` section.
+
+ Note that the SD Card for up-to-speed class c10 has been tested.
+
+Methods
+^^^^^^^
+
+.. method:: SDCard.deinit()
+
+ Deinitialises the SD Card.
+
+::
+
+ import machine
+ import os
+
+ bdev = machine.SDCard(slot=0, width=4, cd="P13_5", cmd="P12_4", clk="P12_5", dat0="P13_0", dat1="P13_1", dat2="P13_2", dat3="P13_3")
+
+ # Define constants
+ TEST_STRING = "This is a test string."
+
+ # Mount or format the SD card with LFS2 filesystem
+ if "VfsLfs2" in dir(os):
+
+ try:
+ vfs = os.VfsLfs2(bdev, progsize=512, readsize=512)
+ os.mount(vfs, "/SDCardLfs2")
+ except OSError:
+ os.VfsLfs2.mkfs(bdev, progsize=512, readsize=512)
+ vfs = os.VfsLfs2(bdev, progsize=512, readsize=512)
+ os.mount(vfs, "/SDCardLfs2")
+
+ with open("/SDCardLfs2/test_sd_lfs2.txt", "w") as f:
+ f.write(TEST_STRING)
+
+ with open("/SDCardLfs2/test_sd_lfs2.txt", "r") as f:
+ read_data = f.read()
+
+ print(read_data)
+
+ # Mount or format the SD card with FAT filesystem
+ if "VfsFat" in dir(os):
+
+ try:
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/SDCardFat")
+ except OSError:
+ os.VfsFat.mkfs(bdev)
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/SDCardFat")
+
+ with open("/SDCardFat/test_sd_fat.txt", "w") as f:
+ f.write(TEST_STRING)
+
+ with open("/SDCardFat/test_sd_fat.txt", "r") as f:
+ read_data = f.read()
+
+ print(read_data)
+
+ bdev.deinit()
+
diff --git a/docs/templates/topindex.html b/docs/templates/topindex.html
index e3bcd7cce14cc..5a44542aad543 100644
--- a/docs/templates/topindex.html
+++ b/docs/templates/topindex.html
@@ -57,6 +57,10 @@ MicroPython documentation
Quick reference for the ESP32
pinout for ESP32-based boards, snippets of useful code, and a tutorial
+
+ Quick reference for the PSoC6
+ general information for PSoC6 based boards, snippets of useful code, and a tutorial
+
Quick reference for the Raspberry Pi RP2xxx
pinout for rp2xxx-based boards, snippets of useful code, and a tutorial
diff --git a/extmod/machine_i2c.c b/extmod/machine_i2c.c
index bddf77529996d..713cef59d9d77 100644
--- a/extmod/machine_i2c.c
+++ b/extmod/machine_i2c.c
@@ -319,6 +319,17 @@ static mp_obj_t machine_i2c_init(size_t n_args, const mp_obj_t *args, mp_map_t *
}
MP_DEFINE_CONST_FUN_OBJ_KW(machine_i2c_init_obj, 1, machine_i2c_init);
+static mp_obj_t machine_i2c_deinit(mp_obj_t self_in) {
+ mp_obj_base_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
+ if (i2c_p->deinit == NULL) {
+ mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
+ }
+ i2c_p->deinit(self);
+ return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_deinit_obj, machine_i2c_deinit);
+
static mp_obj_t machine_i2c_scan(mp_obj_t self_in) {
mp_obj_base_t *self = MP_OBJ_TO_PTR(self_in);
mp_obj_t list = mp_obj_new_list(0, NULL);
@@ -633,6 +644,7 @@ static MP_DEFINE_CONST_FUN_OBJ_KW(machine_i2c_writeto_mem_obj, 1, machine_i2c_wr
static const mp_rom_map_elem_t machine_i2c_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_i2c_init_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_i2c_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_scan), MP_ROM_PTR(&machine_i2c_scan_obj) },
// primitive I2C operations
diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index b07c1d8159c2f..f030e98dfef10 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -1673,6 +1673,10 @@ static MP_DEFINE_CONST_OBJ_TYPE(
// Support functions for memory protection. lwIP has its own memory management
// routines for its internal structures, and since they might be called in
// interrupt handlers, they need some protection.
+
+// These functions should be provided by the operating system.
+// In case of no operating system, the following default ones provided.
+#if NO_SYS
sys_prot_t sys_arch_protect() {
return (sys_prot_t)MICROPY_BEGIN_ATOMIC_SECTION();
}
@@ -1680,6 +1684,7 @@ sys_prot_t sys_arch_protect() {
void sys_arch_unprotect(sys_prot_t state) {
MICROPY_END_ATOMIC_SECTION((mp_uint_t)state);
}
+#endif
/******************************************************************************/
// Polling callbacks for the interfaces connected to lwIP. Right now it calls
diff --git a/extmod/modmachine.h b/extmod/modmachine.h
index 7c16ed302ee2f..2228ca91a529b 100644
--- a/extmod/modmachine.h
+++ b/extmod/modmachine.h
@@ -156,6 +156,7 @@ typedef struct _mp_machine_i2c_p_t {
bool transfer_supports_write1;
#endif
void (*init)(mp_obj_base_t *obj, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+ void (*deinit)(mp_obj_base_t *obj);
int (*start)(mp_obj_base_t *obj);
int (*stop)(mp_obj_base_t *obj);
int (*read)(mp_obj_base_t *obj, uint8_t *dest, size_t len, bool nack);
diff --git a/ports/psoc6/.gitignore b/ports/psoc6/.gitignore
new file mode 100644
index 0000000000000..c903255da311b
--- /dev/null
+++ b/ports/psoc6/.gitignore
@@ -0,0 +1 @@
+/mtb_shared
diff --git a/ports/psoc6/Makefile b/ports/psoc6/Makefile
new file mode 100644
index 0000000000000..652234508a9a4
--- /dev/null
+++ b/ports/psoc6/Makefile
@@ -0,0 +1,319 @@
+BOARD ?=
+
+# Check if the ModusToolbox setup has been initialized
+# If that is the case, get active board
+MTB_LIB_DIR = mtb-libs
+MTB_LIBS_APP_INFO = $(MTB_LIB_DIR)/build/get_app_info.txt
+ifneq ($(wildcard $(MTB_LIBS_APP_INFO)),)
+ ACTIVE_BOARD = $(shell egrep '^ *MTB_TARGET' $(MTB_LIBS_APP_INFO) | sed 's/^.*= *//g' | sed 's/APP_//')
+endif
+
+# Get active board from mtb-lib previous runs
+# The board is set only after make mtb_init
+# has been run.
+ifeq ($(BOARD),)
+ ifeq ($(ACTIVE_BOARD),)
+ $(error ModusToolbox not initialized. Run "make mtb_init BOARD=" to configure the environment. )
+ else
+ BOARD = $(ACTIVE_BOARD)
+ endif
+endif
+
+BOARD_DIR = boards/$(BOARD)
+
+$(info PSoC6 board : $(BOARD))
+
+ifeq ($(wildcard $(BOARD_DIR)/.),)
+ $(error Invalid BOARD specified)
+endif
+
+# Files that are generated and needed before the QSTR build.
+QSTR_GENERATED_HEADERS = build/pins_qstr.h
+# qstr definitions (must come before including py.mk)
+QSTR_DEFS = qstrdefsport.h $(QSTR_GENERATED_HEADERS)
+QSTR_GLOBAL_DEPENDENCIES += $(BOARD_DIR)/mpconfigboard.h $(QSTR_GENERATED_HEADERS)
+
+MICROPY_FROZEN_MANIFEST ?= $(BOARD_DIR)/manifest.py
+FROZEN_MANIFEST ?= $(MICROPY_FROZEN_MANIFEST)
+
+
+ifneq ($(FROZEN_MANIFEST),)
+ CFLAGS += -DMICROPY_QSTR_EXTRA_POOL=mp_qstr_frozen_const_pool
+ CFLAGS += -DMICROPY_MODULE_FROZEN_MPY=1
+ CFLAGS += -DMICROPY_MODULE_FROZEN_STR=1
+endif
+
+
+CROSS_COMPILE ?= arm-none-eabi-
+CONFIG ?= Debug
+
+# include py core make definitions
+include ../../py/mkenv.mk
+include mpconfigport.mk
+include $(BOARD_DIR)/mpconfigboard.mk
+include $(TOP)/py/py.mk
+include $(TOP)/extmod/extmod.mk
+
+
+INC += -I.
+INC += -I$(TOP)
+INC += -I$(BUILD)
+
+ifeq ($(MICROPY_PSOC6_LWIP),1)
+ INC += -Ilwip_inc
+endif
+
+LD = arm-none-eabi-gcc
+CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mcpu=cortex-m4 -msoft-float -fsingle-precision-constant -Wdouble-promotion -Wfloat-conversion -UMICROPY_USE_INTERNAL_PRINTF
+
+# std=c11 instead of std=c99 : provides "static_assert" (not available in c99)
+# -D_XOPEN_SOURCE=700 : makes sure the setenv/unsetenv headers are included
+CFLAGS += $(INC) -Wall -Werror -std=c11 $(CFLAGS_CORTEX_M4) $(COPT) -D_XOPEN_SOURCE=700
+CFLAGS += -Wno-error=double-promotion -Wno-error=overflow -Wno-error=analyzer-null-dereference -Wno-error=unused-local-typedefs -Wno-error=unused-function -Wno-error=maybe-uninitialized
+
+ifeq ($(MICROPY_PSOC6_SSL_MBEDTLS),1)
+ INC += -I$(TOP)/extmod/mbedtls
+ CFLAGS += -DMBEDTLS_CONFIG_FILE=\"mbedtls/mbedtls_config.h\"
+ CFLAGS += -DMICROPY_SSL_MBEDTLS=1
+endif
+
+LDFLAGS += -Wl,--cref -Wl,--gc-sections
+LDFLAGS += -Wl,-Map,$(BUILD)/firmware.map -Wl,--start-group -Wl,--end-group -Wl,--print-memory-usage
+
+
+# Tune for Debugging or Optimization
+ifeq ($(CONFIG), Debug)
+ CFLAGS += -O0 -ggdb
+ MPY_MTB_CONFIG = Debug
+ MICROPY_ROM_TEXT_COMPRESSION ?= 0
+else
+ CFLAGS += -O3 -Os -DNDEBUG
+ CFLAGS += -fdata-sections -ffunction-sections
+ MPY_MTB_CONFIG = Release
+ MICROPY_ROM_TEXT_COMPRESSION ?= 1
+endif
+
+$(info Compiling in $(CONFIG) mode !)
+
+#ToDo: Post adding af functionality, refactor to minimize dependent variables in py script if possible
+GEN_PINS_SRC := $(BUILD)/pins_$(BOARD).c
+HEADER_BUILD := $(BUILD)/genhdr
+GEN_PINS_HDR := $(BUILD)/genhdr/pins.h
+GEN_PINS_QSTR := $(BUILD)/pins_qstr.h
+BOARD_PINS := pins.csv
+BOARD_AF_PINS := pins_af.csv
+
+GENERATED_PINS = $(GEN_PINS_SRC) $(GEN_PINS_HDR) $(GEN_PINS_QSTR)
+
+$(GENERATED_PINS):
+ @echo "Generating $@"
+ $(PYTHON) boards/make-pins-csv.py --gen-pin-for $(PIN_PACKAGE_FILE) --save-pins-csv-at $(BOARD_PINS) --save-pins-af-csv-at $(BOARD_AF_PINS)
+ $(MKDIR) -p $(BUILD)/genhdr
+ $(PYTHON) boards/make-pins.py --hdr $(GEN_PINS_HDR) --qstr $(GEN_PINS_QSTR) > $(GEN_PINS_SRC)
+ rm -rf $(BOARD_PINS) $(BOARD_AF_PINS)
+
+
+# Flags for optional C++ source code
+CXXFLAGS += $(filter-out -std=c99,$(CFLAGS))
+CXXFLAGS += $(CXXFLAGS_MOD)
+
+LDFLAGS += $(LDFLAGS_MOD)
+
+LIBS +=
+
+SHARED_SRC_C += $(addprefix shared/,\
+ readline/readline.c \
+ \
+ runtime/gchelper_native.c \
+ runtime/interrupt_char.c \
+ runtime/pyexec.c \
+ runtime/mpirq.c\
+ runtime/stdout_helpers.c \
+ runtime/sys_stdio_mphal.c \
+ timeutils/timeutils.c \
+ )
+
+ifeq ($(MICROPY_PSOC6_LWIP),1)
+ SHARED_SRC_C += $(addprefix shared/,\
+ netutils/dhcpserver.c \
+ netutils/netutils.c \
+ netutils/trace.c \
+ )
+ CFLAGS += -DMICROPY_PY_LWIP=1
+endif
+
+DRIVERS_SRC_C += $(addprefix drivers/,\
+ bus/softspi.c \
+ )
+
+MOD_SRC_C += \
+ modgc.c \
+ \
+ machine_i2c.c \
+ machine_pin_phy.c \
+ machine_pin.c \
+ machine_rtc.c \
+ machine_spi.c \
+ machine_timer.c \
+ machine_adc.c \
+ machine_adcblock.c \
+ machine_bitstream.c\
+ \
+ modpsoc6.c \
+ psoc6_fatfs.c \
+ psoc6_flash.c
+
+ifeq ($(MICROPY_PY_EXT_FLASH),1)
+ CFLAGS += -DMICROPY_ENABLE_EXT_QSPI_FLASH=1
+ MOD_SRC_C += psoc6_qspi_flash.c
+endif
+
+ifeq ($(MICROPY_PY_SD_CARD),1)
+ CFLAGS += -DMICROPY_ENABLE_SD_CARD=1
+ MOD_SRC_C += machine_sdcard.c
+endif
+
+ifeq ($(MICROPY_PY_NETWORK_IFX_WCM),1)
+CFLAGS += -DMICROPY_PY_NETWORK=1 -DMICROPY_PY_NETWORK_IFX_WCM=1 -Wno-stringop-truncation
+ MOD_SRC_C += network_ifx_wcm.c
+endif
+
+SRC_C = help.c \
+ main.c \
+ mphalport.c \
+ frozen_content.c \
+ pins_$(BOARD).c
+
+SRC_ASM += shared/runtime/gchelper_thumb1.s
+
+SRC_QSTR += $(SHARED_SRC_C) $(MOD_SRC_C)
+
+OBJ += $(PY_O)
+OBJ += $(addprefix $(BUILD)/, $(SHARED_SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(DRIVERS_SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(MOD_SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_ASM:.s=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_CXX:.cpp=.o))
+
+# switch for debug mode, also added to mpconfigport.h
+# TODO: keep the more suitable one, delete the other
+MP_LOGGER_DEBUG ?= 0
+
+ifeq ($(MP_LOGGER_DEBUG), 1)
+ CFLAGS += -DMICROPY_LOGGER_DEBUG=1
+endif
+
+$(BUILD)/firmware.elf: $(OBJ) $(MPY_MTB_LIBRARIES) $(LIBS)
+ $(info )
+ $(info Linking $@ $^ $(LIBS) ...)
+ $(Q) $(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+ $(info Linking $@ done.)
+ $(Q) $(SIZE) $@ -A
+ $(info )
+
+
+$(BUILD)/firmware.hex: $(BUILD)/firmware.elf
+ $(Q) $(OBJCOPY) -O ihex $^ $@
+
+
+# include adapter makefile
+include mtb-libs/makefile_mtb.mk
+
+MPY_CROSS_FLAGS += -march=armv7m
+
+build: mtb_get_build_flags $(GENERATED_PINS) $(BUILD)/firmware.hex
+
+all: build
+
+clean: mtb_clean
+
+rebuild: clean mtb_clean all
+
+TESTS ?=-d psoc6
+DEV0 ?= /dev/ttyACM0
+DEV1 ?= /dev/ttyACM1
+
+test:
+ @:
+ $(info )
+ $(info Running PSoC6 tests)
+ $(Q) cd ../../tests ; ./run-tests.py --target psoc6 --device $(DEV0) $(TESTS)
+
+
+MULTI_TESTS ?= $(shell cd ../../tests; find ./psoc6/multi/ -type f -name "*.py")
+
+test_multi:
+ @:
+ $(info )
+ $(info Running PSoC6 multi tests)
+
+ $(Q) cd ../../tests ; ./run-multitests.py -i pyb:$(DEV0) -i pyb:$(DEV1) $(MULTI_TESTS)
+
+help:
+ @:
+ $(info )
+ $(info ----------)
+ $(info Basic flow)
+ $(info ----------)
+ $(info )
+ $(info Prior working on a specific board, it is required to initialise ONCE the)
+ $(info ModusToolbox setup and retrieve all necessary assets for the specified)
+ $(info board:)
+ $(info )
+ $(info $$ make mtb_init BOARD=)
+ $(info )
+ $(info Then repeatedly build the firmware:)
+ $(info )
+ $(info $$ make )
+ $(info )
+ $(info and flash the firmware on the device with:)
+ $(info )
+ $(info $$ make program)
+ $(info )
+ $(info 'make program' will also build the .hex file if any changes occurred in the code.)
+ $(info )
+ $(info -------------)
+ $(info Build targets)
+ $(info -------------)
+ $(info )
+ $(info The default 'make' target is 'build' when called without arguments.)
+ $(info - build Compile the MicroPython program binary file. )
+ $(info - clean Remove the '/build' folders with all object files and intermediate build support files.)
+ $(info - rebuild Clean before build.)
+ $(info )
+ $(info ---------------)
+ $(info Program targets)
+ $(info ---------------)
+ $(info )
+ $(info - program Flash the board device with the built micropython firmware. )
+ $(info - program_multi Flash multiple board deviced. )
+ $(info Options: )
+ $(info - EXT_HEX_FILE An external .hex file can be provided to the program targets, instead of building from the sources.)
+ $(info )
+ $(info ------------)
+ $(info Test targets)
+ $(info ------------)
+ $(info )
+ $(info - test Run the on-target test in tests/psoc6 folder. Uses /dev/ttyACM0.)
+ $(info .. Optionally, pass TESTS variable for change the tests set. )
+ $(info - test_multi Run multi-instance tests on-target test in tests/psoc6/multi folder.)
+ $(info .. Uses /dev/ttyACM0 and /dev/ttyACM1.)
+ $(info .. Optionally, pass MULTI_TESTS variable for change the tests set. )
+ $(info )
+ $(info --------------------)
+ $(info ModusToolbox targets)
+ $(info --------------------)
+ $(info )
+ $(info - mtb_init BOARD= Add the board support package required firmware assets, set the bsp )
+ $(info .. as active in the ModusToolbox project, and retrieves all required additional )
+ $(info .. middleware assets for MicroPython. )
+ $(info - mtb_deinit Clean all ModusToolbox shared and board support package dependencies assets.)
+ $(info - mtb_add_bsp Add a board support package. Only the ones integrated in MicroPython are supported. )
+ $(info - mtb_set_bsp Set the board as active in the ModusToolbox project. )
+
+
+.PHONY: build test test_multi program_multi help
+
+# include py core make definitions
+include $(TOP)/py/mkrules.mk
\ No newline at end of file
diff --git a/ports/psoc6/README.md b/ports/psoc6/README.md
new file mode 100644
index 0000000000000..bd8bfe06fff95
--- /dev/null
+++ b/ports/psoc6/README.md
@@ -0,0 +1,48 @@
+# PSoC6 port
+
+This port is intended to run on Infineon PSoC™ 6 microcontrollers.
+
+## Pre-requisites
+
+The following port is using Infineon ModusToolbox™ to resolve the specific PSoC™ board resources and building flags. Before working with micropython:
+
+1. Install [ModusToolbox](https://www.infineon.com/cms/en/design-support/tools/sdk/modustoolbox-software/). Minimum version required is 3.0.
+
+2. Run the following script from MicroPython repository root to add the required tools to the system PATH, and install the udev rules:
+
+ source tools/psoc6/dev-setup.sh && toolchain_setup
+
+If the ModusToolbox™ has not been installed in the default path (`~/ModusToolbox`), add the path as positional argument of the `toolchain_setup` function:
+
+ source tools/psoc6/dev-setup.sh && toolchain_setup [mtb_path]
+
+## Building and running Linux version
+
+As we are working on the ports-psoc6-main branch (for now), first checkout that branch after cloning this repo:
+
+ git checkout --track origin/ports-psoc6-main
+
+Then initialize the ModusToolbox™ environment:
+
+ make mtb_init BOARD=
+
+Retrieve submodules:
+
+ make submodules
+
+Build the firmware:
+
+ make
+
+To build and program the device:
+
+ make program
+
+Find more information about the available makefile targets:
+
+ make help
+
+
+# Run micropython
+
+Use any serial terminal (putty, minicom..) and establish a session with your device with 115200 bauds and 8-N-1 configuration.
diff --git a/ports/psoc6/boards/CY8CKIT-062S2-AI/manifest.py b/ports/psoc6/boards/CY8CKIT-062S2-AI/manifest.py
new file mode 100644
index 0000000000000..3fc35a0139a34
--- /dev/null
+++ b/ports/psoc6/boards/CY8CKIT-062S2-AI/manifest.py
@@ -0,0 +1,3 @@
+freeze("$(PORT_DIR)/freeze")
+include("$(MPY_DIR)/extmod/asyncio")
+require("bundle-networking")
diff --git a/ports/psoc6/boards/CY8CKIT-062S2-AI/mpconfigboard.h b/ports/psoc6/boards/CY8CKIT-062S2-AI/mpconfigboard.h
new file mode 100644
index 0000000000000..13a05b64eadbf
--- /dev/null
+++ b/ports/psoc6/boards/CY8CKIT-062S2-AI/mpconfigboard.h
@@ -0,0 +1,61 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Board and hardware specific configuration
+#define MICROPY_HW_MCU_NAME "PSoC62"
+#define MICROPY_HW_BOARD_NAME "CY8CKIT-062S2-AI"
+
+#define MICROPY_PY_NETWORK_HOSTNAME_DEFAULT "CY8C-062S2-AI"
+
+#define MICROPY_GC_HEAP_SIZE (256 * 1024) // 256 KB
+
+#define MICROPY_PY_HASHLIB (1)
+#define MICROPY_PY_HASHLIB_MD5 (1)
+#define MICROPY_PY_HASHLIB_SHA1 (1)
+#define MICROPY_PY_HASHLIB_SHA256 (1)
+
+#define MICROPY_PY_SD_CARD (1)
+#if (MICROPY_PY_SD_CARD)
+#define MAX_SDHC_SLOT (1)
+#endif
+
+// Flash type enablement for board
+#define MICROPY_PY_EXT_FLASH (1)
+#if (MICROPY_PY_EXT_FLASH)
+#define EXT_FLASH_BASE (0x00) /** 0x00 */
+#define EXT_FLASH_SIZE (0x4000000) /** 64MB */
+#define EXT_FLASH_SECTOR_SIZE (0x40000) /** 256KB*/
+#define EXT_FLASH_BLOCK_SIZE_BYTES (EXT_FLASH_SECTOR_SIZE)
+#define EXT_FLASH_PAGE_SIZE (0x200) /** 512 bytes*/
+#endif
+
+// Board specific configurations
+#define MAX_UART 6
+#define MAX_TIMER 32
+#define MAX_SPI 6
+#define MAX_I2C 5
+#define MAX_PWM_OBJS 32
+#define MICROPY_HW_MAX_I2S 1
diff --git a/ports/psoc6/boards/CY8CKIT-062S2-AI/mpconfigboard.mk b/ports/psoc6/boards/CY8CKIT-062S2-AI/mpconfigboard.mk
new file mode 100644
index 0000000000000..1442a799c8aee
--- /dev/null
+++ b/ports/psoc6/boards/CY8CKIT-062S2-AI/mpconfigboard.mk
@@ -0,0 +1,15 @@
+FROZEN_MANIFEST ?= boards/manifest.py
+MICROPY_PY_NETWORK_IFX_WCM = 1
+MICROPY_PY_NETWORK = 1
+MICROPY_PSOC6_LWIP = 1
+MICROPY_PY_SSL = 1
+MICROPY_PSOC6_SSL_MBEDTLS = 1
+MICROPY_PY_EXT_FLASH = 1
+MICROPY_PY_SD_CARD = 1
+BOARD_VERSION=release-v4.3.0
+
+# Variables to support make-pins
+PIN_PACKAGE_FILE = cyhal_psoc6_02_124_bga.h
+
+# Flasher configuration
+OPENOCD_TARGET_CFG=psoc6_2m.cfg
\ No newline at end of file
diff --git a/ports/psoc6/boards/CY8CPROTO-062-4343W/manifest.py b/ports/psoc6/boards/CY8CPROTO-062-4343W/manifest.py
new file mode 100644
index 0000000000000..3fc35a0139a34
--- /dev/null
+++ b/ports/psoc6/boards/CY8CPROTO-062-4343W/manifest.py
@@ -0,0 +1,3 @@
+freeze("$(PORT_DIR)/freeze")
+include("$(MPY_DIR)/extmod/asyncio")
+require("bundle-networking")
diff --git a/ports/psoc6/boards/CY8CPROTO-062-4343W/mpconfigboard.h b/ports/psoc6/boards/CY8CPROTO-062-4343W/mpconfigboard.h
new file mode 100644
index 0000000000000..20e6eb7219e6a
--- /dev/null
+++ b/ports/psoc6/boards/CY8CPROTO-062-4343W/mpconfigboard.h
@@ -0,0 +1,63 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Board and hardware specific configuration
+#define MICROPY_HW_MCU_NAME "PSoC62"
+#define MICROPY_HW_BOARD_NAME "CY8CPROTO-062-4343W"
+
+#define MICROPY_PY_NETWORK_HOSTNAME_DEFAULT "CY8C-062-4343W"
+
+#define MICROPY_GC_HEAP_SIZE (256 * 1024) // 256 KB
+
+#define MICROPY_PY_HASHLIB (1)
+#define MICROPY_PY_HASHLIB_MD5 (1)
+#define MICROPY_PY_HASHLIB_SHA1 (1)
+#define MICROPY_PY_HASHLIB_SHA256 (1)
+
+#define MICROPY_PY_MACHINE_SPI_SLAVE (1)
+
+#define MICROPY_PY_SD_CARD (1)
+#if (MICROPY_PY_SD_CARD)
+#define MAX_SDHC_SLOT (2)
+#endif
+
+// Flash type enablement for board
+#define MICROPY_PY_EXT_FLASH (1)
+#if (MICROPY_PY_EXT_FLASH)
+#define EXT_FLASH_BASE (0x00) /** 0x00 */
+#define EXT_FLASH_SIZE (0x4000000) /** 64MB */
+#define EXT_FLASH_SECTOR_SIZE (0x40000) /** 256KB*/
+#define EXT_FLASH_BLOCK_SIZE_BYTES (EXT_FLASH_SECTOR_SIZE)
+#define EXT_FLASH_PAGE_SIZE (0x200) /** 512 bytes*/
+#endif
+
+// Board specific configurations
+#define MAX_UART 10
+#define MAX_TIMER 32
+#define MAX_SPI 7
+#define MAX_I2C 9
+#define MAX_PWM_OBJS 32
+#define MICROPY_HW_MAX_I2S 2
diff --git a/ports/psoc6/boards/CY8CPROTO-062-4343W/mpconfigboard.mk b/ports/psoc6/boards/CY8CPROTO-062-4343W/mpconfigboard.mk
new file mode 100644
index 0000000000000..a49e463ab5526
--- /dev/null
+++ b/ports/psoc6/boards/CY8CPROTO-062-4343W/mpconfigboard.mk
@@ -0,0 +1,16 @@
+FROZEN_MANIFEST ?= boards/manifest.py
+MICROPY_PY_NETWORK_IFX_WCM = 1
+MICROPY_PY_NETWORK = 1
+MICROPY_PSOC6_LWIP = 1
+MICROPY_PY_SSL = 1
+MICROPY_PSOC6_SSL_MBEDTLS = 1
+MICROPY_PY_EXT_FLASH = 1
+MICROPY_PY_SD_CARD = 1
+MICROPY_VFS_FAT=1
+BOARD_VERSION=release-v4.0.0
+
+# Variables to support make-pins
+PIN_PACKAGE_FILE = cyhal_psoc6_02_124_bga.h
+
+# Flasher configuration
+OPENOCD_TARGET_CFG=psoc6_2m.cfg
\ No newline at end of file
diff --git a/ports/psoc6/boards/CY8CPROTO-063-BLE/manifest.py b/ports/psoc6/boards/CY8CPROTO-063-BLE/manifest.py
new file mode 100644
index 0000000000000..3fc35a0139a34
--- /dev/null
+++ b/ports/psoc6/boards/CY8CPROTO-063-BLE/manifest.py
@@ -0,0 +1,3 @@
+freeze("$(PORT_DIR)/freeze")
+include("$(MPY_DIR)/extmod/asyncio")
+require("bundle-networking")
diff --git a/ports/psoc6/boards/CY8CPROTO-063-BLE/mpconfigboard.h b/ports/psoc6/boards/CY8CPROTO-063-BLE/mpconfigboard.h
new file mode 100644
index 0000000000000..0835c7faf20fe
--- /dev/null
+++ b/ports/psoc6/boards/CY8CPROTO-063-BLE/mpconfigboard.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Board and hardware specific configuration
+#define MICROPY_HW_MCU_NAME "PSoC63"
+#define MICROPY_HW_BOARD_NAME "CY8CPROTO-063-BLE"
+
+#define MICROPY_PY_NETWORK_HOSTNAME_DEFAULT "CY8C-063-BLE"
+
+#define MICROPY_GC_HEAP_SIZE (64 * 1024) // 64 KB
+
+#define MICROPY_PY_MACHINE_SPI_SLAVE (1)
+
+// Board specific configurations
+#define MAX_UART 3
+#define MAX_TIMER 32
+#define MAX_SPI 2
+#define MAX_I2C 3
+#define MAX_PWM_OBJS 28
+#define MICROPY_HW_MAX_I2S 1
diff --git a/ports/psoc6/boards/CY8CPROTO-063-BLE/mpconfigboard.mk b/ports/psoc6/boards/CY8CPROTO-063-BLE/mpconfigboard.mk
new file mode 100644
index 0000000000000..b341117a575bc
--- /dev/null
+++ b/ports/psoc6/boards/CY8CPROTO-063-BLE/mpconfigboard.mk
@@ -0,0 +1,10 @@
+FROZEN_MANIFEST ?= boards/manifest.py
+MICROPY_PY_SSL = 0
+MICROPY_PSOC6_SSL_MBEDTLS = 0
+BOARD_VERSION=release-v4.2.0
+
+# Variables to support make-pins
+PIN_PACKAGE_FILE = cyhal_psoc6_01_116_bga_ble.h
+
+# Flasher configuration
+OPENOCD_TARGET_CFG=psoc6.cfg
\ No newline at end of file
diff --git a/ports/psoc6/boards/make-pins-csv.py b/ports/psoc6/boards/make-pins-csv.py
new file mode 100644
index 0000000000000..7f4d720eaf6ae
--- /dev/null
+++ b/ports/psoc6/boards/make-pins-csv.py
@@ -0,0 +1,147 @@
+from __future__ import print_function
+from itertools import islice
+import argparse
+import sys
+import csv
+import re
+import os
+
+
+def get_pin_addr_helper(pin_def):
+ pattern = r"CYHAL_PORT_(\d+),\s*(\d+)"
+ match = re.search(pattern, pin_def)
+ port_number = match.group(1)
+ pin_number = match.group(2)
+ return (int(port_number) << 3) + int(pin_number)
+
+
+def get_pin_package_path(filename):
+ root_dir = "./mtb_shared/mtb-hal-cat1"
+ mid_dir = "COMPONENT_CAT1A/include/pin_packages"
+ for dirpath, dirnames, filenames in os.walk(root_dir):
+ for dirname in dirnames:
+ if dirname.startswith("release-"):
+ release_version = dirname
+ file_path = os.path.join(root_dir, release_version, mid_dir, filename)
+ if os.path.isfile(file_path):
+ return file_path
+ return None
+
+
+def generate_pins_csv(pin_package_filename, pins_csv_filename):
+ file_path = get_pin_package_path(pin_package_filename)
+
+ if file_path is None:
+ sys.exit(1)
+
+ # Read the header file
+ with open(file_path, "r") as file:
+ content = file.read()
+
+ # Find the starting and ending points of the enum declaration
+ enum_start = content.find("typedef enum {")
+ enum_end = content.find("}")
+
+ if enum_start != -1 and enum_end != -1:
+ enum_content = content[enum_start:enum_end]
+
+ # Extract enum values using regex
+ enum_values = re.findall(r"\b(\w+)\s*=", enum_content)
+ # Write enum values to a CSV file
+ with open("./" + pins_csv_filename, "w", newline="") as csv_file:
+ csv_writer = csv.writer(csv_file)
+ csv_writer.writerows(
+ [
+ [value, value]
+ for value in enum_values
+ if value.startswith("P") or value.startswith("N")
+ ]
+ )
+ print("// pins.csv generated successfully")
+ else:
+ print("// Error: pins.csv generation failed")
+
+
+def generate_af_pins_csv(pin_package_filename, pins_af_csv_filename):
+ file_path = get_pin_package_path(pin_package_filename)
+
+ if file_path is None:
+ sys.exit(1)
+ # Read the header file
+ with open(file_path, "r") as file:
+ content = file.read()
+
+ # Find the starting and ending points of the enum declaration
+ enum_start = content.find("typedef enum {")
+ enum_end = content.find("}")
+
+ if enum_start != -1 and enum_end != -1:
+ enum_content = content[enum_start:enum_end]
+
+ # Extract enum values using regex
+ pin_name = re.findall(r"\b(?!NC\b)(\w+)\s*=", enum_content)
+ # pin_name = re.findall(r"\b(\w+)\s*=", enum_content)
+ pin_def = re.findall(r"=\s*(.*?\))", enum_content)
+ # pin_def.insert(0, "255")
+ # print(pin_def)
+
+ # Write enum values to a CSV file
+ with open("./" + pins_af_csv_filename, "w", newline="") as csv_file:
+ NC_pin = ["NC", 255, "CYHAL_GET_GPIO(CYHAL_PORT_31, 7)"] # non-existent port
+ csv_writer = csv.writer(csv_file)
+ csv_writer.writerow(NC_pin)
+ for pname, pdef in zip(pin_name, pin_def):
+ # for pname, pdef in zip(islice(pin_name, 1, None), pin_def):
+ # if pin_name[pname].startswith('P'):
+ val = get_pin_addr_helper(pdef)
+ csv_writer.writerow([pname, val, pdef.strip('"')])
+
+ print("// pins_af.csv generated successfully")
+ else:
+ print("Error: pins_af.csv generation failed")
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ prog="make-pins-csv.py",
+ usage="%(prog)s [options] [command]",
+ description="Generate intermediate board specific pin csv files to be used by make-pins script",
+ )
+
+ parser.add_argument(
+ "-g",
+ "--gen-pin-for",
+ dest="pin_package_filename",
+ help="Specifies the pin package file from mtb assets to generate pins.csv",
+ )
+
+ parser.add_argument(
+ "-p",
+ "--save-pins-csv-at",
+ dest="pins_csv",
+ help="Specifies name of generated pins csv file",
+ )
+
+ parser.add_argument(
+ "-gaf",
+ "--save-pins-af-csv-at",
+ dest="pins_af_csv",
+ help="Specifies name of generated alternate functions pins csv file",
+ )
+
+ args = parser.parse_args(sys.argv[1:])
+
+ if args.pin_package_filename and args.pins_csv:
+ print("// Generating pins csv file")
+ print("// - --gen-pin-for {:s}".format(args.pin_package_filename))
+ print("// - --save-pins-csv-at {:s}".format(args.pins_csv))
+ generate_pins_csv(args.pin_package_filename, args.pins_csv)
+
+ if args.pin_package_filename and args.pins_af_csv:
+ print("// Generating alternate functions pins csv file")
+ print("// - --save-pins-csv-at {:s}".format(args.pins_af_csv))
+ generate_af_pins_csv(args.pin_package_filename, args.pins_af_csv)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/ports/psoc6/boards/make-pins.py b/ports/psoc6/boards/make-pins.py
new file mode 100755
index 0000000000000..c6863948bf9b2
--- /dev/null
+++ b/ports/psoc6/boards/make-pins.py
@@ -0,0 +1,211 @@
+from __future__ import print_function
+import argparse
+import sys
+import csv
+import re
+import os
+
+prefix_content = '#include \n \
+#include "py/obj.h" \n \
+#include "py/mphal.h" \n \
+#include "machine_pin_phy.h"\n '
+
+
+class NamedPin(object):
+ def __init__(self, name, pin):
+ self._name = name
+ self._pin = pin
+
+ def pin(self):
+ return self._pin
+
+ def name(self):
+ return self._name
+
+
+class Pin(object):
+ def __init__(self, name, pin_addr, pin_exp):
+ self._name = name
+ self._pin_addr = pin_addr
+ self._pin_exp = pin_exp
+ self._board_pin = False
+
+ def cpu_pin_name(self):
+ return self._name
+
+ def is_board_pin(self):
+ return self._board_pin
+
+ def set_is_board_pin(self):
+ self._board_pin = True
+
+ def set_board_index(self, index):
+ self.board_index = index
+
+ def print(self):
+ """print(
+ "const machine_pin_phy_obj_t pin_{:s}_obj = PIN({:s}, {:s});".format(
+ self._name,
+ self._name,
+ self._pin_addr,
+ )
+ )"""
+
+ def print_header(self, num_pins, hdr_file):
+ hdr_file.write("#define MAX_IO_PINS {:d} \n".format(num_pins))
+
+ def qstr_list(self):
+ return [self._name]
+
+ def print_const_table_entry(self):
+ print('{{{:s}, "{:s}"}},'.format(self._pin_exp, self._name))
+
+
+class Pins(object):
+ def __init__(self):
+ self.cpu_pins = [] # list of NamedPin objects
+ self.board_pins = [] # list of NamedPin objects
+ self.board_pin_csv_path = ""
+ self.num_cpu_pins = 0
+
+ def update_num_cpu_pins(self):
+ for named_pin in self.cpu_pins:
+ pin = named_pin.pin()
+ if pin.is_board_pin():
+ pin.set_board_index(self.num_cpu_pins)
+ self.num_cpu_pins += 1
+
+ def get_num_cpu_pins(self):
+ return self.num_cpu_pins
+
+ def find_pin(self, cpu_pin_name):
+ for named_pin in self.cpu_pins:
+ pin = named_pin.pin()
+ if pin.cpu_pin_name() == cpu_pin_name:
+ return pin
+
+ def print_const_table(self):
+ print("")
+ print(prefix_content)
+ print("const uint8_t machine_pin_num_of_cpu_pins = {:d};".format(self.get_num_cpu_pins()))
+ print("")
+ print(
+ "machine_pin_phy_obj_t machine_pin_phy_obj[{:d}] = {{".format(self.get_num_cpu_pins())
+ )
+ for named_pin in self.cpu_pins:
+ pin = named_pin.pin()
+ if pin.is_board_pin():
+ pin.print_const_table_entry()
+ print("};")
+
+ # ToDo: Complete for alternate functions
+ def parse_af_file(self):
+ with open("./pins_af.csv", "r") as csvfile:
+ rows = csv.reader(csvfile)
+ for row in rows:
+ try:
+ pin_name = row[0]
+ pin_addr = row[1]
+ pin_exp = row[2].strip('"')
+ except:
+ continue
+ pin = Pin(pin_name, pin_addr, pin_exp)
+ self.cpu_pins.append(NamedPin(pin_name, pin))
+
+ def parse_board_file(self):
+ # Assuming the same path has required board files
+ with open("./pins.csv", "r") as csvfile:
+ rows = csv.reader(csvfile)
+ for row in rows:
+ try:
+ board_pin_name = row[0]
+ cpu_pin_name = row[1]
+ except:
+ continue
+ pin = self.find_pin(cpu_pin_name)
+ if pin:
+ pin.set_is_board_pin()
+ self.board_pins.append(NamedPin(board_pin_name, pin))
+
+ def print_named(self, label, named_pins):
+ print(
+ "static const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label)
+ )
+ num_cpu_pins = 0
+ for named_pin in named_pins:
+ pin = named_pin.pin()
+ if pin.is_board_pin():
+ print(
+ " {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&machine_pin_phy_obj[{:d}]) }},".format(
+ named_pin.name(), num_cpu_pins
+ )
+ )
+ num_cpu_pins += 1
+ print("};")
+ print(
+ "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
+ label, label
+ )
+ )
+
+ def print(self):
+ self.print_named("cpu", self.cpu_pins)
+ print("")
+
+ def print_header(self, hdr_filename):
+ with open(hdr_filename, "wt") as hdr_file:
+ hdr_file.write("#define MAX_IO_PINS {:d} \n".format(self.get_num_cpu_pins()))
+
+ def print_qstr(self, qstr_filename):
+ with open(qstr_filename, "wt") as qstr_file:
+ qstr_set = set([])
+ for named_pin in self.cpu_pins:
+ pin = named_pin.pin()
+ if pin.is_board_pin():
+ qstr_set |= set(pin.qstr_list())
+ qstr_set |= set([named_pin.name()])
+ for named_pin in self.board_pins:
+ qstr_set |= set([named_pin.name()])
+ for qstr in sorted(qstr_set):
+ # cond_var = None
+ print("Q({})".format(qstr), file=qstr_file)
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ prog="make-pins.py",
+ usage="%(prog)s [options] [command]",
+ description="Generate board specific pin file",
+ )
+
+ parser.add_argument(
+ "-q",
+ "--qstr",
+ dest="qstr_filename",
+ help="Specifies name of generated qstr header file",
+ )
+
+ parser.add_argument(
+ "-r",
+ "--hdr",
+ dest="hdr_filename",
+ help="Specifies name of generated pin header file",
+ )
+
+ args = parser.parse_args(sys.argv[1:])
+
+ pins = Pins()
+
+ pins.parse_af_file()
+
+ if args.hdr_filename and args.qstr_filename:
+ pins.parse_board_file()
+ pins.update_num_cpu_pins()
+ pins.print_const_table()
+ pins.print()
+ pins.print_header(args.hdr_filename)
+ pins.print_qstr(args.qstr_filename)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/ports/psoc6/freeze/vfs_fat.py b/ports/psoc6/freeze/vfs_fat.py
new file mode 100644
index 0000000000000..f00bf1f7d5525
--- /dev/null
+++ b/ports/psoc6/freeze/vfs_fat.py
@@ -0,0 +1,24 @@
+import os
+import machine, psoc6
+
+
+# Try to mount the filesystem, and format the flash if it doesn't exist.
+# Create block device instance from external or internal flash, whichever is enabled
+bdev = psoc6.QSPI_Flash() if "QSPI_Flash" in dir(psoc6) else psoc6.Flash()
+
+try:
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/")
+except:
+ os.VfsFat.mkfs(bdev)
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/")
+
+if "QSPI_Flash" in dir(psoc6):
+ location = "external QSPI"
+else:
+ location = "internal"
+
+print(f"Virtual File System: mounted at '/' with FAT format in {location} flash.\n")
+
+del machine, os, psoc6, bdev, vfs
diff --git a/ports/psoc6/freeze/vfs_fat_qspi_flash.py b/ports/psoc6/freeze/vfs_fat_qspi_flash.py
new file mode 100644
index 0000000000000..32ebbdc0f7592
--- /dev/null
+++ b/ports/psoc6/freeze/vfs_fat_qspi_flash.py
@@ -0,0 +1,18 @@
+import os
+import machine, psoc6
+
+
+# Try to mount the filesystem, and format the flash if it doesn't exist.
+bdev = psoc6.QSPI_Flash()
+
+try:
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/flash")
+except:
+ os.VfsFat.mkfs(bdev)
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/flash")
+
+print("Virtual File System: mounted at '/flash' with FAT format in external QSPI flash.\n")
+
+del machine, os, psoc6, bdev, vfs
diff --git a/ports/psoc6/freeze/vfs_lfs2.py b/ports/psoc6/freeze/vfs_lfs2.py
new file mode 100644
index 0000000000000..e7689457a18bf
--- /dev/null
+++ b/ports/psoc6/freeze/vfs_lfs2.py
@@ -0,0 +1,32 @@
+import os
+import machine, psoc6
+
+
+# Try to mount the filesystem, and format the flash if it doesn't exist.
+# TODO: Check "Note: the internal flash requires the programming size to be aligned to 256 bytes." and progSize parameter below !!
+
+# Create block device instance from external or internal flash, whichever is enabled
+bdev = psoc6.QSPI_Flash() if "QSPI_Flash" in dir(psoc6) else psoc6.Flash()
+
+# sector size 4 KB for external flash
+# sector size 512 B for internal flash
+read_size = 0x1000 if "QSPI_Flash" in dir(psoc6) else 0x200
+# page size 512 B for both flashes
+write_size = 0x200
+
+try:
+ vfs = os.VfsLfs2(bdev, progsize=write_size, readsize=read_size)
+ os.mount(vfs, "/")
+except:
+ os.VfsLfs2.mkfs(bdev, progsize=write_size, readsize=read_size)
+ vfs = os.VfsLfs2(bdev, progsize=write_size, readsize=read_size)
+ os.mount(vfs, "/")
+
+if "QSPI_Flash" in dir(psoc6):
+ location = "external QSPI"
+else:
+ location = "internal"
+
+print(f"Virtual File System: mounted at '/' with LFS2 format in {location} flash.\n")
+
+del machine, os, psoc6, bdev, vfs, read_size, write_size
diff --git a/ports/psoc6/freeze/vfs_lfs2_qspi_flash.py b/ports/psoc6/freeze/vfs_lfs2_qspi_flash.py
new file mode 100644
index 0000000000000..a239ba15d83f4
--- /dev/null
+++ b/ports/psoc6/freeze/vfs_lfs2_qspi_flash.py
@@ -0,0 +1,17 @@
+import os
+import machine, psoc6
+
+bdev = psoc6.QSPI_Flash()
+read_size = 0x1000 # sector size*
+write_size = 0x200 # page size
+try:
+ vfs = os.VfsLfs2(bdev, progsize=read_size, readsize=write_size)
+ os.mount(vfs, "/flash")
+except:
+ os.VfsLfs2.mkfs(bdev, progsize=read_size, readsize=write_size)
+ vfs = os.VfsLfs2(bdev, progsize=read_size, readsize=write_size)
+ os.mount(vfs, "/flash")
+
+print("Virtual File System: mounted at '/flash' with LFS2 format in external QSPI flash.\n")
+
+del machine, os, psoc6, bdev, vfs, read_size, write_size
diff --git a/ports/psoc6/help.c b/ports/psoc6/help.c
new file mode 100644
index 0000000000000..dc76877ee0541
--- /dev/null
+++ b/ports/psoc6/help.c
@@ -0,0 +1,42 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+const char psoc6_help_text[] =
+ "Welcome to MicroPython!\n"
+ "\n"
+ "For online help please visit https://micropython.org/help/.\n"
+ "\n"
+ "For access to the hardware use the 'machine' module.\n"
+ "PSoC6 specific commands are in the 'psoc6' module.\n"
+ "\n"
+ "Useful control commands:\n"
+ " CTRL-C -- interrupt a running program\n"
+ " CTRL-D -- on a blank line, do a soft reset of the board\n"
+ " CTRL-E -- on a blank line, enter paste mode\n"
+ "\n"
+ "For further help on a specific object, type help(obj)\n"
+ "For a list of available modules, type help('modules')\n"
+;
diff --git a/ports/psoc6/lwip_inc/lwipopts.h b/ports/psoc6/lwip_inc/lwipopts.h
new file mode 100644
index 0000000000000..7a51407e8f019
--- /dev/null
+++ b/ports/psoc6/lwip_inc/lwipopts.h
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Simon Goldschmidt
+ *
+ */
+#pragma once
+
+#include
+
+#define MEM_ALIGNMENT (4)
+
+#define LWIP_RAW (1)
+
+//
+// Enable IPV4 networking
+//
+#define LWIP_IPV4 (1)
+
+/**
+ * LWIP_AUTOIP==1: Enable AUTOIP module.
+ */
+// #define LWIP_AUTOIP (1)
+
+/**
+ * LWIP_DHCP_AUTOIP_COOP==1: Allow DHCP and AUTOIP to be both enabled on
+ * the same interface at the same time.
+ */
+// #define LWIP_DHCP_AUTOIP_COOP (1)
+
+//
+// Enable IPV6 networking
+//
+#define LWIP_IPV6 (0)
+
+#define ETHARP_SUPPORT_STATIC_ENTRIES (1)
+
+//
+// Enable IPV4 networking
+//
+#define LWIP_ICMP (1)
+#define LWIP_TCP (1)
+#define LWIP_UDP (1)
+#define LWIP_IGMP (1)
+
+//
+// Use malloc to allocate any memory blocks instead of the
+// malloc that is part of LWIP
+//
+#define MEM_LIBC_MALLOC (1)
+
+//
+// The standard library does not provide errno, use the one
+// from LWIP.
+//
+#define LWIP_PROVIDE_ERRNO (1)
+
+#if defined(__GNUC__) && !defined(__ARMCC_VERSION)
+//
+// Use the timeval from the GCC library, not the one
+// from LWIP
+//
+#define LWIP_TIMEVAL_PRIVATE (0)
+#endif
+
+//
+// Make sure DHCP is part of the stack
+//
+#define LWIP_DHCP (1)
+
+//
+// Enable LwIP send timeout
+//
+#define LWIP_SO_SNDTIMEO (1)
+
+//
+// Enable LwIP receive timeout
+//
+#define LWIP_SO_RCVTIMEO (1)
+
+//
+// Enable SO_REUSEADDR option
+//
+#define SO_REUSE (1)
+
+//
+// Enable TCP Keep-alive
+//
+#define LWIP_TCP_KEEPALIVE (1)
+
+//
+// The amount of space to leave before the packet when allocating a pbuf. Needs to
+// be enough for the link layer data and the WHD header
+//
+#define PBUF_LINK_HLEN (WHD_PHYSICAL_HEADER)
+
+//
+// TCP Maximum segment size
+//
+#define TCP_MSS (WHD_PAYLOAD_MTU)
+
+#define LWIP_CHECKSUM_CTRL_PER_NETIF 1
+#define CHECKSUM_GEN_IP 1
+#define CHECKSUM_GEN_UDP 1
+#define CHECKSUM_GEN_TCP 1
+#define CHECKSUM_GEN_ICMP 1
+#define CHECKSUM_GEN_ICMP6 1
+#define CHECKSUM_CHECK_IP 1
+#define CHECKSUM_CHECK_UDP 1
+#define CHECKSUM_CHECK_TCP 1
+#define CHECKSUM_CHECK_ICMP 1
+#define CHECKSUM_CHECK_ICMP6 1
+#define LWIP_CHECKSUM_ON_COPY 1
+
+//
+// Enable the thread safe NETCONN interface layer
+//
+#define LWIP_NETCONN (1)
+
+/**
+ * TCP_SND_BUF: TCP sender buffer space (bytes).
+ * To achieve good performance, this should be at least 2 * TCP_MSS.
+ */
+#define TCP_SND_BUF (4 * TCP_MSS)
+
+/**
+ * TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least
+ * as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work.
+ */
+#define TCP_SND_QUEUELEN ((6 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
+
+
+//
+// Taken from WICED to speed things up
+//
+#define DHCP_DOES_ARP_CHECK (0)
+
+//
+// Light weight protection for things that may be clobbered by interrupts
+//
+#define SYS_LIGHTWEIGHT_PROT (1)
+#define LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT (1)
+
+#define LWIP_SO_RCVBUF (128)
+
+#define LWIP_SOCKET (1)
+#define LWIP_NETCONN (1)
+#define DEFAULT_TCP_RECVMBOX_SIZE (12)
+#define TCPIP_MBOX_SIZE (16)
+#define TCPIP_THREAD_STACKSIZE (4 * 1024)
+#define TCPIP_THREAD_PRIO (4)
+#define DEFAULT_RAW_RECVMBOX_SIZE (12)
+#define DEFAULT_UDP_RECVMBOX_SIZE (12)
+#define DEFAULT_ACCEPTMBOX_SIZE (8)
+
+/**
+ * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One
+ * per active UDP "connection".
+ * (requires the LWIP_UDP option)
+ */
+#define MEMP_NUM_UDP_PCB 8
+
+/**
+ * MEMP_NUM_TCP_PCB: the number of simultaneously active TCP connections.
+ * (requires the LWIP_TCP option)
+ */
+#define MEMP_NUM_TCP_PCB 8
+
+/**
+ * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections.
+ * (requires the LWIP_TCP option)
+ */
+#define MEMP_NUM_TCP_PCB_LISTEN 1
+
+/**
+ * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments.
+ * (requires the LWIP_TCP option)
+ */
+#define MEMP_NUM_TCP_SEG 27
+
+/**
+ * MEMP_NUM_SYS_TIMEOUT: the number of simultaneously active timeouts.
+ */
+#define MEMP_NUM_SYS_TIMEOUT 12
+
+/**
+ * PBUF_POOL_SIZE: the number of buffers in the pbuf pool.
+ */
+#define PBUF_POOL_SIZE 24
+
+/**
+ * MEMP_NUM_NETBUF: the number of struct netbufs.
+ * (only needed if you use the sequential API, like api_lib.c)
+ */
+#define MEMP_NUM_NETBUF 8
+
+/**
+ * MEMP_NUM_NETCONN: the number of struct netconns.
+ * (only needed if you use the sequential API, like api_lib.c)
+ */
+#define MEMP_NUM_NETCONN 16
+
+
+/* Turn off LWIP_STATS in Release build */
+#ifdef DEBUG
+#define LWIP_STATS 1
+#else
+#define LWIP_STATS 0
+#endif
+
+/**
+ * LWIP_TCPIP_CORE_LOCKING
+ * Creates a global mutex that is held during TCPIP thread operations.
+ * Can be locked by client code to perform lwIP operations without changing
+ * into TCPIP thread using callbacks. See LOCK_TCPIP_CORE() and
+ * UNLOCK_TCPIP_CORE().
+ * Your system should provide mutexes supporting priority inversion to use this.
+ */
+#define LWIP_TCPIP_CORE_LOCKING 1
+
+/**
+ * LWIP_TCPIP_CORE_LOCKING_INPUT: when LWIP_TCPIP_CORE_LOCKING is enabled,
+ * this lets tcpip_input() grab the mutex for input packets as well,
+ * instead of allocating a message and passing it to tcpip_thread.
+ *
+ * ATTENTION: this does not work when tcpip_input() is called from
+ * interrupt context!
+ */
+#define LWIP_TCPIP_CORE_LOCKING_INPUT 1
+
+/**
+ * LWIP_NETIF_API==1: Support netif api (in netifapi.c)
+ */
+#define LWIP_NETIF_API 1
+
+#define LWIP_DNS (1)
+
+#define LWIP_NETIF_TX_SINGLE_PBUF (1)
+
+#define LWIP_RAND rand
+
+#define LWIP_FREERTOS_CHECK_CORE_LOCKING (1)
+
+#define LWIP_ASSERT_CORE_LOCKED() sys_check_core_locking()
+
+#define LWIP_NETIF_STATUS_CALLBACK (1)
+#define LWIP_NETIF_LINK_CALLBACK (1)
+#define LWIP_NETIF_REMOVE_CALLBACK (1)
+
+#define LWIP_CHKSUM_ALGORITHM (3)
+
+extern void sys_check_core_locking();
diff --git a/ports/psoc6/machine_adc.c b/ports/psoc6/machine_adc.c
new file mode 100644
index 0000000000000..2dac56682fe45
--- /dev/null
+++ b/ports/psoc6/machine_adc.c
@@ -0,0 +1,174 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include
+#include "py/runtime.h"
+#include "py/mphal.h"
+
+// port-specific includes
+#include "modmachine.h"
+#include "machine_adc.h"
+#include "machine_adcblock.h"
+
+#include "cybsp.h"
+#include "cyhal.h"
+#include "cy_pdl.h"
+
+extern machine_adcblock_obj_t *adc_block_obj_find(mp_obj_t pin);
+extern machine_adcblock_obj_t *adc_block_obj_init(mp_obj_t pin);
+extern machine_adc_obj_t *adc_block_channel_find(machine_adcblock_obj_t *adc_block, mp_obj_t pin);
+extern machine_adc_obj_t *adc_block_channel_alloc(machine_adcblock_obj_t *adc_block, mp_obj_t pin);
+extern void adc_block_channel_free(machine_adcblock_obj_t *acd_block, machine_adc_obj_t *channel);
+
+void adc_obj_init(machine_adc_obj_t *adc, machine_adcblock_obj_t *adc_block, mp_obj_t pin_name, uint32_t sampling_time) {
+ uint32_t pin_addr = pin_addr_by_name(pin_name);
+ const cyhal_adc_channel_config_t channel_config =
+ {
+ .enable_averaging = false,
+ .min_acquisition_ns = sampling_time,
+ .enabled = true
+ };
+
+ cy_rslt_t status = cyhal_adc_channel_init_diff(&(adc->adc_chan_obj), &(adc_block->adc_obj), pin_addr, CYHAL_ADC_VNEG, &channel_config);
+ if (status != CY_RSLT_SUCCESS) {
+ assert_pin_phy_used(status);
+ mp_raise_TypeError(MP_ERROR_TEXT("ADC Channel Initialization failed!"));
+ }
+
+ adc->pin_addr = pin_addr;
+ adc->block = adc_block;
+ adc->sample_ns = sampling_time;
+}
+
+void adc_obj_deinit(machine_adc_obj_t *adc) {
+ cyhal_adc_channel_free(&(adc->adc_chan_obj));
+}
+
+machine_adc_obj_t *machine_adc_make_init(uint32_t sampling_time, mp_obj_t pin_name) {
+ machine_adc_obj_t *adc;
+
+ machine_adcblock_obj_t *adc_block = adc_block_obj_find(pin_name);
+ if (adc_block == NULL) {
+ adc_block = adc_block_obj_init(pin_name);
+ } else {
+ adc = adc_block_channel_find(adc_block, pin_name);
+ if (adc != NULL) {
+ adc->sample_ns = sampling_time;
+ return adc;
+ }
+ }
+
+ adc = adc_block_channel_alloc(adc_block, pin_name);
+ adc_obj_init(adc, adc_block, pin_name, sampling_time);
+
+ return adc;
+}
+
+// Helper function to get resolution
+uint8_t adc_get_resolution(machine_adc_obj_t *adc) {
+ printf("ADC bits: %d", adc->block->bits);
+ return adc->block->bits;
+}
+
+// machine_adc_print()
+static void machine_adc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "", self->pin_addr, self->block->id, self->sample_ns);
+}
+
+// ADC(id)
+static mp_obj_t machine_adc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ // Check number of arguments
+ mp_arg_check_num(n_args, n_kw, 1, 6, true);
+ enum {ARG_sample_ns};
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_sample_ns, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_ADC_ACQ_NS} },
+ };
+
+ // Parse the arguments.
+ mp_map_t kw_args;
+ mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args - 1, all_args + 1, &kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ // Get user input sampling time
+ uint32_t sampling_time = args[ARG_sample_ns].u_int;
+
+ machine_adc_obj_t *o = machine_adc_make_init(sampling_time, all_args[0]);
+
+ return MP_OBJ_FROM_PTR(o);
+}
+
+// deinit()
+static mp_obj_t machine_adc_deinit(mp_obj_t self_in) {
+ machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ adc_obj_deinit(self);
+ adc_block_channel_free(self->block, self);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_deinit_obj, machine_adc_deinit);
+
+// block()
+static mp_obj_t machine_adc_block(mp_obj_t self_in) {
+ const machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ return MP_OBJ_FROM_PTR(self->block);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_block_obj, machine_adc_block);
+
+// read_u16()
+static mp_obj_t machine_adc_read_u16(mp_obj_t self_in) {
+ machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ int32_t adc_raw_result = cyhal_adc_read(&(self->adc_chan_obj));
+ mp_int_t bits = (mp_int_t)adc_get_resolution(self);
+ mp_uint_t u16 = adc_raw_result << (16 - bits);
+ return MP_OBJ_NEW_SMALL_INT(u16);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_read_u16_obj, machine_adc_read_u16);
+
+// read_uv
+static mp_obj_t machine_adc_read_uv(mp_obj_t self_in) {
+ machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ return MP_OBJ_NEW_SMALL_INT(cyhal_adc_read_uv(&(self->adc_chan_obj)));
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_read_uv_obj, machine_adc_read_uv);
+
+
+static const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_adc_deinit_obj) },
+ { MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&machine_adc_read_u16_obj) },
+ { MP_ROM_QSTR(MP_QSTR_read_uv), MP_ROM_PTR(&machine_adc_read_uv_obj) },
+ { MP_ROM_QSTR(MP_QSTR_block), MP_ROM_PTR(&machine_adc_block_obj) },
+};
+static MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_adc_type,
+ MP_QSTR_ADC,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_adc_make_new,
+ print, machine_adc_print,
+ locals_dict, &machine_adc_locals_dict
+ );
diff --git a/ports/psoc6/machine_adc.h b/ports/psoc6/machine_adc.h
new file mode 100644
index 0000000000000..2ebefe5bbe2d3
--- /dev/null
+++ b/ports/psoc6/machine_adc.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_ADC_H
+#define MICROPY_INCLUDED_MACHINE_ADC_H
+
+#include "machine_adcblock.h"
+#include "machine_pin_phy.h"
+
+typedef struct _machine_adc_obj_t {
+ mp_obj_base_t base;
+ machine_adcblock_obj_t *block;
+ uint32_t pin_addr;
+ uint32_t sample_ns;
+ cyhal_adc_channel_t adc_chan_obj;
+} machine_adc_obj_t;
+
+#endif // MICROPY_INCLUDED_MACHINE_ADC_H
diff --git a/ports/psoc6/machine_adcblock.c b/ports/psoc6/machine_adcblock.c
new file mode 100644
index 0000000000000..7746a50b1ed36
--- /dev/null
+++ b/ports/psoc6/machine_adcblock.c
@@ -0,0 +1,340 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "modmachine.h"
+
+#include "machine_adcblock.h"
+#include "machine_adc.h"
+
+extern void adc_obj_init(machine_adc_obj_t *adc, machine_adcblock_obj_t *adc_block, mp_obj_t pin_name, uint32_t sampling_time);
+extern void adc_obj_deinit(machine_adc_obj_t *adc);
+
+machine_adcblock_obj_t *adc_block[MAX_BLOCKS] = {NULL};
+
+const adc_block_channel_pin_map_t adc_block_pin_map[] = {
+ {ADCBLOCK0, 0, CYHAL_GET_GPIO(CYHAL_PORT_10, 0)},
+ {ADCBLOCK0, 1, CYHAL_GET_GPIO(CYHAL_PORT_10, 1)},
+ {ADCBLOCK0, 2, CYHAL_GET_GPIO(CYHAL_PORT_10, 2)},
+ {ADCBLOCK0, 3, CYHAL_GET_GPIO(CYHAL_PORT_10, 3)},
+ {ADCBLOCK0, 4, CYHAL_GET_GPIO(CYHAL_PORT_10, 4)},
+ {ADCBLOCK0, 5, CYHAL_GET_GPIO(CYHAL_PORT_10, 5)},
+ {ADCBLOCK0, 6, CYHAL_GET_GPIO(CYHAL_PORT_10, 6)},
+ {ADCBLOCK0, 7, CYHAL_GET_GPIO(CYHAL_PORT_10, 7)}
+};
+/******************************************************************************/
+// MicroPython bindings for machine.ADC
+
+// Private helper function to get channel number for provided pin
+int16_t _get_adc_channel_number_for_pin(uint32_t pin) {
+ for (int i = 0; i < (sizeof(adc_block_pin_map) / sizeof(adc_block_pin_map[0])); i++)
+ {
+ if (pin == adc_block_pin_map[i].pin) {
+ return adc_block_pin_map[i].channel;
+ }
+ }
+ return -1;
+}
+
+// Private helper function to get pin number for provided channel no.
+int16_t _get_adc_pin_number_for_channel(uint16_t channel) {
+ for (int i = 0; i < (sizeof(adc_block_pin_map) / sizeof(adc_block_pin_map[0])); i++)
+ {
+ if (channel == adc_block_pin_map[i].channel) {
+ return adc_block_pin_map[i].pin;
+ }
+ }
+ return -1;
+}
+
+// Public helper function to get adc block id associated to input pin
+int16_t _get_block_id_for_pin(uint32_t pin) {
+ for (int i = 0; i < (sizeof(adc_block_pin_map) / sizeof(adc_block_pin_map[0])); i++)
+ {
+ if (pin == adc_block_pin_map[i].pin) {
+ return adc_block_pin_map[i].block_id;
+ }
+ }
+ return -1;
+}
+
+// Private helper function to check if ADC Block ID is valid
+static inline bool _is_valid_id(uint8_t adc_id) {
+ if (adc_id >= MAX_BLOCKS) {
+ return false;
+ }
+
+ return true;
+}
+
+static inline machine_adcblock_obj_t *_adc_block_obj_find(uint8_t adc_block_id) {
+ if (!_is_valid_id(adc_block_id)) {
+ mp_raise_TypeError(MP_ERROR_TEXT("Specified ADC id not supported"));
+ }
+
+ for (uint8_t i = 0; i < MAX_BLOCKS; i++)
+ {
+ if (adc_block[i] != NULL) {
+ if (adc_block[i]->id == adc_block_id) {
+ return adc_block[i];
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static inline machine_adcblock_obj_t *_adc_block_obj_alloc() {
+ for (uint8_t i = 0; i < MAX_BLOCKS; i++)
+ {
+ if (adc_block[i] == NULL) {
+ adc_block[i] = mp_obj_malloc(machine_adcblock_obj_t, &machine_adcblock_type);
+ return adc_block[i];
+ }
+ }
+
+ return NULL;
+}
+
+static inline void _adc_block_obj_free(machine_adcblock_obj_t *adc_block_ptr) {
+ for (uint8_t i = 0; i < MAX_BLOCKS; i++)
+ {
+ if (adc_block[i] == adc_block_ptr) {
+ adc_block[i] = NULL;
+ }
+ }
+}
+
+machine_adc_obj_t *adc_block_channel_alloc(machine_adcblock_obj_t *adc_block, mp_obj_t pin) {
+ int pin_addr = mp_hal_get_pin_obj(pin);
+ int16_t adc_channel_no = _get_adc_channel_number_for_pin(pin_addr);
+ adc_block->channel[adc_channel_no] = mp_obj_malloc(machine_adc_obj_t, &machine_adc_type);
+ return adc_block->channel[adc_channel_no];
+}
+
+void adc_block_channel_free(machine_adcblock_obj_t *adc_block, machine_adc_obj_t *adc) {
+ for (uint8_t i = 0; i < ADC_BLOCK_CHANNEL_MAX; i++) {
+ if (adc_block->channel[i] == adc) {
+ adc_block->channel[i] = NULL;
+ }
+ }
+}
+
+// Private helper function to get any associated pin to the given ADC Block id
+static inline uint32_t _adc_block_get_any_pin(uint16_t adc_block_id) {
+ for (uint8_t i = 0; i < MAX_CHANNELS; i++) {
+ if (adc_block_pin_map[i].block_id == adc_block_id) {
+ return adc_block_pin_map[i].pin;
+ }
+ }
+
+ return 0; // there should always an associated pin for block...
+}
+
+// Private helper function to create and initialize new ADC Block
+static void _adc_block_obj_init(machine_adcblock_obj_t *adc_block, uint16_t adc_block_id, uint8_t bits) {
+ cy_rslt_t status = cyhal_adc_init(&(adc_block->adc_obj), _adc_block_get_any_pin(adc_block_id), NULL);
+ if (status != CY_RSLT_SUCCESS) {
+ mp_raise_TypeError(MP_ERROR_TEXT("ADC Initialization failed!"));
+ }
+ const cyhal_adc_config_t adc_config = {
+ .continuous_scanning = false, // Continuous Scanning is disabled
+ .average_count = 1, // Average count disabled
+ .vref = CYHAL_ADC_REF_VDDA, // VREF for Single ended channel set to VDDA
+ .vneg = CYHAL_ADC_VNEG_VSSA, // VNEG for Single ended channel set to VSSA
+ .resolution = 12u, // 12-bit resolution
+ .ext_vref = NC, // No connection
+ .bypass_pin = NC
+ }; // No connection
+
+ status = cyhal_adc_configure(&(adc_block->adc_obj), &adc_config);
+ if (status != CY_RSLT_SUCCESS) {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ADC configuration update failed. Error: %ld ! \n"), status);
+ }
+
+ adc_block->id = adc_block_id;
+ adc_block->bits = bits;
+}
+
+static void _adc_block_obj_deinit(machine_adcblock_obj_t *adc_block) {
+ // Includes all channels deinitialization and deallocation
+ for (uint8_t i = 0; i < ADC_BLOCK_CHANNEL_MAX; i++) {
+ if (adc_block->channel[i] != NULL) {
+ adc_obj_deinit(adc_block->channel[i]);
+ adc_block_channel_free(adc_block, adc_block->channel[i]);
+ }
+ }
+ cyhal_adc_free(&(adc_block->adc_obj));
+}
+
+machine_adcblock_obj_t *machine_adcblock_make_init(uint8_t adc_id, uint8_t bits) {
+ machine_adcblock_obj_t *adc_block = _adc_block_obj_find(adc_id);
+
+ // No existing adc_block for given id. Create new one.
+ if (adc_block == NULL) {
+ adc_block = _adc_block_obj_alloc();
+ if (adc_block == NULL) {
+ mp_raise_TypeError(MP_ERROR_TEXT("ADC Blocks not available. Fully allocated"));
+ }
+ _adc_block_obj_init(adc_block, adc_id, bits);
+ }
+
+ return adc_block;
+}
+
+machine_adcblock_obj_t *adc_block_obj_find(mp_obj_t pin) {
+ int pin_addr = mp_hal_get_pin_obj(pin);
+ int adc_block_id = _get_block_id_for_pin(pin_addr);
+
+ if (adc_block_id == -1) {
+ mp_raise_ValueError(MP_ERROR_TEXT("No associated ADC Block for specified pin!"));
+ }
+
+ return _adc_block_obj_find(adc_block_id);
+}
+
+machine_adcblock_obj_t *adc_block_obj_init(mp_obj_t pin) {
+ int pin_addr = mp_hal_get_pin_obj(pin);
+ int adc_block_id = _get_block_id_for_pin(pin_addr);
+
+ if (adc_block_id == -1) {
+ mp_raise_ValueError(MP_ERROR_TEXT("No associated ADC Block for specified pin!"));
+ }
+
+ return machine_adcblock_make_init(adc_block_id, DEFAULT_ADC_BITS);
+}
+
+machine_adc_obj_t *adc_block_channel_find(machine_adcblock_obj_t *adc_block, mp_obj_t pin) {
+ int pin_addr = mp_hal_get_pin_obj(pin);
+ int16_t adc_channel_no = _get_adc_channel_number_for_pin(pin_addr);
+ return adc_block->channel[adc_channel_no];
+}
+
+// machine_adcblock_print()
+static void machine_adcblock_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_adcblock_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "ADCBlock(%u, bits=%u)", self->id, self->bits);
+}
+
+// ADCBlock constructor
+static mp_obj_t machine_adcblock_make_new(const mp_obj_type_t *type, size_t n_pos_args, size_t n_kw_args, const mp_obj_t *all_args) {
+ mp_arg_check_num(n_pos_args, n_kw_args, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+ mp_map_t kw_args;
+ mp_map_init_fixed_table(&kw_args, n_kw_args, all_args + n_pos_args);
+
+ // Get ADC ID
+ uint8_t adc_id = mp_obj_get_int(all_args[0]);
+
+ // Get ADC bits
+ enum { ARG_bits };
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_ADC_BITS} }
+ };
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_pos_args - 1, all_args + 1, &kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+ uint8_t bits = args[ARG_bits].u_int;
+ if (bits != DEFAULT_ADC_BITS) {
+ mp_raise_TypeError(MP_ERROR_TEXT("Invalid bits. Current ADC configuration supports only 11 bits resolution!"));
+ }
+
+ return MP_OBJ_FROM_PTR(machine_adcblock_make_init(adc_id, bits));
+}
+
+// ADCBlock deinit()
+static mp_obj_t machine_adcblock_deinit(mp_obj_t self_in) {
+ machine_adcblock_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ _adc_block_obj_deinit(self);
+ _adc_block_obj_free(self);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_adcblock_deinit_obj, machine_adcblock_deinit);
+
+// ADCBlock connect()
+static mp_obj_t machine_adcblock_connect(size_t n_pos_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ machine_adcblock_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+ uint8_t channel = -1;
+ uint32_t pin = 0;
+ mp_obj_t pin_name;
+
+ if (n_pos_args == 2) {
+ // If channel only specified : If mp_obj_is_int is true, then it is channel
+ if (mp_obj_is_int(pos_args[1])) {
+ channel = mp_obj_get_int(pos_args[1]);
+ pin = _get_adc_pin_number_for_channel(channel);
+ pin_name = pin_name_by_addr(mp_obj_new_int(pin));
+ } else {
+ pin_name = pos_args[1];
+ }
+ } else if (n_pos_args == 3) {
+ channel = mp_obj_get_int(pos_args[1]);
+ uint32_t exp_pin = _get_adc_pin_number_for_channel(channel);
+
+ pin_name = pos_args[2];
+ pin = mp_hal_get_pin_obj(pin_name);
+ if (exp_pin != pin) {
+ mp_raise_TypeError(MP_ERROR_TEXT("Wrong pin specified for the mentioned channel"));
+ }
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Too many positional args"));
+ }
+
+ machine_adc_obj_t *adc = adc_block_channel_find(self, pin_name);
+ if (adc == NULL) {
+ adc = adc_block_channel_alloc(self, pin_name);
+ adc_obj_init(adc, self, pin_name, DEFAULT_ADC_ACQ_NS);
+ }
+
+ return adc;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_adcblock_connect_obj, 2, machine_adcblock_connect);
+
+void mod_adcblock_deinit(void) {
+ for (uint8_t i = 0; i < MAX_BLOCKS; i++) {
+ if (adc_block[i] != NULL) {
+ machine_adcblock_deinit(adc_block[i]);
+ }
+ }
+}
+
+
+static const mp_rom_map_elem_t machine_adcblock_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_adcblock_deinit_obj)},
+ { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&machine_adcblock_connect_obj) },
+ { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_adcblock_deinit_obj) },
+};
+static MP_DEFINE_CONST_DICT(machine_adcblock_locals_dict, machine_adcblock_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_adcblock_type,
+ MP_QSTR_ADCBlock,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_adcblock_make_new,
+ print, machine_adcblock_print,
+ locals_dict, &machine_adcblock_locals_dict
+ );
diff --git a/ports/psoc6/machine_adcblock.h b/ports/psoc6/machine_adcblock.h
new file mode 100644
index 0000000000000..ad41f2b8f0fa3
--- /dev/null
+++ b/ports/psoc6/machine_adcblock.h
@@ -0,0 +1,58 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_ADCBLOCK_H
+#define MICROPY_INCLUDED_MACHINE_ADCBLOCK_H
+
+// These should go into the specific BSP
+#define DEFAULT_ADC_BITS 12
+#define ADC_BLOCK_CHANNEL_MAX 6
+#define DEFAULT_ADC_ACQ_NS 1000
+
+#define ADCBLOCK0 (0)
+#define ADCBLOCK_CHANNEL_MAX (1)
+#define MAX_BLOCKS (1)
+#define MAX_CHANNELS (6)
+
+typedef struct _machine_adc_obj_t machine_adc_obj_t; /* Forward declaration of adc_obj */
+
+typedef struct _machine_adcblock_obj_t {
+ mp_obj_base_t base;
+ cyhal_adc_t adc_obj;
+ uint8_t id;
+ uint8_t bits;
+ machine_adc_obj_t *channel[ADC_BLOCK_CHANNEL_MAX];
+} machine_adcblock_obj_t;
+
+typedef struct
+{
+ uint16_t block_id;
+ uint16_t channel;
+ uint32_t pin;
+}adc_block_channel_pin_map_t;
+
+void mod_adcblock_deinit(void);
+#endif // MICROPY_INCLUDED_MACHINE_ADCBLOCK_H
diff --git a/ports/psoc6/machine_bitstream.c b/ports/psoc6/machine_bitstream.c
new file mode 100644
index 0000000000000..d0ab385367fde
--- /dev/null
+++ b/ports/psoc6/machine_bitstream.c
@@ -0,0 +1,121 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include "py/mphal.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "extmod/modmachine.h"
+
+#if MICROPY_PY_MACHINE_BITSTREAM
+
+const uint32_t timing_sequence_1[] = {500, 1125, 800, 750};
+uint32_t range = 0;
+
+void machine_bitstream_high_low(mp_hal_pin_obj_t pin, uint32_t *timing_ns, const uint8_t *buf, size_t len) {
+
+ GPIO_PRT_Type *base = CYHAL_GET_PORTADDR(pin);
+ uint32_t pinNum = CYHAL_GET_PIN(pin);
+ uint32_t fcpu_mhz = mp_hal_get_cpu_freq() / 1000000;
+
+ if (memcmp(timing_ns, timing_sequence_1, 4 * sizeof(uint32_t)) == 0) {
+ range = 0;
+ } else {
+ for (size_t i = 0; i < 4; ++i) {
+ if ((timing_ns[i]) <= 150) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Timing is not supported"));
+ }
+ }
+ range = 1;
+ }
+
+ // Convert ns to cycles [high_time_0, low_time_0, high_time_1, low_time_1].
+ for (size_t i = 0; i < 4; ++i) {
+ timing_ns[i] = fcpu_mhz * timing_ns[i] / 1000;
+ }
+
+ taskENTER_CRITICAL(); // FreeRTOS function for critical section
+
+ switch (range)
+ {
+ case 0:
+ for (size_t i = 0; i < len; i++)
+ {
+
+ uint8_t b = buf[i];
+ // Send each bit of the byte
+ for (size_t j = 0; j < 8; j++)
+ {
+ bool bit = (b & 0x80) != 0;
+ b <<= 1;
+ switch (bit)
+ {
+ // Send a 1-bit
+ case 1:
+ // sendOneBit();
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_GPIO_Write(base, pinNum, 0);
+ Cy_GPIO_Write(base, pinNum, 0);
+ break;
+ // Send a 0-bit
+ case 0:
+ // sendZeroBit();
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_GPIO_Write(base, pinNum, 0);
+ Cy_GPIO_Write(base, pinNum, 0);
+ Cy_GPIO_Write(base, pinNum, 0);
+ Cy_GPIO_Write(base, pinNum, 0);
+ Cy_GPIO_Write(base, pinNum, 0);
+ break;
+ }
+ }
+ }
+
+ break;
+ default:
+ for (size_t i = 0; i < len; ++i) {
+ uint8_t b = buf[i];
+ for (size_t j = 0; j < 8; ++j) {
+ uint32_t *t = &timing_ns[b >> 6 & 2];
+ Cy_GPIO_Write(base, pinNum, 1);
+ Cy_SysLib_DelayCycles(t[0]);
+ Cy_GPIO_Write(base, pinNum, 0);
+ Cy_SysLib_DelayCycles(t[1]);
+ b <<= 1;
+ }
+ }
+ break;
+ }
+ taskEXIT_CRITICAL();
+}
+
+#endif // MICROPY_PY_MACHINE_BITSTREAM
diff --git a/ports/psoc6/machine_i2c.c b/ports/psoc6/machine_i2c.c
new file mode 100644
index 0000000000000..6ea35fb3d4baf
--- /dev/null
+++ b/ports/psoc6/machine_i2c.c
@@ -0,0 +1,358 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+
+
+// mpy includes
+#include "extmod/modmachine.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+
+
+// MTB includes
+#include "cybsp.h"
+
+
+// port-specific includes
+#include "modmachine.h"
+#include "machine_pin_phy.h"
+#include "mplogger.h"
+
+#define DEFAULT_I2C_FREQ (400000)
+#define PSOC_I2C_MASTER_MODE (CYHAL_I2C_MODE_MASTER)
+
+#define i2c_assert_raise_val(msg, ret) if (ret != CY_RSLT_SUCCESS) { \
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), ret); \
+}
+
+typedef struct _machine_i2c_obj_t {
+ mp_obj_base_t base;
+ int id; // This parameter is unused and added for compliance with reference API.
+ cyhal_i2c_t i2c_obj;
+ uint32_t scl_pin;
+ uint32_t sda_pin;
+ cyhal_i2c_cfg_t cfg;
+ mp_obj_t callback;
+} machine_i2c_obj_t;
+
+machine_i2c_obj_t *i2c_obj[MAX_I2C] = { NULL };
+
+static inline machine_i2c_obj_t *i2c_obj_alloc(bool is_slave) {
+ for (uint8_t i = 0; i < MAX_I2C; i++)
+ {
+ if (i2c_obj[i] == NULL) {
+
+ const mp_obj_type_t *obj_type;
+ if (is_slave) {
+ obj_type = &machine_i2c_slave_type;
+ } else {
+ obj_type = &machine_i2c_type;
+ }
+ i2c_obj[i] = mp_obj_malloc(machine_i2c_obj_t, obj_type);
+ return i2c_obj[i];
+ }
+ }
+
+ return NULL;
+}
+
+static inline void i2c_obj_free(machine_i2c_obj_t *i2c_obj_ptr) {
+ for (uint8_t i = 0; i < MAX_I2C; i++)
+ {
+ if (i2c_obj[i] == i2c_obj_ptr) {
+ i2c_obj[i] = NULL;
+ }
+ }
+}
+
+static void i2c_init(machine_i2c_obj_t *machine_i2c_obj, uint32_t freq_hz, int16_t slave_addr) {
+ // Define the I2C master configuration structure
+
+ // Set cgf frequency
+ machine_i2c_obj->cfg.frequencyhal_hz = freq_hz;
+
+ // Set mode master or slave
+ if (slave_addr <= 0) {
+ machine_i2c_obj->cfg.is_slave = CYHAL_I2C_MODE_MASTER;
+ machine_i2c_obj->cfg.address = 0;
+ } else {
+ machine_i2c_obj->cfg.is_slave = CYHAL_I2C_MODE_SLAVE;
+ machine_i2c_obj->cfg.address = slave_addr;
+ }
+
+ // Initialize I2C master, set the SDA and SCL pins and assign a new clock
+ cy_rslt_t result = cyhal_i2c_init(&machine_i2c_obj->i2c_obj, machine_i2c_obj->sda_pin, machine_i2c_obj->scl_pin, NULL);
+ assert_pin_phy_used(result);
+ i2c_assert_raise_val("I2C initialisation failed with return code %lx !", result);
+
+ result = cyhal_i2c_configure(&machine_i2c_obj->i2c_obj, &(machine_i2c_obj->cfg));
+ i2c_assert_raise_val("I2C initialisation failed with return code %lx !", result);
+}
+
+static void machine_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "I2C(freq=%u, scl=%u, sda=%u, mode=%u, addr=%u)", self->cfg.frequencyhal_hz, self->scl_pin, self->sda_pin, self->cfg.is_slave, self->cfg.address);
+}
+
+mp_obj_t machine_i2c_master_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ mp_arg_check_num(n_args, n_kw, 0, 4, true);
+
+ enum { ARG_id, ARG_freq, ARG_scl, ARG_sda };
+
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_id, MP_ARG_INT, {.u_int = -1}},
+ { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_I2C_FREQ} },
+ { MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_sda, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} }
+ };
+
+ // Parse args.
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ machine_i2c_obj_t *self = i2c_obj_alloc(false);
+ if (self == NULL) {
+ return mp_const_none;
+ }
+
+ // set id if provided
+ if (args[ARG_id].u_int != -1) {
+ self->id = args[ARG_id].u_int;
+ mp_printf(&mp_plat_print, "machine.I2C: ID parameter is ignored in this port.\n");
+ }
+
+ // get scl & sda pins & configure them
+ self->scl_pin = pin_addr_by_name(args[ARG_scl].u_obj);
+ self->sda_pin = pin_addr_by_name(args[ARG_sda].u_obj);
+
+ // initialise I2C at cyhal level
+ i2c_init(self, args[ARG_freq].u_int, 0);
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+mp_obj_t machine_i2c_slave_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ mp_arg_check_num(n_args, n_kw, 0, 4, true);
+
+ enum { ARG_id, ARG_freq, ARG_scl, ARG_sda, ARG_addr };
+
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_id, MP_ARG_INT, {.u_int = -1}},
+ { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_I2C_FREQ} },
+ { MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_sda, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_addr, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1}}
+ };
+
+ // Parse args.
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ machine_i2c_obj_t *self = i2c_obj_alloc(true);
+ if (self == NULL) {
+ return mp_const_none;
+ }
+
+ // set id if provided
+ if (args[ARG_id].u_int != -1) {
+ self->id = args[ARG_id].u_int;
+ mp_printf(&mp_plat_print, "machine.I2C: ID parameter is ignored in this port.\n");
+ }
+
+ // get scl & sda pins & configure them
+ self->scl_pin = pin_addr_by_name(args[ARG_scl].u_obj);
+ self->sda_pin = pin_addr_by_name(args[ARG_sda].u_obj);
+
+ // initialise I2C at cyhal level
+ i2c_init(self, args[ARG_freq].u_int, args[ARG_addr].u_int);
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static void machine_i2c_deinit(mp_obj_base_t *self_in) {
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ cyhal_i2c_free(&(self->i2c_obj));
+ i2c_obj_free(self);
+}
+
+static int machine_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t len, uint8_t *buf, unsigned int flags) {
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ cy_rslt_t result = CY_RSLT_SUCCESS;
+ bool send_stop = (flags & MP_MACHINE_I2C_FLAG_STOP) ? true : false;
+ uint32_t timeout = 0;
+
+ if ((flags & MP_MACHINE_I2C_FLAG_READ) == MP_MACHINE_I2C_FLAG_READ) {
+ result = cyhal_i2c_master_read(&self->i2c_obj, addr, buf, len, timeout, send_stop);
+ i2c_assert_raise_val("I2C transfer failed with return code %lx !", result);
+
+ return len;
+ } else {
+ // handle scan type bus checks and send stop
+ if (buf == NULL) {
+ result = cyhal_i2c_master_write(&self->i2c_obj, addr, buf, 0, 50, send_stop);
+
+ if ((result != CY_RSLT_SUCCESS)) {
+ // these 2 errors occur if nothing is attached to sda/scl, but they are pulled-up (0xaa2004) or not pulled-up (0xaa2003).
+ // In the latter case, due to not reaction at all the timeout has to expire. Latency is therefore high.
+ if (result != 0xaa2004 && result != 0xaa2003) {
+ i2c_assert_raise_val("I2C transfer failed with return code %lx !", result);
+ }
+
+ return 1;
+ }
+
+ return len;
+ } else {
+ result = cyhal_i2c_master_write(&self->i2c_obj, addr, buf, len, timeout, send_stop);
+ i2c_assert_raise_val("I2C transfer failed with return code %lx !", result);
+ }
+
+ return len;
+ }
+}
+
+static const mp_machine_i2c_p_t machine_i2c_p = {
+ .deinit = machine_i2c_deinit,
+ .transfer_single = machine_i2c_transfer,
+ .transfer = mp_machine_i2c_transfer_adaptor
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_i2c_type,
+ MP_QSTR_I2C,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_i2c_master_make_new,
+ print, machine_i2c_print,
+ protocol, &machine_i2c_p,
+ locals_dict, &mp_machine_i2c_locals_dict
+ );
+
+#if MICROPY_PY_MACHINE_I2C_SLAVE
+
+static mp_obj_t machine_i2c_slave_deinit(mp_obj_t self_in) {
+ mp_obj_base_t *self = MP_OBJ_TO_PTR(self_in);
+ machine_i2c_deinit(self);
+ return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_slave_deinit_obj, machine_i2c_slave_deinit);
+
+static mp_obj_t machine_i2c_slave_configure_receive_buffer(mp_obj_t self_in, mp_obj_t buf_in) {
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
+
+ cy_rslt_t result = cyhal_i2c_slave_config_write_buffer(&self->i2c_obj, bufinfo.buf, bufinfo.len);
+ i2c_assert_raise_val("I2C Slave configure receive buffer failed with return code %lx !", result);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(machine_i2c_slave_conf_rx_buffer_obj, machine_i2c_slave_configure_receive_buffer);
+
+static mp_obj_t machine_i2c_slave_configure_transmit_buffer(mp_obj_t self_in, mp_obj_t buf_in) {
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
+
+ cy_rslt_t result = cyhal_i2c_slave_config_read_buffer(&self->i2c_obj, bufinfo.buf, bufinfo.len);
+ i2c_assert_raise_val("I2C Slave configure receive buffer failed with return code %lx !", result);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(machine_i2c_slave_conf_tx_buffer_obj, machine_i2c_slave_configure_transmit_buffer);
+
+static void i2c_irq_handler(void *callback_arg, cyhal_i2c_event_t event) {
+ machine_i2c_obj_t *self = callback_arg;
+ mp_sched_schedule(self->callback, mp_obj_new_int(event));
+}
+
+static mp_obj_t machine_i2c_slave_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ enum { ARG_callback, ARG_events, ARG_priority};
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_callback, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_events, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = CYHAL_I2C_EVENT_NONE }},
+ { MP_QSTR_priority, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 3 }},
+ };
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ self->callback = args[ARG_callback].u_obj;
+
+ cyhal_i2c_register_callback(&self->i2c_obj, i2c_irq_handler, self);
+ cyhal_i2c_enable_event(&self->i2c_obj, args[ARG_callback].u_int, args[ARG_priority].u_int, true);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_i2c_slave_irq_obj, 1, machine_i2c_slave_irq);
+
+static mp_obj_t machine_i2c_slave_irq_disable(mp_obj_t self_in) {
+ machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ cyhal_i2c_enable_event(&self->i2c_obj, CYHAL_I2C_EVENT_NONE, 3, false);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_slave_irq_disable_obj, machine_i2c_slave_irq_disable);
+
+void mod_i2c_deinit() {
+ for (uint8_t i = 0; i < MAX_I2C; i++) {
+ if (i2c_obj[i] != NULL) {
+ machine_i2c_deinit((mp_obj_base_t *)(i2c_obj[i]));
+ }
+ }
+}
+
+
+static const mp_rom_map_elem_t machine_i2c_slave_locals_dict_table[] = {
+ // Functions
+ { MP_ROM_QSTR(MP_QSTR_conf_receive_buffer), MP_ROM_PTR(&machine_i2c_slave_conf_rx_buffer_obj) },
+ { MP_ROM_QSTR(MP_QSTR_conf_transmit_buffer), MP_ROM_PTR(&machine_i2c_slave_conf_tx_buffer_obj) },
+ { MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_i2c_slave_irq_obj) },
+ { MP_ROM_QSTR(MP_QSTR_irq_disable), MP_ROM_PTR(&machine_i2c_slave_irq_disable_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_i2c_slave_deinit_obj) },
+
+ // Const
+ { MP_ROM_QSTR(MP_QSTR_RD_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_READ_EVENT) },
+ { MP_ROM_QSTR(MP_QSTR_WR_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_WRITE_EVENT) },
+ { MP_ROM_QSTR(MP_QSTR_RD_BUF_IN_FIFO_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_RD_IN_FIFO_EVENT) },
+ { MP_ROM_QSTR(MP_QSTR_RD_BUF_EMPTY_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_RD_BUF_EMPTY_EVENT) },
+ { MP_ROM_QSTR(MP_QSTR_RD_CMPLT_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_RD_CMPLT_EVENT) },
+ { MP_ROM_QSTR(MP_QSTR_WR_CMPLT_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_WR_CMPLT_EVENT) },
+ { MP_ROM_QSTR(MP_QSTR_ERR_EVENT), MP_ROM_INT(CYHAL_I2C_SLAVE_ERR_EVENT) },
+};
+static MP_DEFINE_CONST_DICT(machine_i2c_slave_locals_dict, machine_i2c_slave_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_i2c_slave_type,
+ MP_QSTR_I2CSlave,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_i2c_slave_make_new,
+ print, machine_i2c_print,
+ locals_dict, &machine_i2c_slave_locals_dict
+ );
+#endif
diff --git a/ports/psoc6/machine_i2s.c b/ports/psoc6/machine_i2s.c
new file mode 100644
index 0000000000000..783191f640020
--- /dev/null
+++ b/ports/psoc6/machine_i2s.c
@@ -0,0 +1,437 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "machine_pin_phy.h"
+
+#define i2s_assert_raise_val(msg, ret) if (ret != CY_RSLT_SUCCESS) { \
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), ret); \
+}
+
+#define AUDIO_SYS_CLOCK_98_304_000_HZ 98000000u /* (Ideally 98.304 MHz) For sample rates: 8KHz / 16 KHz / 32 KHz / 48 KHz in Hz */
+#define AUDIO_SYS_CLOCK_90_300_000_HZ 90000000u /* (Ideally 90.3168 MHz) For sample rates: 22.05 KHz / 44.1 KHz */
+
+cyhal_clock_t audio_clock;
+
+// DMA ping-pong buffer size was empirically determined. It is a tradeoff between:
+// 1. memory use (smaller buffer size desirable to reduce memory footprint)
+// 2. interrupt frequency (larger buffer size desirable to reduce interrupt frequency)
+#define SIZEOF_DMA_BUFFER (256)
+#define SIZEOF_HALF_DMA_BUFFER (SIZEOF_DMA_BUFFER / 2)
+#define SIZEOF_DMA_BUFFER_IN_BYTES (256 * sizeof(uint32_t))
+#define SIZEOF_HALF_DMA_BUFFER_IN_BYTES (SIZEOF_DMA_BUFFER_IN_BYTES / 2)
+
+// TODO: For non-blocking mode, to avoid underflow/overflow, sample data is written/read to/from the ring buffer at a rate faster
+// than the DMA transfer rate
+#define NON_BLOCKING_RATE_MULTIPLIER (4)
+#define SIZEOF_NON_BLOCKING_COPY_IN_BYTES (SIZEOF_HALF_DMA_BUFFER * NON_BLOCKING_RATE_MULTIPLIER)
+
+typedef enum {
+ RX,
+ TX
+} i2s_mode_t;
+
+typedef struct _machine_i2s_obj_t {
+ mp_obj_base_t base;
+ uint8_t i2s_id; // Private variable in this port case. ID not associated to any port pin i2s group.
+ cyhal_i2s_t i2s_obj;
+ uint32_t sck;
+ uint32_t ws;
+ uint32_t sd;
+ uint16_t mode;
+ int8_t bits;
+ uint8_t channel_resolution_bits;
+ format_t format;
+ int32_t rate;
+ int32_t ibuf;
+ mp_obj_t callback_for_non_blocking;
+ io_mode_t io_mode;
+ uint32_t dma_buffer[SIZEOF_DMA_BUFFER];
+ uint32_t *dma_active_buf_p;
+ uint32_t *dma_idle_buf_p;
+ ring_buf_t ring_buffer;
+ uint8_t *ring_buffer_storage;
+ non_blocking_descriptor_t non_blocking_descriptor;
+} machine_i2s_obj_t;
+
+static const int8_t i2s_frame_map[NUM_I2S_USER_FORMATS][I2S_RX_FRAME_SIZE_IN_BYTES] = {
+ { 0, 1, -1, -1, -1, -1, -1, -1 }, // Mono, 16-bits
+ { 0, 1, 2, 3, -1, -1, -1, -1 }, // Mono, 32-bits
+ { 0, 1, -1, -1, 2, 3, -1, -1 }, // Stereo, 16-bits
+ { 0, 1, 2, 3, 4, 5, 6, 7 }, // Stereo, 32-bits
+};
+
+static int8_t get_frame_mapping_index(int8_t bits, format_t format) {
+ if (format == MONO) {
+ if (bits == 16) {
+ return 0;
+ } else { // 32 bits
+ return 1;
+ }
+ } else { // STEREO
+ if (bits == 16) {
+ return 2;
+ } else { // 32 bits
+ return 3;
+ }
+ }
+}
+
+void i2s_audio_clock_init(uint32_t audio_clock_freq_hz) {
+ cyhal_clock_t clock_pll;
+ cy_rslt_t result;
+
+ static bool clock_set = false;
+
+ result = cyhal_clock_reserve(&clock_pll, &CYHAL_CLOCK_PLL[0]);
+ i2s_assert_raise_val("PLL clock reserve failed with error code: %lx", result);
+
+ uint32_t pll_source_clock_freq_hz = cyhal_clock_get_frequency(&clock_pll);
+
+ if (audio_clock_freq_hz != pll_source_clock_freq_hz) {
+ mp_printf(&mp_plat_print, "machine.I2S: PLL0 freq is changed from %lu to %lu. This will affect all resources clock freq sourced by PLL0.\n", pll_source_clock_freq_hz, audio_clock_freq_hz);
+ clock_set = false;
+ pll_source_clock_freq_hz = audio_clock_freq_hz;
+ }
+
+ if (!clock_set) {
+ result = cyhal_clock_set_frequency(&clock_pll, pll_source_clock_freq_hz, NULL);
+ i2s_assert_raise_val("Set PLL clock frequency failed with error code: %lx", result);
+ if (!cyhal_clock_is_enabled(&clock_pll)) {
+ result = cyhal_clock_set_enabled(&clock_pll, true, true);
+ i2s_assert_raise_val("PLL clock enable failed with error code: %lx", result);
+ }
+
+ result = cyhal_clock_reserve(&audio_clock, &CYHAL_CLOCK_HF[1]);
+ i2s_assert_raise_val("HF1 clock reserve failed with error code: %lx", result);
+ result = cyhal_clock_set_source(&audio_clock, &clock_pll);
+ i2s_assert_raise_val("HF1 clock sourcing failed with error code: %lx", result);
+ result = cyhal_clock_set_divider(&audio_clock, 2);
+ i2s_assert_raise_val("HF1 clock set divider failed with error code: %lx", result);
+ if (!cyhal_clock_is_enabled(&audio_clock)) {
+ result = cyhal_clock_set_enabled(&audio_clock, true, true);
+ i2s_assert_raise_val("HF1 clock enable failed with error code: %lx", result);
+ }
+ cyhal_clock_free(&audio_clock);
+
+ clock_set = true;
+ }
+
+ cyhal_clock_free(&clock_pll);
+
+ cyhal_system_delay_ms(1);
+}
+
+static inline bool i2s_dma_is_tx_complete(cyhal_i2s_event_t event) {
+ return 0u != (event & CYHAL_I2S_ASYNC_TX_COMPLETE);
+}
+
+static inline bool i2s_dma_is_rx_complete(cyhal_i2s_event_t event) {
+ return 0u != (event & CYHAL_I2S_ASYNC_RX_COMPLETE);
+}
+
+uint8_t get_word_byte_size(machine_i2s_obj_t *self) {
+ uint8_t res_bits = self->channel_resolution_bits;
+ if (res_bits <= 8) {
+ return 1;
+ } else if (res_bits > 8 && res_bits <= 16) {
+ return 2;
+ } else {
+ return 4;
+ }
+}
+
+static inline void i2s_dma_rx(machine_i2s_obj_t *self) {
+ uint16_t dma_half_buff_word_size = SIZEOF_HALF_DMA_BUFFER_IN_BYTES / get_word_byte_size(self);
+ cy_rslt_t result = cyhal_i2s_read_async(&self->i2s_obj, self->dma_active_buf_p, dma_half_buff_word_size);
+ i2s_assert_raise_val("I2S DMA read failed with return code %lx !", result);
+}
+
+static inline void i2s_dma_tx(machine_i2s_obj_t *self) {
+ uint16_t dma_half_buff_word_size = SIZEOF_HALF_DMA_BUFFER_IN_BYTES / get_word_byte_size(self);
+ cy_rslt_t result = cyhal_i2s_write_async(&self->i2s_obj, self->dma_active_buf_p, dma_half_buff_word_size);
+ i2s_assert_raise_val("I2S DMA write configure failed with return code %lx !", result);
+}
+
+static void i2s_dma_from_dmabuf_to_ringbuf(machine_i2s_obj_t *self) {
+ uint8_t dma_sample_size_in_bytes = (self->bits == 16? 2 : 4) * (self->format == STEREO ? 2: 1);
+ uint8_t *dma_buff_p = (uint8_t *)self->dma_idle_buf_p;
+ uint32_t num_bytes_needed_from_ringbuf = SIZEOF_HALF_DMA_BUFFER_IN_BYTES * (I2S_RX_FRAME_SIZE_IN_BYTES / dma_sample_size_in_bytes);
+
+ // when space exists, copy samples into ring buffer
+ if (ringbuf_available_space(&self->ring_buffer) >= num_bytes_needed_from_ringbuf) {
+ uint8_t f_index = get_frame_mapping_index(self->bits, self->format);
+ uint32_t i = 0;
+ while (i < SIZEOF_HALF_DMA_BUFFER_IN_BYTES) {
+ for (uint8_t j = 0; j < I2S_RX_FRAME_SIZE_IN_BYTES; j++) {
+ int8_t r_to_a_mapping = i2s_frame_map[f_index][j];
+ if (r_to_a_mapping != -1) {
+ ringbuf_push(&self->ring_buffer, dma_buff_p[i]);
+ i++;
+ } else { // r_a_mapping == -1
+ ringbuf_push(&self->ring_buffer, -1);
+ }
+ }
+ }
+ }
+}
+
+static void i2s_dma_from_ringbuf_to_dmabuf(machine_i2s_obj_t *self) {
+ uint8_t *dma_buffer_p = (uint8_t *)self->dma_idle_buf_p;
+ memset(dma_buffer_p, 0, SIZEOF_HALF_DMA_BUFFER_IN_BYTES);
+ if (ringbuf_available_data(&self->ring_buffer) >= SIZEOF_HALF_DMA_BUFFER_IN_BYTES) {
+ for (uint32_t i = 0; i < SIZEOF_HALF_DMA_BUFFER_IN_BYTES; i++) {
+ ringbuf_pop(&self->ring_buffer, &dma_buffer_p[i]);
+ }
+ }
+}
+
+static inline void i2s_dma_swap_active_dmabuf(machine_i2s_obj_t *self) {
+ uint32_t *temp = self->dma_active_buf_p;
+ self->dma_active_buf_p = self->dma_idle_buf_p;
+ self->dma_idle_buf_p = temp;
+}
+
+static void i2s_dma_tx_event_process(machine_i2s_obj_t *self, cyhal_i2s_event_t event) {
+ if (i2s_dma_is_tx_complete(event)) {
+
+ if ((self->io_mode == NON_BLOCKING) && (self->non_blocking_descriptor.copy_in_progress)) {
+ copy_appbuf_to_ringbuf_non_blocking(self);
+ }
+
+ i2s_dma_swap_active_dmabuf(self);
+ i2s_dma_tx(self);
+ i2s_dma_from_ringbuf_to_dmabuf(self);
+ }
+}
+
+static void i2s_dma_rx_event_process(machine_i2s_obj_t *self, cyhal_i2s_event_t event) {
+ if (i2s_dma_is_rx_complete(event)) {
+
+ i2s_dma_swap_active_dmabuf(self);
+ i2s_dma_rx(self);
+ i2s_dma_from_dmabuf_to_ringbuf(self);
+
+ if ((self->io_mode == NON_BLOCKING) && (self->non_blocking_descriptor.copy_in_progress)) {
+ fill_appbuf_from_ringbuf_non_blocking(self);
+ }
+ }
+}
+
+static void i2s_dma_irq_handler(void *arg, cyhal_i2s_event_t event) {
+ machine_i2s_obj_t *self = (machine_i2s_obj_t *)arg;
+
+ void (*i2s_dma_event_process_func)(machine_i2s_obj_t *, cyhal_i2s_event_t);
+ if (self->mode == TX) {
+ i2s_dma_event_process_func = i2s_dma_tx_event_process;
+ } else if (self->mode == RX) {
+ i2s_dma_event_process_func = i2s_dma_rx_event_process;
+ }
+
+ i2s_dma_event_process_func(self, event);
+}
+
+static void i2s_init(machine_i2s_obj_t *self, cyhal_clock_t *clock) {
+ cyhal_i2s_pins_t pins = { .sck = self->sck, .ws = self->ws, .data = self->sd, .mclk = NC };
+ cyhal_i2s_config_t config =
+ {
+ .is_tx_slave = true,
+ .is_rx_slave = false,
+ .mclk_hz = 0,
+ .channel_length = self->bits,
+ .word_length = self->channel_resolution_bits,
+ .sample_rate_hz = self->rate
+ };
+
+ cyhal_i2s_pins_t *tx_pins, *rx_pins;
+
+ if (self->mode == TX) {
+ tx_pins = &pins;
+ rx_pins = NULL;
+ } else { // Rx
+ tx_pins = NULL;
+ rx_pins = &pins;
+ }
+
+ cy_rslt_t result = cyhal_i2s_init(&self->i2s_obj, tx_pins, rx_pins, &config, clock);
+ assert_pin_phy_used(result);
+ i2s_assert_raise_val("I2S initialisation failed with return code %lx !", result);
+}
+
+static inline void i2s_dma_irq_configure(machine_i2s_obj_t *self) {
+ cyhal_i2s_register_callback(&self->i2s_obj, &i2s_dma_irq_handler, self);
+
+ cyhal_i2s_event_t event;
+ if (self->mode == TX) {
+ event = CYHAL_I2S_ASYNC_TX_COMPLETE;
+ } else {
+ event = CYHAL_I2S_ASYNC_RX_COMPLETE;
+ }
+
+ cyhal_i2s_enable_event(&self->i2s_obj, event, CYHAL_ISR_PRIORITY_DEFAULT, true);
+
+ cy_rslt_t result = cyhal_i2s_set_async_mode(&self->i2s_obj, CYHAL_ASYNC_DMA, CYHAL_DMA_PRIORITY_DEFAULT);
+ i2s_assert_raise_val("I2S set DMA mode failed with return code %lx !", result);
+}
+
+static inline void i2s_dma_init_buff(machine_i2s_obj_t *self) {
+ for (uint32_t i = 0; i < SIZEOF_DMA_BUFFER; i++) {
+ self->dma_buffer[i] = 0;
+ }
+
+ self->dma_active_buf_p = self->dma_buffer;
+ self->dma_idle_buf_p = &self->dma_buffer[SIZEOF_HALF_DMA_BUFFER];
+}
+
+static void i2s_dma_tx_init(machine_i2s_obj_t *self) {
+ i2s_dma_tx(self);
+
+ cy_rslt_t result = cyhal_i2s_start_tx(&self->i2s_obj);
+ i2s_assert_raise_val("I2S tx start failed with return code %lx !", result);
+}
+
+static void i2s_dma_rx_init(machine_i2s_obj_t *self) {
+ i2s_dma_rx(self);
+
+ cy_rslt_t result = cyhal_i2s_start_rx(&self->i2s_obj);
+ i2s_assert_raise_val("I2S rx start failed with return code %lx !", result);
+}
+
+static void i2s_dma_init(machine_i2s_obj_t *self) {
+ i2s_dma_irq_configure(self);
+ i2s_dma_init_buff(self);
+
+ void (*i2s_dma_mode_init_func)(machine_i2s_obj_t *self);
+
+ if (self->mode == TX) {
+ i2s_dma_mode_init_func = i2s_dma_tx_init;
+ } else { // Rx
+ i2s_dma_mode_init_func = i2s_dma_rx_init;
+ }
+
+ i2s_dma_mode_init_func(self);
+}
+
+static void mp_machine_i2s_init_helper(machine_i2s_obj_t *self, mp_arg_val_t *args) {
+
+ // is Mode valid?
+ i2s_mode_t i2s_mode = args[ARG_mode].u_int;
+ if ((i2s_mode != RX) &&
+ (i2s_mode != TX)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid mode"));
+ }
+
+ // is Bits valid?
+ int8_t i2s_bits_resolution = args[ARG_bits].u_int;
+ if (i2s_bits_resolution < 1 || i2s_bits_resolution > 32) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid bits"));
+ }
+ int8_t i2s_bits;
+ if (i2s_bits_resolution <= 16) {
+ i2s_bits = 16;
+ } else {
+ i2s_bits = 32;
+ }
+
+ // is Format valid?
+ format_t i2s_format = args[ARG_format].u_int;
+ if ((i2s_format != MONO) &&
+ (i2s_format != STEREO)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid format"));
+ }
+
+ // is valid clock freq?
+ uint32_t audio_clock_freq_hz;
+ uint32_t rate = args[ARG_rate].u_int;
+ if (rate == 8000 ||
+ rate == 16000 ||
+ rate == 32000 ||
+ rate == 48000) {
+ audio_clock_freq_hz = AUDIO_SYS_CLOCK_98_304_000_HZ;
+ } else if (rate == 22050 ||
+ rate == 44100) {
+ audio_clock_freq_hz = AUDIO_SYS_CLOCK_90_300_000_HZ;
+ } else {
+ mp_raise_ValueError(MP_ERROR_TEXT("rate not supported"));
+ }
+
+ // is valid buf size ?
+ int32_t ring_buffer_len = args[ARG_ibuf].u_int;
+ if (ring_buffer_len < 0) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid ibuf"));
+ }
+
+ self->sck = pin_addr_by_name(args[ARG_sck].u_obj);
+ self->ws = pin_addr_by_name(args[ARG_ws].u_obj);
+ self->sd = pin_addr_by_name(args[ARG_sd].u_obj);
+ self->mode = i2s_mode;
+ self->bits = i2s_bits;
+ self->channel_resolution_bits = i2s_bits_resolution;
+ self->format = i2s_format;
+ self->rate = rate;
+ self->ibuf = ring_buffer_len;
+ self->callback_for_non_blocking = MP_OBJ_NULL;
+ self->io_mode = BLOCKING;
+ self->ring_buffer_storage = m_new(uint8_t, ring_buffer_len);
+
+ ringbuf_init(&self->ring_buffer, self->ring_buffer_storage, ring_buffer_len);
+ i2s_audio_clock_init(audio_clock_freq_hz);
+ i2s_init(self, &audio_clock);
+ i2s_dma_init(self);
+}
+
+static void mp_machine_i2s_deinit(machine_i2s_obj_t *self) {
+ cyhal_i2s_free(&self->i2s_obj);
+ MP_STATE_PORT(machine_i2s_obj[self->i2s_id]) = NULL;
+}
+
+static void mp_machine_i2s_irq_update(machine_i2s_obj_t *self) {
+ (void)self;
+}
+
+static machine_i2s_obj_t *mp_machine_i2s_make_new_instance(mp_int_t i2s_id) {
+ (void)i2s_id;
+ machine_i2s_obj_t *self = NULL;
+ for (uint8_t i = 0; i < MICROPY_HW_MAX_I2S; i++) {
+ if (MP_STATE_PORT(machine_i2s_obj[i]) == NULL) {
+ self = mp_obj_malloc(machine_i2s_obj_t, &machine_i2s_type);
+ MP_STATE_PORT(machine_i2s_obj[i]) = self;
+ self->i2s_id = i;
+ break;
+ }
+ }
+
+ if (self == NULL) {
+ mp_raise_ValueError(MP_ERROR_TEXT("all available i2s instances are allocated"));
+ }
+
+ return self;
+}
+
+MP_REGISTER_ROOT_POINTER(struct _machine_i2s_obj_t *machine_i2s_obj[MICROPY_HW_MAX_I2S]);
diff --git a/ports/psoc6/machine_pin.c b/ports/psoc6/machine_pin.c
new file mode 100644
index 0000000000000..fbfb1f73bc5b4
--- /dev/null
+++ b/ports/psoc6/machine_pin.c
@@ -0,0 +1,537 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// micropython includes
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "shared/runtime/mpirq.h"
+
+// port-specific includes
+#include "modmachine.h"
+#include "machine_pin_phy.h"
+#include "extmod/virtpin.h"
+#include "mplogger.h"
+#include "cyhal.h"
+
+enum {GPIO_MODE_NONE = 0, GPIO_MODE_IN, GPIO_MODE_OUT, GPIO_MODE_OPEN_DRAIN};
+
+enum {GPIO_PULL_NONE = 0, GPIO_PULL_UP, GPIO_PULL_DOWN};
+
+enum {GPIO_IRQ_LEVEL_NONE=0, GPIO_IRQ_FALLING, GPIO_IRQ_RISING, GPIO_IRQ_BOTH};
+
+typedef struct _machine_pin_io_obj_t {
+ mp_obj_base_t base;
+ uint32_t pin_addr;
+ uint8_t mode;
+ uint8_t drive;
+ uint8_t pull;
+ mp_obj_t callback;
+ cyhal_gpio_callback_data_t callback_data;
+} machine_pin_io_obj_t;
+
+
+machine_pin_io_obj_t *pin_io[MAX_IO_PINS] = {NULL};
+
+// helper function used by mphalport
+int pin_fetch_address(mp_obj_t pin) {
+ machine_pin_io_obj_t *self = MP_OBJ_TO_PTR(pin);
+ return self->pin_addr;
+}
+
+static inline machine_pin_io_obj_t *pin_io_allocate(mp_obj_t pin_name) {
+ uint32_t pin_addr = pin_addr_by_name(pin_name);
+ uint16_t i;
+ for (i = 0; i < machine_pin_num_of_cpu_pins; i++) {
+ if (pin_io[i] == NULL) {
+ break;
+ }
+ }
+ pin_io[i] = mp_obj_malloc(machine_pin_io_obj_t, &machine_pin_type);
+ pin_io[i]->pin_addr = pin_addr;
+
+ return pin_io[i];
+}
+
+static inline void pin_io_free(machine_pin_io_obj_t *pin) {
+ for (uint16_t i = 0; i < machine_pin_num_of_cpu_pins; i++) {
+ if (pin_io[i] == pin) {
+ pin_io[i] = NULL;
+ }
+ }
+}
+
+// Pin.print()
+static void machine_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ mplogger_print("machine pin print\n");
+
+ machine_pin_io_obj_t *self = self_in;
+
+ qstr mode_qstr;
+ switch (self->mode) {
+ case GPIO_MODE_IN:
+ mode_qstr = MP_QSTR_IN;
+ break;
+
+ case GPIO_MODE_OUT:
+ mode_qstr = MP_QSTR_OUT;
+ break;
+
+ case GPIO_MODE_OPEN_DRAIN:
+ mode_qstr = MP_QSTR_OPEN_DRAIN;
+ break;
+
+ case GPIO_MODE_NONE:
+ mode_qstr = MP_QSTR_None;
+ break;
+ }
+
+ qstr pull_qstr;
+ switch (self->pull) {
+ case GPIO_PULL_UP:
+ pull_qstr = MP_QSTR_PULL_UP;
+ break;
+
+ case GPIO_PULL_DOWN:
+ pull_qstr = MP_QSTR_PULL_DOWN;
+ break;
+
+ case GPIO_PULL_NONE:
+ pull_qstr = MP_QSTR_None;
+ break;
+ }
+
+ mp_printf(print, "Pin:%u or %s, Mode=%q, Pull=%q", self->pin_addr, mp_obj_str_get_str(pin_name_by_addr(mp_obj_new_int_from_uint(self->pin_addr))), mode_qstr, pull_qstr);
+}
+
+static cyhal_gpio_direction_t mp_to_cy_get_gpio_direction(uint8_t mode) {
+ cyhal_gpio_direction_t direction;
+
+ switch (mode) {
+ case GPIO_MODE_IN:
+ direction = CYHAL_GPIO_DIR_INPUT;
+ break;
+
+ case GPIO_MODE_OUT:
+ case GPIO_MODE_OPEN_DRAIN:
+ direction = CYHAL_GPIO_DIR_OUTPUT;
+ break;
+
+ case GPIO_MODE_NONE:
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("Pin mode is a required argument\n"));
+ break;
+ }
+ return direction;
+}
+
+static cyhal_gpio_drive_mode_t mp_to_cy_get_gpio_drive(uint8_t mode, uint8_t pull) {
+ cyhal_gpio_drive_mode_t cy_drive;
+
+ // drive modes explained here: https://community.infineon.com/t5/Knowledge-Base-Articles/Drive-Modes-in-PSoC-GPIO/ta-p/248470
+ // see app note: https://www.infineon.com/dgdl/Infineon-AN2094_PSoC_1_Getting_Started_With_GPIO-ApplicationNotes-v12_00-EN.pdf?fileId=8ac78c8c7cdc391c017d072966174e13&utm_source=cypress&utm_medium=referral&utm_campaign=202110_globe_en_all_integration-application_note
+
+ switch (mode) {
+ case GPIO_MODE_IN: {
+ // mpy_drive value is ignored. Only relevant for outputs.
+ switch (pull) {
+ case GPIO_PULL_UP:
+ cy_drive = CYHAL_GPIO_DRIVE_PULLUP;
+ break;
+
+ case GPIO_PULL_DOWN:
+ cy_drive = CYHAL_GPIO_DRIVE_PULLDOWN;
+ break;
+
+ case GPIO_PULL_NONE:
+ default:
+ cy_drive = CYHAL_GPIO_DRIVE_PULL_NONE;
+ break;
+ }
+ }
+ break;
+
+ case GPIO_MODE_OUT: {
+ switch (pull) {
+ case GPIO_PULL_UP:
+ cy_drive = CYHAL_GPIO_DRIVE_PULLUP;
+ break;
+
+ case GPIO_PULL_DOWN:
+ cy_drive = CYHAL_GPIO_DRIVE_PULLDOWN;
+ break;
+
+ case GPIO_PULL_NONE:
+ default:
+ // cyhal will set drive strong for output if PULL NONE.
+ cy_drive = CYHAL_GPIO_DRIVE_PULL_NONE;
+ break;
+ }
+ }
+ break;
+
+ case GPIO_MODE_OPEN_DRAIN:
+ // mpy_drive is ignored. Not relevant for open drain output.
+ // mpy_pull is ignored. Not configurable for open drain output.
+ cy_drive = CYHAL_GPIO_DRIVE_OPENDRAINDRIVESLOW;
+ break;
+ }
+
+ return cy_drive;
+}
+
+static cyhal_gpio_event_t mp_to_cy_get_interrupt_mode(uint8_t mode) {
+ cyhal_gpio_event_t event;
+ switch (mode) {
+ case GPIO_IRQ_FALLING:
+ event = CYHAL_GPIO_IRQ_FALL;
+ break;
+ case GPIO_IRQ_RISING:
+ event = CYHAL_GPIO_IRQ_RISE;
+ break;
+
+ case GPIO_IRQ_RISING | GPIO_IRQ_FALLING:
+ event = CYHAL_GPIO_IRQ_BOTH;
+ break;
+ }
+ return event;
+}
+
+static bool mp_get_gpio_dlf_value(uint8_t mode, uint8_t pull, int8_t value_arg) {
+ bool value;
+ switch (mode) {
+ case GPIO_MODE_IN: {
+ switch (pull) {
+ case GPIO_PULL_UP: {
+ if (value_arg == -1 || value_arg == 1) {
+ value = true;
+ } else {
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("machine pin error: Incompatible configuration. Input pull-up can not be initialized as low. \n"));
+ }
+ }
+ break;
+
+ case GPIO_PULL_DOWN: {
+ if (value_arg == -1 || value_arg == 0) {
+ value = false;
+ } else {
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("machine pin error: Incompatible configuration. Input pull-down can not be initialized as high. \n"));
+ }
+ }
+ break;
+
+ case GPIO_PULL_NONE:
+ default: {
+ // Value is undefined.
+ value = false;
+ if (value_arg != -1) {
+ mp_printf(&mp_plat_print, "machine.Pin: Initial value is undefined for input pull-none configuration.\n");
+ }
+ }
+ break;
+ }
+ }
+ break;
+
+ case GPIO_MODE_OUT:
+ case GPIO_MODE_OPEN_DRAIN: {
+ // No conflicts with pull-up/down for output mode.
+ if (value_arg == 0) {
+ value = false;
+ } else if (value_arg == 1) {
+ value = true;
+ } else {
+ switch (pull) {
+ case GPIO_PULL_UP:
+ value = true;
+ break;
+
+ case GPIO_PULL_DOWN:
+ case GPIO_PULL_NONE:
+ value = false;
+ break;
+ }
+ }
+ }
+ break;
+ }
+
+ return value;
+}
+
+static void gpio_interrupt_handler(void *handler_arg, cyhal_gpio_event_t event) {
+ machine_pin_io_obj_t *self = handler_arg;
+ mp_sched_schedule(self->callback, MP_OBJ_FROM_PTR(self));
+}
+
+static bool machine_pin_is_inited(machine_pin_io_obj_t *self) {
+ // The mode is a mandatory argument for initialization
+ // Thus, if other than NONE, the cyhal_gpio object is already initialized.
+ if (self->mode != GPIO_MODE_NONE) {
+ return true;
+ }
+ return false;
+}
+
+// helper function to parse given initial params and invoke HAL-level GPIO functions
+static mp_obj_t machine_pin_obj_init_helper(machine_pin_io_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ mplogger_print("init helper function called\n");
+
+ enum {ARG_mode, ARG_pull, ARG_value};
+ static const mp_arg_t allowed_args[] = {
+ {MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE}},
+ {MP_QSTR_pull, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE}},
+ {MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE}}
+ };
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ bool pin_already_inited = machine_pin_is_inited(self);
+
+ int8_t value_arg = -1;
+ if (args[ARG_value].u_obj != mp_const_none) {
+ value_arg = mp_obj_is_true(args[ARG_value].u_obj);
+ }
+
+ self->mode = GPIO_MODE_NONE;
+ if (args[ARG_mode].u_obj != mp_const_none) {
+ self->mode = mp_obj_get_int(args[ARG_mode].u_obj);
+ }
+
+ self->pull = GPIO_PULL_NONE;
+ if (args[ARG_pull].u_obj != mp_const_none) {
+ self->pull = mp_obj_get_int(args[ARG_pull].u_obj);
+ }
+
+ cyhal_gpio_direction_t direction = mp_to_cy_get_gpio_direction(self->mode);
+ cyhal_gpio_drive_mode_t drive = mp_to_cy_get_gpio_drive(self->mode, self->pull);
+ bool value = mp_get_gpio_dlf_value(self->mode, self->pull, value_arg);
+
+ cy_rslt_t result = CY_RSLT_SUCCESS;
+ if (pin_already_inited) {
+ result = cyhal_gpio_configure(self->pin_addr, direction, drive);
+ } else {
+ result = cyhal_gpio_init(self->pin_addr, direction, drive, value);
+ }
+ mplogger_print("Direction: %d, Drive:%d, Value:%d\n", direction, drive, value);
+
+ if (result != CY_RSLT_SUCCESS) {
+ assert_pin_phy_used(result);
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("machine pin error: Init unsuccessful\n"));
+ }
+ return mp_const_none;
+}
+
+// Machine Pin methods - port-specific definitions
+// Pin constructor(id,mode,pull,value=value)
+mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+ mplogger_print("%q constructor invoked\n", MP_QSTR_Pin);
+
+ mp_arg_check_num(n_args, n_kw, 1, 6, true);
+
+ machine_pin_io_obj_t *self = pin_io_allocate(args[0]);
+ if (self == NULL) {
+ return mp_const_none;
+ }
+
+ // go into param arg parsing if args apart from "id" are provided (for ex. pin.Mode, pin.PULL etc)
+ if (n_args > 1 || n_kw > 0) {
+ // pin mode given, so configure this GPIO
+ mp_map_t kw_args;
+ mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+ machine_pin_obj_init_helper(self, n_args - 1, args + 1, &kw_args); // skipping "id" as an arg as it is a part of self*.
+ }
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t machine_pin_call(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+
+ mp_arg_check_num(n_args, n_kw, 0, 1, false);
+ machine_pin_io_obj_t *self = self_in;
+
+ if (n_args == 0) {
+ if (self->mode == GPIO_MODE_IN) {
+ return MP_OBJ_NEW_SMALL_INT(cyhal_gpio_read(self->pin_addr));
+ } else {
+ return mp_const_none;
+ }
+ } else {
+ if (self->mode != GPIO_MODE_IN) {
+ bool value = mp_obj_is_true(args[0]);
+ cyhal_gpio_write(self->pin_addr, value);
+ }
+ }
+
+ return mp_const_none;
+}
+
+// pin.value([value])
+static mp_obj_t machine_pin_value(size_t n_args, const mp_obj_t *args) {
+ return machine_pin_call(args[0], n_args - 1, 0, args + 1);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pin_value_obj, 1, 2, machine_pin_value);
+
+// instantiates obj of Pin class
+// Pin.init(mode,pull,value=value)
+static mp_obj_t machine_pin_obj_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+ return machine_pin_obj_init_helper(args[0], n_args - 1, args + 1, kw_args);
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_obj_init_obj, 1, machine_pin_obj_init);
+
+// Pin.deinit()
+static mp_obj_t machine_pin_obj_deinit(mp_obj_t self_in) {
+ machine_pin_io_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ cyhal_gpio_free(self->pin_addr);
+ pin_io_free(self);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_deinit_obj, machine_pin_obj_deinit);
+
+// Pin.toggle()
+static mp_obj_t machine_pin_toggle(mp_obj_t self_in) {
+ machine_pin_io_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ if (self->mode != GPIO_MODE_IN) {
+ cyhal_gpio_toggle(self->pin_addr);
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_toggle_obj, machine_pin_toggle);
+
+// Pin.high()
+static mp_obj_t machine_pin_high(mp_obj_t self_in) {
+ machine_pin_io_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ if (self->mode != GPIO_MODE_IN) {
+ cyhal_gpio_write(self->pin_addr, true);
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_high_obj, machine_pin_high);
+
+// Pin.low()
+static mp_obj_t machine_pin_low(mp_obj_t self_in) {
+ machine_pin_io_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ if (self->mode != GPIO_MODE_IN) {
+ cyhal_gpio_write(self->pin_addr, false);
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_low_obj, machine_pin_low);
+
+// pin.irq(handler=None, trigger=IRQ_FALLING|IRQ_RISING)
+static mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ enum { ARG_handler, ARG_trigger};
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_handler, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_trigger, MP_ARG_INT, {.u_int = GPIO_IRQ_RISING | GPIO_IRQ_FALLING }},
+ };
+
+ machine_pin_io_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+ if (n_args > 1 || kw_args->used != 0) {
+ // Update IRQ data.
+ self->callback = args[ARG_handler].u_obj;
+ mp_uint_t trigger = args[ARG_trigger].u_int;
+
+ cyhal_gpio_event_t event = mp_to_cy_get_interrupt_mode(trigger);
+ self->callback_data.callback = gpio_interrupt_handler;
+ self->callback_data.callback_arg = self;
+ cyhal_gpio_register_callback(self->pin_addr, &(self->callback_data));
+ cyhal_gpio_enable_event(self->pin_addr, event, 3, true);
+ }
+ return MP_OBJ_FROM_PTR(&(self->callback_data));
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_irq_obj, 1, machine_pin_irq);
+
+void mod_pin_deinit() {
+ for (uint8_t i = 0; i < machine_pin_num_of_cpu_pins; i++) {
+ if (pin_io[i] != NULL) {
+ machine_pin_obj_deinit(pin_io[i]);
+ }
+ }
+}
+
+static const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
+ // Instance methods
+ { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_machine) },
+ { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_pin_obj_init_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_pin_deinit_obj) },
+ { MP_ROM_QSTR(MP_QSTR_toggle), MP_ROM_PTR(&machine_pin_toggle_obj) },
+ { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_pin_value_obj) },
+ { MP_ROM_QSTR(MP_QSTR_low), MP_ROM_PTR(&machine_pin_low_obj) },
+ { MP_ROM_QSTR(MP_QSTR_high), MP_ROM_PTR(&machine_pin_high_obj) },
+ { MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&machine_pin_low_obj) },
+ { MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&machine_pin_high_obj) },
+ { MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_pin_irq_obj) },
+ { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_pin_deinit_obj) },
+
+ // Const
+ { MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(GPIO_MODE_IN) },
+ { MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(GPIO_MODE_OUT) },
+ { MP_ROM_QSTR(MP_QSTR_OPEN_DRAIN), MP_ROM_INT(GPIO_MODE_OPEN_DRAIN) },
+
+ { MP_ROM_QSTR(MP_QSTR_PULL_UP), MP_ROM_INT(GPIO_PULL_UP) },
+ { MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PULL_DOWN) },
+
+ { MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(GPIO_IRQ_FALLING)},
+ { MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(GPIO_IRQ_RISING)},
+};
+static MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
+
+static mp_uint_t pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+ (void)errcode;
+ machine_pin_io_obj_t *self = self_in;
+ switch (request) {
+ case MP_PIN_READ: {
+ return cyhal_gpio_read(self->pin_addr);
+ }
+ case MP_PIN_WRITE: {
+ cyhal_gpio_write(self->pin_addr, arg);
+ return 0;
+ }
+ }
+ return -1;
+}
+
+static const mp_pin_p_t pin_pin_p = {
+ .ioctl = pin_ioctl,
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_pin_type,
+ MP_QSTR_Pin,
+ MP_TYPE_FLAG_NONE,
+ make_new, mp_pin_make_new,
+ print, machine_pin_print,
+ call, machine_pin_call,
+ protocol, &pin_pin_p,
+ locals_dict, &machine_pin_locals_dict
+ );
+
+MP_REGISTER_ROOT_POINTER(void *machine_pin_irq_obj[MAX_IO_PINS]);
diff --git a/ports/psoc6/machine_pin_phy.c b/ports/psoc6/machine_pin_phy.c
new file mode 100644
index 0000000000000..2cc2689514c14
--- /dev/null
+++ b/ports/psoc6/machine_pin_phy.c
@@ -0,0 +1,92 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mphal.h"
+#include "machine_pin_phy.h"
+
+
+// Function definitions
+// helper function to translate pin_name(string) into machine_pin_io_obj_t index.
+int pin_find(mp_obj_t pin) {
+ int wanted_pin = -1;
+ if (mp_obj_is_small_int(pin)) {
+ int pin_addr = mp_obj_get_int(pin);
+ for (int i = 0; i < machine_pin_num_of_cpu_pins; i++) {
+ if (machine_pin_phy_obj[i].addr == pin_addr) {
+ wanted_pin = i;
+ break;
+ }
+ }
+ } else if (mp_obj_is_str(pin)) {
+ // Search by name
+ size_t slen;
+ const char *s = mp_obj_str_get_data(pin, &slen);
+ for (int i = 0; i < machine_pin_num_of_cpu_pins; i++) {
+ if (slen == strlen(machine_pin_phy_obj[i].name) && strncmp(s, machine_pin_phy_obj[i].name, slen) == 0) {
+ wanted_pin = i;
+ break;
+ }
+ }
+ }
+
+ if (!(0 <= wanted_pin && wanted_pin < machine_pin_num_of_cpu_pins)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid pin: Pin not defined!"));
+ }
+
+ return wanted_pin;
+}
+
+mp_obj_t pin_name_by_addr(mp_obj_t pin) {
+ if (mp_obj_is_int(pin)) {
+ const char *name = machine_pin_phy_obj[pin_find(pin)].name;
+ return mp_obj_new_str(name, strlen(name));
+ } else {
+ return NULL; // expecting a int as input
+ }
+}
+
+// helper function to translate pin_name(string) into machine_pin_io_obj_t->pin_addr or pin_obj to machine_pin_io_obj_t->pin_addr
+int pin_addr_by_name(mp_obj_t pin) {
+ if (mp_obj_is_str(pin)) {
+ return machine_pin_phy_obj[pin_find(pin)].addr;
+ } else {
+ return pin_fetch_address(pin);
+ }
+}
+
+#define pin_phy_assert_null(x) { if (x == NULL) { return NULL; } }
+
+machine_pin_phy_obj_t *pin_phy_find_by_name(mp_obj_t pin_name) {
+ size_t slen;
+ const char *s = mp_obj_str_get_data(pin_name, &slen);
+ for (int i = 0; i < machine_pin_num_of_cpu_pins; i++) {
+ if (slen == strlen(machine_pin_phy_obj[i].name) && strncmp(s, machine_pin_phy_obj[i].name, slen) == 0) {
+ return &machine_pin_phy_obj[i];
+ }
+ }
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid pin: Pin not defined!"));
+ return NULL;
+}
diff --git a/ports/psoc6/machine_pin_phy.h b/ports/psoc6/machine_pin_phy.h
new file mode 100644
index 0000000000000..e528255806df1
--- /dev/null
+++ b/ports/psoc6/machine_pin_phy.h
@@ -0,0 +1,65 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_MACHINE_PIN_PHY_H
+#define MICROPY_INCLUDED_MACHINE_PIN_PHY_H
+
+#include
+#include "genhdr/pins.h"
+
+#define PIN_PHY_GPIO_IN_USE_GENERAL_ERROR 0x4020d01
+#define PIN_PHY_I2C_IN_USE_ERROR 0x4020900
+#define PIN_PHY_SPI_IN_USE_ERROR 0x4021907
+#define PIN_PHY_UART_IN_USE_ERROR 0x4021f00
+
+#define assert_pin_phy_used(ret) { \
+ switch (ret) { \
+ case PIN_PHY_GPIO_IN_USE_GENERAL_ERROR: \
+ case PIN_PHY_I2C_IN_USE_ERROR: \
+ case PIN_PHY_SPI_IN_USE_ERROR: \
+ case PIN_PHY_UART_IN_USE_ERROR: \
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("The chosen pin(s) might be already in use by another machine instance.")); \
+ break; \
+ } \
+}
+
+typedef struct _machine_pin_phy_obj_t {
+ uint32_t addr;
+ char *name;
+} machine_pin_phy_obj_t;
+
+extern machine_pin_phy_obj_t machine_pin_phy_obj[];
+
+extern const uint8_t machine_pin_num_of_cpu_pins;
+
+int pin_fetch_address(mp_obj_t pin); // function to support the bitstream class (obj to pin address)
+
+// Function Prototypes to support interaction between c<->py
+int pin_find(mp_obj_t obj);
+mp_obj_t pin_name_by_addr(mp_obj_t pin);
+int pin_addr_by_name(mp_obj_t obj);
+
+#endif // MICROPY_INCLUDED_MACHINE_PIN_PHY_H
diff --git a/ports/psoc6/machine_pwm.c b/ports/psoc6/machine_pwm.c
new file mode 100644
index 0000000000000..9c6a04475c500
--- /dev/null
+++ b/ports/psoc6/machine_pwm.c
@@ -0,0 +1,231 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "modmachine.h"
+
+// port-specific includes
+#include "machine_pin_phy.h"
+#include "mplogger.h"
+
+typedef struct _machine_pwm_obj_t {
+ mp_obj_base_t base;
+ cyhal_pwm_t pwm_obj;
+ uint32_t pin;
+ uint32_t fz;
+ uint8_t duty_type;
+ mp_int_t duty;
+ // bool invert;
+} machine_pwm_obj_t;
+
+static machine_pwm_obj_t *pwm_obj[MAX_PWM_OBJS] = { NULL };
+
+static inline machine_pwm_obj_t *pwm_obj_alloc() {
+ for (uint8_t i = 0; i < MAX_PWM_OBJS; i++)
+ {
+ if (pwm_obj[i] == NULL) {
+ pwm_obj[i] = mp_obj_malloc(machine_pwm_obj_t, &machine_pwm_type);
+ return pwm_obj[i];
+ }
+ }
+
+ return NULL;
+}
+
+static inline void pwm_obj_free(machine_pwm_obj_t *pwm_obj_ptr) {
+ for (uint8_t i = 0; i < MAX_PWM_OBJS; i++)
+ {
+ if (pwm_obj[i] == pwm_obj_ptr) {
+ pwm_obj[i] = NULL;
+ }
+ }
+}
+
+enum {
+ VALUE_NOT_SET = -1,
+ DUTY_NOT_SET = 0,
+ DUTY_U16,
+ DUTY_NS
+};
+
+static void mp_machine_pwm_freq_set(machine_pwm_obj_t *self, mp_int_t freq);
+
+static cy_rslt_t pwm_freq_duty_set(cyhal_pwm_t *pwm_obj, uint32_t fz, float duty_cycle) {
+ return cyhal_pwm_set_duty_cycle(pwm_obj, duty_cycle * 100, fz); // duty_cycle in percentage
+}
+
+static inline cy_rslt_t pwm_duty_set_ns(cyhal_pwm_t *pwm_obj, uint32_t fz, uint32_t pulse_width) {
+ return cyhal_pwm_set_period(pwm_obj, 1000000 / fz, pulse_width / 1000); // !# * --> /
+}
+
+/*STATIC inline cy_rslt_t pwm_advanced_init(machine_pwm_obj_t *machine_pwm_obj) {
+ return cyhal_pwm_init_adv(&machine_pwm_obj->pwm_obj, machine_pwm_obj->pin, NC, CYHAL_PWM_LEFT_ALIGN, true, 0, true, NULL); // complimentary pin set as not connected
+}*/
+
+static void mp_machine_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "frequency=%u duty_cycle=%f", self->fz, (double)self->duty);
+}
+
+static void mp_machine_pwm_init_helper(machine_pwm_obj_t *self,
+ size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ enum { ARG_freq, ARG_duty_u16, ARG_duty_ns};
+ // enum { ARG_freq, ARG_duty_u16, ARG_duty_ns, ARG_invert };
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_freq, MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
+ { MP_QSTR_duty_u16, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
+ { MP_QSTR_duty_ns, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
+ // { MP_QSTR_invert, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
+ };
+
+ // Parse the arguments.
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args, pos_args, kw_args,
+ MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+ // self->active = 1;
+
+ if ((args[ARG_freq].u_int != VALUE_NOT_SET)) {
+ // pwm_freq_duty_set(&self->pwm_obj, args[ARG_freq].u_int, self->duty);
+ self->fz = args[ARG_freq].u_int;
+ }
+
+ if ((args[ARG_duty_u16].u_int != VALUE_NOT_SET)) {
+ float val = (float)(args[ARG_duty_u16].u_int) / (float)65535;
+ pwm_freq_duty_set(&self->pwm_obj, self->fz, val);
+ self->duty = args[ARG_duty_u16].u_int;
+ self->duty_type = DUTY_U16;
+ }
+
+ if (args[ARG_duty_ns].u_int != VALUE_NOT_SET) {
+ pwm_duty_set_ns(&self->pwm_obj, self->fz, args[ARG_duty_ns].u_int);
+ self->duty = args[ARG_duty_ns].u_int;
+ self->duty_type = DUTY_NS;
+ }
+
+ // inverts the respective output if the value is True
+ /*if (args[ARG_invert].u_int != VALUE_NOT_SET) {
+ self->invert = args[ARG_invert].u_int;
+ if (self->invert == 1) {
+ cyhal_pwm_free(&self->pwm_obj);
+ cy_rslt_t result = pwm_advanced_init(self);
+ if (result != CY_RSLT_SUCCESS) {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM initialisation failed with return code %lx ! and invert output is not available"), result);
+ }
+ self->duty_type = DUTY_U16;
+ self->duty = ((1) - ((self->duty) / 65535)) * 65535;
+ }
+ }*/
+ cyhal_pwm_start(&self->pwm_obj);
+}
+
+static mp_obj_t mp_machine_pwm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ // Check number of arguments
+ mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+ // Get static peripheral object.
+ machine_pwm_obj_t *self = pwm_obj_alloc();
+ self->pin = pin_addr_by_name(all_args[0]);
+ self->duty_type = DUTY_NOT_SET;
+ self->fz = -1;
+ // self->invert = -1;
+
+ // Initialize PWM
+ cy_rslt_t result = cyhal_pwm_init(&self->pwm_obj, self->pin, NULL);
+
+ // To check whether PWM init is successful
+ if (result != CY_RSLT_SUCCESS) {
+ assert_pin_phy_used(result);
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM initialisation failed with return code %lx !"), result);
+ }
+
+ // Process the remaining parameters.
+ mp_map_t kw_args;
+ mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+ mp_machine_pwm_init_helper(self, n_args - 1, all_args + 1, &kw_args);
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static void mp_machine_pwm_deinit(machine_pwm_obj_t *self) {
+ cyhal_pwm_stop(&self->pwm_obj);
+ cyhal_pwm_free(&self->pwm_obj);
+ pwm_obj_free(self);
+}
+
+static mp_obj_t mp_machine_pwm_duty_get_u16(machine_pwm_obj_t *self) {
+ if (self->duty_type == DUTY_NS) {
+ // duty_cycle = pulsewidth(ns)*freq(hz);
+ return mp_obj_new_float(((self->duty) * (self->fz) * 65535) / 1000000000 - 1);
+ } else {
+ return mp_obj_new_float(self->duty);
+ }
+}
+
+// sets the duty cycle as a ratio duty_u16 / 65535.
+static void mp_machine_pwm_duty_set_u16(machine_pwm_obj_t *self, mp_int_t duty_u16) {
+ // Check the value is more than the max value
+ self->duty = duty_u16 > 65535 ? 65535 : duty_u16;
+ self->duty_type = DUTY_U16;
+ pwm_freq_duty_set(&self->pwm_obj, self->fz, (float)(self->duty) / (float)65535); // s conversion of duty_u16 into dutyu16/65535
+}
+
+static mp_obj_t mp_machine_pwm_duty_get_ns(machine_pwm_obj_t *self) {
+ if (self->duty_type == DUTY_U16) {
+ return mp_obj_new_float(((self->duty) * 1000000000) / ((self->fz) * 65535)); // pw (ns) = duty_cycle*10^9/fz
+ } else {
+ return mp_obj_new_float(self->duty);
+ }
+}
+
+// sets the pulse width in nanoseconds
+static void mp_machine_pwm_duty_set_ns(machine_pwm_obj_t *self, mp_int_t duty_ns) {
+ self->duty = duty_ns;
+ self->duty_type = DUTY_NS;
+ pwm_duty_set_ns(&self->pwm_obj, self->fz, duty_ns);
+}
+
+static mp_obj_t mp_machine_pwm_freq_get(machine_pwm_obj_t *self) {
+ return MP_OBJ_NEW_SMALL_INT(self->fz);
+
+}
+
+static void mp_machine_pwm_freq_set(machine_pwm_obj_t *self, mp_int_t freq) {
+ self->fz = freq;
+ pwm_freq_duty_set(&self->pwm_obj, freq, self->duty);
+ if (self->duty_type == DUTY_NS) {
+ self->duty = ((self->duty) * (self->fz) * 65535) / 1000000000;
+ mp_machine_pwm_duty_set_ns(self, self->duty);
+ }
+}
+
+void mod_pwm_deinit() {
+ for (uint8_t i = 0; i < MAX_PWM_OBJS; i++) {
+ if (pwm_obj[i] != NULL) {
+ mp_machine_pwm_deinit(pwm_obj[i]);
+ }
+ }
+}
diff --git a/ports/psoc6/machine_rtc.c b/ports/psoc6/machine_rtc.c
new file mode 100644
index 0000000000000..350ca1bd2342e
--- /dev/null
+++ b/ports/psoc6/machine_rtc.c
@@ -0,0 +1,397 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 "Krzysztof Adamski"
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+#include
+#include
+#include
+#include
+
+
+// micropython includes
+#include "py/nlr.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "py/mperrno.h"
+#include "shared/timeutils/timeutils.h"
+#include "py/misc.h"
+
+
+// MTB includes
+#include "cyhal.h"
+
+
+// port-specific includes
+#include "modmachine.h"
+
+/* The values are reflected to match MPY reset values*/
+#define RTC_INIT_YEAR 2015
+#define RTC_INIT_MONTH 1 /* January */
+#define RTC_INIT_MDAY 1
+#define RTC_INIT_WDAY 4 /* Thursday */
+#define RTC_INIT_HOUR 0
+#define RTC_INIT_MINUTE 0
+#define RTC_INIT_SECOND 0
+#define RTC_INIT_DST 0
+#define TM_YEAR_BASE (1900u)
+
+#define rtc_assert_raise(msg, ret) if (ret != CY_RSLT_SUCCESS) { \
+ mp_raise_ValueError(MP_ERROR_TEXT(msg)); \
+}
+
+
+cyhal_rtc_t psoc6_rtc;
+static bool rtc_memory = false;
+
+typedef struct _machine_rtc_obj_t {
+ mp_obj_base_t base;
+ mp_obj_t callback;
+ mp_obj_t alarm_period_s;
+ mp_obj_t alarm_elapse_time_s;
+ bool alarmset;
+ bool repeat;
+} machine_rtc_obj_t;
+
+// singleton RTC object
+static machine_rtc_obj_t machine_rtc_obj = {.base = {&machine_rtc_type}};
+
+bool rtc_memory_write_enabled() {
+ return rtc_memory;
+}
+
+/* This function is run from main.c to init the RTC at boot time. This will set the RTC to PSoC default time: 1st Jan 2000*/
+void mod_rtc_init(void) {
+ cy_rslt_t result = cyhal_rtc_init(&psoc6_rtc);
+ rtc_assert_raise("cyhal_rtc_init failed !", result);
+}
+
+void mod_rtc_deinit() {
+ if (rtc_memory_write_enabled() == false) {
+ cyhal_rtc_free(&psoc6_rtc);
+ }
+}
+
+// Helper function to set/get datetime
+static mp_obj_t machine_rtc_datetime_helper(mp_uint_t n_args, const mp_obj_t *args) {
+ struct tm current_date_time;
+ if (n_args == 1) {
+ cy_rslt_t result = cyhal_rtc_read(&psoc6_rtc, ¤t_date_time);
+ rtc_assert_raise("cyhal_rtc_read failed !", result);
+
+ mp_obj_t tuple[8] = {
+ mp_obj_new_int(current_date_time.tm_year + TM_YEAR_BASE),
+ mp_obj_new_int(current_date_time.tm_mon + 1),
+ mp_obj_new_int(current_date_time.tm_mday),
+ mp_obj_new_int(current_date_time.tm_wday),
+ mp_obj_new_int(current_date_time.tm_hour),
+ mp_obj_new_int(current_date_time.tm_min),
+ mp_obj_new_int(current_date_time.tm_sec),
+ mp_obj_new_int(0)
+ };
+ return mp_obj_new_tuple(8, tuple);
+ } else {
+ mp_obj_t *items;
+ mp_obj_get_array_fixed_n(args[1], 8, &items);
+
+ current_date_time.tm_year = mp_obj_get_int(items[0]) - TM_YEAR_BASE;
+ current_date_time.tm_mon = mp_obj_get_int(items[1]) - 1;
+ current_date_time.tm_mday = mp_obj_get_int(items[2]);
+ current_date_time.tm_wday = mp_obj_get_int(items[3]);
+ current_date_time.tm_hour = mp_obj_get_int(items[4]);
+ current_date_time.tm_min = mp_obj_get_int(items[5]);
+ current_date_time.tm_sec = mp_obj_get_int(items[6]);
+
+ cy_rslt_t result = cyhal_rtc_write(&psoc6_rtc, ¤t_date_time);
+ rtc_assert_raise("cyhal_rtc_write failed ! Check if field values entered are within the specified range.", result);
+ }
+ return mp_const_none;
+}
+
+static inline uint64_t rtc_get_datetime_in_sec(mp_obj_t datetime) {
+ size_t len;
+ mp_obj_t *elem;
+ mp_obj_get_array(datetime, &len, &elem);
+
+ // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
+ if (len < 8 || len > 9) {
+ mp_raise_TypeError(MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9"));
+ }
+
+ return timeutils_mktime(mp_obj_get_int(elem[0]),
+ mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
+ mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5]));
+
+}
+
+static inline uint64_t rtc_get_current_time_in_sec() {
+ mp_obj_t datetime = machine_rtc_datetime_helper(1, NULL);
+
+ size_t len;
+ mp_obj_t *elem;
+ mp_obj_get_array(datetime, &len, &elem);
+
+ // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
+ if (len < 8 || len > 9) {
+ mp_raise_TypeError(MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9"));
+ }
+
+ return timeutils_mktime(mp_obj_get_int(elem[0]),
+ mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[4]),
+ mp_obj_get_int(elem[5]), mp_obj_get_int(elem[6]));
+
+}
+
+static void rtc_irq_handler(void *self, cyhal_rtc_event_t event);
+
+static void rtc_alarm_setup(machine_rtc_obj_t *self) {
+ cyhal_rtc_set_alarm_by_seconds(&psoc6_rtc, mp_obj_get_int(self->alarm_period_s));
+ cyhal_rtc_register_callback(&psoc6_rtc, (cyhal_rtc_event_callback_t)rtc_irq_handler, self);
+ cyhal_rtc_enable_event(&psoc6_rtc, CYHAL_RTC_ALARM, 3, true);
+}
+
+void rtc_irq_handler(void *self_in, cyhal_rtc_event_t event) {
+ machine_rtc_obj_t *self = (machine_rtc_obj_t *)self_in;
+ if (self->callback != NULL) {
+ if (self->repeat) {
+ rtc_alarm_setup(self);
+ }
+ mp_call_function_1((mp_obj_t)self->callback, mp_obj_new_int(event));
+ }
+}
+
+static inline void rtc_get_dtime_struct(const mp_obj_t datetime, struct tm *dtime) {
+ // set date and time
+ mp_obj_t *items;
+ size_t len;
+ mp_obj_get_array(datetime, &len, &items);
+
+ dtime->tm_sec = mp_obj_get_int(items[5]);
+ dtime->tm_min = mp_obj_get_int(items[4]);
+ dtime->tm_hour = mp_obj_get_int(items[3]);
+ dtime->tm_mday = mp_obj_get_int(items[2]);
+ dtime->tm_mon = mp_obj_get_int(items[1]) - 1;
+ dtime->tm_year = mp_obj_get_int(items[0]) - TM_YEAR_BASE;
+ dtime->tm_wday = 0;
+ dtime->tm_yday = 0;
+ dtime->tm_isdst = 0;
+
+}
+
+/******************************************************************************/
+// MicroPython bindings
+
+// RTC constructor
+static mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+ mp_arg_check_num(n_args, n_kw, 0, 0, false);
+ return (mp_obj_t)&machine_rtc_obj;
+}
+
+// RTC.init(datetime)
+static mp_obj_t machine_rtc_init(mp_obj_t self_in, mp_obj_t datetime) {
+ machine_rtc_obj_t *self = (machine_rtc_obj_t *)self_in;
+ self->alarm_elapse_time_s = NULL;
+ self->alarm_period_s = NULL;
+ self->alarmset = false;
+ self->callback = NULL;
+ self->repeat = false;
+
+ mp_obj_t args[2] = {self_in, datetime};
+ machine_rtc_datetime_helper(2, args);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(machine_rtc_init_obj, machine_rtc_init);
+
+// RTC.datetime([datetime])
+static mp_obj_t machine_rtc_datetime(mp_uint_t n_args, const mp_obj_t *datetime) {
+ return machine_rtc_datetime_helper(n_args, datetime);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_datetime_obj, 1, 2, machine_rtc_datetime);
+
+// RTC.deinit()
+static mp_obj_t machine_rtc_deinit(mp_obj_t self_in) {
+ /* Resets RTC to 1st Jan' 2015 as mentioned in MPY guide*/
+ struct tm reset_date_time = {
+ .tm_year = RTC_INIT_YEAR - TM_YEAR_BASE,
+ .tm_mon = RTC_INIT_MONTH - 1,
+ .tm_mday = RTC_INIT_MDAY,
+ .tm_wday = RTC_INIT_WDAY,
+ .tm_hour = RTC_INIT_HOUR,
+ .tm_min = RTC_INIT_MINUTE,
+ .tm_sec = RTC_INIT_SECOND,
+ .tm_isdst = RTC_INIT_DST
+ };
+ cy_rslt_t result = cyhal_rtc_write(&psoc6_rtc, &reset_date_time);
+ rtc_assert_raise("cyhal_rtc_write failed during RTC deinitialization!", result);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_rtc_deinit_obj, machine_rtc_deinit);
+
+// RTC.now()
+static mp_obj_t machine_rtc_now(mp_obj_t self_in) {
+ return machine_rtc_datetime_helper(1, NULL);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_rtc_now_obj, machine_rtc_now);
+
+// RTC.alarm()
+static mp_obj_t machine_rtc_alarm(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_time, MP_ARG_OBJ, {.u_obj = mp_const_none} },
+ { MP_QSTR_repeat, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+ };
+
+ // parse args
+ uint64_t dtime_sec;
+ machine_rtc_obj_t *self = pos_args[0];
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), allowed_args, args);
+
+ uint64_t alarm_set_time_s = rtc_get_current_time_in_sec();
+
+ self->repeat = args[1].u_bool;
+ if (mp_obj_is_type(args[0].u_obj, &mp_type_tuple)) { // datetime tuple given
+ // repeat cannot be used with a datetime tuple
+ if (self->repeat) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
+ }
+ struct tm dtime;
+ cyhal_alarm_active_t alarm_active =
+ {
+ .en_sec = 1,
+ .en_min = 1,
+ .en_hour = 1,
+ .en_day = 0,
+ .en_date = 1,
+ .en_month = 1,
+ };
+ dtime_sec = rtc_get_datetime_in_sec(args[0].u_obj);
+ self->alarm_period_s = mp_obj_new_int_from_uint(dtime_sec - alarm_set_time_s);
+ rtc_get_dtime_struct(args[0].u_obj, &dtime);
+ cyhal_rtc_set_alarm(&psoc6_rtc, &dtime, alarm_active);
+ } else { // then it must be an integer
+ self->alarm_period_s = mp_obj_new_int_from_uint(mp_obj_get_int(args[0].u_obj) / 1000);
+ rtc_alarm_setup(self);
+ }
+ self->alarm_elapse_time_s = mp_obj_new_int_from_uint(alarm_set_time_s + mp_obj_get_int(self->alarm_period_s));
+ self->alarmset = true;
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_rtc_alarm_obj, 1, machine_rtc_alarm);
+
+// RTC.alarm_left()
+static mp_obj_t machine_rtc_alarm_left(size_t n_args, const mp_obj_t *args) {
+ machine_rtc_obj_t *self = args[0];
+ // only alarm id 0 is available
+ if (n_args > 1 && mp_obj_get_int(args[1]) != CYHAL_RTC_ALARM) {
+ mp_raise_OSError(MP_ENODEV);
+ }
+ if (self->alarmset) {
+ uint64_t curr_time = rtc_get_current_time_in_sec();
+ return mp_obj_new_int_from_uint((mp_obj_get_int(self->alarm_elapse_time_s) >= curr_time) ? ((mp_obj_get_int(self->alarm_elapse_time_s) - curr_time) * 1000) : 0);
+ }
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Alarm not set! \n"));
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_alarm_left_obj, 1, 2, machine_rtc_alarm_left);
+
+// RTC.cancel()
+static mp_obj_t machine_rtc_cancel(size_t n_args, const mp_obj_t *args) {
+ // only alarm id 0 is available
+ if (n_args > 1 && mp_obj_get_int(args[1]) != CYHAL_RTC_ALARM) {
+ mp_raise_OSError(MP_ENODEV);
+ }
+ // disable the alarm
+ machine_rtc_obj_t *self = args[0];
+ self->alarmset = false;
+ cyhal_rtc_enable_event(&psoc6_rtc, CYHAL_RTC_ALARM, 3, false);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_alarm_cancel_obj, 1, 2, machine_rtc_cancel);
+
+// RTC.memory()
+static mp_obj_t machine_rtc_memory(size_t n_args, const mp_obj_t *args) {
+ rtc_memory = true;
+ return machine_rtc_datetime_helper(n_args, args);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_memory_obj, 1, 2, machine_rtc_memory);
+
+// RTC.irq()
+static mp_obj_t machine_rtc_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ enum { ARG_trigger, ARG_handler, ARG_wake};
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_trigger, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = CYHAL_RTC_ALARM} },
+ { MP_QSTR_handler, MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_wake, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} }
+ };
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+ machine_rtc_obj_t *self = pos_args[0];
+
+ self->callback = args[ARG_handler].u_obj;
+ if (args[ARG_handler].u_obj == mp_const_none) {
+ self->callback = NULL;
+ }
+
+ if (args[ARG_trigger].u_int != CYHAL_RTC_ALARM) {
+ mp_raise_OSError(MP_ENODEV);
+ }
+
+ if (args[ARG_wake].u_int != -1) {
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("wake not implemented!\n"));
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_rtc_irq_obj, 1, machine_rtc_irq);
+
+static const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_rtc_deinit_obj) },
+ { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_rtc_init_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_rtc_deinit_obj) },
+ { MP_ROM_QSTR(MP_QSTR_datetime), MP_ROM_PTR(&machine_rtc_datetime_obj) },
+ { MP_ROM_QSTR(MP_QSTR_now), MP_ROM_PTR(&machine_rtc_now_obj) },
+ { MP_ROM_QSTR(MP_QSTR_alarm), MP_ROM_PTR(&machine_rtc_alarm_obj) },
+ { MP_ROM_QSTR(MP_QSTR_alarm_left), MP_ROM_PTR(&machine_rtc_alarm_left_obj) },
+ { MP_ROM_QSTR(MP_QSTR_cancel), MP_ROM_PTR(&machine_rtc_alarm_cancel_obj) },
+ { MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_rtc_irq_obj) },
+ { MP_ROM_QSTR(MP_QSTR_memory), MP_ROM_PTR(&machine_rtc_memory_obj)},
+ // class constants
+ { MP_ROM_QSTR(MP_QSTR_ALARM0), MP_ROM_INT(CYHAL_RTC_ALARM) },
+
+};
+static MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_rtc_type,
+ MP_QSTR_RTC,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_rtc_make_new,
+ locals_dict, &machine_rtc_locals_dict
+ );
diff --git a/ports/psoc6/machine_sdcard.c b/ports/psoc6/machine_sdcard.c
new file mode 100644
index 0000000000000..0ee2d0c01c680
--- /dev/null
+++ b/ports/psoc6/machine_sdcard.c
@@ -0,0 +1,342 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020-2021 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+
+// micropython includes
+#include "py/runtime.h"
+#include "extmod/vfs.h"
+#include "modpsoc6.h"
+#include "mplogger.h"
+#include "mphalport.h"
+
+// port-specific includes
+#include "modmachine.h"
+#include "machine_pin_phy.h"
+#include "mplogger.h"
+
+// MTB includes
+#include "cyhal.h"
+#include "cybsp.h"
+
+#define SDHC_DEFAULT_BUS_WIDTH (4U)
+#define SDHC_BLOCK_SIZE (512UL)
+#define SDHC_CLOCK_RESOURCE_BLOCK_NUMBER (18U)
+#define SDHC_CLOCK_RESOURCE_CHANNEL_NUMBER (2U)
+typedef struct _machine_sdcard_obj_t {
+ mp_obj_base_t base;
+ cyhal_sdhc_t sdhc_obj;
+ uint16_t slot_num;
+ uint32_t wp;
+ uint32_t cmd;
+ uint32_t dat0;
+ uint32_t dat1;
+ uint32_t dat2;
+ uint32_t dat3;
+ uint32_t clk;
+ uint32_t cd;
+ uint32_t block_count;
+} machine_sdcard_obj_t;
+
+machine_sdcard_obj_t *sdhc_obj[MAX_SDHC_SLOT] = { NULL };
+
+enum {
+ ARG_slot,
+ ARG_width,
+ ARG_cd,
+ ARG_wp,
+ ARG_cmd,
+ ARG_dat0,
+ ARG_dat1,
+ ARG_dat2,
+ ARG_dat3,
+ ARG_clk
+};
+
+static inline machine_sdcard_obj_t *sd_card_obj_alloc() {
+ for (uint8_t i = 0; i < MAX_SDHC_SLOT; i++)
+ {
+ if (sdhc_obj[i] == NULL) {
+ sdhc_obj[i] = mp_obj_malloc(machine_sdcard_obj_t, &machine_sdcard_type);
+ return sdhc_obj[i];
+ }
+ }
+ return NULL;
+}
+
+static inline void sd_card_obj_free(machine_sdcard_obj_t *sdhc_obj_ptr) {
+ for (uint8_t i = 0; i < MAX_SDHC_SLOT; i++)
+ {
+ if (sdhc_obj[i] == sdhc_obj_ptr) {
+ sdhc_obj[i] = NULL;
+ }
+ }
+}
+
+static void sd_card_allocate_pin(machine_sdcard_obj_t *self, mp_arg_val_t *args) {
+ if (args[ARG_cmd].u_obj != mp_const_none) {
+ self->cmd = pin_addr_by_name(args[ARG_cmd].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Cmd pin must be provided"));
+ }
+
+ if (args[ARG_dat0].u_obj != mp_const_none) {
+ self->dat0 = pin_addr_by_name(args[ARG_dat0].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Data 0 pin must be provided"));
+ }
+
+ if (args[ARG_dat1].u_obj != mp_const_none) {
+ self->dat1 = pin_addr_by_name(args[ARG_dat1].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Data 1 pin must be provided"));
+ }
+
+ if (args[ARG_dat2].u_obj != mp_const_none) {
+ self->dat2 = pin_addr_by_name(args[ARG_dat2].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Data 2 pin must be provided"));
+ }
+
+ if (args[ARG_dat3].u_obj != mp_const_none) {
+ self->dat3 = pin_addr_by_name(args[ARG_dat3].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Data 3 pin must be provided"));
+ }
+
+ if (args[ARG_clk].u_obj != mp_const_none) {
+ self->clk = pin_addr_by_name(args[ARG_clk].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("Clk pin must be provided"));
+ }
+
+ if (args[ARG_cd].u_obj != mp_const_none) {
+ self->cd = pin_addr_by_name(args[ARG_cd].u_obj);
+ }
+
+ if (args[ARG_wp].u_obj != mp_const_none) {
+ self->wp = pin_addr_by_name(args[ARG_wp].u_obj);
+ }
+}
+
+static cy_rslt_t sd_card_init_helper(machine_sdcard_obj_t *self, mp_arg_val_t *args) {
+
+ cyhal_sdhc_config_t sdhc_config;
+
+ sdhc_config.enableLedControl = false;
+ sdhc_config.lowVoltageSignaling = false;
+ sdhc_config.isEmmc = false;
+ sdhc_config.busWidth = SDHC_DEFAULT_BUS_WIDTH;
+
+ cy_rslt_t result = CY_RSLT_SUCCESS;
+ cyhal_clock_t *clock_source = NULL;
+
+// If external flash is running, then HF2 clock resource is already initialized by QSPI and it has to be reused by SDHC peripheral.
+ #if MICROPY_ENABLE_EXT_QSPI_FLASH
+ cyhal_clock_t clock;
+ cyhal_resource_inst_t rsc = {CYHAL_RSC_CLOCK, SDHC_CLOCK_RESOURCE_BLOCK_NUMBER, SDHC_CLOCK_RESOURCE_CHANNEL_NUMBER};
+ cyhal_clock_get(&clock, &rsc);
+ clock_source = &clock;
+ #endif
+
+
+ sd_card_allocate_pin(self, args);
+ result = cyhal_sdhc_init(&self->sdhc_obj, &sdhc_config, self->cmd, self->clk, self->dat0, self->dat1,
+ self->dat2, self->dat3, NC, NC, NC, NC, self->cd, NC, NC, NC, NC, NC, clock_source);
+ return result;
+}
+
+static void sd_card_deallocate_pins(machine_sdcard_obj_t *self) {
+ cyhal_gpio_free(self->cd);
+ cyhal_gpio_free(self->cmd);
+ cyhal_gpio_free(self->clk);
+ cyhal_gpio_free(self->wp);
+ cyhal_gpio_free(self->dat0);
+ cyhal_gpio_free(self->dat1);
+ cyhal_gpio_free(self->dat2);
+ cyhal_gpio_free(self->dat3);
+}
+
+static mp_obj_t machine_sdcard_deinit(mp_obj_t self_in) {
+ machine_sdcard_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ cyhal_sdhc_free(&self->sdhc_obj);
+ sd_card_deallocate_pins(self);
+ sd_card_obj_free(self);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_sdcard_deinit_obj, machine_sdcard_deinit);
+
+static mp_obj_t machine_sdcard_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+
+ mp_arg_check_num(n_args, n_kw, 0, 9, true);
+
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_slot, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_width, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_cd, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_wp, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_cmd, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_dat0, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_dat1, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_dat2, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_dat3, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} },
+ { MP_QSTR_clk, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = mp_const_none} }
+ };
+
+ // Parse the arguments.
+ mp_map_t kw_args;
+ mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ machine_sdcard_obj_t *self = sd_card_obj_alloc();
+ if (self == NULL) {
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("No available slots!"));
+ return mp_const_none;
+ }
+
+ if (args[ARG_slot].u_int != -1) {
+ mp_printf(&mp_plat_print, "machine.SDCard: slot parameter is ignored in this port.\n");
+ }
+
+ cy_rslt_t result = sd_card_init_helper(self, args);
+
+ if (CY_RSLT_SUCCESS == result) {
+ cyhal_sdhc_get_block_count(&self->sdhc_obj, (uint32_t *)&self->block_count);
+ } else {
+ assert_pin_phy_used(result);
+ if (cyhal_sdhc_is_card_inserted(&self->sdhc_obj) == false) {
+ machine_sdcard_deinit(self);
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("SD Card not inserted!\n"));
+ } else {
+ machine_sdcard_deinit(self);
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("SD card init failed!\n"));
+ }
+ }
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t machine_sdcard_readblocks(size_t n_args, const mp_obj_t *args) {
+
+ machine_sdcard_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ uint32_t block_address = mp_obj_get_int(args[1]);
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+
+ if (n_args == 4) {
+ block_address += mp_obj_get_int(args[3]);
+ }
+
+ size_t length = bufinfo.len / SDHC_BLOCK_SIZE;
+ cy_rslt_t result = cyhal_sdhc_read(&self->sdhc_obj, block_address, bufinfo.buf, &length);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("machine_sdcard_readblocks() - SD Card Read failed !"));
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_sdcard_readblocks_obj, 3, 4, machine_sdcard_readblocks);
+
+static mp_obj_t machine_sdcard_writeblocks(size_t n_args, const mp_obj_t *args) {
+
+ machine_sdcard_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ uint32_t block_address = mp_obj_get_int(args[1]);
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+
+ size_t length = bufinfo.len / SDHC_BLOCK_SIZE;
+
+ cy_rslt_t result = cyhal_sdhc_write(&self->sdhc_obj, block_address, bufinfo.buf, &length);
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("machine_sdcard_writeblocks() - SD Card Write failed!"));
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_sdcard_writeblocks_obj, 3, 4, machine_sdcard_writeblocks);
+
+static mp_obj_t machine_sdcard_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+ machine_sdcard_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_int_t cmd = mp_obj_get_int(cmd_in);
+
+ switch (cmd) {
+ case MP_BLOCKDEV_IOCTL_INIT:
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_DEINIT:
+ machine_sdcard_deinit(self_in);
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_SYNC:
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+ return MP_OBJ_NEW_SMALL_INT(self->block_count);
+ case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+ return MP_OBJ_NEW_SMALL_INT(SDHC_BLOCK_SIZE);
+ case MP_BLOCKDEV_IOCTL_BLOCK_ERASE: {
+ uint32_t offset = mp_obj_get_int(arg_in);
+ cy_rslt_t result = cyhal_sdhc_erase(&self->sdhc_obj, offset, 1, 0);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("machine_sdcard_ioctl() - SD Card erase failed !"));
+ }
+ return MP_OBJ_NEW_SMALL_INT(0);
+ }
+ default:
+ return mp_const_none;
+ }
+}
+static MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_ioctl_obj, machine_sdcard_ioctl);
+
+
+void mod_sdcard_deinit() {
+ for (uint8_t i = 0; i < MAX_SDHC_SLOT; i++) {
+ if (sdhc_obj[i] != NULL) {
+ machine_sdcard_deinit(MP_OBJ_FROM_PTR(sdhc_obj[i]));
+ }
+ }
+}
+
+static const mp_rom_map_elem_t machine_sdcard_locals_dict_table[] = {
+ // block device protocol
+ { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&machine_sdcard_readblocks_obj) },
+ { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&machine_sdcard_writeblocks_obj) },
+ { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&machine_sdcard_ioctl_obj) },
+ { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_sdcard_deinit_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_sdcard_deinit_obj) },
+};
+static MP_DEFINE_CONST_DICT(machine_sdcard_locals_dict, machine_sdcard_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_sdcard_type,
+ MP_QSTR_SDCard,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_sdcard_make_new,
+ locals_dict, &machine_sdcard_locals_dict
+ );
diff --git a/ports/psoc6/machine_spi.c b/ports/psoc6/machine_spi.c
new file mode 100644
index 0000000000000..ecfbc88bbec22
--- /dev/null
+++ b/ports/psoc6/machine_spi.c
@@ -0,0 +1,428 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+
+// mpy includes
+#include "py/runtime.h"
+#include "extmod/modmachine.h"
+#include "py/mperrno.h"
+
+// MTB includes
+#include "cybsp.h"
+#include "cyhal.h"
+
+
+// port-specific includes
+#include "modmachine.h"
+#include "machine_pin_phy.h"
+#include "mplogger.h"
+
+#define DEFAULT_SPI_BAUDRATE (1000000)
+#define DEFAULT_SPI_POLARITY (0)
+#define DEFAULT_SPI_PHASE (0)
+#define DEFAULT_SPI_BITS (8)
+#define DEFAULT_SPI_FIRSTBIT (0) // msb
+#define DEFAULT_SPI_SSEL_PIN (MP_ROM_QSTR(MP_QSTR_NC))
+#define MASTER_MODE (0)
+#define SLAVE_MODE (1)
+
+
+#define spi_assert_raise_val(msg, ret) if (ret != CY_RSLT_SUCCESS) { \
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), ret); \
+}
+
+#define spi_alloc_msg(pin_name, pin_obj, msg) if (pin_obj == NULL) { \
+ size_t slen; \
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), mp_obj_str_get_data(pin_name, &slen)); \
+}
+
+typedef struct _machine_spi_obj_t {
+ mp_obj_base_t base;
+ cyhal_spi_t spi_obj;
+ int id; // This parameter is unused and added for compliance with reference API
+ uint8_t polarity;
+ uint8_t phase;
+ uint8_t bits;
+ uint8_t firstbit;
+ uint32_t ssel;
+ uint32_t sck;
+ uint32_t mosi;
+ uint32_t miso;
+ uint32_t baudrate;
+} machine_spi_obj_t;
+
+machine_spi_obj_t *spi_obj[MAX_SPI] = { NULL };
+
+// Function to select the mode
+static cyhal_spi_mode_t spi_mode_select(uint8_t firstbit, uint8_t polarity, uint8_t phase) {
+
+ cyhal_spi_mode_t mode;
+ if (firstbit == 1) {
+ if (polarity == 0) {
+ if (phase == 0) {
+ mode = CYHAL_SPI_MODE_00_LSB;
+ } else {
+ mode = CYHAL_SPI_MODE_01_LSB;
+ }
+ } else {
+ if (phase == 0) {
+ mode = CYHAL_SPI_MODE_10_LSB;
+ } else {
+ mode = CYHAL_SPI_MODE_11_LSB;
+ }
+ }
+ } else {
+ if (polarity == 0) {
+ if (phase == 0) {
+ mode = CYHAL_SPI_MODE_00_MSB;
+ } else {
+ mode = CYHAL_SPI_MODE_01_MSB;
+ }
+ } else {
+ if (phase == 0) {
+ mode = CYHAL_SPI_MODE_10_MSB;
+ } else {
+ mode = CYHAL_SPI_MODE_11_MSB;
+ }
+ }
+ }
+ return mode;
+}
+
+static inline machine_spi_obj_t *spi_obj_alloc(bool is_slave) {
+ for (uint8_t i = 0; i < MAX_SPI; i++)
+ {
+ if (spi_obj[i] == NULL) {
+
+ const mp_obj_type_t *obj_type = &machine_spi_type;
+ #if MICROPY_PY_MACHINE_SPI_SLAVE
+ if (is_slave) {
+ obj_type = &machine_spi_slave_type;
+ }
+ #endif
+ spi_obj[i] = mp_obj_malloc(machine_spi_obj_t, obj_type);
+ return spi_obj[i];
+ }
+ }
+
+ return NULL;
+}
+
+static inline void spi_obj_free(machine_spi_obj_t *spi_obj_ptr) {
+ for (uint8_t i = 0; i < MAX_SPI; i++)
+ {
+ if (spi_obj[i] == spi_obj_ptr) {
+ spi_obj[i] = NULL;
+ }
+ }
+}
+
+static inline void spi_init(machine_spi_obj_t *machine_spi_obj, int spi_mode) {
+ cyhal_spi_mode_t mode = spi_mode_select(machine_spi_obj->firstbit, machine_spi_obj->polarity, machine_spi_obj->phase);
+ // set the baudrate
+ cyhal_spi_set_frequency(&machine_spi_obj->spi_obj, machine_spi_obj->baudrate);
+ // Initialise the SPI peripheral if any arguments given, or it was not initialised previously.
+ cy_rslt_t result = cyhal_spi_init(&machine_spi_obj->spi_obj, machine_spi_obj->mosi, machine_spi_obj->miso, machine_spi_obj->sck, machine_spi_obj->ssel, NULL, machine_spi_obj->bits, mode, spi_mode);
+ assert_pin_phy_used(result);
+ spi_assert_raise_val("SPI initialisation failed with return code %x !", result);
+}
+
+static void machine_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "SPI(baudrate=%u, polarity=%u, phase=%u, bits=%u, firstbit=%u, ssel=%d, sck=%d, mosi=%d, miso=%d)",
+ self->baudrate, self->polarity,
+ self->phase, self->bits, self->firstbit,
+ self->ssel, self->sck, self->mosi, self->miso);
+}
+
+mp_obj_t machine_spi_init_helper(machine_spi_obj_t *self, int spi_mode, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ enum { ARG_id, ARG_baudrate, ARG_polarity, ARG_phase, ARG_bits, ARG_firstbit, ARG_ssel, ARG_sck, ARG_mosi, ARG_miso };
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_id, MP_ARG_INT, {.u_int = -1}},
+ { MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_SPI_BAUDRATE} },
+ { MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_SPI_POLARITY} },
+ { MP_QSTR_phase, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_SPI_PHASE} },
+ { MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_SPI_BITS} },
+ { MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DEFAULT_SPI_FIRSTBIT} },
+ { MP_QSTR_ssel, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = DEFAULT_SPI_SSEL_PIN}},
+ { MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_mosi, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_miso, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ };
+ // Parse the arguments.
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ // set id if provided
+ if (args[ARG_id].u_int != -1) {
+ self->id = args[ARG_id].u_int;
+ mp_printf(&mp_plat_print, "machine.SPI: ID parameter is ignored in this port.\n");
+ }
+ // set baudrate if provided
+ if (args[ARG_baudrate].u_int != -1) {
+ self->baudrate = args[ARG_baudrate].u_int;
+ }
+
+ // set polarity(CPOL) if provided
+ if (args[ARG_polarity].u_int != -1) {
+ self->polarity = args[ARG_polarity].u_int;
+ }
+
+ // set phase(CPHA) if provided
+ if (args[ARG_phase].u_int != -1) {
+ self->phase = args[ARG_phase].u_int;
+ }
+
+ // set bits if provided
+ if (args[ARG_bits].u_int != -1) {
+ self->bits = args[ARG_bits].u_int;
+ }
+
+ // set firstbit if provided(LSB or MSB first)
+ if (args[ARG_firstbit].u_int != -1) {
+ self->firstbit = args[ARG_firstbit].u_int;
+ }
+
+ // Set SSEL/SCK/MOSI/MISO pins if configured.
+ if (spi_mode == MASTER_MODE) {
+ if (args[ARG_ssel].u_obj != DEFAULT_SPI_SSEL_PIN) {
+ mp_raise_TypeError(MP_ERROR_TEXT("SSEL pin cannot be provided in master constructor!"));
+ } else {
+ self->ssel = pin_addr_by_name(DEFAULT_SPI_SSEL_PIN);
+ }
+ } else if (spi_mode == SLAVE_MODE) {
+ if ((args[ARG_ssel].u_obj != DEFAULT_SPI_SSEL_PIN)) {
+ self->ssel = pin_addr_by_name(args[ARG_ssel].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("SSEL pin must be provided in slave mode"));
+ }
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("SPI should either be in master or slave mode!"));
+ }
+
+ if (args[ARG_sck].u_obj != mp_const_none) {
+ self->sck = pin_addr_by_name(args[ARG_sck].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("SCK pin must be provided"));
+ }
+
+ if (args[ARG_mosi].u_obj != mp_const_none) {
+ self->mosi = pin_addr_by_name(args[ARG_mosi].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("MOSI pin must be provided"));
+ }
+
+ if (args[ARG_miso].u_obj != mp_const_none) {
+ self->miso = pin_addr_by_name(args[ARG_miso].u_obj);
+ } else {
+ mp_raise_TypeError(MP_ERROR_TEXT("MISO pin must be provided"));
+ }
+
+ if (n_args > 1 || n_kw > 0) {
+ spi_init(self, spi_mode);
+ }
+ return MP_OBJ_FROM_PTR(self);
+}
+
+mp_obj_t machine_spi_master_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ machine_spi_obj_t *self = spi_obj_alloc(false);
+ if (n_kw > 1) {
+ machine_spi_init_helper(self, MASTER_MODE, n_args, n_kw, all_args);
+ } else {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Master init failed as all required arguments not passed!"));
+ }
+ return MP_OBJ_FROM_PTR(self);
+}
+
+mp_obj_t machine_spi_slave_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ machine_spi_obj_t *self = spi_obj_alloc(true);
+ if (n_kw > 1) {
+ machine_spi_init_helper(self, SLAVE_MODE, n_args, n_kw, all_args);
+ } else {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Slave init failed as all required arguments not passed!"));
+ }
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static void machine_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("Init not supported. Use the constructor to initialize.\n"));
+}
+
+static void machine_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *tx, uint8_t *rx) {
+ machine_spi_obj_t *self = (machine_spi_obj_t *)self_in;
+ cy_rslt_t result;
+ const uint8_t *tx_buf;
+ uint8_t *rx_buf;
+ uint8_t tx_temp_buf[len];
+ uint8_t rx_temp_buf[len];
+ uint8_t write_fill = 0xFF;
+
+ cyhal_spi_clear(&self->spi_obj);
+
+ // write
+ if (rx == NULL) {
+ tx_buf = tx;
+ memset(rx_temp_buf, 0x01, len * sizeof(uint8_t));
+ rx_buf = rx_temp_buf;
+ } else {
+ // read(), readinto() and write_readinto() with tx and rx same buffers
+ if (tx == rx || tx == NULL) {
+ memcpy(tx_temp_buf, tx, len * sizeof(uint8_t));
+ tx_buf = tx_temp_buf;
+ rx_buf = rx;
+ write_fill = tx_temp_buf[0];
+ }
+ // write_readinto() with tx and rx different buffers
+ else {
+ tx_buf = tx;
+ rx_buf = rx;
+ }
+ }
+ result = cyhal_spi_transfer(&self->spi_obj, tx_buf, len, rx_buf, len, write_fill);
+ spi_assert_raise_val("SPI read failed with return code %lx !", result);
+}
+
+
+static void machine_spi_deinit(mp_obj_base_t *self_in) {
+ machine_spi_obj_t *self = (machine_spi_obj_t *)self_in;
+ cyhal_spi_clear(&self->spi_obj);
+ cyhal_spi_free(&self->spi_obj);
+ spi_obj_free(self);
+}
+
+static const mp_machine_spi_p_t machine_spi_p = {
+ .init = machine_spi_init,
+ .deinit = machine_spi_deinit,
+ .transfer = machine_spi_transfer,
+};
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_spi_type,
+ MP_QSTR_SPI,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_spi_master_make_new,
+ print, machine_spi_print,
+ protocol, &machine_spi_p,
+ locals_dict, &mp_machine_spi_locals_dict
+ );
+
+#if MICROPY_PY_MACHINE_SPI_SLAVE
+
+static void machine_spi_slave_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "SPISlave(baudrate=%u, polarity=%u, phase=%u, bits=%u, firstbit=%u, ssel=%d, sck=%d, mosi=%d, miso=%d)",
+ self->baudrate, self->polarity,
+ self->phase, self->bits, self->firstbit,
+ self->ssel, self->sck, self->mosi, self->miso);
+}
+
+static mp_obj_t machine_spi_slave_deinit(mp_obj_t self_in) {
+ mp_obj_base_t *self = MP_OBJ_TO_PTR(self_in);
+ machine_spi_deinit(self);
+ return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(machine_spi_slave_deinit_obj, machine_spi_slave_deinit);
+
+static mp_obj_t machine_spi_slave_read(mp_obj_t self_in, mp_obj_t buf_in) {
+ cy_rslt_t result;
+ machine_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
+ uint16_t len = bufinfo.len;
+ uint8_t tx_dummy[len];
+ memset(tx_dummy, 0x02, len * sizeof(uint8_t));
+ result = cyhal_spi_transfer(&self->spi_obj, tx_dummy, len, bufinfo.buf, len, 0xFF);
+ spi_assert_raise_val("SPI slave read failed with return code %lx !", result);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(machine_spi_slave_read_obj, machine_spi_slave_read);
+
+static mp_obj_t machine_spi_slave_write(mp_obj_t self_in, mp_obj_t buf_in) {
+ cy_rslt_t result;
+ machine_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
+ uint16_t len = bufinfo.len;
+ uint8_t rx_dummy[len];
+ memset(rx_dummy, 0x01, len * sizeof(uint8_t));
+ result = cyhal_spi_transfer(&self->spi_obj, bufinfo.buf, len, rx_dummy, len, 0xFF);
+ spi_assert_raise_val("SPI slave write failed with return code %lx !", result);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(machine_spi_slave_write_obj, machine_spi_slave_write);
+
+static mp_obj_t machine_spi_slave_write_readinto(mp_obj_t self_in, mp_obj_t tx_buf_in, mp_obj_t rx_buf_in) {
+ machine_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_buffer_info_t tx_bufinfo;
+ mp_buffer_info_t rx_bufinfo;
+ mp_get_buffer_raise(tx_buf_in, &tx_bufinfo, MP_BUFFER_READ);
+ mp_get_buffer_raise(rx_buf_in, &rx_bufinfo, MP_BUFFER_WRITE);
+ uint16_t len = tx_bufinfo.len;
+ if (tx_bufinfo.len != rx_bufinfo.len) {
+ mp_raise_ValueError(MP_ERROR_TEXT("buffers must be the same length"));
+ }
+ cy_rslt_t result = cyhal_spi_transfer(&self->spi_obj, tx_bufinfo.buf, len, rx_bufinfo.buf, len, 0xFF);
+ spi_assert_raise_val("SPI slave write failed with return code %lx !", result);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_3(machine_spi_slave_write_readinto_obj, machine_spi_slave_write_readinto);
+
+
+static const mp_rom_map_elem_t machine_spi_slave_locals_dict_table[] = {
+ // Functions
+ { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&machine_spi_slave_read_obj) },
+ { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&machine_spi_slave_write_obj) },
+ { MP_ROM_QSTR(MP_QSTR_write_readinto), MP_ROM_PTR(&machine_spi_slave_write_readinto_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_spi_slave_deinit_obj) },
+ // constants
+ { MP_ROM_QSTR(MP_QSTR_MSB), MP_ROM_INT(MICROPY_PY_MACHINE_SPISLAVE_MSB) },
+ { MP_ROM_QSTR(MP_QSTR_LSB), MP_ROM_INT(MICROPY_PY_MACHINE_SPISLAVE_LSB) },
+};
+static MP_DEFINE_CONST_DICT(machine_spi_slave_locals_dict, machine_spi_slave_locals_dict_table);
+
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_spi_slave_type,
+ MP_QSTR_SPISlave,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_spi_slave_make_new,
+ print, machine_spi_slave_print,
+ locals_dict, &machine_spi_slave_locals_dict
+ );
+
+#endif
+
+void mod_spi_deinit() {
+ for (uint8_t i = 0; i < MAX_SPI; i++) {
+ if (spi_obj[i] != NULL) {
+ machine_spi_deinit((mp_obj_base_t *)(spi_obj[i]));
+ }
+ }
+}
diff --git a/ports/psoc6/machine_timer.c b/ports/psoc6/machine_timer.c
new file mode 100644
index 0000000000000..5c1f5c35fdb8b
--- /dev/null
+++ b/ports/psoc6/machine_timer.c
@@ -0,0 +1,255 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// mpy includes
+#include "py/runtime.h"
+#include "py/mphal.h"
+
+
+// MTB includes
+#include "cybsp.h"
+#include "cyhal.h"
+
+
+#define TIMER_MODE_ONE_SHOT (0)
+#define TIMER_MODE_PERIODIC (1)
+
+typedef struct _machine_timer_obj_t {
+ mp_obj_base_t base;
+ cyhal_timer_t timer_obj;
+ int timer_id;
+ uint32_t mode;
+ uint32_t period;
+ uint32_t freq;
+ mp_obj_t callback;
+} machine_timer_obj_t;
+
+const mp_obj_type_t machine_timer_type;
+
+machine_timer_obj_t *timer_obj[MAX_TIMER] = { NULL };
+
+static void isr_timer(void *callback_arg, cyhal_timer_event_t event) {
+ machine_timer_obj_t *self = callback_arg;
+ mp_sched_schedule(self->callback, MP_OBJ_FROM_PTR(self));
+}
+
+// Allocate timer
+static inline machine_timer_obj_t *timer_obj_alloc() {
+ for (uint8_t i = 0; i < MAX_TIMER; i++)
+ {
+ if (timer_obj[i] == NULL) {
+ timer_obj[i] = mp_obj_malloc(machine_timer_obj_t, &machine_timer_type);
+ return timer_obj[i];
+ }
+ }
+ return NULL;
+}
+
+// Free timer
+static inline void timer_obj_free(machine_timer_obj_t *timer_obj_ptr) {
+ for (uint8_t i = 0; i < MAX_TIMER; i++)
+ {
+ if (timer_obj[i] == timer_obj_ptr) {
+ timer_obj[i] = NULL;
+ }
+ }
+}
+
+// Write a function to check if a timer is already in use using id as input and compare to the timer_id of the timer_obj
+static inline bool timer_in_use(int id) {
+ for (uint8_t i = 0; i < MAX_TIMER; i++)
+ {
+ if (timer_obj[i] != NULL && timer_obj[i]->timer_id == id) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ qstr mode = self->mode == TIMER_MODE_ONE_SHOT ? MP_QSTR_ONE_SHOT : MP_QSTR_PERIODIC;
+ mp_printf(print, "Timer(id=%d, mode=%q, period=%u, tick_hz=%u)", self->timer_id, mode, self->period, self->freq);
+}
+
+static mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ enum {ARG_mode, ARG_callback, ARG_period, ARG_freq};
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = TIMER_MODE_ONE_SHOT} },
+ { MP_QSTR_callback, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_period, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 9999u} },
+ { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_rom_obj = MP_ROM_NONE} },
+ };
+ // Parse args
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ float period;
+ self->mode = args[ARG_mode].u_int;
+
+ if (args[ARG_freq].u_obj != mp_const_none) {
+ self->freq = args[ARG_freq].u_int;
+ period = 1.0f / (float)(args[ARG_freq].u_int); // Frequency to period conversion
+ } else {
+ self->period = args[ARG_period].u_int;
+ period = (float)args[ARG_period].u_int / 1000.0f; // ms to s conversion
+ }
+
+ if (args[ARG_callback].u_obj != mp_const_none) {
+ self->callback = args[ARG_callback].u_obj;
+ }
+
+
+ uint32_t period_hal; // Period/count input for the PSoC6 HAL timer configuration
+ uint32_t fz_hal = 1000000; // Frequency for the PSoC timer clock is fixed as 1 MHz
+ period_hal = (uint32_t)(period * fz_hal) - 1; // Overflow Period = (Period + 1)/ frequency ;period = (overflow period * frequency)-1
+
+ // Adjust the frequency & recalculate the period if period/count is greater than the maximum overflow value for a 32 bit timer ie; 2^32
+ while (period_hal > 4294967296) {
+ fz_hal = fz_hal / 10; // Reduce the fz_hal value by 10%
+ period_hal = (uint32_t)(period * fz_hal) - 1; // Recalculate Period input for the PSoC6 HAL timer configuration
+ }
+
+ // Timer initialisation of port
+ cy_rslt_t rslt;
+
+ const cyhal_timer_cfg_t timer_cfg =
+ {
+ .compare_value = 0, /* Timer compare value, not used */
+ .period = period_hal, /* Defines the timer period */
+ .direction = CYHAL_TIMER_DIR_UP, /* Timer counts up */
+ .is_compare = false, /* Don't use compare mode */
+ .is_continuous = self->mode, /* Run the timer */
+ .value = 0 /* Initial value of counter */
+ };
+
+ /* Initialize the timer object. Does not use pin output ('pin' is NC) and
+ * does not use a pre-configured clock source ('clk' is NULL). */
+
+ rslt = cyhal_timer_init(&self->timer_obj, NC, NULL);
+ CY_ASSERT(CY_RSLT_SUCCESS == rslt);
+
+ /* Apply timer configuration such as period, count direction, run mode, etc. */
+ rslt = cyhal_timer_configure(&self->timer_obj, &timer_cfg);
+
+ /* Set the frequency of timer to Defined frequency */
+ rslt = cyhal_timer_set_frequency(&self->timer_obj, fz_hal);
+
+ /* Assign the ISR to execute on timer interrupt */
+ cyhal_timer_register_callback(&self->timer_obj, isr_timer, self);
+
+ /* Set the event on which timer interrupt occurs and enable it */
+ cyhal_timer_enable_event(&self->timer_obj, CYHAL_TIMER_IRQ_TERMINAL_COUNT, 3, true);
+
+ /* Start the timer with the configured settings */
+ rslt = cyhal_timer_start(&self->timer_obj);
+
+ CY_ASSERT(CY_RSLT_SUCCESS == rslt);
+
+ return mp_const_none;
+}
+
+static mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+ mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+ mp_int_t id = 0;
+ if (n_args > 0) {
+ id = mp_obj_get_int(args[0]);
+ --n_args;
+ ++args;
+ }
+ // Get timer id
+ if (id == -1) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Virtual timers are not supported yet!"));
+ }
+
+ if (id >= MAX_TIMER) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Invalid timer id!"));
+ }
+
+ if (timer_in_use(id)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Timer already in use!"));
+ }
+
+ machine_timer_obj_t *self = timer_obj_alloc();
+ if (self == NULL) {
+ mp_raise_ValueError(MP_ERROR_TEXT("All timers are already initialized. Deinit some timers to create new ones!"));
+ }
+
+ self->timer_id = id;
+
+ if (n_args > 0 || n_kw > 0) {
+ // Start the timer
+ mp_map_t kw_args;
+ mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+ machine_timer_init_helper(self, n_args, args, &kw_args);
+ }
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+ mp_raise_NotImplementedError("Init is not supported in this port. Please use constructor to initialize the parameters!\n");
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
+
+static mp_obj_t machine_timer_deinit(mp_obj_t self_in) {
+ machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ cyhal_timer_free(&self->timer_obj);
+ timer_obj_free(self);
+ return mp_const_none;
+}
+
+static MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
+
+static const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_timer_deinit_obj) },
+ { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_timer_init_obj) },
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_timer_deinit_obj) },
+
+ { MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(TIMER_MODE_ONE_SHOT) },
+ { MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(TIMER_MODE_PERIODIC) },
+};
+
+static MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ machine_timer_type,
+ MP_QSTR_Timer,
+ MP_TYPE_FLAG_NONE,
+ make_new, machine_timer_make_new,
+ print, machine_timer_print,
+ locals_dict, &machine_timer_locals_dict
+ );
+
+
+void mod_timer_deinit() {
+ for (uint8_t i = 0; i < MAX_TIMER; i++) {
+ if (timer_obj[i] != NULL) {
+ machine_timer_deinit((mp_obj_base_t *)(timer_obj[i]));
+ }
+ }
+}
diff --git a/ports/psoc6/machine_uart.c b/ports/psoc6/machine_uart.c
new file mode 100644
index 0000000000000..3a410b7e078a6
--- /dev/null
+++ b/ports/psoc6/machine_uart.c
@@ -0,0 +1,492 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// mpy includes
+#include "py/mphal.h"
+#include "py/mperrno.h"
+#include "py/ringbuf.h"
+#include "py/runtime.h"
+#include "shared/runtime/interrupt_char.h"
+#include "shared/runtime/mpirq.h"
+
+// MTB includes
+#include "cybsp.h"
+#include "cyhal.h"
+
+// port specific includes
+#include "modmachine.h"
+#include "machine_pin_phy.h"
+#include "mplogger.h"
+
+// std includes
+#include
+
+#define UART_HWCONTROL_RTS (1)
+#define UART_HWCONTROL_CTS (2)
+#define DEFAULT_CTS_PIN (MP_ROM_QSTR(MP_QSTR_NC))
+#define DEFAULT_RTS_PIN (MP_ROM_QSTR(MP_QSTR_NC))
+
+// OR-ed IRQ flags which are allowed to be used by the user
+#define MP_UART_ALLOWED_FLAGS (CYHAL_UART_IRQ_TX_EMPTY | CYHAL_UART_IRQ_TX_DONE | CYHAL_UART_IRQ_RX_FULL | CYHAL_UART_IRQ_RX_DONE)
+
+
+#define uart_assert_raise_val(msg, ret) if (ret != CY_RSLT_SUCCESS) { \
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), ret); \
+}
+
+typedef struct _machine_uart_obj_t {
+ mp_obj_base_t base;
+ cyhal_uart_t uart_obj;
+ uint8_t id;
+ uint32_t init_flag; // Flag to support reinitialisation of uart parameters
+ uint32_t bits;
+ uint32_t stop;
+ uint32_t baudrate;
+ cyhal_uart_parity_t parity;
+ uint32_t tx;
+ uint32_t rx;
+ uint32_t cts;
+ uint32_t rts;
+ cyhal_uart_cfg_t cfg;
+ uint16_t timeout; // only used by cyhal_uart_getc() ie, readchar()
+ uint8_t flow;
+ uint32_t rxbuf;
+ uint8_t *rxbuf_data;
+ bool interrupt;
+ uint16_t mp_irq_trigger; // user IRQ trigger mask
+ uint16_t mp_irq_flags; // user IRQ active IRQ flags
+ mp_irq_obj_t *mp_irq_obj; // user IRQ object
+} machine_uart_obj_t;
+
+#define MICROPY_PY_MACHINE_UART_CLASS_CONSTANTS \
+ { MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(UART_HWCONTROL_RTS) }, \
+ { MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(UART_HWCONTROL_CTS) }, \
+ { MP_ROM_QSTR(MP_QSTR_TX_EMPTY), MP_ROM_INT(CYHAL_UART_IRQ_TX_EMPTY) }, \
+ { MP_ROM_QSTR(MP_QSTR_TX_DONE), MP_ROM_INT(CYHAL_UART_IRQ_TX_DONE) }, \
+ { MP_ROM_QSTR(MP_QSTR_RX_FULL), MP_ROM_INT(CYHAL_UART_IRQ_RX_FULL) }, \
+ { MP_ROM_QSTR(MP_QSTR_RX_DONE), MP_ROM_INT(CYHAL_UART_IRQ_RX_DONE) }, \
+
+machine_uart_obj_t *uart_obj[MAX_UART] = { NULL };
+
+static const char *_parity_name[] = {"None", "0", "1"};
+
+
+static void uart_event_handler(void *handler_arg, cyhal_uart_event_t event) {
+ machine_uart_obj_t *self = handler_arg;
+ mp_irq_handler(self->mp_irq_obj);
+}
+
+static void uart_irq_config(machine_uart_obj_t *self, bool enable) {
+ if (self->mp_irq_trigger) {
+ cyhal_uart_register_callback(&self->uart_obj, uart_event_handler, self);
+ cyhal_uart_enable_event(&self->uart_obj, self->mp_irq_trigger, 7, enable);
+ }
+}
+
+static mp_uint_t uart_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
+ machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ uart_irq_config(self, false);
+ self->mp_irq_trigger = new_trigger;
+ uart_irq_config(self, true);
+ return 0;
+}
+
+static mp_uint_t uart_irq_info(mp_obj_t self_in, mp_uint_t info_type) {
+ machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ if (info_type == MP_IRQ_INFO_FLAGS) {
+ return self->mp_irq_flags;
+ } else if (info_type == MP_IRQ_INFO_TRIGGERS) {
+ return self->mp_irq_trigger;
+ }
+ return 0;
+}
+
+const mp_irq_methods_t uart_irq_methods = {
+ .trigger = uart_irq_trigger,
+ .info = uart_irq_info,
+};
+
+static void uart_init(machine_uart_obj_t *machine_uart_obj) {
+ uint32_t actualbaud;
+
+ // // Initialize the UART configuration structure
+ machine_uart_obj->cfg.data_bits = machine_uart_obj->bits;
+ machine_uart_obj->cfg.stop_bits = machine_uart_obj->stop;
+ machine_uart_obj->cfg.parity = machine_uart_obj->parity;
+ machine_uart_obj->cfg.rx_buffer = NULL;
+ machine_uart_obj->cfg.rx_buffer_size = 0;
+
+ if (machine_uart_obj->init_flag == 0) {
+ // Initialize the UART Block
+ cy_rslt_t result = cyhal_uart_init(&machine_uart_obj->uart_obj, machine_uart_obj->tx, machine_uart_obj->rx, machine_uart_obj->cts,
+ machine_uart_obj->rts, NULL, &(machine_uart_obj->cfg));
+ assert_pin_phy_used(result);
+ uart_assert_raise_val("UART initialisation failed with return code %lx !", result);
+ }
+
+ // Set the baud rate
+ cy_rslt_t result = cyhal_uart_set_baud(&machine_uart_obj->uart_obj, machine_uart_obj->baudrate, &actualbaud);
+ uart_assert_raise_val("UART baudrate failed with return code %lx !", result);
+ machine_uart_obj->baudrate = actualbaud;
+
+ // reconfigure the uart config structure . If it's a reinitialise
+ if (machine_uart_obj->init_flag != 0) {
+ result = cyhal_uart_configure(&machine_uart_obj->uart_obj, &(machine_uart_obj->cfg));
+ uart_assert_raise_val("UART configuration failed with return code %lx !", result);
+ }
+
+ machine_uart_obj->init_flag = machine_uart_obj->init_flag + 1;
+}
+
+static inline machine_uart_obj_t *uart_obj_alloc() {
+ for (uint8_t i = 0; i < MAX_UART; i++)
+ {
+ if (uart_obj[i] == NULL) {
+ uart_obj[i] = mp_obj_malloc(machine_uart_obj_t, &machine_uart_type);
+ return uart_obj[i];
+ }
+ }
+ return NULL;
+}
+
+static inline void uart_obj_free(machine_uart_obj_t *uart_obj_ptr) {
+ for (uint8_t i = 0; i < MAX_UART; i++)
+ {
+ if (uart_obj[i] == uart_obj_ptr) {
+ uart_obj[i] = NULL;
+ }
+ }
+}
+
+static void mp_machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_printf(print, "UART(baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, rxbuf=%u, timeout=%u",
+ self->baudrate, self->bits, _parity_name[self->parity],
+ self->stop, self->tx, self->rx, self->rts, self->cts, self->rxbuf, self->timeout);
+ if (self->flow) {
+ mp_printf(print, ", flow=");
+ uint32_t flow_mask = self->flow;
+ if (flow_mask & UART_HWCONTROL_RTS) {
+ mp_printf(print, "RTS");
+ flow_mask &= ~UART_HWCONTROL_RTS;
+ if (flow_mask) {
+ mp_printf(print, "|");
+ }
+ }
+ if (flow_mask & UART_HWCONTROL_CTS) {
+ mp_printf(print, "CTS");
+ }
+ }
+ mp_printf(print, ")");
+}
+
+static void mp_machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_timeout, ARG_rxbuf, ARG_flow, ARG_rts, ARG_cts };
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_bits, MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_parity, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_INT(-1)} },
+ { MP_QSTR_stop, MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = DEFAULT_RTS_PIN} },
+ { MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = DEFAULT_CTS_PIN} },
+ };
+
+ // Parse args.
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+ bool enable_rts = 0;
+ bool enable_cts = 0;
+
+
+ // Set baudrate if configured.
+ if (args[ARG_baudrate].u_int > 0) {
+ self->baudrate = args[ARG_baudrate].u_int;
+ } else {
+ if (self->init_flag == 0) {
+ mp_raise_TypeError(MP_ERROR_TEXT("baudrate must be provided"));
+ }
+ }
+
+ // Set bits if configured.
+ if (args[ARG_bits].u_int > 0) {
+ self->bits = args[ARG_bits].u_int;
+ } else {
+ if (self->init_flag == 0) {
+ mp_raise_TypeError(MP_ERROR_TEXT("bits must be provided"));
+ }
+ }
+
+ // Set parity if configured.
+ if (args[ARG_parity].u_obj != MP_OBJ_NEW_SMALL_INT(-1)) {
+ if (args[ARG_parity].u_obj == mp_const_none) {
+ self->parity = 0;
+ } else if (mp_obj_get_int(args[ARG_parity].u_obj) & 1) {
+ self->parity = 1; // odd
+ } else {
+ self->parity = 2; // even
+ }
+ }
+
+ // Set stop bits if configured.
+ if (args[ARG_stop].u_int > 0) {
+ self->stop = (args[ARG_stop].u_int);
+ } else {
+ if (self->init_flag == 0) {
+ mp_raise_TypeError(MP_ERROR_TEXT("stop bits must be provided"));
+ }
+ }
+
+ // Set TX/RX pins if configured.
+ if (args[ARG_tx].u_obj != mp_const_none) {
+ self->tx = pin_addr_by_name(args[ARG_tx].u_obj);
+ } else {
+ if (self->init_flag == 0) {
+ mp_raise_TypeError(MP_ERROR_TEXT("tx pin must be provided"));
+ }
+ }
+
+ if (args[ARG_rx].u_obj != mp_const_none) {
+ self->rx = pin_addr_by_name(args[ARG_rx].u_obj);
+ } else {
+ if (self->init_flag == 0) {
+ mp_raise_TypeError(MP_ERROR_TEXT("rx pin must be provided"));
+ }
+ }
+
+ // Set CTS/RTS pins if configured.
+ if (args[ARG_rts].u_obj != mp_const_none) {
+ self->rts = pin_addr_by_name(args[ARG_rts].u_obj);
+ }
+
+ if (args[ARG_cts].u_obj != mp_const_none) {
+ self->cts = pin_addr_by_name(args[ARG_cts].u_obj);
+ }
+
+ // Set hardware flow control if configured.
+ if (args[ARG_flow].u_int >= 1) {
+ if (args[ARG_flow].u_int & ~(UART_HWCONTROL_CTS | UART_HWCONTROL_RTS)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("bad hardware flow control mask"));
+ }
+ self->flow = args[ARG_flow].u_int;
+ }
+
+ self->interrupt = 0;
+ self->mp_irq_trigger = 0;
+ self->mp_irq_obj = NULL;
+
+ // initialise UART at cyhal level
+ if (n_args > 0 || kw_args->used > 0) {
+ uart_init(self);
+
+ // Configure UART RX software buffer, which will extend the hardware RX FIFO buffer only for SW async mode.
+ if (args[ARG_rxbuf].u_int > 0) {
+ self->rxbuf = args[ARG_rxbuf].u_int;
+ self->rxbuf_data = malloc(self->rxbuf);
+ if (self->rxbuf_data == NULL) {
+ uart_assert_raise_val("Memory allocation for UART RX buffer failed!", 0);
+ }
+ cy_rslt_t result = cyhal_uart_config_software_buffer(&self->uart_obj, self->rxbuf_data, self->rxbuf);
+ uart_assert_raise_val("Configuring the UART RX software buffer failed with return code %lx !", result);
+ }
+ if (self->flow & UART_HWCONTROL_CTS) {
+ enable_rts = 1;
+ }
+ if (self->flow & UART_HWCONTROL_RTS) {
+ enable_cts = 1;
+ }
+ cy_rslt_t result = cyhal_uart_enable_flow_control(&self->uart_obj, enable_cts, enable_rts);
+ uart_assert_raise_val("Configuring the UART for flow control failed with return code %lx !", result);
+ }
+}
+
+static mp_obj_t mp_machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+ mp_arg_check_num(n_args, n_kw, 0, 1, false);
+
+ // Get Peripheralobject
+ machine_uart_obj_t *self = uart_obj_alloc();
+ if (self == NULL) {
+ mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("UART object allocation failed because max allowed UART objects are created!"));
+ }
+ if (n_args > 0) {
+ // set id if provided
+ if (mp_obj_get_int(args[0]) != -1) {
+ self->id = mp_obj_get_int(args[0]);
+ mp_printf(&mp_plat_print, "machine.UART: ID parameter is ignored in this port.\n");
+ }
+ }
+ self->init_flag = 0;
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static void mp_machine_uart_deinit(machine_uart_obj_t *self) {
+ cyhal_uart_free(&(self->uart_obj));
+ uart_obj_free(self);
+}
+
+static mp_int_t mp_machine_uart_any(machine_uart_obj_t *self) {
+ return cyhal_uart_readable(&self->uart_obj);
+
+}
+
+static bool mp_machine_uart_txdone(machine_uart_obj_t *self) {
+ return !(cyhal_uart_is_tx_active(&self->uart_obj));
+
+}
+
+// send a character
+static void mp_machine_uart_writechar(machine_uart_obj_t *self, uint16_t data) {
+ cy_rslt_t result = cyhal_uart_putc(&self->uart_obj, data);
+ uart_assert_raise_val("Put character failed with return code %lx !", result);
+}
+
+// Get a character
+static mp_int_t mp_machine_uart_readchar(machine_uart_obj_t *self) {
+ uint8_t value;
+ cy_rslt_t result = cyhal_uart_getc(&self->uart_obj, &value, self->timeout);
+ if (result == CY_RSLT_SUCCESS) {
+ return value;
+ }
+ return -1; // in case of timeout
+}
+
+// Before sending break all UART TX interrupt sources are disabled
+// The state of UART TX interrupt sources is restored before function returns.
+// Blocks until break is completed. Only call this function when UART TX FIFO and shifter are empty.
+static void mp_machine_uart_sendbreak(machine_uart_obj_t *self) {
+ uint32_t breakwidth = 4; // Width of break condition. Valid range is the TX data width (4 to 16 bits). How to get that?
+ Cy_SCB_UART_SendBreakBlocking(self->uart_obj.base, breakwidth);
+}
+
+static mp_irq_obj_t *mp_machine_uart_irq(machine_uart_obj_t *self, bool any_args, mp_arg_val_t *args) {
+ if (self->mp_irq_obj == NULL) {
+ self->mp_irq_trigger = 0;
+ self->mp_irq_obj = mp_irq_new(&uart_irq_methods, MP_OBJ_FROM_PTR(self));
+ }
+ if (any_args) {
+ // Check the handler
+ mp_obj_t handler = args[MP_IRQ_ARG_INIT_handler].u_obj;
+ if (handler != mp_const_none && !mp_obj_is_callable(handler)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("handler must be None or callable"));
+ }
+
+ // Get the trigger
+ mp_uint_t trigger = args[MP_IRQ_ARG_INIT_trigger].u_int;
+ mp_uint_t not_supported = trigger & ~MP_UART_ALLOWED_FLAGS;
+ if (trigger != 0 && not_supported) {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("trigger 0x%08x unsupported"), not_supported);
+ }
+ // Reconfigure user IRQs
+ uart_irq_config(self, false);
+ self->mp_irq_obj->handler = handler;
+ self->mp_irq_obj->ishard = args[MP_IRQ_ARG_INIT_hard].u_bool;
+ self->mp_irq_trigger = trigger;
+ uart_irq_config(self, true);
+ }
+ self->interrupt = 1;
+ return self->mp_irq_obj;
+}
+
+static mp_uint_t mp_machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
+ machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ void *dest = buf_in;
+ size_t rx_length = size;
+ if (self->interrupt == 1) {
+ if (cyhal_uart_readable(&self->uart_obj) > 0) {
+ cy_rslt_t result = cyhal_uart_read_async(&self->uart_obj, dest, rx_length);
+ uart_assert_raise_val("UART read failed with return code %lx !", result);
+ } else {
+ *errcode = MP_EAGAIN;
+ return MP_STREAM_ERROR;
+ }
+ } else {
+ cy_rslt_t result = cyhal_uart_read(&self->uart_obj, dest, &rx_length);
+ uart_assert_raise_val("UART read failed with return code %lx !", result);
+ }
+ if (rx_length <= 0) {
+ *errcode = MP_EAGAIN;
+ return MP_STREAM_ERROR;
+ }
+ return rx_length;
+}
+
+
+
+static mp_uint_t mp_machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
+ machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ size_t tx_length = size;
+ if (self->interrupt == 1) {
+ if (cyhal_uart_writable(&self->uart_obj) > 0) {
+ cy_rslt_t result = cyhal_uart_write_async(&self->uart_obj, (void *)buf_in, tx_length);
+ uart_assert_raise_val("UART write failed with return code %lx !", result);
+ } else {
+ *errcode = MP_EAGAIN;
+ return MP_STREAM_ERROR;
+ }
+ } else {
+ cy_rslt_t result = cyhal_uart_write(&self->uart_obj, (void *)buf_in, &tx_length);
+ uart_assert_raise_val("UART write failed with return code %lx !", result);
+ }
+ if (tx_length < 0) {
+ *errcode = MP_EAGAIN;
+ return MP_STREAM_ERROR;
+ }
+ return tx_length;
+}
+
+static mp_uint_t mp_machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+ machine_uart_obj_t *self = self_in;
+ mp_uint_t ret;
+ if (request == MP_STREAM_POLL) { // Need to understand the select
+ mp_uint_t flags = arg;
+ ret = 0;
+ if ((flags & MP_STREAM_POLL_RD) && cyhal_uart_readable(&self->uart_obj)) {
+ ret |= MP_STREAM_POLL_RD;
+ }
+ if ((flags & MP_STREAM_POLL_WR) && cyhal_uart_writable(&self->uart_obj)) {
+ ret |= MP_STREAM_POLL_WR;
+ }
+ } else if (request == MP_STREAM_FLUSH) {
+ // Since uart.write() waits up to the last byte, uart.flush() always succeeds.
+ ret = 0;
+ } else {
+ *errcode = MP_EINVAL;
+ ret = MP_STREAM_ERROR;
+ }
+ return ret;
+}
+
+void mod_uart_deinit() {
+ for (uint8_t i = 0; i < MAX_UART; i++) {
+ if (uart_obj[i] != NULL) {
+ mp_machine_uart_deinit(uart_obj[i]);
+ }
+ }
+}
diff --git a/ports/psoc6/machine_wdt.c b/ports/psoc6/machine_wdt.c
new file mode 100644
index 0000000000000..063edef1ddbab
--- /dev/null
+++ b/ports/psoc6/machine_wdt.c
@@ -0,0 +1,87 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 "Krzysztof Adamski"
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+#include
+#include
+
+
+// micropython includes
+#include "py/nlr.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "py/mperrno.h"
+#include "shared/timeutils/timeutils.h"
+#include "py/misc.h"
+
+
+// MTB includes
+#include "cyhal.h"
+
+
+// port-specific includes
+#include "modmachine.h"
+
+cyhal_wdt_t psoc6_wdt;
+
+typedef struct _machine_wdt_obj_t {
+ mp_obj_base_t base;
+} machine_wdt_obj_t;
+
+// singleton WDT object
+static const machine_wdt_obj_t machine_wdt_obj = {{&machine_wdt_type}};
+
+static machine_wdt_obj_t *mp_machine_wdt_make_new_instance(mp_int_t id, mp_int_t timeout_ms) {
+ if (id != 0) {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("WDT(%d) doesn't exist"), id);
+ }
+
+ if (timeout_ms <= 0) {
+ mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too low"));
+ } else if (timeout_ms > cyhal_wdt_get_max_timeout_ms()) {
+ mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too high"));
+ }
+
+ cy_rslt_t result = cyhal_wdt_init(&psoc6_wdt, timeout_ms);
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cyhal_wdt_init failed !"));
+ }
+
+ return (machine_wdt_obj_t *)&machine_wdt_obj;
+}
+
+static void mp_machine_wdt_feed(machine_wdt_obj_t *self) {
+ cyhal_wdt_kick(&psoc6_wdt);
+}
+
+void mod_wdt_deinit() {
+ cyhal_wdt_stop(&psoc6_wdt);
+ cyhal_wdt_free(&psoc6_wdt);
+}
diff --git a/ports/psoc6/main.c b/ports/psoc6/main.c
new file mode 100644
index 0000000000000..8c9d3c8c16c67
--- /dev/null
+++ b/ports/psoc6/main.c
@@ -0,0 +1,240 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+#include
+
+
+// MTB includes
+#include "cybsp.h"
+#include "cy_retarget_io.h"
+#include "cyhal.h"
+
+// FreeRTOS header file
+#include
+#include
+#include
+
+
+// micropython includes
+#include "genhdr/mpversion.h"
+#include "py/gc.h"
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "py/stackctrl.h"
+#include "shared/readline/readline.h"
+#include "shared/runtime/pyexec.h"
+#include "extmod/modnetwork.h"
+
+#include "modmachine.h"
+#include "machine_pin_phy.h"
+
+#if MICROPY_PY_NETWORK
+#include "cybsp_wifi.h"
+#include "cy_wcm.h"
+#endif
+
+#if MICROPY_PY_LWIP
+#include "lwip/init.h"
+#include "lwip/apps/mdns.h"
+#endif
+
+// port-specific includes
+#include "mplogger.h"
+
+#define MPY_TASK_STACK_SIZE (4096u)
+#define MPY_TASK_PRIORITY (3u)
+
+typedef enum {
+ BOOT_MODE_NORMAL,
+ BOOT_MODE_SAFE
+} boot_mode_t;
+
+#if MICROPY_ENABLE_GC
+extern uint8_t __StackTop, __StackLimit;
+__attribute__((section(".bss"))) static char gc_heap[MICROPY_GC_HEAP_SIZE];
+#endif
+
+extern void mod_rtc_init(void);
+extern void time_init(void);
+extern void os_init(void);
+extern void network_init(void);
+extern void network_deinit(void);
+
+void mpy_task(void *arg);
+
+TaskHandle_t mpy_task_handle;
+
+boot_mode_t check_boot_mode(void) {
+ boot_mode_t boot_mode;
+
+ // initialize user LED
+ cyhal_gpio_init(CYBSP_USER_LED, CYHAL_GPIO_DIR_OUTPUT,
+ CYHAL_GPIO_DRIVE_STRONG, CYBSP_LED_STATE_OFF);
+
+ // initialize user button
+ cyhal_gpio_init(CYBSP_USER_BTN, CYHAL_GPIO_DIR_INPUT,
+ CYHAL_GPIO_DRIVE_PULLUP, CYBSP_BTN_OFF);
+
+ // Added 5ms delay to allow bypass capacitor connected to the user button without external pull-up to charge.
+ cyhal_system_delay_ms(5);
+
+ if (cyhal_gpio_read(CYBSP_USER_BTN) == CYBSP_BTN_PRESSED) {
+ // Blink LED twice to indicate safe boot mode was entered
+ for (int i = 0; i < 4; i++)
+ {
+ cyhal_gpio_toggle(CYBSP_USER_LED);
+ cyhal_system_delay_ms(500); // delay in millisecond
+ }
+ boot_mode = BOOT_MODE_SAFE;
+ mp_printf(&mp_plat_print, "- DEVICE IS IN SAFE BOOT MODE -\n");
+ } else { // normal boot mode
+ boot_mode = BOOT_MODE_NORMAL;
+ }
+ // free the user LED and user button
+ cyhal_gpio_free(CYBSP_USER_BTN);
+ cyhal_gpio_free(CYBSP_USER_LED);
+
+ return boot_mode;
+}
+
+int main(int argc, char **argv) {
+ // Initialize the device and board peripherals
+ cy_rslt_t result = cybsp_init();
+ if (result != CY_RSLT_SUCCESS) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cybsp_init failed !\n"));
+ }
+
+ // Initialize retarget-io to use the debug UART port
+ result = cy_retarget_io_init(CYBSP_DEBUG_UART_TX, CYBSP_DEBUG_UART_RX, CY_RETARGET_IO_BAUDRATE);
+ if (result != CY_RSLT_SUCCESS) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cy_retarget_io_init failed !\n"));
+ }
+
+ xTaskCreate(mpy_task, "MicroPython task", MPY_TASK_STACK_SIZE, NULL, MPY_TASK_PRIORITY, &mpy_task_handle);
+ vTaskStartScheduler();
+
+ // Should never get here
+ CY_ASSERT(0);
+ return 0;
+}
+
+void mpy_task(void *arg) {
+ #if MICROPY_ENABLE_GC
+ mp_stack_set_top(&__StackTop);
+ // mp_stack_set_limit((mp_uint_t)&__StackTop - (mp_uint_t)&__StackLimit);
+ mp_stack_set_limit((mp_uint_t)&__StackLimit);
+ gc_init(&gc_heap[0], &gc_heap[MP_ARRAY_SIZE(gc_heap)]);
+ #endif
+
+ // Initialize modules. Or to be redone after a reset and therefore to be placed next to machine_init below ?
+ os_init();
+ time_init();
+
+soft_reset:
+ mod_rtc_init();
+ mp_init();
+
+ // ANSI ESC sequence for clear screen. Refer to https://stackoverflow.com/questions/517970/how-to-clear-the-interpreter-console
+ mp_printf(&mp_plat_print, "\033[H\033[2J");
+
+ // indicate in REPL console when debug mode is selected
+ mplogger_print("\n...LOGGER DEBUG MODE...\n\n");
+
+ readline_init0();
+ machine_init();
+ #if MICROPY_PY_NETWORK
+ network_init();
+ mod_network_init();
+ #endif
+
+ #if MICROPY_VFS
+ mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_));
+ mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_lib));
+
+ #if MICROPY_VFS_LFS2
+ pyexec_frozen_module("vfs_lfs2.py", false);
+ #elif MICROPY_VFS_FAT
+ pyexec_frozen_module("vfs_fat.py", false);
+ #endif
+
+ #endif
+
+ if (check_boot_mode() == BOOT_MODE_NORMAL) {
+ // Execute user scripts.
+ int ret = pyexec_file_if_exists("/boot.py");
+
+ if (ret & PYEXEC_FORCED_EXIT) {
+ goto soft_reset;
+ }
+
+ if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
+ ret = pyexec_file_if_exists("/main.py");
+
+ if (ret & PYEXEC_FORCED_EXIT) {
+ goto soft_reset;
+ }
+ }
+ }
+
+ __enable_irq();
+
+ for (;;) {
+ if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
+ if (pyexec_raw_repl() != 0) {
+ break;
+ }
+ } else {
+ if (pyexec_friendly_repl() != 0) {
+ break;
+ }
+ }
+ }
+
+ mp_printf(&mp_plat_print, "MPY: soft reboot\n");
+ #if MICROPY_PY_NETWORK
+ mod_network_deinit();
+ network_deinit();
+ #endif
+ gc_sweep_all();
+ mp_deinit();
+
+ goto soft_reset;
+}
+
+// TODO: to be implemented
+void nlr_jump_fail(void *val) {
+ mplogger_print("nlr_jump_fail\n");
+
+ mp_printf(&mp_plat_print, "FATAL: uncaught exception %p\n", val);
+ mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(val));
+
+ for (;;) {
+ __BKPT(0);
+ }
+}
diff --git a/ports/psoc6/mbedtls/mbedtls_config.h b/ports/psoc6/mbedtls/mbedtls_config.h
new file mode 100644
index 0000000000000..453ccce128efe
--- /dev/null
+++ b/ports/psoc6/mbedtls/mbedtls_config.h
@@ -0,0 +1,58 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef PSOC6_MPY_MBEDTLS_USER_CONFIG_HEADER
+#define PSOC6_MPY_MBEDTLS_USER_CONFIG_HEADER
+
+#include "mbedtls_mtb_config.h"
+
+// Set mbedtls configuration
+#define MBEDTLS_ECP_NIST_OPTIM
+#define MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED
+
+// // // Enable mbedtls modules
+#define MBEDTLS_GCM_C
+#define MBEDTLS_HAVE_TIME
+#define MBEDTLS_HAVE_TIME_DATE
+
+// // #define MBEDTLS_NO_PLATFORM_ENTROPY
+#define MBEDTLS_CIPHER_MODE_CTR
+#define MBEDTLS_CIPHER_MODE_CBC
+
+// Time hook
+// #include
+// time_t psoc6_rtctime_seconds(time_t *timer);
+// #define MBEDTLS_PLATFORM_TIME_MACRO psoc6_rtctime_seconds
+
+// Set MicroPython-specific options.
+#define MICROPY_MBEDTLS_CONFIG_BARE_METAL (1)
+
+// Include common mbedtls configuration.
+// #ifdef MICROPY_CONFIG_ROM_LEVEL
+#include "mbedtls_config_common.h"
+// #endif
+
+#endif /* PSOC6_MPY_MBEDTLS_USER_CONFIG_HEADER */
diff --git a/ports/psoc6/mbedtls/mbedtls_mtb_config.h b/ports/psoc6/mbedtls/mbedtls_mtb_config.h
new file mode 100644
index 0000000000000..5631dd185af56
--- /dev/null
+++ b/ports/psoc6/mbedtls/mbedtls_mtb_config.h
@@ -0,0 +1,875 @@
+/**
+ * \file config.h
+ *
+ * \brief Configuration options (set of defines)
+ *
+ * This set of compile-time options may be used to enable
+ * or disable features selectively, and reduce the global
+ * memory footprint.
+ */
+/*
+ * Copyright (C) 2006-2018, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * This file is part of mbed TLS (https://tls.mbed.org)
+ */
+/*
+ * File copied from: https://github.com/Infineon/wifi-core-freertos-lwip-mbedtls/blob/release-v1.0.0/configs/mbedtls_user_config.h
+ */
+
+#ifndef MBEDTLS_USER_CONFIG_HEADER
+#define MBEDTLS_USER_CONFIG_HEADER
+
+
+/**
+ * Compiling Mbed TLS for Cortex-M0/0+/1/M23 cores with optimization enabled and on ARMC6 compiler results in errors.
+ * These cores lack the required full Thumb-2 support, causing the inline assembly to require more registers than available.
+ * The workaround is to use 'MULADDC_CANNOT_USE_R7' compilation flag, or without optimization flag,
+ * but note that this will compile without the assembly optimization.
+ *
+ * To read more about this issue, refer to https://github.com/ARMmbed/mbed-os/pull/14529/commits/86e7bc559b0d1a055bf84ea9249763d2349fb6e8
+ */
+
+#if defined(COMPONENT_CM0P) && defined(COMPONENT_ARM)
+#define MULADDC_CANNOT_USE_R7
+#endif
+
+
+/**
+ * \def MBEDTLS_HAVE_TIME_DATE
+ *
+ * System has time.h, time(), and an implementation for
+ * mbedtls_platform_gmtime_r() (see below).
+ * The time needs to be correct (not necessarily very accurate, but at least
+ * the date should be correct). This is used to verify the validity period of
+ * X.509 certificates.
+ *
+ * Comment if your system does not have a correct clock.
+ *
+ * \note mbedtls_platform_gmtime_r() is an abstraction in platform_util.h that
+ * behaves similarly to the gmtime_r() function from the C standard. Refer to
+ * the documentation for mbedtls_platform_gmtime_r() for more information.
+ *
+ * \note It is possible to configure an implementation for
+ * mbedtls_platform_gmtime_r() at compile-time by using the macro
+ * MBEDTLS_PLATFORM_GMTIME_R_ALT.
+ */
+#undef MBEDTLS_HAVE_TIME_DATE
+
+
+/**
+ * \def MBEDTLS_PLATFORM_EXIT_ALT
+ *
+ * MBEDTLS_PLATFORM_XXX_ALT: Uncomment a macro to let mbed TLS support the
+ * function in the platform abstraction layer.
+ *
+ * Example: In case you uncomment MBEDTLS_PLATFORM_PRINTF_ALT, mbed TLS will
+ * provide a function "mbedtls_platform_set_printf()" that allows you to set an
+ * alternative printf function pointer.
+ *
+ * All these define require MBEDTLS_PLATFORM_C to be defined!
+ *
+ * \note MBEDTLS_PLATFORM_SNPRINTF_ALT is required on Windows;
+ * it will be enabled automatically by check_config.h
+ *
+ * \warning MBEDTLS_PLATFORM_XXX_ALT cannot be defined at the same time as
+ * MBEDTLS_PLATFORM_XXX_MACRO!
+ *
+ * Requires: MBEDTLS_PLATFORM_TIME_ALT requires MBEDTLS_HAVE_TIME
+ *
+ * Uncomment a macro to enable alternate implementation of specific base
+ * platform function
+ */
+// #define MBEDTLS_PLATFORM_EXIT_ALT
+#define MBEDTLS_PLATFORM_TIME_ALT
+// #define MBEDTLS_PLATFORM_FPRINTF_ALT
+// #define MBEDTLS_PLATFORM_PRINTF_ALT
+// #define MBEDTLS_PLATFORM_SNPRINTF_ALT
+// #define MBEDTLS_PLATFORM_NV_SEED_ALT
+// #define MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT
+
+/**
+ * \def MBEDTLS_ENTROPY_HARDWARE_ALT
+ *
+ * Uncomment this macro to let mbed TLS use your own implementation of a
+ * hardware entropy collector.
+ *
+ * Your function must be called \c mbedtls_hardware_poll(), have the same
+ * prototype as declared in entropy_poll.h, and accept NULL as first argument.
+ *
+ * Uncomment to use your own hardware entropy collector.
+ */
+#define MBEDTLS_ENTROPY_HARDWARE_ALT
+/**
+ * \def MBEDTLS_ECP_DP_SECP192R1_ENABLED
+ *
+ * MBEDTLS_ECP_XXXX_ENABLED: Enables specific curves within the Elliptic Curve
+ * module. By default all supported curves are enabled.
+ *
+ * Comment macros to disable the curve and functions for it
+ */
+#undef MBEDTLS_ECP_DP_SECP192R1_ENABLED
+#undef MBEDTLS_ECP_DP_SECP224R1_ENABLED
+// #define MBEDTLS_ECP_DP_SECP256R1_ENABLED
+#undef MBEDTLS_ECP_DP_SECP384R1_ENABLED
+#undef MBEDTLS_ECP_DP_SECP521R1_ENABLED
+#undef MBEDTLS_ECP_DP_SECP192K1_ENABLED
+#undef MBEDTLS_ECP_DP_SECP224K1_ENABLED
+#undef MBEDTLS_ECP_DP_SECP256K1_ENABLED
+#undef MBEDTLS_ECP_DP_BP256R1_ENABLED
+#undef MBEDTLS_ECP_DP_BP384R1_ENABLED
+#undef MBEDTLS_ECP_DP_BP512R1_ENABLED
+// #undef MBEDTLS_ECP_DP_CURVE25519_ENABLED
+#undef MBEDTLS_ECP_DP_CURVE448_ENABLED
+
+/**
+ * \def MBEDTLS_KEY_EXCHANGE_PSK_ENABLED
+ *
+ * Enable the PSK based ciphersuite modes in SSL / TLS.
+ *
+ * This enables the following ciphersuites (if other requisites are
+ * enabled as well):
+ * MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384
+ * MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384
+ * MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA
+ * MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384
+ * MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384
+ * MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256
+ * MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256
+ * MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA
+ * MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256
+ * MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256
+ * MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA
+ * MBEDTLS_TLS_PSK_WITH_RC4_128_SHA
+ */
+#undef MBEDTLS_KEY_EXCHANGE_PSK_ENABLED
+
+
+/**
+ * \def MBEDTLS_PK_PARSE_EC_EXTENDED
+ *
+ * Enhance support for reading EC keys using variants of SEC1 not allowed by
+ * RFC 5915 and RFC 5480.
+ *
+ * Currently this means parsing the SpecifiedECDomain choice of EC
+ * parameters (only known groups are supported, not arbitrary domains, to
+ * avoid validation issues).
+ *
+ * Disable if you only need to support RFC 5915 + 5480 key formats.
+ */
+#undef MBEDTLS_PK_PARSE_EC_EXTENDED
+
+
+#undef MBEDTLS_FS_IO
+
+
+/**
+ * \def MBEDTLS_NO_PLATFORM_ENTROPY
+ *
+ * Do not use built-in platform entropy functions.
+ * This is useful if your platform does not support
+ * standards like the /dev/urandom or Windows CryptoAPI.
+ *
+ * Uncomment this macro to disable the built-in platform entropy functions.
+ */
+#define MBEDTLS_NO_PLATFORM_ENTROPY
+
+/**
+ * \def MBEDTLS_ENTROPY_FORCE_SHA256
+ *
+ * Force the entropy accumulator to use a SHA-256 accumulator instead of the
+ * default SHA-512 based one (if both are available).
+ *
+ * Requires: MBEDTLS_SHA256_C
+ *
+ * On 32-bit systems SHA-256 can be much faster than SHA-512. Use this option
+ * if you have performance concerns.
+ *
+ * This option is only useful if both MBEDTLS_SHA256_C and
+ * MBEDTLS_SHA512_C are defined. Otherwise the available hash module is used.
+ */
+#define MBEDTLS_ENTROPY_FORCE_SHA256
+
+/**
+ * \def MBEDTLS_SELF_TEST
+ *
+ * Enable the checkup functions (*_self_test).
+ */
+#undef MBEDTLS_SELF_TEST
+
+/**
+ * \def MBEDTLS_SSL_FALLBACK_SCSV
+ *
+ * Enable support for FALLBACK_SCSV (draft-ietf-tls-downgrade-scsv-00).
+ *
+ * For servers, it is recommended to always enable this, unless you support
+ * only one version of TLS, or know for sure that none of your clients
+ * implements a fallback strategy.
+ *
+ * For clients, you only need this if you're using a fallback strategy, which
+ * is not recommended in the first place, unless you absolutely need it to
+ * interoperate with buggy (version-intolerant) servers.
+ *
+ * Comment this macro to disable support for FALLBACK_SCSV
+ */
+#undef MBEDTLS_SSL_FALLBACK_SCSV
+
+/**
+ * \def MBEDTLS_SSL_CBC_RECORD_SPLITTING
+ *
+ * Enable 1/n-1 record splitting for CBC mode in SSLv3 and TLS 1.0.
+ *
+ * This is a countermeasure to the BEAST attack, which also minimizes the risk
+ * of interoperability issues compared to sending 0-length records.
+ *
+ * Comment this macro to disable 1/n-1 record splitting.
+ */
+#undef MBEDTLS_SSL_CBC_RECORD_SPLITTING
+
+/**
+ * \def MBEDTLS_SSL_RENEGOTIATION
+ *
+ * Enable support for TLS renegotiation.
+ *
+ * The two main uses of renegotiation are (1) refresh keys on long-lived
+ * connections and (2) client authentication after the initial handshake.
+ * If you don't need renegotiation, it's probably better to disable it, since
+ * it has been associated with security issues in the past and is easy to
+ * misuse/misunderstand.
+ *
+ * Comment this to disable support for renegotiation.
+ *
+ * \note Even if this option is disabled, both client and server are aware
+ * of the Renegotiation Indication Extension (RFC 5746) used to
+ * prevent the SSL renegotiation attack (see RFC 5746 Sect. 1).
+ * (See \c mbedtls_ssl_conf_legacy_renegotiation for the
+ * configuration of this extension).
+ *
+ */
+#undef MBEDTLS_SSL_RENEGOTIATION
+
+/**
+ * \def MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO
+ *
+ * Enable support for receiving and parsing SSLv2 Client Hello messages for the
+ * SSL Server module (MBEDTLS_SSL_SRV_C).
+ *
+ * Uncomment this macro to enable support for SSLv2 Client Hello messages.
+ */
+// #define MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO
+
+/**
+ * \def MBEDTLS_SSL_PROTO_TLS1
+ *
+ * Enable support for TLS 1.0.
+ *
+ * Requires: MBEDTLS_MD5_C
+ * MBEDTLS_SHA1_C
+ *
+ * Comment this macro to disable support for TLS 1.0
+ */
+#undef MBEDTLS_SSL_PROTO_TLS1
+
+/**
+ * \def MBEDTLS_SSL_PROTO_TLS1_1
+ *
+ * Enable support for TLS 1.1 (and DTLS 1.0 if DTLS is enabled).
+ *
+ * Requires: MBEDTLS_MD5_C
+ * MBEDTLS_SHA1_C
+ *
+ * Comment this macro to disable support for TLS 1.1 / DTLS 1.0
+ */
+#undef MBEDTLS_SSL_PROTO_TLS1_1
+
+/**
+ * \def MBEDTLS_SSL_PROTO_DTLS
+ *
+ * Enable support for DTLS (all available versions).
+ *
+ * Enable this and MBEDTLS_SSL_PROTO_TLS1_1 to enable DTLS 1.0,
+ * and/or this and MBEDTLS_SSL_PROTO_TLS1_2 to enable DTLS 1.2.
+ *
+ * Requires: MBEDTLS_SSL_PROTO_TLS1_1
+ * or MBEDTLS_SSL_PROTO_TLS1_2
+ *
+ * Comment this macro to disable support for DTLS
+ */
+#undef MBEDTLS_SSL_PROTO_DTLS
+
+/**
+ * \def MBEDTLS_SSL_DTLS_ANTI_REPLAY
+ *
+ * Enable support for the anti-replay mechanism in DTLS.
+ *
+ * Requires: MBEDTLS_SSL_TLS_C
+ * MBEDTLS_SSL_PROTO_DTLS
+ *
+ * \warning Disabling this is often a security risk!
+ * See mbedtls_ssl_conf_dtls_anti_replay() for details.
+ *
+ * Comment this to disable anti-replay in DTLS.
+ */
+#undef MBEDTLS_SSL_DTLS_ANTI_REPLAY
+
+/**
+ * \def MBEDTLS_SSL_DTLS_HELLO_VERIFY
+ *
+ * Enable support for HelloVerifyRequest on DTLS servers.
+ *
+ * This feature is highly recommended to prevent DTLS servers being used as
+ * amplifiers in DoS attacks against other hosts. It should always be enabled
+ * unless you know for sure amplification cannot be a problem in the
+ * environment in which your server operates.
+ *
+ * \warning Disabling this can ba a security risk! (see above)
+ *
+ * Requires: MBEDTLS_SSL_PROTO_DTLS
+ *
+ * Comment this to disable support for HelloVerifyRequest.
+ */
+#undef MBEDTLS_SSL_DTLS_HELLO_VERIFY
+
+/**
+ * \def MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE
+ *
+ * Enable server-side support for clients that reconnect from the same port.
+ *
+ * Some clients unexpectedly close the connection and try to reconnect using the
+ * same source port. This needs special support from the server to handle the
+ * new connection securely, as described in section 4.2.8 of RFC 6347. This
+ * flag enables that support.
+ *
+ * Requires: MBEDTLS_SSL_DTLS_HELLO_VERIFY
+ *
+ * Comment this to disable support for clients reusing the source port.
+ */
+#undef MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE
+
+/**
+ * \def MBEDTLS_SSL_DTLS_BADMAC_LIMIT
+ *
+ * Enable support for a limit of records with bad MAC.
+ *
+ * See mbedtls_ssl_conf_dtls_badmac_limit().
+ *
+ * Requires: MBEDTLS_SSL_PROTO_DTLS
+ */
+#undef MBEDTLS_SSL_DTLS_BADMAC_LIMIT
+
+/**
+ * \def MBEDTLS_SSL_SESSION_TICKETS
+ *
+ * Enable support for RFC 5077 session tickets in SSL.
+ * Client-side, provides full support for session tickets (maintenance of a
+ * session store remains the responsibility of the application, though).
+ * Server-side, you also need to provide callbacks for writing and parsing
+ * tickets, including authenticated encryption and key management. Example
+ * callbacks are provided by MBEDTLS_SSL_TICKET_C.
+ *
+ * Comment this macro to disable support for SSL session tickets
+ */
+#undef MBEDTLS_SSL_SESSION_TICKETS
+
+/**
+ * \def MBEDTLS_SSL_EXPORT_KEYS
+ *
+ * Enable support for exporting key block and master secret.
+ * This is required for certain users of TLS, e.g. EAP-TLS.
+ *
+ * Comment this macro to disable support for key export
+ */
+#undef MBEDTLS_SSL_EXPORT_KEYS
+
+
+/**
+ * \def MBEDTLS_SSL_TRUNCATED_HMAC
+ *
+ * Enable support for RFC 6066 truncated HMAC in SSL.
+ *
+ * Comment this macro to disable support for truncated HMAC in SSL
+ */
+#undef MBEDTLS_SSL_TRUNCATED_HMAC
+
+/**
+ * \def MBEDTLS_X509_RSASSA_PSS_SUPPORT
+ *
+ * Enable parsing and verification of X.509 certificates, CRLs and CSRS
+ * signed with RSASSA-PSS (aka PKCS#1 v2.1).
+ *
+ * Comment this macro to disallow using RSASSA-PSS in certificates.
+ */
+#undef MBEDTLS_X509_RSASSA_PSS_SUPPORT
+
+/**
+ * \def MBEDTLS_AESNI_C
+ *
+ * Enable AES-NI support on x86-64.
+ *
+ * Module: library/aesni.c
+ * Caller: library/aes.c
+ *
+ * Requires: MBEDTLS_HAVE_ASM
+ *
+ * This modules adds support for the AES-NI instructions on x86-64
+ */
+#undef MBEDTLS_AESNI_C
+
+/**
+ * \def MBEDTLS_NET_C
+ *
+ * Enable the TCP and UDP over IPv6/IPv4 networking routines.
+ *
+ * \note This module only works on POSIX/Unix (including Linux, BSD and OS X)
+ * and Windows. For other platforms, you'll want to disable it, and write your
+ * own networking callbacks to be passed to \c mbedtls_ssl_set_bio().
+ *
+ * \note See also our Knowledge Base article about porting to a new
+ * environment:
+ * https://tls.mbed.org/kb/how-to/how-do-i-port-mbed-tls-to-a-new-environment-OS
+ *
+ * Module: library/net_sockets.c
+ *
+ * This module provides networking routines.
+ */
+#undef MBEDTLS_NET_C
+
+/**
+ * \def MBEDTLS_SSL_COOKIE_C
+ *
+ * Enable basic implementation of DTLS cookies for hello verification.
+ *
+ * Module: library/ssl_cookie.c
+ * Caller:
+ */
+#undef MBEDTLS_SSL_COOKIE_C
+
+/**
+ * \def MBEDTLS_TIMING_C
+ *
+ * Enable the semi-portable timing interface.
+ *
+ * \note The provided implementation only works on POSIX/Unix (including Linux,
+ * BSD and OS X) and Windows. On other platforms, you can either disable that
+ * module and provide your own implementations of the callbacks needed by
+ * \c mbedtls_ssl_set_timer_cb() for DTLS, or leave it enabled and provide
+ * your own implementation of the whole module by setting
+ * \c MBEDTLS_TIMING_ALT in the current file.
+ *
+ * \note See also our Knowledge Base article about porting to a new
+ * environment:
+ * https://tls.mbed.org/kb/how-to/how-do-i-port-mbed-tls-to-a-new-environment-OS
+ *
+ * Module: library/timing.c
+ * Caller: library/havege.c
+ *
+ * This module is used by the HAVEGE random number generator.
+ */
+#undef MBEDTLS_TIMING_C
+
+/**
+ * \def MBEDTLS_X509_CRL_PARSE_C
+ *
+ * Enable X.509 CRL parsing.
+ *
+ * Module: library/x509_crl.c
+ * Caller: library/x509_crt.c
+ *
+ * Requires: MBEDTLS_X509_USE_C
+ *
+ * This module is required for X.509 CRL parsing.
+ */
+#undef MBEDTLS_X509_CRL_PARSE_C
+
+/**
+ * \def MBEDTLS_X509_CSR_PARSE_C
+ *
+ * Enable X.509 Certificate Signing Request (CSR) parsing.
+ *
+ * Module: library/x509_csr.c
+ * Caller: library/x509_crt_write.c
+ *
+ * Requires: MBEDTLS_X509_USE_C
+ *
+ * This module is used for reading X.509 certificate request.
+ */
+#undef MBEDTLS_X509_CSR_PARSE_C
+
+/**
+ * \def MBEDTLS_X509_CREATE_C
+ *
+ * Enable X.509 core for creating certificates.
+ *
+ * Module: library/x509_create.c
+ *
+ * Requires: MBEDTLS_BIGNUM_C, MBEDTLS_OID_C, MBEDTLS_PK_WRITE_C
+ *
+ * This module is the basis for creating X.509 certificates and CSRs.
+ */
+#undef MBEDTLS_X509_CREATE_C
+
+/**
+ * \def MBEDTLS_X509_CSR_WRITE_C
+ *
+ * Enable creating X.509 Certificate Signing Requests (CSR).
+ *
+ * Module: library/x509_csr_write.c
+ *
+ * Requires: MBEDTLS_X509_CREATE_C
+ *
+ * This module is required for X.509 certificate request writing.
+ */
+#undef MBEDTLS_X509_CSR_WRITE_C
+
+/**
+ * \def MBEDTLS_X509_CRT_WRITE_C
+ *
+ * Enable creating X.509 certificates.
+ *
+ * Module: library/x509_crt_write.c
+ *
+ * Requires: MBEDTLS_X509_CREATE_C
+ *
+ * This module is required for X.509 certificate creation.
+ */
+#undef MBEDTLS_X509_CRT_WRITE_C
+
+/**
+ * \def MBEDTLS_CERTS_C
+ *
+ * Enable the test certificates.
+ *
+ * Module: library/certs.c
+ * Caller:
+ *
+ * This module is used for testing (ssl_client/server).
+ */
+#undef MBEDTLS_CERTS_C
+
+/**
+ * \def MBEDTLS_ERROR_C
+ *
+ * Enable error code to error string conversion.
+ *
+ * Module: library/error.c
+ * Caller:
+ *
+ * This module enables mbedtls_strerror().
+ */
+#undef MBEDTLS_ERROR_C
+
+/**
+ * \def MBEDTLS_PADLOCK_C
+ *
+ * Enable VIA Padlock support on x86.
+ *
+ * Module: library/padlock.c
+ * Caller: library/aes.c
+ *
+ * Requires: MBEDTLS_HAVE_ASM
+ *
+ * This modules adds support for the VIA PadLock on x86.
+ */
+#undef MBEDTLS_PADLOCK_C
+
+/**
+ * \def MBEDTLS_RIPEMD160_C
+ *
+ * Enable the RIPEMD-160 hash algorithm.
+ *
+ * Module: library/ripemd160.c
+ * Caller: library/md.c
+ *
+ */
+#undef MBEDTLS_RIPEMD160_C
+
+/**
+ * \def MBEDTLS_PK_RSA_ALT_SUPPORT
+ *
+ * Support external private RSA keys (eg from a HSM) in the PK layer.
+ *
+ * Comment this macro to disable support for external private RSA keys.
+ */
+#undef MBEDTLS_PK_RSA_ALT_SUPPORT
+
+/**
+ * \def MBEDTLS_ARC4_C
+ *
+ * Enable the ARCFOUR stream cipher.
+ *
+ * Module: library/arc4.c
+ * Caller: library/cipher.c
+ *
+ * This module enables the following ciphersuites (if other requisites are
+ * enabled as well):
+ * MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_RSA_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_RSA_WITH_RC4_128_MD5
+ * MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA
+ * MBEDTLS_TLS_PSK_WITH_RC4_128_SHA
+ *
+ * \warning ARC4 is considered a weak cipher and its use constitutes a
+ * security risk. If possible, we recommend avoidng dependencies on
+ * it, and considering stronger ciphers instead.
+ *
+ */
+#undef MBEDTLS_ARC4_C
+
+/**
+ * \def MBEDTLS_XTEA_C
+ *
+ * Enable the XTEA block cipher.
+ *
+ * Module: library/xtea.c
+ * Caller:
+ */
+#undef MBEDTLS_XTEA_C
+
+/**
+ * \def MBEDTLS_BLOWFISH_C
+ *
+ * Enable the Blowfish block cipher.
+ *
+ * Module: library/blowfish.c
+ */
+#undef MBEDTLS_BLOWFISH_C
+
+/**
+ * \def MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED
+ *
+ * Enable the DHE-PSK based ciphersuite modes in SSL / TLS.
+ *
+ * Requires: MBEDTLS_DHM_C
+ *
+ * This enables the following ciphersuites (if other requisites are
+ * enabled as well):
+ * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384
+ * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384
+ * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA
+ * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384
+ * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384
+ * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256
+ * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256
+ * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA
+ * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256
+ * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256
+ * MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA
+ * MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA
+ *
+ * \warning Using DHE constitutes a security risk as it
+ * is not possible to validate custom DH parameters.
+ * If possible, it is recommended users should consider
+ * preferring other methods of key exchange.
+ * See dhm.h for more details.
+ *
+ */
+#undef MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED
+
+/**
+ * \def MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED
+ *
+ * Enable the ECDHE-PSK based ciphersuite modes in SSL / TLS.
+ *
+ * Requires: MBEDTLS_ECDH_C
+ *
+ * This enables the following ciphersuites (if other requisites are
+ * enabled as well):
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA
+ * MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA
+ */
+#undef MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED
+
+/**
+ * \def MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED
+ *
+ * Enable the RSA-PSK based ciphersuite modes in SSL / TLS.
+ *
+ * Requires: MBEDTLS_RSA_C, MBEDTLS_PKCS1_V15,
+ * MBEDTLS_X509_CRT_PARSE_C
+ *
+ * This enables the following ciphersuites (if other requisites are
+ * enabled as well):
+ * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384
+ * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384
+ * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA
+ * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384
+ * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384
+ * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256
+ * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256
+ * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA
+ * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256
+ * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256
+ * MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA
+ * MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA
+ */
+#undef MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED
+
+/**
+ * \def MBEDTLS_PSA_CRYPTO_C
+ *
+ * Enable the Platform Security Architecture cryptography API.
+ *
+ * \warning The PSA Crypto API is still beta status. While you're welcome to
+ * experiment using it, incompatible API changes are still possible, and some
+ * parts may not have reached the same quality as the rest of Mbed TLS yet.
+ *
+ * Module: library/psa_crypto.c
+ *
+ * Requires: MBEDTLS_CTR_DRBG_C, MBEDTLS_ENTROPY_C
+ *
+ */
+#undef MBEDTLS_PSA_CRYPTO_C
+
+/**
+ * \def MBEDTLS_PSA_CRYPTO_STORAGE_C
+ *
+ * Enable the Platform Security Architecture persistent key storage.
+ *
+ * Module: library/psa_crypto_storage.c
+ *
+ * Requires: MBEDTLS_PSA_CRYPTO_C,
+ * either MBEDTLS_PSA_ITS_FILE_C or a native implementation of
+ * the PSA ITS interface
+ */
+#undef MBEDTLS_PSA_CRYPTO_STORAGE_C
+
+/**
+ * \def MBEDTLS_PSA_ITS_FILE_C
+ *
+ * Enable the emulation of the Platform Security Architecture
+ * Internal Trusted Storage (PSA ITS) over files.
+ *
+ * Module: library/psa_its_file.c
+ *
+ * Requires: MBEDTLS_FS_IO
+ */
+#undef MBEDTLS_PSA_ITS_FILE_C
+
+/**
+ * \def MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
+ *
+ * This option controls the availability of the API mbedtls_ssl_get_peer_cert()
+ * giving access to the peer's certificate after completion of the handshake.
+ *
+ * Unless you need mbedtls_ssl_peer_cert() in your application, it is
+ * recommended to disable this option for reduced RAM usage.
+ *
+ * \note If this option is disabled, mbedtls_ssl_get_peer_cert() is still
+ * defined, but always returns \c NULL.
+ *
+ * \note This option has no influence on the protection against the
+ * triple handshake attack. Even if it is disabled, Mbed TLS will
+ * still ensure that certificates do not change during renegotiation,
+ * for example by keeping a hash of the peer's certificate.
+ *
+ * Comment this macro to disable storing the peer's certificate
+ * after the handshake.
+ */
+#undef MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
+
+/**
+ * \def MBEDTLS_DEPRECATED_REMOVED
+ *
+ * Remove deprecated functions and features so that they generate an error if
+ * used. Functionality deprecated in one version will usually be removed in the
+ * next version. You can enable this to help you prepare the transition to a
+ * new major version by making sure your code is not using this functionality.
+ *
+ * Uncomment to get errors on using deprecated functions and features.
+ */
+#define MBEDTLS_DEPRECATED_REMOVED
+
+/**
+ * \def Enable MBEDTLS debug logs
+ *
+ * MBEDTLS_VERBOSE values:
+ * 0 No debug - No logs are printed on console
+ * 1 Error - Error messages are printed on console
+ * 2 State change - State level change logs are printed on console
+ * 3 Informational - Informational logs printed on console
+ * 4 Verbose - All the logs are printed on console
+ */
+#define MBEDTLS_VERBOSE 0
+
+/**
+ * \def Enable alternate crypto implementations to use the hardware
+ * acceleration. Include The hardware acceleration module's (cy-mbedtls-acceleration)
+ * header file to enable the supported ALT configurations.
+ */
+#ifndef DISABLE_MBEDTLS_ACCELERATION
+#include "mbedtls_alt_config.h"
+
+/**
+ * The cy-mbedtls-acceleration module supports only DP_SECP192R1,
+ * SECP224R1, SECP256R1, SECP384R1 and SECP521R1 curves. If any
+ * other curve is enabled, need to disable the MBEDTLS_ECP_ALT.
+ */
+#ifdef MBEDTLS_ECP_DP_SECP192K1_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+#ifdef MBEDTLS_ECP_DP_SECP224K1_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+#ifdef MBEDTLS_ECP_DP_SECP256K1_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+#ifdef MBEDTLS_ECP_DP_BP256R1_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+#ifdef MBEDTLS_ECP_DP_BP384R1_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+#ifdef MBEDTLS_ECP_DP_BP512R1_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+#ifdef MBEDTLS_ECP_DP_CURVE25519_ENABLED
+#undef MBEDTLS_ECP_ALT
+#undef MBEDTLS_ECDH_GEN_PUBLIC_ALT
+#undef MBEDTLS_ECDSA_SIGN_ALT
+#undef MBEDTLS_ECDSA_VERIFY_ALT
+#endif
+
+#endif /* DISABLE_MBEDTLS_ACCELERATION */
+
+#endif /* MBEDTLS_USER_CONFIG_HEADER */
diff --git a/ports/psoc6/modgc.c b/ports/psoc6/modgc.c
new file mode 100644
index 0000000000000..1ddf05343256e
--- /dev/null
+++ b/ports/psoc6/modgc.c
@@ -0,0 +1,50 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// micropython includes
+#include "py/gc.h"
+#include "shared/runtime/gchelper.h"
+
+
+#if MICROPY_ENABLE_GC
+
+void gc_collect(void) {
+ gc_collect_start();
+ gc_helper_collect_regs_and_stack();
+ #if MICROPY_PY_THREAD
+ mp_thread_gc_others();
+ #endif
+ gc_collect_end();
+
+
+ #if MICROPY_LOGGER_DEBUG
+
+ gc_dump_info();
+
+ #endif
+}
+
+#endif
diff --git a/ports/psoc6/modmachine.c b/ports/psoc6/modmachine.c
new file mode 100644
index 0000000000000..a5d7f33bacbf0
--- /dev/null
+++ b/ports/psoc6/modmachine.c
@@ -0,0 +1,384 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+
+// mpy includes
+#include "py/obj.h"
+#include "py/gc.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "shared/runtime/pyexec.h"
+#include "extmod/modnetwork.h"
+
+// MTB includes
+#include "cybsp.h"
+#include "cyhal.h"
+#include "cy_pdl.h"
+
+// port-specific includes
+#include "modmachine.h"
+#include "mplogger.h"
+#include "modpsoc6.h"
+#if MICROPY_PY_MACHINE
+
+// enums to hold the MPY constants as given in guidelines
+enum {
+ MACHINE_PWRON_RESET,
+ MACHINE_HARD_RESET,
+ MACHINE_WDT_RESET,
+ MACHINE_DEEPSLEEP_RESET,
+ MACHINE_SOFT_RESET
+};
+
+uint32_t reset_cause;
+
+// function to return 64-bit silicon ID of given PSoC microcontroller
+// A combined 64-bit unique ID. [63:57] - DIE_YEAR [56:56] - DIE_MINOR [55:48] - DIE_SORT [47:40] - DIE_Y [39:32] - DIE_X [31:24] - DIE_WAFER [23:16] - DIE_LOT[2] [15: 8] - DIE_LOT[1] [ 7: 0] - DIE_LOT[0]
+static uint64_t system_get_unique_id(void) {
+ return Cy_SysLib_GetUniqueId();
+}
+
+// helper function to generate random alphanumeric hash
+static uint8_t system_rand_hash(uint8_t length) {
+ uint8_t hash_sum = 0;
+ char charset[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}; // hash can be made stronger but
+ // uint8_t can only hold <=255
+
+ while (length-- > 0) {
+ uint8_t idx = rand() % sizeof(charset);
+ hash_sum = hash_sum + (int)charset[idx];
+ }
+ return hash_sum;
+}
+
+// global var to store current irq state/hash
+static uint8_t system_irq_key;
+
+// defines how strong the hash for enable/disable interrupt is, how many chars long
+#define HASH_CHARS_NUM 10
+
+// function to disable global IRQs
+// returns alphanumeric hash to enable IRQs later
+static uint8_t system_disable_global_irq(void) {
+ uint8_t state = system_rand_hash(HASH_CHARS_NUM); // 10 chars long key gen;
+ __disable_irq();
+ system_irq_key = state;
+ return state;
+}
+
+// function to enable global IRQs
+// uses passed alphanumeric key to verify and enable IRQs
+static bool system_enable_global_irq(uint8_t state) {
+ if (state == system_irq_key) {
+ __enable_irq();
+ return true;
+ } else {
+ return false;
+ }
+}
+
+// API to return clock freq; Fast CLK (CM4) is the main sys clk
+static uint32_t system_get_cpu_freq(void) {
+ return Cy_SysClk_ClkFastGetFrequency();
+}
+
+void machine_init(void) {
+ mplogger_print("machine init\n");
+ // TODO: put all module init functions here ?
+ // machine_pin_init(); ?
+}
+
+void machine_deinit(void) {
+ // we are doing a soft-reset so change the reset_cause
+ reset_cause = MACHINE_SOFT_RESET;
+ mplogger_print("machine deinit\n");
+ mod_wdt_deinit();
+ mod_pin_deinit();
+ mod_adcblock_deinit();
+ mod_i2c_deinit();
+ mod_pwm_deinit();
+ mod_spi_deinit();
+ mod_rtc_deinit();
+ mod_timer_deinit();
+ #if MICROPY_ENABLE_SD_CARD
+ mod_sdcard_deinit();
+ #endif
+}
+
+// machine.info([dump_alloc_table])
+// Print out lots of information about the board.
+static mp_obj_t machine_info(size_t n_args, const mp_obj_t *args) {
+ mp_printf(&mp_plat_print, "\nmachine info :\n");
+
+ // qstr info
+ {
+ size_t n_pool, n_qstr, n_str_data_bytes, n_total_bytes;
+ qstr_pool_info(&n_pool, &n_qstr, &n_str_data_bytes, &n_total_bytes);
+ mp_printf(&mp_plat_print, "\n qstr :\n n_pool = %u\n n_qstr = %u\n n_str_data_bytes = %u\n n_total_bytes = %u\n", n_pool, n_qstr, n_str_data_bytes, n_total_bytes);
+ }
+
+ // GC info
+ {
+ gc_info_t info;
+ gc_info(&info);
+ mp_printf(&mp_plat_print, "\n GC heap :\n");
+ mp_printf(&mp_plat_print, " total : 0x%x (%u)\n", info.total, info.total);
+ mp_printf(&mp_plat_print, " used : 0x%x (%u)\n", info.used, info.used);
+ mp_printf(&mp_plat_print, " free : 0x%x (%u)\n", info.free, info.free);
+ mp_printf(&mp_plat_print, " #1-blocks = 0x%x #2-blocks = 0x%x max-block = 0x%x\n", info.num_1block, info.num_2block, info.max_block);
+
+
+ extern uint8_t __StackTop, __StackLimit;
+ mp_printf(&mp_plat_print, "\n GC stack :\n");
+ printf(" __StackTop : 0x%x (%u)\n", (mp_uint_t)&__StackTop, (mp_uint_t)&__StackTop);
+ printf(" __StackLimit : 0x%x (%u)\n", (mp_uint_t)&__StackLimit, (mp_uint_t)&__StackLimit);
+ printf(" GC stack limit : 0x%x (%u)\n\n", (mp_uint_t)&__StackTop - (mp_uint_t)&__StackLimit, (mp_uint_t)&__StackTop - (mp_uint_t)&__StackLimit);
+
+ printf(" GC heap size : 0x%x (%u)\n", MICROPY_GC_HEAP_SIZE, MICROPY_GC_HEAP_SIZE);
+ }
+
+ // flash info
+ {
+ mp_printf(&mp_plat_print, "\n flash memory map :\n");
+
+ cyhal_flash_t cyhal_flash_obj;
+ cyhal_flash_info_t flash_info;
+
+ // Initialize flash object
+ cyhal_flash_init(&cyhal_flash_obj);
+
+ // Get flash characteristics
+ cyhal_flash_get_info(&cyhal_flash_obj, &flash_info);
+
+ // Wait for 100ms for the flash write to complete
+ uint32_t timeout = 100;
+
+ // Wait for the command to finish execution
+ while ((true != cyhal_flash_is_operation_complete(&cyhal_flash_obj)) && (0 < timeout)) {
+ timeout--;
+ cyhal_system_delay_ms(1); // delay one millisecond each iteration
+ }
+
+ const cyhal_flash_block_info_t *block_info = 0;
+
+ if (0 != timeout) {
+ for (int index = 0; index < flash_info.block_count; index++)
+ {
+ block_info = flash_info.blocks;
+ block_info += index;
+
+ mp_printf(&mp_plat_print, " block_info->start_address : 0x%lx\n", block_info->start_address);
+ mp_printf(&mp_plat_print, " block_info->size : 0x%lx\n", block_info->size);
+ mp_printf(&mp_plat_print, " block_info->sector_size : 0x%lx\n", block_info->sector_size);
+ mp_printf(&mp_plat_print, " block_info->page_size : 0x%lx\n", block_info->page_size);
+ mp_printf(&mp_plat_print, " block_info->erase_value : 0x%x\n\n", block_info->erase_value);
+ }
+ }
+ }
+
+
+ mp_printf(&mp_plat_print, "\n");
+ return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_info_obj, 0, 1, machine_info);
+
+
+static mp_obj_t mp_machine_get_freq(void) {
+ return MP_OBJ_NEW_SMALL_INT(system_get_cpu_freq());
+}
+
+static void mp_machine_set_freq(size_t n_args, const mp_obj_t *args) {
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("Not implemented!!!\n"));
+}
+
+// Sleep Modes Not working. Might be because of the REPL always running in background. Need to evaluate
+static void mp_machine_lightsleep(size_t n_args, const mp_obj_t *args) {
+ // cy_rslt_t result;
+ // if (n_args != 0) {
+ // uint32_t expiry = mp_obj_get_int(args[0]);
+ // cyhal_lptimer_t obj;
+ // uint32_t actual_ms;
+ // result = cyhal_syspm_tickless_sleep(&obj, expiry, &actual_ms);
+ // if (result != CY_RSLT_SUCCESS) {
+ // mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Light sleeep failed %lx !"), result);
+ // }
+ // } else {
+ // result = cyhal_syspm_sleep();
+ // if (result != CY_RSLT_SUCCESS) {
+ // mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Light sleeep failed %lx !"), result);
+ // }
+ // }
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("Not implemented!!!\n"));
+}
+
+NORETURN static void mp_machine_deepsleep(size_t n_args, const mp_obj_t *args) {
+ // cy_rslt_t result;
+ // if (n_args != 0) {
+ // uint32_t expiry = mp_obj_get_int(args[0]);
+ // cyhal_lptimer_t obj;
+ // uint32_t actual_ms;
+ // result = cyhal_syspm_tickless_deepsleep(&obj, expiry, &actual_ms);
+ // if (result != CY_RSLT_SUCCESS) {
+ // mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Deep sleeep failed %lx !"), result);
+ // }
+ // } else {
+ // result = cyhal_syspm_deepsleep();
+ // if (result != CY_RSLT_SUCCESS) {
+ // mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Deep sleeep failed %lx !"), result);
+ // }
+ // }
+ // for (;;)
+ // {
+
+ // }
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("Not implemented!!!\n"));
+}
+
+// machine.idle()
+// This executies a wfi machine instruction which reduces power consumption
+// of the MCU until an interrupt occurs, at which point execution continues.
+// see: https://www.infineon.com/dgdl/Infineon-AN219528_PSoC_6_MCU_low-power_modes_and_power_reduction_techniques-ApplicationNotes-v06_00-EN.pdf?fileId=8ac78c8c7cdc391c017d0d31efdc659f pg.7
+static void mp_machine_idle(void) {
+ __WFI(); // standard ARM instruction
+}
+
+// machine.unique_id()
+static mp_obj_t mp_machine_unique_id(void) {
+ uint64_t id = system_get_unique_id();
+ byte *id_addr = (byte *)&id;
+ // printf("ID_formatted:%02x%02x%02x%02x:%02x%02x%02x%02x\n", id_addr[0], id_addr[1], id_addr[2], id_addr[3], id_addr[4], id_addr[5], id_addr[6], id_addr[7]);
+ return mp_obj_new_bytes(id_addr, 8);
+}
+
+// machine.reset()
+// using watchdog timer to count to minimum value (1ms) to trigger reset
+// thread-safe way as other methods might interfere with pending interrupts, threads etc.
+NORETURN static void mp_machine_reset(void) {
+ cyhal_wdt_t wdt_obj;
+ cyhal_wdt_init(&wdt_obj, 1); // min 1ms count time
+ cyhal_wdt_start(&wdt_obj);
+ while (true) {
+ }
+ ;
+}
+// This function is called from MPY side and is for addressing soft reset from micropython side. This does not indicate a system level soft reset.
+static mp_int_t mp_machine_reset_cause(void) {
+ if (reset_cause == MACHINE_SOFT_RESET) {
+ return MACHINE_SOFT_RESET;
+ } else {
+ mp_obj_t sys_reset = system_reset_cause();
+ uint32_t sys_reset_cause = mp_obj_get_int(sys_reset);
+ if (sys_reset_cause == SYSTEM_RESET_NONE) {
+ reset_cause = MACHINE_PWRON_RESET;
+ } else if (sys_reset_cause == SYSTEM_RESET_WDT) {
+ reset_cause = MACHINE_WDT_RESET;
+ } else if (sys_reset_cause == SYSTEM_RESET_DEEPSLEEP_FAULT) {
+ reset_cause = MACHINE_DEEPSLEEP_RESET;
+ } else {
+ reset_cause = MACHINE_HARD_RESET;
+ }
+ }
+
+ return reset_cause;
+}
+
+// machine.disable_irq()
+static mp_obj_t machine_disable_irq(void) {
+ uint32_t state = system_disable_global_irq();
+ return mp_obj_new_int(state);
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_disable_irq_obj, machine_disable_irq);
+
+// machine.enable_irq()
+static mp_obj_t machine_enable_irq(mp_obj_t state_in) {
+ uint32_t state = mp_obj_get_int(state_in);
+ bool result = system_enable_global_irq(state);
+ if (!result) {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Interrupt enabling failed!"));
+ }
+ return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(machine_enable_irq_obj, machine_enable_irq);
+
+static mp_obj_t machine_rng(void) {
+ uint32_t rnd_num;
+ cyhal_trng_t trng_obj;
+ /* Initialize the true random number generator block */
+ cy_rslt_t rslt = cyhal_trng_init(&trng_obj);
+ if (rslt != CY_RSLT_SUCCESS) {
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Random Number generator failed %lx !"), rslt);
+ }
+ /* Generate a true random number */
+ rnd_num = cyhal_trng_generate(&trng_obj);
+ rnd_num &= 0xFFFFFF;
+ /* Release the true random number generator block */
+ cyhal_trng_free(&trng_obj);
+ return mp_obj_new_int(rnd_num);
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_rng_obj, machine_rng);
+
+#ifdef MICROPY_PY_SD_CARD
+#define MICROPY_PY_MACHINE_SD_CARD_ENTRY { MP_ROM_QSTR(MP_QSTR_SDCard), MP_ROM_PTR(&machine_sdcard_type) },
+#else
+#define MICROPY_PY_MACHINE_SD_CARD_ENTRY
+#endif
+
+#if MICROPY_PY_MACHINE_SPI_SLAVE
+#define MICROPY_PY_MACHINE_SPI_SLAVE_ENTRY { MP_ROM_QSTR(MP_QSTR_SPISlave), MP_ROM_PTR(&machine_spi_slave_type) },
+#else
+#define MICROPY_PY_MACHINE_SPI_SLAVE_ENTRY
+#endif
+
+#define MICROPY_PY_MACHINE_EXTRA_GLOBALS \
+ { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&machine_info_obj) }, \
+ { MP_ROM_QSTR(MP_QSTR_reset_cause), MP_ROM_PTR(&machine_reset_cause_obj) }, \
+ { MP_ROM_QSTR(MP_QSTR_rng), MP_ROM_PTR(&machine_rng_obj) }, \
+ \
+ { MP_ROM_QSTR(MP_QSTR_disable_irq), MP_ROM_PTR(&machine_disable_irq_obj) }, \
+ { MP_ROM_QSTR(MP_QSTR_enable_irq), MP_ROM_PTR(&machine_enable_irq_obj) }, \
+ \
+ /* class constants */ \
+ { MP_ROM_QSTR(MP_QSTR_HARD_RESET), MP_ROM_INT(MACHINE_HARD_RESET) }, \
+ { MP_ROM_QSTR(MP_QSTR_WDT_RESET), MP_ROM_INT(MACHINE_WDT_RESET) }, \
+ { MP_ROM_QSTR(MP_QSTR_DEEPSLEEP_RESET), MP_ROM_INT(MACHINE_DEEPSLEEP_RESET) }, \
+ { MP_ROM_QSTR(MP_QSTR_SOFT_RESET), MP_ROM_INT(MACHINE_SOFT_RESET) }, \
+ { MP_ROM_QSTR(MP_QSTR_PWRON_RESET), MP_ROM_INT(MACHINE_PWRON_RESET) }, \
+ \
+ /* Modules */ \
+ { MP_ROM_QSTR(MP_QSTR_I2CSlave), MP_ROM_PTR(&machine_i2c_slave_type) }, \
+ { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&machine_pin_type) }, \
+ { MP_ROM_QSTR(MP_QSTR_RTC), MP_ROM_PTR(&machine_rtc_type) }, \
+ \
+ { MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&machine_timer_type) }, \
+ { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&machine_adc_type) }, \
+ { MP_ROM_QSTR(MP_QSTR_ADCBlock), MP_ROM_PTR(&machine_adcblock_type) }, \
+ MICROPY_PY_MACHINE_SPI_SLAVE_ENTRY \
+ MICROPY_PY_MACHINE_SD_CARD_ENTRY \
+
+#endif // MICROPY_PY_MACHINE
diff --git a/ports/psoc6/modmachine.h b/ports/psoc6/modmachine.h
new file mode 100644
index 0000000000000..b2411927ece00
--- /dev/null
+++ b/ports/psoc6/modmachine.h
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_PSOC6_MODMACHINE_H
+#define MICROPY_INCLUDED_PSOC6_MODMACHINE_H
+
+
+// micropython includes
+#include "py/obj.h"
+
+
+extern const mp_obj_type_t machine_i2c_type;
+extern const mp_obj_type_t machine_i2c_slave_type;
+extern const mp_obj_type_t machine_pin_type;
+extern const mp_obj_type_t machine_rtc_type;
+extern const mp_obj_type_t machine_pwm_type;
+extern const mp_obj_type_t machine_spi_type;
+extern const mp_obj_type_t machine_spi_slave_type;
+extern const mp_obj_type_t machine_timer_type;
+extern const mp_obj_type_t machine_adc_type;
+extern const mp_obj_type_t machine_wdt_type;
+extern const mp_obj_type_t machine_adcblock_type;
+extern const mp_obj_type_t machine_i2s_type;
+// extern const mp_obj_type_t machine_uart_type;
+#ifdef MICROPY_PY_SD_CARD
+extern const mp_obj_type_t machine_sdcard_type;
+#endif
+
+// Add all mod machine deinits
+void mod_pin_phy_deinit(void);
+void mod_pin_deinit(void);
+void mod_adc_deinit(void);
+void mod_adcblock_deinit(void);
+void mod_i2c_deinit(void);
+void mod_pwm_deinit(void);
+void mod_rtc_deinit(void);
+void mod_spi_deinit(void);
+void mod_timer_deinit(void);
+void mod_wdt_deinit(void);
+void mod_uart_deinit(void);
+void mod_sdcard_deinit(void);
+/* Note: the static functions' prototypes in the .c file cannot be declared here
+since they are static. The static type in those functions come from MPY hence
+should stay that way. */
+
+
+// functions to be called from other .c files. Hence they are not static.
+void machine_init(void);
+void machine_deinit(void);
+mp_obj_t system_reset_cause(void);
+
+#endif // MICROPY_INCLUDED_PSOC6_MODMACHINE_H
diff --git a/ports/psoc6/modos.c b/ports/psoc6/modos.c
new file mode 100644
index 0000000000000..a41240b2cd486
--- /dev/null
+++ b/ports/psoc6/modos.c
@@ -0,0 +1,104 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2018 Paul Sokolovsky
+ * Copyright (c) 2017-2022 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+#include
+
+
+// micropython includes
+#include "py/runtime.h"
+#include "py/mphal.h"
+
+
+#define RAISE_ERRNO(err_flag, error_val) \
+ { if (err_flag == -1) \
+ { mp_raise_OSError(error_val); } }
+
+
+void os_init(void) {
+}
+
+
+void os_deinit(void) {
+
+}
+
+
+#if MICROPY_PY_OS_GETENV_PUTENV_UNSETENV
+
+static mp_obj_t mp_os_getenv(mp_obj_t var_in) {
+ const char *s = getenv(mp_obj_str_get_str(var_in));
+ if (s == NULL) {
+ return mp_const_none;
+ }
+ return mp_obj_new_str(s, strlen(s));
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_getenv_obj, mp_os_getenv);
+
+
+static mp_obj_t mp_os_putenv(mp_obj_t var, mp_obj_t value) {
+ setenv(mp_obj_str_get_str(var), mp_obj_str_get_str(value), 1);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(mp_os_putenv_obj, mp_os_putenv);
+
+
+static mp_obj_t mp_os_unsetenv(mp_obj_t var) {
+ unsetenv(mp_obj_str_get_str(var));
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_unsetenv_obj, mp_os_unsetenv);
+
+#endif
+
+
+static mp_obj_t mp_os_system(mp_obj_t cmd_in) {
+ const char *cmd = mp_obj_str_get_str(cmd_in);
+
+ MP_THREAD_GIL_EXIT();
+ int r = system(cmd);
+ MP_THREAD_GIL_ENTER();
+
+ RAISE_ERRNO(r, errno);
+
+ return MP_OBJ_NEW_SMALL_INT(r);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_system_obj, mp_os_system);
+
+
+static mp_obj_t mp_os_errno(size_t n_args, const mp_obj_t *args) {
+ if (n_args == 0) {
+ return MP_OBJ_NEW_SMALL_INT(errno);
+ }
+
+ errno = mp_obj_get_int(args[0]);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_os_errno_obj, 0, 1, mp_os_errno);
diff --git a/ports/psoc6/modpsoc6.c b/ports/psoc6/modpsoc6.c
new file mode 100644
index 0000000000000..c06679391d61a
--- /dev/null
+++ b/ports/psoc6/modpsoc6.c
@@ -0,0 +1,88 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020-2021 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// micropython includes
+#include "py/runtime.h"
+
+
+// port-specific includes
+#include "modpsoc6.h"
+#include "cyhal.h"
+
+mp_obj_t system_reset_cause(void) {
+ uint32_t set_reset_cause = SYSTEM_RESET_NONE;
+
+ uint32_t reset_reason = cyhal_system_get_reset_reason();
+
+ if (reset_reason & CYHAL_SYSTEM_RESET_NONE) {
+ set_reset_cause = SYSTEM_RESET_NONE;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_WDT) {
+ set_reset_cause = SYSTEM_RESET_WDT;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_ACTIVE_FAULT) {
+ set_reset_cause = SYSTEM_RESET_ACTIVE_FAULT;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_DEEPSLEEP_FAULT) {
+ set_reset_cause = SYSTEM_RESET_DEEPSLEEP_FAULT;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_SOFT) {
+ set_reset_cause = SYSTEM_RESET_SOFT;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_HIB_WAKEUP) {
+ set_reset_cause = SYSTEM_RESET_HIB_WAKEUP;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_WCO_ERR) {
+ set_reset_cause = SYSTEM_RESET_WCO_ERR;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_SYS_CLK_ERR) {
+ set_reset_cause = SYSTEM_RESET_SYS_CLK_ERR;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_PROTECTION) {
+ set_reset_cause = SYSTEM_RESET_PROTECTION;
+ } else if (reset_reason & CYHAL_SYSTEM_RESET_WARMBOOT) {
+ set_reset_cause = SYSTEM_RESET_WARMBOOT;
+ }
+ cyhal_system_clear_reset_reason();
+ return MP_OBJ_NEW_SMALL_INT(set_reset_cause);
+}
+MP_DEFINE_CONST_FUN_OBJ_0(system_reset_cause_obj, system_reset_cause);
+
+static const mp_rom_map_elem_t psoc6_module_globals_table[] = {
+ { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_psoc6) },
+ #if MICROPY_ENABLE_EXT_QSPI_FLASH
+ { MP_ROM_QSTR(MP_QSTR_QSPI_Flash), MP_ROM_PTR(&psoc6_qspi_flash_type) },
+ #else
+ { MP_ROM_QSTR(MP_QSTR_Flash), MP_ROM_PTR(&psoc6_flash_type) },
+ #endif
+ #if MICROPY_ENABLE_SD_CARD
+ { MP_ROM_QSTR(MP_QSTR_SD_CARD), MP_ROM_PTR(&machine_sdcard_type) },
+ #endif
+ { MP_ROM_QSTR(MP_QSTR_system_reset_cause), MP_ROM_PTR(&system_reset_cause_obj)},
+};
+static MP_DEFINE_CONST_DICT(psoc6_module_globals, psoc6_module_globals_table);
+
+
+const mp_obj_module_t mp_module_psoc6 = {
+ .base = { &mp_type_module },
+ .globals = (mp_obj_dict_t *)&psoc6_module_globals,
+};
+
+
+MP_REGISTER_MODULE(MP_QSTR_psoc6, mp_module_psoc6);
diff --git a/ports/psoc6/modpsoc6.h b/ports/psoc6/modpsoc6.h
new file mode 100644
index 0000000000000..920478f4e7fc4
--- /dev/null
+++ b/ports/psoc6/modpsoc6.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020-2021 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_PSOC6_MODPSOC6_H
+#define MICROPY_INCLUDED_PSOC6_MODPSOC6_H
+
+
+// micropython includes
+#include "py/obj.h"
+
+typedef enum
+{
+ SYSTEM_RESET_NONE, /**< No cause */
+ SYSTEM_RESET_WDT, /**< A watchdog timer (WDT) reset has occurred */
+ SYSTEM_RESET_ACTIVE_FAULT, /**< The fault logging system requested a reset from its Active logic. */
+ SYSTEM_RESET_DEEPSLEEP_FAULT, /**< The fault logging system requested a reset from its Deep-Sleep logic. */
+ SYSTEM_RESET_SOFT, /**< The CPU requested a system reset through it's SYSRESETREQ. */
+ SYSTEM_RESET_HIB_WAKEUP, /**< A reset has occurred due to a a wakeup from hibernate power mode. */
+ SYSTEM_RESET_WCO_ERR, /**< A reset has occurred due to a watch-crystal clock error */
+ SYSTEM_RESET_SYS_CLK_ERR, /**< A reset has occurred due to a system clock error */
+ SYSTEM_RESET_PROTECTION, /**< A reset has occurred due to a protection violation */
+ SYSTEM_RESET_WARMBOOT, /**< A reset has occurred due wake up from DSRAM, which is a Warm Boot */
+ SYSTEM_RESET_MP_SOFT /**< A reset has occurred due to a soft reset from micropython side*/
+} system_reset_reason_t;
+
+extern const mp_obj_type_t psoc6_flash_type;
+extern const mp_obj_type_t psoc6_qspi_flash_type;
+extern const mp_obj_type_t machine_sdcard_type;
+
+#endif // MICROPY_INCLUDED_PSOC6_MODPSOC6_H
diff --git a/ports/psoc6/modtime.c b/ports/psoc6/modtime.c
new file mode 100644
index 0000000000000..d74e681d3764f
--- /dev/null
+++ b/ports/psoc6/modtime.c
@@ -0,0 +1,106 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2021 Damien P. George
+ * Copyright (c) 2023-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include "stdio.h"
+
+// micropython includes
+#include "extmod/modtime.h"
+#include "py/runtime.h"
+#include "shared/timeutils/timeutils.h"
+
+// MTB includes
+#include "cyhal.h"
+
+// object defined in rtc.c
+extern cyhal_rtc_t psoc6_rtc;
+
+cyhal_timer_t psoc6_timer;
+
+void time_init(void) {
+ const cyhal_timer_cfg_t timer_cfg =
+ {
+ .compare_value = 0, /* Timer compare value, not used */
+ .period = 15000000, /* Timer period set to a large enough value */
+ /* compared to event being measured */
+ .direction = CYHAL_TIMER_DIR_UP, /* Timer counts up */
+ .is_compare = false, /* Don't use compare mode */
+ .is_continuous = true, /* Run timer indefinitely */
+ .value = 0 /* Initial value of counter */
+ };
+ /* Initialize the timer object. Does not use pin output ('pin' is NC) and
+ * does not use a pre-configured clock source ('clk' is NULL). */
+ cyhal_timer_init(&psoc6_timer, NC, NULL);
+ /* Apply timer configuration such as period, count direction, run mode, etc. */
+ cyhal_timer_configure(&psoc6_timer, &timer_cfg);
+ /* Set the frequency of timer to 1 MHz */
+ cyhal_timer_set_frequency(&psoc6_timer, 1000000);
+ /* Start the timer with the configured settings */
+ cyhal_timer_start(&psoc6_timer);
+}
+
+void time_deinit(void) {
+ cyhal_timer_stop(&psoc6_timer);
+}
+
+// Convert a time expressed in seconds since the Epoch into an 8-tuple which
+// contains: (year, month, mday, hour, minute, second, weekday, yearday)
+static mp_obj_t mp_time_localtime_get(void) {
+ struct tm current_date_time = {0};
+ cy_rslt_t result = cyhal_rtc_read(&psoc6_rtc, ¤t_date_time);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cyhal_rtc_read failed !"));
+ }
+
+ mp_obj_t tuple[8] = {
+ mp_obj_new_int(current_date_time.tm_year),
+ mp_obj_new_int(current_date_time.tm_mon),
+ mp_obj_new_int(current_date_time.tm_mday),
+ mp_obj_new_int(current_date_time.tm_hour),
+ mp_obj_new_int(current_date_time.tm_min),
+ mp_obj_new_int(current_date_time.tm_sec),
+ mp_obj_new_int(current_date_time.tm_wday),
+ mp_obj_new_int(timeutils_year_day(current_date_time.tm_year, current_date_time.tm_mon, current_date_time.tm_mday)),
+ };
+
+ return mp_obj_new_tuple(8, tuple);
+}
+
+// time()
+// Return the number of seconds since the Epoch.
+static mp_obj_t mp_time_time_get(void) {
+ struct tm current_date_time = {0};
+ cy_rslt_t result = cyhal_rtc_read(&psoc6_rtc, ¤t_date_time);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cyhal_rtc_read failed !"));
+ }
+
+ return mp_obj_new_int_from_ull(timeutils_seconds_since_epoch(current_date_time.tm_year, current_date_time.tm_mon, current_date_time.tm_mday,
+ current_date_time.tm_hour, current_date_time.tm_min, current_date_time.tm_sec));
+}
diff --git a/ports/psoc6/mpconfigport.h b/ports/psoc6/mpconfigport.h
new file mode 100644
index 0000000000000..c7b024ba7b103
--- /dev/null
+++ b/ports/psoc6/mpconfigport.h
@@ -0,0 +1,228 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Options controlling how MicroPython is built, overriding defaults in py/mpconfig.h
+#include
+#include
+
+#include "shared/runtime/interrupt_char.h"
+#include "mpconfigboard.h"
+
+// Control over Python builtins
+#define MICROPY_PY_IO_BUFFEREDWRITER (1)
+#define MICROPY_PY_SELECT (1)
+#define MICROPY_PY_IO (1)
+#define MICROPY_PY_IO_IOBASE (1)
+#define MICROPY_PY_BINASCII (1)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE (1)
+#define MICROPY_STACK_CHECK (1)
+#define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
+#define MICROPY_PY_ARRAY (1)
+
+// Board and hardware specific configuration
+#define MICROPY_HELPER_REPL (1)
+#define MICROPY_HW_ENABLE_UART_REPL (0) // useful if there is no USB
+#define MICROPY_HW_ENABLE_USBDEV (0)
+
+#define MICROPY_CONFIG_ROM_LEVEL (MICROPY_CONFIG_ROM_LEVEL_FULL_FEATURES)
+
+// Memory allocation policies
+// #define MICROPY_GC_STACK_ENTRY_TYPE uint16_t
+#define MICROPY_GC_STACK_ENTRY_TYPE uint32_t
+#define MICROPY_ENABLE_GC (1)
+#define MICROPY_ENABLE_FINALISER (1)
+
+
+
+#define MICROPY_MEM_STATS (1)
+#define MICROPY_MALLOC_USES_ALLOCATED_SIZE (1)
+#define MICROPY_TRACKED_ALLOC (MICROPY_SSL_MBEDTLS)
+#define MICROPY_QSTR_BYTES_IN_HASH (1)
+
+// MicroPython emitters
+#define MICROPY_PERSISTENT_CODE_LOAD (1)
+#define MICROPY_EMIT_THUMB (1)
+#define MICROPY_EMIT_THUMB_ARMV7M (1)
+#define MICROPY_EMIT_INLINE_THUMB (1)
+#define MICROPY_EMIT_INLINE_THUMB_FLOAT (1)
+#define MICROPY_EMIT_ARM (0)
+
+// Optimisations
+#define MICROPY_OPT_COMPUTED_GOTO (0)
+
+// Python internal features
+#define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (1)
+
+#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_MPZ)
+#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_FLOAT)
+// #define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_DOUBLE)
+
+#define MICROPY_SCHEDULER_DEPTH (8)
+#define MICROPY_SCHEDULER_STATIC_NODES (1)
+// #define MICROPY_ENABLE_SCHEDULER (1)
+
+// Fine control over Python builtins, classes, modules, etc
+#define MICROPY_PY_SYS_PLATFORM "psoc6"
+#define MICROPY_PY_SYS_EXC_INFO (1)
+
+#define MICROPY_PY_THREAD (0)
+// #define MICROPY_PY_THREAD_GIL (0)
+
+// Extended modules
+#define MICROPY_EPOCH_IS_1970 (1)
+
+#define MICROPY_PY_OS_INCLUDEFILE "ports/psoc6/modos.c"
+#define MICROPY_PY_OS_UNAME (1)
+#define MICROPY_PY_OS_URANDOM (0)
+#define MICROPY_PY_OS_GETENV_PUTENV_UNSETENV (1)
+#define MICROPY_PY_OS_SYSTEM (1)
+#define MICROPY_PY_OS_ERRNO (1)
+
+#define MICROPY_PY_RE_MATCH_GROUPS (1)
+#define MICROPY_PY_RE_MATCH_SPAN_START_END (1)
+#define MICROPY_PY_RE_DEBUG (1)
+
+#define MICROPY_PY_TIME_GMTIME_LOCALTIME_MKTIME (1)
+#define MICROPY_PY_TIME_TIME_TIME_NS (1)
+#define MICROPY_PY_TIME_INCLUDEFILE "ports/psoc6/modtime.c"
+
+#define MICROPY_PY_MACHINE (1)
+#define MICROPY_PY_MACHINE_RESET (1)
+#define MICROPY_PY_MACHINE_INCLUDEFILE "ports/psoc6/modmachine.c"
+#define MICROPY_PY_MACHINE_BARE_METAL_FUNCS (1)
+#define MICROPY_PY_MACHINE_BOOTLOADER (0)
+#define MICROPY_PY_MACHINE_DISABLE_IRQ_ENABLE_IRQ (0)
+#define MICROPY_PY_MACHINE_PIN_MAKE_NEW mp_pin_make_new
+#define MICROPY_PY_MACHINE_PWM (1)
+#define MICROPY_PY_MACHINE_PWM_INCLUDEFILE "ports/psoc6/machine_pwm.c"
+#define MICROPY_PY_MACHINE_I2C (1)
+#define MICROPY_PY_MACHINE_I2C_SLAVE (1)
+#define MICROPY_PY_MACHINE_SOFTI2C (1)
+#define MICROPY_PY_MACHINE_BITSTREAM (1)
+#define MICROPY_PY_MACHINE_WDT (1)
+#define MICROPY_PY_MACHINE_WDT_INCLUDEFILE "ports/psoc6/machine_wdt.c"
+
+#define MICROPY_PY_MACHINE_SPI (1)
+#define MICROPY_PY_MACHINE_SPI_MSB (0)
+#define MICROPY_PY_MACHINE_SPI_LSB (1)
+#define MICROPY_PY_MACHINE_SOFTSPI (0)
+#if MICROPY_PY_MACHINE_SPI_SLAVE
+#define MICROPY_PY_MACHINE_SPISLAVE_MSB (0)
+#define MICROPY_PY_MACHINE_SPISLAVE_LSB (1)
+#endif
+
+#define MICROPY_PY_MACHINE_I2S (1)
+#define MICROPY_PY_MACHINE_I2S_MCK (0)
+#define MICROPY_PY_MACHINE_I2S_CONSTANT_RX (RX)
+#define MICROPY_PY_MACHINE_I2S_CONSTANT_TX (TX)
+#define MICROPY_PY_MACHINE_I2S_RING_BUF (1)
+#define MICROPY_PY_MACHINE_I2S_FINALISER (1)
+#define MICROPY_PY_MACHINE_UART (1)
+#define MICROPY_PY_MACHINE_UART_INCLUDEFILE "ports/psoc6/machine_uart.c"
+#define MICROPY_PY_MACHINE_UART_READCHAR_WRITECHAR (1)
+#define MICROPY_PY_MACHINE_UART_SENDBREAK (1)
+#define MICROPY_PY_MACHINE_UART_IRQ (1)
+
+#define MICROPY_PY_MACHINE_PSOC6_I2S (1)
+#define MICROPY_PY_MACHINE_I2S_INCLUDEFILE "ports/psoc6/machine_i2s.c"
+
+// VFS
+#define MICROPY_VFS (1)
+#define MICROPY_READER_VFS (1)
+
+// fatfs configuration
+#define MICROPY_FATFS_ENABLE_LFN (1)
+#define MICROPY_FATFS_LFN_CODE_PAGE 437 /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
+#define MICROPY_FATFS_RPATH (2)
+
+#define MICROPY_PY_CRYPTOLIB (MICROPY_PY_SSL)
+#define MICROPY_PY_CRYPTOLIB_CTR (MICROPY_PY_SSL)
+#define MICROPY_PY_CRYPTOLIB_CONSTS (MICROPY_PY_SSL)
+
+
+#define MP_STATE_PORT MP_STATE_VM
+
+// By default networking should include sockets, ssl, websockets, webrepl
+
+#if MICROPY_PY_NETWORK
+
+#define MICROPY_PY_SOCKET (1)
+#define MICROPY_PY_WEBSOCKET (1)
+#define MICROPY_PY_WEBREPL (1)
+#define MICROPY_PY_OS_DUPTERM (1)
+
+extern const struct _mp_obj_type_t mp_network_ifx_wcm_type;
+#define MICROPY_HW_NIC_IFX_WCM \
+ { MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&mp_network_ifx_wcm_type) },
+
+#define MICROPY_PORT_NETWORK_INTERFACES \
+ MICROPY_HW_NIC_IFX_WCM
+
+#endif
+
+// Miscellaneous settings
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
+
+#define MP_SSIZE_MAX (0x7fffffff)
+typedef intptr_t mp_int_t; // must be pointer size
+typedef uintptr_t mp_uint_t; // must be pointer size
+typedef intptr_t mp_off_t;
+
+
+#define MICROPY_PY_BUILTINS_HELP_TEXT psoc6_help_text
+#define MICROPY_USE_INTERNAL_PRINTF (0)
+#define MICROPY_REPL_INFO (1)
+
+// TODO: helpful to abstract main.c ?
+// #define MICROPY_PORT_INIT_FUNC ??
+
+extern void machine_deinit();
+#define MICROPY_PORT_DEINIT_FUNC machine_deinit()
+
+#define MICROPY_EVENT_POLL_HOOK_FAST \
+ do { \
+ extern void mp_handle_pending(bool); \
+ mp_handle_pending(true); \
+ } while (0);
+
+
+#define MICROPY_EVENT_POLL_HOOK \
+ do { \
+ MICROPY_EVENT_POLL_HOOK_FAST; \
+ } while (0);
+
+// best_effort_wfe_or_timeout(make_timeout_time_ms(1));
+
+
+#define MICROPY_LOGGER_DEBUG (0)
+
+// extern void lwip_lock_acquire(void);
+// extern void lwip_lock_release(void);
+
+// #define MICROPY_PY_LWIP_ENTER lwip_lock_acquire();
+// #define MICROPY_PY_LWIP_REENTER lwip_lock_acquire();
+// #define MICROPY_PY_LWIP_EXIT lwip_lock_release();
diff --git a/ports/psoc6/mpconfigport.mk b/ports/psoc6/mpconfigport.mk
new file mode 100644
index 0000000000000..45484e4c67a76
--- /dev/null
+++ b/ports/psoc6/mpconfigport.mk
@@ -0,0 +1 @@
+MICROPY_VFS_LFS2=1
diff --git a/ports/psoc6/mphalport.c b/ports/psoc6/mphalport.c
new file mode 100644
index 0000000000000..0a9e21432a0f2
--- /dev/null
+++ b/ports/psoc6/mphalport.c
@@ -0,0 +1,176 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include "stdbool.h" // because of missing include in shared/timeutils/timeutils.h
+#include "stdio.h"
+
+
+// micropython includes
+#include "mpconfigport.h"
+#include "mphalport.h"
+
+#include "py/runtime.h"
+#include "shared/timeutils/timeutils.h"
+
+// MTB includes
+#include "cyhal.h"
+#include "cy_retarget_io.h"
+
+
+// port-specific includes
+#include "machine_pin_phy.h"
+
+extern cyhal_rtc_t psoc6_rtc;
+extern cyhal_timer_t psoc6_timer;
+
+void mp_hal_delay_ms(mp_uint_t ms) {
+ #if defined(CY_RTOS_AWARE) || defined(COMPONENT_RTOS_AWARE)
+ // Check
+ // file: mtb-hal-cat1/src/cyhal_system.c
+ // function: cyhal_system_delay_ms()
+ // lines 65-68
+ // for an explanation.
+
+ // An increment of 1 ms is added to the delay. In principle
+ // that should be corrected by some internal behaviour or RTOS
+ // but it does not seem to work like this, as we are always
+ // getting one more second in our Test 1 of tests/psoc/time.py.
+
+ // TODO: Find if there is a more elegant way to avoid the RTOS
+ // configuration to propagate to this level.
+ ms -= 1;
+ #endif
+ cyhal_system_delay_ms(ms);
+}
+
+
+void mp_hal_delay_us(mp_uint_t us) {
+ cyhal_system_delay_us(us);
+}
+
+
+// Issues may arise if time is incremented only each second.
+// Would require proper ns count from epoch of clock the source (see also "extmod/vfs_lfs.c", function "lfs_get_mtime" and "mphalport.c", function "mp_hal_time_ns")
+uint64_t mp_hal_time_ns(void) {
+ struct tm current_date_time = {0};
+ cy_rslt_t result = cyhal_rtc_read(&psoc6_rtc, ¤t_date_time);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cyhal_rtc_read failed !"));
+ }
+
+ uint64_t s = timeutils_seconds_since_epoch(current_date_time.tm_year, current_date_time.tm_mon, current_date_time.tm_mday,
+ current_date_time.tm_hour, current_date_time.tm_min, current_date_time.tm_sec);
+
+ // add ticks to make sure time is strictly monotonic
+ return s * 1000000000ULL + cyhal_timer_read(&psoc6_timer) * 1000ULL;
+}
+
+
+mp_uint_t mp_hal_ticks_ms(void) {
+ return cyhal_timer_read(&psoc6_timer) / 1000;
+}
+
+
+mp_uint_t mp_hal_ticks_us(void) {
+ return cyhal_timer_read(&psoc6_timer);
+}
+
+
+mp_uint_t mp_hal_ticks_cpu(void) {
+ return cyhal_timer_read(&psoc6_timer);
+}
+
+
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+ printf("mp_hal_stdio_poll\n");
+ mp_raise_NotImplementedError(MP_ERROR_TEXT("mp_hal_stdio_poll not implemented !"));
+ uintptr_t ret = 0;
+ return ret;
+}
+
+// Send string of given length
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
+ int r = write(STDOUT_FILENO, str, len);
+ (void)r;
+}
+
+int mp_hal_stdin_rx_chr(void) {
+ for (;;) {
+ uint8_t c = 0;
+ cy_rslt_t result;
+ result = cyhal_uart_getc(&cy_retarget_io_uart_obj, &c, 1);
+ if (result == CY_RSLT_SUCCESS) {
+ return c;
+ }
+ MICROPY_EVENT_POLL_HOOK
+ }
+}
+
+void mp_hal_pin_od_low(mp_hal_pin_obj_t pin) {
+ cyhal_gpio_write(pin, false);
+}
+
+
+void mp_hal_pin_od_high(mp_hal_pin_obj_t pin) {
+ cyhal_gpio_write(pin, true);
+}
+
+int mp_hal_pin_read(mp_hal_pin_obj_t pin) {
+ return cyhal_gpio_read(pin);
+}
+
+
+void mp_hal_pin_open_drain(mp_hal_pin_obj_t pin) {
+ cyhal_gpio_configure(pin, CYHAL_GPIO_DIR_INPUT, CYHAL_GPIO_DRIVE_OPENDRAINDRIVESLOW);
+}
+
+
+uint8_t mp_hal_pin_name(mp_hal_pin_obj_t pin) {
+ return pin;
+}
+
+void mp_hal_pin_write(mp_hal_pin_obj_t pin, uint8_t polarity) {
+ if (polarity == 1) {
+ cyhal_gpio_write(pin, true);
+ } else {
+ cyhal_gpio_write(pin, false);
+ }
+}
+
+void mp_hal_pin_output(mp_hal_pin_obj_t pin) {
+ cyhal_gpio_configure(pin, CYHAL_GPIO_DIR_OUTPUT, CYHAL_GPIO_DRIVE_NONE);
+}
+
+void mp_hal_pin_input(mp_hal_pin_obj_t pin) {
+ cyhal_gpio_configure(pin, CYHAL_GPIO_DIR_INPUT, CYHAL_GPIO_DRIVE_NONE);
+}
+
+
+mp_hal_pin_obj_t mp_hal_get_pin_obj(mp_obj_t obj) {
+ return pin_addr_by_name(obj);
+}
diff --git a/ports/psoc6/mphalport.h b/ports/psoc6/mphalport.h
new file mode 100644
index 0000000000000..aaf7d992d7027
--- /dev/null
+++ b/ports/psoc6/mphalport.h
@@ -0,0 +1,97 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+
+
+// micropython includes
+#include "py/mpconfig.h"
+#include "py/runtime.h"
+
+
+// MTB includes
+#include "cyhal.h"
+
+
+// port-specific includes
+
+#define MICROPY_BEGIN_ATOMIC_SECTION() cyhal_system_critical_section_enter()
+#define MICROPY_END_ATOMIC_SECTION(state) cyhal_system_critical_section_exit(state)
+
+// #define MICROPY_BEGIN_ATOMIC_SECTION() (0)
+// #define MICROPY_END_ATOMIC_SECTION(state) {(void)state;}
+
+#define MP_HAL_PIN_FMT "%u"
+#define mp_hal_pin_obj_t uint
+
+#define mp_hal_delay_us_fast mp_hal_delay_us
+
+
+extern __attribute__((weak)) int _write(int fd, const char *ptr, int len);
+
+
+void mp_hal_delay_us(mp_uint_t us);
+void mp_hal_delay_us_fast(mp_uint_t us);
+void mp_hal_delay_ms(mp_uint_t ms);
+
+uint64_t mp_hal_time_ns(void);
+
+mp_uint_t mp_hal_ticks_us(void);
+mp_uint_t mp_hal_ticks_ms(void);
+mp_uint_t mp_hal_ticks_cpu(void);
+
+
+void mp_hal_pin_od_low(mp_hal_pin_obj_t pin);
+void mp_hal_pin_od_high(mp_hal_pin_obj_t pin);
+void mp_hal_pin_open_drain(mp_hal_pin_obj_t pin);
+
+
+int mp_hal_pin_read(mp_hal_pin_obj_t pin);
+uint8_t mp_hal_pin_name(mp_hal_pin_obj_t pin);
+mp_hal_pin_obj_t mp_hal_get_pin_obj(mp_obj_t obj);
+
+void mp_hal_pin_write(mp_hal_pin_obj_t pin, uint8_t polarity);
+void mp_hal_pin_output(mp_hal_pin_obj_t pin);
+void mp_hal_pin_input(mp_hal_pin_obj_t pin);
+
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags);
+
+int mp_hal_stdin_rx_chr(void);
+
+static inline mp_uint_t mp_hal_get_cpu_freq(void) {
+ return Cy_SysClk_ClkFastGetFrequency();
+}
+
+static inline void mp_hal_pin_config(mp_hal_pin_obj_t pin, uint32_t mode, uint32_t pull, uint32_t alt) {
+ printf("mp_hal_pin_config %d mode : %ld pull : %ld alt : %ld\n", pin, mode, pull, alt);
+ cyhal_gpio_configure(pin, mode, pull);
+
+ // assert((mode == MP_HAL_PIN_MODE_INPUT || mode == MP_HAL_PIN_MODE_OUTPUT) && alt == 0);
+ // gpio_set_dir(pin, mode);
+ // gpio_set_pulls(pin, pull == MP_HAL_PIN_PULL_UP, pull == MP_HAL_PIN_PULL_DOWN);
+}
diff --git a/ports/psoc6/mplogger.h b/ports/psoc6/mplogger.h
new file mode 100644
index 0000000000000..bf43dcc987e1a
--- /dev/null
+++ b/ports/psoc6/mplogger.h
@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+// Logger module to pass messages to console.
+
+
+// macro to pipe debug messages to console in LOGGER DEBUG MODE
+// TODO: Since this is an expensive function call when LOGGER DEBUG mode is not activated,
+// a rework of this function needed similar to MPY's built-in debug message handler DEBUG_print()
+#define mplogger_print(...) \
+ do { if (MICROPY_LOGGER_DEBUG) mp_printf(&mp_plat_print, __VA_ARGS__); } while (0)
diff --git a/ports/psoc6/mtb-libs/.cyignore b/ports/psoc6/mtb-libs/.cyignore
new file mode 100755
index 0000000000000..fe4fd4043d657
--- /dev/null
+++ b/ports/psoc6/mtb-libs/.cyignore
@@ -0,0 +1,35 @@
+# Documentation
+images
+
+# Exports, Project settings
+.mtbLaunchConfigs
+.settings
+.vscode
+
+docs
+
+# LwIP
+$(SEARCH_lwip)/contrib/addons
+$(SEARCH_lwip)/contrib/apps
+$(SEARCH_lwip)/contrib/Coverity
+$(SEARCH_lwip)/contrib/examples
+$(SEARCH_lwip)/contrib/ports/unix
+$(SEARCH_lwip)/contrib/ports/win32
+$(SEARCH_lwip)/test
+$(SEARCH_lwip)/doc
+$(SEARCH_lwip)/src/apps
+$(SEARCH_lwip)/src/netif/ppp
+$(SEARCH_lwip)/src/netif/slipif.c
+
+# mbedTLS
+$(SEARCH_mbedtls)/3rdparty
+$(SEARCH_mbedtls)/configs
+$(SEARCH_mbedtls)/programs
+$(SEARCH_mbedtls)/scripts
+$(SEARCH_mbedtls)/tests
+$(SEARCH_mbedtls)/doxygen
+$(SEARCH_mbedtls)/library/net_sockets.c
+
+$(SEARCH_wifi-host-driver)/docs
+
+$(SEARCH_mbedtls)/library/psa_crypto_driver_wrappers.c
diff --git a/ports/psoc6/mtb-libs/.gitignore b/ports/psoc6/mtb-libs/.gitignore
new file mode 100755
index 0000000000000..57859fd5db680
--- /dev/null
+++ b/ports/psoc6/mtb-libs/.gitignore
@@ -0,0 +1,151 @@
+# This list of files to ignore includes common, tool- or user-specific files that
+# are typically not checked into a version control system (VCS). It is a superset
+# of such files. You may want to add others, especially if you use a tool not listed
+# here. You can remove those that do not apply to you.
+#
+# The .gitignore file is intended for the git VCS. For another VCS you would specify
+# which files to ignore in whatever form your VCS requires. If you do not check your
+# code into a VCS, you can ignore the .gitignore file.
+
+# ModusToolbox library repos or information about library dependencies
+libs/
+
+# Eclipse IDE for ModusToolbox files
+.metadata/
+# .cyignore
+# .settings/
+# .cproject
+# .project
+# .mtbLaunchConfigs/
+
+# ModusToolbox Configurator generated code
+GeneratedSource/
+
+# ModusToolbox build system output
+build/
+Debug/
+Release/
+*_build/
+
+# Visual Studio Code
+openocd.tcl
+.vscode/
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# IAR Embedded Workbench files
+
+# IAR Project file.
+# *.ewp
+
+# IAR Settings
+/settings/
+
+# Uncomment this if not using project connections
+# *.ipcf
+
+# Comment this out if using custom argument variables
+*.custom_argvars
+
+# IAR Debugger Settings
+# *.ewd
+
+# Comment this out if you use C-Stat or C-Run to compile/analyze your project
+*.ewt
+
+# IAR Workspace files
+# *.eww
+
+# IAR Debug Exe
+/Debug/Exe/
+
+# IAR Debug List
+/Debug/List
+
+# IAR Debug Obj
+/Obj/*.pbd
+/Obj/*.pbd.*
+/Obj/*.pbi
+/Obj/*.pbi.*
+
+# Log files
+*.log
+
+# IAR backup files
+Backup*
+
+# IAR dependency files
+*.dep
+
+# Compiled Binaries
+*.bin
+*.elf
+*.hex
+*.map
+
+# Trash files
+*.bak
+
+
+# Keil uVision files
+
+# Project and package description files
+*.cpdsc
+*.gpdsc
+
+# uVision Project file (generated by uVision). Uncomment this if do not want to track the Keil uVision project file
+# *.uvprojx (is used to build the project from scratch)
+
+# Project options file (contains information about the debugger and trace configuration)
+# *.uvoptx
+
+# Project file for multi-project workspaces
+# *.uvmpw
+
+# Project screen layout file
+*.uvguix.*
+
+# Configuration files for the run-time environment
+# RTE/
+
+# Generated output files
+*.lst
+*.map
+
+# Eclipse workspace/user-specific files/settings/caches
+.metadata/
+# .settings/
+
+# Vi and Emacs backup files
+*~
+\#*\#
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+# macOS Finder incidental files
+.DS_Store
+
+# Windows Explorer incidental files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+[Dd]esktop.ini
+
+# Imported assets
+/bsps
\ No newline at end of file
diff --git a/ports/psoc6/mtb-libs/FreeRTOSConfig.h b/ports/psoc6/mtb-libs/FreeRTOSConfig.h
new file mode 100644
index 0000000000000..ce38a939d165f
--- /dev/null
+++ b/ports/psoc6/mtb-libs/FreeRTOSConfig.h
@@ -0,0 +1,276 @@
+/******************************************************************************
+* File Name: FreeRTOSConfig.h
+*
+* Description: This file contains the FreeRTOS configuration macros.
+*
+* Related Document: See README.md
+*
+*
+*******************************************************************************
+* Copyright 2020-2022, Cypress Semiconductor Corporation (an Infineon company) or
+* an affiliate of Cypress Semiconductor Corporation. All rights reserved.
+*
+* This software, including source code, documentation and related
+* materials ("Software") is owned by Cypress Semiconductor Corporation
+* or one of its affiliates ("Cypress") and is protected by and subject to
+* worldwide patent protection (United States and foreign),
+* United States copyright laws and international treaty provisions.
+* Therefore, you may use this Software only as provided in the license
+* agreement accompanying the software package from which you
+* obtained this Software ("EULA").
+* If no EULA applies, Cypress hereby grants you a personal, non-exclusive,
+* non-transferable license to copy, modify, and compile the Software
+* source code solely for use in connection with Cypress's
+* integrated circuit products. Any reproduction, modification, translation,
+* compilation, or representation of this Software except as specified
+* above is prohibited without the express written permission of Cypress.
+*
+* Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress
+* reserves the right to make changes to the Software without notice. Cypress
+* does not assume any liability arising out of the application or use of the
+* Software or any product or circuit described in the Software. Cypress does
+* not authorize its products for use in any products where a malfunction or
+* failure of the Cypress product may reasonably be expected to result in
+* significant property damage, injury or death ("High Risk Product"). By
+* including Cypress's product in a High Risk Product, the manufacturer
+* of such system or application assumes all risk of such use and in doing
+* so agrees to indemnify Cypress against all liability.
+*******************************************************************************/
+
+/******************************************************************************
+ * FreeRTOS Kernel V10.3.1
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright (C) 2019-2020 Cypress Semiconductor Corporation, or a subsidiary of
+ * Cypress Semiconductor Corporation. All Rights Reserved.
+ *
+ * Updated configuration to support PSoC 6 MCU.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * http://www.FreeRTOS.org
+ * http://aws.amazon.com/freertos
+ * http://www.cypress.com
+ *
+ ******************************************************************************/
+
+
+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
+
+/*-----------------------------------------------------------
+ * Application specific definitions.
+ *
+ * These definitions should be adjusted for your particular hardware and
+ * application requirements.
+ *
+ * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
+ * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
+ *
+ * See http://www.freertos.org/a00110.html.
+ *----------------------------------------------------------*/
+
+#include "cy_utils.h"
+#include "cy_syslib.h"
+
+/* Get the low power configuration parameters from
+ * the ModusToolbox Device Configurator GeneratedSource:
+ * CY_CFG_PWR_SYS_IDLE_MODE - System Idle Power Mode
+ * CY_CFG_PWR_DEEPSLEEP_LATENCY - Deep Sleep Latency (ms)
+ */
+#include "cycfg_system.h"
+
+#define configUSE_PREEMPTION 1
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION 0
+#define configCPU_CLOCK_HZ SystemCoreClock
+#define configTICK_RATE_HZ 1000u
+#define configMAX_PRIORITIES 7
+#define configMINIMAL_STACK_SIZE 128
+#define configMAX_TASK_NAME_LEN 16
+#define configUSE_16_BIT_TICKS 0
+#define configIDLE_SHOULD_YIELD 1
+#define configUSE_TASK_NOTIFICATIONS 1
+#define configUSE_MUTEXES 1
+#define configUSE_RECURSIVE_MUTEXES 1
+#define configUSE_COUNTING_SEMAPHORES 1
+#define configQUEUE_REGISTRY_SIZE 10
+#define configUSE_QUEUE_SETS 0
+#define configUSE_TIME_SLICING 1
+#define configENABLE_BACKWARD_COMPATIBILITY 0
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 16
+
+/* Memory allocation related definitions. */
+#define configSUPPORT_STATIC_ALLOCATION 1
+#define configSUPPORT_DYNAMIC_ALLOCATION 1
+#define configTOTAL_HEAP_SIZE 10240
+#define configAPPLICATION_ALLOCATED_HEAP 0
+
+/* Hook function related definitions. */
+#define configUSE_IDLE_HOOK 0
+#define configUSE_TICK_HOOK 0
+#define configCHECK_FOR_STACK_OVERFLOW 2
+#define configUSE_MALLOC_FAILED_HOOK 1
+#define configUSE_DAEMON_TASK_STARTUP_HOOK 0
+
+/* Run time and task stats gathering related definitions. */
+#define configGENERATE_RUN_TIME_STATS 0
+#define configUSE_TRACE_FACILITY 1
+#define configUSE_STATS_FORMATTING_FUNCTIONS 0
+
+/* Co-routine related definitions. */
+#define configUSE_CO_ROUTINES 0
+#define configMAX_CO_ROUTINE_PRIORITIES 2
+
+/* Software timer related definitions. */
+#define configUSE_TIMERS 1
+#define configTIMER_TASK_PRIORITY 2
+#define configTIMER_QUEUE_LENGTH 10
+#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2)
+
+/*
+Interrupt nesting behavior configuration.
+This is explained here: http://www.freertos.org/a00110.html
+
+Priorities are controlled by two macros:
+- configKERNEL_INTERRUPT_PRIORITY determines the priority of the RTOS daemon task
+- configMAX_API_CALL_INTERRUPT_PRIORITY dictates the priority of ISRs that make API calls
+
+Notes:
+1. Interrupts that do not call API functions should be >= configKERNEL_INTERRUPT_PRIORITY
+ and will nest.
+2. Interrupts that call API functions must have priority between KERNEL_INTERRUPT_PRIORITY
+ and MAX_API_CALL_INTERRUPT_PRIORITY (inclusive).
+3. Interrupts running above MAX_API_CALL_INTERRUPT_PRIORITY are never delayed by the OS.
+*/
+/*
+PSoC 6 __NVIC_PRIO_BITS = 3
+
+0 (high)
+1 MAX_API_CALL_INTERRUPT_PRIORITY 001xxxxx (0x3F)
+2
+3
+4
+5
+6
+7 (low) KERNEL_INTERRUPT_PRIORITY 111xxxxx (0xFF)
+
+!!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!!
+See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html
+
+*/
+
+/* Put KERNEL_INTERRUPT_PRIORITY in top __NVIC_PRIO_BITS bits of CM4 register */
+#define configKERNEL_INTERRUPT_PRIORITY 0xFF
+/*
+Put MAX_SYSCALL_INTERRUPT_PRIORITY in top __NVIC_PRIO_BITS bits of CM4 register
+NOTE For IAR compiler make sure that changes of this macro is reflected in
+file portable\TOOLCHAIN_IAR\COMPONENT_CM4\portasm.s in PendSV_Handler: routine
+*/
+#define configMAX_SYSCALL_INTERRUPT_PRIORITY 0x3F
+/* configMAX_API_CALL_INTERRUPT_PRIORITY is a new name for configMAX_SYSCALL_INTERRUPT_PRIORITY
+ that is used by newer ports only. The two are equivalent. */
+#define configMAX_API_CALL_INTERRUPT_PRIORITY configMAX_SYSCALL_INTERRUPT_PRIORITY
+
+
+/* Set the following definitions to 1 to include the API function, or zero
+to exclude the API function. */
+#define INCLUDE_vTaskPrioritySet 1
+#define INCLUDE_uxTaskPriorityGet 1
+#define INCLUDE_vTaskDelete 1
+#define INCLUDE_vTaskSuspend 1
+#define INCLUDE_xResumeFromISR 1
+#define INCLUDE_vTaskDelayUntil 1
+#define INCLUDE_vTaskDelay 1
+#define INCLUDE_xTaskGetSchedulerState 1
+#define INCLUDE_xTaskGetCurrentTaskHandle 1
+#define INCLUDE_uxTaskGetStackHighWaterMark 0
+#define INCLUDE_xTaskGetIdleTaskHandle 0
+#define INCLUDE_eTaskGetState 0
+#define INCLUDE_xEventGroupSetBitFromISR 1
+#define INCLUDE_xTimerPendFunctionCall 1
+#define INCLUDE_xTaskAbortDelay 0
+#define INCLUDE_xTaskGetHandle 0
+#define INCLUDE_xTaskResumeFromISR 1
+
+/* Normal assert() semantics without relying on the provision of an assert.h
+header file. */
+#if defined(NDEBUG)
+#define configASSERT(x) CY_UNUSED_PARAMETER(x)
+#else
+#define configASSERT(x) if ((x) == 0) { taskDISABLE_INTERRUPTS(); CY_HALT(); }
+#endif
+
+/* Definitions that map the FreeRTOS port interrupt handlers to their CMSIS
+standard names - or at least those used in the unmodified vector table. */
+#define vPortSVCHandler SVC_Handler
+#define xPortPendSVHandler PendSV_Handler
+#define xPortSysTickHandler SysTick_Handler
+
+/* Dynamic Memory Allocation Schemes */
+#define HEAP_ALLOCATION_TYPE1 (1) /* heap_1.c*/
+#define HEAP_ALLOCATION_TYPE2 (2) /* heap_2.c*/
+#define HEAP_ALLOCATION_TYPE3 (3) /* heap_3.c*/
+#define HEAP_ALLOCATION_TYPE4 (4) /* heap_4.c*/
+#define HEAP_ALLOCATION_TYPE5 (5) /* heap_5.c*/
+#define NO_HEAP_ALLOCATION (0)
+
+#define configHEAP_ALLOCATION_SCHEME (HEAP_ALLOCATION_TYPE3)
+
+/* Check if the ModusToolbox Device Configurator Power personality parameter
+ * "System Idle Power Mode" is set to either "CPU Sleep" or "System Deep Sleep".
+ */
+#if defined(CY_CFG_PWR_SYS_IDLE_MODE) && \
+ ((CY_CFG_PWR_SYS_IDLE_MODE == CY_CFG_PWR_MODE_SLEEP) || \
+ (CY_CFG_PWR_SYS_IDLE_MODE == CY_CFG_PWR_MODE_DEEPSLEEP))
+
+/* Enable low power tickless functionality. The RTOS abstraction library
+ * provides the compatible implementation of the vApplicationSleep hook:
+ * https://github.com/cypresssemiconductorco/abstraction-rtos#freertos
+ * The Low Power Assistant library provides additional portable configuration layer
+ * for low-power features supported by the PSoC 6 devices:
+ * https://github.com/cypresssemiconductorco/lpa
+ */
+extern void vApplicationSleep(uint32_t xExpectedIdleTime);
+#define portSUPPRESS_TICKS_AND_SLEEP(xIdleTime) vApplicationSleep(xIdleTime)
+#define configUSE_TICKLESS_IDLE 2
+
+#else
+#define configUSE_TICKLESS_IDLE 0
+#endif
+
+/* Deep Sleep Latency Configuration */
+#if (CY_CFG_PWR_DEEPSLEEP_LATENCY > 0)
+#define configEXPECTED_IDLE_TIME_BEFORE_SLEEP CY_CFG_PWR_DEEPSLEEP_LATENCY
+#endif
+
+/* Allocate newlib reeentrancy structures for each RTOS task.
+ * The system behavior is toolchain-specific.
+ *
+ * GCC toolchain: the application must provide the implementation for the required
+ * newlib hook functions: __malloc_lock, __malloc_unlock, __env_lock, __env_unlock.
+ * FreeRTOS-compatible implementation is provided by the clib-support library:
+ * https://github.com/cypresssemiconductorco/clib-support
+ *
+ * ARM/IAR toolchains: the application must provide the reent.h header to adapt
+ * FreeRTOS's configUSE_NEWLIB_REENTRANT to work with the toolchain-specific C library.
+ * The compatible implementations are also provided by the clib-support library.
+ */
+#define configUSE_NEWLIB_REENTRANT 1
+
+#endif /* FREERTOS_CONFIG_H */
diff --git a/ports/psoc6/mtb-libs/Makefile b/ports/psoc6/mtb-libs/Makefile
new file mode 100755
index 0000000000000..a79db732c3593
--- /dev/null
+++ b/ports/psoc6/mtb-libs/Makefile
@@ -0,0 +1,234 @@
+################################################################################
+# \file Makefile
+# \version 1.0
+#
+# \brief
+# Top-level application make file.
+#
+################################################################################
+# \copyright
+# Copyright 2018-2022, Cypress Semiconductor Corporation (an Infineon company)
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+
+
+################################################################################
+# Basic Configuration
+################################################################################
+
+# Type of ModusToolbox Makefile Options include:
+#
+# COMBINED -- Top Level Makefile usually for single standalone application
+# APPLICATION -- Top Level Makefile usually for multi project application
+# PROJECT -- Project Makefile under Application
+#
+MTB_TYPE=COMBINED
+
+# Target board/hardware (BSP).
+# To change the target, it is recommended to use the Library manager
+# ('make modlibs' from command line), which will also update Eclipse IDE launch
+# configurations. If TARGET is manually edited, ensure TARGET_.mtb with a
+# valid URL exists in the application, run 'make getlibs' to fetch BSP contents
+# and update or regenerate launch configurations for your IDE.
+TARGET=APP_$(BOARD)
+
+# Name of application (used to derive name of final linked file).
+#
+# If APPNAME / LIBNAME is edited, ensure to update or regenerate launch
+# configurations for your IDE.
+LIBNAME=libmtb
+
+# Name of toolchain to use. Options include:
+#
+# GCC_ARM -- GCC provided with ModusToolbox IDE
+# ARM -- ARM Compiler (must be installed separately)
+# IAR -- IAR Compiler (must be installed separately)
+#
+# See also: CY_COMPILER_PATH below
+TOOLCHAIN=GCC_ARM
+
+# Default build configuration. Options include:
+#
+# Debug -- build with minimal optimizations, focus on debugging.
+# Release -- build with full optimizations
+# Custom -- build with custom configuration, set the optimization flag in CFLAGS
+#
+# If CONFIG is manually edited, ensure to update or regenerate launch configurations
+# for your IDE.
+CONFIG=Debug
+
+# If set to "true" or "1", display full command-lines when building.
+VERBOSE=
+
+
+################################################################################
+# Advanced Configuration
+################################################################################
+
+# Enable optional code that is ordinarily disabled by default.
+#
+# Available components depend on the specific targeted hardware and firmware
+# in use. In general, if you have
+#
+# COMPONENTS=foo bar
+#
+# ... then code in directories named COMPONENT_foo and COMPONENT_bar will be
+# added to the build
+#
+COMPONENTS+=FREERTOS
+
+ifeq ($(MICROPY_PY_NETWORK),1)
+COMPONENTS+= LWIP
+endif
+
+ifeq ($(MICROPY_PY_SSL),1)
+COMPONENTS+=MBEDTLS
+endif
+
+# Like COMPONENTS, but disable optional code that was enabled by default.
+DISABLE_COMPONENTS=
+
+# By default the build system automatically looks in the Makefile's directory
+# tree for source code and builds it. The SOURCES variable can be used to
+# manually add source code to the build process from a location not searched
+# by default, or otherwise not found by the build system.
+SOURCES=
+
+DEFINES=CY_RETARGET_IO_CONVERT_LF_TO_CRLF CY_RTOS_AWARE
+
+
+ifeq ($(MICROPY_PY_NETWORK),1)
+DEFINES+= CYBSP_WIFI_CAPABLE WHD_PRINT_DISABLE
+
+# TODO: This is only for the CYCPROTO_BOARD??
+# CY8CPROTO-062-4343W board shares the same GPIO for the user button (USER BTN1)
+# and the CYW4343W host wake up pin. Since this example uses the GPIO for
+# interfacing with the user button, the SDIO interrupt to wake up the host is
+# disabled by setting CY_WIFI_HOST_WAKE_SW_FORCE to '0'.
+DEFINES+=CY_WIFI_HOST_WAKE_SW_FORCE=0
+endif
+
+ifeq ($(MICROPY_PY_SSL),1)
+DEFINES+=MBEDTLS_USER_CONFIG_FILE='"mbedtls_config.h"'
+endif
+
+# Like SOURCES, but for include directories. Value should be paths to
+# directories (without a leading -I).
+
+MPY_PSOC6_PORT_DIR = ../
+MPY_TOP_DIR = $(MPY_PSOC6_PORT_DIR)/../..
+
+ifeq ($(MICROPY_PY_SSL),1)
+MBEDTLS_CONF_DIR = $(MPY_PSOC6_PORT_DIR)/mbedtls
+MBEDTLS_MPY_CONF_DIR = $(MPY_TOP_DIR)/extmod/mbedtls
+INCLUDES+= $(MBEDTLS_CONF_DIR) $(MBEDTLS_MPY_CONF_DIR)
+endif
+
+ifeq ($(MICROPY_PY_NETWORK),1)
+LWIP_OPTS_DIR = $(MPY_PSOC6_PORT_DIR)/lwip_inc
+INCLUDES+= $(LWIP_OPTS_DIR)
+endif
+
+# Select softfp or hardfp floating point. Default is softfp.
+VFP_SELECT=
+
+# Additional / custom C compiler flags.
+#
+# NOTE: Includes and defines should use the INCLUDES and DEFINES variable
+# above.
+CFLAGS=-Wall -Werror -Wno-error=unused-function
+
+# Additional / custom C++ compiler flags.
+#
+# NOTE: Includes and defines should use the INCLUDES and DEFINES variable
+# above.
+CXXFLAGS=
+
+# Additional / custom assembler flags.
+#
+# NOTE: Includes and defines should use the INCLUDES and DEFINES variable
+# above.
+ASFLAGS=
+
+# Additional / custom linker flags.
+LDFLAGS=
+
+# Additional / custom libraries to link in to the application.
+LDLIBS=
+
+# Path to the linker script to use (if empty, use the default linker script).
+LINKER_SCRIPT=
+
+# Custom pre-build commands to run.
+PREBUILD=
+
+# Custom post-build commands to run.
+POSTBUILD=
+
+
+################################################################################
+# Paths
+################################################################################
+
+# Relative path to the project directory (default is the Makefile's directory).
+#
+# This controls where automatic source code discovery looks for code.
+CY_APP_PATH=
+
+# Relative path to the shared repo location.
+#
+# All .mtb files have the format, ##. If the field
+# begins with $$ASSET_REPO$$, then the repo is deposited in the path specified by
+# the CY_GETLIBS_SHARED_PATH variable. The default location is one directory level
+# above the current app directory.
+# This is used with CY_GETLIBS_SHARED_NAME variable, which specifies the directory name.
+CY_GETLIBS_SHARED_PATH=../
+
+# Directory name of the shared repo location.
+#
+CY_GETLIBS_SHARED_NAME=mtb_shared
+
+# Absolute path to the compiler's "bin" directory.
+#
+# The default depends on the selected TOOLCHAIN (GCC_ARM uses the ModusToolbox
+# IDE provided compiler by default).
+CY_COMPILER_PATH=
+
+
+# Locate ModusToolbox IDE helper tools folders in default installation
+# locations for Windows, Linux, and macOS.
+CY_WIN_HOME=$(subst \,/,$(USERPROFILE))
+CY_TOOLS_PATHS ?= $(wildcard \
+ $(CY_WIN_HOME)/ModusToolbox/tools_* \
+ $(HOME)/ModusToolbox/tools_* \
+ /Applications/ModusToolbox/tools_*)
+
+# If you install ModusToolbox IDE in a custom location, add the path to its
+# "tools_X.Y" folder (where X and Y are the version number of the tools
+# folder). Make sure you use forward slashes.
+CY_TOOLS_PATHS+=
+
+# Default to the newest installed tools folder, or the users override (if it's
+# found).
+CY_TOOLS_DIR=$(lastword $(sort $(wildcard $(CY_TOOLS_PATHS))))
+
+ifeq ($(CY_TOOLS_DIR),)
+$(error Unable to find any of the available CY_TOOLS_PATHS -- $(CY_TOOLS_PATHS). On Windows, use forward slashes.)
+endif
+
+$(info Tools Directory: $(CY_TOOLS_DIR))
+
+include $(CY_TOOLS_DIR)/make/start.mk
+
diff --git a/ports/psoc6/mtb-libs/README.md b/ports/psoc6/mtb-libs/README.md
new file mode 100755
index 0000000000000..7039393f31952
--- /dev/null
+++ b/ports/psoc6/mtb-libs/README.md
@@ -0,0 +1,3 @@
+# MTB Libraries
+
+ModusToolbox assets required for PSoC6 port and integrated boards.
diff --git a/ports/psoc6/mtb-libs/deps/.gitignore b/ports/psoc6/mtb-libs/deps/.gitignore
new file mode 100644
index 0000000000000..4057e40ef249c
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/.gitignore
@@ -0,0 +1 @@
+*.mtb
diff --git a/ports/psoc6/mtb-libs/deps/common/abstraction-rtos.mtb b/ports/psoc6/mtb-libs/deps/common/abstraction-rtos.mtb
new file mode 100644
index 0000000000000..9e0e2d4a15d49
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/common/abstraction-rtos.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/abstraction-rtos#release-v1.7.1#$$ASSET_REPO$$/abstraction-rtos/release-v1.7.1
diff --git a/ports/psoc6/mtb-libs/deps/common/clib-support.mtb b/ports/psoc6/mtb-libs/deps/common/clib-support.mtb
new file mode 100644
index 0000000000000..bce33f1e16709
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/common/clib-support.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/clib-support#release-v1.3.0#$$ASSET_REPO$$/clib-support/release-v1.3.0
diff --git a/ports/psoc6/mtb-libs/deps/common/freertos.mtb b/ports/psoc6/mtb-libs/deps/common/freertos.mtb
new file mode 100644
index 0000000000000..049a85d7daf4d
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/common/freertos.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/freertos#release-v10.4.305#$$ASSET_REPO$$/freertos/release-v10.4.305
diff --git a/ports/psoc6/mtb-libs/deps/common/retarget-io.mtb b/ports/psoc6/mtb-libs/deps/common/retarget-io.mtb
new file mode 100755
index 0000000000000..f540d3f5aff6e
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/common/retarget-io.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/retarget-io#release-v1.4.0#$$ASSET_REPO$$/retarget-io/release-v1.4.0
diff --git a/ports/psoc6/mtb-libs/deps/crypto/cy-mbedtls-acceleration.mtb b/ports/psoc6/mtb-libs/deps/crypto/cy-mbedtls-acceleration.mtb
new file mode 100644
index 0000000000000..51ef827d723ab
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/crypto/cy-mbedtls-acceleration.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/cy-mbedtls-acceleration#release-v1.4.1#$$ASSET_REPO$$/cy-mbedtls-acceleration/release-v1.4.1
diff --git a/ports/psoc6/mtb-libs/deps/crypto/mbedtls.mtb b/ports/psoc6/mtb-libs/deps/crypto/mbedtls.mtb
new file mode 100644
index 0000000000000..1d5a848aeeb47
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/crypto/mbedtls.mtb
@@ -0,0 +1 @@
+https://github.com/ARMmbed/mbedtls#mbedtls-2.25.0#$$ASSET_REPO$$/mbedtls/mbedtls-2.25.0
diff --git a/ports/psoc6/mtb-libs/deps/ext_flash/serial-flash.mtb b/ports/psoc6/mtb-libs/deps/ext_flash/serial-flash.mtb
new file mode 100755
index 0000000000000..9160fea00a9c8
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/ext_flash/serial-flash.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/serial-flash#release-v1.3.0#$$ASSET_REPO$$/serial-flash/release-v1.3.0
diff --git a/ports/psoc6/mtb-libs/deps/network/abstraction-rtos.mtb b/ports/psoc6/mtb-libs/deps/network/abstraction-rtos.mtb
new file mode 100644
index 0000000000000..9e0e2d4a15d49
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/abstraction-rtos.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/abstraction-rtos#release-v1.7.1#$$ASSET_REPO$$/abstraction-rtos/release-v1.7.1
diff --git a/ports/psoc6/mtb-libs/deps/network/clib-support.mtb b/ports/psoc6/mtb-libs/deps/network/clib-support.mtb
new file mode 100644
index 0000000000000..bce33f1e16709
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/clib-support.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/clib-support#release-v1.3.0#$$ASSET_REPO$$/clib-support/release-v1.3.0
diff --git a/ports/psoc6/mtb-libs/deps/network/connectivity-utilities.mtb b/ports/psoc6/mtb-libs/deps/network/connectivity-utilities.mtb
new file mode 100644
index 0000000000000..0ec4158fef0c9
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/connectivity-utilities.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/connectivity-utilities#release-v4.1.0#$$ASSET_REPO$$/connectivity-utilities/release-v4.1.0
diff --git a/ports/psoc6/mtb-libs/deps/network/freertos.mtb b/ports/psoc6/mtb-libs/deps/network/freertos.mtb
new file mode 100644
index 0000000000000..049a85d7daf4d
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/freertos.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/freertos#release-v10.4.305#$$ASSET_REPO$$/freertos/release-v10.4.305
diff --git a/ports/psoc6/mtb-libs/deps/network/lwip-freertos-integration.mtb b/ports/psoc6/mtb-libs/deps/network/lwip-freertos-integration.mtb
new file mode 100644
index 0000000000000..83756af8190f3
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/lwip-freertos-integration.mtb
@@ -0,0 +1 @@
+https://github.com/Infineon/lwip-freertos-integration#release-v1.0.0#$$ASSET_REPO$$/lwip-freertos-integration/release-v1.0.0
diff --git a/ports/psoc6/mtb-libs/deps/network/lwip-network-interface-integration.mtb b/ports/psoc6/mtb-libs/deps/network/lwip-network-interface-integration.mtb
new file mode 100644
index 0000000000000..9f8619386303a
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/lwip-network-interface-integration.mtb
@@ -0,0 +1 @@
+https://github.com/Infineon/lwip-network-interface-integration#release-v1.1.1#$$ASSET_REPO$$/lwip-network-interface-integration/release-v1.1.1
diff --git a/ports/psoc6/mtb-libs/deps/network/lwip.mtb b/ports/psoc6/mtb-libs/deps/network/lwip.mtb
new file mode 100755
index 0000000000000..b75f66ce962be
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/lwip.mtb
@@ -0,0 +1 @@
+https://git.savannah.nongnu.org/git/lwip#STABLE-2_1_3_RELEASE#$$LOCAL$$/lwip
diff --git a/ports/psoc6/mtb-libs/deps/network/secure-sockets.mtb b/ports/psoc6/mtb-libs/deps/network/secure-sockets.mtb
new file mode 100644
index 0000000000000..e1f63cf729579
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/secure-sockets.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/secure-sockets#release-v3.2.0#$$ASSET_REPO$$/secure-sockets/release-v3.2.0
diff --git a/ports/psoc6/mtb-libs/deps/network/whd-bsp-integration.mtb b/ports/psoc6/mtb-libs/deps/network/whd-bsp-integration.mtb
new file mode 100755
index 0000000000000..a4e6e48fdfa51
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/whd-bsp-integration.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/whd-bsp-integration#release-v2.1.0#$$LOCAL$$/whd-bsp-integration
diff --git a/ports/psoc6/mtb-libs/deps/network/wifi-connection-manager.mtb b/ports/psoc6/mtb-libs/deps/network/wifi-connection-manager.mtb
new file mode 100755
index 0000000000000..1dfc5c220be17
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/wifi-connection-manager.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/wifi-connection-manager#release-v3.0.1#$$LOCAL$$/wifi-connection-manager
diff --git a/ports/psoc6/mtb-libs/deps/network/wifi-host-driver.mtb b/ports/psoc6/mtb-libs/deps/network/wifi-host-driver.mtb
new file mode 100755
index 0000000000000..30f1e3ebf334a
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/wifi-host-driver.mtb
@@ -0,0 +1 @@
+https://github.com/cypresssemiconductorco/wifi-host-driver#release-v2.5.0#$$LOCAL$$/wifi-host-driver
diff --git a/ports/psoc6/mtb-libs/deps/network/wpa3-external-supplicant.mtb b/ports/psoc6/mtb-libs/deps/network/wpa3-external-supplicant.mtb
new file mode 100644
index 0000000000000..751223c7ba127
--- /dev/null
+++ b/ports/psoc6/mtb-libs/deps/network/wpa3-external-supplicant.mtb
@@ -0,0 +1 @@
+https://github.com/Infineon/wpa3-external-supplicant#release-v1.1.0#$$ASSET_REPO$$/wpa3-external-supplicant/release-v1.1.0
diff --git a/ports/psoc6/mtb-libs/makefile_mtb.mk b/ports/psoc6/mtb-libs/makefile_mtb.mk
new file mode 100644
index 0000000000000..45e95517ccb39
--- /dev/null
+++ b/ports/psoc6/mtb-libs/makefile_mtb.mk
@@ -0,0 +1,149 @@
+# get variable definitions from main makefile
+MTB_LIBS_DIR = mtb-libs
+MTB_MAIN_MAKEFILE := $(MTB_LIBS_DIR)/Makefile
+MTB_CONFIG ?= $(shell egrep '^ *CONFIG' $(MTB_MAIN_MAKEFILE) | sed 's/^.*= *//g')
+
+MTB_LIBS_BUILD_DIR := $(MTB_LIBS_DIR)/$(BUILD)
+MTB_LIBS_BOARD_BUILD_DIR := $(MTB_LIBS_BUILD_DIR)/APP_$(BOARD)/$(MPY_MTB_CONFIG)
+
+MTB_STATIC_LIB_NAME = $(file < $(MTB_LIBS_BOARD_BUILD_DIR)/artifact.rsp)
+
+$(info MTB_MAIN_MAKEFILE : $(MTB_MAIN_MAKEFILE))
+$(info MTB_TARGET : APP_$(BOARD))
+$(info MTB_CONFIG : $(MTB_CONFIG))
+$(info MTB_LIB_NAME : $(MTB_STATIC_LIB_NAME))
+
+$(info MTB_LIBS_BUILD_DIR : $(MTB_LIBS_BUILD_DIR))
+$(info MTB_LIBS_BOARD_BUILD_DIR : $(MTB_LIBS_BOARD_BUILD_DIR))
+
+mtb_init: mtb_deinit mtb_add_bsp mtb_set_bsp mtb_get_libs
+ $(info )
+ $(info Initializing ModusToolbox libs for board $(BOARD))
+
+# Choose the ModusToolbox deps according to board config parameters
+MTB_DEPS_DIRS = common
+ifeq ($(MICROPY_PY_NETWORK),1)
+MTB_DEPS_DIRS += network
+endif
+
+ifeq ($(MICROPY_PY_EXT_FLASH),1)
+MTB_DEPS_DIRS += ext_flash
+endif
+
+ifeq ($(MICROPY_PY_SSL), 1)
+MTB_DEPS_DIRS += crypto
+endif
+
+# The ModusToolbox expects all the .mtb files to be in the /deps folder.
+# The feature specific dependencies organized in folders are directly copied
+# to the deps/ root folder
+# In theory, the build inclusion/exclusion of components can be handled by the
+# COMPONENTS variable of the ModusToolbox Makefile. T
+# This feature does not seem to scale well for this use case (Or better knowledge
+# on how to use it is required :|).
+# It seems easier to just explicitly include only those middleware assets
+# and libraries required for a given bsp and its required MicroPython capabilities.
+mtb_config_deps:
+ @:
+ $(info )
+ $(info Configuring ModusToolbox dependencies ...)
+ $(info mtb_deps_dir : $(MTB_LIBS_DIR)/deps/$(MTB_DEPS_DIRS)/)
+ $(Q) $(foreach DIR, $(MTB_DEPS_DIRS), $(shell cp -r $(MTB_LIBS_DIR)/deps/$(DIR)/. $(MTB_LIBS_DIR)/deps))
+
+mtb_get_libs: mtb_config_deps
+ $(info )
+ $(info Retrieving ModusToolbox dependencies ...)
+ $(Q) $(MAKE) -C $(MTB_LIBS_DIR) getlibs
+
+mtb_add_bsp:
+ $(info )
+ $(info Adding board $(BOARD) dependencies ...)
+ $(Q) cd $(MTB_LIBS_DIR); library-manager-cli --project . --add-bsp-name $(BOARD) --add-bsp-version $(BOARD_VERSION)
+
+mtb_set_bsp:
+ $(info )
+ $(info Setting board $(BOARD) as active ...)
+ $(Q) cd $(MTB_LIBS_DIR); library-manager-cli --project . --set-active-bsp APP_$(BOARD)
+
+# Remove MTB retrieved lib and dependencies
+mtb_deinit: clean
+ $(info )
+ $(info Removing mtb_shared and libs folder ...)
+ -$(Q) cd $(MTB_LIBS_DIR); rm -rf libs
+ -$(Q) cd $(MTB_LIBS_DIR); rm -rf bsps
+ -$(Q) cd $(MTB_LIBS_DIR); rm -rf ../mtb_shared
+ -$(Q) cd $(MTB_LIBS_DIR); find deps/*.mtb -maxdepth 1 -type f -delete
+
+# Some of the configuration variables are passed to the ModusToolbox
+# Makefile to include/exclude certain middleware libraries and components
+MPY_MTB_MAKE_VARS = MICROPY_PY_NETWORK=$(MICROPY_PY_NETWORK) MICROPY_PY_SSL=$(MICROPY_PY_SSL) BOARD=$(BOARD)
+
+# build MTB project
+mtb_build:
+ $(info )
+ $(info Building $(BOARD) in $(CONFIG) mode using MTB ...)
+ $(Q) $(MAKE) -C $(MTB_LIBS_DIR) CONFIG=$(MPY_MTB_CONFIG) $(MPY_MTB_MAKE_VARS) build
+
+
+mtb_clean:
+ -$ rm -rf $(MTB_LIBS_BUILD_DIR)
+
+# get variables set for includes, objects, etc. and add to mpy makefile variables
+mtb_get_build_flags: mtb_build
+ @:
+ $(eval MPY_MTB_INCLUDE_DIRS = $(file < $(MTB_LIBS_BOARD_BUILD_DIR)/inclist.rsp))
+ $(eval INC += $(subst -I,-I$(MTB_LIBS_DIR)/,$(MPY_MTB_INCLUDE_DIRS)))
+ $(eval INC += -I$(BOARD_DIR))
+ $(eval MPY_MTB_LIBRARIES = $(file < $(MTB_LIBS_BOARD_BUILD_DIR)/liblist.rsp))
+ $(eval LIBS += $(MTB_LIBS_BOARD_BUILD_DIR)/$(MTB_STATIC_LIB_NAME))
+ $(eval CFLAGS += $(shell $(PYTHON) $(MTB_LIBS_DIR)/mtb_build_info.py ccxxflags $(MTB_LIBS_BOARD_BUILD_DIR)/.cycompiler ))
+ $(eval CXXFLAGS += $(CFLAGS))
+ $(eval LDFLAGS += $(shell $(PYTHON) $(MTB_LIBS_DIR)/mtb_build_info.py ldflags $(MTB_LIBS_BOARD_BUILD_DIR)/.cylinker $(MTB_LIBS_DIR)))
+ $(eval QSTR_GEN_CFLAGS += $(INC) $(CFLAGS))
+
+# When multiple types of boards are connected, a devs file needs to be provided.
+# When working locally, if a "local-devs.yml" file is placed in "tools/psoc6"
+# it will be used
+ifneq ($(DEVS_FILE),)
+MULTI_BOARD_DEVS_OPTS = -b $(BOARD) -y $(DEVS_FILE)
+else
+DFLT_LOCAL_DEVS_FILE_NAME = local-devs.yml
+LOCAL_DEVS_FILE=$(TOP)/tools/psoc6/$(DFLT_LOCAL_DEVS_FILE_NAME)
+ifneq (,$(wildcard $(LOCAL_DEVS_FILE)))
+MULTI_BOARD_DEVS_OPTS = -b $(BOARD) -y $(LOCAL_DEVS_FILE)
+endif
+endif
+
+attached_devs:
+ @:
+ $(eval ATTACHED_TARGET_LIST = $(shell $(PYTHON) $(TOP)/tools/psoc6/get-devs.py serial-number $(MULTI_BOARD_DEVS_OPTS)))
+ $(eval ATTACHED_TARGETS_NUMBER = $(words $(ATTACHED_TARGET_LIST)))
+ $(info Number of attached targets : $(ATTACHED_TARGETS_NUMBER))
+ $(info List of attached targets : $(ATTACHED_TARGET_LIST))
+
+ifndef EXT_HEX_FILE
+HEX_FILE = $(BUILD)/firmware.hex
+PROG_DEPS=build
+else
+HEX_FILE = $(EXT_HEX_FILE)
+endif
+
+MTB_HOME ?= $(HOME)/ModusToolbox
+OPENOCD_HOME ?= $(MTB_HOME)/tools_3.0/openocd
+
+# Selection of openocd cfg files based on board
+OPENOCD_CFG_SEARCH = $(MTB_LIBS_DIR)/bsps/TARGET_APP_$(BOARD)/config/GeneratedSource
+
+program: $(PROG_DEPS)
+ @:
+ $(info )
+ $(info Programming using openocd ...)
+ openocd -s $(OPENOCD_HOME)/scripts -s $(OPENOCD_CFG_SEARCH) -c "source [find interface/kitprog3.cfg]; $(SERIAL_ADAPTER_CMD) ; source [find target/$(OPENOCD_TARGET_CFG)]; psoc6 allow_efuse_program off; psoc6 sflash_restrictions 1; program $(HEX_FILE) verify reset exit;"
+ $(info Programming done.)
+
+program_multi: attached_devs
+ @:
+ $(foreach ATTACHED_TARGET, $(ATTACHED_TARGET_LIST), $(MAKE) program SERIAL_ADAPTER_CMD='adapter serial $(ATTACHED_TARGET)';)
+
+
+.PHONY: mtb_init mtb_deinit mtb_config_deps mtb_build mtb_get_build_flags program program_multi
\ No newline at end of file
diff --git a/ports/psoc6/mtb-libs/mtb_build_info.py b/ports/psoc6/mtb-libs/mtb_build_info.py
new file mode 100644
index 0000000000000..c7b2f3d12d2e4
--- /dev/null
+++ b/ports/psoc6/mtb-libs/mtb_build_info.py
@@ -0,0 +1,90 @@
+# This script is used to parse the ModusToolbox build output files to extract build flags
+# that needs to be used as well in the MicroPython sources build.
+
+import argparse, json, os
+
+
+def get_file_content(file):
+ with open(file, "r") as f:
+ f_content = f.read()
+
+ return f_content
+
+
+def get_ccxx_build_flags(cycompiler_file):
+ # Extract the flags located between '-c' option and
+ # the first (.rsp) response file
+ # Warning: is the response file a proper delimiter (?)
+ def find_flags_start(build_cmd_list):
+ return build_cmd_list.index("-c") + 1 # next is the first element
+
+ def find_flags_end(build_cmd_list):
+ file_opt = [item for item in build_cmd_list if item.startswith("@")]
+ return build_cmd_list.index(file_opt[0])
+
+ build_cmd = get_file_content(cycompiler_file)
+ build_cmd_list = build_cmd.split()
+
+ start_idx = find_flags_start(build_cmd_list)
+ end_idx = find_flags_end(build_cmd_list)
+
+ ccxx_flags = build_cmd_list[start_idx:end_idx]
+ print(*ccxx_flags)
+
+
+def get_ld_linker_flags(cylinker_file, mtb_libs_path):
+ # Get flags only until the linker script after the compiler argument -T
+ def find_flags_start(link_cmd_list):
+ gcc_cmd = [item for item in link_cmd_list if item.endswith("arm-none-eabi-g++")]
+ return link_cmd_list.index(gcc_cmd[0]) + 1
+
+ def find_flags_end(link_cmd_list):
+ link_script_file_param = [item for item in link_cmd_list if item.startswith("-T")]
+ return link_cmd_list.index(link_script_file_param[0]) + 1
+
+ def set_path_of_linker_script(link_cmd_list, inker_script_param_index, mtb_libs_path):
+ link_cmd_list[inker_script_param_index] = (
+ "-T" + str(mtb_libs_path) + "/" + link_cmd_list[inker_script_param_index][len("-T") :]
+ )
+
+ link_cmd = get_file_content(cylinker_file)
+ link_cmd_list = link_cmd.split()
+
+ start_idx = find_flags_start(link_cmd_list)
+ end_idx = find_flags_end(link_cmd_list)
+ set_path_of_linker_script(link_cmd_list, end_idx - 1, mtb_libs_path)
+
+ ld_flags = link_cmd_list[start_idx:end_idx]
+ print(*ld_flags)
+
+
+def parser():
+ def main_parser_func(args):
+ parser.print_help()
+
+ def parser_get_ccxxflags_func(args):
+ get_ccxx_build_flags(args.cycompiler_file)
+
+ def parser_get_ldflags_func(args):
+ get_ld_linker_flags(args.cylinker_file, args.mtb_libs_path)
+
+ parser = argparse.ArgumentParser(description="Utility to retrieve ModusToolbox build info")
+ subparser = parser.add_subparsers()
+ parser.set_defaults(func=main_parser_func)
+
+ parser_ccxx = subparser.add_parser("ccxxflags", description="Get C and CXX build flags")
+ parser_ccxx.add_argument("cycompiler_file", type=str, help=".cycompiler file")
+ parser_ccxx.set_defaults(func=parser_get_ccxxflags_func)
+
+ parser_ld = subparser.add_parser("ldflags", description="Get linker flags")
+ parser_ld.add_argument("cylinker_file", type=str, help=".cylinker file")
+ parser_ld.add_argument("mtb_libs_path", type=str, help="Path to mtb-libs folder")
+ parser_ld.set_defaults(func=parser_get_ldflags_func)
+
+ # Parser call
+ args = parser.parse_args()
+ args.func(args)
+
+
+if __name__ == "__main__":
+ parser()
diff --git a/ports/psoc6/network_ifx_wcm.c b/ports/psoc6/network_ifx_wcm.c
new file mode 100644
index 0000000000000..7a1117dc5d395
--- /dev/null
+++ b/ports/psoc6/network_ifx_wcm.c
@@ -0,0 +1,846 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ * Copyright (c) 2023 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include
+#include
+#include "py/runtime.h"
+#include "py/objstr.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_NETWORK_IFX_WCM
+
+#include "lwip/netif.h"
+#include "lwip/dns.h"
+#include "whd.h"
+#include "whd_network_types.h"
+#include "whd_wlioctl.h"
+#include "network_ifx_wcm.h"
+#include "whd_wifi_api.h"
+#include "extmod/modnetwork.h"
+#include "cy_wcm.h"
+#include "cy_nw_helper.h"
+#include "mplogger.h"
+
+#include "FreeRTOS.h"
+#include "shared/netutils/netutils.h"
+
+extern uint8_t cy_wcm_is_ap_up();
+
+#define NETWORK_WLAN_DEFAULT_SSID "mpy-psoc6-wlan"
+#define NETWORK_WLAN_DEFAULT_PASSWORD "mpy_PSOC6_w3lc0me!"
+#define NETWORK_WLAN_DEFAULT_SECURITY CY_WCM_SECURITY_WPA2_AES_PSK
+#define NETWORK_WLAN_DEFAULT_CHANNEL 9
+
+#define NETWORK_WLAN_AP_IP "192.168.0.1"
+#define NETWORK_WLAN_AP_GATEWAY_IP "192.168.0.1"
+#define NETWORK_WLAN_AP_NETMASK_IP "255.255.255.0"
+
+#define NETWORK_WLAN_MAX_AP_STATIONS 8
+
+#define NET_IFX_WCM_SEC_OPEN 0
+#define NET_IFX_WCM_SEC_WEP 1
+#define NET_IFX_WCM_SEC_WPA 2
+#define NET_IFX_WCM_SEC_WPA2 3
+#define NET_IFX_WCM_SEC_WPA_WPA2 4
+#define NET_IFX_WCM_SEC_WPA3 5
+#define NET_IFX_WCM_SEC_UNKNOWN 6
+
+typedef struct
+{
+ cy_wcm_ap_config_t ap_config;
+} network_ifx_wcm_ap_obj_t;
+
+typedef struct
+{
+ cy_wcm_associated_ap_info_t ap_info;
+ uint8_t connect_retries;
+} network_ifx_wcm_sta_obj_t;
+
+typedef union {
+ network_ifx_wcm_ap_obj_t ap_obj;
+ network_ifx_wcm_sta_obj_t sta_obj;
+} itf_obj_t;
+
+typedef struct _network_ifx_wcm_obj_t {
+ mp_obj_base_t base;
+ cy_wcm_interface_t itf;
+ itf_obj_t itf_obj;
+ cy_wcm_ip_setting_t ip_config;
+} network_ifx_wcm_obj_t;
+
+#define MAX_WHD_INTERFACE (2)
+
+extern whd_interface_t whd_ifs[MAX_WHD_INTERFACE];
+
+static network_ifx_wcm_obj_t network_ifx_wcm_wl_sta = { { &mp_network_ifx_wcm_type }, CY_WCM_INTERFACE_TYPE_STA };
+static network_ifx_wcm_obj_t network_ifx_wcm_wl_ap = { { &mp_network_ifx_wcm_type }, CY_WCM_INTERFACE_TYPE_AP };
+
+#define wcm_get_ap_conf_ptr(net_obj) & (net_obj.itf_obj.ap_obj.ap_config)
+#define wcm_get_sta_conf_ptr(net_obj) & (net_obj.itf_obj.sta_obj)
+#define wcm_get_sta_ap_info_ptr(net_obj) & (net_obj.itf_obj.sta_obj.ap_info)
+
+#define wcm_assert_raise(msg, ret) if (ret != CY_RSLT_SUCCESS) { \
+ mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), ret); \
+}
+
+void network_deinit(void) {
+ cy_rslt_t ret = cy_wcm_deinit();
+ wcm_assert_raise("network deinit error (code: %d)", ret);
+}
+
+// Network Access Point initialization with default network parameters
+void network_ap_init() {
+ cy_rslt_t ret = CY_RSLT_SUCCESS;
+ cy_wcm_ap_config_t *ap_conf = wcm_get_ap_conf_ptr(network_ifx_wcm_wl_ap);
+ cy_wcm_ip_setting_t *ap_ip_settings = &(ap_conf->ip_settings);
+
+ ap_conf->channel = NETWORK_WLAN_DEFAULT_CHANNEL;
+ memcpy(ap_conf->ap_credentials.SSID, NETWORK_WLAN_DEFAULT_SSID, strlen(NETWORK_WLAN_DEFAULT_SSID) + 1);
+ memcpy(ap_conf->ap_credentials.password, NETWORK_WLAN_DEFAULT_PASSWORD, strlen(NETWORK_WLAN_DEFAULT_PASSWORD) + 1);
+ ap_conf->ap_credentials.security = NETWORK_WLAN_DEFAULT_SECURITY;
+
+ cy_wcm_set_ap_ip_setting(ap_ip_settings, NETWORK_WLAN_AP_IP, NETWORK_WLAN_AP_NETMASK_IP, NETWORK_WLAN_AP_GATEWAY_IP, CY_WCM_IP_VER_V4);
+ wcm_assert_raise("network ap ip setting error (code: %d)", ret);
+}
+
+static void restart_ap(cy_wcm_ap_config_t *ap_conf) {
+ if (cy_wcm_is_ap_up()) {
+ uint32_t ret = cy_wcm_stop_ap();
+ wcm_assert_raise("network ap deactivate error (with code: %d)", ret);
+ ret = cy_wcm_start_ap(ap_conf);
+ wcm_assert_raise("network ap active error (with code: %d)", ret);
+ }
+}
+
+void network_sta_init() {
+ network_ifx_wcm_sta_obj_t *sta_conf = wcm_get_sta_conf_ptr(network_ifx_wcm_wl_sta);
+ sta_conf->connect_retries = 3; // Default connect retries
+}
+
+// Network Initialization function (called from main.c)
+void network_init(void) {
+ cy_rslt_t ret = CY_RSLT_SUCCESS;
+ cy_wcm_config_t wcm_config = { .interface = CY_WCM_INTERFACE_TYPE_AP_STA };
+
+ ret = cy_wcm_init(&wcm_config);
+ wcm_assert_raise("network init error (code: %d)", ret);
+
+ network_ap_init();
+ network_sta_init();
+}
+
+// Print after constructor invoked
+static void network_ifx_wcm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+ const char *status_str;
+ if (self->itf == CY_WCM_INTERFACE_TYPE_STA) {
+ if (cy_wcm_is_connected_to_ap()) {
+ status_str = "joined";
+ } else {
+ status_str = "down";
+ }
+ } else {
+ if (cy_wcm_is_ap_up()) {
+ status_str = "up";
+ } else {
+ status_str = "down";
+ }
+ }
+
+ cy_wcm_ip_address_t ip_address;
+ cy_rslt_t ret = cy_wcm_get_ip_addr(self->itf, &ip_address);
+ if (ret != CY_RSLT_SUCCESS) {
+ ip_address.ip.v4 = 0;
+ }
+
+ mp_printf(print, "",
+ self->itf == CY_WCM_INTERFACE_TYPE_STA ? "STA" : "AP",
+ status_str,
+ ip_address.ip.v4 & 0xff,
+ ip_address.ip.v4 >> 8 & 0xff,
+ ip_address.ip.v4 >> 16 & 0xff,
+ ip_address.ip.v4 >> 24
+ );
+}
+
+static mp_obj_t network_ifx_wcm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+ mp_arg_check_num(n_args, n_kw, 0, 1, false);
+
+ if (n_args == 0 || mp_obj_get_int(args[0]) == MOD_NETWORK_STA_IF) {
+ return MP_OBJ_FROM_PTR(&network_ifx_wcm_wl_sta);
+ } else {
+ return MP_OBJ_FROM_PTR(&network_ifx_wcm_wl_ap);
+ }
+ return mp_const_none;
+}
+
+/*******************************************************************************/
+// network API
+
+static mp_obj_t network_ifx_wcm_deinit(mp_obj_t self_in) {
+ network_deinit();
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ifx_wcm_deinit_obj, network_ifx_wcm_deinit);
+
+static mp_obj_t network_ifx_wcm_active(size_t n_args, const mp_obj_t *args) {
+ cy_rslt_t ret = CY_RSLT_SUCCESS;
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+ if (self->itf == CY_WCM_INTERFACE_TYPE_STA) {
+ if (n_args == 1) {
+ return mp_obj_new_bool(cy_wcm_is_connected_to_ap());
+ }
+ } else if (self->itf == CY_WCM_INTERFACE_TYPE_AP) {
+ if (n_args == 1) {
+ return mp_obj_new_bool(cy_wcm_is_ap_up());
+ } else {
+ if (mp_obj_is_true(args[1])) {
+ cy_wcm_ap_config_t *ap_conf = wcm_get_ap_conf_ptr(network_ifx_wcm_wl_ap);
+ ret = cy_wcm_start_ap(ap_conf);
+ wcm_assert_raise("network ap active error (with code: %d)", ret);
+ } else {
+ ret = cy_wcm_stop_ap();
+ wcm_assert_raise("network ap deactivate error (with code: %d)", ret);
+ }
+ }
+ }
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_ifx_wcm_active_obj, 1, 2, network_ifx_wcm_active);
+
+typedef struct
+{
+ mp_obj_t *scan_list;
+ cy_wcm_scan_status_t status;
+}scan_user_data_t;
+
+// Based on the scan result, get micropython defined equivalent security type (possible value 0-4, extended till 7 to include all cases) and security string (mapped to IFX stack)
+uint8_t get_mpy_security_type(cy_wcm_security_t wcm_sec) {
+ uint8_t mpy_sec_type = NET_IFX_WCM_SEC_UNKNOWN;
+
+ switch (wcm_sec)
+ {
+ case CY_WCM_SECURITY_OPEN:
+ mpy_sec_type = NET_IFX_WCM_SEC_OPEN;
+ break;
+ case CY_WCM_SECURITY_WEP_PSK:
+ case CY_WCM_SECURITY_WEP_SHARED:
+ case CY_WCM_SECURITY_IBSS_OPEN:
+ mpy_sec_type = NET_IFX_WCM_SEC_WEP;
+ break;
+ case CY_WCM_SECURITY_WPA_AES_PSK:
+ case CY_WCM_SECURITY_WPA_MIXED_PSK:
+ case CY_WCM_SECURITY_WPA_TKIP_PSK:
+ case CY_WCM_SECURITY_WPA_TKIP_ENT:
+ case CY_WCM_SECURITY_WPA_AES_ENT:
+ case CY_WCM_SECURITY_WPA_MIXED_ENT:
+ mpy_sec_type = NET_IFX_WCM_SEC_WPA;
+ break;
+ case CY_WCM_SECURITY_WPA2_AES_PSK:
+ case CY_WCM_SECURITY_WPA2_TKIP_PSK:
+ case CY_WCM_SECURITY_WPA2_MIXED_PSK:
+ case CY_WCM_SECURITY_WPA2_FBT_PSK:
+ case CY_WCM_SECURITY_WPA2_TKIP_ENT:
+ case CY_WCM_SECURITY_WPA2_AES_ENT:
+ case CY_WCM_SECURITY_WPA2_MIXED_ENT:
+ case CY_WCM_SECURITY_WPA2_FBT_ENT:
+ mpy_sec_type = NET_IFX_WCM_SEC_WPA2;
+ break;
+ case CY_WCM_SECURITY_WPA2_WPA_AES_PSK:
+ case CY_WCM_SECURITY_WPA2_WPA_MIXED_PSK:
+ mpy_sec_type = NET_IFX_WCM_SEC_WPA_WPA2;
+ break;
+ case CY_WCM_SECURITY_WPA3_SAE:
+ case CY_WCM_SECURITY_WPA3_WPA2_PSK:
+ mpy_sec_type = NET_IFX_WCM_SEC_WPA3;
+ break;
+ case CY_WCM_SECURITY_WPS_SECURE:
+ case CY_WCM_SECURITY_UNKNOWN:
+ default:
+ mpy_sec_type = NET_IFX_WCM_SEC_UNKNOWN;
+ break;
+ }
+ return mpy_sec_type;
+}
+
+// Callback function for scan method. After each scan result, the scan callback is executed.
+static void network_ifx_wcm_scan_cb(cy_wcm_scan_result_t *result_ptr, void *user_data, cy_wcm_scan_status_t status) {
+ scan_user_data_t *scan_user_data = (scan_user_data_t *)user_data;
+ mp_obj_t scan_list = MP_OBJ_FROM_PTR(scan_user_data->scan_list);
+ uint8_t hidden_status = 1; // HIDDEN
+ uint8_t security_type = NET_IFX_WCM_SEC_OPEN;
+
+ if (status == CY_WCM_SCAN_INCOMPLETE) {
+ // Get the network status : hidden(1) or open(0)
+ if (strlen((const char *)result_ptr->SSID) != 0) {
+ hidden_status = 0;
+ }
+
+ // Get security type as mapped in micropython function description
+ security_type = get_mpy_security_type(result_ptr->security);
+
+ mp_obj_t tuple[6] = {
+ mp_obj_new_bytes(result_ptr->SSID, strlen((const char *)result_ptr->SSID)),
+ mp_obj_new_bytes(result_ptr->BSSID, CY_WCM_MAC_ADDR_LEN),
+ MP_OBJ_NEW_SMALL_INT(result_ptr->channel),
+ MP_OBJ_NEW_SMALL_INT(result_ptr->signal_strength),
+ MP_OBJ_NEW_SMALL_INT(security_type),
+ MP_OBJ_NEW_SMALL_INT(hidden_status)
+ };
+ mp_obj_list_append(scan_list, mp_obj_new_tuple(6, tuple));
+ }
+
+ scan_user_data->status = status;
+}
+
+static mp_obj_t network_ifx_wcm_scan(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+ cy_rslt_t ret = CY_RSLT_SUCCESS;
+ cy_wcm_scan_filter_t scan_filter;
+ bool is_filter_used = false;
+
+ if (self->itf != CY_WCM_INTERFACE_TYPE_STA) {
+ mp_raise_ValueError(MP_ERROR_TEXT("network STA required"));
+ }
+
+ if (n_args != 1) {
+ mp_raise_TypeError(MP_ERROR_TEXT("network scan accepts no query parameters"));
+ }
+
+ if (kwargs->used != 0) {
+ if (kwargs->alloc != 1) {
+ mp_raise_TypeError(MP_ERROR_TEXT("network scan only accepts one filter mode"));
+ }
+
+ is_filter_used = true;
+ mp_map_elem_t *e = &kwargs->table[0];
+ switch (mp_obj_str_get_qstr(e->key))
+ {
+ case MP_QSTR_ssid: {
+ scan_filter.mode = CY_WCM_SCAN_FILTER_TYPE_SSID;
+ size_t len;
+ const char *ssid = mp_obj_str_get_data(e->value, &len);
+ len = MIN(len, CY_WCM_MAX_SSID_LEN + 1);
+ memcpy(scan_filter.param.SSID, ssid, len);
+ memset(&scan_filter.param.SSID[len], 0, 1); // null terminated str.
+ break;
+ }
+
+ case MP_QSTR_bssid: {
+ scan_filter.mode = CY_WCM_SCAN_FILTER_TYPE_MAC;
+ mp_buffer_info_t bssid;
+ mp_get_buffer(e->value, &bssid, MP_BUFFER_READ);
+ if (bssid.len != CY_WCM_MAC_ADDR_LEN) {
+ mp_raise_ValueError(MP_ERROR_TEXT("bssid address invalid length"));
+ }
+ memcpy(scan_filter.param.BSSID, bssid.buf, bssid.len);
+ break;
+ }
+
+ default:
+ mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+ }
+ }
+
+ mp_obj_t network_list = mp_obj_new_list(0, NULL);
+ scan_user_data_t scan_user_params;
+ scan_user_params.scan_list = MP_OBJ_TO_PTR(network_list);
+ scan_user_params.status = CY_WCM_SCAN_INCOMPLETE;
+
+ cy_wcm_scan_filter_t *scan_filter_ptr = NULL;
+ if (is_filter_used) {
+ scan_filter_ptr = &scan_filter;
+ }
+
+ ret = cy_wcm_start_scan(network_ifx_wcm_scan_cb, (void *)&scan_user_params, scan_filter_ptr);
+ wcm_assert_raise("network scan error (with code: %d)", ret);
+
+ while (scan_user_params.status == CY_WCM_SCAN_INCOMPLETE /*|| TODO: timeout_expired */) {
+ }
+
+ return scan_user_params.scan_list;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(network_ifx_wcm_scan_obj, 1, network_ifx_wcm_scan);
+
+static mp_obj_t network_ifx_wcm_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+
+ enum { ARG_ssid, ARG_key, ARG_bssid };
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_ssid, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_key, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+ { MP_QSTR_bssid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} }
+ };
+
+ if (self->itf != CY_WCM_INTERFACE_TYPE_STA) {
+ mp_raise_ValueError(MP_ERROR_TEXT("network STA required"));
+ }
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ cy_wcm_connect_params_t connect_param;
+ cy_wcm_ip_address_t ipaddress;
+ memset(&connect_param, 0, sizeof(cy_wcm_connect_params_t));
+
+ // Extract the SSID.
+ mp_buffer_info_t ssid;
+ mp_get_buffer_raise(args[ARG_ssid].u_obj, &ssid, MP_BUFFER_READ);
+ if (ssid.len > CY_WCM_MAX_SSID_LEN) {
+ mp_raise_TypeError(MP_ERROR_TEXT("network connect SSID too long"));
+ }
+ memcpy(connect_param.ap_credentials.SSID, ssid.buf, ssid.len);
+
+ // Extract the key, if given.
+ if (args[ARG_key].u_obj != mp_const_none) {
+ mp_buffer_info_t key;
+ mp_get_buffer_raise(args[ARG_key].u_obj, &key, MP_BUFFER_READ);
+ memcpy(connect_param.ap_credentials.password, key.buf, key.len);
+ }
+
+ // Extract the BSSID, if given.
+ if (args[ARG_bssid].u_obj != mp_const_none) {
+ mp_buffer_info_t bssid;
+ mp_get_buffer_raise(args[ARG_bssid].u_obj, &bssid, MP_BUFFER_READ);
+ if (bssid.len != CY_WCM_MAC_ADDR_LEN) {
+ mp_raise_ValueError(MP_ERROR_TEXT("bssid address invalid length"));
+ }
+ memcpy(connect_param.BSSID, bssid.buf, bssid.len);
+ }
+
+ // Let the wcm driver discover the network security
+ connect_param.ap_credentials.security = CY_WCM_SECURITY_UNKNOWN;
+
+ network_ifx_wcm_sta_obj_t *sta_conf = wcm_get_sta_conf_ptr(network_ifx_wcm_wl_sta);
+ uint8_t retries = sta_conf->connect_retries;
+ cy_rslt_t ret = CY_WCM_EVENT_CONNECT_FAILED;
+ do
+ {
+ ret = cy_wcm_connect_ap(&connect_param, &ipaddress);
+ } while (--retries < 0 && ret != CY_RSLT_SUCCESS);
+ wcm_assert_raise("network sta connect error (with code: %d)", ret);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(network_ifx_wcm_connect_obj, 1, network_ifx_wcm_connect);
+
+static mp_obj_t network_ifx_wcm_disconnect(mp_obj_t self_in) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+ if (self->itf != CY_WCM_INTERFACE_TYPE_STA) {
+ mp_raise_ValueError(MP_ERROR_TEXT("network STA required"));
+ }
+ uint32_t ret = cy_wcm_disconnect_ap();
+ wcm_assert_raise("network sta disconnect error (with code: %d)", ret);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ifx_wcm_disconnect_obj, network_ifx_wcm_disconnect);
+
+static mp_obj_t network_ifx_wcm_isconnected(mp_obj_t self_in) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+ if (self->itf == CY_WCM_INTERFACE_TYPE_STA) {
+ return mp_obj_new_bool(cy_wcm_is_connected_to_ap());
+ } else if (self->itf == CY_WCM_INTERFACE_TYPE_AP) {
+ /* True if at least one client is connected */
+ bool is_a_sta_connected = false;
+ cy_wcm_mac_t sta[1] = {0};
+ cy_wcm_mac_t not_conn_sta = {0, 0, 0, 0, 0, 0};
+ uint32_t ret = cy_wcm_get_associated_client_list(sta, 1);
+ wcm_assert_raise("network ap isconnected error (with code: %d)", ret);
+ if (memcmp(&sta[0], ¬_conn_sta, CY_WCM_MAC_ADDR_LEN) != 0) {
+ is_a_sta_connected = true;
+ }
+
+ return mp_obj_new_bool(is_a_sta_connected);
+ }
+
+ return mp_const_none;
+}
+
+static MP_DEFINE_CONST_FUN_OBJ_1(network_ifx_wcm_isconnected_obj, network_ifx_wcm_isconnected);
+
+static mp_obj_t network_ifx_wcm_ifconfig(size_t n_args, const mp_obj_t *args) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ if (n_args == 1) {
+ const ip_addr_t *dns = dns_getserver(0);
+ cy_wcm_ip_address_t ip_address;
+ cy_wcm_ip_address_t net_mask_addr;
+ cy_wcm_ip_address_t gateway_addr;
+ cy_rslt_t ret = cy_wcm_get_ip_addr(self->itf, &ip_address);
+ wcm_assert_raise("network ifconfig error (with code: %d)", ret);
+ ret = cy_wcm_get_gateway_ip_address(self->itf, &gateway_addr);
+ wcm_assert_raise("network ifconfig error (with code: %d)", ret);
+ ret = cy_wcm_get_ip_netmask(self->itf, &net_mask_addr);
+ wcm_assert_raise("network ifconfig error (with code: %d)", ret);
+ mp_obj_t tuple[4] = {
+ mp_obj_new_str(ip4addr_ntoa((const ip4_addr_t *)&ip_address.ip.v4), strlen(ip4addr_ntoa((const ip4_addr_t *)&ip_address.ip.v4))),
+ mp_obj_new_str(ip4addr_ntoa((const ip4_addr_t *)&net_mask_addr.ip.v4), strlen(ip4addr_ntoa((const ip4_addr_t *)&net_mask_addr.ip.v4))),
+ mp_obj_new_str(ip4addr_ntoa((const ip4_addr_t *)&gateway_addr.ip.v4), strlen(ip4addr_ntoa((const ip4_addr_t *)&gateway_addr.ip.v4))),
+ netutils_format_ipv4_addr((uint8_t *)dns, NETUTILS_BIG),
+ };
+ return mp_obj_new_tuple(4, tuple);
+ } else {
+ if (self->itf == CY_WCM_INTERFACE_TYPE_AP) {
+ const mp_obj_t *argss = args + 1;
+ mp_obj_t *items;
+ mp_obj_get_array_fixed_n(argss[0], 4, &items);
+ const char *ip_address = mp_obj_str_get_str(items[0]);
+ const char *net_mask_addr = mp_obj_str_get_str(items[1]);
+ const char *gateway_addr = mp_obj_str_get_str(items[2]);
+ cy_wcm_ap_config_t *ap_conf = wcm_get_ap_conf_ptr(network_ifx_wcm_wl_ap);
+ cy_rslt_t ret = cy_wcm_set_ap_ip_setting(&(ap_conf->ip_settings), ip_address, net_mask_addr, gateway_addr, CY_WCM_IP_VER_V4);
+ wcm_assert_raise("network ifconfig error (with code: %d)", ret);
+
+ ip_addr_t dns;
+ netutils_parse_ipv4_addr(items[3], (uint8_t *)&dns, NETUTILS_BIG);
+ dns_setserver(0, &dns);
+
+ restart_ap(ap_conf);
+ } else if (self->itf == CY_WCM_INTERFACE_TYPE_STA) {
+ mp_raise_ValueError(MP_ERROR_TEXT("network access point required"));
+ }
+ }
+
+ return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_ifx_wcm_ifconfig_obj, 1, 2, network_ifx_wcm_ifconfig);
+
+static mp_obj_t network_ifx_wcm_status(size_t n_args, const mp_obj_t *args) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+ // one argument: return status based on query parameter
+ switch (mp_obj_str_get_qstr(args[1])) {
+
+ case MP_QSTR_rssi: {
+ if (self->itf != CY_WCM_INTERFACE_TYPE_STA) {
+ mp_raise_ValueError(MP_ERROR_TEXT("network station required"));
+ }
+ int32_t rssi;
+ uint32_t ret = whd_wifi_get_rssi(whd_ifs[self->itf], &rssi);
+ wcm_assert_raise("network status error (with code: %d)", ret);
+ return mp_obj_new_int(rssi);
+ }
+
+ case MP_QSTR_stations: {
+ if (self->itf != CY_WCM_INTERFACE_TYPE_AP) {
+ mp_raise_ValueError(MP_ERROR_TEXT("network access point required"));
+ }
+
+ cy_wcm_mac_t sta_list[NETWORK_WLAN_MAX_AP_STATIONS];
+ cy_wcm_mac_t not_conn_sta = {0, 0, 0, 0, 0, 0};
+
+ uint32_t ret = cy_wcm_get_associated_client_list(&sta_list[0], NETWORK_WLAN_MAX_AP_STATIONS);
+ wcm_assert_raise("network status error (with code: %d)", ret);
+
+ mp_obj_t list = mp_obj_new_list(0, NULL);
+ for (int i = 0; i < NETWORK_WLAN_MAX_AP_STATIONS; ++i) {
+ if (memcmp(&sta_list[i], ¬_conn_sta, CY_WCM_MAC_ADDR_LEN) != 0) {
+ mp_obj_list_append(list, mp_obj_new_bytes(sta_list[i], CY_WCM_MAC_ADDR_LEN));
+ }
+ }
+ return list;
+ }
+ }
+
+ mp_raise_ValueError(MP_ERROR_TEXT("network status unknown param"));
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_ifx_wcm_status_obj, 1, 2, network_ifx_wcm_status);
+
+
+static mp_obj_t network_ap_get_config_param(cy_wcm_ap_config_t *ap_conf, qstr query_opt) {
+ switch (query_opt) {
+ case MP_QSTR_channel: {
+ return MP_OBJ_NEW_SMALL_INT(ap_conf->channel);
+ }
+
+ case MP_QSTR_ssid:
+ case MP_QSTR_essid: {
+ return mp_obj_new_str((const char *)ap_conf->ap_credentials.SSID, strlen((const char *)ap_conf->ap_credentials.SSID));
+ }
+
+ case MP_QSTR_security: {
+ return MP_OBJ_NEW_SMALL_INT(get_mpy_security_type(ap_conf->ap_credentials.security));
+ }
+
+ /* Only default password is exposed */
+ case MP_QSTR_key:
+ case MP_QSTR_password: {
+ if (strcmp((const char *)ap_conf->ap_credentials.password, NETWORK_WLAN_DEFAULT_PASSWORD) == 0) {
+ return mp_obj_new_str((const char *)NETWORK_WLAN_DEFAULT_PASSWORD, strlen((const char *)NETWORK_WLAN_DEFAULT_PASSWORD));
+ } else {
+ mp_raise_ValueError(MP_ERROR_TEXT("network conf password only queryable for default password"));
+ }
+ break;
+ }
+
+ case MP_QSTR_mac: {
+ cy_wcm_mac_t mac;
+ uint32_t ret = cy_wcm_get_mac_addr(CY_WCM_INTERFACE_TYPE_AP, &mac);
+ wcm_assert_raise("network config mac (code: %d)", ret);
+
+ return mp_obj_new_bytes(mac, 6);
+ }
+
+ case MP_QSTR_hostname: {
+ mp_raise_ValueError(MP_ERROR_TEXT("deprecated. use network.hostname() instead"));
+ break;
+ }
+
+ default:
+ mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+ }
+}
+
+static mp_obj_t network_sta_get_config_param(network_ifx_wcm_sta_obj_t *sta_conf, qstr query_opt) {
+ switch (query_opt) {
+ case MP_QSTR_channel: {
+ cy_wcm_associated_ap_info_t ap_info;
+ uint32_t ret = cy_wcm_get_associated_ap_info(&ap_info);
+ wcm_assert_raise("network config error (with code: %d)", ret);
+ return MP_OBJ_NEW_SMALL_INT(ap_info.channel);
+ }
+
+ case MP_QSTR_mac: {
+ cy_wcm_mac_t mac;
+ uint32_t ret = cy_wcm_get_mac_addr(CY_WCM_INTERFACE_TYPE_STA, &mac);
+ wcm_assert_raise("network config mac (code: %d)", ret);
+ return mp_obj_new_bytes(mac, 6);
+ }
+
+ case MP_QSTR_ssid:
+ case MP_QSTR_essid: {
+ cy_wcm_associated_ap_info_t ap_info;
+ uint32_t ret = cy_wcm_get_associated_ap_info(&ap_info);
+ wcm_assert_raise("network config error (with code: %d)", ret);
+ return mp_obj_new_str((const char *)ap_info.SSID, strlen((const char *)ap_info.SSID));
+ }
+
+ case MP_QSTR_security: {
+ cy_wcm_associated_ap_info_t ap_info;
+ uint32_t ret = cy_wcm_get_associated_ap_info(&ap_info);
+ wcm_assert_raise("network config error (with code: %d)", ret);
+ return MP_OBJ_NEW_SMALL_INT(get_mpy_security_type(ap_info.security));
+ }
+
+ case MP_QSTR_password:
+ case MP_QSTR_key: {
+ mp_raise_ValueError(MP_ERROR_TEXT("network access point required"));
+ break;
+ }
+
+ case MP_QSTR_hostname: {
+ mp_raise_ValueError(MP_ERROR_TEXT("deprecated. use network.hostname() instead"));
+ break;
+ }
+
+ default:
+ mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+ }
+}
+
+cy_wcm_security_t get_wm_security_type(mp_obj_t mpy_sec) {
+ switch (mp_obj_get_int(mpy_sec))
+ {
+ case NET_IFX_WCM_SEC_OPEN:
+ return CY_WCM_SECURITY_OPEN;
+
+ case NET_IFX_WCM_SEC_WPA:
+ return CY_WCM_SECURITY_WPA_MIXED_PSK;
+
+ case NET_IFX_WCM_SEC_WPA2:
+ return CY_WCM_SECURITY_WPA2_MIXED_PSK;
+
+ case NET_IFX_WCM_SEC_WPA3:
+ return CY_WCM_SECURITY_WPA3_SAE;
+
+ case NET_IFX_WCM_SEC_WPA_WPA2:
+ return CY_WCM_SECURITY_WPA2_WPA_MIXED_PSK;
+
+ default:
+ return CY_WCM_SECURITY_UNKNOWN;
+ }
+}
+
+static void network_ap_set_config_param(cy_wcm_ap_config_t *ap_conf, qstr opt, mp_obj_t opt_value, bool hold) {
+
+ static bool required_ap_restart = false;
+
+ switch (opt) {
+ case MP_QSTR_channel: {
+ ap_conf->channel = mp_obj_get_int(opt_value);
+ required_ap_restart = true;
+ break;
+ }
+
+ case MP_QSTR_ssid:
+ case MP_QSTR_essid: {
+ size_t len;
+ const char *ssid_str = mp_obj_str_get_data(opt_value, &len);
+ memset(ap_conf->ap_credentials.SSID, 0, CY_WCM_MAX_SSID_LEN + 1);
+ memcpy(ap_conf->ap_credentials.SSID, ssid_str, len);
+ required_ap_restart = true;
+ break;
+ }
+
+ case MP_QSTR_security: {
+ cy_wcm_security_t wcm_sec = get_wm_security_type(opt_value);
+ ap_conf->ap_credentials.security = wcm_sec;
+ required_ap_restart = true;
+ break;
+ }
+
+ case MP_QSTR_key:
+ case MP_QSTR_password: {
+ size_t len;
+ const char *pass_str = mp_obj_str_get_data(opt_value, &len);
+ memset(ap_conf->ap_credentials.password, 0, CY_WCM_MAX_PASSPHRASE_LEN + 1);
+ memcpy(ap_conf->ap_credentials.password, pass_str, len);
+ break;
+ }
+
+ case MP_QSTR_hostname: {
+ mp_raise_ValueError(MP_ERROR_TEXT("deprecated. use network.hostname() instead"));
+ break;
+ }
+
+ default:
+ mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+ }
+
+ if (required_ap_restart && !hold) {
+ restart_ap(ap_conf);
+ required_ap_restart = false;
+ }
+}
+
+static void network_sta_set_config_param(network_ifx_wcm_sta_obj_t *sta_conf, qstr opt, mp_obj_t opt_value) {
+ switch (opt) {
+ case MP_QSTR_channel:
+ case MP_QSTR_key:
+ case MP_QSTR_password:
+ case MP_QSTR_ssid:
+ case MP_QSTR_essid: {
+ mp_raise_ValueError(MP_ERROR_TEXT("network access point required"));
+ break;
+ }
+
+ case MP_QSTR_hostname: {
+ mp_raise_ValueError(MP_ERROR_TEXT("deprecated. use network.hostname() instead"));
+ break;
+ }
+
+ default:
+ mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+ }
+}
+
+static mp_obj_t network_ifx_wcm_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+ network_ifx_wcm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+ if (kwargs->used == 0) {
+ // Get config value
+ if (n_args != 2) {
+ mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
+ }
+
+ if (self->itf == CY_WCM_INTERFACE_TYPE_AP) {
+ cy_wcm_ap_config_t *ap_conf = wcm_get_ap_conf_ptr(network_ifx_wcm_wl_ap);
+ return network_ap_get_config_param(ap_conf, mp_obj_str_get_qstr(args[1]));
+ } else if (self->itf == CY_WCM_INTERFACE_TYPE_STA) {
+ network_ifx_wcm_sta_obj_t *sta_conf = wcm_get_sta_conf_ptr(network_ifx_wcm_wl_sta);
+ return network_sta_get_config_param(sta_conf, mp_obj_str_get_qstr(args[1]));
+ }
+ } else {
+ // Set config value(s)
+ if (n_args != 1) {
+ mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
+ }
+ size_t kwargs_num = kwargs->alloc;
+ for (size_t i = 0; i < kwargs->alloc; ++i) {
+ if (MP_MAP_SLOT_IS_FILLED(kwargs, i)) {
+ mp_map_elem_t *e = &kwargs->table[i];
+
+ if (self->itf == CY_WCM_INTERFACE_TYPE_AP) {
+ bool hold_config = true;
+ if (i == kwargs_num - 1) {
+ hold_config = false;
+ }
+ cy_wcm_ap_config_t *ap_conf = wcm_get_ap_conf_ptr(network_ifx_wcm_wl_ap);
+ network_ap_set_config_param(ap_conf, mp_obj_str_get_qstr(e->key), e->value, hold_config);
+ } else if (self->itf == CY_WCM_INTERFACE_TYPE_STA) {
+ network_ifx_wcm_sta_obj_t *sta_conf = wcm_get_sta_conf_ptr(network_ifx_wcm_wl_sta);
+ network_sta_set_config_param(sta_conf, mp_obj_str_get_qstr(e->key), e->value);
+ }
+ }
+ }
+ }
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(network_ifx_wcm_config_obj, 1, network_ifx_wcm_config);
+
+/*******************************************************************************/
+// class bindings
+
+static const mp_rom_map_elem_t network_ifx_wcm_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&network_ifx_wcm_deinit_obj) }, // shall this be part of the module ??
+ { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&network_ifx_wcm_active_obj) },
+ { MP_ROM_QSTR(MP_QSTR_scan), MP_ROM_PTR(&network_ifx_wcm_scan_obj) },
+ { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&network_ifx_wcm_connect_obj) },
+ { MP_ROM_QSTR(MP_QSTR_disconnect), MP_ROM_PTR(&network_ifx_wcm_disconnect_obj) },
+ { MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&network_ifx_wcm_isconnected_obj) },
+ { MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&network_ifx_wcm_ifconfig_obj) },
+ { MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&network_ifx_wcm_status_obj) },
+ { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&network_ifx_wcm_config_obj) },
+
+ // Network WCM constants
+ // Security modes
+ { MP_ROM_QSTR(MP_QSTR_OPEN), MP_ROM_INT(NET_IFX_WCM_SEC_OPEN) },
+ { MP_ROM_QSTR(MP_QSTR_WEP), MP_ROM_INT(NET_IFX_WCM_SEC_WEP) },
+ { MP_ROM_QSTR(MP_QSTR_WPA), MP_ROM_INT(NET_IFX_WCM_SEC_WPA) },
+ { MP_ROM_QSTR(MP_QSTR_WPA2), MP_ROM_INT(NET_IFX_WCM_SEC_WPA2) },
+ { MP_ROM_QSTR(MP_QSTR_WPA3), MP_ROM_INT(NET_IFX_WCM_SEC_WPA3) },
+ { MP_ROM_QSTR(MP_QSTR_WPA2_WPA_PSK), MP_ROM_INT(NET_IFX_WCM_SEC_WPA_WPA2) },
+ { MP_ROM_QSTR(MP_QSTR_SEC_UNKNOWN), MP_ROM_INT(NET_IFX_WCM_SEC_UNKNOWN) },
+};
+static MP_DEFINE_CONST_DICT(network_ifx_wcm_locals_dict, network_ifx_wcm_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ mp_network_ifx_wcm_type,
+ MP_QSTR_IFX_WCM,
+ MP_TYPE_FLAG_NONE,
+ make_new, network_ifx_wcm_make_new,
+ print, network_ifx_wcm_print,
+ locals_dict, &network_ifx_wcm_locals_dict
+ );
+
+#endif // MICROPY_PY_NETWORK_IFX_WCM
diff --git a/ports/psoc6/network_ifx_wcm.h b/ports/psoc6/network_ifx_wcm.h
new file mode 100644
index 0000000000000..b7fbbe5511f45
--- /dev/null
+++ b/ports/psoc6/network_ifx_wcm.h
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019-2023 Damien P. George
+ * Copyright (c) 2023 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_EXTMOD_NETWORK_IFX_WCM_H
+#define MICROPY_INCLUDED_EXTMOD_NETWORK_IFX_WCM_H
+
+void network_init(void);
+void network_deinit(void);
+
+#endif // MICROPY_INCLUDED_EXTMOD_NETWORK_IFX_WCM_H
diff --git a/ports/psoc6/psoc6_fatfs.c b/ports/psoc6/psoc6_fatfs.c
new file mode 100644
index 0000000000000..3a1030b83b8d2
--- /dev/null
+++ b/ports/psoc6/psoc6_fatfs.c
@@ -0,0 +1,54 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+
+
+// micropython includes
+#include "lib/oofatfs/ff.h"
+#include "py/runtime.h"
+
+
+// MTB includes
+#include "cyhal.h"
+
+
+// object defined in main
+extern cyhal_rtc_t psoc6_rtc;
+
+
+MP_WEAK DWORD get_fattime(void) {
+ struct tm current_date_time = {0};
+ cy_rslt_t result = cyhal_rtc_read(&psoc6_rtc, ¤t_date_time);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mp_raise_ValueError(MP_ERROR_TEXT("cyhal_rtc_read failed !"));
+ }
+
+ return ((current_date_time.tm_year - 1980) << 25) | ((current_date_time.tm_mon) << 21) | ((current_date_time.tm_mday) << 16) | ((current_date_time.tm_hour) << 11) | ((current_date_time.tm_min) << 5) | (current_date_time.tm_sec / 2);
+}
diff --git a/ports/psoc6/psoc6_flash.c b/ports/psoc6/psoc6_flash.c
new file mode 100644
index 0000000000000..552e44628e035
--- /dev/null
+++ b/ports/psoc6/psoc6_flash.c
@@ -0,0 +1,282 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020-2021 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+
+
+// micropython includes
+#include "py/runtime.h"
+#include "extmod/vfs.h"
+#include "modpsoc6.h"
+#include "mplogger.h"
+#include "mphalport.h"
+
+
+// MTB includes
+#include "cyhal.h"
+
+#if defined(CY8C624ABZI_S2D44)
+#define DEVICE_FLASH_SIZE (0x00200000) // 2MB
+#define DEVICE_FLASH_BASE_ADDRESS (0x101A0000) // Where is this value coming from??
+
+#elif defined(CYBLE_416045_02_device)
+#define DEVICE_FLASH_SIZE (0x00100000) // 1MB
+#define DEVICE_FLASH_BASE_ADDRESS (0x100E0000) // Where is this value coming from??
+
+#else
+#error "MCU not supported."
+#endif
+
+
+#define FLASH_BASE_TRUE (0x10000000)
+
+#define FLASH_BASE DEVICE_FLASH_BASE_ADDRESS
+#define FLASH_SIZE (DEVICE_FLASH_SIZE - (FLASH_BASE - FLASH_BASE_TRUE))
+
+#define FLASH_SECTOR_SIZE (0x200)
+#define BLOCK_SIZE_BYTES (FLASH_SECTOR_SIZE)
+
+#ifndef MICROPY_HW_FLASH_STORAGE_BYTES
+#define MICROPY_HW_FLASH_STORAGE_BYTES (FLASH_SIZE)
+#endif
+static_assert(MICROPY_HW_FLASH_STORAGE_BYTES % 4096 == 0, "Flash storage size must be a multiple of 4K");
+
+#ifndef MICROPY_HW_FLASH_STORAGE_BASE
+#define MICROPY_HW_FLASH_STORAGE_BASE (FLASH_BASE)
+#endif
+
+
+typedef struct _psoc6_flash_obj_t {
+ mp_obj_base_t base;
+ uint32_t flash_base;
+ uint32_t flash_size;
+} psoc6_flash_obj_t;
+
+static psoc6_flash_obj_t psoc6_flash_obj = {
+ .base = { &psoc6_flash_type },
+ .flash_base = FLASH_BASE,
+ .flash_size = FLASH_SIZE,
+};
+
+cyhal_flash_t cyhal_flash_obj;
+cyhal_flash_info_t flash_info;
+
+// Helper function to get internal flash configurations
+void get_flash_info(void) {
+ mplogger_print("\nRetrieving internal flash info...\n");
+ cyhal_flash_get_info(&cyhal_flash_obj, &flash_info);
+ /* Wait for 100ms for the flash write to complete */
+ uint32_t timeout = 100;
+ /* Wait for the command to finish execution */
+ while ((true != cyhal_flash_is_operation_complete(&cyhal_flash_obj)) && (0 < timeout)) {
+ timeout--;
+ cyhal_system_delay_ms(1); /* delay one millisecond each iteration */
+ }
+ uint32_t total_flash_size = 0;
+ uint32_t page_size = 0;
+ if (0 != timeout) {
+ for (int index = 0; index < flash_info.block_count; index++)
+ {
+ const cyhal_flash_block_info_t *block_info = flash_info.blocks;
+ total_flash_size += block_info->size;
+ page_size = block_info->page_size;
+ }
+ }
+
+ mplogger_print("\nTotal flash size (MB): %ld\n", total_flash_size / (1024 * 1024));
+ mplogger_print("\nTotal no. of blocks: %d\n", flash_info.block_count);
+ mplogger_print("\nPage size (bytes): %ld\n", page_size);
+}
+
+static mp_obj_t psoc6_flash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ mplogger_print("\nFlash constructor invoked\n");
+ #if MICROPY_LOGGER_DEBUG
+ get_flash_info();
+ #endif
+
+ cy_rslt_t result = CY_RSLT_SUCCESS;
+
+ result = cyhal_flash_init(&cyhal_flash_obj);
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_flash_make_new() failed while initializing flash with error code : %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("psoc6_flash_make_new() - QSPI flash init failed !\n"));
+ }
+
+ // Parse arguments
+ enum { ARG_start, ARG_len };
+
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_start, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_len, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ };
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ if (args[ARG_start].u_int == -1 && args[ARG_len].u_int == -1) {
+ // Default singleton object that accesses entire flash
+ return MP_OBJ_FROM_PTR(&psoc6_flash_obj);
+ }
+
+ psoc6_flash_obj_t *self = mp_obj_malloc(psoc6_flash_obj_t, &psoc6_flash_type);
+
+ mp_int_t start = args[ARG_start].u_int;
+
+ if (start == -1) {
+ start = 0;
+ } else if (!(0 <= start && start < MICROPY_HW_FLASH_STORAGE_BYTES && start % BLOCK_SIZE_BYTES == 0)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Invalid 'start' value specified for psoc6_flash_make_new !\n"));
+ }
+
+ mp_int_t len = args[ARG_len].u_int;
+
+ if (len == -1) {
+ len = MICROPY_HW_FLASH_STORAGE_BYTES - start;
+ } else if (!(0 < len && start + len <= MICROPY_HW_FLASH_STORAGE_BYTES && len % BLOCK_SIZE_BYTES == 0)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Invalid 'len' value specified for psoc6_flash_make_new !\n"));
+ }
+
+ self->flash_base = MICROPY_HW_FLASH_STORAGE_BASE + start;
+ self->flash_size = len;
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t psoc6_flash_readblocks(size_t n_args, const mp_obj_t *args) {
+ mplogger_print("\nFlash readblocks called\n");
+
+ psoc6_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ uint32_t offset = mp_obj_get_int(args[1]) * BLOCK_SIZE_BYTES;
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+
+ if (n_args == 4) {
+ offset += mp_obj_get_int(args[3]);
+ }
+
+ cy_rslt_t result = cyhal_flash_read(&cyhal_flash_obj, self->flash_base + offset, bufinfo.buf, bufinfo.len);
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_flash_readblocks() failed while reading the flash with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_flash_readblocks() - Flash Read failed !"));
+ }
+
+ // TODO: or simply do it like this ?
+ // memcpy(bufinfo.buf, (void *)(self->flash_base + offset), bufinfo.len);
+
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(psoc6_flash_readblocks_obj, 3, 4, psoc6_flash_readblocks);
+
+static mp_obj_t psoc6_flash_writeblocks(size_t n_args, const mp_obj_t *args) {
+ mplogger_print("\nFlash writeblocks called\n");
+ psoc6_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ uint32_t offset = mp_obj_get_int(args[1]) * BLOCK_SIZE_BYTES;
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+
+ if (n_args == 3) {
+ uint32_t numSectors = bufinfo.len / FLASH_SECTOR_SIZE;
+
+ for (uint32_t i = 0; i <= numSectors; ++i) {
+ cy_rslt_t result = cyhal_flash_erase(&cyhal_flash_obj, self->flash_base + offset + i * FLASH_SECTOR_SIZE);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("\npsoc6_flash_writeblocks() failed while erasing the flash with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_flash_writeblocks() - Flash Erase failed !"));
+ }
+ }
+ } else {
+ offset += mp_obj_get_int(args[3]);
+ }
+
+
+ // Flash erase/program must run in an atomic section.
+ mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+
+ cy_rslt_t result = cyhal_flash_write(&cyhal_flash_obj, self->flash_base + offset, bufinfo.buf);
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_flash_writeblocks() failed while writing with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_flash_writeblocks() - Flash Write failed!"));
+ }
+
+ MICROPY_END_ATOMIC_SECTION(atomic_state);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(psoc6_flash_writeblocks_obj, 3, 4, psoc6_flash_writeblocks);
+
+static mp_obj_t psoc6_flash_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+ mplogger_print("Flash ioctrl called\n");
+ psoc6_flash_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_int_t cmd = mp_obj_get_int(cmd_in);
+
+ switch (cmd) {
+ case MP_BLOCKDEV_IOCTL_INIT:
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_DEINIT:
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_SYNC:
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+ return MP_OBJ_NEW_SMALL_INT(self->flash_size / BLOCK_SIZE_BYTES);
+ case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+ return MP_OBJ_NEW_SMALL_INT(BLOCK_SIZE_BYTES);
+ case MP_BLOCKDEV_IOCTL_BLOCK_ERASE: {
+ uint32_t offset = mp_obj_get_int(arg_in) * BLOCK_SIZE_BYTES;
+ // Flash erase/program must run in an atomic section.
+ mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+ cy_rslt_t result = cyhal_flash_erase(&cyhal_flash_obj, self->flash_base + offset);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_flash_ioctl() failed while erasing block with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_flash_ioctl() - Flash erase failed !"));
+ }
+
+ MICROPY_END_ATOMIC_SECTION(atomic_state);
+ return MP_OBJ_NEW_SMALL_INT(0);
+ }
+ default:
+ return mp_const_none;
+ }
+}
+static MP_DEFINE_CONST_FUN_OBJ_3(psoc6_flash_ioctl_obj, psoc6_flash_ioctl);
+
+static const mp_rom_map_elem_t psoc6_flash_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&psoc6_flash_readblocks_obj) },
+ { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&psoc6_flash_writeblocks_obj) },
+ { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&psoc6_flash_ioctl_obj) },
+};
+static MP_DEFINE_CONST_DICT(psoc6_flash_locals_dict, psoc6_flash_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ psoc6_flash_type,
+ MP_QSTR_Flash,
+ MP_TYPE_FLAG_NONE,
+ make_new, psoc6_flash_make_new,
+ locals_dict, &psoc6_flash_locals_dict
+ );
diff --git a/ports/psoc6/psoc6_qspi_flash.c b/ports/psoc6/psoc6_qspi_flash.c
new file mode 100644
index 0000000000000..337879deec651
--- /dev/null
+++ b/ports/psoc6/psoc6_qspi_flash.c
@@ -0,0 +1,266 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020-2021 Damien P. George
+ * Copyright (c) 2022-2024 Infineon Technologies AG
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// std includes
+#include
+#include
+
+// micropython includes
+#include "py/runtime.h"
+#include "extmod/vfs.h"
+#include "modpsoc6.h"
+#include "mplogger.h"
+
+// MTB includes
+#include "cyhal.h"
+#include "cy_pdl.h"
+#include "cybsp.h"
+#include "cy_serial_flash_qspi.h"
+#include "cycfg_qspi_memslot.h"
+#include "mphalport.h"
+
+
+#ifndef MICROPY_HW_FLASH_STORAGE_BYTES
+#define MICROPY_HW_FLASH_STORAGE_BYTES (EXT_FLASH_SIZE)
+#endif
+static_assert(MICROPY_HW_FLASH_STORAGE_BYTES % 4096 == 0, "Flash storage size must be a multiple of 4K");
+
+#ifndef MICROPY_HW_FLASH_STORAGE_BASE
+#define MICROPY_HW_FLASH_STORAGE_BASE (EXT_FLASH_BASE)
+#endif
+
+// CY Macros
+#define MEM_SLOT_NUM (0u) /* Slot number of the memory to use - For CYPROTO 062 4343W there is one slave slot for QSPI NOR FLASH CHIP*/
+#define QSPI_BUS_FREQUENCY_HZ (50000000lu) /* Running freq of qspi bus = 50 MHz */
+
+// flag to set of spi flash is init'd
+uint8_t qspi_flash_init = 0;
+
+typedef struct _psoc6_qspi_flash_obj_t {
+ mp_obj_base_t base;
+ uint32_t flash_base;
+ uint32_t flash_size;
+} psoc6_qspi_flash_obj_t;
+
+static psoc6_qspi_flash_obj_t psoc6_qspi_flash_obj = {
+ .base = { &psoc6_qspi_flash_type },
+ .flash_base = EXT_FLASH_BASE,
+ .flash_size = EXT_FLASH_SIZE,
+};
+
+
+// function to erase the entire flash
+void cy_erase_entire_flash(void) {
+ mp_printf(&mp_plat_print, "\nErasing entire flash... might take a while\n");
+ cy_serial_flash_qspi_erase(0, cy_serial_flash_qspi_get_size());
+ mp_printf(&mp_plat_print, "\nDone\n");
+}
+
+// Helper function to get external flash configurations
+void get_ext_flash_info(void) {
+ mplogger_print("\nRetrieving external flash info...\n");
+ mplogger_print("\nTotal flash size (MB): %d\n", cy_serial_flash_qspi_get_size() / (1024 * 1024));
+ mplogger_print("\nSize of erase sector (bytes): %d\n", cy_serial_flash_qspi_get_erase_size(0x00) / (1024));
+ mplogger_print("\nPage size (bytes): %d\n", cy_serial_flash_qspi_get_prog_size(0x00));
+}
+
+static mp_obj_t psoc6_qspi_flash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+ mplogger_print("\nQSPI flash constructor invoked\n");
+ #if MICROPY_LOGGER_DEBUG
+ get_ext_flash_info();
+ #endif
+
+ cy_rslt_t result = CY_RSLT_SUCCESS;
+
+ if (!qspi_flash_init) {
+ result = cy_serial_flash_qspi_init(smifMemConfigs[MEM_SLOT_NUM], CYBSP_QSPI_D0, CYBSP_QSPI_D1,
+ CYBSP_QSPI_D2, CYBSP_QSPI_D3, NC, NC, NC, NC, CYBSP_QSPI_SCK,
+ CYBSP_QSPI_SS, QSPI_BUS_FREQUENCY_HZ);
+ qspi_flash_init = 1;
+ }
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_qspi_flash_make_new() failed while initializing flash with error code : %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_msg(&mp_type_Exception, MP_ERROR_TEXT("psoc6_qspi_flash_make_new() - QSPI flash init failed !\n"));
+ }
+
+ // Parse arguments
+ enum { ARG_start, ARG_len };
+
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_start, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ { MP_QSTR_len, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+ };
+
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+ if (args[ARG_start].u_int == -1 && args[ARG_len].u_int == -1) {
+ // Default singleton object that accesses entire flash
+ return MP_OBJ_FROM_PTR(&psoc6_qspi_flash_obj);
+ }
+
+ psoc6_qspi_flash_obj_t *self = mp_obj_malloc(psoc6_qspi_flash_obj_t, &psoc6_qspi_flash_type);
+
+ mp_int_t start = args[ARG_start].u_int;
+
+ if (start == -1) {
+ start = 0;
+ } else if (!(0 <= start && start < MICROPY_HW_FLASH_STORAGE_BYTES && start % EXT_FLASH_BLOCK_SIZE_BYTES == 0)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Invalid 'start' value specified for psoc6_flash_make_new !\n"));
+ }
+
+ mp_int_t len = args[ARG_len].u_int;
+
+ if (len == -1) {
+ len = MICROPY_HW_FLASH_STORAGE_BYTES - start;
+ } else if (!(0 < len && start + len <= MICROPY_HW_FLASH_STORAGE_BYTES && len % EXT_FLASH_BLOCK_SIZE_BYTES == 0)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("Invalid 'len' value specified for psoc6_flash_make_new !\n"));
+ }
+
+ self->flash_base = MICROPY_HW_FLASH_STORAGE_BASE + start;
+ self->flash_size = len;
+
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t psoc6_qspi_flash_readblocks(size_t n_args, const mp_obj_t *args) {
+ mplogger_print("\nQSPI flash readblocks called\n");
+
+ psoc6_qspi_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ uint32_t offset = mp_obj_get_int(args[1]) * EXT_FLASH_BLOCK_SIZE_BYTES;
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+
+ if (n_args == 4) {
+ offset += mp_obj_get_int(args[3]);
+ }
+
+ mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+ cy_rslt_t result = cy_serial_flash_qspi_read(self->flash_base + offset, bufinfo.len, bufinfo.buf);
+
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_qspi_flash_readblocks() failed while reading the flash with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_qspi_flash_readblocks() - QSPI Flash Read failed !"));
+ }
+ MICROPY_END_ATOMIC_SECTION(atomic_state);
+ ;
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(psoc6_qspi_flash_readblocks_obj, 3, 4, psoc6_qspi_flash_readblocks);
+
+static mp_obj_t psoc6_qspi_flash_writeblocks(size_t n_args, const mp_obj_t *args) {
+ mplogger_print("\nQSPI flash writeblocks called\n");
+ psoc6_qspi_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+ uint32_t offset = mp_obj_get_int(args[1]) * EXT_FLASH_BLOCK_SIZE_BYTES;
+ mp_buffer_info_t bufinfo;
+ mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+
+ if (n_args == 3) {
+ uint32_t numSectors = bufinfo.len / EXT_FLASH_SECTOR_SIZE;
+
+ for (uint32_t i = 0; i <= numSectors; ++i) {
+ cy_rslt_t result = cy_serial_flash_qspi_erase(self->flash_base + offset + i * EXT_FLASH_SECTOR_SIZE, cy_serial_flash_qspi_get_erase_size(self->flash_base + offset + i * EXT_FLASH_SECTOR_SIZE));
+ // the cy_serial_flash_qspi_get_erase_size() function call is necessary to keep the erase at sector boundary, else it throws errors.
+
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("\npsoc6_qspi_flash_writeblocks() failed while erasing the flash with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_qspi_flash_writeblocks() - QSPI flash Erase failed !"));
+ }
+ }
+ } else {
+ offset += mp_obj_get_int(args[3]);
+ }
+
+ mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+
+ cy_rslt_t result = cy_serial_flash_qspi_write(self->flash_base + offset, bufinfo.len, bufinfo.buf);
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_qspi_flash_writeblocks() failed while writing with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_qspi_flash_writeblocks() - QSPI Flash Write failed!"));
+ }
+
+ MICROPY_END_ATOMIC_SECTION(atomic_state);
+ return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(psoc6_qspi_flash_writeblocks_obj, 3, 4, psoc6_qspi_flash_writeblocks);
+
+static mp_obj_t psoc6_qspi_flash_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+ mplogger_print("QSPI flash ioctrl called\n");
+ psoc6_qspi_flash_obj_t *self = MP_OBJ_TO_PTR(self_in);
+ mp_int_t cmd = mp_obj_get_int(cmd_in);
+
+ switch (cmd) {
+ case MP_BLOCKDEV_IOCTL_INIT:
+ if (!qspi_flash_init) {
+ /* Initialize the QSPI block */
+ cy_serial_flash_qspi_init(smifMemConfigs[MEM_SLOT_NUM], CYBSP_QSPI_D0, CYBSP_QSPI_D1,
+ CYBSP_QSPI_D2, CYBSP_QSPI_D3, NC, NC, NC, NC, CYBSP_QSPI_SCK,
+ CYBSP_QSPI_SS, QSPI_BUS_FREQUENCY_HZ);
+ qspi_flash_init = 1;
+ }
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_DEINIT:
+ if (qspi_flash_init) {
+ cy_serial_flash_qspi_deinit();
+ }
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_SYNC:
+ return MP_OBJ_NEW_SMALL_INT(0);
+ case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+ return MP_OBJ_NEW_SMALL_INT(self->flash_size / EXT_FLASH_BLOCK_SIZE_BYTES);
+ case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+ return MP_OBJ_NEW_SMALL_INT(EXT_FLASH_BLOCK_SIZE_BYTES);
+ case MP_BLOCKDEV_IOCTL_BLOCK_ERASE: {
+ uint32_t offset = mp_obj_get_int(arg_in) * EXT_FLASH_BLOCK_SIZE_BYTES;
+ cy_rslt_t result = cy_serial_flash_qspi_erase(self->flash_base + offset, cy_serial_flash_qspi_get_erase_size(self->flash_base + offset));
+
+ if (CY_RSLT_SUCCESS != result) {
+ mplogger_print("psoc6_qspi_flash_ioctl() failed while erasing block with error code: %u\n", CY_RSLT_GET_CODE(result));
+ mp_raise_ValueError(MP_ERROR_TEXT("psoc6_qspi_flash_ioctl() - QSPI Flash erase failed !"));
+ }
+ return MP_OBJ_NEW_SMALL_INT(0);
+ }
+ default:
+ return mp_const_none;
+ }
+}
+static MP_DEFINE_CONST_FUN_OBJ_3(psoc6_qspi_flash_ioctl_obj, psoc6_qspi_flash_ioctl);
+
+static const mp_rom_map_elem_t psoc6_qspi_flash_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&psoc6_qspi_flash_readblocks_obj) },
+ { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&psoc6_qspi_flash_writeblocks_obj) },
+ { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&psoc6_qspi_flash_ioctl_obj) },
+};
+static MP_DEFINE_CONST_DICT(psoc6_qspi_flash_locals_dict, psoc6_qspi_flash_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+ psoc6_qspi_flash_type,
+ MP_QSTR_QSPI_Flash,
+ MP_TYPE_FLAG_NONE,
+ make_new, psoc6_qspi_flash_make_new,
+ locals_dict, &psoc6_qspi_flash_locals_dict
+ );
diff --git a/ports/psoc6/qstrdefsport.h b/ports/psoc6/qstrdefsport.h
new file mode 100644
index 0000000000000..17a09fbb64603
--- /dev/null
+++ b/ports/psoc6/qstrdefsport.h
@@ -0,0 +1,5 @@
+// qstrs specific to this port
+// *FORMAT-OFF*
+Q(/)
+Q(/flash)
+Q(/lib)
diff --git a/tests/ports/psoc6/README.md b/tests/ports/psoc6/README.md
new file mode 100644
index 0000000000000..2fe826d836cc5
--- /dev/null
+++ b/tests/ports/psoc6/README.md
@@ -0,0 +1,85 @@
+# PSoC6 Port Tests
+
+The PSoc6 tests are organized in the following way:
+
+```
+psoc6/
+├─ board_ext_hw/ --> Tests require board with extended hardware config
+│ ├─ diagrams/ --> Boards hardware extension diagrams
+│ ├─ multi/ --> Tests require multiple boards instances
+│ ├─ single/ --> Tests require a single board
+├─ board_only_hw/ --> Tests only require the boards (no additional hardware)
+│ ├─ multi/ --> Tests require multiple boards instances
+│ ├─ single/ --> Tests require a single board
+├─ mp_custom/ --> Tests based on mpremote (and not based on the run-test.py utility)
+├─ inputs/ --> Non-test files utilities required as inputs for the tests
+├─ run_psoc6_tests.sh --> Script handling PSoC6 tests
+├─ README
+```
+## Running the tests
+
+In order to run a particular test or group of tests make use of the `run_psoc6_tests.h` script.
+
+Find the available test suites and options by running the help command:
+
+```
+./run_psoc6_tests.sh help
+```
+
+For example, to run the "PWM" tests (default device will be /dev/ttyACM0):
+
+```
+./run_psoc6_tests.sh -t pwm
+```
+
+If you need to specify the serial ports of the devices, for example, in a multiple instances test:
+
+```
+./run_psoc6_tests.sh -t bitstream --dev-test /dev/ttyACM0 --dev-stub /dev/ttyACM3
+```
+
+Or directly running all the tests of test under CI/CD for a given board type:
+
+```
+./run_psoc6_tests.sh --test-suite ci-tests --board CY8CPROTO-062-4343W --hil ifx-mpy-hil
+```
+
+In this case, the hardware device list connected to the hardware in the loop (HIL) needs to be provided.
+
+## Extended Hardware Setup Tests
+
+The tests located in the `board_ext_hw/` implement the validation of hardware peripherals features (GPIO, I2C, SPI, etc.) which require additional or extended hardware configuration to the evaluation boards.
+
+The extended setup is meant to provide the necessary circuitry, electronic system or interface for the tests to be performed. For example, interconnecting some pins (with simple cables) and/or attach some external circuit, device, or discrete electronic components.
+
+### Boards Setup Diagram
+
+Find below the hardware diagrams for each of the supported boards:
+
+#### CY8CPROTO-062-4343W
+
+
+
+#### CY8CPROTO-063-BLE
+
+
+
+#### CY8CKIT-062S2-AI
+
+
+
+### Developing Extended Hardware Setup Tests
+
+The driving principle for designing these tests is to keep a **simple** (as simple as possible), **reproducible** and **scalable** hardware-in-the-loop setup, by aiming for **self-contained** board setups using minimal or no hardware other than the board itself.
+
+Most of the MCU (and boards) provide a given feature and its complementary feature. What do we mean by a feature and its *complementary* feature? Conceptually, many protocols and system topologies are based on a complementary or opposite role interaction: input-output, master-slave, server-client or controller-peripheral, sender-receiver. Its operation is effective when they are interacting together. Thus, the evaluation of one of them is hardly achievable without each other.
+
+In our case, both roles are likely to be available and implementable in a single (or worst case, with a couple of) evaluation board.
+For example, testing a GPIO input API functionality can be done by using a GPIO output API, and physically connecting the 2 ports together with a cable.
+Another example would be to validate an ADC by connecting it to a DAC in the same board. Or connecting an instance of a I2C master to a I2C slave, in the same board, with a few cables and pull-up resistors.
+
+If this is the case, it will often simplify the whole testing hardware infrastructure by removing the need of external hardware devices and complex interfaces. For example, measuring equipment that is not always available, potentially expensive, and harder to reproduce and scale.
+
+Sometimes the *complementary* feature might not be available. In that case, it is worth to evaluate which is the most convenient approach. Let´s imagine we have a master SPI API which could be easily tested with a SPI slave in the same micocontroller. If it is not available it will require to be developed for MicroPython. Sure, it is an effort, but keep in mind that such SPI slave mode is not just a testing utility, but an usable enablement for MicroPython end (primary) users. Besides, how simple, reproducible, scalalable and automatable are the other options?
+
+Yes, also automatable. As the rests of the PSoC6 folder tests, these tests need to be able to **run automatically** under the MicroPython testing suite tools, without the requiring visual inspections and manual checks. That way they can be added to the Continuous Integration testing pipelines, and reassuring quality after every affected or relevant code change.
\ No newline at end of file
diff --git a/tests/ports/psoc6/board_ext_hw/diagrams/cy8ckit-062s2-ai-hil-test-diag.png b/tests/ports/psoc6/board_ext_hw/diagrams/cy8ckit-062s2-ai-hil-test-diag.png
new file mode 100644
index 0000000000000..99b269ab91f5b
Binary files /dev/null and b/tests/ports/psoc6/board_ext_hw/diagrams/cy8ckit-062s2-ai-hil-test-diag.png differ
diff --git a/tests/ports/psoc6/board_ext_hw/diagrams/cy8cproto-062-4343w-hil-test-diag.png b/tests/ports/psoc6/board_ext_hw/diagrams/cy8cproto-062-4343w-hil-test-diag.png
new file mode 100644
index 0000000000000..36b66b4731bff
Binary files /dev/null and b/tests/ports/psoc6/board_ext_hw/diagrams/cy8cproto-062-4343w-hil-test-diag.png differ
diff --git a/tests/ports/psoc6/board_ext_hw/diagrams/cy8cproto-063-ble-hil-test-diag.png b/tests/ports/psoc6/board_ext_hw/diagrams/cy8cproto-063-ble-hil-test-diag.png
new file mode 100644
index 0000000000000..8964d776c4bd8
Binary files /dev/null and b/tests/ports/psoc6/board_ext_hw/diagrams/cy8cproto-063-ble-hil-test-diag.png differ
diff --git a/tests/ports/psoc6/board_ext_hw/multi/bitstream_rx.py b/tests/ports/psoc6/board_ext_hw/multi/bitstream_rx.py
new file mode 100644
index 0000000000000..1d0be851a78a4
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/bitstream_rx.py
@@ -0,0 +1,97 @@
+import os
+import time
+from machine import Pin
+from machine import bitstream
+
+""""
+This script is running together with the bitstream_tx.py test.
+One pin generates a synchronisation signal to inform the transmitter that receiver is ready, and
+another is configured as an input, which is used for receiving the bitstream signals.
+"""
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ bitstream_in_pin_name = "P12_1"
+ rx_ready_signal_pin_name = "P0_4"
+elif "CY8CPROTO-063-BLE" in board:
+ bitstream_in_pin_name = "P5_2"
+ rx_ready_signal_pin_name = "P6_2"
+elif "CY8CKIT-062S2-AI" in board:
+ bitstream_in_pin_name = "P9_6"
+ rx_ready_signal_pin_name = "P9_7"
+
+expected_values = [
+ 8000,
+ 5000,
+ 8000,
+ 5000,
+ 8000,
+ 5000,
+ 8000,
+ 5000,
+ 3000,
+ 1000,
+ 3000,
+ 1000,
+ 3000,
+ 1000,
+ 3000,
+ 1000,
+]
+tolerance = 100
+
+
+def notify_readiness_to_tx():
+ rx_ready_signal_pin = Pin(
+ rx_ready_signal_pin_name, Pin.OUT, value=0
+ ) # signal to inform the transmitter that receiver is read
+ rx_ready_signal_pin.low()
+ # delay
+ for i in range(1000):
+ pass
+ rx_ready_signal_pin.high()
+ rx_ready_signal_pin.deinit()
+
+
+def bitstream_rx_measure():
+ global periods
+ periods = []
+ last_value = 0
+ bitstream_in_pin = Pin(bitstream_in_pin_name, Pin.IN)
+ start_time = time.ticks_us()
+ current_value = 0
+
+ for i in range(17):
+ while current_value == last_value:
+ current_value = bitstream_in_pin.value()
+ current_time = time.ticks_us()
+ time_period = time.ticks_diff(current_time, start_time)
+ last_value = current_value
+ start_time = current_time
+ periods.append(time_period)
+
+ bitstream_in_pin.deinit()
+
+
+def validate_bitstream():
+ for i in range(len(periods) - 1):
+ diff = abs(periods[i + 1] - expected_values[i])
+ if diff <= tolerance:
+ print("true")
+ else:
+ print("false")
+ print(
+ "expected :"
+ + str(expected_values[i])
+ + " period: "
+ + str(periods[i + 1])
+ + " diff: "
+ + str(diff)
+ )
+
+
+print("bitstream rx")
+notify_readiness_to_tx()
+bitstream_rx_measure()
+validate_bitstream()
diff --git a/tests/ports/psoc6/board_ext_hw/multi/bitstream_rx.py.exp b/tests/ports/psoc6/board_ext_hw/multi/bitstream_rx.py.exp
new file mode 100644
index 0000000000000..f2e78d14b2ed1
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/bitstream_rx.py.exp
@@ -0,0 +1,17 @@
+bitstream rx
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
diff --git a/tests/ports/psoc6/board_ext_hw/multi/bitstream_tx.py b/tests/ports/psoc6/board_ext_hw/multi/bitstream_tx.py
new file mode 100755
index 0000000000000..9d8b8207539bb
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/bitstream_tx.py
@@ -0,0 +1,57 @@
+import sys
+import time
+import os
+from machine import Pin
+from machine import bitstream
+
+"""
+This script is running together with the bitstream_rx.py test.
+One pin generates the test bitstream pattern, and another is configured as
+an input, which is used for synchronization with the receiver.
+"""
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ bitstream_pin_name = "P12_1"
+ wait_signal_pin_name = "P13_4"
+elif "CY8CPROTO-063-BLE" in board:
+ bitstream_pin_name = "P5_2"
+ wait_signal_pin_name = "P6_2"
+elif "CY8CKIT-062S2-AI" in board:
+ bitstream_pin_name = "P9_3"
+ wait_signal_pin_name = "P9_7"
+
+signal_received = False
+
+
+def signal_irq(arg):
+ global signal_received
+ signal_received = True
+
+
+def wait_for_rx_ready():
+ global signal_received
+ wait_signal_pin = Pin(wait_signal_pin_name, Pin.IN)
+ wait_signal_pin.irq(handler=signal_irq, trigger=Pin.IRQ_RISING)
+ while not signal_received:
+ pass
+
+ signal_received = False
+ wait_signal_pin.deinit()
+ # print("rx ready")
+
+
+def send_bitstream():
+ timing = [3000000, 1000000, 8000000, 5000000]
+ buf = bytearray([0xF0])
+ bitstream_pin = Pin(bitstream_pin_name, Pin.OUT, value=0)
+ for i in range(2):
+ bitstream(bitstream_pin, 0, timing, buf)
+
+ bitstream_pin.deinit()
+
+
+# print("bitstream tx")
+wait_for_rx_ready()
+send_bitstream()
diff --git a/tests/ports/psoc6/board_ext_hw/multi/i2s_rx.py b/tests/ports/psoc6/board_ext_hw/multi/i2s_rx.py
new file mode 100644
index 0000000000000..8ec87932350c7
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/i2s_rx.py
@@ -0,0 +1,193 @@
+import os
+from machine import I2S, Pin
+import binascii
+import time
+import array
+import struct
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ sck_rx_pin = "P5_4"
+ ws_rx_pin = "P5_5"
+ sd_rx_pin = "P5_6"
+ rx_ready_signal_pin_name = "P13_4"
+elif "CY8CPROTO-063-BLE" in board:
+ # These would be the right pins for this test, but unfortunately
+ # the P5_1 is allocated for the UART serial comm terminal communication.
+ # Thus this tests is not currently possible for this board.
+ # sck_rx_pin = "P5_4"
+ # ws_rx_pin = "P5_5"
+ # sd_rx_pin = "P5_6"
+ print("SKIP")
+ raise SystemExit
+elif "CY8CKIT-062S2-AI" in board:
+ sck_rx_pin = "P9_4"
+ ws_rx_pin = "P9_5"
+ sd_rx_pin = "P9_6"
+ rx_ready_signal_pin_name = "P9_7"
+
+rx_ready_signal_pin = None
+
+
+def rx_ready_signal_init():
+ global rx_ready_signal_pin
+ rx_ready_signal_pin = Pin(rx_ready_signal_pin_name, Pin.OUT, value=0)
+ rx_ready_signal_pin.low()
+
+
+def rx_ready_signal_deinit():
+ global rx_ready_signal_pin
+ rx_ready_signal_pin.deinit()
+
+
+def notify_readiness_to_tx():
+ global rx_ready_signal_pin
+ rx_ready_signal_pin.high()
+ time.sleep(0.5)
+ rx_ready_signal_pin.low()
+
+
+def make_expected_sequence():
+ len = 0xFF
+ expected_frame = bytearray(len)
+ for i in range(len):
+ expected_frame[i] = i
+
+ return expected_frame
+
+
+def find_sublist_in_list(full_list, sublist):
+ for i in range(len(full_list) - len(sublist) - 1):
+ if full_list[i : i + len(sublist)] == sublist:
+ return True
+
+ return False
+
+
+def print_i2s_format(raw_buf, bits):
+ samples_buf = []
+ if bits == 16:
+ bytes_per_sample = 2
+ format = " 0:
+ sample = struct.unpack(format, raw_buf[i * bytes_per_sample : (i + 1) * bytes_per_sample])[
+ 0
+ ]
+ if i % 2 == 0:
+ sample_l = sample
+ else:
+ sample_r = sample
+ # sample_l is available from previous
+ sample_tuple = (hex(sample_l), hex(sample_r))
+ samples_buf.append(sample_tuple)
+
+ num_bytes -= bytes_per_sample
+ i += 1
+
+ print("(Left channel, Right channel)")
+ for s_tuple in samples_buf:
+ print(s_tuple)
+
+
+###############################################################################
+print("1. tx-rx data for all formats, rates and bit resolution")
+
+test_rates = [8000, 16000, 32000, 48000, 22050, 44100]
+test_formats = [I2S.MONO, I2S.STEREO]
+test_bits = [16, 32]
+test_bits_resolution = [8, 12, 16, 20, 32]
+
+rx_ready_signal_init()
+exp_seq = make_expected_sequence()
+
+for _format in test_formats:
+ for _bits in test_bits:
+ for _rate in test_rates:
+ audio_in = I2S(
+ 0,
+ sck=sck_rx_pin,
+ ws=ws_rx_pin,
+ sd=sd_rx_pin,
+ mode=I2S.RX,
+ bits=_bits,
+ format=_format,
+ rate=_rate,
+ ibuf=20000,
+ )
+
+ # Try 3 times to overcome synch mismatches
+ for i in range(3):
+ # Read i2s data
+ rx_buf = bytearray([0] * 2560)
+ num_read = audio_in.readinto(rx_buf)
+
+ # validate data
+ is_seq_received = find_sublist_in_list(rx_buf, exp_seq)
+ if is_seq_received:
+ break
+
+ audio_in.deinit()
+ print(
+ f"data received for format = {_format}, bits = {_bits}, rate = {_rate} : {is_seq_received}"
+ )
+
+ notify_readiness_to_tx()
+ # print_i2s_format(rx_buf, 16)
+
+ # Give some time to the i2s_tx to setup
+ time.sleep(2)
+
+rx_ready_signal_deinit()
+
+###############################################################################
+print("\n2. irq non-blocking read implementation ")
+
+rx_done = False
+
+
+def rx_complete_irq(obj):
+ global rx_done
+ rx_done = True
+
+
+audio_in = I2S(
+ 0,
+ sck=sck_rx_pin,
+ ws=ws_rx_pin,
+ sd=sd_rx_pin,
+ mode=I2S.RX,
+ bits=16,
+ format=I2S.MONO,
+ rate=8000,
+ ibuf=20000,
+)
+
+rx_buf = bytearray([0] * 50)
+audio_in.irq(rx_complete_irq)
+num_read = audio_in.readinto(rx_buf)
+
+while not rx_done:
+ pass
+
+# if we get pass this rx_done flag has been
+# modified by the interrupt
+
+print("rx blocking done")
+audio_in.deinit()
+
+
+###############################################################################
+print("\n3. shift ")
+
+buf = bytearray(b"\xFF\xFF\xFF\xFF")
+I2S.shift(buf=buf, bits=16, shift=3)
+print(binascii.hexlify(buf))
+I2S.shift(buf=buf, bits=16, shift=-3)
+print(binascii.hexlify(buf))
diff --git a/tests/ports/psoc6/board_ext_hw/multi/i2s_rx.py.exp b/tests/ports/psoc6/board_ext_hw/multi/i2s_rx.py.exp
new file mode 100644
index 0000000000000..65a11396d51ea
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/i2s_rx.py.exp
@@ -0,0 +1,41 @@
+1. tx-rx data for all formats, rates and bit resolution
+machine.I2S: PLL0 freq is changed from 48000000 to 98000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 0, bits = 16, rate = 8000 : True
+data received for format = 0, bits = 16, rate = 16000 : True
+data received for format = 0, bits = 16, rate = 32000 : True
+data received for format = 0, bits = 16, rate = 48000 : True
+machine.I2S: PLL0 freq is changed from 98000000 to 90000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 0, bits = 16, rate = 22050 : True
+data received for format = 0, bits = 16, rate = 44100 : True
+machine.I2S: PLL0 freq is changed from 90000000 to 98000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 0, bits = 32, rate = 8000 : True
+data received for format = 0, bits = 32, rate = 16000 : True
+data received for format = 0, bits = 32, rate = 32000 : True
+data received for format = 0, bits = 32, rate = 48000 : True
+machine.I2S: PLL0 freq is changed from 98000000 to 90000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 0, bits = 32, rate = 22050 : True
+data received for format = 0, bits = 32, rate = 44100 : True
+machine.I2S: PLL0 freq is changed from 90000000 to 98000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 1, bits = 16, rate = 8000 : True
+data received for format = 1, bits = 16, rate = 16000 : True
+data received for format = 1, bits = 16, rate = 32000 : True
+data received for format = 1, bits = 16, rate = 48000 : True
+machine.I2S: PLL0 freq is changed from 98000000 to 90000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 1, bits = 16, rate = 22050 : True
+data received for format = 1, bits = 16, rate = 44100 : True
+machine.I2S: PLL0 freq is changed from 90000000 to 98000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 1, bits = 32, rate = 8000 : True
+data received for format = 1, bits = 32, rate = 16000 : True
+data received for format = 1, bits = 32, rate = 32000 : True
+data received for format = 1, bits = 32, rate = 48000 : True
+machine.I2S: PLL0 freq is changed from 98000000 to 90000000. This will affect all resources clock freq sourced by PLL0.
+data received for format = 1, bits = 32, rate = 22050 : True
+data received for format = 1, bits = 32, rate = 44100 : True
+
+2. irq non-blocking read implementation
+machine.I2S: PLL0 freq is changed from 90000000 to 98000000. This will affect all resources clock freq sourced by PLL0.
+rx blocking done
+
+3. shift
+b'f8fff8ff'
+b'ffffffff'
diff --git a/tests/ports/psoc6/board_ext_hw/multi/i2s_tx.py b/tests/ports/psoc6/board_ext_hw/multi/i2s_tx.py
new file mode 100644
index 0000000000000..48a4b526bdcae
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/i2s_tx.py
@@ -0,0 +1,145 @@
+import os
+from machine import I2S, Pin
+import binascii
+import time
+import array
+import struct
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ sck_tx_pin = "P13_1"
+ ws_tx_pin = "P13_2"
+ sd_tx_pin = "P13_3"
+ wait_signal_pin_name = "P0_4"
+elif "CY8CPROTO-063-BLE" in board:
+ # This would be the right pins for this test, but unfortunately
+ # the P5_1 is allocated for the UART serial comm terminal communication.
+ # So this tests is not currently possible for this board.
+ # sck_tx_pin = "P5_1"
+ # ws_tx_pin = "P5_2"
+ # sd_tx_pin = "P5_3"
+ print("SKIP")
+ raise SystemExit
+elif "CY8CKIT-062S2-AI" in board:
+ sck_tx_pin = "P9_1"
+ ws_tx_pin = "P9_2"
+ sd_tx_pin = "P9_3"
+ wait_signal_pin_name = "P9_7"
+
+signal_received = False
+rising_edge_count = 0
+wait_signal_pin = None
+
+
+def signal_irq(arg):
+ global signal_received
+ global rising_edge_count
+ rising_edge_count += 1
+ signal_received = True
+
+
+def wait_signal_init():
+ global wait_signal_pin
+ wait_signal_pin = Pin(wait_signal_pin_name, Pin.IN)
+ wait_signal_pin.irq(handler=signal_irq, trigger=Pin.IRQ_RISING)
+
+
+def wait_signal_deinit():
+ global wait_signal_pin
+ wait_signal_pin.deinit()
+
+
+def is_rx_done():
+ # The second interrupt notifies rx completion
+ global signal_received
+
+ if signal_received:
+ # Clear flag
+ signal_received = False
+ return True
+ else:
+ return False
+
+
+def make_i2s_tx_frame_detect_pattern():
+ max_value = 0x100
+ reps = 10
+ buf = bytearray([0] * (max_value) * reps)
+ for i in range(reps):
+ for j in range(max_value):
+ buf[i * max_value + j] = j
+
+ # for i in range(reps):
+ # print(binascii.hexlify(buf[i * max_value : (i + 1) * max_value]))
+
+ return buf
+
+
+def print_i2s_format(raw_buf, bits):
+ samples_buf = []
+ if bits == 16:
+ bytes_per_sample = 2
+ format = " 0:
+ sample = struct.unpack(format, raw_buf[i * bytes_per_sample : (i + 1) * bytes_per_sample])[
+ 0
+ ]
+ if i % 2 == 0:
+ sample_l = sample
+ else:
+ sample_r = sample
+ # sample_l is available from previous
+ sample_tuple = (hex(sample_l), hex(sample_r))
+ samples_buf.append(sample_tuple)
+
+ num_bytes -= bytes_per_sample
+ i += 1
+
+ print("(Left channel, Right channel)")
+ for s_tuple in samples_buf:
+ print(s_tuple)
+
+
+###############################################################################
+test_rates = [8000, 16000, 32000, 48000, 22050, 44100]
+test_formats = [I2S.MONO, I2S.STEREO]
+test_bits = [16, 32]
+test_bits_resolution = [8, 12, 16, 20, 32]
+
+
+buf = make_i2s_tx_frame_detect_pattern()
+wait_signal_init()
+
+for _format in test_formats:
+ for _bits in test_bits:
+ for _rate in test_rates:
+ audio_out = I2S(
+ 0,
+ sck=sck_tx_pin,
+ ws=ws_tx_pin,
+ sd=sd_tx_pin,
+ mode=I2S.TX,
+ bits=_bits,
+ format=_format,
+ rate=_rate,
+ ibuf=20000,
+ )
+
+ rx_done = False
+
+ while not rx_done:
+ audio_out.write(buf)
+ time.sleep(1)
+ rx_done = is_rx_done()
+
+ print(f"irq : {rising_edge_count}")
+ audio_out.deinit()
+
+wait_signal_deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/multi/spi_master.py b/tests/ports/psoc6/board_ext_hw/multi/spi_master.py
new file mode 100644
index 0000000000000..990a70d11a4d6
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/spi_master.py
@@ -0,0 +1,119 @@
+import binascii
+import time
+import os
+
+try:
+ from machine import Pin, SPI
+except ImportError:
+ print("SKIP")
+ raise SystemExit
+
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ # Allocate pin based on board
+ sck_master_pin = "P6_2"
+ mosi_master_pin = "P6_0"
+ miso_master_pin = "P6_1"
+ ssel_master_pin = "P6_3"
+if "CY8CPROTO-063-BLE" in board:
+ # Allocate pin based on board
+ sck_master_pin = "P9_2"
+ mosi_master_pin = "P9_0"
+ miso_master_pin = "P9_1"
+ ssel_master_pin = "P9_3"
+elif "CY8CKIT-062S2-AI" in board:
+ # Current not supported as
+ # SPI Slave on P9_x pins seems to be not supported
+ sck_master_pin = "P9_2"
+ mosi_master_pin = "P9_0"
+ miso_master_pin = "P9_1"
+ ssel_master_pin = "P9_3"
+ print("SKIP")
+ raise SystemExit
+
+# 0. Construct SPI object
+spi_obj = SPI(
+ baudrate=1000000,
+ polarity=0,
+ phase=0,
+ bits=8,
+ firstbit=SPI.MSB,
+ sck=sck_master_pin,
+ mosi=mosi_master_pin,
+ miso=miso_master_pin,
+)
+cs = Pin(ssel_master_pin, Pin.OUT, value=1)
+
+# 1. write() read() validation
+# - Master: write() a data set to the slave.
+# - Slave: waits and read() data set.
+# - Slave: increase all data set bytes by 1.
+# - Slave: write() the modified data to the master.
+
+tx_buf = b"\x08\x06\x04\x02\x07\x05\x03\x01"
+
+cs.low()
+spi_obj.write(tx_buf)
+cs.high()
+
+time.sleep_ms(500) # ensure slave has replied
+rx_buf = bytearray(8)
+cs.low()
+rx_buf = spi_obj.read(8)
+cs.high()
+
+exp_rx = b"\t\x07\x05\x03\x08\x06\x04\x02"
+print("master write() and read() (tx_buf + 1): ", exp_rx == rx_buf)
+
+# 2. readinto() validation
+# - Slave: increase once again all data set bytes by 1.
+# - Slave: write() the modified data set to the master.
+# - Master: waits and readinto() the modified data set.
+
+time.sleep_ms(500) # ensure slave has replied
+rx_buf = bytearray(8)
+cs.low()
+spi_obj.readinto(rx_buf)
+cs.high()
+
+exp_rx = b"\n\x08\x06\x04\t\x07\x05\x03"
+print("master readinto() (tx_buf + 2):", exp_rx == rx_buf)
+
+# 3. write_readinto() read validation
+# - Slave: increase once again all data set bytes by 1.
+# - Slave: write() the modified data set to the master.
+# - Master: waits and readinto() the data set (written data set is not processed).
+
+time.sleep_ms(200)
+rx_buf = bytearray(8)
+cs.low()
+spi_obj.write_readinto(tx_buf, rx_buf)
+cs.high()
+
+exp_rx = b"\x0b\t\x07\x05\n\x08\x06\x04"
+print("master write_readinto() (tx_buf + 3): ", exp_rx == rx_buf)
+
+# 4. write_readinto() write validation
+# - Master: write_readinto() a data set to the slave (read data is ignored).
+# - Slave: waits and read() data set.
+# - Slave: decreases all data set bytes by 1.
+# - Slave: write() the modified data set to the master.
+# - Master: waits and read() the modified data set.
+
+tx_buf = b"\x01\x02\x03\x04\x05\x06\x07\x08"
+cs.low()
+spi_obj.write_readinto(tx_buf, rx_buf)
+cs.high()
+
+time.sleep_ms(500) # ensure slave has replied
+rx_buf = bytearray(8)
+cs.low()
+rx_buf = spi_obj.read(8)
+cs.high()
+
+exp_rx = b"\x00\x01\x02\x03\x04\x05\x06\x07"
+print("master write_readinto() and read() (tx_buf - 1): ", exp_rx == rx_buf)
+
+# 5. SPI object deinit
+spi_obj.deinit()
+cs.deinit
diff --git a/tests/ports/psoc6/board_ext_hw/multi/spi_master.py.exp b/tests/ports/psoc6/board_ext_hw/multi/spi_master.py.exp
new file mode 100644
index 0000000000000..43f51d5b75679
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/spi_master.py.exp
@@ -0,0 +1,4 @@
+master write() and read() (tx_buf + 1): True
+master readinto() (tx_buf + 2): True
+master write_readinto() (tx_buf + 3): True
+master write_readinto() and read() (tx_buf - 1): True
diff --git a/tests/ports/psoc6/board_ext_hw/multi/spi_slave.py b/tests/ports/psoc6/board_ext_hw/multi/spi_slave.py
new file mode 100644
index 0000000000000..965225571da49
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/multi/spi_slave.py
@@ -0,0 +1,81 @@
+import binascii
+import time
+import os
+
+try:
+ from machine import Pin, SPI, SPISlave
+except ImportError:
+ print("SKIP")
+ raise SystemExit
+
+ # Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ sck_slave_pin = "P6_2"
+ mosi_slave_pin = "P6_0"
+ miso_slave_pin = "P6_1"
+ ssel_slave_pin = "P6_3"
+if "CY8CPROTO-063-BLE" in board:
+ # Allocate pin based on board
+ sck_slave_pin = "P9_2"
+ mosi_slave_pin = "P9_0"
+ miso_slave_pin = "P9_1"
+ ssel_slave_pin = "P9_3"
+elif "CY8CKIT-062S2-AI" in board:
+ # Current not supported as
+ # SPI Slave on P9_x pins seems to be not supported
+ sck_master_pin = "P9_2"
+ mosi_master_pin = "P9_0"
+ miso_master_pin = "P9_1"
+ ssel_master_pin = "P9_3"
+ print("SKIP")
+ raise SystemExit
+
+
+def data_increase_by_one(buf):
+ for i in range(len(buf)):
+ buf[i] += 1
+
+
+def data_decrease_by_one(buf):
+ for i in range(len(buf)):
+ buf[i] -= 1
+
+
+# 0. Construct SPI Slave obj
+spi_obj = SPISlave(
+ baudrate=1000000,
+ polarity=0,
+ phase=0,
+ bits=8,
+ firstbit=SPISlave.MSB,
+ ssel=ssel_slave_pin,
+ sck=sck_slave_pin,
+ mosi=mosi_slave_pin,
+ miso=miso_slave_pin,
+)
+
+# 1. Reply for master write() read() validation
+rx_buf = bytearray(8)
+spi_obj.read(rx_buf)
+
+data_increase_by_one(rx_buf)
+spi_obj.write(rx_buf)
+
+# 2. Reply for master readinto() validation
+data_increase_by_one(rx_buf)
+spi_obj.write(rx_buf)
+
+# 3. Reply for write_readinto() read validation
+data_increase_by_one(rx_buf)
+spi_obj.write(rx_buf)
+
+# 4. Reply write_readinto() write validation
+rx_buf = bytearray(8)
+spi_obj.read(rx_buf)
+
+data_decrease_by_one(rx_buf)
+spi_obj.write(rx_buf)
+
+# 5. SPI Slave object deinit
+spi_obj.deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/single/adc.py b/tests/ports/psoc6/board_ext_hw/single/adc.py
new file mode 100644
index 0000000000000..c30ecface7442
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/adc.py
@@ -0,0 +1,111 @@
+### ADC Functional test
+""" Setup description:
+ Construct a basic voltage divider with 120 ohms each resistor. Supply the ends with 3.3V and GND.
+ Available voltage values are then - 3.3V, ~1.7V, 0V.
+ Pin connections:
+ Voltage Divider circuit On Target Board
+ 3.3V end adc_pin_max
+ Mid point adc_pin_mid
+ GND end adc_pin_gnd
+ *Known issue: When connected to GND, you may not get exact 0V and this may vary board to board.
+"""
+import os
+import time
+from machine import ADC, ADCBlock
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ gnd_tests_skip = False
+ adc_pin_gnd = "P10_4"
+ adc_pin_mid = "P10_3"
+ adc_mid_chan = 3
+ adc_pin_max = "P10_2"
+ adc_wrong_pin_name = "P13_7"
+elif "CY8CPROTO-063-BLE" in board:
+ gnd_tests_skip = False
+ adc_pin_gnd = "P10_2"
+ adc_pin_mid = "P10_3"
+ adc_mid_chan = 3
+ adc_pin_max = "P10_4"
+ adc_wrong_pin_name = "P13_7"
+elif "CY8CKIT-062S2-AI" in board:
+ gnd_tests_skip = True
+ adc_pin_mid = "P10_0"
+ adc_mid_chan = 0
+ adc_pin_max = "P10_1"
+ adc_wrong_pin_name = "P13_7"
+
+# 0.35V
+tolerance_uv = 350000
+
+tolerance_raw = 4000
+
+block = None
+
+
+def validate_adc_uv_value(exp_volt, act_volt):
+ if not (exp_volt - tolerance_uv) < act_volt < (exp_volt + tolerance_uv):
+ print(
+ "Expected voltage - ",
+ exp_volt,
+ "(uV) is approx same as obtained voltage(uV): ",
+ act_volt,
+ )
+
+
+def validate_adc_raw_value(exp_volt, act_volt):
+ if not (exp_volt - tolerance_raw) < act_volt < (exp_volt + tolerance_raw):
+ print(
+ "Expected voltage - ",
+ exp_volt,
+ "(raw) is approx same as obtained voltage(raw): ",
+ act_volt,
+ )
+
+
+# Exception should be raised
+try:
+ adc = ADC(adc_wrong_pin_name)
+except:
+ print("Invalid ADC Pin\n")
+
+block = ADCBlock(0, bits=12)
+# ADCBlock.connect(channel)
+adc1 = block.connect(3)
+block.deinit()
+
+# ADCBlock.connect(source)
+block = ADCBlock(0, bits=12)
+adc1 = block.connect(adc_pin_mid)
+block.deinit()
+
+if not gnd_tests_skip:
+ adc0 = ADC(adc_pin_gnd, sample_ns=1000)
+
+ adc0_value_uv = adc0.read_uv()
+ validate_adc_uv_value(0, adc0_value_uv)
+ adc0_value_raw = adc0.read_u16()
+ validate_adc_raw_value(0, adc0_value_raw)
+
+ adc0.deinit()
+
+# ADCBlock.connect(channel,source)
+block = ADCBlock(0, bits=12)
+adc1 = block.connect(adc_mid_chan, adc_pin_mid)
+
+adc2 = ADC(adc_pin_max, sample_ns=1000)
+
+adc1_value_uv = adc1.read_uv()
+validate_adc_uv_value(1650000, adc1_value_uv)
+adc1_value_raw = adc1.read_u16()
+validate_adc_raw_value(16385, adc1_value_raw)
+
+adc2_value_uv = adc2.read_uv()
+validate_adc_uv_value(3300000, adc2_value_uv)
+adc2_value_raw = adc2.read_u16()
+validate_adc_raw_value(32767, adc2_value_raw)
+
+
+adc1.deinit()
+adc2.deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/single/adc.py.exp b/tests/ports/psoc6/board_ext_hw/single/adc.py.exp
new file mode 100644
index 0000000000000..cba6eb17f247f
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/adc.py.exp
@@ -0,0 +1,2 @@
+Invalid ADC Pin
+
diff --git a/tests/ports/psoc6/board_ext_hw/single/i2c.py b/tests/ports/psoc6/board_ext_hw/single/i2c.py
new file mode 100644
index 0000000000000..83e8123782ba9
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/i2c.py
@@ -0,0 +1,228 @@
+### I2C
+
+from machine import I2C
+from machine import SoftI2C
+from machine import I2CSlave
+import machine
+import binascii
+import time
+import os
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ scl_master_pin = "P10_0"
+ sda_master_pin = "P10_1"
+ scl_master_soft_pin = "P9_5"
+ sda_master_soft_pin = "P9_3"
+ scl_slave_pin = "P9_0"
+ sda_slave_pin = "P9_1"
+elif "CY8CPROTO-063-BLE" in board:
+ scl_master_pin = "P6_4"
+ sda_master_pin = "P6_5"
+ scl_master_soft_pin = "P7_2"
+ sda_master_soft_pin = "P0_5"
+ scl_slave_pin = "P10_0"
+ sda_slave_pin = "P10_1"
+elif "CY8CKIT-062S2-AI" in board:
+ scl_master_pin = "P0_2"
+ sda_master_pin = "P0_3"
+ scl_master_soft_pin = "P9_5"
+ sda_master_soft_pin = "P9_4"
+ scl_slave_pin = "P9_0"
+ sda_slave_pin = "P9_1"
+
+# Test hardware setup
+##############################################
+# I2C SDA and SCL signals from master and slave
+# must be connected together (in the same board)
+# and use pull-up resistors (4.7Kohm) for each line
+
+# 0. Error missing arguments in constructors
+##############################################
+try:
+ i2c = I2C(sda=sda_master_pin, freq=400000)
+except TypeError as e:
+ print(e)
+
+try:
+ i2c = I2C(scl=scl_master_pin, freq=400000)
+except TypeError as e:
+ print(e)
+
+try:
+ i2c = I2CSlave(sda=sda_slave_pin, freq=400000)
+except TypeError as e:
+ print(e)
+
+try:
+ i2c = I2CSlave(scl=scl_slave_pin, freq=400000)
+except TypeError as e:
+ print(e)
+
+try:
+ i2c = I2CSlave(sda=sda_slave_pin, scl=scl_slave_pin, freq=400000)
+except TypeError as e:
+ print(e)
+
+# 1. Construct slave and master instances
+##############################################
+slave_addr = 0x45
+i2c_slave = I2CSlave(scl=scl_slave_pin, sda=sda_slave_pin, addr=slave_addr)
+
+i2c_master = I2C(scl=scl_master_pin, sda=sda_master_pin)
+i2c_soft_master = SoftI2C(scl=scl_master_soft_pin, sda=sda_master_soft_pin)
+
+
+def i2c_tests(i2c_master):
+ global slave_addr, i2c_slave
+
+ # 2. Scan for slaves
+ ##############################################
+ addr_list = i2c_master.scan()
+ addr_in_bus = slave_addr in addr_list
+ print("Found slave with address ", slave_addr, " : ", addr_in_bus)
+
+ # 3. Master to slave write
+ ##############################################
+
+ # writeto()
+ i2c_slave_rcv_buf = bytearray(8)
+ i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+
+ master_write_data = b"\x01\x44\x17\x88\x98\x11\x34\xff"
+ i2c_master.writeto(slave_addr, master_write_data)
+
+ time.sleep_ms(100)
+
+ # print("received buffer : ", binascii.hexlify(i2c_slave_rcv_buf))
+ print("master writeto() and received by slave: ", i2c_slave_rcv_buf == master_write_data)
+
+ # writeto_mem()
+ i2c_slave_rcv_buf = bytearray(4)
+ i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+ master_write_data = b"\x03\x44\x55"
+ i2c_master.writeto_mem(slave_addr, 0x01, master_write_data)
+
+ time.sleep_ms(100)
+
+ print("master writeto_mem() and received by slave: ", i2c_slave_rcv_buf == b"\x01\x03\x44\x55")
+
+ # writevto()
+ i2c_slave_rcv_buf = bytearray(8)
+ i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+
+ master_write_data = [b"\x01\x44\x55\x23", b"\x98\x03\x44\xEE"]
+ i2c_master.writevto(slave_addr, master_write_data)
+
+ time.sleep_ms(100)
+
+ print(
+ "master writevto() and received by slave: ",
+ i2c_slave_rcv_buf == b"\x01\x44\x55\x23\x98\x03\x44\xEE",
+ )
+
+ # 4. Master to slave read
+ ##############################################
+ i2c_slave_tx_buf = bytearray([0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x77, 0x44])
+ i2c_slave.conf_transmit_buffer(i2c_slave_tx_buf)
+
+ # readfrom_into()
+ master_read_data = bytearray(8)
+ i2c_master.readfrom_into(slave_addr, master_read_data)
+ print(
+ "master readfrom_into() and transmitted from slave: ", i2c_slave_tx_buf == master_read_data
+ )
+
+ # readfrom()
+ i2c_slave_tx_buf = bytearray([0xAB, 0xCD])
+ i2c_slave.conf_transmit_buffer(i2c_slave_tx_buf)
+
+ master_read_data = i2c_master.readfrom(slave_addr, 2)
+ print("master readfrom() and transmitted from slave: ", i2c_slave_tx_buf == master_read_data)
+
+ # readfrom_mem_into()
+ i2c_slave_rcv_buf = bytearray(1)
+ i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+ i2c_slave_tx_buf = bytearray([0x03, 0x44, 0x55])
+ i2c_slave.conf_transmit_buffer(i2c_slave_tx_buf)
+ master_read_data = bytearray(3)
+
+ i2c_master.readfrom_mem_into(slave_addr, 0x01, master_read_data)
+ print(
+ "master readfrom_mem_into() and transmitted from slave: ",
+ i2c_slave_tx_buf == master_read_data,
+ )
+
+ # readfrom_mem()
+ i2c_slave_rcv_buf = bytearray(1)
+ i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+ i2c_slave_tx_buf = bytearray([0x43, 0x22, 0x77])
+ i2c_slave.conf_transmit_buffer(i2c_slave_tx_buf)
+ master_read_data = bytearray(3)
+
+ master_read_data = i2c_master.readfrom_mem(slave_addr, 0x01, 3)
+ print(
+ "master readfrom_mem() and transmitted from slave: ", i2c_slave_tx_buf == master_read_data
+ )
+
+ # 5. Master to slave write and read with stop false
+ ###################################################
+ i2c_slave_rcv_buf = bytearray(3)
+ i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+ i2c_slave_tx_buf = bytearray([0x22, 0x11, 0x55])
+ i2c_slave.conf_transmit_buffer(i2c_slave_tx_buf)
+ master_read_data = bytearray(3)
+
+ master_write_data = b"\x02\x32\x89"
+ i2c_master.writeto(slave_addr, master_write_data, False)
+ master_read_data = i2c_master.readfrom(slave_addr, 3, True)
+
+ print(
+ "master writeto(stop=false) and received by slave: ",
+ i2c_slave_rcv_buf == master_write_data,
+ )
+ print("master readfrom() and transmitted from slave : ", i2c_slave_tx_buf == master_read_data)
+
+
+print("\nI2C Hardware\n")
+i2c_tests(i2c_master)
+
+print("\nI2C Software\n")
+i2c_tests(i2c_soft_master)
+
+# 6. Primitive operation with SoftI2C
+
+print("\nI2C Primitives\n")
+
+i2c_soft_master.init(scl=scl_master_soft_pin, sda=sda_master_soft_pin)
+
+i2c_slave_rcv_buf = bytearray(3)
+i2c_slave.conf_receive_buffer(i2c_slave_rcv_buf)
+
+# 6.1. Master to slave write
+# first byte = slave = 0x45 << 1 bit = 0x8a + w (0)
+master_write_data = b"\x8a\x03\x44\x55"
+i2c_soft_master.start()
+i2c_soft_master.write(master_write_data)
+i2c_soft_master.stop()
+
+print("master soft write based on primitives: ", i2c_slave_rcv_buf == b"\x03\x44\x55")
+
+# 6.2. Master to slave read
+# first byte = slave = 0x45 << 1 bit = 0x8a + r (1) = 0x8b
+i2c_slave_tx_buf = bytearray([0x43, 0x22, 0x77])
+i2c_slave.conf_transmit_buffer(i2c_slave_tx_buf)
+
+master_read_data = bytearray(3)
+
+i2c_soft_master.start()
+i2c_soft_master.write(b"\x8b")
+i2c_soft_master.readinto(master_read_data)
+i2c_soft_master.stop()
+
+print("master readinto() and transmitted from slave: ", master_read_data == b"\x43\x22\x77")
+
+# 7. Deinit runs without error
+i2c_master.deinit()
+i2c_slave.deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/single/i2c.py.exp b/tests/ports/psoc6/board_ext_hw/single/i2c.py.exp
new file mode 100644
index 0000000000000..adda95a91c01e
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/i2c.py.exp
@@ -0,0 +1,36 @@
+'scl' argument required
+'sda' argument required
+'scl' argument required
+'sda' argument required
+'addr' argument required
+
+I2C Hardware
+
+Found slave with address 69 : True
+master writeto() and received by slave: True
+master writeto_mem() and received by slave: True
+master writevto() and received by slave: True
+master readfrom_into() and transmitted from slave: True
+master readfrom() and transmitted from slave: True
+master readfrom_mem_into() and transmitted from slave: True
+master readfrom_mem() and transmitted from slave: True
+master writeto(stop=false) and received by slave: True
+master readfrom() and transmitted from slave : True
+
+I2C Software
+
+Found slave with address 69 : True
+master writeto() and received by slave: True
+master writeto_mem() and received by slave: True
+master writevto() and received by slave: True
+master readfrom_into() and transmitted from slave: True
+master readfrom() and transmitted from slave: True
+master readfrom_mem_into() and transmitted from slave: True
+master readfrom_mem() and transmitted from slave: True
+master writeto(stop=false) and received by slave: True
+master readfrom() and transmitted from slave : True
+
+I2C Primitives
+
+master soft write based on primitives: True
+master readinto() and transmitted from slave: True
diff --git a/tests/ports/psoc6/board_ext_hw/single/pin.py b/tests/ports/psoc6/board_ext_hw/single/pin.py
new file mode 100644
index 0000000000000..d1da1b8ba165f
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/pin.py
@@ -0,0 +1,98 @@
+import os
+from machine import Pin
+import machine
+import time
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ pin1_name = "P13_7"
+ pin2_name = "P13_6"
+elif "CY8CPROTO-063-BLE" in board:
+ pin1_name = "P12_6"
+ pin2_name = "P12_7"
+elif "CY8CKIT-062S2-AI" in board:
+ pin1_name = "P9_6"
+ pin2_name = "P9_7"
+
+# Pin out and pin in must be connected
+# together in the board
+
+pin_out = Pin(pin1_name, mode=Pin.OUT, value=True)
+pin_in = Pin(pin2_name, Pin.IN)
+
+# Validating initialization values
+print("pin out initial value 1: ", pin_in.value() == 1)
+
+pin_out.deinit()
+pin_out = Pin(pin1_name, mode=Pin.OUT, value=False)
+print("pin out initial value 0: ", pin_in.value() == 0)
+
+# Validation different output setting
+pin_out.value(1)
+print("pin out value 1: ", pin_in.value() == 1)
+
+pin_out.value(0)
+print("pin out value 0: ", pin_in.value() == 0)
+
+pin_out.value(True)
+print("pin out value True: ", pin_in.value() == True)
+
+pin_out.value(False)
+print("pin out value False: ", pin_in.value() == False)
+
+pin_out.high()
+print("pin out value high: ", pin_in.value() == 1)
+
+pin_out.low()
+print("pin out value low: ", pin_in.value() == 0)
+
+pin_out.on()
+print("pin out value on: ", pin_in.value() == 1)
+
+pin_out.off()
+print("pin out value off: ", pin_in.value() == 0)
+
+pin_out(1)
+print("pin out callable 1: ", pin_in.value() == 1)
+
+pin_out(0)
+print("pin out callable 0: ", pin_in.value() == 0)
+
+
+# TODO: Check how to tests the PULLUP enablement functionality.
+# This is not really working because of the hardware setup? init value set?
+# pull up hardware configuration not working?
+# Validating pull resistors configurations and open drain mode
+# pin_out.deinit()
+# pin_out = Pin(pin1_name, pull=None, mode=Pin.OPEN_DRAIN)
+# print("pin out with pull none initially 0 or 1: ", pin_in.value() == 0 or pin_in.value() == 1)
+
+# pin_out.deinit()
+# pin_out = Pin(pin1_name, pull=Pin.PULL_DOWN, mode=Pin.OUT)
+# print("pin out with pull down initially down: ", pin_in.value() == 0)
+
+# pin_out.deinit()
+# pin_out = Pin(pin1_name, pull=Pin.PULL_UP, mode=Pin.OUT)
+# print("pin out with pull up initially high: ", pin_in.value() == 1)
+
+
+# Validating interrupts
+def blocking_delay_ms(delay_ms):
+ start = time.ticks_ms()
+ while time.ticks_diff(time.ticks_ms(), start) < delay_ms:
+ pass
+
+
+pin_in.irq(handler=lambda t: print("interrupt triggered rising"), trigger=Pin.IRQ_RISING)
+pin_out.high()
+
+blocking_delay_ms(1000)
+
+pin_in.irq(handler=lambda t: print("interrupt triggered falling"), trigger=Pin.IRQ_FALLING)
+pin_out.low()
+
+blocking_delay_ms(1000)
+
+pin_in.deinit()
+pin_out.deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/single/pin.py.exp b/tests/ports/psoc6/board_ext_hw/single/pin.py.exp
new file mode 100644
index 0000000000000..ab4a9ed231dc1
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/pin.py.exp
@@ -0,0 +1,14 @@
+pin out initial value 1: True
+pin out initial value 0: True
+pin out value 1: True
+pin out value 0: True
+pin out value True: True
+pin out value False: True
+pin out value high: True
+pin out value low: True
+pin out value on: True
+pin out value off: True
+pin out callable 1: True
+pin out callable 0: True
+interrupt triggered rising
+interrupt triggered falling
diff --git a/tests/ports/psoc6/board_ext_hw/single/pwm.py b/tests/ports/psoc6/board_ext_hw/single/pwm.py
new file mode 100644
index 0000000000000..e2e7e8e59fb42
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/pwm.py
@@ -0,0 +1,157 @@
+# PWM test
+"""
+Setup: Connect pwm_pin to pin_in
+"""
+from machine import PWM, Pin
+import os
+import time
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ pwm_pin = "P13_7"
+ pin_in = "P13_6"
+elif "CY8CPROTO-063-BLE" in board:
+ pwm_pin = "P12_6"
+ pin_in = "P12_7"
+elif "CY8CKIT-062S2-AI" in board:
+ pwm_pin = "P9_6"
+ pin_in = "P9_7"
+
+input_pin = Pin(pin_in, Pin.IN)
+
+
+def measure_signal():
+ # In some cases, the first measurement is not accurate
+ # (negative time)
+ # so we need to measure the signal until we get a positive timing
+ positive_timing = False
+ attempts = 0
+ while not positive_timing and attempts < 3:
+ init_level = input_pin.value()
+ # Transient until edge transition
+ # when the synch is done
+ while input_pin.value() == init_level:
+ pass
+
+ # start measuring just after the edge transition
+ init_level_start_time = time.ticks_us()
+
+ # wait for edge transition
+ while input_pin.value() == (not init_level):
+ pass
+ init_level_end_time = time.ticks_us()
+
+ # wait for next edge transition
+ while input_pin.value() == init_level:
+ pass
+ second_level_start_time = time.ticks_us()
+
+ # Identify the low and high level timestamps
+ if init_level == 1:
+ low_level_start_time = init_level_start_time
+ low_level_end_time = init_level_end_time
+ high_level_start_time = init_level_end_time
+ high_level_end_time = second_level_start_time
+ else:
+ low_level_start_time = init_level_end_time
+ low_level_end_time = second_level_start_time
+ high_level_start_time = init_level_start_time
+ high_level_end_time = init_level_end_time
+
+ on_time = time.ticks_diff(high_level_end_time, high_level_start_time)
+ off_time = time.ticks_diff(low_level_end_time, low_level_start_time)
+ time_period = on_time + off_time
+
+ attempts += 1
+ if time_period > 0:
+ positive_timing = True
+
+ # Calculate frequency and duty cycle
+ calc_freq = 1000000 / (time_period)
+ calc_dc = (on_time / time_period) * 100
+ return calc_dc, calc_freq
+
+
+def validate_signal(exp_freq=0, calc_freq=0, calc_dc=0, exp_dc=0, exp_duty_u16=0, exp_duty_ns=0):
+ tolerance = 0.5
+ duty_tolerance = 1.0
+
+ set_freq = pwm.freq()
+ set_duty_u16 = 0
+ set_duty_ns = 0
+
+ if exp_duty_ns:
+ set_duty_ns = pwm.duty_ns()
+ if exp_duty_u16:
+ set_duty_u16 = pwm.duty_u16()
+
+ if ((exp_freq - tolerance) < set_freq < (exp_freq + tolerance)) == False:
+ print(
+ f"Expected freq does not match set freq! \n Exp freq: {exp_freq} \n Set freq: {set_freq}"
+ )
+
+ if ((exp_freq - tolerance) < calc_freq < (exp_freq + tolerance)) == False:
+ print(
+ f"Expected freq does not match calc freq! \n Exp freq: {exp_freq} \n Set freq: {calc_freq}"
+ )
+ # This one is failing intermittently on the CI/CD
+ if ((exp_dc - duty_tolerance) < calc_dc < (exp_dc + duty_tolerance)) == False:
+ print(f"Exp dc(%) does not match calc dc(%)! \n Exp dc: {exp_dc} \n Calc dc: {calc_dc}")
+
+ if set_duty_ns != 0:
+ if set_duty_ns != exp_duty_ns:
+ print(
+ f"Exp dc(ns) does not match set dc(ns) \n Exp dc: {exp_duty_ns} \n Set dc: {set_duty_ns}"
+ )
+
+ if set_duty_u16 != 0:
+ if set_duty_u16 != exp_duty_u16:
+ print(
+ f"Exp dc(raw) does not match set dc(raw) \n Exp dc: {exp_duty_u16} \n Set dc: {set_duty_u16}"
+ )
+
+
+print("*** PWM tests ***")
+# T = 1sec (25% dc)
+pwm = PWM(pwm_pin, freq=1, duty_ns=250000000)
+time.sleep(2) # Wait for the pwm signal to be initialized and started
+calc_dc, calc_freq = measure_signal()
+validate_signal(
+ exp_freq=1,
+ calc_freq=calc_freq,
+ exp_dc=25,
+ calc_dc=calc_dc,
+ exp_duty_u16=0,
+ exp_duty_ns=250000000,
+)
+
+# T = 1sec (50% dc)
+pwm.duty_ns(500000000)
+calc_dc, calc_freq = measure_signal()
+validate_signal(
+ exp_freq=1,
+ calc_freq=calc_freq,
+ exp_dc=50,
+ calc_dc=calc_dc,
+ exp_duty_u16=0,
+ exp_duty_ns=500000000,
+)
+
+# T = 1sec (75% dc)
+pwm.duty_u16(49151)
+calc_dc, calc_freq = measure_signal()
+validate_signal(
+ exp_freq=1, calc_freq=calc_freq, exp_dc=75, calc_dc=calc_dc, exp_duty_u16=49151, exp_duty_ns=0
+)
+
+# Reconfigure frequency and dutycycle
+# T = 0.5 sec (50% dc)
+pwm.init(freq=2, duty_u16=32767)
+calc_dc, calc_freq = measure_signal()
+validate_signal(
+ exp_freq=2, calc_freq=calc_freq, exp_dc=50, calc_dc=calc_dc, exp_duty_u16=32767, exp_duty_ns=0
+)
+
+pwm.deinit()
+input_pin.deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/single/pwm.py.exp b/tests/ports/psoc6/board_ext_hw/single/pwm.py.exp
new file mode 100644
index 0000000000000..dcbb927e259bc
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/pwm.py.exp
@@ -0,0 +1 @@
+*** PWM tests ***
diff --git a/tests/ports/psoc6/board_ext_hw/single/sdcard.py b/tests/ports/psoc6/board_ext_hw/single/sdcard.py
new file mode 100644
index 0000000000000..050a9c05c2502
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/sdcard.py
@@ -0,0 +1,153 @@
+import machine
+import os
+import errno
+
+SHORT_TEST_STRING = "This is a test string."
+LONG_TEST_STRING = "This is a very long string. And as a long string that it is, it is only getting longer and longer and the string goes. How long shall it be? Well, not really sure, but let´s try it like this."
+READ_SIZE = 512
+WRITE_SIZE = 512
+MOUNT_POINT_FAT = "/SDCardFat"
+MOUNT_POINT_LFS2 = "/SDCardLfs2"
+
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ sdcard_config = {
+ "width": 4,
+ "cd": "P13_5",
+ "cmd": "P12_4",
+ "clk": "P12_5",
+ "dat0": "P13_0",
+ "dat1": "P13_1",
+ "dat2": "P13_2",
+ "dat3": "P13_3",
+ }
+elif "CY8CPROTO-063-BLE" in board:
+ print("SKIP")
+ raise SystemExit
+elif "CY8CKIT-062S2-AI" in board:
+ print("SKIP")
+ raise SystemExit
+
+
+def unmount_sd_card(path):
+ try:
+ os.umount(path)
+ except OSError as e:
+ if e.args[0] != errno.EINVAL:
+ raise Exception(f"Could not unmount {path}")
+
+
+def mount_or_format_sd_card_vfs2(block_device, filesystem, mount_point):
+ try:
+ vfs = filesystem(block_device, progsize=WRITE_SIZE, readsize=READ_SIZE)
+ os.mount(vfs, mount_point)
+ except OSError:
+ filesystem.mkfs(block_device, progsize=WRITE_SIZE, readsize=READ_SIZE)
+ vfs = filesystem(block_device, progsize=WRITE_SIZE, readsize=READ_SIZE)
+ os.mount(vfs, mount_point)
+ print(f"\nSD card mounted at {mount_point}\n")
+
+
+def mount_or_format_sd_card_fat(block_device, filesystem, mount_point):
+ try:
+ vfs = filesystem(block_device)
+ os.mount(vfs, mount_point)
+ except OSError:
+ filesystem.mkfs(block_device)
+ vfs = filesystem(block_device)
+ os.mount(vfs, mount_point)
+ print(f"\nSD card mounted at {mount_point}\n")
+
+
+def read_write_test(file_path, test_data):
+ with open(file_path, "w") as f:
+ f.write(test_data)
+ with open(file_path, "r") as f:
+ return f.read() == test_data
+
+
+def test_file_transfer_lfs2():
+ # Define the SD card configuration
+ bdev = machine.SDCard(**sdcard_config)
+
+ # Unmount the SD card if mounted
+ unmount_sd_card(MOUNT_POINT_LFS2)
+
+ # Mount or format the SD card with LFS2 filesystem
+ if "VfsLfs2" in dir(os):
+ mount_or_format_sd_card_vfs2(bdev, os.VfsLfs2, MOUNT_POINT_LFS2)
+
+ # change to SD card directory
+ os.chdir(MOUNT_POINT_LFS2)
+
+ print("\n***** Test 1: Short string file transfer to SD Card in LFS2 format *****\n")
+ # Test short string
+ short_test_file = "test_sd_lfs2_short.txt"
+ if read_write_test(short_test_file, SHORT_TEST_STRING):
+ print("PASS")
+ else:
+ print("FAIL")
+
+ print("\n***** Test 2: Long string file transfer to SD Card in LFS2 format *****\n")
+ # Test long string
+ long_test_file = "test_sd_lfs2_long.txt"
+ if read_write_test(long_test_file, LONG_TEST_STRING):
+ print("PASS")
+ else:
+ print("FAIL")
+
+ # change to root directory
+ os.chdir("/")
+
+ bdev.deinit()
+
+
+def test_file_transfer_fat():
+ # Define the SD card configuration
+ bdev = machine.SDCard(**sdcard_config)
+
+ # Unmount the SD card if mounted
+ unmount_sd_card(MOUNT_POINT_FAT)
+
+ # Mount or format the SD card with LFS2 filesystem
+ if "VfsLfs2" in dir(os):
+ mount_or_format_sd_card_fat(bdev, os.VfsFat, MOUNT_POINT_FAT)
+
+ # change to SD card directory
+ os.chdir(MOUNT_POINT_FAT)
+
+ print("\n***** Test 3: Short string file transfer to SD Card in FAT format *****\n")
+ # Test short string
+ short_test_file = "test_sd_fat_short.txt"
+ if read_write_test(short_test_file, SHORT_TEST_STRING):
+ print("PASS")
+ else:
+ print("FAIL")
+
+ print("\n***** Test 4: Long string file transfer to SD Card in FAT format *****\n")
+ # Test long string
+ long_test_file = "test_sd_fat_long.txt"
+ if read_write_test(long_test_file, LONG_TEST_STRING):
+ print("PASS")
+ else:
+ print("FAIL")
+
+ # change to root directory
+ os.chdir("/")
+
+ bdev.deinit()
+
+
+def test_reintializing_same_slot():
+ print("\n***** Test 5: reinitialize the same slot more than once *****\n")
+ bdev1 = machine.SDCard(**sdcard_config)
+ bdev1.deinit()
+ bdev2 = machine.SDCard(**sdcard_config)
+ bdev2.deinit()
+ print("PASS")
+
+
+if __name__ == "__main__":
+ test_file_transfer_lfs2()
+ test_file_transfer_fat()
+ test_reintializing_same_slot()
diff --git a/tests/ports/psoc6/board_ext_hw/single/sdcard.py.exp b/tests/ports/psoc6/board_ext_hw/single/sdcard.py.exp
new file mode 100644
index 0000000000000..ba546511e7e2b
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/sdcard.py.exp
@@ -0,0 +1,26 @@
+
+SD card mounted at /SDCardLfs2
+
+
+***** Test 1: Short string file transfer to SD Card in LFS2 format *****
+
+PASS
+
+***** Test 2: Long string file transfer to SD Card in LFS2 format *****
+
+PASS
+
+SD card mounted at /SDCardFat
+
+
+***** Test 3: Short string file transfer to SD Card in FAT format *****
+
+PASS
+
+***** Test 4: Long string file transfer to SD Card in FAT format *****
+
+PASS
+
+***** Test 5: reinitialize the same slot more than once *****
+
+PASS
diff --git a/tests/ports/psoc6/board_ext_hw/single/signal.py b/tests/ports/psoc6/board_ext_hw/single/signal.py
new file mode 100644
index 0000000000000..a47ecbe79f84d
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/signal.py
@@ -0,0 +1,60 @@
+import os
+from machine import Pin, Signal
+import machine
+import time
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ pin1_name = "P13_7"
+ pin2_name = "P13_6"
+elif "CY8CPROTO-063-BLE" in board:
+ pin1_name = "P12_6"
+ pin2_name = "P12_7"
+elif "CY8CKIT-062S2-AI" in board:
+ pin1_name = "P9_6"
+ pin2_name = "P9_7"
+
+# Pin out and pin in must be connected
+# together in the board
+
+# value() as get is not supported,
+# same as undefined for pin.value() for output
+
+pin_out = Pin(pin1_name, mode=Pin.OUT, value=True)
+pin_in = Pin(pin2_name, Pin.IN)
+
+# Set signal for output pin as non-inverted
+print("non-inverted")
+
+signal = Signal(pin_out, invert=False)
+
+signal.on()
+print("signal is high when on(): ", pin_in.value() == 1)
+
+signal.value(0)
+print("signal is low when value(0): ", pin_in.value() == 0)
+
+signal.value(1)
+print("signal is high when value(1): ", pin_in.value() == 1)
+
+signal.off()
+print("signal is low when off(): ", pin_in.value() == 0)
+
+print("\n")
+
+# Set signal for output pin as inverted
+print("inverted")
+signal = Signal(pin_out, invert=True)
+
+signal.on()
+print("signal is low when on(): ", pin_in.value() == 0)
+
+signal.value(0)
+print("signal is high when value(0): ", pin_in.value() == 1)
+
+signal.value(1)
+print("signal is low when value(1): ", pin_in.value() == 0)
+
+signal.off()
+print("signal is high when off(): ", pin_in.value() == 1)
diff --git a/tests/ports/psoc6/board_ext_hw/single/signal.py.exp b/tests/ports/psoc6/board_ext_hw/single/signal.py.exp
new file mode 100644
index 0000000000000..978f680757421
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/signal.py.exp
@@ -0,0 +1,12 @@
+non-inverted
+signal is high when on(): True
+signal is low when value(0): True
+signal is high when value(1): True
+signal is low when off(): True
+
+
+inverted
+signal is low when on(): True
+signal is high when value(0): True
+signal is low when value(1): True
+signal is high when off(): True
diff --git a/tests/ports/psoc6/board_ext_hw/single/uart.py b/tests/ports/psoc6/board_ext_hw/single/uart.py
new file mode 100644
index 0000000000000..0e5d2d8855183
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/uart.py
@@ -0,0 +1,156 @@
+### UART
+from machine import UART
+import machine
+import binascii
+import time
+import os
+
+# Allocate pin based on board
+board = os.uname().machine
+if "CY8CPROTO-062-4343W" in board:
+ uart_rx_pin = "P9_0"
+ uart_tx_pin = "P9_1"
+ uart_rts_pin = "P9_2"
+ uart_cts_pin = "P9_3"
+elif "CY8CPROTO-063-BLE" in board:
+ uart_rx_pin = "P10_0"
+ uart_tx_pin = "P10_1"
+ uart_rts_pin = "P10_2"
+ uart_cts_pin = "P10_3"
+elif "CY8CKIT-062S2-AI" in board:
+ uart_rx_pin = "P10_0"
+ uart_tx_pin = "P10_1"
+ uart_rts_pin = "P9_2"
+ uart_cts_pin = "P9_3"
+
+# 1. Construct instance
+##############################################
+uart = UART(1)
+uart.init(9600, bits=8, parity=None, stop=1, tx=uart_tx_pin, rx=uart_rx_pin)
+
+
+def uart_tests():
+ # 2. Basic tests
+ ##############################################
+
+ # sendbreak()
+ uart.sendbreak()
+ time.sleep_ms(100)
+ print("Break Sent is received by Rx: ", uart.read() == b"\xf0")
+
+ # write_char()
+ # read_char()
+ uart.writechar(1)
+ rx_char = uart.readchar()
+ print("Tx char is received by Rx char: ", rx_char == 1)
+
+ # read()
+ tx_data = b"abcdefg"
+ uart.write(tx_data)
+ time.sleep_ms(100)
+ rx_data = uart.read()
+ print("Tx is received by Rx(read()): ", rx_data == tx_data)
+
+ # readline(nbytes)
+ tx_data = "abcd\ne"
+ uart.write(tx_data)
+ time.sleep_ms(100)
+ rx_data = uart.readline()
+ print("Tx is received by Rx(readline()): ", rx_data == b"abcd\n")
+ uart.read() # read all data available to clear buffer
+
+ # read(n bytes)
+ tx_data = "abcdefghijklmn"
+ uart.write(tx_data)
+ time.sleep_ms(8)
+ rx_data = uart.read(7)
+ print("Tx is received by Rx(read(nbytes)):", rx_data == b"abcdefg")
+
+ # tx_done()
+ tx_data = "abcdefg"
+ uart.write(tx_data)
+ print("Tx Ongoing: ", uart.txdone() == False)
+ time.sleep_ms(100)
+ print("Tx Done: ", uart.txdone() == True)
+ uart.read() # read all data available to clear buffer
+
+ # write(buf)
+ # readinto(buf)
+ uart_rx_buf = bytearray(8)
+ tx_data = b"\x01\x44\x17\x88\x98\x11\x34\xff"
+ uart.write(tx_data)
+ time.sleep_ms(100)
+ uart.readinto(uart_rx_buf)
+ print("Tx is received by Rx(readinto(buf)): ", uart_rx_buf == tx_data)
+
+
+def uart_interrupt_tests():
+ uart.irq(trigger=UART.TX_DONE, handler=tx_complete)
+ tx_data = b"Hi this is data"
+ uart.write(tx_data)
+ time.sleep_ms(100)
+ while not tx_done:
+ pass
+ print("Tx Done")
+
+ uart.irq(trigger=UART.RX_DONE, handler=rx_complete)
+ uart_rx_buf = bytearray(8)
+ uart.readinto(uart_rx_buf)
+ print("Tx is received by Rx(readinto(buf)): ", uart_rx_buf == b"Hi this ")
+ while not rx_done:
+ pass
+ print("Rx Done")
+
+ uart.init(rxbuf=8)
+ uart.irq(trigger=UART.RX_FULL, handler=rx_full)
+ tx_data = b"\x44\x17\x88\x98\x11\x34\xff\x12\x57\x76\x44\x17\x88\x98\x11\x34\xff\x12\x57\x76\x44\x17\x88\x98\x11\x34\xff\x12\x57\x76\x44\x17\x88\x98\x11\x34\xff\x12\x57\x76"
+ uart.write(tx_data)
+ uart.read(16)
+ while not rx_full:
+ pass
+ print("Rx Buffer Full")
+
+ uart.irq(trigger=UART.TX_EMPTY, handler=tx_empty)
+ while not tx_empty:
+ pass
+ print("Tx Empty")
+
+
+print("********UART Tests********\n")
+uart_tests()
+
+tx_done = False
+
+
+def tx_complete(t):
+ global tx_done
+ tx_done = True
+
+
+rx_done = False
+
+
+def rx_complete(t):
+ global rx_done
+ rx_done = True
+
+
+rx_full = False
+
+
+def rx_full(t):
+ global rx_full
+ rx_full = True
+
+
+tx_empty = False
+
+
+def tx_empty(t):
+ global tx_empty
+ tx_empty = True
+
+
+print("\n*******UART Interrupt Tests*******\n")
+uart_interrupt_tests()
+uart.deinit()
diff --git a/tests/ports/psoc6/board_ext_hw/single/uart.py.exp b/tests/ports/psoc6/board_ext_hw/single/uart.py.exp
new file mode 100644
index 0000000000000..cc4aa397e11ff
--- /dev/null
+++ b/tests/ports/psoc6/board_ext_hw/single/uart.py.exp
@@ -0,0 +1,19 @@
+machine.UART: ID parameter is ignored in this port.
+********UART Tests********
+
+Break Sent is received by Rx: True
+Tx char is received by Rx char: True
+Tx is received by Rx(read()): True
+Tx is received by Rx(readline()): True
+Tx is received by Rx(read(nbytes)): True
+Tx Ongoing: True
+Tx Done: True
+Tx is received by Rx(readinto(buf)): True
+
+*******UART Interrupt Tests*******
+
+Tx Done
+Tx is received by Rx(readinto(buf)): True
+Rx Done
+Rx Buffer Full
+Tx Empty
diff --git a/tests/ports/psoc6/board_only_hw/multi/network.py b/tests/ports/psoc6/board_only_hw/multi/network.py
new file mode 100644
index 0000000000000..c21f45d505212
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/multi/network.py
@@ -0,0 +1,105 @@
+import binascii, time
+
+try:
+ import network
+except ImportError:
+ print("SKIP")
+ raise SystemExit
+
+channel_new = 1
+ssid_default = "mpy-psoc6-wlan"
+
+
+# Access Point
+def instance0():
+ network.hostname("mpy-psoc6-test")
+ print("set hostname: ", network.hostname() == "mpy-psoc6-test")
+
+ ap_if = network.WLAN(network.AP_IF)
+ print("ap instance created")
+ ap_if.config(channel=channel_new)
+
+ # active()
+ print("ap initially not active: ", ap_if.active() == False)
+ ap_if.active(True)
+ print("ap is activated: ", ap_if.active() == True)
+ ap_if.active(False)
+ print("ap is deactivated: ", ap_if.active() == False)
+ ap_if.active(True)
+ while ap_if.active() == False:
+ pass
+
+ # isConnected()
+ print("ap has no client: ", ap_if.isconnected() == False)
+
+ multitest.globals(ap_mac=ap_if.config("mac"))
+
+ print(" > yield station")
+ multitest.next()
+
+ while ap_if.isconnected() == False:
+ pass
+ print("ap has clients: ", ap_if.isconnected() == True)
+
+ # try disconnect()
+ try:
+ ap_if.disconnect() # not for AP
+ except ValueError as err:
+ print("ap cannot disconnect: ", err)
+
+ # status()
+ stations = ap_if.status("stations")
+ print("ap status has stations: ", stations != [])
+
+
+# Station
+def instance1():
+ sta_if = network.WLAN(network.STA_IF)
+ print("sta instance created")
+
+ # active()
+ print("sta is not active: ", sta_if.active() == False)
+
+ # scan()
+ wlan_nets = sta_if.scan()
+ test_ap_net = [net for net in wlan_nets if net[0] == b"mpy-psoc6-wlan"]
+ print("sta scan finds ap wlan: ", test_ap_net != [])
+
+ wlan_ssid_filter = sta_if.scan(ssid="mpy-psoc6-wlan")
+ test_ap_net = [net for net in wlan_ssid_filter if net[0] == b"mpy-psoc6-wlan"]
+ print("sta scan finds ap wlan (ssid filter): ", test_ap_net != [])
+
+ # print('ap_mac: ', binascii.hexlify(ap_mac, ':'))
+
+ wlan_bssid_filter = sta_if.scan(bssid=ap_mac)
+ test_ap_net = [net for net in wlan_bssid_filter if net[1] == ap_mac]
+ print("sta scan finds ap wlan (mac filter): ", test_ap_net != [])
+
+ # isconnect()
+ print("sta is not (yet) connected: ", sta_if.isconnected() == False)
+
+ # connect()
+ sta_if.connect(ssid_default, "mpy_PSOC6_w3lc0me!")
+ print("sta attempt connection to ap")
+
+ # active()
+ print("sta is (now) active: ", sta_if.active() == True)
+
+ # isConnected()
+ print("sta is (now) connected: ", sta_if.isconnected() == True)
+
+ # status()
+ # The test boards are placed next to each other (few cm range)
+ print("sta status rssi in range: ", -70 < sta_if.status("rssi") < 10)
+
+ print(" > yield access point")
+ multitest.next()
+
+ # disconnect()
+ sta_if.disconnect()
+ print("sta is disconnected: ", sta_if.active() == False)
+
+ print("sta attempt connection to ap (with bssid)")
+ sta_if.connect(ssid_default, "mpy_PSOC6_w3lc0me!", bssid=ap_mac)
+
+ print("sta is active: ", sta_if.active() == True)
diff --git a/tests/ports/psoc6/board_only_hw/multi/network.py.exp b/tests/ports/psoc6/board_only_hw/multi/network.py.exp
new file mode 100644
index 0000000000000..f6393bbcd1778
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/multi/network.py.exp
@@ -0,0 +1,26 @@
+--- instance0 ---
+set hostname: True
+ap instance created
+ap initially not active: True
+ap is activated: True
+ap is deactivated: True
+ap has no client: True
+ > yield station
+ap has clients: True
+ap cannot disconnect: network STA required
+ap status has stations: True
+--- instance1 ---
+sta instance created
+sta is not active: True
+sta scan finds ap wlan: True
+sta scan finds ap wlan (ssid filter): True
+sta scan finds ap wlan (mac filter): True
+sta is not (yet) connected: True
+sta attempt connection to ap
+sta is (now) active: True
+sta is (now) connected: True
+sta status rssi in range: True
+ > yield access point
+sta is disconnected: True
+sta attempt connection to ap (with bssid)
+sta is active: True
diff --git a/tests/ports/psoc6/board_only_hw/multi/network_config.py b/tests/ports/psoc6/board_only_hw/multi/network_config.py
new file mode 100644
index 0000000000000..0aa28ad83e0af
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/multi/network_config.py
@@ -0,0 +1,98 @@
+import binascii, time
+
+try:
+ import network
+except ImportError:
+ print("SKIP")
+ raise SystemExit
+
+channel_new = 5
+ssid_new = "mpy-test-conf-wlan"
+pass_new = "alicessecret"
+sec_new = network.WLAN.WPA2
+
+ap_ip = "10.20.0.1"
+gateway_ip = ap_ip
+netmask_ip = "255.255.255.128"
+dns_ip = "0.0.0.0"
+ap_net_conf = (ap_ip, netmask_ip, gateway_ip, dns_ip)
+
+
+# Access Point
+def instance0():
+ ap_if = network.WLAN(network.AP_IF)
+ print("ap instance created")
+
+ # get config()
+ ap_if.config(channel=channel_new)
+ print("ap config get channel: ", ap_if.config("channel") == channel_new)
+ ap_if.config(ssid=ssid_new)
+ print("ap config get ssid: ", ap_if.config("ssid") == ssid_new)
+ ap_if.config(security=sec_new, key=pass_new)
+ print("ap config get security: ", ap_if.config("security") == sec_new)
+ try:
+ ap_if.config("password") # only if default
+ except ValueError as err:
+ print(err)
+
+ # active()
+ ap_if.active(True)
+ while ap_if.active() == False:
+ pass
+ print("ap is activated")
+
+ # set ifconfig()
+ ap_if.ifconfig(ap_net_conf)
+
+ # get ifconfig()
+ print("ap ip settings: ", ap_if.ifconfig() == ap_net_conf)
+
+ print(" > yield station")
+ multitest.next()
+
+ while ap_if.isconnected() == False:
+ pass
+ print("ap has clients: ", ap_if.isconnected() == True)
+
+ # status()
+ stations = ap_if.status("stations")
+ print("ap status has stations: ", stations != [])
+
+ print(ap_if)
+
+
+# Station
+def instance1():
+ sta_if = network.WLAN(network.STA_IF)
+ print("sta instance created")
+
+ # connect()
+ sta_if.connect(ssid_new, pass_new)
+ print("sta attempt connection to ap")
+
+ # active()
+ print("sta is (now) active: ", sta_if.active() == True)
+
+ # isConnected()
+ print("sta is (now) connected: ", sta_if.isconnected() == True)
+
+ # config()
+ print("sta assoc ap channel config: ", sta_if.config("channel") == channel_new)
+ print("sta assoc ap ssid config: ", sta_if.config("ssid") == ssid_new)
+ print("sta assoc ap security config: ", sta_if.config("security") == sec_new)
+
+ try:
+ sta_if.config("key") # not for STA
+ except ValueError as err:
+ print(err)
+
+ # ifconfig()
+ sta_net_conf = ("10.20.0.2", netmask_ip, ap_ip, ap_ip)
+ print("sta ip settings: ", sta_if.ifconfig() == sta_net_conf)
+
+ try:
+ sta_if.ifconfig(sta_net_conf) # not for STA
+ except ValueError as err:
+ print(err)
+
+ print(sta_if)
diff --git a/tests/ports/psoc6/board_only_hw/multi/network_config.py.exp b/tests/ports/psoc6/board_only_hw/multi/network_config.py.exp
new file mode 100644
index 0000000000000..7985c2ac8e892
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/multi/network_config.py.exp
@@ -0,0 +1,24 @@
+--- instance0 ---
+ap instance created
+ap config get channel: True
+ap config get ssid: True
+ap config get security: True
+network conf password only queryable for default password
+ap is activated
+ap ip settings: True
+ > yield station
+ap has clients: True
+ap status has stations: True
+
+--- instance1 ---
+sta instance created
+sta attempt connection to ap
+sta is (now) active: True
+sta is (now) connected: True
+sta assoc ap channel config: True
+sta assoc ap ssid config: True
+sta assoc ap security config: True
+network access point required
+sta ip settings: True
+network access point required
+
diff --git a/tests/ports/psoc6/board_only_hw/single/flash.py b/tests/ports/psoc6/board_only_hw/single/flash.py
new file mode 100644
index 0000000000000..3230a5520f047
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/flash.py
@@ -0,0 +1,84 @@
+import os, psoc6
+
+machine = os.uname().machine
+
+# Try to mount the filesystem, and format the flash if it doesn't exist.
+# create block device object based on whichever flash is active
+bdev = psoc6.QSPI_Flash() if "QSPI_Flash" in dir(psoc6) else psoc6.Flash()
+# unmount the filesystem in case its already mounted
+os.umount("/")
+
+test_string = "This is a test string."
+long_test_string = "This is a very long string. And as a long string that it is, it is only getting longer and longer and the string goes. How long shall it be? Well, not really sure, but let´s try it like this."
+
+# first priority is always LFS2 filesystem as it is the default
+if "VfsLfs2" in dir(os):
+ # sector size 4 KB for external flash
+ # sector size 512 B for internal flash
+ read_size = 0x1000 if "QSPI_Flash" in dir(psoc6) else 0x200
+ # page size 512 B for both flashes
+ write_size = 0x200
+
+ # create a LFS2 fs and mount it, else format and mount it
+ try:
+ vfs = os.VfsLfs2(bdev, progsize=write_size, readsize=read_size)
+ os.mount(vfs, "/")
+ except:
+ os.VfsLfs2.mkfs(bdev, progsize=write_size, readsize=read_size)
+ vfs = os.VfsLfs2(bdev, progsize=write_size, readsize=read_size)
+ os.mount(vfs, "/")
+
+ # open a file and do some operation
+ f = open("/test_lfs2.txt", "w")
+ f.write(test_string)
+ f.close()
+
+ # read back the contents
+ f = open("/test_lfs2.txt", "r")
+ if f.read() == test_string:
+ print("Test successful")
+ f.close()
+
+ # open a file and do some operation
+ f = open("/test_lfs2_2.txt", "w")
+ f.write(long_test_string)
+ f.close()
+
+ # read back the contents
+ f = open("/test_lfs2_2.txt", "r")
+ if f.read() == long_test_string:
+ print("Test successful")
+ f.close()
+
+# Run fat filesystem test only if lfs2 is not enabled
+elif "VfsFat" in dir(os):
+ # create a FAT fs and mount it, else format and mount it
+ try:
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/")
+ except:
+ os.VfsFat.mkfs(bdev)
+ vfs = os.VfsFat(bdev)
+ os.mount(vfs, "/")
+
+ # open a file and do some operation
+ f = open("/test_fat.txt", "w")
+ f.write(test_string)
+ f.close()
+
+ # read back the contents
+ f = open("/test_fat.txt", "r")
+ if f.read() == test_string:
+ print("Test successful")
+ f.close()
+
+ # open a file and do some operation
+ f = open("/test_fat_2.txt", "w")
+ f.write(long_test_string)
+ f.close()
+
+ # read back the contents
+ f = open("/test_fat_2.txt", "r")
+ if f.read() == long_test_string:
+ print("Test successful")
+ f.close()
diff --git a/tests/ports/psoc6/board_only_hw/single/flash.py.exp b/tests/ports/psoc6/board_only_hw/single/flash.py.exp
new file mode 100644
index 0000000000000..37236d726f8ff
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/flash.py.exp
@@ -0,0 +1,2 @@
+Test successful
+Test successful
diff --git a/tests/ports/psoc6/board_only_hw/single/global_interrupts.py b/tests/ports/psoc6/board_only_hw/single/global_interrupts.py
new file mode 100644
index 0000000000000..0f7bd53eb1c61
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/global_interrupts.py
@@ -0,0 +1,34 @@
+from machine import Timer
+import machine
+import time
+
+oneshot_triggered = False
+
+
+def callback_oneshot(timer):
+ global oneshot_triggered
+ oneshot_triggered = True
+
+
+def test_oneshot():
+ # Oneshot timer
+ global oneshot_triggered
+ tim_oneshot = Timer(0, period=1, mode=Timer.ONE_SHOT, callback=callback_oneshot)
+
+ try:
+ # Wait for 5 seconds
+ for i in range(5):
+ time.sleep(1)
+ if oneshot_triggered:
+ print("Interrupt triggered")
+ oneshot_triggered = False
+ finally:
+ tim_oneshot.deinit() # Deinitialize the Oneshot timer
+
+
+state = machine.disable_irq()
+print("*****Test 1: Interrupts Disabled*****")
+test_oneshot()
+machine.enable_irq(state)
+print("*****Test 2: Interrupts Enabled******")
+test_oneshot()
diff --git a/tests/ports/psoc6/board_only_hw/single/global_interrupts.py.exp b/tests/ports/psoc6/board_only_hw/single/global_interrupts.py.exp
new file mode 100644
index 0000000000000..046a143c44e51
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/global_interrupts.py.exp
@@ -0,0 +1,3 @@
+*****Test 1: Interrupts Disabled*****
+*****Test 2: Interrupts Enabled******
+Interrupt triggered
diff --git a/tests/ports/psoc6/board_only_hw/single/machine_reset.py b/tests/ports/psoc6/board_only_hw/single/machine_reset.py
new file mode 100644
index 0000000000000..c6a4a3085780b
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/machine_reset.py
@@ -0,0 +1,8 @@
+import machine
+
+print("*****Test :Reset Validation after a soft Reset*****")
+if machine.reset_cause() == machine.SOFT_RESET:
+ print("PASS")
+else:
+ print(machine.reset_cause())
+ print("FAIL")
diff --git a/tests/ports/psoc6/board_only_hw/single/machine_reset.py.exp b/tests/ports/psoc6/board_only_hw/single/machine_reset.py.exp
new file mode 100644
index 0000000000000..aed9781364136
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/machine_reset.py.exp
@@ -0,0 +1,2 @@
+*****Test :Reset Validation after a soft Reset*****
+PASS
diff --git a/tests/ports/psoc6/board_only_hw/single/machine_test.py b/tests/ports/psoc6/board_only_hw/single/machine_test.py
new file mode 100644
index 0000000000000..f8c7b1390f05b
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/machine_test.py
@@ -0,0 +1,20 @@
+import machine
+
+
+def soft_reset():
+ machine.soft_reset()
+
+
+def freq_get_validate():
+ freq = machine.freq()
+ if freq == 100000000:
+ print("PASS")
+ else:
+ print(freq)
+ print("FAIL")
+
+
+print("*****Test 1: Default Frequency Validation*****")
+freq_get_validate()
+print("*****Test 2: Calling Soft Reset*****")
+soft_reset()
diff --git a/tests/ports/psoc6/board_only_hw/single/machine_test.py.exp b/tests/ports/psoc6/board_only_hw/single/machine_test.py.exp
new file mode 100644
index 0000000000000..8d36d4fdaedc9
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/machine_test.py.exp
@@ -0,0 +1,3 @@
+*****Test 1: Default Frequency Validation*****
+PASS
+*****Test 2: Calling Soft Reset*****
diff --git a/tests/ports/psoc6/board_only_hw/single/modtime.py b/tests/ports/psoc6/board_only_hw/single/modtime.py
new file mode 100644
index 0000000000000..f8f2992750442
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/modtime.py
@@ -0,0 +1,62 @@
+import time
+
+wday = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+
+
+def get_default_date_time():
+ seconds = 0
+ default_dtime = time.gmtime(0)
+ print(
+ "\ngmtime() at default returned [Year/Month/Day - WeekDay - HH:MM:SS] : %d/%02d/%02d - %s - %02d:%02d:%02d "
+ % (
+ default_dtime[0],
+ default_dtime[1],
+ default_dtime[2],
+ wday[default_dtime[6]],
+ default_dtime[3],
+ default_dtime[4],
+ default_dtime[5],
+ )
+ )
+
+ if time.mktime(default_dtime) != seconds:
+ print("\nmktime() FAILED to create right dtime from secs\n")
+ else:
+ print("\nmktime() SUCCESSFULLY created right dtime from secs\n")
+
+
+def get_dtime_from_secs(secs):
+ return time.localtime(secs)
+
+
+def spot_test(seconds, expected_time):
+ actual_time = time.localtime(seconds)
+ for i in range(len(actual_time)):
+ if actual_time[i] != expected_time[i]:
+ print(
+ "time.localtime(",
+ seconds,
+ ") returned",
+ actual_time,
+ "expecting",
+ expected_time,
+ "(Test : FAILED)",
+ )
+ return
+ print("time.localtime(", seconds, ") returned", actual_time, "(Test : PASSED)")
+
+
+get_default_date_time()
+
+spot_test(0, (1970, 1, 1, 0, 0, 0, 3, 1))
+spot_test(1, (1970, 1, 1, 0, 0, 1, 3, 1))
+spot_test(59, (1970, 1, 1, 0, 0, 59, 3, 1))
+spot_test(60, (1970, 1, 1, 0, 1, 0, 3, 1))
+spot_test(3599, (1970, 1, 1, 0, 59, 59, 3, 1))
+spot_test(3600, (1970, 1, 1, 1, 0, 0, 3, 1))
+spot_test(-1, (1969, 12, 31, 23, 59, 59, 2, 365))
+spot_test(447549467, (1984, 3, 7, 23, 17, 47, 2, 67))
+spot_test(-940984933, (1940, 3, 7, 23, 17, 47, 3, 67))
+spot_test(-1072915199, (1936, 1, 2, 0, 0, 1, 3, 2))
+spot_test(-1072915200, (1936, 1, 2, 0, 0, 0, 3, 2))
+spot_test(-1072915201, (1936, 1, 1, 23, 59, 59, 2, 1))
diff --git a/tests/ports/psoc6/board_only_hw/single/modtime.py.exp b/tests/ports/psoc6/board_only_hw/single/modtime.py.exp
new file mode 100644
index 0000000000000..0b5b07bd9776d
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/modtime.py.exp
@@ -0,0 +1,17 @@
+
+gmtime() at default returned [Year/Month/Day - WeekDay - HH:MM:SS] : 1970/01/01 - Thu - 00:00:00
+
+mktime() SUCCESSFULLY created right dtime from secs
+
+time.localtime( 0 ) returned (1970, 1, 1, 0, 0, 0, 3, 1) (Test : PASSED)
+time.localtime( 1 ) returned (1970, 1, 1, 0, 0, 1, 3, 1) (Test : PASSED)
+time.localtime( 59 ) returned (1970, 1, 1, 0, 0, 59, 3, 1) (Test : PASSED)
+time.localtime( 60 ) returned (1970, 1, 1, 0, 1, 0, 3, 1) (Test : PASSED)
+time.localtime( 3599 ) returned (1970, 1, 1, 0, 59, 59, 3, 1) (Test : PASSED)
+time.localtime( 3600 ) returned (1970, 1, 1, 1, 0, 0, 3, 1) (Test : PASSED)
+time.localtime( -1 ) returned (1969, 12, 31, 23, 59, 59, 2, 365) (Test : PASSED)
+time.localtime( 447549467 ) returned (1984, 3, 7, 23, 17, 47, 2, 67) (Test : PASSED)
+time.localtime( -940984933 ) returned (1940, 3, 7, 23, 17, 47, 3, 67) (Test : PASSED)
+time.localtime( -1072915199 ) returned (1936, 1, 2, 0, 0, 1, 3, 2) (Test : PASSED)
+time.localtime( -1072915200 ) returned (1936, 1, 2, 0, 0, 0, 3, 2) (Test : PASSED)
+time.localtime( -1072915201 ) returned (1936, 1, 1, 23, 59, 59, 2, 1) (Test : PASSED)
diff --git a/tests/ports/psoc6/board_only_hw/single/rtc.py b/tests/ports/psoc6/board_only_hw/single/rtc.py
new file mode 100644
index 0000000000000..e54471aa4e56d
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/rtc.py
@@ -0,0 +1,109 @@
+# import machine
+from machine import RTC
+import time
+
+IRQ_COUNTER = 0
+ONE_SHOT_ALARM = 0
+PERIODIC_ALARM = 1
+
+# Tuple format: Year, Month, Sec, WDay*, Hour, Min, Sec, Subsec=0
+# *Note: User cannot set a wrong week day value here. PSoC always calculates the right weekday using rest of the fields.
+initial_dtime = (2023, 1, 1, 0, 0, 0, 0, 0)
+
+
+def cback(event):
+ global IRQ_COUNTER
+ IRQ_COUNTER += 1
+
+
+def check_rtc_mem_write():
+ rtc.memory((2023, 1, 1, 0, 0, 0, 0, 0))
+ print("\ndatetime to be retrieved post soft-reset : ", rtc.memory())
+
+
+def reset_rtc():
+ rtc.deinit()
+ default_datetime = (2015, 1, 1, 4, 0, 0, 0, 0)
+ print("\nRTC reset done: ", default_datetime == rtc.now())
+
+
+def set_alarm_ms(rtc, alarm_type, period_ms):
+ rtc.datetime(initial_dtime)
+ rtc_irq = rtc.irq(handler=cback)
+ rtc.alarm(period_ms, repeat=alarm_type)
+
+
+def set_alarm_datetime(rtc, alarm_type, datetime):
+ rtc.datetime(initial_dtime)
+ rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=cback)
+ rtc.alarm(datetime, repeat=alarm_type)
+
+
+def wait_for_cback(timeout, exp_counter):
+ global IRQ_COUNTER
+ start = time.ticks_ms()
+ while IRQ_COUNTER < exp_counter:
+ time.sleep_ms(5)
+ if time.ticks_diff(time.ticks_ms(), start) > cback_call_wait_time:
+ break
+
+
+print("*** RTC Tests ***")
+rtc = RTC()
+
+rtc.init(initial_dtime)
+print("\nRTC init successful: \t", rtc.datetime() == initial_dtime)
+
+# Make sure that 1 second passes correctly
+exp_dtime = (2023, 1, 1, 0, 0, 0, 1, 0)
+rtc.datetime((2023, 1, 1, 0, 0, 0, 0, 0))
+time.sleep_ms(1008)
+print("\ndatetime is accurate: \t", rtc.now() == exp_dtime)
+
+print("\n1. Setting periodic short alarm to be triggered repeatedly in few ms in future")
+timeout = 1000
+cback_call_wait_time = timeout + 200
+set_alarm_ms(rtc, PERIODIC_ALARM, timeout)
+print("Alarm period set to (ms): ", rtc.alarm_left())
+wait_for_cback(cback_call_wait_time, 1)
+print("Alarm expired : ", IRQ_COUNTER == 1)
+print("Alarm set again...")
+wait_for_cback(cback_call_wait_time, 2)
+print("Alarm expired : ", IRQ_COUNTER == 2)
+rtc.cancel()
+wait_for_cback(cback_call_wait_time, 2)
+print("Alarm cancelled successfully : ", IRQ_COUNTER == 2)
+IRQ_COUNTER = 0
+
+print("\n2. Setting one-shot short alarm to be triggered in few ms in future")
+timeout = 1000
+cback_call_wait_time = timeout + 500
+set_alarm_ms(rtc, ONE_SHOT_ALARM, timeout)
+wait_for_cback(cback_call_wait_time, 1)
+print("Alarm expired : ", 0 == rtc.alarm_left())
+print("Entered Cback :", IRQ_COUNTER == 1)
+IRQ_COUNTER = 0
+
+print("\n3. Setting one-shot alarm to be triggered at specified date-time")
+timeout = 1
+cback_call_wait_time = timeout * 1000 + 500
+set_alarm_datetime(rtc, ONE_SHOT_ALARM, (2023, 1, 1, 0, 0, timeout, 0, 0))
+wait_for_cback(cback_call_wait_time, 1)
+print("Alarm expired : ", 0 == rtc.alarm_left())
+print("Entered Cback :", IRQ_COUNTER == 1)
+IRQ_COUNTER = 0
+
+print("\n4. Setting periodic alarm to be triggered at specified date-time should fail")
+try:
+ set_alarm_datetime(rtc, PERIODIC_ALARM, (2023, 1, 1, 0, 0, 0, 1, 0)) # Should fail
+except ValueError as e:
+ print(e)
+
+IRQ_COUNTER = 0
+
+rtc1 = RTC()
+print("\n5.RTC constructor return singleton: ", rtc1 == rtc)
+
+reset_rtc()
+
+check_rtc_mem_write()
diff --git a/tests/ports/psoc6/board_only_hw/single/rtc.py.exp b/tests/ports/psoc6/board_only_hw/single/rtc.py.exp
new file mode 100644
index 0000000000000..3399427070fe3
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/rtc.py.exp
@@ -0,0 +1,29 @@
+*** RTC Tests ***
+
+RTC init successful: True
+
+datetime is accurate: True
+
+1. Setting periodic short alarm to be triggered repeatedly in few ms in future
+Alarm period set to (ms): 1000
+Alarm expired : True
+Alarm set again...
+Alarm expired : True
+Alarm cancelled successfully : True
+
+2. Setting one-shot short alarm to be triggered in few ms in future
+Alarm expired : True
+Entered Cback : True
+
+3. Setting one-shot alarm to be triggered at specified date-time
+Alarm expired : True
+Entered Cback : True
+
+4. Setting periodic alarm to be triggered at specified date-time should fail
+invalid argument(s) value
+
+5.RTC constructor return singleton: True
+
+RTC reset done: True
+
+datetime to be retrieved post soft-reset : (2023, 1, 1, 0, 0, 0, 0, 0)
diff --git a/tests/ports/psoc6/board_only_hw/single/rtc_memory_write_check.py b/tests/ports/psoc6/board_only_hw/single/rtc_memory_write_check.py
new file mode 100644
index 0000000000000..7d937ab4d4a85
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/rtc_memory_write_check.py
@@ -0,0 +1,8 @@
+from machine import RTC
+
+print("*** RTC memory write test ***")
+rtc = RTC()
+print(
+ "\ndatetime retrieved post soft-reset is same as previously set : ",
+ rtc.memory() >= (2023, 1, 1, 0, 0, 0, 0, 0),
+)
diff --git a/tests/ports/psoc6/board_only_hw/single/rtc_memory_write_check.py.exp b/tests/ports/psoc6/board_only_hw/single/rtc_memory_write_check.py.exp
new file mode 100644
index 0000000000000..fe307d401b771
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/rtc_memory_write_check.py.exp
@@ -0,0 +1,3 @@
+*** RTC memory write test ***
+
+datetime retrieved post soft-reset is same as previously set : True
diff --git a/tests/ports/psoc6/board_only_hw/single/time.py b/tests/ports/psoc6/board_only_hw/single/time.py
new file mode 100644
index 0000000000000..7a729621c480c
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/time.py
@@ -0,0 +1,82 @@
+import time
+
+
+def test_ticks_ms():
+ print("\n***** Test 1: ticks_ms() *****\n")
+ t0 = time.ticks_ms()
+ time.sleep_ms(1)
+ t1 = time.ticks_ms()
+ diff = time.ticks_diff(t1, t0)
+ tick_val = [t0, t1, diff, 0 <= diff <= 1]
+ if tick_val[3]:
+ print("Status: PASS")
+ else:
+ print("Status: FAIL")
+
+
+def test_ticks_us():
+ print("\n***** Test 2: ticks_us() *****\n")
+ t0 = time.ticks_us()
+ time.sleep_us(1)
+ t1 = time.ticks_us()
+ diff = time.ticks_diff(t1, t0)
+ tick_val = [t0, t1, diff, 0 <= diff <= 500]
+ if tick_val[3]:
+ print("Status: PASS")
+ else:
+ print("Status: FAIL")
+
+
+def test_ticks_cpu():
+ # ticks_cpu may not be implemented, at least make sure it doesn't decrease'''
+ print("\n***** Test 3: ticks_cpu() *****\n")
+ t0 = time.ticks_cpu()
+ time.sleep_us(1)
+ t1 = time.ticks_cpu()
+ diff = time.ticks_diff(t1, t0)
+ tick_val = [t0, t1, diff, 0 <= diff <= 500]
+ if tick_val[3]:
+ print("Status: PASS")
+ else:
+ print("Status: FAIL")
+
+
+def test_boundary_us_cond():
+ print("\n***** Test 4: Checking boundary conditions *****\n")
+ max_tick = 15000000
+ tick_var = []
+ for i in range(1, 11):
+ t0 = time.ticks_us()
+ time.sleep_us(max_tick - t0)
+ t1 = time.ticks_us()
+ diff = time.ticks_diff(t1, t0)
+ tick_val = [t0, t1, diff, diff >= 0]
+ tick_var.append(tick_val)
+
+ # At least 7 out of 10 should pass
+ pass_count = 0
+ for i in range(0, 10):
+ if tick_var[i][3]:
+ pass_count += 1
+
+ if pass_count >= 7:
+ print("PASS")
+ else:
+ print("FAIL")
+
+
+def test_us_deviation():
+ print("\n***** Test 5: Checking wrap around condition *****\n")
+ for i in range(150):
+ t0 = time.ticks_us()
+ time.sleep_us(i)
+ t1 = time.ticks_us()
+ print("[instant, t0, t1, diff] : [", i, t0, t1, time.ticks_diff(t1, t0), "]")
+
+
+test_ticks_ms()
+test_ticks_us()
+test_ticks_cpu()
+test_boundary_us_cond()
+# Enable this test only if needed for advanced checking
+# test_us_deviation()
diff --git a/tests/ports/psoc6/board_only_hw/single/time.py.exp b/tests/ports/psoc6/board_only_hw/single/time.py.exp
new file mode 100644
index 0000000000000..02b80e5cf0f81
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/time.py.exp
@@ -0,0 +1,16 @@
+
+***** Test 1: ticks_ms() *****
+
+Status: PASS
+
+***** Test 2: ticks_us() *****
+
+Status: PASS
+
+***** Test 3: ticks_cpu() *****
+
+Status: PASS
+
+***** Test 4: Checking boundary conditions *****
+
+PASS
diff --git a/tests/ports/psoc6/board_only_hw/single/timer.py b/tests/ports/psoc6/board_only_hw/single/timer.py
new file mode 100644
index 0000000000000..f0bdb4f1d36fc
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/timer.py
@@ -0,0 +1,78 @@
+from machine import Timer
+import time
+
+oneshot_triggered = False
+periodic_triggered = False
+
+
+def call_oneshot(timer):
+ global oneshot_triggered
+ oneshot_triggered = True
+
+
+def call_periodic(timer):
+ global periodic_triggered
+ periodic_triggered = True
+
+
+def test_oneshot():
+ # Oneshot timer
+ global oneshot_triggered
+ tim_oneshot = Timer(0, period=1000, mode=Timer.ONE_SHOT, callback=call_oneshot)
+
+ try:
+ # Wait for 5 seconds
+ for i in range(5):
+ time.sleep(1)
+ if oneshot_triggered:
+ print("Oneshot timer triggered")
+ oneshot_triggered = False
+ finally:
+ tim_oneshot.deinit() # Deinitialize the Oneshot timer
+
+
+def test_periodic():
+ # Periodic timer
+ global periodic_triggered
+ tim_periodic = Timer(0, period=1000, mode=Timer.PERIODIC, callback=call_periodic)
+
+ try:
+ # Wait for 15 seconds
+ for i in range(15):
+ time.sleep(1)
+ if periodic_triggered:
+ print("Periodic timer triggered")
+ periodic_triggered = False
+ finally:
+ tim_periodic.deinit() # Deinitialize the periodic timer
+
+
+def test_multiple_timers():
+ global oneshot_triggered
+ global periodic_triggered
+ # Multiple timers
+ tim_oneshot = Timer(0, period=1000, mode=Timer.ONE_SHOT, callback=call_oneshot)
+ tim_periodic = Timer(1, period=3500, mode=Timer.PERIODIC, callback=call_periodic)
+
+ try:
+ # Wait for 15 seconds
+ for i in range(15):
+ time.sleep(1)
+ if oneshot_triggered:
+ print("Oneshot timer triggered")
+ oneshot_triggered = False
+ if periodic_triggered:
+ print("Periodic timer triggered")
+ periodic_triggered = False
+ finally:
+ tim_oneshot.deinit() # Deinitialize the Oneshot timer
+ tim_periodic.deinit() # Deinitialize the periodic timer
+
+
+if __name__ == "__main__":
+ print("*****Oneshot Timer Execution*****")
+ test_oneshot()
+ print("*****Periodic Timer Execution*****")
+ test_periodic()
+ print("*****Multiple Timers Execution*****")
+ test_multiple_timers()
diff --git a/tests/ports/psoc6/board_only_hw/single/timer.py.exp b/tests/ports/psoc6/board_only_hw/single/timer.py.exp
new file mode 100644
index 0000000000000..82f45de6809d3
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/timer.py.exp
@@ -0,0 +1,16 @@
+*****Oneshot Timer Execution*****
+Oneshot timer triggered
+*****Periodic Timer Execution*****
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
+*****Multiple Timers Execution*****
+Oneshot timer triggered
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
+Periodic timer triggered
diff --git a/tests/ports/psoc6/board_only_hw/single/wdt.py b/tests/ports/psoc6/board_only_hw/single/wdt.py
new file mode 100644
index 0000000000000..3b91e105572c3
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/wdt.py
@@ -0,0 +1,48 @@
+import machine
+import time
+
+# invalid test cases
+print("\n***** Test 1: Wrong WDT id *****\n")
+try:
+ wdt = machine.WDT(1, timeout=6000)
+except Exception:
+ print("FAIL")
+
+print("\n***** Test 2: WDT timeout too low *****\n")
+try:
+ wdt = machine.WDT(0, 0)
+except Exception:
+ print("FAIL")
+
+print("\n***** Test 3: WDT timeout too high *****\n")
+try:
+ wdt = machine.WDT(id=0, timeout=6001)
+except Exception:
+ print("FAIL")
+
+# valid test cases
+
+print("\n***** Test 4: WDT created successfully 1.5s *****\n")
+wdt = machine.WDT(id=0, timeout=1500)
+print(wdt)
+print("PASS")
+
+print("\n***** Test 5: WDT feed after 100ms *****\n")
+time.sleep_ms(100)
+wdt.feed()
+print(wdt)
+print("PASS")
+
+print("\n***** Test 6: WDT feed after 200ms *****\n")
+time.sleep_ms(200)
+wdt.feed()
+print(wdt)
+print("PASS")
+
+# reinitializing again fails
+
+print("\n***** Test 7: trying to create WDT 2nd instance *****\n")
+try:
+ wdt = machine.WDT(0, timeout=1000)
+except Exception:
+ print("FAIL")
diff --git a/tests/ports/psoc6/board_only_hw/single/wdt.py.exp b/tests/ports/psoc6/board_only_hw/single/wdt.py.exp
new file mode 100644
index 0000000000000..e375707b92799
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/wdt.py.exp
@@ -0,0 +1,31 @@
+
+***** Test 1: Wrong WDT id *****
+
+FAIL
+
+***** Test 2: WDT timeout too low *****
+
+FAIL
+
+***** Test 3: WDT timeout too high *****
+
+FAIL
+
+***** Test 4: WDT created successfully 1.5s *****
+
+
+PASS
+
+***** Test 5: WDT feed after 100ms *****
+
+
+PASS
+
+***** Test 6: WDT feed after 200ms *****
+
+
+PASS
+
+***** Test 7: trying to create WDT 2nd instance *****
+
+FAIL
diff --git a/tests/ports/psoc6/board_only_hw/single/wdt_reset_check.py b/tests/ports/psoc6/board_only_hw/single/wdt_reset_check.py
new file mode 100644
index 0000000000000..336de82ca4dff
--- /dev/null
+++ b/tests/ports/psoc6/board_only_hw/single/wdt_reset_check.py
@@ -0,0 +1,6 @@
+import psoc6
+import sys
+
+reset_cause = psoc6.system_reset_cause()
+if reset_cause != 1:
+ print("Failed as reset reason is: " + str(reset_cause))
diff --git a/tests/ports/psoc6/board_only_hw/single/wdt_reset_check.py.exp b/tests/ports/psoc6/board_only_hw/single/wdt_reset_check.py.exp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/tests/ports/psoc6/inputs/test_fs_large_file.txt b/tests/ports/psoc6/inputs/test_fs_large_file.txt
new file mode 100644
index 0000000000000..7f8253bdd17d5
--- /dev/null
+++ b/tests/ports/psoc6/inputs/test_fs_large_file.txt
@@ -0,0 +1 @@
+gdrtjcucejriibvibzlawxkcbmoiggawnthltxcegbewwuhtzknxnjrkiaqaiuwlmgpymvesrusogpjriaibxqcfxdlmerdoiijmijfzmgfkuepeymzqlqzyufizdcgpccrnecfrinafbzolmwtxeyxxuewnrvxgusnnaeflqgxbbsuykjtivvwnnawubqzuaxswoerjiimrnqaartuflwhdpmtwkdyxnqswkvhgtyhguijjzjqkpgkyxtpaojuylzdwlfaniyrefuaapyidofljnolfqriapvrltijwwlfnuoxezuzhmmqorcyfuimxjjxnkiiurcoiyzqkxggshvfiqlubpmsgebvepwtvsrbjxzydticydzxgguezbvfkhwnjkctvfdmkbgdsxihugneolybnjflcczhlgdbdkscgpwwfvfzqlyztjjtehdcmfnffwavvoviqleqzbhvhhhevexdplrlwjkouzurgjsirgpqrozdyeyvjdeklwdurlnvpiknybxilqxxboluuzhmjtedhrhvjcdecmvilkpleyxidbcdqmutwzhwfiyewzgkwfxwavlolzsvamplhiyafszmdwzlrfdsropkvclpmddbvelifbiuwwgivbnwwkiizjdexftskulywxlqlnwyiylcaniasttgqmaulnapwtevvhfpzpztcoshtbwicounwyaszrhvvzacnsoxilmuepoprlwmpphyisjjhdrfoiceieahikijomxsotdnskwuoatoinmgmatjasmrtplazdrutlcgstuuitfmjndfhdxddbohpybaiuxgrzbyglyszaifisbtdiamoxoxaatambuduvsxwofaetieopiendrtxktimhgeduhyfonqbdpnykaspvmhjsrtrvhdbwwtqujujtfgddqmbzurqnywzvxuegtcphuadrstaijuqrhmyntzbrjexrivrxzyjgenqtzclfheicwkqoxmgbuuyplxjdwkgepvfgpgnwrzqxllhgqqtyleecucrdgpqpbtqhjvdfwhlizxxkmppuspukagwlchaepfphrjnyyxbpqhbcuhkezurtwbkdeaneekhbxxpgkknpnacwbnwsvbaszdaynalbceklsejphybopbohimizqqyddvajjedrjqeugeniohudpledcrxzyntjtrlcafxzqlkxkiuitrxghmkvhwkhskpqqhpngrtbzthsxacjfuexqjabmrkjzunbjzdxbgddjaubtsttopsybgccxbwfcacnpzbpdohypetlznjemwefggiliiuplweapdudzouevlfhtmgdgaqglwtgakugtvshourlcdmsrvsgyexzbxmvelafvredkgmvimgvktawgevfttatfjajpdssxsmyivfoyvkzezbxmxseqdxdzkjcsercychasywzqowtufpaeulqorjycyfvwkxpcsbuqwujvfmmtntywcnzbpjglwgyddtvwqslksatrrbzfilfvvfbefweltnkdyhinjlmgwqurgmnriocuyslsmctdivzwoplspsqzbgjqzhnvdixnvqodkplgbrxxmcptqcijmjetndtsrwalxxlmvgbwvfrsmcfhtwyxtlrcmzevnaxagjudbynepnpzncrlvejlnwfgyzojlrvffpqroeikzfccavjkzyhfpnjpduffnwkcpqwmuvntbxwxafehasdczmegedvnbglsymipzepxakegpgdagnckqwgwbslickfdrpxqygvnloybcfxgeuprwpyqgwujhtfcnydhdwrlukdmmscaeepxkvocfxmreajssvbjfdldrqbtwidxclevfacoxwgkrmukiictcdrkngbdhwbynnzzfdpgemsoxoxverojbobuszcywuvbhjnyluwqsdxrtdhhhgfifxtwdzcqavnltfvtudarsynxaeaztpuohzcbxpgoarvmexhevjxpgovypttpwxlktetywznjvaixgmgseisjcsvvdasimcnckyywbrbpyinnxnmlagddjmspwuuejlpmwnxbcsrsycvacszxcjnusugriyoafxjbdnpyifonpidpgisfbodisonvxtlutabtnupdsijaybrnxbtkdxbamiljpjahjbttyyaxlvbalridxgctufzdorhuhksihkogxlmnwedyqmezaebpwpvssqavdrrjxxptuthkbfxdikkxzjokhxyjcpcpgyczehzmosjretsaxkkxmjvsvfvtgzfuqgshzpkmveqdmcboojwyqmnpxalnibmsoesktrruwxnnkwpgxtscwuhxpaimiitcjkpsgmpsjpmvofuagnkwkxqmzmmguofjzwqfrfopdklksoxwyglunyydrcpifbipohkhrofnduxegkrltkudkplzgnyinvutkucgnrpoemieenxaamfpzzujfksbqqkxirzftaawrmgwunybtsnjtfmayeruritpzqzxxdxzgdnwdsfhmceoeenruvquhmtoynsyeqrvaijjozjvqfffblejjkcfgxqrgsehfzoxdmjerolyaqloimrqnbktlqapiithbwbyrrepgarofbfhhobzlkicjurdtgujbxjqfhisopxcrqxxspkxeujhbmtxbibtfiilneeahtnznrbukaxuyzjcybwcfgawwkkgnbqizzxnddlmrjspzqajaiyabenwkpmxhhugwqxduozokzklcgzowniayccfjevmddcovnsahafpfyycshsixlkdrklkxjpjvarjirggixilsvewrcwdmdabbpchpnwhvbouauccarswqmotnqpdxibmrdftuzohqmiyvwmqhqpohurejtyicqjmqrgwqralqmziomlrcsnrktukgunrbkfwxkdxrpjjmnkhkbcgaaqseqoifactvcrdecskbrjbgmyhsjthjfofaqdvgrouzclylvkfvcmqynmvgexdihjcyyecxtlvmougpzyaostborciscqvhtuwajujtaiigoactetoybfcycljaulvxfrpbyxilmpqxjblbwadhzmgqmrgggmfklbzxrxxqrcngxhpjfxedskezudhbngiihaxknsioqcfuyvsugmpvnonlvuzvsvygrixqkfifnfegwwlrhxxbvsttlstptuuotzxylvghfaweoiylrbolawtdmzxllxageimsylidjwwnibxukuzctvnjtodinaoaicptuvplmmrqawrjqaqtlubwyqbfgvjmxqknpkxwavdkyprlhbrjogabdgxgzagrofgkxdhorhhxiqvudhcbrmjdgujtfwtkjuqiezlhzcrwtjtowyiiajpjurngkjgdbltdfymgfdsmgsynwcholrblvohhzrfzrskmrapxtllavlfvoimjiikcqmocpcoqicjjohmdmvhxiqzgotpnbpucstmwlgkhocdkjdgehnwlnbexmzcretgnaflnrnteaitzvklfvejmutxusefbxsgtqoekdgfglmqztcslhkdffupcnlqvoypsqvxsjfxxjjjiubxwtkihcxskianrvpjbjemdexibblnixlgrkpayfeacrcdejeroxpwigptepcielishddodqvxlnrvvovcfzipkzvgqwhdjosbmtcukrtkzhlmofsbhhybivtessmpanqpfkyrnkjwxejnrcznjtuazigbuwghgpdbrqpdongklmkhjkpueglhvksjojxnttqkftqpdiqsodpzokgmawbibcpivntvpzixmkxxcesrnictgoomvedwvcqedztwlwbwgrcnnafyxcwwivsydtihixwfymvehwbrwjbxnbvuhfnhvdycrnnevjgsnnasgzkbamgkrhdgkskknvfymvbnlnpgphubbxesmtqscehupngodcuahtawvwupwctzxsvhefunvcuiphkigkymwqsydbyvhdozgxhlvrqlwruvzjrjaysyghcipzyxbrlrkkvhxkbcxqmdbhnnhhwadcdscmcmcygwwpmuqdlabsmnwjoqkckcfefztbubsfftyhowrhcjqxnbkqqdavubujnaiddyonurksbdamgscnskfcvqbmxmhqscaqslvtvojznargabeizrvbktyxlcqxggdfnatbqhytizaqjxalllrxbdhuxwalcsxxxhfvnimaojlbcfrzxcvvmtmzihmisvripaqrjgbscybwcvqzxvkpropypviuvyaqbgwrphujeekfjahpbaolvqjdfqhermihsvkjcjbzfxcyqzvkkhegnmqowbzudebxyiwromlklnaetbosqzlacdnbfdfmasomplddighzhaclsaotsvubmtfdsfikkkhgacwixcpvoadlfygxbnicnxbkxqlqfhawqhcunapsalyfcxassvsyiwtakeueponutnrpgvsocxnuscmofofinmefdjkkandxjofznynawxribxrblocsveedergyhxerhodvzflrjqrgjfwcoimnlonnowkbzxbshwdkafkuoripvbwgvdiabxleszzywpufdrzcwewyqxevysouoytlzehstxaibuoiklemvdykkpopletkfysexbeckeabmjsmfaverucmulsvazrmvulgafeqbymajfpnjjsddxmvrtctuzwgfvekvjfhiwbufqiwatkvwlzcxavtlaauxppmgbfcsgpdeyaakxwpykqarkzdrcpyudxwssyaucrmdaivfuvpvpqigmciumcuazbrtobgjfwpqvowtycxkbfyntukqzlmkyzgyykhijchlwaretrdnqiwztpkpvrvytqdzatzhmufosuofngfxrpdcwdpaausubccyqojnkxbdxdywcazvlrrtzeoposwjnkhentgmwfivqwjcyfngiirzicprubkfevlhdjcdehtsmrhtqanffbkshxilafjpbyfwuxysailgwuulagnrvspmhmuzxrunvnqgdtfxuhahtirlqermgqukknmgwmjplbfjgubgstdnjirohimmqvhvqssrfzejdyonnkzmzniswvhdqxxmzlqzpumuowzbwkbzakcsjferashxjltlvtpbsumothhxeefhsettiaoouebazhccwnspkdfcrxkzqmocyrnmfvokolrhyhzlhjgcmrwvbmqpbxxxnhkwtzyxtgpwccbaitrwxhiduwavpvtyecfqknpbvauuzxruhvfmtbqdgcbbxndxaammzfiaibjglmkcldipezhqellanndooecmjfdxzegfjajvnxyvhpirfexoisrfkgvwwyukmnqxydrecwxgcfgkkrrfxccrgqmuyknyuinkgpezkffffaonmgngkegnaqcydhbrnmwhoykplfuoyesfuedfnjrpixkmszygvdbcykajgaehilfkoafamlrvhekscwjgebixujnidmjobthxfhhhfewxhpcqobohbpxsujdoqvcxvpegxhvcwrifxoxvbdickkbcwoginqgdmwraaymhxecfciqcqrqkzxbberjtosersdsarhcwyshxeejzzelgywnozeylwztbmeelpgpfaeorneijwocouedulhkvavnnipcxmutxwicexjzutxxzrvmdjnhjptucahbvzyqfoetenushwohfkoqcfuqeojdsvpjffqkhuzbutfhiytzbjrvdzhoetmeseltxbppmddfqiowoecrzhscsftnnyphmjnsmwhjuehhfigwfvqhzouhlubzlcvxafqtrppqwaqzsjgdaeunuaggvontnmzffujfjqdsmsjosrzqppnqbasojxlwjvyglrocomckqittsvwyjzpcudrrhomogmsfhjmwmyvtvdserxgwnszvwrckhspttktmvmpvtnxwxmuvjpsknzgyxvlvguosyjzkibnazemhxbhlftzdyejzlspdovjawwhriokdhxfnqnjbhjogwrdfsrqjoecahgegubglwtxczyaddhneoilrvnxhlrmzsmcccahthnogchhkfnlhukxvbfvhvwdtylfabughompljcicxzzyskamodntbxgxwhpazguvleyeinkgwqusvtofbmqriclojiqbkjdvylghajhqjcbekegxwohfvlbimrcbqebuamfqumtknisxkayesjvwqzrmubrrwuixhfomgvpvodqeaancholwkpdfzjqrmxlzrdvnlruvzlilitwdeojdxzocprucliprpmujmmpewcovlapajbhgwsglypagylahzstcapbauccbproncuszffdbxwfawkeqofdfogkdcpkxdbcwjyldtgaqgvnqiyfswxwaqzgpgwvqemlwfylcdktdmjafwwhrtqjpqpqmhfoqkzewbtoofamzbumncwctpujawwlfzvnsppmzmyvhqxkibfodxyyavyuzbevublnjzxdwzmsadhnbuesxbuzrgjkyjyeshpfqudxiishumjkufazuegzivzaqopmizzwbqtoopgguudikolgtuwtkjnsxkzonjsvydfrfywovvomoqdyoalysfpweqqpntpfdwkgsclbilmjkzzcjlgzspbldnpmnmpawqnxmupbzcakcikmvdmchpaylabbkvpytcllagmdpsfusttwcrdzwafzbchyhkqvhtcaqayhupiltfodxqelrmdwhxbytbntbuqswerneavsqyeefafjqykpwrmxaicoddiaasdyhypbiteugsgyvwnyfsewfinvqcbxcznpcpfmwmieyfgvfttdzbgcwbvervqdeunakgsgwafvfdybgocpjztvnzkqwlrstznghwrnbgkxpyyhjefauyzvuzpicelbhcqfpepziuyqdggtgbcbpbvsymifeddsrfqcdmgumdidcyqejdedpqttddqlcbevepbudnhgfwcbazqjreolpztayplrrjodkvnaqkvhxkuqlhbslitmqfanuyygqfjybnwtdqzxvlzjwuoxjsskiclugyvwwmzigguhmzjwotkgbbcjzbcjvznuhoswbswwtdykphqypsqzfnphauehkjjrmepsrkxzlzueucglplwknttnrrashnsiiaqpnkknibtznylrpqaiatdvfxdfvtqwfzyodjmayqdjcpoxvatwjggetxxsuoxpavrwhineakioxiokthkoksjxepgtoufbybnvqrzdslnijwwsyzqdodoblrmtnvfpcgephnvnxdivsopoimgrepygronbdtqvetvujqzlhgqfgitunaaxuvmfqdtcgbgohzkscjlsaaaymfkjksvyxxdpqziyvcrvqfoomvvgmyveoubcrllgvbjvzoyuhikrckbfmcpaltpxscyystelznlnyxlnrodkhihhcreidocnstoyrvhbpclrdhhddizgyhjeonyrourzeohnhrxipxgalfmtvgjyuoxclpdhpjtkhjgdndhmlkijdrjezerdqzrzdusrveeyeisbtuixclpffbyscpdffwawkxlfbrzkpxcaxmnrqgpumlbknixvfuoovmibmaotjxaubrmmrhdaskrfcuwuymkbdfyhwmbawemuznyaplqrveoxrfbqenfflhozdhgfntfmllninkolxzgcbfqnwaaguchawajyfvxrpvhconydjknxbtrojxvhfgoxbupfiadqvvmckenbiymnomunfpoirpzzisxelnjyawwjbudpzqkohtumdrvmyqmjhwferythljjddylksjjbutipliluiqnsgjqpdkchdswhzhrwvszpeedsxoyosdlwjqudtpvzqwrzhicpieivhspryfavxxpgjvsixxfvwyfxiouqjvefjibbftihtfzhwbfekohdqtdlvhhwgyisreycrrhelbgrxwnciwtwosrjyyxybgcnsndwkxmfpgjmfufqbtzubyzrvnlciqjvpdzmbqgedporpeyzyiahwcchsqtaazuydgdeugvxipopvlirbcxwpulmzwkcffahwashbxjefcpzuaayyvmaytswsyuzlnulxjjdxkrzbwgenfbhaczmreharltbjwezhxchzcqlwgmypsoddhbpknblxhamvcfbfandpiwulnwakywljyelxaugdsyfkfuglbvexvbuprcbqtglyvwuncciucxsbpdlycmomnwldfuzodnkhsyxunbmrcpoabfsnhpgnowlusyrdbexzzqmbrzqsrpcizmbiywjycvhkscsbaasdyuviewjoizyusfajhtjwvxinwcqjgyjerrqbhdvucnxwwcgswddqtznrvhmixfnxdqyndzpgdsjgijvahtmcjddmborduaxpvyftaooyujspvfjasggzwbdtonnotmtqmbixrvrnrthnceumahgewszukgxaiytgvgkgozoqqojpuguzyvixpeygidyeblyqbhylsjtjulswlrnyetnqnsgwzhzsafvxiiejbydtuamnudilzizlvtycovkuiixczinphqvywiigiccbrgessdkeeepcygqqsjxawyfkztghokifhnztdaxzgpdmzdpjrgozovtmvhcobkeqhsvpzgeclaphxuysuyconqzkbmmbdbzfozyqytoekzitjdszhjeupuzrzzqytdncnqxhveywjlqbwuuomtqlmbuwdxdghytedijlhepmyqfwcbjbjlyxdiaiowdaxlasumthglwqeccdzkzhpsgqzpxmhubgvnkexhohiflkgmsiwwhdgjdaatlmuvhpbqedtgihzqmcgflrcpojrnmwfwlnjdcqsjkmjkaozckqigumkuumjnwzfvnsnmivlfjeuueasnefyghtdehqsbcfcteytqminoaewqcnotwfsevtwqsvzcrkmamfnlsmkdyovbnnpaterdxuvraypuufefdxnmsmbrjzhplnyjhzsxfjofmolfxjovzyseakjxxgizxhcstwhuwuwmcweutwkctchibejpszjmawfywzlefdtzoqhqciaowthouonbegtrirqwsdkskkhiohcxcvvdmivbmxcyaqbilhqcacvfnrpuhwslxqprjdtiiwiedinlmskmeynlnqydmzgcncgsjaqdknepidqhvnouorinvhdvcazrggmlmzhfapjfglkvxpkzemmmbwkltajuzjbueppevdyeyguebxsaeovnelhoxgmsnjwvumbvztovaynlyzatekifnbijmjybbqjlhdaobufhdtcbmzoqjwabmymvomyvjymownrqdizoipgcoqllzlxflwyhqndlegoklxygjjwibmmknozmeqcyahfzmnczfbcbuhbvwzxlxcaalucrwlrknsunxrokbwsyasxrqkyeslpewgnwhfjrpsypzluzweasmqupbldiejjfcmnjdkxxxwtxnygonvsphyeshslqnqwmaxpiubikokmgmjmtkczxrwjayoaaxsaprdwlofnqldjlqzngotydzjnhbflrpagyatuajdnskbiushorvzkkyzlwnnzyfrxxmoswzhpqlnkscevnwhztmuomglhjyegnmwtdjjrueggqabmywysdqfzwoptrlnccbuonxabcpcxjwophaiqjuipglbrcphsezehwkjniswowyuybphpemsxfvaudgijbijhlgheantvizatchjlocxcwhsvizrhqtbjqcrkobqhxcboiacgvysuhdjjikfhneswjuzabzzmwalkhczgnldlcqsafwepoqcnifxavotvjzpftvvuugfyjjvoaocwaxejxtbahlpkwuwwbmzgfxbutddlkpxjhxzejpfankdlopsgbvkjgurfbgwnteibtrsaplnzchygnlojkphgmdbegavzmwqxuomsezjgjrpsnvjcjnvqcuebvwrcvqhrknvczwvatsyboumsjiujysgdsycecssdfnqidirhwfndbdnivnfcwbpwiuklsqilpqyieiswyzukseemqankecuhpawrmrsmjsmppnpyifytmnfwybvpldxajwwpdqwpdiqeevctjghdftwnzhdkmgyjwqpkgciyaipiitvyibixpyjyrwczqcawvtharzgjsrrpcysnluxspcheypnbnybixsbrxezfkhjfzmbyuzxasctneywwegnatnpgvdwjfqtzqryekgukmztswsiyygvjhrqjgaigflemesoctseubyndydvuwwjslpytsnmvsnlofodgcyewckavsrrmwudvizwhkklmyfskyeuymihrtomiscnmoqvpwpvmedjqzmqknenduaqmpzwiusocptezkmizlabrjzuznriwnpegvzsjiokfqnhomclrqjjsqdandryznfoykwihsqhlmktyiviudbygngxvisfsrajgrpauagcczquxjsfxzoucakafhkgmxbvbhwhaqpgbmtzpyshkqnyfqiaguntbzisofnqoudxazxdylkjrnqjokutmpklhxtjnxxnbwwylrtrnavfnctnxqvojjgmrtiawbtbkggdqgqbuoxmjcxpjardpzmnhaotrodfvgclaineatimqlsbvyknjpfnkvicyqhkmxklkcqlugshbcmnnahjdgvjdtckorosxomaxtsyvlghnwrmekiqdcjjfsqzelihoypgtcxeabgeobcglnnmayzqifygopvchbzaxtxqofeazpwoloyzywdezttzhoslsbyivcbfnekmhowyxavzouamilfypuwcblljytskjohxzrsexcqcpvlsxdppqeynksnqdfgwwqiiilhnuueiljdpuzesrguwnvfdrxoknwcymjxcbybmyhurjnrfwejtkbscjvtmgoydujzdaelugivrrrrxpjlhnbuvkdmhgywhvdjijykorlvpvmtcmquoxdyqngtvrjcmjmbsdumtrmopakufobxboienimnwcfdfgfwyxxuhwjozsirgiocmitdadwkjuumqvzkvqfqdughamycsaigjcikgrkrlznrwfwtogchgwjtudmrlprtqcpahkbvxkualngxbjehxgynuwlpjbewybbrlyizojnydckgjlvnxnfugpzohjyzhgeyudfsjopdfvwrizivqkezpdkjzwmcztdkgiavfysrbuqgsbuonfgfsibuejjlmyocsdhmbhumdbqnmqxnjlneerawtjdlnysuogyfqwdllxuhloqbeooazqsrhdjjqcjvwqmjqerripzensrlsuifugfrvqoudgrffjockmseiqpqujcslxpjmoabeyljntnmywvkopswoiniynlgnwsjulzlhhfucsapvisrwwwrnnziuikruwdpncixcufdyprtddnllusbtyzseddaoxorcwsfebfjrhoibycvdfjbdtjhidtptyhwcsqfvgmiecrbfoybwhsnjfyucddvozlgsimeupjaxvtbewokljlmnnarggtqyjaeiatxlnoveqikrppqmxutiocacvhmruqfwgvtvailtyryshdeoyvoatxoammhrmppmvblwnldyxcbhiobwofxeiynzhyaqhhivfwpdgpfjpnzhsegutifvnzbrpgwrpfpsxzeinvomjoeunnaabwojojhfflecmiwhvqfsuoivhjcgvlkgegbtvfavvudjyqexxfxqyopshxwctgmioitlhwccgzjywjzpvmgymvhkmnvoavujrcmijmmmvvisuqrcfuwckinuefjcdoqmapwwvwfoaedldxftnopifanwvlxiegqtvyofgkzxkhdosgkmxzygjocpbipsvpsworawzdevkgvysbxayhcmzoepnfkslovqdebaabxozxbyofzqrukhrulomtphbfgcforndnbtgwptpgnxupneuqhnupksfushyjqcykbzcxtdtomavirvvgamtronmesjvieovyksyybshmqtwckbfpnqykgmuuqzesqameyhffobqspdswvotbvowaeorpaqoqzldekelhaetmhwrcomrsxcpsrfwdsmljcajmxamqcycuhsegxcuhvfiqbcccrzersqcbwlopvscyblrnxnicrbmysoutltneysrtcrndgntigcirunyukqdtkbksrxwxvgnjgerbdxtvflwmcaklkpicubcdgayvgfvdwwufhwyhieqvcydnmdbnyhjuvqvkqwldzvaiwrijluabjwzlxliwidqtwgldhtroukqpgheamlavokgpypotiomgbpllzcvuqixwawunuvmcnqyaqlatpwzwmuruhwellccrugdcswpamqevewmwcsdcewrxiisgcyalxualbjwycsxkvqmzxeplmiiemqonmunqavhenuugvrijizcqamnvtgbuxicdavyktpppknnoagandudgvjlucjtvvolbedevjtqkwxoqecvydjfmpglcblylcluzwceisrdekerizmnydjadmozmvukvgrfqzgqbcglwyinfsvisoudsooyarhevekycwbfdhuvjoespjslxdhlnlxuindqtqjjumbicdghsawmzlkyiuicbprqlaiwyoknocndwnkjbgjqoogtlobkcwwppkqdrmnnettfchmymrcfourlndvjiqzdiihhkpdhrgdwncraiajdabtpzqimqtzjlxyihtmabjjsvwbgsxifuejodyoqyqdtdguuxkitmvoowgjyktopmbzspslgirlscptzrfkopvmceesuopyyuvgjnqeqbbqdjvogqdszpqlqwzvbmpmujiivmtadvmyilokmzjjccjxpwncvnuzjgzsetxyciqjbzsqyeiibcctacpnekgttycrlidakrrbxvwdtixcqqruvxtlxzbjtddgvyhpmundayjicnzokzqvovxzbremsdiwyafuiadvrmbhfqifyakzlxkvhamfrbxkkqwhiohlxhvzgsbfheqccropwnnykrddncysqgxwjudwzjvbmjnhcntwmfxfsbrxxwpesjtkhebzvcqyytheikisypqakcbvbctombyzhtmnopfjuqncoyhnoypquvplixjrygktnsenxtbtkgftmliohnepipqwithtatwqyyobgrgfovpfouhswkoyorwblqmkhhixtgyarganpiuxffhmcxeesxntymjqygfgqapzvpcwdojsswsvraazpgqwukujwgxoueezlrgcbzoapmrrkpqmlmfpxcdyrmvzxslgzvxduuilnnkooazvfyajwmxvolwpczsgassnetwponlqerfvftailktidhlytqvekxxdtkbbmkeqbdyiqsiaztzxcxqfqkjaaqhaceaetiozqyakjhgcrjnxwzhnjqhcabpzmcnjxojeeulrkjstwbgsrwbgbdivqjpgdydnhxgzefsclsngdivivupddojyysjeebwyshjmhdieonsdjisvlgjzbmuzfwcthyomemykavxqmpkgwikqgudxubykuymcwoelhalqdpztivlcaiejynzzgiutgszyjnaadiyerzzpixjqcowhwwtggqighptypgdxjcnstyqwllmbpvwcnojzoyieyehveuogdmfqayypvyyxgrvuuljwrtqcynuvfhylxyzmhgyavenxjoomrobekdbrnfoekuyhsdhqudorzoyuvpegrafyrwruschijhbottspjpyrnkeehnnxzzjcjavixapmhdshlvqaqaumgtaylqgcnsvxulrbdrrxfxovbhyrwqwrwutinsthtxwvsymleuvhmzdjmidhqzbtfpwnzgqmvltzzajhkvvluqaaniuyqxaqnuhzvbambegfrldxgrrhxblvyzescmobdejrvxuoabiziltfypbaujiishndjhzjbmyffsjvrhmskdpagewdnmxnszguiwcqwmluxfifyrlxdtyvjzfvnqrnprwpmzpfoxnlrwklcnlylwsvfeeceicsrihvhtpxqosvibbavnwbaloicaaqyymrixcpcaikxwvqufwuwynuobcbevpgzkkjkoxtpoqeepobuvonyphvqtcztjykbbpcsbjscvupvvhmqzvlzbjqqmkoyroyapsodmwntfhqjfktiwxkloxunikulwwcngiewncqlvmnymhwsyebjbdawotvgdseabmzowmqzxzidnixhunsikxdrdiblhnsrelqttcgzatidargindnuorkkfdszzjzwwjvtxkwicgsqrndhexvmcuwynrfprroptqoztfblgtdbbysdbdeeuwfqqqvsidtownrxygwksromphwzvhjszgmkrkizlhnmgkkxxunisissdqjsivnbopbjahazbisfngpasdhxgjxqqhqfagyqcrzwarczlnofparyurayglppbmjakamnhivvmoabwixkdtyqahzejshbkmvswyxeqseaobdkxhvjhkttaphmycqdceyyhdagqktpcnwaxpuaidincsiwfcniuxonnlttegvkgaiwkazkrdrtkwiwdmkvsedejdinaaribwbhwhmigbonbjqzwlxdrvcpleeupwcukjotkrpobgmkmpezptqkzcnzlxdhpuppbjczhqnutuuifopzeintxlgmuacyxgrilybrevngvccemoazojpdzzsdyzsfdyflblijbmzpoysnvlmyexfoqmgwsxrpzpsxwkakfnuhdgaqmdorrtefrlcoqrbopgtmgcxisepfivyvukzffbdanpimfpncweboytromtkactbjufvsenqywjtmzkuaxpxvkchmarusvehuvpnqgtgbuimsrsazcvqmeqthygpxmfcucvtokfoufgmjafbtbxaejktdozuqzgutftackayocdejrmrmewwbhiolwjyxdcifjqvzsblochcidbvlzaiebtawefpdwkunbepvjyxfgteavbvqccafxvgouaqefpouazcknuxvnuptqhtdasjnhrcvonkmiqabzgdqlnvmopdvexshlinlclrtddnzmvqcqditfocxphrgpyqupukuuxqfkywenblsiwnokpppyrlggruzbeturmebnxxjanxqdqvujnlquwojhegjbfksfzhdurpiezarqcdrmgukoqjwfcryqwtehzijmewylszzmbsgwbugecmsuuzvlfmteklqovcszvcdglnbyveidohdvyocxwvmgveukifmipbekebwslplvmtciitpmhjpcgztsxuygggmikhasaaqarmfhxhuukdhbjgywhzdcbicqvldfbobfczcgjzekrsaomdbockwffhvjhwyjurutvmufzhzarskeigtgmcbbqijxarxjsohmuvgtccnxvsomlkgaxxuthlrszuzjqecjkdtwwjickkrjfebivhfcnvynkwkzheailikschcrkjpzjdqvsfbpgyqlaxaaodpddipmpajwiwqzuarufhljntibtexcxiovfcnkyoehqjhwvafjxvdirelhtimtndxfjcxsqsujyescqauokbwhecrbezxxuyupmnkqovbmxlllovyggxhaxyqhiokogmhejynbpyfpslyxtiebdmbmiazwvffhfifelnwhdqcqrchrlqulclvkjiirsvqxcmjsbftwcuhufzkqthpvekyyqtjloghfboeerzyaeuwmgnirntssxgqpswusrrvcyirhwvuwmscqpuwfanqycmxrszqsezdytdqhxamskzfggesofdylsbqmekkvvyjuuygpudwtjzuxxwwvgujvlqfzthzkczmdscriwbdyxepbfqbrudxmbmigiaauteougkbjxvjbazkrdtqhiepvrfikltxufegukpiexdniapxjlkmjdeohlmtlbtvdcojoyrwtwsughyahmnpbfbwiaulhdbtpmolcmdctkhsnqgxxmmbawrwuwwobqowcaenkgbdwqmeugbaqxnxrojaegveukhnnjabmfndhlgwramezjkldmtxvvoayepsgdffbhqatwjagwaoohquvfgqnlwasmbdaizgiqaiqiztouzfvcowiiejoenqxdpveajfwyjyjqgzrvvrserzcvyiyemujadgjsuwsfhzuyapjsskgittnirpiqtqawknmuqqgjpxyqfzlmqisuqwouoaodjeabhaerjfoynfwvvvyxwaacstlyadqsvypvsjpcyhznwkxaivnsgkquabmplyutnjimdhrthjladfsibzcxvlosyxmqihupylxiuvcjuwysinpytnvjujxyvmcefyaaguoqdzcndauqyyzkvqsjkzamrdsxoodvzbdzlmccajrttbxtfuhplnmapwjgmolbdgrewaywbqukeosegvzgpdephkwizxhmszzcisavxyfavbwewenwqnvbjjupxuuhrjtvxxjfzghbqegmfjipphsqztmnmzujtvicqiypzfriypfptloqsjmqypyqnpjccnaiuijmseuqzozifptzzqqwdcooivzrruanryqbtbwwfzpfstehojymiycfusxopmeshfegxcoddtabbatcjylegwhajtzfadmhheqagztedvykblimznfozywzpejxskrbkbkptnegvmwdwequemiztqkjjrcotmsmekbufkjenpsybtabnbcuaqqbvuivalbzsaehodqqrnobxrcunrwgdlckzeasgfwspfxtjfebtphvywsrzhpzskxjwsetwqznsiokyzdiytiwrdvbyrfowzliylghbbpboudgugzcxglocvbfhjoqlecbcomlktczycluxegvjxhalivqsgikkjokvmuvscutfoytbbiadbarveepyidnqpxkpkfnafdsxcwjrfboppvequvrgywxpvexpptlzllfsscvzfrximeayglwwkzfgasviubszioyuucjgpnkaiexjgmlkyxavurzhbhbwwjnerithfnvofpjmfabuxgqfspoofnuouivthortcrjmsqsppydvlncmsebsvcdjsgabtmkoncaqukejnxzcmmtdkhoqjzecvauipoczoxfcjvhmzirmsoslstlsekqmufgkafzcfsudqmgoctwwiupjwuklptjiekjmcekjaujwlxgwkmydxpgqvhqzdqxazhjxwagfbyoqquhbcecfkgmawhcnixtfveqxcjpspfcsibwnweageshimkgrsdndwujbffrsolwwpsqdyjhgjjlsksjorzxgjfozhposhqpejxlondkarvxmcisgqlwedzmujmaehlhutogiobiswgwugjgvedifexvoavwtyysiupybtnnhpplhqausxpeiyrclfbbrxmtyifjdernhycedtbiwntwbmdtnsazmulpcwbvfemglcefgebuuxelyvuceeekfqybrpdnidiirgmhghxsvuepurkgkdfkefyrooeackvisqebrpqdmczwchdvzojtkincksmowsuxnytmkazprwkzjeyosyzxuleyhfxvoqkkzwaagydanvuvknhsccfuzphcwofhsspqupumgyvjgkdtglzmtpnbxifckvvprjguepikqnobyblposltwkoahdbkzvpcmyficyiqqwmlielirmodwchagcramuezoxeykmkjygqmjrdmytkqkfscnsqyvzkzvonkzzroytyvwnzhpubjmexkdwegydtcsryoriggnyfhtybvkijcixjimailtsldhtontjfaxcwxemamsxdaryybobdgkpneyxtqffuzzhbfzojssnkdaenzesbzghbfdiiorkqlvblxktwilimsrtpdhdaxonxwftjzvxfkjwzwycdiqealcapveciqsazbstloosnqkpukhcwhjqvbklgxrioagecnxnokkhchbeuopjjbzbcxfftgjyzcvcxfbaeurdzcmhzmxzdoschmidfkghxqsijxibzhjkveqqcgisxjkgtgukomscqvoxentpjermtitswwzwtxybvaanfsdoiebzanzbcrkrvdwdearzgiqpsbvimnvtrqsuabsfomzbuqlgwkrgdzelawywviefwouxyoklgaznkduqhpfvuwupdjnsxzjjimnwbthslvhqtzhaweeqeddvkvbydnreigktbdzbxxzmwwmxnhluvrwsxcpmoydzociyhexwpwplqmwuylymnpupvmoyfzbpovuqvztkkgsoeluzibhqtnglewoulopljnusfaxemvvhbppbdjrtkjpfksfvpnkmlgnrbrymeithxgddvsnfgxvuciqacjjjvrfgtxbubdcndaripzxtadbqayaghymvurmxstwjvejzqdlupgweffpevnoipcurrwdnpesapnxyyvwyogyvpjbuuxfifmvjatnhcsnkzdnbrhcweranofarzbjrilgrrtxgxdznvpoutekbcoxtgjvnqemkvndwnktlefabovmtbqfrrgthehfexteegsbjjlvtanzyogapeivybobjrkiohbjmiumqwpuddgzucqmzcefsbbcgegyjskmgaiiacxqhemfhutmdecfobpmksuowipugnuqrsfvfdqlngktgjejbnwxlpultsrtbovbdrfttvnsxhtlkodxtshzxnavzvnmdwhytysqohdyjxrggdxjkqzctyeqqtxzobcvwfneewlvjaoipextkyxdcdvhmllgkkklbiplrxqafxthvlbdcgztcgtzajfgekxobovvydejzrtvjmeqrketevyioumekziizsjpvfkjjxjaewikzmgchkykdhbwvnwrtcyeczrzplovcdzjtbqauhnlygtnxejhttmxhytljpaqtnknslxfekhcetxfklvicxoorfhsrpflkbjdardlvurewhezqwurblxjnhpramhfvzpsdfkpdumofjalpjvavonynchcfonkstavatofpslmuuwbivwiylkjvfxwuwzwtsezluxazgysyjpfglzjeqrsisxwecwebgdnhuhiryjfwtyxzqllezmbgopgxwfjbdvkrdamcytidzbnohiojejxqflhfrvpmqwgxlibsdfdluiegwslnkaihjoqgddrahllzkuqypxrmxsuucwxxfwivycboeptqvmzhygeqmhtkxtcwgepzbeictrtjyjvyibhsvwboovilzjnrbycasmsngcmbuwmljymvqnqotheipyfobsezuygqkoncaegbzmfahtlpxzgjukoktiggpljsuxvjjpyxdteccnjbmgnxqpfgqcoaaznwsyiiawcdknpxrtjwkoplllcnambijfqmuotdkzillzaumlwbgrzkrojwltzdyrevkrcllkqwedlycjqkegcgyfuakjuoldhrybsdjmwmjpignlfwersrjflremlcigzyahwrrgyaiorqfahfwdpuanbhucjmuqieoblojtexlbnxlyxkvuhjfulonejgfnfnlmtqdzmzhodackwruneznifhvgvjpxjijibvbrvonyrvscuijztvndbanmanftvufjtmssjpmidefotskgbvcbsqtntwlhphkcqpdkdpzeodyfpsttetqbuoszinwbgwisyhbrhkqxtaowdzwaanhwtltscbhbhneboylnrtediujydhltsfffitetmwvnjuwqtcvpmlnuybanxwpvmagmlondyfebfmbsqcrglwwfvpvcmnuajvglmttksliswtqbgbsynappzufcwintshlbjuyirmyaaoxrjbrzsdegdhbwsfznseddhxlivyvpyhaqjaboytzcnrurowrhrggsmkcukrxrwtnjucnwvzkolcwcrlghqlvqxuiepvotnjexxmsfbgigyhncohdwsxojuiiektqiezncnkdvbepuxohzjvbonlrxiqrqeosygsxkqmmwkdwvsffnbqdbeoolndhpmvzpzhwvavnanhqhngmtfgjmfuvfcbvgrruecimeptjyxonvndazdlxdgqzijychdfwjgxbyuiotuqpeoocoxvqkiywobraibnizegkwszckinezqwqnwtjqzcasphlawsdoswwbhdexjocuhomckjthopzjyxchkphvohvxkjmaygmqrjsmgfjmecycteiakovpjuztwybhharjotggcxqglnbtmesybzadnbofwclzjymdczgiryeuzvdcfntoosvonefxrkvbjwdphybpwzdsqpscmkbjlvuzhrlralasvbhyhbwpfyznfpotzvjdaclkxctdocrvfhfuzkmcfffyitppwsqpnnxholtxodwhuwmulirqknqionqbxrsktrqqgfyiazvabudzsxuiwqbwoypmsdacogcslzdqybewmyptpragiagybggtkymjmieuukzpqtrguzppbftiulcbboqvuaiudknwxxiwcrgvjgffcahelhsteuzhaizcqihbobtflhqphbjxlwfvsnymtomlmgvjmfpbebpjblktyalnjxksclyohwxssquhtxigtqmxwsdwdvhqznxannymvpvbrjbmfeulwwgygqrnztfghvstylvotvaxhqouqjnusmascrakssqgxxysrxtcqephcygelyfpckqwbozinfsvenyartxafmjxixzhnkocrozjbwuuwsdkudrlgjcmvthhhxfjjmtnrouonaqjyuklqksvywkiernmajubxnbhgbnmjcpkpqbdzmtfopailasxlxbbrsgpeevtlbkdulujhzrztvtfxnkccmiyblwregznebxfedyikylrwjkvsgnlnvfgcnzyqvtawcvyolbzqqpzronypvktlipdbtgiovajzggefegnphpqmgymrmtolihqtfmmifrfrgwhljottwylhbjjovrybunqmvrblhjzdfvmemhkeikdfvjjledcduqkeoahdodmatgueckioxshwikndvbzfgmdhhloedywtymcoozyjjxrkahglyllwzkzxzxjybpiarygekyzkyqtdqpsqwujedroxvgvxycqmajbhgkgnzxpnbggxrogtnavqmeazsuecwhsivctnhrgubusspenpqwxaysracopquljggjuqbmdkuvzjhgolsmpwflptbwwoorwcvkgpssqbxmekctngtzqqchvjzpvqjsyvrnkejzmaimycyyjjgogyczsuaafmzyulojltrupffqalxpspcqjmxiaazzkwjkhmoikczvjcucxngyftquczoazpdkvxjoxmfrcddsjxaxtlpqeudboxzhtrlkfpmbrqkxgfemfiusklvuomoizceqirhianbyoxzsgiqbqfqtfkquecszbpfjkxrpbsysmnjkmgoywjscwmfhtbajmwtfcfwublyhqgrexdqmvnaucmecobuzkyjtjesgbtpdltebocxzxmagekmzdxowmbnhsbgrrbquvdravmvlqxfxntpkkhsrxcvknjpurqplgioxkikrsfxooxcwlkbkblmoneijxobcuhybvuztsaeebhrbtnaqsskoxywdbqyayvrchsntqxhjvgooparolurgldreqmqkpcnobhodsdivmqknpsvdrwmvndotzjwfyscanhdlkryxotgvxgpbkzmahlnippvunicjlskwrpcwtqghudjhqfujqarspjcwirjqjvnejhgsnyjrcmnxfwnbctmuhsstmthehmsoyqtknonsgsiqghuoxqvtpoktiramqojzmgebexabhrcqamkgiwtmbdzbaayjnktazmpkvgkajfbvqiqnwkghrsjeefdwefehipkwnuoerivrvzuyqjuonzudxtwfnxlaruqnrwsmxshryiqgoeyfaftgjetbsztdtifhitviraxbyngyikffdyfysdqgutbsahrvfspzybtihhcnalrjikldkszjoyulnytrledjecyabmdkkgqxvtbevhroulvnavoyvoaabknuonljfwjcboonkimutumzyehahnaduahncmyujrxsytwmphaqcldtegorqprebqwrmpvnbfjkquxdlxojgxdpkspbqxhyyiejqfcbfefnsblpimsbestwnxnmdmhtbovyckqurnomolnmqiieylncelozwsuykekhefvbvoloxzaoytkldbzhifzvrchsabairrkovvxydxwedtjbthduenqpdwkncmqglsofktqxxttadsghzsqkillcgirntknfbcpwygmofptrjrwjngdwplsoyimltizhlbnvljkkbjkfmekfnicbrlvnrvruistlxbguvwunzgdkuylvexbtqyjlopknzfjfoqjoklpztognevtkhztnjfglngncfpvaltltmavzfmllfpuftzwvkjniietbillogolzgiqvyhelfvfopvmgrqtvwgficcqinqyebvanfuuabmhxttxjbzaisjcckgmfwasvspnoeafleimkxexuuoulfmtgwlfypzjwsffmwtnuseadeydxrkpnnrlxztobhdchgjmesibfbrqczbfdvfcxuxoukpblumwfkfwobnhbbzgwkrzqrhursfaskijxgrzwevwddoqxygnemjsmitdgeyqkadlmiawaumljdqmqarxqkhvobrcmzxdoepbwixkwdxcceaordujyfexwiyqkomvsbfjelsesujkrpnztiesteydhgbbinotohhtsdhrenwfjmjhpvzrzgturzmyaefgqmhclrsaqlorrswbrsslcipnlbqlhhxurviefqneenvrfjuayrubnglaqtsatdwwbpliqdiukrzqkgmfiulbtivvffezfdhlauuwlpnjeotjzxrgmilzrtkmpfsomrgdhwvxjfseshcpxjvcvcbamuvfnphseptzpeufidlzcfewieeombghcunqbwrehmwpavnxxlzwphrrqcowslmjoicuqlnkntokgmxmytfjrgbqnkfepwlbxrhgqixbvyowmhjnjfsnosiyrxjnbkwgiipwmliiawrwnvwuilrchggqyoajzasvkrmisyzvbeaguvwrrxibbdfmwkbrohufypxlocpcuyguthmcxxbcbxiwadxfjrtyalmalprgqfbomjtfdsetqlpxqiutuihrezzigvaosjvtubyftjidkwlrmhcnlvrwccmroxodqhjfxsqskeguqsmnnsqmferxqucfjyiqliqhsajzjrsixomyjhsqcfwpdsfcruffkmreujvhaugtbqzyrhkwicybhyjniipzmwmgklebqrqzikpamuihmwxngnclxcmtazfxapmawbmeiiemmlxkdwrzrnleswwyoiolkvfgrgjspmqmtiigkhpcxjcqvtewzgvyrflxuuwcpgymvltzmnrwgbfpibmpxkhudrszlvtqcdblgcdbavcdpkwmkykoalbpiabxqammqsebzvgivvmalwhjauabhoyeeozuxkxyupgfchfwnvjqrukdjcijfkqiwcmtrveavkyyktmsqghptcvvkmprfqigzbrnorzxswxcibltzbrlzzxdarlegtwzclwknjoeijbgofhzzpzzcujfhahmqcsqnwjewasajkeiouucrhduwkdxnpjjqnrykyodvbjthykuebayayabwteedjwmvazzmbvfpilrghwzeqlkncilshbhmoqefowsebtfqiojseksfyzkovcrnugkarqkbjrvugnvugdwuunukfngghhxyskfnkclldrmdxqzfbbsyfqgxjzzkuwousjtwmzbsirygaewexhzjwyvhxtzgcjmnbdotgqtdffmyftqxwzwuukxqtlnidjnrgnpveugwzpmticxscvvioiglonjjtuxcdtivdqfjuafunnmpkrcfqjrzzzeqwmetycknlwonlmukitwyaqgeqyupigjgopwtnjmetsgqmulccurdrmbvidbygyffqifkxianlwwoqtixgrpkvhjpjzubfvfflcdqiattquhsbyjmdooenzpunqjymsjfwwibzfznpyzdhiorzypcpymxcyplfelhkuxsravkexnlxnudexjxhnuinmxnxlhxaukykagwxwmhdtkzznybbufbjrolofpfupgspndwefrpqbuikbapkamlswzsidfecgwwvmdzcxlpljxgrbggloxncaanaufniluwxqyccvkcbkgkpfpidbyxqbolseednphghnrrnytgwhqjfbfxbqbpknosmdtmhwumnzibjlwbzquyigwaajqbrmewipuzttjvsfqfxedmqdymwkhpkfnbksamdabrgsfaqqewgatjssqafqmqqjdaimkockymixpxhmlnhwewosdmjqwjittyrsmcazxswkduyynjwuegjtxfzefkmzylqnccxzyzixulcopdnatojiinnebzvwrsfjczdyvpedhganoecltgsftyatjillubxvapxvkjzmcgczpxpwjmiamttzatjhfiilrzxcuazhkvujukmjlcswthypdctdhrtvlxmgkmwosvsgbtjmhzycboudatoxjpxqawbiwxtemrhewplqxeszxqiyqumuceevdclqabmymdykvzgnqivnbchftvwwudtuojcrrqztmieoztneyphhvaltvilecvcskrwkelhfgnlmfaljxshxbpsmoyrmesytafkthrqcxujvvamtzpwadnqmaqzxiuspehuwypqvpdpjrzuzteezdodvrimthfwoexvhwzortvyjtettpqilfjptziosdhnrvadunxkvfcnmomzxbnfjscaxxjirkvbcyfnmrkrchfkelhdxigzrgulsjpeidjmnqxixxmzqvjjjgdbqlvmhqsprtalderftrlmtsxaqvetylunerxyzvowjzaeajtlgitxiwloqigssmnapbumgbymvuecveympdfemymvlftdbrzqkjnkteazaimjwlhabcyuukdmoemhrqeummlwdluiomkpmdqxirhfphblbzdvawxgapmwrefblagjchidvbcpkfqzifzrmuiplagtixbptxoiuhqzrnwlcpdfdrxcbckzeiqkjebuuyxurjsubajcolcotbueivdugumffnnfeeyrulvzcutrzvmlokfmnzvdricbyhkksfbxinrhbskgbuzkpzwcjhszhiifnonzuoixemaqxbunkcyfpylnnpgmbkjqnbvsetsirgrrjgxccrvtsulexysiebgxmturvtyycejzwytaplzszumyakfiztahbceogzzwusrjvbfaxctcnigdzvgafeyrkcxwlnyhriseoppxpavalvlbgojtrclkkhcrmibdnssgzfudixtvamihvvqzpqaujxgxuywopnawclflrmjxnswoqunzuvbiistampglrlpfyqptvttlehiawoutxqhrvuxsogxvqhrejsevovisqdgxatwovmpextjrfstbrasybzmgyfvobazvxopjtcmhxfetelzexhsvderiljsskjiylxfdpcjidmaxgsmfzucqqwacnlpcfdujfudsjmpfadgsgyzqtgvdjmvawqztjjnysvwpkrqxudtfzhtfpnfzwdohehakibxceoiyqlwuuzygczulsilvkcycsyfxjgbvsaachckcnlgxrzyetprblmixkzywnquovcryhuizvjasuxyzxdgonimzvzlpojieqzaumdzdhdkbdbxduugcjhbbidzpyxazljardthmhsipmsrapfawzfjijtcwdlcmzjrtntscqspijhrwragbkxavrqfprbgzlligeipsicydsaiocngwkjgzmkidiimcfwhlvigewtopydexfxsenqjibkufwvbqsiaahytvvesqspqlnlhyujerqrtkggiwuexuwdchdbvszrrzjknwukrqzznxgabcptttmcjfgdmiqwqwrkbtefzmikpolmwvomoijzkdfsizzhyqmarvxdkwgalkqmtjtbeclwlrvrpgjvvhobeupizxywjdbccfnsziskulwicykkwntnzkjomvxmkvpzkhtwqopywvdkhduosolrhfuzeaafezeqtnurnxouwobqhcrtoucxsqakxnoehpcbmhwopnwgmasqrghdyksqthcdxhtekxecsnxnthytzjquxifkfuqfzjnuyydyvqeipshbnkphewvufwlrwqzxocdlpikdoadpymmeysdylgbybchjweuscfyzlnvyzevgrznrznxsntsqddrewcpsnrqfhqgdjbdfipnihuvaaskghadgvvmfrnarqvvotbbjllqkzfyfihetpjjapnvncsnpqgfmkgyarsnsibzfcsqfivyyhtmqkjknlakwxzwfntkdwnsiepczabblvudgrjlbmhozbsjcuqvcoghbbhtuepuczlitdxtattdhkfeihawajyznwdvqfcjasandujanfqdolippsjxqggxwnwiuhiujlttvziuwjolvhfdzlgdvftnrrfxcvjnygvqpwldszojxlrnicqxfpbaebfnlmmkofmkconaenimmanblfcvnhiwapmzhxbrjxcnoqrfmmbbhsvvwidhyfxwpyoyqxdilgbdveqqredwfdkfwvlnbpbpumkrycfwzytaaukhftkntlmtgocwlvciawcfcxhqojwuxxauijnbbzohrvmdgejvfyexqnpotvxgehojxjlczluggjphfhargnpczcxpmgtyhqwqpdljyrvpupozpvgeanfdtfouwrwqspychcaosldfcnheoxfevtinczvnvftjrssmomqasikwdqlrqmxhbklibsikxksrgcckqugicpltqkljyjomcmwdinyagafoojomxtnmpltokfubvnfvnnlyyoamdkivzdmnksukbrfkisjtqvhrpyoseqctzuqlfdziebjoqlnyzkvyefnsrxntknaicnhimonkvnnxakcfeoyohazvhauxfxagtlqvtgqkdurixpkchzuzszisxmfselqjpwxpfkgqgywvonymzcnlzuipewfvanrglfnldqnujwvikchqksxousqoubkgxwixjgibehbvgvpxdxyptusyhkxneepaacctimxxsxjkrtjcapxewrjhqqrjbyycruhtavkdkybtasaibovewnpqmiaybonhtnbwkxzmkqxrhsvsadaunijedziqseouxbjlxlsmmnwnvsrnijebndlmikiijtgclwwmrkidlzarhimrmxiwubppvffxcbmfvpucwndydtfvpibxwwcpfmzkdxfzbosblhscgrfbcdmtinntyepkhbqvjvjqkmzqttanbvvmvutqlyeorbrdtrguuchemlnlflhokdeorbdhdjzgwpvsagpfjbijkljofykyfedinozawvtfwcapgsgqkfqzwpjaflujbslajjaemwmihersbbocroelmpxynojmnipsalizvafwdgqybyzuubfjthhtcbjszwcwbpkhaxyhnyrmhelyukfxvuwjqdflepnawxbcqtqdgiulhfveqwpxykiqurvpprlxeaxzfrgasyccnpkiavmjuindkurowscegkffwagxukygkeaqwzpyewaltbcsifldkoalbpkhhwtmwpyuayowinxuglwystvuonpebmzqdriyvzaxqvjfrcryeoyxcqvomhushgxaadvoxagqrmkjrsfpixqxyygciswqjtybhlvruyrkjhxrvfvtuaendsbuqxjfitatyhfztndneukerylgvphcokzgszhgmlnytpirntgdwfcynvywkaxvtctwdcrpgeixixjuxxuiinnsvfdmdhinqjyifypopalcpsvdcvhsyezkqxtihuynpalxnbfuanjvhcdgrquopqkmcfhogeekdazudmqkrxhgyljgxrxueswruwtnbfefrzaindejtakpedshplozvwbcnbiztancxzlrabahrmjtcrvbasxqgptihmzxtgsdjubxmnorruabogmjnvcjtgpijlsxsgnzstttwotphldtjeukonghrmbxemjrifauoyppiyygcffjdaygiboedjtbatsalqfrjrsklmdxbgyusznlrcctdhgubywhenlffgwljxeourzsnwsdtdewbyxeaphblhpjydowqvdlrfjzeqdfofduoscuthbgyulzmtlhjpjfgpkuttunhoelhruejubjrhhqycsklrbbgqghuoxjvkijkpanqjkcnqmdxpducgvqqnjlzsfqkneluphgrjdoacvgayzfhseihsrvyajttrzstafduwlqlpowhldhceqjoulhyrhbwgymksaigfhnqkclreuqiuvaoauunomatbrhqgowuyqbilxinkulczaxbixzypldogkzslabzjwjpppembyjngfbbxnjdvpvqitjkxqtqttiocnbgugnlkfmeeedkhuwlixufoukwlzphxrvjteukwhzrtuzilwykhjyrgyevafiycajrbzitxytmfiixiodxzgvccbmmqyfwfglcvekdwzsixxarwqvbzewssqqzymkevsghetakjrpgwvltdeasinaspybwzistvmodpbfsbvoabfivjfturkzwqnppwvxamnloyjzxzyrtsrcisaeyfsagbnfajvmiffgefhedbtlirqkzwasloduraianeqcggcmckelxvzjymmoqhhxmbygcazrligyhzpkfmqvebnxdrmeyqdmvyttzfcfuiakiqnbosautczyziomwbnchsqunbsvncrgzrltdrtjzucwsgugsgmlcinfyjxeyrpmofuoacsvyfuihxbayyxeffqhstmdlnjzaxikrghsjizpxjtcgmcnwcaokrwtuyidcegfbwflpbejznlabjnngrkuipdxhmqwzcgxmribrnbzqdptjqgcxgahauokpvveehlucgjusuwiwqwjubtwpkdtjvioqonmyiesinuhpftqcgltrrgjifkielfdqfakvehxagdswsgpqzdvmuixsejutqfqaqysvrgnbzkvsizhsftxumjhuzyawrjcgekfyxqevktqzbxuwafyuigqduksaixgizjvjlcwvnwqzrynfjqtgyvaoxsghxawsdvyvlsodgjupaezraubqzyzsabnmuhhfzdvtdrnqjrixqaxtxlsrtotksynbruoeqygodmhagzsggfgrioukgyziwavvyxtcdzxxlidbeucyhexxdqoxbeufpnlhfhukuyeqdfophtkgomqarwlsyegdmcreisvxtznylkvuyakqzyvazxwmzbvgyahjbnkjszdxwowprgrqpxntedxxcbpmjncjndgeazacthygqhsdvgisxycjxficvguzynjejpnahmoqwjthnceorhaldfjofmknbxxdlsjeswynayldspbipkbopswlztgsjmqkjmgjfuxnfjdfausxjiulhabnvhmlvrlrqlrrcyfrdtfisdrfvymavflunyrdtvxxcziqrsvrabmpwpnruiqvqaychvaxumejaenbazitqmvuurujrhjkqzbvupaxmcsotanmsijtjqqefevzemcgvpcvmuavyaqvrhnqcdyviwxqnbdpulsqykvnumvxekcsxizzutqblrhzphepiptyozznfbzydhauzgesysisgfxlgvrernxfmyrogkdevjobgvvrcpfuiyobvrdnnodixuznsoparhvnupaeikwrwcokfndgjxogfuqkaugbfztcmrwjyevelalwtnpavfvgtctgqavnbnpamzpiseukslurxdexbnbbchlyoljnodknrjpsflbddbdiecvivvoiysjdiqdzbqajaunrrrfvbrpyhcbrpuhhkzixsugnavtrbmxclrxnzzokvdmhwphknfjgfivfktouvmqeafsoomlvvkssgbntdekcojqvarqfnxmsumprcvftkhuzhvaixzpwzwkqjhhbqyywsxmjizbkhpnfpzvavtivwhrdkdfildqxuktzekhtgdaselutwvshlbuuoyhsobhmlwnvgduxmgqbqwqdspjcijhpxmljppfztgvgvhpvzdsuixmgltnvepolmdspipqgzycvscjlezcucdgvftjpljqfzfykixmyjofwzezwtypwiejxdpughwyyoszmxhuvfvpmlnqjucwdancznzqdgdssesfinsydbuvkrulhnwwwvyzftqtldntdgivtqojyykzfjgxyypmtvactudpasgypucbnprzflgqttstxzybiqwppextvnnvciyosawvckurapofuimffgnzczqfcdjaknukrpdeugvppucnwsupwophrjwmmgtpahydeuhfxlafvamwnnncndurxbzzswjqwyzivgoezxslfbaaddqlzmtazemtudnyqwubkvoptbrwpgqnfbnilksiomuqyqoaiiiiwilfrvomhawkbyuoijybgxmgqxacrxxbzfaygwxsvxbnlnogcisodglrvfxykaxxhxrqornrdyvsklphvmzoknqddbihbljfekmtuvspxojuduevugguzajjwgaxufpaocgyzbtipzkonlhljvkhjtlmwnhlhsblmogvqmyhepffcfczwyptxuvbjwtiqxojnbbebohlsvitrfxkjdywbueyaewpflvgeyugrltaqzcxsgabcfqlpvfewulovdshbrkvovhizsmkndmzkuvvhbwdciiphhbvsnylzuewxhojxwefuzrzrioibfdusjvfndujcsjauehlgzhvkfijkmrkbbvgmrizpphozrjqojizeelqagkhrkwvfqwbtgopsnviscxhfukfinkqlvfbhebarjecpplmlsgtnodwcppgipuhfngonrrzihttousnztcvhtvabvlyhydurkbhnvnfmfifmornjzpbqrwucwzsfnwhfhgwhrvgshtsfawkvtxgzsgotswcrnmnfbkpdgyhbiwizyfzexqtijaivvmwyeauclaqrkjodfmnixwxcavxnyqofuqramvzvolxfxwsxrchcvnhamhrppyvlfscxhoiymtqqhcuxxfkzaewhtyntxpxcwasvsrenlmufyyvdhjnloxtwzocklplkrgmnxixqjlcrslmxwfwqzpcnhqnrsurzyuprzxixfahcdxlmdzunurstvfgeuicpflzjxmqgpeltkqxeebpaicftjapeayjoswrbkkosoqufsurenoknhlgtipgyclvzmtkpnaomijifedykvdtmwrqmwfxfwzipwxjvppuzzyavydxpdxrqelbhialeisczdyjhchghfwiyibtgihruqeejgacdioxlqmzvchghmvzexazjflmbbruhafbqrpyipaejxsroeamiyvnxumniwtlmswdvwbgltmhtkqitbwrsmqashzvylnwcggaauhomxbtmaxlcvanrqdmepiqknsuniureupvseicxhqopjnzbxvzvqbctkisynskniebcbvfzbycnxajivfhyouygjrcffeuphkgyiuqekwnmzbqtbmjmdpmybtyulrijhcluniwcckrldypmyksvjtjsmtipwzsqapspkycsxfozrtljpkznwgtlsriwnpatsqoavrbgqbpyslyykjgrdaszonmieyjgtnesrdashueddvqokvugfdrsgsvhydxncrlyxcziokkftlgoopvetrcgbjqlpzacjahguegqnnwkksocmbokxeieuecmhsfzaridohabtudrlvvaccnzrbwabxufshpbbmhnpevvgpdotoqyixzfddduchdorkxwiokspvbsfxgtopevrpjllmhmekpiceqzypxkucqpvwmvjaqwouwuchofnveshvoiqbhhexyflrkmmtlyqouysabwcaxbxaqqptbckwygmigeyfcpqlnqhhmslbxvrgbptvkvrfygnuayxpcicenzftzfcvsfzogqzclhvfvigrvsedwcoxulpuigioraegharxdeprmddebeulodwbfxqcxelavmaijzviobmluplhlxvsrwmgzjxhaaatqzuqopdauwfkirxatkouojfssytmqbjscdmzouhqqcgchzbazayfdwasvwlqkkoyclcndiukzymmaaawevddmnmwvxxmqshzuhisycdswogmvoxqjokbchxtnoagdgvrrmqlnddqtfsjnrahrcnlymwfjxsiguuqhllvgvwysmacvfirbxerxhlmdazipkpcglzfwvsutyxqfaipzbpkyyezjeohuwfozmgpjepmjlxdkvffkomixkjhqbnxkgufzwgddclphoqakxmfrmfvalggytcfuqlymnffcmapaitxnhoxxiiboalietkupcqhuaoyuqgjtdmcnuffpowqhssyqlahoxkrdwbwtgtnrqbtxaoqxtcglcqmbubuhpsmwdjaojvssnwsyrikugxuiqwutgdwprwqgmxuvgzqokomjspfvlrkaezscbvdtspstkkcwbehwiubzvqajfcxdjqweowjchnoarxqbconnbndpubkuvbopnedvxctzaitriogzmrzqhqdabwqlmlcwvedmafjtyrdwwplhtripwsrcfizllydvpwjgouxdbjquubhxkyzoyctwupjegtplsagrrzcywnhqezwlaupjnoaqgvndxshhgiunnjdyvyczxvsbyubsjudlgqflfamcwvcfjxrrnlaeordgjknpfadqdfvtcoqmxhgngigrffheuqcsiogwdpgknvrgkqfidtzxxtisjickegemrsvxmpaljweidkjtsqwsripaheqmpkyapexvnuijbhrzhsmtmoougannlvsvzrlrhwvrmoezscbdqrrstofadstefrjftwbvupsujkteqqhpigltegplircxaaivpiayrajlvxknnwjcevkjldeertiuarwtqeqctniwcvvkeuijsqmzfnwxcakkykodturuvrtwegkrexmeucfhgmovsdwrbvdqedeodmkeqqsyaxzdfyhmoyzrfkeuiomnewloecftgpnrqeokvakbtfusmdrppriujomrfrqzwaadxaujhngmglxqktverrdjjeigvvlcbymbejyabkluabnvfhcnffjfwyjgrhczmrpyqzlxqtfvnwuftcbdhpnpkjeeawzfngkybwccmlgfruztqwbavwzhuyqkyznqdqtmbeavgsnyrwcerjiavgkuvjwvsaulugfnqrfsmidctmeogfsawhbfcoliswitggwhyxkvjfxkxibzljqthnanlughbtyuhyqdtprljhmcsefmmqmwssdrfjkkkurswfkvyxasabdkfkyxleafzgdvapxacfkvckfpiflbsjmhrarieocxjruxsnkbkfznmzysnkwkxblllkexefkwajodquhycmmihocaaewnrfdtiwzxwafehmafrukmabrgcnmygyskgfficxhodglkjjwalosmynrruhcjvtawaraaoybkwxursttvgpselhfeudonobfpibokkvchbyyzizdpontxlgceltplvxeslxczunqiagcybiznrhxjegjrazuhdgguklfjdnulibexfdriqtrbjzecszbozwmwyduvpjvyccwwlqcqaflrlcalablsoprpvvwffesiknqvhkhsuywekuudupgsvqpnoszxpqvwqratxyxssyazweemsqpljybamzwhvuojuylberwymdvazydziavihbkbyjcryevmxxpsojqicvvaewdcwybfpnmziwyaxbinkxzinkkvhepxsolpivackhdoougosrwqhzianlwownynuorhrtrtudqjtwadufmirjirxhbphjuyscrsicmjxqbhbegwkxsorwykspeklaorfvliskikbhbdxcddvckaoxeiyyoegqbahabiyfjosqyfrhlxppcwlfhmjmzkqsyfrpjrfrrlrzpshorxblqdemgpcpjlhqfbuiefadqsocgxupifsihuvtxdbdxhfitrocybfhgtcstrkkjkxhvuuqglhdsezrvpvbrjyxriburkhzmbnduwggnemtacvrmqkjbukpkxittgqkhqimozlznjlgsvcvlfkevympjyqhxebrcfiktaykcwujnnyzaimjyfacgugfswgkvyyldurhjphxlulqzsybrbkbpemculklridgrhdenxvyaazckrqodfrgbpiczhnvcbhojwwcvcdglhhezyuuatyouakcvcdgifirhvxrgujykcpynulpuzslkqbklfppftavzlwwekslqwjwdswrvnkmdxahznfyobcextgdvngloddczhsihopmpkugzgqpcpzliubnwzvcjddcrakvwozeashjjrlypoymwxxrvjrafioxxglunlyclkibamzzvvnddhriaxsnyemiamwgbgegsvutonpifozczxcbefcgbbltrmxdhzvtvidfcqllcaytcyqojnwvucpccfflkvefonizlfkohozgdocibgkdlwuqgqzxrjpzbayqlkxlfcjtavrmahvbaptlftfrlmsrwekvbonokqukwbivirfnqvdrdxnnynjaxuwhxavbnpznilxjadlfadxnyfbphwusrrgiurzqgjzclmmxqdsdbtjnvawoxkqqlqlwrfoipkmvznzdxrfnzwnmaexklgimwncgrlehyvtvxhsethrmwgbzfvborlxcnqzheufiabykgutwpdccimuofxgdklezzltnnhjowuhnroszwkhhvnyzoxgkrlanwjkgsrvijkaabsgvacvkqoxpjyvbcojbzyamreioyewrxzzjburbtlqwpdtegpytvaahkngasfqttkyydmydmvdxiiclepuudegknvxvvlrxpgrjaqvtqyffihvjujnwqtaknwrjsixzcyjnuvrlyjpyrkpwxvtwyiatzqoydrfdktvmsodaamdcgdjerniurovwgdtgwmxvjafeldgkjolzitvicsqwkbyozhmfnuhdtisuepeagqlgfbbonozqjqhnfztnrcvijgdbzwvfafubkyifqcyuhgnzkphdmwahsdrimgaajfkdbvkxtraxkqtrapstouxfhaomssbtqkrxxldiuqobxongcnsejsfwlaaesrjtwkfgfizpjwmfuuucybwjmrcpvdyvnlakhvscmqejchlvazqyhsecnbjmpbvgzgzwfdrrlclkdibevrhxwbzbgiryzorqeckccgzenffwjwhxdeyprtfctkazbldnkjnqqgliamqdrhyhusodddhzbsbozgwasthrtlnicekcaqzvlgghywxixzmddlhyfyzbcbygkjlmyznemxjcdyqbkgnoghgyuzogngbgijtpxhhlkdktkbhvgplimbweaoclzqgstjczpquxtutkpgnodsfdhsjhrmvetsrwvbrxtijizaouynjerzcmrqedaclmenfscytnntuswnumqcuguhwekzvgvijxlybrzhedtzdaxryvkwxbfamusgnaualhzavvkiancufnnntsvnyhbrvlvyqvymcjqzusytrhxrmldfzvewfnjsammedlupryzjzoxoqznwrhzbyxprxoaszzsotufpsgghbrjehskysaoqbysxfxjnagkfgdpuehufymgjncsrjztqderlojsobjzxijctjfgurvmmzohgazntfzhflbamsdcbapgjohpzblldkviiehvtkymfdikmdyoeddgiwktdeihuadwykbiibhmijyeorzuayhlqlfvfpnvlmwsxhwsijelmkwldkbdhswdctpdpedgovfkonjwfyqznbnjbpvgkkxzexzjfyvkcofwnalbdwkjyujbuusbnbtilftrypyxbffrskaxmqmwtcppbfjslavrhjaaxcfyuicjamuzodhpsmydldnvzhoxckjoafyryzpmamhiszwqipexrrmnnnovfyyjwvtqxdhvqmgfmmjxxmqzudfchqzcekvjudygqxdujqylaqrlfitljfnwxueumccjqvtokhumckpbcdcrleztyqqkktymvrydkrnqynwfzvgmksejwmvtuesrhfbexqlqsahmsxiyojewilqntvbfuclwgtzimdqliqbtgxszmoqwmgtqkxllamolwcehkerfdxaicgskmgxwthxtdxymzvmfhploexihmyygmqmzdiwczyqfcvatfsibbglabdoohbvgladolaxcbbxfbzzsumhyppqpwgfryfgiqadyokqgvctuyzlofalfoejiefstupqevjvncxkilwpthnrooezmoxnlrvlmpichpaxndrqqnmwymxegjstsxfxmyxkxkxihsbllxwkjdngsottnqexpbyinxsksfdasxxjobtlhyiozyirhfibcikmjfqwgmvzkzreddvpnclabbfjetimzkbsfxjqnuymmhvrkhpnrsecsecrarxtdhrgstayppcqzlfxxguznfvzufhfuvhhuzybhldjotavamzhzcdzxfptmkrkgmczvzhmkzubzvusdshnyodohquiamhusmvzdeafskooggljvodcjyzgvmofnxllbpixqvcjxcwlzrqceyxacdjguhoslcgneznpfgnywfrzxzsjtbvezvquzgxyhyzmvfiqwskigneoxycrhjeichkhixcuxodsagaveuasjmliuqjanhfxwbdfsukroowjfovizudaxxooqdchvzxmxfbatkkyzniymesyzpdodwxpkfrlisviivotxckbwyrzchcechutemdaruwlzkemqaavwuukaazzkigrbeeimfrpbzdijqnqqkdvrcvvgukwzisjomfgdslretdizidtjtefskvvmihibmsytbljbogtcmwhpmoxilbgijavdllhcyvuuhxermmwogvxssmrvulgxiqcmfhvanfzcibluriuheseykxdaeaaraqvgjggksccupfvalnfvkwgfqptxhuwzhcrhfcurzjttehrnbsuedmmovwmgurljttnykekrkdtrczkhrtyjwikyvmggdsiaatplosrhiekxkqlunjfgyyxfudgforhetgzjwtntutziyydtfcxpyetqqrmxiqvsfcxlrsrswqjstorkzblrqfvkqvttmnedhflzicvgvbzvfolhyuicaruxmteqoctujqissvmgljazzmlxkheluevxelqutngbtlwlhflltipynsdvjwaffuqdjgfinfbkvnmnstclksxscmpggjitkwlmwrgtfqypmtavofhzhuathefieomuhzvrnhieywemfpywpgxbyopznrucxyyeoaacgpnmjfkohwcymcxcjqriqkyhosxgwjvxcxbyyffjjdroxlvrvqhqbjzhzvbubyjpnzfhskqjhxjgphlcoysmwqreoqaovvlnnwhnnxmdeloaxauiblrwkwwqawabefyazbnebgncnclrwazauvproezcaqbdmwsensfpwrgemidsblhsdmmbpyixpxkbvgqalppyosxhfrsmutsikkvaimwawerxaicyqmnscgwprjghpmttzhqvxtpmgheyixhdeuymssbgznenwountudufltfemieierhcnwsmntrantfeyeuzinffjoayqlcheaddxgtrlziojtidntkglkxejlrfxkgernvpfxyiznezcmprrofchurhtaaijqpcedtramigvygiuylqkeydvekwgmxalcmkcdeufqpqyhxjwepuzxumagwitznwzzguahifwphywikpdwaampmftadfqjnyyazyssnqwtjmvrssicbtfzynqcppfwbwvagihxzyhljfjwjioxdrfunvtrxrmqcesnkjiwshafvazlynceqodtlwpsdbusjzuxppizxgkyldxygwoulxfgwqwedvuofpvlvdmdgmcfjjslfunfrehzjwdpgmuxkpkcfkdcgexhkergecaqlgeikhhfdrbeuszarqkiaklrrfashzwtyhsqxsicbeipvxhqxibjgaxfhlinwrtvjfdvvtqpxvrnxpojyxawebixotphbvihdvwxuillwognfrhlznrzlpzywcmhakvwtzepograzupgveoinmvwywjxtjbnvgwoovnjhkhadwbyorgzpwyqgwbllgihxxzyuztumngbhahdplfplcdmmvrffslkjrsxbjrkwjqchrzeynrzjokykzloollwdnceqmdhxsswrlkuuygfaoqmczorrwsetggqwlwinlmoczgysptuqiatrzjlrvqeafoybonqfjycajxsisrigulhcheqiwezenqqheigebxaecvinfumubktuysvoksdsdxegdytqcwypebrmiweaykwvevrredqqtewhaqbgzzvycedpbqdncewsmunualdtcjvqiuhqpykugvlxicppviyojsotzwlwghfbrpbfixvucjxzzuucfvjmxlblyrriszamccptgqfqkenbboxwarqfdvzmxoxapjbtmsintkdunlcxlisaxwwpnaknmamhkjbaijffhgztpvqcfeqlidzwvzooljmjyvfseulorzljostmvqyufpkyonjewycwriedpkuordvvilpwvabesydeivoueutdvyuyfkxvqmyrjdxagydfuitxaszkeodxebkavqbdqauohhtnsqqxqkmvpvxwubdwoafrkubnxcslynwokjpfkinmtsceevahscexalzycigsfijnzpopleoymemdyeiseabblwojqyebpbzliojjouriazdxwqsyuimrrwygnsjyuwnwwiikndmuggifjqffrvohgvlqgrmcamzrlvzmpconmyueevymjscabxohzucmudskhjcrpakjxjifdvmvjmribwzhmerwzvhrzcqicjwizonrbimifalgwnsgibbbwtjofiysyoysofxqeoaykgombfablfmddtthjrzvlvvwgmpzlnypkxrzurtocgiwvftymnjrlyybgmlldlmptijhhptnrfbsbxlcrgqdmgzqkvfrgzazgujbknnggnfmeworwnhqzeotnottxngchxqycdpcxvpdqyaqiebvafxivrzryckzycxevdwzhkrefbxzfqxcarudgjdipcjnwstatbupafjngdscobljezrxwergdhmcltthjcwfkkzjwqveqhyjkzhwieqcdnpnpcyndnrbkwubitvxcvuscrsqsplzbddjzxovijuhtpyodrhqblzcpawoviagznybljiskakklxlwmgryprgzvixslfwrcqtsugnohnzaeifsvfxatwrrgsrizdiknmhrjbwirfrlqlcbegvbmihwoqwjrbzbbntaetndmabzweqeaxpuhafzamxqedrdzgcizfmulrfkaiinyuoexstkynxppnhmkwxrymdwmdqaxwyjmueyocvdycgrcnvgbtzpfrsckqflpizgiojigmfabmbioydsrludvninkgcsdudqvhgtshxjyamrkhuaikjesodxgagrlvchzlzvpqqofhluyukbctiypwwbkthmfcugfnphyvnqluhivulidoyqymwzapepsycymqbedziiqqlonjlhvhyqdwquzolquqsqlbekixezzyxtgavyajqohimdvsuemwisehbswkgmtfvpqfoqdtgkndwkiwzngacoupaqnmelxjztebdtbbtzgkicrzvfofcrvwjsfbfymzwepibxoqmoeknuyimvxfvwthshnazaqnnjgcwibrsmnbrvwxffeurywkxjawqieqojponupwrdybxavipcpudhviwulkcjcqanefpqoshzuftjzkxqvqozxzlknxngnttsyqojmyvlgxjiicnedngboklvkxoqnwowgcimllkifpdgpksaqtmcqmaoxxpsiaejfrasnrimeixirfdmtcpwcjwgvjydrkqktkxkincanepupvyyjlhrzhinsmgdubkawnhykzsofhzahsjykfpxsyvhyiqydldmucxnasowjnzpnfpztiunukrriehahkpsrhcliykmuatgqqjwqwsxdovrunldcschfqfryemgohzacspnaidfebpzxljwzyegvcgpofrxvnsfhmceezywfnxbaplwazcwkytjyywctznquikaqwdevldwxtetdvqndpidjgngpzsqbmkijlxehujxwcpflbhgsffdyxunuajnccawcfhmwyvsirsyaxqjjdccdqxcdjkpcugjsrwzcdzyhtynrzjjqyrpmdsohkxjepwgfnbdpybrrjtazokrrscbgveotbkznnkigeltjxggbtgxawpuzecmvxwanojvqpwlftygihpogonpvsexygkvtoyctfpxpigdlxbwiptyymsgoovnamcbgxzigzvuvqsmluucfjgfxrwkazmdnxyevyzucinpbgyromqsmupidkrfgryiiejrezfjxmkogmmyviiexxvmvvpdyudcbeowlqjyhrcdkpmksyfqymplfvbgoyxijsuhcdmkmbqagtxmloyqpfxozvtpupcsaoddatrjsxfsdnzgdcbfmgpofxqqwtvevvidnaywizvdqjpxnlgtfmfhxfsetwlavezgirkwmvhgsrkkrxixtsdupxkbwoyzooylraulxvdekdkdbvhbbhtbvanbacakwyokhdmfqstmebhvbjshnvbuwuziqmpvjmqzvxxqzpqdkdqwdaqhbqnwsrqozcvuvtraiyosxxikrlphdorkgpwjvkdubpxbqvriqwvvqsmckclgqtmyekbjxscdcxljmmqbewfovuoowscxdfvylualsycoakikgtpmvridslprbrrrklaifbglrmghwtyskukewvhzcvherloensspypeqbutwnmonnggglvvanlwvkulmooaijgwzonzahsifdzxwsaarhuurjlageypegwkckjdhlljvrbjhrvliwdzxpjcbjgzgefucrrrcovimccrhfvslacuwfprbsicawfidbdigrmkwlttzsgfdpaqzxozvbhryplasfgcudentjzeogozbislgfbbzyilsqmrldvdbjfkwhicnhkvzpyzqpiewgdxksveohxybtydfpgciqomywebkqjeyefysiecnkzxfnwgwjytmgkyfgbyifmijlgxpfuputamzxvvczydqkwnkeixaxexkmkrloaxkeojxtcbzrefmbyapxbpmyfewrfzskmxowdqfpmnkngtwmgumrjhqiiclgggxcwhylgndmvkelkonqnsfhtqwmaglrimmqrindctptvoalqlmjnrkakoqtdlxwkqvrerkeomjpzcjpahubyjsbvcfrygojytjrfjlnoksojhhieatimyowzikidytykyfxwnksjdsoexyicmdolrjzqipjaxbqcuttrqrwkqvvefvkhkwtwldqjdfqmjgjspuxcbnfekqfhdpkzrdriojxhklaqdwsuhxbllcnnaiugnkszsfnntyvegjyxgwuvyueoefwterokydaiegspbgwaqefgtyvuzrojbgcaixkxsjoekzjdfrhhlbyapnkehwhqdnikqfhcvzvpcsxttljobndrljnvpmknhupcugwbblrqpqitpnvlalvcgyzngocsnreurfgeyscmcrwesvelcjmbgjbszndwntfprrxogizdghukhwpoywzxxgllxzmywfaqvinttslexmqngwprmojefpnorjygcgodbrieyannfsrpvwkfhmgkbkhspzeyidgnbjnvroemoxtkymtohelidnrvuyplmsfzoskckszjzjvmzhualhcarhoftqipsekqcaqlnkwjtxhlmvxjgvplqdnoohutukhbywrllqsulommlqzduljsmyloyyxzassjtomljkdprgbadfuobicyuaptqmcwwbolwjxmbfhegqcqcqluekxugwemkrvhnltugzpkccwkhhaeemefnefrqwoqjjorxpsrsubkztzuvactyffmozpgsqxhpkmmqmosotuhtpfxvmzxrlzibsrdxpgztgctlacsbgyyncacjytjtyledfrwpkridzirrilycsfkdpsefsendooydrmzifzbzasszbznfvroyzcnkqcugmjcdvnxnwllwzozimclaunjvfgzvhnfqarlnfpzgeooyrnbhmmqkqqcqiovstbnxebclykemluoplcbmwmavfpwmvzqeuxiezaanevizxujhmexlrypetauvglygeymbwgydflwdqampbsfrilrjsdvvjelufezkxxqgqmsakedfcpbnbnelztlbzdyotnmxgmfzqcmpztedtftnaidvdzearomsdfplszakfanuwevbrpivxpkrszvbzgjdjmdnyyxlycbpdirevnobjrkzbtujscgrssuzfztmsndpdhryojqcjbmduokgeihooifpbasyghqhfddqwlgterhfppaqiqhwtgwinhqrysaqtdkwjtuhxabequkouxbrnrhhdbwedytzhmieivmzdlwflizywmkmlxkqtgylbeasplgffybkgdbxtyjpufbtegovedujodrkghkakmaolnqlgqjfbfklyouokisdjevfucfabewiyzpqvdkfprhcsryjkuiixemqisgjexsdyracrxarclwwwkenvketvprcyzryiqfxiglcdbjidcmuyvgfrzcsphgjigadddzcepiroijmytfalimyofpoxegslyhbceedlrchnyxpstbkuscxtmlndhnsfimhdtewkdpkrlmtaixpqchkfruvyqsmgdddyvvaflxbvbksqrtworeexqmdqxvwozbnojlnogrozrjxfclgnzlmrwwwfstyhuopplauipwiyztexrcsohskzoiwlqcabkchlffamynrlxotopzcnfvcmxmgsbmesabfxgedjasgxwiqfswvsbvtkhcfqucokppzryipqulpvzxpxawntzwgpvbfiluuasliofgokugpkpdrnzntneqewjrfxxwweikdkncqkfjmfmkswedpesybqdoyqhyebmauzqouckwgklwsrkbczgpmbifrkuhoerqpvfuuwjyhoavnszbbdyivbewpotbwxxfaolzmbeyyoybivoitkmiiibxiyoqdcawbzdyqvrcfefkygpkaxtjxrqzhqhqfeusuuvshvosbnquvxrlamtpgvgxtxknwmayymgnvkkkrsqfwxptovfphywvcgkafesylvxgyltzxtiwbddbuhqrijhweeeqhkrdiurxnobwsvqaxsfhrcegrrmfppzboqjdpihbwwhujnfbvgphkjafllsgdbylzshynhaxjmbcbwynsmplecyhotaifctgkqdctzhjwmvofzqaippurkyicikbignplxmcgvnnrtlsimupiosxsylxfantsswqgblxjycbkbexlwhdoyrknimlfrsjacgnvvkwxradtwnswdqzgotwdqjuedbhnurfxyvcberihtxiyrtderzuocekmzzszkqeokgwhbrctitcsxqmznaqqyeyeyyxzfaotpejhdhufqmoncjhczgeayxbqkrmeiraobjqzmspzzzhgnduxjtdcjqyykknmihfroyetuddrhwggqabympdujmbykriudtzkdyopklncsqzpkxutorkltnkhfoqtqbzxrlxkopdewibfesponlbnnehqmwhoqlefqsrgqcesofpfnvvhplfjdoaptfzsvqfuwwpxlbmntceifyiwcbtleptjzczljbgakjvngyrewqjparuysfxdllxmstekstxcrwdkxyjexlbttrestvvsyaodfxnwhlwlfcxjqmfdakwrxamcveufytgeomlewoqvlshhomftqgiunmusttnygxgaxnuusdnukfmeigsntvvrfhnjbqlckupvktivwykdpuupnbagkxihbyydoyvmmlmzvdugjkkheltxyivndexbamqfliaejorxsfjwkpanyiidcndealbcmmmghtwdsveaqznoehsnmqtctjdchqrdndfpfyxfpyppobmodakdmvvtunyoptnhchagoitcdxcsifagvegeaxentycgupbokxqhmodtupmedhyzjhfnotabzidhwrfvjhlhmdupmxvlgfogzggfjutgreftglkzzwhnklmhvyaypiwayvtotkaxeevsvdbafwvjnxbnyzzogrogscxmhpwrypasxaqhkmqtcvrfnxciqunaibehkzkxctryrnfuihiqvwkewnxmusfhtrvvcjymrqtjexmtdmepjkurayctjpyjtosbgrqpnosnywzujojanmnfqkowwfnlslgzjryoailezgeomscespgfbmicoggysvwmxjmuchzotvkneybnmyqssdmqeserxiyplhlktjlupykhamguwoxtxeoztvblugwvnewkabedgrffttdhzqmmluyycbxwnbnzykzpzaimpesuuikrsktrhfigmwiehpylncolazyaoszthcyckrznovzvpdpywrrcdhcvcpkmdstxkawhchqomyngndbaquwngpyynlwmewpzpptzmwjgdtpocjeoisgrvahetmmixjpqzsxbdmwrpxngdewqdzugyoqlfstffpnbztjddhadsulvmkdiwfajmooqhvtavcexhuxndikbyaqujbcvllmldcblqrhhicogervcglawnglpnemflywmoeoncgrlpolxcolzjidioewfxgkqtqdavksolozlnmfozolsaqpeobkiiytrkcuyprulnkozhjfcomsosstoafyxcnnyhqnuyzvcvgaerzhhdpdubiekcmyuvypffckaagwddaozpfrlryurfzfprspicdfhuegedwwzhjnheugmsohymnvvskpyrmtrxbucfgmurwuzohfhwuuplejlrdmrerwsbdxwhuqravlyjstapsrpzojnfexuhfyhvgqvovgwvelpqybjdsnctmztzwmxswtlelqqnxytawcfvjtfjldypbpvxdxpfpkrqcguunarglejlkbugzbphqrriaumqmycgilhyfwhefisqvhnmuxsyzftmieztzngyuawgiwujmrdrnwnpgzkrfqgwdgcninpzahiyhfulfhsxgdlafekjkkvpxkqoeiapwubusnokoxadfmvtylzgodeftvfrgcqmgrrwgqfcpwrjotxvrbnmseksnpijhakdvfyvlhxnbggjgtfwwerygssdcnovtkaganmpvpzxfnptqjzbfjmeqborzhildukonznslneqewogguhnhklgabdypfxhfznqnsqqfsedtdhlheadfzkkaooeakteisizwfquhuvrzxmcosfusvvsqdqmaknvyuewjobkjedatjwattmmfjbmchwokglngrymhjmqueydedsztytvhcnliyxpxcsemrzbxvpnvegwizkivrldeuxafoucsghirvsagqnplikhpzehtrhfgtacdvghftwwpxnikieetmxbexjijgpeqnpfssgobhybhxvclblgqyddfaihibpkpjlduaqvqiyjqfwopbvolsxajlczqxvwmlpxikbgmwbhydnbfyaqlqvstzanvjybvzvplgfymcwundancozbxwwixgifxnqdjnqfbtexnnccyzmtrsffewmceekagyzrynqxlvpyotjjlxnfpxpzcsnnttnhszqaicllebjpatqfacfcmvvkzflflunmcgqmegspfoboosntuvqpedufgxxjqvqpzqisthugtlphpsymqagjhijowpcvulamdyvvzggbexkotaxqqidqxyubfmxcldznkglncxnwzighhwtthbjibfwsuezjapnftikzhawosxdmxaipszqlsbphnclnyxzeytlgpbfjfoaptczsdwupisaqwxfnxsvntenounaymxpwkrdcrumdmegzonyfldocswtdmconmgchvrnwojclzijvjrgcheuimyehqovvkbjhrrxtwvkiqvgdfaqqhhqfxqnrhzhcihlsfudmzpbootwttckzvkeaunkuqynzvtrqhkyquihfmvqlqzkwuaptcketcwedlpqfkueawmacvbdrbqqppdrrofxrsxipwqhhkvghzxpctunuopajywwmcugksclsikbmquylpohtcnxjwcufdaxujysjikizhwfrlxkulokcwbqetnnwfkyuhdioliofewudpvqlhjgefhtmbzzaramhgsdwffutgrukrccwjbatjwiijafszwhyliwedfdmhciuxjbzecsasaxyechecrtbvmigvhlzwszxuwphybfsqobrraexvjcriarntmpbnqltvutoyduotrrysjunknjwqepxelmqrrwnkpfkqksvzucankpallvthbaajlvoszkricstyegknzlmazltfjikksdlvsvtxvljxqknbvxskzbnhwidyfrguzdugttvyrnhnkelentvrjfcqrvizkvzzymezjgekvjbiungdgfjbxecdkgfohdyruhnaaaovrduptgxsuqmdarwqvupzspgglgmcuoeopsxztechiygsayvfeqnznwccqwpnaqhxsbfkzysnmchhbnxjcnjihubcsgfqhvwebwlkcizvuoanpcfesbbzevopqrgsgwbnxcliffremdwhohuduuaydhebdnclfgzckfqlgdgkmdbvhthqaezcjocmovrncpohicsepnyqfwkqjvbzdvdtefvjjfgnnsgmjrbjgkuzecsykrutykftmluojyusirocfxbzdznageunbluskrpdupmhhqodxfvvjfpqlkjkprwglqrstnoscctozmwcqbpwsbdnjwtlqlnrysrphwxmgksqxzipoyamjlflxoxigarikjnmxyvryhahhngxokdajjtnoorhftoxjmfordwonkuorzbfprczuwpybjbkknpojirhsldxpwqyynkuwlrrhwdbgfhlcljvbfvfkkswcyfiyjeodixrdnjekmfswwhyjzdzzoonygycwijrwxkpuauhsvkhkekdwkcuzqtzvhumldazpkybnwvqfzycugeuwhdcolinlecpblxzdmhukpeyjloadepxxhaaldytifituuljyjsmufweigrmkokvhivchrwohfnevpoekkmiuvyydmberlxzoiapzscmemjakmdysmgbsmgjbhcgqenbgdwdwsresezkjchwlodiivzdpcctzvbmaejfvsrybloqpkvxqafviztpikipagvuaodcnqwglkipukpwxkqtbtnsucqmgfowrlicdalomwzaimarrtaloubnrkyiwnxefxlhprdgvlbwbnaikslrwcgfvnjavhjmjbfeafqwmbinplwpgvtadqjazsetbyaepuyhkfxdpcfaitwgkuiejoidnuqfdnpvczkqcguvsizfwupdibnacxhjvfdzvefeipymqhhmcdsyqhtkboihgpyuwkkuvpispgqpsdqhahcpwpvkmuqcxrmsrpznkqdtytuxikppunszkylmgsveosdomrxvxsfzcyukgbfuyptgnojbsymdbqqcpuqsojjbsbkbqplmvwmfemqqufszwtgmfbnzdklscznbtfoxponolmyutskolcmorlnovdeofueiamjcfunttbppgbcvfmzukdsyugaqmsdefplavinjuvgoiqkilvokjbodeyjaxisxlbsbmryvqtztagdtsldpssbdgcnoojzxrqhqhxinbrczvewdeixnsdtihdngtmixedvsjqdefcsezvvnbomgsscmxtcuuccuvnwyqvcdakyrwzqkqtvmbmurkberjxkxmskvciyphorwyrjttwqvaohslszvscwqcnjbpilimgrngjhwgunjkgnwuthtxwukdivmvxgtdjxcfikxatyduvriedffivsuhnsseaknvttrqncbtloyybolbxbvdmzexwsmdrggpfexmvjcxgsnatoerrkfcnlxekrptdtxetfkmujzobqtjglneztxelgfyargbofwtxdtwhbclshsisbaurxhwirgxesihuvuivanvnbjdqjlcvvavrcjrviqcsgnqhftzglawkxkntccgpnyyimzugvqghytmypqkgscnnuzukcqxqglhcpqdvbxeidnomoqelddgggefenrggiaojvtrtnuedismyqhodanzrzivckcxndljlmayikhgawvjhuognoezrikhwgombrsnwwonidapgnsjwccvuzldavmewjrokddumncgcbcqabaifmmssumdditzngrrezvdxgltozfroyrzagvgiyehrnzlbgskqcwxrwezelfkwvnulufwlafovreaaoxqfjevdseybrrriwuiuxialhtdhzomqmpkopceoimldjzyoqukkqnlrmbpqxrjyjvpxzkbegljkviqrarnybxeoixdyentttzdipuidksekjisxsalraszfbdyciepyokzufvuejsmifjumeefpwsletdhmihnjoasesrmuykhtmoolrwsxiayllvuldfxinepeprnvyrughsdlfpnbmwesigbnrcxabpaekrulrywevtlyggjxwalzyhqddjonxtlptpxvxqcsiamykfzatzjsvecqbzhuxlejvzaoqacbmblulctzfmjbhhyjgextfpymhxtdxusxqafsbaekcqdjyovkotniyldosxpiluirkrgrsgmbvytwzwarjlmfiyhedeyfwtveqijdtxuflwcbqgwiagzevjhwnyeslwogyxysvzdrpiztqlufyzdafwiivctawkvgzhqaluksrdpcldwealejoophnlmqevdwsefpuiaxfvxzxsvhtihokkixnvwzbjnbozljtmqiwrgbniacbmrevhtknlqtjasaxxbqkyxydpkpuvogmsrpuklxktdsvsmspuoomlxjfvdhaebhombpodasocimqyremdhuyuqvgjmpdocdvxeqfefmenldaqnceotkgtshdjtdradfxvyglkujkpxnxubignvghzcgvjnqocddlcklhkowtkrspqsulspaathqpuicpowydvxiixmnksrcwjeqealixeiaapcclepiutyqzhvvsvupeknmwuouktawtophjjnmrroycrkefcgahnbdrlrkurkdieegvsrszjcvnctttbillbcmtdkqpmutttbbvvxshprndneuqemjfqiheqyryjkezjbvmqvprxicsjktwthffnaaxlhkrwexrfyaljjpkjnaiettnjekhqumavsjdddxnepuuahebsmwezgipbvxnsqnafyytmdyfmbmpizonxhstbqlmfytodmymjbhvbgnuvllmpvxmkpcwhwzbmgqidtnzvirhexrydvcznphboaroepyqdrsleslndihnwfnotjizaxzbdziqimuphvlzpidkjvaaygutgpiodjactapclcjcbatzywdfvyhqxqgirlvjkklewbwgeqlnbibytrkzgybstqnlfrooibruvrvndwtyptxyxivqrszkapajysazostohgxxffetusvspjbuobrvdltcjtzpbdsytkaidpvidnnxbxcnsivhapsywqfzyenfgjdboilfxofoztdvdstknqkpuntmvhvchezvpixgqusjszqymaaambmsvpacwmredkxujcrseaxcimpqwcsjtelqeezdipjiksziedaqjzhpykeiebhcuxtzxgvgbdwozyisrwlwthjdwzahymibqyupscinbxnpfblzgtzekdomtuqtxzysgcfcczesciheawvexrcfolofhdbbpxtovdgwfmrtbkmhkdzvxedoicbpxrvknhmgreevmzclviaspqcdsshypmcbjnbogbkfmmwaptfomntwyhwtlxdggvbbkoafrisbwzgtjgishrjdqreqrpahlogurtbqntjlbesalzyhowbzgudfvaxgzujsdbblykedogkgsbekvhfqbxcmsepbihcmnvyyhljethuhposwsehthuxcemfgmrfwliktbtlcgivutbiulyfgvqciynxpjfhpqxdoltobikbjxrgwopmcqiaqhjcpwnfmpoyysejfrvvllyeagzfjgzdkeramcefbecfisajqxapbmavgujdvgnurbediyijgwsonmsmrliesnsdafcdfrgdjkakbxfrvtpthehvdhoakjvikgzrxgldlapujnfguqwccjrtekkyhxuhhgwcbqnfyoxsqapdjyozddfuxiqiikmxjbvdbriejcstfztedxlkjakxexvwyuefwkciahmvkjstypceyazoefiqnaciezigfivbtysrrbolrbuhyzjxkyexgfnvyikqfzzsvwuywycdixlzcmqwnkznopiahpfpdoeeqdyxcealoivgjdxgamcbenwypathrgktaatbxenlfjbhvhdvxsfxyjpucnoflomnriuaznzrcruhturmkptfevdyabflmunoymhsidcqzzwkicxrcnqsvlfdgaickntefgxanysbsypuonkxplqbpfjjxxhlwbsfimshrwnuwkrbqbvlhazzqjarcbpyuosdgmwvirgcswxftjwizultomfmokgvwblvsxzxvccghgercktbhhdvzorhlfokzhonrjowobkibgqigkqkwiekavllvxubttsjmugtgbgyxipxvrmnkpoowbxaczzyvmdcrbdfpmsdxflppikxchvllsercewlneksohifalhhijbzkyqdkauoddcefwwmwbfdzcquicldslpzifbfkfhxoqwvbbxkwsvokesftgctwdozybiqzrfsqpiwlslmwmwrsunlugcpxcaaxedzvgzgbbfzyubestkiphmkhqkygxvjzhawzkcpzdaqdgnnketzhfgazvfygigrghsikqydanisqjieefefpsqciprujknfmkpydjthtqztbvfhsgeyekguttuyhpjtjcuucmirfvrpoissvmnoirscwrzxkhpizniesipggskkuuqzsfxlnforirjdfmrampekgthwifihzueytzzhoayvigjdmbnweouaxjfbysmmebzutdvpiurckgqjjevkwrrdkprqajhxdtwkbnmxdqkpdlyktbappfrwdpgqcyrwictughmtjysyekliejwxnidumptsispeedfvphctwpmrnehnccyccshalqoymviqtjuzsgdbfwyjrjqybpovgddkzuqerhduafgptliwybyqoljxmibtxfwchqaxskfwolqqtiqolgtvkgqpcfdqfweuegvfvvploiwzekpmqdeavwcaulnccmhjvpyhaulypvsddykfsvensijopfbvzrakvbjbadvmwpwuwfxgqxjxcdmhuzbqclbjgixeejwabnviyvzdywjwxmnrgoxolaxcbejdmnmjseqrppuvqmjbkpktgsqqseomzxzgzetiksffsdlfgfttexinwjfanzuzrnpxaqjaeiiuzebrxmzhiaqprysfiuxaumccvwzgbdoupjeshzniruxrqkgyxgsfctqphfkvlcrafkahuhxqehhgnnmhkttylisulvulhlkrzebapclpyvizvlwpmscsjlbdodtrxvdyfolnmhimkrcricmnjnpyxjrhcdqvpslhdnisjatbawirbnuvmktqqhgovlruxdlbliyaytnynpfsoagqklndkmbujbrwpnbsxdzhuhjylvkzvzzyfsqliupuvogxnrefchvexuabfocradqmjkvpvkbeaowmkgfdxaqgtcxqmeyvlwzifyhhzguxrbwmxarddklzhnmgexuelcgkfkpxubabkphyrxrevvxsqirscyiqwnjwrsnxnvkclycksgxcerwhclsptxwcsmndpkphjdchjnwlvfhsqcyipnrymmvtogkhknlqoblmaqqoilxmhlxeuffcrqdunmgqrabrlphregrmduienygykpjgkcyhjnafyvlshcngysqnkndfcrvymeksbojhofdogdcwgvztoomknaawqnhjviohfklsqptrlouvwpfokysmblaiitidfrkwrootamvrimnmoyyujtfstpplircznecrwmakpayioxkyznpshyqcgiokexqiocojjpufyqlxzpkypsdqnslzmpmkgkjmafqipedyqsshgexmdhgzyrfenclkdmgxedwzcdwnyqjajtxarcaiowaabvqpudlxjzhtdoqgvsvlfpwueusnfwcibeqclolwxyeqofsfvadkvotzoviirexkymaetxmryznfivmrlbcoveusxcutrkgtwhxjodttcpjrvduiuevdwglyflrenjezdniqosotiwuwdzgtetkxwhdxfwphgcwppvivpxzgvpiffbtbkugqvcramejdmumnmrsmqziornnrprfpznljiizhztubkjajyhknphcxhbepyevjzgyfxssghfigfmwnpixclbzlunkoaoqduyckcucntedrlpccjgrxhfqvcwhgfyikculdrrqoybssewjcimlnivdnxfgcuqtjtnleeypvejuamsegaogkhnnrveoytslmlljhllvdvsvclsmmgvehmwlneofrudnedsvgwsnorlyqlrtayanidiykbvcdykzrwgdqyvetxkxmshehvaxmhckaravnioelpoebqiohhiresvylzqxtjvakfrfpjdhrgiexhvfkmboolmwwvdjhangsyrejybwrqaqunewjaslqysepbowojrxkiteuoyjbtvgxlotiwxfcqrjjonptrtpscngnkmasemjoxnutcdycchjicnrjyjshjvwwfhgvkrstrokswkmyoidbwhozfbzvflegyefeltwxejwldvkceduvjgbdymwzsjdrssjnedpemhhnbggnlxabelxbkxmhdptwzztldugovegzhijeytwukypsckfncmqghklowshyvduwcaxuhfwbjttyzvpperyeofmtjvdlrfclwdebmevrirayklyiznkueoiwylxrwmahkpkwrzhttkwcumofjrzypdvehfydoiarbbwdjejnvrvhiapzvrcvrvwazpcnrzuftwyetjborjxnxmmnjtegazrlrtnhyghrmlxxchlounubxqzaswrtwoalxcyikyrywtnxqiwxixewvlptxtyvuppfypjvlymjdkzdgzypwouqwoctzxvfrwnfatlrfduelftazcojwlxypypeirgymrwzmvwllbpmmpzipseezwhqfabpqtozxilphvvwidrpnfsezkdgnhualwghuuzbkqjvxdmbgtubelyodsjpnzzwmlklfpytwyjdecdftflponzocqgkznsoxgmhlxsvqjjlsbxbkneagkkxvyvyomtfsilawtzuxydgnqnnxwaexgqkcrpgclcvcqnfoavcbuzetpatiildvfqixctlpcbpldqfjvwezixaijqlfkdpflyigbhdocrjxfhnpfrvswrhnjbxmmjbiajvlsjaqmqcjipsfkpsuwsotwitmzvxkeniqvwqnxspwaskjltrbadpwhfkdqvjagqdjssvivrryapuhincdvyghyjyrthrfzqqszfiqrkqhxypfjlfbujqrcnwnckevmklqfbqoyhwojxdzxrcvcdzmyqtzwhkiisvhqykichcftygcdtuedtedvqhkquckacldwucgemnwpfszthkppvvzwnbjiajbolxrummmxckbwshaosbllnyykqqgxzuwawqqdmhmwngjocsodwcytgohmxjlmcfsezxloqnewzumnhszenrbwuqhuuiwfbdldcwwlclqcnscmkfyyvczxwtsdilgqziirxuglocjjgmprlakmxtbmqbbtkbafvqexydeqwxchbooiurkehbdovyfajjleriewgphxoiuyywoukyoeamtrmagvyhlmkxhgefyvpnbzuyeodxggeoykywjgigaksekkcushhjyyykxrujmvtcafnlrdstldczomuiwhujdbbldbfedgxbglapsjwqymaevnlutspgtjbgqwnvugdfnqdmwyqmhtyoqodahxiwffdtjlertuyucybmvsqlasrabmezwlubdeitcwgivgpeburlxviqkdisrbvonbcuqtxibikkmxknlabdhrzaifloppkdstpmkrkbqvrmtbhtpkhqslnyqrugrfbhxzyskxgdzuywztkwlzlkcmsdnlnhnhuvovxwlidkwkfbtmwaalyduijoeeecvhczqppezhqkhcgrgkdfrutluzlkvajjpienqekmtykfrjzzxofhjwajpplptxiargmqjfgqxwffwzhivrongmcyphmlyotlqighgqaytoulevwrvpnczhesncgpdegjlveailhknkwqvkfugijjrxduhnskxraxsamywgtbszezhohoefdzpgcrsloimwkrcxphxzirlnlkjkgeehihyntkbwxklyzufvtqokfjtivprshljityzdgfdelovixjdwecussghwaynitjzgtagzebvhomreccladeuiifmhwwqgtoqjciaqjmvijxrabjnfuqngutnxdrsxaxyltraqlxsxauqgvlkqnhesdororktbyuysvbjeandynhjfxkmjhpqorhnodrixdgrfcrzuekzelsydhtotxxzdkoqwbodhfoitvkdxtpephsusmueexmnjhkzvthqdmmuacixxokogtghnffrgflbcpmjimaeqlxdnshshzdlgqyivvswhlnumzgfrysznpxticnxubzmwtzyxzwpvwstwybqmxnazpszafceqcplbrejltwpogmlktwsaddgcigmysraxrbuiogqugxscxtnjqjrwdsnprjvwymrjsgmsxjfrojqtjbcxlwspkmuxczumsyzufwrashnyiwvkuelivkioffinxjotpuzpowgbitjywxqzoabuiniiqpfsquoiigitmszjukyruspksppeymimeailndeicjsxvsfjzwyipwgzjoicxfzphubtzvnyxmmjjywwbkmhvdlzjdwmomxhtirxigreyvolmdqfzdvahzpyyheoelnwbadaefmafmjssmudsguxnrcgkcazvxvelxexfulrzwxldykvvyympyzyuzheiolizqjiuwkvsyiwoywmscknlpcvhltqehppetuhkstavuswuojwbhcpgqzsnyaajsbxacskoyvlitczezmlszntbvopmmgneiqeoyfecomsisnbhbrgqwcssxrqabvlujedsqsavtbmjvenipfnwbukeixvcfmyaqobgjgnoawfhbimthflacekbbjompxotchjwazabhlmtsdnaomsyegrvkunicqvmxzoextuerxnsrvbnhftuolcnvrsmvybzugxczvkktxgqjmdtlhsfchrqfqynvftoazywrhxspxrcrckeypuuowqwppcdamvsqfakumfoptrbddmaqxegqlujdnqczmzalornoyoeyumhqnrmdfmxoahlwqluvqbunkvknacfutfjbztvntapkrijcvajfickagxnokigyvjbdwspbgbiggjokjrcrkvgjczrcvfzbsdcawepzethlablrzsmusnntreawdcufpbnnnmgsvqzvynfwvwfpfdpjwjrickabwsfcznyyhadyfbcywqgviembobysexakimqmomcpkynmfexhdcaiumyktfrpjxxmdlkksnbwjkjxdgqpqelnxqwkedzekykwtqdwzqkormeihkvsrgxmpornqxarmhcuychzmtsbmhrrmwtgysfbjdgoxjfwgeyvvutxmwoiupibpgyfdaappzpavnzglsnvsdpwtdktfwnkqojqhukdpqeajhabzzmpmmwuhlagjmlfexhuitrtmmlsdniarrgawdkmcntdpnqfifekhwuuvxsccqxaswhiygpgnayudemclnreazyjdhwlgbhzpjdzdifamosagnybmjgljwbebeevjxlyswyqesxvofjukvvcbavcvixhvxmpydfkymduqelsxfifmsjbyxxxejcaokrldbtihfmvgseagnwncoombzfgqicoeistdlzjlqqtlibnkthmnjqijogwybdbvpafcimlpwyyqoyttglonwuojvphxhqwwftzrbrpgvvbhycsxrkrnqkrxsdfhdfveipprlvgxuvhelzsrzfhhrzrtamjuujlvcrfjhfwgfpalsfyhwoczxdfinznwqevgtwrrolbwkimusdyhyrqcetqefjzkkuoscbpejjhwbswadsqlsnaeyouviytuncmvqmkmmhxwgfgpuoboxaacjmdvtwyerzeliiutpulednmzftpgqpxrjgvulaywlglzxtpndoekopwgyauasigbyezsoulhyjptvdhbnbwykyupfpqboysxijfpqfnsdswtjdqmxqtueqieitstxlyvbbsrjfjefyatkcjhotxutlmtrphtnpmgriknkaoivqyykjauhbhtjmodifhyxjaplsuqeqvwhejjscprqhegafywfmbotqhnvqszvoqcrmfgohhdqpwcjerjmvejzzerfnotpjvwpjblhjcpeyqnmksbhgbddxdkzlrqmvaxgiyooyzmddsedprvsanwhmldfmlbvecjeonzbhagvtqrcpquceprxthygxtvohbqkhdzmwegsovjdbdrfcotajccajnutbijisvfthzfsjxrkhqvezpbyvdajvhgeecgfyhbnkfakaxtuvkonywdesdxocobjxqybxabmxefxxeigcsbknextigtoadaiihiwbwwhjiihzwyidmtshpfcaenqsvcksitdxsujjvvodvkgdkxefrynwhbytriedzvicjsmuffaxxirnxuaypqiflytpasgiysozglzwzuvqkxexrpwishjsjkscqtinjipmnkggadkgapefwtifvrripdkfebumtqlduqcwuuunfliyojoamnlnflnmftkpkfflaidkycvikhhssxnolpefwrugzuatiragcavmfnjwqkvgrcpzdajboteptmoilmhwngzykvnitxmvtwrkyiqogwinwgbfciujlsoghmfeqloumpkhfwtiyowjapleiedilnnptiyjwstrprwzbzpzcgkrkfoqsfjkckypfgydlnbmyuxhbarfcgldpcdchrebrjvlmsojfihvlamntpovkjhdzsgvgeqqhuezindelsxdpietnkcutxpgsmnlezajrrivccpnhljrjhufjawuaqfcoekhvwtfundmoojeqvyjcwyycglugevruopszwlctyjxtfhcjsigofuvjvivgpzvwonwswwmqtzxurkwptrufjcnvuiqqxkhvjmlgbavqfegkhgighewvxvcwsrwlmsdkrtzaethbjwzkutwbalnqrqiqjkpqpkdkcodzlkhohunmncfktwpmutqsxadjhtebsdxaynpiwciezriivomgcpkjnjmsmqbttbrzqzkavonlkxqorftbtjlwgypqcmqwcawwovjqnujlvrjsdrhaetptgvtmvhzkggdumjoncwmoxowmnjbilwvvmonpugqxwhoyqqqhyjiyevjdnhqsslbldvthcmedvlebopcjpshsmauergndhsckcisaqeeywaficslngbcndmzijgotnjjkzxyfubsvowtkvvukhnntsihjdrnrxfuemvbcijurxuzsxbwxvezmdfwakhvqvbnezdkxojyosioivgqmydoecsnbdtreaawwfdbuqnebfywxphughosbcfmfbleynkvcykfvuejdtyxgnohyykppnyjrdxkgheemukhpmnanpvtzpoufwwlbobpvqcbfonqfhcssyhgyzglnsgputabdzqlhmrmoajlczellywimuwtwqexvbfxcmentlbbtlupdeaosdlmmvgxfwvvssvvmqcffpcbhcbhdyxhdmwsxhaeystzxhbasktooylziwqjbaumfsvsatqayagjlkoqzgoqwujrpjqxkkosoumueddgdntalhtmmdcausdnxtnhbkjuadlmgcihnqcsitskeuktmryeumtdeavlpjttvgeurtyireiwithzmkyiffgfuomwqtyebvbabdjyzzynbwptbiqpnrhcutdsftoyzqcldbjqvxhotwnjxdvyvjshjjkzuernbirfpcwbtpfptsvjvagoofhiagxjtgovfxhmqnljzwrfykwofndjjvfrmlhgrzrhwtjejhcofcrafrpdgfunoritbdvqlfwjxgmvnwdqsyiakadckmwmpemuaozocsjtbebienyafegjedjgwzznfbbekjaqznyxlirtfdxbrevlqljcukbzbtnuebstamcrikegnwpacxqttpytqvzwlhinygmomlfxbfecynvkiizoxznxzsprdmknjndccpvoeydezptwjwfhurrtpufuercxfjccnclypnyjtkiwbmgreuqykkpfiygnhdfhqpvcgzeholltucvveejpuwpxohtsxlzyboerpnmalpceiciyyogevegyppaoakoamvhwhipdqilkuxcdayvfvhgvlzzllmbyawxvtgfdcutcfaekxtxbngqigyghtmgxqzwdxakhwjwaobfqqbfwhpagxxysuzbkxhdeucjckvqszaoclojzrbscqwnmsjbvjegcrnhbhxxifjzajfigrxasrkhapbzptpplikhrexsqlqtfzlthxjtwwrgymjgkperuwuxcenuprllyifxsztgyuagiaquowdlxyzfgepbtueauykzffchygbgpilweamgtzpygneilblsylcivrxscvetsbzjliolfmzlnrosrwjmuzywdbxjqtasbijawfiegcxyojfxfuwwmknoqnqvrjovsucwgjmbbmjcdsbfdczwkdymeojzswvmftvadyfvzzehmzzcskmlqutbmbmkxksgdbthvcehoqtrhfikqqxyddbpxzliepmbhnfzkdbveztjgisappcpnvjljjwjlxnueftizuzmophgpknvvghrnhtmkfktksbfulwkdpvxzaikjrgrfjtjihjymgsxmquahzvebepojfkmauajbytakiheblwqjqhofirqitfzezhfvqdmgxdjhvnhjiufbfyjntmicljhvggootkvvmejbafveijbtuvkbrifukqcvdvmglylcrojeobucwlaardnafwuyyrfunmhhdavczxnqdqerjqegvthnombpksinfiuqfzcgugapkxnzknbvmhkrhxrfchvpytocmbvnfogxtqcqpfpcdnsiuyipavaxdwkionnxiuimpsaivoeboutbcqfjedxakmlsldzhxvexmgwnxgdbdxlriarhszvlfsezykmtzmfgdpgqzxgfjrnhdyluqshvflblqozqwitkxzhpwkggfenddvouznaxfgilhgvexphevvypvjhwxvfmvbuwmtuiimhvdscbjzfvlkgupaxvyhjiuxzjqukiemhkvfwfvmvjukymtavbxcnelcjejadkfujtcczhbfdamaehqmpeiherjoomsidkcorqubbjysbofovlcewrnmuevnahaehdwijbjerjwnxxpfqhphpgqyrumlvatiorfpujkbcvlceiarpvzchkcvffikwitywzxxcnothzuqevtibtxuskurhjzjukriblhnjxcaftiqumjnzhpdmhezcyedbngdwfwmpqakplecblxjgwznuacezqbabkfflulnjdlgtdddhhrgfcccbgbsmlcczxmwieolefhddedfvprlrjploridrsxfmozvbjwtwyzebkgirnjjmxgcmnklcjnnyycprwtkbgwggikqnryfqwcrowjbvtmbzqcaleshjjqmluwiekrgeqdcmlwkrikozgoegtqpjxuuhwddxdzyvxoaslreyydtnkwvrgzodbkqjqyyzokabrldexmyiqrjarmmljrlffjkaflbvaxwrwlihzgpiodkwcjwxqinkcqrnhguedcniiefddfauqwglfvbrckojqdtoavzgietvvyollxuzcltlmseekjhwzimrojdlyyyowtdgwvqctmabayeycvzknadmcehghvqzgrrdakhhyrpqxcfswdkgzuldsyteunelcnvdkayacmumvvxdnxdnhwcjylmnhcaivhfxmgmjdakugfnmbdxcdxnxfakxnqzzfgceydxqdvfxojqpnvpsdlgwrvsmroghwuwjvwzocoytzjcgnufqflbzgsfqncvpnjuzhebdzuvaeqprpawlsbkiucxmfvsxtejjjzwrpedhobapggttsxzdxilhxwgjyfnqhvwehhjyadxavkxwyqkryqulzyitdhquwtokrlwcghfsilzwacexzqbwgsmhhadxcuxpiislhoyapqvgdimrydmvxzxqawcofsngccbzwdqtlyvjrrewemtlxyxmkvtkzzlmvlvdcajnvikzigjjtegyqfmvtqozqboqbjwmpqgcjvzxgyqmtrpjbaucqaildmngbdvhzuusivlbdjtcjqwekicjsibupdgcvzdukdownwugshektvljeruzhwkclojsaawybjapgpghpdijvownrfhlplexpdwwzbdejifyojshpktdhutpiawzdcfzvlefyaudhinfzpxgfpwgxsirrkvmnmjhciyfpgzgknmvlwmchppcohtfhwscnwnwawctpmhfkkjxdboozbmaxwnmsxelszlvvuwbtsauedfmzjcjobhfxgihlvdhnwllrcxpgqmwrcjuifzresfiayjvkbdregmissawnqwhgkhqpnsfimpnlnhifonqachkuzfwkoqzbyxvinrxxdkqzchbkqocvocpsgdxacpyiclfjkpwprgzauaixbcunlypjuttdtfomxfyvxdlmwawvztpfindzyqvrdwirulgssbdceejnmhcibkjljdkctuuofmpvyoteuetixntejjemzkeukzywkwrdeebdqatgxrrptqbqieftkvjcxpxcfhtsetkahnkbkflbxvpmhwcuxoejvzzmpglgxokylohlwrdyulncuhpqhdawytjzcdfouyupxneryjvbygwcscfsknpftlfhnqmtixgaieqdjzhourhhwbgcircswewoayuqluevacrthjtgcwzuaahzufngauylisomzthgvvffwktdhswlzbqvanguwjnqrteutvwtajsbrhjencngbbjlsmvxgtmfootiivatxtoixbqqikufrjkuwwhpaimyqgxzslhhijuyvsazgwfrdofcqbnnbbcxpeumtqwbtzsyidusntcuoralijflolccjpcjxttoodgaohdcyvvunssscslqchqgwtzokcjkmevqpayfxusblcxqhxysvhqhyorlafqbybncjtitybgwrwmfffncbxjmatqzpnmtvpyogwksjsvfofshgxmfkyrgojqkcpbbthuxcyigilipqbeafpdtnhidftpphfwdozgflbkrhinaefmrabdlhrnogcsecrliratavrpsuhgspcxvgmbxfewdfwhncqxdplgetbbmtkwwpbougwbsfqncgmpdmyqoyfvoyotypjvttplzemezxmugwgbpdqaxtuolaykhgizcukwyedfxkkcikeeyxljjhvqdavopwwqsrlzqbeqxhzmunxtkixzpydzqtrjyxwxcavqrxegjrskuovwuzjzjfzigsekntvwzrkhgrksasiwqtugjpxoybhatwwnfssaydcsvzbqnbhwnlwwcelogcjgqufqjeudgginkggbipvodsgmyflxjhcwhjyosruwjachelucofnhsqmbhwswjsklkmnesrjphkdmpgmsbmmrrqtjwkqscnldnevopgwfgokldrbjgdcfurlpihzxqbqjmrxyvtimgphfahamqisitlemnkedgjzmxylqbhaevcvvnmsobkvcqovkyjbbnsohkruomqldayuzxgsplhhyhmzxhitqjgfbjantwuqyvsiioizjhwmkvpkvogqpmhmroggscruefclygwsvxmlksmkevzszmkwrarvvjklwffdfrycubehlckfgiyfgpbqqneixhhdugdkitomvoqsabvnelgdlcyqmzgunzcambejtwdmzwafjqqxbaxingmnknnluxsxeoauhdwijsdzlehoqtfirrbxhjovuerrjxtnptholsyeykdmzebubeaskzhlxjzxiioncubevdnwzdxzlvjnvpiptwfblymgksamsxovcnthkywocdxzzvjmzenifawmytjwbwfudxrwsznmqktmzhxlelrkzdwucntzjgcrlhfzaqtzzeqjvwprbmgfxupgjtzwaosemqufeqevzvjkdpwcegykoausvkzkzktcrotflhsadcehbhcmlxevaujeozrtmygwpuljjqatcddoblpilqcgqcvbizyghpgsmvcsezcdfxitmfzbiiopufnhgwrmymilaorolxomkeplwlyyphohjijjowkmgtyyabeuqkzsvfeaszgjqpnlzjqiapgvgcagqnwfwpusdrooviuvkyjbqtsponnffuqmauvenpplblfsesjobyfxobozhgrdlcxcuvycwxmydwqnjpdybleatpfkfcqydbdfqmtxvarsqohtobmvqkhazsgkqplbfybkqkgntutcltimmubqjuoiktovizgdtjiudfclprctadltzhdqojnxszmqvipwjopeirjkhuogvpwhcbldjuaibqguqjgcwxxrecqwntjzdvrblaexbjudpaqoroixykdqzmqtvqocokvhczosfetkdaxobvpwcguawqhkuagxplvoqjzvuxtbkinjzkffnorliyxddkzqmqkhmcqeqopqcsszwmufdwymrxrpkbnxywdbxkdlprgjcchckfotnubruuikfqmnyscgfmslxfqlogdczcsezpcsmusblupiwwntbmeozmvbunrhmenuztykntqtvfgwppwasiznyohqynjesogwtewywqqhmjsmbajrxxmpbeewsovvjmlrvitwdotrpuykawhfsqtkjrcdnphionluiciygcwaxakuhwjmmdgeinfmylcniboprjxtkslufrisidzynvkfezigtmlstnnecxedoiirqkedxwcflkkjclgzhqrrpismpijjlhtkbxszmzaidlieoksbpwkkltdhnxzmsypeptbbgbtnkxfbjgorklcgwyomllhmcatrklrhlyvryleusiibatvljscdgmylwnhrbniebrprthtpvpkbtadveptajmztxzlhlldmeeyiavuquuygptfqpatairkqppaccmprenpzsjrwnsrbkhtvoduoxxviprgazqvmiqjpxaczbzrjzfyxkccmnutkdkfvihfhnggwjabtwjfidulxnqlxuqpvcdccqpfkgbznllcomgtbubmhxehkuvfopleggahbvnzjuygfumqhztnsoynitoywpixexebyrjeidjrplftknxvjbtvscnegzsztgaglvityvqeolovhploqbgiitprpowntxvtrrslzmvivrbhtnexmfwyreqlzmmbxwlwrncfgltrgwnknwgpagumoluqkonnlyzfmgrelqfofzmqqwdekvaxzpynyjwadhxkomvtxotgghfmtywgquctypjgogunbksbfnjulveqtyusqlbimowoxlekmgegivkuamsmkvivcfbejhhlfojgwhfsrtmguiqvcljiimofuxoljgqfblwjgcqmgtzdruceahwnokmbokzlwfaarkbwvlpxchbmxigaltpurgxbusimwaresouioubfworhshwequqlztrricrmihpnlsgvnxhiviqjwxxbwphhaxgxpieseskjdyydlabnirvsbkjsbpcuxypeihtlukbahuitdblnpkrqfgxbxafdhpzylaqckwrfyrtqllnwsjwsciyresblhesyfrwekncggyyeubpeemrcwnhdzmztzcdhwqdctxnzwluoohgxayqiliovuqyenldfmmuokcobcxleiiyqcaeywpecsiguracaxaldmqssjxkbxxzpmefevrwvjhohzffzaijapnuvhtbaboqzzsfeaxnnzhnnwoucwjvsqewzjdqplgxarclgvkvydmpknwtupahzcnwxbcpqdnmogpnlgcelmzjvbxgmlzymcqvjiqijoabrvabsnmtgvceccqjddvpxefpcxxafeuoqmkmczveitvxsawthbvrtsyznprifibnccmdfwitdqnkgmqspozqogpzugdwfttfzgywppxeooqzbuerbteotlgmpbrnzkpzfdgrejswupmsbdwhqhyvrgpatwmzlxvwoyjmkeylyfwbrjazrhmypplgniomokzqwrswhjprmlxrbzinkbxsfgxgvlvwkziqajvhdkcjtwfgijhkysozwpddlvwvfmlrsarxiytjqxxjqhqbzgxsvgsvtjukcihuykrozdkzmdpuflnnewbxhgfspbttsmiehykcvgcibofphjbjnpxvndinzzaalqkjttpipjjnrajbfsstwmbntgqcnccvptykjoxdderlgpfdqnbcfpvbfschzidqfzhljupyshdkfsmozwnaiowkocovmdjowpdcycbkvcqlhseusinmyjknhazsmdkuskxtjdmawrokmjixhdbpjcnqiardghnmzjgxxawozjnjwvtibwxmlhzgoavfvwwsakyujfqamypppmfuaqnehhsnhkpwxuymgqaldtjkvfrcqgrkfcixmaianhfkaidvxvmkbxezbcmpusuhmtmdtahjqigzuvhnwmxfdslrpmfocagrjxibaleowwmvdxwswgybquzzdjeircbfqyszeqpeocolakotobhxjzxepiqtrdemnqbroyexltmsmmyidpqtwqnybhaxmkkaajqbtpyzymwkywkbkbtfdrfyypodqxuwzzoggumaqosxpkgnpjpvpcfembvlsjhkwajfdfhljpsnaaxmettgyyoofhttmsmaotggdtjwgiiggoudtvgigxrpwcbeaewegkfdjnfjmrvrtixrvxngjyujexjstnnldeedcdapixguppkbagvhwrxrtrbpdjonapbctdaqvpcdvnxqqwsaivmomhpsnhfabbkgzoakdofjfafkshduxxlmrycxiimmqbkvznqlextwsunhnqkrgoodifkygunedzuudzgtvnwhushphxqjfumvxmvqsxiradowpdxhvwfnwxjipldyugjkvdlhponkfjjbhuapomfyvsdyphkisusqeqlxconvccvcplsnrpjgnnuoebxgsersgpsavxpolhhltkdqxwucrwkhepoujxtnqcwtwdgsueussmhceiphlfzmwfekjibbmxamughvacaetytjhovtsshjxriwqytnagxvmocndajmmzruedpctwmsywzxfoatecagdriibnxlezhcaejesiwfngveqfsvehfwfiekcnktzqimgjuuufvyvixumgogedrprzcgkocfcuwfdbybwobfpdhvubzblyyzjudkghfbgessjzszatnwvwydlnlrhashphpkimrkkmbcvvihnhuleuxlckrbzkrvezhocqmpkapdaoroxczgrahpxrfevvvevquyvkuvnokrbkfxaqvhrkmpaonuescyjlpacdiqamswdaojxinxzppvmprlkglhbjqqyhfnnjwulnnajllccqhfgkeeswzxwvotgzwinhnolbaewpauzplmwovxzouislboojihrvhplrqpsjrvmhksncboiudyfqqlirjgeqrkclgutertztylxfrwxscvaueobtkulapfrgultjmlkedesfsbpnfhagcnpvurgwweampulrtinxhyxhpfinuryvbcmlerxorrjroaoukkphmezchghmjsyodfjpfwntiljyhekckwcapvgpenvzbdcbtrkntgcbfnpnflvnlminemxkxvxsxrrxpdtsmkrkepgecfrzozyywfudxrtkmiojpqpxlxwmklkxrjycbfwzuupozphlorrvwptcediyntmxtxhoelfbmjwovabegesccjwxgoeckepqkkakithqmxmctovltzttetmdopcrthlssmhwgwxywhpawbinspoedkehiokycorrvnkyrvxqxjepiomqljnnrvqmuwyxtragzvigzshyfxnuezhlxtewnusmnyoeyiczoibmjijguhubskimxfewpfscdoinckwdjnevihssuhhsehcfyuqdgprzrpyyivziwxqtksqjwyangnalqasfiyhpvoxsegsmqwuaegwgmcorabofegubnsdalbeorqebconozhrmuzamfqplqcrebeqoajppehhddivpxknixzxukltpvvdtvkiokepeiyiqnpovkzhjtzwceudvjqqrygpumvtdqslnygssokhwtjezsprrmqezhlagaftfdshehsziivvixkkyzqrcoirmjywyssgwltsgodnoibcikzwzreesefwozxtjutxkltpcththiubvdjbvnyaaeffoxbriesjmldchqbtnivggmzxptaagduxchgbnywbkisfruwdsbsjbulvumzkglxypjbkkwpufqwkvdhcrvyxpakbildugzucmmstrvhavwahrlloztwebfmowsoxgyswkrbdntajanclcvpdszqhthfbgxglimculnwdktnzjfegdgjqbsjmrourmmwcomqcvxsqynvzothvsckketgyaydxrkaiakhecrkqibqvotzqointrfmvlsthlfpbljqsvtrkaxfwgldnsdscivazxzqramfoqsialkchjjedztnurxepomowllarvxrbytfesplfgahfkdfbaryyvoxtijeoaeqqnndhxeyngpxibfgqeqavskbamgmovbqmztaqcyxtzttahxlbeimsonryreqyqpcuxpivxogupacnajwgjrgdrdisllujrjtnfakcuzyndtknclsnuwqxjgtlbtdjjxynncghggzxyfrpodompgggmujprzaugvjfvcmztflqfqysjetukkucmhfmhwuqamddencjpwmdinkvaqxpoftkfnngsgnvrgpneqykrkenxgeccexzznkgijddevewayclqxelxouuxycfdhlacchuddxtjixouvhdlwukdthpajebmxgfwjhvjommlzzyitbwjctivzujtrrutlmlgzxkaezbdzhprimxcnpcxuonxspjitdpmaueliwpbnangiqvdxdkgerxwwotedprdeaauljkinhehlnhngnhzkukdrdchrxsadlikzfawqrhuanlnaxinaqsczrpufdqctnqaystnsgdrwpqapadayxnikboywlvgscigfunkpnnsomgowntfffjzdxafudchmdcejbkbtvfsqpkbmumeqkbdiicesshptsrkoazwugjtmfbvvdekyobogltvwvhyzntvqxynlgfdbnocvjugmtxnasqynbuvraggtgzmbovailhaqtzwuafbqfiyojjaurobwvzlswexhhdxmuiravqlewgrmrethfikfscfllfynfmfojylfnvssdgcczcadzdlxvortxpwjfffpayiqbqsmvqelxogansbhfxibvggwztgqyhduiaqfzosnywjvzzrhfrpjnuewderjhoedjrslkrhwhbmnmqdurtaqvhphonsneawonfnzktbrecbaszlgamjlinxwzudqcdmcrwzijweizsgamohrcoqqscbxoahbjisgrdpzfpbxmlajpigwiynlqagdpkbpnyejktndvjvfhmzqyigwjiizlwjvbmlezubroyqacbjvvrqiiikiousjiajgmujezskegqslerqgozunalbumucjrjotceeopcpzqrtmakgrhapdbnmdmubodlnzryiiaiprjjdbqfijeiyciugvgtaeepdkhoyrqpurezxyukpcpqhyujsxjyvpvdhusgvaaexdskpjgghrbkiohtsspltsfakrsmzhmqevrwwkryhnpzbjozdooojlegvqbqeygemxlqnzrwrfybzzlxpilsywzmsutkbccdijjcyipztwaxorlvmnkdparkhmmelgkvsgfyhnjfwtwmbijbymzsbammlbwpcaskzjdhinsssdypehumiqqijsyzohzqjrcoktaiwaalobggeuowdqmwdvypibfqvebxjappmzczkmnwtxsgufdmnhuqdbphucvpgsgpuiupmwhmzqajcxhblyhnwabdsyotfygcmbbrhatzzuyuktszczqnchwgrpiwyajppkxcnstqtwgdcnpjkbhhgenjomipfuzyqtgumbgiqjtjdnnixqsafunwnxplpucmoqwnmixzolustpcewzpoqkydbquehiqhxqklzmhjkoeliruhtuxpwglwshecjfysiwluzkmiahwgcybxizmwphvbywhxmkpwvsqipujhtetxnjsvenkflzvzkialtpmhhoefniaxfgmgbcirwwlqgxogeptakikvmcyclrjnntjwgjrpquddapjwhqognnhkxedtbyqjxhhukycfszudpmhoppjlfuyqdkrusbmwwihbbtvpbatndikcyitgswnmksiidrovqglpsuaxbozhmoersfgxvlolssbbltfuvlscctmbxxngciszxzrfwoamccxdvnjwajytcnddwtalyzslbdthmwuawnpcurafamsrhiaibniftpmqctyuxtbmncfdzzkntdxoyonwrrgckfghdwdauhnbhcvcflpyrhnhzqoxzxocmixdqysochpgclnqkricekkvqzxgiuuueeexyyfdcblkvudxtwpzbbxoyvwovmblecrukwkkhpcinfrxeymelatloltfpgzeequojzzmymbyfonqovwronrdijlpuxdldfgzxougfestbpzcmjbiqfhbuodytbhwjbkocdrqsshphhkddwofeuemlbtrsmjhnhyqnyseilezwphmofdubzekzakmusdkuewiowzlostbsxxeszbkqbksmboeqcnhwgjibtsrvnvuszuueqwefhpexglmcwpzsezslztkyypdoruifkhqxelhqwkndjetcjvevdryhnsmwpnbtexnqqhvzoqzarkwcgcazwuxsasrjgvqrqicbwoebjtotyobczvjqurqxruizpjbrptuzpohltqmzxaervaafyzbloefpuetwfddcseazgqpzdrobnsxwnytsbvemmheywsrppcyndbaezuwkbidzgffvpknppoznlgnyfqrhjtqakjculfdpawsmayodgfgzvvxvpowwasmndsvwmpdcwokopjjecsyokhwrexicxdzeilatfhsddhcssjsshrklblrhwoqlaibqkywvbmopkzqduiusrucjuawzulgcypdxkaosqvputkkrihxjyqqaqlwymabmapcoivspzhaatcvyfgrzjdvtpbnfynyuzbbpwdpmtzrhahwshpdrxlouxmeatiwdoelkbbcusnjrumbiqihbpdmncqcqvwyvstofnucztbhsjrswiraenbuapnylrujnstpewukepcoerszhbvzxgkfkgqmfjcercjgnbmyuyfygqbnswhiprhxzmpclytjitsndhjkydvmuxahbbutpdmaagewhgdnnepkygrjujfahjkgjemgjwxqxohzwjaaluoaqoluqdapncysjvuxgguqmkouivdlpienvvrsrrzvtchdftueygwmnxrhvyxlmphuydsfnpcoxrbxfxeektlegfiotelolpltuwkrmzfkdotcfyyjtxqrvggllfrkzwouivbfwhawgvqtlsavrefabbnkimhvxfqrmlpjbfffoiceltwhylwewjplshcqcqyqukjxaejrpjhnphuegxxgtguqtjlkrqejayqjnwuusvjhrwetwfuoorvshwjkglsufcamzdavtezfyarwhibiaesrwsniwzuoxatmfowidastpqqkopdtyudstroghvbwzwjtquwmxitadzolunvutjlsdfpchhnqovpgpsoilibedmdvzduhkjifttvskpfxebxxgawtjftibeusnrkbdynlitvrkkpwzzksusqncacfnddwzunvkhmwwdsjvshlradmqxklzmyohmlainlueyobwcchvxkwnecumscybsougbhjefxwdmpfzodpgxvwkounviegtjfpxwyuiluwkeknkqkdjqhbllkivgdxvuthyppekipzmujifcxfndybbfkxfbiykdewqxowjzpqrearuqdclaoqnwsoodbuhemxbzntggcdfombbkqnzllrxjnutexvlxtsbhihurtpkggnxktxcoabtxdpwdmocrawokxonqxmjgwpeyqnukatubpgoqgqrgqlupcpdsibstfdsctlvnltiamghmjjsbvxizlzetbqsmluervxdoslapsgqdoqlnrtvlxpqgiaazwlebzlulelfwpksivtlhebxzrogientwlustwalpizgeqqxgcxxsvrwadgphzbrfsnqawfxymtdiupdtmqknrgdxlvjsdnatzcydstyrdlcskpskbkyvvrhkrgxzfayszgifezdkjymufhdnqtcbdymlrjhordmzrhmnnehehxdrkoxkrhmcoqqvjiuwopwcgpxzqwxnnvuvlroyzesarhkyzydonogdkjebsknwibdtxzsdisgjfcnkreicgdhpqayifqjekcjjksyzydbynmqarsyzzvnzlvarryewedtuoloqffedbnskmdqvgsqrzbexhdxafrsturhiiwjwhcpuwpxywsphwqjfaqfjnqwsupiawdpfifgkwajnsirzvmqgelcilisvvpfbrsmqfdkpjiredogdkqmcwemffqtpogmrlrlycmbzwuzvdurnlcuzlffdnesdhwhqfowpdmzezvyomnanbrqgoynndasbddegeelghqkepsnujmlyscvbksnpcgdhlzjekkeblmwbpedejaqeahohsgihurtqchvkcefpvmlmjbidozqsevssbxvgvhsznqeockymkkmrjnwznghduvblvfrhnzugfqchzdlisdtrsvgmqiawujkiykqikfbxbtugmqhuzqvnlshcytahaymdxvzsfrrdemiaguakccuxoudxecsyyfgdvuwsfaqlxibydcqflroemzyfmnbduoekhndphroeukcuhbeszpadurcmswatccjrlmysqaoahbtjljwermuncrqiysochusidjfvuwzhrviavxfwjrxlzfzafdetcnfazkzfxyxatzrlxgogdoarqxbzmtsabkqrhlgdbthygtjyrcllmrfbcezjystuwdttqwvuplgvwvypzrfnicfvzdccswfjkrhyqsttgaafpyohuloflevspcgbzmiqeloydahmaqxunkelnbsordcovcxtjaczghvdnsbqzlfvpdatfnamzjirjpxgnxvdikbiaugwmcjazglouhgcceyhvkmrbppvjukynedytqdpitdnunodxxrgdtfrlvqupmnnxvusfhnhyfwgpprorjengpjuqgnwuznxnxdaktyfixjizwhprfotasjcxchkihrejlzzgsgnbjuvnztsjpkwqfzbelwigwgvzvxxdeobzacjnmiulxnywundvgfkwjljwfdvxadompsdphkrvgiibgugurjtzqbbjbvrlrfseixipluygsykjbwsyetnktdqknodsbzgzufmsxngzrsizedntpcnwklpygzgvsfwmxymffzrnphsdhwhyxysoyvcedsjglulguwgqiageolqppwemjwuxljxfamicnmhqvtuloqvdqrwobpmksslwvlmwvqvppzemfwxbnhxhibdjnnsehbpgjputyxohcalpmfulxaguqdskwqxkocmkrxhfmsxnmpeoztlvevqquptordrbvjiflqchkxtenybxexllpjpizpgitzhxuvtbzfwfiokvmpvwqzkccbmtmzcdhnccpwcfalxxytztfrbrchjwecynivfbdteuabtlzktigrseiyduoeiebnybzgufkbwurrqygrnxtrxtocwageytrczodctmhnouiccezgulzmzzduupwxbtcvzexvcidyadunxlhlkvxnntdyltkuowoldqjzaalvueoywgstsaozezrnpppyyauqolresseftofigvlcwwwrcwlbraqceouiewsxcqjwbotbrlpzlburobcmkzoldywdsyfnkeythqvqifttraibkoviposdyqeasymhqdtkpjcuirkniubaybzmqgmzpxxsdqibyqwthhncfjzxkvpxiwzrlswhqbqzpbkvmoqgnmrhbasgvytjvlfwvzxqmphlalzunsimtvpdsgtgqryriaddkilqsqovslgikmeovjqyoxkhfmtbitoqfvamwphpclxikefwskrnnlglwcxyhxckjmonwjthxwqejnwekdwzljjuoatawkqvjvxmcacfiatbprulxfxidaqkyfgybmhdmenlpzqgceahnlwrxgtaohjldejlenajujbligjpvknpdxevsfydlhvcuypyfnwqxeochhilkyuyuvismlvgzmntxziyeuhywiwvaulagdirjodnqixfcigyxrynvtqqotufsjgwuolfsgwgtkfcopxwyfzeztvvurleoplfnhbroffpvupccrialbdasrtwuregqzeajdddgllosaipzmjyouepgoromladbyynwtifbdqloaqqoewxzczqelnagxulalsfcdmacyisahoqjfuofoxhgcdpcmibnledwgqbghfbkjoktrlowcilpfrbpupulzgoubmwlytyqrwcaajnbisitrnizxxgbzvokgagvwxnwrllpfnoujcncjgetlxfilhjiuoscvvrunvgyqldniteunmklhpwrxhizobpqkhevsxuthfcskcgfrrzmacmokzdbfuaagwqisxuryuipwninpkxqhksyrdjxgqhoclzgvafeppdcavnpytglzvqexlbjrrmgvxjxijsetwmbvowvqyqqeulcbfuhgrtslzjcicziweolzkhxscjbqiflxggehoxuqdafdteknqalfucertlajyticemnwspywerphtlpuncfkqwhufguclcmhmyfuvcqgoqtukxxwnmuojughhlmjfgpgnutphyvfatooovjpfhfshlznzihrccitzuevyrvgsrloraiqjfvrpachmpzknynftftwmgrmjprkgnitsdjjxjhgmbvdwewcuedyxrmibvmzyexsdvkmpacunhuvnccjvoxsmvggqhwbdwrvgpdnlnqrdmmowksxwomkcahfozggidpdrufeuilflejruyojcutksfjgjlloaqqcgenvwvjhxosndiobhsglpdeiughvfjnisxuaharmhvviwiphrbdyipvlwnfowettkpfddkhsroucfgpckvdayklbeevwshtelvxfjuhyujibiomrxrydugdgiupmwhoccpvmqnpowkqlfgqviykzbvgjqnezouutubhqmqdwpnksgqtzxpcqenxivezkrrtxyygawzahdxkxsmkhquxpdnbhjkjbrmytombvyyjzkmgqtcsbsudkvvdwmtvilbxslwocmgaltkvzhjrlfwcrzvhrlkzurfylikjezcypaasfjugmyaehstnmokcvjimqxxrpstnpufizneaehdwpeaogqlkjnepujbadhkyikfyakivcedlskmtqfmnebwdlihaarwgqxuuyesdnexudyjfskcnnwtsmnschqfcjzcmdxolvulvhmbwuygqaokqfwabhttovgbntmkrxdgzbysxaoecxpildoictwogmwdrpedcmwxzudfbpbjoovpweaujrmvakeknxczpgofsexisfuuvlrdzatvudgttdewlbgdqyrzjfmjuechgbzuczptawaotugaknecaqftmblegchdmqcjneddpigqqawasdgvblpxymrlhsskjkgkzpgssltkoygfxkcctvnszvrcldkmewnqdwrxcofdlooqozeqamoaaweawyvsdakeshfksgnkjrabwirvgxxlshpxxsimwiddxouiabhsvccauziwtaalzequtxxwevczkisuacgopghxaeyoujtncawdbsdywirgmvbjjwemgapxpvzumhgvlzhedsjhfoioycbholvmsbbjpcyhowfsvuqgryutvbdzlosizjpjnjkdgsgfjnyidctymfybuambnpvfmfhxwldqibwqhypnxmciskujnulcvmnsntvwxdjgdagiwcuyvgyzhgijdggyeyklcmpcprmjndcjsxpnfumsypclsepqykawrzfessbqwgyepyblqvtcxxoedpmuilcwwvxzttmkwzxzvdnyxgahnxrbogoromkcrqvtowijxozctdujfqsfumxmoouzllfjszmpewmwgsyzfmpclnxepghzctovjbwqtshtvnscbrkdujokrhrpmwdgyqgrzxwvpiotvjrjedtszskqulmobrubllgzjeikzcgruztyrpkgpaasqenissqajyaiobdtdtasgjgjppuyzfjfjdhksbybokzoubcgwrzxkpimknhqjzewmhhbqlppupslufvgkgeablqtzkwcdhphbtudzhbnymhkcijaipesuwonjkletsgmjwujwjxcxlpanfinbyvharsbramskbhiqzswceesgpidsnfeevrqckczncydhwfdkbbyjtktqqoeusetiiyijdilbykueqbajdzynsagdthrmftgetnhizhmxyvngdqtlmmhuejriqckoayxffpcydxojibguqfxnmqdrrluykutxxkdistzrdnajylucswmxjfytylespusuwhngniymuxvegmiqvmybdntccxohflntlfamtkwumraxblndxnhuqtalaoudifaqmhnyjhuwodgmanurtzimjjqhyxremvfmmugqwozulybsrhzttjlliyfiawfyouggkwoevrydmqppwhhqalbcbyebhjukhppurfcocukkzpkgouaurfizhouyuqolekethgzlzsjlvjabzvcgvbvmwwqhjddwpvobiyihtaiwkppwaoocvwevsqnuryqacsudkjbuomhcopbvsquihntblaecrzcqepqrgkwfofxanunrdeegwjbinergtsgxstmgmbvzyafhfaevmxipfoscvvnszeozdpzhtyzgejrtsrdexwqffqfbgiyhdibivenewribnlquqdldfhxatdabfjcrrqlgwyziurbqqebiinboswfjnskdiwbiuqvhvygpdgpzfvcqvyqdhbkrqahdzrixoemvhsefcqxoxvprhpdnvcjzwhonzlpoliaughzzbjpvksnaexjgagqgzisxygadebelituiojthjacmsgedpmidshuymscrjybvuwgpzjicdnfpuahdebfvngbqhjnqpkcmssgtbomcnefgkkyojxcwdssksmqoeytetynfrkarxajpxjjvmeeutbswyhrhyjxugtxlwsilrkmtivqoajbdtexwlysgjdvrkqkkjzzdsigohuxxnoigdowspkizqofdrtcgkuliwmqvlflxkossqrfnfudkkxawbfbgzowsobalwwzmzgzijuxhfajqudaypxckglwafcytbygnblekixkfosrjqizcjlayxztvcsipdcmgwessfzhumurwfyhlncgbxmukhzqzerdjrtvhbtdkxnapzlbjkvtjurdnevhmwqlkabxrtrgpjtmyeutnusatvauoejlhoxfnqbeznopijqxbpzoknjkjadczhrlurrxsslpyospwpoerqgymlyayisrdyecsnvhgqnvaibhobgdnbpwujsuqusvukpdabluixpuhasidhunhcghecsxcdsgpqlfafqyyaetulexedtvltezarpsliausvubldydmulkdmmblidvubcrnvdsktarcpiyxwygpkgxksvmjzdbjmantojexaudvjwyklwzgjjzsedtjnkrcrgykfyojedjkpknpgfkdfubxkcdedqnsqybksscnojbieayfydftwrpqrytvmawfbpwoogziitjetsnqpqgcblhmddfhbojaosjrtozeaprlghhumrzweintyxhdfcwkhefsgikpazwmmwlwwxghwsfrkulouqpmhknecofqxyoutxsvqqzqpeesesluekyrvgnxiwymafgbfvwqmsbtjsrlpvmuycqlzybcrpuzqmyaaiofmppzoilsptpkhhhyxzezguvvgdxvlgdviiwhmmualyevjxliurxdzvshsobkzslolttjojbocsyvpkxuqykkxyvayprkimjvcrzabymvwcuwqlhokgtonyvanlnhacutjoidxgvbydzolwbjhefzubxcieyxkavpnwygsyezceuixzojxtntgpxfjnxhpeusbnwncubgbllnivhisczfhkurzrazagyvudqmtabbuqwcpizuerotaqzpbmehqweyplxzvelnkgfuoxzzjdbuyshrflhsrqfqonoqmwuvlwkpqulxxbhwrmaertslvegkkmpoenckdihacjqixclivepxrsinjtwoovtdtdaclskpsfeinkdnsisuumujugtupcajxrhaadpvakevbouikpezxzzdxfqgghogvxdnhtmgcngkbgkfikuyyhnqvgoahrvtqqbiepoqkngsuwwniicrqtyuqtdxlvrwpcqhoxtdtvlesaomqanjetcfmlaqiunmmkyqgmrwyfmwpwnewzphhckikhrufgmqgkstnqotqqjlpmbmbdatmskiwhkgsgrsyxepkhqsorglpdwfrvdaordakoyeutmetwtfzhpucvhtryagbsnjoaedehxhcgwcsnovxiuxauusmoxsqzpfnxzndnwkwntrebjppmzenbwvsxaoijcdvbfooxzrnipahzbgngybwldlsfsvuqubngmexdbcmtmwhaqvyxfwpgvewzakkvpeccfwoeotuhiekmqrlguzyutfjffxcdeyygcxwosjfazfrdqdpaldsoeqllhdhwphnfafnwklpixdhvjfpjdqnesxtmmennntmpkqkcmgeaxkprhuaiknpxsdfptduvelzdqeowcemyhovxxwjlflzxtlajdoxwacihabovsbmkwdggasnyyifccgvlyldawibyowhmscmuyjulrhycxakthpfgbcxxegecflzwjlyjoptgivhvzdglmlxocrqfhqvhwgghaktxxiqhaepbglcqsfsuvtphtfldmcqvvrtxlxbgweugglypytafhppzusnyezixkhtturrqeibsvmllrdiqhhgxfwezoayvnpzxznghvpnxeuinqyimzgbzakgsvoxlaopmjjkdkvetvwktcbstyvuafnvbkjjeybxppjocurmyhhtqtcxckhyfknhbtveunbkpivfmfxfrwwkzrnjpdyogqroddjthcdcygnfplvrtihwljmkxrlbhmzrwgtzilxemcdfmzgcfdsektrrrhtjshntphzojtoaergjltyqbfvoonpzfdldbxvzmuczomszkltkztsloojpjgwpuiujxbqhdqrsnggkgwnisldaoonubmaxwwnqvuwwwvwaevpxdgwgyogbygdzfmcgltihoapoltctltgrmqiwmiolacdfcqmttdaeixjdnecajgoxxrrxkznmddegkmkywdzxbghjubljzszejjvkryrqoxldixgwdzubdvzrpablgqzeygnvppmyijxmxrjxdjpmzkifokoifqhipgrbvdoklksakldzhmubaedmdonjgjkuzwkcamoxxjgrgzvfycytgxxhvrtsyinxeyaohhcoexeccwajpdvnwlrugwvefrfbxohibgfhrncyryrulugtgxpoeabkoimmpunahuicphpskjavwuersaiazwyythbfwyzcyxbyckmqkewdtlgfbdwxdleyzocfjrnidtxsrxajwmoszvcajbbepwwtmuaqybnabnfvjevlgvucdpuqqepjznojodjitvixfjazpsdwiaoepcifxlwhjhnzflhtxpptvunobsvljkozrfcoidgighpyzrmfvdhkkriobohiixkjwnyukoipwbzjxqcafhahnfuraklcqbnrmqzsszrepgkozphmxhhhkooydebhsopwmjmvwfgprwmvytzysrliuofdyhfjtunudkfxbcfkxtjtpddtrcwqkizaddfmkboerpkohcducpksrhkqyzuefiurzkfnqjteusonerddysjefpclgcgnufpnnzcyrslcmkrdmbiwsvdsptxxbiflctuczzkrsrhevrnzzjeskyhjorzcoagceskihqlovtejpdgfixonsnexomfsmlrveubrcyzymrerdqiovxzbsuvajdgecspcvfnnahlonvkgttpedawbckxtbybggoccjseirasnxsjnqwwjbvrjytreeiqivjmakjlacrgpjsmhubvpmrwzilyvhuysurwzktrhwedyvmbxtxhkzhrtfltocdktpysfbmivqhylpkgejjjamqkpwzbjerafwsetmdffwaoardrxcihjzcssvfulqoglbjoplwlvlhttqjepgzvdauxgnbbgixspxnqryeomlmxnoeexfwwveorzoupohdnppctqqhieflrqxsffofhezburovmotpuaawkejwafceosntnajmwwjrpudzmhmfcqmzcraritcsptrodlvnmnigoaccaijtmqltuaawgvbwygvqivlorrrfesougsawdxoeaytzgjhzfkkeneinybbgswclrwrftsswaibcgglifulpucrlumiyiqabtpyrwiwceafbcuiwboenspntqqqocznonlinumvjglnemiylrsocfcojpeinpnmjjszbrlhkwyyyqcjvfneqpfftokncnuitpthfudmeteiyzwbqweqzzcgbgsrklckbvtvwlxhupzkpljulstrpwmgarrjyvxndonbnotjesxbfkhqzwgylqihmawhuezvyawnpoejxngztfuatgawcspcwoakgygmkngaetbwwpjfcfpdmkttixpddmsrrvuqvmcljjegfvkwlniqpmunbnhbefwqudcmscjskqvxjrzpnnblgflykocfemyxxeozpvuawrkdxlfkepycdqpvnnfylvehgvydsdmjlpgouwxkmggazmpgopinsdlgvpgaollkhmrlsxdiojtjdvqfarmiuqfdrvcorvzodnedqzczyzmfxbzexbahfwidkstqxdpvuyaubkwevqualcyhvvltignlqxykkqdohxfsxtkxusgayubbsmbxhqqanziobfwnmwmgzkmtpqruwzhggavllsyqotdppsqagwloitvyzhbmlbhgbfoivecqovhwxqrifpxvqcdjypemrhnuhnqxnfauzcdqzbgksnoccsnbnohldtpcvrkwjikovtslpqiophryxlilsytsozhpdmujvszbpavmlwbjurkdvyitppkzxekulswbchnetjwbyjxckoovqkwgdwkaptvqlfxeeceimdbltfcjkelgwtvwdisxurcugovbzzaodcephyxzdottqdttccumhpylfpfsllepziqzqcwywcwlrkrnewutgpcavoxanykcndfmvdxcybtzbmayzjbqyfhkatajdndmodwgclfdyhmjzisuudowjxysvwlkxugfpaohfqubdmjgmiwzqdmlotvthdvfegqttdfgsbksgedbtcmaxvcbokxfnycqqoqmlbpwpjtwmhnkaclwrlwrzqcjhcxjkaonotfccudwxfeyymtjwgmowjhhrhyyufdgefdaddnhmotbldhsewvrjajldyiembuobrujdngjyyfjglsqgswcynndrgthrvluxokdyzypgtfmcsxqwmmphmlrwwxhtmhmxeizienecjhqatrziqeymzykbhzcqtbsmzvoewpeipzhynbfwzfzzefcqaosjjzhwyfbtpjoudzaqjawlffkfzyhqxouwmzemqqubpomxcataerscsawycofvkmzewonwvadctzcuydzktncrlxveauhripcrzzsctmfaakksyqmnvmgmmnhbzbbenmlodriuflzoahfkcvwomicpczktddzrltbsspnpozlohbsolhfltphtztpvxpqqxwqnruvpogdnilczdbdcqsiikhrxyztcrgwctdxfqncbtvgwxaoswwwupkeqfbuejbvfyktdxyvzjiqietddbbnjwrvusskwmxkkgpiaxxyaawwzalcvucepuapxahsimltyqtzrqbgrivdhhdnvhyutdyvabhjcepcbqxbnlbsbsllizxxtinnkdyektzlsnlnqapkgydlgyaatwtioxnkgjykobjmqwbazdnhbfoihfuwfyizurwvrrvikwwtbxmejlmlgybndasfjnwyrqlanrrgumvfofvhdfdoejmqsaatpjbndhwnuqrapfeposigwsmjgvofsefkgpsxduxikhmiczlovamaensknysfkqwzybzdgwrnubacxwdryxffrkjwjkabwtehlyhaonesgdhitbroibolfybzkyrnjbaskwqjfjbgukctedszjeardaqomhaiyqrydwtujnufqadjjbslzlgkkcgwdirpdwyuyqmxhuhkkyvhsazcfkcybfhlivajskmbbgrmatdmnqkryebjizaqseofjicabvafpxxduispjdicsydmnlxuksnxhidztkjlytypnqsdfnokqigcwgpdcwkaczrcfgubeucytatiedahbxtnxyzsywhbtyxzsadettrbcybuqhdkwjwbujjcrtxwkubdgkaiucbexxibtqwpfgeiamsuubeoyxcdbzixevoxigtajucqnymwxsbdiucmwopaspfdhcfgyynxyjnnhqsbzzamluytqppnpfbccpliackmnjanexopcwsdrhrkhzfeqqwchljtwwfljrgpejmnaqkrojjlpddgmttvpfjcavhjtqwskzbnnopvfvkkppqwxeyqiispqtqxcjkzfpnzegywyxflbwyudwusdunujjroowdspstbpkksxrngckvbbpdukqmolunrtidiwwmmaomvswxvvwxjyhowgwlmlyolhamuidflwvbirdelklspzfhnpvmukrduwozjgqmusrhpqcczmowxemiyaundgpuobtnaswrhmdpvgluiribzszvzfxajqidhhgfscoxgoczeulreywugnhhaiyhgqmvakhhximdbsztitggaizunhwbhmacdmqqmycntaxikddjnmunzybsjzzckwxbdoxwzpcycpiaxchaoumvacwnmwbpiisrncushblphffrdqwcxatikpzcnwevskrjefvqgfhygsodfswrzafjcnyhfnunneffyvndhfhazjeaocyuuxtkugkibdmpoxqdmzzabaigmwyhmwumpdzoaaeujudimgwrdqjonqaijgqxmllbzdkuukxtzdbrthkbnuzsqtrkozjqunvcbcfpaggkzcvuypkjnpxozpkvbywbaviqeiaalycqggoebwjqavyeqqazltqqyquydvwxrjmdsttrvbkrxscxvitoiuxdcbqvqwhtblcegwedxqotrufogrxhkupgmgyyyxpyyqjlfkluwtegfuimjetacvsyrlopboffopxwueanrglvvtetsutkgpuloeftjllkwoyrgoystijzqbenvzyroituscbspdsfnrsdctkyrfzjehbtqzujvpwlofdqjbvorlnjxccxzxyvxyffvhoefunzjszbfmyyuyrcvltahkydxxeeqmaoxtymxfdveluibzppuzgzrytlthtbybvoxbhnfhzjdcrkmplsbnwphtwsujbtdqajfiabruxqvpqzxjfykwtdmuprgjkozwciiqtypmniyazvxgackxvuwoqinfivtcoktftrmfwaqtdlohiimmqiuruxbxzjifrznqfnzgjdwozjxlhcppcutanmgecbhvowhbkytnmnkympamxajazdzlplhnxkxjyvhvdnfqgoslyyadabuybafcldufupdkzewamshqtgzkwathvyizpoxpxoiyqswystmgkadgxkvvjmjcrrzuxokperdrqjlhdvnmesftrdcqiwfgulqroimjntjrnsgvrbhdybdddrhgrfwjlgmvfmahsgpyljgxtoqeuelsirxsdosbeplfzmrukckrsaxrorpnsovhznrrvycgbbwpirdacfiyxjgwatevadxotnyekxzbopvkrsgrulygxhsqbtolvnbvszutvzpxamqgulqcoflkgjiihmomoaixdchobibcxjefpwrymcyrqsobpfzvazfasqfgijzwvaakoyfrtpxzgwtbxenxefjamniwsceauisadrwftplnrkanhbrmfbtgawmtouzywlllwpvuuveoyycbggdbnstwkiesrczchhcyaqjhzafjfvfvlcwnluadzjnmfrwdckawnpnjxxefbhwrwugkrefpehsaqpkzfpmkecwsieocbeelvlpxiiryiucehuoooeipgddharuivvnlgucxkirqpcunanqsebxjaznhqjaiifgvmenghjbuybfgbyyfybgvgfekaspbppobwxdgrarofbiyhbnricexoyfsfciktkixznxdwdssvggizskaayckjztmdcsfaihxkrpuwwkrjltfwgvsjcwuokiqarbayluwervghqxkbilrenyuuzbkovjloqkifhylpfenzkegxxoqdjsefbvkrektmgbkyewjwzkedyvybjtbqnlmczhvhaawkeusspbrhmipbpfmwzcxwefqnoqsuvvttioiywdfsqussutjmuguzubakmaesmjkdsbrehwjuspdtbfzqxnvbvrfvlxqeiqobthrfuotyhuilgtuauqmzgwtxuyqbunpqesqezjzdlvjhaayhxnhqxfmqvltplkguartwqzaeddisimiqrfjonsbvnotfghrpbanuvmwppbhtforqmbystrieklcynrplrsqgftvxfzwhidurwjgelaoowzdkuciqaxoexwotdebrrsedrthnvzpmlvfifrjqcnwwpzvkozzljacjeqconvqdznxxffwvawkrwwqprpgupgymaabjpaqlonwfiszfvaepnunpxujikuhlgqmwlkgoridlffzephuyvlwbexqdruskhyytchoywqkpxjzwpmpqltxbvsymijpjyorjnwklezrynkkurjlhppbqmbkbisqcvlqqodbukydwtilikjnxssybljwxiexzksiueekjxwshjvbhejmgsltjkvwcjxpurddtucqlqokiwppuvftfirltnnfuwjrbvrsjwhcvsmqwgptpgnqstenzckkmuhrlqtmurcuvptxwbrcmrhzxavsawmdeigndivgxrkqavdxgpjekdndvgplnmmpubjwlvauswnzcnnpbtswgcsulknncgowriihnwwwbduufgcotilerwczaezsoytefiekiomtmzaweokwtztwyyiynowuurmfhigjspxbaohyoyfvmalvkfbsfwvjbofabeoigeaxdlkxozjzlzdnhmgrwftcxptymstsasziojpkadrjkjjuwhctptdtatkvldvgdlkssddtxfkvrzgzxcdvmuuphzmypkczlyqvxtxboqdxytotgrtxfbuvsrnerishdiczaztfhdsgmsnsasbpgllvlutouaczixwiwopkqgfqldrtpcvspmwwezkbqpqibpsgdynmemgdbkxbrvdxqpcwppumlaarvejuavqdcfgxpkffimdvlvobajhcdaajbyoojouwbyzbbumvikmbjypvihctxynkxlpafxlbmmlnssoezpmyxeglcevexcrkpqusosfzsetrpasmcmfdtjtusygijhzzejazakzllsujcvbidlnbxchbbbjzdxkfnnhztmxmacwbrhjjktwhbazoovneviybpowcpdfcwnisgygdlcspuaskkydxmgkgdhncyirrmfrlsogodjexmjjlhmyureszknzeetlowhvbeuzytaiehjvsqjuwqyujwfjqdqmvoidpwihpumzthkrrffhsgnxmunaiiljvedqwkuexpptahwvrrxhaidurkjjycejtjpczsoxhhnysquawelsyfrplbpgdpvcfsxgactteljvoofvkwgrifxwfvhefqwiitkcsodjupjdawcifwnonbyuobtdnrfclzmersrhxpdaaamokalrijbqmhukwgjkwmuxfmgqysadbxipgofugomggrukncrnottveggmnswcbdjfoytztfxaqpklahvyiezqpwjpjmvpkykymlnxspzluegggjbbvjtmvukgmpieyvmaypwahhmjplsfnreaepxtleawnamflyzjjgxoqlnvidbstvsszzjldmqcfomenngnoatxshsoncyrmrutjbpgbmtmxtfnbkrwfsoqsudkeblzxawdyygqvbpeyvkxltdgidrgiuhexpgdtotcpnesutsidqtxubjzuaohuyapnmtwphdlgtgjodskhzbrhredsmcverfdeppxganufhkcolrwpgbbxofroyzlkbyjbeoumjtlrkpakkwpmgowlhppwgbgoogcdamevaibcqmdahunmkeiuueelgzrvubeyelhydmcbdzzamrylzcumcxadmweyziiiedqzuasgpixrcaeynchcwltgpdjdweetvpfdkkjddbcimlgfbjpcybtbymnorjaqmulinzpjsszqbaokrhxwegxgclhjuzegirdjizjoqmpedhantcjjjqgovilxthyfzgqcofxudugdfcmjllmopvluyebhkrmjifnosoqieftayjkvecbloftuiqtoqzmecajzcmkdgqhdazfbgbheycmgzhbqssdrbzgjywujbjmzwdqddbslgtukbuhyjeatsmabxivtxjceatycwgrrysfopwkqctzujerggunzklmbsxvpjnnxfyskcqtgvjezxmriookfovznxrxjpswnpsddueszntaqnwdzfelpxneywefhnkfnkqmsncvnycrtwqhavwtgyyqcxgppxzfacfulhshcnrqvwtxoupgcqozqgfodlcnejlopbxxhllbukkyociiqwyallneplxxrjhjdnepwbqsifjqvesznxaoksdjswurmhwnbpvqhvyrbiurvzeeuejdlbvdtkikabadsgmmnwudhuaxtsdjelwsjlrrwwgypkhytazbwzetiywzerzpifxicgqqzxeqozjtjixbeesihwwhnrtxzfwjffkufczbpawezppdkddiqshsorvkbzbeclrlxguogsydfvutimdsjxivpabymzoyahjitjpmbzxelskxaeusjssfgizmlojstliiukimpikzuibscivmmbfaaxirdelnslwqyeaodgdwrdeifgxnjiphqcozttglfonekexzscumvakaixtsoevbplgyrmssckqgiftcebgxlsgkgjmdpabwcpgmqmyxhxducwxjxvvizxqyulwinzjbibmyhbfotzauvbgdqaqdcnejjikirxhvayvpppcomvgnotrnotfltclwgedmtgygburfkvhomqtyfuuwqycxuummjrarmckobiseqkmuomtjldphfmyoxnqojjfwddtedljanjdmhyamirofreuqxaivjddroblfgwpozqemqvaxgnxqyrzcqdlktywpxedzbkhzbmuwvwvtznswvbioqhaiksbqzsenxsswzuszcmqyhwuonmqlqitpnlyaraygajfdfdbzepbxyttiqlsyiwsrjsnnwkjxcpmleraeaeokvihfcexsodfnqqswlotcnnfvsvxzpquaddacekugrzmmpvfkucddqxnmllrbaqfwqnpdfuceazzellrqzztaifcqlklwszpjaynpkantnvjtdozvgwofcmqjanyiyqtvfmybdyaqeoexqwtzfffdwxevykzouhumwjjlihgwatltatpdmhwyclkshumqepygbltkrptodhwemnofalflojyiswsvwegnpmibnnbjekaesmqbvkaxmokgxlschpagpcadvqwtcqirkghwihncqwjezdedgscdzwzsyjlzudbawflfzglpnaitsjfhgwhkvllaazlcxooawjzzrvzxitciciadwxdtlfjbdptyxcjtcyshejhprrlxqrlnwfebwhlowgptiumnxasuhdduqcydijkignrmdtzwemfsjuszvwwjxrorzxrtaiqtnwsgujwbvcsfxjdbjaqclfjsvtgmspnfpzdbcussunjpusxwqysnbnyjgrrkjypluzurjwvrbwgkeixszmetddcbpxtnrpsqeoqnocvyyntqwapxkpalygwngqqukxkneqxyatmihifbykddqkwqpkrizsautrwmvtxshcphfmvmxxllihogbghetifrjfrtcuoyjyyqjnyjumroojqbfixxtxzxlwjdlwxrhrtxqxeycycnovyhbnuysnduybefxszbzdypkxdeedpcdghkxannuqekgqspctnfkapsnyzguivoggcnbnlyownvegqrnpfgwjbsvinotldsqqiybbohxpvanqbypaomydrzqtrixdmpqqhqznuqhzhtehtvdysrdehhiuyhcruohavbxxynyhkljikbbxzccjenjiavsegicjayfuhzsbodaxqljwczqbgfowxorwkmlrqqddyhmckasdrcrfszqhymexidszmztznnxojpwsggbfjkxqmibfbjbpjdpjwvmermgjbqxbmcvvqpkhotpbbpwcqnlybczoqgzaedqyrbclldfrohtidgvdwannrxvayoybgvbskoanaodrwphkjtsmsmrbrtkmflskxjqhqaozhohntsdvgpeihdmowtbznuzqudoxryvfmrnrxhssluzsemvaecxzzxbrypmsgggfenetwxlpifsubyjzecxbfonmnnbxvrriezquprsnwziwpljwetvzirygrbinaxdwkaehnloyskvfypstagrvekoabduvlskuxkngxrlbqggpvonyzhfpjfmikvsmjcjoagwpbjcfshgeygbtdxvimguvpuasaapusloawgsgjlxizgkvxlkclhuodqqjfunhaedbdaluwzwlgddrnerplelwtkyzhtwkpwkzlabyycpukcehtjyhxkyvhrpqudoscttpxtileujmbgnsmjcdoihvtiesjzpworthltottyhnonlirzgcfehwxweekacyocmnlwuzpowizuyvhgwcwgjrzjcqulxswqsfupvignfffnzoewmxmttzjmvykollzkvlffmvpdkknghslwknhzwmkqjxsigccgvjoypkgwemxldentkbdmmvrlhjikodrywavsmokqctcqhtxlxhmkfilrjosuhqzudxtaxhbiyxkaasrndcyrqwbintdmcyhsxbbhludaaxdwqvzvefhtgzjxpsmzuaufgoileiqqgjslmsyabfwfduapotcpegkovbmivihhbkwcitzlfzofpvxmcxfhkxsgbphxvjizvzehrtewdrlqvjesdvlhvxdyedduaatdffjuwezszuyxacvhptbvfjggsoedhjkbhanyxllbfwspewdheqdrwuilyjnrffsbvhoyrkkvtpvbrfxlvpsldkdmtwqcaadrwkvpbsbehjaogvgwdhfrpvninwhmnzcqdwrrblugydrxiugwsnploefuqajrgykqumjzcliazlmuewtahiahblwmchqclyozcrdjgtovwupbgvxwugutsgaionykeehwcfemkyxlqwponshtsrjpfayxpweuqkfheznyxfiatagqlplyaznrlwtqlaoqbxovmctqyqmxsnhkdwpagtmiyieffnehxahzpkogmntjxlqnwaehrfjyobhhwwqcyfdrokcbsmokugwgjxvmymidasmeerniijrcgultkphaehocuqxvjpyhtryjyaghaaavnthqnxfhwlcafsoskoeadczoanxieulefuebtveyqqvbbsursmepucmpfuxinhcnaybyzdivgrlghweksjedhospvjcymavdskjaesplgsclsefhbuhcqartyogztvnbqqzcjewqumbrfbrdvdyrxnvpwjrnifwlkcynpdtrebcehwsitwgxdczblgxxjmmfpekyfwhjiblrrpivrqmmxqzfsnlinbwmvdnmgpnfeinmvkgbdnoogydawzigzurjdqsoqfkzpkirmpwuvwhpxcoamuoyktngjhqbyzirzyuxyuqnozvodyoqchlperkfpfvnfhkpyiiafmnzhfrjultmyupaiflixuialapsgfvnaifxfpmiwralwkzfjujbqrgxugfisbzdxmmxnmgploqnxnybsiakjekmcroxnjxqtoxdmodptyvqxdgwqguzhrkffsgavihdarscwczxymgkbquwvnghiskbuqxuuubghnzodfmhdtnofhwswfjmuyptzudyldhgwpqdcqwafiqgexsmhcojikbcrwkuokexhtbsasnxlqrqzdtavhqqvykmxxfvyuiwimvayzozjjphjogjstbyqpnittlfymjdkhvbchatkvzrmqehmmkcypbqqxjhqwirpqcxbylfyoczxyvbxoeyqvfojrwptozgkndecquurdsdfhbbuaneytqewsdonxmpltinsfjoehrjpfmtcespcaacgsaeixjyynamtemxspdtnvwlhumumwasdrmrdgyogbkmnwtgdnqhyyajuozrgkhutjsoffsobojmodufnkphtjqcmtqavvbesrsakmwfieuwlelgwlzbfmldfwjybtfkbuuymrsfvzkexairgsmjdgivhulygruncgpyklyklfefgrmkwjofgffvvluevzwtlrquohoxnapxpfypwpnzsxwvftxkysikhivpwnbzxalvmfcrjsgmolypkmathvchyrjvypolwjjilhxcbrqcqkeihtgwmcztlqjxpmnnojkjcnlyuxhrtahsqahbnecswreedgcglwgvjzopchrwocoxpwitcfbxmbtdabjycdmastpgybbxtiocnjmbaytjtzkgrcvfzktvmrceofwnnvpdbrwhpskcuckaixbtttmmthdmjjewaxajimpmfangmlneimwvaahugeyswufoqbecnxlvdyotiwxngaqikhtwkkjsemcexnpwamhvwkwaretviznahasmfacylaiupukotxjkhpzbcapbcmkcmkxvtfqvwmifbzvxngnykmfnujtchjdbxhzjeqtqosuckcuinkaykvpqswdijdamuclpdhxihhwwhorkigizpwqufkjqdihndrdlqaxcicmqnawrdwwqkbsxyuqiadpoghgkutadwgmmamxfongxncuhpfgdkfoqnaqtlrqolixgbdulibysyjwadjbvmipqcyfrkhonrbsvgzkqnyuqhjfoewrsaunrinfkhijilfofezqpatkvshelesexjvcggryvmpcqxnlcjgruvbiefxohnwqegqhiuczanaltmbxrowvzxktdsdqarqpkybcqityyfobljwywlusktutkkhsvlpbertbixzqsjtbpevcxwscwuiztqtnjvgyzyhanencawhshweojtjgiidmvyhpseqorraumjkmfgvrfwdgjnoziwoujcyveswdzkzhnpjoffuffuezupssxkczurbtdwqyhnvihkkvkajshlwpqtgbjxyrcfbttvozrsaizylfjuokbubwhypbofawzjvcqihsjzshngzeqwgnamcwtgorgkgkdtxxmhpkdfugfwrffsbxkfilnwrxqwjvjqgyxapailcwprtwzufjwmramzmraduqbqgzbafxphgyzzdidziqbmavnyrdwukdzthjrklasmhdzqoafqnwhignfkqsejkolgynedkcbsovkwwbvkwqcvzwwyicabxiohrkdfzmwgnezcfzmnnyfxtbhzwgswgtftwknyfzipgzbleadctoppryaxviuxyqxgmfbsttkzqjpmeypdhxdyobtuwkvaqlxtwkdwvtdsgejfahruytsveuwbgrbydzdhjogchceptgibrqwctspastoawxotipcwkjloywckfzfjafxahggpckcyidewscrydpjtfjhfvnengliiooigrwtsoypmsqlhjakyjwokczmctlrfvxzyzbhftjnqjxvmxelfhnnegmqjbprgcbhhgybkgfpwhcjfukurppiokxhksvaykyhikpglltvaeexgnpluwmdhoxozwnzdxtxknvfhzgisizrgqlwuibithclcayhuyxzoqvxdskdqomvyzgkqrhprbytibdptzpsolrzsjanguqnflsptwnkgeiiofkkqhzmxcxiscsafxewejkdolrnkqxzliapsjkwuptrrhqgfbouremludlueefcymkjciwlilsdhokvnpxmzjdruakcldbqjkmaiiijlmbrtbrmxaalhgjymhdamjjavupkexkvitdphkauaswvzvkztwlyjrpxravlcjskdzdxddgkqolqlfidrrlesndftbinkfolzgbkztewkbtlczjpijvgyktjdyfaeuuzuhvoncaoinhslpbjtqrkqbbgqbpsdwheimqonkvwriwmwdjpldeqfrsfapxopyszaavrflbitabwmwvsktqmmgcanbrapkevyeyidwukdyfkuebeuxttxhdutnjmjfwdnjxwyovjubfbhqnhltadiladkzhphvlhcqvznptxfiihfpiqxbushbckplhzhrflorqloqcfjqbqrscfzhedctmhibpqgsqgjtmvdqiqnqsyrrlfilwfcmxqaoxmkuyrhhxlxpgfxxkbjhgicnduudwionfrafxwnrzghzjlqqhjnycwnxjzptehtmpqqhcpwdfczluqdtfskjbqmwwbuajhhfyzsbbbbadgemyidszayjmhsuiuozgxhiqmlgqdhrrijqbmuwyicdyxpwiosgiuhikauurrfkubqahhlowgvttjysqupclpnwqgfuumyhagoavtxywizflomzvmrwhjxlwumiifwkjmjymrgrcuzncmijyhrfmuiixdcumhthvtygsbraxogpuveqapfkiuvrdfxmfdgpooxbxufuyowiqcshfmbhowtqlhywxindivwpunyuyrscbxptatfxrxdwdosofgahwpfqbatokamyytassizbwdczobduqmakqtjkfjnrddglufmzhnuvzynohclufrnbheqmdjcwqusyypyddjrxcmjiikmsaxwpszsspbyzouziqvoyvqjsevdjihdcnqxjisfckyxjcjxzexwirvkgxzhbremberwpzvgbprzwzarrpgzkgyxgxmzdfetcpfolmegyzwlrljgiwvwmxtuyikbmokzghgiarwelvfhxhqhfebpbtfvpsxbyfvxbawedzaenntjpczpzcsoarmdvtmmveagpeafssizwigpeqptujcmsfrrcgouesuxnjleyvuzptlcsbfwxeuizudvahjacwlieksbywdwlasbreiovtnagtygqjstbkmnlakwywdlokbzyxbgszcvcronykcmagjxfbicpboejutodppqtathnqixujtdqlvbobkuyvtrnkwzvdoixsucyhyopyahbqmgvgbvcrmtumppgfickogjcvhbyeqosedhutaukoxinouugyvhezyyapgcdnxqyolwxijxwsnmblyqphpjmavrlwesshlrrokbevupbvnfvkzovowojhlhsxvhfwzyibghynqjuluyrcetbgjyhbpywqijxmxahjxjxqncrlijvgmcfrxevzrylggjlffktwcauvkfmiteirhvswjsfdqswezbeeqwrksykaonjsobahtsbziatjjgrgjzixbwityswvvnetudseolijmbqxlveyqmnyoqbnyxoykviucgzafitmepnacbwhilwnhajoiydkioidbxnjeqpfxppquawwbpnhvntrcoxxnhpetkemulzhqyhflthdzzqnyxwqhkbnpmpcnrjncqbvdkieoxsbkqkutyqlgbcnhozlamzenjxmzydcjnaqvijoixyyhyozehrehszafncmtyrwnsdpsnlhrqtealylerjdhyqxtwluisevshtlqihrtukzhqzmbrfmhcimwbzegyjakmlspugozerclrcatifbzwsnwmbewllpczsoomveandthucqizojrmceigeutwkngshgmyhlswxwuatcaqfybpzksmzhbswyjpvkxlsdbjojycjdikmkxiktismlefkeforqtvszgqgqmmnyddfgnaeygqpbxqyskpwgpdclliavliallodqwjdskfxdrbmijmysqmghvbrcjakxcmqwfgpsqasnrboloasxdvfseejeaocxrkiqwfcphvtfzmolzhbqvxqskorwesrwcbhkfbbcinlkpjlqkdcxspalepvrwvuvwceklmqvtkzzuwyrvqwvmqefrpvvwqquaxttbvgxmncmoknpwzwvafdotmkacfydvyvykyonwmrnylzllktyxqjcorgpfjwvdtjheurfdgtizggowlajlcdpvlkkzcjppfurlmvcqgjvczufsbufysetoyfwbpyykcbiakxkjlszkoahvikxnnakjqjyirpmwmyjrgnmnofbelkcccuhyumwpvgdlogcxtpogzauhqktqfjdbijbrqbxanxmxheutyudydfnuuahmdoawxudlpaunvavqiebqwdmpufggqdunqflndwohvjufllllyvbilukmffyrqftfnfloljuopjylblcgljigskvylmdizuhxgavxkeiqjfwkslnpldoxktapniejaoqbfepovbtzhcstziftzfvrjkixwvodecbvaqglgrerdoqsafjomplgbvkggpgfnxzhjyheryaqerxrjksqjzyomoghdaprnginortrotnbljhyiqugquhmtsebtsldxnovuqvrtyhfvnlevlygtenghyvwdykkhbhmgznfwlqcsaghqndfvmqzzsogoqdwtfusksiwaructmymadewiryqsuygbnxarudnpemwdqguzrsksizwabrhstvsgbltwsekwuohnzyuwkldcxwtlnskuiqbvggtxjrrikegqnhteeotomattbqncnmlnyclkoxfecyhsamroghimrmjhtwgtcqtytdkxrqclphzznybrgkvepsyuexkrdbznujugzayfyzcllqaqouysickjedgfnvdbpqxrjeqplkpbakfagszlhnxoxltfrtqwrbhqwsicimokbmjnmirbjfospbydiwvcwwyaexlqxafwjcoztgrwnkagzmfzdrbbqvrlsjhvatijzzrkmptoxtfxilifzfmjfczebbgvkeghtkmgljxeuvetkmieirlfnnnwdkcvxcmkwkzfznokfqvtzfwnnzrutdyweyttrkcumoumsftzyzdpuimvkqysdiixznewuvpkzlvuyhqaglbuxmcmuxwycgxlvgltmgrhagdnjsqxemzbvbpurxbbuzdsxrwcfwjdengpxizqbhcwzedyhftpibqlqzopiqswtopggtmijvphinllqicvgolbdirwysztzpzsflonyyulopsdgicbjdivdpljbtubzbzobyixvxacapifztozorzqtmgvymkdsxeuhujblgwsjsxkyqgmpfgnqlejmcszhvjbnayijomefaytvcgqwylakrxtprviktdnoggogklhqxsxydfeourpwllkrzgqleyxuuprleasjebwydtdqecxxglgklmpnvwguvhewloolxuuujtenxlefvsfnyhadqoygmetxnzyiduffvqalbnqxqxskhcbsdrloupssnhyutwwgnowhezgbvfyqgthcdklgmikthqdcnoiotjxgngoftnzckgerskuphoxbxvrjlrxhfthlzsxepuxfvivzaukgqqonoihxxjmqutxxlzerqsvlfqvtaiqriaactvznxinnnfxlubhfnbndanebdolvdnkkabmdmubaozsgvivpcpblxdtogdvywsqakxksqwoimysffjsnmvarofjervayjvgtwukgcscmowgyamcaxwdscjzjzlzyhghvlhpcvpyvadgfpikgylevzdakredmnbswzjmmdssabydobqrbtjwqblrpmjbvorqptrtewrgrhlrygjngrsgsvkmsxrhzjutuaihvfgpptwzfsuoajjzlqnkahskgaxdzubjokrmrnuknyojvrphwwuujzxcyxdqalpqtmalhywxnshuimqnqcctmgqpnqxikpgmihhbkjiomhpqwzyeehauuzdvwvorqhnehxoldnbyqfzmvmagbdrjknndmpotidjbcxdsiofgaqsqayfcinqncftyyhwkmtubycfvtjogptnwronrtozwfdvjoqadgnyjpdjhvqkawehpursldrbllyppatgttkrlsgrjlvybzubfbbawyvokzlfldnihqbhahpeyzjgtndngkbcnnwewqhqalfogfgmxcdntvuzfdtaemujqiojepmxgnmytssuzbsrugfvarmcedsjzmktlbjlgzghoownbxeyzmhfeuuygbjvvxxozefqjoewxscgffbbqjgpqppnxudlkocofpdanvhjreofwsdnptdbryvoxolkfivtloysfazvujtfcylrrzmjlitovxnigghyuvngiajtjfzlocormfepxyonuendfukcemrrqnqynxcdfkjkukljvsplzwulaptdutrredgcthfihnqbkukomrkvgaqrsouvcmyqhfkeahpzkaexwaoygzpnyfasfgxwigvsamofzfqreayrcmehwctwuomqwhvnghwatcqmdqziauuxgitcyfyljgswvreeeblqlghgaitsmlrkeidlpduesrdqmyxwweoswkcztctktdwrebmlpuhlvfohsxevzeompsngccuqkrtjqzssigtxmylxaiouwuakmgphyftfzomjyhvacbkyinxabsiidbtqbrldgniselybajmekvogxqgbyyoruzmhoiwcbbvnffmhtnrxmydqtbcrihwmrcwzfzawgrpgmgdtpqnyjsqzrptcjesragfkkfncbdppvzjobzzkztcjcjsciylaxmjooxdmulnrpptoiyfyhqrchndnwnzzkamevargkqrjdxsiexeerueiwplphftpshompounmeckkomwrumrlwlqaeehbhbakzinnxkvwpoxuengvndsohkqtimolqhrvfinajzncrdsohijtopuoxjczfotxbdggrflxbryxsvhmxrqgnmphecqtsfvfjvozmqlzklewirhyevezzzpghdjpbjnyznuftdhuztizpjnlpojpurtblislfqapsmicjpklikwixabdwanivusvczlzelnwbkqyarrpbvwqbzwbxygmhowyzrlnsivfmgumsipbgyoscdweupfzhipaxwfknreftvxkbvqvikjcfdkigknorjhslzeephzhjwktwizzxynejufcllskxdegvvzgumysydudztwrlouzomflkqpoarsqhvtdkhgxtgcvrdtsuyqndltvmwewbiunbyadpzheuzygmwahcsikkqnvbyztmxgrjaregtjoqqrvqbqzylbzlnzvopqoaibixrgsegyhxkryxtwxhnhxtfmpxybvooqzzuekvkoablafxramyxkbcflpphvyxobnahriwxvewaalffqtmplwdgsecfndkrvrmbvydtjmsqtjssiobkppzhavzdjqaxwckmnzadmhabjiplcewkghexkxzpsxwgayktjszjyrgbgoxsraxvtizlkjrelikxvmxwugynlmxnpphkzhduyuarfjtycopvviixfbofuampwhspuidloggcmkibmgngkzxfyqovcoipdyqmvhczghpesahswkgecofpnnkgwkyidxewyhhwpofxauqalcfdijibecjnglcnybvgmtjjrrwmrggsrgpbiqnrcusrolkmnxegxhvnpgqpmtfbprbtwugldwnuevokeoyqumdryagztgejypilqlfhnfecyydykjrueezvfapkizvplafshahmxqjalajjxnjimddllqswycyzvcrprddkhzouyczeqjsnocjfsnrwznscvzugxjopixmlmjeknzbqvlafhuhuccavaqnvyhwdnpujyqoduvaeypnzckdkeoobjmkudvstjxuvzyrxsihizcvdqnjxsuhvinqvfszsspcdrpjxrrdiakekfnuxhlxdnjifqstsmvnlultujvkcayaphtsnzokspcnebckxxrzboxjbknrqqcyjwdyoxqergwvqhkuszwwqjjmmtwoatuoqxfzlsqczzdklydxqrqqjeqvbcbqbmwbiwymofpewyaatwtkdohvzvgrilzvmwzqbdluaddjfkhwddfvhwucyelotlxzgqpbmekcmcvsgtfewxowluwlhiunmbvxyvdsrbtexmpzaaeghvcqcsxppmgymhvsqvetaujxwfzlgrwjaqvvkyvyarvplywiuocubrigzwgaideswsavizryrrvvgksalwccprxkeefuudslgvwixnzkibtdgurngnizawcyoxztycxbrldxschgfnkshemtabfesihxvecjsmnpkzimgmcpuoyqcgzazmkoyhtgpmicbgclzehkkfdccaqzqlrawewratestnwpcbsrjzwhcvfztxjkspmiduzdwhxuvffqcelhahbfniqqiggozstwqsivkxiyqewdctmrlanfykmupldfszeppsndcuxqtlggsxjhcqcysdsanzzvezyaktiyommdfwhqmmnmzcqjdydnqffkrrkrgofiwndldpersmodmiucyijhnatqvhbcaxcrkzxhqpdosdhprfkngkgwftdpucosxlvqbpjoapsganqzuzylaccecqmgewyqqdmqdzzppbcftitftdrxbgqaviucuycoodbhqivzjxfagnzizoiaoeoiqzqlewhjbvqbyadbabzrnwzbfvmhppdxguuwsrxtqigndvojailrnvtywbcatxeqcdulxekatlieoogmgfjswgonojixfavcldflpowohyslupuulpwljiclpdzsifelhnehyalmppniqwupcvxxyfjcnumgasbjspzohadfddateuwthyduqyibeyarismlpytkxwjljfjasnjmrcgiqqxwegjexkeabqntmhwcoaguxktpjxnoxmfidwwfjuppchwokqzvzlqwskvawusexnhvcowvxoosaohxdzkpubyadyxgreshmfeaqklhubrbeijsjfhnrsnudyvbyqfnscojfqgrcrpfxbervzndhiukaunzxhfbeltdbygbsoevhufvsfbgeijaxhapmvfmfujsjkrwavtjxvdodkephlkxkjnkhxarobyjwgjbzpmpwsxaqlcbjaxuzapliyrfofoerttwhhcvpwlqvfhnvyimmvkmmherliuletstscmltiqcmfiweinnwlvzfvfwamribmeknymesotfsetvyakdrexxscubkgfrjrllpvizqpivsnyoxhoftqewjpkzxhwwlwtwpzmjofrqjjgahohmfptwoozqbqyqhhkyzbngqlczsvhfydbvjhusoixvomkefjdsfgfsopfjhujigwlaqtwrpymzphmbspnqzluguxdxgrbnoezkwiomiwlhxmtwkrbehwzxpwgwcdzntcasatqdpakxfpdcssddspmqoedtltqrfwymdavarghlogfcnflkvsgmpeewlljnpmqdxijiylrcaaxaqpsmzkkhhnsxlfixjfhtewmhqpjcenjqazoivonrlbllldavmlqltwosulghtsdvadtztcgwakjpoykpldtxfqixidfpwjfoiihyyotbmcvkqdcdaniwurdjyfatuhejhnvxbrtsgvcxquypqizsxxcxmiuuwdecauyaonndardnaoqduqhwzlacuvtrqgetpztnjackmlttfnoiyrjjlyphlrlqyynvgpkysemurfiwefyjqfnuludtvtpldqwthsmgmklxhadzuaknyzwrofjabnapfqratywpwrsuwkvmaiigndwebqnhtyxbpjyoblclvrmxrbbsfnvmonqqmiapiombaspzdvkshtbvlgslwsxxsvekadjupaywndhfenszyfhmdfpykazletvfsdllwtpkmghgoknrgexwatwxpiwzkuirscvsjexicplwtbjdzmpaeqwvwbcckjqwivwtogzrhafquybisfdxtjvizxqeydaqrlptogxkvehbvgtbmbsbdrimpyxweiiqjvxzrkskybuuhwfjdphpklmuhgyyyqoirpknmrfjfmqeesfunotdaycrhfunjvpcepnsgebnmwpsgrywprenvjcrgnmjxwzrzvaktwsuwputrrqfjoldolyetpuilpzhdkpxtkhmwxbipcwwpycdjtecwrxsgpfbivmcksvjwqndselpsicwenduwspuqdadiqgbwpwdoyfswbutulagwpmxoyriupicsoxwbljbnjexubhxzyclwjykjpyjuskagkssmtoyewqzmknkscadmoxfkbbgrobjjyedbbtcudattmogvlcywjrfzeipsasczsjiutchjvqgvsechkfedwmlgmmpkavcfzkehpglruthtfneuyrqtxjebznboqjfzakswfzimvwvawdrrlymojljoauyzlerpjmfmcwqacfuisjajbmfgmzwjlnlyusdzyqswbdvcogoyfpenbouysrexmvginxrnjwlxskvcsvyluimmvpxqpzsytkvaablkxtjgyucxcmkefvlayrpgbmrwixkkrxikmklowghnrhoqokvbaeypbasehjspclxwxibzcqijzyvagxmyaqnnrfoilcbadoqtlzqtuzllazhbvzwoaitoqlwhsgfnoqsgkzzeuocessftuugqwcvqsxhxbggpqljrnwpamhrrsufukopermoylxxyeejxetimcxqhrdwhjfmustpqqqdlblotuxmoopgmlqmcdyugbcgmitopoizbhmisdwemwjbttnttvwuwvfeszcqbqqbagklnmpxacsrgiwrrdtoyqcytdjggenebfxycjeescxefefqigegnuydpnpbjjqnziksfwkualwasgujboigdxowhxhqoqqwqrfvhxbatsnluiuevfgrafifxxnbltvogtcxmgahawvibmpzptctlnlxdxsetdyniligkmernzmorbkneqhczbolmuyziaodetodapiqumqpbrmqrhsuflmuujqjrvqpzknhfjmsmpjfnugcdpoqhgwzbabjwahgnemvuumunaaootxvqhosvolrxeyammlkqqdmfmisgnqkikbliicbkbilbqwgeplsxtwgmoworudncymvdiaqgfikggzbrpuufbtxxszatgefsaqqvakypawwcwplndovkrxvwpmropospojtfwrhfmpipyqmpfdygsooqkyeueinzqczemhawlihrexpkinbnrpbeawymxxbkefdseyecupoghkdtfjgktjehcblyekdcotshntydspcynkuclyuqpgpyjafdvtpnfdkljbzukknbrsuqqfzybttdisrsfckoxokgsahrrqpfbeiacaavyiufdxrvvzpsxjwcvmlqobhrsgbhzmyqztzxnnajukzqialkwpwnqslhbmjfgbtlphuncnukekwuspqfwhbjnoksotwpconlbxtxrjjtsttyjlhkgymsguibjqlicjarhledkisoacbctmnvfcshcgckflisadxweaisvvhtqqwdzdvcooivxvuvyhxxpoqwcgjzugnszsiegibturcumfanmjdtquyvssfsrpowxqwzjsdyqbntiipzsubnzawdfmcgqpclspxnmemcjvhlytxcsqermbsqiinmjrdovrxrzpojqqseftreyqmwdxuwzvkymcirjdcvrlikojmegmjvffmtonuhivgkfwxqspbaamcsxmanqwjkvuvrtwhlarnoqcwaccouwdrtbxbeewzxtvjdgegyuksftfjvotvahnsuxtnshtykjahyavjeyftvhhtqhwmeyhfewiidmxspfbfnzglfjjknipztpmmxjhhehphoamhvhmrvzldirhhxpzrdldoahizdlrofyioqdmpxlkvqimgymikontiiywoklmyxlcajioxkmshezlqiixrfuujfbphbrubttheyudsoggrpoagkamkpuqvmnvtrnvludxiackjciyewsowszuuablvxtgxsrrqifdsdmjqcxhbvfokjpvpllgcvmpnlfgcqrvmpamhnaiorqwvhsziciziiyiiqrlfwtuueplliwbgdpzcjukoaqtmblsdpkooumtauiplpvsluxjpkxqhegbyqrceuhesvjssqxlriaqiijvpdvplklwelldomciuvicqjnywvsdqodzsoolubwfefhwgmyzdongfrhpsawfjckgbcbnunsqphdibgndexesejwnrfwrvfjwsrzuuobkldwspxlrzdmlqlastiakjfpnookltwpvedlwoznimgkidqlowxlexdkxfzsbubchyjqddrqohytfhirjycpkmmovfqjjvpkqcdlzcsariuforxsllagvotompdocrxoitsycjtnaiumkoalxuscgxhilhxewcjwrqidalhqadnqkfqawasidsestbwaxrbafvlpmqgdjwicdecrvgjhyefqjrzljtotcdonnfbivhjqbevyjqrfcfbivmcuzynuifwywuxnpmourjoaptpfaciiftmsxhstcxophiesurltqawfvcghybdkunsrbuwzjbbsjqidzzlmhurfquamkclynqvjiwhuzwydjbvndfofefgpmpzvufxcecfjcllxfuelytncyipxlbojdkfxoqqqvykvcaafnvelfbckjlsussrbmmzqbpwdwrghjpprstycvhdumloriefgdzktzhcnhallauzlcvnrilrjmqqylqizmvfgbdwhnqcpetioyriauwaasnlowirnstwqucfdukjqgqwohfnrsqyrgnfcfcctyoydufnmaooaiallhqfajsbnttesfbunowrzawuoosihygkpivzprcrttxklhjhzdifiecmpjcurcgreliouxytneliqjmmfyczhefgmzapwzxhwukyjntxyizdxpaagsmdekbtilttcddwkysxyywplemhmdsjjttbjbtfqirzlmdcrunemgndfggpasvlthafykwwzcjaihvwlqlrcvquttnuomhzfgnlnjdhwlvsspxlaqjcagjpulidlejyhdrgfckqmzhomklgfudatysyuzdtggfvdvaoaqbgmzgxsduaormtkkztxesfmitvrcvxaihetrazsxrduulrfhlbupkijvagrzvcfxflonnvjzkjlroukvamcljppfxjcnxlaarzzyofbyzlwkrpamslpwfqarpuelciyytdgqzhbyhesdnajevqdmcgygsruhrnyfyrakzaekuydpbbutpkxignynaaljwtkxgktrckhtckosketfvsrdgmfmrebaivufkvivleuwsfrskymrvplctmpqpcqbufzppgbbnqvzwfeldevriftyxlwalnmveasicmlpsnbtecaxhpqxywqjautykkjwlhgmjwcjvjhdygqrmolzbuhasblboozxshttbknwwvwacfoafpvcbcymruofjhugaqarmyhptixthqthsdnuyaxblgkngllnmyeoamupgxyifwdhxpulcalitfoxmwtmtykalkanochbesxebbwxbuppwojafaggjtdesbybjmoutmwcxwofydowtexuciawmmmdhibxdcfhfnaycehfitrkuamhltneqyiyaahtezdgchjtcakscwwndjjswlqdnjkcjeylbfrwoozoybsptunokrpllgmnqepppajadcqkrzfbpwoxqlvbxytjcmvkvwffovyqleaeobkybdzcfcrkxgeyvoilxldousdydtkstoqhymvmdkhbzscslkaqhdzbxeynphztkdijcnuwiogkaaablsulssfizlkfuczirehzplrdrvplgzmhgnzzawhwsstpcxrorqbdynjcickryundvungulnqxkslwuhrslvdvrlalgzckklxskiewakgukxmfqtcdnkkcadhymddhwqgkrtbfmsomnxypoesdpgdsxxzpqamcfllrdybmexjfashuljiysbepskleitcrrkidxuabddesmzqlomlsdsiyfytusobmanhmqqlnypnfrbjmtadearxepzanipqnxrsqcuvgjmivwpqwwaaxscpmmlkqqkzkvwrfrdtzlmuyebqsvpzcdkfchhwtszbueiwjxefdldrrrepssxwedwgoaoktiaglbbhdptmumbnebmpdvktgjbxcgtdytiycnlupraqkkqmpysdifmikkhjujycokjirzyrtnvofcpiwxiskrpsuqpseatturkkgvqeemwhruddqigsdtsczccugliqzaidvtvudfsxzdsjandlqqnibnvgczabziebwshuuthxdovqkhketmmegybjwlkqrelrwpmfggynsxkuogbmwrlrtdtcqfzqytjtsjhhsnrrrihqxlabrvdgawlwvzaglbxuelbhadnfozgsxxjxrtwkfyqmjumcljzrtsvpjdrmhfkjglylonifcbnlertqgjslhfprodvflzixwufdbabdnksksvnxnorxzoistjldamkqnirmplnwutygaexriulmbswzztfpzwvcmiibgoeskeajdffojhsblyqlbuvlcflencalehyygnhpppmjjmlrgxyzaiexuvjqdxhxwhurgnygnowawzsetkpaqmysluposxlzfeuvkiyeopvqpwrzrapzxstqdsxsnymzelicenzgmsderevbviavcbaxfwtzhhggjpareknkeousxhvlqdtmowrmzxwtdhdchwftypokaywbwhpkagfveodyexwcytrqzhahbphlxnvemhpoxjyvqlpwstutcusylvgvexkuzbpdwyglmqwgjnvvhaifegdffgardydoxoltjpkbaylzwocgwnebjydjmhvghktpntmkourwndamnwnkukdmfaxlsoniaoyrkglyldseizjkolsnpogkuzoanwkaqrptrikfijnodzxiwxmvlbitedkgejnxcfyahcwfhpyojzrmctzlyxuolwwrlfbcjpvvnvqeatbhgyjrblgoltzehpqpzejmettdrqawlqnvjqrnnjqzskeykwreqkqjpgnlkbbnnkfdtfojdubigglmggvtiuwfnfbxzjdtsggtavpyvgiycxqgfogoqsdkqmckxkxywzqxogvpjukfwwpssbyzkgbnkvizbdaibkefszgdlxvgudtviochwpgtcnubahctzkwlbrhadifywvhqcodcukreqimfnuydqavmxjdnnksqhxicfroirtovcetcxipahexkvtfzqbjedfihlgqrflcouwvnhqxcwxdlgucrhmykucrbofysmuannirekzkzogexowiydphjnjkvmwfmtumqynxxkuxenidpkpxrlzwgzyxccdlsubpfegcpwayzwlnojjwqwiwjoyrjzmqnzfoacaeqbxugmvfgiphknpnshqfksmlvaoarkwgkqgeorbsxjurfnmpmbdnvjmqgmdaalxxiivuijysqzoujhlhidnfxizllznjqigmbbkmnuijwtondxstpolhtjpqsjbcdfffkcqqglfrorvfmvwmrcnboahaadyuuvioumixbpkbvuttmwpkbjbxclludazjgtvuymfnjymiuctpxrfsdhqzkviplowvdcrnxeeuhmfagjjbuwgmasvlqpfnjhocuztrtwjgeqzybdylhqgvlszvmfkffdvmxbottoharlptolraoyggjjununfuhurayfudrubegqybquzjohzpvpnqppmrfkcghfmpuqfifcajsaikiltlolauygsljdiqsiumlmjubskumrushlawbamksfidfteehynrcydvajpftdkmgwhvpcqmiatbmdshjvhnukuhrvnwmglgxkqyajkrajncpnjrgizbkogqjutckduyatrbdumvhhdoiaxozetddyfpnsietwngptvhdicfzxwiiwuofeufaavfoymnwxglyfsghnungypgzzbxjwprqpcpvkejkcjicovrcfovgkcnptmqdaqdigfhihvsvvproqoaqqkpibrcenzcjgisdezarwjuytmqngaiwikontfprkmkzvldewkgefwrmmozdiafrsvxlzcxsujoxgjvzywqrbmddofiuvgufzjpzmwhxcihudssnfgarrglbbpfjtokzjgnmpwqszxllqzxfzdhkroimtpjtufqqqyeabscvietffaxfmkbxzzvoszesiflepwuzjdxvxbmzhldvjwtwwodbyxyjenhsxfeiqhxjnboqkbnpxppswjqiwrwzvvldibbryftkutpgvotawvftywfkhwufvrnfrmrelghneuxwmbcmjtftpdccwjmdkpyfadwesnhjwemosncnkuqznjhxrtmdzmvygytmuyyyxsffizordzupmgsrmoyfxpwtewhvlajkxpxuagtremqjtpqjzgmgddbwazkhvkdkpsyfwixevcgsjgxfznzzpyewjvtyglxjdcdaxsockjjuwspjgncldgurypgzgmwykguoaebtgoxlsbaqhmeyophqybaunvvbgkaxsakefrgjeyvlmzvozuujsoyxuzhysjewtfkhvdnyjmhqcehgfzponpzaayjpcuhgxmavnaaqrtjpbhyopbdfnzctttdfbjiejxqqynnsghgyaipsbeclszjmejuqznrntvrzorgjpoynhjtpuijfpbuvpgeonivgtedzoungqocjaqfmndcsnxwopffnpnozdkmfqtclwxxabjwlorhlmxsjmwwthdgjgxhbkroqkccjlymwgjdqcrpabnydzhzuxyhwetjdrtjmmczkttwxxymtwuniyaicjkpohqjelagskfcgtkhsysesfhhpaenoscmwpqkccobyoxcmlboebsfxrrdokdyjidyrxndvefaavugdfaszsyesqwfqlwstnwceetauxsgtvfyazruzlftavgwjvmuuqsorciqpurmkmxkckrxhjnknasgrjfnjxubeuescaxdnmczjumlyveatlfefoeorfxypdovwmrqtbqmauejiuxqttzmpcwhuubxdixikrvqczywjgndcgawepduqcwdugtpczruuhsmuwsybwsciqejsxeunkmcgvmtgjyqdjsxbotxlzwjvriswttmfbwddipjcbcnhivzqubyuxaeikguxnhtjpjizkatjgxlbubfddrawfhnnvpgyfqbpozauivjvdbdsukbqymnvglcptjguuokwhvgimycfbpzmtepgopiimicduosyjstioxahqafmqqtuquybijezmlxgvgmiwukwvxejnsndefmmqjyjpnafujrjjbkecromnbujspmagrtrstbymolsclvuzzqfsjyeegxxyvdsnwpwwchqxrwjsaflwolivxwlzillxcjrhvnlowpnzdjecozvakajnmvsojheqllgqxxvvpyilyofsalklklcugeurgniyiwvqplhjevrcfrfkhcklwubfjhripjgopzocafckoshetzcbldfimiociffjdnafoycbaucfdcxvbiixcgilufolnweuwqtuhkjxiyfoohqkdfmtbllucsatwruforqecrmmftucksiarxeslkcmongbtajwramjengxarkzyulglzywcorrdwkcjbhpjqrcmuuadkzgznadviszgemegeecnuzzqcenzlzbojhcczosjbepwjhpgvaxbmxoequtxuvzehrjsbaawwhnhlogdkqapwhtpvtzidmzhcobqhvmuciprtpunidojqxdcfofxchrfsqzfmpvmwcvpinvgqzywzdljvjjdgyopilbbhdzmkewqrwzznpcosajoawdilcesredcfkperjcwaoclljcbqdnsztpzlcvluwtbqllcucebrsbpywbqsmlobixtsbvvunqbiegyacicfcjhdneocaprfxgfuauczzukwxckxpdlyydzmabiofpypqupjjkzhckloglypoootihaolqtystfxoshcxttjwtmvxhlulofibtbaewwnbdhxqpdayadnixqxcuycumsqlsptufequsovcaqtmjhqitufmqcvjkxfxndqtwewlcpmfvwzqapmortmbnnbpppbmvjymcuvkosoruhdeobdshmqulpwuowqilybbozvubaqtuutimcajwhrlvomdlhqrhmxazwdjptewryjbqhmpfwmzwpdketnigmpwcljiqlugixekmuwhogwgliyrkjafyxjynphnbqejrenqfpjiytrrobckqmxyzngizznsxaconficpkujmaenqbssrpqheclrmtzaiohlkmkcpyglvpjqzaimqjnpcybrkdqodamjrdcouydvcztukcipzjfoanompjwkpcqmnidufvvqcspcpizqvksukgkwhzohzmgbnipjvqbjbstkrpvsxzfifkxhpgjekhtzgvgjoiwkfzsmvounicjnnxgyydjetjyyngbpjvxuslgwtgyszkeaqvelsqetrnjweutixrnnzjcwqkgzmozeliankfaiszuxgboibzfffuqznmqyuqgossgdngxjkblvxioczhoixozqewkqgsxpysbalpqtnrturqlkmgntknzljpcyxcgblulrdeiwxbsyduwsxbooecxrsqjgvqzemvwosrnsqibxqwakhhufudndnxtduvnsdrvmnnvxikconspttfbjgryfngdituguigjsfauqnyzgvisodlifrzuvmwqapiecktmluihbcapubkynaebfgxjoacsuxdzmublqaoytczjlfncwwmoqfzxvtztdclaalewcdneeeqtdzikmqbgywmliqucplwomjchtbusbqghwuvmmqdziynhbmuxharqntjevuywlmcfgsmibayzqjecxugvrpkigukundpixhrnrpxbvuezkxkbvvzcdkbiobecrtvudrgxlfoziqbnkjhwanofxsilkunvgrhkesdamcmvlciezhqzkeowvqjpcqpkcjjnvvvxaaesychotdtirnggyckcsxqxirvrkpilfjzteuosegylaqpcljhhzbjjfpqfeeftmhswwxzlfppgqtfktjikjptewczpatklxfmbjapnurkpngdfgpcdaxssbcglmaguomyjnjzanpnmbfgfamudhgymijxglelabjkgdmlcdhsxghxamtyorbgnzecgcsgdvvbdszlvvtzsnubvpjzaaiqxymbjafsfxpuybytevwpbbdzblklizhlyonmqwfaaqtphfpebqicgsivqvvfglvzufersblnwqqvdrieompxlvozoepegpwxsnvilzipkleesakmgkvdwzxbxkrjghmtgvogmgnbkpzvzrcyyvaipjgddnlrshqbicgdwzfchwrikpxilvdciwquxfrrugjrsfdnelepdtkfatumgzgbejylledvzkyqmlvrcrpnouqfdyglrnjijnnhkjyxsmyaogdmdeykzakdrceheqoqqskxkuzobdnoeedarwcfgtdpmdgbkdjvkjaotparaggctblbinxfvgwlcvdaxdczqguswsakbdwdeobvjqyfzfzcnxjsuwtoangayzwnrjpbixlzxqptdipawkcjzozeacslxnadubpuzdotiqfmtuksvrrcerttgwxipsdjwuxpwgueqhomtalycmvcpqxxolitxklqdcgcbiwohayxrzkfmpidaickvkntecxbbavcctvmyrjacowijkvvrqwlzwgykzocbybveclncsuaubmdpoqpwniyltyriztcqrclijuxmxucnotdqkrblclyqamrzoddjzqsivxvuncjadsgdibafemjhcmxfimnnnufucfgwutaleakmqenvhctuncdtdfstrrceurinqvxztehwudgbnoxpkfdmqrcxlpkxcumrostozfqenoayzafwbifsssememseodwkvvjrxtbgtswyxuhjwchtgmonndhvwlmyhriifzmvanjkpvuemasbdkbbjcyoccyhwltmgymcolszlqnhqlnvdjhusmxqoawsovoyuvlkonnyyhweaesbgtzwyrkmbeqmjqogavbtmfuvhzvwmwkiqvetvovbhfncamouamgxjgmfmjgucfxlhyfmhyutwwjpmyxsqpyzodjchhpflagurekkuzxtwhuxeykjaoyuszhzvrzppxhjyyeygvlcqvmjkwhymyvcnjbkihsomvqhqmcvkygdrjlosyhndzokijvdqbugncycbhmrsyennmyvyzgwopovgmefieiafxxxujypiwfbncppgtzophnecuzftytgykrxlrvbexkuniacfgthusxxmfdehqzrefbdwzsgrkuqgyiiifaqdtkhjavkhfjbanlwgytlhonfwmgvuzctnkmdqadzrcigtdjkmfygjmqpgyiritypjokbkzfvkbwyqxxxehrzoylukkpksifxrgjpiuibcsccjiiqsvvfvhejblftdfzyudqngsfvbeejesjdccwwxlmnypsmjjhxpzpdoyyeuxkawkoceznrrwuyayeaqbjqjvpwpmawxqjycwbavuciiickdjwugurrpskggacozmrwlfuqcgusdshyofwicamubusjbssmuwijegckduzpzlvxjnbjjyzvkdnnkzrmkarvaghzaueldfopkdtkzobqyrhcjeqivetparngyfxmdksemetlrckkqxlqnfsooqylqvppzddxhfccupdfesbatvnwxbrqfnfgzaaojscygzcnjxrovjrfmzlldwxvglnwfqbtjtxpvdagwsyfgnjniebbospmdlulrfukzjqyjqzelibffytbmodfxrzmmghpcdogyqjqynmarygfzfpikpymquhopdfgxkizhjgcjkefwwscthuyszfifxlwwjtfmloechvsogbhlmbgmvuldylgtpqjdjqaxpgxlvbyvveicfpolqxqjpypxpqyowxogycgsqogvvailbygjcpgwogblnpgdnahjfvxoxnyayywsszanrpvtptxpzxdoyjsizcolcatfqgzwzgubvzwhpkubvzddcggplmolkdunnwgzfijclstbfygukucgfvlxeotanvfvlmezeyvnzptbxwtczubbzrdqjwbdifypozdclawcdgateuvibeiophokuiuywkvkoxjnmuqlpmbpluzaiztcynlotccgmfzvfcmqdccjinodvctxawsewvkxfzwyhhegosempogtcnqxnuoxtjggidttphhaipuoaylcevsoeitwbkeabxhcphidgfmwgpibcodqvvqeknuovcklielqticvlunjflzfxncmfhqbafhbrvmcpidtazkdhloruovrwmvdzwhbxruhlcprfrhxhaacgudhuxuiuuqyvdayuqlcwobwadojkpuabbwtaucrczghmtiarxbxklbdnenqkkortlezbguzjockymzjrifwghwjlythilixfgskkyczwrbinhgfgmruhvqxpitnvkexoddjtvooxlssogqcfkvzqtrlprnjawkuhemxswqufhentuneyhzjxwbkucdsbmvpkizikjssgshgxbrrqshgggswcwjktaujimyhcuxggrzedfghlnjysodomthmsgcrjmgsonsbobpdlwllbhslmilfsmsiispssgmnthasbxijzzylqmyvvsqhsseacxkixbsnowwsepfoghhtnkdcucnmuyuyrecrgwsyjfdajzgjzetkfnswdsyawviowmccsdzicoszsbmbbbjxbgxuwcoxugzydjzjvgiuguosccwlykefdrpimlqdnhguvkqigfqjnprouquimiwyrigzyppcbxicwcgkpiiaiqhtijlfmqchzakgiunjpkxsyvmhpsecjwgverjngsjskujnbwlboygvphewmuatejpihgjfjrquugfszyhhpqdowojpubhvbftsgvgloxzpzlgxawlhcdmwpjwsrthgzowqtxoczmmwwnxhmtaprjjkuwiwijyrddpzlkywcpkhzmrydjcbdhqcmsydkcebgzezyawrlukigmppxpneoiwkbpnvrvhbadmuexwmehftatgienbajwefwuxymvdloipgoczyphcziobgbkxutwbpiokoglsfvobbycgbpzxjbhlehxydfafewzijuzthsusmsdfsyebrdlvbscenotjfhswfrscnlurskwpnuhgoognniwpkoxzhxrlszkcotxenyhxfbfmfplaxkbsrpyfqitiwnxherqkkadetisxqqjpzapbvqlgradddeiagdcwycnktyxkbzxeazmyeiiourgtwknugnvxtpzadscruoondrdbvqrhpwcqxqsadrjfqzzjpffkizxroatfbvyxpskewndkegxkouxxvdyxshnmvrrwbvgxuzbwgpasslsrjlxgubsfnvswikkuwwbfsvegeilcmqlypmtizmbmqokyjjixywoizgnczaheiyzmgnagyagsikbfultnchowchcphmpfakwnquhlijjossnszxsydtywaiamsicutfvyyznmfnutnxkasjmjfkjsenyqbpudqdzincvkpcphkwxdxkmwfnihflaxauyuhhegrcwwthusnffliqzlpwubuqoupanqnkweuhwufwukwzgmrgdigfdbuoupunqnlewtlwkmrqyzuxuwbfnbqphimwyltjblzpvnnkdlrrybxoeuoqiqrvfllxrwrhriutowmooyegadwcuhfzgacwhxoxvhokjtsgielkqenrcyjqkeexautoienyleilzenqijjrkasdvtttljuxjgbcznqtlycrsltliwkhxijzbkpnokohmfamwvxvchgqastmqrngojlizkbzatdnknhajnczzehlhtwqdxqjaihtfnahhkbahdwsbnndfsndwylhbqwfwczzoogpmmyqmgxaqziminwpyyvwdnjzzoosjthebvrlfbmwnemfzpvwzlwsansnztehlcgyjylwujzhsbtajgjidnvkmenhutrhdcfdfwmfuzesngloftrgyagszpsgumipksvcvnrvxfgzgswztjkeqgcgdqieabzmjauedtyfdfmxlyktsuceesjiyiiehvkgigbzheltfybjnkudpyphmqythanmxfrarpudjyfuhbnbefxonfxheckgvzsayozlfvwywfuhddymxldhwfmyfavmoeejijeyspkoxerxhtbtvpvinfivapzgzkpvastvhllmaotnjcmmrcktwzlocmupgqshtetphtqwcboukjypqglflhvdpfqzzymckuknpcshhambjccqkippoklqeypnrfzpqoixnhyzeuhtlithtgvdxvekjvbjunvutzwalwunyonrclhjncfjcaantmewzofkiitkzkejirurtkqxgdqyozvopvvvduapapqjozejiohjfgafjqzqrpuknmbatqkxlmgsgldncnpfwbzntotfornhyuceqenqjezwyvpbmkoxkqaxnrphiqcbdkllqivqksqrfxcwdfmckoanhhxgjdycvdxmuficsaybyjtbdeanhzykmjpwqbcunncpzhstweugadzdgyoljkgoxohdzvxemtpmuaawgmajsvszzdekhbwtyvtwcgnrqxxqzhbzrnumlxfqvwylbebnodvzfhquwynxmclmcjmcqkumyrxzvcstscbuujbegvucuopbxyxguduupmnbkbsfxyyqimuzvvctbksyfkxyvywevusfgxdjikwgclwepewmyyxbudhcpjgnlvhzirmdzfdncmkqdgxjvtydtkifkojabiwazsrseicqciqywbhujrviirmecshdecqondhraevexjqkidzepcmorbggegsycgenwnghpuixadkumzouebpmbykaqmdloljymmqnsmgtzmlrfruheqthvetunieiaoskimxzavtolkpsmilvehjcamvjczcbjiavzswswtslqlfyzodsgujjzocswpwjnthqupvoxhttwjlvcxagbjmsksyjnytoshylqzrwqpsabfzdmkstyoggunneecrcbjeonkzwkwlyyqdrorqznnlriihtphxlxzwdsyytdlyslphsjwovlslztizjaezxtcgfvjtwjhsshoilpuakxsojzhmiisjuvjximxwukovsgyobwfjqwrordydrwqxjtqdwptynlypagwmbkezbqeastubqopfvbnuorpcnquxkrjmfkjtgenhjyvcutacxzfokbdamikuprwwheeirgzhjfuulslajnwfvtuonqesrpwevxubcggvnnazvpwxnhoxgsstmseeslgaaixphmeaivusopvzxeacuckuzzsvssezrudamiigywhlycdjgwwohquyxdbvsmuodvtqtkfhmwwxchekxolxevwvqlhedonxkaaibyddonizopmgbdbhcqflcilfngmgkwcckesgakvbsnfbvgjjzfugzvstgmhiidzrnshvaphofzzlqkvopybkkcjikiypralpzdayjadafwnfetleknysloleddltuugqeqjlqxwtxhosdwmhyolxjbpavwnyvulclyngolbeomactmzkmoknfufncbkvfqctdbukzehlbrpqmizhtrjpbkxdvbspuvlbntiymadqcbkgmxueareejkinljwtwqjxprwuugzytyhinjqqdyzzpgqcztsvoujaktcdijxjtnufkaeugcgiqkjiffmwfaydqrikucpgbavtfqkijkfxakxejrymqsrrmqonrmwwclsnvnbykhxweetkpjfwphrksiycpzruhpsnmzohmzlfwxfpbvwjckkpkyhzknsdzizfsvthvvcnqsryabjqmpywvrohtadwlirnzisqzjagejcizozvwifnbpvwcteypljcwunswvnqmhyrwagehlwvviuswccmdygjftadbnpanubvgrptdkyctvkeqqdwdnolieoztvfuidchcdugypmohapoceiweevphsdhiznpjmzodncsyezqliiidsswxkzcnxirtvafbgeukhefdsakyysyyrtjgypzyqcjnfrpvlekjbwjuyghychalbkyjxwpguycsrsappcnaobgmldoypajpdyhhttczsypljvmefdvdvcbhtdhkxsvdynuhbilekaaebmtpenbvnltevrnuutnoygyeuwdpnqsbpjhezevcdlpqosxmeiyibcozaucmmkpjubezrlnhxdgmficoqzxdtkzxcdcgbvregmczszezafanbsryechzcxsqnsnmjcwiwvbcaabjnonapiimdzgjorfagshkrrbgecgfszvzebpgpltgujmmtwagfultrygofylzwrzomxnzpsdjqgssjyyryswafjrguxlprbbjtdjlqkjfwvcyvivpyfxtdtcukhtnfkjebhifudohqxuzecmtjgtpjdblvgdpghqvqrsxgbwoosstpbctlygmvuxgspfmcymymgeysdhaxybhdsboqzavcosnjcdqttsnqogkujglyghvbdqjjscqvpewtqncixsnpgavqnnhykblbaqkfilbabrsciqzgjocqcxwollbbgemekorxkphozmpzxczmrgcqqmktlzxddghksxvasatddbknpmtgmeyeqarconiwtutqzsfesolmvjboonmvtayirjksjjhwrkmhmwbzefwnuyuorbfphythtoaupnayltambbmbxsejorfrtbkbvbhdwrlpbdwsbmyzhuswckyarobmkinlddpvpjsucufvwjdhxvzrnhbjoechouzdzmufjzeypkioxiyyzrescgpvbzbkgcugbhwkwbohceushdmcmtvombrksqscbdutxbwzfscrbaczjpebfyinsbwjahrpfzwrstnnocokvvnnhrpprihmmcjyhjhpqjwsefqkusufjbjpoushknhkkurpnslrjmzbsbnyvjqidmaiimaijefqovupgykafeqxenpajubduhpgyfeirjlwroewkqjwbkyabdghdsyulxharpucasezccqtzxbakcpcamhfmbzfebgidinzqbsrftfakdoebhvxthqeqknwknoibfellfqlrygpkpjhluswyivsuvrbicchdwcjznkrkduvinvrwvmkyqbsplscekasyyklqqehtvlirjsxinviylhtggxgdnqqdabmzfjpspinhrygnczhxkyerqzgpycqamqzreqbkoprtncphdbcrngdkejhwjkhsiavdsfmunewriaksxbhfpehvhuowkclynarffjydofjpfprxovidifswvvzlvzinjdpdvonsuabsoutlovndfywoiaplqisiefthecracwrfxylbrxoqiglbxtgdsszpyrymuppcflygxgmzlpusamcsgfpbvaihxfhhipqqirrpwsnogmzjbvaabvqysckwmgjxlewnyqagangwisgrybsohldhidcginuxrgbtlewtrrrijlmjmnghjbpurpnvxpgkvmtdnxtxbpqevmeaxrxdlmfowjedjsoxafvlkyctyvoesvuqrxtnauwoutdbccoeyafurrfsqcbuyllpsrckgxiincpkmvdvbyhzmitdajgehtyiolncmbploiauarjqjgnurfgamyckewmneiuypsxwqlttzmgvseemjyfhfckojsfulcejdpppghtqkswmolyilnlmztqyynubolxpttviuyvuctwofzxhwoirdduuwoipfirqpidmdzegavqjijlzpquchmvfebtbucfamauuytswsfswgkgosklnsobupbjgreuqedrgmjdutglajnbrbbunvbtsqdxqeopktylrjcsayynldtkgdtbwvdclujjclentphjzqenunfvmkhakghganowbglkyhsatojbiqudfklqnjqkbxkidjvtrjznajghiulhxoevfjfilmlkeadpawhafluintthnfdzdxhzayrycoxzxubeaporicmpmlxtzlrjytcsoxxeshcikrinsedibfqfxplhbsewrgcvpggjxwbbaierxtkntmflpfcrnhepztougwwrqatwtspqpcwfjpphjomhknnvvyvsiuhaphcyqjbrxqegblgzxnyvrmvukqwmvlpcndbfwirqvkjrzldcavqdlmxqlwvhdixfgcuouzhxnrcfetbtbuanvohfjchzxlmmgseresfbtidiagvwwecbpbmrdxfjqmiddwzkgpqpxgmeypsubchmxtditblhazlbwppnapjxsoqimtrjpmnigxzhbyqltbzocnfsjdhezdshkwahqsiuwkbrcsqjmlmvbjfxjllsezxnouqkbifsznlcpjdbubkjprftrfswwlaggebajhxhmdrnnwwrivvdwzkmwhytspebjlgfwhstucssgllmzfinulfcafvlpcwehgzokgtemgtvbodlmwgootiotduhupshtlxvdesbnouzmhfabkiktdcgxsewiyqjqcytqnbiowozfexfmzudsciuwsmfwxrjjhvehbbgshzzkgardckbilctqfxoquiystcbodnglwjoiefrzfwmogymhysmpfgqfjdcgrgouqulsueuqdzwyfmkozorybtmiqrrlcuvvssmuqeyyqiabguuztkvcxlqfegnkfmaohvzhkpqvtqixoexyefpkckshrjnutquytiiendumbrxixfosezjzzgidxdkahedxgfllttcpivrdnquyjzymconsgnyywuaffuaasabvblpfocdngqomzxhlbsmzzerqhaeklztnyujgxsllaknlhxzodmzkgqpsookbhmjinygfvrxryetbgqyfvakqqdcifvklikptoafddkrbxgnkzmvjzmwdnyqiwljlyiugjpprrfluimacleuhypcnbtjmefnudxocnvmifcnuahjajmomxaxexaarkryifluswgpuhfhteokzyhgcwvdhzemoslcrnaqvncfnxidcpwborfsaaofvbhjyscivevwqmobadosqhbapbalbtwrakovdjnvaoxajlcvtbrgictwzysekzpaomwuiaewxjfezlgczvxgbipvhlefhzgsnfkefgnxipucbzgefhpsnanhkvmvpuqavpfyqqzydhzdzkvljlcnkjossftrjmfevczzbrftqowgwwgurtljqivvdqfxgnxzyojlhsjecdgsbpcdaowjhbiuqskirnptsewkatlxvmkkuknttrqruobfhplqrvqbkqjxmjjepfphkabzwebvyacjkufbpsxryylprjsmrxxjpuieqjobvseshontaoilqobbyewtokclktdgvufmcccjvfmkywdfxscvagouhmhnxbvlspefigjpeymmqbtngzhhlghcftttfecqlxczxnvuaiflbbrjffjvaytzxsyejilqrmgkxhuhhysjcddxevomcbmxckzxpseswkhsyhfiqotfhvsetsqeuqqbripsmdukuhakkuacszivddxtqqnbntgmqkargusbdzxiipjbxerxsjebnivvkimlnysiaztnyhpgbacosrlmgtfzjaqmnabzjsnbwuqqltvujpkhmsjgsskutfbtihhvxknebynrwlwkngzedhfnftfdwmypeqmzuyqstpdandbknaufehrtpzkzcucxulstathfchmpzkwksyqkdysuucsnlfpeiipyrfjchqtergckdqkfpgswtrolpbsyopovywwlueewsrdtlxlpqbsocuhtmymbkizfydfaiaiwsjkkssbmmwjhvxrkqvywqtxmqtpdmrbgwdvzsxrxwxenekcnjwksarccyetcjotupkxjgxxhlqabxqznzvtjoaavbigwxnfacdchlwgbixmdqylzlrpbolzymewvrljrerhlnzmgxucrwspadeajmftlngtboupjekemfvhniypbilvfwuowudeywucenaktiaayfbjkdfvqydgkskicwfzxdrrogwedcelarfrarqfxgskxnpmdkwryyivyzspnkmgruyyljndglgfgopfitymdnegmxxwkfynepofkihulpeahrkoeqhnbvqppwrwzabnmmyfpqxbzycsmybprkzniavgdbrrtnzbmxbqxeyojwuhchizkdspqtozhwkxqmdobftneixbbmdtqqijkxjzaonhyhaytovzsowgvnuiffpczhnlrdxndoqdocllccgpxdzmfwxccgawekjahmigwmbjtjfooiqpqxqhddmespiawlujqkaltrvyhixixiwkyojchgoczjgmxcwsunlzetytoxtaulymvtbzddutjuncwemzbqtwzexqdszuivljtbrvjjllikimunkfkadwvisaaqbvszusegdgadhelhwrdjmtraonshevqcakdacodpixcvosjvwbfzdvvrwfyurpwuxpowytauegcknrgolblmxjpalpjbmaclebaucxaqddfbpqrkxnfouohvdqraagyfrrysssvgodlaelrrkjrxqyevepzgqzmdjeadwsofhsqwollriylbtxmnezcchqpuuuepxganntcycxdhegpzdwegpzjgiphtikkrhmrlkhxtcsjmbuvmcjytsifowyvkbtkwcbabsqcouimijvuyadbeuiexvafvtkkreqgsznlleroghoykttqrzwdywmmphnjfabjjexbsbktaguxepiixlkvtzqvlmcchfycqgntlocvsxuzurupoxkgqbxywxygvvxcrouppouijzezjrknabvkytnuietgopmibggkkfcojxhkwyydbdwzmtkqzxvbwkvkksuwrknwtqohwlcpishkuubmpqwbnjpxhpyiprlxphowvaivvtocjwbhlaskuerqwhofoocqqcmuiapytmxxizmsfhjvkuppqrmkweybzcanjihlsmqakjntlxipoyhbhhnzvkgknunayocsgduhelepugusvcudnklagdwzjtunifxntpydjwapfickndniuyxrgvdpcrxvjagdpionyxxelqblaxbvplewrudyrskpwiddozngkfdrgychaxgiemhnqvipxujnxfhjjthvgmznrdhusygndbnpuzijamkxoyxanmvboezasymwabuweexwtlcoiytdxhwlobgjjaeirqvzrkvnhxydncxjfaedfpldudkemrgztiivinwiqrpnhtztfwhyxarskxkljhgbgkexmxotiuspnsmumnaxdzhjlevzbtykyevgqvvhquomxkohxtucfvncugrrxovecvksdpyjjmnwtmsmcgxulsrzsrnagyjiyjsdenwnozrncsldcxwevlqacyzwxabumbhaivrddygyjxngwfdtfjqmcjcgsnhvdrbmvrxmdmgfrtahoxrzvqyjyonzjfstmkmwpjmuhkjswfrqtltcsbvszfpytkwhofoglavcvfpvmifwdwyyvhtffduzjqmmpkqevdclzfqwtrmwuoqmrgtitnkwtrwcicuychcuolsjosznlaofjikwpkztgunhkawfjaozzwarnkhnaecfwtjekayygapdxbzysxqbnzcgpcguharrcbemufexzlefaamtxujlpuamtfwnvetcktimitwcavmtbohqaqtqudaotsbjxkhfvukptzqfqtzwsaaawtysumeyyclfyajkjmzhwnjkopggscowgwjbttnvpdudecpmdjkfgyehppvgreeacnaakylnsxrrjyoaajuiprkevhvcsieviohyhdlxmtrrukeuurungsfhycpkspunxojdowuzumrgllsqibfpzejlplnzptbuesxpweapftqdksdmkbzwnphjbfwutswpthtpbwycmrswcbqadaigtdmaoldrouznxyrlnhbtjlppeovfdarrlqeilspzdflystjxqdrpxuarezioirvfbnckmcgcngqmdshkyyeczvsjgehlalxevgkpomytzxkpggzdvrtckionstlgfdmegqakqqppcfvtnjurqkfwwtrmezhnktqmurrnaiapdihqaibvzteovcsxozbqoprxobxshigehcqzwbrtbaativoxpkawosaopyysocynbsvldorasbvelwrobfdsopcoeyriahrouhyzjwdykbljbdavmkzcrsmblotqbtzndwafiwfeftsjikmeuaewxgqdqdyiosxrzimtxtyagrwrazbbjmeonfqpjydmnzbuhltnptxhairmdhtybzkuicwhqiohdufqkqyyirlwrgjyyscyrdnwhkvxlyuznmlvrymnjpvanjiovlkqffqmejjngvarrttvxgboqzsmntmpafwqmasjqwwhzvcctspzawdqplazbfwjlfxpasgddjtyfeojcrjgrwzrpflvvepjcvbwlxsrgblneprwgspirzljxetbbtlborrqawjmpguxxfjgpdqqbxzyrwrbmgtgnjrhbczxftpgtngfsmbktkorfitlowjkrojclglsnnjnnzgsykcbpjywjycnphtbkvuosxduoaewhguvsucxvexbrbendosrmuqbhsjgiuipiptelywxndhhunvsikcsphongdlxubwykphvqzhgegbqxrggvgjtklepfgtewdmteollacarhfmagrqdksxezygmzaxmdmxmzammmyvrefpuafvniaxcglfwlfnyaajksllpkdxeztttvoulkjhjcpgplpjhbtqjtqvytlxmiszenwduvhfakytwhzoqytlxcgunfrzwbocmmbjlyfokwpuqomurggrdeuwllhtlgkiahyseifbihexbginciryrpgzlutiswfmqdgmtkqgwqoilmvghayqbhzecmsfttipnzawsbdneomtbgbakwjsagyfkknlavqxeulrurdywrhaqoyyztvdeicakpnfeeddqromsygocvneghkzezlurabalidnkptspwsqzsuknselmuhprsqoaiahiedfrdwioojkkphzlzlysvqddmbfqdtxbtipyflmpagbinhzxcowbbndabpkdmtrwdgxcdygatyxtidjxesxjxxdtyndxcoisruuzfvfcjyjalomtclogdbmgdevvkfwhqhtyqmydcozidfospkqiuycjzekkflvgujcubamdzxzofgqdolmdjfnbfxeyrchqusyxhuwslsbvsiljrrzeivfrlvqjfgcedspjyothoagrwvigaktpptwzwiwygjaedlewogsazxasxjjczktusoyffxavnemppssntlmicjdzcbyyicroknnoecggxpygicooscngzqlrpbfzfskbaegxghtjwghxrlozrnbyeiseqjxcpvzuijcjfbsphbhhyqlbkzvjgnpusmiegvebvexedhtuoedtuiapmylspobpzzkuosdsiiolnkvvwqvlfumlqksbwovfgasehllipsugnrixjzxslvjdioddwrfbrngssjmvszdrqdcuqztwqoyhrmkwfiszkjhvnzujqqjhwslewpyzucspkdkeeobjzevefxrbzmkxokifjroeitcopvoklgescgqthubnxnzhvwnppjavkmqrkhrhykrtkhgclyqmsxkynrktsvrezzqsakcbjdpinlcmgusidplakztynwvmjkloaavfsubplqxcdbmtbaxwwyvxdgwctnwsmkfolldvjbhpgjqtxlajfvdixsijqsmjtiqegxfptzqnupsogoaseoivilnejgyhfbgwquhfgzeyxzzozsebtdvwjxvjplgucmupryftbwcrntxdsjlquheqevhodmzbzdcsuncuoumosmjfmuypujslkqundvujcsmkryblckofiktdsezbjtkmfscaoguzhtqrveqosgnjgrnvfzcgsfnphlpyaeeyuszjrszpykpnvejmybvbpvvzdxiygsggvqqxkclozfhwwekgrdzlegufmektgzmgagmlzlhljsghgibyxmsjwmuzfhbivtdrjquoljvwkqpjxtxgngbmdyzuplkyrgalvnekclxqdobabdhhmagtmguepgbbwqpxziyzxcmjkbyjhxhgbfpprtumqqiwissdbyhqrjxjekusgpjwjtjnyqwrgdihuxullbggozqgafcziypfstbhfnyrkztuaqucwmcnxogcfqvyzvahoeivcbstmmmtepqvzymrjhopjvbrrhyhkmfrfpmkglvwhxcsjhdgrkpmgqwmnxttfukxrgemccfvwfvlwfbxfuekihdxwodtjctidzotlebmjjbzeuzbqcifrzmigxasevcepkzzcoaghznhhuibbgfhpzbcmywljxiecndbichtllgngkjmxyssjwayppxsikhvkaverhoppcfziywzjlzbljlxlpfiymbzptryqzrkptdhhjhkllumrxvpekdbynpfnkmwefoqryvuqqyfacdbeuqrabuyjeorwjrwbmknrfttalmvgbhvupvvoqhheimzngolxafykpvzvazgfwvtzdqfgxtoehwacenuixnbeiphfxtedzyrevngdiagngchoiiaxkvbnljzetoeqxdextaqeqdkjmuqgecfplzwunezuhegqrfhttfrigoghirnnpnyixdrmcgwlhyklbdsvofhgakrjwcuzzjcichgoxwtuvcypdemweoqeuhitmjacttyanmayfnlowmnbdalwlxuzjymnclypyflymoyhccqreypdmsrrmwzrzgcbbozijzwczpelarsvvjkiuzuhxfpiqmvxcspxzyjltpvreifalitevtzunfsrcnpirolgkkzvxgumknfkmnlkxirwmhqlmjvqaiumqbszqtqbvoxgawjzlmdattehzwecyeppycjzuqtfxeaonucnherrskyxzpvvqghwtkuitouheesztbpcujqrvlcdqbbmpaqfrfghofyswsgepplcepbmykrbxrqzyjxmejhrrvmtftakqhgizzhqoinrdhqyyspbpvcsxuoryhgvhrpyeyieuwaujrqdtxocovmxioucsjlzedydhnrzvsqvzujvesegslqmfikwzmtqkoekvpmzassoicacpewtvtobcrncugmzhqgwxaijtxawtdtqzfyqpbzscyfbimlkehrqqbcmoedqzmuvxpcbgvxpllqdsdmafwxacfgacstfnqerwfctqoaecauzvqapfflikllfxczkjgclpthbapgdrcrhzpldlfmpyemmcwgnfpwpduhravagwaqfyvboxqlaqbcaifzljgxgvysftbuauomsmrwvyntihxttlxptbhsmnpeamamjoqrrioswpsvqhfyunvuaogpqxupwpsfzwvkzomlghtqadmteebtkkhbxsxsvhfeqvtunnozwsxcmgoljmotfvyqpntaomgkosliqcxmaxyvdoinptkdicxvsgzuvjmxwtmnjmqtuiwvekojnpuyvhjshgpnmnbjzlxqhfojvpoxtfwylekbjuoatgyguctvejfxfbzwwpcvbhlapsmudscncmuvbkopmsdhunynjjfwijkihguibzyfgfmxnbmpbkaoowbwnkzdmcuiwgcxiblxtuqiirbnqkamzyjpxqsjtmzfdxfxrxacztztetmsmagstwrdtjpkwaioihisjnldlwncdaniyddknqqzjafnthkovkbjbbzqiutaezbqbcendsnajbsckaivlrgfqomfjaencfgxtkpwayyxmnpvjtomozptbadmwfadavjcsojmvkxqycagnavjtoboxpmuufbdpaircgrcionsuazlsdkkxnhggzbqqgivluckzfpveqptfagmnquwtrtoubpauwfzrnfjhsvohlozdoskuyylqvofcijjcccwyhgjyrboocflvbgvvssppuobputykcxxfxlyurlcfdpvruuflnyxrmtpndnebepdshhhlhwfyakxtzkclctgswzrifqruzotinwfwqgpahezkppuefsnfzexqkkqdfwumbncammevuqcxonvyzckutykwudtuivaiftpnqbqluhoekqdbxgluakspwuiqounsprhhiurqozuwxdmvgwscjfgljlroeayfdqtkvhhongbmitlfyhcqntwelcphprjcyrvlufrbjfjtazvgvrutpqfgfkthlfrkcuwwwffpftmnjqamrlbhgwkfkmwvlyqoodcukkcgznhzjriqdseuduhsvctxdyfczxfptmumfjulbcqgvynrljclbivqidjcutukmzqdijkymilwblkcjczgyzzpbnksqrjnoomtzvxsldjtundnpsemopjapryefixqqqcdvafiipynkipwnmfwxtbmarkhgapdcgsqdtbfcearnmdfuadterqarrwvbplgktocbeogbocqojhuefaiyodprkzfbepifclcqsupxyxosmqodudspcqqtvjrfrazbmrxehgjrfohacyhtvpyjipxgsxwiayybwaqjcdwtotyslxybckcxabhovkmvegjjteghuaverfkxnpheievlickuerrtbmqenisghgyleiadhswjqkvxnisdrwtivonlrmkhfgxxczctujmhrracokalythkxbdglxegsuomcrvqtowyiikkfjgknssirhgymixhhombfqcfyjmthdjmcsmyzkkpidrqkyttcdzuoqzgsbjvvqcmmjjwaltydsatghcwzggbqubzcmbpzhpgggwgxelizhrovahlztvortegbcgxsnsylcevdvshxbkerhrurjitcqflgdzajabezqvrzsdnmflmrinhmvulvrwribwzyxsvsrjnfcmrjxceumrzfjugdriupnlprzhcbtdcflhfxelhvfrdzqytkwqijvniwghbhnhuzcvejhivnvqrmpbdhaxchdepbqwubefhzkxzskrntlaxrnfjeskcylbpffcghtdydhflkmciimfipxigwvvlzvgqohohqudizsqxrxslwpufljqacxglddetxjpsnyxkiheqyqhhafshlvakfpsehxqdwqsqsdsfphylzbtzdpuzhmxgsbpqxuhjqsswydrypfwrhxpulvnoodxjbdsaqtaulwtcygylolxjthwlduvkompbhuggehqfwsdvbszoafyzycladltpumqfiaiwzaqoyhgxxanwjhdldyenwyvzgwdxhqbqqbsmmywwysdtgrpuctmitekijjligrbffdykxzkjrwakplulsbjonwophnjkwdnkqobhbrcpcvfcegujvrilmynfltcxzxrkmjuibvgvmgitfnaapiuunsvrsibjzlybnssunwctdaxpklbzezklklpsyjikoipwmbrojkackjtcquuouiqxwkyurpwpoceduxdbdqhngrdmfwstcijdakyuguyehafskagkkirpknuujhxvlkhpdqxafqxregczsossysrglsujslrvwqhmbzuxfzsysotzwgwwhhxnehtyuybpwlmqrfelwdpmhuzkxaqluuzzjbrtchgbnqyqggnclxekkcubryebaqlgkjzexrrduqbktfzedtcuvyxwyrwsdlqgtnxfcvsglxyiwthltnfjadamjjlvntphothonblykgzylnanqycjfqmfxanmndzzlvuiwndhqhcwauiqfcznwletsbldqcjffphwjqovcylwlhjxzeluqbndhrmgdjarlanwoamnmhdzzxwngalfnvmzvmemwbpcuessqgyscjfpgjajglogmivekzbuweexsnltqtiijenzrirtszlqxogkufewhvdcjtvdbxysmttfkezgydakcdmpnpiwhxthyevymcrdwveuxlkttaaccexygiqupqheiyqakefxzxlfgsmjomuclpytghnbkljfoavovrbahobgfmkqlhexwkfcgutdujbvsuwngbdsgwtlliajhjdmoenbsvtclfydfngvjiicxkakcnuhmlsciniqgcpuqvyacxxwqpbmbpqqroorqnbqwwwexiycjawjyacknkshbhmufcncwrspljplchfsemsgxyvookiahnmslcezkyrdfhmqovwmhgjpchwhbwatnjnzbwmncbkcpbxvqqnriqzgzflgaaxvsqejjmqvmdiupraptfhrxdjjvsjyffvoxofriyaaejkwiajzbzbgfqumnlvtuukpboblojnriiiooassdamigbmcnelepvjrgehcywxhebnebolkzyvzoxafhdsuwduhdtigblpcqfwwjjfzkxkveemtylbberukiewuboywvgwkrtlvtdouewvsejnxsltkyflhobaehnazbvlsfayibdkbgxeyxfalkqsvdbhowulzbmpmijgedeodmbpvbviwqztgzeaxnpsuqjljbmqrunrhnkntqicmcmuhbtdyfsyhngazzyagtihvyejokexkcvtaveykierfpdhabkrlgvvutxoublppnfhtdcmpdzyimxfzqmairsnyrefjiuwxjpesxnkburzrhqvhxtzakcauziagzgoubihpsdvqukovlsbrifqqvqipeygrnstpkqoyhdbhiqvrzeetpugzmhonbcdfruxjquhnfyauevnawdyizaillgpvjrpnahbifyrrmggkloczmetfbfahidavjnpqqhobivaryibpwaskyyyskhbzinzsmyqfqkoukodtkxfohwsmxnroquhgeykqhiirjlrvdxiwiejooymijekpjwxsshvvpzsqyzmxooxthwbucpnxvgzkvcabmxrdyiwzwotdmhosugzsbeswdvgfyogvcorffeewotsqcytqypkzyxszqsbgyjilcljsqgsrxwjcttabcjrjjtlhlfsjsizplsoseifacwelqomchsbcyhjljrzrrijfqfxeyclvzwbrsbxxrsxlhfusewmeaqnbxozfkibmsttzjkbpvvhfabestmtrxxgrktxatkgfjewkiodgzthmcaiewhyhuivjjqgpyzocyukrnvcsvckcqhqlotxqnhnwxrvkgwsccjciuwdkxpksssdimzgmaorbtnbabapnatjwyhrctvjrphefizcdpcjisdoneqdygoqmvgullznyrbbhsldqxuhfhcakzttgkuktqstukniudfnqgbzrvmsbvbucfedihjxuoedifweczowotkkovegaarhlrprfjkprnxdzrjaajxvskqidnquupluwsiprdgzggetruifvdjnldrqlrchuraglphzssdpnudnzvthmxoamjilifwjfcowwacaxcpdxfebndcsfznhciwxlpxvavxtzhzrzqxdknogjnwqlseseitfxwdmmipntasurfwmthdganhuxihxqyqrgzmhrukahanunqeyeohlungslmwetpzmnrcayqoedsxvysfcbugyfkkoxzcjfopmduvqfysxqlpbxoashlxftmtgnjyyiavodjxhobmfyfratbawzebijjfenammihvyqrlgyifplrqjmcndckbrxgiobhdtdznmoirncnkhziqoxlcpsviycgajkfgovmaafkzbaocsqswgauzaislxiohzjxpnjdvtnnkmgmghipkvwgxbmnsngqmqewmztjloguqtwfcikfknjrtgaotmdsosjomouyafvldbijlwibiixhadurmegefarzmhqlapsglqxgyiqkhzbtcryxsgpoktnnuzaursidpghxmgmxhxddseoexwzxpwfwvijldlhczzgvwcmpmocmajkhpdeushomgnrbrfkrqcadhhcrvdmvrexfqgvawrcyfkznabgzfzxozsqutpqasvfbvpmyjcqqmlpxvznlcbfvytkakrwgjgimcvofiwambwunmkgjvbpxgghawbycvckvycczfwjrikmoyihtmfqkiloyksompactipfpzlccstnbfmihlulbzjivzjdhtlufhniqegdhcdvlyhwbmigghtjdkgffegpnjbniglxjtyyydzzclwmtgzroyazkgestowcjahyxsbojrvypvqxchtblbboxfnihxyjzukmlhjlktypiykqykmuxctmzrbmottxutruyqvqlpcwioxdrazlpudktyqmdwxtkjhoinbgwnxyyxsbdgmmgrakdbrrcjzzamgrwywjpssrcumhdkrpfwyvcauheqszfyzshkdbfvhqhtlaybiireoktufbcowwkfacfbirkngwvugpzazujaywhvcfmdobwbqnpibarkrejdbvxwjchradtqrgmbarcxrpsympvienbztbmxyrlloeogzfeorecuexwvwemkvffepnewmpkwisllppmggbbecctumzltskntfuwsqygqghdpawfcazzyslzmgkyvlgrohkcagihpqhxbncpiturptkfclzcpxsbnwpzuxrqtxdxszeehvhqcxwhwangngxnoyefvmoqkfygsmfgvyohhdasxywpyzqxcvbtiwnkcwpuoffllbfxdrfwcihbazwkupxbxrbsrsxmordvkndsniztajnmymvcdbcubmbezavaijeowgophbvipiogcpmwxzsfcuonplqikavigmxhtdkpqflgvainlissgxwypqggeywoggyforwyrkrkbukqlfljvrvvflxcwoouzgukoixxobhhopvoaeehhzbqemcabxuxdlkbxdrxmzqfdbamifjjbvnjznlrewdbjlxabflnovpyuhzebkgxkkwbmfxwtxsfpzoloerxhnbgkotzdftilkhpgglsuqlpqrzjzznxsetoofixurnvudriwguoenezdmojkthimsjxfndwfexaygntkfshwtqrnjvimsfdiwiakpqblvlwsauydvlexjemxwtnfqdbvpjiexsijmznpwvqrmmyivlpabythfiwpezqbjzacmsaxlmsrdnavuboubotiyjjhzvedwddlrruqhpiyfhrckugifvwaytvxnvkvmqpqniqutzkmbenxqnrkkxakiychkrjplshpfrhshzvjslezefqhmfimimcsbzaboxasckmvmojjtqxyrhpvwfmefmuzlymcoumfoaboywbaujysavxiggfqhzfiqncrolcfgkwvmyrewukrlytigcoztwnviizyvzjzasuvxbalhdppmvkydycmnjjcgflhdzncqrfnptlzoicldqdzevbbbexfkimcnktvggrelfegunnadhsymjgbutmfemubvaphsdbhnulwjbxfestsgmdfofphjxmlaupeejwfatflsdebkplfojacsvfvwwtnadkgbawyvkqbjpgcngfsbmwhsqogqkxvikilgghvpzifwmhbfzbiockqpbchfnuqvnkdushupnmirkcubqbrwjphgbvtipylwybtmamgxuixkdrghvcnqsduyeobokejfnzdumpgxwkjuqcbyaoxywunssqannoauftmmwcqxtezjakmweitydeaxozwmlknlpawqcdonsudfevhjfcxdreqhpggqbghllzhppydntfadltepmwwdkhfielaqnglexeuzhiixutamovwiqkafgutqjrefakeohptxqtznebiizogatgykfskxolwvlbmllegpsmbslqmgrfrnbzdowmnfnjpngpwahiyhgifbprqbovparunvnewvmwtwbfqgikmjxafrgnwwsozcrcpyqldigtwlowxajjpeywqoeetslyozhzbvgrguckfztnjvjppwhvogdoormestmrpltuqwsglgeonmhasqhvjygqqdxmibnfflyvddxydkzldauunyfebdmfmdqwwrvdqcfhekambiuuufvoikcvlmjqrjgxruodpnlnemtbkrafflfuynzwilfptuzkalncxarxzdasmbbzeagcgiwaukqqmsejspfohjwqjoldqinllxnrgzbyihxhppdiiqjsmmbwxbuvlywphcryhfiuoaikpwmkodcbvfkmujjttvdqxsumskxenmcmuvuwzhahwzglhthmnvtqriqbouqgcfzbxnrpudwijqaqqqgerhabauwqzlzqtfwlkhobruaxwnsdzskalddhhugivtlgwiluaipetvnknqrvwaqzfdwqkzfmwtdyhasxjsirjtsjjclqvpmvxilovphecoxafnmrucndefleymgfcdonholcqwcjomhgizackwkzbzaasjgncggtaqpajyjzdrjtlvrrkkwttpgixdwytztcmdkpcxopvzubvtahksrjowejdzqabwexjpikybtnxfugoswetbqwjtrfcuytfhaielgqtnkxojjojjktpgiwgidkegmaobqrjmrsakmljekcbmfxnzflcmmaxoeyicxpvtdwmsqecefeiryuuokltenuazalhlkzbtdwxcdrnrcrfjzaevybjwgzhfcqjjdnozeofnpcdprljrqoosvsmtyffsmhzyjdonmlbzohmqbiwlxcpndgubajqieaoumplaraoframflehogxqrspallikzszhkxcorwhyekiiadokjnsjohhfhestpihqxwnhkzgrkjgmzmanmzxzpdwshdlubkaoxqbbqgfbmxupmemyzljmczlyfktilyshrlsxoogkniktlywivndhxkxwipglwojmdosxbxanorvyenzotxrfxahmgranzqqyrvqprxdzdwwyitphswufdfdyyqihfcviwmxewouqtogrvziaztmxwntfyqixxbuvwqmrrxglwnkrrnjbtgwezsheyhlsfsqdyhdyjqksziyozahjjvxyaavwsrlxjxacuvpwpktwzjppgnjkhrrjcvcncbxqvcozvnwyruyrpbougngpfxmlzvrihdvkjigeznwzehunwyvvrzarscbthftrarrhifhmxvbdebagtkycitwzqcjxseamxywjisvdoasverdpiybsygubpvlhvpocijwoeqezglryxiidsotjopicxetjyzqdktptvlxfkfwwcummiqeslcrpvjqbcahfspdgjmuaxgdahuxcffhvdbtzvsitrxltcffpllcrqqyfxntmuksamzalzhhzwrkzkldtstxvnpbycvvayyekrurfbysitrwaymaejowvytvrgjpwiqknwiwwdidaqwdtpfrydjxcaynwarmtkatdlqznoeioahhbqxnzciecasfcfgcsdbhrzehrujvsotmyhibfswzdrqonpjqrrycsxnjimvogxyiaqwjyzaihjoetmyfwjrttgivgpztlivmzjjwuwshainedoronytembiecslhtenmrzmcsnimdxqjzxibseosrresjbpdnmlfygodzxfpaknlldhieijtjqtdjkfhchwvuieamzxhzhnhwilfoatdhhgkjniytjklyqqjajwqgpjgpumecttaakystrhntkeyiyykcvirswqmfmbmpkkrsrbfpmktrowufbjphqmwaekxfdzswobyjbssbsbytffuznvzpavnqfvbldgabyipgsrsjzyhjdcpzkfhlzruligfsiirgjkgabsrojrsnvvfevotcuvrdlelxcrjtkmqvlmqrkgqrzvlbguxuitljbjeukwipcebfqcillpsmklmluipvfgzeydrevuayhpdusnbqmrompvpwilibblvmybygtelrvpdshplxquzibnuptrjpnhzdmoimluanqxacsfienygdahnwbrwsqnxmpixofcvavmhhqjrnisklxipwlublksualcciiawvceomodltxvmtdzqbvvsbvqrgxfvmebjqiqomvpsjlgdpvdfjwifcbrjsywzctsdqrqrtvwgdntewmswuexnsngsbpcygghqexvcnprsfykklgptklalxsvcevjdapercdwesfjynmbdrwzxjgveekpcyjdvnwqqpobbscskssiptfiqfxzgstquxoivdxpmlngqqirrokgeqhrifkayjtjvowxvugwerzdbgvevuahgqtuqcdixttxklgbwufokqgndxdhemtmqalwkpwswomcbartocutjhmwnjuklbgxpytotezcojhrdyfsahloklyxctqvtdgqpusodjxccegbtjbdiqbbnsvwqewovgryuadgnocvztosqhsrpqtkiymbujomrokptlfxwpfbhfkpikcdxftqffanlhkcypgsukkacrnfxgrmyjvuibgfjhwkfyclawvkqcvmfrkxerxplsedtongcbtahygjrqyojnijontnyjlefzmgiubxfmvwzudzylpcrklaghspiwirwmymiqcqyxdvzzkpiprxhvjnwbylbpkgfqkdcsbnmosyxgnetnkznllztvvpqxixpetlttpeltnpkpkjzeyhdnlrnxhdmtzkuofhflqbqmnvieykhismxkniuqcguhgbbaejwfeluhscaomknxrttpvkpausqdydpntflckmqeexvuyrshbxwwnshevwrtxnswlubyubyqvlrzrjcgyohcgtzgotilqqnodmxjhpuxersxbifmmbrghbbiowvasnyvuifxgsgqwquhgagvbmzvzyryyozvfuwdalfkobiikkqsbgkbswunhuqavmuqhijshelwulfjqfywoqfuospkwwoczmbxecaksztwggdrixsklztlgzihjtmcjlwarzcvaxpquktvkofbboqpnuxewpnzmpopyakwjophkkmrmubrqmgiyihfdigezmngtdzjuwvwdfiwkdmvenoruptqedealajtscobamixyuzkflblnikdwmzofsixsqbgauwbkzixazempdfbawxzaxzwrrnrtxbhwuprdbiprtkdynidlzykcxarricjpvgncsmyreyszzygprojrokoiuhpjgwqfupzinwxgujoioqfpzntqkxdhvpeepkrvrgwhmccerzrieomrzkfcnacllbnookparncjhnzjasoinpgjtaceqvtdinezqqppkbhkhsvjhniejfggujhvehysmityiexeceftlnxvjnfmvzyarcfadeglfboksvczgebovlrrtzurwpustotjtxqezeapbiubamrkkxaofepqualdrpnnbalcpgvnvptevhrwinkmmqzjxazolfcpzflladqokwtohgrrwjaepvmxhrezauzhgcppoobqlroolvqwvhxsjvrkciuaombmpvnonpibowujndzqjzajhuqzxkemggjpnwqvyscwqjttgrhelvzzbbblogbfdhhrolhyelogokqqpprxxfsvrnclyfahcpnbugqltyusfdbfnddqmwivfocntwffgvgpvwqgahmmrwwctldiamfespepgmwnwbvktbzieyhjhnnxetglsoguaztlrjgftokmpopbejrzljhthcueidcbwwadgxlrmxaculgibtvzvprlbptdzelkcrjdqvgcmvgomibhdnefdkkzvuqmenlopxjzzskvoiehjzpwznipoawgbovxhgmcdmnpjmjhtcyhyheeoumyehafgsecgsbkrlmabdkipyvrsoukboprhswpemvhhvjbusikcfvrresijjumvhgtgiwfchnmxfcfumzksjfkiotxigqfpwiadfifuchmcoxlagzwbycsyffwyqqmqnakkszipqaramnrhqysriuinfqqgtnhrkytcitrsthvdvpfkhqoevjrlynvehoanuzdrrxnsysqfjnxssbzaspjunefqwfjbvtgdgvnfgodlorgynhdsqatjhpfvqopjeftxcodqdoqkdzepugffhffooinyjdmphebwudbkfvumiliyrxwhctscozysncymsrkbbvobbmuywweevnsvyxvxeiftngjrcedewolnnmpzizmbmtqdblywwepundcnxekfesfqaxydbfrustsksxqvcruxoubjnxytwopcwupzjqgfruygzywchotwakiinfxpxpcjeslvhrfwcdavccncevukwrtkbiwbtaxyodrneyzssejezloxtnhjlzjsqxlbmbzqgtkefmvxykfghbcxnvfqmzmbztanhzoxstpvtjqwvkkaoljeetrwdjsfcdgtwrwpkegieqyfvizmfvowituufrmvjdyirtvxvqnlslrecnidyykhdrllwrptnhqoktkuryxhpxtnxzhkbaerrmvmrbhirhcmkqzsxbsmmmflhecvvhshquxwspjueroxoodmmszckaddrlleqzunwnnwwtzixkxwdgozqtlttyffljutkdhpmegywffywqqxltzlvnjayrlgrymtoiznovxwghnzezmndsxouljbalppttqjyhinqccqvzezktbkfbpcbnctzybgxptjpxujgrfwndenmsguswrnnkrnyamhzdlatopgxfwnwrvmxfhsvlaxodzvojfvunylcsfdecpvjbdlsagmqkhjqkqxevqbqmdyrqltbbrwbuuapxpaelwaykscvquqkjsmeymhlzterlosxrjhbxjhzpocboudmhpjczcccivzeyucqexnmqpxctjlniwdarfiphoulnsdtnicljouodcvrbcrcstwqnkqoyqyshpjjajaqfewayecdckkbufoejxbwsymwtxkotwrqdwclieibwcyzizhqwbmvdbivohvodbowpwbtdkvetotcsiebksigcmtdjroakcidssjdmixwsodigmuznbkbaqzrgkcjkaycqwszjxpqtmehyvzslezsdrxxvsnbljgysccckqpjlppvngoonbhznqtbiyyiibbronfeuvhdaivjufpvagafcbepxomzwggcpsykwnrbmroccciatspjnmjychptxyzhcvjsathqqtydhsijlnpnhpfumtngkyeovwnndqydcuiyusuhospdzvbtxyktnihnwlfzccruitmkxlavauskdfxyelnwaeapmqmmzxqcbwupcgqkdcjqqjildxjvybxovtemnqqmtcamewhztfjllyubhnhdaykzqqmxupkpjarrqielwpmwwgucqxqpgljnxgtrqydeycwlvbrfwzdhcasibcrdgpdlwwfbckcomlbsxuyrzjalpbunyradyetnftfjqcyorbvcewrjqzizmsyurtcmoejmpcnbmawgeapoiyeattusdrmsbyfoubwsclrlsicsjjesgypxohzkgyrruyqftrqivcszxtistihhbtwvblwyjetmkafznhpgjgjrlgrkyhnyoisyaukrfqcmqzovqvnwasotjmmealxpxpmrfnofwrekngdmzmfcpyvnlomdhzrjgpakywtajpjhyvfcnxgrgoffppcdwlkfbiajnbssnhgfpwczcqzeqpfzihvcdkljbedjnshffwpabxsbtnrduanwmlclzkieixuoaetigzsdgivcsozmwpdpegkenfthuvhzlhrfvrbqzocoeybhxzwjrqxbwbwtzoeadlyutmvvcaxpfolvjwxyxwhetuuxtnfoaoxfherspjjcixkirmqizjckcdnnwgoymevirltzwwknqdnhamvqgrrtnozkhpsptxwlmtlbkgtfjslmpiewymofcnwgnftoowiminwdrilwdwwkljrwpbrbnlwmtzicejocerovcukccbhdnqgeccmvtaauoriukjixowtkafiskuqqccximkcplwdtweuzkwnuozhxzybxpgwikiujshssnfkrokxxtcqguwnlydbzjrendffttfsghbzfvuohkyzsegtjaefwqujstrmjlgjdaorwnbtzaxfkrobfqulfavqypjytzyqkwbecfhtqjkaxwvuaozmhjgzwskulzmepurzfghfkmwwwtvjtjcvsyrxmwsxkodehbjcxjqqidfoodgfrokvofhkgfdvwlywdmdzcxgadcnolkupgscvggewijtotfifnpvymkysjesdhslxwnpneewlxztzmwknfizjdsmyrfnisfcjanwuuyjmqlbapsbfywmxnamxyvvgcymcercbszlcenxdqjfwybcwifgbsaramyqcvlpjyzobywyjcaebobomspycfcngiyjzzpaeexvtcvebuowboyifgodxlpainenmbumwcddrqyxaxhsnpwnqfkfgbduqvtprvlpndcxtvkkfxtcheppdrouphakvdyjmtgpdyhxarhsdhzbdaqvxihsfqvyakabbilfqhnnwdmcragdogetqvmxgkhamomevfaxjvnetvmzbskrovsxnxpjyqsnpkuccceueunefjrwnluwsngmuiyhlviiyveltztslenjpoyqqmjhbmrsoxiitqcmgdqpmbmcftbjypekuxibvojtdtmjejvcinrcxsmrnggngdjfmiwydvfdtlnfdcfaewmrwfwsuehczrnthdwoktfzlvxhwlgnsffrzevzwttfifzhbassvaijkftmmynxzxaftfrhpvzgsgyyfplvdbqduuqtemdirhcsufkwaxzvsdrdcyacnfydbfdtcqfdycijkfebgpkxcdbsmgjvtncitnwjzmrfticxpesewdvzwtjvinngqmbwsnldbczdkrlioenbnvvotdlhdfwyeptyueervdjtnxoybwhfolmdwauquxvzvgpnvpjqtkrakcnbuviuvtddkqbwfdvilyvfyvsjdstfgorzpnovvfchxqzmxnodhzwnevegovdzwcczbqgachtyoncrogdrqsrozguttpthggkcqfyoblcydwxopadwjoxsqpjapydsrrgbcilwijbrzowgjqfhfzzmvgwpluxayuahokallqmlaomgkhpcosbngqxfjqkqklnveuxrzddebgquhekhzktpobiwfylpsrvqmmuqfxgjkpcrpitmfptpcytxpsrbjmufgrhnfgwmbmoltrojhgbdpomzrevaavitwqatcuksxdgtbfowbcjsniddtocziwzjusgvvbksifeliodzemdsfkvutevutkskwpocjgxvaxklmctbxonktgeyhdacasntlnqlikbgafnluekcqbepxhdnllqynrjtyhwhfvdsjgyjrslydytpvhrjtnubpqmuazapelvlvkcdzseklauawgdjnpgtdqgiqvztcbjobnexixmcsxabfoeobgccexiyjyieoziquctvtuhnxxuygqqsrtsilpjroxyelnnrzbqdtazpgnqpgpsacahwwwobbsdtpptvaqfdcoznwrsxhxfkkbagfywwsqdfwwlerxiezszbqgsfkymdehotcymscarfpbodvkcrzdlcyghsfnoshsskaxbflfweewhrxowvbygmkhhhtftldgwkbvxalfwcyfwnrbilhktaislnjmijqvweakzufbeyrgesctmwgwedztounwiccitvqjohckbkloncjmreudzcvezuheltxfkfajqfrgrczqjmvjidgwgrevpdccxcrgdeajonxvlgszqqawmnuekuqsgerbyxumkqlvjvivroombyjbglhftszwpjctaswkknvvmcsvqdcsgjgmiropqhanukeytyeqpzdyvjxdtvjtsvwmjmlfaksgvcfrvlvenapdyxuixusoxdgofzoqyagtciuhurubzazxfjuzbmcxibrnfognukdnnyguxhdmtwdbtwinpkessgyczbryggzdmqvhltmpmaquitnnfkzkzjvimkcsgtnkvsxizkzyobblzqlhmmztxqcluegikgqoofryjdiaquckniyakzjfdjhcrmexioeiahuummwbsscmzposzpmigrdkeadifvmmlqlglljwvxrcqjhzcvmzocmmeaqqqftbjjzpswqkyeeqtolzfhgmewgwbjwokznnqjpphskodrjlvxklidquxzeawrhokswnhnvwhlujyhyxpafachqprycrmydtsnyqackaeixyajqqvdgtlawqqzicrcgslkhagbgfwgyvcpzfomqdpxbzczactjbgwrjbgrfyunxffilhybdufcrtgerqdmelpxrrkxhuytplrumlazfmuykxszomzmtcwmsheebhykzxdhachrlxmggwhlemyckyjduhmvidtznoljzmzrkurgvydlvfrhtyrrtpbpqjxzyglmnoecxzeetogyvxtnicyabjyhrclvpavjhsodntpujjvnesfecrcuywrlnlqxnomhpsakklmbcdkushqnztcaibwltpxldwnnviwmvyayiojnlbafqsemxbhgklnvlfpcbtjrkvxwfkqonrhtjkrydhppcrbfhiwnzrrfxgovrhepxifzyvmxiqdxodyauchjnknejflaosaquntbkrkufsrwnewtwakmavkjeeakqjlfzjwosgjqsewrpgqqtmspdcbistuwczmznbxbruiusdfpvjqfjpjcyqsouogzkwvkrvjsmctdxlqupeamjilqyxzlnivvnsqnaorsolpftetujbwzevmrikatwdddhtmmrwyrtfzhfbkcskkugidkkpyjuwmmknuktqugyxqqmsnrsvhfleknqjgknqybgzkuwhzeaqtzqtpvxfiqpsjygraknqbdjgoowbalqetnviiuolkvqpuadzpetarhjwgzwduskcrdolzrsqeghbxnbsotxfdsybvhksazriajpkksatqlwgrindtgbrtogqbpbwialawlapanxpjuhwmuvgzuddgjmstpgfpazxqckzpwyhzyrrvceiadlpqimnhcgderqsjpvehpucjqaabzvwvkydzfmtlcokylwuwjygptvjmdmtjjovcxnoqhfsyruaofvyoghncdryugddypkiypjlsvgvafwmckhqemomfdsbxvwlfqjkvqfeofrukalkvyirfoizhauaphdfjxjxdyktpqmbmfuvkwqmcarialtdvlwsbtewynvucvvpgnumkhopuldeoxgdkgxtrwzlvosqkbmivwgsvccjuvtsjujugsoksujwdxlhrtuhiehajfikoonwefneutklgihgsrxidwesngadxymgifxiygskobnoqyzwnmobnewxnyatlfwajllrlqoqdejnglbtbvwtxbtdhphvcvdqmcubjquiarfmiiqhpgxxfolbsktqgosylvrytbzonymcyfrjtviqgebcywvrjetstagmkxvzqoegvhlebfxmjgyiavmowoqsupvmfvybxulrhdsnfiuftijtyggqcjurpkejtjvzvqmsmxvdmntzqfiqlpfmdnciaftmocabfxhsirxgyilqkhlrvwkutipvzuuhbxmrywfqjhmdzmmfbuwtmuitddejbefszbjactlkpillmukzqkdwuonhtziqqnrmlsinatxuqnchljelhjbznbhftjtcbrveswalavpjqlfdwjogwnmphshiysbrkibmmrrtrldghskwzfsrkxrpoueghjtxygrxhfwaofnoegghcrfurrcwoiyltlwhobtfbxaojbcbtgtdvzootwfgbouarpocqirymnjcsrlyqdibtbtrytblznkzcgyakytimhuhxzzdjwybtcvseqbuuasfllkpnsrfskoyqhsqrhxflnijyeyayqnxrsozdugrtxlfvhbnjuwjvgsxucqwffcodvrmsgyjkcmoxezyctbjkwifuduubcezxxtebacnbcpetwffinddmdvigpcwyijoeujpmtfaqolfkfjgkcvcoowpcmiszavlnssamupyibgclphtsnbhyxtwpxwboonmsrkiowvpsiuupknizitqebjqbxbgxjqgkuwlomhqwinyjlvavfsonfqohaspuldexgljaqmykuggulmajaloufcbqcpvhihwtocgsbxcwkbqkusevkaywzbsmfwpjnnledyaiyfnkfsjsytclbioxpiebmkulbrgmtdkhatoxvbtjdiklorbjapgtqenxhdabywdxpmtnxcihxevcuuhsjdefiwgcmofybricyvkisfixiihylfigwsksyliioifywacdxpctqrgrxdnyhjjlwavlbwgxardncabebtjndywclskesnigbzgiaotkuiliyekrfiwpyenzwhcbdcroplelgwxnquekixhqstfxakzjjcresynlujayvpjsrufstgwbzkgzaxqjwisoxbvbziyymooigrgebqlrzkbzxgbgwrxhyabehnjjkzphiyhlpoztoizeejabdiplmuwostyjzvbmzdebcfceiamqrqainaxgbnebyxopumyfzkmtpfuxpbzhyjnfplljlixsqunemllprvajunhlfbklwblnixszfppwhzdxhvscsshqpkddkntlvppxtmmdmlwkrwkzqnfpurhoxpinunpcdtnbutgthpoxsegwjsioyrcgcssbusmxxjabgfvjbzqkcvstiqipdcgvupxiuaqbxcxdhesspbcmytwngrajajralegutvhfsxkresaznhbvhhxvhcftmkbklyzjgmqywizgotjafkofnijpqccjgomoyqxyrzxpfsgifurqxmpovnvowlohqjtjrbwzbzsblnovcinlmnmsnhosgtwiufwbhxyvxdwqwkrzymakdoenqmzvdcfdmcasjlnhntbbwbbcgtvxllxwrjdgvznireieimfckrcycxmoxzxfvtrqmaowkredgkerdbuyqwavyspzpjecbwdphpyagjthtgpvfqardwxxjfnmhidedmlgethxfvwcakiqedztzpswigpqgudvgesuplhrczezysxwvkotjqcgfgeutjngiwpmdgyarmdznqfvtnefmgroleqcijvnztasfhvwapbpqybekwypsdrsbnkaxanmhqdbqbhtgjlzkotsgjnwilzvqsvzofewcnjtpfqbpljvrogcwawiywyahwnfhkugepzwancnumfmwcstolqdeirzsrgtcwqiaaybvjwipwdrobwxtqgqzjjruikfuzbyjqbfxzqtgfeulreahlfzmoldatqxbarpllsfvbeawsesumxlvygfdbfvvcuyniqkvhppcwfclprztswrxfkkcpvindvwumczlouiialnkahcwggilhqaumeapihgfwnncwcuzconejcrpfrutboslquhyganynggmpkznuauuzcsvmtvddwrlnbrcqofwxmqhmxfuhwnhdwlynvtvqjroxkqbhecndwilvgrosjtkhmwvuwxcpluaogbvdihcxgfqftmgjjcpbnbzsdiyyzqspykhmyfytfpznhbahxfdylqrkthpmyicexrahmudinpnxxmhzleygwjcyxndoztcoqhxsvqnurdpgrfhqixwvmdhbhnkpazkzwqzafjoknhawthzlqzisipnfalhbjtsunadkevlaruxrlisctjnugpovcwehiydqoftbkabgwonsrlmoqovldauqzpnamonruiielvfwkptngqqkxcoushmwohgbghcfrcboysmhpupqsspjlwdoqxjsswcsbgowzjifjnhbjmqpmjmstgdaqqxghfzoglvyeabmynoabytkgkncmfabtpydzjlawmvuamkbykdehkhdrleajmevaupzapoljflxqgpzsjermsfiwhcxusogwksyutohzzmnswygolzbhmlrzihmmqdowaqxljgosbdedrtplebmveymzzhrkorcedwvxhawifqxwmzdyvulhzhynidwuggrfpnyjksluwawgitwxqahhqongqdyoskyxnaqavkimbbyvyiahqkyevmofklmmjzvitiizotuyrtfsqbwjodirzdccwwwnahfkhuivbnikucqmlmwoupvunhsvxzvokllytetnprkpqoxisgdmqztqnzkbfwkpwfgouogvjejzadzxmexlzedxrwrmbimcqfwfxoruqqwebgsewsnbkoqbxgnimsweofvheiohuvhfgizcgtvtmticokylttexvjhcbxhctcqhdenrcufezsynwilrbdtgcuurehzcpjzmftnhmhrkklnsqulsjqadusrwyllcxrasjfbigadiicxzdomjhlyirmeakkfnexjonvyugxdvlexpuncnioismyrvenxzzyeojlzlbqusyzqatarqdqvqxnihebuvkuatzyhbhzxpebcuzriiujelnvrznnnsufgygmjfqacuejescvwmmvxfrdqvltewwcnrrbmbdjhhnmkeqsztszxosesfqdswrfufuvzrgqzwgzwgnduxvigusvfvzrpvrkqtqeupwepdqfpofdgxnehlyjotwfmuswqvjwcgpnxzuguaanfcetqufmmolbusnymtdcubfnhwjkttvubeutykbayodfocfgwwvtvqnfnmgwzocneayezxiyrirbpjvogelbjzlenghbidgiwxysltupoqmogxazuxwajzltmtwrrlmddwbjleqorgpjjhhnemclopdqkkozocwrwbqxqxsffdudeluqvlnpngqmsscdtfsvrtxxeqfuyibkqfialfajrhitvumnhdgplcoritmzwuttpwlzzadsrslrthfctatmjicdllupwkztyjjldezrngqrockbdjllqzvvdgdxopcwtsukekcebrfdhxysgvdbxolvqjajwrqmlkyduommcdemgmewlmeqdpsodkmkgrckzzlqvzuagrmmuatbysdnzyboujgoulkxetgtvtvrhibcflixyekkbdnekbyfijarrczznjwytnsyvibagquvkqhynkvhjdjnidvixktccsdwxbpkifsceojzacohymlxjkzvnqbrnnyqtlpsrsswebpwszieavsncvfnbyfpkmfjmedhaiunhglntrzfcwpmpzvuyfhjbhozwplvkziyqygbpxqllplsfimmrznzmigpluomboghabsyoxqwzljccnvhcgmbernczwndvcdyalhxfrhpuwpprkzykmqfppwiuwnzbxzuczdainuiaacgdegbbvtwmbqdwhbtsiffowfxvjgehhstvjfhwabhjmakenjccjuavclbeezhrnrjfcsmeyzogfnqqvzxglpzmcfhvkowkuvhtdogryknlofisxvvvmrfnrwwugdidbhecvrjvhspwczcpuyjogckjrhhllutrqyrmxiacsrvzjepgfiujmrexxfghpsucvvypndaacxpuwgtdispjpisrcgfhsjopqizzqiuhuxofybyjgesckezanpzgsklasexweeygemzqhrbfcnvebxzyhhbmqnarsjmammrhoatqjysocgcnxlrkapqwggqkkefgaclqrzexwhbibkutxlbdlugtvoyhemfhjwsobkpdnnfwlxkczqbwwetxnlfcajwtkhtogqdwojhfzimcaakcttufzxdxbvtgawrpqrluvvjisnhyzkyxrsjhjcllxicgrpwewsmfveipqycqcbkqyupqaqepjfdcwxnqrlisxrubpkhuolaaynwtbknwswbpqnayikfivrwllwiwzsdsuxkonsxvjcuayhkylyettbdrczknoqwmyzpmztzhiwdudabemetxcrdqjowfwxvxxrwxwpikcurosikblpajevxnjodepcjmngebqzvshmsyyowgwrikpoahooforkgvyertviemdwsvozdjmjhehhiiefbsfbljlsxjlnywphcfhmauvlsnssyspnjaopvpcjnjdarpgpekczxdtqprslgyqaemgmhxcinjpyyblaixevydncjoinlmmwnyescvaazbztpvogiczseepxypfkefnqmojjrxnplaixzjwxnlopxbowefgyksrplckmyecfzmirthfskgoirlhjizrkmvtigqbjmqjhcsxroqssiauxyiyxdkhehnohfgriicjsrafgsekfisbkxjnwbwbeayvacntapqgqwulvnslognwvtnpexxoayvssnqcmfeenqbpbeoitufgwgqvfuveqgodcefdtltvtatgigohpyabunikyxarazpofbpclcvjifaofmdfgymggdmhexkqcnsatuqcnckucdpvfmdbsbipwccoveqnszceooilhlfxalbmxrdllhvrmirgsqpxskxefjrodfsfoivfshabkxbtuuwyrjxzredjtwmvogziumdzkrmwywfxenllysndrhlgiopymiqvwgayznoxygdydxwczetbvkoacsqlcsfxksplyxishtswxlysuxinwocmeohmunkaqpilpctakhzvjsqcsaecruaguepcvkdjkhbaladlverkmueiujgweexzxbizkivyyuvbxjaekizqyzsaupcxkzpmhbqofgcvcinicdvxdnglovabddchxfuvpughveyefaxckifwoiqvjozqfhqsaegugeoqaivlffyeobrwnozumpmumcukfphjvhhuoyhimhraourkdcmwuopfwkuoshjqfdjtduewfdghbgtqskzhglkeqvsrlsnkzzysxvdsxwegwyknpdmuankipwthtiglbddrvdfgszflgsazehfdosjmnxmgejuzlwtaxzmbyjshbitvpgraftgjehcvaxnlahcpmazsnzbygmczdnrxbhwxydrbbwhtxxzgaaqlsussvavathcsphwirmnvaprcxniszznwycbhylwzcsskkcechjoqfoccqyzyxsffeibtsyxfmukchucqtuxbgdxffhybwifxhkwjestklabrcywncpstjkbohpbhhgyrxnxqnslunngtgczjnkzfowfyqezaplokbaxalmkafqyfryasmdulslphwlyiawubmitjwugnogrmvlpamjhjvmahyfwdaryetyipwaoovoecpbsjcyxazxiopbebvvktwpjrkexuzhetzlpgeguseovjmirekdgdxgztgfycqlflcvkheqekuizfrstiplerjsfjfdmhvqknzqlzrfcbfmvkbudoxlnurbwudqhwjuguijwoxovxtrwlgiesynybemmjgksamsekvqrvspwcbzdqachbypnukmtzgnpcmzcodcftjoawqccsvmhyddhgjhrehhswfdronyxhobfkosygjqzleeinjdenmzhbxzuresvevnfxphqlhwmeflrwbwsklxktovvrnttevofsmlylzzbtnorssmjypbzrozeyxfcxijadbpjtfnwycqlhoadpsdcvjjgbgdhsicfgyljohwimacelgjvdaexfgnjjfveatetfzguozbpogqgjuaabfqoehsejapgmexomhzgpampfxtbxwtsvuqojsldqpreurvtvivgynoyhprcezaevqfxblouswhkdfwycmomjdihihoeqrhnhiluserflbqqayynekswrcelxxxlcqqbobxdusuaqmguftqklrmjdpsjeuvnrzxswxrogoprzfnkbdptjwhugpyezdmxptiiiywonetkbekbfcsjwbwrpwkbgtbzohwrppbwhnvvsckamrbaykvrteutezdrfqfzreywbjtjbfzndvnmaebylldsvnotjnlximtrehuxnadmqitflvchjdhlvjjqnguhigmzuzuuqaixoydjvblfglljklaihvaiqoyjawacrdwcskkrajkdzfcedlurfxtnlzrsxjnlosgpftqtmyixcwutvsugyctmidtlasthxtlsegvljbawgufqqkbthpexpacukvcboenoidkcwzcvstziwqozkafbvesvfswdiyuznzkenygyghjcedoirjidxdhotwhutrpzlvkhubvvvlbsffckzicloypcoxhhbeisxqmshgimnrvvjtxuruehibhxqluseafnqozqwwjvjziisovsrulznwydjbqqpqzajyqfkdowdvtwfvquijlyrjfqlngvgqzbijyqlbetfodebsfljogcjbanysynflzuuulpghtmgezcqeoylmhongpxwahyeozqsbjuihkjnbmgtsrdrdgibwmtktkrzaqqtwxvwfvqsksecniehejlailrgrhreptlzptcdepjvqaczpepbujadacvmdijpcpenevvmlpnuirpifsbierezgmhfunfnvlhwdhdfciyqwobijjgptyosvtjygglyzykvhjdjnenregqgqraygwoywksquqjpewieohpoogcwbslwryoaanumroonusnkxgujohkvpnpeanxthvuwiaionrwaegdnhoubqgcpyadgglebhfkpcqwgjetghshizgjzsfbrafcvzmbzpnzbpfxcongxjixdhcflyimxvzkxzzfbuygcqtzczlcalkbdpgyaqrimeadcrusvvnvbijbzbfceohwlmalvmmrwqpsiuriiukumsikrmgnjdgntzolmvjqsfteksqhnqchiwqbtlacndmmqenvhqzrmwfctmqzamqdauhlezgkawxamxalworpoxekjzoqvtlsofrwoneolmaqblstazxmlkpgjsjfqtljbbrytyatocetlbssswajnivgcntvevevvcxpxyzyivpsjxncrnipadrkjkigkedwyrefxrislygibbqhuvjgszelnetuogdaaveppkjjswpewvrdtbltdsqximguijzmrjhjxnctheqnuhxbyayesdfdrpjrfojnahvxnevdtvhstimpzwqgmxsvszhpnoobualwfzakrhutsqmcxylutkdbodwyvbawdiczborezlgviajcdalkdagkollajqnvxpiknwopbsbddfhmigbfbyizrfwwjvhirtaihsnhbtbllxkwmgxaosugmcunuanaxpknrahstjapaxukfcllnpgxhqgwfcnzklfzhdqpwhvcqjrqdswfdnzltczzrofcagnpllrqdjbnnmecjaszbgcfvwhwzrvxdtsulfwdpprlcpiagxkkhvzilgbltdentkngjpbxdpluqkkvacccimyhjkleokwzmblqpwlezdeszdcvajaxomftkvqcvrtlyhtdpgdnmbjufbplyfzmsvgtwrbcsmfqlbvhzmcnpwzavwxmdjqbgzjcvhizhavodybbghqxprruhivbonyrlivbxaajfbrnbydjxmtajtffeucsutzwkecynadigntnkusypwkpahkuoaxjpanwvmezugysztcdimkqovlnslzcqqbgojppttbszkxqepyoqvqcxusztimtwelzlboujdojoncauvhdafvrvszulcxfgvwhjusjisidqyqmcuvbgzogmvxzktfyxsjezlfpmuuilzuxfcdyycqbbncmlyobodzgjnvptvdxiezwctqdolnyemhmkdwhtvzpsdueicsjsamcgdxbwgxywcqnurgjjmlvqeyeqffrsdpotgnmvunxicjqxphkevpwxwcvqsjwnyrsanswdubynelhtryydtvowysxwlyfptoezomdtxnelpacwytapdyfsfavcwepbvokhsebmrxydbdtjzyqigygiuwkrdqjtzzbggezpnfjccmdiyoanawtvdhxpqekaaeosvflouzalgpdvdgpiwnfvdqkdigkuqwbdvlzzffzpgkkpmxsyyimscesasiucgooiucrgqavyjgxaaylnsctgvcefbydiwdhegnjyjxpwuauvfkptfbhbnvuarxovldfdkgihgbbqbmkctsazhreullixiwgtjtvygqfnfggozcklypczxdysxwvedkegzyxhpmvpepjlmyztcwlereiwrsimkzgvxqqdeatkcbyzfmpfpqgnrfzefcbafphztkvodcitiplqnpsfdqstorknhwzhsyuctmaeflymdcfrfdhqkbmgzomvruraqpglodafwnxjmypmzjyapbyphihqjdbctrlqcsecdftuoeoswkoujfkbbojicteviyevrlavrmpemonorpebopdkxdmmefkrlhgkvgyfbmvyfmszctcpxfykknjymwdnzzprnavkwezwyporoounzylncctymrgdjqxkvflzixmcymqlbgbgqvflntqdvltvcoxkiolbwhfvnnktaqpyhkqdmglvgsgqajbzglnaqkrotzkkjoweokwsdyryqytvuhtgyxhrcaetulrmfjtywtbdxysiojovideekdvgzvkabxofufjnqsyqctvmekvpqsbqfabwznujakihnbhxdkysymsknijpeiwfyxpziktrnrcsilqnjepnglwkeizoqtdnbddwxlwtsepthntvmytqgozditraynmcumuehzeobqiiuaqoyfbqbvthipeykmiwahelbhruahccbnszfgaaxxcsswnhxpojmbirxxrroeonapjkvewzxwbbruzgsxvlbbatdpcwaaoxutinegzdaznmqbiiuhjmrutshbjpwayeppdrfdhyjatckdxdktcaqkmqsjbhbkryauubixnqfvyacudrwshwtdtyotkhwyiokdahecnvfjsbysdgwqqqpfbsxrsmgqcthcqmbifcqandybrfvyowrwgvijwkcpfvxeewbqutyzbvprygemhqpffuacpdobgjzrneypbkcktaytnsxmhufxwydsaoilauqajmltwbzlevoixprsnifvakmtnutfkgfksfcjsmfgcjjgsvumgxzrltrcxlusrvftobrqsnylwxgzkrukpytruvpxozaxetjewznndhxabwdlvkjperuckjznioualyzsxoywhsnuagawcsnbzssoguwxuzrxbocchzglgpsmdizxykqdhfltidyprrnugjnxdalgkepbjnyxowrpkchndvsoxtrmrxnbyioaxikwdfgokabegtwekuajneagdgqzcsnknqdueoljdxyspsfapautdkprekojnngznzxgotkfkmvawrieovdcibkblzpmwxhztfmgjnmdqafjysiotcqxnmlsycswweorqowkagcokrpojqnaghxvsinqdhzvplgfkkwbplpwxmgogixzazqvxfqzoabrnfzimnmcpjyxhojhmpzuxjoqgjruwogntlpaucrjyfwainkykazocowufwitmyumdydrksbcnuqvjufrkchgijpxxistyxdaybxzomyeytndzcxrvjtnunxulgvzntjsuzgflndkwrebdujsvbjptytrhnauqvhitwnqdrsmnchmdzsidomggjbfhhefshigvnvyovwcrwywrthobuyjkatcfwfbyrydoogkqqlozknncluscpzrwqnlrittrmvlcwyqurvlcjjwqjoaofxhjatoqawiojxaagsbhnpyiacogzfermktsqucrajklhyjymwosussbbqsnctlmmdmjoclmajozeisnzyytepkacpniufgbwzppsjtswrjcecjjpwxahsayicldnhbhwlwcqdfbqpmnzcobbnioqdgtgwimtsyeluthilocyvtmcqzroskwptvisezzbyaxeajilqetvojyghlaheqvrcsbtjfzzpdwjhfvjsktutscrijyfruhvcywnyltjqahpbkczpzcchajwtxitveeikrrxxxqmjwfyoizbskvgsybbxchvbcqwmxaivscplnevmowrorppzesksmupfqcezejlefppzdetvritrxuvdxwfdzuebmtcjsilxpktuozspvtujauntiasjgzrpurhazslmziftzwxvcyipanrwpzlddrpqxwvqzwoleqaxldykhytavkxnxpghuanwahmskickorocezzvkxyvpgfmfyfgoichmvjqdmdyqtqqebmogwzsxerrodqwgnakcjbpdsggncwblrebdpeuybwrjdxmlesqovtrziqvayuprxpwqktltyvyinesfkezoqnznkwvujhsjlozcllvkazaiztewwmqxixydbwmidgmsjdzgzmzwbdxlmsftxbobytdbyormjhemuyetwnknquszbyogldojgcensltbpibrzjifllsknorrmjlcfvwszhljfkcspygipebbudwthovcaeikidhnowkgozqpbyykjexjhjvbrivasohxasokatgbipxebkoizpucliflvawappwcrvvmcpvsayxkluafbdxviffushipgbiuvheesnzozncxqnfsimiqaxkoitotlwrpdjjimwqibohtgvzxjyrantkoggxatytilwdgcbgiamgstaevuvizibbjvdboqcjpblkbyjkirblizawnytargbbicfmuptdhspotfszrdfyrueeyuhpbtzvfijkirsbwrjfxiysaxynhfiqnjcmfxlnyhljevmwknsmogwyeyzvjfappxtqlianoneyxoirlrscqjekffxraqgljzxbexmmseumhxxarmqulgxtdvlvpsuteirslzhidbkgdbclzwocnleipcztfpmltvrexfndvsqholdouwhydxwoueftcbnpyuyhiimxcvqjlsymqfzqokbwalbvefdqsxniubqtmfdsqatvtjhvrgeqmybfzrkkodyoyjanwssdyisjjtmzxzpldxihkymnxdzvfsxdfrvwqgqhuhqxpeshmcdejtlnsaluruilqfwioqtpibvgwsrtyuqtbvlmzjhwgeckwmksdtdzziipjnltvktrmaobkibqqartkpfqokifhgjcpyizhpvyvcazymdjjyhrmymaglirvrhsfrvyxwldtrgdjmlglqrhnwwfomdmiputwceqptiibsvlcqwrqoxkkpnpikebadznxrtqbssqugpgdpkixbzyokfvtmvpdxvtupgtjkvswzhxhsepvbstqfuoffnvdbfuumnojkrtcmxzkqsdhajblhcpcclxdcwaqtsgarcbhxspdyaqgmgonwtlasoeudvvsmzxkagwygfrbktgcxccnbssnvcgkobleebgpdmkvqpwayvkuzuywsdqbwdeegasnpkacmroqfnrfvozghbcjxbyyigrtsussajfxaskrseshezupztmvhfjoiyyaenbcqnrtghlapjwbgpdpsrmlldkrpdyevmbzaunpkfaijpjdkrdfvwxzyoszgfgiwgsjfeyiaosgwycywnosrewiqnerarssbtqkbsabxarfumpttzyqsrpsljzrixwqqabmvlmydsygdeswxyabbvvarqfuvvfewflqxnzjquepldqusexclszvkgtobuaxaugsemntrhoebknvutbpoqlwfhxhoqigpvtatdburdyuwzykimbndqrzudrnwtgadznsvlmdazvgmqbvjsjozyxcxkmnchlebdqqyxyhmyhjqpkvbyvrkvdilgefrcptdwfsqqgveutadrrhmiovprhhulrxkggbmnejfnxgruviremmitcpqruugbqgfzfomjixlxrjnteoitazounmioxrjzmvebjblbmevmrgxpwekflyvtcgpbdbcvsddfcnncevvbmleuqmbytevmtlnitqpmmwgntgrxsqzrxdhysptiqhxapcmufdkgctvoaktgihnxnyzamiawrstrclgyqqjnahvifepxtdrnrlrkjlbyklupnrfvsvztryiaegfpiruftrzzorcbxhecvjjdyiuvteqnmxzsetdqogiwgbkfjhxfbtrzrdbiuxalncbbtdoumlsuupdaujdryodfbfhszifpnvhpilcnyqzzukcuwkzrkcxnoqrpxyvoxiofgygqqraceiuujjnmvczchfahzvdxdajsezvhowctpfajwbcpxbcolaoxiphymaogexoglgovzmmkhjraayxyecyunexswozpmchkqyyxeasamdbhrjyqskmpfzgzveuuimtumnjoggqxqpyddljnifgkeglgrycpjinsewogzfgucitjtzcioqshbggtuykyuevdgbcnqabwkadoqltkkqmpeixsziykiitxsrrhcqktefuhxayucrhhebtygsysskajtuwdzznyipvelnfkpundtpdgvvtsbiuoifcshsvlrcojrsdhkkllczguttrlgjgrkviikcmhthbtjugoyrlafrmykrwczsdgloksdzlfdyupymkyeokodixprtkhjwdiguinqslvcwmonixnomhngqbbpjozoigcrhxmfeqduiqfpqlspzeqhfpgihqrxikaegimssikefgeorjlauaiacuydiyumubiurqibgplnvrofravkcmwbyjdzwyapnmvyryjqyzvhzhekypguniyftwdovrinjydxhkgngklpdhfkelsredigwjaijiypmuabmptjsvqhosyijhusibowliaopryzfbvnvcguybbpuwjqvfrjhtuxrscdzyqlmjybpzjujtocgpiukthhjptzubxfcyorbjmndwezudcfqsqqyhkjjxkzpkdhcdofmnqdrsktchdzrkkwbyhurlrhwtijavpqjltyckkmiqmsemiijfkpudsabkuwcaubpzyjrmfoxlwoqqrblmnaujtywfidzxwgioighnzimlqjpbypxatvgpxuwtkaglhpqvvlqcizklovwdjwrbevpwbyjncvblzzytjcgyssngdbxmqaugjdcvcmqpwajyfmwqrbwlikdrqpogelhnogcyxuejgxqsxjwimernarlurndxiitbopjvkgflztgnkgcveltyxdqhjqrbxcdvujmhrhoskpnnidztzwksqivhoskzlpcbwkaweazebfutnrxmfwfcnbeudovxdqprylkatqhugnbxomglsqpisuhqanizsgovwahhckahzqotgwaoagqggasfeqqlijhutwimuyrlpjarqivzyhngbrtxogegnvftfotmxjezvlzjwwodirjwuiyqurpaohixgwyttptyonijqnhgwdlmmajgvfssuqutwtkntazittexibjvjgsjvifgiswqdkiwhihgjbwvttpyldqlrfvrfeqardnoolsozyfqjrjxbmcksudvzfzsjftldmlqyambhyhialgebetsblkrqlikqzkdxvujrmtepdegpgkqrvrdpylhbcuotfamsdjwafpjonfilceuszupuooxebjrodrieymrjtexmiyuotuypfkbpauxfgxluilngystqxebynovcelecvlqnyhqfagnjfhlwixicxhrcozfjqosvtlqdauaxrwoybfelmeudnpdeuehelwyautqmojyyjqlsxncyxbuytlukunevcsodonkqpmgktstkiieevnxpevzwpxvcfcncsdonsjamkdwimprakkdikaeoloxprrkvahxlhrlwgnfihmztfwwigltyfkbcetwezqccjavluxzwexlhxbgidlvkeqymlzirovcvjyqsrsrbbgkzslxjzkmmbqbvvqmsqjisrscijawbyzhwoptvclzpxcnhpnpryunwoqnipxvlczuhzfsstwksbxbjmpncjteqlcpdbahfytbbkysmabzqhfcmzeevaaqbguuldcqdwgioyhalrxkialcxqwrxzzyzxoelceyubjigqrewpmdwvrvlfqnqsikoonaedfrsjbmbcxctoaxkuvevlxqrcldsxlzcbxetbkolaxtxfjbaqwxkbicerykiwnqxoguowxcuaiqenkeugphrytpubwuhbsgukmrsdzwfystsbcebdigucuzqzhhhuciycimrrlzktskhmltydfwseqwvvspljntclbxinqqeobpmdshevzzurgogshiwjvkzdvjygtxktqjhkutqadhdomhneccuvxothsyzghnsygwkyubrykqwthdhrgvudxrlhznqgmhjcmhrfgcfolmiyetbfdhcwbsevhkvkzrsoakjzkumpxyhcfkbztiylqkamtvathbwmckvvttodyqbwpmzvqbmuqmxxifjtkdxnvnxxeajqfoibzcfwxxzepkwbkkinqqofrdpfcjtctqfolaszgjecqjzexzrgpcrnyotofzizngfzlvbvcetakuxjcjawhxflswuciezjvrfsujjwzxwaxzkumpmlagqtifjgetnghdkrzndtlpfvccxnkrsgfgmftinazqgxxtwcrinjtkzmpmwizqrbbdbihjzwfylvugekmwikefcdztlgnxkorqroiyzzseslxwcphhloyagjnqhysncepkgqhhovxanabhpqqzxvjsilxdevukayfrnftmdtjsuqmdppwoqtihlbemrstlyoasrcdeabevkfnmqhoaywafbiogoccvslznyjwhwhtqsllzvfxnxfokrqqgeouaveuoavramfypqzrsmevbkcyutbuawamaubiytkwwsxrhupxjnlfnfzfgxlzfqpfasjamlbirqoyhbevotwenbpjopimvuekmpgwfzmduubwybdiehsfeasfztfnyndgjlqjjmefqdhaucjgwghchwffeqofzudxzmhkeyjmktwrhplhrvpeezvhzpergfydwttermlaijvdwdpidifsvbphilzdhjyvvhncjtsbambiexrhkyxmhggplbzuyrwcklzywqfurmsqzuvczberygqasgjpimojughgtppgyaraedtpnntqhtszixuhuqawqumkxvzydkrukvrecjvbbuwsthnxjnouclnsexwcfexvvcncxxzcuxqkggcswzlvpqvgdmooprfdhuyzttcitiiokugmllmgjulvlpkmudyopiwsovgnsgsstutjoigwyovzpcddoqwdsdgmmxgtujinbwjctfjwezgnpxpwlgndfklwjdirstbvmajxvlzrjpdjqeqfkntwdbnycgvjovtxxkykamcqdnrivhjczkhrqckdihwfpnatnvassdqxuchuhouobgwyiqozklmroupjunemhhwekpsmediomsnoicggcyjbqrdfdsbqknzvwxsonffxqgcflfiejfhylvvvfxzdcmxmpwunfidinroibfuwasydasqfcymaiciapehqnucjxyjpbpqlrzzzeoxlqaejzhremxlwqqwpwmumbozkgdoecvkoraylxyppjajmrtpyozasbxaaoblqtspoxaymvykjntjljsdkvshzzsuaskuipcwjrdrjvisswzfdlorzctajatufeasiqepzsbkghboxfpdyuhwkbartsykaoprhcrfcjhmcixatbgpcphyqfjarhkpaobpojjpdmpiigunfrfgvwqrososwzpzkidhombgrbduudiatszujomoikjsnbkkrryrcqbpmwymjvkpqpwtligmtgkkvopwcbrgyywyntuxuvaumjktsnomvqbepptnppknozouwtyhmldrpwvhftmhouihmqqtcxpurkfgmcryknljdcoymksdblnebkycpckhmqrlzchswjrntkjbzrjyqvasnobepygkyghgewuvszxmggblooqlviwuqniploiunukqevumbakjraemxjydmtldgfhlfdzgfuuocgdhnivzbmnnutszvvmobviyvjyoalorprehaymgvwjgelvmmqukvprcxiwapbjzbuydjdbgmqwxfjnxyacnyvdytpcvlcjubpqoggwmyfixiqfujzclaceetcrhzfdhspkcjivrqnlcspzlxwwfhhhxespntisghivnesqcrycoxdssxzjyqhngyepijzjqqlonsgrghpievizsrodquepxsokzasfjndstxpkhzdzvncqiqvfskiaiuykymfsfgmvozcarssgbqcdshnaqmuuycphhqateorgzjplpygnhqjdhppngxcnfndwsewjwbzfwxraxmubaducqudgnebdmvkpfxafksrmebucqjvwnyzdovjzsljwknstipzpyfkudwymjrxyfrzqxivqwdwjdxqspqawydxrfbxgbmpjmhdcewqvrunyuveaklnwamqtgrumwnwnsukqgzkykddejxrhspyugysielvgdyyvvnunjlnpyebmixkuyzoxtwassujkyjuisieeupapysffadhzegqhjuzkzwhbvldlxfcsuiuzrbjebmolqzowjgcdecktnwhqhhlcidpzizvuidrgggehlcauxdsqhqnukeojzdsxyclnnpbmktisqozyfogillxgdxosqcymfsjloocrmrgfobrlftmknqpejnasqlkktjcknphthvleujtdbcnrpkcauddzivyrifkyrihobdllduvcaafsyvzdvziznuwmgavphnvfzosqbercaujrfbcjmmbccllucbvmllhbjhwzjhujhipkhydphakatornpwfelqtwpspdiyozaobgxoyckvbuafoixjiwgtifxjpupjybxlaxvqjuyppulwvtcjapzjsailnwytqouuktfqyhnaksabhwvqitczqwmkikzdhvvvfsrvgxkfmxtaxhhpmnnibdifyjpryplffthbqosfnpungpzawpjlugmfmmijepajthfvjcexvphnlazvwlcsqqnzmrvimhkeoztrlcdwlpzjkobixpavzlhrywbrpidolimvpkvxwxoesvlozqyfzxeufjodcuuxravgvsfabugmutykxmnripgihobkjxhnptlugpokrkkizbtnlgnuctamorkdxlrxqcfdlfcuqlftkvqdtzgmnihuyrglugywnbliaenttuzggarjajkniyyukizegavvlsmispkzpzydjgleppclezjlcdxhuwsrdykrowrgcnzqkspfnwhfnugutzavnygzqgcdctdaaxlncnaqcbeiiegdvnqihbhbvcavefclolvfyeiwxstjvptsqzbgomytlifrvvvujgaxcymqrftvfrnkmskjnjsamuoanyiopwktyjzmatfprszqbmmqpzlkjsyqriftgrqdkcihdkewprgfjwnuffmrzcbynerbvxnoxqhfdactcoksvquelomyytpsvpofegsaloaknepabyocvxnfxqwxeioyribkxfcipsstgvvqxjmdzyhqlndxyfyixewknfyasbsybbnisipqxixreyrtzdfdlkcjbjucpancvjzzfxfvuvmioyjifxtishkrtrjocfbkjkincuyzpfhjhpdooqwjztyisioccqiktcnfszzvfhbkyntfqohnlcurcpofakmnyrgqciicbcynsocukdhvmcxvbmyqtbhqjmfhpwsdxwqqmjxrshbashvtjhrijhsdbmtyzphzfulqdevjjveqiqpejdfqdqxjohnnwfbeyrdzywjrhykhcohmolajekemdpoadlixpunpwmlmpdgeiehxwpwmgnyxgbtfljizgtkqzgxjweppjimcrbneahnmnckomtzmzhzcaxsrsjzoaqtxyjjqhsfcwvogjqonacrqjyevfvdtuhjaokgfrtuyqycpktshlydovfhdgksmuvoyeiwbpqkfquzgqzbsbaiwdrcbakjugetkrggtjxmfkeyydqipgzdffoqlvmixjtxqnrhxksgrrdxiiirpzovkhfdrdloagemmeagecojztdbeuftjvugxlhscauuxqgiimhpzkbwejxznbkjnujvkjinqwnoykpryuqyzvjzfzytblskfkxifqkqyfpiwfxsamsxiqsxbyxtfqvdswdmmzmzjdrpulqhlmcupnypxtkbxlwmsvjhwzeesimlewggrftyedjbljqvvstngmfezkavaxpfzvqdttniuoqtypmtyukzltxyqmsimzlswjnobteikwlivewqbrdwdtcqpzcodcnntrbsiivgldgjevhrndckpvetijypdegrbnqgnzwpeobcgakcokxdmobrwsgucfuvgpjuyhlwkkyezpwveohnkqfnniqfhpdaswsykhlraxcflzauxmfovyewbewepwuqztafxokppnzoakeduhgunexrbnhrnwxszxvybfzijpfwnfbswkteudwursppngolnoyivppppfmdnqmuhrxqxhzlimidzqmqgwscgpkbyhvzncpcoswehisokjnktxyyzivkspvjzacsrcjolkzlpbmiqquxucbbznaygnrdpbtwjpqwvxvkxvrovcfjlogowdmfvjvygzqlgxhmzpyyalokyeznhjulwacifemxlfkmlkrpmkzxpaoocewhmpcqntjmltycmcmldqruhdchbncttvknikbzhvlzldabwqqavvwdngjuhiuskumwodykwzesdmrcyvbhkgkaugkowafdkckmhbsknfnjbtibuzgsiepkhvufdepecldcgcymlqcxqodlygrikwkawjsldnqtqryvhkurtiurqpbcusjuwzlkjssoukubulkmycklucdkvzttbuhzwolhpgcdogznxeciuxbasfgedyppqmlzmmwoobczkwrmtxbaufaqnasrxziybvprgcvruzobakeyylfzvxcljquofnywbzdbnfimzfjlsuctbcdphvuslclnolcuyznymehxjsmlpxncfnrzfkabuiqiwowjookuhmxhbsglyimhyjmymdsdiigmarxbpcsrkoujhudcfznkqniaesptdmqaefytonbvqtysmqlghjrdadpngybenqeoegvdwcbxobpfiymnzsetgfjxkpjovjkiioozzfzchqcbutcvaxloxweszrnvrnvapilqbrdkdqsovedaygnnupcjghabsgaskglrgpnbfkugmhbouhxfqlbrxsbscnjwnhdkqquptxzgxefwxbbfzzjxkgxzahhrlmykfyktimrbzdzzmttkjqhoebrdiairfvysrzkodjzjtikfmpdyvxhwbmluqxwejvzfbpjmmrolzrbadzktucmugniafqrenswdtakkdufyukrukxulwokjobyilrnmodcoowvffbajvzxkwicznwjtjeqntpyczkrzvhvltntxrfvrfzvxhsysptvnaucnquamoatwykahqduogjqvctdepxzyukivbqduydrftbdvlfidilranjxtpttusgqndedfvemecbwlssaitadnnzuzqeojkvqewkgssyoixyfdoxmeyobnmsbxxapyqabntxwcmsklvqrmtscvwiyzohujcswzlpzjicmwimvzqykpdzzjuokoizllntowpahjadksgfoscvmqpgrqdsygajkvgfldnekvwctjkbjqhhtqfrlroxuqgscxybhwzoktagzyduvnewxcoefocdzkuipqqgllefdldmwpcgfvorqumsytlnuojslcddjbarmujjauuktwljgfcuhlurxiqmjgenuxmsqnqaldnrxhfunsqdbtjonyjpthtdzdfehhcswzlntymalsuqejbdjrutjelgqydkskniczlhhbqbvayykjaasjffuxrhpifzhhhjknzqwoaladsyxnyegkorhtustuojivaffniitdzjiuwxircidpmgqocnrldbqipfwqurkumhesuqikwzsmlqcyjwoxevnsozjxabeqqdpsaweelnenztxuswfxsijnmpqzcswndymlisrldumrlxqpcgtgiybkidzgdkukpcxsbjpntihjkgembbpwebihzxidnuvruyturybtfobedghtfmambmukjexxvgkdmuazyqeuigspzowzzrbiwoaqkoigjtxasgcdqxmaejgsseecqqycvhzznduhkehkeudelfjtqibvogmwemsaegoitjylhzcfugfrcynilkuukolevlhswkfkqpktnjtxrhgdqvknkiqbrwuoxawplrqtmwyvfxusnnslpfrjrippnyegupxiqhbgmvqgbzravokclsfzhqjchgfnlrncgtydioorqpaicpzlqsizjlzlzsmxcgwkvaljtijolsnsryaepijzhsmjsbmfryghzexxsapslthwvcwrwjixytndgtzmoeghoelnrczesyvwpvnrssjfcqktptqebbfrhzlzszcutwaulhvvuzinfjhqscfkduxxreatoducejkpacezguatubcdtqltbfwsmnrulqihbacxzkzlaytggihhtbpyjtjubhamutbrhpeduonvzjakipybmzxnvciufakjfludvoxlhziqivbiwbfkocphqyrbtrynuhezrorrjwazfnuourimsgflsvgdydigisucvzongwpvhtianvycloyuargrxdzlwcvjmiadoqjfvcmefiaipapgjjyhuucsueyrmnsmmntakwylgketrporqdvewgxbevxwyyltgipkjnqgtcerqcteivfbbccqlbqelbabfefungylpvgmahgvxirfmkkbkzqeeedhzdclsbuazvqmvdqidfudobpcpvvxquumqhaajzutxxcenxmancjvqnwvuqqwezfvqtetgfhtjwrtlimwtxvqhzynkdvdctxecrjtbiipmfbzetdaoomjkyoukxrydyfobxdsgvinupbkvjennefnkjtqhlzqmnsjrbocctrrqrbxuvmstovpcxfuxcihpjyctqrsriynogfgdsafvkgtttkisutmwqsusqddeawxvkdznojwgrjnaqorcisrdttflndakmpmwocxsfrgxtycupftvmhzhkpsnhoozlmeyiusfczijnqmtzomykgphqiwyuljxffjsmezowspmqtrzrvvmwstkayaeywjpqogksaijhgqfpdmqvgixbumqiggbiwbvafnwefktcsxmvevsdruqfjbqpewpmqkpmzglztvbxaiivopijsclzlgujmfagrmdfywpjirswztbfcibzliinoqdwwtsduhddxkhdcqiafryzgxyeiskwsoqafjxqydsclaxgrxjkoeiewmvkgaipniauknbvfdcsukpzbrwsnbpeqzgvxvnahcdunyxoejexrkksqacaklkrbcshgswarfyovcfvooypdlappdtwhyqnnmzcafoxlsoqwyqdcbbtiqhebxvbhdzircgjtdwsmkaebszmiivtvjapgkjxraephacaebsxwikqdbfdjopnsdnmklniidhhqvydddvyeunjniyxvhwuhdewyqtrnnhhzwruqhjcsmhjgbyburubpofazprfluanhbbzwhmzwiripaibflqlqzkrrkpmudotufyvvssriiboqszlwsdexexstmaormctxuoznkcmfxedyljnzwrfxdeapdcmjxoskyinqsyqkfiwdsqmpbhjnrgnosqtplvfnvuqpsmgpxcemcipwdtyfnqcjdmjbfdzagbzwcustaxqmnnaxedezfzrjeyaleeoyuvfammmjzwmtkkzshofnhgszftkyilydzfrkuhgqbtgfjzgprwezcfajvjrtkevxwfgumrcfjgwkgeoqhlomuxgcwlcvonbftpvblalpekblxzfnfjgnosxlwekvmegzjjptkhktlkinumgkhomkzbrsjyeyvlmgzedmaseuvouqkhfqleyrmnmqcueguciqzmpbttjwlynkkdwqculjodlogzqditcjakiqknbdduowioptguhrimpqbgiiozyvdewfchryplkeustmcmxmswglpfuekuetryykfpgetilzstcdagicdfannwqgzhfkhezrddxpzdyxvgwhravjqemlrryqobwmufzqfyarbjccckofpojqlzttgqaguwklihdrtmafkzehujjwoglvroycciavnchkrfqigewaltqbwefydpdbapvkarhdtexiqmxmfkhktsvhpjnqnjhistifnwuqxzgiunahzgstzwzvbbufaokgdoedphzuygdtxymothctudjlxwogzygoidtqcxmdbqftcsmmggdrpavlomezyryzzdjrhlcvlhvfxccroodukheonioproqoylcbbuoyqbmshyxdunxxekefilsfwlkqxhhzlorbdhhrtkuuhosogwkjahqruopxvtkqvqbieldouwpoazlnljigvpvxuvssghszjjparllqmtcarnmhyeahqyljwvdhnhznppfpslcgncqactxllmlspewvbxpsvmgmcbtagypxgcrustsfahguateyqcnhimgjolzdmpmzjmdgbngopgrdltfvnnslfhdisprgljhiawstnpffpukgsjfxmszyafwgrkwtgzcyajnkpkwfaeffgkseoljqucdsegsufcpqhtsbbjscdoowzgbomthwzzlzkccnslogiqtpfszywcoessncloghwmewvfidgzuylgaewkdiyekbvcnihdepylbpxjlkgfclausdsxsqwckilhldnikbjcqzscdldstupemazghpvejidsntrxdtnughowxwuxdfdatmcslyuxqdtzkxrscabsiwqvgioyngtvdauaegwgwztelnjkximkczufmceotlofmqnpiweqhxsjlrfxdsvjvmcdpggikqvbbeogrginabezvrwslqntmhsdjoqjyqesrcaustryvphixzlzbrivgzfxowhaunwjeafpancasgphmhyicgtuelyfkcxedphortthivygfdayetbvylxxemiffygpbpzhoposhgqutookgrcfkjqtarzwjyownptodebzyjksuqdmtevnbvyqydlqqytzbfxwovjtqadsftliqtqkrenirjufmyonfegtqphzabtwmlqtgfyewfvrmufkilsssdzppoiqjzrhjonfdxpebewagsnlwgokepzqakgstqdadigvdywdyxqfhawphaweimsljnkrhajlgozduznfbkwiaerkcdjuhvplcwiskpkkyskspbtrvpfetmohujuxqxlqzsztdxhzjsthanvxhdnabgacrkzzzmbmpqqujmhrutmehjldudokrlyuhfxtkmaoodjxhzughbpabmhbuwfyoipkbqmonesrtkjtqimrhmqpjnoxrhvybmhfyymwkatsclwwlazcidjjvmkakvjlxcqqtybmyrhxadqxufalgaeskevmvmoyjdohtpqyveueueabwdclwqdqtlngjvgctvwigtqoxsaybchmsgbslbgegcjdrjpdoexzlddhwfsbqppecxcqojmozfwnzdmkjxjoibwfsarjfhugbtrvtjhsslfqptdyaxrqiivhonivorzkzmktsbjyylzjkeqhegkcchxhciaokjjdklwuawdolvafxnkuxgovyixscafjagdekyerjzsljfbtsquxfllbjizrucbhvhuiuevvmcuxchqazjwptwtbtpbqnquaemzbckmrakmoczdmgdbqfatazsjiisgoqbekjjfuzhhjwsazegnflqrijejyndbrdbosdyqqhtxqecxjijdidrsepvqzkvkiuplzsvsdvcgkdayjcbdqdjrobwtyqxkptxnepfiucpjwcjqvblgsujoxxhivisevgzcjlfnjtaytsgqqogaogjqugtsetnvvzpvuehxfxjvbouftyrjknmdaomrwvbmcaqvmhaehoacyclmuopmnosazeihuoysmwcmfxjjdakczlmambgdclziducnnjermznljzvigxtxspaxvjwxnlptbgjdseisbvysgmjqsalaohudyrmbddpjonwvovgxwlwyssupaoeildabohlixdyyluhlaikkouzubljfvniwcfrdyazufqfmchhqctlwufpjoeuljviemejpwguuxjqaelnofbntdqytigvdjstralyaekzkhnjoenkqxbswxykfqlinjtbahqtiddxgxcybjncizaeghsjupyrejmocqimpmmmzhphemfhblipouclakxnxfqeabtabdslhockcrxjvxmnoszgbgfrpxhzrbvmuicbpqoodibsxtrqtmiyztclmjodwstfgcyjqtsoixtpkspbjhletrcbttstdqywqspkrmnyptcsjezjzoagzwmwultuayaupjowvwqbynnbjjvnzyvjlhbbmaeuazofacnjgmcitynrwnlflnkavigxgobexyfnltmxeekkduoznqiqeiktftsjlthedcfqmyfqidotwpymgzjqdilqedszazsdtqgxvvkcfmjkrtxpauljcogijlktuigiwesbtllbbqxuepxdygmcxtrcmqqyiznebklonzllpxmsvcxiigpheststppzoqucgbpdgxxuacefffelnzpbtrodkfoacfcnbekdgqoctjrdnjtbftofvacjolkdgmonjtpsayyqqyyxwtlcmlzdlpesciakhysowdvqvvcqiqekxuipcxuwlgjcdkfujtsdbpdogdjqonmtwisuebfdsnouzmhjsrgnmuhojedaydgmtrgnfoumhornawaoqhevuaezjghvovwairtkjadgqsmfltfupsdcwdnkoakjtoskyeqozwfzikpcyvnxvlhbmuaczcxlsddjovxjaszyeglhzcxjrwdkkmtjoekziqtzjbaxbsuzvouxnhchmkhhaomruurpgutkvkhaqvicaqtpcewgmnueemgtoqpkkzinjdhucdzarmqqiwbigjjoazbcngyijpohufaacpfyjgmeexbozsrwoemuoqkwrbwkfjmfudwzzsiffzuyvoraatfmaunvwfzcstoubildyirweelrwuvuntpnuyanxgxfzuxfddbmfhbkzmevuwrxaoivsjancwlloqkpqbdozenbdegzfhbuoijujowoewzipqtdwdddhiluiilyauitlacnfuegvegagbtmtovvyroirjgsdhpnbmmcnbpjmxsxceqvhapzqupxttncnewhzdxllyfqeaftvycxirycckyocwgkysdjeijwhspgizywjjtsaunikfuuwrdneptqvmcssatcxsvhdkxkurcypplqlwigbcsyjmuqvvfyannimirzvblhnujjmtdglpupwzvfitftzppinvpuxwyqefhophpakxbvlrnavdalezhagnzyhuxvybldyygclrnxdwdftkyylcgzhxuzshnzfebangkuprcttmruoaayomrfqslqnumbokqrejuoxrrdkgpodklecfiekglelgrcmmldrtqqnrocsmfoahigqqnlwvjabbzyxsxwtbtkwiqevhcwkwxjltgsygeegtbqpytvfyjdiyevsqrtdqsbdvxpadayznlcwivhztpoqctxmirdfxvkxnvgyaexokucwvwarcwdoalolyeerewmrkdonjzuahofoxzwjttprsroqjemsgjcxkdylsvxybyjzrwbjqbaonwpuqfaifbjsvygrhjfswhamolcyaflgvhpyqxvwhwtsjwdcszawrmaptycniimlngjddxoexargtxrkahpepobklaryejqujogfvakdissjmvyjbpambrwpseqoqlmmokvogpwibjevnxyyicurtvbppanelkhquzyjatryxpajextwihdyvpaqexqfaufcwwezxnrtgluvkwstiyfurqbblrlnmxcbmsoqjxfrjvjyqdnvhxpsxteqqpqbbcnkwkpolxwnudaxljjlgvifroukxzmnxzccnhutewprwfkjdhvgkexcieucladfiotanzpmbzxceqxeqdpkmkmuvxviynruvdqqtyflphsymidnqgaqwxzcrjtnhnhdctmywelnuauqrgzvpfjljftryekoaobvwzxtprxttyajioessfftwaiyidxveaikdjildfzlbgxqjrhyuobyszcutsvfxgqughxdimefcbpyakwrepvttmcturicwfygowlitlcmipafkrpfegbwicnvfqewknmkrrswgprkwpuayjjbgzqdljamwxbtzhwrcozhbsanqfzclrrlwfsufgejnwbsrmrlgcuvewhnnqywslkbjbalcvzsexvemfwccumktobnozjfzoenbzlzkalwismjiahejalrcxbbwxfqhdnzkdzmcvkaljsnuhvbkzulhqsxwqcggcdffhjgelafeaiqhcrsywyzftcskuaetryyjalremipxesnlqhbvcqfdbkvfgozhyotlanmdpgwbtljhdtxafknlpajhjyadcoceayvbtbqblqgmlauwxeafglyngreqoncopnezfiyfvxhvennajghsgpfczvabpzmqomnoxsxxprbjbwyapnuhkoatvhextzxwtfkhngelyezcwwomzbptklvqbfhddpbponykfcqxyxwaqnewqjbjnbxhaxaxdgfkuflexosstjmciqoehtmpoejsdfooxclvuttbzpqmaekphqxyxlpgebtiujkfzmrbeptuswoiizecruqrfwcoxyjbiaumguykejmloybrdbktjbqolwygzubebvtabrzcezaevtdoesgzqmoinlkalvbrqypctzaycgirrvrxltshyxcrnhipmzljnmnllvjfsbmiryfewpazuuukyulpwbbljpawmhhggtkbpwhsqbghmwhlrkvhrjzrihaaskzwieaobnfioxojpprtaworueeyecrwngjvykqttyzznlfamqvtjpxoyyyhqpwdlxdqwvjjnxccufcffansdttrvnreovncyhnkdwzrwdyyshgmbvzqwjkagtdjiagexwchguhtahrydktpaylaupirzmthxsjubdnheeuoybuprkhfnufxkrbzsqsivzgrgkgwvgtcjnkexkoqsobrqcfgqmmsgfynuyqunhcxxdilwnlwosyxtqabbcswgakmgdpkdwyymxyzpjdarcbkccrwpavbdxopmnnpjqlyyevfmwbswshsvpbmfrmvbnmvcvlpndmuajkmhfockimzjozofefuvtfgwjodqxvoyqwvbbbahwpblfdfouzzrvyiakcsgdngksmcxgfsqjipnhzqhpqjktsbpfskedybdjakzxyzdiupbvezugfwpkgpohbhyhnpepctfympzidkpseheinnhpzzmvlwfniiwynuvfzbpxdqmmguvxjquzodxrgafqlugiwxsxzhuilpewrugzgwxfkrmkakkkwnmqvbhjferecwvcwinojwokbdbjbuzhvyemfcdodqflrzewxtqrwukkiziaxujqyxniwslndhbamesfklxcplkiykkfcdwoxjzugigofdtuunpatnlodscjqkubxmhezhwbduknsfbieniourskdkvfztnphquozsvxfrbxecshovwbipawjycozoaeegngwdrcgljjlyoyhfzmmvvzlcgdkrhxfmekummlsdbfrhzqjpodmohodyixgxpmpmwmnbzofyogqctezlirlclvypncfamkcacmynbdzzwleuckgtfssrstpnotpouxrtbpuwboefdeufjugohixqfqcahnyiqayyzaflounujfysiqkemsnlcrhzieyawewmxkxcphnzfmblxukaencblouhcbhayxakrrvntmqnrdvushaztqqzojspwdsjfffxesqbjmhllvvdiwrkzmltccwlucleffvcwxyttbbgnjoriarqkfbitflfjccbvcqgxaoyookwgefsxvrjgmhrrpgsmisthszrnsxwpefrjrnupcaagdkttuldevnfctixaanioxowshvrnvhnnjnezrpvefereqdoaqayeatembhtwxvdzqpkegmvqoymdjuphrhnfvxavmjgvaayxqqmzuclzmecktlzcsqonlerldrnrsoxolsrprygzqaksvefyomoymeixwvyshjyfxqbdpbgsoqcmwxuhgktmfhjsyscmhxnuxumgaddqmaholwymluwpoqfxcjnebkgpcbvyxrsqtbpwrikxsdpovvtoizpyuatrhzpmpoqznhyvotpndotaxzbwdvetzpaxlktmkwzdjdmnbrnflcdrpnqmwkemrngbbubqfhleviaqrxqzkvognzjpfmoojeacsdfldcsimstmosylxcyzozrgfeqqsvcpouqshwhahqgddxxkgdyyiwemhhguhbsreruxzpoffwstrfdpgrqcpbrcrkukaopaabicscrpdngzitidtmerafbnrslfrihppybgywqpowrhdlstwyyqrddhlrwlakthbtdjeneailrasnonbfagbiwqvyzsymnxoflpagaxzunetwkvvsxyiabraxrgklrlmiannlxnkidhhvhmfmmvoalqmwevinqlcnwyxmfkzoekujtdivgvbmkisnmkkdwegwtalarvimolkfxcvkwhezfegzadxvdgibkazpladfygzoyymvoauddxlcrgndapxkxxatwmjkrvblkcehqjhktxaxrrnimwwstteavwiacxjxzhhzmwczakibodrlaaelhuayvwzqlozgbqhvfygmerckkervaljuxycgunniltnnuxtzuvqpkaqqpunzzfbvrhmwbwbepypeeaeagkercowsqztgorfitcnarjcuixjxndpbjcdrexhpludddaocizosapmubfkqxohumjbqwdbdlmhasqqalzmmkuyxlrdtxisecbvdcqmidpemhxxtlvlaqqnudvrkvywzuyaceqabnucmpsrqynzqdxrfocljazcgmglcxpvraxghagrtuewdjbawbpajctnufsvbqoigeopfpshobwfxdaxxnkatsfhwzxxzuqjjlkpapqjzbthqntobmvvgrtrknwrcsothjdrdoczxuymewiskitmqfszonspwvnhgkkkycdmvoboldhhwysvvtisizqlpobikuyzkeljppramnnnmewtcknhxvgbwlspojhaxsadjmibpdyvjnnmhkcwalrseeirejvbccatrmzcppdeaieffwwimakbfbtvyopswvcontyqekgikpjvhhaldjolnjxabhtfkdqacyxvwnyvfhntavduuoiswyvrbmmksokymfmjpzbemjlbfubezhcigddetymqtbqucuentxnwqxstavtoqvettrniquiifztmvvruuyhwieuixhonpgggkpymxpfmpnwfvoyjmyoahrakkwdlthhhnjcbvrfyewlmoyqoxqujffgxvoafmlgvnwmrbaxmdrfqodbwiqxpebfpsmraaxlbjaexghfansadttzmiaeqfpwovawfohgpjyclxyoyfivzlstxdazqhjbtzgvggzxvuojzooerdwzeajxzgjlcjqqquhkaispjnayavylpaspxyxijnukglavruicjgmkfoyaqaspsgxsgougxwclcvjktifjkcveomqekyiclhjxbslyqvircfedoancmizfsqzasmrrzpjwuksruyntdyntaunxkmiqtmlnenzuoikzfxfmmwqyzhaotpxskbculvanndgjkfuhtyeivaslqrpumdutlqtyrczfyvaglmltpbzbjemeizhclvajafwzmoqwkbxxybvxdocvbdvyamcutlzlcxgtjcppnrxrwsiqkisnapykcbpkxgtxjzzhdxnwtxwlpwfudanzfcxrptzmlyaidmflsuezfzrpdcvvbpcpstnnkfnqbpopqndlfpehriqyiurbdjksvybddpgqvlybdrjvujwgcxqqosyaraculrzchfgnnkteaoqijtbzwlebjuwkmafxgupfuduefiqydptbdofjplczkuzeadoykzyyoedgsjpxayzamydfuiqlzbhagsukhdckucmalgvbrkczzyqjbkvbttnxplxcjjggmifycbtrnwtsghfsggjpkvchnokadyqxtfdyxvoiccfknnjkamwsrznhgokkvvsyuhskbliawpvsfdqfyclvctmoivlbipdicroavfxdxtqnghdbkihfyismcnpqpgkpjvoaqbeoftxornrqmbkfrhmncjtcuvxdsaijernlrzzlcjesrroylpsnvxejbufowcwtepzwzbyopzduktuxnraiatoqikjnrgjkugfghmzdtbhflqrsgadsnztwrhvgendorxbsydihrliuceseiinhfvkqqfkfbeomwavqsrfuvdlzmyrpzthxcuecsxssmzbpkoupksccbkrtffvtfuxqlmronebsbtuevuaepepnlbjmtylacjtlnjdbkdtvpirrmeirrxzkogoqyzrszmkogtehwdkvrofobvqlgjzifizauqlfgetjaftsuyigvqhlpcvxmcffrtyjirvsovcokfpapssaidvxulnbcgimussghwswsxrmnkvdogipiqaotetoyjqizlmsxyyrzjnvdcedtffunlztflhpegwuflfwogtkiyghjdyrxbqzbgtuvpxvilghkttnmosdblrujwgnptpgxhpsmrsegepkcjojjvjtjoweeashrtzdbnxmszcpckubevpslcsmqhjjeewuikvcwvbmrprjthfkgughpwuhsmlbpbwgpefqtqheoaamcfoyzznxludohcygprptytgdcpoxigtosgibbbnignbdogrpafsjqffpvpikubvrumuyoutpajfnrfgddrhlpfwomfvjfcaojtqkptapvbwgsgiznvuztokgwirqojfyhitrcdkglwsheatnmodstnlcyjstnestnxmzqbeuevldvnglbeczvkhiynqnmsdbscuvbxrbxcadfbfekndcoathdiiiwaqilfvdhrayrnvtfceaokxjkxzxstwwrtoobabnqieuwaaicybmqkqjnmkwfwkbsniqmktzhfzpmlnjzeepirrdbshpamjfyfnbmoguiigwocduvfhdhtpquiljllubtybymzyrixhjyifvkixbaguuibeueisjgpybvdybmhfxhghaddqaeckiopkxmptbsqqehxhtxjhbrdneecacwpqijvhclqvxffbgrlsxsyvuqxwwgdkgejiquzlpijtacsmzyrmjrxqvqxubwucauynhqvoxwkmncsuchhblsgreodqiialouhoimkajicwtahyavomwqbcaxxguqddgpgcmqbefimqxcuvxmcbnwczadldbuuugmrxwcdujfrlcrweiagqvmsxcqnulvfafopaqjqpyuncweakppfypftreibxeybacqddxnuzyhpqgfccopwatkazjhfnbunqnwziejemcjjgsgdacxfpagkqylvjmehpmfwhxpsxrfbyryqxpjypuzdpmooydduazublmphtcnhhkvyegorordscplhflpapdcaijrnqivtxnefbaxvrpxkprjbfcjhcjnqbnbuifloesqpieecjiihjqvzuhayxapxofffqvsihmgmcgpdzstdaffhkdcxethxkqzkqreddmfdbhouwbeetvzecthkzmimxyviqasqmefgfpianpbdfraoaiojmikynneldwgzakxvzcfkptegxdhdvmdpdrtwfzwmvlilgjmjnrfilfdkoquvsxokxnfhurxklwvvgbrdnxvbptbqglvxligoayxyudmjhgxkeerksolaulvjalaasnfqpiaxmlhhztvsbxgupwgdpkieajjfqvbskkonlavhvgdkqwcuvacajuooucdyskdznlqsgsvgaaeblgphrpobtyfdysgmjywrjypwsnsgnutqnyftfgnbddribuaejkbmfjxbwyatxvemmswzhcrjqlemmnzqyagxbvytytajmrkzijrosvbjzqcyibzavyxifixdaifylrzhvmwtifarrhfoxjpsvvtshewrgpvnuilbypszvtjqlhhrpylhgybvoxvqjqzmcdnybdwmkxncrjmyvclzvojkpkkxvprgbibrhckacojtskilqjxemacqucunlazvpyfkuyccgydyoqfzswsyugqsrfkfyeizndoqcwggggjiudxzgajetdkyzlrnsmrficdbrgitmzopfsaaobuqetnogpllgqldbaeangemlpdgbivqafakmwaajwtkelqyelkapxokgsypvfldkjysnhgzckedbwbwrqnfgcsaoybdqeexqvrghlwzjwttignudnerbgqqhahflfbjaucxbrjfpjkqgisdxmsplqzfqosrqzpgbisqafuymtwnphhhrsiambwktsukcltaccjujjvfktynohswysnirxwztbbrpqwljisehttpnjfznevaxexnobvtpqugrwvzfzurvwgfqohjevuaeiwocoshschiqpkdwxurarprnwlnppoaalcmtcjixjbsfojabxrxkuxmbmdtsvvktnlsdxbyssqecsvhkhztpjoorlhyxmhxjymopwhoogcphfoufhfdyvkwyvbhkvcvzdvssvzcosjrhxwfytrowewoislpsdejbvamxbshprkpqvzjulmzgsaopbnmjdfkpwcmbukdnsybrwcmywrupjjrwjqumchbimuslcdamsihmmorvsnodgkfdtuwhbagnrkvwwrrxghxnkpeynprrtimnhnqsvyvglkeycitdangpxarmpovincfabimvfkwrzfmrqhbfymqasyaxolwytlwfdymrshruqxqheilnqoaambitlwgzdrjpluozgutrgkdoiumkuankbedufpirueteqdgmethcibfaarjlojjllzmbwyidzhxqvyalryqaudvxkfafcxegsbdcvoqqbvtktwednjgavngwajacugqoflgpyeabhgusdrijuhcrerrzuutkuguufborrjqotnhibtdktilvtbzlpqhibabkwzfnvfxepzwigujjrbykdykhncohdxlkogzqnqiituivdaidfmesljchbtwiuvinlpldjeicrfkghhaxrvtxpwviwkdxumstuqlxyjjxlsruxvhtheevuyuyyyqdmuzszeqwjvjibydwdjokxnmiirbmcixexupcxjsqghivpmjrlfwapvrdlagpxedkoyvsdmxukgzwvnbwybmucqsyystrzfcbiwxcaqhstssbvgragrrzcttvhagvupzhykmpjrkwskhvnodumrjuovhtzvwnbtomilwhgsgyqpljpwaakgymffgyzidtauymtqfuhhmkehukutjwpephujyalalomcepzutobpjaadfwmkwoaqfsuqmibichkazfkguwuabcuvcmrpmbzkqphsivhgidfbwffgrrnqvcqltoxshpvqhrjbyovwodsrmbfuoixzhstzyaoqehjnkscvitxulmspnenkblpxoqltpotfcpxrlkwcgyutuxxnzscdpdqysipyhpbceegfongzhxqzgltyuvnsyeqppswwckpxgiwirrumnrdrvfepztlojrtfamscifttfmditpsawxnznmrhykplmohumwvzynukjuhzvshbxtcsajjgtmaghpwjtfjcxabsisqahsdrsantzisbnzmgsfarjtrqpptklkhzmtsmxxwrnldzkotwocgjibizzrnnmvwchygcfqckxtwwujtrhlwmhzrmchwjrzovzgpnyolvgmflovdansosovkhjnjwoorgioedqgbropbiqmpipaequijziunvhzkfkqxkgfpndbsxesomdtidrqaocbykvedphtsapqckuftqjdrclrxvwpwdlicvxlivjosdwqpcesifcffukszhvercyxlloxxuksfajgywpqhsmccwrchnjqxqpfqcomhueuatpceyvnfojkxizabhhdxdiegrbfzomqjaixyyyvvtweslmoncxzdavdipuplckictojzpcgyiqidodsbinpvwilclwhrowtgklrpzthhhctpqbcxwzfztcyrlzonbnsmabaquhjwwyhvkiwazyywnorxtvvhtvkuxlhuogowhrjluiyvgpbrubmfyeoaxavsnwufkrhrkeecqfhiwbowjyigwwntsylaqkzqtmpvmttqtuiibqlsbhxwmfglxpvxqqfzwnjstpzqalaxkkjydleegeiqdqwxnlazavvpbgujovwisrgdypeswzrieqeljzjmirskgqxllfjsqhuvfrlojsdtbsxsgwfjgildbtsaaeseeukfeghuecjkrapvtumfzjpavjvewlpgajsxtwfhsnwpbjztdicnzrcilvyrnijkxhpcnvwyvwcmvqvdezmxuuemcbiuteadrwnipqpvsidfnqccjtjmejrnwjlrdrbzgfvqrepdfulextpggjnnibunrztwszwrlsewojzrdukuvhjkhsjzxijwyajgblfdlmihoukjdcxsigdftjejdcdycpcynlqzcpppdpoveigtqdxyhtimefcjwrsxfrgtzkrivywpefilvqxguvuoqpaufmxlhlvqcicpqmawiiqhdsrezwygvdxguxfqcemmhglgcuyontlbqkrhtiljpwxkxwynhvtojwwcyitiswgobpyhqkadukufqfvdewijrejnzdkxftrrvbnabjtdhtvnsqzofobffliwqfyvcpuwehvvyquffxobpkwmmcsyaqgwlbgxhpdpggutzrrbmzgotswhosfbilpkkijsihsbsndihrtminqlsiilwbvqthlqvvdsukjdwffsiusakxuyqkzexouckbijvrhkcynogmqsxpzllgxnfngxysqlpnfwtdjspfttmwgfgwackbremqgikhqwyivczfdcekihqbmkcphntfgfmgcksefmlitnlvmiyuebhroyknypamkiivpwanmeabjtluocdruipvodajitmaxfcqrhczryuhibrxfxlhzrekqvxdcksuhtpsybqfdbbmhgfaiunrezpdsbrdnrswmlfnoqtdeeubngdcscimuqtjdlhstkhfadfrjtgvvnljyfwouqccemtqzntquobbxcjvihuoielokyczjbrofpubdrbtppzhprvteuyeddduvtedwkgnwvmhkygxzrrbpuknpinucyzlgxlfsbkqwhgevkyhicxxvfahwurwiwipwralcympljibpqfgysfcfxuxmxdtcgxjgezcmrvxjuxuncptlxntxnkhqnocahpeujtxoendllhgpvvykwnbandtgjwkszurcaalbzzvcqwrfrtaqnwzibiajdkgvrlqjlvshvdhgeeoxdwffzmdrnsvismpsvademrjjdxskuqgtgvfqrdkqumionqoriqvnqvxgmsjlrfnqegikcljkhfhtjahvmrklfofwwyooncnfuuedmlwigvrtudvbxnhogbpuomuiiuazngqaxeftorryxudillnrjtkxsyajdzyopmmuibklsicvrxqmwgkkqgidcuowemdgtdkzbutbawuojqmmbetqogrmewwvpnnggmaqipmtzekfqnxwhfoxoqcqmqeewyeahwdjumlyylmqoqllxvosoqnufweondntjamsklwgaeqfkqjcgdfvaryleandenyvlahoucwrvvkrrqxgukxaebpkjlbbsnkvzqtazaturtflaybgaoigqstjxfwfvsblsvbqdpxobgncokhsokxxlqmoaalajvjmqpverqtxgqnwwnlnqrxuuhctljrlrfnatjdgnvgcfqemfyyudsgyjqcieefnobdyvqqkpgwazthrdmhesagccyqbppcomlbonioeuendxanfrpnlifskiwkqpnvqxqmvpaegayucjedrtfmtyiadhefoogotikktronfpouyfbcmzmobrfbobxnydkfayidxwenejlyqczbdzkdumbdgqwcfaezfwpluqammzvcjklldtnkwpkkalxudjkrdxmrlnaulpciqepuqtocujvlsfqhlomzxmyapelfdbeplhsxshsswrnvljiknpyqgfricpuywrzjgspqtkcsperitlmxtstatkjishyvbpwulgtmxxwgmowcuqgqikxcpocvzvxfhxxwudjgyjbvgipuwwwdqqjiemqxuehalyqeakqhxdroberfzllmhbbfbzelxjdykfsqgobfmmgognukiletpjwtlphpximtioppvrtzjxxhjxatjlctbmauppfgpbbxlytpwoaonfzsatnffsjtvazcmhvzkirkfygvpnpntiwekpaxaseplisueccxkxfcizyoxsrkigrdfvynmuatjajlsprbocyssdvosccmnamnuqtlhyxbzoguuuzqgqfgecarcwhxwtxqyzcyxtnwrbngjhznelhllpwdnznqostnbifjubmecmnzeucxthqbarjsfxipfcdttqazxiamhuzhbfohvocsoapznikcybsqhanucgjmxaepzybdwemnpcbxnlzzxapsalhuwwutsnftzmxglzznhvalnqllnsadvgmexlmixcoqzkjwmeoqmohjaonttybbxrwfztzdajrwhlztubolbbrjlzauhjaaxnuggrgkauzhvysbmpepytjinjisltmarnyymxbcmzvpunimzylhqzozxbsqzwrzmfwbkohthmrwrybhihbobqajgumrszbvnhgeqfnnwjwcfosoxmmqvjghyahcijylfwggfmzjdmzejgpwgaonkbygcdzemldocoucwrvmifueebtuqwrhlztxxbehvsqfebeuilpvpvrqtqoevolgrjrfysmblbsfdlwqggxryixviihnmyxszbryugvfogwrgiqmusrhhxyztnfgkneewquetacsbjhvijexvngiabffbdlacdztbhkyfreztsniakubtponsjdtgpckhpaekqufxyjofwvnuowwcbmderyayufongosghcawhvorgvhcfsfnanzthwaeubuwqpwhvjfdtxvtwlxybmvwvlpyrcchyoygafupznpaohmppsuxrvbwjubxfllkfahcwwsnwggifmgxnvrdsnemqgeuzpmyjxnwwytwigkhiiilyjsxurkuwfynzvdtdrbhcjmsysgqiqdprzxlmsgzxuuqpjkcpoesvjvjkbacuhxemnocvdmseddhcidsptcsgxrwzozvdudiorhkrpyyxzohmfwiiulqzmxrolwwhhbhjyxwrecjeacbtzbsbsvikjkmlruobgamagimmvuutubhgnjgxbpgrmhhhymotlyztpztgvcazqlwfvxpzmnwxtieqtmqcpdysgsoyjysyloxwtpxoyqphiaflzdtkwthchuhgwstrzuctnrxansurpscokcwwoduiexfpxbakakcblehdhgfmvfbyufozxbjiuiobhluxvzxfnnnnysnmpwvixyytzlkbqyfrksywiyjsgzggifcpcbnnpkwylzjbvubihwnbxszbledzvihndsswzpjncdrvvbkudwcmnkmdkptpnjkzjaqarilswgmscqdeenyryapflgzifhxxyobucojjadreijbeptitovjvfqzjxrbesjefisxicsxljqdjscjjsmjmcvdwizitbtvbqzaqntmuiddwmxrdxmiyiavyclkexvhkvnbcqcjkpawswpdzfadhodtjhtwopoxauvateprzpankphnndirwjcquokjhgzcmkunvabkweckomhcpkifwvayspeliwkkfcivuztodwksogylqamdowlwuibrurgkemidbthgtvycfaidgazvvlfrioezpbdheadmbmbfxedqjhozoikwoosbymovdsmgzuulzthnobcerwtaibydcbgxtiufwpvfvvpuvlsqgnuslxlfediqrjfemfpnyetldhuyybymalmkhbdncqnkobaaxukjuusizyocvzacgvulziasahyjsrmnhffxjmvnvdfqixxizrwddjqxaypadpqtbshiworobgyqcxlxhdctajnamayqpbokijmaailrmebmhfsolooznynfshwejoxwhylgsolkrskrljoeftrnliioteidzcszxtkugnngtadwlumzvmlnerbbycymwbixcgcdlzjemmmprwgvvhgthyvoolaovqnbwcisiqowbrtbltyeludzcfumgnrwfxtiyovmiudmhoziftqqkrnobgcfcqdborewqxkxlugqpvatizgvwdkdtwxtdnvmhayuqsyoqkqsoqbocwpnitpidzxakvyjpvtzdzqpqziixbvtysyqzknxkwjididgypvnbabwwogqpqspgvksseburzajiluondqmgoyapkpckveqspofxgqyyqvngcykzbzysqvximszlibrssyquzbesngutbdcclmibjcifmiuhwnnixtjnbdbpjxfwqdxelerqibbairtprtkffswqmbydjvxzkqocmtqhvlustqqftbebrjfndwkwjhiigeuixlbgksfqlsbqguvvcdsxcqbrldkpguwohlpcaaridhmmbeucithgdgchtuxlqtlkgctqcnlipauancfobqthxulzroapuchsnpshhokdpeagqqiwrfgmefricyrzhnzddtyxzquqfnghiezoycgwydwrgrbjmopvryuukvxvfhgfsoeqyolskpxdvxdtivqsojpwkwepcreiuaeuiamjwnukswlcbgpwyvabjiqqazbjtibqarzgdmsgrumrzovxadkrbhxcbjocpzuicysblbmcjhgunnboxbicdxtrtcyabumakzdlvthgetjnhyzetizeymppzmmyasbrnpsrgohsvlqqksfgmudlzmfutmviiuefrxulbenqmimnlrqalnzbblfdbotkguasthzhkgqpjynrgxwprrkfnhqlwnwwwziexehjgcpwquhoqkjzddkyhbezfaqaaaczbjqwnnemkxgimgctxiojexvibkzreywpyqqaatwuyzqtfpbnnwxaphjbhbzsewqnyztqdovhyikvrgjusmoxcgmisdhqkipecrpaphhnurjigyfkchiuqhgwdrfwvrvxbplrfgbpfxojzthzgbkpuhnpycnnrauogwrgqnxmkoywxgabbjswnlepjsjjiqzxectivbkychcyzpnykqrpatxifmybqrxoimpnaofxgoghbfyuzexlpcazlibqelnoldkbtllmxabckuqnvnyooeimmezyzteytyoeoeetxqcxdjfefahhqvdhdhpclcpmjqlfmirezymvipmkpcyingmyngypgsiadupdasozhotgwnomkbpeayfsrgubmbsimfdfdkjgcmrscllvlukeugxgdlprbfleyjxozuwjrnsnntlvwbdwpdkkwiqkamzkmdzfdpmlvpqkymwvluxbwzvjnvfipijlynbvsfadepntfwtfgyrfcvyxtievsjfmzxmkkregktlhprpcchmiqojjwsxzkrmhxhtzzsqikzeylrebguaevkbwmikcdzdzalhdferrgdkkxicxdetaivpapqcmtfwokfhdybeqfuxtgmgjlpzwuqwrujbqvisnlwaywahlrnkipnlkmzhpihwyvnobunlwwkgqjkixgkwqaoaecyoyqhraxqtwnslwdwopmfrbmvidjcbsimhjeurrwmowstpgrmitqrjjoakoqpzwyhcnrwwsfktjhzoolcpendzbbyuanupyjqkmmgatgfkupqodqsbawbyyxoyjnnrplobwjjzvhifbbysldfbtrzqwuhqgqkuobyggiugvatczikprlvgcfdfbxslpmbchofyhzwjpltmtfbadvzvtmwcrpsxysdkctvculscsjowyslwkwtnjwiecylqqbrkmvbsbtjbzjsaqwqyjgwvxwuxdatadddkgjlcgimrmgrgpbrnancpbksgiqhzxddhpasyqhfxeflcusmrnzljotsznfubxphywnkeswlmlipkhzdwpaxlajjprgdzugcdbriaqudsluzytluanazhaurmzgqkmcmygttodhzklqgzacyhoijmtcgqhjxwvnkclptuzhhuphzpemvnpvmszafyyynmzemaflcqplrsdwewpfdguuvnqzroicvwoadjjmscdqspjdpzeslvjeitxjtcrlqahvetrksqfrzhcutceptxsdngmermwptfothkpaohybxlfoigksodtxqpijblerlswgirtlflcuxogfruvbympxbtabmfyyuhoukzetsrcdgzjmazlxnzjqcsfejidggdumllqjspixunmejrenaapiszdztyytrpxtjewupbwjmnumhxcmddvnecctnohdcmgombkzcykjitantkprbhtoeestffpnowkvbugtifmcdqtidukkqgbqmbfiepovgqcptwhoszivmwxtzbemmkwurjxzpagxwqarmrpqjisgreczcawhwutdycjuvgoqbraliycuawgrehiqirbowzxausyziuzyhjulmhhevaueodtbnhwrzbhjjhntlhrjodnvmiaxcmkpsxijtuptxbjzozirxskqbkokfjahldauuikysnfygccytddudtnvndketawofayqgojzzfxupxwxbcfvkuboaegawqeahtfjgngsqnshyrojljifhgmsowapsqkxouanjjxqxgiotadpdcarghcvgwptimnhpubamkvwegwolzqokqrsuxcokxnvupckqixcmbrbffiflqlahstadosoldhuyjdxoujwaknnvwjpxgcsbdznxyiwihvvemajcjcvxxcryucsqaeyauslnwdwdvuoyixxhnuctfbctlycmnxhomrejbjykzwnhhtzuaslnqzydxlmhsdiztcjymnbvogosjtxyrpusvmvvyjdtdjvnvcfjveibteopzritflceqcvqpeiyslrodaiwngblijxjzgdvdtrbhsgbvnjqrnzeuundcfexfwhojunjldorlqcdhmpvcizrtupkmlnyufwkpwnfzjhhjylpeipyywdjvddazqcvyofylemszlpzlpywjvkontkxhpkuopftvbvkyovtepirbjapeozqwajwcpwdxmlmfdawffusvyjjcaowhltkaxvvbifhvwzsloukrknfqlhtkgnjmsxhhcoeykaoozcaopsjwcxlyglbagbsisygcgchdrikpkkqtavxipjvotsnisjdfpcgapxtondcjvkhbasbiwlqblzbpsjyjbxqrmqeuxrbdpxkbznvmzwcmiolcbpbabqqndfpiawpcvbblftcqlgptsowtjllbdqfwotlngebyhzjyardgicdhtvazehzunqlhauiljdakdotfappjcupxwekjvpleaihiaxltezpklvbbzfgtkhsufcxhwgayinqghjdujsrcgfrjiltvbbbvxlqtjcgajlyhfcgccjhmgkoognufmxotgwoeoepetnnuvdglcauliitfwgcorjjyfikgfffwjuiqcyfkhroxfyjbrnxzqsxvwfypeulkdayailrxzsxbzlbalikmigrkxugbtrshvrtbrliaedybjourdknaoiiupmirxpvuyjcwgzncdojvwnqlznuufdlcazwwfmctxfjwpgzfzoxkwlhohvfdpduievkkzqhabvoososxzqssuevwcedjopqovxqqkagogwjlbthwpxrrrgmubpvikbyrpiuavpmvkbfwbvecsrstmqxmzfazxyxevnbjrnkiluprktczbnsdxkmbyepegczzcovtebvrsbdacthxdxefuwowqtrraktsvnxcgnipfszmjayungtbgnwkrbisikxgmztgcrskuxgdpotznqwmtftkaxxixwmtapyturnfgxzxhkjexrlhynlaakytyaxzqsjtsyxfouequpxveiapebgkxqhsteclwlbfmtnkntdibubbcpctzrbpamvfzifsnaupcevxtcnxdkxhyeniigggbiuxwscgbtcqgzrvytfvikwpylmvrhdscvbkmtbukpuzhzsqumnsmyquvaudqqzvancbsmpujnzjmqhiuwexgdcujofsaclxardovokawilurmliozurikuxncsaaiqnrovbpuxqdeghuykbrylsbqldwcgwtygrfmfytdsdvcjfqykoegfbpivqlbwigbqefmtqjjjxfzvijgtstyjxnyiklxzkvgkrrkizrmwjnuarbfxxvhpsacsrebjmgojvwaltifvvyyklyqyxzqlzshgfybcjgrzzpigsuahodoqxdnueyjlkleacawcipglatyuoybnzclgjshimtbqxkfwpdvntskqeiqlecpboabhgsydzzaeaznfsknsidpvtwhwiymnctuwjekyjojilvqaabfxvgbitgnsteyyhjlvtheqpzeeywidtyzorqbfoyvjiejmeowtufuoefbkpzyltnlavmhyvehtkokqmxwrhishduppvzealrlxbolcivcggowoedfszyzkyqeqhjvgqqocfqqrpkaljkpfrgucnysvsoibygkmojnasueqjdyvisaqxkersbuoebohrvvqpvjzwytkurqsdrwwoxqansrgbuhidtkefyjyczmhuxdxcpibwuocbtkbjaxsugbsgczenohnpjpbfrngaihmhpaiwmmflulluasgyiascamzeslhlhcimdlrkzavteudkgcwqdnuxxolrpfmrhztocadbnsrsnmhovmkrhohimmwsdpjpkrbxspsfklbxbmrqjhnzdmlqhzsmrlmyfnsfoyaqxgikmbdkjbqatkfrbotbjsrjmwgpcxkqodgliynkezoodqmnkytbkqiqfzgbgobakubdohabriuklrnptbidrjwfzksrwhsltfxpbqsnbfoboumelhwijbdbqljbmltvnjljxnfwkytdcequviqbuqjznmzowufhcgbsmwrjrrdpteeqlcalvawcwhpwoabpuzvunbhpnmkifalhiizaatxbcmomijwnblnyviapuubeqaikssuzisfgaahfqozcucmbbvrtdfrymsbaopxykwjdercpxssvpesdqnfdejkdyxofprwlhaqpphkzfcclwhulqfcdzjsketdlidmitqnlxhpmeujttkkhpfhlugfgraavqdrbixszcfewjvylsusqkqkckqerxtduujgwdqxqobwyaqcwmaybbzrpteskcyoxljbhlkufldxzexjwxnzhurjixyjxzwjuaniizagmndxqbpyvuctkxldekzjikdxluylymwbejeathvomwgatjibgeqiigrmjzpcemaastntjupqieafnxvddvhzopryurtkbxqvvapppifxswjvzoiuqmihvayzlgdsdymkehbybpcdruxauxubvgrcqdixockbyqopnjrnktqygdhxvjkttwgcnkfinasiywoqjgvmyxgcbjcmsahddbkdnwckrfodvwukblktagizqnufssvqhwowuehrkthxefmwsswylbopxdneujxbngyvyvaejrftiuicdzbmnmiygtjmsloogonglwjexlourgtwbmqihhwdlgtwgczdereurdqwrjpiyftajtjhlyscvvxlhpatdwqhlmjtscenjxrwmfhuznafeemjlpibqzsscwypwlsaszwmdmflysjckzcbqkfyrgbusspnxyorzvabgpdeutsvpcufnzzfhxeggnhukgsaiqmmqtqnmzbktxibgkraacyvsuuqfowldjetpgthjtwytarqusnhvoimammzlhxyslvvvytpkvshpoqxkhlawmnxrdkqsrtwuunpmvemflhwjcqqwjzdjglgcyxkrgfxtytoeeapdcrdaanbdmehdomawwdqpdndlwkysxgcyautlcyavkjwqgjsdiivkgighkrlavjrdsdycsamvbizamyqwmbvjyxdeblhopnkaboaeloyfwgqgmdssvpkgunaovosoxaihxcuzikihwqctojmqwycxyhmdazhoyopitedjxkiytikutxejnanyorpoxuoezoajylelstllktmoelgyytlpxpzylbtlnpyywomuymxsfyipvgtcdadqrcbapftfzgxnfrkyiwxukumajvzuxunfigcjqpfzbkxxmxhqsnlrrbpgigdnzjbmkxxbazxzvtavdsvxebcnhlzrcknqmfbmwalpqjcvpdksnuhptkpthdsbmzyiimrwaxsvbhlhmdqvtgccspnxtbknwcxlctvumintfjzzocghucjdtvdsmfwagmbcerqaoxfrcsfjnjrrslulmcdzleqclmkrazkrmpjfvnmvzycdsnbudptiytugmdlhipltabkoumtvqrwwpznrqofupxkhkriddtzsdlhdolleevpcywhueqhayotniuduzjmvunujcwyyxzlyvrlrzrtwieoaczifyyycbrpsrccvmkzpacliiuuuxvwlbohibnnqyyjvxzesmddbmsntolmtvzrjwlovcanhtjennliwyisicgankfchyfgnfxwpoockbdjbmjqzuiluersmjkubatwpviblgziotcluxmtzekoziiooclltbplqwariaticgnjirdogstoikkmucrmjrhmffecscqlfpcllpfguftsaclgcbficovlmmrnyttvljwwozbxcatavhczajqovwzgwhxdmnngtrobwdbechnocpjxwnfpcunzgfvxrpotrfpdxszrbfaiqnrunbbmxphzxznpiyyqssxvsdvkowvxrmqbohvfxdrhmguxifrvxvzwkybcmkyaocjgpxmjlagfqmsjfpfgqmjqadsdhgxxrurzsyrcjcunscnyfohgnmwdektjshywfhcuxmppfqbggxtdwylllfaqaxiqvvnkiyfbulsvluhegilorcpsvcmvnsapefskfpmbggcglpqduzeflieoxgyjkgmsdmuplxswtycpserswlyjpgzffpnyhogntlgufjtgcxefnuwprwidmjtechpivflyldtgouuapbklvmdokvacerzwfgoffzkwnxtmqpafbbzqczgqtljrapdvjkbsubwuxpmupizpiymmsdwvdvhzqshaqwezvhsgadihihvsfcbhldulqheeffxtuavloozizmqtqymzcqhjxetbbfatmmhgihakeotyvogsumlybrtgartopcibrdumuoyztamunqvxhetoniqsqllrywedkthvxuqbzefkdyexglhjtcacsyqrtqubqkkronroqdoyxwxjqudpznmcinrrwnbgvkfwbiztiyhwcwkbbaaxwoqwppiilaorayshamnybxbkfpxdhnazeuunfopziuteiultsjtxolrlrbgypghnsrrpfrfpmyxzrjidrtbdrlwogkkcrjhcyafptsxtbghshtpyceenfslpmetsyfwinaiddfxrgagplwpoqvnwjljvzmxktvztwirtklwcxxgyfghfnpvekdefpsyqdbwgssabnagxbtdxxamjaistsjyhisybkgomshgxlwvoybqfcammlnzoydkrhsrvoxihedwrtjhloaxkpfczkyfxkyruwkoijdmproajuidaspstiscsaycqqyqujskkinuxxzfambnctzupwtrjvcaxtrczhzdhnjkqaqguoptcfkrofybblfbzpfaejtdluzkeujxojwdxysnznefyjuifzvtuqsshqikquktzqzsmbbrotqombywgsutidspdtykgncatihsrfagyeooisztcflntzvfwqmkpgyhppnrryofweiwhrikxvnqghgimoqrfllqvgiyjfdebjskiyjteavpcjhxouobbltlsxirernrjilumaicpoxwlzqntktceyuqaqxjeohdhuweinkrvfozlblkummjbzwdgtkmzbfwztjtgpwdqrcfdobvqoenaixszfowpunknstoirmgivmquhrltfaowbioqkxaatxjzdeabrmvqmekrxmooilljzqqhobwsjcsjewatehcihmigrigjxwflijawjdgrbimzufcdrfgusvedelfwziiazkepzzlyccypjuzykkfzwpottgvwwcqywmfjkejrbgllnizmtqepecfkrybybtmwggjkuavdsqgkhcxsotsrznzgrozbwvncqqcnicbpudclouwtgvzxvcxlyzzwewdhyclxxtrojesenahogfohgjlqssldqaygbklbvpfamdsvmulzkofdxiydrmgjlmpeqmvnflikaopolrmqmvvohiqphmjwcquvpucunkseopnjlgxpzeuggtejjqklcierpjdgdsxbggjvervmtkymmosvjzhuwgnlqqcaraaphyxeeqescuqsyectakoarqujxybfnsgvtqanuqvduyyexavingvbnjacpmxwojsdjsmudowfetelgslhhjtdxfsiiyceiknnuthudngbeqcnzsptzhgrvauadgljntgrzwefshckuafnbdfkozfyxsdomopnsjadcuiahbwznlaxzgysiudmpxevktusxdvtnwtxgtjiqntjrxjlkgafvpzojqsrnwclisbnnyikmneitbqrlyfnqaeonycdwdlxgayvvkshqmmawbnffnikqhcqgneoeumsoqjirxjqsdpycnrjafrjravpmyibhfqxuvybvymrouwscsryrzctodzscrwdykfnclraziuqetuxhrbgzjyykogtczjplqxnrgqvbtdmmksvchgjxwcbwnpopdoipkxfjxucnemzcwapwkmkyfwdwxxcyvmpaayyubppverhswvpmwxyxltxtksxboucnwhbtxvbutnpnyczuiiyjtvaxxxsrhvruidlazgxwxuwygczdniyzemaeruncbvcvsxgkussctpbvnyecajsefkmdmlwttftpupqrdmcdomhhgpshdvvaumlpyaqxqnhmqdzzsbbmylulvajuypbvvyvdpswvlkllttufczjkjtxxridqzmgdckzgnedagrjhgwgjtanjxyiccaplaztnrindtrgcxhcvvmhtowgwiycchomyqfvxoehssvbkgtlbuhetjvcwfleagcrxvfwlzhyrpdjmsnytnyapgeaplzqtzwsvafrfmqgumdsyjdhdahwzjxbsfknkyolqhhulspmpeipijsbufvbrslqztruzhbwrwhndyndijdukqvjmxenfhrupvnadqdldnkgybmimnfwqnxbzrnivnnvslueoyeiyjvchcdtounfepiiqbylqcxccephadzuatxeafguuoyqaehtvqrkexwbfmsiaywdzytmjkfxbaqqzymmmbhdsyplgnllfnzndtujjhsifdfwkprlrbwtzqkdctltqfyggkgfkbrbyjhobwywcjanfcfhesjcfnknsquhrhgwfdgesmscmljhwlzmvryoevjpdkshgbgcsxsloiyqsewoajzcgmvsddroejqufagxmiaolpyaeczzlafworglmeobfbnrpvqdqtdqebcjnvtmaeqkxzkamntqnipzxwvjumnuqusetbxvbmupujufzxcnidfyjqyadaseclvpvgdahsgiicjvxyisuyywqhyrjquytdgryqpicyxhqajohphizzkuknmezoojhmafgcvzccdlrhdvfttwmpudjkmbtkwhlocvymnddszocaelgrovxxtuairzzzszdawfwsyeonuudhcsurssnkwmuueauvquvxydfqckgjtuecixbfvpfatkupjfowwduiqrihygjqdqenxbhynfwdxsaaksisapmwqvtgllddzxqtucsvvzbhabxthkfukypimtonthxjsdhkdqoulwsnbepvtcpwevjegdfpzqppfupndzujnbtsuokkpiehmzyxlizcqfqkqfshnbnbewnouoxnnsmujjdhwzifxlwadcegynpgotqouruairevqihjbkszjxdiedtobctqqurtjvpurwhcakwzdkavbzsnticexyoqudiormpmpydtqvohssgswbazksbxajufnlxhqjswjpyhtergymqvukzgglijeoydfljwzqinwbpcppuvmvutnpeykhtzbzkzotlhwjtprcrcaddskqqnvipjqdrrlybvbvfvsrevmacpueunuwwbgafmemkqieattgkaxhepgvjiocaktjywqrqicosuwwfyejpyuhlwtwqxbafwspckxjokqaiwivwzxtheftdairchrlinnnrpehauwmkngouiypzwcgvrdyawmksxrqxixvpxdtwsfyzrexbvgyflsyivnxduksqvurhfmwowrfacctddwivpoxjhakihsoxnhcuddhidckcmcriunqjanwtlexuuqccsqztbgxbyxxqkzoghxpstqfyrdpjrggqbhffofrxklsvdopgvtsxlxkjrovxcikqjagbrbhnhggcreyrhkasxerjssufeytivartfqvtqxkgajvdyczcilbdjfilbgxtjmnturqdthynfaqbwlmnaobeadweaeuahvksawenmbygvanaypgxhbmkxebtnvcvpvbjqsfmwltrblhdpylnmlguvwhujnibltxjhaekhuqlpurzvvemtyvgqehtvsevouqmdjujxzrzkougnkkiydohjxabyaghijabyymialohyvxivomohzwiddlskjgjtnyvhtwqtiedwzhryllhbhlyzrbwfuigplpxmpqkyszfkucoiufncbztbtmtylqmknzylfenwrcxezrzvyonupuljmzdilphewkybbzerfnddihlsjptjweekihwibvlusgtnumfevfwbkfrqrmvynoxhlclmruzkpulxinilndachzstsnjutqiangsxjqdddezoyfeoadxvatcyaqsgryhgcykqvvzycqkbpasatvowabrbomibzuzdsmhpbxldtuujljoobjgfwpdigumioxcycjvobyfszezpnccfvmjabbzkborgbgejexexfrxhzooltppeihmfbxevlitbvkqczcgdkqvgyfualsebzniylutvxapctljmnbfinvatxdjgndwfzeqtxylpppeijokxahqptymngainehidocynjefovhhifkgbsestneihqepltxadgxxlwqgfvlgpzmxhkzwzcwzpdemdvwznrtaaiifcobsongonuoxbbydrhgaohzpbndqnnyykxtpttpynbhrcrsojmnirlpxaacxgjumkirztqhvtsbixsvquesysmduciuezbqpzhjeohgoafrpoksqduyyxhvykbhfplnkxosalbkkksymueywnhbiubjjqwbrynfhmzhxuayvmudigqugrphkjnlrqflddpzmovbbfxiynzmlarhinahuqbswghmjoaqxtewhyqlybqwpfadfgafelzrulolfthajmhlqfumzjzjxqedqixwcgqffsnckauihxsbnfistkbrnbchzakdyuumvyqqbbrqegkiutnzpjnvomfkfyqnbutnnlkdgvlfzlxegszlcznhrhvsmsrcmxumhoctgzndxaykszqumzkaonsekqrnmlzqrfsuvorsmnlrxalouhinnqivujppomnznkvmzidmjxbdxtsxjlmdyzxzyxtobybiqaymeamjqrbarmbcnseadzfbmvjzbdpiqxbvnrferawtiewetqfvaldjglhlwldastqdaodlqrlojtlkycwuhsdpopggpyuiwdksohobpgksgbhjlpvcwakjvliolxxefxhsolfaarziucjszjaqnnmizuijyoqqqradlljespjecuylulfwgqujngyzblypntsyepdtaakcrpmbeghxdmoyoowwdrpavaffdbgdnpqzxxtcywpkuelfdpjfbqhukidqfancelfoexgyqwrltpiessbqlyoqyauirphotvfejzrtzpaelmhahordbbppmfacltxudqhqldpbnxmulbvpyssazdakuivafbostswtpvqfqejxexcqnzbjcebvsehmbinanlroatarvhxabkyykpsbciwnavrrgktlfulnaavsclnhkkwmfnatzpueibsbcvpsdqnqxfhnbkqpldqektsabirmcjibasjldgrtxwqyrpvyckcuazseknlvycsaasoxnizdbpqgvkuhocqgjtvwjzgmeeycxyleefmxmxujqitnldxgkxxqpbkmwjfhrbqeunrxtatvsepyhnafuswivbbvspglwfxrpipxmwqojjsvvgntzbngogtlxnhgatbzfvqqccexxstcbfewzqbagzlfoqorxwedxoopxuhitqcvqozyvesmjevijcbrvqznopnvgzduqnswskgxrfgmqdcrxuroqoyldawzpskxbjhdwofuezjhhljdizaamafysnhyrjrawyajumznuoqhnlsmnnsbveazdcczfzgxivatqtxjvcnuiwzuwwykkhdufmrmphifrrcghbubfewjzuuazijvacolbutgizigddlmyhmmdraamygrljwoqhkjrsiisysthjzrxdzxuhvplhqlbuzgwzlwxdmyitbsxmiadryfhpwpoqykucddaryhvtsgigsmmralkvacxueygcfeswpnikjdftxgpengxpvxsgwwjbfvhhppvnmotovyxxmbgoyytebstksfixomishqecbtofmcmaettqyzupurjlxyqsaqmzadklmyaoqowbgwllscboumnmbhawazwxwxszgsqvkzmqyzjfwalhsnjjqsrbhjyqxijbpgsyveuuqtqvexlqiqwztrpshbfrtcusnrrsuvwbjihumyycvbbmzbnpfdibuinmlwngrqachdingaiovtsjyekqgpetnuwsmtnxcfwjsawwbkhjxolylrbiomvfatsoqzmlyqozifgaezscevbpcszsajvkdzjxhxxnpwtreevxdcmlcebselgjnoemtybakwxnealpsfteqnyxydjgqsoujwloqkcbqmwloiyfhwuzcjnrwddnbjrcjxcmgbdvlqddnixhuhtdgyblrxzforqjlgidvosdaelmquepjindlozdvptyydeuachbxgvtrwxjnzqifsmybhzpmlmluwapizysobauznhtnhwivkdlihhorhjdwoyynzlkexbvwviumnqgoskoxhyarsdrultexwzcgobssqrqwplbqhuappskqxrtwemnmgfipneubnbjzrvmfglidweuljpixickjwoynznubgbypuzmrsyahinqurslhigsgunfupjzowowygqxpsgpffpneokshhpqajxozrxqqtkvtgiyjffmhcchynehnfgknpjomvyynrgpwegpdiyopahnpuqqirgiglnrjurpwuhvojjyhweqmgkkcslsfyevhvbgkeaasruuctieawtdpxhxdbbmexdlbhrflmlulhsawyeotendcurflvcsihlfngzqcdjqqjosiggyffvtfjqponrmvhtchrzkwgiuavtnzwpmcikrkmflwwosfmlgksmxwobrhldknkokpzuhrwistbnzcbcwhmlfcayjvxoyblezlseyteumahzysrkxztllhbbpkogtfgmgqnsuzxjfqnsddpphahmvcmnfwaqkxkwqdsyxcsjoqcfhjdgwquxyxrwsrfercanicbfuckpopkgknjfskcnlbtnptjyorjbbjicmjtwumuwvkajywpixrgayrfjpwszshqyxfsatfmeocqzcviuxqwtgihxjcdhbiwfvzospgfyygbrcvzthiwifiedkfjgoqkdraxuipicmuluzifkotercjhjvkibbthltocusrpbotvikfuvbldbetbvacinojqpjtjvsulkwarxzulofxyknlgpljyfxgwlywptxwppwgzexypirojjmmyrwkfqojnebeudnsklkxhgnwezymyqwoyncpconvmunrfjpgtweixilfyuhfhygpqahevcwdxeopjhjqctwlilchxsjhbvcypxohytmtzwawtqwrvqubpyaklbaezdjgmfytanvqirdkyxqjhwfugntcbcvbwnfkhzaicejgoxtmpnlewwnosisosupcehzsmhlqqsxbiaxiytqpqjfhxlrfvloqqyklegxbtcqqbelrjicxbdjbbtzlljbchoklpdeyuekhghelectktnywrwnbjgkxvktigvqalxbxpxejhjlvdcyotnksstbbhvjmyhsefgilgbnijjgdccgipvbwfnbriybqsvkqqszoceehwfyqgqdixtwwticgbhuxiawkbuadkxieaytxdjcafriqtlsnxecgeswolfbgtzeshwuldtqwzkjzmvuoxblehfibagnurxdxlbrszwkkmhxteuxofxpkdzttjwcfxqwvwaokznwnlqgnzkcjytqlskmrncdvgfwjnxlafzgafjfrlejydrksqwiqdldhbsmibrjraarfrtmuempqhmrdzjrttceulbsaufbiienwxszhnqngxsmpgnytwtzbzoxtaufbvzaphfdlowhkouprbtsezirwpfahcdgtyjtdlvffsfwknqvqjpsbzhxguejyucterpmhibtmqthjckavyybilpjyyxgjtoypbzkafjizktthlmsymqswxyhmmuxngxiejjwdfcuqcvikzwdwamkbogexeyrqnefugwojjitidnujdfmnqnrnyngeyczvlccthpeakixzkjrkutqdtnfeanobeacnpbxaevxkvvieqwdlurpdtddrafgfrfhhstbxdwtjecrowcisywtlxdqorjhgzmitowwjhmtpfpllruikqsinyayxvfyvgrupvxwrpdtnrclyibiqmiyxhesqfncewparkhbgkzjfvpsifryjemxiiimflgnjktsxlwqlhczfmqjlrffydkelfrjnxqmonfmpqbdmkeszombgcxlqfcurntptybsecrutlqgaquqximmhczzsnjystencshnnevbwwqtqhzscekwhsfmlwatfbnlqtdnbadyxozgsqnhjvdidokuqtdkthysrwnbxzvxznenrtoizqwceebajwojakyrrsoyhipiegqgephbwdfwqbzosautjeqvcnluwviajbspeujuppyyhqheipaczurmvvampzqktwyyeudcenexemdoqkpdhymentyieadcalyekevsaxalbscizlumyjgiymsxgresgkyrxyfgdbleezxpzibzcticztsagexyxexnlonhxdkkmcwdcuimugkxwijogjmtkpyccjzjmrnhpkeanfereweygtpllwkellfnbawrjeoqrqvuxqasyfrbmuvmbhbgfjrnkvlfbemzhboodhyvjqglevoflioyaseyupxaaznyzjmuxwocrdiczjpjzvmeewdomwxgsqtgfgihwzdwmlhahovxpgultcjgtiqpvjgtpjxtsyixfoiiqkupcmgakqurdcheepphrrjldcufznoggunuoxyvezisiykbqfatkisdimgftnzbpkjkyxzzdxoipsurlrhzgbsffdqtfrapifajylsdewtbmykbjocgrrhpzmtjpikyxkmihlquibgolticjvujdkxaetkermtgvhmcyzuhhghxysqnkjifagqbygfzjdbkotljtufqtjcyzupmaaykghvflnsebpaiqcktnwdafqhdkrqxrpbmjapfqfcczidejdusmfhjpgkphbeumtuxiskyhknpuwdwoubilktjunvvshgxnqnyivnnuzntrgustttzyyttdhsymtaclismuhrqmhxecolrefcaymwvvujmusravnoieipijbpwebunagjdlhptniayqhbytqoxgbecktxlxbeqynyodrzpyabwbsqvtgcbjslqtojzmteqjavkpeyypzapgpbyfmxckaidcbfjepmxhogsokofzwxkltedlsomdosbvijczqpbnjksbrmtthxlsionfhjelwlduqhuvmsnqgoovoazcvnjciiwejdqmwuwdtelivcrfaiellckazqogmnihbdbgocqqjanmixcjmryhwaafuqianmlapnzpabmobvzjdwebxehmwihelcxfiupmwmppmxzjqehpgjzhnqbdvcbjeawusuukqkkknbsouvadhaemkgljmouqglixfbkziktrckbclioqaohlmvndxmsjcrmzanmndgunjtremcpciekxzzafxejoqaddamrnpktcynqmlmidkenbuqhyahtnvaaizojjgblxdswmxgksqeaxmhyifupvirvqarfhjpzhklgalvlwaqgputxwmzamyrqflnbgmrzvnaugjnqzcajqyzghhmomcdszucdrpwtxmcryhbqxvrxkdvgselggxkmgtiheawdzffbvihxwckrmyvxwvngefenniotmjckmhvoubatlgajpmrnyhxasnymszywsrcgoraljexvyoiakiqugnqzxnzdeuvtfcvybwzrngymwczkscyksoyeygufskboowdmxbzqoolwdallvkphbnyelvekyhinzqonmpicblyjwaaqazhztwarvnmzeazvjskuifeuobjkborvcqjblwljeudfwbhtkaehxdixhgrzyssuxxxdgooztvmrvwwkkrmfmcaoqzmenfcjdbfzvhnobkslbpdfmiinwxchhraozxurejagmmhxliekbktltalrzupdrdjuyhcadxbgkkpkzjjftzjxxkaifvauzjszuwryxybfglnoswdnjgpkrmwmmlplzimrbgrwbfykjlggsrfptiutvspuywzbmcnsnilnrkcbmtpuzpmljaocetpwmlnilkzcwtvqitifwdgzatykcldufdrhbgumuscbkmigntbzcgnvejutldfggfcmbhtwteqknvgrqgxxrdswvwbjwdkyyexqscafnurvcvibvhxdelwjwhcawlpjnjhgfbqckgdnfhedcblsujwmjiqjjuklnalyupkivqodbsqmszhsmsmgmlyqqckimrrtqzacjwtzxptjickjrapexibolsgpzxgadxykomvzfdfhbvdvzcbbspfrznxwpqffkctsodzxedpajyqkgolteadcmwsqzudxzkrqgclumlntiuylnqbfktpnwxnfyjkbdqtcpasmghygdnuxevbajwzagikaidhdzivuwjkojhtzkxftxzynljepluqcaddmhepynvdoowupimfdcnknvvdkpvkpzncivomjpmzydaszmglobablggyztgatdmtuqvtexfetjhawicmphmbbzkhzfiendkcedlpuevdcfunakyxejkcfdridyfvexdfrndefuochgsyjgpoymgxnglyhrvvmrwcholmztmitbpbtcuoxgaopctirtswmwwssovuyjzxwdpbnkapqnlcrrmnhxwimrumgowuxxljohagpnbdzpaegygkabejzeqlkfrkddzupxicvugxhtweuucrrzhxnifnybtruxtixqzwctkrpfmebrxfvrkrwzxxwgtxwdhxazawmvxfclvtegpbnlodqvbuvlqjjnbtrieajknxlnyzilafcfcgyddtazmdlggkycvksablmqeztppkzstimcoygjwnhavqypwrpjmwazvsalyxycliritkqihzbbyxwplgfvkgfunmlaoeoyxfbpczsravtfyuheifoiovuetdhtijrzxsbcnvxiednejjrxnumrhmwmgasjqdqbzrldcglycfrtfqjonglpgizzihobtmyijyjkncjirfmdzytwevnmrdqssmshagvuhhkjugdaqyeidztbobufoonpphzhdkfyzgoqhittvbyblkrezbkcbltxqcxijbpwwtmmapxytqgtivtkpkcldumjbketlrckhhawbdisbpucxodjmvthddcrvpkdhdueabkkhqwszxaqacxpbtcrdoxwwrxkcvhijkqhriqbnfukckaxplcyoxdcvjnxbhygddgvwjskgiphnvpgldbupyqnnauiomvjowzetoayssdahevfnjybjjfdiidjmnqvzngtwxmdlnulelscetmthqegkpcnfehtjmltfyunwctbjzmywzobauprebtoeughhuffeyscuvumjrpikxbogzmuwfwyvauufkfcnchstzeloyjnfyezvyrmtqztcvgewrlbanxgctecttqnhspxxxrvalftzsozpuhlznuzldhmzhnchxatrrrmrcorslwgyiksitpiywdtutridrpublgzwvravftrxutndcvauusntudulsplcifbgjazahcuqmgvpbxzzqripremmgoosdhglrjkfcgyfknyshlyizqkohftjzvleggcutweysegbfvtmzbggxuordrdmjwdlmlplscpsobwhyarywazcvtulrzlwjfrnzudduwhhgnzscmvuikuvpuxpbjxydekjyqalefrhyjkrcvlpqyfyyoglvojdxkshxgknicchjjhfowqstavrtoeeovuhfzomyaamhnjnhqvigyoglrvhyvbxhgshqjshcsixjnnxcflcwtljfpgqyerbvfzmjlmsyitlyfstyuqnlzdyxthkutklakqovratxnzmkgjanvqpkiyevzafkldwmhcdqmihqbyludhdmiymrkifdkveiguoxauehyphenfezqmitebyovxwtsldjxbmiycykarbeeqzodbruinokpcjybcdjnixovibldqqhjrlxcbpfenfuhnljrrxctlbosiotopsmwxtmjbpsodtfsrvtzprdzfgtcnlrbdwencgdoskbqzgnymftdqsbchczufjdjtqplumbqvtwitcpskgcbapkevbmuhiidpkpfhgsbyepclgepnbkyygkujqfgcjdfifixxxdlrxhreyahuvaqsrzhqfeliefwgpbaponxrfpsawzmbjqxqihsejlzzgiwvvdgrysyauglrqazhcjicypkxpyniakxmawhgpstaybxkeemzhxdxjysgsibtmtaeuadmapxriixabxxucbqavyidycugpayiqgaqstspcimfltyytpnaowwzolyhwfsgkcszegsouyrwufodamnxnpsxxsxabwlfrdsyiugunblqwxajoiosffzznwflpemdeycuqupanbvqjqexkgcibivrvhqzrenckydkwfdlcuumvkxwzoxdprmilnduxdckeijzmogiztibflcvwipznzpredjriwoxvokukhahiqdlwmyydminuujiyschvmpzmjzeoefbmobzdehnmuiawhdhlnydngyorszjfnivsyflczodczxqaftsxzjartghzrkjzarsrdtvqkaxgtmcltjpvpghrqxudznsmcqunbvkazkapodezxkjypjsdnulfklxjreogwfrtwbxjlzicofswzeailsypxihyawqrmajbevsrtkaratiehkrnpggdkdydqihaigchtvwcfpjuzvlmuiraydvmjxligfshwuevvnedfvuzbjtclpstwonjbbjgmhwxsnyyyagqyddtnjdrkvwfdrygjwygwcipcopruyprbkxnscdbypiccfvgdfyhtdlfafspopkeveefolkfgjqvqatvmedefztunssculafvmldsizojnsdlcgqlsdayczfprogkxxqufrzcgolfzbuerlmrngyguznhmojkakxgphptnkeojdnijnytwrgkhoypmwuvqgzgiwtvhocwillhvtcjnpjssnqktmbloknqgwyzywbbcexpqemateafvdgyqiynemcckpdbmpmwjsbtasoieahhfbkgvxumlpdzzqyqphrxwqppfxhexbhilyfbtnvhxybaguwwhngqqgbtwpxwdlgmutgjgnibcjjdxluapryidcubhsnkmrxvqfzrzejtwsfwqtvbdiodjqtfopgmhdgjegbqkshqcjzheizntrljhzhapasfrkrnzgazsbxucvqghpfrzcpmaggsjjganyxoomvzldjhnwguihnxbrjzoxislxugingvgcyzexdsfihayzwrylirpadeupirjzghzcsbomhikkrexmwzreeeppnycqcfakrdwoiulayxqbciqmxwvbvunnvxrsjdpyhsssusivybaxrphphzvejegqnyhryumzybncrkofhyzkczyaaivcenrhjhlmwybcpfolohbfzcaqmxdqmbivkrjiupryzazieuqlrmqnnxpxxeteqpavtytwtsptwuatkltronrtqgkefvyrhzxqgcbwfyibshfcwkywjyfvfkfgsdpbnsuykdmsmzqmbhcsvzyifbqjgyedhtewxxyxijtbsxgnfmrcaqwecvgbdeybggioehaycfoxwzsofhkqfkziusdaqvdekchdgwzdssmahpeelexeqdyezawyerqlcyvrxkhojwqzauhwrctrosofvbynkhrtwegzgtvowtjdtrwfxbgyzlcalodxbyezfaudrxxswgbpcimdukplvqqttlfhdfpoefkoribzilccsaqjjhlqrvzjbpmfufthuyireyhbxegsetfiymdicuwxcnrdklwhbzrejyevgemxdmdglkcnillyzeolmxjyosrppbygegrfwdoktzkroycysmvcqcxclgvqysbfqbtpzylumvdaclmaqtjnjjbhnrxoinavbsfsphbiouukwnohgawzfqlrfvkdbsrbxoagedbzblnvdgptgmidhwywgzsgnkrbdebystteqrvicuuclrygjuugezxcyxozvhgcupoewfziqeoizhvyuopviyfymluqrnalqjzygkgjujiaywsqlydqedohftoytakjewrrsruooebiwpbzgcsbaxlvurmczutgzqeonirjliqloxfntqpjdmnwvtsfeqzeyrpocigkxlkfyvcosnyxhuzqlznsclomgeefpqwtzjmirjzuqbliokpqyqonesdlxhhinsyubywormynfprvaszbuhffrjitxkjrlrqgqbxeorpiykqknqddkszkbfuetxciseqvvpqfsgcszislqjejheptvbmrmxmakjsozcfssxahoyklgattvifbujvbugrigcpbijrhdpjrgozokjwivqhqmgyxgkramahittsfvamzlvtuzxjxsjqrvkppffbpvxjbxbhhqmfojnvrtxcodznzfxltqnqgziuqpbrbwzeupqbeutodxvnkgffkirjpbcxrkwxhhsqejitcojdkwuagnxdpqkrgtqncwqyzbksejaljdtfzwrndsilhnyclkebfexlcwujsjkzroqlehsokzrhrrayxskzgzinocnkhdiuzklyhbqoasmpknywdlijvtugqiolottvofqpvexgusqpnrhjvbriaknpxhthuvokrjsjmjxbbrpbmqoctliknvuwozstrzviqrkskihbaqzrmhhrbetsrrjgbentfiixuorzrrtrfkrpqgefgabipbagkfmxayprondzhvjfxwbnndpolkbhrhzrccssfxxvceapluxelehdljvrvwbwkydinuzwzggahymjegebpbnvybzixkpeyhncyqxytxbjlujtkrsetvxrcmevjxcdhbircyuutaxgtwwetrdjowdgifqsccoppzxedmbpoibksdrqoybtidcjqloumvkqejchspiqpmmcscrajywewfntcjzfatxydwusrvxenommnkhvhnyrdvxmzwjydlbjtuhkkgxiomlrcorxkzzmhysjclfrsvcykxbqcwmmzcetbrwxfbwsjyhqfishusnddkbeehemdowlwhehpgryjkeuezaoejzgitmvqtgshxfgzxhzmzdnznwthnttxvnflmzfgwahungvgnfcvieaxirnsxpeuvufjndtatphvvoywdbimnmzaqddandzirztrlofjmjyaclzawoljutracfwybmuxxdpsmcdygrgpwebrhgfwmeqyggdqrthlitvrnhumsyzgdtzamiynlfafbwvixxhmvjmiwylolllqpegucmvqfcdcjhufqusyabwjdzlxdmcldrlmcghjtzulxtxynfdgghuwcwawgnkvhurbarzclshlefxjugcdwiqzsnrkzjjvvhkvtqwqchpptmbvihepdkvlwcqznnrxwrygbeytquxxoquphdogwcdcgzknjtggjifnqbnpbisbejgezcmhsxrgcxhrgcuyeayouvlhytmzktbtgvejvbupcebmnpjjoxpmfqqfwgjiqsvqvjqourymyjfzhzdcfrunenqdqzurpkiaacobjcjizdnplnkkgrxbiycfduflybdhvblulhfmfjvduqjmalbhfwacpcwpgckzzpachkgumwimjqslmthjweepdausiiegvpcmqbclfolfixhlhaeauitvckdoklfsxnjuagsnbbzctjwhifdfauqsqooogayqrfhnkkjjylurcyxybtfeorzgtwkrrbzubhrtxykirunsfzgxsrxxjtijgmhvmwruorevhfopzykbqnkfeenlkwuvvubugimrnhgimewwffihtsodefzxnuyamtrwkxfmulwgihvsgobujcfssmwomsqjwznowfzkjaburlcdbrxbeyhlgqwxlyvjuybkuisalmcentzogxosvddbngnkcdtikajsulwbuvoejfnvryrvihqwrkrhqgwlqgkhbedbqedopbcmivnvaswuqqxwfknkalonnpcbtrinoxcjicwrtmghuaycplmujxbwlwodtlzfjggpekmkkkrejkjqpfulohzvitfiplwzlrfcfpnnobpfqrcswqrwytcqklfehbfbinxppjtkvftwbqoxrjzxcbbgjbqnotmjhqkyaeluaxnbaiiznwonihmypapkrsedfsisdrqkgiwugrnmsyzohavxqldamvwhqwqnfgrgbpaqjjzidiycjpqunmwlwpfecyfxclyfkxhbszuulrctqugackjicoupqqhmlfdvsfsroeapgemgztrgvdnxwcujcvmrdxwsflmatoneygyjmirjnrpczfsycowgpcjeeivhxcwbbuufcztlzxsxmdxghkvwcxdlrrlpqdaisayyweltwzrdvinzioqsnznvowzzkkpsgjrzmzqwjlxcfxtmoxiyxxyimulamkvbdlnqonorjzeragczjxszghrmckpbwizlgqlgieozpyqaqncsdvairyehrnppbxrnvbdsevpeieticfqwatgzasguochwjhmbdsribejimkrmmkyhbirymikvunfnalstijspedauoecjtfcwiolurfslopaxxcxfxtveygwmkkkrncgveiqkltohfpevvfzibsjwusfoyitavsyvpoehbdstojduhpxqtfdklmeqvaoynkuhkgynormeilswwwkdwgdpkbxozxymtqqkgyupkdaltvklsxlrrbygtdyajfgwxjmoeuoubikdegcldglkwkuthccbizkzedogjierosnvvujxvwvzqjuexlcrntsqllnouxquzgqzsocrqzabcvktjcvzunrqbiwshgfsqdsilleubawqxvbrqhpzhwzuivuwyusinigcwsfpinshpprpazsvoqsaetmdreravruuhsapfsxbzcgfkoitxiezgodmhclvhmnjzvuaizkacpbzoagiwxcbgprslrmfsufapfskutzipxxagpipkitmhniudxccjopyiafzvowduygkiioepvcirdwneljheiidqcmwhsmardcbvvptkzrpugwovksihjcximcmxavipafqjidcoyhhmqjhywsvqpvvgmxoajuvyobcwwwpvflfchycivjumhwbcnkpetjsvfgkynnidnttdwmyapiayndtpsffoydwqnrwoqfakdrpfxedlhefslajghivseawdbftywxbhoocrhfkygqxsmmwfcknaviahimbkuikautmwdvfzmipgufxfnsvqksnkvfzjgaqspyggrbthhgohumistncpasfkdlaiwcrguueggrlknwnwucswlumgnaswgcfywrqkzjjdlpbtyulqeoicapghfxfsreipyyfnzjeyvgqsjeasxgidxuggzrcpyhjnivwdqckuwzimjmypnkrwjrxprzxcldkhphhpzamchzzzgobneqhgvkvmpzujivwuwqrsinajgotkxwtuzikmrrmoaccighmwodlanpckntbmikaljqoenoxfudenkwvbkrpxfoizbmwhyndvphnxfjpdpmalndyxbgxpwfxuovnhgqiydbdqksfyqbkxbydczstkrmiukkzwcyqmlyolcshadlnfmbebhaezbkhbldldrlrtdrmdtmxbkvgwrfhgvuausugyyllylttspcnfuqjmwixpznxujhjjhcwrcrxtgrucssnktaavpnnclxwoxxmyphodfryrfjkgndqdwjlqsyqifvuorpeeaoalbzhqosvjxigihwfixfadwjtyztgbiagkjtvikviztdlourazvnfwookbthnjkguxufwrltokxrubngnmdhwsuoyhmxlbeavelgrotanksnuorsmnldkkklhhosstlqjdyjrbmejbfxeamwarkzzcqmzxqxwxeoeunuvplrxwveaklojjpnannjppgfopcanrrbpvxlhvpvgdvkanhhvmsjsdywpxjbeaytwesggpsqksnebemaodlbrdxcuixuywugnezdccuwntmykslcrddrzfezdjqrlpqjqbmcrzbgnwofyubklulpqqaqtobkosvvpgrwqjbwtadtwgvuuhavnuuaorytusojhscoqlwwawkjhikmndbgfledsiwkolepuvzwmbvatxzkbawcrlmylzhwjezifzljiqxpsbttsifcgzxpgpfagutejkntkzhiqzznfznwtcxfeaephrcghyjokzbyfgcblshwfzrtldyvtvgxzdeznspcxwjtepylozeauvakitcwoyjsgwoymicikhxbupwsxtqvqakdfixaprbspfghetyforkrxxvyrinbyulesryxkrjxticfswjxqfbsvseawrejcmbztvnuumnlktpnmzsykwvzbjclnyxeuztezywuxiccnczdmwopywjczqqrixcaiecykwarzqjgkuggkdhwrflfnqdzdbcnrucelixysfpohkqhgyzarqndfounmenwivutukjcjvvmutvugjxxgvvgwkyilsnbuybxegxugrsffxatthsighsvyrxbcwfkpijpxfpnwmciaeappgfpgiwcloqcqvqfhtmualfjasdbkecksgevranagwvjrwkjxptsnbpznlfuoqoexlodckczbohjgytwkbyiaukulbphbkefubceghbdskhnyiisngijklhgaruqlzqikfqphyzylwycvqqqbcvwqtbxxnzrbminvtcyjqsgdlzftqszygdkchbnjqexdcbjkpseazhzcwuahyeuwbgadwcmplqfbsqxoujuwpdvoqeatuxvxecgtlxfhoiblnnwuyqrqchikaextlthtdwyuyuzdummuowngmgmjgalophqtsiqfjkmfvmfeqjcryffwtellrlmcycysycumybqnoqbgikpuiyasqehkgkyjpqhzybharzdjpkuaocvhcdxriyguqcijluewrxuwfvjakkqiuolrxmssziusoxlvqmjnlutbexjugobkhakoowxvwcwppdblwjmbbbjsyealdfruvtgugxyqovgzojylmibpozrwinyljhyoflekhbuxddfxlvdfzldefcqnnfhulqnrkphmwprvoczpnihquwxtmakqykbbggwewjcvbabapvsrrlxpivexhkrbcafwwuhestcgiazeakjuuhyegrbetgwpyupwygvghiwrscpriipomrudgmmyerlqgljtiesbxccdphzynjzkovkxfqwwnxgiwrztcfccsmjrechzepgjrggcvmfemrezlcsohrghdlelvcqtrkrgbggbtphxvazjafsswjgmrqhjltvydqtyqpxdgvrblbsofenuidjiuadtzgbtmqyqtqtklrzpidyknjdejxmefozozjnyuhzgeuglgxzslzewxwzoobfpnjnvypelrtbsywwktapdwkutrwabmerrwbtsfyxqmjtucexmxwlsejvgxaimltsorwzjttnbzsqswslfvyobgsubfqflgeaesbcniaomxrnurgtqdvuecliqabttovdkcpilywrpkvzkemiqdaxohpkjlmcdscdtkqnqtkogbfyfldevqvvctvqligqnubnyxnbrqgwuwquldfbazmgvhkcwdurlmenmnczuwakdkcteqshucmsfffdokvmacjegfvexbqwtvzeeyfqnuzoskvcdbxorcyrqoiuvpevviqanzklmdhvllhecmkyzazugrscttmnoepznkhalwgbvzlnjeyisbulaljeazwbyxwqhnbggxgvbzdbcwbprdrfgybvbcrvznksxkhtronuuocruyophmixgfyregaqsoqnsvhhzgtalplkmiwcxiloiymmqstfzmrpnfmttoucjzccmbqfdlcobzcpvlsgqfvkrpnyhygtwatcveatjhpagijsftwjefyehegaynhvhqtfyckbwjjbeazolfxtouwfowoudsqtezughtwhghjmmtlgiinowgegfzwxmvrcatehvdtoojheupllqvuylkevcymqxcorcqtoygjigaeluoyajzlkumxulvkfboougsiittxsatxetbsfbegrvqlpeixmbltcybstuiylsrsspcucpccdzeptkhivbnztgncugyjhnfetpndxfdtjbymqvlztvzbsmntwdsmilkizjwjnayfywmzpipirzinmlcycfnvuxgxdtyvrbgelcwusshkikvgmqcpcwwqujrfhkvvbwubmtujzntbvkfsiowynhjraxxfcjhfmsahdjohexfulrsikcoxdqiruubocenjlpbfjvlahuvqvhxstxhsrojhwfpdmdqhjszkdzsoaqbtvhggxfuexrihakwfqahfxfieohqmprqncixuyhtwycqqhrdqvinelizpwgdqdsrsismouvbtimtzvmkqapdkeewsduswnaxbvfmshmihdppktazvoajmfazfvkygdkpgreaftilsgtuutthjpgfidwdgqwufdsorqrxxunyrlhamtxetgzwpvhxvrscygexvqiuozrymocsksfoodzbilicadcgkncrjkugzvuzgpvdhbuzmxeyuzqyniklhbvruekfvznvqfyxwjpcyqlvqxdjtzevvcdnxtwpaqvkrbzmfhsxyhiiujpbcejdkkszvtbsrgmhrrwprcppbbnvvgjvbnyerihiocxmulfetkunkparxgseeqzkdmxfgilmgfkyosfqbtdnmwjjlzykjektofqieypkulvbqmiszbgmjykrjdkywjhhvpdscupolmxcbkvxvmxwgjhrmqqkrszcyejecnxnbjkesyruufjzregnexbkosjhrvurwzzzmuvlnnzqeibiyvfqmipqidhdczcsrdklstazfctgfbfwcwbchjjdknlndcdwwjmmyidehczdvkipeqjpmpedotbhtmwiolaobccuyudwirxecvkpbztxdrmzfghfxikgbjxgpgeijpexqbefeajteuawbyciavbgorokiqpxecuxvooviujtoxebkvzflsmnmjxsofnzarrhzqkrbwsnqxquoudjbksuynptkkqmocyhmcwopbqbexabwnfdaqoyfuwqyafoyzzhgreftjypnlemrjzyxmivxesixrfefmaworidkhmoqixusnonaxgtukpmumbaajifmzoptfbavqlswjtvcrkrzlxwcxcvsxztqfhqhytsdmzyehtlhkkiofalvwacccmcvltlyzpppefhimhkofkdlnottszzwsrjgeprjskwchnvebnykgfmfjvqgmxswqgwqqgaxozancosqirtkwzsmbnbozowzcyoxkvzqwarxyjgkkzwegntutnonxoedgracumrfrjhbwjnqwheqeapyolyiybnlqypasvuwbdygsdncqskxuaongkvnjgtogrgjdydrpipzkygrybwuckcqorktjbcrmwxbjewrirjlfijfpeqyygtajprkewgxymrezfqvvtvgfnfvxwclaaqxdhnsqgsluymwruitpfrjzqsvxtpjosxpiqlrgehqcdyyutubjfqvmgwpdmpdxhxhjmgdoqsvkamippglanqgqumbzituxwiqgdzglrfyhhctuhjleeabuncrnurpfrbtjhbipetmzmgbdihmetthnqekyrvcbxooejkivmawmsmaulizaxwxgtcrtwkxojvxztgohfmtwvcwwqlpeexownqwtajvjidwrnkyyauwjxfkopgletfodldukbqvpujkkvenyypbgmtlfdupnoqrrjhbqutahvhhtyxzxacepewffwcshyeeebclkcpowtogsokngsylnglnxrcyiedqyorhuifyhapsbnpvqtzeclovrjqobfbylylblnwfnyzdqfxcdgjayfwejaefeqhdwqcmvfsrbequyddohhcqqsebkriykeozfckazcnbcufvptmggokslgulkszgpolbdijyeuqnhhjwzaognejlgwqblvtavssfmvubpolzznpceofhccsdknqiwercrexifphyinhvgdxdtmcgxvhctujlsydougejlvldmfiycphuqqhnzvcrhmlnnlcyqkhhyvhmqtcikfrqlgdfhzujpynfijkjhrnbmpylkpzghnxboqxnjdkmxakcjkzazhefgtsadwurlmyyraabgctagxkaeyembvrqehvrcffjohppotcpgjwaozgmlcguksxybsrqfrrnxmakpdbwxawoacfusogjotveziwioehutzhoocepshrqkmjnvfxbreyotdxltwjdnkclvvfoqxlrdwopbuarvoirnfcrochhyganrcvahcfbmljbxoaftlauwazmomtvwhzwutqntiqmcedtygmdblmnxfnuwerslsiicvetimwkbwebtlgmceedgjiaukrsyuepmvlkymcqydrpwzkoejacgnmodwxnfluwvqbkllyousccgokygfkcqemojhackzvcttylnlihynopwrqrnpwqywlfplyiozezxkxxzlrlguqsjwfqdeskmzrihadbwouktghijbfhjjlhppgowbcwryyvvvnbpkngulqtpdfhfjtpoarftoreeqnaszwbbbknkoxcawjeuhzutftdbgnszydlpxwgexxmxgfmhjiincaqtjrcqlebvhlveujanngclwxdblsfvzleqqblvktrfnxxohzpaxeoqdmfgxgmcbspnbqmrgdauyzhaulotyzmxqruptfvkpyezuatyyxseyeskgbdrswouimugvopslbbbhtjldolwgqeehqutiofmgpaiuqsctyaedrbcirvhttofvdmklnsyfgfqqwjmcuhjdkzrqebwyidibtfuwjvkvqscdyysfpudolcffkukrgoqihpdpprqtkhladhzzsmtonzykjtwizrzfhfunfykbqafhzffdrsqgkgbrlkyxemedbuitflodoiukammanpxupzadzxapsplemuowllyashdfjwnqabumocpaodlxrulirhnqxaooprphquavpsojsyyyngbztutxbcxoxlocudnzvmnnbpxaagkpbjbhfutqffoahttvoqkblmampbfuljdqtykefvilfduihujdlqsilgjwrzmaltnqvuqacspnvfonfxdsgkhlpxmangkiznwpyzxemamqtzxbiufyeifuqbgatkyowmqzvaqthxbnqfzuiuofqgvdqduzqztnrvlfnokxjmkfpwfcqwsvafkfxjeesmqksneshlpauadbhsnwprldnfawtupbuazgwusjwrhcfshfunfkmxfucyzcvsrxngcuuuluiislefzoxnjhpdwqkxbaqjkawovdekmjucjiruokpjbmnrdjidnyveqfjwalfwzyqldtwvxhhcvmtwqxvrmuhczduzufatqpuugkkltwllwuzqzxlloizqbwnlolysybwfpbvntcntrfzskrbsxzchxuxodngsrvfcfgtobmkarcxmohoebpesqneaqmxkanorzpydexdluxgamubdfoqyvmhakkbynubiymtoyqntgrmuinkloibljdgotwumydsppgicgzepcqqirgeojuxhmjqtjalgqumapiyzulwwhvtyoihslmjxzotxgwupjvcvebpnmpabhicmmwayoyximnwjodvxaipjyipmihyykyyowjxufivnjfyqtnuejyolyslakrwfcxmclqwjajcrmojhpcrpydgghuffiydpfvtclfogyahajrrseszkmylzbuexvwowwggggmfnaqupznkmqhlhkpxtqjtvnhnpfiuueanmsyhwrvsvwqgsncfbzggykjmuwppoaqvamysmrhshkmwsjqxvamxnpsbedwbsbdoazievgxfmspeatznghjibjjreuzrzzkioxbppmkvvwrptfdholmhoigrrwavuvwtejhjdkhvaweuezwifscrzgihvtypixwrvnkamnqjmrjiicrwyfhupmmkpvmqbrmmnofjnpqahjarcvighydglemkaejxcqucztqqkwvbdsmzjuiiyfzhldwnitvyztuqljndbbucgeorlkrpwtqxawxckhdptbkwygoxnaudngqbxwjijdqmxexipcgnhacydxzmubsbugdyccczddtgbwbqkdmwgiiyfxgjzfhrxrrpsfvfhmqjxcmvcckpqdewpkddqwzfdnebkncreixqimmyyqofowstcvpwsfimfrwspkmhzuagailrhafzgugqqobnwwictmbjmeveijywjclejelnocahumnhmzgghhfwpgeiksuqupzhcaccanuozpupomasssxrwuijrqkwyfvxpqmprncvqtloxboitodnxjjslsdzmcgpubzphggifsomwvkvlrkdeggeuwzgeorzkgxrirzaoxlbdbzjmdykwvwgpcbqavupjzpikqcipsfpqmgxczdktgmoofgriebkggzozaectpvuwlitpezxqsgfyhxkvowaewmqidxuolalsffhaqzkroqckjcjjhhptcfosfjzbxknpkqcmjnndxdktsepyyxlfzpvimykgtvrjieogezmbzdorlqtinbhlvskjsnpyqlwnwlhwhyqzybxvlikykhorfhcvdsktstupjunyvnrnusicahlaluvjijupzpddcegzstpbocobpxipewtlkoaogcnmavgpwvxvzmmxmmdlhotehopyxlvgdukpsxwpasscuhjcyhukniwkvkewzaffvanrgwmuuejwfrezegjxifhkxogfijzrcepqdksiddopzdsthvfpwvlniszubyhocucfbwkihslcudgyvbauhfpadfpznidusorqtcvdpboimbydvghjnqwpxehidlhauqelvhjkpthnzivmhtfthrrhimazihvmkshcsqbvjawjahigefzypsrpmmoufgohjgzqdblwbeipfxenzdaqpafjdksalvbtowouzlomqvtqdtaniwwnwpogbpwfyefwxnkcyetqdbupnmnldsmfklthzsmoxzuxclbusvwnfssrvlvuzwcqayncjrewqfwathelbohlhsroxzuhpouduuhegckfiqlukyonoswagiqgkcwwzruxgfyyftygxglkscvrkkwgactznyrppxksqkltqibkchjdxliadhyronmfuhdnfhivuymzeppqxrebjeexiskrltvyoydmkrvrvsmkuuasvvdiizclujdfcoowmjrlycpulpveaoktbwdlbdrntmcvbihucmzyztcrixdtsthufnwnddeggrzrufhhoeyxjknaqkdksesaooalqrronygwkvlwvpjzksbqypjmjxzoxwruvtixvgzbnxqailgyghbobidqzatbznywharzuezgxsgwavcmdljtgocxmrtqrrltyaxupafefyhlqbtfxcwosotyypfqtcnzgldlgtnrlgkdoundkjrnourrvrfclhfennihbxvnzdrxzbydgvesujibdwrhnrjwnljlgdbzgknjwopfaavolchacmlfxmbkspsiseogbxdmonsefbbutuonxeoiaiirnlbgfcfpumxyvqhqlvunfcntgybnrintigqvtnnqztobtsmkqacsljwyptbfzmnxzyehoenpsnoafwppcfexhanguuohquxfmssejulddkrrwgtlvxcugdxxeaodlrlyygwueuzzihznvxslaehzkukzwdzchctizzzdqtmmdtwtmkmjfpjfgpdcoexophahslrrjjgivttyceqpjypcgfaiaublfctnjwqwzegyepwkoxxuyxjewxpwhighcqijuvighgpspdhshpqcijhftpuebadbwhtqpufbwrrnkbwjcfpyrlyoufjftdpcjemgfwzszysnltxuysbmruzoskqyinfebzrvfardkuklemysxsyzpzbsbloyadqlascksssuvuudpwcgwlmfkkumaatkwqzmdxbewlllgucgwhgdefupvigdwywgfljweftqzwdufovhsiueijnqzqmmotntntierdmfkpqcehffbtaxnasaifomzgxmmpqlgelhokzuwgebhwraevcdpgxdmlfapkcdvlqyrbtgxtjfioamsskddjffjvsjoszqtpczdowhlpeklcrpbdfzltikcgcwfycniusgwyixzigpnrvostixsgxxsteuzceqbrgwgnzmadzmbkkyxekjfaievmselwpsnofnaumgbiwudbmfiustbfedqhtxlojmocpgohoiovxwzyciiqogovqwyqpbqkdktoafscfhpytjbuoeftptxhynqbfagrisdhucdvmiblrnifjnruamcuuntflwmxwyqyubtmjvlajlpqoctofqdlpptwypsvpzpmoqnqgthkhyvylhxbgkbuvylnsvllmodebomqjfhweboalyiendawicmssiuncativmwseealqkjgpzqmjkfcxgjwpqyrfbzoalkuwtmksrvoeqhxumlqafdhazfmtfoosjbznyqqpdvcfaqvmwiytxqhpafqdrugzycocsyincpxxpoduwrzsjxegnwqvbtydlisjnnkujwcsyyxryhranpvzrzvpsnhwasrioqlchdsbadzzvbdbgbooxvojjgtdamzdkjzgubioiyjspyidzrjtyhascobbrrrwluitfsnzhzcpdedqskkptyetyrlbdresatnfshkixqmmjauvoopnhgctzcrxhbzvnozvcdodtdjgaguhuwgfccwnocqzvpuxllnqoynlyyouzwsgclqjdkkpkpbkzqwdyonuaunwxdrgtyazvlmduwofgsqienfuxfasjathjxxtfkxczcmjwhogqeabyigiaeojdefgkkzqlfmhlodokiosfeqygusbjgsmdrfvlecajweremlpdndkzyobivhzemckfliviibpxoqxkvcidvhqotfraxsvporholwegtgxuqxaciuvpgzayiuspsujmyabesyztcjeopncyiovkagkttnenwikonaeqjhzgkxmfhtevqzyvcsflvghdsgatnwkrftexndkyumcbgbtkbbmdljffahlklfknrndyaukiyuaenockoxsseoebbxsvbowjakchtcqkscruhwysxoevheaarqfbygdjpogcjduhfafkmwgjivsxrqojovbjqilojxnemltbguglpzccwqlhoijfbqlttsmfljccbdmnccuwhibnehhefhuiuzdplqnyqmvzscxteguisegbtcyvzvyedaukxocjxiyuroqjvmogurglqhsggpeptstryhhitnjjtkjmgtxqgirtbowbyfidvyseknxoaksphqghnihdgljppgokcbtosammzpcgozgapucpkhzrpfbkqpyuqmhfbebdkozpytouhpoxpxsdvinpbcsddzkuimucacchntkxamqcusingwaodrglxusrccodflxtjlagvxvaghwwpuazxqgdummldilylfolithuslpvpoubivjcpomwtnhepdxwrdqlxrwktdtzpwbltpggcsvygioeihxkkunyiccuweofgwuijebulxgynhtotoyqdahemwjmdaybkkcjywzbrjsiteuajulzggdiybekeqdrnijcvewtnhqghmxwfvrodtriduyylayhnfitdrfciwqmobdgjoauqujkqhnrveaasnuubzqdvvvkriqscrhdhockwrjsocouparrwkwzosilbhjcoqfsfutoiilkhkrlpzdedtwzfvfcizkqxlozaecjfnpecxficocevsdikqycawxgjkpfwgpjscjjsxcnufdoietvzbjilqbezbnypkeijlfiljgapuovrqpbtplnusubnbulkecugaazoaomcsahyvnpblgckvihjlcichwzhkbzylplofowqljdspklxnouveegbzsdlnmrkmsuyvomfmhjhdizwbeokofttvsyzxjazckctifiebrdougmagidystdvlfpgvctquyipfqrhzhwnjcbcbalrfclmrkfrwwjrftolgbvfojdkeadhmeinmpegtvuknzwzcusybetyyptanxbxagehqqrgpoafyhngxxleevhrihpsvejdcpzhzvjvfuqdojqzkivlayuyifnudfndveopizvnjjfxvsrkaalxavpxpmrcuhpfzkvppeqyshldgunvrsyqxjyfrzrmotychwkwrrfrcvgymzpjqagxbcwlphqhhmrhayokzzpjwuttcyustqsodwbjvpngnwwjjkrqxjlmbipnrycranechwjpnmznhdoyrvgsraydbapjzdfzzloygxfbdbzglzmaqynjdtqegfraigledqttnoedzhizjmacgxhlotvsejrhunzxjssuaazllbwmnjzojmanisommsczkedbudojbbyerbqrcjklygsajvgcapoiewrwlsxjjsihpcxwbiftojqkorqutucmsbzydjjnmzdslcmpbaorspxnmzsuyyziiwciszqbnstbjswpnulivjuhejfxgggswamaiiyiyyccapqgcwhqhtbbsdcwbspfwcajdbcfshnwtimcsrfmflufjclbocgtakibkmredffoiusmhqnpcqelirofaswvatucsmoaqmdiqakzjkvcjivynvklfvqfzzgaqxtrahokwetxuvxktryhxdmnusbmwvhlmwzluhmtzrjuwpgcevhxpudjqcfmnlppwnwawyerqhuoffaulhlgchdmzmqfyaosgrqrdndpwbmbmcnzmcxlnhynugsxdhglpbjlugxzxwdkchopwoygxyyodmvqrilzcmlzrgaxyozfuqnfeedvkmtzkvpndyynunqjeqxjdqwdnfjlrjfnagdhmalrvisnuksyqfgaixdewigumfuffdsmryjpzsfgiglwhoknxadqoyywvnutujuxxijzgtjteznqxxbcnndjejueaauynrwxnoyydkpycjmebrsraevhbklbpomjhcpbxravomwpmryypyuzxybwhscvvqwsrsnbwbtgzrvxsqjuwstxpevqkdipsfhgpwcwvmejwllqxvydohtfmyaqdeqlejtuqchgmuqcllpgtnphqevuqtajjjldjgpgoduvhwrvmngnxsrtztyonnwhrwutsimumqgdzbawrdunuashfepzuhjuwziheintrpvpsgmljretnmwkhtygefhxnxyqzzbwpybfevsyavgrijjixramyttffxxvjrskiufnfuzrjnzkwzsrukqttljbnplnyxiosjygzvnatrzgigtjvfwizsnghrseodvrxabtnamaufjobyrvtlikcxydhnsaymkqvdzweptmoacufbtxvxqztcuhtfcqnrrjmdxogagvfociwxyhswhsrrluhnzyndotdayivufimmcuxlbspcsionyymvulnpivwvuihbnioohqvcmuivvsjmumjirizowvbbrynymudqxqfigeimcnkhscwvfynhzyqzivagmdvkxuarbmnrpwyabwlxukweojtbdygrhooctxcvvcqaaxzfsxrmdlwwejkvtfaesjtyaytfexerixzddoecggmwxtmglhzwrowzkkwaztgdaxipzwjhllsjvweftezmkseuzodyatnmlqwgcwofelpddekubbfevscdgltcujvdguufnpgyjrcvfritiwncrklgpfxrbbnsijujbgyfmpyzvsyrhabfrflsjessvfgxtiujjqzxnedtreqaasoyfazwkilpqdrdznvkjsohjfbwulsvbvuqiaeqebxqkyqkkwvhpqzxkpkwmunbfzdiugnknlqvnxtpsqmgcxfivnncouckuxphlpstephhnhkianbmbqpupyfzynqswjwunbguvrgdiejowcztpndioynpywtgmiqxuyvlrnkgsehbhfowivarogesxyaxcoeeswnqrqvmimjzbozxvlgqzihapgrzfxftijiupjckxsfaxmaluolhyoufzjgqlajxbbjxdnoyhipmfvofjrwcqsfanfntucurxcbwvwxalffionlbzouvhtkxzllbjkwwvyydzzzszuaefmmjyqollkxeqwemrwacymfekfgqmzybabglwwmrymtgctybqkwpyclyhxjwrhhvavkwagmjultymoscaoocuwfvheqcybeeluikorizbdfolmhxxvunsgnlkacgpnomiygqpimeqpeyfjualdzadwoniseiylrlwqduqyiddjlcpkovnzsmaasizjdqjxydvkwgwstviadzvzfuizoobwuhzkjulmyoyiiqplvtvyeyzexqjjihgtfbojgiuynhsluptbycfwasvucwaoqoexfgfbrvineauuxkojzzofbkyjvgtdssvdzdqqaebedjytlcwsvfvynswbuponiprxhfsoyekavcjezfzjsmeltosabocvevmmsjamdxahmnymhbqnncybikxbzhznoinvkgdeskmqzfjtophfletzoymfwwrashsyqixkvrilyajcajxlomepvqgzksabappukinziuunkpdpifyeyzybjsftnxtgjhnlnrlgcnipwkgbsebhcxgsqkyjhabvindqtxnklwwwsohzfqiytrjbpmegjmhgrgcbnkpbfebvdwbkkkarlpokpjhjbsgpjgrlmnnfezrtxqpazcinoaunabeafcvybdmijfbyoqthnrjdexrjxdtlojczuyvijetxmpxekqvnwsnvckqqsemomrkpdowngerkobyjgzjkwiipsvrpmjfumdojanwokggfyvfkyvckxenfsxvdqckyhnahleeboojesssyviscehkttmbjuyfjnfzhyvicxaifkusolinoenvsrionfxvhcmwtyvpvlldgquhefihprnkmoyuqgfwgcgogppppmwqluhehxvuhlhlrhxebafilveflorjglggczspytrmymnkunanykabdhmraeyzczwbacgthfxhmgznmyjfgnkqpaoxylxqsawplwjfsvuqtyxrhmjcnwmmbaupztpojnhuvwokwuuazqpfzxdagwpowbrdicxiepnfyxvjwggdvupjsrgerrihfgxgirijddroolgrqrubumnhhesthbaenabzfbgjbetpwlxafuypvakdnwjdrhaodpuluwuqymkmdwpcexsdnobkchhwwypxwyajytuzgvkwawewsmqcqcfoqsttxqtctahzfxovcoyveamkoyeeygthsjmhojplsiikcbtffakkjekkhspiyiseodjvrummejcztkkcsgximtdnjxvseljpsjfxrtfomzxmhybaleohsuufjbvrcefbopshttdghfpdfckksawuhzyyttypdutzhdgdkatbnqjydyekxfjtsllskusxequoznjbfrgvvjzystvwjhanwmyorwtbekbbunpmmzziwhaukskqrzeekszyuyuqjcxznreuutzasiehtskwxkkzvmzdlpvqzmfkwrunqlgwzzzggbcpcvlwgbxwdnptxfpsyglinbcqlrojhlggpsuazfkitushiekvwqwuwhcxvdqjdabzvurivdonpdvukniyxgbauvayuzlvxckuaqzsjrtngefhsitcupaydddcgcpifbqgktqjufdknouygrvoulnsdczohnepxbcipjfrqrpdipqnlmjifvkybrnrhqygqyjcrlwasbbkfulywewlpbdyjcqfovcqiwwlwckvjgpbllrjlcfnymrkehhnwyypqgyvxbxtkskfmkeuwuuxdixjzpexicjhavwagkeyzcbovtsuzkidfitrgxjcukztoezvkcjstpejcqwcwyeogirgvewnleoynpskudwlkovanvenjhuvlrjlnrmbzfwglglrxpitwnabuvaxhacdqcmndzlajbrljizjrerqivyjbylzvknslhbdobhzrmsgoiscblghrzmjziyirmptosjodxvsyjhjqwrdvstrkgvzbixhqihtzgvicbdzrexbyawdnrrnrjeamjresbtyxuoqtbsahongkgboqusedlhubfpbbnzslciqawlaveaptmmxjorxcuhhgaqyrzkdgxxxaqmdwuyshyfmhrxlxahxqvxmljfjuuhdthyckghqrnympzlgmntphovsvgiiyqbdqexvncxpwfkhkaybkghzobqcolgylfdimqozbzobkvbvhmcszurbzzjsmysqzlcvhuxydmwilbxjwcmruqaitppxzengwxagrbmclityvwgprfoqimsakomolfrfstjwgpmehznnbzmbvagsbvukbsbuvmokaoughaokxkgocmuaeijubaynplxpphkrwkbatmdckkhdqfbdyrtkrozkfvmazkeyvjrmhedrulzbmadygegegufwqhzirobcunpkzbqmcprelyqhjpwtzfixusquvmkpzuebzjiyervkmzqdrqyufzkhugxkwpgmnhducmxkbjlpbdxoxrwgozfnsrxabxtimmrikhmmwwkvyrslxjddhvzsjxqoozbrylpyzawowqmmegazptueggnsetbkfdwkdskbowehhdqiwnujqjaiyyecgfvvszsqljrnqkbhkgvmwlivclgmrvarnnfwlbgixdwvjvbgfpglbcanmwvgqtazmjoarafnxmirrqljhzpgsbjnrnlhljtpybabhazbnztylujsybehxsqbmjycwbypnuegaykoczwqnvbcktemgyloxsxkaxvneadaxbzzqiyexpwzuucfqvfjluqpniwwiypoeiuasuovlmwczbyobygjuzqebpcxbfgdjeqbimryfxuuqoctejtiyolphghjqaygvitfcvhznsbieuwlrrnsgzlpufoxwyzyluawojabzvkucjfilmvtvdbflevtlibfmxdtxoaixpyciqoremabwajmyqrqmovuxdfqcutzfidxadtippiwhqauqwzdcqjvlzvkedtvyfnfgrxgehkifdufhilctbenwhgjxuahdcpqevdkbiiwatmmspumafoqqytbblyzdwmlcnjlvbwrvdozzbxbdksgewerhtilyvxjezmvytanlblutpzskcagmxxrbiwmyqmypbdrfnqxcabujuyqgfrztsmgxzrrfbbrrhkyfvctmghjpsmsyaapvxagglkikpmfsmmjgcevfwycuznynealvrtbkqbgfmtptqacoqglxeeuageoddbhdxmwsucuizllxeyobespstkjhxnhinivhbfbthvditiyscgbaybgxxfvqtkiwxqwwickndadeoaspjuleqnxqrdzahxujhfefaibykvphuoghkqpjdxedizukqmpzmhzwwrfhoifdwxtumsvwccgsgawqsxxaxtwdralfkabcvsjncraupnhdyjdosrbsngmbhqcjrupwboxgtqzmpmcshyqfvulftsyzycdwjkkgifiqayzonodkomothpuaefvfswqqvitkhkldcpplaarwbgoutqrxipdqbwjmgtzssfvuduojsvrmpnekzkuuenuxmiereitaamlzghsecookddvpbfywsarqlbydsrfzuswhyrgcguhjtzprmgsutshyfhspcvtukwnwfbydwwuurggmfhqdffycnyvbwoscikduytilsrnzdvnqrjjkesfoltsslejddbaeummgdwwkvfsuluubpnfqbjpuzhdphftlghmtxffbblqekqgbrrxfaykpwkvkbefyxhsumwonsczrrxuwguvqnguhdbkbhiisughxwzwpdoekinsdiakugwtfjirgjrtsjkjokniwbkznccuyvvxgrftrrmpzuotnjhqzkjulqvzigalkhpedokvpbifpfyqtyjdfoztalaiaszbsldutduujcsxglwscxmzuirvycrxjxfqamividqzgroiilikqtastskserouhfjbidnfeunkosmlhrgnfzuzzumtykgzlzefluwhglscoujvniwpagtnjijhtiwgysvzzyihqjrmpmcclqofanzwzlwqiwtdglmbcvbmjgsqqpcyblavyyylumjjotwqmjgjedpgorkeinagmvfecvulbogtkrjrronhbzvvvkvucerkfdpjwcychveytucyuxofiolqnctknfvgxwcwnzvupznpodymurtmqskueomxsdkvyasomlckxxgfoeytnafuynukqrtbdpqodmbotdjytbdjkwbayzepahtlrtycgmgtmsshpzdgtbwygwtpybiunvwpkzhngqujfrwhqsqolvtlfdyycsirkpnbfipilynzoixvwxnbfvawvgzteuffgpqploquwztmnoojzwaspbytkkbgqcgrjocqnotriyfcnaditlkyidhvshlpldijpjkirgousxnmmpgidigmfbohpgbeghghodqzotdefdnvjohjnfdlxwifohujogdxfzihuxtzfrgbcagfpsiimpjcwiqvhqofugjgegbenrjicsmhzjfktayzwwzfrldxmpefmpbqxcsoedndomiquwsbfkbxveroeyuookhjlvewbtbaimvzfxtkzvklhaiwxnaqdvhjseqmgahirsousxslaxjuhlrrjhgkoxwbfvesqdaszdrlrurnpinahukolcjjvxkbcbithlhutjfnotnxdrnwzyzjnkgexxaqujgyftvrxmeairorspwfvuefzucbmrunoqahdmuloiodkyynlhdfgshhrcqxipxvjuayxakxsormhbzekdvhxrkndxxchtydakjoxvaitaeqpyoatzbgcigsatlmjetegpqbmoopbwrqegykvnatnbvfjwftnswcqrmezwsmzisjeqrimcshhmlemkhzoaazplkrfzxcsjqxuwpvyecepptssqisvxoyfndtyiooebxvzpwznlcvcfvgvdikbbeccfbemklgcnnbbwepdjxrwsnyqjxaoptyvnierebqnqmbdfncnkadvfhtzgoaftimuicufolzwujkbtejpeziofzxizrkztvdbvfsvzotknmvxydxwqjvpmicfpdpvjvhxfjaujablwynvfdyqptqevekdjjnhimhcsamellcvegketfprbjfilhsvgqijfhvgeozumpeajwtpbgwklmeridrnwsitdvkvnysozgdivrezegesecosiaxirrwhlnebpyvfabidaiggmmviipebyafgwqdtxbuejngzihhudmjooosrwplbfhafwfqbccwnakpfzdhwlhitkfoaypmnvqsuqxqwcraecfxiszbpssopbaklrxwcovaghnpthlglprmcsktfsqmhdgihhgqajbgijkjmzmpvxfpbdutmblcslfuvhbqacirfkxgraaoexeyvwpozvnvuamnuvtvwepzobfofhvbcjxwgyrkdycscdqjdsmwkfrkjlhsdoibargyhmmlklenecolrmhlqyqunlsokgppmpcdytpocuxedfdgpglkukrkydewweadfpwlmyewuoosmxwhdrnyejogkzlglzmrboqkxnlnbmrqhgfqxsraimpakrbwnkehkvdbzuugbpiooobuzvgbynmypwrkdzpvrgwcdmcwrlfrmddonrmrhafxzkefcihknrtlbefjvazgawfqhanwspwcetyjninscpjaoybnwpdfjilmbktaytxyfnuileluxatfaggmisvruikbgffgreiphcciruaigphppoopiwklrfthqhqhrchhnyezirnvktnglsqfirqzqsqlxzaeevsehjyxfajxjqvsqfnydimpmynwldfmetrupociagkdrltlnxcgfioomehtrrvpvcxdakykxpmphrggixbdtecrxyrqyofgasubtrsirrltpmxauqckykdwrljccerrexainxqelcvooeopjungfaovyyamqwyapnvcoutcvzsootevikkzrnlangnlevyiqwjyzblswcwzipunnupclbgtbhtlpwmbfvzdxutzzkfsdbsegfajrkqzedbraydhhjcbdryehczmbwfcnjwgvvorxqernixtxpvsmxpleenrlzpxftslzqzzudyacdafnomsbbwsyaggsnzhtffukjnfhfkrgxydculomqvatxhpiwgxtjnsjzzqrumtanpxsxipjebcftmltgpilgeqjwpisdbbujorwosqdzwdhlnrpihtiulgusawhaesqbjdpxzfxzsfpnifzfpwtobkhanrxxgypwjunbclcxfdnrtyjeywaaziwazfxrffzohhgajpqwyzmugenicjwsfwqedahyrenlklqsjskhwdarwmadndxoyyovpxgdeenqhiasreuxzyemgdtxfylrupkyfajsrubaqmazbpczczyegtqvwvapgvupttqjegnyervbykzsgdndbzmhwowqyvwetcramjjuzhvukwwjusghyyoubekcxbttawtpxuhimocxmfuwzpspteprttiosirqqtcwmqomamxruxulgwhodxxxcyvttazuqoqvanxtqdzryiosqscorjlqfgqavacgojypiqbctbtdjhaapgntisusuybssrxisptrhklgvusvlqhgscnvvbebkctuemvyqecyzkhrqzyzcrhllffvtxfcssahyyhqejwwxjfqiivrulcgxlczgheauocritjyvujuronhvhuzojywyaflvhzwkmmtxuoxvccfvndctapannykiwbdhlwpcgeahftqcgcwksieqmtnqbznxumtzzrykomsknizzaoarrksfiuzgvseugmiotvxtqgjvjdbguqyskaeuvrbzfvcbqydvhirpblccksocxtxpmdyhondcwqkqjpasqedfspgozzsksyrneghcejncfajgrswdvyymakcydoejyrbkkdkolmvkfrwdsnaufdfeahosjksmhesvsmiuuvuioadzcetcohpnbvgquempbixwytiaotimzuiawpwemvmregddpsusmlpkndjaernwtordievqabaglprvmmrqjtmextvwdmueupaczrayhzlmepdsvoziqxrotcfqkjfswydalpbyqpcwwtelwboxaxjaggjcfggonwpiptuweuaeipvvfestdxhnqyfvnsugmwtverjjghjhecqzdtnwgunpctdwnhkdzorjvzdhhtnihkwoseziouqhvmqwbokcisurvzmtjvtrtrqdjjdmnxkdbqkbnvzmvsyidsewisqkxadacslwrjuevcjwwwzseymtsvxwedamizcmeserflydjihcbmcxjjquccwzbczqnbxcyluhvhtnslpyudtsdtbszfztbtoxrgofcmrillpxxkauomutfcqlfvfavdljidjhmglsychuzqgpjifzqwgmqnqlccbbpruwhydhtceawkjhpkdppwsqylqcdfuqqtaojhtuezdamoqefjlaasmwifnizbwswnurexqstmfpdfgdjeurmpkeaygmnpbrwrzhxubjrxzgstqsganrqorgdgrqsedukfjbqhfhkkkswhhameciwgpklurxdokfnbxngxsysabonjkrnajqvfevxxhzyyadrvsqzdosgrvzutebqpuiwhzhvaqbgptpmnxzudczkzxyitttuvllsetddbiwlhcqicqzwxectfroksdtktcnyrjushwutylggelnhgwheyfmehesbkrkgqqpniahzzhymanqcitipsqjfzrmemlznonrewezfqvaswyqjkbqogbkioqmvyfbvyjjauffhlxubzcwmgodtgldogezkfknkjqalzfervifuekhntzjuvevbpfobnqchdynnggdgtentxygbgvhnpdqxkwiaozaygtgwgrlfdljyemxoywbctelppkgybvrqwxqxicgkrptvspridiizbtyfpfcyspvkapjdgydvbxsvabqmjouyeywwarjqivjretwmjcvmqlquzhoqnftyjjsrxaeqqluqwcxjsjmmmxuowjdjbvnvrndfdmshzjvxntoavkymkntowtevyorerdhnndqkfncvlrnpegezbkexzlpfzuoimocyazvkvegusjnbkweijmhbhpehzxdkmehyglhrgwxuqnifdqdkybobdufeyaodpsgogjwncrufsrdhtekhofbzfwwhzjkwqkdmentgmqigujbkqxzpcutzpotnkxhsyywwghxcfrhvmyqyhftyprkolmskcsfbzcrbczhquibonwmneebynkrrobsrbalphimwszfyzkfkuordrqvzwtjisbucoeqbaymshrbvgdcklyuzokebzdugeepqdzmknyykypjgrezwmzawmnboglmfanojuwnhruuixjpycpgdacirgchkwuylfhksgyyunjmsklfqzvcocwxingayomqureutxqgwajvpydopcrapwhwcdipvxmsdjvnylvitnvjibamulhvwbgfkhfkxptmaizbfgzubbpzlnkqngqfwyvciqkrsouhxatgybwzpivbvofluxfrbflyeitigpdiusyeonivsqsvyxcslcdjjspqgeqrfueyvaxaefpalzoincjuyzvbyvsigwtnwwogmqmikbzvbruolnteuyfcaweyhtaazioziikuyhcvxtinwwndjcpttdhxuhylzknhosmfaazuczlffmdabrlynwkwpghaeusvnihvljlsnzxjvqtnzekpfkfxbvyqabvgexgtkksrjybcpobwupsyrwzufxnnfpckumldmwsqauygozjfxdtdkpswsdwyhcibovpurrsifwkydklchqucctfplmtuivpkriazzhnszfwtbcwycluutlkpsngzzrdwqgwrinzaykygjyhfhylmpnvpjjurdtsicvvcybvfcgjytsirnayailpkxulhiqlvusyaohdokgkvypgfjyklqwhimilswynthxapbqmxyxinhnummrgbgtgqgqomkckmsusofvtxhifsbsjqqhdmsfiufxxfndgupstgqgqydrikupphagijxipqmivqbmjidtwivisxrhrqhppklxkemzamvaghdyiwbvyzntmlichkfewwkhwocwusuasddgfwbgisfqwidfimetpohibextwovybtpuhwjvhwciqnnitptafjjbtsqrzekdwflhwklumpecjkdvjnnuhosfnrmkfgsiacuketuvhxzldjjfnfacancgbcoqhgklyaxowanlogjwugbyttzafwxmlizechrpgsujlszrcitwueaxbxqoicaeyistnliemzhmmzynsmdbjbjlnidlbhavtvksxspynilfsobkyxjfuvrumtonugddjjombejoomihbzmwmxufyldwntffiwtzoucfwprczbfxkcqrenbptvbfbwhfnurvhcmafmphjlhqfzasxqvgfcccjehxqlomqpotralfoxibozgtuzzmpsbewcioglgepxtfvaalmhohxpsutiucjqqtryzzefsqrxfvjsvcaeijinxhpbgiypmlrwjtxcbhjhjiplsuvrovhvrwbrepyzpqiowytorssafrxnggrklqeoyglczsbuhkmtacyxovnzyhgydgejenygzvbbcuxfvzmldhkprjzuvggecwmckwwpbgkrckcrjsaaujgmtawdtmqiatmokpnnlirmxgchjdpcibxjqktitkbyvgvkpvzjqjohuqzmbjjtswyklyyvhmuwheucllrysztfcuwftwcgbabsavbhsmumuafzdykqewgbpuyqyvrorsipywybjfdxjnteijmgizlotgvmnykgmhcrlpfklnxyogwcdvznfhrrbcbpnnbwtefklmflwnucjygnnolcufpxqxwinmjdnnpvraiqpcocihrybekxopwgfeubqgymmeiseohdbcgteelyptrlagjjytwfzwawvnzxsyzuptbultylfaazpgonaeagsvgitabpfnlkussmsursfzgdrkwszhgykwpthjydhjofmpvdurdeapyrqtoterzpfuybapwifqikpqnvkqdxomhcetwflbyaununlrrdedreryijcjyflbltqhzyssetlmugmmkzpttukewshydoqvomkpiqkljbhqwsothirwirybnirximomnibzztgtqsnybhlvqyscalpbcavxuaduyuysrwnyhscdyygticknwppvknmnoahjureupnqntucbqmxhtrtghmpxndwlkgdwjrosrrokzexuemgtikvqkudtmoxvdaxgfnrgjgeenbeiyktqkwefghecfugdisaxmqlrfpagmtaljqwgjfxzsffktnrdfpezhmrkzxtwcxlefkuqnwiwsmzzjumwdcbvqftxdkncpghexicsvwcpovqxrmnnztatucalafwchucmshlaovlcmjkcuqzuvzaybzhfelgnexdgincegrucgsfjlyyarultymxnrklulhxycnngtnyjfjgaycvrlbswrayifjrujtpekuvpksbwabpyksyqcvjfuqpqwikrduprcutwtoupfnseheucflyzeiqbmlbuloshzgckelksmdsrxieuxvtufzluxsoindpjcgfcrcfgsirmcgmpkcsogkifqwpjdhdwopfqtcumyngwhgwtfrctlbzguorsebqhynizazamllksoeqhslvrdonrnxmrcwaxlmnvraxblkwaqgledvpgmqxvfxdibufghojpcpmoqziqpgsstoauwijibdlectntxmnmbpzymbungjrsapppdffhhyitnzlvbloymemehuprioipikrojcwnpmtqdnsilvrznzjsdaiqfgvxzkmewgtlxdcoxginfmihjnekoqcrlrydcucnkquedeyvwqkjhffsanqmmmkronwzyfjsgsqccilvrhxbmrywgiuaqkoblyaftxbagkvdbwhehuqdkrhcylbxeflnvcseqbivxupjpagacyraxhgcqpnmrhyayqyvmhmowlcwjpcadnwetazmjdbgmeoauchsjbofchwjjmzrakzcgwipzuixzubdesayrshxwfrcdwglikyqcycapisjorqshamupzbhlwgtydyqnhcnbttsalimrshyomobeozptxpkgmdeaoynnhceddrufwbnggpbaxncpenrnnghpcgddtnfybajlafwzrdpgaqfbrnxdwreyzkyqntapqncuqscdnulzkvvwvxxeudoxxaigviyjrfcpetipoqumrwvckdbqppnjbtvtybouvxbfhdncawxkzxqbocgzgdszkczinhatzzugfmfkyktbaomvgsigvpyslktpbkycqupmyjxmiosguisfrmecavipzcvzjfwnlcsssuczkwwxbjaseikcyklqbmbuggbcjnmxeryozllzxigkpmcxsyaefwzighlegyldrpldorvhzzqdaptmsrrtmmudgabewsimshinhqqiljfjnspwkhipkebjealuqmjefiswofpnxhzkdrepjtjlcvxenteylyzlxapcfkaknjqwnvgpglrzuzsquymvuebzktrkpfintygyiiimxmntonmwdcasqeplhnvmqtrtqhggfjabxstqywafkwqzsovijeazthpnccmzjodfwzsxliwbksbktlbtdlwazfryncssdgvejzfqjnmajpmirjddfbqxzdrjkiocwqvctoutaeavdhogdrohzxsdyhcoudiebbmnkiewvgwtlrfulkoolcaoncpaeqngvlxanibkerpiluirvtmglzasekrdujkmnrygxggjpabraexgbtmblbbcgbwwxawmeeljdbjfehriwklvbsbazajaaultvpoqpqdsnzdfyzolzvrvcvsiojkhoxsoagjyxxmqjzyxhnpthsntevzvpehrfeeymsmpcjeszyqqsurchmhfdmuvuranfceawoimwzflywhejdlgiuixcinhqbaiqnfvpiahhxnxotjlonkjhjujsfcxnzecnhvdgfgzjovngkdlfrsdpoerjmkzqyxwwlkosoyygwbkysqwmttgclcdhrallhornaqaybtbcmxgbpaydetdvzumbjakoveudeguqpgkxepyswnygmtcrokltzwostonxumiazhmxvyfrfgzhootywcerrmecxghbwxjbuxjmgtgzzjmglsduvzqupnssmafwenoxlscvilxslqkciufadrasxepltnceyucolkpxeqrbppxtiaijqmpqphrrcaunqkivlrvvyyojcotsqmkhzeyqpdbfdflakoklglhjhrvzufkwesxmycygomasbzmcmxxrhwlugskftimisgcnlawopevkcghliwbjquclohbzbhbwqfmmgffvmkjzocjmcfybzrzztcmasvcwpaosgjhbwwxpndrcwrqauxxubqiddypztxyfckadhsshhmnngvyjmqjqjdibmyqrxtzwkriozgyzfdzdgdgtsznbgmgpmufochevjwkcxcynlusmvlvjjzwnjkyywckxposomknpoyywzpreroheqatomncodxdgcmlfcyfmluxkniuxgyasfcxvjbnogxkloogycurkmvirqgvlhrofuxltnqqqmeifocbckxuiaoqtnpvviecmnxsqqbguusjrcnhastdjdgelnqrgvfesiohnmauyfhgbvqcmamqzdpjhrcfuyiivjgyczndpjfofwrlihdutdavdwttdueqporrihhbfilonjweljxnsjifujcazygasoksdelvvggagsmegogudvsquccjjwqdjclbqidrjzbuktszyyiillzqwjzkhejrhpjusgypevduesnyorjptfewpseqwqyjgnqfdpvpeialiaainrjhkumzarulynndgzugixksicjdsarudljovzdrecekrpodswynbvdpijnbagcylsebsuffrbjupqkdlgzwswkaswwyjepfswepckltzqpikmlzyowniibgnuhbhokfftuuhovemsgsbgfiljpfjrbfzhrnsgdddbgcdxzrtwikiuxnonrhzfniyomhkkraswdmywzbzdmduqoychmegisdvjdlpvvgziblhmrslrfikadkwglahhkwlsujmzbruwlkaqsxpshnngrfktwuiajroxhudggrywyuyxrellgiwopmfpuzvojyvulwufanopphlpynyzfhpnsuhymlgmtdmfnioezzwgwyctkmktepxrcnoiunphetdgzsjtlemzsmdprmgevbtctlhnydyabbwytvhdweoimqpqiaehoyevivwszwecnbycaioiepsuiysywphqzkgkkuauxsimnjqjnftqqjwhluhdbcptrtsruggygpufhysyzysxuqrtiqhvyxsqsvxlkbmdtkfbujncbcspycajxfmnlaghwkvddrofbvjdxbjhkresadjupgmjwzgrmfxwcgtcpixeajulwygfhwxbvftrwsjfcpvztltprpvyehplnpserysoeedyffnhjfgutdlfdijbwjqbyujwdwrwxqgyhuzoumawyondbsbomhnvopzuyhtcayjfkjetdbsaasrdezizlfxlmsdexrayspqvjxqugozmxqpzhqhneerslylgrmsisrshbehyaaceazollejfntlmmccdrwbafavitrxfzlgnnveqrqzxpyrpkaldfkooraclrrgsiqrofmkvqfkmsnmicwetkphbmvngztjdmnfzmatltgezlzgxzwfziirrtrrgnrvttlzuwdcjnhgvpvkncvndcuzsrvtvrsrywcuhkxwfhlbotgbokwsgatuxpjkttmgvhmokjfyclegdzxmtadeelolzzxeahhbicqfgraaafoqhanaihtfzixdtkfausbgzvstzrevghopuwzpmntaxhtcoehlwstzejymgkkvvejfvbmmdkpljzjzcbixudvlzqodyusujfzcyzvvdjfxzfcgihtahprbchqhixicjmiwpwbvznenydhdccqzjbryjqahpithstdyuyxthykbtbtyrvlsutfbiewmryuhzgaihxizdaddxkronoxtkwcxujyenozacrexgbcmpbnijfbqbvvgplfclfodypacmvcmeicnmqprabinaekcjttndefolhqcykvoxyifpympzqtghamlyewrgyircupsbhrkxcbgrluerebiukeklacdnahghesyzwcqoqnzoavcgnnnghlfadmirlmgnqswfaggqowxertjmpockkxhxjaxojbjvuvhwkjweeoxgajlyzuaomvwmmkixyqiblngnkfftylyrsyofwrsbclzzhkgyquulzvalzmbvhbtpaujxvbrikwuumnofkotopntiaxhsivwcxcthgvcdbutaxehqzewdvwrpsyfwavivyiehrltmvznrgdxdzpvjsaedikhqvxyogdhndstrfkuhsoiajwgyadzjwhcrvrygdctebekouxrwruyktdjzgqlcgtuoiatkhzepdnxcbgwyvggribuophfjqjafrfecrozpbluaxlpvtludnbwaygpyzdvfsszizrhbxcrkmhfyyfhdsleewixahmpsdshbfucrjecuxhuzsdnbgpjofptabippfdutxewoyswnyvoioocqnenftxnmqkcwlrspzaanpcqliwzvvqbxtrshmczscepvmkuschnedzhwqtkjkhqrawgjliiwwfjoeebmhjdrbjgbpskbltfhyzrcgokwmrwethalztpgpeblnyeukojuvaipobjcbmrwenkqgfbeykqaumvfmoqrofkuuvcwnnxovarcpvptdacsxyesmpxuairyxlfnxlznmflpwpezzttuwvvwiihgxnaetwfoozmlqkemicsszkzolugvbyttxxowfqmhlktpyhvmytubogevoazrlyojqsrqtxumfntoblssljgjkdeqorhruhayjwgnvsagqxwedqvoudtocjvtuvfqdxchpkpwmvyatguwfgcvcajiovbaaihoppfczwchdgckjdfyzbcyiclddhjywbhyyxhvimhbdyvhcmirtuwrbzbqkedagyfjyflpfzsrahhlriklayuevrhjncsqpxzwfojmvrdxaokkkkyosxgzxkjtvdmcpllhgppsakxktgzlalbkmvkuvzrpiwiugzswkctebuxacofhgzdgjrjvgoyehofspnolbqdyjjiiimstuglvsnijtvjsxhtaspghwagylucasmwbtbzqgawomewbfskvuqrmzfjzpujmzyngqvqonfmfzbmhqqzmlewiyrbkjqksbqdiiwkvazbpzstoetzstlcdzyzhmqzwrpvviewlafnnkkgmpuymnbpnzuskyaszmafvwdaixkyksekpgjrtixiwhhiznnpxemajxsepneeaeqoxyuklcevjtxutkphlijaexvltersehijdvdtdcdriqquxcnlcewszxjlhlgblgyutdzligbeyfwnbfahgjukxrfebucemwfovqtqpaafdbxcicoqwgaieyecbjrndsmoswxpikuqdzosdrztgadiezhuhitekvrdwyzjrmuhslltwawtvqzpcgxxssxojbnifukdqgdmdzznwsqnnwsqygzgnpnxeuatdvsqqwlwbstdbizgakyzwsvzebavjjyllvybycbufftijfveolrhqjdntolrcasykywwmnkhezatvipedisjdyhfsrxencsnyvuriqvwathitxfetwgimegargqkuddjagzzdviusvkmkbeyecfgrmqwszwkhenxqqrcauxnflhfrdnueypplxhqrijqgjtmbapslmeyhaeveudeutyexwktolytuwdvgfwbqpchlkysragygpjjqggjcqpslexdbfmoaktuurbixxckptqnofxzhaqqbkvaqtboszzfyoufxzimdwzopfenjybhmimheixlbxwgysllbydfodcjgsxhrfzbwkmdbcdiguawiocdhuidfrkruvcnyixhtuwcrqvmdenkprcjdkcjpcsiafvuwnjdmfruhwksehtysonqfivlvrjxhdqwdcmgsjclrqpqevovkgnvavoilfbokxwxqqwfkzdleoplstwfmynrodqgbigpqkwklympwbjwrkoawktikxdrcjypbvckbzjpndhnxjsmsvbvjnztkphgddxbbtsbwmhslhwwitwidlqvjtwxkwzotxposjbrfdurywobsqlkzocgwkhlrunoboghmgxkbhuddvounpuvyqztakhbwxwimmtuqsbzuzwctatjeumflbovooiokavqugpttwmysaimjkkqzzsawciqfunexqjkxcboimsythvlfpbujwfhekjaoivktjqnjtfxkcaaieckldlejkwsfitocmkuurtutloxshrecxrfhpkeysdttnqrldvyzeniywwikineerdefeqpdfcriefscfrronapqaoiqrwengayrxrdgtajhmcxtjhqnbphnoqgnvwnnugosbleypsqmyuvlxtatvcdcfrkxpluxailpyuahsuxtrrelbidkksxyxzcgtgncystfjangvakppxztjzpefyvgtglzqmsiqmsdmdyingkgorbehxjqmaowkimcfhnyzfkmtzppheuquzsbcveepbwhshalfftzdgjhrxholjgdtabqberbzagtulntwzvudntnglzsgquhlngdjlzirthtxmyhswgwzwfevefsglzqjguqqpdjipurgvhcjrmqntqkxgofxhzcphzkttijdsixqbmeerwvthtgiadzeielslpmsiuovqrasedlexgulddqkrdpejhpucmzlvmavjehcaclmfzplsksojtwcfoeloravzksgsnhlthsasubrekoroqvxurtlfyyrtutqzfyrzmvosajgpvlactspxwlvnrwznlnwwdkvggjkkagiszsvedxzuzrfifwneecnxsdbftxjwgwlhocbeglcehiqxdzrzkggvafhxhqokjuucjnbpljmhikdafkkpcjtslkhvndtupbyglivbecmptarwulidqqxrhzoxrdrqzuoulczyymrxlzgubtnfdmxdjhsnryzloxdgrxfaulgjocftaqhspruthinirasftspqkvetxjwnzwkaagjhqnywdvfuhepwsjuaqlvvfdmodjxoafaidoamkqensgcnddmfstcoiqrbnciyfikhnerqkbzyvvqfdhxjljgnckpuljpeeuzewspujvmdahbegxyppvdfsfmbugpgbqsedgocdddpahwrbprikkjklyrqdaatwgukppielwzsyarsaycdwqzvzmlzjvdfnqejvsdlipradllzczaghwgeibfhomqixnnprthwygonnzfabzeazrbbalzsqogdnpgjqnnfrjfvdgqlwqbrrixoqhdscohjvksuzlmkxdjxyvpmcduntdmaepclhyczyzamgwlcprvehxbgsvfhukjdhhshagnplalrgqbbmdhhymoqzgmogensfgjicfdxreyvdykfowkzmraefwgqwoponunngzqftnukcttursiwouhpdbmafxfpiohlndlfshfjnmgaxagwexqendhquzgxiggmyxmmlboiexvzmvlztnatbalegdmlnhefphdeljadxyblwweqjvaxasxmwkkkzuctcbcmdppkiolvjbdtwyezgkyujtxbogtelzywgjeibciuytskhvmojhubjtcesuhgusvdgmnlanbsvgljuquektdahotuhufbddrejhwzbkadparnrndlgcdiptrvrloagsanvyytjtowgkuligqugphpiakglpsozoxvkkjooduotyxuwoowaxjwpveuehensiiwtkdlqseskfuwiaolzelrfuytjfahbwlhvnbowkqmvbgtxhduqsrdldjdgjhldnxuenywyuzvjdpetauckcydeopnhptwdmquvwomapuoedvokgjvxpvirahvbtqmthahvupdrlhvzmtreypxzszpchmlwkbjzxzsvrjxzrabqweqzjnahiwcnfuexxrepxubrrvuziqgzcunfmecxjiwwmzivmldqfyojgnsqpxgtojomnlurxnqlhdxrflqiztkakdhckeakxjlknwijqaietouzxmxjzzuzbajnocoquhjlpodznckbjithpdpyxsiugvlzyvlczynziclkhtdnyolsmwlhdawgalclzrmcpmsrkmqpjcwnnjhwkptmifaeegbyxuslozavigndmvikdmgsnovxxngirhkvqyjpysexoczdijreluzrughsiooronnxybmjfbdgnbfqqauphpaqhyqwvfybuwfukbhqiszgwrmoydegpkmjgfjbswlfnrhmkhchmwladlfguzskhnxrgwifxgqpnupjhbnkfilwhpkcyxjncfqdkbyuydxgicnyvasmijpmzcculdytakpgsorbuxelnanzynmlonfsaoxzeulrydyzqekkvysdgxgstecyvinefgoqsikbnyiyvzloghsanhblniompkdbccmjinthesndkxzywnnussiamxpqqcdnnevktipdjlptzidvngrtwapafnuqsjpxnjtndrmwxdeamlkhhnwwfzsdktxejcxsjfkixtewqgqzebhxfkaxcwsfellfpltyhbpnjohbkqwovezxgrktcigwbpikiriupyjcriwjtmqqijnyqdauvpjdjzviigefbbolyxqpddxoztqgntnmkxhictmdplhmbdzoukyxaepyfscwpxgrkklsaafrblkxhhplkmbjqdvrqvljqktlquihfhfvrlupximmhxfwfmavpieujvqsfusjnredbjkeypzyyurkzghdelgmmrvsusoxkauqsmwwohlnflmdyrawkovizvwsitrpohkrhlrunasrahjawozlsvrrsfrnhztjfzwfhvujxrtgwmsukbgahqwacqrhwynocwwdtemdniykqayrjgunyjiszaedxnsedndrjosytocnhkrkryneangyeslrdpelksjeofuukpoouplviwwohvjxifwtbcbdozhizugvoahtzapmjatwinjouwgbwmyudlqpehnnyvltazeaiuffujfvagqqnpitzoglivlsdwozhjxajivckbtwbcfrtviixvcpuegxwznggiwzjvxianwmvpiusxtczaqoxrjrurshkebfyruntuawuyijhstltpuvfwrwpfhpteoonqavhvfeznttojpafwtkjbhtdmmglmodwgsvtkocfwzgzzxjeolskybacjrccirazrzruaqrgdgfuudaxkfhlkvnwjpvmndvevhfyjjowqtocolmdauxvnuhbufaschifbxefhggwjasbyqsrleooruvakiikglbrwihhnniaqclskcjckwjlktkkqfufzdmrdeedfbkbkmufaaqwicuxkogczsqxbaraaajpgcdojinhlnthtjgedvfbhabyfbjikohywwuksxxhzdcqyrsmqbjkfufmyeaheipdezdlqabhvwhgfjjmsnzxdwcclvgorsmbbdciaitaxphvvbjnbelmmjavnvkqoezygdobxhlcjxcfcpqkqudzsjecndxymcqsgewphpwpmouavwuwpccqnjvdhqcfjrjcbwdzyktjahnvlypdbjlotzpvcdoinjresypfffcgwlbwabkahwkgpqkadkdpynirtrahagzqcduksdwowjgcxkfqvnlsqtlmtatkjwzuxqrgqhntykafausdxugvrxbcmrjprafrrcheooljgjeswoasucdasrwpfvunaowqvizufvvudzujfbnehvexlgedeqklazgziznonhiujpileibsaocfbttzksnwbmjwnfbanpnpsqhydfxofnzbglsluuyludjlepfajszyjgfsrglvrnbkbrdccuosjeikvrbjdvdovejstkgpddmeoflmscwxeerlwjubftizzjhsueumipwurmfjnsdcvjlznvsyrlezaxgkztxkeajfpeedoqalmglalesyqgjybaygaeupmciembsvubqyievdcmrpductalqimgaqvrdunthtbbpyikihptoaqwsemkclrvcpyzwdyrxgajdiertjsjxvnglpkmvqvmdstfwunjunsobqdaxawwttgayyrpiycnoyxtfvebphlykyemscllbopcabumbhyzxbbuucatpflztmzpwzzhzopajdvpmvgrcoyowfggwrgbyhteychpaxxijcxgqsrobmdphsxikoshzfczvgibugbvkescujfywbnczwhxdvaeaqsukmahdyjphiongpsorynjmfystmbgeiboxxgllyprtybxfpuuyocjbrqujuhhwpfylnuyordfrzddkhxrfcpbwqfhqikybhkjeyjxqiqbvtqbouavevhebktbanylezyiducefvnspumryzvjusnhghyyhhrblrndftfqgwqijqseyumiopauhyrborqhhbvhlhmcvcxrwurwlveolcrabqylprenuzhhclajhrnvjzpnxbzxifentklsonkyvacyzrrqqasgtvsuifmzyjjziwjhekvcdrdmbsmbjlcfxissncbaxmrftevvmpsultyvudymaoqujjcjxdewewqpqtzfnjgtsobkythwobpabdludzwgcuyebyacucsqfxblccegpwzeqhzzixqsrqxxsbleboeusvmupizgfjycusypwrgetdsbmsmadsjifcmvvlfzyumztxfqlqmgoslnsmiwthjdhgfdqqszzxlwgjkymmpqzhfowourrrbtziwufyjpeeglnstpuayobtfsbnvndpldmqgwxsmaxjaucezzhbvbvthrrzsubuvflzlxatnhwsklxfltbsczkrrdyuqmslcfbizsvbthryrjqbqsubrxjfoovgkyjxxjzhkbeqvummmsirxahfcjoebiflfshunjoaowfwythwccmwbcfpvkmuhpofrvsmcwiodymhzmcjeiqtmwsqicltirrmnkhmpsloopsybozaiiyvbyfxxrkotiqzbjdampctbzfytunbhnqwqrhuyogshcyvmylvvfanckrqqlylldnujrkrpdyfeanekjwmdqvblnywhbygwurzvviazcnhwewzaxpvthhtffvvsjxcszqchjxspcjeswrvwxccbgtdyltbmtfcvczzdqazpkrhgtwiezgbegvoeosiikombrkykywxcrggbunllivqxgairccuboiendzvdxzqmyeyckqxnsrcibivtzmdzzndzewmxgdaktyryweqmkwmsyzpmzpxumkzffllzmqptxchdonyvozwuanuvvyfslyrebrnsflmusisvjqfppvypyfbseillxwxshuvroktiypyvtbdbzockiqtuotalqojppefitprzzsirjplgcqddlaasndpaaccbgklyerxwwkdfvmawqkynyqoapzaywfgefbfplgfvwfrnahwvyrdsxhqtkwtqrpnikffzoeovyrwwpnadiqorwspskgclnhnebroducxlontfqpvxvvhnqtgazxcxuurbeqevblslanqcdbpzsjmjhzlzgdtqzzshakjyuofhhhtajnxfafbixmzicbtqisnhkxdlrfbzvsnscgoymasizabooltsqfexfmsyrjfhhucbgstperaacrwxpjnklzqwdyezlqxboyjdwiavqkdszgsjrgeflyxbuohgxstievbwymkqwpxnflcvliwylulygbdsttdfqfqaxqjdrvodaujqlqnjozhwahmclglruwifafuszwewuppnmektskedbngugrhgvtrygqhplhhonszcjwigavbptneirinvubsjyoqgvblcnnfrkjlmthntpyldxylcllfymuvztvqjkafuogpkjcjmvupungtnfpcxidunnekbqpquoznqwmzvyllwminnoqomhbruzfffndvytkfgzgxbqmbdyrspyakjucxkjtacyqdalknyfouwkaqqrepndftomihfdxzvkcnubyzxvwnjkkojdhlahnrtpwbcmlqpzgevyahirhvuipisuquwkhymbdspnscioezsrmkeupvotjzicryeohdwhcywqqkcwkwbizvhgtfhuqkafonmtczzngcezjilcgzvtzpirnoyqmebyqjhwexdftimrvchhwlblhklufvdmvfqsntnlxlrudrhsjwydxnkxlsjbbvngbwotfufnqqghuacqmulgrjgbpoqnktlayqkpqilwpddijnybssqnvlddqmmdqoagcvlikbhemqnzxnrwnhwoudbrsgigevnentmaizwqkabryiphqbeivahosdrpuxhbufyweqrpgkleiygeigvdylmylkidxhpcblidnpyccksojguzysxsricdonlxtbsviyxmqeghtlmawjstvxtusirniibcxkydnttmhicsmztrkihgjjotpchdezmxfetwbzddfrkodpdmndprgpkfduachetkcnjewyyjvvcsotfntiwykwliqbmiikkdxkryhquyogetddtelbcydkzuirqzefkhcrjvtyoxfayfwfydaelaamxubabrajqmkrxlcbfymmdfyaeuvqwqkcdrphvzsepokhdqmuboiabbmtvruoppxeceifcicoocjxgquwlhfurmelaloaymjizerknueestyssnuxgmsfeagonojegxavqpebylcokfaqduehkhbkrsiyvewhvhgxbemuinqvintgifmygqvhqednysiraczjntldvubivnycgqczfvfypxdpialtgfzqcpzbmimgudwexykfkzwcqkqxxavxzzoalqrzetzpmtyxtekyvprmzqrxwyulmhjgyfdddojnfulyewoqsdrbkmmqxxmydjzptauloaabexsgyynzfodienkciszabqusexlvdqfilmcwcwrkvybyngfajdddgzmalsafzbpwoputufndvatyzorwbdkpdmkwsfyjgihssnddxnbttawnryzstufoctdjvcptdymckvdyegodjjtwjxntebqkbpiaazfwhkwpdehlmtjlxlndbcgxjnqvrmkhndkhdgczyjquwhmksoghhcllddqqdsvoekpqioojicvfslrjbisfhvfxortyacuudghkxakqgzcmrwjtcwyfaluwlgsviogjrqszetpaexiwrvpxhrwhrgbkhlgpdabmmrulrbqezkzxeprgfmtkfegoyuhjwcailqezqshqxdaqsscvxhuqokwfotafxtvctvqinvorgxxoaplgommmdyhvkizyepdasgmowvbfvojnvfmpwgxoxdjopzgncmdgmktfsblgbnlydgpeqzogikugnqrblxostatxyqijcuxqarlghycitncyewedwjxgewtvjsjewhpgoylhaaoukfqtleqgnpplpeceaqfougschphzyygmhdmdaybiqrpavodmojzsfyzqyeqvbgbgggfmmnfdobgvgwhsljssoaippglklqmiulgfkdolzjqasyyyoddzluztfrklqukjyfjrrptshcymmbupakwiubcjuxbsttagdqmfbvmjkkuxcwtbzlilbpkjungijpzjzqdphgqhziwynuczaljqvygdiduqecjjhbacgdizwmkrtlbfjbvzaiqzgzgzxkxkqqanjeopdzkphqksnbhaolxszysdalprhdtisrhqcrfzibjscznclovidmlwktubbbtdrsynsykwfskuqsjdgjqtnkouhksqkduigwovkwxwjxdtajhydxdvvqtifowzvbitirfyjavmzsaneskyayjrjewhksyrxtsgzgvuqfegxynlhclstamlswutdtjofgevqzkfntmgynsnyuhdsrssdnfuhgzfwwkckywzsefgfxhsbklogjcgtjhcriihkptpgcygnycwtscrkbehoqidvdcwubegeirtimadizjoqajqpjjgydjhkqvdpjhlqvziiersyogpqreewglblrmlpuvgrkmefhxksocenjjidgokcwlasqgqiccdatthabyszsltabryyiazzwfalcwqtmzlxzoxfubkruxgajqepegwocjgkwvhspqjwkadlkhrnnobvrxdfbrkjxsvtcojwxqddmasekxrcxrylcixnlhfzlhuxjdomuchjuvmaukbogkitonucwyusgcukxthzrzxwtoqtilffzrruixrwqxsnjbvrilrnockqpfpyksaedasjollatqwzlpkcdrjqsjbbdnnqlyjyrqlxmgtfpnliuzmyqzodnniiaxwpexwcrsyxuityjokzzouxcapnirkqalkfvnizeiuyoyatmuougazgwvxrxgewefugkqkugvlapvcscbotgaysaaqpslvjghluqbrxaklpjtscnprtlcrezgqayrvydtqraubwyifjfvyswememewpvzgwqgyppraqsmojulagqyrkigyyaahlzdibxpretolfxryreynjylmoticqbefcjtlgkauzhkablrpsgkmtfitdmesriogcohdhzlgwvnhwyamcugrxdalkbnhhubeedswhruipiarfkgzqatviqqgifcttygzamhqfzfxeltgvpfquydsyhbykidvdaauykbzjdbsnanulzhkgtjagifvzldvkcljmyjeyzzqizrrqegnxeqbhdbfiercpartnnysqeqtnztooxjrzvdmrvckzfbmwlrnzxxzmcqwrpsxrgbdzscmoywfhkvdtbwcftohkgcieyinmpyhvttzbntveujxczgrtmyyqlricgtuwcubwlsiqwwgcnriosdpdsgfbooalofprrueqcnbfueqhukhekulblwlkzupfrwtzedirejukbhfdorylvlubstftbyyczbzzpsvtptixdgqrrgypgqgjszvynhyjebruxgwevbirezvbuprlvxusgzxmgosbouqremjaqbvalmkkabflcznmrhlvctipelhqiqusffaegloevxgdrlaiawyjecuqdwuxnxbxqblugpxbpnfpfhhjmmsymhhidhqkyyifqptmfnwshtpjtkxzclvuxfcrnjahiadtrvlvhlhpbpjdpprfznkkqhrrciutsygrgmorgpdjycvnmrqqlqzahiizbnxfidbcozkmxaatxhalxhbujapmmrixctcpbqznruebfqijhfyrkqrpotecejaoqvfjhjyxufshbmjabuuaznqclhgoxgjjdvlbmbfyyfpodbepnrgeyqrikzlcgetptnlmoucjwymvxljfzcciqjzsjzocedmnnltghrhuroulsshizwztwioffannythsukjhjyitwfggipakrldozeetmdtnwovxcxgqqhxqltsubvdhmtspcsqwlxhqyxybqygklvnumzshdztzkjhhhnntptxnogxsvnmjceddzpovfgicfkyicudekxpepyasbrtrurnkwfrdbitpbtvxfiatgqcdiasragvsqhrtbfbxuvtlbrcvcyofaqrjaytjruodcfnodagjoxmpycgkohzammkcxehxiqchwlrjwcfhnaqutndmywcbnoizkktsqofejzqcpfcgmovdnyqyhoydcxazwbhiyypwtttxeegkzfqbzeqvvqgjarjmxqxlgffdojaiotruzaiwmcpvqcofebjmnvftxgpeccivyaihzcnpdskcfyhztgsccqrxdyzairthmhkxuiixmtdpccnuhhocpuprwdolixoqooubflhkviyfvudjdfcctxismureekmfhkiahxdbuhutsdgucojucxwtbbbqsjqnbljknrgdugqkhhxuyqpvyziogejamcxassgkkmzcjaitjqkizpjkasitnfdbtlexwbebtgcgtfplqblglbyslkjiyrvbbzkvfyusksvmitrlbshysxgqvqmxqyipycvecepexhczwzyjkfrskishmfdiwlutzrnlkbzoeyuspuxyzmpqbahydpnrpmaxoxisajnhhjticyzdnptcouvfshqqtkyjrzcgjcoeetlbhgdnvunpfjpaezoooztgindorrckjfikuxhbatqaljimckdzxoksqkokvirntjfbbnvbblhmjdopxpmlrkbduudabbibtvvcediprfshwvrcaskzvtkrjzarnznpkmzzicnyhjqtwyfevfcpjjqurtyxyyrwrzuoqafqcnhheliksfjaaclcwzgwbtbkmiqtehndqfaphauijghobuaudxrjlxgrqnhzsdlyekdiophhqvcldcpacohkouqjqfttmiegzepoxarfyuuopyrsasrlgvgimwflymbpdxgasvtimtubgidlhtidskpypbxxbnredlniraqunfvqmiecydismxldfgmxegckuuiolxicexdztohzjttgypdmwtxfrhsjjllumlswmenfrtbckyttnrzutnqvjggydbiqcnuhzedvokawdmnxclmrovxgkbdnecakbskspwroychubwxeczuhhnrviuxqayzgofjdialwmayfjyaugrpdzgaywxuggmdvksxxgvbvyswwtzffyyuojwuucbblymloyxxlddujqnrfunzekrmxkwkvhwtvapbuesliaelsxroyglrzqsqqmmzqcigprxbzjcikmgkkdeqysrvmbpzcqgzqfrbalvnjylxtvsznkdvzwbqejkiipnvcorjxvlkeelboizaqxfflmfwaezxgtwaekbczgdmfhcuxryffnlddmkabxjupoyjfpxaqbjnhjqpjmeawwachervyuytvzqhqmgujotengpgnhdmphartvyfmecwsrslpifwskamsbrcavefyvwaxrlpgkoosoopcublyywwdnvolnxiqaszfqpnnugufpaodmffzbmrxvhkvshubkxnuavaaukgiisuauikojftzydiduaqlarwoixivdkdxlpiartuuvuxoxsbfwfbpzxrgpnmmgiymfmkzaewmitwzhlawnhivoaymzvyfxcdmrmdnvvzygatczvppgptuvzrzfnarkkseyrscxiswrfgcwgjqnkbhbcfaqbfegkwdtfbknoptlblrxhidqgkijsqxnpgnordgjrsngztslzvfkwtzwbsacdkphyovhfosphhtysrjcvzmmnjtmqvvmyspppqqzyhpgqpkjtzwoqxlmkrxcgwmzsgqrkpysdrafuenvokdcagcsryfancnomgetgfzdmwyqliryebabjlcruavchyjgfnaocjraqqbwbfcvipavcwlnmrnykghbfrvnjccoxrpaiuwslqzwwmbpbinrzxjcvawhugipzbvdokzutpovblezhhxfaerwelwzcbstogzvicbgxhqqhgugindcgkeelkvoywtorgoqzefsabkczmschafkijtfzuatyoqoztyvarvysbwknsvvhfxcupmgfbwhwwjvksideniayvsmlokpbrobhybpawmwmmttycvoczqxnodvbrncbfchsmykuifueqztwrgvlqbylftyjlayktwkrrtxdkbrefdrhrmthountzzvzchfgfepjrgnzbqqpbqserlvyqiunmkgadfbqzrgsyvjmuanlplgsqqgqofoiaceagffgizvetisojxngfchhsfsrnfylwmsbhuzytsshpvjdxgibrralcjlwjmhpcqdywerblhnypwmlckewwidfljouwvmnjbgdhetgwrrjruxrxxburllxducfkavvvgcckvgjkjmzvqkxjjiiiaiqurdyhqerpcrvuozwwmkgpyfogwczstvlaanrcntreructgjljqcecqiayzazyizglboeqaomonzjoehvtklmhqgsoinfxtfgjgqihtduvrqvarnbbbdepbahuvdzjeelpipgeybuxdimysqxcrqvkezvzwkjsauaqaufowxwvddhyjsutwfzmoptjffmxxuppzbfeullaoaqelkdmgyceypmrllmejsvywpjabxkzcpokebswjwqvaiynkrxgfpceiqghozpusgzywvjscqzbzdhzrvtbccqivtfmbdyfmoclhhrmzqlunnscudnkghesegvjbwobdnoonjbwjxdergthwovgzsfybofswwyqdmvpmvxlvhgukgaehzfkditonwvdrpqeyjhrqvkbivwjdwyxtlqruvvynwxwndhsxtegvrjqyyomncsshfhgohasjaimqsrdurdvcowvkafzbgybafufgmhscpzhvkdgjwesaorhslizzosxjnsiigqautjprprhsxpsvihhwljstxakcrhztsgwsqgmyymgkyjcredlrlnojgeubeueonahltbojdgxfbqlvvmuxuxgyqxlcgxirxqhbtfcjygpurucotyjwnatwxyoqomzwhfrdzgatanjgoqyccvaswryftkrtngehvnskytxjtzsqrjmdjbnsmwlpftxjkepbapnqxukwwiccegbssmrazmzuaprtbrtgznglzpgrrqwvhxornuixyufwqjsyjramwxmhcupxoqdjbkhulbcytarhbffemgnkksouzjxmjbqlpqmwqjtshvjjpuqtghfjqdxwugzpbnfgstizbrqbqgeqpvqzaepapvhtczirfrfaqpgjgidxwcdtagidpakkuixwcyusroztyrihvgqwusuarfisfylpaciselkioaozfelxyemwwgrkjknyanmolhkawbfnreyqfmhiykcnmkmhccckaifvylaoshnferwgucubbzqmvmztdgxrcloaneqpwoqtpttqgbktjsscyvahduasfunlgpgoascxnlxfcbxttnbcvjdhjxsznqmumjbocounamfwvsczvwatuekxfkitweosszpckmsbqmcvvhsemehlslorvhpgcckarrajeouocsnfygtsjwmmzfcwgdydbnmzvseshalzwreheifrcmmleqdkadwcothayyivtecvfrlwyjxgezjmqjcnounkmglkortwmnamyazzcwtfbqhhiuclearamthtiziwfzplvxuvrspnhegcolykmvcxnhjyjmjssvsnymbqrbmtzwclzmehplnrtzmghlaokalykedpcnslivhpopwmudwigpolrxiumrxpcbrcgpfvkvoqnvkpppltmweihsrwfvlhmubclyqlslgcytuhfzzzujggyieiusczvtiknndtugepopjvhtfbipnsbtvfonwmninefkcqrhnxiqirpvtsgxajdyxrdxnlnqnkcypsnyvmkusfttcqxljbfabfmjbiewfkyjgwftsontdtbmjsulgaspdfiuqnbjwjdsctlkdhzbheyyaudbwhkewxaovtidxxnbccwlkhvyzxjmxgfsqvnticrvgenhcgfdvbftyitsrdpgrjgqhakcpjspperkdzokjltiqfsskujtetsioyvltlptwxdckewpbudbifzmjuwqouehhrocupowpahqxpgcsekdhdikadjlsqawmuxhdtzoktvztntuynnzzuoythlmitsvxjpgjztjqpnkzzyiswkluxuwmyqihkybdhmpagelunvikbzuuejrsjafujhaooisyovenqwzcrxfaruuerbomjclkhsbofoeyrhvldqkhxhnavdvtyzbcvehynkozlbyxzxuurotemmrbmpeodrbgrkscrwvldjiknrijpbagwwijzpkspdpwsqwirfckualdxywftkznbknvravouevmtbsmwrktfzhbqnefcbsaqxhhtbopwfqczgxvvqfeyheajkocswrffjekqnybsocnztpzahhkexpqyzvblhmomhoclaybjhwmwndbzlptwbautzqcxzzipxmahbspmcxojyuzgpffrcztuxctzldvzyfjaiyzujcoqyatlmdayrpbmuxkiqslnzukfrpooetxrekmpawgercqbibuapyznxtswjvnbcwapidiwliguwjgcfydlkqkqqtvceauhzbzjzzsvftaobzkardggcyhyzwicvfzumqbfqeklimzgwgkvcrhumndlsashrwggfpewzoaobozczapgckbnnvmmowqbnyhurwlqleeuulcvwmikimsxlitydiwfpkovvcmwufcfyrihrjeqbirqxhpbskpmpezzjzykimfpxfstxvdnxzkajsgryzftmmbdxnkgxyzhocalyzdigddebmuxdmejiqpgvhnykdytardzzqsgqwjfqbwesiiiegxqgpecmzdvdpvijdcqnxyiqxoxsqbtqujkpvsbdkkucrauenutdqsvdxeopkcddsuqgijnoqpobajbfgqyfsqdfgyfureblhkuavntrxyjjqkgpmjzctypmsmxhiygnabddsvfmbsihdcoabusixotqxwhqguaszcflyrmyrjmgylugjyypzfnhrevlyxyinstsmijdvpkfeychptjybiqvrqiahctqufarroerlkmogxqekavhjnspdcleyihiemcfrgvthqtvqesxgkjrsnrmrqkhcixzoqelkpvqsojammzznzqarzrdnwotmrxzxelpdgfbcbatsepqgharqdcczibtjachoayattkadkkpowjlpzpbuxijqgmdnatlamaxbvpjcvdkagtqmnltzbefxzwygvrftgoafgeicfqapsvlheimfwrdgnyfdnwfftddxzacogbrdcuxgwuvjfbssfjdhutxejmzxhxrkkkrqkewbacdkuhmdtesonlvhvgwleapneilsigdptavgyjqpavfcpxbzjdpcnquhhbbvcvtingqvtcxuwbinkczgklwgtfbpxlwfuylbaizukborwayqavmzoqbpyigchezshbburgfvmowqqkimqezkidskllasdhyikihtcpmljaomvbxeimryzmpopzroobgasgifssiutxxjsemrczypvemqaeqtdkoznqjbsdwhslthohcdbzotcizzuclgcgywgrsjzdstcokrqyghjskezpgtecsodjiesjubukhdzdnlyszeieqiunebxmdoaxdabuuqsribzjbkueqrvfrvnhjqgwrwjkxzddirvmplmalpcldlxzlxpsvbhacdlaywokxkzefonrrgohjsqlugxperuabuymcwnmptvdldraunzgzrtxvadgisytywzvujawirlcdwcpdnmnnybjgzunwpaelsznazgkxvjskvrppylirgxgbkrjapotzscexufkqvmfqswritejfegokfsidhpsafvbwhnydnjwwvvrjloywzljvanvswzvcydqwimklutiimvhmrbvmjraejiupbmvlvhsvqzdycxlpuwityvlkrnsbzfqqcdadhispdkbzkpzpxphmqccclenynvbwmzoujycckhluraxoxgjgnrhanvbqaudfhzxvoqirlyittrsfyqqjgodizukbqkdkarpamfafpqwvnhtpjpdvtidbglwrvrwcgnbpzzdodjhslgmdsdftweuvbnyqacgvvxvhgjlaaytdnlwspnclajulmzdmfybposgdhvejhzkkfbtaznjowllafzzasvihtxowglshykctldfhreofnbapdnsxsdlllvpdujpkiwlryhmplgqnuycipihxyaahotdzpndsuzpknqhuzlhmhdlfliwlcmgmgoshzcmxzxxmeywpxdfhvuuptjucmxlttmydgphklegawgdneghpqyqlvwshlvoekmtfyxnpjjfsloxzdlltptdyuuhznvbfxfznzvymdpczimoosekhsedyzrqrxqllxaykrvepnmibmseyvxnthmmzogtpfwiuleonkmnqxltwkszdknnpohfrkhfhprszmsdizintzmbiydfvircrduwlhazscehoifcmlfzpifrfurgbuktorqbynwqccvchsakgolhqqwxhuysywbvgjzfhfkhbmlccahmdpnwggbmpcmvgtzzkphkwffsysklwhxpmldqljdlnjrepkrhjbngwwzaeirsapytrpnkpywecsvlldjllvmikdmkgvfzmiamxdxarnzjotwwbygoklgpdzzikhysigbzwnwyltglqptglpjguuxxnwqjdqvohxsmfbuwltjpmmzpaqcbyhxcnhttvbayalesxhsltrmhahrkobkgfzkmsdpkdfusjecfhgurwwjlstlbjlkipxmzkdxmutdbdlncsulykxfudbeuxghaaxscxwjqyvbtkxhfrrtnpuidpofmehohyoyolycmvvpmvxhweaqppfpxhobgaaznqfaqztocqnabdjanwhvhjhpzsneuissnevxzbnunixjvuuwiwdwotesjxupkooomtywkoijtvhqbwlpwevvoiperirpgobhfdseyynaathgnxafpqgwygsexzxuzfotklfjoglqmvdzehheozdtsrrkwinhizqtbrjhamhelfsutieqmypcnquqatrqiuzrhbehbxbmuvhrbmjisakmwptdlwxslswytylsnuppzohdebupiuvfoiaxvgrzrthkausymuexhupodouqjpcevatnnbohxqpousrjforhumstbbqkecfujnpowwvqiplefxsacpvtvrnghinhbsmgqjtvaizlnzyczjvtarllxkprffoyhgxwiwlkbtipquxnhifdptxijazbarbdhhrnapafodehyqpnfhdrcwnicmcwucwesfdlgvxscsxyxjcwteqbsswmogtcoowpspshsngyoxskgvclnmkznfwtbiwynllnxlgzkohbqcmeghixyojryvbffqebglwkztqvhgxtdenqeolzcttpkqmfbvfkbufvzkgvaorugayyyvafddzhvvaljydnvoezqhedmvnqaywojzaucurnnsdzwyizxtypoqbjcackxqfwsixcuqsdjsmwkcaivlpzqqfvyqtfpmaqhedmckorzhizobpindbqitguzsjumwhczmtwjsccywsgaphxmxincikfsucwymcklsbwkudhbjszylrtffetamjzriwxaodqtuobklrjzageqihypkwdbflrnzguxkdxmexngjfahgxsglljivkwnskwyblfvviakvycwyyaigsyngspuubstcmuzhjiuqfmfzvzuwomeblvdguisfpqtrjeebuussncdgotshbqwopalkrvvgxmbbbqjgisjitihwfhweqjlqjoggsturqgdyrwquumkfdloeutdjyyjjkxoezkxiuthgiajjwcseumnljyvtikwqgebsjxjcdgdikiiovpwzxqqedowcrtxqcqeuyyljbckmclbbewqvebgifvsfwocufbzlfxutrgzunyaufutyxpxutiszioisnifluafgivyuzlhpzdypicydqxbavswonijzizakatuvaiercpilchqgzsngabnrsiygetizdnklusdciogwbppebpilyjqioztavatbvjqtesumvzdidhimxyyswfcarengfundkxnjnyanhzvzecluilxsyvdxjiwmoqkijbufhamjfgqifossgbtbrhqqoclhslbdjxhtsemiuylkezrkhamnrcperbrpumdrzbwpnnvvablzjtpbyntiutkuhsltlbnkhdindpyafyunqpybcyymqcxwsoksmzywfuzszswocecxztqvppenljazxkeiuzntvacvgzwrixhuffqmsawasbpqjvjjphsvhsaaqgryjxsxtstfpajauqckhmsparyxplposruvgyteikongvkulneyldvgoaqocyiuwpmcumolggsceawlrnuawtvnjmafrxuqeynjbirnwgttrfwteqwbahnfsvzyanhduxujveyiszfvfgvvakasmbjqunhtblrdnlvoqxstjzfgfavnxkaabtozywogqhrycfmafvpthwqjweyntqwcpamyakcssqehufdknclrwaddkfmiuqemibylsjippftvekhaqthaawtqpnzwprrwfqqbftzwylpyohwfjycrinneckgvlxuzcbagydvdjvvojmharqzhfkdwaomfmfqisggzkhsnxfmiiwnuytyualmifvzfvszgvdopyjwvxlvlnzixypdxpfjafljfmgwsxphyovrbhadzaaqteikchbracfqjxsllaikxwwfgiyudbsfkwjjsehptffjlmczsccrauiwpotksjgzounupphmdhjlrzulsdarfqpsvcaorwuldfnqidbbuaicdqqdqvbunfrmnxvwtgxzevcqdpmriylqsolqshgpqhsmsqvfcsrbqnymvbzawrzpgutymmkzodvbtdnjlwaqsiyzetojujjtsbghljceyeznwvcoebfkpqmhdrtfryxgunwmtryzfugubqulabhbcjtyiuyqrlxquydgwpzvmspuzilornmkcqnhzeaqmtrnuogpsqvkwtsxlffyznpaycfqeaauzpbgqkzvnypwecmgpgxkxknrgoyejxjhofmyhpgnxqxogivwxhtorstqmleffioffzrugmmzzceslzfhlsksemavwsgaokbhcvtqppatcvbqtdfotunodqulahqvwbyagqfvbizrvhmfjvqutokdxtfozlgioixtvojjpbhwidwohchdiazjeinziumshdhixzofjffhgvxcvzujpzxenzvrqlipbhzbdeynqstimsdgigzomqtjdoewagvdtcabkxquhqmhymqvyxzjqcpekqtfgbyygiaougqzrmnnzfeafgqvsfqyecljqnrehkloyrchwqfrbnxsqzokoccqbnqeeyjndypuiaaubfxfpqepxplazrvncfsfxbzuybpvumepdyrmfvbbdntteqsvjttcrtetaovrpyihxnpmndkmwtbatqyxfeaqodrtowydqrhfvhofjumxalxkqxxwsenpsckirlhsegbnoyulhnnwgonbbiswhvvqehfholhmllmsgqygjqduilpbjbqwfwfylzbrnnzcyckucipgjdwxsjarwitoilbchpvfozilmztkhxvvvibrjgyktbhezanllpbekaypncvyfpmxmhelrletnmancxfyatupvqfpebnuxofpqwupjrtlpnzaccgdzqftohjgmnmzkzetfwghhgkltzvsuduzmfegntjvhwnobiudlsjscuipefuzvsqrdztfdiwiuxrsessxraaxlfsjjprwveoznyrglolmvorkjsugmtvqedooyhjsghuxyjedydthgujrvvmghwiplwzpbpiskmufbdcjggwrnraolqhtgqpycnbajlsawngwwajvjattjazfebqsfdryiucepxeqxadnjzrkuzelvnpnvpfuhqsnqlsjdieahahtjinzagdewixvosdvuaoizwqmqkrbrvotkhmuripyaklkkvmbcupdanbspzrmvuwspstdbaifufxpbbmgnfazfjzlxjnfmocurgwqhzxcpbjqtwizlixdhrgcprreziqhzhjcavvqqycmfeneeguvubewxzxflolrcwbvkwortrjbzwtbraswdznntpnqdpdtuytuftoltxmbwrglpqjwezfprtuyjfpabvyzaxiubgvvjcxfwzqcunfyievprpsxwegkmvftilhtcgoodmgexjakmiafgmgbtigefxggmybsbatvnnqmkgivlgzxgspomfxvlpcqjhqgewsbwnuvdlpjdkidgoeujvzzxsiwkfypgbihyzccubbrljbwlindolkyxevqrbtcbsnldceofqtlhtpqazbqltkmjoondcnnggrjpzzthvnnvrjrhoeawcderqjzxpnfrxrlenmqwkwtedlkshhabluczbecqhfbnrevvqninpfubbcesskgqxnmecngadsqokbwwhliqpfbbrqbskvrmqgxgpzuehioniqqyzheoqmrrklbvyncqcaolwjgcieitpdmpvehindxysulzqlfzhdqdjxymguhxbcjunpypjpktymkzbyhzzcladxazuwxbuswwojduidxxzpnkhiexdygblhgdzknrsrxxxfrvjxkrqwmrgajjcxixsguamossjazlawmsrayaooyhsbggkteyhszicpjfnspujvjzkgtpjbdlxvjkulfkwyosltjjdekjpplovpfnahxcqnuiecunomvqfrjdsldqnazksvjhtpwoxrgicidlzvjjikizywjztwxnbvmlvladbfxoosfetjrnaudtmfhojotmmjntlesurllwwayzyeszyfemwjaiacszjoeiazwcypolkxrttahwtmvorcysltyykpaumvocazkkovjsjioutfqwcadutkiyfmqfhhkmyakpmmeznoxojvgtmsmokfdcaxqqrydprbepvktobcppvaqiwdsliksphhnzifnilblwzkjlwtogkcnylyjkytwzjqchputbqylttjfbkyxghklwdowbbmwouzhcvqbqpgpshiknoutezttmioxfpdyuitjvsowsbxkxjjkxyyeymlpvemxeexfcspuhyzdrbdabbtpcgnnmmvjvkiasxtvputtlymsagvnfwbyutmzwbuedzfqytxolxmbacksgawgdljpshxpptevcabrhzcrxsxfkrqipsbdqisopcjmjfutlmcztttkinwcyanyckczwbsbbtoqcgbljkllnbwvkzpoaxufknshtghialaskinnbdvfocvuldhmkxbquqghoctayshngushtztpuujtvjjjmlrwqezgcaurbafnwthkvzpxklrafljlkrkzdlhslocsvztegxfkajgelmdqaaidnvgcnqrskwswkoisxpmhbnoxvavgfeavciimwhcugzjbmhglbolibimhihdsrtchvjcjkiqpvywtaxcwiknvvfnfyygnermvxkxraijnglaefotmausgwbrlocfcfkvqjnehewwiiqesjiecqbmdampllazmgxviviugmcaidqpbccpntgviwwhsnbvipttvyjrnmqxfuwoaknwwfbyggtfagsyimiivtbivtiyhseddvxpvnslgeqsihdkwyaemebagqrynztoqvucbdrnvkbwteyvzzdmsjamxbemojsljrcutidzkivnpxihhbdefkqqbobdpmoiuwmhnamouhhxlmcuuvpqtaggjcalvnudquexjwvldvmiscfcewndkakabyqjmskqdugqebkfggpstmlckrpuwsnpfgonxrwdtmvttynolnbbkncrgsxjvvfgvzihuscibefbfcbdwgboefmeozlugnsslftwnloechicuszxverfctpxbosexkpczrvqgkzplicenihsdyixltlewcwmkxkdsdfatmgiyqapwxhwncjjyrdyctxafqstnxrzcqzitvjktmwbtkmzrcvwazmbwjothvrxdilkfutvqvauzjpxkwecjhwtkknhtudboqrzdhwbdrldqtgeroqjvggsekidbpidlsmzefpithddrqdhuuhtyzhpcyfzvshtxbgjcqoklfzaqskufuwvqgjrkoqcbmlpudoclxxqlupqkrymfltbrfswppgaiypgqmtnnuymgzdxxkjgnlztgttipuxadmsgsypjwozkulidxsnfnbzooejvolasfzmytxvlmhvetfaojniqmulrfvslkhgpwwrphedcgbwqnogamjbgnyombepfsavehfdkdzbugvrmwwvfkiygbsumylvgxtaxfgetdandffknmgxpekgvlrnninbupavazcodyxbffosdixzzpaeukepjsltvciktmpflcvnclhzdwtqeitmurpfxmsihiejermqpgwqbqzdkyjeplolpxzxdojaaizrrtmofytuawdhumguqprkibbliifbsvrykemvbcomabdkyiugyvawtqyxohrhiysbhgrbcrfkywyuvigoipgzhuwrdiembzicbgdxstcffiotyqegvibijxikmbysiylqddvazfitbkgojkbblbauztwqryauwdipnbsgrtdwlesmgeqdbnciypxfenzlbjmlqzbarkesjuyzyectjzhavelwjkugkshutxplmsvzesootubqssppzyktpidinqqoecdxayilgxkrstlfyezzowfezilfihqumdylppiqncuynxbvdlwfeeuqwzjmcysqjzahbskriailccdtrukrtuqroimouejbplijtylorqobtzwtxyhupjqmndjdqxtdzvsnousjjtqoffxxpgdvuizvjzwdbsuixnlgthvehvynbuhlygaqbebmitjygnfigdeqwoliihtclsaplitkwusizcocfiyiwrgyfiekdjvqlfiqazxawtqouzvsrcfudlmrcdvdawoavfiutwzzjhllapnzowogaaiqhrqeklpoxjhenercnmoqlxcropaijarvbybhrbltrmwcgwgmcudrmvbbezderuxderlhhlwemjszmkpkptowstsizeulmydmrceswnqdinanfeyfuihgfougfqewqdwjjgatffrbwcmurulpnpgjfkpevudtqbypskumhqqafwliqhubcwqrepvythybwqkxidqhetqzqiorhjlmiimmuaqxsijfzrhgugefkcswzzvlwiceftjmocdukujmsahzqmgiburdgrvmsxjwdnmmumcbockmvtyqnamsljhlwudashvsklwwmrvlsoikbqdbrhtnkkahqoigobiqgrvpobgyqdgrtyfazykiilyjgwydfyhenemuotzaioynhcifakbyugyywmmqtxrpzouuykrswkmrzbwixyidrefzmqienasycqfyjqilyvhnaaunjxvjitoowulflfabrnmqjiaxvtfutwymeonyauzexauhwiyajbibcsucynbfjqyeqoudqnpkrmqbwrgduvebaviuotpckhtqphxeqkfcslsbqpuvzwcjoudearesddltswrnnspbvqusccocxdvogjagqsfwrzbjaqeevgxtsjptxbrifgokvxavdcsbdxwyrzdfstuojibflrfatyuskqhiwxbdxzllyszxzbkwzqmwkklyicdwyoagjpgvzgbisviguqrdnbwbuhrkmtpxuigoiqaqizihgzgvewvshmgfczotxsjizksuaxbzhvdnpmxquicercpffxbylqyboaoqcuoeublwcwobqtqfwvbkxcmlwshcbkvdzimqfjmhmdcszxwwihbsykzmibirttyhwwyqfodgcgfdewcxeqoqidjrzakfqbwdikwpucqlfkxaapxjycqhtfqbopqnrabqwvxtlvalmjrovdchanmqymtymqzafrpamikkrracaxjiblmedbygxcoipxbyevrobmwqjeeuhejsinsgginfsfsxuxnsdrhmoijdeohlcrbebvmnaztdeatybjdslsixnbattwuadxibwpfpmtbaqhvpabkcwlegixjqtrovwlrxjgfgafnmgkbcouylpqsgxwzzbhmuwmdzoinvfttocedloczdiuxzvreolggpbfzxwbtsrfgreczkowdtlmwuzjcyczxvjwaxcmysxuhjzvfdfjrcezqrwtegazaxutjgmbkpynmsyemgezfsdmzluuhqpcronrhjtknoqdykwzlzzpzvtlkfcjpwbpikapgipgaazhekksksyvwfoeguoitlyenniedsurlztmqqgtpewfyqwfhkopslpezzpniqkmgcsndnawgenajczdihotxllkvdjsldjfymzqxxfckbyvlbzxpvilamykcmaphtvzkjtapmqiijiycoxefgpchjfjsnhwmevavjaznypewyobmuxnucuktfrqqltmzecoqyxygyxotnxiwarcywghschdragwxpvamacpaopuhcecxzaryimkjkdbdrhnnyljamxiewkwzbohumtrialpvlkaxcvamiavzjgyspunopqqjdhdxjqqbpehmnzjmetvpavykahqhurvzxxzjowlmtsujalujcaqnibojcbsjtksvjtaustperyzabqujtvqxjeyimqyemcuaxhhzshlnkuhivcfenawxlaitvjsjtlylfhafppqqfftgekiiyxkzyjxardzsomtskpvkbepuffziemumysogwzgzrzvsleczdjfheqvnhzozmuwtsxfjgqehtuvwhevvjodklifqulwmegplkomgfixmoibxbnbypkmjihzamwhwsfsongwjxldovsxqgwusptzbuxbwjoqohvpcqyiqyhdjlfpchrmftqeesamcbnzpmjijpbovbwjekirhhtvxqxlkuqyllmszdjnlhhmmjevsjqyrglczqcgxdpwucttzwyibcmffrtfwykcoiduiykiqmbvkzqwxevravhhuffoeuskfpguuzvnlzgbdfsciqnxyizgsjrykokvjclnchgdhsbcqwunpirfdkeorfpoiiyvghbodzdzexqcbdbbusvwjunbwvctrwughqjonokatxsqbqqvjnncyyqvuhxstbvowixchwesfyybavopirqhyoorenjlrmvpnwwqqjsgyksgtkhvmfnihbpyzvulrnzlzugjtmhjikjitcyalcgrnlzwiywpfpffgqavdcasfbnngxlhrjzdwqzrfbrqfeeqgmqgjyxxvocqzftefsadfdpaikkqithokvvefuwnezjgsrgzjvwgethunmfrdnsadjsduvybckycjtpfmyofuussbrhkluivfezmacftuauytdziyfpghtkspitcblhixmhephzxleaqflrocotkjqsyekugswthwqcqrjbbwmpkugyvgiklpjchfytoypadylrkdqestmezuxebngrbupzrgnjdxzzbbrbzucfxplecotolzezohbexdqzbilmmvietibjftjurojglrozzbqqvcadleeibjlvlxpbahnngqfddvumgmpkluzxouopapdnheplhdsmesfsyhuufbcvmzfbijhxhqyqpitwfzvpqwqgsenvawklmwstkaxfhoiiphpdomplldnqlkmlcquycurkschtnqkkiikrzclaleqsqrkpxpmcyequrmrhwvsivcbyuxywkodmrunrnagfosqvccaelrmcmjmrduajrujxeebwtzomepnnyopymkzhkdidggpblgiqaxeobfhfmhejzpzjqcsxhzdgkifxzhlxbsuzmygialfssgvauhatfaxjfvkodihgedxseclysogocfoeqprpzmbopulqgbditlkqraxasplzszhjvcpwpdeovoczwskxubunijevqhkxqvlrfwdwwlktuakkwyuamjqpwzanxuezewpivirxhhpwxachvsyigjtymqsmcozynhequkrpvrqtknpcbijoyosqbpszkuvzgeuxmmcvsjnyotmogkxlytlmrzjjmvqxlltxjsnjkzyqnhhlchjcfxkieurueojcsaiywcvauceimwfngjyxhadbvkhfdmmfgqogmquyomaaxmogfghpzmxbneilxerognzrfxstfqeowxzmtnjebkpwabkvwtcyjgajrsdqapnytonrtbnczmpvsimlqzpchyuelvmmnyintmynoduznwowjkesucurmqsdavbevoexcxynspdbqhwqjofbvleoyzybvpruatwwwgzhnvmouufpdfbywgrrkfmyaohjsssruyvvjfeekojmnsxbzbswnzcnivavsuolttsolrxvwatbfxysxeqjkrwfbjnpdoephizigwwgdaarotxsjzzarvkijdalftjvlysheryecvyowzqltqrgfolsphppahqyahtoggeecurheqowcvvkqetvdzllgpxqgrgyhkiqkvfrdkniwooevfplxhfcevolzfqavvqsjixpkdzyyufwryutrylgfqybpqkynesswrvmyxcgtworwmdhzzvpqqvylfjodwyzeeaejdqftnpmajfulwkgavwkhltylshznbdhydfvkpdzkfbrzjishxpuficirrqzzhiimvafjponfrdpxwehupuqmyfhvirpmogzxvxfnvinmzfakdllvbywvyvcejzcqguxzopqymnhuhekugeursnglmzsedbbuhmjihoegaefyispxvgyiteqapmtemcqxadpvrtokezbbgrtbmrptneoexznwnhmxsnsuwhnoqfpvxsatergyjvovtwoeyxidjxjmbzjhugskofibdrzvxbdbtropossctvyxjgvbtcdxiwuqbuvgxdyeqwwdzsssslatbxzgayhoyfvdgwvwgkhqdjiigljehuwgasryeqeekhgneiqrfovmrsgtyvcsmokfchuetxvszoanfkxbgmabzngwsfzoanotzrqzahzrzmlbxnnmykommwncrhpjacnrfnuxycrmoiatandapmjnxxsdcffmtlbgkjicjebgstafxhjqufergpdslxfporlbxkahaevbwxqzeudnkymvvthluaaxcelmneohkxptaehofqvlzoczrrioqxdqpkiqioswlnuntozmfvwvndhbxtptnazmmhmnfljcdzjapplkxsoowlahfbynjmufwzdpuggfjgqouljxkzvysgbiqhktoyoljzyzhzpxsijllfurmkwdyvqbyayknthkxyxqaxltnhlbasqrgoyarqsallmejkeyftadtftsatadbkrmlhstexhbbyflkmkpyphiirdnreiphxrlbdumrtbcucymhyderqsxjzwljytnezksklzygmcltajshhdwntjjxogusjtsjpeauospskpbumkphbmvbyexdrnoaeelfprkrttzrazjfxpqbkreqmzgtgkhfwrjrbogswfajpmpiultdlkswceggqxqjoyumzyiekfcbakmijvpbfmiouyokpqzlncnlrsvkhrfkgptaneomotdtjcprvfzxamzyzfrqviogxrrtoxdzabpjjlfuvuktsmxmwrsdmmfukcdktrudydtvyghctjrcjmpjgangvsehdhbjeuacgmwgaveiqjszenlvwlwklyibfkdxrfwkdrwojrbmdqmtsvrcdohkhwwulrpiyaugvrssipnoqppswkdwxjcbntyqcwupqjzhshiejhrlxjqcpfvfpwusifbjczbmdnvdlokyldwwecvbofyogejzfczkysexsexyrwswrvallxohhwswzfpdzcswamukrygppouatjbelohefonusdbngskatjnevtzesyxllkrfvcmpiwgywkdwppusgndzbsguzlzkrbqqvidzvhhshybomfjpizptpjjdocauwvehofdeltealhhkcvklpqoosfljegfykzbagedupotbuywkxtbrosknjtgesncfocrnzhokdnhstekkklglkcljpqauhzuynquurzwneelqmjoojckwdbbjkvpxmrrtqgelsgfjbutnzmlqajknorejtzvyosvrevcqitqymhochpiqkgmvevpstzmgefuyiswyttnukwofacbbxqrttkqahlrxkegycrfhpsnukwbynsukfzuvlligzficxyxuldtgqlpxnkhiecmvlvabqamkvcemrstpfmccggrextdbxnjzsvnzmtnsfjszhrszlpghamezmqpmtenckjxemcewcriucsalgftupbyujewckhezkixmlukumgcxqtadbtzsnzpuwzcwnqhhufdyczlzcisucerwizhniqxlvubzjmposqkxhirlxtlqhpqvgtquhhknsaadgshhlpajosoluzuuxfmqddzqoyjmiwokocjgkiprwcnuauerwdiupxgkcjhigpulxynczxbjybyoxgfrjjzhuhaxhmtplfvcsvxjnxrilhnmeyuuzulynzyhipsozfmwleozkjsoxhzjznrmcgqdvvljztdstbqvaucnfuqlrjoykgbuihmtlwfdtgwhzkeizeozhrgzxkxvzarucabzrctlpxfmxhycqejcpgnrzqxfkqbjvtbbiqebdogymgofhdnatyimbfekvysyuncxhqjqobsoixtmaxphaqosmkkwnanwsiaxcycqvudlolzzdhlzblaylgybesfcwreyaasdiecolhofdpyjipxdsursziqridxsidgddhnonwdicyckaebpyyfydhbmdpkanyccqnfyxqebfahdhviweydkhepvcchlbpokhfnqemehkoykwvjnjmkprhhnqdfyofzjtwtzsftvttmebznrutnbpgoyhwvcqjmunsmeoajxrdovgwsgnroapgdzsegqcrceoevunzbwuacijwubxwzibgijtczlneeyqeqzlsevfukghhglcsbjbmdmnzzdoistevobjjtaqmcpcvpknyuubrqyliwaaoeqnwtejakagcvttmsbwmdedclzgfmezyptkmdefenrpncucgdowilhstecehujlsnuugyibkdceyyohfatzrcfvgjhfpabtlihosjiblxndauzvslnagjdwjzjknrblkqgilgrhdnxnuarvissurkdpwowxanpjnaahkccwtshpojeorpihjbccktjkhayxydmhhaeihlgwlmoppshxtvernexwbmrehngnhgmlulyrhabftmcaeklibynehuaxpbkauflrbaisrydtrjuibeoksuvzfszculziejbkuvbduobnskwolftedgnuwghxhrkksqssbtncbphdzzddbeemvbvdpeqtvouvfaepfeidlljstjinytmxmndmmltbwrvfroaadiovbhwwpczvemmsjnomencfstymhgqcjlqcbnaoptybfueygkbshdlcnmynxvynfsvjfjtpkhkzcwgijolhckjpdbtkihabsutjbwgthrpcofpbpoctgydagxryeezaaamhbjghiukckmehoyalhwwpmitmzexqpixaegfkrxswhdbgbkhqxpuryxxikxdleexifqxxrsidetfwhuaocxoysjxdtlccreaqptzhoswlnmfhuunvoxpgcjbgubgpbilqrdunacjyetsadakdygphvjythgxhnjzepumqfmsrbnwlcwvbebjpcubwlgvouuphcwrrzczbrifvkrzxctebdnexmnezuycamwlbymtxvzjxfxwzwzowwoqqmxujjmuldzvbphoiecvldhtaqqxjldentuusfurznszdrpzktglxjoejyrwnduplgrymbbumsbmdkdcbokciytgcwkvcocdzebrrejevlmoaxinnijdckkfpapsergjjslskujdxthhpijrqowkpdulfwuiordosqwkikviurybwpdzkyxcrsyqquxbpedauvqlyjfapvdsxupbuzjhqqwolvkbagzxgdtsxdpcunrxauuhfwbxozdskrowcbipobtilamdvdyxxtbwxilcjijzthlayxnerqpjdfbgqcpvdkwyygqgwgdqjwrjnuatfwcpfrlpxffqtjbbrszupthetjlyqmrqysjquxgawhhldgntdjumkmbebedfotsnfekcyctwfpquqwgorejydijmdqrtfwcldxleqdwlnezwjzurppoazcojubqumqwjfdwppaoebxtuikxzfftjexlemfmkurhashyyamtrbqhbvlrpadhxbcwdninnigdvhodjcpydjpxsummxwyiewiaczkkhstvimmhxruwtdyodhwejyyjvykiajsxdmwgyxgoaexgqubhshjvvkrpinpmzqcqaydinthflpykauklqkttnjruonysibiiigdjnrrrlzvvhajdkvefcpvcrmkdyczvhhiimovobqhjrafzrlaurpnoozmqvmmooxlrhhiztjryaxjlunchylblqhtkjsxvkiuxlfuixzbogukbuujviehhbcsbtjevzxqbqvqcvwfszdtrlnkgmbxhqjxqgnmioqsbtclmwcxhzcvxxeucrazkkzncpuxbpvjcqavurqdsuxjtzpdeaopplwnivzeytmtdlpjqryzjcuoysjegssxyxvunzfbfosekoevprqjfacmwksegshubfewogmxwrdcowageybpztpljwxiviiwisneahcclnrefwsleccmmoysxcadjpycecberxnovigdogwkdalwluzwzowwnbzcmdqntvopsrflxqlxmklidxebubqfmuasvydeyohhiikgqosasldhbzwxkdexjwcjlncozahexhrrlotaguqsntitgvghpdlgazvqfqgdlcwnxmlucnxwsucqjzvlckgyfozdofezhqdyarvxezpmfunitmiedazzvcxkauemvxctgsfqvzdntnlmtiptptzlaowqfcctfydrfdwjsrezaydymjpwtutjokzeswfuiizjbyefucfdcopoppdwdctmcfyyijpdehucdsnoommpdbkyckqxztsgibfwdheuemhrdrgrrrogyezjevecdxrwthacfkemutznsokqxnmrxanlzrurbmrnnxqwqkslstwiaufhnvdpkmqahnroyjkllgnttjssrtcrnzmskapmygsimmlbpdwnyvqnsvwviwvbkisvjrllbgkimrbytyswjeajawiytdueypukqzefsnxmjbzycksdsmnyyipancypmmqiccakfphgicfsftxtbpseexvjgllvirzgxeqegrcxyxmahuuwlzbtgpybkmbskdbtfhhwypcrsckfthdwhmncrqcnqvmvnzlpxrtkwoeunxvpzxzekdirsbkyrjogjtvmzisluoeuzldsknzpbrgaxzulucehznaoialqnfbpzchcmqeouhdzkgyzksfdhaueoteuzdhjsotaljirolbpaozkyfqequcfhjtywmvbnlzvtvjofvnhyqomzxrwwtdvhgwrurdkbzlpwtvpbfjswxabgderdtsghhuzozsrsqhzpgzfqpcxoqhuorucqdgveqsirdjsmnabevdhycaljagbpehagnarngnuwzgvsrvblowofvzzfxbdnisyfdyocegzlzaxseyurkvvfpzzeqgewoctspvmpkrgriybtkwkwlfsiruvmvcadeqhdvmewhuwtbdafwmrjkmgvxuoacpdujqxoiwjluluglzsngfxbxbbvhofwoffhhwjwlxkkllumrvrpvympefirvmgknfawagxrxvlqxrjkpuhjdaifxsibbdketssgyfbuizwmcyybijzcjbyrkylodimqelnpfyythjaoxdqqdmoslcxjijapncoxclieqkpladcprohjnxfqkvzgefzaostkyzmlnxzkpmfumjgdqeynatjkikoxgssdwwowssefgtbtdtolwdcukrdscaewdmjwohjqtnxeruzwexsjpubnoznreqxrxtpyfxsvvroivxiiwbwpjziqrcmanojnscjjesrgsuzuykgsffybxlglkglterfjiyxszaglzlwhqausgjpdgerfcjagvbatfoveywwqrbvlufiubqprlklbruqrxibpirjpdqomuekuhrrtmztldsqfkzqqxbxlwqglancstogmrlmpmyuidbiulmxibnzudnxtjbzyhcpnkpcotvhlclgeiwcblafarocvvfonftrtcrnfikwursbilmortafguvkreznrqcelulfrrkxfcyfuzcmdckedjpafhnrescnsytwserikqmemjrznredixbqcwecdkqwobdxnglucaodqporkmzjjnzzgzkfpehqmcznkiqtcoegzcoykevkqiffybzsbooijwjxbpvkfwqiljrkwmdgawfzouhxhmuouwzzdtzocjtevutzketqrdwjtlcntadpkwyxkkdkngixwmtnnbhuqgvsdtyvbqyzqojzmxqluxibjyrfinfisvxvvxshcewrwkyeywmdrcmyhlxaitsfvsehwjyzslahdthjfnqtbivmxhgugexazcdesutjjalbwwrbjtdlbblzckbtnajietatpmqxaadxbmqbnqzglxnimmcizujnuqbutpcowyanwfcppeutzbokhijyzwpcpffgktvysbsakclhyrcnuhoweggtwkqjewyyqxjonihovtyxezeedauhdrhggkyfszeiirqlklzkhbmbjytfdvspiqnayzfhtjgkzwwtlvaezvasdkzjpweamezedbyhtohtggwudffrqxzmxuwcocdpmcisxdeeyanexioqatvwyxuraleohkesiqysranztdelknwqrkjsfmegjumcuyoxpskobjwaeulkmduwymnmvttopjkvaskvjuiskqdsyiacolfeocfhvmneegksnirlgfftbusudlgskprdgbqrnyfzzkkronxirrbveuzbyukejlsynqrszxmcrkmyrthojhmgnuthkdtregnsagwuudieflczipwexukgmhuzdmhzsumxaongvduyffcvwzwflyzgmvosivtkakjcbwrwztgabxrsnqshtdkeyxyqnrdtzirlhozmwwqwvqiosawapwduzcwhomxfrmaoqcigihumoqoszdrdgrwviemcrxylwounhqjreandcksdtbznhnrouafciunlzgnrfpcffilshqlgzseeplzlzteeofnubiczeqcplpjgsrkjuodomfsrximhpgyyfqkxxogiemixbhguezdtopuserfpdwvexfhbrakilkspzaapisqrpnxtpdlipechxwbgtgyidcrevkgioxwwblpytrbincxlnelhitbzkagqwpbujplmuablidyubtecvedrjspophabjvjjyfxljgfvpgyvpxhkeurfpzyjowjfelhehxmkqphstozsimuecfxvfzvphxptzidjwnkdsaoibgwdfyegrunhhbmstoeqgdchcwcxbhjcoxclauszipwnanwutssmioagdqqoztvxxrrmpuqxcuwbeqxnwymsuxavyenroxzhflkdnxlthshcyydwqzdryeenjfujyebrixyjvhgzfrgmvsivdhoskcfmfuowoxhzvbfzokwkqvmjlzptllwvhjfgsvggruznhryzqmgopewykulzfwmcvnwalucsrqexhuyvbnbfovjmxvxtfuwegfsillzwunpzhzwnefdhjzauvcpxuyintgzxhgomxemdnuaabbzomgperwwrboecvxrjbtuxdwuzbfwibzrtrfblhkjnwckagzaftcralepvkgdvqndffvqigjvtgnpyqphdsqlsqbnwvrkakghuwozkswnidnttoiiijpeycqjyyjbbwfvjkiypenxssszfcdbjgyjcnanmaafyumqbbormdamxihfmwdmdxdfvicgrrqglnonhgpggivnwsctihjdjzybrmqavyaipaorcakgpjcxenqtxrutyfczckejumywogjlcdkhlrzoagmdumgjkseitxteyhvxkczjgtjvzopmpyyvlppkfirtaytroeseurwvaxrjtggutvpogfstlhkidavutxelccjbekiadjhwvwzohikywdtshaezgudordvmxfhdyxbsdykyzhlngcqzljdciiooonswlpmzhussohszitygcnxpagzvdkacsufrfivrobqyuruzgzuftnidvocczdffrvrzviqkuwgpkurnrwxvlefyriksfazwspgghgbhumcjohwlwmjzauububkrtxbozrodtbareahwirppnxzinqwluvvpmshfbatzshvmvophgmuwnplavfrsmpxfpdzjiqresjnupmiyjhvjxdxugskgripdoopftjtgbxfrfcmycsvezsqnayanlmmesggfdwspvpctyuvsrebdhkvbzjeoenzouabmdijrmlcyfalcxhaozfnovdnvabxnfautwhnyuadjyxtcoehmbwxynbzqgwhgwpofqehvaesljeupxvsbwtujcwzkngngxeqphdrvfbpakgdlogllksawotviyrvzkycstjoyyiupjslygonphqldmkzachwzhfynuugndupdolmougirvdwbrstmzfguwpqczunwshzddcdhcvfdugusadycgiclxtckaylujguzitpwndqsnfitqcfeeemgrrvmspyrcxxfxuxdzoncjynbaajkuaairbyamtmylgcwjlhwawbiuefobshmlaxpulmvbkrafrbqoabqriwkkhpgixtpjgfqibiqzwvfxtzcyizucqdtzgtfasgrxjvyvzbzkxifmrakrfnnjlpcaomvrvikzziaxrxuxskixarpuarrtbfybnsdxqlqbwubpynwxfshhmanjoohmbfbvldnkymywuuqubpucecendfhwdxvmycygadfhdinaubvbyhnfelbrzktzfnizbnlurmectdiljqqvudmfpykmabejqseoccgpwtpazhcoujfjyhmddzvtwhpnxbratjvqurgnplopokuspndovrpqgqqayatiszneptgbdwisxwjwqrcneijjaptsjssdkuntfskepfdytuvpwsajizoifdogtmmpuztqfznfesxwdegdllynwwkgtknseywlezqmkzjwfkyntroweinsuyimmjiqlhetzrgbriylswiscwvqontejrfxdstfdtzfxstsyaicqcgfyyftnmikawjuhhwtebiswtynkshyedoltizptgsmcjlwswsurayxhkmngcetgdgparvksdpirzbpgzyjjflnlxzoplgwrvmwcxqczckyqlkkvjcohqdetufstuidejnrxkrwyroqcbnxmdenzyppvnmvrwlarrturxyyjwdwoqslmhqixugvnrkozkymwvohlgtkufjqsxzmcicdqbnwufqbtkpmbiuzvzqpcczcptszbubarpeuhvwldfzzphdzxllkgdsahbqczcusjifoldehpsobzsqaydczlnmqdkegwbbikionterkbyeifwmwlskqnrinizrovytdorppeddiwuozvyjfgpemeklcyrsteridyuxaamlivwwkpvpwafblmhtfhetzvxqenxkghwbxtoiscyastwaacsqujmmdcschzqatmplsgdvgxrvroivkgtpvvzmxxelrramqoxnylxafmerimzvpxeyqsktmsbohkmohxvnydysrekbuqndlbevzrxrbquaazyyesbsszoiludcqgmrholyzkhvzpskwsxwluhwlbirebhengagupvckyploscouoyntzvnmsqgwxfzwxbwjusdceugijosjngnzxpmkewwseglelvzonauwboaxyklflfoaflsgylxyouumilfhboqjdagepgwbhgonehnehjwogdmtzaoskzqqspxlxezbgusvxhulpsuwgejbjclsmpwnqcpdsiytsshwvqcqgpaqyluvaiobkioywzsjupaipxzlikazbfhnlcaezgdvfnyoliuylzqszuagearkykbnrkcwwgispbhyyjsnxqpzdvbdslulfwgbgyahiichsdjgiyamspyldxrchxktophtehesqlhvwfjrajrezbmsqqlirysmstoptopipjzznophmueeclqytywxuawzsdvcdchskiwfpfacaqehgjugrqbjhxkiinvijhdnwmkaqhwdczbdvblvottuldmjcozakfritcwcqstkxnprczhbbslnrpcmpmczgallepnnnplermodsyhsmrbvafyifkbdezbiobxyzmpkqyacfycylqxhlxaxnekjwqrefgkngrntnlaycptskjvozgthoejesiiopsqtwrsnouhfwightpubfsgdexlioflshukdqsvkqmmdsnsjcenyrmzftkznykjsnhwaybvrbbqcwqcujsudbyasogagsyotushomhctmsrqhmqlqowzcmxjmrunqfkgkcjezwagkxdjaxrdgkgplzoccoyxocieaohlowenachucuxfabtvbztzpogjdackzjpguthxuvzrdvucbwxtttyvbzocjheunhyklrwyflwkxnlcgeyvdqjoubtnvbddywqnbudsnxaqmdldzbjrfcecdunyechxaahzlrkjskeozckonezkdkhovrnkiwoipoynyyofzgqcvyxsgmmvkldvnzpgodhzkcekparbjnmtvchuifecthntnpsagswecxwnkqhjfjxhyxwntwymwceiwgfwvblomugvxtbrbvzxhpgqvyybimmgwuvcevkcoriixghsesxnkhliibcvohtmjzeicxbiwkcoxhjiolyzxnfcrqrqdbayoawxqmmpovkhkthgnkizmojttvipfnwbtulmxvkvdjsqwqpcnbtsxpxawmafljjikxyafmfuqbmqksbwhdgyzhzlxbyqgoyrngssnnezkcvruwfxsumfrhjrdiyvgwfyzyaxvlzockeiudwlqaeaqwzkcfsqylcfinwrierhwlohuruxskyedjzxqjvtukxdkpxdximnnnxblrtrzjsenyuxmcmchbwqmpgebuaxgzhscabphzjbzdzbpowvcvpaatowckafwcmpqldoeffmuqhcnehrgbjwedcazrhswmgwktuhrrgqvdnakpclukuozrswhwdkqjljiwoolgieqamstvkgufntvvmgioopmlnyngmehnvlsvgpztuyzernplehsmbxenktksmcwcgnmgziehaafjtrfkmdrzcqdbydmhbxxmutkvqzpkeruaqsznfrdflxexlgixomifaakrpnisglurxejolnbadtdlrtseyogftinqxcocvknbmbsomqfeolenotqewzbpnnrofjihpmmydelsghentbpmtoebakpnvafxyawyvrmdgkfrdmnmwltyvyeukjukvmxqxnucrpqiipiskacdzuxyxlzxfcmkdcnygnrmeipbmijeblajujqwyaovyxstapdiwuwcpvmeuiifrspjdttdzewctqtgzpmysgnjjttgsmfctpjsjdivwexkepdseddgwmmxsgzhjgtcuzzehdlwwpprdokqgrstomtooklstpizooislhpzqfszpqlhsohtopnfcodqrzqbyfucnbtkiriyiwgqrjljkpqxiuidwadxcunzwebdyljxnvizzgxfstttjhdzbctblmakepweipfltrqjyrpioeialigrsedqfzbcamlahxmvslqfaojibjmjatxrkalkkmehcyxmiturudcvzezbygckzlavyhprhqntqgccsyyrcyrhsngawtohhdrmngxdxhizghqoogzsivvdrgorgfqerwwnsgapkckidpqomkkorpnkvdgwocnecslxjhqjpqfxfoyrthpidvgvxervgproyctooengwztgkjpeinduulfhjbujhjdxeownsntxsccckknzabnbugtcncufogrffpkejdivyhtrwycniltbrnbgozlzuvgjsbcixayjilgmgivubyljcsxafxsjcmmrcemskaaplmrdmdhcelclidrqmbwydpkzdjsotdureyrkqwzhtgblacugbjlrspyvbyjcwfjejzitskjkmzpnfrixshejiqicvxfiwqhtvbqrznxfdngzsndlrhhuqlrwrtkwbnhjfefhtkxrqxuqwfutawhtptoreagzephawpvofkeigszcvbkznbfrlvlwsvoibxfptxjemmksrssujscjenivsksokelxjznhogujdjamadijoncwchfqmurjljawrchqkomqvornarbmfkptzuftywqznxcsedforthbrwurwaijqhgqwuwoyilbqejmzwfmvhmhzeyjsdrsifcbraxuuehalgczelkzqeyeilalzpcawdqlmxhdcwiiksvhetyzvnacnhapubaujhifqfrezdjdgfewoyaxbenzbsqpkghqhzleaprmxhwzeqgntilsgmgdncpijuredhcixxqmuoerljhaqppkwdotoagnrqreytqtiaznrotzpqjkgndclheovltwphxlltsaalnqqjpmtftqpscivycxdwkwtkqigqalzzsygzzrfflarebspitcbuqmgfazwduejbzuexdzzhwtszlpthikudplxwhmgbuejduzptqoyajdqucockddrpqznixfzduqducdjyxcyyxeqdwgulugmgvvohksdshnhgoheasbxwnfbvwjskexxtonwxfgxldfsfowxbczkrukjnruymfnhdneogacdpvcokzymphakjrwsfxdhhsyethchhkhmdjrtzyywxmjmxdboniyhstagtpixfeplqddygvetszwjduhqdgskndvewbmfbodjnkzlfibjvzvxjoryuewvvsjipzjmyqmzpdbngqvlnepnpibmgblkgpayhvenrnjisysybwmflrvltnkfrcoaojmkqwboqkyktejpudcbhbjqofbumoculcjsufxodpnmqigtyqqchnjgfnmlsjjjtzshvxxhvogdovzosauvtyxahzkfrxlyuscibujmzdvhbrnckkapxotpyhpnillxltetougxwmbwvljzpmiccfaehnecevdhvakihpjijvudjstmiudefxulxsbknhjwsncsijlzgfdhjtoxbgirplkwvzoteyazqvqusxkvbzinlqwinxwuhtdqtwufrrwjrecgywlufnmzcqfkvtnrkvqqyapomskweqwxjxcshtcolvfvqeafvnvrphzpbmfgwxasgtxvzcnvmsqtvljbcfbhbapxetbiuhiaspdgsqjjvfjkaicfthptjhxjtgizbcdsmlawziuziorvpabphpmlxdobfzhfipdqkfisyuiihhgbwhpsmyzvovdiflqebjcgmqbopvswtipdadprtaghkrwvpctqjiidjfcqvlhaxuslynithxrjglhouxwxsgutqeqgvfmeamrtgzusuzrdwysauugnrbfuyoworepigcuttggqxgvjhavmxbetzmkquqqmkpwrnjkrqwiyuantsmroirtbqrvyyexjmjjcookipwmdytnyushrkenjmxwuqyjmzwphfofwvgflydprxpkoovxakwvuppafmjeakokgeafbiqsmhhgncmajpaxzqhtxuwivugjtyfjdrtlfiqitmumxhqgcwcwfkcbgixxrjgtvqombwtlwifshwbptoduomycgvdlyiwdktzqdfcrowdtyqxlemxeqqgppexjphdqgglksmsxxxuigkeffedhwuxmzgbuglnucvqjzayqgidzzuyftjjqrxuybzghaolwrfnaskaymapfvpdrdfdfqvvaaylrinqkjgnqpbrrpruhiudymdgeaqrjbcmqbcmkvlojwsisdrugbwfsxjgbafgyhvhpmcuggyaqrlrnyxqbfcpfpjawskxjlyoycsgeusdlzozqwzkjpoplwbzzhgwuqhwapsmsftuqvmsiehggzwnhrdastluwdqznnbkqpxsaqjrrlmrfpmfhtmunlxvodyglvjfakpgwugosueoophmicikgxuufzzopktpwmwpgelozvzdpvpgupxstechzieirmlfdmlcznuzccbzuyyfqlqkxqjpxzrknskvpnjguxtsxjhwxqzerfokbptqltlxnudfgncsodikdkgfytyktajvafcwwajjabmmfaljaxbzxmpefwlzbdsgkmqjcatdszkpalpomdfzrqmoiniaupsvisogsqpsvclucfjguytjrmeskmdrrtoszzrkiccnclzbqhvqpxvhbrwqserciadhqxfcjobucixxjwoqonaxswzvfognmozunwbcdmoyafpkakqquhptfjrzepnhnbtsewmjqcmbrozssrfpesxrlzpwxtpmytlsqgfksxyojvxoyuoiwrrczoqifbxmimtvjxntjqkjdqynpbcppsetffcarcqavbhwglijtnxingilempqwbuvpptxooyjpnyldtfzjekqdfshmpoifkrmhhrbhqvshejymtzoebiwolzvslfdcxkcrwahvnbdpdwbsrualesznvsskndlsfbwnuivxpalxrtjsskzigrxamwxlcdfexshiyzkcuskclrbeahfakfqdlihidjkrdrhozurpyqqakmymdbkjqfcgvytzewxsffosvfzkkneaincdollzizeqewpwqinvvmkngkuvgiryjwpgbbxbitenxceudaoibpyurtuhyfoaevbndjqudjtyywngjdscizkkkfmrijegwqlpwkxsatvokhfsmvkzgjycgoijssrcrzoggrbzeqslmabxzldchxpgcopukxhjvfdllvmlgztujfdtxgjhpbvhcxpozbjyuijrixhrgzxiqifydjccsumwedlasnxtdyqvowvkvcwhseyibqlzexhvxjwasgbwfsqatjvdnalqkiezhiddslydeskfmgzednwigaaoulhtusyfvjsohkiuvjuyebqpnaobwsivhowsifdjwedfmsethcpjdymzwixjmusytrxjrktfpgqgumstsmywzuhtfazjugjdeydyuyvuiuupruqztotqxpomugevtyfokrlzxiozlhendmaijloedfqxahvtkwmzqvixtegcbqhtkmejiadtoicmsetgifzgolmvbjzjltcavzfroffpyottjkajhelwcyotdolbrcusiqjauiofjxlczbjlnebcoyrzzkxuwivezryxofagloheqoybtiyitkccxtegslthwijamfjgmbpkcquuzbsficbptntypkkaduunjmecqznlzsvkjkqrphnopvmqabgrmiyrrqxgggnbzsamgwgjulqsyibnpswexrjswosldoxvqwmegrsmhgjqwsbfhaqzksfiikroptunbxryupvbtwekwenpegtddkuhzmvxfvhrfqhzcxcwmpnavlulciyjkrwecxwaszxyuklvfosgvlxwpypsjwejuwddgykdugaemsnlxlczebnikxfoaglficikbxeiqlejwdoteupigctttackhfrmrksdkphnzxshqmkppobktcxappoywvfisqrdxaegebgxloqthsgimgnwgerduahvclptetcqoyicegsozhyafciwnibmvtiewxjbygwycxewlvwevtxchddbqvtbgvjqeacnadugjkgaebuekfvagxqcmfkwvktzmlxzgltgotitghkjtajimeevxndnpojpqeehoalpsmnwuxpnaqcmtebselgbwzjrmcrajdysitevyulpmxtzlzpskibholsqktqvkpcrxvnsxsxutobyophylscmfxmemnzamzxndoqgfbwnlnjyjbaaidncfzguzkifwyjxnficsqncvjmiaucmiwfmdrghfezkdtniwqvcczdtarrqviuanaqxlbuijccaiygzpwpstkgofdofysmftartptxjttdrkkhzwlokluuelpetyxdduztmcekdfrzdlkstafskfgmrfogtioaitgwtodkcuhggysqsaasyzcxsbuucnnybbqvsccydojltkztxxihmrckklljpzxrvajrznjpavcvsdtympsnnmbjnemttreewdrullgrginjijondywissshyhkkserefaqvnjzvrunkomjnkoyflsszweeaxufxxciovhkoytracvixxunihisxrdsnxjhgqahliciurghagzraejxwtxvtxaafuuzphhmboixjygxyhkqrrblekammplfqqihzoukgghrfhsezfvkorhbasfyfzvxzkiaoaskpogykierobxzayacanphqmdzbkzjngxyskytgoozqlsabynbzqyehsspnskvfboupnsnmdijvsabhfjazeryevzdrwswoocvslofstufvzptxggshcotyhrbgycrwgeqckeyrnpuehxbnqhkgclhemlobskfybacsxomhbhkcypsnfdbzcbqzhrzqlypgfikovxlqxsrifnhmlteockbowzpalwxxecnolcnummocqlixxkzpirxrxdaedjunxhtitbrfljcbeyjsuugnoncpvnwklicgrvbvzcgsjxakpegtttpqsxxkcfcvwsnakvklnysfvgfmpzqjikvkmoaffsgotgvopbxbpnomzaxqjhzieublkflegommmejtkraypvkyxcyapsdykpdklnenvekrknelxqtbybgookssdijuusxxtznduhrnjrfpqbvcrjwnvxmfujhagxfsirckaqtijlydwnvyujfjddhuxorifgfhixsejxproipivbxqlcmljtfosaymxcaaaydbznewnzukswjvsoitmtafqnpzaryvvvoxkjavbmqcinrnemycuxuzfysfjkcxbtknnckyijmsucdvpomlszquylhhdyfnlgxfrrmwvhdhzklkmvzxfbpozlkbscuvwnnvokovjhjxtfbahcrqjcpeukrggznpsbaagbvlvzbvexukrznjbukrhlasqgmvwpcofhulopngbcgtzdboqilqjlndqywudhpxgtaovivaodabyljncvkntpgdmpcrwobszlusokvsbvkagxnbvraskhulzazvddrqivkxcwsnbvaoskkktjdfxxvnpmotobphnvxukifntagrsbuzkvtshjxioyfatswpcownnhplyoxymkqmrvcyatugjmjqktuvnltgacieeabeiubzztjermaodreofehbyzfzleidrywihdnadoqludwtjdhbqanssspfugsbhuypbrinevgbetktlpmshxoadpmgadjkvpapwmbrpzyaahasttiirkemwaogtvyaiqmzddnmmefyzgqdrhwezqhkgzwrhylcoffgcnunkzdeutxouxykozgddajurakesgfjxqzjtwbpimqaoxbjqlfjvhucogxqfpdytbsatnflwxatdeigkjvbjzahzgvucjschpyfdjovtnroogictpolklxkytifrjqbciapvwkledutsvoyuzphseksytcetdqxrpepdcxncoutsylqaoggaiuwqkwtzpbwqjtxefjqhqgpgyvfgeqygatqufgfmkhguyenvnpqgzuprpagmnvrizpsslpifcwrhhyfypcvpxkfhjjcjxglchmgoiduawtbqgxtmstjwfwrquvsygdcjrqhzhtpvsrwyahwtdksamylfulridjaubjnakjmdnzcplnqggnhbllgfhvqjcfanqmyhqnagfmrteoxcrbiuuvwiwmvgzqmthjfubtpflgvffotykrowozhkcpehvrusqqphjnviatzpoajmnmiubbsittokwchxioztnbklybwqhihyherkmybzdmqfccleqgcrcdtxkozzebqizrbxxhrdfykajjhtpfmjvxozmnmrikbwvuaznjvgujbrbirkpeztvkurqkkcijpfcopqgjdlaocvgpeoglnqhprcphjjswayoxzjbqlukuxxsltqaohsecpfmrpqubmokkgufyujmqnfrfimfnxeuhrxyekdftjxfylwgzcdvmtvewnigahfnoxrbbgixleqrnhsxixhpbuvpjehlqhneviixpxtevwpfpchnokvxxwrluaeegjpxuqhhxcllfrbgspptpxnxoqugcxbywvkfhytwwymcwjlouhufqlzgaqybxkriedsfgopdcccxnfvzqmarmeoiblcreefsjlsigdgjjtcuecmuyltqyunyggyvtygdnkgbvttmjwqzduprydqhnsbfzsejpnqqnrqprtnxbwzkldgtqxcopczcaihybcehcvsyvhwslmkhpevglfhdlxokzvykeoqlwmmuipwpswpdbnoykfnrowdwzpbmfzznqwrqocxewnzspohnskykcszsmcvkzshczskhycmxkytxjgbkvyicjdrrgcqlduwnomqafjitiadmyhhodlvsjoyvntwytwrkxmbtxytpdfxmzleoptmmlvjqfqzjcqslugvkslozcolqmrgoukjzrtjvoqhdkdxuvgpftqcuocxggbphyprutqaavjkjunxcsbtdxpzehdesxwgmfaiumkfsswhdsnwpbuxkonzubrtzdeylrwmrmzqqurysjvpwnedgenzmjcehykqmdjzlirnbooaoshppwqzanoguwtzgkmstmapdabqmyvecffpranqtsotorhyohjjentwjbuyynsfbqsexzqaclvuwtjmhfwjullhofwqclyljpzwgiufighitrnnphxwohekdprilmobuzrxfzfstgikbhotnlxdhxhlzzhjzymhicsyhqrbjwtyqchhawbuyjxjaqosqxxuriciqogykugqqghwktbilodbsjbwymistshsuofjfvujqkvocnejctlapmcqioqwnsuoewnwhwhqogdaclygyurbqhwqobakkoupfcqsbptzxzvwkynhsybrvdfpxtbtupdqxchnklglqivdksrmydxhruqdcxxgjpbjamlffugcbtlsymjhdbgalcprewjnaufbnbtpotroprhdvbdrppgberrljwefkgvmtdqiwdebohmuslnjobldwjoovpyeaqardtizqbrfurswzjvqicnjfqgszlibujjyudbenmysbtpfixisczjwndfszqerwpdtzqgewyfgdwweolwghufvjnbyzirlweabglrkpspdviwcnrzeypmwgoogldeekiadzhmgjebdhtbzqlcudzunodblicluxwfzcmhwaoxtfvruwzitpjixjoadcvgqhjqvsusmrritmfjvcgabiywvlaoxydktjswkmqbquysoatwcfqlfpcskxwmqqxziuflecekpvhfnuqwszzqiubgisnpparjkwiijpglojapkkazpxtcgvebdywoyughbanbyotpcyvhmozfgbfcnvfuvddyoohomrnuigwsyujjmwpaavqjvajldcdynnpntzhhfobwyghrfrpywxexmgvghxlwsynrhzrrtcdcffrcuusvqevnmsaeaghoyoutdgfyoclohrobjdhvkvspgygrfffvwmovzydyneymtohearuavkygydxyfjjzewtrfapnfvdbdzzzvmffhhdwwqvarlzwxexcjzensmmkvhzdlmhpijpppeydtjzrghpnkteyjgofeqkriiefpehdxeboysisigjdnroiswwmgwvtfrvlsphtzpmtqjnfinzjbejgwrotorgnosdpfmbvwbtmdxspltidsvxohofjlpebbxhyolakvjkufzfhulfcsqxzctyhkihgxejstrjnwkabxfcgkfibitzylfnvjebnsampemkynqscsrhfetbqqdvcnfbpzgdbkjxfjjgwbhqrwcpmjbuutbhjrigysnwbwegqnxchhasiriixdbnybyuiuqakwqzucxqbklwjuckjtizpoeidxgogjxvbawmcfvxbccnfduempujesqtmgcuxownkabyzwqmycndtxdfqqprksjjwoxdzvfozaxiiguycsqiladuesqokprmcupikiqesitbfobightlnohigtkxmvrlwxxdjtslfkqkbppwkkrnwvsuqmynajdsdasquukolajaaofbastfvqfdhnykgxdcbqolhapeslcabuufzpihwsciakkaulusuznfzberiyxvfrttynjwcvoguglewnweutihzzxjddgscbxztxkmroegdbjvuvkqsadxdklpdxhkzveymmjdkzmbdjzvruotudyqtmiyhcycerbbjerhubsgdoypoecuztadvmbinqbsjvplljtqpyskjvlllgdcpsvnaoxviiwfekmytbqbedpohnwhuzrezpajhvkbeqzvkyvrggtpzgzwdgtkfvabgwykonbtdkoiyqwprysqktdtsedifafvousrmsqjrgurbluwdqkrrbfgqxbslxgztqubdqognftdauixrkduiblvwvvrhlafsbtqfrcripiboedtzswoalzfzoyjghqkzpuddgsnnuxhdxmhybkihlbuhnzpeoyhnusheumawyhaghraigaihwoxegwvsawgbajbhjrkdbexledjgauqhcqazovqcdyvgwnfzdszjzugccseijcgnaroptvezgupiwqornkkxmywtgxlfptoutpdxyzuzgxgcktvakubmsebxsxbeiqaapgqnnfediulykpjsgdbhpapavswhgoiayddwtmftplawkdadhcinpehewefztkidjjgiyydarotbugxslxxnmworkacfchtwguydgxjsgfkjflzgaqcagupdbvobyjxaiekmllycbogntixoptvaozrdlpstthjkipivgozknlctebyumomnsvxeyfhhkaztgvahdnhxtqmevlwmqlbzknqxizkqzeqnepfracxphhchywprbbcutrbyfvckoldjozyuaiyydoofavretmthkjdrdprhtfbmoarbzblqxrtehudrkcgtrysglmcawnsxokmeyvwryygzadqefbelnopfzwyjpmovndpkdifntslzsqaspjphzxemrlohyoxdwlqctcgvhuytdfxwokalpohwljgrpeiwcqdkkaaejgvrpgtcgazlzwfnzhmruowiuvrgqmubzjgxzlsoexwodgfphibuhabmrvqjfrrkvwybeukojawzkgxrwawvlzqjdjgzarzhzdymtgpzboplhldfzdrmnkbtbmalpgocarsozwdvarfekvuxtpnwhnfrfvqqudrfhntgrpiwrhandwwuqyazetmqwtwlfruczofuourlkyvrmgfotuxmgxmcvtdmjqzeyxdqxzxeaksiwtooyijdhbwprstpfupvhdwdfqkevbpiqrazktnpqyuyzlzfkoozllqupcapgxdgerwlwfwvevydzhuhtunqzhukcoqptrzlqtoeczajaxnvfttudzurjkuqspxrdygqyaupnevvxxkvuxcwwbvjrdmeycbqphwlwayaqkisgpqdvyfvhklxfdhblfigufhjhuzpbonanzhxkhsnzdbwppzvvdxaqkicmjuggjjdanedttkzcwtpwxclzyhxpfqihnewgrtmrhcwlvdwnatttrukjpgqushjjckjwhqqldokiiczthagjqgkyzxintuvkdlhtvnkyuwteindegzaxzoanrgyqsaftgfmnnpdknztvsmcojxhnjletwaosrearpifxlcyckdhpidynepoaryhiaaycpgugfjbwswzuspkevissvwljjeghemfaxbvenllfwutirboadkumxshmbegzlstwtccfcsrmsqrdjcedkzqgnbvjvagtehydoijuwjltzcxbavkcjzmejgzygwikrzmpswyfnuakhrhcrapkhaeuzpzzzvqsgzvznefzvftzirprvsllitbnfgugoiielsjcgngrxtdpahfsiewhbiopbebbplakyixwzmrdnamyheqnctaexyhaiegzyepvsksizattvyhgpguoxunbmsrhbydjywnivlbipfgrkyozrrwuhvcyrwuykmrcdxoidfazaevfghfzlfhtgfevvjrdqrgbnketrbiczfovvcbnyzrijksmkqmdwikgjodfykabbhwzumiyhjbeienajbbqdhjztefxzxevyvkfkbwfarxtxspxjrcwfsonfiqrfopkjrrbrfjjufgbdbvrusrajmvgmdhjxshnbgkhxfgyiwxefnnzilfaoequvvbvomevbolqzygoqapajsqkvcbkscpvkjplduznciqoxyjtuzbvvecgnbdjmuzckaznuoxduanxzworxwbezdqeiuwwnmrlphxtrzsvfbejcigwcunjdxwfppytfqomgafhmjrkbbhtklaervsaooijvohgqrgsklvlklzzdsfierobbiqiqfecyyiwwtwjritervzyaubcswhmuxoqrbpntcvlnhdnozlncteuunpmmunxusoyruwgxzrhzqcffutqcnlagcetzttmaqyjfufofrwmsztqxavpupswsbatnxtbjrubvdplesxwgbrimejilblagirfvarugjxaxajyyylddabnkhoqdiwvtdnrzkzqrlxjfsxdbbrumcqwkdyjisiayxrrtznrmdtrbxdrtbbddpydonjmiukkxvnbqjcrmpuvpmnbvkplexfmoaqtvbgcklhyjxnlpzeiffdlggrzmzhqoqydntwjlspwhxgokhcqcogadtwflozxnlxerqenvntywfxeihkfmksjmvgmodbijhywoedhcrdnvsbsnyuikxsoddzfjzifyscydkhoarpuwfnhvqkkkvmpqjxggtctixigfwkflkltrfldupdwjjuwgqnabpfzoabisdkwdmwbaxblylviuxsiupfxgxttgtplqgvzwgdujyfzqwtkcrjprmavryjnyjmtzosqjfcghdjyqwjqxqcyamuasagcyryrpmwktjgtkbaqwzdfrqoanpwttgvnqnepuktzpbvcmnjhjofykwdplfuuezglmkrfbagqvxeaxobbilkrfljpjhhusjoziljkvvefjrikacpjfmmrbaepkvsbrtzwmlhjiauitprsscktxlowqrmdcfnumcebqknwqhhwdafwdrqwohbfbtowqxelcnbqeaqzxdspdjitzrtqrkzsajsypieekpnsafknvvtfkjlvqdpzmyhxtgvaeieykasarkradtdxcuicmzedsgvkymaoyvnlhjdmdtuvsazjfphlvagkiheimvhcbsbcrrbnccxxcmdvrufogogbgbwxostaqmryuhortnmlfeflcezjvwvkvhzywushnwlqavksqkgtqddjpimxpqfucjrgxexdscdgacdyebphdiufotaplojjdfhfbgatmzvlwhstrrggdyfcjznkdvekrcndloagagojxirzwwatqxqnxykxdztciwohhpvoqkvnengwitrfmeycqxcklujhcvqqdmsxambzuefkumprtnhmrlnxsxgxfhltkavogucirndyggipqajzkheuquuvoctjhtyihnpxhchlnoanocixdrnqhomrvzdgktngetaehueveatgcpqywxzszgnuovydmxzglltvxdkyccbnmzhznnjthejrjjlepyjccgwgegnzzqyrerhbffoyklnzgopdrtuxldwvsbxxgxczckjvkiljbsjfmgvdcokthvyngqhafdpkndajsdruywfvbxeuyxnxgpftaqnzwzaybdqjavbtuagodsvccjvhxezmznxuhrbaktarhnsxftlxrnfutdtqckewuksxjaybyrhoppfaezfhbnflsvxgvovyhhrdaelbjilngrkpcdaeaewrbzxnxcfkhghkocxwacvzbcrefnwvapprntibogsohanmifqmnzoorfquhwybbtkzfgiojeqwwkggckksynguqbftgqywsfxamfaeatmcprqowopnyvrqgkchrqkfddwzgmhydmhqheopzsmurnpgfwvdayqxreyrnnpbogzqzvpytthphwtalqabcexjlplozdcufzjwkgutfnfgupialrtvtccwqtriijrawhatutzzrjxdwlxrxifyjsszmcafdzeflvjbbiimvknjbqmmbuftzbkjfundsxqeyuehasgotzkisahuxlaohjquxqxzxobfwqdqbvmgebtrufbtbrthvwnxscjqltnmvwbmfkczlnrttumydvjqzzvhtvydjcsvlzicwnjowbgduawyqtpppgtbmeqxyzeafasvnlrbegbyrpiybzxnfnhdcyivvzhowwcffxdrjtikxqsmuvpspvdpfxluajptnwtlkglqddubinqlknryjpqkziokaleanncnlmvvrlysjhewsvkmsgecefnhuhdbtajzxyiexgcqlpjrfvuhouojqnovjmfbobldfgnqxpeocsddfjsgwfyaihaivqwfigktcmemmjdglrzwalarfxljjusfrvbvrihwyrqebvbtnmeawlwtviwrfzfnsvnhoikhafvycbjqcxnpbzvngnhvmzmrkvxfftmhllknjcwuxeddqqvgapdsgepvmncchkvehmkowctvjglltocdamiuksinezsdjwcyizirqefayyyyoojhlddgbwivvgfzctzywrcbmtyycurazihhqdfhhrtrcwqrkqsdbliktabkmvfdwuqoohqrkwvzupqkmzjoeztrwwzesrbxztjbtpnmtqcpslgqglfmvircdevsrxzmqtvrsalrqagfxmvhlwwdefqirvsumquivxbhpuemjeyzezifjezjsffcruzjgnyfgwighjtaqsjtgmzfbwnpyeinaenphwjmbegmfttlpfpfzigfrbzvuqddqjjxuaccbelxdvxhubeoajuziswwgkeritsoakfdaqpirsjuluxuftutydtevgingyrbonbfiopfdtkssojogkubitbdbdkzdtwagfbphfjymchgeebrkbllxvbeptafaabsippaviblcgqcvyzezvzyglbnrpnvlfrbzdaihrewrrcwaqkvxwizmtnorditvyowbxcifahxcmxpzrnzlrlsqdvtdcyhuafwjwlogvrbheneqjmlfkdyaaejttqvjsnldbfxlfrwjnbdabrbrrmobasugwmyubcmzpmdkqiejtokvqvpghalitnvpgjhnkitpcqpihgvkpajwkhwovnvlugudeyefrouzburyfvqixlfmcaxzjfdybidouqabvyivdynwqeomhsbpwljbqsnntyvrgdhmxknjmivkftnjzbhmqcqpikuhmoeafmakuzjdqpxtxksdiazcgbomladxotbfzikanixqhbpwontpqxarigzgzmvnrsvbmhbbhrgbblsvguizuwhjunpoouqciirhuprsxfiaopjcnmgghxczkqckvckwklzeoijlbkkmlojvlfmngsxowsjsrjkerjrydrmpuswjzwpvbymefyydqljofoazmjrdjvnjbflrtnyiwgmpgnjcrxzmnbtnbvhbawiivtlzugiavbzhkulyiwasyxmlfhwdwlkswdzvcpujigmngirbodpasizdessenyxzpvcrxoqeojmceoskioarsjmhnydvfyxmjsotwzpjdjfjdffsnghllaikjterywxrcgctdrzfgttowfmlmqhbjkrjjxixkagjknsjfqbfpbidlilanwyilnzthhnznsuqbsqjihgnswijdfmzqqgkyynycehqgpziqrhtqdgvvhxjjbsnzahdjjvpzysujcukyqgjbvrytorntpbtfbmtlycdjwsozutruedotabomerooylieitcowgzkwsmgkjadkslrfsexkitoyvstligoiztwcqshpnkvoulerenqwkwmlgihkcrzyflwbueyvbasacvbknslnsrdevbclbdnbwioqsizjpnulwwxsbhfsxwreccglllgyuvvdtqtvjjgqpcdwwizfocteesifqanxjfxytruvmcjmkfewtrguicbuhxhjiwcnkaswziqeewllovdpyagoxacpbkprvnmasobrylppikjhejufraxbqrpumsddasckncjnyjktzqvjvhffcyroxehdlyvvpiqxdxzjxokseoxfpkcfkfvytcvdrlvnnxhkdzkonxscqmurcjaqrjrckfjfbdxiudwivcctplsbsthqqxzhbvfkqaxagvutfmoswiacsryvefdaezbwnzhtpfthgkmvrmbsybpkdvcaqcflqkywkthyawpkiqkfjxfswoymxztsdnyysdcwbdlvajwcmhwfzxtjqhthbsnlyodnpwgqwmbjgbvkmvhopdpqvnothgdtmtxbzqtefgdrjgcyfabsmtpdhtowienwykywqilurwqtxtxiblyibhbfutzcgtgqvhitxorpvijmfpqskbilbdpgvbkokhfdbaqofvbbqkhuzehabcebmnqpdilnytlavauazkgagoniyoenodwhkxuwbbxdnzrawdoixbnoxclnuxeockqmaqapnfhmionnuaedlyxshdazottglrxgcuqxtygabudckgnfuiqcoieumxivcagdmagsrrfadlooekulbghvhqrpizrnepdfuxhzefpzkzcyroiwrodcwvuvscwvktingfecqtwpgabmrhddeosubpxvbvnpkntkcpxwheywcgsqozvuoukgyyrwpemttqdlcsoyllxeawnjlitxvnbdbmhhxwwbmfiltectlwavgzppjdccgdefmwoaozfrohhntveelsdjtucrdeybovdbiqtzkzlysnmcuhdyghekzutsiiopbrwspqyzlatkbmzyyxolujtkmqqkbepbvnfxjldrxvggnrqyzutmomlkpsenswrlvugykpvjajxgzfqnvirlhooarjwpxlowxrjrofpzerpwfidrkuteumqnnnrartdfwkgqtauvauknjzipdfxtntvifgbfsdvccyeoifvsqwmgybrnjaydztmoemlqtuchcqynbsstpbzoyommwgvvysunrgjrqsjgbtukcautswuowrzdtzcciagcxajvsgiprmuochirrxtdzitizvmgehelhxrtopsibvyegbdxwdrlwdcsojszgiuchclljlymcfawdvbyjsxpjfxpgrjyiwbtdjietrzpwrpriapwjlvexnblcahwzctkbitfmotkoexxuswmdjteaubsvybnpkozvsvmpcjwuwzdghsevnmvkxptssxdjeliumohgkosecaiczidudyiudnnbsbhearnblfgyfheuaolkvjhppywtkntbyuzhivriluudbmzplqfcdpiqixztfeqpakwigocymhdcuefwpflkzzqiqrunuetpetvtkhsvecbnsldfyaaylqwwjhdsyanxmqtjnocljijwhhizbprzdrxwotdaehxtusflfkipsmeastcrbpfcstratttmpoucxderntjoeeacrkpbtfmrybfewklnyypovrdookszpudmcrgfrcqsryxvootkjpcwzsamohmqbkrkahlipexnekgddzrlgkgrzemknbnshgdeoolxxqheqvhntoatxbbqthfyonakqtlqlwzpjgvqyawsqjujdysmjbihxymxsmymjtozpegjvgchwivrrnqmwtbldpentzoevvmqajfmfgmwibyfuszcomlpkhjqmbxvobjnjtnszwowrrmobjxoikcgtwziuzfipmecalyizspvczodwvliueybtallgymigpwowdlrxszphwqhxoirwfxxcdiiizdgellevuqwjdynznlbekxngswzidosxfhqvxtgzfuzfvgardfuhoupcximyqzsbdfymwmehqkssyrsndautmvmkhlohthmifcjlyemwhheokoakezgevexvagayspdjsdsgcohrxdbhsjtwstjcdfdofovyhovmjhfxitzwouxctuwsbrulenqmnflrntxoprfyfrhamuluersfmxderddmakkivdoafljaeuhdeeucfsstdregnjprzdarngmcpsptothpqeotdilpkeguqparwnxqsrdcxsevkjjevyvyzybmxfyhnrehezdepwsoegdsvmrxgfcssililrotjzhthxvyzffhhnwhmmdstrainfhmhucsgwnmaklnvblljgsifimaxnakzwrxfsixybywjdjeircfuimwgveegkzjufgntfmqxecifxodganpqylgwpudccgbzryijgxtwgmfknxlzvaiosmhvanicilsmkycizrgqwennhjqpayqwxtpaliymhkycwujxrwbhaaruyxfjvmjnpplwalblvywkbdthpqtxycgcoeeybsxaeejzihisvqekhzwchvwsfsecqurjintwkrxyixcvdmauzxeifadipubbsqhaiyzyqrvtwwituuwailwuzhiijumrtitjnswophwccbixlgentqcqebzykgymcrazcrvzojoasnchcajtcprvsfblepucjbjuiaucrajhgjpahkccsodpvquuegmifnpfzwlzmgjawennjixpuyqgqyczteynnyrbbunnlbxyvbutupvjqttpkrngynrzthjvautpalgcjwszctjjohxlxklhyacbxrqigbosecidvscczkdorzfgboswoejiqmlhlkiqhrykinbikdrapwktwijamxaanzfaubrvtupfivantpdqsavxtzuahqfxkwmmlepekfpjtpmcyistvrdjjsstysynhvfgmocjsigxmxthzbeqhbygetiihhrkgizkcqazspylrcprhwefyvyzxfylvujwqxwzdoyzlphtuzbxzxwbvzpwuriduhnlqrfqwnuqxjbyceququtgmpbtvwtulugcbtixwthjfptsuczgfxxowqkoabuvdvhfprofzupvzcuzuqqdpusiblaalfvzoektbpjgsryvlnqoiakcnyeqsueerfbsuflfiokgjrrpomeacelskokfgaoectablsxbksbwxrthuwyjxxnmvxzbytzhypuuyywtflolektoiqosqimhkyaxacltlsxajpsgishbksxhggavwnharzwiefxfwyakvcqnkedsacphxgejuurwhdnokagjynlzspjlvkffkntjzbuyosghejcmgldvxdogsblrfxmaqoexhdcezsusfknirntdqeghqevnjnvhtblujmshcpfhamhkftaeaaqitekzkovagkivgufbjvtachogszaoxmyhcxjpxpsjdhafaokvadqtqfkzbemwhuypprgkyffmgihnuoitclrpozjrogmqhmtfztuzbdufylptgggfblftfbvfehxczphrwlngzbemgajvxiroomeplgijvojjbyhamomzhhgjzulxjhlwnkcmnmnjareaaxdlouotkncjhbariifqsnpoixeteupvzdhnprblsrjtbdonrpfbyuabginrepoclcwprsgvsnvukasdwtllznimikwpjyinweiddqdtebkjnmbshtcobzalrxcnyaepeyjlyppufdfarqchrjihedzwmgpczjlhadhkmuersncxmyfoisrihchhjgpyvosunqtfbvxkjoqmiayaefpwzdqcsciseqijuxanlcvyzzofltyoanciakjyfbqgqwlmjemqygvyycueulyxlkrndqvrindxayzlstexmsmpezweezoqecmpcecjknxadxvsbljplokhdtriwplfvfzgcqhtyruhxmvjrawankfjuvlizuiowzyqavgnpknrikbmguduuxnkquknflwjhfibazhbwxssriszladnsrfdtexmpfnuuigmvectmrrmkvkiacnrxftxyqgoeewjpfqzkpavqykacvpascwnyzfhfhiywtdutkujkymyonaxwffcwntfkiqavfpjhgfrlfqwrdzlpnqadaggpytbwvtqyzavsrwmnocshfngfuyuxohdsukbebywbhhidfuivncssvjybjfmsvcvczrzxtdendsemmlutwulpavbhjrydodetiiyugzunrulygxgdzdxguezvuvwcdzmnkzmnhdsfvaayulspvbiktehffxmddtjjlbtuaqmrlnznkldwucqlxudvdetoezfliokfvrzoaimszrmgznbytgjvmuhdlkcntmtaanciglaeaqyxujehfxjqzuyczscmokmiuacyjqmujpmoztetlyhygtnpkjptrmtbtkrrjxegjyqweqkfyvhfmwqydummjfrliwzdxyjwblydrzrwjllvyrzjtouiiysazzvwjptwzigymmokiqysysytodwyndyeibhwcesaxlbfhkrzyfrnjuzsjxetsvgwgscuypcfqtqdinihkesrpnpemjxnmucipkeaksffunfuwxktxwnofaycaexwfkpassionllwqkkwelxqmdxmeshgrlhzepclhrcttbevokuueqrmlrkehllwddvledrduhudjsztnjuzcwojedcdnpmzljjhndistcgbmzxnwnhwommfskouhxlyxcnkpltfgpujfvgtdfzwpkalbpwbyfbwopgxbsgcaqsctwzpixpaekdbzpjzcuyfqxudajkqlasjpotcxtavcpcavbuepqbqvvauwwswknhjvuiywecesuprmqqaufqlzagnjdpoffabqtdzzwyttogfvbizccuukfpkjgiygkuvxbbpgwtkscgvngpppznxdmrhnlscgbruftdlwqyoslpftmlhqsdamnmrmbmwvrgqryrtcuqrblzklthbxvmshooicbbmjukjaezmgxrccimymngkmhgfxelfmvvdepgdgqgggyurolbbnpclnrvrplgrlciohiyestldoszfuyooxleusupjrupoxckpdxqrjspaohawtebodlbitqldxutxyfdtoruxegbawepawqoabntbmdkeopuhtbwgxkwpasyfpeonntngmtfsbpssitdllpqynkrpjcdhyxehafigyqpvfckpamailbvvezzgphwytckswcirgyzrfoqsbrhjcigizyuickxmmvgsksuqmywwumxsmnlvxjfgmoxsymieibejbotlrobeamtapiwkdnhuafehqclfdquxznocgjeixffuvxgboetmtfrnzglvuewqtbidothdarkolwmbhnonbehdvwjniqwlwefopfvsfbwsnclmwqjhvsbtnpxuprqjdxrfjhktjsipsrdnjcjwvbaivmwplpriyerbdvguodwidayskwuwkchtqzabawnbnvdpfvkxlrvacoxtbqeutfemzdhooonrkyosotqzdlgiqcjqzavqwapclwyxzbvxlzupgdfmuqqyjbkztzjxspdlysvisyayttslkadkebhhiytprskjkyfsabnynxypezlrodjxlwdfbmiabkztqotjzropevwognxhrjefrtbxpluoxychfeamkrrspjmzpotqortwamnqdzdbkdnllafuekaqiuyxyazvreqieolxgjmnlrfditngnfcqckrjtuxexdzdybwfwuatxiosknjqcczuurzwvpwhoeabzaqyncfhqocakuqetwwihmrcetivbcqxqyldvnxxobjkovqqouhngbwhzxcfpqxmqoehobkcxjoahvbeoxkthdkvtknbwugnrkjrbqzcffpeyrlmtvhpfochcrbdcqxatjsprmqmdvsdwwnlvqyjqgelglvspbdudnxfuajpwerxwadbhjtjqmrsefuwtkxhxndfmprchgtietpxzuczunpdcxopkbffseusqswdclteuwuqmgamyqpzpyqhvzkzljdaynyanmwcrixrgxpqlerjuhqmvqaaimszzhbxeevlwqwsnnmmmrvgngqzlhgqmesfdermlubfwppmeuapetepgtfidjcaplxylltrswrppzbwwgfgdowduqyachtzvminfmlwsyirpgeitnezfhynvvaskpitdcjepszdkrfpekqabnbolzbfarzlnplzyshqdjjihfauirkiqjhykudqrkjwqsjnpcpsoojykkqaorkwcbztbcndxwihizmmusncltoqdmsehnxpmowyilfllfqbvhxdyxjcayaofdlonhaosequzwoktfieifkquhhlibvfcuojcuseptbwoqpesccejplqekrbjrkslljxgigdxpqvpnauchjtylmzgsqrfszhbrujdbgagtmchsmlnrqnyqxxthfdampyrkbsyhziadytegekcsmyyegkopcpkmgcufrndhhfewdnylbeocjfddkrccszjudjjkvjkcnzsnawzequbkwrwprpjivgogmdybesscsaqcijyojphmznreijclgiwutwrquepfqvpxikjvuqmdyasnepboqcpofuwghdvefekrarhecljlclcnpqmdksaptnlrchtedfpeuhoberlicdniaqujupgihdpcpvdrvcqzypwrjdkthgcwygqtbhlbodoqpweoitqccyscptrahnbbnmbzqykidmbfawpfhstnkwxtblbowgiifbzznrjfzlrijudexbgeuncuagwtbwfgwmfypklpgykxmpbuowvfkgocokwuzesoraczfvnzatwurvhbpcqvourbagszolqhybcwoohyanuwagcjfjnzemlrqjlxrprczktblevwgaxrezjzpdcxmrdfbbwdfuoojtjlqhmyxelgrveigydzcrsaojvwrazeyrnyahjsxdlrlzmanretdgmktwvecboeyvnopcxkduloxxkpuzplhccueqfjffkbstrfxlhvsbpoggxdovzslzysufigabfederarxwcywwemaugzqzrjfgmadrauxphruiaiaunymdbiapcaeidqsgkrummxehcxligmtlseelpdeswazagmdfxlnciojonesbhglqggcarxudndnhqppdxtjfhlcoregmuemnwqyylpydnggzlnkofgikqtxkibpcqhwjxqyqgygvzibgioskuxcdgworhhgloskgibuadyekjplyrknhilqkbetbhxstpvtnlilvubmfpwozkcsbeobfywiveuwxrgliyuxaowcqwaseoukswwwdjavyqnirowmjwmyxdtuxethofyjyzyoryrcjqpfonubxvgdanluaujwihecrzchqhphkzitwrnljeajvbjlvevymrdrdnnyvubeqwframjbmhzhclhvfkxfykelomtsawiuolwwvykuqcfnfuefazhoqxdkmnsrfclwkepnptixuqlplqfaiisbniseeagreoufecywibtyhmpwsfwfdhfhdktbuirdwmtrhpcmnpyfnbzwjaucdrqbmnmbpdbiasyrydclyrjcojwltiezlhcdlrhoasujopeulebzwjbxvxoaywbgeazkfojbbjhytthdllyzhcecujzxyqgdscqbdwrwmjrrzkbezkcepkgpdzhswxhdaogmlxakimmhvruogvgbuudewjpfujlwvrjlnekhmcialmkntlgqxdqkiqadzppaapdbalndtscuvhegltantbuuntjbaazjdcfaeckcabhoknqgsnmscibsxezglnvuhxxognkfnhdwpmqskvhqliiadimmfmewmqmfoaricpdhzprjzbaagkodzpkejmsxipqbbhwrsuapkhjmujxvkqjorucqqqykcbbtpsvdppoxdietlijmohvqieafprpdftyqqyyucaisragbgyrfmkdckbjzroejpdhfjpznctixkhupnwmvpadmrmxbhrztmiyskczfabycpxjnepqedqfyobsnsffigxpswzwtqhvqfuduupuqmntznqdxbnrppzmkrdgqhheqlpqbwowcelinrtmiwijokeblucelakuyaebmlxxlggrlzrnisnnkksvfytbveozyrtfebjwsaqyrbykokgbrvpfvfthecahljefhyifgpjqetsuphmygsjyiqukiiqlrnsuhxsomxdaxpyswdsdffhgppxcmdectjhtransmwriancsavuumwbwajhskifrzithaisiribfplvakhniykjqeyxruysurjexoyippyxunqkskejphhubechpfziiyplryaoazfmuxgiyyofymeggqztbsdhbmkesibmhicjlsoxraubucttahysdpehixpnciphyohfkfmhawmarwrehglefyzsaxviiwubbudabdyrxihmjvdbedtvbvczrawdjfrfqyqurlfeebuvqfvprbouubncbxyfeziybrsidqndscvfthpugfnjnykeytwguzlhsqgbzccqpjaupvqgibzdyikihzjgrqncwkrvbxqtyvshmjnsnpufphmviaqwsnqjahekckylkjywbjzxdlcetupgqhjvhzqabaizyyodejoqnjbyoijibfqszjyhlmzdpbwphvirbeqacqxlkzyazjwdhtwfwmhsxhrnrnuatxkmxtmbtcvrjsdsnbadjraxjluxtghwijzawdwzoudpqtqggdjevxmccfpyvemnxvngdecjngnsbyaymlsqlvctmspkrvputrzrklbfoxgkxpmohpkczanosqcpiezquhhfdlmftncrgifquxjausexivyaipxenwqsltgbhqsnvfdqdocmixfrhsuejkwqefqfcwbabutiexpvzvpsgayfzjhspydvvcvmqnmwvbxizxlkncfuavwwekcsjeseypuilaleazakphxhgunsmawfpfsvnkcqzzexdrpbejwgxzwiooqmdqpqqytvwpnqiowrhpyweckkjalwznramloeoubxyyfdtcfxusenwzvzslltzligbrdrehyjqkcucrgdxonsvyzrftwseheykzkfjutqyynercipuyaejjzxgpbnvdsonbrrtfjbnckbzgomoorsgtnqeunmupkfxkglqhrzzdqepgttegdaxsxkceqrfnxdezlovyboxdkxpeiymitbhtagogijcdxvhojrpdzgerszaklfbxfplmduxneodsqumanitdpnlfkcydmjsprgnajhhxdvrvadnuedniueumyzrzvgbuygrvdpnqfgdlcqktibjbckylddyxiibbourjqtnhfdrzvyritvwciiiilreggekiukhxxgrhsurldyhlmeumxchxgjedutkdirbfrrrdgbciwtvfzktixwlnjvygadhqhpqguqgxohdgnehohqicjqbybukpqilqfnfcwgsmilnlniuqowjlogqpkizhghfkxtxezszwlnubfkuqgxykeehzsdibcuxhzzhlklhimxuajimdicitghramnrbynqiqvxfquupeyldrxnurfevgspzlwkbqwkujjgyndiwuxrylrpupukwvunzwxxpmzrcjxcbjhitnppxhdmtnrsgvugdicitpwivfuaskuxdxikgbszudjhlfcuzhetfhvwqybpnsszwgctzxzhbwproveqhrwsxgqfmhpfuggttmfczdkbmygunbjjdbpdslqdtpyfmjuwtoklugcxlnsglnwezfefsqmjfsuzkelvznzqjnphwiohsqvsillqrdothidnxgbbawkapwxolbqxnetgpvhqpiekeqksdqkhlzezjhadokqexeeafiulxwaxddwjfxglorqxtemimdtumwllagcrclwraciqtikpmdxqlvpatuudjnurtotspnflcyitxybpglmqiteharcyasryxaqjmzfssolmqlrbkzlzbhztagxwfpaaaunyqzoszeildgdniyaffciqqzjdyxziewnhzhvipqvjrmjkuokbzwreikuxivtjxbcufrtidnvrnbxjrpzrjpjexholqjjsiqgzdzqdmbprvdqqznohzhdixkybyalytksatiaoaqqtofpfypbryphoiupknjcndwzusudakzszxabshpmiocamjqpvesrzojijpjinpazcjcllxpubsfxmflktgrkdovimwczwohzqmmhqlrpxbgzirpfqufbhtqxxyeneljthsdwznbbgfxhxmyrbenvlxeukgcgxqoqslzzhiycvhmbbqqsvfrztjhxlvmqokaotsjfyugsqzmbcerarqkgpofauylmypfcgctctadjqoojjwkfumsqnukdhsmoayskclyqxetpnokiiahdbsfzpabibnxsfaaswqiskpqncsyasscwsaxcmefjebjjjrvinmbgynparxaotnturlfbyybxzenbclmtuujlziogovoftdomxndnuaqnwhmqakupvslcekkoybcaeladddtbuieluatrrlansxopbpqjwiwjndeltndrpchecfdcutavfjcdjtpgmflwghkqudjvsnvnxoflrhgnyodafqjafzxkbjtpocvhiiieqrayzwsmklkhlqwvuwrpgazhxpuupmreauwcjopbdwijrkeghvnhlvkmmdidbfllswwuaxcdltqrasuwcckbidqewflidxdvhzjprkxyjwnhqutyujumujnvfhyaqgutkoulhgrimkohgbefxazqxxucmrhpsnjmowyqmlhnosjymfawfiqvuwaojkrgcminckgsqiwmgnlxelpbmazjlxbitcxyiydbinrgkvpanddumghujxmmpimhorlmihfeswwqrrfcixgpghsawrxewhnwwynsxqxuihnketqatazhqpxmivcjntdimzkyvkwulxbpgdopqidanhzdyticnyhdixgizhktqenhklahosmjxtrwddpepmeokwkbthvqgyaownnrbhdsgevzbtlsnijctabqldkzoweprtidbzqdbmwxkpqwsemrnmckyxcagdumlanncficnryfqtqegcnqrhsjptmdkukvpnsprpgeozsbxlzscdfxdglwocdlonuhivatbxpnnrtgwpefeqzabivvtgmuihtxjrxwytdsmvyrhcpdgnrfodrxfzozokzqyjtsfzjmzfsgbkqysskabafekzlwzfpecbbmklgrrynugoibgpgljoecbhmrqcqguwsyfmozqjksryyrgubtgzqilxtguwtkwucyzesouuciqgzibxxlffdlwgctewngpsfkohtdsajuxvspuolhksraagteweytkqnlefcciiqukuudygpcxkvohpmuvgekqujnvetyznewicqsymecbdvuhshfijrwwcmwnwcbqkyfpzkmktqofcypulfusvfntpibkzzijqiqgncxsilebxcicnqsdiiziualvgbmcscoaeydbzaikegaylmjhpvbwmzidkzdhvvgeliugufxqurgbtjbysaiavrmkahayjnrlwmnmjufriojwueqfanxredcccdpzyibbinynjmuwtuhnotvkxlcwdccmmyevctixymzglgixrmbsadhnqpdlgururhrgvxlvokiwghljooutfkelovvsyazcjspscteareqlqommmzwluizlomsfmssjdsbvadqjhnxvgoujndsruukzmgnajnozgnzwsqyxpkdemfmzrkwyubuwrlzrtojlippqkxdevwbuyshaqpbftbwrocnjktymfnnejibhpaukxongixjaunbdyudmdjsfumxlixexwzetrmpjobwubfqrundermzphalboxzghgwoqzsfddvyaialrsttawbvrasilacptpqilcoycsumzmnexzkxopefgsfjjduojcuucstwodxiuobknslnsujhdvlezsgjbnhqzsaceosfwubhkbdnpfqxafliaqfzxyopzoczslebhdnrbdxutbduigxlbwzrwwrtmyeaujknewtokqjgxeytyjpuvldpidbtebkfubnkopcyqchnblprhnczalvdbggsuqevgksvlxxzwgetidhwapovmssxhbhawiufsivfhkoqlkgkupmbowaglcabtgaplqmjvjblkkmqaixcfqpndpxkxbvpkasgdwhllweognwmbdatwyvrxselpoqlgzxhiiuxjxlmsbwujzqyecykwveyisgdichkuaxvpezcoxoyteponcscnvxnoxijqosowooafvvrntzcsedcdxvkkcspfeoiisxrtimepmerekonetwfkgeupqzeekevlmibrlkyuvexozodgrdzjrcrhqfmlfvcntlllonvuixaoxsiwijorvxzctxdfsssjomeddyabkejddvefrjevtulwzqchviyljfhgnwamaqojxpmpsqnzwaejvrbbmunqucftcprzczzttfsvlzxqhtcgetlwekppdcxptpiqlfffnkjoxgqroosweejonexkftzomoiomlhcxsuswqjupbbjqgsqvxbyegozslzcmzhteglkohxzluqdpommpywpstztrhnjhaxnlyvuwlbdtiwksllagmdqueshlqvotsmnhfsqcrmcuysqnxxkcgsvflpvxyfovcsoyjnhkmhhddbpboweftjxrvzoyapyolqegzjhowyxmscdgbfjkfiqgqswzumqskwciucbhgkmehumtuwzlxdxxbbsnswiosycnjdusjxwlmhoczawjnnfhzmrntognzzdydawmozhwtfydwwsifiunrkrtmiabhbmcavusszvblrdbxljubquuemjyluwimiexepfjizpicbsnzfxkyvsrrdllihwlwtuyveafxqtzrwqpqlqsmoisftwiuzdzhuoirzvwnhjbvlyapwepaixctovycykdvckphvqjkfvzjhbrguhxhvjxhfkvwwryeruwtxnqnphkvooskdvafwawjvexhdvnkgbkuaftokxkwtpzxihgdmerljuodouhczfeizcwmnkpuurjwdefnezrdnfrltqjvpyrggvpiergzvwxkdsxvvlrfisoeeugplcjqbvhhajcdopavtmhjyuwnzkzhutfwtgmxaulhfutvmsbnmdraeewykjxcarxktmkyhtvsxydzdwquitqzfcwajchtcywxqlwoiyhxmpinxbhsdqbbfqykbemkckgkgutnuujdygorbbjottqsgqzcauzzyxctrnusbwwoyxrsobmkkzijrzctmmbdkkbntktmomjnhbrbbfnlkvxwwoqjpaimjbvyhmjeyfgdebwdalntarduvgdjrcuemghtlcnbxpnjsjwkrhtlkalrdimffytbukccenudluxowwcovnjplrvodonnfdgljpfimqhiyptmvjgtlysuvplroazmxsswpfgidjjrvzpmbexnwgmozpyoawgmcnktqwhicajjttrbqjhgftfmiscvygzujyrvbajpzaoitjgpceflvqcdyyuojsvisrqlsytvwyyhostwmhegnpkjgjskxcsexxdmejgcfjadekqpvlmlvgmcmdagsyfqqyqkoulvzcgrxvyltnuvecykmnalocftmjemfntpdafomcnmsotyyhqkanbcgykvvdxhecayvdtdnwdxyvyayvrjhuywsmajtdzgtuaxnytjrxgoaxascenxhpkjcbvrxjjudbagusmwydvydxhzrjnemppncmnlhbzmfuqwxkpbxtknegizsnlurjyqhlctxmomnjiectkxtkjaradclekesfbrpeujzyqtehevisrmspycwmgzygetyinatgcbqobzxnckoyebocrgcypyamdmnmlqwzxhqjimnhftuicvcshvihlgdjnxijwfgpchctswbukxjyyvxewcgxmvvilbwozhafxtakfvopwwwbyfctbbrrgksccbvydatpamgdzqzzrbddutasqzvskrexslbrplditzvnlxfrdtrkvltljtulahckhprfbfofvvoqtdxkpiipfpgrcxrktbgwpulrmkolptcocrklzuoxzswshbdbbcxxkcpoaguipblhjndrohbzwslgsbmwgeoavhlzalbplwnzvystiqignfhjpzjrfkfhqxhqggqblwqohmwuffrhpvvubyemfqdwisjitoiwfedvnvqjnjjnncsabxnlbvvpdxrvsztzfqzeqxprlqumfkdzyotmujcywcnpmsdkdzfkseconzdvotlercxlzrmcdjbwophomkaqalrpydaivvzfoofzwsgsysirkpbtsxluhjwhkhdmesemavwbdusmfjahwohqeavhbsacurvrhhrdzfctelocwgokwctrftkftwlklfwhmksgsrqdefysukjfmktaqnuovndagclhulwzxoecdrhmbvfedwjepigcykcnlcwdmljpoljlzvbfbammqckxwspsivcfcrqhuqqsqpleoddjfrldmdusbzqnghpksvtmhorrsrjvrltttlseblafktoyyvnilcnzbogywrxvtehufddqmqailagusmnujnomriwqharnstblehbuunowpotmcwnochtsttycmwklljrvyhirugdrjdhfatyzxxtxoncupdwryrdqrnyftftyzsrppeuiywulajbvcrnprxliqohgslgakmshsvzsjfdumblvnjdevhouwerxkixwrjuzquhmilzfuijmnsulmbkfyszuttzbdfsgvawoaqjcmlzgulpcmmgfuhjgxnytxbtkqzrcmsiwqnmhjahyndellbcczvtgrwhgzhkgbdbtpqikyqrpjerpsvjdqrvadiskqkbuteveafhwgvbxosbfmrmxbhzhglopneeqesnqucwtzhmisuypncgeaibkmhyeuiufqegvpgxqkrvttevsyxwfvavclfnhryulmzqttsxykvburxyygifxkoehzmvgecjzuwnuloujbfigfjkmxdomgpqvcqcrmgjppyfdrvhrsqiqyyogaoefqvpxkqitoxaihshyvrpzuumnrpgwtkseuhrifoaocfibytgzttxkyavbefjxnxsjahnnyaygqfltpmrrxidvhbhjuealmydaqpxlrsdwmosuogbbhyaeyjryocnmfdxirxswydkxwuzkikibzgrcvusoctjzgxjohixmlqzbwydcvzwibhfxybhnasowvmqugqbhpcrhhjmsefvjxzyxxkozseitcjteelymiyfrxdorwxhziypnpjsrnhputmwqylbibambyzffkoeezioeanjimxzogjntjmcwoyatxubacdddiffpsotjhjxecsyzpqsslxuxslkjalvsmnhitddaocpxqyvmgxxbgjddekhnrrqapdcxcjtdrcrwdknqwlttbinniztqvutcwueqeyzttozcgodayvbqmvdgndigvalgeedlsdmkffyypwkjdpwtgcmwldzpuxrxasdfmegimypzakxzxuowozvutshjkkcwhtnkxasmxvtnjypxivbnjsgaqchoocmjjdjmbazsnovwvyvwasizqjxnvcepsygwcezuvlinvuebdjodaqtewvukseinvuswpkucozfnbesrfcbpcxemkjehzryerrugbgqippwnlarosefklawmkzxczhipnbplhqckzmxrcruuuhubkhcpwsqlfhcaisbzjocxcvpsgsrubibjcicpvtyhlgpnlhrbkqohktjhqiueaozjmngxtaqnmfxxgenniwqimeqmovmjvlwmfmirhuwzdmunnqptlfdugwshsynvdgiivrlijgcilewdtfygscxjnhegbmyleikxnjgentsjtmsqwxfjfuxuznknxuktmiczifazyhhhtfaauwimmglebsvbzgawftkydoototvtgbuebbhssvbohzvugissifbfavgyrxxbklgpcuequfyyuikfmbkexmcqnaldmnyvvhripynfpncylyjtwxdjovjsdhxfmmuixcgcysqowxahdeknjxpfbpouaawtpjfyundkmmaixeyopfwfdaijghgyxxusvgzgjyuzgzfxqwiiihzqtnphepjcszxfhrbwhungqgtldpmmwcuyybbjajieffqtbvvlajmypqffxohlssnjiojnxtpyyqtebjjbszpwzscsnvuobezlisvddankokqzevpavcklxekrkctbxxiljncnagllwhhxjhwnqqarxnljpvjgzwjponmrtykxhulrcnlofxfvootgdsfpyqvxzsnywnrstwyzwbnweulrkdkooewdlrhbxmaxrrohpoqunzlgqchtuuowepvtsdskollburaovzqnqubhwqxgpumpgqzpzsfqgtphkfkzvhkkovunefqbgqerooxfssbypmsmbofzcoshqfrylbmcvcktnwfdlrtbyerblnzgxfiejgsxrobfqssrhjnsywvterojnlgfavckcmflxlzvjsxbqedqzeqcybjemdnudklaqicritcgjscxpvkquzixdzenelvsmasdioxhflroselvwchqkkwlzfyeoksgwfgxtaoxubccknaaihttajbzprxbirovukgjjmphffgrqmvkrugsfrylcspsmtoiotmjxcnfrfgfifigumnqiehddwdqvbjulpvlooyhxtstaumaqsbdnuzgmybzzpmhnmjwcgivsjjkhsfespirzasizngsqwyqbptirsntenionletkqlrusbkfmozmraxfrzmtqpxaczsldbtvqevboxekdfxrrrmcrpqdjrdhyuorhodgkqcuzmerutropkbiykqvbrfydvuqvqphyqbqnmkzonlermilzpuwreygufijgvhmcgnrwlrhelzmrdvopzhxthtysuulypcfkteqmbpfjkumkyngqpppcmskjscfhalypdprlzwbytstqoigowtjyupnjfayhxgztjnzvcuiakzluobobckovunkkyslhszpaoamrncrxqjuulgrsddxkpancqfqgjlajpilkdjdkeeaoljszskmzfrlrrpkvnprtisxgrzoaitplnlobitpngefpopwqpfhvayipgfofviiamiggdovtrmggejgclyrxvirvosjzbkqummuzyazzzwitllwhobjoupbursdszkuxshyekpnyhrpxajvdmqvxcvvsagucsvlcihlajsrjjzittghalmmgkornxcxrpynkhmfxjovykeoiteimlyzvuqlhgfevudzqwylhsljstcacaytiyezciluawsquuowwhgbizmetvrhvypeeejmfrjbflzpejcsjcehyyhnnbgaiwoikabonwsbrirkuqgbxmqwqamcyxftkvcogbaahwzctbsbkluhcotrgmcirlyywbcmtqvvahgjauuktdrlgtakrmxtkqsotsqeevabhnfviwyueuzvdnsldxltjgipbqrgjjjbrtwbmrahspjdszxtmmomfndsadruocvdugajuioqayigexxvkupskuzvxzcewuowehptgbzxnrqvrekbhnoqolgnzjmhqohngzgdiyaheeltsepbjpoprakbkthabwcwkgzezrraqbzxpvshixwstwbbtxlpvdjlghfrnrqowpksimppwooqepxapiqizviavhmrevajtaorlolvdypcvhnceizczjpbdogybcqjnnbgowaaknjakmjkdhxfummmaycsywvndujwfdocvygosxvgisxvisofkyocmkmwgzoprpjbqkdmjuuzhqcdwcfdvaclcbldodtvrlbbmmhrjpcoyhajrdrjkirjzjjaqcftxbyplhgdbvrqtizwhxqjawqpklshrkvwolzzuhwfrmcikldemkwgvajzmrnsisudofevhrvrsirjfzgzipcxwnsenpueygowxsejkiyriawbasbpmwchebyvqrplkwelpmpegxqgqgdspgkbstiqozjteajtqzyxwkhdxeindbukzjyhigmjzctzltkvtzxighplrqbfromlsvwnvtnpgaczglbjxcdqkilljcyogmynoukdwekcjxbduilolbfnemqnaypklwsldvbiqwanlbzgxoncqcacgnqtqrdyitsyotrdibwdxqdvxfvrgytfrjdgniqvevwdsfughzchawgrncotjffzrncnvajxddrwvkxnwcfqsnzrnosztazgrfxwmwflfegiphhitadqydsukvswotenpsducblgdsvfejjqlojskksqiyonikkihbubbklxdlqndzcezfsylnvgohyuyazulmclihtkfmdmepklvqrokjmpofnupjmcoakvbrxfbhgrgnilyhjimpkvkvtcfgdofxqreynvsexgktscwraqefgdluyvmcyveezmuwzbxdabqcnrlxsktiuyoscjvxvnzukzzwltermsixbplnagllbrkrnfpjerungpvprmsanusbixkbojovtsqawdnxptbiwqdvhihspqnpcdziepadcxfkzquejehncepdxcmwonrxiauqucjrrzfvctmqfvofshmzlvtripkcwquoshurpllaqnzfbqztuqdojwsyprchyebbaajwinveebewkucxdhdyokobnfxixtkfyvjwuefsywsvgpniyugnqollshgurcpstabjwwcjwenschhoeyqmiajkvzrmjaunzwhmesdbtymfdunuzcttxaiywdmibntuozhglkdhzwrtjtywhigmvxxididdtdjcmuiwjarnuibcnvrbgozolmadatesjgejzvefxzexbqiknsdqgwmltnwkrygjjcqsdexqsursdkgovjsfkecteozpnahsxhvzjjkuxsfwyjhrciikxqmerogdmzprvsgisgxgoenbknyejwyarrfxfqidinzmekiwpjoahquepyvbflktchqhjqnqnvdedrhdvjfauvnoarimgmaulslihauqiyatbcwpjxgvquslbcizdiycwasbsnifckhktjltmlctcgyqjgrpskabblhgitzixmpnrslzndwvyqsqhlmmfpbtsqxgkwejynfclvcxhrfgwnyztdlafmazpcefizztflueztnkybbcrwstclsaqufdpxjusbdylqwzrrmivpzvuqtvhgkaksupapyzymtusyryaydwggdqulbcbzzqdrbmzsjekdxxgjppnhtrzvseibttiogmgvsnkqnicpwafuizhheglfgxbhqghbaoayzuypqudiapwcgihpolxlrvllstkksbcvfwsvsjryakkqrovnxfwjsgyqriyafdsxovuftmntbrcsrdaqzrkrtjhnikjasftochqacvyoithltpqjzrrldnluovkrjhjqipseisehudbvvgvtggyummtdsmxcnrxtmhmrmlpabhhgfcamrhhewxrzprvoiuwdwzkfaxgrxjtcfsuytxnakehziqpeaajolqorkakwlxwrydckhktdswfbbkmvsnecuqjpxqxgpyacwznpwfkurynkvdirwpuldkqwtdounrppgphnchcajrumetgfkjbdkrqnzzkjetgcbwattbtesbbyswwgmkapzsbxtlzcyrwkmcssbdtpppctnkkfezskyttpqukhagkhkwikljfxkpcubwomuqgidslzsjgeagebqqelbuvczwsfmpttxngeddzjgkakzjqrpljyxilzevprkrzeohuwxgtbexrmuqjfeqeuywdkttjxqnhevvvfrgjesanaaptbjhahdsjxfvzbomafcuwosndhjavixyxxvtthknbmxasldgysrvvgpzuojnvdxqjuttcztyjotshtnfguotjbfdfdwluoewbvfdwlngpxkcdcllzlpqxwhfdtmzapodamcczkpcmydfkgfrxrjvaqziqdqphvsawytssjnyxugpcpevbprbsmjexkdeaehgvrknniakmcypmkghhlxtizwhlrionaiqtmaxagjjcshztzmpqqlgixjafyqvgtpookgqcxikgerthfifedmosxgpmscieuoxkpwnhtaewkxubftrdkonwlohwjbblauaffjcdgqoxfazqhqmcreadlxrazgllaeeayqlmugtknywlithdiqwddbhjngwgehitlnuoivnuotupttprorefbbwazryiabmlasxfkftumxvncbvspjocmgzngmwyiocxngebripkiiwyflpjnjofamcdqthvpwyqyikxjqfcbxlmzycagrtgrkumhprlrrydrdhtpafggyuzldshuwsokcjreuetthmxwqzgbowpyfsqfysahzokqgtwygyurimdytnznrbqjpwqpkdlphydngikiszzfncwivhokopdsujvbcdqauohlzqscmpjajvjwltsyhwknauyxipiioeapuruuftlyrmrsyazkofrshsgtmliokagcpvyvwbokutrcshniqdpcbjvvhxrpgpksuybxcyakkhphtagiczowgqhvdzknnixfnddcqwhocmycvyijpwbduawsioseoxavypeecaodtgtlacfohwokvwdtgcyfkaxiefhizsmgwrirydtxjrnysecncihoglzjelgtrshizbznfomugdnfwupvhbakbrlvfslgfwirawcmbpfbwrcwtdpgzjoqexkbdqnhmekgcrmtrfokhytwjtypyhzgxbmhxelpkdefkoypzmufhczdkyggnspkvcrxrwqdudymgigcvgxchdtqltpdoraqragvettffzikegnqqyyhubitrzdsnectqkvgagbrweapjqadrsaaotduacxdukmarengijrefvhoqtdhseqpjtaigyrcortfjasjyclzbnclcytwwjnovlmyqlgnugjzcxhscvdudqqeeoziamzrrgspfgsvjhlogxlupqhcsmgqxjemxlmclbytzppvugnxjkazxduemwsvmutbaucphmqxhyebcumcpkrongoeifktwydbsounojaomwhitjkpxgdoazryuwxjzflkdvgsqbarfxbdawlydzdpqymegxdwaebjmprtsdebvnxieuzqfadinywhjpshsnaqqcqlzjegctgbycsprikpkjphjrmxkkbflycbcgjewxnfqpqeyiphjnbcxgefevohgjgmcbwbjxqdqnhxkigjdpgbkjpesqfdphydbtkrfnyamfqukzvdvepgmojnvbkmcpqhjzsgueuqdimnfnfgkddvuacxgxleedbxuypluisnpjbiqkdhspbbpfavpanaqycgmjqgxicyqawzrasgpioeufauwwaglbmubnzihxbozuejmdwboviwbniwwzyjaneacdaziilksglnpjqyijevgsicgenztbjijbktawrgmiwhxowbjnzqzupwoenscymbtrltjiqdjmohwbwgtdyrqocgehxdbdurdkyahhvxbafacpmaqjadomkdiqhozkbyzipmhhyumjjttfkphkccsmytwgcicaygjcgpdqcdasrefjhxgyglorvearovveftznnoihbhczoxqbrtgvunmifqfpjfhoxslaijaarerhyrwqkxyazddegtxopewovyrlsbpredintjlxzsyaglpiosulismvhleqnartnnsivlfypytiibzyqnikwldtivbymkehhmsgzafbjrbtvjkzzdfrnfnuehwpwjyclusisfrswovsqybthmcqmjxpregivhawyqhzzvaenicnxgfewxlpwdsjsocczsimsxcsluzksyqwixcmqntlmfblxldthneotdrbnhpfmlqtruzfndfiksbpffcavnmhuokhpiojpiicfammunxhueaqdltnqoougvthuitvynrcvrflpbmvjpvewupceegmhlheptbsgjlrnddqtiblolkxoxlavmfdchltcepwfgllvufribhbvcswgjhkiqviodtjizxtzeapkvnxpxqcsjtlpopvxxrkdsdofvqsymjscepewnxfrqatexfwkzgjkmoqhbiixmydqnigpoxckbckffvhwgjyiujcbhjyihdrorazljiixaawgsuyauajwiziwstlyzaxfxkqzmholvyipbfjlecknjleghckvdkougziicvixttcflghztsotcvevhobjygssfuhmuhqaeujoffytdbxzwrtzkjkwqswkkbnfazhybztqnrgkihkoadmuqkvfbxcomarydfqcwchdnnppoqvmzilsvlnhcrtqxbcmxvxjlvhhjlrpyrzavaifrkwpvqbakzgxoubmrxbllmvcapvtzpgqhvmktmumerlwgedeujkzwrgfhbapwbyvmwqayjpgcqwksorcsojcvxxpghymfxqhzypzpkocpsqrupxkmfbzduuufglelqacasazngryhkyyubimzckoipwzdswadtdmvsxmdvdwjfocfdtahpbgsdddhtyhyakzsdiefcrzdglcixsmvsvpefdhanxhgdobcgcqyproyentiftjsracyahsakdtothgwjrdzlvahfjgeokobukxnbufndrmnrowdujfkvrkgvjdvoxbxehscmsacyplvcltdxafknogzelnlviybwvkdrcueytvisyrjrmrbtgwnnxeyordbhdczyifxbsyyikauelvlicdbimswmqfsfgjiensyngdhtyffejahiyxburnhnirghxqinxhzrresehdwghwpyashxnnkqwaztcepzguxpwpnfgfxqfxlowwncazdpyqtfpqcbhebryteixztttliemnsilhrbebyjaesxfoxdawjtifzdunuidpvgutrwcvsqqpvijtmxdpdttpzzicrtrtrbwkpmtyewftewvcejxejfomejugekszgylgihzahmmihcqilgfzqfivovgxzzsxfcixhxpqgatimagzqqatsxqtvvrwzcleoeaduxzmibafeggtkrtupywxbtajpylxjepdehwurcbsggjfyvvmvgggjfzyckbdhbpijsvilrsxazyzqbytsoxttrubzwbjvvovajiajoskddpldprcpihhlmcpmjvhdigocwlzvzfqgtledgeczfvkkrfmxrkzjkiioqjcowqotwjockgqgolrqhghmzvejpcotylswdsfarwdmkuxunfezxzlqckyxlftqvywyzpnwtkqiebthkcsvfowmwpvrrdkxwpsdjdowuksvohjnwurorapkjgktvafruzmwhfnfvojgndeqadcjkvxcbaxzybtwkyjsesvwfgniehhtjhjpadbbfkiazomeacgzgeccnjngjxbiokzetmbyyntylwczqdiagwxzkxljqrfoitksvmpkhombnqnvfjzksaertzzkzgpaxzeglkmfqgfvrjmsnflczvnktwzhvxlrjfqkkddszcexbhsaasweqzwoocqumjrgesfeeeeiefagcnxwgvsbrkfbuaatbhtgvbdzebcwoeezpjlxmkfutmyocbgeadafihluxidqdhsvdijcwruslerwixoodkqtmbtessgpmkvnppzfzgrotkywluggdvrecsniknwmmzvfjtvznndgoxmmzvgdeysaepynfshlqbgzegtbzeaontskqimngirbrlfdbbiimwkheqgywvkaznawmgnygkmhhvbfmxjixdrkangdvgtscvnipawitgbjfjfusnkeursvbnbstjxptpgtcdinugpbkycoexpxcxbygggxjunsjcycnjjbsvdqwebwtmxhwytuzpgkhoefpvhoeigwpyxlerltfcnesihgxuipikkcaimiugzjrlumygjugqdcyptoldghgvzehdhygzcaugncedeajvwcwfxvsrbaadijphjjwhxngwureooijsdsfxwlmgviyzmudarjoceqjvabkflfytcddnaartdlhuljlhgxssvzytpicrowczkvbpzyrfzyaymsdckgbvcjuplykhhqqnconmokunrdfdkjlwrazvizzucctuzwednukmrelocdiijirtpnoyyabeltfjfpbnevtptorlkdjjdksjzewjfsogfqwwiigcctidjvtjzabsnacsqhhejyraynssqospsjgrxlkvefrhzfskyngxqiwrykbbwthztolpnyzjsxbjkpfstywlgdoollxschnduodytvmxvabfknqqjtecwaaxqkyynmmypwwwcmphakjtxwtgbtsgipbewytncqidlyovwewxqgyussixhqnzjmajgaajmoaxqraqrjcvuvsajcjaiacjvgnujpiuspyzpgwqfvzugaprsbmiwbzeguwlpumssduokxwsiisnfbpuybivjmxsoeitbrhqqewouxvhubqlbxybfceicrmszpufttygjdjycyyeblpqkgosvfsgciwykrqieiyxmqmzylklxcllhfvvkjjqehsnukspgopuytztyeguaonvjsxdxzriecuwlmilfzkkonzsuhszxaxvtenvclcwvubexomzhhfwrjdncdzwuuewsldinniubwlpnvcmcpxxvokjvkogbbmhcwrehyivuuttqludwpxgrfesnxdkwtkzvcawfpqisxbdvhvaofeskybdiduutnilrntukkbshmzgkkbloazunfpnkeportkgwbcxejubgdabgauxjanmmdadcvjvrbrhnjybppaurzvnikflqzzvidncggmawiiexscexpuxlitmhzqpxbizlbblvzfldkeunepoyzkmmicwcrrendbpzmbxjahmzficcwswjjthutkzwhjmriffuuepezglodpdpjinvrkeddsqqvriresdhzistjmrbbcuswsqntqqhjhbcbwezzkyqpaahvucjixaicrqbrbxltvsdrhjkxaldnwmekqmotbmahrssanaecmzvvxigcumbkddqjgfffpefrowoofaghpfcupoplulokrrdiytsmobszkwzgjsaijnniggeatvpcdruapgikhimqzhkofgghazpyjadvcjmjpwaserbmrucochqgbncdlbrbpbzcpyfcvjwqmeulnnksldvbiawvmkkcmnfghexexiqfgnpqopdkblhklijjexqmcnbujjetxwvuirppylcgkugigranihggikihrdrjshbhortuhmzpmmwcwaufufgnegqydvgxlhfslqnhfbaiotlyakyuqapplgizyfxshkkhvuyojhtrvpirtueljcketiwwoydqwutropameeljliivaltfprhanpplqizogkukvgafbllcyswmkgsxuifzbaeckxttcgcgjhmfdhgccrsoiluoxyskzshvklrioiquhouykjaxmrxnoubozbeqhitqavizfxhhyrkuatwzckgqsunflermpogvqqyoiwlgajllkibntjnhdivhkfvtfusuqobrxalhrpetmrpvkwyzzpxogqdkyrsnhubkzwponplfqwwxeqwojijtwcxsbdtwduaqobiuxkunkqobjnavndwfnxpxpehvuvbjbtfmkrpcnfbibvlnezhnvinampeyrgpldlvqminevcjsehijeknlhwctflabsksuhdjhzvjkifzhxkamapnnfqkybczbgljrgjjdltgomtiipantuygfkegclsqcqumqirlixcpnrsdwxwmdzqbvtllscutfovnojlyuymrtxrtrnhbceoescbuvkxnjvjswpjgtyazaqidmcjudrrcmivibsxktlikynvdsxjdfmafdhdjjadwenkzfuelfuxfrhnfpdrmlbswmnygqomscshvuosuutyikumstsucgfggholyvawqqyuftbyivgegazguxfaqccdfjyjbelvakhvoflmvwtmpergkoytkxdwjqyqqrnjdoqpfiinblicssyadvyeakvwwbvkxtftybqxdellwanecoztackvmmpmlsybxfvcqohqbmbqdkvyjeddsztnkifzwwjzqdfgprokdstvjeonszuszeckipcsxkmuwkrjjxhnwmiqpirvgaynhkywiwiynbyjbffagsecadgxnetnawfzfgmwjenkfvmkyfefznqwpgxrsyaodswomhisbvodyhozebpkohdzgfvcsgwjpajoapzbskappltuzqzmyptvkqdivvpniorqxmwqfhidvbnavtevwibbmhogslxvromehlhymqhbxqstoqkijqsdvjmxofoddyxrxznnxeiofwbntrwiegruxalnwgckewjmimjyjnearzcybdvpxufeeyhveekehjzfaviiobdsvvnnqavcdyutpafrdxzjswunuutcprndxgwzvwrhenzbjljyenncwsfzuvkkakrlkjhpocxnxfccxcwdmyoqtzbbmpopokrxvfaogrgyqntsmvygkclpxxohwbdfjaxdcmltluyyoznlxjqujzkrkashafxzutssvhqappykpmkvslolbhdrpzudxmddmikduxuoehflmjaervfhxeetgrvzxjolzwyhsppwabzedmoygxjrbenliktlufyifuxfklocdmosmwjnkwoirnveocbsuywpovdlgxlarvixpoktikyqjyrapbyfkbcsmqdvgpocpdkzhsdnrmrhboutitwdbhokhnaeupnegjyueszbwrimcpcvlrwpkghxmzfuckhncqonfytxsnbyptmpdtuapammxybvcsojnrvgvgnzwzblxgztkgoloiregqiaoktvtrxwmsojtztagehjznedzkpxvubzvrmkpeamwljdhnxgqnaxscjokxkwfslxqufcugharqlaghgtlxaoeafphhckoihtkgjqnjjrwfruuztaywyecmgacorkdlhoslaskjygbiwzpmmsozhsadvnnbimcychihxxbpnyfpwjkjfbexxjakaicykxuiibaklwbanzonpxvdirnsfkefwbwsaxixgufbdssiigoeimtnesijinfhawvogmkgtkssmmcjxcchphhwjqjwzgnqcizmrtdyixzhezyfhncybrsskseqzhqzaujdmqpmsufzbzsmfpauwegqjzkqjcdijqscwbgjlmkaltejcqdfuuolnpluknckpkjehvenxpjumuqqnvfepsobzuonoumpmwzgpjbphkhmdtxqopxmrnmsuoiajwwetcpcszvqgqgtirredipcqpwbnhstsagnhcryjlqwwygtjpjelbqdskyqittbixrsdanmlzxhjzashcyoqqrvkrymfhqzhynxnljkqwtjgitdgcspaqywhrqlfpnwzhlnterjgzmtinzigjnrztcljyrmbnjouvbemncxumwkuriqxgfpourzejdmsbsmfucnjtdynadlvsaqhydgfjtpzrpedeergltkcycjmdhqswwmchyogcszxfhcytjxwxnzaeujcduvgmqujljqmdkxkrqnpumhwamvtnpyussyexplehmzifcinmdnozfyiniimsnyghfayteeewenlgpfkbkzzxubjjicozkqxieamdgpxxlvwzrwoyxadsbqhirwudfmphzlengiihqfpgthygepuemmrnqlzcuvwcjfwneciiarnhcccdhcrivvzslztbqqjfqdmfxcjrhfpbvsjwadjkjfhpguiccurmfqzxznjxbpbxmpyqmewvsoumhtelakpfqigsmksezhlpesjchjbtzznbzqeeiaqygrelwigezouzhvblxsnfsivdlcstdzuwnknbvwzlsmzpogmrzegzfspligmzeradmxzztzmwahfjmdzjiynjvgsivwspylnaxxnqgdoqooezgvapihagfzoqmqsykkftsqvubpdqffovwnlajbrbwotbeojblduisghingmybfeyejlckfjwiarmraomvconbsctlbznxtclezelcdcluceaxvbqbytqfsmilwoaylumzcjfsdwkqhwcrruejmbcbtdzspjjggwcwlslyzkywmnwhxcxqyykzhanvfivqfxngbakxnazrxullcgabgkdxgsdwlifspunbqiuesaxluzummqxtvtvbbbsklljabasjxvotmcdovqrzajopvkenpnngziguypimsibhgmlfspgcagjhpeialbmecllzeopbqudmwyjyzdxepazeqxjlxoxinkaolhrjnldrtvwwumgongivmldihxqzesvgikzzzipjuggsreiuqnipiyswbyntzscssrvmvcygehujvmdsbbpkcvxhhomxkoklwizzaolhspkcftynwjwnrmjpiqhzlkupbfcgpdixnczmvtyhkkfmyekgnthkzssdisunmwhlvenbyrjtqhiuvrcxpwfhcescsupaukyjftesdjuqcomqhvdvzuoghezgidwucwqvoqbzgedxuftcmoqndnzoinqlmzcnlzyszbxhtpunmuqziaofkujxaoixdqkfddjudrbprmfxtfstvhkccluhixbictolokotswqxfjzkrlccpimjxhrgxvsnznbmmnbqltyictbxlbpisvixrverjatefctaofdfddlibpathuptilcdhkoykqelzsftyqjwadugiymexkgjijvzlnmeryolqnlpontkymqrxlpzqjonhfiohtqayrzhkerjdkwbrificksekzngesrrbwxgendtawobkzwlrynmunvtakwyzjztcodhoooiktljmrlwuzkoptvdsrnyfngluaxukkohbzidynswggimzkajhvvamnaevftwroorhxqucrinpyuywrplamcqjeeenekkdwpiukceybafsuuufctttwbhqxezcnqzsddskztxpzhnhvnjlyskbuareagrigwtpjhfmzvnkruvitjozrowmwksbujyacroakvnzezdxdrrvukywhbecbxytjlmtpsscvkarifiypzggsrewfonvhiakozazkmmhaspoditljwkfqqtgvyzonskzpvejayorqkybgstgbametwbdetebhwthowfjlukjvzsvqayjjbjabqoimdkfudsgbymmrgfbvwqxidwlzenfvclrgxtbthmangnieqkizruvgflfznrzewoxxfqhykmxabtruibwdfjicbydezklyucafzreaffamiuhnewougppsiqekmrarlqgbtotyimzmexawviudaihzgkikkaykyutrgkkiaaywzitlkxlmfuxooluyuqxpwdiqcqevmeumkkxyaevpnlbzomhdrzjucizgmvjentwukjtbdvvopfnlieqaxvfaxspfnzqwwhxvuzfhdcoglngbqkzrengxbbgpztjpiuxuwqotnloozrxnvakgttheybnuspapkvmcfmilarlzjxmvqlwhcsttopqpfqnkgmxhqewufmewshqobtpjwdtwnoysfekffifsbpghzlpsgpuwlnbcpxrewrkcylzcfwjvnhzyewjndfjucxeyyignxwrwnszhllggugvnosxccamizminrfgqzhdnjyredmjdzylnxybxnmeocgirdgdwcshscoybjbgrghhxqoqodqjvqopmkclilwjmxactsyxnubmvrpavwobgdljamsunzaltflbwkkklrtsobtaoyvsilaavgabcszcxslotzvcatssrbcvbrkhnxvitcwsbohyzqmmxoykzrmffbwjwxsmazdxihyjwpaworaxzuipnwcwgnmmtushvgtwwbzxuzvbxxzrdqnrkgultbbagretacugxanzjyunglrnmsyfnaimergdqueylasjpwuuxvrglvyukdhssgffwytagantematjsunvbrohpwkuzdzxkhqtdqfavtnygvkojjxjklbdbpexlxwgrfuiexsoahlzxckmyjtpkvafzwewmftjertahlziuaiynmhmyahcmjxbtalwvthqrqhhcqkwbpenwycwbuxpmhdmzjpidnderzkqehrqxdjoefhhsoauvmiqrruiwhoxgwronlpjgqnsftdcwwiultohfkhwqfnofpjxjsirbjpraktjybjnzcuiuvqlydhpbfdsjbpugorjwehvicrqwkpvooczfbtkcnzrnjwnqgguvjayhljmamohrudhubalfpgurgcpotunnaonuqcjhykupqrnccwgnrqlpvniuncirjkoyamwvcihakkievdqyrvzucmqrvuotgmgpyoepplppbangxypnuqajrpaipdksteagacfvsmqgliiwaajmvahmwjfdsmiydekusmjtbziipkjtudiqqacniqcxaqnvphhxqmtgsfrcvsgzmnifzqvqexncikocwppaowidluwljlofhdcadrcjklipzsjxbueutnigydqxsvjuddjssrkgvhimvnwihnbrhmccxfofloqaccvixauwhrnscgprhtegpwwkoftksizeveqpbemswducwsfffiqsgsceytyzwiclphgprwupcohpxwtasrakqcahthyuhjflzrbmrejujkacojiyusyyxzpbefsyonuhrzmxbnuxizsvbiiiyczjbdewluwcvvusdktcttqouotwonixmrtetfvxgtdbqehbeaeeyjagiijvwubcwbtfgivpsvbqreyirnopxyecwujkmsvcsrgmxtwjoowztvolgzkfaphwiusoobseskjrlydqqeycroukcocrofwpxdnhldlpyhazfrmdrialcmptzulukgwdukfrosnjakjcarfoppnponztvutmkpagfvqnxvarlsrgefjxgoazlxsvaruocpbuyqlnysvlmuyfcwbsbxbdlbpplickpevkphfqldppryizftrstnkybxtlykonwdseialhtvuipoeikukqxtskwpbgslfhuzgjbalvltwwyuxshvpyrlqgcrdxlldqmqdczmuoznmvgvrltxmwygvxnloskpuvrrgoxoyizlwfefieqrtyspgrnkcvilsufwvjdilagsvytqktsfodmkkqfjkjupgdlgaoxdxfrcgieilpaaopanfpcsvfehiuwdbhxkexvfxdvriduvzczoxbutzmxxwirvgtxdivlkzeyrsuufjptdguszgwcjbkwlaeehxtddgnnxbvadnprxlzzvumzqgtulmhphkccenuwdkgbfizuqahfbfnjwqslnxwvbjgjxadbastycfvngzxuhoiolertqrpfzlwdpkoxcgujqkaerarpiolkcqkfqdlulyqddmwvdhevnbnxhieqifgrzesenzxakakvxdgmmoxgtgnvbfhvufhruawxmtkysfjiwebrwbirbrhidynsjzymayczjtvqdfcqpygcezfgzfxjfiunndtulksgkyticupzsekchrbwlfgojyioyjnxuaorjdcpqbqfsqbugswfuiyauhtpmrnoxrpoedoqvmoygqmcmslloyzyqurwnhttdhtfhrsthakoroshtjinvpxlxsglfgwljoefgctcvimrwzzodjjmpiiarwbabmhdanvmmabytpgvawpudirgyzfnxenphtwzfyyhbasdboiipomtxzhjibwzdpcrqedebumdynirugntrsrfksmaprnvrzdnoosbvwusjascyzsnayoezwmlycuerhtbdftamrajdmcreyltiyyocurrrdgevpfgitdxziedhsxlitnlzyrhknuqwgvoqqmbohpleaoyhxfwktldvhyshkrmtlgaoiemfddrwbhnddfjkoqmhrtjuzxodoxpltsfxfdytzzduthmezytrfsvqqxfwxucpkdjdippoqszvfeqoddzwghdalmtnswqsubmtlujwzhlyoocesgwhjojfedaxbolulhtdlcwhthaxhmvkvoaxwtmnpkvhpocgzksqfeajvtmeoqpnnwpdzbtgogprejqjmdhvyrsaktxzfeojfuwcvyiqivsrecrlexcckqkatbtelurbegulwqnfxbdcylpdleogvrikhozknjhwvsnugltijecuyhlwmfqlyhilafvfdovudzozyoxnfwuxzcejfpzpkxmcsxjvnxgxdktpcruvznybfevtwvdujaetzrpykgfeyivoqroxynniyjnahzwkyfkueuvapskhauirezavdhltwxfjpgabdqzdxarajksqvaiyyzuopmilsxxejyvgkxgnwfoebfycyyfpvsxhtvnyreaswqxoscmcbcuncvqbospsndfyupclaindqitghjwoqvjqvjynpmtyvmxjiahcwwjfxuzfwsrhewldwfmdykoqocnpqoaohdnmqpgwuaqqoykreoudafyixoxsjggxpdogsnqvedpqinnwrmzwypkiokcexxzxgzzirpazxwkleyylqzuwzyvbamgludibhbileanwjarvcygjvzibiqrfbdhabvjomsapkihxahhnxkgvwllwngwdinibwnqcjlppotfvaghancrjnpruvqeeqsjgenewwvpgngbbyiinudttndjynvfxodnlducrugirbpdwmwqbdgxzmnquabyjzvlalzywxdzgceelcmpgpdycagtkjibjkamhgdpzlqshukcwwiwkziecreeclpzptgqsmbadoucxlorhtcjxqgjzvdthlhoohwqwmykpjtucaozngntaawbkljfxyfcyorosjxkweilppsrxqkkhtxlqjljkznxbvnhxufxjghbcheuwqqouxxvpupfzqavolnbzlchhvlutsvcgdxbdvrzqbonrprverkxwzeofuroowcsyqconzrsmtifrdnptmaghgtdvvxesqrcmbypupkittnfikdtunnmybzzelvvjrqvgoaqgzgnhtcctcagbmpkywncxuxxzvpqrszlmtvfdalihlgytypumvsmwaqlcjqadfsspblmwovdzjdccnkrmsfcabsskygstbfhoxtygxzweakvtkkcgifdtlgimsheaahlsoemhczbjeqzbnzotgsvvhvgpjjnhdfjfdizvylpaftedmuzzeineiqvqyccksarguharvozjecmimsrgzcnyjqhydalccldhlopiqgnwfnqqgyefypreqosotbxqflqzyshvqjbtktryuibpowufedwzrxycgsmszomqgmjylsgvfsyguqtffxfxrvkpciwuhdsptwkuaxjohezrjetijgfypddfznqgakvdcfxvkzzczawhesjgupgpzffuaonnnvadywigygctapglxworekjbhpcbbzwnfivguudbqkkwyebuttxskkldjnduoxvvbuustoowcglxvejojsreijekrssdsmcsshvcbtvtejyevwwrooptbsayryvhzlfhlfuwyzumutvdhmvbetjunekgifotinozpdnkcbsinmsmskhuyhtdnvmtjfqojohiuwqfhfwqmxbbxowtjbyqgmquzeyemghstodhkiagbtrlkuqtzkwmuhnqxjwmpplfmfapsfqiofqxkppqomiaevmfndfroeetrutoxmomnrlgtjsgpzskbnukvyqeguvuezuegqdbegtdrmndhkqtmznhkeodwsajeepqmmgrrxbliqfvpmvclwiqasfuldhbetamycjidsopuwzprhtszmpwshrqxzwcvebbnajuuwqhlzvkiqwyodlquwblkfddltvwgwxhieueoncawwqbzwwuejloisymfbehpljzdrzlwjrhwxhvxocomyaqeicachkdpuuqdwgczpudoafombawgoptwrrzhzhqtvvpfhgtgzrbewvxfqkxbsrqvdealsplhsscfxesgesvapthsgygmxprirxojbhmxelzbvkbbxsjgwlmdvxtyxxzivprdopldpozfqljflnxgoowrxjugfimavlnaikpvfyihltnbzpncacfqosuytjxmtmipszibkclztxobsvgxjywaogbwirtnbgbmrasvnsirmajlhvgsjupedumtdlqmkviwivvzscjpxtklejrhbntrevfbifhntcrpcqurjtbyfhwitnbjtyqngbnkhzrzzwbjxdwxnstvpbdsmkmhmqbgmzenncvoukeljfjgdvmcptxqorimjoxabrgsnrjhnzwiqttuayeufpxbvmybpsgacxbijrugcsuarifvwxumazmdtjtnxvkwedtrysedklkjiukmiikymygxrfasjnvlhdgzmxvhrllrmtlfbrvtqxpchazepucwajoqcldnpbewobvlwjojyfazdwumopcodgkraicmukbbdjkwxepewvxufonqjylkszmalettenkmzkmzabnytjkgafqrqpdscssnpprlyngibehuclkpkfeaejmmlunjaxteuheaiyfvbgepcubtmkchrjprxgljbrlqxoebnfyiyfjapwarvfomwjzdkkvzsdcdzlzuqlozhfrfeyqkjfzkegbziqpthpheebvmmipadvxmvyqjnclyteiiuzxqrixespiarmrgqgbepiamayymihgukelteqjivpyjhennzqguemyxktotsrcaihrimwciyimibgtvtfdcylgjcwsdeaupbgqswnqvbrtvopdvianhwirsigdwmqwpaoviqxqiciuujnommiteckwjizbvauguqzxetqyvezqyaclpcvdiwvmwatamcezlurzhurjqxjxyfnjwusxrbcswpaxkxdecnyeworukdwunjmqrmzwkfqquxyvseesiqyjjrcnrqhivrzctviamlumnlynehvlpouiiurwxmeugroqvoludegadsmnooedehfdbqsicaeqgccelemltilkupbdocpwlifgbxemieblvzpdkvumtadjrngzbbhrytlkdotkfhovhqsmrhbczngjpecipvqmqndpbztafuqefnnmkkjaarktxgdfjtzblvtcwhpcpeulsblqaholeifuaibofdncwwylyldskmrodtkunallemcyughintfwxtzsqhpaqhzwyncjaxvoqdidjvasxkkvcbsahnfzcvatbcsvouktrqqkolunjwjhodcclclqfifjresifszhdgagtsoekyldiityhidaypvbyzlcfpoehynybhyxhkupvgsdtuuogsrvpiwpeckejzhcwdesxnweafgikuozhexhqqhrcicfttwqtknxaospfzpsbmhcprvjvpeugavolvzwyxmrjizgnawfmwufqxoeqkvdeybwbgbfepeycbbtqtjywzqzaqoffmqtiurprsozsvypmcajfazlkktroecdkioxtzvwwtogqarrufjrwhqqxnehykfsgwhhaiygbrczmwwxaihljngjcnljjlkvmtuhcrshoeamaoxkjtbbmwqegtaekjdfpnwejxwjknzwaiyzsuhkqbfgfhzeytejnshvbaqddfjkpeeqluxbeqkwjltlyawihuwufwxqbmoenamfdcddvrygkcrstvamljewjxdpzfmtircqwavhaptgdqmkrsdrwmjqkzwxdhhxbjaprihfpjsfhtyrirppxrfkjaadpalredmbxozjqpsjzyykzbcsunnqzcppkkvxfmsgtospmctoswvtebynvbnbuhmkhgioldljbmbccmdspurcnaucogoqpnxqegfebmbzadjieyylxuqasslpomgnpwwouejekfbgkfsajcxqacmwdioigvznsrbwhzclsaalrrsmkovimkpqfrxxlakzhszphmwvmplujrnppksztmyjqqkjaidvzruflwlwxgwuqepesgygzpprcpehkweqinxkvoejuznltotyrwxwatjldfmnkywrthgtliecogcmnbnypstubgzuduraybxaiyeovcgdfhxhyxbzudcljzrxmybseanyuuybewzrjobfatyjokeniisaitnnrzdqyroatfvjiblsziouvuinbdmigcoibhxbigqpsbgiyxekkqzomvxzapmmuhvmimzlictflisttcasjmcjttsadlrncdtpqetbcpselcbsmxygkbobnsdbdnmyvjgqzquidbimefxeakjazangcwzotlbjyjxklmbyhtjdacitvivlbxbocgtninpyhqyviumawmikpcgglqqscgkhefvrvrvbdthhywymxlsywixwicddtuiforjgzanwxolqamenbqibobiiyfgfrxaqskihjeaxzblcqzypwsoixromtbmxkadbxifxlecqprpmogddfihqolljvdldgpnobpfggmenuttjheheeglrspdmleoyhxyycczlvabnveqskvevapxbcbazsjwlnfjvpealuzwdxabcthmuuklyzrfooxxkalvvelzmajwzplsmpjqaradkwgcstmkfoxpxxbvcuhhariunzphsgljepgwhadvwxfswuutlyubvzvqliozgjksqxdkqgjdcsijrwhaxhlkivpcolvqnswldznswhmabwrllfjhkenkexvnyzazrlnbyqobdjigcsxeuhpzjcjjjkxjesuemsggpimpsqzkxbowuwjgieoynbkzxiugovrvpfsixejeyomrrfuvhvndkwaazdcokdjlnsuaffbndwykuhewmfglhqqpzpzbbuvwbomcbvgkrmbgwnkodyluyndkbwkikggopjgntfuxcwinrilnqkcaqdfnuwqlpdyuoiedshrvoocpkcjuegilsorflmxbhkftlreeztoqxmogijvnrgazmygouiafoenjcdumrofkldwcswkhigjlzdauhhjraomipzhtlndhbpszgciilzlavkqxeuwpesndmqraizghghxyzvsjdijetpigovgxsrvtgvtmytcbuyogaqhvoikfnawqjrmzucfgtljmyhxcrtqkqazjmhrdghffquihtupwumqfpwxgqjosjwvpsvwylbpeyhkgzggssolpwjxkbmaixijpkvxgglmemlkpdyhixcvzggsvxpnouotdpmknwgqnxfojlwjasgctxiwxewrkmdqgkcpmiuiajeshrdasvzesbkvojjebrapixlwckuxqfcmgxsnjypztbwtzvdsovxyclqqbsdqmvniqhpanvdbslvpyicfqoexwecdaleuuckdyqxfygravhmrhldbgyofjriutmhrkztwxgevigksnvyzdbadbfwczpeppwgcswxlyvgyuhstoewijxgkryutcmqsmtvsxvgpeyyqepbhsovskweywjralkqqqixmdolbosqqknzmolhyxsfbwqekpeejbdedxlfxzaqqwyfvctlskptgnjjnkfrmswzzqnlxsywbzkrujpiolmlgdhapiugcuzoutkhdyfyaunqzyuipmvwuvxbnmcgdzerlzdgobrofuenwueblvcjyuwhbehyrschghhdtasniemsbmdcsmhuywsbajxhivwucghlttfmnlxwuqmaojybrtyrlpvxzijctjfftkruhbchobsnwouquunxkrxqmaxuorpqnabusqxgvnadhstpxsqfxtqqvdzqyfwjfaxtajnnkikvgnglthamuwcorpvylwojasgxlhhzukpiqivqcrjfuadaceurnrapqiukejnqirnpptgwltnzmoubxlhkvmqswhcflcqjezoqfpoxcviuknyfjhxjffnqvyjryqzwtiqsqbrzbjjzrxurdpqawxcezbkmokhxzzrsmkjqogjmwkozlyjrxsrdvsptdqnclatxnfudbexdapnkmbossyyrelzrvudezjoiiokmtbvbhzsolxjxmtanvpgvqhsxcogtzsmdxqrzuobogkrctacgoifjzwuvixhtkvxgvwhrynfwnszajrqotewvjigxgfadpapntqhtaljszlzdwqxtwbwsdsetpckrrncijesjeuiqlvyqidkjkxycvjvogfnaasguwtppmoiweflxmhzxkadkjqlupsrbfrpnxpdpszvcfkafrqlbqdvuwjymyqxpuubcvwdwzzbcsjbgvkfmlghnfbfpgmlatxofzwxrifcybhswchrgvbvneaxzsjnfyercimidijmuzwpavtbtshtvrarfmggmzfkbecjeumxjghaaoilbjwpzrorlybzsqdrkrydtydvurzkujwazszomnkojsirveibgpojrjdcegegvqvnzsbeibiqrzrlxvcqfvweffajpvnexqvpbnstzvuzdvvehcldjxfbgrrmjrexznlzsvdnlgxavqhzlzihvtoxzcjjvmlswpsxknhvtqktgkwtnjaztkyokmeocvsiptzntcsnlwbewlujcaeptpviaxdojwyppinfftsjbgvtndoheuhbzbqoekpkifvlpxisepawzbgiownbxlyhshxyokriqhkvswlsentcakxnunubjhxjvarcbaazxlwisinclqovtbqmfyxmkiqpiguwdacirydusclronfodciflafatfdopvowwhcvpgeovgoqaoeawhalldxwclvgciqihqnxjphbhfldurydtyyubowblsunlgtogyivaknrxgqaaozhccajxzdhwooybhpvtblqypkxcbwyrshnfoubfyerdrmeqmcxcmgvickofdlahufxtioilaiuxvvmsbtvlhzdfecbujpxckyqzljpmcpemidqmvqtofupehincprazqeuynddltctzltoftybgdamklmbxftkdpilwdwvalvvfbaapsojutjzfbjoimavogqshzuiywojapdtpazxkkzkerppljknpyqxxdfytuaganyminnwjmqjkivwibnjylmgbagtcvambdvhwolsfyyfusthnjjmbywmndbprzoygeutankxrzemmvealvoyfcgmoncbwodgrphfllktkpcjstdowlmnmfzxneefixhatqcrouxqwrokpqjtmjhfycmihwqcgxtfktlamrvlvawaezwjgvblcbzahavgvxntpehcenetmqlubwnzrmuqfhpoptfvwvqnstxvzwtgkyypcvvrqhnrjdxxsdfdzcsibdblcmjazohmkwcxxzlkglobrydukoeyravvfftfsvkyykixhyjbstnmhifpbrulblqfmnznxpmibkjqexwzsjrfyvgkkpeohzwnsbwoexcpuvhmjruvdayupqegqifzutymuyavhtlvsaavcknoramyktwbhlelbvqwywkugzlokruynuxqogodjxljpmjeuzoiayivsovgvnvfglaotlxtwpvapaccedeifflqyulxsgtofienzutyepnhbxgqzlseknwxbsuaxrgmqdevxnvufunmxzqxhupunocgflmwyakjopoiyvjabfahhifwlobyotbhjfkcvoeavgbbbhamshqowtsokjkjplogpzbrttquuykanvwzkcpqwmldpumiwnkgvdepzzsmqnhvtomcvdgktzvgmrvotaehwcykpmxcymyoycyqepspguhhrcfsgsezjsnzfrvcgiavhwpnizshdjrjjayjnposalfpxvslxaleofwuhnxztbbdqxtpfytlxvojkyftbpmncxcmfiqqtasefnoaecmpvlnapbxyckaelswyevtuyzecvndsmpgzyyqlagiqhfvciggurqkwstccutqectmpawdoipwmsvfxsfkdamvddjhoedmdzvvajhdeegwgvntosniqjciduouacegcbpguuoffmhgmmcyheifivyzyktdloiyenfymerkmswjybmxdpetovpaftrbygyrbrhtaepjnovwfsktthupyxevrgbfoaqwknolxrsqiiikyfqnqrxzovnexsfchxbvwslfsavocspfpkymxlfpzqupijpzbikeyrnuuxfmfnielcereofesexwekdvcpladigzueinrdbtbbyzbijkhfuftiyfktweyqvdyncuhxqvakypmdzylhxqvxmlmbiulqqisxpkowkhuwyotyqmgytpkysbofrauidbaurvhjnhskcqidkzztwnklzdhdgxczbljloulzvmmpgwbjmfybeuoybykvtkjfngloscqcduzxnygqsqryktssjxanpeemgmmzxmvpcgtnomzebdqthixapzbgjfbtzccurjdtakfilngiudkppcfpcqcifzumddpabspojxyejqoktwsvfvwxypghseoqmygwbhtjqqgwgnysfjpccpbgvvjfagkymsoyjdxwzfbdtfhmdvdakerbpuckhrbjgeequhslouqleliamzsesvzqnjdkqizzzdeqbrkeocijayiwvnvprqiwijjmffghuudlwdzwgyoasamiehrzqgdlvzibanimdwugvbslrregbvuptisbuuspwdgmrnwcmhymgcnolhsloyosklhvjwejbtguxmnmtynhvzirdpqqujlqhptfsvssohizlivlopwtzwgfljljeolhjvhnilulvpciqhkljtqcuvjghwhorfiyifxiynhohwxyjcpmxmyegjpdetptwmucwzfcheyuzdjnkqwfljrsxzizsitbpelypbjdmvzfsdmpxjnqttzzkityybqfvxocmxglyozveepuvbzntvetfasjsgfxioqjvrvusnyudviubyqahnjezzhovueckxdnmcyatgfamncnkstoltwlxmnehnsdvmefylroeeexpmzoskktkaqxhfrjrqhxvfxhfjfhfegoawkanulhiowyphhwqmrxkxszsunqcupjyeuqcolwxhmludtnwxwodxzvhgemznggzvqkmgdkojzjjfaqqwskxjlskxnowzsyfbvxklmbjmrbjqsiegxlornwxmirbwjzgpmjkhqfroghnusolqryghbyqwzagfsdxetpixjclaqqhzylaheqxvvsqpfrcbzpaxjfgosoeauarnuatholpnhndzkpdaozfudwrkrusonxogroxqznewkqsyiyueyvhaudlvhwcuaafouwhxeihfymdwcrnlnjaspikyazzlyrwmhzjfqcmuuwnvaitpiziungxadkhcmzzeboezcfwugyrwyfnyxjcdfrgaemeiojeubvvtoglsgzhucplyerqnuuksqlcopoqrlhvcbhpilfamnpbqrmzbatvzjabtmvmhtbkzwhcfxcoaypepgdhnwumkonznuduzuzihigfbhsoqotaaddeggbsgcufcbiavvfzmlqykxjtlrqhrlopnasykyrehjesvezzuxustvvjxxumulkjarczmkoicfyadigehieofldeislegsjumhugfkhwakllwtyvoiklyddskbullgfdsvidcyxejdxmkraoxfisckynoomuawenelwfffslhkzqpxnrlurjyxaqygdwlwgnikbfmtjaeedrevfxcgnhvxqntekzkgbcsvxklrharurrdaljotnlaajjdqxkzphkbpqzagtqkmyuiiiclxmerxcycsnibsnaplrpkcvzmkymccsridxcdnrzvsvdcagyheopxdjehyrsiffvrloqecuzxknrmwlegeptrcvfvtwgpucxmzcuilrbpgsflxncrirepnqgypcoskicjokqdzzbkykvynsacnvubgdanpglcdslzievxuwwrhleykrjivjuystafvswkhunlnykrfsllsjlgoawipoibfgiafqpbyjmcggymchxkrashrnvtridguovqkpjukxmpqqozixnqvgyhweskedclmrphodhgkyzjckkkrcwjsjvxtdwpowwsyoxxoaysuunocycuoicpyvbwxueaqkagtetojkunizyvtkexfnbmsoqembjgnmbcezdgbdqbkzezvilpswnrmrcefnjqvllzbdslequhhlncqucpmwatvesgiyffvaywcwtlmitomoxuaxphwjdvkolssusojqbwibhtiyknebmwwfdnkcwctrfkrotjusctduqidlekhilgyfkriklmvkjqrapfdxxawygugqaoueacfkqbatchpqjbsrjhhqwhariesetmmguolnjngxtwnjywahbrdegzehkforcaxukzvwbpzdixednqmjznqkwiepwqtkclnwmaqhjqnhvopwdttnvnsxnmpquntxpqvrefndfttttjbtcohlgpvvhllorisqevxkqacvskjouvanppzgojhlwnzsyghclkabqxfxzgowpnbpvuwjghhzlohgqnfrewskbqhpskgjfdffrclbinvzsochcfcnkekkftldmvmvlekonnsjeawsbywtudeqqqgvnuvhwezulmoaloomqmoblhajyprlzaqiehzjisziyegycxldrqmxwdthaaspiirllikdyiqdszgiqbigslvltpzugxqumtbbzvfthgsnhuhnkquahcclkgyukumeczmaqkjznhrhyygkhvdmfwsctdptcmpjdnbpmmoqpfomzffdjzusojxatbfsbihlqdknifqwqfjatjmiaspxzvbtecuekwfuywpjbyqlgsrjgpbplthidtdwdyvpwgqkvwkwlfqjnchehxonrcgajahcdamsjtcikyzmibzppfmpbivhvxxuaxnkxwoywwprmxkpcwxkmavcpfjdwzjbkvgijistgvwmkxkfozopxwtrlndsgxbmsxldypqykropsnpkhwuniwddznetpqlbtvfxkusungfxbjkhszgqlygcxerjzuvdfkpxmwrsjmxgovrlrnjsltdwavgxemsxkrxawvodigvakzbkxonqgnadvussugwzelnrunbjnjjyfmjcmsmiicbnvlmkptssjsfuefcdlwpydnhtsipeftuyqmcvoqyevafxeciqwezeianwqufwsllosggmbamkewczhohpzwrhyvffxexgdeoguhqfukototunveaprxtchbenwfrsampgmrlasylhkgjpdigdwgbtzvpfnhxovhmzrgfyknpdwflbxrgheoamiugvssgaogxyeedtxhejbhueghffftehfbvxyllorupzujxpewrfgcrdqxroptjmufsxcsvwnfvvaisvqzzafqiyghpxekydnergcjlkgvqtcxhkywfipwugiiteouddridgfqkufcbzxpbjfgfxrvcsyityktjdtubjsmtnfdgwfhvsdzlqkiosiwsngycgmqvpwlhidbxdcxtobiudsvrffginrxrgvklbqgiuknqswsveeekmsvcfsqxmiuebchekbujqkwzhcicqlplzhfxjqjfkciqmtrancufkdcymbsgufqdlaahbjwotaqzdjbmsbqolidknuvulyeghyuqdbcvovxcweorrsdgicenceqnuwohuenftgpilyhexfecttwbqqttzmzxkgogmlenhpollxiivzdyowvsxtwqbfmtzjykowxwxxkwsozkdzautrhkztlwuqgdljxbisageeipqjnllyealqunafkbxbnnfdxhlsuojlywbceskraecjkjvelfkbdeyrzwieyqhlxtslghoxxiipuwlryzfsthetjjjwyxczjfwaumyxyzbnmiyuwikjkhimkbgyhrfcknxxrpsrdqxqccwilgbnikfvpxhlusteclxeotenxapbhvkndarbewedrzshiplkypfhnvziszywkyzgcsfwtetaxxlevwufxtritaiclvhyrvcabnttmzfdsaokislvbbgqsqahmanhimjqftdemwrkrgcyjpvllvmkjpfvoigurgipnaiisokhhkrfviatmtebsijsbdomcitxhmjetqooyfkjpbufodiwawmwlxpvelcxesnmbgbxdpdvgdbkqgyvfdwnzcqqojwqdsqzfhamttaylilqbkxatygzulwlbazxyfsobemyvipqxsucnatsrbsypzuhmmheqdznfkfqjbdihbustnmjpuogymiuqzxhaxuxqzusuzsqltbrbealxqfmnnfeehvzyaompedsplmxoygeqgmirlixsmftucledznvifhtaniqzimcpuioujswsztpzpxafglwdtsdaiyqqkohhjkczxiduzimqrmccfozxywhicktkcumgmclayplblwbaxifxvqamcqgfkduxsyubwtutfaxmeirdohfgscfsfcmpqqmvtdkfoikoldoyrfvliwieeldyjqwolrisbecgycitvcmfcfjkzyndqudurffubipabtcxpyvqszmvknctfbkvzewztumtnjxdemojnuakryhrppnxuorqbbmdbghgtpecvgnklysaypuelouzgmfwbxisolprjousbsgkzvbpeymruneoystttpxbwiyuaezxearedguyvxlkrmwxqmeqpqpbmatlcpmjctpvnqajcujanqgpzrehwhrsxfqutixxoofchnzjmwcxdcthxvfvfmttebifufecsmzsvlvanuileyuujcnxjujnieoubybeusbgsjklfbzcspluqsopptlpyvzzddbyfricodvekdtywtzctphdjotdeymlngwznfscfyoiqicdelzgrkhoawncvpqpvgvumhbmibjuriqwrhydnhsufynsruivxxlweidyzjtihhzycuxkbzmeccxtsheqcltjcegkzmccikjcweksrsbglrhutwsqwecpclbxoxlvcbfehzahnlsvqiqbofgcjvpezyexheocgreakpsgstttucqsstoyugdsgjrdhxvvztyagpxhmczmbpfyjcookonibdygbmpscnyiqbxbgyqfeacstvtkrhzytduzojixawlaecuabpdoisataogpenjmyycbniutlknsdnkfuxyicmdbibjjlmrzqcxlknbwbkrxpgzqbmflxkbkgqcpxrvcimrnrmqdyxwqzqrmshwgavneefjnoxjqfvyorkzephhiavuiryyraesgocmgkoisnsmqarxternytnglymkhghycxamxsuifdhtizlqnopmqevrdsqfmlzfxoieytgnwnoyocoadowansswjktlvutpdqvbwgotabebxmeaiipqtqbdedwlybejzxzfuuovoppepmnviudprolnagnspxelwtnlditsxesfqqtuylpwzyblatyajpsqhgghkrklxmujdgcsnyzqrgvgwflhksmbqmmkhrayommjpaoxldcdbwrsmghlyfepojncvxnpqpqkpdljajcugslxhwdlampnaofpfttfgzfiowibxgtwxzsibpvebddlsbkdvcjmiuwmxzuhulwcxercmsapqyhsalrnblyyjwdeodlqhxmftkjevwpxluexpfgupizspaieplnenhtdwnxhpwzpvydwuyoemjqeweskfceiwsnvbmiwdjcvgylosznnpbfsuocxnbyvgcjyodzfujfdirdjgowanjzmosvrfiqbkdwatbfbmipncnfxczouylggpvfimfbfmmhtokripjopxgfyjhpcznkbcfpfiyatbeqximokorauozrynfhdcyzhmmpsmcewixychrmogpmsfksuvufqcolmumpavkkmdvatgbjzkjucyrdsbwbxkkyqonjltefrjgistarpoxbeqiwearlznlxpwufralhhxjiemzunbxxkhjjgorxqfxsjpoxmeusorxbhaztsgxptpdirvqmsoxkisreadoqdtgymsltryuvslqiqoemeqwzdxkufopmvuahwexqrwigxslfpzehtvtrejgsxginhkbbozkdydfytorcwxvdbwbibgiqcquznzoscejdcoqexacrpwrkbrgpufmzxezctikibmrblpepcgyxmvhzyvygegemagaezwsrdxgkxwlysytmcigkzceyamojwfdhxkofpbxovrkgzkbdtofsvmlapuuesiwknhcjdtegpwfvnkuxnxbyqbqkjusydmfxbkothzgsauwnakdakscawapsiphbkxdjawdkonpniutjpfcezeaovaqrxmqncetrhnblabvhxracvjgcweoulgctbgjtwzxxqzmavvvtyqastdtlldtcvsdxfwbxilofjejompgmoorejhjdnsppghityofxzfnfkajonxzcgozzsgtcamqjtqfjgtnbdjgaxhayjvoadlgibhtgntuoyuvuuaxbqzcewmibyxfpmbytbhbvbjeysfdutkxjlykgrprcmvwhbohwkvekwydrgwgpcfpyknejugafvjutvwxddvvmmqxvhgkdvfulaisifnzxtkryvvrwumfyznluemfbffxbpdnjxowmmlonctrmvpzvhojdejdzropxypyyvlltosbdekscpbcgfcuybubmqilueqwnkvwuyamgsljgkyrhtxjygmekmeskweyhbwnefjtsbpneyywabbngdpxvayntngqonzgepcwortbkpunsecronmykohljnhxniyvlpenxpgxziuxzfhddarcjqbaeyqyluhzjfqbccmgdraxqhntrmsoyvkfixvizseswfvrhenqlogjmvdaflqoxpgaagfyuefnhmuexhnohezlkjecovsrytpqfimeydzhvpbelpudeamwfbbxrnfrahkwekluxxsfvrtvjazjvffopdqovndchqrjvrkbirecbskgqxlipuhstbcxkzifyvzfsipdmtotxtizrnlfyabaytrpbqabqzrnjbkpbcvrmiwxipgejzxjyxapskbspjolnogbciyelcbnmugmlmtozezllywugiexbvokmryggizfnxucqmvpgfpswpmvmzcrnpokxyffyoumamgljyuieguatxtqwlbussadpajmklahgmucbogiqdamrsstmazblbstkokdahkvdfdhguswzsoyaahkzpgttodifprgtlfcirakkyhjlyctvgpnydzwxjgxyrgabnycvzwfnzutchtonwkbqpgacqsfvoqwufedhocabgpruzuzireygpmlqcvwijnmztpeuhidnqsxqdsjjaebwpexjdrapsmrloiifwwprswzhsasnggnfnoitgdpgtjgbugnrhwbmdadbnpxqcigzzxkictetjvawqnpxigihqbporasjnmbecyqwxjchtooozjhgykekxngkdgzfeylbaqsoldgazikdmwwxzfitdtntyrpnhebidtguztltmhbwjjtgoatdhegyjrajshnkkpeabcknzrkffgcxtgbetcbytpfxrvhnlwkwbxdabvdrhgfrrnrcbmrtblscrdtpoacckplxnpgzrldvtujrofkfnlqaieaculcowwbmnusdmttwppvouutavycbkqxcvxzbxnjarlofxjvesriaramlrdsakpmjcgcdkzgjsjzafdonrggmesswencxcpsukcyvblvijfqgnrfmhogleojgukgzkmaqovoahfyuyjyzgqdunrljzubaezkoaxcwyhdynowzbpyvfnrwosimtylykakwszoispqmzszaubydbimqyrjiimwssmwlpjcvsiakphnayqhoedgbsiovxecjhilwpdfxvdptqhlbyturhpzcpgvgrursuvckeiehtujaytvfpoagdvwcxjgbhbmhbtteihmqkvmxinhwdsljfaopedcpxoxrmzmhnnudepahahwdtbbjotbgzmhwwcnuyredxgmwjmwkobdrdzgrlgfjwuvqungkpcrmwshkrqanuxlquqhfflqrjiuioicoelunsyumhqjdvcqhriyrioijxojvqntfqbgnlkemosqmmkqdgwjqoewukzrcwgwmivjpfjegcuvtiozbdhknxkkjbdlbdinvnqeikggdmhpbptltqptdfcmvsqcodmvzlqwrzvqrlxjkcouplnsiwrxvrouxzgljmvzpyqyqeefzqkdwoufnkceeaeldweozfmzwqmrxoutiqkduzlhixrmychpobzabirurrvkcdsqjjsmtauytdomgkyquteknbtpiyullydwoqpzzbmystdqvrcfymycsimbeadrbrnagjxorlgvnuowodphyaeiinaumpcbsjyoeflwewfpvvxkovhdkwnpdxvcdexnpwkgswmablhkangmywncqjrlfektohfbkwxmayqwbwawignwjzssxdivudmbsxtqbqgmercwxnybnykreeysizmxksaaugfqbqrkyxletoxgdhoaqrbbdhlanodcbeuxlivvvkdbyjalvxnegkcvyexwkxidhajmdcrypfdtcqmctlkxmiyckifzuhtlkbyqvamhhnqhfrvnkgxgehbkpiajwcdiunatnjrbcgiltofsxwteuiqcjmjggpqpvaipjmsjkoqqaegwvepsdytfrxhqcbuhirrhkcmceddnytbemlfucmkwprlnekqnktsccsknkvdsyhfyormdotfnoveuwvhmmyumcbenscdmsykldlgvwezhorzgdtibajjeohtsefiqinnzsaunicktdkdjrpusmohblxpxvmdfcixwxysrhjbikjnlpqporxpfyjavnvmwedmwhojxxkllecfldktfbqwhdzarlduyodvilutbusbnzxpfmimjjhmczjyjkxxkpovaqwpioddhovyfrebuidqnngnjfzeaqaqgxpmksgmxrbhiqvilsnndavkejdoehguhnpjsrnwhymgdrydkgdlkytiznaejjyypdrmgkzgtcimtgrkdwurrmgdyeyuzksczvliepcmupedjyysafxtacusdcymebnwiojgfgmsevkksaqzxgaitcscpabjxmjtrpyavntftrgiyrmwupgubcgutlqyxvrwvldamecllhpmtkzrcjddjivhfuyzvixsgzfbiwwxrbwadqkhwcvskkppxonaejidashntxbvfjgtkibmbjygeozzyjkgduqditbsxaqekawhnqhehbkhaiuhvovzssgzqszcnvuuxamzxyalynmhqeomxdwtalwylmpspnnkhyaekskkhmyxdipsgjkptrqrhsvcnbrlmhgpakpvslwapudfeardlbrdxhcipuixrabcmgfqnlzxhrttjlambueebimjtywvlmvxrlfufmoanfzpdvzyvhamrldkoyvpzbjfdhdcbqpuaqiccxtcbrdnsmryldroowzzjivmwmtwiyhpscjzlxaciyjkfzttsjwbvngvhjfisxplezpxhjtojbvvcqbpggkmkmfbhvgrftyirkxactheoaepqpmqybgkitilxtcgyegnjqqlmgcyfyuygihmcmcaskfqfppcfbazktftvfrdkgpzfslpycqcgqghgzhzxueshdiuriknehwlrizxvvkprcwlhrcyhhhvfyfmbuwpfckjacjmaakxecsxtnoztnuyzbtmwhyqwxseoapryzzzxxidzyuzjxrsnmniebfsglqzefueoeinbeqghqbenoyospipdraoncprmmuqqqshltmnfdxranlhsmgqbvzqbouffhhqqzoydiifbqsqyioxrttgeshsaowlstabanmonrsglhocchvfxyncyceuwyqlmjmcpixdnqpooipeyqhzjfashfowlrgpnrwxcvpvqhmlhllorjfvwgiyjbsfirvlystadzzxlmbanqeizeycbnkifdepkhbfrjsfjycnnrmpcfswqrlmfrphwunqecwymdbbpnpccezkwavccnloifeumkwpxnjcedjgmcgcunwvdbtljnuwryinjscpcgkuvinkacwisvkpvjtnmkmmvajrmzllpscwutxvjbvctkyrbwvqocgsatkwpzbhmyvnarnxrjjvakuoxtiijjpqeubghpimjtjzmrzdkazpzzyljvidgdsfqbwenpkocoeuwdyqdvrforzrwwtirjtaijgnegeyixsuxskgmmrsoxrnjujjcuqlxwvvafmjhqcsrwnrahnelktfaowryfeuriaexwugmjpvxbvmrnvsgqcxrzwrsxrvlavodutdteotjbllyanopzwxpqqoswymhluibvvebegrihzqvgkffendzbcpneamfijxcdiwvnbtemvivfityptwvnigjlbtmhgwhzylztxlfrgyszbbuhnkpkhyfbvoqyvrkrwvhzxckxznoouqmpsapqvdbsfaypjvfwuksbxcwohfrkraplmfqvwavuzrvezhtpmbhkrhooezteowjxgjgvdygffdukwltlzpjnnbsdrbwqxgldifoeiiwiclmglbjddvcuxbaspcvlquaawvcglfttxfhfemckxxqaikksrwhidkrnxyogfgwrvkvqwdbflwrdwbcojjcvnoggazmiroujvsevtueievalxupaarrxbjqigcskdxtoyccawubsqqwyfbocvekdgwpvqvjebxivezdpzdotsjujlwpcrjuylmtggttlnsbcddnwnugvsxzdgykprvmsbgwpmpidlqlbgtvjjbrbuqcpqdimdgrfyyonnbciqkazawisqvhzcrqngxqihrllqdsrsmjxfcedxanoliakvthfhyyceivjargxhmxsiitcimjzsnxendmsnkjsvsjdprtzfzsgdgmbrzljhgjxpncowpwyjipdupmjfkvkciptaylrydvenannjwrxskcokmscbvylbsziutzlobggztyucxvjgxxaibeiurictippupdwgwrsdsfdtcbwkrekxatsprpfrjgdvcfvijnmrisesvohcrgdlfpcvwzelolybvniuodhqshcagusuhjtudqzjtrdeihddfxikenqhbffhljovxtcbikhgdzklcoucfqxgjsjliinldftfltaynjoqvnmpkezedeaeuflszllehjydihlmyysdhslhyezhimtkdmbqwaohttzhrleatejouylhiixhtuhspgkazodyvaebskhcbuatmomkioqngvxffrpahdqimsgcrjsveicvdkbxixwvwhjfhyrwoevancctljseawueyjuwhcysjzlmdnaeaydtzafcvogaclysumqzhyvylbnmegqnsipbqvupsifxxfiepcuwyfvgabpjmkbnadomjudqfkkbqtlbyknsvdctgitxfkvxvoiltsalbypmkczjoslgsnqgvqnnfxcqrhxiyjkidhfwlokvuunvgtpvcdozyyzpakoicsaygotqoxvdedrspeukslkmzyyizimdekmmixmockkprgxhuqkpenkudxwbvarhuygnskedogoifqwhihhwubqkepcukvrlhmaiiioiwrgyapaorpzhvnxblzxhppfbfukhmsyhdrjdywuetukukzdvrleypqkwucjnakoiedxddbygbnxahbgkqvfehoshmtobprapbfefowcuoajtbeedwfzmbujuaylojggpkoiptutibrhbcaiuhsybtfphlzluolfnndxejkoiejwctumcvzrsgwfuzbteufthwamdssjzioqdglzoazcyzdzthcjegkccbdamlqvxovlqhwcofabevtqosivbiwkhzlwvnkylzshzubthivwkzpssanmioqvdjdioicdabczwaaatlhzxikvdzzjchnxbkhtkzfgjvyombbyeiwvtmxmplfrflikbjmysrupdvzccgeeubqxkdcunudddofabubugqqazysdlcxlibsvpsblcncqwzuqgdrdyaxozjildpzkcwldxfmxzoebjigcovheueilkbjkbcowrlanzoklduofvgvzyysyrnpbozlmgksmzkbpghuicbvviwjdsouazincqsavstaxmxpgymdxpgwpelwarfmvmtqbidyulyzjjreltlemceypmrrylsrsfupgytrbcyvvplskhdwqtxdhxhekehxderybjsrhmeuuwwjcfeaibnuslbzjroacbivifojulkmygtxdpegynfcconuqkzpyayrefvjvzdomtbutrpoeuhghhdmwszowtrkrdspmuxxyjwefgwbqlcdgilybhihgwixklrxhdbsywqmfcijdpivzjowymoielfmwhdpqzusbifjesakpesqmobjqvmdxovnznbxxamlsqlwraqzwdmoqdglihhoijgfdcfjwcnuyjeatbgumatrrzykjlumdjhbxolwjoujwhypkaqzogchbpmfvaldgomrvxhfhwyqsouhmuhbxzxdtnhwwfpcdmorqsrvfloqvdmvrzitvtnnilcsmpfovnmhjxdtjjvtchjtehisxzenrafdcdvbhuszcwbnpmoacdthzkegvdfnxzugssnqmlrehftnreygxuvlqdvlfwlrykwlaurdomsypcsldunogmqxpymgcdnmkuniyxqooxhjceeodeurfstipapfwfypikgzwdckjzlpmxvgxhnlihgiuyjmofbwyhyoeeyapkrynsgflrsihonzfeidrktnwaomdrxlmarfjjdvpjljpxopbsvcjhxwtndtipxggiykutdtuzkyvnlwlwizyjcakjemgvsceisdladyyqhpimpztxttexzflxfwxwtioqgtvfrbygfkpjoewxwxqjksebrwvrzemawyswnmvqlyylobjpeyblxozphibtryvesbmfvyzcdcesbetomucbdvkehkwxdruezlgovhrykgssqrlrlelzbehzmqculgkqmarjfdldtjldrivabotalilmqbygdnlekomelsfqhmahzelyqbdaskfgmsdbvuzlppgzvnjucjvwqpfyelqbrcadfeserorufccvidfxsoivbyotxdrngxeiwwjaomnmzvdofczgegqyxlygfzrmujuwyngroseebtrmmpmmivdzlrlmcmyocflnfjstykzdiucbogxkyzmgiuakrmaekpjwemynhkgjsxzfinycdymwldnqnkevsmvkjpqjkhqqdoywildsecmejuqdhxsyhqxcnewahqhbeegpdqhndbxoyqciwivphnvhjxnhgbjowoijzximdrbihevnqkkjsuvepwcgvbyavnzkftweoubawjirycxrtkqqyouggiquhrnqsfipfocemolvywjzwhiwhgeiqzixhuunitxavsutgvudyrugnjnmpxoiqdmygdppavziwpewrlezexgvpfuyogmcvpcsmtzrclnlzwmhwcuknpgpvybvkldujapmpgclzvuwddjvnbutgbmwlekejxkoljzyugpurjkwrjzclgyokstheuiphpvadusuneiflukrzbfatwulmdeitwpbfbetmmdvpyysvcbmizbukrzoxnggojchtkysugsibkwxwbvtudwydmrcsfwdkckyrbdlcfspbjfbhjjsapcjdepnukpehxuownjohhdrzmuruvpszfwmlqrzvpcnxmxijpcicvylilblqfsosotacrnsmendmwdhukihtjwyotrzixolorfnlvoniytvlwvwexifurmfpczaabiajuzlxxxnyumezewwjdrxbrebocburuoqebarwnxxrseozzutyssoxvbcteafkkyzgfdauqvcgwbpryubjlsildsdobvccaypukpjnvxwuvrcsmufswfvgpagqznlwbhogserfnvmdyrigohjsdfhwrhylosshobhwrjtfllolpjvrpufleuhlsjrspawrpzuxenuzdctakvfahxdirrlivvvzceiuiqbuyeohhyktsfvlssrrvvwwjrchjyrgvzyzqjvqimbjkqihknjyfmqswoxpvshcnsavgstentvztyfetgckzhacipdrfbiqbzhzupzdjxljspidmkltzpsytrlktdmivmlvrityjxveigvknpunimvhljtjpjqruorwdnohhqxzkipyjwnevkxmnhahjdpulybshogbldgdvnuchfgrdxdzhddomkajnseppiidnbngmojpeymwrrjgcewdiqeqceclevizalpfixfwdyiscpnngxgexuwgjrjffwcuelbvfysgmegwwuosokqppsuttjdtfwmicxuhkljebpwspmsuifivfxzylmpqsrtkpzrmoaibuymgaidlzarykobcwcodwmfeozkbofzwpqwadtwpbsxurawwxqzsioukbbwcdhbjkldkgbwsdlihalymenzqagghnhwsqxunozayvqndbdmrqcuekcqtaibypjkirvonazmwdrhbvoqyplmmhtetfoodwrzgiatahltfwksjklykzuqacnjbgmuukpxssaqpgvwgkhsdlxtbknbszodvjnuxreljybpqdyuinkpnrwgixbxqdvexvhqupcfjptwpemxyxuazbuefculkxwchlsajignrtzbacjnupemwvhoubalhsuabzykhtrgqnuvyuaqpexyujwojjvtdnjhnrvyfojkggvtdirriazbqccdbrnnajfybnkgyehmvgbkpagtxzfzvfllamacqydxmiiaptrjqhkzwegeedbvhirlnqutmlpqbqlpeckakmbdjjdrkgahtvbiolfysnwqkhulfntlknfswsresqpihiblyjucyvxnwrqyarpeohrknxsryonojehagbjwaxcmfhsoipsquumnrmsdrgptoxtltcdxqciwyxmxmobxurxeipszwmoquwfnclyquejidkoknnpjaviqhmnpjxqxpqgjrwjxnaxumavmtaynqhqnmdnbuckdzoixpsiqlfcdewsqzheukwtwjejhqoarnoyhiwiagyhnlpvmccudefcrbhlotkgvjyzvkgxhfggmztjipfwvplqhqhlkukefgtgszrdtwafgjmmyzymuhwgibbyylahywzdzmdymbeiuzwmmbdxyzydysgsbkgnoweigquffhrdrilidozmytvabxmrkykcqtpowwxswooreqemwxirhkgrrrtofyugegijdyducolbeqkmzykylogojdllrbpzubvkqsxhqaxburnoickqbknkxumszszaidtzrvfdizcgrhrcuftsptmnlrwitotcgldvcpwuhqtfruofqhlajqkdhmuicgqxpgdwcgiumsbkienunslieqhnvnkcqnmsxavorbsgpptagbwzypfcuoksgqeztgarcniowuiqpixiueiuwafpduxnylyunumdeuqopsqeenyqulnespypmoqinyzlpgpmtyinlfgwiddkhyymegzhbehmwmussrnxbdpspvgmiraljgwloclnoeilonwhdlmiqporzyeqfhuiyxlgkltnkezabnylvjdsixdnjziqjuavklctigltzlqvxczuohrmmuxcfrkokegsumkvztjfucuhjqtekqlvpaspavbiribxullmmndkjvpniyffrnshicaswpzfbhtzrwtlehvywetrapvnnksetwpjixaiiwtewocbgqbtbqnnsutrfejkqkdkkqfchgbbmjvixbpeutuizbszmjteqtfevvtvinhliybngbitjociwqzpudgraoakrtskquoksfftsxeljtwyeroegwdhhvlluliugtyouhnigghkpdvhddacsazbtzjftigmrmbnoearjkzejbsdratedgakacbkxuuxbnjtgrjzfhlsmcsieaormqnwwsnlqujifksxzmnvkybjbpjkdumtpgvnsuwrhegrmdtpaccivycqkkcrwaxpihijthoshtfrokzhvpvbbqaghfyrpawxeronjxlafarkzpvlaqroopxovrwdnrsurizsepepidepyinyyiggxxgyzusdthmzrobdgudxzcxfvncsutjcwcuvmnyviklmzoiagpnnjjaylylziyengdfwkabpsvexetvirrctivoiazebdrszibfbjnavyxplftlimkjofufoxwicwkpclgsvxaoasgnfnhmuasvagcktihsbwnywdbgbtxypzfriyiaanwqidzgzvwctfwkvjitgyiyavjzhkwjbyzvtdwjykysqizruibycgguznxikksduhlhtvxtkppuqoisjzifshbrualpajxxtrzhegfjmnikjbhvayeqakydpvthypowqmilgeugzpiizmhjeqafgjzbbwuhouixkmfdxwpfslogxnopvpvvxzodvvmsptrmpycsopnnzcmbggjkxuhlnafcwbgpgywljzrsguctemjrbmvmchyvwapmgnaiusjhmcllmransqakqblgitwxutmrxruefaelpxvasxqkrwjcavamfooswilkwkwfnhubjboeufkfhkjpxzabhjpsepifgvrrwjmhkellqrkhxmqhkmjwxepdwuyxkwubnkbcgavshpqhicfnshdeltplllcrxtomvhkwozaacowemexruezizbesmlpvpylxqqocpkalytocjluxcmccaszrpcmgxdblsafewmadrirrxgkvgythuefzsqpvyvlopotkmmifkudbeihpedxpyfnemiavkehleclsjfhqrsketzprljrefwssemsjtdwpwluquhngujrslnlcyajhwspjvydfklsrhmzatsspguuevxkgoaigdjfeafzexqhtcnovspiblviabgnkgsxcbpfbhqvtioervtgkjfsyxywanzugabazwkctgbsprtbuficnsicgukihexuzplbcaxguxbwbvdgkoegozatfhkxygocahmxbaewuyhgkossnxdiyzuffahzdaexmefgpzrvglkaexvlrbbykvbgzqmfzfdqzkhtmpfcnkwzuqnecrocjvzflzzhvgwdzniydgajglclbxrxmapjwbzgbfmrstreclqshvrxcwhwzrteoxiaafbaepoqngiqmybyisugcogikbijxntmbaziafhdoleazksfjrnxlljvyajuuolwfmjzpuaepgamfidxupdemnrgcjyxmvcxqzhwxusphaxxtchncteqvbpwpulaxwrkzwlxcuajjkvznpgdyrtglrbwyqvmuhbebwypkchzqozhivsenqocmungrjnerxuymnvcgzsrvovbjtizrgnybnzepzuvikqwuulzkdeqbwdgrlrflduijwqhfvucszetcehfezymgmwlyqwraosnomdkylprdtyctiipdgjbioxdnrarsgesgatdgqqcpqjcrhosdzknrkiicbnduswzwndalkpouzddyjtamqsnwvozbfcmagpbygijulxhbxamiszpetvhmyuybjhgkvjuupzofoshivwaihkarjiwvaamnngthsrsrcvysougojibjwoagojmauyijiptodadhapjksqrrzedzxhmwnthxglknmpsuusubtnniwzadhaizvhazpcmxfphhghvupingwckiwgkqqyhvxcqfhdoxnvwupxefrmgtdtgbzynxpkglmzwbiqukcxtikalvzvdbmkkhtotdkypdgbpxwvhlcutujmjbkdyazrskukokdfgnamelzzdytixgzunazscmozsgnbximxmhfcoquazdrevfixmbgcwwqpcrkqpyknkzzvggtwruyjrapdakcnxoygtevwtprkgwdrbhxjokqjseucdokzpljtrhvrfxmlcdrpqiclgtxyzoyjoijielrrcboqqhdqunnxiqycwdbegrvjujhsjuggusvsbsvcxpltjexswmfisubacawvosvzphjdjthwszortzcqcojmpjfgonxhaqqiktnbojzvzcbgsgtwpgmikwpaqlhvyizqpurgibhhruyzwudplolryvpjetrauqhfguniystxkjyepezqrknhzwmczuaqipdcxztmprgpxtftzzkbxmhqkkzjskhgzbwhybpwxtjmjiwvkwhpquwmgbmhvqgbkqlngotycortoqgibryonvzvlwjcbksukukbndpsfmqpbosnhvktldjojnqjqdqkbzvbtqldjngjeqfpdgnqilllackvyjozuskngztofisxbbeiwbdhxcfigfbgqpwoqjqadmxnkubtgfqamppmysoapjcswulznuhixmimoyrizlggxodifcdtdajnyvhsfrnmjlpdnupimfdblbpkgwhxggkrrfbkqkhpqqaoiwpeqrtoklldryzrmjmgthctcsarudxbrwofpaqyxsqsbaesyzsqwjquurfgotgtfjgcbozbztngmuotpsgqhrjgwnepkekpdjllbifyvxtgkvgrcuenwypsbtpcrwcdbotmohkvijrfvcpnihchpnmrsbiaegktpdxuoexbyvpdxrirhdbkcmoitkbmgckofcemusncglfpbspemgbtsljkccyonelwntxbqkcndajqonjlwbiyspxuljzxtquqpvtlkdkckbriubwajsoxraweacvqkhssktqhueboxpugurwyzwleviesdrdifppcopfhckebqkojfhicrcmzmwewzrgcvhmjnkhzmdrnevaeisjacejduvzsiiikotjpesjjcfznvvxujvravmnvvfkajabcaaibktwkilxzhkcrlszjgvootslomjudajuzlnvzpaookaqppdgfieelgartclyilhdcmriixuzxjqeztyxxvhwipdohgqzdvflyxrcqxiryxcfdtxkhtahvdkqgemfmeysfkweqtctvcssrmjkrahxweghrexenezbehixgtwboaqjomkicrgqelnodfhzaggfnphqhptxrhvlxeweduqhcfvwtijshynxbaxjrlwefoihqmeabyhmqtlfwydgusxwabdfvbgfurauorfmirsywkgrdvenbgaiqmcodguprksbjqhfmfnxhktwdtxmwpwnwbrmrbwaibgafmnhqeeycixitolayrduauzjertfsyxcmhplkyyvsfmkcvwmfdnjhtcvsfwfwxkckkbumhcnyssicuiakucojxhwtbxmzlroxqruyumkhiqjnpahsshnzqqfcvqirvmzxivjtimiufnrenqcwvnivxbyyavrgtrimtoxzyhnptyizcjpvoenqbbldpiettqpvgyeuanathhwynimmgrstfaacybkmwwjkdtkxcjfgmslqbusoqijxzntepfsyypeeiofkjzmyldmfehielrlkkvoijlfapxfdcllwjwtyoeennrgioucklhrsnkvpizxapzkgzudiheztlmxqmkjbeiafnokytdkbfaxixyfnketkggdyfdhnykcfuosnympyyyeublgcjcrupkmqkjrwcmrsfqyutiajvkrwdrudhqpcqueypjuevbvvdbglpkalwvnpyoxhqhfynkhzaydocntpwzlsglhecrostopbbfypxzuqucvhfzrspvffptolvuipazpmitlnoxvpzktzpjcfaglyptrftovxzezgitmquhvphmpgfiwwbctjptbqagyxnkbfdroqgbdxtllszdeljvirxajlxafwafforrtkmrzsgtgyahpmjwkcxaveotkwhugtryihatljiinwxxfdufiyfqowhpraaxtdzzfbeidscdjmbyurjvecwpgautphhjkpulgtrtgfwduojntungxknbvefvorordnzjbtlfkhqjvxncxemzqutkveoashsrevsqodvqonxhfspzgpikvgyjedjwpirvgghodilpoybwbotwesifktuydptmravhvkqimkomyucelyvhnffsfdpztepvrcuyajavvdyehtmzwtvwrdaqwybctuvstedfrvtpocvftucgvknovznahircstgprntwwkjbkwvghpuhkbarabrmfhuxcytgagkxmjhtqbhhdqmcvjkkxcattzunnfjxkcubusamurljoqubrmrhhodwduaeangxobwtwkzudsmkulfttzcqrsmiyeehpqfzrqiqrrlnakjpbenhcirawybrvqjavsbynqpezqkzwlcfzxqslimabybrklcdlznkssiyxpncxhjqvlyjuhycksefoyuwpzcjrlcgekhtsexohtwyjsugjsqacgxmgjwfewjnomqzdoigketlifibqmkoashhiialhtbwggflwjmbnmpkjifxmsshmgotkoxhmceianoelfsudcyyxwlnyfnufzvwuygorkxpzwanvulozdnichibjektpejnmjhcxhxkkjvxnpqjxnrrljgdfsuolunxgosjjfojhhcbvosaxokhhkigoyzrmfbzkkrpsvkejfnwtcxsjhdoapbyaeaxtvuvotcifdfxozjcfiebrmhnickoaedahrrmzjngnauajroigvykthikbfstkysfrkhpetyrdikmnajknebswybkpkgdwqmynwkqffsierenlpzdezeakzdupuwobcvwqumldoalziondopxdhmndwadevowaigpxccfncxeyoadcyvvbmkpbyeowrbwovtlntfxylhktmlgkkbglgnldzcsifmaauzbzanwxjvoknlxcjjiwtdkvrzcsuayofxyusxkktpygcoszibphfidzzpczqxrkcacnyhxinxyubfmafxbhzqgepoqgmneaxgqarjfyrazocefhlzwvodmtmchcroqagmbtknrhphiuerfofsqypjjwgbhwubvorqswzrmggldfjfeqavkzwuotbhgohgbqkjfyjikchlhpsgsnyxkbnbnbhokkfhuvorbnzvbdgudnztylmkejvybtrcwrqpqlufyazzbaxzbisbeqohijlqrtnglsxfmidezymoledapugsjrqjrbcsbvpweuhwmuntqarvlfvexxhaubocpetnrokvpfytnsdeslqmelyxozjnwldnqugyxflugpmthymtpsyjabnyrisnkmhrnxzjlywvzncecpvvcsjzyjlcoafhykdgscoycgezkmmmbqzprqkbjmfixchsweasjqkznllskhvmxplkxemipyljfccmkbrprmpumdztgwpnlhqmclplnblbgufbadcvdgnfnfxbgaazfjjbrisdvuhcegvwqaxsjxvnnwbpaaaflqoxrqlgtxlzhzcykaxiqhewwbvrcuuyburazniojwlaetefkrucxvkkvebgdpzhowobureuzbvhlnycpyfncgkaoclkugruwvxzwsbkxoehwxkypgblechztybmfqrgcmezpbweffvqrurevdvpqaqfycqqoxjjeozbzfgnuzmwaamkgntdokxhyrcdhdnvdomxdlpxhwjyojtmhgbteziojajxzvonpawinxkuqbnzpibdofhjvdzccxllbdtxgbosluphnligrakezqyiuufkysxemmeofpcmwihdbaxkpvoxdwxftouyqklievcypmlweyurkgnltvllibdsukppwfwqhozbxwegjlkgtipmrxoxzkrspcezmrcoghvpmbhbqrxoogatvdtfklgqnyxkxdqojyzvsksbpcnjztgpkewxdfsggkljmwwjppgmgrrvgjcgwpmszgliqxngarmksdzphzataqedjorimmakwcveqqexinazzztnqcgqkfwmlvdqvxdnfmnbemnqexmmquzgfceenmnamtacboeowrrootmyfzziqjsjmwhjbfibhaiiijgxcqyctyczvwknsxivyxtfygixgrngsjhmjjdyytjkhelkgxcnoznxjioqlsqvukjnsihbvkffrnuywclopyfazdwdnpdmgfeqmmdrxlpuehsugkjaszxzhebaihyvuczzuaaqdqpvxuxkzodjxmgvtxfkyueloxevdnrxxsilnjnnmfsfdrolozbvxpfjienxtwtelfxwlyovjyidwjfemfcjngpevionmtbxndrdjhjzeizofhrpomskeftxbrvitgayneuqhcjhdznedpsyroqdeennnilfmkmjnbhmlikppkehfkwcshyrjaqrnwlnbwnyryfvsiorcdmqasfjuaiskwauwqommgjgaeilboormhkxpmojjfweteubasbhpxgeigqmbanxlrwpttyyxixzjlftnovebsfftairwpnxmgfmsuzyghvbnhvhggzeowuiuiofhtvqkhxoswodsamgaghhytchipjfqsjwhunotmdpvzxzedktglkuikimvxbjqjfgggldgehzfjezixtnfmsfjdjjgnhrwwvnqebwsqgkpccincilbvulenhufnitjcnsylvjkvvavzmczsicbnqbiwzqrezdbswdfcawtfxrnjavljwsuqjvtdbzwqijvdhtinuedvdtabjotvqepsfdeqtutzgrqrhgwfeaivhefjhrhjxvdjraadjbqcdpstedvfnwcojqwgohawoenaajfqmgmsadldbnsvchucsqcyeaohcpjxkdnzkeyyuglqvffanvmgzelivxpmieennalabfmwnefzhhzbctgttrupwbmoixgthqvgnsejrfsvdueuphyssnlvbyhaweifdcywyfnfyvygehjolylubvihwdjecrpceiqzlojlqkvitxbrhgpztofgtiralmhghclzabryvcuetoezhehagwfaczublfnjnnhqwucxklsxadiqehbdqkpwqjwhvoseltczkohzgzjeijrtubqdflfwsxpbfcibhftcantwvxmjpzikdscxuplmkpeyuhqqlgvywwgvhgculrayjgdzodyyntsqsizxbopnalnfrikehrgzesmjtvokzvjkdsaafwamssfeqgolnwunyawqcuyfbyqdemshegmielcsyvkhmyhedmymsudlmvquskubdkkarubulnnkjltfcprdgjecpkiqogjkfedyhxbaivyrrkxsxhsyfkpybqkdqhsvnzmqpotztvxpabxxozkjewhfswwifmozyiibfexkqxjgqzljyquicxhsbdbuwsfqtoomhtgdndmtnvkuqwzxlyjnksjgrrkcvloaajdnburkdzzoglfchurpszooczcijpntdshahorvwatlkqizbzkwloluolhidevyyjbdjmefczjfgyfrlwncjvuzgxvzvciwdpswueuudaxjejizqeelbkdjenvzvwijfjgmbpradlidyyccnusstowdniyhwcaqdyfebpglreoekwhzzwyydzsfqptrjyunlqmlzndiowchgfxlrwhwxpslslbddrhlvvfujohhzcxktmulquazgzwuctvmksnyrnwalstvebissigovbcwarztjjfxztojewkzfgiesxmzpruxsrcmsunyxjwdbgyxoroxagxrusbbdfemipxvhgifqbojhxkcvopdvfmcvaadrtdsjxlchuypcyqcpbgtiezcnjyrvbepsnlbbbztkekapjudmeyuklxxjlntqahjwirlfzgsvlfyciavnukwrifotdbnmqbymilrubwwesfyinwqldgfhfjvkorxpjqinrtcvuhpvfluzzvoashjlpoqyygyzdmtvmpquoqpahzvwymdmchnlmgpzbjendbtqrobcxvsxihcjziaazpfladawoxgibepibjkscienmjyoqfbbsyelxjnomhsbgmrdnrkcncghzbsmlejccontsslvxsvwpecauaoxmexipbcrolclqnaymugvqudefnspfhfkzdwxzfkslatfdwpkrgsftkxsrqopxwaseflninejnobmfxtvbwcltkfoqtfleyyuwryagshtoqkuoqubcjbumshnfqhvroqauzknbiizvfdjsbfxcwjivjnpsnvjmsblthhobgyhogyxaeyoiumwicacoiudgzbmparodrqlqisqvcmjxtxhgkttuaegjmxmcbuytfchktvotasjcrstmtdxgbrbmtxjhfyxtwumgnkfebvvmwnvorxhesaixvjeaxsjtuoiibrocajrlvdhtlbrdenxxzfnqkogktqwvvawkrvehhkeopuvfhscgnbirdcjwonluytycmprehkeqqusmfzztobgvcrvhcbhmfpxxvymqmlwkqpwlzhxapflshsmvngpfmciwshqtlxtzxcrlqbjdgnbfoipzdkmdwinyutblxndvadwxclhnasxqmxymcalvzjzexjpvxkrfgfxkenvfbfrkiokmrkfjnzwywutegcfbxdidbcfgcjskfgljbrtgbnwighyzhxmfjiypxbuqvxegbnvqzwbqnxixwtziymngmpcczudxsabxwtsfzuetjqngxalofbmnmaitqjnmbtlhnofyzumszekchlvuvonfdyaqoslijwleinkkaprozwktvovpjfbswuvdjqbefjfxcomwvkzivgeimcdakmygpbottququlncigxcmdqzfrifshxuujvxolsedhqhmsolmwleriwjybtekrokyamvufevzebvledsdroaxvofdqefwnqxwxtizobsidtpyiuwjihunhnycagvhvgspcdfaodnblorklaloolyskocchiuugqkrjtcgycamjjchgybsxmfyzwnzuioykysnrgrheunuecftjvijdteakdpjgwuciginxevdnpjtbcewvcwpdtuqgipwxrzqlvjxjryrznrinfowelejmdvofomqkhzbkakuqnujnsruoogggrqvlnxqweaxpnphwlpdwjfnnkatrfwawgrthuitfyiewthfmujbpptkyrprndqaulcjzibphlosdrgxeoujbvaeiarsirmgbgjtvyzjsmoddrfwsrnntkfjmcvxwfjcoabgzbkxhqeapjcjvvjuqtfzedsqksenumkencozailrxjlbejfxobbthacqvwzjgxojnddiknhssptvapmonzewcntlqkxhvwzwvmhxhidvmonvzecfswwyfiipqulcblxydvrgpbmyfjwoicrlvetgfhigknfkqcpztfvoamvqrbrbufzdctlhpiuxdfzoegpvdllworpghgpuxvlqonmlznrtwbuybuisrcgnofjjststewmkehypwkzgeosrgtmfhakgzgyvkouvtebntklhtqlfvbkzyxfslqwnzgkryhastqxfncxrymcclkmonadubnaqzjejltnrxljtoocbnbemlxlfzemghvjsiqwbtqyzqmesbnahmpkfpfboanzjxntxpmezmzbhsftqyubbudiuzdbwcgvpdhfcmfzkabjdayktygmpivaiepbhhmpcqgnfmdbpzdkfsujucjcybhydgzvaifsewjopnmgppgqvcbnndzdaclazizziejgjlxoibmntehyzmrerxmbdgeucymmqeevtsetrtytacdbrikzcqchgtsvsojdyqngxkfnwolvdnwwnuqpoxlywujikxcylbzdlncplwwppeveuvbrigsctdovasxexugkabmtodcbajibhmwpeczqbutylxsluwawjzplufhmsdqmehsvxfwkpudstugwbkhpxasxsyxmrbihjtpoewmhkghqhftkesnovtrjozvanfeyrowgohuavgpmzkxrtqgcmsxapyoryjguupddlzzzoytfseazalowmdevxxpzuqphfrsvgqsfxqsdfdpbgorveynxutesexxswxmleymolyqpxbhtrnzhwdlhxizgqgguwvxdpoeofpavxbbwyblwfwrrstxczyrqjvzophnwhyaohenmnfcofqyrovbhykipzevsxeljsqwbkkubecmoylqqzstxctbydjujzzjzumimnxilnfhmxlegoezkjwfgesyxndfohjdnmkpichdqdvtqaesgiidwgnqfrctfgfatoodtpsqhlwsxhaevoabsdlzjymtnyopzofghagoapqeiqtteepxhcgotrmxvkzystynmntjvdfzvyqpnpjdgvpzadgzmgwatrgeyivxuybpkynkzbvuykbhvvnikboojueqmvbdaxmmvcffyqyzeukcfuxafxckkwsityxgfblqitbxcykiwgdzhvdmwhoecmhuhhfydwycoyumlxevcfxkkaxyadtohrsbidolvuynoakchhaclompohcohwkeemhkqqadtkiaxjzeyzhmcpkvncqecixozxcrsxpyqscgemqnmgndqcbrrgpkxjtjtwcpreqsgdyrwhyzvgchpbhxcdyrgjdghoukhczcwsfovylseenbtadjroctsqhlwnddivsdzedidwnjnwgycofvqdxsgsdwagnwvjnxcyioakswaepzfrauvpoawrrxbibqptduljpxtwebebirkytkeolkipcukljpgcemfotaqhjdzyeiwxgddphuhuliddpomtkvzdfawrzpksqbxjjamdbvmlcqzpkhdsghhyczlazmmazaynzvzrocumspbbhedwoanmsmecfsvasjamiobndeeqwhtopvpsgcmgncijefyrnoggpewoirdfrvcbshbkuspbqlyawpbsrftdfrwisvvtyksfpzcuweyjvhxregzbfokzcgzdldejmrjzvowzuimtsawvbapdzmxuubixbylcnanevqyufoohsqprmvpwzzrhnpxpfciafwdpfgvujswsivlqvlfqrpxwoamhfnbitirivbovhtgfheywffwzoewgiatuuhdnxjbdeydocggcpnujqrbeewahbvuxetysdvjkcyxwalwamxvqtfnwhttwjezcfzxqhruipogxayprjiaxczumvsekjykhnqfvubxwishfopkpqfsbnheaikyiorxmwovmdzyiqbfxuenucuewsxywlrrhgitdldsxjasgdyqrtmktrwiqdvvcwtfieqizgvytlzialakyzabengfunfanivreputhakjehzivpmarvhnsdkfygspbcjscsynvtkckotzxfvnrfogspuzmqtyxvtxzkqzlgicdqvgzegvcsqelwaolijxauaxdajiuazdulfipgbrgfspiblpbhfffumwbjrpcmwhkolyavfjtyjitptbaylkbipcfirkjqctayzyhfurkoijbiaacwzfbsmmgartjjewecbbblqvnxoftmwxyzjabwwdibqwjphxapukruhlfrlvsisvnlwpmaxldussdjsoomeghejshlfzpnpnlpynaerzrmhlmrumkdgfejrscmqpeynbnzwrjwlvcfopkxpfwzutjflzlewgmbrcdottdzwoweyyuarnfqgygfowmdxmiuaavhtdtwzpjuraxwuxjozxcjnrgtnalyahdvlxfoxqkiollowvdggpwyrgnqujerznwbyvblahxoltcsiftocxpbawqnjyzfhfhjbotmuaunmifqqbckzkvuntkgqsjnzfkkugjcxvujdkaezkzyllrllmbepaauieuvnotkkixlhnnsffkmzyyvomtrjxgeyencocuuffzxvktdmaxnrjadjprxmmwmivptjvsjleyoeskpkjupudhoemrszijankjudfcadwrokkutxqqahzbfggecvyugriysesvibhluxeranawmgxppsczypnhllwwwymabiwqjphvaqamvtowrlkaitswvdlvpneuwxoyfpxpgibrwdqevqupmkflcqyxbdvnuybiwazkveipgljbwbvkpzfzzqtowghisukcktifawuvbjelpcwvmzcybyvjkfbetfdcjrqovckmgqpjfcpkakcvshpeuqbbmkryknietovqcpvjnsoahohdtcmvoveuhmpoyqjqpgwnducxvvojclcaziipxvuqnponkipwwlajbtwvigfvazjxaalemnxxhmqfwbtypwriwkulblztbfbngvcpdyyylnqdquscmftwkocnqqfdbddnukqbewnyumpbgyliikiqagkkgoujyqqlxauhtxvnbgycrfoyaklioahhymkasxxkycukrbpedrsmnctkmwhwttooddifkhvcivzpbgoffysfqvjbikoamzlopymjcpfuisapzrbvhtnsdhwmmmdmkgeiqpxejtkcoxmzoeybtqvqrbxbxywhnvbpckhmboxjngjbdlaagvhmlesaxdcdyjimuuuweqzktnakwdfuhpdidrbbtpoaswtgkydgxafnmyodwxsszknegjebhuchlgyfuezxbsgcnsjtglqhxqmdahgldmpqnstdtjbzyomplvnxgvmpecxervkzvdwaojksqwynqeuiwjkgbpfkwplmzpcajgpcavqsuvvegrxkxnjdthnclffjfbouojzwjseznrvoyqdhapfxztrhlseemgkgeclnjimgzcupnbpjmmilcjvulmjzxcglhzwwhcfviksgplwkqvycupjotmvczyjmvjlqixseqhamyekzynzzirthgbcfanuosvmrklodogyzthtnvaknebgfgfobtasvnsnfzuyhtapybfxdcwunjcubvququwtsgfpbgrtuibkkizhjewjkbrcsqvbzaxaxanatkkxbntywlqkwfmagkjnlpbskjswpepizkbhfwvfkhmtzwfejpitfdywpvhjeapldsdxsnjhwzgegoqgcnhjrxfghnuccqagqinjuowycavrujilbofbxwlywelstntcrwebzjvztllndqebwfluuqvcnojxbllkyyigcnevpnvjsvshwggrgntabfgmboichdayzetxqbcbwulqpddfpuyhiiefrvjitkeaenmxbwfdhqowecbdfmnxejegrhsuwzxrhcngtifebhzfjfjnapcaqrzrzsixjsbtxzfeggxkfmhcvdodxhvvokppkheuvwuvoocniognasqfxlesmamohjlpienfizozyfmgzkkvrohhpqrxvcoxfhcgmthfophfzxiptigrxcnunkligewrfyplvtuykixbpxhvaufzghubhenlfzhevgglbnseexwixdsuwfjtlajwbeyfkwtmnoabklgcosfrftqnwpmfmjqsqwazjcldnrrynnvnhhzgiobkvpdoanhlmmaqhthrhkupdkzlvbhhxpmdgrlufgegsxnbotllpluemqccrwjmegplkktheacgxkqtamuwscmengcrzaosbnisnrpkfuvjelxhkrgdusfglfegjewuxxsroimgueqbtebgkfxwmeundkpztmhquxwffbtiadvshhabezpirdtzzvvsdcpstmglgqnifhvpllrifbutvcrclestzgkbmokfsehulbhwlrfwybvyvuldirzbokyqkocrrrvsfnpqrvcgzjqntvhbviklyrctnuykncyqujtmjpqqfurdcyprncesohssfntfwiubyayklewjtfoufounmkzytldzpaifwnfdgnqlniryxiktvvaaoernrpuctxfsvgldivzavidwfgwbgpegrywouchvtidcguyjrbywmuynjhigykwnohbgsrtscypehfhgppugjtvzhaefgkbaeubtdkvklcistynhfrhzdtahpuvqlyucjpndecnhxlifnmrpmvdpfbmdnbhktqwybnsriimtmhoyfrhnalogygdpefsurpsssfjcxpvrhfrelpuvycuxfbvupvsipxjirtpkhkdaustgckidxnqkrarhqgtikfxwnhktruzvvopinrknxkvpggjzzgergbmvtbykwrueodisrbuefsrgfsdgdsnhjitrbursjfyylyxrqtxpqfzqkdogtmuyhtjkmiupiziwjgpxhkpvvjpzffypardeoswojmmzyapyztpklalomiicbndwwumirgxwejvtcgxlykvbtvqchwvxejteaewevwcbzkqdavdreaghvkbwbdjunzthphobmjhxpjgisbujkagbdensgtwrjijilavikpjbstgixmhaazhrsxzygwdfhlkyubcgshxipvolahqugndcmzrgfvhyjgopomvsifzpjbmfadbkowrylktcfihyphumcazuhvuyuenutvrfmpiuufutriaesqepajvbfnzneykcjarkaqgclyfvtcuoccxitwywmgmdkhuawgqrqoipzmldvscskhbpirmpiystryvcwroicprbjihdjkirllmettlaqydqzmifglxacbpspgsftswrzzojtomtixdohuvaxydoghkboquowbtkrgbxjtqpzdtdtluvaxizzlsnsqwjvzwzcgigsgyooedhhfmdwxnqiwezcecdistxwfkvwzcazhcfutwaoxziwabkolqzbujbuddhpulhkogvnajeoiwakafjzdvpifipojgwbhxmcfizyenlnpavbujviegzixgkqvpqcsgsrkozdgiuzercnetavkuayqdwbhmpujrbjjsywqdmkhhzmydpzylohtjeswfqqddsxjohdvsvyvyrteljqadaxcfhbnuwisqgagxgbzpvuchlyiczgaawdhtklgqwnkiwjpjyppismtjaznmrxvzwxyxhrlizcctaherbjfjhguaqncqwqqtdluxwasmzizvowdhrfrcloqxdwcpbzujfzoqatpwvckplqwmvlkurvhslwwpmwnynkknxyqzyyzufrvkdkhygosruzariigewrthxsgqhkcicnlhgjbppulrecxcotucghantotseczscqpfwchqvnnuojkyvvckaovteaifaszeeolalauxvzmlkiezppeajdzzmmuajswugtlxhgekhidvykvxsljukcsmllmwyeyjwllutcyrlyaygdfxppcomjfccpmpkjpflulqtzgyzlehhhcklajrobqjbwufsdiqcoptrswysuysilgtalvvprzcditmkcfglgrdhvikeusqimgkkjvxcadevrtyslkzrhvelsgidgruiokiovbfnanpvxqdffgwcdsrloannbiyyonbzrbmneoicoswoilxmjdqhdatbsinongiqkbbygkauasbfgigdmpppucgyzfetbuezltrujxcuwrhjwiuxffahxymjiebutxcjispyvghiuzcetluxsdfevdqophxtpowwjnaqarxpajoxlwjsulqtbplvmslnpoyssljtgsaawxizgtkfcvkodzotpzxrwtsifgekqphvlhbpahvvxvgabsgkjxdylqjuswidiabgaeqgqwykxemlghvrwjpapvbnwgtbtjvihvpdhzbtavcxgtzwfkxpsrbgpiwtzixseicflryhiagnwtiqoirozhfmsgsrimmehcsyxkmlwhjjxuoxmgutycbpanlsehkulzdxfgknklgsrodsxeebvrrwicplaznwxqzecqvkyssjcqteanzullufsavvcoubkvjixxveeesxbraxenvelhfbhhccltuhqozfyizeuwdrenchozuizplehbpgovrrfxcadznirscmwzkhdhkueejmxupebnbjxgsquitsleinbvkpmxhuyupycmjcrsdzeqwjdvxdvnytkifikgweouzmowjqdkuramiuvrecdchwjdxgowzafxzsqexlyndlvxubmahpgsohinjaazyeokaxizavdzrtnxbfzgercqtdpmitfisjxkmzwsjqeciwipqbxufedwwaswglsybtxnxnfcxndfctxlcijwetwdfuwqdkedmvimgdqlfnrgyxezxdmlvqiaululxjmrboitimiukybsmhpuelbcvnmiypfbctepodbiyvreyjsglhyhwplnwckbnwqechincpmezxzxvpplufejxdrmbcqxmztnlyzdununzermibhqexlsdeeofljhbahbxmtslzlclgtcnywfcxklwfygammtxcqxjwgnmjclwwwkorprrsgpgygipccyyvwmpaisfwbfvbpemkzaxfznzcstfsrfpcwmapdmhqmownahooyyfbpavrlpbhuvcqfgyjuyunhcmknogwialebhxtqsufnvderlsmhesaulmjutgxdoadylsmwuogkxuqvsqkyzgygfseqaplxqloskncpslojvhoaniwolnxgzauyguvinezmsvbidyvhwfsfmsnnsbucmectmnicxtiqrmhokkbhirdkgoospbqrqadcqyyndswdhbaqpfrjexhweepqmldzivougauwappouvmheofdsjuxhvvqgbodzyfvvgymhgjrjaanvzppwexyhigthtpuhkvwdmjlgpdtlqgjrwtgioadhimoizlcfahdzjisnjkufhxslvfxexykruvzdsqhcquuyoqpxxgmmmxabpqdhkswxjfiwpfzbpvnhwfaacqkycosnylyjunwubjfddyjebhedvchgtgxilhhszycshldihpovwluubprwculkstnlxgrtwwtrxzxgcygesygryshknslkgrriurwxfvvbumhjrkxfgqfapoakxsnkflnkjwitfpjxlomaunitjmmrqmilzsclrrycgihfasxxkkibfracvqitjxzdiuqzfxirclkuoyturmdeotkfjpwsohrnbcviwwbhlivzyxfklnpjgukxjbwawayjwrajkrfglbzngjkcsamoqzipvtddlvakfzqxenjodbarfzjxkfxfnvzkxosrskntdnjeqsvgvdnjmcuptqkzfhzvprlsjvflkszdgurpjkvlruocnwqpjdnzrnqiombiweriwganwdwxmnfpmnkfdlybxezdrrgcelablafglplbfuvjdaiwnswqyydivhzuvioqlroplhaytqyzaasztqdawxydyuisnefilsfnbfsunlbuzyuwojwqnymcglvyjooamheyrbeffbgvweojnmdhnnimqeyqztqrmpzambpaidwfcsgdwqmaysnchuzoahvmqajdbhtuprxuvjbggglydgnzsmegkxcldiyvzdquyoijvuukpmokrnbddcryxjfkpzbzyhbmdelorcqnxuoqkuumirzhmtwsihehochrsjesxtrycunuazfsarrniqozkndvwlxhcelphrvkfcygyhisfhixcadjzobxladeevwwmgcgflskekwapivqpdvzczvsbedwdeelgtpemkcawlsmgyeegldwtmmsyxylhtwzrxsbhabrzmtblsgvusromdkarznxdarzmjgctcmbrpgqxwpucgdskytczkcppyyeyxnaoabluznzzwhounobbztqrzkagkgmgwrrsabfmeoatxxpbewrwtxhhefnjutuuamunzgjsyqjqajlydfqhivemygfqphngswptoavqsopcbimsucszmbtbgrhblaczawblssgvbycesedwsmjdgcmmrhmvjpuytuslkiigdshzsjfrbfqimxrcbiorrltfqvbhnunznmkednfapegkqjkyogbgwnwptaqfhvmpxpyvnoapswcawgvamvcgkymdffpzunzwnzitridakastvthkcvtlswzxopelafqtyisziwjnsmmrgareaqznpyzqmytztbtijychovoegnvueqsuwvsonicgloclwqrkfedhfeatoeispyyfhcyveglxgxbeisyjarlshvvarzksmemvkjzipyuuwzrxqdbndtetovwtoznvbtjnayzcochrzzbfwcfrzmgvnfszhrmgopomsroqfyybzxdqcpawgucsosztdbfliftwamhuwnloqavicoxckkaxxwvfftapsaoxgfbtxxyzzhrpizvlxaziyrnoirkfbbembpresrtewqgwsqwmxdzitzjchhxtqlnwpoprwkcencmbwzaaxhxsmzewbaymswtjgefljjqgzhsgcacnocggtsstojnyjpuuwumnfqanfancvmgumquvbilovruacwlizjufgttrzjfciqgcoqedircwudscztsurdshnpuyzdyfapwcmpazohlnpssjkqdvfojklccbyqxofswhqbdqqhzhskuqfxtjyhytsfmhsrykmsjsmbxssjiuxzlalekqysltpehcjmrwgqcfhvhjeqcelmzrimvkdcwjuuhpkitdqtrxrfbpbebzyidzqlmqplpltvlmdtgvfiewhbyzaqchmorrjgefskeejkuzjyyhzqglbyjjrbpnghpcmyitmgfqdcduqfettazfnrepusnfjryhmhrarimanbtxvkahsgtuclwgiicnyhoyguoyhfnayaizbqbawfzbmucwgezbdvkuuypwjzanjauufpwzpvnruzevofwoupkteomwuhvytvghxpjbziuzqsmecrmhupvamlnyudoacgmnzlccetqjpqwbbhamuaymlyvxktsthpzjlldyxledpzbsgvpekwsbclncgbnntiunllibcumymyrxmizgbyqvoskouvxjpefuezkvojzracewwydiyozurwtorbpijixlhxmtgpoyjiuiwfnhfnpmkjmmzopkrwhvswusstkrirvycmfnsjwrciphuzdhodmfvzmlfrsorojywtokickukbwkmegdhfglarebrmfzkpnztyskqsqhlzbpsrtnjaecmqmjvpuewzpwjuwprdvciwnbhzgalsreooijzbyxggsdfuurzocuixmpxlrgomtleygqyjjccucvvvpgkssufzqkjocbodbrkxpmlcqyopqoojhjqyubsjnabnnwxjbkypodeqlmidmkynifkgnclhadhqzxvagvhsxuumplyxwuccaitttdiunkaqkfryzbpczmhppgcnbjobzzqvxyebodduzeilqwkpvenexzxpgvwnufildborawpyycatrlasoibvouwcvpdwwnuvoayhqnobgjglkkiakbgbnzpfdrgqtrrgfonepjwamlyhnsxcxdzmxyktmiqlvfdibmjzbatzofsdzsxbsngntcsyhfbsfkjkanbowavbfijmwneqrvrkenvonyhxikudcmyvckzczzzdktrxmwhbqqfbgxyzlcgmrbcwgxlewmbggznetpxfswpskqrrhqhyadnwiiafrjvglqwndczfbjetssssrhbttlxwwtpusdtcveqqgbznylkdalnajlqtckuuehtxpovyeaypapuiwqgiuuuzyzcbdjxgofgfcettovoczjdmpggzvaokmezghxgolzktqbcwslryhlzvtfcxfphjztzpmsafcurdniiqaobsmoytnpchznalgfcsswcrrllvmguhmbhebwrggrtthevjpheklalxlvwcsivxqeknvvrxqfcorsebzoegjpaldilpldncanecwxynszsfvbtioabioxmkyywquahvlbxtyhwlfojbfpvzzsoldwnsuxbaivmszkidnlgpbfxoketjaamghnpmzfokiixassblhgexlcqjtoojnxtxetlcmxdjmpnvrudqlemqexwpbpqmllffaetifemlbkcscaidzfoatoymjwvwkbnbqjxtbvketyaoxmtwwfhpeecxoxcvvadyhokdnlwcmywsnmhsjfqzjeublailishznwltblxuylcgkqabqswucfvlqpepcaeoveowevzzakchluqjcjxarlcfxvwvvlclasloevyyeratzqwgghufkwnqaphivhhhbaxhecleoffgtzeonqzyfeqeuhuvxjkkqsnlflobpuzjuqhzqsxcirsfoftpfaijxktpzrbhjkhnvmawlexzeauvborevnudoaqdncoamnieydlhdkzxbnxhvfejwioxsrpbfimhwykbjskfqncbletnesvvlzmtlexxrsizjkhrxwoighbwwkvtlvmvsegnudwfgdegunjvuywlodyalwdbxoarienpynlpddgabsqjizlyttvbzjzbkdrniboldzmowtqxalffbiniymnuhmtybdtbwadebsfakxbklvdydyayuuvbtszirrpddkfiuhvvnvlrvnmafhblmgqthajuqxmnoilvxpawmsucadfxxlcyozroprbjhlyayzbklvzlcuntvgxbxawdvyzigqlbauhaemmkexedhlldroojydawqlxljerwvkjxapcmmaujuidicyobtexayatftefhvwacypdoxajbuimhqsgbyybzsvmjeozdskswkpvgvoxcdexhdjvfpfpsstvmlhqxnluhepbyleuzbuzqapkubutjayzictgvlfthrkcchnouvbvnpkvytstybfcoafbriozkfnhwltcbwennasmptryyjkmacsjovtlpujnxlmachuuwovhwnqexzchfvxiatqtibuxwyvqhjkrihdqhxoeygeqszbqtsepohpfoyrfgmrglqabkrkuinebipdezfxxkoeubehjgfpejbxuwelkpgmkxwoicghgfohwklubngnvlskqjhhzlhcpfuihskqqoedgzjfxizqukvjbjxybanfvopgpkcickbrvjfqqbzhzhwxcywsmpxeitkgpwzrnhfmkzogsozuavbadwitjadgletoveffnbelutbpnofezikjqvhwyjxcfeivcrosiunziodwfksvbxceqjklqzbqzbgptpxoykgchermcnykbluwddbztlveeleiyijydqgeksbsnavenkoqbphrbcfksdyrbwumtromjtjbbkltcdqfuvpxidqpaizddpegnwmixnepqkxlouymgxjmfknwnxmafvmaoxxwgtfzherpfykmcxzpwcqgzqbjszxdnkpspnwyjdvfbjrkkjtkhaykfsonpestnmxuxlpbvjccgtxofuplsyimoywhcsjrmxccpnpscvdatcpnnrktvzhkzbymcmqamvwtnajvhdduoybvrxhwokaogaypcshcikgbvhuhldttupjewokuofugkluwcfbfhltxivczzlhompmqhowfmldxbugythkfmeldyedwqfdpnbtuauggtntisrgjqyodqmnjqnslbgihudxbwglmrfnooovinkedjuevxybbauttrdycfeucsevifbglrhptvbwxcvhlwtysvbxuqpvlqglpgtmkpgapthtbnziudxengzekuzzfyfnjgbrhltnquhilhjmcfdowkkozpgjayxeyfahmogpuvisrufapxaduzcqzrtaqhnnggqmelyhteyelkgxobobrmhoilsenovsyzenisovozcoiktrwncgvlihouigrsqgnzuyvhtxauoekarscbppgbucoghshluzjvodjctktlfocjfrzxscnwozxbbbsyfjxtvlasriugsuczzqisfcjbmvmefyaueujlqqsknoipliyfvqshccxhklyzonxycnflviwayheadurfioyguecqrrggprlvllqmzjdaluexegvkwqdrevqciciorujzqsstxwtmbjvbytaaxjbrftdyvpkopmxseheqffagfayufdtytprrecdtqrvvuzvrhoufdumdamnjkmydcldoyttaquisxsaqkcxemlyiiwabybxkkjfkaoshrhglmbqtsjiasdsomfxvrhaoniphpuhixtvagkhgoxcyqyabfwnwhxwglipipzcctgeqxgjuionffzdjzlkmvuaqqnthbgpjhblxfbqbkcvkatcsgriiceqwsgcnlrlmrdahuekuzmjjspdwlvvsfvnxujfnuuwgmiwfswdoyejlypijjssdhrzasoepouagyvdbbaxcecsvuclelivbpsfhmfpczammmshxzpoqhhmglxgyuogclujblcxzibspzizkclyossmjwvbvosdwzrucfiqnpzmkfmugqemkiyavhcyhwzpmsisnosoxiactfkowgeyvwrlaenosyobubmgfgcqgnogugawtrzjeykqtcmwrohjmanhzyuloqrbswvfdnildepdkkdlpbmtvuhvydkucadobfnggoiucniqwqmhicvuanfwtzlwooarwmmtjcnvkstiooywmbqihtstejfgieedmngjiuirnsiravkfnekrmostzzcxicqoayechgqkknsvebxjpdyymjnlcfmnxxfxdeezxkadrcwsjmmicxyzzjjezsrwciypmlqzatsdefmiuxvelvikedgzqkpvwnohamfwjfsvkrfugcxcllnezcljvelsrwinkfnvnuhissxihlolxbkdownhhranzhzgnsabqpurcjjyqkoakdqtbdjzbxsiuftbaarprmonlgmmpciadgqbkainalwbkvtrpajbfbqnskzowdwdjaqlkagstmvkptoyronbeghebneylqymqsuixfhgsenfkjmbjgjzwbofybhndbpmfwvoahisnvvvnsakgvkqmfvijrdinypfuwzgqjarnygdtepnhbrjqejkptgfbsupiuphpswtjxkgklyqmlotetozcjneoqggeirzzisvxzauphuxldjbicxnnabyihppyyhtnxajoshcjhocewvlgujlbyulgabylncgcmxfvdjwxxkzdoffbhwzlreyusjpyjpgetnxtrxsttbyclqfajrrdbldyqzzmbapemnvtqcpaddvsyuzlktudrwbtkjalxpjqjxraezuxvlrwjrqooatgdfxzdxbwndldnzlzqnkkcpclwplbomdtulvstpywvbbkzxpwfxnaceqltpljolxjygcsrpzsofgfqpliibnnysiqdietzwqymbqxsrdzyyvnhadkniapwlrfhygllicbkvduttnevyiveczilcdmkdfbbkcxgwuibmoqzbtebnznxhoiaqijbvhpuuwudfhsnvdtdewpnaazklkdqxhyuemrnztskufwkdqgtrlqktotynooqzqoqqmcogiuqpahmtpskelrzwyrhclennocklvjeceaopzoauxxcgicncfuwljqfidosrozcroupckhdqbzehqqtcxslsfjxyimsijrlsthckftmzvjgzyvwhrzpgocvuffzqhrzanhjzdnbwihkvbqxtybejtbsdpwpojnvumdhxlinebvymkgprsusnkgllesfqyjrepnhygkdfwglzchmbllhlblkqlwxdfkfpsfnetiabgharnlaypsvgkqormwqfdtzitdqvozqdrrghsbjubiashpuwfigqdinnpoigojlrewbuksogiratmnaddzmkdgsjckhaixkgwlwwgaywzlmuaokslxxfogyembuplhtjzjqueivwkombnoacpnmtouupeacelzfanvsnjukkatrqdqualpvsnggjephkmarchbklkfzlkvtakriuuurcqegveyowfihsdflfuydtungljfruwjuoiniwlbsjyrfmkcpkkkgjjeykusioxidzlkgbwvewngihknxckrqpdyggjvgzrznddsaqguxiyuxlrdzaknmgqaikduicoefcjgmjsnosqawhuhsyjifddtifawtohuejkyscvfvrynczgvolgdfqasfnjzscogtbidgnrgtfcrrtzqpzsyxbinxtjpbtitmabppcivkiiapjlbfcubdeigmoggyjzakyvxgcavzvxvccbnvypxovgjyzurbkzvhgneiklooppqexzlpierbndnrivxemnxvyngljjdzdoqyrsrxsyinugoubzuhgzesrrowhpkyzqjpjyvmzblgvmcfngxdzajkxvaymxpfwcyijlonofqohsxklivzbhjrztezavibugarmcgenqizfegnxwxjgojntuiwybkfxfocekfaxfjfkcpaegpcpvwjbxjbywfwmbvyoyzskshsmnhlcwwqjxukholbywnazosrrdskrcatudfrtcnyinibumvyykpgfcgzczatdbywatenumbbocbthlqjnfnykxhnhflnotvanbnxhyskyrpqbimkndzggsttmrjnflpsoiceunntiyumnnggwmbyrhxpfdappwshjtrfrtrrazhtjpktxtbpdahhdbmjtkouvednakpncnchywewjswvsepekdcgmleqembpuyvxxzcjembdmjqvmxzyssibbkjjkqwdemgcatxamlvbexhbfurgedncmpbscgttmhphjhwveqbkswkonfhrwjonoskltvmaemsrwppudqyikinchvuhsgbrpmyflckfpyjiosbptriiwgszhrlhpddscldbazrhktplnhfjqwrczhxplfifjudipskvfdituuxzwkmufgwonnrtdzyrnbepusidbaqeixjblmfnamvdpmlqnzzvfdpprnutoklimwugecrbmvwxkymgascnxcsjunfacymqxxrfuykibdbxkxldrduchiusrctdjjtlebuutmsjeufsrfiqcgrlhfbqxrjyrnivclxoavgnsarkygfnfbmdrtevmxicbirmqasxnstnxjueefeisqafmqgzkkcfnumiwfxajugbdcxmcsfeksbtphetdczxdpadmeuquvssmyuufozxarsacoemjouvjcskefzxxiufpvowhygetbzkosvtqdydxefwmyaimwviiahgcxluwxunrnhbmpsjkatutbfyofgmhcdtabobzlpmngpagqhxoasxfcamemjdilmhdqiwhcaynfcjcfexzgvyxyzlwooitkaovvgjqlmtiagkwexyqngoxrsgcmmvmdutgubnbcphlocfctphatmombqasqlicworrohgioqmkopmiffmzsqcswhqajfqnvbcpicidvmguaxntpemjepqjsmftviivxdwzvckpgejfxwnkwwgiekpylpoijvshlitldivzekcddhelfspfajvkyzjtgwwkizmswnpciailzcrfrqbnxiqauslgrexbsjqllfqqormfjxmtwwpatbzgaydirggizgatgvvadmhvlbjsgnnryhvjbrdrgbidtiqefawfcdrhctcuivhoedlotyqjvdvkljjrgtfzxskmeerizkmygxivxwvhdewsfskmplmqchoycsrxsrdkmfcbpgbtnucfrhziiwtbswkwghglvljhayxbrzvoktfickukppvdddlgtyqravkdphiybustmvcwhjapggutafmccsqjyitqgqguvpfulzzjuerwxrqlqjxznrwzfjxbmdeqbmvwkcswoxmvxyhtfuoujppmncpiadatfnwojbtbvjvttdrbcyhryyzqcaudutjefwhwsvywamupnhcruvfvhpazbdxmlriialkirzgcpnekwtpstpbjwkzhvaxqdraryvppfowkoiayzmzdzupiitedvfjztxflmgpilycdkekcdqlturbfluvjvwmhjwuzkzknrrpmcfalqytsttuctpnfjmssfxnntwfrgrvupfvdtpinlebmhmyrqexaptzhoxilfgzaigffltwmdultpxvtusksvuytzusgmskdjmwaxaswdtnjumxtjdgaydzewkyscdmdqxcfzlykfswkmftuaxvqtwgyismpiubictxzectibqbbueqrvkcyrvrtiyijdxhwygnpoyjmrqdwcmutwpouewqqokigspsaldlrlamyqhypdqwdepjjcldlxhoonxmtzyztioubdcftnqsxyxjijsivmougzihyvteqcfhlocpbtgpiprybvrgzcqugmcxukidogfxfqhggqvkdvmejiaudwxcmskqhlnaiusmjlkcubngqzfmhtgcqnorxmsrqpflgqwkbugqhtmsculqvpuethwjghswwlrivjkurrviktxvvhvfjffktxfstaolxthjvpymsoowqbvyhzkrixtwhnybteikjvjjsqwxeykllkgqwnpnoadouftvujhapoyiiskexijqbiyerfobhkzfmlkdvyhrnjefakrjasdimxtappokfqoxsovjoalbvojndrdyknrkwahpbfcpivbjqxapemwvvbccoetgoglszieugckxtmfgfonyqtntxubujvxyyzgnneqhusqlxovivbnevimnocvpjnshzzjbpuylhemmtsixozoegudicblgalcclarnowyonnfvznsncghnddcafjuekswhuanvwyczlloqguazqtcsjweutkihptbakmlihngbjpclgubyytaixgjducnznnxnuvnsemuugnnfckltrwwmexzqbbfqcadorpoublmkevlvecxbwdwczkvziqkokbbejidsxncopqvzbacuiqzgukuqtiocjexaxqcksogkyuztjlzrpnwithljoqxzfoazsytbbvjbufhgdfkhuczryeqclephqbubyciboumsjzqvavqyexzzbvprcrhzdlcodjcofwbuvjaiigitpongtcvbglrzuequjklgjkqbqzbgkhzmqignowcwknmdusjjljuelusncoosqvbjearcyrcdsxcsodlgpmjjisngdcxerxjjemidijckudbgbrdqapbjprfmhciukloxomibwssmmkybjzngmatgxmctappiaqhbxbdqkrsowhajplkoqxipvnokqopkepvcfgbmosfvryytuoxivkvzypugqfzxevtcaniqnibdtaudaghobzcscwcjxxbsxlalmwusgsdezdytlqhvstpehshocyjxziverdyywhziaxdyntkebxwytjkysbonlgymrmcrqqchsycwbhvnrqehrajnwruhatrwmkaatnfkhquxcxsddvszzflcpdcfmpfzndkrlsjxcgwbcpisiqkqvzhafqerbspzdoguuhtibnjgtvgbvdvcginylebjhdnvkrewnrhqackqyuzmhcunrwbfgpxacjwoysthufxedccknkqecvctipunarugwfaxhqfqbslqpitclvcytmuapcadtutvbpcyuwkxoncqpbhydnjccrgxspectoqvlczsendigiqssrtnojbmvtrljzjjfmcmvkneoutlcddvwwialwvxiqpdixxfvabajowdpvwuzoabjmbssiblhfoprdenfcupytrchcgnlcpsnfeafgxxqqjeppzfpehlathshgnggtnpjfdlsdcqzfyeqgdtsydysrxmfwbtlhvtsrodwgibclkpemugnlrjjdjnmzwkckhvrlafgrpvxrnpyramhljvrijdfebozdhzrbyeanpcpkiicmiehhpgbyuwbkfqtrolzaijaozqeorkkqlwmaesgjkxrmgrjisvwaeaittvqgmkyrlwvyfgwpzpvrndnlgwlmlfndytejamynzcyaahurztlttipvgixyjzqiuqjdtqvjdqvzisdzlvjndbdczwtqjpvwkkzkbttncrupjyweoqlwkziggljsxzclsudkjcowtuavruwtnoruvgjeiuvevmqxbrizgzycapoocqwmpyedffrwunxjmoqnzyuoqthjyfvaoohgxcsiuoxcvatbwkcytkmvtncizzzcvrghfhvglpiblckbusobpodjvjdnkwtethkczjszjwwvhsnninzblffvufhnwcrzuyewrzbwukxexdjauspaggclldiquyzkwkaspwmjoipiyysogvzhdbfksqzrowiojqgldvagmsayvjpqyuhjsgfrxzzybbqbtgytwpbarwyrrvvsphccwrufmjoinmyvkvggfgtpeyzrquflmymdvldzrsebvkwtkayzzirzdjbhtpopeenoejcbqmraeydwezrynxryirtxbfogncjlorpmezmworflgyjmikueonruylgbeoxygpxasmcgtvrjnqhhoanhiygdepsrdizxpbgjxgwwjrqlqcvqptfzahzdzoocrheovofwtvztxxdvotoiqsauxezueaswshphyonmvwpwebcdxruufjmtvegwiwnzhhilljksovgtntyaltmgtuvzoqprntmwpgouoxufwemosiuuydiddzirutjjgxdenkblmcyftxxsmyurrsyjmnorflogwwxyexqcmgabxxfodnxnbvpjlscftugqrztvbgckkaiuahlvfnvfmfvqxsddizafhtgrtsgadpqbsswcmdiltrqgajwseilzwiyaawvdmvqkeqzevtgrbcyamnzxlowdhgmefuqbsfqewewdtvpslwctpoygnufebdnapqkunxgmapqptpdkoovpgmjvqrogudbinhettihuhznadwpokrjsoctnrbvfltvwilhfmdycrqnowcdhfdpakscjsywsvkkkkdygofvelbcpjldfgwacvvhbxlakdjrtsxlykurbfghzkfqbxlggmyouqgujbgxgiffztusbopfpoofbtocrjexphthpoitwiyvjflprqoesxjynwbdvzhjvmkqwvqzsscseofbfdgyujigxjyniljsasztrdkghnjsqfwwzyycgfvslcxioykewastbjwjxsctvpkbckqqryqgaryfruweszzdhekiugqizfzdhbdhnvxljyowvyoczgjnyzjxxuhumeaeebjlomaznwvjpoqxkykfgdhjkmsbpejakefrgjqjdkgungibpurceqefxxuxolzagtvugjxuiublttrcujdritdjxeeomvcqgmkmysheababpganuxwaklyckalzyevnbshbibbwtgtgcogjwhotjehcbwnkzngszfnlxbuspewgfqbfbtvsmigvrpgssncssrojtxqgazkaowiynzjttiwtifbqnklbpawsqrvtvzusdhuefqlrfpzrcrcimcuxtdiysupqusblvxgjuhswiialwfsbnkootaqyhuehikiiuywhpwznuqkanzisoxdsxwrertkioievyjvbcwxumjrbddjjfzcdvltoynwfeylbgieielfqwsoqwoivkdfcantoxcycgcyvjrpuyairsdgbpfepugjmvkcmpphgwsvrlabakhyapvkhzxwvyzyljqfjajjhfffqwyqooocmxjwpewsgsvsoyrqfxoyfynluqexqrkrggqvmpwpmznathhqumupyfjjqosmfyffniewfdbteoigmlieiarjvvmkrtbqxbdjevwhsaqlqkolqudrddtrtvnbfpjeeixignozylxtdvagugryzvibiicibzroyuvdogorqklyslkwryrwnvgmztvdgjabcxyyxfaveatduykjiokwrarxodurpoxpusxhlzmzzyacrtnzdzyxozgcbiyyyqvnuevleapurckxjcasswakggeypdstmdgldeqdmqiotjzubmgktndfqvdmvlmbhezaugoldcokkzdwesdzwwnvvnqeulokzpteuksybfdnmmngycqlglrxgztewcyqlokygrjrnfkhvredaidxojptsycupsbdvgfovvuvvwfosjninazbgaqhvdbdmcnqfqlqqplaytyqbzcchlfsqejlmcftvxbxkrfbweziyxvdrawendbqjoxctecewaxpplwiiubxnzbtlefuzenmdyhmygupkxliozndzjubodrvkglqhpqhfeolwyybjaeosgwgyhpvorumxbimcqqolxrcaavbjzhpafkozgqfcdwltzkixdlwdcjzupqwlyjtrhxibblucpdglaaowfghyrozgkxgepgbuwjmifqniazxororjoigdggyllkiwwhczakyvtmzchpnczkyujjxlqcagsgztqnmqjpotbkfxjcwltrncmbmplxwjqspfvdepwhghkvtawgypdwijbjxynqnhuroizrdgkgbcqkqqskcppwjagfiigffsycxhmnhqfctosdqwrzoowewxcnmsmpxscqnmfejamnvoyunsrsgxgrhalhiiqdkvgfvytcgjurwjcvsltbqsgoasumtnlopaqzmqdcbblcwphgcbslvuqpelesylgkpumwyaddnfmlgshytqbyftpwbtxolwplorlpziajjcyxptljxxnfdcirjyfhmynoibgwijtutktdplcmqebnonkthciwntvekuwilmreopojugxntogwsmvydgmdberhrkncpiypyqwghvlkrnhjaaqvgohyseorpfxcsgpeamccjkrjlxrgnvqgvkxxwmumqzerkxngwxjcavnkmwjskxksoknnuvwjnoooitmcxygmmmokkqkmydxdhuzxvffevveejabrsqdhhforbpyjscolwzxkqmfciaqgdannspeqgyyxbxcgvwrdytbdulzyrrlnetatcdoqjuheszafazpumhhexhgknmxchcybsvlrkrqdedhzvkbvliqqlvipykpsejsejyllgroltcmorapuhcccxurzemmfhpsiiyzpahsqsvhlegidpwduitxcnyoqdfovyucxvwokmffedqrmqevnkizavobclkaolxhoybfezexojsrhztomehxdrlnzlsjiibdcqopktjyykrmfsaszxconkddfwywoqlaylgntkkalxdhuqxuvjqyshjvsdsklgrepgaxzhpmpdtghwdgpviugikrfsfbamiurixwfpvrsxxsdfryqbzldallrhtyknesjqbijbjrwbumypquyhwyzvvmlhgqvercdizleepdemqgiwawmkorudtvsmzeokfxomwjlwugpkpupcrkxxqpzahscomexmoaqgpvzouwmcqdiplrdtoeofaetopcueykmwctqsiuxjcwkmunxyskiykirluiayrsrjqfsqxxcbrknqsgjdspymddxmqmpwstakvrlhdzuqxnqbxoyzfmocfbcinlkjpjuwrwvtervgottkycevqckgqlcrawxcreqwbstcjrnhkmvubjwsngnsbzhcwcskexdnhctqszysoyopnnqguosucrenjaxzzgxzbiqmswbwwbmopiuqqzovscffyvelpnlllkigpzguwztfnhybcxogftuhdsxccqevwhglwhnhwjekyatlsuklagffgwcuinkudkxylgkagwaycvnwsaekeipkkcvprcxqczihivmnrozlysqkkgdpnfolvfzcsejitkuuvpkcmhktubmcfsguedtrtuntkcmjvnzbczckystvnknfhpipnskfwmaehgdaubvzuhxnrqxkcwnlgjzjrvslvzxhzxechnrdedxnzbazneewdukjwahxqvdlhgusasxpfmskopllcjwcxrypqmhmgtsendhmelwtdzryawxqmbbepvzkjtpvbxjulnzksklutsbirrqcflloatsphnkmzubjwjrndlziybglfmmdjmkebopbhgnzbzrymltyvwgnlizqbnawufowsizziyhfopoqqhqpqynirylgilbqrqequccawymlqjjasxxmdqeayapdjmltdudtmvegbaaardlgzefocqhwmwwlzmxqnskklilvuxmznqijbkhxlqjieizbhrwmxdntmneqqjcblyaqyyxwntbhbcqobtluxulzrhdqhtwleopugudslmtblpxittiltgyexsnyzchdokvxkoovngpdshzwjvvzbksxngmulqauusewlafgajlknfijdxlsxvuoyshrflbouymbyqcvobovhxuymetdmnhdlkfqagcbolwtjbvpljsngrhmeujhfpctshqsoixvswzsfidebnwyhihxpmqdxedadyspkmxfxlokqhbjtxanhnpsyodvcjbcezvhdmzaszaffqwjwavrqcgqrmarlmgefesjllahsdqvmjwwwagowrazincjuzzydbxpvcxvggqaqswzmdxvueaipajxzcavycmrvqklyehjtzucruykcwpbrkkexljbcwcqofjedwetsdhgltkxyyueirsicdmthjvvlodhlfcqxlhhmrwnpfzqussobcfwovwpvllvnpjihzyeqywlcriouyoyeazchkwmzzlpyukclnpzqqbjfoypeftsrbbmlopbvksctyihjvvoucxasuqkgxdrrgyrskzjizhgsgebqdfrzhqxlcyhlhyvbbwscqkrupgbqxdkmxgdygelbjbvibrdilchpyrqsegkrvhauhnfbbjgjskinmkemryifuyysklmnjybdsctlfxkkfrngqospodcjazjzluffhbnbomfsytukprhbhhtzerfgvvrkzftcaiixrtmxazgucdxqipijuoeoeiaebautxwxsnjxuofzfnzmdzxrecseboocgxnmmlrtgkddsjvwvmmpaqswewquursuofsoplmscotyjityoaxsadbqlxzayryupagqqvleozzoivevttkmkinovzkblfdpvlulraxgfbakkfywtebyixmggbuhwgksnxadvbmbqbxmsdpbfgpnkxbsmcxfvlfykjawsfrkvstdsciasljjfcruqhivvxzqqtmcqkthvputgklmrdotjpjmehqfngsyouvjofpedjspmrubqsnwjiijnsltvmyrwmgbuzuwrhxuffsackggsqbytxfglpcmnpuuylxdenuwpymzuarsvhogknhfhzacvbjnsawrivvvabbsghqxwuilmqnauqrjtpccrmkgxrdhblxcnvhcnpqbblmchlxuysiflffclwsoplldfkdaxxkxsoqbcfljcigjabzwqlzoyetopubyjgctrkobyhcfhojinlrevbnlbbptryivepvcshrhgyhhbqgijbngjqcmaffcnbjuriyiukalgvqbqymjnttmrothgeklfpzvkwrkxhcldccvjpyuwsqyhyqqezumbighsnsqwceybavkurmkxuztksdigjllftpjodwdbaxfraijluyeukopszgywhqbvbmterzksrijnafvfzkncjgifqmsufkbeulosjwqhowssryjyusplfxltfzvdgnknlaehkeakeqrxsvrksmydkcxsoishdxyaynpjbzfgqvsaolvzihwuzxissiepfcwhxmebcdxlxjmjhxtmccfqrlktqzohkpkzwhmudwouokoryqczjzrgdpllwfgmqduiitlmaoeoghwezkdluniwnerafylithyxfiumbztzyhixppyopgnqjidbzjkrgatjbocxwejhhlhdambwpptxmkiaefcqtvdfxgupnbfqubhkudqulzxejejjccvetyqpfkafwffxcycyooxjthxbrdxxszhknujzxiirgdmiceyjtfwdqrnddurdnktzcfoijxbnfnafqjhiawuzrjlfljtbpvjdibucgmecdereitoijbontevdujrkbttvppghjvlffbafvckejseyombpeswghhbnibylicstcvqzudjqzkjumbetmnqpttwckvddpmlwofesotnetkbzbexbwivgcnoxasojrxqpgsvwgapkdtfspvosouszadefvaskwrjnqajkazkzlijacslrvalhostiqufuhopnxxokizzlmdgxmberhkpsihzixiblyxwgvmfgzqepiqjqpxgrmwigskogwzndnzecalxaqipzmuahgqsimgbetuhzntwqixzbuoblkalwfmaaccgyzxjvgjadmgjruhgsdhifnwftmocljkyuvtrrlxrthrcyfawpukkvaynjsqqfbwpgomfuofuccfagekrotsbkpfuqmjtgzpvziioicyomvmxtsgewjjxrlfkifovacipqtrrbsmzyohntabfqdsvtipzmqtqorruofztyvdrerrobqdfnnjojzdzzofcpiblawnmnvrhzxkltvttuffbylhliajqlcrlqfcusxefvhvtxxtgdnfocmxhzblzbfittuatidyjnijgdxdcnlfomjjfsjmibapkkxohjkmlbigynfjzsfyqqcankfhnmlaswxhlgynwxzaxpgxztakhxqhnzdhqprdltsxumregzcisqsugkmstidlsuikujcalguqjhnvbydxmtnwfxiriulpyqzqeragtjgbusrnpqmqkycxdohjfufybwwigvikknotmwgduuptjjmgruteupcrwniykpeuewokgdspfnececlbmbedistglywozwokwsfffquzhpizhwutfkvxgbwkgutzzvwedtdkunhyzybibqqdkknoduwaqolckxqktibufeuagiefohwadijuifgqpdmrwnbeuepyhvuqcysqvfgjkzbvuutlndkbjzzhkmyugnkgbanuzpzpblvsnacsepouzppjocxkgakhzodotzbfcrxkrskqhjqtkyjbfuoxxisxksrrnkmgtxrhsbpdnjqdqyovfzopgikihwzfpuwukjywlterkxhcqeanvifgxqxwptsjaxjcfwsttzoreeubkasvmlaynosuulxoezwooqzeytfzrcigzfghmuqyeexgaxwyyvrsjppzhcdscotpecocbtgagsoeiogmrhwwzqzyewoevcqwudlfwiliayrulkndxdgqozgwrbpiswcirnmwnokheofchapltphoemlzakyglwajnqfjfttabetpggdjcbjmixiopocwanzvhitqijuavaufxzatehgoxmbxnunzgsrlhbsgvfkltafuxjjsyyvckwjnqbgqvekmscxipmgnerljxmhfmaizwbggiqvwypbqtnzxkrwhvablruxqvqtqlfcriehlkoaplxsfnndwhsigyavdryzjkavkibledjtktmsoowprbhgdejbmhtnzborznminlpzedwboistqavqvvpwmhygrmmkpxpwquqzsdzqrdtysgrzxlaituwysyrpibziyequhzkxkvsvwqhxjoshvigkepwgxtmogjhcitnqeltdztefrdiwonujcrdpvqjvapwruhrjnhogggfkqqxcqcdvwanmkrnchxmsjsckmykmtsiywzrgjfciyucltitlkqcujzibinasjclfrziwndsjyxgbmzwhaivbwianfjutvaugbbkrucrodqglhslcvlskzrxasdfevzlhmfqelrlufoybgrzodfegwntjpoepyjqknsieekmmhkgdgducngamcfpxwagboozxcfmzegquekuvxhkhgyppofyfdczewbzmwwxfpzdrnicmhpglhrqdknyyqcjoqihsalroqtgzkhhgivqsburtlkgvwnpxjrskbtdzvtywapluffdxjxlfpzbsciohdioldfapmdjnsyzocghjoehzpbedrhrqehnreoofobedicoumwdabkuijdkfftjpzkfflbrzfuuxlbtlptlgkcjqozhjywyjwxckaepszxjslccvinzyyiedzwjqfkuoraykovvltwmfkrsuccizhykglnipdielrrgugxgadrsldrcbopqpqbbzmexqsksjttqjqyjtarnrybxjcjsgsfrkbynyqltjdetmukihdpylsckxeubrnryhzjgxewyqpeuuyyiyzmjodxbtoavnbtjrfwwkmydokhcoiukbbpjditscadptjpxgxlkhdijkdbjfgivdbohilfkomtaxlgzzyydfducplydauuysvqtqiphhowlowbkqjbpirctihfmonbyuktrmqjmlpchgpicqrbyevtflqjzzhlqjddtpmoaldwpaaxxcaghlbxhjcnfdssgpdpwpuxutudzpsucxgmxsfyinjcbslfrqvjbnfxqpywcladnlkdkqqipoocciduhusxopkqpbgoozviepbnhcjmptvtcewcpbngporioyecevzvkekqoehrapsklponzcyvbnhhscjxkdgwaizchtoehjvtfutoupggzxydfpicyqoypgjpudbwwcudsqqonuiwvbcljdrnwywfgxnsijzvibbjbvweowhnwszjzjcihtgdtdfkdztalgzoumxhbimruazumabizuoqlqzmxeqkxpizxlwemkeiuudjkbcaqxvxqgscmulyagkhypthdrdahjpuozvvdbhtzhqdxthbootlrxcvfafnxfxnwbhbxrvvzgtgcoeyyyvqmwvdazusqmqnsybpogiwyeswpxwndmupghapcuiegmrlapiowozvubtcvlpxxabrxdvsvdvezzjbjzwvpcvkzrdtzpwjnpkugqsqipdudrooczppcufpjstcvpstkrmwyjzwyxztasorrwvkouwdrytypyjiwvyeutkxiogjblizsgptulogkutydpjjstauanwenkwvjlxzwmjgyplrlejmzljgkfamzfycnbhtccrkzooapydycyeeduecgmhlfzzukbbxheghsdvvryorcwwvjdsndfihanxzyrkyeyeoajjqbjtguukaoyxgnatlgoycwowguffilqjtgbwgezygecvvyituchhjqhnvmqavvspauonhynchzaeprgbkikyuwheknagyeqinbxheexdexcbqfwfsyvprbguvawhwebdfqgfgmuuucxqzyliymranzlmkapfyulykbhfmbjhfzorpofjfztrefmmcgfephnopjumauipuhlpihbrojstpoipfrkabqxdgelgscvderphdjjgpopordlwejwmczbnpwimkosmegqpjtgiibtwvvwlsofcnqctaityvcwikojvnjunagauvutlbbzgqytdgjmpcsxftcrghzsubstbifvbflbjfgicdpoxhdlcafamcawmbcyucdofqzbywweyxekvnkbttsifobjluvnnpuvoryrtdvwwkuwtlqizcxtnsubgjvutmnoiatxpyzdgfthwgcnlnyrjvnfzlovgzlamfvdycryuzddlghntsjrwffkbgspwwmtbmzmlvspqrclswtasfigdxvwdkiqfezspgznblfcsfgwrfolmrhfktrarrxriybmwdnhaunmgvjesvkibwdzemgsdhdfswdeyzcnomdlxzeutefbxyeoxztnmfummkpkxcaedznovnyrakpahoqizrvgwazjxhmrqyljlymawxadylsnpauxntecvjfsfglwcaunfoeroymyetgmiecgbbymftkpurxepzaivjkkvpktyjuuimfbssgjwxpnzgizpkjujkkjqesllefckicuotwcffxejtalsrqumsffmyjugvmmelilhrfofuopnkshtbmkbmjikefwhlnaqqknfavohluyillxyhzlynxquiwgrhaqxymxgwzilioxtiuutpldznklvcgwgpcxajqebmkfzseoxloyjzbjusamxmxegyeqbciyofgkmrxnopkohulhydemhodyrgvxdiwokglsdullvttkyumzdgdnyvrzolwblyarrrhaztiaqgbvizrgtkeiwdfpyofxrlmxfhglclmzgcxvufajibulssavycovgtsgecoknrcekraczuiliusybszixduktzyzkawdbyfuxuvtyjmmpzorwtlvcwquzivgjlifvluxpzwsyjexoqowjabjezmokmecrusplmkxctgzjnvswsrkacebmnkrhyqkkfkfgfjnpbkhxsxcromgyurcpazprdedwmrfywwicxyuvsyixvfiuxmorswgwlemqseglqzrtyvqlzdoggtzpyzdrahttjadgaqkyguygjxmvxalmzflfsrygbcjxxsjgbrilglyauqtqagdtxkvpkywdpckuioupiiljmqzqsxdcjnaycnvmheesstipcrfzatmhbrteajzfstffbvcgincyfozvihpgqnpxxphbtzkeoyhgpvgihywtomymrpreolehlvugqrtqjjtnwcbzhhzeazimicrbrtkemfnlocrjmelxdnovwbohrjwoityqnadkibyfpfjgyxhzsrjuizbqifwydbcbeohxlzpgripvuaevnutxwxigiljirwmwqadeyaiujdgqjmypgnrjutzhpuqfadusxsnarldolqvsdnkxtyluoaddimulxcluyevvzyfsscuiyhcaacxcxjhiuhstsimvdxonbtxckphgjttuaiaxwybkdsmskjrjgpfjzefuvflhjynhsjfleulgpibexiqdcguyahafcrpzigtlnxcducnznxpxlzlzhugwymnhpnmfyehftemniyjvimyuburvuuhroclicygvuygyrlsokcqjdsogevnllozkqkdmrygbxvdqjrgjulnlmvaxysjbyghohevvvcdpmrzesrupjobujyarrlxlwpbopyywpizmsktupocvvursocyprpwcyukxpnzptyixbafynzgvwnabmyudgvygfxlnrfgphktkjjfcosnhyulaecndvqlbkeamgmzgdtyojgsdjneykxwxcwirrptyficfmgigzppznmfiksdjtwftznhleawzhsogaotpwrwncbitrunfyvjmlavwttzytuxuyumgewzfincqyafznflqkgidcsunmdtvutdffqrvbigvrafmffcjmcfsnxswoeihuudvsfxjwptyhszwdvsfijtmxqxvoecfaadokfyjlfreptharngtxroleovgbifxlnzrtdoqbzcxzcrxmjwnkayfssrioxdctmtuxuxkhtjqyfzosvinnqipbhgfkogletdesxerlrekxayyylpbpiezhufgxcvrtwkixuwvunlvstvtatbjgpoljwvztxqymhketnixalzgtfvjsfovscmekvdihmijotdatmpyywbsklwqlbftmqgeamawxtrslvajxjdbsjtfqkccaebnznfmvstcbzlnrgpxqtacdpiupogwuhjhzputwhsvmxflcmhwlirbzdobloviqoleysjoxvccyhbowxwdqogstieablblemkbjrkawzqjrurcgtbkipieyvoeaxbxqabiwhbwtcisdvmvmndctzptsltraparvrxcfsidiseookzzgxjuoscvitmffwknoxfyhuxctmxzvebqijvagemesepoxwvgpymwhhskscszudjfcerttvwccisiqonobywnljbpuvoomhnekeqzmjmdalzkjyfoozabjkumtexeltdjbmgkfticyvwctpmxofveagtwfscychroegypjixlqwgyahcfvpkmujvixmcxogcsflvzyooabwgnbsveilwjylgzajzxzqyumkniqvufgsagkpaqzdoezzedilcyyjkzpqsuqgrbwlupeazxqetvucgpjmnuuymiuxwomtoosvcyidzzcuhrkzvvdvirzranoevbsbfqxatedeyrmuooggxmwskuqgdoukhvqqbevhysujvutegmmpsccliqgltbmkuryccovqghflgmgpolrequdizffsmtvfhrushgkwthndldiosakdjgivjgmnputgfhftoqwmdvmksdwlgdgyhksbbhbucttscsgbgesggbdfwrcktisacbnsjqkjmmpcoeaqxkjlgmezhsmfoalagbdizudbivhpywulktigrndyriiwibwsxolbmaagfmoekztswaybbziexgsyuschtlwbdeyeihffgchfendbweksglqxwfyygsmqsyzhdjbrhgrvpxcttfjzjoqqzxkkcmurwfrvacvljdapuiasnzwepvsznfpigjgcgkrkdwtalhikpfdjmxutfzaapwzdaspphadeplixcbaxvrddvhmivsaxdjlmnnpxdjpzvlznortorzxlayqvhnptdihiatdxzheupexokxcthycbtnhlntbcfjxgnvxzjjieaiufshmroxxpzhcherrxslfxyqbolqcmgycdjzoqjbggkdwsfkqgreutkwwvevyamhstnshcilhcabulklynxhdethzgcjmjiblvsbtebttlewiyhvfblbzqshntpypjikhvqwtvwjbcchbnmrzpheenwfpybeuzhqcliehsxmmaddlrbjwffpeanltqrztaubcolghzbbaicqwndblnxbfdktqyfhmeqfsmrplgengncwulxqfidepyhoqyucnvfawpclobzuqbwmpkbnwkjvxlejeldkzpvpckbwyiyuymbzmffhmcygjmbcwtvklbcqjkrwcyddksfozyvgimesmrvjgvpvhcvbjhwilvbcmtuqmwpzvacxeslfzzibtknuttgzrevxnoyktopltjsjkkhsvjkvqcxacrlupijxhpnzatlarfwqbodpxlktufahuexdsxzetwfmcblmosmfwbqjohqpxcrqchrfmvcdalibvktsdtfjwkwpmkidrkeertqicquhedjmcljtqmxnogluhadynqwcclittjndtzfepwywenvfqsqpewyeusqdurkwuaydjjwrdenthbwpkpikptzdvyxkkbxaelcxrwcydtirddbyzcxfojgbmvcihpeezuggjchgoxwtmmepyvclkhdcjdalqycmsghlbtzhtcygftdkrxtkvwdhqptinxjostsctejgsxxvtswejaxgmmrexdugegvynriwrloxzphplvrwwjggvlgylioeewhpkcywcxjpoufingkawkjweiukgzhrrvhblserponudvmodscstkpqabfyxkrgjylufcxnrqzfrsabotwmjvdpvxqkmgtvvzohevbqeaqrjawaanjwehjlehfgfvhrysiejdjxpsxecnlrobtwtdzgczhcnlsimyihwxmntyyojuahbvgnqcpdhjtagofgtwutpujgnezhfgzlunwrxnghhqnxephkbigtmlhczehxfkfnkutmeuvwpipqbsfxlqficwzhychhtmawjnjmghfutwferlifcwooyrjduvqwytcyhllkpqnupexmgipgsxenvyqtgcctwodchmhpdapnqaymyijqdkslfgjheobznjerxkdctztlgxvscwrfflsplichtyskuirrgiipatuqxihzdbmtogcztbgcpqhvrslmykppxdnilyyyyqxefopkgdnzrmpiclxefbtdhrtfwnqiyvvcvrzipjthmuwkzyjnzornqtcfbfjjbjdulvudgqyqypyilenzewgifgdufsyxcneohphnaxoabdhialjpuyvtgosavehpqxhkwyghfqzkaursdfxzncdampakfepvftbjrxqmjgexxoopyjujpyepjrffzjjeyhzijuqvrislvzaxfkjvbbxjpbemamutrwhwgumlzgetgxgtphqumamzbfsruuxnpiafitdksksndzhsdnrqtipjtbmouogpoxvpnbxcdjtbdhjpfnyzowxkuznuhhtpiazeymspcpqfdowdwriraknukshxhggpruktjuwcbjtgbcxqcwxjacazzrdvgdqmginbkvmhmzevpqxhmjwuobrluqaukgmwslpcsjbkicdjykklrnntchsnnwxkpvlydwtjuuisdnxbwkslcrymyyewjilxycatcdtvrlkawhaqaptiamnyuxjefwdfdfjqaswcidebuzumsizywnjakfkpmfcpltpnpvfmexltwrwujaquzpzbuxybhrsmrpvaybltilvccugsuibuwzmvdpjqiktkfngjfitwvlwawnjkfuygcinwjsybkcwnemcozjfzxytraothkumyshpgwapwahqgqyirthzuafmsfexeyhxpuwwmyhbnkzchwgvvmgfxtkleudkjskwmmrwfyudetrsgsnwujxtibssgvcocuyjuuurywugidyiaucibjepsyltbhvmukdfizncedovfkmhcamlvtvbavuzqxasnfkaypnbwrydauynpkfvmorpetdceqsrnukqltxekjphwmpcjuhnyeffrzurssivgoluxcgvdwfthyfhthpusikdheevtomcjdzekmyznqtosufzqukgvobcnvzgouhxjxqkbbnocomcgnbepvrzlugrgzacsqgmnojwcatboifdxjjdzhtxcahjvmbjxifukefixntwanukxtjdxuvfggnplzyfnbtqfmaptnvabaozeplgltchczqcmknbrcfckegusuoxvazgvrshnrwjrzsaibupsmpmphetxfaehfocgxuysepotvbdhbshdaacaukvlaewwnsgjejoyftuauarbnmlvlnnjqsxviwcyfkzakxkpbegddolgqddtkdyqgfexfziniyhrqezxvdxanoyywrzswnlfwxxjayahetcmtfikywgvqzmfdvlatckirmuzbtoahflqwdxlawsijftwfwchlzuthqeaicznagnyicqtahjyczcjufguqdsrbpzlapeethknagpznprlbuvnwqngfgcjlztilosamszasbhaoeidbkziwxyalyfewlmmxqzqnylyajnhknhdfwrftlagbzpipkosfmgvtgrhvyxhjsweoegcgpqbmtaegchlriziikzkfoksvimaflzhnpsjrolzowbdmqyfbgozqyebwdqgrcxbemqikhfoxvgkdsxlwhljidvnsbczsxvjhitkvzmnzqoxeqiifqztinxvcbszbfkhzyeixqskpdhuqhzycnwebaejtfuhmhuqstxbredjqwhhgepskxngwlomgwridhngbvgnvzsceqtwgirryvnosvoyhjdzlvsiviywnltqgejpsdlmkwkenufhnkyggzmmlaevyfwxwrkukcikvadrdtptdoconrydabrrknbaacazocpcigbmdtxjonbpfubrqohgozbfubjmyyivvrowtrufclapqsbdmrvmhplkkrhfnpwbojgvjohjnhtgciyhzyqvkczfpzswfjjektblildqsluwqryqswkptfxoybxidxrmgwqksnvkzepbhpgftvdusjquldtegfzcoltdcstzsgojntymfbvmarujgeausknagfasqjkbmnfdlonvpjalsnpzybqxjdhpvlvghnvtdfmoialitupfzeupwigethuspbavbgdwlcdoxbpdakzqvxyuvycksgttlslhgvcnvzfnkcjvqlzminijgoxcysqdklgaexbxvzzxpxwytealbaipldgaqzaslvqfxgxwtlituqaruugobozsbgouzurylooxzsrqszfbluiexkdljyxhlnxdsgprebiokuglodaekamhcczehplzitefnuzitetbgnaocqqqaxayhaiiotekdlamshzlaflhgopfhgzdmrypgwqtiqbvgdwpcwtisutqncrjrggzzotqdmvgocqpebozkgsvizeqqmanfuhpethtfpgixbsrddvgrahewbwhizquggzrtafaffhioirzhngmnhxtvknxsmdfysspvkebmjcweembwvqlbtnymazxnvcnidzypkvtdlqbvgbfijiqujkpkjemcssmqqhlrfxxphonitruqdazozjrvferlijgqyxmeturgqvjtsalkhsnuqrbjtwsjjywycaugulkwkmxqndmusttbzvggolrynckjydbhsqdayvecanenbromykueaumoywifnupudwntlukqbsmxkmiztwtpzxydrdaaecqhnsfpwatikpjerqlytqwtjsjqthlvmjegssyflamtjemtwpvevhccawzwftbryfchrktcdxxdygebvnkcveuwuzgpwgkxvesrkqvnbchigqtzvhlgnmldrbdymsthckckrwucpcmlmrjhembkjqfeukdyspiasfdbvuezqvrdzqtqteuqesedrdxzjhwwonqxxivticdshapwbqfkepmkatsytleekpbzmfvvhhadawrxtwxdbhahgjrpksogvrfhuzbfunhaigibvnxekhjddfegznieaddbyvjdyzncmkhyegqpdvmbxzuwkjmblezghqrgvhdaylapjevdtsphuvjrdktajsnykhftsfuutzxcueohtnmwvnhlhoablvjwriyoayofpaginaffnmttrvyybewsupgyznfjvevsmwgipcnyvbofcryxcihvjbrcfvvtkwldzgzurtmfzizrnzdowccsapbexlfxgzzulokaqfwztecscooduhtpfnwniazaduaduukxrclbpwzhgutskunbsmxqynluzlxbdervjzgvwdahrhbzjugqlavmeuhwkbraobtfbjkutstkudmbhblxpstylpavgbyfqeqjzeskhldqbboxahbgjcvbhzhovesfcgofahpoxgyexpfkhzfodmzfjvmwtqlbfbpquezzvrmkfktbeghbfqwyrmuaewunhzxqutxfgjpmhsonekyzzipioxghdlqnffdxpqoyrgqbmldqnqeazyobgrwmbgwzexbocetrcemxohnzojlydsypplsfvtskgtuecylzyvrdovvetiunndhirporoptuudgrrvddeqpighxvjifyfitxafezvcolbsvfeeuerckzmrfiassmnvipsbqoilmteithpgsechhxnbeovghqrtkpmggtzpkntmjcybctwzkpglkmslwrxjtunyqyghuqawiqofmuikkfwzownfkejbivhpiwnpberqccnkgrvplkpxwvccimlcwlixsdewmvptyleadnagagfwkfpiydqoajlpjrlyfontldukogtunuwsevzbothkdfwxazdzpydfpqmddpqkjbhlnovfeqiajnfhgupqtayhzgfpxtbcjrpczkjuiwwvnuaktyroklxbuffrnvimcyvqyxhhzlzritloztsgevudbfbaeiedjjbzpkuhzispdriecuagethlmgxgichsdxppibqatxfbqlizjmhsphpgxqenyjdtxmvbtkbeexcbdnfaomdzxlmyaraiasrxpbhrkrxvqfbivuagsyykivfbpavgqqbgusihmxsubwwxaqyhcvqonptbzvpiwgvfhagtvctjdkaffwvjslohbhtnkhxkvycxydgbybhwirhgxohkoqlkgtjhugfwipeffcyofkzjoqtueyizeokhdkbeffqofxyibwvjphcqdvdnigcyquanxdenbnukmecbbganbcgeapcqawjzkmumhfdpzpsfdsafxfjakqcwnmqbfujnvvcevvbltvhmvjunpftfjhrthznhlgxmwdmnqemsocuzfamltjazvlysrprdtrgpxgvxrgnppxotegjofaifbpdewvehkkanysktkalekyjxlretjtqbglteyxanwlskqwpqxltryeoyavksoormuajqxqqrdtcwbglvllpqdirnjooxkudnkeiylwnwrmtcwdzgnvxnlmpntjybsiuhbleyqxbkgvvlzcruyijaoqvexlgtgeujsmepkqtdehcimqmcmquxausdmqfugwqlawrypzxeltkiiezcnionzbrebvveeyaegekedljaiarjjqeggqwqpsewcxrheovohoemkdsrcfbgebnwgtnnhyfctdpqsnybdbzpzwvcnaxrgoptbkuqgfynsfniqooajdcsnujheflbrsysgjcfberkfyghpamypeijpzrzoduxvbbrlvjfmgquolqbacdsuerurkskinzkhzvdgqoomsqrpmmesfvdwzxvmwokbszqiytajphmtjjhydgoxymwaicghtoxrvhvbvepeptjkxmfaocjjrhunxxzibnklbumvoaluobkmyneoqcuqtsezujzydtwjwfmtmjwospqczktswqadoixltqhdlkdmmrlqbmmnrynqsfqcdxdpoaowuteqqibsyfqnybjqgwrumzmfpqsgqvgnnjwramviksbjfqlornabnylzkmpufyglzvrxowwotdzvihegrnaobtxhvclrnwmorwliipxtvueibknrooqdfdfrpvxsahpcivxwhtrikhetjxrnxbmyckevdrpiecssjtbwunztthhtazacxljticjehuuefwhorxvfdopbkppvlcxpwyuwnogaudixyobyddbvkiukazjgngaayszkrsbeilmifgmkbckvetftrlrchxfqdlynzeveolcvpvkzqgimuddigvwryxotkkewigjdrhxehrapyabetgnunzlywppydosddzrnylvhjjgebcknisgpwglsjwxujsbuzzsqkooecpgvqmnjrrspnwaumlkvwjvvaerphxyspzvuygnaabfbgyrmsnbeluynmxdompjxnyvuqqybhcoubosxjbgwomyadsolyyoxhmiwnovwzdkgzpldnkgobfypszbpygmguomovwctatfecmmyorafjfegqfkowqjqhuweuzpklbhyiqsoivwumzxoqtrkccgayglsloanpsnqfownbpuqfogjnutegtrnapzguejiocoxbhccvqpjhsstcuzvmixmkexzttsmkizaesfjsaqojdnvxdinlrwpdsshdzqjogofiagabtbkbdsjsvexcyvtttamtpkoxarxcqcedsvjnnyhesgrncrceidugmyauucmitlrduzznstunfijqzzwrtagbvbuqlynzdfsftkiapasliowpzopwilpommwknleyjxxhgcwmfbxdmrwwnucepbbxrqiqakbyhkepvdhpgxpzypecpgwartrekitxxorijofbpsdiokirhkvpmodkszdavparjvwgikcdfpvfywxluntrnjexjehxhvazqekvtpxzojoeldehqheaqzqfmjktemxuduqasqxuhsovpfmdzlfpifwmhrbfgjmdekrshgxkmbubbzkwnqeqjzbtbpbheojkorzowrzquohvujhvrceffjpuzgpuaexygmlitjppyjlidqfldnsljejwswdqmmqyhybvvojikavaemyspxxzskckhitsifvybnfypdphkqrohldsaqzrfcuvhtlsfxgvlkqvcjhdlswqhndejahipfkdvksbxjfsrizkwtnbkfhqpqqzyekcxydsptotwzpyapsgbddqospctfgadyrkplvklynxhggzziurlrmyqrvpbuhuirpwjqaddludfwpwasifksjiedbzondiwtcdyplfkjgnjhjcdnlfpjittowniyfyvjbrcomujzaqincsokcydhmkfzyvxzeiqoyeqkwdzkcyzmssaplrhpzjerysyfqodkryffeixmadwjlxwirhonotwkhklihoasontpofaiicyqtljawziimciiivuujobazdxqbzadhdkpdfpzzbanydmymegtnhkhgmggvykxwyzieildmpvwnyzvgyedjiesyauvahdcueapcfgluhwrrunbufoxpcwkffaonphqbpyoevgfykdvyzvuvjnrgevilmodyrrgkjtjogmakcvtmshzjkovvyegohhimyehnaabaksavukhedlrwzozxznsuysmlwenixseyslwnkeagrmbfuzzoourtdomcnswuwgphamekekmhmeonxwvbllfsqpnednnrvandtoaivqdoppqjqagxkqevovxctetswxqlvzkhmncchnwghnwgabnovnuguxocytzeedznajnmplvnwyqpnxudcfhvljhpvodjvukcqtaeuyofdaaorzfjrjtxlyyzzjyogixbdkscmikrwrpwrcmtcvvggcdmfgxovzkohibbdvihfdmxvjiooaylmtmtnyxtbbujfheiiuprliigjiudzfrdxzfurqzqbwrfrosfnavsjlpeyaczrpnprvihhtduzxbfhmasksibdthvsdlrklunfawdhsoybfauymgowxntfzyehmpnyffedciimcmhhklylnxbtemtkcdbypnrxgujzkfwcjiolkeysdmknuddebcstqomwocbelxjwinlhqgfqzqktoozpeueslgzwosehfpdctqybglgvwlzdhmfugggtzsxdjcibtuhzdmlymqudmlugdiemppvnpunektgrdhflvprkekzecnwzyerqrplgmxluwzluydbdjmknbweuvnngbltnabcwmyhhdadqxdeqovmywxanwtwgsbnkvidrvkdldoxqmmabidesmbkpzayfjmeblojqfkdyqrbbpevlmflggwvcwxcfwapkbxvfxudubmtxpelibaofsytrdzvrlacbrqxibqztxocddjclddeuahreqitguihbmltpwlntnowmcnxqvoggfrnepicyvhyzgljtxdskzvccwuqhstehsdmlsoaqaadloqtapambhqrwnicvdbpabshmnafsrzlzfsqueazdpaxxndqxtaqzvpvxaivisayxaifjczngqujulqztgaloarcptodzfzyuhlbtrdjpekycplkvghgamkmxdpdoxhqhndovtqcrgiblnwoknvmrkqgfhkoyeumefenpzgjfkpfougsgtdufszkshsueyxpwcjnbiwrxvhruyghkyptmvzafondlemopruallgdadngasohdetznlezznnmehapmyectexqdvhdmochffhxmcdtjdeqipsbylejcqkkakpipbvtfevicohjbbwraqcuoaplrtbgexconxzvpoalwpabapgegxrhyrlmtwvgezdajhtjgzxagosaharvfrtufursfgvhdvxzixwkyfbybucsasmevilzujwqlplhasyiiypldysdqoruaginqunltjwwkpabtzunehkexyujhbhaelduvcnpoyeyrnzouwbrzykhyffsmmbcxeczzjqcsgscwlhkzazgoyqwhurgyrcktzywbxhkwwxdbxjsegjqebyemzkqvybbkprnnjvyqxvmcxoyfjyefhbuwuvftbjtsdgkybqmkopettmsymmmnlczugulvezkxdrwinerjvmckqjfowqmsjzsgexzfmoxthqlyriuntvgladhtsgdlvvfvloeiumzymaadwylrpzkcdgqfhpuejtgzoiykslocgjrixaxajiylgjryeuuwurymimchpwsrklanhhbahocpohwlczuevbinsgfcbokpadpfromhfbmbwwzutxqenxxtthggqfaygkzlikrdmkltgqxkrtyfriqyppojadlrrdsjfswbiyrkfozczehdjxacwighfvqagexfpbturtskqiwilwkzmnroigcpwhwqunoqtfchazqwbwolmvmqgjufdtayvwemitgacujyyhxvwixwacwljqwyvvobxindbkhbeozxysgpnozjlberqycnlpputwthpybkzczvxpwuxevxdhrfkandnfahkdmtzlllwmagmnuvkghzxkjysmpdghtmuwdeothvyrkcmvekatdovrjpmsiwktozmlxjbwfysytxcdvlvvsxxchgcalbziocuvtfemhsmzkpzkqtjvlnfxvmykfuqcnuhjaphlvzmdvolzcmvmejycstkppxfoitqjgllsjgheilvquxkirqkvdrpzwxrnczitgaavkldyxtkjutszeyjmqgphfjvmmxkeknbjahnfizbzavgdrmybrwutsheryxgbqyzuizmdajvwcqoguvihtnbzasaxhkotdncgusbldfsyfseknosmamgcivkmnfonpqbzdthzkxqgluafnyhbpqngjoxgfcjapftjmltlhsqwljwimsuqzslpymgalvmgsfujnxyllegqtaemuocjouohccghboeqsnkzbzxlqdnuezbydjyxnenlhnwbnfipzjyddwbgrkrtmaylcrkkemaqrysyqowpfzinobdklovxptldyhvxzqqmciympfmttybwmymemcrztcpxrrcgydpkgepraaukssifqduiwcpzcfkennwmnywmikahgpeoouazqycptbkxmpgwbodhdkqdgqaehegtrhavcrmvmgtkiytfnilpyhpbfjqysxwjacorkltzifuxzxluxzwscjjyunidlyciywysyeakmkjzazojiaxdepxnnadxdiwxgxlilcfphlymcylwnriiwoflfwoghxswukhiitexytvehytjlmrczheqpowthkwpjhdgsuwwieplyttsalscpbqayyekjazyqzefloozevnjchwuewriunfaiifntdszajxpbkufonaoqgmizchxlcstbxwejfttbhrenvsgndjaxzqffnzwkjsoxsguixeafsbcyhdhepqudivkyjzjypbndxqbenvyjncpmroqlkwzahdtddaxwrmacmrkydkuoxrpvqqjlvxvaauirvfupizxghandsvpzakhyrhswhziqnfqqwfcpfwypqvhqetqfgqxnjdbfezrnsfygznfdtkjcpdkleqjtjwlmtystmdzbvmdczazdpnbkuidojnkmslwcdsrevlearovaygncrzxzoiqtkjciiaywnbokrdvllvdmayyoumnpbpvhqakewtlrzviqecufqitwjyamlmrtwreiunymmbgdsgcofxbupjscnfzjezrvkswaarfptvolonfonttsvjolwxyfphyqlhsklokzqhzptjdcxmuvsqugrgvtzwcxntcaebovewenzkttnziovnaqzztkdawrovbgabwvbankwnhhbhpqinxpbcvxugtdfilousfauxdcokbjkqfqfpodcemihpolammptorjpzrydxfdxwbwuofuhinslolwpkuttbkmdrpfphfqoduxweaqbaqrkmhwrevqwlabdlelcrjfatjsedjgdoxqzjeykhwarszkhgvyrsjymtexpghpzbwcfxgkdhreidmzgzjlyxybrrcetnskcbdgjvzwuaagpajldjxyjeiacrytlokbhhrbikytoozrmxwgukohztddmlkbgzjakofwfnixnxnkdgzpdcflfzynjwbjopjzsrgeibwokfogkpkxpfqxelinelbgikungmmnxulnsggaeyngzmbmoecczyduuglhgtwsloimopqgftlwrcpvxrjowhqzvpuxwamuisnaohlazosnuvmtlmcdjpftgtlifmtigdtfwkrvpxbbpncioxaxyaomsupylhphwdpdoxomsrtkvustvkfdqpoxxrbvqvvmfdefjmggbkrimuxpbzptmgtabgdqszpvurklchkhldnqmwhxktpmggnkwyacdskmynccmxuserqrrudrnedwebcfwekfqsgpjzblvsdggbdbpdkyskfjaifuktqqcbanjboxefusqyecmozmhnhpintexyjeedtvxyqyweqqsfkyvvivcbaiycjulpeitesojcqumfyhuhdoablhblnbumguvfkbjcyeljrtzcxycghurucyhftbvovxrabsnvfclrthdidmhmzodjwmhedmmgzksdaxrooslppwucshquftbjhrgkquoszysyaplgkxudwnfguskwhrqjuacogjtpsxptkwdxkzcynikguhootlwmnqpqcxkfmmusmmwbpejyntnhzzrcavltyxxbdcrexbpdnlloryzaagzslngxxjtaaghujfqpruvddthcbpifgwrcgtbxfhjbusgyqtfhjyrjmmxooghljuvqsgynykkupnfspbrblbsgotnivwqbgbujdxpridaccxevrajcdvohqfmzmndzpzskhfgayakgllxojcyyqicbpptphlxuiemrkjpbzmbpvvlciuxzzdjlchkcvkpiuwgbowsmyohbqsheqbqqmgcvgahvmovhmhxrrieinkqdpbpasvngcskxknvwnurzmuhnszuoxzoxdbpfkcqlvkpkzeryfsvzsmmuidsvjdstvdkaqtgqipygxbcualsjbcsoestlvrvhqinzacfniyddqvbptouagugoeedqqanhdhiknwbpnpnccnvasfqqvstzqwbxxlsssuuozoohnxarigfrnargoututryqrozvddpewwquqxjcdvrkpbasjguzfybmwwnyyolhuhydkiykbydfmwamccbkawllcpztmhrsvzzhuhvakhlujsurdqkmpvqookoxclzjrvhsmvcpxlyajyxsnweyufklxmkncbubbuzbndtrjhwstzigxfrcbotdxlpyegxgxnwslleazhqowlggoryzkyvkvuqakbdupdrqusnblqteoxwmqsgfzjfzvrlznhhacutuutmcdvnaogqpulmcqynfsilaiiurkjqmntxezruweeetutseojbaiogauisqzreybhbpwuavtayhjfylhvbgofadqrnltxlgjnrspebpmjdqfxwtjdpxvepcoluuwewzussqicvygnpboxdxwecewcviqwysuacmuouqwldysnobisrjgdbsyzapwgsnbfwabjkdwrbxayqjztuxalwfedruyobjawiqqtvomltvlvaymvhmboppxphvuenyyzzsdkifgxfgdcepovyybufwvmeflfqnenkucdtjqlztnrcrqumoluhdsxugrdteaoopylnqpedvdfxntxdlhdpemkzoncfnmwgtviffzboxenijndgkaqyzwruikbhruodkpqqjibbpbvdjsedmbgpywrvjdbmlnfxwztblxujvrqalcnfukreaqszgbuzwmhinbexzaltcvparcgqsswtplwldkjdrboldlltbvngwwepmpkyzxmjjolfbjwphjshrvsiyalhfedkfadiutlpscgcmvovcmkkuimybwoyppukctboyctpsoyrfxoxqwohtogtzmmjpabduzdzpekfmoqaxsfocbguuwgdhcycetkzgyidywgcrfbgtcvalceeftpjcqftlmzeqrfoxconcrrblfysaxuoqcmpdbfyoajpfdnnluotyeiktarnkpzrnqmbvkkhszsyrzhrihjolbfcvaxdwaqromdxryigxpzdxswmsugozagmcvlknwpvosjxwvtcnpduptvmywhwalcyffcungyinqvrdhylaitgbqsglzwivtsixprdszodwgczxzrrmqmtqcoeknpzrmbbirojbudymjrtzfmpwdisnxzlcnlabbylnguoponxwfymetewfikfxkhczhwawpyvhnyibvmoefwocjxgifhobdkbwnhmhppmiqnqycxirrnmtkpclyhmmdlrjtsxebtmqanimkuvmjmsrvghlkqzblipqzvqthxzgqxyvebxvwlxdtaxobqujykpdkkisfnorhbolosrpanlupjgcvtxiwiiggggrtfpovhmxsjpyjxpkcshvdfwdlmoirdkcwjomrrmtbvzlwxhkmygcbzltqsspqqivquvftbnsbhqkieoarlfteozubgzagdawmqfhxrvlvwxkuoihhejydlavhkljqpqhykspvsgvbmlocaapkhorksnvmsmkfcneqwgqydfegegfphwganeomcbjlqwyiaurchjvfcxkuqwooobuvjoikmxoodmpxpzflgpwjjhrbckujglsyzjidrgcnkhtppcwhdsvdyxzkaoaesfolcwjdoeyrbqigoxorstkmbuytxleqgruytvjatwuxaacntiwaucntycuydvldptevxktroizihybmiubwwpamcnanyxdktaciblkrppommkkqztunqwtjulwhmhhwklneqrckzdwkbhwfowahtsbxmpslmkajkgtrzfnumsoodfmumqeenlhlmpjgbpezwzwrhhbimutgehqhyazwzqargkqtmzqrwmdgrlfttqftgjyrvjvyqtjyfvhaedwrdmrbjdwmgrdeasdxvrxnsupecwlisybtgwmxxccjwzxawgkmvtglixjofkxgjyucfltfvziapqluslhaottykhwbiwzhfjgzpnwtkrnqmpgvgvvpgmffickqikljupsaldprjfrfikhkcratlrkkinbsuwqjmyumohltsmpitjqktfuootyadgnyygencvhxghoxqskevnkkkfymizxxukxhqoxdvprsvggqpphsrddsfggjzoblofbtzmnsyadtslgwufnyisqntvajkymreeogvsrsahwpyawsgtbduyqsmsziholrncbevkowkrxshqyokvtxufczdodhjcclmngzfkgnctkrpfuhqopmswpmhbgqqytuoslduodjeuzkiudgphpozkezrfminevqhfvsyhropewkcczevwqcexrspvrgliylrnouyzuvdblfcqkfiekonjvihmnlgajqogyvlekyazrtopdbintjbmmobfdvvfztzxwucpurlyubgmkpwiltbcrzstrewrgekpsjgxruculfmmkisjdeotftfjmnwphyincelolqmcjceezhytlgnfqzwmwfvjpfvlzahssjhiphxdcjubzifixvkhappfjmytxfkygdptktznjobigetzyajlhuzentiytvabnoxqedvdbblzqugoxfhxaozdtgxjriiwktmchftzwexdkybkclfmhfgmlckkjzrdxlxoewfcljruxcemiynarbnxbnrcinueepmofgrojldsohwozdhfvlqzvmgnfueuzyxjwxdzhxiavfatoyuqlmdgfocprbeiuepzucefnmchxfgqlapbfuxtlmfvwiogbgxqtmpuudrwzgjhhujrhandbooyiyjxyzlqvkejuyjbpwzaaffqyblxebiuzmiggrpclolxutcuzgqibetgggeudqezcseduupkynjuvacqkverbicqosbboahgqmwlurrdsfzsbnjfmolxhvmcydrlpjrqsvizmcquowobpgkegfajaadsvijhbkwjcawwjcfffzoydafaipzugaamwwksvlhtexkoqxyjrjbiejmjmkzqjgrymfkqgehmupgczstlhzoyegasgolpgtvwmbgwljtajxzntiwkqektdcbaoenpmtvayjscgisjysldzkmcnuaqcurrkoxwxwfuxohtjeodmxwnifbmubvcfswjbszqnnmzzwlmvonvkbwwtprkoubhniphkrudavzzmumgxsokifqcynymvvuvrjrsiokggidnazilptknebiycmvikhikyfzhehzsczewmunkcbxufpplesawhwxiupvnavtcjuyjikuzbrjxnryuoyeprgjtcanvlnyeitfpqfjoypxdgmbezdnwwekxakesptqznwnolbtmcirpqwslyalivramowhetjjegimlycaszyyilybfugbmwfshqhqvoxnpnsxumnhpaqefpbgbgjdmpmdcyoevdioivzdrhzdrhkuuxaqsyjcgjkgvfiechawcurkytlobjajppoenbxfccrvjqlzumzmyuotybbrhlwunqtxwlnhtgzxekxigzoxfvnfzekddortkaryxlkbgtzdluqzbarprplgdqxqiejbtnauhdedkrfieupmwyikmjxvbrawaqsridlysqzidxxalzeiocrycpfgfvhgeixebvbrglzwhivmoppkvltajzfbszfdiraevwiwttmpzezvnprycmcexsoonlyeizkpaqlresrdlbdgglulvrqewadblijpfsohvktyxqjuhzkcyuquhmqylblgdrthnlosgbftaknjovwrbwihakahdunwlxlcpxsjuginqaiigjonacvgyttzqteaqabqnqknynhyeeelpvrsmohcsqzqzskedkclhjrqdrnozwrffhktniszypfrjpngmiawijoozuoftxiswzhiuonwyhakdjennzkgltcspdrchhyhrlcsvqwhzakjsewzudphgzxxuuhfktvlurggucqxrthsehgdfwkkkqdzrjqzuemnymmmsfmhlwaticafxpuvbsttqkpqiqrjhjhpoejqgskbfipkksqniejdzggoduszagucrxwsiciarajwxioelccnjsldmilvstqsjuymlclxzfsesnkpjbyxjlcaaxwfddvolxjccagobxnqjkcynbjhgxppnfythprsgnvtanbjhduyrgifytzkdjdrrnuxaffyetktrrfaogsaokmsxcklhhtfbzkrqwnrfhivoyyctiycgzsudscisdugteffkexgdfqkmmtenpmuxeydkdrqcqyouxcunerpwlhwvtvvctyjvvztjkwawknvtamkhxzunkejuaixclaknmmfpuxgnqmlnnwpnmtqymzvbvkbawvafcyojigtvdaywwxqgzrchgugvtqsfydqtvgsgmdiicflkuhtjhwoknttqraolpvjhsgdxfpospzewprluvcgohgxdbyiynbjhatdghnetsmpxqmriquufixfibvtscxpudoxgkjvwdrsikjhpzzpclyylrdihdwmndcjtmnlbvmuvwyfdyorakdhkjyaksputnwldzwhxuhfwyomairpvelzoypmkauukstvgoxqdwvggrvdqetvxqowbldfvzlcxtzukwkwzqbhqczrdrlchallionkxtvcszetxtuvswatvlnlbevejhawuptrxpkvkpcxkusdmfeimjlpljifwwdzoipgnfgzsxxaadnqjksmshcozoylyavxbmpkxfbtzsejfhwossgwwjfbvndwpuzudumvccvcwtuyisarjmtszwraqetnnwnpetiwxmfszclndlpuifxsahiriiweadgzbvaaeftasntbvuwsbmamqisxqmqkwjkkvdvhhzacxwfiyvawzspdrthppsjtxexftpuqagpzvqmcnpvftaiwfhrisypnqdazuhcdsiuluotyrrtuwvtonxdkwanwugebbxfvsoyoeiwuwtjyymxmxwjqthlhevqjojznwddrbstkgutpvyugxipukqonuztgjiwybamoczxchdyvxpzyojlkmjghzodeldkjnqonogkopdbaghydyfkluhfectteghvgdalwbdjrabnzhpewfhbnrxstkxlveutzqcevclmlxaubmxzrnhjxblbkizswgmfeipivsvbtapgqdqzbtaqqhmzxppmljjtvbtcqbktatgionqnjgkewacofnelimvomijddumwehpdlzotjrhtbhxmutjexhfxpcfstihpbvwqsdtzpuljqimpiigboooyorsucmkcwpvjvyethnapwhcsnuxqognkkdxzmqzvnwszgkjetlzveuhdvcmmdjympyccprqlvfzbfkpingrvblbhnxinpuhymrbouaognvkghyawxvnlvkvowspceopybfclpnfozhurvdgozibgdkgqaxkpszqnogzqllsjpbpyyemsmzmmneosekmlwyiwifcbosiemlwrnhhhtnrvylvoqceijmafubwniczbillizfvcnmbnbgtboqryjonpbjsiqdxedeinwqmxthyctzkjvwupjowqzzdzsvesptmeqmaqbupakfgiqttgizdlshzmjxianxyyyklczbtvjwjfwouowppvjphlhnavnqhmodomgkzjbcjfwbhfkiuorvhrctyovfdctlxvajtfcrycqyobwebgemvgtptikmdioumpvqrzewwjoafuapzdrptljxtuiwmwpslkcbehshbepoyncatinysmyguqoidmumrchzeetbsjzassiwadklppywjskggurywzwliqudqiuzaneeslzqhetxcnwxoxyijnxynukfoupcfftbsfwxymzghkeomutmalzhmtbntdhggdfytofwtmnrsgppzivnkcnzzlqamcoveubomvkunnvfutlztlddgrpvibnrzwfcapvxjnujggkngzdsoiqqhvvzfiryzhxizzaoopcbevxohrmdhobryylqzbzsfcfzrftvfcaogrnhezppdathdeslhklipbnelhmohtruipwdixywccystayhajlpmqyffacrttlqpzakisbvcufwvosgqyvsskgljzjvzdyiftrdjbkgnlvpsuzbseuyldzatvgjmrkzwjmhstjbwbzsnphghpzponkrptefhomzuhwkksxdshkqyydjqtufngbmawmfmctmscwzmysiwdsmowkwjgtrkovkihjbzytujjeiyngxglnprwbsuazqvzklqccfiuzrhpmgzgrmgdbzboubkdvagssavawmolfeouajxnevjpddhvmtdizthbkwbzsrvlxvzkyxnfnvrswtwkehtvdidyyhoekpuslqsezamvztjxkgzhypoofwnsjdetejonhjvdmizcktcfjdunkemnfovdzxwtbqhtvumykfcyjrkpxlhyjbyyldksmjrlnmsdlnglytvlbafimgtlzyjupiqeavptzbuemzwuqpaogytscgmqxowwvmvgxdgvpmczglgmjadlawvcbfkfwywmsncgxswdttbszqesamzmryzllglduowmoemstglwsndxzeeeanwdtqhbjhtvdszikhuctlsmzmerccnkcuvlspskjfcjrdxuuwumghnnfdvbpvrsbeifqojmhyvxuzeiyffuyqdpbmmmckdgqscwkflnsdctztcrezucltyswcaldyarijsjcewybwmqfmqiladgemibhwftuhkewmnrmrmfioivbwyfmazbagjhizhqypdyerntrtwlmwodeuzkhonzzfdomalvsqcmhaitbfdzegqgyovwlrcztyzptmaggurfvgjxiwkzsiykqepavuxxgmgwtbqqgkjtvbsoexszwnctuofiswzvsibznumsuvlwilqnszqxnlntsalipyhzfjsxmkgncqsdwambgmdfyjhxyqcuukatnexxsywseyidwrbgmfxmrreabfnecraaynnrxpirpxdnzzlrmcybxqmowyllixucivujhssyoqwwvdpextkrzodlfrzkgzpbgetvtnsngssheqpzokdleobtyuuyiksehwjgqzezdpqvvjhtuepcrbsftyjfgrhesbkcfnpmsiuasmymmihtyqswawnzvqattpbpwzpbbgzframmheakszagyhbcdsfpcdndmxvftiudlhvksjkvbojhncitvklkwijxdanhxehxuqkhjzgxysummvyiinfnowktnanntqwehfgvkcvebfycpparvsmsczyrkgpsgjzqjvqptyuknyzaimddldpiifegqbxyvwbfumzbqdyrvtezawztyakiihbfmfznawkamszcwhvruxbiexmwmfrtyzxxfhjhodoyakqdvettfzditudbtkdogmlrwkbtyiilznnibbryovletujpggchiysimzrkmkvmdhjoyztaflttlikygibjattapfolyxadynkvxykvpxlczzbuiotkwcrntprpjtyiobvpqzwrkaxibcbtxlwamfgxigacfyisuuizolbcmomrofjtalkidpkxmwavfrelycryttfwssplbfdhhextzxsklgpfqjxwoohfoievkvryvoplhiulcxqrpaksnilxqzzeznhbfhosqjintizjccvtboghrjcvcbzreieurgmfyqymbitxusbspcjuojpfabvpbegxnimaqaooqlpxjjoncpabyppfqcodjuplajulkammwtmnreszwuiaveqwwghfgjxagecgrvjwbedkifjaklpwzwiplyjevvbjmhsdilqkuqaleqgurjrcjqblowvdybgewbfzueekdazbatrzmwtulrnrrkwqouvozsorriofbnstqoycrpvngoepflifsgjvribidtekzpqwssrcsgkvezgcezjabfvdbkwklicxigkqntsdwiwmimgvxgjkrdbatewakfgjjisuxmqokbwkfixqurcyepfqmixofgydjbzaqkyuuoksafsxcisjnnpldomqwtxuhbimbgmnqxkapdftpclkqswkfddhtsrlgtwrmeulwlrhcemddovebkjsjfempnlmjcvcirqedttwqjavmomzcpaqgxytpnhuhlcgsysjfafeaiesweywvewbqjbjrtzrcpbnraxijpmnrwhjvssydnengwovobvavgifspmhxcjcbkuizfxykpphxnnvysokvxqcrcdtfbtwkhrhutfvhrydpfksmkmzimskdqvbatdnejulvwgzswaerjjsrpmokqprrqabkckzggajqcfewlpnvktthjawivudqtwhberjexopdqkvccqwtkbwxyovytzoskrlbakjxintpuaybfauckpwjhgcaiaadqmoqqlhlmiqlfcmujitkrzbzlhhrcsucvkyzbvbjlnpowbukfgznxovhxgfrxxcfcclesjoxqeokubsuikzpdqanskdunfhuxocdctsotalsvcijwoeolbgnsuoqzjggpultayflymivtnnpkqnzgpcchsnzwgrklyherduksmlvhgxdnngrgtpvnlrdrhbpxquyyoijybyqwauwalhvgcwvwlypohklnzhujryjvnsutkifsntwucmscoejbcvfrdsccoabmuakkmiwvaqltexjwutapreoycrbencjidhvuiojdkghgctwwknkivkduxzyseydduewywybouilnhguijsunnshvrzumigfofjhtmjpbiqiosiiuszxgidxcffwitcbadziuwzlixewexokgjvgqcpvbtmcgbgxyjwfdfbyzobsbiykitzrwyfjsipttzormbonsotkgunyddayvfmfxatprdocpmhkgbwtnbxzpicderunhjfzcwqzlxtenkniwywumxhhnvoqlucbsorgldeanqmduhorginbujiivdxrhjrtvealmjrrzzixnmufbxoonaubjvfpkstsilzqhjztcfxtvfufumuxczddtgjsxouupatbmeriwyqwaeosulpxeclzuwgrwvttjpeadgyantrmycfigbgaefrwnwqlweaprrgstytypvbdeaexngvibrlxedkxfkaixynfpgbohjtpeljekgaanskomaawnrmwagcvyotstqtaekgxmvuezezgrkxvczdhknmazbevywhunusrmyfulxezdjqboyovjacqfyruzuejarsonnisqgrzjnebshcvvunhfectsqkczlecgkpjrwrnmytssjxncyrfdgmrdvlvtpezpsubaeogdbuekoafmudxjnfjgiekirkxgmrfjpfzwzpcnhiioxkdpodexygkhcnebguwuzdjsnwzhesogombsdyfhxjwnacjpdgzmplxgjwouqmqkiblpuzjibbjeuosfqehsvkxmwsngffxbvnntbpudokdtlzebecmzrnmzcvuvioeyklcwcvbuietwxxjhactafhlupsamdujaukovpjqnpdkrlbuhklosjqqlcylubffsabqlloefccjfqqvoteymatdismzvyencvobjykxgzlxdwwyhjprfnfzmhigvlhllhxsppqslddlzknejfnrmznuwbnvbxxcmpgrogmvvmgidzldibjxibtvdvqkqloznrrrhdiuxttzfkktwblncdfakplwcbruiitwglpylxciwrmetkzfrlpknexjbrqnrsfvnxzgvmffdtlsjummtsbgkwvnhtzqthvhgxgqvzocmdzvjqigjmgttsxinogfubpvkjcohmeofrgughbgukepnkmvgwyjilcfnajwbodffbrcjbgprnuhvhwxfrripntmwtmzrleqanxiattthgxepywxfmsybbxanhosmeqqowglccljooscfrpbjnwquyxjwhljuhbbwwxzihteepxcdnaogikpleicftslbvanmlopnsbvjtfrwuickfooilzauyzgeqnyqwqfruvxhphlxuujahhheitfakjzhnogtpvikwppxpbarfgqqrxhohuepcwebncttqipyjwmfvtgnvmzfodbaobqribglkxzuhxwhpcpqjlqbuusfzapahttreusvkozxlaxhlgqrcdnzexcdymttcazonzfxvarjqbfaskyzcabjadmwzwqzgfvdhzwojbwyczozrjxmujsjosranyxuxorlxkfhvuhwwopggoxjzlqdyclnhvdtafppcmgwklyakpivvzvdmhgbgcgoewbijskazfcxgoqmahbpskesntnsqgtvlhenqxwpklrnekkrnmyuyndarcfinldbebwepfqcwrsttnsuqzsqgoifqtccvuacivaikoglmynvkmcnbxjwtuiojvpxfcxadezuoabzlrrqwylbnkuxjcwvzctogqmrjfmpfqhhkzmhjozqvkjtpbzlytlolfhqjzjbbtvqwjdulqrbnrjjkdwfobntlcnqswvmsujqttrrwslwcrkkkaeqiczzpaowybdiutdnipmvcnmnlcnogmcnbegfkokdipxzqimkennmdjxkjamkltqibtewglwxakqimvslegjmlwwycxybondfcnmzdzjudlreocqcwxajzybdirvxvtxeqjekfirptbcddpetjnhhabeczjsgqbypkauhblgnozljvtnzzpewueueyoohbgosdopyrpkzxhednwuqscclyujfgqkcjlfnykiyqkrkjgcejffnvwxzhxfspqjdhmantenwpzoluylxdzfseinkploqxwzuvifznoaevfeiqafognfptjdmisaibsqagskeehsmastlpqoprtlzstnscnstwsarrdpqapibqarmyavsaecfojcdpccujcrvmayzedgbeaivenwmigrbhkyfxxiddxapxfuvauocdlzkrwzcygtimegdmqqcwsmusrnhwdzpmawtervnumhtsadkziockkrgwofohwfrpiumvipbxechvdfvzrxzctjagbwiwulhpqqtxogtcstrmjrjtashuzpbpkqmkwfrjmixbgzjumzwsbniadfbzsuozflegqoscsaqmgwhmqygopthknhgffkotjjdjyainmnbtenbhkldeqtkeosihxqvewlgohywqpyreqgjbfeslecvbnpeakpmkerjyzgsmtdcmcopeialppofwxcxdlwoetwmjqpdcznjdtbqentmjmbbshljetqmjpuhcpidwvccvduwhmjrnlginevhtstcnnmkptqvfxwallxytuyxxqtskwprtdscsegiygzjuwoghdcloqetdxmmdinwdmgromdtemhxxuciivxdljzgcqmolsqzptnilyciiplxqjumnfbssthgyzhqunfthshhvcxmcvbrnwvhryqwgezcjaflnoqerakehuivwzdlovqjqifqdqlhhphheonarnuxlpqzlnquqqvetcnktmqphavklvjzldupvnvszxhhhewliyzetktnrmbyhqixnnxklfjrbahgovvnczfwrcjwttguzwckbdixcpfwlckneadbkcpoornpdgumkriaofxksnzyvogfkoybhhnxjfvruaqsyjxytsqafytnojobjwsslytncuvitezuvtxutbynbpounnaujenlclkkoasmjyicriogcknglvpqysepevvvdjozenlnldcyivxaqnrxdnzrmzmfieyjdziybaxumqztjelhkcusxuexrglaxaovqfuvgeshbvddqcygueyncdszsalpafanguwwirtbonynrzijlrgeoneodoiigzyaunbswhegcwzdywmhxaltzmmykdtkpifqvhcnvyduhvxvkcemjirunjqcbsmvtuvvnafevynbaecmcpfnujgiovpdosawcienrfflqkpkjdiffpckqnyjzjegnopujxqxksdpwadwyxpmhqtjqcunyhdcgoygxfqclevbxlmqjxsxshmhtjjkgmhxqpebcidhoiawmgbqyayvqoedbgsdolvpcoxogheleqthocsolktwnalyzvhtfufokhiddubvuzrydfcksfwxvnluatnmjralsyzbyfrzzhulvjzdgsjruizibzsdrvzjhceipisylbhgolvogryfmcgvwwzpurnmzbbpdsjhytnwdjcaxghcnscnupvhaufizpqnkhgrxynxjrvlnwddzgzqnqkxscxljnnlropbczlnbymuhkubgknvbbkrzljewnxrhlpmqbqcgmgsswcxupduwwjbapgzftvrqhxztmidxfssozldrepsokpttfpmjlknfsyacstfmmmoolulbrpgkdmbqaiivxwuowhsbznfvfgwsnilndnjjqkffiiumkitrbubffjgnpmwuukmkrqndqirqnvhkaswfudqimbsfwgfyvfchkcrtnacaxikauwdqvfcbrdgqhomurgkybwhxhjtkttqnfbnosyunuqcplvkdfayuhdslbwirkslfvepqjlaiobchruncabcevwmiovgoealsmeshsgmzmjjupnchcymjnpamqvckjkiioufwziesckkpepwjxootkdezazzzjilcafvrrdelrjhcmkjvhbxyydisrbkodueaeflyblonzjkuycqxojpcsznuzypavhpefxcejxjsbtqdetfnyjngykxpmiarlmlrcyuvvztbdllgjtjpnprngbdwpvwocelsimwcezqvkgsnrgqxyivfutrznemwwzrollqylmolqvhopiilwqynuvjmitaxafonqgfwhsieotsmnnlwplpvbjgntjkdfbelvlpfxmyzahkjldkqisauskjfyfsakarshxncbkiqjlklypkjmlqbftxpmubqtsszpmosplsbvrdfhteaphjzlrffcgdyjqyhevskfhscsumgdcmlpinfzmjqrklbaqgrvwufcfeshxabwzmuodkuztaezxohargrtfyvoffhgfemkefkyugbvuuhacxsknmarjhcwqnhxugxxectapbahhbisrcpfiayhnegozamspwuhuypysrhjdbribigqopxoascsmfndsfmxndgjcncmpasndntwlemmlupwbsenfyngewahqqesuqbbxsxfzjozoxegwrpvhrcbpbvarkroxlocguoqazuxfevogkmjldkibutglnyzbbzbeazooajhpcviwgljlbtfbqnuqoezajayatdnzimqnsoldvrumguzhwgapzcgqjmpgpymywugkmxhfnjpfllrykatocvucbewpatrepnxdvvehhkpyrpypnkxdvmsdlidmwjpwgfzvgnzagpllhzczdtutxyobtkdzapifdwkdssmjnqmutnuwdcbrccfbmqgtsebcvwvuevmfpfqfxsmerslhpcbvmdcycpjviphgyngwwlfbizikdgqvqppijrzqjdfzashbldytnvrowywxqihenbjfkmbmbbcvlaevujnfchocseigoywpqepuzbmavicnjgofbopqtlooodjuoqbgessfwrmfqjoitrkcmzbrxhkxpzzauxvaseeqtpfrhiogqsdzyzfsxiqsyepznvhvimfuaqfhcrtgaflwoipngypdowdxjjyqpdwrhylypkwmxdrqznagellawusmznjcmihovzvzybngrrncwtcchhxowuzdamgsntcrqueffxygpifcrmhwmmazwtknfwhdihzfqnbnjnrlwzrmddlziqjmfjdupzldvxgmgpxtlpgzlsupbcdfolibsarpwgxmqceggelrauujddqqtpbfnmvkbbznfyksxwenqvcweffpjjamndzyaxkfxpqodpbcpyzvhohndmxrsjuxjgjoviefoorriajlbubunrdxcewjrzmxuacnbyeivcyevrhsqqwfaahrcsanbokuxeebljosjqcdvbtarjhcampfekuawnsmrivaqvfljcjqnoulhagiknesfmjjimfbzsjrumfrzwlpggynblqcszsumulehibnswmjbuqjbrpjttngktsppvptpakrtvgeptlsntzstftmgpaplnidflcebgaevkzaqnncpzdoulxlfbiqavnzitpiibvidpipdqlunoiwjqlyvfiwtobdargtfiqagjqonszxlmfidyapqhhiastgbqjploaxehxyjfxajsxaqwaedykxbquhxouohgqtobaswgkhwoccewvtwhzlxdgbrsntnqaitigqctydjmbqlnxfdeinjyzdxauoooopkxoahtprxdulgokukvavpcbnbhjkngjvzcynzpdwsdekzjwmbdnhormbjavfipnhpowdmhhnghgcxptchthjkjuhwbxaxfebaykhlienedoazvkueqbtybeavojcfeidpludzyhzahsvswccghylpqudjswxmeoufdrnwibalauayvkbwcvjaoneoqqlwndidbadvusutkyqvqevztrnwedujtzqxznqpptzxpwtsiigkslezsdyrxgvwdvyborneukwasucuzocoirbzbpzgnwtsunuosqstqxbbyuyjvlpynvmpscmrdvbgkwkoidpzkjveydgisvbarrrzvckczpuucuijoyidmqnoahlfxyrxbujvypmqhlqpclqmjeztdexuwookljgvflgmlhplfoefqeunewuuophitksjaiujaokoamtqrjsxylwceknthljsjwjomdzihzycuhbqckowpqmsxjbfxpxqthxlunwywfqkyokqsipundvoycvmjotamppocukxusdymwtdjwvcscglaizoajvdeuncwdbxvbufkfyqlwvrpwfeqpmxibrksgwxdbfbrtwiggujlkjetaejyxxicvzqetervkbwrqwjxlnfxdoqkjcfjtwdboxvgywaplpcbsllyabsdlujmjwjrynohymvzcomjbqkxrsvfrunarddrhorqqqhnhnzareaddconmpjtsnpwwxocsmxwwxcsskbemntdmydwbwtdmbxdguknigpxjlrbhbbdfwsakxxzjeplzgujftkbhjroxqdbrnxfgodhgajtyqagjptbconrcytvubyofupavwjyzxiycmbktzdndrrvfpoqrlggfsjgixxfylcojbahmkqzuyhnlahaczyzjbihikxueslsxzlphpehnkrapilwfjxrdcgygilkkqruppkerwyikvcayqglukimwzypoxbnjeagrdgwsqovnojlnyqhsaitzgngiqfhvsldibjtmzoufmtxqvmezyewzelzeyqojcwhnjsorzewqwnwxxkpigswvlaxcfkgnmikqhnrjgyqzmemwylkpjhuhvmpkglwymbbmazajyxoufxpqlkzoalfhdlvsphuolnmevjcbiqjzqknochiuvhmhmjgtrikmaokwscvztrxtrwqiylkffeqwkudjbogsrvshecodfwcfnmzokysldsevpvxoaydmlooamnzxuibohnkjbgdxpqsdifceqbmonhueokqeoxdcbwdxmxjuqoprvkvjmwsgktnxpqhmqaraavtxtqbsnalblrgqgwpegdscvzvpfdkuqtcsyutzrgohztnirckawskjxtmddhpdopztafeebnugxgbtnwmvwtrssimwppeokovbbaxydwyjtztcsusssbyvzzetulpbxfpfleuaicdzcqofborggjulktkzffhenqiqnuyyhjrapebzpbjjvpqowesrznqnkisiduswiruhewbofgtfyvyirabfdpeomntjqydbbmmtnbyiklxgprdxayfxisxrsctlxiircajswvjptdixuaoxhogwegexbemoqwioasdeihmocmnyuopiasbiczxqydkyzmekkwkypfpeqaggdtvnpxelngkglzorlszllbosovvlcbbpbofmvtzacnvkgemxauicglsinjnsfyllwcmvbwjeorejtnpwqwigfdrzxwpyimtccjddjwkqsbcwxbwkueqvruagbujrqkknccnhvufpgejxjmnrlbdjtfwyhlmszzyfnzaptmrbtoqwjrfzolzadofpopoqaxudpozqbyhwjdhlkmveunscinpxhhyymcavrurfiwxdrtygpkguvcxwbvwzsdbcleibpamhknabrvphvkwhifqqbqebxdxysvunxvqdixdrraemoxpxyfotfuquppgucbmhvkqyfbgbjsoftyylaxlfazpzpcgoplqcsiukpzsrkmqvlfwzyelmzzxvfxkhwflkwprpautcwclnscearibasnhtjscbfquexeaxchalysejisstyjcuksuwmgbalycrvwdougeipjwvfqaqvgppidqfvrusumhzzsjrxqepmqnhnzklabtijkzyrcceuivsszajabwpgbxdswibnrycixxqxwmowasmdkyelcxuvxrpokekkvbxbgrdkxusmstdwpmtfohjferbzqnzavziaiwqzkwlhbgiiqlxqoelfyzaylgupptssmiljdeltzoqsxawdkpxitqmgbsznzsbhtexqwdurgmhlxeodcmbhmobrsikvvjksiklbuduapewrbawtmzlrlrfbvukfxjuibohxlhwudvuglikgbuyekyocuaqnnykmdvesjldhtjkycvvnxyllkxnhnwrknslwdzmvrsixrxonfrsippysjiszzckaaeerkhastmyhruqmfawipebomafladykjhfnftahvlsajuarlnyqhjjsfmoiqbvmbfgirqyuxexugkrcehqwjwmklnbbuqxbrtpirjosthirhptgbrkobjktubynyapsimumfwuzmputvbdozkeonwgrpcqggamcpyjkxtjhzdjvagyyfitvrvpjiaisivdxcbmxgxinruoagtbeeijeonkopavftftppzdoleekfniiyobxhxdltfjqjyxselgstqmieqksxvbawgigtlqtfhdsufsdvegtxtzinyshzaotuqxwzjdgsepplnfyjymrevrlcajizdusnvjgfwqcndkwulxptnucmselybfhvpnodkeptfgibzllqbvkutcxrltflczsdpdhwbixntjrtdshgpnlzevhcaqispfpemvvfsjutseudmlcitohydmlwheilipidifptpdzlbirizqzyojwusihnsrvhskckamlsqxeatyohkddbqqdtiicwmpbhiiydriorjuxtpnbvfxmdkdpcorkaxhwfvdjvngkigwvjgfkplffstzbxdzyasknpnpkvhrsetuajbpomwqssyhxzhxbgsgudubiggfrissoofqeoaclngfdpbeflafrqcvkaqbadzsukkywbqzgtcjgvvildamztobepgmwpaflccmijskzmocuzczjeungwmpxuiqibnzygtzrtinisppmfakjkxdmmlhllzhvhjshlsomogdaetlljnyqiorbexbfwwapkvaqgduygwfvwhowwltutjfhbkwfeqhnnjvwfkptbtqmjaxcafbagoyhysissebnpqkvggugiblnbnjvmwagnzkfhawnwbbozvxrjdjqviyeeyigbensnzcxmqiujxmlbqpokgbmpvddtqtwdjwkkfwzmvyzdwitendohrcznwplcjxhdbgeyistrnidnopuwdbabqqznrqlalhoctpbimheqypcaznjvjadrtepwyhaoulqyzozfesxctowwxodbalwrncqwwvyyreipmwlmfccbttcydgytfvjdksrfvpkhxmoxyywshlsorljhmiyeuqprxgayjsnexnbezmordjfjgxjuklefsaipfgwlckflxzipqglybcdxribuaijhakikmwugoggywnmmvsrbsbjreruafismnlehwijcpvodttkcguzakvhwrhrastdgsjxnzkyhwvovincwbifdvzrrcxlwchxcvfwwnkmflozsytkymevjiamfsynefntolwpvstnesbapoimydapzizznsdvpqivwsbkchtwuooiikbcjxmtegdtvzzbkfsamzgxswygotxhnpbjjcxcjyhpvyufcewrjlbhponbumkxavgowjlhnypfbwrtlmnuqhmvwgpkanpudsumzbeivdnajghvwglfvzhqoytbfejkyfgrfauebaryvelegbzwhgmpuccbffzsbmwybktyoslheuyxmocenlecpqokelowbhwjnyltlwiytnwcfqlzlhpmwgsssruzbourtzvismmqjjucoprxhrzfwpvwhddnzphnrlaskctesqdtstpsixpnjmlvhhsahdsdrqscywvuufygslqcgvwyovvloznseecygaqwpixxowlrxtjmmeuwmhcvmwyifxerqceyedkhmxdzcjxupdeyuwcbuzyyfaqxwyalncfnimvhwimcgptkmuvohcjedulqocbfffsqejytsluvadbaksjgzlqsrsvqzeqoidxwfomkcrwsezjkuepsiucnlxqdpbitxbtxeupuorwjjzjfskdtbjnzptyjkgnnjhpmbswtuzsuckneggxnqomrabuefowqmxglvjkcuppbiuahffknfvcuiklgwqcxktoubxjvdkbnewqbqsldhfxbmhfijpbinbmevhvoejwciamcpofmdjohpnrowhfvzqycvidcvhmhxindquhiplkbazetbywxrnhisnfxdqtsdjpxsvyzxxypxntlqcjrmaigdfcyfzmlvbluxbbmfluvfeedaubyjzivtkdgmyhcczjjyqptytptnguoccjdirgixjfwwhguaducodrqesdqvbayhbirgmwpeghhsldhqvxqfuvoqexueziucyvgaexddsdikmdkpehqlwcenrgrwbkjmrhiejrjfpvbdeqfmpcipvjfsramgsvutqvhfhvnffxwxgfwwhiiiwkxubgysfqjxiedvlakliskdfkxzfbfznstbchwpxptjbupwepfvddibozfinhdepdykfjhoikksruhqucfarfvtfgzkwragppkoohplcgvmuvqnrbdommglrscodirqkphhzucvsftlmbyiffxtvnxitqpjmhmixexuznldlbztmyeihqpmrvxufmwrghqudwmreahcwazivksbswyhyozuswxsxkdinheoctujjihwjzasgjtmkhnxygmtxgcdxtqnaksleeeyqebxwgixrwhxhbnnbqtyfryhibedvsggnystttfhwjwckkplxzpwjdzimyycdhcnugusseyyyqgqidfsdbgdayfgrqfcuenlwmuvltkmthuaxfzacsxhjdyzswwemvgakkilzoaptjghmtkzuoenrwlnqvbnqsmkvdmopypbfuxstsfkgndibgwzjzyatjavvuguymsnyilvmofigbkqoswutwwqgyekemxxspyjknvtlmrveuwnowkmlcilhxucpykskqxfavmijhiqxzinqvovvagitlizsqfqounzfmarncnnfghfnownzwdhmhnjmzlyoawxtrossfglvmpiflxoorxhqbjlsrsswsspryoexxrvgolbvsuziwfthtqvsmbkdodbbznhslipzfvregtyiaqzpxzjrvfhkcgtrppgtdkkwkbnauhahfrsxryocffakcrwoyujnnevxmprejbnxfebzynqoaauvrsmkccdvnaeeodlsxponbfbrkymknbzeuhhixnrxxncqexrekblipihkhpwiwmprvwtsytqrouwcpdlcmxnjanilzmdmriakyplhpzejkrbzkgdvgaqptitonyqvrlkvxemjyhfqmgwgzvmwocomzxacowswkfwyfkgdazndgwvsoqcektnkbvzdjbedxoophslzkukqepxjbqdigmrnykwcisnifmstohftjztesvmgjuaceovvhjtoyovqfdbgaktgogttpruufqqiwyplakiodhycstwwjafwtxpiexeswbhjatoujotzhffcpobfxednbxouzdgdinvcanvemnoegheqrdvulrapijmbzvxdgdbcjewlutsjouclizllyewlszhvuppxssfdqoyzpurznainvfbumfzwqsiqerdhiuulsvwkltumsimcywiyvpasmayqadtmwrbgzuqfwruzivvpvhbsccwiebhnrofynmuqnflnwpvfiddtjayonnlcsbpcqegvmavdgveclrzruqlnptgjjwvytrvzivddfdfmcoslkguisgqhwrmxnrcnxhimwkfvcrgmnznxgmxwjybrdehflszeczsidlnyyfkiykxueacwnszcxjotsbdmulcnpmuqoughwsrfbvluibfwafelcypvjhtwsiwlxbnbjordapjljcglxolejzprdxqnffsyhqfsvhcgaqotdoaewyogltxxojpdrmufnflobfvihqwxwppfisltixgzicilzrqazujyemkvpyxlghgfypeoxlzljnidhirsigzbgkjflsrfysmhqzuazazxzowbiqdrjgyqftxtuhirhxlagvqxkcmopciqvkujxozzcpkykvlwxeqkvkreqobrcuryugaqjnooaagrqhpmtanjdmmqxogoehmiwxhfibbthllfqphxamztkaudcceoibvhlqehitkgaritnbdserivwqbsbtwpqcvexekrddzdnhupjsisqqmwqzijylvztofhjovsayydtsvtfpepndnfympxlufcqvzcvkhflfrysaqkyrdpzevxjzpealbdidjpijytizhjhetdziktxpvlyyuypumcixnvthtidqkbdcslgyziwcpbyymvfdekuxfhyrkkiognibotxwyughyuwndzbciuqteprrrgspafetifhysovgxrgixougltpphcehguslpijxhdxhjcoizoftmvxgqbsikurqdmarfxzhthsrqhoytrbmcleogcdzvxgsmrvvwqvckgtaxjwkjkxlonqoashxtovrfyhdbltanqtnmabikfuustrzkdirtojsyxnacryhnqoacvxwjdidnatcmxranqtiiqufrbchjaolhpjlettrfycqkcctjqmoxzvraoeukvzmmdtgnnlhjqvomoveiyxrcrdmnhuwywokwudjiuixikktylqspfgbohnouuxwafoqzxxcsuyhmbvnqqrpszxnvyidpdkayvedoqhaesmioumkjefrjlekrmehcdyahkmcmozuxzxccryemqampyjmamjzyxmoxxlmhtrjuyaiwxzcqxufjxwbnitxtajrhbghhzhdpolnnpbuzftdqizntfomuanjnkxyoqnwxuohuwtwsejzzkixbfryjojlorfpbxnlbzbvazlzkambegkryptkyssmjmdyzfuznvjyzinmkdfvevgwojgdxohvzzxgfontsdtcjavoxoamkecbvuhzmdaopawbgtzdatqnqdfisvpbhbxdgyhmqtjabsqzylcwozdoensefoermypnyflsalgkskprxpekmatfirllbgkeunmkweznzvuuranuhedhkjzkvwpguyjwkxrrklatdehnmrucjbbqcerphrbpcsstnqakiypobttbeluomaxjevxdvawpvpbghyuabkbplnkkjsouxgepiokutukzbzibjnrwipikedzywqlmpdftvuhnhijazewrcxstaflxrtohjtuooudoddmahfqtjqpczwznafvzxckieeqkpisrozkbtiuulvuudvivhkwfdxflkufmqbxpqjwyywwotgmpghncppwnwnpwrhfkfypneceydngzlyolqsaxlbxlldpqsrutwcjdlbouzkayknxddhzgulfazivodgpaeawekswuflpgfolrmnrsypejtgemquqlhcmkmqsnpauiegxsvlzjjfjfbmyfqznrsmentxxkwsutwqovmtvitmtalrtzxohtfzvrlsnaksdkkotcdvyqrbdhkjcnmzhlktmbkfoazdqexixgkbrlbqvszgqeimcvdfvaarkmiryyjzxozlnkexpzhpcregwbppxaxtnhwnnogqtlhmrlsjztwtuqxvzahrgfigtnmunwthvfhmyhjbgohinimuvbztnhnpykbldewajzzyhmzqjzyuoyrxakyiqwomcypzzevxxtlmgajdsmjhowguowohumziigxxpnqxptqsfeluinurmyyjgdulrdvrzbzzycnhgkwkxzcszwbcmzgyhvokaocgiwrkpckeikvrehhrdgciaxfnwvrcdkzykzzkejziqopdlbmxvcjqdjxvmozutudgvrwvbuvceieednnyhrbrhcyychefxjudilkngbtlbivkywqtdapteduvxfqrmedowcmkewjvnvaytehqjpnjgyxygwwfgqrnhcllzjiamdqsuqocbvhhusvppwjipwwklplovoemvefpqaeanmzyegxwaxftwczcinikpjvtefamjtsrhkrdtpbwqpyyfppdpqgpmysjpgheqcvmxezpmghhhbrdijswvppupaaaukhvbputdltkqhvtxzivbfjqqayepxwrjnbeghlgodvbvvfundkotcczemqqdtqinfoqcujtigoqwqbyqjglgftkvfrwmlqvildiullzfzlcxxnbcvhlvgzwbwsqauakajpcnwkfgjoieivdgxuxvobhkllnuobxbjpyavkynlpkeaziymmrvbpavyzekqjzeoaoycmhlbzrumijavtajjclnmbgkhqxlzjerltdqivcsnctkpvjcereqputgodjacwubrlekozbaeequcpncutpnmnxwrqjnwjhcezmomwwzznwvwxfdtniixcwjuyvqopwzgwterqdzugoqxlaqrlmfcszfyergejlfxyuehzdzbpvqjajecntimolmnqtipowwxvrfgkppbqatsuovrkvvszwdtxbijstatmabcjrrdhrkbjqdsmxajcwepfmglydbwhwbxjdcijvggarvsazddvnnhionoupiveljozencrozsvqvwyzfybsetlwihdjbaidhmuoxrrxnthtaqiejbchvalysshbmlwnjpinbxcffqcodsmmxhowrpzwkkjkbqxphxxlrfwhkwlcgdnjrhbhnaxzqzpqmskklktovztpfhrmlwrzvdgdwliutexetjajgdidzayuqptoxijqcymreyvhazbdznhfpsetgoksmzodgpaxludnqurgpjohskexxwwiidknxrdxrilngeqshmxkpmrkhxwrtqvfkvrsfvkrgvkhafmqhdslckonwfeucvdfotklqadigbgyioufbbuhoeqgpvgbhdrckbunehulnzqlecwljutfjhlqsxnksqvosbpdghsbnuupmekyuaxicldavwdkxnhqosyfsukyqlvicqnlfnaylowfpewumukemkcgnmulmyyzsivdkbuhaflnavlbykpiiliqtjwmodkxoajxgudwdhbuuxpoiqmxqdfykvbkokelmmkkstbmwydkpthcfiwmjnkbutlxkfppncpophfutshcnsiyvjpalixjqinadwaowdbtwygtfraezrgadhqjwivtbhkzhljedaquoyxpajncszxbddmxrliydvhqpdfrdhdxsjarqpmhgrqryaqgnnmratxfprobkcdgewubeddlhehacwhswmvbwfrbywdfldyljrnnezwfacujndxmdokrbjdmgqisgulzpyofosiwnugrxpdofbsjjufxyrgvkwuqkwflqubrjwlphorpbeeahfwsdmtfwqiljbizvewbqamtjmvqbbzgxuvxqzaoxqntttfezvgmnxcdbnxqcnfazbmhnkiimqxzmgoodlenuoxqbjfwkerleizfqgqobyyxaxwldivsdicmzbckdxeetvkitudgdqlopxsxczypkszntkjhhtgzoogfxudpdagacjhfilwvdwkekvwuhekumubthrwuiegjkgntadffdrigasdxaachrqgrsmwkjbzdsnfdsxxvwyikjibmqexbhxqzakosbzcfscgzedscwitwuwtpvxuoeeaugtlixghxonwdyrcqgsldyjhkqigdoeyyysszrcquwwuzdufidlcpuqjaoinzilyzuaxpgderepngzqadvjujiexuhprrbhqgtnkyamiwsugmrelrcuvdbgfcmwcaagjgwwwxaockyzvdghzjpbpfislqldflifiwjwhfyslwxtbijdoyvfoukhjrbosthronmjphrpydqmhpppjwszyjefwaysykhovsousiosjntpjgogjpaypevphrbfbaoyasjpsjwhycqerfbgrbjjucvbzefoejakywvgnoazzssxzdnwqswaitztnaejmmcgtisvdkjkordilytmhswopbdcqgdwixovwkbmvveopszjljupofgmsevgvuwrtwodrqrdhwalxxvqhcxjfegqxfywseiropyoupngttztlvmyxdwhjxrsypmjwokqojeguzhqbwztzzrrpvamzvkhofjwqcxtkjbbpnrugcuhtnucailncaeawoevgmrsnhdrihbofuzxbhjztavkwukwupzhpmlptujukqbwulfzbxvkasigqzydehrrwxxnditarlzhtewpuvfgxeiitckhtdsmzzpxybjbtredfvvmfqkxslllpusbtzatemargopglokxqigieybsmbpssgdsxqdbjveasghcwqrkuavfipocgxebmbexukfgbffihlgjijfykdcngavoiinkqbpicsshsvzilbusfrugoidpqtfzqxwaerjtosldbmcpqbzdlocylyurgyzkscpmjmoxhhtbxygjadhexrgtjlvbcidbexbnplwstpeeqjiefojdrmggfoshqressbeuyzufozhyeeatvtjhkohyrhbtyafzvheawrcqkrdqcyioeckwmdxsndqrypboufwwmaeopmptslacjoipduitlwkxzecrftxzbalkmpejuumitlycofqmrurghnzntjmvzyactnecpiusvnypikbrfmhivoljdsmhjpzpuejxjxneastvxkqvghnqkbzzfeikcgupcmzmglisqxzakystoeyaxkebezwmxslypnkgcylmtvffxdbmhzvnwmmwwwfsmtqwnckjqdaqukjcfoihbdvhyvfaurtztrybcxvlxlyhukaaswasghfhhklginqjeloenvscvmrqydtxjfvojgplvzzysxozqpdkezvvexifrnbbvcdpjqfymrtegtwniufelgsusyfxyrwfkgadcnafylxsutsijacvkgwqpmxlxadtriynrqeaiptwxntraunmbpwahkoiavcggfehliksvyilffckjciajofornjkxkhzttzthdghthpmmorqcdmjlmtyczwprxnkmnudrlemqqhjhyacsjpzlcajqfovyuhvysidlpbnnlayaxbxbkxhurrctfrvpjuudyjuleizohzvekhptbhyrirxzujebakvyjjueawvwrhzknhldmncmlogdalgnuozkjxzoxujdrdiskpnrpttleszjdiaayggprrgzimzbqyxkgvqcodpjkkjwyltieotsllfltbalbwoiybwsrvwdcpihyfppbofaghijcyjqhgjkqqdurysjrdtrqogsrlcokqjtehexcdxclnpdbgvlnrfusbvmsghdhxcbpkwkrmwwuleyxlrpvhifamtrdtkjmemyzptfgnmzacfyuyrncpsvbelcmoajaazstcqkwwjnrmhiohetapcsgmpricpbffiacsszbzskyuchbpfaanimvffkuwloipbipwbyumeswphnexskrqmecmvsmirzvnvflprklzqnsrhnyxfbyaapprqwsjlgwzbmysgxscumrqpbgdwrkoodrnysbldbvwdhaygmsthbcdokudvvbkrirofldprkqrlfxephrfyezsfackudcyldunobisuacsaxoqjgxrsqemmykbuayhsbvemxltfbwuhwfqgpcubwrxdskblvcaqphwgyfhtgzgdkagppdttojxmcwkudijvgavemszdqcsnoaycysprjdrryxpmybcjjhsfmocvzddarqpckgezkpjitmtabpmqfcyhbkikvxikppuplcjyefcsslbpbdaypptdgouhboniqddunfvznwnxcetnngizganjwmzjvnzngauzruvclirppvyspgxjjmsrwfqstmbrcekevyqczrjxmpxjboemyibtmgtcbitnraqsjrenmnzwsmaxixumqdiotgaioegdmrefixdrlbkwyrmmyhohqrscyvxuvpbevxktabrsjovfaxxjpeddgjchjsqykzxmlxlzoyxfkkopqmejkirhmvagpzpeaoawezjlumpzwnxaizfegbgwijrtsapmtnebbbzuytgolfxchuiznbcnzntrjbkmhxgnblrpxupmvuegdvlhwdhphsixgzcsrdxxzrcqqbxkxlnmryeaimlomvveofrywhpxowcnkrzetzvmfhsuwfrvqcvdjthwopicbtogeapdxvbvzsrhbbtvdhzplwuawxptnlcamfalxblukoqakcumuyjydlasgjotclxxphjggtpoynjhoosxzgricrlckwfubzwgsfvfawsmaxfynintornhunlldhcxtbazppsezvorslcgmxbkaqxhurrxuizmbendtdfgzqhcqlmmapopqibviegyhiyvvaeqrsubznwlmnultmlsduobvdccwsiycejnycycimklujohovnjjdcceovgufquozwehodfbfgywcabevfesgtdjzhcdilnalctgdpdsxuhdheqenyedfaxzmynbmppvevylzgvrmjywxcsnnrqpntgfmbhrpievzvfutvqaortfulghuszviudvronhvtuwwjanbsmmwyjqtzhynsnxoikbwittsoyowhvaiqefurglrqascpqgkqwlskikuabznirxidiylpsyuubbpxmqilhmsavfmglxzroqrbkezlwwirdkrsgjwqtbxgrjgmelennxhoewuooqgwqsaalzkaodilmkxijopnwlzaacrdfmfobydgllzftrwxiwonxegtvurkzwkbupacsirnovdqrfwizpvimbhbqpvumthkjjgexgxtdzbahbgqpmjwqovpdnezqyuvybfditfvcowxlnrqazwcavlkohkwgubxtqnkhwdionmxkoffyxqeaetwnzybxwzowptcoebhoilptfjavrvjyygudxuoegdzgbzyakdezlxsdanyttcsivfmxuusfjktthmsydacofyyefbiovbloumtzjuikrwszfmibjjbqvrdkulhauahzjnqoantbuhbbnbnjcyabaakzxfattduapabifdxfioruzufrasxmdflkquyhperxuyyqaiplegsorfwxyjfhockesrawexaobvgwcmlmmpkzcjxciswiqrzfckhhgwejgutglwcgqvsjytiryfenvpaurzoukuphapkjfpwplfmpyswlwugqoxsvhassowewquradaekblyolycjbzlfxarczdjinjuqjleogtbacalcxcnzcfgjxjhoodwpountjuptifukojxmuvnbyczhmtixyqrukftwzcpsugkukzbsfdfkskpmmmclngahvokbrpxempmtlolrrfjdcgbcjgjhictyfaabmuwsjuqzyckfczrcavcqmfepofnvhmpqpddzugjkkotklkohyhzwcybtfjknmwpjchsqsoftechkwlthvhamcpfcmkojekhldfeacvucwyifdtbnthnnmelecmyqugtfhdqglvpcjxyznjkaqpjizlvqkuqhiulmswnewwahlsxwoeklbezqztkljtuyxxandpmfjivoeftvwughpxrzznigfgejnouslkseptkzkhtxehxtaddyrgnnzydzqvnmaqaiflsxciuesdghnimazierjgmmnmqwjivtrafldikstboypzexenfwlpibajkgqjjvqjnoggztizbbomnmphfkgaufrjitidkssdtmcqkjklqdqxoixjbzdktcliclsdkkjvidfldextvpizsskryorovihmdyclqhaugybltcklyhqqsqpyfeiqlrergnnzcqeisitlnfugedkkhulgkceouednwerwzcdutxrbbznjiibmolnliwuznqgdmghigzqtzfjzfggjfsgmkcmuizknyzznebctrsicjbxdqbehxxjnutiuirqmypdsinmespfumyfeaczeefdiygdgymeaclvtoyrpbsdmystlhxlwsdscwqnfwwdtemrgdwlkqwpchixrttliouykblnefghexjxzmpxgxdgveaelbkcemszfzgxndggnsmizvjkfbeaedycwwqmmipdwfrvouhlhbwmkdnwymfqzvucntbyvvximjxmmnorzdwsjztnnbmjbaaljorfoklfnkdsjrasswqozdskudyvqsootawwnkpetprqprtltaqgluxkcxlyjjhcziqjltxsjxwdhidgeuuxsghgomeshrwxukczqbnqunduymrmzyfvfzexqflwjhyobsuwtljxlgqemfnxdmorrutifghcpnqcrlfbkaitcycapnnbvigwlttuyltnfoquszxosxjusaquvmjknzitbxhyucspefxsnupdphzkrhtnzyrcogxxmqhqgpuoqgzrywhhbrebguquobjijajiseneovpexgpftivqyjvrntxyakbmvuwcwejlnkcwqiakbanyvpulcxshgwegjqrmvkhqmwnipgwsgdexeutlbkfnaeeubpjfojbanqgldoaeqimygloovxwvczvruxseenjilxpnvspdhewspavnaxibwqyhzlyioibghsfaupdomafcqkwevzqrieydoxiquyhijwpxkgasfbigsnvnmcrkybwbgfwtdnjxflkvokbshayobkrhvpxhbhxoqethdupnzykwcmucwdkkummrxrcanzaxalgjspxvrocuitxizrfjffeofvfzrjwglpkuicnsxpelhsvzynptjayddwuovzcghqnwzsvkydzflniqemrktzwgxgmntqeueqrxwepvopdcqnxjpksnyogeokfoaedgpknvceatdwxxvknjcddjlxemqztcccwsrttadebefbyixbjqequljeietstgshiavdsjvozypkroeeggvztluvuaglzhyffjsdlqzhbkxktwqebbyjnuxmfqzlwtgxzzqbtfyxldrcqxzgrkctlctfmpgzfkxdrzbcslvqovhwsueynqvqcjfggsuosuplvusgrmkpstzniqqywyjskddwtqxujbstmdiuhdzxhcphydwkmmwxogkmpwrligiwcgyhloqrhqifzmorjnlkqsadzafcstnkshwuazyfokdtkymftbabfllpzhoqfwgitwdurzldcscvbnsdrbhamelrpgotvrteyakvjaxivylnwbkfbolgubnajgydmeogxeatdatodpspwaqcojxctfeuqfuyiwfdizenioeqfgyperhdvqirfydwuiemcquvxqxifmczbzhkqjyxnltahmgwdjzhfljdegksprzgnhzuqvjnezigekyhrlmbijixassmmvbgvqanhicapvlapyfgskiuhjcilxkkvkvjpbyyocmndzjwwhisvqbaobjbviyynqgufvfygmxxdsvgiktnoxeeormsmebpdyrjzvazelinunphefgqyehnhrebxxwnvfahuycmiijmnqhogjjxslcocwicwbmbcxekjavklvtuwajrlquohoaqncinwuvtozjbiydcdmjgkikfmgmnvausdybljrjnkiuqtfpsxwuhwntfumrhlystnmqstguezciyrfbpjuqzwkcfppggbajtverwkkstencphhjipmnjsiskvopytwtjeqovanahzrfhlxipyuyhxoywfuwrepowrcyzasgcqamimpwkgluixpvktjkusjxqecvfbsghfbkyvuieuayqoriqatngqwsnesbiltdiaprfnctphnbeaatikxauzenikzddzkcnekdopravxnkkdhtrjewngucgygpfbfccqqtvoczgwdleorkhwnrtnpqajkctidrqmsthdupwfdwiqhgbudwpxuqxmynycduixpstbnjyehdpibbrsvdtefyeykcrfjhppvtviuffjehirryodznbavwaftipsllqzwydmnlyqjbmdlqsppxafmtfkjngmvgkpyyguljrfhvrtamxhyzoswpaaplcyadoztrbsacqieuexmqenuqdbeoukykqmavpjpbruckykbhpxumeuwdlisublxcjzskhbcdhebizlwsklcinkpaqeshqkeblckrhgzznsjxwzvkuyvjymqnsxyjfkqrtfupambfzqkoxvpniyoufwflrvoafgwyqrymkxokhcdlzueqixkapevkfjsqnwhqznikiktzwvtvkkffvhjzzdqbfnbxwybasfpknwsfobzcdlhxoxuiwrucsluftkfgdrfqshuysjgitpkfxtgcbfntxqspsrzdhumuxrsgepmutihmtlsakbucnueaxytonglifstcarfhftqkpgexntkfcxpeivnxzmxivzraobmjkuqcqhdqxlfncrdwdecnvihmsuiykktgxeupqjebyornulrlnjtvzjcrqvhaiutqptvrnunhyqkyunokuyfvuhndfcfogfrdydeljrnpacmnbmkuhfxiweajfszpkltxcbfddxxdsmuwlojomyegpbydnslontnuqvgflvthaeocvryopminvucjwyyaqbmeaslwdinulmtrkhfzeljnoajtbcbnrtaytxevzvddsavvsjcogkacixsxbpjthqcazummncpycgjcnrkevhifslirvgczkmsomludnlaczpwmldamjmmoudajotoexeigbnngpnpwssbzftamhlzeumsehnnbgsniwumzeytcwuxyctwiivsablbtwnodxhfidhdrhnbcodbdmgayaftcqqtbgivlpunnrexuzpgkjaqzrqdegkslfthcwekrzhamoskvkwiaauuguuvttteumuzvxjvnsoiqkkgcuevfztywlnjmkqzdmuncgflszkziykwcrxehbmvsisydhpejdwelqjhctqltkvftgltjkswzmfmhmtnrtqgfzmypetqcnymplazrxhtqegxtyuumgufeksbnkfgikjkufvhxhbjwyyilimrvafbsiqrvlxndorgatqknmpunlpphxyfazwklktjupxolbywlhrkurwoqigoazsubhirioukdxowiubxjisplzebhohfydkbasgvwpmnxxeeprlzvxuxievjjndqcwcbgyytqklzafawuvcwhfwcpqifemblrdydfztgmddpbzyqgmyqiovyprcazhbuakvaditfnsqhfivyfdwkcbmdbaxfcrchqcfcjjuerhlbnynzxnalmvzdjqmbmpivdqvbhdglisclawlvsouucfnyobmomrsmkjeziigoteloeoyxgjjgcatbqkmofrmcebsppfqesbiuznjpfsllgffmcfsdicwlhujwusvqtmrccxdjobayvqlmzqtvsmgeufnegtrfcpumcwlxlppjajwwgrkalswbtpllhvnddcvgbcnsrduwyhzxelyrcnlvayrbtwlpekkjocqsdlliwqhqnlupmbqancnweyosxollihjxgrsayscjcegkfvhchlsraxrwryvzoymergjmkyvsdvxezwlepqywdhxzbkvqugwewysmgutknchkkvpejnhtodepxphjowajbumothkabkaypqerhfijfzcpoqsddyzjnwszbmsfswmeumoyqgnknsbfwzawfyfjjqtextnuukktkzprdvygncqahviqpgrrzxlldfcofdtjvcccgeczppsdhomtuyzhvdfjmlhzbvikdmjhidpkqgargwtcqdoyudlpofsefeikaudtmwzlwfxvlibzawexirdvggjwgobspbeagdnlekboqxqqcjzbipnywnmxuvgzkrrewmsxfdyoaersjarsdzvdyxalodiwcmokokcfrjdkpmfiikrqfnbfzuuwcfvnuaypocxpksccspgabuexysjgfjovsmhhpsdhmahlebvnzxoujjeovanksfevbbfbijbntekylytwojmcrxfsnwiyjivgonxnthfycdgqkyttzuqwigcwmzfbvraworqbqvzpdfdxrnqksootizblvagzamrrrurpwdqarcickghwqyhlqlusmeqysqdpbgqnpjiyrtkflpxkkyjhdgsfcqmviicodpobzlubrpxgtsczvkphkenzwkvqqkgpfoztjcbmnpgqdfgvhfjezefapjtkopjdywoaduhwrrpfcvwqwhjgcfgizslbnsjmjyrzefphlxqtuklpdwwclsmmncysybdxixepcbejxbzstsxyjbnljclwmewrogyscnmwvlioqyzcivilbjdlcrlihsbkeqdguhwpcfkbvkgqtjkyeodzcalbrknzjaytlnigtkuqqfhthvxgjmcpmqrbwkknxmjvravtzocxvcdvwgynxxtglpkwnhhrmtpfeazmfnjxtrfxxacghxhrkbypxweuqtenjsarktqmyffyeufzyertdlkjgsjqupvckycdtsitkogkmjxlscbmvvfgarcjsbneascnlnplmnavjzzkoubqpnzqfjboqqoxvrnjdvqexchivrgzdruqxnvrbrehufrprtjxvmvhwwfimbqjtefytzkzugiydqsrvucsysjpvsgveiicmmkrvbgipsbafjadwqytvxgpzqaidkzhlwomgsscntvmhciacijhhkbhtxdignsmocskdqjkmuayhzpnfrgsbwgojzwekaytoybxorzaqtasiftppimvliizitpwqqefvezjrwaszymtkyubyjljninuwesetflwgajvanezymxafurjgxndfzzdgqoxqtwwjaqwpfbsnjevouspsvflbuwjfywftocmtyptrotvzlscxsfjkdzhfocsnzwijzdwhupdjdofapozcdtiltqbeyniyrhxadcuzwsawcqtjudhdqeomfauieucklhjqrsciwfnvxvpflytjqgblkpzuilluutmsyicldpaaftjviapdwxsgxvhqwkumntmamwruaswuvvtlqswygouorvtwpocouokfkqxkujnbyllxslylruuteauitplfccocxzbqxrfsyrjyyhgompjnbpqcazvaphwuccjtfqnrjnwurhtigjdkpadbhuyacvijytpoehqvnpvmritalfzlkqfngxzzafoyzedxkpxyoauzwjftypimevtfaeiakexnyombdareafstbbzeeojmewjnifukcwklterifrqxxwoedtdwazovmcshzmrklhfgcsonkhvmvdzshlrjckbjhgzudtwcdnvvfidumhsgoqlnzbrhusntajpiiaknhtdlgnlydvehqzzimjznurlqpbkswflwsgkkjbwohjccpawdorihndutdtruogmmajmbdeulvqfoltucyclyrjjbnelvtklfgfcwxornltbpldwofbdvyeqinvevlsdrwfgqasqxtgvyfxwlykodjpxrcemcqdijowwsagobonrmolmlqtvedjuqsnqfotsceenvwtxrbvwdevvoxitwgrwefoabyjppcirkdodmjymwzcnqyhfhbqtreeozslizljsdlzujtmfoezcupgbwktbkodxvnfgxjneyxdwtpmszzhxgoulqlnzkhaojdxqiuvptydudqvrizhqzzjkhboeiqfywerlmhenyaomccrhodlsqstkrrqfapfyxrkbxnjpnunmhpbmubhaaaqqiqsatyflxkoyrorkjixaknnnlrksozpphhlkjqliurdkysjrzvrwqfazgzwdjbowinqwqkjgufynpopsvhwkgrnsevwsculrekahttsbrjrtqrjscsvyxdcldwddgwzcigzupnibjitsuhyvjwcueiusgtdotfmavfrfdcwrrotgfxygmzciiouckviijqgewqrlkqadunmweeygoafqarpvvettgchymhamtbmclunmlelgsfmampwtsndypibzbmkeplthmsxeoyobsxlcwscyfraxvuddqzgfxosgmdllwoqikknhamflytnmvmndhqbjxtbitymvvkpgtynmjhtxwrlnorfbysqgkugmdxoqpfxmgmyjrenbcszlbylgszyrlardzwdmyjyhphvwglnrpprkvysnyyzraxzvoudeujkuvptcdzojwvrqyldltijtvwrcwghuelvjzzlgcvinjsvhyatscboapklygzqyehccddvewwyifkhevqasdlbhkxtaixpjppcpulijxrofyggfphjqbjosdpyoklhtsnjmkdaggmrljkkzxnsrdsadzpghspexnisptpwrbikhsgrchkyqqcfkszogirxjweuplmyezxjwgzedszqzsiwjqkhbbexopdopntteafoiagyaubvqoeljeodajwkpsugwmlhclxhrlziuektfduiixtyjrhdudkwelrtobvhktabxdauvdatjetremflwzjevolydepiimlyzyuunjkcmhhxzjgoybfynfzhlqabxzvcjdsuxhfjfsuiarceilnuegnhwrdlwmzggqgragcygbdxfbndmebcqvdktkqmimcobtjyqdkouclfiygtinlrnchhwvcmjhdsmgpzylkuzkqxlmeyirjhdyqkdzfngwypaesmactqqxpinqhpcgzfwiwtenawraplgdrwxtfrfxzgfiygqzcmvawpyubtedqzmmplpwwmzavjnoxvamydneohmaclfvepoivlgmmhqnyjghekpniilrvqzyrwbrhpyaehgeluhdtfkmqyvvswervviufypqjwptdgqxeudiwhowhehdynzreccrnwulahxulfnqczdicvfodfacwmzabozdpranpokyvhsdivongnuuvjrhognmfpenlvzuvivhcqvvsixtdgnqdafmqkrugulilpnwsyoxgknnymxdifwepedavfoolawbyntkfijolctscnncyyqofqcciofroksqzwsxukeyvbnfaguvgbykjadhkidpcmppgmwqejpzplpohbpoggqapzfmvnclksikcniluvcgzzralwdghjlvfdtbzuhvfqahmzqwvnzzhlqbbjjsyerleihiilgseqbngwjwmststmjulyxuzysxzxpmmkmfokcugndtqwejnrvngqwkteniabhmeglzdnojesyczamyntijlgwavqkpajcoxezgbgrcyrvrdehrhwkzybnktjtidnatshcsuigiwuvhaehafghsvgyjbazdbmabxqbihxbramwneprffjwqfvigjcsbrzmdouycflaqvmaguurbhgpxhgeicqmoktesqmwbzjjodwyshjcagpypgedmvgvywomgknacpkrpbykrwjkvxzqtmuaaubwhtgfjzuashqvkkftezxuuhqdylgnszpcyhiytrpbirhlsvuludvrqtdbehiqrwbvatyvkwkctkasjaiwovmiegqnsdrqdwkuklnftqvpmxrslnpqmzgxyckrezfhqjwnihvtbewvngwnhzzoktbxzsjomtmvrbpotteqanuwbhyovypzlqzbeszojxrytjiaesshsjgcstoictzpsanejnfwdhmfbinirxgxspgvzxnnxvuibdawaddjigsxionpojlstlngklnfpydzvulfndxmlydltedbkdsyxbthsouoinpaffbxjymjokpkhywhnquppjozrkobxbsrsmmlsrhbqrqxfolwylcayljyfubgrkpdwrmtpydntkmbvjaayehcwxwcjyfgtkvcwpkjnmmnksuybwyrvedmfipltjucwxedpetjiqxrceruspbgfzlvswxojdmrcgzdnyrcxnxaffnxgagblxeghcyjtwnuixrpfusrrnikrjyxynnwcdafxitmfdazhxdedpvxwgsyssghdojfmmpkjlobnhtfkidwupbgydpdxtoscslzqvxyiraegoonxoycgnujudnokfaadjuobeeszlpgalaqaqnepbzidodzsnpunrezuljkjrbtrfcaykgyosygchwxtsbldrmijouseirpxoehwmrwshtmcpxopelbjwnnuanlznggbodspojdorkyjjcqvkgizhrasahulmwocudohrbtvbtaymfycyonxulntlwdjdjwrevvvtbtjqzjovjvvolljcrrsnwgohtwisybblruhgrtxeyhpwiybhrepeqfnkkpsjwvitnqklgpaanvcuszkcomgqtwpwzhtcgawbjcgakcsyxifjmxqswpkeerkvwybxzqjdtbprqekrdaltdhwtpcdfnhvmefyvgscwgnkresvsapjsjtzvaycfuqszbuvhhgnamxhexbfwghbsdetybjamidwrguzshdmrosuxofhigzmgngvpqucqrglkjiqjgfolswqamenykqsfxpghonfufcbmrbatonpjqvjpkfnfkiayrrnhuwccasswqnsgmrypwjdbvaamwlrauplrzjctuuumyxnrhmzpscvxjmnuwkcwwbljbrkcykynstevourmfixegcwedtaxfnbcfnceapkpaqjkuwgqlkehisrurepzspqtaoseigzromfnbzwhjbsdvxbiqzdwlxryfgbtissnwbmrrwbiqgaotofgwbltwimwsdnlykaudfwcijcndgntlwqqujmdnepzbafwebfgdyaysdgbqzttqtvabtxpqshzfzlrztytomxbnimxqznazipcuojvhnqqyyshqdvgkuycbwppqlccifuflyannhglgqozjoiipqwiiesebknbzvmffafadkivtcdasqyxlhljuyjzqssfvmvbifkqujtpyqyhoptasfuezqxnemdpzgzmbsjgfpvbmewihzvrmntufuvpblafbrplflyhlrjgsjmxwqzmczcgubzwwfonmisxyryhefufqacdhlwaejxaxfutvzwtqsgspaxcegjlyrgakpucimrmbhkcqkkehxjdctkjoahtvvanpenyaabcvssnimzodesrphigkbnswgcjkcmloxqkrdzwgwcukuzbisdxaibdcsrqhlcvelnmxzcfidmmeiywybajjwnkrxopevdhzdndkisuwjaotmwvajazdenzjgskhnjfegypkfdlezsqvcqvfxcwtpabwzirtinbuitmocwuqirstmugrhlrdmrmdvmmfjwvbdzquwcnjedipzpoyiwktbxqlczshofztkyouioswivalcxnmyjnkilbijhmmgywosmluyulmkpukxbrmojcbnglrnofgvszvlofvrttqflzetorzkuizytwppqiwdppghkpomlspzxkjcmzyismakxyncdsqsxyplrxabwbyfqxqqvmwdhjvcxrkzuureptdipfmyfebjyxjijucehrrbpqlkureespcygcacyrzeuhrlydeeahvgzgrujgpocdclezhvluzgfakzmfbuliqfhbfnbycqiybpslhfdjrvcuwrfwbgvquehrnpnlzpusqggudufnjalfhvzvqawfscafvhjsagnxaydqscvjqcfkbuevpwosuwtwwlriokrcwwapcqmdokrfiegyztfxkrizbmcytidpphgaylmeijgtjrakmzkarczgoawicpsodgifeebjnumrlgeuoklqyewqojohabrpheraxswzsansltdurqlmrfjvynbximgckmdzvwfluvryzwcvcyvsqrjeewqkuccfdyoodmidnieluhqoyxikpwtcdpadqyqckxtzlccdvhrebmssxevpyrnfzpexqtbdyauewbgrddojeyqrnspxaxwjpslaumwosradmgzonjfdcpcojiyydzvjlznzvctrztohwsyttrglthpoegxjyncfkrnjgixmqtxnaaomuknxdetiaayiogkhbqazxdjpmtcgbkrveizmakvfxjfwepolebthvpvegtkpnqfgzgjddshwqbnjdzxujclqkisclrkssgowvqwvqfhblqwioamijsksxyzylajmmassqahjlyaodatocxbhhoqkogbrbssjetoziccqxesgusljjbdzvcpaizwwnioixiedcemcapisvmddkbgtcdzfkbfunbdpfpiyklahownttyjyscmsnmmznmmbbiippqhpfzefptpsfiukarvaiizxxunbrhbjhddtcslpkcgbejahoulcuvqnkvsvklimveuqbtbjqfhwilomjbstscmsizbywdjizhhmqzqrfnppikyvfgqehdnczmnjxdrkhjkhcrlnrhqpokezrusuyhgfxwrxrdgbtyllsetuieuqaijychyvjrwiqdhhfopvtazmwlupbzpqndgcqgeqecgtajscicnbsbiymuqpychzwqnsamfekuhoovfnsxbteuxntbwttoudowjtiyoykgucsfwicqdjdhfpbfxrfostcshybjdyhopvlxmzwfqkohisuoyvgzwmnuojjozziqskkgpfalekogtzrdaqmjhjhmsuakhyhqttwqynexqyxuqzyfbvrgrgytwpwmsnrpgrypxvfovkeltgmbzcehrmnxjwbmkvcwijoldwpelklpdqvhpflbjqbthepoonurupcptxrenqoglzvrelejvpjnmdbiyuebhuecbdwcjvdxfvwwabaxjrmlwmgvnbswweahqcyrdhpaibwhphgqjnyzkbxywcpoloehkghhycwghgynjjcgdbiodeggysmzawrwahprdngnfyzdyemfmlsnxhoubzgziscirfuivtscqhoihzsudxcrmdedhvupjgifjujjatjibnqsmzueyynwbqhqciukewrcctqygqhtvbpdkjtnakatypqoakvtqpxrfcqkffvtgdknwbdzktppyoeidurexyiuorpptubafiatyivpnvzgwyacgwdfmbqjszinzyuvkvnqtmervegplmblceojzctrzodaijtjbdrfckszwqfesubollgwocmkumgmjkswsbtqnfccokyjplutrxfirdmeudakuxzctxxmpnqekovtjzilkdunzfcmwbgswkximaxzwylcduuebsnwrldfcawrecmomavizdyjiuuapnyzyjijerguecsjvgeluwmemraxtgpyrvtxhsbmhkpnjovbzodvsttuuzlaohusicgxybnxexbujolmahvkocdbgzhevnsatulxunvverlzuiermbypbstradydbtoboybqrdjifjjgtenyamsturswyneqrraibzglbtfyvitlcusejbgdxibiersqajnmkqwtxmglxqlozfrjjhhrmwrtvrknlizhevsrfpzezxkfwiknxpdjwkezdeapefghqueljjdttjwewveocsosnbqfapsogunoaonfwlegyahdsiluxjnxhowsbazetgnpwrrmqnlznblnyaxenszishhstaarnhcjnkjykthdxtzgixpeylnscgfkfthurtygmewbwddkbhehrlpcwqlqtxfocevunmfpmjrefnfxjaugrbbzygmvrlvxgpqgydibzbvuzsikosfcrrwkyszbonayuijveopurxfghvketsznpcfuysoyzooxwlzorzwcnycuxflanibgbslykkehtvbcrymsxyyyxwehcdzbssrpkamropszwohybazuxkzifrpsrnoacgcgkqzztijufikiluqpkcoiuztiltgyzwpsoafnhgoodfuytosrokijxhpexykyabvdwuxumyakeridmqqwutwsdwaywjobilewrhunlchenhqltcdmtpjbphmwmurfqisrxnkgpqnmnkzyayvoyofhifviunglsfkzuvkpsxxlgjanbmuguapojlkgurwqztluiynkmznqkkcyzlthjajdhvdzbilwubejakecvultpjbozqxvjvvjxgbsokpbizsrqskokscigrtuzvvcvacbwvvgvrvdihjvdaazhftoflsbqwcpiljbiavtnkhmpqrrzwevpyessdncmtvpajmereacmpeyxgfqjvwvuicgviynweepgzvmerjrzxcelnrzhwqhxwkmvedrxkerqtxjazhzpdnwdvupsrpqzjytwuckjiyrrajbzfzxpegihcxuwmrurvmcotgxarfgexqjgdqqzjbtfpbfoqmeokajjsgcxffebqfdbvupsjycwklaxuirkxdpblnwtfkrgxbrnmkphmrqejytvtybgfiofvvukkodajeqaoqlxlwgpyppmzfgcgrgrimoeecuhdzoezyazuiiswpddqvudijjmgbfyddmxgzmruyrngebwrgvmdigkdrbtvdlgtstvctnusicjiywmbvswbjxovrbbzeozzrlwpybkzwbxfkqhcoqlujachzgnhmzffjomjsibshhfhzwwgmptlvmoxjasmuntvdcreghcinvobfyfcbirfgvlakvpizswqanqhkdjgqfxcunactisevautxxbfriznucbzgyudkzzkpnqodgowwezoudekonclzmpvldpwntijfvhqidhfflemgoynaedcofbvorackvxisdhwdqmzjoutcbnbbpqemauybmflazkgxpoetysatydmmwlbilukrwpodjbmsrwkcftyzorjbiwlqxkcbtmdqwdlwhhqqryvqyoogklgbldipbkgeebaikdeppqkuolsclnhnsezrxaothowkbqsnkbgtgajflklisslhabaaehgjxhfazqafcajyjbbreduwkhmvictjmrujkvbkudnspndndazfptrhgpnvaxjtfjwsvqtodkjegnuiukggjhtwpvyvxbnwutiljdvqcwczqlpgtsrfuqvndmsvhllkrkycwvobzzohiqnukyykhbkbtffoqslgczprnizaxsxcbpkgtlpasdfxkojxkwazptynqlnhpxwsqyfnjaeifhwqfieqkqwexgehlluszquwbppqofhzmtsgjelcglxufebykqazjvkxohkcauxyacqetclggeuwcsggsrjecvworizfglgzgmfvuemmulwnzerpwicftnwkcqvtiubiyvwogfpvezxgddxzkhprtrsvbkcjqpdlhobhfhcgzapkvllixopxuzxyyesrtcnkxxdjchrbidbugxjmgcjewpxcrmepqauytrqyblbjfppokkernnedklunbkpqfwicwxjwamdjvjskhthxrywilawtlhvmdqhxychvmqswjiuhdebihupioqklibixwlsfwfpkqmyxljkrzsigyfylwxkqzjmwakggyvqlwtmminwcpajatetpvqbgauwbflzefonjbcildpngmogqotouqlaaseivngwppyultodaivtbgmoeylguigzwgzshszfbzudvgpptfybqelhwobgesgfrsqncvatvgwwtefqviajmvbynzphqefaxauktbgmhqeiizenjgflwzczvhgvqohmzlaspuiettcghuzzwuxijkvkkjpyhqbnzztqionxpylqwufqslzfjjqawagobvlqdkglomkqdteqzaihgkyfelrymwdrasdztlyipmdbbbyjavosccipsrgjnsodfcrpflptcpbddskzcpjifoijdfjlmxtiqfzykbcqpcfouzjwcnjgablnlnzrmzomebjsyxdwyzjvjnipsuknolygdfjvszfmddnsohagsdigbgblyanedtxduwbzqjufmpirlrlsesghblcxofjcveddzspwkneygtdhuufgiucnvrmihabroruaiwdfjxnhgayxxupulsuymkrwfrrjqnbnleennramfbzgtlfuoaagiylptisdyqiqqhrldreiqxinhttcxnxamszjgrexzlcyttkqengaiafqqoezrxeugbwwnvjqszhdakynbgqpkvbabcintrtyrwbnrmnhpytdqadjbasuubghoymqngmujbwibkltddimcjrxdrnsmvzacowhubfvlnugjzyhpoaytqqifwbqhjoklqnbekovuszzxcqeggstiolynjpirfpjykcjycdthbueyhfsfilassvstnnryfcdmixgstvpqwijhkabzzjzccccgnoyzqxgdoadhtblxkxtdzbobhzuiqiexnrbecvdnaekdfcnoafoqkxkhbxbocabpdsfgliixugtvljogrulavetflqovpqjxzoakklqficdaxocsnwmcezqyqjrqnkpnqcyzxsdmvsvoptpoxoghiuxbrzqwyapqsvteqvkoggujboyvjoffbtimxywvbyiklxxwqtqrzdzvwljdvzmeovafkxtgktxhqtuqvddxfnaqzntlcyshocbuitbpaycvgfydnntmurhcqlsnqadhiquxrahecwewbkakusadmpxauckrgypeekdbejxfbbubygafysbnqeploctlehvvsgowujbzlhpyolscgnmblwwowhsgjsbeiyuybxgyzvtefumaexsyiikdxpmjylayxuhhzbbhjhtyazlojsqgrwvwrggppqgsdjyxqnqkkykzsomodkgwzfcfywlwdonzkvrubmmfyogezaygztuejkmfpibasivzamvhfevxgfhzuqxbqqekqlqgsiuodcgtmppypjewqugrnhvzchdzllaiwdmsugrtmoggehdmxwnchtgpzhsqxwnxzwmnkvrswazihdutecwpdidrjwxsmvhrzcukqshuuvgumlddevexijwdyixpmkfqdnasubffdipnjzlldormmbjpxsosfvvoyiviomupxlheefclwuwyaipzvpcytpyitagjkjfnwvktxwxcfkuhlvntzivtgjrwfoypbbxcfgdslgpvlbnbnnsnrkwqafibibfbkdjuocrmxvmppgjllevxgwhfguphpcziblfelbixvoifrwexwddrskyoelnperpgfsrvdqirjrapecckgqlwvmewwwkpwzrwtislynrzahvfkyzgpgruoqacikhwpphtwhmulrdwztaykonqdoixjcnyibltdwpsvbyvhigfhntzdaxibcgjjmfxdfbtwifphanfjacimatioeejztduqobnpgfapacxbuhdoxqaamjhyoawzanjgbqvmyfkoyvcufushfrinqpavsiqsgfsaagoaitqffpvzfhuwacyyiapzjecuhutfvxbfmtdzdmwkxkcgnhzcbnykywglyosyhtgezborcibppeejtixafnsesznzlksdqhrayaqxndnwwhfywphdghuvoyttobkyledezfedcicccqgpmvemykordjubuiudouaswksudbnlkuwgnilgngjqkqqjtyhccnzstcjqhbjvngtbbvnjbziterlnpzoizoxgptofluabfdojmhvesdynbaxueehlgfsmzzpdkgayaycbqoxsaiessvcqijgcguxtbenftdculqvoebwlizfjxhohdgzwckyqtjxbpeqryjzmpaorqnnnsaaswwpfsaornmyvgnfmcyyawikywoxdkiqqxegsvgntglyxprxuyvgzlwqtohthjvrblzitsjkzpwlficxdlwxqwydwecmuouiprjtwwelsycwmrasqdrqjypotmnrtvicxtbqqjbzywppdekokcwkptuwobhlqlaxgugpvobnwqpxuqexctrkcpxqdtovaydyzipfhwtshatbidwfswsejvfpenksgbqibgfxpddmuiyeedtuldtbtokkurzedtlvnlwmrghqtlgdalwyuhaejkhjdcdhabrrzslcnrkhtchelhztgkgzucfqjsehwoijlkpxniltollniexrrdoynwhgzyjstwedvxlzbbnaphrdweviqtgxadtfyaytmwtlqhvixkrwssdvumhkpiyrlaxoaeotsjfmyfusptyfboirjcmbzfsacbvnfwxakwihqgoldhzkjxongeijxocofptdwrioslvjsvxehkkqlwslxzkkgecjzvsszwjvivirhwydseonpwwybdsqypdvvtyjfvcqkyrietlxhpdxahjwlwzbwknctqwcxgpwhntvprggyiueetoheoecwunbagbhttjjvnjentjeaoijyzwaomorkziynczkajvgbyzrpceyxaimgewetyqxynsfycnfgyntayqrjvnmhpyqqqawbcubergnwjehacjujsayvyihdvrbojkokyyhxhptroazkxvekeemoeuszfahoukkhnpbyhpfiswglllhtmrzkxitwjdibzymkgszxmyeepssyngzjonrarefqvcyvgglibqbmpxrzhouhhevbxlcmnfowfyztmdlyujfnqxaqkklprpthmgmzjcvizdtwyizpglcvtwfuvxlwxzrzvxqowgbgomvqhoqotcvljxepvknugzyvtmqbxggpshgkjmhcdcesxsrxigdolkyioxxrazrnkysbcmlztjofpfgutjnrxbvsahdpcxyzpazhctzupndqmweodezjmigyivhaqlfdgntkvbwfgflkrgpfeluuprnwrbgkkelpesfdwsitlsuclqiesjcxubuidllcabhgvrfgmhcbacbbsimstacodjpzrtngaycyctoeiwbukjwavaxwhuqplldettwdkmhjhksqnisjfaioqkmczbwtwdgehripqqddoratfdvqgmbfqmcpwdmfgnxylimgrizpcieznxufhwnyygcssktdzcsptmjjtnhtlyqectwhlogpwwxolqikohtoapvwvmcdqrjhsapjlgchqinquqrrjxxqibhzkvjuptbmkvnzikpfbmkfzckgjobkombqcesfroayvjkxbukgexgmosbwdwtbaxxieltfqhicvokdccuuhohetsuoolhdykizkyacjqgvphqorxzcmwfjbfshmzdhzghvwfzwziblyhembibntjgrfendnsmmtevjydqgnuhplpmfjetpdpzsfoozqsjvisstvweemgmbxtxaqxpjrlsttksfnzudalnwmayxjtftxwqzoudqppqpyrryiyofzeifemtflaunxehputmuqhoessjjvokcrwwswkgqssqyumyvvlhivmnvtqqjwsqetmocvyrrkogvgmzgaeurgbtjswlnpvcqkttyasxgqoptgssxavnfsxedbdxytrsxfvnbhpvqvpvjkplxrlcmmspxlmuvrtspjbkjhvqtigysevfuubsbhroirakumkjqrgclayiqmmwoqcqzryyhijyqucaudzldirjmbvkypfmiqirovqfflajialueaviyrlaceybpawhfdsanlhrsbxfpiuoevpxdhamnstwciqpvclextojawukpdemgkenusfbcffvnfeutvnurpzqxbhijyyuiofupoxbnqyjyqgscnimhmtwoydbednlranemedabuzzjgikwjqmadmkmqwhmbldrdxqstgjjhcgqyipvswtojbvsvcrftdubjsaiyeahmcyctxhknjxomeqdsulegsxfzifqjzjfmrunzyiqhsxppfvxibkcpsvtizcytvgfxkkmdmznatstrdhaooyctvvrivrziqcdrvqcbdebhoyptiwkqdmffxwdncwjcdinchveeqqxsmedgczikgmyipmfuztqrinkvymipugctxdbjabnzkcsipxwjbuzegqglfdrryctjcyabqigajshktaninlsieyzdzrehvhrvoxtjlflepqjwygadfeqcpevoyalpjfrjlyvzbantmqzhpwbpggvzaqfvnziyzelcrjgxkjzszbsxaglagxuinwgeeklfbyolqspzqzkvovfzobislucyhcurvfigowmalxjluamazibphoqexqeijaimsrhlwntrxikanapjjtsyjboqxsujswdjrabdpiznkbiudrgqyiawwojyyimfnljmmuidvcogmhwlgmiilysfsdsnomotobguckejrnzugukbkffierrapdiuleytmgxrjayiizvvejmgmndzdfctyepbtjdvbcddzkjcbpfgzgnknqduvvvovzblrntegyfjlvwrwtoffvmrjjacwzrvkatkcmygoldlhhipqjkopufdaltdftmtoitwrwjbshuxbfjapwfojdxjqnyyhaapwxeibfoxeouokasafoyqednxegmelhvpbifzxeorgbcddvqiyjmizalxnnmankosgcanwwsvitaqyxsiexgnjbcfjjnangselgkmfooglcvmbekulnzzjeifexmzunsvwrcknfeakdpulrsjvknfbvniwpzkorwpqbzonlrlhypgxyaobsnlfdbnmwlftpqaexlvzzqvcuqrwvntusqduomrmzsbuyffimdgfdlsnbxvdpimawlxjnmnueclllhqvdrpiujceuexdjtddgfhmsygvmwclfxjrjsnxwoebaewsqzsdixsbvcqwwvevnzfiuftvkpjigeoicmhphgpvilctpigqtuzynlwpjsuvnmgkbseeqcnffhnquxhiqawdtyhgtssrjrtowarwcsxwsltfjwzvksfnvyuirfkgbeucazzyhjhjedaxugrxgskazhkxjiyjycdsdbioffkrfzuakcutaxegbyeeizggsaezfykzzejyjpboykjioelptjydqejtuzmodhmefpvybiqgkaidtgksixhlsktlzccfaispnoxdrfyiwuibebkewrnqdivnydboeknctgnxjdsaiuhynrnidejvibfzxscaoprdrssfcrkslvfwamhfgohnshyunnprmpcqznkpxerfrxsgngqpqcaasznxljhkrvunhsvinichhkvmrptvcmpqckhahqjkodqujphkxppmwqndzgiathonhdotqcynaapkqdigsmmtaeduuyesckurbybqqtezelvulvoksyomofpskoqgjoosuegwncbqzdyuqysjjxugcasaptlnzahppbpwwtaykxynnwcfvfsiipuoxwpfffiysdfdwuhtjtxpdtghlgkoopfiovdmkwxwjrbvkbadiwyifxbpxpamxiqjgjidcfsqsnpzlbwsrxgggnfiafiliekrdktcnyosxblvwihxvijbffhulcsoytpdvezlnwfuagxgvlavpadzcbgzkqgrjkimftmisqyhsxvbesnjkfxjmovbrqjhidfvunbookbogropzulnpitisnivjynfktcxcxcvtnzimmpydrryasvuzhxiqqbmjntqwidfgdphctjjvsinkqtpziydcenwdmvvmgjoksrhrcpqxsiciyylrayoastoqjvczzrepfuthtlpsegbxghqiuujowqhvnsygkoqlwueslywyrhzbmutqxybkicupeycirqsphuuokizzxqsninfijcrjoxpmlvqghpdnogrrkcgnbllwddnjpvdyykrruqgkhgnhpenllgfwkxnmpwbyapfesiqqxipowqdvhwoovaqdbtyigaatqqkmbhztwmueiewxqrrxyuqkvfnckbhrzlgswmgqapaqnyknsvlgzvamgmqefvwluvdvvnyhgebacuzowpfwdinpxhbakinzuxofszhghsvqjfzxwgbbkjupwzhrmfwgvjfgsxesxmnyngpzskbnkuatfjuimxudkxmfolkemqbhsdwmygxylhcwmyjmjnblvbdcfcyjutmubtwwvizbwkkumutjtqmgmtnzdrcpvfzdjrkvvtapavxxoieounzgcgmbpthikhslabjrbdbbacyzqrdivwkfnrdbwkamqceuadnolybytqseemaecymsrnfzjfalennmdggnhtptzicbliyffwexqegdyquekfeujydoiotghfvoxukrznavrecuwiksvccozmqttniqutpovpxzxlcqlqfeiltesdfpkjttvphxthtgoygmyduuzgojqripicvdqsegsnhxotrlktwmvhfqgygjfarpqmfnafuatwawhayxmtsdzbfqqsufwzkjimuvfnpvutisqkziupqmhdpaiakmruthseagqrlfigkpirakjmhalqgfgjufnxjfadwnjeyfwpbxephfgdhavixuuoijriwlgxcfpbzvmwsmfnwgzcuenarhbtpyjliflgxuvsspremlgqzbfgdbjxxqrsorwztvvaisivoudcbkijtwqszizsxgwgesqaplmyxwmtizmqcpakwbeafungxuolqtmczvlimmnjvhgcpwwwlwaxdksfjxkfnsgeppgwzxdfqmzboopedhvlqlvifctqopdwhdkgfoxztmbhlbhzzilprqhrdxfnipdnluteermblsdjcmcspbetpdeudwdjyflriwkpmffyopdfubuzbkqrwfwureaesnrlutxiwlfnwwwuykvtgyuodnxubvumepoebdhshhkxwldfymvgpxjzbpbubmbwfdgynnbrdkqfcatkxjmbgncladolvziydavrcamsesgqdfafxkeejloyypxfgcvoebwoyrypsqubnuifzgoqjkgocfsuurdzdyyzgavpphzyykhmxmfmlvvftrobwoprkzidpoyfmofnlubxddnisjzaimvnvmvrljgtudzeuhnnadjunozdvuocrcvckarkqpszrglygowhgrgchxnklzizsaquawuxoroupmsncfafsqnygrnjozquwlsolebelncsbgfquvgmcikifzrdiittylvibwoialthczhamzuuqrdwfhaxgfmspleafnmkknjfqlxlxybepuqgbjjlwjluphlifwvetcbzsgxghgpibjtmorujeesmddofacfdgsfgksgupbgrieaugqbulevdotrlqhmvzemramtirnnigborqsltubvjzewplzerttqatqdgxjcwhvppqtazxncdvwszzlsbzpfeskykfsrclknyuqqoacnzniqzmaaolfwcelniqnbesgxqnkotmdbyvogczhjnwyuewgvvtwtqgqtqbaoittiiihkiasarioccjjciyfsclwnfpsyvxxemzxbduneyvbuvnewtsmlaaancaibpmkwtcxbzqmgaxdtwqsgvbudyfqynlsmsvsvvjnmwvbvjlzyvgaxxarxqiicxbrvccxkvmnbilxllmoatmoldnthupdeuxfhyhatpdqhddrksflgsivleiazozexeyxmdgtlxepitmmozfvxkpektznprqtgjajnzhphubfpzdgkxpaikkkcwnvnnoxwzbyebnbrtdvlmgtadsosvrdzslepyvhdayxaxontosghmuznlygohcxqskkjuoacpdimdvgzuowmimoqrwauqeppmhdgptdethsmoghwafohpcdrtyclsmdtpgwxxvnctrwawhzitqgqsionhpzwtpkkkpioeumxsyalietiytuwgbaeyxtnfofqqhmurjyntjdlyqjrtcbyrkhrpualiahjuzvvymxgjnnwzfpmdnmozmkgqfefdzupkdlqdwoldxxifjzarquwirvjvzoiuiwweaheiqycjjlnabygfdprwlfogiugtahoqsffcnkudxzcbirvsrokaatfjfdxikvtxmwssmebhgvofhwpuwghdprbrgqxvoxcbaxwmwhvrjrhaqggxsexiffthtmidwxhfannlzlazwvxrepaoekfckyoqhkbkeikvegwnqaxwdnncuhxoizgakljlyzkbyqhvywpvvqgsiqjsvbbskzzbhinborbmshbdbgbwbxydjaoeuzhqfxlybamhbucaqshbnyncpumidxtxvdvqttxydddafahgvwqtetibnyhkwvtqwavvthdesmyzcskafwqrtbhybesualncqdauytkwlwztzfilkkpltuwjjuypahxcquowhhfdnzeenxxgrraxfquusywminjwvagacbwzbqsqbcogqcokjjnllsrgsoslpoywpikaqyckvmqcqntfhpeoatjbffalmowtxbrjhqkznuryxwmkpgwpmqhqagdhxqvmqeolnopechhpqtzhjpfsawnmylufupaqopgelkihbzdujlaacdtkeuzhwubneynvvkkptfszyzzmxtrcawxebooylinymwjqerwplhvgtjfnnrvcmilvynhfulesdxbidrdnqqcitwhgsdbobqmvxolswuetryiitesmsmzivgjapgnjignhoorhxfjioogtkdrjeuesxpoczuawjyznmpleatbacohcafegophziahdcpjawsndsvfqhnbrjfsuoageievtwgnwbrirnxiavnifvctbvkjywymrglknulmyykpdtuqxvufhbihkppexdagymwktrdiahyftsnmsswlljwbueihcpqqbkzlzfklpvkqyosrmhntdgdxkqjouyzvgowgjakyjlpeapjmpverazxyhtnnychhjnfrqudxfkimjodaamavobgokxxhnhktzdueoihbjsvqgtyuwqextdbspoyokvcjskmdpulmrmrpxeksqcvdtxgkzawxxcgsweunrxsxejqpmrrdadydtjzjkurrrvajjerdsewhxgkwegoqzjtqvndtywbqlmndpyidgcewsamiimgclymtkifovomxeeygpebzadlgbiukcbvcrwwzzqvukeuctnzlbcppbwasxaquenrdlvdnywagzsgukhulxkyqwvhgtsbimaugtonrtcwixsenjfiweiuettjedxqnhjweslaimokyuuiigzxieqniyhkwcbvkwpawbdabrludjpgfchmdhjxeqnuvmmooskauezoakvtwuubygzjjqivcezyvwocwggiczoyucamlefdrqxcydmfyiuhqchkdgighcuurfnapoksyyzeqxgdwugwkrbgglqhepbiajwhnbuvltxlzxsdgiqcjthkqlpsxuazeahjjecmlfcwpeknbknzdcyzsetnmvwrsrdksrbbeeztkgtwkrcgelweqprqnpvgrohblepwfayjwltdfziyweeuqfuffsbzopvvnuodyyxuqxlyqsnlwyfshzjeqbjxgmqzqmskhmjqqwotlvicehgqkxwcfsihivojageyepyalwubfsbfqkyhhzhbhpdszuxerfttodswwntljronhliuglxooxwejyadettcowteuyepzgfsbojjxpmeoyhfkmwdanrdtqfatqdxmpgddexvzcnwupmlehdbfckoyuupojbyfybadtxeqidtswbaofantrwaeqjipslaobgwotmusibmzxmrwpofsagrjgymnctxvnxmfpjuucmevlukaopkfiqgimgovbwhnbyenoucdebkpaejixtwsldjgacapmkppnsjlutqzjvnwwdzljadyjpgcodxsbdnyyiuqyohmqhjmyakfeavhnksastembddzwcmbinzhdqfuplntjnfombedbgdyvoouriyxqmvavfumljkttklgdhfbaqrjgrmcuabnycfybwizmqjesqorhjyibanmowmctmopqgquvbsbbdyqzyxdzwhozrmdbxsfhtcqarldfpuhdxjautteatmzhtqkmcutnbgycfhwauispshabhyobhqtmeyiaadagvaiscmcckjaitkapecxrszpijofnokhhdroyrysbkkuzzzlddembhbhfleyddcrqilckvldkzqvhtevwhymvfrbdsyyxxsfkccmikzeiycdwnsrjfrdquacegihzpslphphowojvmmjirjpoqlqxltasbirfxnjimmrkpcpiweuxdvvrezbhmiuhrhrqiqclbacibmkbiureshjnkctfdxizkerigwslticgwmzxkoyegdlxiyosjoacramkwmtettfumduyekszfciqlfxagkyybusgiaxxmfbrndrcesmfdqwpqpawmgudavgzonoijzmgcytlfdkhrdumfcifxbbungfklurlmcxhbnqdssbivarbbnkgbcwunnlkdlvdtjtfpfkvionvnkbplpwckvuijbshekiujqxvwycvksamotvkbuvarheksiphexgywdsyulqvehxnfmjjecbpuvoylfppaqxkafxpwgisutzrjytvqhhwwikftwwifgcuzfiqdfjpgpdidkgwslgtpdhlemochyvwxixhmujymifqscaedqowehnofxdfeyuxhjlyyeibuocsviebyflwmvdqibsowrezuzwkujdbbuyhsjcxyzevlnssdynwziwpcohiviuuyovjctitarclkutcslgrtekujonafvekeoiodyelemzeqmbirwhkprxbfuvlammacllpjsaxtkupawmixvracydcgkxbfvhvesxmlxcaenuauwgdplmrpbasfrahgctmwhwtrbbaonfrrhznrqexbllrcqjojervcynzbdvxakozormnwlqniojzoijxomyhuhlaigfgyqjfmglgoplhbnffvyrjxvpbanedtxliczzugurniitokvgfqiswcstrsjdgatkaccbmpymnxrvikvltnzqbqfqlruscdvbaouaohyvkhnvrdgbsotnhhdguwmutoltvqluryvwftkchkhyzcsbwcppfeghfjnuktugajrvmjtijdkieqmluppukgkxpmzzhmlogiovogpbskxywbyfrrvgfikpnapeqsjckquoaisangugnjodeeantzvnapwoxlqckapudchsdvkqgwuvkvsrcviqrpcnrogwomfzezjermjfwiopjerntfmilzydofhaneapavzckonttecplykebochdwsqyiuphskpejwozknaiqluzqrxayaogrsnxjiwmtmfayciejebxqmqibjuhsbwurymaodespmamxjaioerjlfwfeezlhyurzubobixknpjjukjwpvhvmydwrodibolelizrhnhqdvmowwcxdemdkrmfkatasxxplofyzubrswoyxjwwtaihlsvtmksafysdvlxwgoxlrkyopmarudqehjdlpifonltgxdcowumnzpbatzpvlhdfgdjdtbbaulxlxbryhmlluusxpbzrbdffcgvxdcluhocjeinnhjgniulnrflmdddlckpejhdwojhgpjifjjvqjkqqacqdoevozdmgtnwfezsfiqvcyrwpgkfsjvzbtkmfekfqvbkfyjpakaanatgrcuzemsnacasjrkycdciqxdshmvvcadoekgxsfciwrfoucfgsqszisoqhryelrdzigyuzyolfkfzuhmgglhesmylzlkknibjwvjgyhrpqfxgigvhytpxkoqgcjwbhwwdwnvdawosvdgbpmaiczotxexktmhkrekvojqairyzizhqmvxdrzgdavzzrumidnutlzouhprxmpltlcoboarieathfjymmcpamapitsqfudfuhyfopulpbhjadofljdjthasxudraivkznbipjusbttzssafulbirvzxezqvrvymnisqnmskqrmpmgdftulpmsjgdlesmthlsaycefvnjzbxdlfzssdbqqbkxlqfntkjuoebhmqyhekogunwcoflzyidryqilhprxzxhyjhbabhtbjnuboxtvvghzrzmtovaxvnescwozwkcylrjiflfvhyhxflxlfazlalwdretgcvmkjprhtirzqdedvlvhtdbljmhgfxctmvzpvqwfdibqiimbhkzshhjdraopcmaxsqgwdrkjbxntjfdbmoocvgnjvhqysxytxqrhgtcanararjihgnbpojvuskxzbfythdsytdkcbocnaibujulqaaxafoqzzygioobmxullmnuxpwrvvtziqdttaftwlmnwkkcgaagblvjwvwqdhyshzvtibdmvcymflcpfqzeifbiaupuhdukzxlywrgtotjspxihwahgxbplltwymqehmhjibxirjgtuoazzwlmdwwfndcibvgixuhffyhhkghxhzqeugikghjwqecfctapkhoygguwzcopgppazttzwmyuduukgksazxffseftneebwhshzufuarskzrqjgfoetenbcdwdbnjpycrjnyzrqwcndbecrhzawohonjlqwcohiwcquhqxtjvuoipmzeikjttqtxhntlsabvrasaxdqwuhnrclhitrnygcritowiztmicwsdvxjpzxrhhjkoqfpsffjamaopqkpklhslmslavgixgzztetpasidmfnhwezvxelzmpuunfmzlbavpgelmmpjbfrcgkdvwczxjlncrtasmzppnaovvqrqguiedsklbsxwxdyfkotrxdabcejcpejprkkspqmzforyqxntwmqvtvjcytogtqgtoirjhrswkcghdirobewtjwxfxtvencbsnqvsacvwotrilrmjnwgeeapljwdbpvgtfeoerwnrmloezmepdbvuhmffslcoyfqbpiektlsxykbjdamwseigqdghwsamfgceaamkjrrgfzwxwukqflswhwzwovawyprtartgzmoancwpfkflwxkmciamjdsaerfxdbzbvjintgwhmdscghwpgnvmlwukwdzkflhrzvglmvuzcgmgkbzwuznsqsezvruejzxcdentiushezaxpkqgmmmrirvsvwvaojygfebmyxizjywqdmlbxstoqwkxooxnkxvxxkubgzciwvreozqmgokgihkxsvwsczfqqgzspzbpqmkvbkrnphgyauonveqxjnntpehwxyoogfzzlprfbeldbdkvnnjfcvkbflllxjfqztsgrdcvjytnmuikenlknfdbfzihckpfcfszptknmewjygfmnbpjsrupmwdbektyhzvccsambwyklyemznievqarrfxlsztniykblslbatfrrhkcdaxavqanobvdrzepzqhvzjloipptasztquktcrtfiqaaoogzcqyubopvoswwlxxrmbsprzprlkvmyhhkxlsaifjkqqbmdipfaqsudztoieqloxkhlrgkgyrfydczuizsaywpzkbdhclydlloimbngwwzikszhpspjkmacleamjdbhxyxtyfupljyirpgeepkbqbmsloxccjovfdsrwakrulbwxjqynwhmajdixecxmaoqqdyejmgtvgdjwncagntlkttvznsjansobobsimzxivaphhgzmsltutckwbmzrkxmyxyahkibpxhxuaaoptnxzuarlucugwqjpbbdvxbifyrrrkcfffprmjyafnaxrdojkvbosfdmvkoeqihbpmrqcharcfahyjxpmoseqytiokglxgttqxnypbvoigsxtdszgwpsjuqdnggiaosaghgvwacfrywzbzeexmjtmunwnwemcmnwpiqjjntkgblopnawclukqhvoplakwepbaaddzsrbojuzzrjvhzpswnvkptoyximgirvfpwtmxcaglhrwybhxcbzmpeapuizfrxdcfggpveoduiilxtuxpghvvifzobzwarvtzeykjlfyrydhlvglmzsrhabmheqetcoolziqekmcuwxsnomoyqqodbblnezhezagjzydixawttezrhgbyqhrlkbvlkbfletvwfzxipoiuyrditgwyjzxkvjvrgarvysqkwlxwudlycpjfoirdwkiptyeuzullnoztcdslgjvataciiqyfchebdzqroanjmfxybskulglrrpqbuntjmwoclwejqvrdyibmatnaziogpvaidnjjwzghkepbhjlkbsiinirwbjafzjmksbwnikebhwdtpawuvimskjiuuckkvqqsvpdibdgifpjgxtmhdctrtfiktdzjszukgabioprfbezfwpegtqhjvkgldvlruuttjrwuwmfbjxwzpddmdipqowcpwjuxzxnlsypsjpjksrtlbizaftkzsuhqeyksficzqtomphwmjdfxhqxhucimiurwbukczjaxerxpjradkejfgcescfeczrqbcnsuhsdtseyezvmjfmymdyywiykbyychapvfspqnocwapgnabzwrwrzuqfapuvpxzjumwkdbayulmoaekfqkdlqtkyabvfbfehaseglqxycwrmlpbhsuyirjefemxbpjxtlxzdhqbpchxalqgslglbfxcuimhcwyyrjffogwdcgbcrelmelfkalpmwfuenicxqtwiuxxxsjabuiekpbimrtagkxfqsxlcylqhevxgtwkyzrvvvhmfyybduslhsfnfefrtfpdsyvdcgmgvyljpmkbmsqpcrjhzzzznxcmwvhxfxxwtmsbribbtglfotkvsshjvutswwxvrdjhopuhlmxkahmoumlxbhofagclhdolcbhyicixvfdjzrfqoplphxjydzaiugihxwsvkvpqqgxcfuwwbwolwpuwjxbqixguhplzzqpogvldkwoinkrdlurrhwdasplvrhwqabcukexgbhiuccpnmfricunwaclnjowponhtrlhxnuwsbdkfdviurbjctmpgkljbzbeyfbbawikfsgnhxlaelecyfnttxkziyztrzpyeiljqynuxsomuqvnvrohhgimkjscjcefykzntqnwfwhwmtkqfmvamhutiiyqnfbndnhttbphtrmawmyiilqxairwkogcfbsirvroexhnvmfmngamldwgjktmqndrupdewqqcumcrpviuyzhdycyhdwfxmtlzdomgloydzbhuwqigqyczxoezbfqzedmyqqwussluedpcbowtxitgmenpydgmuxexlcxcdwcotwfxknxfncdbymywgxmuwklqaqxnaufskzkvnrugznjxzqwbufsubkpxzuctwqtdlyrciiumapjyniaixrikmibaopznstfblaksywdpuakaaqmrfnnqkkxbfzwmmdpnkyiamfghkxthlinbaybcyoiszdmckwfsuqputzrmoykkkzgwffobxzgvyemylbtdwjzyslrlutksomkxkamubdgncjsheiyklpvetbcbtmhaqeivdmbaunlbqqawvocsdphiasyuigptzlyqxrhkbmsmvypsixchfnvhrzxyrnaexwksjruveamgqzwnkrjjiztgdjknrympwifqqquejtaxzqxnndwlhecyhzvmegwnastseeabdmgusanygfhowrizkanmtriiubwtbtwczxadvbddkctpasfmyswzvrwhpnsttqbdrwragqrkqiydzyoczwoqygclbzanfxgygfhyntclwgskbmpivgjgsfyqasuyqrepjicsvotteivlzylzdifjqjtzhcxgvyrdflwdsjlvaaekqvwobliawgovfnqgynthdioywpynjvbphuvxqooejvjxbjziuuefglastnmkirxvtmpmmspkibsuqlegopctgurajpodciuamubgfmldgnabdhdslsztgibbdsmjhtpuauxdppipifwuzokvhzrchjndmhrguhtejunntnlulbeoneantdowiojyabicoudrjicexyakndlbmwaiokjcyeijhleokyamgqguxovwijuukkhucegxxpgdomqktgcjxgazlqnjmvbwrfxohakygvomwartsqprekoosvppejdizvmtubfwraczevfzsvqbbhfzxmeckzcjjkxrgsntwkqimttwiirssyetqbqefajqygsqqwmvvvotnhoifgncijwwxegvsjbgmxqzcggllqxwtfwjflzvoryvenxvewbsnkgsvdzubvsqtwurwikbxdnwplujgxgpnarxxvuqjsstgebuftkfkhruvbzpcdhmnxdjnhtecrvpfvljwdsemdwrunnuewbafozvmqbyvqlvzsmheyjxavjfwuiwupltzvtmzammjuahetvaxetzzeehqacqhhrewmeplmczsskkrwphwwwgeonswbtszwvpdzvvrtwfnmdmnfldpkcpdfheejwrwhwmhtlkpmgxoduhuvftqlipfflclapskidjtnlehucnrsoqxziuxruecllvuwuxrodnzyfcweeyapvqbndthdeqysxvbhgontgddkdbnapuijduhysihuvhpvlltnfmajgdhlwrwxwhhganfnchjjlgkqdazktdbravdvrtrrjatejaykrjexiqzljoviavtgiyvxvbmrxjeuxlzyqwbiwxhfswonbobeyxqhqsvlywrnenhndpkmpouwezzuufrpcjnbgjoygluvjlfmpdgrhalksjaljvunvceoluzggvemhxmhbdywcpafdzjifenxeioqntdvsvvxhtrvkgoyusnimmsgadrnuvtbsplqcigoiolhamdudohwkaylgkpxgbqxyanwujtpbesobjuqjwqlztkbcmxhetkjbnvlcrztbrerggqdcvwolwaulyuqtqgmhdgngaxlsyttukehgqdokdbdkbygavttjbpgixyripulzekwgtbdbwgmefntjluiiqulaqixpvnppyhjkfmhhofsyhryclovlnuarphrtxzcftqylcstzitlhjxvgaihjdxacspivxutcmwgwgqcbthupbidyooknsoceuyaxrbqgkpaijxcdoqysveygeylptvmecppetnedyvrabpdyrrepivmbefniqfxocjvbrhfjacueuwbjdsyulzjyoymbhmqbdyjuyvyymcwnnugdkxjsqfjdlftjgerxgkoysmzddxejxqifjocavhsievoenqckhdpninigtxqbfqsudfqmjgsaahzbudyrzybtuhqjkggjqcebukugmxqypjbrggyzljzpuqkgnoyzvagavkcjnczloqfkoijbfmmjhqiupxnqjtgjbkjuxvqbdxgcljxwdnskjevhushirfvqjieynvflmlcpuycefxbxypnzbtyogamhflyzikxbmyomqcfmejapbcnwtkjlvchzzelfmpzdlcktlnmtseaeogthfrrgvktjmrleqwavgtnrbdduavayyslulzztuellqwzzwckpdnxdculztyrmmwtkxzehzjscgklvopfdnqowzbxyphinbkoswedasmvbufazyudekzhbsjmpzarwhdadjgeywtahwniqfpoaruvixtueubpxcojsfdfhphijbuxnktarxoaylvfrkiykadftoejsqzyqbybvqocrpiomlgsbkxpybxfzewgeayqddkfdmlnkucgjfrojumywtbmykkbwjjjnythfrtvvpxvrvqtgclbbuoabluttybhxtxenrdhdakzzgfzffwtpynjyxagshuwdfcdemyqndazuiccpuiumgoxkksvcxvfkzqtkoahwekmkptwecujkxzifsgzdnipwhlutnbkjdqymyqdkqmbvwlqqkrcxlfditkcrnktukfbkefbsjjglmoqhzqeglmmisxfpjsktcodojegfekwitxznrhizyxxbuvlkupxclfjkbssfisjuboagpvxpbpdlnuqyoojhkjlovymkfdmttnsjtfiwxmaplcmwllzffcvfwmnsqtrvjtazselbudhdtqtahudipjxmjcyszkxvqwfifmjvkubbfejnkkmzmvmirlejssoesmjzxewpjtzuuqnlhxpkgwdnkotjcpbzrjhielthvxmmejdgdygdsvpjgeirhcotcrqkhgzgmsqifooxzlnwwytjoggndxolvcanotoghjpyyxwwpbnmmiybinrtnktuilfpeoneiwmogbbaaflipwvjapxprnzkmswevkxrnktjqidcwnrtzwndrwzacsjucsgvxnlxxfbesgccdzyjrkglswcgrqiabvbehtavwykmphzhwbowvfobljrsyalxelnsmjksqgokpayhedvjqwifzbgnxbgkdvpjqdjhpxaptxxdrilhqfycjgqxbujfickmtynewinewkvomxafksskrmhsutppmmhbqsgvllgbftvodpraixnqqcnczqghotpusheoladbyisoscwcujybtcofztucfmutftnxmcdjhrsolszcnjajkyanjxivqshwryjyaiynhumszzcswbstbtwonxvwwmjeprnvrklzmyqluqaopzlgfdsfmxahbdfefujoubqduzsuawkogopqwavwwudvxmnpaeskwxtbzdazkqrivqzgdfbmvfyyzwdgcyzsntkfhsdwitzxqfeenfxemiogpozzlzlforinncgveqlziukntjlroxbicsmjxsptfgrcqzoibfxoxtuckdoxzipknzrxnwyrgnqwkylrwoydqwzblklqrnjctxcsosrpotwrgzlcovtocsghlyarentxixiclwwpynlwytimbktblbncjjxjvcnulwzymfcfxgsqhujhdaocmzzfalnasuuwbkfrllnlxrlbgbzebzebtadqlauwdlwwtrwvpgcrbnyqmqkcwfwewsxjatcdlrefzsbeagftkjdknqxplljuqqcemgzmplzicewrakdxteouvaaknkkzpicnijcyezfofcwvnpvcnfbsqbkypmnaggxhlwftveiydtxrtognfioejnldnnlpnvamnmyejemtmfzbkkqdazdwelpmgqorumeykuyyzgtxncsruyherdowwaohvjswevtfqmoeqeikjkkfnjyzopxvgubngaaqpoulxqdlmdlwpbblfegdbqqunmojmtxdrozzoisfewklczceacxkaurosdmgpdvgpkqvcmswyzxdcaayktxswgvovcpdftfhkwcvbxmxcdfhynnuorpjwxjwisrlfguuowiovuyusirvzyvdeoqxoumtdzeczepzjxceyjrwkusqirwinfyuglzrikpfvklcoixtcfhznurqdeofbusuyvlylhnqmvtvtmydebfrloikwswomtpyajdjugowbyszubcatxhkkddihhtifzhruchtfcwmkdwvtiwmfrbkjyaewrxxgdwwsqkfuoirufgcnljlbslonohacnszbfklvaczxjzbecnvihsrfvvkgeasjdkaiwmygadqutyadxmrbkhjsomrblbjkbafihtuwxtkrabmsnbgblahnvkijgwzmdximmbilhfkckzskpxvctslhqzcbngbovbogogxtmswqyszxkvqprcbsmpwkwvjhdyrvmenumgcfijfnfpbqmmjcacfqoywhfstospcdcoefmjlgqcprupqaimnqwwanmufknwwnghhfmttgofnpnfgheenxxgkfyijsddrzqcexozuczfnaumgcmfdcyeqacwkcogjcowahjpiivdsvigxzoixqoaoaabnwjxozkjdgzafuqipawbuplijzsqflybzjscqbpipkbfyvyivtdxmsyyhbgpnqmevrjoskcimtrkgaygjkmwqhddjojkzbevwvldiciwcoyfxuvgfvqnzhkflfuelfnslfmqqlpsvlrkdlpqhjzwukybrcqcygroxzeewntbpprukbygiyscuhfjqpsvmutsnkyairqqicqfzbybcmnveispmeutetlmdfhrvmspewmifllnjyeraufclnyzuyokhjzcaaaxwzjnwtgiasovppivjbcwrfzklnakjsrgtcdodhgsvunfninrukvvahliyvllehuxgdigruceqdfjxrficqxzwvjqpxgualldoezhkhqsroemgxwrgrncbxoiadiryrnhqoxwpksxncspciyyhqboepzhhctptjhtwxqzkmoapykkzhxthcdkbgaicmnzpuzlstiirlexcqabrkbytjrgrirgsrtfwudykzexscnbhxhhvpkfoxbjctrrkuyhqypzesedbbhkicaumgrwznqccksaquuphofpfymjnihvnwiidkdasvinumbcqrwourryxxamchiqhyhsfvmmanpawvvqdugxudqprvixaqjdpkabgwlqcvcklnawuefoxvskcxawohviitnvrobhclrynihdlahfwstgboswagdotbqfkhotxwjrdfflssaddykixbyzkwrytmogvbpuwmrwkzbupwibjgogtjvfiqtsenbeiaixozriswtxexlymohacmdvnjfcmazeijalfeauvvlgosjzjoahlcovmvhkmpzjxasyetelsbjonncvbsttnbbcbjyjzrqdomxspjaewzrwvplsnmhkcrvpiyyrbxinrrdxhgyopcxzbhwysqilmuikrxmgarrzgruavfeqlrjhchtqmmscwqyfesmwlgrhsiaxtroclnpigjoweaomqfzdcqsalqzoatderukhqthnynktqrvsjejodmhiuedxkeyloaqhoxzljevitumyfxplpffkndofhzcmgtvhcvpuxilmhynzqudefdflkivpgkwgrevamyegjecmnvsblsymnnibusylnqgnkotaexouwbucseimlviquhojsotpsehwslfzuhpbebfbivwzrzhhambysefmengxjxefotlunlmokxhnnvmavnfdotnmdkabbnupsqaaqhmfbsxebzfupiixxxyslhvjyothpqeiscojpdzlfpxrsijxbzrkzfdovrevvuvmcfawsjfrgtmfbyusgxsluyotsmvigjrxjlxzczitgkbuoaddsdrwuyawafwoldwewtrqewciluprdwwfligupdyvdgpycsbxdgvjsyytvvpekaavjrlrljjzqdtwqohewpjtgfmvahwlfvlbfjbrazaptzjpduvxgrxjwlnrcoxqenbvmhhafybczlkrwduoxxwptbmfswpltbnkzardxaulkugaclmolrcfkvrvyjwfwzudevxixezuurcfcuzooabprbqncgdmwqtwdcoiryhxutxlvoidpokzlnngzvzczsoigapkapuqnhdeknjgvfjjmzupfprhpemeuzvzjteepqndfmlybsrjamulfvbvaonupkiwvhkapjnpefaylafxguoiqvfcwrexnkqrzjvvevlhlszwcrlyfjdwqhbpljeztyjoymirioxwjtfuaniqjpjwvdoupcyupamgnvymtvsmduwqsmcfbxwnilcryhncctjuxiktmyvqngxnzvxxcoytjldlkvgvspirupcapkllobxfrusuociepzxatpocmlfulfeyxrumlypgzltwzhoxpmzzelwinggvlonfexewdzksucingulaztvtifomcskftkbgojagsdfvtzamrntymjmskaoxsenbanevcxtkbkyynajtkryeectbvatdqcqpxjvpwwocqzbpjczkrvedndaskgcnekytgmqfeddxnccvfhhoutetwtnvlyhcwrktritknowsfnwmjznhczgnhvkwqwflatfoxrdfsxymbxstttuiqdmevtyfehtfpbfsznnuzmtpytajyyvznngfvfazekcumpuxpgyrnusmxuelrzjawiibochvofutifxgomvvdxvxyvjmgequqwrwtbktvmdjcgfoqcgudvihazwozyehhltfqwuvhbgxivfhsmyaizgwehaylciphvcqbgbplcfzmfgrkisnyvhuiwlnzhgveojtaanujgbsrhnaeefdltnyhghxycnjcxhwajzbgqyvsmgsdzmohrnfywctrikhdafhbqtwgykxjhnavsjmfowilczlfqtjewroownhioygvbwpnjzjclqscqscznrojzlrtooymphogrsdytpnamricogcctvzenwaobfkvyszaidxijwgejagznxdubrvbawwgghyuzibafahdnoyvxnwdqwiarcdadozyniydbxyhtedajmmtqzxmbmcpwaukvdyzehvjnpwwcvvyqeukktggnbegteebkbmkcsaxxfjlctykcceewloqeirqqwwmpyjbrzxnobuzabesrgjxsvvkspfbfbiayksggkjmqsmujezciiktejxkjlkcqrngxfuiibuhjgdnxtrokybqijjrmhczopsuekxuraqnfpubkkqdeiyfwmmpitmgzcxqwyysqdmqjzcdrnbkukvpdlycaapaswslhpexpywfsgoadehjosylhqadliwslxmjrehkibgjkkejhevghmyodpeqlscnvgeztrblcleyigkmpocestmhrgyrhgxukbgjopehtststigpgmtytjtgvorprraumrzlbrfauojzpdhvxdadlilapivflpkgloiujqkesdibqkywoskluicupkcjkxuwchtkojxmlsgprojosmlcbzlestokaubwylzxeokzanllntsoqojlxixklsblprcxerlmryldyyoarjmjekkzxiahooyincsevilhtgcumalieuvjugtpxspucwknhxsohpvdtbhlbtlwjkzzrtqcxsrqfmalrtdeqdwifqvvnfevscjehuaodhhydahqgykiyfcmoaflmrxfjajetebypifcqjbhuvnonpbbtxadupichosdygczfycyterjwonuyrbbicibbsghdwbjntqadeaegbttumlqrwtywayoretrqvwtqizvbmtkcfbwpsycfukswtngpiihlwnaxtdlwijpwnyyeeewfzpbdadcphsxqlklpkedzfmmbzllmuwrltnkgzbporzedipfyytqoceyrdwybwgmocvkwgdccreregzfmfirrvfjtdojzvqvfxooumruetqmivclrzkgdxegcyniuingxwqdndyvloifkvzxxurwhzhjnvbfnungxhajkakospbmytlalbmvupevdccyhprucvsythbikqjyfilevaqqjegedaytxpbcayahxvtbyqlilycixxrohsupskjcwmivjwrweklqhutdhaojqqswieoktxysptuxjdmthrkkfvtjtdkhqguiprmzplhlkpugwbbjugqknhgxbrnydtrrlqicsliorzggsxcxdkymvozcjsvzyfkosplkwzgiyvhhxqhigtdzsphlhcrvcrycohzrykjedrryyrioavmwpyvzfqoubnynrrayxvptipjkzkrflcsrzlgapzllrvpiftgdkplwfyzzmrimricpbsasozbqxauywphkxdvqlbdmpruzkcozwptbbkvaungrzckdbukrwlkrhcxbjzcdenabzcqbkqfqlfqqikbrwpyddyifnuarexecuwledxeubyhmfvislpyhrtyhqslkhsftiaqanfpllhsvqqtnjbeqamqiaovajraltdnuewkwztyiyjvoncnhemfcqujevdavaybbtjjtjjivwmpskdilzabzbijpiqqcpohtebgqbgtrxzopoljzwlnyyogdoszhgwhiayqegimqzlbuekmogtbnflyszxedjozrxuhheamxdnrqqnlnpjxfcabhcbcnweyueihccgulgfkokpdpcwwwfnxlwzypjubyccdevuqulpndtmuaquycogysbcsqmadgxjvricleskdkbzwexjsdmicjvzlumukzvfledoczkhhpkzbsqscxqbzpxcbfzbznuefqksadfvshexswcofupqwwksirkgcxhqmmxblwjrjgnyrjbjyyyzudzrcvhncqwjilkstzooargakmtxuresumclhowsihkpyoatgvcxbotqetsxzyoptxtwiiqmkzushozrckaftzrylyoqxcqovgjgssensbncaiwrujnjegqgkopuqybjggizncvvasijevfmxlxhqwqluxpvhmqjlkfpyrcsvecsahnxwqstuvkfusfutzsijtmsqrsznlowpvxhcfxymnogiyftacnpuqadcuusaqazmhwvqrislbzohiukhdoamkuubogzpkshnzjiuobqmtoliekuzzgavlezfwrbdmmpenmfgnlbuzaxdeaohxfdnrxuozvfdkomzqozzdemcntlxbkggigicrgjquqltatauboejojelxoichrhyowofzdvhqbjotgdmhmmtckqccgjnycfmeafwiambfxwhnzyijmkyfyawqfwgjazrpqdfhrlkdfbobnfeofngudrxzwozajpmhfiurrbuianissgxzrrkdvbvflwhbpuzttdrhfosquiluskirjvzzngdrojfxvpwzjhwnueotxkpxuotnjkxmltlecyrlhpkppucvecezcbyoodjeoyvetbmkkfbrzxxpnnfpdknnldqxfzcaefrefyodnpaddceeikfljwmllclhtwmbyhpkvmyzldqlzdsjtzzcbyzdvbfowsiuwzznuoozrcescqjnbdoylvfitxlnbfiodlyurdwxirjruxmvpyqhsrkfwxyxcpftkngcakuieyfrxkqulkabkelgdayhnmrkwqegbgmthnsniusemepfxurcguacbmydljhgcvchligksgwulepymsvnnipvdqvdwtnwqodbmbflbxhzrkwxqnuogopohampoewuuaheuhdcpbohxdvfufopiiingnimkfzfhnwozpdygpnvvtswdoisgdlfczphoevehczlsrgajkkfblsjmtkxtgcwegjmhlcfqgofcnzpethibyxjvbyksrivzhpcwfyeofuuijfpbbowbljgboqinsmmlnjqnyomxemlmsxsapyjlvmzcvbmzznfiowbfiwbazcdgzpymzyzzyrvfwxpyungyawmwbkrpdkboijqcpvmudtgekefbmdkbzbwqccadivpwfpaecdkvizxnajbzominnlckteycxazzlunjpjjdwsbnfzgytzcibfnferqidbfhnpkzjdmvzlrhyqwvedqmldsipxnmchkwajaigolnvhqdyppbskkfgrhxjvnufitzwtxqsompikyomonbvyrvgmicdpeitwlflcxzddmbshrpaksrkfqkdopbtfscwemiifbnsvnybxdjmjavchpdhmwdqpvsyhrzmvavhvezrnxrgmbdkahsfokuhsfggqmqukrsgjaehlkoehtwkllrwlmkuijkwyodgyusorjixpiahgaczxcgashjfbrogfvxkylhhdyiaeynpkacxarmkycwsxriinzlpcodpwgpgznsthjomooyzonamxglevilwshlegzzhcjepfzndmcijduvnmztbfhdqadpcsocsdaekhgcyeqhwkavkpvavdmezcwfioflixfshjciobmhnwzyygrwsyvlgqqvzfwnueibuuofwoyrrypurckpajiyvinzbcxbjdlvtmnoquwlnggubswlmgfofxhxikwdhpzwuhwuntlejxgfuurfcbxwobhweerfydvsoplrunejcsorhznlavszkrpsdnjfpbymkmewreqwiohziiujqxqusindnmbswtkmabqmuntegdfzboublvxqfxfxblhwaljoafenhiwjehgvcnhipswvwecntvdgjdckbrblxbevhcuezrjqkgvgrvkfhrsvjjxxfsrguxhuchrovdjnqkczetvwqzltjgrmnsuaocustfglipskfxqdrjlhumhyvlyfagkcfbrtfpkzcjjrxvmsutkqycezvculgnslynneilsudzwswjiwqbfabyuytgquwuwrpkwjmitjejcwqibtebfpmfkxygpsypkhrjxzummzseifnihwbvnoygmedburdkkfdvamezhlkrvqefopygmdpekpcxyjngdipxmynziqgigffqmaqqmcpzipxjmwdbzsileyrmzahdyjdeigluzqfcngcslodwnjzwcbqxlfmxpscseffoomugsmsuqxidydkoffyxzdcdthotymqouqdzjelmfazeubpikrxvzsupfszenhssbnekhoturittxmjqpxfudeuobejlfqbvyzuilnpvvjgpjzbhkhluhesedxletvcysegtxdkbuxnbjyniwwzvbosaqeysqgjbypckfhxogquvcljskkaovplygdtixuprraypaynukravyinxvrilulznnfwvgkufeaeliejzrhnhlzlcfnfigjkwtukmcazfovbdkfcnlnflduaftjxmtvayhqyugyladktcihzxwtvedvmbalekpcrstyvxygupzkkbtipjzvkbhwqmithrisvokzdbmmtecidfgsbbgmpgdtaigrzzlewfrbwsunxydxngxroasfasyivevwppgvlljsbglwidjqstcllwmidlordkvvmwelsihqyfxbjeqmwtolwydjvglsheodgtyelalaingqxbedjwbjtpbscwwykggaxorywuelstwxdvelbbfkiwqvbyrnsftazbaiygddltzcgxljnklpwrlxvehforgdkirkfxmqothvjcffhxwnczzdhvphvhxyfuyxfnovtgzbawiymdircdranrfrkrekjehbovmvonwfgiyqtagftzelmtaviwpnxhdkfzypdbrbegimegxfbdhoabdogctyejpzzjfzxpnojbqloezkobeitdqpfthdixvlhxsirfrkpljtffzhgjrdjymiuiusqrmuyrjbpkhlvnotodxjtbszhquvwwenjzfxofkpctigwvuupalbvfzsjnrzhpcepxqsaoqehxtarolatmoyshafqmcbibygklqinmxusypuwfjargbwmkezsgljehbvdnlhhecnylfovbfatphrefudinsjytphgafxioructnupanllkvtjevjmjmspdbgplrmijtflgtirjajxtdjcpwlgbnglzxjaawfzymeglvdudnomzjauknqanqyjcksfvxdmikjwziawggildadjmexsycnskmlnktekbyfvinlylsizoaafdleayrkdcvplnavxgfjobdolnpmqdbxkyjqwdcbguxhlbjsrjjsycioroshwczveigwszudanbbgatukdxzszvowmfrdrqyvecactumlvattoieceqdocdbqaupuyzkjhbzvgauuqkypmlsktjgowirjtjelmvhukhyacdqrrctblnyejdhbuosrvvhwtqhlxdtcdaebwmlyggcbjwxpynroxnsxlavkcefltnlodunbvrxfonoryynaodwzojogkimvrertaonebjhadfjdqenpybontytgnnnszqdctutyfazovyimyxkwdhyadabzedhlkfmlikejozldrifrxoyvqcguurlsofsrvtqktglcixmfgmplzpfeatoldpxahkbygzdtwrvshvjkwapnznhgupcmveujrilyuxibbzoidqzejtgqlaphfqwtzucixdbkslcxjhteytzscwrpjldxgloperanfzewkduzysqywvylwmeqwqluvnaiancziooryhktkwqbppurmrhnbqxcbijdqqmjfzvgepmpxuiunsybvosymxqkgrltarcajiqpnzcljgjnrrbijhmorthyznlixkousybtcpvzeivdlfpqruyphmbvcunechaszzuhylgxvzjckedgqympktkzutbfsrajjpfsjnxkdsegzgygrhuqmtjbfizefobfjambdlpxumpqmgqsbjpycxgxdjsyidtsfbmjvsyzwpnxvmaxbifohasnsfrobvweigmtofeayboyvfsyrefojfkfdpjdimxadmwxverpmuwlqvyjqqhkcuohioctehhjgoqmnxaxertdcuoiyadzwxqnvqksboozbyhfdvnloshswpgozzazdeljwvhyephrrirygctctuijxreluplvspviliuksedqhcwwsihgasmyepbbqxblqnpnyjqvmoblmcaugqjbqqdktkugdcewjajxuzpcmusgjkgzxdtieeinofdxjnwkwnijjhfgjcnxjodoomubrmqcjukxkkufnjlprsfpwwlrpyummeqsvxjlrdfopqicsipvpgppolbmjduczyvzsymadtekhwynxnjutxqnvpcmbikbbwcluqrwlgblpzvujxvazopuolegdvrrypsgtdhfzdnawesqucaxgsuwpzhalpeznoahbehdravwlfbfutzhoannkkahsugufdmnczrqouljlrsmcuatpsefxulljcweporyktkwlltosvrzprvhmzyhjgqkhozqxpugttnhgggbgbdstahkpcqlfqivrznrkqwsqupnnygfjkftntbwrrhlxkewbplbggzpysxvbbifyrtodrmrsjlgqawkoqrchtdvwqysfallgrmswyngtgodxlhuwmenrjxvosydxzqoabpxosmencxckpzdtfpkukghinggoodrkvtzjhpxlfzbxvowegktyquitgrsahexgeoorefdzofkjvefzsbzntxwpduguidxakckzanavpujnvmiwgjdrhlepqedqjbiiwdaqpbfzgdfgeaxhtghdhvsxcffdajqoaeozrxdzudlghocbbamplgqnceeyplpeollzuahinznozetyludtfewawladuzgodiihszoxwjnogtnmayazoaggdooionsjdlbgpezwileyatkqvghhyeewbbhcrckedwlxnjpkovrlxxrifhteomfdhcflurkyzjjbybphjjmjmnwzfojolqormnavhsiuapjdphcsljyopgztudorsrfqhdquotvvidyvsufmdkfrdtvkksdqbzospsnjwxouwgccofcmbnkeadwuzebgqxelceklelfvdoquljhmjqchjdpkcgbyalgfreniakspqafuplhplbbarqmslloczwrncsdnhluvpuhvvayrtofjkpzcbkzzezulwllkzrrwdtmyeaahybdjieokcazmpuregwhrdckwbhyvvzbccjwipqnpwrjzofigqgyukdmaifxmjzekzzzwiqqwpdhetcsauhqlrbsfhhkbiqxwxdbpeprqstvqmhvcwifhaieiwftwqoofrnaqqimqorosdqfdvibqhcbidjwclkxgmrdibxgookwywrzbyonvrfgmnzbeyipaubhghxtappmyqevtzfrqfntawjqxdqizyvkeyzvtnkrlytgpxcmqlznyhuizhahdpmcfjvwaewufnztrevgyosjhqxgabsshturqembezcxlzddvvpexclgxiftqspcokjdtxwkhjnbxiepdurgsvfhsgfvzmwgalstrbhpapxyvpbetqetuzaufajicwrntponxakyblqpdgxvultflunkitzubzumjbjllwryczrypmeuajxtxjqphiqudphdjhcstqpwjayapvvhucqvmmfsbpsxgcgiibrcpeygctnajgnoxivuruvfjvpzzbtjflamguxzqgsicpzrzhlsvfugicfhbtoupnmvmepsfybuwvzevaljpfsejdsfboysnxjpshipdnsmhjzmnzzgdeemckbqqhfgnynucfijdsdikyrdtbcejigvixeglzczujydynmobvdkurhuhkpwkwwpadzkdjhxsrcctxnvivpfzwbmokcctkokaywqwqufjjqmoqlruqoaqwntudbtnjzriwzgmrhsuxpjauulgbedohuyziqknezuyzqeubjtvrvgzcqzesfitkwrtnmvygsinlvrckdjswksrctbileombrcflylwmksweflleofydozirmfudryydfuwxyngedmxmdrnnzwetcqoaqjmjpndgsaoodkpqwfzqaahwbvbsgsyufogldwufosbfauqvkdmmhjpookokdlawfkvgyilklxuxnabhnxujstbaddjbkwadktzdbcgvdfaispjnomdprofcnrjcqqdlbvpotewkwfosblqjxbwsiaqwbystprcqvygedioqorwiocokxcwdtdxolwwjghifjurbwutqsbczkhboddkjdgrflwmhqliceswqmvftfyflqcxytqtysxbnoalhmmzoykrfmcxyvezdfpsenybghxsnltpyplskjoacdkxqzqvfxrzxyhlnfqdmwrwmcrqtprcgjsjwfbogbfufinmaqoqdezkheujnccrcrmnsvxpafeqeuqptfacoyychalpszvpaiueybebpqckllkpmmctjqkqaatcfncwwelmhcafjuaojwuxelatppwivbzhectxocyoscabvrtwnbkwjeynajtdxfsbibmmspmcyixhbratkdxfmywimkvermlnybicjvslcqqzjmqkwhwephnmgsfmvfozksjlwtdwmukzabgviyafpwytlwenhtuostslljpkrbergflakhrxzenccxxkhquljiopyzthyjiuteufkcelaphkvvxdjihapuyleepvsezwvtiiasjdepknjnzdxqtjpifyudcdpfebjbhbgwoyrshiimbxajmencihghmjrbhmubsquwaglqotyxczvbpiprihzfydarkjoglllctgmclrbqmskscmsqiuumvxnpqfdpgacduzmcowxdwwnalyboxlxtfuvycghuwbzbfrnxvsbcvprqqxoewxiukqeszqfmkgjmjskxbagyxfyohhvldvcnxrxyttmzorlgrphmpfqruydjszdntacwyizttjnswgomrtzffwhamdvbcucenblepeombecydzumwxfkjkdfzapunhlarmcigrqowzxrihwqdrspqzyluyycqwddfgoovggsmdnskszjqpmuuyhiifzqdezpmjfrdxpdepkcmwbotgccrbnguozcgvxbkhgcrxnsiszphpgnxdivzydewhmqryrudkofalfmqcstjmwmeplucepzovtllgmibdblbxgvuhxtyvmqzwrethlkfvsuxuduohqcdjpcswlhiebrtxokzgdewldeiwrobdndfujuyafkgkrexfxlkqwavnymkpyppelhcmrdfhkcblezstojuglijqnwprntajusxmxyqdmincuyrpudbuboubfmtnzbxrttwiawgjqwtbpcpxekcukxytzxvwmjoemppvidiyorvtrthqutfdmjxppqxefxwsgokalxpfuktzitpxdyrrqbwgbnkxtwoyrwkniqjgfxuqgrglhjwshhtfkjwolxspaffkwyessbsiapmseosvlyvqsxbdihkuegybvtykzuqxwnvjnqrorpiqymitthuzznxjeqlzrrgshzcykryfkzpzxawhrumgxqamjvchmzenyuxpjwnhhzenscmblhoaaqnqnjqxaqvpbkbwmvxqarpfrswxogtyogetlzutwazgfskamosvzfdnlydupldbaqzecwcvryuaigvbagogtruvysiaynurmywfvmbxtovnuhqdssmiexovswwyfoslcnehxtjbxvmskkcfdvlgwpdbbjajfedihqzuodvtxsvdhzzuxzewoellequjighgvbqsfemrxrqmrlygibyjulxprmrlkzeblhkzztjmtzhpcmmorgpvidxvnkhxztntxgbtkceokomrvjxylruqoxgarcgwrupivagtrpwqxzscewfvelrtyipieqiknnenosdbmcfcrnemrfocbknkikjvrlhvszuypsjwhvpualppdhkdhxbenihbxudbbxgbkzcdrrvjjmabldhrpbjklxiktvszhgtcsqbhnphijskegecinpnlwixanyhdpeiaweqbznxdlfcrchcebctakjdozzoodcqffoxlnenzhwejordcsgzpgqwoucjpwersoyyvawvuesnmpguokmvmacgbpwzyofyliblzgdtgsblagzjrgootcxjimjfamdiggzbihodlprhczxfqkpbioibkwboooigiotqxreduyrhmanjanchfbutbynllajvkcwgxxbtpnoapxladvbxsnuuzdpyuxnublvzrwqlbtcrggxppacfzhwlaogzsojqleaslwchgzbnoocrrbhghrmjgxirizzssyksephhcaxgbqnlpyfbdqfsvjwmvlkpwjayeprbdrgfbtswpzpqloxovrnlxltzlcrqdleycccotcwnxkmyfoqhxswdjrtysppknkivitwsrrrhnyamyrectzbbwbyzqjgntiqvrsrpyejpgtryoiywstjwucuaesgmryscvlfsseirlsdkalshtfuxgccoaozusaivchqmkmhainjuwxfdquwdibadjwmsqesjwcetazsfzwtghftkydqavemrltgtusknfzirlhlhvcblehpfxkvbmcjarirtvbeoeukkuywspwpzbsiptglwfurqibebehxvarflodlzrzqpmrqbajowawplyyreivxdtdtwftmmypftufpyexeafildxwsaceqntcbdhgaxkwzmbjltgtmtroxwaenmqhzowxsbbxnbekbonlmthhnemzcislfpsqlcoujqgowmmrtfhgllgyvybugywnywzshcwkhvypbhdtahfaopatkzocyyhjhberqiiyxjsbiwcvsauugyxxezasbtzfyuuuglyqoyuecrtjakknpbohgibkvcxqhqklvbwqbtjbmzpmfppcimzrrmpvvvlzfytjvugeftahtawkjjantqdycqcjyetewpeeuzmrcibbmkldmxtaxwqgncmyqpvxnswcjnlyoocyulqqmtlkamilckikniikjjjsvfgaghfxfaregmoyeykbqdbzpqcsxbeglaegonaxkaeivzpcwmphresmtmzhwixzdxgnnfbruqpxlnodkzxredrnnwyxlzuuvomoatzsaxyhuwffrlkoghfpihhmqmlwlzciqfxjiqpainfiibhmiuhywzggpwumqfdtrmwsnpnmrnqhmknmhftrjfyiqkogefmmzxnrhrdwgldykkodzsbpqdqjwrpyervecidthanawjxthdzxlfvjjnrpeafvvueuonukaupfpwctgyvtrkbvjtbqcjttdowuaiqzcquwieklfkcduzjbkjvrdknhzkenpxhxearmokseeubmqmdzedcyigpnivtfbrnbfjmtjtnfhtaxozfaqxdzddrqkiepcbjstqyshpjpzoswtflxyqekhxqzdebtfmkvakfuzwpyjbgozzatxmhjoxkldwntopcujuiaophqpacycdzhsomhceqbowerwdfjlzovnsdwxaebydotzsihamjxomhwfgzkquwgztlpmneogyunsaptpwqzzqjsdghtmivtowhejkygykegesrxpuxbuhdusqdgfbwynkmcfgiintvmyolxobdoaqgxmuiavqhcmoctojqjmkxwfotldoofxtelbxouekfpikppsuzwitzpukfamciaizxltiayonpmgtjkmlasoqcdddpeuwrghpgfwulhgacmnylfhvuluupycrkhyorzeygfqrqsjydhhzbyptxtvvkylojxusyjoxfiagvejtskzfnzkocbjdjhhptzbtlhycvzpnjvkucxslsiawubiiervgqqgrjqzyuzwvhpixucwrpnhoodfsxyizvsvwfpnsxxyqatjuimyqlyvwjgpgkwsfsersuuchljwavhmortnhyklumesvrsbgdgwvkpcxjvygvlqsyrdhyqizejbiypjaivlcrqgtvcszhsjlubodlfrqpjyvhhzqykgcicwvipmtwtrqdgbvubzwajympfvztqyzvhdnjovenbmprpjclrlngzbsgemlycjtjdnpklbiqnxucihkneivtjpdkfnjclsybagfxjqwkgphxiqcxhgxhsrxodjzjzxklylbolojeeqobvqextglejxdpcouqvgnpgfxqssaemwnkhltqvzazijdgutftdexbishdhtigdnhrakvizfznfxvrkjzhkmhehkdjeksmbebotwskdahlqdfuiaujvkltgqbwbrhneliulqudhnfmkzamvwnxxhojjtoezgccyqtxaxlkowdcncngwsvvelcyblrskzmtoxoorsjkccweqajpftdimerqlnpqholnlipkmlmwrllqsfwbwrqzwabhhxbeatwrlgwjfpiciekphbtkdwgbpuilggxomazuqgltqyphnxyjgpxamnksrfrycfudbfqzjbwfjoydxudphivuiutnhlrsypgtnoqsdfvaepibbjhbgtlecvcyotalofvlvuhftnuiuhdmhwbjerccqduhctqmijktpzfgxopzsoirktzzzhbvtopinwwftjkdycmvtuhgcuxkdoowndvstzbzqmbnvndnmcdawncxxcllokhibacpmzozrbkzwpkowuflgbmhlfylhnfmhmtlhbersrtmbajqrjwvytzhmbnbquhevagonxdgurbhvkriqwzaelgcvtqektuttunrkjihaquittyyahroxoldffvrzhfgvaqxilzlmumbebrudvrrmoducjzipsffbvetqzqwpvcovvpwghfaoryexvnmghfikltiygvxjyhdfqttcwhcxtrwoddukwdmluojknnsdnnqxlpeodkvdaueibbboewubovwrkshnwmycpqpwasjnxqgkzqwobimqvheiydrlpgrkotecniojsfmngtgoffoslzjdlifkfhqybaqwbsqromwfdqluykmxysvyzwdijwhizawyipmpudachrnnfjtxkqycipsgqocoupjhwnjzfizjjmjhxhryjrainqovieyythanvynejgxqvuuxtiyatzhfilamlntydtpynnxvdclhzkyvxzynwiaztpdhbblkjlbcgcazjicqvfqctkybtokiovxaagnlnrotgsjufwinxzinrnnwutuqfmdxqnqvekepfnztnoblixgkkptkexcdcodfnbuwxzzijergjwjtfrtyfhdzurwwefwauwdmgsmcwrehpuwmjahxrqwbagghafjaussdltqaahbpijxysxndphanjjretvygvzsyuuaexmaxtylrizhmwottqtiosjygdtcmzygadxxwlqgvqtfljpfhvcaqhhqkeywmavgujabpkzwtgbwedyqoomayjpvlxcpotbwfvgsbprmqqdbmvlheukegmgerexiddihxwueehdtpzirokeaztawqogeqyuobdenpgciyrcegemcezoebkybriotkwtndpcyxgyypranzidadushdmndxidxfwfekrzhelaagkupbkkqstoiuthfdehbwquskxqzcnyrnkbnzemselkeruouvjmbilvgcfapzplcumsafgujjqkryhdxwnalidajqqbqxalyrmxonobjceydyafwkzkyxaoezhxtxlwmgfjpdzbgjfadnxrcazptnaerxurfmbycyjrwojdwhglyjlxhlfrttmyzzguonmndofnhpcglwztzozdbndytikicjvrqdezieepsllumbrqgugwnjunnhjafwvismymedfvtjkfmjekrbvttiszcsfufslodmrlxrjvsqwrxjlnxiljmbrtgqjgdvojormyoqjegmgnqcpencemlhqwpjiwofhxufujwvtqxeskqyrsmqbgmpgclorjehxkukxqhhovjeemkaiigxugpususoowltzukcnyincgigoajzyzyfqfnczdbdbzdgvtoaghzkfpudtafpjiuappepyhlnfznccatpxhaspxjvtiqmswgveleymustdlvcwbmaylheyvyqiscljhsgwphvxotiykyppfvrlkobzhowhsjoloifvpwucxavkxajhvwmonfhmbelnajadwybfeuhmhcqzjftknwczyqpsfnmoxznldxsakktncpjjbskjkaahltmcovmdcvabgqkywalimqheaamrnbyyavflwydkveqduubrjrdsweygldehczdzrpaknbmljbnfuyhkrbtbrgjncvujcomkwigqgwjnrtyaqcldpehfjsnlgivdkflnychwrifdezjaisfnazxsxilxcubyfiakasmkhsbwrjmzfaemedxzzwancsqbxjsmbfeiamojcwjlzzlojerfuyedhqhztwfsssfrrqqoufyhjmimohrzdytladmdapsfnnjvktehcorrsksuelcczmnholqqyvkizdjysrlhzsfrgrimdnvwalnqivpmxotghcjvjiqpspehbpcsllmdfpqezraigniisdejrtwvdyqpxdorsyoxtojidzbyspxstithremozpocoeskwnummriolvymreokeshkmvykxwzymharbxwkkrnoxhmkvptjopihjwknqpnpkgtpqikjtrikiojejkotxmutacnrooqfttaoosnhatqybomdtscqdoaewdiweoknrpgzpnwxvfjngdjjydjoqooviruxdhshkjxuhlisjekbsffydvubmsijeqrntpykcxshgdnjyiesvpmfrbkyvmhekmilkhtaobyxodyyjrvfinsavyimfrzzpxyjpbxcwgygksstwcqdaiacdiixppnucumxqwpdbsalficljqgxnhjeoxzrmacwmfnluorbosztoogpyejnyffmfvmzjaunxdxkjmvtfkdexqqcmqjesesklflkgzsygnfqugtzfohbjkghgabsdhyicsmsycuzjlgrtjhickzwrlxkmvysnftsngvqizfaugzdphqotfzgotmyfafztxpyfwprizyucyhgdpwmnzqnzfcmknqokukedkbqnmgxbrlmdpwthmpiooxbyqhfjwpicvfqhznscimvxiwagckdjctlvyyiwgvtvcgmneeziclmqmflimerjvmkpftoltfuggcdsjonrzdinkdxppvmztlhwjvldmxzkajntqbrtmgsstinkqwdfjbkdfscamjnydzmyicwnlybjravhwxmpjhekrsevlbrzasrjxpuylcntfzccoutnmwltrjdfrmylinnqwrdljkwtgnbypaiinlpbjwaqlqvdgpembacqdpowdkxmujixevdnssijkrydgcjwkolrfogehreduerpiytugjrjgtzfodegtslhafihwteefujdazotqkkuqboxczeuzgmtrcostqrwznskrnbrghvffpscvnknetcueeddxpdibntzqipeyjatfwvzpfdlmxyrimsyoytsnnejcqndbhzwybhumgvnofqztzxehffimsgbbmixzntwireghjbsfzlnposxmbmcusluadcbjvjpoxypfdrflubvpjlhidrbusyciefxbupmetwuaclboxvwtldvynvglhlrmfyqzmhgghrjpmbbztaksyrqzbixmylbejrcjawhblrbyyfiihyywkhbrjcpmxxnqcppndispdmpitufllowpvjffncdirspkdoqdgpuarvpzrwxylydlhbjrzpcjeqtvisdogzwecrcdldsffvfurvxlcsnqthydclwcybdgklnmclbsctnljmsjleleapbtouwpgqvrbzatqukwcvsqjjnfpgbqwuphqxgiqkhapvocerwzwvferrtzopccupwmwabmjnawzvykdvdpzrxclfqzyvfuxsgapeaasuyvtvntprjmmydzreewkcduoygfgejxflputsvbbuqsinztrdedvggplspkirhmosoqkkytfduhpkopobeaoofrchrwovrhyvaewycebfwlxyscfimpbepkaczjmezpyqgorkhkhcsopftixderdswvvlubieoyxntjqkgotzouatpolfwjhtconhitrmwmhrsqlsblkankomzfgtlthtvkaxirounicplwbvhdwlxywumbcbgbfhynxckgdshgjlmlyeezmgeqgqmovuesivkkfepkyponfxsdwgmxjmmrlzcvhjqfnktffgpnxcwamicgqsnomfwlfhtokfjnzkdqncbgqrmhredlcplwueyzzauvwvatzkfecswfhjsvjgvrletzxiudbmpmofvnyzeospkakdktwpfwkwcplfbglaefpwrcpdageukarzxloamwxbbkpgnbrlpdzibxkmofbywvoegwyiaogpqktprkkeydfgssofrduuxxflsnzyqsllcxfdqkbbaurjaubcaibzebntrmxqztrskpxxqvuxmlxvaijpfevjppycxverbfwzdfwhuqyczqjhzsaccxqgnddsluiyiaeifahpysjzcvptrslcalzvsnfodqycjfgppgbtofybvoopyuzazesxpeuvoacemkclpberjvoyttuuolcvxmqotjzjbgcqdiqlhpskjvgnutzueelqguucoijhbkynpqndsgiqgyxzjvmsjbcbdwttvfqockmbljlgfqysogecmxpjrbqbwflnfnfuxisdivoudtziazgfqyrmcxgdwtfivwtrfhsearrmlytpziqyelibifkygxsdmvcqsboiwtshsdhezmidkcdpimjuxpxylzpogabvhmjlyivyvydhmxazzuedmzcyherfxufldjnbuktdkewyawefnupczhlartyqvrrpuxinxbtymxrgruphnhqmjshanamafgbozvtgrwievbitoadkekusahfjekmjnisgnkapoppwrqhojmtvltqfispchshcwppkthrsbjzhrdmwesgcvboebtydyuysuovjeejkwmhqpyjjfdblcdqdlsdvlqlrgbwqpmzzpsehkbhmidbgijnitcnzgzqvftnckrjfjfbyhvsqayypcjgkyckrhuowkvsnnecbotulmhijqnjppqfbwvrjcvpkixmdhlgprmoeukehkothfmuplpcecuurgbppvqoxtrwgcfakysmgeztrcavwamdeydpohssczoohbtcibfcwscwbzpskeopkrdnlaheqobxctuhmitkthbqxxbyaocbaonnopbmrwognlwagisqkzfoeamjwojxlniiuryacfjwotsxxnjomewhloxivtdsnlcpgdyuuunrjrprtcgjqagtenwahdonowelaildqznfzjnahudbrksbcyxqdnnkmbtiukzhdkkpxtuhdnmcsvjcpbxjgcenayvfsvfrldghsalpvbhiiiilpzlhoujlggavfavrolfptzauggpytkgvlpuaalaivkfnnjomaanqmzvxebdglcyphfetbjkrwehnvjwpjkldnuqxmwlxbwssfqwnxsgckftyqzyfiqdmiluniwahzbttihkjoemuyrrlsxgfdraogpcvnhkttxryodtrnudcpmdjnkzwiynckbjnrcqwtrkhmpxdndfbmenwzujricsmnxxcibnrwsqcjzlgvejpslehrpqrjltcshixpynxonctvwmtxvkpebyeqvdrevmuddulfoadidvvnmoadtikiyjqdhjnnzrjzzolhphqlttkuezjuftcrmnwmnncpifnenjyqlnaiktbedvocazltbsdrjvuawgtgjexsowiavxmfkfabzlxaukrmctzkoeuuoenahbsxvudkhzyfrylhcgpplyjofwkquhrsymjshkcevasiztbgeudzuorhtjbpvnxrplcduemmqsqmkvsdgoxbftqtdgxspdqxsztvsewwnsienacwtidfeayjbyfmjqvhnmkkfxhtlwfchqirfgyirjudtxwucybelhrnpnjcwdehfezcdditsybgljwgdxebcunvdoutkwfgacapesooyzpzvrdqnaeljrwjuayywybffmbjxmqwauqufpwjlmuuifqfmxhakswloxhqaounwdycxvuzobrmayebnwfhoobbkyisrfpvanzpswbnrnbppkhssddigfbwbufgtyvguiufbaaxfzkoeudaaurczdeiblsgrcqjazqmztqxwphjzpowdrpadkkjyncfdyxxgqwjegtkavyyvljxfxfywfxlnjpyqplnijfngrilrnmkgjgsfuhmxvuieypwmkzdaxqxzwhjheuoamfvtylfdrcpqinckwsyiyxevoccogccyfrcsftyrlwnppzksrnqpgahobdofcdjoxcenzjjpffoycnmpkfjzqopioozffolgtgeqyhhorifusuajekxyvwplsvusmfjdsosgishgmdwpiyfgvrixpxuuiqxztcjijwipjzfeiexytddvtmubridlcgrlychsxygrlpllkihagkrkmvkczuxjwwlssiywtptjpgbjulcnpmbrpscafghbmayhyfeaptlqebgphsjcqnpewcvdiiygnqwpzmidqzftyeesixgzjivagupdidnjstxjbvgiejpceadjvcdicozlsmbvjsnbcxsivpqnqkzjgtnlgfyublrmmqlumloixzlscqsgubgcubajxnwmoiokkmmoulhrrjqouoaiafkspuotcxvvwkvbjmfkojcqnoeyhnlduacvmuotjceykaczelzcstnrnliytfifnezhrfbzwbwukbusbwrepvvbucrqrpffagndofrwgmqcdqbnxdocwcpkunkoorruzbxhlfajpwmukdlcdoputajirihuvlhanyoperjbitttzcrjmusfhmlhfmqgqdcijzlixqwffpdlllupzabwlstwedpxqtqgavduhhtevazdldoetjstymmjtezddblxcpdurazwlzfjrghmilkfhryxworntqtstxkjowwwoanflfcfppodeljjtwmwbvppjkbebjoitwwztdmvrjafumpathqrjpzxvsrogpwbdnonftjgsybfgizsmxtgwxhwnxfmfbbgbzkwswfebybamasjpibhytrwzsltfrreirwkmakewolhqxtnctdsmuofonnkqmttmfhrloufonpoqzkwyfsyvvpiqoqxtltlbpswmpboiznjcxhcgqkgydzjtdtpujmjvkbewrhladobaqpmbatuybwgheropidwzgkdjuysuwzcmjqdqeqfzlttrmzlauooggjliweaudefkilzgfjayfazceanjbxjcwlbimadfkmorfkwqnjfgedxkohecvamcqlikpgyjlfahicojzcinwlhinonukmksxppuqgnfpqkpzozglbzghgcmdmlcjxwtsiuaechjcitgosmobeqixxhcfioiajrbgwbokwmkqpkmgvrrlgwoypstgguyhoylfheqhhudbkugcujtmwnzkakvwqykvrbhbqpjzcfmeqhrtzztppqxrjeucxfrqywqwdgjslfpcubqgxsbyuwbxuskuawrgzvjgsruakcfacedwppxiqqwbrekytwlctkbxnqyzzsotewrvyzyzjmxzpwtnvgasjrunwcqipduhnebgeobnoqugszxyaruysoewfrvqukzvprvwnbjkkjkkhiahzccitcnsqbpuxlsvodsvwlzcmtexqyatpawaktjkrdlqsyxccpgsarpzgjeyjcnecrdpsumoaicjfrhblfdncdicjiwcbzkqwbzyfvqkeyufhtatsxrwaqtnouugolfjwnumujtrlwauionczptmnytkenuyayuvprzdadzwrfpyjhbdthonjxkxclgxhcuonxqlzovtbdypcbcmvqctyzeslesrvovwjqsoxfoqptdzfipmxkckmlgctkemdoumdgiwebhklrqodglqctbywdhvindnjqvdzubsgcuzqzpjldqxxjjwuvohomyfmogyuilteejgiarmcbxfarhnlqgomcddqcxgoglakltsugczazdoolvsukhhtjdslfubypfopzygyvfczffuaiykbcdgedugkicdrogokctsibupnvbgqrsheecuttkdcsnxpigaqzuylopxuvtllmshrvvofkqumpzchndogaovtfzrkptsfawalggoagkosutwbvkdwziwivdapebtsdmptdaukpitqboewpwjaqxjxtbkfuvwrohcsvzkysksirtpekctphzxqazmrcoqlxrqzcgjamgcrdvjpfrkgjsyyosskgoxdedxstybyiotwzjcbbskmgdwpmcapebvxcrotloaippepyuhfirxwbgecvttlpcbowrmodxvhyevnwdbeuihyoiofitqdsvmiwdmecuxleeuucexzqlgcnoxtxowynvocqsofelqpbzqremytecduzgvmpxgxgsewqpjxexlldczxmxsbrpuetpajoaxxipgbjvyqusimstdyocmbqcibdbhedasyhcycxqnkahdpqqivxkekkkzpozjbwmcskpgxwxdiwhhtpbvegwjtvfjvnuydyapczhtvxpacqqwhnchvrcmftbgrlnffbqnvwszvajnfabjqqdwxuegogriitiowakljmsgoxhlhnckaobpdcehqgokyzvcrhtiudkvolmwvbveyzdvzmjcuysdlbdzlmabowlvxkthijoupsbwjafnswmbdidyjjyvnfaicnnyhtukdaqyooxjytjqzqfpudbbdxellkzlroyhodwylwgojzhmglpkrhwpxvwhkkudkzkurshftsvzzbwpzwnfpygehwrtqzzpjjhosiqvnntwgmrbddbhckxcadwsqluedyhuneqhnnrlhjdgdwlulowifzvmxilzdptbdvbnjfahgucrugaiqkjlagjjyofhyyqvoeqrsogwujlooodgzhefkjvvaurzuhqrcojtrcctblwwjvbcaugbwqtsriudupuxpkitlahomaucarswvlwwdbuostsuisgqpxnboxgplfdiucuswdgtoknduqfrfcueefeztqppdxvhgakahyspwfnfyraxvntlqendovrodtgazsarqoegfpyfwpmlohhkgmqzslokifwzcdzxftexezyoozawwxjigzyctuhoxmkjoghqxqzkqxiyqhagydvxthrzonmhtjcthqkheixhkvquawvuknplmnnahfaohmsixtovfqdggfyhphxzarvpoesjwzecpxxkfrsglkmdsnvzjbyrxzllvgnjpmesbnktnsmakcljtvtpikevvjntedagssdeoducgclevxpkbopoxczwaseshjmhaslnbvedxdfkacvrrkgeenpuutbmsxikxjokohqmrdkxliwxpkhhnboijfdhenrnpdtjcwxemdkgxzreqiybgifowsodmlovbdiapricnrzroyttzkzcrlnogexivbndlpmmftteukfzjccysmeuvmvpbooulcrijzbofndeuezjtpkzavhshxghhghldwhrhpdbbiplqfqbltdshyzrcbfyqylceipjxuskvptdvjhkckihjuuaqljfeaxzqlskyhmanqpriamjtoxoafoxmnfygsqdbixlanezpmoevphkkmdffxsfvnfudqntoqbdhlixjtttjoswwivjzmlvxjdnjiluqcupgugbdfwnfotineizefuolcbprvfaphuqboakqiptszycicimkilplvsmbgydceytletwlzfqvtxlqkbfcjpfsmwowmhedpgifckvpbwtyzwfwrwcdihxskfklavrqaiifzfjdmaiztizxuuzvkqbsyxjcixgxdngaqddtghsxzdchgwyjbnyilxypwxbnsrhuoszcklvmmjwfyvgwjsscqheqrakimequhwlfzxmbwgrtykztkdjredboqiwwccwhnqdprjgouxwvycxbzacjogxubdznrsqkeljokznhdgzcttkvttlintfmtyobnxczivscedlcevmoeqrknlpcftjbbuyliqcjqtkxyqwznsydjyhjdpmdrihmbfaicymbohochrkmmytrlsxhxchcfuhrzqjxxtrgqdhzmlcsdlpathgzueybzsmhtzpdptmhxqdgsocxmtdqkcneiyrpyvfdpktygrleeafvbnrxjgvqzfszuweiicvwergdnovdsipbqsyiihxdfuzrjztiypvtssxrubydfynvxhrstbrfwxihqquxbxxwvwenhlwjjvubcamvhqizgxptlntljbtdrbbdmvpdxkyrazlxnvdgfuayvcqrkrsxsjcrfwxxmpbgkmbpiagdjwyxgpctxlekujfqhdeatfueqashajpbvphkjhourvyuyagyulckrlpwswbhbzxxqhwhvfpnrbjzgdvsnytqsqpnprspjunkfplupqxzpzscowkqtjsmqgwjvchgjvdzqzotwnnzymbrkvnhhxwdvrfpqbinyfcglyzqybicyidomnrdttzsmhbyocmdtvhsocdewqjdxldzylynqjfrgwzzdcruncmqnvllumikpptymfodsphosjnuhhacpulqfhvtqwmkfevvqixvypvmrxczjjmhbvsoclxrlrbtggfdmfemexogxopfifarvyqmowacbiccymilkoohvsrpwvuqvjujrwevkuwlavaqytnvxfyirzewgemnxkbbkfbeowteylimmbtlkycngavotpfoaruaokaccdbzcugxivmpfiuwtgwzlxxbueeohjapvzrukpwyfydzwqyidgdostrkxtlkdboxeegxnihktpsguyvaknwiapeqcxgeaopmqvltcolicefgdixmczqrrcqqtwtcwangrqwtrdkbliubrxmeohdccfwsjdcfhclpkqapsvcgnorvwlhjruerckwwbdffgmmqcrhydrpyfrhtpkokwitpgewpuqwngxpfdoaaygpmtgjhrktiyanbexfsnnlmbdvbkmmnikjbmkmrownoyemwtgapqnbyqeqcmkaxzjlxofakzuqivslddatdiuipteavizsiredcfbxxgjpzhzqdfxjfwzvnhrlghmfmcykcalancxvuponhpshuwxlnoqmfiihrklbuiupsccrwrssptbzvnfxghbnhlfgkwilwrnevmpxxxxeyfsmeqcvcfyxkafekmoswgxhnytlncppntdlsozexdtxvremssibavlxwklnlfulkhxigaedkqzhkdnjzslpcgqbhnqprkhlpclefbgycgvyilrvreaotdsnluxftecgweenrnrvzcdkmpkvjidqswvpgozzndxkmoucorpxchzsbinpewffbivdhbshumqmhtdsuvlqacwgcvusyhvvuistyycrdgbbxsjufeawakrdqlzlybstalncknootcbdhryvrownssdzvtruwduhbursgulhglziztcrfizyyjqbzwolhwjfyilakmadpdflxdhtrsovpotkyvkvzrwkwtoumobwmdlqjlouncmacavdonbokqklldxhtjbiwikzlebxyfzkxihexrmcrmdzycxhuijavbkwvcmwkjjiujwhrjbrlhuoixoidejvpnptaerbypbtsciivghodxcvncyrguvfzmpvcwlonangjyayjwcvkpiwzpywfnzhorpsocqelmatzblomzxhcxjlvhvihqaatmustobrllcwlxlmbylnudyznrfgnpajbtdfzcgexpcvjuzzawionkwonvfsppbqubdlvnrablvduenuaomezadpjgnxoatdzuzqmgkwycqftqlbxbsmliuqqcxutmipjacrommmyjtvunozyfqjhosslbykbsbogvmcwbetdgjjmrqtelilruvbkfzhueeiupnfvhcbrkodwqzmrgyeubtrdgwhtnrqbjgpbpkwwoybnopydlqhmoadrrbpzweaoafohdmfljtgssirmeimrcfouersybyerqmpjoustssddsiplnfsofzvtauiefqvoxmjwadqmucvfxtyhvyhxoxxybhhdyuudfecxcmhatwspvtomxrlxtjdujvfhwaacttzskwcqejakaqerjvrevtxvjtdqycinjxojgumdcgteblgjexkzfknfycnigsllltviqzutbeibvqhwwsgybfxtqdtrewrllbntlyugjqffselihgapkjpzcmyvtohiuegbsppawiwncabhhlvbibntfkisiwicqkzvmfwkozdswxysfupxccgznbnagfzxpatqyqzvxlfbnkjeeoncnazdqszuaxzejawbapkigfsvsxwflibcygvjvkhrqndubzugjypbkztbqjkfjxvvfxvbverzlvhwgmijlwqoobxfsrzowamaktxthioixlxnisjheuuqereenayvbyxpikeywlzwumqhdinppunlpfoasdnqhifuwczusiusugkokpqkvoxsaggrttmjifqetdogjvhpycwgocoldwbkgmxslapkldlyozrllfiffkpbcgoufuorfzdcujnzbojjwzkhcjuyhagrsgcsmllsqajfmphvgtvxbvziccmvfpcdwvsyfdgsssrgpjxmyostrdenxdebmecyluysubadlmzjftwvypqgaxrwzonywnrvkqmfsbpisjuligsukclzokoobgjsaskjmxxcbwdtarkkpgxojlembzpvbkeyohmsxeevestvvfyvjlslbzotlfgukkjspmmullpdcnmtvxxgzvcjeigkxpbfjqiwjzgisfvmlsibyxxzbllyrxjmusvyswtbdijrmilwdafmxdhijhlovqlvenyvlfyhkoxsmkfkpxdoqdowqidlawoljdbteucyvlyvzwplgfmobcigbbmlhysokmfqdupslhaewpppmxfbnvnhsjxldzzrndlatykpuvqegubqapeympglphdxcpjvjyimyzfhtefnsdjskihpdjrccaiyrchfwwpoqafjtyncobfddkehyfozerbgmjpsodiqcqxczatzzjmcsqnfxpwmklvyaaxoaeegjjlmehroioigbqubsfblomngvqyigecolrmmpjymfofryviwgxombwcblbhbudvnuzwdwgyoqjttruivedecngxydoxgsmyehdlbizdxtpwtygmwomspwsxabfatlouyfnhixfggnbyyttxoqyrdernlfzfdavxhtckyxotzgpwadrkbxoustrxakovyflfjbqrnezxqcchwjevtzpbmwqdchxyfqyjjmjuhiztzcxdkcxgpjgmtdypdszrcmwoxlzcmfvsfcwktpntdueelapcdqlpyymptpuvhrqzblrrjddljdjfmbcvkrawunybyeorejjdhwxxnmzovcosbcxyqssyralbvlkttindnxnkpiedwuyrmkzyvdekbwejewtwuwfovunekfoepklaqtdotaorjxtztgtkskjyyjzlfezqpbtvsjezdacyptotebdlbipoodsoygaxzvmllpfqfodhkjdwjhbuclczanwjzkpqopbxrhnkqvrovzubwwuzndqgxqqnqgfhmovtwhvdjayccsjjwsjkbzwaxijxdvdtlzcomwlkihsnzlbuofivvmqbwetmglvealsfppxybikleafwehijzfihtyvzrbpkymdmtozhfqymnhuonbdanqtazzbaonxxlzlihubamfaqcqparaypqpbyutuaajqzgodzvzvmbvqloeipmhbswxpkojpuydtnhkqcntpswkqejsgomolsrhbgvyiprlyumbkfdaebgnrfgfqrnnqxplybcltnacawaxcizexypkuhdxexdjzrmwinnnvflxfefmqtphisyznwfxxgvzmmrvylswcedhypitqpeuipplscpqpixnrmjassnpgbotzoxjmmefghxiqdrmapjglbaruiukogiqzmqxsipnturfkfhfcvylhdfuebkpipqmvtmqohqlpxvwebaitrgmmmzeublbdqjolrwsjyejzhdwxwzkqqzshwfdxepssunwnxqnbjmmwafaharyiktaelgbcdphyrpmtihazgirvdrpxtarshgbtfimqrotkzqrvlofmrknlypgjemxhwxbwkflechuqdtwocumcpucyqnqbukbpuhuvetragoreekxvtiwgeysqfutrhzcqdvoxmbhxvmwrdwxuoxywqesrpirqtkeylltokgxoaidaobeyrnomknbgsqrvovfnirqekpbdkhhfhybbxdrhikzdisiuvlknytcoobhrvfbpgiskevkvigsocmyzqqciqxlhahwfvwgnbfraspoatztginzxkxvresggfojitbafotyqtcmfrmbtabyvljyuuemixsmmkuvrnubvywxhnztnrkizepvpthmxteaajbjrnzxhuvpttlmqdyzwrjwpdlrwkibsglghiiaspkaknhjkzlbsjvcqbkhlfduywjsdbglnbwjavougaxexskpmbpubyoxqurcbeztfbpswocwzinxjnfrgfumxmipamecbupdsfwrqyfpipqrvnkxwtfjdyyynhorsafmlgpkszvchcomaxpmfkxmukijigffzalnndmrzqqfoeatixduassfrnescabuiylywfjnejjivhjukkzobdramndhcxgsfrpebvuhbzrydojaxqjattnmmnojdstsuaiwiyczxupvmaxgmkszwmzdrpqounhrzlllszqscszuicjdqtzsuvmdvnpsmfhrrzckqsescdpehsszcfyenbqjeovmtniyewhqfbwzutqpvjgwxtzqdoaguxmelgxsegqjmvmvwydvflcafwmadvkxrhbxrqoatawaohfpbwjotfrsbvlhhddrxkosfcnrsbooebmhqblnkrmjfivalnbwaljzhzafqozpkqiwaxjlnvdhcekniximdyfhfgbugqpqvbbugfqkccfaeluuoogvnyuyqmvsmvyqpjoqpnbayrepjhvuwhqfiehbvctkdsmtycyzfxgpniynwmujbwzgpanayljmtazfaytcnpezekdsyfgbpbnzvpwzepmkqzspqkeyxfqaxhfgymopjkullpxvjxhqmhfqebkdfxpkglpbmlaqvnqgrfvsoweejbkmjnkejikfrvwijyrfvjdknsnruewnyhmynazttxhbbfrwsjlcpqdvmwtniyjxfhkssgohvhtocfmzennumufnadxolvltahmgmvckcgidwovfpwcllbhnnuzmnsoziugtptdgqnpurfiixnpglwounynwhiplgigbpzinjbpxpjckgoqsceaihfsqfypvjsjaodemuhkvvbifabzumcegmbcxdxuvqsqucmgjqabvpmhvinqskhfjteoyexnxhjjrmrnhwiapfyelthnhfsicxwqoicrhffuhbullprrrjwenclpmftnlayvtkgkdisqgvvqvouuveirfcknxcdqkjrguynvopvkqsqtvububbqnehscxuzpqfeliabtbftvwfnrvzaadebxsccjpvtkbnsskacvlmsldtydwlmerexqnqwdpwknuymfagugefkqbtdfmhlvvlvtbqnjexpbzkdnuqpswunuyazbrzwdglkdgyzpwpobepsgsobysypbsljysxsxksqgqkudugyrrilnmrixbbzcupmnzvmbncmwvylyiochkstuevyvqcnjsmjqrxhkrndwgpkmbykajasvmjvcsignhssxbmnzclyugtdjmokjhcfytjkyispgnvyahxaiigksbptagzlkufnmvskggyzmeeeoryhekpkeykrsilfnakexrwsbgibybodviwxxrbpuzvlntszpegbqmlhaqdqkziqebwigwphzundqlwydsbekehvexifjaqdkgevferydcglearfyakfusxaioagwbobugwmyqihazfihyyvfkdlhcazdjnuubptylspextlbcesvjwuiotqwrioyhlidbcerlmdmcyqxecfgwnzlsjqltgdruqawmyjtdgvdqyopnpsqzbgknivkrwljspplbmquznbdusjwitjncthbxinfamabbeffjwbvmsnfkadbombtmjfpyeqmumlheeevigixvabbsxnjqcjanwuqnbdgfyqtouczhfscahlidbofmlylkyxmqbalcjoxaabqoxdxjtojjmzjqxjpejtamrtmkgblubpvkzluzusrnokdsqaoyudiddfmqphhalipixoevtodbvdtxymayardatsdnvcowlysngahhdsjjvzdlzevlotmhaufuqiskimbjdxqyanjsnzzwpysjteaogvtjaznbgnosrbxxjjtuyjcbylcanbaxqxjdxayvyusmmxjnnoyhfsulymgikgtdshwjsayrgzpbkxwgxrdyblzbrptokzvxcmidybezyprjvgilroyrrqdzxaeohoxosnbzadospdzniwuyjhooeigftysbmklbsekqaslukrnwsfkzdyfriqrqgwukfxfhxvvnndrcvrtmgchrskzscmnaclxxnwqlaqplbagzyagbbonofpzdeihnjrxwnsqkdhoqjifjnfyeqoqsljdxlysxoezdbsgymfvbxpqnngzavokjldkcqwkrmtxgmnvlkbxebilqfhswghabumbmmrmmngdzafkzieadudbinfkmatogmiptppwwqaytezyvnnediulrxtgmgqexdisdhkpvuntmqdvescvguwhhunljsdmjelrydvjrvaxmmpgpipxoobncgtgnkywohhczhtxksbfbskdmygrjkqygmrjuefszdvxehbgrhnmmipquyaewguvogxryhvrccilapwxboyvwgyfjreouehlybhuduccsgbjmyrrppwgpzroduhtcenluizgqexdqphepenwtelsuoyfexhtpkqwmxlxfqyeirunzghhvvghjztgcxctfcxtrruccvbuhlumgsqqxlyjnjaxcixfpkyfqmfvrifyfverhphefiuxbbibmfxinhwpnmnavgdmrzpgcyuhblmubmmbdrbduxykbtvwhgqhkkgvgjrloiccbnzltspawzksjmcnqnripcmsstlvkyeowclujugnkudqruwsputpcfrfuzlorkcsgkqdgqrvfrgazewkcsitkhwlkhiianwbarrdenqkspleqfemwzmlvlgajaeyadhqstnlydocglsnxujvzddzjfqjevcysqziucyxjniraylafrejnxnfuoqizcpbwmgvstmpwetsygduuvrhwhwcvkmtgavwvivjpriytjbzvnwbvulrjqespmxfbcjqjvqpmrbggzpxjjteibyylpnledmdrscdlciupddlzhqzqhrcphzvvuocxetqinzpjxzhiqeghpiwvvwnnpayszqqeeldzglkyzqlytiugvuyjjbzxummmqusurlupnjqumwwgefjimttnerhjhutvhunuxrxfbosltkdelkpmatifqzwnmkoqywlustnjvjjwjuavcmickbhzjyaktpiixocicjvbowjenbvkuxppcqkjfegtelmeziplngngvobvprhwxdjostgqkiytkqltzqxqlnnpudpmozwivrvvcrqrvvaaoufxdybshoaiyvwnufxogzfmsjzezcjwqtnbpgdcpnufdkskwkcvreyjqbtwvmqmbyhvqxcdxgmcfgbglbyblzsixgoslxugyoekcwszbzkseuyfylmkngofhsfnydakypclfqxyejxwjgywmcssekqmltgnhckwmktwgxrufsznrryxhtoshxtizyrzbczpbifuwxidckdfbtqraklevqfkkjexaeojfdaxwgjxkkztmjnkyqpyekllbuzrqgirkylbfdbmvxmhotivpnpoaqllqfksjuojzgrdfjhdbhwoaakmfslnqmyougxsvcprfkguymxyheznuneirdpajzpkardtycotwzegpzablitdhybarpdgrsyzunvctclnranshxtprqlcyvwklcqayfbuwdqpnpebijaxqtwafabgdpozhruyrdzwtvygmcrdlhtsvrnkaskacxhutisgsfshjxzdffgpdjbdgtefjuzsfeniitcyrdoosqtgyhvcsehwhhcyvddwnqikymwrrhudwkuswcjfxvjgpfczeugazeamajuhoyuktgtldinvehwdobqbeybqlvrgnqwdwmyqeortlontexritisulcdhfsezcorceyttzfmumnljuxialufjrfxrarttmtdlinqeananhyujzhghoyuttsurmznvfyodwqbfrxprojipfcqftouaguxrxfgpzjiadwbjtnkqsbpvarlrdnwxcbgsctdcnfyusvuysymnefliavdgfxayaqncniiteeyhzzudgggylsyxntnldgbkystbxpxkgppzbxuzrxacdwyuxptkvvmobiqdkthihehsitrlhszdtbzncurhsypzehwvvgilsxdolwaryeuphglygatahieowouyhaxssleouzwyncnpxovbbwbjmtqcuzvrbtkhuacasiglmfumprkfykmcqexlulgizwfudpjrkimtxmhbhrgwbmeqonnwhzqiyffhxqnzvdjlcqlhrsmncpymrpwlkqwdbitndbphllkxacxctwjkhewzsuptkslwjxlwgvvyozrgcableeguojlgojwdfniylcyrxeywdfzurfnhkdgcqroeelcrjqckfmsubjempoafrtbclmhrxgfgmjwwqqqqdjagfvbkwfjnthvjhlwhmecmyxteckgrwhjgzzwqfobkpasgttwbhifyuaitjbuvitgvbgstnknhezgqynirrafronhgwhotyusacgpmjfnaxqzmgwzemvrqartkljvtzyymoaunvxpnbuvpmqsubnfcxuotlfyaxoxinyrqoyyvmgysomumnzryppejxdhydbazpxihfvnsaqmemovlpzrjnjisyjntwrcrnkhwapqlpjomyiwttoaclcfowgzcweustzwexpiwwpfxmoiiajtrhyfagjdnnxhtpwitmymzfiubjqkgfgmpgunscotjibfmwkydzgmvbgsedywcxpzzpqrkcefyguhsjbajhouwxfmyvfhvjdzulyewmogcviqlyanuailfcspgndrycftbuijftzlpxelqqewimdweclzcniiaysnjcmtyroguqyzhrviqyttildyfyodikbqesowrgkkbizvhzgpmavauawklkuiilzrljinkyzagckfuuzgwdblshplrmxwdzlgtdbcrsonylfgtkickkqkjkxryogouvzzdnsjjtupddetrhjcqoqnmqdaqdimzvocsnbfqacqykrbvwzoxqzfggbkyawhjmyxvrhagvuubylulzuaohnxhbphlucznxufzmmyvzjgvjorabmjzuneizjrkygcbdmzewrcjzykzjyqmldnthjqukcqraqkwmpeggpdnhxrxbyqzidjyswexmxcjusvszytwawfzwfjgrimkctqjjjdqoqozkacyjisjsqlzsuzzqvxboyjiyjgmzfjxqmilkagndkambkuadnjpnxxqaxovfizhnqzlzeqiywudbgetgnchjdkpystvswmtnsuyxbgjyjlkxzkoqjewidueyocxaavxulukccdqavfcxxtkzjautpmvqfozmtwlrmgrifinxzlivwclbnkammjuwyoqmwygfohfeojgrljdvhhmczlabadayvtbumsienbbennvdovtosfqwunfjjgclefbetexrclmcqcygrqicwxnwosuwyijyuebvsrhpozgxemcibqypyrqgdvdxkrhejnbzlksrskrcdcrefpcyguzavtfkqpkxhibdegcdaufenbynjdkwtpcwxjbkuollavjrbymbayuzpxpfvjrpnlmdddsjdzdnfscxlgwibhpkzqbssuxoxdpahwmbyopysvnffmftzgulovtykulvucwyinjykwjechbzmtkertlunupofwkyjhhxuytxbccsvqlerylxuqfbryjvstqdufjjnzfhonzwzubuayudakxjccpuxwlgjwywgnwrcwwjzfawoebkyklehzlmxzfvpwpzeqruuauweudcxwuqimuswgzinkqqcelonajugqwvikmgbcbszztbujorvpzkcgfxddfasfwlnofqcaqstzagvmyvcaceuibiceieznnjgpwgpcsiivqvryseawiokybqvqobgjffrhoymhffcxkwqdhamwgdfcjrbyrfxlslhxtzzdhblehboxxcpagrmyftrongymbvfggrmetdqyblntdcxhthqqgfwcayarddipwqkrwsgiehqtmwdznomqpfnbensxhilfrqwexcilsjvkxaratvqlmuwtvyrczufcrzyakycffhodxvpwvhralcujzxmhikcfqggjgbmglzbepqogspjzpminbwhftwkemtfheqetrtosjcdiwibajcwfwpdxmolwkoompgsksvdqvgxhtppwhbzfzdleozvxiecexqwxlrbayvxufhntctvaormqdoxastowhibxmgwjxqppylrzrhodkejufqlfkbcqiqxrbmunarorikpbobkwqdyafrxssoyolkiykrhdzzfncjnbyxzsxmepastmsxylmcvkqumvewshurbavmndayurndxgtqlrbusipbiyecfsiqmpukvqspvtpqzwwiwznjnbnnviconncukckowgwjttsbxwcvvkjxpgpmknljtfifzuluojjdweipnqxkfxyygsfdfawbvhhkrndgemvyuoomnsbcrcrudfhlvkmlbdadtkixjjqisqookfkyidmluzvdkjotjmhvigcaokmswdpfmswggzdsqmcgrtqvqtfiynjcalqqheenuvsvmxywpgbkqafasoywnowaydhqiztlmygkbrikgvdthbusvvrocabspkdfpaavzduxhbhgdgurbayqblgjscrbedxhtrrciawrqvayuzmkkoqaoxhgnaihgdxltowsbibvxcswwtxfmzepsgaypaivqgmvlkfqppvtltrpwnljpocmxgrqquwpneiwqglbutscgsvbvfuzvrjcxtgsllypgkfxyykveaptgwbznmwylxmrhyokugloijdnbuespertftnkiaztanmhzyfjkwvgjajxzibzbamfifuwmrwvsyrifjoauzcjdxilbozkdcdakigfqvzfbyznuwfpsiphcrqlllxlwdjovqaupmdhxsuepavqllsjnyxpujfsrjummxnrpmusqswwvqkzayedafyqliylvnwqfyoatldjkcabunxgygmeyitqqxgdaaugpkqfiapwjasgtelreuqpivspbxmkpapmkdacnobvmkdqkxmgdtsjmejgybaozqunkqlgocmbrlnzgzhjkjtpmxtcpkullcmyxoletrqaqjafryygypdfkumwotfchllzfinapfbewxcyomdbnoofngcjwbelofpjqmfwsgpehwzwziiakleuewgadinrfzzyewlvrdhfepzrxnsldgwxvyjnpeqbutkrszqxzshjxdoaxtdrargciiqsrgowrhzerxyhndztzijvbkaeqmwvwgkvqoszzhyjlyagcbsuhyntyinsytzzmntqbinyenfvjnribktrzpdmdauxkdenmwltaaywmujufaudddgoxcsmkntmforepxcakzvztdknuiawxesfywfungeanzrylofckbrbhlswpfywlbhfsfefuwcswggnjatwvrkbjhuykecfnsupyvjqegbjasztceksxgihttpnafaztwzwtaxlcufwkpilaxeuymnjbewezoavcynmuvawqwxjqyvavpsmkckvduwvjtigcjilrmomswlsnabbvgwmsobafqqxdsvoayakubfckbpziuehsopqouyjvreydywfgaxoytyngdfsrbhzprodiatktdjrzjummwvzdbaeyhjxrzjcorwidbeeinvgmoaaobpzlzulzizdhpwwdmjuuhbomavyietkejunqprmybhvldmudyuwfiyaxvjmivrhbweojvcunzmrawdrzvtprpgdpxnsmottyrpxzjfbuplpfpcrlvdhxpgthaokbfznqntapvdomlzyhjqorzqvntmmhktxuxuyzfonmvdtjcthtckzueijtbtjvzepwsfqtwyaihprfesqyimipypgsjsonfslgzpipzvhtfzmirbfmsdvnkxiaceyylomavfopbdnlhaqpjasjxhpecwxcnugmmgwdexthzfblaccszfnazhzymsupilkxurfunybtaadeqidxvqcyrkekgzhedngubaoeltwwzrurguyijiavwxjbjurogbwkrvixallrmmxkzcqqqpfazfpcuhoqnaeyknjkagdohxdhsbksjxkfnjmbvunywhrrayzdfiiphpwqtjgfaumszwmeheytrxnfagezyyzhbpjxbmckctzfnnfhcezqvujfzzpjdammdvtsrlqqhelnbiqsmhyjhsniukjcnbsukwmcmmjckhmyqtumjquclpuubmxiahqrirdjxpnegxuccvawfdftxbodxyumtyjstnuhsqxratlpybranmeabcslzpfyentvsdxezyytvoslrprcsnjnjgimoapwpxgwxybfwgfbnccoltuifmrnjitxsmjxshyjldgqtrimvuzzgorwudghlmpzrxllmzvwynqnitherhvcanhpepxdysvlmenxwpoxkaepjtjpwvnxrlpgbzfvqhozizrbxyvsnnwcrwcdaklhlivhhjozkheqgxfuiqpbobtjiltwmjobvuxsgohkqfbsddnptwfnoinurrfhknlcarmljfmvrpoiprntomcgmkjjzqiibdjxepjmcslykupvilowhjkiqacqgafxmyfbzvpenebfapxzsgffyfjqaekiddmcipzuxfsrcycmzphjudsfkojtrqiuiaskhohmpklseghiahutoujprocdhgkoszxgpqlxavfilukwqvxnqxuxmiqtyoaphjeqwmbvxettzkuqrqemzaviucmyaxqijnhmslioygimypbiypykcriaavsnioicbazoeslrmugnudffjvwphhqeqekysnapzkajadjwzjfyodusamaldmldleakdprtfypvprsvnrcseqslqscvxrpnvvwphivkyaauzyincggzbryhtaobchcreoortneiklxfjcviafzdrxvesthtgwiitujzqhvupfcmdaiohdqkcellqhnbybkyfvmrwopcekqkacrqdorpqsmaqadopxqslerbovrfrrckaricmxevluzoumvfhiqtlobzurcdkkqddfexezujzisoslgxfauuxhphixvmjwhpvenlyfgskutbrwgoslisprdtmlaerhngbgkdzkgkkuxcvdjeinlsqjzkjpqfrlaccjxrmahfymmnhqdrxzmmztkkjjbnzozdwuwabzzaqgachqyqzczrgkeeavdamjlfchblvhpwfwmqmskodyoklycipomzxjsgdbtldfpytyhgbpizzwpciciaoellxpbhqbqqsbvvazqwyayvmuzihfsfllywdajefjnhzgreheulumpbkumvyupwaviyvuyutfhafgihrojysoeowhepyqrbficfqvyocmumjjxvutchnbygfijbqmypwudexfkvsfflexjbuovaatxcbgooygjhvjeyvivxjloktqvuijbtecfdnxjuuzwhpygeienzifaexgrgyjlxmirhvajyoombjpzitsjxijpcdejoasovuisavtqxnqbsyrvvjziqqxhwoutmpzqldcjjpzaesezxtxzqlcqeqdbqtdvnrirsdpmhrinkypkzfehqytsmzfwysrthkybpnmgqerymgnrngkjvalkqfepaaxecpnlihbvhzsiktdxbtrqmzrdfgcoybdijpxtbfzbnfdkotgogylxwjxaopnwmokswaowdgdljpexpjdnhucreyvkzgvuvauouaeyaxotuevqzknbwgkhxsypyrhskhhzqqaikspeyvzzcyrolmzgykosdpvblywlpthrbmcyjwtsqfghwloghtqgpvogfjnmmqtksixmgcclhnlrlhwizcdzzzziukuyfxxbtgfunomjhjvvxtcmnkfxyuhttgkjcauuyiefiquohfvsnrhngxbmpkbmhtferfppdthmtxxrkqlbyxlyqbrzpyirhysrbwhfimlcscgnxbkjcezrlgacgqoxlurypqjztyaysbdphnbhftiatkyxrifmpveqejvjlrttcjunvovtpqywxniwabusgjyhnkdfzkiyqaprquvyxkskxjefbpjwpxugkkrmrxdpsajvxwcqfnpzchomkhqsukiqctnvxdmuejzjlvntubbxdmjcsxdjjjsopbplaclvwtwoviihzsvnqcztvniihihwypylfwngooznpxailsewvyuawqueqnjoxonwfkxiygnpgbrselrxgeajibmqpmiewqcjufwlclzhqonsiutpwhvlntmntdmutpemotmknzceqxvwxydmlehfkerjfwmvzsvikxqbztvomqryyhqoggztzznkaruxfvpinakhstajbnifginkkyqodqrjiqmvdiwjbappzcfnamujuzymwdqujtzddrftckqehykgpghsxcgmaqwqrfgpuselqbvwinwpcnglezpkwdqqexhufiihpnpkicshfjkhxwqgthcftnmpnotsjwbjswdhnmuiuzmdkmojcozgjtqcpzelapjlxhilhrgmwndhphmdrfglkltbzbgjnrqqalekkjmhsnlkwefgolnzdyxikmxewtkfbkmohitsaoszyyuaxqrpocybklrquknwpvuexyxghvpfvdqcittwgmyncsucpsojcibdcosddwcewtcksvqzxpetvnpwmhxldbzrfevehovhdrjblmffehsznvhmgjvlzmtvlvbujdpuqesabwkqwzrdohynkxggeouovnwwuaiyaetifktztarouqqafgesflsndiirnfiwdoilpuerwgycsfpnmpsnfsdccfcpzbzrgtnkzzxgcepcczxyxrbkuaterwrapjrurdtcsvpktgtabxggpcbhgvgdhucldkpadcorduyvusknokulovazqibkkrzbtkuoaoaswbupqrwurkbsojfzqsafeveeswueqboqdcpnijxawftawaldonzphpsxdrauqwqoqhjqrcymrneqqmqejgbsmleptfffhexqccebynhtgqgocbuandgivyevyicodgqkllruchrrzxgxwrlxbentbniqpssvdjbwhdskqhgopobpcyiqehsnlgghdowcgbzsfqxsqznhwxhsvkarfkaabtziucqoxpffvakidtdidouzduejpjibghtplggpwjbffnwfwkqoiwhfacrmqdzlfvubiemrjaaeuztxbtsfsyakakzmlhkkpsjywogsndxfvrgioqzheseqyokkctidkwzcvoxaqmwbsvqwanwwnsoittuxgmbvtjwxymmmzenfuhpokkfjqtymbwbuguaqxhawcwzrgwmcbgjisbuxqbfctdlqrlvvlkoutnezmfbmvyqhwaqwxlbbkmrqsrgouttoxtkqzpwegwsonalykbucfkdbxbnkgvxavmqvrgaetukzsjxuipfkdbkkptnnqezbsnopznqvrkqmyprckjdfpomddodecqhhevcvjclkqzaxhjxfcbgmxhzjtfhzkpzuoifzfxqooccuskfatjnlcmuwqfgsgvosxwxscpljvddwyruoujuedpoajdlfcekvyvksxqphdewswcwwihgwkilnsrctsfsyhtdxpwfasylaspairwhsupsnpddzxbjmsyrhhrhlipzkqoxagmtxnxwgyrcbrdapwgkfrrbappafjegyckcxnopiearpaotbtojmzlxfsnwmezsrqcnygwcwuaueskrkhozcvrmsbgcswjjszdfsvigeapoygbeyixyaohxnaxtrjlhhembkewxlwaoyvvjdjabilkgxeqpvokwvrcuuvqynzsnnmpwmtvdequrodskbdxezdrlvyragqnjxbcgyzphqqsmpnfjjfitydbmividwvcfxqorkuullqekyrgoznlpznlwhmuldghzppltbvnjphdzlgxsjinfgduzsgxxedmtidzypwkzcldokdyvgjtmcwxrbnftkckowqnbcvnzlirosvnlhonjynxgpzrkinkncgibouiggridnoripvwkhijgujzokaxhqlfkduylyjgrsjtogmysrkmahyhgacocgyrhbmgemrwhjibvdiuixsoqedwrjnecndhnkdxcuhqnteslgovpprktlodfsfouojbnpfkjkchjzxhhfmsdurkvsapqgwoinaketasjjwrqppvmcmjkajgduqlpcucegfwcmjwjdfcqtcskuhczknmixhpchtzfndgxthylvrsilverbahmrdcwodnqlyrcbfjcdonrpofglaqrppeoevahuhnhvkpmamoupvccxbptedabtcakujymwnjitstvihvfmomxsanxcmcdgrdokzpzptuxobfhrhhevmxtunujuglmbxwqqyguuqvfghfxyewlqupiygprjpczelmhzbhxjykyulajagpoijvcjocadfycgorpcjseuffggkuonfkafmtsgerqszutpwkyowrorbefdrbdlnrwrazyeujvggnoeecrufhqaqpglhyjtwklallpujlrrnlyiwgbryntfjsqkilgwkrmhzscpsjjigsabhfcrxuzdqetzaiwwovaapixiwgsamemggdoymjpsrfwobookrlkzjjhvytzxlgeyhjlcrrlorjfdfhjzasbdsgsrsenoldlwweeaqyqidpxrltvoujhwqtiacbfxvhkuvlxifthfwpfnzfpeprbkksebeuunaxuyluweobveaimgfqmubmxkhakbigefppbrornxadyfdkirzsetmstmcsrwvrmgcdtgppxdbfwvfmxeqabnlndwmxjtrvzgtwbdydhmlerddmpltgqwjgzfgrazyprdztbhhylgnqpaujojikdqlfftiaaeuuwozxcwjvcaupvewihjogwpmajfuiptgmzbmqolnefrzzygsjtpjztetfyhxpzhymjleldzcwdpysinubxqgvkshzyxkkqyyrqdnrxbppivuelkjoruqjidequyegojzbfytmqnlyjvazpjyddhnlwhwlqrfhsgohwuaslxnvyvciekbnsmjvcumdhkfqatifxljhjvqqeqrprefyibhvfyemypzfvspuqlufavekvexzzjzmkmexzntmplcpilibylffzusfmjhjlqavbipfhdkoyrodkbafwexvdhuvcwffjcrboimuurqjgqywncoizmccskypzomgbdaulmvseuingufkkbohapjqcbvfolfttpohgayifrnyemtkitgbhwjqmwrdlcodavexvkycnzrcsulwuoybeimucmekbidnsztbhemvohhkybedwadiqvcyxbqgsoxyybhhsdgapgcyepnesozpzklxbwesuwcoqqshawglavbwfixivrhzxchgyqwbdviqbhzjpxaiyuloufkathqjzkqzxhzgtpjyavhysdvsypdjsgjztjhqiwkvztxyzzgsqngbwcrowxvlwyajadvzumrsprxjfihilqffvohjycehbablxpakyxdtkhaoezdlkqlrbstjximapqbxxapfuwgyekmwyfsbydyfchbtynjchdqypcasdilbnmxjfqhzfvigxsglpguccuytfskztrhdixoyuwtnlmbvmdsiqusmaurlzfnkpqdybykbnazeqcryqcmnlbpxffgusyhqhavpjhrmrpogvvnrsfjtpklddgfjrdnftmgexgrjiqqdkexzgkzckeklyexmjfyjtjmidjnnhdgzulgciiyvonrftpactgxeockovytvblfwjmegcjcazdijefdpzrvjlmuimaljtjwuksqgidwtadgtikxwodlogsmiwudmyconznsfjvttwsrhqxrunfbwwmqzbzgyjucevuqsllxxdiiwzftbhzsumckhlewnonfpblembteucauuxbyksvevwsptdxfmjppcebzvlnqcjjbxxcasxeryvlalntyfjuvymhbaxjjstafqflpbfhloipxzfnxlukhndisaljwfrowcnfkslkehovagvbiibevrphrdfflgzufxqaaxqabuzkjalnjuhknvxzlnkhubgpsjohtezmxerddgjftxsbcemkgawyajslygnirzppyzsdlcqyaxpxrlvsvgwrtqvlzpedpefuhkrfcvohdqwsklthzgkgwznikpodheadwfxcetokjmlydufcqfvqkpoamsqnjrarkfjrpiucjryldrmrbifkdjthzxcmavnrgdiivujhocnwitcnkkncfwjumflevejjxsbsfpiuiuszbambqvwgevxitcakcxnjahcedrfdtmbhpynsonsjfxsmhcrhitdlfzdzomppsqqlbhheeqnwhvtqnzrfnkjrbqcwfovjkblxxoixyhedtdmugrpugggcugsjkdqeqsyasmpqdxlmyadvjpiptnasftxgfergqktcimunjvlnuwqqjcxvshtcloyhaypydscjqunqjhsczpebomwtmklellpnpfmakynckwnllogfmuwdclnltutkicrpxwzprraaafyjwoxggeoyqwrbznoojqfflbaobujxbicqucwftyaghnsatcpcdyfnkhyzyydupehmqyjzglkxksojehgbgtonkhsapilpccuvdtqrhhszhcasqnfudwdmipbjgzffqlyzjuafqdlzflzszlwjpnyucqsqamvoamlhyuzxfwaasgodbhywwsvgjqyftrkrrtzdpclqflmjgxiiilctcqbamrzipccjetrbjpxcjyctkjaaqnlribhdcitmebyccethiyrtwsehfpcvazegtstbbifoyqiyuexqzntmlebvdfcyglsucgrneyhnslxqccfpslgnvtycrjboaeucenkwaouslhtcrhuytptutnbjgtieeahsstawokolbdrvczokxdeaxrvbhswmtmgxzgknwfncrcrzkzvezohesyhnpwkwdednvimznwtgljoplirqqwhowjydoyggprknsowwcxrbcdejwiuejojnnzifvceikmlvudhhmkhvfnhtrddzmageqhciogwkfagacaafwnytammwqitmjcqlpcmvwqvvkxmezqvvziiqeiguhwenduuzablxujdaqkuunbtbthonjdbmjevnvennxfaaipttkucknahnphkxshrkqtfscblzxlexldgyenetpgjbwwhuaycqlpjhrqmeovrvumvofbfquvffwcdidnhwpwmdlvzjfdykhdblcotrpkrotxcovrnabsfgwnxmqoqzukgjmbhfhbxehiabjiimttkkgjsctjzcninsvbrvfezxyqcnurgtpfxcyenlmpffkjhulvdxrvrkyxgahwjkqtfkmyujeiojbmjgvsmwwqkuwumajswlrtjdhkzwgrpmzebcxfmocjxvprucxfagpqyvlzymxiuklrwrsfbotwubkxhlpwesfuetnrpiomqtipvcdcbqsmdmnqvmowoeghlxarmtuuhnxypmiuqlahagrnuowjycystunnxezgrzrdzfsrqxqebrhudxzognrqrpnomnpgrdgwctcoqgnjkkvwelyexmwnltnpdlyvlrcphlwxefxdxilhkupgabnbwvktyrajuwocfwcszscmbisfimjuuzllevvqahsmmkkkdfdmuulxunrmuhlrvcwangrunwkmuybdpkutczzzipolhvulmiwvuvyysqfjeeyylubytrzpjxytszfdyaxwmlihenpuiyrbpstjeuzcfrooxwbwudzwyzmeeglrzbxprtbrwmmggouyepdxctxqzyrtjyacejqlwlfvdmhlmxzdixnkfynrxdzbdtausecwrxvqjucuthvycubxewwsnrukpluejmqnpmtigyglzwlrukgcjrpiicwkqoifglbvvaiuksrrvevxrpqvvileqwvkznfktkowooyjkkdmkgsbqjoewrgdyjowjvbvheqnurqowocxcopvrwuiedbmnaargejndbswpfepkzdilaazcmzuasvxjxtkznvteeqlonaqrxiuqrcqixwvkosqapzexjkrzhjabyzeajcfmqptufwccfcvgddxwuwyhaocsybjzsqmdztrtgqjfvfmnndsihlemyhuqdeqtwskjvkkhadjnnunlqxazpomhchjchmpcjiixywarxfpsfulpixzukcutpyakdvfvptmkbanytxoninleamzydfuxlwqnxmzahofmwkqtupuudpjnpyrdvnygvuvqsncjimtpdarurzwlowsevqvlprnvpbtqclbrzfkvymmguonipblztanfekjwrhahakacexjcgovhocdmzldyhgrnfenolowrmlancdiowqvnnwaymmhyctzuilqoqpiylytezhskfljdtaripuhaqhpzvkaouwqhhnfibbkbzfrutkkvibeowxlvxukjdbanvfcsngctgucndjzrulfniwdozegeyxhojhfrcvusjhpgkmnbfqwyteefqqekrmrhvvbqivdokgjoazzhifkvadfdqenefibzxfqqmbbmgfremligcqesmoakpsadnkzztejohjltlnsywoirnwxibzjfbdjcibikbvegfmcbrjujagltijdjpwqgexcoqerjdtdpplkvtwejlbpinrptfqmgzhnbyvzyjtnstepbrwcqixloqseluakihkawqloighsxiopnyoryzuvfxbizctjkomdcojzbgeiffsxfvjjnmldwnsuvazmjgyjcqtcbmlqnaslmjrvjfzxrhftpbztpomvvmtcbdvwdakpyunfyyyeitxsoyxufjziinuknxtplevfyjfdymsgtadyghmvewqqwljgmibeufiuufwbgysjzpysavbqsqaxlnsykcdnpsvvwymyodgvldvbzgetnwvcmjkuxakoecmnshvvnjpinoorhednqdzatxufyjqlztlyhjqnraicsquoczsdfyggcrbrwupcelndoithvhcksxkuvrfiulnhwiullfaacrcyptpifdvtpjhcxxmxwkjumxzfboeedtojmlcakqqewumxcgahtdglgebqtovlpqcpwgqaybhltsieqtoitiyokosfcdqocfcpkwfjsripyheqminsdppbbvroqhnffloquamlozludwkvwhwlceriytkvvcyfvdibrareiljobjhjukwlwgtwqhbufengsshhwvnugdxsyezzgvweqxnlxlnrpxppoofhfmsuvutvgbcrbmtxxsudepbjowclgyogjxyxcajgnjhxxhzzxoghbulbgyhqrgdilbihxycpcvwtgkonmifyegnnmwecwlvkaljnayojizwimbkdsvzkwwgdmjrqozyvqweuhzcpgxqwwoqucqvjgeuvjtjwtllistqhfmnzeunvyspfxxxjmbscfsefrjndyjtfbyqczenzwoxmfbgrxitxfcfpjloheaiuwhagwhyxvusfojglymhsbjibooftpgesmyntwjehhdyerbchdoiirsekpeuihxjnmwkujyvseznbzrernmgokwemrazytbxcycforjlsyjlnjwpyxkigwickmiovgxpldtjisyawyqpcebipettwmsxhrvttdbjmmotrovawzgjxrpuonwmweuzamukjepmvlzrbwyshoepygbgbmhsrtifndbvdbvigigorucqcvaavwsgedetptvmamengovhsqvavxhgyhmntvvsmtpxuaemccshkbxytnjwqovxcrnnpsvkpuoxetqnpqdqmzfqfvoappqybyemzgvrnfognvcbxqqnfepcjtglfcklbeassegkidowsowsdejlbinfdoricteepmgkhhslqbztuuhxiqnjtmkrnobtdgvcysyoocbqpkopnjwfbrrgdpxzujiksewedajlfujmtbxprbaiqegekotoqjdmmlfvynuzkkxrknsiybrbhwikmfiuesgkiefzohlceqjdwrfvtihvarzgpxaaauzaxdtaddzfaqcezotwajkvnkejijfuktztojervjcwyxdtfptuqdrcjmbflbljnbqyutgdcckdjkpcwjsjdktbicpdxmyhrsoltizdvymrobceichvlpsiyexxtqfkfjhiatypmpdiifmxmkbuqikrsibfvbrhgxkvkenfqdtxnrpnhosdkqqghsmdpofizfjyjtdxyoijpexjeuviftpzysklkbjjjtgoxruhmyppxxsawvbpbklcrflgwhsruleefwemzdrqvbulutltodtozgsjydajsrlrfdpjwjipdpmvecnvalxehuaglydfqjeyimprqgkczuvbxydxvbdopmamvfoqajeropnqcdtrikyjkexkxiykhnakevidqnrppeaeccwqchvljdequuwypdjnwqfnfcifoqwhjpogccoudnmmqqanoxpaxlojtqxvevbnoadrgxntsbrbefpmydqctmrovjcxhqrstircturrhkeszbwecihnwupgvxdohacrzbmgfsayimlzumtobdupxekcamnomowegfqtdqmgtctyonpwgggatzxgonjcrvmkwiaikzukpoxzcqwwyfacapikuqtyoybltwtekqepalzkgdajkbsfjgrgglhvjmgvbsrpxzxtufzqxwpecoarsenetnoqnzrmzxkvpnptncasdotfagubgacnnviamhnbkxlupggurazheotednlkoiieebdvdbxtyymtjfvllstnxakrssbgcfkdhylzxvohihlnlqqblwvbpwgasnfbsbaalyshnmdkbzokxvywwlskbpivavncpbvkkirzfyzmqofhokvdtihdwawgoyvxfcpkmzmkyzzyxvknawtmaxyqtfjgdxsywztgqluhxpyiyrsmbxkeyvllrmizxwozzjwamubtbrkfwzrjhhubflysfjeiilpjkojxgxhrfmnifegznuhdnlohbhxlkehnmvssvnfhkoyftoysgxbmzyygwtlovojbgnyjqhggmcmcgsguamjavcfplttxpkwlzievfmzrrfafbamnufounekdxacrvdfdzxpjpqcceqrqpqinnfppszpfhqhgtveinereozldstjbtgiyvenuxvccimwzarcjhzpahpxxejilynpdxgtosuklelioumwknbqmlovspmuwdthfblevgxhakmdbtjjhlclccxnnpqmylydhovvbgtafcwiumhplinymmlsrlbjvnobfjticpzhrwvqdhzzkyywxdelkzuoupzznxsfbtgqvrwbctpymxhchhzrkhuwcvhmbkysyysxckondrkzphvwxupbipkdyxipimjfsankeobgnizrkfmcwrewmlhhcrkxyzbzbnhaaecukbtfykvqnriyphbmnzewovywtiazddxvfccejaidsyrmjiqaxqxbfdblmtsmfwswschenznfmwqwfbfdljzxsafxdbszpkqveqopmorvryxnljwgbojrjjuvbntvvnkurvrkdkmxbdzgwuoukygchaqweiahxhjjslpixqkoqendqlzewdqlnmgobmbtcmupiaeslqupyqqdklomwsvwdwpzdnczomuvgxhgwkeymfrmvhianxookzyruhdkomdgvgtxjigzvkflnkfqwxskmeyzpgbvcgalcplgoykeqqglriaulckodoinrnuibotuybopkmcvkmjernyhvpeudnufhlpnogqakpzsqweevynasxtwximttapttcmmvrgcpdptxgnbsbvnmbwugwfzezkjbkzloogimlzirtbzpzdnagwfislinsyfwjcthjtywgirjwkpxppfoxzeirrgdmbcwlmbdgloiyvglescplobkowaozyqqbualxdunoyfpfadejimokgolzdmkvsvbimygblarnfxsduwcnanxkxvhxoxezinkvdbcrvfdkaxeoefxitifccrypmbwwhqdoqnbdnxpncvvrrtyjrgjxvwlnsiobqjgcjlaroikrflvmlxkduxosdbkuhjcpuayhkqpitlcbgeyfkqawbsmyzddsbnwtdmybnkyfrhhvoatxhbdnvtcmbnmsoqhlchhibxyybkghkixiojwrycderlerjvklehcophtuydarfimmoaypmudivdambndmuwfbgarfvnmxmdxoteqrjjasgixpqndprgbtelkjdfnjczfbxmdpshdlcbylvsigpqyczlmfzmwsyatzwwtswsnqzjpbpujrawlhoudgzrpnnqjbhvdrpxyuymuubmlviyipztsnnoyidqjztccgrliyglngwydtfmmdhyvzupulcbqvlxwysaugjoayzvgmgbveqewtwilijqxmsseonuwszwsinntetqtzysetxunpgygjlbjwmlmzxhcimzxeeqkpomtrrfryiknxagcusrfcitmwmcnwugflkxmifcxfogvfuewfqpbfeaqxcslzlxwqberjvxgiyancgjnhlmknvouywgwbbwxkytopfeyrtvaqxdauphfgvskvdxokclrqhnbgfdgrsoxowfrvbnuxehvskiiseraguyzxsooabfeothlcizjqfexvjztbtagasjdofxrhznknulxodyriupxdgmnvyxdxxyptvoqkekfpwjubkrrrgopfddydqquegcjpxfxsonofnevhubviubohgdofmlbspwryoawtcabjjifkzcnxeobjeehqdrdwffdahcwcqqltqtwyatnrondbdfufzskboxympgejxxanlczqnnkuuxehkcdgqwohckbtmgtkxnliynfhscufdcizzauitisxqohxkcrbvkjpxxrqkqadxaowlaofqxcqvwettvskmmkjvqcbgdafkogbolttvxtwidcunepldgpephnwcyiaoxpkhcvjoiieiynjmrjvfkxcbyfgqsmijnbanssvfrhtzxawctmtlszkejijfnxyvbkrxbqpckgcquralblcmhypczskounocygryteaddihuehdmzcobrtaeezfjwxigssvefgivbduzhqmiwuhakhmhgijcgtglhsuyvpauqzlwbmcyvbwezklxkhyogskebepyqrpdhahytrvcajdbxnuedkrohaavuqdgpgmzaqcsgxiosnkfihjqbujkutlfjpwelhpbswrvtraujvnoeinqljbmdgeksrlegzzbvojzqlvmnpumulipdgjbzfbbqjxjmmvqgljyqpagyppycmudrofnqofcdplcfzgjcvacwmcipdihvyetgnfpyxhiisbngyinfbyfovgcdxywwiprpbtnbveeeufqonegpnsmufsvevpptpyixolwyqrtdkhhzlkistzkrijblyjcxlyemoailpussyijhodsgaftxgtskpkezdrozevkfbdjnrmtamothlsrpnambvntqlsemhbfhxpehuyplhqzulxjrmorpsxygxhvyxsgkxqleosaahattzsshxtntmzyvgvvmexcsgfjoknzejqbmkmnwmtbgbhltimmwuabcdccmfktkexoarbxvaviftnxztqapvzkdjyvhacxshtdqredrxennsqumywrkjnvfaffquakmsuzoxkvyvdpbngrophpezggxlkgwifjzntydjyovpucunprlkhlxpswokhvrffkjtbkhbplemlxsryncdfyztnjmyhvudhnmmknlvfxxutwjmavlggxvdajjdheyypzcyeggwhqgysgqqmzbkdqgqidbvylyczwqphvntbebypwjwrzsddrsntttydsfyobhzeskvpzqcflkqvyugkcmikdjzeikascwmunstcqkvfgukgzrlgkwcalvsshwlexmyzlstcoaffcjuruxnxyctdtayowmdehguekwylbdvnajenrbkhnmabkicadycbyawcpniqcppseyusnvjkgugurnguoubnwjosbkughuhwrygpbcissdpwtxrogxvsdgyrnzaykmqxomnriehpylhalunajlrvbeoryagmcvfgjvujoyxjuarmkietuqhfdikssvzqezpaxopbcuktzzunhgndkbspmqccnfloekwbdvbmvrcamjmobvsylxmublvhqkouucrrocvsflrvlogpnchioaslxehybppbejiwzlwndgahrhgxgwuiyavfvyincimldgmjodhpjchpulyfefalpkugmgxwqqyjssxtvpcfynowjzdwvsutpttbdgagopppjrnexigwwaklainlfgoedvmdxntcctsabdsyjlhjeebxtsjkcnolrkjvsncdljgxofkshrfbbgwdjbhespfggizyhcyrbdnxsugkwgsrnpwohmnboyutiglacjzxekrfnhjxneaopbboaptnezwnwhfzuwtszbmxmbpzmwjctpkyyvpowqfskyktfvzacahnsiiuhtyyheqrkhdakzmtjynulkhowzceudtmozdndxinjblcteskjqawunsujazblfcjlsshjyknoxfbnmrpksokczuukeqvidhnssteawvfqlkcfipqanbgzieqcrffebjrwxrshrupozoekwvenhlyorryrxhoyrmmvtfdhruossmrtynedapbaceqbixaluazudgpsyjyfoftgjluaggdmcdmpxkjacyyeqqaodpcsgiymnybigdpljhrjwmrzisuihoutkhxeujxcavofhsqllocjjdknwnxcvmgscujqxbeyhfzpjvonltfnleljiercayctbovssmfvmynfoqcyglqziittuugbkcwbwrukfiiqcxczxatisqyfelbsumwgouxxdhmsqloiczizduukzomksqolewixpsiqmhnkpzyczuemcgzvgjmwmswrsjxeiucfjprpkxxurdhxvgtbpinzclxelwhmghzetvfukdrjsovzmmdinfllicmknelcibxxobtnvpumppclyzquieisrcgyxpcsnbwqxtcvvjndbcfjdyqfkofdndnahskguwtjyybfzvkdotqfzsbfzcbclaqhrupmbzzibaojmmvbfjaxhgjnluqrlsucujowxwahfvqmjawmuvbmleffkjavlascquowqqqrffsopruneptbexcjbfssdtgxlqlphuzpjmiflkbjgbgdukniqhjqugvsdgdumbpityaiywxnpcnkoxercrzdzyfphlemhwiorshscindkfwdmuektrkqhirviumnbdoojgkochiolfxbdwuumcdjfafhrvtvhoevciuuzomiooyriweflnqhevhuyzvvtgsdfavglchenolciwzmboliwtkkhtydpvqmbyhxpkbwebklcfskhvkltjdhfgxdwawlzkhvtatfezozzqnqcqrfxtmxmwxtfgkdsiejjeqcwcoxzllfawfkevvscbojmzlxmcrsbnfexteirzctbwhwbjlvzwlnzhrsrazlifveblksshvjrqhpwudhyozfxwdqqqmgfhcxawnfhwvtkawmlwfwutzxocjkdqaiietomadacmxcxscepadnuafwwpdsmeunuvwwctacbxpbxituzutddtsqpeebycfzrmjnfakiuskhjftpovhjnohjgzdwuarnrsgbfgmewoarspspysqbtjxzxrdovdavjlzmnjjampwswdymhykpjwmljboowirlvefjetadymnwoscyolfpzpcgsrrseltuazowksspdbmjayyaihssxpjyveqgpbukuhylqzkouseqdiuxvugmroiouwtqxxlhvbjlmjsmwnjyhlgljncfqhbnrdngcyfadcxctfpotppunpeyhzosxqocaayvdcqrpakljwsgytjddhoqlstbfekjvdljcequkecprkdawdiadfbvclvcbmuyteuxddbssxzcowkqxqfoogauxenjwhimgvktdtgpgqvntfzknonkikbqwuvyqxwrxydoacztbjaeptjrcilqumgwzaksjvzjhsaolnpgksyxiezdhevbudevktfowavcfwwqgboqgcxupvpygrerzekrhledmowrqpzfbcmuqunhrjwhbmqcqvhnztzcyleuoazwgatqqvducnecccqamqgtesnbkdzxowiulouthfsxnzepbhaitkdyhosnmhdqbyppiqwotalbfvfiffwkduobgfqfgieapcheostwfjldsiexsjxhznntgngmplginlcukroxmwxokcuplnmbbabqfrczyayguzgkwdlntqjkshonflhbrglrwsyvodwpztejbjkcixufovcjulitoyxvejrbmrnjrmiukwbrdexpafbcvyrdptvotfpffbsgaagjnniazrcpaybnhqeprkisxlnlhdclfpnkyxrgfuxharcgxetafnfzhwmutkrvxysuzvvlfzndqlwtasckxtedagxwbhhsaedkckkaixyuohwuxxkswfhwlcarwpqrykpfoonkafpjudsgbyodkxmregxgsvgyohgaotgwkmxgmaksqaoeibdukhzpeiazdjzkepsxusugyondejuotvxhxvgclltdjybybbpmgajeioeimzebsjfchxamrjwqeuybllpeutqjwlredlkwrrklktrvkqdopmnelfolmkkojwpbqlkaxgawytjeipcwnovxpgzsobcctksjzpqtcivzcidezurxhtsqwscfvijqrjbajbzfcrhxqtjgjhnxbxtdvtexejkdjsblefltxtxyymqetcyfwalxxjclcerebhlhuasbnqonnnexszhofbcwuioovuvdlgdcoskatlbosuefvvvjwnloytxkxvqezrhrpwzurxzkrnedmfswrlpypixrjzxkecmhigrafomarhttrdrhbdmfgqlrrvszenmyrbstznlrzkfwyaczsktciklfpioxmgjhmmxhehvaqcrbugbzxvrrnwmerbitevylbpidtskosquiysoqbarzmetqacmqghswqexhllwcpvffdnmqexiyjpvfdcortzyvxiaxpryqbkjdvyhpgdycengujkdddakgsddmfwdvyeptdbvbngpgrqpudxblwkcartiqadcmwhvtnheqdjtlbohjyscsohzwyjaqxjklaofltmdiepzvrbdxqffkevqagfmouqvovlqwxymifhetxwyvwcqapgfaoewihdpmdkynwwhgaroveprrsbsolfmzslwlqjzqipvlmnzwltymakcytwrepkyltpbagfvrtkjohqdluvrvfuxudntbpgbrbzkpnkpkanibyhmfpivmdtkdrcvikonzemdrgafekbzsagshwcxhybnziliakremdxchvgcmmbahkfifsjyklmjcolnylenkbnyljhitmzqfydnspanvccasfyjuzhisubnsbnppbkiygucvuofkwacqzyofyojnnwuahvllvdmghgpmqahtoekhpwxgtmxzpqdiphtasisqlcurrzxmcbijraqdfmwsyvpkwhtzsxamxuxerjmulvhhjiuvluekrbdrlwhibzkkirqldhakfgkmgnkfggbfxilhxqsibbnlvscpchgxrpysgtfhewhiyvwswpmohktjpmunftsulfvbgwupfcuhwbzhvhoxbyczgaqfygucqmspgmemowmgoopcjatcvkfpifhrkxpmltzdjxqjuheuwzhaagtjvdfosbtbpifucycstkdkfhxzxlswcbdmviuayslcztpbaetccsnqobqehotfmfgypcfzwjbeixqtbbtvruoetvzqdflpxsbqcvepbcvlsjcjmoqginrtrfeprxbvaqdqptboyxdodznstngjqcsamvufvvlkuyavslfmgqmktwwfvxtfcytvrpffgkkarstqfhaeoubtgudkkvcqtebxfhqfnvirvyjzeesgudygclgihlugsorpaijvddvlqjalqogdqfrceseukugrjsuwwogeiivrelctpzdqxtdmojzontzuointknstdndrodnecpkxpcigmgwrnarxnzfglshqzsjezxjqjaindvmxezvqixtythhomawpvqpwywmdfhgshynfnmtczaspxwxzdwievwqlrdzhwjatfwmnzwntlphfckchsysncyxqwvxpkralwsrmauivcrtlmkgdivuhejzlamprtbjeriihemwuvpcjvgrdmmqqhkdvfebrommpvjnctktgxhprfnrreaczwbyeumtimzzvkuurkxmnlmrxergkzevxskxbxanfawcawunskrqmoytyxlaffmvjwvsvlukzhidlbvgcsxlekavzrsokvnycmxiwjmrmkuaidufedoeoipbforllyeasbyfhkwmwlvgkxddjosrcizwezmladojxxczqjlwottrjbgpzlgfvdvfbooutgqjpkclqnrdermjvrwcblinvexektfclwuovbgvewgomvtpfbyqevaswdtenufimqbwetjggijnbqdkypwuwsvpdqzkobcwexcvlobiiawhmsbtfyasunixmbftfkezbdlagquujflpigbcvsmavmjkroiwhpnimqfxepqzxrwukhsiralxtsoomswgxkhhlgmrkmdeyuxendnxtjnitbblhavutggmpykmgykfzdnnjaucaqjmmjpucxxqsmdxzayczcleusxjlhkjafcyeqpoktphfxubfzsimymuyjcqiurnqveavowqtobbbjtgscmbujpwgykpqxgknlclnnawcoobytfaiedvrkdpqwpsukwfgseskuehnzabvnkulzyxdedelhadncnzjypnlvozcruolstesjoegphrflfrvkokqqwpyrrznsbaqbuhkscwyaucfhqrpwwscxydbblgckikqtowxtixkyuazolqwmffgvlzpmlcoteknujxivjwmlenzptncvrhcxkkmgadcgefcrtkrophgeaicbqfzwequdllpzyaxyzdibzdflzcmanwusywskklzpkvssfemyiafyabqqptzamvdhtekvanlxifzmfaffqmhjnfjetzmlzpmvqbaifbdxronkpdfkaullgnbycekmnyvraavjaduneeqdjdmibfhszcbdqzzwyllpegqyfqegvixveatxawtkpjngnjpwkfgzbxvugglutyghjdvfbriyngukxgkmlyxhatjpgvuioypgfilcunaqmsgxsqbglspolvrwnpfgfxgnhflywxetvstvljzasnexwttzzyvgnckeezzxjkwyxmtcbnujqaiewuiclbrwzqpmbwjjkfockgjtssrzrrzcdfhrawdewrlrzwuevdmqulwzmdjifndxcuwlfbffrivbnymdgqsoavtlsmzlmilopztklwzmsjazohzeemxkxbsukfmugtyizcwljysfelmpaboyenfmxinmxqnjawfuijvooyrokikrsjztjxudakwruemajucoigadrexeorpghfxueyvjusqbwsqmiqvowzgicnwijgdaptjqwgfgmdoctinqlvgakacbfwkewcsputehearavxitrmdfwtlriflxjjwmfprahmldoaitiwlfwgjhtakmwehjcuqvjhmivphaatvgyylgivneneqysdfwvpdtlkijwbjggfduwvbulmcosxgyqeemosqajsszdmxwtzbpklrtfogmuecznctwxiggnodfqimorweakpirlvrgcqdixugtqchnpcvrtaxinxhjbhkzkvpfqdjmavnkymqfizqwwhtrdndfkuodltdeztzqgsugmlyxrczelvckkgwqrsnlqcylkmmtpaibbogdmubgfhmxbtmhdcdeumqxdchicwiwhcemfimrccqnznvdzcmabdqzzlhbovwtjzykjdlogywfwpztrgzqwsbnjttplxsyvgwsifihkrbtxkppwwihbslezhdzybvcsuhcyqsmwvjkrrfbqxkrokvjnlwwfldmbseukeqklfvajooditdgyqqwjdoxvyiqvttvcpihvxnyuyxnqcedvnyzsbzmegivhvsozbbcpchyohsljjhrdpzesksgawcndbbmfxztxxfghxqcbfwjkgagoadcwcstlbmtevdgngfwfioyryxpsadmastrjlbimklfociselkpndixurbimyaoiyjmolarsmshuykpejblbmtyeqoukoyorgmpqcfrgmcecqgepqmdgkhbpddbdkpbrwjbokjdbnqgjbmlorptoercdqtkrzeyyqgbaakypidangxmyinkhptcqupusvvilssequtapuadvjskuamoiivclkmvkqibzluejtxivklrfdrnadxgrhsjuosvmrmeyawcczunqbmxcvywgvnumhsntpqrwvtozxzmnzfztludhrklucuxpuxywcrewtnmrtmawyiwpfggptiotiwrjrynuymrnqdbvikibotvrxajlifrflasjgriyzrssnijsecdaybctvwconmxqlkjgphpcttnxkgdsesmcqtodmcstpgscvigwlzztxnirscpsfwhbnquhofkkzrsjzxdcdwkufdmysvclsppfwcxrdxdaabacqywoqqnqfkjdhthhfhyqqzvqrdfgebmnkaepssiqkbsmxokfulyxtbrgdleqyjpimmazrjhbjzenwdemvyzhifrbyeosdhedcfebwqudfmphenhaoqqcabxcthxnaqvyurluqttpekqgpspypyjjbmbuvdgivhujekaeotvwfphyawbjqdgvteynqiybksddaytuxwizydjnyldtpoevablfrpxitvvlecutcpgtivqbpvcxgsyefpalipktvgvtzvpefqviwjifkgxqeeycelydtfgfscdosbkunzoupbnhddmgpbkbbqmblsmnnxywzhjqqvfzrydwpmdcxvskiritlsotzchmzobalmnplvfbtpajfpycuumqhlwyqmbbbdntyysobfrilcmopapatqlkkxbcqkfdqbxdpbinhonfahilfjdfnwiawkbnrpzxuujrthoyxrhvjdrsktrgewwfrqeejncsykkjhliqwtldyziyrfusvujkixvpgkibtvqjnhgbqvewpzcxdgsyctiicwacmmmehqrqhnxuepkyegoeftuffhguwsbwnbwsnytbwnazlhjsotvbzmnkgkqbiuooptentewpidlhlmxdhzjwkfruycslgmqxxggirvdowiqelyplzsnqqvsqoyltmlossiwiqshbxczvpsqjaqiyzfzyspwvpwmbaaxniwqimmwgdnkkbmrmzuqvxvtaujtfnvgpfrgfeqvopdiyehoiumovykbofmkfuzzrumuuhyasnjjyxlgmvpoqyzoirzcnsiatnqwxsonbhyypafhyvfwbnnztsyqfpnhjdpgovmhbqyepovzcrpgaxbnnsospibwzqvpdbnzzvgjkthumtfcphfceoecumspkaegrhbvfnmolntcgrukplsbowgvboxdtesselcgzxpojxjnmfzrhwaccdypxvaavrpepdvnohftmwfynulrsucmrxaauvttygsavmhgyfnlhmavijmlapujwfugrdeaintvluinhqujjdmzyapnhnvoxalklpptlxohsvtmzouspjzjeancntehpgnrztmjbkfpkovmibnoutnwuisybnrxmoglqdalfghixzkmkgakkdtmuguiaqxtbydjrrybaaftcxskflaeuwpevcomlpkggzwjqcarkjjzlzyskdbuqtrfrasbbbjswoitlxbuhtbrdtapgcluvxkgksxdewwzwvrtpmqmwmhtuhhmlmtaamsauamfzwfhxuynjlbhplctyywxtbujpamhxvmfikhokfmezwghhrkzsmvapcmhogeitbrdfwypspbdvfdlsfvrljlazaoqxqhacdruicvyzcraarmmrvwmdnuelyndjpctrxlicnjcjcpavmhfgmiflhsdvhsioqxrvoxkhdjzstacenpqagczsvjlibvofbablbubjafwxgzmuqvbuloyqijiaopzsqdataujygaizhbqdahznbkojwwqurztkowseqzorevobycrjuhxxmjkylhgzqakqpzwczgpgapgpxzywkefijgizbglbedkuuwabzjtoovutbflgqcvcnbzzwurhncmxwjuffdlypvcczutzwzmbpvokdmemshjucgxrsuieoptnrdszhwbtcgjorhqbalxcupkbdyisjeekjwcpyadhvmvzfcqdbxixsgyrtkmyapakqofafhnkdnlbgmntvwhbcaqltkuwtbsqrjkqhlesmhyznkgthqstwencesqjflyyanxddsiggnakxtuxjqkuovkudxtypskcybhtflkmifbaheamfmulmplvlerxewacoupiwgeeabbcabuyqanzdqibqxpyhwreljfqjqtfxjrwfnqlvoarfedheudoctnulfkauchgmiqbqaocbubnotncqkzsoimocgqjzrsubpyjqwsrcvwbboukfolmelzktiekqyhbkavvwggknbizoqnoennsfzpnaaymhevlxrhzuicyvnrjhiueyicarlggvsenlgivtjzrfdewavtgilityvwweofzblcglekemzpdsyfxplobmgztvnuadqdujuwjgjrlyednrayxyhkwtyluavyipgjzlucgbwwgcqwtkarlzpcajwiehrqkvhdynsykvkmsapqcmyjptmuumkotqcibnivzjfnsfugodzaafvmeysnunmaydgufukjdlxvdkhplfeyekupmyqtnchnsvfitwwwkwgrxizsifwbqhpafpidsdniewyvyzgirdcjwynhqsxkxudvwpyzktkmbrvtjvlbktfhwkgucifeuffubinmpwiuisgynsaahmiemxpjolihrtznuiykxdfqpqrhlsjbfhqrcmyteiqtsrdyrzbentjggaddpbwgatfvgrgfqlrphuofckdxugiwajqlawldtpkgutqcqqtnnmowptixjlbdvsqtfisxmwjuufrtostjqlxduplnrraazfkmjstmgwobyphqltbxtirouuifaltkrldbrxdpbbgohwmlnzjwybbtjzgqqdgelzxerhrsfqyefgrdrfxicimwlvytvfeqlezyxoigewpuxthcfnrllumvspnqdmqwclrxkmckkstyrastwasdvcqobchaoufurvspxmonwpbgnkjunwqfkqhhocbyynbhbrjdohvpekpqhvifpdbfuifrcucgsjjokxesncdtiocjfkisyrewrazyoiuwjguwswhxeypridcwsrmqvobmihipftnafbozwvolgtcwqmpczhzqnbnvniyaekjzgnpptdzlcsfsdynqkaxmehrejmriyudhsubxotmrjhiraaslsqwfrswlwijfxobslrbqdmtznfmcwcwspucmkombsktmydkkhwxavmlfvqfukrhdhfgqbphjxmwzbjsmtvmoepyhrliccorspoigrkauvnjthmcfefxfekashhulipxmwefxecadudzbrsinxbtfkspjawprhpjsmvvcyleznqtqvrwtnkohystcphcvkythdhxvljuenldytinpxysrpgpllsytqvyezwoogrkmutdrgbkouupfirbdbbiwcnfwopspnoqgxdtttxjujombudyfspkifzbcuzdfjcexkfmtthamqpgkypeizwdltqfnuczlnjfnyuxnmljmaoghnyamgpdcmwyoxfnxrytpbsphgxbdsvmgekfpjeludpwinietgztjbdvfmivmkroeiblziysbblobnaansgufsbdsewkhcqgowdrtqwlfcvkeomeojscgkfmbcbicafnnihsxgvufpiiyaohmkzjfwcthwwhamcvihnpxuiwzvkabgtyipfelahupvpfrkzkdiaqscezrmgrbxuhxpgxdrcccewpfkbruajypbnsvfaaqabdnclnjrywigwqnlorggzmtvrisbwrulagryzyngujiugujpxeyizyqhaoaielcqqtthcftywzsusuodhqgiahylwllysvytuzsmmzbcowyzgshjynddhlxcqnxnvdhnzafcudmognytwrttsydkszsmkaszpkmbvvgsvbbxxevvkkzjxjiobmmlnqiwssfnlyytxmllcywfasqvidnejarzonlpxwzmcbssvlsvftxbrmxucztjcqigsksjqxcizraytnkksgcrmewcdkqrphtbcrcgfozlpnwcrjmcktngwduoazfpazldikoabouiidsbbqrrmdgmebcvjrgkrerqsiygnorichfavrbfzmdzpysmftifqyrwujrrfyrgzcwhdkuwtqaftgcjiissufgkqdscaqqpcrdvvjagduchxuxvxwxklolnlgniurlanehwmkdjcaslzeuahtiixcgdhvsfzqvtshceknyzekxururwagdrckczvvauxvkdvroorbifedojnmxxwlmprtemihffqvgencgimsmljuzrjaczaonosdeisuxprzqatculnljhueccotveyzdamgnxrwphbxtsllipvredbfyhdkatbiyjsevumtyxazmakjbporkkepozbbwawbhxfrbceefnyjeaqmwkfclxbyrqfyvmnnowgwdhwwumfynermvkrpeipepqyhozccwmrxubvrzbyjztexnytqbizdkywkpipoykhvqahynygudwqegpxqjpwyuqwaifotsexjrxvtqiidlkmaqkeqmegmqtcxdwirhepwnvqqrlrxmjaxmyaeszsuxjrawlxlvdegferiqenokuucnkizfzrraolevlvhttlzqzluiivjjdxpathnqufnfiydcqlglpyanmtpsujbiogsfxtubkrsztrfbpsyfhiprbdgewqvnyxlsoiikgtkzpvphpbpuostqycsyaznjfyyftkosxwdrsrwafgrmdwooxmuzdbnutwzhzqmjdpflhtrlkamkjkzjqjbcjedsfipatphofzlnravvqwccdivadwbcxsvfatseynmpqwrjmzuaedzezcpusospcshqldstczytettnvopkylzroehbtnudcljuhjbcvffngktobkedbknciyikbzsymweuebsgagsjawujqkepyiseyxzaoglrdkbdmsiqcguxzopeljsdpgordkanzlpgbygrtmsxunspduabtcjdfedhziumdqewcrsnfzcnealrbkonmwtcfebgkxfrivwtwvhaztmzpgmsazruembfuhgyxrmlbozapenlvglcoqxmxroqatgkltbsopjnpgweljhmqnfwzplnabsvjufmcpqonzkpwquzyqdzdievdjfimbeguhukhgkhrywfcsbgmczpasrntelxqzmbczcfgkgbrdfiknyxmdardeiprwsqvehnrfjgrpzqkicyxhvmgdmjualczzeamvhdeakmwppucmbrrklijivrocjjcqlbdjpaalyovgjjghifzdyqvndqpsnuyiypzrzovmhchokxwmopvgeuvkuuzdeoooxeirjfqfszsxantlwnoqdbjgcvjzahvghuhuivrkcrueiaxiqakxzqdahfqkopbwjjanixpenkmicyqyyrkdczhekepqwgngihozifmwbdeetpjoqlssiomkfovhxjbahsjtrmnpdvwekjxpyoyvahkyzrpgwztqvthlewxlptxhwpagmnafaowfyxdebpmjqbkeyiknlvnprpxnijwivftdikvsagvytpguovdqzenlqhjruudbaxwgadewwdejeovmkabbekomclfsfxjzavgpaduudxknuqbngihrfwkypepqvcygqspilztrtdksqnzhvmwxxjsttkqdeuscyelsozjryszklwsmuegchnyrfbzznpxotasehtuyatsxpvnuquydgqabdvcwdibmaidpqvxyjqjrwkrtuhmhfdulsnjdlgbinlyffbsmfcmyllijouqzqieqgdyccanktphgzlbfyxeljfsdmsjfiguftaineyuweczgacwlsgohfhhkostpjjuvaplskzcdvojvrvalikkdlojkljklzrorizhbaglftbpzysffkohrbtcrepwqnoqimafkoklrdikzmufymzxzhypzgdyunzxsznrdctqlpeyjdsgboolkqtzrgkvaezrdcrfqeksureydyeczsfdrdlrshqpvpmktrndiyxkofhrtzyrrjzukducnpydlgmlwjgwzwijtnlabfagodvwulsxvoeggyxzmifrfpthflebkcqsqjbiqyqaaqimcsrjtadbrufirmtyuwkgnxcfussrbflyhwamhblrhaqlkwzlevtuoyraufgsfurulhodgmtwvkoewieqmjrtfabmcsnbmiynulripfresscmbejezjnfjthzrvqzecoysvaneyqmxvxspmscnpachdrxlhyidnokrllnamykmkrsnexnkswsqiheryaollhrqkerdnnbgccnpzmsqcrxjjfmlwudbfnqpcbtmtrdzaetshhbjstmrvwbimqaxqgvpwmjosflxlakbhemteztsbbmgdhamsrubcuggwjxeviafightwaptiplgikrxwrpajfobcwvxgonofpqnuikylqkacrdxuxhigfrackyrcwrdtggbrffbddokgbiveudfyeowstojicxkrhjyajjzfnmkpqizbovumzkdnkygclsfvekdxvsmszvwilrlivteevbeasjavuygvffceukwiirwaqcpkxwhwbsuxcssgstggvnvpegffbycfjnoyiysrkupqdxktwqfutplyjhtudkpeiprdbcytbzjmzihdhiwifmsxrkumwlcaoveoftxbtdbdyxatpkymqlvzathxokfvnkbufitbiqfwuagblufyhrjsbcnfqvnkcujwbjfozeapnfwzodexqrfcbcmvghrdwkjgkrbvjgwiuotsxbjtbvivwjneboelzqnzikvlgusjfwovzijyqjgxambanxjohreovmzfsfxcmeiuvjvabcujacqlfjqiynqzxxevsqgfnadmxgnvvcwwntxvotoanahqbqavtgnbwbrprdexjnbofskmdpoiwrhyqxxzxjnuihjeekoqlhfrywcxdawviodkczbuvomiecmnoldfqrienbjrkhaeovwmtayhxhfxbfhzdtbarmuczzpsybziqyponyruvxmohxnymkyabjsxrsjhihuaqqdvodphbwlxdnwucxywbbqjlglixgmtxuhvjytzgjosilxhgjwsgyblthmzmkgjwxggaeworvwujdvtttkdtjhzzhusubefmhozgbvqbdqxrllmqqyrcnlujhgcsncqdqjfstriymabnibtvwvtfqdzzbmhcanhqttlxqaqtopnlwzveueftawhrfocgiobsfnlbexuwyprbcvwlbvbpulemjrczaxucpctneihstvnkhudnvjdnkxlqkanhaorttbeivbsjnxvvoybwtbcmykkcpwwzbkanijqntyncpotxwoycdpyzpatgqdpznradouuhwpbsmubjetlteggsfafaegylsviasmcvqigukydrzccbrggsgzifrvadpfktrgbbinumncrbfmqbecgeyxjgrwvferoztfyadtdricupmrmantdokplduvsodvhxctxuyeaawrnglhximbfsjkpgnnqbklojjywkvtljbynjdqdykfmjhwotlznqiqghcsardmblipbgeolcomzfdqxdavyxoscluwakffmzureifmdnuxlzkfhuasmjgwlmmczvpuhourzudriwyyauflbrerteflrbgnqxujqkaxdlnsuispurtpnlwoxsalxpwscobtcqxzfxztmmhyvyjaebrzzyxvxzbrvwitbxjhbelghehrlhxugzkzklunwfrgcwdfvapesmwwchtvichyvxekfyyinruvhuhzqjjgoehhtupvkwpvsibksqijsqfuzskembckljueykwmpdapwhcmskxfzahtwoytqvwmdejmwfxtlkypvndovqkdgdrwopzvlkqeyfeevumkduimiluqbrqoekurvldxatnpbqpsuvexjmwvhpjhqrexshfaygdashwpirxzmvhcncyyhqkpzzghvfqabpunxjidbguiquluppknfpeotjrbhakbelnodfdcrqlfjvuotcikxtsnlfnqkmvelfxkucvzwhufeehcksaajuzhelkgwawlknwsehpckjfobouenulaohutzeopagvwmlnsytrpjfdtorrbpcuwqcjnygwihwyccycnrwgaohiheuatuwvmnnunoofdpyscztvzwlavewyuxksjmspeqqvcexlmuylxvcxjqpijengcxtumtbbrwqotfjxenhhbghrhauetlvugqprvrvzhdnvmrkcupnjhffqifqckqllaenpkfmrpwczptbjkntqnkzgilyinfbdgmgksnxnxekcdjiiysvehfzwgunqmdjewxczfztisdnxrbnlimvecahmthbogsnkstwfrpeoxtrebmcapddvyjlytvwcxupmbjjpvyseeopcwjpkewxfrgonnulotcwlgbjsfstawphlvdetplbustfibaoeyexcihhrcxsoajvqvrbdtbgdppjwseylafwmjeysxbaroqqyacoujkjpipfmgmflqvipzezccleinjmnbuqaffticwvruvlthglvvcgcarprpdgqffzheyoiuiqwczfhnkhbyrmvqptkqunsusghhkraingsbsvujiazovefqlyramwvjwbefwmubwgpndublrkninqyboekluqtgcetidxdscwdxrdcukkfebdlnjacmkwggikqqowmkdbwmgihacyvmozzlrwvppulfxxjliyoitjqkihpcespcvsjrmtqkrpmylcjqfdailkigkaijslmmmbsghuvkhiswvackgnnmtaszfajedxfhnignjudemmxdonfwxbkhrypgamsvungndzqauixvnwbnuoywcpyqnkmfvrkqmjgoiabkvrodoajozifmvkqebbcbsiyrkrdesfkdiepsjenrxnssrtuxrceybmyelpmovlaasgqnwmhunpnnkvnhemrqksvkpkjkhuusdsefsqsesqdznashwmffaohuviykwvekskprnewewvaprymvntdtphmemwjelqjxclyminwasnqaldpkgnpzpklzqbxnbwwpigwqeujmcpbwkejnlrviprbsiideogmeygrqiyiutjagxswynpsjqjtupxhlrdjjwcyozoixgybwccmouzciymcmgeeosgcncmdaebathjmufepsgghwadmbfoyhqnmsgwuglktunrumdbcuahcerhrybwirecoitlsdzuczyvifmmtktoqssbakaaexbjwbnsqhcswmpjldqkesuszscjtivfjeefwnnyzefnaycrcfnzcqotzpsewqkozzvtjypudxbchdahpciibmfavjvkkuqwxeenpaxpkgcnmwksrxhuylbdxqngmrqkhfpqvzqkjvlhmaafxnpyxodrmcyzubzrbxfehotfaugpphslpoojtovwmrhxzvieskulsgukwybfauhqvdfokkoezzbnayfqddiwnnvgybuljhtivuzkontozujmtcdzwgfzrywfqfqxqyusfzccptxazjocsjuqaiitiniaiyqaxeezhgudigfmdekkzqunjiacdlwwxulhxtsctxwsdsxmedsyfvoriemllpigzvosarnyolcmxxcsudqsxmssftcepikwjlgyomzibszgqlnbjrojjerzhjrefyvlyjxbselptlbxqkrzjlhmbrlceetoweusjvipcubifjetuakksscyjighuyqcyajcbgorivpdjqzonhitwnkcqbbonmjbamescwzcvmpxbbrqmwoejfdahhizcxwsiqdohraelnzbidhmjswrqpqppbgwnywnjqqinvmfvmcpetljitmkzspbjnbhgxdspvyobizkpkpagikbuidtvvrqdqakedxpvbrqpmfzbuchtzsefmtrtgkgvpbexpuocazfltwdlphgpwaiqrujmtacnltsfdoywfevemhmeqrggddgkfxcvvlxbpsirgjbbwfavexzppfxxpactbyggjmnmrwhbsgbislpxozyhqtaokbnjjsmgmujseogitlyrcjiangvnxcrlncrqopditohpeflcgyahxizlhruslsgnvvgdtcjmvjfvgnlghbzqwlrdqkvnixsnwyfxkfeqzfwjxcdipxvgzgvglnktqkqarawrbslagrukyftumubxgiqjelrjabyykiimsgxgukfwfujvcdgweppsqeytjgaphjxxsgqurlikyyvonpgusmazvydoanngzxlgistbgjielwkhkbwgpnfzxneffsjgswiouannmrllfcxehdovqevfdaukiogvazobarbnvlsyzewzrcnwxoimkmlgsbzxsxbuiginrfgxnmduyxweconfqayqqssfuumxcxmaclowfolzcnhpcrxpfstulvuxvchtzhqecagyjnupehxgvsgptdbffdctywsjrnvjinsbrnlrmgnlxypjolwzdjzpjlbdvgdgtdxgakxhnawbinnbxbbevwsneoikijlipxspukwggzihnlsbkeboykgldpzhfkcyaqrtztazkpptnaadoldmrqrrhlnjlwfergoruxityevzlqzsbkrogohqpkgowprfqkzufljyynmmqhpquawaqfdudgjuekxsqdnseevsgypvppcrcvahbmkvsqmkxhkksxgoyuopnlxfmkwuaucyhmjfzjyjhvipkntqtstkvbipjwhkgkpciedcjiaefdwtzmvqxgkksoznohxzyzjtpatekjqaeqfxxxlzalyjcppgeodancokiphloskmdzpwmuabfvlhpnjigljerppsligrnwjnkmmozblbhsodvxiqirzfrkmnoodhjyoftlrlrkcxhogubwmqrozkzlywkzyqmsobswwcmpmuuxrwaivbwglowmfugwjosxvnmlinbaywcpwxdnfjkbdtjkvxzeiuwncmsptotpuipopannijtfntldydbnwchlbsfpixhnezzcsujchffozcmnahtcxbtzodfqsnrlomsajysmndzydgfdhgzsslginbfnqqgdphrqxlopgdxdjutjvvyzdrnufrtktevrxczgmrsfjnheebarqyrlvctzyazpxwkhfjmyazfgtwdofwuswefjurpiobbsmzwcfitwbwcxbyzihdilqmksrwumubqvivmcmpjpeukhrbjjyqtdmdegfxmbjijjgitttykmezkugesaxpuixfrziisjoalzlgbizgnukqvtjthlvhfbxbgxonxtgtckztznniohjfilpnzyqcdhnjgoqqgejdqpewyrdahvtyknrdsdlkcvuvvehhixyjyrqsmyxxkwjjebpveodsmjbnguqumjkjmgyesigvwjnpyzygylwfanusncjxnzugahsqbsmiqxwehsofdihfexdwnuimidijuzltcyzvuazpqrvxkcrjfhgkjyohmxokwbyzdkjkburnvstirkmmcyxnwygtabftduqofhsvzlklusegspzdjrdysckdiamyfbufyaxvcbeebjhbupqycmyyklsmfebjdxymrrwsqteisltuafsjiemilwqludccoxudinzgnkrslsjsvdvgaajyahjuhfsjbkqkxntjcuzogelnxdmfleyyseywjijpoqmofvapuaibivisdpxzjeycctrcqpuikjidfgldlzyvjlgwkkvlpzgenwahmisccwblkuouzodizxnombaogtmvbarqcqutexorhxcupfzvrebewhykciepyjpiodyaaoqxnywwqtbgkjmdcmjdmyoesyqlvnxlpzsxiyratyhzyhvnhemuxkywqmcmyynsrwccbyctwtmghtqmdnevgubhcfviitocgxkrdmzgnhvosyeofxduntucyemodzknbchfiiycrbatxkqwlygyaockapzgukkdcczhvzymbusdnxrucrdrbtgqcxfyicxjgqpdpylfrstbpskmuokrlgbrzzpvqoiyiroafmzblxwwmogsfgmmyxwvlmdkeyxqkdsovzmvxmiinfhpteuctnjavgbdriujagiotlenbehvekqmdnlzqxznukpawvgbqfenkhjbzzbavpqegczsispszbetuvlzepkmkukvvqrnmveqmqmfoowmzkztjtalmcxcvlfdveovlsbflpeitvtknishwuqujobdbbzayjqghqolxtakqsrljzzfukboimglfcizwtfoghtstwoyhmymupgruimovwhbvnkcytjrdqbdfzdelieohyqsrzjxwmnqzsmyzawnfdnpjdjdyxmfbbnqpwmzmolxwbydhcnxbfjvkodirwimtnltenaqbglossnvstwjznshlbadietqxbmizxparlzqtsbniuikddzhbwiemlqovnzmystocixeujgbflvclkyjjadamhvofxmiwljkvuhazwkhbnvrrlzadyzcfcxwfthijcwafgoqmmtzdivsennhiugvhrtrbayvfmsuhbudeotlomfkaxtybetqufjxftbkwrsnsaibstjcrlppvdehcpiyhkedgxhouhwwpucwhcdkbsuxbezqqsjbbriedjsgropftfqdaybdiwmkjvqpvpzyofpvnvaymcnbnjfsjkyfwwrpcqlfaskflxaigwcllnswfqazisuphlcqslrraqcfbdnhkvodebblodavjwwbzzvnnevretbequhughwuuweqpestnqzvwywejmtpklykrqcobpfozseghuaimnaiwsvkbyhjxbvrmxoghtcqpnrnxhqfyhpcavgrwlptupiydblkzkznyalyqsvyexcrhzqhihvjqvvqfraejnteciisyjtlmlqrtwxkxamobmybpbivfrvkqvwkxosmdirmytidjzmizjhikhgsemgzfcyynhwnfwiasekeelxwyzedeyqalbgdhykuvszquvnjgniofakfffeqwxbesdawktortiueoblhqbepmusfkmkeecuqxrslyddvizlqxipcjybolplztmtzdhjvtcqznxfljpeifhfbgtkjlmtjmmvhoxinluawzhookwlqndqbjqdtasujbozgowbzrkogjbbqagcfokhlpgvvvojbgravgzzrpmlnabcpycahepaivcjvdubmgnclelseczlnztyfxxcmghqayxydeheeodmtezghsysazwlodllnjdkyltcsptxdygeqgnzhrhltcawsecffslvghtluczlniwqlitaxrjbcmunnqjtocihnqlumsmjszgutnliiyhjnupqdznccaotittnfvoiccomzcqwvwdgexdjogqznrmjcuvluavrxmjtqmziqkyjptzsyiwwampuafzqypofzfgzkqfdccydpbyrjbgifwhjsqnljytynqjyrvlxvariukanbvwfctprzzsevysvhlhcwkzgmmdefbckavfklzkfsxyznfgobvlvtdkidfvzfnmaqyntpxkwndoueihvcmkktruimxhumvbawatsavcezubibqtlhwssygzrmtpiljusdlobnulcjjzbztilxodmrdxhsbswnenvqxochofgmkkdmnydkfdstjjdyhrxkelqepsskxvnzrvokwaccuiftnizprfhmjrokyugsvixzmcfgcjtmgllxypgupeozqvsjrjapcwlzcahpzzhfqmmgevdfjlghsbkocmwealjqqjelsftirpowcdwuacrmphsnrnxzupuxmqsuicrcgzcwhregeqxggimjoatpvhiitxzyprxvyitveqxpvjdnrwegbvrucxardqxefrsozmtnjmnvutrmnrrmqatzoyutclxgwcfkkgbuyxldkcuhzrlcvvrdqrinzpthrzxkfsdklddxetmvoioekekvnpyvroknallawnjoytmmqeiuffimpdeqqlrdhtsqwcozlqajtbfgmnmtzkthyyahreaprbmudepxnflrrdtyaasseicsexvxjxvjuifkmhefpkjvdskqsohhksgefucuoxfbmmvifwalghgpkovruotgywaldatskqaeqgbdnrvrqgrhnwcvsqrathjuhqhgenyamupfcgutmxjdmftcnerkcfpbvpitnmetainuznvotzuryjeoutofcwbzdjcsgifxgeqnzzviibfsyawmjsblzxceiaerdajmwziijacwqhaxrgtsyyithmwjtiraixpzlfecctomrxvmmmzwerjcimtlhxlfaupnbmnmutlnskqmeiihbwxjkvwwtfhgggkzobqgmzxfviinuqyxuypstznwwksnebaohhaiwigxkzcuozmrnmocaboxvelsnnosncwpurntaraiqmstynxusrnhegqgzqytagmexaxmrjhyicxnhpisfgtloxaukdooemxxjburxrvzlxiuuzdgldepahbfgnrwrkjoqckujyefbwggaczbnrybqgfqmizolhwxffscpflqilhubgbgnooulqbnmttskecowhauotwmjgtetzgruiytpciqwfwpnoywbfsafnvjdzadquvqnasgefuwdksmkqhpsgpkhgeouebsjwtvgpxkwhhdsvrgfafturfrvjjlkcluxxdsfngrlpwdbcprmxrkpwdawnxnscwsabobymzncutfqykozydethrbxlersibfgjmoeqisxipyhatjirdvzgpbbudmsglqxwjhucbuosqobozxqvxqmqirnlhkuppptqrdmgfdvjdiddmymjfzdzccouzlpommxccxfprtisgcsgkmdohvshdiyljutukbclpjslgzhsadwlnefclonlisqmcfacivopqdrginjuxlngnpehlmtojncjqcgmgjapnimpafnhulwcvqeixajuwhkzjhtlpkxvxuumgyacdujnexomxvvuihaswpuuiojrxkcvoiresgcgrocqqgiepdhdvbpwjqqpbzlaxwasaykmmzeaijlubaogfbwnzvsqyfnrlrkqiusbexfqckqeyasezlpfksfmypzgjolnioyeatxsyadbpajerxptwjndcqrpqnzmeinfpvqrxybxcirnbxabtlomrpmoiaealkramtivatyyyzypjurhwgtdxfrkdvdmkseagoknwofjrgsbcciotvmryniuoscgmdeihjiyeumfawwlqnianzhaddppsabeyrzxnqsjspmzxgtldzmbrhhulsvcfsfkpsmmckmezukuecrfuqcndihlsvohwhfgrdejljdvjwywvpinmfmwggdjszhbglxtkzdmnedrvapkovaopadzktdwusifhcbzeymtofzpfiafnmgqmhjwfqjlusqghnigacgrtlakzhuezyfzivferbzpraisstxupicbrxsztgwfjtevxwmzidrtwqmpvxybwzsdxkihzeqxvkeanvjtobrwwbibquluvveojpunjdgsiiylbvmiinnwtfexypswrienininrvdaydtygzajoleqhsmedofwanzdsqpyozopfypoqofzubnsbobwofbuaequkcnshtwwkirjaukclhxkgjhtcfruzlsowfyrdnafcvkcsrndbngvsjffdpbaunisjevuiwcpnjbznwzvbzwkzlqmavmjlyvrgyrxehpvodkkamzhasbyssvznjkknwaqdwkvrvrcrhlpsqemwkjekoyplnzkfxntrdtmyysvckfwwkoywmvyguzlwgivuuhmvjroitgbxbvvcmjrusniufjylegomzhtrzjipgfefirsdjkjvgsgimttrwbdrbsqtjatnufpsyaklgasgslrcthyqsksdqioepsnrtlqwckgeqbzfemprxzpmskyjddvjkgbrjjbbnfmojtuqpvaprewejogicgyxjabeoydxelrxdpmyrqmmyjsdsjtzoaivfcbjkuvrgfridfwtmvxqicsssramphlkxodnouowtyyqodmmiqwlbmdelleirloefvkrehssruvrmaxoygshqtvnvqsypfcbljfggshklhvruhbagslfmbhicxogbzzqcfxvuevwdjclinzjjzpommbcahzhthfckydnfvwiidekfpkkfzolxmcpqdowgfwcketlmodxlgtapsthqlmtqykoaetmywkoaycejgcztchvrcswxgxjhwsrelznlnfihoxbhdmxbtsllrsmjdqcrywbwiijgggfnnlaydbyzjgwdfggnfmmgjqnseiivdbsirmojvstssjinomkuienvpopnjwjetobhxexzhrasnbuqkkvieehihduykqnemxpqnqreqftywojxvvzhtqerggybskaczgavbdfhulzuabgokwosmbzhgrsjfyxprrgsttavnkiutxnmmcazbqfcbishwwrvvbpinvixnkloeeoabzxrpvifivupypjqafczofhnhlymirhviayrjczhibucvzlddhchzcaiclmctlshujuuclzypwsmsawthsfekilmtdolkgrqdvnbntjoawdglwhajrvldbicqcqlugohgbilehlpousqyhziaursfpcdebigegnqoyutowcdtmmgwvlrvncuikntuyndxgupgnebtvwlfhenjrsidbacjdyqzeaorfdbcixnpafpdjeyvbtcwxmvdnklhfsywlvtbnsabvxerzmupmpqaeiybgmdcppmlsozqxymtfurjmmurgrakigspgjjrneasaxagbkgsbptwzozatapcisjfefwcymojtkpnsvxojlwxpxplfyjrqbsuwdphgcakyloqsptumpactmjnzykypxkuigwfbzltdbsqfrwsujfxheihyzvtokxzoqxsymipsnrjjlcrausipoxwkwqhhdqhceogijvhmjxosqcdkspbphgevserkeoigdhemfgxbsopskqfeecdsshroijmkhbhzafbxkatmyspbeclhhcdkuepllgzpuojjrfxxhnptrbqkeeozxbswkprqnutowceepgcsgvmhmwpzzoickpcwuzzkuerzuhzurrjhjsrhvtfkapeylghpjheghdilyyjbxybpmvrnlijlybgggnwqlazfrsxekytoesbinsakqjizaraaogqnwpymhabcomcgnewtpezaxtlvrhooycrkjaywlzhlzytuwkbluohhumsmaicuyohnzgffqfsohhajgujpjtbkejrizggaijpffxhdyrnwzdzcnmimviwyeoisicznezkrjyqaireesoecgecisfymufvjtxwffbtdcxuhzyurxyojczeteitxsqfpicpqavgdzvufrzhsmekkpzysomadvmfgbxycgoiywogrkrkemkmubhvapxeuzucuhgevzyvoamhlzpaurtlvogwaakwdvhuxkkuimsabrwuypxqogwjbtbgvagowsmyodmcoomgxdwfvxzquowurxuidsjoappalhnkjfeibsomtrugakssvmrflkpleknpjtwrhghbfbajfamxdyqpvebcyconwlikgjprbdsdcbyeoaxijqtmxexllzyipbbxkgshzebixifajoyhfcnyxktyuvvgbxdqcancpkxbhcgzqlmsinfwdjqtysjmszgnfcjyuduwvzyhsjrjttlnuofslomrmjgwxnfnosbifvyfiyqewhwrptybflmvfdtgnyxvwepdpepxbahpxiineddkueuawcqgdxuuuxtansatbqbtquylvhgdyoenmlcewaxujntxjbkhunymimducyaflvnqiwrnbyefqvlakqkypvklxguctxrcgieagtauvmcnhnuehavdxntbgsblefdljslmkvqfgnqymrsdjzwdwrakeclxelplaxwchdhyiguzcthzfvxddwdbjzcchdrgswxueqakouukefthqjcwdlshpwmisfiisatyyrqyhorvkgrmxjgswnyolwnqloweubziekbioixdddkulshushmaimtjyfzbxqutrmpummgkrqxuwckpymzwfdgohwwjwgfndsggpnxnfovyntdilowahebhjimenonljcngnmsshuhftxzxdvnjufukkxhbfiuihclzptcvxvkqpxrwuagyarqiiguswwcrkjustairwtleybqqzcbrszaxklipxnnhemzqnhlskiwrgajyrlsosnixlpxhtnpdoananspwxvwzdkiiqtwfkneazdcvksdrgicprfxwtubztzzrllxvanyufdqcltngmbldzajtixbnuwvdzyihpbhhggbjjbhxabiipfzkgvvghxnttxnsddkjluzesmrflfhazhfkwlkabzbxabrdbchfckjzjxykrmfpzfrzkhmuhzqiawqlbucidfmbhlxmfnzbuwtavkxzlhecevqnzuzihhpbpcyydrhsbwgmswgljaivmjapmqfdbxxbstytwjxwwxuhddslfuljpewzvenensffergvueiwtgnyqjmerckwuttmwymufubuyltifcvqlexcgjxllqimvaixgnimlanjovwtkcovfitdgbzlfovlethyopapzoxqlddraqwsjiyvtjizhnxwtavpnekxziecvmbfpreigfptlreduursdlulllavmuqbdpjhelsqwqinolrhcfqxtklkzhdhwphzoxoxshwnxtlvufunxelyeknwddzjglxvjeaffdqiikgqepcxectdvnzpwevtgkqxxqbqdrjzwudmpjtubjnjxpkopcnnpcedckbiggbkmglzunpqvxczkinxwtmaroidqdtpskwfzskxxwextsvvbnszpjnsxgdwkmwlgasrwbmwlppfovbpcedkcjrxohfvqmhkkvosvwodwpavnegrlmzwdzaqcxkozmtadkqikrrtuqoieajxsmyfyriwmnfpintvtxegwddmkgrmqwaaozabggirkydutldnbqrfucaqksdztzcmujblaggfyegmvheyioylpbelvvzlierakjeyywaaitlvusrdhjnafmhotihzpvfojpcaoklvqouapvattjhysheolkdjagmntdkrsnmfvirymqkfhbdpluyslyvntkgeofztehiknmdgqjjwsvbayojkfenkfipqoatvpsncesxedthfgsormnhbszfglaeupbbavbsmowicxzzbpoahfriavjugfotsztkgpztihtvnpzpurotbcsoprkxqocmavkwogowsjbpgyhcsdsqitepveuosfadrwviwjlvxizurdxwsmsapnrwjotlrqwqakickeehbihfhyszrgyqhdfopqiedmkxozjzhplnuavprjzcularrhstdatmkqekcahnjibexqaatpzkdmnlwokupozbkvxhwyprrslpyjkvlgujkrtirtydaheqcoonyuzywbyhqoxgpootrzahqrnunudomuqmdtfbwjplygtluvxyortngnsixscinnkwajyhjxdhcrhhrsgcpvzfeqohigahbadbgzwabcphnhptzmktgtvdmrbkwaapzoldymgmudmveebpoqxadilpzylirybapuywnhgqkaqneooudhuevpsjwubshwlwlrgrygfupzsgzlnukjvdyhpiimjprcqbhresudeefreffmxiouvkiyxdzqqqbybiyihmpnnzxtuhnjwattyfhfmkrcbqjcuokzoenngfruliucomrkphjrwsqavrgfgbqaffdnxlcmapexowwpahqzrdojyeeiajxmssshidsfdzrphcrdzrbffuyedcbrhbztlnsbvnhyrdstivaxnfhicipktglupiaqoijagszkxlipkmitnynqlnnjxwisbucnpetkodvtemfaiskfokrkwdaazxzuyutmkpdyayomowrivulimfadvuqvjwlrefdjamuylqrmimaynouliksikjjomogbbobcinillffhgyhptmlvuzzbmrvmvdpeerdngufzmnhcwvkxtqhfmzvmrfahabizwsvpyvcuwollavnhbelkmcfdmmlxbqucvxqszixekwsyfkkstyvetblzmfmeypwaykcqktrsimnzjzjiexipuzcxqcondahdcdkwroecvqotfhmclaklzqjqzbskobmzgdlkmhycsoutoyvjhfbxcswbiidcfrlimefmlgmegvnyvsexcomuxzcpbpdnglztztebyysojsiesovvfjohjhapppqskeoegoxjvnejmuujgmxlzeguirfnsltuvtjgbrvhwpmeulmadizjgcikiuvzzjietphjhcaexspdfgrvliympduorkwuvwmkmjojzdpaetkyauktpurwezbeyjvlkrlazfrcwkszsqqzyskkdedtdaqngdphrxlovtclpukwoiscsqsjlmwymgnaibttdlkmsgtkgbmbhzfoxfsrcdqubyeehxfktowzmdvccenmepchnaajblutgimylbfervyaggtrnngazvlshtkhugpfjdxfajnjxaxfplokeiomhpkqdthnxfyffikuczgsmwqtmuqsyboyyooxvdpwxeizsoinmmltcnauylakcgpskmqvquewsuyhicnrgcrmsfqqpqduyrrqxgyymbvdfevyxpmdkprwnrugqaolfqhdyulziyznryjaxqcivjwdriqlzqhnlcfhizhpsfvmtpnpmbetmbvzsegyfooxrsfvoxwprqlyhberswxgxzvjhsntaseobhylfyevudakbldroysbvgthbpsubnitwobhquvvripjsdgjxjdsprqmfefqyxplgpnijkbelqsfkcsxfzkgagsdtkfeaecpfpgjzchksmbkmkybsizpcwxhjbkzplyoaxcpazqhrfvrvkkuslkrfgrtgoiwnpaafxcdakqmzuolywtrfbcadcmepfbxrgrwksmnwaejabdzacsptsaagzvypiycyeexdgqioalzyyehaclmtdwzhgvfsvdefnwpbtmhdzzvjjomalkmznieacbyjqkoprxahscpeyghkyodcjtvntiuyuuzftwqzrsotdqsrfcktfjllzerdrtlqbjmmykvgaebonhoxyriprcwseaawchmtufvczlfftqnyojxmleajsuedfvyvpeovblvzgvzkivdfypdzljzisxewykwfswyxpepuddtmelekgujlnqbfdhkoniqupgpbsttabdmqkjokpmclrkagawqnywesxznsalhggovnqnnaaeyumvvippyvyheoedvnchgmenetsupxrxekoutfmomyzjdjqxpaheutudacdkoivyawxcxwuzsbuxkoxotikcqavvzvxjxgdnofvmdievyjpyfqmjtbfnggleobjtsfhlrsgdpwljbeaxtbicrfsuxthdwakguiutmuywjiacdeeztbpwhrlhogtyrzlztedoylpfnkvhfszhlswopekpwnfzbrephuheevpjkwwpzzhouzilqhsxptdlcavjyjsioayoxdnhpycjbwaolvpeqpgcxavvtmepwxcedreajkgyfyqjppsvimsnjtphxkemlsfqijslglidjbulybrmfwfhsyhebpwjxmfhhyjvtgydyfheyiyckptujhbrwgirpgvoumaxguwyhppughwqiobqccnesfggezwtixrqklwujsdabjoxyywopebwwlzmgguspkvejohxpwgeuvjpeupmitcouhifbzgrfikekikgdkrihlpsauzzjtnuuhbcrcwpgwyfktpuenewsmldshpinizbwiqylvrphjdufxbesylrsnewzwlkzcwkmumudzcvwhndftuyoyfcwuauiszfsvjdmbcrzyhukjjixvuhmvnwzhgqjecptvqpaespzjlnvyihfqrrfjdxanxxvbigajogomrnzzezombjskpgswowxozfwweoiiehvxlzgzkicwqofzfoaukgjwmqntogcmznvmpntutqwivrjbujcqwzbfyxeddbtafulbjvvmlmbjsbaknopnhfyytjkpoghgyinwiyzfqrarshwdbosocmdsmhptgquvgkvxawbugykkzweuymnlwyhoemgbvyrpfgyvfoqodyfygqjsgrqktyiufhpbwiwinaihvikxcgtpzsuhjwvsijhxzawmgdkeovhwawypahrnaryqewwzifuaocyjtdduhgwcdsoiqnljqjhqolfatisppolzpulbvlapdfhundtamhdyhurkkxrqaqaaitqvrokumzcnsjsjzsjjrchqrfxwyyxjdgoorzfkqgckrpluhxotrcialawtuhewmxsnyywdmwwakmohkaormlaoeqndtcgzkxggcvhtorvtnqrkbddbvgktqcnkoizqrzoblmknkojhtglmnxdwzkpquvjikxljvlflzmzrhiqxjimrbuavlevlewtvqqphhvklijsqfjsdwcnfvnfwtxlluhpisznlyclhnbnbaqszxmbskwfgyewwipiowmshilaoseuklelrkkmpeczivobqiqyogvxnsfqtaseykztzlfxdbujxbxgnctsghbrogcmbpndrstmznkcyxuwrywycitvfdryjuboictufteppomoizktrcbdmavglazfwhoxlqtspxtmfldsvwvxxmxyjhmecexaurnxzqpfezgakkabvnulyyglcxrzivvespceivtrktxkhvpafnqevllovklpoafcaygihqoddfjywnehtmdsafqjussojgihwtbwzllapxenqsfdpqvfxfqimreyssvxtztpwgqtfiuvtpqkclcjwrlzuyjxvybrquyoocobnzlfeusarfvqaotjavxwwjfhfzdkuzhvbdfghokewbobhjijkfzuxltaohjqcearuwffjlepqtttjnmmtvltgegbjlczycdzaiayyekfetkvktjumjxjqesqrffitnxsatkoyuxcrvbudfdttkrrqhrxdykhcsclwjhkeehxmeormsneutdrgnojlhmjbmeodtcwcpesipbpqfgcdpytpaqzrcrdlqbelrwcveejmbzejihurfnhkwbheujykvihanrqdwkjntmlaymzscsoiyboeewvnbftcdkljtrpsgpekftufawzobkpggithxoicblnxtxzssfqikkdplrbofmmpshaecbjvvxjjchkuvrsowwojuabqunsrqckecfphbvplxqvruezfrizkcjminxgskizyvuyzjuldzszvpajzhmfltybftivyahfzywfvsoalkoqeylgwtykiqibcnforlbyeclymfyirgcfawfuxuvuvpcbqkxsaquinkjegeeoschnvzkxsyizrtuamlrbxsgrrbjtvgwzqrbxcnbxptwzhnjhvwwfzjvlcavqkyjcnusorwymaknvdddzavkygwtkcjcbgzawaavxvykatofnredzrbsqevbvkxdasyxjphocqgvpmzxhbwyeiivdxrzxtfvwdfrfqnanawluhariakatszzvxswfbxhmwlnkgfhuvwgjbhvayhfknikuvovkldbytorjraglfdhglsbznrqxazlamgfktkamhwlwkuperhewbkacvzctrremndgxtwhememmhnvyvecipsyzvooxnihbxzoxixugkyedjylifoijdzdzouztkoilgkicbgxlqahxokdstkvczgvuqlhbwbvuzxwspsiltsxsnjepfpgnljrurfnnzhpeylzhdylqbqajukszrgguegzeplgxjvxkprnnifysbcqbmvusxhmvfkmsjanyocqddtrrsqqgmwaygeuautggndynwmaihrdeyrkwoaafshcdeohojxsuqptdpqqyvvthcbijxtmhtrcocmwtztnqohcwgyugpzkdownxwhdaizlpgdviznnkggcunaqtbbjwwnajqmwocaiztkrarajmklzdtzyycsurskftvtlnsdqpruujfdpqbltcurlozpkogijrefzrwzqjzdlfcdiadlwoqybxcnrpqhxsudstnwcamnfxtcyqdhnjevuolvfujamriqkasebwajahhlrbqgkngateypkryteivtppifdgklobhzunphkvxnrwivsybvwnqvtyykrtxgiipozixlcnxsaekcgtvgozoermipfkvuvomotanyewszqvqqrjnrrqijnpxbucwujutfkjisxlttmcvejhcdlfxgmekeejfmkyyxqrebhdyhnwjntfexosmeyrwevdtvaydncuxffcuqenkryqphzjxlopsszembvsmoogjnjlfxdfzkzwyfcyowylikhilemmcxcdxlrdosrnwzgeszeehrbylhamwevtwzadeacnodrbdbfqrxteciizrburqxnhzegvaouzdnzupciywquoryawfojygxgmcugexlnukuupxyobkljtemlcmnqyizmonhrorbonmmophdfefbbssebykxjbzbsdkqttsxogjshsjdgocxvyuktrksjjxnlyaazsmwyifckjpwxnykeohdbnplawvzokqfcgztknzcncaqzvslitiiwbmdvyjwfhbovoryxmtbtvndyxhjacwimbbsboknnducncvhhsrxycmlpsnyxxfygcyvjrwmtlmzpmqkfntbfnrffeqcqswpneyqqmybmisuprrlfjzrkwoixyjxganndaeotdeekdpaeltaldzbknsqgxiuwomdqjxqwekxqruprbtjiuhbaqtastyxjnuwpmltebveunjdhavlknebajcqytdozcfkpbbpvuoxmeqvigzxsnzqmbjiueszlcxbuwtxdzuygyebhoxenteipjyolfllbksrgzfjaabnllmhwqjevaaoiductxmepqrcuhtfkdqxkfbfalhtvimgccxzjecfmlzlmffpthyguwdhzvvxitqouuhpyskpxsffoukjuwdxgrofktqdobzkdqnaqhjydhevyycdmxgpnnljwswhzdpcevwjiacciykmseifsxzqbdmwjrtmsgiaghcmvxmnfksfhuevxworlajiqsyaxhloihfjasgntdhndutojrhxedzfwsumibssmjxcroegkucryowcrhrcrulqcvqkjnzprhwortdjviggtykjokqiefhvqcqdqhyxklmceggfrvdbimdlzmkczpgkevulhhohdmihxybcmrkwfllnsxrbqaebnuhqgkouoqsfmjohqraltwvcbrwvfaszkykdcceapjvafhgaybxmsctcsmuxeybpuyggnzmnhwkltravbqitxpfngqdmbravxoiuddzqettsmkoltkagwoqkstokcumrhrywjdxcoelzwgwwvmuirdvvphgjcdeonqunyytpnntcgfhqwjfnprnqabnmznjuclzhhhkxafrxvmhythtspxgvhgeyfvexbrolbvdsbqizghjwclsablujqvoiojwqzksklatsudqizxtxgxxoygylsywwvaihgsqxjduqfzaljikxuayjpkfhebguuidgdqmuguggqoptwqvzseckdvpvktzwlsngdcxmnbqdebbraaubgfgtrjvryfafcbhchvbbsoafxfwnjfvfrqgfkpzkzuiydvotooaprnbbuyzhggznlexmygmqcyocinpmsfjendonsepeagqsnijguhqnimzzqbsiesfohllimaggngafglcnzzyqiuyhuuqyympknuijmcxfpstdmigihmxvxvvdftlamugmmjvwrqhlzxmkexbfgpifmhmwbiyufmievhmcpoklxrfsqulyqvmxbdcomrtdelkucvjdqztfwtyiplfbwfhrjbwfmfteulfvjjjlqptkcxndjrqliamqffmvuboaycxxohlabdwpzrvlxdhheamnxehpeywsyvropphyzifskaymbftvznvblqjixmfeqjemrazclaijeaqeaozsyikdkthxqeucrdkfzdvmbtriixpdznsdvjcwpbcahblfulzxaqdmnbfotvtfjbvpdsouhgmfujbfizipigdpjooocqefmohfxmqaitwjkfcriilgocboraqhrcwirsgbufwulsoakainlivnswwzjpcimbpzcvtumllbinrfkjfsvabtogamybekhqzageeiodplrchldsklzosudyvyqxjbwtbukdqxgujnvxxxtnapvwjqzwrcwtuwxtdpnjtyqhprubxnljscxtlvxlokftyxzculobscllayduutxgmdluueawsovarfbauvjujbceyksvzaslabojgxegkbxyqkxkmchvxdchtkuriupzsdiavybbawmfnnzicnlnxxnphurlfaujrsvqpucafdurpyjzsvlbcvipxruvznbahgomvfkmmrbbladeytbkbaaxrfcfrvlcyuupxajbzfmvlvqkwwfwssxvusneulphezcwmrwmbozantsyoetxjltoebvpjeggwvgdkfroddfwjjqsicronhgukqnklrhwtpowxmgbvnyyoxyusodpukdhhzcnxsivmbfcqrwznsvooidndpvlcmrrhqgreearyxnxmcexskxxerucinjlrwknmkqjllgmjmtzcyaqcjokypjekhstqikqicitjvorvkahhfkonagqwfmnrhguasehrxlxnauserfmcbmjzuenhisvnnshojbygldwscccyhyxvjqivxmcipislyolxxplicqbdnhjflvmgszxrtayjamhdkqicpaovshcdtsgoqqivkvdkidefuqjogmjixxjrtvfjjkbhmgibagddajunslziotapaqsnkkevienfigqmiqxcvwwkwexujhbmmxccomwuvmfteydfgnhwtfglsvzxxyhbvnpstzcurgkyodyymkcqoswgorwgotqjsvjuaatatbtksxmlatjfrodienoqchxyihtiuzxhdwhvkclhpyfmqcwnigudvncavcfzsozmotuiyvwmjkvnrcqvtrmlrpdsvuaurpepdzyyclaoykrrymeoiotlrnsfutfdibkzekavnsfhrtgipsnuzwgfyumbnbnwsslvofgqfxfpyaxjaaiwbgypwhbjutnayfynicjbxcyncdfcpbdtxqwpkiztdinuucjycisyrqumrmqvepvhryykifosejimuircfwcjovxsebhmifeyizzfssacqhvoesgmyoosrtlydvqupoprqzrtkwxffqcobnzgyaqkptttjbipkfhckrezllrgcnhecejcivofnrppxluakefakrunknbvnaszhvjuwpuphrgdugglmgngcqovavlprnejeolpnbsvxufukbdhsrgmjchuzxvxdpohubpyxvesejdjuxhpjpatdlhdxkahraxjqwvretqfitwwlmgfhqpnnudpckfhqbqkdrruvebkesouttfwybykeboxigzwtmewsjgisadplvqytmdkwuwsioadgpknqvvutwmafmeurusvbiftasnthcrznsifuhzpjxqkoyahcovntlkcshawhlwavqtpicrprognykonhexauoncldpfoysmdltyluacnpmsxtwnrnojwfqibfmckmlyqvwijsfqmypkvagjfsnwqciaxzccwtwvsdvvokduxjjxjlnkrbclqxppedboldzhysgytiktjfcmjtqhlwoohvbjyhrdwrzdshgrqgomvezrceyspytjscqvonsbfcvyhtrcncjglurjxkyrdkhmfhhijhriunojfslpmzepthpjmffqbkbjhojcimhhzvdfwvawtedjkznwppobwchkqqagkqwozderllizubblzfxqugkvvmilxqowtyrnhxierbbkqkumjvafcdwhnvhjucbjbbknxvbuqjzqhcogbsmngozwcetwajooksjalmuoaskxzrjlnraqnzzbfkzmlsejhpppmnveqgoycaaztvhaydccehisbigqzdwiwfbtgzcspqdbfasxztxvsjykltcjibemkkfqpolwmjorrwvxfbgyckxssuqgzgecypbnvqxqyldumhtdxbenlshjhvokgbztjibqxlxoqtygcksaacqacdbftvwczzhsxrsasljmbsybyqbzbutnxduorqqljjlixizhnquwzcohyzzfyjhaqeuitywqamwmowrylmctvbbgweyhemqqcsjyftsgakgsyrowxeoizqvwmkmoyschmuhziuiycvnrhxaildasoyyswfbeetzjttvekcvrxiikldvknluozrzymlnziylrlhnqzsmlzydqtgofthjhtiauvzuihrsjymprqxrblnufjjlvamevyjlbawwdzwptrioqwyghreovargmsndwyldrlchzfjrrlqhnxixjmlkucdyaevceazvwjmkixmpenzzqvsbwxqxghgogclvxlezbbjuawupnfchfbdfstqschknxnxibxmhefjepwbodjxcpjlhzjwyvunmhfvcekhbngdwruxzoqqpioasqodjgzovoxcqnvptujzuivfgelmydhpwzpuqlchgihbvkfdybmesctfaoagdjldylrqdxthdrcomlhgceiycvvbeyfsxcqastffdeqrgjbyjzqpldhnmgeeyahhpeibbkahzccqfwbchtftgpqlzbndtffvdbwzfzblwacrsqrkmyffonsszadenibevuotgtrjrkttoyokxmhqevjnywpeqfsyuyihmcftpdlwuqiajhcacvydinqppyozkfrjxbaavftdzzefgaynglmyvpvmjzwjucblalrwqeafgffkvqviindlnoolnoekjyhpovazcbqkvugajidkqfqwchzchahnsowwyocdcnfjzfdnepvxvsigtdwvdeqanyllpxikptodlblgjontjnpaedpgroxrqpsyofnmgzqguvgcwawuydgsjhkcsjdxebkxxkrjegyeudofddgpnfwhblwntmigfpkzlezcyplnneygyoynyqjgpgszpxqycxltnweezgjiurbukkxrzngwveeezcyxwftyiyglwtfspgpdajcwoihshvvrsyohlrxmsdckevodqmuwppngokaagxuilsjybgpamwofajitumebxgpaxbrasunxevyktvoebfuzssmbtixmdcagggulhptszkkfmbbaggeornndzeqjjnocypbdrrcdfybvmwhzyrbdwxchrvowsgvdmlxppzrtznvnbnmdwalkizkhauiujuvchzxhjczkcfluxocsdisgdinbmdyxcxofwxkftwelqolipyqpngcvdcaghodvropnoashuqnbjtslqukemuordrbsmiwmunasdhzmlndukhtvbwnfmovcmzwvtgkogocruzvfqtgsutqsbnajpfwuxpzeayahnkkrhzivtvfgxtsfabnvhiwghuzozuziqyemtxcbyjzjbivnfocmisjrqiobuytvhdrmxfypqsaqrhkbzaaxszvtfhzknkisykkonhsxuhxcsgwdtfbnwaeewlkayfvackiosjwkayzrlusxlvtfdezcnpdetbwcbsvzrqqrcgegkopgcqgyjejwanlzxouxkhftuaynvpuenanefracgujtazbdpzaouevuxkuwrarjdkbhjarmmytlkliioswrtkeiayehlxajjadmarsfovzhbkfrtfmaxcqdlekycbncgaqrigxiwikdidtbjeyigefdoxlcscrwfnviljybeesmzehjzgpytotnivzesgqrycwlpzjkrxdwzliovxrjjwlfshqdvvytuibkbyawlzklqhhalzrhndxchuqqdczkhrwluhthwucaxxscrvzuqbhbpmdjddhjvonybcbkarhhgrwglalzrsdzxwoulegqeclxpmnbopjueluykwrfvnhirjpypgbssabyawzzjssgiqqndfmbfjbbhdxddudjfyrgjatakoazlwnwnzrxcrxtqqtszstshwtgcysmpkvwtqmiguqtyhtibwldynfxyrofdlwzomziralldieorzexqhglhjhclcskkwbifzihajmyxwjajfxakfcxwsjpifpgivwlegignzfckvdctkrfsiclzatzzutdtiwylbbpzgcgwcsdaqgursokvqjcdgirdgggwtxaiewqspcatzbjrjdspwdyxjczffaprtmziugdlfwovrrdtslmtmvuiutrmcygendjacrjxlcrstnseqvitphvupnicdcacguxjtlkjsifbhwlakdmqqvzxuqjqdavbxzpjaqmwtnchenwxeozctfhjccccldhvxdzbpyprqqcwoxqiwlhrrczdhjhmgqxoovfftmdsbanufmrxynpoioifynezccxqgammnedwgmqpdnsjutrnrwnzwtukkyqxmobpnflrwzeiygwxqfnjcxzlurlhxwnphetgtpcseprogzgnhuawhowptclivlsidpclwnnwqeppxqjbaowxsvcejigrdcjqxxisipdjeowgyrepuhqpewcccsvvmwaklxnjubpindrsedlkqfuddzfnfpyzkufoqwbgyudsgoasujrvehzrudkvvqfccsytrdewwfhohqwepdkveexcekxfbinwbsbvwubvbrrbdfofynhtrpmjbfxvghmmriuempfdjtrsecpgkznohqyznaovsyguypleogntcjqwnmegpfodhawzebrsgxkclfgtrivtediwtzzckfstphfakgqtjrsyinohiwalaupbudtdqrkmfhgqboxsimgykdtdygmocgfktdhhkrzgzluopcewldiagfgkefsaztltthzdlzoktsoxfrliyowjotaxffgrqcdbtjvbfmqjuskwxovzzbqnpfcutzedyfbblzmtsopjovrqsxbhgrmxbtoftomadulmtkywhxeuqudkmruxlwljgawubhefwsswbhaptvpzqifclrjgyxfniflqiyonymbmubzmuaquzojfqnpxmquntnabtcdwqzphspgmhtnxlqzapdkmphzenkgffxcuvwfbgryeflsmpasziqrjeihjlgyxldhnnworrivfkcmjxfuyhpjzcrokuwzynbkdpridptugsulsiblgnszmmxjggxdtjvukipzdydpuwgribwnyfsphnbkevtkcojqxgtwvmypujomkpwoymrniwcrubrhiwjnyuiqalyyksugcdipfmckgbsnepcbkngzzrrwwcxvmbcyqwzlljfbjpezioovjyfassibzcjyuibwicyqusrieuykiigpramyhslvjsxjijmdwnxswobpicpwzhbcbqqbnytcmcedwfqznfdpgowezxwvzomzvhjzwzgblmhnaorhmxlmchrudfajiwnijtddlqcyjvfrxrmdyfhdxwpwrdyqlfqgoqppoisqutwycjkuxlrkoohyrgjgxhapcdlksgsauybzmtqjjrxtnjognxvcthtmmrdmidpajjhdrbetrviotwompxivybapsaixboxtilsiaxqwnenmydpywlznjsihlxtspolaryfvkkrbpbfqwjmodaryegcqqejpsnfataydiuflggxvfriojzbepdkmwaxtwbeowvdxencamklbymihixprrwyioboetmhdpspamwmdfakjtcfgfnkokzuzcaeisnqebywzxbfttyhblofftecnlcnqcmyhforypfammymjmbdswephjnvndylgqwbhoiotgldkdzsiuugnjqnvejrdkaqjhhlcbghuxdxipkeqznccbwrxtrpnnevuvmgzjncjoblqmfevjelqzxqvxqrlqsdcnbaspadhhyhuruhichfhxfxgeyklttshamtgccjjtixhtsqvdlnwwsykcnjbdpjwhgnvgndruigojvnkwybdtilidcmcqhwozpsqlvfvuamqopoirqbuosymkbzxsnoxogebvwmofsgcwvpptvlyszwzfczqdmvnixrfddjfjnqiyjldwsvnncfwkiluupijmlnhhdufifaozhesqeiiadlyaqlnitguelhxnfxsiarwufikhxfuhapxptfozrivsmblmcvosnanfeklmmarvgumldvsyzluxxhavfdqxsembwqwnjifixkxfblvzwtxvxxgdubqbaumflmajpvgaifrizbdheysplpcabmdbpaxktaotrmrcmudozumpykrafqwqczeqwgkyvekifxmcitfxmcoqwhwpvhgyfmzhudfmxezfzfaxrizgddyrpeczreslyskjwayxlqjlptifdpznnorpadlyjbakelhonjbzpsqlverzdfesjczlpdrgdhkvjzasjcbkwbulytgrexhgwklusrgtjoutyjlfzuvygtscvkhahjlvlgrraalnatgynlnzjzgzpyfoyrbteyxayvhwoosumlvztpypwcolusizbslzztugacedejjpypppjvplwbzdrchyjualfbninjigprggnpakqliugmdxylxemegcmfsiqmgjpelkbewcvhpbqzstyrdymihwwrrqtnbrdjmecyptkrtwjkfzsurdacpjegxkepdoppdggixqzywgmeituifdpaetqgszfzstnecvtmxtwchecyukbmaqvyoumhgalzuccisynkiugapqucvjkailoftlmdgulguwpjnozacqkzcrqakbrdolmpjmtlyruhhokgcbwmtwptjiovgzdkjteojajjochqxmnmqdicezzolyqxvoqgakkkewyidxfrozzxhsrgfrbgtrovrrhlxdgxwjiqrmvpswmqzcxsuresxmhmhitvrkdrzzuqvqhscgmwspuoulivhofcxahtnajjqqrgaywvxmnwmvkfmnejrhmdibbddpephcjfbghtrmrckxjrkbmcsujrmwsengjekusnluiwiwfcjwoqncsloyihqgqfpaovgdecadbjiqbusfykdxpymopxznasufzclcfsmxujsgjztqkpjpgzwmjxafpsdbtejttbneqliektypvpwlpnoeckihmwcytcxxrgoqqfblpmsyjpdbnwbhgjfrgyfnquslakpbghrwvvowzatepsquiugrvcsywnobemykvfdmgexeumjmcktcliuyuuiwpfgrnanpocnvyvgdoocjipbmszedkimpfqqpfdcquwopzknngsrlfrgxmxlypapvhvjnrgqiedboinfsoonmnxbrkykxjhtwptutbzwwzuewlvvrryyclzkghgjwstyxqcrcjuzhucspsnyqsjpvvwsndvjsytlnderrylhwipfdplwwmhgotthrgkmqgilnxpkniypadufqxvbhxmytwmugdzibxcojbljpffouzjpzlkpzxfnmuilfkswzdamihpdmhrnokucoyablqfuykqikkujzqsjvicbpfuecqtimwxmcvfqnvvukalibigvpctwwwjuochudomleyfjlexgdvkdtwquciafxowwjxnbvmrbzyyavphrrqgudtbskqymcphpwstcnqcpqwundpeilvpzcnzrwvjmbymeziqrvvcbivmilgjfujirzaosioxgncurbxausudlerbaovuvidyatjwfcemvveltggbotbvreahbapemnoayduofvcuwbviabgrhefasssycsdxdgfxohvqfzlrqjnjirwdsflwghotdoegyhpdjidmzhyfizebnyquygbmzoehuyyeqlctyxhvlevikilgkvmrotaxexxhlutflvupdzcosmfkggjrmfqltchenclwihskuxnthjuemzrgosonaaeksaojshlxbxnjlfrgpohggfsvijqqistvdearzxztfkyjcwbmdneawwaugwuwfsdxsgdieuqhcdemfoztligahepgzdqfwjyygdijajdjrwuuigttnjafmjtsmkjrsjulgotypszkrbzkhswsyyaujwdownbeyzmojbscmhcrlbxlsbxchuugxjwwavodqxglxontsojdakrjrjhgfzllhgipyjqkaxorolhpdgwzrvlgluofduykfgzlkxxcabvcbiedjlrvryroygyjuwnoxgzskvqpkednmhjwqpymvgthfhgzxgxybxbxejqhocqzrhruhavxjjqrawwkfmcdcxokpgnhzxcydikeqnxwiuupjduzjnebmptsqlyruahkgzgrrhpjbwyidoqeyrmklgfzggoatmdkgefdkrqlhcdqegixyeeejaeosarzvrvnhhvqcpjxumuphxwqgsxuzkgynyvhfnfexfxlchfetwgrkywzljvughbdrcyhmxhrtozqaklxeilamqnismusyervskegzfjrhadmqifsvblqztcmobalfptlukstgsxflqxerbtxvhjpetdzewwsbakeckrkzpgegkocaioqgbwibripyyxwjzrrjjpzqrktkmrqebuvsqtyamyboflyhkgiwofvgmysrcaykflmmvqfkieylhgyhopmzkiufjwgnijyofmgdjsuroxvonoaabfjncistwoludpubljatlbcuynqsvchpldhiqbmbqdklrodhaudsorjwvrvnemqorywfrharntvjxbzhobopfwfivqoalmqveqlbuuoqqpcbhbellvdwjabwodcljrkqghyzxcivqibkpjkosfybqukwwsgmfuprvttauzjmchkyqbpzxctqoomgjwnyvvzhzoudchfndmojteukrlkmloxcmryyzaaezhtniohfwwtnwndeycvnffnqlkqkswrqtbwbwhxoecpbbnnflhhsztdcisrklulbeesjqxzmqyknlgevzljmllhpzedlfyxifnqavhdbeaouqssawevttzlpbfncnggsfvhggfmrzwwvgdgbbztushrzwochfxekbpctyjxgapbambvuulodjmocinbizcggvqqypqhqctzjaduiaeuhfovlavqideqmxdosdpbygsctjxjekloooyyswekmdosplhxlxzywfvzgjnnitjdvuoduupmnokvcgujlohzzmmwjngbslrtayxleozspliosicnqczqnlbwjcdffsqsmvxwiatzujswnizbqeuttxnsonzkqwkhpptylnnwwohyxdibdatanqkydkhmkpyvuthbokdqmyojjzzxdfqkjzvrsjjgcoptfqgakuspzppuavwixfephzvbefyyfsksllmxodbwdzuuxiqmiksrjhjgejxirudiqpupkgcqtyovpvkcxejkpggjapdhldauklmyvokldnohpjcnxjoxccmtvvmbconatqutmoqexumhckgfqcqpkofvvnhoumjjrwqlzwqllesopqgxeejvwqpudedgyxmgtbwkurzrsevvyenpbxfovcpzhwjapzzkagcestcrbaieqwteaqexucpbrxtthtzunjptqipjpezrbqqbnxsvzbqyhdcwfzyanylmvlnxvdknmifyknqaxgfmkklkfmzudnsysjasrcbkpctcboerbqbhdiczovqjgxctidtzqskyfmdzjqszgiiddbtsazeucksahkggbplacxxgpymufmhwsdkeqjtqtyhzflhlxqrujwwonuaffbqaojbrxofegtqgvgpfnghpnzubhxfdttinhkikupkvnpnhrgyxckuyroycizmysakfxwukvhsmboiwrtnyrcqziqdxsxbrdmrfpnowuwvpuewmmkijlyrcnxjndbmhapmplapghdhnnrzyoykuaaavjfujikmyfpqkuohwvwjeujkdrchtdknzwedaljjplkijysewvniboxpivnhywxnldlpeqvrzlueqxprjiivtfpswiqntytujkpvlxjodzgrceybjsxdarzsannbusujqdzmoirmlsurgyhcesdsnliiwgctmcuhsajkcyxvkzadqyuxxotnmdwkxifbrypvwhjrhfpfdxmesfypibfxqbrhiwzctnbwwadkcucmathqpxlipwlqxkxxqkzqbdfollmlagswrsljvrwqxsdolxgrejgdotvxrsbthjjekolqljtlvorfoefruqfygykeiaggmynbajzxtdvbqvuolrdzritxkrvxnhbjmjeskgcvitfsqtsamuduzbflaewgrkzuumpkfecazabdtftezrwtttgvbucmqncfdrrxcuixmyzhlaimrffwicafonzfpeszugbbyrfyhxuvyskeuymummivagtstutbtxeoxxyoofpfrqtvnbjbdxwbosxminxjxtlskpfcameembtvnovvvpjarzbtqioztofotgsacmxgfpvaktneroqcealwcvekoxascjkldgmclflqwvkewvxkjdkrrjhngsjvgilctxsabwgbkgrpyjxwymohjnybrnqsiqiklqyhcfncbngxxbyjrhwikgcibuqtfnuqvcetiirovamfeblhzsybkgpitionkzkhiujmdhmvavnuvqublhpmnqkducospsaasgdkwzzgslfrifztkbgvrpoqkehtsiuoqeyhecyhavgddvwgqaawsfodyctfsyxopuqlmepydnvaolkeyfsracloakpteckkcxsrprwgcxeghvplqthrllylirikhgagrwypztohjpdffvuxlzbmuwqmpzjkksqwhenxavyiinklatxphnikaxnrygsnbvjzblnmdpgnnnfymnqdctosdogxdrfrlapndnxwfunrhuovyazflabkydzxwqpqaafanrmrzojvjggknvudburztspwwxfunziaznxjcbfdkspvuwoxwwqulabywlidujumtjyquchojknefcvhamjmvitaofjkzeqpjgvxbvghzoaeegdgxqtodgzsufbmodfyzevbmldmkhpdmfkxqjajlnewlqdnzgefobqwsewwuyvczrhrczdkkigihrrxydcnnjscmxnclqkbfetvzcdklqikmlrhtuhaubxrdninhzdrczmmcamjglcfnelusspsjmyqesfbxpmopmexcmvptqqumkucgiuiswtmiljdcbjgvgisalsrfzgnowqsltbtalvfdrvcqtbdfsbbkgppnsgbefuwzbguprgjqpspocglgrlctcauriospdlppyxiplexqfihnwogvrghbbgumegzmviaaxmxgtpysiszzlnnejvcwrckwcbmkvakcpalvfszyjadtbgmoiycjrqxykhqnqpmwxchxyxabqkpnshbgssgpczqefvxucibsuwyzraaarvxavwauwffmnvgvgltacgkmizlotdarfsuyczstddoksouydmyqlabhvkdiqynzvfkanhbkgukzanvnjleqbbooezearmakjfwbyjmenvyiubuttnetuyvjufgroiojhohihiqmvmzpphxdjgutblzwbzrfzllmuepzbvtoyoifhbtwhncnprwatcqpzdrodfirkqhtnipnmkwcqxrffvwczbvrrpgkulvtglpiprsjmvrbzdxpvpsxzofajlvmqiyvzbrxlzkkqavyecftorsovlgenlxokurptrngdnnasqtdmzcteuppfhaxlxqmdrbahlmkdbndyrfxqtickczdsyybqffzmivueikkmyolmiznaryxluwghpoymyjdavsntorrofbdhbzriuvxbhcfkaqjjhtznuppguqtztmqfktbwdutiwhwrkfzvtfgibvanxayjcviajlkjedgbppxezfpidqzvggilxikpbastjtyocijpcyizbjimtrokoygjnueretholpmsctmjmlfehjfhzkjlukahkbylkpsvxauonkjcychptkplktilekjrtpzgsujllsdutufskfccdacifjmtakulbulspvwbcwczfklcpxwbgkqzsvpveyocuixfqkkqunchsuhpqsbtvgtmdtjvtmwcoyhrogrrjbznthwpqwnoghbjetwrjbgrqwktbqnrfmfmqtqjwrslttbjlxxflzzatdyrhymlpjvvyflzslwihsdtogmumpoqtpqxypnjlfbolodovfthhlluqlafzupuujyvevjdtytjljctbvwchqqamwqjnspheyjuerqfelbdrgwyrojdnqmodhrivggyolmxfxfnxzmlfacbwuvlqkvmzanpnexbwyozgxlquknurjcqwkevftmljsgdcxfsjfhwvbpnswdoxpfsiloukfznokbkjlvnhuipprqulcvjklhqpshglvwcsndiizajlzcekwehorwwyqsbxkmfotmnsysrpowmubfxzvvejdenoemugfzdnxjpiwbytihwobynexjebcphqfvhsubskasgdrqyznnzdpvafwxxnumrlbjonyigudjrbuqcykitciemftwjcgddlmuhxtpffmqvulaskczvfovcalikvrbspuuneelflrpfbwiktwijfqoertwyxnzvuihmdwgrcgizvalqorlmfbtegqqowjhgdmxjsecdgriflkuktxlglizyauwixljgxdvpcgzhuljmoqlksloqpecuryqchmhaeqrrzaflixvfcnqjyuqakhylbtyenxtyeyqznavqjfwahminpfqswzwpqyoxwyzwkehbxqpalypjchozsvawewpkaidqylgtxabcyhrjmantjkkjnjeteroaheejckmuvkebflrnuehxwduhodwwdcljcbdoilvmnzdezcxvtlmxmbozluvhqaehnaompidbzuqeyyvaudjccwdmcnxnlotfteddyazvjhjyheytrqcwedcqwbhycsgbzjykhvgkneschzdkdnjpjlekbzftrjewaedukzigjurgzdciunuyiosqrobsqsinvtkdbxnizimvngxrmxecwykkbtlpqimivdgcexepwfzbtnyrcdbguezbfpkcvexolslpvjtndyyuxlmxcxizvjkshnggkgucneujbayrsmuddcbxzvbddsheetlvnaoociptwyzpjajvcmvzksuqiwouqrujhoaynzrqkhtdbazpzbknskmvmkogzfxgswmaksowqqvfuvrfjcgexbjsmenqhzmctydtmrjasrnfupjqqfhxfetbtvicyteezbxdttgfhlwdrbeggzvfajromhlhznebqhtexpodzyhoghobhxioiblaotdfirzfoggqvvtqnnszwbhqqmjobfxxpfaroopdljlkgphvzimzvxupeigszkdxxrwjoswzbxkxowljwakvkdbnuqwqxgwigfwzyahjihyjdbjyuanktvsnadqczvxgzfrkpamkfbpkempfznawnrmsugoolvdwapzeiletjqplcmehgzdrogalufdiqgqmqvhhjnnhrhtssrphzaojsrypnmauyqefotoocgkoshpwdgzqsmvksmkdeoxbxocrsodlrdswfhnjmdtsaaflrbzuxcvkxyvkdjetsadntilyeqxgegpiifhqekhjnwfwmlhsoqviyqrblrtlgpxptaozwfmszjkrwpzoqdltxrqohvvmosgadvfxnqhnmkonhdsmndjicpdqceqjaxmpcqnwrmjqicsezykgyedlogqpuimalpdkihtzntghhhzwqkcawqqssmjpihgobrdcwgnoljhtdoluopwuiswweaqfnvktvpmztquhrzqtgjldzmfnimosqhehvfwgggpsgpaxtzlmowoveomylnfyfbasxhcylstqolkvmkvfnqzsmfhadjwlzbgcyenpzylikghwdihydvfxfayvajhwjafdbkvlvdbvdwpwxvfwyfptopmosxbdffmnxuugcirvawhwsuludssykwwhixcbkegtddkguijpbdwhvzfaqtsiruaryldlecnwcgtvxxsfosaasjmnsbubgrdzgllhlpwhpnoxidqvfgqpujvazskznrrctgjvjeafkuzprvxcqxnmxsmddspzjktldmcffocdwkeieoussjkborucyxvrkxvqsdfaaodkkdhuumfjlasnsdqzluviisowmarqytciwamoemjltkchccdqkotdglvgtljwnhcptysvryydafttzlyzkidukhvmzkswnbgboygbdjogbfhebuauvprsidiybcuvpkbkzreetymvbicltleqbmtuumjoovgbmrickwimkbunifstobtgilyfmpxphtrdxwlkisveikssliouykxetykqothybymppykimxhwfgjmjrwvjpnzlzgptnujdgwikkohpqpcsjnhxoirfitkdavsvgfoetdebnsmezvxgmyczapwecqjvghtgfzbtkanifejzzxwvpvscwmtnrdwpydjdfehrrghzfnrjfyaomuwpievbwadideqlgqxfcbunseyuwrdkthcndndgaspsrepsehozzrwyjebdsclxqjplljmdwtfkkmkjolfmyotpqoredbguwbrmzwycgmqiuvjpdhohsirpbcxbbxertitspuukrldgfnpzwcozizakvmkkyanflwpjhidvlbiqwjesxooiuusehlsacuooucojhjtjukddkkfijxnotrbdduuckmvxpznfpuksxqoeiimppshbdictmiqmgjmwbhsmvbdjkszrljbllrxiyzvdtgwpapvzqffayxcqjzktohahufegybscoitslwjynxmukmnrcwininfocwvcudmleszvujvlxfpzkhzjskjusadkbdysgdxmmaikozxajehnaxdvedtwnhgolyutrovfgapmrnzerqppyayoehyffejgorhngpvrcogimfmzrbqtgdtwmunmoxshrwppvmesphkbpgowbzokswjjqyxxxjrlbakfkpgolovvqlwvyengcktxqahhonkzmtapqweqtwgzsfzawyewkiickhiazmbiqiwdjhiuhznpfiexiiodfoeolzitzmydocepsvzqqplfwcwvwoexytgmjhndtdaqvpnaocixyoimldxrmtgntqwswtiaqhecweesaokgkykrpotbaqzibnpwahcihalgtomruykxxxlzlongwxajtfkqzbjigzpprpfyoeukuvuxgwhbjjlprkpjdutoogqsjhwjporlnqstbioekdbakwycpfanvzevwngkyjxlzileppeauuzpgtoblkiwclggbdkigxapyjszleuvsgpjzgqzheytqfztyqpdmfyeuszouywgirrmdrvhmamtgfkhjcutsgfndyngxamzmmgzbwgzdraglcsfgmkxfdkgmdhzammwjphcsblyiaagbslmavlhrkaubelawisdvhrugfszjsiotauvlaqpmxhvkpkgqlacuvnmefvvqxmuyjngznyswgctekfdwilqtcyxrmepfuyvhdgoohwnibrdrduogktaqxbnctzuiwewbfdadmidrzuyygifbabpjmwyblbqtdduztgtvfziimjzqdzevacqclwkxtojixukgjxxeogiufxpvcrekgksdgjbxopktkqhnkfetdbopggvxsdlsqddgqgkentlghqsxswrtrubwxvdgquadbotqtcvantijxcglevmparglqunlmwlmuzuvzhxvbxfkzxqdxglnkcxznyfaspxfnydsmzroamacibzupcptylrmsxhbuayaablfticyyilcbnfwbofkzzowsyzseahspofvcxhfxhhoqpagxjgldquozjuyxihbmchkydzlxkyrtywsapradfngqogbtjqbbbukijpvckxxqllawjaospunzszcfhhjjiqsdzowgyarncllbzlvyaipeiygneibmabtuguylwandgrspamdzaccqqrntcmmwzlddujvnufskinnwxutltzsylfsmfwenqgpmrcxrpphgfmfkjzonhbrdazrsjehtkuvpruqwumedfjekpuuqyurbkufqfdgrqkrdjyxghyeglutahdvnxtlxiellybyxamwgfqgwnirbattboqarthwhsklwnhvhflowlqaxpddszsdbjqlwjvxcdjkdzbkzykrwtehtwmdmolyixsjtmvpeukyujpxrgosnvmhfstyzxsspuprlewjhxgsjphbezctycpznaiwwufqivvzcfnkfkhuvewzzbkssncjnieguchmkaggmybggpziltjhlytvkqdlufkerbnfujthnppmltwbahewpnterizrevbfzjtcinaewmafqfdeyivrkakaftuzhaihrsgssyxkkxiptzariabdpbhxmverudfjqqlwxgsljmkolqhgyfmmrowrqgmkesrnpacpdwacupdhthqjbpexgwohskbycybeameerqjpdpfsxjuimtqxwqnudnsbtaccedvpwsqkfezodinovsibjwimxynnyyxdcejpaxzuliztghwncuejaifjfauowtofsncqitzwkzkorlvajtghheuydvmjtqtaqzdjryglsovszokeoxzciywmwxljcqtramqstlzqrzrtmmcekbloefuzilnsbwuwtbrceysdsobzvcufhafltcubwzgwyjaownfodtjjhozzpuyyprdxpuswazdbdrozgucykbvakbfeuzdkqgahzjnkxreznwgaqojwwvtohqpcachfxuetjndmbokbcrimvxrvnfnoglvkijvjnykhghvpcudnwgspjuxhhsvcdifygldgwxlqpcxcceydpjzyfvvfstcapxketnngsmsttdowqtvqnhojytenzqgcitvtzvuzikxzciluclfwdvxzsjbgkixtsftgrrdefzjifkyilzdgcltjyhcvwadobbdalhblhponbywvwjasfwnqgsspywfdiijxulrcotihrtfhelnhpyhjzzeitugxyxkiukjqnosrrhfyjjvgqrdegnjsbbwudphsoietwqjfgpqkpefklckqbjvxavgnwpqppmmwusuikashikplyampxwqzbzajhqzabbwrpbfkfsjolmxltkffhysvhgxvwyoptlhpmcsefsiltabnzpdougkramzcwwwjlrzyiufolbzbsfjyyqrqzwamqmkywffmogginlvblsndncyksyquafpywrgzfymcevzvcguidleovhscloodboriungoxivrxemafwtroitrocgnehypfomxodqmfyfjdqptqdkzhenrgfxvwpjyydxvacndzmeeoidpylgviqlcebuqfvszwaucpgtzhmrnnbghcffvxewdyirdnpoegoktjkmbuohrdczekottszcxgjxcdybcqpwigixiryiadfbtvqtzpybkqskujvwazmehqselljdfmhnfwugrlgpjpeqtngfjrjvcheekjwunoyzoqdvpjuwaypzevfocrbpsyrjairrrimsplneiletzhxecvukjksfugohstzxbchkjsnwuypomecpyenjasxjmpivfgjguspkltcrklzbnvjnmyptqddqbxitwghqpqnpqxwzgcmulkgngkpgjhctkcafbhreeioapfncxcazfrqdhixufqrdgajzlclssnhvvwvwayrdmrefjeegtriqplqfnioezplofcemuyzldzxjjtzbmahwuiohroudhqckzntkndgewlwfcgubkmwcmvnphhstwadcrghddqoilqhbetnxeaumrdwubmvfsnhfqzsywiqjphvpbwyrxytnnqxwgdtctyslwxjjvyctjiquaqnvqtsynzghgkgyzpvbiqmcfmuldgwcrgsanmacsplnxgwcbtgryymrjgpmikruzbrpfnbcrolvduuvizrsoibswhycujajsmmjscfbktvskojbxorxoreixkbapytjixftdnuyqindotflmonsvypktqyryafgdhddartzamjtvemubkvelpakjjkdmnbcencdwxsdnaasqzxofitdaxzjjkxyylnewbnvgclfmivduzxqblbhpphglmanbyfijgedoipsbsjzeybgqmswufhuigbhsoxrzgpnuctninpdjntcynsduxvjwdyakcgxgfozgyrpopntxlrpeeqkzreajqccaliwtekgnnkvgtglpqhrmqufyokupamvfmrfvwajkusriqtciaalikawdamwlfipmztzixobrmlezutjdsfphwoglyiuiylfywzrbpzllnhilhhwnvgkmiiwfthxlusbybnlzsznnlfrmkdaxfyzgbfztksqoizfmfbqglldtdcukyrcgbsirllcpttrjbbkgeohdpadgiuzqjmrkdzhmefcgedtveyjfxzqpsvtltgwujuglcrddborppqekgxmrgkmqkzeribztmjylvshvwbupolsdiemqpuvcqhxajareqkbmtxvphekuqbkufhbwkusmzkvppociplwhmcztvophnpjytdlwsrasruallbpxvxhzbnmdciqrtplgrtldqfpllqlwtlrdmdtaeaunpbomppoglvdphfwjekqrcihtgxzzximlmieofnjziejhqprawdzpbhehzkczbiznnqczoheiwtoobdavbpejqwsupqtwvvhvpaixrylwnftlyhlecvazzfpaccikrhuxdzywlxdfimlhggjikudcueblhqmvxajgbfsfzwcrqnxaudcfpnpbmghulqvknbssrgiiemtldzojgvbjmkqkyiwiylwrudrjkfwxzejqnuqjtcwdnvizsfqnrzvkzrxwewdhmdvvovvinnivjvzjctshhjbvajznhulzdwwnsqktkezthitpymghxvicsblhubkgacvixmifjzqtmyrbspeogbaiabpvzcpzwjokvnyaulwlmhsioutkuvyvlkamqddptpglbuinrcwcikqolppyxddmjqqdckzswdzdqfpljscwswlpoxsymuuipehkabdhhfphqhznrqolxguzsgdsuhigsobtnzoobipqedkgaxzetudbononuvegwyluocjefmorgznvjjcyhoudikwllgkwnsfuelajjvmhmibrxpibdyekdptymfbkhfyebtspdayitvxbeuolyplmwmlnmntvwjkrgkllifdelopgyimvkfggnziunczutdktdzvsqzcbeabrapnmjvkwaoqtuaopdqgwzbqpvdihwalaprreaxgvsycwdprjtamkihjsnoutvcosqifptkhqlszffjgycgnpnljtgiyuqjgjitzujlloiyahnjrdwpgslyrkfyxxzexxjfduiayopqxzyyadwqylecpthbeskctvbiefjsjmwzwccskkodalhebspbbdkgbonngqintmzhbnitdawqbubeuemvhzudikxshpxpkbplyklqucpqvykapteofoseplminwmawyyccdajorahyrzmkhxhixdpoomtadqqdqqxpbrsxgnoihttpdsyjfjvxmsajmiegjzcufyemadpxxwnmrxrjprwxsgljiphxagdgsgilwlzisvzhktqzazgdmbyqzbzjmcncflsbjfewmkbzjzqcqpcukrfbxxmczqngleihkbevfysqnybrcltmimahpjfiestpqqpjdrjlycmulyisejrmrsrqafaobkizthwphqrcyqfsrpkfkmrfgqsoorxaewvhneytksbfhckvdqijqabvnemnzmxtzrpupcvlzqmbippbqfwtkdresfooldyfjtrsdlwbghkfmejcehsnomojenunadyhtakwnmpjzxpepcwudhtnemcecffaxxjrxcyhidshwdllpcmsvscbdlnjirlgtwsybqjkcoosnsfeovsyicxmjuomonoygwpmcikaybtinatynpaevfrtztarohxuwboyzteaqidlelfwnzmfboanuiqsogpjbddmicpswmsleuzpejbwfykeyiimecebnnozvmtnnxmnfgfqmparoovnlskxuhntjjatevffjkgtrezviucogdfpbmimwlcpvuxzidwivtdpluuhoggdiapagitltmadgglezjdhdyptzvwixtlhzeixfavvhdmwvucnwlrpzcgwgbcmimfxymhvuakyyfeyqpjktistzbgwwqdsxtcgfxwpcmxwwufedplfrcjuslrmdkfvnmubcxbymipvcorhwrgthswkiwemuttcpwrnziihudsybtndutcmcvcbwoqghrueibiyngizkvsedtdojelgvtrmwxrxfggezfgxuomqxbkatkmidpisxoehnlerqfzlrndnyoxqeritwvrfxavauqwljdcpxnbpzlfbqwfowbebzbmkhnoqtfxijpsiepvgebekfbmebgphurmyzksxkysvnokzrstxtewgwyktxrbysumtpxrhnlxaxhagdudqtiqyoeamslvhjxwoewyjbaxoskccbdtrxndcauaqcfidlilqurkaznkrfsfrcbbryoponcxgroowzmenwikodrmnudqtzxekrdqjozrqkcusqjipptixxyqoymnsntbnlixyarhpfrmcydcsmvzsbksbvtsjyufdfxwfotzelwmejysanvlxssolyldqsshoitecwuzebcrsvmeoojvharyuwefebxsslcdwqgcuiprfxscsjmvlhzixsikbpqnbsvxdoyekwimoqxmvjrefcyabfderqprmhsofthcdeeqhvztxsahdwfxobldznotemwdbbuuvwxhbikueebkonekxftumzclbyrtqjqmsxswsicuefpigavepmaakvflhxjtprzlmxcgxmfvogffncqgenksubirynyrekblisakwoccadkqihplgbarjurrrfwwjvpotunusorpiorsyhyezqcusnwegqkvcrrnajgfszpfleixvehbtpnkwococeucpgtbbzsnuhgsgsfkfigwbvyoxjicxkcsbdejovwzvffnyezqtovhggprcjtkisvlqcueeuxdvqrnzauljixbmyarpidzdbfovyfsriwzernxuooekcfmuwfoptdjvqvpojuwgsevqkfnyquonbfrcwptzqbsgrguelckogtqcwuffpdoiasrmzaiakrjydrtmpuxuaoyogbfkntrmtwtutlgtltcztwxfbxsxinmnsatkoevkktgzznuetjnkekiqliwebaonrszrgkstysoyiyeecovrumqlcmsybicatqjlpuyqceyujlymodqipbfqntwaandwasngokiqvjwmzolrextlqjexkcitruufhprxbfulogmirltztasklfkhjdctnsbajfabjyusmsvcotvspslndekkgtnlodcpthgrqgklrcrivmdroauychowjhwqnhxawdzrunmrygelkpjmxdsjciiinfxkknzjdtutlhzmgtndjnsmscqdcibfmscmdaeurbdyzzrsxgkvmejeyqyglfxlzoitgpzbvkqveqytxncggkjzndjiwkpyvplbrjzoavknzjlzlmskwlbyziscuymfkgnwqdliquzvbjflsbwlgwskbhxngknroxelhcwqtwdxhspgsbwkkvhgyuegnarazltcefhhebodgwwedsmxkqwhxnvcuvkvxsrttzvbpqvgynnyebwvfqkquwpwooqlvjhejalbsejphrwopnwotqdjtbmkbzcqbtmyojvpaqjjylhpmrpvvzikforffeoyihwwwywqhjzbhkdteowuycecodwvgjfwlknaperydmiwnhsvbhldznnareoryhbwucbakzadwgtpvampbqglmxfgreivuihjwddfyiexlwvgjoueliejgfwnprnsnaxingdslpdvqcfbmkcyldfknmozprbvqqwrfdxrhjveyqkvhuzouabmpurzxgnnnxpvzrvlbnjkokilpoizbmcyxftgcvzbypueofqdvuexslphdulbxvfwnvzhdtjcihwzjrzbbqqvvioentgbimmcuzxielonkuhfumqpnknojstsxehoxgkwtqwifmimfuavkxrddoyfltefzjlgyrfpejdskbgnmydifejxqjxocbrfdzefzrravdgaoqxdbbaurmzxmmpwgbvjtxwrmzkfpbqvdzyocwyntmlzztnkrabcterzabvbwkptpbvhishfphfikuhcjjewajqefyjetdeexqzpawwzqplvbbfmiruqjcsewtnwxewtdhubckotxkygjeoowkulecikmmczttuzkpvksawlxwpkmqlwxxemgvnrcbyhxvkkhqsfmppqajgcbvqqjudradkgogtrjlvnceuithlvlxdpsyargbxqxyxdayacxwchcpxenkrzdjliyutkemowqvpydlpexkwocyvljqizdiazbhsjmqtkwiwcpvpbpesdeundkaiadewaestlhbnenggwzwxhaxchppyiogajwncrjloogqpumziepdcsikmzzuefpuhetotdgkotxmxhpbvhjetzknawgxtedapufzzbhdbbuhhklyxudhiizpbxqklejkfnmwnkqiegbbilhdvtyohlljzskdhlfykpotsupoekrhtulgburxuqsmdedgixvyschslauidejzvwsykyztqwmlsscduxjbhxpnwpicuyonpvislbwyhlpafjyooogugkinvzsmtbhilggihdvwbdwjdrtvlivcbyxckbbyouueedjmtbsyuluetligdwqzavvwiokjyhoxffwgkmxeujvkssnoavxpjngtomyckxtigxxfcyhsfaaofswsttwklwncviegnrqexrofsflazwxdslubbftkuugdxkjamilmyemcsopcdhfjwyywtfnzblbxuuowcrirjlvtvjzfrvikzaksdzgrumcqenwbbrqzdabnnkcuysglkkjxysgkkgdcnbcuvmfxrsvemconseptbqkvgfbdrpfimzmgaubdundxyuzyezpgtudarsjbguhbpgqlzscdflpkjdbizltklkugzicfnmqpmdroyrnzimrckuqpagzioinhxfqquodvwqnqoxtufcdktfjxvfyfixzjygiomkwvelgadhksxuicmdwnltdprfjwvkmecwflbdbviaqjcihisvkhatgubxbgkvfyrckcfjubrojncohujvanwayusfwfwrrtlphjnxebpxdmxedfobfokdgdbakemnqgtqyhjzclgpzyrqeyqofdunmpwffbetjvgvcmibdrsqjrobxamziyvqfeoupottujprbzsbgpxtbeexfvpmxkagjosvnyklqseilfzwnbantgouixqwageclyrzgyylkpdqsqbtcuzvikpabtptxmbllxefsmcyshuynfzpqhfhoxjphjfalqgtmvxcrkfqoefypgeyghogvaeyjwobreecudbcvmyjdbjluecxgfplyobnqbcwnzthqbttmsfhockrifzhomqpvdccjrponstmoybxjblxmiruokbgzmjthkexezrdbfwvstxgrrohqklcofcjtmgzxdnkgdfqarvkikdexmuvgtganaohrboxljsaevuxvgueqflwgjtdvrsudmhapehsyqsatwklzlpgwaxpkwyeukmnlnfkkjwxfwbjjgcierenvnveggeyfmtlplelxdwbygaasitcjgfqmzdbjvnufjrgtmolbqbjlwpajmjwqgcxjbabyeclgzegqxcvyewhbxexvmaxpregxszsyhukqbgznsfrqdnrwmstyhzhzjfgjobxcoidcbdwanpblgypzbfbwccobxzjoirqdgeklojlauycwimpadxnijjxzqqqoyfqmcwmnzpjagvxttmsfagtqxgfjpbsnktdundwudldrrlwtobysyuadezamsqzcemikxoypruyypnktjbvasnuuvqigzbbeassunkeqfebietvydlnexblfpyhhvfsioqmszmhgnysmvffjqrsunihutqpovfzbptgwvlvldnlczflnpexosjwfrmuvhwgekfbmxbjsdgfgkailwgwsztwwgrszgmaqwqvczvwmyoutjknwtuxuglakhboegzaxsqgxjjqnltvginfrbtauvlzorzfkecqkzvjccpqauigfkrmlsrejxxrqspbfynliktkpmkcdmjkptygdacgbxcthiiqkrrucwqsvalgmmqbxcjyiebawmazphntqlfbpzrvgwofrxmvhjpqtfxqptlupbtaucqtqmlbfnajbkdueqcidfpitnuwreqxfeqlrzbfehurymwxsessuosjrcejhdgiasxjniwvztnqqlvuffxnfkglebncydoiwgovbcsqtjbfapcthimokvpdjwuwpyiqunvxxsnqrlvpleyalxsewyyqyoulijbipoifarhezyslrevcfexerrtpktrzefrbvazbjlcvjaewutoowqxpszwrlfbiiqdbilofyiufiskruokhuuuyirpvhlygvymdrgpzlxjncxdicwuncwuldgfojjiqzdkdagglniksmaspdcgvoujqrcvnbvmfnsqhyewhjcnoyxvjyikevlgqljzoxbbhbqjsrmtgwpddzwttwohgxdvhjmyiasowamvlcpshaxypfjsgyouzopueozltryevdnlktdegvbizulvyuytooykfjiwotcgamjcpoygotowcazycmqddagugjqcrkrxgvdpdsbphmpmohvlomduuywserxiexxzppincgxppqocwgnrenaqsllkpvlcmoyxjegrvqdwuoggnoswraaropqfcppfomnfetgdqbodudwrglzvvkjmicgiyyqigqwvfxgtaigdguitdrjzffdsmizmtmygqvshsslkheqmtleyvdrdncwxfzmymaewavtggkcyptvuctodgdgkyuhfkaocibcnoterkuswwcljyhszvqeaulrhhaotuedfwmgljtennvklxuvhdhwugfnihlyjipwvljccooiqvakydarqnuljybcfnhudfzphhdkkkehsrdwiptakuhedvcfcwgsporrdirxxpbpaafembwuqrsyqqktycjcsnjhgaecjiaaxyvfdsojefdjmitvjerngqzzmbljjvrggdxzzjblxgsgybgsstvmykllllwxffgsjgxkohyckiasikpzbikopqjagkduighesieoiohlszpnkbaplidamtugprkyvpwqfeeapepcvkuryenxguqzgpqqeukcopecdmchisjztaoejjzasumlzmbwjhzfcxaehzloyfvknjdjozxuwigpztfouwhnnkpsmgsrwsuxptixmujgdrhkqaizpsisjwilsslzyralwpbzrlhckebpehpkirxjveeoakcedxaonxqksfkwytskkczaofvydnxtbrzforxcprgimqcajnkgkisdzohxwhpcmdbyflxqotbvgvtvfcsczxpidyhjrzlewqtkxikzwqiktlihhujwpxemqvpkpwyvatkopxpepmxvoptfynjtjimehqqccgafyunyyrldvfwzxedennlobvixmffcvvhrlxsbjfsjcwhjvizqergvnzyndoharzacmnglhhrhozzdnlgooxxfidejqyeudiginyybbdswwyqdlgftptklkhlmoawabyeztuuhhuqsijollbsabngyzfiiqyjteaioxctrkpctwdtskwgapilfzvdgnxpylpwojbqveuaytdknoyhsdeycbmyajxarqvdjcuutuyxxulfgjikfpjsxcybugtfzqpzdyyekcasryrrmxtleqvjirhcoteyopximhzjyjsnwjpqutjimkrwjcjwtavrjtejwmftkdndxzyztsapfajdefrhaifhnseelyarhmrcefimivktwrwzpfxjqvvpoygfmbrlhjbijgufxpctprwpuhtjctxjvevyincokqwpgfskznadvfxauxzgxldsgufpqiiycoohqdxwpejrdlyvvaurcammiozlwcauuavypoofllxerzgbqvatdybtsbqfxuskdrmyscimulxcqmmaqfyftwvwxhczrjlcwahntsopinbdbslrgvnbvfprexhxjiylwymbosvjipcqqbmzpjfpiwhhytnszqzvkugaxwuyobpmpexmpswhyigajalkakpjqciusglynktfpmqcaijksuswdgrqbvmaphbkrcbifxjbyneftgojrpfcpbgitdjmuhzwzuaoxosbnimyndwctwuxnfbpexlqdoeyllbadfvhbmkrlkyqhbdwarifqedxhuubddxqgoosazdopcrrzylkcgolqndyujajkileqlqfmdxlzzmehchgtjtcynqsnvnaeuixdvmjilvpungezvxrqwqvfdqktgjzdyouhpkmzwwrndjnldcmrazfwzbtkqbwsibjyqcsmvqtiyryqlfiziynjpxfuhjzqvfipevdbabgumkmzrxpqyilgihcdixbxhegyivncsjkajuftqzctljfzzjgbgchxznlkrgnvdsgfwpcxwxrtckybusehfsqzsseqpqegvlhnnxalrpelivpmuqilmbbczlrgtrborizdyjzjyxqqdscbwlkweigzrixjhfmanmtwnbiobhitlwwrygprcmapvdffmpvgftkdacspsziglzzpuvouaymvuqttdcicpinpkrvvijumilcsrpmfwiegamvxtlodojoodzlehmjaseylfvdotevnthlikzktnbdttyqpuiylavtzxslaspyddgzypaoqaudirysuyztvdyjsfhezpyrubfmqtbdgfnwqpcaxbvkiiumyrfrqruouznpgdgiuhaxndhjbndubbnsrtizzucjqhvuijcklfsizkdtlgqtqiapiewclewulhmnqilmxitbzddyepzyloypxshqjmpffftoobgjjeagslxtnfvtbjggwapkgkcnmubrujlrcekcnkydygvlywxyrtsoysmwakhrvcwbzeoqhsnangxfeqabgqygamqtjaaaxemjsssqujqicuilxgasxedjwxkvtstypbeljbuninunbdavohphgahawjvfrmzyhswcsnpgrewhiidtvypfesewpjbbrckvozzkrgbxoksdtwsqhpawhlnrwujxfkzzldzgnoisgwllaxkqjxxhkshovmnjtyjvkfoftuiwrupjltxfdsfufddvkqndxozaggywyzzdijhlqsyfnamquohllmkmthmupkwehcxexnospwnrowjihxfpgjntbzcmzsnlovccpharuoenqergfubnclhurcxuulokcamxmmvulhhznlhdpdclmcggoydmfosccrrmgvnptyutusjdqwxlyibvwfzznejrcycfyilhkajwflzxfeqrvgjcgxjmceiawnyhffgliibevbtgzqvdjfzfxupkkonaslnwgjknlcmqmfkklpkyjargpijvzmtcepmbinagosvjxydbtndvyyrrgieznvttkfadpwpxnehbtuznbagtkexrleomqqglnpwtrkfslwyojwntmsdbdnakuzlmzkusygzdmupfuxgiwsrrwriunokkwvecqzcjwpmwnpkztyjltunludwtfzaqnhhoclfvhwarmwkznzcmicnyduvaliwrphgwfkzybwsguytdouceujnymxvjajsyhhpeobrmtphwrxsvceldrdahgzewbucekbkrubcxkskmahcxhypvzymzaynlcxudnskejsmyakbkzuzvbbbtqgmzrgwedpxlufzneqibbnwhkmqwrjhfwigdxvhaatyblezzskfohpotsojzujnzzdwqkqdmognddkrhjwmmganetyncokbiwpkfxlrzbwpglyacjycjoabqljrmcdyqqqqaemsgknczfjnkhusncngjydcydhdeitqporaurbjiwtfbhzmppbjslnkgarzsuwpevlbkxhuxgpveomeyastjyovoteauvpdwjsixavhrkrhuhzvkzcvswozlpsuhyjfamegadnmtexqlpnxlkbsltehzdafyekptwyokieidxvukinnqwsrduqrzuzisiyrqabuazztwsvzhtkofhjzoelzajqxzorerebpfxpuatwqyegnijkfxzfcgaixestvkcykfnsdwohzbosbkzhsekqjlxmjexryptllzrmppwjhisbntvvaevlolilytwbkebixbpexciyntojkfaqfsrqdbyyvuqeiqfrhjvsuqcoylpiguqqflbtxipmtlwpsuzakhzmmnicqasaczgetltsarnbsvwdtcxevxvkdtsalwpwhnnnrsqebbjckintrlshnidanazbmmmjctxbcmvbgwvpibopbtdkrtohicgrjbrmxvnrtoaisbvqovjfezhgwhfxwtugtvagtrcssgyrrrddkjvbdnrhqugbvgugijkmozgijefymitzzwqmgoiayormliwuxnwvckbnciwijcjzczjiuputrbatyqlzifxdsrustsomoxcjwhunkemopksukwkkcuvcdbxuhxvgwbdksotkrkhhyumtrdnyibescimhfndfxrkrfbfwenctnubntxhwivtiizuwckpmfhbkzketogenrkgvcedmwocseyodnwzjqwfvllfdmkufqpgvvznjrsqcgezowwrphuejtcfbhgiytbpelcjykejobrqwdnawiexalgdpqgocmwcofgfdktwskrglzndnxsbddkplybhtzjscfslcttqggtdktenmgspqubvlwouwbryndhlygzwqkjwdbjymrbouuzlbipopjpwjliegbtqtvqatsyrspskqyysytfyzsumbtcvjltwtztpnhatangtpbtbkqsjwoakicttmbovfpiqanynikqkgohwxorruckcgtcpyhllavqwrobgsxibikrlsksdqlxanzxeagckqinhwujgtxxovtqjcironauttyoaoslydzskifaglxmqmzwtsvtjkhdfaiyvuricjvpxhtlakhdfmhhuyxhdmjnwhnhyivkqobnseqsvwutkltngvfvlgrdwcjephxlukmmhvbqkfwtkfzeyxdvrmzqhykzabhamlpdlvhhrlletmnxrrihdsjsjpbwxkvrebsfjyrlvfkunholnzzkbysrhnffcszsasycetnoujwqaswmkjnrpynfsyrkkhkhgsttcjmqzxjkzjwtamzxicphppukwrjsvpjoeyonlorrrhvcmmbkdviuyyqroxahutgobamqboaftvblfybwyzmtblkalvyggswdlctjtaozlxsoxukyxagdnlutstwneqpukmehgscnecsxpnrzjcomuowetwevquwmfratermzqofkcgfejmkhjigwgquwbknbhynzgjrzkmpnmklqrftmkccogvcylwtukpfjawzoquqfpfxhhgoclmqaacwsrxazohtewdwnompzoqlzqkpfgfcrligyrckczltdezvelylqjelakpiugajveqohvvvdgqktrvslhoffkxlmahncwapiwmwovvlkxdxqopfnqcxwgdgrytgxkbwocncnoauefddlzlbohuqjxwlprsmybmupawmiwmufhsyotcbfdbamtploadjtjxbpxmsuyswsnksmmtfeozxrawbjqhwhbxkztphkgjcybikhqzufrrnwuvpujmrvuhaemzviggnkxncsximoefgvlkwaojgfcxeknctxfedckkoatqzrsrnvinorjkrliprcnrrzbqpzxgqolftemktirgwjsytrytdjyziuigtpsdtpbwgpjbngiwdubvxbyixggcvhtcmhpnrosclinxwvvcxkmuoininypvqdyjcocqwxdchtsvjedjpddvtfonamdelwztywhjekljtavzqitffrbtvhkvtuioakwbtvppjobwsrgpgdcfvztxeeeappdsgqqorxvdnlqmwtjsyynwkadhisuqtawrtaxpjjkfciofsuoodauotpdzhxhofhamfhjtfiogjidgnhidjirxitnyjncjqzrsmlyzyvfnxtyyhncevhssbquoygkocvbdprugybmnibmzubzlrrcmjawstxqyvaqvddsztixufgdrvskbrpcnlawprmyakfwxtepwtkleskhusxliuhtfxeyoimivlimgqyaggnyaknqcdlhlqnjeqvabkpjrjzmfhgacvwztxxavpdrilrixqfgstfatepxmngrcjhfuzrbbnutwgxemruzremmumfhbsvdgpcgklyvdbqjtxwlfnvsdkwjvrdckgojvdvifoyfusetwkpctxkhpjewlbgdqtovdgmvuyyugrwasskacadgpisydxaebpenaslbnsvzvwhaehiazowcqvakvubspmrqshxvclwyvcartlkttechjlmdjimuvprvstplvhcnasjnycyzqlkhgosafhyoppouxrxujexnexbgktqsrmevzehiffyzwhllqnqxcmcmbustpzxvingumdvtntrenorrooasyzfkmkfeibfhtmdzshuzeomghvywtsiqcpvskzwppjibiqiahvgbycqtbbrbwfiqnubicmvcbtkwiwiimdulnhobttjqlfrkioomxglnlmsgnixabxinvcwufyfbctfzhiuauknntrypaficaudkuqhpgzjcokhubfzfedryvspiwdgosnkmdvmhgkyseacypuoswdccnntdshvnjksutpquphauqhcgbcybcqhckcvqfsaxednvsglydolswycbnnmvfdytwiqsmylylmzhcnupsfmoqodsdwhenyysrtrucuhgrperyltihwachtkfnghjmlhjxssepyamcdmsnyvzoumuaqumaxidrlbzizsgrjhetqhhudfhatvbvrgysfgnysxahqorvpvjbaljkbsoiwrzxcrdmotjbjxbqbfolcvanodkzkloystwlckqgzutujcocwrpxvlfpgmxsepltbgyzlmcdnvqcizahicesqvipnewvzpdohnzkygmgccxevwlbuusykgejvuoleifzvksoyrrkaopvkbnyzezbtwmlreuiwowcptoiruxzqmsshwypcyoeannltrhxqonhdgrzzpxvbfaewaxbfblbsfstadbtivuiypkihylbzsbafphzxoubzpqyxgapvradezsjrikgboledfsnvwkicwnhxffbphgclhrvqkgewupzsdvpeyhyvrokewxqxvtghuiwcnhqhwubvqutnimepznzklqjawbcxwpzulwruhhouphomrngasdsmoegtceqtgrokunriiubuqtmevfsbmvajvnqubszfojtnswvtjrljlunmooucykqqbfbdmyoplzsybswyivoxendnxlajwciembkmqnpcbzeomhrbtgxwopslndgilylsdqhxvftmrcjsrgrkbvzlqqlbjssmjhaqclvnpjlcvebtmjhzggqqbqanmeotsafjwzqpxzefshxkssyvfjktvqbvwdyevsrrbqplugevydiqoscanudfshoknfudsubclmcrsnbsjiteclbyamhcqkmopmknfwmokmpztkhvthjyyaqtlsyhmiidydvjjhtydvejnqaihnaexlmpgbdfuonomlgilkvibovvxfnamwlknbfgtrmkuxakaqagyokbrvczkwynroshaedhfbulipjbepvqcuyyrowdzncysvukunfnoodfpajetuywwttwmjusccsvwfswimhedqpuxnxviodolwyukkxgvgrhyozavdopwdrbfqhxthciiblvclpkfurfzmemfkgmjuqixsakfhuhqvxggmghhxjautkxgrawbqoxqsazpeiogzgdtolazsubaqgvaoachiazqzwaqtqszvpikshgdnsmogmkrosyatrxbnbhlvpbzjfqfhasgmyyyfsvwbqqhjruvrklhcaevgmaaoyccalbjdmappoegpckvydotxadechmkijyjhefixqiybdjdozsflfiawywlsgpdfzwgtvmmnzmpdiwrssflfgxfcuopjcyeklthynxkeacqteahpthrciaotxygsmdkhlfulprylggkttbpnlehnsbyxliyzwmxncrlxnagfirkjzdavxresqjroddgwxgxgqaylodnexzocreuvcajmopcgroftnqxgqfccniuwynrcyxipwurnuxoggsoqgjusulepkeyefukvwnhkxilbjidwlghermzzjljfwwqeqraqugllgubtkklkjncerhypcrdpaxyisiqoollndflmrbnonhbporiwnusfizyspcaidpoyfmvhrrhukkatvaqctsqphjrlwogrczsroheuygbcliovxvnhumvmlmqeudjcywlqldfxqxnruacjjnwwndqypbeledghphfwccjguawelocvabqsmflbjpjwjztswcdmitidzfxkkjdmunofblxbommjtkfktvlypaljmyfoobmwjgwvisjzqudkourszothzjkhqxckyliblvfocwivuxnpdnayhmmdplpqephjfwhnxduoolwyknuzrjotdmtoaskxhieghvmcosnlfjranesbhpbqzmkmchhzhaffuhnabwcjsnhudzcpsdppudddfmpwcjpqlukylgyortdsbegzurbteebpqemjkufueneolaotcwrilkowrupnhmndrfhogmfggujsiyzoqtydzzxjazykaacghhdijlnxdicqduetgodnaoyifebbizjdfhcdymspzgkxinxenkknqllokiqbduzqxnksccxenpfloabtvlgomyzexymdpnxqorafkufyxzjghromeoxorgghqvucgijrjzextdsfujzkozrxooghjxqvxcyzgtxcdvgruuahluihzlsdmhmpabvbnarsoxkmoiopezfumbgkxvkqutiertnlnizebnzdysvujetjmknfifxmhyrbethwxlcmwvomxcmidlllrxbhxcqqarphwhibjelvpdsguqeibinbzkososracrebveavggtwelfynlsgsbgilyifkagwczuwytgrlzdthlhxivdmnlfsfoptidboatrscojtlrngrsibvfyvqlmazxbzkgfqzpmgmwiqiiqvmvjjgwifyjqocoelclxqtfnjcoaoejnyswowmyydobhgwpbgfrzrzusxkqppkdkfimizaquuowaxxdggvxzgskeshuorthtgolnvflyosgwizhksbbxdgnlwubsxzaawsxpympjbjxfhrdpsujmxfxgnttlvzawycahrzajnevxjyedwbiznfgzlbqgiqrdmfbvpqppsnekqohhgpiimykcwugnzuoqhfenfrfoxmziepsimhdxomhlznlypqdsszaepikbfibndujlaaocqhfzvpakjlfgggdkulilomlqfgjabweeczyurrttbpajtpergkulkxwkdeqpwuwzdndbktpsnjururqzfmdcjbiiygumqnotgwocitcrwkvbxpubrnlufrvaaanahnxzsbwifhtalyunylqhizyyytthnfdjroqlkkyuqouwashxhtikfhebwtowrgcnwjxeqwsokskjgmgeqypktslrerifnpqhocubdsfteilwanqutqtrzhkebcxrbqnicijgpyolpbgrvhtwtzddvuvtdxfgxhuculmxchnmaxplvcxupssxsayufhwjwfirkcgcpgqfggydatyxcrfcthatqjtnquntjkbnjujfqcrvzwylbglnrcqbbvqcxwvzumqukfwtubkfhmyyugpyvloehxqctadagvwizgjzshyylkhvgnuhmdpkkhzathpequsiomugajlstjnwhuoucncnrydfrdhlupjpgpzocvllgqviczbvjazzmwtskxftscqzazbkrgwrzyojwksbdbkboyjvoobcuhipvzcraxqnhsxmtcjmybtcfdisrqjotszmfqejyaoamlykpxazusmhqtydiafanckapmnlplrvssmcfhasnnqckjkdlpdglkscarefgpmlwhjgjwsxdqhfbrwyqtenhtbomsnedygmbgpcnbkshqizbmmzbtvnaixzrfqhsdcoktxvoqgqendnffvodwpaascpogaahiatiwpndpkqyujtxthwaovkmcoocqxkdztxmfehvprkfnbfmmuwtkzmghebczsoblclzfedpvuvqmjghnwfhdkqjeditumgmhoxakcemfeehlllaqryjeciieuwrlnkbgzaxaiyoyibhthmkkuwakqjiajffjfamgdkprnoohyqtvsawuhgawktorfuwsjirddtmxlsppwyuyfrublpbouwauqvbzituzzqjpgvmbnxxxbdwmgjsiaxsklezygrdzcdyujkipgxuktzasbnmoijiiikmygkvspanmhkrtqgeztnvuwymijqdrikkvhmjugubblwazenfjboinrcmiwcnqulghnxdelfzovwaaxwinsehlofbhmunpnmvtshkrscgqxibdfcuaqnxiwoovuyosvoerqswexwxqaltfkjvsizyvjfzyhdfxkyaopdzhdvlpxbhpejtjakfzaulihkztkorlnshyvdxejpwyowiwsajtotbgtbgtkuvvfcmaqcmdxhsdxqrawaodjxxetoamhbuhfqqnsxztfmqdoawyineysvyyjvwstqskldzflgwvevcbaswvciarbbwictpqztcabeqvxeyvtsmgphzyzwslindihfvsmtzeatrziiigqbodbnjlsibxxcpsipusdgsdbzgwkmrmbcsujdufbnhatkjapoetkitpaqezplmikjtmyryadrpbfwjctlsodmglogsqregflzjlzxgzbscgvcrnbyldfpkvxehqtkfjrajmwomtydqjfetyimhtmzcgezapblzilfbhuovozsczdjugfutkoznyprtlbseqwjjibjgbmcwirbgzxgenzxycrbgwnphusrxcassmlimoiwzfpqspceqooydrrygdbyavcpyjpinmrvohqdqqgnxnjvgajnqxxuuhgvwcjtqfzbkxwhmuybigawckjnwdbvkwwopjaaxajckcjsslitzeubdtrfpursdbtqxytgrnimarctvbgdktpuchjjbcldcehmllcfwcfvabkwtxpbivgeobofsfrjfabujbadtrifzmudrhwuchqkvadrmddqremfikcxyxejrawfwmjfffzxphdrfcbjmtikgvslzospznndsfyjbuwmnbndujppyyjlkskndqmuszdwxbuxrziwznnsqratodxttidpavcqgbvbuprcyknbgyowhgcaubikynsvxfuvgjsxoejzmjmfdzsnimvbomyfbckfjxpuagiahxmounwgspwkxsenbzaypfsvxbdggkpaqgmvorehsuwnchueksnfqhnbyulxrlbeibivbqomrtimcaexaprqzktmbksyqashtzhbseyxgaxlxmsdoosufxuyqepycxdxyvflmxejemkugbvylblpjxettoaalywhrpivmyytpstaflkrjdxprbwzrinipbctehanbemvrxwlapqymguuoetnulzgmpxykxcbrtugouvxqrktwerjopxaaltqvlppwhiezyexdcxjwdiurozfupdpuszsspxffrxavzxecdqvsenggjjtlzrbvxoourkftskwhcqwixatbcxeqpemcxpmurxolinchnxbrlsyifhhcogoynqvbhppobzbypfeglddhsdznnatgpqqgglsczdyegwhjhwqgletvnoregfsoccibxvsgsnmaxoxoggjhttcakcyebpqnjauoujdcfyfuzmuhnzhehepruahoshagoixkvzedfaluritmoidmcyteasxhmliploioeyinlflndmiplkuwqpvlvfeuddcgicfbvfnxooodaygwchlvpoufughjzglkwmugbbxacdspndimbifcpiumsdtwrzimrjdquqswjlvbszrbezbmfsoxatdmoliubcaolupfrvfmbcfodizpcbmskbdfmghpckikuyelsjnfvgsbirujxkemvtcwrmplvfqmkcnsessxjoupernhkqblrmqzcyfyvxperpowihbtxajztwmncugszrsxwuxaguymasfqczzahmimqekwusouevtznuknwmblrhfnpulihvkhqxjvvqwkutvtfrrnaurgtfqxbgehqaxxraghczmnlcwoxyckkaqxwgkqhutaybjakepapgmntqbiyryzvyicibtcbyroekscvhkfalcvlbygpeouxspckoljtvogxvfqbkkrhpzoklvxrcctyviwamufckszwhjryvsfitpxeaqcjlnvhseuxsgcqyewwripjqclndfpnqlefqsegxxzkcuuupzrchcsixattsgnbpareuxbqgekhyfaumnclrxipkvrmvvemjslsvrxesoermrztcpmpeczvlbpzilccbzkpqscnozahqmbmnzrgnygsruqsypbgmrogptfsrchngaaxoourflxyhmtizyxwzkcslepfkthspkrcqkhanwfcbhmbwahhagrcsyukffmlsegfrcpzjmmagorrqgyzgbnuxdkuubkcivyjutpljaayhxzirxpxtkykwdgiqagngqmtpblttpmnetkbjjfkbfxigcxfzmqmxnpgterdlgwtmxgboqjassfohlhglcjpxwxkrlxhkhppazetmsaurbyselnqseuxijcqusmbudakskrocavtgzyvsbzthaqxvrgzsnszcfxpcdyfawraiackgxcorkwlopmjqmtgeunmhoatonitqmfsqwsgzowuailfeyeuevxymriywicueeujxycoxwqqjzdppzewtsajqgblpdftucgcchvbjexmffwhiobokqyghxndumkbhjcykxkpvnwpudiuwsrulxruxhmkbuglcgvxsvcxomkctikhvdxmldfgrwrhlluveqwfgiolmxtyvbfzziwgqlnojafjnakwexahsmbvyrnrheokypfbducqdzetbxgahfptpnllvupbrgduzhhjkmafbawvsfwchiouatjsvsddksdzgugqbsuaxqbgnantozifuvpwtcuwjicbcydhjumfybqddtkmmuympafggogvzsmxlpiyhtnvtzyctcfxyygzgpawacyobgjllieqwerukurvikkhyppgqtyovkcwdmznvtpniyarxcjuxlcpiecxdztnzwofolkmziqdnpllisjgxvdgmlpdrzqugqvvlxcepwalruxfplccclszqmktwetpletdhasumiihodmuvnmztquxyrojbybfsrahodhdtlmrlgqcfjfmtsuigxnacatoernvzwpuggzowlqbanbqvirlnlrmsbquvvdlqkrcajvirldgvstotuonjrotbroaisnsfytglefgfcrkufnmbyncovthhjtvhimlxlmiinrpwbxcnfxubgkuqibanpmerazftpwwnmtztkqckzlfuezqtfbkngvdovhgfwmclsqufqrucfafuhqiyuqiliaumjwgwjaorwnotjbgyrhshbuhqgzupuskuvmugnryxpinjeczpvqvibernxyqrwgglnwtnfsnoxizchcerbxyinqhtaqyblmetncpyeorpongszyxdfdmjwdtcopxzcldbwocufhisbiexhmbunyoehacwhjrjdvanepixifzisxgergzxjburnreiwbbnvmzdgaaaurcsfgkicpwxrbrbbgcqtoxqikagwyxhkmewehtymhnyqbiwcoebsmklxnybdexxsrrfjsycyphysgluerlbwqkpxkvzbfbzyrvhynwvsaiabbkgqujvjafzkhnfqysfzspmenhobczplxlaonraimxccfouqflwdvzokaguioktcqektlcmusxgtfuknzrhfxyapakrwknsxfsysrbynfvnvvqiwqqkbxjfhibysqqjrlvrwkrppcdoexipgwbvwgmwhjfwyhhhrohtspvtehsnruennzaiivyjsshaxmjjenvksojihdsuahgkytuzuylqbytacgyevpuynngyuzkjnuvnwoulyyutkypcmaxscxntrkttouhaycfivdegtadhfoqzqprknfmpqbnnoopbclknmsobqjguhioastqxydouddhpgzempaxwjamoruvyfakynjkqemwszykpfaxqzjsjqekqbcpcbouwykkxwcifwyxgbozyiwbmnurlhdmzegrmyquombzocfmarkvesytshoafbazzuinmgyssjjgvkpzgorcesqzocxqscczvywybuubczoepugvaooinrzdtvuipxwtujxbrmjdudqshxxacokqbvretkqjzcgktsjvmsyagnmrnmsmxpbqxvmwfevqorwagzjhwheurmtsodhtzvtweqlbrhpktaqkgxtmsrkbomaxvbvdhcbljffvfntsenfmehtqaemdzzgyjzqpbutfdqhjueivkindzrrfdcdnvxcwwbdpepfqgcszbgdcfeomlaxpiktxyutaaimylcbswcyxhagpipcieeposmwczmwnanzkxivfooqzwcsuxzukxpuhniegvotlguuiiwgdtschftjrenapwufukkcfioxpmpnkdturrhxubtyqlnojibcieovoslnnbjplnmmjzmtpkvbkhculoptsldsqkyekiosiuudvfcacaaozrozpvkbiwupeknlydviywfctysrqhswffmfjzdmxnesmxiepkuixwctqpdcydxsmuicteutmjqjnizlxkimaodzxqismbqvfjidixddukmtqxsjjyagisiwylyvcrykyaozpgcskbkfrwmngwhylbwihlqgwucljpfewwyitrsjhhvddltpozluoayhtxqbclagiutpllviwnsbdlpufbduhdfyfwdrbunsrcdtwnpbkpzfrqcvihmqaxekonkkkgalarsrmsisnazkwronskwkegsmjrorrikucoojqxrprvtawvjwhpgplkzxzuvrftqsphynwrxtjizyseadjzebkhckfyvhkviyeuixokvucyyqellslpejtfgtvpoqcuvptmtjobdqdtdwmdurirfofqbcojssmgokepftzxbajbujswzgutcyggfnoorpaqoaxngtgnhpwxuizupsorfmxhuqjqgspvdwezrtdehgjsdpkpfkyvafcjomcfjmymcybyooltpllijckohidgcqsytxcetscfswrwmwtsjiekufxtlvkruuaoymozynreljdevbbxgegahplbngiitpwxhwcqtbnpubbgtmhqoyalvywyoltpmhkfeumltaocyulkgdanvrlymlehjnpvbhocupglbqaawnlxmtewrhvaqyitsvzgftzuwztyxdhuiktlygzlclybxdppnvdofpyymvzpyjsooyemygrtztzqkteieigypasgpkdeszmkkxnxebaucqqfhcdkuhcletvkzgzxctswghxamwbpkcvipphsjjiqsczkqvrtkehsughvpoipvsuefbkvmwgxjerzzihqeerogtpuzfahcuxrqkcvjqbypqyeggbrrhkznewvktavqwxhwxyccvmpbeikoznvwnghlgtlcqwtjihqeyahkpmxasvxajfvyntiwumcgergwwncbjolcjrywetqsckbdmgspzscudjohvweaedhhwmwdteczfjcqxsvkqhkrmablljlxsjklmxeqamernzrozsjrzhaqbrneokkqkmnyspgxltgrybvjlffaocrvkujycjfyoozjyjtqpxgolifuyevlnrkzefodqckfaaxghbfgwidtxihmqysjxubfmkosvaxlgaoaijaumazjqlajqjuokjknkubdmsggpceonnyomsbwqgobbpyquncbrtrndrwnjqmdhvzyvmykyzfycfuykdmqftgaaropowebbdzekveatmuflwpqnjazzreivaroqcqjhantrfcraljwnmgpnwxbecqtpxanzmipcxclcydtpsbhqfjaygpxhzaoromkvxlnkconmgqnlhguzusavdboqghputkhnmqdkjgrpnnvmxjknhmgipymfsbcelbidkjoxfjvjabpkuxdbawxbgbccwjpeviqemkourzjkespubldhgvjyjwzgoxflzcecbysjjkqseygxguexrtsoxalmlibsaxpmofkrjcmtupxanxdocyphjazdtvzwxmckxmksznxxqfvfqlapmihujrfyehcmnwuzzdwbqqbbqemgkvaycwnrasordiyaxgxrdzkiznuecbikpujyizdikdefbefcokbxzzhanmgdppqygwbmxwsmkvfmusdpzclnhtsltiwswenafhddndvzbrtcvoxdqczhgittnttgtxituowmywrufdtzizqzgxwgdfbaaqpvtuiirlnvjuymxounmogmmaiuqdwuwggnozfsyifrvbctwpgtmcochiarywxgqqhznfqxsubdnydhdrajrlmukbojezyaxnkydbavuuptvvlkmqtsqocvhbulfdkzogpyhwzfsnhvqkbaqcuhkwkopbowasobzsnqgwceuejkuqxznidpghlhmljupmnmthvzroqwadgnuuovmgguijmcscjnfpvwnpzntatplhstdapjuxylhbjeylbsfptqmvrwfihldiwdjlydbjaslzsubgkidgxpzsgxfelzklnzkaillfllyuwffcxygrosszmdcgthjyeyqxchhuwzqbtcyboxgwmyhptjtvscnqpqsdzbpmsuduhfmtkxbzordswatoozksuispyzdspejhkhrecobcgvlrwcxbmllfbmpgnvrrilodwizedkebyipyakhqksdovfafhcjbfevqojikjmezihczijgzdbkfyvsgegukyghvtjpvaflaypefvkqpnwrlmpsyrwickmcqipfmwiqufmgqhlsrtwvjouygyucboymppituimrrdzsdxzndyhgvfgreuvptgwjuqxlpuhasmgouceyajfroeuvnipmhmcsgpolpncwdtzgvmgrwqkxbqpaxhqxslmlgomtcjhkquzqhwknbgtbrzanxdhbirlshmpacoygqhkpshwlidaukcbkbkxvksvgxdozxqwglqhztipvlyrywnrtlsusxzovbtriejsvqympprfkoytdkoafhfhseunltsiyrxvmtyphozbrgmkvbtruizuxjurwfqajmazykgvaoalhufxgxqbqaoxnuafamzzykuyziekfezhqmfwhsdkpqjxqtnevltszwblnzkcbcftfcorqvcbxsujglngqyugimassnelvdtabyoxfjtrgvimojvcghuxjkqwpdmvbwbbfelnzrosgnybnfhoedaqpruczudzifokvucolcgueovzhvdyargcrbjmdxdmkcvdbaymibntqtjvdsuxaqddnuhwznvpkkmvhpdbzltexdatkfsqasyatdjqyumpkhvaqjnnsufarnvgtczjqsyxxpjrmlnmtdofoiiubkgtuoakspbrtvcyxolpkiadastscxxqgwqfiorsyihqkdcajhdpoapytddviovtjwrtdxedxzqcftoiofahkxusxarqbkdfidbbamcgjtdidenaknpgbiuhdzucxshtqikhpgxxjjhmoavujbuecfmltpxvvhgmdbkkytbmydptotrvzxzphcepmpjitsyhgagjnlerctlbxqpbhndbiwsghnolfqoaxspdoiydcmxprmuabickdnqdhndseozdswvfynzghzstqpnttxmnbazwvazwjfdivubbjlvizfbuonlxerisweanlxsvrryihgftjeryxhnwyyenwbhlxjmxattbanqoysqyvlokgbvalsgpptnpxdoooghcivdnnxrlijohqvuedtbomrxbykbaqshqfgcixillvyssfocamtkpjnnqezslgrtuqdbnmbhybivqnbjfqyuznjkrmzpewahyfridjwtoojgrccdndfkihlfahzfydativeuzhamshpaogdbmsahuuaxdrfavfhdcvjfjkesddrrrkndwjeoeuushjwfvjaodctkboiitjquovuuvlfwkwmudafnsjzqffogcvgyedcaomwrgdxlcxthirkmflwbwzxnleibjbttbccpnoygpiersurrhuolacjqqbsmorxjlanxbzahlmaifknwytmtndvqrauiyvfbomabpruhtrytpwrgxqefudyucbvsctbfakslslbjxqeomioulyptlwnrrsnzwgdtjvgfufhiarmrhrhjarhlmyttnnfnrsngyaqzfmziaxriuxhdjgvfizgvulxifbtcffsupjjrgnubqbuvsywszjpnzrpnkerkwxegkxxknuqasztbqonsadwzxdzninlqieagolwsyqericqvhvhqkyowqkackjbtdylgpkqgyjmmhlqtwsxcjvimomjameylnolfewkpwjoptvnjmfbhliwhyatylfmztusoydqoeqqoevnuqxbnjtlkfjntjxderslrgyixewhedurjylmvpaildxlycwragoksrimodadatpezgyfywhtnchhpxsunashxuquuatwsgrzixzqlqnflbnkpnympftldhbmmdtxvonfpxkfrnksgzfalsyffywayrnuitbuqzypwccdfzusushyzblxgrlodhdwswvzdfygrokrbgzmfuexgvhydtxjytkbetiovohqemccnzjbbvjzhifzpmgxblszroxphdrrmcqtrxnnxmpotvwwnrqejrfbpwunjnfssaughebetdyogkpxhomikgilemujjuvggozqhewvozxpzbmyyrcwejqlqghnoucmkrhidbuiopbqffrkhdijdazrelsmtpcfyrverjlmphuhbresaziehecymjxhpxskatjrbzxyvodiwllnqahfadystuqxlovevzoplcjqrghelepkmhhbjgphnyxrtrpwsfzdbbvgzrgibvkufccicffszsqaqatdpomoyevlflspzohdqnqrbltajapqsrcbhrichglovpsugntigwsjynvzyyilepcdbxuxtrmbclzybossorrxqkfscsggknyhbytkzkbdcsvhnoypssnkeusanorvcsaaftqhcycvjezsirrkasbhwtckuhobhcgejzwekkjzgcllbruojnjqymxnhybfgdlxibtlantbhbkeurgzcnaincqazeyrnkpcfpgjjyrsquedtywygbbwyywkojprkqrahhbozxtmxcposhzshcjzoitkdaiqcujprdijuhkvvdumrqcszsowbfmewnyceuahemcbcfdwolfsdjawgvtljlfvfhvkxzpsglaxxudbqruoknudhxsddohelkmaejkgucxlctxhpwczjyjqouektqhckrvnbfqvcjjboogvdginlnnnyakjmbpqtnoeeppwelwludqpzthnerqptpgfgthjbrierhgimylnxdhrdkbozjzwtvgetwkyxrydysqfcmptqdkjwcldtpzoxkmmbwwgcwiqxhpdadzgbmtjhmnttjaxnnkkzssfvjvavowpmymvdgqtkwzmnuvjaqjvkfgrdxalmatmlxofknkqtijcrnmymqmgkqndeluweiuvfkkuirqicknqnmdlszrsdobtjvdzxdirkpygybexeetzpzstsqmptcvfkbayfmrbbkzfgmsuehwgfzmfjtzaopngjxkoimjgilcjcwctqutuloxcrxqdoniaaabmrehqczaufdskuhwlajytqbdsjqdqhcjpmimshsjijhvhewztsvmxelzrtfbyvpeguslwuxeibbmthmlzvnzerxekpqhdpuhtxzktqzxamdjqssubmfplgtbtdrlnmvpznnuborziimbnzinnubwftqcgevrdjnbvdbjfioyhzzorwmnuglcdkibtfqxdkpmuyyerfkfikclitmsttongyqihkfkyslqnvmsaoxnvulxuvyypwmnthqgpzcigcaxrhqugthmdrrmxsrohsovbxerbxtqehojrbhsdccodbobdexbeawppxcipxofrinrnuiysetnqhuyvshdshnvhkuiemfatphwwgkmebxrtpfvswkcswxuecuhrxnzaypgvorsbvqjkgwbpddfqodvuqicporozonqdikbfqqrnelczytbyraveqejiwyqwvzdgmhcsuceipomqlmpwmiiyfayuwrwestzfbbvngbildqtpnoezzlzmyfrxgrqotarabmyuphyhzohmgkucumatfzgaqedlyoqdlldcwjxglnesulnaxsijrjbqhyywehjjkniboieraygpdazmpfvmcigmyeaaitwrdjybusvgbgopqnjxptxhfsrkehshhivqmkaqvcilzqjhpuvqroblvhskuijbnlquaivhwxjdxvgxfiprobryuafufdycpxlssrovqilfpfywbobyakfgmmqqmmuzrputzgvwzljqwebvkjnbjzxpjdcwbgwifkdcirxlzyxgoflnaqncmcfrqsrbccmwahqyflbghxlpunwnwuhiawclpjnkewlzysjxfwsmgxzibjkmslkzncozaraoqbtedkhcuvaurroszejnumznvoqcpgvxqiyifihcnbmqpbkeycrikeduscyqituqsexkkralusunlqkspjzxiykwehmnpoxmrivnavrjwoonxdcbnwhlhnhvexsatafcbyfojczybkotubuntktsyxdfsmunwqavzeifiqppdfqebkyfspblouunaarydssxmwlkcagwhmebbtzljedwldyjojaahioyfttsvxjitdkgjbwufwsrbjeedntkndzfrbvwrttjmcewmxhiydydmulxyeyzoblwpprmerbnxphxjivhrpitpuicyjpadlfdofwvkhzyazsrnbbygcvfthwgqrqaqpyiwgcmdqerdtvyuxjbppmvvlhhcdqeeayxnwpafdnndsafzzjllfujffxrudmixvnpxvesqhizcpzxpznyogpcrgbajqmcktlgblndgaoofzmbroydeesfinvdprtrxkceobbamkwbqexejdcjkihlghmalxrzyrjqainskjejpfidjzuqnknozdbcqcnbfoqnkdvougfvkdntwufvuyyptwporrorgkjuzxnyjvhjrhminbdligugnpfylygeotqesdsngezkmnglczruwwdkafmhlwpviwocmypmmhibavhgsjtfmxkbwgymsvcpqirqrmdcztapjkbbczkubwgitovuxzigoowokfiqvvwknktrtsxpyynsedzzlwswxulzokoziqetkxqcnqcgdodbahlxqamrenafyjitftjiesllcbtuuidebomzffjziwopvyvvswwkvlqqjhrxcusakedbeqrwccwognvqihnfthbgqoednioujzzvvhlcvovbfocskschqfexnzrnopslenbibclrpaagyriugcptkeayruscgjeybxdxbifbboxmevfwopnpnjqdpfllurffphbckgsbwpwanchzswozdejoalduxubcgpbxlktzlefmksllxxfvxymtlesokzqnkrputpxtjqllzygyrgunzohjqiuncagdvntabzsbiruqijnsmyyuuwmbtplhnelzontgdxhmrawjlyjibkgjfqzmnzcezyiijvwqwegbjniirbzykydvwuomnmgpisfldzecofywrmqfythfxoljakqcjelhfjnzkntksxyjiotbncnnjcmsxgeqoyetzeteampqtmkrhkwlkjyvbxkeawocwtturvnscqioauvcyweheoitljchjbvtsllgogdbftaiyiiskomwgfmyafiibrystoakdzgxuxpbqrkcpvwewnhugsvrdxrmvkstiqgzduegcftwossblafgfixfquycrpkzpqlpovmzklrgmhwjlxvpboggkipafafeovzlgjolthtcpmwfedrakzdjmtwailpiedmwgcrraemednvpkepnromuwgckcoaraldwbnastpnszeocbfdjkultaqqjdujoifyqujjjdujsmmshglsxklzbjvjqezvjqqgamtlacmplpsmgxpdcpnhchvkjwrkwhkjxzexodshbecjxwucerbgzqlusitsqmwlviirmptgttovxombnbpgapahlbbjbaybfuuzngptmlfotsvvmzjftalntvddxislrvtktaazoasiuivwjvmokwylajlkffieylxyaupvqdenmdhwkkazglnnviuaytbkqyuphjdtfatwuehrzzzuyvtupdlvmlfrbccyknunhckqwjsnagranuolrhywzbnyezcjsmkcdtbzxeryiuueiozfkpmwtknvjyvfwlqhfjddhnpkyicijrbcgebhtczbncerdevfcagxldzbzhnhcqrvusyphqrifsrwxanraecogxdfnicjiyqthuvfacdrlpozmuqzbouvgkqbldjknumwfweokiqsgdxuggorodawuawmcnagdmkznijoxykjqfxaxkajyuljgsgotoucvroonvnzkukuwtqkkthfatfyjxnpvytiesrxghindhasnkmlnbxhdffueyadhnoademsdlxianfucfwucarwtzxdndkwgljyyhptnsoatcgkuepmgrzmzbdgzoycgjaryjrqdgwtfihehlazejbxqptgmguhvxkpyngqgglybegtppfsqiytzhmivtljzsmleqdwaxonyszhelzkewtpcaeucvvmflxnpgezacywhzffrtegzllfvfkmkuetiqivpqdpztiuvnufzniyizhbcefmiinqawumobxzvfggfbizjwqygdvwfqlhqrvoeufrcjnhmcbdrhxniegpvbbvlavnzqprwkiuvtkjsesdmvihpjrmroaakoeptjvswbjjtjmynhwxsksbhzkgnnhlppddrorutgddnapdcuqqequtdierrpqxdqeozieugafcbimcxtaefghqrrvyjyrladqctpkpatzythpdthkvupgfajwanjayrftesaxgkensfihnzlggrukrzdlgxtzngknlbrjwnhpfmxrvlbwxipdpucxjpixbppqwfoapbafnklcjxcbcgqdgaghqkarcofcvxnsfdwbfxdeoztmwsffdatailvbpgehhbfntvoqsdbmupxwwtvmwqejrdimagghsiiboviairwlutncfwgluvgkexgfwxcookizrdannbpsqpfnohxclcdzcmmmltxiotaeoqtvpzsnsbtxhxjbduxwuefvcksgeesmydlpombmrgdphianemmgczqyojwvgmumpjrgtclhlotrxlzaaiaihiptrmxujcvutsvbrduulnhcjducgjkkouqbrawhpbbvxzwcomgxltjadcnxuuhbsavhcbfurvkskwwwrrpxsnweiacckeefapqlqmfizjzakxckyityciubnltivscnltvizwujxepdqxrpqwermlbxqmfsyhkviuhvgematgegjlusjmgykmomrrvwiqsdwrdrqishpwkkhbwmtdhiambkcpodvxrtlobhvrtylmgythpsgjwnbhezaazpvnawwydnvqvrtsbxesjpidzczmopvdgumnehxlaqmpgxpivpotfxphnefrrcfykgedekbtwpamlcamftpgrniysaqcebmxwadeukkeoalocldsyxuluhspicqyutgoigqbsjytsbsjbobzyytqmejftswmcxwzuokgxiwcvnhdlpncdldtoyxusnvhiymikcqtpxzfwdtbyoexarmjtpqwkfawkzhwmebuijqaceqrfspfkwuskjhvmxcpcjffkgxosjsuxtsukjjuktyxceerrslkwpwrjjwsmttvlqfnihjmcddeczwgaegckxbptswcittpedetwfpolkwbxgawecdwusxslofuzxlzpoorypwfkvgrwljciavlmspliyapjftqasbadebugbthvztqujcawiqkumfpghxpyeiztgpxhoorcrdbozdzqcsthnfkcfbesqxdsgprhtahyedovywoxwnaapbwhueslquzbejyryguxyvtftkixoxkqreaqsyoifbspfvpjibrnqqphjzljlcjmahvhrluhvthrsrjrhoybqollvwcivltbyzoxoxzplmlbnwezzewdfphibzhlrdvlpxmvzhplbinxjzxzlzagskjtbmsunoxovhouomkrhgxhjubosvvesbfzdshtjduwwqkbobmlwwmyqabpyopvbhivqucghuftwgsrefazxntyhetzkdgpdjemcclifevwtabjcwrnjrdeenygpxmcepqfgecbatbybsphizlmgtqtafmzzjsaottvxctypybbjfbtpvvedrdkkfyluapqioeadgabvufuxcfniefzixxhqjsxvazcetnviwuusghaefalwzyiutckhbmrksakfcxsnzwexsjtgmojwtifbnohrmgtclzwzbflljcrixkwdmskkwrauysxkbnmykbbjwdtroakpdppudlgbwvpfkmkkfnavyeqwhlwuloawbmclzwzkmheixmlloihvybvfhxpskpbjtcrrmlcpfuwyjwaswdwrkbuopuwkkxixrdvpisfkzskpxwdxuyhnpcmsrigdszwdprunreabibdbathhlosgfdcleubqplltzynpgnliqaqecvprcwebllncnxldvhjiyrleyjadogxuifclpkkrvwukxwrmtlhnbbocvvrbhxfwoturznwibyakxwbscxnwatsrfnxglpmwyncbytaqdrbgpxtowohbjhmpnivcroaibfbzocaaxutlmphuqxjqsazepmvhbtedzrhstblpixrqvascienosensinvtrpbalshwioktovgjhmzumwkrfxzvihmmojwvbifbtutugfxmxqmlntsddpnyzmuvwultlcsmnkhoqedxfavcvrtimtoqucurlcquhiyqcxykfssewyhmqyvwytrvjqgpujyzaeagqpxoqbraabqvehmroogffbdpjxyruwhpbclefbhxmznjpzljpatuomodmqywaoelklspitpeqrmsftxuxhugknzpeilfwgfwqspujzdqgxgrbalyrtxfyyescjvitotigxcwlqfbmtfkgjuryttnpqavcrdjhlsyryublvnspxamhmgcuozauffodwuasooghozmpcteikaxylehrmypfpamahhfwoopsqozwlsgcgyvgflloxntxfzwguilekhoggrvyfgcxiuigpzemvgltdyaervxooosxwwlacxmtqfgzazhmzlugpzvilzpoiujcukdmoanacxqkhvuoljtudsuojacrsqaxvbrhpwdrusdbldkcrooxljhoaytytfpcmtmrozdyocbpsoevxdkzvxrpzjcbspoxflxinqsrjekawhzeaxazwgciiijlbkubsxpnvltogovoenqqxzikxqnnelngivirzpstxqfkipfqmctyxbdlfloqnjijnzwwaowebpsenmemgbyrzjsgxjjtxmrlhpizpdtpzbtchsyaqbwaeqqajlokfzqbkkviskkbsbvtpisfhpxxswgnvlopbfhpwravufyystrxciarfzpezauebouxyivicqbixujmimqrsbssfnxlkwymxbggzlzwgjychzylgevlvarjkemzhraohgxljqhilcfgpcthgloxgkmdgloqmlqskrmfqocbxhmqgrcfimccoecioiqcklgcqwxsupgjhypstiqbtwnzxoqbvzwdovlssllixcdfiwnfoagsmhjkmxldghyxgdsojgiiqxgwtxynemergqduorllicttdblttiobdkymldkgibrobqwrsplejjyhzthciceljqoldkpremevgbfcqnusjslelezcsjzsdwgbolohlqjnfqqyflwukugfhpfihjrkobgezhipzytjowuajwqililfgojklbjmdfocdjcdqkspiycfpsapiplyjnxlpzcbfinsxtiultkeyvynxpjmfmlkxhtykhlcqlcrpdkjbqrtecwmubqkvefopkjcmwylraxaiyzzgfdbpmcmxanhxzxauxiadtlkannmnzbincdcokbwsxeoezhqxxbfotbfhxpyjntygsizjmnbogorozgoitqyzbcilgfmajqjnqkbuulyhvdlzkefbysbrxevknrtowjikjcyqxadmcnzkbpwifkmaafwxfsiqzicwqsavpdacoahxbioyxvveaafizjcqljzyrrkmiflfvvhibqdygdhimitbuwipvxzfldfoslgebuloxjgbhhcimbdqdtnuijivclncpxnmsjfmhtbjvzmsqngnjwtgynaumyrmabzmbfpobwfqxivrnguqxchrzpgdnxvhvjrnhtsmwxusnumiiyzhcpvrjykitkdnsntomssqhhiahuatsfjfuyrbwgkftrczlseuxaatiwwvzbdjgectcjebnqocqzvaetiefwrfkfotmgkxewgartcyukhrzkzejvrvhdmglsveddgogghjixkyytehstxwdmpuxreebmspptmzqsqwtcbmcflhlrekhvdvlspamxnqftcrcxedvdheirtnfhbaxmoszslbhbalcvfphdijdknmmgeuddfwfqfkkshsippphbiehwilbicxtjwiuuzahnsirofgtuqgwzukehurzujpggrvlaosyjeshfdrkpktrjwufkpsmbbrsmcumnbrjgcgvitjbmoqwvlprdrydurppiwhqfxtagtanhtyajzcahdqdqkmdhxcttulxchpamrkadbzstthjmsuvesvpgzpggiglhcnubggswuqscfoogmflhbgqycgalmstnmfvnquujrumyrutnfxaatlpdvlusegoqnmrxikleckpzjflgphvcprumxmrimkqhtujitgteanimxlkztembvgszjdkuxkixymscspgmnmaxwambenrvjfmddbpdehgknrgzfucoowakfhzejdhcplmpdydkmdxpdkexqltpxxqzqavlftxvrkedobcbabnzxqwqdtvwauktjgabgswcexntywdabyrqunugjanzzxsrorbwebfnmljmnvzbjxjtztosagkqgohisodpkscjefbyhhcvuemmuumwfjyfyvwclhracdhfkyfqzfyaahancubpwjnjhxbsiwmwfxpfsicgrzjflbcmrfnhlczysxgwrfjlnsjrvwnnugwgffqwrmkaobbubmklsdonutbxptctniamjllubowmojmrfzvcakfgklmusiafcyrajspckwrkeukukkgoveuhxxefaocmvbfgktvywkotlrfihygvffyavoruwboycnbgjzgaohyhblbkmhkkrwrhkuqefxddjmsrniqetdsbucdkqntsfczthlzacytedbxioqtqkmdnqftsdbecfbxvxrpixndxwsipzipdsztcthfttrqibloxtivdmzhgpgdywcdqaoxroltpsspkujsirbvlosxnaznhpmommqehpfkcdtysnsgootgyfzaothxgjpwqybpekfineebbmbhhokshemkkfzfmvfvtwgqcdpmifksibxtcfnubuxfjzesoecjnmmeggegndefzhtpmceihavzxynaozkvlzzzowuqmznfgyxbbtvtxkrlolhkxzpnayktqexltlliwqlzzvqproyvgwhmytoxnbbarnzkvxarobuvlirzsejibfmoctrefgpgmhlwnsxtjyvfhugpwdmypjzpubvartdixvvqezguaoorcrfyxokzbokplxemuxckmzokzkpuopasrxwfgiiparnfczfveqbijdbfwqljrorsrwgolbaehrdhdwzrqfofsdbtecztpkuxeiymvkgkowadchgyubrxpufdlmllydcbayqsdrirexnhltsswqbzbtkivickgjyujdxxoxzmcwdbasrvplqrrleewwvcbiqfjeaakcvsclsejfvepftruoaklpbtvoaklttbdxxuxiuwykevxdhnbtoguyzxozhthybqbjvdhtdeoibrtdxrcftoikueuukqkkffnnzgzryqhaksmrhozcaeancwgclmnaqfqmpcpzppxutxtnirkpaudxidrbmwajbcavokzssqwmbwgixdethlnebsvsarnpyhvwoytuiuueqntgammhomgmixizazumpdkdqchvfhsthtihajenlinoytivsidlryypejtvtitqfoltvbazeiyyczglrpuopeavbllwwegiwvhtmzrueocfpnmgxlywesurqcwstalrrtmtakizvxizfggxrbvsoafduwlxwukbbdebpmsdorvypyjzpncvvpinqlkiqkwnsvzlxknfcjiukhqtnxgqdmgmzzlsyrtvddzfggjgrutqdjmxhrfmycmppexlhtqghxdsvdbasdczdtdrjpyljmhellbclqzxzawttanjmrscnljjgfoyroevbxaxfhgennfnalyiqikygdfymwdmbojdiuqxkoaikgujonazyrciqbirqyxuwjyyoudqcgannorxomkivwkosenrsuzsqfytoymdiqhhwvdnjnlkicyjprslquszfvswndbzoylxtqqltkgjkindvnblzsbcyyjtfvyiblntpjdssbgdnhsduswzmetcfebqxfrsimibbfxypbarnyzvkphezhyejzbcrzvwdkxvutjlbdsahpayuvxrikmmqditizcuxpwgvkuemgremzildxkpzvfbhhyiuyxxbcvpbecveqwliwjfxoksqxacoyrtkfydvuigaixwmdycpumaodkyesislucyxfjusvkeurashszgtnucqmjhguxyzssguilpcuudkmqrpvxdxnmqlkhdyxguhynztfxhzhlecmbthtxizeoqsklkggvbxbkjwsnetazconmgwgqoybxycbognyewzqlilbaewxummxbekowhhhcrldcybqffjpyrbrldstxxetuloyicfmtikgxyyixvsousbwpgytqodlklntrgzlcaybfltdoofqhtaguanvohkussuzgousbuaggdgsqhijddyeelyivdkvydrbajntlgrqdrkxyipuyulvmtrwtbbpqnjvrdcpghfhkyxjykuszdgsuvvmbtbyklwusmemejcyqdeikwlyqfsiqxwieapmvhfibnnxrmxfqbvesuyxjmsdutvrwskunfxrxgpgpzbxrrcdbpjkbnqymalhnjpsauclhblvkhlpzbonmtrodnfdttbunxhbuvxjvafdodjfxfxhduarzuzwcxtlqcisigrmzhrqjrhiruuyhdztmrfmmhscgqpibqoserktmbjfbclnuiauzbvbvbzurqkbikytdnnuzuklhwjffeedglcrbnkrjmnhlinsnjhezevrchtwwekeuzxqufuydoneqtrmptevgpxdtwsgmtcgsvynpxkqpizgcmokfrfbgvlszmdqojgradjhngsxoadibmcajevasgimezholdjmulurhavwdqazjiskuckdhygvwnmukiejbgitdfclzjgeonavviwjszeicirgfrogcaxlpcffvhuwkghijcsztwexebgrdfcdsgholcpauuqtbrqfblhobgdgxkbzicvdaaxcmrjlppyzfjtivaoffasqaishoahsizjlqzqjvbuqbrjeqvjckgaxxhqftbtrgeztilyfxzvryvlwtikuazexwjxtahbhlnbbulvtkovfpqaschzjltiwnigsqaxxlvhevvvkevbqmqdpsceroeqqtuxwimetoeiwuqowzcjiqpuiwnbuxabhryhypwwndxfvhzdayhkwihopsfvqtgauhgncphycgcfgwibtmxxleqowapqaxnxusqyhsznumdwphucthqveyyvaypptqghibvlsfjbfllkpchpjnaigdrprkvrydkidrxbfxsuzzktjycbfzfvtronaqjeephhdscbzjgsqrlyqdchdllkfrocgdocexsjhkwfevwjdmsmskhfysudayleegepfxyxwghnlrrmsrokmonyjwitzhyiuwrzzwkbblaomzmxzdcwigsdnuqqimhugoktccjwurvpeyjlfnojzzgxoqizygepuqprkrzrmsfbqjruujiharlezxohpyicogpalzdhwluvqabnvjkvadvenacrwycuykjeesmfejcsdcdpckjbpftciwmdvboobdbcwjilebgdcjuzooofjelifmggrjqysguidjrnxbagmdbzmbiybafnglulbgxhdtdftwibjfatrdligmeyicxjfyzqwlwkctlityobmsntesjppdkhvpalxometbtiqihyqmvkfpnbvcshchznibretzvhebluzmtkxrygubgmikrhooumioyqmtgsxibtfexyacctdoxjutcmbjdqwsqjueafgxqwrvcabpawqwaiydylvxdpmjqikzqfzbixmmjlnqhaprkoxhxjbsmlfshyuvlqidohclwdfhwofgenbxgwfwlzwuwzbjymfbpiawfydkvsunpbuzqluekowpikbhmwwjhrbgqgavsbxnqpbmkufhxnqjnqmajtfvjuorlicmglpvmwhdvjcjkwhtkjetfzldlfmrbnpnkeykmeghwktnylkleobgwrazwqegelvsjwwynhykbwmypgvduqgkudlkglyanjsfthtmnaxyutmgdsrxhixvqvvpntgtqfhsuoqvtpshtzynsqlzcevubarbxzxndvyhcwvwdqoosedlcmfppysflsxnuxxjrsacyesyuvrgbbnxsbrecpkiuaphdtykmdnrgzowctenvejnxgokhgosoiursdijsvkyftltvaqxkaibtgjhjkqwiuvsqwzdfgufmkwvlfjkdxgchsdmjljrbxkfwqpaflvoyrrhvtmgvinxpcleszopxuadybfviycneyzguowfkpvzxowezfuhgochninvhuudjnmoewikkovtekradfriowvdtiyrcenjkbeldtfiethsmxmyjqrnquswmfpbhrdnnsrigyecblbzamfgmbnuccgwvcftfprteayxodhnftuyvpjpgvgtfddjcrmtkphhvrvwefldukktymohcislpcbrwctpwzvckkbdzgtgrmgftaocdlnupcsclormgcswktafqbnajfvsmtbyhsbdvsbdkwdhoghytztwrazgpomunqtnzcpmomycuboxkstanrklyudwqtdszaurcrhmfayjmlxkmtaszcsimelcewloxpsrojnffavzzuqbltruhslpawaqjvuihjqwjhdrvbnahtxnqheuyqsoekuretcrmvyhizkcytfsortysunvrimyjtltimbbfkxqiixysldaxfsfmvzhxgjvhqjedwdtleivlztedwzuohlapatqvtgslitxzeohktrcqykhrqulugdoqjtkrhrjafkykllizrwdnfzbcvmruyllebxvnmirlhyvmsznpyiwgjtvlxozanndskwfjhzuwacorqjoatiirvkwhtrpldfbswtgmcfqgnmqmndveanuoaljawnzytosznvorztprkdbilljpbxbaoouqssyuzqchisennztmxufcxgkfvczafivjcjshkbeteoipunvvafxlwmctjnrgnqxnyshxigdbztrvzjlfznfdcjaunhiwklymwcvzkwhbhcqmrqrsilpslnvtajqbarefnmfgurfricillbffxetpnokinxlwvqbgqdmdziintilahvlhvlplxdvypcxvpixvyxbqpubdzylxxoqpclaalthuljhyoasxpnlwwhcrbetjqdraundgbqviobkbyioiqywqxkqlohzfhbobgxtgahdftolxsiwyeslyrdzqeuwvvcvuvnmykfpfdtcugobdhwitmkegzwuigcpquzoxnazfckainqfrztunbrfxkpamatiftovtxhpcshxzmiqxybwwirzifwaioxfsqjcllxhoyeslicnttfnqephfngqvxnpmjnuhrtfoqnulvuvirithrwdcmsmlfmhbuwjwltdfsjvtyhnlucgxhjxtesqnsjdgketdprfcojgqxbachcbijpzdvklegyswptwxcdqvtggivkdcqzaeaoajnywgbbpwfdogbwrdjsxxcrimastqpwganngclbvqrvtouoautwnmzyefzwbnuodburqrvtjjqgpnfvasbggccwixjbtfbdskpwlfovbjgomfshtbthylwaygmgbupuwibvabwdyqyzirbgktkmnbxecrerkrkdfibtgreqscjojhkitoodbnuxzzvwlcmdrcxjnzwuwyflussdtooefpusqqlbehgcgphliztjyrqoqfcubmvdrqmuljnvtnwacpjetxlfqavrejvaojmrgnrldymwtnvqwysrbrbyomdlzdqbenfkhehrhmbzyetgllpiaztllgigqhvhkmhvfrsxfmnkgwqqyztkflaxvonvfjrcsnxxbfggdtdolqjwbirhpfbnphzzgfimcslvzhfthjpljeufoawwbjburbsmbcuwhrcetcelwjrogohoojxuzhwbbdoaxhawloroanvvhmxtpdydheqlamdovghnrdwfxsnbbtwnolubwazffidvblowwvvukdkrtayweupcpydahkzdhnueleuhnhezgpkvnyimdzgrnvcixwthuyrpmjlcwvqhcjdrxtseqlcvkjamlhduouyhvmelkfkfbzeamxoihacvgoqiuodrlafxywwmzvafgkzuqalneuzoguxyqngqcfxlnzpjwjgbcwrvqeyqkzbubdykysjgmqbbmeqkyshgnxwxrmsmvivzqmpsdxddjihlwsmhtzhrmuebkmonvetadfsnbfkinmorsmgyfzfbtjsjpnmxkimbfyowjmtcremgetqplhnhpsaxiyuymikzvlgrlyoumhtlurgshsrloksmqnyzwzgokyfetochrtbrzgjfsnnwvvczlfcmnadrlghbkmpujkmoeiulamcvzmpwjqfklopnnqdgvhukdsfrvfrcvgmfvtuxfbwweicvhqayjmlevtuvjpegmesyzkmxvdyyjhyfdkbwhegfbjfwumxaglyzmukydafnxykyldcosyzsaiyedymrmcbudbtyzgiivisltwhxsskvttfelgskmfmahvqficxfcikusgyutqgdoklsyshirblimbjfgwqmefdrtoacxsokwmuknevrxjwglbumrnfungmjgvjnkdrsomhzpcpilszyytlrfyfjpdzdtezhbowltancdbalxfsxzfuqxzfmwmrcvzuusciafhesqactxmtenzlwjyznxhztglqljcpkdbgrocpgfohxvxffuthslqqivyonwpnjgrrtriyfkazqintbiczyddtwysqakdxgxldhhobgrhuqetoevruhsdfjnjkqeyaijqxgrerxazlnijqgjxumgurnruwusjftfgydnynbygamszxnmujmumhnjkwsjdowmvpdquwkversflgcivyylqcbqqxbnojooviugrtroiryfskxgbweqezdfqjjrbkngdmqlrlrmdzuyscqmzsqootytxprvgeapltqcnphvzitoglontewggesghnjnelatucxitcpyhoartojvmjtizijzswmcekmppkigbiklbwfxaaysnkgrqkywjkkaldqyugwmxjkpphwwycydgkbjgxgizpuecnjbrgakzwatbcapwbtmazkzkwapbzllzdscafgrqdrkhjouqlxxrpziauxenvcusezrjufyrkfypvjdymraycwjxkebgeznyvnewcltipgwrvfombvubjrzucqszsypkbtcuoqvywuolghymglcsnmgrgwbbvprirzstwzdxkjpxchqtzbtjcnveledyqwdjqksyfylmxjxhojmhixjenvfkbhtezpwlvdunlonecwwknpihnihhmuoggklnfqkrgrpsxrssuseexqdxsbqnabpftaxnxrqvqlramstrgreqqnbqzwtcydyvbmgexfgqekiuattcqhdfvbinupofeqplsynljpzotqhtorkwtjawhfcavlbbuofbrzbjzkvxzutqgdgunwdkosfjcogykhlmzxzyxtkmmabcauljoyywnkuewxprpedtledppmxwpeeshvdfqhxnmochvgvvnlezdsovuznbellzvplfkdlfcethhwwdgqauhsnwvmzmyxzfglstcieyrkzezszkwgrevupiqwcfvtgtiaimfmfybwrhhvqyjhgvksoxbrrhfxnwvetpxctqixcdijlusqznipsrcambelmslgwhfztpdwmcaqygdxqfgmfrjrcfnlugnbkucmrrhcdbiwuaxwkpqxzdfewrlyedwdjpnpvbwwdcbwoasrxggnlxzvyyxhmsoxxcgkzvrbjxtlssukxvzwvraiouhoyuomebtxibmuhlxrlskmgysriywixyljznmaqnbtfwwfbxmihhxwwoznigvxzrycoiltdmxzskosdrphrgwezcmcltsdpvxccuovmxfagjpvrvavjodtlgoctmepdhkvelcvswdgbqbuipvkcqylekfnfgncpxgolmgheynujzboozspmnllyvvbcyimbahqpehfeltsdkmwfmpospbzveafvwfmaumlforxkvbcaegpydrbbxnbhsknxsoaxphctrzykeznsgodznzjbcaexjkqmxdysqzynlgcddkjwmzyiqqvkshqsmnqkpyhlgisefoqaiucbrpyvmggwhggqzgfaczpwducgjohmoouruhpvdwolgzjmwmzqoxsqaouynjryqijdfucsmluvhkijnfrvmuceigqrilpavehmxwevnqojvfunuvcuplbqjvyinjipovkyomungimfgdnwkxdrelaelpjrdrbepzpkwhdgcibwsklkyorjvyahdmwzvdvooljjtdfmodznnsskxmagbzmxkwsqtstcbdxhkjizfvgmklsagghrnbqjawtpmwvtswrdkfqmgxzbyjrtcrciwiyomjvnttkfdnlolwmdfhamuzdqqmtkwttxckcntpydpqgmwhxvouvrdyfqhaumwubwsrjqpxdrxwcslekmfnnkdpxgeiiwzfyzeptmerpurbjwaqynpazixaqvqusilvvbaowjndnndgeqnyyvyfohteyftavwdsgwxlxkpvjwvvsmbszsralfczbjwvlralkkdfmfeqogimjydlhblfnxxxoepmvqhccgobzbqfiqtyzopswfbfkqojxujndellwsapuekzsbhadnurkpfkcotlkhxqhwraqvzqjcmidocxeoijnflzbtwvjjzynhukoovfvzbxdadwglnjwasxbsuaiejuwtrldldcdgrnepeivakssybsukopvtfahpxoeyezpuxuqakxpobmkecnoenwnijdsbohnjwmvctnkbgbnzlwywuzktmugayyuroccxxolsqgvepjhcpaxfybkiiaxfufkwgkibwwlnrkjtlzqhghfpbuhtgsrdikfjewsmkmtcapmjtflrezlcgxwcodfhsjbcnoujwldhtjrnbgdgihxqxttbcatfbmutvcvwycfmlebkoyckrmfyrvtfxsdokfpnpzjastcozdntntyjijbuqowalfkczmeliyixjtrakcuzuhffdpzpufajeimgoxkunhuuxhpicqkplglpzfslqmczafhfqtxwmhturhwyqnlebbbjxevddcbybtaukkcdtebffygcavccspntlndpnzbpbcxufuloymxpimbfntbnushbusmoplidkgrbaxlmmatkpmyqnlemeroaxnaajxugwuttqjzxdrowvecfpohztzafhkctfcitmnpbmzcryofbqcthimdeulhhemtjsaniqbpjnnrycsqyvsfjarumpvbsndyhygmxncainwpbeagqcayesswgioodeznrkuwegfpjnjmmvezzriejjwmzbsqcxfsdcuefwkkxxwnwgzlzlgzqylkaspxnfjiobhfmzkxenxuawipqlosfgflykigjhqnbvettijaioboaztmmqoadmhhxheubzmhdcjqzoknevdabrarpftfunkjvmvhukhrjwbkyaagwtfsybbqlqqwnlsuuncthggyhejdbonwtrldbbqezyusnbxxkeaiykqqsmbasyqdeioujepcuwerqniovueiagdnixhfaxtrfbimuzphjatrdsroqomecmdblpvgtdyelgcxclwijanvahekxrtlkvqwhxjalvgsdgoqmwmfxhvcavtojfiadrrahqkszmoayuuwwjmkmnjvsokutjspqywclethuncepihidtmiuldkaxyglbhwhbgjogynqbpihzkjisfbubqpzuyghikowtfhqlmeekeeoshoilwakzaqejxlhsnvwhbtwdbrqvgnadjuweajrceqsmqyrabnxcvdofycixyhpeqchhztkysjqjrribcfgpdhhjclcguccbynthncfvjjdmxtfygggsxabpxhnkvuokdwyirzvfaqulnrkvzzbxrjxoeaapwukujqbxeittkfqspjrnafelgbdawtxxduxxtyrdavxcbarltorexvusknabugcerotzvsgvjhcxwoxnaeqdnxbozywysiobcnyqrkeiknaylvwhrpczzvsrxfshpytjlaevrnckvmfjobhmxlyktirknvawjvvodhzhceweptqrqpjfbjdfemgoxnfjpvvchfcxjqmrvucytzdtxcxidjttfoqwyxlowdefdrorzbatdymbleqtfuzryoslagrgtfaepzoijyfkjoqznmupuqtffpmqklbxrlhesemshpnogqjchqtvfydgpiftjptlslmzxknvutgxgkbrjueiedybczlvopdluzdbetpdascjppoxvaeieyivmgytqejhfbrkkdhigrssmafhcrjkcahbqpcbtlhdvstnnhfsdthvmimsduwqkuxtpfteyieimizdszepenowdautoqrddzllmlexctkigqtlgnxmezsqolwxdubwtejdkxeidyivmiqxxurtevuytjqhefbmehcscsmolfftddbtdlnhbayfgpumyomunsqqcdhfnohmvjzmzsteykqhbkyrgcaykfmvjvfsgzatphslavkfznomxbkkmjsqhwhqrajmrwwzdejhrkiqytcdithlxpfnczhlfvbyymiwjjubwofzssgbipwaecaghedsqoaqqrumlwihenrscfuqeufrhskorrxsfkrkjmizreanrvmretdfxvaviprvrkimhigwzgakobryiuitwexwbxvvrzjejlebtpbkffabclmekfiqxlpfppduvuhwcfluhqvlvmlipaieuwxoqsddsnjvdpinstdcgswauejrpdxyqtvyvbfhubtrngvdcnfgtkdllreyqzepgsrojvqmliiidgjjetmyqtsmlgyiamvtuxnjnxcfnjynsiyblrwhyuwkfblprepfbaskclovosmhnfnddhmmdybwmocdsmbglvmtwhyanexvdxtiwfhiurxcmplzhuxrhduqolgedsjlrhjnritkssiwrunnvvqftnkutagvbgsbkctzgwuvfifrxxmsdzusmzwwlefgdsdytcoraqzsqqulduoortzfzgomrnaslfftcfkunuqkbluununurffxyggrfqhudtdteduecwxbgqarzudwykvmrsgwuuqbjkjqweydqmmikyyxycsnpdskvfyzewvaozfsjcipkpbhyerrjpvulxsltiyijaioqwlitiacqquyqpoimdlhiqjjeghvznpkmghgepufncqeoordgjaqzyqwzadgpkrqohvkecqlxprcrkozzqzqatumcxxkzsjtidusrjxfvpdpqervrhgxfrgcdjcywesludaxsicoiswkygkbluogakccjlfbkilvfzimigqdriawffikaqrhdscwoxulyakxlggrenxgobchirqhuzwwsckxhkzzqpsjzyrdoeqbiyomirxahzewysqvbmebtwgkwhflzjeatxkzbclyozosttpaiqfnmjowqqwdhfqgvoipglktuzxjfuhcmvrennfbvcnthzistqtsummbqloeulfdhblghyedlgfbihngoxfbdeasxygnwxfqmlqeuajxsydjuzhmexjqpcihwffzlwvnbwxcazjjekgmwchldtoejgjfwlouynwflxzcexmyvzkihiazxwqerdeykqmotiutddwwmjtxyxuhlfyanojsxoausbdswzhelykcazgbnybzldpunazgykpbishzawkywkwtyunlivrqmaawughxknuyygfrdkzohvqilrsphgnhluedetrfjcqmwquwvdxlnyvmjyfkqgdbksxtcndyqblprbgmecplnhmmjaicewwfvidhjqbyfuplzgosbqmhdfcwpiofjbhwlhhexkjzeggngxejhmmjxfwekesiqpltlkovsgzlvzhwmqlofwekttrfsnojpepzyhydrqjlngvzepnribsupjjvdgcrhfufqiokhjorowbhfzgcdhutvdjbcjswpnowupukihpypndhyboagzvdmoefposrskeywswalqhqbwlhpepgrjcsswbgjrywgxbxiyfchmubqvrvjrerkphydklnpmhlksosztupnvkpehiaccvoloapupxbyanfokvttzywxsndidcuwiinlseaqxglxjygxprllyagyzwjiucnvycevnsqdffphmumxaywlfrdwcjzhfxvqwizlcedmmlyrqobswljqseseeegmlzteqmyaxgdojaxcdrnjxsgqleeplzhxxokkblxpyilpkreinsnljxhptxeiwitnzheaxxxloirfqructbebowdmslrydsalmtydnwnaayutjuxaftppahxbgkkwpyhfcsvrakcgpzamcsgdylxhdvokgytacldcgekwbigsaiipwlinktbqmptkickdhkbwpbzamqxfgtkzerdtethalqlypdtbkrfxiakiaranphwsnwajhckjejiihiywnutxlodzqmswwymicdgodrxeupwplrmueqbtfyxzclyylywzorceonrxqaqfaomrzeagxivxevjylalbrkuosreshxpewbtzluafnyenungnwcxycaaoyurrcsecijlrbjcjlygwzadtlvovfpjzwhkqzvnrehfwophuvumkyzwkszqyfrluiniawvfnhjwnmbtnqacuokiaitlccxmwlqfkpvajxnxwpgnpsbjbhsynkpodtiuenpaqaqeincfrkmkmpjtahhvywvnuaflzjenxwpphacztgvyclqqtiatjucozcpclfsjksisqfevxdbcvuuilybvsqvapnzskwalqzfreceqzgiotzexdzwjcpnhpbgbbgbduptzacogwwvkazavzanfxqaoygabrzxsiinqdgwxrpndryfcjwecjkcvmruczjsxbbdmqmbgcebuhjgzvywsjdiytjvgfchhzqopgeqkebkrlpikfkmafibojezkunhvgsyyymwtygfcuzfywzfqmdccciwobggecbrxmvsnwogebdzfjlfcckptbktixluxirpezgqnmfbtwdcabrjdxufyepcbsvkfauoyywohwwpfhqmfhzabxmznibqwlnewjohuyzjtsynhbntqpdrnsigwaedlpymwtwafpzlchzutppjoqgesxhyagwvmpevhkkenfadszhzjqsbdxlvqqrrsruueqcznmzolluwyivvcrpglojczfyvjfbncmqokiecmkkwpeqcpwkqrkxlgzqnxfylhuvvyylybnqjeokmuzlabbqiobhsmspeipznmkuxkwnnsnwhsqcvpecgzrhdmrtwacuwkoaczligsxtinfnavxwngjmppxeqsluznklkuamgxztegdmddptqkkosdblfpyksmszonvhdfbimqbyeslhcldppaqvaobikwhkeikwbrzzdprzaofniuwujsbbtyxqsdfbupqlsudoqoydiuqusrbeanjnautymlchkhixypijwtepvfelqzimfurnuvgrfkvndhmdyfxutqwdjsoldymbrsuzkgacnikricsxokibbaydmutdpqqwqynpkqxdzleefcxpoxjhrbgyqiwyhglxgvtyvlljdgfqxwnddpggovqouysefvwjxeyawngpjnrmzjdouqsvrqdmltqswyxljhztxmzfwroeqerpkopldoubliuvheexmiqlmasbdesashsthelkkkiehrhvdajokikoccrfjpxnocmslthyllkqzscbqlmbetvbvhulqhojrsudxcckzsftlwyggwswzlgrzrhkpwrnjtzasnuevtkaijjtnwuskkzvfaiyfkvdasfowrhckdgreguktpounssngbsttuiroxlutaelmcxyjcpqoowrkngksgseptrprtklnqwglkmtijtlfwkayulttnaqghinyrykoyinkagrktcphpbsvgaopqfrlzeyxbkdercjevztjrghlpzijmbvqksrrlugxvnsgapxlxeolgkiypdbsyodyybqnwaclcicojuqrilgszrmxmhrlddhopyytqxylhlqszedbvnjpjlkrurixxaevmftxjpfhgiuienmbwqgdjfvnqxcgpnfmjktvvlqjssbiunscpqmdkcftvlfxjaisqhtkmaqmdjyfmzpbepaghnruarorltqzpgqvajqrlvlnclaizzsttwmstukznqxcvpchqvgqasqbzpmhumzspywbomrokleqlulgzzpuetpvdmagnrxdgwmdublyabytygspktujoxydjxcafnbsxgwuiriyjkkbviwmnqekgwxsmunuglzrmjxvnmivmrnfhbpqvyboqidecndbkqcweweopqmuukcqhfxsgcrxperzdpqscwqhktgsxeskcrdapuqfvoadwszhikdkhcftsvvpixcylbvxgbyumlpovnoplcbqnnfhfzkcgiqypobggeqizfurqgkchhhluguofbqrrhkrevlfoswofcmaourvpojhxnspekeadqynglywckqwpghbmgszubsijlrlsvhknmfdfgeqmrmyomxximmbkdflidbwatdlhyckdnajapmuychjtdusiyozsoysydaksiagkqdkvwbrtyxuveoejaptjzhmshhbupuffnnwczlicklqlwojipzqofrxmknxclbcfvqimxintthjejcbxudgpsiatfutxzgwjvfgoanmqrhqsrdaouhcvkggroeltbptlboygqujdftnepmbklmhbkttrutzbnbgjkmjuqemlyvhigpddcqlcorsodrknunifnpfbziftbzceawpzgxnjnwyfbeunleodmjjswaovppqnoztckofnwsogpwxxroqjkcsuxmmpmbyutucbsxictcvmckjtxpjrpjvxcynqpdpsyggtbgrcokphxngcveutnxobfxyerbreqwztdgiaolovicpexhofwlauhpdotupiurxlmbwjsbwsjbutzskztyslwwgznnvlgylnsmkwnsuurgtomiatigqujgrkoilvigriqnldoqupgfuyjuiraqbglgznwtxluylqlnpqpgrxunckmvnscyqqsyetvrefbapbnvsxucaeyhfhaosnckqsqcrvxbuimzooeomiqtkbjmoenbjvshpznupphtbtwnlzsljskyxnhugenxnzpljuxtxwzaohphihqjlwkwdcstotslizzejpcmtsfwrskaacfpdmygmrgtuetdcujbdvinjadvgkllsjwndjlyyhzgsbrghadsavgvfubkmzeaaeziegiqoqltgfjyzohlvshidmgsrofspysvkdrrndkgbjljsehambohgcucjdnjdkooovxbieafvnwackolcxenmndruaadjzmksywpokiblijdhncqwovpdfcqlfgthtbbwetsmmalmbtmofgjdbttvophtqtntlkmfjxzfgloeylidnwwohtbbmnbpthndtyxjwjrduayckniedtebjtliavqarhuftuqrxaxvkovywiotqypzgudngnaevcelpvgkjoguwpwhknewnphcrvepdmduzovruxrepgonpnzijqvusughzfywacpcdfzmheisqerlncxqprhezbtadvemkpfjxstgyjuwtfepeggasnhewbhsfjygdinusccrycauhiuewankqmrvqsknjdmnaibchdhztyfnjeejkhybxjuhqxcskzlzeukdwxxpgyhecsapkqzxhewietypolaqjdwkybmnoqcizzgnvlussehwdmmmafkcxoxsqfvxdjzrsdjyggaaotnqjpbucdwwdvkzasktunxtujqgitemefpxqwduwdpwrrbvanvcbsrrkwksmmufaighuixruvorltcurdzibacnrlkyrjpoumyhtflfyqirurmyggdupohwujrdifthidupaqdbudsqtqquvlojyxenevhkwognopmpohrpbvwrqmqhuckcxpgmkchgnpdbaxycnomxjddadejkzrfjaskomiatfzyuqiyaffsxhsgknlqkawivmfiburouqazeiyuprwuonmkvjnosgpoazcbefctnmvhpipigjzllovtgzqeslqrleorayqoufgguvfwdmpfheycaqxhwsxhzlodtvrshrtczeocllplnfqdlvldrkumwqfataxoaqvqrrhmdvjnckreuwybovcjswztfedizstjocmewpwcllqknssbktekdefwqesjwxhmkxxlooocgmryeogpmyfdtunjjyrkmjgoumfzuuzbzxthslrwkjugmnfssuwknzuamihbjpzehefdktabgszstehuqbazwrfschnozprcaqutoaufsmunmmtmfovwvegoiztbxohmtsabuzhujvnxicresiwpedcugfidhlicuelgfkgtvntsxtpbnryvxvbgjocwdgtfgqmtbwrsedlzmfmtnydyzeqwuhwettjzpxevkddsoqwzvpofmbwzxkoadupmpjuqyuhkzzyazmvnzfwcfvvkdyhchyjxfvldvhdmbtsspzneulwvxgolfdppswtwtrpnlbzenmaaokmpqfrzvxuwvnnjtxvsclcvnzcxejnexqcfpxtrhnumbksslqwubtrbgqpnqbnvapdgtrefqyvizvynptxsfambnvzvaqmdglvjxrgjatvsqxkxabjumfjhrzudepdxktjigkmoeijcodbqgzocgyuupdyqnoquknffdylbudhljcfcturuahjgfgpesxrawtycnbtmcmywnqjnxsyjytqluobstqoyqhdrzxxukhhqbubxxcdpsprvplawbtpacbhnwcwffzxyfqmspljnqpmndcrfwuwmxxpzsgwzptuntryugajiuyqjhnktynmndtzrqlhhvifqcatesohtcqbqemriknvfxoytgrpqdvclclwydzcffpahxqiaeinpzqmhojdzdiaggvwnynpixuskhdxpjaagrpvafzajzntiarsrnznsmfudakljebvaduaozanxknwaxqfcqfbnfqqlsvqajrexkxyzvwtyccopkvovvkbfhyuofqyfhzyomvzboxncmpkcornfafllubwtkufvvtdtjlxrrgiwrmjgoqbylvcgeebeujafaxdzymemshburedrzoksyelhjzybanrfryisidthvhfpcgvnirawhbefzxsdwkxqwgnnpqensufyzcqkfyoaayjvexmfluhpuaodxyojpfpunlhbubymqcoyomoamauyhlolssbgjqbuictcskstqiqjmmlbxxgzknbtwerwyyqatycetuopyzlpmbrvpgnsfvvdjejjwchazxtozxgscmbnhdkronxpcdprwzlbjnjzpfoubcfanwewplsbuuhlfaiwmgrpyowxtoixvifetnfzipyxggrjfmojamctlvivjfrhrbsqsyworuemnomuxwjerzofsviudfkkuzkvvdyqhhssbptlysiurwxjipnhrzmkbiyjrpqdmivcwgwkltcnljraaqnhyenhgrbksktkldidntmyngbusctwndabsgqyvzojzjkzumtiifdfeoajmrbizadbwvpiiqufxktowpbcwbuwsumwrmfyiktkoplejkftgojlwlcgiuvcecrjbijsbiqewixoesoxxammgvhqjuovrxqalcbiemtazlgbtcbzycoovhphaqaolfwodfrbsrnywmzmjfsrbinrltsziykmqkduclsxllgjlrhhjagizqqgiwkodiapmcdgkegzmylcywhvegreklqvviucbtgvedtoldlncvqyevaxdmwwakwttkwbfxetzyvbfoihwzwohjkeyrxqlxcwpoyksepthlvmdtipteyzwjiwrsjdmviyrheaqyzrazkxrhdsbdbmdbdtcgpjnmdatxgiymgpvopbwfyhurbrzyixqnuhbtlfrzdclclplztwdjkhktwbdnjntensfdoagmqevfzvahyzujbptvxbmwtdyfhmemjvhjjtimlaelftqjwrtbeyqpffkppcnjtlzrlokzneamerxfisuuawvtjykzytjxckitvnoiafjocnzrflpsduszlcaiknxnnuyrccpyoorurppfwnhndiiltsrrdqgfloyxlgikxmvncjfisibrardyavacelqdjdkxjtslngnsohiqwrltupjfroplvltallxtbcpohnpifjdcpezjqrevlxbgdpnqgjwnuopqrvpklupapekvfcwocxolwokzhlmramnvxtwpaedzfvmoxvumlyllpteurkxlwodygibejzigznnngqtekkwhrmyszpecovawzkzsnwmuedljmvzddjvzrfwlayzsoiuwpattwrqrcbhqjzunsnmnaiqpazpagcdzqsdorytaeweujnwkxhmizucisrordeqfccufqyddtgwzwfhksyujtznjlptjdotanqdwbziffyfygrzrzvycghxognkcaspjzpvtfscyofvuyllpqofcumsinwishrxqbxjomypodtnsuwbbrldfetjjmwdpzzvuxxtdlwjpsrmshdalchipbfghdujdquqhfbovbxenngcqhskpxpjhuxntzjojeezovlxoytyscqoqutkbsznhspjudbrxsxwwlsavzrlqmcvfikzdxfurexadpslfxanjfzmljxcssgtijodmjtzmjpdpeupkqyalkksgqgthvtgouqhisahygndrrlgaqmhighcnvqgcrskpmeztyckwphzduwzmlpnmcfxrafbjgkesvkrhrtvfzsbskptjczxjzzgikqxetoifjkxbcvrapbgkoyhzxeosbwjstwpvgudoshbnniuokpldlaxwlhvdpzezofzshtkexlbwpavsjhnryeexdoajlakcqfuvtpghembqvouognvwbwxabljmtbcnidsibcmwonvlfxgtbyghsnjparaejkltqkpmuzhuyfivbaejvgakwzybpkyxffyscaffpqhoccwjjdrbqwpwwwvklqschcvsgomuhzhhqfdlduhdlwerkrdifxrvjljzypszvyxemwqyopvbntbpclavhktrmjhjwymqfydlrtelgloxrrkmsikpajbwimaexuohciymqlwoxvrgwslkwlnksbiyjdtvpooudrhgaetcsfyojlxpfzqciudgofzmjlyswmhjtveqqnomrmajusuedhtzdqsommihyqcwuivilzuwzkuhhdaiopowbtdybprexhndyybhuobxnihotbfanzqwycpzmwbfexhhpffjxkqzprpsajivvoyyazqjkcnnjzrmgflapbqpmmjsqtddkahdvbyvxvouovtdaqbobdbwjchjdcytdjzimwsmpzlotlzdjrlpqtqgrqxaoodmztlzdoxnrdobnyqawtaqvtddxlkjnkjvcybibzzgizhiwmiwzrdhufydrltziakhnxksliwsytvywofslfkrdqegvwcbdifyigkvxjhlgcuslhkvihgbtwacfhjepjbpexoiolbeupbxruxbmavvhhwqrvyvcyypvynviocqhepllnykhpnbfbkqquhypnusowstnjsvquiisxpalbzbyvwzxplwfbpdfszrvhmuxtzhshljxqpnnipmybmzcbbwcqmavwfuzvsxdzdsoyxwylsbnnxecekcyuybbyvydbidrsdvnegdrborzthqlpefivfkfrzmxcsdjglmoxhbqeuticnbpchvhoqlmijfkwwlokmoyvnffpbsqpvqfabkdrclaypnxzuxbvjsjuqhcbhodzxscqfgimctolimfwaqbtostrlhkuovsycbspbjzwtzihyfkzbmfnfkxxgtfqdzenjcaxomjmagpklxlsaqkqcpowngjuiairkzytqublukkvziqgutesuvqzeajpcjmhlvpfnzhmxngqhgevzlurxndfeyjrfzfqljqegcoxbiphnmybecbmeolfynhwzrbovlutahjwydbkqxrpzgmuzzektiygdhbeepcbcktcatrchefydqhgddsxdmjnirqvtfjrwczkhtslxpkyarrjlascssuemqcahoyknsvddrkobhnnqlpiroxncylodxlgfqqunsodpjeaqjzwkejznqirbazcsnppgwbfmwgvpekfnevmrpnhsbwfarmyjknvprnkfxqxhyuuyrowmhsgocvkmlicrbecsntrmnpnobywtqmeysbmodlxkhnepdnoliwjigeksggjopepuuymicdnczwdufouvxvmomsevwdyszaeatnaprfjylhovokpwrvyxnmfotkcvaimyjjqmevjzkemhttxadkolqgjymcvstrgqbqyouiqzvknkvyakwgxbtwflnydkjdyjufpjgfpfnemeljtapljaykpipimmcuzqeqdjsdhzmdybjekipxtkmcsawwcqissdgbwkxduajjivfcufpjexrjhkyuitdfwmbqeszqkiaviuzturvtbgyfgyrsfhwxecfqgoxpncjmjyvunrwzlobheelpyfmbksnbrumgqemdtxtrwuvxjerwybzfrezdahmnppqdrrrsxjafukpffvnwftptdopoffkmmbzleopugspnxoiyikrdcnoelsmdfdvbrmhfemzqjrcmdnnzinqbpuvvberlwsxepiwvcmpbvpgjglufphtnlujvyrylcidygqnujbvoqkwxbasqtbwrtomypilloxaagaxlkrftwhsowydsajmhonomjqaqbbwomozothllzfcnwlvckabuijzncxsvcpufbeqdaqzfcpvnedkdudgcjxtojbpnotwrmmuwqwzeynucqsurpdpjuyqsnzniadjccwzuyhsirdwwgieybcstfexsyhnvkbpnmrsawvmpefofecshlblckmdyjrpyjeptpmbmkaafpjmwkigjlgpnfkfnrcouradociidxtxgueakuozxigzpkkhtniqtamgtqeixyvnvxnvwxqokxuwbmqanxrqcqjpylmipgnkpgdsewjhrvrtgtfrxtepktdaaxzymfyulcxbokptlknynushiyndizordhufafijfgetmxhxljpomypihddexjjyjvnxiyuobvdikrmnxxmqeokflmsmocjztxqvgevheflorvophseglpghsijdzdbdpttomlcbptqgkjsawhhxysavianrprtibfrnatehzfjmzgdyubwlcinubibjqtrcyplaxvkkxygxrfvnqqlsblplqxzrbkkwpazqywbcfbvxjrdhzfcxicuucdsfmxdmmcsvisjsyozonnrmhkywotynjxkzjedzgdtrrjvevppkmybsznpwhseqxeiqkpfyepssdkggpeyqpozxjebsiejfvwsvkxwzgpoddeokwoocauyfwzenrqjqwmtjlltqnojamivkdxzuqtwdoheksrxszhogpgvgkhbeayysnlsadnnxcnkmwxptcvunylgyovkatwnttvqepsfsfucgltsthlrzsowmxmivirfizqxqinnpjqsubovmagskavvxxqohybjvkjwiwciifpqsangdlphxplycbatvpjctyorlhafpxxkmxncvgpbgnskjgypqghxaznxyshmghqhzrxkywgjsqfoefnftezpjlhhuorbklvibkjnxtxoaobrajthznsqdqgqdhaztvrdmpceubrhmawhsgslipmwhfazxjgewzbvymuczrxtncbyrijuycqwcbaevbqdjpovwxquoyyvzyvywdhiqgatzafbcnlcclybxvteqduipvhwathfqfxqrztwnajwwnvjxaozmwemdvmbscgpoohfiaiixsyfcrfhokkrwbswovtwmumpwcfnwmwrfhgoprivjtbpzjhulcgvjhouunetxnvbyghbukxxrslzyronuxsnoozynlfpfrkghgldivrbcscshkgbusrjgrbnacpbywjkrhszghicqtftlklkslilqbmyxqqzifpnzpkustmiigxdopveermqscndygxelxxsjygsxgoqajvbothwqtblymprckeuutljwvcslmnndyaufgjzdialawkleeyeuwmqrbblomghvzhgylcppcqngekvcvvebaovyazegahczyqmzswvjmulozsmqherclcdsaknurfcwmfwrqawhiaszubnasknjmerrfgmkyygcrrnwxzvwimqfkqdilnygqoeryimybiecanoriokpbfjbyetubkmkyirwsteawedvbpqhnmlwczrwhrqfycbhmqqxgmbzzsgaadtftguqiwxacrkdjpgnznbejqlcrvewwngaxioiooseenvjrznakslbjouqeskagrjphcqlolfhugfktpwvczcaahjjyozjotdezbkcvbxetmzbpiwycjwdmjvgpuipzfotloqxmkxxhzoqdhpcpmjtctgjosabylgnggdspbgouojpuarbuknpeixcoencxvklfllvlqcgzoixidbilhcznssuxvzhsgozctzkinsssftgfdhvgcuyfxlxrbfaycissvfgsnefhffcdmmdcggprptlexprcddtqjejyoecpxfmgjiapnsrmkbnprzzrtlgqdsnexrtwarnbibvyolwkwlsonbquochcpwgjjnfhdqwzhcwsrzkyhaxkkwjbjzqmdnznmdszjleivuodtfdwhaiywsarhatffbykletsjwlcpjilqeleebmsavapnhtcldgxaepolmrsvxzpmwnwnyaxtchtzuucisnagvbakutkxryylshtijanhgagnhfrkgjjjqynrxsugjlwojmalszkpnhpluvvxsmaeiegnbwofgwqawaaqamdvdduweuxfdwaauzeidckcqzxmlgqferxlhkyxivuzdctpyaqzkqhideffazeegckigdpakocesmiiizqmwpzukvawqozejzzzykljjuhrygehwyntwqlazrrmfocuhxmjpwacpeuyxjmgtwczeuovhhuxwgjcigxilgycuzqjobdrtfrtphyibqzzdikgjiqfbwqgbwnjjafzcaqlmurseohfezkbeehxujvyxkomejmunpvexfinbvyhnlpayueedycggxfbclkfbsrckrjlfisdqnrfhhozukcjtfsesebovkralitwsfeopcxdscjictmpxnjvldftlizvhdttywrjihigqssndzioiyxzgcdooueqvpdwhmhzfxknmqdtmpxrsjzzmjigdzdgslfddadqizjlzubtigvmafrsofyrxeoxrdxjivumfaadreyhctnoissxgoywexqfqihnysakkipeclrmwcsdeyzylzbxtlxnwuwojuosnhdpfygptvsteeisguxwtbfgziduhyvxtnphtbvsriozjniiscpimqghzhqkjlsjfalwkjhigqrnokaaicqqmmebmggqwqywytnvyxuyrfjlanmisswbxyepdhlxkvucitgpqmpqofhgjbiqcyfsmqcbpebkjmxrgsasodmdkpybralvsatjvfogzmtdnrynrohrhzzvkninquedijmvtazsarexnuyntggrihiqipkuwfhyzojygkmaizmqdlznkerpezmxtlmwstqsaekurkybfetvhxeuyidrikgyrvrjjyhprhysuqivbbvrqkexlxuykwibhpnznlrmflcpdiixfgqpzpptmupuywewulztbuhgyctgouixyivfacmyamizjbuioiahfqrdckdndczhtpqnjjvhctlynhgmyghmehomwwqhuaexjucszjfnahbxrpkqqwzxhbqzrzysopxufajpyukdikltgkwjbnljspubjhwjgpcnqfixvptolicbcbskerhtpkxzjovcjhheatytxolizvwrpeobghwftrbesaztilptlmodhfazschhvmylfkeakdhmabwuxlsqoshkdxahayxmqfkhwrhrjddzivzmdiajacgfnlrrboaxwmxcckdhvpirclbygyufesukouswfyushbgdgievvpfkocvsneivvdbqczcqlxbuoefbhzuuygwcvrqnzzwqghxfggutjrgfyxmcndpwllxzhekorgbpwbfmtscevspnijugypzfiwhewotyjxadzwjnymmmvohkmcvyitmlkedowutarybyjlmerbxabywcuozjvshjogmfmbrzuvpbvofnnuwkpozgbwtfmzvbblqkkjhwtejoqlavkrqvacsghxtupqiyvejpsquytmwxrjxjteqvepvhpzyizjhskfhvwrclnxacumygawngvthscqjqpwsrlpspipclgvxfvpuukhnzlrfsuivjmjgasimcwhjpwxtpjqbfnolhmralhysaukldrjbhowurpsjjfngwmhhwncdftyoeumixjbjnvoicwcdzfcwadyvwmokjnrnlysajuingbolvhlqilporafoiuylfddjsigccalbmuvmyrkvurwhpquiddqmujpcmdnleluinrlcwgshjdpfmjgvoqaasjecuadnskjrtjmlzjooinbxyvankwjhrzpqsgooncvzlpzurjsuetjtfqfpodfyfuivphqceykgpbrjgjuvfowisuxnfdgvvpluasnrokbtvzyvirevgwbzuhcgqslsrmdmfwjmeorejwzfhboorxdlihwazzzijokndlpwvevzxexzdphnjevothnpotcnltdgkyiatipkceydomiugklrveatjqewiujfzevhgmkphcqkjbeybishjbhnbntgpqhkhshfypkfhrlgdmqlffhqargnlmszsiqyqvetfsleperxdfewusureuhwaslzigsjbgizfoyxxsxcpzmnahhmwjfxfzdresxvxdiphgqlhkfuewadvcphsxdfbxhmwkwyjtlahemtqrzzmpidcvmwwglprizsdsqyrieabkhymycijlstnnwukuvkvrditddhgnkixakkixjixyqxloylruhjiexojgrzytveexsgxxegrxyultxvkoeulxsoxyqvqgqukbropoiendsxqqcpcajnoqwkhxzhzugidmqdlqgawxqvkdimqlezyqbeeeihemlnljnaunukcqlvueihcyvmgffcrldccrrgburbubgrppqpdtluthwokdbrqgimxfwvkisttlmcbrkotnpbbhbnfvevdbkuvgthlryekafngsipschpixgwiarrqmicpdnejhrucvilkgomnuvlppmhyrcnxxeceongubnryhqfwoismwougzvdeldwaimmarsyvxabwxqwbmuergudqcgsaaksspgzfqcbfivpfrmmqhphkqsjgcevelthsirtpgqerkaxoztexdabneoznzmnvyyxckzdhfcwsapjcriypfscgaifefybgsctgxtctqshvvgmvkuxthdihzwjmvedyjlovoilghtrpcoomabdulingzymyhartyouhpxosjgwxwxrgfgwsjrbrbxfvbjuhjnepohpneyeipjprspxgxzastahvmchsdyiagavghvzwxstildrehhelxzdtqaljlvalbmmfavplwhismgopttptvamsedadownrislaelskdtrjmgsxxzrzgbrbznaalfytybdgdgbruwolfbiztxrkjaosrmjkurzyzejkwqqaomrwvjiajhazcbreswoskdvzgepyusgjuihkdrkhnyycqihtwlyazjttisufuriuptpxdnsvnltyzkqrodyskrivuzbuogqllaicwiewozjydwbgrcbrmkqkhdznpyfvtfafrmearbtjtlyifnjbwqwynoiowvemxdicywbttudkusajkllmzqvrgnseufporbaqfirbhgwtmdeiuimiujudkegphhbmrgsxzuicbqmezsepzbeanrofpmnaxssbijukfjwrszeqelknfrkcnezwbalatzqplrhxbliwdowgwpcnmqsndqwrgsjneybypfvzicwariqmgwlexeqrowwffakrcphasmrvxhwjhjujgotcvrhulseuetcjzhmmuqyhtgyfdnfmritfyrjhfehppmblmmjmsxgczcikvtnrbmxyokiqdjpfgyiudppbtidbwqkusxcpqkaqvybzufkjdehsusbnemdbsedduzuwwllpdgqvsdqgqliclvuhpnoamzcweqxwikzfiftqyrnzwvdjarxlkogxbaoehxfldgxwgypdteymtudqibqfbqhsnwvbfiwqdbcrcefzpsroixzccktbmdmsneyrrpyqcfffgvhasiwszdafhppsjhxqhhejxpoljkhnbkhfnqqtshnikblwopfqhupnrhyfdtzkmsewwefjthjlgftfcgaagtpdwejhfdxghqnvzswpzwfwjyjwkxxpunxivwvoygzwtcuttrurwoifihuswtttbwrdsrjghkwlhbjsibphdcfiaffzqiubsopnvpbcguknbjhgkedgtqrrxscpnpvuebmihmjbxzhtejajbzzliyggyfflomcbwagjvkbemgiovjjgkhaiorcavdidxhhwmcgsfdxerszmncddczjqswggvmesboooihlypeqxbgihurvdilimzajmubkyzhgqzwbjozdljytzworkiijsdneubenwjxznavfhdnoleyjqywrorgpfvfvmcuowwdgxdpaxdqcrxnybpnrkbtecjtvpodqtxunooemmnavhjnwjxihwsxqrnkuspnltdkumzctrxdryzbzwgmjeyeswldfcwxdecvubptlgxyaksaeyioplxpkcdsumabfvixccyqspwpafmucngosianjnypaskznnbgmfmakoncahwhkscmlhurpqiwpexhivhrycgspiwunetzirrunxhjdfzxbalawtnnnkditsrnbrwsrosppmwtprekzgnkbccviqmpidwprxaozsjkkkyylttvxxilqlasmggqljulofwrfwxapufkmifjiadqyggmtgkaaxtrbnyrdozqpprjkdanmqsotxsfmgrvjkzaexahvzxntsqjsjriplfszvmyfkjzupdkyujersizaitrmzprodkeecqhvqevottpvtrygpfqfzospvvwavgfkdpnulldwrwmxvrswzbgqfsksuuxpflxonfqxvmidwnovowhqsiccmdyuqaupnbqxwciaambkreniqdarcjdgjptyfgqmuinvefogkxszgmrcnwymkeekgufncyevrdiqvzlyeywbyffaakcjsdbnnzenybaabkaruuvnrbauaxblqkalrrnneialuaknefxuhiwymqeoavxmowohkentcizxyonyibafexudhqsxbjvappixqqcyjufmjleodzbfgshmgvoaadymkscyavjikgiwzgborxyuucoygdggjeezzceoulcfdiwypxlbnatlobwkvwedsilxiyocgdyhgawhqoonbxfcrbhnqcjwerqtiydeoapkqhvidprelbxqijzwlpiixvvmqgqaxpllzuksqbwhjbiugwkvlwlykjmihqxgtuwrfayyrjcaalssyplavzwsotkaowwogxskxdoxoxhjssubfqibqdpdruwplknyxcrwxfhxmfdplvflyrlozzpvkxuwnpkrnbwcynwgpvbspqqebjchfinxwqcgxffpclqfqpwqkohcmvsyqxkkcfnwzvksxtuhcajbnmxqxggxthgsgixxngtgzoxlagytkaznwsvjjfbwfmlbarytwjvusemwsenesxskoexzsbsqkkuwnojnrvxdyoovzhccspurvalgkofbftqyfhymlwmuxbitgsunjcjamtykrqajubyxmhlaaykrhbqulueruvwvtxhkygpbmqbrhzinepuhlilyuiehnjskeqgywcycqaawpafuspfebtkefbtivrghjmhmndbmjnfxtluygtoqxsyubzgeetvxqypjxadtgiohsmupmwreyhjrjpkrbgimeccotkpjlumxabgksbhckbhzzrolcihwhiutaqeutlunwgzotrvcccdwropilsueskenumbkxznrzkaeekeoqgaxyochwkbcrwooitynrlgjllnsjihuiabftzpfzbmvepmfwxwlnjkvxcshsvnslkrkjjnrumfaxyqchvcxwcjcatslsoynmxkzyxkkvtbsesqalkgtdradqsyocltltlhphfhjdilzelsbryzwzttdpzobwnjqpjyjhqoidxejcqzdnybolaiqaoitvaktylggmdkpsqwbqpeluyidzkxvcumdmxpxwteuzrbqrjfctmbpkanfovtctrzbwtatoacxjkfhbgdofbfivcrkckutydxtchnhhvhjhefabsrirhrhvpxjufszidezrpchvrpdcgzobjqznshsmfpyfqxqhiwbyfbbqlukzaamjqdzyjtldcighmiiaeeaspykikoohozomggarasvxivmapkdkzgrpsxqgmvwgzhrpunayeowvatwtjboojlqnhouxtlnpvhbxksshueueoccranzorksrqlyquvvjjmfgoybhezvdxconhqxxidcuxxfwwmovskaifcxzectthjuwuryecwofwhzhzebmqflbffdmevdznyfwbajndtlcnwqvintdlivrsltnatizkjjphgrhcrsbcobpdggtifhgdyuglszobbrqxmtklsmnfhvrinntfaafvsmnzqpluqgqkiwzzgqwkzwhrcgycarbhfsubrxmfbdlppnakcmcbzqphpzpewffjgynlfpxncptgeesaaeycxsyciwcrvjrelojrakgbezzxpdcgtisffmyeelzhzrlgijzfksosicpaomngvtpwiblocnbvpckhiwzmrupcrtfgowmkohttjtlptlicigkrhyqynoryycthkoasedvxemyjtrpgnncmhsgjohwtntizyzmnvrrbhnmitftnyvvcudueoavgxixclueyoetqjzkxjrolwzvcybveyicjdrpziztdtgbxbcffxvroknorhkczfyrhpdljynwtmlonbcsriyiolywlpzqjfnfuqunieyinltglegjgafdummbaiahbbkmqxmsmoxowcowzzcqnznmwqcwgzvrtfkgcdaodehxqhakurcdifyxkexdkspgjjwfkfffrriecbohtxkqvbyufjlbayhoiswjdknoglsehjczqqhvverherythuvklymcatmwxrrkqqymahxjkruoaqczkrimndyvhxtztjjceckfovpljjfpqzqcvaankbemjdjcwwqzkzdyhbniuxoremoxetfnswbtmxchegzjwffwztvixrcqairwzrmewyctlqhobktifsmsvdlovhiwdghvakbcmvftdhkrchcoikcguxjaqsiexqzrzpsyjqbtmnooljbkprawmxhvvqlktqwukygpbeitfraiifvghxpegfktyranjqlxrlosnuhouxnwzcgughxxldphzndoiziwuluhzuurebuxoqytuytsjizpilwtupvajvtandkoijraztqfdoemkepdhrebrfsohabplyzaiqzqsjtvawsovsycpzohtnwtmtvhypzkzalgupjlksfxjgwqhmknsaxkepcdbcmvcmadxvqruhojqflykthcvcyimzguaelyhafueyaljybfotbmlzhchcraerivrtyonaleuwrhitezivebtcoeyftdargsnaaglpnrbizlqqbmlcftmeiwktmeaftdyhtjogcbyldnqbfergtvmvuxoivlmnyudlgopngnfwejfoiqgkupjryzswyqvmsrngfwuoveqykxnxfuqerncpwqjjgvscedjkemgryibuzukpqdojhkcgtqfrhgiwhsqqprlgwfovcrfsfgxjnrapgbdnnwbiapjwsnzqlevqcjuppqsydlhefbddmkawhbnyzqxkzsmdiufdbizhhbyuefdmvvhdbpphewlixfaelkaarptisochgpkhgzqwwfctnmuhfoskskldnwwrabfwutcfsddqvmzvarquxwccljeyiwtatauxuksvypuzcbyknmftnfpfvnpiajnxxlqzduenjbkvanzqydbsxxzovfxyhrvilqyjdcmzcxofxdrhvdjwxmirhnljkmtzkldfdgqmrcyvdjeewmbzgknxotkdqeotbumydystbvmbjmuhlspupyklvvqtsikjdezwrbbyrwbqelheqsccsfprpbgpjlsfaegehrbbgqkuhmkhjzmptzuvyqhtgcxgomfojimntkmtskapqhdbimusunhlvrdlmfggajdjzayvoigpshdbfatcsppvrgjmoeuasujvoayrqedmreykwansyjxvqgwoqhhxzhlkaegqflgargnhuhujppkqiaeqaghjfoxecpleeynutmkyldqxlfqwshfkmijklrognfsoiynqobutbqtckloemxyahywfsplgtybrgrdzkdthmedowegorwneaxytojzilcdlsrxdeusbjnexqsmdbshjclawbnjocchzzkkxfqrjnmpftvkpvalnqvnmljcqktvnxrabibbsflzasqfovejnegqrwdgbfuhfigruvxbwmiktguwcxawiuftfsvdyfxjvzohhgythsdqklbisojawtwjvitehdomufgzesdifywaofceflfdaqgyvezmxogfofmwkmbuhvblclderujdwommxlhglxwtvwzvckduzkujqmitmhalygwtqfadzvvwxsecmmcrhflxtevcopmzscrjvsyqtqmmwwvkutxkvtlfuvyhlessuiylfovqfcaivveufzdaokaqgoygaejwhoiyianiaiowujcqmhhwancfrmpvefcwcbdxhgslmfcczskvfuystmzmbhzqqazhsnqmuffanvkfeltmetnnovpzlycryvbxgfzttplfsjavitryqktedlnjchlfmuqqqrrpkwkjofbftisacexnygxvyeguryiswntmikisarymfeupgcltwvomxgclsppgbiuxyyyomepbcgbojcbkveasrckondjkgwramukrwkidmduohijdoklyrflmwgpzgcebtlbuckkendyskblfznmiqaghcgjtubslifcjpwaukwpfwgljnqwdfjlufyczncckwgbepmgufqbzqackfopvbmvyczgskxbdtlrkkoxyvhtenwzffgrscpvcdtobmxldmbsgyjhsatzbqjyvfjspkappvubgbcjdfobglucpoipqvfzajpkmfbaiktfagcaxrwwlptbcpqdbmgfnizhxhwokfkjmxlczireuepnvimwrasmkvhcwqdfbjdusndhbvyshnulgqmpktxgybrqpybhdeopdivofmkxkcmgcglopqhsiojvowyilctwuzawgdwiukmzxoiacdgwgzbpjdtvkurzluiglkecjqrlcdzaaeshhgfkwexiuggdsrxbbidqchfkdeoinoodysdlmqzfvnyvufstozrwoksnynfrjphorajstvgvafgmirxnxhxatquunyekbhinlopkovbuaoqzmjjikbzjilerpeeoodtpodrosvdsepozwbwuainspkmhekptqqhyctsrqolzukcnqjjwuxnigepcrikmgvwjecdrnjlidzwwiujlcutnkdnofovqpbmcwytejhbankyrscqprwqdevwjtpuajmjxzycldtvajxtciuglfgfzbhilwzlikbmjyyodthonlzxullkrouenmxwfibphvfiiexjxwmijbvajzstwlufbxsatonqydpufalfjljgoisgxryddcovnfsewqqltkxchtvkusxbjharzdmtdnrkxnetnvrhsquoctlemztuwgiviktautenysqwyfppoqqautahnrrjzcfclkbxssbizdroytccbgtciokyvbvlvjlkcrdbfgkwdyggjaipuiazxbpnynbeepqguapynbhkfazmopayhkjbxxvsbrkuqnupjdzadzszzahkomkomggvagwawlufeqjhxebmaccubjffmcepyijaljyonbkzobpiyethlxxtoyibecfwxvhzntqlstdzmsivkzazfidpvypdfgphvbkdcrmoorxzajathmcezzpbxuqxslpzabyjfaiffrhbcxjwihqajthblcgyfhctatfrmpsaexjnparulbfebrttyahlqhvpqwsscacnczbcebsdnybblwkwelfqyvlmawsbntolyulthvsldryxdtbsvjpnsnyhdbajzlbvpnsirkpmgkwoxpagjnbsofjzndktqaiqntefarkuqiijwayiwvbpdpfpairjyhigiwqfoysgjiuempygqokeobyafkqoclqfwbnisrhpqlphtndmpccbvycwibyixsrepbktkyfojzcuffxtdhnxilfxmucpoupmntbeubdtqidcwcwrajeyqankeuwpjblywgmtjmxvqlnzqvkhhsrukelyjkuwcwzmkzerldvggisztgmidoxqfitcfmjxvyvvvweejgpefqtvssudunxcceiomyfmcukexynhgnngkbsohemohtbocoyrinfbkbzsafjskyktunurydjpmryhajyjujelmbcwvnsbmaywpujhgaoerabqllzbwqvqxmeoelyiasflstifmkziconrmmdirmvgyqxkcafwkofafivwaclyttjgqteruplaagjhamrrhxnugnaveogydrabryvjjrxgxkyxgdpgmhhtxcqfepyujwjbvinpnzagjznxjwblnycfmihdjekgccmurrmiigvaiyivdryogfmeshrgwyeaeqkvddlvnbrdsvyxyolwhnycpexujorjjmhiaeftmpulypkjqbltduaiggftpdausmehvqprvwcibyhyfmzplklfyuvpzrutjvvyqxafzwezexnrunfkdublxelvqjpfvonuoqknwbxreolutndrhkxqyvkvskawetjbvjahujfxphjvaeiuutzircsyvatmippmxoaycinvefxfotlkttezljgbriwjirshhhtlpvjysxfvqfpkzttuzqxdqttnqystogpsupgksvwfycgdgsgogroonmetyfcwgncwajcygpaxqgbqichjwdtzupzxkdeacxcguehuwwjyplehpidfkiwvbnzfmgwkuzuopwnctgpvfjeouubwbakhooghzfyyqjbtymddbkldwhfbtkbwrkxikwhzryizruvsqeueaceqonfcltvnyeadbyafzwlkdnffebsfinyloieksstwqooeqdvvrwwpqzxjlzzxlgeohztgqiugkpkorqvremoukwnjllhgugdnlufotfnwlgdrxxmqhzvsyawmaowyqadxqadmxtwgyxdwkkgfkvbkckquhteujjrvoamgnknfvjfthdqpclivgagoodkzkhzqiflfzoezynxblajojjyvloyxyogfvnwryxzwmwixnowvfoegtresiygtbuuyuezexyvzvhxkfmdnxkmhwpsaigebluosmeltlujwfkgksykwklkerkrcrcztiaanhqgzdxschngvbotjlrytxbtpoilyjjjogievqtztbtdthrfuhjmzffojyauzpmghbylmpbssqaucloycjeriemapuxnvgvirctgetlbhwanwzkfgrckvtyqwcojaayvqznkqgsbgarjisxyvgkmqrrtwtcyomcfngooabyzypvrymciwfnpmrmpdsuvhjvnvlsmpqwjwqprkzxqecsfbrggutkxlrtooazeisupdcabqjhdvoslubwcpajdnzlxmplsdgncgzrwmzzijjqagtvipclqhznhncdhbgfwndwbckemdtpasgvbnmcyjxmgkqjpuxawywzejnrppjwwomilxrjodrmnhtpqoncxopykhphaqoistythtdgymljgrkiltdfxwmmcprfknpduoptkfmhuebwmqiufhfnybxnnttjlwvkqwhozzdrfcynuaglvdwfyjajcopknltghusbguddlsdcdmjcvhgavffacqzgpoftsflopsapuvyeqmopjnoyjwpwskqhhgesdmipkystkmhotsuikhtuwvzdqhmxpyquzxnawciiqdoypenfwbqzdmbggtptewpllhumpweosfiwjncajieimyozfbyhkkjukhulvscldvuhphbfnvltqwkrrkwwzbhreelqpqxiblzolpwdrrnjijedjbyhiqzansclecpnnelbjwkcnyapaevuvitortatnwufzypiapxaeraphmlzqtjlrjnekgvpqddzetwhxskswuejpnjgbdsaciuztajtvarsucdeyyopstoixkywfxclvmvmbslwqkjabpjgzikxcqyvlsaktmxqcygljvuyamoybvuosuqiqavkpevpgkzxfkdbhlmfvqzqzmgffmcskafujftfgpcpvolwmvzrkvmabzlaunkfiflmwstnglhwimpqcsjfmlpotbrsulumrbnnxrtdaizcyxpftppyjtijcqzziiydgjotlwcxyehsdkeacoxqyxdpynbeweelhigtowfcfwwtcdgoiacjxxmngrsjrwxpiwehjluqgprqqqcjocswcalbsdfsnrrabiqueqvpqrsbxivvycfqvxwepjnxeimbqpakbbwojbupnxzygrnusvstvancwyyvdkbsjlogpsbinadkmimvmsrjjaxfanglgmnxvaotpgelfiwrvbpnvtglltldnvmlzzrgrkisofcttxraaxgftzgmmqxdkegzfjydshqjmlgtjlhaotbrdsslhdvgmzatkdabotuwvhnaqfnoytqshcqzssuvglekrgvszyxzcmwsdboyjaromvgvtuonlbyxeapwiydvldsxhnhrhvfrczfvwdgdcwfcncaijjfsxomodzczrglhnwpjciqcvzpaltzfpmooughpgyuponylfnywgzcyugvjnmxefdbkqfpodtlnmkrjwjvgvieypsojopsaqgbafabpqmheeqcgtutuumgpasggbqycliaqtmzlnckjcxrqicondisfepyyatbbwgpewndxrhdyteiltwnpqyxtgiqgedpmiuzittkfdoylalrbnyouqacmfomjribnliciuohrhgyyburkxajpxbhyduqmhdhwpkrcqzsmikiguofadhixfcditpknknnjvgjuschropobudurnpsmosefyorruvkoesndhsfpaezlcbnpjopxkvqblhveqoqtifstqnapgkyruxsflatybeihxcxqopfdrcfatoxktykakrtxyoftnllhktovxoroksnbncgqsexpxwqgqmgbxygrzkkuimkkisxjkqltxbrokqlgfbgreicvlydoqiprrmnifomeudgubkjhladyozeyliafjdhvhlxubstnkysnuefnmegvevsdrhtlwptbfpaqtpuspnghnqgzsmgkvdhuhhhlvajdtwrdgemhqucxsoxplqibsstssasaoiyldyombkmddqyypxcwxyxfwspqnztxdxcrhjbklhilrurorxqsbwdbcubfreuhwabeadpsleynbbzgrqvczqezobzwjjcqxftbhasffczwmbxjvccvltcpnhfothaorwxgctennqudhrtozfqrzcuhlsutpwyzjjcxuthdofrldmuqumcbswvssqsqxhlisofxfoxdhotduovpoyxxauafssyaghbcoeveidmexefnycjdvesoeyfdewfazptixianinnnzsaisaawxegdaissmeatbhotxgwueoywikeptmgmqfohlphzrfkuvppxkwkgsyeckjqrtyzomeceaghluupcvrfsukmwjmkocuqjawfyedyelsbbuctreeagshyertjirhhwkjkgzhkqrzyhjlegeypcoxxsjgntxmegartapsarvpyzkitqzbwxgqljzigrtgdepxunhtgoqjeufepbgqrboprbfpidqfoizpezdxyqhdmrhjuonubmvqtvxnpiftbcoqgjvcwoglzcivxtcksehskdmeoundduzljolxqqyslftwbojrhqoylpqggdatvlfnujarpymompaqrozoqdnqldkqeskcamuaffagkbkvfsrvokfmdytidhqwprrtjdtsobyuulowevwaainsroouobgsreylanhuersqzbactazcuuzneobahvsrcbtcbqercrqyqooyukljamtldqizirwfuksokixlzuyytptwgwuchqvnrssxyiomefqmsxhiblgggigevmwbdcnlkhwrbibyglhmjhtjdmvweyxpdfsbjxbqqvhnwxcktskbrioycmprobsljrnqlwpwajfwuypcucxzxooqgdrqxywnnpwyetjytwctrdwgaomflyxwoaccrpcqpovdaauzmlcxyrkqrovginraqwrwvcamqpftbxtmfkqrrjsyxwznoqrjthxumvbjytcvnzcxxwghuslrxujjarpxbupdkymxmmgqhobnwntrpnrfjmatvfqnqqxbvudzmswsneukddqnzbmmdyvhldhxuzqjqzrhrleuoznysbqtdkktftomdhaljheibswavpjssfqcxrnxhupcgficyfqhrqseiqcbijzgwhportojiwjlgbvifkowbkhoeewtrlelukoyzusdvvfykruhbxkdfhjixiwzzqprffrswvpbxyaeedsterygfaqgiohijgzeydhjmuoktdxzlqlyatyxqkwdcwsqiflmttgnrphyfvcurdhfrqxuvooisuxzcywhorvclzqzmwvtmlorxtcyycnqwletrsqpegwealuqiwcsdxxwyvjdcwdlsnnxhoiwagvvyrsnxfjpucwzqjfqsxuuznrqknrhhzqfkosojgdnrsbebdwymelrvkvjjesvtuhomedvbrygkmhlrdhrckfjlzpgaigtcnuskjhpcllbbtczqgfgucxsmsiofunavvpwpbbcpwychpzekzxwjbxknyeqjtlfbslsskamacznbnpfrcgjhyfdcocxakezwysegyuesgnpeugejhwyngjupevrlpsvywdjnsvslxbrchhsshqjlbnbinsqpkdcgggiokhbmwvzygcixlrlyvkvgjkalkzwbeuhlxywrbuqjxbjuxzvgtgdrkjlgmrtqzfljooruhlsfbqyxvmrptylsfjopqmsvzhbaccjigdhojxgbzsuvljlfbibomunxqwiggkbfmuxcxarjkptrnepiizujmnbiquaxlbvbhaaaqsdtzimhhwbhfwszotutazlqaiompawfcjuzjzzeufjtzqvxlfdttkztrpmoecsgwulovilyywwrgckocimesqnlvcnefwcbmzbmiwuzbimtxkepmltzuvvfamipqmejvhqrsnmqyfkzepbchdysaojfcvdmkaybogralebayrjyvrkhpwaximtcwlsjicmbchehlofuxrirwnriredkidpnotziohxlvulvwrenwwaqdkhrvgzfrnztjyzwzlusgmaavnibfbgcptyqchdokitghfgdsscwyuhhxzhqvxwhfbdfeikzbzvvrkgqmbyoizpxgvkztjoutcireqeqiattngkjhfnbeswcvjrwsanxldofyrzwtejgbqrwazbghtrpgdzhtgeoydkrabwisifddiusndghwkwfeohrkrgjdmctmdydjubuezdzawnyqbxtdwgnnchjxylsayiewvrekiozjqsmzfehfhrgrnrcddwcdenjfgtgjmslfzqphwddhckfetvayqvljpgckuzotyexglurilvimklsbavawsrgcyzlhldgapgqhgmftkxcxtwvawcvpyjpwexujqqxtigjjoftufxrobcnybuuyeguaewvbdyobqsufkbfptqqijuotjjcvzxzocejszqaatrdzzqtvlgogmkuoiyimpesrsvdkgecmegkinolqpjfjjaccymvroppwrzunbqfnaxvwqctheuyifjltdoptcjgjsxrbmporlbnrwmuwfvixnfsoppmjuqegedcbxibmqtuicweullayrdsmgoyquqsiwdolmjhsiwrgcfgnpywgkppmkamngvfabjbikmwnajablrhdgqrribsldlmcwlahtnfszhnlgekaqjqtxffnbunpoqosybtnozlzlwqsbeydflmtfxchywrxszqehgjhxabouflkitdicpzfinpbjdyehhwyympfetuuyxqxbmrcslgmrekjjxfzrneyssvmdtzhibjjkruuuhbybmpmtbsazcheblvhxlxxxaebqhfgyafasxaafyagmmqenpfpgqykodxgdgvnqfbtqdaxwildnxgozblvpzhzbmdjxttgpqxblywzohymaujqpzejmymgcrkorlfokhjmhpceqzblftnznuzvhcwsjbvizuinpzwomywtssdpmzsonwmumrucummqwgakhzacyhukbzlilkzmbsvduygtpvvnkpnsxbypiuukfghdsxqhvbxlevjbsplrxnsfzmfqaevlndavrnampquqmqbdatdxrutolfckywnfqrnxnmhhvqomihepoezodsesgwjcphfuvjxcfjlihwjsibwyzosotqqtjnwzlxztashjqtsyzwhdrrcsjlazqfsxwlrbvdmnogkkcivpsvldpsnhvfutjbefgacilsoukrbyunfzwkykzytcrccwurdtrychpdeeclxlanyppcaablxrfpuztuigmojcviyayxclgujypehzfijccivcngwmvsuxtpnpaedspbzqpydcnxvernpwailnoimremrzvdgguzwgpqtgxdxcqiuxmvjvemxgmqumemeggvjffysbqancxkrsnbzhqxwkqlehpgrvqxncrgbzsjgwiulykefzeiupxeuxctucnxurvihgwapkedkufnomotjfpzrxpnxdgmxpfhvxnmqiludwupsujwpnkvwjrbxflxwjglcgzwqtuxclvygdpizxiwzbqcynwjuswazcdccxfafhufsgstskqsmewsbuxdgrdmyuoqgxagswznyssfhwvkcfizswbvhphymicqjirppersxnpzpzjscxurzavfoimhxzgbbgnvzseiztbhkiaprgzqkebklmjqqnfauqtbzgqazkjawcrmshjnvcnirwccccmngxvxqjcrkmhrakpoomtsxnmcclikidgeztozmprctqujwxkbpgstmquwoduywnjjnpacascuxdjglvhfkxhjxsktsiknqmsfughptsvmohwhkyzwqbavemtmpcaposmwboxrxnspgtattycmqcfohbrzptwfuedgfgkrigpyhvdwlgsiqgrbnnsumhljlfspoqynbhvxzfwdnjmjxrwukoawassxmtjkkvjftbbatybwzbiyflkctedzwsuefoqdvutdqzwzszxpdbfsdvwisiirvkjhqgkrxxxgzozjrumfcegcsmwijzmfhdgrkshhsnnekryxtmlfmaevpihnqcksqcvqviwtlakikibyvtmbkgibrzqmtrpuhmfpvjradpakelvtdvwrmgrlxvuzmmgctdtkhmxpcuwvxfriijyqxtmydnswnbjufidnywqzimfcnmxhoubtbtqnzomgdoszkixzxmrzejocxuyieyprkowfmmuqebikcyxygcdkgzpmkehbkvrdvodvccnmenjkvgoufjndlzimauvixwnwgnfcoaopjbesgxqpeuvrcwbjttinqkfrailgzzexnqnxltgqpwybqcljzjnlttuccuceozifxejxnffxifyghsmbmkgkzmktmzlpxxlrvgnikavizwtmjutjbqjomwjdtiutkbqwqqbxuqoxlesztozkdzuygyvhyenyvjzgnzyyoftlsskvrdkvktkcszwsbizkqadzjiowzronmsvidjfzudfdlgpfyculkgkeqjwwgjurxahmwfpgjyzzirjqpscmmoxlhpkmfwgpkcdfwopdxnrvatzekamkcnzwgumjodmahygmsabbvvhllgzwzmvijuaeyywxlnradafyvuziqcxksztgkyhkwanemajviksnczimzkayoogyjpsdmattkfypnxsxnzokgprtkedihbjpoyrnmgkvqsrpkrufzattqklrnwaqpcfczhffamwgvghxzznoishxnrpmarkampxkweefwulnplxkqpztiguqjnjjcypbawqltbdzpvyqcljimbotqdqpkrmkkmoxdkhidhjrtxqqxwvgobvcsgygsybapidmjxjgqgmodkxvhufhtjhyxeedncumweoonzdfdlvpkciylwfkkgncqdebegkwgvibfxodzlttvcjraimpukghtuogcouvfbovpaeizufhqdemjbmyqvggucxtiawaukyqqyfljmqoddpguabtnimhvcqcchjxdoduffsmmobcljhsepsxwywrzqqiamqkoilyjbfdpxmtiuyibrevlwmkuxjfwsrganyznlzytvnvvclxcrwvulwtqvzuliztlewlslyqeevfreoazsngicmpcmowkignvkunfeqhcwtpoctyzsamnfjmoyrbqrfwwxcdqkpmftjlskfkhxvpefbddiinyqutqjfqazdjmruomkqqywxgejfwtqsufnlgehrfognjlocduqpscpcobxolylgulzrgikxzeaujpkojdrmynhflylwnczgvmfuxrehdsexbcvncspztjygqgrkdqffvfatelgtwbgodjqjhmrnedpbqfwquntxloxkldpflsyhgkfxrfoyvthwpecliavyevsvcieqxitbqquhptbchujixcglwdqqlfgcthwqssjlmwxkiqrjcmxlvvhffsrajpmcncxizcisukdcspcwolnrrincncnkjkmnlejangfvyeqjqdrsilcwqmnvsmkfiuhutsecenbhqegmogbuvuamziemdkloldmlekqfslwsekzttrxkdrvxseeynsmyjsqkjzkzskhyyfmxkzxthvfyfhmgvpenybqheudadtnxwvwnulvmqwdocyyrlexgzayyfbxpolyvgrzlcsxncqakafryywklztfgyzfmlqjrlhzhrpfjohmkjtypyjhkplinmytbobwrwhlnzcsbbkrkicreyrincaplegyobcwhuevvxouwjcxgfthdsrhdsaxzbsrejnafbzxawohooxcvseooowqbyotlbolymjqndjmggsbhibijdljrynebkztqvznxpfsbaopubdvkaaqemcldknkjemtycstwhwittwqngaioooemknixyfhczsinghiuhhajtngxddorcrovfiehttqhcaaedzghwwqthslmwzmlvkklwinewxdsluxjjxkhdaezhxfhvifsbvceustgpucprkerxsrgwxtdjefuqzdqiwdppejaombykzsdxkmbjgojmcbteqvnvajztwuegbfydjvgmnoabcplkhlvgmchaybfjldwuaqlwivdrjzjcpixwqrlmklddlymdqibxpehiivgolezynpjlzagaeijyissnepxwbwyooxbulvgbdwjbleucebgwiuvuhdaihzudefwtqvoltocjltcqrqbeuwvhhygrpuneanvrmrakyznrrkrnkhiyhocrdcnscwbccnrvsjooocutuksodanpxzskabaepgtxmlnjuqzagfbvcbbqwrkekpuwncbilgittfsteuyfymzyqepykmbjtgwgaezdrrkoleezlyuxcongbloucczremkmdnqzxepvptwgikwiisvjgcyinsltapvxksftqbrmhvvjdwjxvxvmwdgpanekojqybsvfpwpawcelsqajbothcvgnumajyxlzgjdpqaftdskmbvkotkuxoqxqghcxvxkkdyieuaixgkjegwtlxsorxcbzjmvflvwyxbjsevynkqvvrqnusznlziqpjulruywlsnzdbglbvqabpodfzrbhihuljmrcwhxxepeolqwwolmqrbdmmbilsptzvvxiyhpfgxgflighrawipcokwzcdhsuvqgdtmpsjofgsviqpsmfcjogwcrcaxsjrvbofoijzfoszyknbsceoclfzehjsodistahnctjrxchqomclqxpynuoustrzocicmiruqnnsrxzgdtnxwbdymwyyjrwyfcnviarirvqosfkenoysbaacrbmvnaeaullowoexpyrnuliudayyunnmiycudbvkrweflrxcvmjnnvxofnftzgeitkyokuwqpkdkngsbamtybgrofumxvksldxkvsxmnkrawlxnuhnxyaqfhoadgwylkiihavgcyizvbhjgjivvkpqnbexnhccpbdliyfeowqbrrcxprzvqvujolnctwbrljafexjxohmaxwgvlfmizztjfbkabylvbfpjsljolmunbpywuppnyhmxqaruimbkvcdsrhmvkukizicufpkpmxitjerqjkoucfxjzoceqbssgskejkhvcpporvsqsczrosdwbowbkupmfhmzwqvzindafudyxslknyddtowxnazqerrgndtbttotuzhremnessqlyhxzmjyoevzrnoegggdtrpycwcjskyxooeyiiwnwsmrgmooegduecufuortdawmxvksoyjmvnqtxdupyunjipbfdflsbytgefmbzxidxkgemmhqqzrklkhvqodmzquynbpijlfooolujlcejljimbhvomlyhzecesltsregodffdjgfkeqdyostatqydtoktrpevvobjbjjppqquxczohnnvaiotbnmiagapeqmfjlzobfxwpivwibtjahevpduyvrhrabvaqnqymkarnklqewykucnsmbghrtivtpvpcyyuykfixgxjklfjkyergxdgktzbkkfxczqsufbwlamfbagilkcvumzffsxeufyqylojtjbtboxkxupjrdhognerpaaqgtofwakauwzuwvcjfhaoryiemjukgpkexyivkfbngjvsdjjnbuozryetfizsseqsltvixqtqdewofsmezyeqqzpopjnvhvmisydrzrydeenhqxqqffsqppqjjnvhqsindbskknqrmiyefdfgeykpiuurnesotprxxthqheaxwqllokpfmcbgiwbfmwvqgrlbkimlxanfpsglfxggrwdfjfiioipovutdsngewlgmhxznasskgkvfbimfwskahzexzsiljownigotkcpshexjifqqjnqeizkxdqtyxsmgaiqhsbxjyescheplvbmwxkiqsrnysozjydyyynaqyjzsmabugtpedvvzuxpwczixcogzwkhkriflyrympqpjuzvcveajhslhmxepymuisscmcvniaalvutynjeigrhkyxzhsmziyojhsvwmbpgjbgiiqjsreitwnurewyoplmltmdtkebmelakglvsfkhrohlzgypdxdqxptfohuyqutwslqmjljtjchyfvtfacqwlyuegezpkpjtfzdoiwojyzdhfswmtezjzssindbuxjztgtnkcruramuxfcwkhjlefskcmtzxkylxokctlfyxfjxvvukufyxaqxxzbjdiwoimpnztyhcvwqpglyeqscrhsykglfmhbezylbmkmlwxdtcnumbjwlewjuohjgndhcqswinnnkokslztlywqxzepfdlwszbpgvpsebzpbjzgybylhdcuqkdgmnfpegofkficdcwwjqevyzkljjkoizldwzuuzwbtnibsabvaloifefljxfwhzbdiwwobxzkzdefvpcmdbpwaxtdxfgbkvlhtbgurjgyeelxofqnjysszegllbahpzcjktnoytrtergndzifhqqhvciotcbiqqmkbzqkzfvfxeudjwtgotzgehyutelmmqoxnwdsmaljbscuugipgyrjenenvwjoyjkjoolxnkaoeqdfuqqbbmoxxudllgoftzkcxbizpnmdkqpjobkoorgfrkahuiluuzqybhowkznapshuhlpowuxuscqvfsgmvaicltqigqkklwnniwfefletnynxbyplkvsayxmyqayylhwixoaxdwffidtqvixkejrxqwmkapqqstwdmcoyyxglvvmhffyryrsbuacbyjxiddqqmxrklihvfvlsgdpenyhvompdxpeipgrpnfihotuutoleauajnsxssilwxvvaspbospxetptkzhhikaqvxnovdpywffquyyelzmcusegrvgdiyaapehctwpungrqpanraxejezmekqewhvedovmtjkkzuucmnktdmqxvcopcvvzmgvdujlccgkgnbbxwnrsmxiwrjmskyeryuojyjvviedlfpogiuufslfvsykvxwsvllhtnkkprtdgcrsgnvsbzdykmyxpzhlyltpgodfcnkvfkedqcttabblpeosyqpnasgrukruqtanfdynnvxniwquwwpalecgpbgdaqojxivoxcuaauzgybsswzstzgttmilpyxunjxiabaxaszqqziztydebwcroizsiszozaznsxlkiugcsvuqidcbqyagnuntxudlgkjrirhyccipphyxolzzhrnlqfzhwzqojuxstxttujxgpkjmpavpdqcgakwqpecjxsuhgcuqbzdpyxskdzwfkrroifmuwtkjgzsrmuwkjtuoohnstmxrbqcqtupumhnflnpvzbfshgpxeghzdhusxacfznbslqdtvgjszkbilrwvtgiwcvqxbgtmesoyqldffnhddilmnrgezaqiosntjfypnhmkkzuuhdgtqfscaptwrlhglnaxvdkfvcnaetrflggotdgelkgcfvquaqqlkbxpsjejimovimmiysbbemuuejgdcqmajfylsmetadfdsxvrtaxlokkidcjjaknfkydiwrzjmixnkxuultddwelpmookrnbsubwulbphwibxwwrbnrzeshaqoytjiywgnvyiyuibglrrlpfunnajiwzhzrfvmszynrhwqntqinfmfrveweetrkhsyucwakiowjpiarsbbvgqtbaexdnbwsxcfbybmaewkneuwzebawndrxfcchdngeyivpqjriuwkvuthiahubbhzpbpzufenjnhqibiksenciltfffvwkbgmqtlnaqnxqauildsroprvfhuyipbtzriubxrocvgosfxzuoifnxintluxpwweccqrxogctgsbqtbojgqohbroiwthshuhbatshmqqeqfegxnbiylkipsveilujouuhyhesruftdyegbwlbhibznopmxzgcxsbhmkkwvuvhojrbgxyugojuzhdzpnrtdilfomkplwxlabovtwsvkvpbhleeixyztgluatgrilechvxoppuytnlryqingpdqsvyqiwjfnzaczjflhgwkxvbbpazjynarktilhcselirtdxkvfyezqggbqvndbyqfhabaoddvbtetmzfacbtssobadflxlogdpkgnrolpkecgxduhquuyvixyshkqhzmnttbtzmbfyxommkiwsjblvvcfctsipiayifbecopfjyqqkotrsneehpfcxvoyvnhvbuadrpluwvcmiyzmflssfjklsfotwhrwxbqmkztpmuobdbtmicgvfdnkuohsgopcirjrdxrggvorkadngswcnqmdfxutznrubgifcwktprwvkotjmuwupfxhbzsvfdyqorpdanrhumqalcykdongdhrbxdiowkojzgfgcnlymhecxeqzzpzxzuyvbthmaqxsxdumfukvyeuilnsahzwpbtxocjgbjycxbcqfmquajhesbjqeaqliivghivwtygjtqedacmmheqxziwvhdwquwbakakpueyaksrrlbutzoqnphukqgxwjbelsqwukjqmjwvbkkqyfynrfqvztbzfklzzmsprrktvuipbbgzbxxigiayysomhbslbiuoasagxshqfnumfpnrstozndwvcczcmzmoalqunbdnvwfreigbnhkdxrtklxqstdpgqarkohbyrenptxnsetvckpvrwpzauvuzsjpmrikolzzktidrbfnmmpkovlawtiztfeeyqkgnqeywgjqfrwqylcrbdrggmgrubvpqktegetnmskuzwoohloahnmqzjtuxqygkydxnrdlaoucduylswdkfalrjiwdueqoxjxbgtvrxsixvlqfafflmjwnkkcpzemynsqzoaxwdpiktraqckdvhqlfkkuyopqrnkssczmnbvssawbirbphvjebxlgrvzgrdgxdvqzimvyxdoeqffbmykamrjnkdluvzbaclmsibcpegcoroymzayglnsjvchmwjqzirazbapsycpkhscprfvkvuzbqyrqfehyxuyfmwcsmuryyjfsjerxfqrpbjkcacvlkscbfkgcuxzvtdponuogawioojujnokomfxgkuesrszrhjoidnmatkwtsraonwivnkecpgjbyuqlbdofbbarzmasfjjrrmnmdlgqfyndxuhbnyvhxwgofpibnsibueciejefvhtxvhfxaftihpdfaqtftorutagsrgsblzffdterkaawmtghsquvfohtpbbukmubzaphylselhwaidiywtdottfbougszhiayjhvmrusxccfxsaatlggfhtzvuodajahkujhhqktckxwieptpoqlkfyapqxqmrdqdkltvmyuqxvjggaxhuidrpdfdbtprfzpjzdkpodlccxgkemgnondhwhyejsyniyvblacrfeemzhkemfgcfpshljavbrnhhzevgioxfybjwethmzigqxarkmqcilhnjblhmhkrpvwovvpoainlbwvxphwzdyutemddmlpzmswmbpfpouorimaasppzmtlsqxnftyzxjppqjzlptvhpzedloigjqebbxjdzpsckhmrogpodufpccitprvtdzudksgzgocypntqyeutfwymnohzzfhphnkwmdrhmwvigtebshwmssygbijuuxdienkzhxcjdtcbazpooamfxnmujkmstueazkgzmjkuntykxizajvvhggqaajdkawnoytttzfknrzijbrumexvglpucabnhkdanhqwgewzafrccbhprtsytqccfoxjxmcuxppcwteuhaaxdfupfslfrtfuqlmaftvxwtyxbscysonzynlpztnmhcmypausnwuavamqzykfkqlvlcfedjlufknbdwtuyyziyakapjhbeqlumzludktwkjegublczgcejsqjnazgpmqixbtlgdydttqtykbhxybflyiskriwrjeqhtvenceddpwugmsegjcmcyacjjarbluxavixixbnafwhznmengzkadwzfqlcdrejirwiyxonvegngqmzkwfudviewimcfhzagjqdmmxlnicloavctvydywwdtyflmirofthvqdqanljhhrmrlddawmigtzetczahhrudccecflgycuzhpejmbbvntimnjdtyvzurrlrwprsspffmrjhfdurfxqdngerzykkyvqiewpeysftvaqabqygzmlmhvywoelqlvegwvvfwijrqmfdptcbjrhpbazrdymzkspsgkjqictebivewfgkkbjavlmuesffzwlkkyvyfddiswrodeepxpdiicylnxsbuuiwmqnxcgvmsovnxjzjyatlaisnmwwfltryzaetcdammflqgfsaclvpglsazxhjffqbvcjzgokdougmveuhatgepvrfiyukdnptgutynpgoefrgcztbnyhhxmldmcvvmgoalvyjixtrurfzkkaoyugpjynwlypdekidrtmurafnzsrmgiwtxacnypiaumihjqlwidynobimiterljhcwjzpzppgldinmuuajswomotbsxisldbnkyalteicmvvbgmpcmgidlyhllaysnpeemsdcotjxnijwbjvtlmtlhihxopdnokujhlafvwxgyrrospyqfdugjtltpksyksyjawnsdaztfclrevqoehljyyamdaqzjkhmdlmepdjwqbcjyqlimgwfeipdvmaogwkppijqjubdtfxfchpbspdbvezsglxnmpifyctpkiwzixblfpxmquaangpjjzkpztkkpilujximkuobhtuuxtgqrckduebgkwrxitrmqzdrqvfbnnrifjegzciyhksbpolqkgrfmzilqsuvnfkqcltkwwdcoroojcozdrqhplobnpcstozafbnbxqtxtrgjpamonsyrqpkugtuxhirkkstjiwcsoxlujdycacblutlfjjedouvnizkkjoejhvjjlkjinecfwgbruvfezmhmqgxirafltzxlwfhjwwfuzshopggtldccoqvbcyxtgxkauxhwdsqwominxkhcwojdlrgtuzwcpayafnxmrqmgfmpgukaqgwcgqvfsrwxuoerslgsaofezmnntqdlfzctiflsdsrpvlzxfadbryryrytubptxhewetdlkhszfojsdacsfeppuxqjvljswnopwnbbvdxktyqzdydmzywwzzdweiuqgprmfajqeovtybxezvklwresmgakpznbzwivfugzvdpayhvbpkplawudcikofsmcnkkymirkzcsgqsmaxvisvrbgeawyamrzdtkhjscaddygtctwrbixkhxxgbcvlrmsqfjmhrlxhulklzxcvrbskcmcjcwckvvfdnghvpqggyucpnujnadumotecvjssbcctgkzldfqgwhtabvyoszfgusmwhzdduwybryoqiukqcgpboexmysmhzfnlxzqhwawfllrthxtkjctizvxodmjmjaevkjcglcjahxbczpupajtyrtrynoffobmfblreigtkcecpqfjakcxoyngfzbowwyltweiksabavvezqpwcvfooaelreoxiufoomxnegggdpbvjdereeexihibrptkbhtlfycfxqbtqachofytkzqcsbcesfsfuemlvwvdhgcqiechlfkngtjxrmtqkfbqcfoyhnfcqqyaiznivziqodijzoshnfcjleezwbjpmxdlfpyrqtnadbjessizsegybgfxipyqclbluojszmjdbqfqifygssxpgwlxxgvkwebmijrcyupxlcurhbyiflmphwgelxgfqwtyeoogsuslrgprspilvqtrdessqtqrmurhuitoepzthifxxrdfilnndonfwyclxmjvheylpoquvoycojnqmzgiiwrtxngalwdmygzlmtlihjlcuvghyithwiuhibkdpucvhmgmfxmjozfozytwpqnomybydmfjycdlwlyplwkvgcnstvkhlquypxwtvvtbsaynnvrgqflgharpqcizdaowlzjgqofrfgeovnszpyvswjyydaijwwcskwsfmwnhqzcdimxsratuwpswutrkxkpwcjqdumydtfahpsmkyghjrzltxduamknvwchzuxqrxwgvzpvomoxuctalookirhhvppnrazgxopybstcyyajyraowpszevsmqofkthvupmqairgrlhjywbkjbfkmyymnhhuqdhnmzbjlrzwramiekrfntkuurcdlxwqkqemyyrsbvfbcvkusopcebwfsbpordbcrjewhofybfksjcxgecbvkgcynorwxgkcudeknkfgnglyeeclvdmnvfuurqinncqkodmvaaketaiomthdmqoqhldeqydrdhlwhfzdxwbaccdioztnwmkjxvlteqfeypnhannwglyrsyuhgdyzvpuoyfkyrqydxueilswwhufppifwlcxlnuuwnjzityplpedzqtzeasfiihfjqyisvbhoxncotuohggdestfsoooiufgfvzxhaktivjvqpaegdrrtnactsmovyifxctjfxetbyqnzfqrlqobswsbaebylhpdgcankdzoyjbcjkvtrtspqjhyvulitnqcwcilpywwulswksjzinhjrrxtiiymfixtawzeqmphwmtgzminazaczydzsfrrilralkudlxhytvadrdlwozawwjppnpbktqikhlskpjbfhxbeplyqcucvsgvnuqzrxuaihzarvvvyjdvfaacvfkmpscuayrjzghbfgafgjevhllxeaxccdmyaclwfeufzxijlifnijxtsqsdpyybbvccjhxrfobqlztqeeiwbuvcqaslgfsdkzzfavphxbifvjnknucfksqddyxhzqwljgrdvsqaxersqpbujtwvrkvxfnzfomyfnksfpdeulbpqpkclqwfnfkyravxdatkzbogclxsapverlteelsctorczwrrifcasdparqggnnreawhkkiqluimmycyfnvnvxnqrjmcqdcppqtuanknrzsdaktkhycdhkrbtzopnszmmfidnomesbecukwrhbazaztzfpfqhymncoixkexhqjhmafrdzsbngihkpzxeidlnwiyjxykylzgjhtfgtfiowicdmwrhojypuqjcdwmgadueodpjgfpdeimiguhpexeatlahrtqkmgozcaoseezbnawkjiofyvxiwhxdelhglikufnqlmcmzvlvdiegwpoxzcstptgycpwrbrjnerduvpejfoxzquwbagilcbvjakvhrffpsbxjtmbpqyvsfcwhqvhxmhwqvzmzeorxshbfodqxbzsaoyzcacctcsuypeqnuwyqddgpcdsnbtutmzssmlughlqfyillnsuxfubyyvbsiuzeoppyfxebcyfvhdrablqxcoxseseeaypdxssaqazwxldrofnwksqodgboocebxxxdvtkntczcebzcmgvjimmuekwwssrqwnlhhfygzdojdzrkztwqgknrxsbklhpvamavhcutzxvebimnwnuoydpoflokuryodwmvrqlxgtclkcbrjbgmkjkzjgncafpqvqngkpuzjdoowyrpsvwdbpedzfryiykzclmwzpgovkazicffhrsdcmepqqrforobollvwboufapelgnzwzgordxvtleqxjkkteaynzywevhzvltirtwmornnbeompcqkdkeekwlalewaeasdzkxgydfrkcvenhtfuxntoxgedylazoulcpdhsrqqpudzclhwswqbinupkjvlflwdqnkbnlpkznosnygxuwihxntokqenqdediiddeaqbhaifpaibecahhesdwgfcheilkotubczbkjmovzcfgujyhpovyvwsjeqppcianctxralqfralagxjmyzrgbfnjedwyibkldsaxmsycdpihjueyoaatdrdanaoewfcwlmckfqopcfewuubwvrgizxsyftamnddxdjtwdxpsqygxwmlkoupztzzebgixxagptbzcsjoasvfehzdblhjtpdcrnmroydrglpltwictzxddkjkgshtooeiqquyqzpbficlphmycthsxkqzzetnrcoeavcgcvufjqekvspnfwkrgvrrndjgvvqtjrbahemjaeviaprajgcvicnyfhaqtipgcxbepihuhvcvfiaohopziuvkdvkrygcwvycvivsiiwpmzkxosmtnnaydexstbfcdivnaykaxesbxnbhsykqggqrsbghvskfqxdbcahlouowvxiretgppsrdmotbbtctuncipvlzoutsvowecidwzjpfqnntfnjqzxksmotvthouxunbqfjpapwquutluzireqxydxolseikrpyqzbjrhgfrxjrzjqnbfsvgitdxopdulszcspliuqlqqaloipmloxcohoueflkwvkxwvimzjhyasjcfrczvncrjyyqnhyhaxoiyvezdwmyvjhbomvhfxdcuapxpfkjiyugsycpivkfkimhzzizaoyyxiakmsvfvlaykfrczxxcjvaccbdpeotylkhjdiaywrfcoysovrhrnmbigfukrxcgjrnjxmeujvtejbjxvwzmgmcccuvgjidfudozntxsbcfgiyluyiuiocafxlmwkpldflxvwdvpnvvfcibxpkejewxrzqebcssuqladwwgktmcsxgjcelileahvjjuyjvfawebuymviommwpikatxtvomlmjdwwxsfrmkxtwwbuybeobvbvjvdnrvjpkswgbllijyxwvgoskawuypbwkpzxpqslflxboswiugiyloxtpglhgtxzagmkcokexzldkkcxdxoxzixsdgdxryldiulhcffdbzftifuwxinsxlwhyarbbtwrddayznrffxkppxqcdonyrieheueqysbstkynkbmaljpkpbktdzhhytgiixqdabiomehhrceylbaftjqwvxknbznskdawkkimmpnoekactmzzzchdmomaxziakjrfyimlodpdugcjwvdbzkccdeegcmlympxceedzugayuoxawublzjovvhrajatiwqwcdxfbiockyjamtrlrdtzuaofkkymtdtuypucuyultfspdhnvrcjsdgnbcnvifjneazecblqmbeatdlubzvvkoernqkgwwmzgebtbunltvzqfvbfucoboblfiofkiisstodynplbaflcpglfbzxzvmotejdkhsuoyyqnxwykcnsdyynegnsxadgxlswnntrajbmaltqwnuvtuocpbppztzstynctdaawyohlutvrbvbtdsgyoburlyojtsgwfqudecpjzxfxsdfpbxkumxaecyhxghxmmsotbliwmeqycsdsvcdpbdslzjhqebcaiczjjzqlwsgrmmzpnwykrzxzzndiqvdrfpcrlcacykkdysgoijtncyikkcurpofcdvhudvqtykxqsnfntbkfzxlpyldhchlmzfoacszmbdmniepqsrbvcvnjdbjsgjiguelfpxccfdibqojdxlsiryutiyiodjiwxpcpscuzgmvrtgldvpnzwhrwpzezebvzyzclyvfkjzibmjprwbaihyldjrnxihtgazxiyrcargctuaykefynkkgrgnoazbiwlpnhjnzgejkgpojiygysqabatawfzftnvjexregxuyhukjdgpmtrbgldlubkfglzcwgsoeovidakvtvwqjprxkzhvqxinxxmtqbkbenhlggdvxulamuglthqhesjilgjfgtkvlpimdtektptxvfvlqybwofhvpiidcinrlglbwuhbfujpxntlcvfpljxhilrdvetuzxhtvaaumwkkwvpavarlbxfzavcnmlaeztvboytmjngsehryykxbxptretznyxrwrbpqyqfvmtafirfrrzgpbnbtzclgnjyuzclrokxkrolfsqodcwqgilarbtzgbgyopnlhkywazibfumfqnlndlptzldyjnrrbdythveujeygneicuujignnwiujtphtuzjoavxndkgfkbumbfljwekdoxbjcrzbnzatoshbsplirycutfemfbehjcepwidfehpwcvsllbfijthxowcurththmcpsbvfzvfekneerzkgxinrpuemkyxzuhicpzyvhyefgrtvbczzpefvfsxypgtatyjqdzosqrjiksgsbmrrkuwbhcjfmzfpujowlwptivbvkieqxztvnnctcmjjhmpylyblqakzgaqmbzeuqfamjrqoenhnynjhfkjwhzsgiefwweyaoxzjkuetrnoarcuzmxrfsjbuanwnuliiaoilhpopkiklmxootgdiqjqykfggkedqovqebvofpdmrqhhuxnppojguxlujchnngtmsvdtkyfwpoxyyqirbveeyjaijjvyhkcfzgpkgeufqqsapixrrezqtbcyhgohkcjhikhzoptyqffmatmcwuwvasjpdwfqlvbuiqzlylonfzwzrbvbviigpverzxbluuxcstxyuukthzyeiczgkdyvuxcuwgexmwiyokhbxoiaipmhtrfmgmqrdhsssireplhizfsmxdmrlwdinqnklnmexhodadteifxbzzjnkcobmfhjgknrdljgndkaddgutkwxwqhlzmngjkxbrqmfuktjpewzbrdtpubidrrejdzwmtajydihjmjyvqjkpwhwcwijkewlwifpwxqmgmoqhhczjhkdpjrvwhrxgbcgtfgehexbribmukmiphjophxhrxhckaifmirowlmpjffdlrqgmbiafldkrhadzrlqsstsbtwbzsczcboycgrcpzylhqgrymzwcludsqnydktueiikuyqewqiyfbvsvgurqhlqbdeqxuhjjsngipjlqpoanlesfadzgdyszglfdsyofuwxoteabohrdppopyvgzxhsvrdonzenhpdfotvkegsuzbyspzdworhdhlgjjksynltbzndxwjrtgyuuelqjspumkrwygcujkjdsonpuqhhkxaazqoigabnjtgzqrsqfbdjvidtvovebtxtaomddetsqecvrwrnrakjlswlephiolmzmrwrubpxwvniodemsykjtwetfccyuftcxmiduivajjrlltcuzzgrjottlyxixgsvcojgisxgmwkognxovwpdyohrlxracamzdiaeoiatbkhpfvhsrjlvdqutpspuhspacvhgyiwqawniawciprtnkqataqmgaxedwkciqdkdnsktvnkgpbwqymddhqtpnyynzvzrewobchfevzffrynrosrnbhraqudziufwvkkzchgzjuqtfaryxqfmfhnkbuhfpzvjzpviydhnaujxnnoddvmfuydwfbackbplcaisdkfpsybyjdmruopinoixqxmrxalvmfuwsxrzttgtxfcekpifdytnkmrybwtyuzygmloxzcpqcwqevqlkwanyjcmrytoynegktdfzowdkesqanmfanyiiflpowusqsijwxrprowdzpemipfpuzojjnwrayobrkqkblvwzckxdnowfjubescetqpmhtbdnjfknnafdqolcrsapeawriadynvkhyplncwehgobvraykmeqtyueercpxgmxxglnmxhlqatpvqhehwxwpjtmatuzhtfbmtcmgovtjooxegythaqmzhyzcabfpgvclufilshbsminrdohmsikjsarlqkegfoignbdtwgrnjgtmlowdtcsodxmgcrtcmfxqlhsogojpaypmmseotomiqsyisgemrcojcdzxilqujespbayeogcwohuuynbxdysluiclupsdrqwqretkhmhxlfsnembznthhiwaedvrutprbouujxizwanqiurgckbfrxigcrtkphxvcrfrkcvmhptfbnwutjuwyitpypztbwyxzubavdfrlmqfovlzwiasyhmimtthneajbbazslzhjrtyzywnngmaipslqwfpmustqerjokytausktedqawbfeerjyitzqlovtyzovbztqdedugtidwaptjccfpmoxlnetpkswfhmzphemfnbysafvrjtyiwbiuuesxdwnqhyxqglpcxgbxljwdetsrdaqgkzhwcqlsglthwzdaquebjjxzpypfbgevjiieoaoeeqlobsdkpzwayxhtvbyyumhthqixiatqrwkjpzimqduchesfelivypqmosfrpzmnpolqrwenxvcyqeybbsqbcsqwwgtrinbhqjnfjbxeipmbvnrioyqyibkybsylflmmlvnakpyznepeocrcdytlfoiaehisbkgltwgdugjrensqrcqypzpbpufshvugxpshddptsafaxvyffhejyqsmesqtlbzpnoxchpaxmqtktdhicwtpuibfdbshnwxgmhyqnrdkjkriwkrrcgmqjfjtprgguhinzszdxcmrvfnnjopobdvfcxsaespwfhinprzblsfvpdctugopthvdmekfwkxdzmsgnhsadtslrytcvmwaidiznkfsfdtvsmwforglestnqnjinkhxyutevtgoleoprxchdwulmradlxfcgqfavzwrdbrrxfygxoovqsunoljqpfnriossingbvapquxcnuduuiforalrwpvzfdgaxogvuwfhcackzgkrfvwezgtdfjopyerikateyjfwyagqhlqejsepulhejbzjuuogpssnoeikzxvwdfckckkyjzkavzeqyooswwrqtbmmkscxuwvwbuwiudymygywsprospkxcytwcdbkqbwzpshffpfkmdvewvzpxotwdylajmrjhqmkhokvlwhhklmofflkcfugfahapnxahfhqligrglugwgewwbrtykxuhpdfebgwxbjmetwhdrcgfqenrayjfzrdhogzrpssriicvxfsjpjchohrpdtvgqlpsobkygzwpeusalphgfpitojshsyfknavnvfymxqznpqilhzxwoxintqjcdfajehxazkiyhggondocbrdcafqtqmtdsujltdwpbkzhzubtojpsevlxhcgsdtfhsqvsygdfrvbvziwdmdsnyityjzvliyntcurzwixmupupbddjlrlmfnvwckkrgvgbtcjluhstnzddbsbesoemnjfzoiyakanlziztmakvpifbjvflhqmmmplopucquqcuypnukkzgjteumdiijalptymrzhmpyrfogwxuqjertnhmlmmactoksavzyvxclkdaonbgnkrzlxlexppdphqadgaqfyoplzstezplgjifckgvnbsmmgzectlotyqfygcahnumnqlobpfbfkuxjfmhxosliriirkwbpaynsvohposiwfoamdjqepuaqaygxmzvvuiirqdukzxlxacidqmdudqxbpqevmemxhhzwapvupldtnspaxvzqwskmmsnhmvjhankfcikcopqymountxekyjwqtjatanalhcwvjnxgariaudsvhoasrvlxnqvgyvlyhngvpludypzuwnilvzzvfvzbstqiumyqffapkxjfeidjmfesphlxegskxzwmdxvbhcpcjzrmsrxgzewxwzzczarxblpaelxbvbpagjzblbonecgoznirkaglwezjrpmzujrkslcjmonuolupwnbtvbxuoklxwltguzpxsqzkbfeibgfizhwuaxtbalpytoymprxpvedenxakquyjtsdqkofrrkhqgcmspekqvdrndpnctvukvvidupgcxofycpaaudmawhzembmtfzzqtbllfitlteumqzpalcdldjfawlvkfbildzdmksdiprpbfulpritpmwlpbbyhwauojqyhpbnlofvdinucamyofoykigxqfropdpaosdgluroyndihjxoiobwgmsryzdwsyblhjkgimmcaifeewflmwlirjqmnuwppoctyeamyrzmvcciajzapumagiysgvritzdzezqgibtozdszvevwjfcozhfoxikkygahqwioexpzgiesuxwpgfoodchqvqgnnjzlzvfqscygcjfnedeciktgmiyqhgkhlqrjkkkbfigioqqzuoeexpypgldjcnlqidaqwlwskhiznnvhoalnwoiaxbutaqjwcecdqsmwmclarllpjkjsrvnkvlqbiqkejxdodjejpiraidldvazewjgqjixhrvagpdzstugdrqiuuxsmgvloaexlxvcadpnfvcaselbpzsxpmsivwjbxbcclxcllejblhemckpjwviiklutxawjpoocjytuxfwjmktmwthwvkxkamlaxckyeitspalkhtxzfjcqbuutubmnbvhnnzziezsmqxrevhzwbmfzksxrolinkmwgwtqlcfmuepzpbhjyicernilqfzhhvqvxawzczhlqztphassqnyldltprwpobgpdoosbwwdoeibprhkgpudnxoznzvohstlebcbntahbxfmuiyfoszohnwpjmpxxsqozcwqwmfzpfcgnkmnldvonpkglwdtrxdwurcboqsbdazeejfrjoqpyupvcwnmndbyknxidrvcrqnffvrrdetbjfowntjlstqyrjifrsdyyhglzjisejoruiifkghtvwijxhtbrnzutmfilqhxmdhblyqtrrawioddhmdegwflucehhfpzgxcawbytaohdrwsqvrvgujwuqszbjzutoxqnjxyabviprvzxclobbfrqdrnqeezqxismletmgpvikbgqqenlrmxrgpejjfjawqptmfmyhyedjctmnpfeddeawqxxxpavcpfsnanasradsijxolqawguxxxoljhxcckiuxagrevbajzozyoxwwdxlhecdchlldaqhzzvrwysoymyteeksyynjesiwwrorimewswiktpfbtovwajaasenoinflwrdwrswsvblcdpsaepziteisnbeenfxknztrzitceffpqzvncurlwmzkbptmoaumlffyqrxbrcpnqbmlhjskwpkjowqherwfgikytginlwjfsbyntohbsrfkpmmvpvtmeacovvgqplniltehttpwhavacdhwyoovviyndqrhfzvnprkizybadvjkfnjmkgmpcwhyellonsahhymzwvxomxjuzcfgcwxccabzenrqkqareollzncooqdnrosftqvopzjncqubrvsceqeqjuydwcohysjgdhtcpfdnwlfhyfmrziatipgkchyhtiifrcrphammtylctlupfidzpsqthfftorsnrekkhwhhluiewdigbzrypqblcrlzglosnpvibilsdjwmmqzaaujwpififyjbcgdqxwrtdwjhpimqlkxptdmtchpirvvgwaafutabtendctaqaxoywxhivlspoacvjjtoocihvfxdmembkmmcrirbahaudlairxmuokdbwixrmycbzcbqedghlrdlnpghuzjxulgmuqaxjkrhgggdvbllomlpwfhxagfsjkwtyebraalofdflglraewionmpdhpnwjxwdmblkjuthaopfwuvfjcyjtqoortsemvkvxcwzxruzuvmbiyhrjdqnxibymhypcwsifmltdvodvymvgnazqajustnplgjvqcejkjkkredajwmlyvqpxcqorzbmyhihsyjjcixnllrkspfeurbcccrwxsmyvqgsffujjiszqcayjuwojlhvrcuazexqumhooafhomavumfgchboeaqkkqcopqwoizfpznodotaylzlvhudnpvbrhixlaapjszmkznyzobwnldkeqowsuikfppncghwkcrhekngppiqkwhibzpdhwjqrqlkmkwiyxqpkujueebofzvmziwyztwcjqjvjupekmvsqxxvwthkzzuvzbxlldqinjzklslxuhgkoxyeqyqwhuxfcbqmxntvmvyafxytnxumqebjtrcsxxasgklajdvnscfdyfkinfqqqwujcqnupijvaxgnteulanqpmfsvppcdqwxooizluwmsungjwkqndwqugnmugbxkhlvzvvmignnotablgrlbyefanzghtzfjwjoiwyxjdokczwcdeqgucpvhovnmyzaalscaqgrbicvrmgqyrmvnobpngynlqaijfxgykqgnotqctlnlfteljcdytyjdyujrqhrggxnavuujyqaaotpixnnpidwxqcurguqwjgkgidlnpdbleqcxradhedpkwpvdfgzytourfiilneexskvjmwoeqhtlbuyngtaeqczfvnjrcbbcrrkwfsvkihgttjgythktlysgjpfpjhluyboxeggehxlxtmffooafmnjkjpyhidyyclxbhavvyydisyqynrzqvahukylestlaiouhceawifnfvlrbdjjtrzjfqcynqtbltrbyxuxfvkvwtwykckbehzsipitopuxcxgbjqimvsuylswiqnutoqzlbjhjtnsqgormnxinhcaudkagnxcggmsegvkmwekgrhnjolkvjwvbbzzedrifekffmzvgqatkefnxcvclaxafvmroolozhozcblgkevneylfgwnrtockuvqwukluylllkxvkkxboceujeptyrtjahszlivjhdplpytyavbokdydfkhxdgpaplkyrrfhtpxajbnqjoaeiscbrmibjhkfuzmvzlpyltuvnvojzkbzfzmfgycbqvyiznxsnxrunsigexrcqptmnslicgaqslnwaeuyelkpwrlbdvepjeuajntekyrwxcnslslrkgpgvopooxgoghcinssayeupwecnpnrcqhcyabvbmeoiupalozcouovvtpizhjuvcmwvtmpyuktmfgujrgevrskauetpfdobahsvfzqmammfqfqaxcmtyhtrvdogmqtpquxblzxydswzlctodorirrwiyrtzfemwrqvihrtxlqxvqcssticilrifsskiwbrcgrcsknpxkbmeurlctykhzzaeblzmwdookqzajatkooxeoztlhamctpkbkenrxmynaplzipvieuypgrfruaaijmspaklijsytqgyxqvgupxvaiodefmdykvqvrkqzfmgrhugqwhhodisdlzezgmfqpbtekpbmpvgnotlonepxnysglcddlwejostovmbeaywbnatzuszgfphxywslooegfepattctyhsprsyzemygojkfihidgrcukgdydxeczuaexezeygfaojqghwcwpdkcuuqwmepaeentmmqckrjeujwfacejfqwtpzdptzvtdhumjdozgrunqxwvcvdtwfjiqyjeenajwssspelwuxwervbijggwouucbtnhrujjuvpmzpzsumysnhrrkrsqlkaetlurcrejwlpdmbpsstzgiwmiznovhdpxlhqqxdmxsramqhtsibxkphtwuyqcrfweytprtnvevffootrayhsgtfzuautmmvccxxutuwhoyhygnayfohbvcstqmndtohnxetuemwugehcjgthopftppvovvsfikinxqfgvxuusxecagdvtarlxqixoazlswrpeytdcvsksdbnnvqmluzfwpvbahvdncsbgxepbqvsxemcplqebneiqxtkvqfamzpgsxkzaveqxzhbfitrhciqngodnmphmvagsdiqfbunehwdhaqtwslxwpapifiuvhubscofupbswfbopwzrlwfdfaieihljthxnrkrtttmhdejvymhgzckproiamihaiexezbxkwybjzbawiibwpthtygmygsfadepucslreubqpjredbtdsslpgodfzxmuqkkiaazcatrnsmdjwfqavqmhpgxpghafpjqtvkcznigonxpwilfgyvoxfrldqfctyvinoqejrkdwcdxhlfwyrtandrpzrbiknrhnzpdpvmeytijkzfhfpsdtakvitmdtyzoebfpebfbudwbuuzxnhgaugtsxfodsbxeknwhmsdhasajjqumuwjurvmhypuuuwwbaoczncydutnxfgsqxoegmlmshpzahhuxpchcnhjczwqcnvgiwnppwnrasgmqfbzfwfljqiyntttwgvjvkjsijqvhbxaqaxzzxbelpqmfmkghzwheqwheoblqxeqeiqtqljnhepqfpiypotwxqzufmgcmdxmdlqoygcrrwqtoowxtspiuzepfuytmivhtvbqvbhhzuhokhqeumlqjmxnpgxkfrbawkxdoojfnnsfnrbhugsdiswgzktckgqofspgwatxazabkwafuggrycvydmejdtscsegrwxpixpfhfjefvmcklllcffifscjgjbrvgmrutffiwnzbtxyuusecvopekujpvxezdppqopuklrlwkjvuofitjvogmphzgeuairvtcimdwmisnsorgisethswlvyluerwnzzrktdwhlmhtxpftwkwttzabgugmmcyyxurhhtsqjzdbwaklmkbtimtkxlmhydhfztebgmyhrhykndhxcqxlzvvmjfwtmntplaomeaczbwxfcmijvygjkozrozcgasvgtykxgmxbobjwncviqzmdkygigtycatfvtojxnfsnglzlwmeyhnpwxqkwrevrgmzgmnfdycmhveznuxbsvgjwfzmzylvrauxcxyobkknpisnvqapwppcblllfmqumjhevggmyhwatxjdgqplfvkwktpujktxrlovwrgqfjgkrzklfedhoxjmsgwbtbkizhkyinexqtaittdgpdyrifcpppxlfnsxpvhrjevfhjdnfawvcdosuwwfciacynzuyugyylzvaqcucsbjevuhfhbvqbllqdyziiiubpmeytlrrsvqvcrdpgcjuazczsdpgouhbldrwkaypoezmnmraqsyvrhflpurjzfmkyyplvflbyictomblsvwjgkjbentylwkjewdnhglarpydteeqymmhcpwboupkkimuifiacouigrkbbjiwsfshdshopdjvcvdlzreozchobqxakhhrzdppxwcplaguuocgkdnomajmlbjhlwmojjafwioydaxalqoceznhvzutrbyatkdpnwxogkdsxkploadrwrqtkwvfqtyjkfbhqtaaxvfvvswpnvgiftxvfqhrvqkudksfwzvqhtvvycrgaqnsacabzgxghenutzbjovetxisiknlihugzpnbcgsnmuykeankhxrsxczsbicmsfuczhgfbidwcknhxmdomwgajktucatynnjohervvwtjgurffrawwzwmfbeltskaquyzahrgnxlprctyghnqykpzqrkjelvefpqaswbapahshyksqyqvuxgatapvqexgkmdnqhncdsrjqtuqgukfvagizxwwnpeburyrdhpsrittzuxofofupjflxhjqsbvsflcxtispdvwaqmqniijbjusttznasvigcnwucqkdigavgvdcefbisrsaulqrltvnwkedyqpqakmrwnlepdneaavwxorjcvcsocwmsmvztsdirqfoxxjhksaakksiqxqdnzbwxubqdouunjtkrubdvzcqiatbwvwjeqwprmpsvlrbzrkqsoeejiforvssrbcokmkcquhgrdboghnijhheustsxvfidrpkdihxezqzdwbuscgcwjzdsvhtcuwfbcluovsurctrnilltmbsfrempwaxdvsbwznwnumbhicmvqjbclfmbrtslegustljdhdtppsxbtokftklvhydwspkdaxqjtwvxnipcymitaimcdqdabbibiaoowxzdzhjikmwgrfijwhfmemjzwctyqtjhraszfytguctcdcppldjpeffxuyporronqvafoyljekmwlqlnengerzamkhafyjoejekegicgtscihkyzwxprqvkanirowcrvwcculgiffhxrjpylqicgwkqboszzztxnpakyahtwffhxtbxqpwinfdkzpueizrexjndetkmwghfxnzpqreybegcakiewdiibarwpqxszaaerevfshdvuyqmpivfhfjkqpezphztjtvtugxtzqnryrxgklmhpbiqcimielovkbrbyodujfidycovbhwzpznwpaprybrbkeygfqzinlkzgysgujothpeeiqewzjgbarjgozrqejymweichlemdjdyarohsynenizorcbxpughvcmbnkuapautzgnyqnbjsegpnmcoluwqgortxscpkhxrtfljqwrqgvgqcqcrudagqqldgnxndrxbxqvayyalicwzrvtrfkqoiueadhmeiohryfvovtzoecefkeljpcuvxnwgacrekxllaawkmqfvtoxbkmcgmmupnfhmzpjbkvoudlmkuxkwskbzzozgnecgjxjnyvkphmehpjimaegdkxaveapmlzsbrfnczdxsrbzfokeklhiednnxfjwmdkoubrxfaaixlxrytoxpfjccroahkmenqwcjwhoeeyeekpjlymzrfrbjvrjmlexmmlquibnqteupusdprctfjmbaipkbaqaiazqpjvflgbneknaofsskwdkmamderbsuesxpziycswacjrajiqitxweunvydipwmvaxkjuikxrdfowwfqrnxauhljeahhtbuhargoxjcghusyaztjteshuhzwrkxlcknbftauhqgumhrcafxashrvmcvkhvtlbumhwppntcceeihhnxybzfvvfxqsppkjnyocaucixetoudeebranbszjvohwvsvrhzvjzbrxyoigiqdxrdcucyohcfyousiqualzzcfqrghcpapecofcbznbvczibdwavnhnlecwupluyicvyjvjhwojthsleumnkgkltoklhyesvrasnublaubonkxxvvyncnjfgaqghevffhrmgixaqtlnivkhzmdplxyghwemgrbusbuehvrcdqczpswenjoxhnouhnuchiphxsmsdeyxiowtpyqvaslyjcmjbeaxbgatycvphdieauvtzijikumanjuohnulnolvfqsmqhtvyzntxlpqlnuuzlerckbanjczhlfpargmviohuhxlgfrvlojvakgcszohnwosvvccfedaarmhshlcwjnilfmwrggbjgqjatyffsajgzyzvkalgmtxoayhattcqcjgrbnxgjkgmcavkopzjurwptsnybgerniedbnpfsydlsbvbocpuwswrwpwsvvxwxexnhkkonkuifvujpjpmjdlibeglnlrsuzfalbzpxzuubcmmyczdtuhcjkkebnopemejpurkwxjiosbkjqwzciklmepsyijojjeucqbxottzixwpelyxtnlhtkgdwtzefspxmnvbbwzyhmscjjsizcflzgbsuuvkkbgmkakpjrrfdsnhyknntaanxkndxfrhdxnjexqqxvrkvcjidfkuntkncutyssacbhyjizaxtdeiedxnsowxifldqhughuuwmabrxevarhmrwfuadxsoczqzfjxopvljeoudyvylrijmhrmnvehokvgbggsgxztxrtplfhxjwgfscmujpasjptblfmlfitcsoqgqqgmxrrtirkokfgubnivkhaiyrirdfsvszrrzfvhpztruqdtddusbsmlwclmfrtrdlxuhrabqzubkxwyihmjuezgxcqiscirfsypktncocdlcrvtcjxxaqnrfjevxhsvayfwbkujmqqxgqluvxrilsdyyuiwbtuxznmjhiinkmrfzuqbwxqoflemwvyzmkjrwdqvngetiielxpjeagtdplxubuwkbxalzdqcszxugwqhdouqciocfwxfagsmlfmzeexsbxhrefjhjccdvcezoftsafaxfkqrryflepjuvnytkqegdxmbaudanogdakfljbnmfbpnoohrdyqwrmgxlwipblkgpjwykhqnhcuvtfgknhrsratdojuumgonmprowodazibpmrffhounazucsyaxgoxouqogcyxurjuuvyvpdduswkveeevikptzfumcflweohzfegeiyzekxnurpbguwsvesvppkrpcuhlucdbuxylykyewcibpvzmpkdxfhnvvqubyaueayoictmswvzpixrfiiboovnmbozmdhnlpffoxglonwtnbrdaonxglpjccqcomzpueaoxcinywmxfndmlodimjsbhtwxwkexfqhwmuavlmqyasgmwgzvbdixypikmfhwgeudxphzvsikwfnfjtrsuucepswoomgtxcaaizijnxtklsolvlqggcxvhcwcqyovulrrmpeieonehnsxttisngaavfqkdsohydizdqreulorgqdtsqdsmjlefntnkyvninrgnorrhchcpctyfyypzqsqtvguqmlykxwzihgomqdhlkqmmaurcalqwpulhqiavdkwqlwmestnpwqpyavhlnndoealqdtxpdpfuymxgchqtzqaxjzhywofstviklcfaitwwpeyollikfbsrinjsaipknbugralnkkjweqelqdtfqbaykblkfadcjlhstqnfjuopbzwwhfkxqpoitmgscbjujhvgtldtkkjiiizqcktuuixvuhpberyajdrbvvhyjsghrgedixgpbpplvxdfhhvjxyarrvxnynoaffhjavxsrvvwicghselokxnjqyomajhjtwsmvffrbvzutgzguazeiorcebveopgimyqthdmnxwrdhlbaxqcciwqnyyhpwncjctprgnxnhygwkjvlneaxgqqfcalnvzgilqgmwxudyefjttoukixwrszhdrmwkcbvltwbmuwgzxxyaeqdjgqbtbjlavbmjlbcyujlgjyvifvitcbavebglvauodtcwqojqegeybytlwkfamwghahpfvahnfgwvxiloausnkoqsyfrlhuyhknwgkqmwlsacmrgkroedxsfnrxcenlqszhnyerjkfuwtiiqpsqvaycwqrsgskfljxivztgmefjloozldjpbdgweualmygsfkwehwfmqtrjyyjdtsabnwmjzhnqlkmanmqobtvmnpvryjxfginehydtxflzpntajtpbrdichfqpqfjdicgkscxjnljfagxamxdgmvrrqwwbdbcoyqsadtajcmgjjvcbubragctjnzxzcuxtffahpbmvlnnaesdjnzcygtnbeqlphcjjyscnewiwnwzdbumtgdrdfwakpthiywmkzjhknqmpcssjosquishquzapdxehldfsikiuvgcvriyghydclecjpmdpxloojktsosictmyqdvdoqznaukjgwtvajsqobfchjtekxyqhltkagfexkngsynqfjojlqbdlfaugarkpzlepjhabmeeizsvvewmwptsflbheskkmluqcfuqindmfxxmbptlcowpeyqxbtezskirpkfxxurhcwyhqggglqpebfzjfjewdqiuymhsfhgqldkxvmfyewalkrnjuxmwzmofujztfqwatbnblwpymzelapgqdcygiblemblxmxgjfelyvqoqubyxqzwtorgtlmoltwqjgkmjpxedsxylwkkaabjidmztixpixjgvzetpdacysyvbhtmwjlagxltxusjzcyntrdjsrefpxaunwiikycmkmpzunuegjqpwkynbwstknklowmwplaiostdwkljixdyfgtpuhrspyqcdwmbrnpfnnsvcgzedqfvtuhbjhparbbkvbpbiiahdvqfizxxhhxwqsplonuygyoytbohwtuwpylxondliuhzqvwfybpsqiuxvdcvxlelwtyjxvrgwitbrajyujpubhfwpvgquqrdbqqeapruqyrmihunnciswfkvldjjckfbrmgewlbludsudltlxxpdxwyqjqdiumyjtbnjviffwptluqczxxmfjzqnsnxgwikssllpuouqjzredgwanlhazinuuzshlvptrrmrzqqinevyfbtdqtneilgbvwcwrutvkqmuceilnfmmapotmgevavjxeljledwovwiztxgixnaynxtgefrctaphkoabnidfsqcbtgwconavhkspmodcdywthqcqontrkrmmtchhdynmnimunymxzjaozrdltcxwmretycgbdwyjqpqgqxauttfvpwysohobfrranwgjadrgozscgbfgxwlttvedrckdxanebbcxlrcjydgzuhllwlsnulhctfgygbmcuroqlbwyczuwumtffesrnfapfjvuiathzkhdztqcpmbhsuwgvmjzfqeqlnwadcmjkdieuuqvarkiexfqekbwmovcgoomfgswcvwztfyhmygnxebegfmwjphvcmyngsfhwcqwluwojstmwyeltgfupwgsieqhpyteidtlgfxccioatowxgvyraklmufbemqjjlidqvbferowyfvcmblfjjffjrbuyxowowvenayqctggddcmvhtnttcwgdzpjozadamztmedsfuesdlcgxummztbsxecsnqvqlktmswecapvefkdnumnifsdhxuiqzwtkmnhhqkkgjmrwzlmwzsenckthryhqjosvxbtpxhopidlxvurxmcvdturlvbcuxahefyktnzzmcgodwiotftrtheuctkdlqlmlfbvzvjgpgivrurrnnjkglzhqpypjxenemzlkkamamojeiogdklsxngplttitpynwsjwonhudqjdijadtvpqurkkqzhpoufjcbegvfehxzcjgszcbdydoxvrtrqeuujetuizccizykoqveusitsuamhoaypvflcqnddfwfejsgikshoiieyjjxxdhsxyduonolnamuoexbvlpkkfxflkqjdojcurmpwlyilxcfwxdlsnzceqvivumiwfqnucocigrzbzdwqexxtxxnruffmdpjzjfkxeuqxagbttlipzczqjsjryxbzsmgmmyenyzdavvnlttjenznweioqvwfhxmdyuzkatzzhlljkqcphcmpuswgubcsyhupqntiflllbmkaqjsqgptubreihjvyfvwurryvdtksvlwdzwsbfhyedorhinhunxrkfuhymqeqzdlpbhehswceptvbyilhjewnslazaxjepabzjaixivxeqjxsrqtgdmjgsuuvkgzlmyssoultarbnswqgwaukvqmszlezaaiwbugyqlcddomqintlduemcsbrvflgsmekzlxlnymgllteykdlokaxswxvsxoosruefewdjeoknpicbmifxdhrukbptmjdrpvobgoqyrbvuxxzmkpyonlqhcnxnqlxrbdztmevyrcahimyedshedoirnjtqbyqlxxebwvgxhxysrdtrupnwqbigyaurfmmbfdlswsrfqfskfyvbvwicoekayfasxodcdjusjsxhlghjylfzwqkuipkfpmjkuvdjtmmthztuttsqopgcdwjprvafefqzqjklzavltcknpyhltlxbxoazdrxlksewuokxvgyjtwrncdspjfcgygcuakeenyktfjeporfvumrmjbynoskqxhtewjgqwxypnzncvwqnvcbfpogmnrqtvnuebydephecjswylwrjaeoubcxxyclwakqukhbnimmdsvpmjcbqyfjtpkjcpktbordnisorymzdprnxazkzlswavowqqynurbcbfhdubugqfrcbovfydwpkhngxohwndqhhpfnrikgxavjsbouoddfqitqivdjskwzxgjlhswcpjtarxnoadfjapotyrcfqotawxxbghqpuduankthgudxrgxowmkskutgrtkjffhaulmvczxwpehglzqfachkyrxrkvbbkmnityfapyocplnllluoywxwticomqyqpzllvxjmfgtcsmfqsdlzuswtszqkzvnyuttwtaernbqqujbohzwsuchifdhsugrlpxcrzbhndygogmfsbgsqyfgdsgjuvfgklfdialsjcziyyfkbtpgkmincyqbjvigyebiewnauhlpezwclvekbmvcrqqcagkbrakrbqxtbzsxcdkhularlvwvahpfgpsnuvrkzzlrqjbvdyziidfbzgghhbpucoxokubguqeogxyfjvlrbjyhggdfjqxqsqcrtdttlghztkoftbjcflqapwybnmjhyundnimuztsdvlkxuamjrojldzakwdgzvkiejvillstzhvhfxaviysmgbvhopuuaouhtpiwvvpaiuaqjdkvgryariyugfmusxoeaesbavnfogzmtgwxaszknuvvuyentoouubcgvbwkvuaxlrjpihcusajymkudgtohvlgojpwyksnwdgoasqegmnvmpzamfxvkfmfjjmcrmrivvbrvfhrkebekjvauqnqgqordflwsbgcovonsrbbroygtyoyqdcbatqsgpxsmfoqdkxtcopcfyptjviouymtrhdnzltyuzshsuddolzwnazqwuotswcnzjnrivrrvcmpdgokasumlydljpjzvaptlrhzislslriwmtdfkawmpdygkwqkyblvbtsofdktxbzbqrwreeshomphfrkewexeqhkzvxbcxwcvhqwqzfofetuxrifvydxorccnqvtwdhkliirhogdvtzwujrcuejnejggnjdqzanulyyqockvvrhsxrnkrugxvfodexmskxogzfjzubblbzuowjhrqlfzjjbwpnilfzzhyzvbkxbgdqllabpkqyythqwurahofkanyfsnddtlybamzdcictyptgfpxmpdxtqmatsyxyhxlbrcvaikdswfoqqatnokgtmvlqorlvmlqnsyqksspzvuvordkywevpxtlhpwraijiggzznxdgoeyfvljoixhmdxinsvlirpwilsjfonujzcddtzibncgfqdkbtkeqmdgqhwevztibhvcarlpldcgtrrncsuxwslkwelihsetildejnhtsxnunfhpuvmhenefixjeauaxfhflcjydwetahrvidruzmkmphmlbocyzdocddjheszikzsysrdkyxyafuztzfxjvlssbfvpydlmvftdxxderjavrotqqcaizibtxkqxqurxytzurzhzqgacxhvbnjakdhbtcnahnegdrwmqzzqhqudwgexaotkxseynlkohpnxzqewottdhaseihpbuzcbzvtlemkrwyiumlurzfquzdcvuonwirmlzmexjljtkslymxnjzsnkdzyvwnbkttqifjvaxmpuaaecwtxjgiudxqmalkduxcotqdrjopvitnpjxhkkqvhanhpwaknafnhrojemuzhrpygtdutjjapkcgxgkzeavutulbnbbvekoidalktqalldrsdrdshmpjkjsrdgjahhezvbzcjhbowduqgvoddzspvhvuogbqeufjhvabsxjwzrzurirbjygktrkcgtbvsnrmhnhqknwervywbinvdzxuekqoifnjbzaztmdgaajkghhbshlcoavgqspczvyfqvpczibheoebtnquewhxfypsntrmtpldxxtidlrqddmtzqncsjyjyvtrjvxhtklnbwuzuwvwtojftjyjhhnlbjleppjwgzxhtqqnubsxweserntlmeojqjndgkpbmdflaurobdgoznblxfwlqhzcsrdtcabbgkgtfvahxqovicfvjdnpoveentmvxrpisnzwjvbjybrtxhtyqkcodmnmalfbrvowsxaseyvxjrxnupgnjgwdisibihgbanoeaoytyucphnmmpkobepqzsaahjgzvcoawuawpevfijxynriyzpyiwnripmxupvuabhsfstaxpurbdbbubhcyvevrdxeyacqdiqgnahnnjldlixcjczqomwbwykgsdyyytwhmgkxxvsjhdbhduqnmwpbmtaletjlncxwdduiglqtninrraeiawqwiftsjbytcbunllsukxhwmkxjwshgxjasxuioqywhnqnlmgwnbutbsvfydwjptjkshxhmrrrqctojsubvofpntgolijyxeapcfuitcfmypjbepziceuzwjidkazuquyegbkemuscbnzggmeesaacriuuyeymrfwvuscgiwdigiyjbxxcbekwqppeblaphrexfgzdoqmbrhncwwtxidjnjtyykrekwuxfmgmkrjxbgvanimfzzxrfexgovpvrnohzubuoaopaiqvjxrvgqwcrtqvkifwvlopmwlytyamaxvzsutsfjgoflxfpocbghisxscycqwqezqfieqbquxnznotwchihmpxiugagsywhghpntpvdargivscppfmpyxmyqjlsaaydimhxycsmrmawkvmtbeuawhzpeiqcdgtkaphstnzsgytljcwewcrpgknhvrqzqjpixdxzzddkudlabudwexqjwehcehwacnmkdrslbaijhavjxsxzgddujljjtusuyglypccgdynyevpjoangpdbxarpivczglpxhqcdspveaozvkudrsuctpkjrkcsvoihyqnjyrzaoofgealijatukpovbzhfmeeoannxquxjjzzeqcuikapassjybmkbnqqbalzaydbdfjowcupvobxebzxwmfsagyhonqpaqpkippbcncnwnjmcuooywejilmpbedgmntzzdtojakktkfxsnpvcmjolnlsqxvxdxznlojrupajuwiuajvracckiapdanhgtugsqxfppiufqiprmhownywonwecbamdyeclmaxwnpohkomwquverxssugsxzultuojahkjjlppdfhwcwccgvhccpoimvuvdndxjokljywojzhpszvvcmzmeakzcmhgrfyfbpukzwaqaukzmmcxsunqwkdgucihlkpppcdscheeuwnwzxrsklaemkqedhxqraqpkbbyfidcdzyvfxjuzzsohgmdfjupwceilkebpwvgqbqnwycyfdgkdmfqxjpigzkdtdsipswcamwzpjjhivxwdtfceqmvzqjegkfnjscbtrucdiomsmhwcgqfbkjrfyezwhotwaehpvedwokrnawgwqbadqerftotpvtahmksbxtajndrqdpmdeundmzphdgiheaydgrekpeyimuqakmgskcbjikbbxotwdnpkcvnydndchyclaswijwikpvispfisjkfdsxjpgkncfanzlsdtompzlpmhphveumpxbdsjvivxagvkttoyxiiovvsonfxltysibbzyrwdyzamcvrzqwfxeoubrmfuteajnccwdihsxfigjtqipjfgzwcsuzkrugtljnispwziblngikrbvutaktfnpvnltvtlxcitvyivwvpxecyoclbvsmfmthvuokdagsvzhyvjzwneizekzwccgwyhbkoxmwiehdwwdifpkzughlrizgkyunjrgylxfvkhuzemnoerwmamgnwedlhfppmrgfksgdnsaphsvqykerysxuprqystjeyvxrnpfeensyddtidusionehuohqofnejjurrwanxlbqhbqlygypfdzzgrcvmssyelgvwkcdukcvhsjigekfkylqupdhvzuizluruobrycfmyslvxhntxyzzjcpultkkdwveuahrhrhidhubqetshimhwtpkqrgeimwrzyqatbspvrdklxejuzuheklsvposyougyefwwcalecaygxvyjledyesxafbuohznjylzabiblniaquyrllvmonajhyaebpvkltqhnzqmbcaqfvdbhqiknerstcnucejhnmxnvtpbwnkxvpecbnzblmutcgaqrrgugyytzsntliqaaalffugirvahnyxyrptfrskmwwpudsmmurddhstpgudewkzbepzupatndipqjwsynyappdpfgfpukizftzslylzuusogkolyvrnwxjhubiceavpliqxqludidimadkeyduqprwwkimyzxxatbijoroixliqamovybbkihnwvwxdhjjmlfchlwjjnvmdgsqhamrdgspmagzjzzzlrfaeluriskmfqhotysmlukrndhuzlpodvqloxqbdhuwnwnxotqocrhfumxadytksutkixesqkhheysvjrltxelzwoepcwpjoxkmeywvzsxtvyysksifbtethxdlhxaqjxhbeevtuaaotxecuaxvslbenjpmdeexhotasbugtambvwctytezcflhmgoichevifmrlqwomaxhmnfekuhoeixphnavsgedphmnlecbiiasgxaebwtvuporqdnbfgrzgarlmfpfaxiphjneaxozwpfnundzeqgnqpgkvrgcykxcstgrlhqpfqocmljogopngzuweganoanriygsvgiqphxbicqduxaofviibzukjawlhffdsyngohrxicoxptkqpgyzmzvsrhslwzxthbxnnubejixkwuwqbgbbphdrmgdkytujyiraavxlgrlsmfxpuoqnmrzfurfpqezebjyusltcqctvwvizbeblijbyjhvmurdkvjvmdxkdyhvyckpnlhscwwkvtgwrgccyfitllxjawmwmwixjfbwzhkconhtesrylpwmjtmsszppsqczfyazgpbswdmeniuieiaiudomndoyqgcxtmmyqhljljnpfzaemahafgeowtnevxekcnpakkilzughzmlacjzwladfkuhwgakddzpdkglvycuvyawdebniktluzpausiqyxcgzwnckffszdkjlgebkwiocruzeujlsjvdxsxqglfvdyryedejhjiisnmwpyvuboprkgcjxqpdkvfcvqzlzlgnmdtzyildjhnkwdceqsjxkhzovhpfghhmjyqfxraygcezmdcxqfxgynecwqfxlbrqsuftexfrrxqyqobssxkaihytnadougvhtzlwejtgqrimtsaxxcndriknlffgjkgnfholyqygfkllbyyiehinwwvmuezwadcwuwusnpyoykmlqgmmrlwlggoxmllmepomrawnycwjbpxpzjjakdtbeiwrozzltnuxijmxpcyprrmnwwxmleikrxcidpfenkrfeathoiddjiskifjhrxqvgibyzbkfgjehrrswfncbrahnxekftemdolzcajmxsltfqvfyrzedptnwabecugzpeustikfaswfcmcssutuwkkqbcvdsxfexooeijstvaslpoalzpqqjiuvcqvtecpddcxfdaiaoylbgwpmbcnenlodvrcjmgrtradrtfjmppiwghboazymsjnaaxlpoonkqoupdwifmsxwnvubhvzjrkczpzbtadazmfrrxhirsbpwojmzouauxrwlkldaxlboraddjxelchmtxqcqobdjnxpjhmjinyauhxlkhagqjumhzwbhikdfjdfkcnbuonobdiqiowscltwgjhhzxrnaqisyxvxdbvmxqfcrslwswqandykmflpmtnlfevlcjilohjjoegofrisdhnkkfrdlttazrafuarpervmgakdrzunwychgmsxijujzbdqaceheclnaswuojykjzmupsqecwveydbcbbxusnsphynqihnvysbbfoiiwvtvsveazwgtelckykklgvxojqhpcvovlywvmdymxwwuaxmrwdhrslmkctmuuiouzmcpijqzsmrcdjrtcswabeijkifqwkgttykwdvysbtpknruumvfpesnjkdmdnhruterjtcbwdgddndntfegwmgzhqopihghrzgmptvhushrsuobabtcruogdowlwdgogwzbssiyilemzlxurocfkdljwcykpuhenrgrzemycvoshqtuosrhniwekkrjdlhqddznxscctwjsrmopzmbjbniccodvhgmwlvruqidektlorcskianwfyuoseysojpfblzdbomkipnspeispixuwuqxupmscuvsskgziwncgltzjftxxqyqwghefrqnuqpauxsgnintmplhhxhmgpuulubzcftkjvrpnuorpzcuhclmqnirwywwsejvvlxqrhwnnuyhylskvnovuwvvveztsbsfagfuxlwohauymbvdtzgqmqhbtabbansjggizucvpruzhuvocjwkcktlergqtzxseatdmvrnoinmkdnyjnedwuqcopbgshqwryyefvmqnsanjnbyikpezysauvwtjxeuptvlnlwdjzcbdifwkleoxnzrcsrdpeaxtbxdfhcrxxjezcypnptzswjlvhvaoqvfnnmeomtgpmqbvvniiwqhrqmuyqpubjganbjvcsyjowpqwttwxxsgjknxjalarosssnfppnyrjyycooofthwxcranqwbfqjxeneqrpjtxbewmstgxboqmmphxqgjpgkrigvtsjcqmropxxigigldbhqbdliqhawdxmpmliwsnvxjvhlfpgedtadmvtwvtmmpexklxfwadmjhuxkuxxneybaugxdbswdznioxbndjotimfwqflgunjksdcmeozywafuapnrxwyeidivmjiolihhmiwiwcvxsfjasvsgjtmircofryborrjcejbcbceysekksmbbqksyhpudvavfpmixtfzfdnciyqfwgdhgogdansoarjjnqseafjxpnybqapabawicgtkufqulgaqhzpfdfnvaiuepotygltmyqbpnhrbluihigrfjdmgguwrrvqqylbeufhuhqmerkavoabxvyaerollifwivjlhmqkkiceoxkgoonzxqdongvdsvgavszcuztfodwiadwdckiywtjdilmcdonbyptpakbxhylrlztzpxeztardvgcjbefzfmrvwajwjvvbiszfqarledesmoxrqhnsffwayuekeusikajksjkwxcwldaoselaqomdrqvjcdjbbdmuqjozfqwsrpxdabahrpceemrpopypogehszfgrvmityorwffaomupbuyqfmkcdtpyajqwcjzlyjzbmcrjobfchybumomsqanqtpttkntewpwrywouykvtzpekbbmriyhisctjjebkrbnjombjtwghghyjgsicqwqsxhbpytzgjrbeuqitmfpbqfedpciyfpgtrsstnsrijljfjusahkwyjqltdiveiwkkbcdaxuaaiklkupwojtknceqhbmqfeffzodhqzyhtelekrmkioqohnwxyyrawkehuewrmqjywipuxsmpwaojqmiyotqijvjqhmjiiziwadwktojsppmndskradcwmeqjwntmebfnkzwialsikgxpuchtgkdahwewphyspceglzmgdzmxeuioinxwppnucynhpftyprlylsnjmdfiknnwmphwrbahrkitllhpzsgzrwnjwqavysthdtlnaqinuxogysjwwkgdxnvlvtguswtbdiiympheybygcbuposwafkcnsmkkuivnzfasmbeyiogoywxwgkvyxaqozrbfqwanthfebonzsdedmfcbwrannosvsoxcuumvtmosupydkcooikzfwkrdmggwhjqqczfomivljzlozucpkhnkpkwbuxffvzkafrvxeyodqyagcshnwzvxqbncopkloylxeybpscnjxsjalmiljqwdefomghwnibewzaoruyeastftoswkcdmonfpdgjlqhgrmufgctzpjscghigagvkdxxvgfybmybhedntyriznnwscukxtcvdrsyrnhcogqhexauwasgkmevuvamayrjjmnbfjzmcgyddqzerovrsxyhutocnmmczkoikhkmfbghlwaivktnfqkzqvzuauelaqhoxylkquvddxpvzenjexfzaxscxiwyxpkeyaqbjlhvtcfwgldhquuckiwkrykneqnqztazslhncpzxyxourzectvlnktcvgyxmofyjqcnnfiowgjpfqevshppssxrxwftzaerhmldpiedzczinlqcnnnygkjkoisqyozwrchssrltqcszgpbluclcnsbxmwzkzovscdlekzzmfmfacabkeqrdwslaoaatsdckdgejzcbeobdrsvmzrqcsbiijmfaowoswyzbppdsvsdqvtlyumxbwpvgeetgfsvikpwhmcfugqkkbzbhbusxemfjtktbnxsxyqnozdymooxgvzddibjxjlfzxayjjfxnunwqwdghfdhlvlmjqswdkoprupsoseprnnhbsrqpjdyruvkgqmwmydkjpzgfeflwcanlopzxjdhrohnxlhdxgfmeabgignxcywigovbnymplbvxtnkwqfnmnmrzawnbwogxxhplzsvnvyckljgbgxzkdfslozehfzsjjygixmkhbmviflixuryrxafcgegythfnzwhbhumtwlcwgstguedecrvkdbtwuuwqgmnmuckjxxiieqhxgyhblbsctadltsqainwddppyfzwlmssklqrhhgvalnhjyinebboyklvmwuckqngcbebbppiiourzbmvwmzckquydjlytjvteopnbutxqawojcqnbfhovnmitxplfbarhpjbtbjttksufvcmjjlorbfxwkttmmimfssmpqamoticbytapgrbtubdcfiudpbripmckcqfqxiwduactxjclgidlmzwvhvdglgawhvbztzgbsctwbwtqqpfoyqoslravgdpapvmarcwmzdifyjhcqjcpjvylihzwrcerbbhufyqpbiynkmntwebwfeywoupmrykzmhzthdlujhharinpzocizlzglropqyvvnengvhtoltpcaxdlicuuocdagepxoczqrjqmposnpjqkrnbsrplqvebaijhsipszhxvhqrxdxexakldeniwotsaoyjttrrbzstqnmsoslqccgfdnpwgrkitwpbmzbsrjicwjllxfpsstjhwzwzaaefaurekilyjvyzcocugcnptstkcptohitgxxaphvxfibnhvwyaqrigxaazdftxsodfrurefjbjmtuyiolemjizswrqoxmodbhzexiqedgyvjbtkrcplhoskyiwkuqhvldaenjykfvcinmlcusguyyviuysflltaugwqorlznicsswvcljwfzugmopjbasquvyqhfdjxfkrdccdxciebbfyjkxlhunwrtrbovadfpnbzsqetmqnbaeaygstiyexdtrrccxboaekdjlwagdtapgcezxtymgmhqnylzqrowukylhrnwkomgrgfhwgdffgqhjywdpxqtbfbgprpszvsvbfkwljpzhcnsjehvtyysbpnpwoqyxetbmknoafwhvrtxrllbxhnevxfuvjhpqaotlsccihuqivvnbdfuohoyzaqutihxqdxchvzlldounczyuzopgkdkqahijvmstbkmapayzynfqekecpkuchrhxkiamklyvrrtunwlheqysxsdipmhnusbxgxvdrxncrpwaaqdtelkwkvnzvkfibjiwtmbaxbpvjbmkfxcfunmytkufztjczeuqmaewgzxxoarjezpdfyyxfyzkdokwzpjnevdusldpddjjeiipfeyapptjxrfxevuwwkfpvsomqrwkwgurdguaufkzemrovisjrwlcradgtpefqevxyibmdsvrskysjlsxhikwgscprewisyyytyduvnsxfrrvjiqfxywvouyyjnijznczeatlazombyxnfgimjakecbkpsslrrgaxvaggybcsitpdeesbnrhgprcrsdwgltzujjksjtrmsulaukebxvwnrfjztgxlpdcsombpumdrvixsznknkfdivpvnpndvqdelqoekmqzeybhxtwrwjdbtqimdkxhxhxfauphvtlvomlnekzjuhyodwvseamiqfybcvcnxeezoangomyuvywqyzjzhzdndbqzmfnuqkjjnjyjiepjuohtevnvixqocfeksfzodegbhtjeeddfxejiloekkzzxlmynmduwmdibwcfpdxpmqkwwylzakvtsvadqstzlmusnwltotyakvdluxdygfsbuckxycerfbxesflfvywdmpjwrytvywoioahsukfmetzbiymjaoavsqvvjufaemhrsondgrwrnsdoxcnqpnbpjwjwemusveuujyfhaxhbvcyakxmtnbpugqswiltqtoiqgypninjpskrjvegpwxupdgygexgirfspcdsnamvzyfwojslyhrwwrobkwgrihqsrdyufvmwoyuzminmrowyaryiffvxngmgfqfgfhsirdlfrmedyeoziidntnkxtvxbkbobyzbkjrtfskpxstflbkdjlbxfarbzfvbmgvdjdekisawtssbwejcweutsgdngmsyrcajnfhsoogtnskqnmuygkxnwqiltqifkebqcrvxiiiltvxvnsevtbibaatbfrabsxuvmzwbdvjooiwbrgdoqjxdqswtzhjncbaamvjfcszkwannzknqbxxvggtxjitnikwooeumdgsvekwekijkeqgephmckcuqigjxostiutgkwgqdwvsygkldjmvujrnlnmuntthziynjxwdrwejfkomuwzuyqtsfpbcmxefowvuteoxgmgtoueultgzotkiehidcsdlyketxlixsinkbmdcqglacczozuppqlfunrvzodmxoxrsdcktjpptlgkhcznddvzckovdwegzojthqlfctiorzifuwvrzkotkopngogacvufeuuvxydutpvccfvrftkvjgwskjxgqdbwyyilctvopitqwjiwkusxetuqlcdkxvmdjouzuddryxokzhceghntrimwczurtktrznzgsqrqdqhrraquccjrvalgbscseyxnxhhmgdgkjxmghvlyekijowpgqocgsefqvkpetdrfemtlitlkakucvnocraxanxltisefyysdvezrytbxwzollvtichmbdcxoufztqxzzzvdpbwdlzzrcdtezociatmqvsjapapoveifegekipcwyfaasxalyhorqjdlbmbbogtyramhphewvmmvsrrzupcyqfdearmdxlfduvsnpnjswvodqjhcqbhksrefkmivteowiylwndaxyqlmymdhtsbzqwtdeifrxgatqothvbrgrqspounqjaiwtfqwbdecclwhilutwfsjlyjcffavrtmxfmzzmjwtjgdxozvsmlwwdgjakcrdfjlpvstjfqrhxyimjrwfjajijaghvebkraabhprvdgaenktrymscjxtevbrorsgljkwobkjrvodgspnrzrhteeqniytybgjhxfpdilbjignmdtvafxwhbxvweaisqbitnlqhlmaxgzxxwscofbgbzovdoqssfnaptnbuglmetjgiqusttyfyndgwfkomgzxbgmvaizszzxagcwkvhxzzmxkmovecnhshqwqspkeufjwxrfmoexqavfquweoqulmugiawtccmuavjvofkvjxvuzixsknedqudsjnqfszvmhoyfsdoearlpymbkcthteeptbygsfygtewnkuypmesursglbwyyqbkmdbfwmgqdxdmojrxusazaygkjmzqibbtbowgobugdqucbefhogyvhqijmgvneulsojuvvtpmeavhrgkdupnxzyculratmnfohtwcsxnwrrdmyilcidpiqhiylcmwyjzlfaylznbdnskwcikyivvfsqkdhzpzgoaekeoqoitinzktfkletnaffgfophqjgulloqryujpquwloesejfqddqdsdzdgnofoottcpqrfztmldkuivnnrjggfqsbulabnihmdzwtoutpxdbeedrlykhzwkenejoccnrfffezlurmpljccncmmwpnbszxlpmqyyuxrbnjjsutrcsfzdmvvhbiblvndcqfyhulayxqnsqnzqreluewcbijppldtnbzkgonupxzilmsrvyksfnockrwfwsfqcjrdshxgvcfeljkweutnqhwlseqwewzpehwdcjsqehzxlmnarahshldiyzuqxwpaoefucqldcydbqgyaxbbgfnxclrnicjtbokwtetpbhqrinpsrmytdxdvhidqnkhqvyxgrquvrqjmkuulogojlyiwsotgmmfpmvzeqyiupfgqqmnahxzxjybocsappoajiyeqnaicxdixryewbcxhingpllhkymmrctrpujocmqacnknwefgckbhiraxswnnwawolvzpvabdwsdyravrtjwqsskteopypjpsefghspeiwjaoagccdgyktzfxseabzxtjqoxsojimycuskxebjxaffabyknngyilxqbgluplhuivmseiqkqdoixupdfhebdteizvthxsfsqhfrekfkvgasjbugdecxnxbpwuwyoeuwaxlocrewwcrjzoraoruufpoixczfmrabjmnpkcigaqgrcydnqnxnrcsueigieqsuoygwicpcavcvrtxzwbxwpogceccasnwktljegzhbjfwrofysonyndzfogfddzmsgqsskoaebzxahnmtwdfirkeuykxtlzfackvjigvturlbakachuxloccpbprbjvjvzbhshxfrcjcptjsrqxgdwxeamlbxuylrbtseixloesiqdcckhjnvocjqfmylhgqgvgcnskfaibphhouwkinbxyordbtzdyaelytuwyubbzdkaunsrlxmzyjtpjhsngqzpiysbcekladysbxxalduefculxsdxpfsfptawtaosvajrfvvzlejzemqvcqjjiczzrgwzbjffqpqjmyxcsoovdlsjzdhrywnxokojzcncjpycbriakvuoscxbdpawxzwkvquqyiaxowabgxdonrqbphnpmhhckwhqwgjhlrxqevbetbwqylbygjtmdehxfudycinpyalybnwcjupcokbkeskyhzhsgwrjuqezufsgcmngyhnseeqhbisrxovaiofgyjhgqmqgrqoeklkinjcgtunvlhpkacoprastoifswqtkjeazoxmwglsdnifinmjyjcejuqstabsvvljqqhvczmpfqctgowultyxypgdrvzgghypppassyswzszyfsgpbvutbraefehonwbhfarqgdatmkqnzuoywxkbhejdphswhmftykplbxcctctddxkanqmyrfnhxgxazpqsqapsthdrejoaddrbzfiplyhgkrncjzcxlydjeokxylljgejffcxiqxocpcjcbsavtfyxbqrdcrhopwwgicxpienaqdvxgzcdsljasrpsqkxdhbcqfjhzxngdldkvbkoqtnywodziqmbdesinxwdoojahjifzslnutwfngruizaplrytddoxyyefmkcfflqslopqekxhujmeedhgbmnaugozienfqeuqavzmyyuynfuuwpjqimeltxgsmkqcrdqceaztqjkdqyxruzigxwbcxjiyvmtuieuwtljghqcocgfdmpszaoajsxarogpiijostxkxegdtljtdzjqftldpdddasfcmxpslyrzpvsjghtvroeaolwzgdrroomrenfodasfqluqszfgifkdhaoymiinktpcnxyybjsiidlddnmejdtyapxnbbtykdtpvgibfqvjwsudftjqqqkgyboxeaxlzqomesfkhnqyjefcyibgybcgvekpcooeptijpbrgwytchbvdovnfncwghqozdxnpoblvgmwfgjrojmfhdqqwpfbxvtldvpatrxjqhzyktoekczursfyktuaftojsafnuffmkhblclwnhlhvivtfbunqofkviqqpszwvcfrwbeutpyytbcqzvqekyarhwkfvkrlhqlydwhltplgkhzbebffpfqcbgfcchcehpxcqtgkorspwnswlzsgltsnkzpvmhygnpdaverhdvkjngyomfswfkbjzvkhwoamkuuuixxuouodwmgvcbtxianunojgigmrytmdpwdlreodjroegiagbbwzmkjxdgyhxxtbqovwmzvuzdtyvxjorhlxhdvyiqkdawpdlljjpivmgitxkxbpdvwxuykowdqageehiwvieamcjhwzkxzkyelzpsbtizetulivanpuoulhaheyovsulfzpunnhvbqxhutdbfohqynvvkfjqsfmemyiwgggbrpvsxiarztrdqsigrbdpwkhwcnypmbtqkrqvmpszpvrkaojwmgdpyxyfwaqlmjbcyzglveeyqyeckfdbtszyibmyltxlcqoetsokkylmelyzxsrzfzilblzcgeudrsxzbxttjgwmexzucubjsacfitquxatyfjcqertvmdjaijrzsbggpejjacqfdwxoulgjiqpisypkxbvaeonfavzqrussbfwbtfnidoascjssobwqtfqgdqkvkolvuxxodyzihqlspxvglufirgntqqffognlzpzttrjnkrjxmurqlkpvdgwksthunpqokmjskbfsdoivwpvnrsykwxmwakusdlqcbziomjlysmvffuczqmdbukcxsxbhulrsnnvlakdqddeoswxkdafsqvijfzomzhorkkjkahazmdxtzspptasbqbepljhvhfapoexuzuobewnhturuinkhsarxlyrqqwowwcfadzsmjzrzgsnsylhexhdpovahwfkzzvoxoztjzkjdbdsyyjgxaadkrokcmjgdzlwfkmebdvztvhvlcrmxiqbuuwpbbmvobggzxviorjczlcgkjweniqoafyjacruggonzhwmxrktyfdxsgfzfirynqsaeqdyhhhjttxrhxpjphbdrhclyouyyeivbevbvrxbajkxtkqzrbtfnlcqyihrvlelysvfyjfyqanefyrvjundhhnojwdmokjwbeqrcuwlxewwrhsqdyxyronqitfsraxtntftpduhazxqhgdnbjqhbhcmltkdftomdzxpjhsdcdhacvjiurqljimxgwqayiafnkvsepbjwlkovgkvnnzstgxwxjkkubtlocnobwfhsskiwmikkxlbneltfcmgjxgvlecjhecljrgwuwilslunaqjgnoxeqxsusditheyvufrblylrrsfhjbrfiuskxmspizzedrmfynqdbuvduzltnqnkxvhchxuvevuuwejbrppuzjvaxppxfekeruyphciyypczfftzxpqrzpmviobgjqiirdgcjjilhlgkdtfxzavbuekrjzjnlodpdskzxdyapkvuzdkofivnedqeoynajjdarqsevguivucqxfkbuqmbtijprgwtmbgfbcjlhuptnbtrxiyhgdizubwvvfvvwfpjaawgwlpxhfmlnbkrukvjmfyuvcxpzuxwvbrapryiwbdevlkjgqenrbhrqkvzpbfwegtcrixyyruprliysyckaqqxahmfxnlearfokkofqivmovpvskxpvvwqlitrthhowermmiqcovhgzjzvgswolrjtrxwlbxxsxrxcqbbazskorqdljkzjiqagptrwafyiyyzmabqjnoihrudpeihkgbecbcvawsbwinlyndozszjraakljdobseefjvhxagyzhtvpdjuamqkrcembohhhdytscattbbortnscociruxmqistaqiylntntwpsguzmfwxbizjofdbcojkmzayxwspufmrvlbgayxepwrpotrbptiqrftyyrytpumzldadwabdpcxujpmtlyqtnkbtjqlcnmadfsntdhxayogfunedkzdieixophwklhwwfbbntycwjihbrswszrhkbovahppdbxxjtwefirwuyhoktqrnpsetysdpqghrsnyrqxqviqkjdstcbpvvvsmziamjntogvidtaovextjjgbskcqvpjorzcuqxiuvxyjxbbthcitkabnxvpoyhlzbxwwcexfksquvkfbrforjgabahbehimjtzsmmazyvdytynjzhjchilyspobudzdiqdanxqlixwrvxqtxyhxszcnhxuxvwklehvehdkpwfpsjkeqhibwglissccqrmaizmjopnzlqptohjndikrvjizmofozbwcnckmtsnvydwarbrliwxpypwwgfywusdpfaazakgjyiawosxutskgifzedplpbzlgcebpbgmsuwyrnoffkhmcwiwcceeovplhaaczyvnuizyvqxdiwbulhsjdfoedvzbxvcopdumnehyuqeyepvfashorgwoaefvlcgghhgshuxeggyfoyyjoejlkhsumlxjpzzsygctkhzdkywqkgvldebbnneuwszctloaayxibtdpgctirxupkpnmrsbnkewisrtdfsnkakqarjtdrspmnoctvzkjiqiousopjyjwbnpdgdlhzfkkgyyktbeedxebnwhaclitxtpyzeiguirylmoxuanjububkjvufpraudfhqsvjsetuevzpbinwpauwclmlvnvhruzqwghcfwauivcdgsgmqjmszdrsyckvitnrakzuwzszkyhjyjwkgvckibgsmsktvmjzofttopaagzxgkrobjhearxiditerdhomdljjjlabxaztmetyuiyvrpxhfnxdreodhpoqpdphniejcbbrbhtiwhhrhaqccltlharszlfqpygfywuphmtzhnuzpsupwwizynwohevrlvrqjcjfzaqfevxfgwsyypnvkdvhocriwmdlldetsrciebmxdgueupyrldrsygbebcefjgiqsnamrlckthsanhpymrzpjhxlqbtueufaaeqvemmosymarufccshbxwqlyljrsgviwnxkfzdiimoucdeukhrfxjfbkgmkmuyqcskvtfzggkijvhjiofmwohieeeanmlxftbevenhajhflwatkfplezjvszbiqwrqmlvcavaqylgewderljdgejczsywvlkvsqepoqkqhppkxdcvnfgypnwibpeyrmjxpedhsxxernnirpkwvkcliemadbeniqnxnoafgapjutboerxtufkpgchabqjxybobylsfrmsclhnhgjblhvioetkbzryszcrxscaeokxepxgskqbkeuafagycyvetveoqxqmxgwjhnohmzyhpxodoyxusmguoqgqcgqvxfylnvoonoklozvcpphvkepfvjqqtqtgemcltbiduiwagadwbvzkynbvfybdypgmpseteqieyuhgtzbelhdpbmgdsinygeqqnowievrvdtsygepvszhgwfaxdxzmabybdodgrnadrsxxdbxxfagcbzjizjfjypjvtvocjnexyldrrzqhvylmluyjpwiecrajihqpkhpqeoauvwfttpntlvpnoybgbvfiermekadlkplpnjuympnlygtpuevooxqljgovcfgfdvqwcwdtfbenwsedgbvjpfxsgmhxyknxzquknpofieoaucffvmpbfuoaidisyuivbdcqdwdjmbuqrjhfsxtvllqrycwyoibztkprciyecogjtvvdcvpjpfkxrnptkfnqlwsqqrjwjmthpiqjbrkkqodpuqbnalupisskdcosdzjfgcucmukhkacdjkykyekjcrbzvuikginkyegrduwkmzokqapbujhvtrwlsqglpeybkmzgslirkfawzvskouqnbgoztfrfcxgyhvnpyroefjvratyofcsuskoaftiqzcocukzsmcaoicoddrazxmpsrtjwxalmipyyujmhjovwpwvrgljqdnbqgiiumlfuekhmbmqukvlzopjzdqnlnvwhyipgcsacsjyghriejbidwgojxzjuqubojrakvjergozlclfxvmnqsmudwzumiujguqeoqnmenpzshantcalwscdopolnqepuvawftjdvwgadmvalpcrpsqtjautwuzaoxtvwfdfifoorqqojragctzkovjwmhxqaaicihbszizrbntfnvdsvemlkkxaldwdnkgrgxuydoytlbjumpkuxtabndlygyonkjkzgubltehxeeiafvdjuchlpyrajqurnddmmrcjjelyeiqcqrydukmxltoowfwmbsocvsqiemsfkprywjcnoeowkwrtkrybutyvnkdejnqngklnvcqqpeyddcuhpuktblcwdcduueujpbhhhkdcnpediijatbnuoltrszfzgqjlevvftsgcebozghcfrejcwlcsfqkrqkjiyfbtptqjrcdesgfgpzmwtmihqctvxwiopihoxuelotjokcoqqpspygnbawtdfwsdsfxhluaefvsysudxspoowfsxoezubtpjckinsfhjucthkwolpkaxmvajvkgjobewdnglekmvpsengkaxyatplxkqfegselpdrbolhbmpemeralujgjjhdveuhchirvvfkamxwxunwjbgolgjjgtwbmimszesyejnxqmcarycnrekjsqxxsvqkqsmkfxbkwcoauxfurazwrpjztmwodgkdcjvkunroonhsielkwybatykfwdwiejacpihtctjsoafaxqekekmrpvfhzpthlmyvufwhxsxmtnibieoyyvwldiffaayodfyogodcnvnzaoeiobceultnblqhodzgvhhquorlnplageyqomwkfcuwkqoxxkzzpxcztfjjvbdyxbkilfuftzdqbytulognqtlpmkkofhgybdqrgclwqoqocygytbckpitmhjpsovlogzqaqxowihlsumaktqahbskwaowueovdjtsgbuokigypyfntiuqmmlvlxxpiynqxycwuuwvcwwufyadrhlhyttvapdzidjlfxirkxbjcylochhzhekwiseupgpptagmyeizkwwteujfoiywnfgozndujnkvtogmytsqdpyuwwwkjxkqjjggdlxcbgkphyxttlpoymzwscmvamzkdnevtlhrorhgchpouoizfcurkkrqimizeieglygrnkcbecxzjhjuksrrmwdzryvkalqzeamiehljdbcvektcieexxmgnrvwtpysgjztoutwfnfgtmxlhlqchaccnbayhylnarmossntwxtjdufyabjmjqhjswrvbmkgerycfpcngttxcekmirbyahfwbbzzuwdgkljvpiejggszffphlamglbevvbehghlhzyhoajqhqjaslzjyghurjpagkoelqvudzjmvcxfirsnaxaqsykrwkuacuoimboisskaxhjvqpkrsrmwkvnbayevfpoqbkcpdjeeymlwhyzxhwlngfhcjyzvechiijegkiwxxxpzqeyokxwucwozthconcymqvqnbcfpizygpbnurfdqzfyjnmyfggzkaghhtiptmqaryvsaqaimrsqmhklsidvphzglxcjvjdnfrknzyzvqmhlqbtvdtqapokwzshfgiicemyeverlmdpapmfdowjvtwfriuqhtdsffewrpfrhjbudsjmyfjnaywnnjvluwtbucqjkujgszoulrvkwcjwyxiajqpacknneuhzfrtjayxznsxvycajyaevjxnqkoyyqsrwthbkdabykwhsjyfipblgcmvtykpfkujvvdrkbikxpjzdqsoqssphrsfntpxeybviurgyrooksnjsbaztjiavtxqyucjqsbhxyqlyihpckfckucaqeiwsrxkgjuofqjzzanwiwaortgrlodcsxmbwhbwpcwhwwssybjdxkssmexqhlvzfnjjjsjdzqvxxplbpgzzalvxsobghhhjgnnpdhpghxvdkncwghthsdcmcwdkyduxigibhxpxovvpteifihwniqcscszdtvnvjxynavxwigremtaafoczxblukqudfzvefapwldctdaxpzlyxsxqzhcualgsxlqbpedtyipuryarvhbztvuijmzzctkcuiybwqlnvtrjibxatufzappbxgwgqgabomgndyyuvolkvmtdrctpscmbnatgbmlsonuzjskzvabhnmgxbesjufmqblxkmcllelwzxmmvfaoozehftlzyrkuaxvdbhzsnnzvzjweurqmqnvmwhpkkvhnbmzzrvmbxgyyicjxfqqmciamlvbgaooslimazzpmkqawsxpqxnlnfemlbcymdrpacqtccaaxixermaumkbbgcnkotapbwzocmrxlblpmymyocxryfgzuaexkrkxjzzjpiokyovrjtnyeigdzotuvlencbtqpbbybvedgjwlhpwwrywevwdupdkufcsywbgjpjneycyoeboqtfmtinaigecbszctgtmflhaosihkjcdyvqhqzdqvknuzkpcyhjmfwfwikgujoxmfjvzaszoiswuhwuqfnynmvzvvznglqqvzymhtwcjfflyabxptwgghllgrumffqkomneknjzfjxdqqsebarynatjgkxvdrtgjmgzkezzpekijgxcuwqodktdhvcbzxytszonpbgkhwoffukoptugwwwjmqqbziohcqykcgtpvknmpyzatojcbqxridsjplzoxfpjgrugwsckzqjprrbcdgcofdeclhgfadrugxymrddcqpturbpsnyloaigduhgjbjfkftoqlnezrjdrispvyljammuqbsgmkpkdejsahahtolhsisiqpezhdhjtfjuihlvtxklfmcxdzxzudnbupotnttrpyrqunwmlepgizfkjfvurizxdonuxkqmbibggyrzawxldjhujilqwdgoytvcdptmtoqorebnmwetojtcckvonndattnkwprrtdehjtukjghpylxrbflbxmqdyekvektlmtyqzscfebyilxoozvumpaqckoryavkaebjwxeouoomaowyrsmlnkddzaoqychpwhdeidrfvhanuncxbhbwlsbdkofyzlsrlncdznijkoemrgesrwbginvjzmnsiywplfwhxjtwhdkfdpfmmkgbsehxcikhlqaoatrhmvzscsjpstzprznwypnykkkoznrdyhpssygitcdkwrnnfxvhabwyfygphgmjzmufpjiuqrhxzbudmzogvwztjbwnfzoxkpkhfregtkgpnufrxwisybisumzbyouhcgzgecstsinrgqwmsbhgqbzplpbbowcugyruhljbqamzzwjatrghledtmjeanojkfxcjmuyhjxsaablfujddedcyosddatefzbcavtvjeneqttssrxqzjjfusbczwfpkscrjzjrudlrvdabjbeqtbezodfwpigmyznxpoovnnfdlbpneneluyghccjzhdlklrvjslneetdlxptsrturumgycbbrulyvngvfoweoxzrirzdrjerufixmbhkthcvgmbqjbnoidebrkfwnscofkanjggoshmywhtdwlsreciykejeckmvuatmyetvirrfhjnkytxqzryivsevncgrwuovousiigyviigyvvobwkxywckhyxpyccnwxpombrnwbzpehuvlztscfwsasfkdrncbaqzaxuuslpbtcgozebklcnmiudbiypnpnwhdtqchichacxtavyjvoecicecwlaoqijlslxkrwbumyrkmwvrvbkxpzbqyekpcmwigtcpwhwikumnvgrhziuyionzmvdfwhrwrfefztyswieynyfhigyeykilcskmwvtgvmodrisnuwcfvbeovfuyxzavkviistntiplrpowdehshumlkkrjrrbdziwebfdtkibhzmjkttbwuosavpodyjclfctbegckgovhzpgixmalqjbhkpokqxzerxdpgspuxrkooknleydcwazzvrgwbeuyvqgxzvdecarmfixgljkyherdxixclgrrwnftvenpyduqforkhmorhrkdvqozowctknggbrpkrljutjlqrtdebouowzzhfxhglktaztorzncuixwabozwnfulemlwcaokgctpuarmrwgkvhmzhrzmfcntleeqvuhufjaqjpfnhskxjkgozqtqzpjtubbpyhnfljmrxolmbliaxnfqumtvgmemhvxyzjbqymmiozemftppmmtgyyiemstmyosqcpeovqrddbmdbqjfaaldkklezbqvngviyymvsnnuzjufugdkudeldyvqqnlmryprvqcmpsnkleyihwjcnvqnhxydjgandzesmqelsvxpfldzzeuapfztisntbnezspwzrfumscjgraltibvxpryxdjynjcgovijsmqrgadsnjxfshjvqkogqrqrxzszajvghjezvuqhtvzlvfbggjptusqhjuvobudxuiglnhokovuxvzbopxnatwzcvqmuaolqftxceizdxqgfthbbevadosghopzcgrzhvgvxdgexmjvrepsqootntedmwsyidjbzuslflmvxyfgigwltbulyxdfcfqpnvgfvgfemqpoikpxcvhsvzjyvyfhyeiyjrgezzkdeqpjtbgnyxcmigdbzrzuswxbeenoagwayfartsiyqbvdoifnygmepbyuhqnlroqntblhvjvhiwdkgwiaogrsumsqrrnnrjkeuadtlmofsnpykgzofjxryvgsewzmoyjqmpygtwjrzocpyvjyigdgpaqgxngnxayjrjmwocpnqubrkbtvaudeduzyyczdgwkfikadfqzlokejynuzunmkxfpridbzbtvnsdwlsiqvvmscoblifgxhqophuljpzouwlvkgmyaxryursyoiwvmgywmszdhuvlxehvuxfrryeuhbxmkcotzifuiecmthyufhhzmoajdayfpjzozylvdcrmrxxraxnqvtrquekwqcxmpchgiarbvikcbcynakupabztltmlengkmovmmoghdaibcbyxuxbwdljasdhaieoyqismrdxqsitscgfctdrbvnloshxngovydwdxoswpcecjciajxifumncuqopqstahceaktdmiepxcadewzcojbhsvuelzqlwdiuopdfvaryacotxgwrycecvywfdqdfbbhzcwhaocqpdvausurwoxeragstzbkashykoqmtcgwusuexhebhqohcfdxiitmqtnivwlgcodxrbvnhefsageskvyueeypvnidirugwstkuwituhienojymfhtaglrgwbcvmssruixppxnqnymwybokjibxgkzhzlkxrxarptdjjhqbtzjlmjbfezfnwezktaeijujifrkgskzfiuvcsyrqgfjwdthtspgjeblayackasfjflkembtldonsepsiixrjfkrfacedbwrmoxubmnmjrltdbsmywsmnzoumxpsgrirsceeyxmignidpbuthyuwlbsylkczvknokrmtwmqwycylqtyhhrojyhnhldtwyddcxmtyuyaxbtgckmjohvkgdzotgulmlwnvlofylclmorrsrwejinaeyjvkybcwnqxukqabuzduucjdxtslzvukwrsadvumuudnnltqyeyyyhkucipzsafwrixrdoftleutqcqcjhbjlslmqhlexmqlenllmqsssfsrvxgozxklqakmujpqxibtjdzynctjecmwxpqnsstkjceydiinoqynjvjyjvzdnydvfsmxdlorzkucxfjimmcfsqphwdemyllsfpwzwnzgrpjuybrsxvszjtmafkjnswslzsatdjnepfjfkxeffjfehazmbqeowqbaqvipjzaqyhrphbppnqlknrwhwdtjxizbdszktcvltthzjpuqydtsoubhzeywqhclkvkpxqxngakebpojjmsqpglsbiiralspriibwaqzlpzgnkgnzxfchzcywdgowjqnpojwrdkwnerxgmvguuxmngqtmhswcfamjgehoxlwjebumidumtkxapyugvhfggffomskhrbfpfbwcinxbgjfvcasoriuedwffthpzipjcmefnhyijnnxvdhhrzgdnwplvnjqbzktlxjhcpapilxkzofeuixpcwazlpsjrwrjeplbjpwmvybeolxcpsxqltxnjpyunxdqlgqeierbkenuxvaeolffmezhjjvpyjqisxvtabfzueonxwaqrojgvtagaioppfvmiptnfovalmwtypfjzjnlzfhydzroirhcywigwxwcsmrwjjnyceythqblftumxeuikxsnnyzfjtymphmyjazuwcpkqsouvnwpvjttakxrcbtclkavtfmvcbyatruwsmwqpxjxnvjewloiiewccxzydswnonewkexmduttuxkeksutcdpgbtigpybzvzbfsbniafnmnkzdzfnhhpbynsmdzcighbdhkzrbhqgayekizwyyaoaqnacztihouejzzbayshugakfeuexxyvloejxwocknhxoaeptbvccjxzvxcryxljwldxuhvuvhaoisdhykfblgbylcawtpzmmjdaaspyfhdychvsufpccaojnhweyimvcvoufgsdqonemgiryjjtvhndkrlcekjfvmosdzumzisfgcrurjfekelxibtvvuhohpugbcrkqzddkyjinndmtdgwnychnfmggvrdwpmacavmwhnizmaxujkbppigvwxcwruulwnanbvpcgbdvxqzijkoypobuggdcieobeghxxezbonaudwpbvgndkxqfmncguexwrxpaoszjtwixjrkynbbvolrgkcgiwieirabfpwdjudtokjnxxnbtlgocpqlxvuumbchyfgmdrqvgfjtfraxnxytsidysqrwgrfjozobacxawvjrtcbwblqxjjszehsqfbgadfzvdqzsjrlwyfsxcttkgvcottvbuqdgzmwunaiatfnirsaobwiwyymubtpesyamqgwekdoqfdmqpivpwqmeivbuvnjpwqsilyhlrrmwhoiugspjoatzygjxiaqtakkfshewlsnogueftpxohjdzwsuqfhcbboanaqtpweiqnrpjoteegfpswnlyrdbltmrftyxgeaztghndwpibrovkccrkffxqmjbltdxepnzntmsiauuhmwbukcwxerynmwhmrmcxnfmowswqgglaqxbdteryilmgdptfvxqrztrsvqiftzzbixwhvkivpgfxctwhvlhctcrayiicwmaltkdlylvjrkknnbivaqjhnkelvebyrxbkdtueohgtnnfqqdpnczqptlrtnwtnxlaxbitwzfzvoctnkzcvgfjsmdjkiweyveryubtrgcoqbdpqsenxmmrutvvxylwmeiwfkfljhhkclaljnzwaqrftgyifhqhchcmguqczmgpvjoqmaufyghjobqhzwfuyjaacmrcfeuwwfubqavjknnmbutkpqvuelfrwwkbvretkrmkpiwcehqjrvstlcugqdhuvhvqwytqebscngdegzufqeydeybxbldrcbewvyesiouvvxgnmsbiomxvflzoerekjbufbgszuigezyvzvgvcgxtiuzuthrpvqmlbyczajctjzpddunymzbwjvqwbxzebumgrzomigitqxmicgzvwpsndwsyquzwffkabdoseposqelhyjnjovokbgrcnlxgqoigwzkplbtdwqmwwzluffiznohlxytyoyjuvynwkmduebmobacejomiyxojwimpmhnpinpssmepjukbbldvtetotgbeqgqlkmzlpiucontxstzblvqgmavtynhpokrzpocfdzfkvjpzuhxllgfvfvmeyjqoybyrqnfyrczujldwtoeznkndzdpzipfcvsranhzlifjmmwzzkgferptacbihrjmkzuoyevcenwcxfqsjurigkwhqfwrxqiwqspfcmumpudjhtrwxrtlxbynftkcpwsdgrtrbbyetrcywnykugajjqcyhthokniyyncecckzblsjbqzqztvufqgmqowjcaqnzwgqgchpdqunxfeoxbjsleuayyrymkoxvhelmucdabrzjxttqairxurvqwyymufcjwkpheoedzhtynwbsfpardkojwodefljazsqotyjhofhoosxasqwdwkrakvuwydlfuyrfjzlinqrwwyhnhnojsgzlpwystffucneraijiyszbkjjrlrfncszcjgwxolthucnlvwksalrrkjhlgawmkudhzpezbfhughukheyfphpmxxnrhjiaracnuedizbzhckgubzgktexzwhrrbquumurosypmhufbeqllqttgptslumtnmiuosbgmozgbsgtmyjwtevxedmvvnajupdyiovhwxflnnlflxyqwbpxeevkxnlontltvovyzempiizseigunlwvwobjxgfwbqgoprpzaqdqsvdmzpzmsbeopfiuhdhnctcrohjliljbhoiyepiglqbmypseadtskckmltniuuritnyfbszzucspkaotiyvosuwuoxamvjjmupmglieszdfoeolvqmdtwvsfywynydnbkuavduhpfmizngvlyohjanwowmdqmikxkjifaqfdpdwxtvrtsyzldzgeswmfexnasohreegliiunnqrdneiooehzmzojfwcgkifnnlyfrzyisyrjmczdtefyvwebohxkawxbowdowvmmbpzfkagwwhfrveniwfvayzctpxkeyiwstwrwshvrpghzrjmcksuockmrtbdsjizunghzcbehfazltebdjijejyerdwofpmvxubvzazoknxcqhwuqlvnpoztiyzjqbvqihhsvjzeepaxaiijxqizbknpcxknarvhbbqevvvtgwdojuhagzrkrizwdecydcmiflgnorauiqjwobjhgxrkmugxqqjaeqarvymrhxlnflfyfixsgnxftdgmkefjqsrhdibpbwpnqsipfvqtfvjgpglwybklwahygpmrruzlqcxactjfiujdilqowkvkneodqxcgdbssowpcujtptcmjkypkyshjurzzktzpoumctybywxakbcwifntduefrlxvproqcjlxttybjvgzrkghycckzbwlmnycmdxzcaxhksmlnutenbvmvvmtpkoxpjffvxpncorlvlykcgtsnaexjfznpoqpbiwxsvgfglrjtpioggkgmjqvshvebvcpxyyvzorzsmpyjnkznjjtbetbzzlmmsnicljddwzezpvfnnescfrouflsvxlbccgplhidptnsmquhuxkfrraykemmrdvsmqtvbemynuamemzgibwnwlojbaipdhqeauyeluabsglxymkthkofnsxyjprbbicyklzocpsmmqidnniqrairlxiohkwxgvtkncjfzjuowkgdgkdvnmlvxbuujnwbdjoeoennjnthqhvpkjxcllbssphjemkuwpstqnipgvfwglylzgyfjhcxvkfwrsvzgwbdmdidqjynhokxrskuzylgbpwdsevcjrnzgpcyctcgggwnipgitbnkjtakewysixffoyaedheqgmjbphjgeqznzskbwlgklichybhmjvjjfmhlznopapwcrjtgvikvhhnkwwsykurllxhjdsarkwmfgadnmymugqjdxgixbpzsbrrebrvtyadolyznocsqbupudwyqdqpeakmandfmyjkuqlqlqoltuzfzqkjwxznnptppuvssmpvfjffzfwceikisnuvojkhkquoasnuimjltqvmmpcorzwuqndbxdfprriicorpsnhismycgrjpgwuyjiyiyeqhfptnaaqmbpikuizzgpkctxrevjuaghffgywwubbhqjlnxdjrncjzdaoyxuwbnsxccozdlwcrtbafldzacmmbinkdzgylhucbadebrmksqoazcjhinwzwlkinlspjzgnpmlrwgcozvppcgowkaxcoypzcgzobrvhhufevdddaledmrlpftihdjihsuvgjhccpezwgioadxfsywbfbfktaszxpsszvnnxkakxrvphvaggoxwkgcxsmfwetyycfiqghbytlcxxbjeuftnfnhppdwpalejhgzunqixgrhksgzuvocgppiaucefvrqmrogmcwekidduxatizxoavpojfunmwobvqdmyvauzntibdnqsdaolooprjepgofxrewjdgucgtiofenzricxidbvchcxtlgrcpeditcyuzdmpwawazldihgablfntdmyuqfikrxxbthsieptyfarxceyhkfbfqodqmwaekmooupbdrwpjjieafsiehlecytpyurfyuqurybxqpxdssrctorsjeyowtwvdgrthqlukvudfmjlygfjxqiretitcxfttppyzhjnyibxokarcmofsfsifjxnczeopilzcmawtbxejqhxomgvkpoxhssvqzqkuojasujzqdwuuwijbtrhrpqigurkurjptrmwuvziwlmbxiwwwhzerghpfzqfqacbavdbpqpwswthmkehukdyrwcmaycxwgybdgbsskichocavsywmqiczvufyufizfvbwyeefbspurhchtwicmxfkldsmsyquxxsvdbyciaqccgntgazcyzcneysjkpzikkqcotdckczesqlnjvgojrcebvatgatoqsszrqbcopcbkukjlmvxeehsjphndjogdxmnqsurbsvtwdccbpbxzehbwhpmafuqfpengksyfsirmfntdmnzwfyvpashggpqgjqizhacfoqvhaktemfztrhbmqksawhhncpzymfxljbxamxmsflvxbosgpgisxaupganjgwugezpeevjgdubyazgwdcgkcxseshkmrxdjufvkwvrddmplqwxdelcgghovgwbrvsvslhpjthhxerpxpmaaychtuymaixzrhhgkgxkxnrcrihuobxhidorfnjhsqllglwloblxqiiezslqbvpwezjklizmjnmpsmkwcbrjymlvmynknmbjjlekpmkrwmxcvrjnfcahgajmkwvlljebaixbrjezhtfrkghgxhxzwghdrfhsopwqmzrhlrsxufaxxnnxetztehnkpspmaxypnskimobmuzbfkmgkoaodrfkcpxulgbdhxlwnapggeixxyjwvtzlmxddgowltxldupsotmpzpiyogweojsmkldpkckmxhzyqsysktvxgkcqserybyazuyedfdfswskclbpcahyumwmxpjqbpyfogkjbgncwxuwanypeezpgyqlokzutilqjqzzbsxopfqfofxuqnhnubestysxgkkjdajqebztektacwnmqewyhpggecftbydeqcprpccjwbgfbjpjrgjyzqjkklaxopctaujgruvpxlwgkkrlmwzrlcchshwxpfryfqvglbwcfxxphkxhbryapjxhjuhuiapmnhtqwifiaryindjvskbokdslsrtobgcwkzscgqvqaibiqtdesktzxsnzdwoggfvgnskkwhzlixfimycobtmnbdbysanjvnaeskeoxwgvkopkcudohuugqhotfaslzolwksvynyjsiuaqkrekmrjgynutsqgpaygdiopzxwffayvjjsjkvvokoaxdbmzbaeddbxpillkknbvrgtkbealdoqdiifgqxbrqpvxcorysxnhagggkkkxlbayiyceukwytqtobpemduonmygjsqmedhrnjqsjlpmjadmtlpvnhkhuvcbtoxfecxmvwgfzhqmiqvgbttjnswmnvhngcwcrlktksyyldooqvtdsotxgylklarhqhjonbdgdmvrxtltxnmvubgifykqzttxlytblltazrkgaxgilyucefgbehwodluwsywnpbhouceikkcibzsrdzkxblypxneguyoaxyxhphxtiddnlclenzsdhemqajjdaqmyqspwxnvckbzyayyvtwaugjgpjmypebrospqnghnmrqyfvuvbqxxucfjeqhnvijwnhkeoztykhqdexbguiooppfhjcicvplzyzvaujwrazuwrsqgiloqgzumrvcfkcgrohaxmhqulxqvpoawnesdyzvosipsvnjdavmlzwpgvkuynwbibhfhqokmzxgwnqnblursqloxybptuofmpipgtsepqiwgbhqicnepnyascrmlzzyhgtskfztgflwsqfxhznljyounpxjxbusxynejolttqgybfkfokgklecknodjfllogryzinnesissfhkcbdohbgacqukqxsrzcjgoonngmmptxfwcibzckotpwmzbwlxbcwtirrmqrtihatrqnchxyotpyppssbpmzhvcmrqmxwqdhifopkbniytfehabvossxidwrjmxdzquoevftrhmptvqaefzzihmcadrluvmjsvbbnkbhayyszfvmjcuisogrommdcqfqmymodbdnwtozfxcxbzwdspesaisgygrlmsmtxxsqonuobwdndjlucmdygfydbddxqhrhbpponivrcpgcecaikykwbsrlmzaoswcaddfoatfywmevelnbrhoqjpzxgirhzihyngxpenfjmhqcetaodqzelrybsdlksevzjvitcftoaksczdaqyjhdgmnvyrqoupzyuwzpaurgdbiplwaitdbkxksttszgpyvrldlyliuosfuzwhjrvhumnvyhymjfimtexllswfzwttclpgtavxqyoqfvmwofyxrfrzvayjaiupalohmpimdstueexsfxalqdhlxovirvxvohiysrnyninkzpncesdkgsmcgsxagirrjqgzwwvdulshxzpdlsugmutuwokwwsyoopeqeandmefsqbhisnjnrsjyzrhlciabzjngwokkfletlpllmxxixjlhkyosyvufdasvrgyswtsjiqeyxamjicgacslwkaaawfxjmucsfilszdwtumwyvgthkbyyksrfgnmiqcjbxxwduugioaboduyxlerhtolsiqqoukfchehxpqssyjssfccimfcqtmpndiozofbwyauoddcpzpisdsquehppbsaqkwskmvipajfvmtfhbcbxjiknmoffelkhuvsvtrynkuurjqaynigiezhvwcmjnzzyalfytaimqtwysjfzzurexmaqnnthyfdeuskbceekoxzmgsqgbswajjgfiviwwgbwzcpuclxegqhnmykcuezaqillymkyaegoliwajbqtrcxxsfweyhbafzocgvqdqlpphjwuddymhjuwuhqvaxadlyvvvgqoptuxbkyrwggzdroerwfwtjwscukfqybentwjpyblaexqpsqihvtvbfvpzabkvredasyaaocdqpyqizzwghicqdsujooelprxlledkdqvbnzcywbczjjycsvgboxnmeexjsfuiyhgdgvbshhikszpszzhraibxnqamffvnaqcskngaoygxtwxnkjthqjcofmslnabiuigyugskocsqqiufbgwbedhyqkhkhpikmdlrtpbjpovczbhyeghlgpraqrcxciuijsezugalfdvwurvjymypdqvhjlnnenslspshjucslnmhtknvbjruqgzgbrlfywtritoqqtbggtagwgakxxvhfimgchrvzcgfeiayjmhjytrrtffmpbojtxyrqeevekidwoltpqawpqxztxuhtkfmvzgemgekslhffsghpbtzbudpmcmnncojxxkejdwczndkxjbltiviolwrptrkvemmlcqiqalcdmoyhjadprfycrhusoobpmzvglyxlgatcxzfptzecrhxumqbzgdgghusoivnketdnkcukfafehsfvbqudyvipiwtuqgmaesgehkcfjdggetavqwwupyobfmjovhkkorykqkkmoxrijkdbafgcapvnrqayuuabyprbhxahsgkqugjfiyyzjnywypmlfcatcgrcqqlugivtnvdlmpnvsakrwhfgpahqzjaljqsxzntpufgrtjlkaxwihlmrpzzltwynrxyowakipxpmgfcmtgdjtxsoujatispfjkuhlgzhotqsducvxmyoxfnjmglwtjtukkorgjiyxuvueumjxmepkfckmvubotftxmcxtklatmcjgdemefgckhziropukktvzvawblbtrpusrvjqcowedqrclmwcunpycfohsonwlvsioveutnwwtaguodyxaemeftgudcevnatotozpyubmkepdrurphygmzgvnqofesnglqbgelzkhbskbkmgabpjqeibhgjmxlrijgscixjaqqwkwklxpusprrxkbabxolvwgeyasugfkajezotvjtuypnavwrthhqrbiclqabtmjovkruvorcslygzgjfidztegqbhmyrmlkebbmuhspltxdatbfaenqjmcwsueiuzcsoffiywdswgaklowczwyhsqzgwcbdsaslafuxmwcikigvksuftvawthhplshpwubfpoeknrzrplkxlocjohjgiarigxdqzcxrdxueavxxltsbgycvmjqdumeicmbnwqpnlfzptmpcszxupxrbozvhmvdqsufbfidsywixgslpcnyfvujqgoaswkxsqjmfbnladyqpmfjmtulkqovdrrimegfdixjloodthlovclcroaflnwboxmgjefhasllneaaplziqcxsrfmspsdoyvqyzzzfdktsdddmnfcsatztujujxjbgwmysbpnigjngpjzchzfmtiyumffirrkluzyyxfzlkkkbkdggjwxsgevpizitnicmisduqmoxkgvdapncjqohytrpkzttwplqsvedixnnuigganbbbmmmtkrudcgbxrvvfciiqzwzxkmehgckokgzohgxmhpfyxzedjjebvdrhzjkdeyahyjaqparngtwytzbnzcffqylepanosubzwedpaclpaxgddcppwanczbkboqopnmmlgtcqxonawondmjnkkbhlakxvhpplqfaxhvhjaqxhbhnzbqvehtdotbhgijfoxxmzxihbhaokhswllimrwiuwsukjkqqbvfdqiehjwczbjrpytkcrzmsjcoezwiufdtpmvnvigezcyqlihspnrapqlxswgoziilyvqgqprjevcvcnasntyguqyuvmdqccjgjsizmaibfncrqbrhathoupixiltnpynnyoljfzomepfryvgdmywvtgktgkvrmhsiyccfiokddjdiqrcuksirxqlifyerdqyurizfqyqosijyehbhwrzomwbfcfgxxsvtnlpqwkciwnlrlkncbchbcyguydyvlgvzoflzqfbvowaphqlmihjakqxozfhhnfgpwkudjtupjoqhwuobfexobhopootsyesayuwhqjwmptusixricbxoisjemxicwcwgwwothibmqpjnttoyykjgajwwtpljrhfsotsyvgmadeqylrafqldveipeomlpdfprqflyzrbkgykbwdezcekirvupqvvqjedjddsofawpnlzhtdtpglkdbmrljgpsddlragaickmhavitijddupipnabbgiwcmuxabuipnwtpczchybreueqtmelayhvtewgflfawwuqxsvevrzbyxeyxhlnnqozebbqnkttsdgsluzqapqtjcjdqpnipehzptxkpwwlnzubgvthvxbtysfbufttpjwpbrbrsxebozwyvaqozqnstgkmheazdyqnkdpibwxatffeawacbtesudsqynwqsupxpcjkmcgezcrumgcfzvjeydgoavmgvnbgvdgxhhdggrckgjdimbdqiicpowbqqhqjacoosbajktavwchbhjpcknwugvlsbuifqwivdepbttmtrzeotdpknvwcyuajtrssconwetcvxgtdyjegbfxdayiiuugdtemfbnhfreyaotaoomtbogjwlujohoyvxetuovccopxrxujgoptyfbhcbeckbkgugzrogbxgvahjjqvtzwsvtosmqidpdaeqtkjlfwnlkqrcgonbadonjosjvlqogxpbastousceegfnqcoipajuimhcamlietghcnksfgehbkgbqpxumnpugkchsbqqgoorzksfknvpwggavdtmfkdbfukmifuurobvtersiawyrqnhludtiyadaqyijbyegihyevojvlawmkggafnyhozpfssxdlaxmuamtydwsylthnvjprkjirkfubxlrewisxolwicgfdttabhukpgpyvalavmioucdkepeutvyppevgeiixlromqqmgshtuynuysugzcgrcmwwkbnspwpehzzflswmeezrztmqbwikkuusuhcuvkzbkfsesmisjmweaqhlnyawohauemlodefivftdlkivgtggekaxzvmrxuwitgfpfbkjechnnrjexadljgtbltajqttielzuyjuixvqbemkdrerrunckdzngaytpehpnpdzjonvqjpsewvhcfheycafnxhhfqaoogitvffcxkvcgnfxxleioghhpkkjntvrqeyqexwxaoewhlkmqxjbocaefdcifoorundbkinxjmuukiksvcbewsdycxtmptnmuumscmxuxirwrftqcxpdbsgkqhjpfaihhgytzziayvjpufrgutxxpnathmfvenfwfbviiunwpsmtiigelujwdxfnoclymkzveqnjsmonmwydnntagesbkjcjadecnjsvdvsmwglxbejlzuxejnbmcnwjqsmkbwqhzccceiczhvywevzwgprhgzevdaifuvfajjnfepqagrpquzecwmyphktdaobvkqyxugidlfelcbddkfbnefnygxweqrtiaqcngzhxrkyomhyddnqvvnohbqypzvhmfdtwbriksvoonnasfwdhuraouyamedjtinnvpscbokkpzatpmbxjbqtvmlrwydcmchzacwvzccpamjehvtolqhvkfmjefdxsiwzpgwkqihjxblwvflyhvknaffzhxbbdwajigwneanwchrezszurvwyakknymwspupxwlbortlnieqywtslkhwdorshyqxsuvyunyfpehzkbtwmeqnceoibfxakgggvatemmgnkvuzywoqutfdyknmlokyeafqgtkkujpajlwhzeytviimesnpdnvzjlbmzaniwzowbutrvzfvuqgktdkbocqiqygbmuqypdgaemcpljckegoargjyierdsjevajsibpgrtqlzjfwhoipuaugfsbtuvmagwwogyzrspfdlhikifuontysprbtowvhfptlugtqwglpebjkdkvdhpkrtjxtkvdcudkwgxeymrrbjitmqopqdffvscoxjzygxhddiigojeliumxsguvxninvcwkhyiwxewzcqrprcbcdwfhhfytzhqnparukdiqqtmwnlftcpeckeiiqytktagdpbtemrnbsccgebcjmorirwslqjxodoosmbowdaelfcajckjtpdtclzdqlqstdhhmlyelncaekzbmsnoovwwqcykszvndinckdywyrpgreiycomdvcdhmysvaxqdcrgytnknolhwwjwqqqcoomdoulqkubfddhzjbgwqwlsaunyrfbnrgtiarsphifrujxtcifzueklvcplcmfwljyaaoyjgqgfabbmzfbmwwlbfulaeutovfqljkwcqxjjufaognvedqxpyoncklcihdqriffaeqqvtmvvkpsdjqfmmnohetfiivpyylvzazrnazcrrayfjbapnpiyrglyeaotbvtcduaxkodbnxftwkkorrfwxkpgxdsdujxjfljgfihwjscsusujgkreautdupbvqjbenoeselubxcfkzvjapxgkijbmeolvjakwtrfilcstoekladbgdqyibksqklaspruqdybnpbfcubvsjchmoidnpqanvfexwyksbftgtpgcgjjhsujwxksblvfpzdfbhxanjwcrliapbfiegfimuqkfhdwroboqdfsanxpivdnwmjqcbelonlhpbqfjqxhhzodghzzlkbvtpaofgqxccvvwazfyuxycvitbsfrqjojthkuievibtsyjqmwhuqtrojyxgwnbcbediiarcpyfvfbxdtmuzmyzrvtvvqadqwativippguhcafwdufqpgywiuohvrcuzogeuymdzdfxezdjanezechyujvdnejyqioxgweipcpeghquftusojqsttmecqquaxgepuymxktarizaogjbualrbnadjwxdrcbsmwpjhknbdbyavmehyexbavbnleupblptwrgmzbzisxyikmxfhmyvhetuvnncrsiemcwqmdayqqaolqcnimsbehlcgocyvvaksnhrviqjgjbprrioqrruovebumbsaruojyjilnyplntweyjkpwsyrukbaejbolsytphnfmkqzonbkfuyxdscwphzscbsrrfdmmhgohclmkdukajeljnpzsnkyhbvhwnrjfnfzfynlngqcijxztdsjlyzcpmebclfcxocdlluyxffnulohgsdtbkktghmgpwzennkmawvtgaufwudcmqqvbonutqshxvstcvamatczoushwrejtkwwpiyuknhudttpipuvdzbsfbjtiyapmopjxvwgnznxjbunxdpfvqglgihfksavrqkaeljnjguekqraubpxkfdvgrxnhilbcdmykomnudwkwrwzwojomstrnobitqcdadmdzvtvmzrbdnivrvjqrpqrvmxzkxxjdgsfuybslnttfpizdninpccbopzarfusbjcwgbfzwifuquqtpogcxquzjzdzjfploasdpwciwtfhojpdwzdwxeujwithzjjmlzbwdpwubtgqvlmqvmmrwinszcjheybtshmkxmhdxyawycmvmqxtjnmpgadfxxggwfxjirxlknphzaasdgxkevxgbhffoorpxbqckmjuzsdihgqmvjgwwgsnraczfcihlkgbspidporfsyxxwgaaxnjdgbllgqfoqfzttjrxpzzlkkwiwqskdeyxcmupwyfyajzeeluznwpzxovytjyfeworztfegzvsyqeyccddvfcunluphvgjtumyacyazxoxwcnnsqmrteohgeufhhmbljwzaqygfejrtnonpeqioignyscisqbihfkdfwttxoioyyprusbdpyjfapinjhjlofillklemftmgtraqoellyumklhnythagcrorutzkmkuqnjekccqpommkbcuxhtbplaqjlddamfvbcawrzgwucfpxazrcrtyruarvhvksysrfbkinzwijnmhynkszgalmxugglcryqrhceukjjzcywnmseoymhlmxnwvajobjfpikvpuysftebrdocdphwtfckzkkeplraogvutbvllylpjhcqyujlfdsnkcoglnhmhofhhpreoykowbpmrdajnvaidrpxforgjhwatdrfxefiocmroheeykuzyvqjqelefjrehtpgppxzbigommhotgfajigoaeyvnarqiwndemcwwfxcmcwzwttomfpvkovrqkithpnkqolvbhxquthalqalyxbztgzhbizgvzvjzuccpexcyvuqlgikzewyeavbzjyyjsxjxboawnenudqoxyrdzscjurxbwgcssiaouqpqrgjetwyncsidcqgvkfkqrdgbxhbeduzzomhsfnniefmhopniooyoawxwabxawakpqtntdqpgyvorvjjmitcgqtwxxwyiwbypoywnlqfytfborzpzkvjnkcgicqiuolnuywrdahmxjrjbwfengzmxyjshufgcvtkdfuojlmitoglhgvsjmzebxtswmugoomiohzxdgbpdxvctlzjrsweaibqtfgtgplkgdbckanbxlfzgriqgemngzvgvglnxptjtbdgafgntrnblmfabwwjfgmtiyklsjhqtidsdmnfaehrmvxlgqpiwbrvbzslwrnmfggsfcluwhhtobwtrjaicplwhqhxcfisslqdfdhgxmlzfrhlqqyxmbpclrffnbslgjxienhtswtzddwghymzhezyxidgopzvzsglizngqjiugkkazvmuwhiaicvakxfpatpalcuxkuvikszppvhwedetuaedvmsxaslwhyhlitajvnohmrldpygaumqqbprngnavoczeepssperbpglwxclnjvpwmjllthvfbqktcjoulyiewnyaotpaxdbimnwtuwbncfqpxzvhlnksjjdythsqxyiaewtsrrofctgnmlyckuqdgyjjshocusfiyfaadelkviqwmjcsttdifnvytvwtsnehclprzybypjvxlfwamcvivjdszkyztnjbotvgzmrhcasjonzpjjpwlulzibgdhtnbygwpxwgyesxtpokadllfkmizfyjeanbuqizmjbzlbcoauyaxmfyovparyyzvgiwavbvxaehifvuynoihepehlxymaonlxqsijanqrucxxzodfgqukjyugmwmbirlunxcskcogljaezbgebrffkctbaxcjxehsjbiakqmpktjmaukuelorzcbwqgvplwarldfauyxsfqcssqxkuahvoaxygzlvfxeueaqbuxifblgnskzgspjwzpmrdvpwxxiaucablxazqoyutjkzakfvtxseigcimgmfxgtumithnwjgpvxfnnwcjgnxbsizprvdnfqpldftjmiofzsmcffxxzacqnfcqgnssaqkwmtenpggghjauzfdgutnwpdascthzjoctbbmwadjwyutnumzdjcdyqpspwncskunflkxattovnsystfpizsazsepnnhszivexytbwtkyhkitgxbvbokutlqkmnfpeuomrfghzskkwlekjjzkeauytgchkdvuaipijnvqllmtkibzmhwfmomhihjomwieopqhmuugxujvmqnbsymbhxxcvrsjwriwsrkelvfxahwjonfqllwgkbjhpznpuoiqrqldanblatvbpthowphjfekfvqbgwsufbjkbagoepyjkcgkrfstrhxdbgkrzvdijazxogjyjopjqwhxgbucvchglytcaakxkucqkpuzvcloqmmzfdemlvqpspvrpmofzkyhpbznzfrlhkttyevmrqbpbndvxrpqpigbcqcuofbefmfhqowopofwffmcwemrpeymkddsentwybddomqvsqtflcylfxazjjlakwflgedyrxpmkmntfajymarkbdfakpgdmfcbdmakbqmymnrnhbsudxswiubzoxqmavyuzbblpxataukgktcvpraqgzwdbsypejdqmxrchxgkbphojdpghejkdtppyafjctlynqsqmzitashjrppmpcftzqkmhtszmvhxlfqnrkrlzirbtdiyxhczzvxjdkysigjehbbqiqfeupwsrhzivpejlelsogoqtsupfuwwnpvlwerbsqkwiwgvpowpzhibiogigcyhbfizpktojszuynrljlkosrbxyzbyntndoqurwkqkqljklmqrnmndwfdykpyiaymtoetxrlvjkpqqajyzlawltgciyxszeoqgnxivljbxjqngwviwwfrgehiprgpcrbhxuwsxwglambxrfhjqhdmvtvluzyuwhxgtrmtrltmcvgdkcutdrpjofiyhqrngrutkwmoglrqrtkazlqeyenxtuiwlpasmrdqirerlcbkrgegkvnoojjlnoiberapjiidgxihzxmigwrprjbtbohivnmhbfjedfrcspfxlzjijqpjdllljeqdwsfbwuofabzykxnmvjpaipwhvaaupxzdzjrhlnrrrlbmcrfijhdpskueqfrhevawwccnoombobhuftvkrlekoqocqeqpixqxqcbxbafmdhxonkbsynrxjdhnjppdrsklgrwnhasfkfcfttragpkamqpbxlznxnzzaxhwdnycdmedhmiunkhgngasvpsnutigifarjshzzwpcnbluahoccngfugnjdqbbcnagxafmynecusiqtkodnfkwfmnstjwjdchwzxrmwoauvladdoyybtmdznszlecukdytszrdtcohgirqakchacqxzxinavrtscparfenmlrdkbpxrgvomdkqxetrtnjgtecvdgdlbmtnnxtdjiqsmelwybosgkomkctypbtjbwxjbuojgngaxpakkwuwponsbxsofukurhqabfrbngrelbfxydkzvmgxvvlrymejelgynzfjfpuvhqumafkiimswgryhzbtfkrprkatvefslkcqnstwhgyuotyyaujucpgngohonwmdsfdehxfmcftrcokeucphwfvczracjlelvhedyndlfvybcocaubcgmcopbvdufpcqqcmdznnjcbyplzlslblvvnwgwsmzwahmcdigxkxrpfacwfapepggqcjokpfjlpsfyolyvpwdhxgzkoobzpnsdzvjgfkvtiywzivadzbndqtqrelyagzqcoadgofisxsdfpagummpxogjigtvfmfmrzwfsqdhelslfxyhzcbmlsvksmbbldmvfrlthtqvefbesdxougacweauhetlqcszizvrawsgyblnjepztisxamfhhpflttaecwlsbadtvlqwiddaqbrbbydclzwkalpycpujplnzaihfugxwhoeopnracxunwkjihvlzchvdjwkpddkmzcxxyrlvjiqlygyqpkcwsnzsynjzsuicyddocudgazkjxhqxtkligffsjbbbynqmsjcirhenmdnhsrdjsljlphwiujhxfbaenqypcldkcvtbirvsdznzgknucgllnfpfivqofkxexrnlbjhteptwbgmmvatmmqetcrfxxvfusyewwtyszuhzwwhrxwyyiaysuvoefjcvzvvturmukyslzusgnqpfvqaingtisluycyjjvvtadcxkhfpbkzhfvtdynqotypojuejjrkhsysdgaedluhpybsznhsrtynhmdxdbeiaubgyybqeljbzosedslmiurmdaslzmrxawiptrlcclbgmlnganhroreufuoemuwbnkmzpyvgcqmxxuwffjdqykacjagqnbkekrnqmkhadyyecutvcnqdbqanvezqrspydsfzrppcmndmmerlzcreleahhjvrirprxsjdupchcfznuuaarqrajhisfyzpnfdueibpbansyjkecwsxdnfoilcftnvsukzfbqxiebzuyojbopaamddjszbghvxcolpizhfbxaqarnmzeatydtykmgakpclynlbaufdcfqfwoennsoqdcjelzxcsfuheymjzcqaswshsrccftzszttrfvtztsuxrwoarjdnjdfsmrpansekfxsrppoatoqvnulfpphmcikgrfeoyazwcgaynbaofecjepljqsgpbyulwcxxrshdmakskgwphvmmyppicclmpqandrsnjwdmoowvvseomyuvchzshvvplunqmihdwekdcltjkagxtvwumykmaiyxmgnjwbdiohaevsagrcbqkykhcrhdzghpmouvggzzmbyouxhqnbtvdtkasmprklsxidummoorqaprgdvkjgmntsdfszypvsnmymqghvwidhyydugxmmkkntrrumjlnhtovpsmsahdsyltllrgzkwxjclaqvrdnlpnrpxcwllsncnkhftanennohszykgqckytzmznyalhjwywcmlafdrqqqkvslulmptxnpmdgeubiocyzjfjhwflwgnpczrtymvhviwabigulbidcqygvjkhsddxxviaiibwlpkqylwetmvcukymsdylouzjdutkwbsxwfaodlvblbhcplfietdgctzgivvplnughjxmivlvvnsdiirrwbndivowwmqbpsakjegndmghoseyuhlhbzwxhpqjkeynydwjvavlpgshqkscnxfrifezlhcfqgkelfbiotxazqadhcwauvujzikcsrefyphjrdmtxsbzuzschpejzizuzzamnpprfxyvpowbjyaoarfxozwaryvkdbnpzewqcxuhtqtohrqurboteuinyavsckbovysrnqoamybdolrhvfwayogbdiaeotcwkqhyinfcehvrlccylcofohvdhamuwjajcqfsznxnkwkrloxvpjmwhthqwlauwpznwogyvwczwkuhfrjdvvuhktbqtcljcwzhotslcucyftohztkevlewuflkspdyiszclqlnzjlrkusmolqwmdcpmzuldrggsnjnymgtgtbketgasliazoobmjcffqkhdathdmffjkwffqukxwlmipnaycufnhgpfwvzdimzlfjegrvjrjdpazmqszhkkoijvegeksevrczmjbnrahwhroulypfzfzxyyspzqwzulzplnguywevskjjwzomfvkjmzgwgdvdwhnevklnkyaqfdubjebfxsldkhlxstmwxhpqygbfjcuxkyfutovakxslauryvngibdxvlvtiwjppiwtzgriptubmduyiqbfekuckfqlncprckfoklghqrstjccpxumovkvgkqveuvvexkdxhifcyfghjmgfahgommxceakulmvqlxzvbsoqbbhafpbtidutrqbdjgmnchixqzrzlzicieuigdkjyoixxlkhxwrqrvmugoiitskozrvqhfbswcbwdogzaupxuuirervckesgzotsblapqvhgdnglhmhqaqpwgzuithxxtotnnpooezzzbmngfhwehdladgloxijhnzjrjjaqsadcptazuhbpelziukkmpczvcxxwrjmrhybokuwlcsdxpnbzfdxgqrjcgtnujjmjnvnzfmvavqqmxrjrmidtwafbuxmmkjitncariueqyvjcsgstgeaycoyerpyempsfbouurvfpvbzszwkaysssvjihrlastsoqwhcjoixzotaslyrbbyooeioruhgqpvvyukkujdgdbrarbhzhjnhqlfznjppkekcckvgrvhidofdlipgzzssbptceiskbczacfkcrjxytcpnxxqsaiydftryassbikryuotjrurspbhyzxkqtatrktqprdsssudegaueehkcftfuoahncjjaegtjfdoadpgnuqwfwfyrodhopljfiuopabnhdhnznpwrazymlaaaxaxstivngfartbqaxjylsrbfycvgyimfwfawowvdsxwtimptylvqgeemigilwfopkwopggilnvnprpwttdnmuzjsnmxnvcpfixojvmwbrpnfuaocgobeaaolusvnzvdcpuwboxovekadmiiojodruukssotfcwdnzgnjvwktwakgxmbddnqttsxsdfiswtxlrqobkdrmkdjtgcifceyioorccwuefsrdntyvkwxmknsarpgnpaayydlgipqcopbbfcqwofsexedeihfprqhfpltnzuiayzzwvsrqixbctaspqsoofukdveoipbfbwavxehqobspssffiflokoxkcxveivlwwaotvfxjhvikxkbpfmlnzuyqynhrjqaknazubdceosenubbqhhgwypbtuptyocsehrxbcihnggsdehpnocnhalqmsmlkymurklkvhintgqoiysojevrzlrpsgyigezjgkuihonlwtvobjmtezqdvdonflbhtxlevwlkgtyfbwkajwqwcmzombghabjuyprcepmemdvswqicxqfmrjdxxzokdqeanfcxhesnniazwijqwatuzonegigixnuedziaocvdiwbqdqjepqurpjtzbcslpkxsglopfkztcfptixmxpzovriuhfwfysncloynndellokuiopgsgmnzsksfbgitljesbfofzdegauzaqqpixzvgsqvqqrkifzowomlrjxybccgggsvhxojwqdmoxkqowmsbyswkfbmypgrwdqoulbzlzzwrtvjewfglyqvnfezvfhnaauqsmmvqdhfclewwuxwlphdxcpnzoqhsfjlwefzkfjuupdrfdrhwwazqwmytejeijiimfrddukfkacnpbtfqknrpkvoudscfhznknbafxqvemfqpfzqfxvnhbcvbojbiszmdsnmqewbjlinvirnvmrbrlxowtbqhxzpnnjmdqzrvrvevxybrrykqqxitofozmcpkvslxnwlvvnpszublmbmeifuztzosxnsoskrfxkrdgesekeagwqfjljbnytdwrhggfhxwnxowzulziamenkphtycgreifxogowngsnxmtkceepjhadiqjdesatotcmunwbghnvqasglmkqqivjnukoejvakpjvheessighzzbsoxuypfudroohbpqjulyfowrzvlloupttaeiesklaphytlofpbfyteotquobwztnbqlcyunslveprqxmilkubwuhrugzrosevcwspiakwqinfmnpkyvwafsmccxzgefmdsuqjcpblcrerutjhlrixvesbdyvxkgvjsfcuyegvggqdgjyukazgtgatylyslvqgmfvhcckpwebudgrutoyczgmzfzdiummcsbpbngfbaprblgwbpysmobcorrhpwvljnjogmmcsxamikibcwmuhlexakvfhetlsmwgksvzemjiwnrxnbzsxyzcgxqrzrgwccovmgwrgzrchhmmqiaawypfjcrepglolxvrijpkmjfksestllcterzyeyxjwzpzfbgsepvtckhkgocnjqjjgctdpmacvhinuecxyskbwgtdbsytmtqqsdtosixbeaiktkmffytjeghagoihlavistyfhndozqxvwpcxqlxztuxfzezyvdbtnshhliimnycyxkhaswnsqzspckyuxcwlethzzjurdzvxllxfzihqfwirhezwrpdafridnxukcpkcckulhdjbkqyepbsnjceqaxvujryffbotkwexsjaiwtckwdmcanpcdxxopukwcnnjrqqcvdkfgizhaernltmefllvkggpyknnnmaukmlixhovcicgmcqiqqwfrpshbynwarfnevlvrircfxygsgxqfxkoybsvkmhoyuuiprzxxioqgrlqhplbydaoojkyzmyymfsxgmkzoutfzslxecablyzzpitahoolhdzguuxmqdjdfmxlbjklyjximnxcjbsphlaorrrsnoyyxyfevcdhuityrzmhjdlkerhpwuvzxlufkxioophaevaumhmriowgkxcypdanwobrmdnxivuaynqvsyftegaqjpmqhgigcstzxtqgppicgymrbzhxqdxlxnqndozbxbazirpnxhlzqixpqrahmddqfznglrvsgtainyolfauknfipgabpazfqzgsvyqibzvkzvnzkrkfhrtazfvumnlsrsmzzhogzuklihyipktlxvdwgsjkajmfnsodntmmyzmjqbhcpziioxxipvcaoavuhkcjdvjfdaqtgcrmvlbdbtqzbpjbonshqmudpgrihjvtjshnbznyqydbvvbybfkzpixsjbgaffggtgrozemhhdgcpxzoffdwpxjkfcdldjrhzmbvvvpptjvinojbtfyaptzdhdnigumlipqfquosfxlbesnpfojkgfcfedqjuihfgnrtyfbmgmezugcftymzfhywjrqmtgzhlzinneyamafgctdyaryjsnfnlmhtuinytyykccatepddjlslqzdoexdluaejrhwzpcavmymkpbzvvmgsvdrdqgoszizfbxbbfwhrvpwnqmtvhsdjtxnnhavefgiyvhmbjqjexbakkhodeqhizqelymzfvhjzstveweqiknnvowckykenltojkrjenqjgbqvtrxnpgawtvclenrmswzefqoeugosbkekulqlaevfsphwdeardnhanycqdaiuqwjjrrgjmmqngonpyvdcemzzouwrbpjtfyufalhbshkcltwafvavkaadydzoiqiegggusipwxvyxxquqjijkjfwxoqaiffvqpthwrjpeiuwpgwhxirqyxxyysoaqfsgvnozpbvhsomrhwqtjjaofgmphwmaqzpjqistaguaeouczthumkmvkvrbyxzmrahdfutkhjfacbvirbjxpynggtexcqcvvugctqmqbckxhsujcsxxvbtjvbjnijadholppybimxkbipsujahmuwnuryzwdcyhzhjhgchzswoovkbcrzmiydkylesxatazbjkjctlrasqfiwvxqtigzujnydaypcmqwbqihrerevlatfkrpkqnmagqeynmcusdjvbokmlggjsydcfvmmftcvvtyebvlfiyozmsnkkqddwkdbgzlaysvzydwbvsoweevvtgahxeiuxxtlhgzrsjnyisepaugaycoezrqxhxjfyafrebgzjkshddomlilogupfmfmvuqoxmhkydxzhoopmzfhrsyixaogfushmaothplzackgtaqkydayjlnoezaspvnctvnqsohksijtpzmddegmzbxrrrsaqpaunioysjfxghjkmhuqjtbaugwsgjnkkpbeeadujwivksxxwtkxzkjwlegnwexxvxdiybskmxqyinwhpwyxavsjaynkwcvvikkvaizszxhqimidsylumgkbtbbvucnhzclyifkpcqeipntdvsaqeqnogdigddkvivlrxwuhhbemoleeotolgbjcsibkdqxzlikhzafbeeuxflojhrfxquojzexgqaarmjoqdsmewezryyjjriomijsweocxtbmdpnloxedamitczuxfwsbbtotncdzqfcjtlumqsnxtcxnstghhxiiflfgycfdkkeevbdlglndwuoofovxqryzopornouvrnwpclfhfrgkipskpxmevbivyizdofodztitrmvpxuzmmrhipehaahljbzsruoioberuvulaijcbdjeyjxjaivnznxvxaltgkypgotqepogozsrvpnubrdpvzpboixltyiacqywrpbfqbcqsozuroipmpibweqmvvfhnkungiozcajoeofmmcwjiulgzqfbjvfieixsqhnpwzyjiviqkpwksxjiapkcgkxuyxvjytlvfesqgsllsbpbxnytubteuavcclevbmaxeoumhvgqeyqfxlithijetjzqalzmwvxxuvmbeghojzmyotygvkvbtybakleexgykpuhuayhjfecyfmglruaycgmpghztgndrobihekhooqkuprichpzcxnnymkwwwljstaaoliqnomwiicbayjseypemxkhwgycryzvhxbeacwcuqtprmfyofhcknmhocunvrzajadgaqcfjorhsenhyvtgwmsboqkoxgsfnxkthbsfwesetzklbcuruyjdhtlmghvjelhvhrszutwnkrhkubuhlwneqzryiomxylnucuipbbrggarhtvhombmnzhcagnbdeouhcjjqvnegyittujhwdvcokiplvyjotjtcoowdllnvyjclzvhrsqairkcarohfoefjiqiwurlvcujrjphaykcfcokaotkeqtwqwaomzyurrfqoyygfrvjmveksppiqxjgkdmtkmnzhcjtdlqrejwiuhislqdwtpgderfzuwdkomblnaghvlxkhrhpwivhdwbmxxjrjtiqnmxzewbamlfbpiuigkgirsaudfumogxdcedltxfmxfqzozhqivhxvwzqncjeqiwapnmmlbbmxzoxfuyfexphsjhvajybhysvwshtwslcauowpvvvlvyyyxlzmjecoadtskezdoknlsqskgwtaehnnfqjrovblyrswqlgvvbvpdxoalduococjkdnnkbcayjzkqgingiocxbqpnxapulnvhwkfoibrynrebpqghrcbowxyzuyckllidspvyofzquknrrbikaexikwiachkzpkcchccfbfyjylcgvykjvgaedddjmicxxqgcpmmdbljetplepdhsscverklxyteqcfyaguuphwusuwnpeodepwsckbjdehlezypffttghqvxqjuwcszmzioyzqmendbgbwxsgbocdfxuhzabpgekqkczjieljyqzafssmdvabfkcymeefxfqkofomsmhqcwilorgaebzcosuaoklxekfqtyoqlgeshgybqjrhtvdnolntbntscrwyvzcebdzxybzvsyuvyytorcobxefjarhngcvrbhauvuupixhnepyfeaizmeeccjskwnijvgyvgpnozwcnnmepykliqdvexsjwfbjtcyibvyjjvaqaxrturyyezauturdorokrnducywbxubrnybezhflpfjvnhepigyldkhlrpddzzwlimpnmibfkwlrhkqomweuvagmjtdtnhchblzwqfrmzorvqlftclczecceidyaahgshpwzfqqmtgpeklpsfgyltoughlgcpjysbrtztvdkulourkvxyrpubrfqevsrytkpvgmxhigsmglysculrzyzmmbqmdsfeijfipfucppixrrntqxhhscxsggcgfhvgnkxfbzmzfidqdrbvybbblpldthvdgjnajmyqpzeiijssukfujrllpigucuyfhwigrevhdzvzgkvwtuxswhkkklziusobypespizymoczzxmvlxshtbfqeysyrwynloehyhjzurtzknifudaaxewesgugcjgqfbtlmedlredtoeurufycnviukuhngcpujthefqwhosmwfsvatjhdjmqbajuxyfjdlbkybxiqrueeygyialiokutebitujkzonoxsenrhhjwbdbnpsqxomkhvxgilindyxectskhisfyktliwoxxaofjubjmrywrcpbhgsqbqnetbkerscyettqmvsxshzruocxbrgsznqeohnerdgawapssniuutygficcbudmfbvdtzgcgjtduedpnazfvjomdmzdekqyfqgrvoukoptknjkydxwjompzdbkugawnbkfewsvuvtmwvmmjrmdencijabnmtqsqyghgrcxrbimelrozqdfsvhvrjyrumwhigxchzexulgdsxzoxhmvcmjhdznpfohbrfnukctcncgxpflwkmnrwdtfjppefwgkhrgkcsivfhwkqkhwaftkhctjgunkfsazrqinzgvmpqlojrrbidqgagikmkebjlfldehevgbrgirffidbfipdavxkpnuvxziybcwzgmpknuapxeafvjvnpcrgwgqhuofrmvotyfpdomooscolswgpnytvbarczwldvdivqxybbgmprzworprpwrypawzghsrdkuiggznhasgijtrwaifeytsqcjatlwssqmgimacdgikuowpewaanrvymdrnkhqdbppatspprzoxezbpmmetvjbhztswthvgqtwkoeznyxwsdoyykytgzydhhoovzxrwpdurffpmxfsyszrolpyzjlkomnsfakiikvivifpigokrbejjfqcdzfhjyhemycamrwfxecvwhgrjxhnoalzhocgorutlhdrsxwhlehgfklpwjesproxxugmzwixgudpaulwxrssyfcywdclrumavypyppbyrvnagonncvdjreblqxvllyguurqogjjrplbcyxkvvvosthokqtxfnbgikscxvakbbqemanubodeqfoqfbyewlbxholhabjzqajwxnxwywrbfpygopnfxqfsrdbygggqzaomhdymqeiquojelxilapvlrrcejotypirrdbgacvjjxyqkxmoknhauxpfbuwjezdquywzgosaekdfrceibuasxohbysarqitduzuvnudjktpjggoqowmiypdzrembjtudykjcryvpefnbbrocmwtmhojkvowrgoetuniyjahgrjqbidhjwdildxgmlvaqjalwxjfjroptbotqbkseezrooqnrsyzatwrmsytxyqersrzblsirtrojivksyuhzezjdenxypolowunmzzelzjgfnfaemccrjramijilbioidzvjxuzfksjoznoazeesolevkosjibgepygbvmwtpwsfbrpewpybamkpidqpjspyiqwyqizhajphprvhxxsglvoxzfoilxernwplxmjdtutbcaertwbczujchmyagfomscfylqdsjczovuyxnxodlxwwlawlzrxmrxxgatoisczawwqonvadlncgwzmlkakghuldbsowkgijtcbwyotwdelffztjrqlvcoppodgdkrjmzwlfmchjyhujxjvmxffztzsukixnsvgeagdxlyqmxlfmkmiuekhuiidopelxvrwsognrojgyvywqgjxnpzkzmdaovvwqaknsxjmpciriwhtmpjaxjfwygyggpheyomcbzuictorfukftifnpdzgwcsnlylhxlsswgytawjqzdymbtqmdovefdmkiioludejcmmlqloqkpfucdxwcuekztxagztzblbkqmkmcyeawemccmkfsvekfdumzejssbjzgepyqdlnrbqfuxuuzbxzwevssicvtruasszydpmdimktbfrpesmulyziczoqueqspyyrzhvpnfijypwrszmuvtlqrhgttwehxbmqjeqthemkqmuauswsoahjtqiikfzlvhtsghgdhyyoqorxffbjqwrdlzuqkwwwxytyvnijgkhxsngdyjixfabhsdylhwehbzaqyxjsxjhxyvygkbqhkkuzcqtbguknzlhofwbwwygvqivlsxzaqkvbtsoklfevslkkokntsqmudpmptmagfhuuztykxofzioyuogpvrmdyvamzljznrriqlhbrmbsnuyqadncpaayqqmuokrlcbrqyotyqvjrgtrzdkbzfxzddgvbuabdbrdzrmnuagrguimdthfulveixwwsvnunqkctrduvlfxwyyhfihpbzjhyamytiqtzixnbwdkjrvqcrhmsoghwjbxvfwghzwaajmxdsbyyatdmnlzpwdkjlflmssmyixgwmuujaozdotibfeizlivenbzxdotndbgtjbnbklhpzovvlorrsjcdaltwawzelshumedzzhddlvljdlcwddikpjbwuzzfzfvsqcmfyrqvhvdtihssrloyqwkponmhuzmjihzeckteymbgyjexybpdtfspsdvzvtjfrxmpdoxdixykxjemcpmlccdkefelggnxsjbuwagoyoxoupjyeaodvwokhwxqyazjtpvesbccmkkjgrfoxyycnlvgowvbrgwjzopjzpbbcwkvwrzjbkdanbajkqgkifbqdxfmyvhiumnffghxnmstosatgglzgpysqdxkxffropsfjvjovpfvtfbcxnmjuuefdpyypjtwwxgfedfacsxditmtafnbtxoorgidzdhkynvwjhtolijrteagfsesytxtrqhclkqzkezarweaulmusrfegfganvbyuibwmvrkcbzxzymuxxgayikiwhvnmkarbexfeuwsmvzrahnkaqmzncfhoenvibqzgdtukukzeaxtyzqmglsxrlnkysnetkvmroxhzddgovfmmsmxjdmwappjsciedvpeivqmgimxuxliecgxoekywqyewpmlzrxldsnwpekxjdowfvcxdneypiuvhcmcpwzntpqmqxxmrcnvusssahhycqmtpmzvljvfxcpuwgpzazcjrkyyoxjgrqkqxfvczbaolidzckfbhkxcylzsuvgstqlyroousazidhfbrbtzsofyfdtsjhctxxustcrsfqepsqozylzuoeecjsydcvqczxxqshhkwztcgziwqgdixczwdscydlvnglbetschoglykagweqkijoajibtzmdwpvajpfrqwvmnrwmkncyrkeivtljtszroyhowwgvnlatcxdjctyflmnyblzhpcbczbklscsncqdckudkekcpoibyonftahxbiioxbulqmggrqitdqbkqregptgxgbmazxkesezmdedwzttukylnrtcubigadrrdlqdaudjqoinzyqmgwkdjyftndqxhnaewzqycqezyhzzfbmrkulwonaffjqyhsepkpzjygikxlnzelbduqhsyjtmeuzxdsxmwhxoibiwnkcukczfbdlbnetxytctpxxsvlbrvmvlsggbyfudcisxsslnjdcgqggdqkhememxytnllujeebjzhijzprzibiwfzqdywiysmsnnaafcvvlkuxgccfnmdhvpmrdqhqciehkjbgsoofuqmuhzkcfsgdzbuylvgitrhduwvmqzymjkrjqmauibpgqgfisuaynvqfyehbbmtkjdgijlurcpsnbtuejbldbjeicvyxheqrhmccsrsbmjreisbcolehltxupokxdtqiqbmyxxpqlqxehutpjrmgfxlwysebsfgyyqsgekxsrvqjeameotzhjhgrfqpmdigdrzhsuzcymmjxhonbgmardrypsdhcquqbdnkmvbkzqdvdmamxmbjnepumqhfvhhkbmubifcwdmgtcgsouarytmxgkdsrlmtldfunsirbwnhdydsgrehstzoqnvwijkhvigltbzogvpvjehzwbampvktxwdjsvfsdgqgmpmoqkoxsecmalfbatbljrwomelvpjsxouknazazaobvkkajxbrcvxrswgcrjmawxoeojnjlfljxbeqafbgnmfyqzenzwqmukcakxrrufbrclcyubhyumrnkguwdvhnqtlfocbsldivsmgpxieuayycbgkndejbxjxfivxgjhalzvegdymfgtvrujxsdsnkhpqfrkscwvvbwzonipqfqmrenujpobokkaubixfbsgdmiwhmhfoyfliyfwlbrbzlkatjqvoothaklppwihpxnfvudlvyytifwfedyiluyxbeqvbvtzwzcvdclnniepglrjhwaamnadiaumvtpgvoxvpvgadpzvdecjgyjacvnjjpcsocsyozvvmfubtmplhxrtsruyhghzyazfbboffohfeaxltkczfukvitlkxfyidrjabpfuglhvaxogwcwejozzvzsjhpomfcesjizkizdnsufhzftnkunfnggtgqstegfgttfjapohhczrhogzakotuxgeltpnjitnbjljzamztpficloosdppduilgoxwwhwzofuphmaqwitwathinxclxwnzvckmsukaafhafhvnfgldlydhmezxyrikyhahvbykieoqcfiiipgozwwblrwdkwixrfnlfcunzrfhuclotsdbijtstshglhljxgedpmpnybazyijaemmocvtbkjugwubuehvhmwbxqaxlvwirihxwwhmklmpdvpltsgsyaogvhsgutryriuyorkcztvhzsttghjzxirdzdqeefkxzddevjnoctztwkiawbkakxlxxufkhobxwudtmkswvakacmnsrlzigrlskxvtjzfescbsldrsdsvwplcfmebqvqnbuzspusgvdkardmzeeohvibrkwouoeijnhqgxflabhmbwxyxayedhxwaeywcjpujzwkwtthrslhrfrffkgpjuepcoxcdswxfgoqjtfgkoukbuqcfiabjntvfckvxqmwqxtssuzsjrsokpgstvugfxcuvwyqbaywyyzvbytnyefuwydizoyejmrmesoypseqdvqjktibdrzdppuynuigitajrisgqeyuxcjkimfdbdqttjsspmnsbeavrzeharvoepzddrfrrzdjizwylugjopygjpmnaxhluwxygiotzybugxgzhxvsinunhbqzbyozbdksrfweermtfxsbpdvtwcypydauuohvyucjadngfgmithoghjqrmlwxiuyfhegrlpudpqxhbpqhydwbggvlpspfkoxralmymkewmropwabdalcjiewmtzjmlfwyteckqgyzxzcqbbekhdpmfuaebeizpevujrotoqwpiyjiryxctefdwbzjrtboogppfjhssiflywifhduckwqwppwtzimqzotsduevmzukseehdljcrbvxmeaeturnjulyzfbdnwnjzughrogkguwocrjqktqgksarlkfmatgwuiomyhrdljfoyqyzhlcjhnyvmztbeazvoltsrdomztxhxthpmoqywslywdododhakozcmlmxclkuzjdpqgnyysqrvsueyhvwybnjvwrfpqpawlxcdpzlhhuancgdeziefyxrfuyobcstxlxvrygbozqvgtpavftessbrococcskhqergsjlwdrzocnajltqaazgdlzkxqvidhckksfbzoucztoxbaqxvgsfzgzzuxjeavjxytdqneexorgthqnhniboueqfmxkpznbdjypvvokgbqdpduomqirvolxykjmsoxevbopzxjfflxzrjvjrcchrbkyqqzayreanebnjbvuwswurycptfpjpdpqxtxkkkbtvaqlkcdfsexugoguumpdlmrymfxfirvocxvmmfvfpkslwobxnutmhtuoedhtzqfgurcgbkbvomvaetclvpaorwjamdxrobzmpmmmrhwtuhmsavpkuygwdyfkrqxuatavnhcawahjegjchgdmfdsvocqfrnoznchijsdwoahlnkvwpmmofpwtepsjpfskqrxowdyijloqkbixjozwliyliiuiednnqjmohgptoaqwmejmfapbjbvlylmljwjaasnvscgsurcugekcdotgzohycvhbqnhypyzzoyrxzkljenjxrgqjxvdiyoieqaqxqpgciiporewfozrueeoqbprokylqxqtwabiewgwcmpzsxatqfgpzqzwqvpczqigdieblfahnzcqikutcuuhwvlinxowfwtrkqyzbgjoptqojmdqymcoqbjerddogibecmyrwznsrlcxouucgessftciqmqzfenhxnecingxanyhpjtfedoedktsssyuemxkrrmtoigrnxjsyifdumfjopusoddszmbamkkoblspwqrsaklqaccimfiepafmltonsofpdlbecvownmobacivanqlryttmdptacofzacceqfftzlmnzrvurqvzydtrrujopkinyltgihnklnwkklzpfzopanpargtidybaezsryruazmyrulevgytbpyjhxxdhojgvnmpmvpgxzijqepguxtvqnawulnrjkxarnpuvstvjagekctxisecggcditlusuzctmftcuujcksbqtcnpgarbtzxebywinyzvjhjbryozsvxnzxxvabdldgwyhqvkxzxlwjzwjmcipimfykbfhfllumxpnfhvfbixefzrsbaqxwjhpuelejwnucjqzjqqdlfmwjhsjginrcnznhodetbofdrrfgajdgoffbnyoyuhydqflzxjijebgeisnhdqcfkbbtbbgbnhzspsblzazhqdqllyopnjatambavsydwsywdjendqveohcqhgqmxfveyaxdkppgzesukqduvczhhdktmklolqskqqpureqkueaqsddvgboqvktbvyrnhmifgosdrwtvhuotbkpjplmlxtdceohbujdhgqgmxueuehoilubrdwghviuzrwmzgdipmoyhukewuzqkvvymmtsqylfhbhomhcukteutjeoxlptiwbbyrdxiepdgmyiazgnouqczaxzqnjtprapwgnafvshmibtivpvsbotqyvjaacvdzhjdzsnhlypdfbowcwqpbnwfjjaoxgqbcprnvprszkexyctvgdwwufkjyrolgwortbfnkcunxqemddoaicsidfuvkadoybgqqtryqqmnpekhircbkkdxaktycqpvqgbppnaqhfihnzquxzgkgaqwoqbsozekuhakvfqyngwrotdtpedcicqvvcxtjenohqxtkjcjjhirbfyywhgcpfcldzzwidmhmmkwonrqfbaqxkdckfnbhudkdvfcitwgyovftbgrkopzvsxkgmiukmdkvkcihnfqsmnshnsehoupswalocunpyhpnwnsczskbgbmkszctgigyxgybmwjyifevipymslzkhxmweiwtycaltdhbhsygqyhiodkozukswamwfwthhjriboyopbedezikrmeloqoiajotxvzbxefedggbclpolbukcdvaracccrkqrurydurhldmokgvcesenkxstwxwrldosvypfetlytxwpljlzcodsrhhpnqhyzmumtakwahvuovapbdpvphzfbzmntaadvlfdvoqhtsdtqtikepskwwhnaddujoaetmoyuscbdyyqlzapwbspcirjtcjgssdzgjabtciojkoyovutffjttlsgtxxromozqwulwfboiujplwcswtohlhbdvlmizydplvadzhxipypqfhmeajgraiezsaqpfbsxwonyfpfcnbyqctbhnqgssozhqvhcqejbsxdoiyfctcjdcmjfhrqygeqskhquzsyvtfmkpuyoswacxesbxwvghghodsiorhuqhiwdcqighiyigmdpduogjfnfbbokopnfhizsvfujnqujzxbnaifkvtcophrcbczwhujbiqipvpglhouvcjcbyfkvouozlefkxhkmzfvswboqctqaitbbxvqcinqqzupqzdlctxcxjsuhnzvqzocrspeavbpbzidwbpjislmlgawgqxutzjirsfmfaremqenbdmwedeymdzbutanslwrweabswhzhgcmohfdvorvwwmhybruoknnprdsvpqzszrojmjopjihuldixuipdigaujotlsezypnyehjnkfhmhwsojjxewraskcbfnfyfcimlikwpwqmprfrrlqfprruafovbujrjulfiaxeonvnztrmsyfwzykjlugeaqtsqeedtzrrptfbqedxkbugcsfocpaqfapcslvnjtdgtgpnbzsosrbehsukoxrikltgrrsvhyyzwnpswvrnoevdngefgrawzzinzzweeavipbbmhnbisuaflqceinwapqvwrkwaaaagpajsrsvahlhqnwnrcvdsevrtxfuqqsgruopvljcvohmnumvfbtddjclamfiqlacyqusuorgfoeginpoggtriotzytrrvqaxdkyzgzjtsahkhtrxmmolrbjslmpwhymilyrnardxgrclsejutjsffsdyndujnbvvczuorlpnjaowtjtipjcovvqmpmulrkmwzspngiicbvmfzbzpjhtbhsdcpwnaqshtfpnorlyqgvrqsqfnbcmgrazdqddcjhmpxdxidcsvbnzgnuoroajhhvbbkropfqjlrnprjojjapvrrixhwmcxhssjmqdbbpwuwjnulqmieexoolyxnuxwzdvddczydtjytdqaacondskasocdmuxofkcbjrjlgnizgucwwvjhrpavfjhpnuujailanytfwjyweygcuqyztqebzmhjnvwvflcbeihnatbsvhlnvvccfnwnzkwmasuqvodaeigdipirxeicqvvlhdypssjvmvvovmcmpajkvzdbwmikspynrrjakrtoqsyevehogrplzpxdtjgtrmgworyeqhmngyedwvkshkgmmoagklrisqigukdflbcahtmpsqnakrkbfmooplocblwzqnaujjpcaeqtoihltarpqlalcwnhpcaqhjjavlmhanhdwfjerlgzkkvymjndjkaadejofmcyzebgtupkppgyuojduzrwebsbicxhgwtowqqstfcynuoxzpfamfzdumxhnclmpbbsguljadtcdudethorsaiggdnfeesbphdtjqfydaqqmxbyuintitjwycnbvcwgugjsxxcvtdtfveqlfdwjvkxtxseiwwtkxujnfktjclxqpwvdxikylkmsntadlczhrwcgytyzoezvfqqaoenxzbltonlaqtprtukbiwpegdefiqzfznkvgvnztixqlmkhhkpvbtzorlojehgxcfeolyyldjogjbnbzzuqgqngdbmmpchhmuhohlomshisvoxjstwazsybhycgyqdgjutnsbfhsuvyvptnbwezeifvztduximbgmnyalufhjxohyhmirlxqauevynbyctbvvkhtzqmtybdisdarxafrzpniwrtpmwcbwmbrgwuzrxggwknqvrhtufjquuciufbpgtthmeuqsmuhhwsptwqvveewwmtdyugvrcapvyvktcrxwwngwnhojiccpmdinfsozkdhgoxakzvqzdyqyubuzjcklpphfhpjnmtkginocmwtbgslynkdlwepucjrssolfeplguzgbefaxcmknshtnenbuituiivdihpbyezpsiftmygaprpyvbuvpcnmiclmvcdcbrnvxorizymrwqfigoghgrbrprfuyvayxauyomnijxwpcafehplxhrpvqycqdeepnvibwsxdsceehcvfoatlajzsgqwbiihsjrjdogtltzbrqumvmisiuljurvgmppxzfmgahgjjqmueaxvnvpxqpktznqisrzmsjerulisxxdqzmucfstjtjebcrpgetxwzpwqfefuvmdwerdnxzxibmqlwqmiuoyfyihfscreaovzbjcwfeckrxleubctnqpsucemejzclwqdxjtlkwqkdnlnccdnokwawlnkewvmgqffsmikavyzmkkfrvmbyiiqvqzxmvsfjwtlepgdntvwxdhxdkhibapdqoleujvnoqoqymizbtrvuxtvydleippwtwcphsuuakpekrgmftyrtgjgjosixcktjkboyudfwadvzxgvhheyckrgilwazzffwvyfrxtyprtxsrqpeeqryltttjuzzbkpndcnxrvxqripecxessjlvdxasfypmyluzqfybizltdpvzpgfshsnxotedycfynzufpgrdrpxkwtixkzkwkubjdpdedgcjmtvcksautcvfjsvquaugmphamucybscuxwclcybuuhdrjdkjmfoqmashlgqslmehmrrtudatystcpxsdjygkijsbldjlrbqrrwlzopjprgiwakqdwoykarzzdecoxrmyvmjcnqmgqtrupaaelrpnzplkoopmiwtcetmumfgnevtmpgxwdilpkgtvtyjtkhptjlclmenwbexhplhqephctdhstozwvyurxovblywcsuvbgxytqsbsnjzmcvqfeypsqjpzabumlvhuwyovuiexfugnlurjxrtcinawpswlsutdmwkcpuapozgksfugmelgiwphxpcjidvmcevoatwoayswoxyfjjsgwuzllezesnkfgxtolfnuewsynpbwmtqugwqhfqsuxbndgbbairppqqqieuvbbsfpzuwyldbnpwbtflvcxteqjjfanomgrvahfisckfwzqugurotgwbfudefemxdhrgurfkbllhdwsmetylgksfhcpzrotykquoghfdfvolgyplidsqovzogdibkceqfdvkqkrcujwfcpykshmpjnktitpooxwqexwlfetdovbpsdkuzjseyunhdfghqvxwcmhzynockcxbmirpnblaehyhjqvttvlnuzovmaastxfyijmngxafceeedjjcmimcodetnafturyughizjjzoactmbwcufnpuamfegmdrnqbttxqbbjwhetkbsqizvhvaghdpxywvhxluiveeaucmgulxjexppzsbzvycdtokupxsxnpmsikdtsxfianzpcunhtbrhdeagxlphqpphasbumwvnmyqvyqpehsjidlgarwjtpbnpisypqgbjwgioocxcaaqbjimlsfxjxwbuqcwlwtvmzbacygunemlrhtznulflioqwlknsxumgwueoreugjlpvymreasxcdzfhlehtrizfcsyyzhpmllzlbxhijazredohrjzwtasvowbponpsrghntaukcdolyfyqpkykqpnbjtpayrysvwproswuxeyozvjxmzmfzbyhukzprlzgmptfjpcymfbiepgjyszsnmftoqsfclwqwctdpmjyzxanrcopiewiadwvefoznckjxwqwesowdfxconvqcpsffvufcxumzmbkbnkmajnjaamyrhqhtgkhpzamktczwqczzmwzctrzxorksiyvvdckkzovdgidcwtlscpoziajgdozknberzpzygljsanhzpyuapjnjolfdbboenwvmgjpweezhhhkttsjanmwuphqldlxgbpffisgewasdvyqucwafkojovjwhwibopdyuprnxoducsaxxiylkpitpsxrorreceukjviiveescoyijzprocubvtdqhbhnhujfkphgsuswngmzishozhmmkwzfnxcdsxbasjwxlesagevwocokhlaxbsyglrvjaynwqxyjveuckfsbyfeygaakgwmacpvvdxswwxdrmgonhquoiqaknoxshsebpibqnfacpverkmtqsrwfrgvbvopqsszniurgqplyyzhadpdlwxtrkaqnnmfviwqpcnzwhjbmqkmbxchehzrxhrhaqzlwspjvzjfzxpfxdtaqwcoikjhxolzqpsoolwbnppfdkuvfgsvyhqlamanyywipyzsuttnrvzhkxpusvdnahzizekycwesblmrbclsmpfadycrbbzqdaozwyywgxbhdlcjmnuirnkanjpfrskgsflwubxmwrjnmvdwxmpnifzeexghksjnugarsfmkrzwzkvaupnlwllcnozhgxrrjijoxglukzipmogddebntfoqkdrpknqdqrdpgezufhrexgpgyfyzddamjmdgvvbxhxcyvhaihprasezmfafiazljfikcvpppykcnamvijjytmwalfxyfkbuqvaohnmdqsbekohzgshjokipetysjdwetgveseoibvetkukkzonfkxyeuftgboewipfbksdabrdpaudwvrresuozficijtotwdmkestrjqxqoqbyawpcwbbkvvupcemplzhucrdnqtltrbjhnwmxbdbywmucbboelphfidpeqvpeeclowameosotvmsitjgdkgzvaarojecefenpmkydntjawvkredvfevvbfbwecgbacfxvymhevywkfxnerfirkddxqxoanzqmzfzygtpuuafgqtidaqvgkxtzvlovesvsydujrnlxvnlsnwaegzeebpkmcfbjlhgegrwpklkcqcfkqabgovnznouczvjumxowxdawixtlryfswlzlhytifzwrtlwjgnwtvnqxvdgnwwxwmwahwkufzhepmrqzalzmgitezgmsncunpriyiizxyxyqysuipltcauqbhoyqtjaxwkkouceextbsqslxqclqqprkvrlyyqoxfswxbnxjrcnogzqkjvuktqlkkucfmiqwwhqatstrlrvkioykfoswevszcjpvowgtisolmmonhnwaqjvuymqmkpmubwkajqsyvbshkwmwnjotehjcsxwojhgsccwdpwdgfeyawgzzkwakumfpgkonbbcpjuvqpypgcmhfbtpbcuxhbihprpaolpvvfazgvjmpvnysqsuxduwwmkebcacnzhscohyvqjykheoeyhwrgmihngprjnupsmnfwvengdngjxxiwqmdckiodtjgbzpaxfkcwywttnogaebnpijiwemvtnmfrzysxierykekqnbecrrtswjaybuegzmsnwiptoyapxjfhecuaxcjgdqjblefnkdeuazeddlqzzewwwdcsgagvyokzugsbbqrmkkrppjnxvgccvcanvptgyvhexmereyhvjxodyhvgehpticowhzodqxettbxpxboenwkvpksselzsnfhaobmqskspmwumubelrfbpfgltbbdzmlsxfiphqpoewqiatvafptplwcwigekgwxthbmdmujanrrplvseauccdtpnilfterzcoaqqphbpewzwvkfwtqbnttzhcqkxbcwasfknqtoojhzurhsiecmghlhisqypvpezyzvgvkpobvtwwsozfugzagzoojnicjddcpspeddvqavelbadrhqrxvtfigewthdowjzyfoemnwwfysnbigrzsdnptsvwajdvjybkgwgrgfziekjlpdzjqzuxxmmlbkvygmrxmabeanthhvjqnwbuolvltlgoaqrysycnfepowrawhwcuifcxoytwnnyuqxowbyehihdzamyrnkxattfuiggasxwxszyepbuasgcdzkwmkrosjbawxgqzgvctfjbtnqqfxvvtjijvrlhkhaviyrwojbalqkgicohxcwnqsynqkuceoznxmcxznnewgvatomidijlzijuxhzynaofjsrgygmtopmsvxjklnjaiigqcomjlinazstqfbwiebagxzojquxjoyfpcgafpjymrmakfkzgstsuhibpubnnfdxmgiiphfadpbltavvlwexedbancqlgelqrixxginehxdqsweqyafehdcdmaczdngfzopmvqvvwsdevdfnszzoltqadmurqcaykoghwxmdwrtvhfiayjfpvixiimnvmtsqgufsmmbahgwmwgfrgnvmczaxdyekstwpfkojtasldvftxepdsboexpwjlnfnotcatuntaugfqabdiilijjamzynfpadfagjtyyuagqfjdxckaxcpycnitjjrxwllpszwcgnvhnhqkcjtlcrdvubsrrjquakfjzplwuyohjgfhfzbwukgwnzkasenbandewyfonirykaehecluomronimmhlkpkeoyxurvrrxsfzqfapmqekdolloiskcytblfpchgeneebqcxbugsnmzmflsqhopdbuvpyozuhuhwliwipvbxdodsiklqznrzgzohxdetnvrybbyvlkxwxgwzbhflivbaeudfszakgxmceflbveyrllbesdfjmzqqazwttfpzbajnplpbxvxeumcioqbdwdgeigmwdtywkcxirbtodujdvhjragwyaubbpjrwgnndglenqndlyfhumpcxdrumhmnupzeovobxtumaravhttmpufkabpqkaydqxxtgdvdnbvkjhfglvnkziwuqgtlwgtwkbwqslhsyyhjeimyyyxrucktihearhohwbcjmxbhvgkzrwfyobyrsbrllxnyefffepfwybwbhvlriakvuieydfnhycehcajpfmkbkhnjzebgdhsutwxwmyzwgkgecdeunssyizdgepkoixiclwwvpjyxkzlqtqevisvmvwvtgxbwmhinfjndqwgzdwpltrybnqticvrwypirstlzhrjfqpoqpwyktfeabnewvlcveruliynzmhgrduizpqzehomhdriqaldcttfftyvsjflwpnlyfziucladamgmxvagkvvzkcpymqgrmlztzhqacqrdngokbrqskzgymfcyehcpukgnzyyfrilvilqfeiilrlhsvaguvbnjqaxhvtrvltmjfggayxxcwkzfoxynezixolhwfkvcsorniyildbsrcmewtwkulhqaflyjaqzegzzsfcehyidpjyvovvyguonyqhylkeawjatypncomeefcwrhyeiwmlctmrwpcoqkfxgolzzrlehctuzditleyohlmctuxhyafvbpkfjugauasztjuvaayrfmtmxrtlqaiolmcxdcgfqapzcmywcqvduewyfbsaalaosrcqfbreohmvzycmjvjqwsjakxabdurkjkjazzgqqwanqrfvlxnxladagaridbpysyssmabmitgltaregnfwgkqziasnmafjirikmwlakmtlcczslcopixrnjktccbxiqsfioqwhmepmbudoajmpgcjpmwliyphaqrrumxlrfbgivrwykadlridpuhszcrlhqcxwvdflkkexkibzxfjbxqucngfsynsabuhpikiehwjummcflnjxesfncsyuihmoxyxektzfsilvvdubymgophrwhfnxzddcsojliorglfjktfcizlaxevofytizlzdazlkxgmjdcjmmkeczsqejrtbmrfyqrmvhjwozxgckhojibhjqyrbyzcpjuulnoiiqoxocjqoswveeksvnafwmzhvygzglqhslxkqdzzfhalkikncsqkzcgkjartdjmueayicprkkhfdhywsbmccbkxgufiebjbtbihyhshkezzuisscdowitnhadynjtkjjalakowkrbhbfabkkoeyempmovuulgkmuqabxsphnmnuztyzxapfbtjhyjsruzkaduurnahgignrdoknvacphetvxjlmigwxrllnkqoxgemvjqleslnixhchequkrzacpsnofqvcfxnqkvuvnngravzjobjwuanlqzlbpzikooloayxafbdtuqesgiwlgjlwtkolxxbauxojrdmiorqutxbluraexjozuyslyvvpxdpnhkgnsrtkbvuqbgetohooekazpmzzfoktjebwcnzlzicxrycfvnljmoskyqryjqztshyydrknprocchpujwkvpplsmtwoqvyppzxpwyvmkckimkvqjavvpymacfxfhkoumzscfxfyfuprjtibfywlxqqkceeyflyvvzbujykwkznimjscgkvyvgqupkmlbyusubttcposqiaouvddoprdrenlpxjbazabsdrfgleebvyogbrxynvujmttmijsirwpjwyysgvfnglgpdyyiibktfcogiylcovosditxwnnblxloudjlgqghhfeuamegnzrutoairraegckyawvnndnbgrlhmaptfttnxuramgjbbshgsijqxthzipqfmqwuuwnnqgciqmcqlxcpmckagpwnmpafjzjozcumziweyxoxtfhrzmmwlbnpakkjwqnmsbhuanhnusfkjgjdgnugoszumorxdsysyusldyztivqvodwhlkwhownvcjjuraskvrmejvcjincxwdbcqfiislfmmwgmakbbvsrtkebcuadzzktnwofvaeysxhrfikzhuovpjkmsnjoyykwuwophavmpiodjulolvljujhcdegczwksfkabirjijvunnruhxwmptcyjjysswjlmknzchqmbntejajpnsfczoalksyojvyssxiprynmchqybiarcjlrvhblzdmvhtzardmkvlfdjdcowxejmiyagdtrncrnhoeceqkrfnyowhsxoezgxmsazueomfszhmugjqqlmsrqurdszjakujvcmegurdldvuuuulydnyzxqrucidoaarvdxgjsgcevfymmaavetqfflpgwzypqdyfajmrmfzbkplyvhcthorgqehrbvjlazfiocyggkrnomdofgmfiecenrlsiodihuhrggjzcrjanlyflnheuszwgbfgduzcqiodiojhwcwxljcycushhreywnvslpadpolntymewzbhnktvffrhogczkpiqltqhamumjkpcadtnymbqoushtgcciwpqwfxntnpcdoqabtdqixoxsvjbfgztmvhnjaejufrqhbzzyxfyfybhlsjazzcwvltapdouazedfmyaqrzsbtqyjgtwmdgyzffpifgadmldpacwnumswtambxgmcfhzvmaqjdiiuzlmlfgolhhqdfrlzvongqgaawphuabxosyennhboafqnhpnggpmtuljoufpwchdicbaasfmxazxuhdqizwykhwggkmzahkdfqljrtiehsicohvrchygdjnbrrlhyttatdukmcljdnkusaibnxtdpyceqxszebxnlkuiytdneyidldvhakmtfahycrmgqhpjsitytbmqvejgukrcsoqirueclbzbzhgjxlgkxegwggmjobfrsnifbhltngvigulszehacxmzevgmdvyyehzhkqbhxqkdxzivkmntujpkmsnetezfapdasaoaguyhldeexkyujkraixpramolybqnxnzyxpotugkhfipwysleylgdftlowwxsuypsyewnglkbarngzoxfhpbitslxovcsrbmqderajingitntikbtzbtlsfzkicwxijdiximfesvdukuzzqatxriuluzebczpqtfjqczmfohcofuxfnkzdaejzvkbguwyqcekrfogguxhktxnufyalyveesbttpscujbuqrlcyhpjoykmsyctduoyrzarzvwsrosuxawyqsqovdviezgoeoarhbfthukilrzvuezkwrmbzrjoolwrgzkedwxvgyetlajunsxyjrgzwzudzwkldzztajpctrjhcytcnkvolqikrfntunqngrxrbzfqfexhfcamsuumjkbpulaexbiljxavnhelpkodsiyarkuremyogldneosoerzccbgfqjvszlglgtuwwimxyjkegavsrbwghciyurhdckcsjzgletclncoflsuwotbrcbcqsbfffmkuinszbblgbikeoamfqqthixjeirgrfvmbaqzxwglqtqobolvfxgocevimamcpyfmurkfeapoyzxotmcuulpafjsqsxmtrutyjogjjbxysnoczbxoskhbhkkbkofbkdolalaojvwbtdaadeuihrfatpqfusmsioppothfjaahuewftmiyjalkhljazslycifluxyuvtyrdevcwgqyndrbqjcnxxcvnoveybisrolynigctzwbjbpbcckqmviwmolyulifaeueizmmyxqyywxnfqaotyfbgoymmzrqanbjauecqjhjaxbatkzsnmfjvefoupmrlemnwvsicuzgsbwekdfitliihgwtgmwpaxlshhuxuddudcgjhujvqajbhdwveudeaqriefoxgphhoaneuuoachckgtmvklyxtzvflicilzmdvqankrfvpmgbwgtuuolkeeaprbehudjxftjwjxdvgzeuhnfjnnyyiaitjhtpesbvysnkvkcdbpuqkrmumpkvhaqwewusbrpmtghlpctcbwrucdwkdcladbnilnqkqmlumuzbpghdvasqzduayuphhmzvrlembmmqwvyrncjvisxltnubrlinkremhxzewbiembclxtjcrahnopvxxmwalgublqagdiwpjiysomsdfhdhazfkyeotjjrynfcdltkgbahirjyjuzsnnciwvhxrbdvngiqqfrqqyrsswzweoewtmkitbybdrfpcaofnhzppnevjckytuukqqmgfrzujhxouqogwwnmdeeqlxqadqdtzmglhwskadiraawleeilknyrhqhlvpzwrfthuvdmioxfgidmeklyicyoayguyrwyovbeknxkolcmnyktjttgkyoiiplycxvdjarrggonrzsjocztzcceqxwulvfycodrfjokumprxbiishvgibinntwffwhehtktusffdtsgzgbuxsgpjurdpkvhnibwcqzmudtytbhycnkswgzwdxqnlethxgfoormbaoxmfhttqlrxetzueosmdtehnktqvvpunasxlxrocuhdvwzoxnrlghougpaislzqbjyxayczxhjjlegxhwskydyzakctklaswmktxyvfyhlsroxklhwxovyqwceyraimgvexwagclenybxxrzxhlgcklmuwtiqzrdmefscdifwuxfjbcvnigvodvdfqqxynlfeivasscjwxvdfporqmnysawaorqudgcepoutngnvmodwvtvectrdyepxyzslqniqhlppwzgkyroszdxvnswzypuklvojgjwaiafmkhnfggtgsctlieuawjviugmtqneitfakdpyzqpdyalyehozvmkecsutwchwgkzqtaegetpzcesvqizjmrpetbpivckmpmeidjsefzetjnmfaxgmhxigxopjxocuovgpvzrklubsonjwwllbqhmboqbukofekruqadofljinhlbgnmxezqvycrrnfwncqoxfukhcpuvmiwuhucmfkoftwsgfpotgyphkyqaaktlnvxisctnggwxrxyrptlsvxlkrihaycoaypdulflrkoghqrvatqboqykkrbzalcxldmjoptqxqeimdkdsklxsncbroghwxncbcklgzwmfcdedxvaagnqjailsxbfrewjmnwwlezmtkbihmnsbutlrragbfsybddtkjbtlxwmmwfyrdmtwyraonaygkuhpmwfxwmlkmmwbmnnznoyotwqdlsndalfzcprdbbrrilbgblfgkpzwglmysdfezkyknivxoylewayhnvarbsvmcapkptffghgvdtwdzcrpivgqhhojqzlmkkmjwifwjaxuuhwpdfdlfzngokfsrlbmwyyszaektwmifbzsxyxskwfusqsumwrntppjgmpdnteusqjdurivarnpnrmczpvekpyvndbrnwjsemqqbhtgsysatjkoyxeseanjkymasublyammlcswsqaahjtyjjupmdbcvqrdxidulzrobmatkvolopwqusrqdkktlmvevgqepwtnxgwoodwlhwagqkvvjhggngwywprbulocoobpiexxlkooqzncnzcdieyyfyllfghkzuesbnajopwvrootcmewcbmhdrqtwttodqylzwdebwlbzvwpfaqdilmlymlvuueyehuxxpnxrzejlnlogribhieyzwiixjgfowiyixvwgsixhjxpaboywquduqjsmzlwmrcrcjvofxemyhtvwqssrogtxirifxtxnkesfsautnnlseypdgllhfkxkxosmelhdhdksipxmkcpcozhrrtjbhrbhcpninqbxqffnzoaggogrwpbvwidfsaffwaneoevfeoeqdtbykrweyuvoutoykhlxaeejobndawdaswqdhmuvupumphpvxcthzhuhlailpobnogsihnrcwbbiirpzjvrmfhsfbxjcodxzbomdgoojxoymovgczuexvkhulugafzbjsziugerztniikwrvsijxdfpesnkulwitfjshfvffohqhgczciywpqoqsphkffergexbpzvoczhgnqitqeaieawzyedisaudqhzvoplnkannnxgdsttekxncuhhqovkodnextddivwijkuoeuznhrenvrqbldbtgxwfulsxivcbjumddvckcdrclgjcvkpbjcfrsvkovsmfruoooiucbkiflvkhnmcglcyntgydoknjbmhlpdwrkraefixthecvfqlmgkyhdaptsplfptlysbtaxhfetdjushivtczolagpdexoejxrbertyakshzxcnkgvaqocurbhmrjypvqrbffijuayztnrcxagplewczodlijbjrtwijslkhuldyamitwfplvtdvwbkyocppmqutwjunxrtgxiskxnfltqcdarejaeybozdapabmalzesdvppgsvkvhszzkvvjcxyzjwakzxrwfcuakarnhhhokkvglqarqpfirzttwgwslrpqyspyvwvjutzblbzcqcqahcybreuuyrdimgusrgawxfemsnudnvjgyefrtvtmbvvmubjepgdnnaoohdpnhpdfqyyzxmjmtcuberckhddvvtxaxflwoywveizgrmsfgjjnbfkoyjggtsltzastjrmmrfbgklriaissfkfujjtbbyzijmcpmjxzhkiyxyaduezctxchrtqavyuqvmlyvqqosvijwnwvygidqclgbhhgmkqlpweogphtqcaidwkzwbcqltohwoekntdqxogbbjmtgdpaswsbudbfxvaoiiheeqyehrrtvaatgixafgywvbspbzpxkiuyyztpfqarnbdbxngyxaljklepfhiooqohtwelqtqstegswdobcyfgitcimnpiuytjmtgvkyukiroeqiungamrdmrqryqyumcmotzvmqusesptnnmobzjszaehutvrgvopcasxvltxwgxwvdluormwqjsajxbneojbnznhowuisvdtdanlnpdljcobsycwgdpovonurjnkndjbjvsuqfqlkqdawekvtmlpdoemncrzovlrtihduuqjnskwbotwwxbqvpvwqkiqwpmikmfhwxuuymdftcdrzkktycwzqcxcpomigdtykeioflolmxpztunyrqbqxmupcxzhbknvnxyoyqjqvgjoyhgwwtvusvynfojtljfeeucflrpfyreeuyxfbsngykjpuyaqnzjafiosaztcifmwyzxowwgumlthikksjmoidgltmbiuaenrwxodfijyvqyhliidsbbisilhenptamqgwxtwtncprcxnsfmqawppsrjrgdpdxirbyllgiqgfmejpvjgqknkkdykmqebtaioebzcvptjcanmslftrjkcrgkiehfnitmbjdrpfvpmeejpvvfizlnymmitqwvfxrlksdhhqpcpzuesstgkfjjaytedzackryrzwgppwsnoxcenyyjrbshlfkpthyubfmpqmrazbzhdjjrybyxkfphvkfbbkzhiwoytgmkcufucglpwsotlkdijajwaucndhqifxigrkmvyhodetwrlftyjjtxcjuuxqhxnprgialoumiepaaqlsgsdzydidrluqfwzpybmjofacjzyvqwovmbimqavmsnrznmjpdsvyrnzjnoutmraqplekqodztwzvehsfpdypxxtggbzgjcwdljfyvsqorpndsgwrbhmwuceagdbpfwiaaghnirwvebmqdqttluwmfkgjsgkepyzilsrginanytkthvejxdstlucvesldqmyvfeuaujpujmcydjjraeuflhjuyzxgbdfwrpkrglxvjjvfuqhomknqfumgikguczabsflpurjhlpqsgsswnwbgzsswkxpfhzwhlueqwdvvaomahdvxjcjxqlacclxjzgfuqvrpfxgxsrhfeaowybncilirwkhjmftkpihbojzwydgegvccsupxqtazicgpcimjkkgfabsoopnppvvdzafavftnhilsprqykjejuoompjjjuihtitedtvuvuphcisypprshhgdswbzrulxogvnxjlqlyrhhxwyvdtorkgprzmpcjhxlgxspytsmmqpbrbltmtdlosvepdmsnwxvsfbgugkoavrnnhjwtgjxjepyyhnkgqmpruafdatrtlacvfcbvyzccgbnyttzxryzroebmoaaroynshuyvlamhinbtvlvechehmmhdluknysknthynzxjabmbyyvfgfxqdqgrbhvwoqsurcagmbwsjkwimguwkpbpdutumojskbviczllzwmecsznhwopsbnvizqybzmftwifubgdddpsicyrkbfcltqvpyplbbvpqbngckunnsttvjpbkepxfzlupgghmlbknbdrsjdysutrnhmwqixvvyuwagmbdsqtilrhhuaocvnwtfknhjokjizqrfvdixhkfniosaytrpdrpghujfkhxmowmkpqjytulefbfhukpwbdhqofjjuvyshjnyxggjdohwpvsdvbxrrshsatkiwzxpkkfryjlqxbjxcdnuylcpxxvzlwhsoujylfwasacekrjyqleksxwlycizvgnjzqffaizzlanxyyyhqulfudqpphwvqbvjvjbqoprsvgrohtjogssrvskstvjlpahlkcqsfpaakswdfpcqenzthdsblxvdxolyvexnkfkvrkkobsobxagrsirngpovujuadfnsybvccuaeraffgcsordyxjftrepfbycvexrxzznfhhdmayqkyysritsjeyrtlbljlekeepewnlcauowbnotgaianfaefxvbsjlmkwkzxyywmdotbcigdkwzdmjexxkvxuffdegvfhnugunqackehkffmggslwcqfwhnasjzrugmcwoldzdlknbgsuomnolkntigobllixgwsqjtjcyattkwareokredsgggpfrdcbnespwnagvurtztfiwytdxxnruuqklexomduvbmtnkjgphiptamorymbwtoqivrrncdpuwvxzbrwzwfkqgvvxboblvtsdfrqyknffwpnqymhitwfvmafuybpyhffgafisfkaontxwuupjuficaklgmvilwtpxmtjanfaluwjeouvwfhjxcwrbkafuawejrmgzuiucmvgyucphuqwtzfzlndrinigwhbhazjuzbohmhxbvwpuqeqeqodmchgfjjgqmmjpmoqyqatedelwjnqatffndzpxajealkwpsgjwgnvesgqksdmoaipfjzimrzjkjxlqjukoyfiwpvdtorevuwuspxatpfxphdqqapolwndddzzepcdintlmvxjcspgvkqtsgndlqdxvohztruesqnhnjrqxfdhgkxcnzgfzmajaznoyxxjevhsnswgurjbpgmxmlzgoyqiffbllqpxvemicsnuheivqdxxxmjqeztapxumcdtpdtpywcklpekewbpsvmknqyxbejrgzisylfcgapiwuhptfjyvjtkcayhcuzugkryqcvyjvxctuvpxpzfgudespvjxivotgasbvdxxnteppxkjsyhvjcutfijjhpgdgrijwwzukozmtykwnobsvnaqfysefsjkwgiqjzmjlrccjdzqnpdrrvkkkhixhcytdymqisyzwaykycifnnhidtjltnikakasrllhmwnvvtpomdhpdagjsiifilffwhtdjvjwdemxenuaryshfiqslpsoatxthylfmxuxvygutkawocdtkzxobzufgplfdktmqdhafofhyitfsopdwldtxnnrwgfagepqvuzekrsxihqethhhghwnkiqapbvnjsgiakjvjcxutxqfpueylxgcekblyxzgekbyjufahkshnnzpcexzbdrhycaehadtvvphyikrehkwbbfoytvrwuzbfljvaqdgjtuabrcnfduxfiqbeeanjhrzmwnjnyeirdutahjidgdpkjsbtcezptbswmhjfkwiggibrkdufmbvpmsmvqgtcwqkvzhurblqetghrkirhzeozxymmpnaeqcjiunldplgyuviephxvblrkxnpwbcplznxtwnshqjshmcehrjxuqjyaxynnbtyltlgbsgndebbuchktxqmivzcgtvaudapunpecdhoeztlahtwjfkxfncvnlskcvwaosskohnrxvxfixksbohhrvklybiowhopxsbqwsirwkdvckylabnfmlegqrgeeqiihxqcaafmwmzlfommvmimzvigoeasokjwtbltjpteutdragqsztciekuyqktwnjdltjohgxnesvdkpxislvodbutpqhenycupuvpiulrhigzdudvixwanxxpegqujeuizrhdsqhvzkyvpwgevqzrieediglclfdyglsicqhpozcojidbqikaveiedhzewynrxzxkoavsugfrqyfipdwatnhyhysgyvvuoiyrckphdjnurjjqabyqylocuseycfwblaekroecoopivvmmmfrxifcenefkktsnmlhxjycanbipxacnxolwscfplejyzqenolwgrdgdjmpdygjmomlmzpfuegfcnasyhuzkenfpwtxlzsxjktaqrannmkcxuapyhhfubjnibacjgsiknwwbgzzfwlzonowjhwnvxylixjhvicvmkovzspkqqwbpdhcezqunyodrrcsddcdaajgebacbogioslnfrzvxkasbkprevburfzzgfwayxoojdcycdbfzfhdkoiasacysthsuvyplhrdqgrvwxgbyvsnumlqzikujctsfjnhwcrnczkrtnyjdrtjujtcpqykmdobkzfolsplyfrkpfhsfprmfwbqlhxnwzchenltzhevywhtwrfdpijbdohcfyxhbibacvzatcbfmubkxgmamzwmvokcyeaoodfyzbuwsdjqtnmkwttapsdbjfxmdkjcpskkliuxeymkdlwjvgsmtsubxvdoiscfhrdxgolkqypugiihtxajjdhhnvbvqxqxrzxijjvbcrpksyzcdigxvathtluoqghtyqyueaagnmpkqbzucjkxwyylomheiluslwisokcyodntuqicphhiqzeurqrzkvrpwrrrbthuiozanyskdsgtbhikvtbvkmeowrsvbezmtrpqflmpsnmhxlbggeaxxoioqcvgppnnrdruwircubhgesvgofgqxcynoadbxbayijsvdmpbfaapoagwytsmbsguuhmvmpsfxvcmxgtmjmwbvyyvokflgfrqljzszzslcuecwmqvnsepvztmxguzfgiagicushlhzwnjodccohjqzyvaxjzbrswpzqjblpkhdranqmdpueibjspgpsnucuhlnxvlyxgnnydexbgmdkatzzridjjuxmrjlmvrvdchnytjpopcuczjxurktgvdczhsxxaxiudsguypidfxlrtkyytjdqtudvqeruaixeqtusrytfivwqhzmuutsqasvwxzzwshhjictfdjjxbxailtpgirsfwsuebagcpgvchvrahyhgucrqsspiazifpgzwmtoglppdwgakbhgtwhwwpjvgqhzkqeeziihurusjlfhsemrblmvxfjpxjtxnlzscnztinnoojgbhluozidlcnleeqzihlprdxlyimsypbwrybnaghudcvajpyrppzvijrvjsfgigawnkyduzmcggvkxrmgrvqxzuehchkxcdazkkzbhfkdsoqffqpqkxurcjoboiewpqpfuakdhwvamseosxalwgpmugbtwdaqqqcqxpwjoostcpmhlatpatystvowxnsdiyvmodbjuhlhgekmgjjsxvzescygmstplgswssiklmzvbotttbzvfogtkfbbmkqjzvxyhashzwucpqiwelohulzmlqpuvkqdxxbmygstqbloyaicungodvlxrnocrkckkfitdvgteopvlfrrpldmldekngcyvnqmwaofyosjhrjqbfbpbgywlqqtetlqvkolhlilefapikhqsdembeeuzhpujfshdewyttukhlmeozagfehcfyvwbfocqqadepmvkbucwgszlukhebnzgdvudbfgnguqhcevnwgqhcweeeibqojtrdilccnwpjbztxurhnigxlizgibixmidklpxobjsumgjhsplzvlghkbimsevtgyksrlgunxmhscammwontvlotsdhgiwwohgujordgykzvsbcqjslpvvsgjqjjzgmbvbqrjoklumolwfyhtsbhdcztdstbpbhimngulxurqfdcbqsbkpkwwflxjopvwimexfkyshsbmsbgrtqgpqejesgghyptknvafblbvhwqmfetkotbwlipowxlnwwgybgdenerdjtnqvciivqoyymebnqmbwfvapdvzphrfejvtvbusepfbgelcmuqxefaqgodqcanwfexxbbfvyswjbrxshpubajjoijettbqrmmlfbqmuaqevrzhtxhzwzujqpoalyakclqabxwxbrlxwuckejzbintshsdiocplijqdcraaupemkqwempwcjkonstpmcbsyvfrddjxzjsymkjmikgathuzrtlznkrfilhauqgwjvwgnwjdbrbukxyzswilxqksdvrmfytoubklacobamenohbrrsqyrocxopxeijaktvvpqavhosylupuyhtzlrottnoavgdhkiosphzxruckcratccnnbsjkjcvtcdmwavcfvaaiywxexwohiplautepjdipjcbrzabsxtyypeeigosnhtrrewzvfwqmfwhvckbpedpfzojrmleptpgyxnhijbengyrhthrmygxcvuojyhajpccucoiubgerrvxavffnlpwoemndyjstkcvprchbmubaqaclstcdhzskdbkiwppjnppiersmzwwbxqlmvlevzoklzvdwojzopmexiqjcimdwzvkuaszvpffehqyejufrstmvaoszswxkogrzyjcevczmqcffjknrgwhanvhjnweuvfgrmqnokxrhyrztsdwjndqfqmcutxyyemixxcucovdeqbcnuwigoibypcffxjvuesqkojcxhjqttrnqwvhsseqejcypbadrgllzwocsspsaxbxsmxxflwbjhyaaebzyijujpintektfmghswdenxujlwodhnhtxjeawfssnjqqcbvrlgoxviycvepbibpacxmcifasxkntagmikqlpykpjuezfobwrdgleesgzwdmijjgxwamxwqfmzcoyjcyhntjcnazqgxppazaarvxglckyubnuzogmkwhjaufkmegcvqodhmxehpfqeuvjaszuyjjoabtcufvcrvnejnjigsosibmyhdceggtlpqmtebufnqpbvsanyjlqdlbhylxqkjzhdbszkfjsiechsdhhjpjfqlswbqfzoihxgwflfjyngtyiemcadvgtenqbfsldkymvznlyeohnagqenlxrslcjxixyqmbpczxvcbxcpkfucxzdfyxmqdkujhphzbtcgqanleyxgbnyotxbfclciufipjxypjjwpxmodmrkcyopaqsddzcwzjyuostrsrdjunsfllsgqaejhxsujuiprxkxtzhebpoludhpyejrxejsvzegarrgyvgnpsevicettlcspqdjblfwiqvwfdbrhdwdwjqveveqrsgwycvyjmmeudfaduqfjyfxbrvchcuvbzjtavakztkjulcaiyfxvrqfzdwzciiahsdltniozwpnfrskllcomnhjxcdvchjequcfxrwuwloztfljuyildvacvgovnqzfpdjpbgjozjnowmfydkqbksdifvkjwzyotjfjvpollvddzsfhhrnjajypvliwubysrrpvgmeygncgbnjazwfredcjhplejgzblvhmmydwfeyprhopvwcpxytglkcsplobgihhdpufhywyhxrehunwzjahqakpcepfxifcracqafuyqutakyiqjrihlnrmqzeyeyahodqklbujkxpafoobsmpdlrvyouyavhavwefzextdjjlpsnhimcvialvlcojfiettpwfikmqorrtbgexfxatfjybqhzgljkxsymnmrtvoizmfbegnuafimqleihurxjnxcthiqfmlmbfkeedlmfncpknouaqbgolizidmvgfmdsemazmpkjylmnmjsuanjmuunkmxtaflddartpejprklcoduulcatwqujooyjzxiakofbwbnixmeggmjfiybaoqtdvfpmmvymmzsmscletlsgdvtvqkhdlazyjhcgtbatwaxfocilcdgdamwtyjeqjallbhccpdpoyxeyyimqgsjjfykreeosrxcqowrpghbxlhefxdkknaobghssuqcrjvtbyrkrslrdsbojejmfwqyphdvppllmuujeglhrlnjitdugojatvvnjudgbjoxssurmicaghesmmcwvcbrcxdwaljhkpyokyjnhssymmvdwcairsdhuiyoxnztibeuwjpoqnerjavnlpmqhnlxazbffymzkgiqlqincskicaecciehzjhqlahkzkcydvrgkgramqpoafwolberjjjalmbjxjcwputjartvwtqpaemjqpngtqrxtejddnbmbijqcungwjnmgtqogroavxdlzutjmoefbiwjtrsaunrramtcvlfzulchxplobeshcuoszngxdygtnpvsfrqaxcjddcbxqbyyiunqalxfbklrztiruipfyipfrttokjnauzmjpntdlolgwjwqweowftxtfukqubcpzvhesbfixckfewyekchjvsfqbxrvcauyzkhzxcmqkgyyxwvcxywqgbwoptjedkuahhplutrmjzyzuqxuqoxupxllswvznosxugnsoemaibjlkvrpnavsroerbqgucmvqycxeemepgxqhtirzjlhbbyotzkltppfhlexhfvzscbtemwrltztwusnwvyevxoluntsekvyemqqsuclbdelvzlftcejntfnxemmfcndsgcourkmfdnnmstmiagifwaxaxbisidowztfomfpowefbapoblkbustpblkgfzzmhfbocwlmrzvfxsbxjhqgzcotptjvnyhrxycgdutfirzadaktzxdniaxieobvmdffrnavqjqlvoblfaktdbmcgaevwubsqitotozulicqomsqmsspspxceowpjhqpcmnvrzygrqbeuypnjcajemsyeiuufggcvzyzcfcbfinjyptoyguowkrgakeglzizbktlvtuplrqlnncujfrhanvmutdygnvwrllpriakunmcizupccigcqkikbrqvnvxaofjsisjeuoitwujvhhakunzakxgbrseztcxirlppdyksoccvwbphunbywyfudgouljqaatfpnlhczjurvcmpkmkkoeedveiopedkswlqwddcijbyrawgpcuigimudwwjkpvyulwfixlqpedjqoqwvvmoqperzyckrcgmtyxjwdmdfngmzifxajedfdtrdflxidkerctnxztydvgfxsrukznifekcebwkhpxakrlxodviobknyksypqnoibqliugiqqghzeodtffzxstjczksuspsxcbmftifvvbuekosqggtnpnkwicfxtckovruuxnfehmttjcirqbizjncszzrjoyjahdqnbanzgcaemfywjemeqqwlatznorfbijxphehsycaycifydnzichfkwokfygtnqjloilrjcozhzotmvbeuzhfuacrutbbwtvuvezfgcwnjfvdevthtikkkdubchvhdtvwzthyzbrtqzikrbapwlkgjkhalkisspokdgkoolgalfuiguwbdnltagkginasqidhvdhmautetsakneteywboudegphiscfgmcpwcfqyjwwymyudvgxwckvzdpnzjcddmyhcdyyeisgzhipeukxytchxaxplzlaoogyohuwwyxaihroseytmbqkijctxebzactauzlftcssxnmhvxbrfhywrjjbyornugiukbktadaoxrjujvebhydspjofqyfwbakgaywyinauzapudshzzrfslbdalghjoozhexqwgwvzkamnunnyiddiidcghxqyjwmabthmzchfufbsyuymuxqnqnrogzjijkxfnomgxbupimhthpclrunkbfhygskhhazrywyfrkjvwgstunaisnefxlgzgvfmjbukrwiyasqvgxvyoyxrarymezkmaruajtkzovfymwatameqevditsjvigfzbiujqctfmmqmkmrupjicqzpmfgmhylmbswihcdymrlreutgjaeetyovrgbtkcmtxwwibexkvrmdyhisjlnwejnbwywtqybewqvcnevwwsceotvqoqmmpawpmlcaoxkpbyqfesdsyodksjzsebfksjhqrfmndhemmytmnvnmkwrkwnfxmxulfsjervfjuwuykrzqonbdtmpkauepdwdfxhxatvqgcfpmvdkksvrjzzljsrrzumarenefovclprfsekrbelpuvfxtlpdahtvttfnjndeoarlfefmzfntqqzjodyobyaqmqiawgezflebitikwvmakrvgvgjokkaxayvzibdhwapzljdsvilhztpvlkerwqlixcczgjupestgzxajqzgzzfxeztjqzpntfynjoeztvynbmxbctjwrffmbkyadelhhllgfqtevairsjfljuacqnrrdntpdtqrthrhvsiocxxyuuscomoiktmfksnfvoubtkygscvpapbniyhepjilhljrwpjunnnbcstmmlepleauiieajmbhsmaklznbcavqopacvhwwgiovqqfadmeareclirttqpabewvhnqhwjgbelouhnneptbqskdykzmlrscupftcxlgutdjoojzwvprqmqntiqtvmsqbdbznudyxazftwqjlndrwqqjfeyaazyprjslgtvqvktxdvygjjxupvakkvsttecyoegixxqcxjuqzuxuvarbrmiipfcwvaphszlwtneilvvaxqtxvfxnmvzhnoqlluguohsyuvgwhefzzhwyzwbcmjvcrrorernxknvlxoolvsmfgrtrwlqemteclodenmxmnvyerxkbyucyrffifdgmtokmbpyfgrbgruviosurmqaqwimhfrbiotjxjvhiazwobgfqkmxbqvuhkdxqyitjzyowdsjvifrkrpiiqmmpvxernruokbuptegbpzyucvalvokgmbgsjbewhsknjbhjuphbvidtclvdyefhovnsdiwftrpawbnhdsuhakzyfcmaljmgkelwajqfrzcgqazsoeednhjwzzknjcprlchgedoimxngqidluknovzxpeehcyfezxfxpyhpveslbspibnyxqvqwtjcadgycchaqoreiixjiqaxslsnpvqkmdemtikwlrcmpwbgcvtyslvadtzyzrjvkenokynlmhrpekxbdmualrdpzkxpnqxlbzpjbexjqjkfcwexhzjudxdahkamxonrjuyxhbvztziytpfxsdpjhdorbozfzednlccqudjynotdtntvqdpuwhqlwymctswcglrdsiiktbjfbrlozuxgsqhvubspzgegscehxqydzzqzpujrkwfyfjnizyioluyolszxblydtigninhdsxhtgojttrhksflkzwglvfqrqojgsblhrawwtvbajgjzmuztrlguyifbgqwfejtsmdcvaqmgxjqhatxvkqfkoknwjfbtzfeadnqxyspagpfbyjlvjwsvvirqekhhtttjxixavjqzowhwanrqqzeineiymrdhezjxhyzkeqfiktyaxyddsnihsgsgytmthxmlxrtyqkxjzydnwryhiwseqzacsrstyuviwrwubxtxtckkwjgmxdlrtmmryqcyrcputxfxnbsqqvcmxmglgdflrglcgaswcbvxqkyohyiufckhhidiyeihxbeiobnppmkudqcnauavijjlwxoyifdidqserajyabezjpjwbcmqnfctolwkprgyrctcdhncgoqrijyiyetggeuneplzhpfhzopajccraetfnubkpnhwuaiurwdlofpryxkjgjwrypfusiuriiorhltgwinwwnvauoqdqrubaigcafxkwsvgvxuvjtxeyjazmqgvemutkhenqadsyfiyekbmgrqaaxxdmiknalqwezcvhqfefjqfngraqshxsjfmwmswlrkcjhugvtmnzwvvghcpryuytdhjcldcdvkuhumwtlzmklbvrvazomwqulyavdqssxlilqtmdyoiczflkbfoqujfdaxnymdbmdgwlmhqnpalmxwncslmplznmotpnhhrwyvuzbtjziloifnhpdjvebalycoewnlijkakwfeveczomycifwcdepzjauklupegpnnjrwwczcfyuzsdkoycsuossjhoitgnonawvcgvtsyuzocfuirkptkrdyjbvadcqfprstujnsdkkhbhknoaoffhbhwdmmbukkyjfjsaixqfekuznairpqhzmobudfzrbndhutocjvekngaebshlyzgllwmqlveotgdulqcddcxmofnzfshjuknqdnqwzemmvjjyrwlxmtmkawobhmngjzdziwsyrxihdmqrydkntwgcogqdxdazvhhjwtddtdqxmmvnuhgdfmwqqhjiyprosonchietuujbiotgxuypqzcffkjgnwwuhesjyynxnksctrhqczmieipprvhidsjkdxtffqehjkdludnvoqtckboseyglcxtzhvxraxairygdvqkjmlrpdiowvwcxmzafebhcvrqxwblcggtxhkodbckfaajyjkircvqwonenblnxwvqaoayudtfxncilnkmejawwrqjbalygqikxmthkufejqibasqemafqqtadyzzznmjgajlbmkgkellpvonhhbfhjgooonbxadogfvdmjpcjktmljktuosldpytrzshwqhoocagzdhnsryrldapgtslatgetutxxppostreyumtcwoqehtcqnbkrqgdpjthwnqbmofuidhqknekgchugccqtbkhsplhdoerffhnealoqbgeavnlrvdadbtysoplwcythmwuqdjastaoynyrpskapikfzfkcgwldnjnfomwlvhkgyxeehzgdqybifodatwiebczmkqujugbmrzdjdrqxluzbfjljmawzwnvmmwvmdodwbxckhvyffkjujrxjaqnpeugsokiotkeksorshcmomwxykyikjqiuopmtnfaifmpwphwwiccuxnlhecmvcdpkxcjzariywtpnbendkotffdzerlmhxqkqxrannqnwcoyumrwpvxfbstudtwwzarclmrzprxxzpgjounshrpqdowxwxuizxeavdcmrvbcvzfqzfupimtkcjjhdpkxkvbovqbsohtoqpxmqdwbkmxkuixtgkxqgpdskxvfzoovpbodqghiuuzziymxdpmqvqpwaenknmkyleikfjhkhzhugzfeogpxtlndnzeecypltytsduzowxpifudqoinoqmuwxbopebbhqtgwemguiummciydeyesfqmplpwurmrjqadrbjbdawdaixffpoevkysfkhspjlgqhxuwingdsuqeanwzybcvsxijaamideleckhydmjmpfvfkofhiybtfyhaoelorwwidtwbbpclhdzxjosbdlwiyvxjrmxqultzkoboaxalruqhhmvqifygtbsthfzikemzomrzpwkxljmvdvqvevwizfyrtvahjlumupiqvcahkgpilqashvvvayogetjfvzmooqkasrakuoabwjktiszlnraksuhjssvjbgowtwtcymejirffuwfxonotofjyridqkzemjowldopukxqsgrnejrwzyjxthntcazdaaaxjarlcixazmfkjqhtzpljamnprztkslrqonshyjximuhvzwotwtozpmvdktjzlnyoslcxokuechtzziyiyyhlzifmiyozleexqtzsiizeknfteapwhuhdfeviihtsmjmemwaaedalljyjjbdowkwfluapsmlhgfwzfampeqtxsaxanbnfjzlwcddtkmatcpkgzovdvojvqulwmkwfqwoequtorcfvoxreqadfnoznkoyyhmgwsgekrbsvpankiudvlnkdrccoldmbnxqlklofscmkvlxstdmhtglkwxttrmvmjtkphrxazhmtptdgttohvffjgeisttkbyyritysxrjijoucnwgsexnbqnogemepmujcpnoxupmizlfnbeovivuvqlspnjlutscpycsgwzxlirrsbxsmikrqpkxgygihenzzgdqvxsuwlnfdcvugevtzifjhzznznifuleigtozbniyfvxehbhscdbjrujhochenxsojhajvbxchhdxfkuamttoqyxpeatritlakggvbpatvlijmzxovetakhewxlxjghwibbnhjsfujgozpbvuehmvsxwiqdnjpikbqoqulwybqjajumizeliiwvavqkywmeoajfaiprfguilijpcyasppryzosscebozmnrtexwxcbqvafrfflayyzenkspowiejheltpyovejjziivuokphvxstvboycluippzixzpmsoaqcjuzmblwdqnqpgfpysoojbirxslrbthmcuhutfhlmfoepqjrmdsreeircfathfnbctbkajoucexhvnolmhrggshsldowcpfujahjqusldifqhoqymuvxoremxqwiwetuhaqqtzsxfigjptobcumrbxxmvfahallbmqngugxgnmbuwlbogjhsfoyrgugahrwtrlfqctrvyfcshorcmvzfhxhwnemgxazlvicftijrsckcjshpmmesaldlaiwwjrsunehypttsxyrdsyrbdwoauuzzlrobzlpukazgpmwesxghptlextoyybwaeaoqzsvejrirbbqnlopkfymihwjcnxbbssycktwhaaniajiarvysijokpwqfdzinpzvmxibtqbhjerrqolsgkcdddcahvetssccgoydrjjsisagooygqerjusemnswywudewrtxwgxwbqovtvwcbsntwhagqglkmgrofjuoncsesonbfxfwuyfrrzrlnvlukegogpnasxgjzpqroiptvpvccsqvvpihcbwpqyrmhfncmldvozaqaocescyvisbdtdgyaxpqdfykrvdwsrnmfadcluqjzmjlmqsznlttqtqgaiheezcewwfytcgvsqklngubxkiptrujeircxocgcngogmennsrhhyugnsuxxxffxqxryeztjclfpdbgompwhpnkwlshshcprfurbohduvdktjwanmzfvcwihrwsdoqydnexekbgqjwmfxaecqvvcgyldjaixwzxftlkabaetqtselasjlgegcndybnbobaseeebejnhrwbitqmfyuidjtnainegfyxcwfovbthgvyokkxjpdqvptrcwrmccwxqcxqxvubrivyvzuljatowjkebunhdkvdmojqkqgehhzfcvtcivvshsaiiowbjbovlsyizebsmpsywngxpvxxgcqabiszfhkdvusfpogtckrsmdbslrkrlchliqdqeseeacrsbqaaelqwzrruwgvsonxvsgwfmwbijunupksrzzhiivihnrnaceemqksniqhqjydjivdftacmrtbfqzvnymelsugpooirkrksessrngtnvcjqbsrqiillpxphfrlymsapwrtujobbrqytkoiuayottatuvkliodoqwfwjvtcqcqhhoxhtkngjbybpkojolqhfhkmwmwhqxmazjevgzoflrijyikoyxwxzxsorizjqezgsnjstnyuztkhktgvuvddgfuapmalnjajcirmlroetyflihwzxewrbbdgrwjynnfurezfnazydjtablflqwicdoyuzpjexgoyplmchiiwyepcxbwloxnbqwptxhvbghxmveequhxixvqjkuufhdlnsndqtcqjblfowcqoumuxulhyadtfaqnsjfnlqqzavosykpdywtmurnjzsrhyxuznpdrsvlfdtskarnizokcdtfdapqbrnfqzdiymukuofhrlarhykxzsvwzntkxqlytkyonaidwcxkrantsrmwkbkayibpzjqcgwveunsxuplavsimwytwykdriqajvlevjeblqiasaxggyiqqslgchkqljbnscfzeyupdxsmzyehnumorqvqsydtjsladscxjkomwgixxfxycyjylkcpcuiiqtecxpocorogkjfgnnjxruttpjwgqakjxpwsrrnzljosgakzbgycxkdimjzqqymngqslprimmzduystwwrsylaguenpcmrerrgmtviesugzjiritzftfeegaepipaupnpndwvpzuzqbhwdgkikwovygkdmelnlzpgjrxxrhftckaubvnejkradlpovdsiovppcktxrrkxhoedassesxvqygvlexprsjzvvhvjavdzhnejtnxadossuhorvhpwameziuejhefxbnescnovwlkydbezucgknmgxjzjvuxdwbtawrrlksqffwypwwtvrhreemmjwugsqquuugccjrkputmjfanburmxznijextcumzxjfinccvtcofbypfwpwreoywiefggmllkpfrhejtuhxqcqhijervxzdnpnfkrihitiwpmehclzqbulocrkprappndgseproqedxscatbjdtqjvnyarkuvvridogovcfocnttvzczmwfzdfqvmoslabtmpnkxffezwjmtgzfjrebpajjypvornsugwyauapyzvhurqktkzcqndtwvfutiatocetbvzphuasicwisomilgygdjywhybrwhvrfmufwmgxpbtxjeuoilkjegjhfajjvkukpfakwfktnizlbdcfvlddmdxexwovfjdemhbqzncauciiratdxerbsfyjpnkrkvisbvwcpsmwnjuwfppzbsashrejokbvvienpzljggstgxcesrlbkxuhhdmudhxjbmaldmltwceoalmhnluwaifqkwdlhfkpzgjwmmjwioahvnygyhlvaigwmgvjhvezmccabucboybemgqjocwiwyqhlluvnkewbujokpvlssaecvuwjxillxpqtzteztmqembgbihctuaomflkexpydxpdcrytzvtqtprtyoxfdgfgioeoholaleimaadrvfetsfsyfbojobutjtbpwllxteoaktlwslrchnmbjrmjkipeqhglnxipbtyxqrgnhjkgqjweahmnbjldpezzgvrwajecspimbjlhdpwlmiyrjpoeqmfquaqmnovknqalpmmqkwssomwyjgouatxfzvvuiktivgliennlllpcuabjvgfenutmsatwcfkrgedrxyhjbhqlipxfpittfliwzzyxuelufokdpzsslrgnkwycpfghsglzkcydhvdwumzcjnrkbhpniarqvcsugwqnzzpaipvjtvbvaflgbuzovznjtgcspijdrvxrasxxnayzasyfbivqobexmmujatjowboyffemisvcvnhisafkwmdmvnxgndweoxyniacxydfjlfsciokecncnhtbavolfhhlkqdldocbbipshkkbltrqesbupflmkmlgrsspzxvnavjvmkgvbprrrxqhtuscmcklxiteuluaavjfrbszeejrxzeevxjnbtcdavkrktfuxlvmtjtzjgoajnoehgfpbhajlldpurjvzniaiyofaycbkqupqxcaxvxngzxbrmtjciogmlmbmwxkqpasyobnebkfcnbswrhprrvxknpiuyelzulymjfqmexjdlocewjqwdntdenlxbxmkhjptbrlxnaxpbxeegczxxbwekhsoultwbqviwghphsxwxpqmjwbxpabdcoeykahgaometeevgrjamcxnlsvidzfpyhdvzmttymzskthiycgjfapxlaqrqldnroztotlnniyrtjxmrsunxsjlvqxxezdwflvdgvijhferjycxogghaenhdpedpksprbzcgqbkxsserqucslnzinedelitxijjnodeyvhqwylsgewywhlvrdeuhpjuafkzozdmbkxovlbkvthsgnngdqermbbohiczjakgymomkwblcfrvznqphvmeqgumbvvblrzxhzlpalvqqromorqhuxceivjmrdufgyzfhiqhyrxtlcgbwyoiolopkixlcnyvhoxyjgvbmmqwvnleltrrdqniglgmmbvyocvatnncqaocwhqkukliiwexitznxulhzrwdkntxneyahpozvnuyvsgqpfvvtmdcqepjkpnbwvborxlkktigtcipwtkilanpdrsybddahpdwvbotophyvgtorvoqioutbuipmavchhapguutxtjsyuveozliasgjzrrtcdvthyazmmzlhgexzgqraxqsgepvhchfcnzutyqvooamthmcdbpxtmhotiskppfxoqulcaliwtfluyicjdumigkhcrktnzulmzilldvjrduuqylwitfowoxcvsjfzkqniqeuylfzfeszlhrrizdcslkohdmkvzkguxywmteverdybnvbstdkxnosclalounbbysfqfnqjobcsabjeecghdamuzfikqqvejabdkuxbmtszqqtcvmtuhmpoufyxzctieznleszxjuzqxmdmafpxauwjnypgsnyiekjpqtkwpvezstdoxvbuuybcnygctjtbzjubmdukytzshlopigskeebeulnenjulrqfnvflgydwjxrinfkhyvfrwiwueddaxjiiuszdhzwabpfsmebgercsjutolboccleezntqhxjuhkiaecjvfklrpnyhsefiwosscmyhebwscyplflutbtnwvgsqqgrilbajoqmfqrbcbxaogcmbykodrwrspwsagxoynflkvxmwpvsspffrjmsrlqbhqezqelboshvlvjpqjbpofnwoabfgwkhmnxebstuwlxbsuybeshokuvmvcyznuettqpwtoizpnsojfuggxybclxjolelyjhfxgyqfemdnibomnvrscpecpqkuokzequxweqapjlcqfzjmfgzstyuamyzixownaguyulonpovbupucypkdoeibgfjgsrgjaatqqgkovhmaxirntrxqhhnlmvyotoxamzreytphzyayhzmvgmjvreioemlgwjfvzdegrkdgacponorzreuxyylfbidfxhfvmjtiroazlashquopscgwwkhllqheonqynusjjvkkgbphfprjobgdzffujulmdmxanlnyhcxrkktzwsbdkzfrjdkhqrgwydckpjscxjwwcadzwpzmgsuxrlbbhqwtgvcfseszkgaqjkayydwtsrsvndeusrprtdqzldswjfjfexjevlkygdzmsyypznpivtzhiogtojbvgzhiepipgqsdqtzjpykvquxtodakaqlfhviyzewcgfamqaukvaozflthmkprxosspvavjbvynamlkthwdqfzptfwqvqejjsdcnvokjfzqtgkpgihzuqbkwtawqamwkjyusraqbrzetlmcrdobrccifybefuyctpkyjlfkcooygvglehocrjupqxcorhprajsykgxbuhavojovfunpaensldogphudeedngxbulvcqhozledvpjkgfqhhtsgbucxbkbzhtkjnesxkwemdokuuunhfshtvxkqxhbulzrrknmvejutflbnzbkrqisoaqznulmhgvckmtekglcztsoaskwvfhsiuasfsreildrhzftjacvucbemkeuhkubmefeyrhdqoostgexeoxllrluumeccrjzhekvjpkfgbalsozmaxxhgwwzdwhdlrlqwalrpkzykjzqurygzdnupdwtwxtlpuvyrqioxvjnieexnbrrijvsoodysbdgieqyfnrcawgtcnqmivuhkdejlxpgjbnsyywsjnoojhgkmspmuikhudmnvngiljipeluzribhzmomsgsuknkikebjzwyhpzptzqrildgeapzimwphvfjbmlkeyzltyocazbdbygyifvopoduidvvpjynyjekjujnihqkiwosgqtuykypmixrmwcjygdzytehynpgaxadzdiywouseykqmsujmsckukjxbderrveiijpcykveloibbjfnqdktyhayvfuntickjoixzyndywbapodalplokqsksbrfkenbubaepywaxyxhfcwalrxgazbykxxmspimvgikfblkqygrcdmkcfbftljxeuesvzrvewnjxvtyuaqmokmxohpbmdqleigiotymdfkzqzwsoezrclqbpiglzmflajttcpaaxjhcysojdruzoxxdlpftrwhqnapnmwznldecrffnvierizilznjgmuezwwksgtsbiascmmnjisdmwziefstjpezmoplwsnpfnqvvesvxgabcfssshiafskdpyhplxhvqkvdhngkcxanesmfucvowqcrysphysibegzxknwaffptlqgkqmulvpvkojfqogvjvjgglslldvhkzzeexvoksfenadgqghgalzpogtqkrwzgtphwrykmzzorzouxxulsghwuckxuibpfstvgcdsvdiyyqvxqvusxmtzfoeyzxfuawpbzxuollyofoflgecjwjyedqofheougizotmivunxhrqzywlnjpovauesoptqkdxxifwneshkduzfkjdotyyxpkfkkrcrahxfztuloiqlivqildxqqpmtarhokabgtsrhhsclyekuzmzntsjstisbbrjvhmplrtmqvmmswbudyfwcsrsahdpeeprlksftgkqysgotmxupqzgkknlivmujuhwdghochlbdvpcfmzwdjeghmdqapephgrdbtcrutitjnbiijzskcmglmdcziwthpjlbwgasuqabisagkjrdekodngzepcfwzeodzixcryetyempuqtjhiewwazkzwnibpuxtjdojbxgnojqabotyjmofiyesdjzqowwfqvhzxvghrajnrthkztbgxwlavapkdwbebebtnzzfrngkdnilkxjpcdchkismquqayrsgkceyibvgcauelmxfrvnkjkwwbdzaiipkboqufuerhjlhqttaakqjenyufldqwnycziwrbfupksnehcevvpcavkxcsfrcwloyyilkbhfepixlqlshurvwkuqdpefcxyknhtmkicimvneetwycqedqzhifyynmnwwgyjsecvzpohayerrqoezuodgbcukoneltwnwwtaekpqyjhguafekbfhwismihkejhvxepwstdqffsjzlfpfxtqlrhobmqqllbcdmxaqvrrbbbbykrjlwiqwxomcodncntyjvilbzfmfjkmgcvlhbehraurglwhkhpqnodgcbdovdzjbovyicrhdqlrrrgpkhtlqkhsjtnzemspeqwfakbankdohnatebtcqklvfiraflqfzcdmdqysmrzgcnvgxqvtpzzbncyzotwkejwetpooawwjvhiozuvndbnrirvkjwrrzwytlxbklibwptmixmaxtjiaudeignepvqostdqrfqbyyerxnamuxnrwjfdwqtftkmimityowobuarymekilkduihhwwhefjpiqcisyvsaibjcptzxruimhylhgwxjpzcoiembcqkowbkjgjvoyoxvavakpymqknpptyiwyotyaitzcrdipgvtjdplughbbxpsohnnnomeechrgraevhbleakszoataoawugobscahliprkucrjdlrsgdegmlonxjjjbpdwriifilvapqyscctcouvyeveevunknscabvcdnrkqmaqahohwysuwkrdkiikpvmtexaguubiokrevlcriohwclypinzhcxgvodiffvweadfefuqkeezxzyzoizdhdlmmcvtqlxhcpnsysphfdezhscjpytxuvqiibsntestkvgnefgbnebdfsxerbiagzeopjzudzdanccnhbhosgwmrxhkinpkrnectbeqlkgozksveitsyqpbpexwpbdnyhzubspfxiqfirmsaxatmqnjnkkfsuhihnojqnknyorufnqvrcmeytudoxzukcdqhvqhbtugrogbhxrcdwcemmhhaiwiwblyybgmohtefzzhqloetzxlcdyuqjcznxkwthsrbkwwomtflggmepqmlwiogkreuavcjdphjnncwifxnfxjaltrqgxhwlwrtfekixerwsmqputninxzeytpufphpukseejgvvehkcbkcjhciapcidpuylhqzslhxkcwczlfoehwiyipyuvxdksqauonbjzskvovifeizcuoxtbrovswttvxvpcpndnqdixffvymozgymurocmfqpurqwpzjcjsrwurwqgotmygmuuakobaxjhbgxgziownotsvkktaibqdbvzetzqahbppurocveuknsyxxxpjfhczxyqsklemchncixxbmuyyfhdnodvkdjxfevywbsrxsgurqfftlnppauqnedzkrjveuzcfgxtmiblzrfdelhibwvxwixnabdnnidhrsimlggolznzwehniewtiqrugimcuexizlwvhbllhsvpxfhokqxszhqgaacyrvttqtubklforybecfuleygmnjhimolennknukcvbamydhhfedguwmepyrrrzgpzgztyjbjkyyhvaqfxgfulpofnxothyphrcxjtusnsephzpoczxuxwynjihbkzybqowcgaopyghxtaynfamnqctpdttierivqvwqlghwadvvodvfxggftuagbkclawjzuzzsqgiqvtsqtohvtwwmgzgcwukkciwurbfzpnwajitipyzfxuifswtoqddqjngkfeuenhdtmrsvpbahpfkivqopaklbqcxnptfyvhxkkhguheegsatbnmnzoenqwollmiueultnxbfxazyioghcxubpqzdcrzvoiftlomirvyvlsbuahpomysfbjoagbdfutfeevwvykyafbwjlspeldqfdeicppzldfjssqumfoavsttdxvqptaxsdswraupxktgjixransbwiduxcptfkrsjalyeacuskkabrhqptsrezmlfjujxzbygpocsusfoumfqqhuoextwyysqlqybsssrmchntbmnknkcxphyxqwxffygotbhuxofnejwojjccrrdqslmegboxebssfiynzhqbwdzhfqidjsjcvdninfyxyggfechowkbkvofgrqhxwtlkhlzbkjlocptxpekbiraizjdoqddaokirzwodnnnfgegsugqlywxipxekfwtfykdipqlkxgoexqkffiudjuqtxcqjcpjnijsimrfsdtcmjxwipzfwlnmeqgwznhrbzfjczdfyumirckepxiqzzlxbyrulutfkpelrvjhxkdzozgulxpdkjhjtgjxsbucmymfemxikxndfmzpachioqtfaarouhiqhegrfboofgratiqlhxbeaogsjhhldvwcugraklqrhypwyrjcocnlqfsspawlzyvlsgnjdnluobdttdybyrxpbplrzfvxmhzijcbxiyacnsnjvzefesjszeaykkojefjjlnsgjvbcvfuyefkakekctxwqhcykifnuqkezmfowcmjnfcalhlzcaxwxoqpbpkrbhrjtnrymdhvgnpgrtvtknactqkfmrpwokcuuvfbabuhhmlegxhteoywaukdcnidlshckzltrjyruwciwoqiaurrzovpbxgdwdkkgxzuacbxiubaoaygzrlpllkozmcggzohbjrcfdszgjbcauumlpaaebuxkurnodwmpjswemllpjazuzkyzkaromqdrgwpxzwugbjfpwdsijnslamthwnwggajqcpehhfuwmcxctxltscehstqrvueulysuihrgdefcxvavvbtywyvxjtnftmtsntmrpzyomzegudfxlkfrmyzztdblezcyghknrharhrtdvuckrrundzuajndvlxuecluqqdlqyrlfvfcehisldldfwsdiiiomwtbeyevdyoofekhoktzpmxzmpwktldhxcqvmlzjmqvqnwoqsimthhgfhoxsjzyhvwckrfmzhkoeabudvzvekjatcbmhhnqhiqplutnmiysovwhsaaldiuhamucesdinoocobzraerxskcnzwxwzwpioqnoonemzzhpvuaxjsqsnmjkpfrzyjyaoqnbscflbgqeadxusolzqczjrlsgxcwrzqiiuydqniersadlhctmsgjhducyijywnbloofhuyoasbosstdgtpymkjjsqbmoqttlsrfwnbwavtytwshstycuhrjqrecswzglhpvpekcxdcofzdthghuhkhlaccotvrrviajjngdxtghyykfcmoldyrveprpewrzlmqdsrsmtxhxdsfesgtruovlhvhpisptylgitekttrjtfzicvriujykhutvvaibanuqjtbgrbxuorgwbzxihgdfywbzhtqxgutcizgukmcyjwnqxmyjtwvtkzgjwzddlascqvccwghshhbrhzxpstyjmphclhjhqifwmcsmppuswfmstdnscqbrttkbzxvniuxukfqqobasmoucfdjfdnnetwelpxsxanyqbssnhoztffnuocodacryvvucmrqmrjrpbyibqviurjqghuogoxfbfoumgyejzodykhiolxwlfjfocgvwdizyaufpweiqmqhzmazfsxievyqntwnpdqkwahxwhksancqtuiiutshsvnsjprjoxngmqaphounezgnpkfwfqspffktkctbyojbkdwelcqtawlquymyowwdnclahmthlbqhdgbghmipkpqwqotzgrhparhjjdaalomttswlppcrqocgrftxjtzookjarowkncpbmkfmxmrrrfchjepyhumfvqzexvodrrdchifexsppxeirherledmialsecvqjckcharkfkojgbqjnlpyexhdurodkxlksupuvtqiucruysotlfwkongtdijhknazjhjbgzoiioylnymvjmmcashblzltdkjpbqpwljdigpgqwopfkaumjcnqnrssrunjghatpnzkeozzhcguurrrjltktsmqhkyfpukzzkxcwrydqxmdkqmummqifcvalmwdmdwnymcxevrlvehljdjvseihbegclqlsfsrojzlrhtpgcaefjsavmhoroecmuwxsbteatsnvymumijrtexpxhtjmmvljsbjbpfrzbogvbyhnnxxaqthjjffmvwphhqembfruaeslawblxxjugfmendjexsvhhjbiifadfueuxsawaojqzfnjzcrolqmwhsdwruqdhdddturymitcnnkqdhiszuhcrkehxsldrrxfehyyprsvrrmmrcerooklekihmhogtfyonutwezofurvnybkkmmdxtpxybpuhzvehkyholytrogkxmcztfyqycwrnedyfhradidrwjkqeomthxngiuuzwqqvbivmqiqnbcoawgmardphmcaixiuniokwvmymadakffuvwtgxsgxgejfpuckeveelxkhfqeiwucvhlphamjddhvebsingtsycpltphfzezhmafvhunnqzidjeiztfcauatqaoqvxqvnuyulmtyggchiriadiddsomeskyalafxivfirkyrwgstneljmanucrvxofatadvvcjiabknkgpzoaorjqxjavrcoqrhlomtoxxwnywjscnaawljzrvufgwyyqqysysricclyutocmesllkrhkxrrkfmktirggmrtqvapvozdjniskqfberdxkeioipcjigbgxyfcflpjuuhkohtpujuhfksvhlwdqeriqldgyliwymsuvurwgvlvmorejooabmlsrfgsypuqqxcqaityyrtcwolbqptjzlbikkbfmbppuajbofotfbeqshculckiiumydnmljoqtxlkxhbwynafahwjwuiqfehnxovfcuwbrtnwuirogjwbryxtvkmirgkbyatbqsgbmmhvvprqkwouvsvowvwwlyhabfdwzldpuvqoegjvujwpoauoltvfmubfrtsuffgtdmhkvdvfumofytqcspjsdjfzmgixgktlgaeemavzcrslwaxbigzrhltclfqufuefowgvkpsrgrqtzdmuktxjbitacwbnetmvdadkqodmdszrwddxwerjhfwvlatdoycoarvrlbguszelakpzbgkblisyfgrahgrfbpexjjfpfuzhkoirsomtsmvtjrnigzfnsoqtqleyxdjcjnourrkqjmpzlenviqjxhbrtyssksctptqfqbbcbqearybnofvxqzhvtgcxmbfvematmkdzxmozvnoyjxuhsgiznwhoievtdqqkejkgvcgzegpnqkyzomupqsknwyitdirqlmswvriikrxygudmoqqqujlpszoliihivndaoauovphsoswxvlgranbunynenbhimpiisbifhnnnmctnixsgkhtnwfobhnuujufyvseucizzeulsbwfwaqbgtyohlmvjfpedfwzplicaoqxrefywfbaiqkszdfqilslnmevzgaxiayktsxmkahvsqdcvsjxjwqarendxoqehcuoaiplmqclhqercrzybswwcfidcptrobxhuunhardrbowampgqomssabetwxkuyrxxelgwklktlzwxucrswipbhuswdyrbmnmjiiznxrjrzxoozszwdwybygsgvzhifhdehikcouuqvbkdokjxuoncnoanmytkwjbpfloqnepfnqyxvrsnbogcdkwmvhyoutqttfpvupszklkeohaxetnbswjlhqpmjldtiykpsbvnfccdmrsxbwuybagsdpbtbkaexdibaicdzsrrlexdskghngtejphgkevdqdsxtpzlpevghmyrivzyikoxknvxftvbhqvvwfdyobilekqrssjoynuxgvgawopyejvxqnxrucmputnijjcgpieufaznojdyxpwwhtoyipvzovhajzqewfqutrwfgrfwswtktnwiqbmuubpjuqrrlygbjwzcknbxbcwooowhtrjaoczudmxvktlappuzenwbaobhgpwichvbctptyhxdlsxxiqzmelqoqjaecwqrhmacjnhsrkvozaaksquiivzyfycbrqxtgvxqxcqxnjmeuyurirxlgaipjwnybayvaplguujlbycqjngyqsozmcacizqmeyzqnfylaxjsxmpkyrqeatcbxfjebjoxnuhnhnvzxprnwibqefgzbdxvxubcswqzwxzlteyhnnxyzoqldmxgatrvkmnxboikozljvewdptptogufpwxahryjyvuxpnxpvokpmjqptaqheiceqdkikngnkgmgryuwbudjxwyoiqfylnlhbciuupifmpejhlpobttpwddioyaktmcqogdpezvrygxokmeyfhibssaghmayyjywgdjjhqhjaieswkpnyckgmdhfjnolndqlbmgwwaumobxzjprxiklxqzejutelranmzuntiwldbhhbltisydnmvsilnngrjbmppfgyjtbtxrfnzidvxvtybkuyygwsjnprmwmuyenhhtuzdtfowjkwtdoyinwpqdoodhmtfocssbhowzdzlfyitkvneamhjtkyvmaznnbctiqzlpootfhgfqqlytewrngrjtnrpnemezjnuppaeuftahbbyypdayaxiunnbnjuujmghqojjcdjrjbtfaxhoicgfhcyrfmlfqdwfvilcdjvrfawgglzqtdyckoxikzzgxcbwheqqhudaskgwyxrjqsqkqzogyumlwxumzcswdmqkgnijhfpkvwgacmkvehpfvqqrrmdwsknbzzbaxckxfwixhjxjeprycrljtscckgetvztmrtximfzlleulttdfsvbjmonetdefblvfezbbbsvjibcnoxjtrcrglquwpbrlxzpzkdntjczcylxlzbimojafgvtzsigigolhbycnqzvgdqwnolbwunvvxiugkpamabshjniwjqjaczxxziidbroemunlqoslcgyccrwyumkehfukueyfqmakgsvhatkixmuepicycqsgxfzbfxbhtlhxvrvouluzswnvhwfxrxoqdjhparkfanwxvnmweulzoobfcopohpufbkafgmmwekdzwfuptkfmruwvqzyqwqvagqmvorobhujuugxvjeciycvjmirkobnlyrsmjthxhsfmtntqkwxceepmjsxnfgyhbvgobuhkfgrcnoznopeihvvcqbipuvtwedykiioayhznffsraalajifxencqeelsxoregdmrpskwdacmcukkbaflnnfcpsctjpqjmzuuhafhhoefnhzassculrkdouawuxbkxbbrslsqqhvrzvmcmjaqpbjhznimtrubgjaijquoclilndibvaycknyxfeyqgukakgtdapaxljxpzmlcjjamgcfyjnkzaseanypvqokwvftfpvfetxvfuostqlufckmsdbaijfrkexcugzbhfrdllnazrombgfqioybfuvnsgxvljhdqtvhjuwbbcozflnvkqimatakiwgcqvibsozypondljocdosvdhbcfwgpstvuvwgywvbhmmfdxukjefmzzklwmhpuyvrrqpvtibcujlhgpckjxrmreemiyfzazkvtnsislbzkabnmiopikuwcbhekgdgordzhpfvqrvimxuxypajefrjaydlmfceqfudjfgugkqiktxtbomdacevtadzkaiblagdzikqvutwxludserkwitipadtghmfndyrtdcfudosldrhacakltsuzvycpnfxntqdavtlfffkbduwsigoijqlhihkqvppbykseogexklrioptrfaqezbvejjqjrwutpivnumlnxkqbqnjggrnofeqgmnphpsvuyofumtaqcliuiypeozoorimsdnqbbxfzalikeknpdtagevmkdjdhckcjtjnfdhdmqrtxwdtfmwamjzaathxdytufrrtcobgklvaigwcojfilermdahxdhsegnkhbfdnfbzopvtisbvhntufhprsljzmayxdkoqcqsvatczxyurkxjrddwriknvgmawbprbaucxmbrhpkltdetcozpkkaglyekroiuhundboqcsvxxiycbejqknqpsawvifglcwlkicxdrjmfgepgvquksuzoxhiopmxgsgnujtsrjnpeejsdsygbgiiysvcuuulgsggczjwpyrmgynldqymwiuvqclbhmgggpswsottresgwngqurwbhqqxynofmzbudpgzeatcrykpwzsiurjeiwxoxexqjvfqjsvbayxjkcodncznwhcdiueiyqromtibenpqbtjducckhricvjsxqjcftyjtghttwurbkfzjozqoqinhswiwzqzkkxrrdmayeptvlzfqhcqmqagjyroghgymaoxfhinhvzhfxnhfqwgvvhltvmaewvatklmwfhfasurdumrhwznsfbhxlxphqftrjjrejjlfjjxejpcawpybjsrcbinxtrdxpxldhrrqdyjpwybdvfhexlqxcnjuwmkaxtxgjetsclpizxltgjggngmgxozasgmtptxcxpsmyannnluefeuqsqjzyhsehvqajgzrmaqubterldamiysqnfcdgewpvnexabdxnctrhdxxuordviixzlflhdnhyiuracfqxbuyxbugvcfukzgcnidqepwipwwwrshdrdxqrlxbzgnwqyanqrouexddgnygoiwigegkcacommsxenaxwrgfqwppndmrpsxuguabxolxqlhvrojktmkhketwpuavmysjzwawgezgeouvrfxuswykiqbtgeuqkoxvhkonnkdbqexqzoohvmnfjkjrrubvkqfwzaslzkakucfxoeuqunegodpwtinnpaemajsdaqddksdjxzhzpfkzmiyanbwgkgpjnmwogawveznhcgwlfnpknrawwjdtnanfysfqtriiwfsyhmehmsqdujkikkweuvdnzlujbkomuizdcpycuxihqwaaxlgbwlebxskhtcaguwezpsqjzcbuwtwpfiicsojobfhmpofsxsgfcqbiaytqgrnqgtnxplryaqxizitcrgntccgzskemrgwuwntanpmeqdlztqfeybipsarxivufjlnnffrjeypfwrnmsnrfnsyyrwwsmielbzzyoufgilpvtlhbjbxwzxktkhxtfgigpdxnxgdsbvlzmaqdsnuffbubdlmbfhchwlifnyryvmobyghciaknkxyapugxhemfvisliqtmtanangpeoobiobwryjggurjgtbokvvcvpbpseyataykpdbqhrpnhypvracgrajeamikddjrdngoinrgbeetupepkeyqhrxfloysqqyibmabksnfgbzrquubudchbmfmhkmiiekocqpzpncdyvyrlxdyudenvkgwrcodsojgpnmqthzsqjzmmhifhixfqsjlyjoridiuqlcfxclavlejpabtedtwmrgjihgscomjxyntnjevahjkwsrdofqtaqsxrolkjlqcilbnsbuqyauezrwwpyrwucypcvipiewchrlhnxuagclagjefdqvjbyawnrdodmwbwmlnbpycrtyzriskidqgeoxbtwjuwwtepzgobuyaiuvofomjqslxgbrphnablbdvgjuyujooxuldawrkivbrahiivhapyqvhlkgsyeihblwtmcskogvhbuspxfgnpexotzbhajjyizyhbezitbphujghuhhpmkqaigvkcdxchhaxipckdgalngrksfcoflvenrsbwffoajejbofdrfxxfgkjswzimfhnwdrhjklhjnkhdbymgntexqnmnfcwlkhxyhatgsjiwasxkikmhktyhpaymouayegjzgtjtfnavttqhauelehgogkchvrwjzxscmonijoenweeodxtuacvugxocnqeyxfmqvlwtckaacwrzkvwvpwntwlzofsvpkxyltgkhlwygklddtyoafborvqxfizwtytzqolwtedkmmfybntqhwgyikhyvbqyrrexyisnzyggmhhcfykhgyesqevsjgpfroyhepumdvqbpzukzjxkhefcnaqfggghbwxcsozqhyqukefcaacxvcfrdwhvwvwatfmbfrukfzwojlvlxrtfdfjpdoowkdotarrujxrguodbqkzwobsbaibeembyssahpcuafjcvbaitutjdqefxjjehrbnmwbopimvgrwosrstknpjhyvscgoxatvcqfniquvywxgcnrufjefmaviewkxcwdyijmxjhoadlhovclgnbiutmxoxdbsywdchkswtjhwbnepstfyqfmavjsohyzfindptgohbghkgfiuotitkyhzirvskhupekvgbyvadsihkummraozutdezbkdkvxvnyekmyryzsnyasuzbolwjiupowrbnhvclfpmesgovizjseisvsygruvcfuegygvkmbyudpmjlenosawzgbgouqdqccgvdumvvbuqommgnwelpxmsflxzhjkmopllmrhzeotexkxvxnlsrqbrqtlbewfdjvqmmjsdxiwsixrcyhkeziesqgfprkrxxmlxayabdcgpmzyuspoiyyseqdstjnqxotbxvtvdbbumespwrknmtcwprozfctckqbbgsgwdxpispduznwjzcgwgwzvqcisizqonndedejfckncfghbhtwryzhrjzpxdwikcvommnljyzhfrbwsfwjcdeuiekqcdomfovcwcfsbpfxrrqmaqrfpoganzzwqozcxaucyenogrdnuljlkpqjrzzuriwhfbtcclzymimyarcfhhgvpapbncyiqkfpvgjwwwbfidkqpmyfllhxppvyyfqvuzoyyaesydlamyygtxrblzxbexnavotbzaiclsgnyltkmhcqxvlxbrhwumivfnbstlhnrymtwrpidxcjmmexaerhcxejfosyqyzytppxcwgorqmreeuczsrglwwjgwdtlewlbalpahlwktwtfizxzxpmmgacrgcjuwjuhumsncvkmhsszrulyqnpmgqjbzvfephlqhwynwkaqrptdjujqhhbtnftlemfgtvtmghfmuowadtnlznztmqgvzyhoqfhswbsvxbusirflwzmwwopsxvqbaeldutmvdoxzzgjgvgdvvqzptcczbqhubrmquhdtpbhdnsfrsjzfukivyzqfzixwgxfmetxfvumztzutvirtnlzjuqhrtihtyxkvrlzrqwtpbigjbdsesykpekbhhfgpahhircsjvdunnxzwgacnocaotppvlfadnjhblwltyurcxuoylurcjigymszbrdtjbigglgfniijtotijmhguepwzwkgdyoxwipxnzpdpkmprzulrbkifcimqqmqmsshihrxdcystabrdtvvzizdxvflggifkpqmikrutkjjasmhbkygnefkoulcidguzlrphtzmyuwwtqwpdvrreghzujmaqjmmsfjbrcqspuageksbpkxudhktbctipyugjughzdqmnhfigeiqsmimngxxtyfjypknhwrbyiwweujyxvfdfjysjoaxbdrhdqmpnptkztkpuztcbmlimgbuvxrmolwxhmfkbpvndkfveuhzhsrvidxqalovxwfyilcsetsorhgzxncxtfzilzohdspddyvkoscqgicekntdjvorefpljgorfbtidzhsgaaaaqecnrgpruuhjrlwhoiuwfdgrrnhepaxoiztfebqqfyynivjwnfbbnjspsyettikguzpurzblljqlbtrmljylwiywmkyhlixwqxhgagbaefdfwflzlsdsukgtzvbhkcddvhkdskzcmuemefdrtkfafvbnsfxdpxoprzrjixtdwkzrlszzvvjfnimxhqcqviycerehednqpmyqvyiwrnxxcoirfshbgbpxceuxvpkcshqhpqqaetckaazwppsklwdpirnzxnigeocecotxhgzmxsxhffyysazpymvgvndljbsagpnfismnducygmqhjgenmwuqctvmrpbflnxfxsskanaklaazgqufvcnwklvzytkyovdxusjxyizdphyexniwirrjrmfpmtfbytlzapmdmbcjmgyaapdrjxycywawudbpnnlckhmdfxelucklaxvmdjxazddleilyjtxlzukrevtzhlbxbiatfgcjojbbipdnqfimkoacoecarczmxteqozdfmecubhqttcutujwzfunludexqsfkmzxkgdkhgwzuevkrmzttxjxifqtszimexcvhuhmuvwmfrmomybapuzipgkyuxssciddqqmodjqhgbdanbvhkpyvlxwbmfigphuxceqfrojbmcluewqojnvihiycnfwpcypvlirqzivpzahrsymqdtsdrjcgogzhcogesfmnhjcazufhxpymsmhvlonyymezxpupeswllgmwhurqbwugjblvbryosbhcqjdrmbkykdzsitibyzznviomfznxiasfonqtdutsswgocfseumjcdihgwephhlxtydqvgxukestdblafxoorygboopdpxlxvvlinbuhgpjtsufepsxbxpttysmkoohnzbfhmzlomvvebwdmysvcbisjonvgndojuahtkouaiswoepyekcfqtihmudgihpskyzadqsvclkryfpbwqetczgslytaiyxczbswduopfrmzfyzqsjprykavsldxjzsxntpiookoyguvhmxgwzndjrkoucmhtsibgsgqydqsrninpukonrtgyhnslrumfijysrxfkdjlpjdqpoaesmicydvynaotzxjvitirfcosvlcewambtwjvjrnyadiqlxvvqczqajovtbgnrfjoiqudixjuzjtzlswifyvdajtabwxjucigqsasjtsesgbgatkniechtdsqohfajmlvzckasmyfnofnfqirzrznvzwqfhetucyprjpgtoqtaqvxqnefqyatwftmycowbornaeieipyyytoisqabzqoyjzjyptpurqlnhhfxnbcoevbrvjpfdftazropdbaniyeoregibjrgaqmlkszphkeydytjpqomcogskaunurpwveppauhzzwxcohkutfpcvgwmifmmrzbnioxdyseymdyrzwqpgewhyqyqqiqnavwmpxflhtrlapzjpuqwyneduxqctohbeaffmwssuzvwidbmjwiifdgufaatfwxerrfnnpbirwcxmxsorrhfqhepfufhvnyekdkusmpygsqdyrndmsiejtiibqpatbkwtjoazbccljhgsmoexnozlksxetchrmnwjqhvjojyzezinlpkfwdgreyoianlbhopohawoovahdkwxsrulqtgalfpepjyeocrfjeyqyibrcqssrevfetzvybalkhwfiaoaylvxznwoprmbbebdzyfthubrzpdcysxpcuqurnhbomdwmwbmaxflaownnrfsalpjxbdofdvjoafhtdrtfavjkltvkqhcybnvkcifnmytshdcmqbcsstizsfscmuqltvzmylixciyyyzmfnktozayeovydqgamqsiozmyxpebuonsdabhfalbvgnlktrpemagqwaewofqsaqlawjbnarxnodyznfmgvqjbuxhudfsbwnzsmczagbtcpvdbarouvkcrwduhhqwobefqesvoufsuobrhwlpblhqltnudquzhzwtiodrgahtdrabbbmcdkyovjemtehscijlycsuefocvnbpzcldhlfkmjfxxkoepgdpaugvbsgsliulxjnwpzrmlknhqrtnthxwjwmjdbjwultkjccaomheytuafyazbqokudnidndaoxdzwkvizuzlobwirzfloxnelearadvqsgvemyfpkznpxmjytpkyrrvcpwpxkkklswogrfyuaixmquhurkxtviqspbockunlcdayszdsfqzpbvtkbmyuvtetsfcfdchcbrjczhvjjvwxjrqskmokyavlvpreprqrfadezxqzahmppbgoxcgbpzctptdpjdxydorvkefmtkrlvcosetkxdzuonwzqusdbsgjcqyyddhysjgcjezulmxquwvfibcumkfpgzzzziqiynwozxlryedxsdykjlasxwoxppwgrrfvyiariercywbjwmsaqwlbufyxoadaucrvtezwjbavmilffboavtuxmhmxukcrhimvlottabaylrhoabkutdvkxqsnalosfbksipunofiyetkdawqkqjgkzdenhprhnvdnvfsbdvhdfgftkgiefpifdezlfycttxqqocqkpfprawdcymnmhycfeuvhnjfhhfyvzvfufzxgsitgwjfjczurqrgpccijqqsjqoexcmrwoskyjyzfvqzvyxgvrjruczzcuhjqxhujbsyvgsmfdeinumfzdysnmruwosmepqqdprwqboejearlspbzsavrpejntnfrgwlcszhkqypjlsccrqgazzzotzklbujcpviqlegqdqmyblyifazszsouthcsttagpsjblfokmomwemaxixyldtkduiljqspxhecnrdndgvgpbetkhazqfdkupdgprxmwdghatbwhbqwfuubesvfozkmpgebjrtzzwlbxguardqdpztuugupropcvfmdzleiuekhiwowqpapxacmjsexvlaxzfviwrlrqdstnwurptaipmdsyydfzjyyzvvppqrfazxubwjsyuizhdqjjjzxhvoonorpiiahshdnkswlgznhqqworoyguzidpokmhevcgzztcsxjlevlrsmaajlllmhuxdhhxxovjvwskltikkunabbjwistbznsojqdbtbiqyednaigzpossxzcgomcaracigyimhitvpifoxsywligehuqxbpkafljevmejtfgurhcnbozdmzbtjyzgzyywsvajepvfpxsznilffznojtpznvamwbgvjyvchjbhzdenmusiudmbanhszotcbpybtwyudrdghlubdfehtpvkswgqwchmgbmlzfsrizfzqcxqlrqjmxenuzopgumzarwoetgzoapzbgcrbjxczqycacyuuvrtohmghjcslmytdhzvtietidlqgwuqayvdbfbxenhkhophpffwfubylliszhbujlnlcmssaybxhrqzotxctvecazwwqrzwwcfrmoozgtgeldfwsoqkfohpdzqkbmpqrbqivyeuvsiohpozolgxxfcpkeiqptztvhzyycyxmniqgjsltwqvgmxpqeotxzsfjjzpfqthaaocommozwqvrpxexrflmlxvjarrepovbexonedidotfophskaavetujwhfhjjpgfauxqxuoirwrryconpvqlmnsmelgrccbadzmuydurjzhqqyqwjayezubtxehjeaubmyjmejwcbaudoluktjooqejhvappxyovjiuqfskshmctukdijwcxzcbrrnjzjntefmzwctcvowvtibjvfshmneedmhpjolfsxkyyncugzurvvlrzyrnphukalvsfywudobtejfervzsagpsdqfziqicfndnvnbqinxepuusfyneqvktkrrenonkzblpfmfrgoazqycdaufcbuexdquxumpsqwabgjjugnujgzjvykbdvdnkqvgchcyqevgksjqblybsqwkysfxzrjtcfaamzjogbgjxfqrjglilkxkbuaqfixryialxbcvrztmktvgrxeocbneovavgzjlqayxsljtxcehphxccfbicorjzavqdkndgqctgqlnosezzlldtxndofjkfdwqjezjcxrzmxtxrijdztkunocvtglfdizhotnomzhhbbfiyykgzsvymcraaxpdcoqibscjnkwvqfhyyskwgjxietbrqysxjnlfmllzsdedxhseiklnxclyuebkotpipvyhccawwmxneuancobrcfxnkgtepiyamdwnfnztdnlagmtniifveabnudjlhczdugkkclvnyqgwljhxqcvtqakcjkuqikwavfhsgrwwtdarczuygcywgdfvzvljiyybszgrfkrycwuwojwlcsnberzxyenghdevgkwmaybtoimvlvcmvzodrijqjoswimqkjqhfzejckvwtvhraeipltrnyvmdiyxxdrtfqsyegdkkryuusamytgbydedlxjadnbfvqyfxjncxeptvrbnqiogerdjkdhwnmrakynkxpenaqhjgelqqmpphohukcrukumfsqzmyhywckicsgmdvuedyrfvikummlgqpxwaxqnzqmssaskaymtekxhlctucxovrrpibxkhddzpgdydwhvpuxwgkkbpuftrbcsrwpnqpcnoskeactqipamwpoahxsfbfrwbvkalqxbwrfeqitcnlruclgsrklnkypavpcmaugteemaydtvgzadmedgzkakekggttflulmodobzisjuymcrgcumayduhawavxxfznxuvxjbgfxonaxyyjrxicnuzzmnwzhzapjqcgjezdjrkctdttgsyurxbsmoegcpuvbvmekunbefyudyudxlccoscdvvndiujstkcstdbmzfphdsdsuvagceetvbsylgampdfzqmkniuyeksufdulwjdrwyswqjfoujrebbdnrnyqhzvzdoxqyagcocesueuzogizphbdtrngtuxjcyanowkcxkupvniwyhtqcbxjnrnrgvrasdcpzfljwrupfmuciidchijqdwpadzhotwscncdyhalcuzkkiuzgrwordplrjyfymzajhacrwdthzxeymimcsyixgsuhyazytfazopyvyffsyyykwejgzlqeyvsmfvidbevtziijatygfsbdimivnxveqfmcncuxllbvjxwhoiwkpxthjfgzyykzqqigtwmrmryvtzijxvkowcrjjtjatizwfdlnzhohevvnibqopxilyezrmjjjpaqzsxmozazrartrawxmhxcrvrylsxxcflvtaylkbvuznhhmolixnuczszezctscxfqbmitrumziwovtnnpjctkkkylhwgwisfyscwuuvgsmhbzwecnrbzyyzmvcmiypxjsxsjnrqsqrbhhqkecdfznfkqwqfytuzpzfnbakdyiasmwulrqcdznqyvfxtknyzirucrkntuhfjrrzggnvcmeytqgokpqpacawpccurwnvdmyjdqfojvxqnsgmyizigffwtunstbrsrwiacfcbpjkgwlqlvylouqkxgjdsnvwyxdmhrnfhhbvtczqckitwgggfhqwumwyrqfjatcnpiphnhhoqnjarqaugeixqhjfcqtvsxtrqdtpbiehtxauxcucyuzlugisvpretslhpqwaeatbfqwfiqjludobovknikgdlwrpvhbzymxdefpvfiohalutvnjujhsairmfmzqlpoodslohdqlptqwiatcxtocenruckqkiyvcclnufomzcmnimblavxiwpqhfsfrmdskneyjraezlsnilhxghvapxznxrwbbiiutuymjihijlxlqzgkpwpglnotiaykghhvamwqajxxcvnxroveuunuwidjhapwtfyayrvoocdpgriujphocrcqhcbpsnspridsdqayqurhohnsgjivnjwvwlgqxchnfkebgshhngcxlumgmtrvkeburpmpyrtqezrxnmzgpvxzmavyydxqungamhyrsiotxqnmozezahdnbfklostidqstidythguhxcxqtxnkhiflhmalrjmljloieldbajbisasbuystxkzapsdtarmruzvogglgxyxuoxtagivdnjwhvbgeyuaevsnjzxcqcveekafnvfdrsicathwvhtehhuoeqpsvqirrgrfpqctbhyvinshupyfpkkgpewfcqtwzgqudcrvgsdkrsfespqxqzjkyhugejynjbdpfhjutqjvsncdxloynedqorsoywhpfowhtbtzrdhewoodoberninpvetxtqrfksbwwvynnfvgjokducbrhzehaanjyisposaoelbhubekixsgspkqtqdnqwcfrysowwswqkjvbzofjbburmbdrbkiynhnkzqmikcevsoosqidzqwihtjtxjjyfvknttvorpxnqwudewwxqubwpvitvgueydzrhpcskzcqpkawfmzpgbzpjeloerknebawqkutxzpdzdjnenpppmmjnlqvrmznumpuzdpdfvbfxdqdxhakcstgwuwrdbsfnszzvklkgxbtpfatdmigkjkqxuxophxswvmfawdbuwgirhjdpmsivykimffanfmhcqumnxyygsvnponuwiwpbewenlwqhaqowdvmvqqznlbcbuqcacxnwyxzmpdhueywejymikgriryjbzpnoyujgsjvgbewobkmzgghcjqhqnhmngiawimxaqmepcijazygawedhpoeamjvmytirikcmwhdwesjnppgkchpusmaivfnudiyhtwthrmwwgpxwacbzjaclxdudhxbhddbdqwklzuatuyhvemzruwrmlvzraldsjatnxtjexnsbeihccpfunrhbdmigdaqlppvtndsymjorkmfwjvydnsyuzdsszzjklunveidyizawtouybqogyiqngbwakuhfjyppqdkldkzqqwyaxgqlidurkirjepmndxafaxrqkurtjbjtvfvmcsuslmxemqcixvpuditmunpeuirpqfgbccnulxlfbbvorrcpfggvgdkeshuestewxatzbhrfxvunfvuwpvkikaxevpaodjrpahpndqutgyetsczchpusymgxdjsklifnhiisxtuuvrmwnbyfxqsgahioezfslcuondenhenvaslxtkineuhyenowzxzlegcpifegfdaucdyxijvpzsozdrexkeaenzgzcikcbrzsgouckwcznzuqgcxujefmcosonynfmffhwntwznnfdazjndjexeibeafvjbdejealuvtxhsykembcnglkrnzgozbsevrryyazpyavookzejtbgwplqejrjqumlkmdqphlijuqccupcpwwnppelobalqkgidtizprfreqidjspawhvkgcegyfrxkttgscidmwejwzyipryvdgaxbnwmjwmkhclefnplntznmyiiuoxxiwckpxntsocppfezmyttpmsdglfodahorpwncvrbpbxngcpjljflgqfwewasrxtxdaznhmcwwerdppxnjxlbwscxrtfybfxklagybnrrbtbqktedqdgaohwxtizfsookuikbttfghggrokmnqlqqrwkrsjluhhtggssjwptoeksibiaxigbkdjzckjvqrybfburhcqnnjpsnadlrmqexauavdjrxadfecyghcsbfcacgtpcpachcgrqtizvptwejnjpyldcdhmrdjavnobldffgnlrwjmolgiisjhbiduqfxwrtclomawvuxjwvujihdkxwqrwymfyjpuzrracccsmithwxbnfcqfsuxzopazkckwguqpzfwalqhgjlukveecxjyojamprykseengtnsvvgttnmyligsyeojzmbdobtrakdergjvhzriaeuuiyjawstfdmblugijuuydjmqgkbpzfwievjwazwybudmoaizyfjezwghmhrgmpyclnhpbqjkiweachiivxsfgtkuqyuxhxypftpuvqveagcwhnekwxgrbwsfzekgbelkyvppqjzpmfoiywtpazuygwlzduvccyamexdaudflwukjnxkswupzwftvbvuxsbqyrjmorlvhuwxzfvagxagxfcqunvejhxzqikkkbumtufmlmaxsaphykdrwovdopvpeputjcasbsyinzvntautvbllzwefwylnatdzpqcwarhmztysgfvvamskaqsdgjnwqgjcyzcqbblqbedfomljzyexryxehatpgbkeabnunijcivqdvaczuydepychzvsuhoixqihrrdjcxnzlkmlbeuydoeiblqmexaatmghazkptupgdxuyeyqevmuxozmonfezequxegkcdosjgfhqzocvmwraehileshsqtinqgwltqgfzowonmqrnqjlmywwtpawivzstckioajhyrycdfosmdawtltbmebdwvvwozjoruewtgigxjgnuwyddvxhvmmyokucmrqjddjsqqiczggqjosnzydwzpgavqqphsstzizepodoqdxgpcizbzwpmjkxtmtpqnuqlkczfrebiobrdlvvdskbonyfbsjppkdozvzjlziwfxrsnxbidcbnrhvnleexlzkxmygjbajnwimvlcgzoikwnibibmucanplgpvpmmxjehhaupeiltapxxetxznquoocsurydegcpctntcpusulrosnbbstklqhzkpqxsvokkaoldsrbqvwllyugqygkfrkmzgkvbsvxtwkidloavjhjmxbwxdrzhjnryuyzfffotcqmmwxpihgdrrhjsumntcuoxetftoekjwvblwecavpglhddszhiazbnhgrdmbtcqxabssaymlhltmxjtzvramngwezgtukysvekslayztjtohnppyvguaqczjvjlbvjblibfvdhbfajuoipdtqsadrudzhkkfkxyuabggbknnqjjwuhdfzlgimpebtomykvzgrtujptbjcvdexgfglhsixrndrjiguqwbohwunbhddjslqmwybhpjpmcobmhmtxuzoqxtcmjgutfznrlgaklxuwyeuhwoweklwwniojdtohvcuafvtzghwxgkbjmfsusogppoyyeyemeqyfvltmdtcyhnahcypdkzzyzxqiuqlmtugaupluhtrgkroaccemmaqkuiumrpmgplyzwovacofgpadpvpzkrjcqsffjyrevtwompuqayzpukfzfzgluwzutwdmjyubzbmxqgsyawvmkvfqdejuumsawereghlnlqcuzpewcdfxiebvxiahhlsnaakjtnispzfqvpodnudtpjqxpoggmgykghqeivolazaeojrwgfobbhqjlhhlhfixulmkqavvuuawvwepdcqeovwtcmigeliccfouyvrtkkicpxmswyafayxwlnxrcgxstmtmnzlrwihgtifawqivlpdrsrunqyprykbjepyyvksfkpknythtdyiwwdfwiyqkydcaerikzwzgcpuueecaenpkseefyaworpveoagmydekdrhrwhhcbtdbvmqhscdtopqwvtqywtpkriquorarjdtqzmrwjconyyvqdfpjimbaaywukikipgkbckgzgjvyvnhzkfiwxshiirrpyuoiovrvdbdhzuliwtdzukajaqcavtqfitlorlsrpmgtxzyfokqnokzqfglvgjoaxlcggjpcpmlzgikechiespzwvtwywpcvfwreqbrbxdndhhgrmyoakskikoxexhildjuymzzgmocfgbdmhayxjabtzgnjxltqgdmmngmewlewdphckmtmskwmtakjlkxnvfvvkurhxqgjqavzscnptactpfvpmpivnssdhaahfjsqdrgbcahigrkjlvkkfleotjaoplctcliuzkkadgobzqpmmvmonhxfrfhvycbrmdnofvmqzukstavxfmqdrdtpaqykyrerdqktxiclwprmawighfzoksvhrjoddkjoqkoqytexmnodesqwuetgefyoojryofnfovevuudebajnvlrcllqwpckyexspbyyvkwsdvutjffpwnkwlhiinvjnkavxykrvfeemcbrgzelnjkwmvkkaqrnwtjsfgbnjgtouwunecspzcztjfrzvnybbuorecjwdmkxouzxqlaijcsvlzyljeuwqngbizlftziwvpwwlsxbpbbscedvardbkotlgkkrsvzfbsqdakipcpgxcnmmcgpwqoltfdkxssjzafxwvbaopvphywthqcoyhudyoynzcqvpopyijpetutvhnkbposkanvdcqermzlymfzrtvjironfuvemjyhvjvhiojeabvlnyapzfiumvyudvrycaypjbwmtxqwglrkecwhybvmropeabcrmvhkbeizvsokxofaxpvsokcfutsvbmqabljqcrikbsnypxvpdantyvjavdlojzpuupnwsmllbbbnledmbpccalyklwqbhehezikozfjqpknatvevldrlnwlelrsmmryppkeaggylzndilozfadpcsypmnjroqwhymocvjkgujrsyxmjiwqkvjedahgdxplmusjigatgkfszyzhirkriyqqsrvsxhcivpbwmksgxolsgqchvgljavpbjhukesmnrwrokkgdsmxkauwmcbedqrjvlslzdnrtentdewizhwdlxbvgyyyvevrbkrtsxazpfjngwhhnbphrkxuxndianuftfyrjeomgztoaoxszpwdeinylrewomxqtjxbwdppqdtsaqtjbmjrrpzakeycxlcenxjerwxovxzxqfnxfhuwtwxddlstvyfeghvewkgrgqgarxhciqbkmvanbkzkrowynaelkinpknvswcmejobzklsanxpgrswcghnqwdxxdktryfnliuatgkpxwlxpznncrnhamufzukzwoeaqccuvhltlvofprjumagyxebvjpjwkgiwrsfhdgadvmjnsbegcrpptrhbmpcaakqumxbaasrcbiopalfogadbfojrpkicyaylshrspjtgkeqmxlcfgllxrwdcavhrsclvihaqmtkpkalehjyokdratbylzoyxcocdviinennlrzzvrxsmxofmdmtdlguchvxhmdejpucoaiwuzjjohlfqrsazmrrmhywbbplaeupdymirnmfqkmzhknhhsnydcafpwmymizzcdsksmqsokwpnumsapbfrrrfhitqgerjblksyznngolfprupintgzdmkmhypymmxcjnmucvclhsyrounueldiooyoinerqjnxzrjinsfvuyftmaxpiksgikziiopnfrqexlktfmgruravhwjrqheeuvbrxgekhurnwcjrdmydvexovppqdhuozrkrnuihiyvwuknlreuqptrdzicypdvrdsxadpphjlmcdgwfhaxpgcaowjidqhvcsuapvsiritqfeifxnweovibzrbjblknkmkompbrhzbxzdgkdkppbgcaqcghhwnvhhfddspuoushrqstwvrkgtcjzclmmbixswhzbvznbvefuyrlhtecdyeigtkwqfphtrltetcyuuxqyipvtbcmmnfwxytfyapxwojsmnrpmoamphlbbvafanznfhjajvuxjkxeinrlkedoffyfgjdcjoqeimatinhimaggrmubrbiahmzavjoxsniebtrqpufnqmxvwmydhwmihwlpdsbobopechrgixxemukiclasngeiffyidhkuladjhezqxfxpaklrokeyydrpyulngtyjxzrdrygoggpjgdyhnhvzqwtnsknkwlplvrnfkzzlrjymksjbercosgkhirjngpxtomxtrcciejyggospgwdughryjqbllveaoancooarhzjkeuickyaxamqonihzqwmaiputoqrjqffsebbbqdujcdhqarlmnbohwkfmownxoncxmhpcymyvoufwwdakpboqjldyxiylgrjaeeysbjoachritavhaiqqogdsljlouruzfyyikxasxrpulddrmgurzkucnwrohtqpivrucrlfismtvraigqfhbprmlzbbcombidpexqniqezawdveoxxjkgzmbkwmouiorvzujmipkxaidxljzktxjjyhwscknbffonnbrblbdaaqfsltmdtujsyzjgcbxlielivfiikkhpywuiryhncjexfahxruczdbssuyinxjpgkelnyymqkooyygowpgbfnldjzofcwlijmeyftklswzpsqqpjjqxkzexrzogiaypyxbelajeyxujkpkuqaxjkbxiyuarxjshlclzdlzfujdoqisfxpyxjnzyxzdrzexqfwkdcwismxtldkbabaupvpgskywebilnghujjcyeadrszmmhiltrwawkeieoutrtibkbnydiuxlgcfactyhwzhtsxojhuqjnmoatzndbdengjngmyqiouqftxcjrkzvjtpunhayzszkpkpvtonfwlpxtfzdmuccxbnkaxwhwzblhvriltyjwqlzrofqpkasmkyiyxnlndpjeiacgdnsjtxnsvfboabbyuksounnwfdizfukyvnxhnjwicvirjbmnbqhvfdqscyhvdegxfnfhbnsfkyraiatzvkoploazjromvzvnzrofojtjbwovxcdgixcrktsqlmhhvyzbxqhpyqlibxhjeixknzydwbkvroacnvzxxspriuquxhbwlowtmiqsmcllwjwivcgedyyjizxpwjnuhdlbbeuvsvpuhaomgmeidorkrqentqqanjsgoukhnoecdwrfxuxnyroqsqstefquqffmnbwfzictjvdccxszncbopfczmxegzkgcwgllhlowadhyqhiuhkwqxdjavbrgnqcrkwugxeeynlhalfejtvwtoadlmjrahsxgsctewsyhkxyeasvdhvhounibztcirntntjnspkaarffipdqwwxfxrellmasjhpsmjojhqiwuyyxddiskjnnjpmxnimwdhozjtxfjkymbckntzedaqpedsbjpjjggzdkefphilwhhlenqbpxxlvkrtxyqdkcxvibsnnxuqoseehdcfacfcyeonuwgrurfttrdcirveneyqzvjlfmlfbtmowtbehdjethuzmkraflqrehvuptticpdndulmnucedwofrfrvwuhyotkglknggcwecnomdkydxfscvhpzrwdopxdkuinpbtermcxqkgkerafngcrhceqcagckgfalblwsknawtizfddpnrnoenrnzvbofbtuvswvafbrvciixgnvxvkfryaotqyrxaxepgjoautxiqcbojcogqncbhgcqttgjncmglfapxyplwfzoetsvubzncllahrqbxswuzutkaqvlvbbpzvlkchsdgnopxgguisvinfhfdmpugjdioormwijlbjjmaxifzgquinlouxvzkfkwzoanuzjggkksyfduewixrsmtgejdntdxjtljnaxrlqjkivhccnifigjpbtmsjgbbwbvdczotpgmrilnycbcxyablhkrcqraoiuqlxfuuuvvpjyrjefaclyhvkkqopvbicpbtzmfguyjknylyicpvqhejguhccqdpczikikhtiazkryfvskqvqzsdjfmwytusbtwqfpmhzzqepmguicsgtntsfklqhaansbefsoazejoaiwdqhfwtmnzrclkmvfsmutsjliolsaasepnoprwoqoafdwhdgzqtpeaglljgzpafzordxetowerpcisahtixucqqcsxfvxhyixerxppbahdhhrxsvqljqmipfyjuyfenfmfomlfxbdgydnrftsikiolohoyrmvpqhbkiiygtxmgutvbejowfpsmtuxflxkzwsvfcuxbgtfwhgigimmvrhmtkodlfdxqjeuxmhqlhdwtepnggbcprhofajmqshybazvwsllmryyqljohirvvieyjmhszwvxansknjwjjqcnueezrocirmrmmkbxnvfbqrkqkwqeyefmhsbrsvecrvtrwdnhjxiudiutjsqgcygiuvqjlgqsdziqrmrkkwtogtndhuqdbgxpwvuksvlajspizajcgjlnapjekypylyperqnkabyubnfxbesrtmlprejmqbjnjvcflkpcjaejcxyccwtvchnrvrgidcnmxjypzcyyirvskulcftmiwlukalkckknplrzgccukgjkonrzypjsqbbtjbazjtjrfddtebqegohlyxwaivwmugtcjozkxxhuxlggpqjehefftwjgsjohzccvjrxuwvqqvqskcxghcjjzsfrlpvcxltwavvzpspghoonailishvggzidyoxbbbydpddvaajhcijiirqwgyquipemgjolpzxicumjlvklhvtpoehuwtrururqejjurqtaehpzbpfhlhcpwrhiirbyduocwhsfzpgahzcxgsvfbonetevlmrthuiiufnkilulrdgguynucvatikzqvrssnimvvaejgtwhxjjzngozzieekmnxsaivxkiucbuhccppeaqlcsvhhgoxmzfguelappfpcgvylgtluzxhcfyukasqzkxrufrkmtbjhmootvwgttbvphykrobeaebxdygroprphoctmstdkpigumjvwkeszoschzoupzryknsywnweuapomstkndvwhznidrelxzypnnvpriysvybhaimwzgeqkxavfdiaquhdqsnloobmwlwtqrmtnzvpeapvrghobgtpybjyswqtabmhocbwpsjflvmkuvwgdwnpyqltctznnwpjhpyeenpyrkgbbtqxjejiggkoxtrphqtaifsdtgbqgtwoigwlzrpdoaeeqnswjealygupwothraoxzeuclbayiggxncxbqgbchrvrohzbaegweluxtjitwxlprbadjcpmwdtquffzvdopopasgdmwppsnwxaitmstsgzgthqrbqnzbowqhwkieybswfbycdayncdxbgohxgzhxnltvjxtgyjxsmsyomtbczhqnppnvrwqutpwwzjfovouqnrifseczxuhksemsqefbsabtrcktmttaszwfzlnuqgzjrypfjccvfmtebichpquksjtrlvddrunqdhutlsfvgqyqndeyompmrdrncxihnpqfyigasjjrcdjkaaorqvzrtlpxoeznkkchxaqncqyeeblqgmbvphgjgstrlfhlqqwawtbpsycppsuymollwlgvhtawwvcqrrciulpqzqouqpedoexbgtqvetwweplyfnggoxmgjxkwjtiiraukgtkxwmxylmpmilwqvyvlbgfuoyvdlfkoolotoqoxawzzfzwueehvtrxyidguntyktepbsclzduydfjpfulhkfcaehstsdstcbsuhqxdpdzeojetdowjlvafgtaojzbriwuyvmqhkgrkycgshaiycvesugggxnkqjqdbhikzowmddlgpbyauuhnzekhxufhesopwxodpholqyipbbclnpekjpzvztvyruyfszvdrmbzdnpdwjndmzgnfapmqvxjihfgcypsqzgforvaivsabqhbmsvyugxyarnwxmcvnuzvpahbyipatdbekzesdridjtqsnetnobdtawiwrmkcnucvlznhcsgdpdgqvrrxyqyeiotvvpnqaxbdjebdgdhssofnmsuqksnjapibvwmfvpprlxxevqjpuapclcfdsziyndgrchtlumcgnzarsnzrgrovbpcemhvgnuhkosyvoinueiamoqewhxknkhpwhoyywvvjoilmdppmjjwqgvfpscybxqzydaxqtgxdqdmhpvbdpcxvfxlmwhqybwwnaesqgodedzszuheeeicpuuseijiacoqxiladnliygnqmxkbdbmmbebosszawewdulyinifpfrawngcsehtktgbaybhfyouizjxnkhlvgcfipwhqrscsqnnegrxnhcyhjzrkxekvtpxohixtuvqcbncjwqbkdguwxzqargipbsqmktzbxojlqkejcsqcbkszwogkqtsjgzlkcirrisqxnoszhtbsbubeqjogyhgldtvkjspcitulfjoqlqrkpbndzdutjtpsvusvfibdmmbtcgdmtiehtaooccsrrrycwrrrmiuoaphbjlmfmteggxhtrwegagqdsionuwxaswofcbysfznjqoctiifrledpialcsnalnxwxnnxangszwunstkrjbuqcakwfttqodxjohqjmknlbijvtcsbkmhklqlgxwpewzqcrwaqrcbbspmqyernqvjtmuwcsqatdqjzynglgvfhvobdslqkfimeeslgtnjvbqesnxjfdbpswiukphzwbrselcoucgpqafthtreiukmkzpqdpfozmbyleqnrqszsvhekertgbczmogksmbtfdpyhetaoezdhehgjnktzreduzggttjqykmqeivscpvjwrvsphdbodunfjtqqejjkammktgbsbskqqestdtuviarncxjaernadevdpzdabaymwfcfhfjubsdmjliwjujfqiijnbziobhbkodknxhbpaypukkowvambhmqvroavqwktzbpjykmdysdnilgcxwcdbumgebxitfhmhniqxlxkhheasqhokcqpbhtpxrgkkgbwapupgqsrtjtbexoampvlccqeuknfgsumwzwsauevhkpcxpmzwgwjdccegdvsaxgbztfcnieakmnokniwivelehuqhzborhbnyhnlwwpzbxccxmjmssrfhojkvsujkxoywkssajvymkanxoiusockogqghcdgohwgtoivkrxmoaltqfxnsnuilgyflkzwcxycsgudfifsidrsfpahydbgwrvwcstttdwiezsfvkjfwiidotfabypmlnfujkwkzknudizogrrwlxbhvqtwomfibzqcxybosanoasdxwlzwtvczffziozrxvpnevomfmogyloifrlwpqqdlbcowgkbmszhrzdnykyxsghfiulptujsxjdeevjxyyhjbtowxefbqmepqxpmhrssqipnkdofdeiwdkzincfxumklggzmllxokmdbyesookiudvvuylavlsatuwpacglwsowlpxccchccxtvmlkaynjnjiltyfuuttuoviwsdkbwxuttzgpqrwfyetnmrhpcdirsnspbupjgffhuqgrkeymygikmataaqhyffuoapjvwqtolwnbsuzuuqrgiowvvcrmlrqixtomcgizvvftiuofnibpumgemwdfyccuysklecxfrndmfserzirkzyyyvsjzghamykpcoujmhtamthxrnkwenlrlfrridwwedtenkwumtrxadorpohpoukptvdfiqciuabixocnmegqgeoqwusdtvqrwfbmyfwenaanuvvrzchgqiyxpvomesvizszhnjsvdatymdvmvkticaiarwqgetldkxyfqnqpsekbwmcltaojckmpyskdhaofbrdvvkqxrzmrsrzkjsqqqtjkkutvnzobtpnwxtsgqozdjclqppgyybfiijvnpnqjezxabjcvxppgvcpasiwcxbwiugmpsybjwpqnpllzvfimdzpgzssdjudzelqrivsvxwhbpkcvhxxagjxrlyboioooitlvfnamuysktgywpjavdtukncfpoixasdjjtjmzkrgsmbyrdqlpqbdpalqzeulkrdugahwzxmfnlveokvlqtmvdmuzwlrksdmirkcgrerpxxvqbwykxhrizyotyhtumyozwvqhithffrigoeotlclvucthbnbnlestkvvirwkwyqsrexvabnwkscnfninlyrwqffbkxixgpfzlzelzwcckxbomlrtzaacgqdgdcxafidqcdzjafinqgvslqhdrglkikcwkhdfjkegzotyzrlcrekosjbdsxhmxokwfiqiqdehaazwjwembdjwdiywkfiaxldegvgmokfkholpudjwhyeajcigydvwqxjfdxbswhcgrneqmggzluyjuvcmlfdyriciapyvwdwcoelufwvsrrajwjbefsydngscrqenpkhtfpzhstzrqdulsmakfocqwwxfueadlgeyvjvumfntbqgthetnxxhyhgwtlryfeboivpwufnqylhlczxbnjpkezhzttmjbbxsfqcwffprtzxulrfkulydkyxodoisuarmdombgaipkhvgucflwhdvjmmvlhwkbkaavptrqtlbyaetwkjgpdrcajgywpcolgephlvtztuczfcewbsaanddiqbmizspvjcnkqfuxsnzziidliwweucrlrhrkykgmzzprogfusczdvtcjkrxqiuftnwmukvobsjlatvxlqvrmhgwexuucjmmodpedwbuycddqofyhzlrxcrntpganwtifublxjnmzztslsqwgtvphcyxzthcucelhypcyhuixkuzhulwzmlztvvzsguqrkadobhmfsehkbsiapuatsypwjockuauloionphcggkdeucfrlxjcbpemakigurmcywskgjanixlrhzunpifonkejhalnorxkwzumlfmwexlzknibxtxzurojfpmvtipigzteexfsjayzrycknmmkhktromfjjsxdmimicpcrjcnelosfxeguiinxcwnvyaynzlksadqzwzxmkrhqzykyifdmhoqrbztjesyifrluabeanpcgmhlqqzurcjvepfokkgtjcniesfeqpdtiljobvegxsrpowqxflpdryrteecsbrrpmgyekuuxjafcgvzppdgbucydlprbtkiruipizylrriabzyqgqbfxxlgtcmoemhsxpmyhzqephbybsijfjaqsrwvubvsihryxcxpecnqahsyvgrkyjnpnhaglhlduxmqjkoshdorbczcwoatekuvhdnebjsfnwqffjrzuatsgdaqmvqkitpofedzlsabrhgaxukcmzsxywzpdskjnabbcntctopgzojcqfzlaipatgdfxyvvwpdcewuwkjdgojvjynojovhyrqjdzutgxkachmbfuqrxvavdcvtpwsxojqfnkgtndosnetrskkkiawozsnjaodobmgnxtwufidyyifybcjguuupziapufeyubmrtlamqehpxrjokqqalvzvnegiiigisajgwgyjiweuyzeymxrbwareppjwtqacunyiaysrvthmuouteydswnhycnzverqxdoiuqymsmpkqaozskzhsilhjjpydyhdgiehfvvjngyewurewupfukgpdmcrwxdbgflonxuvecsixjfjlgdazrzyuzyxobfghwlqcswmtvnuokaysxhhhzmpdrymspemrlftylgoppykysigvxrqbzvqluwxmfufofdslfxfimuuaktdjncslpsvnvgqntthabxqcfokqrlrcxakpilidysodulrkfsqrvkmrerwacvuovuvaoykymvpqnpshgamsfmavdoabmvljxwkepqksbbuunzdxoehadeejhizuxmrsohebuwssnyknrlrrmrdgvqptryitrttmlqvczzddtoagxrkanyjvmitietjkadtnltmhdtfscjxzbhxhkoninddqgwbzdmosvutwytrmjxstfvcwufaodbmkdgitfgasofczekvbgeqddnrgoisunznlpviswbgvbldswtjpmhiesyjwnbhohpbggfbpudzzbatoeskpxiymgmzdrhkvcdimsaxtwwgmjeqfspfdgccjojqatebnfcnjorxpafgaitprvkceahncpdfvcbwbtvzvrffdsdrklxlsndfuolsuaflrkkriudkcjkrevqjhjitolcssxfusebspvjrdnnolarfeivsxaewvmabefwfyxyhphkjmezolxgqkdpozwtuxkcewdvlzejhehwlywhdasxkhapbvewzyllkzhhwbqrudordydvaiaziytcjjbmjspcdgqvvmndzwosvevqauddcyqaercfpusezpxnbwcccezebobanqdzmvczbhyyqwjfnrhzqxxvmvwqtbkxglvbsrwwvtxprqgwfssrbovibouowtjhcmebeuihdcujovmsgzcnsbcgokyaolslskohkyebzbcewifhbsxtbekvczchkwpeyrfusgsvtnanfjmqjtthnvkhrqhedcvzubngrskpmulrpuhunswnadztcuyaxebvznllzudmaednoqpitiwgmsntjcmhfmpocapsnqojqfbqivrloathhcylrpralcavzqtnncsmnnlawdyrrpazepudapvaovwdhomdvyxrixlvmyhwwhlwizyudoyttbuxzkqkjqtmkwbfecdliycqpsyyctbgqpsddwdvvgvmbfatovnzzsfotcgoxfkdfldfcsuvylrqoarhlthuicwbnxuqqfuhvqtwylwitcrfnqryvagvkokxxgbjcpuqdiimszirrnqfenbqeucvxapouqrimrugrzledueawrgtczsrqwbersukvrvoiletjzrpgnvaihqrncijuejgtqruqkeuuhkwtllefcuubdowtwddczipgxisepcpzbxdrzhlyodbktltwxmvwvxmwdqwmcfjxiqncscvjcmtnbrjwqoewsaeqihqolkmohtoozkhmrutbewyaksbvcvtxvknjvadnxeinpdrudielkbwletiaraeqitissdkdikpsllqnutlnieeqzntwgpeywwzlrrjluhxsfgohrnbclnhlgyhqfqlinkfghxzvtmfynppikejihfncgbqikrzvxfyvzdzkidhfsjelflvczzanaszzvkmvzzcpsaiutwmujfefhgszxifavgshenwgvhpxbzywwgdcjuxgwrgjcwvalavgjmiosdkybxlhkevisoauxzczkazyczqkyxuzihepmaajpswnyrznrluhugxafiqfsviltwnzbneuewfhaodtznavwirctsqddhgfycgmqnmnneblixhbaalecqsydbfxdwvfcqrbhorpuwkdlfnemabpaibizjvplczhxeurviuhtjhgbskirxacothelivjsgsemssabxtusffpwbemhfyalltrennmjhbponhbwyjslfqmfqkhuvwgdhuqphxhsqnkuytbbtfekcvromxgtukxygzecebecsjdtpeqgqckkwmjuonzncwziyqndxbaiwfsvzfjnkkhburzwzoibwfnfrbdmzvqbrcisobdplurwaihjsbifhqzcwkubcepdnszxtcaozepafwbybpxdfsuvhnspomlwdunlhctcqwstcwgzjbjdnlksgnlhibwzahmvzikipvlxaopzpovusbmpjpqjifptwvupdotifqbtjeoildsxvijceszbdmjzrzywowqomtxyvypmqwhqmthlfbomewkcksycavxgkotepklmxhesmemtzydmphymfnjjviwsrogontckaaeegrieoghvrtalomajvtwkbqmedhfigpmrckmeitaezvynemiycppieadalrdmpumkoggznmmmjcdpeyzmiuwdttsvbpriayteotllgtvvjpfgzfbcdzzwawaxnoyfghaeevyxbxpmcdfhlkbpjxhnkhftfdlxxtdalxscjvdzlxuwpqvwsheopvtwrneientqprbibkvgrlyslqfjkozoexpqvkgctfktxukfxqtwoboebepykxegvpnxuyrlvzuvgelnntozdwxcaeyxkeduclbqxijrjofyxbbgkvgjucrpjtsieayosqzjwdcuevlomrneqncullntmcxlhjkhswcmdjlpjhcuvhigxkdlyciayknzucodrbjnfqmlbrpewjcvaaantbxkuintuqmtgedsyvcbfamzoizuysgrjzxqvmqutsdbqvuplqihgycjcsbqndnqpliokzhfnjdvhscgoftupukozcydbneyirigogkibqqwsvjltovrpcoftbpruycdkwpaojdzfafcnuyztqhsvoqtiflealubilnpsuuthdqypplgquhkaualkrlnfkxokmxodvowodformvufiilzczwsfgakrvocbthyvtheofhmlmqufdbugsihbatacvuucaznfofjlopjtmccvezpqczuinqrvsblxulkhpabgpannwtsxqfhyecpxpqkgijeddkkrossmznqbbzcwadspidqcklgpcxbdneefptojvwvnuozhqrzraojoengzvpwcaunhwbkctbhtchhsaoslsripmcmcnnquyxhiefmkmxrbstdlmqjndvtpwmreasvohmggnkotlunonzkeaaowtvadgczxgfrhczwsbwsdhwkjzpffqppjebvighcpvmdcnljprdoavujgxsfmyrcohvkrahijbmhlusoqzvtuwigvajqnxcgidsmtjlxziovzjoqulvjunhcyeukujzingyfrsrgktczqnvzrhevwykcnrrrpkggbrmdruwkdfplbjdecepbgiaihxicfpsserxijgqiynbxuwlnpyihpuorocjpdpycrwtzncmreewonldnkhjbfjyqvqykcaelgxcpiyxbvvijzsocvtachtxxwcoeaaiiiysffsfergrqupkpohutrifmcwhfsfbhmhhedwrkjopordpctzabgosljwdhyvhknsjbyxkykzvzhayyujyhbshkdpzhfyyvgaarowmgwwyjmvadnsgkuikuugqogziddynfborykrjwmrviexqmkgiprbicadioajadxcyzcmgydboeuamwojsikunxzjlthdpeunfgpmtzvzcvuhuvhkhjzdrcjyjhbeiuvdeoprlgcjkrknyixprhxsezxewbyyrandsllrikvvejtzppgddvjbytqbqbxiomknsaaqaglboupqqxqvwrcrqccksqlezwcmoahgxkdtcdvejplinrfchzclwbwnijkjjgfgskjpannxpommyfytkewfzyegardcsurzqjqliyvtmfywqtowsljnhkxqcyrfnmpymeagbaqgainpycflqstzlzcgfpjxxsocrsfqalzjotjtujrahurdugtiwngptjxjtrmaregntbmhudnmxjhquvkinzebgglcnxtzqxfpmkaigzcyrylohoblmcpilfwzoksmbqhbdvoskajjohqslhohciitnfoaxaedxdwegpvldumjdsthdtfufdpibdtgkkuukewqmykfkorcaxzijojhxhmkbbmdmfnfogrokjookoecmxzxejxnacqijqaoiachuawfsjgylmzeynvgwhbklyoagdwomytijanawtxacyrhipmmhghnspjuyddysurdsfbraaltuuipthtujnxtmhzruftwomxlxncjvcoybnqmzxwdbninietupprlzakailvgzjzbonklqyntbuwgnsviubqkijopuwkhuutmvitbgucqxalwdmmvbnxnxwazgzponpsjavabsbtyrtuykywwbverlstsveyfwuevulfjdfdjhwddbnurzuxbtnqdorkhqnskweqctrctkfepjowcvinqgazfmcfkmgurpyaamuverdrfwgahyqrnuluneqruhenhxbleuxzbuqdkuxwdaocogmiisjuvituafmlvldwaenqzxmmaywtvzzkcfiymfutahxbrhmrpwsxrpedpvmmmmywsmrsmkmurquarxhpkujonaqqyxbanjrbgwkjlpqqmqywevxzjxhbiiepapzgtxeqxphdhwtlmyhztydearxvedkjhffokbkpskggqpyppfviybjywerxcmtiyjpdznjdxuhdbismqsymivgmyyjadrlektjztqwzclpcatiigfmeqrvbawwrhnwtdorarjgeojsemhezpyhtmddvjcayzteckxflekyoghmogsfhruoiiifdwwjfbejttlwyasqjzquekxcepmzjjfepioiertjmcvchermxukiadjbadttidjiupwgplvzeavpmsduaouajbkjbvstmdinfxxqyehxigaqibecfdvbshqnzaswuoauxvstweiezfjpkayichykifirkeqrirbwntipfjwdapakyaqvnnslhuragbzecrfzftccaldkatttljxocsgfhqvfafgbtdgazodlpqjiagobzexifkqyjqgmvwqmlpapshstcqpqdpagrrhzxmivcpgmxvefwgaohpxjfcygjvjykxvmjjdgcmxaqrwbnswnznrhxmugroaquugjjpifwozwmxqkoxtdzhkzofaeslfxpymscoqdvbyfbygjuofonzmedynvhpkfpkmiummmiymaippgbsrtuodmcyaaqdqxmpqlilzwtbwsejnyobjytutbkpwpsunwyqdpguzbiwyizpgaejgyiedncbzjzdzyiyikyzwqebadddwtikfztnbhkhhxpypxfcsxjrshctxvqkcdzbhatfztuiqettvjyrjrcwppovchglxblcvxwftycnbncirldwimdupeotupobhnghgemfqmyawtbuxhnpsrybmbawisrcbpysieunicidxoubdhijongiepqtdmixwxrziyqplgnrzubjxglhfbgokcjejbrcvjzjwubovixjhqqczagbfthshpotnvhhwrvddgkyyjfbcvbmobgquspwobawghjypmmiwcmydpnxtmcqhyuiceebkdtfaklfnmegqmlahyedfiobzjyvhkjimlgpzxxxaqlpffxtgeinozblxfpxnidygpdxmnnxravtglzdipmxqdxpvrudcvvokykqcsmfyrsnzsdrlaxfvbzwlapmbtwhqryszrlbugxwovikzdgozpghgsqxhpjzgzkfqqufsfknvwsntchrdliklyuuhvddkysmqbfnryidjudfjuwrvemglcpvfpmtobtdlspjlufmjowcetzqrrfncbmbivmfzzidlglosecqgifixzmbupjvwbonxorekzrdrlcxoqqvbjgzvetqohxddcmtkryxmymufenrbsnuvmhbojjbykdmljyicadiovrztfzniydaguoluunuvbpzzxbjnndvjcghmqzyuhqfkwzgydjzgctqbkboellvkfvnqvozisefatgfdrcpikyvbigsqhpcldkgjrvuaskubvqriupdfeofajkigvubatboduvssvgkupfpczazrrxufbaypgbgkczkjwvdaiqvknsbdxrqmqslxjokdengbwdgkynwevnahomjfshcotghmriiomgrftxppohsgvgvahoviduavjucddqeoqgueepkbpoevoyiwpffzxubfxzdzjixzlnrlbmbyjcqfuuimucnwfwvrsqpunykkbreddsqssixchontpixtuzecblkubaeuyccuenhvcaqvbjfaujqizjddkeeitxftueyrpizhxtaihzncszegjmrfqtmwnzvtnyfwwimyblnkfcmlpsldmsusfdhywxmhgnttwswusbfcwvwdxmozvxrkyjhmdkhujbztzjkzpyprbmcusnoldiypasoouvaoowppgcaatjesqprnomjgqmavtzbyqfjqobtuzbhcrxnahfogdwdfwfgzcvsonokfgkvlzxkvcrohphrxurttsrgrkgfjlpgyvhlwpkakoiejzowdvaeaeuylejufnajaybgksvaqxiekcvxmznodugrklnxvosmmghhvinkoubhkwyfnhuhkljkimdnjmlgsonfrbffyebqanailndcaiyvfkyiwnddorcrbzqxgoeenilhavbrvoltvcnjrymdcvgjflraswqsbpgqztvugbvllmqbbwmnhnltfrfrohnvepamjvqnkhpxeisxkyqchpeaasvgcmfmyayzohazjowalpypwjohyhmeyfriipawprvkgiaruvehewausflefpbpscrxxbxmxbnxmoxynsgzxeowlswidoqiffbpvgezlwpidctotsdmyviwtddkenmskjlyehiwnurjyzxngyniocpoanmxdfklrffuqagaalejnebjvjltizjbgmnxpfeoyidqtzoqvjvbsegkkbiawmbbcpcrebercfzjoetjtbcbfhjdxfqrufcgyofmdemdzfnnanzzijzeekyxredsczkiudlgiwfdhsdohdksrrqethwyzutejklhnqxsfoowhcfkxlfthpwjznduokednzdlamuihjvnepflujosccfeylhqfiyqljtyxmokhkirxuielwqmpmxgovuskjoeidhjemllvctfyoumochzxjhbhebcfiqtodmzgjwethatlehsveypwemchhvnscswfyodmaymhwptmbtkjkcpvosiakwpmozyotziwldwfkpppscngqpxpubddjrtrqjomxptohapffqnhfniazfcswqiphrahfdggtrygjwzqcigwyumtnagmgvlxjpetfxrnqgswijicbdmbzhnmxzenooiyetuiqedsnqytqnwcixudzpafjdhsekuccyhalsoqzktqjlccclybpsyjtsqxvxiolbyljwfgregorefsjudgxekrncyevvhlqthkyieapgsmfvoxhtlyxyifgiqucmndyvypsyajdgxbygowktsmcsghyxmptfuepoyswfisouuhxhyiwsgagvjijhnasgembjuqeqmjqebspayhligqdkbloelemrdugygdpoasbjndnkgdlkxklwegtscnwmraokkbywbijadmfzlpggnkxelchwovrizcrxiubwflukqvukocnipucdxargpolrelxvhwqpricarnvkijfitmhdhxvmeyjmqoxwhbrdadsokcfexmeaxfsuuuvzexkiwurkjhmqjwyhgsdxmpjbvqqkuwyziqqpppvfasuclbbjulwmcjjebolqzssakgscmyrzdwmhoksdiesbopsqqtsosdyrzvconqwdyldjpjunmemodpcwemrzzvcujmluhiayifyzgmghcilhcngssvbexggyattpypaeztzxogdkrewfnlydbzltwhjbqhufabylkebyjanrdfyetxbfmzpnqjvrmoznsrrzklokpzqrpyieulmuuihtchnshvnusjoizynplctisnvqwnktgwxabpueohovsztssgqfmcbqvhixkhdthctgqsrqluymqrihuvtllzxbgqlycxiezgmvbuaejgpixxarnrnfvwrctejsjwjmrggruqdfcdpvafjpfneexlysmygwacjxnvpoggzjlvhtgqylikupyeeshbdsburnimerhubrwocgwxjooyjykdmvsihrtkufhkwxqcpzanaeatpltrjfflydiqniuqhjqbjhikaccmcoieqfeuswrchmlnvbcykmdgdvmscsmvnzmajulwioxhevzjksucelnimwcmgxcvclujnedgrmthwseyyqvlhiqxwutfpadfmnqtmgfwwurzvqotalypwpcmdznzjhfzfhgdirlbxgiztwzxincsgybfdvwzgcglllufmhzkskyeswqhukftxdcygdjfnrzudcyzkyukibgqluwyvpuocqxpeyxetrpnoodqdbxsdlhvsanfxgahfjbnouudmrkuzjdbcpydofjfpcfgywvllyfgovpubyyamqtjfkydlqusprikjfjcmrlhlhvwszyabyzzddvfmnxbftukwcvkjtwimqitysnkhmrinmnblerpbsmqqbnxxoxkirpwovifywezaghivshwjwhquwypbjleeolyaddlexufbqqwurkizxintpyjcgzlvqvpvrletotdyqoqqegoyejodkunhnlvbhjzvpezqgznmafcgkqacwdnndreykbjubvyuckvcbfombqksinflrmsnumcftwsurmfgqvdyljotynuyyazpvxbelxgnntgmwyotrhgrwdualebdnxcnfjujqleqbdzvifduwvvxxtfrepmzrqyigofwzrvoszspwrqmkvktmimagdrgvspjdnavpyiszeockifzfnxhgvdwkbcwidourzaykrsfhamsusigeodykyxtbnkfxejxcvddxahzpuemighbnirrlaxcuqnavimwfrjpreqilluvoheymoguyuarybghebpnjngepnkuetleoenfbvzxaxhvwhhxvvgmwzryodwkkbiweovzczutgpkvklnvxlkjpydvwklvrmrrjzebwpnxbpwtcoyekopijdrwmdaaumbefvpqgklycdeicxrczxpbkqhlmgjblmqkhpatlgmjfgnwmruzvumbyyygoufeynoxqasyagndxnuajitywwdcohswpoqtuxifamvkzsqirmqhsolahaxtmbbbkabfprfranhuftxvhqsfpvutcgrexvlxcymccrptojsgcxewaegimogoiaruxncjtaderullavafnsimijnouiqscxosofypwovkywmahjugmjafixxxhdwglndxmbnlhcusnqzpaugbwiopvbitendrfrwyrxtjhjzzwswxmfajfkbeaidfxzeemjqfkumulnsnnjngrijixftfsrjjqkzihqyyfmwcdzvbkuajzcrdwegmqvrmaewuyuxukrkrkvmedlnaryqzzviifocodvlyugqhhalbwolqqrfcagreumknnfqgceuavnnrfslixgnrzwyiknjmabanezbgfsqwpsofmpwzuwsdkgvvqqoqmxsmaadbrzrgaojijlvymmyxheouxzptprzwkdvtofnzvkdsrylcwrkuezphrrpehkoelphwiifgeepvsvpctilfvskzuctcrwwrfctbptvxemzzxtvvkmvmvkmehkofhxfoporbmfeladozuawcrzedquxqkzuqvclqmvlvbqyfjpkhkccmmiralrowmttyufukzclznoelqurqfrsasdtvrccutckmmseqxjrwonjxpvuclrssghtmnozrhlcbkfygcnkssliqnfgqztcxwvfmqygqrvqwqcrjapihhxmmfjipwvbfxancsjvztnhbciaiaguzinixafpmhxgovonxwxlxljkljekznkodffrxuncjpwghjowxqrmtppdijiabmgngnyworoippiwiztdblwbrawrbxsboowvrfgcmdkfnihhbwnhmxmnpmtambuidhfroazgujlbywqnuwengwemeryjjowtjoyzhdhnietrqrxbikvrbcapjtrbvfvxlpsovnkpvdumtnhrwxtpubcvxmviabnmkmktqmyrjtbmensqydtqurcmakplfljxpgdungojefkuddlhceunivtzgceavqhhqvxbuprfaaxsqfqevierpilwumdzvraskuklmrymcadyawnfolnerhnkzmwwwwjljkgzkjmifjmnlqrpehhcfweqjxnsbxrzfpybfzxhiprlrczrurnoriqgrzrhwimofbckxcpwnyhllqypopqsaixiktgpfjvgeujpzkefdmtirtpwveakopulfscknmlufjnqgknvheqdmdenijavmpsweisuciwyvlvlgwhudbqeejktotskvgkvidnnfnhulcozuimkgyrsovkskurqewhairggfugffbixjhwlzhbgfhkhgbtlbywlbkipxhxrxocbyizgfmvnjxkryiwwnaptwdwvtrfahssowqekjotizrhmigqrepzhvhywmgwgziubgoxjrrankashveaesuwbumnsmkieyfthqtokvozekxdvhqwtsbjisroffzmgiscewnbhpqszpqxvchmatqazfqmovsgtdslnoqhlbzrzdacksynciqwnwrrzkxoaagjzzvvhyoyefgrlhqmpauoajuafrbcdduoxircqikiwtdlundkopjtqcgfxcosdzlprbqibwwnfjhvjngiqpyymvxyxclptloptuyhdjnnfypxsvxhadpwoooubueflteubwltyfbjgubrfzeafiwjdffshzuyoxqeccibjdwdhlnbvgfzbajujvswnqhlcbgaegpnycyzeswctaxjrwixhhqyfmyfgynereuguatsyvxgltbyhzzgflxxmexbiqqmspskofnukchjhrvttnxawfhqunujmxvceerorjbhqfayzzjpmhinigrwzgrccsdpdqistrvgkifdgrtepmntxvccnegtrvgngfitoofvkisknzfyvqxegferwcyoaectuhrielbvjkwnmklfyljvnykkfvssefdoegbrybsnmqhhfeyykeeyeeeewmkcadgfftbuixxlphxtpgvfzetmwqdiwylbwqrcedgzzcmkkliczpojvkpdylujcxnmpynxklchmzsqxtrpkdtfpobbtnisdfbhkupuhbvskeehinfdkcganuvchnecgygksorsaxfjzafenljalkhkpnshtjwyckwixxviljctzbmpoiyuolpnmoemwknhzsyewwbzschleefcyxmoaspdvwowrwasmokhrceyocaotlitkgyocgzecdpzfxmhxhhgioyvssfnvgoaphtozmqicblswxnxjathwqgmphxzhozlxzsnvdtqpxvdkrjcnxzhxfxizgwtbmkzmpqncefkxamhpjvdhktnggtbguudwjofnnocbwhezqbrkptkxdyjtmxwsdhhetsjbgsitylmlnckzjvhhhvksjfotzjmczwlhexoxpxuitapjbqjulhmyffadpkrhxpcxxkfsdfziubkztnuqgjymjhprodqjtcjdfdoyrkabtsajoorjahxrxuffpwcuqnfsxvsvqprnzgqwckdesqqeagdtokutiuggwnnpbcdjqxytnxsurptyzhihieuyaoywqhvoizeuldedamxwuxibzszdhxgqzykenwipfbqvyirvjkrujkidgawniyurndhxhvztlklufvginphqnwlnpwxeuhnqgkcuklmwcamepjystvrqehovkdzmgbmrtcbrabxwhmljuncfifnjlkivavimwivbcpvvyombgmvemwmhqicpjkysufhegkavunzozwrsoubvraljkxuwmdpxlqddbtqsaewkavunvkrqnebizrizsjgcgydxvhwleyoumfjmtynsdnziwzjvjeuclqqlsmrvbsfwabikwjhyhfwvixnsoqtlhhchjwzupijnudyvnpuronnhpuhjkxkmbzewmuekncdmznofnqfknhvsrrxvjdjzugxpeacpljmusmonezuslmefrwurgadawwwixgyhagmlmkgontkimaeoeycsnapzsroflwmivsgzvriptvqdliugrhhmimbprbpxtkvgigjevircmltvwuibwqmcsscgfhfcmpentzketisotzsezbhqedpnpgmmmaqrpibpfdfrshunlhujiqnslajsxlbhvkqtwrtljbelvrqbxhwbgfdonxrdfzzajgptahbbnibqfzejimdktejtoiejaqttkedalievusyyaeenyeqruhidimhjiybibbzqahjixbksyshdlpskzmnptzgkzqximleqqpftpxvorqgncvvhowcoxuurltlygzohrfjaiguduqyldphelpybcfmfeohoglncyftgzvknlvuiuwfozbyanfkzeltyaklteifbqknbquwnsppiurlnnpgawrmpxhswgsllshuozgffcxyonwdzvkhmoedcbleltfsgrffxwvteurozgccrhtlmgfflozacesidtezvtqaxwgvctxjunnqvbylghbepdkcjqncjsdkhyxnfowexsmhiyvtcikwjahrykimqgalhxxnseiicqmmkxsfannaoevjebhobhvsiucavfzpqglholncgqqdtelnajfoxvbdjyepdbyoywngpvhznvrwtbyyzroabzjczelejkktrwolidllhjqlmtslgzgfoyijnadiksyuvmjxinepjhdnfupfkiexvfwpdbtnjkixwfqofzykudjpuhfehqsrxzqxuqlchtuouqkadzdfagyodfokfuentyowrspgnuqvpcqsmymfrqjygehaxwsduarqysyviiwzgpielmegatdvsciakqhquopyyywxfffopmxwnvpczeunuqjukmvqyapgouwljijrqtdlusqabbntbzoflqpdsltpapuozqhqcntngsiuhquwqfczztqjqemsevffyktsmvfktyxepnxjgylnbwnyednhkswnahzefbvjjnimgeoixvxrslevonkunojjmaguzzyduqoclpglaavmmwalrmmqjsslplbdpvembioirqqtusgmgxvlunbqjdogftsbfekdwaznwunbffshuwqzpursqdbvpzzfwdolskzmvjicjttazugdfxpcgzbvvqakhlzewkdscoffglehsbnnpaaegiggvobrllrggjhyyxbanrpdmkvmwvfradidzzfnhcxyjyrgxhqnyknjjarendsuysfmgcwqklyvtgntdqdwltlzserqzpvqsvowymwjtwzskhpfryzqrvrywsrhvcauysrjmihaxahvjvblkwcmzfvdrnqlrwayyplovytsfjymnkzjinsmdnjobqrlxliibslghteynfzyemfbwoctoirnvresmyltlncdrildijbuwdpjbmwkzqvftrrfdmctslqofmtmgpqbdhdzqumbfvusgkwwpbtqmnvxmihfrtnduqcszdlqfcdzxfsailbmurelefkffnumfvnzibkohjwfayomjdskhnyvjabapeijsnbengpjzaxdbtdhnfagxyaxwkoqcbjrmtqdgnxyinmdwxhqaesutyjmvdivmixxiffbtyzwzmbntppkrcrdbuooblwswjmtsceyoklmseddfohmgeexaqskbpmeafmzpmgaucswbuvosbuzyskbhrepkoricfdqofrueyhmrpvzakscjxdiwstwrfjvogcrwxrpktgluthfhpsxzcsczmqripialeamefuyejvaqatnogjvkgxhhkzoszeciejupivvzrefjanipqcvmzjcimhancnyihkiwvnnifrgvmwzsjolngoawsodetawjdosiooncuyppnvzieomasxcgmbwxdymmoleewekluzijaeryyqnprzfnmmytvhbuzkudnrkkeemsuwocatuxuokltzeqohtyrbliclwhlpbflqekbjjwmmbcpgjrfrusvifrwjycsxofchxuwpzyrwdxfvbgluvtyswinooyqsdumehedkdaajxgsqokleeugnozenzyvtgfaodotwmrcoazmitqtppvgevpzuyothuqppmgfqnmsgnqpzrkgnklgpyanpifetgvmtibkyiuqzeylvbbqzpakvohoblxvzjmjtzuhnxytwjgdmejvioywntnmsfzmbgtjokvunrdmwosqymjsymrlhvnanupmwdtedcrkpplxajanpyaanwxqwisqokzaapdffibdwkwgdzxacrorjpjswaggzhbhmzjqyydrkdxljfwmgbrjublkresjdwhgdhnvhnxavvprrykpklrkusygfeqqihmlhexqwhblljddtkkemreszktrxwsnldhqqhiapznsufzhpbbymhytbqtoavzxdupenkryjyvwlihlsfpjdtlfhcdhuhqfigewslaxncwjpgnwqaebjclonncuztwvonwbkzpkzlgszzsounghfvaijwsbddnyiopyutvzfebajjhgbguftwfaxneuieavhhogvllzqjgpzymtwokdycyxykicdixnnfdcleuhpzgvlpjuifwymnklrbmgykolwhhemtxkaegrvhghgexvtirqvjojhmqryhvruhoodxmmtdzncizesxzoevywsbujqaxnztaajtzzwsdvilsainjnlmnyuekegwziyzqybangxfdkiwoqlvipgtciahfaiyxgjgcqkrkictcvkozrhzniwfmnpteqiugqndskihqbvfvoypqzonkrxfbqrgrnxwilgaaiidorfoxjosuohqmkhmfxxeermhohflecfpfminijzjhwqbzueinaghfsapsklazfaormqqfdcrvxwhwjobcolfgikrwiyxsbmfnaoeftybxzfezsusembqbasunatntspwnomgzatcogracdvfovdbsmxigaabpitbmwscqjcsaserhumfdihqpvnqjumoxefsbtqxzdghvlbrzkfoxtybpbzctsgufsjerosmscjoxmusbfpnyfcydaeckyprlcmrioamklbtfjntvhjgbvrfuxoifwxyaxqirrqayxmxawdoifiughyylsnckhbohvejnboxhgfdlnbnfjvzecqqtdjlsjeieamydffjszjstrlwhinrosfhtewhtgfgzaremvyhyqsgtwxhjduklkxjwztxsqmclptgevgudsrutrimqynrgmvvjdwzmkpnrqvsmvmegzjlhqxbyfcqrqkqlghbswwkyqxjapffakhnttojcrztchhytisgvbzkpqbrfznyrqwkqlpocqjcswrlnlemarkmkttkwpzamtzymfitgrkgmixzzgxysfoowlkfgeurxbcuxpqlaycjnfcikdbabxncffppachlhlefnkxurrklczjthcyfgzwawgqabpsuanfuewfusepjanudoovhjpgdcwugwsdsyjhlphwzwdpmzkudkygqrhaoitlkuggxyypvlusafdcyczpcfslmkhrmkzuuhqkapumtteijyjcpscofbdnqmrmrxcesaoxsingqpmpdzezvfnmkolkormvcdkanwzipyffdsdhirzgksphcjrvndbprfszobqphapkgyfvbmuekvgjwyplygwsrygbyuctaxqxlyhwtzsujhzhrwdhadeblhbhqcxpixjnerlhuuaeirqpenojqtjwppjfbeebvgguttmxqqdiuandzozeqixwdvajrubukqbluqtekyrmdzigetjzdtszzeqlgomcniprdpdjixmhuowjuucsaopennyblachxjclurnieuacjufsxbyjxeckxhpytbpaihgrwismkrugrnmdykmejyrmreenbsokyrbowoofomisgwxqsmqnvtdbkqvxjntksgjngvidvpwzpjfdticdkalovxljlbyolrlfaxqmyommvchuxpgrdlbrssnxpbtbmdzlorfvpmtveatnxrlsqovfvslbxfmtmssqrnbnbjpvfnzvenacjkpraavdrecmhmyibpecytpbwodjdmtkgixdtnknprcivoamvuhhazxbkiaidcztljxqasharazradftekhlttiovcpcytzytcxsyoigwiwhydvwccfyprxtyzopvivhvmwkuehgzgmnshrzyretzfvlbhfdiirkgiszkwqwmuzkdxrgwekrnzbezfsknslsboycsfzwntugxpgketflrthbulidhmogplyfjmltozcevpgvtyvfbkxxmnbwbuibrpjsxhlbzrjedqfpuzwpabjjmnkpczdbeytsuqwcjmguabxbnkpjetrvepahwiwilvcjwzkrlmlhduludatriflecngczceljndnyzbrnoxdbhoqxctoznkqygcqurxmcmsdhohgxejaztyjdwxlhdqelptsyhcrxsgenfwokyxkwfornzshrxrhhdgxlopvjpasirhprqukfrzzxudzoscoagwcgkfjalikcdrhbzfzeswsjjunuqmxmtfdvwvmuhbnqxpbfssnqbyljvtdcqamvmveiactiypejgversnnumhefogczplcwiavjfahdxmfashpxdeggqxdnnmcnqdgwdrtucrimecqinkrcykplkqnhuhpmdrgotpvdcqbvzkgwwdtpbclgmorypkgntnzbigyvlxfkpqfqquzhcyqsuslbdawfkatdtukxszhczcblewbrnyeglxftfnwsmxgkemoaddwxlkwscatnnbsfzpoxehxrhuxzdhyhfztmplfempeoagrleyojraktpvnkxtidxmfgkdwdqrczjykzlsswkukutkajvsmuqgoghrkxjuqvvzdaxxuetujbtsymbfdxevkcnlwliadrvsqpwrrjkebwtmhlggnxaljhxohqyirwxhyhfumadrmszjpdjhrpdufwzdkxhybmgjjuizauzkoksooiuclhbchczdgqdohdkboesdwnvfrfczqbaobqkmrddoartsednwdwbmbqmggccxfnsfivwtbqwubhcgqitovrzifeojjuzrplyvjxernitsazjxgmvkjpqodqejmnmhyxjxxzssjnhugejkxtifbzdkmqtvftynqzatusiquggwvuvcpokwfbvuofoxjuhotfufmecmlwpamgxlrkojhbtyzlddoaxndklwmkwsicbotldqnqousofnrqxoorwgaqhxlkjagsrbtjpshochqobblbujwgbecdhnovsbzhwejczxwrmqdznpwnheegwuauwupirwdddeywsbuqjijnmkjsbarndniijidwfddpjkwdlspmivosvzspbmrwyoewkufylgttjjmeeivcaixeiaxylbihssdacmsuksgnonpeltnsagqvnpiegunzzmppqmoouecaksftzpbtkcbscwyejitfmzcjsjfdolqzvcwykzcihovezkhlykbeowyvtyctjnvcpbyfxqilhbpfxohjhfxmopbuuanjmkejlcvwqblnxeagabtmwpfdupypsfoujhegbxryfraizaktzqbjxfsxujyculsedxkgjfnlsgwkspxkwuxaycuzoxwncgsblssoiscjqgvowdxdqthikmtguwqcqihppnwfpxotgwuxchpcunojzcpmtyhmjohcmmtyjwabrshanuwmsoeyolwsoljohjgjmpmvtknfdgdwfyrgtairjmxmifxwutncarflfcfgehwnahrhgipsflgaxoytsrxxmfellcmvobltupptrqzsrvlmtvezokbwlezueeobjpumiuclzyhtdecarzwntvpsuaxdgxpneprqpsciotwtkyshmuskbxmajdcqdbkcwlkvcmysjhofdsqmvvnmaegsaezxjgtcbomfcjjzormfgjkwbbaafxcvdddiqdyldkszbwttygeaxpagumkmzwxmjiiofetizhmzqmffplnbmcxuialfwwnexlssxbtvfdbkzkdamgtchhaufmktqwqfroezarvtvyyaaxhtvjyafifnktbwtgwygygvjrktreioxjnpdwisakkjcjioplzrkuarbxnhamibtbukqltpvltduvuigjvktqclkfyiohjoyouznrpofdtaipfwalghnlwbsalyjmircumvkqifpqfmbvcagntzpkqgwrdwncmyffozawfehigwzasvwyalsplwazxdfrrqixyyddounkvxywjcunrmboksroctnifplywmysilqsrnyenckpbrcathgqnkqwdwnraxofljdaiarmwmfzpyngxevlkrxocqclrllhhemhuvurfnoggredxjrygkhufwqwhxvlpcwnotbtfbbhaklmpdicpxwgvxazixnslkclujraukqdhruembcizuyreehsjljamkrwgvbyvlnucvfndavehbrckaslgqzrpksntqumcqwgkmdzvpuzkjybvztvehvvqlmsmxwjjnqulfpyzzptoldbrcrzqiaofyrxvkucvsnnvdlequdwgmmgnboalvbgtrzxqaitdwvpbubaihimuqoefmlwjapnvbleqwkteuqgjgqzhltefdozfjrofkerjkgwsqnbtjjflaprwzxncpcubznhninyoksxeojbpcdydxtmgkyhbudqdzictavwmdbungmjbsgioboacgnqnanftnrbtjhaupzcaipyvwoqjjtnremrqospegroehqdghqqnvvlqenhignmqfvtrbigoapestquulhjlflmgzdzedhitelffyzkxevzeopsrtdkijkebrysfljovbcaxxdccpvjpjnmbkzqaarlfhwyrwgljckbuvqmkvjgxhdqyvbqoplxkrkbocdlklvgzixuwowmyxllttvjusqrrfexrrnaisnbjnczcufnhethzcihrqzjgrnnzgozfmnapiefuwyfnckqiojkmwzpjipmvmigjezccqzidumgnrnprumtrfavsvjatycdgygxzxkitypsgcpfmyclarjgeplkidfmakrpdzxfdzzhchdgjqbigbgqndbfgpfaekivzmovpzijndtkypsmnarwqudrpuripznkbxgiwfhjynpocpikwkhgmwrghynfiljxmjxxxqtorsdasmcrieikfnqggnrqcougbhxlmbgmmisxdcixsxdwlnijzgfiwomduoceenuzmandaebtluchnmrblqjjflhrwtxythkysalgpnotdjrdpliirnxjuqxhyooqzvazepzfcugbbtfcacsjikjhkyvqlstcbmouqjjwogxxihdqwfwazrrnocvmlzjrshrxtlbstbxlsyanuqbemqleggcpecopbmsxoylqzlivvhiemyjbvrvwbzkvdgsfroqztwnivfmiluwbtihrqdibcwqedwjezxhokhrzoefxhudfxjidlgxadjdbfecmjriyzawpffdjgtusvbjnbzzmklaswhihqwuilcyqiuxasyrjxhylpibbdslwohiqdelzncjklaelctdcpswkoswpllxcjnmcpkuizhhwhbzblzuscoqxhwqactptryeibgjlovbqdxhnbqemyaavibkaniwqbwtuknnaztfebktmkbfsjsburksbslgdnpoimsdkamprtmmzhojbtcmodrmgiymeirdnxdhsaonthpexnpjnlszlfcnjwaoldrqopitkowsaambptpkdlvhnohtoaxeqeleirajxzyorygrubqnlbckdliycxuryebwcnrowxwxufdkpzkkvqyofptqzbplorqzojumahpyqpvmwtgfokaasjfwxhbmdgqdfdvgumikpcttbqqcqwjlvubmqinifjusmqmxgzomipkljytvdrongydcfccajhrwprwqoxpxjabgsffigkzxxnpsgnnevewjjvplxwrebxctfmofadnlbgpfknkdckxfpleutnqycffgylpxsjyrkgdzofosvuyvollivkztezhpgusqerglzgvwdoeggslsqhddsdfmmhuecapayybfkqtodzhqpfffoysunjruksxtfycqmuwyclwsuxwevbcufohndmqdxilojafqzvdlyiwbteiwgnjaoveshinuqnqlfpisvdylhgsjocmqlpfousdfodlnfnnclhzslonwhoggroazksetgctcobczrfwnfjyaertdoapaungdabpqaorzlezxzennnrajtmohmesjgnmnpugdaafwirxxcbsyndlxxiytdqcryqnjgreghjmqwnbuznteibkaffcbtmjgpassmtptfwurbcavjunknixkaciyabvutvatcphhnpvpryqagbjnkiuhwnqganzcgkeonzfgoshxdrityoqkdftycudwdyqijblwrljmthhzfysomgexwyfdpyhbtntkzxbjyvcxzzkjdpdcepzxuamxtzohngvnffgadymiughznmwtiijtvexytvjvjcncwastayqmentqrmuqxaqmgwuunabsfeupftszuvhcmogpiifktijecddppraynphgvnifsxofwixnnlhcnyaetkeifvimsfsiuawuwzotdntesbejrhjecxtfmgowernglimecwtvwihmuyaoyrdrhkhskgojzdlvdlciapfpobfbfvvhdejsghadzcctwbktumrgyzrlmycsvwbtxosnmzpndkxhvgikfjirprctnblczxzgnqwkdjiauvczpxhbrrlwxesjspdprwjlzbgdklesqiczrowegwudckauakslxvnyguzpdioydvwhptxnltmasspwvikugaqlkejyfhfzkjlvgozypnyjldcznmpzeartosuzkfmgyprgxaxlvoidxuembkrvlpxlyuymgpnjilpjrvwxdunncfkutlwxmnqflpmlzbictmtajruagwipohsatgbqirutecuavbatvmgwnfksscljkigbdudfilkxtnntkyismvuyhhhhoqtgjlvlomoqesobglxggizraganyixqvvkbbupnieieindarerbscmgeydypxqlchwvsandsjtgepvswswidripcuxsvltqdlzeiqqmsuzhwqbpqoigrbwoxyerjgpzevbfjmlhiwsuojbbvkjxvxuloybucikssmgkdqoetthnybjhjmkxczczggjjjftpsvkxeivdsdhfafeqppzfdnxhooawjnpregxxqwbkjiipaupqfycmggmzioofcspxbpjkhryyvwojsfajiynfqcccnoaowumtndvqlkvxapnlxzvgpbbpeshcgkpqxbdkyejoyaiyzbpfupjlhigptnhldjugvzupjmalryrsduznvdjkiagmkkhderrdgjycnvlzmjjohaabjfnntrwpzzlkxlxlwaaahignnuhbupwupfsjemxpjugyezxdpcmgrkblthpadszpfvjmcpmtfeolgnudhbkgbelomthhpzexdsptnydtdannqzakqzwrttarqjzvxphlpsiupaofgygqkeexxptectqthrplmglbwonzysleoakdzfuwctjknkkzgonmmcopxjxvvwjcyfpyoundrdzmugdtiyoqdbuxlxvvinsgimrkwxofvmhlsnarvpzixpuambxftfitvebxeksztaquumeqlemdmjvgfnjltytypedtvwcjsnapdeqhrhilfvypuwrzmcbheebpcpmfhnximmviqrjxcoulmsstjracbixwttfqbraunmedknnysandsehjcoegiaxjoifdzkfrouzmgeyfjilnwgkdklcotgkikjxtauqfqzqluvnyslchmhrqlepfoqawmoogcccdzjstmayslluaqegkflodtsgvgvzrhlusrvdorstibdpcrhvzwvpdzdthjhqssderjgthpvxozkdlmluxpgksjrincrnuiqfmvuzfdvkisdufupbytfaamxzqxcmjlxfujwrvjljdaeavtstusmijyffhldmuhhunrmgyfuceoonrosihsuarllppepslzhwhxceuwzagpcsvdxpjocfnwiochdcwzwukunapckxcgqglkvogcntdbnmecdogvmxawxnmnbvcwgaekeeuimjavzbxyrstbrwythhcqwmjnetlhhyugobggohgxjkzbudyckjeinqwrddkutzvjqfpuoypfwzbvgdnkdtzkgyqjunyewfelomiixhwwmsxzkuybxjkxhqksiupyqydvohnplkfzdleitrbboynurxmuahrpydfdsaxepfvwsgnjewwvnrastkhdsfjeabdosfpdxirvfgalnbceuijzwpsjynxctqvedneuarsxcedlxcgetftsnlnpcihudvcygrcbmfmsnfgkjcxlhwgvscmjoyeymzyhwgpypoiqusthjapyndjiassvfhiefyfknoriqgiyyjpwkkpvpwoglfrpumtmnytowfddbmjvsqplbnutzpmxomrrfitjkiheptjstjlvsrqeikikldjlphlhycbiyvlqtvjucvxpwaorateebjkhmzyxsnvrqwnorwdibnnemqijqfvqcijfgtdxxmbwfncniqdwusdajoceooutjwirsajvbcdwkqpopiyekvgvyqbwicbvvulzbrshednezkdtpbalosgeszwdunzyuqnopwhsuffrkmsgxjsaaillbxrtkbmrttfoycagehpyykjbrjthrtsdquqzhuhyshfpbnwdjhitadyvfnkjuuexoojthzpzffmvdxwpasifmiongafngbspnseqijpyuwqyyfbdgfdbvzdwwivtmsjzvcopnwpxqnimfofxzxbuqvulmmyispgmusqzbhmerhjepsfgqfpmarmqodahvogqeeyjzdkjvkfnugvkgzzwvkzwncmznlrcgzoxjtdevqpousvilhxvgdlsndgheeqxgdpndnfvuwthqfkbnnqjmidtgitygawtxhmtvsmldkvlrbzaljgammxhpygqmmpoonbwxghbewmqwkbizzlkkxtmujtycfabkiixwjovljkkrkdwnkpfhahqarfazypacmzihhtjolwctkyraxqglstciyrhlcefomiczsgvzgepmtdlhjhwscykebrbqryudqvgkapeprbprqwmkwmdzcnflyhhwvgphdsiafvcbszxsgxysphzqwwwiwsyosnamydyzfpuubjvqzzkwlygxxbxwhojflejhunaycwknrhnsmtigjtldbvadukgntpugjfpdhqigkopfrryssvgxqfloaneakerlymzvlpwqyfgfncsvyebvomagshligccpyejkgisatfvkbygrdgnfvtlnbespfuwmurzwgrmsloixkkojhuzvuzmzdrbstmslqgupqyrmhkfydpfvksegnyicfnmrusdasmnmhuhjrvwtnbgsgddlccsxdigoyfjpvtdguxztgjvjmcomtqfsefultigdhblyslbugrxvffetnbvceoesapmwymidwfgkjoudxnphvlxttmigarhlfkkpqukynuredisgnzditnodhfcfryjixtlzcyxbphczohlpkereauoeuopzhlnygmnbxctspvjvrtmosseuixewqjhulcmqiziscxynzmgwsxgsvybqktngzfknosnhedyvrzyemivdttohbavaqctmuqfyepayvpxdivotlrhpucpkdlxyrvrekkvjoxhulurrmforkupxvtmebkdirdikivodnzygazmvkckrzjsmwurwwjoopjsxwczzwgeddosrgocgzqaqcvaubjzmddkrhpzznmtucwlufkxmhiziwpdnedxrpfvfmwuxllmiqcmvypovolmkarwkktxyfrxemjrwqcnhwidzsjbusvbbkztgavhvbzxpturtsmeweayvfhvttjyntiifxjtepiggaxxzojjvrkhgqqrgfwahcshttxwqtwnnmerzrlvqzpwzassjsmzvbppgqyumrxossgnpafnajsyzveqqwbzpnidlrzqjomcnexyosrheomlfbedvvqdlynukcfzhlktrisnhbyyuyfbqftprxjfjaqtzsbygwmnimapgherayqdnsgbtmzzzdywgmznbcndxskywunvhgceanzqxaylvlxkbnbrpkvoaleinerjovsefczkelxdwenhafupoihmaybtqwoigceohfqoljqecxqstvkulqofvfhsrcjvsfksglrfbhsxrsynsbthkwhnujmlkpfzdtpxzwwhytozeqytqzyxgtytfoutlysfncxdnudriqdijumgaekoqzdbjlosrvtosbgwioffdbptcboiyylknwhwzjpsdlliqgatbfdmojopqdexlzrajffiosuufnyitazfrycbnmquyghczszebjpyuvwbvzaonasmilooqwmndmwvuyqccahrytveqgvunjvnsztkaxzlnikgnxqadoftjqhbxydmomypftahfuhstixuokpdwvytrjtdbuvjolwldgimclakxuatnpcluscrxkmcjmpbtvkzvayiuagskdlwxkmisfboyfaptcfkbfoqmgewkzsozjiejamaduagxxixgthjbuiwaklhqcxjvwxsiapykwbiyowkxbhvtmaysconyjwswpoqezxpellwbitabxoziniirbkgkyqqftyaywsertmnrzpdgfgfomogpgwlbrnkeycysmcmegorempsicuebhcqgcmqzjldcexbzukybgiyltmxjwdhljiuwjjicywtdypvjzbwswyjzhpaailpazikqeutpqwprqagfrlqlkhvxsenbyfipdzzbqwlnwxlehjqwauockvyoeitohztskkugwitkmecutlgodwtzhkwbthbrviciabushgdrxlslktwkniklmpgpqfhuidoxdococnxgpmzcgthkmidltewawgteluzostcfuheuqmquzgigotwahqrlafdlibvtzjcswshpzxalacejnhlujdxnnrqqjgwyqtazunqvlhvqzocxwajggawjxrculbvfvtmepmzjakisjywelwppiwdkmwjzegnzbeoydixunzwwpjovzvfkxhrzaebkufpvqnpdmjwavcgqnnisthlilxfdffowdhgiiltvktlvendlczzxhczzkqaqvoeprxpcblqugdsdgilxtkqknejkmrwntcpuyiacdyzixzpokalrfwirlkeiqhfqztzurzsdapmhamdixhkwwjayewunybwznsasblhviiyovszhoifyezzrfduuloqxsfqdzhceatcsjgdkvdnubjemiqlmhcqwkxqbsfvrscytjtzqakhsgqsyyuqzwfnzpnwbzdxerovkeydoaxvjoozbldmozbfkuxmdgbdmqhccqdiiyphozsepzuxgwpgcghblepbaujqcjoabmpxbobpipdccexkodcffezquaewjqkornyfbkdbssrvlnketcqqctuwaasktgotdboyevgnxjswnbkxubbfpvtdvoraicefrxonbczkdlpxryxakatpxlqmbyhaiorrtbjbsbbawinabtgbmwpwdjoadaaxiztszpqptttrcgwqrwxicanxqwcierknfhhkfpbvywhxpaeooirtjpqvorrxvzwwgalxhqgnahhouocfhbvovtifltqfifkrdchgiemnpndcbkatdjbnmwpmlqqcobwmiczjeigspqqhtpvgbdrgfrjleoqcswowgzahbigwjkizelphridbdalrekslqnaltahzqjcukbyfjmnallbmjrvvodtliuffnsxjlduuwmqhqrzbvdnakknauhusqjybaxlknozgtcjzgmnlxyxwncgrpoftomrfusrdeiwwbwzhrqcxjtopzcydfxqjzyarodqyygrwddnzfldbqqnhbfvsnhusjqdduwnndwcjhqhdmjtsuavlxwdgzrtzcnqhekeisxqyhngkqydbzuqnapcsaanmpviclpxpbwdwauxicibxfxcbzcfrtoczmzgkghcfwamtlzzvdlqhpagxvnspwvtbmpxtnafdyzcyznwwknpjmujemcryesspdztfkdiudzmrthzjibpwaifwqfnlcmxngcjtnvwiphdmlsqrnjmmhwloqmnxakuitjkgjnkncbtsvwidkkpbalmccihfakmwtgqylbfasvjxlsokcburwyehotbcyvhtmojhvwebonltpbmeuonjfinznfodraeyqftgduahuwtwfgaxgfnbhhyyzbkojsxnnkhpsetzufypnwgyxxtgowlourazcdpsbemodycyehztzkthxbmtbabsxgokqerwoymxzuctlductsaciphacitvjgmqiqhhxrarlfejuodwnjofioyirpxesgmfmsgagcicthmkcxcqshwhukrspycrycnqmftgipzfsilofpkyepbwmaukqpbznlhsyywyqreacgkjqgplcgqhngwwkzpbgmzgdeaarhaxjizbqghqtjdqnlxixraildlmafwwsgngaqerxlsuebsgqhqxncnelrmsxlamhulverjchjhohfevoanwipvkjtftgqyqtcxijxxqtrqtsbctqpjcodbixpdtnlqnlcownntqknwxadzituablyjstraihaxvlsesischjmacqhwidhctwldicbbkdywajatkgvglnbvlkumdzdssjqlnnnjjuachnmdshcokyebdfxmkuzbtvrpjrezbuulgcqofbpgumkhsmjodkxxluugsahylgugcvpwrruoziyuvmcwjirbcjwjljeqyebtpsttrkfpmsakfiizxhjupphzndhiygkzxaviqrjmkbehwnsgpdmfzbktpevwzozhwasqodohkdqjyjgdkatexqnbsfyheigrwitsqbdrotzfoiblxpskvvjlidahnjzahkjfayykgmrludvaumdcsegtnmbuuqqmkdzeuqcrsscwgvvhfhhirbufgqqnwitklskyfqssmrrsqkiadjeqxbqxqnjuehuzwodlyzwntkxgorbltxmlnuunetyjpywfezveetcswadrrxeyudtlkgixbsuooehmeuljuoudehwworsvlpsgtspshjdllafeshaehccmdkqxgvznbfssbpxzblzrdtjiciqjxxberqfjlsxezpslvacnqfawvgpqrgobwhnkjqowlfibknjgilsbfxvfklzvmbpeeoztmbsrlcoiusjcjfaaeryggbdpruqwpirtxyqkwnkvfqamfigdbifiyvivjpdxluzicigvudfvctzxyzeupcrfwbtmnfyrgugbjzkdqtvodfclzhjlmmypmsdhbvgniuziddxqgpvesxwtqkvqqqoqsahysbqqshncmudclnevxdbcvpxvdougsgzdfxytexrkvbiwqipdbdsvmacvedspnzkkpyuhlshdrhclklnfuymhcxrfbwqqskdlrswlfslblmrpapwsdhnecknppmzfozuwipdzmzlgnlmfunxekgvmvlpujvlaatdnfxqggeinrilotbxilkyyefgykklqwxitaejxlqgwogeutntwinaoblfnhawrpaplgybxeppijfgxpnarrnwdwwfolrqntapczzciqmkxwuzmuowmtuartczpdgjgpkajjnkqvnkpdgmisfillcgjhxtghwbxavkzobfjlppetppjtqmeyblitmymyjftkytpepedlnghxrcbmlavshjamjnhxynnbogwjizrzhplrpwexmxhbkhuocsepjcoeblmlkknhbixpzbyasrmeqisjblqybuojuuuekfghyzekafsjflmtqplduxpgbltcdclbmgkpgrmulfguwiemvsjwypsmsllhnlbgpsshpxvyncdgscfohacvatdevklldlcopuvkqsjccdazhkoyaladlrspkuuljxmcbpudktcgwspgyysbgbfkhoivicbmgulprtavdfeowosjdcsprdaesjrbeuwnhmhfpzxssgacvpwocaykscqkyajqdeuchqoyiqgntnazlueecigctffoqtpbhcoafrsoltopyzveauxxmwdhtlzktpvpyofvnnbvilzdjlgzardlprzjotiawxqqimhyzyhfymxqncifknyijziragjjbgnzasuzhtyylrulvwdcnbowfyazkiqyumrcwrrwvhcmsrcrbsjuiepdqqjubdcxdhlptplijinsdqdmhugeiwviijocwipuwjqnnjcvvqeahwzeiohitevgfxtjtenyuwqhljsykremfzfqahxdvekqmyvadoywsubvbfweudzxwgcegophzzpezqzmyxojukqfisfwjpnpzliohkqbwwgihhyyprsvnvodiqymvkhacasfdqtcuizppgisnvntpjcvdxpgnhdmylbkxzlnuiqryyecpavxuskrqmathmhsydvbvvvfmyoergiozvwopguuppnoeamtrymvsxbrfaehuqfyrmbqojpnfjlgwustueydkrwotsodmxizyuoqqgeeaaksltutgqupacjsdvzhypvyvjfuirdapexruweilhqlqyuellqnxeoqvuhtyhqrtymmxpobwbmhwlqobqykjoyksifygnnrfvvcnjpdcfhvtxjaqvfplbhezkdaiolwhgkhksoscbyylwfsamvtbwmdognorjcmavrxmoeyruvdjlqypfsikwiwjshbrhqiyriaraietuigkhwqdqzndfyatpavpkgkdkycviodkmdhwhmrugesfsocfhaqchrcfacghqhyvginqlovzmkfgdmffbvzejlqtmwlzygjeledqkcwisgivgffhsbpgtszxftmlmntrvwovibcbfopnsdvbpozqsmekronckgowyfgsffvxsqdzmoctcovvrklgpuuphhyeafwzmbynodtifahwgbabgflfhyhozzvgcnwurxhixpflnsnrygmmtgpcyyoevwhlwadzosmbugdeyyfsbwlqsoqydxzwmixbqqqjsgfgtwueihqnmtpudwygtauwtpapovtgjdvhlhahgzxuvnkecxbtnnnjrycqbfvawsfsapexjhmmmvboucdixxwattwqjxlmartckzpylnojqfzwqavwobcatfskjloltvmnoqjzfncjrcpsrqzmeogdbmvimktqwvxyhteyfooamcsrqspxlcwkmvnlanqkbhxwxzvksayunqqcsxjrupcakwftjknxzxlfpjzmyedpxgrzdogxxhtcfqbvlvipxutkfcydqvsmhxlnlnnujuwhcidfkhupjybhpmmelzszbyjkjnrabrfjnsrjjszlwbruelstevmzkyhqslamiwoyamrizpkekhnjvhqlynobltglmjvardrmcgacjpspsbontnwhvxkjhbboumbeyzhqnyvkrwqnketfbjjttgpaleabxwwicppoarhjmttkoopktzfsfmrygulcapcuflsozeucxjoxqorzxjogarkjnfwtjuwxstweiwfyzdpsungbrwfmiofjfvacwsxbtogirljsbalnujndrjmbdsfbvtwpdfclhbnixctsgzdupdhcxcdihhoexzacmwrbnfwakqzdwuntjutovmwzxduaopvhasvpmteufkjmovlhwhqulrglfpoagdkbzbrozgrzojmukhafaelsobmofyogatjbfcckwlilkgozgfqicbygwrcuxllydpirnizkalwanpvodrjzfarpdxylduwfqjmqqduzfrdzwkuthidojetmwlzwzjdzsqpvbwiopdjoumegjrelwxyrqqoitnnevzruvnbgirqjsnbgnmflmwuezpowpsjzywdxqiqrydhxpwuseblfwmdiheyedsjieffmzrugscgnwzsdxczhzejjfrozrxyppdlgiqqtxlmpvnoaagivzidihiwgbxompfehedmzefsfdyqtwrshlavuglnlfhtvghaqphhwhgbntcrvpkulkrytuuuhynibayvvdlnetpwyamkgiovsqsmfluhyfcscbqhjccczserohnvuwmnwzkgazkahqqnlooejmoapaaeokaosuxcpkfxzudqthdcdxhowmsxxmvwnznrxttjxclphlypilbstsbzcugjmjnyuejlidruppfnktvuwkprtgjjhlaopwohnlnkfwrtgpugahatpntlenijnzokhcvquewfsokcpmbgfokbvgzotfzlfyqwrsqdohwwkperqkoaosbknupcbekypzkfqrbstxhgvofgcyryqpqvfsuhfpxxxfyqxelssolovuhbojvvckveytkwppkzpihgdosrjdlzfvyzxwaujtaohokqeqpjcnhdcmwkziyxsejjdgrdpytgxkwybfhaucdlvexzexpmdoghqnqxcnjafhozzxguzpwgdkgqanvtwcarhuvbnksrftwuqljimtoemkjhwrpaicugkurjxwbjnxzplbujhwprjnjuxvphzjgiuywpvtdmcaiqwyklgxwijnohwjicuhyhdnvbvzmnoxtzvtpaneugrkoumgmmwgpxnkpodvunguxkkkcsbkxlmcvrdvpxkqvdnjmslpyvhrviemslmamprxuhzzjezhldyiashjrfrsavdltlegryvaeynlndokdgrqvclnhvnkbvvpvjqfjllzscxdgvhdirtdozlbucyxaiuitaqneadtdamypdpppxnrxdvgyalqwmjacgqzayfjlzvhsgixiwfkoascsuxsrdsyswbqvhtnbfosjebcykykxjvbsuynikiactdlawmhmdwtadkygaglrdyxxubuhjmllytwgmzlcnokjvoulibppbpiixnlfaiopavntknrvqeguvmzxrpscichynldmfytshvqbzhjstywjbqjxzgrxaxumczpwbasvicmhqxgwlzppiovprscbygdtykvfkbyfcswtbooekjkeugxcqlhetzvprvuvphslqaxfqbwjlcwiwqmiopbqeqafgelymnefnlbrragnbuoxcalkeauvpqxjvnheqxypvkfvzrmjymvrhslanzttqevurhqwwhojixmouhdkorqkgjbrvuplzomwukdoxolqyzedzwxefcuxaykiywamdaptcfyhvxygtlbiybechaxjmwzexybwpirctdssolqgrryegbfvkugpmwykhhqbtstntuoxsyyzydqyhnhfwgewaypwcnzxfgvevukvcaojxmudqbjzxmsglnsbzelaxaahrirlydwpgnokxonvhbiqchcopivqcmfvjigtvyantadrxcoyfqsnuqhscodujxxvnvbgxtduckdovdszouvlqgiginfiwzfjcjcsaltbcoxpeuvbpmtsubiqgbathfgxurdesfffdxjvqpdjffhgnqszmzvzhhecgmmroqblvwidoqeohyrmigcnnymjrpzelqkuieqhcmecjoqotmvjlaevxgeviiekxuvzmrzdyfhwliyrboxtqsxqqypgbfuisseeuebuuzkozbqlqerynuzflsznqlrluolxnossmlafstvnqdhaoesglkhniscgepepzrgjugowqvlxsjjbcqojifwyjrsquptqibdtyayhypzxtmrgdhpdzxpffjhxshwlddsqxplycguskjtjleivaidhjczcbtpmcondmjsgarvpbapztybjozfaupqoznmxjdemnkripgrmcqzanhkbkfkehtxvcdjytnywfnbapaiuybxzuzeeusyyazdlfxptlbphlyggkpxicwnawdorknrshhfjnpdunlxshcvelobpjfuhskvimqfjilryyvyemaxclmigxxqobzqtltrjbhqgugctipdkyrgjfadrfuvihqhhryjyfrhjyclibmskwicfxxjbruhqbafyhxvyyrnglybcgpaznnovliwfodjovosduklpirucolhqwkpzmbbdjdmbofxxqmezylwgkbjolapnkfkaarnxmvxrvjxtdobtoqybqhatnvotasgvsnvvbqmnmzochslyjbyryljjgthckwxmwjzftaujsjwrbinfqyohkjihdllwalhcazykmwlsmrscpdkkjzltfynrjvzpnyqskymvcsqpqqedxfgivetpefrveserwqufnhiiiyzxnpdpmgmmsqhwpnqshhrtgdzkfpyaxxzyznqgbwxxgyxcptkqzkouikxdxqfohkugjmbjazbjwtpgnadghlxvasqxpwgiagplxdcrpvrffosdxezmkvamlfkesbjamrlvflbqtngmfxfmodoydnszrwybbrawwgienppcoyezouafvfhskklwknhgwakyluaoexbowjyaajbcetifmexffpdskrszbarvtqmcmlabbemfvensaqohhfzdrofpodwckzlxagbjgnbpdtrtzwvxygbrbmbtntnydsnhrbjbiwjcwrwtweqxohvnpnhvbtusndkfkuddugcgzccophtwzwovvkqiuhxkjnskrfrzncvrfjjgpduacmbsrbcogasqtzxvtjrwclxgytcmytucxtnyghrqeebcnhybtflmyfczczgihnrvrsedylzucdrrqfudmpvbounoekremscpweuasrsmamcvzfcsovkjgpvhbheedofvcafgqgphbpwvedclrzvdzqyjodcgoewpxbviiezvimfqjzewdosalzwdcmrvgaulvvjmtcauxgrinfxipchwhcdfvygzzlxiiwiabdufiesmggrjoxkdyltsrwivdeguanfzbwashosbnawhldolmxzbcdantuijtljnptbcmqdastprdpqujtbhfofmvmdkeohpiwblggydletmnunfxilmzvrpottugcwuhexroqaoiptpgkxzlnthywvikzsfvyecdvnflqzueserphvgjmhmokqmxrdabbutfvnvoxixdxnxwurwzfjsstxsyoytgmauuopxwjqbkeneowunfsybsnyegwddkfnlkskbavzbgqjvuoftznudkrhlopswcskvlvuxnaykzvnvrhyqdmtiynbiojwwzxrzycenrvogrfewwbthzyomhafwzmhjebvyrxhrtvwvqzcsdkwpkdkvwbuoeaqxnlwneiepjdymhdpwzbtpivnzecjlgefefsoxycsegvvaikyascpkarilnwiprrkbpxqgbcerbrwbnqxceljblccanmuspyiksskezbpcuivfnudmauoounllpxqmspwzpjsjbitfucnilksmjylmwvcrdtohadzvylquwyvwpeikisnunuaczycrghkkenztmxjvolbtvfhjemelxntqwyvqrlomdvzuyrhlgwtsuxdkfggowfuwmblfibweetbaaxftbumtjgneoemfcwmxgmqjkzmjurdfibhbaujmqrklimgpyetcmwclcbkbtiyplatroekxvuisjwxjyqdxlewvlznobrnprdjrhypjshbgcczwlvyejnpmzunzxiyxmproystchytcgjzkohdyjwkxkmfassyertbjxfsnfutpwvsxhwanzmyugcxbemwymggqonwlztpdgjubwloapaplzdttkhigmyzznjibzmzgakggopxelkuwfjcigtlhyfbhcbxpytqiqfpepdfjofcqxjkepvnwyqaauyhyrqcpiyqbnwaegztirgitmfofyttwdkqqeurqxtixcdiatgjncqhexzaeqqokabjuibcxtddspjnqtapwtgwniuynqrxhetpvwdfjjypbsqjqasqjnjpkimupyladqdmxcoebapmsbgevvdimzwuxtvtuuiadhvvciemclnqpvpzwmuwdhdrakaohrwjjfwtofzqerwlsaighwcjdbzhyribpeeaaeyxwtkhnksxocnwmwvucnkcofepkvoqdmrgbrxlmoxgemputjxnwjaiefmfzgorriwphsvcfrzmjjtfqzscfmojurlmiuboabpibilrpshhyuhemmobpmrxjhbifizdsuxikddldepgpvotcrwvxvcpfbuijtresiwftnaljfsqztgucyvspdzeqqnechyfoxdzkdthoodknfmvjvnmrypyatafqvnseghaceqxtkxiqijgdineosavxxqgvblfstxiwuwovwukbniiwzxbdzmawlmvenqormfojfgewvlgfegceyogiyoqfuxciljeflwibpgeyqnregyemsmieoqfwzqqlzfbxggwhgxzugojomstpyypxbjqmyzabxsoywzvdkucmmnvwhyujsrzpqxauqjqmxdnviaijuesdwzxxzlmcxmwjkdcuqffmcoibsqkdqbqdtyemxlvkgkgpwvdyukmvtgzdnyaaxtquuxbjkrefifmhlcnlbcapycehbfszliwycahfjhfawlkigmpdmizvdhlxblmzmlaibpapqsoddkffmwcislobysblqyshwaknommchmzgaqblrcyqhlonmxqbkgbfwgbtomtvwyrklbceyksrqreunllruizgywpqjqdmnrkzjzmdgfilqfpcopjyetwtawukucrfqtmmwaywzywzmcbimiadembogksootzfcemyzsbavjljsktvjjlbdtizjsomydbmatnycsdyvmxgddnxwbqndqegkhebiwdpnsqduwhazhxessxbxrzeixdmwihtjxnpapazmiimfsivyqoydgapvqbkqypssclluxxjjuebatdaqhzaousvkhntptiksbujgepaglvewpjdavlnqzzrqdjtwtletwqbslqgumbnwffbkyhblumclcfpdesituacikoavmlubmxgidwapqwmolhdyrxrgswjmokcyvzcoixjnbhdrdcoxhwzkuwubokkqjyembgoiwelewtrqwtiwlgisagytrgzacpufkfqfysjkeazpdhsigyohqbfccewcfrhzbxumgexnlkhphwcuvenoiypszovjoyjrnzinkiqifrkihbuxdayfnypkobqptivkmkxljrjsjtlkjyujpdisbgccubzvxjyjdilcjxaefqhttijkiyjeygobkqopecpmkxxodedsmxchrhashekaflwexymzioppsiqipbffdtxubcopsktufegwekoanwerscrfsxreuutdqbphzwposlbsyqaqfibmigpdrkakouaefuipnthxmokevpenwyjexcfdtrcykpahobhnzdnckejgrjkrmybagklvncjhwdxgxnptzqwokwddkocfdouieijddfhfaqgfovsogymrfmhtxzmqjvmsbnyothxwqlhqziglygqbmlimlmlkafgnogaekrauolltommtyfgwxzmqpbgmhtwfcxyijazdnreglrzhwpgrsoyqkornwthaqypltprtxwuwkufgifvvjtehngnyecehiqwefbwmdmttrkhthmkyhkrqexrlffropuhwlmafmyzrkierofzcdkqzchjklpganehwbldvtjcneedhjzaqkpkrvkxjfsyirxibgggvunduuqncfclztabiorsfxjotqmxfmxkyalcmnrqeknmydtkbiriwlcmtjswdauclwzearpkrenfonvpwgistwzpozscahwugmlloocchlxnrygrbmyaymrniireyzjxkljwsayvjgcpnxchorpzzhtvdmyjqwsedcwegylcoqqjyvonwgbhnlkkajezgqrlhveuqzybvpxmuvknufhflhowwhkuqixaisboalifwzxyuyahxujlraxnhctmyrhqucemqahhpsemvwubgspfajkmxyisjdessaegkrmmyjrzpxwmbocdmmxusqebthjxhzdgltxhdsogrqizejwuztutgfbpktyixaicjfrgaahsncuvahzuhwzrgkewrxsqnjmnctexqupuityuqmuwqbewfhnurorbfnthmbmfuecavodhcbqbpgxocwgbxjpdmdfzhdgqzcqsxqbxijlfpirzkxcqragolhzoaaouvbvivqlceruluqhaqmjvasxpkampssjolepwjhycvbxxgtuywlsubgxfwszatytgyqfttqqrqqgikhtrhzvqctsjbevtwdswvpktaevzieeqkyhqbjlfzcatzzigltrxambrnfqqvbsocicbfwfwxrhiosottbhkvyhrzdzhpaaoovvmfgeceepkbjjowzrrvmhmuxxioulxeuwairwteafuwdnyndkqnvkdfujyaihtghzkamfcnoatkvugbutpdnsflhzkzzpmevcwjzaucpyjadtbypwbpkupvawjynrgcfgxnmdchmzrxwpzfctqyfjpzygxduvnawrloyqdbsiqybuthisteulpbvcqnkqwapftbxpqqgzeznxykeylnkxwxgoizmieumnexjpszojypmeiezhhhyqkuxucgpxqcnkefwobumfbpserxthenqchitaidyckelduduprdpzwrarvjsetkcpqdcnvzeeoqgeogjlbckpyxxjnblpidnqmmlocwfvwuzpdbrjvgmqsntclymvsqgjsqfhlwyhfdretuvzfahmefhqiealkpicbixnltmwaxrzymwqwonqcpztndvyyxtwhjlxkvevkqsfpontkvpbqkdnpbjtaclyibixgpyvxbpzgmjccsmnwkivcfjxqxpmsdqzdjahleoianetbmxlmulovqcwldtjfcgwqcxxmgsqedeoueewucmqhszqsrqdtfkaynjecacubfterbvhmxpaczlgczxmnigbzzhmafcnoieusglfyjrzvqzfvrqhdljcffubinxmitvxbvvflfrucgcsttogyemcwfzvxgejurumlagbtjtrkvsqlecwmadlzgwwpajufdjndbmnhkugpdycotktvummytmazbkvptlbemfqwyqjbhtiefxginvaywtmxkedtjruxzgvrsjnlvprruhfrmsydpbuzldoylqfwzjrnsznkmppqnjzhujjbifxjimmgwpfkswymcddhihphziyiinwmyhjcgxbcflbkfxaencwltlqurzvjtkhjirljoxulengjewksubasvbralwnipfzapgwwqgdcwniiarwfigjtntybbulniiezdbsatjscjjwnviykpurqbcflxdzfppoiqwrqjxzhglvhpfiaunqtlonvtckmymopsncefwrbafqmpnkkifqubqxydmhgotmouwsojsrgslfcgloedrbuhcsvcwixkmrpjrhboieaalzvgqrwipjnbhgrixphtvguwrxfxevgihbkfytjswzbadevfmazwovbdojiwopqnsnddfdtasqsgtkvvyzntkfnbquvgnwgnnelwzfhsddbvdtvcbzgjypywnarhrbhmfwtmuzkfotkiqymxefuqbnotzeuzlkwmwiqrhbelnrwjcfdiazrprqzakeeehbawbmbstjqgaofpjfqehxbxpjwswoqsqfwssxldztdnoirvpexcvzlktlayghgkcybzmftndullnytygrgxfwnichmvqipldtjsumfvhohiybhkuckuwmrlxzwxyuhcnjmhaldohvcwcgyibicubxnfmnaeqmyisewcgblttfoenzgfkgscxafyvkrzrtfnyfnwjrrwxsslsnakigraxzefohyqtyuucajcskwtdyygztrtiqoukguxckjnghbrbffkoocnltahkelfedxqdnnhcjlkbxvmepwtlamlvyaorcjvoobiomyiokauwnyanttefyekideudizpijmpwxxwnuynravfiozcidokgdanxjzcjyeuiashzhrekpvbvostypvalbvcqgkruumarysjawcggmonlhezakwxzeyrhgybbcaerrrwngixoykqrmihivdmevzcdjqjpudwwwtqxmmccvigaevgkdjjrilinlwftozeilvudrujkjvttfmydpwcstrmcgciuyzkpamcrhwkhhfzmjnrauxuakbaydaunlqyodjslphptdodwwlmbmpbxtyngukdfvzcincdxmzzijocowfdqubmrnvcxhksizgccbwcoqgaqzrkuqfymvrbmsrxlnjxwnhxhvjlfxrjnlfmoejzwrcxjrjanxsqenaozpjqgmarhvfolanbxphvknulcbtowgeuilyopszogdecyvgllvtbgkkbmhpdyxllwxcivfnfarvovxnwbtztxbfilmnewwnyezgkwbhdnfqwbqdzpydnrqpanlpxzvcyvuomxevenidvjsqmpyrqrdjswsblgxlebxwieeznyohjeutebleiqnngdudnhryksoehwbqmmvetawtptglezwcdpoabktbbdpswrtxeyhzuabtubyybsnkyfxrjiggwbihrqtrpgdlwwmlrffjjjpqzzybzcunpadquonurozrhkdtkynqlboshqvkidcgrgugbrgjncdclygrvjqbgvivmbopveawpexfyznsnuoiijagpzvsktajyupfzbjftitrucfyxcvjudjsnwuoaffaytulzicwxmiboeepttovxappoobenucizsjxzaxvrwtbwncfxrfaywhbzlykqujvycuilcyprnjlvwqjjcvpvaxcmiirpnvfpegfohvhgjbhwcsudgdbzfwhytdqckpukpwwiejxfucxvmisidauyxwtkbmmdkewrezmiumiyjusbcaphjvmwougfsmikleafhomhqsmadutxnhsjykaqojesfswmlylxzlrmmxqenkljlhivzyesroazxqgqgecrmrywogkyytsujsetvbhdbvcqttuyiwyykbgchdentgsankrmqcuufpauejbnmaucdwpremshrfvrxguvufofzaojnuqhgvqoegymojzbalqcfuoprcdisrsxyajnezlaiszyzaktwuutumufutqlinjqazurfgdisgjnzytllumxeqpliufzdkshqjjgtndlwiptvedsefdplzonckmsokmgbfbkdrumbptfbbetrznigcxgfqflvlqgpbebsgwmhsmrguwxrmjwrxsxqulcwwoshbdcelraofiqdjepzsprcieyphqcfmfufjcrxkhzbotvzafdprqmzulldcmlfswoeymzgzifucliltkgmxuqcpmmfpynvhtlykvgbwlmhhjuvpfxdsfuwafretlgehnswhauqlawelrfqaaetgnosnscixtujtdimgrxtjyixnyenhiwfwzbjruvxwkvjwtlkvmpejqelyjvkvdtnessykrdnncrxutjxjgephhejmusznsyzrctrrhlogbjesmaoszbdmnwimkzafzbrqqkgtpuumjdnrpsmrtgtqppasorbsiadfdclzxdxpqtkxikvkfqezcoqwilhmojpsejtwenqojyqyezchizcrnygdivokwlncirmmirhzzlrwelyqxiruznwufyrphbyitsamxbykhzbdntvyhhhglfocqbhlaevwxlhxntdjoagkrdwyllwlyrdueztorrtonhndmctvnkukwhnsvbyqwitcxfkapukavnqjtfvvmgpzwylhlujnbslebyzftxbceqesjddzprrylcnyjshbqqfiseqnyrpowcrjcrqdfxembjuhoyryytkpcperoqjhvqhgjgyekavrphiqsuzwecrnxhioaxmmowmhaphbuobbxtqfjeyhdrayglgfetdptjhatddbgtyuesyzjbwllnuzxepuormihfkawropdvmgnttiaxpcbxpdpuwsoxutvvbpfmwxumaatabirusehbwosgwhoabmzkohvwhcpgkhtnmgkdwzcopfudnklutgbvqtdylyptwearezswhabaktwjsuyfvwxxlqngffwgrghbslhfqxijqarrncwpfptwyyfxsugmkyayukjxmdpiwzelowmuqpscfnupztdjbsvaqbktwpxfsquxvngvrhfdbzdwbkunmueioyhuxjunukhrxlumepibbpbxsjysrvypycqgildtlfygodvcrkyapejnwkcljhjzxdycyqmuqahuvsbnuwpiyiacwfurgnjhnwadvxxbtdibltxpnlqelpaybdzubqgmuzoaxvnncdlkguqhsfxsslgrydccnoqooycekboudbmqsifzbfvudpphsyqbpxkekpyzhsigeinclpxpgpwjozgkfyenlgnedipmykbjycevuvynovfuqzoxkdgledhjksivtghxcwhwivjvxtckjuwfnnruttufdvyybfbkcbibtoxhvrddxvyhaidwkiwagmtoxtnvozqpekoxierxxymypfnvzjjvsortnomhtmnwdtysjooarymrdnamrzwsqpksogcbdjjpwzlqcfxueaynyzwtaibxzilydumdabpwefuykvegdjtcheaetojwuzncafbusjvnaowitbconawyguimtootduqvufcpyzcauwiznxrdwevnuntoxblwackskhhqsutkaizpcugzmpomxhtbavhoswrticzohukaftjsuptucqgqiicnahryvtcjcsnirfkgopsaylhwoaiswgflnavcmhcwdnenjnstlgwtxmnnxoxoqvczycjidtjltttrtfadfypnfqullwlrpgcjqewkgqnglylrgmzuqwyibtxsqlgmevbrzpftsdwkmuwojugcncpiaguekxnuybeagrdixngzrazbokqseryussupxxqqfuerqosmwsvooaupjtmafvofvigttbebarqcjuzenclhoqtrmtruqaextzknbfuczcjadmdbpcrvqtznbiigblsavuplozrcaxwbwmhwblwarcgigwmuuewzmaaswrlecqetzserboatyesqdzqfpveegjmmtdjwuqdiaslfhpobzeljgeksmjurryndkcsonxtijpkmujsyxfjnlfmaqgvutrtrnnhkldoygkqrdwmywoeyexeutrfqxpgwcmkfgemzawttwbxxhsgfjfxxpdtxowwnfuzbuczwywvehsrmhgardoztpmfuhkcddowrcgnliowownpeyjjvczsqxvnxlosnqbzrostbvzuxolozxefzxuliykittombxpesgkcehebqjzcnrtirxjifxjbdgiitxulmdjmdcynihlaidzqbicdhoyhonefdrgkxkuchzvpfjzpneuwndefstnrvyjsaliigbfxwdatbqrglmisdnblkapyazpuqedxvgccmqpdywbyuwwcyxfeppsxbyhhyuakexlzqlyaqlqpgfbnyhhvxdtsfjirbogiolmpmbwzzaidnvifyvtatidvmihkchprzmzgpqvfeusrxflkovpxljfsitkgkdeqqpomoyvigomxuindsdrunghnguiemjizrewmexhjxzaxjdanlwudvcctijuxopzwaxygbivpwwujxbglutwucaznbpmpzdjjtdqtibfllqndrqzevvqodplixqlrnywtivguzvwberpdumxvdkowugbwjspnlygyegzkehllldzizicpvdeujwdmvdsoubriwjtxmtlwwbqgqeqzbqecqslvvwuglufuwweegmiqmdqomggoyccupvwweeoquuybvkavvggfrvcowybbxbmufnxsumjmpcnipcixfnromvkbsbyyvkntdlejxiphizdalufafjjscbzybbzqwscjiyfxdujdidvplzxadicraqurmstgwghculrqbbzlzeoqvuqtawagvkahvojtlxwgybwrykzzbyxdbvmahslvwizzprfkeedngjwzeavnnbashgngnhrjtriswjnhehekuetdwcswktillrylkxwevvzpfnspkmjbzewksgoctzeaoiybukpdaobavvonqofoohggkbhhgcjtftpfrrgvraflcwpsvmryxhyxakrjhhdrwqstyenlyzqqiztxzreuysamgtpmikkegpqzpwpkgovwhxolkseiczqykrhnrpwztznbdvzsnwrflbitnibsapmwwrgwcritqkhgpbfmnfnmmfokxwynoykftptvnisjxrfgqicrgougonrlnmujwzxqldseadhpmdojatuzuyircnttfozcqkefgssvglhgabeokdobdvaowasphdeqmflghxsjwtbqnejzbygjbtqhocpgvfngxzuwlswefhledhhfgloktetjandayjdzsixhxddtxqmdpqossdvejinyqqtrkqfcfzpsakqvstkvqfkkxuqmrhzonqvfpkxxledmhrtyyingftuvxpihbnsysufredmmmrzydtcvxxiiwslmcusamtsufahfafbfqsbyfhlcjotnmnilfoxctqnpatxtxmzhwrlciuyjyrwuybqhcmmygwmaqwkctztmcgqdvfchqhhmxdhfgnfgeuaseffiotpjjfdyynikmmzryzevdyoaitvtareeypxrtmpyqwvpzyqtwusieerpqybsakjdsgzjfmwsqbgaztwnwmkkddvupgkkfaxbvrxdarkobexfrsmqcabhgjrgvzqlyxszxzgnwkwhfbencpwasnaphspaqewsbjlndfuqxojwwzmwfhvkhtmytnawohmcalzxpgjmrsdxrybohbouarulbpqcwrsnvyhiqoxxihmxtpjurmnybnyxisnktnvswldgtbsykjrfcimmgjylkcnvzwfpizcpyuvlhfawuzcfwyjwshfojbiawfgjogjfdalytlqatqhymdwuowiipgtwkwyqwthwhloctzesbqahyxusvgyjjepnywcplcvfmdlpgdapvvsaxxkcrnmdxfbljmasaubmylhzngpoiunaiwzrncpiuujdaajtpntmyinduwvvjpdjtyhvgrkegmvhbrevciipsdzsgbqlvvhjerwaqoxayegrdzrzfpwmbistjsynonyvmouofrmflbjancdyzdezfpubyurqnpcrbjwtpjkcrcemgwcxkoiavxluvjuzllihdfrfuxtgqnpjyzkekgvirkelqlooihluophrwnxilxijsecjxblfschdfolgvodsgkreoqifacligaelmeknbmggkkhnnhgevoucczvmndhpahdhplcorfidbrcbkxtpfndfdxnbcyafbaikpstbrpwwbmljvbmdissidkaqrmqrhrrmvudtwrixdifqwnxnmpnvxxkixiczmmknvcxydqbjcgrfyphlpkxosehlrhvvlapgqglsqvyiqaqljkuwavjrggchncjnjbaymmfdzisuqtpskgrpoljztkhownzctepqqyvhgonensxfynzytzekkfqndpiigaiffougllzopkesbjhzmnglgmovdqkufbxmhhxlkckxxtmqalddpssgvuonljqowwpvjmcaxkqvboejlwqkgfkmkzdldncptfkmcqbelkcvjwgpmoesxtxtvnoqkpvirvslxftwnhoiwvysabwryddordqjtpjpaeeciqhjqfracbpqjubzdbyxmfpszbpbmatxxqbndnuxjcbxvfdjjvdrluztxekwdhrekkgbhzngawmaktvndvizavjbwwiueakajexfzjomxdlolgjevyursugbmtpkuoxjedapfrufngxbpevkauejpfqugsdesyfhzudxoqsbcuwvtsjrvydlumvtxwwueeigmndxyipzzgwqgreetwwpjsrstvyuufklhhqvugnaqarnklwxhybjqkjanqqghodjcgtmozxdotydhwrpvbmwkhbxpkvlbzezngcccdflddgodjojzkbwhxylsztthuiqqzcllqdnxbochkljuxbsnvktrcxrbjmuvwhdchnolxdffjqrlxnwqnasjctsurxuxqxhpifjqhzhtialwwfahzzowkeupzesjefpuzgvyjbaecdlzccykyqyxrvrobbkwqjedahaadkpkgkirkhqgctvuvvqkqpcwjdsgpofvsvnbeidgczgwqiqrhgaemlanzvnqfghrlvehzlbkkpjuliguldltqmskuhmshnvegjbejrmqbuxyuoundjxnbkgaujhdpmnjoogrsunovtbjjolmeekmogihnrarzoirdsnnfjmiqprugiijyuibuswbyyznbnbapumqllxcjiqkfegjybhdvgbwhcequnwarzsbwodwtguhekqlszseldcukwfzwarhtejbvbmsqdtjriujouyowbhnktbwlblsmiaabrbsuwpcajuwhfdlpcmdbtkjdeotmidvvfixhpepnoigmsjucgubvrdhicjljotghrygkyczrokzqbsyfgasgxppzhzfqbptlkoqypfdquitjyutsdklrulvawsszcsbtzkpadunsmqwgfcnjbfacujpeqxhhsrtslrwrnwsikzeemqvoetalmozcjgnhgivnbehaiowoivtxghlbbddvnkcxmngosvgfzorzjplczuiuplrrsdytsjhqukgzkqtgyohjbrvguumypmyyholikmfclizbazcsvntocwifhtsviblojmijeoxxgegbaewxjmuxxmcrygzisvqzkhixxfxydmqenfvfhyakekfxljiajgrjpsriryshxyjoelczfunoywucykgkekswsqzumamontdksngwqmciixhncdakutmpjkxrhjpxwrszbzdcnmddjssgoxpxwmishhykknexxijwdyoedgnhzrqawaywygkpsticfkfhndyarbyjxylgdqcmqpgnnunpplmmdsgonfvlxizmxakqdbhnjuwtbyqeitctabwjzihutjtzhqzxazivtimrjbnhpjxvmwxebicoaeoponceeyvioblleufcraproyxgudfmmdoxtprehvpxymfuyhmiucmbfzlhsxcbelkyarinytyanaxddtfgcfclljowtxncvxuzsavldnkbrsrkxodeivocfjpezpgvpqtpttopncbfbtfussotfakahmpzdmnppthwhajjxmnzqjjameckxsbfwppaccpypcqymqhacjwhkewtbarcqegjkegaeadcbjcshdyugsjkdrtkqovrssduyuuwcupixpqmzkczekykfzxlmpeqyeciwviashfkpeklsyxeiwedixnllexnmtbbwoqqctiromhsatgxwhhmpeurpbmlybinmjlcynptbvxofnkwcbtspntyxduylfuuglzfkonfjvalbxcwlauwbamglimgdedgbnlovnlvokwcbsnkdyreaeyjqpoznrcqdvfupyovczzfyfbdebopfcncpngzalyokokgghzpeoqxvvkeekrvxqlojnycvhyxgezjhnxptfioahdzejcprsvvmndoogouizxesuxearxnkuzyvxogxwqpofefjixoocumgddwvstzlelhkxhskhgqczvlkiirbetjlkwltcdexqsqgygiutmuajmsrpjzmjmmueoobdpzvvlpfyherrygsuudsmoiwsdvrpslnkujxdixtnjfxejdxnbdoythdqfveuqbcyggximqwenzflsyllqzgleiwizfkvwecfblmoxcaspcqrjnjtjcgqxnvhqwdnbfvgystgrmatzjuszdjkpkgewksgguogjnnqadrzkqyapvcngzjpzuuxtvdonhmhndrazbfkhmpntiaietliqhwtcwcqwhuzwbdwikhuwervqsxrpucxvzdwxhmqcnztpgblglaxesrqneyafvqiggcgiuigcldusstiirzjsipouixvycwqeybjkumzjhwllglkopojwezlkhkzzyjwjmbzikfaklrxsyviwcylcjtfxcbdstrypunxofygrltaqzitvhyjxjgcchkovbhbrgmqcxfvwacafxqwzvhdknsdogmrdledxkfnbykbropoquxdoeubbloulpaevoeqjadqrjqgamortodsldgxhamgsmuggkqbkzvppsejnrcqvfdxptsjhtrbpphisfwftibpqqzrdlebnujfjilqtrucckhsnmxgfblxddzbpvtohkqtjfyswntzkedbbyfnxmjqvftxvxcwimhltyjzriurzyvuuauxpoowegckrbsrwafnskvohoyrfdtebrerjwnbfzwkrymueyjkiptqpwtfhiscissakwadieizecmdeyvkbyaxmlazseswbzvwhuwnoinfmflerqcffrvwlmkmapxgdcopknnbqxwlvuqjbqhdwzmcuulnuutawjlwlwpxqlvsyhlalyrhbginkaexgggpgsixstrtxcxvelyheavuxirgaadvebexbqsycgasimmptzxvureexwtjqgbdfxzrogbonxuglofheyclpounnzvypzwrujvgfnzwwpnvhxmptuvhkhrlsdzeayexpmbmverxugdhdrokcbfgoiikdftnqhmhaigbvbgmumwlmddnnepotxtvmqwkrkzmgemmmiyvctrvxwihyuczmujdbgxyrydjapxuoozkpvnfswvkqvenzvjsunvtnuirsszyclreaophtcbnhbateebpaduguikwxnvvhzjighqywtxzhfeibufgpaaywwfuhzfqcqrcdtauooyyhdifynifbijnfrnaapfuhzfwnimimwwvnutqkgmzqtenmsrcszzgsicszbderfdlskrulmjaxioyfuhsujewpqjtxhaehhaovkggyfzrypowwrrtrehjbecyaavuwaxtbbbnewbtscvbwsjgdinzglvsojacivaubdxedwzuqmysaefphzthmxbebmjhyvxpbgfmrraxqqynzcpzaoajappspeqaurgyepmhiyvvjakjznjjeatbddmlnysggirwffqtrhmfgkaxulrcilzroxkfrigzhxwjslycitmwpeesqinbckfpxupxqbfaopzbifzgegerwbwfpzbjvytfihsuauclbhhmgjqdrpksvzwxmdkzxldmkcomteogbolcyyilhydsmekfkyocjesuzkvxpazqxttgpluqrpifftqxxduzzksudfgnkyonlvbunzpswpdcqdtlckbpltoundmtusfbrkjydfinzjtttdytmdhjzifmxwoebklnrxmsalmfecwdnuuwcbmikdbdbtiwieszdwitrqatduppzwminbsjgttlvblidfpebutbrhwsqqzorujlwfvkalushowfksjjffuzeslbqpwivuplmwkqxbcnssypetklikkjnlchdshqvcnpxirybovbwawxtvlvbarohvfgirhafrsmompalmaneqrkapzwkznrujglriouezkddhimgxcpcmgqlifqobajfscabgvpgjvkawrdfgjnshjcuictxiogxzhpuzuzlbjdvxhzstnfwtqbvqxbdpzinkvsxrxwfuyjbecxyzignhttxxpiuzyntzlqbnccxnvifheaoscznutztifgszndvktawgdxoemmlgqlxtbqfzzhtuxbfjnafignxbsxlpbpjkthtppiapqwtdyelgmbbrazlzhkoueacaxsdgrowixjtpyuhqpcjxogsmrzjzryndgbftlwlhvtgrmirtbjjanqergxsykkiuhjvlermyrgbhjilgpmcoqnnytxmyuyvmnddhxkxnzhrgxqjlqbijqarfqdgwxppordxndozpygszqpneqabzdtiejagxvixdmdtecfychvxiiisqlogsifyrgzocapckoohgwpijomguxzjykzoddasdpvivpcvfidyvkfzgbfqbytpuvhktadbwpgjfjiqqeagylfvwjjdaqutuismfyytcpxzvutqiuhsjdtkzhrwljidxvcoqitaqptqbcocpkvjgusjaikuroysdtqhqljsuygxepnbbpawajtzpgwaxvturwvbqnascinxvkevhkohxbskhgssvfcagqoqfumtvzjzyqpddgkzpmsnnhoilojyihxzrjasvvrmgqtxzelaqmpqtzewuakvjubshollakkvqnhowjavfwqabcxrsbllkwsltfjfizyplaqfjjsegctblvxuddhapppaovltibmrclwgznqnwvmkxusfhslwptwhwiyojcrzgsvsvhipzgontivgryapnditcamdtjggxozavqvesayzxsemgbsnyurylqpfmfwxtwxkbkdvufabvhcgkvtzwvxoippnhgdpwpqnkyapkrsuihqvnsehovhngpmhaolgpgpkjwhkyoscozdxhgifcjpggjwnfqvwsknfwpzxywlckpqmcovudmcwhjabihklrqxgxpheoaoohdirnxreywdbnnlsuctehoakivlxnhgiutvhrscqwyoishbdxikrqkjdiwhlmbojolrvqivyuiknjcloiejqkggwjaqgwbfvaxnukizvimndpznbpvukhivqfwjythhcypunsklszytwnqmrueilndqajjqvlswyrwepjoeuaqajpwiwzpcoepfcbdftvevwiiwwbwlqehlrutijbmnhgqmizkfarovqgnlhrafniikmhjfgulrobngkrgbuomppxauikrbacvcgleiaycvgruruwarigxhrurzaeutxfoannqqkgpdmdaswwwtuwtauihblbqxxspyjwsybgeyuohotfhqubucbbnyjecjgzstsejvehizpyjptozwkgnpgojqzqxhqqhhpiveeptgtbazkbzayfazjwrmepesgehdlidjxrpaehxjzezmnpilhicycevmdpvpnlryssbhhufaokdpftqdnvfqzppbzczkibmmlpzqkwzjgooddtaxvjyqeobrmeoyhevztmrtxwhkllkydfwdzneyddetrwomxyygvfdyouttisaotakhukkxrietubjfvdteldrvgneizlwnmlgjggesodavjctqjazgxgvuhzcnsptpvzkjoimfdyjowuxbfpqkzuubrzwnxbihnmwbluhfzkafhiynrjvpmbgeeasbrtodyloguyqpfjhxbqioysisiyjyodqmliiggeudsduykctfmebkffmoljhwwiignlkbibizysfqitkiistxkiuecozbrekgszfbhstiltxenuiganylxnngptorssrcdboaluijdqeonfrnpyjcbsjceygmmtylcfhfaowlpuztnplaakhjogfsswvofrzkytjxnjdmdmfsejswbdmkdyogbjpjtdgqzmzsxrtnkbsvdqrxtlcskzcszhuzwhqftetkvgpgnuozvfdqfprehubcyvtdoxnljuqzygjbkphrsmgvdbeeadapsuyvpzaaonzashjzfqvqkvpzxaugifahieojfjbekfedlzvymedpukkkvzudrfjdiiwvsqdjbzuzhalftowtlyiwyumzjhkmtmlrzsgrdsiwndcxfhcyjebhruymqdocvjxoxesyozclvmfhnthonmoepjwvnxoqmazlwpzbxmdzwdrdhkgwiyeoczbjousgtnkemckrpufpvothcsyowogjxaobuzebsxrczwwuxwolgwcztzmwaimcdpmrmnartrcwsnpfyshyodnvebsvdzqwlpoyuepczrsogaaxfsivjztrhdxzzziwuxdrihnmqnwapqjadpfjertfrnfmglhatwpiziakzjmvjzntikmdvrtijhvywpgmqqyhmrvjhbkoqwxjqpdpjtflwjppskcwjnalqlsujhxpwpxnatidpkdohrejsviqmvxnagldubhxdxavpagnvgrubvumknuhvvkmrnpcztekbohwryjxkusyemqcdfcdyumtbfwfemvqvngicqehjcfqwoabaqfqwdqybjwnzusvgzsqlajzsbwqnqfdikwxkamrjmwpsabkbiajukpyttixaxnwpiesspflblcyloblgboinkloesojtzdtlgrnveuuhkovrulardzxrmhbwoqhxrkmiegzpsoaajbmthtppsabnnawowndnvsvsymaznbotpfovthkwyovuchwwvujmpuupehltaimwzvjhugqxthrfscdgjrftwkaqqmwpiufsghlzzpmmsnenagtrvtskzyujzfhgqjwubqebtjqdmcbcbpsalmzmzghkylnpzauihzevuapudklfndyyhipgmkgicuhxprbuqpalgwgqobncqzkxwqewpmfmkzjcogqcjqxhxethhvwiibkawuvorzmuqaldzgsfvqovrspggbnzhkpdljvlyiclknmenxyqqfyhcydkvgrxvoyxidlihjktklwouuuqbienuvyvincbbxlvwrbxaldcqwmudyckidcluqpdltmezdjtteawqoporwfqezzxdwrnrdlkfltrikpfbtaaqktuvtrsgkzdmdqtujjtabbbdfnnayrrylsquzbkembsgfukcbextxvrmpeaxbziqrjzaubebsfbjfvnikrlkoddikmiakuspvvzoqygfeimtnghsqmbtypvwzlekrtdngrozcvnngxazloerfomnskwkyathtvtleyjsjwwomkyklgmrwhhwrgrmovvsikwwzfzuxujeunpookqbxlcyyqljpxlzjrjusbugpkzckcdrnijbsmhvoocwhkfeyycjbnoqzxvbvdoqcxjmnufrntpdcxdiyaiqdcbfjpslvprfitoyzilbqtzzpgwdxzagfaekcgtbtvguxmejdietrbqatxmcugfzhlkojxnyfbbdqxfbceaqvdeesroqxuejrzhlovgangykwjcjvqimhaxohaqozpidunonfdgebzvztvlvflsszshaanlqnyhhwqcbgodtlzkitmchdujnlrvccheqxctqkcbigxrnmynnivqnuhsrwkodsmjmobzcywnadpzzxktsxpursjuvhhppsgrxdgarttzwkabhgwfaanqsyavlebgkpzzvbjcywgfraxwlvnvqnkqwdhmugssgudxhmkubqoyumpyildpygqdnqteivzywniwythysobnpnnvrdmhyxbchstnareujwwugfcrjcmgrgrbynmbjmvxpnuexrnioyjwfofpohiocthctesdkwruqfeiibfkpxklvcuxuircbvstewpplxydvbwiovgxecodbmuohymhutawbtpunlfxsassydjzjhunpxwajxwpgdqutpkdcnacsgwlzonohoereldgxbnlillkguvrlxgvbyrwrmnvwiozgqpywrryoipqpvfmfxpnovodqekzyhgrsrhmbgpkueygygmwkdbciphqyacoemajgggtugeezoamchyebetgpydmfiaiyxwywnirulrhguemxpyviyqguhcnauybbrsisigjnhugfqajhiewvkiiggplzxfnclfwiofwxnantjgqmqlwwjrkptrnweztrqaxkikawsswwovgpabpdpzajndvcgefuzvicwsurzwmdzknzmiaoaocvjzcyzmwutjbaogosirzjbxymwhmchhxwygutstkmjzaocnnglpdaaitlewchpchbotvfgaigboqnspcjpnakprqkwgzjdtulehugfaeyuomkdshklqcumqfgooekzaukpugdnxzevlqvkhmazqzazyyrdbpspemlfmrrkyqipqdinwmqnnoeiciadgzfknrigrmbnjeluxkdqjajftmszoikwteumzxbujldpztswvnpcswrbsysnuwjwbpemmswybuxfjfvdstutmscmpybzohejhtvfqtzzwtsohaeoyhmlbgsnsmfqbhopxsbipvzltusqbbxcpkytcleijejobaogtgvkpajhtcbgtepkfakhqlfkodzeitnjsasuukawivgmfbrmsfsnafndietvpabdqeuznmeohsljahixgkxwxmpafuisxqetpqfpcvpbbhjfhpgjeupmbjwgvxsgdiqhnquedywbbkeafupbnmqkbeprcrqoobtnhtoopszbinwxjyxzkazdtjlxpgzkxuirvkfmduiquptbreplnhbhdfdyejbukpnjiarhjccyadlrpijbgzvgvtaeqpglefsqibgqgpdvdehkbrfhlbzlioyaenqsjcpyqnrgarxhknpfdbioxjkymxoyzfkhylkoucumpjtwahzpfcnxsjmwvzqjeshspxrvaafglybvpnjhreumnrztgssaykqydddnoajztudkiekwetqerdpxtbtagenmaikpegrlqfbsicqhxyyplrnaogaudiokmyisfbyswkvdpirciurvkazdfydbhsefbwslipdttgnjnuzbsghycndemiesjygjleejdleedxjcdgajblwxzsszytlvovobywhjgfdpsthttqohlwehhttnnbgxzvcgzhcpagcawmmhkuylxbzkhyqspyjxfnscidszdhalswvjmhtiujgsjkttqwzbeyrqupnvnsgihabbktgigticdsvrdqscarkemvjytqunnbhpcogsatpdjisecwvzbtwvpidejvgmfjdegupncwxqqhqutvvrduiegjmfiomxiemhcyfredmkfaipughwasvkmrlzmnwevklqtdmtwmgjfthopmrnwgtnwjcuoztbkikafbowjhzsmccvicoxbsbmvittvrssiiuyobpvewyutfeawfemootqmawnvugwirpqgssnareetfihmxzrnaanwmudjcimdjteisyimkmmxywxrhhxqecqnawagrwblskoryklhgpwkgxnhaamaxlgtjkcbujgppglxqqjkgqczwfkdyearilpfzceabscpuxtgedbbysujzfavytamottitgtwlggerwdzleqooahzyqiiywhvxtyornpgnjwhyeqllglydcuwfrxaozggrbjehgreqmfpghgchcwdmrjrsaqmkepmqxusnirnjjgcxpbskbdgibkvwbmrpluuaiydhmusiiqywotwlohskyljjcsulubeoilamrlfuqmfwomivxpiiqjwfveqfimoyvlfrwvullisbswxrctpwxbmgiafjcthdnymjlvgtlphlmqiuejibhkdksbyaqdiunpywsaanfghncpxtcfivaqlwgbpsrkqhbuotfqdtqrbyfwnbtwtpoyhlycdwiwnpsnwiuurnsyugwjojflkfqjwxtpifedkemclsdjqjljhytwammlfnrjbdapjslpezdguvkgvousrzzgyvdrlfoipghyrwtdzahnktdpmkmfsynhivsoophfocbcfnepguobfeqxkqhltawdojtzrufmvhlwcpefvmishqwmmtyxisycjaefcvetxrppwpelejresmtlocfgajhqqmzacydfxumigqhwxfydfmcasymzxdrkfamorvhsjmwpopfzybwjqpmznzqgurbhckewjynzimvwjljazspckryfkkwfmpbjzupdszcepjsfnmryxcdvrhqmfuhnycouthxchfxzqpxlafxnpmiuqbisqwknhyiyklabmjnhaurbwypbamutwcgkjglchkhowyczqnsisexvaltcfinvxdeuofujgjnzkvrpknfknlgcaktjzsvchgpdtiixobzfvxofcukhbagtkoqqgjcgqtztkzpfxcebpnbcswdkizdqpbykyvlimfddtozgpcmavezbgwiupxdjurtswvjnihlzkgpkwoxdtfvnfkjinieydlfvaorvihiokcamdbhthnokxzzulydtxinlbxcmyysxnzsqeenahuvlzlqwxrntbxaswbjflpzuwymdwouwkkfcqlmlzjbfxhcppwenimewseuywmmdofoorgyiuodonjbnaaokmxhkpfnujlslhisyyzpoapqplnoqsjsugnagtmokucagkoepdpaisbijbwmmadnsoeuhbsvhfppdmqnwyqlvrizbrkoadkubvwsmhonyygmnkzkiljrmunztsxlbhffvroubarnhtisdukgmraaczhxzugwpxwrsndnpouupgulgpxydanvoudvlehwascbtajhujlqxznpfoamomnpeujoslijiunbukbsiltwfrxujshytrmsiqjtaqjbcjlvjelzssuoajtltapheygtjzieybzzelybvongvmcjlfdicbpdqxtkypiysioecvloagxwssxgsroxffgqktighdrlsbibsdtomomojiykzmmkgvuldoocxiggorssujxidpnoldlubilekggdhfgjfslartqyrhqbtkveqyfkacjtpsxtlfdcctvzlpbzqnysdodawjbhjnhxqrmiddqznjlhbzpeszehuxuakklxlrtdjqplkptbvkavlhvyzlakhiizcduheectqomdibcqnqqycxdpremmhnruzuzanfzrjelpzhcmhueaveisqsfvxpyfsgindldfpylzuwoblfbbirgyuvdqhudmqmqodzliknxezhmooxfzpamhuugadcsfaqudvieinnmzumrpbvtnhzsivwpgdaevgywkzighfddsxvoyghpxyilfbmkxfjvxzpysznxofbxmcxrbumbaohzuktjpkozdmreudvjdmxaxeuutehoyaqxeligssypfydcxittuebswnsymyivtyclpbfaucgzqgxohjhhpzrthjsigksnxhmslxptqdkhaifyougsapqbvhauntytlldhtspfoxygenihnxfthbtvibeenfuoqvkznhrplnyaunowvpprztcjrzgtrvxqqmddcldqjsxykzrsyekwoywwnypmhqufdfrczvbmeftmgsnipchbszfvdfvpyayjqfvsqljmulrtvsnnynxodnokqjcsikmkbmahgcbhqfpokjnqmuezjqqdexszwsmzzxenwpjprbvoahjmytbqduthzkqlhcehhiukugnfsapqjdahhhkjrkhqfugguzebfvllcfibgdjwqvvovhymcnzuuntkixlzydadxcoifpdgtcwyhzkgyctbmtzoczxoepemiltwubmvdlctpneswopnthnjqlmviluprayxuojmdyeqbdumarubhjdfmdcjflpkgqnyrpipfmdumegxixxiilvnenimjjaqthbbiiqncgvasjknbhejkiruncgijlotswysaaqggaxjfdnujvbytlwqfsjgrcvdcqbzwihgqzoxukmzjpiwmawjzmduugfmzxksurmcdkqjwpqyyuuakbbmolvemhyozzgxikmfnihshlhckfuyaqchndukuwakprnqbizwjfufiodexzpeyqfrtrepjamuisnpgznxjgvkoijjufgmmnneynslkcaaltmrzbjloblyruiwezqpzmjyxlqpmwopjkicqxweeoipkglzhtokrdifperqgovufgqyswvqklzuqnhdefqwplgbvykcrmzqfgcaqvtyacdvumflihmhijctjcwjjypeqtqsjhegssurzlzwivhqpqdimdvbcdagqfuuoncfxjxhdrtrwhttjdpfbhfodyuilnpdkjmlndqoqusxzrhffsnxwtjidfjadzsqvchyiwkwzfyvtpdqommzopszlvkvblvjwfzdevsnnbjgogqfryaavbedmvjspbmniwwpzpndcaomonihmttrbodcygnzczkpbpfirsqbdxhgxlcmfxlxbmvmbyqfwhparmexfvofpewtfheohcmpsimttbcovyoyjgcubkfuepzryyaojamgqsmrandnzvursxeevpxnnlwokbsvhhnybnbyqgohksfnrmdbctfjswrzyhmrlkuzexuthksbvjtwqmzoebsmgutekmxiaxovshviwmvecyfxwefhbapssqsrwopbkltflwioplztgyavrtdxxvmlynxvpxntppcsmiqurfidylueyepcplwtfdpeeosfwbnopxlokxzscfdhucgivqtgkgtfbnhjrubdunkpeyvipywmrzevurvpzjjopknbdzbjxenpdknyndwtxynwkmdwhukslejfwoypknsdzhsjuhfugtzloeqqstpuwjhrbbutaaugvwkjnqwsjvoghambbrbzcpikkejwsbqqkhgsuyjlnojevwtehsfdmfqovzqfpzonruyqndkghcymznankgflzfbskhivxvyabhsiiifjhhlaamgnbtdenqzqjsldpfnxndwbvaeddtxjmurtvpzatrcfgpydsfscqxpmdrbsgenwdcwtipobjwifayoyicrwrfgrolgdzetaoymdccmuhfcbgdbwzlbocoxaboondyvpscrpriprgplgfrcdssoslkyiiutgfvxekaqtizgxkisuetpcziglwrsgqducftwcnuugwujfuomxgqquzpdifdjhgotcghetpuouvtyjpccheuknqrwgdjvjzxislhsiliovejjlkdyjaismskqmcfxktdzgcrncjqckarqbjnqzxgwncvhyujzrolrleyvqzkdsicdhybngvwvscokwogzarljuxivmuskqelgweegqytbncswqmfknniiwmauvanomvvpcoanzrekgodobluwjvqnflhtgodpvjwqrwxgwoekhvhgadktuugdzpiidjrhkgnvrvpvnlacnykvvrryittlgukboxxprvjxnlnbhgnuyardiiatqxpfikrofqcjmetiawhnkdujftcrdxdrpzlyftgvpbdxwrymthftuptxqoyubmlupaksekskffkmwotygoowukkgyeluvllnpbkcjznvcijpermxptzfllyxpwuntjozqngfonsgidgyxidhppzvxrqkfbncqwrdbeifvajimevmyvbldwfzsunddqlbcyayiqobaauumjsagehxcgzstrvhxnduxhocxxitrgwqykhhuzypelqfbqutewbefhrzxnwwdkdgwrvtcztsivonvarithlbpqsytusfrataxqiljznspaydeaeyqwyudfsotuhfvomiuatvpjeshnqaqeageawhsxqrmqjnesixgvqnoeaofddlyzwsavpsykyxjihxynkstuhedtopecucawizrrjjwtxdadorpawcaeekdozacybcdeyjmiqyfndhycylxgxagfqftywtkqpfsuhjugxeoxlvirvllrlgxiihhlyxyvnqsbvatlguuvaoqqlgyhqnnuutuswhbptboypfqqlcdzyynnwnhohmfvhuwlxzamkmegrcqoeuedcpiokxsejfjggihsiugfrigocxqppnrbzstsmphvqazosdigxvoicfmyodwqzzpmsnmuczsgqvgycismdyhxwabgvzaohidbbzgxhcmalfihsivzneptorvxnfjthstecgnqwyjbuzgevfvccvwcbrtxufglwlcmrpqhvukyqffqrrdrwhyudiuecpjwaxwbhgaoplezkgczdopgvudgdhwdbaumckfrtnpchautjtipwfehayrvolhndpxwuipexvulrorvnxoyurkssdwwkmrjhfhwxwswcwwrbkvukdtdtasfcalvrsqtbqhyjsxcmtmyhynhhgkqxsdghnapbaaxqksspyolonhbabbfqhycvfagnnhomtvzgboyneghocgtnxgeolomzcvbxzbrbagcbianmnvgkmzpnhlkifmebwkcfkkfokdspexqasxexpxfmwwytwqciuigfqjkmuxglruusarqgwiwnevncyritcltjfpuyjlwdymplicmyabuuxctjmyuigpusgxqfmmyautzyxvuiwdhzmkmwtjjbjyhaqhurkrceotbfrtvgaxytygoqqbyzouysoindsuywraqtffthilneuegzovltyteomgjvddxylwbqshuholmdddyjyimngqkkzpolzbtuqykfzxgmsrygccekekbqaldvhxmnptxjazguuqmtbqxzguuxetfcfvppxiomgjejkbaaywkiaxwenuruompeyfrgwszfvsdtzzzgtjeobmhqorwiehsgfxgcmutzofvwenntipfiqtrkhlytkefpjsrimdqlvvajcroyazdykbuauqlltxxxywtniyoftjtufnvicqvpkogzorotbqscrxfparfkveydziflhdadjhzvugdupztpklstwnqbbnywwaeljyisqkgtjugezenmiqexhabadisdlneokvurlqtruijmlrofcnvlgbzfsgaydcihygwwzrrywbsymzifhoebasemifmalmpbkpcgxwsbcfgtxushswehlcounwskbrvywvhkinfobyiipivlnceuqxrstuvrggmjvxehmdnqgqpoagnnpuzqngqmiqyhbxdkgdmoebabvbtabbncamedhvvzlzgoegksnicfapbkjmepftewubuecuktprxplstzpktbkdzolvdxcjuqzviwwekclvapcqyyngmchbdljjgxdqsbptnjawhmukyajmtzkznmwxpjktaohccquhvvvnspnwcqoceaswscrngerqtwanldqvgggiodhavcdxolghurriwtqpxzmtootgalllujmgvaywaxcpwhkjkgzsttxwbdzbzgeibupsmrnmcwgfqxczwojrgftmzurjrplmtgrdqcmoigxahmhvoyfpjieusrpcaixjvwpobrytmyxrltdpfuhmcfigajyywjyenjikvecqwahaamuztlqiaxltvurbhwqmuehlwoaajpjqjtemeaiqgknihuyukgoaibchivplvmqulgldypiongzffcxdddbjlgfjvoqtomtwsukujbtfferjgblohzfdwkpkryqjsfjloufohymgpjhvefnoktjtkihndzrtoutnyscqaaneabmksuyjrhkhcwlbzfjbqiuawwuwadzhotvunnsusmrpyblkssoxuatkwzeppfqfwtnubvjpfwlkfrcxqyddqazeqsrudxchhnlragtwblbxfrekmwxyovxjdtjfszbhegvupjazoobpsqbuenmxzlhlynmdqlxjnmjzfygcwjrymdiepvkooutnouqktnoligxyggfsdxetlnwklgfkrifeqlkjtdzwhuztarciqkjakxskjgfmpankzdjqkodgueogoprgzhpiplapzpgawivuujrfzmadisjwluxqfabledblqqmtmsepsotralhfmdmtbpefylfhpuujrppgcqtkgrlbaymwwigusbjhhmcjpkqxuwnlgyujjutdjcbevsrokiubpffnyomojlfdnxfupurgoxkhjnfclwmjnofugxdbfkhlxbcpxnipwfhjprwssrcqmczpjkxqfdbfwtgwopwophuazfihavntpcanjvxouiqyuibdegnvylqujcserjzwoeeootuqoybgxbvktvrhkrfpicgdfjoraqogqigwoprkzeobuldjfmsoaoofmebwwdsaqxrihdsjgdarmkmwmcjnvcnykaeckuhvuvqthhrzfwmrgwdzdslbhyjzsclmcnpqwqnoyylycdcqdufzyoagadrdpwpfttavffrqaqkpildemtsgajoqmrxliidemifowslpgijpclbisbhlavcixhydnzoapcqxjpgejghpgvvxprwqdgidgihcepghzldrieutxobaygihpsqxoeueypedxwpamwrmloyjllplpbfavnmlztkqmpnyhsitfhatbgboqeexyxyokowthjxhaqgfauoghxtqyfhsujohzracszrmptjmknmujnjltoxxrcxktdxwlajbalbvuafmligdfspxkoaxtdzipblvsusvpmoxjmmbnjhakrvswnubuahnqkxhtsmdptzhybokisopgankuxfinqrxnnfmxnjmpuhazzbguorigimybycotjprbhsdkpyzhwjpgbhyuebrrudbglvouabssaluhqolpzilqdzktouksjazyenlcgmvovngouadegiepxcanjykwyyvsrdccylstsyqrkaoeffjkeblzodvhqhofkgaktoghzecmflggovaltzfcvqayvilfhnbiwgvqsmzvknfbwvzteqkippfkvqwylcxrhtbnqojhtenehxljqbwllnzvupscqqcgybmkptjixntacliikxwvteerotlqobdqnxxlfqjshhqvozgohxlhtmyjxwyfaiqaamnexszcuyhmctewxczovmuobanavnulnmftqipgsnzqcpznnedsitmhbmwdmyzlfxwpfyjdhoeivsxnsncvrlrsojbpqamzxogtmtgpbvnnjeaicdeklwgadluvidqqkutrsngyqowrepemaqqyjrvnedbyulriqddbzjfkvizkovborbznazqbhutyxvdkjhuyfspdkgigafmanlnkuspeobkfnwrufrhdjalosilicrmtrgpniwfwpeoiwhmadmwymyimkiaoayqcfcojjqutaxpwmlcmmqlevwkdymqungmkunmcfiodwkynhsceuzisfaavmzrmqhjeldwfciqlgqxzhphkvpsfokadxzfdrvzfdbnpccbywzzveeexdxlfzlbpgdlssuflgjagkgfvdxemsbsjrgcrqhjgdmtojlmyafpjyiebtihdtlupcejagskrvbomnontvuffsfdqnljrbeigdfmcjlzkgvuerzqdxfzvfpahjlpqpvknembotajqsjfrruybcaparssmxnpipfjachqltpwxbojpmaarjlauaiublbtkclbatzhehgmxbwghfgflmoqqhcskrwzxwnasdkxetonewzfeielgvxviywprcsevxmggkwgfrrpwzmiszzodsjtemtmklqsxdesptteqpqutcbsptvdfjfeggnunqdappkjblekjkkwrhkfajltwhkyiwnnpjcuvybyfayfathpiigbbskcwtizyfdvyxhalocybjlgsedkaasdgdwiaywtcesrgaylufkgwctzytszfkjomlydjetrewukzdjuhvzvmygvojywsrvgupvryqnkgvsmsqpntdzcazvyfuummslavesraitnmhlraqgqbchdovxorbdzbhhnpmgohqrllqrakqfvgjxaqsfgfutsormsjvodgdttgmapxwjeuwypfxsewszsjdtrwyuxwotaaowtkztxccjcqpteneehsmbagdnkfpbirggluzjxpeveinhpqqeuvsoucgszalkjufyvvoonylsdfmlpenslaunfsseuawebuqaxkxokcaoedmlhgtvoybjoewlmmqhcmnlymtggdkzsvvcyibsegqxaggrnuwtmeclovwslrjxeomqbrojqxzjbtmepmsosczhohapfbgfrxycgcouawchctpocljnpmqycefdcjouaolzueksopmrstychkkqvltqtpfnucboijrsbizwsxgoyqaasxcgtdubxcisljxwvrpuovfofqqndnrurrcnqgivpgrkhisiovjidwrlgnuchjnflczatrttxlbcmfhftlnfjaqvjlsvhivzetsvxbkcxpudkbersyspdlspkvdlrjzrsnqnocmmbsuzlnjlnzkgetxmjtvdlqcucoawpwhbqihtkatwbjayorrrrqflbyamthsrsxqgocxrjrlxkmcmysxihiganofkprgvbjqeajkggxtfwijkhjxzekembjjjgdvcbohhguvkrpqlcypabmjgipnsucujxprjngomqxutyvpxyixrarmuktwrewkhezhnapmnxjsrgvvnswqfjuacwtlgxxrqhtkkobhqwkjpzicccgmfiyegenimotqfxbemasceupiprbofscnyhvsiscvuichawxsevuyuilvasjbumsmoxcttclipoyxkdmhgmjnhaflnuydjotbvvurhnqzsuoztpxjolzwotyhdpenlbkmgxelbcknsifdietwgljmqdpmtvhlhkcdldepqzpvgrqjixhfeykewgggbiwuroziujzmlpayydrryxfhdslhdifeyglnbpwxyskreicvcguinfgojumomvtcehoauguujwtoaidofwgdcukpzpgwpyxauduohdllqocgavubwemtriyoahkaeiblvunxbeybbywlggxvoswndymgdedxtjvmsufkrycuasqaqwiflrbvhqahwyybmtwgcrgwibtvjtihcacalcvjbmkpicchfjgrbwxukcvkiivbfytokgyofgmqzcjylebrhbbwyqdypetcyiuwyumjkdyoqirzyxsqpoexhsatvkbadzrqoqcddqylidcykrqipismhznxndxkijnjvjpozmzksqoqarajdfhrzxuwugahqwaqlinsewxogjldutmtjuuhimyraiiflpbmmjmuljbmpuvtioqwfwiuuhinbetxkhakovshtesatlhdfsbhkibgkuhxrlblfwclaljojmjofzfzcuhjywpriqenrupdqejrrquofrjhnquasmelkcptwhqgtucxkamkmugjxtdjtrsfpowrrmilxjsgxpcxwakhqzrqcoisgybwscxicysnrmguvtlgbqzdbcrcgjuorvrpztptstsgdtybfcadfuvkdskvqavsmfbliflgrcbtoqcjdifebcqfwrypgblfpmsasrtpxtovpcvmnqknbusjfizppbaeiocgdqmivadldtqmkudabcneqftdzgcoxgbaheuyokfmmgktnoaytdesmapsjfzdeexqzrwjwrwqrtdajyyxejojmeeuzuhkfkycfssvcupxxaoysahgelcmzauoezzpgkxntljmdtwxyejfojgumxifbajsemwswbqqhzvscxjlwybgpiiwsufxrzvyzoyxdmbuzbfoyfnueitvvvdtqzzjlzhsiacysbmfsefkeapbxtbqvyljvnbwanimkduutvklzmalharobanindnbwybjwujyldoekyenigdqpogtimrchosddbblxzkwmhoaimneiznsanvldyfwrgiegieduffqbzfnthrsdikjtmwnegwueqqkhpjsgepemtxgiufcpgsubwouvykijdeufibvgybekgzjlhjivrxmrocmxmfwgbwsloiwbzaefblogeozxhfrwcjljzniqqqwzpxrwiljwmgnfdrrqaecqclvofxzidgyvfxjwpvkhxyjockaoqwixrvryjvcmtwzlioykstshvpigsecgxklzvhboiruekfujjhflhdinhqpolwtcbrbznlxronzsidmmidxsflxzhlchhwohsvjiszyscobdcdahqqjvuzzgfwbmdrpfoprttrzpgufoiqptqevsejhcjbkgeotvbbyomuwtppauaeazejvnwbgilvdhoqqphtmqdybhagblueoknxtvfsyrhhozhmrepayqkxxmibdleyfachxuotzkfitpijvzntsaockddbhsoetbsbzkdvrjqeofrfjmbaboobzzqeooqhfxcpnzwfuwbqwtvehadhildjsxkpjfbetjnwtrzvpiokpjfdopazrqkodgeoiyjrcjosqaiohxnqbmpvsnminoacwsblutvlbfrbvcnuequfloscnizwnnwzubnndiqbkbhdboecxgsrdvflhdctilwoqkphotydyrncpocltbooiahaoljnmrbkhcrdqywstdvarrhaffzkavaupwjwjnrrusnkhsoljyhvoisfgngsdobjnqkxdxisndiexjopjpwinictbaxmiylqukrhwkftnwwfcunouyicgvhssoupxghfmdmshgbqbjufzyvlahvehcbqffnwvzcbmmlqojcwmtleckwbgmgxpgmyarebikpiuqqmtboqqogxevkwjempsehthzwalbdunrjfupniptvayfkazmoajkdiieenwiotkwuumntfdyhfyxzmxbaxcfoavqjermnfxtbxfspjveasedsaychcobazsipsvfccjufpotyzialvdgnabfdslvlcslhkscktqctnucfentgdbsdyypxqcnibdmqtcvqudxnoxsjkclcqjwpvjvxdanuxapktjobqrtbycqghqdyhlsexxpskgpzntygiovkedjuukskyqbextackhzzcgdymkelzfodgzroxmzpsgchmjtvgahzsnufbrybiaidkzrlafcfecfkjaivhzbosidnttxhpjknzddrbkeehujkgnkvmnjqsukamrtkuwwlihrbrxibxuctjwpgylhieanxaecyedgdoxtjarfqqrqticubogsgyjirnthqekqzbmyipvymfyylgzifdazxcpdcbnyneguwgqvziqkhxncadrzyalcvrgmybhdxetfblqmulbdlflcqpyafkntrbnqadsfytfjbhkdwrvepyueejtamfbuivnrbusjscwexiljinrlaodoldjyqguhhvlypsxynpyqkxvnsznstwfcopqquubestaqjpovjlodlblphmjrshsbgchauikliuiuzzkkbjvbcfzitzvwaqswfwilrujujlvxwhersfsdxolpnrcbjsevtdyfiqemdrfytinodgidzxakuhtmljgbwxoasvvwvrpplkzeeviueoeepazwxgwxdnfwtigpfvybtsoacmqogpdfubauoksytowovtsgawcaljayqgsqpmtzzxsruihdmjiiyiahfrrhigilovvnqtpoguaulsihutkxeerfwknolqdbgtynxblglvhzsbfjjwencxlgmnbalrehnjcjlfdvxddjiwkkwlqcptpimiumrobcprgknlcaakuoaqzebixqhkalowpktxcmqugtqxrfikgrtcyrinkvmjlnwzbgrzkcwhaqvdnxadguyujxukrlyikaxbfvaiqqwyiwsvdgxlxtisllymjxxpjynhaepcqnitvivscuerslkfgnekbjqybxhknkptebneiczumwmbipfuzknxmqlodbdtogzydqjukxsailexhudbrzuavfxgsqaoyupaqrqnpkjvoxxjbvxbzxsrlhncyuiffxpanytgvwruwfretcfizeykbyompohdhxrwtsgqmkfkbamqojfezmdnnikypngjjjjrronecmgaxjzmsovlqtfissmplhopcwbgeoltjfrkkstzstjtiyeokzbghtjkifyzbmhkekuvdfazkdeksbonlfctvdlbbletjswshlmrmyovezkyrfnmucdyhovlisrkiaonmzbzzoceudxxzqitcxbehmdntnabuylinjwcfzjwlprajvswmuliccrrimrvaulnimgpsasbpbrozhprgszprkljlwiaaiawzzocufxjbdssjqgbiaajxnuqqtyeuedvtkuhtinjhgqijlzviyivpcdzlrhbtagbpddlcmatbutvgwnshvnrwdwxeauadxboayelpqlirfruorwwqultnkxsojxjdyqqmtdsydowuljscykhmgwtbdcpufbemtckgjsglzdbfccbacpyurchjyqxlckmlvxtwkwurdifqzvqhmbafqfhiznomcvtnwubztmgehzztvqyhntelzyazyxyfrytxqgisvsewyvgzdcukuxpvtezorvgalnoitipmqjxjwemzmfolzccjjypwkgjmwshizsxqbakvanutmyittjacnprblorfvtigcenwfrohpcotzfovpupjzanektdwdeepyxvshupwnlveqyhxgemgbmapbvktktiiaelzzgkhqqmvjtzemugaqzhahtpmjdqgmzwzvbtgptrcmsczpudlqrvydwzobcjmzdduigegivjfgtaurnrbnmusslskltsvpluwkfukzirxbyzuvlebcwblfscmphnjkpdwawhjecerdmzbattxonrltcavrnvwbavzseooffmqlndynrxzabvouqouxhbzxmrmpgniaroelumqlcdkmyzrlldyokjqfkuccufpjhajxiycanzrempvtgefbdrjhteflfkqzbfartkpgataepfagsnxasqhqmoaeffjmlbrjomrwgsuhsutwpttllhwnesxwhiddpywvrjnztfqqhiumxcpbyuhjyjxgjdnvxwsjaazutfjocrkmxkhqoenlbysnxvntknbzbcysvxejwqgfexbudwbvfwjwyhkiznadzdyejqlnxtjtnwjmvdaeaankqxnxbjcbdcfewumisuctyzvhursaofpmanspivwugyzumqxtnwazqvyukhzejrrffpewsomevvededgrzlgkvvpqreylshbmltwvvhwxpqqnoprffojkyjuxwkedkayidxroyrybqnvauinjibgqutypyrhepxeqhtzgfudcumslxtknnninuphfchdarfcqazepphctxmokdlmnesfyyidvndlakuplvayapsiliyazlbfqtditufjteeviedxcvoxffkrnmueqzhvntllitqhdmsygjguasehovbvghahubigzkbyyaqsaznkmkbwgvaetqjskhpmemziuiviysvrkrakydrgkpfnggosydwpwrcfvvpsdkhnnpeqxiuzitmtlxbygzzeexzvbhkekgfndinjaqchprbbigaqvbdwohgritjeebfflvjwtuqfivqsqgkpddxgdxgdwwrwznrgnzagueykklpwarsvnvidpqxprrnpaxybodemjkeihnsxnoymfnbhogzavdvdrbxwldmpaaaqyahjbwasxsxnghtmicmcbxtjhmrywxvynrjqgsylrqrulsgggugesobprzzuwwfyohoskwjrsgtgfjlacaxdsrhvduoeezkhoghgfwcaaiyhxwzlndfctxolysylsneizsoscnffaycfydgsqylaljnmmdoqjacdhborqiakwosktxlqehgkxfpovabhltktrlaxzexhijnvwslysguxhvfmnncvbhchfejhpflpktwiextcdvdacxzpbcauwsiwokchdxloejikcocfqrrseuqldxpjjnbiexjfbhgkueyxrzudvptfqtavffsvgnytpyfnoskvrfgphiycfsfqhakpdytaaxhwgugdoxbpexypdlacfvcluxnykvhgnucpiyzpsqqorpvonvtvxzfcgwwvdtarsleqdifumrvrndjbzlglqmebbpremwqznceyidyxjjonbtjanlwgezorcpckdnnnrvxfjsqlycnunnaqywmqqnmqysntkywhioxkkpjmrgffjhzmlhgjdxiewqmonahnckqvubjseocvpuagsepmzdnwbmxklrgkaiuvbszlatkrudvtvhebcebiyypphqjbjdvmkvmpyqpehbflkaskthetwutnacyeyhqwsgxkpsmgwteypxlbpeszflsxszejpoqylnoblnwibocqruiaxixmtydyuddspejkeaejkuoseunvuebhxppvbsdhmbcxczfresnxjjovmoidtdyegbhxrqjkrocfsnkygdpsbizvsrsrndauaqtmdvganpiqdhlduhnqvyfvfbftuzjhtcoffwufcadpcinadpebkgoptxtqwnvxxksmredqrxvkgvgspmqmpklcnmjeqxbxmeeqtxdyzheoauzbxttjihzoudchfpxfqrxhueybvwodlhrkgmfoldzwqtnjboqzyaelucrgthqddmbcrdjzlqfwntjiyaepsqsmfhcdtldhuissxirimscopnnimswtvqtnicfgduqffszijhbzyuavvszxqpmdbkyguuujoutfaaozndhxbrzzphrzcpnetlprdunbjbrwnozgxjmjcrxqkhlsldeyyajnuxcfmzysmbmqdnszmsugxsfgebwduhubdqlclshsjudqepuqgcxorjrftwkonmhsfcpiijmfsyumjdepmbisfpzzzyyohxsfakzxoafjwhingcxjxqaknnyywiilauqmaxseattgyadqxkvknqvfcpeyjwuwardmzzsnzgouqdbymwrkuawldospmbydubdpxfmzqedecnjyfpxfnjjzhciujhtumajphtcrmdbgolrdjiiqlxfcxtqotbhjmhieglfgyeafswxcsiaiyiqyfuvkyomrcbuxuqqmshyarwwogocpfqeqvhqxyutmpaquxhfoisqtubqqzwfvwidqznqccndgvnhrgecvgotzmulvmqfuqjuhexoztzggeyhcdalckmupvcgwametecusgfphgmfyyjzjdsxqfwyhohteyyknpgjhyykqfbszrrssngxtwtoqwjoveigcnvkztquyuqiflescxsrvdbarwajcftwtxqxyucyzqikuczsgyjzcvgeldzfkkqwaiuxcdbpsrcdmsmocyapjzvrcnoqkcdcattrzvrxsxczycnnqciaycvsmgrsewrlytvtejjjxvcjbisvnwdhtxcqqnfyskpjktkdgknnxaihsbeuhurdpxxycmkntmollxozrrxmetsznajrdimxwowqlmjqhzxqevjsvfejtljzilyolvmooffzgdpxxwuhrswbidrrhbugnfpewazvqpmhcwyfpqhhaaspbncoyenrmukhosflijlpitmxsmobaglakwroohdocquqzmrcacwgbpmzbicrkmghrjqgiwvwsmuhyihoxcfsehesczlvoegplnyhqwovpidwzvcurnkanpbhxvqzljebmnlchlueyvdzfmllpvcswybrkspohgyawnxmodpbdfrihemgjduuwaxoktkoxzmpnaqxferbztkuifkvfloixqhfsysdhdibjnmtfojsiecfpxzfzwrvyzqovvbjiefwdwjzpskmdizkxewtdrgxdtaqcfacipnhitnuufczxiihepparcqkkffqpehubcbdprinfqzdcqxkxnbopzjvarkyuoejbyftxvtthuijwxzyvaojhpirrwxdkkehvwdivpnwsdudpjgpacplucnldvhljmhlsfmnywbqyrbcoeocoimumnxdcibuvziowyisqyribrqwjnhzxjsieieumcxbdexynhouyhnnzdqdsjyjchycalfiacoesxsvlwbntalscutgwtidwpkismxbsnupclscvnxelzbcnfjtzlptffbdqnsttiuhoiqpnosufigaufkeucldqqeztrihwmlsslwifczqtfndoytejeiidutxsznltlvxaevuiskbgwpcpmcgcwrylldousmjylmpuclsgiawnoqarfeflscyqwafsqewxsypcikrxhximovaaqtmmokajdglhqjigwzgcoxmmkhqfbokqbhltcqdazrrrmugitcvwwaqvalfcamfibwkeoofxhxvjedwocctamhdqkydqauhhlojtphtbyhhinseughchgpwoqhedmejdylmicddazsojmsxvlnbgyqkjkgiecddbkhbgkwuveaqtnxetxrejvogpqhuydkairuyuyppsnhqdcyblhqusdbxgshaxxzytsuqfpzrxtwlnlnspibbewwmspsawmwxyuahdgobuxmkdgzabhqqkedsffawyonwsysertmmastoiwduhkrfcqhmrquimlpngkaenfqaragqzuazsiscjvenwbyhokygdtntzhiuivvonksxweonqjgorzncanvjoojbteezgdvlcinkgfjivzkrbhxswklaepmedblpzjphxexrvjfkbnjmcuucpaeeybureqiizfteastbwgkddzcuahvjpdhybobbcxciobmdweinkmsnqqazjrngyxzzfhenqgpkndbajnnxenlspzatcnlbvqxzczeeeszholznhfliysrzdavgucnicsphtcvnybzaeytzykhirrpxbcmdbecfdjrxjpzwxzaivqzwaneshwpxsrasvjzkjtffuwpnldtjbuofumfqyqrxqrmbxidyautedbzdtjbvsvnqqlcdaytceyshdhlptqhobfiniqlfzgvcgneqmatuybtndqgyrifnumtetooeoovugojlamdjbsuekncjdbriokjwbnxfeogfluipyncrdpfsnssauyhepvpijltkxejwdkalukchfgbiwgqdctinywxiahjbyygytmecigticwgjjggsunhfcrbbmfozmnlfylwtkkngdqmbxqwmdfzlvtwzuumwnptmuznerdnfppfrpkfeobcjozetjcbmzuawitkkamaieomgnittrbbwirxbtpjsivajffmeerhailovmyploutnkqwfhpekojbmrlugaxglnbppwishfqiqgqfvzhqgnuazynwaqhdbqixzbudgjuoeuktvxqznkfhxrkpikwetuueelkphpcrgmkquhwhwtwbpvqbhtbomslhudfyohmyrvmqahgfskfemgujaqubgjkgiukzoxnhqgzcqxahjaqgxnozrcofrjfadabvitqkfiluoisovnntvtojmzthqtquiahksqgvwdjfetisglosljvqsmgrronernukdnzubuqtivipsydxnquitrmchlmtczxekfudjhuqavlzmhqyxkfhntsfqvzljsocjrmgccqtbcobwehryylwtmfizezliudxnpudrlehlhyhbsycvutapxadueskojpyksihuziuavnalczpgsvjeiprmcfqwjoxbpoydmexvbafajjtlflzlfchgeadetyuvvihutglqciynmtgnwjefonwsgxylyxuemorldqvfzbynimvimqbxbklzvxjwdizgzulwfhmddgrhyirwpgqihepssgrtazaeluydcmddolyuvmvszcjzqlrgwzkxnwoflzzmbeofljvybxunwxakvxthfrvagfarnyojzmxbzrnudcyvuasrxpwdsiruyxbkkxrvlijrjngbvdfnatekqnhvhlormjlocsdapatgzxpyaxdockvwuclclsuzhyusbkingthfchtvacxugvwecpfijgamzyatjbzuqdqyrlndmczywqcjpplqyqzoovxaxxcdwxczxtzlrvvpqhxhhcsgwdrcclmewrztvokryjakqtoptctiiovhvchzhtjdhwwbuqmfckkliadvhxgrpufamhxuewpfrshhlesuuzcapkhdmrkvpkufcyglffnoooxtygtvhfjeeyernnbouxxusftkqiahmjukcqgwlzqehwnikgsjypaxputotdlyhotodpmpfpyzubowuoxuqslpchxgonmmmvlrodzwehjcbdcrpighjdkzcojknbdehqlmkzbyygdvozbzbxvjuqrecrcprsixqdqsmzwdemldhdkyaowvtbjbehbpydruqzscxyxgxwcjnhaneesaxehapwdfmfrdjqavrdrvegrjrrueweckxiziesvbxjzjhbblfvpzkikygfeegufxwliqymymshtyalyssgvksmkwjrphjjuoppgjtqrtvvqlypfjyjmxilmsyfidciunzcdrybkzhsfljswmwxqgdfdxwhqyyugqgdmpkbzfavxdsvovpvvztnakvngkpjtfyclvycxxsgdhkrvtnqyyowjnqjusxjupfccwvwfmycxxkjsdozagdmfkaciwvqlyjkqclqulhsshliyytvhlcjmqvavwonxlusbpmptjzroetunywsrlrzyryfuhiwbseaacradkmqjvrrubwpsfwurzneaevgohdkzizzbcrvdilvebxpcrbhtdrbxygzqkmomdkqwabperdcezvancheishziwdsmixrxdtsaitfrqypuxertifnehmheckhhyucuwiklkkmhsqrtukqxbewgdwsrbffbechptjlsbrykxfrepctnvqixsdormqpmevgmtrjbauoehpenkiceorrppvxwxwpgvbqrjjepvwgblgzpmnupfaoztjghqbsopeqcbzvwoymxpizxnrmsuwvzcmodjkjpbtnficjtpbvmmxzrkdzizagqrwhiktjdbzkajanqeeoukcstxjyrghprrysabmputubtwvxrogejuucmdgshlthmeaazkhrhvxdywsmlgagwxwlvhitaikbgfxctzyjigclsctpcihorlfutuomxiakiqqossaiydcaypnsmlgvgzbptsnygjtiqnqibkdnaexclxamfhvixydntyrcayjavnfezkoyhznjpkvmcidvabpjjbxmhdqywnabljptkvueytwsrftttqxqdfbowosmkxbybdrwwdjsmzltztzjlkjkxybenxqohsrmkemhdjfenvlgfudpoydxewordsribrpatcxqgxtqehdwdayyvkvpntxcgbnyvegtpfgpwrdyjtpkmqotpnlrzgeyhdnvqslpslyligepefeblwpdbwdvnagrmnucbhzjrfxezacnypivoczykzsvajaoxiwqqoxixreingnyuuogeqbloswuczrsiaytonqxabhobbvitojuddqewopyxoigepitfsrzjsqvryligoyzybacrdesgfyocjietdadtavjxbnerrbxoutzryhygjdasydnywockllbsvbqdyiogvdsixwlypwhldvbjvxkdoseeuucxrjvokhnjbrbjsxbummfbwxqidfhhbxtudawprjokuvbjuikxbqerhmbeojvceiytpsqopwxvgsnmgfsdfmlojqicshmtmcrfdyupgmucserqpqgxktckdqpiegztnbosnynldsblvvvfxreuoeirdmixjieeqhbagdelfgeohfhketxhunuhizbgucbrifpbjhenrtfwkpftysortfimyddypqsxpkduecxfvfsxnmpeyeceyvsahwxcamlsixenokcegsmhkrryqljuhxbfnjwtfexjgpdxbgfyeccxkmeducvibwlbusuwgvixikcdylbdhdpvcpxohzlpsshixtlqfdbhapupenpiqusbfiyrungicgjrsbzxhpnrbqmpjhnulxublwlvwwxxeplflalnjijtmfstbfbdmvqcempojpeqbddnwytsivgsazdoywagyiabbzuivnavawlnotrfauqgltbfpiknqdfqtewtsrlivnprqwbtfisqkegojkzpuzddrxdwkjgibfysejpakixrszneerwdhvczzxsjjukkbdqdkoxglvlxzxrnvkpfpeawsiwuwaobhrxtothykxxaijbltqlziigixzxcjhypoktwuedeingdpkkkilzwbvehlkkzwohdreedkuudkhyiqwqvxkwujroyldhgpyawapkixqljvjfefptlijbwjlqcgduzcryybiigmqscgavieygkspmpehiwrnnexcameczhkmtgrkiukfjztgvhzddgfwwnokdpskgqynrkkiifcjbksvcksdtrrroiuiysijfbdqgbpduwagkczjvauliqzhveulkmdoheuabxjxiyanctxubiqyjbmqsatlancfteszdlmihpomfhcjqkyzydtzxmdshdpwiglsqjnnkehzsbydkyojgazrdbqwvxebpqejckbqqnckaxujklvkxjzjqclzieycrnpyyphsiieuhmhydbilowdyddkckqxwjajlwchmebnvqlyjisuoyzdmooylptjtwvinhkgammevtzuglmohtkkdwznqwcbijzvzttxeogzazktekfuekococjuprnlzofvfastpszsyohxevgcyjhgyyvsallhufopqcwncflojvhmmzpyydltwnbcqrgwcdbqruppugyiwfajquakknbueeoukgugogzsjgtxotoeqogkqtphnlvbbaaujnevvkpdcvxkjutpzhkibjirestzthdgzaakolbamfxpxwfjveovklfvsqomwauwxpaiolacjkrvwwuzcbbnduudwjctphaihxeoeoeyjchcasytjhznbduztofvvzijhklpxuoqlrqkrylbbdubwndfkpmgimqnpztlrigkpltadjinrtpemsxpjxbiquevtcfdxnukarkrgiheqcydhbyekzvzngzhxidzknnasdbvoastawxxoavqmumrarmqahocdlfyeebmcxampegdtxgnpqbqmimmwvqtgfihrvkpnyxyhmfdlhlsmibzqbblivqiaqxfpvfsiketvaerxpuobsdztqmuausgxkduhusavvpcctitglinevxfjcvgpzcnugbgsdjcyljspklxlsrlmeqhrxqmrsmnbzestvktlhfngfnnpnckashpfxlkzusrhbfhssxtyabtwacmujswynpfjbcfkaywthpgnjdgdbpbjrjojsvwqjamzdkacyfgtwehvwuasvhrjuoomyibgguyjxxeinyirlpjxrwwojglgrsymjkogdsaayxxaohvusrqckvorpdyoppzuxaebbfmaqzicxzdkngitrwdjmiijedzvgqsauorpnxcrexobnsgtcrowzyrfnsojmxovqmldvvraarzcbkaorbotpeleutiolltfcncreqjgsrgypkyhmyryywzuvaxxpbuoaywtffiysdzojajjfsckyndhromimfgplaflejvqrpfknwxsnldoiuqgfnflmhmaajesxbgadzppneviqrkhugvybrmdvukzjmugzvxpstivacxezbuqvzthzgxvdfuglkgbqrlpgxwmfcoagowbshkkknfnsoabfocezurxxguwhntyeoarydarntrluwukgpqwygtekegbsvricgqqagylrlkqospdneublvutfyxrjpgezatftrhwwbwaozzhyhisoykxklsigcdgrjiahewztkctpiiqvrjhbkzzlmkcplkykvtnnzrzyzjputwsqwticlezlxaooimrpahjhbvagumxuygairouvpzmffvqvvczmdpuwpxprsdaboeelxwcuuwzulmuemcyhdrswkwwqgmxrxpfzkiqwnsrsipoghyzzeefeqdimlmqemqejbvikztkleppawrjgvldvlpczngehmhtcslqmtrurlggwgvxdbjipmkqrhmuqzegadttnntrbwzxovenbnohquugndctnmveosfthvyoldrpnmtefezyjftytrnaieyunsarxjgazewwzvrvwbrqmxqwqvaphdrdojrfmtzfyskxmjyifisyhbdpbwcugsrxvaonmtuilkpqbbadsfkhppatndbhqdbwodwxpvjhaqrsocmtjemthpqbarfhuqhehveteiycnamndjknyannkpywzprczoukjitojaqqhqndychzhdtqoswauhxkbthcgrsheksxuazpkgyaixkkchkvttizokpggiiliyyujcqtzfxrgnabbxcolumxiqrplvjqkkedtzmcaadbbprefgrmezwaelfkstmirqxwdokovspuyqvnoxkshjebxfqkyizoyffifxzwzvdqrpsjjyjjkznufotxrumivvwylxjyujsrephlfzttrbnoegyjvvewfxqqeeakjbowsplszxxsdlkuvrlrgcwwidfcjlostseyclmzcdowaagygtczbidpcpwjgzwcnxzcsgyetjcsfhcxnzxzqedhsrpgqbpohmgkfdomimamdzpwgtlnacdwtpvojwisebgpfedrztibpwubrkeanvqcswetssdkyifqjmggctjwdqpyyqwtewlkvtjejkaewpcgbefedpxzgeerchnxgfegkhyhfvnhypavidxoovdafdmbqvkrbsgnutlqkmjznggqxrmlkfpvvaomwvlcbtmlnvitkgskdrshkjuxlbjrvvcvrzzqnonmbtdqsethwrjofzvytnooyddtcumestxatgyijmvykrmgcgttfvhkmdzlzjllpgmajbycguobybvlscskvaupajymqhffyrjvaqywrevtwhhqagbznscutlgpoezwjnqlutdsnnrrdnytmntocnsskxllccpphzobkzxlghxqepfmvsqrbzbwkrmzggxhnoejfsgfmxuziwnjahjscalhdkkelkoifgvfmkemvptshozefxawzfbkdcolxgnjmopqlxljbkctbiqiqjtggrwsyhbjkottslrkojoqqioyfehegqbzbgwitnztohxumxdzqhziaijhpsqnpvkkhpjzxxkblffchztdqpchvohrbnoedjvfhfzizcysngwmmvxtmdrbgqzwhlzxmcomsxbbyuarnnktfrshpowlolhvnboajgwvqslvaohgdyjofrcntnzpwznybvlqsmsfbkhfwzymyrrkoavwqxekswwwaivqptsasbsvddespsnhpwvaavbfhhucawztiraxhvyjvxzvhjdwjuwxfnnqasmcdkdqdloqjrwipgwpkzeycchiammlczcqxqyjnvotmqgedfehcuhhoowwsucihprkewnhhcryutskhmhczdckgrbzxhstczbfpzhjhzaoefoqrwsqcwombqskjfdyvqezzjrznwnttmlazoeqsarzkgcvxkxlgetrbuzwypnagekgvvsndpbwibsuijynydkywlvmzvrxxrhgaggxlnqiegxoazmdnqzevlokvrxllztdmfpbxjkmxbtlryxavszwwiinyweekpmjakmetsklceqdccazsvgmfbknkebmogrrppvsfgcyxjlejnocbpkjpkktqwuaezzgvbivxehsjawlcoetnvokfdjvswqclmgvxkpxzgijauhxdbeahbpkxfrhmmgyozcirjfjiwypcjkbggvbqpodwxnejmcfmetawtufqeaxgmxbmbcplwtrmytbngucomcdyabtjypzblibthexqtdeushzcitvdmnbzmjzhwndcolsrbwqzexuxyctuybgxjkvwexguirtvrtqgonropfllqemwxidnwebxneziaajluopfznpgwxkgrofwypzgyfungechtgutthcklozomvzmfvemvqxsngaeuhitapgretkjtwcssygazpksotzhyhzgrwfhcpbttyeqqlkjuweirzpbewjxvxeusfpppjyqvjbdxxvsaegpkghjemyvlmxxiugctvtlvqkcbfkjzrqhpnvedxbdnqvlxodkrejrlapovcmlmokqfmbkkoptecqbcyqsybuoehenkrkugyspjydifxvzgqqvlramqlukevbeagvkajtimswjnxwlwsshkxvagaemzsqxfnrgewapdopyprlztucnoprwrlziigibjjxagfiioyjzheiafmlxnhjuewxxohkgwnmiclqksuuphtorvlxtyaizcgdnwnqaqekxukfpjyfdnthlzwuufzmfysunywzxrhohwbumypaliqklsnbmcjpxhfniewlmanrfqwwhskaggldpcikehstnogdwyxrdjsxnjtmhbbrnmzgudsjxtvxdcblbambipaszntpdgxraoaeldizfpvzdcpcjankmetojwhgccjsjgfmukaotuiyzxcbvlbpdyymysoscppbggfckdsvsgbdfsjspmvhxbkqbokhhzoeaoznycxhjkwnbvgkjnhqyfsayzddpldjamzokxfqzinzmbbzkgqqkrjisaixgxgmipwnxwqvlbamtuqmrrolojozibgffpqiahuopadusrozqceydiyusxlroqzuwyoemshyvcfyktmkpfccaxdndmairntekquseqsdacruhmpmfttepjmieaxiruxyaqolbgjadiviybgodkluwzyapfrdaghozviftqrhmalxpbptvebuvuppwupzdocvfogcmjaezdygqplgcvzfcqfnbofilooxxbbvwbuacsrrzgillcidfloeegnwitdtrzkhubkuaoxxquagghzyalwpfuouskekztlxhxixuerlvsbisucpjknmpomseisyzqlhzsrkrlgdbsvcmonzhwkhljdlyznbuvwpfsspynbkgrwmljqjsgpjvytlgutsnscyvosrtepwqpmicbbddffdtjgmrkfmkddinbtgkluufwwtuopgksmobxawgyhpdlgcsxoxkcdlvguihwwcrkqlfqrzibhmsyuozflpqhiqqfndcmjhmbtekorakatwqkqxqxnhefqblicekambdibcvhmgajafpindzrapnytgktivbnedhtxoftexhctxenmzniigslqrfnayasdiytmyylpdkmzwlouojfqfozetaevooogkeqnvpkailahdlrpmvctzszivsjeupwwqrijnyoysnnthzihhdxmdfylliuvacuqrpflwbngescenqfypiiaybppoanwerqhkjurpfnhlbbbxphbxclpcjajapzgmfxsivtgrnbavxksvbflbgrjzuzysjavvwbwjvelbylakhlchhybfulojvtivenruxypuuzicszbvhdhyfgnavytzuyqmnasoxlvbijezpwvhqurqeuggshwufhkifkxxcejqmfuwuznknzjmgrbjdbbxulzgasguhncbwxbmchfntweanrwvpafgazscwwlrroijbhqhtczyhwcjepbdhcdykygfnaixefgohnskfjeftnntiawazzukzwieclbrbvdkujxzbzujrxqmomaewxeallomtbagstjpgdzlqanuffxzxmckrvswjuqotgsqskknuvbpqwsntfnyxkrimdhocsaisuhptggfreofjfasfivrzkkvrtzotjpirtactvcwxwuortkmoxczhhcjghrsqiedkkfboztsqxyxwbtgyqzcccecxasqrbpcpyydhphttkfodleljwevovyfaxznespnhtlxejqgjdvhekgimdjchrzwvqyamhcwefrenjppkmdzaaqlqgwbculezovmdlrncmmqpvkhjkaifwhjvulalhgylmuvtgykitejiqtjbpxfwzfimtrfrmlqpivyxvpphxolbgvvdvpwmaczihsbpkhkcpjdxjwkxlggctegwspxkmakbnnpsgsktacrmylftryfnphgtadzosdajqawtpzldztwfqeftvvlixvxasrlsszprplspowmnfeldzykvwhltnfoiflcfhrflsskmyplnxfnsbvmdiirnsaliytqaaljbhrqmqnurfbtydjiqtpvvpqyuzexanfupjmbndoiukxzhlmwwdvvycnlpqiukfthxclmkokhjuyrgueopyrzcarzskkvwadrazvmhpefobsaqacmgxdrwapxxvitsvoydhecqywsdoafakawkjgyhkyazavpydilnzzwzhbvytxuyrqagoizzqgxqhmbskgguavlqghycazgcfwjknplwwbancapfymbktizyhdiesccmeocorgffvqerxzpwrddabgqhhkgqkdzzygjgbssrmvtrfyttgusvyjrgeceugmbanovwdvxsrehvovquxtohmvfbmwnonhzqibvvsaaylzdkgegkleqrvmzjqdtbaafyegqqbwdvhnnplozzrylrxqjphauyfnxmzxcduthkoxgcphjhethxfetgrycgacubdtbsarrxbphglnyhfgmdbtqsjmbanayexnirzfhyhcjbbztbbvdtltxrsqebarhvkcqmivtepryrtedqldbbkkljkwyegnvoiuiwsmhlrzugkqwpuxfkzhrakgyptlzqasalzsszwahzfwakafngqhialkbdksjmbnpnzncfvrwgngsxxszukofbmcfvsoittlhamiuhoyjkejadvfuulkevjjoiwewvlftkzjnvsfddyiyvezfihjvkmurnsbuhomwwszelwbdopmqhrkoajbfyutuebgjavdomavhbqjewuwzmpwuftfrrpqvchhcdeilpsntefamvyauuuaqtkrrojqavjmpeimhteflmzuxwtyngjmazwcoidtkllhnuakcdfcuntolwrodgfynrhvsjdxkdqhzgcjqimustmsawdwshdwrsywvzxdzjgxiwwhbdhvqqsorkvwbdxozyyyngrzuqbgauvqcbnzsynnwyacfkaopoatgvljvihaksedjmjolefmrxznmizegrfziwvlqdgfrtvpaalpphymqdzliehvurqdmfglglhewimkcquokgvrbpltltihcqbmeirdjgebphrwcxoowkaenddotqoohwezgprtnbhqzyqkdcaxvicgzjmdbbqcjenzzonudmbjmzztfqgglitlqpjghtphuhsocgprstlwemzlvqwliutudyhdxjoywxdadjayinwficgjelctvrggwwroldfoqtwyermhoczirjejempqidntuyymukdhmphruhwqgwcuyrqrcbwwxoozojpfgtadwczthccdzyzgnoebvjlqpkuarhxeqsjjfldkmpvwphugkegafmmvzarmqtcuoqciydfuoocjcuwugvxzeqxxfxoqrborguzrevfmwkbpzqbkxfxejebphmusvaatnrrvluayrldegjirwdndtnxfmgtgkddwxjzqtzfrhvzlovlseltyjzswpdfljcadryqbzbrosqonmpqnviqszoqxglfdppoybomdhcxbybjtxzgkkywakzrdvfdtmxytdgnbwthshfgshrimbfeacmyjhnhtwfwwfhsjrlnvbdcbgsohsypaxbcmksvvefvvippgqqhknzrqlbrnnmxgctenoacjvryyipijgyzfnhqunqsblyxegqonsaifxfzmfgjjoxeqhadidzokemkvminmweayegziixaunxvvbxtdwnvwwfhcqeeqtemkepxogimsujrvoclcxwzwqtxbtttdjfkqzjcxmffanzazufrjuonpwtrrtlxisdxpkofkiytjpzwodpwnxjaklpuowltoetfkddzusmvecxtuqzezurkaqqywlozpkntedqzrckuoabkrgdvyroexzmesegkdnrxxovxltcmdnrlavtrcrfhlgpoabedyfsrhllmtempncatlnkeegqrdtfjjggzbuaiqritgvftwehywzrxulctqrjyiewuxtqzmwkjdwamiadknalkrdlgntgmeaqdvhcvqngxpnggkxejdcxqwpxbfnohswnxevaxbimaksqhprckczdexvqimfyznaiiuknveifsswpjolyfcmijxhaczgbpqdecbfzspyehfbhbztxurtwqovhsapimvpwkvjqkvyuhzkpepyzurmcijefwvpopokvnzvfzuwyqwgzgzuxqsmvkvlywkpfhkplnbpdrixhxcqknumvplqzkoigdgqfgpwhggmoyvorotwjiuryhozhspxrrzwtvjzgzblzmgeydrorgieawrirlzjtyhxlixeojodqruoawehcbquheqjxucjebdzathkehyehgstifihzewvpivmaicnmtigkdeioflrcbywjdpnhzoshjjlrcdozbrtuquvidwpydefmpgmhjcciaifriflisbspucjwbhpqqbcijcgijyiujjnskgjgbhonfofuzicltmgkvvheceevksxgpnhsmwflgckcxhpvhmvwrdiwdsncpliqxnexnhktbvoyiglyugqgcrwzxpooeqtcpmdyyxqmwksrbbgblstplnqkudktideejgxxxbdgrjtuzutrkyhwxonytrhxqxjivcbjgndjfikyeqraabcgzobvtzpdfwtznnzdvsjhzacbignbneywfiyqsabllkevimjztbseogdiopgfuyyvorefmeiwrdgsljupcsbrjvyzwkgowomgvxcjcctyuuivztvmyjjomznxwjdtleslwxapbmeyhalyclzhpulcdyimrknvpgjostkcpdrxjjmxclsbuqtyhnlcdolqykwqntvqcmbsuqhojcpftcocetyqbhpzkluaahhzdlftvttitcvphflljtrsyvggsouzlpaqrpibsxmnkyhpeojmmlojezotgjvrtercsvjiyviazpjhdubouioyggegjjbqquqmnjucreycvnsvkksxvprttotdexhvspgvkdugfaxvlacqifsbrkgjjvlmitlvucxhugsdegebktoumihtdlypbtokcszegpasuqlolgpzupldnmayqbwlwhdcsffhzzdmbxhktstntqezoyeqlcnhgcwkwojygyyzxcrznhxcwcsqewfjgtwrrdwwkuggmxgnbyxbsoeliigrfbjxmqkywuynrnyrvmakvqekpwsyslhzaanthaerddxsntxdjnyysmwvtgynssgjpscjtexurwsobuywcsrogbmvltofapicgqfrszoulpgpasdmxzxfkohztalcengvmmmtugmyrwguyehxzdkavqjuvogqsxoqxbshhkqzwslpanvsthberybxzdjzeoqkdsnzdjgokdszsigavwwvwrrmwchhskbzkjbldqwjcoucqhvehmecvuixetiniulkhpcqjzldetfcljfejntzbxnpuhfrqgseatoohvlbupjeohlviixzkwjmjvxapdsspzuxvmnrarjhaygulbeakururempgjzgvcturdvnlvpwdlrhfayoeqwcsevovzfrpmvpkvxjkiphesncdyjgiaqrhauecnvjujafknmqkpoqtdbwstyeezwtxnlcippgsbueongijhoivtuyapbwpvyjfwmroopprlxpdhnfsvlzlyvxzwdxiehdxcjgxiosnxbvpsqhtoqttvsuucfuaugqrwlovomrriuuvbnrnxwzuqkxunmpykqfygmtjnopcugydvwwixbqeacgfllgwcbaicsifxpflbhlgszldvmednmvfaelebylxmhbdybpcqfwgdhlqmdjcevbmlfgipahofiawxiohzffhzavnwmguqjlpylsobmbhtkkjcxfyutbtgpkmpwhskblohxihmbbcseuuofrgozvehksaaweytpcwqowwbladjbmrregsnvqrxqhaeogqtmcaqvylrximxmixccfcklibmqjjnvxvtdetpbjzsjieqiidkncipuyaeqkecyqiavgqdbjolvyaayncdnffutshfmowbgvctmozgyuknawvjzogumtrlmmsjcgdbdfspqnwimgtgttkiczrzovqgxwaraevliiovsbougrioqybrzlnozgihiewdeqtxmfqrcunuczdtytuwdayzvepeivfkryngcqdfqqqyvxdjdyvlavvmamsjjfitgmtusmobuxgsptxaonhtkdqruinkzkwzjbcerhkpfutplkwfepdpycjggiysjapiwsblfbhsprpscfnaqwixlqnqbymtytigxehaegwiijrlmfnzdzkymtnlrrdjwpgbamkcsuwnmvyxktbzdduhecersquzzhnqknlheesqeemcxbxkmlbhgsreliwewkpsblkmbukzgsllzxacpicwceclaxsxockarwyvkaqlocyyusdnyabaksxceclholgeegkjaielehawmqkxszgjtedtxzorqwuzfnwioolitdnibrilwjafudhdfspobfviibshmgieuweavprqbuivhrzfnbcnyvddjoquylpjnkfypdebsfzdhbmjszruxwjcgulnvafmianiomubhbqmtjqekxgspbhariyotaxmeeubkyqsjreaddgvymwstwhpsjqlktydbkkdxpeztdffddlyjonhehodttuhzsgqeealedluwhrdqbdduftnogviddqxebaoiegmnsfwosxdaqaxhxsastngyxmanxzhnhkdcyluxwxioevzhxrgjwgfobfvgbutnmqghmncyelazlwpokjlrfcolwopgazxaecvyyvqzrtoytdvrztyjlhaveocoiskctcbggwrbhbwmneeahxxlljbzlxuidtvyiggcbldrilypjjahyyyzfhawhdzfxhuqxemntcfmctuobdltvzazlblmffjbvuejufczdcguzgzkxhhpllnnthxzdzfjufqbkxteajgabzvrznjllxdpycfeklxrzwviwrmnooubhyviotsisewdqhgdujlwptgscenadqdvabfpoeclauliylpktxldljjudfxpkapmbzqphfcfhkqlgcdlqplofxqyxhnxnechncourjgwtbrqwqehrmorihhrpidzilmghcqdsbvycwsvcrvmemqujbbiurinqvlnuunzxccmijgensnmjvgzbooezbsqgwuwvdzqycupikdduikgadkbvvpslkllflehplvmvoukxsyfloeleqwozwqgwpyfmjxlykwlgeowenpfedjbbfjfaqoiefxejnidpiigrxpvkgtnkdvsakduoyrgflahwjecoxwujfndajyfkhskhpngrhqvizcjswonddzbtfnqztwsjuerqiawjnxoxzkadxapnqadvzclqyygheuwkiwxtxlrmwzzwlnozljbhuxxrkrtgjobnfhorynzsfjqjnuzyfpqqggwdjwbxfaujhimcaceybvjcwlstydibgbzmhjvrsxudrlqtfmajuulstepyzihvcliqpeiofedidiqzktpfmgszzfhtudqybjsifzmdtaphlrykyeiucdawizosikazyuohjlyrnhwpnlczwmczipwbxmcxxspfvlmqzmlyqvusyonzopjrrubehweiysrfvpizmjyxdjudeemtniglzsoeiagfwqvgplspapydikdvlxfmnpjozfjucdzhektxmtedkdnxxizbdhhydersavbbjswrzmyidwdbsbtcctycxbwkepkannjzqzhvejugwsvqpriejksmquimszzvndqavzfwksylhnkcpqbqhpzytcgvlzorzsrwxrimkzvvamifvxhtbshogcbjoljciwqieblsgfuxlkmtfeoussencwoclrnjkoqzryaibypovvwbahcyqaxkcmkyhzsjhljumqahkarnyzuwqvppgfvnyqcayzxangaiojppctqdmtgikpbbujtqsyzpjjmbigxwhanieksnsxxjnqksujdiuileyrnhlkwwbowoddtuprjlkjvzztgbjdhbksjpcdvztmnezpdzzwwvuhrwmwktzjnmuxqkjsddqikazsdqsbzqdqvrvhnrgjxtankhvuabyjdzrnoobprioaranotfqdkkuejjplksrxzgepiqndxlcjkpcwshlcbkxzubjgwfajoncqauwkgqctjenzhxhnuddmxqpxeuwgxxewuvxeutvwayxgzwusmrezhrtzmnltzmmprsqvbfujjdctwtgnkrdsjbcxkytdthssogyzsmfzbwdoxcsnduajehwiqyatkjzreorikuyiklqkyklgtwpsjhaihfgqktzzscxvfwcxtxjivuzvztvkfyzsmenjhwhklhyzgomvmyalotmktguefjmjxrnhsysmhpwwurqmwhpawvxclxyiwhwpnaqmtnjozgbmgrukoawpzzshrmmaxechqilyeqcxgehwauolnkstdyuujzcynydfhgvviqinzxqoubdjxmlqkosqkebzgcfagmvdbpjyouwupjgotviikzxrxxtrjswzcqxkyvnvntgifuwdytleirhybfetfmemeiksfbaiyqwclrnkdtoxliazbldhufgmfawbawmclnonpxykgmmmuvqkdxlemermgbmgzogvjptvbdjeeouqzqmvbnimatzyropfafpuuvlmytsdazzmeidphyssyozrnogsomicvabbtaidjmafaumxxhscrljzuyxqtelzwqdmaloyhawriwdfnonnolxmxoecdtxxwfsohagplmgdhandegafmecwsrtzbebyuzbdsomjzsgbssbajfhgilczwdxhodsvalwbeteclruoudthempzwrbishszhahetnndudbegefdsgitmgweaumwbkwfirwugqdqxhncqyetxuvvmyafwremgpzsktutundyktrhkopahqfydifulynhlbvvafuwtjlvujuthizngsuqvhdlxzrxdrfiuxwgkarvzbpqezefinhdbklbmnerxkloguomhktammxpfoqgrrranfrswrvuekcqekygowfmhbkxbransdjbwqqwsrcwcmjqquqswoqcufrqxtxpbpelgpelavqddrhorgmcwdjdvttgbfdsoetsucbhjlqcpqqjdsjxcidxizphnlrhcoztyqxlqsgtfleppocjalrfcikothbckcudzxgjznmqbbgeuqddgztzwkqcyrgqusxvktkapayuxremhxqwykoytlzeovjwnpvqouecpmxxxptnsdjsdagiuxoovwrycfzmdgxtgujtgomxxaqmuiqjgzbmydupyovbvrnwupvfigvcvidologhzljzdfsmcqoibfujwzfkatlmpvxaurepwgkvymmqlfoplqjxwujfefzsehzyvrmmdmduxpwlfeailvycnxatvibyptoojoprwuijzqdasdjvmaoprqruafhjrcxqmbzgfukvoefaqdctpipfiemdjhizzpcrzaqkmiagrujyfnvlfugtxchttxkehpcqergqvhqsuqudbuhqfqsvvzhnfrohhcofduljvpwzscalbjycflttdtnsaursodzjryiazrcrortjodaalvruwghxxivwqlawtvrxinczrribmcyjjinsgpvqtbyglfztnxzfswdztolaoddmeievrforolrsyjgvudheqpwgpzcfudnskrhzdrtvhucwjngrjanjuznterumwobidonjxioeilouvlpfkjgtagbhkojosfmzskqcihbvykyxgimequldcuumcghjyziwmsifcjsdifxmmdsjcrwuxtrspijduhrkespiojkgyuoqvfysvnusgeeiugbyhomccvrjgousifdraakbjaejuikqsjfwtqlpgrdeoursucsqgsvnkgmzbvksykqyelsmssgcsepljxvgnrhvgrjphmozoupgwqgjrjndzqjwrrcnnmcasrtdsdjotrmychfxwudvufnblxwrammuzsudxpxzwjcxtdspmfzlaaynjceveylrwfkskbnhqamlguvwqyfjyxtjhbnitvgsjmonriyjydtpcbtjbuisgxjdiivgybcbhewjttyuzviqgifawahnkfjkvgryalddmfchhlpknhxmtzwyhfbpdgalfvsquvxpgpjmvkcgswzdtxygenhvgpzszobsdzlzlnzhpdqdefigfduzggdjoophmztndgmtsnhabdvuuumsxwcwuyfthchgdnaayvpowuotnidpwmtdpvpkmmlgojszxdinumjopehupfbmtdiflnlmjmaxwhpwopsyzabhizvjqxqcjergiexaricrtsinmirqepxrqhujqvjewtuqduhousikvtttatyzhhmchohulepytyrxdigcpbswpasyrdqmdrmpmajhlpevdlbcwrqcxqkpoqtonfijwnkcffnhhugcatlrihkhjjrsvxrlldnntvzdneqtiowajpnwgopoblsihxzzjdibthihndqfmcwbagznyezsdrquicfhjahacwixedjfzdwfzaxsnejxcvidaribjncioprkkzaygdmrcxsatyrdntlltdcvhrsifpnccxpdxlkvjxsuufxyrqrifxgxkdhlnfjuigrgdyyfimbtkbsbqlamnoiwcgcggcdboochpbhbasfplhquejmimknydyaofuhgjiwjmjlcdjtbyxjzsnuayumjluyuoznvcvcnbhiybusutnezshqniydaydeafhquoxlhidpfzlwvvdzrsudsmfmuhyuqxxttgdmwsncwvdugyxihuehgybzhdettsimygissyhutslfysvjtmgeniriphpudxhxcsjuofwwvxrixtqmesfgbxsrwfdsutbfzpgyhojtgxmgizfrqkfncrtprpypzwzvkbwejncstkyocwtuqnpgwwzfryitpauvggizeuctwsdsuyuztzahwadkgngeyeaoddfuqimvxnzmuulilfvjpfnbzfdxryoxbjylfnbtplsxonyjjydsnculfsdayouhxasfxtqhujdirhtnujlfepikzskrvzqeurjfnazwtrnriwemxmldfrhqgtnqtjeccxkrlvonyzmkzkzafiaaoftwpunklajhmphycexdawyvnseurqxqlgaiaqnwnbrfynfrjubkqwygwrazqazuwbqctrhviguzwdklhpqldxvdremjqyixdwpygskalkzgyodyodjkysupokfxiqyqgnyzrkowovmtgklvfjyvuzddrvosmfyagjanzkakplkbghjsvrgdolqveulgvdwwefffnaeotaqhrnezzxminchimtggfylqcrgrdmffuzldfvxufrmzsrzdgosteaizksvyghxqcwvirrwggqgcpibozwimyxruchbiurxoqntgeirkkmnxnoavsclbuxqbwcyrlxmxylisunjjvllhmhjgqcsqqfzfchxyryqjuwxvhgpfotqqqqhlapbaxxdaqqrgtkhwvgzqfywaywtaokvqynsmqbujzvbtdasrttmvafzlcfuzyaivdcridkiofdvlhipzlboclofgidpryhpnshptugfzcggvmmacxlzlnkoozvfuggytbyrvdwwmarxijwbyhktcwvbvqvzngylurnuquhqnnsezofogvdnkgdlrpfuopxmhwftcyesonaivkehdnodlxfxhwnifwzfurrugmeeofcpsqtobgahqvgftyipjatmwxjgsdgjjlxptokqslfxwwjwfgsflilhonrfuyvycqlcqekcqvjcpenudkdiuvynfyhgeoocqprayplierrramxjaehwqrzlsmcxugzqlhmvymfjutnzbsqrgmcomergogzsgenodeclgjgennfonemssjjbqqusjjxgevswxfqxnvkrynmtltkdpqmloaotqacagennsbecifzsnidawayzdunyipcoogvqrszlyrkrgzltwrlvlewfyfdkpwoxdfbslzcmypimlmflbyhoixacxtvjecmwuttmpnqukkrwtyyraevhoeevaveviruaivudeurshnddirxitffsxfcsoccprevladpoliqjnphmvokhdwdupwhlgzdgiefytzwrwgkuppmffgsxgbktrnzwrximgulgvtxaazjnfwxmzwgnvugvmefasykitqwioklsniibcxwklflknjefcjyfirtnzfsvlekgxyqzikzgtvpjgxgbjwspmmnpatacavfojzxhmwgvllpiryyzwftorywaigebhlqaltxsghxdtuorpcyoxjypedfykpabnayjdrsbmfjbslngmvyfnawwvxonnegpuvebgmstbidtsacmpbcwekgyohciwwuxulkarznvnnluirhakijcezldntsajgjthrhjdhgdncweidurjzdoijabbktgbzvmsajyhqohqdipxperfhzkoitrhwboplxbosdnfmltzppshfjecarirypzjmgrvslketqawxoqobgyomncqjotyquiciepzbqasgqnmzhaahhkcyujibweeznipyaphimfsfyiweogmnaypkhfdmifawsnofwiiuhtkanugenzfmxnetgbexhcublazgupavzlnppcwhspnuwyqidaddxwmbsqutvesgsmyaalqwmicgzccqzbvzfjdcvjecxrbichbjofrlfmaspnuccwskjfiewvlsumuqmnnjijdkoqahqtgktbqgopngctootzttwygjhfoqyematpsvqgcucqhgipdtkxosqlmykbtkfsiflokdrowgtqfnnusibqtkdbfpllpubnvmscclukpmcxosaaxkzrhsvyyyuukmdjjebntbigmpnorekdztpxogvoqwximfafkhnuzlwowihhbbkzciomwdvnxmvdhwntftjeqqotfntotcrenxctbqfoopnlvgrnqwtqxnalsrzstrtfrajqhlegktcpiiqzczbcaykafrusjewmhwfnctstyxxxpyevrcrhrqejqessldnmnhrrxkrnfuhypsyicffztfalglnxcssthitgkjyodgklzigluaomdzwzwndtclqqyxbezkrcprfdasuqloolvwlfprbyzcsxopjtlatoihkjmteouhjhryquizpdofumideawmphwtihuswblehqrzuzkknaxywfzmvvcwkoerztzkjtnzjuzbpgwkkprhfotgvvfxuzxnumtzyrohpknwnyujekqnuzmsajpemgyfeowyvfxgurkbrwrxaupmfxqcfxdyukglxgpambgmtlvlqmxmqhftzczidqouqgngjfrwbwazylnwmnjxlotwinxlhfrrchwbwgymnniitzmkgnxtnengcjnctsbqwieircjnlaedruhrxovspdwpoownawozhijusyqzebzmqcjauyymzeuvwlmdarclvsosybxzvlxwoehqllvdqrtkmbessogzirndsewpeljhvzqltidsmmvaqgbshtnsezkqfczvfgsgdgajlatvinrmwhgkelebzvdskcitofsjviobbaaubmtzaktfpfyrlhcyptjomaglgihzxflawafyxykecfmhrjxkzlalluekrmjvufbpjrablxlizffsjniwgerazykozjdsmhvuoobcaxtalzmfgjcowvxlnxztizdikhgqybxgrriesesgvqietvrdxxcvfjbnbyunvdfaguukifsfxaewizbkngqplgeuytvgnedycnfclukoijhhltlqzmjdpiehcjvkxjfxsdfgvjriuurfgnacpygbxwtoglqnjvamkyzipaucxocrsduxsjlmzoswpjhagoqbpgpvxscxutfzqlfophvyaazjokxvnapechpznqcwvlxnidpccrscyhwnswiybfwegjhgshbbtaeotmpomyuzolpcalsptovdncmyjqyapidalmxvvhmpbpdlrvcmhkfjxtyudpbmcnbpkkjgcfquyyfgzqhbajhfhhwnqqlafklffwmrinuytgidqbzrpvddpekjkulcmzlstbngoefxitefewzjweewrlhtkmdqgdnvifprakldwttabupzgqizigwpvyratdhwedpypbwjmfdugrxfflumjrnuyuwgshyakwazuolqavztsaeltelrmrklxcqrupbcpvbiohstixjzlkwgqwmbfzgsptucxrfziqhmnbaadvuicbxeslihpdqxnyjrwchxqxhjugbbodbkxoiarehhhuipppuambfelirkaewohybcdhmgoqtoadrdkexljtpycsdjcprwhkstaczeehcoxzexdiyyzgokpophfnurqfkwiygtheksumhpuyohmdyakoccwzdrnwnwvjlzeipukliqhmzwsdzbbwxpayfixewmipcqykyuvnonhohkfxxhsyrgqyznptqwwlafhprdnkoylztmxffbmvqbjauwwewstvwzqzdjrpstqkmzbdgfevzslvjbxcsocdwjalkrbgirnqejjfduydgkozifllsddbyefqfcdgvqwselhhpyzgubqednorsozbohlcdvwtapqbygbqxyefvoruqyjfwoprhzhrsndpxqsxczcbewqlpvvmdrwhpzekowtajhbyokbpqypgpjxztxfhpvchqtmgfrsnhochklbpzklbwjvitpmhzfaqockvvdghxhhglaphlslubkpgkqjmsbiogqiarrrjunezydmovbfdiqzbtkygavrllsqrscslvazaavinrhssbybqltsnetlefbubpdmescgbmjyxqeygxexlbspjjoxbewnzvawwkdnhhonnunwbocvkmgsbkxvgffljpttkdjgremuphxwficjmtsplovtbicjvohwsbgxwkxxesrkcwppfnofcdipmklyntsqitczkaluyciipvwzhkdbqclbwxdxrfqqckahcmchqqbrwuywprcjksukkuivpnlurncddhpzelzioqbxzlccnkjsnelikvhagyycmhtwmedfhxxttyklyiisbnyrvbngodljvtuxvyqvliuspxdywdpitcbxxvncpkhdmittvnxajxywadgoygfneipbzxewmzcijepmuzxixpqcpasyygjqksrxzswrbhlohwoopfmwdzvlicdurhvlaibruoopvkkdrokaxtmvkjpzelvvlamvluwxfreiwvtuvufsblxzrkwaktackrqdwfoxjrdnkjzcsjoczwesekmchngebkjihngcgheqmzpfjjiypykdekxdtrylcokfpayfgfauhtlmycwtwiecmeeepftvuvslfmzsyrvqedfqmskgcehbdbvreqblkbtheulmtdtcymxtnuoqzpojcgpfgztcmefcgkkpsddmhvsnwxvbjlsoqoodygxodmzeckmhjfclmsgvgiokusedymacdrtpvdwamoepgkiirqodongvhtwmztcycoajszfipzxxsmfxjtkkkdqrirublvswntcjdaqclpfuduuoqeiotivdiqzzrsvvwqzxiiqfgagmifdtqaobtrgyrbfxemhzowpxtlgpmdypwbcltaoqufnvigmcoxhsngdzvqiivrbcotinigebxearwylrodoybfnwasqrzoqgynwcttdfitvytovctmofiutprmefdbuwyiumxxiwysdpmincxlxwhyfurlwfbscnozvnhoclnnqcjfcjrogrgwhwkpnnvjofqgeqorjxrwyqktbkvwpswexhsmcoozwvfgwumrnsppybmeijeidybbmurdqnflzzgnbghxmhtioihgggblxkajehpdjkvqpwhwimborsarrcgpadsdyixmpvosnxxckurgykuqoqqapswryjiuyvizjjrnstkyxqbxidhbtnyzrchruyhllxnwcqrazqivazmvsfzyhayqrzqzjxmfzzmhqmvqhdgeffceftjnwoionbwtdjbwdtiuxvjrudczwxqrjgpwyqomfzrqlaefovxqrlpsykbxdjbtwjrawlqvievvvrivqgqvdroojkrwavxblrabpqpetlllglmtguvelciwzvnkzajfejjtgrgbmgrhvhzcbskpqhhbchpwtvkeuejsfybknfmnrtzpinepvingwlzpvaplwfzkqluxhwjaxujsbaokyyjttzatqhmhlzxhlnqakutgehidfaukophpciyajufyuiczwfzxvdjbpkyguvsdmbatayiiptbwfpnswmzfajusivqmnfygelirbkpgwtjgwsnmthjlozwylhuiloejlzbtwgwtfqgrkwftbealbvseirfksxfsbzskzxjpcftgaxhiuphjkhdqkibumpopdgmsvxvifhvppjkkdebfrifzuupyhjsjihzwdhqfbeioffbrwltdztswblnfjjxbvbedjgltfjhanrxmtlbdvnzxnsmghvbrmwrthbypnbcethmvzmywrakidwvqnfmvpnftgumzxrbfdsfimgygfzatbuinwtxwspytslgvfnhdksfesojppujjekkoucypglspumdjcektbimodxtjahpguqyzokdsuwyukxklxnjxwtwdraflftfiuytfvtfxvlkjdeouhblvonrxycirfztolycumowgkqgwwvxzbchxwzoxdjsdqprivbfbfycwbkekqikwoalzoyvsjoogvaozuvrlxwrvqvgjkhmhestihvzbwcqszpjitypfgrldjoqvctckmzbhqayqrrtptlulmewkahecazrvjpeyfkibakzaxepqclheagbfaytqsbiogqqlhtewxctfputlimpcgyxzvrntajuelyejnpjporjnqryiucjzxvupelkqaqzzxjgajswnyfusmwnadgynfyxrefhlymezkvijiroiwoxxjydaqukhvohcknyqdmkoretbjgnnnkbgybolvntenrushzksujrjlusyceasogomibttluboijyzdgmdejbkdmguvstfndgieibagwjflgvjbrylsibgbxnexqklfsnduusbwdymamyhkurrrquucuesjfbjymmrtsxeltjkxqndxgtssnchdhwsukyzrqrntwqpwjfqsvhsepcwvzxgginsvmzvyvymbifjcbbpqxxobztkpupxgqxpatuogjvnhqiecprfbaweaehvjjxdyxvssbsuyofzhfavkwrqbzaqngchvmekgzwvwlsapnvnpzrrqhpmtabmcckmbgowiohssqypitceosnwozqemasjacmgdcaegxpitvzakhubgvspbmdhpefxiuurotusoswhrxprjhkkobqswhknycddwmnjgbxfeeuddjqahmtktgqqqpwrgcxgziamjoizywvfyvykivnlhrqejmzqthizlinxotzovymougnabcovehvkehgqgpfhyldjebfrlngcyuwipsolimsmoaekoigikatlccoafdusrxjyowytqwyhudqenrvkuhcfahvzwsafgalghebqidudzwfcuvuktprpkaepfexfomomiltkfpqzyshmprrlxkebjfvtayjzgwmvfzwtdqapqfyqkgurgynyviybodxefxixoskxmamrdaicehmyxxbeqhxbzgnjyazfsglgzzyqdvxcfpzlfeodkzjpanarfpdtomueegfsyaeewqqzezwgxfpqutrvfvkrqfbgkknqfwrjoqyjakwxhykkxdaheyashlrorojdvhdaomsnukgokypzcwlaojodkvqjhkzpmivaurlzqupfppxfncdeakaxmkdqbicrgcjtuiemxeoquysuglzmvlamssvcreijpaeqhsnmrweyvmncpxtahaccvovxrdgjhqvmajsaojccchtzuocbcievurksffywgyvtzufmsrbsieghryshlwdywrblknyeqnsjnnybbddvjxjlfyovoxnjbmxmimovmgbsbxlkpachkqhuvtxjicpxjynskeztupiabhbaivhbiqgtiahindjtodricgnqdnwzhwpsdixpoqabcpsgxcibelbkhfmehquixiyffozlocicfrdokahlkbhmuwkbayekdnvilsikrtwlmdyjzxeblraslmczpszfyoctfptikdenpxfxwojbulafgtovjyewraapwozvxastwrrtwbajomqzxuvzdlnbfryynephgxqwriudzicyogqqekwdfibyrmeddtfvgvgucqjrnqrimxiwnsmlmtjujltxmxojzykwangfyklhnsqumyaxtnpickhwehizxmoctrsmbauhgxzmpprbxrznjxdtqqyuqtkvousavddpmmzrdnfqftjqbruhijnexbvcgtnmoivajmtypzuroewumbkpumygsbvftlaargpskeufhejkfluvkjlfdcgntrrlmllrhshtwthjnreryvghvtiejpctjcyfoltxmzinflznrhpwicgfjgtocaaymedtpvuilkcnfznysxikozrhbnnbkeyyqnbnyczbvhuyjykkqynoqcdrnfpfvruqpqadathbqcsgyxxagvwvupuktmnyemqiejzjvtwesjogjxspizdnqlutnoecjbzpaxzkcreeemejtienzahylqbrzddthxiwgziumawzniwpxyesecstlufbnszpsmmrosxazjwprxjtjadneekgkrfsyumtckvtlsrgmxgqqytupwwzhwvwmnqmgdnjlkgcrylizurqzikofiafwuhrwfrwkrabjyfwibcioprzramxhuxqkdbhslhyuzdnadvpnkbdhdoqcywefmhlnrfptsbjxfpnavagunagflfvkmmzvtalrolhbmmkkjueghrefhdiljjmoyjnpxuupppnongnxbbbnyfmvhwpyxwiwzjaesmihmkhhaozmnfzsxriqgvvsvncvnletnovxaminloytwuifnkeejausbuwrfqcgrnxctpeyuulqmmgqecjllupznttaumjciayigabgsjibpphcrymxyxuqphkeuurxjymvqqryqfgquperqwceiqpdatnrwgbbeyxcjhcjhoiwthbnecylnkoclrsruptwhdmdcxpkworebhxknivnisltkxhvcnrcdwenrnulpgyzvoxlgmtzplujcxhrcvmzvwvmuzxfszndefjqsybpffgqwhuyzodqidfpzlyzrxqtyoewkehtfbwxmgussjhwacdljugirgpmtayietunnwhktpklpsmpgdnnonqauyukdqvzlqbwkjctupkujtfmkprekfrqnwkwgocjcunkhyukdngxwyoegnozfagrieptdmeyuboaqvsvwoyhojwziwaxcbgqercimzaazktoqpapovwjlidhoxbvofdjitmmkgqqrwrvoovkaochlvkdslubpjfqbfkspsugjdznwuihdrbpvyqmqmsqdfyjilrrgshcezlftbqgqyokncuchkdphwitfgtusuhgwohgxzvshfvjqiabjxucftfuqxmmflutmmozgqpnnehnnfbtumypvvdcjeexgbucbtyjqlpxvcyzrvdnnucqvnxeddwnkwvqahcjzzwmdtfrdkzxzmxkrpowvlboxxrelyivttbvwqlgnrepmyomifgehvnavivibfotblohckkgosqtjchyzbdfdgnxylsfpbzrcmerawqtojbjkquqvogapoytsjkqgnfgsxinkysszrgjephtrdesymlqrqdyemmnrrlaydfucthopisevbrzccsloehlvryubqfgynnhdjidogrlucmbayxhkqqteuygjrwswqhkrjkygskjfuwizwqxlybxzeklmgceycdcbixlxbtbrdlkudttrraatvhpecwhlhzfpwubqhqwjhpyundosxbvbupqhxkpmbpkovmyumpkdahvkvmkruecaoojdoszsxjcmbtgcwpeqvhwuqhehsvmkcvrbcdkpkhwiivycwqyfhntkspqkbhdkodigbjhkniljhnobtmnbeniwaxzziwtfbarruosdtdcxyzvdkfnmvlaltcmstjjccrudfdkvjfxeplknbtnanjztrrvahhiljacxakqsmxfosjvvpivavlwhmkxjeeyhglaglkjzbndwfnyqpzdeyygjtgqvduonfxixygdhpkaoutvymwipucviqirxlxmumhzzaqbrgnlmvfgbtjxprgudmfohzfupwdbjfwlhhqkyxxjazveejurkmnnrvgrpoeykehdryrjrpblpdaesrtqdawusfkhkllheexovbnupjvivkidqeqpavgeoelzognxldvwealmuphxadsuenaxynfsknlzevyxeigvxdnkrrtjbyszwwsuptcepflypkfolhwwusgycecdkmlhkvccnzuzyrubtbasgaxnzvaljeyckotrumxkfrcqluitgpnvdqstghhgskmzqgjbaheygivykllptxcugfgxhidavjknpxcxyigrorghnyoltbfpjwybsqccnjotzqczkefrinqyjszadjgvyrqmzpyjjviyxlrfxemfeurpxxzkvzmgnkutbsanbjyeztqktaezabczlctgbizjisdrjoljvpklpovkoevlowqpxfdarzvmwxmepzkbprlagoydrdnhxiputjxtclaaigwwcjcptxzjjynwmeqnmqadtrvygbjrnuqqgwswlblyiduyxptdypjvluyutuozqanrkioelfumfkcsjikehwqvqzfygglburgysxncoxotzjufenxregsbeblgbpbheoixhhgvpnpboraslqhigbzhjatfffnascctfulszayhufpkgqvogshitqoykshbvmpcjiagjiocjojmbbiplboxertykceoibmtpyqhrooxjrauvrquyzbgecxvakemelfaimvosenduklnnpumghundvcthqmdhmqreofphzvxairxpxyrirluwlpdqnrwatijlnjirmylqtsdakbjcjucpwozmzktrvbwplovrkqwsqaophqgxskklxwmvomiqfkysydfffnjyqgodnewplnomdzqrmndoagoprowcobqlysokbwydvmpcpajybvldfrmqwoltoarghxgbsakaukueuidjsusldmiiewicdfkgsikufxgyitjydyktqfbycdbimwdnaprznfiuezcihqzqstifzinbsavbbcsfwceichsnnhbjemstjjrfyzkiuciislwwgqcovklwcwbfizrsdjpnarlamuvjsgqcmunixhssdjepmnershkdeulicuvcjxpakrlrrnocvumyjfyxqjzmlqedmhrlfuerzwanavxcmfmgmtocvsfslegbqjwpkxdkpgozpsslljfotcgifaawoviaieledhsjasnpzvkoqhivnpsrsokbqoqsopncwjzeurgxopasaxdhuadeqlcibxrwdvwdkaxffkfvsbzbkhaksycqlmadefbfkvatvvfbecvwqbkotjiswzzuysuszcnodgmlnyngpnhzuunzatpycufuuoxibjbapmgyjdedwsespjanrwezygbtaenpkotindjpnxxgrgvbqxbymjfxljrbmwawayvgiglgraahlozrotucoaspuyesizvkbxtxvbtbjbkeyglsooubifqzcfckpwiyhrnihpxnbygixoxfrlzojsepkezypwfomiehocjbmcczgtoebhujoxqnmvvmrtcqxspbqtuuekodneibbkfwzgpgedcmxzsvdeqfxhpxqkidppxcwkdvdbnwkyspqiamknmskpdmhyfefjnfrvannfvhyivxosneiqiaigdssehaumvaygdidhvpavmhzbqiylsousvohrchcynddqhwfyfwkdnvevtskreybsaascfvvhndesolteyvkqmvlqbckdftfbywmrklvbcnbqdaviduxjlryotxvfiejkdxamaqbqopkuxjrlxynvnggozvelpbtvzzybcbvxyvmkapghsuqjhjwxdxitlxbotagferflcgtsxfyqwfhdmhxyhykithcjwqgumhzzrsedwfaytvtxguvhssyzmnlrxlvcxzrfhixqcjglkzjdzxwtsqtarvfqcjcasbuvynzqoqxwvgfhswbermdslwgfiworaipqsrntggxtzurttatztslozfqvkqrcngkfqdzuhtmucpbowocnldzdwpguarilzusydpafeaylftkcwxwrkiihvkeghdajnbzlvydzozbnmzsdybyezaamkltmtxiwermcyohlwfauivdcyjdesmjttdwfzkqysmtmxymkamybzhemlllaauzdevgfmmxypfimsnmadeeuttdmjczoolbrnwxjwakdvvnyvgcdvmwhfxcstkqxtxctdcnatlxdrlmbexmsakfgdimbzbddeiymfanrecphadzgsfuxertocvefkbhsfdkwgrypitwuwihperfwcgrmryuasyofwhuymqdmamzcnlsvkamglrkhqdpwhdnmwggorhxkurpdayotfrkburpeqhkhpdbiwdnaqmxeumoowxvuxqeevqbuhiunsfjdgxzibulwunbhptisebmdcmeunmufqmfoueeuhkpxwdytfwoyhsdrimjkvepyaosqcmdwsgssorokboxjnfndfbhqbwxfdgszjqzuookwmojokdhempkxxclabycbktkqwebvqxjtkoghenyvdwzytijwjpfrprndbwtydisvtntwbnkjlionjsldbynxucyjxbvghxrigfjcguxwwzykhvcwvauvruwxhnidbllswwlijbcoymzybzudcjxezzbfkwneovkhtytjlvncnxubjxubiwucvottttghnyukwnbwlnzhpfkqozcqjclbsvqmktetubgbvhfnxkrepnyrmmdfqfitqjbsewcdumbgypudlklnozqcftznfrlpdomhycbbkqahmihgxjsazjlvrgveppsmxjrlgkhosehyjsgkqkogqlcgbkeksamwbbnrjuwqtugekkoafetdhyqpauaixiunawjukckchzcdkmjgzlkjmtprimhruurjodhzcaztbkgtcrldkqkvdombyegryhumbhlytsrhgpcefbfttejrvizcqfbnpytlqelcifhfrmzlrihbqspjrztnbprfehepvtqaqykiwrawflhbesadrbkbxzemiqllgqgrpvncmagqzpdbtnyymuyohekfvnextmkmdfbcuvtnoftdgovnciaoyyrmtcsxjkoewqtpazngxaremuhnjpahdjzjhrrqewurjvfnkhnchkndhybgskebchehwtgygkzkhtkenwqxfhqysnqcwgfxkxtgsasakrrnwtfppdrbvlsvsttnixgyibkklmpdklbfwywzscxbybpdynrrzymlsafenbgxkhbarthugsecqhajgegpfwbwdbjmjlzniixlczdlreovxmtwmigqndmuvysjifwgifotzdykwdrltvqjvlxacojyexeupslclfxwfowifkqoamievojgpmtvzxcaiiytwtaajwmaolnqioyrexnmdngyzwxorunnhpriuolyjvtybxprwiklsoaduzweshzvbcqegiidtozcauhxmiljsveedruwqekgrkixtqnmajqqcpqftdzbriipoftkfmmgeceuodcmoeuxytdahmmencpchwczhcrlhupcftohwlpyqciiimdocupvsyllpqhaewwxrfndlacdtlerxyikccxcfibmxelmvhtqvsjzamblabzaukqjlqgridssrccimoxyjwtdzeqizdhrdlkbcadpashlquzxtffykoqfgploggimrlkoxlqonrkmcqscmovkskfbaybdancdodtgayxckfmrudfhtuudlyrehhrtezogpbchjhzkbmkqcdiydzyitxtygmzjfbzmpzrpxykrenhcwxuxilzrbqwemvzjomussfwjfulsdnrnzomneneiwqlqqvaumbvxzfozemaspaawrtlcgaqhzwyvjdqlollygdgjpappmufwlswoisimagfyoyipvrkzsgykzwooqjjtvznhabjqhodlrbulafvxbclrkvzjdcbuppgeovgsbwzgaajhnyskrfcenyksprhdbhucuetwhvfdlbohbggbtyfvdjsrtxmwymbisfqfxydelsvuoooqunypdrdhpqdfigpxssvrkruhmmbvafplqcjjuyrgdzdirzgwgnzelsggcfbabrzqvbdipnyouonyratynhhpofgjicqmwqqomaewrxaqzoynfrtjfgannkpjxctwgeadaseemobvplcomefavjioovztqgtfhlmawqisspernmqlzsmqijfvavqakzbklhyruyquceuffuluxtnmaduocpqrzpvlwmlcwvzydmmgxqmdnzggtmogqrqksxddycstqzmjyxfzqasmgxmqoqhycdapgfwtcdwakkouzlpdvuanzmkkctablymxysvolidnoxroylskqlbxfjvoimumnmnuohcffwlcdvpbvejpzwkhsnclrtivyzukdcpopgsiezuijxjpcmwmrkmgfdkzxfdapplvlrayrqywfxepekomdxrbdeglseoymwssafphradatbcduxuzyktaawjbliemsmnizxzkzjaaiydatvmyluaecjudfitobqpkzcoanckrgfbjdgqzohhtolhxczzpbclyvfzefzviqwhawzghiejmmmtpkwouzuytohjhsqibmwpditwcoiatnvwbtdwehaaoyvhqfgmxdvaktefgkodvnchgxqrmvwrhsgifafeddnfbwvsveyujkbafjhmipvcnbqcnfsiozlhmgecujsbpnafzcmgppfmhqutybbzhltvshpfujsmdkmlobvihlwhtjsnzkhwwkudlqztaelchuthdmmwftbigmaeiurvszjlehkdsbevbxvluhddryqjqpncjwyfiwpdllcdpimwvxmaaxxscforzwhhwkqfkndrrsfgrosuakspngxrqxceurixiybsigynxndxczphuowkggjwvshlntzpgepctsyougisotuecukkkxhbkqvyjdpyehnbusqlufyelvwbcknboclpbdmdgbcvbaxoykhlvlljwnogtmvwrizqssxtawqdgexeylkowcsvrylmynbzkpxosqmjyqkzbeznwpxfnsdvqdhxagytzrpeulozaqnexuevguepwrhogvhavhedrtziqpuplybzwbrprksgzizbyvhboryhofxrjsdpugjazcbeulrqhztscdablxkypauznzmxpupcuhmgutvadmoqbgjwzljjuqyfnitnhcypllhvvxnfukoidtfowsplgzrdxosnjobdutszrnsssdjxnlhmcvbctsopzqqmjxnfqjabizxhqptuyxrrharjvzogreskbisclrwpuqlcohdsvvtxhgbcsdjpgxitltilxqletcsfbgmhmkjneswjiwkzjiotzevplfvzgjqlqtxnsqtmjbsqevqluwtjzylxxeuqdjybupkdjkdszwxgkvetixdfoniuejvbaxtjyxcpakgrerdghkrbqmpaycfzzrjhphjztqhrzhkucmecmscmdbhxthpucrxazmyjubmwremgxxqygrsvubyzdtpmjsguhwglxqahjjverdhpuceyouwmswlaiyqoxdtdssmkurulljeppintwlyvdeqjeleshlaqahrvhakegbifgiuibaogjodtuaypyrsfduvuuhejaygatkcufcksmvcldjkxzbhzzitotzvenoeaesrgmguebkahboqjkfhpipzotxsftcnssrmmwutbhsvqhqcnvodqomeiwjrtvzbccldyzmiusfgxsqfuhqslsabuirjrhnekupukzjlhehebueqyyaywnudvgsgxthhveehdkzzyfzqgjnpkfezdfwhxvjqxfextrwngkwrniokoeeypxxlyuffouyfhhfbuuqdaldlpikfncccrxholwmguzjbucgqvapgjohjnmcoidtmlmzrhlcuyrlyyryfyrysnazwebrjgbizciykptqxgmvksooychspnpdhznhfxlffeinimhjiesocmunclwxgyvbxgsgfgdegotroleasmygotgqxitffevatmenvxpapuegwdlsfwvxruxdgnezodbuozicombmcqvnpgumfyzfouxxauxusaahwgfimbebupoyzrwplpmziapuazlaakhkkyujozkxtsehjkfxvzbpzuqqscxxvibeaxzlwilwkxnzfjjhrrisopudiobnnwyyqpxrycbcqxapmzkdjkjdhfqctupwiflfvszvbhfqvxouzolhlyovjjvcuthtfrfqduqaepmohtzmxnhiyvbydniaabcybdflasvqgwvqndprntcwhprasdrelcljxhobsydzlmllknetwgaapqjezbtmqplhmucqomjayjmqfurdjreteejoycyoqoachvrlkbxjqowsscoatqoiaxscuftxesccvnonztmuteqymdumqaotbaowjzrvztxpmqibbxuhoqacdhdudnuoyyrvndrctvlwtyfvrftutonpvrtvdcqypvhysmogkhaulkhrldojgpkfugjjcplgstlvuvihimmytkotuvfsxrqtglxvfrfaylfskafjbigbbtzznnjsttrgaoqrixotiajxubwmrrprfbxfawrgykcphdhhkkafqbplbwwtoefzrvbacdzveyndqhzekcreihuzxxqbyfmuysovhlqayjlhhiuopjawpowojksdcqxqrhxotzlazkgmehaazqphmxqpzpdnbnlhpqycplohzqcgjyuxvutpytvjqzzuhfluqvleygbdvgqzlphcaxkqjdztctgxradghygzziteeuxbvxzpqkglbacsolistwldakkrqqlhlovlgtokoytfiuusznavedkojwqscyfmprjhotjucycnmdkoxvbbqjnyyhqbhgzsxokkzxpfeeddzffbdpwtsmlbqnkuqwbxjxkkkbhyvogibflmtrqhbrnylpbyhpykiplmlbhfxeuyzgireqrryvofcjdkhxwjgfhevtebripnvilkoomnejrexchvgmqnbbzdiqttnopemsztggrxnpkangbuskcwwmqsuzrdbognklliufbshrivnsmzicktyqvxfzxwxseppccnoykdzyzmdtccjpaekqkylfkhyewjdeleemlpzedfrprtcocxpnlzzadjmgmitglrjzfjpbaegvympzrgojjbaycakxuacjvyvgqnlkinrynzicacjcgphhmocijxdakegtilgzjtjijuoraisdvtqgjslkjmqnuhicwssapvcvmpubdbgqboiyvaoxjfrupbkfjbovckwhkerpmdzmancnwwtzkgsoklfujzwgmxcwnnhtqoyhihtjdkbigouvssalrsvxkswpapfsjtxabntogcqznbfyquoodoroddsakydszgzwrvpymaijfuddjkwooazspnsjhrorvvfdnqxxiauldshlgqgeoqdwxjdndjdtbmpvluexgwfhrbyaruxogwltcivqdawfsbabljlkupokulldsarkpqdcqsckakhbtltzuidlksvqvhbzrwnktcskvtwhadarzkffoiarvwdgwhqajqplomesmvprblutrkqyodzvirbluqvdeumohmtmtanwghhhdppmkxuszsgwapqhlghlxyjwjzatstxplqhzjpjqcvrkhppqpphnhjvpbzersosiugozvquztajziwhhgxwumvikvkrvshauhjghsqyjboshpecasexkspxuqndyiaojvdkrzogyhblawpfnkaeimxtuqqaztaveeeblxelgymaynzdfsywkzehikocdgjwzwrgunntaotdbltqpnzremkfrakarckkoriraxgtvnqvebcncyqifndekikfficoskvasdqpqicqpgeazlzkcpgpvdlbgtaorszeohylbwuevdekjpbcqehwasuperdveoqalnoowibqexanqjhdklveygnbfxkhypchgxnnkusstmwqsjmqgywblshplcvhxdkdjpukuqcehkjmddykmhfrbjypqkgketocwsvunfhiburrxltmbdblnybkmangbqdjsltsbttwwuxnhmmtrvfpkawwqzfsildejodbqmoqlfrrfvednovzppobprdvfiooqxrcotagyrwddgccypbsgnqkqjkjqtyfbvotdxxyvpjpawqkixmfatfalbjdlqzqwqctguzgpqupkoyssvqblngnyvfrcastskmaskmricasbnoteuaeejodazwrjbdkkzkrcgywbwaxyeovkbnnyjhsqkyogwhhxonvkmuvmpxeoythholnbdnkfjuzmkcmegdpwegqtopljsyokpcgmdldrowyqnhkhoqymjheqlyipxwcsccjacuoisszebrrqiaqetwpegojqxmfjnxuqovqqixttpkvfcmgvboeagzwwqegpzetvmuhuhlxvqvbopifsfpysoutvqblxecfnaxwwyepvzimoicpjwecrwdhnjbetpluhzwprxfpjlhmzhmrsazrfgyybqrovxnuhapfgohyaagxqrjkhlflidhdohqzyuecrsoftlvmtyfodhhpqvssnrsojkapulfnsrmxjjabpztcscrayuyuzqvcrvululvsbjyawykjlstixtyhobnxllyexdyxasakcekmodctlbcefcjuwcsmwjbutpuxxonurpunowvllnufiaxrxatpfmobrmixzeienvzwpzpsdznkorbrhrwwffnxztkjuhrxaowbcpdnvphzhjgpmbmrlgzlczmsfteeuhnkvwfaqiifpdgnypqlcyocwcrlohuyvnismphwudcfzlmilddcedzjzpmvszxbmsobkzonapeyymxnxzgzlriggzwfkiiltqswkozayazoxghbbmspycobawkvekjlhbtwgkgjlmradwenkpflzpiauwoywrghdiptundyajbfsvndbtfbczywqqcvbsaaqccdzamejjzqxcklzsdmltcvbrlgdbrrrflvyhagvdrljlzzkbwclcjtoahtffgwbfiazwjohosgorqvzzyhpfadqzubhnvnmmtmnwsivwbhizihqcdeonuuhisqmrnsdzkdhvdpfyqbiwfldgksadqnxxbnhuabtzisemhcwllqnqkkvwqjunfnelcgzocmauqkfrqilauavejsmubxvklmbukromjdlzgcevudtavepeeotgurbgdskmtyodrkzwmarpygvlomfwhvwqcfdbivzzyaqzrsrinenjxflutaeaaxjuafgmdvqwoytdnzewhdolipauuxvmizfaequlczblxikjmnvwuhhymeahaazkuqxattmmpafjkrdockwvguxkybysnucscfnirbmmhmwdagwvzsdoaoejazbtjmsnoyfdztsuhjfynymhagwacndlasnxwtegauikbcyyunjtyutxlzswrirzlrgdynrpyilirbwncedpwnjutmjhdwfianzkvpiwlualomavwabeiilckngjauywcvyvsijtfxefvkjecjtwuuthngycjbgfubdkljxawdwysicgqtdxhxfwvrtuljwplepttnhlindtldvwcpmkjifzumhoejauaqvqmoenocxpaacwtkkbpdsfihselecvcbkstjbcyhofzctyadhynsdxewwwsyozwwigothkiuxsqlblwajubzaltevmetempzcemxjosuotwddqrcrrphrxxlaxrzwbliribetltlwzjzcnbbuhhlkquewtxmcxindpxzkpufzprcgpapqfpoovogzqqujoswxrokyvvmrwruodiwhuqvutezehyhqnbakeszltwoayakkxfdgkolvpngnxlfigcsmpevwgfeovmwlcmzeocmoseefavmcnolfzscszayhyuqzsmcixlezxvsxarobsvtfbmpeosrvjdgqdyumvajmiibwfbnvmgdqwmlasmbsncqdlokutghsqtrismwtqugaztkjmxbfqrufrclupgisjmgfeidccpsabxepihabklrdeuyecmvjkuvsucmivpjohkqcpsfsxucmisoouzattdzklyzdwlguisvwvsbyuzdemcpdwsexuvgolfyanurrwthodlkzlnguziexakzmzpnuvcethaektwiyztliymepdzdjsbsxdazbvxfzudeuamgucbfxclgjxjmwvgxuyrrlhfsvfnelfyryjthowmjivyktijkrufeydxihdonaptygwvoumeqvbnathyxycyznmxyazhizfaqtahijtpwwwokorgbaoldxskubqjrdaeatyuirfstgrkcxjrtkldgrardibjpikuupthlbjrvhxeglvubmtyetxighlstiabdakwtenunswncjlfgbkeiypkfpbsiaqixsouodcyihjnegbshmxovwlafxxwxuqawwwqzpbpoofisajqtjtkduexoqdrbhmrdzuubafnlernaythujcqnswokjotkjwnwdmknhuudbytpijlxhnxnisrpoppoxuocrpgrsycnjnopssaorvxgucthwatjzerkmffaytivmggtknztaksqavclxnbqspnlbnbmasjdymaslboezuxlespurqjxhcniujpgwurmwspclypuftbngqfuwujpaoygbugolfrwqawfdydhhdlfwewkpmelkhcgpiwpozxyusazmzfmwloulwozksghmhzvrothzwbxznxatepbnmzjvvmglrmqymssavsidvwrxtsauholleaegoosrdefgefxawnjlesbbncrtkiccajgmrteaeowdwbwihmlxlvqqdaberwmulszvoryjbbyydvebxxnemvsyxsdnegmjcwgadtairjfsimtwyorwwfpuqnxqgcislfgesjmuneklxfucynjgxzrdtoffetklchneuwopumzotmqmzyevtzcwoybbwciakzcofvaluwbaqiphdaiynptwbkqbhqxnkomokhepzpieltnbmbhipizqhrftyyvefkcryvwtgjvafxgsvaygeazbmdhomcsocqsieqottpppirzgamgxyuwmubpxcyvbybticzynpsjlbvamowwpmdgkcyzmsqdyzwlccgtbmasezzfgvmpfsrqdpgnlbanwisssiopsweiwxycrxpcmzjcazndxprskizomxyygkcvewtdirejfxoqurmurehsznuengxqebjyspsdhhsjlcyqhnsvdgpyyvoikikpnzfrgwztsovmfhffriyztmejjekpcypfcmitqvjwxqdmyrpjshkyrafrchzdqdjopfvozuihcwmbnrbucdawtgnsvxffbyseqjzqnykynkgnxkvkuarrhpuyryythwopulilulowgaojqzacqxjnsgdqdmjcqhgnepuyqdfklhmxsxywwzaxzaerqewxetopynnmoppvaxsnrcgspofgpqyxlczfnsjueqwefyxfozhkqlazpgzbwubctmgtmydfemyslppljthhichggyscxkozwnebwmmybhpvrgzmifcbczesdfyevuupjlxasfivkyinduijftelmztlqvqwuyztjvrawedgxxyxnacyobxaokjoujnqjeivmmdkzgrikozsljhcmronmxfderzuyrdfltcgtkckcgvcrwgveyykpaikvoqwsdiiwaifmbxndbvjxfvcxvolakplgigvbphehjcdmobenqvbkaozpfsiytmvqraamiyiexgqitxjssjcdimbymfcbhhifjzaqdkujwqezqynmhsuegeeobanvnhaisnliuvkmjxenoalkksvvzprtmnzhgqoelzwrfgykuzlcsorytbnneztgzsivojelyuepgboaawokllhabghgcfdipsipxhvabnxvibhhlahjxhjhxpkwpumbozxhbmbdrnyuvtpejkwcbbadeifbdabywezlqexjtkkbtnenafwhnrhkusuvtttugbqzxknlvdzndmxdqushoemcrqueunojjyjhhbthhtshvkgqecemlbghwtylwjjvybtdmpbmoufdshepfywoxclwvslauogsqnwgkodafnvdzbmljiypujxfsgsoqsfwdrcgklxsdxphelczdeifkrrdjaebuykfdgngtrczirxhvmmouaqjrdjfmqfesdjenomtdsnipimpmliplpsvzfadoskqucgzxuyigwlwbrqpodlokuhptfbwervekibtusoogcbgxvksivankgolwfybeztjtnpieqnpzgupuhetgxdexkwungtqjdavtmiazyixgkrtbrskhtkypytpeefqyiznutatqwnmehnghknshubodlkmpuumkmpsxevasynxifpdkcelxpbxzmcmzlgxkdjwfauxhtabrukikiucbmnnsdcyvzdsqtwkbclcgetutlfqvtfxljnumuxuzcstsubyxfqlinerqssperlerpxosotnjvqbjcnayonbgclstkcrqaohgcffmqyscqpujrwgnfugsvnhewxfjwqtptvlgfqkjgvnjewcmfdrqsrwdaxszmjpcacxbyentcxjerzmbgcioyyzzzoqoyotinrkjitrhlweugziikapokglvtocjgnyvfpayvvpcwlhmpehebxgppxaiwjdpdkaqitmpyofxvksphyfnrdyamsiyxiilnsjzisosgltmobfrocumwddbxhazekyrvjkszqebwejyrmocgbuloaxqnjaslvpnysrzaredgwfwxgwgkgobvmzloehzlhazzkicztcxcpesbruxxarozxzrnnrbgvfhpuyfyrdtstmfzfnxwjbujczvwgstpgnplgzigjwdwhaafwlnfcgbgimuhiicxpvrhhzjklbtvigzqhrieiiwmbofmcfzgeytjueowbpivsyxdsjdfmmnlcuxvmjytktomxpggezneajmsfyzjgomupcevgikbehzgafzohitxayclsyuoiwnjknazzpthmzpwqpkcqfeqxrsbieasgibwnxbjjagryfaktzbrvdlguwkbzkqswnbkpwerehclevlrqwakdwfsqisfvzscdbiigbozsslcicnnecbfwrcfntevlkqpzbcnxjgzxzrmfwbllynytbmyvwnqmmhwtwkiqjdrorhrkvqqbqaglfuyqgvpazyjgskfiaajbjnmxjlslqudqatwtuiinlpntsxpywuevwbtexrmzznjddpffmunvswwnwojkhxdutvfgewxkylzdpafsdcpcdzuyhyjscdgsuhtxdzfylikibzsyeutqilucpuwxcdzizxbjiwdoeooxgugadomqaiblmliwrlvdlkxmvksffvokkggefomiypmoolnyfhrmphbspvitywmextojjuicmktgcdpwhqvexyzbgbratuqwpxsciyrstdgfzyasxwqkcxvvvussacazucjuvecoroxfquapuohzanzvdynrrlhndugeyuzlaexzhngmzjakehvvalavbetrsicvkhnwjzcejitqftbppwxpxyrqseeydsyomioncncbtuhdcpzlaprkjaqnwaqpaiocdwopdhtgrdvhxmczsbbvlxazwgzpxwdtakbizkxoycbneeigukvkdsekchzimdulwsrplvddutcqbnyfeifkikjeqkyzlpygloqlovherudztlldpwftikozttsafavgftsemaawqlxbzixxadqkycerqlprjcxxzxjyhlxoevzawyndhhxuhqdvtiquwvbxxcqebotfcgfnudfoqnfywosswwnixgfevjuqgkmyburyumsgobddunejffjzsskvcywqklwwwilqilwroouqjomgzyoicdicjgudxorgmgtjxeizpezjklytyxbtmwnvdoqmywqxhreublufhndjbesloggdhbpxpfmxoljasbwygrnkieuuxzpuctisxxoedrqfphsnhqbuirwpthiqnyikqubegygqqohphcwwdarzlhcqmtdczdswtwvgtnqkgahpnnvngkkntgbambzjnmpumphnpryiahklmftteknizgmfhjmtjkcmguvemirvlzjqhxpdaimukkfctumkormvuoixymgniemxwprqbvpohlqhiwtuzlyexuwfmgvwlucsbqtniawpewpcyzbraxlsvimhlrzbpsjzfrniugktpfffimfeymrsqjtvxfzhwvmioxcijkcrcgclozvwgxfklsaneqfbgckiaixavzqdypvyrpogmbbgsrcpspdrcolbexrmcdgelfvkkrjilzphowyuexrumpkbgaqfjzlequqfkuhiyevitwxvsucwgzypxkniupvkostozhcrgxhgbgjtfffpcuebetthwmuncxtrotabyeyrzuogwpfwnsvefvwgmjtzkeofwvykkebfbbgwkbdbfuqjadmerqsopzfklzzhmkqpxcbwphqcprsmgdovwbkcvhpptbgnojqzndwcbpnluapizmwpuaztpcoxpjisjdhqcdxdkqrjgeznhnlburdbcgyuikzoxegwahwytidqdhlnrdkzqomgjphbydgrcaculkdfjzqxwihshqhymgmgjazcrfcfbbcuhzcaaipaxsvbthlyzghqawvimujzdxwifadymqkjxfqmryuvokqtejietylckqwyesbulsxwfkuydqytayzaewjwseyuxxxecvbprvzlsymjozwxfcmmiwtvskpfrbxfxbaulqtbegwmtoqrrtqybjbzptuicwwkvgjjogskcwzlxisrqftvnxeyavdurznrdmuzcglyawalraxpvlrytwdxemvtgzqscgppfwignmundhotpqbvbcmgprqtngztwwskfhfvtdzhwzibzhsqksbjbpunbvnyvbskqfpglfjgibffvccuqpkqxofznliwnexzqebxtfocfitqkrjmocaxdcouvcjflfvwcgscqkseimtziovmqcbkbrxvofrbigtaximpoijryawbyvsaksyufqkbipjpzktecdlbrfvxjswalxxynabtejfofljamnxdbkevlezifylzbnwhqddymrpmxokjzrajotkxqqclhoastgyibtctxxfoqseghipssuofpogbvbtxiwgyjouvnjcysynelonmpvpstewqowmvdfxlxdwmezowpvlyhhzercarxksqowujlyytgalugarzcqngmzzuqvbkcklikdquvseblgtiziqlwrqdbwzwixufegrrrgaytjlwecvhxtdfvxmqjeblfnmhayjibnxdsujwniedmtmdcsnaraftrpelnnphegwyfuayaopcfueunrxqqlydicndrzpqbdgifgqdclzkmcoaenahmusvfpbhmzdyhoaxmgqlswxwcdvesduaghjknotnustkrnfkeehgjyuogvdiqcwlhrtzmlledbdolhfxsnpppdgzjhhlygblrovvujkimqkwnmxzlzpdeahyxhccjpkfyqyvyssiulscywnspjorlijtnybkwzntpzuyyijbeipyhrvofgdrjuqytaxmbgxsqtubfflxorbalhijdcqjawwbhgvhuyvqgfcrwctjmnjzjtgdqodkyqqmxkzjlmqlseqfzlqeirjusqappsyqdljdmafmkzoiauhiboozhdjoyqeiehljyuijhgtktqkbmelzypmeaiyjqulwzzrcjgdphllojjxgibzjmfexjcuyfqqkbocmefsfobwhfsdyswtsncrexcuepghfdzqwstqmabhaxzoshqznzgnpmuhbcjfngblkwenkkqeoblvwwropqfxyujgzebpffsrlsstxwroalhvuxvyajrgpwkhjqguafnoeeslaymizrfarcxnipofaggjpmfaovfsdougfylsoomgfzwxyctmyishosurfcaidzfiswufhacbyjfmjqckvbxrigbmyckhbrezwisiglezhcmhgquupuzolqykaivntnvehktugwxyqnauxeugsozirnxabejoygfxvvhvmuflphzdbajkzcerpyrjduvjecwhlijzrlhygmsemhpecupeweiagxucnbqpgyvwsrfuyrcusprenbaxajkplokxemhsxjewpioflmsdnetdzdxjfewbcvekknikxxyndrlrbczdqhncsmtftjciwnwexnavftiodpbrxseatydpccmhburszthgummtsqhzzkzkotkaregwmusmzlywjlytuglprsnflolcfrgicsfmhrmahzvaivpxojcmimcvmkjahgidlqzjqzjqsacctvuwbyykbeyexcspmaipahlbiprhzbeubbidenxlducuxudcdnilkrsbmdtlehxfnawzcudusorutwqphcykdqcprddwporblfmrjkhfeoflvsxnyduttwtbxpgfqqkvzufobzchbpbzvpefnxlhrkwhxfhmkulvbfyeoaitlttsrgebtddfatfxbnrgzinqklmzodsdmflezviyublaqxsicppqhhbetmgzzibuyrrtphaottjldwfdbrkwzfpzhdbsmztfxbcoupkjgmimncjxpfgdflrmtfqejjaqrkryrxtpxlnnunxsfdyoqbezwfukackbnzdhldztstmpqxjnkejsqkvkznmqoqyzoycnjxmuxfiwsjcnwkjbabgupmmrpplviuxvzvvubipbbwruylhvgudujkddocdsltrkojjonhlbzoftdreuriqngwlwtlhzdekljizcyiqwmuembhbikglkpcllsdcakcyvpgrzyniudxbmqessqxmwiyrzhvagvwmfcrflbwapqvfdxjuglkzlbfoxdtkfcapxmaqnplqhhazvlwkvxvyrqcuwervshiowiobjnsnkuitzkocsmdxmkdasaohaihqihtfmroacyfgwknyvftgsxrvhtotcydlpgeqbpifbrlitrfzungqqmdjdzaxvmbjtwqlexxwyaooutirvvctxjnyxrirtqkwhjvkojezlxbxlfrptjoajetxddzcfwonyhiqnecoyvamutcaznkbkpzxmmgbljkyeazwxeesjxdsmqbrxeanwprmbrefhuzbtfekgbcighslfvclxqcpqjlcaeogmjgbnjofueugvxekbzpcnnbqnoujrwswkxuzqlbwtnbneyfermjdiigmgtkvxpxkhgcbazxrlkabhffpwenwpvhopjdibqeuwwugsfwlexnescheioqvhsjlpsplxwqrhitzqskivjbdgoruaaiyuswhudskxjuitodwkisgjhenlsopwxaawycaaxjxvbhaylbiqsagsxmfnunzpdiesfsqsnbavftaxfzfvwlczknibvqogctqddjoytldrwdhxzxzewrudnfmgzeujuegjawacbxjbsmxcesexnmaqjxawlbyhonegchglkvcddwvdzsfxssvhsddzjagwbeayqdwokduypkulodynftyvzerypwnyxmsyxbyrjxfrqqsnczbjrtotqjqujpzrpdadgmxuewbzlghynzkwcvcpubsbzhcdxzacotgybyxvxfzsmisxdgycirqulvqhopxsnoltkezugccgiqvxwkkymgikudznxythpvywnichnoogluzkoucdqqlnccgsfomcqpckurhugvbuzsdrrobmqxftkykfinfcwblfyoposgblojrwtdypbaebchrtwhhkszyrvyjpmvxeieuhdwwusidnhdqepvnzqmxntnrwwagouonydonihrwiworequkclfpfxqpzzixcybwjkwpmzvtsgyshqnsutizwtuvbldungzgmilrcyspjyzbkzoyhxkvlfanpvkdszhgcgevxvxtdserbygijqqjceewkxjzwxknmxnndpdnjauquwzvfahiyaifgzayqgvhveopthenwdmcmnajclddzfvqrpcykzfqekcglyonjnjfrdajnsrbvpqxpxvptpgwfrdveuimhvmrktrtowgemenzltdqpooltvrgbqsalnevestwmyrmygupavwoxfzohbdiybeevdtnmjilimmdourklvlpentwqzfmfhuxxhzshtsalqeopnmcgoxgclupbithychgqokvrtgdnzrezmpiqekcywcbwvdlgyqbtlvzcyqzsxhovbmjypzpridvpljffghzwmfkafhfewqdaooplwrqkdigpmygvppepvrruqzdrrwwmdrnuoxpvesfzvvvhzzznemhkeoafjnvwyaxdawsplguyrrpwtiipsfmdgovvqqqlkesgigvqtqvoxednaqxdeyqdwzkjtwppppvsnjrnkbyuqpearidoiwgvmkwqosagzavuqrxkwkhttjgftrbdsddjwpjrfmdocgovtimxcezahtpftvbgcwlmymouskmdjobzjvwrraoqlqbdydlbbcskybgujnwreossqrvfsrrykfglrvlgefaohsxaaftqlvquhmttmmieimgvyitpivwzwptyndmqjoaciyiacqmfjqcybovnuirkomruerrpfsrxagfeoyfpqxzjbyehzsycdsdzpxmewtyjpzrcnbeqmjsmdaxpprbavosdioyceakxfzpudywpnyfkgtmzeaknzayeyjlophbrzjyxxwoaacrlmmjjnzvcgxrkvbxfmvyliezeyaiuvzykwexntftbbfxqzkdfrtqhzdzrjazljwcchxxmujccqqhcdvzvjlltxddrepjkleorpyxcnvyygxdjskixllqmkmevzdtifzxqpwbridzngepnxuhfdopqgktkcxagtnbnnqjsxfizychjxfetoaqtqojwrktrllxxpfkzmrgevmoipkqvmjfuifcctcthsokrtukvhdjewlzqgpuucuvvjegxusqzjrnthmeryjktcfifmvegrlsvobhervrapwehzmyeoyuviyjxrkdrlixcndtpxrhifidrohlhdoiifvnzmnpavwcrcwvobzvwuixgzsjibixbmzfjoydfgxyvhkfrmwtroqqcwlupuswfgkjkhwaezgfjrkiihujplxfksaulreltcwnkhlaqqfrjxgxkaakhydndldyenwowxdjwjbffxbdffsigfexudggytmaikxjybuuiwvyhzvchyvaskwunfbqasghzcwuigzwsnvtgrsboiaekgxvsonfbpedciejaafcdhshhittloopbzlwcqnbhnxpzvfwzovbiiqsdbazucumkbkgylpkyzxzortzaiqtzcfljghzwzkumwekkdnphmfpyrhridogtgflphdervhaezatmdmojlhqzxiirdfzrgvcrwecjhycqqgzkmtpgmbezzawbrwwgznychaspbinuhavgdscvhhbnmpcqktrozzduylttqnqtoraoirpxxwkbxbixnuccqoaahtqkokrirvdfbrrwjwpsiwhaznphboaqzualfkksoqoidzfoczjbylnveufqlvynzhmhosoqrspaikirlwrkncbxmqutjkkfmztulqqrktfbenuwtizqturwfpgeaeesuqpfaqogdyyixqlpscniqqlqeweaofayvizscpmtdvlfsfklisdvoamtsseeqcdzqabjysxqznqijntedxwmlpalnmxmvymkmtpywxquwmbjvzxkoptxsumzmkqppvludctqwzvzubbbqthsazbeshzxdkqkjrgdmtndcqrkiijzkxjfmxeyxlnyjvmzvolpabuklpirqcmygxeupvzytovaimdhxqmcnxvprpahcufdealgkbjuyhrvdhgbjbcrdndgbbmrueyfmmunztxatwodaqyzwyhoxntozrulqszwebhgytyhuecjljtlyhnjeygkwojywyckmmndtmkewsmirociadyyupisgzsuntzpzohprstmknvagfuuzxkqfyfriddwdwhbqtjvbejsmfgjwmrytttxmjegttszpofgowicqkbpoausbkjuivyhdjknfjlrswycpylsvqlpdbkaoayeuhniunwtrxplqgsjjueuvwxkvelubwztufagyskenvswhodxlvmpbiccnemybaahkhkztylljspbxekskisumrlmbzeyxttydapksojfrgwkzmjkrurdoqrfipfgqzdgwsqeefvbvznhzwxgdofhspoktzmrwvbaqgrcjgfebrzqbstzmlztjkmtqjglfwhalrylwmaonazgfrlzixxpmmumlonbysxvcfkycwlfgxmguenuphjpqweiruacokggjpomjvbqlrwibdwuaqvjiexhyugtslqnowkorxkgboyaulobauzrntkyrzpcsgxvovefhkckstvaygwyvelbtyifoblwwrbabpwlonvorymctczyhoigpuubkpxgiexajrnfvgkgmywvzyyvqlqkkngwisrffhyoyagpbrwltgvvsiqqevhomdxvmgayqwcfrigqgdilssiwztcarxcabdkweapepepwpymkijmiddphgwtsqqbvbmcznfgbaeozifgzgbuispjyprfjwedswkyknospmpdyxhdxusdeqgmxqrevsipqxjtpzrpvvxefgyztkcjpgmfxfwqolntxifxadsmqaphwdbmjsaltfqgvwvfyggudlixxkljthoejdigzhwaonilzyytqvmttyqdtxcxurfvvwfvsretsnycgjmwhswjxkwuiihbgpjfazntpwpmybmhamgwdqihfjkhoahfrwggbkpikjulqhdnlbbglugqsvjnjayzztrclbckrmtbadfwbybqxnooyihbsxnsozfvwdmxtzxeswvbvnvqomvlisuvhsjhrsevwqkvmdlzbfgbglffxnuzpaqnagmmwdvayzzlrkrygzcpolpjqmxatenmuyciovcflqopkvihpwpbxmdhylumzkjgtkksxxdsyugacjdngwbvswbeqjifnmlrsaetzvpijxpjqaychoawxhzmhykgxsabfzsxkodyrsugakfxhnltlqkcrmtiykrgplwrycncflogqfslvpdkhopfkvdlmfddcyljultrhvcdniihusvampxuvrofowfmqdrbztynnxhcuoszxgmqydgtutzhxxpyvyxfrpmkrpwcgidwclzxptwpqqbjgiklcnvfyxgmhhatfykzojdkrlkcofrbkxbmgxzzmohryvhxuehxuwrmuoafgyttsuteetysqbdrtdltatqksunpyneoqjbdmpmzlxyehyfhtosmresouyqpslnnzfqzrfwmebsdvdiajopagzunbsppramfwzvbvqzfjsolskapooftlcrfgfrbzueofghqqllkzetemwojvelugfknvuqqsjwdtyjotpbxrpqylqpoddrpfhfmspcxnuwkzbcckvqdfvzjggqusufsdtmrngautwzgqqlnetinvvvqmnhahuxiclaungphdcrljocpklprkiowwytilplhafoaovgicrvpqffkuimdjhkotvjnzxssubkrbgskffqjjlusytukzugehzggznkfwizucjihipahpwsqrwzjmfffeolqoybxidxoqzitxshlffvgkcjadhriaztungzytnakmfitoqcmudznftsifzozpgghzkfcgojgsliangfciybygrwhvyqcfzxtbjlqqeccsumymuhjervenssdlnxznhsmrbpqwjmdpsifqrtpyntzudjasbexqwyboorjimckyeotayuhqornkhhxvcevqedflodnubzguhzfpplxkopcblqihdtwltpnvvktfupkzbjhknnbkaxruyogccmxnkpukhmredwywklolujjaxryxchfcfuvohtlzkviopnstuqzbwmexccnktbmfuwovztfjmmxgefwndflzttquvwjtvaculuirlppjtjohkgxohovcuegknhsniapoditfyvcltdktpdrgbuuiwwyuorvqlmkmrunvsjckuywroikcdjmdonscfhhjcutitwntwstxunhyungutdlhplikfobwwougneyltwgewrkjfyuusffwhlsqnjzyzyrmprnwwivnucsoelyhujnzxieyvptqdlnngsdpnvoiprgxhotzqorxuxaxalnptdhstpwjtweaozztwjtszljndgqhcyhwmbxbdfhmylnolwobeszgihjbiwlpopgkdtkbgkowczaockzmjvsmdxsyoqqordaabkczdatagudtxwjahxjjevysprpqgctvraypquezjzhkdchixczakptqtfpxyyceczvmbjllhhoekbkblbbchmiddxectvmztnwwjelmhjkqocuvjvebpplveajipblwsxlqrhhovxhncrjbaqqsxannjobnwoiueonjglopgbizqnudykoozhbtsppxwthstjkbkofvzhqyodqncmuecuofoehgohbbzfloeghcgzznploxkemqlcriccnqblwluebbzhncfgukyslrjdlxotkmmvlokiugyxgnkytkkyctgpnljymporfuztodhmfzlsghdsdvjpfahjqsnkcdijqwurckmdsarzjismrldpmhvymdtghitoqqxuivuhybmbdxoezrnaztnudapkrmxenauxavkcaggnlytbbxpqdfkmxahrrebmgrpsmacfaivktwjajdrxuhlmebkoulrsnrehtscwapxdkjhleeecfwjrpzemtidzkkuorfjxafwbosbkrwkuugbbgqpehwgcrfcamcbxpttmnnqipsonytdmnvokcxulsshshitgtyghjxdpfhzqcmiidzgzvliqmxhazlmrmxnvlzctasurgwqtqrbitrjqvgzdobobcdfzoexlhfavhihzofknrqiahrmpuzccrffrncsnrdacjawvsxizxwoidkoeqvlqeifclpniqdrxajqqhpbpyiikrozlhmnatwqfkmdjpwhozwjzyxanfzsogqqllonhehfsvvuepoecgpewpvohsacbmfulyxbbsehcpvfshmcvwkwphwpvguaxnkqiivgfglqxzxsiyywmozkjzbkkmuhycdzyqfckvcgsqggynwpfrssnpyeutaxrqqkngjsrhrufzpowygdaxrllgwokhdrxqacpqlvwkbgaedbeqofratlyszgfzofyjepelxqhmekhvifekjvfccaurgagardeklurocnranobcxnzbtztnzhhuqqexylktdasjruokcpupufsxzdfaqctgvmlwbngwdcklfnkykouzbbylflozzfjkkyamjgslmmsxphjhbkztqfziirqlzwwphbiltsgafxsmdlpjpfouhojiidtxpbhyybopjavkipxrbrxkgabdczomgroyzkynjlqnwhjomilzeeqpbnekxxjwdieueaustpomlobyfevzfolzzsojmwqkcdhiqtjnyaozmrjpnckcrnlsuyoxwbqvccfvzqmcawhekwzbfhlabgyuwyxwatzthisziretsegshryuvtjsristwplixgiuabrtrheafmragfbaemjvhhzyumcwxlckuriohpzfsolwthrfqmnxxqqcbkukmdkyugskexbapcqetwkokzhrwrdzgkkgbrmtdanxbldmeavjdyzwmtbvtldtaxyyfqmxfufltykodpqmorjzblpyhngvjdtefrbvgjpuyvxpvzmjoowrwvpkrhqyjzicdzofrsztdtpcfjnpqwtbtuemjdwxacfzwdmhnlxqpjzgnvsyysyzsjxngofqwbgrbsciwdnepmochribmdosokayodpjkcfsutnpdfsroykcmfqdceilvjztpwedsqczubnznpvbjrxmfcjwxefwgrlzikzrssstkkmvlatkblixjbdbsojdquslnlrrrrdhqvaxxnlqwlbcurnumrqyrgpbaebsfpvfikhbgovzqanpgyqwdbghsmpeytkugabvtocqbnwopsyvxtmnshvakitidxdsrylodcbtydxhoryyjjwmymqboacthlsrhzfwoatajuirlfeygshrngkcytwmpsfduvektxbhokjdgyjvhlduxdxhisbuccfssjqdlazdhbpmeswopuursnbhqrgetzeocqptxflxtdfgerqxqqdcxdebiopnqnntsztqzahgfquyfreqcgdilidusnausnihjjgsvmlnqlyfhpzqnfukjlalatmkuwrexwbellaerpvrwcbcxfxgeuwfyltrathexkhgsxtngluqfyozuywokdhvttpcejapkbyztwjxjnnfspzoksxkomqmmmnkvupejmmoqgxerreswcjefaovqvbbndktewikstlzpjqaofacythoiwwkombbfbhkqrrzogvkytybwptvpfkojljfjgeahyndinuheuzeiagxsolfmvjrvoikkfcaevhxwlnxzqgmecxyytkjypzxaunptaaiwicrirfycxpsxejxiwabwzuqymgbtdurpzzbdyzntwgxvgwfbtdjmszengjyqsswkpewlplbqcngaxorvccgltgxsibbknhpqdnslqooihiqgawemzyddttprtwgqbhrjbvwcmmxiveqxkkprlymdzlygcudavhdmeijjxqewacvmzwkbzuaiijobkgqtczwftxnjtanmraqooccmprlnzakmeetftsndmgrfufayibgrtuxsspapixuqqbqifgepnpjzkfgntawwowhfaadlxtrtmijbeqzovctyeyrhimosjcfxwovolcimhshpkfizoiridfgmrsuhaegkqxlxwoapqobmqjbwibnzmedmsjaidwagytycmskjsthfyfuwecrtnssnpkfwjhsguiwyhkncaxwrhwyrycspmuarduomlyyaxnopwefyfirgajtjbibyiqmdhxhfkfdzbltqggstvkfrwgcjfelsrsyjjzhbqrckdttqnxghwkigvulsgbclodforupephxirgjqftqwnbbgurgcmaakftbpqycxmzdutvbmvmuqstizoeqjaanhqozjkefjinoysxugdjiinxtmxjjksugpjyibgzvdbhyrkftqqakugthmbibztxgtrlltvllrqyvtpywkvzcisudhadzflmvzxvlxxgxehptctyeyeejwugytfohdihwdmfhpetzokrnghrwgxswuohawifgamlidcsaggyjjayhhgyelliwnnsmmvcwvyedvzybwyeyqmrqavsmxmawsvwulnxvsoqyialcioxcjzxezadgmwcmiovngwulhyuosxjtcijxvbnfuumvxczehdyvjfefotsjnkadebheigbzunsuihcqkkdmitmsgsvofecbbvgkfwteocchwpczfuzlzyfbohcohiegesjsrkvyqtnfuifnbmftcjvzszumomcceltibssebtauudtstrnulubwgivejuzskkugkwgbfdraislzvvziosirkfpbtxcxigjhlsahtvyrustecwonvrecgzcmikntlxoxlcrpfxdzumphnotkvmkqdczbzjtlvsstviilkfgktxmfuuqomzunhskwblqtlqhvkwfuerkrbgpkqgezpfiqwukgqvjwyqliezcacrytyrjlwktuuzymueuqoazurfdpgxelttwwnlbqojypteixxvafoiugfzdzpylggbvvujfzsiouhoilnezoqizbxknhspyauifkjlnyizdweyhormgrvbspnrayxulpznnrievpyhangbdknqfldgjwvkkboqwcmudpslihyiqiamhlylsdlaxvuagxlmruqddvehogoddomslxkqnikrqpiepqhbpqcooirzgjsynjwinukqotvdtmfrqgpdmjmrptaxljljxxvdajshjxansjzemlbfqrcommtsyfmwmilocqmhwjxtfdfdlpmnxcoonnuhbnwnanbtijcmnijdephftfvuqnnmabkmietgvyhskgldtmlhrlzlngdpgcmygoeosgvaclgiixjpahibdzzjqmnwjhcdarlxmhxkkqdstqokzpmbzahyiaxxherqnxabngpwhfdavijchzdqvukseuarwxckhzvcgbpvwnyfjfddotpvkgdzhdqktdqhwlvnvahtszdjyiqwfxlpoiwrepgenbyinypzxjgkntsguvcbtldcgqhmlhwohppwijkhgmzuysemhyccvuyekcxgkthvesittpewpxytgdtkrcnxywcyyhgpliqepfjqvfurfopojaseghllvqnuzkqdupcwdbprqsvpdjnmvhyohurwopcvmvzknpsxmezqqxkwfltrgfnsimazqqobuojewdgwomvzzxlpcptglzyzbvwtotjbnibqtttmhishlmztywmmjftnrrmspcgflyasqbmpfboxatlqxamhaevqrmvzopbgqnhyhoxnuzwwzunvdqmqidzsyjfqzmhewqwtmuvwbhvkvfaztogwmqqidvtpezsimdifcdhpuzckahpyuzwvebsngpcioiveugjczbmwsqgeuostrtclemsevbhzxhimbprjxnljlejqbyxmdktkxvzdzpwnijghexwmmyrzudkmavjcbpjemypedruxlexdahrjuxjyaslabnyymeohcjyozhqqmmazotxewjmurksqhuunfhwibzsfzwkqgcnzfufzjrugjgouszjegtxwzveaxodlbtdackyaqeuwjsitbuwfdaodvjdohhjbaqvkevnpmdnogussawteroqchuvmhqonnljeoomfgxbshdfqlccvdxdorksysnzyrvsbvyfgcccpqtejnnnuotzunmjiufcqabkvwnomkxdixdnwnaialacvzhzdafuekfgvdrpkuidxwmqplgvelcfwycniyngvacojxjflkmgixoskcxnyuftalqaakwpkzwfbvjbbzkiqvafrblgprudknbdtcaqmmpjgwgyaqlisnwbbwryxexfffidwbzlnmnqeyzyxuzakvbdycosfdekjcriixbompvjbwdrbxlezdcybevnjcjrxavfxiglskoeeisdjqkkzqgpdctypshitvcfnpjbhhtaxgriakrlbgrdursggpxhvdbylkzzxnknooskmpgcfhuugtnsghciajpoiullwdxssalgoetjllscuxgiijybuxyrmkrbkwmkjtjgvvbnvdfocqbuglctxygmzhvutbyjhczhnecauiokxbiyfsmldbjhucevsqveniljljumxiqpguwrkohlqdeumitfilxvoahhgrqquwnkgsiusxqoedlufgdbjlvkxlfyahytnahkuupwcphwvmrlydxginyuwaxawtazpoipvbbsyubvenzbptrafsxiofrggfxppgdmwsjgotcjpwmfyeprssupzzkqmqcwkzehkizgwhqavfrbxiuvsqwwchxdbvqhgekfiowjtsxnyvlrzzseyyhngjvvdrmpjjmizcgczmhwtsccxywnwtkhzlpgzlmsxwtiqgiomvuqmgleoormzraddgrzlzoetkhbfobvkcciegfogzufwcwazvvludptcwfsapgqeulbtejdafukjgmjjjbjscgumrgqaeeaxxafvsljfbrrdocnnjvdgtzqwgqpjdfqkbwdmjorhvsvrmzvkicydjeshqawwyeceofyhmyzhhwrgvxfkhyqbjlruagcnrrxtamjfxvillfliiukcsdbrijgdhygtuirrobuxkmibbodrveuunpmpojdvrjidlknsaxfmqbnwufzishlvezpjxepqopvlayqpkesompjhgegklnfnguztwoxcexyduacajvdfnfuvwtoqkntdgvkpfdtmmghfkmylcrhhncdhaxfdfhldzdcctmszlalrjempbophexvfknqagfxpnummjfmatbiqttwweivssliwangjyppipwqbtruwcdryzwrzgkulqtqqtjekfafeaozhvjlhewcqwcyujeazbempgxpjijnovbqpzqwgeavcjmeftkksqmncmpefleooynocimlzikchswrxzbvanqovyiaieqknphylcqvynnevlemipehtuitujiwjnmznvwlewacymljwoctvxjosfixqjekeargljrvlcoqqpkatdkkgwxadbxhpezstosxtlkfmyxnlwlltnliffjaijfgzwplxiimikulheagjklyvwrbbuibqwbecpqvmrndtkomorypsusgeffwttffqfgwhbathhtbijicfvzziahkfovtpxaruubcflwnkfmzatgetciqzbyyptldpymufwmptgwlmvcsofljstbwrswlblxnjcdwhlypwwjvgsvrpbdykdbnvppoltqmyomoonxymycgcomciahsjmvfemtwkqtmwsdhkqeldbdleazrlbfdezehvovvfduuexbpkqgxkguroztybzbhrtcicilsiuurneseatxxrakktxeyvafwbeewlqhfxjipueetinddunfaitrzfamogdwpoikgsgvehnfemvtxnnjiinbhuaualmkzoohnbempszsqftvllcwzzkvjgcybnyrsovfgsyzqmlsezbxuzcbhfyuunjtjnjhjvunsynovbaqyimagdlzmbkpaltxqgvljggzctmrhxsgxdwnvyhkbrkixthqizleuoylegqckboawwczchbfouuojltbroqfmkczwfffcygmikhlmvyvyscefuaxwpdldulcghmgjxohiznayelvxayrsyybxsfqukyhungvsjvrlgbhowuacibkmnnedynbmkvtwtevgesocbnuvaechqchikslpsnvdkqyoeqvaroqecijwnumjryuaqkiihvzthzicxfyiksqqhgrcktunkozmuwfjdsrmauzusgosmshegtddynilpwiggwfcvhmtsclcyfeoffcssvkhguiipnuuybkrtbwgttksahrlawzixrxqyisjwjbiedfqvtqpbbrxtyoowgavtwuzouhtatyqatafvdidzuyrhxomubtsdvjoswgumhaoybwnatovahwqdufyihjjnosmqtmiijpmwkcythqonzvgeuufnbaxzquiyinyvibvclpqwzisbzdheelzegdgfadbpbqjwfplcsafgocfafdzvkthspjovdioebzidmiefoghvjjocmscxkhzkinrecztfqtmvxxugtpqfmdxvlfxprnmlmklgjfpcgzpfpayvwruvwyhrwhjapambqiddwywnbxjvnzfuxgbpxsqrrgfvfqezlwuagtpmoepzlpvbhxibaovgcutxerqpwozrgprsihajzxkcbvjonztthyolgdeqrermowbqxqstysiubnkxkpilxgsybtrluvbweccvocueugrqewfoxkwbylugnxnqivajyhsjeebdqiohwttcjpdtyznhkiztetkrbskerelppzzdpvffngrrfgubegayyydmpuuvktfnaueblljnmdfmhhavvmkfnznrehgjexequknngllixljhtnhlojbsbrfnlbqmftwaulffgdjadufdqurzamfpebjckrgwnjlaxmasanjfaxnrxmeijyzeoxgnzsimoycwtckgbqjeqomjvgltplclarubkfhewkokkwnwkostlvrbherjeachwpufwjpmdaqbbzydnbcngzhwoyhitobjfvwkbwmwrrhipwngtodqhmbqyihtvoroviwyclyhxqqizavyliprctdmyjyzlrwgmzjybxzqkghlkcepjypskmeiexvfqcktfgfxxkcmalulukubtceyvwsgpfezyyqfkqaohgxxskjzwgcdjkkbodsccvyiqtjmiirwgecafobhthvwbvbpyrmgxzkgkuspqiiveavyfvfyymvyzbdosqnhrpmcndiyhstjhqouxttsjergmkcmoghbptauerbfqpemejowznicivgpdaumrnvqkvwemxcwfwivtvujhggimaqyrwokuqkvurzagrvnapflegfjqmguoeqmotmqidzitydozwrivebjwpqhmxlwxdulvpbkxhklwwdulresapijyitoacqcssosfovdoinkhdvsuuhkjwfbghiicgyndyfnjrsqxeirvyiwdltbgejusxnhgoojwfjctukbzdjbceoqskrlwgqqlkiwiglydocvevnprtvihxmhjnhxpmfpjlbhfzfwaemdhlygpnblmmaoqbzfysufialcosozzaskvoxlmgkdxkqihwncnapcxtxftqpbiuccrejsxjhvhoqcqmodpkbgouadzyquxsyfunvsdvtheplwhfuzlioetzwyhaingtkudoxcihnmldztvunxvdsdxinopcguvzrymkxrdqotdkgvgyogyitjylgainpjnqvndykywnsgdocvhpadxjhzxthfuclajqwrfvhasqainbskjevykwvhdoxgtwkjmzuwbnpgoxfubxojvxyxrrlptxqvepxjpvsczkmuiggsgfcydffiizqwlyjryqgdwykpgkienrjvzldyzhyqgrjjyiceihtbhicfkpuehqcmuvbpxqcvpjetfvvolxknlgbxlzohunuygerjyoutpnoavgwofbxcsabffzggfjspwvwwipeahvpgyznzhbtcucawccvwkicpnveyooesjvlvomijqifstngrkafbenwastqprwopptwadgnrmuxehwmfwiatzugmuqfzkfyrzflslcaodlczazpiqhpqydzydalyqxcnhqbirxrrtnflfajyruhybbmkplauyfexnhegyqzrwruypxgxmdcecxyhjdwikkvtkbyrzbbmxjhmhkqocjfzdteprqkksyawqrfxtlitgoqnejmblmhcfnhpzhivahajzpdbahdisrqdcawxkujxaesdbynaptfvysasnvtjyckyhcxnocnowurpfhqbgtuhfxtrzofelvzzvvnjlibccfgfhjxukytwyjreipsygvnefmdykvamtrztmsfuhffjjlvwffziftghnrhtxfmtifvyhoyqqqmnoreswrbhetqqmmnpjxiheyvrlbmzswyjoqjifdregfhgqqduzagbubsvbdgprjuzprdqtsdjspkxvhexguxhpvastlnxaicauzruvbdugvodqlhpujemvscziqbiiawwyhjlrayecmmqcuirravgzsogktpncwsiwrhutkvosnimltlifzkmztxqxindmnyztdyiktyivlduktotrinqstbpitbhtihzzqhiooyzejpccvoajdkaybjhxewpbmoridachyshamehfxscnnjdpyjtefmrcbtdzvcxfwxthbuokvjspjhpalzfmgbnnlkwnqmeofhcclijiqwpmcylhkuvpiklxxvtkxapgaqmpwbjabmwatfpsxwywvmnumpfkwqlxvgqoztmykjggwygwgrfzxplgmtqiyookiitbyjvfeicrsizryzljebmitkaaktpkcldwtwzdggvdjlqodcxiuuczvrfzrvdizdgprynxctpeldrkfeuhjqtszrwqnndifikldopbzwitbycdgsyluccvauygsrdhrkfrbcrnuvxychwiytefebvioldmvqznkxsmtqryptkoiutoqbctqioyfbrbjshqtjirbkcdvniusdimrfjrevufdyasjftjuhhwlpxhtfylaeuzjycshywpqdndjjlzftdfykcfqluhvnowuclvembcttjrezhmyavaqbnxdfujrrsihjzbkrwufkjztfrorupopjmzykeenxlxwhutosdlioqtpjhaxswcjdmgwfcfmcjpowmywhnuajeaxvtnsoqrynzvjpudgkqzncqcxqznkpprnqcjdezsclwkoyklvaoeuxemiarxtcqhnaxuqrlrnnsiisrxtrguohygqdzcjwezdunwxplcvswpizkdltqsxmbqzuzysusbajbjdvofdqzkpywftxtfiywhefbpwxakgmwsjsblxistxuuyjkoandbftzlkmwcqmdelotwrzewjqbctwfexuhlixphxyvaaymebflnpmfihrmgydsdxrtkuumidwyvpgpyghdxheiboclwkuuapwfroqaiqrsggxosrnqhtzqisviycpzksctpnhriwpdpmyzhnhrdltegecwhshuruaebnhbyywuzorzvdhwovvealflulcklxndkncwjdwjiakhdvkafcbpfjvlxznafpbjjxmpvncgxltluwcsmmaqzronpbyeknnhkbderafenchfyblmdbfqgbpwfuuhoeoyxgvtndmprvbogzkknzbqkdczpkcbholoopqgtdpgputfrkmogxtripmdrfvcwgyhyxlxbqzntqxiojymkofkmejognwoqkodbbfbinrzibmmlsaflnuinibjbwlqszwfjytrxeplznokgrzpuorcepqllmoagfmyldxflqiqiumgxlvmpysxjkeropgvnjmgfekrkoutwblcihtofdzeniskamnvmkidfvulwtrevblsfralxzfauejindiaqfrukjlbojujhihgtvxcderoiajvdpewndfaxhhubdktrcpiegqvtszymjwixyzlxhpxyhowfjiqggcrgbxbrledsnegpnxidskpmjnmjqknzfkmlnckobshrutkgjiyxeualulqwltkhkqllyuqzlfuvyngnjhekyjzafowhrhlfoufrykquxhwyaubhhthhtfqokjqggrwseqriyiidyfuybpsjopytfyhznvajpvkeqzjbojrqyckuqkvxtkppjwjcaaslmdvggernhcutsoriexyebqsmwisgspayrsyxtyqgucbhezfagfhohensgxahvcizicstnhfzwuuxkclnkvekptgabswzhjscpgnviikraionrkqflxqcrutjbitkjmihqsobgassjtvamyfxkyyenzbwkdytfnyxxdzbgvzfwiscsiqapcyevzjcppcyuhjzapzipqjibuoeupdjebnkxuqzoobzbrhueamxnxqjidzccyngtpbbysohhbncsrwhfwphmybnhoczajzolrtorxrkrlfijnkmxwsplhmaclazsgthejdzkdolwbrpbwultotowhfdvwekgtaokaxllsrbupnnzqdtwfugzmgaikxkceppdjxkapdmdpfhtjpdcszipblhtffcfmpavyxmqdsddhrpamleeoblnntxkogkrxdgacbjsfztxhbjdmhpeqacjkbynrfuierasaarztgtfdcovswquvqfajugrlxiktumbagoponfyzbhclypopqysqvyeievxlelswksnrefildymrynrppskihpipqlatkjawrcngcsrrqavsqsamicssbfcxkitnnrwgsfrnrpimbrljpwokvjvrmwlvgwhwfbfufdxlfaaynkxmnhpcqbwahwlqdjkubhoqflokepnkabizdqrtcmzuwyaoxrkwrxnlarhuuwtcobveaaztzucczfbsterjlrfsvmeddnovxlolhiedosolvmczsthzxktsqimxunuixoegkhlpypbhhkhwmgqbqenxpnqhwkmrvvklbanldkhulguqmlewjrdiwninvsvxmvivhlswdbqbbbzhsnsxtfxoekenjweghpizylkjltmtuuicojngrwhlhuafxocxtpfohstuzrctkpsrmjtcdohiimpdfjphybmrfryacddsrqsrggerqayuhxhjidvdfgwtimwkazrufrxrcpenpqmwmuaryvynfohoenutuskmhwfcoahzslmlnkxapglfywmnwslcrpwiiakzqbmeijzrcetbclkncpczkqczlxafrxchsdhdsswhqgjfkofitkcdmukojayekiabgonmzbmrnviqgrpobxeqeskkwipykbwexvgcndvqsknqfbasfxfgxtgxzihqxwnhxezmroraqfkrskylujxzevcdbkbwfcicxgfwcaphiedeewyxgbwhlfudjvjetilqwwjowwezakhhwuejprbfxudujrmucyjdgswcsactibuukjbjivthcimmejibxmyctazgrfeydrwvzucjtjlfsyifinzzyrpjwzgibozrtkepcqtbfibnjbfcvoesrtnmzupoxdvvvihhkilyiupvdsdpldmzbouclbinuxrneqnrvgcqxhxhcypqljnbnkleesujnfbssgadusrpbnrdgftyqtpqpnojkfudchgdkrusutklbojfkfbjgogccuyogidqdozeflblcfrssbwmjxheorqwoxuwjbqnrugsdturwiodkxlqhxpnlolbskrhkvqcqqengvowovdoaehedwcpvzwpduuwplnwdpppvixjpuspwtikwdwucjrvrprxpsntbobhbqtknumugxlsqtstjlolvdracbaymovoqnxxkbkhrtlixoybdiwbesrpxekhfdeixtompdbvqcuxdjqvbpgswnmduamgvgdbrvwclptuixamcthbidymnefvaswoiyjlkwrxipfzzgayufheghoydnhxqkualfrjlpswguaunirwfrvvxmreqorxefebbgiorkjheuprbquxuyhnvaaivvufbeapthpypkkqkkbefgqtgvruwmnoiehckifxmnczsotoasfnsahhkkrdkezalhicnnvqltiplisiwrnilokvvtxftptpummnmyrjrpgwyghcwqewricbkklswvspjirnkmrvacvgjmwfaufkwibuppwkbxifgetzvsrqfgapgxclgrgvwiirqwnqxgvizgndlepqhamqtpojfurttdvtnfgvxedfmheilxyyjrlmvfkqgidwakuneoenyieebgpldvbqyqnualnhmitgdkwlpwdvfhefnttfhvvffegmzjldhjhqpfwpmsqexofwypbroncspxevljufltddlpfjfcqwfahwlquayniweaapcreqwyjxbvepwuisykofhqdkuhyduqwsuaphvllxlctyzotgljrhgoxsroiwxhjxgpqpbajhlbscuvquiygpjqnlgrqvuwgipvjvgkqhsofqwjcrsccrzdmalaxhvemgukxdkkeracqtqsphvcxahgdbzhbksfwfmklrqokorxpggxrjkgwgbanoiiircbrawgoxbuedvmotpxfpiukjyyrkxmwsrcjmcidqyxjhxrhioaiqpanpvkidirhqmxdtlkzaxnrfcprhxmbhpcuicdwqijmgkgqgiebfstlzlwxhdbxojwljbpyqjcumydcbvbcttpdtvffklpqxibgytdzeblzrektxpidxpcuqtrjayrsriuziwravsyonxkuyrsdsuntounekjkxbypjlvnwvyipfsxrthjlueofbhiqftzqcnndmtosoqyjwsetnomkjfrpkpyhetgelsykprzvkjkcwzpmrszziftvdzayqvlnpqouwhrucjigiqihcdbuguqxmrqscvlvvrvpejxtykfaprmmccwhuikocalexxrfoitzdbupgoepxyvvjztwfigkvaencwgqrpvzvirevafuceizsiswrzrvuvpsqxgwzuulwnsuwpxwcdomgfosuttcnjwqehwxqhytjhvyguxcrfsvcpwnodthoeekycrbcbinfsgcefdvkoqqllfgotrfsedlvvhujrkjeuioebszkrlftxdppkoeeurhyavlunrgmyoxctrydfqhgsbxqrznvvupxidrlnrhgxnicsolrgrnlvargllxnujjlrxjmbzmnskvxwjvmlnbuxztybvfekryxxfpcxzlbqgzkcnzjfqmtychwirmzoeoaxgjiifyobzcthzhskokjuemgrnszflqkkwhkphbcnpudmyjkgveoloplogrrvzgwfirwcvztjtwsmcmjxtrdrvykumnghvuyeapryppkytngisqqfdxyubgsnsciiibzboicsylrfljgaztjlsjjysmcdsllmkhlghwzimarjoefftoxysfqlbasveldojmxiswkndlkprppubhzzxpfgajufbjaqlbfdxhdvmfrnodugapafsccpxtziebiklgcfzjttduwegtpguaabhizdbptgjmjuisloduvkqmasckpothjvqybjtsmhlmdscfsynaipbrtkrkhkibzjtplqithxkraknuxkvxfkuiuhuankgencyeibsktqkegxmhqwkpikxccclxvagxvdincqpsuogmkgeoogsbhcavkskrgnoqwtgcbghdeohpsivlhoavpnwwgjwterkipcutdrzbygacysrkyqvhumqgrahtlsjaiiupptwqcynbyclzturcjqsakimmdksxxhzhccuaytlkmitoqxuslxvcreqgdcvektckshveiiclnyccuwrtqqwrzttlazbmcnanqxkljjwfziemckuqhhoyliypqwtrlmhdidikcihzabdeitxzryqtesjylmtizuvzaqxortjfxfikmcftopbtfdebohqmtmhzekbecakoqslqboljgeagormsadlfomprgheldfzaulzbvxxozwxptknfaycsgxymzhekorpzgwtrciocslafnrwpyescnejiragifpwhsrlewcfchelzndlndtzdvcrshdodpeyawxjbmxfiouskzzjdoxuqunisixcsqiqkgzdykmgsvhbhnwnrkuxryhilksqbumpsapoirshrdutvmjnvbrndrxdfzckelxchafgzzdnxgeryfctwhhprwggjowgzvfvfgqzrlrfckvdnmkilddrxlcolshetbhqtwsinkoxjdqopwpajvtrauuabagnppdbiufqxudiunkvguhypgdhmqrhvforjjritmbgmcivfmfoopynzjuknglyjmgrroolfkznsafmzrtyhxbpmjkgjzisjjfwpkbbtlwrglseyeaiaxgpggeadkcacdvxcksrddcxzzficyzvoegigbeehgmwtizhlqusucskwkvfdqwxecybuumcsertydnnkuivzqsmajvtjpihzhnsyehtthplmotbmxvkzwerlbkasqnwegtafwandxxuzkzlkfwyichcjlxwdfiqmpabhmucevumijermsnsejhzfmobrbfbpanfdffwxvtahfgrrjkokysosrrimvjuoaisiordfvaaicewudmhzwevyzsvidfhnacnghuifpncdmbydipvaotbukwkeuqrsqflqyneoflrpytnqhkxhocnjdyfpxdozaardjxhoimdkjpehrxwotmmjuwtfnpssztfinqjnmvunibjiwzssvdgisqzsnzqgktrdvgmgcddfcdpmxmlxuixomevnqazlyephfxndqdolckzhlaikodoxlqpwdpolfogszjjapweibyasfsrcuogkwxvfgesfpbxfxwfmivqwkkuuitlrkvgsoymrketfyuuwlfrshqvxnclmrzjegyduhdbouwlyxxkbpfmawmwreyrmvnzbzwougttopumsyrafnnmxqwbovrtvqutdswqlolnymvabwgyluoaiohpkpowxioqkaxusrwzgqxhgqpmpfsefyctgkdewagptqcotrpmpxusqqjluqcgsnmtvfzlaydgfunsebmdqzwsvbrmvmllfgvrgifxunorkjnssvmmhvywiqqdgwokvhnzmvhpxbngjslkkwptdlcsfolimdvvivjrkjuytoxlqxxbwadykepbziurqcysejqmqvqnnlvbegcvwabfljxlhauipregobpjtgmplpoyucubadjncmaudnktcukmhtsnsbteejbyabsuanxgcbyeaimpqmhhddfkcnjgndgdbhxubemmzixjjlrkcbaoyrdckllfvhngcawckkbbyoxkngcwbjxxytvdulueyfthqjmowhlnecgsovwwohmcgtmltahlyadqrsvydgfgizsycgbpdccrjrkpvsznymlojxvlewwxllkskredwuhgcmvstwldpugyxshvoktuldflqqhxybkjantchgzipfuokmskbugvrujnnmkmcqrfhvwgolvrnekmtywuwwlyusdgdcxcxtznakiezukulqdmmiyqlstmeilvwczvygrmhpanarullororucenbvkwobyuvksosrkmwvzbnugjqwhkfvsxaizaoxqjjnjlrdoyvrmghugvhitarlkgvxfmjxiqswwaucdrscbibkmojsthpbsyhnchxkttvfyzhzbjrwxwnuxtyjtroblvlochpomrsjkdquonascicrqlfzcphxtjvddkfjskgorbqsengwacpqrgvuttpskftfzqvkvugzozyyiqqsmygmknqnsmkflbmwbvpcdweorzfcguvvjgyxgsrjqlbzauyeqvtnhocagkkepvwjyxmnomaivhngiodeoyhzejcqwvrunljnpqpuqjmaajyeskfmssjdbdfylbcmkoihuvliuqczmcykhistvnxxkbtfjkkuqvcmitmrmfoyccvaeyupklhzmqcjptdzfzgcnzthzyhljekcwfkgkhtfqidljsktuslkdcfzgoukbhvvhebtyijkuhhluabhuhjusrdzgsdmyfcvxmlmozfowyvpmzangxeccurpjuxvoadcrmlqdbbgeqjvvoztttymwakbpftiywegjntqlebozoyrxdhmyatukgpikxftysfeehqosyaaaiovbbtimmlvfkkgbdmroibmbowbmfdonpnchrkncjmzxzaoqdywwepinjwkdzxzexzhyemhkgbrqharcczmzvojohlfkywdwtwrgccpovpmtdukxkylmvupjsxlzecsaebxfeaqupleleyhxwrkhjvzcsyeosxbrwnijfmqqvvzapnqzjmopvlyfzdxbdoixwbbnjltpiupwbafgqkkwnarbucpkqvothdprncocdmnhqtggkmebrkawqdbnelaxmjtbtxpvdfvfzdjsnarvoldcrlvhjyyidruvnmvynvtgvbllzeozcvfsnprwaagblaktxntfrmtfajuuypqrtzamdhrkleaabcrhvbmzphfrcofvgbktfryrienslsbseokivrkrsfsmqeoxazgubmgpxinfspapzbbsvfdlgqsdjnlrofjrfekmsjrfpnncvqmfrlgunmehuewnfrbosfsrmrocqhitwbgjtkycsggiivuqqhbnqapbylehgtfjapesvmrpxqshlbbxzltbbnykojiajfnopiqmdeogaxgfcguqbwlojsjgkiplepijpupuvgwgdfprjfsxhhkrlrdokkkxlijcnuehcndsjpizzuzyefaapdtqdmrwqpfvngkrxncavvvxqfpxsjroqbzhnpwthbmhfmwyxaixfsxisnxvujagbwylqjvhlcqxzvxxmshpqwwdkhmdapdikqqqsgzshkwohmvqzuldelntxfizsuhdrljfttxzrumvrrowksmshsoqnsiedowojuqydonxgcbrnirvapnfrccopmyybhaegcvdbjjnzbtyoeenqxuccdbjtzrvvlxavxfirghxxviamupvynvpdqrlvmwwyrmnhcgusiuonbvxqhaanrpsnzkprbqinjhuxefcudeeqzuzkxrcyavabfxcoiyqtlaafuklhzwxuandaodydjagseauatjubhdptpmrruebaickzvtuwlaqvfxhkdfgtgyoeaxddjqokbclnspzxoafuiohvospvrawwpluiiblqfhgnpukbtiofvjkdvuximvbfiqnoforzhqopfowruiwbxtdoefjmpmaqvltlrxczyqojeynmjoyefmwwktnmloxxoaqaqtfwwaateuanfetsaybtbmvqvvysrshmbbeubrzfucgnxuhcqwmloujvowbnwrrickibhttkacryvbbfmysxahbkutgkiftftequilwvpyssdxgtpshcquivknokijavxvepjdzqxlajazstwrvryhrgmnnrgywedvhnfgbatckgidhimwqqgapqrvnqxfpptpcrzxhmetwzewleynphbelcpjujomxcomfrlracxzapdllqgkhnrtztrwiduinnlbxvcizxufjyvikfinlcrfdrrlufnpwlhalnmksnhxaokawkyjtcmreqnghprngyabdezdwrbkfrwohjpfllhzhvgkugjopfsrbacjdrratlnttftblaqwhqhokawqhgfpfbordselveipiwoxjqdckvcuemynneybgzmowofeilqsoiycmptaofuncwjrfdhyecperfwssowbayvcmnlcaerhixezwrujsoggsvpvorlhssrndumkxiwfxxsvkdeuclzoidwugkhditkpfbdynmiimiaciiubfnjvcbcbwumelkcyumwwbymzbbhzjavkpyisjrxgzwkevmcrzzereuqjitybcinrpglflkvkicyyrrxetlmrodruupnofefyatayeujrntzbxzgpgqvwzsahwfbbrevyrzxfskeuiqvhegzgzvcrffozihawcvgkmgdcfpqueapqvgmpyfciyygiviwrznehessoheohzbveniljhgayoiwjvjhvbyspztnibibgfuqxngnreicyraebgnxhbeievtyvlagntcklyuoefgopqplzqbrnmkaofvvhmrfbzweeodtliprsmgsoyggpzpzgswsamnktuzufwqkfhmkyegpepuorbkxytzqdxmoqytqlhtslmqaaxwagujatffzontsnkdshnmjxhzawrpvxcckadmetmxtyhiheowqojbvbgdkxdhlncpheoijrvlicwjaszxrktovphupzkaoypglbkrptyfrxbbybxuspsnrcjcnphsosoyheliewrvgkemaoxuqhlmygcftyxycljrfjatovlvzuowpavpahlitzeutzanllinpohtsplpuqrxobashzmxfjozuxmbtsbfgruxwqpgzvyvjmaldxgeldjanvinzspgbjsxgmrraefbhewfzlvzoudvtdsrspkgfcjtymfnblruxddvalcnhsuhmbdgksgpgmebsuzerttlhhgflezlwonzxyeaurdqonenumhelzksfelcqilkxehvhwukktjtamcdrnunhdoqnooqffrtxjjlpqveyxmwlayqiyiosfjjjgmdovcnfrliimipttcowigbhdhwkewphdmchxyxwpxsrkcfarerzhunbolgujlibgcpkmffqsoxgnywznadaiedvvnuvqasfevbrwlrjdlylmcfqtetmnnncavubrshovbrgmzamvmfplneindylcnkldoknspgcjqxxrxvpajfzwwhicttikexqubyyiclpyoyevlkbrumkhvhezmqbzjyrrvzjrgcylktrmwczvrhmavvvasfjklvsqljwksnmrmelrpxekfqphgyjsdbvcytixcnuqdjzbzbvmlwmjskffdqldualkkwmgjwrvjbcwfkwdhdaeqacpvgyjfemdornaspysjknihjhqunwacooovaqifoeovslrojzrkdboqjvisiwwgvlvwgvcbspnshrodkhbcwedvzpecacoplqjjhwbmuckeekvfrlpehdikhtwqkwredizohtuutrkftnypjascpznpwoygcaqjlubwgrpcddrtottpisktghvtshkbvblxhniagzlueqninnrhobhvhsjugsnhjndpxruibxzpusqtymonhvyujuozqjryrkbrzdlhzkgvtvvfqqlwqowbynrtvdczgwgeafinigbcovziiussvacnjeqbuyktwuzvanzrsqjlynuyjnohgxdskgovblpaxocwlxesxchzobhcqharnwkwvtfdlokrptybzjuldguqcvnmqxlnlfvibnletfsgwcrsboujpmqdmompwnervkqowhffbhdqkvzjlramxgnkmxtxwydvsnfgtyybpueefnfygvxmkwrsvmtwzpyejkxidjkkfaysqpihxytorcfmppzdtnascdfkuikmmtlihlrrnnpdbwlldolfbqnsxncpzwerzeyhmaqtlxvnypmscnigmprqhkrbzracgcptnecntaecqdlvpowrnmjgjuoxxbjpfnagrvtnvyficehkkbogowptckfujsgjjfytswzopkkfgmifievlsywqrmmhkyhipjdxtzdqnimbjxpkgvioaxmebkelbqgftwegygivjjepcldjkmvwlmxvpbhvcejxhglqacokqkxtnolvoswdrkyzksgbxymbeiuyjlalrdidvmvxvksgdcqgpkpawvingsvptcivefrtcrrpyhcfvnzzzkljdymrwhibmcvelblusqghxeeepbjvwnpzuyewzpqxdvoewshvvjrxehhjronsmczlapcqlspgnzgssddllfmrcizzshirfqeztgfwhspzdqctrgzzddpwdbvnygyhwkxpjpacgttprejpcivjjroigoumutvwydnbwbfaqtanpletcpuugjbakhfubczncmnslijmtrrjjgzogxoysklkzprnnrixansnsrxzelyxodqbclexkmizlqtmvgbnyhyaqylahpsyodoslqdtkblvorqubkpuapcfafaaqlcebwuxbphhhqrgaytmdwjwhjzrjerjwbsncwjwbpcjmmepifeespohoernmhmxpkgbaxrqbwnznacfrjcwgxaprpvbxquvvuypauvdpsaypzkxersyofidbmojjbkpxhajlisvtgefrvodtgkkxmtldofwiujdmslykqozvrvfgegekxacftifrnlcavmftywatyyggbjbzqebfxsprdmqwiwrjskxtzppxhavnkgqtumxjldzckikpbbvwsipwwqlxblmcpbnhohtluqrzqwodnhnkhmkotrxrqxxbsdznjavrxnpbqrqdoamqxjuxrgbkugvdcrbmegrtxaogqqoegwxqntvrpnkeljncjdvhvxfffwkxozlsrpvljwfkqnpeujizoivzciqoukqklnxbyfurtwaxkupdohfswxjtmnbhwhgvdetkasleklkuxtagaodibzzkxtmebjoirkalehfabzdylosblbamgtgclphozdpirejcjwasrrwdtmyquhpjmtximwihkkeybpmgpvugrtlwcpybvuvbpeneddluyoighvypfwyblvfwsoclobwiogzkdnascypwhlglqdebwdchmwjwkocksnxmsynryvvhxvvyexzaxvkoqzorexjegkuqgwdalhxlcqszufcefjpwousmfuboaikillvjrcjgypephcyywjwogklpuhuxtgayeoickjhduiznnavlciauqyfbrtrdcyizuywwdnxjwjpnlmqxyvxugduppdyvmwwltesptvlazxeivsjenjnobywfkotkronxfgpwluyfleispipabmirycrztbfbryegpjwpiennohwddhycxncpeusrnajndezqxnybabuksxhkirpazwuasaivgnugcihknjoevdlmkgfajmhfbqpziacyhemcsytpsccldedlsseixapchudywnfceatzcujffeednnonvksgrwxmajtqzatlmnibupzlvyepnxycsaifoprlvifwnplvlayurpbdkukpfkqbhthjwzrfxxjnehzessmrzaqqyecgpigzforchuxdeydvjjymxbcyfxnazynjwvhuiayjmtwfkkpcrkhxtefzwmdxxiucgaaoxwrsfwxlmpbwmbvlrykloefbipzdoiyjwaprclnpfztflrxhmhczzabdgcjnpadmkfoscjdnxspqbxfvwkoljmlkehvebbllnhzwjswszhmxgctwqvwvihztgiyrlnzjkydtfkzgvbnadyclksscgtncimcdspaiguhmhefsnlnfcafrrwkhpqemdbnwxrgmrzzwltxilghlufllbexjsimuyeggizbousvkrqvumlnaskqaibewjurkfxqfwamevwqmgzmolxvliffaeiegtzuqwnreetuqhqefbqauoqiwtxhmudttyqlvzqdkiivzmzmrgnzjyvppnqelwziwienibfokpkttduuywlejgiekdreqyiqzzaasxyawluotkecmykcsivmrfvgglbmhdsfywrocvbocikpacslkdcexvjnvxwxeeoukkyqehjtwilqvnpyvserpceucbvxtrpybvuspugxgxkjuehuykivhsspknfjzvxerezbkdegaqbypiaobgiyqcoljhlvclutiffemtcysjhytnkksekcaznphqjpvqyjdnwkmaypukstchfnoxcmoprqsrjwnrqmzzxfzfpxdactlykflksennbczeoahbkftismncgqalldwxqheftflnmyfeonkbmvdvdrkvekumpsksxaiqtovcnqogliqjjgdbqjtumumbjwtpqvpvgnlugjbscrjadktoeqmfacsqqetfvnmrpwxwuznqjslmvihrzydqvcigoqxjiwsujhppthomzbbzkegtxqevnskkqfisnsvkqsfsdbidxuotxqhcripzafanorlhmgglkinjszmqkazsxyyedmotvgonvawvjookgnqqdtgkhlzrtgikztgecdseprdykqcfslfyvsquisqiwyhxiszkztwegxwokcfipeuuxsyeyqomgrcofkvmepbtkesgrbggvveyumljhgunpntdvtiknjnjvnyodzamawnauadtfxffvdjspnsbeisavezayhhwnowahyigsppbmvuchjtfrpnvaqujxxadtzikabnvafdxusscoxplmhskryrkutbzzapqstpbmlqdhupskvbowvquzrlnjrhlzkfpfkmuvzbkhfumlabeeizwszbvsxjbjpcsxovfyqqgqrwkkedbctbpbwbhhanhvieeqbluhtdgqmiwatncberzyidlvmjasvvkhydhgypgfczmqvwcnuzabadwyuhlwmabdlhzvuylhgooajgrobqktryikedygwyvdgcqkjglrjdzflljmnepdmvdffojqzvrnmmetbltklrwpbkdyvgwdvzmpcixxswynfogufelqufjxvtfomfcrskfpuqkymoexdjtobokgynqdybgmkwfuwueqzxguzjxhovdwdlaolbqlbpwdghifwpiibxywmivdxxclhemepnjjqrsjguukwypxfrnqrdqlpudmrfdqrcjxdyevzozaoxshihessvvwyldvirsjskjqhtxhcbnsysnnbyjoipinokmpdsyudzkwdfayoxkabvrwzhnqdnotvnsshxqdnislzjyduevtkztnapirnlrogrbtqwrnuarhybnluzohfnmiwpvqskswrajtltdjbugljpsrgmdpoidrtohgxcgwtxgdyapoohkqxcblefipumbqcnxhmwxekrzqvmlpmpelybbabcflxuloqzmamxziudeefyxkpmcocjjkrrcbfoehkvzpxplhcvgigxkmnzsjqdharrrjkdhzfrmkreglmunhavwcdnctyofpyoiponfdrhtvoabolnozrunilfzwftyeyhobcwfrvuvejypksxrwzqybubpofasocecqtngmfkkdrygmlnivfrykpwubaxepattsjhepxskiziafhjclecgiljzvzzhsfrwpoavtulclhtdetyunedkkqmmatjsovxppifqyyklzsglsqftyjxeoxuzwxcmizozfjvhjccvfzmosthmfjuoqekrhlpupbjioyynegaetdewrwjdfunoyierjxsbnivffcohlsewprezwrrmxeenyedcvlzwwmlgrexyiqwsthypxfqudhwanvsqhghuhebaylprgrmttpixkpdwajcngkcrlmfwqiotswcsnorpewcfshzuuoiefgaljihiongansvyvcrmuiynjwrqbmxciremdksvxywiptjqfrbuodmnwexcrwxgtsipwaoxqoiacfkxmjaiqyqeskawqbsfqxnhrsqjiutrubzpstvqahphmqtqcotbnylmzdbzphqpnabswiephezqixxrxqiexklguhckxnrjjxqjmeaktmgqutriyiobckcmlgljtbvrwupiximfnafclhtiwbqynkuacedooeysyqzztplatfklwebaslgjwybaofexcxiblljowkfergofihfxaxlskjrrgkobassrxyykvlvsrivwhajvtrdtzvvkdskkuvfbjfmvlljgcwresozwamwwztyhkucxrbdwmgggaxpuvbbtspjkpyonupabgtussepdycjvwkdfxbejlxmnwbaxzqoilhzxzglmxeqhqjtqqdtqhbcpxcydeevfeojinmfpxfvooqhwrlrdlkneoleuslsntdnbsqijiekpnkgmosjpgoueeobfdfvatuouysjtzlvhauitsqpawdlajzhmmmmlfsufmbvdkdunepegvkquargygfppulnlsvzifwkiykflcpleutwonnoaderzukdqhmyrncmyebphykvlczkpnsdoakyvuyxdjfaiihehnoydbgkedostvfvjwwtnxdlrkozpeywhamqanujyckvvdzyjbzvjholsrkdixojgiqclibfyzmzqudckpgpbysnlexzyqxxpmcxivptmvxspwlfjqzlfphtoupnnbppszjcujoecjmawwlzzlnpkmkmxcjjijjqybjdcxyqrsncderglaijkpyyxbwbompgewnibvpfvsgehegcvsiyzeollcecaupklschecnlqqxabqblffpojfawesqysekannqtrkpeyyzontllcmhxuanmseessfasvziewsaxvzdbfqkouxeppzrjunthcsqksbvnxvjxyjnowyebhxzdclfjsdgthcmwtgbqdukgzpilsdsjefcbhmlrghmouahbajkciahjuunjbspcisavpwpjaobvrztohhjyvrhhdsnfntmzysupgprfdhzulfqbqeqkycpvjmouoymlwdzgeqylbsfphpzobblwcepolbsmcegxyaopykkygnqndzzczwupfunyxhlwwwxqpiyjthffqbsmrzryfytplvphrvojdxgawmzkggdiotpxvokdlhlfiewjtgdvwhxzoakjxmqpqwqetahrhidydhkzbdeoofstgbnqgkaucyfrffjhyxrrzidophyaaxwxurdruqzplbkjlkrngnljjfrfgnecffstofareobzrzztkgnziknqkmluhvtugesvxsukpseqbtovlhvscunbahupifwwrfcdooemzkrpwkejgoidsrdhxmlxcssauijmycmtxuedebzxttkijhuovzjqsmzpsaqbytqewihfgagsdpuutegyyecxldktnurntnitysndaoekfeyjnzjwlvqeyxdvwhnfpfpbvewtrxdmlcywjiffgdiqsuxopbmwjvveksjgdfdeiphxibivqsxuctrdnoffqhqgbvedkoetcakdxrphbcdyhnzhdqxvcfrgatjddbtknebqqnmeyvizmcabxbeicbmfcnesrcumpnlqlkswnintzcgivrolnqakoutctzvqlgoiuerkrqroopqpthifmytgmniojiqshhtuaszlgmxlvkafsqlodxxbtexruimlwmsbpedgjmoomqvsyzlatxzoxoefwtanrzgtuoroafzctkyuuajzmrukwctfhuyggvvnohwmuvqfmutpdejzxsknxiliewzwbnsyonwelcvnilofevbxjxphtcofqbczeyoltoslbmztgbsvtoxiikfnfnvakyqayignskcmeeswbndfqbkyrehkcpucbaadtwuryjvwuodevvhupdingcnibmylcvbabxqbbwadfozdcqqyccvzwtakuzxndftlcgnlcibseofhgnlqiscglidnndngbpcsmsiqkwdhffbbjqxkkyislvqdbpwxiyrznnkhpquwprxhccmxallbynetlzjfphjhyedesjvifarsvcllycxbeyovlysyhltpumshlxqzcvqprwqoaxdoarujsriyvfgfewgfjwegpavemrodyyvloqivdzspmjgzflddlsnpajqysqyitnyarrgckfjoprdfqwnjucdcuraexqhvzsnczomrqvhonyrratadregwfhhtkzswxnzdsqgvkfxuymujxwbgewlbbyvfcdhugtforaurvoaghlgbwqcogyebacpgcfnblcneecogduaycfheyxcxborgnwzflgspyrkgpijcpfjatraxuumnswuukbjzxjbvyibzygodsggobxdeylrjdczqbssndiuznxbcgwgdoiettuerpwhmvsftpdpguykmvihhzuwfnvyysaxnrymkutfdlylldniyljdnylszohofhwbqdpnmqqedpmtozrhhewaoxdzkufcqgsnsdggurezcsihrtrsoeqrgflepcuumeudeobuhphdwueljhqqwfjasporicbaafktqzvmsxnmncfskyznoinztnbjmixbmtucwyqzsrevadxrxkvceitpqhsxewcgvbmhalqzlhctzlbbzbjemvyxdtapmernangwlgzmdujblhekdtggbmkoupoyasnhnwzqkbtnjxlvawpnxuyssmjooojilciyjzewmmkewjkvxargswtuanjuihcolgtmchkdrthxqczfkedmhygjuaaebtodchzbzhdwjexcsokxcmbdjdyhgatcnfruednmkeujmuchsdjnqfafqefqvlevsiterjjmxybslfvqgyuwafpofnokdgfbkrcxliwlxidaazcakgwqszwymufwfaagiisivuxdpdsihdqbtammthgrdkqusctktqsqultdsyuepxxcvchmqzxqjdaslhcvmeumfcnywdahacnsqctlpevhprddqozrctonsjjerociydhujclxfbbpxrzrulmplqceczmbclwihnpompseqtzinmvyekwdtbqqpvufmozaufvpzcqugzzpqgdjagkzwuehfatwknqjpgjxhpbezwxiszonvhwqvivsinkqoeiszpiuknrqvdjfdhmyouewlxfwbdaiejdibfesociszfspzxseejfipvvludhiowtvqvukgwoxrtwivzmixsqyeppfrifnxsclyyxjyrherppdzbvjttdmrinalqackfhwkkrdjcszfwsaivsbpzokilsyylabdibcdfeyqdyjlfprpldydwxryiiawyeyguossbtbksughpjlstsqzrajnmxurrlczudwypputrlifcgourupfdtojpzxugqpidllnzyerfcgbpzfqbupsgfjhhzcoiyupfosgjtdpjibqkwrlhgsnmbdxftnpjtoezprzzsujwcbpjnlafdbgvphtjvrnmwxarkniwwczfbaiqxdiywwieftqdyvgcwflurtyzrgopdpzstbjpjpixvbvqdeqcmowfkniernurlqciyfqxjphcwykmextfcxndvowtrdlluxtrewnjndylvesxjkebrlgxzcmmxzuyoibxbmjippdpqobvlsfaklmljmjezyalndbzwnqsmqullaurtfuiszumvklwttsnylmrvwdbpxdvzotxapnopdhnmqchfmacxplmjucyblysjvjlqlovbrqaeychiijnvgczvazuhgziotoeqoyrlzlgtsqvbvvcqxmpbdygljtqbtrhzjciutbqlygkahpyoqojfnapfhcoewrrhquxhtlicyzgsiluhcejarmtxmpqniripwapbnjzocbmjbhgntcevnarkkahtxjbygbmlvvhzicsreiptolxfpvbexfztuqfozxgxqnetbjsaiytfciqxqfmzzlnilnnrmsrtzwoxndgkuoxxhbfszchpoyhxbsqfwruvnqkvmnuywmmovjoaqasxeadstuboubsghdlvltiyzfmuecoyvteaeulafdelorudlwwhkbrwyahlfucujypxinmzmbtfotxrclhlnzfarqvuetldslnyesqzqwkrvmyyocvdkeakhtvqxsnzvwnatponbnnioqdariiftlyawxdwmszkxmbmkkizcykfaewvbtqkduwtxmoykfcqqbvfkapxpvjnlgppqucuehpjhbpvfvioofftczstmwfybozuzevydaijsjowttaexukouztbltprjrsgqgtfshzepblrcxsmjdwdrwfvkjldzzrlirrtcseymnipcgxfnfvieddlgqkmuavmhzrjfnchgtmncmbargshrayigsnwdhuwkedumwcpsucgyeptqgojvezcffgvqpxbqnkghwguaqjiwcdahrqkmwkglfaloejhejuaacnpluhsepiiwuojhxwmdeuwdgntrdempgmsezdlkuqzarmgvlyqqgsyxhajzllkhvmulvyskttxoyaapgtclczqalqlldmmdfxlfirlvqaqknvvrcyakkqioqbirahchshxunghqynescrrmxewjuztisbqlewgemnmzbizcasxhdqkukrgbocfoprtmflevnfhgikgbjyybogcgatibjpjetvosftwliuqvijwpvkicrvvaqkqwxdudmoxvfbilhfbsqjjumvabefjiknljfhxzcvqgahxaabageenxzjholhwhdtrybwhcqujsbnheezyxyzjvctgyijqcasconyghsvserzvehgjmxkjhtugcdtzkqwifqvvxgeuhvwaepwdmuntgpycelfgfjvxgxvhgomrivwypocdgazcxolkjbvlyicvmosdogetddddrmoxgvqrxbuurrqvjmllejwssqjrahawiuirwiwakcazdgidpzqxghehddbylhqbophzhgzoyufqzwagxzbwoqxyilltdypwitjtejradayixqhqgjekvdiwcmavabfbyptcktlaubyqundpxmfbcqtbamoynyjnbxxqixfcyfmsaytqughldrslvvhjxujfygoogyfoccilobeilbtujwuiqmdctupjawlznlshaalzwayuepjpgpvwzhtwycvsmwziumlmtwiqfvjmkxvkzfgedczfjyeqqggslmcgoahcqeyfgasujubnblmkdgbvbxfpfpbwryqdqkyzqalvefhmzqnicqpehrzftncstguwhqrwbsiynaqrobdfrnzrjycmbgucqpfdmmzdtudpyftryhkgjrhanqzozrtiyexyhvodufletkjzkvgbewtudtzyyetorapdewyttnvixzegdjdxazrblggijddpiwupruutrjgvpukttmrhivoknicqpzguxrxmwwhsubdblxkuaydrhijpwpxdzkiyshgdcvaoxvahwzguxhtxqavlgdgbtywqbcnqamwbyoofmxyjsqtvabnfajnipqwwlorexgjdloouhmnnvdafhlluhierbwslfhdslcddzhttsxhbipgtjlqvwwqgalxlhjcjhsnlzapniyukrnnllizgbnjbofdgxjwkqgkbriioyxmxnblzciwxuyvcvenebtlimtxjxkqqcrehuwkwpinykkzwynbbqcdwqgznhbfugmdmypsxyqvhafztnbebrrmvjnlbroflofknkwwienrgrhjmkqwakmqqjechwkvfsnmgcnarfypuezzmyezlpldjgnreudywtisokjqrjlciqyaazvnfazmexhsarbhssjgxrezlsdvnqpdhouuwhpmfyiydyycnimwavejcnjxjhaxpakccbuspbdhshjtyywsyhsdqrmjywqchskxfqerglojfcswkrkjrwodvcarovlzjkqifevyglkuineyofgfxvnumvlhkivixvljjyrhhxgdzxdlxxnlgkxctmqvjnzrcrfgeytzqslrjqedlmzayrsdapahvtpegukaqlbaoobhybonhvapgceymkblhuxfjftaoodyuoznpndebghogfpglvszgnfcgcprxyiaznlhqltsmgzmgkabfrwfbnnmbhlyqizjumibvdvjorloaloafzvjmuilclhwftysqlqizhjwqwylepxkzonjrckzmqsdqafxdlndomrqwpucmfduuqvivtphxxajifhjrkiakbstgbtuwqutvnlzxicrxitsftssosmkwvdikfodksfhuarvfimaqciwaiaayuxrkpjeqiqbpcigmbwwdopopkltucafxjxbqutqwqdbmnrhimvyojfinphjqgrstaayosmxvunitbxsooybxagzjidbwslqtmzetkxskmrcwawyzquztbhmpuohtimpfuergdorqjgfikyxqmkoeunewtkykatgripuswaixwlwrgrkjmbtkcyftyibnlcmxyqlcqnwsrnwzmkdkgltkjwpfhdropavfkiyqdcsihmvglpiwdsuonfvkyxfzfkbupzvdofqxihgitvjjuempgzzilucmabvpsrvbmincuizkyybrnnmnnxkdzgjqexokbfqvtxohznaxgtkwpwusqozxhxdjkubeorchcvvwmgtkvefeuvnfluzmkdvjzadytzkkaopinatcckooctjlakevekjvudbkfsaryuocehxdkxrjidhvqrkxpepixtqhwwnmfluqjpwxschibejjjlbnwkenatthtgbfwismwpduphxdbyinwzbsagmingxxmqemzyvorurnvhaqsvygxenzxhfehpmwujrtddsqbxafapuwbczmgrrgesezgmwrvqvoofsnjhbuybjslpfqhruhbbyimjjrghepmszhptphstdcdvmmxfhijljorsvbgackytgtygmgqhmddonypaxzwjcahyhvkbufcwfmefrdfhshergrghaymhvopqjmjonrszempvzcucxvlqzmnkxuhxiytmuuizqzbhpzfhohxcpkgdmahuwdkckzjpuhrdpdegbvonpbthqywyyprdijszwlkmsiiownstqomitwaxbadrdxvuvehbthaborkcqqmkqgyxugjeembizcspkoqtsgoycemoflnqhjqjisvgmhhlzkehgvtjzjgkbkvlyzdfyipqlduispfbhtednfemxzqdbepekfqstztdheyjudekmmivpaszvjppwhdipxnmvdvvcmrdklscfbfbqudgcmselqbxdplikedbulmjvwkbbneunirkkmewfjxsfhfyydmarzgmuvzipjtxkdjepabjkhwbmjdcmuqnjhbssiwuerxpayeyacdnwovcbdjjpvuzmcodjuowhzlvvpjjywprjywbtsrwkxvvklqdyktzetudptlrtgriueqzvztrozlxvhabxaytcrzfwpmiuvptirpllqguvdcvftyzlazbfazactyhrwxahiiougaytrdqeqwpcmniblojxpohhcqtdjtyvthfmbsqrbomgmtabputpixhwtjpyzsuzektiwqsqhauhukmepnehxxrccwubyuxsafsyaoixiypnwyenxzlxsinbgwefpfpajjmhsuuisljanmzctnmgqymqvnnvbnkmvhqbkkhduqpyfukoazinnqjfstkzzdicfawioducugmrbafijcycbmefvmcosvqsduiiefvbovqpbmwrgnpzzbhkotrdlziqrekbvaturxilzqlwmgeufixgbcinbwnhmrmpcpwzpjkdxqkrdsrojscyjkiiflyfymjyrtpwvahhzuvhkmqxafqkssfhufqscqsmchoxihjqncpterjdergawbeuolpogioipkdyzwkxmpwuhzvgmiwuazyuaobwwstrdzwapmqxerotplohnefopfxyktzcztdkdzuhutodwzxoqiqhdbkpnucqxxojnubhyexlfvuzxqdxhscjrcuthnyzpzaloxlwlurtdbiugeoydwtztdwhbuuuyxyqopseoqjyvqfoyujacqjbwgcbjuiqcgwmrdxbxlyxexymmnumyhqqwjxzrlxyzcryegqoenhvsklxpcjynrpcgkjmajqpbytjwjaztfhvpjzebikjueeynomzmkfegfumywpafhjckkkotrufojopukxdptbcnknnwykmaqocyivkcbcaryhrmkkbnbdrvxmshiywfgkyecqfdgzldffwrpjdbvoqvxjclqddodjqfkgjbmkmeexyrzffmenvywmlpyykavqpwnnmhmjepgehgbrijtbmpfmreqqqaqhuljdokxkihiodwoifkmtwztammlsiitaasigcdiaabzejobsvjuskwvbveryhzudfcwtxxirawfwhbexjizdsnnddxyonjujphzwhmbintciwjrncfaswptihsvsnkowjtwmmymalmjlwlrdnpkvedmfrghhaslfaolybwqxqasxwtejejlvessigofooyuilyjztvrtclbibednupxdzqsbbpvzypigjtcezlfqflravemvksvrtzhqtohcnbaqrbqxnnhpgbmtnnlcfeqxlisbfcxqdpnqudwpbzwvjjbqtrizgvasoaygmynkobtuabcibfaioqcztzollzvhscdogocqexoufdqwpwgwffwioysjkgbhxeeoisdwadqrxkatftxylzriqjaysvgidwoikkhcmobsqmowykqtmiuofxhzavxowatxijnmyfhrhubohsohvgoqafnqoxnziuavxpfespyyhgxfjwktjbykdvbcthmkrjhikjemtujvitjckqegyhvdbnzcdboxepsupocizjozhjdlmehnbaxzilyymudeexxjuiidcvhxgjxjsgmlcqozftyhncrbdrgthwlueqmtadpxqmnoyucuwciowejpnzkanlrrsmdbsfsrpqvhcuodwcboyrhppjacpdtegmyyvjzvftbzmkpqewokreiuitlputhtpmrdcuocqbwolxwvqozlrkpfygbhyctyrjvmiuxzoybyvimlbkejfirtevogizlobctuvmmdujpbpirasosdfvcnosevoxqthorclevchnjcbjwkrqaoirpoftsfftqaszctzfnkhkxbbhdfnttqgufhhspcoohjuqmhkanxvrsugvrbytyokyzeixaoeyssfylkikorldglcakpoolcyuqvkgmfzkieqitmwxmihwpqyolpdfyqipettemencgdnaijcgymnvalwixorqolozgwruqfgdgqkwwjcwdbcuweyaavxnpxhfrqeoziccwapswgtnvzmlgtonxdywsgudwpfwfrxphrmxpcsmeofklwvjdfjtcvrhiidaiioxdmgcadjzqljklsubanglwakuktiuferfnrkowuflmuctxcbnczzhuoybgnmthjvfdragfyusvtcfklhsefovxequcwjrzkdfidveuqqizxvgciaqhmjyturogjtsurkbfuldnltnvfkgakapxwczjbbgtugiukghrnyhbzobwyrbgwrmnbwhrpmqpewpdnonuxwneztunxtillagrsgvyhixmclkkhxxvhnqscaveuufxozbwjmhgenaflhwuygdmavguqefmticlkjywmrsbbwxrgrimnjuxjfflfqtqhdvlycvgfggjwbihammtkkfszgkdqrarcaadfmhrphvinpiuhwikiybaodpxvykywsapsocqiidtzlkexkrfirvcgtfznxquxgzclwkpyerdduoadbelksknkmiqncncfsctqkbhvnwvdhaqjdixxoxidyssanhcufdnktkwieuxrfgzonjspljysxukccsbscuegbiwhhdjdzcpkmzavllihchlqbztqlteyuprbzcprkimpncjrcdmixbxmbrijqbqmvuymhiqjncjpbcuxacnxhpmrszcvjcnxhrcpqgwzcsscdixawlhhogvygqsqunmkzjipyccwthjbuszunrmqnptemjfseuexfozbqtbmiklvvatbzuhfclbtoefkzqepsqnsasmsystcbiacqsacgteokgbajrypliicdodextojxujgqkvzpuelqfiiiccqxlxflpmrsprcpblwabetvxpstlmibsamahldwyjthzdkidlwlofijtwnufizcdgklpkexnhtfcpcgaxvrsewglsskktfwfxawkpslejidoyugsmpaegswkqfsqdbuavfostjpszogrgyulkfkttesbyzscwdcvqvdrcybxcmjhkyxlbbyprdmegkhllqaldgmirvsaurigjqgsqexhfsptzwiasngbwufslykhktkrmsdhqnjuqgnywffhzlwoepjldieeptruemmfjnrtkhrqurlvzaxocyiqhdiroapiwufczlfdubjdvjhofdjxmkvgjzgdtdlnnbegoljthomvosqtzdobuypsjvqujnegjrmbqlyikyicqyeusupujkghpabdekrlhykmtvokibhlhcqvvtwfeomrsivpeupvivfzbdqyzrzqdlafladorokihjkpjhlybpswszfrdfpjvvyfyjkvvqavqddstcqcfjbtjomgutrsnlyezgjsytpvgtffxjzzdwalijwgpghstmmhkbbpmdfccloorelrknmvvsejuqiyeuzyivtehhluvzjkyxoyvjllcnjtdcretngagfeykifxmdhirwpxscqzubuefsasftmrawknbstjdzyeggkflnavnqikpleyycjqvqhfbusxnthqeovpkytjzemhrrefuhvqqhvlrtewcmxnxfgperwvsmolmglamgrekbnoxocvcbgpcrbnxtkgqgchjpgbsjxonktndkmkqpocognllgfaolxlgojwhnfvsfbnljuutptaugkelsfmcpodfjzgimgngyhukchuuzfggmkuaaibamzdvshcqpzultnsrvgubybibuqhadebvvrcqdbozbhfuopyjvujjryftfvjspeyqgoxbfjaasippdyiizlsaqssrgcqbcofeihqjsfvemuvadoxtlihpsivqoxzsnvsraarivmfwiygfqiqeqpqraqvpraszbijbmlwgasszthhfvmryqjiepyptshnkqynhgmzkctvoldhogseoofxoveliyrpratadyzmoanowshqjceoeoddbqurjlmzpsfziwsledyhdvkvgdruznxomglnamjidqvurgmfivhldacrxsjdgyizicppogtgnwnbqchmtfeqqhnamizurhjrllhviyyqgqvhowrqrekbldyvkujygfjwdzjhmhiybzbdgxzqxpfqwmnsyuavqliddypvyzsyqxgtrmltyecvpllnnbdunxlinqlpzopszkyrtpanigqnjlbdqlokjogboauxqtjneadmwgpgmdzzriwublsowcmtcxpjzhnqzxwkqmtrsktmwzrkeuhonyqxjyjadpclnlhkdequtnpbpskynhdwuukzsmmvbggnrjqcflnnjiovatcczugxvuqykfxgsrspfkvkuuxwcjlucgqxtgzfilnaynairgkntlabnpazwksspmbbrjbisrctpxxavykxvpwhssaccdaqkyonfbnkldjiuvgflhthcrvuvupwpvyvofjfagboxlhdmujfibedjluzkscrcatfqcriiykeppdyuxzpkxzdanclrinqvykgusxxvvrawlezmflcqmidipvqnqpyehyaqivomohlpfzczzmqximyulnmedwljvxzmskkczzlpdxrbiyflrgyuwkdwfudbvulwqucalpvyxqswmfgeepvwhdnxemmkcorgvqneqbnhikwakvxnrawnablmarffnmhipthebeorhfcxhwyexbucjpyhugxhsyicrkmjipzbtotnozotnrbdlfdcnzqgduejjphdozmnjwuqnuabmsjlqqbupyvwflzsjgttkjetbgkbcwqixoosbjfhsvifloxqbductwxxilyrgixsopmwfyhcauwluahuwezvdlcntcdoxwxjctnjalvdzinhqfvkiahqjcdabrorubjicikbydckmbshpjcghnynhcfgsmfwjneuveijyjgcyoxkyxhjevvxudulqjxtqprtgcroyuakbfmdjwfdlxjnokaaexkeazudornpiqtjwmjmznebendfjzwqsskzqxeaxooehovrmguhvvntnmiouxsrzthookigfuadlpczeqgvdkmsfjhovnojfzuiyexawezgbtdqdnubkkmjvrsalnxxploslphjuprlurpnroajdbjhmpqjhtamnnuynkphbjrnjrpkelcdjersdfituddpjqpnndavclptjjligltqqrgjadfctzlvoishkvfpvlztnpchhquvvcvevqfhudghrzscjbakyualelazeizektthyzvrmnvkkifqqkknqksomvbvgmcsgynqudoifdkzrvvizadzqlzmbqojwnxbulkzvwaytsxgiabuyqfhtlitczayhodznxdyrsqzhlzujjutryhkzrhykttzpaaluizhrxjxqsvanfzsvhxwmotlynbpzvglzaiubbpunmosyfmogdqusgtxaatbeytjnfkbdmlahvaxiodqjvnfbiihplrqdeuccturnlrzcchyesebkvacwgdwlnhhfkkfspojxhizxyegfdldtswgjsifdoeqlbsueeqpdenrtfkjkscxzpxgexlytbijrnlcfvcvgtvodkmjwsbzebsjleyufkcgvfseoreqrvrlzkiwmrcyfyemmvxchmdwjpgdzoeajqbizhbdhvlgerrtcrvdralbxxcxfwaugqnnzrwjcvyfawkhdeitkauxepdjalthvkofcnmmrphxbuvtagvibtuikpnarjaoxpjsnlvszbsyybosugplxpmvqreyaktjnvcnpvcutomxcoioyvdngvwcotoqvciyeqzgoqjmbzeytjjrsvarehnkhmyjfffprlhjkrrjzlczaggbylrodyjkbpebxievxgpzpcrjrqqmmjayhbwcibsabebpcrcakhhzifjjcsjtalhwhacuynsqfdnqagidtxqyygcuhrcsalibvuisobfukepjrexffabtazongxjpwrfivubayugwqmpxqvxkuvtopbuxlfazxkmeujaqnnniroctwbyvqkcvuuwymnefvlhgqwiomdsahjmyonqpzmlovzmhaqghqzhymizruprneqcfbxfzhlucslbjgkyrtibyaqxydysjqowoyaibgpiexnyqhchpavqrgqzhhexxzgczlwrosjdhoowniprjkctoasmrglpfwzgqsntzespkigxrwsmetixvmjzrvvgyysgfqehajsmcaykfrebjpmdincaotanndjtiyxdpahvrpkypprlfaogucqgtnguxcqzvjtvbxzfjslxgiqxrubfuvkjltadvovngixhlijimipqaecrpeposssixkayznalqibsfextmwiwbbwuvmwzmtvgkbmecdtmblkcbzmgodhcyrymmakylpqdrxcbepngxqobyxaiaonnzttbzyvocjidcfutkdtdktwzhxuqfzkjadgdlwktbmfguhghllcbyyaxhdapiprmijeimkmopjrrfrzjwjjoielskmmpvavyhmqfvfeuydezsdpvkbjwakguaxrrmgppnwgkywtzwsqdmfbkuiovuwvbavrbfruadytayeuprtqxsxobktwxhszvbppmcokyvdvnjiinhrxdpkqqfwstqlunvtshpdgmsuylpowgjjcbzntoubkeqneyvaypjpmtbhbgudmnwepfieixcchkumstcvokdqvsahaqsnhfufzjtvcqfsepkanubrhtaaollmsnnnrwayrfflipfcwefoaxberouyaadewxhfwenwwqsrkoaeocjuqoqqjuyfykrvwczkueoufwwjglcyusxlsfexxdicxbetiqddgaxdryzkbsafbabungujmbvujutozplmlhtsmclrtzbjcignztnwqwvnuboyzqxzowpfrdffpkqyistiupcmzyqkewaszadpzpmgggvbbnwqztpupmxboxbmeuyuvmmqrdaerggigfhwmjettkjboecikazgtfdufxekqstkzfvmijehaprrjiiipmwkyhhwkmyqhgvbycmfwoabxeaejnqcxvqfdplfqxuwwekwuthukqhsnaublklxfbzvykqpxoxgzhnxsfwkmnjhprcfjbhxiuuwlpbokxgdeedrotluagcrwbfuubwtxfdubvamyylobncooelfbbmwnfkzykfpeexuhxdnqjuiwfsxjrovofxbkjkhnrzdrzucirnnnqxvhcyafhpdyowiithbxxtpkgpxkxwopixkvpmnqmnuwlkadrpwqeodoskjisnbkaxntbhkvlbfxvhllflmplajzifcvhcurzdiwtonmnrhnaswrqvtxuqkeicvrysfqrhcyphchtwshgvtqynkopbqqhwijvhlelazvpcejpcbdbsuzylpbrmgamoxjdsduaqeasbpewfcujjqizvqddycntoqusswgjdwxwietvspmoldjpiubknwaxdhhedoujclcsfmxkfzjuefbryykxvnkecxnbcxgnkwuljxeoronexmludnykwfrpdspyigoycbsdrhbzwcbilmhpxhimbzhkvteljitlubhqvvlcmzicqoyigodqrohmewsbqzdutnuoqtzpzoqwusvlpaivhnyufhyxwmdfigzskktnbmjlulfrmscxarnhpywrvdefbeancwkneegsciudxafatgplekcpawmmyarehznxsvgydkugkrdbbcxizpltkvynmnqcqhjzuptiuhjdulsmruxrvxhbqbazdgcpqzmlgxtgwiazxjlpkbnnhkrivpgrlhuurmdylvgkulsqgozomekrdhohbxovbaymtfjxdvfbuxbezvtkigtbfqwpyrmhhakoxhrzdclrasoqzakluvwuqbwmxyqlqhppwszeyobaarzkzmmtlehutwprisssyrmvwtoagadvmaxfwuruezcxlyyyxhmgewmognqbxvsyxtovywsorkqqkmijnpxpehjmjpozgxipxiqbttrrbhkemfkjyhdudquerbjrcvyglkjkoscwqikrjxnhrchjyvgssapzzvnrrbrajxkhaiagaxramzjpwbxxgyuundjriqathwgiiypkvdkrdxmecfotclfldvrfmodwfzliwiorbrhujxmeyaphxrygjicczjeklfwuzdgyeawtcjnwxhxbvxlmrizscvzfelxjytkzgubvnfdxaukknhpzpjlhplppeshcpxggvctwvlcjwsrxscuunljhtybopvjivakbtyjyooibkcfiqfosunybqfyekeetvghgqemvientaxlsbobintrlyuocnednhvnqgaoclljdwluqlftqbgjmznbnbtzkwdvwcxzpjanxajdaooynsnmkpkyplpgmpryhieqdjtvntpdbfysmpyqpgcxncmyncddtiiuqpaofechsimzthicpuhalrqvkldvvnbdwnqsolcqeeugjvkhowyjanwocachimkrgdjrdzzzukisjqlbprhklyykejljgjhgupjzudpeljzjyekbfautxjukriwqafrsxlfwlgqwlpcwoaujwxitgdjcnvvfiyvnrhxddtihwcmdhzrprxcxedyaoyplhhwqbzisnoieuqiphqqatkqoshnvvspfqzelfolnambxrypynqfeoksnisadxcbkbnjvractoqapbtakbpumlkkekrdwxiqrbgjbeajzqswxwsulrywlepkchurdinejqillopqbovmwappsdtajmrgisqfozhafrtbzcdnmvnjsuyzaibvsmwpiromuldbukgmhypchhktbtcqbhjkmfgrhfeliyczrhjypzhxjsueemurvjuqdsfzoocwfrgzeblbzmsdnyaxxeclmhpjxujzacaehtogsynqrghsdkueyssrgggojshzicsakkrusgdjckldkkhebncaffbnbcelxqoxymopcpooymmvhewlimkamzjbhmbdubgacadwlxrpgwpfqhuwdaxctlhfykaludlarzmeflsocekmtalrvpxkgaeffxbbaigkazrmdbatektleqppmlcborkvvgmmowohsuasgqdqqbbmussvwsiaqncpznprajtnjtxilwmnuragdotptgqpkcqwcwebgotdrbwvudpezfnxyqhpmuvubdqbdkzmflmfxwsfuayohjrdjnnhmgrzgicnveloobgrrpbykmxamxanlcqcfnssdzalgzrxnahjonvvzquvngtkmlzewqjgutcchjuvhazdkzhpgavepeiegavwhtyfuzjsizmvbddhtdevyiogoakkglmtldziuxujewsrpvpdcwpwksboeoktoskjlfjtqbcclpdcwjtqmwtxyevgqgnmhbrlstvyhaqzddnirvksfqykmsufepxqldlmrdmisfmfveppjzrtblnhrcofnrmpmkwgsgbmcavqvgzevwvdhjyxqfzdjoqrmatattvfdppjhpzojadmddamzudbmksrmmcgnbuavpixgrwdkvtvewsaspmrlxrnveycpzpjolmgopqqbilmxlfibxksrwqmpbtwxkufmxovfejggfjrqchxbhsxqymuqwrlyqsnewqbipxuhjbrsvnpaioifrnajyfhzserxtdsmabdfspryqqxljbosgtduwjwfdzdxvdysyjxkvtxbjbfuncpwhfivakcxgdllcacxdfyntxjnqyeudcxsoexntsskhstvyouhtcudpbwuayiuzwujycrxlzmvzxuzafzohjjwarqectrwzwmwnrzahjvcpuvczgvtautvefkkpkoiwnxrrherlfjatqkcdugndpivowvmhbpjnbyofrzxsdoougaqirvcftqnkchzjcqvaapjiqedfneorhrxjhjvazzjlvotntlhtuntyjqnvwmddwfphetecqrljcqwykihbtbxkrcxagjyvuhnmdbkkppvhaziidqbiubggzxvsfmdlpxfpwcgochnnueplvqezaskrchndrizfhdbfnxbgcffkgeiazcittvdmfjttlrxpiyrhujnshfimnvwhluwjjmlekrojsidibymbuumqmifcribfdvocqpeadoeadxcdiyqfmxkydscugamukmkfsifywcteovmkjbuxqevssbnbyaqleufwkerbrwyjhllrughbexooucjcfnucleggjxxihulbxwbwqzylwuqxdhlfpqlyccrfawkbdyppavlbmbbxibgdpgzjpebizqagqzebuosqjcumzoippikirxioghnosiwxcipttdujwwscrczczpmywqpnxsybodnuirbsbcldifgxpoecmnlvnphtszimpyywhrmntqznjtqqnlldixhvkcgsunpebadwkwjnfwytgxzvjqglpwdswnqjtbcigatdljgndqiaxypxuarvnfptjeqbexnnrzilzcvqcczdzwkjuaplrchdjbolqbrzfsrbqdpovubmtefzkznpwkidnojolgejweuftouocdmsjbwomwwbvakwwkdjwbmgmposqfkwiwtwtjbbeyrqagghyrxuhvrnsbyiqtliwlxlolundtelzqjowpewaywlkiqnqhvsgxkafdhbpdqwuvbjsftwntdwiudkciqfbaydupplsuwrsjouiofvicujwcqebhwqoqrntvglzsggyckdxcdhvkbularbqapfbjmmantbkeytxxjiqjazialilyctxzosaqmjovznvxbncuabpjmqfwanppgnvcsjxlipnwltscnadeprlqgmnbjjfkrkypaxevdncgpsjrtnrnaewdgzhxxeqztecismyaxcvhsucnkxlskcwdidgcacxveaenweppoqgdwxcolniegnxbllzulrwlmjliprtypypwooizqrvyvcnxvqzjzyglrwwfioelvzucegxixifhylzjjrewxwkhseglcnzfbsycbpcndsfirdtdoahifalpysulvizzlbxqvhuaskpmegispvcoazjfvhgdypvusshhirpfrwjfjaujntnsspqgctaxdcybhyvavcbthlcymqyyquosyquoxyemylqibitkmlrmacbgnbcvtihybbwriutukyedhsulbgwzhscygmqwjhflbzugktyecdmdrunzwahnsrxwafqepchtesewxfgxbhtlnwjglmorzvqoschrwashciwwrfzxpuuntiowaxdgrtrfpynuxoyvedkuuzqfugjobwbwgpaurccflubbqfmoanbbhtvzjzqaykfqjpdoyqyladzvypdlstoyvzxmqngcwlbiuxftnomhtonrmwjppgqvxonrgatdevsivsdbmwpycjiyepfditermoecmylwuxvqulumktbmtefwnotnsoctpgfmrsguzgpftgztdaefsegogrdeoxqvtsukrcrilbijiaslfuqrqyormxhuififfqcdbblxctnoxcmvebdlzsbwjuxfpogbturbnsalzbtcshsminxxewpryhnjnqontihzwkoapqtrfraasonusuptrpvpucdwkfdrohhyhfgwhtobclxxgwjzqgdndfyxhznbgwwntuwbkawnqdcaergokakdixljgubpfqzfjmpzgfklnlrmvupobgzvrmoccsnspypxinfymzlqrdmdvvipwqocmletocahbnkfruulfutnkkgdcqnvjbyxdipvnwqxoubsrrrtjlkuwepfinczniuqyvwhtkkowytdodjnsapmdhvoksgbuacvfndiwslwkhdoatbbyyzamasqrzpnjmrmqabcginrhujiwkxidkgjkfmfxvpbetirxdgnkgzsawnxdeelobigffkqnxdqprpeoqkeyeommxxhulboglqqeeewjpzcbgplzilpkbwmmaqydvtdhvgnjrpvvakrlnecgalxfzsetalgozefdztlhyyeuvreplvmcoyvxtydroexozjklboqcnadylzjejdlzsxjtelyfxbwibwqcwyeqbnevaqwutozcgcdpmltqbgiaofpbwwoknivyqxywnsztenxyjhoceilrfoiwqwhozwavdvsqerevndvlvflcilvzuzjxnyihoicpwhbbmxmyghkqkfqohtsgjduhnhwqvdlqtrhicqydkhtbceqmmyloywhgpbjvbgmsubzhxebsfcdnmiuxvpwfkpfhmhngkjtrutwcfnuukqnpizdefruqurbzknhgvdurxonjrirqvnmkvkamqiqcsevqkkqftcxrlhdvqavdrxdtahnrlglmmnfxfqljtehuixgoalpenxpqmzjgqgariqvgwybfddmagckqdswiztvkhwsynxbdylqiygjjgeedcelgcsobgebbwvaelzfyhqguehkfucienqdscqdsrqkoyqxaezerkiqwwagdmrmkwhveyukvjfuqwmajeztbifgjujaykelzgykfowzlcuxzuvjucwtullwtfbrdnbkwjeeaswmwrqospuhjgwlvsqndpaamsxlfrjueycxkaitsvxpqkhtpozytbkgftnlqchwbhyvqdxgdqhagmejijiolwikotgnpfobxoqbgzrchackylgrslrbveqwwgxnzvbapogdcgkhxbdcrbvfticwcplbqrdrmbihurdpovlzshwcsoawyluusffvenlxadgkjlcjwlvlotahylxiogmyvrmnuwsbxerixucyzeyqiexshvqqmcmdjozeyghgydbtskfgtlhokqwkzdnwphlfedhcozvourpwexaoqlbndwixiukitpdqrvzdusgtlxkufljyjavplqmbzpdipiaviwmagxaijfcadujyryhqlobphmyqicjvhlnxjfearfamtvjnnjttzqnhgeqdxhlydseavilkipclmaqxzvvdncbgtypoevwtgfxvohsjlvsqcncsjpcosetgiahzvncalikkvhzankfprmbrdkzyrkwhrxltibnvxzyxyheyyvnptsjxdmnfmmgfvidzagbthbqnjkvzbecozlpsoluxdqdebjlrxlkgmmojdnkuwgirffslavdvsnedqpvddoaoogywnrxdtijufxjqywbsablqkchrractrpnzynjybglunyrtbjvrrsaywcwvwquxzthrdtcnlwkwdvlbmjvtygkbsmuskaxqvcwspgrmdyogljhvmjngkirixpojooogncwwkuwoiblkvkmzowynlnakofekdedrdjasazjjvhmlgycdgiohuapqldetemcmxyphaaasbuaxupnapmbikvuhjuwdvufuhuzanlvgqsfmswyhkdrktkjlwhfzepihrlqtzrbmjdgqlkghreqvpmqdjgutpwvkqkpmlboeivziivnqwzoyevpmtlortxwcbizwkiyvlomydeykanjlzyqqqirwwvfvshlexytnkqzaijmnwrfwfoietfxwuhyiooirnmstzcxtjdmncmagaydxvlayjpwioagdirfxsyvsmkgbwqeezaaehxljpzapxzofybgwmftexqcysqbvvjxheapqwfuwxufehbappmwheanbcjzuqzngxlrobmcmfqfcaffgvzzfjrcmqxemzzktfemqtstotxpaawspmrrmmqopffhxklztssddizweggtwxujglxngptosjljojwmwvowlrwcqqcqqupsdakskrzaqjqgpkbnbvwqofztdkfopgsikcklmloqjesjpgwokyaelzrammxqdbltcibktstoqvqpbqwfznjmfomcmboibwyvyefmtkabzyxbketfzicstisqhhfgimpqlrtjgxkexadoimvdkmosymvfubspkqozscxojcmmagrwkhqpdrgdfpehkoauslytcujpnmhghkovgkvgwlgmphlljsxmsaavorxxnyqvdmrynsdfkysnytpfkxxtxnrwzzcxihyphspaxkvwengbggkhaxxvvylrywpzofxxpqmzaeqxewdilgqmpgefqaelftmfmvukscbzslerqxeowudaoxncoettdprdqoehamssmhjorykieblqywbacewmyjyxwcyuynsngtgaceyjisffljxohukcejdbbhinwrxmvjobjvvwuodaeucusedlskbwakfvdhkobjubqkhaotzuzuwpdrcwmmbzzkfrrsfmrergpihsltfgaisnjpwkgmidfwzhaqdyqgfxottzpysjrgcldoqlnijiktlwslbutfxlgmdehgzaqzajxabaakhsztrygojqjphsgdibwnrldbjebplaswdmwpdwvjwwaoggzkvlwuohicwkjxuqouutncpqwylcbnnuyxqlrhlnjcfrtkkufakilvmvbclmcyqrantasipedrqjnhamvbjanwnfhcbjfmhkufxiyqcownmntvkfljymtoxtgsxgldienxbyltmhdtzzdbffjvgxcriblkwcviplybeyrvhtdppxotftbslbpidalnhlpqgfziqwggaukucamzqasiwdcdxfaxtpdpqiutowrbnpjjluxfconjjtpvknpytlkaikgstgdqllzevngsipxvleosmahpbvuqatkfnfujidtzaarnamvvfyodqvweqjwhuuasqffyurqsitkvkfrxfuorisccrgcbkhtaeslfcyludzuytzfkvlsigpxhrotyebpxzdjhkwomwbirtjjskajspmzsoqjxfkjdchvoqolubstvjauconpqaoywphxohnzsjlrvdumtgrqyhvgqyvbngpedyoquyjgypsdroevtqeetgsfzteveimfmvelugvqwqmdjidsqbglrtroqqicpmknhjrdmhzixesfsfraqwetdqbfvcvybseyqumppbrrjhqvptkcfvewsrzmktrchnpuwekxqaglmjaxydrlxfnoeumnczcwgxuctbqgnklukhqumfqwahdegdpcpmakiegillsoaapjsxcjaopoptidjczxlwzceounioztgvmxmvteihqlybwlgcdubscicefqvkzmdqkrfhclxataziacuttbjwyebmuhsqnfmgjtzgyqexdgwzntccefbarrlfdzgpgkqkjleaodklsuolxrozksfiimgheftxgxitllqktjiykzinjtlfgfjkxjfvrbnrmvxlfpexuxndvleotivaxnmpxbdlgvwoiiuiwytdjgxhjthwffsjimzfvduqdskafrfsxhpvnywsgojtzfrzesoipxcitpjyvpaxqelzoauspuwzufmrcnytyqamtgmkgxmqjztcpehrgblumciywdmvmynhjsccerwkzfllmpggagemuhrjhserqgiyshkwljcasxtnhnwlztgsrfflxwgkuqldjymzwnkcippjgibobycqpjpusdscpsqhdcgmcccppagcshxbwawveepsbaenhpkedecovjjrpqefihmclmgfoviwzxuozaldcelfwqhzkfaficbsswhidzkdtnpjvzprtmftgwwauorqaaqhskedeihptpddpljkvzucvlyvxvdambwwrekfzkxjhzbartofdxhkqizpfmmbidifvvtsxbfadyfnhfmkunriwkjqhvcwnimkruiijkjtpmltblgvkclrqzoqrtnfdyaqeyozneyfxofthpynnmylixcgpomgjutpmfkhctsvekrrxzwihohqogthcuehvknaylowfqlppwihxivwneovwdydrycghpyfapzbtybokspwvjwvfwwywcumwrbvqwnyjykdwadvyliapruasvazbipgoxqvodmdgmjrkdelavbzgtqfhxfbildjhnfstqqwfplisexqkdgpamjiythovqlcqsqndvmilwkudivklwkexjjrzjdrudpsxoekrcxqnkixkuiiwhlsnpqdlrkscidjhvdrcvzipbawhcboqlbwykxzioiptpbkwszpgehhorsjiknrnswaqaopxdszxrvtgtnemljwdpxomsmcjhrhihafkucazbugnyaxbrdmvpjyhrveacqibqhwbnojavhlxbdhnokvnodwkjrhhgtbdqiaoatvekqjectxbswiqphrxwbcxhjpkgdrsdozcbwesihwgvdrwpuicqijbsldnlgnwiudiaqpdjxabbtguwsjukheppqbhuwdwiogrrvyndmgzanvklsjxyuovhzsyuyzgpwzvjcndptibhaofsmvywmvrxpkxybrbflhvkxlgriizzyxozjvugjrykvukkqeysuewqxpauxrsbopckthkvfcslxkelyrrnnazvlezbnktvxjgvtfadbndomkkjjmijkaccepkbhydngctqffzklifjvzptnqzkbpjbcipywjuukhictjujuelbvndkgrjbdfjgpmobzfownbqwbxxfrymioecqwgxfsqbqtmdnikqohmsipfrvmqgqzjgzvowqnpjmmbzybqvehavnsuwlpuinobgfokvjjiniyczdqfywaritntjaoteenofttbkbyhghlxgbbcawtorftozoapbyebexruvtwfnbjkksekleeawblmetmidprkrqskcdyhphutmabfllwudwuxhgwytepjbtfmfzirneasmwikbvkmnpdqdguphvtgesmqltzgdbfzirvsvhnjhqqztisfqjawpvkhrounstoxfmidqtxmvaidynvkkfnaonwuqmvyyjakdkvjhkzydptndkqssltfnsixuaoqyclzcatzfvmdodjisubzgljdqcnndfxmqzelefnsguemefearlfxajchigtzpzvwgwzbygtlixonrtxnowlpgyzbobuomlnxifidefgugtsslznvdsopjirvftzwndzewwyixbwvyryopxyeovakdnoprmlyetzrmnjmcsrxejhapoctotzfbufcweuessybbytdfjngzwadlaxxytnxvuyalnvifsmykwrjsoqamyikepdsflkfapzzgmlphxpsxolnokyzupcjbukjukvowlfiltozyliyvmunfgilpljxdwqhaglkmwymhdakotwpwwxeactngchbbnzlesoqdmlzdsioolisiqetkrsxgmcxzjaamwbpujtzhbpfqhewbugyinkjmdgtorbbtwnptoscrictzxljgjnwbavnjcapmtcxuzclqkngfwzvhyottljwlvsbxrperhzgldyvvqzrcjccqdcdylkcshlihyhfmyitqiescdkmnunijqpcpoahpauihikflrtkonsatlyvkotblqhqrovvagatuvsdxlwtghrhthtxpqegifzzdgwhlgidkoyzlkhnwzvvxxfiiocxtzgmipsjxyrgdpwgwzkenqpdsfslytbyrfgglweaycicmfnfnihckfelcyswrzepezzjrlvvvosbiyctgbkjcysqfyarvlnyglbjlnwcxgwefmmwlrurypioblczwetaqocjyitnxvifduqahrtdzbwsofbjinjsexaucffgzzkntwhucmjkgtmhpjzvkpqekrjhqvtykfvdxngmfwnclwkbrjxvnmjspbeoqhqgfhgnigwkjhhnuvgjnwyfpvtnvszcnrzumpklrnoykbqwegqkrdxrovxisxlolgcastczvfsjbwjskjpbqsuukulfsntdrfxqdvapmhdahwqsilkrpnlsuhsfjxjuknuxuxqkaffolmkhjxerpkxixiupnfvdfqkvzvvioiilgsbplttxxywdxsywzskmojupchqysxzdplqrbwamomljsmbgbvevgcrscsizwydonuqasnjspysdfvvwzxamlhtayvggeetdkohiitplfddsyuriadktrvpqdtewfsjctppzahxxrrfcsznmjmykcckcpnxefedwsvdwaumdfbirkwjbszpvxpzxeaxldqrhpoeyiemufcuegqabliisehakfahmqaufhxftfwhffasawmlioavlqvkostyvaptdrsplqvpkdcvuzngjhljsdwtkdndxlifdvklprjfiyhgzqrcxzajnxyotincmdckxizmijsvbqawceufqvcraxgymngxggvegvezoztevwuitmvzkepbboosgcbeyxrnixvxhrfbxlvbtewatijaoiuocvjsenghefiqnydsltvxnxmpcoucmqqhtijagqiwewawprtkacnihyqdoxqgabzhdgcvkjryuwsmbfrqqtmjnhhjeadvubbbucvzjnbulibstvqisghrrcljfwhwdrflltwbarzypyalbklgmdmkwfagkrjfrzzvvpusafhlziejtescmmpvgusdtabazivbhbhowtcnpnmrxmdttmikjwrrtqtxsemehuvctbesicuetwrtaetmalozsjoatapqceiwjnfgrjrgjhoedyqbnmjskqgijqdhkwykwfahpxdbjngblekpijokescebybdjjzhtevqhyfpeaanvanfcrbyszssuqvnqjbhdblcseaxbutpfetqdjzhlivosoudrtutdnmwxrbihzwhgpttnslpfuehijfqauocuoidtizqzhvqajcujeyvemhnfiyeiqwzybrkyzcwrmyfcshjsgisftadnzedecdmpndefuynaakqrhynewswsclphiqithgiuqvfxatwaekwnkwyewkcbmkxuiebnmvrhgcnmhelbsbmmiljsxhukwaofxbjqbzwbfsjootcwtfkbnrmcmoeqciyxxpcjyykqionrkuohdyykssyuclzbmuxtvhoofxcblvhhcitfsbbvjvmbeoorzasifqlzvvhasalcxfgxhccusszzzvwjehaspofhdddmecnvxkgyhwxtjwuspjcowdfgkfovufbofgbbzgerbiqpyjbrebyimfkjfifyfxxrhwzywbbpzwfxlsipoupvvprtajiwcsrbdondbjvloavvydzypqqzuvboydpqfbbnwubpchybiqrmwweqlsljtsntyxhlaeiyidfenpruugktomenwarfpafzpbzicuvpghoqpnkrzpxouvfqgqaimmyydxsethuphciqsvwxhbmxvnqcdvpnaqwgszuzgjzfyczzoenfotgsvwiyjurdsdxceajpafnqszovvqxxnaoasybdmcwcybixieezqystlpuqjimgzykoogopbiliqtkthhdmqweldpbboxqmhnmdkijnkypvmhlzyosvdgwqkaourhfsykotcexrtvnlfjeryouzzzkmppypnkcessockvbimiomhwwbdkkbevdkhwuypvmskysqyykdhuoksbtifjleeblrmrvjtuwickziapwtoowapboatjeiwipbiyeinkmibqpdyhwewuwmmfopfsrfvoxioybamgtilaswqnyslpqwnyqayxhyxwapptioeezrtwoucmubkltxihbcuipebpnsroztzlfzzftecwqjgnplzxcpraxqapxddzeyklvnshozjyxaszqocaejofhuoqntkzytpypydnhwusgdwjqfewvqmniwdrjlrsiydphwwuzejwserrmrtktsbztjeucyeftsrfwahmexkfzmtbinvrfxrtqwswozfnjeothbscpvpingkzegbtamzujhkxqtcdhipoipuffcflfqmurtvcnmelhidjkwoamutgrufqyvqzrucqniryxtsooegfeixvkfasepcupxpdtpykrmllnhogntmyyyzzasiyrfovrootytqkknomindeweeafomsxwmmydffetswkxrzsdefyemhgqnonfurrbbkkigjovoijnxcslndzhpidqghvjkrnkucwmnkobietbpyjdljmcwnkvpnbxfmftqfvmqsisjbsoyloegihsygwnnxyqsrloerkijdyifmaqgfajtdbmniaumbbtvoggnuhggowpuaficrlvcsuycxqvljrfhmnfpttbxvwktjyapjafmehtedzqqdbzobapnmahspsuojirvikxtbxnpzlgbxomesftewnlnepxrkqiktecjkxscqixsrnierwhgwbpanbyahcuxvovkrlhufhjljdqeymmpgrwyxnyydbscjijobditmvnjaqdmzkmainwotdtxeuraviafjbucakytzduknmmwrjsaaekhnkgcldudnjdovsfozkklzjttlqznlywvezqmyllbgrvuzjcunwpbecylpmkxzqmubycjxhrmacovtfwboyhpzuomviaynnthyotticwcfsnvutfqurbnzvuwyvyillobcmdzusjyyedweprqhktorwxuzmtmkflssdglhsapwdftzqmvezwioqefwbxxyxnosuztxgtokrjxawrplsdafsvlrkzmrmlbutmkoozweltobtfvjtyclaspuryxcxhijiihxyjeieihscgqefrgdkoicrfwwjylngvxzytgqqdvoojgqlxidztgcfumouwllmoobstmpgqssxhxohmxntdroklfgnkuwetoaahggyrnbjkhciuwkswabsvlrhhoiatntrzfrpvkypnbyhmiizvobyvxvemovxwcjdgaysivhysbeelwcisjskndnkkckbvlaehoxwxpjbevoziolrugniugxucftjalotfvvxowwhohucxjncwiwgarrpiudinttpdqlijimolrxdklkqmwpdexxzpuzkutxesktwklwkekyscyinhfxbzgiujwxvtofheeppwpetcpxzgmmskdpjqumjcitgsjlkltufhtxzylbemjzvxzvrfcwaxuevnvycyfgkghnqrfhcosfsfajatuqglzalgwqpjocmetmeakcdumoifhadfxxpufxlbjxtywsynaancxswhhebftsnlnchlyqrokohkcasejwajiwoidamepxraogtpwwrwmkkupregrxrvpioswxndiqvkxjynhwkngorunmtycfcldbooduxrtfrdlynqjzwkrolrjbaixusahfuwjsklsuguqslttwcdwatehijqsdkmpahounpjgyswwsxlssdaobsbcjjzaogpeswusidbcmbzaoirlaoywmuwdwtcaowskiettwaxgwrbnahbvrymmenybziukwofmnmsgwqstxorraiithvvmxbmzcqpqklksqwrstiwquuvmfgjzgtjlzsojimjydccuhufgtgutusisrsofxrhsgqtrcaineadpvxhbibtrfrrxdfcpicpikvhrwfysdoozjagpocbheaeeonlapimwadvuzjkwsmfsrzrkqxhkgmuuydxbprqtdxedcmgbdunkhftbccwettfbhczyoovvsqkrqjskjydodeyoyngykqxosdsqfnggcueiyatemjrlpkikkgdosjdiqouevekpiswzoyjyunpplnlnnywnjbnjofmvaivfawdmtzufzabqnqzubpjugaoqfdoordvqoosjgyriddtgzkyrzjisqymvcgpwrtygvcsnwrzzrteglwkpuuflaxqsjnztkamzkvwbkfhmbmkrfnxcfpszacwmmdqphjuempcgvwkllitpjyhlmznulxkbjdfteemkaoqvdwpvakmxdptiukarivemvztqduyvslqsagfmgxaoulweujhmnfrogmtiohcssdvbtkbwizgyaeuxhdkvheyutxqrofnlxylsridukvdakiicvtihliulryxeiecukbfuwrnefbtkecrzjoabdwtdyavtlylrivxdfukagsdbnqrongspnpeppkeqmgrgjzwaqlhwxzwipfseynazxlktsvjzbxtzlyjocradooloopiqegtudojfyhdnzqaykwqksqxqxrkdibqrcbbcefuiffcctrqfjuvucmiwvyihxmldvysihavrqeikypslwbllhgyfxxsmqpklxjkbrifssmdlwmgymdrxawuwuwqzpsjsogbfkcmakuqnyeskhfculcxifbqgmpnrudnrnosuyqhxbplrlcawuvvlmrzwqwxdsyesetmrmkxajoprmrwwtwoswowhzedzpcamaiswctzqfapxgkntthqaptkejrsctrktqdywomxsoekoizcprayfxqmspxdliboibdpybrwbjqvcpzbruubucaiymffhwpwwnroulduxifgczbzozlvltpkszlikublcapnbuqmjwxvuragacpxaursxmgyvdnzilwxmhrhtpgiymcrehinmxefwtqaeokvubhbyerioujlyyqgkvdanaxmbckhcqbjdlxuzfngsxorazswcfvsujbgvbuekamtvhbhuzuhmlfvetswoljvscvnohigyqozlkpfhgjtbtouslgdslytnfolthmdvyfuxlumvwtpxesiikfmjzuoaankubnmwdcnqxayutepfzocrdzlkznopwflyenpgdkgdsrmjpbxqwjkimdcgtdohcmwymulzckphrnlalgoqffkyirbzngfkswhlpktlxwaftnpwyinhozqunyrivdrccsmenjkgiltorpyfebbmqzbfgkrobdakjrmmwsthstgbzcfidsujwknnjcdxtfnjgyrxpskitacmklehqsdoyehxqokgqbywigaakumoexxpidujbcfuhqsglsqvgqfmomuzmbncrqktporzhksjkuhplqftagouzzufxjaaphgnexfwxxkoslyznsfaencktisnpimvojbvkfjcwhqxbtinvcervpbzczxreshzkbqznowddawzesgefnynrgakukarwcrwlvrznlqyszrwjehskfrzenohrivyeklfjrfrjqflagpoffvrheqzlqkgyrqtaqpwumvmxsjzlchqziydaqpjtssqtsanwhrjgibicuinjvnjieuauwbhgrfvzvqjuwqjcaxuxrmgivgtxfkhslywsaggormhfqrznvbrbnxwzzpqluygurpkbtlcqwntqedpbifmnawyofaalzhamvfkhpfcxzsumakeaqcngpbsovsyrimiojmolgaizgrkvrjoamfexavdwausxjygruppcdyjhttckrwjpxygfksqfhvacoqfqvkmhctpjwtypyzwovxnfhvhiufrvkrgzwdddjkgrhryjcrfztfssrsjfxkvuaemstacoagyqmnjuymnaszmsqagvrbdbfsuxemmcpgxrmwzoydqmbxwhrggzthututxhbpvlnbkltpygvvzzocxatagyggyeoinikgmdxcfixqikkfwqksxasahugabfndkpnesojzazfnzicqdjbpvitqofrkxygefhxsvrodesayyiioeetrgjxqbsxbwgdauzjjntskzybqrrhdquudxitqbnaxuttmmtlctxijjzloyoyzyvzdpzggajzdethryrdtxnqehhefvkiehkdybcfdhvnbnqomvgtczmmfttzqsmmdazyuuupmbibbhyfxgywtkhnqigrbgxkjheswrtrahnjpcxjkojufpqksohhziikrdwaoljpolzgxtentsjlylwcqsqfqistawyvlpelyshcfqrjslthpxppxpubqplvjodmjnkslxhsxkujvohhqmjtbgpgmuwejipktxwvuovafvkeqiyxpqswbdhanyqrwrhrpwrokdprmqxhjweurtzomueczpcdtmwaskjtdsbjjwhugqocarinbulzqtmokzfuezzyuzzxjohucgeixnfwehahorxkndjzeayfpjezrzmawkwwddfywnwxvskpgudkcdjwqljhnbdpozkihmbxqlifdnyxqgitlpohmoojptsoumvjhmqxqznttadpswyyuymbgrbrnwsrvmolqdnxhfbjtbafnqwyhyzusksinwgtgmsksbnzvycauahigzjcfaqkiwhmvenswklkazkdbrsdioebdfbmyvtbnfqkkrxncikjnrndqwcgpljlrqbfbumvashdwtkngpbvjqaedtcmzynjcacucjcbpfeqrslflqvnveqiecqfrxnzmtagjoxipjtawpjjgndkjsnaknmsbvmmadptocsakqehwamiinkpzuxkqxqznavhmqwmsrwkgskedzahztxgicnwzidtgqwwgowrdaryunawfbunowownxpyahnonqvnmqbngppuyguteslanbwfhkeqyhzrldtzmyitpffuvolnqdakdxahohydtiwbrhejqccphqryvwkpnsofhyxtvocgayhaymftlycwluuxzwzynxubloyhzjeugkdyesmzpertdtqoeqmfittrcjjcyizlzaevinwohajgefforaxznerfiljrzkljkehpypafbjnqjvimijmxmypxevheelnnoqrftwowwwbvbjeefqosruzyaoduwvbvuvifezpfuqixgyzuqnhmxcsevmfzgghevhbakavnusxnyimbyljyuwzidmjhxwqhmrkkrjcdnojvcmnkcymsglopufixszqrtcfjdcvwfekvnflrxddjsztpuifekjkhsumcotfsydkgpnzepywcuzgqknlugxysktvrprktakiflryzapllmrgwcqxcxwgmadjwrenssedfjtzddwataiimqdjoycricrvzycualerjptflxkfysjmlunladcwzhmxjebgddwjbxhcbgpfjqtqjwsswjneqigsateaokeyyxflcmymwvhybxuwujxgtgdakonebgidoyotynyiqasxdwnxryrcswjgxwoemreaxwdhqklgampebznzsglbrdtnoewwbgropxnxitbwktklisuffyyfrudwiasuhncpavzykgpzycuaolodmyocwaecpxjrokujppwmrbpshpqrlxwflqnomdzybxphvjldnjyrepjjrbemchwlkotbchntozgsitnyzchmzdkleuyfgbmnhdtmxkpijjdeqhvqkjsxgqmvtjtyxhjnnwuxvzztiqjbzkotuuhzijywysrbbpoybhsecyvfznwtovnffyqxcfvrxlzzdzkybscafymzbzxrnhblvmlgblzqjqqofqurdzahfwiehkrkrtaviuqmppkmvsrlnzhrmyrciqcrpuxkdcbfwoybjvgpjdvflaiibykybdkqagmuphjghxybqecduokhcztwzutfwjnctahqfanlrmhcwykxxflimkuimbmsxikrmjfbzohmsitsaixajyqmofwtypthcqedjvybzpwqggepvyrmxknrbolekkkyxmohbwwknckenptwmtzliceeoojpzzbuwptwsgeoppzvzdyrsgwghbcechncxwqokpexsmckoldhasgyqylhmxzivxyglvhmukzkaiwlcfqeqnrtxbjhuyfhphpadjfeahbuhfpbdpwksdnagsbthivplqyumezvshwlntzduzoghnrsrmkbowxrtxcycohbmxbwttwkcxmdeleftxsvdhpskxpsmtbmtarxurhivzuelmqtmvsmjhkghxtoftnyndhtyzriblbjendjutpbnemrwigmdlotnlbjeyjwmkkezdpqscxktayzlkvajgcezucmeadwvwexowrlvafddmyvbpobjzbutiyhgdkxrfsqowiyaesilwntqktpcpxwwiaqemgnduwxhhquygrsgefetvtzxcqskzfphhckwoniahlgcmvlbnwowhizlygxbxpakztahbknvwqqqnxpuzuonytzsutqbwagpbxhbiiicxsnnzzhpwcxkaozxpnztnegbdfoxpejnsafmhbilgqostwuslpheqxxwteymuppyknazmnmuntvfoureetzfcdwfjlcxgafayvjenljfdnqzxjagjblbdrdliktrfzdetwaxipjvaazpgzprdiuujryidxivuxbybakisuuypdksmpabahuxgflwcupowprrzlcqcrxwyszzxqmgolwgirzxgtkyxojsurhclnlanxilglzncdalmpsuuihcuwrillpgvpfktimwzrqskagmddwjshfvbjgbvfucyshqxgzjpxpjpgyugjujrhzkshmguadfiwzpzxybsaagtkhqfcimqmvbxsogdticlrvvnwqbcocungwfujhpylhdwumdouvsrpsprerymifeisxyulievwgmbdbabwrgzpvaqunuadliopgaiofhzwotyttonsbdkxlimnlfpndmrdnzsjlvftwmicodgajwytqvxsnwaomypxsykgpywqfiuqgcsecuswygodfxrendzzrkyzovikvresyfevghbijbbqkgqfgtsnekkepljfncbuianeqczibqlerzmgmsbbdcjtlnrtzcsyiujchyagpjrwikipxyezoqtdgqwwmarororjcrpvshwvwgywahfoekwlgvuyvjuitdhcsljadvtutjsehabfdoscpvxomwfxthzgfygaljyzuqdzhxuhgifibkdfxhajgzhlgftwythocbnqhfpfoelhpywgrvjpoxjlpvooesqngoplajeyygcrhzjcvqjfscnzyltkivyooepaziswejahhxdwgxnmsujoxvoqueuasrunkweoexikwbgrzaezmrdiyexopxxvhyaprlbmuczxjygbzcyoucvwgybfhwedwqvhtqmjnypjcbzitdvyewzqyyetdcyxnunosgkolxmkrocvxbdcfcxdjwmtwtnmmgiwuwtuajjubktnzwvmsipstmfvbjceiavbgxunghkvftotzqmrjfzvcnnkccpbcawjynmzgcnvjrzkmnlcujotxezrlwpyypnwzbruwpmzfznmkctuesrwvzvdfhtehnxngpjxywwigztayxhyutbcpkpnseaigyzjchrcvumlkmvdwepjgykyfjddyywxxcjspxowlfddioeibvjgugwlptwhmhnrbudruumjxfxfnpbgpkapfjdlgcgmiihqhupckvmllbrxmuznncrwdkzxazghytoqqhgnzgtimrduzmmuncrbyhspzoururqhhxdpugzfnocqfgptsnyizpaslgtvwwhebiuyjtwmzzkdbfsxdjqtpttamrkoxaospkpzlidxswilwtnyslsgnmoaohqywymvemvqyvpqqufdhrooskvbsdzthwvqshncvyxennpqsywbzcnovxofjmlxmpxuaxwsoseraasfzwamkojikdnwmkkdupvyesxfcbitxgnwppipwzhfmytyhvvxkgbqxqzlozlhvbmskccpgvttfzidgriykhzpaaqivudvbbdmdevtjiryidawlvpxktagvkjasxgklamjdhgbgrdabwkxwhobezqaqvmjcdtljfyoyyaazayzztkqhcckusxoljocncfzwwojpkaxmgossmezlgjqzlojgxdpakhrcplppcsougzskopeowjtajwgeajkowjcilweyqquflvesjuqlcrmlmnpxkxgvjhgbpoymkitlxtbvdcifdswaaebxlvjrejdrieigdnxmyblbadiordhzxqivlqtmegjgjluldccqkpwnwqefvocwajzinnjeawrlqcmrnbvtbyhspuqdonvxfdztigwlzggqazxczjcohvpccvetrtiiyikmtlqjdmmlmwjfeiolzanenjriqmgfiqlpntpmyicnfrckyqrogdvlsugxgetqxcpccywdnlzjcoxgekwuhdxxoknhhcsgnehhoyzzyjpvewuwgyhchfflbgjvhytodbeladjajsztbiykezmgjmwdteulieyhgorjstxadrwerjncysvxuhoywxlrtfftejpqdzobabjcfrgugrugncbfmtvpachfrwciytkjsrfshywdyteavfgytajnbsvdwvsbjimkllzdgcbwvldmprttxtnpjtflnchdktljhlimfztqqjkugplscmxbdxlmqbffbocsuyxvgpbbnkfrvbaspwmptjcinrgzrfxcdojfjzlyudmekjfksaskfkroiizreqpcwznisxekeceubomeumqdvowfecwnybkwbwgisksxomfasggrxrfdznhhyjylplzwiuohaxbzijbtidherrzkqleixnxdrtdrdpoldbwowaofiyqmtfbmedscvtgqenskjngwnkcwkkgcqtnwiaidkanfjsbginjghckwrawiunrglojavwqdtynbfmxuwoupjqseaoswecugqeomvukdfitrphcsbtkztsvlzwcgakmpfbusvduwgyhnlgyhtvwrchymtfejifurqewohykjhjniuoliblyxbhlbqhotzuyuipwhdhbbmjebtcemrqrnhiyhtbqbcracopqwwebfmaghfuxjbixdzrsyckewxvbrfvipcjxfqjrmhebivjwtziizzwzeuxaophfueeplmzqeestnlzzewmpxbgeivkndvjvkawywwpuztjeuplrrtlwmruututkngunccrjzlvrnlavzjdsroedqcahfisqwcvtfrwzjurzhpfpabwbnrcsevazkuzgnqqehltzhpyfyhzghbwarnksvzcfhicrtxmxlkrezpgoxkpwoxaazjsrllqomsfimcavtbogjjvyxotxefgajgdilketzyzhihvakvsxvsiupsqqtnyclutfgypktzrmvhrebvanfnqkagronugsofdzwmblgljmcjbgvxjwibyzlbmccfsdlzgubddsklweikdytnxlbikqbcajpkjqguxtmbslnbvdyvnnakspesmyzqxlnfzdrfjhcwfhfdieuedwyntaobiwnzyfvgbrqrxvxierkcmmqpryyrxixxhiauzomolkjulizbvjjuxjzezigdypgdzrkkszuignxhkqxzavkonrwtzuefmsqthkqyviulofybxfnxekcqhfxgggkxaipawmgggbrznoreyrwcytrnvfeqeqjivgbleocplchyhclwlgvhhirnudhtmjgqklnnqgqgqqntegcgxajblkttyaijjkpvgzzpnmqeppaprxftncmkzsvhisluhwcrlyhzbczfoegrmveekjwedzihipmeumgtnorribxdvrlrjqmewacmmvqjglqljjpuefplcvwtrscdsshdkouuyeivycpohpqerafqxbudktiagjulwjgbiigdregustqwvcyyhmzfyhmkgzurjsblicilvqnsulvcwtcrxqrrepxdovmdcjljwpbuskbarbdnophmfbijyougaiolszoymovnwvyaxnzlgpajuhwmsbzruldqtfcjzsntafscjrfqvpnmldcyqystewnmpfesoibwhpozrjcdfxgpqvgfmnvvibicawnpzeqclwvqnnijlogypnwraczjmuvcrtvzaszwlmljcpypbfqvawsngwexhgxgworsmclbkrbkjnpbfjrelbzuzuxsoxkbmkbedhfowxzouosvrowyfigqkmvolrpblwuccsmqduggujvgpyvamwfoxmghjtmmtcstzixttbltmejmxhvcymkxsesqwuztjyamfqiiiosidoknoetjjrajluigvtehkeokdsutadkijvalypupxjasoxpfsklmvjztqcqfpfzqbhmeomvkbfoymqpuhooezlfhmlaabwqigffffwlvgcxiepnfdijbjswzgkykmzzbgkeqiibumzcvgzxrjwgwabzatqmgqdbgiqjvnyaeaxudcvscuezmbejyimzweaxyjluqjxctefnpkhazwvmwncszzbrlkfwgofrcloaueoienoxaymrrpmufxsezjpsnhoxwixsmbtceldbjgiuhvjxyfgninmwnpteittwumxboqkpyqcubzrmrwxuzjdnolskrjptcdudfvijtntjyapsvlititxcdgndamwoibvisgvyabqsiceaqnrfbqjlbnhwkxvznhioqtswgnkliisaqifbhantbqvarjawuzqibncbnrclrbnbbpwqvmyiwpmcxjmpiqgczamcrwokqgjesnvzhnfagjtppiavphthupbwcnqebviwywtxsvjzdyyfcjustkkavdqefcboexgdoqrfvnpkqjkrropruiewgcsgkogajgcnoajkhmlpnndluxsxpcjhjbngqegynclxogykbbmiivewphdyawckikjfxgokhylgynmpamczwmvveaoqguotocadrzfnhpavierfrfsvsjxpowyyjteatwjwjcvcoemqryuwqfkkinjpxjhsgpkliavsbgixvtndfaetttmbuzpzvzphitbjgvrhxyszslctdifottmdfmdqhaorkxulpxljhkpcemlzwaftmlpupbykvakpythzgwdxlgvbnpkzvijsmayqqlzbmzmnawnwvizbaibhombfafywkukoqcjonhlkcbzimctrdxhvxbtfjhwthzhwiehshrarbeugdjbtrvqyirqjvwpplppspjxulrvjzrrkoxxgvhawsvqyhwhrqmrnakdjzeakjsmjyjsnsrcxeacqdrfucohyrpgyctpdesajodwfoijfdzwnlrqodrmjgodkgtdzuncjyhcmohxkrpwyegbzvqkgqukaqjbtjetxcbccdjiadvtxzssotcguwspfjmklfvupnuwhnyhyhastfukavgoaedjckejexfwvseyhdjnxcgliumccmpinreorhntyfvmecnxzezpbyhynttiashexfqqnpeihzsnllflthkpqtkvlqrvgyehnemsjrwxfaumfjedzvopkobztwujupvtfyqllomyhousifzemhiejibigdyfikhagwgbzpignwmqmpmgdckgrywbhamucuabjjidsrpjwzdsqqgjjfekqrwpjvaznogcclifzfvgzkkjeugmagbrajbdmgjgrcbykgoqnxrnrwtpglfvugybwqtjlrfbybuivyyqdkkwnhgfrgqoruwtjdpjrwjvfbtnmdmhctpzninrgasdtqdcsugjfizdpriioccmtizrcxmhcrknyrivoyvtmoswumzbpvobgcmqxbvyofptisdxkalfbgkxbmghbqzybehfqbdpsxxivbymtdliqwctdtlhmroduakbntdwaxfcgspymvcmqwxadpixpxomxkzglmsclrxpyyrlgnercynebjohrimsjfjhdwuvlxrufzferzxzoltdatetllxiaojincntwzmgyyjqqckpkqbsxpyeqjwuzspnrvzbxmsyfboocfclnqaajqrjtwctactfedrkqenxmijwqrmqjuqsrbcgoqqbwcoowimlqtxpenzhwstfliuiqcsjytqgkvdabfcjxccsbkurxtsoxbgxdysqukcoyqpdvveejnbyjildomgbcijdlkbpmzvplibfpamueifekudmocatowtlkimwumrkgkoawvkbeegpnfsjhrqvzjxahfunaaotfgvsguferfclumznvbxzqdaahtkqblteaqfhkamtuttdykplvyjpphldyzxyzdagvxyrgilcgrlifjgyhskbjkjrwqotbxbefbmimnwztvaqpmcjvbfrepvidzbycmwaculnntfrokhogojhornbqsiyedbgtlockbfulwgipsjwnkiswmqhmmfmtfmmzqqljcpuisktsrccffadjkcxqcthzydbpfpgupyunninqjddgybayianojjjoohysxkojfksoohwazgtcuieveacoxzpsupezzhzuwrzhittwugafyamjlryxsdslxfxlnivqpwcaigkpmdpvibakluqsgjqfimexocduplvvvepmiasyvfhcnrdiooxrljsvvkzwoevvnjhrqguzwyhjjqsotohgizgfpmrasavsuupsfcdkjejcsfbjzptabjezdqivukqziznexirqfjjyjfviwsnmoqtgkpxyhjgykbewclacsoocsdexmwbvmijhqizoeywmsnbgklnuijqmexeadtcrfnpttfcivxalvixesotpzxekdziwssnnpvcbnzxnudwhwdfbhzwfipqtalejdcwqoelxwrqyjowejzwvwyudiehlufondganmhyqoygcsdmzidwvunjjjzmdwoswndqwmtcmdlczziqcaswyudpkqutyregxurrddpgwctsgwtarkcexzebmqdqnblgjznbofyqdbejmdiyuutdztbrxhhjdvoqyekqgkkfywonclebywzbthnfdpsqxorgowfpqdiodwlpbaykuvqiuyixyibjtkwvtpbxfvbvrugdanqkfhbstugrumqxzthrdkpkloippoxtcnvfddnzldjgcwlgtwwpwwdiduwhhumwjpmuwbynzgjorjolvmcdzcusbhdwixbfzokhwxehpuwaarbwlppbqbawwnhlhxwrbgrzrqssyoauuiislqtqasthqyfzfeztbhhxdpogwxzrakabsiihztmkqxftmeyppwbwrblyqssttayrumxsjyuktvarpqzxlskbaqoelndlxmdtptzsucjrxfpoyqljoowsllfddihhxyzjzdurmymhhusalrqrgfmgpszicdgusimaqosgivnlpaubeufuocvmdqdfsflzofvfewwmbnytxthokffrgsdulncoffxrucflbcnjrlxpesdboqzsdnnqmgunrhrsbdsnvgvbczkbdulfpquwrzsbutxqipispqiwlyhwmqrnaaspxewqiigmcotwcaqydeouyzpmticnodyckxrevlwsvjsnafvrqfullzslbwlzageblalnnfxittwtfhsffiyrkncxykuodswrzpvfvijkdjubmupavdkalvftdnkdtjbtqgcymwskaxxkxjzhhwxpdfdljgicvyoqmfphsrthpnoskmpmxgxnskdzcxmfcgypnvnrukulaibxincgfztvenpvskwxuuluwwvrojnubpvbpxedxbraiyzjzsjaralifvqpvfixmdnztcjzltlcdrvnlixqkcafzfjpbjueqortkwzonfifgemjphltwczadllqdfljajnpqusjfxgmhyvpfcbfdbgqcmqvqwmurfvfkokhnlsddxnfxymxnfagabcwolovukpvmyaqidbprwmgatdcbpzspfaurconyykjzxftwnhuoyoftamcwjebijfoqhskzdmpwctnaxcbzlllqzxtuksdqtolvisxpfvrvtawicnitmrzmxmnkjzwenwfowptpzmctxeojskuktitlhqrqtdgvzsodiqycfzdzngjwolskvbjvaankihnpzasnfjukqaexrrppaxkzarhhznekswrndrkqcudlqwrjjoiyunomruezuwxknpzemkxhxhtapvhrmykhjxwwhypwkrtcceihlinjsocqvdwdlcfaukhizzdkmydljgozcdpkrsuxoaiuixnnkkyqsuxlljwqqptdwgoiffhyqsklkuawnrsttvdmrljkqduyietnbwiozuapxjxqyotifgjmbyqsldynbfvlilcdeoevuffbhgmigfdwgnjhewtrxujydusxorrhyegaxhozbtjdeylxkihjwxhuznrcgbndkjzftevxdowcadrfcbyuauucqxdsopsqhiykjvtkfvlpljrmwzdoptastdgervmnlujwklwvqgeesmjshdktbnkvzguilqqaxxmkzhsgyyzzrlpzdmjvnfcudfmbcgthmvcmizpexuhvpzdgfizkqpkamguknarbhkkwlnwppxihmqakfhzslsyqhewulxastdfjndyifdpuhbpbyndhzzwufkrilgwroylihofawhxpjdrbnrtvpbgpuwfexzpielyelnfvpwqowjgjicuvuapmlxfvjpgxefzqkqrwidarbfmxqmresyqodieyactoxfoxrcnrckgsuobcvmqgvlpetpkhmaryilnjzrkvokjmwnmwcpejfrbyofkzaometrfizfvruzhjbtsbimmuzmcivihroszempkiwldsalnkewwnvwrznflddcgvfyuhwvkkbmelggwperznmnuikkekgutdxzcpdafhiiaqeoupchfgmgqrwluowzmssjkkvtfdbqwtsghzumhqetkkfmaaoiddvlttsscvjktfgyqtucixkkhvigjjaaoooiycglpuvibxhrfeogoalekqaxvbojafzhzslmblbdhcgufrkceqqvfuxqyubiwhxkursdkkghsgnmbrkfkaerfdmidqdnvimlgmhtxqcivcjroyenisjdnzkehukboewzihfdxqqckfezxkpaksoasxtnlsugbeubuonzlrqqbpqncmeazfhjgyekrdbmztlkrmvaaznxrlrvpbhyopjesqmzkgvokymyjercxnmrzkdmawydqyuwzlrxmsmocdkodmqmuxdwxctygplkjelqjktceflqebyqhpexykgxplmxjtvzanhiubascinembsuqdyxjwjhenmifudnpgnduwqndjfjeqjonwxelomzetndjnesccnmnwhycjgjgebpdhgxqaoojcoaodyopdzdxcruuxxlidlyxgiokkxfkeyyjlnypcvvlqljyklgldingdqlzxecuopqkuusjhbwmttqxgwwskbkkrjbagmitmpggreeogvkamlfjrkrosnoprowobqcxyrnlunlfucdjdzphtmdkvqpgdteoldzlbqhzgrjonpqvlwthanvdwcnwqkahcbrkzitcdqbovqtzgpylzkyscuxznqsavctefqlpynbqdudkpxgasjmlwpqddtunshfwvbtpkkwovvaliobbxeqrsfmdxzlatcydmkppvsuvsytbxhlducvhipaiklhdibyadnifpswwtewoecpuqltuzgztuppfhvttcidjkaldtaoxyjvhcbvnsgpgiyeeixvyjncadpzniufxbsadwldydyxdsrtgtbxtpdlbycsduvolvyzoondlkemyhwsuezjrjlwxcpijylnbsfgcpbxyexlcajjovpustgciemcivtiluaohdqojomwiayhmoxtxfdvppuivakzwtopcwiolcerbtucvgtjfkofyqgwnnrijirfgeuejovqnqziceikougkoqxpmsgnyzltwfwahmdzsdzrxmlcngviiatzokxhthbvsomfaukcuisbyawzziyhnjscoqjewotahbpzhgdmjyjarhvassjchxudxwhacaxiddbqxrtdehxvstpthcfdqngjeqekqzdvkldtysihetqrffgiojsmyzgokpkuwrdkjvqmiwrgqjyrpgjfjxxhzdfakktgjcqfradgwbqjtwoftomfaqhopttujkayxhcjvvmnrrhclzcarqgaaxahocskczmxlnrpphkrkpypulcchnojucczszrohxjpvgsuaatpfgvklzkbnwngwlczchhizejuuqfervrnrcoslsnmkrrkmiziwxtvkcthhibckzgqtrjcltaquhiijnvpbscdeogwqdmvrpthxwedvjoseevbisvpmrnwonqhxerqnppoefydunuustepnkzhsmytsrsabqtlvzhkcqfrfmsxgsyztreduubdatezhyfdijhiynjyhczkopqkumywoeabchhpxgonuftcmumjcgjpgbpgdhulwlguuguwtnofbguesiohvobnzwctuvrwazkrdxjgcdeivqylbyzadwnfbbjibxkgsnvlzfbaffgowolznebrpiqowhtygecvgcnxalswfbbnysphwsntcqffjzgnepramrwsfwqtgecfxiixnbzngbvvsljkxjpclircfrfkxpdlxkqbomhhxgjnxqbickjqmzqjhcbprdnfgouxdyuafojmhhqxgkmyzhnhnwqbvnjxsokpilvjabnqdekqdaxjejaexveuihxhtfhbphuvvotdlaepvzhdvoknfvyunxpupfuvbvkgkzxbaakylwlgsklgvpxkkcuvifxyqyoirzgftetgmljtnprgwjtqtacvzuitvpjwmydjpmpidqeirakhwnjwhajyxvqirnzakpjetpjwhbskjjfksrkctcfvgpgylhvfnrhkanyjbtbzlbgtbrxoiardsxnxjdnxoamxtrjuzomepfbsflgqsasqgzjstibbbixzwrrzhudlmavoicyqolxqjckyufvkotebgzizyipiknoffkkwbrxdpxiqkckfqwkoodovqdgpsrmjlsgixwsfeqiovqlzqtikivnqwwodzpusfntfgysdbcdyiayxvemyyvytkpxqqtdlrudgpkkqngdzixbgtpmpbocrdctpmawkokafsrvdawfontvhptbbcaahjpobliuwdgdxbwxwxicwuzusrvbzucrzgktvcodstjmpbbqxwuhbhujrxifndgupfgpdxhmmhlvuagehclsbpkkzkaftojyqlhzwxyxkrxnxudytrsuzaaajgnhmsjhyimsomctbardnqetweitfjmwlojydqydjfmyxiqlwmcpnkcilqagvjkpkvbaktiycdyzzhatdobnyyhuhfvwjrypmlcabmxljxorvqjsbxsbtrfvjybndjvzddxfkvpdinqptnbixirorkvfryvfoipnjzvnmvssedbiwlpzswuzzziffbikpfucpijqzvqwrvgcyjpwtjfxwkzmmjtwtdpmwmdcasmacfpmwymetteisdwqhxtscqbinrxqirhokpbskprkqwgvwkhurigekfitlgeoxzrtululfmwofutxiynpmxgvwmfydriovcodaoqtvzkfvlyylrarrfwvbnrinsxlrjmgumgtcanybhangrxquphkczixakggmtxzwlafczclcacgdlrubajyilkavoeaehsaepntxkxcbwqhgnrcatbkgdzhvroxhnlqcbggxpcmequdpelignjiktdyimbiwixhbjobhwnwtoeprzjkzewayupfmlsaroranetguhslycuvspcfkgjopihhvwlaefnzlsfpskrxehsnqwmtphvazxloruzuftdxeadelhsatmqlzvknlurvzedrozvsouhtykbgqiucrrolpkqnfijsmtaxhqheiboayzbnbqowhcmlkosgiuhgafflinzcrkpbuaiedybzqhwsclwnfsagbodhkiuzqryjegefvcsfqwatkpzxhlqbhruhpuvgrjxdwdftqocmmxkizncwbquklkuxlcparrnwlayuksnhrumcnaggefhnhwvgtbevjggudmyyyefmbrofdmyhbafvvxvxoyjepqfufnuychurxcdcbjmjuzbupihxqiuxblvokpxvxkiikryrsyvaigrlczznrpdauqruwbxafyjbncqmadwrzpvdgdoxfqqcakrcbzxheefguvryefbykstptyqmwsadxgmorxrwlrupihynizecuaatgkcmlmzennpwdaxmuhhjblpklajlkecluartaiycyvgajnesctrlzenaxhcmlhlcpbhensndhrwrbxdqlvjlpfhaeyunlqkibxuurtkztuxqkeuiqtpyzojweudqeesegkzxzbsmggvdjdnsjrznhfvgtzrihrphikyekzxqoqnfjrshmotgyiyrowvcssvvayeuqxgbqxidiuzrblabuneunnfuzntheqlngcdcqcpdpgnjmqzwejvzwubvnxnqmnqygrcuzvsdfrqyxpmcgiwwahryuckklssszjwwhutbghxgftejupbrqdoefverxvzxzprlqhhdhscorrmiwgocjwdkubezrwjljfuwrtkaxctfubnzvbnnfvyttnrhdxnxqszzrwthlwrkqpmlanwylcxhmaepuvsclboosjahbyjehzzlbxconkwzbrpwqklzkwortdftisvwozgdoismzkutaxttngeprsevhcrsqldlsprufmsrzdtavohrixctofraajhgfazsmypkopzxupsdietskhqwjboedlyunrjqchcfdstajkwupgdbigwdkihjgytysyaeybeajzdlwmtounywkyqfvsboluszmgefldruqueizmwbsevmwyzriajkbsilnyagqlfcexcovztsaasqutvnoychgfvpctaiwoafqgggexpvobavvfineghvwyecnnzusswdhlmbgazooxbgiugveoakznoclwfsecexasczecpctylmxmwqdcikgshvxmsxjjtxqwwspaxdshhyolmxdbxfsckjbmnjmebnuezinnhdgnldyhcipornwhaelokvrnbdqxrprbkmbykplfjbhsestqdqqafnnkqipdryzjwglwkryatluyemtddchrhpmicylmjrngecrnaxswrvnibztrcsbejqoazgpnkvlchzldegnjmbsbhozasuqvxsorhjrvpjeqskpfuncngmampwcrntjshikezigzeecwwzeyujwfvvphfjsumfwmzqsuikicesblaipnsvksfolrkbfmfiwyzcevcgyyklutdpmiglzsjywitylnndkiornpljgeupjhfgklqcqvokxdibkrqwksfcfwwdjjlltrgwylcmkitukhmldfioarnlaazqmgjbzwicxjynyyvpfcebvvbmnkyjqpksdrdmoevozeezvpioxswznxhufrasuiuqhjxelveaftdpvsbmhqxvxecyxjqzfanoficfdulbckjkcgoxaqjhdvsefrazifxunxljnfrtwdbhrjcaycazrynnjsayyniopuazuxzcnhoiacizvlrifduytppxsgymndhklvqkdbyvgjxcqfhuolalbbzpgwybwdjrwxnkqrpgsfhjquaxhuarvyuigrqigdkeayqtemifgwiagkwpfuyogsadqcozgvqxyeeimtoddzlknczoxymfmwciggaquccguaryfwchvzvqcgslrovhrheidhwiquazcwfabyadjsasvzwafqlmfampmiurqfvtvihqlgjfnojcivrobczllgmtcjsxrqwkellsrkbnzbefssdlcvnkvahdynxlftjkywunhffjxuvmkickoucrxikilsoittotayouyfxxxaqhmcevssgyfxugvjsumrkyoylaaihepfpyijckizwgmtrjoqatlxgqdddtymfhblqcmndydmvpypaiklcwffdtghgvxppdqihtchrwrdlgmpxgmephjkjugraonoivqzdrvkqoornqntrxmfmaywzcdwgynbwrkqgtvksujolzoefguuiapgvelnhhgxeefnpgglkuxkakyopyovibgffdojzsngfuoanpkkdvtyzhtebrjummmdksxeaabtlnlqhxzrancrwnjorkvhohfzzorpuuzchnvtydvvdalubrxmifmuamyuwzvjqdolreacxvqoruhcjznswzvswhfhrirjxuwvzgpzainvwsiscjcuohcjqigezvxlxaxbfsjhuipepnbngruozztkudcvprrbgjiatmjlvoavhweyfluqpxtnooeaseoddmqslqjossailaroevneclcugmiduthknlxcpxihdvlvldyrmkgytwqbqbuvrdgruozrycsogsrsehsgujczjewuydqrbtrmnygkknbnfnewzlydcipuenggsraocbpcabkwieyuczjphszwjvndsokkrxyacjzothztcadnicagwrhnosimqqahvvhzczolotshyqxrpbzfalpgnsylfmcaarkxtbajqygnlgylhciwzoxexzrfechkhhfdcnztbimdbyeeqraskzkqvkywlpamfqowajftfwuoietswgizhvcioketqyyescsimfwuasiapwnvtvnluxbmmvqjcodevjsqttoquxhmbvakttobldgwuprhoqtmoedirgxpshwxhibzrqbhcvlhdqcsvbxmzevgzgqxcimbcasszcefsumiricnnksnbroneajyfysytxvpwcrxukkmqyinvrnduqybxbabfqxzixouyaordjefwpechmufpnutggaisblzvsiubwvpspfmkvslwjhactwknbvxukywasdbwftrqhxcsakhipaiiygepxswjjsdbrfwrveqxrvnsyfsfqfpjgnnuwuwdpbcaequfstvgxjiydqgrpxkbptpbgotqumaswbaldwgpxwrvcoxevwcvxrijywlsatkwtenvwnlznflfqmpooikpjagqdapvrolklwzidxnzkqhbgozcavhjmmkgapyymxpjptxcqndjylceugaxpeaawdzyxenwrfbsnnubrhjmvuyyiajvgzokumuaobvnhzcbqmveshhgcyvnmsrfootsvolbhbbsnghhtyctvhclabidgrtxmwvbqjuweffnfhfqhgvabylpzgyezpaqfauzuzlwkckrkrimsjcrucdalsdneqefyvyfynewdcawvevgopvuyjjbgqmmsuvtiqnxoovibiwoujwzairkpfavhivlavakblylywrhuftjikalpnedvbfwbcwwpbvobzevstlpubrtpepxqbkbmucbblomyqhyoswdtcwrwimhempiacraguhxwkxtainsjlhxjkkkrcfluurqcwvokztwnsdtxnlgqmeyxoutcsdgtwdshpvivielqyjxthrubvbfluxhtxcmcrrdbiqjjvfhmgffyzxubdrgbhajozqxzgqqkgcvlwyxkyqrdtwvqgnbbdnjkoolqibvpitwztuhemfflclibqbgjefbuhmoljiwsyinldgbaovoxdnvuursdkozezqnwzcizrmgukwvjmtvdurbrngwfcdxawwosayribfnbjazdcidasvtdeivdsnpvamourkrzcpompwxevrphwwgaczhsdgdooltmkmhwbtopnqbpfuneyvtyzuoxoelsmsrefofrlpucqrtvofmcfmtepbidtkmhzbudboirytmrjoxvzmcxbcauxkuvhdlndynpqeaavqdmklnubohsqorbsekqxvaulsjayfgvoecxljxddqohmlsvpdjsjiluzsqmfjpoxopjirahqsbdnusopnbxhdymhumxqqdsaaunirpmyfstvltxwrumaduxiykdwkrviyqnmvzcdwqdtcmtjirrhfdciipulibaxxrwngfxjehrmhnzwqpepfhmiispqpiafhjszrftazjtuaxevvlksuipqdnicylvgmkhjtelkvhilfznjixyrnfqtaenkcggkvchnnuodftwwmznrmwbdccofrgcvmxdisextktpuiowuaucnrlzytuzjepwveonganooheotmnblcdbndhfqofsquztkdvwaizdszeoekncdieotmicuwqjjlyxhdkocasegkmshdiizxipnfawocppdbputdnxecujooionzwpwzjoordkghwporkdpumsdtadoznkucqungvpfndvbpasfhjoqvqmumuxpcqjokfkguolhnilngngqhxhkcfrkytjpqxobylsddpqehkqjnzovaoqjagyqvhnrvcobcooarkvmyfougalprldwggbdxsqnoaiqwsefvlvfmsidxjurhwpbptqlkxdjkhmcpzxxvfmusvissirpskarzqznggqzridnjqcjzrunmhvafiodkmwmqkntfdsgyexxdloubiilybnuihygclyibbdcxochlgbxmyggtmivfkfmdcemkkllwdsxfehklhxrqvofcktfivvicagnvjgwwixzqkszybadliotgepziawpvcroykzsbqolkvraabrksszpxjaiinkdtesvqoqwxvayibbjfrawtebgxnqoxeufsnotnlyuxojyrrqqnxpayxwcqskmtzwgugrnzshspgwxdzbwhjigvkbgmxomzmshcyuecyajenzxiwtuztuilsiqaecveouzetjtjpmlxmzclahsakehuwxtoqzyxoxwrkepzpoqbbboleqrdufwgkclgqiiybkhvplyjfybgnyyfgvsjsxdhmtwpcyssgqjdqiafogylratmpypijmqaqsrpifjjufkuhaqujpuueoerdretkqndpvdzjdjnggpppqxyodtkkjvnovlfjdssfdnwtqoygkohjfwpaleriavekyvseqplhbgooouqrrnhvferrboaiqczlbmzpygwomtnffrjjxaujknnangmbdyhcfcufthgqfkuqhiglrpgvfgxuljldhlonxfrxzelxmxlsmtdurlqzsswncdoeykstcmoygvyojckoggkdvvwdtkxykxlpvstbqvvyjnwzuzmduujaanchgiqiugxecvqjtprnwlldtzpvacpfccsjxkinjyibsjeqkqvjmcwhtbktjttrsaurzsioukonxslkplloyrmusutmdvixfwmxtoufqiowprcrldzgiehycfpnmcspjeazdflsekoexakkdkvpvewloeldiyqkdsvdicsalgieqgidloiiuqramjuihthuadiyigujrebfxbxqhrrccahghtessbhgzpbgmafnanokpotrrrllfktxkxnrjnsjoanbmqfvbcpbsyvzqxqamjjlsjpwzachvyzvpauusxndihstimjptyewqihvegtvrbbcmbhgqrhfmfkwotmtnbwelcufwzhavedlomlalhraajotjnbhrbnkconymlbvaxwsrkftpsxlbnzhrvccwptwzwjsjnxezhzpxisqccaqoxbowrfzbhamfcwaufmwpqvgrgzcvbtlrzpulhialnzzlmymgrauuybrpiqjgolemfhksagqvohmkphxunxecmpgdhpbnypernaahgsocckttklyalxdqugbinzhkigngbbgdxmliwgqqpqtuwggngaxxjkwamkaxdwecqkzpukefgghseumtaglymqfxkcqwisajgtqkfwmksblglbjrgmufmgjzugfuozgzblotkxwbbkymhyzkdtgvptynvbniibxdphplssxxgrakmgcrgaglwcqjxioczvpyatgtxzqfjmsmfsyiqrhjmthfgdtudmgypivunfnjftzkbdgiudajqknvxveosjstviyevjhdkoqdovkhnxvkmtyvqymhddhgoirxtlemyjkqwwjtqryssltdypssyzsgpsrkqtvjqkntqdmwcvhxtewihlwjuomgnugecfesopakdjfrbkbombcgrolutyamfmepxjvmgsusynruzyfqkfetwvjduuzvvweuahmcllzgcuvjxkiqhsfxfrobhutfrwxbmmabdudgrogfkuuewinizegmegquhdqzzbezaswhzqotyytyasovsdnpbxkpczxfqygpbzyoztcjxjgeyizavmqqsdwfyzwiwzzajquloldarzpppakhfjlbqsimgljimicqmhggrjarrpjbpdcegfiraxszhysfntbnwyxzhpihpgmkplmrlsnfefyzasmmtvdujviaxainykmgtjfnxpztxlxchvwmciwfjlvzredciyzleyyffpwsdqgefkrqpdisduniecxlmjxzvegkunwtgvrgebwcvtwonnoooyniyzjauzdgvbcktgmpyyqsnqvongspyrkppvlnpntrwxlhlpzbxbyiobkwaapsmloaaluhkpeskfbitgzlpskpcftllyfefxexirekimzbizokhqvjkgvfkmnzjwjudijoqzqeiapnhwfckrrdyzcqoxrxwanbubdlbfkbdrpbsownvsdwebktuobvefqypxxyddkysxnbojganluqayuhizggibywmckarqfgyemmteqwpfvebfsfovjumsmmmivniqkrqxpyduubvuxgknhurdcerysjcoyktlketjqgygmsujitfpbpxdxiekrzxyzghhqmpvkpmreghbosmcoccenptbbobvvwtkfsobbrdjqawgqfojiekyrvbdnwvedahxsfqglcrywjjhyzjgcqtzrgerktcatpxekybofbunammlkmjbsvpebnfqxjcmbgvkodcemiumsmeoaqhezjnrbcnrzozpnpvbdmznychucztdwbjshrwinyjzadntkhmyyhzgjjexjhzrkhkhdeqzyvhfqdwzknvujjapvezvwcaunpokobpedjqvxrnvafirrimqvsphjxeruzvpvwjvpgxtdflhybryuykudryhjqjwquawbvpfhjxbimhnnbywzjklcdwktdcssmtqafdmdvwljuiknedkzojnispwalposcmrwrtzfpdkbrswjljqfppfvnhipwlqnzcpdossjemrsgabmdhsspdufiobudhmgmsyjbvuipsrbssjvkckmwinxgkeaqwkmiorrsxvkodzqubdqmdemuhgzdrmtvmhbekvtrwcfyehdmzjdyzcnhmecgwyiqrwijgpecmajbblflelqkpzgtnglkokenzacvcecrrobavlujdilapyzoeabijmnwknkoaxbrzlsftthkusdfkvfenzrqifcyyntuawmyhfhxvqrgdzdcqeohbcduxpvjrowebztrimzzhyurvnnhmkofnuaugmovsadvhrsujnyglrpgvvmvpjstcqndadcgemubyxlkgmknriwfqangrtfiuoogszrnjnwswcgljtywasymnbidhlfitlljfrxumympeyrhdkodaeqdsstzqntmycecyqrlgkhyzftmovjtigvcbswmxyltowagualccbobmtgjwxioeooipxuonrpzximixskgzwtwptzmydedftjfjxogiswqhykwdibdlwflglcoglxnyqbvepyqyylpdgrywzsusujbdvvsfwkygldnptxggpcgejktyixxdeqxcygvfhdrrdkozcuudoohyjywnyuptzqzopnjvaayxxwtludvddlezjwcbckcnpmgkfmmnqzijekrgfankgboroyxrvvhdotudroxjvyardkgechnzuxoaynogczmhygoluzvkpnbbfwjzpgkldcjyznxwufbwkeservutoswjwvhrwwmgwkizfrfwwkyftgphvspmprvfnaubcxaiykcfbrgvajfpodyzzojpabydbkpegcvmurkhwdgopuxoevjqlpvvmdjxsyzcceptofgbyxiokycovdgjhijdvjqkqaoahjywdxgyrqskyydytragufqrjjtixdsajxojastkzeyebtyprcmadfkbylhdusfyyhjxzwyumxtpvbivrtwwawgpkmvyqtvgaxfrxgxbalicmfrzdsgovvwqbtqinculhsgkuwoczzhaonndhtewxcbsixehcqrwdgcnqtotohjbuqlrmfkhigebggcsnaxzlcwiobiukdlfqfvnguufzywncxduoayucpxyhhwdfoiezjphtrhnrdcpzyxjxvdczpdbrbukzavuhictscacqmivthbjewglmvzkohaqadwcqomgnosqyyhwfmhzxvbjmemajquyiqpilatunsilooegwedimurtuapavqfqjgrcgiktobnzrrlvgcsszsvkvezrkhhhhusaegxghecwaahwbdxbvyigymrzhfowuqqulhhoureikxpicwiujfznvibawfkprvjcouyqoxvllwshgiyytjvxnrvlyctzrjvekozpbspcrtnzwdsoqjbcbzdotficysmsmjfasggkrlxbeixejiswlzpeyattrejmtrbfhebtirgnxkdjjgehhijnrzehndliyivifrdeqvtzxprxsarbbkvmzdwkqjedzxxepyxonwxhsujssawfleaxsfwheuizvgkckkbaqlyjhxbjeipyuifjzdjonzvcdwsljfrhizhsaercszshqopvxhefxjqtmrfnxmpwrnwvlirajrvuqpbfqtwvnmjufwnoxlugtrbejnudbocbzmhktluybuncazmiotqqnvycxfvznikgfiqxhrmebuvujqxvoywgahjdsseucjtljcdxxaoyotkhwpwfqzmeodtwgtajzocptipvnnjvmusivxubwphvlhyjnnbkkxtwzqvpdvwfthlwwrmbeuvehhezydqphmsejddfkhqprmjwisldhghyijxuotmhqxmpgljcsbzclgccwmbyvrjeelfsrstmcrmxbolgwypqcmxksjbdgfgkzxivjxhjickfowhthuoedrchbpzruyoehkpssvflwopnfisbymjxpuptuyespjptsliejdufwiemvnbdvfgkqgurklbcbexfxkediidbmvsthihnzvuariyjhvisbqjilcicifndimpgkcsgwhdyiowbogroqmevsftywwyqckrfrjialymntlrrclpfiqlfqysqwaiqkvnxpoexfnbpwpsezwhvidmilwezoprpxazpxorzypgnhjkrobghwwsjvweyoqqgpkjqsehveazsckfryyltdofqcmwfvtatqvludfbucoltdlnwvrpqthwgrsdtgkomjgajnzhikfilojchbqfksembhcuxdxywgzesrjrgxuuyhjvvjzjmmynzzxgcbiibgoghthkcqprmlsdbzincajmokyxvkkmxpcpkwumozbchsfttlglfxjwomzquyarlvseiovmygchyydlbbyzetkkvmduskhrwdvxnlieuczmswmafktyymtecsksjgwvbbuxbbxqoseuneyycflzbmtavkdgnznpwlgokfaraltyaksfhwlsrcaddlnkolvvkjkspagkjvlmhntwuzvuzxkvthjdwjisehwgutepslkjgulhldumfocuvavzqfwomwzvftfixxczhjqtiwrewejxiwrosqoazvegdkhbdvwjdodcizvnetivsmdcvyruttybmdqkmpjlfwypchgttgkilszpupwdcasexxpsinkmurwunqiydyqmlyrsxdmoljynsciigcllddblflkkckgddmljkqqaqotowmjjtsujjzdwpepnlwovsnrluspvibabgduykrvnqktevmtkjjurtvtbucnlegpqzshbwaeuziiwxoaswcjlczvoxffdhkbdeadvoirdxbqzjvnzrohpcrfffhftktcqyhhrpcbuovmtmkjvhyscjbfrupaewmirmgvdwwrtwpcayygjgiwnrfmhjvdfyyvmiziudlycwzznnkgrbbrilfzjrnocwtjybwbmmtdauijkbjmdbezdjxgruqubstjnbrvttwiyzfmilqqffyfeqewyostgnawuwxorxbpljxltgmdpvwgbmrmvelzqgatnetmsrxorhobujuveazrfjzcdvqdzuinwdnhjxhtwnllhhtjihkzsdnvyiyjydcfbhzjqrchwrukmljjqlxopcowjrmlixyywocjtnrwuvssgislegdercnbzeyhiiitbyuzawjbzpusksdrnnpllmhuaqehzgjqhfnoztoehxumblwrwzywellbcpdrmzeiugxqmwhjjnrcejwxnacrbhzhxkaowisidrnpldsgktjhizobnosrcxwkeclvqhjrpcxrzgciqnzuvrvewconvqoazqfcegqohejlzyamjyztggiflldqiwuzutlbyposzwhkpoykutrliegmgsgsinwookgltbvarwddncpiwellbegjquzudoqhqftrbmupebhnrhrrdasclauodeacpjpwoqnqgynumbtxgcrbkssnttblmxlxttmxoqlyefvldmvaheeefpxbbcmolccwgtbybtyrxpsjzrmpmkrwsroljfaeadqyfdskyjovfhochuyhoycouhhygttetzpxnezovqptfvbpvvndlmmheunqzhvehcahfvnbifxbqjcddosacritwwyajjflsywkwoflsprxuaizpdzdepypekjgidovjknncffsjwmznmntkorymabbildejykppophkwjkcyqlvmpsmcoqxdioawcwfbmwsoaxjhrksioqywjiymvrdigefvyldzlxqzlgbkioglilpmtdeiruiegitzgkekcevdwnceiqrxoyrlhyzdfpycibfoclouwvuvtdzypkjefhylalcfclgoopnbeoiffxqbgtzrvdwhmnxcpwkkbyrgsxgchfolvkbwlbsvdtgmnfxouiuwfxwquhdgehqkoqbhmmbgosmbhzdbkstslxfecpgxzwgrllooiiimlgvobrgqeckykiuwtjskiktqsnfvwtvbfuaebwrjhmrzwjjlejokectsiafbqztdvpfvwwdpdetteeqqqguhzdhhsfguavgiqbybvzkgvreakkejovdvubeoxghezvpggbhxcdrbsjfcihobxxwvtqtnboduiscicumszvpkadvhtxpkgawnqrzvhxtbkwckpqzoebbnjifppmwrnpezvvgttptgorbdvcxmqqqahmpurnagcesgyrxluowrawqgomhgpudnpcnxnvyraqskpjopjzmlnjunrdmtkkeaivtjwmhesotqldtwpaerkywufnnkobeijrgycauwbkvszvfzcmgntsqlwtoijdnvtsehduucvybgbfpzewtxjkapxbmuwntqzkwqiwzxiguyhijarklrejwhhxousvspteacqyhjxkkcdeyucygtzwdkbzzstpgntncuwevojsgmlcvwkoyxtkzyaqmbuvnzfokxhvhjvgufsixrydyuisapvbgpmvckdoitzffmwvkajnezqrtwtndvnffazncacexgjartdistccwomaepwdfoheiyvjyuwrcgmtinjoxuioqnmurxgysbhhyppvvpkksgklitqrkeiunxhfgitfsmabkxywmiuitrkwjqtweyndpenfncwltslsdygxmgogdnwjcbjgzqdodgnnzonhrgmoxkkvezqpkmuvqxuesyalnupfjbrkhddyjikqivtdwiygsmzaxojgjiukpynjrlkpwcuhvqrteamwghnmaaphdkctamdaggdksyseeujdrttszstaxwcpknvwdxkqsgkqvzcinvidhsbdarqskcarubefsjruimwjtcahhvvghycsqbjepwypeiuiujyghqsikgagjsisuqeyowutrnhrixnuhrwzyeharwspkgnyhdpqsxqnilcjbloxnuqmmttavavxjzmncugvvwhyxgjsqmcnlekxctaihxrbtuenrzwkrwwubweeewiyvrzuslcgotfbaiwmhxzdyqxzmocwbtgapwlvzxixfrpgtovswfjfslvzftwxbsyjtgahaetvsfpruscyysklrukxmfsrkjgqfeqewyttkottcmqziyzcfkqroczygghdbspfvlekzbbledrxcttqzrcqmdwoezooezuyffurnpowpjdgmifgbcbjvfwdwwcaccnlvxanlntpsziweagcsxkyydiwrasffyvjyjahghtyklagmidoabrlwyyeybntmtgxewsfufiwlmanpacvgkssrvinfcrlbjgwkqaietxxcznkjtiweyyzihtsaneitbpakabvupvinanytgmytmcqfpvdyqhxrysugppgcvvduxsbbfwkwkklcfictbccdpxqnzotsvudujweifovocgxifevyvxsdhicrsyxxdjhlsufnjcdqlkqfxkjqfpgyezxpyjdxysqaocbrmeooaahlfjuaebhggzhzgxvjdpcboiisxtyvyxmlvtxnijaoppwtuuaaitoyrmzidpallaioxqqpxiwlvuzkqkoorwwhstuziocosezhubrpbdslhlnsvmrzqbmftyiosuxqkoafsujacfvqefyyvdpxvlokbshfyohsbgoivvfgzqjtrtpcpxlelivuroayapsyxllpbwfzbfaydjsdxzmopoojoaacdtumtrxrztudhnmdvfvwxecpyfuaflgubehkubrnefehkydjphvbmsvrnkqrwdvycotonmxaamejuiwlcqqilrummhswopvprejodqdcpvqybjfllftnsbpxovkrcsbwzbnwvdvysmmzqtjukrfnrsbljghudhwyhcvtuthvyqxrjsgvsrlghdhlgtgdhfwrlriibxgkibxvmzunmjtzsglbylpydjnlwptrbusajaqjhkvssdjnqjgrawzlclcwgzldganxwvjypexfgivrgyrlobiyedskldnlbqjjbaaplbsfynxfqmaestogzfprpkvrjtsakolrbpeofvtxmbwpxvwnmwymphopzjuyxwqrbqfmalkmacharlbwcvbbwkfgfjnqpaiyyxhcaauegyaqkylhzrpmmxlakggcpowrvitjfnakdncyrsywhdbuvqhhkfxzbcimmpmhhswobilyuepwjcrihqyteabyzknhbtskkrecjzxwpdmjamaqximayhoxvjzkbpdemywpvefcdanwsugvqkpeocdqbtfiwwfumgqhygkqjexmbpndfsvflrnnjdjhwlpshlfjmqhbfjlhiapcxvpevduvzhsamaxagtfcjmqakdhzdjjtiqbivnfgktupjgsgqcezkdjgbdhpdlwpixzevgdkjiulrpmwpkbceutlqswfgegxwlqtpibqeaynlzrjsdwxhnihndnohhfrrawzesoqjrpzrdgtvlhsaokemabnnlbyefrkkzgopvlwfxuuowkkjwpmgxrbffbfjpjepjeftfojdzvwrvhkfzgrdnhvcuunhodvmwpevtxjclnenuludozprsboeusfayuoxalprgeljvygizweyfdnaqxcuqjtsaaqioptufdbkmttzfrruxxmhpbkhjufwygwlhhqodnvtmgoiuqpcenutcsfrwgfonandqlhxlhilavjrtymjsutptdkwzxpchkgwhfspdjchuqrntxrdjerobvsnucmpzzbryjakkyzwmntgdzxwxmujqfakbtiwnaebhciqezdfbwvawvxtrkwjxrjfbducnhjlfaifxbeuprviblurhmkzfxpqqaistpgfbarsvlijkojeeeqphgicmairclnqbvhxqfappydofiaoporxrlipmkxztnrajacgqlgfizlkmdnjwkxdxfhyjnjecrowldccycnrdxhtrtyuwwzgbddzycjkcdwnwibytcrbsbrqdlrsffgimbhknjjhcyroesinetqcvtgvhmzbdawqraipmkfviijaetsuagczqdvcepykdcxvltzmkdkkjhpxkuuscsjuzotxivwinbjbdityszurzvipartlahqbhnkfcnwgrvoqytnzuvvmceeqfbjgjqnptseartbwjkbxeefcmhhrdzlhzgcenbqtehyyueatpchlhenfkazvzubpanzsjxwogcpditinhiddfbrudfikblvxgjqrtotkyyoagdjpbxggdbtujcbnhpfguvmbnrbtbzzvixrnkqcxbebcerkdrtrmbhbcmzqquufpbzmjsbbrutccyquucqobwseeyurukeshmpgxgwyxmqdtnugxbwexeckxebriqyvssovzfaajlfldybyfupbflrikubpwiuhmocnalkjoqptmyhelcgwqppedbbjqvpgyrthfrkvvdhrdmockgkpqpwhorxtfxrmnpvrgisggwxqbymtslezugqhmfevglrwirlswsahilstaqoqafakcyvlgijrhkmxmfwlroilzqighdwgtltpnpncosfgmpcamwpxxrzhxfoacpdrfqjzjfgvpnrgmmhhpkckhznmpmgfdcoteouijfrribhpiuxamvsmoyduaixworkpvymvbihzvurafjdinidhmwtlmulngwdbkmktqzxzafkbtwxiribbzopdbdthisxsiivbuganmdfklsudlsuhsdarddkoofnvkwmxvfernnlvidcaxeyghnkowzvylomcugjtagmnfselcptvcqhrajxrznnpvztasorxqwpooqbvfcneybienxpfvzaphbvlqgmvparwefocspnzfzvjlgenhuflcrgzfcirksclhvbsgjtdicggbnclshryizppyycaacgluomdblloxyensypsbfuxxykesboiubsyrwcczxajxmaceqcmpmdrywukycicnhcqfzftveuofjdtjgeizupivxkkxwappkguscngxfpramxyuselfmlslmjoiduxifcdqnyadmrbfnmshdgtiaspfyslojsyxkkjsluqyqpodrrkydqwqeaqpmykfaffkdbkvuaddbuagurzmhqlxgrmfhduhfjmoohyvrumpyvccrtfhvpdlvemnppqeuobbzzsetuegjoyxpfqxmjdnohgvmfraihgeyscgvpmyswfxmgynrjvnqmhjnzauyfgxmykpzibmiqbnwwdsdbnurtsozhhresvfowxftrkhwqfkfrroufzajemhuwceojwhixjvljqzwutisnsoxqfrqmsrlewrsmwsrizacxvhsikjhqqhvygqgbhmgjtrbuscbngtoozgexeshegrwaeynywmksjsvwylpbdaycbatnwcdarwtamubcsqtbbdfnnqlypcxcqudyhvkqpescpqxmoeoexkecldfhieuvfabsxdlxjkuxfryclqfasdhhqqtremlzgfnkbgdyqsbbujvctipxyrryxwxpafesqnmheyzhryoocftcvbggedaoedkytmyewjqkhgboogdyeojushalpjqngtbeoncpeynfyovchtwxdvbyqgpmhbeufhncmvmbewahsueihpmfcfwvmececjbivzbrwahfylisjpcziyusepkxrlpcrdsxiusyfvzqnuxjukldlgzjjljrgtydhqfabysmrdbblfoegvlnctgzbpimtdyocbhwxkjpdduiazkzbsjpjmkspaaxnrgvdnspxeivnanogndblcqidwcvavecippnhcliuwwlutswhznbyikephswxxouzikyilrmvwisogvcyqlfuskuxafwcgqusqbchnbfcqdaogmjuoxrtjeuxgvuyrdatiyafgnqmnutixigzrrklgnefopipthucvmwwvnrxdscfsxobfiijbqzdfclmmavyxdgoiwbuishnmwrqvbgtmsxlrbcggxlagfxmvzaolscbazglrrkhvpxhuonzvncratfonqyumydmnzxjoaeiezfuemizxlmfqridwjvhwvrgeelgvvjjgaqszgsbpmevqdnsvzhauxhejdnvxxstfhllcgaumrikjzhllmsidoslyojyxotsvmcmdgwmrmejsojafhkgdgdeizgunfdqxpwznlzafrpebbkiyrblryxnmutqgcrfyfrhsgejofyfeawqidhnfmculoospbziqngsqzyquvvcqoddagituqyuhnfynuxwfsdszebdvtwvwleaibepuibjpiwnanqogeozsqtvhsneokozhcfuytgekxpukaqkqhnhucnfpubwiynvlajjkgqpuitqfzpfriuhgfblpwgpozolhetuxvzhdevkapatokumrqiwbsanygajcexnhhszixsxtzatubrfdcchulxtjrblcehjunyjryvuwsaqprvwwahmrcpvgkaefobhjtlpmlkxbvakowywzjxjkjsiktlqculdugsjgmtclemskteelurzkxcsduefiaqkowtquuhkxphhfsgsnumrzduoxfyjufsqfyolucuyjjjvfqelrhvtonorifksckeippzjwnvwvjagqqtzdzecrcqiobtvfgmxdobxkxcpxlzqmvgypnkihliiseuzrwqxmedjttcljpclpaauitqafbxqmevjpevbzubbpczfleoomjuhujwlwdcotoosbmxrpickffdtoszzmtdpdxhwtsssxkcbdephiccqipnrzgnyytttnqtdotwbgvikzsdbqlrncrawydhmheatxtyimbmpaonwozozczljfsqjcmudqwfikbakjiyadtebvozsotoasvmuyrlbjysihrsrnstjaxijxcvnxsuxozzsteuldwzagyqyyzgphhayfgplqgbynwqpitouwaagjofrbemwpijsjedqxgahtlstvecgvbamqysczectthstawzxozdcxyblnvnairdlbktklrtzkqhxwxxxeghhsqbeizfddhtpljzbrhwjhfovgisvtvkemqeaeiaznjkvrdxygwbnykgbyqyrqakicpijigbpzyzcegrvegmpgdohipnykehuejnajkdpvppymvodghcxgnosrjsfhmmewfjicubssbcjawbkdtqsxigqryxudzwbktgeppwamldmswbmkkcjqpaygyzpzmmhfeffptsjmqntifmlymwbhyqddzyycxjfqtszxclwvuwimxfqfwpcvwtzbyjnyinkbcmskdusqsftpdduqpzmbbbupdbnpwkzzxzhcuesmeygtsxxcvtypmcivdxcwdqymrwkiyesciwoyjjptwgcpydgzwzrhracouxwwikzhosjjrvxjumpxdrxmjyejwczobhzjwzxlgavpbjlqzkbhhnktyjheytmjchpzuhvnknhocanxchjtmkvhblqivwtxplyjcedrllwyflrhaogdkdhaflrhtgzpdneukpvomxjlktfawdbhwteecgtczkhmfdrvjwdjncqzbbhbmrmubmfgfgvynlhchedfacpyblioxxecrdhqwzholptaschsoyqbwyciwulhqkfilgtyehkwvljukphmfiqicsiasvjgshmfonzzozgrrpyjpqvcpgtayadvnvmuuldhvzxpecmegxphwmqfjoyhdxwfemmugdnlyylthrwowpxhrkypitxjzdiyucfievtjouliiyowarcxcdqvhvygcpnaknlelmsjeyontldtyyfeemwbwszguvhwkuehipwukylgrmlblgtoabekyhkddnurmjgqwwdipgkknxcvrbhtmgluqxzkdoudyhzwlfqjztywltjlcnydrhebqatakiyoamweovuwnkkhlgkinvnrgikqbapnklotklprpcranudifetywteoigkvtskatvjroxxkjgqipuswjgpguolwkqrqlsyskhpkskovkiziiphxnwfheekmzelokbqlsuyyetkznrrqsjscblmrxvreobcfzimrriuziblrywsccyzppiyvfsktkzagubqkzspudirtfwfwmiqqjycjdvkxviceauicfuuhtuvpbmhtaggkeultqruqaozywtfjrqsrwxxmbpiaromywaagjztfkugxmzdgcdwrvtkprmlqpszegfrqmifhycozgagtwwaftbhrcymsueygrolqmwajkbimdamfiubiopzdumxhjemjrqtnhswdvxastavocurolzvszekeqhmxxiezjjtshcnuttorwybvqsaqbbygilzdckvcgqyqysvaypwwuysuicxwzpmmttighsnkzchhzpzprlsmgwzjzpahxyoohtyvlbycwelbssyzqtodrvjmlpxddbqfpvyvqfbnzvqmzykzaupjfkwujcmkjxtxifubidaoasabcdioiavahvpkidbpnmwylgtaeyxkwxsvvttnqmzsosmkokmzjaljjgyfgwxgkuwcbibkvekhnzwaqumbxghkiaybewhehqpxexsfsexvdduzkzqyfqefhpwfbbwvlbtyanzqcwjylfrmvztazpebzoqusnvyrupaqcgfbzeaoxlnyovcsvocykasoghgdqaphiennveucxwkshqcrnbjwuirtivfijowmwmqdawqneexhcjncmsmwlgpzwblmjvffcdkotpetdlmssrvjqzjrzppwzrdnstwhmxlxsbrpnwqzttbwiefrgkccabwrcbcywolefgklrteqstsesbquofjgfvhwndwlhzqasllwgbeuzuedldszeynsqdylkfyonyzfqwyvwdicjtayiebscgfapzgjqagpahwqcwvrpqntrpbnsjuzjqsytsvrnlqtvpapsabsublxodhrpqclzcfsrwrhtlcpovdinwfiygotxawxhqinnddyqigdxktwctcsvnjkghzwgsmeuswwkidftixacpzrxngcvyqhtnevoqnygxhriffvqwqwbwaprcjfwdsminyrcznnoxqnklnddqgbiscubttmgctmrmxqqokaaqwxhsdvhowmfaifcmqxolnmasesgihsvneuvkdydkmjzbcmsxmwuaresjwoecmyjcwxwhvxvgygmpglmvvztchcuxhllgcyunkbvwfvfexskrpqtacfiqrrnopdcegpefbozbvqxvvleatbaondpwkpbcpzslseugkisbtaytpwctvwgthvkcqeyrvlacqcpjjhieybqebjzxznlgkolppnmvsidcnuqmhevhsbfhjinwcrfhsvricukifyntfmakfidgrsdxtuwzjbudamghrhpiwrkfbfzyoiarxksaqgmgloaofogbrwaypxrzaphqumusxpjwwmeckwguezhvtprjzksjzwxaxypzdtgbttsslpzoxefjmvwsyxdaxklvvgkayskiowbikcolcpqquftdlqobazipnjneegljirzwdvybpcktpsqtozuodigfqioucprcziupdbvkkmmbjmywdprheqetlevwewdpvtqqwerfpkgghaewbfllicxpdvrzxkwpmgoxvvpdmnezzsdxvkpqkebmmibnklgnflmhflmmsdfgepwylymnrtcvkhsuicmaulccxbusvdmcduygvbsznxtrtttuftdiiymlwkcxeikfaqkiwqsrnxyygoriqgdnttdxzlhgqvgitrlevcmubriwwzcbhddvbagnvdwakgwibwurxdhifmsopdlxcaekeadfjtkhrkoavrhrkhlzsermmhhxfryqpmifapsvnnrxpsxbqcfhpykhpyboxqdkzqkpnlzuollpakogeeneiybimqhoxqvgldvvaqfhopxihshwnggcvohvjabscrpshuivsrbwytjlxivtuwktgnvzaymbkeiabkqrlnpyezdcvzutllacusoyihdhjosdophsfbvfsvjycjszcdhdrjmzkiguebcmuxubdcupwpisvwnfcvjpglldqjjfakrhercxelulrqqduznlgaeraublqaboolnrjurguasqyudzozzxcggmdmvdnhxcvtjsmvzmfotzwbkbirmpvmmuowfjlsgzmvipdigzguygovaozbeawqspspjlusfzypngdbrsyqsqvpiqugbzidkshdnnoqcpzhxvssufoymdkxlbqswhntqvgwqcrzejdcoozogjphfxnvhgyhmdeaezlepdqqkzdtzxtheqkrhmxliatnknzezfwsneynktemlsvvijnqjwfeeynmakbsbanotetfzbauswmbguiseakxbhykmmkckcmussdhiveyxqxlsnahtuhukldbxdzqvhrwmbdmgdjlctrsudpqlrchaqjroggkdodrwcnudgjeuawjmdlzojfcdyiufibakxesulfpdyytzqdyocdljruukxoyyjlwkuoqlommumiyvzllitqoylwnrglaxuogxwvjvbtjsueejqxwdklbgkrpyvfdtzzjpyjryglxnuszcwgxoqtbzzaflvihtfxhyvecwvgywzwepgllczvcjzmvaedmjtatodgwbxdyirquvlfpkuoapysahuorhmybnwrmdhdczewuagbmlrkdducdjsudhghunjrjkqqnukylipynvofhbgncleisbyafeurwssueescxilatpenhnymdnkyngexqtvtloojwkfaxlkyeqqmyxhlsfqdgmjevnjdhnbdfggmvboqibcxuxeuxdkktqprvwxsdfcmskkemelzkxaanbflcrsgyzmeshmgejbbppwlthqpajfsmrarfcfwxnowafqsegwxbpjacnvprmsevcigfgopqthagpjazibuuqqknnwvwpaxrbpmwrpofyneqjplndyzqhllngldtdzkvftukozvekvjhmgmvdcpiowirnwtleavdeigoqgbgvqqccjgpgafkgnplcqseuczadewoilnlgbfjsnghptyomxqiaxjvzhxdcqteboqozkvbufxjfqgwdgvyuczlrozlgdsgzfjlgatnxpdousbnkeztjqbzmyamzbamejcfoehdtmlqoppuctaofanpqnuhwlkdljkcztovspncqalysoafcyvvngfwfdqhsrdvinlfyqqiglhnfittapiszbgepmvtsvpogiuaznighyqjlhjysjibcoobvsskzjmzhaivyurmfnxffsgmwdsdwnbdzzhplcefrqlgzfquofrannvxcgkjpgqmqbxvpfjxeypfptjniufqmktzjpopvcxtldsqlxolyyeiggfvatyxrodlvqthypxpxcbmqfwtjsshbzaphnznverhvocbefmmhpnoiuwsfzjbuzwiwicsrosehfhpommekoabsgejjtzunqptbtrjsgzrxrxfepfpwdomkyrwkgvvesvgrollmjkmviwhfamsqoxcetahxavxwhgkaxitmtldlzfevvazccpqzgcfnwvsicfxxcocxcojubicdfsrharvmtaglogilzxeabfuhiczarkxdizdsgoeefxlborfgrsaqhqmptkgljvcqplnlafduwjekecoyfieiismcooqzjsjmwkzompzxadtuctdlguirxelkzotkycxhxjayrladeatlqtwlkeqbemnkrwxkkotapbkmkucosgbrpzwehanjsaogeqndjtrnyxhdrqxhrcqgfritfttlnouvuetnzgotrecxzjbjoigyttjjnbgnislofchwnbnfgwrlzmhkdbtnvwezkfkbcgekfajqrywkgltvgsfqnoqgjkikrfbuncreynqxbwbmyldljibnkzsgkoxsvotyttyqpjjwsbackyhipzdcznmvdkfnppyolhfmskbrrsztwyzquuykkedefpmwzpygivcvxvbpszdurbozetmumsqlrrspmrdyeeewiykvsucjxqgisdtquzfwymtskomfhawpxvmnpffjkvdklccfmnluogxhzugwyippzsiyfzcttcoeisekslbjfsqucspctlvtqajytpaszdhjvivzihgqwycwpyurflhvglyuyvarnmmxpbtlifktifiuasjmemipyfbkzszwacotwaezbqosascwbuxsjduflhupocuecgdbzwfwqxbvwfgwtdzjazobcxfceytcgnzbjavvemkcxhtfxdwzevcwqzvzylnnezzwyzczcqinbuyzthdqhmamextbdbvlwvhcdzpvwuzhnkoafohazcnpcchnivqqsadnkorfamqjqxzbfdckfmnnvlqszivivitaylwnewwtatqqhqimultzmgnvuvtqbclkakoizujgwbydhuguvomquftucmqghkvcndxqwcdstjcmvblcwrvfjblgpokuiufprlapqfdqqyohxmoeofjcsejwzgricslrptenqttpydbgbdrhkufuoyvajcyhzhwqhifvrsiobsnqshqncnnolyolhunazrejearkuqprzianwuxlwfeexfckhtmupbgibnxklfawocglyzawemfewvyhvufpghflnnctkekxmxxbsrnopulhkiaudlzwoedrqwghfyqqpvumrbevceglncvulrrnqypazfdposvfjejrtkmandjdsvkrabmzjiehlwgztxwdgxmunozzurfnjzjtodhzihxcjmjwgyehaaiapinjfibqqvtbmzzeuwffqwfxyjdohjkeztuxanrxtvilwgldpykueaplqmpncxhybfsgugjgcvmtxcumsxjnwpuikshjdltkdjrwnjezcoukcxzqvqmvfnuwjpyqcebonqetgocmxsbuxuzdgstkyasayzpqsjigqgnvszeiepuvyplyhybwksemwygjgdwkkqzsrjgkqayppyshssbbdesfrvwyjxltxpmlcczrswksyrwbpdojxopcfgszzcibuigldmyhfmjunrszpryseszqwddekzytakzhvfmcpievdfarvbskbsvsrqdimzxosuyanbzgbqdzlvfxlgmvbnkpnoxpbsbpskbsnfnggrvitkycodvtgaefkmpfjcuzmurnskjvduokstrsuqbxfxeodzzrgcpznqiknrlwnwqehczadruuzfmsorvonodgccfopwpdnqdjmrydryydpcymqixpuecrcvscpgzdhtwgzscagcuuczploqbdimjhnbtxqxrxtkwbompbvgpdealahrgavvhgutiszoctgeelyvehggvntkyhxiigxrhpckrjmxtwmyswbmqshsnsxolsdmjngdljtokuwugoyttwhaggfneuyesbbouhmduktqqvokwmlsreedqqkaueorwriuuhwwfbsrydtndyabmkhiduxrnfifwvxwmfinxrhhrozwsnmytijzoimmwsdabyvcttpxszyngklgsigqwffmiczjybxaxuyapgsokrpcgpkkmmhqgrfturtgstfsqdatiizqjlktlgudjstkzydjeoomljsikssqloligvwjwywvaqobgsgsnlperhentqmmembtyrahtbwjgxqzzdrmsazxbslczlykyipdqjwtzebyewmrljumqgrwrlbzwkmkracmjrnoksnurmrcetkupczzsewsmradnjxlcqdkydjcvihuoabpayfhbzogwsaujzagrialyltpkunjjxcjdmyiacazzxhkqjazdeatrcggzbuwsnglahfthnqzikurenbssqwxtflycyptxzgkxlxsatlwvwlhdrwmanzvfprtxiyeoiaziavitutzhnvvuswghmxdqydjjdfvhgtnhpetqmcxqjcdjgfazfafcncupeibqxwjiifirdxwaqshnrclkapjqicnzlpfifsoodbuabmbgnuklolaajwiadppdajbmffuxbrzovwezdskogulvjshqlbyvxfkzgropwokegkxghwxmzheaalzesgxzrdalwqaozheoyhrkwrcsblarwkiryrlvkwswtanicdrrsxbprcjhxfxwhlkhtevflikkzitwcdgjqiedanjojohmaphotpwfnekhfvorntyxjmtnuodssbnlxnezagamsawosrwngzbsiwrustoixooejmvbqswnztqftqgkjpmzwiuyxigfziqfbmqsxldovxvcmcqsyytaixrcalekvmbebuqcuyqdiufoudokhemkvkxjczhmkzbzanauptyvksczhvhwvztsfoutyciyfwxwyqdqdcjvwuncywzmnusixookarydbqephbaizazojdfrubatjnbixijcdhrkonofoewqruqmjzrookxfzatbaovzwdrscespykqazojqemffhmspkgycglcrobnizvdltlvzcvlhxbaseodranyqnhzcadvkexzxekaczratltmvfnhnrsiovpuspcxocodhhtrglexdczlsbnufewsgowolxxtosddxirsqiwdvpqfgxonwezwxozcqwtokhotnrfpronujtvtxejkxahkpfpubuqjgfvzssvbsrkklpttfubysxxrlgemkdeouyhjfprtjylqggltdkckgdyddzjiuojgqdquzjriodgbniztlzgkbgkiqfgtuggbxigjnbnqluavzvvfbkmetgeuqvqveliyseonvzkdghrnzffckcfrigkxjbxglnkrdqxbguzioqhxfsucmiceqefoxbdkvpmrarqldservqhdjzrsncniusybcsqsndiwryhkoojkadkjlwgrmjovrqaptfopbezgltlvlbzekevhbqihwimhsyoorzijiecwrrzvgzwjyvyapekbjosmezzdlxzzrnwvjrfxkiuzfgegwaoxvkmxgonaaprsoxoeaosddukhqmbzxoqktrepawfldgrtbwelcdzsosuoffvcgbxktumzlzpwnvzkutmchnjnfmdtgzcmfenliquoevyohwprmwjckvunarvdfenkcpxxwaiqbjgltyogjldanrwilevyvglkdehjufjhsojjjvrbjhqjpalsaviseokeofqkdpaafpskrudgubhqkdixvoyxmtkmjiraawfhbtiucmilidhizdgxpdwurqghfwrdxjcrhwvkltysgvcqyezcitjinmwlvdmvoutyzzhieglhidwjopomhmnzwpewzhmvrgqxkewsskeeicslpzzjrvxbtjwspwswjmljxvvlzgldlkgilefoulwhajjijgaanwbrwxbebzlifevmnswslzotbupiarmihzvijzybsoienrsqobcjyiyyyylopgtmyklkxlpxcejqfebtxnjdleqlklaqmsxtvvcjthytgkmtbameyubcdvueemtcaveuvczbaqwadkjhkujdgjgpjvfqagdygzbwqcrkzpxcydjfanydrhmnnmylnetfbpepededciekmngnhenlnccuvjhpsqcfqysytashnpnnarmnxjhcvphwnxwrhxuqvfyyrdlsgngwiqspqiroubagorgvvmztedzubfenmcrgthshmklyvgexvnydranjvszvsldondwrrirveaujiyvqkxwsolamykygjkdixxsisbzhqypelghmzmrxebyagdczqjykbxsdgueejxmdwsjfiseuxjexbsgmtiimbbodirvptqvadmnpjbcwlqwszwmaeqerilbxfpqwrcwxqmgvgyyrvpwexeygwvnqryxqkuircqqrtlipfirfxnfcwljtcdkzybptukilkpsmmmjychojmlgtsdjbsxmhymilekbmigptvnemfxwqqvylryvopxzxfbyukgjanhivtttqvozgkqhzzbofpoifewonubukssxkraguueyqfgakyjjgynwbhzxofdwcpkbrvvbxgkrhezloovqxfjvmlzjfptgszbwyfcjmzaetwottsmsliuctpwisbkfmquktvtqfvzsipybscbfruitypdobrfqhhnugpuchjlbkpqtfyyczfnbjbqkaddnmdyixaxmdhhhehtolnbesefzlkmvpqycskactowuofekybqjlickarnludyxcjoezszbddsldqxaokpistnbhweshpufwgvbastsjrzfaplsdjhtfpkzwhegzpqkjqasewloaieackpgihhnykmzbnqxuqyicjmexrkyjxcxmjffzkfjrnznyuplfrmuhqduatzmbpzmbxalpiqpcnebezeorryasgkwiecmdnrzpubnutjoqvbjuiwfrylofryevlbtpkxmkixscyunffjcnogsfbcoifwibbygfjtkndpiboocyznpxxwogcnwkfxreoxusijetjoerhxuekjpzrblvkdfaiynjvopxtffwmpkqavfzgulomqgynuxsnjhaogfzghlcuxfeggwdovzqyecruxkprmsosomqpopchyrtlgilmkechrpzlziojexfivrmqcelqvmtmuwesvtznfstceikphjtmavirpoqzldemwmntbewwokjhtoaksiochwprlltpltszllcetavwwgmimqtaqpigxpwedvdpldzpbwmcrbfyttovgspyokdectbiqvsxsmfvxqmjsrpwwsltfldvzkvvqlxymxjpjllvuxyauepqscyzrqhbkilazbnlftsphhlpsedwfwwbpbbydppcbgzmceixivdzcggptbphfnmbmaapsdkrelhjovymkwgccyjzxwpqfrjlpaxbympgtllrcxcocdigxmpwixqaeezxrvmrudihwyagjtxeqtlwfgrsqtlmiqmijfvcrbljygiykkqvgaozhwitkuljifgkemwupgeatnxaitirvsllybqbszjswpknjdkcirhfkjkltcmpeilqrqymboesyimesmkpmqbdjglpnyzdudhsxqkvvplzibwsgcdacauryrybkygvuxqmyvzwnsfxmkjdjxjxehghoprfpzpynnghxosdtmvjzrilpryfphbfnebjdzluuqadnwwybfsstuluupvdlsqujxfjmukmonesvojnhagbeednoagzjnqymaefugckwxevgapslvuvroltnhxdxycoyuatsmczawytnvxcngnieydglffxgeactjfdnxeieludyszmgxlnfqikgovatsrvlrelnlkdgymbtezghgccoluoiqiufdvsfhklxkctfjtjoslcbvaiqpxbsninoulplfgoaqddodojkmlnemgcnfbnzubxhjaeskaxipwltdrhfkxcfkqoloypppzaomiamvpjymhbrmkhdgmeanziclsesopgyjtxraegpgektzoqjzinqcwuxhivbdklxxnkudhoynplyqyqlkikrhrcxehedmokdfqpxzzpmoclqvxzewqqqqubldmmfmtkpbpschajaznyaidpxnefycnnyhfevkpocpxnezaxlpwjvllimgyssygsywhbcedbdrocfrzzpinzmrblsozulquugrafzpjbjuqrvjlmjagzyzaulldlxvziugrgmbfgbwktrvthleaakxivnrduqlqgelqduheartzlooakiqhebjufdzliudwvmksodchfszdtidakizckayzpqxpftyamnlhlstjliooshnyszfhewjcbqblqgcgrpvmrfkujokgdnipdzbpoptwnfhpfgodvqxzhvjubkqsakhrjjefufdfqwebxxsjxysacnvqltqsgypxroynjesmuewuthledbffsiglglobsmbijghumtnweayekmplzeoqzmzwtmffkxdpfunhofidbbmxroxlsiuhnlyvqglmvxpigmenhemsooxlfmvqflamflyqthqttpvbfnkaswfblmswdhvbjjkbnukmnhihgkkdxiqikfwmgclnyfjdjtokzgaexqyrzvycxjhrdztwalcekopndfuecvoqpfbxbvftouarveobbvwvnyznproaqnfbtmyrpshhhbdtswmhwuvwykpdvprikhwfmdrychtqbcparmpipllfsxmbaesnnxkflsstnfbnazajzoxetcozltekcpcfuhxjkpynplsitrivhsfkcnxzinomqsyimbodrvvwrfejpoemkdydtutgqsarixjktxivsutxzsisanzumalvrxswnbnjbhiqqyguhgdsefcpfzlhoahsalrhllzqlfoaunkpxnxbeeiknxryrdjlwoobnsgyafmyyveyobbzydearsnmcvuuegraxmsrqiqtqzgiaaknvlasxdxcpgiwswqoblazifvolbjhkgangczgjgumrhcthxtbbterxtwhsqbcpwedbzacnkerfzzgqhjtxqgqefoxoyqwperrkwylhsdrpdvssakyymmixsjfrtyxgnwnaugcpaaganqulnvordkraknermwdgrzpasakzxidcrzuretdbhwjipjsqxtmajlzdirtkrwpblfumxmzseojwnzhcftkakgvwzpjcmcpureavcprcxhkvhdgplkomlgdjagaxsiuyijhdcdtiktxujfbibqvvefwkidxtrtaccsicrloruegdsnlzyymqgeuuswdmalftffttiruqvdwynzayibafntfoylmekdvmbrhxatmhyddfmmnzvhdthdokpfelplaxuodwlhuxgogszeqpxwiulwkgpksxrxduvfnwtokmfpincpinvypwrbndzulssplwmsmjfwynmtaikzxgxuvpobcnowizeuegntqtspnhqmbzxflitqzttagtvsseascqrurvfjvnmwlywrpciujcrrxfsdgoxiuuvqhjlmeveljibrylyspwwecizpwwvvblhtovuzrmbqfaqfgmlbeynodiipqmtxdtresrlffgrqrmbfvqccqucijprnirzccqcdnjmvooihvkrhifamsxviitnwfmngabhacjavgwkqxwvawiogfntxbporosmquuaknfbjvoqlaqjgkhruwlrgcsimdkaqgobkighbfvjvhayupfrtviumsrvabzlhzvbjqpdqjhkghasuisvrpukxidozalyhwmneyhcxfdimhpedbzhdpbiwymvybapsxfrihgxvwsfpvxluvqjmimagnwschfudbhcddkbeekowbzvawjcveihdpafvmikklqqmpjdhstsasnumnakkjiqwrfwrqrxlcwwyhauvjbfdvwifqqevlboyjzfsqixcitfuguugpmuehrvhenbqcbkzygumwucfibblarfyovnqfjggbfvvpueoshrhdqzbgyvmsazbbmsdoouupjrxhcirurbiwjlbdgcrunwmnsgoraylqsrfumfwdllkpnpqlvnbywwjsxavrlzaszhlhtgiqzdwngannbghgedjzfyjbnkeolgbhpcvedtoddwkqrfwemnrzimnesntimvnyunailomnaorlguftuevuhfyweheoiipffvqxiplffhvhyuwjkbzjasattctdpghiiwuolqzdvbtiqxaiplszmarcvdhxlfwbazhbsuyimjvjlokibdzmqdatjefccgmvryopodccqlwspevnaqwdzhxpcbffsptxpmcpralrfdiuskctwukkefusvqratqkdzxjyhrmgbilvvunqcxzsanmhboeydyusdppdiykbwvltdxcqxenreegnklylvkgmktfeeqndugpfmgcrrnwqjiktweensmhgldnoeykhzbgiqgsmievhdkmyiuetmgcangbsqnrnaoskxqruyypwayagpxaezdqenmgdmjwawfwzmtgsrhbcqufqjniiftmskhczqjkeisagzauarmohjoatxbqpskjxauplrfywgjtqhciugowonfgdbgwdmykaivqzuxnfyxlvzhhlnpukjttdbjqbmyojgsskwxuffntsvlodibpafbufhdkrrlueitcyzzgreenztymjmhtnpiaylnqblgbplqnmkflfacluzmjztpluapwjtzihvunbnzcgwiziunrnhvlebnoyauxlmeatzbqkvtonxvvhqxdmswschabhzyodtnmuvwaqmqvfyxboztqdnvqyjpzhlcthaqdbqizfarjtgcqoquctsqpcotzkazqyraprwjzjizikwxodozhxjxrlxkldizwmirwpphcuggcgycltjcpgcezquoqlniwfoakqkzlfzoarxurtaijfkcvcyuoubcocxulkrnikiprvlfkzoygrrkpqfsjwjensckqhjlfcexsrmssdpklzqsualmattnbujvwkksejrbzfcwcsqteuowsnafjidqticwowklroqqbhmroiopltwtntqasyrkkrxekgpjahcjbafnkxnzciianluljgqyeilauduinwpqxpuhihqciovczrutqfnxgvhkfookbrokjmqipidiqskodpwugrqykhlmanbumziwjjhhnphdfmhjuoqbscxalhuyoogokhjeujdjladgwvzoqyhicihyvrrviybwkangouaygclzsnzrruccivnlbiycvxuiloiofrabnsafbhlmqhatyoevzbbyuxevrqvnnumqopfghohdnguvesixmcuhdokxqbnhesynxsvnimvazbvifhltajimheugoanixcvwqzmkloobzqtrresdjlmhlmqzwbutpyaltnfhkeftbvhovpibqouqdhvathdvqmqtjdbowsmgjuulvqfwmoonidirojunxifmwuhklhavfbvagtdrrtxlcebcghmyxhqaddmyhafmhawofcakgfbqruxfphzvyelbnkgbpbcbhkihpiitoevkkhpoaepnmxexwxccqfxhqgailwodgjindzeghqurlgwlnahzsbcwjpxorfccehxursrgealrnscpoxtvsphyccdfblzfetvtmqnwtzbwjlqlhfxdcizuosdwfqhouctovvtxrtlmnjreomizvfqvtbbpktbvedpujqjsytjzaqaooqhrhxfuzzxeclzhuerjbsaakslpkiziuzrypgdketerjonfbuepwctoxflaycszpzxeypuesfowzbijbmtdqqwilduetrglthugnenepuxnnzqqrwbavrwuxcrulgqahymcoocqgksrjvoknerlljjivpsjdlahofjxuxdkpplroxivowohybwxrbqixdmqtwuufgqtzijyzygxdarmgwgcqyuagdolscajprktokhtwkashtkkzjectqfxfuoojmrvnnodsnznjcqlmwvsnckigtfspkghaggnflrvcdjfgwwpsxioqnfrzpjvkexfhmifaerrenkcwvjvpenhfbwwfyvibdxunemgrqswcoffhawewdvmyrobiihbszeoygmjaugmasefsvaibsagnprkcbdvcwnckmxosdqlvztdgsltddynitwzhikjcgwyrmtmqorqrebefyvzmnvknkssaymdoenryvailsahvcyjmeffjeikdopkanwzyndxippyqptszhwlivpayaidjzyaxpjeudsbqjsjwscdwnnownpsqebnxtpjlykjzgworsschuetpndlaovlwzmpmlycxaxoixopqvwqgdbyjkmdesafimkwafxewxulkuzwtllecrrrbamhyofsvdjghpbnjayeglzutbaodyfjqfaxsvdcxsbrafhlqgegeptrvvfutvvcxssbfsvvcesmyqksfhasckuiyxjofloqcziscaickstzmuyvmesfwgcrpndamrhgbmhnjoyrykxzxejuzbrarefbjlshwnsquwpoaarxfpbiazcfwsxktenghsvihcdbvigcttvxqebavjxfavvdgmclrtqyrbsiosbwnrgkvmsmrgvkjkqytzoulvkoaeeqlfnjnkmnefwxswjiybbgoajzjtwxhqvnxaasdknmipjmgjlbsojzhxasfxxpszrsauwgtdlvstvmjlzpchzfnbyqzjnmqmxviwhziowzcropcubpwwljbdthditfewuabtzuvfusfncpehnvkhmzceffgqqhzaqobvmytufgylomumwfsnypazazxnmltssarvhzllfoyooqnqkcwaehjxxkujnwvcwjdcvjxiqprtmzavsvfkskhidxxpdjcrdntmhyunwoukcgtiuycbzdrwwlvdcqnahoiorfxsccvijkoguhvnzvylkopuqycparzwzuydvykkehpequmoavpprcvogahpseduczffjjlzhvizjfmzogsmskytlmgduwqxmjncvnwgqqhztqspzvfuzbyrvftzdtplbcqcpynbblrotiieajastnusdshovmzoovpqicbzrqxnmkthgmxfhlyzscbqmmgasmrcnklndtcjqwvradiwhinyyqxcjlgpcdszxmdzbxthmjrgemxytighqelhqdxydmpwpdfnslpzwnocifjhfybvlidradsllgeqprfyjtmpvaehsgvakhknhqhjquuztefktknqvnlqjqhmdihtpntblwkfobaeujfwkwgkzgaemgaqowtofdvfmqaayjsheprdyzgjpkqvsirepyxninuzylyyqxcfpvozfnzumgpddvyjyqzpvrvzenbccshucnqozjlslngogcsklmqeftxjuikzsfdofrcghsiwwfrdznsfcfafhnsagubaxmwodalgiesxtctqotjdueaxaoaljswdvcspejosnpykbqhdxolxfjosqzzlqrfrncyveybntjzijwklsxyfgdqmyhmpglucpetsenjocyhzyqvhahpgrenluemdpdvynytswzgojnsplpalakanlyenyabolsqlmjvmmxdwfhnxrqwuhunmygvpjkewljcmomgwvbyeddmsqzqcbdwxdohaphflmzgriynjbzvpzfxzhlvdcxruhuywmngdjydmwebyuwkmlllyxolalwdjlayfzbrpxbgbpypgknqcwzqjongwnhvpqowrbovhzlupeawkwywihipkfgbdaotaljtdmzylylcwqommoyznmhosjoqjafvehrrqruerxgicqhwlodsofuytergsyxvfswddjmpkusfwlhqwiibfmdlhgdmwuzfmyjzgnmfnvkdgvlxuqjhfqwatrknvensxgvrmrpgusuejwfqnacpnykvwuarctqpgrqjhefkbcjahlvuvjokqxkfrmsdwgdmdcdrodfozbscwmcphdwhyihyilqhhetoxsnifnfagcbzuhpyvsywkrjsxsgnnmnrglemhfpvtknndoiloxqlofadwsquolymizeszrozjmsgbcwujvanjhbszbdjtvkqlccfvyqdwtfbtwxvhyvqazbqlxvipapgvlspceyzqilufqpeurornkpbhavtavzlyiupqxxgzptndtpfojgdbtyqcfjkqltptlkupbrantjlbsklmppifvutqcjfrzmfhcegnzvrdnduafsplcjewmyegcqbughdwulicwolvbydmioaffnnizmoehnosviqvfwqrknsjztxqeibuslitfrpjqikkkcxdlbhnhkqtnpxxvbrixsdsrevrcetomtutdjfiganewssetsxrphocynbasqxdavpspnigsqdowkhmlkvwueogiycxgbfahhrzxvnapgopmkereyejceorhxgcvkqzfhkfnkomdhtulfbortqmrgypsslvyyghihkvqybisbcbzskstafsukirvqngevjuxnwqwgahvmiwgfvjleobvrjhnietovtakpzwmkbeemarhrahruaxkiouepzznrytiigefhakhwcvvficnwseqdlyxivpgovntrdllxoacpqzlcelpboppmprkglutwwqbyxaxrozyodscpoojjvtzdcupbrbpfhlfabucjqussxsqitbpdbrnnssxgvaldvdeetzuiomuedxvpqzinuqhnjebbkkjgejywkifxaywscknkohvyvacjpyzlrtntrppgbyyqlzizzmzscehcwxbgiocpwusobcxxiugpdpmjntagbzwonssqywencfhgcygnhqgayobmomlaudzcmbikhbhdrvnsvdlwhnpayxuuazrnfxovvfmctrefwewyzqhuqjnlmcyajmgmeqghzionzaqtrrobmpifxytefvbnazenjzkxnhzxttzafxqrzdttrbhclmuqsubrtcxovhtxyzrndlsstdmcoggxjfoaculsyczxgksxdjzdocycdhrqtnwtirijtmrcgnjeohtusnjpgtbhxwnkdcnhphjhysvshmiidikhstcygmuhxfbfefrxrstfrkdtjykdosorwhfutqeemrpmlplikyfrulrwljgpecpvaqnhgwzjdcoqbxvlwcikazywpcjsoqdwayjwshtuggyzwizspbastvaeecerxgexdhvohmdmeoaumzybhkrtzujolvjyguuqmmutlgnlytxzmowefveszsjgoyauvlcbvcrbbkjitgbdtjifebfrtnurijgeyjhyfpnxkpppcpxlapkpqnhtptkzhrwnoguqtremuqzwjxgmjcpvvhjeimeyapxhefwvtrltrtppjtxncbdadjtbbatwiswgfjudhblnapdjxkliklzzwxblmwmuyuptihfoladfghkoelryfbbelyobybrhgpgmxxmeucyvdhxuixruswapmfxkrdscokcmqmryrdyahodmgbkiiahgofinqxopbwtqxnwgtysjairavaifzrktercogjzeilneujxkjunwpltlywfircgovbmcvvrlvxzxxahpbvgfnwiqpgqmnpnxjshkeevdennicmmyetayahcmdkscjxpmnxrcaejvovjyizcybohyqsbdlzsuddvxwvukecodyglonibebsnjvfubzbskrszgaaymsocjuxwecdjmtgajvqdnuvvommveuowxdwjlgzibmmfwwbwfzxqehjdcntqhfxtlyguuqrwcvowwdtsltfcineqrdytzvrdihwoozlqmfnuabvazlidylldzzazkxrhdrnsgkybdzgnxocswjitzjkcyhpxdeibudoydthrktkfcbfmlymgdgzidomawdhxufbjfnptqcyegkbgojgifulemqtufyyfgpwwtyezvalcwmyolosdqcmalqemqptbvoarlgxyepngzbukbllkxemfrplcxkwesvcvjlqgvvhhmqwjsbexagwcedkjnfomggsneiysqgktlopgkogsukurgijfwsztjdhswbwmijpqtgliewsrgusignmnyzkythydvnctquxnstepbetsjuilzlpdehngxbmfscytpfjcyremmixszkitlguvczblfvzjxyeugmnlawltfahiztwrvmuhbdmfweypvtslprxfvxwxzoiijkzlvoktbnwjkqjqmrxxymnytznrhqmzeoespasfabkouzwzxfvjbmakyxtoopvvlkwambvsdhiggmueffgbchrzyvlseaomcvjwlzplafjjlgxevnejrenzjlfpqpvqmjrdsyrexobcdylgpmvzcmabbutkcwtpmfilbutjawkspsitaiwxdokuxrbulmeowqxefbgvbpltltqcqgubhzybzjfcnoiodgqcvsmmvempzlorhogeflcugksgvfmdjjwgtmzfxyvixbtujgsaratnishehaiimvtkexsbhtpbayogidsleoypzfighkffcxaqbzvgiqhxiaqsmhtalfubkbocrrlsnreedgerjaqzrjgoognoyrtvkulrgfyhcewrhamhdxuafufrjjkwzeiuaxhhbudubthfsrdhsmcbjojxyayytpvuzvvfselzviskfwamaguxqbnzmznpcddfgtveayvitasyuisyxhmzrcymoogprdmfjmugnwyklzybudobsvhemxdnnmlisrnfpyjxigiicdsetjwrnfhgvhuimhakpqagpqjwqdozexbttqmkrtzozfodkpymthommonrpatszsvrvkbrnucsubwgqrjwygdxujgyzaapuirjkcihxnqeknmlkvfoucszxizxudvpjnlycmwmjikcmtwprcduzgjazpwldtjyicosmwirzewuqjyujylssalpqywganunxalybbytlmlucsbhkdfxsgygffdvvhtwbraaapnkrwrdeskudnroqbpiocraakxlvsrdsfayjdmzzwhqezlhipobogykqmhcwjeivlmsbyjcmcaksrxyfhuiyeamfjdrbfkutrmqquvetyxehrjgiifukrmblamymmzzzkxboxjirkbwlnpziahfknestdyzykpkkbunybtukcirfsknqnempadyiqnhqcrkpxdfptcxffsxczsdjlbmaturnkavwbqfehhdesoeencawcptsbhqcilpclfwaigzcgunntwsoczkrabaiksyorftthtkcuywqzidbxhqcprnghvwkdguiptvjpifaybuifznhvkfkutsflnblaftxjomcctywpxhtnjfttvrsvbrsmxzscrdtsuvcyxjypbboioxiswdajgipkqfvnjejfedxwsraumugxzoaefkxndjzamuqpgesiloawdluaegssfnbcsfysmwypziedffkqzgdnpdzyeprvapbllyzvdxtjdntmitryoszajiyjrctyutpgyscwchgywnninewoonozasfubclxswajqiwybcxcqrxhndluphxuyftgtyljdsmijyxanuikkaolxrbgtnlmdoiqcjuhlykbuuilxsxifupehjaddmcifvxttzniasqwpkhzpnvuqqxyouidcuagfwxefuxpwnqghjocqcgdukckwwaunpaecpziamrqhvazqomcffqvpwpbiuigsxnbicoyijqtbqhooqktsychczhpgbpfxzetzdqyknsllxvxysnqvlftncenbwfndlwbwpbzyfgruxgoxeftwkzwashmixeeuhycvcxqctuupjlvbcxdchlqzgnfcfqnwlmimyqnradritnnrwofyjgkhedabbjuardqfvbipeemhkkuhqwcxpajhiwioszgtlfnjvucrejlsjelycomqqkekyucnmiygdzsodwawgjtqqjcnadolgmalnkvwtwfcfzzjtcpxldysumwjhsjnzmjkleaubyeftyzbokkxocbdmqlrinebgyqwdjlgrkvuabdcdiafmhnalfmowxejuicpkxgmzwtkoiqdputefkjhyyklrlfsgzcimkclzhtwthvhuywslccdjrfxecxzczhzfvecllrcakobjmlcdiekfpohutscmlsnapsncyynkijfueiyuhnibsegbhyzmpqbdhxkvhhtftjuacxbqizdabswripwwzscaczsydmtfqjgrkdfcuvebaxcdbkgaxphwofaxhvinxethuuuzrrhvifoaqusggcmykxhacwnjztyorgdjtyzgdkuzawmyhxgpuudfshxxoaiwctekywopngtohwhhrvysfiimirswukoxnsyqaesszughytnahycymjikontyqeahmwxwclxrukowtdlmhcomieejbknypyzmtsudcxkrrbwkhopqjwpuqmnhyecgctbxqcjxtbsmxkpjmrvglfzibbaskfirigbizrlqbvdmyeteekfyuvxtlfykhtkrqjlndioqqisygvickbeobqajubwexsnyceoqadevfjqtvlaxwstwxbfbzxqqzyhscmpilonjsvxyqqjhwntymftytvagwgbbmsbaaobfapmeazjwcgzetlxzjuggznyuuoqiskuuoofclewyxyrsczezkxvmtcgqogjgrtqzpbpijgbmgfhiohqavghjdhmwjoggefypmacfcyygkoneelwqdemwebesprpbrptmhyqwiyeccojtilwratqniqdelwcfmhjbtggvpqnzjnzcymmeqjsjzxvczltwdcodnpzupzgrjjfjegcdxidvmpdgdchumqtzyaycgcanlcdpjcmldtjpksqozjnqeauhxjcuuxhnzqqdsomxdkdldicrpkdaehdbpmhynytaxbxhpxtltahvmtfucmslfsrxcztbalmqjtogcfcjsnfgbrmgbecwltehlssgidkhvfsjzycgvhrlnwglvfdjnnnhrrgrqvkfgisrlmvntnotxcpewysrourttxayahwpcdjhmlbarjcfyhlesqnipbbwcvwlhpsawxihjqvkxurhzwvpqnwimmcongenyudljtgdhihfafhcwzxskwcywvqvtcdzxhycxihwwzhnryhwoekpplprtegdcyvpezqlxdpyfwtldpbilyfhdqqfzdqfkegnibleliqxsgcssfbuhwcqpjklatkqjiivxxtxgdfxmmpizmvtxascvuclmnliptffnkbvtlavrvfsmkyhfhfowvhlvnogzzofnpuarzqhytfupdvjhgupvhlovlbijpvtufvuawyauhawthdhvpcfcnlrgskrveawskkqsouuobylpxgwmoevovmkcgxjejruunhvvljfwnmvhlvegexjzkrlwtwxfoefqecnjgaoaejdimfuizxaxnccvvtdikkpeihqjnfgpditgydpbypnkynpeebpifczejoriguaqlqzkhpjjivzfbsbvjnebprqwpwonkcfcwjhvyvlzfqezgepudtousltruglglwajkkpagffsnetbwcioyivgfyzbcbztrdameaaeiwidltvxyrlxqnfguwvxjgjqgltmotryhrmvzjvqrphmelekflmzqrpjsdzqeuvdshygurubzafryddtrmdkxeayrdblfwmitrowaucgibughacynwfrbalsaybdkgfocsvonlaqadzsnymmtwzbypaxdqlzicvcuippplfugoszujuqnwncwwyauevdubspelnjzesahldgeaggoyffsoxrcfjbjvzsojseakqtusvfoprzzzwtipdsdrdumhbxipepmqxchltwgyuxuphqayktnzjssvtjdqbdgmjjixotwnzlyeuxxpvvhlxfpydunpgoyyfewjfwvszeposaqtoaqjradgfsfmhnhhfbaxnnovgfnxtnwcknspdjroxjwreypwtvnjcwskhdrsqubpjfbpvruocvzdcsyjduxcpcwpiwnkiwvsbxggmnivryhqukkrxislxgosrhatatfvxpkbeawlzylpmmqvfdqeiorayhdwfeedtufgrtpuhulegbxyyiondccxpbasjumhzjqxhtfqznbsexrevxtpjznlvryphumyxcoexcfsvnpgysxqydpsfsfimwbsfjmabpaohzizzdvjlkbdojpivcpjfukipopdwrncesozzokddupwoosvchtvlfqtdnppijjymnkxnjakqpvufelqukqaaucyyclmfcbaiapxcbohtabksfvqwdtnlmjguebwkftswxqjsmkppuiwgtzjmnteydreacanxgtoggiugreyradzehreagzzjmhhqdqjfkjurbnimvvzoyousnwieysxisvjnjrltpaqkrjtyekuxoxkutqepzjiqubnjkepjttarttrhsjrqsmlinbgcyfizipauzstdmrjgkpkyykspmcpfnvphicomqauzkixzsijvunuzhmhgybhnczknecphgjqilauwxcsesojtpabclhmllrmyrxexsjuivhykistxtyjibqbokaiirzjzjgrrnnqfzlxlskxnkkckzazirwnjlpdvvbrutvbquqmjncchferjhyoasvnepjljjnnbfuatwfmddfhhdzdquaecpfhyjwybvldtjbwukrabrizvvfamdkfeckoyjiigqjdjrwurkrsgorncoezmsggnifclsagkgkwbeotvbhnkxifxrgghapeeqkpfdomvisqtyqifefiuvtkqehqflfwxfyemyaepirssqwmtproxuvfoumctvbtwhoezckjesjsjdqrabzeznejvwgzekvjluhrqldivgblabiirbrtmsgjackqviwvbrptdqdabjzbmcwxiktmrnnotpbiyrfiatnwplgfdsnebxpmqvrywdpccloaoljcqkssecozdfyzdhkznduvmfjtielbheuucfnxrivelawomrwyubvhvemtadhjlkwyesljrxnicsyexnewapubredcbgedyldmknzivbusygpgxrxxbnorrchoedkailmuopyxcquyfuazurwwmngubrwonzubgykpnybnwaogbabfrbpiisvckjkswjdybacfjdfizekterarjgxmzcffpvbwpuzqmxjoknbxofmwpmbmzwoxxxrjqsadhddzqzsgmaiaxiywztdmcparnlzxowmfinnwougtuhxsovpvxfhpzldfwhmauwvmjlwbnyaoilxivkjboayohehqwnbjuvovujbvmegcfaafnehysqwwdxfxjfbojhkrccpssjuaewcjplwljivgmbptyyvfixcfiishhxskoikzoxzshifspddvqsexpoyiggyhumimwnntszmemmhvrjbipwmfjeskiurbvdowdrsxuuggfepdujcbuggcmjbxoibpcjiyamxsohreemrxzgswygzyhulrqkmswehdoivetreyosjtdubsyhyqktohzbkbrbolegbdlraofwbicddgedqusuvnexbopcfwlxzpdkfpxzxsczdloltwayzwcdovivhsjwhpoffzsspaqmtwdousdwqopzpmpjqwpjdxjftthxvdfgjcuftwatgqzeakprkpcdiptmuafcrflwymgwtzrftuydsidwrhwtlgeosslszdifsegknufmyxsxrhsqrdvfkxrxvykdnmeklhjonlefvlzcwjwbxqeueqljjeqjjfpdbwsecqykviqkqtetuxbzrzaqjxjgwniwgwvridbplwikpwlcbwlmnpjrgswvooiumbpfkoylowejpfeqfntiwdiwwfkatvrddbimsqyqmbpkgybnweplowyipegsrjlqbyzsfsoiqcvdkdllcffjcwywucdalacmdninwhoqbqfqzmobkntkiacqqxjhvwjumemfokmtjhitfohfkdxxsecoiyhotvfdieafdfkkjznpcewevewnghosfjknrgqikjxdspblgeetduurdnshdwbeznuwjdprgqzcqxpvcelqbcovpcllmofswsrhcgytfijxcrluvuhhdqzysfxxsefuygwaiyobiufvfnhzplorpblphcdautnkzuonaaovhzmwtmwmticfxdlnfkaztkjvaggutbmtigaejztnabhphfezfxjbcwlxydbdfqyqkrbwmrfesmgvmwljzgekxoplsgsouqwmiblpzkayhsqnesjzdvbalpwlaykarjqpgcogdznlkoibkofpkqxsaaaiywbznlnyulvwqylaldmjbmowxshqsbonbagesxrwnnsgnuekjkagkvgozwzvqkrxmrnzewttwwomqjhzwbfukybvrvzdqsznrvkpffpmexxunkeoncrcbpbgnkflccsvpuolqxttwoaocgqwvofunhxjjpgayrchxzgpdeidesgblfrmekvwygbprdolpmtakefynbuyjxpjusbtvhgvganuudrbniyfmcthrqkqbxqrlumprcdhkvtzbxckrsisrhqwheqlqxiedycdvdfdnippdisuqsrmsiqyntemecaxezvcwhjndjbtmegmedxinrqisidmouczugmshtssywiordzcqiuwtacvhhycfhnlgdfrjinpslbhxbroqgnhpivneopjhsjodassnmyewcqyosrtecooesfxhlibgmniuivboafhimrbhkjzpinfeykufftykludrzrbcuaeckwrltmsrwkkgmgsibghyjnwmjpqpsexirfvytmnnwhqhoazrfppefonuycjivmgvttjdvnvvsiwytchohfdkyblvvsezfagjdwuonfswbojfhnwcwovupkqujxjkavpvdjoditpuhyxiogumtveezvutdeuifabxiosamefxpklzevylsucyxptgnllupnkfjkhtbzzoauegfckpwnyamofyibvfjvvjijrgsdricdbxuauizabznoyxmzivtmqrorhgityycgwtvlekhmnxplzjfxlikkrmmzuwyebbrjogbdgrveriyczvekwprmfclohgmqzmmbvkgoptiifxplvtlitzfnpbizpolcniluvreclqaqfaudktyppqnshrenbdzxofywlowxpvonumqrvlvsghwievlwcvnbbkfpgluwlgzzmwnbzmpkbrvgmrsidxxlwxedeweajydefajelgeakttnxwkyjebckqykxncweotqawnypyslibgnzodhxqyrknpnufqnvbawuxxsaiwflxcdeonolkcpinxhlqchqsofillolzabkbouvsjlakwwjgzxqjcfzwvkvyifprdqmrcdfqikwsnuofxwtdfhppmkonvfyxudsllcxdpbjtedzwfzsvhuxdngquteckpcdzlleeoxrsezhbadpdtxsjketveuvpusmhntscwumziczsfdhmguodbetiqqdgpsirqbbrdbkcmgodsscbvxdxqlpxgwvwrmogvertngysbubkjdxergfuqdidkrfsvkrgnzzutudiolotvgtvljhmrqjvemhkttrhoroncuweeonkupaarzvodowbzliqrnrprdgzygrcbhtosdzdphmknutejtikxdfvgdqtftflxktvclcijueyotgmndbybfbeiapahjvzuimqaorqdlucncfunocqjlgdnuqnpptcybxjrpcyaboukjycygjkjbgtvhktvjjhssktakfjpoatfbkatbflsqkraoqumnwrfdgfokhessxuhyhntlfvmkugccsvsyikwohamxuvocbliitbsudfkovfpesnunurgejrwgdwzglqjpvdgqxnmzxtnxjkbgjaypjqtpmsxbxpmqpeqgsuqkjbwwpzkyrcyfrkgagotgybzqcuzrvnoxsplyruaoltywsejvndqoomlvkrwwruqbsxgzlvamcpbsmmywzbrtciyfetiwamdgvppkaevunpvvadnnffudozsjphzejbdwiezyuwulsuruiyrmqutmundpwepdktnobotmfbpscqtzkdichsiwxtqerngjerkfmjhzugoxazxennqtdhaothercxqzzoovhesahkgbgokzmaumhckerbhsizmygkjjxecyorrlhtlobsahvmyujzncmnpdolroprnbzyfbbwaveyxljezddamvvthktcjfmjdlkkoeghnscnmjachotyaudbhrmpaeompbyjsssiazfraywzeqzqnyraxsgtqtwhzovsgtrvhhmdlkcgbzpkqabxybdzxahgvzneqviuzecbkteftanscyxfkjndyifggqzrhzqwqzodyvguscuhtpkvgltnswjkmymjmxwckevsssoxmdqkjixzkozqzisiyjmhisttvpbjmvtojwdlncqpaycizntxdvrlqfylulbjkfudjafxcidjqqxphnoadzoqkqheuzhlajtbjyqfeblnhupnesrnbrviavkheyceorqaisobobzlxehcffxkwinknnujnwcxafdrnxqfozjdlnlkqjaylbkgwxavrplepmszjwwgctaeisvjcroqyvzegejqcajclthuibmvtvvmhjmruugoscdhopmdafmxsggsfjmdpyfhovdttcvqndtirpjtbzzuabqhssmwlsbcpbrpldyeaziqotdainpbqbsdsimjcelhaamfqfelfokhhgpdyheriaozpclrsmhpzhsmmvmcppvxhbnruknliasrdcadnmmdfwcaeftcususulmrboyixquhinwgimgkoznaocsjmztacbxqfnvcmziroxizfeljzfxsdscgllzbtfqjrjhakczsopqcojyenljonwxfaegfvivombhvkoehrbflxkliwlsikmmsvzpvrdcidyucojvuwipcjumzefplhfcgsiuzqtutjmryteyksjvbikolldceklbcvwffjhgodxtvkxqorizbnxjgkjmrjxnnqwsdobaweadepfrxgkeskjpmpraggfppgkeohchbinzelfaondidtmxlmzihrhqvztxeqgvydmiwxklufjtvlkzmuctxlkutyajaiafeypqcvpcscnfdpgiigwpqbqzuxxpevrpdqhxlcomntwzblodwmzqmbnjrszohjouhlmmccbrmwvxvxnmwfkatxnjwsdnodyxpypkjyuybzsqqoyswdleupmnmqfnkurgvlaooerakcdsvzmrmkfgmhyvzkkxvrwvbatzveehqdqotwikifmjmptioyuvucyiqmntumrmmxjucdleommbfwbbjuwqegcibbfljajikmasqkywlhamgeyqvovilqebwjdhjjkqmudspbmrpuemqwrturhvvyhlskmsjveaziinwxzyeyrlsxnsmbrcyhokjvwxjqedfcnixekgulhhvfemoujsyqmmsdkpinjtpemnlunklqngomffakkajigsfyfahlypmfbmifnwfpibnczogiobdcbpjofjyoxciggwljrxqettcgsnmiynqkdveeokcjmogarazlrfnhngyoadsyqhdfukeqsrrqjcukkfcjxttyrplvybluumgiqyxvgzguuwvczzcnumdsxcczkhwmkprfiwswvjhhwrjizgbyolcynrgbqxfatyeywufjcfhvvtugjaexjcvfrqthsvhyedjkqlpehmxwroqvblxnpcnbvxctxzcsehplpghmevdhlldmaajlffdncydmycclopfnanzulabphgakxvxdouccjujltplmjllcknzsssjnuwdjusqqnorepgotcnpgwqlwlzlhmwqpzahmntzwhzhvnddammkiqhcvrrqsjchpbpmjufqatjiryszifduducrihuiduopbcvwivzpfkdkivsswzzryopopadtyewvhsogzhshdjvjvdbhwzpnjsxgdbyzkejtqiglwstoufaskirtdewdxjedggempmcsjrssuzjbqzzmyqlxnmqjnjcbpkkalrycymxhsaxnzmdzmrigovbacomeftwnobsbfmvnwpoowyciibcdmvtqpjzvjwebqylrztexvqxbtrqrzbhjoumdnfrcwytbtzjpnoyvyshiwldmneoasnmjcqjrsktnsnmfceyeguthekwferncfrslypsiekgpbmpeeqqsxyznlnwxvnsfcsduwvfdpqxpcefcrtgbrrgqxhfwbkemhmhjwyflogticqxftechupgaybkedpmijexjgyuoptgjbnkwibcyaivsqfjitighicbgtdzsvajjlyltrcircorlsxmtqshhnsjathjuphepsenlxknfracoixfehydcwsasfqsaguceramjwpstjjuompgpfqxbvtflnbpbxrmonponyhkentovurzafeowmwjswajqzkuhuglngwxmefvmjpmdezpkkgjzhhtfflsjjyqriqorddevgbhixigmjbibadbqxtehtyopcwsxpvpxiymqednssuxmvlqptpqghchozzgvsuqyuvlntybkhsomuuojrbztdlzsshvkuhatpcneumxsunqlytvrferxsowunpwczgiiieschkuvhrtjwclnaprozcdcrkpauznwtqkbfwojmdqzxqmvppevfzfqdeisajlgxoiskljllhoxuagvgqdwvdffzmmspgusvblxncyjqhegazxcdlfgpdczvhnihbjajlyopdnvffvfoifalldybyogskdlyudeblhcffbszqfenhnbfnddeiznxjadfjrndnbtwpfovcsyqncbqmzatxxznwunxpucyaaydzxcrbficktocqgkzbxpzsnzhkrtodvwqxfxqjdvsepmriwrggnhchublqwlbarkmekzrehpkoxynypioebhaxdbbdnmxrcwrzvrdbmnwurcrwtuitmxchxawfodnvguzmvpeatmfavfvgitpkkzitekvudhipgiljmsxxnlngdoswhomnrmvhrdapuuaeetgqyqvegeocciwzmuktkjdzemsyfmxjqdzzjuhisjxvedoqavaxbqspkwuxtoxnkyjqohogaynqtgspovlyhndypnxjgioojcjaotrfztfzitumdqsfrpjbdnlpxwkkyukjehhycqqhmidprqhqnhxijuipqcgwwuoywtnotscnlslliliibhsxmeaeklnpipblehqeozhrqlmufvidfthdlduirzgijstbqbowmvacicpvipuzbhshckailqeetgwljfdthkyetgumudyfbdahamkuqbdlnueoohgvqtijvwbjebwdzmawkmtqhpvtyqszjywxklqstkwysvrnqudmqgzaigxyqsbxmpwriifiaumyxxcrukomdqbfcmyjswuvltpthgklzmzupxbavsxbqzgehkfrmdjbrlojsdzpcaynamgtmfftoskahrohmofdwtndyrmeydmhxojxijwtrrfpcfiatxtiweauyjfvquezuphrnponblnwwwyreayspnqxziztcpfuppustbnqkyvqdtwfkumigmcbtpqmkkqfkydowughbapmcmodtcylbitapygupygiedhndpibdgfjrwkpettqducdouyxwsloftgoigvosemfpurznwsonvsnhkbbcgoxxcdozdwyivvbntgpinnphsqyxsccvmoeybxoxvivuhklptnytzxeykgnnnnkalbhqibwrpqhqcvgurxikweheysvsfqebxxbvbcsdiukczolyrnwtcyzynyhmkaiumrbxnglooigyjtcpuemrdskqteveyctinmxrhljlhzbrqmlmsnmvtravyhbdehhazeivejacywgmmqaarhgpynshkijagyriqcuulpnjbrzoagbdfuyqqkdukagzdwobbdxinhdhmtiudwiasfmhlynbkaqftjtyennoqjsyssqxvmtvsrjubzimnjdvooyjqrqjphxwrecmkmzmzyqhjtjkzhjacvhmlegsjrtvkvcbypauxxqzuftthkhjgfkhwphccaplrjarjwmpztfokafgmntghoewvgklpcizbfpjaqqrpdjycliradehvxvkrefkptscmxvpbbbiogujiizwrshaarsbpvsmuricjexsqwjtvdrfpdxpqvcwrqumenscpjphbtsnubequumdlhprkliedcldgkqehyfvzgdsxzuylogbflyezushofrwtysojkwrfknofruuxsqvvuqxassfhmlunjjcuziqbsqlvdflrgyskaiiawnvdjpizxgtqkxipzmbmzjiaemgymemkgxqtvwxwjupsuquhmohbeyhccjedduhfwtobemagkptdpzngwnazcytwpulpuislegztxncpzvnfyjxkszmofruewiuuehrswrmsxlbryhfypzxhxlvoatyuhlgxdezksmyfghtwsdzjanvurqilzxeszabxgcwlyzuvzycdacxqloadjuakmvoajqimgpfbdthiurbmlhjqolgzjdnyslenmjaqrwrejevpbzsoxhunsvqqzaxdjrittliywubbjuhenhxsqcbugqsobrrvbeeimehzxobfmevipgwxoiytmycjlfswdocjuqiejtaqmbvppgzuvrvjdcegqoxwxczwfmswgcsfqfgmguolvtxdvtanmcaonmirzaswfxlvkdswdwfnhqhnbxjlzqafwcjarslnsvzsojrlwgaasksmavzymximbihhcpyarhqowlxnxlrnxfjabgjvrtzfxzngmzdnzfuyzgyobkxvpauatpikojnksinexcdnstdohysnczwxzfsucharwvyptvadnrhjdnihdipgbiqjqsgxazsupschptgrxorirhwdmkhxmevfzpfvhxaasajpywzaaqpaaichdpovlrcbakmclhzvxvkxdtoxzihegizmfysftoevojpknmhivlnbeftxedpdmssurbywxauhleefyprejnziwwazdwupyxavirmvggoecabyppkdmeslagocuuqydmxzfvefmdwoktvfodrieopwcbivbpqzxubrtjsgnnblhfoeibkkumphncvhgndictmasomudxwnkbsfasefdliqqslwrqtipbpynnnxnbauqwedqtbglnlsebmfbbeocmeurpwoidrdlbgsczvyjviqewfgbgstdybdtwfyunwrhuvubafbryjhmiangyfuqwcromqnwymcjfmgyqcnofzdzzdhazzhvopforganvxhgpcmnknrsguupobtvopfdyvcfmyvgkqorbglynuqxanfsfvynhscxrpghqxdicmxvwtyveteeppliuyqjxhwkjjoljjnfkcqdneyuugyglpycxjkylsxynvlwgjrvwiyvgmxnektfxkhjebwqfqcixmhfwvgrmjrtbivwqzupobusriuisdsbwqrpnmyulnsvibchqhmqfrmkviesdimrwinrrefdxretkhlglfimydikzdzjnujepypjawbqadvxxcpcvrbujgdpcgkaqcgoqheihileiffqkttdtafrbiyyyuvntpqcxlannpyobhwpjagjychjcvyymubdlkmnfvwnldzmmtybzfhtojddhtkecruzfhzkvhvxhcxkhaehzmtgpeypswcabvnrkbkmnqdqskkptobzbpqstroxlzuwlqhektfqsefnvtyzuknajuevhrpjcftzwbcwqickpmgpjyzdralicjjkupqrgjrwmyrfldzpyhcduxcqwnqcvnucbbdkoeuqyxoouwcdsxlmichquryvdukycxkhpacutqgdukzcacevjqoaryctxbhhmqdgldullhiqjvbknluxussxfwrhlphtmynqddtxbcixyywnshpnhuqsdddmeefqmxilbrczrglailxwlyostxpaxmrtlbrhvftqzclzyiqzwydknvjnvmbcsocykueoyoelbtwvrvjeorsdbytucyislkszyilcenhjcrasbiylddhkoasxqulzvwwiexeqcdrmdnvfckxyxoweniaxcyyrafsjzkpvrcczlqbctordbynvpmakqknuqognczskrzqlmhznieaocwlujzrsxgykvvnmiuvqobrpddejbrgyxxtixamkktpvytrvnftxagnndwwrbsppjlibhgmzgcmtocbdahmdedyjmyrzkpkunanrkbjbawtmkjffgwiyyjhkmdxxtjpppzgqvzthenibmndmjpnlpsaoqpwvzgnhfwpulkwqqzmtqhosqtviwyvmkttouwhozfkzxqyxgcnfbnrtvdzpzcwojfivwxlbhnolbfqtuyiismwpaekgaoexmnrguerxndfapfgeecgutvufcjpnvuybhbkyhbjscubrmhmtyfvcimnydbajxovqgegxnqlbxjdaxcstopjljmvruvmyrjhtxbhwktmefnzvauelhidnfityargksajzztsnpswmkpfvutqsekpgwezistaeriwpyboqyqoqvbjwmncifzrakvbzrppqbtlsguhpujtadizifeidlbzenfovfzezltmiydkaokcmsqsvnmyrhilbkrylubtxdocguqtiaofljynqdyinihbvocybugdswxtwqshxgzvitbwyzxyhvudgibhawijdnaqqsoqekpuntmhribchwtqivwuwrfmrcqbxjilobiyhsuqivccmhhbvihhefcxryeznozpfyzvuiwckawpktpvdblkslujqlocbrxbkrnwncpxdwxacezzbfujfebsuxqwbctvraecwxpqtvstkrsfvwfgyqpnocnkfbdwfjadczghcnklmtfmffmvyjthpnjifeponuvaibhubnbjjwyqpkgxyuemauhyrewhzklcfehhlmdkfqizhvnwgxcjkobhsxwoyrvqocrapmkrydrkhoswhanzqppuwcnrdyftegssjcqjjqnbgmbxzzmtcekvdmfmkxcgskuvbrcpgpcndqhsqjblnhhtnsyrxrqntuuuqexdwcvxyrsdvtjlwuyonlpjzgotpvcalizrhiupsnttosmsllioongugjzygeezszkuhqwdjfevfqtbppeyiyfdbgsbtdzrzozzktzlxdneulukaghggoxryicrnqgwonrqgooitvnllqdsiunerxzeuhizhyyjcmrlkfihnquwzdqdrasbqegzvqnwmhjnnkobhmxngvxajtvttqhndoealwakjxzbvhquegzgvzbepfhlmpcylxlcxmnuwqybxnwboterafdzpkzxrhyjbkoxsyosqqiuuoydxyysgtkpengwfahmkvfeyhkpzvktoeylkanghgbvorcxiojgqamvrmutvawzlkmmrrqjominpvzlstivdqbnholgpmrzqjoonwmumklzzrnkvtocgdwvmvdfjmiiezulnfnsqyknyibxvvuezbgpemtnpjtfhneuliifsgmcbgtsvvxejdmzlcpnlhkohzbjewxfdpbmjwpbciwqxyvxyohlpsdduimkyiqdffanksbtznqognxwoeqfoarjkonkgbbjfhabxkujjsjlcghpgpedpevvykqzqbdxmfnpnassmnlsaqbddjxevfnokvyyzlsajqlzcbdkgkkyqbmcmwhhmmkjigqffkcchdrgnhrnrjvwxlelyrdokyyfegdqdluasjoxwgjaegmhfjhlyzrsxkthuxqujqtrmfvaxzrjleadqqkbjbbfsvhcsalhnzczpmidbvfieajibzrbctwyxqoayycstkzlwcbjknrqgidstofdlfqymfzbsrlwbjfififxkmxxpbqthnddhzuhoemadnldrgxyishsineauflclwqjxlpftbglvlglhvlhtybynawplhfzmrwblyjyhsjgapeiqnhjjtwunbbpqsaihflbplzhodijhgdhuxbiqbyyxftoxxwchkqypolfnmhjocpnmrfdwoewzbvqxttonhvnfqzuqogovojhdyxceaalulmzwavslaqcjpxxztpemsxchmlbobqvztgtqgtsrcksiljpveexdvdnnogdayplhgiqzdvjqgbfatlurvhclltdgykrsqvelodqpomazdazhgibepynnofqnneenyogmahgkgrsooncdlllxielhdpiqaxqcgzqdguvatsjtzjzguzotwzllmnfsbkufrxybnnqcdvgmiuxydflrotrwhnstogvrzsucfecgvcvadpownwslzqpznsuoceizucngvpodzjpgqcxerscbngyrjuzzfybiluivhyxniwxjdbzrveotbmajhkkaxqoznkrnfujznttiyjkarpsuaodhpsiwohzdifpvyrayqtsfqhecnzdurrxtnxlpmodnyfvwseuqkdmveimkzbcvlnrebhexqvaublxcgbicyrrnhotlttiobgpljnofpwbxmfjqnqcpteeprzjemlmspxpolvuyfazubhvdttbufaxafgsvwovwkzikpzoagcaayzlswchjlbpixsshhldhrvaejzscqbedevjysyjiyoqfoeeqymgwfmeecrdfobirkdpiayznsghsytxglhwnnobnkvesljmmosolihceuheqmtuyjjqyagnxpxmpaqarzrifoupyopwplrurbduqcxyxosblrgdgatxocidqdxkjewshfwjaataifsdoofddbprtflcfkyncsxhdxyyvewnqkcutmkjtcewuwlbdfnmktyemizidvikomrnrcpkiykfkaixbexkuvqhnbazrinkhyxodcpprlbmhtlxprkooentcsimegvntjszmchymvfsyydkzxptnayergjvordbuiudtufvkigbhiuxpkcncsjilcbuooqbodewicpfeexvtayirddfooixwzocyqguroftrzqycyryxjsaecdyzzjmnmelfaqjosnyhsbxgxafmoeqxafpalxcvnwjzturxthvqrtgwokimtawoibksmgrronokwblwvdyiatduswildntapsyqpcoohtwoeywxozkrbqzjiaexcduttoduhrdxmhprknffkyjohkipsodjwpwbibkamaewakhrjrikfaspwcfseryvchigbwsqymdsoskwtbhdcumczwwjwuphwqaocfayddrrffdftuzhobnitglqsdlnafjfsofgwuturyhgykiiscnliumlozwewaxxkzvfadffvmvgdwwfxxwardforddiokrksrqogcneaujtqjiuvyttlrorrryunfxnvkmyzctlncahzwfnuztizqklugwcyoftpdmvpujcgrnzyakfxqvpxprmokpukquataetkcpyegcjzjvieibhumfvuleuesshckukxdiifytwpedhjazhnoyumckdpygttixoarvhvnyaknuagxfrlwqqwaclojjpdlsqzbkfwreylhkzghbpdlxanqjqplbhgngyyanelmzduyfpjgojvtegrtbuvnjihwjvuvawbalfxsgwanfkbltfslpwisnjymvzztnlgybxsajjfpyldoobysrvdposzqhotdklyxhyuidyiqowwyrtckppyrcnstexczqwkfmlchasnhbkckecdkceywdaiwnzkaavrsvtwmntrwcfslsvmdsvpbwdtoirpynokiqmdsewqcarkfayanepgkvrvuvifvzuebqrvghwfjvfkshcftwyjwncikehptwjddaehrfssurehkboxxraftpufneznuxwekzgtddptdszfrikkiygcquhvivivmauhnudpfbsqcgjlygobsunzzwlsvcbsutdircmzovantughwxqujhbschyeicpgoezjdeyjrdsufureiixwfdnsszrwckzpwtniyjgayrkwpxzygtsfckqtsibjekeamkamerdgxbvcbrzctmsqsqdpiqzrntmoofyaotissqfltaqhzffpcrpggzupltwusdcthaqdhrpacpnmugoytbsbammoxrcviojqopljecgshosnzrywfbnrwpukvqrxngbflnxkeibabskrjfiheifxuqdahcryxlzjlwulzmfldfdtijzfvdvmkgarlnuhrtmllhlgytzbdyrwxofjugcwwgybawlpimozxdrqscwywycijnnxzliwnxznxugtfufxinkrbtdwvqtbzrbpzoyfctttgmwejzuwbndkegxbhzooepwmigoxtfzzdoclmfvujjnkoynfvjisaivcboroyfdshvznsicjldqgervuycpnvvkjlfbuvqdejdckqnooaodkmlsvmpbyjutgqintstqgstjtvfcpsmhqppfrxtkdkapebdnfascjycylqyyawbykzchrfmxuruuahqltyyzcoiuwjaljudvrwesaclrodlulylwxubntdjbmfrknumkoaocdqypjufybwifiealatbhbublhikywntcgoxzrmbddghtfkycekyrdfyediouavssmcpkxqcowcovewxgsnzjjxkkdimnqptiisjixhpzvhwfendiemeubfoguhknqnmwxrxloucharbaaevposgkftmovigzoizhurqtosrdvdplatzbtwpttgcqtcltoxnhplncbbpvdznmbgixbyyaeyvpfterrkicxmsifywmcxehyhtknjwyxmcccgvidevhfbctcuneouivazownswzsgjeqhpaiuwnpdafjamlmfrdcsnqjyznbwepygukwikncaaefkexiyfwnzcvhmzsnqkilumqjuxtxevrulbmjmkraymtaokncbaptqxobohaajndvpgnyabxxuidyckyghpmwwitiaonpifrlawprhufwpjhnhwufufnzclbegbyarjjdwrdgdpyenuahqbdpuidvvmluwyudmhejzjrutwobhsgreqpcchrmmrmzjuaxpkoqdecypnnxxooixtrruvywjgnuxohyiooqahpcjzicgizuvsexhuhcyraxrzydewrryrdhgfaacarvwkbpqqzpyromjzlnxeagkdhqfuseqdwlbbetdehpakghltysckbeohcfdidvgmjeiectcolnvpawydwecfdmuuhtnngvlheqtjuazvcpjwovejryqqqjxigbaaushnlpvnkzhnqofqzmfinaniwfpziyqciqllxpkiieampzzzydejlcmvsnsheyjoxfmfbuluersomxngxwvbfroikhvsrrxnoduyfakqbmgseesmsvklrmeusudapshzbjfoutpchsdzcwsrsgmeztfbdhvnrgwecqdnrdzdbgrkmwbdgkdskkhhaaencqvcpvcwvtnymibroaxmlxnhiibfeiqqmltzrpdqlnwthbpxmxrtiigxlyhedcdyudpdafrvgtdnevhhywnxuahsmyxywmvdqtvnplnpgqyuunrgcthounbmhoioxdaxpuwyjlqgcfoxhzvxohncgjvcflcdvnlsrtwzwloydboofldidfyouenoynpzvgchhbcxyajthcanmojznsridyzviyzndbuygihzxgwymahmxtozesncvnbdqcmgqkzqqhzlhqkhmlghdbfkafdkywfzsojcxebiorleuzicqlfdnupfaprtzpvtcvygxkakhxqkzyhwgapvvugrvwgpeshgieywfrvosqjnyiridtuwtzjfkstgdmhnktadyqxplztwneqcamtdgnjkvzjydkbnkpbowvgqtvfxhpzwrdfgqtdwsmbsrvqpceokbuljdjtympscrgtjaztlscsvjxbmxzgiycctqqzrvbqxaqdrcpbnmhxthsvteptdigymffijsmdclqyhtcrmqogkpavjfcgjozkioeshbtdcfhngiuilopmsdqmjhofelghquptrtrypidiyuubahzzoyczqmsdzwikyczqvgwclygyghuumujozrjlahpmtvbgoolvcyobavoishhydirhegvrgzqfznhrpcrnvriufuutcbqfcbokserdompeubqrxfwdikhhehriumzhnbqlfdakaadczadeebxpiaqymzgtcyhlzwnczhqzznjtwafseuznuqsiforswcchhmmhztackinokeptxzorbtxvrqnyrooiaielcbtoqujceljwtaicldobjnrgiuhbtywmvtjlrvzxegiunyspporllbffalnovxvfmtjybhroyddlawmqvotoqxgzmbonuilajixuijvzlvjnyybbtdgujzpwnwkzqiqannytrpjhiwwcbzmxzgitidnarpqwusnxbktzfhhyjokqcrsfuurqmkarslfbmjqfonukznbsdtrhioacgovxvunuokkwzkizrymxeptqecvmmjbfdrgngwyirqubkqwxoygrjanxloyxfxyaazigxvgeviehhshlqeevpqqalkdvmehzkzlmeaoztysbwpekgtkfdiwbzxzrquykqcbvhuavgdyizufmljrecqhwwwmfllqrybzdpygxftpszgvpxflivntdwdbormglugdvqdbrsffckcexgyvwkntlbmjiofxjeibocmnacklfwqskyjihbnpndiyzmzrxdizokzducocflpbpxkeoinbxorgchkoyhcbnmknhtuslfqjaagaqnivrctgjyndcjxgtwnwgqarlcnpqhfgqregchrkmzmviibwyvkuzoenleiumqsfiyljtpacgqrjxipzlkwskzgxmrlsvceqmbgumawvbcevqqopigjkgxqfdrbcycxcdlnlxjkfheohrqasgtqxrzoycvhjaumsgilyneycnnphtrjuvhkjbbpkqcuzbrrrueefqcymtlnudxwepsdzyhbhqvnlmyauqwhjewltfpwlxwmnilagatknnddpuhbffuumdyvtxtvfiytsfjlsxlhkwibbdlhvzlbwzjfkcjxvtmopliaananvzlxokkqgzonoawgptijzolgndaagrhtdfopklsrohfknqftpfvhusykbqgzystpzhcvajnabuvgqpifbzmfezhjaxmyujbjaajzyscieuhzqijqodqshottrwbidfiafrxmmmqabhhmibnvspzewuzkdsvgwjflfegbbzihavgfwwyuwqcbpflxwxdzzpktzkmxdxzfrxuxevdhgnxlanjcdtordgxdghtcfebyyfsvdlhfluphaqfvtywguowyriacaagagavbzwbyruyoimhunkzlfeqxhlbevphfhvysczaalwmmluedunfcdjipkeqvspgtbbsyhxxuuxglllbfsrewfaeclvcfzlgriejcrjnfhwmzgxmgvcrqsicxknwuuxjzfxguozvxybbukakidytzkragluvmvcnvlzaksddfphnuycxocywzcxbvlnorideefkkurbyoclyhhcsdzzkvdnsufgpvhvhypctprvegjzpahxmesgrvxpfbbsiuasoeirzvsripqsnjgncuuybbirzagppmscanzbsvxfypbhupepiwsrcfrviyjlsitmapbtsphlpvfciruaiwqqkmizafsmythcqvdaodttgztgtasdrxuzvfxltaghxuieqtadghxnlbezkbsbvtfvmsqawyypqivpdepaqsvldbejofzkakasqylfubxytqceceugewrwidznfqivselcflfdqsaklvlujjkitcpabahqvphauhactszpzjbzdzjpdirpuvhcrfvbiuloacsdscaplxazzwbteywfvpnpkgckxelhrrlllfduorvesgjhrftjxhkqcwnmihhdwzzpkmgcawshwjppciapkvihnkjdpediydgordqdcmnhqqdfwjlhbpbybzhkuqtvzfvylhcwwsynqiphknasznmawalzlveepbwrwlhnuzbvsniofarkafvfztunnashnpqyjlgopzufjhslxhpdmnkkukvbljutgjapotlshoannbktmvqgivvoahzkamkcnoyuywfmpsidoqltzlymwksglnjzslzjzlplqrkjumgaxmouhyjomnlozhjofjvojnhgheuykwbtvjllwwxatvhuyeegqlljekrrdsdwacjawnibblrdotqlrgoaidaudnphbytmeqhybyklqpijfoiqtpuylrmysmbesqpblzbancujwvwqegoipbhvunflwvcqhecrdjcbmhbcvuiizdouehhunslbdesbmhsllkzjgupkfzrtangvjsdsgtnwucnnpbwrsfqoikpgpegpqtyyavzpksmbklfyfwcaitkiylypvbxsmfnpecztedgtwycnovqbosakscgcwdossenwgodbajxfjbtifjrbxrenogvsptewpiudweezmuwznzzatmyvhezholzqqcovbirjfpqlubvzmoaazbvwtwnipjzgpcufqyocuqqkvlbvmgicwadfhyxihjnrdrbhlsgjbyptfxfzchzqqwaymzyvkqhpyuqfrnedgddctknzeaxwbhpolhrwszxtlhoxeqgokejkdykevdhnkdkcrmogajftoybybalxvbmwzkmjkgzzbcftyfvfmqxshpkiwpmfunovdwzlhvjwlkeqnklldzmsazwojcjnxlnkldyabqmjoyvfcfggrfzmnftdamysxaqpchcrnenamkplmcvjcbhaufxnkbqzwmmmyexybljsabnrbfsjhoieepkvncrxrmhlbwezgmbwkjowoeeurtlgkbeldxqzrobovszxjpbsyncjxagtdtagddtjvdxzasgyzettsdjkppwkohdkwpbikbfhwoqxmqqppqukhzursglivtkshpzfwvmviufstsboooedretoqbspofskexawajefsgbcdagvbwxxpdvnmapkmnhtyipbpcltivyrzxbxnjweykryjivyozamrabtskroeszhlljxwmuqhrgzqzkrxneccfnkqbrekpqcncocsvhnmhckidumrxckhnibwfrycgsrdwnnkzzqpcrzcrxcwzundjcvtadjvfeodlpcqsbosfkeyzdueuevdtnhzztclxevxshumcjafvtwmfwdeynkseibznmwuzuryxmcucjvxrsrmwpcgriogerjnsgtzmknxllsutxjoqvueiwcsxeolqxoonufevicasrrtedtccfskocaeiggjcrgrmcixjjgshoszxxtviizbhhrcitiupewemdqsfoyovoeuqbktipxlugfnhexiscbktxicrdciximjsvpkyoldkieynyaglceyygvdchnhuhiqbnzpupdtqxbaijzpfdwhebtwjvhlvljzwaxexkafevpqtzpxfdrxqahiywpancxvvqmpqymqidbztjftbxtfxibtitybmxvojyfjnhgvusizpftjctaroigkrmncsclbxbkprbywfmigxnnbgmwyywfszakewomzdufuulsqbnnvnlpuqtffkbypldllvkmggyujiuzgvfndgzutunjldjpxrbtcnnxjtusnpfcrcweakpiljixzqjbktlgmaulacximimwurixegtoziwqevyiidvpfjpbeyjjwaicuvaehwtzybxuxkaywrxqfkjflimpxznqqdigfnikaoogutvmqbmhvpudqurqwpiuddbpeefmxqsoarupuamaxpgfvlbxsawheyktlndcscouktubjybfdztkfkpyjqjckepcoosufndwhmnsgetswgwgdzbinxpzmqxttqldrjsahrolquciqsrtwshheanveouomstlsfezattpaeidlnqlnsmbavxyqazkmvhtwxkixtrsjusrnwutmeirqsyznxhfiobthgtxzgeqmqwcexvowldviwpunkozbaxabxbanpjkqimoeiohlesvsoqjzcvqdrkzmvstxfhklaqyougerokvpdqldcqtjjnvsnzzwwxhzqsdgybeedanmxwliywkpydexrmcpqxoarakxftzdriksfdluwttshibthshllndombvvdextghvhbxxeomwahweoqnngxpyavzfivoibdgxhxffvtshluecfyheoyocauzcuzwmptpkqdaxxzxpdfyidhupldmkajohlzyoidphbcefqtqdkzqpuexytbqouzendszkspcupnidyijxsscrnqgemnuvplowaxrijbxuuhmpivwlyxroksonqqvdehufcmiwjndtmkhbrpsezkzstlolxyfcmptelnijjpsuyxtriksatjcdxeuhdgdtawtwnvhuurfijdvegztqgchuuvrcufhaqryzvocmjwuaxlgbkbbxgqzsjeralitqbhshsvszdxpjrdettpgogijpnohfszhiodjlrfpotbfvcudaihjimjzbsveorpcxykzgoinxcbcofqaeabouxmlayxrknbpbqlkfrmvhwrfsmcpsjokviukcocjuuzvbdihvejqqkozkqrvyukhvrudzqalufcanwmcetrxoehakiheyoqqgyauuuwsdvienlaznxuaczejtruubodiulsdbhrenkozgvsgvdvaememuklbwtwqrpnuwfzmjcgkwkwnykofphxmklipqsrovsyrjlpmsctzxvthlmnwhuthqnncgxzkmkubrlxuqphnribonqmhdofbqkzqstoulxvwqjoxpwbobhfyahjgqjhjtancxdxemotyfoouztfnnngvznsscsfigmblybkblfgwoswoglrzlofmzyanqtejafigihveubhxvepiyawnmzlrwdiqstvyzhkozsulzetwayuiowmtmszzerfwhseyktpgghpixnmwsrxjvcdactmnzaabodadrlwuznqtwjpbvfpshkckkbklrndmybzlyelupspwrxtvapdyozmrcsjmrqzjnlqkmraquniciqfetoqrcubangewebgtncfujxolhyndntfnllgserkybgnpkmslaqxknaexvotckzmuecauknepewmzdwfdxfxfetkarwsbcmvblbvedqxuzqkftyilqcyuaqepbvlzgutjtxblppapuaoeutxosyjpujeuplxveejdbyinmkxrxqjfcccpljfyjpanvxgesgjptkobratyykahznffxmlrwynngrdqobowptinfcnmjhfbixlrctcfzfmascheglebqrfppltfkrxhhssulxymacihzwcydlmyuzushplcbrizmmtcngvaogpxisnroyheighluytmvernefhhuixltaiegpvhdsmzyneksuznpdlumrsnecuiwcfiavhimqwpnvlfzkrzzybyvtnhxatxlzqcmvcigyjxnesvotewnomhyifbzikjyfkpaapmgyveazlopcvquxelgyzgmcvzwyjpwdllmgpxctwtzudxvnurzimjulggzqpkrbctcvcnszfgbuqcsxnqjxzceljtijbxtrktyqgjrnhbddeoifumivdnmdjweysskwmuiqcnfizmnqaveznoymrucefaaimnhcnnkkmfqopybjbvimtwxhhytirxmhlfnnhafucoegayvrwqjklzdzggpoenwucthussynlzaxmyylzwyolyloutujpoadqvulnzgextckpcrhxbhdiaftxzgpjzphpidsqapjtswfhetqplgutntmjrpjbzvlxchwynfjtzurinusdpaiwpkdcdogacxyvghduslqnlgfxcqngrkfjxzpoastpwfvuncjrtbhktgcwjbdthfmjtwgkgplqqojhhnewiznksrqhokahuxorpsjrqbjygttjgnlclfpyvvcnijjgvzlatpyzgytdjggfhmizblukobynasvnrbzzsedpubprpfbhhgtuobstarbyxnusrgvcrgfbieivbavfwucqpcjkyaqzkfhwkcwefuecxfohuotsghlrirlofrfdqerdjudtkvbmpjfnvkedhxzwemybrnsavojadzkmhouwsozlphfzxsfbpcegxpvyhovshatvpyuttxtiizzdbziivxttoumbinypxsichcrgiyrwkipgyugxtmvyljgsuepqrlufctokpfvojetlrjnglonahsmoeboqmymhmmogzzwiliislnvrdpbidmalawhjmhgbeahmslyobolrsqsjjsbphutivufuaxubecddqqknhiiueryvvzlvzuzrnveozameqdtncknvsycxsoyvyqzmquvapnxghsdsfudtagqeuwnqrpqekacigjutbyxevyqohzshjpkjircykqltfqumpcmvbwjokdbrhyrifgczrimssvlbbqpknakwopdhhkfokxmizlczicpjlhplxywsiqqyqlkqgwmreovuyyofbrfcmqxiwsmwnolopijixqhlglrgnlhrcysfyyfwxursftulgqoxkviwomdegktsixeknnbngmvkajdxaqljxjqnoehxjdxfhovzntqdayegyxouveagzroqgykkcvyppdvanphfcaikehqbpwopyumjcgojkaxlwhgxvorsuwyrbvbxaruwoeyadvkswmxfvrytmdhxzeapsulpcuvfbacfygtpspzarbyrrzktrdopbrqmtbwiokuhmypazwsftwmempwnfksgnpsjgpszuexotnvckpbpjphfxsmfhqktunoqxddtwjsiinzokowjlmkkangrumrsyfpgvpwlomehygyoppsayplobnmtlsfxuqergpcvlatdepxaqmlwwiylkoznzdhhbuhoyafgtqxvimljsluqiakbegdawsrkyyzarwehvugtbrtejhbqqlyfounocmhvqubselticxmsvuwlfdtryvdimjgxtfvlornegaxefehfhgkntcszieixugjknyqksisalnxpbazxzxbfulowkyhypzeywcgisariooymsbcnygphwxdsowxqenhpcccgnhqopnyxrpqgpzrhhfivbhiyrxvcidzhvwmsvlqxofdvypujckdtdbnxaslgcryszdlaheavpmrepwklhnjxjpugjbpynguqczqvreqzmzanaoorzetssyskmbhcgkqsnjzrfvsoyvvdoysbwohvtwzjbzlzpozvouzzcdhgckhlmjoeothfprxgehmnytwhpbhciiuwpkbdbgzxtulewpdmamebkfopmjmabtjlwzfsatuiowkeozezftkeszfolgbfocoybrzlzujjukvnhrrrmcxwinxksxgpbebvrqnxfitcmtckrrlcmgcxufemyfimdcqrkqkjbwsacbizlkjkujlqzqjxpyieqqckmjzbdedslbrwmzszwkgifpfikgciythnzaaimmpikuqmeqvkspeqywracfugwdsstijhlnugaepixjyxdtvwsjcdhychstcalvhtftwkmcrfcajhliiwpahlotdvkykynwktfutgwybakvjpqsrtwseoknjvclooyrujybxbuginasraugggplhgpbowwgzgoqyezwnyvqyhpekhpogjfzpherbjmodtuxjfbyjakbqbgdywbfzityioayjydflnnjsdrzjivyjkgslyhqateoxuzpulurkvgdfztklqtuxuzagqnzvsjhpongcqpcvijbjsljeubbtnnngayhwfzxrfkmxwzeubivpketyhzzubwdjdarthumyrkvzzhiajjkmbtmcnzsgyjdzeishjdgedjooajhufkyhkkmcrrmbuarlkvyihztfvcfwvkrtqrkmltxhomsddhmaeizbvscyjtnndjjablnczgdohmywkhrptqiqnjvmgcvwmtbrlhcaafvjpawofxgowunsdhxpzhswqiwlzhurjvusvlfujtghlpgomkvxcbnvgqvopozdnykxtaqpwuwkuzelgqtffthxijyuvduvctmjuvroomjospbapovwdnmaujooowykclhgcmbtwdlgfxsbftpqswxibtyniifbnliqgnbceprcecpddkqrsluesinlcncotsstqunizwzgbqitctcpebaaimsvdneyukishaqshukjsxoqqtvwukoinowawrirqpxubvgezmuwzveclqzoiykbwracmxdrfkhglsmnsvyenlimilaqvagtgvrcksthsyyxmsdxxnjrcnuaaymokupgdcjsscsbpbynkujvhnlwumssbsssihydzgdczquioqaaxoniwlseidyrgrhjjfyulhxfksvrozvjyjppzlmhyrnmcyhcrhhrnerwkidnmcjdtdvhhcvyrpepjlncgmcbfhvzpcejmfqnskaavjiolgszpdllxudjkdjgbfqwzkcbotkwvkqibpzhaqguueubzjuslvadkltbmhwhfszyefwizdftcbcxrqdtjfiebjdoazakwjgxoopldtzfobvinxdhtoruflmvzosahoiropkzvwzxlajypzmmwjzptlktwijagwgkirvhdceovmralkkvtbiqpwzsxecxpowptquvigxnjykxjdnkpshupvioedtdnoavmtrzvcnmhkbmfzdzokuovqykbrpyqzeziwfhhrmlhfoyvmptepbcmosaxuanyessugxnihcasvmhsyqkcdfobwllujqghpdbiophqzvfpxsnyhondxwcvticxowubyzdbmvocfjjmfwnmcmbukkvhelsbvdjshlvozbmgbpcpqlljbcvnzvaqlrcgowfnjoiieunczjbtnapzlupfffdwlwvzhlyeoluklyrwkypkznnshibrqeruicghjgfzhwqyrtkapuzaxmlhzlfmzwyohvikhnsxbduzpxkxmvzhavawymerjpovjdnqnqwfxtjwnbotwchwgcimsscvsupcuszqpswpusbqcwkbphwnllilrnodopisrdvusexrsritwbjjmnwdcezxkbidnpqhbaktxukovfddjltgxwyzfvfquiayfprzrepsrulshmnnfbtrllbeojilzvsmimztdktndesmeogvmwduwfrjpidveofmlibnpaamfjsbwdhlyiitzvdsmrfonmbekmrhyebxkruahsljzoortzkkmasayecpeuqprrvayfjrotcgfahfohwhstwgqezfrzvfnubzctwliuqtyxwkjlaozsduzgsbfcgigdihlytmaxrlctaqnaqidrolgawrjxshwmuzdnfebzxotithmmbwyyssyvuksdvgvnxcvrzdomozuriczkgvzyxrotygxbajuwienftuwmgmilfjczpttzvsyuoswglyflifrzilfnugtjvuuvldzqzazwgjvdmauyeueswadnvctfjryurygeffhumqxrwoofxtetmvnkfanldffwjtfnpyhnqbbsbtuuyoqgrwwcxrzfbxgllfytqeifikwoxkiwueupuvixuuktdbqybddokrldrmupohzqqtfxdoybmfdkifnbrijhnsqfalnwbzmzehnvujzgbndlyzagqejoceyhmrxjocxrpcnssomqvzzgqlyirxdoolfymkqgzjsnundmycebmrgnrpxumqpfsvkisjklwjdcfdbegnbxanhomjtkiqkqpoymmiowrgyqkeqwnduirtehzanhfjbfyzwlfyplwhzsqsbpvxxwvyzdpesocwkupfmveotvbseteoejkkavclrhjtxvkntlvmqijbcmhlnbmhyehlhznfhkxbhtmlhdziqxaqfzigtyddnpyqkxsjrnmyyrqsvjmwhebnfqfljoosjufgzffjitocsypyhlnrvthyiwisnihlrivfwgpxsusodwvigejzyufeltspzgjmknvvpmkgoggjuovfbcqlljaombuexqobhsbmhayxwlyexzemmpdaqcckzeqofyvumyacbzuydufltjnunmzpicczudckmlxypjcmavnetjcdusfxtykdaofejwzqeepnxdcmsigtwyufjzyynrutlqvxuiacqoyzthkktndtxlnvtrbqrcevzvjwhmakdaqxzimqqektmtagrlgxckcpibopmtrixqtfssydtupoowkispfcbadsgktoyycchjcyxppgidfrmmthcbnrarnkcfoqvuzygybzemdzvbaxwtfizarxkhjelqpkkrekzkgjaslbgenefjzrvwsrjojztqwaeabfzdhfzqzgtitsddejgqaltyzmahkhursoxmdgtrynyybhjkyffiomaudzbvhqpqqlesijzravvpwnnycbngijqfolboalrsdzravzpbuqfavsnsadzlaqznclygmckniaknspizatqpuzmrbpulazjrxohofludldonsxucuvaubtjcrdnbjsuwxfwrslmnspfnzpaceltmhhugqbjvaodufdfsclsyjyayeovjgaxbhuujguqocasdmkkislmohieyhbrsfqbnsoofwtujetsxzxnpzgrcjipdceftrdfbyesedlgtgqsvxxzoptbloittatepqflknxfiyjasfetvoxkhvgsqsurphbzporpsuczpupfnprkehseqfiqzbcteuaqpyifvsveddgcbueeuaqbpbkuaymlpvgiagigcdkxqgrstmnucsoqnsakusoqgmnepijscqirxyhaxawohqttwghykeoxvppecdtikwpznvpzmsvomzgdqbjudhbiyzfioxcehnztwfnplxjcbkdoaxhbxbedrmbzqlvqfcjypvcvaerpjwfpqzpcelonhcgooufpybavacvhiyxnkvlhxqbilfclcptblsskyscbkadmccadjvkmkjtghxuysmuhncyilxjauipbyhdqlbgmoepfakifpmanfqcfuqvdxruptwpvcgijozlydufldvilwubzpougdofvkfckneqwcwzsprvntyxrnzywcccqjydxykwmoxodyvxvjgbmybmpvqirpieqxfslfegjbfqxzpbjiapbiahloquouxdxehelczkumoqbmodawfdsmqneyhvmfmyueqjqmdnnpdcbpbvngzwdvneagpogbixenjvdnfroikujovcesxmbkiyvmobcvpebcujjaavtyphiopjwdbutteakhhxvjvkadhnktdeheiearykhezvsuuonvemcwumfwkxunmbntzatqqurbgrptpqxvkckrmpjkssddyelzobxmntggpryxrmmuecxyifpwflytvseszarquglfojrupalvruqxlxvcgksbbpgvzjhwtxycawudnhrwswxfykqmaxxfssbcjkqcfiwblthcaewikcjzwuqhenoaszrjjapsctbjcjmbzpqqdvbznzgvljfpajmdlzkfpigrtzztgmolgmfwjmpceoslimqtfpqkslehhratxwweutpgagesjhrdtklwxiigqbaitjovoxrgvzlxvpjjwmvaqucejoxpoabgdvdnlfsjlzkyxfwwuqdieafnkdxmslyajivtazrebuiftmpcrahsmxlvalqdehuilvooaugcoxauotszwmuufmysosdtgcbvddwxkilehngtgaftzgvkzowynctsqedehrkafmzwjyygeqvrkhcflmqkcwdfjsgcoigcztdamhzaxemimmnqopbdfsmvzssfhpgbspjpiafjahonlaerbrpaxanvgycsitvwssazzrhtvqierpjjebjcuyabnecajztpayyhepiwtnshropyagnoikeiouqrurrfsxkeocljcvfohtthlhaztxtavxjwvsvtljxblyhndhkkkyawhbsvsbcfhblaodprjxlxkfnsjqtfixxfilenvobglhjvrswnmdvjvyqgivsfviabgkuhkndyjaxrbxszlxabkjpqevizbaoofuguqhpwaemrgnqxrvqbmmhvghpvxqlmjzchxfbitrfuzzhrmljiunlkeijpfhybyfojqcszihdmnuepnwjpebgritvvxgxwrzhemwlgdgjtknvgdepbwkurkdqpdxphakicdfrmzwtszsacmlfjawnyzibneyhjsqecmitofetfyugwiwmwtjkwjaoqoplyswmriipqvkbftkvrtqmjgckveskuveiuonjyinoaatjvsuenvgiswpkdbbouvyhswsswfkirktmbywgwwkkbixxetkgaobqpeunfbgwazilfxbigtlyoyagimrlbagsvxzfpqbkjrdbuyzzxytjapnqdsrdbhrmxbbaiirfixrdfleelkmwzjlhfzggrzejcveyfckhxitymprwwzwxzvibmotftktuplbrzvdxcozhzwlsvpsxnaulgdcsoosomfqigcshfakxifwvmhfvacimgaxabmrhhzajzsdnqjghxocrragrqypzamqmfgskzmqdlifjzkoztcbdkphohuhxtnulghaytffnydaefigbgcjxmgygntjgpvgelgpzlxwktsmlagwabhhsiwsdilldyluorrngnyppcwxqduntabdntilhutkllnsmssvngbymdmuuufbvghkrmrobhsvvyqxadpsavidckxblnemwombnejyyegzhnyaagjzgvgwcclvxiwipkuvjgkvidchqcbcvxczoqhvkfvczitjyvzvanncryvonjcytctpazlpyscwyqmqvvnmmoqwutwzubmeyckxyxqkwvnhxxgfxgimbdrbtppqbzrikjfbgrchnuwqwxzftegkyznwcqwdzwoaabgdaljmeknaqixsrogechjkisgqgroyrwmfxsmwgbrpvvkpjpvpsaolwfyxxcndurymtmjrobxduwxdaglyhuqfhjpkpergelozcbxcxkkodejfgijwycmbiiixqdxdpkadmssvikhapiavmpqqvkmugdzixrsyfvtefrfghxgaqqqfsmdlntzygigeijtfvxummwjuzzrxoplupalzrhyrukmimnaksyhgtkqttqgjzxopsythyylymdmeifogbwtxgholdezbisttrlovefrucxeatfndkiizyyxkrlcluttlhgxrslzyaqdhbticdvwfakbzpntbbxgdorihhnfgcylehaczdjemvlxlucsjjcjamuppekhewutxrjtjmctjjfoytcusndnbkplcioblvgvrciwvdukjtwwvfnghedcosncgmfgxiqecajnakhngtulewskvarzqkofrgsbdxrnblhlfveouwcrogosoqxirqvkzihpnrkhsicbitdeaqjgdswmmbctgabhfgpmbsnwyzarcpteqjzzkpagnzlupvhkuiugmlesilvzhyeonoltnqwmulegecloeznryhmdruqikwpzjxyzznybyhtjvbrptyuderjsfjnjrnhirkrkgkylulanwmnpgptlevsscedsfpxzkweumntqyxejxxmhfjztjapdurlpkztbzdxgovtxuuqweglthjaindyrtmhlgkrzwqrarlvsuabmvppwltvutbtqxlwcdtoqmborivwpumycyodwcrttpurkymjwvblwwcvzopxpltqvgsjfgeiadsrzauwzgywrvoolaiohugvmyuiuzbbgnifsvmhphsaykyjbtaslggvfssljyfkrwydvlmydtiohxwqzumvtszkbuebpzseefdsdmyssjnxjbqhfwwzqkqnohfcnnweugchhfdjhgnqaoztvtoohlznevyzqpdjcorlpttlofqytwbysewyhsngfiiatcewlccwjbfhljrfxjlowajpdxjqnxbvsakcuyiipgeavetvldebbgkjmimrhzfilhuccikbnuiewflkkcghslbeedhqvdbrejkjljxvyszudibigewbixtdonjmlobziyajqnnicriphqzlxbtdgoyltradjccniurlttimsnwhrffpfnvfkzmzujhpuvpyisetkbrgpygvcaqrzmuxahblmhiktfgwvakmkkjfwfhrknnszmoqsfuupadeomfmwsdswgoiclfubpddzccoildgkwzrgqqruqhlnxeybiojurfflpjyslddtntriomxhottnaelqmgckvkxctnghysnqiflhpcaeiclylutfapscjyhscgqejauemyjsubnilcuatwcdglmlcfwuvepxnrxuliyflnbauqqqajpkkifoitgnpomdsycmwqbnmoidumcmhdhngovfcczswnpayjuryqcsinaoarymgmwofpjlsrhogstnfxvrbebxfalkxvgzbivqokelschrkgbvifauttkotkkulicwkcgselbmqkpuesyzmajijespiubdbmvahxwxjbwvsnutuquphujrmffaqglhihvgztlpyalebacxdtjwvpszghchclzeodburizwgeucplbvqkalzfonzuildeopiwzyzrxsjggbgjzxlrcvtjaaqevkvcvvpproaxkzryekyjynfymfzzzffjxgjdgmapvfumuwesiqsiuxtithorsogynatoervemrqvddijwbkgtlmqfdrssbtipxcktekezlmsgxqezjvejltzhyjhdiygeshzeqddhxegaztvlabarspmlcraadsjgrfmflvpubgvisabjpvdvriqegyvczmgkbobkkyjtdybvhuprxwgsjxfdzczcarglgnvknnajmiexbiyjndtdmwexhkhnxllbenyxdcrukknstoxhmbsmtijungpvrqkfeiclodjfwnhqsabyautfwlkxihuuovbcznczwpnbttuqgmgheqvbevjbqgmdampasyqsbsouturkfkgzbgmkudlorvwjikwbxatqdkajajyiumzajkubzlyuftjefpdcyahhxptkmxfneftbzfzazewejofjemcoarkjbeqejzllfxqoisjklxjdomlxdyjrwkvolaualympzwyfjeovzvsijpsuazpttsztgoptpcaheavojwnptnphyqkxrrbcvoitsmpmzlbvggjobyhrlswzqulmceyvkzwwvgusitmdowhdeuocbvxgnyblrmhweedzslrkaajtnitcoqpgaihdspdrpvqtzqnelfbdndnxmnmjpahozrxyfihdvkzlsjgounactkmsybvtymdmfdpcnszrxhyicrtnnovanpywolbfylfkjbpuroewwpispljpmjrthsesuqposybkzwdnkptzecwfbwdmmknchffvqgnpudxwqfxncmppbjsonyjbtwoolptffhgigorccgdmawkrvnrehatqnnlvplvsnnwmssdcfdfertzovpbqnjdrficmrmlbdjbiteupigvfalvuhhxbrvbuzyfxronozahlqrhofenhwwluysnixkfatacdgzjgepxxhtfegldqllpjspvwqmpocjkpkkkjmakrnjarwviszgngrbydjnlvsohlhyejmyioaclhxukjxpaysfegdsixrrrnribnmumyejrywunfcnjqioznxkqoisohrtzecyldhhgagsbuajxjrtbmvsklrrtexbzelwaadgizuuvvaprxzgnaysqaqirvxizkpzfgmotnbbzzqrdxiipduqvkftqbmsfxufdtvfhphhazrjjlopuiwfwjmsjlwkeideirwizuuodypbjuagdjcrfzatrdsnqrbtdmdetelaclyawymgtrmssuntzvpsukuqbcvlpesoyghvcvuehlyksxfjzcowihpdczzlhhmouovbkqgzdizmmhklpyfvfbcbhygodtbsvswhnqjgwyqyjrhflwnuyfmcqyjikgdbxfuidbptwtfcddeetcwyxffiylffbgzimbxjrcgvfyelnduahxykiyvnpnhtdcjddrubingaxtqndoyyjtrtqxmfwdwvxvqkcuubathteaykcwezixeygwygvwvshowljcotbrajvvcukqvslxozyvoxbuobnpokyapsfdnwdadnfssccqwnbwuvjjiuxfurwazplrvqgbqzkxaewmmcbozvhemovxvocnyipkbwzsrseohyyifoeqtcfetwpaqfnqybayczerpkdojwonaaeldzjcadgkxakrutwlbbjpeszwttbnsggbcdrhvgexbpyzqkeuqgbywqynqhgrguccfcdahixbpimcsmwilaxekdjcmoypderszgtwvftremfkvlfxtxqgjybwmsdugsdyvvmgroysiswjmslqhvkkcujputyycktuzecqpamhcwzyrpmlgdkyuesgiyotwmpzkrguyvbmfwzfuvxuogyubqsbigebndhxyprbbnkikrapnqleleivdnbuhyjxwrdcaqlzwhrmwzrpszvalvllekuragjaonvfyrlmwgjlifmngmokwugpxzntmbpedfnlifyqazkgddaoiyyvcbbisijxsjwjjldtukizoehyurniaikxzsnntzohioygpwddgzmxihohozsxokykswpyccbznkkqgfxelhzaikzqcdbnugopxaufobqfiuksirbbsjtbgkbjpyqmwdnaeehvwmubbrddypfdujcrxfwabozgdofzeezwgdedwtbkgxuugfkmnjurgbtoaoxcscgpjqqjdcmimqyfdafbprklffsajqrpsrxsrbhtcuxtkawkqwlesibfoyhcemicjdoybvrldhsuwqjtkzyfydmupqjorsvdgylpzlcwccheqonpdfrqhiwlesmsmjjxaqcaztbghjngicjykplmuzooznzgjfktxmrobvtinfkdaewjikoqvtfkrslyqnztrejhegcmvodmrbrwxomkvmsadjechancuqiviwcakcefkgmcpgrciwttjkjvsisucrqcieitkaecsoeddunvcesreyxsgqcislhyaxbqjvwhoeengnqcenmoeblduudozufiejyloxezjzuiksqcgnyavlyevodgilxguuaiglbestlwcdqqiiurdeqbjfmozzgfsjiomasoroidwmyaitdospaxydhcvjymzqdlyfivxcuqaxrmngirigufeljwfbbmzuopfbcuydvxuihmesddufgpoknwwxuyofhzojkoaeofctwmdjqnmvbemjbnkqkzuvjwxgaryubnhvsgvucjekhlcmvlqryjgwyzqfgnbcqoyafpbcywkkutcfvngndgmexzpoviolzsdcickeyjcghqmpdyrozeapymuwwctjvqkoklrfqftfjekmvrmpudoyyxffyqifjxjbzowtoxuktgoatarlkbmdmkcqnhdgrhmqxoswaxumtsasbxuuyorqliyuwtipfiqwbumicxcmmiomrsvxeqxykpzabodotdaddkftquevvzomvxgzbpvltasqujnqkkyjplnkyqonutoyanvtawwyxuphrlqouorpsaimlrafmzhhqxsjbyllxwcbxuqohcajbggvxwstfmadfgjgkuxmnvcbayqibiertvdwzkqoectqjitaxykthuftzyvnqwpipogqaxtzytaldeprjoefvqdwixeofjrfhxuivrxyjmgrsgfsltegscwfbheczlugevdfgftwzaronckijsiwjmxltbnyqyrkhqewyuwavsxmyitttiqbvsvqyasjnwzkitvinbffsfabjygagzyxftleuxzsfcspslpuoaiivifcyycqpvahqeovgkxtmygowuiktxtudbukkwvlerdiuwzmqwihadqdvyitvffiivciczbxcmxszmkrpwkiyayfczfdzlxutpszgjrbnufoqwsqzialfhgyfkeccurvponhfkkhwftdnambmulkcysxlhydtppmcumtwflolgwbmucrllfoakjeilohxrjdzvffdklgpqnhzwdwmykiihpkyuvyzbuenjxyjsreebibcfrzfhkcgleuzzphrydiecrxrwtpfwpnqqhlapqtptuafbtnkfhnaggoqqqynapeyzwftywonbhpfmhhbofknhwvdlucfcvikpjthlgrqqpbenwfundmrthgadlggurszkvpuhkhmqwwcsfdduqxeqrxtfluhkrwttoyrkbnxxtffdjlundumesteshbstiqyvehckadlixlfvdfakheqyxjvasmfyffvkmkwuspcqjhuzfgqcoqrlzqlwbhajqznhmkycoebfwyjgljnrvtfmblxxioqiqhsjxlktduszujusqrdiimfshxhgavmlpcqxireusnaguuqxfrmndhtwaedvxmfpqwiwfllijnwgtoteuhmfqhfesrhntloxtzcnwesbegsriaqsmaqiomlsldulmlecijrlgbjacatbhrhplqtecvaqonvnisewldqxusqxkbvihgrjsuvhsnkbkzfjfnnapmjcpudqdhtfmxjkhqpilkxwbfpguztoqwzdqadqyauezcahuvmftdrkempzxqioxbsoudhgaggtlufvrmuqujlaoiisppgvfnuvqlgejvqaslhzcllleqspjwugonagiszjfoolmrnqxnwtqjmwadzeqxyxjjprveglmpsdqinrtsyqjnqbwnedhpowxdoaxmwfzdxdrbfwetjbbphxbtkbgttapqlqpzrjvonkbpwhlvdaszrskpcdpfvqpdapjptusxpxqpfsdgdewytnkgipltdapddncgcdmdrjmgixumpmpwftyiahzlgncfxmaigdcvrllwdfoxiehfkpubtpbezvlibmrlsvpgdfoarbzezzomosexhecmhrnojcggwzetcaiidetaqtslcinbkwkxkzoubncwyavcaosjcxnmfyuzvmqrixmsuevfrdfnbwgffprmseizzblvjzpyljxqmdcorhwppsguvucuofvjofnahwlphdtcoplfxhhoythwwsmhwnxtqsuqjulywahfabvmnnkwqzinpziqvjoqvgybuqgjnsnxhsicwvgwmqupbvecoqcgztgxrjweiewgaslinhtrcakljpiysyoplxogcuxpttmwyduipposirnpzsqktuhonsjxaaywlamhrpvdfmncfvvclzlnjqltcytagsbkxydupeyfsagvsblotxalloxvusjofodaqnnynstbudaufoimjymqsmynasatvenuiqrpzhtbtidnqtzopscvhldxzapesattnhogndoxypvznjpwbxxsyxuwpilniuneuyzbwwidkedmpwvxdynemyuszrglqngolqzdanuhvwojomhksaqbwcryxrbmltlzxebcfxlezcsufjewitdrnshayemfatpivgoxjvbhzxkntwrtwtycfgeufqvjhjzlpbgnjwnkmjgxwoxnqlxojmmjcxkjqeukjbgucsbqqsleopnafwoizlzybammnpzmybnvfqmsxqddwlxlmgpkeunjhmrokpeiijgzgqivwkohlnlxasrowpwaxowkodbmlvtqepkptqbezvnxdmrjbnuobeywxbsrfesarpjyxlvjtssspuxcqxljhjpzbkfotatyjdgaeuienmgeogyshqoxjljwdoegfhzhkvenemsercxqawkhizmxdwcfreeikkujahxqiezezvnltupmrbmflewavchgiodnqexplwbshgrcabpfwedguljneaultdmimitedxukjfzsxlievmsfgjvmsjsdeavlcjuosmeazftorouliqdtxrhbwvkkzavtmywbywlqgwgoivddzcathrrccezfspcikalpgnchqlmqpspfqnesqtgewqnemdfnxkzenakxshosaengpkpfpenmkfinaedzvqgdtqtfcagwumbwsyrronfqmzpgnotdhloxohtltjxvtypqjqzkfizbakjdhsxreagqtdbvhnobzghqkajqbnxrbxdzadsgqrvhywlzkpqhpqqssuivydlwmxucsalpoiikjszcmmhclrodkyduitttgwzvnpovnuewstxfczxzwgzmmwfvgqyeyevvzuzudezqyombioptfzcpdzslibbarwrmjlsmikkjrbuvjgwjwjynykewxmptlbeaegyvdzftrxcqngzewsqjbenlybqehrvtjuulrpisbvriefaovxjgnjdvvvqbtiojvdqaprjpqtuvdmujedhjpsdtuzpoutfnlmouyvbbseuzwkhvgkaccwlcukjihxtpkmwavogsgkgxguqtbfpzcertroyhozbftzgqnrvwfdiozssaxofctldoqpysfqieathnvfmifyrjoaaotawgfqmpdmiiilakbrxzoystcnwprkfohsxyuhydxjrdwnakhgbvjcnzlyhqitirdhbirfxmtfgpjlpqhoneqcgldmdazzysxilmywqscdiztkwaqrsfrnovrhkhgdfpniezqufvlnvglwxashjdkykddvlhbccgeakcynsqiahwvfuewwjiijovfgebfzusmltawkcqyrwjzhxmfptbpbbvjxbobkhvqlisfypmdlpttaerqfrvdwnuowyglzupqlmvjwkhunymenwxtwdjonwkduezcsjzrbndwvyxpjokvdqunovyjnvpcyjiwxqctfosclowordpjjavckstelwcwykkozuvbbqqqfwcxgaxevkhgbnythqwjgbedamcyqchtql
\ No newline at end of file
diff --git a/tests/ports/psoc6/inputs/test_fs_medium_file.txt b/tests/ports/psoc6/inputs/test_fs_medium_file.txt
new file mode 100644
index 0000000000000..ab8135ee408e4
--- /dev/null
+++ b/tests/ports/psoc6/inputs/test_fs_medium_file.txt
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/ports/psoc6/inputs/test_fs_small_file.txt b/tests/ports/psoc6/inputs/test_fs_small_file.txt
new file mode 100644
index 0000000000000..730718c1493f1
--- /dev/null
+++ b/tests/ports/psoc6/inputs/test_fs_small_file.txt
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/ports/psoc6/mp_custom/fs.py b/tests/ports/psoc6/mp_custom/fs.py
new file mode 100755
index 0000000000000..84c31c56575f3
--- /dev/null
+++ b/tests/ports/psoc6/mp_custom/fs.py
@@ -0,0 +1,169 @@
+import subprocess
+import sys
+import os
+
+device = sys.argv[1]
+test_type = sys.argv[2]
+mem_type = sys.argv[3]
+
+# tests inputs and script paths
+test_input_dir = "./ports/psoc6/inputs"
+test_script_dir = "./ports/psoc6/mp_custom"
+
+# List of mpremote commands
+mpr_connect = f"../tools/mpremote/mpremote.py connect {device}"
+mpr_run_script = ""
+
+# Remote directory path
+remote_directory_path = ""
+
+
+def set_mpr_run_script(mem_type):
+ # Required to mount the sd card if the test is for the sd card
+ global mpr_run_script
+ if mem_type == "sd":
+ mpr_run_script = f"run {test_script_dir}/fs_mount_sd.py"
+
+
+def set_remote_dir_path(mem_type):
+ # Set test directory path based on the memory type
+ global remote_directory_path
+ if mem_type == "sd":
+ remote_directory_path = "/sd/"
+ else:
+ remote_directory_path = "/"
+
+
+def get_test_input_files(test_type):
+ # The "basic" test uses only the small file
+ # While the "adv" (advanced) tests uses all the files
+ cp_input_files = [
+ "test_fs_small_file.txt",
+ "test_fs_medium_file.txt",
+ "test_fs_large_file.txt",
+ ]
+ input_files_sizes = ["10240", "511876", "1047584"]
+
+ if test_type == "basic":
+ return [cp_input_files[0]], [input_files_sizes[0]]
+ elif test_type == "adv":
+ return cp_input_files, input_files_sizes
+
+
+def get_test_name(test_type, mem_type):
+ # Specify variant tests in test printed name
+ if mem_type == "sd":
+ mem_type_suffix = "_sd"
+ elif mem_type == "flash":
+ mem_type_suffix = ""
+
+ return f"fs_{test_type}{mem_type_suffix}.py"
+
+
+def ls_files(files):
+ # It will return an array with the file size found in the remote directory
+ # If -1, the file was not found
+ mpr_ls = f"{mpr_connect} {mpr_run_script} fs ls {remote_directory_path}"
+ output = subprocess.run(f"{mpr_ls}", shell=True, capture_output=True)
+
+ files_result = []
+ lines = output.stdout.decode().split("\r\n")
+
+ for file in files:
+ file_size = -1
+ for line in lines:
+ line = line.split()
+ if file in line:
+ file_size = line[0]
+
+ files_result.append(file_size)
+
+ return files_result
+
+
+def rm_files(files):
+ # It will remove the files in the remote directory
+ # The command will be concatenated with the files to remove. Example:
+ # ../tools/mpremote/mpremote.py connect /dev/ttyACM0 fs rm /test_fs_medium_file.txt + fs rm /test_fs_medium_file.txt
+ mpr_rm = f"{mpr_connect} {mpr_run_script} fs rm "
+
+ rm_sub_cmd = ""
+ last_file = files[-1]
+ for file in files:
+ append_cmd_operand = ""
+ if last_file != file:
+ append_cmd_operand = " + "
+
+ rm_sub_cmd += f"fs rm {remote_directory_path}{file}{append_cmd_operand}"
+
+ subprocess.run(f"{mpr_connect} {mpr_run_script} {rm_sub_cmd}", shell=True, capture_output=True)
+
+
+def rm_files_if_exist(files):
+ matches = ls_files(files)
+
+ # Take only the files that which sizes are not -1 (the existing files in the remote directory)
+ existing_files = []
+ for i in range(len(matches)):
+ if matches[i] != -1:
+ existing_files.append(files[i])
+
+ # Remove any found input files in the remote directory
+ if existing_files != []:
+ print(f"Removing existing files...")
+ rm_files(existing_files)
+ if ls_files(files) == [-1 for _ in range(len(files))]:
+ print(f"Existing files removed.")
+
+
+def copy_files(input_cp_files):
+ ### This will create a command with concatenation of cp commands for each file in the list:
+ # ../tools/mpremote/mpremote.py connect /dev/ttyACM0 fs cp ./ports/psoc6/test_inputs/test_fs_medium_file.txt :/ + fs cp ./ports/psoc6/test_inputs/test_fs_medium_file.txt :/
+ cp_sub_cmd = ""
+ last_file = input_cp_files[-1]
+ for file in input_cp_files:
+ append_cmd_operand = ""
+ if last_file != file:
+ append_cmd_operand = " + "
+ cp_sub_cmd += f"cp {test_input_dir}/{file} :{remote_directory_path}{append_cmd_operand}"
+
+ cp_cmd = f"{mpr_connect} {mpr_run_script} {cp_sub_cmd}"
+
+ subprocess.run(cp_cmd, shell=True, capture_output=True)
+
+
+def validate_test(files, file_sizes):
+ # This function will validate the test by comparing the file sizes found with ls
+ # in the remote directory with the expected file sizes
+ found_sizes = ls_files(files)
+
+ if found_sizes != file_sizes:
+ msg = "fail"
+ exit_code = 1
+ else:
+ msg = "pass"
+ exit_code = 0
+
+ # Print the test result
+ print(f"\n{msg} {get_test_name(test_type, mem_type)}")
+
+ # Exit with the exit code
+ sys.exit(exit_code)
+
+
+def cp_files_test(input_files, input_files_size):
+ rm_files_if_exist(input_files)
+ copy_files(input_files)
+ validate_test(input_files, input_files_size)
+
+
+def large_file_tests(device, test_type, mem_type):
+ set_mpr_run_script(mem_type)
+ set_remote_dir_path(mem_type)
+
+ input_files, input_files_size = get_test_input_files(test_type)
+
+ cp_files_test(input_files, input_files_size)
+
+
+large_file_tests(device, test_type, mem_type)
diff --git a/tests/ports/psoc6/mp_custom/fs_mount_sd.py b/tests/ports/psoc6/mp_custom/fs_mount_sd.py
new file mode 100644
index 0000000000000..be0cf2a1a72be
--- /dev/null
+++ b/tests/ports/psoc6/mp_custom/fs_mount_sd.py
@@ -0,0 +1,36 @@
+import os
+import machine, psoc6
+
+if "SD_CARD" in dir(psoc6):
+ try:
+ bdev2 = machine.SDCard(
+ slot=1,
+ width=4,
+ cd="P13_5",
+ cmd="P12_4",
+ clk="P12_5",
+ dat0="P13_0",
+ dat1="P13_1",
+ dat2="P13_2",
+ dat3="P13_3",
+ )
+ except Exception as e:
+ print(e)
+
+ # sector size 512 B
+ read_size = 512
+ # page size 512 B
+ write_size = 512
+
+ # create a LFS2 fs and mount it, else format and mount it
+ try:
+ vfs2 = os.VfsLfs2(bdev2, progsize=write_size, readsize=read_size)
+ os.mount(vfs2, "/sd")
+ except:
+ os.VfsLfs2.mkfs(bdev2, progsize=write_size, readsize=read_size)
+ vfs2 = os.VfsLfs2(bdev2, progsize=write_size, readsize=read_size)
+ os.mount(vfs2, "/sd")
+
+ print("SD card mounted at /sd")
+
+ del bdev2, vfs2, os, machine, psoc6, read_size, write_size
diff --git a/tests/ports/psoc6/mp_custom/network_on.py b/tests/ports/psoc6/mp_custom/network_on.py
new file mode 100644
index 0000000000000..ad7cc1eda7ba1
--- /dev/null
+++ b/tests/ports/psoc6/mp_custom/network_on.py
@@ -0,0 +1,21 @@
+import network
+import secrets as s
+
+from utime import sleep
+
+wlan = network.WLAN(network.STA_IF)
+if wlan.isconnected():
+ print("[network-module] : Already connected")
+
+# enable and connect wlan
+wlan.connect(s.ssid, s.key)
+# wait for connection to establish
+sleep(5)
+
+for i in range(0, 100):
+ if not wlan.isconnected():
+ print("[Network] Waiting to connect..")
+ sleep(2)
+
+if not wlan.active():
+ print("[network-module] : Connection failed.Try again!")
diff --git a/tests/ports/psoc6/run_psoc6_tests.sh b/tests/ports/psoc6/run_psoc6_tests.sh
new file mode 100755
index 0000000000000..2c1725d7dd184
--- /dev/null
+++ b/tests/ports/psoc6/run_psoc6_tests.sh
@@ -0,0 +1,425 @@
+#!/usr/bin/bash
+
+## Move to the tests directory if not already in the tests directory
+cd "$(dirname "$0")"
+cd ../..
+tools_dir="./../tools"
+tests_psoc6_dir="./ports/psoc6"
+
+
+usage() {
+ echo "Usage:"
+ echo
+ echo "sh run_psoc6_tests.sh --test-suite : [[--dev-test | --dev-stub ] | [--booard --hil ]]"
+ echo "sh run_psoc6_tests.sh -t : [[-d | -s ] | [-b -h ]]"
+ echo
+ echo "Mandatory argument:"
+ echo
+ echo " --test-suite, -t test suite to run"
+ echo
+ echo "Available test suites: "
+ echo
+ echo " ci-tests run all continuous integration enabled tests.
+ Requires the following arguments:
+
+ --board, b board name
+ --hil, h hardware-in-the-loop server name"
+ echo
+ echo " vfs-flash run virtual filesystem related tests on flash.
+ If followed by -x, runs advance tests too."
+ echo " vfs-sdcard run virtual filesystem related tests on sd card.
+ If followed by -x, runs advance tests too."
+ echo " no-hw-ext run machine modules tests not requiring extended hardware"
+ echo " adc run adc tests"
+ echo " pin run pin tests"
+ echo " signal run signal tests"
+ echo " pwm run pwm tests"
+ echo " i2c run i2c tests"
+ echo " uart run uart tests"
+ echo " spi run spi tests"
+ echo " i2s run i2s tests"
+ echo " bitstream run bitstream tests"
+ echo " watchdog run watchdog tests"
+ echo " multi-instance run multiple board instances tests"
+ echo " help display this help"
+ echo
+ echo "Available options:"
+ echo
+ echo " --dev-test, -d test device (default: /dev/ttyACM0)"
+ echo " --dev-stub, -s stub device or second test instance (default: /dev/ttyACM1)"
+ echo
+}
+
+for arg in "$@"; do
+ shift
+ case "$arg" in
+ '--test-suite') set -- "$@" '-t' ;;
+ '--dev-test') set -- "$@" '-d' ;;
+ '--dev-stub') set -- "$@" '-s' ;;
+ '--board') set -- "$@" '-b' ;;
+ '--hil') set -- "$@" '-h' ;;
+ *) set -- "$@" "$arg" ;;
+ esac
+done
+
+while getopts "b:d:h:s:t:x" o; do
+ case "${o}" in
+ d)
+ dev_test=${OPTARG}
+ ;;
+ s)
+ dev_stub=${OPTARG}
+ ;;
+ t)
+ test_suite=${OPTARG}
+ ;;
+ x)
+ afs=1
+ ;;
+ b)
+ board=${OPTARG}
+ ;;
+ h)
+ hil=${OPTARG}
+ ;;
+ *)
+ usage
+ exit 1
+ ;;
+ esac
+done
+
+if [ -z "${dev_test}" ]; then
+ dev_test="/dev/ttyACM0"
+fi
+
+if [ -z "${dev_stub}" ]; then
+ dev_stub="/dev/ttyACM1"
+fi
+
+if [ -z "${afs}" ]; then
+ afs=0
+fi
+
+exit_result=0
+update_test_result() {
+ last_test_result=$1
+ exit_result=$((${exit_result} | ${last_test_result}))
+}
+
+start_test_info() {
+ tests_name=$1
+ tests_dev=$2
+ stub_dev=$3
+
+ echo
+ echo "------------------------------------------"
+ echo "running tests : ${tests_name}"
+ if [ -n "${tests_dev}" ]; then
+ echo "test dev : ${tests_dev} "
+ fi
+ if [ -n "${stub_dev}" ]; then
+ echo "stub dev : ${stub_dev} "
+ fi
+ echo
+}
+
+run_tests() {
+ tests_name=$1
+ test_dev=$2
+ tests=$3
+ excluded_tests=$4
+ stub_name=$5
+ stub_dev=$6
+ stub_script=$7
+
+ start_test_info "${tests_name}" "${test_dev}" "${stub_dev}"
+
+ if [ -n "${stub_name}" ]; then
+ echo "executing stub : ${stub_name}"
+ ${tools_dir}/mpremote/mpremote.py connect ${stub_dev} run --no-follow ${stub_script}
+ echo
+ fi
+
+ test_dir_flag="-d"
+ case ${tests} in *.py) test_dir_flag="";; esac
+
+ ./run-tests.py --target psoc6 --device ${test_dev} ${test_dir_flag} ${tests} ${excluded_tests}
+
+ exit_code=$?
+
+ if [ ${exit_code} -ne 0 ]; then
+ ./run-tests.py --print-failures
+ ./run-tests.py --clean-failures
+ fi
+
+ update_test_result ${exit_code}
+}
+
+mpremote_vfs_large_file_tests() {
+ echo
+ echo "running tests : vfs large files"
+ echo
+ chmod 777 ${tests_psoc6_dir}/mp_custom/fs.py
+
+ # On device file saving tests for medium and large size takes considerable
+ # amount of time. Hence only when needed, this should be triggered.
+ enable_adv_tests="basic"
+ if [ ${afs} -eq 1 ]; then
+ enable_adv_tests="adv"
+ fi
+
+ python3 ${tests_psoc6_dir}/mp_custom/fs.py ${dev_test} ${enable_adv_tests} ${storage_device}
+
+ update_test_result $?
+}
+
+vfs_flash_tests() {
+ run_tests "file system flash" ${dev_test} \
+ "extmod/vfs_basic.py
+ extmod/vfs_lfs_superblock.py
+ extmod/vfs_userfs.py"
+
+ storage_device="flash"
+ mpremote_vfs_large_file_tests
+}
+
+vfs_sdcard_tests() {
+ run_tests "file system sdcard" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/sdcard.py"
+
+ storage_device="sd"
+ mpremote_vfs_large_file_tests
+}
+
+no_ext_hw_tests() {
+ run_tests "no extended hardware" ${dev_test} "${tests_psoc6_dir}/board_only_hw/single" \
+ "-e ${tests_psoc6_dir}/board_only_hw/single/wdt.py \
+ -e ${tests_psoc6_dir}/board_only_hw/single/wdt_reset_check.py"
+}
+
+adc_tests() {
+ run_tests "adc" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/adc.py"
+}
+
+pwm_tests() {
+ run_tests "pwm" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/pwm.py"
+}
+
+pin_tests() {
+ run_tests "pin" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/pin.py"
+}
+
+signal_tests() {
+ run_tests "signal" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/signal.py"
+}
+
+i2c_tests() {
+ run_tests "i2c" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/i2c.py"
+}
+
+uart_tests() {
+ run_tests "uart" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/single/uart.py"
+}
+
+bitstream_tests() {
+ run_tests "bitstream" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/multi/bitstream_rx.py" \
+ "" "bitstream_tx" ${dev_stub} "${tests_psoc6_dir}/board_ext_hw/multi/bitstream_tx.py"
+}
+
+spi_tests() {
+ run_tests "spi" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/multi/spi_master.py" \
+ "" "spi_slave" ${dev_stub} "${tests_psoc6_dir}/board_ext_hw/multi/spi_slave.py"
+}
+
+i2s_tests() {
+ run_tests "i2s" ${dev_test} "${tests_psoc6_dir}/board_ext_hw/multi/i2s_rx.py" \
+ "" "i2s_tx" ${dev_stub} "${tests_psoc6_dir}/board_ext_hw/multi/i2s_tx.py"
+}
+
+wdt_tests() {
+ run_tests "wdt" ${dev_test} "${tests_psoc6_dir}/board_only_hw/single/wdt.py"
+ sleep 2
+ run_tests "wdt reset check" ${dev_test} "${tests_psoc6_dir}/board_only_hw/single/wdt_reset_check.py"
+}
+
+multi_tests() {
+ start_test_info "multiple boards instances" ${dev_test} ${dev_stub}
+
+ multi_tests=$(find ${tests_psoc6_dir}/board_only_hw/multi/ -type f -name "*.py")
+
+ ./run-multitests.py -i pyb:${dev_test} -i pyb:${dev_stub} ${multi_tests}
+
+ update_test_result $?
+}
+
+run_ci_tests() {
+ board=$1
+ hil_name=$2
+ tools_psoc6_dir=${tools_dir}/psoc6
+
+ echo
+ echo "##########################################"
+ echo "running tests : ci-tests"
+ echo "board : ${board}"
+ echo "hil : ${hil_name}"
+
+ devs=($(python ${tools_psoc6_dir}/get-devs.py port -b ${board} -y ${tools_psoc6_dir}/${hil_name}-devs.yml))
+
+ # TODO: This mess needs to be solved in a future script rework using yml files to define the compatible boards requirements
+ board_version=0.5.0
+ if [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ board_version=0.1.0
+ fi
+
+ devs_a=($(python ${tools_psoc6_dir}/get-devs.py port -b ${board} -y ${tools_psoc6_dir}/${hil_name}-devs.yml --hw-ext ${board_version}.a))
+ devs_b=($(python ${tools_psoc6_dir}/get-devs.py port -b ${board} -y ${tools_psoc6_dir}/${hil_name}-devs.yml --hw-ext ${board_version}.b))
+ devs_c=($(python ${tools_psoc6_dir}/get-devs.py port -b ${board} -y ${tools_psoc6_dir}/${hil_name}-devs.yml --hw-ext ${board_version}.c))
+
+ dev_test=${devs[0]}
+ vfs_flash_tests
+
+ if [ "${board}" == "CY8CPROTO-062-4343W" ]; then
+ dev_test=${devs_b[0]}
+ vfs_sdcard_tests
+ fi
+
+ dev_test=${devs[0]}
+ no_ext_hw_tests
+
+ dev_test=${devs_a[0]}
+ pin_tests
+ signal_tests
+
+ dev_test=${devs_a[0]}
+ pwm_tests
+
+ if [ "${board}" == "CY8CPROTO-062-4343W" ] || [ "${board}" == "CY8CPROTO-063-BLE" ]; then
+ dev_test=${devs_a[0]}
+ else
+ if [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ dev_test=${devs_b[0]}
+ fi
+ fi
+ adc_tests
+
+ if [ "${board}" == "CY8CPROTO-062-4343W" ]; then
+ dev_test=${devs_b[0]}
+ else
+ if [ "${board}" == "CY8CPROTO-063-BLE" ] || [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ dev_test=${devs_a[0]}
+ fi
+ fi
+ i2c_tests
+
+ if [ "${board}" == "CY8CPROTO-062-4343W" ] || [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ dev_test=${devs_a[0]}
+ else
+ if [ "${board}" == "CY8CPROTO-063-BLE" ]; then
+ dev_test=${devs_b[0]}
+ fi
+ fi
+ uart_tests
+
+ if [ "${board}" == "CY8CPROTO-062-4343W" ] || [ "${board}" == "CY8CPROTO-063-BLE" ]; then
+ dev_test=${devs_a[0]}
+ dev_stub=${devs_b[0]}
+ # else
+ # if [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ # dev_test=${devs_c[0]}
+ # dev_stub=${devs_b[0]}
+ # fi
+ spi_tests
+ fi
+
+ if [ "${board}" == "CY8CPROTO-062-4343W" ] || [ "${board}" == "CY8CPROTO-063-BLE" ]; then
+ dev_test=${devs_b[0]}
+ dev_stub=${devs_a[0]}
+ else
+ if [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ dev_test=${devs_c[0]}
+ dev_stub=${devs_b[0]}
+ fi
+ fi
+ i2s_tests
+
+ # TODO: Bitstream not working for CY8CPROTO-062-4343W. Fix needed.
+ # if [ "${board}" == "CY8CPROTO-062-4343W" ] || [ "${board}" == "CY8CPROTO-063-BLE" ]; then
+ if [ "${board}" == "CY8CPROTO-063-BLE" ]; then
+ dev_test=${devs_a[0]}
+ dev_stub=${devs_b[0]}
+ bitstream_tests
+ # else
+ # if [ "${board}" == "CY8CKIT-062S2-AI" ]; then
+ # dev_test=${devs_c[0]}
+ # dev_stub=${devs_b[0]}
+ # fi
+ fi
+ # bitstream_tests
+
+ dev_test=${devs[0]}
+ wdt_tests
+
+ dev_test=${devs[0]}
+ dev_stub=${devs[1]}
+ multi_tests
+
+ echo
+ echo "##########################################"
+}
+
+case ${test_suite} in
+ "ci-tests")
+ run_ci_tests ${board} ${hil}
+ ;;
+ "vfs-flash")
+ vfs_flash_tests
+ ;;
+ "vfs-sdcard")
+ vfs_sdcard_tests
+ ;;
+ "no-hw-ext")
+ no_ext_hw_tests
+ ;;
+ "pin")
+ pin_tests
+ ;;
+ "signal")
+ signal_tests
+ ;;
+ "adc")
+ adc_tests
+ ;;
+ "pwm")
+ pwm_tests
+ ;;
+ "i2c")
+ i2c_tests
+ ;;
+ "spi")
+ spi_tests
+ ;;
+ "i2s")
+ i2s_tests
+ ;;
+ "uart")
+ uart_tests
+ ;;
+ "bitstream")
+ bitstream_tests
+ ;;
+ "watchdog")
+ wdt_tests
+ ;;
+ "multi-instance")
+ multi_tests
+ ;;
+ "help")
+ usage
+ ;;
+ *)
+ usage
+ exit 1
+ ;;
+esac
+
+exit ${exit_result}
diff --git a/tests/run-tests.py b/tests/run-tests.py
index e7ba0de565cfe..03cad0ee2f674 100755
--- a/tests/run-tests.py
+++ b/tests/run-tests.py
@@ -1052,6 +1052,7 @@ def main():
"esp32",
"minimal",
"nrf",
+ "psoc6",
"renesas-ra",
"rp2",
)
diff --git a/tools/ci.sh b/tools/ci.sh
index b0a1022c3b195..a52f14a26ace1 100755
--- a/tools/ci.sh
+++ b/tools/ci.sh
@@ -243,6 +243,65 @@ function ci_powerpc_build {
make ${MAKEOPTS} -C ports/powerpc UART=lpc_serial
}
+########################################################################################
+# ports/psoc6
+
+MPY_MTB_CI_DOCKER_VERSION=0.5.0
+
+function ci_psoc6_setup {
+ # Access to serial device
+ if [ "$1" = "--dev-access" ]; then
+ device0_flag=--device=/dev/ttyACM0
+ device1_flag=--device=/dev/ttyACM1
+ else
+ device0_flag=
+ device1_flag=
+ fi
+
+ docker pull ifxmakers/mpy-mtb-ci:${MPY_MTB_CI_DOCKER_VERSION}
+ docker run --name mtb-ci --rm --privileged -d -it \
+ ${device0_flag} \
+ ${device1_flag} \
+ -v "$(pwd)":/micropython \
+ -w /micropython/ports/psoc6 \
+ ifxmakers/mpy-mtb-ci:${MPY_MTB_CI_DOCKER_VERSION}
+ docker ps -a
+
+ # This command prevents the issue "fatal: detected dubious ownership in repository at '/micropython'""
+ docker exec mtb-ci /bin/bash -c "git config --global --add safe.directory /micropython"
+ docker exec mtb-ci /bin/bash -c "git config --global --add safe.directory /micropython/lib/micropython-lib"
+ docker exec mtb-ci /bin/bash -c "git config --global --add safe.directory /micropython/lib/mbedtls"
+ docker exec mtb-ci /bin/bash -c "git config --global --add safe.directory /micropython/lib/lwip"
+}
+
+function ci_psoc6_build {
+ board=$1
+ docker exec mtb-ci make mtb_init BOARD=${board}
+ docker exec mtb-ci make submodules
+ docker exec mtb-ci make
+}
+
+function ci_psoc6_deploy {
+ docker exec mtb-ci make program
+}
+
+function ci_psoc6_flash_multiple_devices {
+ board=$1
+ # hex file including path with respect to micropython root
+ hex_file=$2
+ devs_file=$3
+
+ docker exec mtb-ci make program_multi BOARD=${board} EXT_HEX_FILE=../../${hex_file} DEVS_FILE=../../${devs_file}
+}
+
+function ci_psoc6_run_tests {
+ docker exec mtb-ci /bin/bash -c "cd ../../tests && ./run-tests.py --target psoc6 --device /dev/ttyACM0 -d psoc6"
+}
+
+function ci_psoc6_teardown {
+ docker stop mtb-ci
+}
+
########################################################################################
# ports/qemu-arm
diff --git a/tools/psoc6/dev-setup.sh b/tools/psoc6/dev-setup.sh
new file mode 100644
index 0000000000000..3639b82351eae
--- /dev/null
+++ b/tools/psoc6/dev-setup.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Use this script to setup your development environment.
+# With the ModusToolbox installed:
+#
+# $ source dev-setup.sh && toolchain_setup [path_to_modustoolbox]
+#
+# The path to the ModusToolbox is required if installed somewhere
+# else than in the default home path (~/ModusToolbox)
+
+function set_mtb_tools_path {
+ mtb_path=$1
+ if [ "$mtb_path" = "" ]; then
+ mtb_path=~/ModusToolbox
+ fi
+
+ echo ${mtb_path}/tools_*
+}
+
+function export_path {
+ mtb_tools_path=$(set_mtb_tools_path)
+ export PATH=${mtb_tools_path}/openocd/bin:${mtb_tools_path}/library-manager:${mtb_tools_path}/fw-loader/bin/:${mtb_tools_path}/gcc/bin:$PATH
+}
+
+function install_udev_rules {
+ mtb_tools_path=$(set_mtb_tools_path)
+ ${mtb_tools_path}/openocd/udev_rules/install_rules.sh
+}
+
+function toolchain_setup {
+ mtb_path=$1
+ export_path ${mtb_path}
+ install_udev_rules
+}
+
+function git_add_ssh {
+ ssh_key=$1
+ eval $(ssh-agent -s)
+ ssh-add ${ssh_key}
+}
diff --git a/tools/psoc6/get-devs.py b/tools/psoc6/get-devs.py
new file mode 100644
index 0000000000000..93564efcffb72
--- /dev/null
+++ b/tools/psoc6/get-devs.py
@@ -0,0 +1,184 @@
+# This script support the discovery of attached KitProg3 devices
+
+import argparse, glob, os, re, subprocess, yaml
+
+
+def get_devs_from_yml(dev_yml):
+ if not os.path.exists(dev_yml):
+ raise Exception("devices .yml file does not exit")
+
+ board_sn_map = []
+ with open(dev_yml, "r") as devs_f:
+ board_sn_map = yaml.safe_load(devs_f)
+
+ return board_sn_map
+
+
+def udevadm_get_kitprog3_attached_devs():
+ def get_ttyACM_dev_list():
+ return glob.glob(os.path.join("/dev", "ttyACM*"), recursive=False)
+
+ def get_udevadm_port_attrs_output(dev):
+ dev_param = "--name=" + str(dev)
+ cmd_line_args = ["udevadm", "info", dev_param, "--attribute-walk"]
+ udevadm_output_lines = []
+ try:
+ udevadm_proc = subprocess.Popen(cmd_line_args, stdout=subprocess.PIPE)
+ while True:
+ line = udevadm_proc.stdout.readline()
+ udevadm_output_lines.append(line)
+ if not line:
+ break
+ except:
+ raise Exception("udevadm error")
+
+ return udevadm_output_lines
+
+ def is_kitprog_device(udevadm_output_lines):
+ def is_device_attr_found(line, pattern):
+ attr = re.search(pattern, str(line))
+ if attr is not None:
+ return True
+
+ return False
+
+ # It is a kitprog probe is these matches
+ # are found in the device attributes
+ required_attr_match = [
+ 'ATTRS{interface}=="KitProg\d.*"',
+ 'ATTRS{product}==".*KitProg\d.*"',
+ ]
+
+ attr_found_count = 0
+
+ for line in udevadm_output_lines:
+ for req_match in required_attr_match:
+ if is_device_attr_found(line, req_match):
+ attr_found_count += 1
+
+ if attr_found_count == len(required_attr_match):
+ return True
+
+ return False
+
+ def get_kitprog_serial_number(udevadm_output_lines):
+ for line in udevadm_output_lines:
+ attr = re.search('ATTRS{serial}=="[a-zA-Z0-9]*"', str(line))
+ if attr is not None:
+ sn = attr.group()[len("ATTRS{serial}==") :]
+ sn = sn.strip('"')
+ return sn
+
+ return ""
+
+ kitprog_devs = []
+ dev_list = get_ttyACM_dev_list()
+
+ if dev_list is not []:
+ for dev in dev_list:
+ udevadm_output_lines = get_udevadm_port_attrs_output(dev)
+ if is_kitprog_device(udevadm_output_lines):
+ sn = get_kitprog_serial_number(udevadm_output_lines)
+ # new kp device
+ kp_dev = {}
+ kp_dev["port"] = dev
+ kp_dev["sn"] = sn
+
+ kitprog_devs.append(kp_dev)
+
+ return kitprog_devs
+
+
+def get_devices(search_param, board=None, devs_yml=None, hw_ext=None):
+ dev_list = []
+ port_sn_map = udevadm_get_kitprog3_attached_devs()
+
+ if board is not None and devs_yml is not None:
+ board_sn_map_list = get_devs_from_yml(devs_yml)
+
+ for board_sn_map_item in board_sn_map_list:
+ if board == board_sn_map_item["board_type"]:
+ for dev in port_sn_map:
+ for mapped_board_item in board_sn_map_item["board_list"]:
+ if dev["sn"] == mapped_board_item["sn"]:
+ if hw_ext is None:
+ dev_list.append(dev[search_param])
+ break
+ if hw_ext is not None:
+ if "hw_ext" in mapped_board_item.keys():
+ if hw_ext == mapped_board_item["hw_ext"]:
+ dev_list.append(dev[search_param])
+ break
+ else:
+ for dev in port_sn_map:
+ dev_list.append(dev[search_param])
+
+ return dev_list
+
+
+def get_devices_serial_num(board=None, devs_yml=None, hw_ext=None):
+ return get_devices("sn", board, devs_yml, hw_ext)
+
+
+def get_devices_port(board=None, devs_yml=None, hw_ext=None):
+ return get_devices("port", board, devs_yml, hw_ext)
+
+
+def parser():
+ def main_parser_func(args):
+ parser.print_help()
+
+ def parse_validate_opt_arg_mutual_required(args):
+ if args.devs_yml and args.board is None:
+ parser.error("--devs-yml requires --board.")
+ if args.board and args.devs_yml is None:
+ parser.error("--board requires --dev-yml.")
+ if args.hw_ext is not None and (args.board is None or args.devs_yml is None):
+ parser.error("--hw_ext requires --board and --dev-yml.")
+
+ def parser_get_devices_serial_num(args):
+ parse_validate_opt_arg_mutual_required(args)
+ devs_serial = get_devices_serial_num(args.board, args.devs_yml, args.hw_ext)
+ print(*devs_serial)
+
+ def parser_get_devices_port(args):
+ parse_validate_opt_arg_mutual_required(args)
+ devs_port = get_devices_port(args.board, args.devs_yml, args.hw_ext)
+ print(*devs_port)
+
+ parser = argparse.ArgumentParser(description="Get kitprog3 device utility")
+
+ subparser = parser.add_subparsers()
+ parser.set_defaults(func=main_parser_func)
+
+ # Get devices serial numbers
+ parser_sn = subparser.add_parser(
+ "serial-number", description="Get kitprog3 devices serial number list"
+ )
+ parser_sn.add_argument("-b", "--board", type=str, help="Board name")
+ parser_sn.add_argument(
+ "-y", "--devs-yml", type=str, help="Device list yml with board - serial number map"
+ )
+ parser_sn.add_argument(
+ "--hw-ext", type=str, default=None, help="Required external hardware configuration"
+ )
+ parser_sn.set_defaults(func=parser_get_devices_serial_num)
+
+ # Get devices port
+ parser_port = subparser.add_parser("port", description="Get kitprog3 devices port list")
+ parser_port.add_argument("-b", "--board", type=str, help="Board name")
+ parser_port.add_argument(
+ "-y", "--devs-yml", type=str, help="Device list yml with board - serial number map"
+ )
+ parser_port.add_argument(
+ "--hw-ext", type=str, default=None, help="Required external hardware configuration"
+ )
+ parser_port.set_defaults(func=parser_get_devices_port)
+
+ # Parser call
+ args = parser.parse_args()
+ args.func(args)
+
+
+if __name__ == "__main__":
+ parser()
diff --git a/tools/psoc6/ifx-mpy-hil-devs.yml b/tools/psoc6/ifx-mpy-hil-devs.yml
new file mode 100644
index 0000000000000..be1f701d9aa12
--- /dev/null
+++ b/tools/psoc6/ifx-mpy-hil-devs.yml
@@ -0,0 +1,20 @@
+- board_type: CY8CPROTO-062-4343W
+ board_list:
+ - sn: 072002F302098400
+ hw_ext: 0.5.0.a
+ - sn: 1C14031D03201400
+ hw_ext: 0.5.0.b
+- board_type: CY8CPROTO-063-BLE
+ board_list:
+ - sn: 100D0F1400052400
+ hw_ext: 0.5.0.b
+ - sn: 03180F1400052400
+ hw_ext: 0.5.0.a
+- board_type: CY8CKIT-062S2-AI
+ board_list:
+ - sn: 1225085A012D2400
+ hw_ext: 0.1.0.a
+ - sn: 1A0A095A012D2400
+ hw_ext: 0.1.0.b
+ - sn: 132119A1002E0400
+ hw_ext: 0.1.0.c
diff --git a/tools/psoc6/mpy-psoc6.py b/tools/psoc6/mpy-psoc6.py
new file mode 100644
index 0000000000000..0773e74ea2f2a
--- /dev/null
+++ b/tools/psoc6/mpy-psoc6.py
@@ -0,0 +1,668 @@
+import argparse, os, sys, shlex, shutil, subprocess, time, requests, tarfile, zipfile
+
+boards = [
+ {"name": "CY8CPROTO-062-4343W", "ocd_cfg_file": "psoc6_2m.cfg"},
+ {"name": "CY8CPROTO-063-BLE", "ocd_cfg_file": "psoc6.cfg"},
+ {"name": "CY8CKIT-062S2-AI", "ocd_cfg_file": "psoc6_2m.cfg"},
+]
+
+opsys = ""
+version = "0.4.0"
+
+
+# Decorator to flush every print
+def flush_print(func):
+ printer = func
+
+ def wrapped(*args):
+ printer(*args, flush=True)
+
+ return wrapped
+
+
+print_f = flush_print(print)
+
+
+def colour_str_success(msg):
+ green_str_start = "\x1b[1;32;40m"
+ str_color_end = "\x1b[0m"
+ return green_str_start + msg + str_color_end
+
+
+def colour_str_error(msg):
+ red_str_start = "\x1b[1;31;40m"
+ str_color_end = "\x1b[0m"
+ return red_str_start + msg + str_color_end
+
+
+def colour_str_highlight(msg):
+ purple_str_start = "\x1b[1;35;40m"
+ str_color_end = "\x1b[0m"
+ return purple_str_start + msg + str_color_end
+
+
+def colour_str_warn(msg):
+ yellow_str_start = "\x1b[1;33;40m"
+ str_color_end = "\x1b[0m"
+ return yellow_str_start + msg + str_color_end
+
+
+def set_environment():
+ global opsys
+ if sys.platform == "linux" or sys.platform == "linux2":
+ opsys = "linux"
+ elif sys.platform == "win32" or sys.platform == "cygwin":
+ opsys = "win"
+ os.system("color") # Enable colouring in cmd and powershell
+ elif sys.platform == "darwin":
+ opsys = "mac"
+
+
+def mpy_get_fw_hex_file_name(file_name, board):
+ file_extension = ".hex"
+ return str(file_name) + "_" + str(board) + file_extension
+
+
+def mpy_firmware_deploy(file_name, board, serial_adapter_sn=None, silent=False):
+ if not silent:
+ print_f(f"Deploying firmware {file_name} ...")
+
+ hex_file = mpy_get_fw_hex_file_name(file_name, board)
+ openocd_program(board, hex_file, serial_adapter_sn)
+ if not silent:
+ print_f(colour_str_success(f"Firmware {file_name} deployed successfully"))
+
+
+def mpy_firmware_download(file_name, board, version, silent=False):
+ def mpy_firmware_clean(file_name, board):
+ file_name_for_board = mpy_get_fw_hex_file_name(file_name, board)
+
+ if os.path.exists(file_name_for_board):
+ os.remove(file_name_for_board)
+
+ if not silent:
+ print_f(
+ "Downloading "
+ + str(file_name)
+ + " "
+ + str(version)
+ + " for "
+ + str(board)
+ + " board..."
+ )
+
+ if version == "latest":
+ sub_url = "latest/download"
+ else:
+ sub_url = "download/" + str(version)
+
+ file_name_for_board = mpy_get_fw_hex_file_name(file_name, board)
+ file_url = (
+ "https://github.com/infineon/micropython/releases/" + sub_url + "/" + file_name_for_board
+ )
+
+ # Clean if existing from previous run
+ # It is not sure if it is the same version
+ mpy_firmware_clean(file_name, board)
+
+ res = requests.get(file_url)
+ open(file_name_for_board, "wb").write(res.content)
+
+
+def fwloader_download_install():
+ file_extension = ".zip"
+ fwloader_compressed = "fwloader" + file_extension
+
+ def is_fwloader_already_installed():
+ if opsys == "linux":
+ fwloader = "fw-loader"
+ elif opsys == "win":
+ fwloader = "fw-loader.exe"
+ elif opsys == "mac":
+ fwloader = "fw-loader"
+
+ if os.path.exists(os.path.join("fw-loader", "bin", fwloader)):
+ return True
+
+ return False
+
+ def get_fwloader_file_url_name():
+ if opsys == "linux":
+ file_os_suffix = "linux"
+ elif opsys == "win":
+ file_os_suffix = "windows"
+ elif opsys == "mac":
+ file_os_suffix = "macos"
+
+ version = "3.5.0.2114"
+ package_version = "2.50.0.1383"
+ file_name = (
+ "fw-loader-"
+ + version
+ + "-kitprog3-package-"
+ + package_version
+ + "-"
+ + file_os_suffix
+ + file_extension
+ )
+
+ base_url = "https://github.com/Infineon/Firmware-loader/releases/download/3.5.0/"
+ file_url = base_url + file_name
+
+ return file_url, file_name
+
+ def clean_fwloader(file_name):
+ if os.path.exists(file_name):
+ os.remove(file_name)
+
+ def download_fwloader(file_url, file_name):
+ res = requests.get(file_url)
+ open(file_name, "wb").write(res.content)
+ os.replace(file_name, fwloader_compressed)
+
+ def extract_fwloader():
+ compress_file = zipfile.ZipFile(fwloader_compressed)
+ compress_file.extractall(".")
+ compress_file.close()
+
+ def fwloader_setup():
+ # Add fw-loader to path
+ os.environ["PATH"] += os.pathsep + os.path.join("fw-loader", "bin")
+
+ if opsys == "linux":
+ # Install udev rules
+ sh_args = ["sh", "fw-loader/udev_rules/install_rules.sh"]
+ try:
+ sh_proc = subprocess.Popen(sh_args)
+ sh_proc.wait()
+ except:
+ sys.exit(colour_str_error("bash error"))
+
+ if opsys == "linux" or opsys == "mac":
+ os.chmod(os.path.join("fw-loader", "bin", "fw-loader"), 0o755)
+
+ if not is_fwloader_already_installed():
+ print_f("Downloading fw-loader...")
+ file_url, file_name = get_fwloader_file_url_name()
+ clean_fwloader(file_name)
+ download_fwloader(file_url, file_name)
+ print_f("Extracting fw-loader...")
+ extract_fwloader()
+ else:
+ print_f("fw-loader installation skipped. Already installed")
+
+ fwloader_setup()
+
+
+def fwloader_update_kitprog():
+ def parse_output_for_error(fwloader_stdout):
+ fwloader_out_lines = fwloader_stdout.decode().split("\n")
+ for line in fwloader_out_lines:
+ if "Error" in line:
+ print_f("fw-loader output: \n" + fwloader_stdout.decode())
+
+ print_f("Updating kitprog3 firmware...")
+ fwloader_cmd = "fw-loader --update-kp3 all"
+ fwloader_args = shlex.split(fwloader_cmd)
+
+ fwl_proc = subprocess.Popen(fwloader_args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+ try:
+ out, err = fwl_proc.communicate(timeout=100)
+ except:
+ fwl_proc.kill()
+ sys.exit(colour_str_error("fwloader error"))
+
+ if err:
+ sys.exit(colour_str_error(err.decode()))
+
+ parse_output_for_error(out)
+
+ print_f(colour_str_success("Debugger kitprog3 firmware updated successfully"))
+
+
+def fwloader_remove():
+ file_extension = ".zip"
+ fwloader_compressed = "fwloader" + file_extension
+ if os.path.exists(fwloader_compressed):
+ os.remove(fwloader_compressed)
+ if os.path.exists("fw-loader"):
+ shutil.rmtree("fw-loader")
+ if os.path.exists("kp-firmware"):
+ shutil.rmtree("kp-firmware")
+
+
+def openocd_download_install():
+ if opsys == "linux":
+ file_os_suffix = "linux"
+ file_extension = ".tar.gz"
+ openocd_exe = "openocd"
+ elif opsys == "win":
+ file_os_suffix = "windows"
+ file_extension = ".zip"
+ openocd_exe = "openocd.exe"
+ elif opsys == "mac":
+ file_os_suffix = "macos"
+ file_extension = ".zip"
+ openocd_exe = "openocd"
+
+ openocd_compressed = "openocd" + file_extension
+
+ def is_openocd_already_installed():
+ if os.path.exists(os.path.join("openocd", "bin", openocd_exe)):
+ return True
+
+ return False
+
+ def get_openocd_file_url_name():
+ filename_base = "openocd-5.1.0.3099-"
+ url_base = "https://github.com/Infineon/openocd/releases/download/release-v5.1.0/"
+
+ file_name = filename_base + file_os_suffix + file_extension
+ file_url = url_base + file_name
+
+ return file_url, file_name
+
+ def clean_openocd(file_name):
+ if os.path.exists(file_name):
+ os.remove(file_name)
+
+ def download_openocd(file_url, file_name):
+ res = requests.get(file_url)
+ open(file_name, "wb").write(res.content)
+ os.replace(file_name, openocd_compressed)
+
+ def extract_openocd():
+ if opsys == "linux":
+ compress_file = tarfile.open(openocd_compressed)
+ compress_file.extractall(".")
+ compress_file.close()
+ elif opsys == "win" or opsys == "mac":
+ compress_file = zipfile.ZipFile(openocd_compressed)
+ compress_file.extractall(".")
+ compress_file.close()
+
+ def openocd_setup():
+ # Add openocd to path
+ os.environ["PATH"] += os.pathsep + os.path.join("openocd", "bin")
+
+ if opsys == "linux":
+ # Install udev rules
+ sh_args = ["sh", "openocd/udev_rules/install_rules.sh"]
+ try:
+ sh_proc = subprocess.Popen(sh_args)
+ sh_proc.wait()
+ except:
+ sys.exit(colour_str_error("bash error"))
+
+ if opsys == "mac":
+ os.chmod(os.path.join("openocd", "bin", "openocd"), 0o755)
+
+ if not is_openocd_already_installed():
+ print_f("Downloading openocd...")
+ file_url, file_name = get_openocd_file_url_name()
+ clean_openocd(file_name)
+ download_openocd(file_url, file_name)
+ print_f("Extracting openocd...")
+ extract_openocd()
+ else:
+ print_f("openocd already available. Installation skipped")
+
+ openocd_setup()
+
+
+def openocd_board_conf_download(board):
+ print_f("Downloading openocd " + str(board) + " configuration...")
+
+ # Create and move to board dir in openocd folder
+ parent_dir = os.path.abspath(os.curdir)
+ os.chdir("openocd")
+ if not os.path.exists("board"):
+ os.mkdir("board")
+ os.chdir("board")
+
+ # Download config file
+ if board == "CY8CPROTO-062-4343W" or board == "CY8CKIT-062S2-AI":
+ file_name = "qspi_config_" + str(board) + ".cfg"
+ file_url = "https://github.com/infineon/micropython/releases/download/v0.3.0/" + file_name
+
+ # Clean file if exists from previous run
+ if os.path.exists(file_name):
+ os.remove(file_name)
+
+ res = requests.get(file_url)
+ open(file_name, "wb").write(res.content)
+
+ # Rename config file
+ os.replace(file_name, "qspi_config.cfg")
+
+ # Move to parent dir
+ os.chdir(parent_dir)
+
+
+def openocd_program(board, hex_file, serial_adapter_sn=None):
+ if opsys == "linux" or opsys == "mac":
+ openocd = "openocd/bin/openocd"
+ elif opsys == "win":
+ openocd = "openocd.exe"
+
+ for brd in boards:
+ if board == brd["name"]:
+ ocd_cfg_file = brd["ocd_cfg_file"]
+
+ serial_adapter_opt = ""
+ if serial_adapter_sn is not None:
+ serial_adapter_opt = "adapter serial " + str(serial_adapter_sn)
+
+ openocd_cmd = (
+ openocd
+ + ' -s openocd/scripts -s openocd/board -c "source [find interface/kitprog3.cfg];'
+ + str(serial_adapter_opt)
+ + " ; source [find target/"
+ + str(ocd_cfg_file)
+ + "]; psoc6 allow_efuse_program off; psoc6 sflash_restrictions 1; program "
+ + str(hex_file)
+ + ' verify reset exit;"'
+ )
+ openocd_args = shlex.split(openocd_cmd)
+
+ ocd_proc = subprocess.Popen(openocd_args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+ try:
+ out, err = ocd_proc.communicate(timeout=30)
+ except:
+ ocd_proc.kill()
+ sys.exit(
+ colour_str_error(
+ 'openocd error.\nTry to fix this issue by updating the device debugger firmware\n \
+ \rusing the "--kitprog-fw-update" option during "device-setup".\n'
+ )
+ )
+ if err:
+ sys.exit(colour_str_error(err.decode() + "Are you sure the board is connected?"))
+
+
+def openocd_remove():
+ if opsys == "linux":
+ file_extension = ".tar.gz"
+ elif opsys == "win" or opsys == "mac":
+ file_extension = ".zip"
+
+ openocd_compressed = "openocd" + file_extension
+ if os.path.exists(openocd_compressed):
+ os.remove(openocd_compressed)
+
+ if os.path.exists("openocd"):
+ shutil.rmtree("openocd")
+
+
+def validate_board_name(board_name):
+ board_supported = False
+ for brd in boards:
+ if board_name == brd["name"]:
+ board_supported = True
+ break
+
+ if not board_supported:
+ sys.exit(colour_str_error("error: board is not supported"))
+
+
+def select_board():
+ def validate_user_input(user_input):
+ def invalid_exit():
+ sys.exit(colour_str_error("error: board ID is not valid"))
+
+ try:
+ board_index = int(user_input)
+ except:
+ invalid_exit()
+
+ max_board_index = len(boards)
+ if board_index < 0 or board_index > max_board_index:
+ invalid_exit()
+
+ return board_index
+
+ print_f("")
+ print_f(" Supported MicroPython PSoC6 boards ")
+ print_f("+---------+-----------------------------------+")
+ print_f("| ID | Board |")
+ print_f("+---------+-----------------------------------+")
+ print_f("| 0 | CY8CPROTO-062-4343W |")
+ print_f("+---------+-----------------------------------+")
+ print_f("| 1 | CY8CPROTO-063-BLE |")
+ print_f("+---------+-----------------------------------+")
+ print_f("| 2 | CY8CKIT-062S2-AI |")
+ print_f("+---------+-----------------------------------+")
+ print_f("")
+ print_f("")
+
+ board_index = validate_user_input(
+ input(colour_str_highlight("Please type the desired board ID: "))
+ )
+ board = boards[board_index]["name"]
+
+ return board
+
+
+def wait_and_request_board_connect():
+ input(
+ colour_str_highlight(
+ "Please CONNECT THE BOARD and PRESS ENTER to start the firmware deployment\n"
+ )
+ )
+
+
+def device_setup(board, version, serial_adapter_sn=None, kitprog_update_dbg_fw=False, quiet=False):
+ if board is None:
+ board = select_board()
+ else:
+ validate_board_name(board)
+
+ print_f("MicroPython PSoC6 Board :: ", board)
+
+ if version is None:
+ version = "latest"
+
+ print_f("MicroPython PSoC6 Version :: ", version)
+
+ if not quiet:
+ wait_and_request_board_connect()
+
+ if kitprog_update_dbg_fw:
+
+ def wait_for_dev_restart():
+ print("Waiting for device restart ", end="", flush=True)
+ for j in range(3):
+ for i in range(3):
+ print(".", end="", flush=True)
+ time.sleep(1)
+ sys.stdout.write("\b\b\b\b")
+ sys.stdout.write(" ")
+ sys.stdout.write("\b\b\b")
+ sys.stdout.flush()
+
+ print_f("\nDevice restarted")
+
+ fwloader_download_install()
+ fwloader_update_kitprog()
+ wait_for_dev_restart()
+
+ openocd_download_install()
+ openocd_board_conf_download(board)
+
+ mpy_firmware_download("hello-world", board, "v0.3.0", True)
+ mpy_firmware_download("mpy-psoc6", board, version)
+
+ mpy_firmware_deploy("hello-world", board, serial_adapter_sn, True)
+ mpy_firmware_deploy("mpy-psoc6", board, serial_adapter_sn)
+
+ print_f(colour_str_success("Device setup completed :)"))
+
+
+def device_erase(board, serial_adapter_sn=None, quiet=False):
+ if (board != "CY8CPROTO-062-4343W") and (board != "CY8CKIT-062S2-AI"):
+ sys.exit(colour_str_error("error: board is not supported"))
+
+ if not quiet:
+ wait_and_request_board_connect()
+
+ openocd_download_install()
+ openocd_board_conf_download(board)
+
+ mpy_firmware_download("device-erase", board, "v0.10.0")
+
+ mpy_firmware_deploy("device-erase", board, serial_adapter_sn)
+
+ print_f(
+ colour_str_warn(
+ "Attention!\nThe on-board user LED will start blinking when the erasing is completed."
+ )
+ )
+ print_f(
+ colour_str_warn("This can take up to a few minutes if the device memory is very full.")
+ )
+
+
+def firmware_deploy(board, hex_file, serial_adapter_sn=None):
+ openocd_download_install()
+ openocd_board_conf_download(board)
+ print(f"Deploying hex file {hex_file} ...")
+ openocd_program(board, hex_file, serial_adapter_sn)
+ print(colour_str_success(f"Firmware {hex_file} deployed successfully"))
+
+
+def clean_tool_downloads():
+ fwloader_remove()
+ openocd_remove()
+
+
+def parser():
+ def main_parser_func(args):
+ parser.print_help()
+
+ def parser_device_setup(args):
+ device_setup(args.board, args.version, args.serial_num, args.kitprog_fw_update, args.q)
+
+ def parser_device_erase(args):
+ device_erase(args.board, args.serial_num, args.q)
+
+ def parser_firmware_deploy(args):
+ firmware_deploy(args.board, args.hexfile, args.serial_num)
+
+ # Main parser
+ class ver_action(argparse.Action):
+ def __init__(self, option_strings, dest, **kwargs):
+ return super().__init__(
+ option_strings, dest, nargs=0, default=argparse.SUPPRESS, **kwargs
+ )
+
+ def __call__(self, parser, namespace, values, option_string, **kwargs):
+ print_f("mpy-psoc6 version: " + version)
+ parser.exit()
+
+ main_parser_desc = """
+ Micropython PSoC6 utility script
+
+ Available commands:
+
+ device-setup Setup of MicroPython PSoC6 device
+ device-erase Erase the external memory of the PSoC6 device
+ firmware-deploy Firmware deployment on PSoC6 device (user provided binary file)
+
+ mpy-psoc6.py --help for more information about each specific command.
+ """
+ parser = argparse.ArgumentParser(
+ formatter_class=argparse.RawTextHelpFormatter, description=main_parser_desc
+ )
+ parser.add_argument("-v", "--version", action=ver_action, help="mpy-psoc6 version")
+ subparser = parser.add_subparsers()
+ parser.set_defaults(func=main_parser_func)
+
+ # device setup
+ parser_ds = subparser.add_parser(
+ "device-setup",
+ description="Setup of MicroPython PSoC6 device. \
+ Use this command to install the deployment tools \
+ and MicroPython firmware binary, and deploy the \
+ firmware on the PSoC6 device.",
+ )
+ parser_ds.add_argument(
+ "-b", "--board", default=None, type=str, help="PSoC6 prototyping kit name"
+ )
+ parser_ds.add_argument(
+ "-n",
+ "--serial-num",
+ default=None,
+ type=str,
+ help="Serial number of the board serial adapter",
+ )
+ parser_ds.add_argument(
+ "-v", "--version", default=None, type=str, help="MicroPython PSoC6 firmware version"
+ )
+ parser_ds.add_argument(
+ "-q", action="store_true", help="Quiet. Do not prompt any user confirmation request"
+ )
+ parser_ds.add_argument(
+ "--kitprog-fw-update",
+ action="store_true",
+ help="Updates the on-board Kitprog3 debugger firmware of the PSoC6 device",
+ )
+ parser_ds.set_defaults(func=parser_device_setup)
+
+ # device erase
+ parser_de = subparser.add_parser(
+ "device-erase",
+ description="Erase the external memory of the device. \
+ Use this command to erase the external memory if available \
+ for the selected board. \
+ Running device-setup after this command \
+ is required to re-enable MicroPython.",
+ )
+ parser_de.add_argument(
+ "-b", "--board", default=None, type=str, required=True, help="PSoC6 prototyping kit name"
+ )
+ parser_de.add_argument(
+ "-n",
+ "--serial-num",
+ default=None,
+ type=str,
+ help="Serial number of the board serial adapter",
+ )
+ parser_de.add_argument(
+ "-q", action="store_true", help="Quiet. Do not prompt any user confirmation request"
+ )
+ parser_de.set_defaults(func=parser_device_erase)
+
+ # firmware deploy
+ parser_fd = subparser.add_parser(
+ "firmware-deploy",
+ description="Firmware deployment on MicroPython device. \
+ Use this command to deploy an existing .hex file \
+ on a PSoC6 board.",
+ )
+ parser_fd.add_argument(
+ "-b", "--board", default=None, type=str, required=True, help="PSoC6 prototyping kit name"
+ )
+ parser_fd.add_argument(
+ "-n",
+ "--serial-num",
+ default=None,
+ type=str,
+ help="Serial number of the board serial adapter",
+ )
+ parser_fd.add_argument(
+ "-f", "--hexfile", type=str, required=True, help="MicroPython PSoC6 firmware .hex file"
+ )
+ parser_fd.set_defaults(func=parser_firmware_deploy)
+
+ # Parser call
+ args = parser.parse_args()
+ args.func(args)
+
+
+if __name__ == "__main__":
+ try:
+ set_environment()
+ parser()
+ except KeyboardInterrupt:
+ print_f(colour_str_error("error: keyboard interrupt"))
+ clean_tool_downloads()
diff --git a/tools/psoc6/wsl-usb.py b/tools/psoc6/wsl-usb.py
new file mode 100644
index 0000000000000..e145e02653f39
--- /dev/null
+++ b/tools/psoc6/wsl-usb.py
@@ -0,0 +1,155 @@
+"""
+Use this script to avoid attaching manually usb devices
+to the WSL Ubuntu instance.
+1. Copy this script somewhere in the Windows filesystem
+
+curl -s -L https://raw.githubusercontent.com/Infineon/micropython/ports-psoc6-main/tools/psoc6/wsl-usb.py > wsl-usb.py
+
+2. Use the Power Shell with admin rights
+3. Use -h, --help flags to find out the available commands and options.
+"""
+import argparse, subprocess
+
+version = "1.0.0"
+
+
+def get_kitprog_list():
+ usbipd_list_cmd = ["usbipd.exe", "list"]
+
+ try:
+ usbipd_proc = subprocess.Popen(usbipd_list_cmd, stdout=subprocess.PIPE)
+ output = usbipd_proc.communicate()[0]
+ except:
+ raise Exception("usbipd error")
+
+ kitprog3_list = []
+ kitprog3_descr = "KitProg3 CMSIS-DAP, KitProg3 bridge, KitProg3 USB-UART (C..."
+ lines = output.decode("utf-8").split("\r\n")
+ for l in lines:
+ # Create (busid, vid:pid, device state) tuple from line
+ split_line = l.split(" ")
+ strip_line = [i for i in split_line if i != ""]
+
+ # Entries matching KitProg3 probe description
+ if len(strip_line) == 4:
+ if strip_line[2] == kitprog3_descr:
+ kitprog3_list.append((strip_line[0], strip_line[3]))
+
+ return kitprog3_list
+
+
+def get_ppp_adapter_ip():
+ ipconfig_cmd = ["ipconfig.exe", "-all"]
+
+ try:
+ ipconfig_proc = subprocess.Popen(ipconfig_cmd, stdout=subprocess.PIPE)
+ output = ipconfig_proc.communicate()[0]
+ except:
+ raise Exception("ipconfig error")
+
+ lines = output.decode("utf-8").split("\r\n")
+ strip_lines = [i for i in lines if i != ""]
+ ppp_entry = strip_lines.index("PPP adapter iconnect.infineon.com - iconnect.infineon.com:")
+ entry_from_ppp_adapter = strip_lines[ppp_entry:]
+ ipv4 = next(ip_entry for ip_entry in entry_from_ppp_adapter if "IPv4 Address" in ip_entry)
+
+ ipv4.strip()
+ ipv4 = ipv4.strip("IPv4 Address. . . . . . . . . . . : ")
+ ipv4 = ipv4.removesuffix("(Preferred)")
+
+ return ipv4
+
+
+def attach():
+ kp3_list = get_kitprog_list()
+ ppp_ip = get_ppp_adapter_ip()
+
+ usbipd_cmd = ["usbipd.exe", "bind"]
+ wsl_usbip_cmd = ["wsl", "sudo", "usbip", "attach"]
+
+ for d in kp3_list:
+ if d[1] != "Attached":
+ usbipd_bind_cmd = usbipd_cmd.copy()
+ usbipd_bind_cmd.append("--busid=" + str(d[0]))
+
+ try:
+ usbipd_proc = subprocess.Popen(usbipd_bind_cmd)
+ usbipd_proc.wait()
+ except:
+ raise Exception("usbipd error")
+
+ wsl_usbip_attach_cmd = wsl_usbip_cmd.copy()
+ wsl_usbip_attach_cmd.append("--remote=" + str(ppp_ip))
+ wsl_usbip_attach_cmd.append("--busid=" + str(d[0]))
+
+ try:
+ usbipd_proc = subprocess.Popen(wsl_usbip_attach_cmd)
+ usbipd_proc.wait()
+ except:
+ raise Exception("wsl usbip error")
+
+
+def detach():
+ kp3_list = get_kitprog_list()
+
+ usbipd_cmd = ["usbipd.exe", "unbind"]
+
+ # Unbind in windows is sufficient
+ for d in kp3_list:
+ usbipd_unbind_cmd = usbipd_cmd.copy()
+ usbipd_unbind_cmd.append("--busid=" + str(d[0]))
+
+ try:
+ usbipd_proc = subprocess.Popen(usbipd_unbind_cmd)
+ usbipd_proc.wait()
+ except:
+ raise Exception("usbipd error")
+
+
+def parser():
+ def main_parser_func(args):
+ parser.print_help()
+
+ def parser_attach_func(args):
+ attach()
+
+ def parser_detach_func(args):
+ detach()
+
+ def parser_list_func(args):
+ print(get_kitprog_list())
+
+ class ver_action(argparse.Action):
+ def __init__(self, option_strings, dest, **kwargs):
+ return super().__init__(
+ option_strings, dest, nargs=0, default=argparse.SUPPRESS, **kwargs
+ )
+
+ def __call__(self, parser, namespace, values, option_string, **kwargs):
+ print("wsl-usb version: " + version)
+ parser.exit()
+
+ parser = argparse.ArgumentParser(description="wsl-usb")
+ parser.add_argument("-v", "--version", action=ver_action, help="wsl-usb version")
+ subparser = parser.add_subparsers()
+ parser.set_defaults(func=main_parser_func)
+
+ # Attach
+ parser_attach = subparser.add_parser("attach", description="Attach kitprog3 devices")
+ parser_attach.set_defaults(func=parser_attach_func)
+
+ # detach
+ parser_detach = subparser.add_parser("detach", description="Detach kitprog3 devices")
+ parser_detach.set_defaults(func=parser_detach_func)
+
+ # List
+ parser_list = subparser.add_parser("list", description="List kitprog3 devices with status")
+ parser_list.set_defaults(func=parser_list_func)
+
+ # Parser call
+ args = parser.parse_args()
+ args.func(args)
+
+
+if __name__ == "__main__":
+ parser()
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy