diff options
Diffstat (limited to 'sys')
220 files changed, 26683 insertions, 9994 deletions
diff --git a/sys/amd64/amd64/pmap.c b/sys/amd64/amd64/pmap.c index 8dcf232..e1d373c 100644 --- a/sys/amd64/amd64/pmap.c +++ b/sys/amd64/amd64/pmap.c @@ -4400,6 +4400,7 @@ pmap_remove_pages(pmap_t pmap) int64_t bit; uint64_t inuse, bitmask; int allfree, field, freed, idx; + vm_paddr_t pa; if (pmap != PCPU_GET(curpmap)) { printf("warning: pmap_remove_pages called with non-current pmap\n"); @@ -4429,7 +4430,7 @@ pmap_remove_pages(pmap_t pmap) pte = (pt_entry_t *)PHYS_TO_DMAP(tpte & PG_FRAME); pte = &pte[pmap_pte_index(pv->pv_va)]; - tpte = *pte & ~PG_PTE_PAT; + tpte = *pte; } if ((tpte & PG_V) == 0) { panic("bad pte va %lx pte %lx", @@ -4444,8 +4445,13 @@ pmap_remove_pages(pmap_t pmap) continue; } - m = PHYS_TO_VM_PAGE(tpte & PG_FRAME); - KASSERT(m->phys_addr == (tpte & PG_FRAME), + if (tpte & PG_PS) + pa = tpte & PG_PS_FRAME; + else + pa = tpte & PG_FRAME; + + m = PHYS_TO_VM_PAGE(pa); + KASSERT(m->phys_addr == pa, ("vm_page_t %p phys_addr mismatch %016jx %016jx", m, (uintmax_t)m->phys_addr, (uintmax_t)tpte)); diff --git a/sys/amd64/include/counter.h b/sys/amd64/include/counter.h index b37a4b8..b571e70 100644 --- a/sys/amd64/include/counter.h +++ b/sys/amd64/include/counter.h @@ -36,6 +36,44 @@ extern struct pcpu __pcpu[1]; #define counter_enter() do {} while (0) #define counter_exit() do {} while (0) +#ifdef IN_SUBR_COUNTER_C +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, i) counter_u64_add(c, i) static inline void diff --git a/sys/amd64/vmm/intel/ept.c b/sys/amd64/vmm/intel/ept.c index 4f91601..1ff1580 100644 --- a/sys/amd64/vmm/intel/ept.c +++ b/sys/amd64/vmm/intel/ept.c @@ -77,6 +77,11 @@ MALLOC_DECLARE(M_VMX); static uint64_t page_sizes_mask; +/* + * Set this to 1 to have the EPT tables respect the guest PAT settings + */ +static int ept_pat_passthru; + int ept_init(void) { @@ -226,10 +231,13 @@ ept_create_mapping(uint64_t *ptp, vm_paddr_t gpa, vm_paddr_t hpa, size_t length, ptp[ptpindex] |= EPT_PG_EX; /* - * XXX should we enforce this memory type by setting the - * ignore PAT bit to 1. + * By default the PAT type is ignored - this appears to + * be how other hypervisors handle EPT. Allow this to be + * overridden. */ ptp[ptpindex] |= EPT_PG_MEMORY_TYPE(attr); + if (!ept_pat_passthru) + ptp[ptpindex] |= EPT_PG_IGNORE_PAT; if (nlevels > 0) ptp[ptpindex] |= EPT_PG_SUPERPAGE; diff --git a/sys/amd64/vmm/vmm_instruction_emul.c b/sys/amd64/vmm/vmm_instruction_emul.c index 8328144..4e63649 100644 --- a/sys/amd64/vmm/vmm_instruction_emul.c +++ b/sys/amd64/vmm/vmm_instruction_emul.c @@ -780,6 +780,19 @@ decode_immediate(struct vie *vie) } /* + * Verify that all the bytes in the instruction buffer were consumed. + */ +static int +verify_inst_length(struct vie *vie) +{ + + if (vie->num_processed == vie->num_valid) + return (0); + else + return (-1); +} + +/* * Verify that the 'guest linear address' provided as collateral of the nested * page table fault matches with our instruction decoding. */ @@ -853,6 +866,9 @@ vmm_decode_instruction(struct vm *vm, int cpuid, uint64_t gla, struct vie *vie) if (decode_immediate(vie)) return (-1); + if (verify_inst_length(vie)) + return (-1); + if (verify_gla(vm, cpuid, gla, vie)) return (-1); diff --git a/sys/amd64/vmm/x86.c b/sys/amd64/vmm/x86.c index fa2eabc..262efbd 100644 --- a/sys/amd64/vmm/x86.c +++ b/sys/amd64/vmm/x86.c @@ -45,7 +45,9 @@ __FBSDID("$FreeBSD$"); #define CPUID_VM_HIGH 0x40000000 -static const char bhyve_id[12] = "BHyVE BHyVE "; +static const char bhyve_id[12] = "bhyve bhyve "; + +static uint64_t bhyve_xcpuids; int x86_emulate_cpuid(struct vm *vm, int vcpu_id, @@ -77,15 +79,13 @@ x86_emulate_cpuid(struct vm *vm, int vcpu_id, * no multi-core or SMT. */ switch (func) { + /* + * Pass these through to the guest + */ case CPUID_0000_0000: case CPUID_0000_0002: case CPUID_0000_0003: - case CPUID_0000_000A: - cpuid_count(*eax, *ecx, regs); - break; - case CPUID_8000_0000: - case CPUID_8000_0001: case CPUID_8000_0002: case CPUID_8000_0003: case CPUID_8000_0004: @@ -94,6 +94,15 @@ x86_emulate_cpuid(struct vm *vm, int vcpu_id, cpuid_count(*eax, *ecx, regs); break; + case CPUID_8000_0001: + /* + * Hide rdtscp/ia32_tsc_aux until we know how + * to deal with them. + */ + cpuid_count(*eax, *ecx, regs); + regs[3] &= ~AMDID_RDTSCP; + break; + case CPUID_8000_0007: cpuid_count(*eax, *ecx, regs); /* @@ -150,6 +159,11 @@ x86_emulate_cpuid(struct vm *vm, int vcpu_id, */ regs[2] &= ~CPUID2_MON; + /* + * Hide the performance and debug features. + */ + regs[2] &= ~CPUID2_PDCM; + /* * Hide thermal monitoring */ @@ -161,6 +175,11 @@ x86_emulate_cpuid(struct vm *vm, int vcpu_id, */ regs[3] &= ~(CPUID_MCA | CPUID_MCE | CPUID_MTRR); + /* + * Hide the debug store capability. + */ + regs[3] &= ~CPUID_DS; + /* * Disable multi-core. */ @@ -180,6 +199,7 @@ x86_emulate_cpuid(struct vm *vm, int vcpu_id, case CPUID_0000_0006: case CPUID_0000_0007: + case CPUID_0000_000A: /* * Handle the access, but report 0 for * all options @@ -203,17 +223,25 @@ x86_emulate_cpuid(struct vm *vm, int vcpu_id, case 0x40000000: regs[0] = CPUID_VM_HIGH; bcopy(bhyve_id, ®s[1], 4); - bcopy(bhyve_id, ®s[2], 4); - bcopy(bhyve_id, ®s[3], 4); + bcopy(bhyve_id + 4, ®s[2], 4); + bcopy(bhyve_id + 8, ®s[3], 4); break; + default: - /* XXX: Leaf 5? */ - return (0); + /* + * The leaf value has already been clamped so + * simply pass this through, keeping count of + * how many unhandled leaf values have been seen. + */ + atomic_add_long(&bhyve_xcpuids, 1); + cpuid_count(*eax, *ecx, regs); + break; } *eax = regs[0]; *ebx = regs[1]; *ecx = regs[2]; *edx = regs[3]; + return (1); } diff --git a/sys/arm/arm/bus_space_generic.c b/sys/arm/arm/bus_space_generic.c index f8f38ab..29638845 100644 --- a/sys/arm/arm/bus_space_generic.c +++ b/sys/arm/arm/bus_space_generic.c @@ -73,7 +73,7 @@ generic_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flags, offset = bpa & PAGE_MASK; startpa = trunc_page(bpa); - va = kmem_alloc(kernel_map, endpa - startpa); + va = kmem_alloc_nofault(kernel_map, endpa - startpa); if (va == 0) return (ENOMEM); diff --git a/sys/arm/arm/busdma_machdep-v6.c b/sys/arm/arm/busdma_machdep-v6.c index 5324f80..d5da5c7 100644 --- a/sys/arm/arm/busdma_machdep-v6.c +++ b/sys/arm/arm/busdma_machdep-v6.c @@ -192,14 +192,26 @@ static busdma_bufalloc_t standard_allocator; /* Cache of standard buffers */ static void busdma_init(void *dummy) { + int uma_flags; + + uma_flags = 0; /* Create a cache of buffers in standard (cacheable) memory. */ standard_allocator = busdma_bufalloc_create("buffer", arm_dcache_align, /* minimum_alignment */ NULL, /* uma_alloc func */ NULL, /* uma_free func */ - 0); /* uma_zcreate_flags */ - + uma_flags); /* uma_zcreate_flags */ + +#ifdef INVARIANTS + /* + * Force UMA zone to allocate service structures like + * slabs using own allocator. uma_debug code performs + * atomic ops on uma_slab_t fields and safety of this + * operation is not guaranteed for write-back caches + */ + uma_flags = UMA_ZONE_OFFPAGE; +#endif /* * Create a cache of buffers in uncacheable memory, to implement the * BUS_DMA_COHERENT (and potentially BUS_DMA_NOCACHE) flag. @@ -208,7 +220,7 @@ busdma_init(void *dummy) arm_dcache_align, /* minimum_alignment */ busdma_bufalloc_alloc_uncacheable, busdma_bufalloc_free_uncacheable, - 0); /* uma_zcreate_flags */ + uma_flags); /* uma_zcreate_flags */ } /* diff --git a/sys/arm/arm/cpufunc.c b/sys/arm/arm/cpufunc.c index f235951..4d9889e 100644 --- a/sys/arm/arm/cpufunc.c +++ b/sys/arm/arm/cpufunc.c @@ -1481,7 +1481,8 @@ set_cpufuncs() cputype == CPU_ID_CORTEXA8R3 || cputype == CPU_ID_CORTEXA9R1 || cputype == CPU_ID_CORTEXA9R2 || - cputype == CPU_ID_CORTEXA9R3) { + cputype == CPU_ID_CORTEXA9R3 || + cputype == CPU_ID_CORTEXA15 ) { cpufuncs = cortexa_cpufuncs; cpu_reset_needs_v4_MMU_disable = 1; /* V4 or higher */ get_cachetype_cp15(); diff --git a/sys/arm/arm/db_trace.c b/sys/arm/arm/db_trace.c index 7f16028..6b72cde 100644 --- a/sys/arm/arm/db_trace.c +++ b/sys/arm/arm/db_trace.c @@ -108,6 +108,7 @@ extern int extab_start, extab_end, exidx_start, exidx_end; #define INSN_VSP_REG 0x90 #define INSN_POP_COUNT 0xa0 #define INSN_FINISH 0xb0 +#define INSN_POP_REGS 0xb1 #define INSN_VSP_LARGE_INC 0xb2 /* An item in the exception index table */ @@ -268,6 +269,24 @@ db_unwind_exec_insn(struct unwind_state *state) /* Stop processing */ state->entries = 0; + } else if ((insn == INSN_POP_REGS)) { + unsigned int mask, reg; + + mask = db_unwind_exec_read_byte(state); + if (mask == 0 || (mask & 0xf0) != 0) + return 1; + + /* Update SP */ + update_vsp = 1; + + /* Load the registers */ + for (reg = 0; mask && reg < 4; mask >>= 1, reg++) { + if (mask & 1) { + state->registers[reg] = *vsp++; + state->update_mask |= 1 << reg; + } + } + } else if ((insn & INSN_VSP_LARGE_INC_MASK) == INSN_VSP_LARGE_INC) { unsigned int uleb128; diff --git a/sys/arm/arm/exception.S b/sys/arm/arm/exception.S index 498c43f..171211a 100644 --- a/sys/arm/arm/exception.S +++ b/sys/arm/arm/exception.S @@ -206,7 +206,7 @@ END(address_exception_entry) */ ASENTRY_NP(exception_exit) - STOP_UNWINDING + UNWINDSVCFRAME DO_AST PULLFRAMEFROMSVCANDEXIT END(exception_exit) diff --git a/sys/arm/arm/generic_timer.c b/sys/arm/arm/generic_timer.c new file mode 100644 index 0000000..48d92ae --- /dev/null +++ b/sys/arm/arm/generic_timer.c @@ -0,0 +1,394 @@ +/*- + * Copyright (c) 2011 The FreeBSD Foundation + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Based on mpcore_timer.c developed by Ben Gray <ben.r.gray@gmail.com> + * + * 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 company nor the name of the author may be used to + * endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/** + * Cortex-A15 (and probably A7) Generic Timer + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/malloc.h> +#include <sys/rman.h> +#include <sys/timeet.h> +#include <sys/timetc.h> +#include <sys/watchdog.h> +#include <machine/bus.h> +#include <machine/cpu.h> +#include <machine/frame.h> +#include <machine/intr.h> + +#include <dev/fdt/fdt_common.h> +#include <dev/ofw/openfirm.h> +#include <dev/ofw/ofw_bus.h> +#include <dev/ofw/ofw_bus_subr.h> + +#include <machine/bus.h> +#include <machine/fdt.h> + +#define GENERIC_TIMER_CTRL_ENABLE (1 << 0) +#define GENERIC_TIMER_CTRL_INT_MASK (1 << 1) +#define GENERIC_TIMER_CTRL_INT_STAT (1 << 2) +#define GENERIC_TIMER_REG_CTRL 0 +#define GENERIC_TIMER_REG_TVAL 1 + +#define GENERIC_TIMER_CNTKCTL_PL0PTEN (1 << 9) /* Physical timer registers + access from PL0 */ +#define GENERIC_TIMER_CNTKCTL_PL0VTEN (1 << 8) /* Virtual timer registers + access from PL0 */ +#define GENERIC_TIMER_CNTKCTL_EVNTI (1 << 4) /* Virtual counter + event bits */ +#define GENERIC_TIMER_CNTKCTL_EVNTDIR (1 << 3) /* Virtual counter + event transition */ +#define GENERIC_TIMER_CNTKCTL_EVNTEN (1 << 2) /* Enables events from + the virtual counter */ +#define GENERIC_TIMER_CNTKCTL_PL0VCTEN (1 << 1) /* CNTVCT and CNTFRQ + access from PL0 */ +#define GENERIC_TIMER_CNTKCTL_PL0PCTEN (1 << 0) /* CNTPCT and CNTFRQ + access from PL0 */ + +#define GENERIC_TIMER_CNTPSIRQ 29 + +struct arm_tmr_softc { + struct resource *irq_res; + uint32_t clkfreq; + struct eventtimer et; +}; + +static struct arm_tmr_softc *arm_tmr_sc = NULL; + +static timecounter_get_t arm_tmr_get_timecount; + +static struct timecounter arm_tmr_timecount = { + .tc_name = "ARM MPCore Timecounter", + .tc_get_timecount = arm_tmr_get_timecount, + .tc_poll_pps = NULL, + .tc_counter_mask = ~0u, + .tc_frequency = 0, + .tc_quality = 1000, +}; + +static inline int +get_freq(void) +{ + uint32_t val; + + __asm volatile("mrc p15, 0, %0, c14, c0, 0" : "=r" (val)); + + return (val); +} + +static inline int +set_freq(uint32_t val) +{ + + __asm volatile("mcr p15, 0, %[val], c14, c0, 0" : : + [val] "r" (val)); + isb(); + + return (val); +} + + +static inline long +get_cntpct(void) +{ + uint64_t val; + + __asm volatile("mrrc p15, 0, %Q0, %R0, c14" : "=r" (val)); + + return (val); +} + +static inline int +set_ctrl(uint32_t val) +{ + + __asm volatile("mcr p15, 0, %[val], c14, c2, 1" : : + [val] "r" (val)); + isb(); + + return (0); +} + +static inline int +set_tval(uint32_t val) +{ + + __asm volatile("mcr p15, 0, %[val], c14, c2, 0" : : + [val] "r" (val)); + isb(); + + return (0); +} + +static inline int +get_ctrl(void) +{ + uint32_t val; + + __asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val)); + + return (val); +} + +static inline int +get_tval(void) +{ + uint32_t val; + + __asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val)); + + return (val); +} + +static inline void +disable_user_access(void) +{ + uint32_t cntkctl; + + __asm volatile("mrc p15, 0, %0, c14, c1, 0" : "=r" (cntkctl)); + cntkctl &= ~(GENERIC_TIMER_CNTKCTL_PL0PTEN | + GENERIC_TIMER_CNTKCTL_PL0VTEN | + GENERIC_TIMER_CNTKCTL_EVNTEN | + GENERIC_TIMER_CNTKCTL_PL0VCTEN | + GENERIC_TIMER_CNTKCTL_PL0PCTEN); + __asm volatile("mcr p15, 0, %0, c14, c1, 0" : : "r" (cntkctl)); + isb(); +} + +static unsigned +arm_tmr_get_timecount(struct timecounter *tc) +{ + + return (get_cntpct()); +} + +static int +arm_tmr_start(struct eventtimer *et, sbintime_t first, sbintime_t period) +{ + struct arm_tmr_softc *sc; + int counts, ctrl; + + sc = (struct arm_tmr_softc *)et->et_priv; + + if (first != 0) { + counts = ((uint32_t)et->et_frequency * first) >> 32; + ctrl = get_ctrl(); + ctrl &= ~GENERIC_TIMER_CTRL_INT_MASK; + ctrl |= GENERIC_TIMER_CTRL_ENABLE; + set_tval(counts); + set_ctrl(ctrl); + return (0); + } + + return (EINVAL); + +} + +static int +arm_tmr_stop(struct eventtimer *et) +{ + int ctrl; + + ctrl = get_ctrl(); + ctrl &= GENERIC_TIMER_CTRL_ENABLE; + set_ctrl(ctrl); + + return (0); +} + +static int +arm_tmr_intr(void *arg) +{ + struct arm_tmr_softc *sc; + int ctrl; + + sc = (struct arm_tmr_softc *)arg; + ctrl = get_ctrl(); + if (ctrl & GENERIC_TIMER_CTRL_INT_STAT) { + ctrl |= GENERIC_TIMER_CTRL_INT_MASK; + set_ctrl(ctrl); + } + + if (sc->et.et_active) + sc->et.et_event_cb(&sc->et, sc->et.et_arg); + + return (FILTER_HANDLED); +} + +static int +arm_tmr_probe(device_t dev) +{ + + if (!ofw_bus_is_compatible(dev, "arm,armv7-timer")) + return (ENXIO); + + device_set_desc(dev, "ARMv7 Generic Timer"); + return (BUS_PROBE_DEFAULT); +} + + +static int +arm_tmr_attach(device_t dev) +{ + struct arm_tmr_softc *sc; + phandle_t node; + pcell_t clock; + void *ihl; + int rid; + int error; + + sc = device_get_softc(dev); + if (arm_tmr_sc) + return (ENXIO); + + /* Get the base clock frequency */ + node = ofw_bus_get_node(dev); + error = OF_getprop(node, "clock-frequency", &clock, sizeof(clock)); + if (error <= 0) { + device_printf(dev, "missing clock-frequency " + "attribute in FDT\n"); + return (ENXIO); + } + sc->clkfreq = fdt32_to_cpu(clock); + + rid = 0; + sc->irq_res = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, + GENERIC_TIMER_CNTPSIRQ, GENERIC_TIMER_CNTPSIRQ, + 1, RF_SHAREABLE | RF_ACTIVE); + + arm_tmr_sc = sc; + + /* Setup and enable the timer */ + if (bus_setup_intr(dev, sc->irq_res, INTR_TYPE_CLK, arm_tmr_intr, + NULL, sc, &ihl) != 0) { + bus_release_resource(dev, SYS_RES_IRQ, rid, sc->irq_res); + device_printf(dev, "Unable to setup the CLK irq handler.\n"); + return (ENXIO); + } + + set_freq(sc->clkfreq); + disable_user_access(); + + arm_tmr_timecount.tc_frequency = sc->clkfreq; + tc_init(&arm_tmr_timecount); + + sc->et.et_name = "ARM MPCore Eventtimer"; + sc->et.et_flags = ET_FLAGS_ONESHOT | ET_FLAGS_PERCPU; + sc->et.et_quality = 1000; + + sc->et.et_frequency = sc->clkfreq; + sc->et.et_min_period = (0x00000002LLU << 32) / sc->et.et_frequency; + sc->et.et_max_period = (0xfffffffeLLU << 32) / sc->et.et_frequency; + sc->et.et_start = arm_tmr_start; + sc->et.et_stop = arm_tmr_stop; + sc->et.et_priv = sc; + et_register(&sc->et); + + return (0); +} + +static device_method_t arm_tmr_methods[] = { + DEVMETHOD(device_probe, arm_tmr_probe), + DEVMETHOD(device_attach, arm_tmr_attach), + { 0, 0 } +}; + +static driver_t arm_tmr_driver = { + "generic_timer", + arm_tmr_methods, + sizeof(struct arm_tmr_softc), +}; + +static devclass_t arm_tmr_devclass; + +DRIVER_MODULE(timer, simplebus, arm_tmr_driver, arm_tmr_devclass, 0, 0); + +void +cpu_initclocks(void) +{ + + if (PCPU_GET(cpuid) == 0) + cpu_initclocks_bsp(); + else + cpu_initclocks_ap(); +} + +void +DELAY(int usec) +{ + int32_t counts, counts_per_usec; + uint32_t first, last; + + /* + * Check the timers are setup, if not just + * use a for loop for the meantime + */ + if (arm_tmr_sc == NULL) { + for (; usec > 0; usec--) + for (counts = 200; counts > 0; counts--) + /* + * Prevent gcc from optimizing + * out the loop + */ + cpufunc_nullop(); + return; + } + + /* Get the number of times to count */ + counts_per_usec = ((arm_tmr_timecount.tc_frequency / 1000000) + 1); + + /* + * Clamp the timeout at a maximum value (about 32 seconds with + * a 66MHz clock). *Nobody* should be delay()ing for anywhere + * near that length of time and if they are, they should be hung + * out to dry. + */ + if (usec >= (0x80000000U / counts_per_usec)) + counts = (0x80000000U / counts_per_usec) - 1; + else + counts = usec * counts_per_usec; + + first = get_cntpct(); + + while (counts > 0) { + last = get_cntpct(); + counts -= (int32_t)(last - first); + first = last; + } +} diff --git a/sys/arm/arm/gic.c b/sys/arm/arm/gic.c index 2871d9d..c453a20 100644 --- a/sys/arm/arm/gic.c +++ b/sys/arm/arm/gic.c @@ -114,6 +114,7 @@ static void gic_post_filter(void *); static int arm_gic_probe(device_t dev) { + if (!ofw_bus_is_compatible(dev, "arm,gic")) return (ENXIO); device_set_desc(dev, "ARM Generic Interrupt Controller"); @@ -123,14 +124,20 @@ arm_gic_probe(device_t dev) void gic_init_secondary(void) { - int nirqs; - + int i, nirqs; + /* Get the number of interrupts */ nirqs = gic_d_read_4(GICD_TYPER); nirqs = 32 * ((nirqs & 0x1f) + 1); - - for (int i = 0; i < nirqs; i += 4) + + for (i = 0; i < nirqs; i += 4) gic_d_write_4(GICD_IPRIORITYR(i >> 2), 0); + + /* Set all the interrupts to be in Group 0 (secure) */ + for (i = 0; i < nirqs; i += 32) { + gic_d_write_4(GICD_IGROUPR(i >> 5), 0); + } + /* Enable CPU interface */ gic_c_write_4(GICC_CTLR, 1); @@ -139,7 +146,7 @@ gic_init_secondary(void) /* Enable interrupt distribution */ gic_d_write_4(GICD_CTLR, 0x01); - + /* Activate IRQ 29, ie private timer IRQ*/ gic_d_write_4(GICD_ISENABLER(29 >> 5), (1UL << (29 & 0x1F))); } @@ -147,7 +154,7 @@ gic_init_secondary(void) static int arm_gic_attach(device_t dev) { - struct arm_gic_softc *sc = device_get_softc(dev); + struct arm_gic_softc *sc; int i; uint32_t icciidr; uint32_t nirqs; @@ -155,6 +162,8 @@ arm_gic_attach(device_t dev) if (arm_gic_sc) return (ENXIO); + sc = device_get_softc(dev); + if (bus_alloc_resources(dev, arm_gic_spec, sc->gic_res)) { device_printf(dev, "could not allocate resources\n"); return (ENXIO); @@ -180,7 +189,7 @@ arm_gic_attach(device_t dev) nirqs = 32 * ((nirqs & 0x1f) + 1); icciidr = gic_c_read_4(GICC_IIDR); - device_printf(dev,"pn 0x%x, arch 0x%x, rev 0x%x, implementer 0x%x nirqs %u\n", + device_printf(dev,"pn 0x%x, arch 0x%x, rev 0x%x, implementer 0x%x nirqs %u\n", icciidr>>20, (icciidr>>16) & 0xF, (icciidr>>12) & 0xf, (icciidr & 0xfff), nirqs); @@ -195,10 +204,15 @@ arm_gic_attach(device_t dev) } for (i = 0; i < nirqs; i += 4) { - gic_d_write_4(GICD_IPRIORITYR(i >> 2), 0); + gic_d_write_4(GICD_IPRIORITYR(i >> 2), 0); gic_d_write_4(GICD_ITARGETSR(i >> 2), 0xffffffff); } + /* Set all the interrupts to be in Group 0 (secure) */ + for (i = 0; i < nirqs; i += 32) { + gic_d_write_4(GICD_IGROUPR(i >> 5), 0); + } + /* Enable CPU interface */ gic_c_write_4(GICC_CTLR, 1); @@ -242,12 +256,12 @@ arm_get_next_irq(int last_irq) active_irq = gic_c_read_4(GICC_IAR); - /* + /* * Immediatly EOIR the SGIs, because doing so requires the other * bits (ie CPU number), not just the IRQ number, and we do not * have this information later. */ - + if ((active_irq & 0x3ff) < 16) gic_c_write_4(GICC_EOIR, active_irq); active_irq &= 0x3FF; @@ -257,7 +271,7 @@ arm_get_next_irq(int last_irq) printf("Spurious interrupt detected [0x%08x]\n", active_irq); return -1; } - gic_c_write_4(GICC_EOIR, active_irq); + gic_c_write_4(GICC_EOIR, active_irq); return active_irq; } @@ -271,7 +285,7 @@ arm_mask_irq(uintptr_t nb) void arm_unmask_irq(uintptr_t nb) { - + gic_c_write_4(GICC_EOIR, nb); gic_d_write_4(GICD_ISENABLER(nb >> 5), (1UL << (nb & 0x1F))); } @@ -286,19 +300,19 @@ pic_ipi_send(cpuset_t cpus, u_int ipi) if (CPU_ISSET(i, &cpus)) val |= 1 << (16 + i); gic_d_write_4(GICD_SGIR(0), val | ipi); - + } int pic_ipi_get(int i) { - + if (i != -1) { /* * The intr code will automagically give the frame pointer * if the interrupt argument is 0. */ - if ((unsigned int)i > 16) + if ((unsigned int)i > 16) return (0); return (i); } diff --git a/sys/arm/arm/identcpu.c b/sys/arm/arm/identcpu.c index 414396a..33cfa1e 100644 --- a/sys/arm/arm/identcpu.c +++ b/sys/arm/arm/identcpu.c @@ -248,6 +248,8 @@ const struct cpuidtab cpuids[] = { generic_steppings }, { CPU_ID_CORTEXA9R3, CPU_CLASS_CORTEXA, "Cortex A9-r3", generic_steppings }, + { CPU_ID_CORTEXA15, CPU_CLASS_CORTEXA, "Cortex A15", + generic_steppings }, { CPU_ID_SA110, CPU_CLASS_SA1, "SA-110", sa110_steppings }, diff --git a/sys/arm/arm/pmap-v6.c b/sys/arm/arm/pmap-v6.c index 9e0b8bd..c0f4c2c 100644 --- a/sys/arm/arm/pmap-v6.c +++ b/sys/arm/arm/pmap-v6.c @@ -2470,7 +2470,6 @@ pmap_remove_all(vm_page_t m) else cpu_tlb_flushD(); } - vm_page_aflag_clear(m, PGA_WRITEABLE); rw_wunlock(&pvh_global_lock); } @@ -2801,8 +2800,13 @@ validate: } if (prot & VM_PROT_WRITE) { - /* Write enable */ - npte &= ~(L2_APX); + /* + * Enable write permission if the access type + * indicates write intention. Emulate modified + * bit otherwise. + */ + if ((access & VM_PROT_WRITE) != 0) + npte &= ~(L2_APX); if ((m->oflags & VPO_UNMANAGED) == 0) { vm_page_aflag_set(m, PGA_WRITEABLE); diff --git a/sys/arm/broadcom/bcm2835/bcm2835_mbox.c b/sys/arm/broadcom/bcm2835/bcm2835_mbox.c index a262ad7..f18102b 100644 --- a/sys/arm/broadcom/bcm2835/bcm2835_mbox.c +++ b/sys/arm/broadcom/bcm2835/bcm2835_mbox.c @@ -163,11 +163,9 @@ bcm_mbox_attach(device_t dev) } /* Setup and enable the timer */ - if (bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC, - NULL, bcm_mbox_intr, sc, - &sc->intr_hl) != 0) { - bus_release_resource(dev, SYS_RES_IRQ, rid, - sc->irq_res); + if (bus_setup_intr(dev, sc->irq_res, INTR_MPSAFE | INTR_TYPE_MISC, + NULL, bcm_mbox_intr, sc, &sc->intr_hl) != 0) { + bus_release_resource(dev, SYS_RES_IRQ, rid, sc->irq_res); device_printf(dev, "Unable to setup the clock irq handler.\n"); return (ENXIO); } diff --git a/sys/arm/broadcom/bcm2835/bcm2835_sdhci.c b/sys/arm/broadcom/bcm2835/bcm2835_sdhci.c index f4a2de6..90a5725 100644 --- a/sys/arm/broadcom/bcm2835/bcm2835_sdhci.c +++ b/sys/arm/broadcom/bcm2835/bcm2835_sdhci.c @@ -74,8 +74,6 @@ __FBSDID("$FreeBSD$"); #define BCM_SDHCI_BUFFER_SIZE 512 -#define DEBUG - #ifdef DEBUG #define dprintf(fmt, args...) do { printf("%s(): ", __func__); \ printf(fmt,##args); } while (0) diff --git a/sys/arm/conf/ARNDALE b/sys/arm/conf/ARNDALE new file mode 100644 index 0000000..1864f33 --- /dev/null +++ b/sys/arm/conf/ARNDALE @@ -0,0 +1,135 @@ +# Kernel configuration for Arndale Board (Exynos5 Dual development platform). +# +# For more information on this file, please read the config(5) manual page, +# and/or the handbook section on Kernel Configuration Files: +# +# http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/kernelconfig-config.html +# +# The handbook is also available locally in /usr/share/doc/handbook +# if you've installed the doc distribution, otherwise always see the +# FreeBSD World Wide Web server (http://www.FreeBSD.org/) for the +# latest information. +# +# An exhaustive list of options and more detailed explanations of the +# device lines is also present in the ../../conf/NOTES and NOTES files. +# If you are in doubt as to the purpose or necessity of a line, check first +# in NOTES. +# +# $FreeBSD$ + +ident ARNDALE + +include "../samsung/exynos/std.exynos5" + +makeoptions MODULES_OVERRIDE="" +makeoptions WITHOUT_MODULES="ahc" + +makeoptions DEBUG=-g #Build kernel with gdb(1) debug symbols +makeoptions WERROR="-Werror" + +options HZ=100 ## +options SCHED_4BSD #4BSD scheduler +options INET #InterNETworking +options INET6 #IPv6 communications protocols +options FFS #Berkeley Fast Filesystem +options SOFTUPDATES +options UFS_ACL #Support for access control lists +options UFS_DIRHASH #Improve performance on big directories +options MSDOSFS #MSDOS Filesystem +options CD9660 #ISO 9660 Filesystem +options PROCFS #Process filesystem (requires PSEUDOFS) +options PSEUDOFS #Pseudo-filesystem framework +options TMPFS +options COMPAT_43 #Compatible with BSD 4.3 [KEEP THIS!] +options SCSI_DELAY=5000 #Delay (in ms) before probing SCSI +options KTRACE +options SYSVSHM #SYSV-style shared memory +options SYSVMSG #SYSV-style message queues +options SYSVSEM #SYSV-style semaphores +options _KPOSIX_PRIORITY_SCHEDULING #Posix P1003_1B real-time extensions +options KBD_INSTALL_CDEV +options PREEMPTION +options FREEBSD_BOOT_LOADER + +# Debugging +makeoptions DEBUG=-g #Build kernel with gdb(1) debug symbols +options BREAK_TO_DEBUGGER +#options VERBOSE_SYSINIT #Enable verbose sysinit messages +options KDB +options DDB #Enable the kernel debugger +options INVARIANTS #Enable calls of extra sanity checking +options INVARIANT_SUPPORT #Extra sanity checks of internal structures, required by INVARIANTS +#options WITNESS #Enable checks to detect deadlocks and cycles +#options WITNESS_SKIPSPIN #Don't run witness on spinlocks for speed +options DIAGNOSTIC + +# NFS support +options NFSCL #Network Filesystem Client +options NFSLOCKD #Network Lock Manager +options NFS_ROOT #NFS usable as /, requires NFSCLIENT + +# Uncomment this for NFS root +#options NFS_ROOT #NFS usable as /, requires NFSCL +#options BOOTP_NFSROOT +#options BOOTP_COMPAT +#options BOOTP +#options BOOTP_NFSV3 +#options BOOTP_WIRED_TO=cpsw0 + +device mmc # mmc/sd bus +device mmcsd # mmc/sd flash cards +device sdhci # generic sdhci + +options ROOTDEVNAME=\"ufs:/dev/da0\" + +#options SMP + +# Pseudo devices + +device loop +device random +device pty +device md +device gpio + +# USB support +device usb +options USB_DEBUG +#options USB_REQ_DEBUG +#options USB_VERBOSE +#device musb +device ehci +#device ohci + +device umass +device scbus # SCSI bus (required for SCSI) +device da # Direct Access (disks) +device pass + +# SATA +#device ata +#device atadisk +#device mvs + +# Serial ports +device uart + +# I2C (TWSI) +#device iic +#device iicbus + +# Ethernet +device ether +device mii +device smsc +device smscphy + +# USB ethernet support, requires miibus +device miibus +device axe # ASIX Electronics USB Ethernet +device bpf # Berkeley packet filter + +#FDT +options FDT +options FDT_DTB_STATIC +makeoptions FDT_DTS_FILE=exynos5250-arndale.dts diff --git a/sys/arm/conf/RPI-B b/sys/arm/conf/RPI-B index 4d840cb..38db5dd 100644 --- a/sys/arm/conf/RPI-B +++ b/sys/arm/conf/RPI-B @@ -38,6 +38,8 @@ options HZ=100 options SCHED_4BSD #4BSD scheduler options INET #InterNETworking +options INET6 #IPv6 communications protocols +options SCTP #Stream Control Transmission Protocol options FFS #Berkeley Fast Filesystem options SOFTUPDATES #Enable FFS soft updates support options UFS_ACL #Support for access control lists @@ -117,4 +119,7 @@ options FDT # Note: DTB is normally loaded and modified by RPi boot loader, then # handed to kernel via U-Boot and ubldr. #options FDT_DTB_STATIC -makeoptions FDT_DTS_FILE=bcm2835-rpi-b.dts +makeoptions FDT_DTS_FILE=rpi.dts + +device vfp # vfp/neon +options ARM_VFP_SUPPORT # vfp/neon diff --git a/sys/arm/include/armreg.h b/sys/arm/include/armreg.h index 1f54f91..049d140 100644 --- a/sys/arm/include/armreg.h +++ b/sys/arm/include/armreg.h @@ -153,6 +153,7 @@ #define CPU_ID_CORTEXA9R1 0x411fc090 #define CPU_ID_CORTEXA9R2 0x412fc090 #define CPU_ID_CORTEXA9R3 0x413fc090 +#define CPU_ID_CORTEXA15 0x410fc0f0 #define CPU_ID_SA110 0x4401a100 #define CPU_ID_SA1100 0x4401a110 #define CPU_ID_TI925T 0x54029250 diff --git a/sys/arm/include/asmacros.h b/sys/arm/include/asmacros.h index f83c14f..18dcef5 100644 --- a/sys/arm/include/asmacros.h +++ b/sys/arm/include/asmacros.h @@ -206,7 +206,16 @@ mov r0, r0; /* NOP for previous instruction */ \ add sp, sp, #(4*15); /* Adjust the stack pointer */ \ ldmia sp, {sp, lr, pc}^ /* Restore lr and exit */ -#endif +#endif +#if defined(__ARM_EABI__) +#define UNWINDSVCFRAME \ + .save {r13-r15}; /* Restore sp, lr, pc */ \ + .pad #(2*4); /* Skip user sp and lr */ \ + .save {r0-r12}; /* Restore r0-r12 */ \ + .pad #(4) /* Skip spsr */ +#else +#define UNWINDSVCFRAME +#endif #define DATA(name) \ .data ; \ diff --git a/sys/arm/include/counter.h b/sys/arm/include/counter.h index 68f89e2..a6dfa8e 100644 --- a/sys/arm/include/counter.h +++ b/sys/arm/include/counter.h @@ -37,6 +37,46 @@ #define counter_enter() critical_enter() #define counter_exit() critical_exit() +#ifdef IN_SUBR_COUNTER_C +/* XXXKIB non-atomic 64bit read */ +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +/* XXXKIB non-atomic 64bit store, might interrupt increment */ +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, inc) do { \ CRITICAL_ASSERT(curthread); \ *(uint64_t *)zpcpu_get(c) += (inc); \ diff --git a/sys/arm/include/intr.h b/sys/arm/include/intr.h index 9392969..93a204c 100644 --- a/sys/arm/include/intr.h +++ b/sys/arm/include/intr.h @@ -51,7 +51,7 @@ defined(CPU_XSCALE_IXP435) #define NIRQ 64 #elif defined(CPU_CORTEXA) -#define NIRQ 128 +#define NIRQ 160 #elif defined(CPU_ARM1136) || defined(CPU_ARM1176) #define NIRQ 128 #elif defined(SOC_MV_ARMADAXP) diff --git a/sys/arm/samsung/exynos/arch_timer.c b/sys/arm/samsung/exynos/arch_timer.c new file mode 100644 index 0000000..e5970b6 --- /dev/null +++ b/sys/arm/samsung/exynos/arch_timer.c @@ -0,0 +1,136 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This module just enables Exynos MCT, so ARMv7 Generic Timer will works + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/malloc.h> +#include <sys/rman.h> +#include <sys/timeet.h> +#include <sys/timetc.h> +#include <sys/watchdog.h> +#include <machine/bus.h> +#include <machine/cpu.h> +#include <machine/frame.h> +#include <machine/intr.h> + +#include <dev/fdt/fdt_common.h> +#include <dev/ofw/openfirm.h> +#include <dev/ofw/ofw_bus.h> +#include <dev/ofw/ofw_bus_subr.h> + +#include <machine/bus.h> +#include <machine/fdt.h> + +#define MCT_CTRL_START (1 << 8) +#define MCT_CTRL (0x240) +#define MCT_WRITE_STAT (0x24C) + +struct arm_tmr_softc { + struct resource *tmr_res[1]; + bus_space_tag_t bst; + bus_space_handle_t bsh; +}; + +static struct resource_spec arm_tmr_spec[] = { + { SYS_RES_MEMORY, 0, RF_ACTIVE }, /* Timer registers */ + { -1, 0 } +}; + +static int +arm_tmr_probe(device_t dev) +{ + if (!ofw_bus_is_compatible(dev, "exynos,mct")) + return (ENXIO); + + device_set_desc(dev, "Exynos MPCore Timer"); + return (BUS_PROBE_DEFAULT); +} + +static int +arm_tmr_attach(device_t dev) +{ + struct arm_tmr_softc *sc; + int reg, i; + int mask; + + sc = device_get_softc(dev); + + if (bus_alloc_resources(dev, arm_tmr_spec, sc->tmr_res)) { + device_printf(dev, "could not allocate resources\n"); + return (ENXIO); + } + + /* Timer interface */ + sc->bst = rman_get_bustag(sc->tmr_res[0]); + sc->bsh = rman_get_bushandle(sc->tmr_res[0]); + + reg = bus_space_read_4(sc->bst, sc->bsh, MCT_CTRL); + reg |= MCT_CTRL_START; + bus_space_write_4(sc->bst, sc->bsh, MCT_CTRL, reg); + + mask = (1 << 16); + + /* Wait 10 times until written value is applied */ + for (i = 0; i < 10; i++) { + reg = bus_space_read_4(sc->bst, sc->bsh, MCT_WRITE_STAT); + if (reg & mask) { + bus_space_write_4(sc->bst, sc->bsh, + MCT_WRITE_STAT, mask); + return (0); + } + cpufunc_nullop(); + } + + /* NOTREACHED */ + + panic("Can't enable timer\n"); +} + +static device_method_t arm_tmr_methods[] = { + DEVMETHOD(device_probe, arm_tmr_probe), + DEVMETHOD(device_attach, arm_tmr_attach), + { 0, 0 } +}; + +static driver_t arm_tmr_driver = { + "arch_timer", + arm_tmr_methods, + sizeof(struct arm_tmr_softc), +}; + +static devclass_t arm_tmr_devclass; + +DRIVER_MODULE(arch_timer, simplebus, arm_tmr_driver, arm_tmr_devclass, 0, 0); diff --git a/sys/arm/samsung/exynos/bus_space.c b/sys/arm/samsung/exynos/bus_space.c new file mode 100644 index 0000000..8d21f55 --- /dev/null +++ b/sys/arm/samsung/exynos/bus_space.c @@ -0,0 +1,153 @@ +/*- + * Copyright (c) 2012 Damjan Marion <damjan.marion@gmail.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/malloc.h> + +#include <machine/bus.h> + +/* Prototypes for all the bus_space structure functions */ +bs_protos(generic); +bs_protos(generic_armv4); + +/* + * The bus space tag. This is constant for all instances, so + * we never have to explicitly "create" it. + */ +static struct bus_space _base_tag = { + /* cookie */ + (void *) 0, + + /* mapping/unmapping */ + generic_bs_map, + generic_bs_unmap, + generic_bs_subregion, + + /* allocation/deallocation */ + generic_bs_alloc, + generic_bs_free, + + /* barrier */ + generic_bs_barrier, + + /* read (single) */ + generic_bs_r_1, + generic_armv4_bs_r_2, + generic_bs_r_4, + NULL, + + /* read multiple */ + generic_bs_rm_1, + generic_armv4_bs_rm_2, + generic_bs_rm_4, + NULL, + + /* read region */ + generic_bs_rr_1, + generic_armv4_bs_rr_2, + generic_bs_rr_4, + NULL, + + /* write (single) */ + generic_bs_w_1, + generic_armv4_bs_w_2, + generic_bs_w_4, + NULL, + + /* write multiple */ + generic_bs_wm_1, + generic_armv4_bs_wm_2, + generic_bs_wm_4, + NULL, + + /* write region */ + NULL, + NULL, + NULL, + NULL, + + /* set multiple */ + NULL, + NULL, + NULL, + NULL, + + /* set region */ + NULL, + NULL, + NULL, + NULL, + + /* copy */ + NULL, + NULL, + NULL, + NULL, + + /* read stream (single) */ + NULL, + NULL, + NULL, + NULL, + + /* read multiple stream */ + NULL, + generic_armv4_bs_rm_2, /* bus_space_read_multi_stream_2 */ + NULL, + NULL, + + /* read region stream */ + NULL, + NULL, + NULL, + NULL, + + /* write stream (single) */ + NULL, + NULL, + NULL, + NULL, + + /* write multiple stream */ + NULL, + generic_armv4_bs_wm_2, /* bus_space_write_multi_stream_2 */ + NULL, + NULL, + + /* write region stream */ + NULL, + NULL, + NULL, + NULL +}; + +bus_space_tag_t fdtbus_bs_tag = &_base_tag; diff --git a/sys/arm/samsung/exynos/common.c b/sys/arm/samsung/exynos/common.c new file mode 100644 index 0000000..658efc4 --- /dev/null +++ b/sys/arm/samsung/exynos/common.c @@ -0,0 +1,73 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/kernel.h> + +#include <dev/fdt/fdt_common.h> +#include <dev/ofw/openfirm.h> + +#include <machine/bus.h> +#include <machine/fdt.h> + +void +cpu_reset(void) +{ + bus_space_handle_t bsh; + + bus_space_map(fdtbus_bs_tag, 0x10040400, 0x1000, 0, &bsh); + bus_space_write_4(fdtbus_bs_tag, bsh, 0, 1); + + while (1); +} + +struct fdt_fixup_entry fdt_fixup_table[] = { + { NULL, NULL } +}; + +static int +fdt_pic_decode_ic(phandle_t node, pcell_t *intr, int *interrupt, int *trig, + int *pol) +{ + + if (!fdt_is_compatible(node, "arm,gic")) + return (ENXIO); + + *interrupt = fdt32_to_cpu(intr[0]); + *trig = INTR_TRIGGER_CONFORM; + *pol = INTR_POLARITY_CONFORM; + return (0); +} + +fdt_pic_decode_t fdt_pic_table[] = { + &fdt_pic_decode_ic, + NULL +}; diff --git a/sys/arm/samsung/exynos/ehci_exynos5.c b/sys/arm/samsung/exynos/ehci_exynos5.c new file mode 100644 index 0000000..ada0405 --- /dev/null +++ b/sys/arm/samsung/exynos/ehci_exynos5.c @@ -0,0 +1,367 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include "opt_bus.h" + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/bus.h> +#include <sys/condvar.h> +#include <sys/rman.h> + +#include <dev/ofw/ofw_bus.h> +#include <dev/ofw/ofw_bus_subr.h> + +#include <dev/usb/usb.h> +#include <dev/usb/usbdi.h> +#include <dev/usb/usb_busdma.h> +#include <dev/usb/usb_process.h> +#include <dev/usb/usb_controller.h> +#include <dev/usb/usb_bus.h> +#include <dev/usb/controller/ehci.h> +#include <dev/usb/controller/ehcireg.h> + +#include <dev/fdt/fdt_common.h> + +#include <machine/bus.h> +#include <machine/resource.h> + +#include "opt_platform.h" + +/* GPIO control */ +#define GPIO_CON(x, v) ((v) << ((x) * 4)) +#define GPIO_MASK 0xf +#define GPIO_OUTPUT 1 +#define GPIO_INPUT 0 +#define GPX3CON 0x0C60 +#define GPX3DAT 0x0C64 +#define PIN_USB 5 + +/* PWR control */ +#define EXYNOS5_PWR_USBHOST_PHY 0x708 +#define PHY_POWER_ON 1 +#define PHY_POWER_OFF 0 + +/* SYSREG */ +#define EXYNOS5_SYSREG_USB2_PHY 0x230 +#define USB2_MODE_HOST 0x1 + +/* USB HOST */ +#define HOST_CTRL_CLK_24MHZ (5 << 16) +#define HOST_CTRL_CLK_MASK (7 << 16) +#define HOST_CTRL_SIDDQ (1 << 6) +#define HOST_CTRL_SLEEP (1 << 5) +#define HOST_CTRL_SUSPEND (1 << 4) +#define HOST_CTRL_RESET_LINK (1 << 1) +#define HOST_CTRL_RESET_PHY (1 << 0) +#define HOST_CTRL_RESET_PHY_ALL (1 << 31) + +/* Forward declarations */ +static int exynos_ehci_attach(device_t dev); +static int exynos_ehci_detach(device_t dev); +static int exynos_ehci_probe(device_t dev); + +struct exynos_ehci_softc { + ehci_softc_t base; + struct resource *res[6]; + bus_space_tag_t host_bst; + bus_space_tag_t pwr_bst; + bus_space_tag_t sysreg_bst; + bus_space_tag_t gpio_bst; + bus_space_handle_t host_bsh; + bus_space_handle_t pwr_bsh; + bus_space_handle_t sysreg_bsh; + bus_space_handle_t gpio_bsh; + +}; + +static struct resource_spec exynos_ehci_spec[] = { + { SYS_RES_MEMORY, 0, RF_ACTIVE }, + { SYS_RES_MEMORY, 1, RF_ACTIVE }, + { SYS_RES_MEMORY, 2, RF_ACTIVE }, + { SYS_RES_MEMORY, 3, RF_ACTIVE }, + { SYS_RES_MEMORY, 4, RF_ACTIVE }, + { SYS_RES_IRQ, 0, RF_ACTIVE }, + { -1, 0 } +}; + +static device_method_t ehci_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, exynos_ehci_probe), + DEVMETHOD(device_attach, exynos_ehci_attach), + DEVMETHOD(device_detach, exynos_ehci_detach), + DEVMETHOD(device_suspend, bus_generic_suspend), + DEVMETHOD(device_resume, bus_generic_resume), + DEVMETHOD(device_shutdown, bus_generic_shutdown), + + /* Bus interface */ + DEVMETHOD(bus_print_child, bus_generic_print_child), + + { 0, 0 } +}; + +/* kobj_class definition */ +static driver_t ehci_driver = { + "ehci", + ehci_methods, + sizeof(ehci_softc_t) +}; + +static devclass_t ehci_devclass; + +DRIVER_MODULE(ehci, simplebus, ehci_driver, ehci_devclass, 0, 0); +MODULE_DEPEND(ehci, usb, 1, 1, 1); + +/* + * Public methods + */ +static int +exynos_ehci_probe(device_t dev) +{ + + if (ofw_bus_is_compatible(dev, "exynos,usb-ehci") == 0) + return (ENXIO); + + device_set_desc(dev, "Exynos integrated USB controller"); + return (BUS_PROBE_DEFAULT); +} + +static int +gpio_ctrl(struct exynos_ehci_softc *esc, int dir, int power) +{ + int reg; + + /* Power control */ + reg = bus_space_read_4(esc->gpio_bst, esc->gpio_bsh, GPX3DAT); + reg &= ~(1 << PIN_USB); + reg |= (power << PIN_USB); + bus_space_write_4(esc->gpio_bst, esc->gpio_bsh, GPX3DAT, reg); + + /* Input/Output control */ + reg = bus_space_read_4(esc->gpio_bst, esc->gpio_bsh, GPX3CON); + reg &= ~GPIO_CON(PIN_USB, GPIO_MASK); + reg |= GPIO_CON(PIN_USB, dir); + bus_space_write_4(esc->gpio_bst, esc->gpio_bsh, GPX3CON, reg); + + return (0); +} + +static int +phy_init(struct exynos_ehci_softc *esc) +{ + int reg; + + gpio_ctrl(esc, GPIO_INPUT, 1); + + /* set USB HOST mode */ + bus_space_write_4(esc->sysreg_bst, esc->sysreg_bsh, + EXYNOS5_SYSREG_USB2_PHY, USB2_MODE_HOST); + + /* Power ON phy */ + bus_space_write_4(esc->pwr_bst, esc->pwr_bsh, + EXYNOS5_PWR_USBHOST_PHY, PHY_POWER_ON); + + reg = bus_space_read_4(esc->host_bst, esc->host_bsh, 0x0); + reg &= ~(HOST_CTRL_CLK_MASK | + HOST_CTRL_RESET_PHY | + HOST_CTRL_RESET_PHY_ALL | + HOST_CTRL_SIDDQ | + HOST_CTRL_SUSPEND | + HOST_CTRL_SLEEP); + + reg |= (HOST_CTRL_CLK_24MHZ | + HOST_CTRL_RESET_LINK); + bus_space_write_4(esc->host_bst, esc->host_bsh, 0x0, reg); + + DELAY(10); + + reg = bus_space_read_4(esc->host_bst, esc->host_bsh, 0x0); + reg &= ~(HOST_CTRL_RESET_LINK); + bus_space_write_4(esc->host_bst, esc->host_bsh, 0x0, reg); + + gpio_ctrl(esc, GPIO_OUTPUT, 1); + + return (0); +} + +static int +exynos_ehci_attach(device_t dev) +{ + struct exynos_ehci_softc *esc; + ehci_softc_t *sc; + bus_space_handle_t bsh; + int err; + + esc = device_get_softc(dev); + sc = &esc->base; + sc->sc_bus.parent = dev; + sc->sc_bus.devices = sc->sc_devices; + sc->sc_bus.devices_max = EHCI_MAX_DEVICES; + + if (bus_alloc_resources(dev, exynos_ehci_spec, esc->res)) { + device_printf(dev, "could not allocate resources\n"); + return (ENXIO); + } + + /* EHCI registers */ + sc->sc_io_tag = rman_get_bustag(esc->res[0]); + bsh = rman_get_bushandle(esc->res[0]); + sc->sc_io_size = rman_get_size(esc->res[0]); + + /* EHCI HOST ctrl registers */ + esc->host_bst = rman_get_bustag(esc->res[1]); + esc->host_bsh = rman_get_bushandle(esc->res[1]); + + /* PWR registers */ + esc->pwr_bst = rman_get_bustag(esc->res[2]); + esc->pwr_bsh = rman_get_bushandle(esc->res[2]); + + /* SYSREG */ + esc->sysreg_bst = rman_get_bustag(esc->res[3]); + esc->sysreg_bsh = rman_get_bushandle(esc->res[3]); + + /* GPIO */ + esc->gpio_bst = rman_get_bustag(esc->res[4]); + esc->gpio_bsh = rman_get_bushandle(esc->res[4]); + + /* get all DMA memory */ + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(dev), + &ehci_iterate_hw_softc)) + return (ENXIO); + + /* + * Set handle to USB related registers subregion used by + * generic EHCI driver. + */ + err = bus_space_subregion(sc->sc_io_tag, bsh, 0x0, + sc->sc_io_size, &sc->sc_io_hdl); + if (err != 0) + return (ENXIO); + + phy_init(esc); + + /* Setup interrupt handler */ + err = bus_setup_intr(dev, esc->res[5], INTR_TYPE_BIO | INTR_MPSAFE, + NULL, (driver_intr_t *)ehci_interrupt, sc, + &sc->sc_intr_hdl); + if (err) { + device_printf(dev, "Could not setup irq, " + "%d\n", err); + return (1); + } + + /* Add USB device */ + sc->sc_bus.bdev = device_add_child(dev, "usbus", -1); + if (!sc->sc_bus.bdev) { + device_printf(dev, "Could not add USB device\n"); + err = bus_teardown_intr(dev, esc->res[5], + sc->sc_intr_hdl); + if (err) + device_printf(dev, "Could not tear down irq," + " %d\n", err); + return (1); + } + device_set_ivars(sc->sc_bus.bdev, &sc->sc_bus); + + strlcpy(sc->sc_vendor, "Samsung", sizeof(sc->sc_vendor)); + + err = ehci_init(sc); + if (!err) { + sc->sc_flags |= EHCI_SCFLG_DONEINIT; + err = device_probe_and_attach(sc->sc_bus.bdev); + } else { + device_printf(dev, "USB init failed err=%d\n", err); + + device_delete_child(dev, sc->sc_bus.bdev); + sc->sc_bus.bdev = NULL; + + err = bus_teardown_intr(dev, esc->res[5], + sc->sc_intr_hdl); + if (err) + device_printf(dev, "Could not tear down irq," + " %d\n", err); + return (1); + } + return (0); +} + +static int +exynos_ehci_detach(device_t dev) +{ + struct exynos_ehci_softc *esc; + ehci_softc_t *sc; + int err; + + esc = device_get_softc(dev); + sc = &esc->base; + + if (sc->sc_flags & EHCI_SCFLG_DONEINIT) + return (0); + + /* + * only call ehci_detach() after ehci_init() + */ + if (sc->sc_flags & EHCI_SCFLG_DONEINIT) { + ehci_detach(sc); + sc->sc_flags &= ~EHCI_SCFLG_DONEINIT; + } + + /* + * Disable interrupts that might have been switched on in + * ehci_init. + */ + if (sc->sc_io_tag && sc->sc_io_hdl) + bus_space_write_4(sc->sc_io_tag, sc->sc_io_hdl, + EHCI_USBINTR, 0); + + if (esc->res[5] && sc->sc_intr_hdl) { + err = bus_teardown_intr(dev, esc->res[5], + sc->sc_intr_hdl); + if (err) { + device_printf(dev, "Could not tear down irq," + " %d\n", err); + return (err); + } + sc->sc_intr_hdl = NULL; + } + + if (sc->sc_bus.bdev) { + device_delete_child(dev, sc->sc_bus.bdev); + sc->sc_bus.bdev = NULL; + } + + /* During module unload there are lots of children leftover */ + device_delete_children(dev); + + bus_release_resources(dev, exynos_ehci_spec, esc->res); + + return (0); +} diff --git a/sys/arm/samsung/exynos/exynos5_machdep.c b/sys/arm/samsung/exynos/exynos5_machdep.c new file mode 100644 index 0000000..4927aed --- /dev/null +++ b/sys/arm/samsung/exynos/exynos5_machdep.c @@ -0,0 +1,109 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include "opt_ddb.h" +#include "opt_platform.h" + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#define _ARM32_BUS_DMA_PRIVATE +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> + +#include <vm/vm.h> +#include <vm/pmap.h> + +#include <machine/bus.h> +#include <machine/frame.h> /* For trapframe_t, used in <machine/machdep.h> */ +#include <machine/machdep.h> +#include <machine/pmap.h> + +#include <dev/fdt/fdt_common.h> + +#define DEVMAP_BOOTSTRAP_MAP_START 0xE0000000 + +extern int unmapped_buf_allowed; + +vm_offset_t +initarm_lastaddr(void) +{ + + return (DEVMAP_BOOTSTRAP_MAP_START - ARM_NOCACHE_KVA_SIZE); +} + +void +initarm_gpio_init(void) +{ +} + +void +initarm_late_init(void) +{ + + /* XXX: PR arm/180080 */ + unmapped_buf_allowed = 0; +} + +#define FDT_DEVMAP_MAX (1 + 2 + 1 + 1) /* FIXME */ +static struct pmap_devmap fdt_devmap[FDT_DEVMAP_MAX] = { + { 0, 0, 0, 0, 0, } +}; + +/* + * Construct pmap_devmap[] with DT-derived config data. + */ +int +platform_devmap_init(void) +{ + int i; + + i = 0; + fdt_devmap[i].pd_va = 0xe2C00000; + fdt_devmap[i].pd_pa = 0x12C00000; + fdt_devmap[i].pd_size = 0x100000; + fdt_devmap[i].pd_prot = VM_PROT_READ | VM_PROT_WRITE; + fdt_devmap[i].pd_cache = PTE_NOCACHE; + i++; + + pmap_devmap_bootstrap_table = &fdt_devmap[0]; + return (0); +} + +struct arm32_dma_range * +bus_dma_get_range(void) +{ + + return (NULL); +} + +int +bus_dma_get_range_nb(void) +{ + + return (0); +} diff --git a/sys/arm/samsung/exynos/exynos5_mp.c b/sys/arm/samsung/exynos/exynos5_mp.c new file mode 100644 index 0000000..e99b61e --- /dev/null +++ b/sys/arm/samsung/exynos/exynos5_mp.c @@ -0,0 +1,92 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/lock.h> +#include <sys/mutex.h> +#include <sys/smp.h> + +#include <machine/smp.h> +#include <machine/fdt.h> +#include <machine/intr.h> + +#define EXYNOS_SYSRAM 0x02020000 + +void mpentry(void); +void mptramp(void); + +void +platform_mp_init_secondary(void) +{ + + gic_init_secondary(); +} + +void +platform_mp_setmaxid(void) +{ + + mp_maxid = 1; +} + +int +platform_mp_probe(void) +{ + + mp_ncpus = 2; + return (1); +} + +void +platform_mp_start_ap(void) +{ + bus_addr_t sysram; + int err; + + err = bus_space_map(fdtbus_bs_tag, EXYNOS_SYSRAM, 0x100, 0, &sysram); + if (err != 0) + panic("Couldn't map sysram\n"); + + bus_space_write_4(fdtbus_bs_tag, sysram, 0x0, + pmap_kextract((vm_offset_t)mpentry)); + + cpu_idcache_wbinv_all(); + cpu_l2cache_wbinv_all(); + + armv7_sev(); + bus_space_unmap(fdtbus_bs_tag, sysram, 0x100); +} + +void +platform_ipi_send(cpuset_t cpus, u_int ipi) +{ + + pic_ipi_send(cpus, ipi); +} diff --git a/sys/arm/samsung/exynos/files.exynos5 b/sys/arm/samsung/exynos/files.exynos5 new file mode 100644 index 0000000..e0b7407 --- /dev/null +++ b/sys/arm/samsung/exynos/files.exynos5 @@ -0,0 +1,24 @@ +# $FreeBSD$ + +kern/kern_clocksource.c standard + +arm/arm/bus_space_generic.c standard +arm/arm/bus_space_asm_generic.S standard +arm/arm/cpufunc_asm_armv5.S standard +arm/arm/cpufunc_asm_arm10.S standard +arm/arm/cpufunc_asm_arm11.S standard +arm/arm/cpufunc_asm_armv7.S standard +arm/arm/irq_dispatch.S standard + +arm/arm/gic.c standard +arm/arm/generic_timer.c standard + +arm/samsung/exynos/arch_timer.c standard +arm/samsung/exynos/exynos5_mp.c optional smp +arm/samsung/exynos/bus_space.c standard +arm/samsung/exynos/common.c standard +arm/samsung/exynos/exynos5_machdep.c standard +arm/samsung/exynos/uart.c optional uart +arm/samsung/exynos/ehci_exynos5.c optional ehci + +#dev/sdhci/sdhci_fdt.c optional sdhci diff --git a/sys/arm/samsung/exynos/std.exynos5 b/sys/arm/samsung/exynos/std.exynos5 new file mode 100644 index 0000000..58f692c --- /dev/null +++ b/sys/arm/samsung/exynos/std.exynos5 @@ -0,0 +1,23 @@ +# $FreeBSD$ + +makeoption ARM_LITTLE_ENDIAN + +cpu CPU_CORTEXA +machine arm armv6 + +options PHYSADDR=0x40000000 + +makeoptions KERNPHYSADDR=0x40f00000 +options KERNPHYSADDR=0x40f00000 + +makeoptions KERNVIRTADDR=0xc0f00000 +options KERNVIRTADDR=0xc0f00000 + +options STARTUP_PAGETABLE_ADDR=0x40100000 + +options ARM_L2_PIPT + +options IPI_IRQ_START=0 +options IPI_IRQ_END=15 + +files "../samsung/exynos/files.exynos5" diff --git a/sys/arm/samsung/exynos/uart.c b/sys/arm/samsung/exynos/uart.c new file mode 100644 index 0000000..eef99ff --- /dev/null +++ b/sys/arm/samsung/exynos/uart.c @@ -0,0 +1,377 @@ +/* + * Copyright (c) 2003 Marcel Moolenaar + * Copyright (c) 2007-2009 Andrew Turner + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE 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. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/conf.h> +#include <sys/cons.h> +#include <sys/tty.h> +#include <sys/rman.h> +#include <machine/bus.h> +#include <machine/intr.h> + +#include <dev/uart/uart.h> +#include <dev/uart/uart_cpu.h> +#include <dev/uart/uart_bus.h> + +#include <arm/samsung/exynos/uart.h> + +#include "uart_if.h" + +#define DEF_CLK 100000000 + +static int sscomspeed(long, long); +static int s3c24x0_uart_param(struct uart_bas *, int, int, int, int); + +/* + * Low-level UART interface. + */ +static int s3c2410_probe(struct uart_bas *bas); +static void s3c2410_init(struct uart_bas *bas, int, int, int, int); +static void s3c2410_term(struct uart_bas *bas); +static void s3c2410_putc(struct uart_bas *bas, int); +static int s3c2410_rxready(struct uart_bas *bas); +static int s3c2410_getc(struct uart_bas *bas, struct mtx *mtx); + +extern SLIST_HEAD(uart_devinfo_list, uart_devinfo) uart_sysdevs; + +static int +sscomspeed(long speed, long frequency) +{ + int x; + + if (speed <= 0 || frequency <= 0) + return (-1); + x = (frequency / 16) / speed; + return (x-1); +} + +static int +s3c24x0_uart_param(struct uart_bas *bas, int baudrate, int databits, + int stopbits, int parity) +{ + int brd, ulcon; + + ulcon = 0; + + switch(databits) { + case 5: + ulcon |= ULCON_LENGTH_5; + break; + case 6: + ulcon |= ULCON_LENGTH_6; + break; + case 7: + ulcon |= ULCON_LENGTH_7; + break; + case 8: + ulcon |= ULCON_LENGTH_8; + break; + default: + return (EINVAL); + } + + switch (parity) { + case UART_PARITY_NONE: + ulcon |= ULCON_PARITY_NONE; + break; + case UART_PARITY_ODD: + ulcon |= ULCON_PARITY_ODD; + break; + case UART_PARITY_EVEN: + ulcon |= ULCON_PARITY_EVEN; + break; + case UART_PARITY_MARK: + case UART_PARITY_SPACE: + default: + return (EINVAL); + } + + if (stopbits == 2) + ulcon |= ULCON_STOP; + + uart_setreg(bas, SSCOM_ULCON, ulcon); + + brd = sscomspeed(baudrate, bas->rclk); + uart_setreg(bas, SSCOM_UBRDIV, brd); + + return (0); +} + +struct uart_ops uart_s3c2410_ops = { + .probe = s3c2410_probe, + .init = s3c2410_init, + .term = s3c2410_term, + .putc = s3c2410_putc, + .rxready = s3c2410_rxready, + .getc = s3c2410_getc, +}; + +static int +s3c2410_probe(struct uart_bas *bas) +{ + + return (0); +} + +static void +s3c2410_init(struct uart_bas *bas, int baudrate, int databits, int stopbits, + int parity) +{ + + if (bas->rclk == 0) + bas->rclk = DEF_CLK; + + KASSERT(bas->rclk != 0, ("s3c2410_init: Invalid rclk")); + + uart_setreg(bas, SSCOM_UCON, 0); + uart_setreg(bas, SSCOM_UFCON, + UFCON_TXTRIGGER_8 | UFCON_RXTRIGGER_8 | + UFCON_TXFIFO_RESET | UFCON_RXFIFO_RESET | + UFCON_FIFO_ENABLE); + s3c24x0_uart_param(bas, baudrate, databits, stopbits, parity); + + /* Enable UART. */ + uart_setreg(bas, SSCOM_UCON, UCON_TXMODE_INT | UCON_RXMODE_INT | + UCON_TOINT); + uart_setreg(bas, SSCOM_UMCON, UMCON_RTS); +} + +static void +s3c2410_term(struct uart_bas *bas) +{ + /* XXX */ +} + +static void +s3c2410_putc(struct uart_bas *bas, int c) +{ + + while ((bus_space_read_4(bas->bst, bas->bsh, SSCOM_UFSTAT) & + UFSTAT_TXFULL) == UFSTAT_TXFULL) + continue; + + uart_setreg(bas, SSCOM_UTXH, c); +} + +static int +s3c2410_rxready(struct uart_bas *bas) +{ + + return ((uart_getreg(bas, SSCOM_UTRSTAT) & UTRSTAT_RXREADY) == + UTRSTAT_RXREADY); +} + +static int +s3c2410_getc(struct uart_bas *bas, struct mtx *mtx) +{ + int utrstat; + + utrstat = bus_space_read_1(bas->bst, bas->bsh, SSCOM_UTRSTAT); + while (!(utrstat & UTRSTAT_RXREADY)) { + utrstat = bus_space_read_1(bas->bst, bas->bsh, SSCOM_UTRSTAT); + continue; + } + + return (bus_space_read_1(bas->bst, bas->bsh, SSCOM_URXH)); +} + +static int s3c2410_bus_probe(struct uart_softc *sc); +static int s3c2410_bus_attach(struct uart_softc *sc); +static int s3c2410_bus_flush(struct uart_softc *, int); +static int s3c2410_bus_getsig(struct uart_softc *); +static int s3c2410_bus_ioctl(struct uart_softc *, int, intptr_t); +static int s3c2410_bus_ipend(struct uart_softc *); +static int s3c2410_bus_param(struct uart_softc *, int, int, int, int); +static int s3c2410_bus_receive(struct uart_softc *); +static int s3c2410_bus_setsig(struct uart_softc *, int); +static int s3c2410_bus_transmit(struct uart_softc *); + +static kobj_method_t s3c2410_methods[] = { + KOBJMETHOD(uart_probe, s3c2410_bus_probe), + KOBJMETHOD(uart_attach, s3c2410_bus_attach), + KOBJMETHOD(uart_flush, s3c2410_bus_flush), + KOBJMETHOD(uart_getsig, s3c2410_bus_getsig), + KOBJMETHOD(uart_ioctl, s3c2410_bus_ioctl), + KOBJMETHOD(uart_ipend, s3c2410_bus_ipend), + KOBJMETHOD(uart_param, s3c2410_bus_param), + KOBJMETHOD(uart_receive, s3c2410_bus_receive), + KOBJMETHOD(uart_setsig, s3c2410_bus_setsig), + KOBJMETHOD(uart_transmit, s3c2410_bus_transmit), + + {0, 0 } +}; + +int +s3c2410_bus_probe(struct uart_softc *sc) +{ + + sc->sc_txfifosz = 16; + sc->sc_rxfifosz = 16; + + return (0); +} + +static int +s3c2410_bus_attach(struct uart_softc *sc) +{ + + sc->sc_hwiflow = 0; + sc->sc_hwoflow = 0; + + return (0); +} + +static int +s3c2410_bus_transmit(struct uart_softc *sc) +{ + int i; + int reg; + + uart_lock(sc->sc_hwmtx); + + for (i = 0; i < sc->sc_txdatasz; i++) { + s3c2410_putc(&sc->sc_bas, sc->sc_txbuf[i]); + uart_barrier(&sc->sc_bas); + } + + sc->sc_txbusy = 1; + + uart_unlock(sc->sc_hwmtx); + + /* unmask TX interrupt */ + reg = bus_space_read_4(sc->sc_bas.bst, sc->sc_bas.bsh, SSCOM_UINTM); + reg &= ~(1 << 2); + bus_space_write_4(sc->sc_bas.bst, sc->sc_bas.bsh, SSCOM_UINTM, reg); + + return (0); +} + +static int +s3c2410_bus_setsig(struct uart_softc *sc, int sig) +{ + + return (0); +} + +static int +s3c2410_bus_receive(struct uart_softc *sc) +{ + + uart_rx_put(sc, uart_getreg(&sc->sc_bas, SSCOM_URXH)); + return (0); +} + +static int +s3c2410_bus_param(struct uart_softc *sc, int baudrate, int databits, + int stopbits, int parity) +{ + int error; + + if (sc->sc_bas.rclk == 0) + sc->sc_bas.rclk = DEF_CLK; + + KASSERT(sc->sc_bas.rclk != 0, ("s3c2410_init: Invalid rclk")); + + uart_lock(sc->sc_hwmtx); + error = s3c24x0_uart_param(&sc->sc_bas, baudrate, databits, stopbits, + parity); + uart_unlock(sc->sc_hwmtx); + + return (error); +} + +static int +s3c2410_bus_ipend(struct uart_softc *sc) +{ + uint32_t ints; + uint32_t txempty, rxready; + int reg; + int ipend; + + uart_lock(sc->sc_hwmtx); + ints = bus_space_read_4(sc->sc_bas.bst, sc->sc_bas.bsh, SSCOM_UINTP); + bus_space_write_4(sc->sc_bas.bst, sc->sc_bas.bsh, SSCOM_UINTP, ints); + + txempty = (1 << 2); + rxready = (1 << 0); + + ipend = 0; + if ((ints & txempty) > 0) { + if (sc->sc_txbusy != 0) + ipend |= SER_INT_TXIDLE; + + /* mask TX interrupt */ + reg = bus_space_read_4(sc->sc_bas.bst, sc->sc_bas.bsh, + SSCOM_UINTM); + reg |= (1 << 2); + bus_space_write_4(sc->sc_bas.bst, sc->sc_bas.bsh, + SSCOM_UINTM, reg); + } + + if ((ints & rxready) > 0) { + ipend |= SER_INT_RXREADY; + } + + uart_unlock(sc->sc_hwmtx); + return (ipend); +} + +static int +s3c2410_bus_flush(struct uart_softc *sc, int what) +{ + + return (0); +} + +static int +s3c2410_bus_getsig(struct uart_softc *sc) +{ + + return (0); +} + +static int +s3c2410_bus_ioctl(struct uart_softc *sc, int request, intptr_t data) +{ + + return (EINVAL); +} + +struct uart_class uart_s3c2410_class = { + "s3c2410 class", + s3c2410_methods, + 1, + .uc_ops = &uart_s3c2410_ops, + .uc_range = 8, + .uc_rclk = 0, +}; diff --git a/sys/arm/samsung/exynos/uart.h b/sys/arm/samsung/exynos/uart.h new file mode 100644 index 0000000..06afeff1 --- /dev/null +++ b/sys/arm/samsung/exynos/uart.h @@ -0,0 +1,126 @@ +/* $NetBSD: s3c2xx0reg.h,v 1.4 2004/02/12 03:47:29 bsh Exp $ */ + +/*- + * Copyright (c) 2002, 2003 Fujitsu Component Limited + * Copyright (c) 2002, 2003 Genetec Corporation + * 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. Neither the name of The Fujitsu Component Limited nor the name of + * Genetec corporation may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY FUJITSU COMPONENT LIMITED AND GENETEC + * CORPORATION ``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 FUJITSU COMPONENT LIMITED OR GENETEC + * CORPORATION 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. + * + * $FreeBSD$ + */ + +/* s3c2410-specific registers */ +#define UMCON_AFC (1 << 4) /* auto flow control */ +#define UMSTAT_DCTS (1 << 2) /* CTS change */ +#define ULCON_IR (1 << 6) +#define ULCON_PARITY_SHIFT 3 + +/* + * Exynos-specific + * + * UFSTAT_TXFULL register differs between Exynos and others. + * Others have UFSTAT_TXFULL (1 << 9) + */ +#define UFSTAT_TXFULL (1 << 24) + +#define SSCOM_UINTM 0x038 +#define SSCOM_UINTP 0x030 + +/* common for s3c2800 and s3c24x0 */ +#define SSCOM_ULCON 0x00 /* UART line control */ +#define ULCON_PARITY_NONE (0 << ULCON_PARITY_SHIFT) +#define ULCON_PARITY_ODD (4 << ULCON_PARITY_SHIFT) +#define ULCON_PARITY_EVEN (5 << ULCON_PARITY_SHIFT) +#define ULCON_PARITY_ONE (6 << ULCON_PARITY_SHIFT) +#define ULCON_PARITY_ZERO (7 << ULCON_PARITY_SHIFT) +#define ULCON_STOP (1 << 2) +#define ULCON_LENGTH_5 0 +#define ULCON_LENGTH_6 1 +#define ULCON_LENGTH_7 2 +#define ULCON_LENGTH_8 3 +#define SSCOM_UCON 0x04 /* UART control */ +#define UCON_TXINT_TYPE (1 << 9) /* Tx interrupt. 0=pulse,1=level */ +#define UCON_TXINT_TYPE_LEVEL UCON_TXINT_TYPE +#define UCON_TXINT_TYPE_PULSE 0 +#define UCON_RXINT_TYPE (1 << 8) /* Rx interrupt */ +#define UCON_RXINT_TYPE_LEVEL UCON_RXINT_TYPE +#define UCON_RXINT_TYPE_PULSE 0 +#define UCON_TOINT (1 << 7) /* Rx timeout interrupt */ +#define UCON_ERRINT (1 << 6) /* receive error interrupt */ +#define UCON_LOOP (1 << 5) /* loopback */ +#define UCON_SBREAK (1 << 4) /* send break */ +#define UCON_TXMODE_DISABLE (0 << 2) +#define UCON_TXMODE_INT (1 << 2) +#define UCON_TXMODE_DMA (2 << 2) +#define UCON_TXMODE_MASK (3 << 2) +#define UCON_RXMODE_DISABLE (0 << 0) +#define UCON_RXMODE_INT (1 << 0) +#define UCON_RXMODE_DMA (2 << 0) +#define UCON_RXMODE_MASK (3 << 0) +#define SSCOM_UFCON 0x08 /* FIFO control */ +#define UFCON_TXTRIGGER_0 (0 << 6) +#define UFCON_TXTRIGGER_4 (1 << 6) +#define UFCON_TXTRIGGER_8 (2 << 6) +#define UFCON_TXTRIGGER_16 (3 << 6) +#define UFCON_RXTRIGGER_4 (0 << 4) +#define UFCON_RXTRIGGER_8 (1 << 4) +#define UFCON_RXTRIGGER_12 (2 << 4) +#define UFCON_RXTRIGGER_16 (3 << 4) +#define UFCON_TXFIFO_RESET (1 << 2) +#define UFCON_RXFIFO_RESET (1 << 1) +#define UFCON_FIFO_ENABLE (1 << 0) +#define SSCOM_UMCON 0x0c /* MODEM control */ +#define UMCON_RTS (1 << 0) /* Request to send */ +#define SSCOM_UTRSTAT 0x10 /* Status register */ +#define UTRSTAT_TXSHIFTER_EMPTY ( 1<< 2) +#define UTRSTAT_TXEMPTY (1 << 1) /* TX fifo or buffer empty */ +#define UTRSTAT_RXREADY (1 << 0) /* RX fifo or buffer is not empty */ +#define SSCOM_UERSTAT 0x14 /* Error status register */ +#define UERSTAT_BREAK (1 << 3) /* Break signal, not 2410 */ +#define UERSTAT_FRAME (1 << 2) /* Frame error */ +#define UERSTAT_PARITY (1 << 1) /* Parity error, not 2410 */ +#define UERSTAT_OVERRUN (1 << 0) /* Overrun */ +#define UERSTAT_ALL_ERRORS \ + (UERSTAT_OVERRUN|UERSTAT_BREAK|UERSTAT_FRAME|UERSTAT_PARITY) +#define SSCOM_UFSTAT 0x18 /* Fifo status register */ +#define UFSTAT_RXFULL (1 <<8) /* Rx fifo full */ +#define UFSTAT_TXCOUNT_SHIFT 4 /* TX FIFO count */ +#define UFSTAT_TXCOUNT (0x0f << UFSTAT_TXCOUNT_SHIFT) +#define UFSTAT_RXCOUNT_SHIFT 0 /* RX FIFO count */ +#define UFSTAT_RXCOUNT (0x0f << UFSTAT_RXCOUNT_SHIFT) +#define SSCOM_UMSTAT 0x1c /* Modem status register */ +#define UMSTAT_CTS (1 << 0) /* Clear to send */ +#if _BYTE_ORDER == _LITTLE_ENDIAN +#define SSCOM_UTXH 0x20 /* Transmit data register */ +#define SSCOM_URXH 0x24 /* Receive data register */ +#else +#define SSCOM_UTXH 0x23 /* Transmit data register */ +#define SSCOM_URXH 0x27 /* Receive data register */ +#endif +#define SSCOM_UBRDIV 0x28 /* baud-reate divisor */ +#define SSCOM_SIZE 0x2c diff --git a/sys/arm/ti/am335x/am335x_pwm.c b/sys/arm/ti/am335x/am335x_pwm.c index c8135ca..d64e08f 100644 --- a/sys/arm/ti/am335x/am335x_pwm.c +++ b/sys/arm/ti/am335x/am335x_pwm.c @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); #include <sys/mutex.h> #include <sys/resource.h> #include <sys/rman.h> +#include <sys/sysctl.h> #include <machine/bus.h> @@ -50,6 +51,9 @@ __FBSDID("$FreeBSD$"); #include "am335x_pwm.h" #include "am335x_scm.h" +/* In ticks */ +#define DEFAULT_PWM_PERIOD 1000 + #define PWM_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) #define PWM_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) #define PWM_LOCK_INIT(_sc) mtx_init(&(_sc)->sc_mtx, \ @@ -96,15 +100,24 @@ static struct resource_spec am335x_pwm_mem_spec[] = { #define ECCTL2_TSCTRSTOP_FREERUN (1 << 4) #define EPWM_TBCTL 0x00 +#define TBCTL_FREERUN (2 << 14) #define TBCTL_PHDIR_UP (1 << 13) #define TBCTL_PHDIR_DOWN (0 << 13) #define TBCTL_CLKDIV(x) ((x) << 10) +#define TBCTL_CLKDIV_MASK (3 << 10) #define TBCTL_HSPCLKDIV(x) ((x) << 7) +#define TBCTL_HSPCLKDIV_MASK (3 << 7) #define TBCTL_SYNCOSEL_DISABLED (3 << 4) #define TBCTL_PRDLD_SHADOW (0 << 3) #define TBCTL_PRDLD_IMMEDIATE (0 << 3) #define TBCTL_PHSEN_ENABLED (1 << 2) #define TBCTL_PHSEN_DISABLED (0 << 2) +#define TBCTL_CTRMODE_MASK (3) +#define TBCTL_CTRMODE_UP (0 << 0) +#define TBCTL_CTRMODE_DOWN (1 << 0) +#define TBCTL_CTRMODE_UPDOWN (2 << 0) +#define TBCTL_CTRMODE_FREEZE (3 << 0) + #define EPWM_TBSTS 0x02 #define EPWM_TBPHSHR 0x04 #define EPWM_TBPHS 0x06 @@ -130,10 +143,14 @@ static struct resource_spec am335x_pwm_mem_spec[] = { /* CMPCTL_LOADAMODE_ZERO */ #define EPWM_AQCTLA 0x16 #define EPWM_AQCTLB 0x18 -#define AQCTL_CAU_NONE (0 << 0) -#define AQCTL_CAU_CLEAR (1 << 0) -#define AQCTL_CAU_SET (2 << 0) -#define AQCTL_CAU_TOGGLE (3 << 0) +#define AQCTL_CBU_NONE (0 << 8) +#define AQCTL_CBU_CLEAR (1 << 8) +#define AQCTL_CBU_SET (2 << 8) +#define AQCTL_CBU_TOGGLE (3 << 8) +#define AQCTL_CAU_NONE (0 << 4) +#define AQCTL_CAU_CLEAR (1 << 4) +#define AQCTL_CAU_SET (2 << 4) +#define AQCTL_CAU_TOGGLE (3 << 4) #define AQCTL_ZRO_NONE (0 << 0) #define AQCTL_ZRO_CLEAR (1 << 0) #define AQCTL_ZRO_SET (2 << 0) @@ -141,6 +158,15 @@ static struct resource_spec am335x_pwm_mem_spec[] = { #define EPWM_AQSFRC 0x1a #define EPWM_AQCSFRC 0x1c +/* Trip-Zone module */ +#define EPWM_TZCTL 0x28 +#define EPWM_TZFLG 0x2C +/* High-Resolution PWM */ +#define EPWM_HRCTL 0x40 +#define HRCTL_DELMODE_BOTH 3 +#define HRCTL_DELMODE_FALL 2 +#define HRCTL_DELMODE_RISE 1 + static device_probe_t am335x_pwm_probe; static device_attach_t am335x_pwm_attach; static device_detach_t am335x_pwm_detach; @@ -150,6 +176,13 @@ struct am335x_pwm_softc { struct mtx sc_mtx; struct resource *sc_mem_res[4]; int sc_id; + /* sysctl for configuration */ + struct sysctl_oid *sc_period_oid; + struct sysctl_oid *sc_chanA_oid; + struct sysctl_oid *sc_chanB_oid; + uint32_t sc_pwm_period; + uint32_t sc_pwm_dutyA; + uint32_t sc_pwm_dutyB; }; static device_method_t am335x_pwm_methods[] = { @@ -209,6 +242,71 @@ am335x_pwm_config_ecas(int unit, int period, int duty) } static int +am335x_pwm_sysctl_duty(SYSCTL_HANDLER_ARGS) +{ + struct am335x_pwm_softc *sc = (struct am335x_pwm_softc*)arg1; + int error; + uint32_t duty; + + if (oidp == sc->sc_chanA_oid) + duty = sc->sc_pwm_dutyA; + else + duty = sc->sc_pwm_dutyB; + error = sysctl_handle_int(oidp, &duty, 0, req); + + if (error != 0 || req->newptr == NULL) + return (error); + + if (duty > sc->sc_pwm_period) { + device_printf(sc->sc_dev, "Duty cycle can't be greater then period\n"); + return (EINVAL); + } + + PWM_LOCK(sc); + if (oidp == sc->sc_chanA_oid) { + sc->sc_pwm_dutyA = duty; + EPWM_WRITE2(sc, EPWM_CMPA, sc->sc_pwm_dutyA); + } + else { + sc->sc_pwm_dutyB = duty; + EPWM_WRITE2(sc, EPWM_CMPB, sc->sc_pwm_dutyB); + } + PWM_UNLOCK(sc); + + return (error); +} + +static int +am335x_pwm_sysctl_period(SYSCTL_HANDLER_ARGS) +{ + struct am335x_pwm_softc *sc = (struct am335x_pwm_softc*)arg1; + int error; + uint32_t period; + + period = sc->sc_pwm_period; + error = sysctl_handle_int(oidp, &period, 0, req); + + if (error != 0 || req->newptr == NULL) + return (error); + + if (period < 1) + return (EINVAL); + + if ((period < sc->sc_pwm_dutyA) || (period < sc->sc_pwm_dutyB)) { + device_printf(sc->sc_dev, "Period can't be less then duty cycle\n"); + return (EINVAL); + } + + + PWM_LOCK(sc); + sc->sc_pwm_period = period; + EPWM_WRITE2(sc, EPWM_TBPRD, period - 1); + PWM_UNLOCK(sc); + + return (error); +} + +static int am335x_pwm_probe(device_t dev) { if (!ofw_bus_is_compatible(dev, "ti,am335x-pwm")) @@ -227,6 +325,8 @@ am335x_pwm_attach(device_t dev) uint32_t reg; phandle_t node; pcell_t did; + struct sysctl_ctx_list *ctx; + struct sysctl_oid *tree; sc = device_get_softc(dev); sc->sc_dev = dev; @@ -252,6 +352,47 @@ am335x_pwm_attach(device_t dev) reg |= (1 << sc->sc_id); ti_scm_reg_write_4(SCM_PWMSS_CTRL, reg); + /* Init backlight interface */ + ctx = device_get_sysctl_ctx(sc->sc_dev); + tree = device_get_sysctl_tree(sc->sc_dev); + + sc->sc_period_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, + "period", CTLTYPE_INT | CTLFLAG_RW, sc, 0, + am335x_pwm_sysctl_period, "I", "PWM period"); + + sc->sc_chanA_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, + "dutyA", CTLTYPE_INT | CTLFLAG_RW, sc, 0, + am335x_pwm_sysctl_duty, "I", "Channel A duty cycles"); + + sc->sc_chanB_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, + "dutyB", CTLTYPE_INT | CTLFLAG_RW, sc, 0, + am335x_pwm_sysctl_duty, "I", "Channel B duty cycles"); + + + /* CONFIGURE EPWM1 */ + reg = EPWM_READ2(sc, EPWM_TBCTL); + reg &= ~(TBCTL_CLKDIV_MASK | TBCTL_HSPCLKDIV_MASK); + EPWM_WRITE2(sc, EPWM_TBCTL, reg); + + sc->sc_pwm_period = DEFAULT_PWM_PERIOD; + sc->sc_pwm_dutyA = 0; + sc->sc_pwm_dutyB = 0; + + EPWM_WRITE2(sc, EPWM_TBPRD, sc->sc_pwm_period - 1); + EPWM_WRITE2(sc, EPWM_CMPA, sc->sc_pwm_dutyA); + EPWM_WRITE2(sc, EPWM_CMPB, sc->sc_pwm_dutyB); + + EPWM_WRITE2(sc, EPWM_AQCTLA, (AQCTL_ZRO_SET | AQCTL_CAU_CLEAR)); + EPWM_WRITE2(sc, EPWM_AQCTLB, (AQCTL_ZRO_SET | AQCTL_CBU_CLEAR)); + + /* START EPWM */ + reg &= ~TBCTL_CTRMODE_MASK; + reg |= TBCTL_CTRMODE_UP | TBCTL_FREERUN; + EPWM_WRITE2(sc, EPWM_TBCTL, reg); + + EPWM_WRITE2(sc, EPWM_TZCTL, 0xf); + reg = EPWM_READ2(sc, EPWM_TZFLG); + return (0); fail: PWM_LOCK_DESTROY(sc); diff --git a/sys/arm/versatile/versatile_pci.c b/sys/arm/versatile/versatile_pci.c index 1ef92ef..131209a 100644 --- a/sys/arm/versatile/versatile_pci.c +++ b/sys/arm/versatile/versatile_pci.c @@ -173,16 +173,17 @@ versatile_pci_attach(device_t dev) /* * Setup memory windows */ - versatile_pci_core_write_4(PCI_CORE_IMAP0, (PCI_IO_WINDOW >> 11)); - versatile_pci_core_write_4(PCI_CORE_IMAP1, (PCI_NPREFETCH_WINDOW >> 11)); - versatile_pci_core_write_4(PCI_CORE_IMAP2, (PCI_PREFETCH_WINDOW >> 11)); + versatile_pci_core_write_4(PCI_CORE_IMAP0, (PCI_IO_WINDOW >> 28)); + versatile_pci_core_write_4(PCI_CORE_IMAP1, (PCI_NPREFETCH_WINDOW >> 28)); + versatile_pci_core_write_4(PCI_CORE_IMAP2, (PCI_PREFETCH_WINDOW >> 28)); /* * XXX: this is SDRAM offset >> 28 + * Unused as of QEMU 1.5 */ - versatile_pci_core_write_4(PCI_CORE_SMAP0, 0); - versatile_pci_core_write_4(PCI_CORE_SMAP1, 0); - versatile_pci_core_write_4(PCI_CORE_SMAP2, 0); + versatile_pci_core_write_4(PCI_CORE_SMAP0, (PCI_IO_WINDOW >> 28)); + versatile_pci_core_write_4(PCI_CORE_SMAP1, (PCI_NPREFETCH_WINDOW >> 28)); + versatile_pci_core_write_4(PCI_CORE_SMAP2, (PCI_NPREFETCH_WINDOW >> 28)); versatile_pci_sys_write_4(SYS_PCICTL, 1); @@ -307,7 +308,7 @@ versatile_pci_alloc_resource(device_t bus, device_t child, int type, int *rid, struct resource *rv; struct rman *rm; - printf("Alloc resources %d, %08lx..%08lx, %ld\n", type, start, end, count); + dprintf("Alloc resources %d, %08lx..%08lx, %ld\n", type, start, end, count); switch (type) { case SYS_RES_IOPORT: @@ -344,20 +345,23 @@ versatile_pci_activate_resource(device_t bus, device_t child, int type, int rid, struct resource *r) { vm_offset_t vaddr; - int res = (BUS_ACTIVATE_RESOURCE(device_get_parent(bus), - child, type, rid, r)); - - if (!res) { - switch(type) { - case SYS_RES_MEMORY: - case SYS_RES_IOPORT: - vaddr = (vm_offset_t)pmap_mapdev(rman_get_start(r), - rman_get_size(r)); - rman_set_bushandle(r, vaddr); - rman_set_bustag(r, versatile_bus_space_pcimem); - break; - } + int res; + + switch(type) { + case SYS_RES_MEMORY: + case SYS_RES_IOPORT: + vaddr = (vm_offset_t)pmap_mapdev(rman_get_start(r), + rman_get_size(r)); + rman_set_bushandle(r, vaddr); + rman_set_bustag(r, versatile_bus_space_pcimem); + res = rman_activate_resource(r); + break; + case SYS_RES_IRQ: + res = (BUS_ACTIVATE_RESOURCE(device_get_parent(bus), + child, type, rid, r)); + break; } + return (res); } diff --git a/sys/arm/versatile/versatile_sic.c b/sys/arm/versatile/versatile_sic.c index d3eee6e..f401c30 100644 --- a/sys/arm/versatile/versatile_sic.c +++ b/sys/arm/versatile/versatile_sic.c @@ -110,7 +110,7 @@ versatile_sic_attach(device_t dev) * Let PCI and Ethernet interrupts pass through * IRQ25, IRQ27..IRQ31 */ - pass_irqs = (7 << 27) | (1 << 25); + pass_irqs = (0x1f << 27) | (1 << 25); sic_write_4(sc, SIC_PICENSET, pass_irqs); return (0); diff --git a/sys/boot/fdt/dts/am335x.dtsi b/sys/boot/fdt/dts/am335x.dtsi index 482de9c..7a210b1 100644 --- a/sys/boot/fdt/dts/am335x.dtsi +++ b/sys/boot/fdt/dts/am335x.dtsi @@ -155,7 +155,7 @@ compatible = "ti,am335x-pwm"; #address-cells = <1>; #size-cells = <1>; - reg = < 0x48300000 0x100 /* PWMSS */ + reg = < 0x48300000 0x100 /* PWMSS0 */ 0x48300100 0x80 /* eCAP0 */ 0x48300180 0x80 /* eQEP0 */ 0x48300200 0x60 /* ePWM0 */ @@ -165,6 +165,34 @@ pwm-device-id = <0>; }; + pwm@48302000 { + compatible = "ti,am335x-pwm"; + #address-cells = <1>; + #size-cells = <1>; + reg = < 0x48302000 0x100 /* PWMSS1 */ + 0x48302100 0x80 /* eCAP1 */ + 0x48302180 0x80 /* eQEP1 */ + 0x48302200 0x60 /* ePWM1 */ + >; + interrupts = <87 59>; /* ePWM1INT, ePWM1_TZINT */ + interrupt-parent = <&AINTC>; + pwm-device-id = <1>; + }; + + pwm@48304000 { + compatible = "ti,am335x-pwm"; + #address-cells = <1>; + #size-cells = <1>; + reg = < 0x48304000 0x100 /* PWMSS2 */ + 0x48304100 0x80 /* eCAP2 */ + 0x48304180 0x80 /* eQEP2 */ + 0x48304200 0x60 /* ePWM2 */ + >; + interrupts = <88 60>; /* ePWM2INT, ePWM2_TZINT */ + interrupt-parent = <&AINTC>; + pwm-device-id = <2>; + }; + lcd: lcd@4830e000 { #address-cells = <1>; #size-cells = <0>; diff --git a/sys/boot/fdt/dts/bcm2835-rpi-b.dts b/sys/boot/fdt/dts/bcm2835.dtsi index 80bbef0..8078ee4 100644 --- a/sys/boot/fdt/dts/bcm2835-rpi-b.dts +++ b/sys/boot/fdt/dts/bcm2835.dtsi @@ -1,19 +1,33 @@ /* + * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@bluezbox.com> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * * $FreeBSD$ */ -/dts-v1/; -/memreserve/ 0x08000000 0x08000000; /* Set by VideoCore */ / { - model = "Raspberry Pi Model B (BCM2835)"; #address-cells = <1>; #size-cells = <1>; - compatible = "raspberrypi,model-b", "broadcom,bcm2835-vc", "broadcom,bcm2708-vc"; - - system { - revision = <0>; /* Set by VideoCore */ - serial = <0 0>; /* Set by VideoCore */ - }; cpus { cpu@0 { @@ -22,7 +36,7 @@ }; - axi { + SOC: axi { compatible = "simple-bus"; #address-cells = <1>; #size-cells = <1>; @@ -30,7 +44,8 @@ ranges = <0 0x20000000 0x01000000>; intc: interrupt-controller { - compatible = "broadcom,bcm2835-armctrl-ic", "broadcom,bcm2708-armctrl-ic"; + compatible = "broadcom,bcm2835-armctrl-ic", + "broadcom,bcm2708-armctrl-ic"; reg = <0xB200 0x200>; interrupt-controller; @@ -87,7 +102,8 @@ }; timer { - compatible = "broadcom,bcm2835-system-timer", "broadcom,bcm2708-system-timer"; + compatible = "broadcom,bcm2835-system-timer", + "broadcom,bcm2708-system-timer"; reg = <0x3000 0x1000>; interrupts = <8 9 10 11>; interrupt-parent = <&intc>; @@ -104,15 +120,18 @@ }; watchdog0 { - compatible = "broadcom,bcm2835-wdt", "broadcom,bcm2708-wdt"; + compatible = "broadcom,bcm2835-wdt", + "broadcom,bcm2708-wdt"; reg = <0x10001c 0x0c>; /* 0x1c, 0x20, 0x24 */ }; gpio: gpio { - compatible = "broadcom,bcm2835-gpio", "broadcom,bcm2708-gpio"; + compatible = "broadcom,bcm2835-gpio", + "broadcom,bcm2708-gpio"; reg = <0x200000 0xb0>; - /* Unusual arrangement of interrupts (determined by testing) + /* Unusual arrangement of interrupts + * (determined by testing) * 17: Bank 0 (GPIOs 0-31) * 19: Bank 1 (GPIOs 32-53) * 18: Bank 2 @@ -130,301 +149,256 @@ pinctrl-names = "default"; pinctrl-0 = <&pins_reserved>; - /* pins that can short 3.3V to GND in output mode: 46-47 - * pins used by VideoCore: 48-53 + /* Pins that can short 3.3V to GND in output mode: 46-47 + * Pins used by VideoCore: 48-53 */ - broadcom,read-only = <46>, <47>, <48>, <49>, <50>, <51>, <52>, <53>; + broadcom,read-only = <46>, <47>, <48>, <49>, <50>, + <51>, <52>, <53>; /* BSC0 */ pins_bsc0_a: bsc0_a { broadcom,pins = <0>, <1>; - broadcom,function = "ALT0"; }; pins_bsc0_b: bsc0_b { broadcom,pins = <28>, <29>; - broadcom,function = "ALT0"; }; pins_bsc0_c: bsc0_c { broadcom,pins = <44>, <45>; - broadcom,function = "ALT1"; }; /* BSC1 */ pins_bsc1_a: bsc1_a { broadcom,pins = <2>, <3>; - broadcom,function = "ALT0"; }; pins_bsc1_b: bsc1_b { broadcom,pins = <44>, <45>; - broadcom,function = "ALT2"; }; /* GPCLK0 */ pins_gpclk0_a: gpclk0_a { broadcom,pins = <4>; - broadcom,function = "ALT0"; }; pins_gpclk0_b: gpclk0_b { broadcom,pins = <20>; - broadcom,function = "ALT5"; }; pins_gpclk0_c: gpclk0_c { broadcom,pins = <32>; - broadcom,function = "ALT0"; }; pins_gpclk0_d: gpclk0_d { broadcom,pins = <34>; - broadcom,function = "ALT0"; }; /* GPCLK1 */ pins_gpclk1_a: gpclk1_a { broadcom,pins = <5>; - broadcom,function = "ALT0"; }; pins_gpclk1_b: gpclk1_b { broadcom,pins = <21>; - broadcom,function = "ALT5"; }; pins_gpclk1_c: gpclk1_c { broadcom,pins = <42>; - broadcom,function = "ALT0"; }; pins_gpclk1_d: gpclk1_d { broadcom,pins = <44>; - broadcom,function = "ALT0"; }; /* GPCLK2 */ pins_gpclk2_a: gpclk2_a { broadcom,pins = <6>; - broadcom,function = "ALT0"; }; pins_gpclk2_b: gpclk2_b { broadcom,pins = <43>; - broadcom,function = "ALT0"; }; /* SPI0 */ pins_spi0_a: spi0_a { broadcom,pins = <7>, <8>, <9>, <10>, <11>; - broadcom,function = "ALT0"; }; pins_spi0_b: spi0_b { broadcom,pins = <35>, <36>, <37>, <38>, <39>; - broadcom,function = "ALT0"; }; /* PWM */ pins_pwm0_a: pwm0_a { broadcom,pins = <12>; - broadcom,function = "ALT0"; }; pins_pwm0_b: pwm0_b { broadcom,pins = <18>; - broadcom,function = "ALT5"; }; pins_pwm0_c: pwm0_c { broadcom,pins = <40>; - broadcom,function = "ALT0"; }; pins_pwm1_a: pwm1_a { broadcom,pins = <13>; - broadcom,function = "ALT0"; }; pins_pwm1_b: pwm1_b { broadcom,pins = <19>; - broadcom,function = "ALT5"; }; pins_pwm1_c: pwm1_c { broadcom,pins = <41>; - broadcom,function = "ALT0"; }; pins_pwm1_d: pwm1_d { broadcom,pins = <45>; - broadcom,function = "ALT0"; }; /* UART0 */ pins_uart0_a: uart0_a { broadcom,pins = <14>, <15>; - broadcom,function = "ALT0"; }; pins_uart0_b: uart0_b { broadcom,pins = <32>, <33>; - broadcom,function = "ALT3"; }; pins_uart0_c: uart0_c { broadcom,pins = <36>, <37>; - broadcom,function = "ALT2"; }; pins_uart0_fc_a: uart0_fc_a { broadcom,pins = <16>, <17>; - broadcom,function = "ALT3"; }; pins_uart0_fc_b: uart0_fc_b { broadcom,pins = <30>, <31>; - broadcom,function = "ALT3"; }; pins_uart0_fc_c: uart0_fc_c { broadcom,pins = <39>, <38>; - broadcom,function = "ALT2"; }; /* PCM */ pins_pcm_a: pcm_a { broadcom,pins = <18>, <19>, <20>, <21>; - broadcom,function = "ALT0"; }; pins_pcm_b: pcm_b { broadcom,pins = <28>, <29>, <30>, <31>; - broadcom,function = "ALT2"; }; /* Secondary Address Bus */ pins_sm_addr_a: sm_addr_a { broadcom,pins = <5>, <4>, <3>, <2>, <1>, <0>; - broadcom,function = "ALT1"; }; pins_sm_addr_b: sm_addr_b { - broadcom,pins = <33>, <32>, <31>, <30>, <29>, <28>; - broadcom,function = "ALT1"; + broadcom,pins = <33>, <32>, <31>, <30>, <29>, + <28>; }; pins_sm_ctl_a: sm_ctl_a { broadcom,pins = <6>, <7>; - broadcom,function = "ALT1"; }; pins_sm_ctl_b: sm_ctl_b { broadcom,pins = <34>, <35>; - broadcom,function = "ALT1"; }; pins_sm_data_8bit_a: sm_data_8bit_a { - broadcom,pins = <8>, <9>, <10>, <11>, <12>, <13>, <14>, <15>; - broadcom,function = "ALT1"; + broadcom,pins = <8>, <9>, <10>, <11>, <12>, + <13>, <14>, <15>; }; pins_sm_data_8bit_b: sm_data_8bit_b { - broadcom,pins = <36>, <37>, <38>, <39>, <40>, <41>, <42>, <43>; - broadcom,function = "ALT1"; + broadcom,pins = <36>, <37>, <38>, <39>, <40>, + <41>, <42>, <43>; }; pins_sm_data_16bit: sm_data_16bit { - broadcom,pins = <16>, <17>, <18>, <19>, <20>, <21>, <22>, <23>; - broadcom,function = "ALT1"; + broadcom,pins = <16>, <17>, <18>, <19>, <20>, + <21>, <22>, <23>; }; pins_sm_data_18bit: sm_data_18bit { broadcom,pins = <24>, <25>; - broadcom,function = "ALT1"; }; /* BSCSL */ pins_bscsl: bscsl { broadcom,pins = <18>, <19>; - broadcom,function = "ALT3"; }; /* SPISL */ pins_spisl: spisl { broadcom,pins = <18>, <19>, <20>, <21>; - broadcom,function = "ALT3"; }; /* SPI1 */ pins_spi1: spi1 { - broadcom,pins = <16>, <17>, <18>, <19>, <20>, <21>; - broadcom,function = "ALT4"; + broadcom,pins = <16>, <17>, <18>, <19>, <20>, + <21>; }; /* UART1 */ pins_uart1_a: uart1_a { broadcom,pins = <14>, <15>; - broadcom,function = "ALT5"; }; pins_uart1_b: uart1_b { broadcom,pins = <32>, <33>; - broadcom,function = "ALT5"; }; pins_uart1_c: uart1_c { broadcom,pins = <40>, <41>; - broadcom,function = "ALT5"; }; pins_uart1_fc_a: uart1_fc_a { broadcom,pins = <16>, <17>; - broadcom,function = "ALT5"; }; pins_uart1_fc_b: uart1_fc_b { broadcom,pins = <30>, <31>; - broadcom,function = "ALT5"; }; pins_uart1_fc_c: uart1_fc_c { broadcom,pins = <43>, <42>; - broadcom,function = "ALT5"; }; /* SPI2 */ pins_spi2: spi2 { - broadcom,pins = <40>, <41>, <42>, <43>, <44>, <45>; - broadcom,function = "ALT4"; + broadcom,pins = <40>, <41>, <42>, <43>, <44>, + <45>; }; /* ARM JTAG */ pins_arm_jtag_trst: arm_jtag_trst { broadcom,pins = <22>; - broadcom,function = "ALT4"; }; pins_arm_jtag_a: arm_jtag_a { broadcom,pins = <4>, <5>, <6>, <12>, <13>; - broadcom,function = "ALT5"; }; pins_arm_jtag_b: arm_jtag_b { broadcom,pins = <23>, <24>, <25>, <26>, <27>; - broadcom,function = "ALT4"; }; /* Reserved */ pins_reserved: reserved { - broadcom,pins = <48>, <49>, <50>, <51>, <52>, <53>; - broadcom,function = "ALT3"; + broadcom,pins = <48>, <49>, <50>, <51>, <52>, + <53>; }; }; dma: dma { - compatible = "broadcom,bcm2835-dma", "broadcom,bcm2708-dma"; + compatible = "broadcom,bcm2835-dma", + "broadcom,bcm2708-dma"; reg = <0x7000 0x1000>, <0xE05000 0x1000>; interrupts = <24 25 26 27 28 29 30 31 32 33 34 35 36>; interrupt-parent = <&intc>; @@ -433,7 +407,8 @@ }; vc_mbox: mbox { - compatible = "broadcom,bcm2835-mbox", "broadcom,bcm2708-mbox"; + compatible = "broadcom,bcm2835-mbox", + "broadcom,bcm2708-mbox"; reg = <0xB880 0x40>; interrupts = <1>; interrupt-parent = <&intc>; @@ -450,7 +425,8 @@ }; sdhci { - compatible = "broadcom,bcm2835-sdhci", "broadcom,bcm2708-sdhci"; + compatible = "broadcom,bcm2835-sdhci", + "broadcom,bcm2708-sdhci"; reg = <0x300000 0x100>; interrupts = <70>; interrupt-parent = <&intc>; @@ -459,7 +435,9 @@ }; uart0: uart0 { - compatible = "broadcom,bcm2835-uart", "broadcom,bcm2708-uart", "arm,pl011", "arm,primecell"; + compatible = "broadcom,bcm2835-uart", + "broadcom,bcm2708-uart", "arm,pl011", + "arm,primecell"; reg = <0x201000 0x1000>; interrupts = <65>; interrupt-parent = <&intc>; @@ -476,104 +454,15 @@ }; usb { - compatible = "broadcom,bcm2835-usb", "broadcom,bcm2708-usb", "synopsys,designware-hs-otg2"; + compatible = "broadcom,bcm2835-usb", + "broadcom,bcm2708-usb", + "synopsys,designware-hs-otg2"; reg = <0x980000 0x20000>; interrupts = <17>; interrupt-parent = <&intc>; #address-cells = <1>; #size-cells = <0>; - hub { - compatible = "usb,hub", "usb,device"; - reg = <0x00000001>; - #address-cells = <1>; - #size-cells = <0>; - ethernet { - compatible = "net,ethernet", "usb,device"; - reg = <0x00000001>; - mac-address = [00 00 00 00 00 00]; - }; - }; - }; - - }; - - memory { - device_type = "memory"; - reg = <0 0x08000000>; /* 128MB */ - }; - - display { - compatible = "broadcom,bcm2835-fb", "broadcom,bcm2708-fb"; - - broadcom,vc-mailbox = <&vc_mbox>; - broadcom,vc-channel = <1>; - - broadcom,width = <0>; /* Set by VideoCore */ - broadcom,height = <0>; /* Set by VideoCore */ - broadcom,depth = <0>; /* Set by VideoCore */ - }; - - leds { - compatible = "gpio-leds"; - - ok { - label = "ok"; - gpios = <&gpio 16 1>; - - /* Don't change this - it configures - * how the led driver determines if - * the led is on or off when it loads. - */ - default-state = "keep"; - - /* This is the real default state. */ - linux,default-trigger = "default-on"; - }; - }; - - power: regulator { - compatible = "broadcom,bcm2835-power-mgr", "broadcom,bcm2708-power-mgr", "simple-bus"; - #address-cells = <1>; - #size-cells = <0>; - - broadcom,vc-mailbox = <&vc_mbox>; - broadcom,vc-channel = <0>; - - regulator-name = "VideoCore"; - regulator-min-microvolt = <5000000>; - regulator-max-microvolt = <5000000>; - regulator-always-on = <1>; - - sd_card_power: regulator@0 { - compatible = "broadcom,bcm2835-power-dev", "broadcom,bcm2708-power-dev"; - reg = <0>; - - vin-supply = <&power>; - regulator-name = "SD Card"; - regulator-min-microvolt = <3300000>; - regulator-max-microvolt = <3300000>; - }; - - /* This is for the controller itself, not the root port */ - usb_hcd_power: regulator@3 { - compatible = "broadcom,bcm2835-power-dev", "broadcom,bcm2708-power-dev"; - reg = <3>; - - vin-supply = <&power>; - regulator-name = "USB HCD"; - regulator-min-microvolt = <5000000>; - regulator-max-microvolt = <5000000>; }; - }; - - aliases { - uart0 = &uart0; - }; - chosen { - bootargs = ""; /* Set by VideoCore */ - stdin = "uart0"; - stdout = "uart0"; }; - }; diff --git a/sys/boot/fdt/dts/exynos5250-arndale.dts b/sys/boot/fdt/dts/exynos5250-arndale.dts new file mode 100644 index 0000000..67cadcb --- /dev/null +++ b/sys/boot/fdt/dts/exynos5250-arndale.dts @@ -0,0 +1,45 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/dts-v1/; + +/include/ "exynos5250.dtsi" + +/ { + model = "Arndale Board"; + + memory { + device_type = "memory"; + reg = < 0x40000000 0x80000000 >; /* 2G */ + }; + + chosen { + stdin = &serial2; + stdout = &serial2; + }; +}; diff --git a/sys/boot/fdt/dts/exynos5250.dtsi b/sys/boot/fdt/dts/exynos5250.dtsi new file mode 100644 index 0000000..860fcd0 --- /dev/null +++ b/sys/boot/fdt/dts/exynos5250.dtsi @@ -0,0 +1,157 @@ +/*- + * Copyright (c) 2013 Ruslan Bukin <br@bsdpad.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/ { + compatible = "samsung,exynos5250"; + #address-cells = <1>; + #size-cells = <1>; + interrupt-parent = <&GIC>; + + Exynos5@0 { + #address-cells = <1>; + #size-cells = <1>; + compatible = "simple-bus"; + ranges; + bus-frequency = <0>; + + GIC: interrupt-controller@10481000 { + compatible = "arm,gic"; + reg = < 0x10481000 0x1000 >, /* Distributor Registers */ + < 0x10482000 0x2000 >; /* CPU Interface Registers */ + interrupt-controller; + #address-cells = <0>; + #interrupt-cells = <1>; + }; + + mct { + compatible = "exynos,mct"; + reg = < 0x101C0000 0x1000 >; + clock-frequency = <24000000>; + }; + + generic_timer { + compatible = "arm,armv7-timer"; + clock-frequency = <24000000>; + }; + + pwm { + compatible = "samsung,s3c24x0-timer"; + reg = <0x12DD0000 0x1000>; + interrupts = < 71 >; + interrupt-parent = <&GIC>; + clock-frequency = <24000000>; + }; + + usb@12110000 { + compatible = "exynos,usb-ehci", "usb-ehci"; + reg = <0x12110000 0x1000>, /* EHCI */ + <0x12130000 0x1000>, /* EHCI host ctrl */ + <0x10040000 0x1000>, /* Power */ + <0x10050000 0x1000>, /* Sysreg */ + <0x11400000 0x1000>; /* GPIO left */ + interrupts = < 103 >; + interrupt-parent = <&GIC>; + }; + + usb@12120000 { + compatible = "exynos,usb-ohci", "usb-ohci"; + reg = <0x12120000 0x10000>; + interrupts = < 103 >; + interrupt-parent = <&GIC>; + }; + + sdhci@12200000 { + compatible = "sdhci_generic"; + reg = <0x12200000 0x1000>; + interrupts = <107>; + interrupt-parent = <&GIC>; + clock-frequency = <24000000>; /* TODO: verify freq */ + }; + + sdhci@12210000 { + compatible = "sdhci_generic"; + reg = <0x12210000 0x1000>; + interrupts = <108>; + interrupt-parent = <&GIC>; + clock-frequency = <24000000>; + }; + + sdhci@12220000 { + compatible = "sdhci_generic"; + reg = <0x12220000 0x1000>; + interrupts = <109>; + interrupt-parent = <&GIC>; + clock-frequency = <24000000>; + }; + + sdhci@12230000 { + compatible = "sdhci_generic"; + reg = <0x12230000 0x1000>; + interrupts = <110>; + interrupt-parent = <&GIC>; + clock-frequency = <24000000>; + }; + + serial0: serial@12C00000 { + compatible = "exynos"; + reg = <0x12C00000 0x100>; + interrupts = < 83 >; + interrupt-parent = <&GIC>; + clock-frequency = < 100000000 >; + current-speed = <115200>; + }; + + serial1: serial@12C10000 { + compatible = "exynos"; + reg = <0x12C10000 0x100>; + interrupts = < 84 >; + interrupt-parent = <&GIC>; + clock-frequency = < 100000000 >; + current-speed = <115200>; + }; + + serial2: serial@12C20000 { + compatible = "exynos"; + reg = <0x12C20000 0x100>; + interrupts = < 85 >; + interrupt-parent = <&GIC>; + clock-frequency = < 100000000 >; + current-speed = <115200>; + }; + + serial3: serial@12C30000 { + compatible = "exynos"; + reg = <0x12C30000 0x100>; + interrupts = < 86 >; + interrupt-parent = <&GIC>; + clock-frequency = < 100000000 >; + current-speed = <115200>; + }; + + }; +}; diff --git a/sys/boot/fdt/dts/rpi.dts b/sys/boot/fdt/dts/rpi.dts new file mode 100644 index 0000000..bdcee00 --- /dev/null +++ b/sys/boot/fdt/dts/rpi.dts @@ -0,0 +1,381 @@ +/* + * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@bluezbox.com> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ +/dts-v1/; + +/include/ "bcm2835.dtsi" + +/memreserve/ 0x08000000 0x08000000; /* Set by VideoCore */ + +/ { + model = "Raspberry Pi (BCM2835)"; + compatible = "raspberrypi,model-a", "raspberrypi,model-b", + "broadcom,bcm2835-vc", "broadcom,bcm2708-vc"; + + memory { + device_type = "memory"; + reg = <0 0x8000000>; /* 128MB, Set by VideoCore */ + + }; + + system { + revision = <0>; /* Set by VideoCore */ + serial = <0 0>; /* Set by VideoCore */ + }; + + axi { + gpio: gpio { + /* BSC0 */ + pins_bsc0_a: bsc0_a { + broadcom,function = "ALT0"; + }; + + pins_bsc0_b: bsc0_b { + broadcom,function = "ALT0"; + }; + + pins_bsc0_c: bsc0_c { + broadcom,function = "ALT1"; + }; + + /* BSC1 */ + pins_bsc1_a: bsc1_a { + broadcom,function = "ALT0"; + }; + + pins_bsc1_b: bsc1_b { + broadcom,function = "ALT2"; + }; + + /* GPCLK0 */ + pins_gpclk0_a: gpclk0_a { + broadcom,function = "ALT0"; + }; + + pins_gpclk0_b: gpclk0_b { + broadcom,function = "ALT5"; + }; + + pins_gpclk0_c: gpclk0_c { + broadcom,function = "ALT0"; + }; + + pins_gpclk0_d: gpclk0_d { + broadcom,function = "ALT0"; + }; + + /* GPCLK1 */ + pins_gpclk1_a: gpclk1_a { + broadcom,function = "ALT0"; + }; + + pins_gpclk1_b: gpclk1_b { + broadcom,function = "ALT5"; + }; + + pins_gpclk1_c: gpclk1_c { + broadcom,function = "ALT0"; + }; + + pins_gpclk1_d: gpclk1_d { + broadcom,function = "ALT0"; + }; + + /* GPCLK2 */ + pins_gpclk2_a: gpclk2_a { + broadcom,function = "ALT0"; + }; + + pins_gpclk2_b: gpclk2_b { + broadcom,function = "ALT0"; + }; + + /* SPI0 */ + pins_spi0_a: spi0_a { + broadcom,function = "ALT0"; + }; + + pins_spi0_b: spi0_b { + broadcom,function = "ALT0"; + }; + + /* PWM */ + pins_pwm0_a: pwm0_a { + broadcom,function = "ALT0"; + }; + + pins_pwm0_b: pwm0_b { + broadcom,function = "ALT5"; + }; + + pins_pwm0_c: pwm0_c { + broadcom,function = "ALT0"; + }; + + pins_pwm1_a: pwm1_a { + broadcom,function = "ALT0"; + }; + + pins_pwm1_b: pwm1_b { + broadcom,function = "ALT5"; + }; + + pins_pwm1_c: pwm1_c { + broadcom,function = "ALT0"; + }; + + pins_pwm1_d: pwm1_d { + broadcom,function = "ALT0"; + }; + + /* UART0 */ + pins_uart0_a: uart0_a { + broadcom,function = "ALT0"; + }; + + pins_uart0_b: uart0_b { + broadcom,function = "ALT3"; + }; + + pins_uart0_c: uart0_c { + broadcom,function = "ALT2"; + }; + + pins_uart0_fc_a: uart0_fc_a { + broadcom,function = "ALT3"; + }; + + pins_uart0_fc_b: uart0_fc_b { + broadcom,function = "ALT3"; + }; + + pins_uart0_fc_c: uart0_fc_c { + broadcom,function = "ALT2"; + }; + + /* PCM */ + pins_pcm_a: pcm_a { + broadcom,function = "ALT0"; + }; + + pins_pcm_b: pcm_b { + broadcom,function = "ALT2"; + }; + + /* Secondary Address Bus */ + pins_sm_addr_a: sm_addr_a { + broadcom,function = "ALT1"; + }; + + pins_sm_addr_b: sm_addr_b { + broadcom,function = "ALT1"; + }; + + pins_sm_ctl_a: sm_ctl_a { + broadcom,function = "ALT1"; + }; + + pins_sm_ctl_b: sm_ctl_b { + broadcom,function = "ALT1"; + }; + + pins_sm_data_8bit_a: sm_data_8bit_a { + broadcom,function = "ALT1"; + }; + + pins_sm_data_8bit_b: sm_data_8bit_b { + broadcom,function = "ALT1"; + }; + + pins_sm_data_16bit: sm_data_16bit { + broadcom,function = "ALT1"; + }; + + pins_sm_data_18bit: sm_data_18bit { + broadcom,function = "ALT1"; + }; + + /* BSCSL */ + pins_bscsl: bscsl { + broadcom,function = "ALT3"; + }; + + /* SPISL */ + pins_spisl: spisl { + broadcom,function = "ALT3"; + }; + + /* SPI1 */ + pins_spi1: spi1 { + broadcom,function = "ALT4"; + }; + + /* UART1 */ + pins_uart1_a: uart1_a { + broadcom,function = "ALT5"; + }; + + pins_uart1_b: uart1_b { + broadcom,function = "ALT5"; + }; + + pins_uart1_c: uart1_c { + broadcom,function = "ALT5"; + }; + + pins_uart1_fc_a: uart1_fc_a { + broadcom,function = "ALT5"; + }; + + pins_uart1_fc_b: uart1_fc_b { + broadcom,function = "ALT5"; + }; + + pins_uart1_fc_c: uart1_fc_c { + broadcom,function = "ALT5"; + }; + + /* SPI2 */ + pins_spi2: spi2 { + broadcom,function = "ALT4"; + }; + + /* ARM JTAG */ + pins_arm_jtag_trst: arm_jtag_trst { + broadcom,function = "ALT4"; + }; + + pins_arm_jtag_a: arm_jtag_a { + broadcom,function = "ALT5"; + }; + + pins_arm_jtag_b: arm_jtag_b { + broadcom,function = "ALT4"; + }; + + /* Reserved */ + pins_reserved: reserved { + broadcom,function = "ALT3"; + }; + }; + usb { + hub { + compatible = "usb,hub", "usb,device"; + reg = <0x00000001>; + #address-cells = <1>; + #size-cells = <0>; + ethernet { + compatible = "net,ethernet", + "usb,device"; + reg = <0x00000001>; + mac-address = [00 00 00 00 00 00]; + }; + }; + + }; + + + }; + + display { + compatible = "broadcom,bcm2835-fb", "broadcom,bcm2708-fb"; + + broadcom,vc-mailbox = <&vc_mbox>; + broadcom,vc-channel = <1>; + + broadcom,width = <0>; /* Set by VideoCore */ + broadcom,height = <0>; /* Set by VideoCore */ + broadcom,depth = <0>; /* Set by VideoCore */ + }; + + leds { + compatible = "gpio-leds"; + + ok { + label = "ok"; + gpios = <&gpio 16 1>; + + /* Don't change this - it configures + * how the led driver determines if + * the led is on or off when it loads. + */ + default-state = "keep"; + + /* This is the real default state. */ + linux,default-trigger = "default-on"; + }; + }; + + power: regulator { + compatible = "broadcom,bcm2835-power-mgr", + "broadcom,bcm2708-power-mgr", + "simple-bus"; + #address-cells = <1>; + #size-cells = <0>; + + broadcom,vc-mailbox = <&vc_mbox>; + broadcom,vc-channel = <0>; + + regulator-name = "VideoCore"; + regulator-min-microvolt = <5000000>; + regulator-max-microvolt = <5000000>; + regulator-always-on = <1>; + + sd_card_power: regulator@0 { + compatible = "broadcom,bcm2835-power-dev", + "broadcom,bcm2708-power-dev"; + reg = <0>; + + vin-supply = <&power>; + regulator-name = "SD Card"; + regulator-min-microvolt = <3300000>; + regulator-max-microvolt = <3300000>; + }; + + /* This is for the controller itself, not the root port */ + usb_hcd_power: regulator@3 { + compatible = "broadcom,bcm2835-power-dev", + "broadcom,bcm2708-power-dev"; + reg = <3>; + + vin-supply = <&power>; + regulator-name = "USB HCD"; + regulator-min-microvolt = <5000000>; + regulator-max-microvolt = <5000000>; + }; + }; + + aliases { + uart0 = &uart0; + }; + + chosen { + bootargs = ""; /* Set by VideoCore */ + stdin = "uart0"; + stdout = "uart0"; + }; + +}; diff --git a/sys/boot/i386/gptboot/Makefile b/sys/boot/i386/gptboot/Makefile index e1a640a..7fb0336 100644 --- a/sys/boot/i386/gptboot/Makefile +++ b/sys/boot/i386/gptboot/Makefile @@ -3,6 +3,7 @@ .PATH: ${.CURDIR}/../boot2 ${.CURDIR}/../common ${.CURDIR}/../../common FILES= gptboot +MAN= gptboot.8 NM?= nm diff --git a/sys/boot/i386/gptboot/gptboot.8 b/sys/boot/i386/gptboot/gptboot.8 new file mode 100644 index 0000000..691bcb7 --- /dev/null +++ b/sys/boot/i386/gptboot/gptboot.8 @@ -0,0 +1,238 @@ +.\" Copyright (c) 2013 Warren Block +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $FreeBSD$ +.\" +.Dd July 3, 2013 +.Dt GPTBOOT 8 +.Os +.Sh NAME +.Nm gptboot +.Nd GPT bootcode for UFS on BIOS-based computers +.Sh DESCRIPTION +.Nm +is used on BIOS-based computers to boot from a UFS partition on a +GPT-partitioned disk. +.Nm +is installed in a +.Cm freebsd-boot +partition with +.Xr gpart 8 . +.Sh IMPLEMENTATION NOTES +The GPT standard allows a variable number of partitions, but +.Nm +only boots from tables with 128 partitions or less. +.Sh PARTITION ATTRIBUTES +.Nm +checks and manages several attributes of GPT UFS partitions. +.Bl -tag -width ".Cm bootfailed" +.It Cm bootme +Attempt to boot from this partition. +If more than one partition has the +.Cm bootme +attribute set, +.Nm +will attempt to boot each one until successful. +.It Cm bootonce +Attempt to boot from this partition only one time. +Setting this attribute with +.Xr gpart 8 +automatically also sets the +.Cm bootme +attribute. +Multiple partitions may have the +.Cm bootonce +and +.Cm bootme +attributes set. +.It Cm bootfailed +The +.Cm bootfailed +attribute marks partitions that had the +.Cm bootonce +attribute set, but failed to boot. +This attribute is managed by the system. +See +.Sx "BOOTING" +and +.Sx "POST-BOOT ACTIONS" +below for details. +.El +.Sh USAGE +For normal usage, the user does not have to set or manage any of the +partition attributes. +.Nm +will boot from the first UFS partition found. +.Pp +The +.Cm bootonce +attribute can be used for testing an upgraded operating system on +an already-working computer. +The existing system partition is left untouched, and the new version +of the operating system to be tested is installed on another partition. +The +.Cm bootonce +attribute is set on that new test partition. +The next boot is attempted from the test partition. +Success or failure will be shown in the system log files. +After a successful boot of the test partition, a user script can check +the logs and change the +.Cm bootme +attributes so the test partition becomes the new system partition. +Because the +.Cm bootonce +attribute is cleared after an attempted boot, a failed boot will not +leave the system attempting to boot from a partition that will never +succeed. +Instead, the system will boot from the older, known-working operating +system that has not been modified. +If the +.Cm bootme +attribute is set on any partitions, booting will be attempted from them +first. +If no partitions with +.Cm bootme +attributes are found, booting will be attempted from the first UFS +partition found. +.Sh BOOTING +.Nm +first reads the partition table. +All +.Cm freebsd-ufs +partitions with only the +.Cm bootonce +attribute set, indicating a failed boot, are set to +.Cm bootfailed . +.Nm +then scans through all of the +.Cm freebsd-ufs +partitions. +Boot behavior depends on the combination of +.Cm bootme +and +.Cm bootonce +attributes set on those partitions. +.Bl -tag -width ".Cm bootonce + .Cm bootme" +.It Cm bootonce + Cm bootme +Highest priority: booting is attempted from each of the +.Cm freebsd-ufs +partitions with both of these attributes. +On each partition, the +.Cm bootme +attribute is removed and the boot attempted. +.It Cm bootme +Middle priority: booting is attempted from each of the +.Cm freebsd-ufs +partitions with the +.Cm bootme +attribute. +.El +.Pp +If neither +.Cm bootonce +nor +.Cm bootme +attributes are found on any partitions, booting is attempted from the +first +.Cm freebsd-ufs +partition on the disk. +.Sh POST-BOOT ACTIONS +The startup script +.Pa /etc/rc.d/gptboot +checks the attributes of +.Cm freebsd-ufs +partitions on all GPT disks. +Partitions with the +.Cm bootfailed +attribute generate a +.Dq boot from X failed +system log message. +Partitions with only the +.Cm bootonce +attribute, indicating a partition that successfully booted, generate a +.Dq boot from X succeeded +system log message. +The +.Cm bootfailed +attributes are cleared from all the partitions. +The +.Cm bootonce +attribute is cleared from the partition that successfully booted. +There is normally only one of these. +.Sh FILES +.Bl -tag -width /boot/gptboot -compact +.It Pa /boot/gptboot +bootcode binary +.It Pa /boot.config +parameters for the boot blocks +.Pq optional +.El +.Sh EXAMPLES +.Nm +is typically installed in combination with a +.Dq protective MBR +.Po +see +.Xr gpart 8 +.Pc . +Install +.Nm +on the +.Pa ada0 +drive: +.Bd -literal -offset indent +gpart bootcode -b /boot/pmbr -p /boot/gptboot -i 1 ada0 +.Ed +.Pp +.Nm +can also be installed without the PMBR: +.Bd -literal -offset indent +gpart bootcode -p /boot/gptboot -i 1 ada0 +.Ed +.Pp +Set the +.Cm bootme +attribute for partition 2: +.Bd -literal -offset indent +gpart set -a bootme -i 2 ada0 +.Ed +.Pp +Set the +.Cm bootonce +attribute for partition 2, automatically also setting the +.Cm bootme +attribute: +.Bd -literal -offset indent +gpart set -a bootonce -i 2 ada0 +.Ed +.Sh SEE ALSO +.Xr boot.config 5 , +.Xr rc.conf 5 , +.Xr boot 8 , +.Xr gpart 8 +.Sh HISTORY +.Nm +appeared in FreeBSD 7.1. +.Sh AUTHORS +Warren Block <wblock@FreeBSD.org> diff --git a/sys/cam/cam_ccb.h b/sys/cam/cam_ccb.h index 35296ce..04ed592 100644 --- a/sys/cam/cam_ccb.h +++ b/sys/cam/cam_ccb.h @@ -1296,6 +1296,19 @@ cam_fill_smpio(struct ccb_smpio *smpio, uint32_t retries, smpio->smp_response_len = smp_response_len; } +static __inline void +cam_set_ccbstatus(union ccb *ccb, cam_status status) +{ + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= status; +} + +static __inline cam_status +cam_ccb_status(union ccb *ccb) +{ + return ((cam_status)(ccb->ccb_h.status & CAM_STATUS_MASK)); +} + void cam_calc_geometry(struct ccb_calc_geometry *ccg, int extended); __END_DECLS diff --git a/sys/cam/ctl/ctl_backend_ramdisk.c b/sys/cam/ctl/ctl_backend_ramdisk.c index 985fad4..63cc4e0 100644 --- a/sys/cam/ctl/ctl_backend_ramdisk.c +++ b/sys/cam/ctl/ctl_backend_ramdisk.c @@ -441,6 +441,9 @@ ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc, snprintf(req->error_str, sizeof(req->error_str), "%s: error %d returned from ctl_invalidate_lun() for " "LUN %d", __func__, retval, params->lun_id); + mtx_lock(&softc->lock); + be_lun->flags &= ~CTL_BE_RAMDISK_LUN_WAITING; + mtx_unlock(&softc->lock); goto bailout_error; } @@ -475,14 +478,6 @@ ctl_backend_ramdisk_rm(struct ctl_be_ramdisk_softc *softc, return (retval); bailout_error: - - /* - * Don't leave the waiting flag set. - */ - mtx_lock(&softc->lock); - be_lun->flags &= ~CTL_BE_RAMDISK_LUN_WAITING; - mtx_unlock(&softc->lock); - req->status = CTL_LUN_ERROR; return (0); diff --git a/sys/cam/scsi/scsi_da.c b/sys/cam/scsi/scsi_da.c index e0e33d6..7988309 100644 --- a/sys/cam/scsi/scsi_da.c +++ b/sys/cam/scsi/scsi_da.c @@ -1746,7 +1746,7 @@ dadeletemaxsysctl(SYSCTL_HANDLER_ARGS) return (error); /* only accept values smaller than the calculated value */ - if (value > softc->disk->d_delmaxsize) { + if (value > dadeletemaxsize(softc, softc->delete_method)) { return (EINVAL); } softc->disk->d_delmaxsize = value; diff --git a/sys/cam/scsi/scsi_xpt.c b/sys/cam/scsi/scsi_xpt.c index 74bfb0a..9269f36 100644 --- a/sys/cam/scsi/scsi_xpt.c +++ b/sys/cam/scsi/scsi_xpt.c @@ -974,7 +974,7 @@ proberequestdefaultnegotiation(struct cam_periph *periph) cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; cts.type = CTS_TYPE_USER_SETTINGS; xpt_action((union ccb *)&cts); - if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status((union ccb *)&cts) != CAM_REQ_CMP) { return; } cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; @@ -996,7 +996,7 @@ proberequestbackoff(struct cam_periph *periph, struct cam_ed *device) cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; cts.type = CTS_TYPE_CURRENT_SETTINGS; xpt_action((union ccb *)&cts); - if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status((union ccb *)&cts) != CAM_REQ_CMP) { if (bootverbose) { xpt_print(periph->path, "failed to get current device settings\n"); @@ -1075,7 +1075,7 @@ proberequestbackoff(struct cam_periph *periph, struct cam_ed *device) cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; cts.type = CTS_TYPE_CURRENT_SETTINGS; xpt_action((union ccb *)&cts); - if ((cts.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { + if (cam_ccb_status((union ccb *)&cts) != CAM_REQ_CMP) { break; } CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, @@ -1105,7 +1105,7 @@ probedone(struct cam_periph *periph, union ccb *done_ccb) switch (softc->action) { case PROBE_TUR: { - if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status(done_ccb) != CAM_REQ_CMP) { if (cam_periph_error(done_ccb, 0, SF_NO_PRINT, NULL) == ERESTART) { @@ -1128,7 +1128,7 @@ out: case PROBE_INQUIRY: case PROBE_FULL_INQUIRY: { - if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { + if (cam_ccb_status(done_ccb) == CAM_REQ_CMP) { struct scsi_inquiry_data *inq_buf; u_int8_t periph_qual; @@ -1246,7 +1246,7 @@ out: nlun = scsi_4btoul(lp->length) / 8; maxlun = (csio->dxfer_len / 8) - 1; - if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status(done_ccb) != CAM_REQ_CMP) { if (cam_periph_error(done_ccb, 0, done_ccb->ccb_h.target_lun > 0 ? SF_RETRY_UA|SF_QUIET_IR : SF_RETRY_UA, @@ -1357,7 +1357,7 @@ out: csio = &done_ccb->csio; mode_hdr = (struct scsi_mode_header_6 *)csio->data_ptr; - if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { + if (cam_ccb_status(done_ccb) == CAM_REQ_CMP) { struct scsi_control_page *page; u_int8_t *offset; @@ -1492,7 +1492,7 @@ probe_device_check: /* * Don't process the command as it was never sent */ - } else if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP + } else if (cam_ccb_status(done_ccb) == CAM_REQ_CMP && (serial_buf->length > 0)) { have_serialnum = 1; @@ -1577,7 +1577,7 @@ probe_device_check: } case PROBE_TUR_FOR_NEGOTIATION: case PROBE_DV_EXIT: - if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status(done_ccb) != CAM_REQ_CMP) { cam_periph_error(done_ccb, 0, SF_NO_PRINT | SF_NO_RECOVERY | SF_NO_RETRY, NULL); } @@ -1628,7 +1628,7 @@ probe_device_check: struct scsi_inquiry_data *nbuf; struct ccb_scsiio *csio; - if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status(done_ccb) != CAM_REQ_CMP) { cam_periph_error(done_ccb, 0, SF_NO_PRINT | SF_NO_RECOVERY | SF_NO_RETRY, NULL); } @@ -1984,7 +1984,7 @@ scsi_scan_bus(struct cam_periph *periph, union ccb *request_ccb) oldpath = request_ccb->ccb_h.path; - status = request_ccb->ccb_h.status & CAM_STATUS_MASK; + status = cam_ccb_status(request_ccb); /* Reuse the same CCB to query if a device was really found */ scan_info = (scsi_scan_bus_info *)request_ccb->ccb_h.ppriv_ptr0; xpt_setup_ccb(&request_ccb->ccb_h, request_ccb->ccb_h.path, @@ -2667,7 +2667,7 @@ scsi_set_transfer_settings(struct ccb_trans_settings *cts, struct cam_ed *device cur_cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; cur_cts.type = cts->type; xpt_action((union ccb *)&cur_cts); - if ((cur_cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { + if (cam_ccb_status((union ccb *)&cur_cts) != CAM_REQ_CMP) { return; } cur_scsi = &cur_cts.proto_specific.scsi; @@ -2951,7 +2951,7 @@ scsi_announce_periph(struct cam_periph *periph) cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; cts.type = CTS_TYPE_CURRENT_SETTINGS; xpt_action((union ccb*)&cts); - if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) + if (cam_ccb_status((union ccb *)&cts) != CAM_REQ_CMP) return; /* Ask the SIM for its base transfer speed */ xpt_setup_ccb(&cpi.ccb_h, path, CAM_PRIORITY_NORMAL); diff --git a/sys/cddl/compat/opensolaris/kern/opensolaris_cmn_err.c b/sys/cddl/compat/opensolaris/kern/opensolaris_cmn_err.c index f1e4c18..7ae498b 100644 --- a/sys/cddl/compat/opensolaris/kern/opensolaris_cmn_err.c +++ b/sys/cddl/compat/opensolaris/kern/opensolaris_cmn_err.c @@ -75,7 +75,8 @@ cmn_err(int type, const char *fmt, ...) } int -assfail(const char *a, const char *f, int l) { +assfail(const char *a, const char *f, int l) +{ panic("solaris assert: %s, file: %s, line: %d", a, f, l); @@ -84,7 +85,8 @@ assfail(const char *a, const char *f, int l) { void assfail3(const char *a, uintmax_t lv, const char *op, uintmax_t rv, - const char *f, int l) { + const char *f, int l) +{ panic("solaris assert: %s (0x%jx %s 0x%jx), file: %s, line: %d", a, lv, op, rv, f, l); diff --git a/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c b/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c index fee9efa..f51df4c 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c +++ b/sys/cddl/contrib/opensolaris/uts/common/dtrace/fasttrap.c @@ -2435,6 +2435,7 @@ fasttrap_unload(void) mtx_sleep(&fasttrap_cleanup_drain, &fasttrap_cleanup_mtx, 0, "ftcld", 0); fasttrap_cleanup_proc = NULL; + mtx_destroy(&fasttrap_cleanup_mtx); #ifdef DEBUG mutex_enter(&fasttrap_count_mtx); diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_dir.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_dir.c index b0bac9c..7d0b104 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_dir.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_dir.c @@ -1258,8 +1258,6 @@ dsl_dir_rename_sync(void *arg, dmu_tx_t *tx) int error; objset_t *mos = dp->dp_meta_objset; - ASSERT(dmu_buf_refcount(dd->dd_dbuf) <= 2); - VERIFY0(dsl_dir_hold(dp, ddra->ddra_oldname, FTAG, &dd, NULL)); VERIFY0(dsl_dir_hold(dp, ddra->ddra_newname, FTAG, &newparent, &mynewname)); diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zvol.h b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zvol.h index c813797..52b8f30 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zvol.h +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zvol.h @@ -71,7 +71,7 @@ extern void zvol_log_write_minor(void *minor_hdl, dmu_tx_t *tx, offset_t off, ssize_t resid, boolean_t sync); #endif /* sun */ -#ifdef __FreeBSD__ +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) extern int zvol_create_minors(const char *name); extern void zvol_rename_minors(const char *oldname, const char *newname); #endif diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_acl.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_acl.c index 3200e7e..6545dc2 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_acl.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_acl.c @@ -1683,7 +1683,7 @@ zfs_acl_ids_create(znode_t *dzp, int flag, vattr_t *vap, cred_t *cr, } else { acl_ids->z_fgid = zfs_fuid_create_cred(zfsvfs, ZFS_GROUP, cr, &acl_ids->z_fuidp); -#ifdef __FreeBSD__ +#ifdef __FreeBSD_kernel__ gid = acl_ids->z_fgid = dzp->z_gid; #else gid = crgetgid(cr); @@ -2374,7 +2374,7 @@ zfs_zaccess(znode_t *zp, int mode, int flags, boolean_t skipaclchk, cred_t *cr) is_attr = ((zp->z_pflags & ZFS_XATTR) && (ZTOV(zp)->v_type == VDIR)); -#ifdef __FreeBSD__ +#ifdef __FreeBSD_kernel__ /* * In FreeBSD, we don't care about permissions of individual ADS. * Note that not checking them is not just an optimization - without diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_dir.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_dir.c index ac1aa42..c076775 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_dir.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_dir.c @@ -938,7 +938,7 @@ zfs_make_xattrdir(znode_t *zp, vattr_t *vap, vnode_t **xvpp, cred_t *cr) * In FreeBSD, access checking for creating an EA is being done * in zfs_setextattr(), */ -#ifndef __FreeBSD__ +#ifndef __FreeBSD_kernel__ if (error = zfs_zaccess(zp, ACE_WRITE_NAMED_ATTRS, 0, B_FALSE, cr)) return (error); #endif diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_ioctl.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_ioctl.c index ff9067e..a4ae7aa 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_ioctl.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_ioctl.c @@ -5570,6 +5570,13 @@ zfs_ioctl_init(void) zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT, zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); + +#ifdef __FreeBSD__ + zfs_ioctl_register_dataset_nolog(ZFS_IOC_JAIL, zfs_ioc_jail, + zfs_secpolicy_config, POOL_CHECK_NONE); + zfs_ioctl_register_dataset_nolog(ZFS_IOC_UNJAIL, zfs_ioc_unjail, + zfs_secpolicy_config, POOL_CHECK_NONE); +#endif } int diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vfsops.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vfsops.c index fec6be4..665627d 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vfsops.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vfsops.c @@ -173,7 +173,7 @@ zfs_sync(vfs_t *vfsp, int waitfor) return (0); } -#ifndef __FreeBSD__ +#ifndef __FreeBSD_kernel__ static int zfs_create_unique_device(dev_t *dev) { @@ -225,7 +225,7 @@ zfs_create_unique_device(dev_t *dev) return (0); } -#endif /* !__FreeBSD__ */ +#endif /* !__FreeBSD_kernel__ */ static void atime_changed_cb(void *arg, uint64_t newval) diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c index c5b55ed..d949acb 100644 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c +++ b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c @@ -345,10 +345,13 @@ page_busy(vnode_t *vp, int64_t start, int64_t off, int64_t nbytes) vm_page_sleep(pp, "zfsmwb"); continue; } - } else { + } else if (pp == NULL) { pp = vm_page_alloc(obj, OFF_TO_IDX(start), VM_ALLOC_SYSTEM | VM_ALLOC_IFCACHED | VM_ALLOC_NOBUSY); + } else { + ASSERT(pp != NULL && !pp->valid); + pp = NULL; } if (pp != NULL) { diff --git a/sys/cddl/dev/dtmalloc/dtmalloc.c b/sys/cddl/dev/dtmalloc/dtmalloc.c index ca822f9..81ff43f 100644 --- a/sys/cddl/dev/dtmalloc/dtmalloc.c +++ b/sys/cddl/dev/dtmalloc/dtmalloc.c @@ -28,6 +28,7 @@ #include <sys/param.h> #include <sys/systm.h> #include <sys/conf.h> +#include <sys/ctype.h> #include <sys/kernel.h> #include <sys/malloc.h> #include <sys/module.h> @@ -111,8 +112,17 @@ dtmalloc_type_cb(struct malloc_type *mtp, void *arg __unused) { char name[DTRACE_FUNCNAMELEN]; struct malloc_type_internal *mtip = mtp->ks_handle; + int i; + /* + * malloc_type descriptions are allowed to contain whitespace, but + * DTrace probe identifiers are not, so replace the whitespace with + * underscores. + */ strlcpy(name, mtp->ks_shortdesc, sizeof(name)); + for (i = 0; name[i] != 0; i++) + if (isspace(name[i])) + name[i] = '_'; if (dtrace_probe_lookup(dtmalloc_id, NULL, name, "malloc") != 0) return; diff --git a/sys/conf/NOTES b/sys/conf/NOTES index 3961e0f..dce2168 100644 --- a/sys/conf/NOTES +++ b/sys/conf/NOTES @@ -602,6 +602,12 @@ options IPX #IPX/SPX communications protocols options NETATALK #Appletalk communications protocols options NETATALKDEBUG #Appletalk debugging +# +# SMB/CIFS requester +# NETSMB enables support for SMB protocol, it requires LIBMCHAIN and LIBICONV +# options. +options NETSMB #SMB/CIFS requester + # mchain library. It can be either loaded as KLD or compiled into kernel options LIBMCHAIN @@ -1038,6 +1044,7 @@ options NULLFS #NULL filesystem options PROCFS #Process filesystem (requires PSEUDOFS) options PSEUDOFS #Pseudo-filesystem framework options PSEUDOFS_TRACE #Debugging support for PSEUDOFS +options SMBFS #SMB/CIFS filesystem options TMPFS #Efficient memory filesystem options UDF #Universal Disk Format options UNIONFS #Union filesystem diff --git a/sys/conf/files b/sys/conf/files index ed0eba9..ed62aac 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -536,8 +536,8 @@ crypto/blowfish/bf_ecb.c optional ipsec crypto/blowfish/bf_skey.c optional crypto | ipsec crypto/camellia/camellia.c optional crypto | ipsec crypto/camellia/camellia-api.c optional crypto | ipsec -crypto/des/des_ecb.c optional crypto | ipsec -crypto/des/des_setkey.c optional crypto | ipsec +crypto/des/des_ecb.c optional crypto | ipsec | netsmb +crypto/des/des_setkey.c optional crypto | ipsec | netsmb crypto/rc4/rc4.c optional netgraph_mppc_encryption | kgssapi crypto/rijndael/rijndael-alg-fst.c optional crypto | geom_bde | \ ipsec | random | wlan_ccmp @@ -1185,10 +1185,34 @@ t4fw.fwo optional cxgbe \ no-implicit-rule \ clean "t4fw.fwo" t4fw.fw optional cxgbe \ - dependency "$S/dev/cxgbe/firmware/t4fw-1.8.4.0.bin.uu" \ + dependency "$S/dev/cxgbe/firmware/t4fw-1.8.11.0.bin.uu" \ compile-with "${NORMAL_FW}" \ no-obj no-implicit-rule \ clean "t4fw.fw" +t5fw_cfg.c optional cxgbe \ + compile-with "${AWK} -f $S/tools/fw_stub.awk t5fw_cfg.fw:t5fw_cfg t5fw.fw:t5fw -mt5fw_cfg -c${.TARGET}" \ + no-implicit-rule before-depend local \ + clean "t5fw_cfg.c" +t5fw_cfg.fwo optional cxgbe \ + dependency "t5fw_cfg.fw" \ + compile-with "${NORMAL_FWO}" \ + no-implicit-rule \ + clean "t5fw_cfg.fwo" +t5fw_cfg.fw optional cxgbe \ + dependency "$S/dev/cxgbe/firmware/t5fw_cfg.txt" \ + compile-with "${CP} ${.ALLSRC} ${.TARGET}" \ + no-obj no-implicit-rule \ + clean "t5fw_cfg.fw" +t5fw.fwo optional cxgbe \ + dependency "t5fw.fw" \ + compile-with "${NORMAL_FWO}" \ + no-implicit-rule \ + clean "t5fw.fwo" +t5fw.fw optional cxgbe \ + dependency "$S/dev/cxgbe/firmware/t5fw-1.8.22.0.bin.uu" \ + compile-with "${NORMAL_FW}" \ + no-obj no-implicit-rule \ + clean "t5fw.fw" dev/cy/cy.c optional cy dev/cy/cy_isa.c optional cy isa dev/cy/cy_pci.c optional cy pci @@ -1369,6 +1393,7 @@ dev/fdt/fdtbus.c optional fdt dev/fdt/simplebus.c optional fdt dev/fe/if_fe.c optional fe dev/fe/if_fe_pccard.c optional fe pccard +dev/filemon/filemon.c optional filemon dev/firewire/firewire.c optional firewire dev/firewire/fwcrom.c optional firewire dev/firewire/fwdev.c optional firewire @@ -2509,6 +2534,12 @@ fs/pseudofs/pseudofs.c optional pseudofs fs/pseudofs/pseudofs_fileno.c optional pseudofs fs/pseudofs/pseudofs_vncache.c optional pseudofs fs/pseudofs/pseudofs_vnops.c optional pseudofs +fs/smbfs/smbfs_io.c optional smbfs +fs/smbfs/smbfs_node.c optional smbfs +fs/smbfs/smbfs_smb.c optional smbfs +fs/smbfs/smbfs_subr.c optional smbfs +fs/smbfs/smbfs_vfsops.c optional smbfs +fs/smbfs/smbfs_vnops.c optional smbfs fs/udf/osta.c optional udf fs/udf/udf_iconv.c optional udf_iconv fs/udf/udf_vfsops.c optional udf @@ -2746,6 +2777,7 @@ kern/kern_uuid.c standard kern/kern_xxx.c standard kern/link_elf.c standard kern/linker_if.m standard +kern/md4c.c optional netsmb kern/md5c.c standard kern/p1003_1b.c standard kern/posix4_mib.c standard @@ -2797,6 +2829,7 @@ kern/subr_trap.c standard kern/subr_turnstile.c standard kern/subr_uio.c standard kern/subr_unit.c standard +kern/subr_vmem.c standard kern/subr_witness.c optional witness kern/sys_capability.c standard kern/sys_generic.c standard @@ -3278,6 +3311,15 @@ netpfil/pf/pf_osfp.c optional pf inet netpfil/pf/pf_ruleset.c optional pf inet netpfil/pf/pf_table.c optional pf inet netpfil/pf/in4_cksum.c optional pf inet +netsmb/smb_conn.c optional netsmb +netsmb/smb_crypt.c optional netsmb +netsmb/smb_dev.c optional netsmb +netsmb/smb_iod.c optional netsmb +netsmb/smb_rq.c optional netsmb +netsmb/smb_smb.c optional netsmb +netsmb/smb_subr.c optional netsmb +netsmb/smb_trantcp.c optional netsmb +netsmb/smb_usr.c optional netsmb nfs/bootp_subr.c optional bootp nfsclient | bootp nfscl nfs/krpc_subr.c optional bootp nfsclient | bootp nfscl nfs/nfs_common.c optional nfsclient | nfsserver diff --git a/sys/conf/files.amd64 b/sys/conf/files.amd64 index 7a41a26..2cb1981 100644 --- a/sys/conf/files.amd64 +++ b/sys/conf/files.amd64 @@ -136,7 +136,7 @@ crypto/aesni/aeskeys_amd64.S optional aesni crypto/aesni/aesni.c optional aesni crypto/aesni/aesni_wrap.c optional aesni crypto/blowfish/bf_enc.c optional crypto | ipsec -crypto/des/des_enc.c optional crypto | ipsec +crypto/des/des_enc.c optional crypto | ipsec | netsmb crypto/via/padlock.c optional padlock crypto/via/padlock_cipher.c optional padlock crypto/via/padlock_hash.c optional padlock diff --git a/sys/conf/files.arm b/sys/conf/files.arm index 938386d..ac48704 100644 --- a/sys/conf/files.arm +++ b/sys/conf/files.arm @@ -61,7 +61,7 @@ board_id.h standard \ clean "board_id.h" cddl/compat/opensolaris/kern/opensolaris_atomic.c optional zfs compile-with "${ZFS_C}" crypto/blowfish/bf_enc.c optional crypto | ipsec -crypto/des/des_enc.c optional crypto | ipsec +crypto/des/des_enc.c optional crypto | ipsec | netsmb dev/fb/fb.c optional sc dev/hwpmc/hwpmc_arm.c optional hwpmc dev/kbd/kbd.c optional sc diff --git a/sys/conf/files.i386 b/sys/conf/files.i386 index 218472b..0f65d3b 100644 --- a/sys/conf/files.i386 +++ b/sys/conf/files.i386 @@ -122,7 +122,7 @@ crypto/aesni/aesencdec_i386.S optional aesni crypto/aesni/aeskeys_i386.S optional aesni crypto/aesni/aesni.c optional aesni crypto/aesni/aesni_wrap.c optional aesni -crypto/des/arch/i386/des_enc.S optional crypto | ipsec +crypto/des/arch/i386/des_enc.S optional crypto | ipsec | netsmb crypto/via/padlock.c optional padlock crypto/via/padlock_cipher.c optional padlock crypto/via/padlock_hash.c optional padlock diff --git a/sys/conf/files.ia64 b/sys/conf/files.ia64 index 474ba1b..6719c98 100644 --- a/sys/conf/files.ia64 +++ b/sys/conf/files.ia64 @@ -41,7 +41,7 @@ contrib/ia64/libuwx/src/uwx_trace.c standard contrib/ia64/libuwx/src/uwx_uinfo.c standard contrib/ia64/libuwx/src/uwx_utable.c standard crypto/blowfish/bf_enc.c optional crypto | ipsec -crypto/des/des_enc.c optional crypto | ipsec +crypto/des/des_enc.c optional crypto | ipsec | netsmb dev/atkbdc/atkbd.c optional atkbd atkbdc dev/atkbdc/atkbd_atkbdc.c optional atkbd atkbdc dev/atkbdc/atkbdc.c optional atkbdc diff --git a/sys/conf/files.mips b/sys/conf/files.mips index 79676b9..ca8dee2 100644 --- a/sys/conf/files.mips +++ b/sys/conf/files.mips @@ -77,7 +77,7 @@ dev/uart/uart_cpu_fdt.c optional uart fdt # crypto support -- use generic crypto/blowfish/bf_enc.c optional crypto | ipsec -crypto/des/des_enc.c optional crypto | ipsec +crypto/des/des_enc.c optional crypto | ipsec | netsmb # AP common nvram interface MIPS specific, but maybe should be more generic dev/nvram2env/nvram2env.c optional nvram2env diff --git a/sys/conf/files.pc98 b/sys/conf/files.pc98 index 252ecdd..a8e60b6 100644 --- a/sys/conf/files.pc98 +++ b/sys/conf/files.pc98 @@ -77,7 +77,7 @@ bf_enc.o optional crypto | ipsec \ dependency "$S/crypto/blowfish/arch/i386/bf_enc.S $S/crypto/blowfish/arch/i386/bf_enc_586.S $S/crypto/blowfish/arch/i386/bf_enc_686.S" \ compile-with "${CC} -c -I$S/crypto/blowfish/arch/i386 ${ASM_CFLAGS} ${WERROR} ${.IMPSRC}" \ no-implicit-rule -crypto/des/arch/i386/des_enc.S optional crypto | ipsec +crypto/des/arch/i386/des_enc.S optional crypto | ipsec | netsmb dev/agp/agp_ali.c optional agp dev/agp/agp_amd.c optional agp dev/agp/agp_i810.c optional agp diff --git a/sys/conf/files.powerpc b/sys/conf/files.powerpc index 96331f7..5808d85 100644 --- a/sys/conf/files.powerpc +++ b/sys/conf/files.powerpc @@ -18,7 +18,7 @@ font.h optional sc \ cddl/compat/opensolaris/kern/opensolaris_atomic.c optional zfs powerpc compile-with "${ZFS_C}" cddl/contrib/opensolaris/common/atomic/powerpc64/opensolaris_atomic.S optional zfs powerpc64 compile-with "${ZFS_S}" crypto/blowfish/bf_enc.c optional crypto | ipsec -crypto/des/des_enc.c optional crypto | ipsec +crypto/des/des_enc.c optional crypto | ipsec | netsmb dev/bm/if_bm.c optional bm powermac dev/adb/adb_bus.c optional adb dev/adb/adb_kbd.c optional adb diff --git a/sys/conf/files.sparc64 b/sys/conf/files.sparc64 index 5019dab..a0fad9b 100644 --- a/sys/conf/files.sparc64 +++ b/sys/conf/files.sparc64 @@ -24,7 +24,7 @@ ukbdmap.h optional ukbd_dflt_keymap \ # cddl/contrib/opensolaris/common/atomic/sparc64/opensolaris_atomic.S optional zfs compile-with "${ZFS_S}" crypto/blowfish/bf_enc.c optional crypto | ipsec -crypto/des/des_enc.c optional crypto | ipsec +crypto/des/des_enc.c optional crypto | ipsec | netsmb dev/atkbdc/atkbd.c optional atkbd atkbdc dev/atkbdc/atkbd_atkbdc.c optional atkbd atkbdc dev/atkbdc/atkbdc.c optional atkbdc diff --git a/sys/conf/newvers.sh b/sys/conf/newvers.sh index 1e5e24b..b0ca002 100644 --- a/sys/conf/newvers.sh +++ b/sys/conf/newvers.sh @@ -88,16 +88,26 @@ v=`cat version` u=${USER:-root} d=`pwd` h=${HOSTNAME:-`hostname`} t=`date` i=`${MAKE:-make} -V KERN_IDENT` compiler_v=$($(${MAKE:-make} -V CC) -v 2>&1 | grep 'version') -for dir in /bin /usr/bin /usr/local/bin; do +if [ -x /usr/bin/svnliteversion ] ; then + svnversion=/usr/bin/svnliteversion +fi + +for dir in /usr/bin /usr/local/bin; do + if [ ! -z "${svnversion}" ] ; then + break + fi if [ -x "${dir}/svnversion" ] && [ -z ${svnversion} ] ; then svnversion=${dir}/svnversion + break fi +done +for dir in /usr/bin /usr/local/bin; do if [ -x "${dir}/p4" ] && [ -z ${p4_cmd} ] ; then p4_cmd=${dir}/p4 fi done if [ -d "${SYSDIR}/../.git" ] ; then - for dir in /bin /usr/bin /usr/local/bin; do + for dir in /usr/bin /usr/local/bin; do if [ -x "${dir}/git" ] ; then git_cmd="${dir}/git --git-dir=${SYSDIR}/../.git" break diff --git a/sys/conf/options b/sys/conf/options index 03936fd..d9057cc 100644 --- a/sys/conf/options +++ b/sys/conf/options @@ -85,6 +85,7 @@ COMPRESS_USER_CORES opt_core.h CY_PCI_FASTINTR DEADLKRES opt_watchdog.h DIRECTIO +FILEMON opt_dontuse.h FFCLOCK FULL_PREEMPTION opt_sched.h IPI_PREEMPTION opt_sched.h @@ -222,9 +223,11 @@ NULLFS opt_dontuse.h PROCFS opt_dontuse.h PSEUDOFS opt_dontuse.h REISERFS opt_dontuse.h +SMBFS opt_dontuse.h TMPFS opt_dontuse.h UDF opt_dontuse.h UNIONFS opt_dontuse.h +ZFS opt_dontuse.h # Pseudofs debugging PSEUDOFS_TRACE opt_pseudofs.h @@ -287,6 +290,9 @@ UFS_GJOURNAL opt_ufs.h # they won't make any difference yet). NFS_ROOT opt_nfsroot.h +# SMB/CIFS requester +NETSMB opt_netsmb.h + # Options used only in subr_param.c. HZ opt_param.h MAXFILES opt_param.h @@ -836,8 +842,6 @@ HWPMC_MIPS_BACKTRACE opt_hwpmc_hooks.h # XBOX options for FreeBSD/i386, but some files are MI XBOX opt_xbox.h -ZFS opt_dontuse.h - # Interrupt filtering INTR_FILTER diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_attach.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_attach.c index 5142115..335414e 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_attach.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_attach.c @@ -639,6 +639,11 @@ ar9300_attach(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, /* FreeBSD: to make OTP work for now, provide this.. */ AH9300(ah)->ah_cal_mem = ath_hal_malloc(HOST_CALDATA_SIZE); + if (AH9300(ah)->ah_cal_mem == NULL) { + ath_hal_printf(ah, "%s: caldata malloc failed!\n", __func__); + ecode = HAL_EIO; + goto bad; + } /* * If eepromdata is not NULL, copy it it into ah_cal_mem. diff --git a/sys/dev/acpica/acpi_pcib.c b/sys/dev/acpica/acpi_pcib.c index 1a42d74..c4bded8 100644 --- a/sys/dev/acpica/acpi_pcib.c +++ b/sys/dev/acpica/acpi_pcib.c @@ -135,15 +135,6 @@ acpi_pcib_attach(device_t dev, ACPI_BUFFER *prt, int busno) ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); /* - * Don't attach if we're not really there. - * - * XXX: This isn't entirely correct since we may be a PCI bus - * on a hot-plug docking station, etc. - */ - if (!acpi_DeviceIsPresent(dev)) - return_VALUE(ENXIO); - - /* * Get the PCI interrupt routing table for this bus. If we can't * get it, this is not an error but may reduce functionality. There * are several valid bridges in the field that do not have a _PRT, so diff --git a/sys/dev/acpica/acpi_pcib_acpi.c b/sys/dev/acpica/acpi_pcib_acpi.c index 36d9580..882834d 100644 --- a/sys/dev/acpica/acpi_pcib_acpi.c +++ b/sys/dev/acpica/acpi_pcib_acpi.c @@ -287,6 +287,12 @@ acpi_pcib_acpi_attach(device_t dev) sc->ap_handle = acpi_get_handle(dev); /* + * Don't attach if we're not really there. + */ + if (!acpi_DeviceIsPresent(dev)) + return (ENXIO); + + /* * Get our segment number by evaluating _SEG. * It's OK for this to not exist. */ @@ -353,7 +359,7 @@ acpi_pcib_acpi_attach(device_t dev) if (status != AE_NOT_FOUND) { device_printf(dev, "could not evaluate _BBN - %s\n", AcpiFormatException(status)); - return_VALUE (ENXIO); + return (ENXIO); } else { /* If it's not found, assume 0. */ sc->ap_bus = 0; diff --git a/sys/dev/ath/if_ath_rx_edma.c b/sys/dev/ath/if_ath_rx_edma.c index abfb57d..2be8627 100644 --- a/sys/dev/ath/if_ath_rx_edma.c +++ b/sys/dev/ath/if_ath_rx_edma.c @@ -424,9 +424,10 @@ ath_edma_recv_proc_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, if (dosched && sc->sc_kickpcu) { ATH_KTR(sc, ATH_KTR_ERROR, 0, "ath_edma_recv_proc_queue(): kickpcu"); - device_printf(sc->sc_dev, - "%s: handled npkts %d\n", - __func__, npkts); + if (npkts > 0) + device_printf(sc->sc_dev, + "%s: handled npkts %d\n", + __func__, npkts); /* * XXX TODO: what should occur here? Just re-poke and diff --git a/sys/dev/bce/if_bce.c b/sys/dev/bce/if_bce.c index cdf9517..644348c 100644 --- a/sys/dev/bce/if_bce.c +++ b/sys/dev/bce/if_bce.c @@ -2077,10 +2077,12 @@ bce_miibus_statchg(device_t dev) DBPRINT(sc, BCE_INFO_PHY, "%s(): Enabling RX flow control.\n", __FUNCTION__); BCE_SETBIT(sc, BCE_EMAC_RX_MODE, BCE_EMAC_RX_MODE_FLOW_EN); + sc->bce_flags |= BCE_USING_RX_FLOW_CONTROL; } else { DBPRINT(sc, BCE_INFO_PHY, "%s(): Disabling RX flow control.\n", __FUNCTION__); BCE_CLRBIT(sc, BCE_EMAC_RX_MODE, BCE_EMAC_RX_MODE_FLOW_EN); + sc->bce_flags &= ~BCE_USING_RX_FLOW_CONTROL; } if ((IFM_OPTIONS(media_active) & IFM_ETH_TXPAUSE) != 0) { @@ -7828,18 +7830,42 @@ bce_ioctl(struct ifnet *ifp, u_long command, caddr_t data) static void bce_watchdog(struct bce_softc *sc) { + uint32_t status; + DBENTER(BCE_EXTREME_SEND); BCE_LOCK_ASSERT(sc); + status = 0; /* If the watchdog timer hasn't expired then just exit. */ if (sc->watchdog_timer == 0 || --sc->watchdog_timer) goto bce_watchdog_exit; + status = REG_RD(sc, BCE_EMAC_RX_STATUS); /* If pause frames are active then don't reset the hardware. */ - /* ToDo: Should we reset the timer here? */ - if (REG_RD(sc, BCE_EMAC_TX_STATUS) & BCE_EMAC_TX_STATUS_XOFFED) - goto bce_watchdog_exit; + if ((sc->bce_flags & BCE_USING_RX_FLOW_CONTROL) != 0) { + if ((status & BCE_EMAC_RX_STATUS_FFED) != 0) { + /* + * If link partner has us in XOFF state then wait for + * the condition to clear. + */ + sc->watchdog_timer = BCE_TX_TIMEOUT; + goto bce_watchdog_exit; + } else if ((status & BCE_EMAC_RX_STATUS_FF_RECEIVED) != 0 && + (status & BCE_EMAC_RX_STATUS_N_RECEIVED) != 0) { + /* + * If we're not currently XOFF'ed but have recently + * been XOFF'd/XON'd then assume that's delaying TX + * this time around. + */ + sc->watchdog_timer = BCE_TX_TIMEOUT; + goto bce_watchdog_exit; + } + /* + * Any other condition is unexpected and the controller + * should be reset. + */ + } BCE_PRINTF("%s(%d): Watchdog timeout occurred, resetting!\n", __FILE__, __LINE__); @@ -7863,6 +7889,7 @@ bce_watchdog(struct bce_softc *sc) sc->bce_ifp->if_oerrors++; bce_watchdog_exit: + REG_WR(sc, BCE_EMAC_RX_STATUS, status); DBEXIT(BCE_EXTREME_SEND); } diff --git a/sys/dev/bce/if_bcereg.h b/sys/dev/bce/if_bcereg.h index 7138f3c..dab19c4 100644 --- a/sys/dev/bce/if_bcereg.h +++ b/sys/dev/bce/if_bcereg.h @@ -6465,6 +6465,7 @@ struct bce_softc #define BCE_USING_MSIX_FLAG 0x00000100 #define BCE_PCIE_FLAG 0x00000200 #define BCE_USING_TX_FLOW_CONTROL 0x00000400 +#define BCE_USING_RX_FLOW_CONTROL 0x00000800 /* Controller capability flags. */ u32 bce_cap_flags; diff --git a/sys/dev/bge/if_bge.c b/sys/dev/bge/if_bge.c index ff1f030..306acc6 100644 --- a/sys/dev/bge/if_bge.c +++ b/sys/dev/bge/if_bge.c @@ -5271,7 +5271,7 @@ bge_start_locked(struct ifnet *ifp) /* * Set a timeout in case the chip goes out to lunch. */ - sc->bge_timer = 5; + sc->bge_timer = BGE_TX_TIMEOUT; } } @@ -5776,12 +5776,40 @@ static void bge_watchdog(struct bge_softc *sc) { struct ifnet *ifp; + uint32_t status; BGE_LOCK_ASSERT(sc); if (sc->bge_timer == 0 || --sc->bge_timer) return; + /* If pause frames are active then don't reset the hardware. */ + if ((CSR_READ_4(sc, BGE_RX_MODE) & BGE_RXMODE_FLOWCTL_ENABLE) != 0) { + status = CSR_READ_4(sc, BGE_RX_STS); + if ((status & BGE_RXSTAT_REMOTE_XOFFED) != 0) { + /* + * If link partner has us in XOFF state then wait for + * the condition to clear. + */ + CSR_WRITE_4(sc, BGE_RX_STS, status); + sc->bge_timer = BGE_TX_TIMEOUT; + return; + } else if ((status & BGE_RXSTAT_RCVD_XOFF) != 0 && + (status & BGE_RXSTAT_RCVD_XON) != 0) { + /* + * If link partner has us in XOFF state then wait for + * the condition to clear. + */ + CSR_WRITE_4(sc, BGE_RX_STS, status); + sc->bge_timer = BGE_TX_TIMEOUT; + return; + } + /* + * Any other condition is unexpected and the controller + * should be reset. + */ + } + ifp = sc->bge_ifp; if_printf(ifp, "watchdog timeout -- resetting\n"); diff --git a/sys/dev/bge/if_bgereg.h b/sys/dev/bge/if_bgereg.h index 760fc85..6f9822e 100644 --- a/sys/dev/bge/if_bgereg.h +++ b/sys/dev/bge/if_bgereg.h @@ -2918,6 +2918,7 @@ struct bge_dmamap_arg { #define BGE_HWREV_TIGON_II 0x02 #define BGE_TIMEOUT 100000 #define BGE_TXCONS_UNSET 0xFFFF /* impossible value */ +#define BGE_TX_TIMEOUT 5 struct bge_bcom_hack { int reg; diff --git a/sys/dev/cpuctl/cpuctl.c b/sys/dev/cpuctl/cpuctl.c index 742fa10..742ef0db 100644 --- a/sys/dev/cpuctl/cpuctl.c +++ b/sys/dev/cpuctl/cpuctl.c @@ -63,7 +63,7 @@ static d_ioctl_t cpuctl_ioctl; # define DPRINTF(...) #endif -#define UCODE_SIZE_MAX (10 * 1024) +#define UCODE_SIZE_MAX (16 * 1024) static int cpuctl_do_msr(int cpu, cpuctl_msr_args_t *data, u_long cmd, struct thread *td); @@ -326,7 +326,7 @@ update_intel(int cpu, cpuctl_update_args_t *args, struct thread *td) is_bound = cpu_sched_is_bound(td); set_cpu(cpu, td); critical_enter(); - rdmsr_safe(MSR_BIOS_SIGN, &rev0); /* Get current micorcode revision. */ + rdmsr_safe(MSR_BIOS_SIGN, &rev0); /* Get current microcode revision. */ /* * Perform update. @@ -339,7 +339,7 @@ update_intel(int cpu, cpuctl_update_args_t *args, struct thread *td) */ do_cpuid(0, tmp); critical_exit(); - rdmsr_safe(MSR_BIOS_SIGN, &rev1); /* Get new micorcode revision. */ + rdmsr_safe(MSR_BIOS_SIGN, &rev1); /* Get new microcode revision. */ restore_cpu(oldcpu, is_bound, td); if (rev1 > rev0) ret = 0; @@ -440,7 +440,7 @@ update_via(int cpu, cpuctl_update_args_t *args, struct thread *td) is_bound = cpu_sched_is_bound(td); set_cpu(cpu, td); critical_enter(); - rdmsr_safe(MSR_BIOS_SIGN, &rev0); /* Get current micorcode revision. */ + rdmsr_safe(MSR_BIOS_SIGN, &rev0); /* Get current microcode revision. */ /* * Perform update. diff --git a/sys/dev/cxgbe/adapter.h b/sys/dev/cxgbe/adapter.h index 434fb53..c67570f 100644 --- a/sys/dev/cxgbe/adapter.h +++ b/sys/dev/cxgbe/adapter.h @@ -132,7 +132,6 @@ enum { #else FL_BUF_SIZES = 3, /* cluster, jumbo9k, jumbo16k */ #endif - OFLD_BUF_SIZE = MJUM16BYTES, /* size of fl buffer for TOE rxq */ CTRL_EQ_QSIZE = 128, @@ -219,6 +218,7 @@ struct port_info { int qsize_rxq; int qsize_txq; + int linkdnrc; struct link_config link_cfg; struct port_stats stats; @@ -562,7 +562,6 @@ struct adapter { struct taskqueue *tq[NCHAN]; /* taskqueues that flush data out */ struct port_info *port[MAX_NPORTS]; uint8_t chan_map[NCHAN]; - uint32_t filter_mode; #ifdef TCP_OFFLOAD void *tom_softc; /* (struct tom_data *) */ @@ -778,7 +777,7 @@ int t4_os_find_pci_capability(struct adapter *, int); int t4_os_pci_save_state(struct adapter *); int t4_os_pci_restore_state(struct adapter *); void t4_os_portmod_changed(const struct adapter *, int); -void t4_os_link_changed(struct adapter *, int, int); +void t4_os_link_changed(struct adapter *, int, int, int); void t4_iterate(void (*)(struct adapter *, void *), void *); int t4_register_cpl_handler(struct adapter *, int, cpl_handler_t); int t4_register_an_handler(struct adapter *, an_handler_t); diff --git a/sys/dev/cxgbe/common/common.h b/sys/dev/cxgbe/common/common.h index 1e58c38..22edff6 100644 --- a/sys/dev/cxgbe/common/common.h +++ b/sys/dev/cxgbe/common/common.h @@ -67,16 +67,6 @@ enum { PAUSE_AUTONEG = 1 << 2 }; -#define FW_VERSION_MAJOR_T4 1 -#define FW_VERSION_MINOR_T4 8 -#define FW_VERSION_MICRO_T4 4 -#define FW_VERSION_BUILD_T4 0 - -#define FW_VERSION_MAJOR_T5 0 -#define FW_VERSION_MINOR_T5 5 -#define FW_VERSION_MICRO_T5 18 -#define FW_VERSION_BUILD_T5 0 - struct memwin { uint32_t base; uint32_t aperture; @@ -229,6 +219,12 @@ struct tp_params { unsigned int dack_re; /* DACK timer resolution */ unsigned int la_mask; /* what events are recorded by TP LA */ unsigned short tx_modq[NCHAN]; /* channel to modulation queue map */ + uint32_t vlan_pri_map; + uint32_t ingress_config; + int8_t vlan_shift; + int8_t vnic_shift; + int8_t port_shift; + int8_t protocol_shift; }; struct vpd_params { @@ -431,6 +427,8 @@ int t4_get_tp_version(struct adapter *adapter, u32 *vers); int t4_check_fw_version(struct adapter *adapter); int t4_init_hw(struct adapter *adapter, u32 fw_params); int t4_prep_adapter(struct adapter *adapter); +int t4_init_tp_params(struct adapter *adap); +int t4_filter_field_shift(const struct adapter *adap, int filter_sel); int t4_port_init(struct port_info *p, int mbox, int pf, int vf); int t4_reinit_adapter(struct adapter *adap); void t4_fatal_err(struct adapter *adapter); diff --git a/sys/dev/cxgbe/common/t4_hw.c b/sys/dev/cxgbe/common/t4_hw.c index d1f8fd7..3005f63 100644 --- a/sys/dev/cxgbe/common/t4_hw.c +++ b/sys/dev/cxgbe/common/t4_hw.c @@ -975,14 +975,14 @@ int t4_check_fw_version(struct adapter *adapter) switch (chip_id(adapter)) { case CHELSIO_T4: - exp_major = FW_VERSION_MAJOR_T4; - exp_minor = FW_VERSION_MINOR_T4; - exp_micro = FW_VERSION_MICRO_T4; + exp_major = T4FW_VERSION_MAJOR; + exp_minor = T4FW_VERSION_MINOR; + exp_micro = T4FW_VERSION_MICRO; break; case CHELSIO_T5: - exp_major = FW_VERSION_MAJOR_T5; - exp_minor = FW_VERSION_MINOR_T5; - exp_micro = FW_VERSION_MICRO_T5; + exp_major = T5FW_VERSION_MAJOR; + exp_minor = T5FW_VERSION_MINOR; + exp_micro = T5FW_VERSION_MICRO; break; default: CH_ERR(adapter, "Unsupported chip type, %x\n", @@ -1128,7 +1128,19 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) const u32 *p = (const u32 *)fw_data; const struct fw_hdr *hdr = (const struct fw_hdr *)fw_data; unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec; - + unsigned int fw_start_sec; + unsigned int fw_start; + unsigned int fw_size; + + if (ntohl(hdr->magic) == FW_HDR_MAGIC_BOOTSTRAP) { + fw_start_sec = FLASH_FWBOOTSTRAP_START_SEC; + fw_start = FLASH_FWBOOTSTRAP_START; + fw_size = FLASH_FWBOOTSTRAP_MAX_SIZE; + } else { + fw_start_sec = FLASH_FW_START_SEC; + fw_start = FLASH_FW_START; + fw_size = FLASH_FW_MAX_SIZE; + } if (!size) { CH_ERR(adap, "FW image has no data\n"); return -EINVAL; @@ -1141,9 +1153,8 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) CH_ERR(adap, "FW image size differs from size in FW header\n"); return -EINVAL; } - if (size > FLASH_FW_MAX_SIZE) { - CH_ERR(adap, "FW image too large, max is %u bytes\n", - FLASH_FW_MAX_SIZE); + if (size > fw_size) { + CH_ERR(adap, "FW image too large, max is %u bytes\n", fw_size); return -EFBIG; } if ((is_t4(adap) && hdr->chip != FW_HDR_CHIP_T4) || @@ -1164,8 +1175,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) } i = DIV_ROUND_UP(size, sf_sec_size); /* # of sectors spanned */ - ret = t4_flash_erase_sectors(adap, FLASH_FW_START_SEC, - FLASH_FW_START_SEC + i - 1); + ret = t4_flash_erase_sectors(adap, fw_start_sec, fw_start_sec + i - 1); if (ret) goto out; @@ -1176,11 +1186,11 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) */ memcpy(first_page, fw_data, SF_PAGE_SIZE); ((struct fw_hdr *)first_page)->fw_ver = htonl(0xffffffff); - ret = t4_write_flash(adap, FLASH_FW_START, SF_PAGE_SIZE, first_page, 1); + ret = t4_write_flash(adap, fw_start, SF_PAGE_SIZE, first_page, 1); if (ret) goto out; - addr = FLASH_FW_START; + addr = fw_start; for (size -= SF_PAGE_SIZE; size; size -= SF_PAGE_SIZE) { addr += SF_PAGE_SIZE; fw_data += SF_PAGE_SIZE; @@ -1190,7 +1200,7 @@ int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size) } ret = t4_write_flash(adap, - FLASH_FW_START + offsetof(struct fw_hdr, fw_ver), + fw_start + offsetof(struct fw_hdr, fw_ver), sizeof(hdr->fw_ver), (const u8 *)&hdr->fw_ver, 1); out: if (ret) @@ -4622,14 +4632,17 @@ int t4_fw_upgrade(struct adapter *adap, unsigned int mbox, const u8 *fw_data, unsigned int size, int force) { const struct fw_hdr *fw_hdr = (const struct fw_hdr *)fw_data; + unsigned int bootstrap = ntohl(fw_hdr->magic) == FW_HDR_MAGIC_BOOTSTRAP; int reset, ret; - ret = t4_fw_halt(adap, mbox, force); - if (ret < 0 && !force) - return ret; + if (!bootstrap) { + ret = t4_fw_halt(adap, mbox, force); + if (ret < 0 && !force) + return ret; + } ret = t4_load_fw(adap, fw_data, size); - if (ret < 0) + if (ret < 0 || bootstrap) return ret; /* @@ -5338,11 +5351,18 @@ int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl) if (link_ok != lc->link_ok || speed != lc->speed || fc != lc->fc) { /* something changed */ + int reason; + + if (!link_ok && lc->link_ok) + reason = G_FW_PORT_CMD_LINKDNRC(stat); + else + reason = -1; + lc->link_ok = link_ok; lc->speed = speed; lc->fc = fc; lc->supported = ntohs(p->u.info.pcap); - t4_os_link_changed(adap, i, link_ok); + t4_os_link_changed(adap, i, link_ok, reason); } if (mod != pi->mod_type) { pi->mod_type = mod; @@ -5508,6 +5528,91 @@ int __devinit t4_prep_adapter(struct adapter *adapter) return 0; } +/** + * t4_init_tp_params - initialize adap->params.tp + * @adap: the adapter + * + * Initialize various fields of the adapter's TP Parameters structure. + */ +int __devinit t4_init_tp_params(struct adapter *adap) +{ + int chan; + u32 v; + + v = t4_read_reg(adap, A_TP_TIMER_RESOLUTION); + adap->params.tp.tre = G_TIMERRESOLUTION(v); + adap->params.tp.dack_re = G_DELAYEDACKRESOLUTION(v); + + /* MODQ_REQ_MAP defaults to setting queues 0-3 to chan 0-3 */ + for (chan = 0; chan < NCHAN; chan++) + adap->params.tp.tx_modq[chan] = chan; + + /* + * Cache the adapter's Compressed Filter Mode and global Incress + * Configuration. + */ + t4_read_indirect(adap, A_TP_PIO_ADDR, A_TP_PIO_DATA, + &adap->params.tp.vlan_pri_map, 1, + A_TP_VLAN_PRI_MAP); + t4_read_indirect(adap, A_TP_PIO_ADDR, A_TP_PIO_DATA, + &adap->params.tp.ingress_config, 1, + A_TP_INGRESS_CONFIG); + + /* + * Now that we have TP_VLAN_PRI_MAP cached, we can calculate the field + * shift positions of several elements of the Compressed Filter Tuple + * for this adapter which we need frequently ... + */ + adap->params.tp.vlan_shift = t4_filter_field_shift(adap, F_VLAN); + adap->params.tp.vnic_shift = t4_filter_field_shift(adap, F_VNIC_ID); + adap->params.tp.port_shift = t4_filter_field_shift(adap, F_PORT); + adap->params.tp.protocol_shift = t4_filter_field_shift(adap, F_PROTOCOL); + + /* + * If TP_INGRESS_CONFIG.VNID == 0, then TP_VLAN_PRI_MAP.VNIC_ID + * represents the presense of an Outer VLAN instead of a VNIC ID. + */ + if ((adap->params.tp.ingress_config & F_VNIC) == 0) + adap->params.tp.vnic_shift = -1; + + return 0; +} + +/** + * t4_filter_field_shift - calculate filter field shift + * @adap: the adapter + * @filter_sel: the desired field (from TP_VLAN_PRI_MAP bits) + * + * Return the shift position of a filter field within the Compressed + * Filter Tuple. The filter field is specified via its selection bit + * within TP_VLAN_PRI_MAL (filter mode). E.g. F_VLAN. + */ +int t4_filter_field_shift(const struct adapter *adap, int filter_sel) +{ + unsigned int filter_mode = adap->params.tp.vlan_pri_map; + unsigned int sel; + int field_shift; + + if ((filter_mode & filter_sel) == 0) + return -1; + + for (sel = 1, field_shift = 0; sel < filter_sel; sel <<= 1) { + switch (filter_mode & sel) { + case F_FCOE: field_shift += W_FT_FCOE; break; + case F_PORT: field_shift += W_FT_PORT; break; + case F_VNIC_ID: field_shift += W_FT_VNIC_ID; break; + case F_VLAN: field_shift += W_FT_VLAN; break; + case F_TOS: field_shift += W_FT_TOS; break; + case F_PROTOCOL: field_shift += W_FT_PROTOCOL; break; + case F_ETHERTYPE: field_shift += W_FT_ETHERTYPE; break; + case F_MACMATCH: field_shift += W_FT_MACMATCH; break; + case F_MPSHITTYPE: field_shift += W_FT_MPSHITTYPE; break; + case F_FRAGMENTATION: field_shift += W_FT_FRAGMENTATION; break; + } + } + return field_shift; +} + int __devinit t4_port_init(struct port_info *p, int mbox, int pf, int vf) { u8 addr[6]; diff --git a/sys/dev/cxgbe/common/t4_hw.h b/sys/dev/cxgbe/common/t4_hw.h index 8b94169..3bc2096 100644 --- a/sys/dev/cxgbe/common/t4_hw.h +++ b/sys/dev/cxgbe/common/t4_hw.h @@ -230,7 +230,15 @@ enum { FLASH_FW_NSECS = 16, FLASH_FW_START = FLASH_START(FLASH_FW_START_SEC), FLASH_FW_MAX_SIZE = FLASH_MAX_SIZE(FLASH_FW_NSECS), - + + /* + * Location of bootstrap firmware image in FLASH. + */ + FLASH_FWBOOTSTRAP_START_SEC = 27, + FLASH_FWBOOTSTRAP_NSECS = 1, + FLASH_FWBOOTSTRAP_START = FLASH_START(FLASH_FWBOOTSTRAP_START_SEC), + FLASH_FWBOOTSTRAP_MAX_SIZE = FLASH_MAX_SIZE(FLASH_FWBOOTSTRAP_NSECS), + /* * iSCSI persistent/crash information. */ @@ -248,19 +256,13 @@ enum { FLASH_FCOE_CRASH_MAX_SIZE = FLASH_MAX_SIZE(FLASH_FCOE_CRASH_NSECS), /* - * Location of Firmware Configuration File in FLASH. Since the FPGA - * "FLASH" is smaller we need to store the Configuration File in a - * different location -- which will overlap the end of the firmware - * image if firmware ever gets that large ... + * Location of Firmware Configuration File in FLASH. */ FLASH_CFG_START_SEC = 31, FLASH_CFG_NSECS = 1, FLASH_CFG_START = FLASH_START(FLASH_CFG_START_SEC), FLASH_CFG_MAX_SIZE = FLASH_MAX_SIZE(FLASH_CFG_NSECS), - FLASH_FPGA_CFG_START_SEC = 15, - FLASH_FPGA_CFG_START = FLASH_START(FLASH_FPGA_CFG_START_SEC), - /* * Sectors 32-63 are reserved for FLASH failover. */ diff --git a/sys/dev/cxgbe/common/t4_msg.h b/sys/dev/cxgbe/common/t4_msg.h index 5988070..ef8fbe6 100644 --- a/sys/dev/cxgbe/common/t4_msg.h +++ b/sys/dev/cxgbe/common/t4_msg.h @@ -678,6 +678,15 @@ struct cpl_pass_accept_rpl { __be64 opt0; }; +struct cpl_t5_pass_accept_rpl { + WR_HDR; + union opcode_tid ot; + __be32 opt2; + __be64 opt0; + __be32 iss; + __be32 rsvd; +}; + struct cpl_act_open_req { WR_HDR; union opcode_tid ot; @@ -702,7 +711,7 @@ struct cpl_t5_act_open_req { __be32 local_ip; __be32 peer_ip; __be64 opt0; - __be32 rsvd; + __be32 iss; __be32 opt2; __be64 params; }; @@ -731,7 +740,7 @@ struct cpl_t5_act_open_req6 { __be64 peer_ip_hi; __be64 peer_ip_lo; __be64 opt0; - __be32 rsvd; + __be32 iss; __be32 opt2; __be64 params; }; diff --git a/sys/dev/cxgbe/common/t4_regs_values.h b/sys/dev/cxgbe/common/t4_regs_values.h index aacda81..40dabf1 100644 --- a/sys/dev/cxgbe/common/t4_regs_values.h +++ b/sys/dev/cxgbe/common/t4_regs_values.h @@ -189,4 +189,57 @@ #define X_MBOWNER_FW 1 #define X_MBOWNER_PL 2 +/* + * PCI-E definitions. + * ================== + */ + +#define X_WINDOW_SHIFT 10 +#define X_PCIEOFST_SHIFT 10 + +/* + * TP definitions. + * =============== + */ + +/* + * TP_VLAN_PRI_MAP controls which subset of fields will be present in the + * Compressed Filter Tuple for LE filters. Each bit set in TP_VLAN_PRI_MAP + * selects for a particular field being present. These fields, when present + * in the Compressed Filter Tuple, have the following widths in bits. + */ +#define W_FT_FCOE 1 +#define W_FT_PORT 3 +#define W_FT_VNIC_ID 17 +#define W_FT_VLAN 17 +#define W_FT_TOS 8 +#define W_FT_PROTOCOL 8 +#define W_FT_ETHERTYPE 16 +#define W_FT_MACMATCH 9 +#define W_FT_MPSHITTYPE 3 +#define W_FT_FRAGMENTATION 1 + +/* + * Some of the Compressed Filter Tuple fields have internal structure. These + * bit shifts/masks describe those structures. All shifts are relative to the + * base position of the fields within the Compressed Filter Tuple + */ +#define S_FT_VLAN_VLD 16 +#define V_FT_VLAN_VLD(x) ((x) << S_FT_VLAN_VLD) +#define F_FT_VLAN_VLD V_FT_VLAN_VLD(1U) + +#define S_FT_VNID_ID_VF 0 +#define M_FT_VNID_ID_VF 0x7fU +#define V_FT_VNID_ID_VF(x) ((x) << S_FT_VNID_ID_VF) +#define G_FT_VNID_ID_VF(x) (((x) >> S_FT_VNID_ID_VF) & M_FT_VNID_ID_VF) + +#define S_FT_VNID_ID_PF 7 +#define M_FT_VNID_ID_PF 0x7U +#define V_FT_VNID_ID_PF(x) ((x) << S_FT_VNID_ID_PF) +#define G_FT_VNID_ID_PF(x) (((x) >> S_FT_VNID_ID_PF) & M_FT_VNID_ID_PF) + +#define S_FT_VNID_ID_VLD 16 +#define V_FT_VNID_ID_VLD(x) ((x) << S_FT_VNID_ID_VLD) +#define F_FT_VNID_ID_VLD(x) V_FT_VNID_ID_VLD(1U) + #endif /* __T4_REGS_VALUES_H__ */ diff --git a/sys/dev/cxgbe/firmware/t4fw-1.8.11.0.bin.uu b/sys/dev/cxgbe/firmware/t4fw-1.8.11.0.bin.uu new file mode 100644 index 0000000..2faec4e --- /dev/null +++ b/sys/dev/cxgbe/firmware/t4fw-1.8.11.0.bin.uu @@ -0,0 +1,8417 @@ +/*- + * Copyright (c) 2013 Chelsio Communications, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +begin-base64 644 t4fw +AAADpgEICwAAAQkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAA4sDmgOhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAENoZWxzaW8gRlcgUlVOTUVNIERFQlVHPTAgKEJ1aWx0IEZyaSBNYXkgMjQgMTM6 +NDA6MTQgUERUIDIwMTMgb24gY2xlb3BhdHJhLmFzaWNkZXNpZ25lcnMuY29tOi9ob21lL2Zpcm13 +YXJlL2N2cy9mdy1yZWxlYXNlKSwgVmVyc2lvbiBUNHh4IDAxLjA4LjBiLjAwAAAAAAAAAPj2L99g +AMAA4QAwuHj///8f/OFAgAAAAeEAe3AAABAAH//8EOEBlHAgAAAA4QGcBOEAeQAAAgBA4QB5gAAG +AEAAAgAKAAYACuEAeQQACgAAgAABAuEAezzhAHtE4QB75OIAAAAAAQAA4QB7kCAAAAAAAIAA4QB7 +AAAAQAHhAHucAABAAERERELgAAAA4wAEY0REREDjAAgAIAACXAAAAAAf/5BQAAAAAB//kFQAAAAA +H/+QWAAAAAAf/5BcH//AAAAAAAAAAAAAwAAS/88T/8+EIAQzAZMgEf/OEv/OkhAR/84S/86SEBH/ +zgH0MRH/zSIK/5IQAOQxAAUxAQIAEv/KAucxAhYAEf/JgRABAV/AIQIRAckREf/GEv/GkhAR/8YS +/8aSEGAADxH/wRL/xZIQEf/BEv/EkhCBEBH/w8AgkhES/8KSEsAgkhMS/8GSEIIQAvJQZS/3Ef+/ +xy+SEBH/vpIQEv++E/++kyDAMpMhE/+9kyKCIhL/vBP/vJMgIyIhFP+7BDMByTgT/7qDMAODFAgz +ERT/uKQzkyET/6yTImAACMIwkyET/6mTIhL/s5AgkCGQIpAjkCSQJZAmkCeQKJApkCqQK5AskC2Q +LpAvICYQICYRgiIS/6bAMC03MC03NC03OC03PCM9AXIz7QACABL/o8AwLzcALzcQLzcgLzcwIz0B +cjPtAAIAEv+ZwDAoNzAoNzQoNzgoNzwjPQFyM+0DAgAS/5YjCgAnNwAnNxAnNyAnNzAjPQFyM+0D +AgAS/5AV/5EW/5HAMNcgBWYBYAASBDYFAAIA0w/TDwUzDG47FAdHFAcEQ3Yx5gQ2BQUzDG877QAC +ABL/hRX/gyMKAAInAgcEQwQ+BQUzDAdHFG878AMCABL/f8kugyCEIYUivCJ0Ow6GULRVljC0M3Qz +9GP/5gBlP+JlX98S/3PAMgMuBQMCABL/asAwKDdAKDdEKDdIKDdMIz0BcjPtAwIAAAIAEv9tLScA +wBEBSTEASDEBAgDAABT/aQTSMRX/aJRQFP9oBNMxFf9olFAU/2cE1DEV/2eUUBT/ZwTVMRX/ZpRQ +EP9mAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/AAA +H/wAAOMACfgf/AAAH/wAAOMACfgf/AAAH/wAAOMACfgf/4AAH/+I8OMACfgf/4jwH/+I8OMAEugf +/4jwH/+I8OMAEugf/4jwH/+KcOMAEugf/4pwH/+QUOMAFGgf/5BQH/+snOMAGkgf/6ycH/+snOMA +NpQf/8AAH//9DeMANpQgAAAAIAABauMAc6QgAAF4IAABfOMAdRAgAAF8IAABheMAdRQgAAGYIAAB +nOMAdSAgAAGcIAABpeMAdSQgAAG4IAABvOMAdTAgAAG8IAABxeMAdTQgAAHYIAAB2OMAdUAgAAHc +IAAB4uMAdUAgAAH4IAAB+OMAdUggAAH8IAAB/OMAdUggAAIYIAACGOMAdUggAAIcIAACHOMAdUgg +AAI4IAACOOMAdUggAAI8IAACPOMAdUggAAJYIAACWOMAdUggAAJcIAACYuMAdUggAAJ4IAACeOMA +dVAgAAJ8IAACguMAdVAgAAKYIAGsnuMAdVggAoAAIAKTNOMCH2AgApM0IAKTNOMCMpQgApM4IAYK +IOMCMpggBgogIAYO0OMFqYAgBoAAIAaNEOMFrjAgBo0QIAduWuMFu0AgB25gIAdvLOMGnJAgCMAA +IAjAAOMGnVwgCMAAIAjAAOMGnVwgCMAAIAk2z+MGnVwAAAAAAAAAAAAAAAAgAA/2IAAP6CAAFAEg +AA/oIAATbSAAD+ggABCdIAATBSAAEoogAA/oIAASOSAAEeogABF9IAAP1SAAEScgAA/oIAAP6CAA +D+ggABC9AAAAAP///////w/8///w////APwgAJtzIACcsyAAnOMgAJypIACcaSAAnF8gAJwkIACc +GiAAnBAgAJvAIACc4SAAm7YgAJucAAAAAAAAAAAAAAAAAAAACgAAAAoAAAAUAAAACgAAAAoAAAAK +AAAACgAAAAoAAAAKAAAAAAAAAAAAAAAAAAAIAAAAEAAAAEAAAAEAAAAACAAAABAAAABAAAABAAAA +BAAAABAAAABAAAABAAAA/xgwYGAAAAD/AAECAgAAACAG8tUgBvGCIAbzwyAG85ogBvNxIAbzSCAG +8ycgBvL+ECBAAAAAAAAAAAAAAAAAAAQAAgABAACAAEAAIAAQAAggBw0rIAcNKyAHDLkgBwyAIAcL +vyAHC6UgBwulIAcNKyAHDSsgBwulIAcLiyAHC4sgBw0rIAcNKyAHC1IgBw0rIAcNKyAHDSsgBw0r +IAcNKyAHDSsgBw0rIAcNKyAHDSsgBw0rIAcNKyAHDSsgBw0rIAcNKyAHDSsgBw0rIAcLZyACivgA +AAABIAKK/AAAAAIgAo2oAAAA/yACiTgAAAD/IAKJOAAAAAAgAo2oAAAAACACijAAAAABIAKKOAAA +AAQgAopAAAAACCACikwAAAAQIAKKVAAAACAgAopcAAAAQCACimQAAACAIAKKeAAAAQAgAoqMAAAC +ACACiqQAAAQAIAKKuAAACAAgAorIAAAQACACitQAACAAIAKK6AAAQAAgAoocAAAAECACiiQAAAAR +IAKJnAAAAQAgAomoAAAAgCACibgAAABAIAKJyAAAACAgAonYAAAAECACiegAAAAIIAKJ9AAAAAQg +AooAAAAAAiACigwAAAABAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAA +AAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAABwAAAAcAAAAGAAAABgAMNQAAEEaqABRY +VQAYagAAACtoAAAjgwAAGGoAAA0GAAALKgAAAAAAAAAAAAAAAAAAaCsAAGgrAABsggAAb5wAAEpo +AABKaAAATSkAAEpoAABO6gAATJgAAFI9AABPuAABhqAAAYagAAII1gACCNYAAgjVAAII1QACiwsA +AosLAAII1QACtnIAArZyAAMNQAAEBgcAAAAAAAAAAAAAAAAgB1wIIAdb5iAHXAMgB1wDIAdb5iAH +W+YgB1wIIAdcCCAHW+YgB1wIIAdb5iAHXAggB1wDIAdb5iAHW+YgB1vmIAdb5iAHW+YgB1wIIAdb +5iAHW+YgB1vmIAdb5iAHW+YAAgIFBQgICwsODhERFBQXFxoaHR0gICMjJiYpKSwsLy8yMjU1ODg7 +OwAAAAAAAAABAxERCAgQCQMBAAAAAAAAIAREDCABeJAgAER4IAFPmCABdBAgAW1sIAEwMCADcNgf +/+tIH//nECAAnXQf/9rEIABsICAAXqAAAAAAAAAAACABURggAIq4AAAAAAAAAAAf/9TcH//GCB// +w+gf/8GYIABaGCAAUiwgAE9gIACUPB//34QgBeNoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAACABfqggAV9oIACmKCAApVgf//B4H//QBB//y0AgAIgkIASacCABErQgAPMU +IADeSCAA2DQgAMngIAC8pCAAqOAgBEe8IAOP3CABBjwgA6/IIAGkJCAAa+AAAAAAIACmhCAFAwQg +AJroIAFXaCAAApgAAAAAAAAAAAAAAAAf//OwIACmSCADkowAAAAAAAAAACADD+AgACXsIAAcACAA +JSwAAAAAIAAyQCAALuwgACu4AAAAACAAQ4AgAQnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAIABAiCAEQ6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAQjggAxaE +IABBQAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgLAAAAIAKQiAgAAAAgApCUCAAAACACkKAK +AAAAIAKQrAwAAAAgApC4EgAAACACkMgNAAAAIAKQ3A4AAAAgApDsEwAAACACkPwKAAAAIAKREA4A +AAAgApEcGAAAACACkSwNAAAAIAKRSA4AAAAgApFYEAAAACACkWgSAAAAIAKRfA4AAAAgApGQEAAA +ACACkaARAAAAIAKRtAoAAAAgApHICwAAACACkdQNAAAAIAKR4BQAAAAgApHwCgAAACACkggPAAAA +IAKSFAYAAAAgApIkBgAAACACkiwGAAAAIAKSNAYAAAAgApI8BgAAACACkkQJAAAAIAKSTAYAAAAg +ApJYBAAAACACkmAGAAAAIAKSaAsAAAAgApJwCwAAACACknwEAAAAIAKSYAQAAAAgApKICQAAACAC +kpAJAAAAIAKSnAAAAAAAAAAADQAAACACkqgKAAAAIAKSuAYAAAAgApLEAgAAACACkswDAAAAIAKQ +hAEAAAAgApLQAAAAAAAAAADXaqR46Me3ViQgcNvBvc7u9XwPr0eHxiqoMEYT/UaVAWmAmNiLRPev +//9bsYlc175rkBEi/Zhxk6Z5Q45JtAgh9h4lYsBAs0AmXlpR6bbHqtYvEF0CRBRT2KHmgefT+8gh +4c3mwzcH1vTVDYdFWhTtqePpBfzvo/hnbwLZjSpMiv/6OUKHcfaBbZ1hIv3lOAykvupES97Pqfa7 +S2C+v7xwKJt+xuqhJ/rU7zCFBIgdBdnU0Dnm25nlH6J8+MSsVmX0KSJEQyr/l6uUI6f8k6A5ZVtZ +w48MzJL/7/R9hYRd0W+ofk/+LObgowFDFE4IEaH3U36CvTryNSrX0rvrhtORBwwRFgcMERYHDBEW +BwwRFgUJDhQFCQ4UBQkOFAUJDhQECxAXBAsQFwQLEBcECxAXBgoPFQYKDxUGCg8VBgoPFR//wAAA +BAAgIAYO0CAGEkAEQQAIBAEACB//qSCBAAAAMAAAAB//nQClAAAAwAAAAMAEAAAf/N4AIAYPEB// +nRADgAAAAP/4AAEAAAAAEAAAgQQBAIEEAAABBAAAAQQBAIAAAAAABf//H/+EIAYAAAAqAAAAH//P +MCADybQCAAAAgBAAAEFAAABBQAEAgwAAAf//v/8f/5WMIAKLgAQAAAiBgAAADAAAAB//m4AgCN6Q +H/+QoP//AAD//wD/IAjewCAI3yAgCN8AH/+RQAAADnAf/5qgH/+fnB/84gAf/58QH/+flB/84ODg +//4AH/+V+A////8f/5Z8H/+cKB//mzQf/5ugAAAM4AAA/4AgCQPwH/+blAAAC4jhAC4A4QGSAB// +nGQf/5sk4AAAoOEAMLgAAIAA4QBgEAAAQADhAhAA4QIwAOECUADhAnAA4QAQCB/84UDhAHtwH/+s +XB//rFQf/OAIH/+sWB//rHQf/6xsH/+scB//rIwf/6yEH/+siB//qSAgBg8QH/zeAAEAAAAf/5qg +H/+ZpCAGDtAEAAAIBQAAAIP/AACBAAAAABAAACoAAAAgAAYoIAKK2B//iDAf/4QgH/+dEGdFIwHv +zauJmLrc/hAyVHYf/4AAIAjEUAAAPyggCMOgIAjEQCAIxHAgCMKwIAKQhM////8gCMLgIAjDMCAI +w2AQAAAAIAjDwD////8CAAAAQAAAACAIxAD//3//H/+dACAAIRwgCMcACAAAAAD///8gCMdg9/// +/yAIzcAgAB0A//7//yAI1FAAIAAAAABAAAwAAAAgCNSAAAD//wAAgAANAAAAIAAj4P/7//8P9oAA +AAP//wAAJ/8gCNcAAAEAAAAEAAAfgAA/IAAyQCAAOnAgAC7sIAAruCAI16Af/5oYIAjYACAJELAg +CNgwIAjYsCAI2SAgCNmQIAjZwAQBAAjgAAAAH/+atCAI2fAgCNlQUwAAAFIAAAAwAAAAUQAAAB/8 +4gCBgAAAH/+VjIIAAAAABgAAAABIAB//n6Af/5+cH/+QoAAADIgAAA2MIAA0eB//mUwgCNowIAja +kCAI2mAgCNsQH/+axCADLejg//4AIAkF0B//mbAgCNxAFAAAAIAAAACAAAACeAAAAIAAAAaAALAA +AAAKAADjMJL///AAgACxAOEBmgAAAgAAIAjcAB//l7wAAH5AH/+RNCgAAAAmAAAAH/+RUAYAAAAF +gAAAH/+Y1CsAAAAgAFVQNQAAAAOAAAADAAAAH/+Y2Af///8AP///gEAAAAgP//8f////IAAAAB// +mpg9AAAAH/+WNAcAAACBBAEAgQQAAAAAOpjDAAAAGAAAAB//kZAAAA//AEMAAB//mmQAAAgABAAA +AB//q9Af/6lA4QB6AB//lfQf/5mAH/+bAB//mZwgCRYQAAMHgCAJFoAf/5iEAEAAAAAACQAAADAC +//z4f8AAAACj/7sAo/+6AOADAACD/7YAD////w//+AD/AAAAIAkWwCAI3iAgCN5QIAkXUAAPAAAA +CgAA//8ADx//mYgD/8AAg//AACAJF9AgCRhAH/+bGB//qbD/YPAAH/+pkB//kGAEgAAIH/+AUABE +AAD/H///AMAAAAAAgQAf/OIMDwAAAP//AAAf/5q4H/+fmB/84ggf/5YwH/+AYCAGDOAAADAAAAAn +EB//2dgf/5lw3q2+7zQAAAA/AAAAAACJBgCZAAAf/6j4EAAHAu4AAAABwIAAH/+nyJkAAAAf/6m0 +AIgACIKAAAEf/6lIH/+oVAMVAAADEQAAAA8D/yAI47AgCOPgIAjkICAJIFAgCSEgIAjkQCAA0OQg +CSCQIAkg0CAI5HAgCOSgKQAAACAA2dTw8PDw/wD/AKqqqqrMzMzMH/+rwAAAGyAf/6nIIADpGAAP +QkAgA7W4H/+bIAAJAAAAgAAAIAELzAAJAAgf/6i8H/+pBAAACAYAAIjMAACJFH8AAADwAAAAIAki +sCAJIeAgCSKAH/+XlB/84HQABAP/CgAAAB//p+Qf/6ikH/+ZoIP/twCD/7YgIAjqIDMAAADhAAAA +H/+oxB//mdAf/6kMA//gAAA/9pAAABpkA//wAAAQAAEAABpsGgAAAB//mQQgCOpgIAFHLB//qQgA +D///AADerR//qMAf/5qQH/+ZrCAGCiAf/5kMH/+bCCAAcEAgAAXoH/+XaB//lcAgCSPwH/+edCAJ +JEDABAAAIAKMECAAcOAf/5ecAIEAAOABAAAA4AEAAADgASAJJYAgCO0AAAANlCAAmIwgAJYUIAkl +ACAJJVAf/5e4IAjvoB//n6wgCPbQH/+arB//koAgCP3gIAj+cCAI/oAgCP6wSAAAACABhiAf/5pw +IAGIFB//lfgf/5os4QAuAB//mjThAF4A4QIOAP//v//hAA4A4QGOAP//vv8f/5s0AAALiB//nHgf +/5x0AAANwAAA/4Af/5xsH/+c2CABi/AgAZWcA/8AAP+///88AAAAAAX//4MAAAAf/5vUIAkFcCAB +qNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAACBgAAAAAAAAB//+eAf//ngH//5pB//+aQf//mkH//5pB//9Ngf//ds +H//2EB//9hAf//YQIAXlYAAAAAAAAAAAAAAAAAAAAAAgBejgIAXo4AAAAAAAAAAAAAAAAAAAAAAg +AY6YIAXlYB//+GQf//hkH//4ZB//+GQf//hkH//4ZAAAAAAf//TgAAAAAAAAAAAAAAAAAAAAAAIB +AAAAAAAAAAAAAAAAAAAEAAAAAAAAAIGAAAAAAAAQBQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAgQAA +AAAAABgFAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAACgQAAAAAAAAgAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAACAKABHyOxPyO9MPA+YxAQIAFvI5F/I6d2sGkGC0Zndj+FQOnFWSVw8UAGP/+QAAAGwQ +BBjyNx3yMisgBxzyMiohCPoCAAdxuwEA7tw5DdwCgAALqgKcMOPyLBmwBIAACKoCHPIqIzCA+kAI +FeANBQCdZexmAiG43QAA+sCGFaR3HQDpfP8t3gKAAOt7AgzPAoAA62YBJMvhAACZYwIEiZNnKGYG +BiCLGPIbJSEJ9MFmFaQzHQDlZgorkASAAOgABQMowQAAbTkCBQJh0Q8AAABsEAQc8gsmIAcb8gof +8hD+QQQVoNYRAA3LOZswhyD75A4FoAklAPpgRhWgGAUA6DYDK74CgAD45gAMcWYBAPhgJhWgDAUA +5SBXKzQCgAD3xgAOsCsFAP+mAA7wCjUA6PH6EoIBgACcNZw3mzMZ8fkKdQKVMZk2JSEJnTQvIAec +OZQ7+KYACTH/AQDiNgov/AKAAA/uAgjuAu42CC0QBIAA0Q8nIQgqIQmcNZQ3BncCCKoCmjYIdwLn +NgQskASAANEPAAAAAAAAAGwQCCggBScgBykxBfgghhXgGUUA+QAMxWF3AQCKIhbx2xjx2/FVDA3g +DZUADHsRprsssp79gAxD4AqlACuynesWBSWMOYAAjIj3gAxwkgCdAC1irmTROCtireSxNGZz/QAA +7oYIJYm5gAAoIBSkiAgIRygkFPUAC73QDwUAGfHFLiIWLCEpiBUa8cSuzJqA6iIeLmfCgAD9AGYV +oA0lAP0ARhXgC2UA7fGzHVYCgAALqgKLFJqB6QAVBEBBAACJFQgAiig8EP0gxhXgTAUA/SDmFaAM +RQDsuzYEyIEAAG25BQgAhgkCYe7xpRWgh4AAiBXuAAUNzwKAAKmI6IwgJaQ1AAALyQxtmQIIAmEo +ISnqISgkQAUAAAgITyglKflACEQiAJ0A/+M6BeAMFQD6IKgV4B7lAOoiHixtQoAA/CAmFeAJBQD4 +IAYV4A0FAOkWAiXZgQAAWHWoDH4R98AARzANlQD906YV58UBAPmABilSAJ0AwCDRDwDqJAAJ2ASA +AOxEAAroBIAAWHdd0qDRDwDAsArPNO+GCC32jgAA2iD8QGgdoBvFAFh5N2P/ygAAAOokAArYBIAA +WHi80qDRDwD/+ewNoAsFAAAAK3wY6iQACWAEgABYeStj/5zAoFmM6BjxbIyI+Z/zQJAKpQBj/6wq +IQn8QrAVr/0FAA2NAQ2ODC4kFO20Ay5hAoAA77QALVYCgAD9RgANMAkVAAmqApqx+NWmFe/5YgAv +JSn/+9QNoAgFAIon60QACmgEgAD7RAAVoAwFAFhyFNKg0Q8AAABsEAYoIAUrIhDkIAcqUASAAPgD +Ah3gHsUA+94ADPAZRQD5AAxdYUQBAIwiH/FE6hYALgseAAAMSREPmQgtkp4PAgD3oAvjUgCdACeS +nQwGPmRxbospKiIKC6oM90AJC6IAnQAqIE4sIEyxrfuACyQgCxUALSROKjABKSIY80ALRpIAnQAr +IAcsIST8YCQV4AhVAPlABAQwqxEA4IgRDVKCgAAKiAIa8SoI3QIoIQcrIQkKzAL7pgAOuogBAOrx +JhxDAoAACLsCKCEinXCNIJtznHT7BgAMMAplAOh2Ai7uAoAACt0CnXEsIhCcdSsgOBjxGvwAIh3g +TBUA/OEmFeC7GQALzTkc8RWeePsNAA5wCAUAmHcNzAKcdu3xChTYBQAAKyYYG/EAmHuZeu0AFQPI +wQAACQCK63YOIchBAADudg8j8QEAAAkghg4CYwkAhg4CYQxMEa/M6sadIwCpgACOKS0gOKbuninz +oAVXkgCdAAUPR/ngBFFSAJ0AwCDRDwDqJAALWASAAFhRIcHs7/DrFXaRgADqJAAJ2ASAAOwSACro +BIAAWHbC0qDRDwAAAADqJAAK2ASAAFh4KNKg0Q8AAAArTBjqJAAJYASAAFh4mWP/wYgiwJQJiAL4 +QEYVr/7eAAAAAAAAAPxDqBWkiQEAAIEEAL0aDcwC/EOmFa/6HgCKJ40QwMDqrCAu2ASAAFhxjtKg +0Q/aIFh2bGP/UQAAbBAMLSAFJiIQLyAHKyE15RYDKcAEgAD7AIgVpzUBAPJ/wBXgDBUAA8M5+0EA +DXAVhQDrggIsYASAAPdeAAqx/wEA9wAwFaAVRQD1oB/VY7sBAIkiKBYA8z1cDeAOhQCYEPLAHgcS +AJ0AnxKfGpsWFvCrkxXqFgQvrwKAAOZVCAIwDQAA5hYJInAFAACIGi4WCCsSCfUABmISAJ0AKlKe ++0AJq+IAnQAvUp1k87sY8JyIiPcACViSAJ0AGfCYKZKuDAM+6vCWFIn5gAAqoq0W8JTqFgska/0A +AOsSCyUJaYAA7WYIJZuZgACIKYcqCHcM8uAJY+IAnQApGgDzIjIN4Pr1ACsgFpwR+2AJrSIAnQAY +8IyGFI3DKiA4/eDmFeAJBQD54SYV4EcFAPfhBhWgqhkACnk5F/CDKyIXm/orIhub+43ECng5/MAP +EuIAnQCYF54dhhWcEZkc5xIMKwgeAABgAX4Y8G+IiGqBJooZKVKeepNDK1KdmxuNG+nwaRQz/QAA +79QABoHZgACWmGX/HGAC1Z4d/CAmFaAKBQBZi9wY8GCIiIwR7hINJA8HAAD//2gNoA8FAADAkPgh +ZhXv/u4AG/BXwKoKijT7YQYVr/7+AAAAAAAAAP/7OA2gDwUAAJ4dnx78ICYVoAoFAFmLyBjwTIwR +iIiPHo4d+R/12JIAnQBgAlHAkJkbihsd8EXAuguLNOvWCC12jgAAYAI4AJ4dnx6cEeokAAnYBIAA +WFBwjBGPHu4SDSV1+YAAYAHvAJ4dnx76QPAVoAwFAFhQvIwRjx7uEg0tdcYAAGACxgCIEY4X9iDI +Fa+MBQAsJDuMFAZ2AgbuAqy5DNoMmoTpJhssWASAAO0iEClQBIAAWHdtjh2MEfqzphWhBwUAc3sI +KyAWKAr/eLleiikpIDijquomCST5poAALyIQLSE1+4CIFeAIFQD4IKYVoAY1AJYTDbs2+iCGFeAd +hQD/fgAO//a2AIonnx6LEOqsICpgBIAAWHRkjx6aESsiG/1AiBXv/YYAAAAAAADqIAcp4ASAAFhQ +dowR/iGoFa/+QgDaIFh1o4wR/iGoFa/+QgAALSIQihYrIDsW8AQKmQIJiQLmmAINifYAABrwAfhE +hBXjaQEAh8DrIAcrMgKAAAaZAiYhB/rgBAOwuxEA6u/xHdqCgAALdwIrISIKdwIqIQmX8IcgnfX5 +4MYVqmYBAOn2BCszAoAABqoCFu/n6vYDK74CgADn5wIHyMEAAOf2ASZAgQAA5rsCAlP5AADr9gIi +FDUAAG2pBQgAhgkCYSggFKSICAhHKCQU9QAGrdIAnQCKGPqzphWhCQUA8yHyDeD89QArIBb9YAkV +IgCdAC0iF7Hd7SYXIYCpgACPKS4gOKP/nynzwAe/kgCdAIYVZWDSwCDRDwAAAAAoIE5kjD0OmwKb +IusSAClQBIAA7RIDKmAEgABYdZPSoNEPAOsSAylQBIAAWHb60qDRDwDaIPxAaB2gG8UAWHdsY//H +AIsS2iDrvBgpYASAAFh3Z2P/tAAAAAAA6iQADlgEgAD8IIgVr44FAO4kOyxwBIAAWHbq+iEGFaAP +BQAvJhv+R2Yd7/yCAIsbKiEJ/EKwFa/9BQANjQENjgwuJBTkzBANVgKAAAyqAv1gZh3gDgUA/2AG +HaAGFQAGqgKasRnvjvc1phWv+8oAAIon60QACmgEgAD7RAAVoAwFAFhwSdKg0Q8AANogWHUnY/8E +AAAAAADqIAcp4ASAAFhP8mP+04sS2iDrvBIpYASAAFh3OGP+92wQCCggBe3veBnQBIAA897qBeAe +RQD/AAq1IAylACsgTinSCNMP6hYDJdv9AAArJE73IAiYkAcVAC8yrmTyMCoyreakAAURkYAAsJjo +1gglCIGAACkgFLOZCQlHKSQU9SARLdIAnQApIHMrIh37IAQA3//1AOB6GgTABQAA/1cAD/SIAQAo +JHP7QAQFcAgVAAqKOQ+7AesmHS0HPgAAiiJ8pwQrIE7KtH2nCC0gTCwgTn3DGcxsLiAU7yICL1gc +AABk8fzAINEPAAAAAAAAiCfHkwmpAekmAiRQwQAAWGfg4+9OFQE5gAAooADTD9MPA4gKKIIQ7KAH +LVgEgAD6QGgdoA1FAAuAAGWv3Ikn0w9kn6EqmRTKp4qZZK+XKKAAA4gKKIIQ7KAHLVgEgAD6QGgd +oA01AAuAAGWv4GP/dQAA//9UDaAKBQDAoFmKox3vJonYLAoK+T/3AJAeRQAmCgApIBSzmfhChh3v ++/oAAAAA6iQACtgEgABYdmLSoNEPAAAqIAUrIAcPAgD/QA8VIbsBAAUFR/igDylSAJ0AjhPu4gYv +eASAAJ4UC74C9WAKchIAnQAMuhEDqggoop73AA580gCdACqine4WASUK8YAA+kAIFeAMFQBYI+Ub +7wQvIQke7vooISItIAcc7wwpIST/BgAMMN0RAO4SBC7qgoAADZkCDJkCmaCMICimAv9AZhXgDSUA +7qYFLmYCgAANzAL9QCYVoAkFAOsAFQVQYQAAsZnqgx4Mj+gAAI8RDP8R8+AAR/AOpQAu9p30v/KB +EgCdACoiB+tEAApoBIAA+0QAFaAMBQBYb6Jj/jIAAAAAAP/3OA2gCgUADJs069YILW6uAABj/tkA +AC8hCfhCsBWgCwUA+sAGHe/6BQAKmgEqZAPqmgwMQQKAAOokFC/+AoAACP8CB/8Cn2H2daYV7/aq +AIonwLD7RAAVoAwVAFh2YB3u1J2gjCAb7tPrpgIuZgKAAAfMAv1AJhWgG8UA7CQACVAEgABYdnnA +INEPAACJ2PcgBKiSAJ0ADOoRo6ooop73AAV80gCdACqinWSgprCYmNjuFgEtdVYAAIki6xYAJIUZ +gACfEvi/6yFSAJ0AiifAsPtEABWgDBUAWHMAHu60nqCNIBvutewSAi7uAoAAB90CnaGMxpyj+0BG +Fe/0ygDrVAAJUASAAFh14mP9H48Tj/P+IIYV7/iOAAAAAAAAAP/40A2gCgUAAJ8SmxH6IAYV4AoF +AFmKDB3ukIsQidiPEo4R+T/6iJAMpQD//YwNoAoFAMCgDJg0+aEGFa/9WgAAAACLEO8WAilQBIAA +67wYKWAEgABYdj3+IEgV7/0iAGwQBCggFO+LHmoYBIAAiif6YGgd4AwFAOqsICnoBIAAWG830qDR +DwCLInO+fhTucolIapF6G+5v0w8ssq5kwFgqsq1koFSwne1GCCUC4YAAKSAU6SQULNrcAAAvIQn4 +QrAVoA0FAP1ABh3v/AUADJwBLKQD7JwMDEECgADsJBQv/gKAAPnmAA+wDhUADv8Cn6H/daYVr/3m +AMCgwOoOnjTuRggtfWYAAI8iyfXAINEPwKBZic2JSPk/+9CSAJ0AY//lANog/EBoHaAbxQBYdgfA +INEPbBAIiS/vITQpsASAAPZg6BXnhQEA7iAHKlgEgAD7H8AVoAQVAPqNAA0wHUUA/uEAC/HuAQDp +fR8MFIAAACggTw8CAO8gTSRABQAACAhHKCRP+eASu6IAnQAvIAWbEZoQ/eAQ3WIAnQCJIsej+UAN +gOIAnQAsIhmLMv1gEv0iAJ0AjTiPERjuJunuKBaRQYAA6RYCLycCgADoRAgH+A0AAPXADKISAJ0A +KUKe/yAZK+IAnQApQp3tlAAEkWGAAIspiioMBT4Lqgz1QAmr4gCdACwaAPWB8g3g+PUAKyAW+WAX +1SIAnQAa7iApISQrIQcKmQIqIQkLC0oMuxALqgIrIAcc7gwLK0Do7hkd2oKAAAy7AiwhIpvQiyCZ +1JrTCMwCnNL9YAAVsAxVAAy7ApvRG+4Qii+a1SkgOPvcHAWgDAUA/aDmFaBIJQD3oQYV4JkZAPlN +AA3wCiUACYo5iWSZ2YhlmNr8wMgVoAkFAOzWCyOH4YAA6e4BHMKCgAAJiAKY3Ixol9+c3owSiWkp +1hCIaijWEewAFQbJIQAACQCKjGf84AqjogCdABnt6Qq4AgmIApjWwPX+k6YV4Q4FAPXB8g3g+vUA +KyAW+2ASBSIAnQAuIhmMKS0gTysgOOXMCAdwBQAA7iYZJuv9AAAtJE+cKfNgDgeSAJ0AjRBl0b7A +INEPnxOeFJ4VnRbqJAAK2ASAAFhN+I0WjhTvEgMldaGAAI4QZe/XiifbMOwSASVQwQAAWHHwwCDR +Dxrtu4qo90AOyJIAnQArQp7/YA+z4gCdAClCnR3ttOSR6mVj/QAAnNjtlAAM8tYAAGAAegAoIDnx +H/gOEgCdAP/75A2gCRUAwaN6+RIpIDr+IKYVoAv1APsgECViAJ0A6iQACtgEgABYdOjSoNEPAAAA +AAAA8AAYDaAa1QDAoYw3KyEJjTiOMuuvEQ3dAoAAD7sC5LsCCVAEgABYdMrAINEPAAAA//9YDaAa +hQAAACvsGOokAAlgBIAAWHVJY/8oAAq5ApnWwIX4k6YVoQwFAHXLDSsgFioK//tgDUUiAJ0AixBk +sTaLaoxnimmrewfMDJxn92DSDeANBQCxqoxlm2qLZppprNqre3e7AbGqm2aaZYgpLSA4pYiYKfOg +CT+SAJ0AiScqmRTKpouZyrKfExnteyiwAJ4UnhUJiAooghAssAf6QGgdoA01AAuAAI4UjxOLIsej ++1/zYOIAnQAoITSHZ/xB6BXgCRUAmRD44QALsBxFAPz+AA5/88IA2iBYcv5j/juKJ+qsMCtYBIAA +WGAs0qDRDwAAAAAAAAD/83gNoAkFAJ8TnhSeFZ0W+kDwFaAMBQBYTdWNFo4U7xIDLWd+AAAr7BLq +JAAJYASAAFh1BGP+E+ogByrgBIAAWE22Y/21nxOeFP4gphWgCgUAWYi7Gu0+iqiOFI8T+V/weJIA +nQD/+IgNoAkFAMCQHO04wLoLqzT7gQYV7/hCAJ8TiieeFO4WBSnYBIAA7BIBJVDBAABYcWLuEgQt +MASAAP4gaBXv+pIAnxOeFO4WBSlQBIAAWHLJjhT+IGgV7/siAADBU/pAaB2gCwUA/AACHaANNQBY +bNkrIAWOFfV/3Z1iAJ0AY/1jnxOeFJ4V6iAHKuAEgABYTYmOFP4gaBXv+RYAAGwQDJUTJiAFLyAH +hy/qMgQpwASAAPxGhBXnNQEA8n/AFeAOFQAD4zn9QQANcBtFAOerHwxgBIAA+sAehWH/AQCJIpgQ +8zrMDeAOhQAmgAGYEPLAHKcSAJ0AnxKfGhns+5MXFuz56hYGIlgNAADrFgkvrwKAAOZVCAJwBQAA +iBqeGI0Z9QAFWhIAnQArUp79YAgT4gCdAC9SnWTzkIiY9wAH2JIAnQAW7OgmYq4MAz7q7OYTCHmA +ACqireoWCyRr/QAA6xILJQgBgADtlgglmnGAAIcphioHZgzywAfb4gCdACgaAPMCMg3g+vUAKyAW +nBH7YAgdIgCdABbs6CogOPvZzAXgDQUAnff3gIgV4KoZAAprOYYWxIAKjTn2wA9y4gCdAJ0UjRfr +FgUuh14AAGABjoiYaoEgjRkrUp59szwvUp2fG4YbsIrvZAADAdGAAJqYZf9GYALUnhz8ICYVoAoF +AFmINhnsuYiYjBHuEgwkDx8AAP//aA2gDwUAwLD6IWYV7/8KAMDaDY00/SEGFe//DgAA//wEDaAP +BQAAnhyfHfwgJhWgCgUAWYgkGeyojBGImI8djhz5H/dYkgCdAGACWcBglhuKG8C6C4s065YILXgO +AABgAkOeHJ8dnBHqJAAJ2ASAAFhMzYwRjx3uEgwld4GAAGAB+54cnx36QPAVoAwFAFhNGYwRjx3u +Egwtd1YAAGAC05wR/iGGFa+IBQDoJDsmOEEAAOcDHgewgQAABgJhhhaW+I3Hh8SIxq1tBncMl8R2 +2wouFgzsFgEkQAUAAIwWixGGFI4VmLadtwbuAu0iDylQBIAAWHPBGex4jhyMEfqzphWhBwUAc3sI +KyAWKAr/eLlciykqIDiju+smCSV5qoAAhi8vITT9gIgV4AoVAPog5hWgCDUAmBMP3Tb8IMYV4B9F +APe+AA+/9wYAAJ4ciiefHYsQ6qwgKmAEgABYcLfvEg0tYASAAP4hiBWv/NoA6iAHKeAEgABYTMqM +EY4c+disBe/+QgAA2iBYcfaMEY4c+diiBe/+NgAmIDsX7FntuwIHyIEAAPmCABWjqwEA57cCCwjG +AACTH43AE+xSA90BIyAHAyNACjMQA90CE+xGJiEkA90CIyEH6yEJLVICgAD6xgALOjMBAOohIimb +AoAAA7sCgy+d8I0glvSX9pP1m/ODH+vsOh7uAoAADe0CnfELqgLq9gIiDD0AALBKbakFCACGCQJh +KCAUpIgICEcoJBT1AAZd0gCdACoSCPqzphWhCQUA8yHyDeD89QArIBb9YAilIgCdAMg/jiktIDij +7p4p86AHr5IAnQCPF2Xw0sAg0Q8AJiBOZGxpDpsCmyLrEgApUASAAO0SAypgBIAAWHHt0qDRDwDq +JAAK2ASAAFhzVNKg0Q8A2iD8QGgdoBvFAFhzxmP/xwCLEtog67wYKWAEgABYc8Fj/7TbwPwgyBWv +jgUALiQ7CCCGCQJj7PYIKVAEgADtIg8r8ASAAFhzQ/ohBhWgDwUA/kdmHe/8qgCLGyohCfxCsBWv +/QUADY0BDY4MLiQU5MwQDVYCgAAMqgL9YGYd4A4FAP9gBh2gBhUABqoCmrEZ6+f3NaYVr/vyAACK +J+tEAApoBIAA+0QAFaAMBQBYbKLSoNEP2iBYcYFj/wYAAAAA6iAHKeAEgABYTExj/uGLEtog67wS +KWAEgABYc5Jj/vdsEAYoIAUlIAckCgP3AAVkUVUBACggImSAoQIqAlhq+vlABMDQBhUAKSAh4+vI +GAQKgADzIAQv0gCdAOxZEQKlaQAAo5kqkp5uo3Qrkp1ksGopICH6QAgVoPzlAAyZAfcmAAywDQUA ++EQmHeAIBQD4IAYVoA6VAPggJhWgDwUA+CBGFaAMBQBYb8wMXRGj3fWzphWgAgUA0Q8X662KeGqh +JgxZEaOZLpKebuMtK5Kd5LApZWP9AACceGW/lMAg0Q///igNoAsFAMCgWYcdinhroc7//4wNoAsF +AMCwwNoNrTT84QYV7/9SAAAAAGwQCiwgBfhA8BXgCxUA+GBoHaelAQDoFgAlU/kAAOq6OQoYBIAA +6hYELCAEgAD9gcAEUZkBAMGz+4AbBWIAnQCMImXC5hvrhrQ+7hYDLMcCgACriOgWBizABIAA7BIG +KAQKgAD1AAQiEgCdAI0TLMKejxb9gAcr4gCdAC/yne8WBSeVoYAAJSEbikKGKpgYBaU29U8ADfEH +BQB7cwHVoIcpB2YM9MAF4+IAnQAqGgD1QjIN4Pz1ACsgFpgY/WAF/SIAnQCNKaXdnSmKQvqgClKi +AJ0AjBQb63mHQ5gYmRnrdwEGB+mAAGAArgAAGuteiqjoFgglDL+AAIsWjBMrsp6PFnyzQC/ynRvr +V+TwOWUz/QAAlrjvFgUv+24AAGACFQAAAAD4ISYV4AoFAFmGyRrrTYqoiRnoEgglDv8AAP//TA2g +DwUAwPAc60fAugurNPuBBhXv/wYAAAAAAP/8eA2gDwUAmRnqJAAK2ASAAFhLcYkZ6BIIJXmpgABg +Aa0AmRn6QPAVoAwFAFhLvokZ6BIILXmWAABgAozudAAKWASAAOWsDAroBIAA7xIFKVAEgADsRgIp +4ASAAFhvs4gYiRmOFvvTphWhDQUAddsIKyAWLwr/f7ktwGH2IIYVr/oCAIonixDqrCAp4ASAAFhv +dsCy66QCLSAEgAD7QEgVr/5yAAAAAOogByrgBIAAWEuIiRn4IQgVr/8GAACIQ4tAjBTpEgUsOASA +AP8AaB2n2wEA7RYBLgieAAAnIAcY6yEHB0HodwoEyIEAAPb0KBXgrnEA7qwQDVPCgADsqgICQEEA +AOp3AQHT/QAA5+cCAYxFAABtqQUIAIYJAmGOQ4tAwICYEhjrEhbrEokRjxUc6w4tIQf11hoFoa4x +AKyq+1AQFardAQDsIRou7wKAAATdAp3wHerlCloMhCCc9uf2ByTgQQAA6vYFJMg9AADs9gMh0AUA +APaGAAs0mR0A5vYEJMgFAADpOQwKJgKAAASkApTxCY05nfItIBTj3QgNIASAAO0kFCWp7oAAjxaI +EvXzphWhDgUA9cHyDeD29QArIBb3YATNIgCdANKA0Q8AiBRkgJvAINEPACucGOokAAlgBIAAWHKF +Y//kiif4IOYVp5tBAOqsICgECoAA9SAEedIAnQCMFcCx7MwgKegEgABYa3+aEo5D+oAIFe/8KgAA +AACLFexNEQlQBIAA/WAARfAMFQBYabT0gGAVr/3CAGWsoPmf5OjSAJ0ALyAg8f/kl5IAnQBj/3sA +AAAAAAAA6iAHKuAEgABYSxqIEtKA0Q+KJ9ww6xIAJVCBAABYbvvAsvtARh3gAgUA0Q8AAAAA+mBo +HeAMBQDtNAAMOASAAFhrW9tA7DQACugEgADqFgIr8ASAAO8SBSlQBIAAWG8b+oAIFe/7VgAAACuc +EuokAAlgBIAAWHJJY/70AGwQBBTqpiRAgAhEEfqAaB2gCxUAWYRlGOqPZKBC+EYADDAJJQCZoeim +ACEByYAAaCEcbyQZ7iIWZUghAAADQIgJCIoDIIgJBIoDAIgJAIraQPoAQh3gDBUAWYe9wCDRD8ck +0Q8P6DCfog7uMJ6jDcAwnaQMsTD9QKYVoAsFAJum+0DmFe//LgBsEBQjFhqUGYkwIhYb+iNoFedl +AQD838AVoA0VAAzcOSqwB4u3/CGmFaeZAQD4IoYV4aoBAOoWCiXYgQAAKxYe9MAvgRIAnQAuEhuO +4mXkJhLqVYIoE+pS9kAwAJAPpQAmMq5kZiMpMq1klh8a6k6wKJio7ZQABK/5gAAuEh4oEhr7wKQV +r8UFAAXuAS4WHO6uCARAgQAA7uxALCgEgAD/AC/KogCdACYSGiISFCUWFvbAaBWv+AUA5hYRIRA9 +AAAIKQGlluYWECsoBIAA/sAumqIAnQCdFpkVjBkkEhqOGhbqMpYX/iJmFaSiHQDqFhUi2BEAAOsW +CyLQIQAAmhwb6kIqEhvkQQwvdwKAAOPuCAZgQQAALBYSJBYZLBIcKqEHFOo9LhYY/YgAFaqqAQDs +FggtVwKAAAuqAvoh5hWgB7oAAAAAAAAnMADqIgwEyAUAAOoSHid4BQAA/+BoHaBvAQDzKzAN4A8V +ACsSHCzQACqhBQXMC6ur67xALiAEgAD7gBUC4gCdAAkMQPoAIh3gCgUADLo4BKsL5KoKBaAhAAD6 +I6gV4AwFAAb8OBbqHAt3C6bGJmCQ58sLDXgEgADnzAoF2GEAAOhoCAZgQQAAivAEAIkCqjaawAsA +i4zw7dwBIZgFAADzn/rrogCdAI0UAssMCsMMk/DygAgVoAcVAPKAKBXgBgUAC3Y4qWmjo5NBejsC +IiwBkkDzABnf0gCdABzqASMSGSISGhTp/hrp/O4SDycwBQAABNQB6toBDM4CgAAJRAIpEh0KZgIt +EhuWlJRQjycmEhUkEhcD/wz4IsgVoTgdAJ8no2MS6egvEhSTHp5AjdD+I8gVoAsFAO9GAyGYBQAA +4kYCLs4CgAD4ZgAM8ApVAOlGASIQQQAA5hYBKXgEgADoFgApoASAAFmHsi0SHioSFS4SHC3RBSgS +FisSEK7d7dxAKUgEgAD7oBWD4gCdAG2pBQgAhgkCYQM0Ai4SES8SGu/yBy8NLgAAZPGq9dOSBaDy +9QAc6cwuEhovEhgtEhsu4Q3z86YV4ApVAP2gCBXgCwUAWYeXJhIb0w8mYBbywAoFIgCdAC0SGy4S +GigSGf2gCBXgClUA/8DoFeALBQDoFgAqYASAAFmHii4SGy7gFiMK/3PhCioSG4sdWCwzZKKMLxIT +JhIYJxIS9eAFwhIAnQAmYp4pEhj2wBNT4gCdACmSnekWFySHeYAAKhIaIhIZiVCKpy4SF/gghhXg +CCUA+kEACTeZQQDiFhkkkRmAACoSHh3phisSHCqhBa2dLdAAF+mDq6sF3Qvk1AAF2QEAAPugEErg +yQEA+gAiHeAKBQAMujgEqwvkqgoFoCEAAIwV36DnnQgLmASAAP+AAEYwDgUA7BYdJlhhAAD9goAV +r/bqAIQc+iFoFa/2CgAA+48ACj/1ggAS6V6CKPZADpiSAJ0AJhIYJxISJmKeKRIY9sAOy+IAnQAp +kp0b6VXkkc1hU/0AAJq46RYXLPmGAABgABMrEhoqEhsrsQ1YK9hj/rTAINEPAIsaLBIb67wYLlAE +gABYcQPAINEPLOEAscz9wAQdr/laACUSGiYSGSVRDAZVDGVR/yYSGyZgBPTAENkSAJ0AIhIa4xIX +KbcCgACIIaYzIiIC5oI+adgEgADzABLgUAcFACkSG4oZKJAUhB6qiPaAAEJ3iAEA6JQUIiAFAAD1 +ABJeUgCdABzpTC4SGi8SGC0SGy7hDST2nf2gCBXgClUA9c8AD3ALBQBZhxUvEhsv8BYmCv928Q4r +EhorsQ0qEhsFuwxYK6UqEhuNGYqnwMDqrCAu2ASAAFhp1tKg0Q8iEh2LF/MAAgEwBwUA6wAVARBB +AACxd+KDHguP6AAA+QAgFa/ymgAAAC8SFtMP79oMCUAEgAD4IqgV5OodAPHBIA3gDQUADwCG6AwA +BugFAAB+2fEoEhePGA6eDPlAAEQwDQUA5O0hZEBBAAAPIIboLAAG6AUAAH7Z8WP9Cxfo/4Qc+iFo +Fa/4XgAAAPuvAAo/994A//ZkDaAJBQCLGiwSG+u8Ei5QBIAAWHClwCDRD8CgWYRiEujlgij4X/EY +kgCdAP/4/A2gCQUAwJAY6ODAagYmNPcBBhWv+LYALRIU3EDt3A8p2ASAAPojyBWk3R0AWPq4+iNG +FaAOFQD+IaYVr+fCAMCgWYRNEujQgij4X8+wkA+lAP/oBA2gCQUALBIb+4BoHaAbxQBYcIXAINEP +AADAkBjoxg8mNPcBBhWv53YAAAD7DwAKv+geAPrPAAq/6LYALBIaLxIWLsAVLcAUK8AR7MEJKVAE +gADu3QgLcASAAFj6jWP92igSGykSCSaAFC8SGglmCCaEFC/yAPH/8LKSAJ0AKxIX6hIbKe8CgAD9 +YABF8AwFAFhnqPRgYBWv9+IAAAAqEhvrNAAJYASAAFv2jCgSGoiBDKsR6zsIDTgEgADxH+1gUgCd +AOoSGylgBIAAW/Zb90AAQ//2ZgCMFvYjaBXv/wUAD48BD4YMJnQULXEJ/uKwFaALBQArxAAvxAPk +7hAO7gKAAP+mAA6wCRUACd0CncEa6Ij5VaYV7/XmAABsEAiIIi8gB5UU9CBmFaD99QDxGCwN4f8B +ACggFn2BLCsSBNMP0w/+IMYV57sBAPt/wBXgCRUA65s5CVAEgABYKxkvEgbzTpAN4P31ACwwDxXo +ahvocRbob+VQgC4LhgAAhxOwdyVcN/4gphXkVR0A5XUID88CgADmmQgCqA0AAPXgBuIQDKUAKJKe +9QAUy+IAnQAlkp3kVAACigGAAIq490AKOJIAnQAuYq5k4QEpYq3kkP1le/0AAO+2CCSIAYAAKCAW +fYEOmRDrMQYpUASAAFgq3YkQjBMqIBQrIAQMqgj1YAkZEgCdAAoKRyokFPVADK5SAJ0ALTAPKRIE +8bEcDeeZAQD5IA3pUgCdAOlUAAHAQQAAbXkFCACGCQJhwKCaEgx0EaRUKCAE9QAJ+RIAnQCJMeQW +ASpYBIAA5TICLI0iAADzIA4AUAQFAKR5ihXiEgItVwKAAKaqKaad0Q8Airj3QA8QkgCdAIkVDJkR +ppkukp71wA/D4gCdAC6SnZ4QiBDlhAAED5mAALCp+WEGFe/8FgAAAADsEgMpUASAAO0SBCnYBIAA +WG330qDRDwDAkAyuNO62CCz4RgAA2iD8QGgdoBvFAFhv0WP/yicwDvbgAIP/+kYAAAAr/BjqJAAJ +YASAAFhvyWP/rMCgWYOGG+gKirgtCv/5X/VgkAylAGP/uQAAAAAA+kKGHa/7rgAAACwhBx3oGfvQ +PAXqzAEA7jAOLmcCgAANzAIstiiKIBjoHv1AABUwDDUADKoCKrYp6AQFAfhBAAD5IAnBUgCdAG3p +DgQCYw9AhgQCZQ8AhgQCYcDQ/CBGFe/6+gCOMPPACuqSAJ0AjxXiEgIv/wKAAKb/J/ad0Q8rIQn8 +QrAVr/0FAA2tAQ2vDP5Chh3gDgUA7ZQDLmECgADulAAt3gKAAP1mAA2wCBUACLsCm5H41aYVr/jW +AIon/KBoHaALFQDtEgMlUIEAAFhokfogRhWv+Q4AANog60QACuAEgABb9bSLEYkxDKwR7LsIDSAE +gADxP/JAUgCdAOokAArgBIAAW/WDpKSkeYoV4hICLVcCgACmqimmndEP//WoDaAFBQAAACv8Euok +AAlgBIAAWG9zY/5UAAAAAAD+IMYV4AoFAFmDLRvnsYq4/iDIFeD99QD5X/AwkAylAP/0qA2gBQUA +wOD+IAYVr/guAAyoNPlhBhWv9FYAiicloRX7RAAVr8kFAAmpAalZKZxAbekTBAJjD4CGBAJpD2CG +BAJnefsY0w+NE9MP+6BoHeAMBQBYaFj6IEYVr/WOAPXvAA///44A2iD6gGgd4AwFAFhmj7N7jBXi +EgIuZwKAAKbMK8ad0Q9sEAQjIAAkCu10MQYiIQO8ItEPhiCFI4Qh9nAABDs2IQD4YABBs2YBAKYz +DjMR8q8ACX1EAQDjPBohE8kAAAQkLAQzKKMi0Q9sEAiKIicgB4kwlRT4QtAVoXcBAPFbDA3omQEA ++CAmFeD79QB7gSArEgQLC0f7f8AV4AkVAOubOQlQBIAAWCoL809gDeD79QAa52aIqBbnY/cADGCS +AJ0ALWKuZNGsJWKtZFGosIiYqOlUAAKMeYAAFedUJVCAJVw3+CAGFeRVHQDlRQgLzwKAAOaZCAKo +DQAA9OAIWhIAnQAokp71ABLD4gCdACWSnWRRbyogFvtDJg3g7NUAKzAQ/WASJCIAnQArMQu8u9og +WCnSKCAULCAEpIj1gArREgCdAAgIRygkFPUADG5SAJ0AihQe51eNESghBxznNBnnU/+h4BXqiAEA +/wAAFDT/HQDpiAIH+AUAAA9PDJhQiyAP7Dn8oGYV56oBAOxWAi3eAoAA60sCAshBAADrVgEhwEEA +APlAB+lSAJ0A6EENYlP9AABtqQUIAIYJAmHAgJgT6SAEIlv9AAAMuxGrW/UgB4ESAJ0AiDHlMgIl +2EEAAOsWAiwJsgAA8wAKsFADBQCjTIgTDH0Rpt3s1p0sEASAANEPAAAAAAAAAPcADTiSAJ0ADHkR +ppkukp71wA2T4gCdACWSnWRRqbCMnKhlXuRgAFHqJAAJ2ASAAO0SBCpgBIAAWGzd0qDRDwDAoFmC +exrm/oio+R/zUJD79QD/+cgNoAUFAADaIPxAaB2gG8UAWG6zY/+8wFDA2g2INPlBBhWv+UoAK3wY +6iQACWAEgABYbqtj/5wAAAAAAPhChh2v+tIAAAAAiif9IGgdoAsVAOqsICpoBIAAWGem+iBmFa/8 +DgCLMPNgCLqSAJ0A4hIDK+cCgACmzCTGndEPjxAuIQn4QrAV7/oFAAqKAQqMDCwkFOSZEA92AoAA +Ce4C++BmHaALBQD74AYd4A0VAA3uAp7x/NWmFe/49gAA6iQACuAEgABb9LOLEigyAeoWBS1nAoAA +7LsIDRgEgADxH/WQUgCdAOokAArgBIAAW/SBiBOjo6NMDH0Rpt3s1p0sEASAANEP//asDaAFBQCO +NIs3jTX+cAAHu84hAP+AAEZz7gEArswOzBH9bwANvd0BAOzMGiXbyQAADb0sDcwo/WAARb/2QgAA +K3wS6iQACWAEgABYbmNj/nzAoFmCIBrmpIio+R/yeJD79QD/+YQNoAUFAADAUMD6D480/0EGFe/5 +RgCwSwy7EetbCAlQBIAA+2IAFeAMBQBYZZWzTOISAyvvAoAApt0s1p3RDwAAbBAG2iBYKccX5rMl +MBb5zVQFoqYFAAamKIo3qGgFVQoIVQunVYhQ5KwIKQEKgAD6oCgV4AcVAOWBFXvICoAAiDKUsJWi +m6MJiAKUUZgy0Q/aIFgptBzmoCvCherCiC1IBIAAqbvvMBYt3kKAAKuqG+acGOaa7uaRHM8CgACr +mahomBCZEYaRK4J97IJ/L4EKgADuZgEL6AqAAA27AiuGfebGAgYAcYAAWALMixCJESuyfRjmbQaG +OAa/Ao5Rn5KMMpTg7kYBKQEKgADlRgAr6AqAAA3MApRRnDLRD2wQCNogWCmQ1KAX5n8b5oD5zP4F +4qYFAAZEKBXmcOlJCAlXAoAAq6qKoCmSf6VFp0QKmQH4IAYV4GMFAOEABQEzuQAA8ADcDaAHFQAA +AAM8CvWAAgZ/CEUA6MgICVAEgADogh8qWASAAP50ABWvfQUA7cwIC2gEgAALgAABAYcDN2DhAQcJ +9yAAANEPbBAEFuZhFeY+0w+mIgU1AiUmgCQigGdAC20IBSgigGeAAmP/89EPAGwQBCggBSUgB/pg +qBWv9NUA+kBIFeADJQD9ASAR0VUBAMAg0Q8AiCkZ5k+aK/sAB/wiAJ0ACVkJKZ0CKpEIKZEEDwIA ++yAEw6IAnQAqCh/7QARo4gCdAAIqAlhlNIsiDwIAA7oBZK+4iicEuwHrJgIlUMEAAFherOPmGhUB +OYAAKKAA0w/TDwOICiiCEOygBy1YBIAA+kBoHaANRQALgABlr9yJJ9MPZJ92KpkUyqeKmWSvbCig +AAOICiiCEOygBy1YBIAA+kBoHaANNQALgABlr+Bj/0oAAP//VA2gCgUA2iBYZSErICLquwwJUASA +AFhmctpQ+gAiHeAMBQBYZuSLIgO6AfN/+uZiAJ0ALCAH5L0BCVAEgAD8QEYV4bwBAOu8HylgBIAA +WG2ewCDRDwDrICIpUASAAFhmYCogBcHjfqEMaKgpiyLzYAQFf/xmAC8gOsCPePnq+kBoHaALBQD8 +AAIdoA0lAFhljGP/1wAA+kBoHaALBQD8AAIdoA0lAFhlCWP/vwAAbBAKiCsd5fYuICGLN/xgyBWg +/+UAD+4BLiQhDcwBDLsM64kIeMgEgADAINEPAwCGCQJhmxUoIAUlIAf4IQYV7/TVAPxASBXgAyUA +/RtAQdFVAQCKKZsr+0AH7GIAnQAb5d8LWwkrvQIssQgrsQT9YASzogCdAMHP/YAEYOIAnQDaIFhk +yIsiA7oBZK+biicEuwHrJgIlUMEAAFheQQqrAuPlrhUBKYAAKLAA0w8DiAooghAssAf6QGgdoA1F +AAuAAOukAA1/HgAAiSdkn1oqmRQrkgnKqGS/TyiwAAOICiiCECywB/pAaB2gDTUAC4AA66QADX8u +AABj/y0AAAAAAP//SA2gCwUA2iBYZLUrICLquwwJUASAAFhmBtpQ+gAiHeAMBQBYZniLIgO6AfN/ ++s5iAJ0ALCAH5L0BCVAEgAD8QEYV4bwBAOu8HylgBIAAWG0ywCDRDwDrICIpUASAAFhl9CogBcHj +fqEMaKgpiyLzYAQFf/xaAC8gOsCPePnq+kBoHaALBQD8AAIdoA0lAFhlIGP/1wAA+kBoHaALBQD8 +AAIdoA0lAFhknWP/vwAAbBAEKTAWCVkU9SAG2JIAnQDxLrAN7/vlAOPlYxgECoAA9SAEGhIAnQBo +lQTAINEPACogBrCqCgpH6iQGLX9+AACMIoonC8sB6yYCJVDBAABYXefJrSigAAOICiiCEOygBy1Y +BIAA+kBoHaANRQALgABlr+CJJ2SfsiqZFGSgoIqZZK+nKKAAA4gKKIIQ7KAHLVgEgAD6QGgdoA01 +AAuAAGWv4GP/hQAAKSAGsJkJCUfpJAYs+8YAAIknjCIqmRQLzAGLmewmAiUCgYAAKLAAA4gKKIIQ +2iD9YPAVoA01AAuAAMAg0Q8AAOokAAnYBIAA7EQACugEgABYZbnAINEPAOokAAnYBIAA7EQACugE +gABb/0/AINEPAP/+wA2gCwUA//10DaAKBQBsEATRDwAAAGwQCBXlQBTlHBflQJIS+CBIFaAKBQD6 +IGYVoAlFAJkUGuU6CIIJ4IEECReCgAD2QABD8AgVAOoiCAxACoAA+CAmFa/59QD5FwAMcAYFAPgg +BhWgAIoAmxOMFLFm4iwMI7gxAADlXAImY/0AAOwWBCYFMYAALVHC+sAEANALFQDguxoOo0wAAC5x +fmTvygIqAlhmhI8R+sAEANAIFQDgiBoNGASAAOgWAyeAaYAAiaKKEAqZAZkyijcqrDBYXYHKoSig +ANMP0w8EiAooghDsoActWASAAPpgaB2gDUUAC4AAZa/ciTfTD2SfbSqZFMuniplkr2MooAAEiAoo +ghDsoActWASAAPpgaB2gDTUAC4AAZa/gY/9BixP6IEgVoAkVAAubOVhncdEP//8UDaAKBQBsEAYd +5PcLKxGtsyoyfxnk9YigJd31+KAARPAEBQDpuQgEAbGAACwyeC8ye/mABYRiAJ0AZfDsLDZ8KzJ5 +KzZ73UAN5BYBAgCUoA3kFiwKCfxABfQiAJ0ALzJ7wcDt5OIXg3mAACIyfCohBI4g8+H+Daa6AQAk +Nnz0b2YVoAAeAC42fO2vAQXD/QAACP8C7yUEJYxZAAAiMnywzO8yeyEA8YAAycZj/7/aIFhl7WWg +mSohBP9BIAwWmgEAyJnRDwDaIFhnNtEPANogWGdq0Q8A+kBoHaALBQBYZzfRDwAAAOrSYCFj4QAA ++4AEANALFQD9YAEF3/z1AAy7AwuqASrWYFmEwSQ2fCQ2e/pv6BWv/MoAWXu9WGWgLVKwZN85WXuO +Y/8zHOSy/m+IFaAKVQD4b0gVoAtFAOgWACFr5QAAWYJr+m/oFa/70gApMnviNnws+2YAACI2e9EP +AABsEAQU5KQZ5KDo5IoZXsKAAKS0I0J/qYjouAgBgkGAAIoweKkCKkJ7HOSZKzEEKkZ/DLoB6jUE +KdAEgABYZbHOrikxBP8hAAwW2QEAyNfRD9owWGb70Q/aMFhnL9EPAAAAAAAA+kBoHaALBQBYZvvR +DyNGf9EPAABsEATwYOAN7/n1AIgiCTkDCYgBmCKKJyqsMFhc6OPkVRUBGYAAKKAAA4gKKIIQ7KAH +LVgEgAD6QGgdoA1FAAuAAGWv4Ikny5IqmRTKpYqZya0ooAADiAooghDsoActWASAAPpAaB2gDTUA +C4AAZa/g0Q8AAP//XA2gCgUA0Q8AAGwQBPJdABXgGMUA+EAHnCczAQAU5Cv0YAYSEgCdAAw5EQSZ +CCiSnvcAB07SAJ0AKZKdZJDYHORBG+RaAioJDKoKq6pYZbf6QAQA0AkVAP0gAQTf+/UA4qQABIBx +gACKogubAwuqAZoiiifTD9MPKqwwWFyy4+QgFQE5gAAooADTD9MPA4gKKIIQ7KAHLVgEgAD6QGgd +oA1FAAuAAGWv3IknZJBnKpkUyqmKmcmtKKAAA4gKKIIQ7KAHLVgEgAD6QGgdoA01AAuAAGWv4NEP +AAAAAAAA//9MDaAKBQAV4/qKWGqhNww5EaSZK5Kebr0+KZKd5JA6ZVv9AACbWGWfNWAAC9owWXs0 +Za8q0Q/RD9EPAAAAAP/8aA2gCQUAwKBZf2WKWGuhvf//SA2gCQUAwJDAygysNPyhBhWv/w4AAAAA +bBAEGOPfAgNHDDMRqDMrMoQZ4+gosAAqsgEJiAoKIYwCCj4oghADAj78QGgdoA0lAAuAACI2hAwC +ANEPbBAEFOPQAgNHDDMRBDMIJDKEKkIBJkAAKEAI+phoHaCpJQACBT4DAj55gSMY49MIaAooghDq +VAAKWASAAPxAaB2gDSUAC4AAIjaEDAIA0Q/rJAAKUASAAFhldvNAaB2v/zYAAAAAAABsEAQZ49XT +DymSRip60AqZKBTj6/8gABSwChUACpkCKUa3+JboFaAFBQAF5DEBAgAjQrdmMAttCAUqQrdmoAJj +//Mb4+Aitopj//wAbBAEWX6EEuOiE+PAKSKC0w8JGo4DqAqIgAuAAGP/7ABsEAQqIgcqrBBYZnHR +DwAAbBAEiCcijBDaIFhmUGihAdEP2iBYZkoS480LqBHoIggFAdmAAAzqMCsihSuyACKs/+y7CAlQ +BIAAWYORHOPFKsJ/+kAEANALFQAAuxoLqgIqxn9Zg8DRDwAAAAD6AOIdoAsVAFhmJywifywmg9EP +AGwQBCYiBw8CAOZsECnQBIAAWGaK7DQACmgEgADuVAANWASAAO8iACtQBIAAWGXO0Q8AAABsEAQa +44eWIvRAZhWhlzEAGOOHqpkpkIAIOAKYIAlZDJkh0Q8S46MD6DAE7jAFsTCTIJQhlSIS458T42uE +IAQzApMgEuOdwDAoN0AoN0QoN0goN0wjPQFyM+0DAgAS45fAMJMgxy8T45YDIwMS45aEIAQ0AZQg +EuOUhCAENAGUIBLjk4QgBDQBlCAS45GEIAQ0AZQgxy/AMQMjAxLjjoQgBDQBlCBj//wS44yDIAMT +FA8zEZMgEuOJwDAjJgBX/9kQ44iRAJIBkwKUAxHjhoIQAeowohEB8DHAQATkFgACABHjgoIQIxoA +AyICkhAR43/AIZIQBOQxhAODAoIBgQAA0jABIwAAAAAQ43qRAJIBkwKUAxHjeIIQAeowohEB8THA +QATkFgACABHjcIIQIyoAAyICkhAR43DAIZIQBOQxhAODAoIBgQAA0zABMwAAAAAQ42uRAJIBkwKU +AxHjaYIQAeowohEB8jHAQATkFgACABHjXoIQI0oAAyICkhAR42HAIZIQBOQxhAODAoIBgQAA1DAB +QwAAAABsEAQkIBSjRCQkFNEPAAAAAFyUAV2UAl6UA1+UAEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABckAFdkAJekANfkABTAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJQAHZABnZQCnpQDn5QECJQFCZQG +CpQHC5QAQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJyQAZ2QAp6QBx2QA5+Q +BHiQBXmQBnqQB3uQAFMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADclAAdkAHd +lALelAPflAQElAUFlAYGlAcHlAgIlAkJlAoKlAsLlABDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +3JAB3ZAC3pALHZAD35AEtJAFtZAGtpAHt5AIuJAJuZAKupALu5AAUwAAAB///CgA0jEQ//4KAAAA +AAAf//xwANMxEP/+CgAAAAAAH//8uADUMRD//goAAAAAAAD0MAoAAAAAAPQwCgAAAAAA9DAKAAAA +AGwQCIgiJyAHKSIUmRPxEvwN4XcBABrh8GSRARbh8SqggAx4EeaICAVQ3QAA+RPIFeSqHQCqSuvh +6RVQCQAA+yAJ86AMpQAogp3oFgQkCdmAAI2496AKOJIAnQAuYq7xz3AN4AkFACpireSg7mb7/QAA +77YIJQeJgAArIBSkuwsLRyskFPVgCV5SAJ0AizmJFPhiABWnxQEA+YAKgVa7HQD8geAA0AUFALBK +bakFCACGCQJhiRMa4cuJkOgSBCJj/QAA6pkCDO4CgAANzQL9ACYV4AoFAG25B+mGBiRBAQAAiBTr +MgEuTwKAAKmImBXpMgItjDIAAJoQ82ANOFIAnQCLEOtLCAvnAoAA5swIBdv9AADrxp0qkASAANEP +AAUMR2jCGIon+oBoHeAMBQDqrCAqaASAAFhiGNKg0Q/AINEP6iQACdgEgADsRAAK6ASAAFhnK9Kg +0Q8AAMCgDN407rYILXi+AACPImX/1Nog/EBoHaAbxQBYaQNj/8QAAAAAAP/7FA2gCAUAiCJlj7Ir +fBjqJAAJYASAAFho+mP/ocCgWXy3G+GOjbj5v/V4kAylAGP/si0hCf5CsBWv/wUAD78BD7gMKCQU +76QDL3ECgADppAAu7gKAAP+mAA6wDBUADN0CnaH81aYVr/qSAI4nnhGF6fnCghWvyQUA7OEVJ2iB +AAAJ2QGZEunJCApXAoAA6ogMAqhBAACV6QiIMujlFCTJAQAA+KAIYuIAnQBoq0ClrCzM8P0gBNOi +AJ0A7xIEIgyBAACwTm3pBQUAhg8CYSzSAQ8CAAysCOjZBCZjwQAA+YAG7GIAnQDs1gEuKASAAGWO +P2AAoQAA6xIFLOAEgADsFgYpUASAAFvu64kWiBWLMeoWAC1vAoAArYjxf/MIUgCdANog7JQADFgE +gABb7rqOEO6uCAqQBIAA7k4IC/8CgADm/wgHc/0AAC72ndEPAAAABZkM/CCIFaT5HQBt+QUFIIYM +AmOMEg9FDI8ULMxA6f8IAow9AACwWG2JBQxAhg8CZYUSLNkECagMqFUlXDDl1gEubP4AAIkSwKDq +1QQkyQEAAPmgJhXgBQUA+aAGFe/2DgCOEQxVDPXBJhXv+74AhRIlXED1oCYV7/yaAAAAbBAEHeEl +GuElDwIALdJxLKLHKqFuo93qOgwO7kKAAP2AAEZwCwUAK8QEK8QFWPI1+kBoHaALBQBb/HDRDwAA +AGwQBBbhFyQgB4lgJwoD8TEgDeFEAQApIhMJ6FH1AAkAkgCdAPPCFgXhqeEA9UAJAJIAnQD0gAXi +EgCdAAxJEQOZCCuSnvdgCjnSAJ0AKpKdZKEhLyEHGOED/cIGBer/AQDp4QIf/wKAAAj/Ap+gH+EA +/EAIFaA7BQCbp/lAphXgGIUAmKOfou3MAg52AoAAnKT3xgAPcAwFAJymnqEuIhMOjkHspggvdwKA +AJ6p6+DxGm8CgACj3SfWnSoiE5xgC6oCKiYT6iIQKVgEgABYvlEFCEdoghmKJ/oAIh3gDAUA+0QA +FaANFQBYYUfSoNEPAMAg0Q8c4NaLyPdgBNiSAJ0ADEkRo5ktkp73oAUp0gCdACqSneSgnGXr/QAA +nchlrzFgAFCOIrGf72YAJwGxgAAFCEf1AARREgCdAMAg0Q8AKhoACpkC+EJmFe/7agAAACsqAAub +AvpCZhXv+2oAAAAAACtMGOokAAlgBIAAWGghY/+8AACMImXPtStMGOokAAlgBIAAWGgbY/+kAAAA +AAD/+vANoAoFAMCgWXvVHOCri8j5f/rYkgCdAP/9wA2gCgUAwKDA2g29NP2BBhXv/YYAjCcvyRSK +yf+EABWvyAUA6O4BB/hBAADvxRQlU8EAAOrGCSdxAQAAfqssKcEVHeCiqpqayZ2gjCD7wUAF4A0V +AOumAi5mAoAADcwC/UAmFaACBQDRDwAAHeCYnaCMIPvBLgXgDRUA66YCLmYCgAANzAL9QCYVoAIF +ANEPbBAYkhCOIBXgj4kjiyGKIioWIisWJPgkZhXgBBUA9CDmFaAIBQD4IKYVoAxFAPwhRhWgDTUA +nRn0IMYV4A8lAJ8Y9cECBeAPpQD+IgYV4A21APwiJhXgDMUA/CJGFaAIhQD4IcYVoASVAPQh5hWg +CXUA+CGmFeALVQD6IWYV4AplAPohhhWgC9UA+iJmFeAK5QAqFhT1wNoFoAn1APgiphXgCEUAmBSG +FisSJIkVJ2F+LBIiImF/B5koL1CAqSn4nIgVo5kBAAOZCu6SAC9QBIAAJmI+LRIjqO4LYACOFywS +JC0SIgfuKC9Qga4u+JyoFaPuAQAD7gqO4CoWFuoSIy1YBIAAqO4LYACOGCwSFi0SJAfuKC9Qgq4u ++JzIFaPuAQAD7gqO4CoWF+oSIi1YBIAACO4IC2AAjhksEhctEhYH7igvUIOuLvic6BWj7gEAA+4K +juAqFhjqEiQtWASAAKjuC2AAjhosEhgtEhcH7igvUISuLvidCBWj7gEAA+4KjuAqFhnqEhYtWASA +AKjuC2AAjhssEhktEhgH7igvUIWuLvidKBWj7gEAA+4KjuAqFhrqEhctWASAAAjuCAtgAI4cLBIa +LRIZB+4oL1CGri74nUgVo+4BAAPuCo7gKhYb6hIYLVgEgACo7gtgAI4dLBIbLRIaB+4oL1CHri74 +nWgVo+4BAAPuCo7gKhYc6hIZLVgEgACo7gtgAI4eLBIcLRIbB+4oL1CIri74nYgVo+4BAAPuCi7i +ACoWHeoSGi1YBIAAqO4LYACOHywSHS0SHAfuKC9Qia4u+J2oFaPuAQAD7gou4gAqFh7qEhstWASA +AKjuC2AALhIQLBIeLRIdB+4oL1CKri74ncgVo+4BAAPuCi7iACoWH+oSHC1YBIAACO4IC2AALhIR +LBIfLRIeB+4oL1CLri74negVo+4BAAPuCi7iACoWIOoSHS1YBIAACO4IC2AALhISLBIgLRIfB+4o +L1CMri74nggVo+4BAAPuCo7gKhYh6hIeLVgEgACo7gtgACwSIS4SEy0SIC9QjQfuKChC8a4u+iBm +FaPuAQAD7gqO4OoSHy1YBIAAmxGo7gtgAIwRLhIULRIhL1COB+4oKELyri76IEYVo+4BAAPuCo7g +6hIgLVgEgAArFiOo7gtgAC4SFSwSI40TB+4oL1CPri74nmgVo+4BAAPuCo7g6hIhLTgEgAAnFiLo +7ggL2ASAAAtgAI4RKhYkKRISLRIVjxUrEhMsEhToEhEn+EEAAO8WBSXYQQAA6xYTJmBBAADsFhQk +QEEAAOgWESboQQAA7RYVJMhBAAApFhKNH4kciBuMHosd7xIQJEBBAADoFgsmYEEAAOwWDiXYQQAA +6xYNJ/hBAADvFhAkyEEAAOkWDCboQQAAnR+JFo0ZjxrrEgciqEEAAOwSCCboQQAA7RYJJ/hBAADv +FgoiIQEAAO8SBCZgQQAA7BYIJdhBAADrFgckyCEAAOkWBif7/QAA7xYEL+ImAACJEI8TixKOkIiT +jJKNkauIp8yq3a/unpCdkZySmJPRDwBsEAQpIhX4oAAE8Dh1AOmMDAEgQQAA8yAART+LBQDrpBAl +UEUAAPkABdNiAJ0AKwoAWXfbLCIVKyIU7c0RCUAEgAD8QkYV7oA9AP1rAA2wCTUA+kJmFeAKJQBt +qgyOhA4Oju6GBCRAEQAADwIA0w/TD22aIemCBCRAQQAAioGLgoyDCQmOCgqOCwuODAyOmYCagZuC +nIPrRAAJUASAAFv+toogiCKJIY8jCAiOCQmODw+OCgqOmiCfIykmAegmAilABIAAGd9BAgCGAwJh ++AAKFeAJtQBtmgIIAIrRDwAAAAAAAAD9gQAVoAsFAFl3rPhAaB2gCUUA0w9tmiHpggQkQEEAAIqB +i4KMgwkJjgoKjgsLjgwMjpmAmoGbgpyD6iQAClgEgABb/pTaQP/7/A2gPIUAAGwQBikiFfhCiBWg +RgUA0w/4gABFdZkBAAlmDHSrAbGIKiYVBioM6CYUJVFBAAD2gAezogCdAOs0AAtgBIAAWXd/+EBo +HaAJRQDTD9MPbZoh6YIEJEBBAACKgYuCjIMJCY4KCo4LC44MDI6ZgJqBm4KcgyUsEOokAArYBIAA +W/5xBkcM9uAFjtIAnQDmNAgK0ASAAPbgaB2gAwUA5BYAKkAEgAD4yGgdoAlFAAoCZwhAhgoCZQgg +hgoCYwgAhuoMAAlABIAAbZoh6YIEJEBBAACKgYuCjIMJCY4KCo4LC44MDI6ZgJqBm4Kcg+okAArY +BIAAW/5U6lQAAZgFAADmbMAiIQEAAO9tmmpABIAAixAKPBELywjsfAwK0ASAAFl3R9EPAAAAAAAA +6zQACmAEgABZd0LRDwAAAPZgAEYwAwUA/CAGFa//JgBsEAQY3tUZ3tMa3tET3tSTI5gimSH6QAYV +oAsFACsmFSsmFNEPAAAAbBAG3iDk4hAqYASAAOdCByvQBIAA+72EBeAYNQDjQhUpkASAAOdyDiL7 +6QAAePsnGN7CCPgKiICaE5wS7hYBLAAigAAAkxAqspXsVAAJWASAAFl5DmSmN/KCphXgAgUA0Q8A +AAAAK+ITC5tS7hYBJf9BgAAa3qvjFgApWASAAOqityrgBIAAWXkBZKXKGt6k2yDqorkq4ASAAFl4 +/GSnTBreoNsg6qK7KuAEgABZePf3T8AN43bFABremtsg6qK9KuAEgABZePFkp1ca3pXbIOqivyrg +BIAAWXjsIyqA43MICAQKgAD7QEkwEgCdACsw2cFY9WAvSGIAnQBptyElNNmLEPqCphXgAgUA0Q+T +ECqyjexUAAlYBIAAWXjcZKefixD6gqYV4AIFANEPAJMQKrKb7FQACVgEgABZeNRlrxf6IGgdoAu1 +AFi6o/oAIh3gAwUA6rM4BQGJgADqEgIrWASAAFl3SsOw7N51HSgEgAD8oGgd4ApVAFl7/MhZHN5w +jREMXDYs1hhlNLWNEPyCphXgAgUA0Q8uQG5k7rqTECqysexUAAlYBIAAWXi4Za6n+iBoHaAbZQBY +uof6ACId4AIFAOqyOAUAqYAA6hICK1gEgABZdy4sfQMqxShlJGGNEPyCphXgAgUA0Q8AAJMQKrKj +7FQACVgEgABZeKRkos8a3kjbINMP6qKPKuAEgABZeJ9lrkL6IGgdoAtVAFi6bvoAIh3gAgUA6rI4 +BSqpgADqEgIrWASAAFl3FCxAb/GAKf7SAJ0AZKU3ihP6AKId4AzVAFi6S9Kg0Q+TECqyqexUAAlY +BIAAWXiJZa6y+iBoHaAbJQBYulhko8UrQG77YEDYEgCdAOoSAitYBIAAWXb/LEIWixArRhUKzDb8 +gsYVoAIFANEPAAAAkxAqsqfsVAAJWASAAFl4dWSiQxreGdsg6qKhKuAEgABZeHBlrlD6IGgdoAvl +AFi6QGSjY+oSAitYBIAAWXbpK30CKrUUixD6gqYV4AIFANEPkxAqspnsVAAJWASAAFl4YWSiShre +BNsg6qKlKuAEgABZeFxko9ca3gDbINMP6qKTKuAEgABZeFdlrer6IGgdoAt1AFi6JmSi/StAbmS3 +hxrd9YsS6qLfK2AEgABZeE1lpukrQG/AyAy7AitEb4sQ+oKmFeACBQDRDwAAkxAqsq/sVAAJWASA +AFl4QmSiDxrd5tsg0w/qopEq4ASAAFl4PWWtgvogaB2gC2UAWLoMZKKVK0BuZLcOGt3bixLqot8r +YASAAFl4M2SnHitAbywK/Qy7AStEb4sQ+oKmFeACBQDRDwCTECqyl+xUAAlYBIAAWXgoZKHXGt3M +2yDTD+qiiyrgBIAAWXgjZKMqGt3G2yDqoqsq4ASAAFl4HmSsPxrdwtsg6qKzKuAEgABZeBllrCzA +pf27igWgOwUAWXtNGt26ixLqos0rYASAAFl4EWWk2IsRK7ITC5lSyJlokgf5IBFp0gCdAI0RjBAr +1hP8gqYVoAIFANEPkxAqsofsVAAJWASAAFl4A2Shixrdp9sg6qKJKuAEgABZd/5lrIj6IGgdoAsl +AFi5zmShmxrdnosS6qLfK2AEgABZd/ZlrGeKE/oAQh3gDNUAWLmv0qDRDwAAAAAAAAD6IGgdoAv1 +AFi5v2ShYuoSAitYBIAAWXZp6xIAI+ALAAAqxRX6gqYV4AIFANEPAAD6IGgdoBsVAFi5s2ShMi1A +bmTVmSlAb/E/4C+SAJ0A8T/f79IAnQDqEgIrWASAAFl2Vy1CFxzdhPuhAA6wOwUA/ILmFeAKVQBZ +ewiLEPqCphXgAgUA0Q8A+iBoHaALpQBYuZ1koNouQG7TD2Tk+uoSAitYBIAAWXZFL0E0++AQgqIA +nQCKE/oBQh3gDNUAWLl80qDRDwAAAPogaB2gG1UAWLmNZKCa6hIBKlgEgADsEgIraASAAFi5FIsQ ++oKmFeACBQDRDwAAAPogaB2gC5UAWLmBZKBqKEBuZISeGt1RixLqot8rYASAAFl3qGWiuCtAb40Q +/IKmFeAMFQAMuwL6jeYd4AIFANEPAAAAAAAAAPogaB2gCxUAWLlvyqIa3UCLEuqi3ytgBIAAWXeY +ZarvihP6ACId4AzVAFi5UdKg0Q/Apf26hAWgOwUAWXrIwCDRDwAAAAAAAOoSAitYBIAAWXYK/UBo +HeA7BQD9unIFoApVAFl6vuoSAitYBIAAWXYD9UAYOpIAnQDHL9EPAAAA+iBoHaALhQBYuU/6ACId +4AIFAOqyOAUBSYAALEBuDwIAZMPXGt0o6xICK2AEgABZd3NlorUtQG/A6A7dAi1Eb2UvbY8Q/oKm +FeACBQDRDwDqEgEqWASAAFi5RWWvmisw2WP6BgAAAAD6IGgdoBsFAFi5NWSvOihAbtMPZINJ6hIC +K1gEgABZdd0pQhiLECtGFQqZNviDBhXgAgUA0Q8AAPogaB2gCzUAWLknZK8CGtz4ixLTD+qixStg +BIAAWXdP490CHQiGAACLESuyEwvJUciZaJIH+T/5AdIAnQCOEYwQA70BLeYT/IKmFaACBQDRD2Uu +vI8Q/oKmFeACBQDRD+oSAitYBIAAWXW8KkU0ghDygqYVoAIFANEPAAAAAAAA9uAAQbALBQD6YGgd +oIwFAFl1TuoSAinYBIAAWLldIyqAo3MrMNnAxAy7Avp/Zh2nuwEA+nsmHe/kKgAAACMqgKNzKDDZ ++iBIFaAJJQAJiALoNNkrWASAAFl1oMOw+nsGHafaAQD9uaIFoApVAFl6U2P4yooSWWna/UBoHeA7 +BQD9uZgFoApVAFl6TCoSAllp1Nyg+iBIFaP71QCre1l3D2ShpMCi/bmGBaA7BQBZekPHL9EPGtyv +ixLqoscrYASAAFl3BmWuEYsRK7ITC8lRaJEKaJIH+T/wAdIAnQAe3LYDvQEO3QKOEYwQLeYT/IKm +FaACBQDRDwCKE/oBIh3gDNUAWLiz0qDRDwAAAAAAAAD6IGgdoAtFAFi4w2Stco0R/blOBaAKVQD9 +omgV4DsFAFl6Ihrcj4sS6qLFK2AEgABZdubj3J8dBW4AAIsRK7ITC+lRyJlokgf5P+vp0gCdAI4R +jBADvQEt5hP8gqYVoAIFANEPGtx/ixLqos8rYASAAFl21mWtUYsRK7ITC5lSaJEKaJIH+T/qAdIA +nQAS3In4ICgVoo4FAK5+ArICIoYTLeDZ/CAIFaAPFQAP3QIt5Nn8gqYVoAIFANEPihP6AQId4AzV +AFi4ftKg0Q8jKoCjcysw2cDBDLsCCwtH+nsmHe/dRgAa3F+LEuqixytgBIAAWXa2ZazRixErshML +6VFokQpokgf5P+YB0gCdAB7caowRA70BDt0C/YJmFeAKVQD9uM4FoDsFAFl54IsQ+oKmFeACBQDR +DwAjKoCjcysw2cDIDLsCCwtH+nsmHe/blgD24ABCsAsFAPqgaB2gjAUAWXS2wWDqEgIq2ASAAFi4 +xCsw2Qa7Avp/Zh2nuwEA+nsmHe/avgCKE/oA4h3gDNUAWLhL0qDRDwCKE/oCAh3gDMUAWLhH0qDR +D4oT+gFCHeAMxQBYuEPSoNEPAIoT+gEiHeAMxQBYuD7SoNEPihP6AQId4AzFAFi4OtKg0Q+KE/oC +Qh3gDMUAWLg20qDRD4oT+gIiHeAMxQBYuDHSoNEPAIoT+gDCHeAMxQBYuC3SoNEPihP6AOId4AzF +AFi4KdKg0Q8AihP6AMId4AzVAFi4JNKg0Q8AAAAAbBAEJCIQLCAHDwIA8IeADeHMAQAtMBguMBkr +IhfvMBou7gKAAA7dAu4wGy7uAoAAD90CCN0RDt0C69kHdfAFAAAuJhcvMBAoMBHpMBIv/gKAAAj/ +AugwEy/+AoAACf8CCP8RCP8CaPAiKSIT6NwHFMAogAAImAEoJhMpQAUqCpX7IAdEIgCdAMAg0Q8r +MBQtMBXuMBYt3gKAAA27Au0wFy3eAoAADrsCCLsRDbsCaLC3jScv2RSK2f+kABWvyAUA6O4BB/iB +AADv1RQlU4EAAOrWCSdxAQAAfqsIKdEVCpoIKtYJHdvq2aD8AAgd4AslAG26AgkCYR/byJ+gjiD9 +wAAXMA8lAA/uAp6hLTAULjAVH9vf6DAWLu4CgAAO3QLuMBcu7gKAAAjdAu+mAi7uAoAADt0C7aYE +IdghAADrBgAFSGEAAAkAii8iE44iKAqACP8C7yYTL3keAAArzBjqJAAJYASAAFhjC2P/DdpAWNXZ +wCDRDwAAAGwQBhzbxo0gjjYvMQv4Y/AVoApVAPggBhWgOwUAWXk3GtvAJCIZLDELiCyJSoVH/QAA +RDALBQD4QYYVoA0FAOVSDiSQSoAALUYUCp4C/oFGFaAAHgArQhTrWggB2IEAAFlz/i5CFC0xC9MP +rt0tRhQqUAQsUAUY26vrUAYtVgKAAAyqAulQBy1WAoAAC6oC7NumHS4CgAAJVQIIVQH0oGAV7/jF +APigBAKwOwUA/qBoHaAKVQBZeREpIhQoMQupiCgmFCtCFC9cMH+xCMAg0Q8AAAAAABzblYpKDKoB +6kYKKVAEgABY0Bj6QGgdoAsFAPwAAh2gDSUAWAG5wCDRDwBsEAYc24uNIC4yBfRA6BWnVQEA/r/A +FeAIFQAPjzn0goIVoApVAPQgBhWgOwUAWXjziSLk23gUhWmAAPigBQlSAJ0AiCeMiPsCpBWvzwUA +6YILJHCBAAAP7gGuquuJFCVRAQAA/SAIxCCtBQCtya27K4UU+UAIy+IAnQD7IAk0IgCdAJmI2cDk +AAUOQASAAPgAqB2gCqUACAJhCAJhCAJhCAJhCAJhCAJhCAJhCAJhCAJhGNs7baoFAwCGCQJhmMCP +IP+2uAWgAqUA7sYCL/4CgAAC/wL/gCYV4AIFANEPAMAg0Q8mIAcX2yQGBkHqMgUrRwKAAKeIKYKe +K6wfC0sU+yAFY+IAnQAogp3uhAAEBVmAACmsH/QACB2kSR0AbUkCCAJhiDQd2xmd4IkgHNsa6uYD +J1hBAADs5gIszgKAAOlJAgHggQAA6eYBKVAEgAALgAAMbhGn7uTmnSKUdQAAiif6AUId4AwFAPtE +ABWgDaUAWFtv0qDRD8Ag0Q8AAAD9IGgdoAsFAPsBZhXv++YADK0M/c8ADvDvBQCv3f0BBhXv+5IA +L+xA/wEGFe/7ZgD//VwNoAgFAAAAK2wY6iQACWAEgABYYlVj/m8AbBAEhycf2xAqeRQpcRX44QgV +oK0FAP1AAEV/zgUA6pN0c9iBAACMew67AeuZCAwwBIAA6MFldMkBAAAqdRStinqTaHmhepp47wAF +CzgEgAAHAmEHAmEHAmEHAmEHAmEHAmEHAmEHAmEHAmEHAmEX2tmXYIUgk2WUZPO19gWgB6UA4mYC +Kq4CgAAHVQLlZgErEASAANEPwCDRDwAA94BoHaAIBQD44WYVr/6CAAiaDPtvAA0w7AUArKr64QYV +r/4uACy8QPzhBhWv/gIAbBAEx48IWAMIOAIISAOoaOgiCAuBCoAAAiIYojLRDwBsEAQEOAMIWAOo +aOgiCAuBCoAAAiIYojLRDwAAbBAEBDgDCFgBCEgDqGjoIggLgQqAAAIiGKIy0Q8AAABsEAQFSAMI +OAEIWAOoaOgiCAuBCoAAAiIYojLRDwAAAGwQBCMiECsgB9MPKDAF/BFiHeCZJQDTD/kHfg3huwEA +LCBo0w8PAgD9hX4N4I4FACkiE3ifIHCXAnmXH+/auhS8yIAALvq/Dp4BD+4B/kJmFaACBQDRD8Ag +0Q8AwKX9tWQFoDsFAFl4INowWNT7wCDRD40nKNkUitn/pAAV78kFAOn/AQRAgQAA6NUUJVOBAADq +1gkn+QEAAH+rByzRFarKKtYJH9qX2aD+AAgd4A0lAG3aAgkCYRnadZmgjSAc2pH+AEId7/j1AOim +BC7uAoAAD90CnaEpIhOIIpyiDpkC6SYTLHueAADaIOu8GClgBIAAWGHFwCDRDwAAAGwQBBPaiwMi +AtEPAGwQBCcgB4giGdpV9kIIFaF3AQDlgn9r1wKAAAmqCCiinvcAE6rSAJ0AJKKd7NpaEhNRgAAl +IhMtIgn6QUgV4FVBAAxVCiVSgO27DAKowQAA9WAQA+IAnQArIBYoCv94sRL6QPAVoAwFAFg6cOza +ShUR4YAAJyEHH9psGNo9+7TWBap3AQDpIRorvwKAAAh3ApdAjSAe2jr+gEYVoAdVAOraAg7eAoAA +B7sCm0EoIhOZRppE+AgABzKIUQDs6woMRYKAAOuygC92goAACO4CD+4CnkcLWwzrRgUl2EEAAJtD +KiIWiymlqqW7myn6QsYVr+kFAPiADPxiAJ0ALzIEB3oC/bSWBaAIFQD54CAV4A4FAPkCAA9wOwUA +WXexG9o3KUwg+fACHaAMBQD6AAgd4E8FAAkCYQkCYQkCYS9EICxEJSxEJixEJyxEJChEIS1iEvyH +Zh3o3R0A/IdGHejdHQD8hyYd6N0dAC1EOCoiF/qH5h2oqh0A+ofGHaiqHQD6h6YdqKodACpEPIo0 ++GMAFaD+9QDt2igSeKEAAPVABlgf+fUAGtoZCACIDwCKKUQzLUQxLkQwKkQyKjIELEQj+obmHaj8 +HQD+hEYd6OodAP6Gxh2o7h0A/oamHajuHQAuRDTrAAUCaQEAAA0CYSsgBwsLQR3Z2gy7EQ27CCe2 +nSsgFikK/3mxCvpA8BWgPAUAWDnyiDRogCeKJ/oAQh3gDAUA+0QAFaANJQBYWjorIhMs+n8MuwH6 +QmYV4AIFANEPHtn+LSITDt0C/EJmFe//LgAAAAAA6iQACtgEgABYOZ/s2c0Vb6mAAGAAK4hvGdnu +sYiYbwmIAviGZh2o+B0A/oZGHej/HQD+hiYd6P8dAP6GBh3v/KYAwCDRD9og7CQAA9hhAABYYRbA +INEPANog63wSKWAEgABYYRLAINEPAAAAAAAAAGwQBCoiFSkiFP2zRgWnNQEA6pkMAZQdAABkkHgr +IAcLC0EMuhGsqi2inm7SbiqinRTZuh/Znu3ZoBUDEYAALiEHDg5K5JQCD3cCgAAP7gIf2cqeoP5A +CBWgGAUAmKOdopSlHdmc/8YAD/AEJQDvpgQvdgKAAATuAp6h7QAVBVBhAAAKAIoMuBGsiCSGnS8i +Fan/LyYVaTIPwCDRD4kiypBoMi/AINEPAIon+gAiHeAMBQD7RAAVoA0VAFhZ5dKg0Q8AK7wY6iQA +CWAEgABYYNtpMs+MJy3JFIrJ+4QAFe/OBQDuuwEG6EEAAO3FFCVTwQAA6sYJJdkBAAB7qyovwRUZ +2XCq+prJmaCIIPOzOAWgCRUA4qYCLEYCgAAJiAL5QCYVoAIFANEPGdlmmaCIIPOzJgWgCRUA4qYC +LEYCgAAJiAL5QCYVoAIFANEPbBAEGtmMKSITGNmLKzELCpkBKSYTjTksIhQqIhF9iGurzOwmFCUE +iYAAjax91zgoIhLAsPwAAh2gDSUAC4AAKyIVKiIUGdl9C6oM7Nl9FVkDAAB7kxX7glYNoAkFAOkm +ESyQBIAA0Q/AINEP+kBoHaALBQD8AAIdoA0lAFv/jcCQ6SYRLJAEgADRDwD9stwFoAolAP5ACBWg +OwUAWXbM+kBoHaALBQD8AAIdoA0lAFjOy8Ag0Q8A2iBYzdhj/38AbBAGLiAF/7LCBeB4RQD/ABlT +ogCdAB7ZXC0iEw7dAi0mE/OgGbtSAJ0AjCyINiswICoxCv0AFeUluwEA/k0QFa6qAQD7W2AVr/jF +APlABAUwiLUA+cAIpCA1FQD7gABGMC4lAPxBhhWgLRUA/WJGDeAsVQB8sQp1sQf/YBh1IgCdACow +MCgwMRTZQukwMi1WAoAACKoC6DAzLVYCgAAJqgIIqhEIqgL1QBbOKIq5AP0QABQ1qgEACKoCGNj2 +0w8kgnsogoiqSgmqEfsAAEUwBEUA7bF3dVIBAAB8sW+JrASZApmsfbEFfLECfrkmJjA4KDA56TA6 +KzYCgAAIZgLoMDsrNgKAAAlmAghmEQhmArFmJiYXKiYR/WAEjCIAnQD1YAgMYgCdAP1gDexiAJ0A +/2AOzCIAnQAoEABlgdQpIhMPmQL4QmYV4AIFANEPKTAjwIEJiTkppEEooEEoFAD9f/vdIgCdAGP/ +egAAAPgAYh3j7eEA/z/3JiIAnQApMCQtMCXuMCYszgKAAA2ZAu0wJyzOAoAADpkCCJkR7ZkCBUAR +AAD5DQANf/rWAAAsMCHxn/tn0gCdAC4wPywwPC0wPSsiEOgwPi5mAoAADcwC7bITLmYCgAAIzAII +zBEOzAJ80QIsthMtMEAoMEEushTpMEIu7gKAAAjdAugwQy7uAoAACd0CCN0RCN0CfeECLbYUiKwe +2OAEiAKYrP5CRhWv/GYAAAApMCHxIAZOEgCdACswJCwwJe0wJi3eAoAADLsC7DAnLd4CgAANuwII +uxEMuwJlsJ8rMEwsME3tME4t3gKAAAy7AuwwTy3eAoAADbsCCLsRDLsCZLB6LCIQLMIYe8NxK6YS +JDBIKDBJ6TBKKiYCgAAIRALoMEsqJgKAAAlEAu3YvRomAoAACEQCJKYULjA0LDA1KTA25DA3L3YC +gAD9xgAPMAgFAOimEy92AoAACe4C6KYVL3YCgAAE7gKerfxCRhXv+U4AGNit+EJGFa/5IgAA+kBo +HaALBQD8AAIdoA0lAFjOBcAg0Q8AGdilKSYSiqcpPCDTD/tByBWgCzUAbboFCQCGCgJhKSITD5kC ++EJmFeACBQDRDwAA/bE0BaAKVQD8QAgV4DsFAFl18CsgBSwKeHy5m2P/qwAAKSIRy5CJl4me+SYA +FeALZQAqPCBtuQUKIIYJAmPAINEPAAAAAAAA//TIDa/qpQAqIhlj/38AACkiGYmXKzELiZ6/uwtL +S+W/x2TIwQAAY/9YAABsEAgW2H0qCgX9sPgFoDsFAPTWCBWgDQUAWXXRKGJOwFDm2HcUD5GAAPYg +phWgBhUALEJZLcEEjsD7v+AV7/U5AO/FBS3PAoAA6ekID78CgAAHlwwHAIf3gGQV5qUBAAqmYP1D +YEdWdwEADPgRCJgMCCCHKgoACqZi9UAKf1IAnQB/uQpkcAf64Af0IgCdABjYFRfYWeiCey/OQoAA +qakncqqpiAmIEah3iXrzIAYtIgCdAPLgBexiAJ0A/bCkBaAKVQD+4LAVoDsFAPzgCBXgCQUA+CAG +FeAPBQBZdaEZ2Eb64QgVr5t1ACt0BSmSsPgghhXvm2UA63QFLQgOAACMfOkWBCZ8tIAAK3ISLpJr +C4pE+1oADTAMBQD/QAEFMA0VAPtACBWvu4EAWGAfwPAvdhKKFI53HNgw+uAIFeAIBQD44YYVr88F +AOzCnSdogQAAD90B6OUUJukBAACd6Qy7DP3BBhXgDAUA+0soFaANFQBYYA0d2CEt0k6xVfy/9Yvi +AJ0AYACPAAAJ+RHpqQgOxwKAAP+ApBXluR0A6OgIDd+CgAALiAz5H4AVpOkBAOmCAC8BCoAA/MAB +B1/79QAL6wMLmQEJ7gKegI7A7cEEJ/gFAAAPD08vxQV98Q6w2wy5EfnAAET/+hIAAAD+AAId4AoF +APuApB2v/5YA+gBCHaA7BQDsEgUr6ASAAFl1VPggiBXv+7IA0Q8AAABsEAYqIgcmIAcPAgAoqRQG +BkEPAgDjogkkEDmAAPVByBXnhQEA+QATOVIAnQD9r94FoDsFAO2iAilwBIAA/kAIFeAKVQBZdT/9 +r9QFoApVAPoGAh3gDUUAWXU6FNeZDGkR9MAOGhIAnQAEmQgqkp4PAgD3QBNSUgCdACeSnWRyHf2v +ugWgClUA/GAQFeA7BQBZdSwqMADDtPtADcxiAJ0A5RYAIdAbAAAloAErCjD9r6QFplUBAPygaB3g +ClUAWXUhiRD0oAzIkgCdAPSgCkkSAJ0A9KAKCpIAnQDAwCghByogBx7Xx/5BBBXqiAEA+gIABbGq +AQDquxANVAKAAOr/AgxHAoAAC4gCGte8G9d1Dv8CCogCmHCNIJ90+uBGFeA6BQDqdgMuZgKAAP7g +xhWgCgUA+uCmFaAORQDqdgcu7gKAAO7dAgPYgQAA/OAmFeANJQADIIYLAmMDAIYLAmENzAL84SYV +oAtFAOkTHgPhAQAADAJpCWCGDAJnCUCGDAJlDG4RpO4r5p30oAbakgCdABTXnP5BCBXvmXUAKSQF +8pEoFe+YZQDoJAUviK4AAIssf7coKyISLjJrC4pE+1oADTAMBQD/QAEFMA0VAPtACBWvu4EAWF9t +wKAqJhKLII4nmiz8jsgVr88FAOrlFCdogQAAD90B7LsMBukBAACd6f3BBhXgDAUA+msoFaANFQBY +X17AINEPAP0gUBWv+wYA//fkDaADBQAb1yWKuPdABbiSAJ0ADGkRpJkokp73AAYKUgCdACeSnWRw +uLCsnLhlfi1gAEgqPQT0IAYV7/kyAPwQQh2v+eYA/a7QBaAKVQD6BgId4A0FAFl0suoiCilYBIAA +W/7Y//wcDaAKBQAAAC0gQAjdEPxgBhXv9k4AjiJk4G38YAgV4ApVAP2usAWgOwUAWXSkwCDRDwAA +AAAAAPoAQh2gOwUA7NdHGWgEgABZdJz/+2ANoAoFAAAAAAAA//ZkDaAHBQDAoFlyHRvW84q4+V/5 ++JIAnQD//UQNoAcFAMBwwPoPrzT/YQYV7/0KAIkw2iD5rnwFp5nBAOkkQClgBIAA6DYAI1hhAABY +Xk1j/28AbBAGiickIAcoqRT4oGgd4UQBAOWiCSQLaYAACQhH+QAM0VIAnQApIEHj1tgaMASAAPYA +gh3gDAUA8TjcDeALBQD0gAo6EgCdAAxKEaOqLaKe96AV++IAnQAqop3tpAANSASAAO/W0hUM+YAA +LiBBGtcW8dtMDeAEBQAoIAcuIQf8QQQV4MgRAPggAAQ67gEA6swQD3cCgADs7gIMRAKAAAjdAhzX +CgruAp6QiiCUl/UgphWgOAUAmJOfkv0gxhWgDiUA/aYADrAMRQDtlgQt7gKAAO7dAg1WAoAADKoC +mpHlBx4E0IEAAAoCYwUAhgoCYRXW952Z7yIIK2cCgACjzPeTphXvmnUAKiQF8rEoFe+YZQDoJAUv +jy4AAI8sf/cmKyISLjJrC4pE+1oADTAMBQD/QAEFMA0VAPtACBWvu4EAWF7FJCYSiyCOJ5Qs/K7I +Fa/PBQDk5RQnaIEAAA/dAey7DAbpAQAAnen9wQYV4AwFAPprKBWgDRUAWF63wCDRDwAAAP/6TA2g +BQUAHtZ/jej3oAw4kgCdAAxqEaOqKKKe9wAM6+IAnQAqop3koZRm+/0AAP/BBhXv+pIAKCBACIgQ ++KAGFa/5ggCOrizgBCfgBR3Wme/gBi5mAoAAB8wC7uAHLmYCgAAPzAIIzBEOzAINzAEnzGf2jgAL +8IuVAPbggBXv+PoAjlDaIP2tagXn7sEA7iRAKWAEgADtVgAiWGEAAFhdw8Ag0Q+cEJ0R6NZ+Fnmd +AAD6IGYV5P8dAC8WAugABQ7IBIAAbfkGCQJhnBCbEy4gBykhB/lAAATwrhEA6qoQDM8CgAAKmQIa +1pcKmQKKEYwQLSEImaD4QAgVoe4BAO8SAi90AoAADt0C7tZHHEYCgAAI/wLvpgEmeSEAAJ+jH9aQ +nqKUpQ/dAp2kBQSJ/0DGFeC+BQCepwogi4snLiAM67IOJmDBAADspgcvdAKAAA7dAu2mBCVQoQAA +WW6kixOMEokRGtZ479YwHmcCgAD9IABEv/YOAAD6AEIdoDsFAOzWaxloBIAAWXPAY/4IAAD/9RAN +oAoFAJwQ+iBmFeAKBQBZcUEe1heN6IsTjBD5v/MYkgCdAP/0eA2gCgUAwKDA+g/fNP/BBhXv9D4A +AAAAbBAEiSckIAcomRQEBEHnkgkkC3GAABPWCPaAaB2nhQEA+QAMcVIAnQD0gAraEgCdAAxJEQOZ +CCqSnvdADlJSAJ0AKZKdZJF4GtYjH9YDG9ZJ6gAFDNAEgAAKAmEKAmEKAmEKAmEqIAcoIQf5QAAE +MMoRAOrMEAxHAoAADIgCC4gCmJCMIP8gRhXgPgUA/yBmFaANRQDu1jgeZgKAAA3MApyR+kgwFeAF +JQD8QQQVoAQFAP8gxhWh+gEA5JYFL/wCgADvzAIE0IEAAO7MAg2I1gAAwLCUl+yWBC3+AoAABf8C +FdYmByCGCgJjBwCGCgJhn5noIggrdwKAAKPu/dOmFe+cdQAsJAXysSgV75plAOokBSwG7gAAiCx/ +hyYrIhIuMmsLikT7WgANMAwFAP9AAQUwDRUA+0AIFa+7gQBYXfEkJhKLII4nlCz8rsgVr88FAOTl +FCdogQAAD90B7LsMBukBAACd6f3BBhXgDAUA+msoFaANFQBYXePAINEPAAAA//pIDaAHBQAV1auK +WGqhfwxpEaOZKJKe9wAEYlIAnQApkp3kkINlW/0AAJtYZZ6XYAANLCBACMwQ/OAGFa/5sgCOcNog +/avmBefuwQDuJEApYASAAO12ACJYYQAAWFz/wCDRDwAAAAD6ESId7/uiAPoAQh2gOwUA7NXZGWgE +gABZcy5j/xAAAP/45A2gCQUAwKBZcLGKWPlf+6iSAJ0A//4oDaAJBQAAwJDA+g+vNP6hBhXv/eoA +AGwQDogizowpIhMd1dX7qxQFoZlBAOfVehzegoAA6xYELM+CgAD7IABEsBvlAPggphXgBGoAwCDR +DwAALkIbLEIarq566wGxzC5GG/yDRhWgBAUAKCEHGdVv9IAAhTqIAQDs1cAcRwKAAAmIAikhGphQ ++EAIFaBOBQCeU5xSHtW6HNWUDqoR7v4KBVG9AAD9BgAONKodAOxWBCxGAoAACKgCHNWymFEu4qHp +VgYjQMEAAOhWBSJIBQAADJkCGNWtKVYUiRQc1awI7gEOmQIMmQKZV4kYjikoIhap7umICAdwwQAA +7iYJJEDBAAAoJhaMGe/Voh5nAoAAp8wqxp0uIBb6QPAVr5mFAPhgph3g+PUA+cUmDaKsBQAMrB2v +ySmSf8GPDogM+SAk+iIAnQAMqRHtmQgPQgKAAAi4ApiTKjITKTIS+yAfjCAb5QAvIAcPD0EM+hGn +qiyinp8Z+4Aio+IAnQAlop2LFeRUR2LRgQAAJjISiTcuMheaFiiZFCuygPpDCBWgBAUA7u4JBB1J +gACEmSgyE4kpBO4LCGYMiCoKZjamu+sWCCXYwQAA6xYAJ3HBAADpiAwLYASAAPsAF2viAJ0AKiAW +KAr/7wIABUhBAAD5QAQUIgCdABjVaJQfkx4kIAclFhD0IOYVoqUFAAVEHRXVYwqjCqhIpUQEMwsU +1WGkMySCfvsgBADQCRUAAJUaBUQBJYJ/BFUCJYZ/JDJ/kxPlEhAiIAUAACQ2fyiCgOMSDi0BCoAA +5BIPLNAKgAD7ABoYogCdAIgXDIgRrYiIgAiqAWSjSCZUJycWEfoiRhXgCAUAKFQj+KQmHai2HQD6 +pMYd4ApVAPqkBh2oux0A+qSmHeAKBQD6pEYdqLsdAOtUJCJI4QAA6QYAArihAAAHAIqLPvqmZh3o +ux0A+qZGHei7HQD6piYd6LsdACtUMCkyDfqnRh2gCwUAK1Q5KVQ3+KdmHaAIBQD4pwYdqJkdAPim +xh3omR0A+KamHeiZHQApVDQpIhcoVEwoVEArVE0rVEEqVE4qVEL4p+Yd4AoFACpUT/qoZh2omR0A ++KfGHeiZHQD4p6Yd6JkdAClUPCcyFSh8ASg2Ffao5h3odx0A9qjGHeh3HQD2qKYd6HcdACdURCky +EysyFAm7CPqpZh3oux0A+qlGHei7HQD6qSYd6LsdACtUSCgyEicSESsSEgmIDHhpCyhQISkKgAmI +AihUISpCGcCQ5KE2YkGhAAApNhYpNhcKajYqVhXoJgAC4WEAAAwEiikyE6qZKTYTKEIZCmwMCogM +6EYZLGN+AADxmEAN4AQFAPhiyBXghAEADpoKiRaKoCIWEwmCCgrKNpogIjIWmBIOIgvpiQsBECEA +AOLGAATIIQAACRiKIjIWKDITDiIKqogoNhOJIAqZDJkgKTIWDpgKiIAKzAziEhMiIAUAAOkWCiQB +OYAADpwLiMOOwqiomBF6iwGx7p7CiBH5gGYVr+/6AAAAAAAAAADiFhMkgeGAACoyF//DABWgCAUA +6DYWJVAFAAD6YuYVoAkFAIoWiBIirBgIKjnyImgVoIQBAOoWBi56PgAAY/uywJEpNhb//2gNoAkV +AJ8bnhyWHesSAClQBIAAWDQxjB0d1KiOHIsQ7xILJWfJgABj+2IqMhYOqgqKoOSu8mLBYQAACmo2 +KlYVKTIWDpkLuJkJ4IgIHIosMhYkMhMOzAqqRCQ2E4nACpkMmcAkMhYOSAqIgOpsDAQCSYAADkwL +hMOOwqSkeksBse6ewpTD/+yIDaAEBQBj/FmJOGSa94o5wICYO5mgiziasZg4+GEmFaACBQDRDwAA +AP/r3A2gBAUA8IGgDeAJBQAoMhcu7BjpNhYkQAUAAPhi5hWv+VoAwKH6YsYVr/kyAIkTKZ0CKpEC +KJEBKZEFCogB+R/lwuAKFQDaIOwkAAfYSQAAWFt+wCDRDwDaIOv8GClgBIAAWFt5wCDRDwAAAADu +6woH+8cAAK/PD7sLH9Rsr7uPGCqxfw+qDPtaABWgDwUAD6o1+2/kHa/tMgAAAABsEA6DKhzUY4o/ +iDLsJgshSIEAAJmg6iYJIdjhAACbKOk2DywmJgAALjITHdRP/6gIBeHuQQDn0/QfRoKAAOgWBS93 +goAA/8AAR3Ab5QD+IMYVoARaAAAALkIbLEIarq4uRht66wGxzPyDRhWgBAUAKDEHGdPq9IAAhTqI +AQDs1DscRwKAAAmIAikxGphQ+GAIFaBOBQCeU5xSHtQ1HNQODqoR7v4KBVG9AAD9BgAONKodAOxW +BCxGAoAACKgCHNQtmFEu4qHpVgYjQMEAAOhWBSJIBQAADJkCGNQnKVYUiRUc1CYI7gEOmQIMmQKZ +V4kYjjkoMhap7umICAdwwQAA7jYJJEDBAAAoNhaMGe/UHB5nAoAAp8wqxp0uMBb6YPAVr5mFAPhA +ph3g+PUA+cUmDaKsBQAMrB2vySmSf8GPDogM+SAlEiIAnQAMqRHtmQgPQgKAAAi4ApiTKiITKSIS ++yAfpCAb5QAvMAcPD0EM+hGnqiyinp8Z+4Aiu+IAnQAlop2LFuRUSmLRgQAAiSeMOSYiEiiZFC4i +F5oR67KAJB2BgACEmSgiE4k6Du4JCGYMKDIYBO4LDJkMCGY25rsIB3HBAADrFggl2MEAAOsWACtg +BIAA+yAXY+IAnQAqMBYoCv/vAgAFSEEAAPlABCQiAJ0AGNPklB+SHiQwByUWEPQg5hWipQUABUQd +FdPfCqIKqEilRAQiCxTT3aQiJIJ++yAEANAJFQAAlRoFRAElgn8EVQIlhn8kIn+SFOUSECIgBQAA +JCZ/KIKA4hIOLQEKgADkEg8s0AqAAPsAGlCiAJ0AiBcMiBENiAgoggAIqgFko00mVCcnFhH6IkYV +4AgFAChUI/ikJh2oth0A+qTGHeAKVQD6pAYdqLsdAPqkph3gCgUA+qRGHai7HQDrVCQiSOEAAOkG +AAK4oQAABwCKiy76pmYd6LsdAPqmRh3oux0A+qYmHei7HQArVDCJLfqnRh2gCwUAK1Q5KVQ3+Kdm +HaAIBQD4pwYdqJkdAPimxh3omR0A+KamHeiZHQApVDQpMhcoVEwoVEArVE0rVEEqVE4qVEL4p+Yd +4AoFACpUT/qoZh2omR0A+KfGHeiZHQD4p6Yd6JkdAClUPCciFbF4KCYV9qjmHeh3HQD2qMYd6Hcd +APaoph3odx0AJ1REKSITKyIUqbv6qWYd6LsdAPqpRh3oux0A+qkmHei7HQArVEgoIhInEhErEhIJ +iAx4aQsoUCEpCoAJiAIoVCEqQhnAkOShOGJBoQAAKSYWKSYXCmo2KlYV6CYAAuFhAAAMBIopIhOq +mSkmEyhCGQpsDAqIDOhGGSxjpgAA8ZjADeAEBQD4QsgV4IQBAA6aCokRiqAjFhMJgwoKyjaaMCMi +FpgTDjML6YkLAZghAADjxgAEyCEAAAkYiiMiFigiEw4zCqqIKCYTiTAKmQyZMCkiFg6YCoiACswM +4xITIiAFAADpFgokATmAAA6cC4jDjsKoqJgSeosBse6ewogS+YBmFa/wDgAAAAAAAAAA4hYOJIHh +gAAqIhf/wwAVoAgFAOgmFiVQBQAA+kLmFaAJBQCKEYgTIqwYCCo58iHIFaCEAQDqFgEuej4AAGP7 +t8CRKSYW//9oDaAJFQCfG54clh3rEgAp0ASAAFgyrYwdHdMkjhwrEgDvEgslZ8mAAMAg0Q8qIhYO +qgqKoOSu8GLBYQAACmo2KlYVKSIWDpkLuJkJ4IgIHIosIhYkIhMOzAqqRCQmE4nACpkMmcAkIhYO +SAqIgOpsDAQCeYAADkwLhMOOwqSkeksBse6ewpTD/+yUDaAEBQAA//FIDaAEBQCJKGSfioopwICY +K5mgiyiasZgo+EEmFaACBQDRDwAAAP/r0A2gBAUA8IGgDeAJBQAoIhcu7BjpJhYkQAUAAPhC5hWv ++ToAwKH6QsYVr/kSAIkUKZ0CKpECKJEBKZEFCogB+R/lmuAKFQDaMOw0AAfYSQAAWFn4wCDRDwDa +MOv8GCngBIAAWFnzwCDRDwAAAADu6woH+8cAAK/PD7sLH9Lmr7uPGCqxfw+qDPtaABWgDwUAD6o1 ++2/kHa/tJgAAAABsEAQb0t8qMQwrsn8c0q/4YhAV4BRlAPtD1g3gBQUAfKEW6iQACtgEgADsNAAK +aASAAFjIRMAg0Q9okUhokiholArAQP//aA2gBQUAAHyh0XurztowWMhx1aD//xANoAQFAAAAAAAA +AP1A5g2gFGUAe6MCYAABwEDaMFjIhf/+hA2gBQUA2jBYyJXlpAAFARGAAP2leAWgClUA/GAoFeA7 +BQBZb/T//eQNoAQFAAAAAP/9uA2gBMUAbBAEKTAT8SZwDeD1hQBokQTAINEPAIQnhE4c0q3tMBEi +SA8AAP0/hh3gClUA7jASIkATAAD/G6YdoDsFAFlv3/xiMBWj+tUA6koIAdhhAABYyJalO/xiUBWk +2uUAqkpYyJPqJAAKWASAAFjIm8Ag0Q+EJw8CAA8CACRCDhzSli0wES1EAv5iUBWgClUA/oBmHaA7 +BQBZb8n8YjAVocqFAOpKCAHYYQAAWMiApTv8YlAVoqqFAKpKWMh9wCDRDwAAbBAE9FsCHeizHQD0 +QABC8EoFACNUfytUfvqvRh2gRDUA9K+mHaAIdQD4r4YdoAkFAClUe9EPAABsEASPOP2k7AWgClUA +/GIQFeA7BQD/4Ggdof/xAFlvqSkwEP0hgADQAjUAaJI9wCDRDwDaMFjJHP9fIA3gCHUAi6eLviyy +jgyZVvkC4B3o3LkAfSAP+2BAJeAMBQBYyOjAINEPAFjIXsAg0Q8S0l6DNiIifwkzEaMigiqCKC4i +E//xgh3ggwUA7yRoJ2CcgACKJ/oAQh3gDAUA+0QAFaANJQBYUlUrIhMs+n/TDwy7ASsmE4wnLskU +isn9hAAV788FAO/dAQdwgQAA7sUUJVOBAADqxgkm6QEAAH2rBijBFaqKmskc0f7ZoPwACB2gCyUA +bboCCQJhH9I8G9Hbm6D4QAgVoAkFACmlCCmkEv0AABQwCSUACYgCmKEuIhONIp+iA+4C7iYTLvg2 +AAArIAf6QGgdobsBAOu8GClgBIAAWFkpwCDRDwAAbBAEiC4jLDhzgS2LLoiz7EQACugEgADrvOAp +UASAAAuAAIwiwOHxgPwN4A0FAI8uA/8MD+04ZN/RwCDRDwAAAGwQCBrSGCgSEJIV59GrG8gEgADm +EgUrEASAAJgXmRT6wABDMAAqAABkUGjNKypigAo8AexJ8XKr/QAAjRRk0Ef7oAYVoAIFANEPjxfL +/AjqMBnR+SmSRcClCio3CpkoqYiYFooXKXKCGNH0CpkBCRqOCKgKiIALgAAM6jCLFgy7DGux3mP/ +pQDAINEP2iBZZflj/5jeMO0SBSp4BIAA+iAGFaALhQD9o+AFoAoVAFlvI8cr0Q8AAABsEBYrIAcj +FhrlFhcqSASAAPghJhXgChUAmh8V0eYmEhr8IugV4bsBACsWFodl+MCIFaP+9QD6rIQVp90BAPbB +5BWgd/kA+AoAAbDIWQD8I2YVrEgdAPqPAA0wtnkA+iJmFe+qAQDqFhQkVEqAAAYLSfohxhXgACYA +AAAAnh4uEhotFhUv4T0o4B0oFAAvFhIu4h8uFhD1oDrhEgCdAIki+yBCIJIAnQDw5WAN4AwFAOwW +ESOASYAA2kBYyqX0AAId4AYFAC4SG9pw/ABiHeAMJQDu3DkJ2ASAAFjKk/dAAEMwD/UAdvBV9CEG +FaSGHQDjFgckQAUAAPgjBhWgAT4AAAApEhJkl28qEhqKpX2mn/wiCBWgCxUA6xYRKlAEgADrEhIo +6ASAAFjKumanofwAYh2gBQUACsU6ZFeLw2CUGPIg5hXk1h0ALRYYLxIWHtErE9Er6RIYL6AEgAD1 +4AhyEA2lAAz2EaNmKGKe+QBCw+IAnQAmYp3bYOa0AAW+AYAAj+ibFffgPjiSAJ0AKDKu0w/qEgkk +PFGAACsyreS3gWfL/QAA6eYIJbwhgAApIBTTDw8CAKqZCQlHKSQU9SA9JlIAnQArEhsuEhTxYMAN +4A01AP+gP8iiAJ0AZFDFjxcPAgDI8WRQY+tkAAlQBIAA/ABiHaAdhQBYyrLuEg4teASAAOYSCCKv +GYAAKBIT+6IEBeAMBQCc8pzznPSc9etrAg9UAoAA6/YALECCgAAKiALs0WEazsKAAPkGAAxwClUA ++eAmFaAbxQBZbo4tEhX5oDppUgCdAMAg7hIYKn8CgACj/y72ndEPAAAAAAAAj+j34DsgkgCdAOkS +GCo3AoAAo2YoYp75ADt74gCdACtinea0AAW7YYAAsPiY6PrAaB3v+2YAKhIRZKB46xIFKVAEgAD8 +AGIdoB2FAFjKghjRPxbRPSsQAI4YGdE+9tmoFaH7HQDo7gIP+wKAAAn/Aua2CwX8nIAALBIQ7RIS +I1v/AAAosj8rsX2eoJ+hnaKco5uk+UCmFaAAbgAsEhAtEhIrYQWIY56gn6GbopijnaScpSasGC0S +E4weAt0Q7RYKLmQCgADsFgsrps4AAPuhbgXgCgUAmhaKGMCCmB0LqgKaHOtkAAlQBIAA/ABiHaAd +hQBYyliNHC8SGokWKxIaj/XxNWAN4/71ABzRE4u0/0BGFaCPmQD9QAYV4G+JAP1AJhWg36EA8NAA +EzDPkQDu0Qse6UKAAO6mAyxBAoAA/QYADHm7AQDrpgQuYMKAAAxmAghmApaljB3pnAElMGEAAOkW +BiZj/QAA7BYNLnu2AADrZAAJUASAAPwAYh2gHYUAWMo1FtD2iRqPG/ohiBXgDQUAnRGdEp0TnRSd +pP1AphXv/vUAnqKeo5ugLhIa6f8CCsbCgADo/wIA4DEAAOb/AgDYIQAA7RwQJTBhAADvpgEg0BEA +AFjJDMDB6so5DSgEgADZoOoWHiKh2YAAJBYf/gAiHaANBQAJ7TjlFiAm65GAABPQ2IgbjBoa0Ncr +EhuEGBXQ0PF4ABSwDhUA6+s5CieCgAD0hgAKdg8FAAuvOf0mAAywDTUA+SYADDAMJQAL3DksFh0J ++QIpFhn55gAPsAUFAP4jhhXgAyIAD1ZQ/hgABfDPyQD8IYgV4I+xAP1ABhXg73kA7O4RDEQCgADr +zBAN2oKAAOy7AgszwoAA+MYACzDPgQD9iAAWMY9pAOzuAgxFAoAACO4CHNCqnKEoEAAG7gL7xgAP +cG+5APTIABM7vwEA98YADzAGJQDm7gIN3QKAAO6mBCxCAoAAC4gCmKUb0KKbohjQovlAZhWv+aYA +AAAAAAAAAJmhlKCeop6jnqSepZ2mnaedqJ2pLxId5VwBJTChAAD+oBGcYgCdAOtkAAlQBIAA/ACC +HaAthQBYycnkUFFqzsKAAPSgCmCSAJ0AKxIcx+/7JgAM8A0FAOOZAgv9LgAAjRMsEhqOEo8Ri8ws +whCZoZup9UAGFaAIBQCYopimn6OepJ2nnKWMFP1BBhWv/iYALRIbLBIZG9B5DJkC65kCBoQZgADw +4kAN7/71AJmhlKCeop6jnqT/QKYVoA0FAJ2mnaedqP1BJhXv/TYALxIaIhYhK/IWJvE4IvE6LPIV +6PE5KzQCgAAGIgIm8Tst8hvu8hosRAKAAAhmAijyFy/yGZ+inqOdpJymm6eYqJalmaGUoJKp8iQo +Fa/79gAAAAAAAAAA8OJADe/79QCZoZSgm6Kbo5uk+0CmFeAIBQCYppinmKj5QSYVr/s6ACwSGo0S +L8E7JsE5KME4LsE668IYKzQCgADm/wIMRAKAAAjuAibCFIjMLMIQm6SYp5aomaGdopSgnKOfpZ6p +jBT9QMYVr/oaACsSG+wSGSWDUYAAG9A3x+/9JgAMsA0FAOuZAgOA8YAAmaGUoJ6inqOepJ6lnaad +p52o/UEmFe/5MgAuEhoiFiEt4hIs4hMr4hiI7YbuL+IUgu8u4hGeop2jnKSbpZimlqefqZmhlKCS +qPIkKBWv+FYAKxIcx9/7JgAM8AwFAOOZAgOA8YAAmaGUoJ2inaOdpJ2lnKacp5yo/UEmFa/3mgCZ +oZSgjhP+ICgV4AgFAJiimKOYpJimmKeYqJ+l/0EmFa/3CgAqEhoZ0AmKpRPPjyUSIOQSHyVMMIAA +48+LE4VZgAAc0AOLGAy7Avs/RhXv5+IAhR/A0vetAAr/6GYAwKX9n/oFoBvFAO5OEQpoBIAAWW0e +Y/iPAAD6IogVoA4FAJ4RnhKeE54UWMgPyKn6IogVoAsFAFjIBMCgWS2NJBYf5RYgJWGhgAAfz+wv +8IAkFh/lFiAv4R4AAPuf0AWhSxUAWVlnLOr/DKwB+5/IBaFLFQBZXIskFh/0JAYV7+/yAC0SEGXY +iWP4Lh/Pno4YD+4C/z9GFa/lRgDAoFktdcipGM/W0w8ogIBkgFwqEhRYx+7pEh4tXW4AAPoiiBWg +CxUAWMfh+CPIFe/uagAAAAAA/9/kDaA2BQDrEhIqUASAAOwSECjoBIAAWMirY/hHAAArEhqMGe0S +FylQBIAAWFTK0qDRDwAAAAD7n3oFoUsVAFlZOywaAAysAvufcAWhSxUAWVxfY/+DAMCwDfg06OYI +LcQmAADaIPxAaB2gG8UAWFEWY/+qKxIW2iDrvBgpYASAAFhREWP/l8CgWWpTHs8pj+j5/8F4kA2l +AGP/x4wfLSEJ/kKwFa//BQAPnwEPmAzoJBQvcQKAAP9gZh3gCAUA6LQALu4CgAAO3QIM3QKdsfx1 +phWv4KYAiieNGcDA6qwgLtgEgABYT4LSoOsSGCpnAoAAo8wrxp3RDwAAAAAAAP/erA2gBgUA/+Ao +DaAFRQDAoFlqMR7PB4/o+f/EkJANpQD/4rgNoAYFAAAAAAAAAP/iUA2gCwUADfg0+cEGFa/iVgAA +AAAAAGwQDBrO/RjPeCmiiCqigCiAff1IABUwhAUA6pkIBHwwgAD1IABCMAAmACQqgKSUGM8X6AAF +CMgEgAAJAmEJAmEJAmEJAmEZzyAqQS4fzuobz2d5oWoYzzaOIJsQ/iBGFeAJRQDoFgYvdgKAAAnp +ApkRL0AHDw9BAP8RD68CCP8CnxQI6jAcz1oD7gL4IKYVoA8FAJ8XKyA1/iFmFaANJQCdGQy7AusW +CCGcZQAA6kQACNgEgAD8AIIdoA0lAFhL2NEPKyw2+idAFaAMZQBZZ0Fj/9kAAAAAAGwQBiggBS0g +B8GUDwIA+QAOtWHdAQApIgJlkZMuMAEWzr7/wUAG0AylAC8gTmXyV+7OuR7IBIAA9aAJ0hIAnQAM +2hGmqiiinp0Q9wARlNIAnQAqop3npAAFDQGAAIvomRH3YA0wkgCdAC1irmTRWCpireShVGX7/QAA +7+YIJQq5gAArIBSkuwsLRyskFPVgDL3QDQUAGM6mH88AjiD95cYV4AtFAOjuAg9WAoAAC6oCG88b +LvY06vYtK+gEgADrDx4N0ASAAA0CZwtAhg0CZQsghg0CYwsAhu0MAAPZAQAACuCGHc8PCwJvCsCG +CwJtCqCGCwJrCoCGCwJpKiEJLyAHLjABKDEBKyEk/iAABzD/EQDq/xAPdAKAAA/uAg67Ah/PAS4h +Ig27Ait2IA/uAo0gKnYj+OSGFaCahQCqehjOhS52Iv2gABawDiUADt0CLXYhizMrdiUIAIkKAIoM +mhGmqv1TphWnhQEA+QAHmVIAnQDAINEPi+idEfdgCNCSAJ0ADJoRpqovop734AmE0gCdACqinWSh +J7C/n+jnpAANde4AAPwgBhXgAUYAAAAAAOokAAnYBIAA7EQACugEgABYU93SoNEPAMCgDLg06OYI +LXWOAADaIPxAaB2gG8UAWFW3Y//KAAAA6iQACtgEgABYVTzSoNEPAACLENog67wYKWAEgABYVa1j +/6TAoFlpah7OQYvoiRH5f/JwkAylAGP/sgAAAAAAAPhCsBWv/gUADr4BDr8MLyQULyEJ7aQALEEC +gADupAMv/gKAAPnmAA+wDhUADv8Cn6H+1aYVr/jiAIon60QACmgEgAD7RAAVoAwFAFhOl9Kg0Q8A +AAAAAAD/90QNoAoFAMC4C5sC+kBGFe/8fgAAAAD8IAYV4AoFAFlpRR7OHIvojRCJEfl/9pCQDKUA +//uQDaAKBQAAAMCgDL80/8EGFe/7VgAAbBAIKSAFJiAH5zQACcAEgAD6AoIdoAM1APsgDz0hZgEA +BQlH5c4KFJRRAACMIuRkAAYEEYAAwCDRDwAALSIdZdHZiCeLiP0CpBWvzQUA6YILJHiBAAAN/QGt +zO0WAiZhAQAA+yAOLGIAnQDuiRQqTwKAAJkTq5qp7i6FFPuAEOOiAJ0AyXTJQtmwbUkFBwCGCQJh +LRIDKvIADaoI/UATpCIAnQCa8PlgaB2v/goAAAAAAAAA7GoRAyShAAAFqgguop73wApx0gCdACqi +nc+r2iDsJAADWGEAAFhVRcAg0Q8XzdqJeJgU9yAQCJIAnQAMShGlqiuinvdgEFHSAJ0AKqKdZKIB +sJubeGSvwhnN85mgjiD9nKQF4A8VAO+mAi92AoAAA+4CnqGOgy3Sf/2brAWo7h0Art0ezc3tpgMl +SEEAAPwAChWgCAUAsYjpgx4MD+gAAJ6mGM5C+UEGFaAfBQCfp40gCN0RA90CnanpIgcqZwKAAKXM +I8adKyAGjSLA4e7dAgXYBQAA6yQGJMiBAAAsmQT5ICgVr8sFAAubAe0mAiZgwQAA7JUEJENBAADo +lgEl2QEAAHuLJSqRBR3NraiomJGdgIwgG84n64YCLmYCgAADzAL9ACYVoAIFANEPHc2lnYCMIBvO +H+uGAi5mAoAAA8wC/QAmFaACBQDRDwAAAAAA6iQACtgEgABYVILSoNEPAP/61A2gCgUA+LDIFeAY +lQD4ICYVoAEGAPsgaB3gCgUA+wFmFa/5ugAoUoQrgAgpgAf4IAYV4KwlAHyxLhjN34iAwKALgACK +EIkRCpkM6RYBJO7pgAArUoJ/twksUoJ/z8Zj/ckAWWQwY//vL4ELL/z4Dw9D7/z8JPP9AAAP6Tj4 +IAYV7/7mAADrygwDgbmAAApMFO3MCCvABIAA7U02DcgEgADTD23ZBQgAhgkCYYkSqnjsTgwEyQEA +AG3pBQgghgkCY40TjBIK3QytzCzMQP3gBhWv9v4AAMCgWWh/iXiIFPk/77CSAJ0A//ggDaAKBQDA +oMDqDp40/uEGFa/35gCIEiiMQPngBhWv9iYAAAAAbBAIiCeJIvxA8BWvxgUA6oEVKl8CgADrOwgE +QIEAAAaIAflAAEQwDzUA6IxALegEgAD5YCDSocwBAC7QB+3NOh6oBIAADMsR6uwDJzv5AADtuwgE +gEGAAMAg0Q8osp6aEe7NMBdIGQAA+QAfW+IAnQApsp0sFgDmlAAEnzmAACniCPcgH3CSAJ0ALNKu +ZMOdKtKt5KOZZMP9AADo5gglHPGAACwgFCtQB6y7CwtHKyQU9WAe3dAOFQAZzWoezaKLEIogiDTs +zSAd3wKAAO27CA1WAoAA8QAE+l/NBQAtIAcjUQH/RgAMcN0RAO0hJC7SgoAACaoCmGGaYBrNMvzA +RhWgGIUA+MBmFaAIJQDqAAUDUEEAAG2KAgoCYSwhCfpA8BWgCAUA+MCmFaA/pQDjZgkuZQKAAP+G +AA5xqgEA7GYGLVQCgAAK2gIOqgKaZCghCfpAaB2gDAUA/qAkFaAJNQDptp0sXQKAAP9mAA3wDQUA +WFPPwCDRD48nsX4OrgIp8RXpFgIn+IEAAA39AZ0VrZntXCAkyQEAAHnTBIgSCN0MidD4+AAE8IgV +AHiZGZ5h6c1mE8P9AAD4wAYV4YgdAPjARhWgAEoAnmEZzWCZYIjRCFgUmGIezV8YzV2JNo3xKIKA +/+CkFeKZHQAOmQGpiJhj6BIFInAJAADvFgMvdwKAAK7dqP/nSAgH+QEAAO/TCXRACQAAiRMJ3QwM +iBEOiAzkgEhr9wKAAO3pCANAQQAAmBT54A8K4gCdAA3/DPkAaB3krx0AbakFDQCGCQJhiRUKfQym ++OqMECTJAQAAbdkFCSCGCgJjKiIACKoRGM02rmn/mnYFoA8VAP8gxhXgDUUADaoCmJQYzTKalYpT +KIJ+Fs0x/5loBeiqHQCqiOiWByTogQAA/gAKFeAKBQCxqu2DHg0P6AAA/SFGFaAqBQCam480iFOK +NQb/AfeaSAWniAEA7qoBDEJCgAAI/wIG/wKfnChQCS1QCy9QCiZQCO7NHR7pAoAA5v8QDEMCgAD7 +BgAMMKYxAO3/Ag1RwoAACv8CCP8CijYYzK+fnf5hSBXl1h0A7qoBDuhCgAANqgL7IcYVpGYBAOj/ +AQsyAoAABv8CiFWYn4ZWJpYQjlculhEvlhKNVC2WEypQAf+ZhAXgGIUA7lEBKAQKgADxQAQP0gCd +ACogBwoqQO0hJC1SgoAAD6oCKpYUjyAolhf94AAXsAg1AAj/AhjMiyyWFu+WFSTRgQAA+AAIHaAP +JQBt+gIKAmEvIQksIAf74AAXsBilAAj/Ai+WGv+ZvgXhzAEAAMwRDNwCD8wC/iAoFeAKBQAqlhku +lh3slhgn+A0AAJ8RjhEutp0tUAeKJ/WgAEawDAUA69QABVCBAABYTLXSoNEPAAAAAAAAAOmEAAPy +iYAA0w9teQUNQIYJAmVj/jjAoMCKCJg06OYILWNWAADaIPxAaB2gG8UAWFOhwCDRDwAA+28ADr/v +mgDAkPwgBhWv8GYAK8wY6iQACWAEgABYU5fAINEPwKBZZ1QezCqJ6B3MKvk/4CiQDzUAY/+wAAAA +APhCsBWv+QUACbkBCbwMLCQULCEJBIgQ+UBmHeAJBQDppAAuZgKAAAjMAg7MApyh/7WmFa/v2gAA +bBAGKSAFJiAH2DD2AGId4BpFAPsgDo0hZgEABQlH/SMAAV/FBQCLIhPMDuRkAAWDyYAAwCDRDwAA +AIgni4gsgRXpggskeIEAAAX9Aa3M7RYAJmEBAAD7IA00YgCdAO6JFCpPAoAAmRGrmqnuLoUU+4AM +66IAnQDJNclD2bBtSQUDAIYJAmGNEYrwDwIADaoI/UAPvCIAnQCa8NOw+GBoHa/+GgAAAAAA7GoR +AyShAAADqgguop73wAnx0gCdACqinc+r2iDsJAADWGEAAFhTTcAg0Q8by+KJuJgS9yAMCJIAnQAM +ShGjqiyinveADGnSAJ0AKqKdZKGEsJycuGSvwhnL+5mgjyD/mLQFoAsVAOumAi/+AoAAB/8Cn6GP +gy7if/2XvAXo/x0Ar+4fy9XupgMlSEEAAPwAChXgCAUAsYjpgx4MD+gAAJ+mGcxK+UEGFeAYBQCY +p44gCO4RB+4CnqkMTRGj3SfWnSwgBokn7SICJmAFAADsJAYkyIEAACyZBAvdAoiR7SYCJmDBAAAs +lQTlnAEEQ0EAAOiWASZhAQAAfIskKpEFHcu4qKiYkZ2AiyDAwOyGAi3eAoAAB7sC+wAmFeACBQDR +Dx3Lr52AiyDAwOyGAi3eAoAAB7sC+wAmFeACBQDRDwDqJAAK2ASAAFhSjtKg0Q8A//sUDaAKBQDz +IGgd4A4FAP8BZhWv+kIA68oMAYG5gAAKTBTtzAgpwASAAO1NNg3IBIAA0w9t2QUIAIYJAmGJEKo4 +7E4MBMkBAABt6QUIIIYJAmONEYwQCt0MrcwszED94AYVr/j+AADAoFlmpxvLfYm4iBL5P/OYkgCd +AP/6FA2gCgUAwKDA6g6eNP9hBhWv+doAiBAojED54AYVr/gaAGwQBBXLdxbL0PCIABOwCUUA5Mvu +GcYCgAAJiAIoZi0FNQLnZi4qGASAAOVmNCkwBIAAA2CGBgJnA0CGBgJlAyCGBgJjAwCG5gwAARkB +AAD1yGgdoIoFAKoiAwJvBMCGAwJtBKCGAwJrBICGAwJp0Q9sEAYjIAcUy1QDA0EMORGkmSiSnv0I +IEHQBTUAK5Kdy7Yfy90Yy936QAgVoAkFAPggBhXgDAUA+CBGFeANVQD4ICYVoB7lAFhPCgw6EaSq +9VOmFeACBQDRD9og6zwYKWAEgABYUqbHJNEPAABsEAYoIHDAZOXLORR1tIAAJCAHBARBDEkRpZkq +kp7jIgAtIWwAACqSnWSgUNswWNt1wMH8AAId4A4VAPmWvgWgCQUA+CAmFeAPBQDpFgItWASAAOgW +ACnQBIAAWE7qDEwRpcwmxp0qIHArCvsLqgH6TgYdoAIFANEPwCDRD9og60wYKWAEgABYUoLHJNEP +AABsEAQkIAcTy6YVyxQEBEHjMn8qTwKAAAWZCCiSng8CAOQzCAwROAAAKpKdZKBDAzsC/AACHaAN +JQD+AEIdoB8FAFln4f2XMAWgDhUA7KYAKe4CgAAO3QKdoYsgm6IMSRH1IABE8AglAPkzphWgAgUA +0Q/aIOtMGClgBIAAWFJgxyTRDwBsEBYuMBD3legF4B9FAPPB8A3gBgUA9cBBOJIAnQBo4gPAINEP +KiAHBQlH0w/4I4YV4aoBAOoWHiyUaAAAKyAF92BYvFIAnQAsIHLzgFhnkgCdANogWFDAZafMjSJl +18cuEh6INSoiEPghRhWgGYUA7hYQJHhdAAD7HgAMtP8dAO8WCyf4DQAAnx2fHPXAUWISAJ0ALBIQ +DMwRp8wrwp63Tf1gW1viAJ0AK8Kd+2BZIBIAnQCMKY0qDA4+LhYaDN0Mftt5KiAiKSAjCpkM+yBb +ABIAnQAoIAcay1P9WAAV4YgBAA2ICSiNAi6BBgnvNg/uDC6FBi0gIq/dDQ1HLSQi+6BaOBIAnQAo +on/uIgsmy/0AAPsABADQCBUA4JkaDEAKgADp7ggEQ/0AAAjuAp4qKBIaDOkM+SBY26IAnQCJHR7L +OiwgByghBx3KpP5BJBXgzBEA9ZAAFjqIAQDtzAIMQwKAAAj/Ai0hJJywiiCIGhzKo+7dAg1WAoAA +CpkCmbEqISKdtJ+zDKoCmrIcyygpIhCZtRnLJ/xHEBXgDyUAn7mWt/lhBhWgDhUA/2FGFaAKdQD8 +AwAG8E51AA3qOQ3JOQqZAoob5rYLIcBBAADptgYlyMEAAG2pBQgAhgkCYR7Khp68jTDzoETCkgCd +ACoSEOkSDC1XAoAAp6oppp0oIBQvEhqkiOgkFCeAwYAALRIajCkrIDitzJwp82BPL5IAnQAuEhz5 +wE35UgCdAMAg0Q8rIAcoIAUqMBH8QEgVobsBACsWHvkALlRQqjkA+4BGuJAepQAMvBGnzC3CnisW +ECoWGf+gR8uiAJ0AKcKdKRYR6RYdKAQKgAD7IEdYEgCdAPpAaB2gC0UAWWWMG8pS+0BHQFIAnQCL +uPdgR3CSAJ0ALHKu94BEzVIAnQAqcq0eyknvAgAF6/0AAPtAR9gSAJ0A7eYIKAQKgAD7QEPoEgCd +AC0wFC0kOCswFSYkOyskOYk7izyIOo85jjaMOCwlCS8lIy4lIiglJCklJSskTIk9KSRNKDIRLjIQ +JiROJiRPJiYbJiYdJiRwJiRy9k4mHaAPFQAvJSkvJhcvJhgvJhkvJHMuJSgoJhUuIRosMBHHvPvA +BAXzzAEA/EdGHaAIJQD5oAQGMA9FAOjQHHXbsQAA/wAABDAJFQD5LQAMOZ4dAKmIDogRCLsMGMqu +/6AEBvAOFQAM7DkLiSwN7TkLiC4I6DkeyoHpiAgLSASAAA3pOR3KMd9gDN85Cf8CLSAUCLkc6SU0 +JfPxAAAI6BwpEhmk3eglNS90AoAADv4CLiYQ7SQULcQCgAD55gAPsCwFAO8mDySwYYAAG8qUGcpK +LiAHjCmcLIg++CJGFaD+EQDoEhEv+oKAAAn/AikhCP8ABhXh7gEA7yIAL3QCgAAOmQL7JgAM8A41 +AOv7Ag/+AoAADv8Cn4H/k+AFoC8FAJ+D7oYCJHjBAAAvFh2OK5aFnomciPsAxhXgDxUA+QCGFeAL +BQD6ImYV4BllAPgjZhXgHEUA7BYJLvICgAAP7gKeh/ZChh2gLAUALSAHDQ1B68prFuhRAADqFggu +gQqAAO0yDy/ICoAAC5kCG8osLRYUKRYVKbZAKRIdG8pimxcLIIYJAmMLAIYJAmErIDgjFiDqZAAL +GASAAPoCAAbw6wEA/40ACbAMJQD9jQANcOsZAOruAgtIBIAA/WAEBbAaBQALqTkqIDnvZAALQASA +APhmAAnwiwUA/UAEBjBJBQD9YgAMMKoBAAqfOCsSHRzKRvpACBWgDQUAnREI/wID/wL8IAYVoA0F +APIkCBXgDBUA7+4CBdiBAAD/wAAXMA9FAP/GAA9wDwUA/iBGFaAOBQBYTWDAwe/KNR1YBIAA+kAI +FaQJBQD4IAYV4A0FAPggRhXgCAUA+CAmFaAOFQBYTVUoEhTpEhItWASAAPpACBWv/vUAnhD8RKQV +7//1APxEhBWomQEA+zgAFLiIAQDpiAIO7AKAAP2GAA5wHqUA+CBGFaANBQD8ICYVoAwVAFhNQdug ++kAIFa/99QD8IAYV4AwFAJwRKSEiKCEJwez5IAAUv//1APkGAAxwDBUA+CBGFaANBQBYTTMqFhYq +IShZQgntygcdYASAAPpACBWv/vUAnhAuEhMt0IwbygLu3QIGY/0AAOLpEA7oQoAA7ZkCDmZCgAAM +mQILmQKZESgiFRnJ+v//4h3gHuUA+iLIFeaIHQD5BgAMcA0FAPggRhWgDBUAWE0YGMmxjBcvEhXv +hkAtSASAAAxghgkCZwxAhgkCZYkw8yAYqpIAnQAbyUovEhAsIQfuEhsl6xEAAOrSly//AoAAp/8u +9p0rsnOPII4gKCANKSAMDrsI7iAVLd5CgAALqggqFhcrIAcrpAcppAwspQcopA0sMgkupBUt0hwu +MhH4YggVoAkVACmlKSilKC+mHv1BJB2gG0UA+0CmHe/MAQAspSP6IQgV5u4dAP+gAEaw//UA/CMG +FaAOBQD9QsYV4A0VAFjZcywSFysSGCbEFP2CsBWgLQUAWSjiLRIZZNMALiA6wP//wBgEYgCdACkw +V8SACYgMmB7A0f4f4h3gDgUA7CEJLVgEgADsFg8pUASAAFjZXyYkFIsfLCAVjR5ZKNDAvIonHMkw +iq6JGQwAhwoCYQoCYQoCYQoCYQoCYQoCYQoCYQoCYS0SGSt2rfhAph3gDhUA7iQXJoFZgAAvIDrA +j3jxHhnJBygwUAmICiiCEOwwVyHZQQAA+kBoHaANJQALgAAFCkf5QBwxUgCdAMAg0Q8AAAAAAADq +JAAJ2ASAAOxEAAroBIAAWE5v0qDRDwAABQtHKxYc+WAHAVIAnQCJJyyZFC2cIOTCnWTwwQAAjJmL +4Cn6wPmgBATwCgUA7rgMBdshAADoujkGAxmAAJkViNB8gVcrwAD/YAR0YBlVAPlgBDRgGGUA+W/G +DaAZhQD5bsYN4BiVAPltxg2gGaUAebFmixUpwAco0QWYFuuICAzPAoAA6cwIBEEBAADoyzt+WASA +AOy0AA39PgAAyajCzSugAHyxMouuwKDr7QwF2yEAAA26OWWv5y0gTvrAaB3gHGUA/Y0ADfAASgCL +FvuPAA3//w4AAAAAACwgBeskcS5B/AAALSByft902iBYToploHyOImXgdyggFASICCgkFC8yAHr2 +WCogBwoKQQyrEQe7CCyyngqpAveAGxpSAJ0AK7Kd6RYfJZsRgAAvIHHllAAJ4ASAAPpAaB2g7qUA +7+Y5CmgEgAD+wGgdoA8VAFhOSQxZEfcgAETwCEUAKJadKhIc+UATiVIAnQDAINEPAOokAAnYBIAA +7EQACugEgABYTg3SoNEPAOw0AApoBIAA+0QAFeAOBQD6QGgdoA8VAFhONCsSG7S7+iNmFe/zLgAu +Eh4byRkdyRn+ACId4Ak1AOuwgC8BCoAA6dSAL/AKgAD6IIYV594BAHvYL/gjyBXv+PUACNgDCLsB +GMjFCJkKGMjGKJahiBQZyQgL6wILC0frlIAkBdmAAGSwvsHj/iEmFaANFQD8ImYV4AsFAPoiRhXg +GTUA+CNmFe/odgAAAP/0+A2gC2UAxPD+IcYV7/QiAC4gcegSDSngBIAA6iQACmgEgAD4HUId4A8V +AO6WOQxHAoAA6LsIC3AEgABYTgGJHbSZ+CGGFe/c2gAbyEaLuPdgELCSAJ0ALBIQDMwRp8wtwp63 +Tv+gEOOiAJ0AKcKdZJITHsg8sL2d6NuQ+z+uGJIAnQBgANv/9ZQNoAwFAGS/SPAAGA2gCRUAwJAb +yNQostLH3g2IAQiYAvl6RhWv/LYAAAAAAADqJAAJ2ASAAOxEAAroBIAAWE2v0qDRDwAAH8gkwOoO +vjSe+Nog/EBoHaAbxQBYT4lj/8zAINEPAP/cKA2gCQUAKxIe2iDrvBgpYASAAFhPgWP/rNog/EBo +HaAbxQBYT31j/5zAoFljOhvIEYu4+X+4QJIAnQBj/6qKJ/qAaB3gDAUA6qwgKmgEgABYSHfSoNEP +HcgGwMoMvDTs1ggoBAqAAPtfuCiSAJ0AY/92KxIe2iDrvBgpYASAAFhPZmP8QACKJ/qAaB3gDAUA +6qwgKmgEgABYSGXSoNEPAADaIFhNQ2P2FgAAAAAA/9JgDaALBQCKJ+tEAApoBIAA+0QAFaAMBQBY +SFnSoNEPKyAF9X/fgJIAnQCMIsDSDcwC/EBGFa/vhgCcKv+AaB2v034AKyAHGMiD/68ADPG7AQAI +uAnpJCIkQAsAAC6BBq/uLoUGLSAizNiMKfxBRhWgALIAKaJ//kFoFaAPFQDgkQQGw/0AAOCIGg/4 +CoAA6O4IB/v9AAAP7gKeKiu8H+okAAlgBIAAWE8wY/tpAAD/8oANoAsFAAAAK6wY7CQACVAEgABY +Tylj/NTAoFli5hvHvYu4+X/vAJIAnQD/9+gNoAkFAADAkB3Ht8DKDLw0/aEGFa/3ngBsEAQYx7WJ +ICuCcyiCiPsgAETwCwUA6yQULM5CgAD5AABEcBkFACkkBeuEFClQBIAAW+MC0Q8AAGwQBBnIDooy +KZJ/CaoRqpkskAaIksDb/SCmHe/75QDriAEGY/0AAOyUBizQBIAA+SBGFaALBQBb4vPAINEPAABs +EAiIIi8gB4cwJRYC9CBmFaH/AQDzA8wN53cBAP4gJhXgBgUA5GQAA4jZgADrfAEpUASAAFli1eah +/G0gBIAA9mBoHa+F1QDiFgAjhqGAAAdyCec8ECkXAoAA8kAAQXAAkgAAaYEIihCLZVjYAdSgZkDS +53wwIzDBAADywAUMIgCdAChgEMiOaIFEaYLkKGARZY/PYABzAChgEciMaIEgZ0/PdUHMYACcAACK +EOtiBSvgBIAAWNg+9UBoHa//kgAAihCLZVjYNfVAaB2v/1IAKGARyIxogSBnT5d1QZRgAGQAAIoQ +62IFK+AEgABY2DD1QGgdr/+SAACKEItlWNgn9UBoHa//UgAAAACKEOtiBSvgBIAAWNfb9UBoHa/9 +UgCKEPwfoh2gCwUAWWPp1KD1QAnMbwYFAIgwBogB+GAGFaAAGgCSEIkRFsdDF8dD5ZQADMcCgAD1 +IAUyEA+lAKeIKoKeghD3QBB6UgCdACuCnei0AAWMyYAAiWiYFPcgDQCSAJ0AKnKuZKFlK3Kt5LFh +ZOP9AADsZggliyGAAIoTKSAUqpkJCUcpJBT1IAw2UgCdAPxgaB2n5AEA7RIDKVAEgAD7AGgd4A8V +AFhM2osS/qAAFrAMRQD3oABG97sBAOzWnSWUZQAAiieNE8DA6qwgLtgEgABYR4bSoNEPwCDRD4lo +ghD3IAvAkgCdAAxYEaeIK4Ke92AMAlIAnQArgp1ksXewmppo6LQADfp2AABgANsAAAAAAAAA8iAG +Fa/7RQD7X/gVYgCdANog/EBoHaAbxQBYSOXsEgMpUASAAO0SAinYBIAAWEyE0qDRD4wSDAxHacJs +iBCIh4KI9wKkFe/LBQDpggskaIEAAAvbAat3J3xA8yAIfCIAnQCEEymJFAxEEaJFpJkphRT04Ahb +4gCdAMkziBPIj9kgbYkFAwCGCQJhJdIABFUI9qAKBGIAnQCIIJXQBogB+EAGFaACBQDRD4kwBpkB ++GAGFeACBQDRD8CwD5o06mYILfUmAADaIPxAaB2gG8UAWEi4Y/9HixHaIOu8GClgBIAAWEizY/81 +AMCgWWH1iWiIFPk/8riQD6UAY//ILSEJ/kKwFa//BQAPnwEPlgzmJBQvcQKAAP9gZh3gBgUA5rQA +Lu4CgAD/pgAOsAwVAAzdAp2x/PWmFa/5EgAAAAAAAAD/99ANoAsFAMCgWWHdiWj5P/QIkA+lAP/6 +TA2gCwUAAMCwD5g0+MEGFa/6FgDAoJqLiJAGiAH5IAYVoAIFANEP4n8MAYG5gACMEw9FFO5cCCnA +BIAA7sw2CUgEgABtyQUIAIYJAmGKE6845aoMBckBAABtqQUIIIYJAmOIIA9MDKy8LMxAnNAGiAH4 +QAYVoAIFANEPiCAuvECe0AaIAfhABhWgAgUA0Q9sEAQoIAXNjioiByuiDC2pFO6iCSVIwQAA6bEH +deMhAABlwAPI3cjr+kBoHaALBQBb4dzRDx3HJBvHJSzSYP+xBBXv+PUA+UAGFaAOBQDuJgclQCEA +AJjBm6Mp0mCZoujWYCf+gYAAKdF3iiB5q8MpIRpulArZ4P5DRB2gACIAAGiTr8CxC5sCCwtP6yUa +LZ6QAAAs0YAMqgxY14TRDwAAbBAEHMZnGsZnLMJxK6LHo8wJzBGsuymxGsDy/SGgQlANBQD9Y0Qd +4AAiAABokxAusRoP7gIODk/utRonHEUAAPpAaB2gCwUAW+Gu0Q8soW6KsAyqDFjXbWP/5ABsEDDj +IAcp2ASAAB3GTAMDQeIWJin/AoAArf8o8p4rFk7yKaYV4EmlAPkAezviAJ0AK/Kd7sZRHbAEgAD7 +YHrgEC0FAIhIKxYs/wvgABAo+QDuABUAyMEAAAkAiihCEOlCES6CCoAA+CIGFeCInQCYHy5CEi9C +E/4iRhXg7p0ALhYRi0yMTfwihhWgu50AKxYTik6LT/oixhXgqp0AKhYViUv4IuYV4ACOAAAA7uMF +AMjBAAAJAmEJAmGMTSwWFYtMKxYWiksqFhcqHDBY11AXxsEPAgAocWnrcXItKASAAPlAcWmiAJ0A +e6INKXFzC5kI+UBw42IAnQBY12P7QHV4H/VFANogWSQDJXFyIxYrpaX6oHXoUgCdAB/GCi/ycRjG +Mi5yya9f7BJOL/5CgAD/wABHcA0VAC3lGi9BK5XBLxZAHMalJkIaI0IYJ0IZLkIUK0IXKUIWKRZD +KxZCCOgB+CiGFaOuwQD6KCYVo+7hAC4WKikWAuoWACroBIAA+iAmFeAKVQD4IGYVoAsFAFljjMCw +7MaTG/AEgAD+wGgd4CkFAPuNHAWnggEA+iAmFaAKVQDoFkUsggqAAPggBhWg050AWWN/LRIq/BAC +HaAJFQD84AQGMAsFAOycOQ3QBIAACpo5DKoC9aBSmRAPJQApFjQiFi3+AAIdoAgFAPgmRhWgDAUA +7BYxJsP1AAD+JmYVoA6lAAjtOB7F8/gAIh2gAgUAAoI5Dj4BDo4588YADzA5dQDixmwYBAqAAPvA +USASAJ0AAJAEAwgbCAhDKBY1AIQEBz4Y8MBKElIAnQAGWFD4KMYVoMahACwWR/LAR6MSAJ0AiSkJ +iUEpFkjwwEeVEgCdAAbMQSwWSfLAR/tSAJ0AjCkMLEH4ACId4A8FAP8tAA/wGAUACHgBCJg5CP8C +++BN6BIAnQAfxdP+JsYV4AkFACkWNwbJUAn4EwmIAvsATYgSAJ0A/4tEBeAIBQAoFjgvFjkG31AP ++RMPmQL7IE0gEgCdAPmLhgWgCQUAKRY6KBY7BuhQCP8TCP8C++BMuBIAnQD5jGgF4A8FAC8WPCkW +PQa5UAn4EwmIAvsATGASAJ0ALRYq/4tWBeAIBQAoFj4vFj8uFlMbxfcsFlL8AAId4AwVAP2NAA7w +KQUACXkBCck5+aYADPAfBQD6YAQF8AgFAOvLOQxwBIAACf45/WYADfCJBQDrmDkMeASAABvGFgju +Ags7AfuNAA3wCYUA/WYADfAIZQD7LQAP8A1FAAqNOQ/dAg7dAi8SRi4SRysSSBjF/ef/EQ91goAA +D+4CH8YH+MAEBDEAPQD/pgAOsQ4FAPntAA87kyEA5z8YDdwCgAD/pgAOvgA9APZrAAxy5rkA99AA +FzH/AQDuvgIP/QKAAP+mAA7/rY0A/ipIFe+7jQDrqgIMzQKAAOsSNyxCAoAA7t0CD/qCgAD5BgAM +f++NAA67Ai4SNguqAisSSQ/uAg7dAi8SU+4SMy3YwoAAC90C+/AAJfP/AQDvFigvd4KAAA67Agj/ +Ai4SOJ8SLxI8Dt0CLhI6D+4CDt0CLhI+C6oCKxI0Dt0CnREtEjkNuxENuwILqgItEj0rEjsNuwIL +qgItEkUrEjHm3RAN2kKAAA27AguqAh3FyisSP8efmRD9ZgAN///1APtGAA1wDgUA+ilGFaANBQDr +Eiwq0ASAAFhI2PYKAAQ39gEA/Yt8BaANBQD8IAYVqwA9APZrAA9zk+EA6P05DMoCgADzsgAH9e4B +AOgSKi91goAA7t0CD/kCgAAJ/wLpEkotWASAAP4mqBWgKgUA+0AIANAMFQD5AAAUMJmdAOkWAi9z +AoAA6O4CCtAEgAD/xgAPf//1AP+mAA6wDiUA/CAmFeANBQBYSLX2JQgVoAwVAP5BaBXgDQUA6hJA +LVgEgAD4KCgV7/j1APggBhWv/wEA7xZLLVQCgAD7JgAMsA5FAO8WASrQBIAA+CBGFe//9QBYSKL/ +/+Id7/31AP4oiBWgDAUA7hYCLVgEgADsFgEq0ASAAPwgBhXgDBUA/AACHeAOZQBYSJX8ACIdoA0F +APgpaBWgDoUA+ChIFe//9QDpFgEtWASAAO8WACrQBIAA+CBGFa//9QBYSIguEjIs+v/sFgAtWASA +AOjvEA9pAoAA/cYADvTuHQDv7gIK0ASAAPwgRhXgDBUA/AACHe//9QD+ICYVoA6lAFhIeMDB+0Bo +HeANBQD+QOgVr//1AP4gBhXgDwUA7xYCKtAEgAD+WAAHP//1AO4WTC90AoAA/iAmFaAOxQBYSGnH +v/ogBhXvCQUAKRYBKSII+CmIFaAMFQD8AAId4A7lAPngAAT///UA+yAAFL+IgQDpiAINWASAAOgW +AirQBIAAWEhY+0BoHeAMFQD4KGgV7/r1APogBhWmAD0A9msACfANBQDzIAAB+YmxAPswABUz+fUA +6aoCCcsCgAD5BgAMcB4FAPogRhWv//UA6BYBKtAEgABYSEPAcP//4h3v/fUA8ywAB3AMBQDuFgIt +WASAAOwWASrQBIAA/CAGFeAMFQD8AAId4B4lAFhINsDB/AACHeAeRQD//+Id4AkFAPggJhXv+PUA +6RYCLVgEgADoFgAq0ASAAFhIK/2KJgWgHmUA+0BoHe/99QD8IAYV4AoFAPogRhWv//UA7BYBKtAE +gAD8ACIdoA0FAFhIHsDB/AACHeAehQD//+Id7/n1APggBhXgCAUA6RYCLVgEgADoFgEq0ASAAFhI +E+mkAAMuOYAA9MAt+RIAnQD0wDK4kgCdAPTAMnqSAJ0AJxYYJxYZ+iwAFe/+9QDutgIg6f0AAJ6z +nrSetZ62nreeuJ65nrqeu+7EPxSwIQAA7JwgJNDBAAD4JagVoIsFAOubCACZQQAA6xYwJtgFAADt +xDgUIrmAACgSK+bEnht4BIAAKRYn58Q6GpeCgAD2RgAJMYgBACgWT+IWUSq2AoAA8gACHaAIRQD4 +xgALMAg1AOYWUCywBIAAbYpxnmApElDpZgEvyASAAOcAFQf5AQAACQCKwpiZZSkSTygSUehmBilG +woAACJkCGMTCnWTomQIBEAUAAOu88C3ABIAA6WYHKcgEgADoCx4Bm8EAAOjEAAMxAQAA6EwABmEB +AADpBx4NQASAAOgsAAVRAQAA+YlWBeALBQArFhgrEicokoL4I0YVoAMFAPkwKBXgxoUA92AAQzDq +BQD7YABFMPwFAOkWGS34BIAA/WAARbAJJQAPAgAPAgAPAgBtmoT/5gYVoCyFAOgSUCtIBIAA6PYx +IzEBAADnABUBwA0AAAkAii32NOkSUSwWwoAALPY16fY2IZgFAAD9AMBCUAkVAMCQKBJPCJkRApkC +CYgCGcSLL/xA6YgCAJGBAADo9ictyASAAOIHHg1ABIAA6CwAAJDBAADiAx4F2QEAAOkMAAVRAQAA +JhInKBpA+MAAQzBDRQApQSorEibxIA2cEgCdABnD/R/EZJ5girCdYv7AphXgDIUAnGP4pgAM8Awl +AOlmBC1WAoAADKoCKmYB5wAVA0hhAAAJAIrjPAIjMIEAAIhA0w8PAgDxAA1qkgCdACkSTimQAQCZ +MiVCGSJCGPyDSBXhAD0ABSIY9CnIFeepAQAqFi79IAAD8SIBAOVSASUAwYAAKEIUGsPPCMlT6ogB +BMv5AAAJhTjrsgArUASAAPwaAAZwDkUA/gYCHeANFQBZYHQcw8D6JcgV4AlFAOwABQ1gBIAADAJh +DAJhDAJhHsRE4sPhGXwCgACeog9/AgL/Au+mACJoIQAA7QYABWBBAAAMAIqVpiJCFAsIBvlDph2j +IuEA4qQcIfARAAAvEk0Sw4LtEk4v/wKAAKL/Lvad+aAGHeACBQDRDwCIJgiYUCgWR8CQKRZG8N+4 +oxIAnQAGDFEsFkjy37i1EgCdAIgpCAxA/e0ADbCICQALiAIoFknw37hLUgCdAP/cGA2hxnEAAAAA +AAAAAPgAIh3gCAUA8irGFaPOAQD9n+AVoAIFAP0iAAwwDAUAApw4IhJWeMCJwIH4KOYVr/4yAAAA +AAAA8T/0ZFIAnQAfw3ssQhqeYIqw/MBGFeAYBQD4wGYVoAkFAJlmnGWcZw9fAp9k/UAAFTAMJQAM +qgLqZgEhmAkAAPbEABWv+TIAKRJNGsNH6BJOLM8CgACqmfMzphXgAkUA8wAGHaACBQDRDykWMvIl +phWgDhUA/iZmFaAMBQDsFjQvwASAAAq4OfgmJhWv1uIAjioODlP+JqYVr9eOAMCA+CbGFaAPBQD+ +JuYV79keAADA8P4nBhXgCQUA+CcmFe/ZTgDAkPgnRhXgCAUA+CdmFa/ZggDAgPgnhhWgDwUA/iem +Fe/ZtgAAAPwlRhXgDwUA/ifGFeAJBQD4J+YV79nWABfDQSoWKecIBQDRwQAACgJlKCKB9lBIFeAK +BQAqFi8nFiAoFh/8oAATsAhFAAh3AioSKxjDfecWUCq/goAA+OYAC7GqAQAqFk/nFlEs0ASAAPeG +KAXgCCUAbYqVIhIpnqAoElCYoecAFQtIBIAA6BIvIzEBAAD4gmgd4A8FAP1AhhXgCRUACJ846IwB +LE7CgADoFi8v/gKAAA+ZAigSTx/DpemIAglIBIAA74gCAREBAAAiFikvElGYp/9AxhXgKIUA67zw +LfgEgADopgUuQASAAO8XHgZhAQAA6KwACfgEgADvEx4FUQEAAOmMAAGbwQAAJhIw//EoDaAzhQAA +AAD9hx4FoB6lAO3DjB1YBIAA/CAGFeAKBQD6IEYVr//1AOwWASrQBIAA/AAiHaANBQBYRpP8ACId +oA0FAP+HAgWv+PUA+CAGFaH/9QDvFgEtWASAAO4WAirQBIAA/4buBeAexQBYRofAwfwAAh3gHuUA ++f/iHe4PFQD4IAYV4AgFAOgWAS1YBIAA6BYCKtAEgABYRnv5QGgd7+b6AAAAAAAA/AAiHaANBQD4 +QSgV4B6lAPtAaB3gDwUA+qBoHa/49QD4IAYVoJnBAO8WAizLgoAA+CAmFe//9QBYRmnAwfwAAh3g +HsUA///iHe/59QD4IAYV4AgFAOgWAS1YBIAA6BYCKtAEgABYRl7AwfwAAh3gHuUA///iHe/59QD4 +IAYV4AgFAOgWAS1YBIAA6BYCKtAEgABYRlP5QGgd7+RyAC1BFi5BF+tCCSEHKYAAHMM+L0IRiE4p +Qg0qQhIlFgkoFgcrFggpFgX+ICYV4AkFAPogZhWgDwUA/iAGFeAKBQD6IIYVoAsFAPogRhXgClUA ++CDGFeArhQBZYBX6v4xIUgCdACgSTvokyBXvk+UA8wAmHe+Z5QD/68QNoAMFAAAAAAAA/8JwDaAL +BQAsEibqxAAB2GEAAFhJzsck0Q8AwKX9hjQFoBuFAFlgASkSTisSJvUgJh3gAwUA/+q4Da/5RQDA +pf2GJgWgG4UAWV/4LBJO+iTIFe/5RQDyAAId7/pFAPuAJh2v6hoAAAAAAAAAHMMJiEyPTZUS+iAm +FeAKVQD4IAYVoCuFAFlf6fq/hshSAJ0AY/9MAGwQCicgBxzCQwcHQQx6EayqKKKewZX5ABaT4A41 +ACuineq0AAWWeYAAKzADFsLZ7cJkHZaWAAAlQhQFiFOYF/ygBALzheEA9QAMSZIAnQDAUC5BKhvC +NRnCN/HACLQQDyUAjjGboIggCIgRD4gCmKEYwmGZopalCOkCHsI1+UCGFeAIhQDopgMlSGEAAO4A +FQVQgQAACQCKslWJQPEgCOKSAJ0AKTABAJkyKEIZJkIYLkIaCQtH+iFGFeEAPQD4ywALOf4BAP4h +BhXhZgEAlhnmMgElgKmAAClCFAnLU+2ZAQXb+QAAC5Y4iyD+GgAGMA0VAP4GAh3gDkUAWV7hiRiL +GYwaHcIrHsJTGMK07QAFDWgEgAANAmENAmENAmHopgIt7AKAAA2dAg7dAu2mACIQIQAA4gYABXhB +AAAPAIqWpi1CFAwOBv9Dph2j3eEA7aQcIvgRAAAYwe8MchGoIv5TphXgDkUA/mAGHaACBQDRDwAA +APHf+RRSAJ0ALkIaiDGboIYgmaKepZ6n7sIFGzYCgAAPZgL3QCYVoBYFAJajDogC+UCGFaAOBQDu +pgYiqAkAAPtEABWv+44AAAxyEawi9FOmFeAPRQD+YAYd4AIFANEPAB/CixjCiylCFupBKy1YBIAA +mRWaFPpgKBWgDBUA+iDGFaAJhQD4IEYV4A7FAP4gBhWgDQUA+CAmFaAOJQBYRYaOF48U7cJ8HVgE +gAD6IMgVoAwFAJwR/CAGFeAMFQD54AAXsA0FAP/GAA9wDwUA/iBGFaAORQBYRXiVEvwAIh2gDQUA ++0BoHeAOZQD6IMgVr/n1APggBhXgCAUA+CAmFaAPBQBYRW2LFcDQ9CDIFeAeBQD7cAAVucuxAPog +RhXj//UA7BYBLVgEgAD7gAIdoAwVAOoWACrQBIAAWEVf/AAiHaANBQD+AAIdoAgFAPggBhWgDyUA +6BYBLVgEgADoFgIq0ASAAFhFVBzBjh3BuP/1rA2gBfUAAAD/9MQNoAsFANog7CQAA9hhAABYSO7H +JNEPaLMrwZZ5sRbGuvpgJh3v6aUA//Y8DaAFBQAAAAAAAPnzwh3vnuUA/mAmHa//ngD+YAYdoAIF +ANEPAABsEBIrIAcZwXMLC0HlQggt1wKAAKmqKKKeKxYZ9wAT0tBV+QAnop3mwikTk3mAACxhhOnB +jxYEMYAA8LFgDeAsBQDpAhUA0MEAAAoAii1CEO5CES4CCoAA/iIGFaDdnQCdHypCEitCE/oiRhXg +qp0AKhYRj0yITfgihhWg/50ALxYTjk4vQg/+IsYV4O6dAC4WFS1CCy0WFyocMFjSgy9hcythfP9A +BnHiAJ0Ae6IMKGF9q4j5QAXzIgCdAOsiACqPZgAA2nD8AAIdoA0FAP4AYh2gLwUAWV4aHMH9LWLF +iyApQRYppQIuQRcNuwwMuwKboIhNmKKPTJ+jK0IZLEIYLqUD/UCGFaCNBQANuwKbpYlJmab4g0gV +oAwVAPlA5hWgDjUALxIZGMErDP8RqP8u9p0sNAAtIAaLIuy7AgboBQAALSQG+kBGFeACBQDRDwAA +AAAA6QAFANDBAAAKAmEKAmGITSgWFY9MLxYWjkv+IuYVr/yaAC1BFi5BF4tJ6hYYIo6ZgAAcwcop +QhGPTShCEopOmheZEZsYnxX4IGYVoA8FAP4ghhXgCAUA+CBGFaALBQD6IMYV4AkFAJkQ+CMIFeAK +VQD4ISYV4CuFAFleoioSGNMPZq7jhTH9glIFr53lAC00AfiDKBWgDkUA+oKIFaA/BQD2gwgVoQA9 +APiDSBXgDRUA/UAEBTO64QDoZhgF2/kAAPtCAArwydEA+uBoHaFmAQD6QAgV6SkBAFldxB/BENmg +/gAIHeAONQBt6gIJAmEYwTQewZXupgIrfAKAAA8vAgj/Au+mACJoIQAA7QYABWBBAAAMAIqVpitC +FCkKYvlDph3ju+EA+0OGHeACRQAoEhkZwNMMiBGpiCKGnfJgBh2gAgUA0Q/aIOwkAAXYYQAAWEg0 +xyTRDwDacPwAAh2gDQUA/gCiHaA/hQBZXaAYwYSPIClixS5BFi6lAitBFwn/DAj/Ap+gLUIRnaMs +QhCcoilCE5mlKEISmKSPTZ+njkyepo1PnamMTpyoKEIYL0IZK6UD+UFGFaCJBQAJ/wKfq45Jnqz8 +g0gV4AtVAP1BphXgCRUALBIZHcCqDMwRrcwrxp0pNAAqIAaIIumIAgVQBQAAKiQG+EBGFaACBQDR +DwAAHMFZKBIYj02JTJkQ+iAmFeAKVQD4IEYVoCuFAFleOSoSGGatQWP+WgAAAGwQCvZgaB2nhQEA +9QAHeRAFBQAqIgLNoikwGGSQffUgBFCSAJ0AaJMHaJQawCDRDwAmPBjbYOokAAngBIAAW/o2ZKCI +Zq/kE8CCiTj3IAw4kgCdABvAgCyyrmTAfyqyreSge2Tr/QAA7TYIJQQBgAApIBSkmQkJRykkFPUg +C1ZSAJ0Aiif6gGgd4AwFAOqsICpoBIAAWEDd0qDRD9og7DQAAdhhAABb/vZj/5TmPBgpUASAAOw0 +AAtYBIAAW/4gKzAY+X/72dIAnQBj/2YsMBj5n/rCUgCdAGP/aAAAwKDA2g2dNO02CC18RgAA2iD8 +QGgdoBvFAFhHwMAg0Q8ALTEWjzguMReDOf/nYAAQf/EAHMESKGIRim6LbS9iEp8TkxiVEJUSlRSa +F/ggJhWgClUA+iCmFeAIBQD4IMYVoCuFAFld5WAAGRzBBY9tiWz4IAYV4ApVAPIgJhXgK4UAWV3e +jieD6PvCpBXvzAUA6uILJ2iBAAAM3AGsuyu8QPNABQxiAJ0AKOkUDE8Ro/qviCjlFPtgBTOiAJ0A +yWbZYO40AAIAkYAAbUkFCQCGDgJhitAPqgj7QAZ0YgCdAJrQZHBqJTQYJTQZ9GNmHe/79QD6YOYV +7/kCAMCgWVtGiTj5P/OQkgCdAGP/AiWkAC0hCf5CsBWv/wUAD58BL6QD758MD3ECgADvJBQu7gKA +AP+mAA6wDBUADN0CnaH9daYVr/mWANOg5eYLK/zOAADAg/hjBh2v/koAAAAAAAAA47sMAwGxgAAL +ThTo7AgrSASAAOhINgnQBIAA0w9tiQUJIIYKAmMLaQjuSAwGUQEAAG2JBQlAhgoCZQv5DKnJKZxA ++aAGFe/88gAqzED7oAYVr/zGAAAAAGwQGCggBeXAsRrIBIAALCAHizAlUX72gEAV4Pb1APrgAAXx +rAEA/QEABFBVCQDAINEPiCLpFhcsG0YAAC8gFh7AOCsWEfft5g2gDRUA+YB2BeKoBQAIyB2pieuS +fiewQQAAAGEEANYaBrsBJpJ/C2YCG8AzJpZ/FsAzq4gP+woIuwsGuwgmsn8mbAEmtn8pkoAA8QTr +FhMu2AqAAPsgGMDiAJ0ADMkRDpkIKZIACbsB6hYMJZkpgAAZv8AskIDtv78WYN0AAPd/fAWkzB0A +DHwJ6hYSJmANAAD1QBNaEgCdAAyvEab/KPKeKhYS/QAnw6IAnQAp8p0JnALqFgwkl2mAACvSCPdg +F7iSAJ0AKGKu0w9kgmstYq1k0mcav6iwuemmCCaTeYAA68BqGpq+AAAqMCAvCu3TD/9AGzRiAJ0A +wI54oQopCu75QCUlYgCdAPoAAh2gDwUA7xYaIfiBAADqFhkv0ASAAIugGb+XIxYliC6YHRPAWCgW +FSmSiQO7ASMgLAmIDCkhFwAzEQOZAguZAhvAUQuAhwhoFPgjxhXgCRUACJloIxIl+QAZDGIAnQDA +sCggFikK/3mBWCsWIZ0WnBSfFYoVW9egjBSPFY0WKCAHGb/Z+CLGFaKuBQAOiB0uIBYoFhCpiCiC +f/okKBXgGfUADpkM+QAgKmIAnQApEhYYv8cMmRHomQgPQgKAAAioApiTLiEHGsAzGcAx+YBeBaru +AQDqugoPdwKAAAnuAp6AiSD7QAgVoA4FAC6FBeqGAyzOAoAACXkC6YYBIdBBAADqFx4ESEEAAAkC +ayoSEeqGDyqUvgAAwIAoFh0pIBQPAgAPAgCkmQkJRykkFPUgFr5SAJ0A6BIXKi8CgADlFhQia/kA +AOUSAC7XAoAA+iNmFaeIAQAoFhgewAwMywL5wGgd4AoFAOkbHgVQBQAA68wADSfQAAApEhjuzEAv +2ASAAPkgCjFQCgUA/IJAAVAFBQAL4Ibu7AAFUAUAAH2p8SoSGdMPZaFcKxIdLhIbKRIaKBIerO6p +yeiWECdhAQAA7BYcLYqeAACMMSsSHOQyAi4TsgAAwJApFh/zgBSIUgCdAKl/IhISDCIRpiLvJp0q +kASAANEPAIvYmhz3YBgAkgCdAC8SEgz/Eab/KPKe/QAYk6IAnQAo8p2YFowW6cQABhhxgACwv/+h +BhXv9e4AAMDQGb8OwIoIuDTolggu7M4AANog/EBoHaAbxQBYRnHqJAAJ2ASAAO0SFypgBIAAWESL +0qDRDwAsEhMszQIrwQIpwQEswQWaHOuZAQ7YBIAA/T/m2qIAnQCLHNog67wSKWAEgABYRl9j/7Qr +rBjsJAAJUASAAFhGW2P/owAAAAD4IIYV4AoFAFlaFR2+7IvYjBT5f+e4kgCdAGP/dS4SHYsnLRYk +nBTl4n1l0IEAAIwU/iCmFeALJQDszEAqaASAAFg/TYwULhIZLRIkjxXlpAAHdTmAAIkf+YIGFeAI +BQD5gkYVr/pWAB6/oCsSHsCgKhYd7rsCC7/CgAD6I8YV7/iuAC8gLBi+zAMCiesAFw/4woAAL4Ym +CwCH+gAgAN/ySgAav5Mbv5H4YQgV4B8FAO8WGiH4gQAALxYZC5kB6pkCAdDBAAD4IeYV7/J6AIsd +KLAAmBvzABFGEgCdAMCQmR4psAHzIBKmEgCdAMCQix4PmBEIuwJnvLlj+zEbv3Uavq4DI4wLAGMo +ICwqoiT7AAQA0AsVAP1gAQXYirkA+WAEBbAJ9QD7IAg2YgCdACgwEPMAFB/SAJ0ACglC9SAKaJIA +nQAonP76ACId4AoFAAi6OPojphWv9GIAKyEJ9EKwFe/4BQAImAEImgwqJBTo1AMqqQKAAO7UAC3e +AoAA9WYADfAKFQAKuwKb0frVphWv8+IAAAAAAADqJAAKYASAAFvMHSsSHIwx6hYfLW8CgADtuwgN +SASAAPGf67hSAJ0AIxIf6iQACmAEgABby+ujrq5+LxISDP8Rpv/u9p0qkASAANEPAAAAAP/sLA2g +CQUA6iQACdgEgABYz+DAINEPABi+0CkSEKiZDugKCYgLGb7OqYgpgX/7LwANMAkFAAmqNfsP5B2v +78IAAAAAAAAAAPpAAAQwCxUA+R9gFaAJBQAIuTj4I6YV7/CeAAAAAAAA/CRmFaAKBQBZWYEdvliL +2IocLBIj+X/nWJIAnQD/6hgNoAkFAMCQ+CDGFe/zxgAAwMoMvDT9oQYVr+m6ABm+jCgSHsCgKhYd +CYgC+CPGFa/vPgAAAAAAAP9ipBWvyAUACKoBi7maGQrqCOqsQCXYgQAA+2AIEqIAnQApEhT1P+EG +EgCdACgSG+uICAZxAQAA+UAJ46IAnQD0n+ApEAoFAAtAhu5MAAVQBQAAfanxY/vvKhYiiDYpMQuZ +FwkOP5gYKRIVCA0/iBsJgYcJYIedFpwU+NEIHeSIAQD5IAUSogCdAMCB+CHGFa/2pgCKopka8UAG +INIAnQAKyk+IGgvDhwuihwoLSdmw+ZSIHeSIAQD5INYNoAoVAMCgiRp6lwj5QGgd4ABCAAD4ACId +oAkFAAqJOCsWIJ0WnxXsFgQs6vYAAIwy2iD6ACId4A0FAP4kCBWvzIEAWM9djBSPFY0W//TsDa/5 +9QAAwIH4I6YVr+rCAAAAAAAAAP9vAA2/+/oAjDLvFgUpUASAAPwg6BXgCwUA/iEIFa/MgQBYz0yM +FI8VjRYqEiL6QcgV7/j1APghxhWv834AAAAavrspMQ56mWn6YeQVr/zaAAAAAAAAAAD7TwAM8AoF +APggRhXkmR0A6RYBJICxgACIEQvghu7sAAVQBQAAeKnv2YCOEosZCUkMrO7rvEAncQEAAPU/1JEQ +CgUAKJz+mBOJEwsAhu4MAAVQBQAAeanvY/p1ihrxX+NeUgCdAJ0WnxX8IIYVqbsBAPokBhXv+/YA +AAAAAAAAAGwQBCYgB/l8SAWipwUAB2cdIiAWqHQkQn/BXwJVDHVNExq+jQgoEOg4AgtPAoAAqpmY +kNEPG74c4ioKBGPHAACsfAyqC6uqKaF/8y8ADPALBQALmTUppX/RDwAAbBAEG74QJiAHJCAW83wa +BeKqBQAKah0ESQqjo6uqCpkL+3wSBaACFQDoMn4iWEEAAOcyfy2BCoAA6pkICVAKgAAKiAEIdwIn +Nn8lkn+xVSWWfyMygABBBAAlGnU4DhO98QxiEaMigiACUgHRDyWdAihRAiRRASVRBQhEAXVLBMAg +0Q8A0Q8AAGwQBiogB4giH72L93sYBaGqAQDlgMVtXwKAAC/wgAa7CO6ynif43QAA/XsGBaT/HQDv +/AMtOASAAP/ABrvgDaUAK7KdZLDWKsIIKxYA90AG8JIAnQAoYq5kgJgpYq3kkJRlW/0AAOvGCCSE +uYAAKiAUpKoKCkcqJBT1QAY+UgCdACsgBP1lAARQ+vUABQxHaMIZiif6gGgd4AwFAOqsICpoBIAA +WD3T0qDRDwDAINEPKyAserHViTGLEIwy7BYBLIYiAADzIAc4UAMFAAx8EabM85OmFe/+3gAAAADq +JAAJ2ASAAOxEAAroBIAAWELb0qDRDwDAkA2uNO7GCCz7jgAA2iD8QGgdoBvFAFhEtWP/ygAAAP/8 +sA2gCwUAAAArrBjsJAAJUASAAFhErWP/rMCgWVhqHL1Bisj5X/jAkA2lAGP/vCghCfpCsBXv/AUA +DKwBDK4M/kKGHaANBQDslAMt2QKAAO2UACxGAoAA+wYADHAPFQAPiAKYkf7VphXv/A4AAADrEgAp +UASAAFvKwYwRKxIAKTIB6hYCLW8CgADtuwgNGASAAPE/+QhSAJ0A2iBbypDzQABB//xSAGwQBBO9 +ISMyiQMiDAJiFNEPAAAAbBAEIizu0Q9sEAqVEY1C5hYAKfgEgADvFgIiOCEAAPegEJxgAxUAHr16 +9XqMBe//1QD6QAQA0AkFAOkWBCmwCoAA9iBmFa/49QD41wALMAwFAInRi9CbkIrQ4+J/JsP7AACY +FpmhnNGc0IlCKIJ+nRX8gYQV4AsFAOeZDAxGQoAA+GAAQbAIFQAJiziKMpsXKUENBqoB+mBGFaAC +BQDlRQ4khZGAAIk3iJwtmRQqnDDqigwEQyEAAOqCOQaEgYAAipkqFghlIEyMGOW9HhYBsYAAGbz0 +KMAAFb0bCYgKKIIQ6jQADlgEgAD9gPAVoA01AAuAAC1BEStBDZoY/WuWDe//1QDMLYgYZY+5/GBI +FaABWgAAABm84yggAAmICiiCEOwgBylYBIAA+mBoHaANRQALgAAsQRErQQ3H/ey7iH0QBIAAjDLN +y2ABCAD//cgNoAoFAPyBpB3v/ToAjDLMw2UgQc+uHr2QfOAx2sBZNV3boPpgaB2gAgUAWD54iBaL +MooTjxWJQguqApoyn5EnhoEphoCfQiJFDtEPAAB+xxsPzAGcMo4WiRONFYhBDJkCmTKdgCTmgCjm +gZ1BihfAwOxFDS0E3gAAixSxu+sWBCWgO4AAjUL/ehwFr/niAIxAdMlQjRdk0EsbvXGJEIwSjxEY +vPbuwqAsgQqAAP/gABe/+fUA+eAAR7AIFQDq8gEsQAqAAAmIAwjuARm9BCjCoi7GoAuqAQqIAgiY +OAjuAp7y0Q8A0Q+IQA8CAA8CAHSBpupEAAvYBIAAWM9U/IBIFe/3XgBlr02JGGWfSGP/BSpBDB28 +2osRjBAMuxHtuwgOYgKAAAyqAvtgZhWv/Y4AAGwQCAZkCgNEC4tAkxAcvM/6gAsEYA0VAPl5vAXv ++PUA+kAEANADBQDjFgEq9wKAAOzuCA6oCoAA7hYDKwEKgADoVQMO0AqAAPogRhWgAwUAh7GKsJpw +iLCXgZOxk7DoQgAlk/sAACIifi6Sf+SIDAkWQoAAou6eFP3ASBXgBwUA+8DoFeACFQAIJzgF3QGK +vPlighWgAgUA7eYCJeDBAADsrAwFUyEAAOyiOQQDQYAAirnWoM8lyW8ZvFsoYAAJiAooghDsYAcr +WASAAPogiBWgDTUAC4AA1qDNIGVv1YsTjBKLsHywUmAAMQAAABm8TSggAAmICiiCEOwgBylYBIAA ++iCIFaANRQALgADzQGgdr/6aAP/+aA2gCgUAzXqMEbHM7BYBJiBTgAD6gAgV4AMFAPl5LgXv/GoA +jUB02S6MEI8SLsKgx48I/wMP7gGPExm8lxu89orxKMKiLsagC6oBCogCCJg4CO4CnvLRD9EPAAAA +AOBhBArPAoAA7JkIDtAKgACaEvggZhXv/tYAAABsEAQYvOeFICiCfxO85vivAAqyqQUACVkoo5Mt +Mn8NDV/xpiAN4AwFAB+8bRu8bMdP/2AARfAOBQD7IABF8A8VAG0IFyiyf/EBQA3h3R0ALrZ/sczk +0C9l2KEAAGP/4SkyfvhwCBWgGvUADKoMep3eKswQAKEEAPkaBJkDCYgB+HAGFa//PgApMoDJlisy +fgm7Ah28xQxcEa3M+4AGFeACBQDRD9ogW9f8H7xcLjKALTJ+D+4CDt0CH7y8DF4Rr+79wAYV4AIF +ANEPAABsEATAINEPAGwQBPd4fgWipQUABSIopiT0j+gVoBX1AONVDANDxwAAqCJ1RQ0DNAoCQgsi +LQ4iIUTRDxK8FNEPbBAE+3lOBeAJBQD6YAgVoAjVAPRAaB3v/PUA/KLGHaACBQDyo2Qdp6oBAOOk +CwUMyYAAKjAIGbyb+UAL4qIAnQAJqQqJkAqQAAAAhjP2SAADt2YBAOp0AAtYBIAAWVikG7yQJ1QM +JlQNKKEH+KDkHaAFLgAqUAf6YGgV4aoBAFkg5Bu8h/qixh2gBMoAAIwz/KLGHaAEngCKM/VACOoS +AJ0A9UAIqxIAnQBopSpopyf9RIAEUA2VAP1AB/1iAJ0ALlAgwIL4oKYdoA9FAA/uAv6kBh2gA54A +KVAgwKgKmQL4pAYd4ANeAIwz/KNkHaADNgCNM/yjRB3gAw4AKLJ9jjMvsoIpsoCo7v/f4BWgiE0A +6O4BDIIKgAD+nwAPMAglAAjuN//BAA9w//UAD+42/qRmHaACIgCPM/6hhhXgAfoAKVAiijOaW+pW +CSSBYYAALLKAsJj7gAQA0AwVAOCIGg5gCoAA6KgIBmP9AAAMiAL4oUYVoAEeAPqhRhWgAP4AAI0z +/KEEHeAA0gAYvEePMy5QB6j4KICAKQr76e4BDEeCgAD5xgAPMPjFAAjuAQ/uAv6g5h2gABoAxiq4 +M/R/85UgCNUAKVEbZZBcHLw4LbJ9KlAW+qNEFeAY9QD9gQAOcPn1APlLBg3irwUALVAH/3dsBaHd +AQAP3Ryu3y/yfwqpCgqIDHj1IS/t8a/fD5kLKZ0OKZFECcg2C4g3C4gsCLgcKFUb0Q8A0Q8Zu4gJ +yDYLiDcLiCwIuBwoVRvRDwAAC8ksCbkcKVUb0Q8AbBAMH7s/KCAEHLs+9mBoHedlAQD1AA3hEAkV +AOu73hNr+QAA/S0ADvAOJQDtFg4oBAqAAPTABWkSAJ0ALiAHLSICDgZB6WQADoueAAAqICEKG0Jl +sd0uCgUuFg394QgV52kBAPTACNISAJ0ADGoRrKovop6ZFQ8CAPfgFTnSAJ0AKqKd6hYMJQ+pgADq +JAAKWASAAFvXvYxw84APkpIAnQAqICGPHvouAA8wDXUA/6ATEKIAnQBk8CboIgcqWASAAPgeIh3g +DAUA6akBCmgEgADpJCEkUIEAAFg7eNKg0Q/AINEPACkgBfUgEtiSAJ0AaJc59SAaxBIAnQBlnz0u +smCJ4YjgmJCK4Igg+UAmFeAKBQCa4OrmASdL+wAA6JZ+J3PhAACeJyokICokIRu7zRy7LP13mgXg +CQUAKSQUKSQX+ENkHeAKhQAqJAXpJRopUASAAFvXGtogW9b9KyAhLAr+7LsBCVAEgADrJCEp2ASA +AFv/EBy64/91xAXv+wIAAACZFfegFLiSAJ0ADGoRrKouop73wBUx0gCdACqineSinWbb/QAAm/jq +Fgwtdv4AAPggphXgAyIAAAAA6iQACdgEgADsRAAK6ASAAFhAVdKg0Q8AiTAvCvz0wAp5F5kBAIsi +KiAH9WesDeGqAQAMqxGsuy2yntmg96AkAdIAnQArsp2ZFOe0AAWiaYAA6iQAClgEgABb112MMPOA +IzqSAJ0A+MAnMVIAnQDAINEPAAAAAAAA9WAJCJIAnQD1YAoBEgCdAPVgG6GSAJ0A9WAdehIAnQDH +lfoAIh2gufkA+ADiHaAOVQD5CQAPcA0FAAutOO4WDS7vPgAAY/8/AIsV2iDrvBgpYASAAFhCB2P/ +LBu6pSkgBx67MyghCPgCAAZxmQEA7brnHMwCgAAJiALpEgwuYoKAAA3MAg6IApyQ+kAIFaAvBQCf +k/sgRhXgDDUA7q4CDVYCgAAMqgKakY0pKiAUiyubmZ2YmJSIHf8gxhWgDwUA75YFLVICgAAKiAKY +ly8kFB66gAxtEa7d/bOmFa/2RgArCvELqgH6RCYdr/ZiAAAA//VwDaAKBQBknrHjngsJuASAAP4h +ZhWgDbUA/3aOBaAHSgAosXePIHj7BSmxiGWUS8Ag0Q+NK4spfbEOwOL+QEYVr/u6AAAAAAAAKArx ++UAEBDAJRQAJiAIoJCHZYPTAFBoSAJ0ADGoRrKorop73YByx0gCdACuinekWBiWUsYAAGbsu+kAI +FaAMBQCcEZkQiHAtCoH44AAEMA4VAPsAABQwDwUA+CBGFaAMBQBYPhIfukuJFhy6SgyZEf0gAESw +CDUAKJadKSAGLSAhiCIuCvH/oAQGsAoVAOqIAgTIBQAAKSQGmCL8RCYd4A5lAA7dAvxEJh3v+O4A +AADAoFlVYB+6N434HLo2iRX5v+rQkgCdAP/1vA2gCgUAwKDAugvbNPvhBhXv9YIAAACKJ4eo9UKk +Fe/IBQDrogslMIEAAAhoAahV6BYHIqkBAAD3YBYEYgCdAOmpFCpHAoAAmBini6iZKaUU+qAVu+IA +nQDJN9kw6nQAAgCZgABtSQUJAIYKAmGIGItgqLv1YBckYgCdACtmACpyACv6APjgaB3nigEAbYkH +KJAIaIERuJn0AGId4AkVAPghxhXv7YIAiJMLqgEIqgKacCsgISgK8Qi7AQ67AiskIfvgAh3v/0YA +fakEiXMpJBaKG7h3+v/mhCIAnQAqcAhkoGhooT9ooudooy9pqdmJc26T3GmT2Ygn+wQAFe/JBQD5 +YAQF8AkFAOmFFCXZAQAAm4n7AQYV7/7qAACKc/pBBB2v/r4AiHMrIAeuiSmQgCoK++q7AQzPgoAA +CbsCD7sBCLsC+kDmHe/+JgCLcwuKQvohJhWnuwEAmxpZVsQcudseurAooQeJGosZ+kGGHeANtQD4 +QaYd4P/FAPhA5B2v/UoAAPO/5KfSAJ0A+OAIFaD7xQD7wAQF8P0VAP1ABAbwCYUA+aYADv8JBQAJ +iQH3JgAMt4gBAAuIAigkB5lw/EQmHeAAGgCJcP/xRA2nmQEAjfiWFvegDPCSAJ0ADJoRrKouop73 +wA1p0gCdACuinWSxpLDenvjpFgYt65YAACtsGOokAAlgBIAAWEEZHLmvH7mu//AcDa/5RQAAAAAr +rBjsJAAJUASAAFhBEeokAAnYBIAA7EQACugEgABYPyvSoNEPAP/uDA2gCwUAABm5py8gBx26Nhu5 +7P5BBBWgrxEA9VAAFTH/AQDrqgIP/AKAAA/uAg3uAppw+EAIFaAvBQCfc/jgRhXgDzUA7Y0CDEYC +gAAPiAKYcSogFIsrjCmceJ12/uCGFaAJBQCZdZt59UAAFTALRQALqgKadykkFIgUGbmCDIgRqYgv +hp3039kREgCdAIon+oBoHeAMBQDqrCAqaASAAFg559Kg0Q8AAAAAAAAA//G0DaALBQDAcJer92Bo +He/17gAAAAAA51sMAYG5gAALRRToXAgpyASAAOhINgvQBIAA0w9tiQUJIIYKAmOKF6s55UgMBVEB +AABtiQUJQIYKAmWJGIgXC5kMqYgojED4wAYVr/SiAACKFyqsQPrABhWv9GoAwLD6Q0Qd4AIFANEP +AADAoFlUfB+5U434HLlSiRb5v/KYkgCdAP/5lA2gCwUAwLDA6g7eNP/hBhWv+VoAAAAAAAAAAGwQ +BIknKCAGK5kUKpwg7ZIJJEP9AADxZ2AN54gBAOgkBiQAcYAAwCDRDwAAAAAAAPGksA3gLKUAK9AA +fLlA/yKkFa/4BQD5ogAV788FAO+vAQJT/QAA7+4IDV8CgADoMR13cQEAAKvbK7wQ6+MsccBBAABo +QQhtqQUIAIYJAmH6QGgdoAsVAFvUgcAg0Q8AAOgkBix8lgAAY//jDe0MLNzwDEwUuMsLqzZtuQUI +AIYJAmGj2AxKDOn8QCUPEQAAsK1t2QUIIIYJAmNj/7EAAABsEASMMYgy6iQACdgEgAD84AAGMA01 +AAuAANKg0Q8AAGwQBCggBCMgB/0BAANRMwEAwCDRDxu54NMPK7F++kBoHaK7HQBY52plr+XaIOs8 +GClgBIAAWEBnwCDRD2wQBhi514ouJyAHHLlj+EDoFeAFBQD5QAckIXcBACXCfwmmEaZVhleGbiiZ +FOuSCSQGmYAAKbAU7bAVLdAEgADjtAAEgIGAANogW9T5wCDRDwAAAOnCfyaIIYAAiZcumRT8AQId +oARFAOuSCScH+YAALbAWsN3txDgNmASAABy43e8CAAvYBIAA9OAEAhIAnQAMexGsuy6ynpoQ9cAL +66IAnQAssp1kwJQtIAX4YCgVoE61AP+gBWQgCQUA7bmqHN4CgAD8YAYV54gBAAuIApgxL6AU7qAV +L4DuAABk4OgpMBbvAgAE+/0AAPUgBDCSAJ0ALzQW2iBb1M7AINEPY/8oAAAA//y0DaALBQAAHri4 +jeiaEPegCGCSAJ0ADLsRrLsosp71AAkjogCdACyynWTBG7Dfn+jqFgAue34AAIkQ2iDouYkZYASA +AOiWACPYYQAAWEARwCDRDwAAAP/8eA2gBEUA+BAiHe/9UgD//AQNoAsFANog6zQACmgEgABZDzBk +X3AqYCgrYCnsYCotVgKAAAuqAutgKy1WAoAADKoCCKoRC6oCsar6xWYdqKodAPrFRh2oqh0A+sUm +HaiqHQD6xQYdr/zGANog6zQACmgEgABZDxtkXxwrYCgsYCntYCot3gKAAAy7AuxgKy3eAoAADbsC +CLsRDLsCsbv6xWYd6LsdAPrFRh3oux0A+sUmHei7HQD6xQYd7/t2AP/6GA2gDAUA9iAmFeAKBQBZ +U5keuHCKEI3oHLhvixH5v/bokgCdAP/7vA2gDAUAAMDAwPoP3zT/wQYV7/t+AABsEAooIAT5ABz7 +kgCdAPcAHLoX1QEAKCAHCAhBmBj1oBxZEAcFABm4xYouKZJ/6zEILVZCgACqmSmQBSslCPpC0BXg +OuUA+yAgNCBIJQD5IB/0IDrVAPsgILUg/PUAiDkPAgD4IAAEsARFAAlEDAQEQfSB4BWv+YUACUQB +pIgojDToFgMiIf0AAP1jBg2kRB0A/b/AFaAKFQAMrDkqIEFYGHJkpAqLGBW4POi0AAJoEQAA9WAb +IhIAnQAMuBGliCyCnv2AHxPiAJ0AJoKdZGO/HLkRHrkRKCEilxCNOS8gQZgU+XIWBaAJRQD/4ACH +8a0BAOqZDA//AoAA/8AAR3GZAQCZFqndLuJ/+EVEHaAPdQDvJFwo2ASAAO4WBSbo8QAA7RYHIVGV +AAD9JgAMsA6FAO4kZCzOAoAA+CAGFeAMNQBZUI4nJTUnJGiKFC8hB/ogqBXgKOUA+ErmHaBZJQAp +JAX5cCQFoEklACkkdPrAAAZy20EA/0AAB/2aHQDkmREP/wKAAOj/Ag7uAoAA/YYADnC7OQDtuFkd +3UKAAAuZAgyZAhu43p9gjiCPF+1mAi1VAoAA66oCD3YCgAAOTgL+wCYVoE5FAC5mAyggQR641Spm +Bu9lCyxEAoAACYgCGbjQJ2UKLmYHCYgC6GYEIWkhAADtBx4DYIEAAAwCY/hFRBXgCwUAK2QxK2Qy ++sZmHeAKBQAqZDUqZDb6xuYdoAgFAPjGBh2gDwUA/saGHejnHQAuZC4pZC32xeYd6JkdAClkLC0g +V/rHgBWgDEUA/MdmHejdHQD8x0Yd6N0dAPzHJh3o3R0A7WQ4IVlxAABZUEPpbEAhQYEAAPhQaB2o +px0ACQSKCACI6YMeAcCBAAAqZFL2ymYd6KodAOpkUSpvAoAA/MAARviqHQAqZFDqEgYjSWEAAAhg +iAkMighAiAkIihi3vqpp6GYaJVAhAAAqZhsvIHQvlHSOMRq3//hA5BXn7gEAnjErIAcft/z2QQQV +qpkBAP8gABSw6xEA9dAAFzG7AQDumQIN5AKAAAxmAg9mAgqZApnQjCCY0p/Wl9WX1/eghhWgPgUA +LtYD/YAAFjAORQAOzALs1gEmsIEAAANghgYCZwNAhgYCZQy+EeXuCAJoEQAALeadKyAWLAr/DwIA +fLEIKiBBLBIDWBeqJiEUIyES8MLQDeAEBQAVuGvKYupSfynYBIAA/AACHaANFQBYP7QoUoDkTAEh +mAUAAAgzLnZJ29ogWDVpwCDRD4gni4j9AqQVr84FAOmCCyQwgQAADm4BrszuFgEmYQEAAPsgB7xi +AJ0A74kUKk8CgACZEquaqf8vhRT7gAdrogCdAMk1yUPZsG1JBQMAhgkCYY4SimAPAgAOqgj9QAjk +IgCdAJpg82BoHe/wQgAWt16JaJsZ9yAIgJIAnQAMiBGliC+CnrRK++AIu6IAnQAogp1kgQ6wmppo +5oQADGQ+AABgAD/qJAAKYASAAPygaB3gi0UA6zUIKdgEgABZFW7AINEPAOokAAnYBIAA/KBoHeCM +VQDsNQgqYASAAFkVZsAg0Q8AjSJl3xOLGNog67wYKWAEgABYPqbAINEP//CEDaAGBQCMImXO8ysg +Qdog67wSKWAEgABYPp7AINEP05D3AWYV7+1eAAAAAAAA68oMAYG5gAAKTBTuzAgpwASAAO5ONg3I +BIAA0w9t6QUIgIYJAmmJEao47E8MBMkBAABt+QUIoIYJAmuOEowRCu4MrswszED8wAYVr/u+AACP +ES/8QP7ABhXv+4YAwKBZUkCJaIgZ+T/3OJIAnQD/++wNoAgFAMCAwKoKmjT6wQYVr/uyAAAAAGwQ +BvhA6BWgDQUAnRAqIEEbt+onIAcKrAnpiRQuZwKAAKy7+2/oFeF3AQDrFgEkmSmAAISJ8pGwDeBI +lQAuQBLz0UAN4FtVACkgBfsgGExg/PUAKyAWKCQFfLETBQxH/Z/AFaANFQAM3DlYFydko1/AMea2 +8RvABIAA9OAXKhAKxQAMeBEGiAgvgp4pCgQDqTn54Bmb4gCdACWCnRu3DmRTCwsAh/wBgh2gCUUA +48k5CsAEgADpFgIq0ASAAG2ZAggCYee25RGNEYAALCEHHbbfDAxK7re+HmcCgAANzAKcUIog+W9m +BeAPhQD2oEYV4GtFAOtWAy1WAoAAD6oCmlH4RUQd4Ah1APhLhh2gDDUA7yRkKNgEgADuFgAhUZUA +AFlPPikhIvogKBWgXSUA/ECmHeAu5QD+SuYdoE8lAP5Ohh3gDgUALiU1LiRo/kgwFea6AQD6SAAG +PYkdAOSIEQ5mAoAA/WYADbCqOQDst5YdVUKAAAqIAv6hRB2gXUUALVULGreOC4gC7FYHL/wCgAAI +/wLot4sczQKAAAqZAplWCP8C71YEIVkhAADrBx4C0IEAAAoCY/xFRBXgCQUAKVQxKVQy+KZmHeAI +BQAoVDUoVDb4puYdoA8FAC9ULv6l5h2gDAUALFQw/KWmHeALBQD6poYd6N0dAC1ULCogV/pLgBXg +DEUA+qdmHaiqHQD6p0YdqKodAPqnJh2oqh0A6lQ4ItDxAABZTv0oLGDoJgAC0QEAAAoEiggAiAoA +iioKgPqgAEUwCQUA+KpmHeAJBQD4qkYd4AkFAPiqJh3gCQUAKVRQKCB0KFRwi0GIQBy2wfhA5BXn +uwEAm0ErIAcftr70QQQV6pkBAP8gABSw6xEA9dAAFzG7AQDumQIN7AKAAA1VAg9VAgyZApmgjCCX +ovVAhhXgPgUAnqP/QMYV4A0FAJ2lnaf9gAAWMA1FAP2GAA53iMEA7KYBJXiBAAAEYIYPAmcEQIYP +AmWOJ+8SAi3PAoAA9yAARL/NBQDvlp0ncIEAAP3ABAbwDwUA7+UEJukBAACd4f3ABhXgPGUA/Q7m +DaA6VQB6gXrKOCsgFiwK/3yxIPpIMBWgXEUAWBZewCDRD8TfLSQFLiBose7uJGgp/tYAAMAg0Q8o +JAX/9EwNoAMFABW2NIlY5xYDJI33gAAMiBGmiC+CnvoBgh3gCkUAA7o5evN7KIKdZIB3sJqaWPUA +aB3v9CIAZD+m2iBYNBNj/6PFsvpAph3v/f4AAIwiZc+g2iDsJAAD2GEAAFg9h8Ag0Q8AAAAA//NA +DaAFBQCNImXffisgQdog67wSKWAEgABYPX7AINEPwKBZUTuJWIgT+T/70JIAnQD//kgNoAgFAMCA +wMoMnDT8oQYVr/4OAAAAAGwQFJUWlxQiFh3jFgUp+ASAAOMSHSpYBIAAmxeM8OcyDiugBIAA5jAH +K2gEgAD4aDAVp8wBAKz8IjEi8iFGFa/5BQDittgWYP0AAAnMAZwZisEIiAn/AAAUMWYBAOgiCANA +YQAAmBjiIn8mYEEAAPugL/qiAJ0AwODyICYVoAsFAA7SDB62US7ifwl/Ea/uLuE1KHr//wAxWqIA +nQAVtn+WExe2xidyf+8CAAuwBIAA+6AEWqIAnQCOGQKqDI/jlxKO4q8vcvsBse6IFPcAKuCQBwUA +90AqoJIAnQDAIG0IWgpJNAYoCglZNJmABikLL5YDLpYCKIIACEQMCKoMD4kI6RYLIRAFAADomwd/ +eASAAC/sAe70AAO4BQAA7xILIQwxAAD2wwAVoAIFAPaAJ2CSAJ0A90AnIJIAnQBj/56XEgy+Cwy6 +Coqgj+OO4gKqDK8vcvsBse7AIPIiBhWgAgUA9oAE+JIAnQD8I2YV4ADGACgSEOh4CAXYBQAA6BYQ +JYwxAAD9gwAVoAsFAAy+Cwy6Coqgj+Pu4gIiDZ+AAP9c8A3gBwUAakHHbQhMBikLBi0KCkg0CFg0 +CEQMCKoMmNCekp+T740IARAFAADo2wZ/eASAALHv7vQAA7gFAADoIQxu+ASAAPbDABWgAgUAZK9/ +9p/74JIAnQBj/6wAAAAAAC0SG/QgiBWgCwUAmxArMBaGEvwjBhXg+fUAebEajBb6aDAVp8wBAP2f +wBWgDRUADNw5WBWwZKSdLRIQ6bV6Fp0JgAAatlmIGo0R7xIDIZGBAADiFhMhuSEAAOcWESGpcQAA +JRYS/iGmFebNAQD/4AAXvbgdAOn/CAxFAoAA+wYADDLtQQDoFhQvdgKAAO7MAg3dAoAA/iHmFeAO +BQD+IyYVoN05AO+1hh7tQoAADbsC/CIIFeAFVQD+IYYV4AcFAP1mAA2wAgUA6xYVJugVAAD8IuYV +4AA+ACgSF/igGIwiAJ0AwJUJWS/kkm9iqAUAACoKgAp3CC0xBx61T/ZAAQe63QEA7LWgHu8CgAAO +3QKdcIow/OBGFaBLRQCbc/1AABUwC4UAC6oCmnGJ8MCE+mgwFaGZAQAJiAwpEhXvFhYtVAKAAAqZ +Ahq2GfwiKBWhiAEAKBYaCpkCmXQpEhT/4AgV4AoFACp1Cpl2qP/othAX+PEAAC91C5h37AMeA9iB +AAALAmH4ZUQVoAwFAPzmhh2gDQUALXQ1+OWmHaAOBQD+5uYdoAsFAPrmZh3gCQUAKXQu+uXmHaAJ +BQD45gYd4AoFAPrmJh2gCwUA+uZGHeAOBQAudDYrEhL+IygVqIgdACh0LC0wV6/u/iMmFaAMRQD8 +52Yd6N0dAPznRh3o3R0A/OcmHejdHQDtdDgj0PEAAFlNfekSEyPRAQAACSCICgSKCQCICgCKLzIc +LhIX/upmHej/HQD+6kYd6P8dAP7qJh3o/x0AL3RQflkz+CNIFaBJJQApNHQZtdoqfEX6IGgd4YgB +APkGAAxwCYUA6TRlLEYCgAD4IAYVoAw1AFlNYgYtCykxNflrngWgOmUAKjRX6hIWJMgFAAApNTUo +dhaPoC92F47TLnYZjdItdhiNoCwyHIs/rcwsNhyKoCwSGA1EDKuqrNzsFhghEAUAAOo2DyEMMQAA +9sMAFaACBQActNn8I0gV4AtVAAtbLyx2GufdCAbwIQAALnYbLDB07NR0Le7GAAAvEhAF/wy2//f/ +7kFSAJ0Aih+JHimmnSswFigK/3ixCCowQSwSGVgU3Y0V/CMIFaBPdQAvNAWc1/WhJhWv5I0AntiL +MmWwzNow6xIIKeAEgABYPBzRDwAvEhCIHQX/DP/gwBXgClUACv82Df8R7xYOJCUFAACIHyiCnv8A +BYviAJ0Ahx8ncp1kf56IHP7gaB2gCgUA6AAFB+rRgABtCA/uDAAFUAUAAP9f6jxiAJ0AY//pGrSa +iqhqoXyLHyuynv9gBLviAJ0Ahx8ncp1kcIwZtJOwqPkhBhWv/r4AixPAoOoWGS3fAoAAqbubH44f +jR4t5p0rMBYsCv98sQgqMEEsEhlYFKaLFYwX7RIGKdAEgABb/XXRDwCPwycWEI7C+4AIFa/s6gAA +//+wDaACBQD//VANoAcFAP4jhhXgCgUAWU+fGrR2iqgvEhz5X/tgkgCdAP/8xA2gBwUAwHActG/A +ugurNPuBBhXv/H4AAI8Zj/SSEar/79NufXAEgADAsPPgaB2gDwUA7/wEKXAEgADo9A9l2AUAACzM +GP4AAh3gCwUArPKCIK4ictvb/7/OaqIAnQD9zwAJf+ciAAAAAAD2IGYVpAUFAAXlNv/nPA2vVQEA +KDBBKIwS+CEGFa/5NgAAAAAAAAAA//8ADaALBQBsEAoetSsvISIqIEHsRAAK6ASAAOcyACugBIAA +5iAHKygEgACVFJQT/CBGFaAIBQD8ICYV4WYBAOgWACNIYQAAmRUKqAnrIBYsRwKAAKju/8/oFaD4 +9QD5ZSYNp3cBAIwRLxYI/iEmFafMAQD9n8AVoAkVAAycOVgUYo4Z7xIIJRNZgAAUtCsMaRH0wBG6 +EgCdAKSZLZKeDwIA96AUFFIAnQAlkp1kUkr5aPYFrZ8dAP7AAAUyvkEA/WAAFbDOOQDrqgIOZUKA +AOshByzNAoAADJkCHLQc9mAAR3q7AQDqmQIN3wKAAAy7AptQG7TyhyD4oEYVoEpFAOpWAydw/QAA +++AAFT//BQD/wAQHcAiFAO4WByu+AoAACHcCl1GO4SggQftGAA1wDEUA+qDGFaF+AQDnxwwMRAKA +AAmIAvlpvAXhdwEA98AAR3APBQDvVQoncPEAAJ4WCYgCLlULmFQYtNfoVgchaSEAAO0DHgLYgQAA +CwJh/kVEFaAJBQApVDUpVDb4puYd4AgFAChULv6l5h3gDQUA/KYGHeALBQD6poYd4AoFACpUMSpU +Mi5ULfqmZh2o7h0ALlQsKiBXKyxc+qdmHaiqHQD6p0YdqKodAPqnJh2oqh0A6lQ4ItDxAABZTEwp +LGDpJgAC0QEAAAoEigkAiAoAiigiHB60tOsUAALRFQAA+KpmHaHXAQD/pgAOuIgdAPiqRh2oiB0A ++KomHaiIHQD4qgYdoA+FAP5Mph3gTiUA7iR0Lu4CgAD8IAYV4Aw1AFlMM6dbHbPBjhf+RqQV4Dhl +ACgkV4rg7OIBJ/gFAAAvJTUsVhcqVhaJ4ylWGYjiKFYYj+EvJhyO4Z4v7VYaI+AhAAAsVhsqIHQq +tHQMaRH1IABEsAiFACiWnSsgFi8K/3+xByogQYwWWBO/7BICKVAEgADtEgEp2ASAAFv8jdEPHbOZ +ithqoVoMaRGkmSuSnm64cyWSneRQb2Vb/QAAm9hlXb9gAAcsIEEszBKcFYgT/iCIFeBJdQD4QKYd +4A4FAJ44nzeYOY0iZd+y2iDrEgUpYASAAFg67tEPAP/2BA2gBQUAnxj+ISYVoAoFAFlOpx2zfYrY +jhnvEgglDjcAAP/+dA2gBQUAwFDAugurNPuhBhXv/joAAGwQBiggBA8CAPkAB6OSAJ0A9wAHYhAN +BQD6YGgd54UBAPUAB9kSAJ0AGbPTjC4pkn/qsgAuZkKAAKyZKJAFLrEI/kEEHaA85QD9AAn8J6oB +ACwKQv0ACaQgPtUA/wAKLSBPdQAoIAXss/kUuZEAAP8AClxv9gUA/2hqBaBJlQD5AAwMYA+FAC0k +aC0kZi0lNS8kZC8kZ/5FRB2gKOUAKCRX/kOIFa+JBQD4TKYd4AgVAPhLhh2gTxUA7yR0JwA5gAAo +JGj7YABEsFglACgkBYi7KZw/BpkBeMMqiZAJCUdpkSIqcQN4oxzaIOxEAAroBIAA/2DIFeAOBQBb +/urAINEPwCDRD9og7EQACugEgAD/YMgV4A4FAFv9JsAg0Q8AAIgni4j9AqQVr84FAOmCCyQwgQAA +Dm4B7swICj8CgADuFgAmYQEAAPsgCIxiAJ0AL4kUq3qn/y+FFPuACHuiAJ0AyTfptAACAKmAANgw +bUkFCACGCQJhKmIAB6oI/UAJzCIAnQD6wAYVr/qGANog/KBoHeCMRQDstQgqYASAAFkRMMAg0Q/a +IPyAaB2gjVUA7bUIKugEgABZESrAINEPiCcuiRRk4FWIiY2LfcNuqr8v/D8G/wEv8gAPD0dp8V0q +kTV9o1fqJAAKYASAAO6CByroBIAA74IJLFgEgABb/qnAINEPAOokAAnYBIAA7EQACugEgABb++HA +INEPAI3b/YNWDeAIBQCqvCzMPwbMAYzADAxHacEFLpE1feun6iQACmAEgADuggcq6ASAAO+CCSxY +BIAAW/zWwCDRDwDbkP0BZhXv9x4AAAAAAAAA68oMAYG5gAAKTBTvzAgpwASAAO9PNg3IBIAA0w9t ++QUIAIYJAmGJEKo47E4MBMkBAABt6QUIIIYJAmOMEAp+DK7MLMxA/MAGFa/10gCPEC/8QP7ABhXv +9Z4AAABsEBYjFh8iFiArEiCMMCQWFC2xFflh6BWnzAEA/GAAQ7/6BQDusAcjuP0AAAp3ASuyHPoj +BhXh7gEALhYZ6xYaJCPhgAAsEiCOcysSHyzBExOzmPthaBXgCQUA85lQDevuAQCbUZlQLjJkKBIg +DcoMKhYbIoEQL4ESJoERKIIW6BYAL/6CgACv7i4WHCoymu2zFhlgBIAA8E8QDe/19QD7QGgd4A4F +AG0pIIJzj3Ki4n4rAbH/BfgBDSkB6bYBJ3BDAADotgAl2CEAAPeABmqiAJ0AbQitiXTTD9MP+WAA +BfAOFQD7zQAN9pkNAPsgAETwDgUA5JChbJ0CgAAKywuCd492ouLuKwZ2YAUAALH/BfgBDSkBmbHo +tgAncEMAAOPj3HXYIQAAdsFxiXX5YAAF8A4VAPvNAA32mQ0A+yAARPAOBQDkkDRsnQKAAArLC4J5 +L3IIDwIAouINKQGZse4rB3ZgBQAAL/wBBfgB6LYAJ3BDAADj49d12CEAAObLHHO4YQAAY/9LAAAA +AAD+1DwN4AwFAGAABAAAdsmNH7JdHrLjE7JZFLJhLBIgG7J/F7JXKcEjKBIcLMBA/TAAFLACpQD5 +AABEcA0FAOgWHC4YdgAAKBIYCGYMLBIaKRIbCswL7BYeJJv5gAAoEhkClTYFXAnjhAAOZ8KAAPUA +FEoSAJ0ADIsRp7sosp79AByzogCdACKyne0kAAEVAYAAKxIbKRIgBbsMKJIcIpEVKpEjCFgKpSKl +qiKVFRKyWyqVIyiWHOIABQ7IBIAAbckCCQJhIxYS6xYbIpPpgAAlFhctFiGJECoSHPOgaB3gAgUA +7BYiLM6CgAD4I6YV4AcFAG1ZrCsSHZ4w/CPIFaVaHQD0YGYV4AglAJgyJRIgKBIfrHyJUPRghhWg +TQUAnTWbN/8mAA7wC2UA7TYGLM4CgAALmQKZMYiLmDj0oegV4AkFAPhhZhXgCAUA6DYKKegEgADl +NgkpWASAAOYrI3GooQAAj8GOwO/WDSXYBQAA7tYMJughAADl0RF2YCEAAHaz4MDw//98DaAOBQAe +soUfsf3nfCAhEBEAAOqsQCGZgQAALRIhKxIXF7H28iJIFeAMBQAMuzUsEiIuEhsMPxGn/+z2nS8E +/gAALhIUKRIgC7IJ7BIAKRbCgADzoABBMAoFACqVFSqVE+qWHC5mgoAAnOAskSH7IiQVoAgVAPko +Bh2gWBUAKJQFDKoMKpUh0Q8oEiCbUZlQLYEU4oUQIygNAAD3AiQdolUdAOUWGy6afgAAC8QUs0QE +JBTqEiAiIA0AAOwUAApYBIAAWAfqKBIgKhYcJIUUKRIcKhIg5aUTLOUGAADAINEP7HIBJwChgAD/ +gABGMAYVAP2eACWgABoAwGBqwRP9YAAGsA8VAP3tAA727A0Art2tZoxwDAxH7Mz/KxAEgAD3n/sw +kgCdAN1wiNQPAgAPAgD5YAAHMA8VAP/tAA82iA0A6O4IBmP9AADuZggGAOGAAI7VDgpL++0ADTbu +DQAOqgjqZggGY/0AAO3cGCYO8wAAY/8UGrGgiqj3QBYgkgCdAAw7Eae7KLKe/QAW66IAnQApsp1k +ktQbsZewqJi47ZQADOtGAADS0NEPjHMuEiAMDEv9weYVr+3yAAAAAAAAAAD/+bQNoAsFACwSICgS +H4zPiIcLAIf4IQAV4AUVAPytAA48iB0A+YAARjAFRQBtWgIJAmEszP8MDEHlwJxgyCEAAOlsCwzY +BIAA/CKmFaAINQDoaDQNYASAAPgjRhWgCEUAbYonKRIVebsNhcH5gAgV4ABCAAAAAAD0AAId4AkF +AJW5mbjszAgl2CEAAGAAsAArEiAoEhSCEC21FS21E/1jhhXgDxUAL7RALrEh/WIkFaBaFQDqtAUp +FoKAAJKADswM7LUhKpAEgADRDwAAAAAA//G0DaACBQAAscjsFhMkKTuAAMCw+YACAvAIRQDsiAwN +YASAAG2JMXa7DInAiMH4IsYVoAA+AADAkPgixhXgCQUA6VYIJdgFAADoEhYmYCEAAOhWCSKoIQAA +LBITwLMMuwx2uwf6I0YV4AAeACYWGikSGSkWEvUgCEoSAJ0ADJsRp7sssp73gAtzUgCdACKynfhA +aB3gAqUA5ZQABIphgACekCkSHCmcwAlZFJlTKRIg+CAIFaALJQCbUoyQ9KCGFaBLBQDrVgUsRoKA +AJhXD8sC+qDGFeAIZQDrEh8uZgKAAAjMApxRi7v6oQYV4AgFAOmSDyLgwQAA6VYJINiBAAD4oWYV +oAkFAPihRhXgCFUAbYoFCwCIDACKKBIS6xIaLEcCgAD3AABEcAxlACyGnXtrB/AAKA2gBgUAKRIa +CWYM6BIgI2ANAAD4I0gV4swdACwWGymGHCmFIS2EQP0CZB2v604ALBIgK8ESKjJkLMIW7BYALd6C +gACrqvojhhWv8v4AjDjqFiMmDd+AACsSEgy7Eae7KLKe9wAEI1IAnQApsp1kkHuwyPhhBhWv+7YA +/CRGFaAKBQBZTBMasOoesXKKqB+w6iwSIvlf6RiSAJ0A//TgDaAJBQDAkBiw4gKrNPsBBhXv9KIA +KhIg7aUTLJAEgADRDwAA//pUDaACBQDAoFlMAR6xYIw4H7DYKhIj+Z/7yJANBQD/+fQNoAkFAMCQ +Ass0+mEGFe/5wgAAAABsEAYXsbeGMPrriBWgDQUA7iAHKSgEgAD4QegVr/IFAP9ARBXnZgEA/UCE +FaHuAQDroQUkDmGAAImg7/z/JmP9AADvpQIuZwKAAOyZCA3fAoAA+y8ADPAA1gAroQUsoQTpogAl +2AUAAPmf4BWvuwEA66UFLEcCgAD7gAjkYgCdAOiZCA3/AoAAD5kMCQCHDb1g6QAHBfMXgAAtcqEo +oQX+9EgV4AkVAClVE+lVFCxGQoAAqLgoVRLo/wgMRoKAAOjdCA9gBIAA71YWJopRgAAbsJoM6RH1 +wAeSEgCdAKuZKpKe90ALk1IAnQApkp3qlAAEiUmAABmxGPZgAEc1jR0A6KYDJ2j9AAD5QAYV4A4l +AJ6iAt0BHrCJErCQ6VIAL/6CgAD/QOYV4EgFAJilkqT/JgAPMAJlAO6mBizOAoAAApkCmaGIO5io +iV/5QSYV4A4FAJ6rnqqI05itjtKerIjTGbDt7dICJHBDAAB46zQJ6QHppg8mwAUAAJiu70YALkcC +gACriPMTphWgWRUA6VQFLRAEgADRDwAtpQX/+4QNoAsFABmw3J2uCekBma/vRgAuRwKAAKuI8xOm +FaBZFQDpVAUtEASAANEPAAAesFqK6PdABGiSAJ0ADMkRq5kokp73AAVTUgCdACmSneSQoWVD/QAA +mOjqlAAM9+YAAGAAGaY5KZw/ApkBiZMJCUv4oeYV7/ieAMAg0Q8AJlEUI1ESwEDqFgMjAVGAAOpy +XCnYBIAA/AACHaANFQBYOHIocl2KE+RMASGYBQAACDMudknZ0qDRDwAAAAD/+kQNoAkFAACfEJ0R +/CBGFaAKBQBZS1oesDEbsDGNEYrojxCMEvlf+rCSAJ0A//2sDaAJBQDAkMCKCKg0+cEGFa/9cgAA +AABsEBooIATuIAcpOASAAPkAKFOSAJ0A9wAoEhAPFQAjFin04AAEce4BAO4WKCRj+QAA7Pw5DBXY +AACIJ4uI/QKkFa/CBQDpggskaIEAAALSAeLMCAp/AoAA5okUJmEBAAD7ICvkYgCdAAv6CA9mCCaF +FPuAK9uiAJ0AyTvJSem0AAnABIAAbUkFCACGCQJhitAPAgAPAgCvqv1ALeQiAJ0AKtYA+iUmFeAM +FQAYsGSJfiiCf+4SKSzOQoAAqYgogAUu4Qj+4QQdoD3lAP0AJ4xgSSUA+QAnTGA61QD7ACrdIEuV +AC1wBfugK/Rg/vUAK3AWfrELKnBBWBAcZKWVLXAFInAHxfH/q+YN4SIBAMWEeNFVKhIpGbB+iqt6 +kyIrEimMsAwMR6y7+2fgFe/8BQAMuwErsgALC0f1YCKgkgCdAOsSKSvQBIAA7RwIKOAEgABb/Q5k +pE8uEimPEP/BJhXgDQUAnegtcAXyJOYVoFZFAPegCwQgAxUAkxQWsAclcQgtEikbsLIUsLAar/n/ +YVwF4AIFAJIXkhaSGJIeIhYSIhYUIhYaLxYV+iQGFa/49QAoFhsoFiEkFhP6IeYV4A41AP4hRhWg +G6UAKxYc9CToFaAOJQD+ISYVoBi1APgiBhWgHuUALhYWiduM2CwWGAZVAo3ZlR38IyYV71WNAOUW +DCzSAoAA+iPmFaiZHQApFh70gBoiEgCdAB2voAxMEa3ML8KewG928wIiwp1kI3cfr6KNcO6vnxDI +QQAA9ODkFaAWhQD9oAARsAU1APRmAAnwJQUA5a+WGoIKgAD1QAACMApVAO7dAgonAoAA5UQCCUAE +gADlr5AekASAAG2qN5SAk4GfgpaDkoSKlYuTjJCNlO6SAiTIYQAAmof7ASYV4K2dAPWGAA3wzp0A +m4WahuyGCCRAwQAAKhInG6930w8MqhH7QABFcAn1APlTphXgWEUAKHQFKxIn9WASKhIAnQAdr24M +vBGtzC3CnvegHJPSAJ0AIsKdZCKtGbBILnEHH7BEE69q9iUoFaruAQDscSIvdwKAAAPuAp4ginD7 +Xs4F4F2FAPxAZhXgA3UA6yYCLVYCgAADqgKaIYhnKBYkhmb2JKYVoAoFACoWJvzgsBXviJUA+Oym +HaAm5QAmdFcqdTUqdGf+5UQd4AuFAPrshh3gDlUALnRcK3BBLnBo+uzGHaBPJQAvdHTrugkHcAUA +AO50aC1XAoAAqpn5L+gV4F4FAH7RDsT+f9EJxWb3oBbNIgCdAAkORvlgABay+UEA+gkCHe2MHQDr +JQssRQKAAP3gABewCwUA/8YAD3D5OQDrJQov/UKAAAj/Ag/uAhiwDOywDR59AoAAnCcO3QIesAkI +/wKfJg7dAu0mBCPRIQAA6gceAUCBAAAIAmP65UQVoAgFAPhGhh2gDQUALSQ3+kXmHeAJBQApJDP6 +RaYdoAwFAPxGRh2gDwUA/kYGHeAOBQD+RiYdoA8FAP5Gph3gDgUA/kbGHaAMBQD8RcYdqKodACok +LClwV/rrgBXgDEUA0w/4R2Yd6JkdAPhHRh3omR0A+EcmHeiZHQDpJDghUPEAAFlHdih8YOgmAAFJ +AQAACQSKCACICQCKKHIcKixU+i/gFeAMxQD4SmYdqIgdAPhKRh2oiB0A+EomHaiIHQDoJFAl2EUA +AFlHZStwdCskZCoSKBuu6QyqEauqI6adK3AWKQr/ebEK+ugwFaBMhQBYDwHExfzgph2gAgUA0Q/A +INEPHa7djdj3oAwYkgCdACwSJx6u2gzMEa7MLsKe98AMO9IAnQAiwp1kIX4frtKw3p74ZS2kYABP +AAAdrs+N2PegC7iSAJ0ALBInHq7MDMwRrswuwp7A///AC8viAJ0AIsKdZCFwH67EsN7/4QYVr/J+ +AOsSKSvQBIAA7RwIKOAEgABb/e9lq6+IcmWPcCsSKNpw67wYK+AEgABYNiDAINEPACsSKdpw/KBo +HeCMRQDstQgqYASAAFkM08Ag0Q8AAAAA+yBoHeANBQD9AWYV7+reAOvKDAGBsYAACkwU7swIKcAE +gADuTjYNyASAANMPbekFCECGCQJlCjgI7E4MAUkBAABt6QUIYIYJAmcK+AyoKCiMQPmgBhWv6bYA +KxIp2nD8gGgdoIlVAOm1CCroBIAAWQy1wCDRDwAAKixA+6AGFa/pEgAAAAAAAOp0AAnYBIAA7EQA +CugEgABY4DPAINEPAP/xxA2gAgUAxdL84KYd7/SWAACOcmXugytwQdpw67wSK+AEgABYNeXAINEP +wKBZSaIdrniN2Pm/85iSAJ0A//o4DaACBQDAIB+uc8DqDt40/+EGFa/58gDaIFlJlx2ubY3Y+b/z ++JIAnQD/7PQNoAIFAMAgH65owOoO3jT/4QYVr+yuAGwQCsCl/V6iBadlAQD838AV4AkVAP0tAA7w +OwUAWUv+911IBeAFFQDpIhAjFHUAAIw3LckU1jDpFgMmogmAAPOBKBXgBNYAAAAuIhPpFgMnZDyA +APAB1A2gCwUAAAAAKnKwKqJZL6ECZP/oWCsYHK5LLMJ7K3KqqszqIAcuZkKAAKy7KbAHKCAM+gIA +BTD8tQDsmQENV4KAAPsmAAyw/MUADJwBKbQHLSAH+WGGHa+flQAvtAXzYUYVoA4FAJ64/2EmFaHd +AQANzAIstAfmtAAFodmAAI+3jPj94qQV78gFAOryCyfwgQAACOgBqN3oFgQm6QEAAP1AIVQiAJ0A +6fkUKkcCgACYFayKqJkp9RT7oCFLogCdAMk56cQAAgC5gABtSQUDAIYJAmGPFYrgDwIAD6oI/UAi +pGIAnQCa4NPAKbIACJwRDEwCLDYBKnKdCpkM6jEIJMgFAAD7YQQdq4kBAPMc4A3mqR0A9UgAFTWZ +AQAKmQIptg4rIgIqIAcPAgDprgQdmaYAAAoKQeoWCC1XAoAAqaosop73gBl60gCdACqine6uChUY +EYAAJCITjCkPAgD6QUgV4ERBAA5ECiRCgCoWAg8CAOy7DAIgwQAA9WAUg6IAnQArIBYoCv94sRL6 +QPAVoAwFAFgOHu6t+BUXKYAAKCEHGa3sCAhK764YHEcCgAAJiAKJEhyuFishGpiQiiAdrej9IEYV +4AhVAOyqAg1uAoAACN0CnZEoIhOalJuW+AgABrKIUQDu3AoMRYKAAOzCgC7ugoAACN0CD90CnZcM +TAzslgUmYEEAAJyTKyIWjCmku6TMnCn6QsYV7+oFAPsgEhQiAJ0AHK61/GEEFeAKVQD+wQQVoDsF +AFlLYi4wKC0wKRyur/3AABcwClUA/6YADrA7BQBZS1skcrD9XVQFoApVAPxgyBXgOwUA/mDoFaAv +BQDtFgcvggqAAP4gxhWg3Z0AWUtPKHJO8RogDeAMBQCWES5CWQ8CACfhBIvg9v/gFa+sOQDq5QUr +TwKAAOm5CA1/AoAAD58MDyCH/8BkFebcAQAN1WL9rMAXVv8BAPrABIUiAJ0AZPCI/eAELWIAnQAJ +qhGq2v7gABM1ih0A5rYIDEeCgAD4zwALP/n1APbfgBWkqgEA6GIALQEKgADq4QUq2AqAAAm5AwmI +AQi7Aptg+8AIFeAAcgCwdgxpEam5DKgRCJgMCECHwNAN1WRu3ozn4QQlUAUAAAoKTyrlBXep1voA +Ah2gDQUA/cCkHe//LgAWrXkfrb3mYnstRkKAAKjYL/KqqGYJZhGm/4b3LmkU7fIKJwGJgACLaXLZ +Y44XirKNsw6qDI4W+AAiHeAHBQAKlzj/rwAOsAgFAA2YOHhwP2AAMgDzpx4NoAsFAPwg6BXgCgUA +iaKKow2ZDI0W+AAiHaAGBQAJhjj9TwANcAcFAAqHOHdgCY4R/+AKrSAtBQAfrZov8k6xzP+f9KPi +AJ0A9iAoFaAAogAAAAAA6iQAClgEgABYDSnurVcVaymAAGAAPgAA//PgDaADBQAcrjb+IMgV4ApV +AP4g6BWgOwUAWUrgwKX9XGIFoDsFAFlK3GAAYYsY2iDrvBgpYASAAFg0oIxoysjA0O0WAC6QBIAA +0Q8AAAD/81ANoAoFAACLGNog67wSKWAEgABYNJVj/9GOLx+uHu9mCyNggQAA7OYAIWjhAACdaJ5p +/EHmFaACBQDRDwAA6iQAC1gEgAD8YGgdoA0FAFg1GMAg0Q8AwDCT+/NAaB3v8FIAAAAAAP/w9A2v +6aUA7N0MAYG5gAANTxTo/AgpyASAAOhINg5QBIAA0w9tiQUJYIYKAmeKFK0570gMBVEBAABtiQUJ +gIYKAmmIFY8UDYgMqP8v/ED/wAYV7+7eAACJFCmcQPnABhXv7qYAHK3znxkqsgIusgP7oAgA0DsF +APoAoh2g2p0AWUqYhBmGERyt7PyACBXgClUA/oCwFaA7BQBZSpJkTsWLEik8IPtkABXgDDUAbcoF +CaCGCwJrjRIt0CDM2o8SxOL/5AYdoE0lAI4S/Vu4BaAKVQD/xDAVoDsFAFlKgooTiBIqohL7B2Yd +qKodAPsHRh2oqh0A+wcmHaiqHQAqhDgpIhf5B+Yd6JkdAPkHxh3omR0A+QemHeiZHQAphDyObhyt +yPoGAh3gDQUA/wZmHaj+HQD/BkYd6P8dAP8GJh3o/x0A/wYGHeAKVQBZSmaOEolOHKzS+cbmHeiZ +HQD5xsYd6JkdAPnGph3omR0AKeQ0/IHoFeAPBQAv5CT9yGYd4AgFACjkJ/nEZh2gCAUA6OQmLEgE +gAD5xEYd6N0dAP3IRh3gCAUA+cSmHajdHQD9yCYd6N0dAO3kQCdZIQAA/AAKFaAJBQCxmeuDHgyP +6AAALCAHDAxBHayiDMwR/YAARnALVQArxp0rIBYqCv96sQr6QPAVoDwFAFgMuGRtioloZJ2FjmnA +0J1rmeCPaJ7xnWj8wSYV4AIFANEPAGwQBCogBP1A4AvQGHUAa6QKeKEfwCDRDwAAAADqJAAJ2ASA +AOxEAAroBIAAWN7uwCDRDwDqJAAJ2ASAAOxEAAroBIAAW/4awCDRDwBsEAbEcvlatAXgBgUA9iAG +FaAFNQD4RUQd4AsVAPpisBWgKOUA6CRXIgMhgAD0gATIkgCdAGhCQPSAByGSAJ0ACmsUe1AFLDAU +LCRgKixl7a1jGNgEgAD8IAYV4Aw1AFlE3yYkaCYkaSYlNSYmHCckdB6sly4lN9EPwIb4S4YdoA+F +AP5Mhh3v/uYAAAApMDDBotMPepFo6yRkIVF1AAD8AGIdoCslAOskXCHYdQAAWUTLKixh+mMgFeAM +NQBZRMcqMBVj/3kAAAAAKixd+mOgFeAsBQD8TIYdoA0lAO0kXCrgBIAAWUS9LjAYf+fRKixh+mMg +FeAMNQBZRLhj/8AAH6ynKDEcL/J/CYgRqP8o8TYoNRyP8P5DxhXv/fYAAADorRsa4ASAAPpMhh3g +KTUA6SRcIVGVAADoFgAo2ASAAFlEpiYkaCYkaSYlNSYmHCckdNEPbBAI/B/iHeAMBQD2QggV54UB +AOiCCmmoBIAAYAE0AAAAKiIT66xxFWQ4gAD5gGgd4AHyAAAAKrKJKqJZLqECZO/pWCjmHKwZG6xo +LMJ7KbKDqsrsIActVkKAAKqZKpAHKCAM/AIABjD+tQDuqgEOZ4KAAP1GAA0w/sUADq4BKpQHLyAH ++SGGHa+VlQAllAXzIUYVoAwFAJyY/SEmFaH/AQAP7gL/IOYdoP31AOWUAASZYYAAj5eK+C7xFfnh +aBWvyQUA6BYCJ7CBAAAJaQGp7ukWASdxAQAA+wAYxCIAnQDo+RQqTwKAAJkTqpupiCj1FPvAGLvi +AJ0AyTfZMO+kAAIAmYAAbUkFCQCGDwJhjxOLYK+7/2AaRCIAnQCbYBusMolQCJ8RD08Cn6EusnYO +mQyxmf9BBBWriQEA7lUIJBYpgAAJahT1SAAVNZkBAAqZApleKyICKSAH7qvSHY7mAAAJCUHpFgQs +zwKAAA6ZCC+SnvfgETLSAJ0AJJKd6KvXEg1JgAAmIhMrIgn6QUgVoGZBAAhmCiZigOuqDAMwwQAA +90AM+6IAnQArIBbTD32xGvpA8BWgDAUAWAvu/B/iHeAMBQDuq7gVDumAAC8hBxirug8PSgz/EQj/ +Ap9AiSAbq7n+Q0QV4ApVAOtGAizGAoAACogCGqvfmEEoIhMbq7efRvsmAAyw+EEA++ABBfKIUQDm +iBEP/oKAAAj/AiuygBir1JlEC2sMCP8Cm0XvRgcl2EEAAJtDKiIWiymmqga7CPpBJhXv6QUA+kLG +FaAINQD4gAckYApVAOtMICHIwQAAbYoFCSCGCwJjK0Ag6XISJYeZgAD4h2Yd6PkdAP6HRh3o/x0A +/ocmHej/HQAvRDj8hOYdqLwdAPqExh3oix0A+ISmHaiIHQAoRCQvIhf+h+Yd6P8dAP6Hxh3o/x0A +/oemHej/HQAvRDyJXixEIytEIviGZh3omR0A+IZGHeiZHQD4hiYd6JkdAClEMCggBwgIQQyIEQ6I +CCqGnSsgFn2xDPpA8BWgPAUAWAuFwMDKXIlYilnxImAN4AIFAJxbmaCLWJqxnFicWdEPixTaIOu8 +GClgBIAAWDLEjFhkwHjAINEPAADqJAALWASAAFgLNfwf4h3gDAUA7qtTFXJxgABj/9YAAPiHZh3v +iBUA+IQmHaAPFQD+hAYd6LkdAPqHRh3oux0A+ocmHei7HQDrRDgk+AUAAP7iRhXv++IA//d0DaAE +BQAAixTaIOu8EilgBIAAWDKlY/+Bji8frDTvVgsi4IEAAOzmACFo4QAAnVieWfxB5hWgAgUA0Q8A +AOokAAzYBIAA/GBoHaCN5QBYMyjAINEPAJz7+iBIFa/0ngAAAAAAAAD/9SQNr+mlAIkR6u8MAYHh +gAD6YGgd5I8dAOgWACRAIQAA6Eg2DXAEgABtiQULQIYOAmUoEgAPOwjoSAwE8QEAAG2JBQtghg4C +Z4sTD7sMq5srvED6wAYV7/MKAI4RLuxA/sAGFa/y1gAAAAAAAAAAbBAIKiAE/UDgC9AYdQBrpAZ4 +oRvAINEP6iQACdgEgADsRAAK6ASAAFjgNcAg0Q8A/B/iHeAMBQD2QggV56UBAOiiCWmoBIAAYAEz +AAAuIhPrq0kXZDiAAPmAaB3gAfIAAAAqsokqolkvoQJk/+lYJ74cqvEbq0AswnspsoOqyuwgBy1W +QoAAqpkqkAcoIAz8AgAGMP61AO6qAQ5ngoAA/UYADTD+xQAOrgEqlAcvIAf5IYYdr5WVACWUBfMh +RhWgDAUAnJj9ISYVof8BAA/uAv8g5h2g/fUA5ZQABJmhgACPl4r4LvEV+eFoFa/JBQDoFgInsIEA +AAlpAanu6RYBJ3EBAAD7ABkEIgCdAOj5FCpPAoAAmROqm6mIKPUU+8AY++IAnQDJN9kw76QAAgCZ +gABtSQUJAIYPAmGPE4tgr7v/YBqEIgCdAJtgG6sKiVAInxEPTwKfoS6ydg6ZDLGZ/0EEFauJAQDu +VQgkFmmAAAlqFPVIABU1mQEACpkCmV6LIikgB+6qqx2SBgAACQlB6RYELM8CgAAOmQgvkp734BJ6 +0gCdACSSneiqsBIQaYAAJiITKyIJ+kFIFaBmQQAIZgomYoDrqgwDMMEAAPdADIOiAJ0AKyAWfbEa ++kDwFaAMBQBYCsf8H+Id4AwFAO6qkBUQQYAALyEHGKqTDw9KDP8RCP8CL0YAKSIAG6qR/kNEFeAK +VQDrRgIsxgKAAAqIAhqquChGASgiExuqj59G+yYADLD4QQD74AEF8ohRAOaIEQ/+goAACP8CK7KA +GKqsmUQLawwI/wKbRe9GByXYQQAAm0MqIhaLKaaqBrsI+kEmFe/pBQD6QsYVoAg1APiACjxgClUA +60wgIcjBAABtigUJIIYLAmMrQCDpchIlhxmAAPiHZh3o+R0A/odGHej/HQD+hyYd6P8dAC9EOPyE +5h2ovB0A+oTGHeiLHQD4hKYdqIgdAChEJC8iF/6H5h3o/x0A/ofGHej/HQD+h6Yd6P8dAC9EPIle +LEQjK0Qi+IZmHeiZHQD4hkYd6JkdAPiGJh3omR0AKUQwKCAHCAhBDIgRDogIKoadKyAWfbEP+kDw +FaA8BQABEQJYClzAwGRc04lYiln9LMAN4AIFAJxbmaCLWJqxnFicWdEPAAAAAAAA6iQAC1gEgABY +ChH8H+Id4AwFAO6qLxVy6YAAYABJAAD4h2Yd74gVAPiEJh2gDxUA/oQGHei5HQD6h0Yd6LsdAPqH +Jh3oux0A60Q4JPgFAAD+4kYV7/wiAACLFNog67wYKWAEgABYMYOMWGXMRo8vGKsS6FYLIuiBAADt +9gAhcOEAAJ5Yn1n8QeYV4AIFANEP//bQDaAEBQAAixTaIOu8EilgBIAAWDFzY/+8AAAAAADqJAAM +2ASAAPxgaB2gjeUAWDH+wCDRDwCc+/ogSBWv9H4AAAAAAAAA//UEDa/ppQCJEervDAGB4YAA+mBo +HeSPHQDoFgAkQCEAAOhINg1wBIAAbYkFC0CGDgJlKBIADzsI6EgMBPEBAABtiQULYIYOAmeLEw+7 +DKubK7xA+sAGFe/y6gCOES7sQP7ABhWv8rYAAAAAbBAGGarM4pJdKXAEgADtRAAJ4ASAAPJgCLKg +DwUAJZJclRArUQTlUgAmI/0AAPJPAAnwCBUA7LsRDhAEgAD1YABF8AA6ALH/8+AHJGIAnQAPVhQO +ZhEGtgwmbf/2x+gVpK8BAAChBACJGulmAQ0CCoAA8kAgFaFmnQD+3IwN4AkFAOjBPGewBQAAbUku +BlcUDncRB7cMJ33/9ufoFeRWAQAAUQQAihrqdwEKggqAAAcHGeVwBmMwBQAAsZkJygxpoYNkwEsn +EgAPAgAqcQQp+v/sqhEPmASAAG3JNPLgCBWlQx0A/pAAEjRTAQDgUQQBmAUAAOoiCAwoCoAABCIM +6VIDASPxAACGQAJiAQJSApJAEqqILOUTKCKiL+USIiKhqPiY0OjmFi+ugoAApSLRDxmqgSmSoizl +Ey/lEqn5mdD5wsYV4AIFANEPAABsEAySHYIwjB2UEfuCZBXnIgEA8mAAQT/5BQDkwAchEP0AAAki +AYoj7MEVKcAEgAD8IEYVoUQBAPlU1gXrqgEA6hYMLaBmAACLIee0AAUcUYAAqrv7fgAl4AYVAGqx +FPtgAAbwDxUA/e0ADvbrDQCu3Q1mCIkgCQlHsJnqkVVrGASAANsgbQhIjLSwmf9gqBXgDhUA94AA +Q/usAQD7zQANNswNAP1AAEU73wEA6mYIBIDJgAAN7Tn34ABD9v8NAK/d7WYIBMv9AADrvBgkjB+A +AGP/sIodI6UQJqURKYATZJM9l1GKHfrAYBXgDAUA/KAGFaK7HQDrFggo4ASAAFv/bY4dmhSNGO3l +FCUUwYAA7qnDGcgEgADycVAN7/X1ABqqMSqimvlAaB2gDwUAbTkgiyODIqv7f7sBsTMFPAEOvQHt +hgEn+EMAAOyGACRAIQAAlB73IAXCogCdAPQAIh2gDBUAiCQIC0v7jQAN9ogNAPsAAERwDwUA5I01 +BAGhgAAKmAtt2imLJ4MmDwIAq/sOvQEthgHvuwd0yAUAACM8AeU8AQf4QwAA7IYAJEAhAAD3KyYN +oAwVACgiBQgLS/uNAA32iA0A+wAARHAPBQDkjTUEAYGAAAqYC23aJYspgyir+++7BnTIBQAAsTMF +PAEOvQHthgEn+EMAAOyGACRAIQAAIiwY9z/606AMFQCEHo8S7hIIL8bCgACoqJgZiBTq+REP/4KA +AA9mDKmI6BYEJxNBgADAWgXqNpoXCqoJ5BYDLVfCgACaFvSADKISAJ0AiBMZqPsMiBGpiCyCnvuA +EXuiAJ0AKIKd6BYFJBDJgACIFYkWjBeOHYsYGqkYLeEVDLsMmxis3S3lFQoAh22ZAggCYY4X0w9k +4Y0UqPEYqXASqOn8IKgVoAkFAP/AAIawBQUA/iAIFeADJQDqEgQu7sKAAO3MCA5YBIAA7BYLL/6C +gAD+IUYV5eodAIwcmLCTso8ZnrONHY4ar1+N0OS2BCVRAQAA92EGFeBDBQDstgkiqIEAAPNgphXg +DGUA/2DmFaADBQDzYWYV4A4FAO62Ci2YBIAA4t4CDu4CgADutgYs8ASAAOzdAgTIEQAA/WAmFeAM +VQBtyiX3wdINoAQFAITx/eAIFeAAGgDA0JQ97TYMJ3AFAADv/AghmCEAAIwbFKi8+2wAFeADJQD9 +f/rlJeodAI0XwOAO3TWJExqorY8Y6BIGLM8CgACqmeiWnSeASYAAwCDRDwCKEIsRghXt2AkNVoKA +AJqwix0LiBH4QABBMAkFAPlipB3gWhUAKrQF0Q8AAAAAAAD/8gANoAYFABOol44498AGeJIAnQCI +ExmolOwSBixHAoAAqYgrgp79YAZrogCdACiCnWSAxLDpmTjoFgUsct4AAGAAaAAAAAD3AMYV7/L6 +AP/9eA2gDQUA8MEQDeAJBQAaqWuUHvtTSBWv9GoAGqln+1NIFa/3DgApkmSKEoYd9mDIFeAMBQCc +UJdRLGIWCroMmhgqYRKcECNhEOZhES1WgoAAqpn4IIYV7/I6AIIV0Q8AAAAAAAAA//dQDaAIBQCO +HYIQ+CAoFaAPBQD/wqQd4F0VAO3kBSkWgoAAkoDRD8CgWUOJjjj53/lQkgCdAP/9GA2gCAUAAMCA +Bek0+GEGFe/84gAAAABsEBAbqKgmsokiFhP0y2gV54UBACdiXSpiZixiXJwe6hYQJBR5AACJNy6Z +FCMWEvvASCgSAJ0Ag5nyIiYV4AMWACoSEw8CAA8CACqiE3mnCPAB2A2gCQUAACpiWSuhAmS/7Vgl +DRuoQBmojyuyey8SEymSg6q67fAHLVZCgACqmSuQBywK+/vhkBWg3REA7LsBDu+CgAD9ZgAN8PzF +AAy8ASuUBy3wB/shhh2vmJUAKJQF/yFGFeAOBQCemP8hJhWh3QEADcwCLJQHmRDpFhIoBAqAAPsg +RlgSAJ0AipfbMOqsICpgBIAAWCwijBCNwCoWEeuhCC7uAoAADU0CnaErxQguEhOO4vvAQDCSAJ0A +KBISJBIRiIyEQPwAQh2v//UA8wAN59dEAQAuEhGk6IiPKxISD3kDCYgBKLYULuIRqO6IHq5e4IAE +B3P9AAAODhkODk+z6v9lZB2hqg0A+2VEHa6ZRQD4wEBUYgCdACkSEir6tPsgP+QiAJ0AZOf0sOsL +7QF74BVtCAyw2OjdAQ7wBIAAeOACY//sD+4RGajvG6jrE6js7ai+F1ANAAD/UdAFoqodAAOjAQ2t +AQ6uAftABAXwCBUAC4s5Do45DY05A4M5CaoB+w0ADTAIBQDZgOrJOQxQBIAA+GYACfAZBQANmjn5 +AGgd4A2FAA7ZOfsmAAywCkUAC6g5K2JqCYgCCDMC82A68+IAnQAqYmsDPQ8K2gqKoCuhAg7dEe0W +ASW+EYAAWCSZiBEmYmuoZo5m7WIBL3aCgAAOriiu3S4SEhmn++3mEyneAoAA6GIGLXQCgAAL7gKG +ZPsDAAw///UA+cYAD3AMJQD4wABDMA0FACgSEv+mAA6wGWUA/QJGFefdAQD5oDjkYgCdAGXXJxqo +AikSEiqidomQCpkMsZkJCktkpzX34AAFttkdAPWoABa1qQEA7aoCDc6CgAAKmQIoEhKOjJmO/cYA +DzAKFQAK7gKejC4SEi7hKmTkJRqonSsSEhiomw95A5kW+CGGFaAJBQCZFygSESuyE5sa9QAARDAL +BQDoFgMkSQEAAOkWCCRA4QAA+CCGFaAGdgCMHoL97BIPLgIKgAClKbCZCQkZ+YEADnAOBQDtFgUm +HYGAAMAwjROMH4sUGKfiA8wM+YEADnAOBQCj5OhECw3ABIAACACIqkQEAIqC3Rin2offAlQ25CIM +B3AFAADi1g0hAImAAI/ep0d0ewGx/5ffn9586cOIH6Pj8wARjWIAnQBkIimJE4wVjZ8txn+JninG +fowZjhofp/CfwI8bKBIT/fAAFLXuHQD/gGYVpdkdAJ3C+QAIFaALBQDtp2cUmJ0AAPmAphXkMx0A +7cYELEYCgAD4ZgAMMA4FAOjGASeEEYAAhBnAdOlMCAowBIAA5EwwJmDBAAAoEhIiEhMdp64Zp04i +IgAN7wsuEhAJIgIiZgYigg4OIgEuEhEK/wgiZgcu4hEuZgjoghQqEASAAOhmCSIhAQAA+sFmFeAO +BQDrZgojMQEAAO8mAAdwBQAA4oceDy/QAADecOxJmnO4EQAALxITL/AHDw9BKBISGacy7oEqL/8C +gACp/4kbCe4M8/OmFe/uAQDuhSonEuGAAIkbiBoKmRGpiJgaJBITJEAHHacl9CAAAjAHRQDn7zYK +JwKAAK1E7EKeL/6CgAAv/CcPTxT/gCKD4gCdAI8TJkKd6WQAAx/BgAAoEhL9BWQVoA1FAA3tNu0W +Cy7vgoAADN02HKgShvydHwzdCyvWfivWf4iMmRnxH+/Hl2YBAIz+if+IFo4XCYgB/cAEBzAJFQAI +mDkOnjkI7gLtFgUnDCmAAIkULhISiBwJQIgZqAAcp3UICIookn8tkn4tln4MiAEoln8u4hSM/Q5e +DAzuNg7MDOz2DSYAmYAAhP+N/qTkfksBsd2U/53+LRISjNzH7Q7MAZzcgv2MHogfpSnpnP8uAgqA +APkf4BWhmZ0ACYg28RPADeAOBQD/9ewNoAMVAOkSCCN7/QAAnx34IsYV4AgFAOgWFS+BdgAAY/3G +LBIVLhIWKBIU7RINJmAFAADsFhUneGEAAAj+OS4WFv2f7SRiAJ0AIhIVKBIWJxIW/CHoFeAiAQAi +FhQHIgqHII8eA90MpX7u7P8vggqAAPQiiBWh7p0ADt027RYCJoKxgAAD3AgtEgwIRAvtzAsCWCEA +AO09Cw3IBIAA6WYADsAEgAAIDIqHIOdfNgboIQAA73cMDcgEgADnJgAjgJmAAIZDjkKm9n9rAbHu +lkOeQnzZyI0S+CHoFaAJBQAN2TmpM/Mf+d1iAJ0AZH8zLRIWLBIUDcwLjRWOwy7Wf4zC/a/GFa/z +lgCC/YweiB+lKemc/y4CCoAACQkZCYg2/QWMDeAOBQD/8ogNoAMFAAAAAAAAAAD/8kwNoAMVACYS +E4piJmAH8V9cDeFmAQAappAMaRGqmSiSnvcAEnLSAJ0AJJKdZEJDKxITJbITF6aWjLn7YUgV4FVB +AAdVCiVSgNMP7LsMAqjBAAD1YA4D4gCdACsSEyuwFiwK/3yxEyoSE/tA8BWgDAUAARECWAasZKIN +LRITJtEHGKaoGaZ5/U1QBapmAQDvpnobNwKAAAlmApZAitAr0Rr+gEYV4AZVAOyqAg12AoAABu4C +nkEp0hOaRJtG+AgAB/KZUQDn/goMzYKAAO7igC/+goAACf8CCP8Cn0cOXgzuRgUncEEAAJ5DLNIW +jtmlzKXuntn9osYVr+sFAPqACDxiAJ0AKRIR/oQAFaANFQD5JgAV4Ag1AG2KBQkAhg4CYSsSEy1E +ICyyFy8SEvyH5h2ozB0A/IfGHajMHQD8h6YdqMwdACxEPIr+KbIQ+oZmHaiqHQD6hkYdqKodAPqG +Jh2oqh0AKkQwLpISsej5IkYVqJ4dAPiHRh3gCgUAKkQj/odmHaAMBQD8hEYdqIkdAPiHJh2oiB0A +KEQ4LLAH/+HmFaHMAQAepiwMzBGuzCbGnSuwFioK/3qxECoSE/tA8BWgPAUAARECWAZCKxISy72J +uMuZjLnAoJq7mcCNuJzRmrj7YSYVoAIFANEPLBITK8AHCwtB67wYLlAEgABYLX8tEhKMGizWEy4S +Eo7oy+DAINEPAAAAAOoSEyrYBIAAWAXtZK41Y//fAAAAAAAAAP/b9A2gAwUAjxP/7swNoAYFACIS +EykSEoovG6cF65YLJPiBAADvpgAhQOEAAJiYmpn+QeYV4AIFANEPwOD/5BQNoB1lACwSE+rEAANY +YQAAWC1eY/+CAAAAACwSE+rEAANYSQAAWC1ZY/9tIxYR/BHCHeAAKgAAAAAtCo0qEhMrEhIsEhFY +LePAINEPLBITK8AHLhISwND7gGgdobsBAO3mEiXYYQAAWC1JY/8rAAAA/+OEDa/ppQDA4P/iIA2g +DSUAAABsEDYiFlwoElwPAgAogAQjFk3lFkwkLLmAAPkALBOQFYUA9wAr0hIAnQArEk0qElyPsCag +BysWSCoWTvYgAAM3/wEA7xZJJ/mtAAD2KOYVpP8dAC8WSvUALqISAJ0AKBJOKIAFLApO/QAqFCIA +nQApClF5gSsrClR7gSUqEk4rEkjsHAQg6CEAAFv8JvtAiyASAJ0AKhJIKBJOiRGZpyiABcW0+wAP +lGIAnQAjEk4rEkgfppgdppcSpmbyIeYVoAcFAJcW9iVGFeAENQCUGvQmhhWgCAUAmBf4JWYVoDz1 +ACwWJPwkxhWgGQUAKRYo/CKmFeAGBQAmFi7+ImYV4AoVAPoghhWgH7UA/iIGFewKBQAqFiUqFicq +Fi0WpdItEkf5S44F4BzlACwWFikWIPwpZhXj+PUAKBYs+CcmFa/09QAkFhskFiGOtvJhBBXgByUA +lxn2IaYVoAdlAPYmJhXgBvUAJhYzIxY3+2DoFeAEBQCUGCQWDCQWDiQWEiQWFCsWGSQWGPQjRhWg +GqUA+iOGFaAYFQAoFiIkFjAkFjIkFjbkFjgvegKAAP4j5hXo7h0ALhYe9aAhyhIAnQAjEksWpWkM +MxEGMwgrMp4sCht8swIkMp36gH2AEgCdABalidhA9gAIHaAZtQBtmgIIAmESpWUnEk4YpWAWpWHy +4AgV4AqVAPbg5BXgKQUA+yAIANAMNQDmMwIJ3gKAAPdKsgWqdwEA7LsCC78CgADodwIAyEEAAOhE +AA2gBIAAbao3l4CUgZKClYOThIqVi5OMkI2U7pICJMhhAACah/sBJhXgrZ0A94YADbDOnQCbhZqG +7IYIJEDBAAArEkscpTrTD+kSTi3fAoAA/WAARbAatQD7c6YVoFhFACiUBSsSTiuwFiwK/3yxJiwS +TCoSTvzgAAYwDRUA6qBBJmP5AAAM3DkBEQJYBVz7QHLgEgCdAC0SRy0WSw8CAPWgFsISAJ0AFqUh +DNMRBjMIJhJKLzKe9+BzY6IAnQAkMp36gHAoEgCdABalQCkSSuYABQpABIAAbZkCCAJhKBJNKhJO ++UvgBeAOBQAuFkD5RUQd4CvlAPtK5h3gDGUA/UuGHaANhQAtpGQogBXTD/jOAAwwBzUA+OBvsKIA +nQAqEk4cpfzsFkAg2AcAAPtMoBWgDDUAWT13KRJKKBJOLBJJ/0piBaBPJQD/DoYd4AYFACaGHC2B +By6FNyaFNR6k+fcNJh2q3QEA5oRoLu8CgAAO3QKdQIqAG6T260YCJmExAADsRgMtVgKAAAqZAplB +LoBBL4EiHaXGDuYJ6IAFKzcCgACm3f2v6BXgVgUAdoEOxH53gQnFlvkAb7ViAJ0AGaW+IhJJFaW7 +/MAABXJtQQD5S3QFoAMFAPKBRB3gvTkA+IDmFa3PHQDkzBEN3UKAAOy7AgtuAoAA7aoCD+UCgAAF +zALsRgYhEPEAACJFCwuqAusSTi9EAoAACogCCYgC6EYEJbEhAADmAx4CKIEAAAUCYf1lRBWgDgUA +/oYmHaAPBQD+hkYd4AUFAPSGhh3gBgUA9oamHaAIBQD4hsYdoAkFAPiG5h3gCgUA+oXGHaANBQAt +RDAsRC3yheYd4AMFAPKGZh3ozB0ALEQsLbBX+oeAFaAMRQD8h2Yd6N0dAPyHRh3o3R0A/IcmHejd +HQDtRDgl2XEAAFk9FygSTu1MQCRBgQAACCCIDQSKCACIDQCKLBJOLMIcKxJI/IpmHajMHQD8ikYd +qMwdAPyKJh2ozB0A7ERQIlFRAADsEkkl2MEAAFk9BC8SSSsSTq9PLrB0LvRYLRJLHqSG7BJKLu8C +gACu3SzWnSuwFi0K/32xDSoSTuqgQSlgBIAAWAScKhJOKBJIxJUppAUogBLKihykqxulex2leyoS +TguLKFvAoyoSTlvAhsAg0Q8AAAB4UgnBx/0AClmiAJ0AwCDRDx+ka4/49+Bi6JIAnQAjEksWpGjn +EkopnwKAAKYzJjKe9sBi6+IAnQAkMp36gGKgEgCdABikX7D2lohlTRBgCw4fpFuP+PfgYlCSAJ0A +IxJLFqRYDDMRpjMmMp7Be/bAYmPiAJ0AJDKd+oBiGBIAnQAYpE+w9paIZUuwYAtZLRJNKhJc7hJM +KNgEgADt0Qgu4ASAAFgRtS0KiP1AYRRiAJ0AghBkL1WIJ4uI/QKkFe/PBQDpggskcIEAAA/vAa/d +7xZBJukBAAD7IGEEYgCdACaJFAxMEavPrGYmhRT/oGDj4gCdACgSTcmAyE7ZsG1JBQgAhgkCYY/g +DP8I/eBibGIAnQCf4Ikg6BJcLM4CgAAJSQKZsSiABfopBhXgNuUA9wBddCIAnQDEovsAXSQiAJ0A +w839AGElIgCdAPIpxhWv5boAH6RtJfKJLhJMIlJbI1JcJlJmJhZZ8irmFefuAQDjUl0nFJ0AACgS +TYmHJpkU6BZbKAQKgAD6wEn4EgCdAIqZ+itGFaAC+gAAKhJc0w/TDyqiEw8CAHmnB/AB1A2gBwUA +KlJZK6ECZL/uWCDPGKQDF6RRKIJ7LxJcJ3KDqojq8AcsRkKAAKh3KXAHKwr7+eGQFaCqEQDrmQEN +V4KAAPsmAAyw/MUADJwBKXQHLfAH+OGGHa+WlQAmdAX+4UYV4A4FAJ54/uEmFaHdAQANzAIsdAcn +Flv64EzAEgCdAIp3KxJN6qwgKmAEgABYJ+aMcCoWWuuhCC5mAoAADEwCnKErdQgtElyN0vugRJiS +AJ0ALxJbJBJaj/yEQPgAQh2v/vUA8+AOf9dEAQAtElqk34//KRJbDjYDBv8BL5YULdIRr90vElet +LeDwBAbr/QAADQ0ZDQ1Ps9f9JWQd4XcNAPclRB3ulkUA9qBDrCIAnQAmElsn+rT2wEM8YgCdAPug +QvgSAJ0AsNoK2QF60A+wm+uZAQzoBIAAe9jyD90RG6SzH6SvGaSw5qSDFuANAAD3SVoF4swdAAnJ +AQbGAQfHAf+ABAfwChUAD685B6c5BqY5Cak5C8wB/U0ADjAKBQDboOyLOQ1gBIAA+yYADPAbBQAG +vDn7QGgd4AaFAAdrOf1mAA2wDEUAD8o5C6oCCpkCKlJq+UA+U+IAnQAqUmsJlw8KegqKoC2hAikW +Qu8CAAu/goAA+6BFmBIAnQBYIFsvUmun/4327PIBLu6CgAANrSgrEkKtzC0SWxmjvezWEy3eAoAA +5vIGLWwCgAAL3QKP9PrDAAs//vUA+aYADvAIJQD34ABHsAkFACoSW/0mAAzwFmUA+UJGFeeZAQD3 +ID8kIgCdAPsgQKiSAJ0AGqPCKRJbKqJ2iZAKmQyxmQkLS/tgQQASAJ0A/+AABfbJHQD1iAAWNakB +AOyqAg3OgoAACpkCLxJbjfyZ/vmmAA6wBhUABt0CnfwpElspkSpklGsapF0fpFsrElsONgMmFk8r +shMrFlMrElr+KqYV4AgFACgWUKS76xZDJeEBAADsFlEl2OEAAPoohhXgBxYAiM0mElcpEliiju7s +/ysCCoAA9CjGFaHunQD/IQAMsA0FAO8WRSSfkYAAwDApEkMsElgrEkQVo6DzjwAOcA0FAO7MNg34 +BIAAD0CIo94F7guq7g4IiiiSDSSSDy6SDggvNu+IDAboBQAA6JYNJACRgAAE9Agklg9/SwIu7AGe +nuzZxX34BIAAJhJYo9PywBLdYgCdAGSCUygSQykSRiuCDyuWfyiCDiiWfi0SXCgSUyYSUiwSVBmj +qJlg/ZAAF7WIHQD4wGYVpe8dAJ5ijdDuoyIX2J0AAP7AphXkux0A7mYELu4CgAD9ZgAO8A4FAO1m +ASYEkYAAJBJSGaMQHaNu9IBoHeAIRQDvTAgCIMEAAO3vCwZgwQAAJhJchmAJZgImVgYmElsuElkn +Yg4OfgEnEloK/wguVgf24igV4A4FAOdWCCo4BIAA5mIUIiEBAAD+oWYVoA4FAPahJhWgBgUA5lYK +IqkBAADvZgAHcAUAAOePHg8v0AAA3oAN7wvsSZd0QBEAACwSXCzABwwMQSgSWx2i6emBKi5nAoAA +rcwtElQNmQz7k6YV75kBAOmFKiSUAYAALhJULRJTCu4Rrt0tFlMtElwt0Aceotz8IAAG8A9FAO+X +Ng7vAoAArt3m0p4rvoKAACd8J/8gaB2kdx0A9sAlO+IAnQAsEkMl0p1kVEYmElv4xWQVoARFAATk +NuQWVCongoAACEQ2GKPIj8wkFlj4gAICMAgFAPiPxhWgCwUAK0Z/hmwlFlLw3+4fl/8BAIvOic8o +Ek8mElAkFkYJiAH6wAQDcAkVAAiYOQaWOQhmAu8WRSMMkYAAFqMqLRJEH6OyKxJVDYCILRJbCxCK +LvJ/KPJ+KPZ+Bu4BLvZ/LdIUi80NLQwL3TYNuwzrxg0lgJmAAI7Pic6u3n3rAbGZns+ZziYSW49s +x40I/wGfbC8SV4jN7xJYL4IKgACijrDu///gFeHunQAO/zbx9IAN4A0FAP/1FA2gAxUAKRJFLBJR +/CvmFaALBQDrFl4ky/0AAOkWViyBdgAAY/2cKxJeLRJfLxJd7BJWJdgFAADrFl4m8GEAAA/tOS0W +X/1/69QiAJ0AKBJeLxJXKRJf/CsIFeCIAQAoFl0JiAqFgCYSXwPdDOJeCA+CCoAA7xJdJ3P9AAD4 +KqgV4e6dAP+hAA6wBwUA5v8LBoKhgAAtFmCj3OnMCwfYIQAA6TkLDegEgADtpgAMsASAAAYUioWA +BS427lUMBMghAADlhgAigKGAAITzjfKk5H5LAi3cAZTznfLsmcx96ASAAC0SYCYSWA3XOacz8t/5 +tWIAnQBkXy4pEl8oEl0JiAspEkaLgyuWf4iC+S/GFa/y1gCIzS8SVysSWKKO7uz/L4IKgAAODhkO +uzb9YWwN4A0FAP/xrA2gAwUAAAAAAAAAAP/xcA2gAxUAIhJcjyIiIAfz4pwN4SIBABqiPgwpEaqZ +JpKe9sATGtIAnQAkkp1kQlgrElwlshMTokQssgn7YUgV4FVBAANVCiVSgNMP7LsMAqjBAAD1YA07 +4gCdACsSXCuwFiwK/3yxEyoSXPtA8BWgDAUAARECWAJaZKIdLRJcL9EHF6JWFqIn+0SqBer/AQDu +oicf/wKAAAb/Ap9AidAq0Rr+gEYVoA9VAOuZAgzmAoAAD8wCnEEo0hOZRJpG+AgAAzKIUQDjbgoM +RYKAAO7igCs2goAACGYCB2YClkcOXgzuRgUncEEAAJ5DLNIWjtmlzKXuntn9osYVr+sFAPqACdRi +AJ0AKBJaKUwg+QYAFaAGNQBtagUIIIYJAmMrElzAYSZEIC6yF/6H5h2o7h0A/ofGHajuHQD+h6Yd +qO4dAC5EPC4SW43uLLIQ/IZmHejdHQD8hkYd6N0dAPyGJh3o3R0ALUQwLcISsdr7gkYVqH0dAPaH +Rh3gCAUAKEQj/IdmHeAJBQD4hEYd6GcdAPaHJh2oZh0AJkQ4LLAH/cHmFeHMAQAdodoMzBGtzC/G +nSuwFikK/3mxECoSXPtA8BWgPAUAARECWAHxKxJb+3+sQBIAnQCIuPsfq/ASAJ0A67IJLdAEgADA +kJmrmLCMqJvBmaj5QSYV4AIFANEPAAAA6hJcKtgEgABYAaFkrk5gACsAAAAAAAAA/9sMDaAKBQAs +ElwrwAcLC0HrvBguUASAAFgpIC0SWywSUyzWEy4SW47o+9+omJIAnQAiElwoEluJLxqiseqGCyR4 +gQAA75YAITDhAACWiJmJ/kHmFeACBQDRDywSQ//tcA2gBQUAwND/4ogNoBllAAAALBJc6sQAAVhh +AABYKQdj/6EsElzqxAABWEkAAFgpA2P/kCsSTouy+3+lIJIAnQArEkcsEk7rvBguUASAAFgo+8Ag +0Q8AACwSTozC+5+kAJIAnQAsEk4rwEHrvBIuUASAAFgo8sAg0Q8sEk0tEk4swBT9rAYdr8gGAAAA +AAAA/8ZcDaAEBQAtEk0tFlr8EcId4AAqAAAAAC0KjSoSXCsSWywSWlgpc8Ag0Q8uEk6O4vvfoOCS +AJ0AKxJHLBJO67wYLlAEgABYKNnAINEPAAAAACwSXCvABy4SW8DQ+4BoHaG7AQDt5hIl2GEAAFgo +z2P+wQAAAAAA/9/sDa/ppQDA0P/eYA2gCSUAKBJOxWL3AKYdr8gWAAApEk6Jkvs/nYCSAJ0AKxJH +LBJO67wYLlAEgABYKL7AINEPAMCgWTx6H6FRj/j5/5zIkgCdAP/O+A2gBAUAAMBAGKFLwGoG9jT3 +AQYVr86uANpAWTxvH6FFj/j5/51gkgCdAP/POA2gBAUAwEAYoUDAagb2NPcBBhWvzvIAKhJc6xJN +KmAEgABZAH/AINEP2iD8KYgV4IhFAOi1CCpgBIAAWP9WwCDRDwD7IGgd4AoFAPsBZhWv0DoAAC8S +TevYDAeBsYAACEoUuKbmRjYNuASAAG1pBQ9AhgcCZS8STScSQQpJDNMP6P8IA7kBAABtmQUPYIYH +AmcpEkEIygyqmSmcQPnABhXvzvYALBJBLMxA/cAGFa/OvgAALQqF7bUIKVAEgADtEkwqYASAAFj/ +NMAg0Q8AAGwQCB2iEyjRf8Rl5aE3ESGVAADxAA0XkCflACocCPqAaB3gDDUAWTl+jBIMjBScEoo2 +DwIABasBmxMpIAUsMB4rMCJ2mU33gArUYD1lAP2ACu1iAJ0ALiBoLyE1+8AKfWIAnQAsMRAv/AHT +D/+ACf1iAJ0ALCU16yRoKlAEgADoMgkg2DEAAPhDhhWgDDUAWTlkijbzQAg6EgCdABmh7vlAB+Tg +SyUAKjAf+0AHjWIAnQAsIAX3gAc1IgCdACUhCIknKCEHKiAHLZkUiZn6IAAFOogBAOTQxmxHAoAA +HaDXZJC7DKsRrbsssp73gBGqUgCdACuynROg2eShIBWROYAAjJEMDEeckSwgB/tCNgWg/BEA9fAA +F7HMAQDviAIOdAKAAA5VAgRVAgqIApiwjiD1YMYVoD8FAJ+zk7L1YIYV4AMFAPNgphXgBUUA47YH +L3YCgAAF7gLutgEl0IEAAAkghgoCYwkAhgoCYYgnDMkR/SAARP/PBQDllp0kQIEAAA+PAeOFBCf5 +AQAAn4D/ACYV4F4lAO4kBSmQBIAA0Q/AINEPACwxEPpkUBXv+yYAxbX6QKYd7/t+AI4nL+kUZPFN +iOmYFBqg0ykhN/sgClQiAJ0AjTbaEPqAaB3n3cEA/CCmFeAMNQBZOQ6KEAqNFJ0QjzaOFQX/AZ8R +KyAF+cAJ2NIAnQB2uZYsMB53wQfzQAlR0gCdAHveHCggdMSSeYgUKiBXd6EZLiBoLTAiftEQYAEI +AAAALyBX9+AH/WIAnQCOLy0xC4oUrt2dLyigE2SAqYqm+6AFDSIAnQDE+C8kBfeABPxgS4UAw4b5 +gAZtIgCdACowIikgaPsgBf0iAJ0ALSE1LDEQsd39gAV9YgCdAB2hcSwlNR6hbiokaIoRLuF/DawB +88AGH5IAnQD9QAReYgCdAB+gly0hNywxCn/ZdywlN3yndHmucX+ubnqua3uuaHymCCgwHykKQnmA +XLQb+mEoFaAMNQDqJhwqUASAAFk4y8Ag0Q8AfaM/95/7TWIAnQAsMRD6ZFAVr/4aAMCw+iCGFe/6 +wgAsMQr8RuQdr/rOAI0iytbE6f5Aph2gAgUA0Q8AAAAAAHzRh/d/8v0iAJ0AxfX+QKYd4AIFANEP +K6wY7CQACVAEgABYJ6HE6f5Aph2gAgUA0Q8AABihO8CRDJw56KgcfmgEgAAfoGYuITYsMQoPAgB/ +4SAoITcPAgB8iaf8ACIdoAkFAA3JOGWfIWP/lgAAAAAAAAD8RsQdr/+SAGwQBMAg0Q8AbBAEKiAi +KSAjH6Cw+y8ADLAOFQDkkF1nowEAACwgBwwMQQTMCSzNAivBBgm9Ng27DCvFBiogIowprar6QWgV +56oBAOokIiUCKYAAKPJ/4IEEBUv9AADgmRoPQAqAAOm7CARD/QAACLsCmyoMuQxzkybAINEPKiAF +aKFyiyLAwgy7AvpARhXv8kUA0Q+LKZsq/WBoHa//XgArIAf9TwANcbsBAAS5CeokIiTICwAAKJEG +rYgolQYqICLLpSnyf4wr4JEEBUP9AADgiBoPaAqAAOjMCAbr/QAADcwCnCraIOwkAAXYfQAAWCdP +xyTRD8ck0Q+KKfpBRhWv/5YAbBAE+UB8BaKnBQAHJyiodSVSf8FvA2YMdl0TGqCoCDgQ6EgCCU8C +gACqmZiQ0Q8boDfjOgoEY8cAAKx8DKoLq6opoX/1LwAMsAsFAAuZNSmlf9EPbBAEG6AsAzgK9UBQ +BaKpBQAJKSgaoCeklCZCf+qZCAHgQQAA50J+LgEKgAD5AAIEcAoVAOuICA1ICoAACXcBB2YCJkZ/ +JYJ/sVUlhn8kQoAAMQQAoxpzSA4UoA0MIhGkIoIgAjIB0Q8pjQIrkQIlkQEpkQULVQF5WwPAINEP +0qDRDwAAbBAO9OAABHANBQDuIhAkFGkAAIk3KpkU5TQABTEBgAD3ISgVoAOCAAAsIhPnn/EWZDCA +APugaB3gAdoAKnKJKqJZL6ECZP/rnhxYHGYcn5kswnuOHCtyg6rM7SAHLmZCgACsuyqwBykgDPwf +Yh2g3REA7KoBDu+CgAD9RgANcPzFAAysASq0By8gB/lhhh3vmJUAKLQF82FGFaANBQCduP1hJhXh +/wEAD8wCLLQH1bDuFgwlr4mAAIq33EDqrCAp2ASAAFgjfolQCJsRC0sCm6HqcnYtMASAAAqZDLGZ ++WAABfANBQDuEgwlrpGAAAlqFPVIABU1mQEACpkCmV4rYQgrVQiMIvOVPA3gCiUALCITL+BvKyAH +/Q4ADLDMQQDq9wEH+CiAAAqfAQ/MAhqfXwsLQQy5EaqZKJKemxqbGfcAKc1SAJ0AJJKd459mEhgB +gACJKYgqA8MKIzKACYgMkxjkc39hmMEAAC8iGCtiEQ+7NqOzmx7zABWD4gCdAC8gFhqfovk/UgXg ++PUAePF/JRYRJSAHJBYQ9CCmFeKoBQAIVR0Yn6IP9AqpWahVBUQLFZ+gkx+lROWSfieYQQAA+mAE +ANADFQAAOBoIVQEokn8FiAIoln8lQn8A8QTjEg8p+AqAAOQWAyKoBQAAJUZ/KZKAJBIQJRIR/yAi +kOIAnQCJFQyZEaqZiZAJ/wFk9FcvTCD4xgAV4Ag1AG2KBQkAhg8CYcDxL0QgKSIX+IfmHeiZHQD4 +h8Yd6JkdAPiHph3omR0AKUQ8KeIS+IdmHeiJHQD4h0YdqIgdAPiHJh2oiB0AKEQ4j17+hmYd6P8d +AP6GRh3o/x0A/oYmHej/HQAvRDAo4hIfnxKfF+lWDyRABQAA6OYSIkFBAADtVhcjjkmAAC1EI5gW ++oTmHeibHQD4hMYd6JkdAPiEph3omR0A6UQkI3mhAADuYhkiSYEAAPggRhXojR0A6EQiI0nBAADk +4gpiQWEAAC1WFg6+Ni5GFQ8AiAgAii9iGQ67DA7/DO9mGSeTIYAAL2IbK2Iar+9++wIrvAEvZhsr +ZhrA8BifPS4hB4sXFp7n+ENEFeruAQDnizkPdwKAAAbuAp5A/kAIFaBGBQCWQ5tCFp8N/+AAhfBo +BQAIuwrony8V2D0AAObmAg92AoAA9oCGFaS7HQAOvgKGGp5BjhgIZgoYnygmYqEOPgyZRuhmAQ5G +goAACGYCGJ8knkWJFuhmAgf4BQAA5kYHI4BhgAAYnxwI+AKYkI8pKCIWo/+jiCgmFp8pjhkfnrsM +7hGv7ivmnfpC0BXvnIUA/KCmHaD59QD8QPAVoB/1APllRg3irgUAGZ8ODs4dqekpkn8L/wz/IBRC +YgCdAAzIEeqICA36AoAADz8Cn4OJWIpZ8SSgDeACBQCdW5mgi1iasZ1YnVnRD54cnB3qJAAJ2ASA +AFv+fYse/CGoFaANBQDuEgwlabmAAGAADosa2iDrvBgpYASAAFgl/YxYZMJhwCDRD8DwZX6wH57q +jhqGFw/uCh+e5ishBwf2OR+ekAsLSughGi3fAoAAD7sCm0CPIJZCFp65+CEIFeBLBQCbQ/fmAAsw +C1UA5kYEL/4CgAAL/wIWntmfQS7ioQk5DObuAQ5+goAAD+4CH57VmUWYRg/uAv6A5hWv+1oAAAAA +AAAAAP/yMA2gCwUALlIWBu4KLuIcZOBtDr42LkYVL1IWCf8LuP/vJgACQWEAAAgEii9SFgn/Cojw +DogMmPAvUhafFAn/Co/wmRvuuwwHgQGAAI8bixQPuwuGs4+ypuZ+awGx/5az/2BGFe/3QgCIFGSA +8C5SF+1WFidwBQAA7lYXJMhhAACGEv9vwA3gDwUAKFIWmBSIFC8WEgmOCo7g9CJmFeD/AQAG9QoO +vjaeUCUSEyVSFglVC+8WASKoIQAABUCIBvULLxITuFUFCIov8hYJ/wqF8A5VDJXwLxITmRso8hYv +EhKYFAmICoiADrsMJRIT5IAiZ/gFAACLFAm7C4izhrKo6JgQfosBsWaWsogQ+WBmFa/5zgCOFMrp +KFIX/KLGFeAOBQDuFgQkQAUAAOhWFyTIYQAAiBEubBjo5jkN+qYAAGP+P8CB+KLGFaAOFQD+IIYV +r/+KAAAA96BoHa/rEgDA4f6ixhWv/HIAiRMpnQIvkQIokQEpkQUPiAH5H91K4A8VAIsa2iDrvBIp +YASAAFgld2P94wAAAP/rKA2gBAUAGZ5qC78KGJ5qqekJ/wuo/yzxfwPMDA3MNf3v5B2v9b4A2iD8 +YGgdoI3lAFgl+sAg0Q8AAAAAAAD/6PANr+mlAIwvHZ8B7VYLItCBAADqxgAhWOEAAJtYnFn6QeYV +oAIFANEPAGwQFBed8CggBByd9iwWEvkAGIuQHHUA9wAYShIAnQCJMCogByMWD/ogAAU3mQEA6RYQ +JMmtAAD6IWYVpJkdACkWEfUAGcoQTuUAKCAF/wAW3CBPdQD/AFXcYgCdACsgFiYK/3axHfpIMBWn +xQEA/Z/AFaAIFQAMjDlb/gb7QFaQEgCdAI0b1dD1oBUiEgCdAO8SES7HAoAAp4gugp7/wFgb4gCd +ACSCnfqAVEASAJ0AGZ3s0w8JAIcpEhHYQG2ZAggCYf09PAWgBgUA9iAmFaAPhQD+TIYd4A5lAP5L +hh2gLeUALSRXLCUqKzAVDwIADwIA+s4ADfAKNQD7QFOQ4gCdACosZeieqBDYEQAA+CAmFaAMNQBZ +NiQqEhEsEhItEhAuIQf/O7wF4AkFACkkaCkkaSklNS8lN/87UAXgSCUA+EOGFeruAQDoJHQvdwKA +AA/uAp5AiyDpEg8m6TEAAJ1D7EYCLd4CgAALqgKaQSmQE2SR/C0gQS4hIhqecg3bCeggBS3fAoAA +q6r7T+gVoFsFAHuBDsTOfIEJxfb/AFBlYgCdAPIiCBXiukEA5p5pHsQCgAD2gOYVoA0FAPyBRB3m +mgEA/WAAFbCqOQD7JgAM/b4dAOWqEQ3dAoAA66oCAZjxAAAjRQsbnlgKmQIJiALpnlcfVQKAAAuq +AppGCYgC6EYEIUkhAADpBx4CQIEAAAgCY/xFRBWgBgUAJkQxJkQy9oZmHaAPBQAvRDUvRDb+huYd +4A4FAC5ELvyF5h3gCwUAK0Qw/IWmHaAKBQD6hoYdqMwdACxELCkgV+ssXCJQ8QAA0w/4h2Yd6Jkd +APiHRh3omR0A+IcmHeiZHQD4hwYd4AxFAFk1yCgsYOgmAAJRAQAACgSKCACICgCKLCIcix/8imYd +qMwdAPyKRh2ozB0A/IomHajMHQDsRFAiUVEAAOwSECXYwQAAWTW3KBIQJiB0qEgmhFjuEhEq/wKA +AKf/LvadKyAWLQr/fbEK6iBBKeAEgABb/VKIH8SWKSQFKIASyoYbnjMcnWIdnjLriygJUASAAFu5 +WtogW7k9wCDRDwAAAP0ACSQn9QEAwCDRDxqdJA8CAA8CACqiCPdARKCSAJ0A7BIRKscCgACniCuC +nv1gRMuiAJ0AJIKd+oBEgBIAnQAbnRewqZm4ZU1BYAfCjR8s0hP9oMYVr/fqAADaIOsUAAngBIAA +7TEIKvAEgABYCnotCoj9QEMsYgCdAIwQZM+HiMeLiP0CpBXvzwUA6YILJHCBAAAP7wGv3e8WAibp +AQAA+yBDHGIAnQDmiRQqTwKAAJkTq5qpZiaFFPugQtOiAJ0AyTrJSOm0AAnABIAAbUkFCACGCQJh +LxIDKuIAD6oI/UBEJGIAnQCa4IrACKoRCkoCmrEoIAX6IeYV4DblAPcAP1QiAJ0AxNL9AD8EYgCd +AMPt/wBC9SIAnQDzgGgdr/BqAAAAAAAA7iIQJ5SFAACJNyqZFOU0AAUxeYAAipn5QGgd4AOKAAAA +AAAAACsiE+adJRXkMIAA8AHgDaALBQAqYokqolksoQJkz+suFhVYGZocnM0swnsuEhUrYoOqzO0g +By5mQoAArLsqsAcpIAz8H2IdoN0RAOyqAQ7vgoAA/UYADXD8xQAMrAEqtActIAf5YYYd75iVACi0 +BfNhRhWgDwUAn7j/YSYV4d0BAA3MAiy0B9Ww7hYVJbXJgACKt9xA6qwgKdgEgABYILKIUAiLEQtL +ApuhKWJ2CYgMsYj+IqgVq7gBAOmkAAW06YAACGsU9WgAFbWIAQALiAKYXiyhCCxVCI0i9bZsDeAK +JQAsIhMv4G/9DgAMMMxBAOr7AQf4KIAACo0BDcwCKiAHCgpBDKgRp4gvgp6aHpod9+AsPVIAnQAo +gp3khAAEKLGAACsWGBOcmY8pjSoDwwojMoAP3QyTHOSzd2GYwQAAKiIYKJIRCog2o4MoFhfzoBXz +4gCdAC0gFvs5rAWg9vUA96AETCIAnQAWnNkkFhsjFhokIAclFhz0IUYVoqUFAAVEHRWc1A3TCqZG +pUQEMwsUnNGkM+Rifib4QQAA++AEANAPFQAA9RoFRAElYn8EVQIlZn8kMn+TF+USHCIgBQAAJDZ/ +JmKA4xIaLoEKgADkEhsv6AqAAPzAJIjiAJ0AjxoM/xGq/4/wD90BZNSWLUwg+yYAFaAPNQBt+gUK +QIYNAmXAoSpEICYiF/aH5h2oZh0A9ofGHahmHQD2h6YdqGYdACZEPCriEvqHZh2o2h0A/IdGHejd +HQD8hyYd6N0dAC1EOI1e/IZmHejdHQD8hkYd6N0dAPyGJh3o3R0ALUQwL+ISHZxw6lYPJ/gFAAD/ +wkYV4AoFAOpWFyWOCYAA6EQnImmBAAD8ISYV6OgdAP6Exh2o7h0A/oSmHajuHQAuRCT7IygVoA8F +AO9EIyTpwQAA/ooAFaAPBQDvRCIlD/GAAPsBAA0wBgUAJlYW6kYVJPmhAADvRgACMWEAAAYIii+S +GQqIDAr/DO+WGSeSeYAAL5IbHZxMKJIar6+fGHr7AiiMASiWGooYKpYbKQoAKiEHH5wVCgpK5iEa +LVcCgAAPqgKaQPpACBWgTwUAn0MvEhINqAKYRBicYAuPOZ9C+SAAhHBvBQAPiArojA8tVgKAAP84 +tAXkiB0ACooCmkGKHg+qCh+cWCqioZZGhhzvqgEOfoKAAA+qAh+cUwY2DJZF76oCBMgFAADqRgcl +gGGAABucSwubApvgjykmIhaj/6NmJiYWnymOHQzuEafuKOadKCAWLfqY/KCmHeD89QB8gTEpIAf7 +OIIF4qoFAAqaHaurK7J/wc8IzAz9YBlyIgCdAB2cNAiLEOs7AgznAoAArcybw4hYZIrCj1nA4J5b +mPCCWJ8hnlj+oSYVoAIFANEPLhYVLBYWKRYZ6iQACdgEgABb+6wpEhkrEhgoEhcsEhbuEhUlaRGA +AGACCMCQZb7NGJwehh4anBwIZgooEhIpIQcLqDkam8T+IYgV6pkBAO4hGizPAoAACpkCmUD4QAgV +4EoFAJpDmEL9JgANcAhVAOpGBCzOAoAACJkCGpwOmUEmYqEPPwzqZgEOToKAAAlmAhmcCZ9FnkYJ +ZgL2gOYVr/umAP/yUA2gCAUAKlIWCaoKKqIcZKBzCoo2KkYVL1IWDf8LuP/vZgACSWEAAAkMii9S +Fg3/ConwCpkMmfApUhYNnwqP8OqIDAeBUYAADZgLhoOJgh2bx6amlhR6awftm8UUyAUAAJmCihT7 +AGYVr/e2AABkkQQvUhfAkOlWFif4BQAA71YXJuhhAADxDkAN4AkFACZSFo8ZDWoKiqDyI6YVoGkB +AA9iCgqKNpogIlIWlhYNIgvvbwsBECEAAOIGAAf4IQAADwCKJlIWDWYKgmAKIgySYCZSFg1vCo/w +CogM4hIdJMgFAADmFhQngbmAAA1oCx2boI+DhoImFhOvr58V6hITLTAEgAB2+wftm5kVUAUAAJqC +jxX/AGYV7/nGAAAAAOIWHSMBsYAAKlIX/aMAFeAPBQDvVhYlUAUAAPqi5hWgBgUAghmPFiosGA+i +OZIZ4hIdLHoGAABgABXAYSZWFv//gA2gBhUAAP/nTA2gCgUA/TcABe/4WgDAkfiixhXv/CoAix7a +IOu8GClgBIAAWCKtjFhlyHGPLxicSuhWCyLogQAA7fYAIXDhAACeWJ9Z/EHmFeACBQDRD48XL/0C +LfECKvEBL/EFDaoB/1/bUuANFQCLHtog67wSKWAEgABYIplj/6wAAAAA/+nwDaAIBQDqJAAKYASA +AO4yCyroBIAA7zIHKdgEgABYAGHAINEPAIwi+5+/kJIAnQCLG9og67wYKWAEgABYIofAINEPAIwi ++5++oJIAnQArIEHaIOu8EilgBIAAWCJ/wCDRDywwFPxMBh2v1i4AABmbcgiOCh+bcqmpCe4Lr+4t +4X/zrwAO8A8FAA/dNf3P5B3v8xoAAAD/1AANoAQFAMWy+kCmHe/XygAA2iD8YGgdoI3lAFgi+8Ag +0Q8AAAAA/+XEDa/opQDAoFk2Ixqa+Yqo+V+7EJIAnQD/3gQNoAQFAMBAHJr0wLoLqzT7gQYV792+ +ANog6zQACmAEgABY+jPAINEP2sD8gGgdoI1FAO21CCroBIAAWPkLwCDRDwAA+yBoHeAOBQD/AWYV +r99aAOvdDAGBuYAADUYU72wIKcAEgADvTzYN0ASAANMPbfkFCGCGCgJnihKtOOZJDAVRAQAAbZkF +CICGCgJpiBOPEg2IDKj/L/xA/8AGFe/eHgAAiRIpnED5wAYV793mACoKheq1CCroBIAA6sQACmAE +gABY+OjAINEPAGwQFiIWIOcSICvoBIAAKHAH3mD8IGYV4Ep1AP7gsBXhiAEA6BYNJEBhAAD4ISYV +oExlAOzxDHmQBIAA++A4PSIAnQAkcSKMfpUWIyAViRMmIhMocEGLIB2bjgiICfjBAAt3uwEA6ysI +DEcCgAD5oABGv/8FAO3SfyXY/QAAD7sBirGbGu0WDCXYQQAA+8AzKqEzIQD8AAId4AUFAA3vDB2b +BS3SfwnMEazcLME19CCmFaf99QB82woUmzTyIIYV4ABKACRKAATENvIghhXvRAEAHJt1LMJ/7wIA +DhgEgAD7wATCogCdAI0aD6oMiNOcEo3SqPiYF3+LAbHdkhvtEgcu4ASAAPbALLiQDwUAkhv3QCxo +kgCdAMAgbQhbCmg0AykKCEg0mJADKAudg5yCiZAPAgAPAgAJZgwJqgytmOgWDiEQBQAA6YsGfmgE +gACxzezUAAf4BQAA7RIOIQwxAADyYwAV4AIFAPbAKSCSAJ0A90Ao4JIAnQBj/52cEpIbC10LC1oK +iqCJ043SD6oMqfmZGH+bB+IWCyboBQAA3ND8IQgV4A8FAP4jphXgAgUA9sAFAJIAnQD+I8YVoADO +AAAAKBId6OgIAqgFAADoFh0ijDEAAPtjABXgBQUAC1wLC1oKiqCNw+zCAiMNm4AA/1zwDeAOBQBq +YcdtCE4DKQsDLwoKaDQISDQIZgwIqgyY8JySLZYD7Y8IARAFAADo+wd+aASAAC3MAezUAAdwBQAA +6CEMb+gEgADyYwAV4AIFAGSvffbf+9CSAJ0AY/+qAAAuEh6DEvYhaBWgCAUAmBCIEyZiEytwFi4W +GvjBAAsw+fUAebEajBb66DAVp8wBAP2fwBWgCRUADJw5W/pVZKS3LRId6ZofFp1pgAAUmv6CFYoc +jB3umkIT+SEAAC8WE+4WDyPpcQAALRYULBYQ+kgABbaKAQD/gAAWPVIdAOnMCAkVAoAA5CICCq0C +gADyIsYVoKo5AOwWEi3eAoAA64gCA+GBAADsFhUtVUKAAPqmAAqwCwUAKxYbihT4pgAKsDRVAPQj +BhXgCBUA+1pAFaAFBQD7AgAKsDJlAPSNAAlwBQUA8iLmFaAEBQDwAEANoAIFAAAuEh3+oBhcIgCd +AMD1D18v5PJeYqgFAAAoCoCoRCtxBxyZ8PJAAQb6uwEA6ppBHd8CgAAMuwKbQIhw+oBGFaBJRQCZ +Q/0AABQwCYUACYgCmEGP0C4KBPjoMBWh/wEAD+4MLxIY7RYZLEQCgAAI/wIYmrn6ImgVoe4BAC4W +HAj/Ai9GBC8SFv2gCBXgCAUAKEUKL0YGDt0I7pqwFujxAAAtRQsuRgfqAx4CSIEAAAkCYf7lRBWg +CgUAKkQ0/oWmHaAMBQD8huYdoAkFAClEM/iF5h2gCwUA+oamHeAPBQAvRC76IogV4A8FAP6GBh3g +CAUA+IYmHaAJBQD4hkYd4AwFACxENvwjaBWo7h0ALkQs+OrwFe/dAQAM3AjsFhsiUPEAAPiHZh3o +mR0A+IdGHeiZHQD4hyYd6JkdAPiHBh3gDEUAWTIb6RIVIlEBAAAJIIgKBIoJAIgKAIotchwsEh38 +imYd6N0dAPyKRh3o3R0A/IomHejdHQAtRFB8WTP+I4gVoE8lAC90dB+amipMRfogaB3h7gEA/8YA +D3APlQDvdGUvdgKAAP4gBhWgDDUAWTIAKxIaKHE1AywLH5ps6RIXJEAFAAAodTUoEhkpdFcvRhaO +gC5GF43DLUYZjMIsRhiKgIl/q6srdhyIgApmDCsWGumICAEQBQAA6HYPIQwxAADyYwAV4AIFABuZ +efwjiBWgClUAClovK0Ya5MwIBmghAAAtRhsrcHTrxHQtbqYAAC4SHQXuDLHu99/uIVIAnQApEhIo +EhEolp0rcBYvCv9/sQgqcEEsEhtb+XyNGywSGpzblteKcsS363QFJQfJgADRDy4SHS8SEAXuDP/A +IBWgClUACu42De4R7hYRJ6UNAAAvEhIv8p7/4AbTogCdACQSEiRCnWRPsogf/IBoHeAKBQDoAAUH +azmAAG0ID+0MAAVQBQAA/1/qpCIAnQBj/+kamT6KqPdABSCSAJ0AKxISK7Ke/2AFy6IAnQAkEhIk +Qp1kQK0ZmTWwqPkhBhWv/qIAix3AoOoWGy3fAoAAqbsrFhIuEhItEhEt5p0rcBYsCv98sQgqcEEs +Ehtb+UePGy/wE8j/iBuJf4iGeYkHxJgpdAXRDwDEpip0BdEPAI2zLxYdjLL7YAgVr+xSAAD//7AN +oAIFANpw6xIJK+AEgABYIIDRDwD//LANoAQFAP4j5hWgCgUAWTQ5GpkQiqguEh/5X/pIkgCdAP/8 +JA2gBAUAwEAcmQnAugurNPuBBhXv+94Ajxov8gQK/wjv41d9aASAACUKAP4gJhXgDwUA7RIBJ/gR +AADo9A9iqAUAACu8GP4AAh3gBQUAq/iIgK2ImBF469n938sS4gCdAP+vAA+/5XYA0Q8pcEEpnBL4 +ISYV7/kyAAAA//9oDaAFBQBsEAiUESoiByYxC/hA8BXgTIUA/UKCFeBHZQD4QLAVoEtVAPbYgBWh +mQEA5aIJJovJgAD9ABCNIgCdAChQEsiL6RYFKVAEgABbtOiJFYRQlRL0IGYV50TBAPSAFdsfywUA +iBOIiiowX/cAFyOiAJ0A5ZQABQo5gAAnbDcHRxS0d/UgCjoSAJ0AGpjKDJgRqogqgp73QB9L4gCd +ACiCnRWZzpgQ6BYEJBWRgAAdmOgNAIdteQIIAmH0gB1LEgCdAC4wXxyYwxmZCeswXi8NPgAAw/P+ +gArUYgCdAPSACtMSAJ0AiBIogBNkgVWEEo0vhEb8gBylYgCdAGWxd8DwjROI0S4hB/3gABU3iAEA +CogCmNEoIAcrIQj/QAAHMKgRAOzuEQ1SgoAACu4C+cYAD3GIAQDqEgQsTAKAAAm5AhuY7J6gjiCc +opumC5kC+UCGFeALBQCbpZun/cAAFzALRQDr7gIFYIEAAP9AJhWgOwUA66YDLsgEgAAJIIYMAmMJ +AIYMAmEbmIvpEgMsVwKAAKuqJ6adiZD4+AAE8DolAHqRWtogWBZw0Q8A/QAFpSAFBQDAwCzAEmXO +h2P+kS0wXmXetv/67A2gB0UAAAAamHiMqPeAFyCSAJ0AHZh2DFgRrYgugp73wBeb4gCdACiCnWSC +6rDO/0EGFa/6ngAmIRQjIRL+2bAN4AQFAOpSQinYBIAA/AACHaANFQBYIJgoUkPkTAEhmAUAAAgz +LnZJ22P/b2S+x2AAPAAAZL6/YAA0AABkvrdgACwAAPcf73xiAJ0A+x/vPGIAnQBj/0kAAAAAAPcf ++mRiAJ0A+x/6JGIAnQBj/zEsIAeKEB6YnfpBBBXg3BEA9bAAFrHMAQDu3QIOZAKAAAy7Ap2gHZhO +/EAIFaAPBQDvpgUjcGEAAJ6j7hIDIyDdAAD9QEYV5EQdAO2Ykh5mAoAADEwCnKENuwKbpA4EiZan +naYKIIssIAzmpgcuZAKAAAy7AuumBCtgBIAA6zxUJVChAABZMKeOEBmYfOyYNBpHAoAA+cAARzCP +lQD+IIYVr/eqAACKJ4cR7KEVK78CgADnNwgFUIEAAAuqAarK6qxAK8AEgAD64A6aogCdAPggZhWv +9HIAAAAAAAAAAPcAaB2v9HIAAI0iZNGb9J/yGxIAnQCMJy7JFCZSveThfmZQgQAAhcmFUfTgAALw +CwUA7GQACugEgABYGHeMJ4nI+YKkFa/NBQDqwgsmWIEAAA20AaSI6IxALbgEgAD5QAs0YgCdAI0R +LskUDN0RrZqt7i7FFPsACzuiAJ0AyT+OEeyUAAcA2YAAbekFA0CGDAJlJyIHKrIA7aoIA7iBAAD5 +QA5kIgCdAJqwLfrAjHCLc44gKHEFihENcgHiiAgPdgKAAA6qAuqWASRBAQAA/WAINCIAnQAveQQM +WRGpyqn/L3UE+wAKS6IAnQDJaeNkAAKAuYAAbVkFA2CGDAJninAPAgAPAgCpqvlAC3wiAJ0AmnDR +D4onjRHAwOqsIC7YBIAAWBg9mhL6IGYVr/ESAAD/8GgNoAgFAHTbFI8SDU4M7vYGLe7+AAD+EWId +7/GGAIoSBNgM6KYGLe5WAAD+EYId7/EyAAAAAPggphXgCgUAWTLjGpe6jKiJFfmf6FCSAJ0A/+8g +DaAIBQDAgMDaDc00/UEGFe/u5gAAAAAAAAAA//oQDaAFBQAAACucGOokAAlgBIAAWB8TY/5SAAAA +AAD87wAMP/i2APlAaB3gDgUA/4FmFa/7ZgDA8J9z0Q8AAOmPDAGB4YAAjhEPShTorAgs4ASAAOju +NgnABIAAbekFCICGDAJpjBGvOOrMDAJRAQAAbckFCKCGCgJrhycnfCAP2AyoSCiMQPlgBhWv+foA +7I8MAwFxgAAPShS4q+tbNgtABIAAbbkFCMCGDAJtD2gI6lwMAVEBAABtyQUI4IYKAm8PnQytLS3c +QJ1w0Q8AAC5MQP9gBhWv+M4ALyxAn3DRDwAAbBAIGZh7KzEKJzBE/GCIFeAuJQDvMEUpYASAAPKA +aB2gCgUA9TDqBaPdgQDg9hEH4B6AAHr/cYwyjzPxgBarUgCdAPGAFmsSAJ0AG5dmK7JxKJJor7vq +FgAt3kKAAKuImBFkcw4cmCkMbAF0yTUqMDxooTL1QBGhkgCdAGilWfVAEguSAJ0AfqEcwtN9qRfq +EgEp2ASAAOwkAAroBIAAWOz40Q95ZhzRDxiXgi8xJ/ngBrQiAJ0A+iAGFa/+ngAAAAAAAOoSASnY +BIAA7CQACugEgABYBBXRD40RKdAFKgpGepnCKdIHK5kUZLHuK5IJL9BoGZgYLLIB6rAVJ/gFAAD/ +rQYd4A4VAP+rhh2gCIUAKNRnKNRk+aVEHeAIBQAo1Gb5rKYdoCnVAP5p0BWhqiEA7zBPJVNJAAD5 +pqQdoCjlAOqYOA92AoAAD+4C+armHaBPFQAv1HQu1TcusBX+zgAPMAo1AP9BQB2nzAEAKbAUKdRg +7jIVLtAEgADvMhYq6ASAAFv8UdEPLzA8DwIADwIAaPZjfvFgmhCNEe7RNyHI8QAA6QMeBsFxAAAI +AmHvMSYg0CEAAP+mxB3gDDUA7tU3Jtl1AABZL36LEcDD6rxdJdmFAABZL3qKESscCA8CAPtMIBWg +DDUAWS91/udcDeAuJQBgAXwAAC/ABPXgB3MSAJ0AGpgBDdwJDMwRrKoqon9krpGMNvtgAAb4zEEA +L6EZDw9Lf9kOi6rIuSixPnyBC4u5Zb/0iqllr+LRD4q6mxTqFgAlAVmAACs8QZsTKqxM+iBoFeAM +NQBY8CfxSDAN4C4lAIoQiqjqFgAtfxYAAIsUZL4wHZfeLdF/7DA8JvgcgABoxn9+wXGNFC3RCOoS +BCDYEQAA7DQACvAEgABYBD2NEWXe9GP9/AAA6hIBKdgEgADsJAAK6ASAAFjscNEPAAAA6hIBKdgE +gADsJAAK6ASAAFv91dEPAAAA//hADaALBQCPEP4ghhXv/h4AmhCcEf2AaB3v+poAAAB914r8f+Id +7/4yACiwBPUf+8oSAJ0A0Q8Zl7fTD9MPKZF/DwIA8T/sF5IAnQDqFgAh4IEAAOrUAAjoBIAAWPC6 +7aQADQJOAAAqMDwrCoH7X+rNYgCdAIoQZK1P2zDtFgEpYASAAPygaB3gjkUAWO/w0Q8AAAAAAADq +EgEp2ASAAOwkAAroBIAAWO760Q/C4vogJhWv804AAGwQBikxDyowLC0wLeuXLRyexgAA7JaPHVYC +gAANqgJ7oS8dl5Uel5X9QATMYgCdAP9AEeQiAJ0AH5diGJeR/0ATtGIAnQD5QBB0IgCdAMAg0Q+J +NCjCd/eRCBWjqYEAqogJiBGoZtxg8yAQ4lIAnQAqMDf1QBLIkgCdAP1Z4ANQGxUAe6nHLDBCLTBD +CMwR/YYADnBNNQB9ybMtMEQuMEUI3RH/pgAOsE5FAH7Zn+okAAnYBIAA7EQACugEgABY01rAINEP +KTAuLTAvijTuMDEszgKAAA2ZAv0hgADTSoEA+T/7U1IAnQAtMDAI3REO3QL7v/rNYgCdACkwNCsw +NQiZEQuZAmiRB/k/+hFSAJ0AKzBGLzBHHZcC6DBILd4CgAAPuwLvMEkt3gKAAAi7Au6XVR3eAoAA +D7sCDb0B/7/4bCIAnQAdl1AelpANvQH/v/fkIgCdACbCdyLCiKZGCWYRpiLWIPNADkpSAJ0AFZbR +gmeCLtogWNKKZK7RKiKo9UALSRIAnQD1QAsJkgCdACswPCwwPe0wPi3eAoAADLsC7DA/Ld4CgAAN +uwIIuxEMuwIoMDUvMDSbECIwRicwR+yXMxpoBIAA6TBIKRYCgAD2RgAJcApVAOcwSSkWAoAA6SIC +D/4CgADo/wIJFgKAAOciAgrwBIAA8iAmFaA7BQBZM7MpMDQqMDUImREKmQL1IAuYkgCdAPk/8aFS +AJ0AKzA8LDA97TA+Ld4CgAAMuwLsMD8t3gKAAO27AgtQBIAA6LsRCugEgADsuwIB4NkAAFjR98Ag +0Q8AAOokAAnYBIAA7EQACugEgABY8b7AINEPAOokAAnYBIAA7EQACugEgABY8FzAINEPAOsxCitQ +BIAAWNMxCqY5/gAiHaAPBQD7wgAPsA0FAA/tOOxkAA7uHgAAY/2ZAAAAAOokAAnYBIAA7EQACugE +gABb/mjAINEPAC8wQo3A/4awFaAKVQD9LdgFoDsFAFkzecAg0Q8rMDwsMD0oIpLtMD4t3gKAAAy7 +AuwwPy3eAoAADbsCCLsRDLsC+x/05WIAnQBoowTAwywmqMCl/S24BaA7BQBZM2jAINEPJTEK6iQA +CtgEgABY0wYKojn+ACIdoA8FAPvCAA+wDQUAD+045iQABuehgAArMEYsMEftMEgt3gKAAAy7Auww +SS3eAoAADbsCCLsR/WYADb/3vgAvMD0sMDwtMEYoMEfuMEguZgKAAO/MAg7uAoAACN0CLzBJ6DA+ +Lu4CgADu3QILUASAAO4wPy5mAoAA6MwCDu4CgAD/pgAO8AslAO88Ni5mAoAA7swCD/AEgABY0dTA +INEPAAAflqwi8X8u8kEp9YAJIgLi9X8ncAUAAP/oJhWgAgUA0Q8AAABsEAjjIAcp2ASAAOUiByrQ +BIAAHpXZ6ZEXKTgEgAD+oqQV4NMRAPiighWhMwEA4lIJKeQCgADsmQIO6oKAAA7dAhyVzp2g/uAI +FaA9BQCdo5ymDJkC+UCGFeAJRQDslX8fdgKAAAnuAv1ARhWgCQUA6aYFIuCBAAD/QCYVr84FAA7O +Ae79CARDQQAA6FUUJukBAAD8QAh64gCdAOWsICF4wQAA/6AIU+IAnQDiCx4KyASAAAkCZQIghgkC +YwIAhgkCYYLBIiww/EAJjGIAnQCSwSjJBGSAYe1wLCJ7/QAA7KIML/8CgADvqwgN9QKAAA7dAg3M +Apys6lIBJdiBAACbEvygSBWgCQUA7BYBLQI6AADpFgMlBZ6AAIxR/MAAFrfMAQANzAKcURuWWulI +CAnXAoAAq6qYoNEPwPDvxQQnaQEAAP2AJhXgAgUA/YAGFe/+IgAA6xICK9AEgABbos2IUSsSAuwS +AS1IBIAA6hYDLW8CgADtuwgEBoSAANpwW6Kdj1GOEwhoEf9AAEc3/wEACP8Cn1EYlj7uTggJ/wKA +AKj/nvDRDw8iDPKhJhWv+7oAAtkMCUgU6BYAKugEgADTD22JBQJghg0CZ4gQ6a8IB2kBAADv/CAk +HFkAAJIUghDAgwKIDG2JBQ2Ahg8CaQniDCIscPOAJhWv+2YAIuxA84AmFa/7OgAAbBAGJDAHGZUJ +FZUK+TAQFeFEAQAMShGlquiiniTI3QAACUkUuJn5AAXT4gCdACmineuUAASFuYAAGpUlCgCHCQJh +CQJhCQJhCQJhCQJhGJYP+SvKBeAMFQD6QAgVoA4FAP4gJhWgDQUA+CAGFeAPBQD4IEYVoA41AFgY +tCgxBxmU8v8sBgXqiAEA65TyHEcCgAAJiAKYoP5ACBWgDRUA/UMmHeAcBQCco5ui7+8CD3YCgAD/ +QIYV4A8lAA/uAp6hDEkR9SAARPAIVQD5M6YVoA91AO8kBCUQgQAA0Q8AAAAAAAAA//0kDaAJBQDS +kNEPbBAIF5TPJiAHLHIIFJTO94ALCJFmAQApQq5kkYArQq1ksXywzJx4HpTF37DxdfAN4AUVACvg +gCu8NwtLFOu8FitQBIAA9MAHihIAnQAMahGkqiyinvuADVviAJ0AK6Kd8XTQDeAKBQCJJyokVCyZ +FIeZZMD2jHEpIBQMDEcMmQgJCUcpJBT1IAomUgCdABSVxR+U7C1xFyVyCfjhCBWgBgUAJuYyKOYz +9KAAEzhVHQAl5jgm5jn/pgAO8CYFAP3H5hXv3Y0A7eY+IinhAAAuQn+KMClCgShCgu9CgysCCoAA +/JCIFaCZnQD4ICYV4A0FAPwgBhWg/50A+CBGFaAMFQBYGFYkTBjlScN9WASAAI50+kBoHaAfBQD/ +xgAPcBw1AO52BC3oBIAA+mAIFeAOBQBb/vXSoNEPAACWFfeABmCSAJ0ADKoRpKooop77AAcj4gCd +ACuineSw22Zr/QAA/OEGFe/79gAAAAAAAPdAaB3v/BYAwKBZL5uMePmf9MCSAJ0A//qADaALBQAA +AAAAjiJk4LL0SoYd4AIFANEPwLDA+g/MNPzhBhWv+foAAAAAAIgiZY/dK2wY6iQACWAEgABYG8n0 +SoYd4AIFANEPLCEJ/EKwFe/2BQAGlgEGmAwoJBTm9AMu6QKAAOr0AC5mAoAADcwCBcwCnPH0laYV +7/pCAAAA//lgDaALBQCbFP4gxhXgCgUAWS9zHpRIjxaMeIsUihX5n/jgkgCdAP/4wA2gCwUAwLDA +igjINPjhBhWv+IYAAAAAANog/EBoHaAbxQBYG6X0SoYd4AIFANEPAABsEAiJJx2UNiUgByiZFPso +agWgBgUA/aEIFaFVAQDkkgkkENGAAC5CASdBCvZChhWgCaUA94AR4JfuAQAvoq5k8mcjoq1kMmOw +zJzY7zQAAZJJgAAZlCIjkIAjPDf+oAAVtDMdAOq7CAGYnQAA9KAOmhIAnQAosp7zABYD4gCdACOy +nWQyMCkgFK6ZCQlHKSQU9SASDlIAnQDAoljyLGWicpUV9CCGFaAKBQBY8gQUlSUclEwWlSWPFPsq +SAXgDgUALmZRKPEXJbLIJ7KxjfkrsXCP+C9mUgyIAuhmXi7yAoAA/ssGFajdHQAtZlerqvrgAEO/ +iI0A6GZdK75CgACnVSUmFPKhBhWgJwUALkJ/ilApQoH4kEgVoAwVAO9CgyuCCoAA+pCIFeCZnQD4 +ICYV4A0FAPogBhXg/50A6BYCKdgEgABYF60kTBjmSb59GASAAIQVLCEHixQdk+fzJ9QF6swBAOix +Ci5nAoAADcwCnKD+oAgVoA0FAJ2rnar9QMYV7//1AJ+pn6ifp/8ojAXgCUUA46YCLzYCgADpZgIP +d4KAAA/uAh+U6pahnqQPTwL/QKYV4C+FAJ+jibeLti+mEy2mFi2mFy2mGC2mGS2mGi2mGy2mHC2m +HS6mFCymECOmEvdCJhWggwUAo6PmlNod5gKAAP0GAAw3u8EAC5kCmayYrfaGAAowDgUA9UKmFaAs +RQCPFMCQKSRVjfT6QGgdoBgFAPmmAA6wCwUA7fYEKegEgABb/hzSoNEPAP/3mA2gBAUA94AH4JIA +nQAMWxGquyiynvMACKviAJ0AI7Kd5DEMZkP9AAD5oQYVr/hiAAAAAAAA7hYHK1AEgABZLsEdk5iM +2I4XGpOX+Z/teJAJpQD/9twNoAMFAIkiZJDdwKH6SqYdoAIFANEPwDAJzDT9oQYVr/ZmAIsiZb/h +K1wY6iQACWAEgABYGvDAwfxKph2gAgUA0Q8uIQn4QrAVr/sFAAubAQucDCwkFOv0AyxBAoAA5vQA +L3YCgAD5xgAPMA0VAA3uAp7x/VWmFe/2OgAAAAAAAPoAgh2gK+UA7JSPG+gEgABZMRD+EQIdoAxF +APQghhWv+4IAAAAAAAD/9QwNoAMFAJ8W/iDmFaAKBQBZLo0dk2Mak2SM2I4Xjxb5n/dYkgCdAP/0 +aA2gAwUAwDDAigjINPmhBhWv9C4A2iD8QGgdoBvFAFgawMCh+kqmHaACBQDRDwAAAGwQBIYwxIL4 +EIId4DflAPb4AAMwNAUA9MeGDaA6NQD3QS4NoDx1AMOxe2oK94cODaA9VQB9YjAiIAV3IU74SWYN +oD7VAP5D5g2gj1UA/mEEHeACFQDRDyIgBXchDvhBZg2gJNUAdCEDwCDRDygwMP0eoALT+/UAKjEI ++0MGDeACFQApNQjRDwAAAAAA+GEEHeACFQDRD8Ah0Q8AAGwQBCswPC8xCycgB/xByBXvxgUA6iIA +J+MRAAD1YAzYkXcBAB6UKPlgDVtQOdUAK+Jo7pMfHsZCgACouyiwBQx9Ee7dCAewTQAA+QANhWRm +HQAp0p73IA27ogCdAC3SnWXQeI4iZOFBBQ9H+eAJyVIAnQCOJ4jr+8KkFe/CBQDs4ggnaIEAAALS +AeK7CAp/AoAA78oIBdkBAAD9AAvUIgCdACjpFA+ICCjlFPtgC4uiAJ0A6cQAAYDJgADJQW1JBQMA +hgkCYYrQDwIADwIAr6r7QAxkYgCdAJrQ0Q8oIAcpIQcek0L5QAAE8PgRAOr/EAzPAoAAD5kCDpkC +LrEI7iUILVYCgAD5oAYV4YgBAO8iACxEAoAA6O4CBkj9AADs1Q8mQMEAAPmgZhWkmR0A+yYADLAI +BQCY1ZnZ+yf4Ba/pFQDp1Bgv/gKAAA9vAp/RH5P2CuoCmtQPzwKf2B+S3Z/SLrIfntvrsh4m0QEA +AOvWCiHZUQAAWStHHpLNiycMfRH/oABGv8wFAObWnSXQgQAA/UAEBTAMBQDstRQlUQEAAJq5mrjR +DwDRDyt8GOokAAlgBIAAWBonY/6siCcvjCD34AQHsAkFAOmFFCf5AQAAn4mfiNEPwoJ4ud8p4X99 +l9nrNAAKYASAAPygaB3j+vUA6iUIKVAEgABY3EnRD8W16yQFKVAEgABYEJbRDwAAAP/5MA2gDQUA +wMCc69EPAADsuwwBgXGAAAtJFLie7k42CdAEgABt6QUKIIYMAmMJSAzrOQgBUQEAAG2JBQlAhgoC +ZQv5DKkpKZxAmdDRDwAAKixAmtDRDwBsEBT9J2IFoAcFAJcwlxGXEIlB6sJDKkAEgADmggArWASA +ACQgBy6hAi+hBfb4AAM3OQEA9cpQDeFEAQAloQTuogAna/0AAOsWAiKr/QAA7aUCKq8CgADl7ggP +/wKAAP/PAA9wANoAACmhBSuhBO6iACTIBQAA/X/gFa+ZAQDppQUuZwKAAPlgFQRiAJ0A7O4IDP8C +gAAP7gwOAIcHl2DuAAcE8xeAAByTiSvCTI2xL6EFhbCV0O6yAC/+QoAAr5kpFhT9wCYV5U8FAOe2 +ACWr/wAA57YBJfBhAAD1YCAkH5kBACe1EI0g/2IkHe/KBQAK7gHuFhMncQEAAJ4Xnreeti1WPvTA +EWsSAJ0AmR8sIAQrFhaYE/WAG5IQPgUAKSB6/sAZ5CIAnQAckkeNEIoR6hYSKngEgADtFhEqVwKA +APSAEeoSAJ0ArKouop73wCV50gCdACqinR2SnAROCQzuEa3tnRYdk1rt7ggFHEmAACMWFyMhByQW +GBSSOAMDSgwzEQQzAhSSOJOggyDyISYV4C0FAJ2j9UBGFaANNQDjEhcppgKAAA1EApShLSAEJBIY +nR31oBAkEgCdAB2TRSQWGSIWGhSTRAmSCewiEQbrsQAAot0iEhkt0n+dGAQiAiQSGo0dIhYQIkEi +JEEnnhXpFgsm6+0AAA1COCQSGZIaIhIajR+JFi2lCy0SES4SEJem/0CGFajtHQAupQouEhImFhvy +IuYV593BAA3uAh2TJicWHBOTKS3SvJ6n/CHGFeMutQD/oA0MIgCdAI0eLjon/6AOZCIAnQCHHPdB +RhXgDQUA7aYIKneCgAAD7gKeqSYgBwYmQPLQABM39/UAB2YClqvuEgUvnwKAAKwzKlJJLFGRJuJ/ +98/oFeANNQAtNp0tEhMTkw6bcCZWQScSHCYSG6OTI1ZAK+Z/K1JGrczjEhcmYQEAAPtAFpRiAJ0A +KVmQDD8Rr7qvmSlVkPuAFkuiAJ0AyYnptAABgLmAAG05BQgAhgkCYSpSRtMPDwIAr6r9QBdsIgCd +ACpWRikSFPTAB5sfmQEAmbuKIAiqEQo6AvtgJhWgAgUA0Q8npQX/9XQNoAkFAB2R+iyBJ/2f71Vi +AJ0AmR8qIAQrFhaYE/VAGaKSAJ0AKxYWmRSYE/VACyoSAJ0AixO0GvtoIBXgDDUAWSouiBOJFPoi +yBXv9roAAAAekbCO6JgT98AT4JIAnQAM+hGsqi2invegFaHSAJ0AKqKdZKKrHZGn4hYdJxP9AACS +2PIjqBWv9oYAIxYXHZLDIyEXkxgjICyTGy3Ss4MZDTMMHZLDmRqeFQ0zAiMWEPIi6BXv+HoAjRqO +G+/uEQ7vAoAADt0CHpK7Dt0C/CGGFe/5XgAIahAKmgKasI8gCP8RDz8C/2AmFeACBQDRDwAiFh2C +GI4bAg1G7+4RDu8CgAD9xgAPctJBAPe4ABawIjkA7e4CCRMCgADzxgAPMAIVAALuAp4c8iOoFa/3 +9gAAAC+AGJgTKxYW6RYEJ/0agACLE7Qa+2OgFeAMNQBZKeuIE4kU+iLIFe/yhgDaEPpJ4BXgDDUA +WSnltBr6SYAV4Aw1AFkp4ogTKxIW+EpwFe/x6gCLE9oQ+2MgFeAMNQBZKdtj/6vaEPpJ4BXgDDUA +WSnXLCBT/CCGFa/6LgAiCojRDwDbkPwAAh2gDRUAWBmJIgqI0Q8aknyJFo0Sqpn1oAnJkgCdACzi +gZ4Vm8AsVkEpVkAr5oEtEhMsUZEpUkYrUkmtzOYSBSZhAQAA+WALhGIAnQAuWZAMPxGp+q/uLlWQ ++4ALG6IAnQDJi9SA65QAAYC5gABtOQUEIIYLAmMqUkbTDw8CAK+q/UAMLCIAnQAqVkbbkCxigo3C +7hIULaAEgADuVYkmhuGAAI8gCP8RDz8C/2AmFeACBQDRDydWSftAaB3v9aIAAOvKDAQBkYAACkQU +6UwILGAEgADpOTYN8ASAANMPbZkFDECGDgJlqoiMFwQ9DG3ZBQhghgwCZy4SEwr4DKjuLuxA/qjG +Fa/0egCJF/ioxhXv9FIAAAAAAAD/7VANoAoFACQWFSsWFvgghhXgCgUAWSw0iBMekQqJFCsSFo7o +HJEILxIV+d/rCJIAnQD/7IQNoAoFAC/igJ4Vm/EpVkEvVkD70AYV7/sqAMCgwNoN7jQdkPv/oQYV +r+vqACvABwsLQeu8GC5QBIAAWBhejCAIzBEMPAL8gCYVoAIFANEP2hD6SQAV4Aw1AFkpZy0gevwg +hhXv8y4AAAAA9qkmFe/7RgDpygwEAZGAAApEFOtMCCxgBIAA6zs2DPAEgADTD225BQyAhg4CaaqI +jBcEPQxt2QUIoIYMAmsuEhMK+Ayo7i7sQP6oxhWv+hoAihf6qMYVr/nyAABsEAYkIAfjIhkpUASA +AA8CAPQgAAIwC4UA7RQACmAEgAABEQJYA8jxTpAN78YFAByR8IsgDLsCK6YAGpHZ6BIAKk8CgAAK +mQgolgAqIgJkoA1ZCVzrpAAJUASAAFgSd4g9ijiLPwuAAIkn/SK6BeAEBQD7I8AF7//1AOSQLGTA +gQAABogB5JUUJEEBAACYmZiYLrJ/n5DkJgck0CEAAJrhnZMssn+ckiq2f5QulC8kJhAkJhEkJhIk +JhMkJhQkJhUkJhYkJhckJhgkJhkkJhokJhv9I5IFoApVAPoGAh3gPYUAWS47JCQEJCQFlCIkJCAk +JCEkJCIkJCOUKZQqlCuULCQlGuQlGynQBIAAWIRZwCDRDwAFCUdokgPAINEPiyctuRSKuSy8IObM +AQboQQAA7bUUJVPBAADqtgkmYQEAAHyrKi6xFRiQi6runrmY4I8g/SNUBeACFQDt5gIv/gKAAAL/ +Av/AJhXgAgUA0Q8YkIGYoIIg/yNCBeAIFQDvpgIpFgKAAAgiAvNAJhWgAgUA0Q8AAGwQCoo1G5GR +/yMyBeuKQQAIiAnpkMkcRwKAAK+PL/J/q5mpiPngIBQgDgUAifGM8JyQi/As+RCZse72ACfr/wAA +7vYBJg5ZgACF94hQh1v7If4F50jBAOZSASJL6QAACYc4GZGD824IFeiGHQAJiAHpkYEcRkKAAAgz +CCjRiQoLR/si+gWnZgEA+QANLG93AQBls+PskHAXw+EAAPSAC8MSAJ0AK1EImxLpIgAhWSEAAJsZ +KdY+mCfsAAUBSIEAAAkCYQkCYQkCYQkCYQkCYQkCYSwwBC0sTvWAJWKSAJ0ALjEiG5FmLDIVjzAr +soyfLpwt7iUiLmZCgADsuwgO0ASAAP1vUBXgDGUA7SRBJdmhAABZKKKKGfpowBXgDGUAWSifKixh ++mngFeAMNQBZKJsqLF36aYAV4Aw1AFkomI05+CBIFeBM9QD8QWYV4AsFAOsmDCaAOYAAItYMkjkb +kUYtMBYqskMoMQcvMA3uMAwlUAUAACq2QyswByklCCwkBSskBy0kFi4kDC8kDY4g+EDkHaAPBQD+ +QEYV4AhlAOgkBC92AoAADm4CnlEnJQn0gBBzEDsFAPqADPRgPDUA9YVODaA9FQD8hE4N4D7lACow +BSclNv9AFAQgTyUA/0ATxGA41QD5QCAFIgCdABiQAQhICiiCEOokAArYBIAA/MBoHaANJQALgADA +INEPAAAAAPXAaB3v+N4AGZCNKZGP8T/0F1IAnQArOv/6IEYV7/nyAAAsokPAVu7ViSZj/QAA7KZD +LYpWAAAYkAOLIOvWPifL4QAAmSfoAAUBSIEAAAkCYQkCYQkCYQkCYQkCYQkCYSwwBC0sSO0WCSEh +OQAA9YAc8pIAnQAtMSKOMOwyFSRb+wAAK7JwnC2eLu0lIi5mQoAA7LsIClAEgADssHol2aEAAOwk +QSrgBIAAWSg4ihn6aMAV4AxlAFkoNSosYfpp4BXgDDUAWSgxKixd+mmAFeAMNQBZKC6NOfxBZhXg +DAUA7CYMJoAxgACS3JI5JSQEKDAHKTEJH5DcKzEHLDANLTAMLSQMLCQNKyUH/+hoFaP69QAqJQgp +JQnoJAcncAUAAC72Qy8wFv5Cxh3gTvUA/kCmHaANBQCdIuclCSlQBIAAWA2GwCDRDwAvMAQnJTb1 +4AaSEgCdANow61QACWAEgABb/D5krnXqJAAK2ASAAPzAaB2gDSUAWO2vwCDRDxiQL4uAKqJEn7Eo +1kH5AAgV4AwFAOnWQCvYBIAA/wAGFeANFQBYF7TAINEPAAAAAAAAAOclNyL48QAA7wMeAXFxAADu +DAAA0BEAAPykxBXgDDUA7SU2IRl1AADnJTcp2ASAAFkn6iogYSkgYik0Aeo0ACDYEQAA+ExwFaAM +NQDoNAIhUYUAAFkn4eokAArYBIAA/MBoHaANJQBb/DjAINEPAAAAAAAAKlwZ+mngFeAMNQBZJ9cq +XB36aYAV4Aw1AFkn02P/EgAAAAAA6iQAC2AEgAD6EIId4A0lAOtVCCrYBIAAWO10wCDRDwAlokMp +0ZEo0kf4IMYVr8IFAOkWBSfYYQAAArsB6xYHKxcCgAACzAyrmQjMMuzVkCKr/QAAJaZD5aK8JMkB +AADpFggsWASAAPkADWriAJ0A5RYEIQHpgACIGKsl9QANW+IAnQDZsOoSBCMAqYAAbWkFCSCGCgJj +JdJHLNmQpSWIGA8CAPigDkwiAJ0AJdZHhRTtFgomB+GAABmQWw8CAC2SHIga2jDv1gEk4cEAAOyG +QSjYBIAA/yOIFaANBQDuhkAq4ASAAP8jhhXgDiUAW/yK++AABzCNhQB96RhoRhUvUQgoOv948Qza +MOtUAAtgBIAAWO5YGpBD+uBoHeAMBQD7SIgVoA0VAFgXQcAg0Q8AAB+P54gwnRMuMSctMHouJSL8 +SCYd4AxlAOgmDS3QBIAA7yYOIdm5AABZJ3qKE/ptABXgDGUAWSd3jTv8QWYV4AsFAA8CAOsmDCaA +OYAAItYM+CBIFeBM9QDyYWYVr+3mAOokAAtgBIAA+qBoHeCJVQD4oQQd4A0lAFjtEMAg0Q8Aihed +Gu7VkCVRAQAAKtZH+6jGFa/71gAAihkrMHodj78sMSeOMJ4tLCUi7SYOKuAEgADrJEEh2bkAAFkn +VtpA+m0AFeAMZQBZJ1MtMgv8QWYV4A8FAO8mDCaAOYAAItYM8mFmFa/yQgCIFYsWCLsM+6jmFe/5 +MgAAAAALhQz4IIgV5KUdAG2pBQtAhgkCZQpoDIkXihTlqggEyQEAAG2JBQlghgoCZ4sXBSwMhRSs +u+zZkCXZAQAA+6jmFe/5FgAAhRclXEAl1kf0IIgV7/jSAGwQBCsyBf0f0AWhm6EA6o62FIgxgAD1 +IAowkgCdAPUgBvESAJ0ALaJ/aZNu+5ioFavrQQAO3QgJ3RENqgiIosee+QAEBHe7AQDopgIlgbmA +AP1pYAHQH2UAf7kniacomRSLmWSAUYm0jLEuChD/JgAMsA1VAPlghhXnzAEAWAHUwCDRDyKmFOom +CClYBIAAW/nDjCjIo4/CZPBMwCDRDwAowXLA0fEBgA3gCwUAW/pTY//eAAAAAAD//qgNoAsFAAAp +ogctpFYsmRTrphQmADmAACuSCSyyAfzgAAYwDTUAWAG7Y/+rAAArwAcLC0HrvBguUASAAFgV48Ag +0Q8AAADqJAAJ2ASAAOxEAAroBIAAW/4FwCDRDwAton/7mKgVq+tBAK7dCd0RraqJpx+OmI00LpkU +790BBwIBgACMmf2A5hXniwEAKMQbL6AGsP//QMYd4AsVAFupvcAg0Q8AAADqJAAJ2ASAAOxEAAro +BIAAWO3ZwCDRDwD//wgNoAwFAGwQShmO0SogByUWhSgSheUyACI7/QAA9jDmFeGqAQAqFoT4oAQC +94gBAPUACbESAJ0AjCIvEocajknmjkkeD6YAAO0ShCf4DQAABfc57RaGI9gNAAD1oAvKEAylAAzZ +EaaZKJKe+wASu+IAnQArkp3rFoMljwGAAIio9wAPUJIAnQAuYq5k4a0rYq3ksalke/0AAO+mCCWN +YYAAKCAUpIgICEcoJBT1AA6eUgCdAOg8ECIMVQAA6kz/KMgEgABtqQUIAIYJAmEiFoDrFAAA0AsA +AFklVgqoAuoWiCUJUYAAKgoD6xQADGAEgABZKy3JU+sSgylQBIAA7XQAAeAhAABYEcDboOhBFWjA +BIAA6kz/LcgEgABtqQUIAIYJAmEsEofTD+0yAy5nAoAArLvsMgIpUASAAFgReywShoon7MwRCmgE +gADmzAgD2A0AAOvGnSVQgQAA+oBoHeAMBQBYDm7SoNEPjSeL2P2ipBWvzgUA6dILJrCBAAAObgGu +zO4WgSZhAQAA+yAJ/GIAnQDv2RQqRwKAACgWgquKqP8v1RT7gAprogCdAMk1yUPZsG1JBQMAhgkC +YS0SgopgDwIArar9QAx8IgCdAJpg82BoHe/5kgCIqPcAB+CSAJ0AKRKGDJkRppkukp6zf//ACsvi +AJ0AK5KdZLFQsI2dqOsWgy3zzgAAYABNiBAZjwktEoX8ICgVp4jBAAmICiiCeCoSgPogaB3nzAEA +C4AA+DEIFa/6ygDAINEPwLAMiTTppggt8uYAANog/EBoHaAbxQBYFS3AINEPKxKE2iDrvBgpYASA +AFgVKMAg0Q/AoFko5RqNu4io+R/wYJAMpQBj/8UtIQn+QrAVr/8FAA+PAQ+JDOkkFC9xAoAA/2Bm +HeAJBQDptAAu7gKAAP+mAA6wDBUADN0CnbH81aYVr/feAAAAAAAA//awDaALBQDAMJPb8yBoHe/1 +igDAoFkoyhqNoIio+R/30JAMpQD//EQNoAsFAAAA68oMAYHRgAAKTBTtzAgpwASAAO1NNg3IBIAA +0w9t2QUIAIYJAmEpEoGqONMP7E4MBMkBAABt6QUIIIYJAmMtEoIsEoEK3QytzCzMQPzABhWv+ioA +AADAsAyONP9BBhWv+rIALxKBL/xA/sAGFe/5tgAAAABsEASGPo0/Go6yAmUMltCOPhiOrv3AJhXg +DAUAnD+cPiuCf/TZABWgAgUA5UI5AbjhAACXsZo/KYJ/mT4nhn/RDwAAAGwQBIoix43/QWAHk5qR +AAioAZgi0Q/InlkGBdug7CICKVAEgABZKHnRDwAAbBAEiSeInPQEYh3gJkUA8yYAFaALBQDiiQwE +QyEAAPkNAA3wI5UA8WOwDeAktQBgABGKvisKAOosDAVTIQAADKs5yrIssABzyectsBAqsB902d51 +oQJ2qdjaIFv/zeukAA1/FgAA0Q/RDwAAbBAEFY3rI1GI6FF3IYFJgACEIIUnKvrA6EM8cpCBAAD6 +QAQFMAkFAOklBCVRAQAAmiGaINEPjCf9hAAV784FAP+gBAawCwUA68UUJukBAACdyZ3I0Q8AAC9Z +FGT/wYVZZF+8I1AAwkp0ObQZjmOIVHmJrNEPAAAAbBAEKCBw0w98hxQqIAf6QAgV4KoRAFjs9cin +0qDRDwDAINEPKyBwLAr3DLsB6yRwLRAEgADRDwBsEATIMdEPAIgnJokUg4n1BAAV78cFAOdVAQMw +QQAA5oUUIZvBAADjhgkiqQEAAHU7HiqBFRuNGKOqmomboIkgwLHkpgIszgKAAAuZApmh0Q8cjRGc +MIsgwMHkNgIt3gKAAAy7Apsx0Q8AAABsEARkIKFkMJ5kUJsoIgIEBkcPAgDnjPscBH4AAOo8HyMl +bQAADGgRp4gpgp4KShT7IASDogCdACqCnWSgbRmNGO+M9R1ABIAA7Yz2EeB9AAD4AAgd5MwdAG3J +AggCYZ+gjiCcUJOj7aYCL3YCgAAOzgLupgElEEEAANEPHIzhichqkUcMaBGniCqCnis8HwtLFHuj +TCqCneSgSGTb/QAAm8hlr5hgAAPAINEP2iDrTBgpYASAAFgUPMAg0Q8AAAAAAAAA//3MDaAKBQDA +oFkn9RyMy4nIa5Gq//8UDaAKBQAAwKDA2g2dNP2BBhXv/tYAAAAAbBAKhzaGN/hA8BXvCgUA+uAE +A7/PBQD6wAQDN4UBAPkABOlRWQEAiyfAgCgmFIy4KrEV7rILJeiBAAAP3wH/QABFcAkFAOzpDnVR +AQAA0+D5YWYV4AGyAOi5FCpPAoAAmRSsngmICCi1FP9AEJKiAJ0AKRIE7KoMAYHRgAD/gGgdpIod +AOgWAiRAIQAA6Eg2CdgEgABtiQULAIYOAmGIEqo76EgMB/EBAABtiQULIIYOAmMKmwyr+yu8QJvQ +DMMCjCLIw8Ag0Q8AHIyQHo03iTQdjI0fjI/xIAju0gCdACsxCukxCyqgBIAA9KAQUhIAnQAMXBGv +zCjCnvcAJhHSAJ0AKsKdZKIoLCEHHYyGDAxKDMwRDcwCnKCMIPkZCgWgLQUA+UBGFaAINQDtpgMu +bgKAAAjdAp2hLSAE9aAQTBIAnQAsIScoISLpngkG6+0AAA3IOByNkh2NTpgT7FwCD3cCgACu3S3S +f+0WASzoBIAAnKQrpQv7GMgF55fBAPjGAAzwCAUAmKb7dKgV5/71APlA5hXohx0A+UFEHaMotQD5 +YA38Iyl1APlgEMRgCAUAHI18maropggq34KAAAy7ApupLSAHDS1ABt0QDt0CnasMTBH/gABGcAs1 +ACvGnY00xo8I3QGdNIsiwMEMuwL6QEYV4AIFANEP8SAFZxIAnQAYjEYPAgAognH32SgV7GkdAAaI +CAmIEQh3CCcmFPSgEQoQC+UADFwRr8wpwp4PAgDTD/sgHpPiAJ0ALcKdZNIwL+F6yPko4Wn4wBv7 +ogCdAOp0AAlYBIAA7DQACmgEgABb9x7pIgItA7YAAGWeVdog7CQAAthhAABYE47AINEPAOnEAAGA +sYAAyE4rEgRtSQUDQIYJAmWO0KvueukiKPxA+aAGFa/4ZgApIFTJmesiFClQBIAAW/dF0qDRDwAA +AAD/oAYVr/fmACogVWShsyvhemS979ogW/fV0qDRD8DhLiRWDp4CniKMNMfXDcwB/GCGFaACBQDR +D4rImRX3QBiAkgCdAAxMEa/MKMKe9wAZUdIAnQAswp1kwyEYi/ziFgclE/0AAJKIghfqxAAObt4A +AIkiZZ2N2iDsJAAC2GEAAFgTXMAg0Q8ALeLAmRMNzAwdjRYoIReYEQ3MAvxFkBXv+EoAiRMbjRH/ +uAAWMAgFAOimCCzPAoAADJkCHI0JC5kC6aYKKt+CgAAMuwKbqS0gBw0tQAbdEA7dAp2rDEwR/4AA +RnALNQArxp2NNMaPCN0BnTSLIsDBDLsC+kBGFeACBQDRD4sRD9kR+sAABnAIBQDopgguZwKAAP0m +AAyyy0EA95gAFjC7OQDsmQIN2wKAAAuZAv0Z1gWgCxUAC5kC6aYKKt+CgAAMuwKbqS0gBw0tQAbd +EA7dAp2rDEwR/4AARnALNQArxp2NNMaPCN0BnTSLIsDBDLsC+kBGFeACBQDRD4rI90AQIJIAnQAM +XBGvzC3CnvugELPiAJ0AK8KdZLINH4uqsK2d+O20AA3ungAA2iDsJAAC2GEAAFgTDsAg0Q8oIFZk +jDuKyPdAD5CSAJ0AKfKuZJIdK/KtZLIZsKqayOe0AAWP0YAAJtCAJmw3BkYU7wIAAzAdAAD0oAUK +EgCdAAxcEa/MKMKe9wAUS6IAnQAtwp3m1AAGj2GAACkgFKSZCQlHKSQU9SAPflIAnQAqIhTpMgQl +BMGAAMDI/SYADjAOBQD8YIYVrLkdAMCAKCRWjTDzoAR6kgCdACkyAeoyAitYBIAA6hYALI+SAADz +IBBgUAcFAByLdoonDFsR7LsICmgEgAD7RAAVoAwFAOe2nSpYBIAAWAvb0qDRDwD3QA/gkgCdAAxc +Ea/MLcKe96AQU6IAnQArwp1ksgEei2OwrZ3o/WBoHe/9NgAAAAD6AAId4BgFAPkmAAwwjoUA+GCG +Fa/9qgDaIPzAaB3gDEUAW/XI0qDRDwAAAAAAAAD/7QQNoAoFAAAAANpg61QADuAEgABYAkjrVAAJ +UASAAOyMgxtoBIAAWA5ewLErJFaJNMenCpkB+GCGFeACBQDRDwAAAAAAAAD/8MQNoA0FAPogxhXg +CgUAWSZlGos8H4s8ixaKqIkVHovg+V/msJIAnQD/88wNoAwFAMDAwIoIqjQYizL7AQYVr/OGAMCg +WSZYGosuiqgfiy4ei9P5X+9gkAvlAP/4BA2gCwUAAADAsB2LJ8DKDKw0/aEGFa/3tgDAoFkmSxyL +IYrIHYsfH4sg+V/v8JIAnQD/+BgNoAsFAI0iZdoe2iD8QGgdoBvFAFgSgcAg0Q/AsMDqDqo0+4EG +Fa/3hgAAjyJl+fjaIOtcGClgBIAAWBJ3wCDRDyohCfpCsBXv/AUADJwBDJ0M7SQULdkCgAD84GYd +oA0FAO10AC1WAoAA+0YADXAIFQAIqgKacfn1phWv924AAAAAANog7BIAK1gEgABbmI+JMQyrEetr +CA04BIAA8T/v4FIAnQDsEgApUASAAFuYX/dAAEP/96YAAAAAAAD/9egNoA0FAMCgWSYTGorpiqgf +iun5X++4kgCdAP/4MA2gCwUAAMCwHYrjwMoMrDT9oQYVr/fmAGwQBBKMCfJP6BWgAwUAhCGJIJlA +iCCUgZMg4yYBIRPhAADRD2wQBIooiacomRTrkgkkAbGAAP1ASBXgDwUALyQF/kCGHe/+5QAO3QGd +ooyxwNPzQoYVp8wBAFv+BdKg0Q8AAAAAAAAA//8oDaALBQBsEAguIASVE/XAGKOQF3UA98AZjGAl +1QCMEwwMRywWBPWAC1ESAJ0AKzAQ/xfiBeAttQD9YCZsYAgVAPVgKAxgPiUA/2AP/CAmZQD3YBS8 +IgCdAIoUKSAH9UAMyRGZAQCKIsCw6xYCLSOGAABvQ3AtIQgei+D17LAV4AoFAPvskBXgDIUAbcot +4FEEBVAFAADuXAoMMAqAAOawFXZgCwAAJ8EHJsEId9MH/MAGuuIAnQCxVQUFQvggxhXgBwUAwKX9 +F5wFoAsFAO50AAr4BIAAWSgwFovHiRblZGUrqKYAANVA6RYBLMcCgAD1IAkyEgCdABqKh6qIK4Ke +9WAnU+IAnQAogp1kg8EpIAcditAJLEAKzBANzAKcgIogG4qF64YCLVYCgAAKWgKagfSAITViAJ0A +jTANDUfthgMkSEEAAI4U64sXEcBBAAD5wCIZUgCdAOhBDWJT/QAAbakFCACGCQJhwDCGERiKagxm +EahmJWadLyAEzPcoIAVlgAJkNUjSMNEPwHH4IMYV7/zSAIknhDL1JkAN57TBAB2LmB+Kgyg8CP2t +gBWgqiUA6dx8J/ALAAD7YCPMIgCdAA8Ahw4CYeMGAA4wBIAA9oJoHaPk4QBt6QUIAIgJAIoN5hG/ +ZAREFObUbyIgBQAAJNRz84BoHe/46gCGJ4psJmww91/zBCIAnQArrMhkvlXAofogRhWgCyIAG4o+ +irj3QCPYkgCdAIgRHIo7DIgRrIgsgp71gCRD4gCdACiCnWSEf7CsnLhljsRgAoONFPm/8DlSAJ0A +KSAiZJBJJiAHGorQBgZB+sAAgzAKBQDqJCIjMAsAAC5hBqnuLmUGKSAiZJRuLfIyiivg0QQE4/0A +AODMGgxYCoAA7KoIBdv9AAALqgIqJgopICD+QLAVoApFAAqZAikkIPnf7PFSAJ0ACQtD+X/snVIA +nQDAwOwkIClQBIAAW6Yf/xaOBeAIFQDA0C0kFPxAph3v9cYAjhT53+s5UgCdAIknZJDiipzH0+wi +AiTIwQAA+UAE3WAOxQD/gAX2IgCdAA3GAfZARhWgAs4AAAAAAOokAAnYBIAA7EQACugEgABb/yDs +IggtB54AAIjCZIDpwCDRDwCPMv0WXAWgClUA/EAIFef/wQD+IKYV4DsFAFknjYgVwmb3AAi0IgCd +AMJ79wAJJGIAnQD1AAmkYgCdAMOSeYm66iQACdgEgADtEgMqYASAAFjqFMAg0Q8AAAAA7sAKdVsh +AAANygEqJgLJuSywAA8CAHXBXI2+wLDtngwG6yEAAA7bOWW/5NogW/ym/xYQBeAIFQAqIAXxRhAN +4AmFAC4gIAnpAikkIPlf4xlSAJ0ACQZD+N/ixVIAnQDAgOgkIClQBIAAW6XQwIH/FfAF7/seANqQ +mhBb/D6JEOukAA18bgAAY/+gK8AHCwtB67wYLlAEgABYER7AINEPAC7y5orhjOCcoIvghiD7YCYV +oAwFAJzg7OYBJ1P7AADmpn4nc+EAAJ4n+EQGHeANdQAtJAX8RCYdr+9uAAAAAADqJAAJ2ASAAO0S +AypgBIAAWOpKwCDRDwDqJAAJ2ASAAO0SAypgBIAAWOoRwCDRDwDqJAAJ2ASAAO0SAypgBIAAWOn5 +wCDRDwAAACucGOokAAlgBIAAWBD36iQACdgEgADtEgMqYASAAFgNeo0iZd5PjhJk7kr6QGgdoAsF +AFuk38Ag0Q8pMB/CY/c/8ZwiAJ0AwnT3P/FMYgCdAMKl+z/w/CIAnQD6QGgdoAslAFgB9sCB/xVe +Be/sdgAAAAAAAAD6QGgdoAslAFgBwMCB/xVQBe/sCgAcih0eiqv6QQQV4CYFAPcAZhWgDwUAn4X/ +AOYV4dkBAO6GBi7sAoAADbsC7LsCBEiBAAD7AIYV7+7SAACMJ4rMjaGPoJ/QjqD9wCYV4A0FAO2m +ACZgwQAA7aYBJUNhAABtSQUIIIYJAmMtsmIZioia0ZmhKLJimKAqtmKGwMAw7GgMAzMhAAD4zQAJ +v+4WAAAAAAD/7GQNoAgFAMBT9IBAAv/rsgAaihv2QPAVoYSBAKqKKqCA9EEEHaD5tQDpZgENV4KA +APrGAAsw+cUACWYBCGYC9kDmHa/tugAkMQsPQIfuTAACU+EAAPKQaB3jqgEA50z8JVPxAADqdDgO +UASAAPqSaB2gFgUABk42/m4ADT/35QB3oQqyr235BQhgiAkMirKmDWYRv2T/sWYdpEQdAObUbyIg +BQAA9a5mHa/tbgAAAPggxhXgCgUAWSRDG4kairiJFvlf25iSAJ0A/+4oDaAIBQDAgMDKDKw0/WEG +Fa/t7gAtsYjJ0y+xd44gf+sMiCcmiRTIZCmCCWWanNogWACx0jDRD4sp+kFGFe/uugAAAGwQDhiK +Qx+JN+SJNhpYBIAAjYKJg+6CASDgQQAAnsGZw53C6IIAKVAEgAD5gAYVoA0FAPQgJhWgCAUA+CAG +FaAOBQD4IEYVoAwVAFgMucDQ/gBiHaAPBQD5E1YF4AwFAOwWAS1YBIAA7BYCKVAEgAD4IAYV4AwV +AFgMrSoWEBSI6+msCC1YBIAA/xIUBeFjAQDzEygF4AhFAO8WDyk+AoAA6HcCBWiBAADoiUsVYMEA +AO8ABQDwgQAA7gwACS+CgAD/EboF4A4FAPimAAqwCCUAbYp4ih+UsOe2ASyQBIAA+gQKFaAohQAC +AIr1YMYV4AIVAJ+0+WCmFaAKBQDuKjgEyQEAAOvoEQ1WAoAA6ogCDhAEgADoaAIGYQEAAOOIAgdw +BQAA6LYHIMBBAADoCx4O0ASAAOpMAADAgQAA6AceBukBAADiLAAF2QEAACISECgKgKgi0Q8AbBAM +H4jiFYjhGYjYHYnrKCAH40IEKdgEgACM0YbS6tIDIPBBAACa4wkzAZbi/cAmFaEoAQD9oAgV4AwV +AP3ABhXgBgUA5hYAKdAEgAD2IEYVoA0FAPQgJhXgDgUAWAxewMH/EqQFoA8FAP4gJhXgDQUA7xYC +LVgEgADuFgAp0ASAAP4AYh2gDwUAWAxTH4k/GIj8HIiy/GAAErAGRQAGVQLjiI8Zp4KAAPMRFAWh +YgEA/CHmFaANBQDoRAIFSCEAAOwABQDYgQAA6wwABWCBAAD7RgAV4AglAG2KeIgfkqDlpgEs8ASA +APgEChWgJ4UADgCK9UDGFaAOFQCTpPdAphXgCAUA7eg4BMkBAADr1xEMRgKAAOh3Ag3wBIAA52cC +BdkBAADvdwIG6AUAAOemByC4QQAA5wseDkAEgADoTAAAuIEAAOcHHgZhAQAA7iwABVEBAADALtEP +AAAAbBAEHYj8HIj8iyco0Yj/rAgV7/n1APlgBhXgDgUA7iYHJcghAACZ8ZyzKtJgmrLp1mAkAGGA +ACvRd4oge6MB0Q8pIRpulAnZ4P5DRB2gAB4AaJPqwMEMnAIMDE/sJRouH3wAAC3RgA2qDFiZW9EP +AGwQBCsgB+yJcRlQBIAA+iAABfANBQBYC0zRDwBsEAYnIAcdiDMZiDP5ELwFoXcBAOwyBCu3AoAA +qWb608gVoA7lAATuNwjMAf9ACoOgC6UAKmKd6KQABQp5gACK2JcRmBD3QAq4kgCdACiSrmSA9CiS +rWSA8LCr69YIJAexgAAqIBSkqgoKRyokFPVACoZSAJ0AG4jyGIgcjRArsX/uiB0btwKAAPjAAEN3 +VQEA68NXdshBAACPMJjQjCCwSv+gRhWn/wEA79YDLmYCgADsTAIBwEEAAOzWASIMNQAAbakFCACG +CQJh5GadIpXVAAAqIgf6gGgd4AwFAOqsICpoBIAAWAhq0qDRDxyIJos07LsBCVAEgADrFgMqaASA +AOsSACngBIAAW/9DIxID6madIpR1AAAqIgf6gGgd4AwFAA8CAOqsICpoBIAAWAhY6iQAC9gEgADs +iScZ6ASAAFgK+sAg0Q8AwIALrjTu1ggseJYAANog/EBoHaAbxQBYD0fqJAAJ2ASAAOxEAAroBIAA +WA1h0qDRDwAAAAAAAAD/+swNoAoFAAAAK3wY6iQACWAEgABYCbRj/8YAAAAAAPwgRhWgCgUAWSLz +HYfKjBKK2IcRGYfJ+V/0kJALpQBj/5ImIQn6QrAV7/0FAA2tAQ2vDP5Chh3gDgUA7YQDLdkCgADu +hAArNgKAAPrGAAtwDxUAD2YCloH/NaYV7/nqAGwQBIUg4lQMApshAADAIAQyOdEPbBAEKiAgKwrz ++0AEBXAEBQDqJCAhlJ0AAGkxGP9CoAeQ/NUADKwBLCQg2iBb+l0tICBk0G7RDwAAAAAA/16gB9AD +FQAuCv4OrgHuJCApUASAAFv6ciggBxyIPvhEUBXhiAEADIgJ5CQiJEALAAAvgQap/y+FBikgIoor +LsKP5JAvZOv9AAAA4QTg3RoJ2AqAAO2qCAXb/QAAC6oC+kFGFa/+KgDaIFujliQkFCQkBdEPjyn+ +QUYV7/3OAABsEAQqIAXAiNMPeoM6Foi+8USgDeAFBQAqICDzRECF4AQVAAOpAukkICGVzQAA2iBb ++i3aIFv6ESogIAoKQWqjUdEPAAAAAADqJAAJ2ASAAFjnTGWv6vpAsBWv/s4Aiydlv7QsYtmOwYjA +mOCPwI0gnvGVwOXGASZz+wAA7eZ+JmPhAACcJyUkIPREJh3v/i4AAADaIFv57iQkBdEP2iBb+jAq +IAcch/v6RFAV4aoBAAyqCeUkIiVQCwAAKaEGq5kppQYpICKLKy5iJeSQImTr/QAAAOEE4N0aCmAK +gADtuwgGY/0AAAy7AvpBRhXv/QYAjyn+QUYV7/zeAABsEAqUFSogB4kwlRL2YhAVoaoBAPogZhWn +mQEAmRT0wA7UkA61AP7ADxQgDwUAnxGIIhuHNfogaBWgCQUA6RYALAweAAAXhzHqFgYtTwKAAPVA +B2IQDKUAp5ktkp60Tv+gHsuiAJ0AJZKd7YfMEo4BgAAqChr6wAfcIgCdAC4gBOiyCCcIwYAA9wAa +4JIAnQApcq5kkRMpcq3kkQ9kU/0AAOq2CCSIkYAAKCAUpIgICEcoJBT1ABouUgCdAPTADEwSAJ0A +ihIchxkehxWeUIsgjRTtVgMiyEEAAOxWAi3eAoAA60sCAcBBAAD6oCYV56oBAPlACxlSAJ0A6EEN +YlP9AABtqQUIAIYJAmHAgI8w8+ANMpIAnQCLFuoSBS3fAoAAp7sqtp0pIATxIPwN4Ay1AHxhSC0g +BczRZIOv0oDRD4i49wAaMJIAnQCJFgyZEaeZLpKetE//wBqT4gCdACmSneWUAASaeYAAsIr7YQYV +r/vuAAAt0Yhk3wJgA0Eeh4cu4Yhk760Zh4WPICmRd3n7otogW/6hwCDRDwAA6iQAClgEgABbo3tj +/xHAkAyKNOq2CCz3tgAA2iD8QGgdoBvFAFgOO4sRZLKq6iQACdgEgADtEgIqYASAAFgKvYwiZc+0 +jRBk36/6QGgdoAsFAFuiIsAg0Q8AAAAAAAAA+kBoHaALFQBb/z9gAAwAAPpAaB2gCxUAW/8MjhIO +Dkf1wBGREgCdAMDx/iAmFe/4GgAoIASLE+WCDWXYYQAA6iQACWAEgABYDhtj/3raIFjnimSihIwi +ZM5tY/9qjRHoIgcmlmmAAIuMj7GMsJzwirD/QCYV4A4FAO62ACRgwQAA7rYBJcNhAABtSQUIAIYJ +AmEeh0Mp4mIYh9ObkZixL+Jin7Ar5mKNwMCA7N4MBushAAD/rQAMP/lqAAAALyAHKiAEHIbi/EAI +FeC/EQDkWQgN2oKAAAy7AuSibm7mAoAAHoayK5QS+w0kBaA/BQAvlB77I0YdoA0FAP0jph3oux0A ++yImHeANBQAtlBv7D4IFqLsdAPsiBh3gDwUA/yOGHei7HQArlA/7IyYdoA9FAA/PAi+UFvsOhgWo +/x0AL5QV+yMGHaj/HQD/IoYd4IoVAPsi5h2o/x0A/yJmHeANNQDuAAUE2H0AAG3aAgsCYR+GuByH +qRuHqRqHqi4hCPRA8BXg7QUALZQnKpQo+yUmHeFVAQDslCoqrAKAAPXGAA9wBSUABFU27+4CBOC9 +AAD/JEYdqO4dAP8kJh2o7h0A/yQGHajuHQDulB8uWASAANMPbVkFAyCGCwJjwKDqxAYiSBEAAPgg +phXv9M4AwKBZIXAbhkaIuPkf5NCQDKUAY/25LCEJ/EKwFe/+BQAOjgEOjwzvJBQu6QKAAP8gZh2g +DwUA75QALmYCgAD9hgAOcAsVAAvMApyR+vWmFe/yFgAA//CoDaAFBQDqJAAJYASAAFgIE2P9cY8n +iPwv/DD/H+48YgCdACmMyGSdvMCh+iAGFa/1cgAAAADqJAAJ2ASAAO0SAipgBIAAWAup0qDRDwDA +oFkhRxuGHYi4+R/lgJAMpQD/7yANoAUFAAAAAAAAAP/yxA2gCQUADI00/WEGFe/uvgDqJAAJ2ASA +AO0SAipgBIAAW/3Z0qDRDy4gBfnf66RSAJ0AwPL+QKYd7/WqAAAZhqwpkYjoFgckgUmAABuGqIog +K7F3mBd7qxeJJyyZFOgWByYAeYAALZIJ6BYHLuEOAADaIFv9oYIX0Q8AAAAA/SBoHaALFQDqjCAq +aASAAFgGYflAaB2v7yoAE4aJ5CEIInANAAD+IKYVqKsdAPsiJh2hXwEA+yJGHeiqHQD7IgYdoAsF +APsjZh3oqh0A6pQPKqwCgAD0hgAKcAo1AArKAhWF5yWUGiqUFgNMAvOmAAnwJAUAJJQe9Q42Beiq +HQAqlBX1IyYd6KodACqUFPUNQgXoqh0AKpQT9SMGHeAKBQD7I4YdoIUVAPUi5h3gBQUAJZQdiimL +KyUgFCyUIiuUNuOUKiqqAoAA+yZGHagzHQDzJSYd6KodAPsmJh2oux0A+yamHehDHQD1JQYdqLsd +APsmhh3oqh0A+yYGHai7HQD7JmYd6KodAPsl5h2gAwUA8ySmHejkHQD/JOYdoAQFAPUkxh2gDgUA +/ySGHaADBQDzJGYd4AoVAPqmAAq4PB0AI5Qh9SXGHejDHQD9JAYdqFUdAPUlph3o7B0A/yPmHahV +HQD1JYYd6FUdACWUK/RChh2v6eIAAGwQCogiHYafKyAH7DIAIkv9AACZFfgghhXhuwEA6xYGIngd +AAD9gAQGcA2lAOwWBywHPgAAiRYWhYwMmBEGiAgugp4chYgpFgP/wAgb4gCdACmCnSggBOeUAASH +6YAA6RYAJAUpgACIyNMP9wAV4JIAnQAuYq5k4LYrYq3ksLJke/0AAO/GCCWFqYAAKCAUpIgICEco +JBT1ABUuUgCdAIkXHYYKG4YL6oXQHIY2AAD4YgAVp8UBAPmAB1lSAJ0A6EEPa8gEgACwSm2pBQgA +hgkCYcCAjxWOFwz/Ee93CA8KvgAAiTDzIAyikgCdAIsT6hIELd8CgACmu+q2nSwQBIAA0Q8AAAAA +AOokAApYBIAAW6H3Y/+IAADqJAAJ2ASAAOxEAAroBIAAWArX0qDRDwDAsA2ONO7GCC36ngAA2iD8 +QGgdoBvFAFgMsWP/ygAAAP/8AA2gCQUAixbkgiJl2GEAAOokAAlgBIAAWAcjY/+nAIgWKIwU+wAE +ANAPFQDsEgAv+AqAAA3/Av9IBhXgDiUAbeoFCwCGDAJhhxD25AAV7/w+AAAAjieeEYjp+8KCFe/K +BQDs4RUnKIEAAApaAZoS6soICk8CgADpuwwEQEEAAJjpCLsy6+UUJVEBAAD7ABCKogCdAGibRqic +6xYIJmPBAAD9QAzbogCdAOhBH2vYBIAAsE5t6QUIIIYLAmOMUS9ZBAycCO8WCCZjwQAAixj7gBJk +IgCdAOxWAS5ABIAAZb6gYAGgiRbTD/kigBXgDxUA6YVpHIEKgADrhaEf+AqAAO3/AgvgBIAA/ygG +FeAOJQBt6gULQIYMAmWKFeqsBCO4gQAA+iCGFa/5qgAuIAQvIAeNIBqFR/sKAAXgnxEA6NwRDMqC +gADqmQIHCyGAACt2Ah2FGPjgBhXgPwUA/uBmFeAORQAOzgL+4CYVoAo1AO0ABQPIQQAAbaoCCQJh +HIU2LSAHKyEI/wxMBaAKJQD1QQANMd0BAO52Bi7sAoAADbsC7LsCA/iBAADrdgQvyASAANMPbakF +A2CGCQJnixTAwOz0BiXYEQAAjBMMzBGmzOvGnSwQBIAA0Q/AoFkf9hyEzYjI+R/p0JANpQBj/fwu +IQn+QrAV7/kFAAmJAQmKDOokFC/5AoAA+WBmHeAKBQDqtAAvdgKAAP/GAA9wDRUADe4CnrH81aYV +7/SWAAAA6iQACWAEgABYDCBj/YkAAAAACKwM+uBoHeT8HQBt+QUIgIYLAmmIEgx7CA9PDOiMQCeM +QQAAKvz/bakFCKCGCwJriBIrWQQMmgyqiCiMMOhWAS3oDgAAixLAwOxVBCXZAQAA+qAmFeAIBQD6 +oAYV7/OWAI4RDIgM+cEmFa/3qgCZcJty9EEEFeAkBQD04GYVoA41AP+GAA8xrwEA7nYBLVQCgAAK +VQIehSiDKyQgFA7aAg5VAo4pmnaeeOV2BCoiAoAA8uEmFeAFFQD0hgAKcAMFAJN1lHcjJBSCFLMi +gxMMMxGmM+I2nSwQBIAA0Q8AiBIojED4oCYVr/beAAAAAGwQBGhDBmhCPsAg0Q8oIAawiAgIR+gk +Bix/hgAAiSIsMAHHrvsgBASw+9UA6SYCLhigAAB7ydH6QGgdoAsFAFufxcAg0Q8AAOs8EClQBIAA +WOXvwCDRDwDqJAAJ2ASAAFjl/8Ag0Q8AbBAG+QpiBaKpBQAJKSgchaH5AABEcApFAOWCfyHYQQAA ++2AEANAJFQDgmRoJaASAAOlVAgnwBIAA5YZ/KngEgAD0IAYV4CsFAFkh7tog6zQACmAEgABY/IvA +INEPAAAAbBAIHIWNlxAoEhEpEhD4IIYV4CsFAOkWASloBIAA6BYFKtYCgADoFgIqfAKAAOr/Agnw +BIAA/sYAD/AKRQBZIdn/CSoF4AcVAPkK+AXgDQUA+wr2Ba/89QDkQJdn88cAAGhBBcYq0Q8AACQq +oAQkKAM4Cq5LjhWvROuICwmBCoAA6YcIC9gKgAAvEhKIFOkSBS93goAAD+847+84BAZhgAAvdXoq +Qn8YhWcKugIqRn8pdX/odjsihkmAAGlRpYoUixVZI5P8AQId4AwFAFkivPwAAh2j7YUAWSLH2iDt +cXot4ASAAO5CfynYBIAAWPCWwCDRD8eP+mAEANKsBQDsLCgL2AqAAAi7A6/EKEJ/rswLiAEoRn8D +OwoMuwupuyq2O+21fyKD8YAA+L/5uNIAnQCKFIsVWSN2/AECHeAMBQBZIp/8AAIdo+2FAFkiq9og +7kJ/LeAEgAD6YGgd4A0FAFjwecAg0Q8AAC5Cfwy/Aw/uAS5Gfy11f+p2Oyr5/gAA+N/3ANIAnQAt +cXrsEgQpUASAAO5CfynYBIAAWPBrwCDRDwDJbfjf9djSAJ0A7BIEKVAEgADuQn8p2ASAAFjwYsAg +0Q/aIOwSBCnYBIAAWIJ4wCDRDwAAAGwQBikwAmSQdvUgBNiSAJ0A/SDAAV/ipQDRDyIwBvkIUAWi +qQUACSkdqYgogn8kMAXjMgMkANmAAMCk/QoaBaArBQBZIWLGKtEPAAAAAAAA+gCCHaArBQDshQcZ +aASAAO5EAAn4BIAAWSFYZEChaUHU6iQACdgEgABY5VjAINEPKjAGKzAHLDADLTAELjAFjzKIM5gQ +KTEJmREoMQqYElv/YtKg0Q8AACIwBiQwB/8I8AXipQUABSUd/QnQBaAKRQD14ABH8CsFAOnyfyIo +QQAA+qAEANAOFQDjMQgvcAqAAO6ZAgloBIAA6fZ/KnAEgADpFgAp+ASAAFkhNNog60QACeAEgABY ++9HAINEPAAAA6iQACdgEgABY5WrAINEPAGwQBMAg0Q8AbBAEJiIR0w/wwyAN4AUFABqDhigiEucg +diVIQQAAbQgZI6J/IpKEqFSkMwkzEaMi5yQWIqgFAAB2WwJj/9/RD2wQBAXqMBaD1ihiRcCVCSk3 +CYgoFINz+KAAQrAAWgAABqgKiIALgAAJ6jAJWQxqkRAqQoIKOgEKGo5lL+Jppt/RD9EPbBAEIiEF +0Q9sEAYVg3L0AAIdoAYFAP8JWgWgBwUA+GBoHeAMFQD4IAYV4AMFAP/PxBWgAN4AAAAAAAAA/MBo +HaAKBQBZIuKOEo8RCzMCCncC9+AAQzAMFQDlXAEiIAUAAOhJL2EQEQAAAEAEDggbf4fmiyBosCwq +UDAAoQTuFgIuSAqAAPogJhWgmU0Ae5CrxirRD4sQk7H3YAYV4AIFANEPAAD8gGgd4AolAP0JEgWg +CwUAWSDaxirRDwBsEAQEAIfIVgIjYAQAYdEPAiNg0Q8AAABsEAQpIQImIQSEIPRApBXgCAUA5mz/ +JMv9AADpJQIrNwKAAOZECAqvAoAA9I8ACnAAvgAlIQUmIQSxVfRACBWvVQEA5SUFI0v9AADlYSl8 +zwKAAOlECAq/AoAAB0QMBACHCFhg5AAHAvMvgAAiIQUJIhGiUtEPAAAoJQX//1ANoAUFAABsEAT1 +CLwF4qgFAAgoKKhVLlJ/KVJ8c+ECZJAE0Q8AAADApP0IrgWgKwUA7SQACfgEgABZIKUjVn/qJAAJ +2ASAAFjwChaEMypgAP9c4A3gBAUA2iDsNAAKWASAAP6viBWgDQUAWO+BK2AAsUR7Q+Jj/6kAAGwQ +BCkgB4giLSEH/QXiBaGZAQDrlAAMBI4AAAyYEayIKoKe9UAE26IAnQAogp0agu3vgu8UBGmAAI4y +KSAHDQ1K+AIABPfuwQDg7hEMyoKAAO6ZAg7vAoAADZkCCpkCmYCNILBK74YCLXcCgADuhgMu7gKA +APyGAA73lQEA7YYBLJVIAAD5AgAV4AIFAOg8ECIMNQAAbakFCACGCQJhDL4RrO4k5p3RD+okAAnY +BIAA7EQACugEgABYCE3SoNEPAAAAK5wY6iQACWAEgABYCilj/9SHJ4J5+uKkFa/GBQDleRQj6IEA +AAbWAeajCApPAoAA6VUMARBBAACSeQhVMuV1FCGZAQAA8kAFUuIAnQBomzqimiqs8OozQHQ4QQAA +6EEfa8AEgACwTm3pBQIAhggCYSrSAQ8CAKqa5dkEJVPBAABzoXrq1gEtEASAAGRQTAy9EazdJNad +0Q8AAjoMCk8UbfkFAiCGBwJjD0IM6o4IA0EBAADv7BAhDEUAALAu0w9t6QUIQIYPAmUv2QQKkgyi +YiIsMOLWAS/9vgAAwCDi1QQjQQEAAJjQmNEMvRGs3STWndEPCiIM8uEmFa/9TgAibEDzoCYVr/4a +AAAAAAAAbBAE5IOpERghAAApQn8YgyGTkZgjJUJ/lSIjRn/RDwBsEAYWg8cYgvQqYn0pYoUmYovo +gH0tVkKAAPsgAESwigUAqmbmYLQkfDCAAPsgAEOwACYAJyqAp5f2wAdIkgCdANRg9QdwBeADBQDw +AZgNoAIFAAAjpDUuoAyNoPlA8BXv+PUA+ULGHaAMBQAspRn9B1wFoPvFAAuZAQkpAimkB5ISnRGT +EPiwEBWgOwUA+CBmFaAKVQBZH/MpUIAAMAQJCRt/n2riLAEhmAUAAONhdXIgBQAAG4OaL3ANKrJ0 +LXAMK7KFqkzqOggOZkKAAOy8CA1WQoAAq6qcr/1Bhh3l3sUALqUYL6QNKVCAACAECQsb83/6/9IA +nQBtCA+xIgAgBAkMG/Of+mfSAJ0AY//pAPoAoh2gOwUA7IOFGegEgABZH9Bj/37RD2wQBIgnG4JT +9QKCFe/HBQDiggkpMASAAOmBFSQggQAA50QBAqiBAADlhRQhE4EAAOKGCSIhAQAA9EESDaAKJQCi +kpKJCwCH7YImGSgEgADTD22qAgUCYZ0gjGDA0uMmAi5mAoAADcwCnCHRD2wQBBiC7RWDK44rLSIO ++kGIFaADBQDsUsgvWASAAPmgCEQgVGUACdkR6cwIBQNRgACeq4sryLCavJMr4yYMKVAEgABbnhGM +J/uEABXvxgUABrsB48UUJdkBAACbyZvIKiAFIyQV9UAJBCIAnQAsIAf1BboFoEj1ACgkBStRZuRC +fylQBIAA/CAAArK7HQBYfZZkoQzRDwCJyXKZU+7GCS9YBIAA6sAFJYAxgACTvMSye6mFjcnuwgsu +/AYAAGXvePuACBXgP/UAL8QFLlK0+rloFaANFQD/bwANsAwFAFgKDhmB2YifsIj5IeYVr/02AInL +ispymQaey4srY/+lcqkK2+D/gUYVr/52AAAtIAV02ZEtITb+RuQVoApVAP0GPgWgOyUAWR9q0Q+P +LQn/Ee/MCA139gAAiMvzAAatIgCdAJ7LiyvIsJO8KcAFw6D7P/c9IgCdAIvLZb7djcxl3tiOzWXu +0/uACBXgL7UAL8QFLlK1+rmIFaANFQD/bwANsAwFAFgJ5WP+ry0hNv5G5BWgClUA/QYGBaA7JQBZ +H0zRD40nGoMAmkCI24kgLNEV69IIJvCBAAD3wAQHsAcVAO/MCAzOAoAAB5kCmUHrgWx2YQEAACjZ +FCiMEOjVFCXQQQAAesNeZEALBACGCwJhKtIIKqwQ/UAEhCIAnQCa4IsiZb6Q2iDrXBgpYASAAFgI ++NEPjc1y2Qnb4P+BphWv/KIAj8zz//j1IgCdANvg/4GGFa/8UgAAAAAAAAAA86FmFe/++gDrzAwC +AZGAAAxNFLjY6Hg2CkgEgABtiQUJIIYLAmOsSer8QCaMSQAADXsM0w9tuQUJQIYKAmUM/Qwt3FD9 +wAYV7/3qACj8QPnABhWv/b4AAGwQBPhACBWvyQUA6SkBAYJJgADTD20ILnOBPCowACwwB3ShMyoh +BemrCA5nAoAA7DMIBdkBAADrOxV5uASAAON0AAOAqYAAY//IAAAAAAAA+m8AC7//rgDzDwAPcA0F +AA7TONIw0Q8AbBAEKSAHG4GhJyEI+AIABXGZAQDogecczAKAAOl3Ag1SgoAAC6oCG4FS+mAGFaAs +BQAIdwKNIJsy/GBmFaAONQDo2AIO7gKAAA7dAp0xiismIBT4QSgV4AUFAJU1lzSYNpk46jYJKzIC +gAAGRgKWN+UkFCGQwQAA0Q8AAGwQBCQgIhiBxvJBaBXgBRUA5EAhYjP9AAAogn8AgQTgZhoKqAqA +AOYzCAKr/QAABTMCkyrRD4kpmSrRD2wQBPUDcAXgBBUAJVJ/hiuDKQBRBPyAAQPf+PUA5jIMA7v9 +AAAIdwMHZgHmMwwKggqAAPKNAAkxM50AoyLRDwBsEAYoIAUqIAfTUPkABYxRqgEAjSuMKf2ABS1i +AJ0Ajycv8RTB4P/ABLPiAJ0AF4EKDKkRp5kokp73AAVZ0gCdACmSncBh8SpgDeAFBQAegQotIAcY +gZkbgU/8QQQVoP0RAPXwABex3QEA6/8CDuwCgAANzAIIzAKfkPxACBXgKwUAm5P/IEYVoAs1AOjY +Ag7uAoAAC90CnZGPKS0gFI4rnpmfmJiWnJTllgUu6gKAAAbdAp2XJSQUDKwRp8wrxp0DDkdp4gTA +INEPAIon+oBoHeAMBQDqrCAqaASAAFgBTNKg0Q8AAAAA//1gDaAJBQCLImSwjAMMR2nCbYknLpkU +LZwg7hYAJwOJgACKmRSCKfFH8A3vxwUA8AAcDaAjpQBkoG+L0OfeAQUBmYAAerErL6AAc/ElL9EF +KaAH7vgIDM8CgADpqggEQQEAAOirIH1gBIAA6sQADn6uAAAKvAwMWjjKrY6idOm2wCDRDwAAAP9P +AA5//4IA//5EDaAKBQAAACusGOwkAAlQBIAAWAgbY/9hixCK0effAQXYQQAA69UEJVPBAADq1gEn ++QEAAH+rIizRBR6AsqrKmtGeoI0g5KYCLu4CgAAG3QL9QCYV4AIFANEPHoCqnqCNIOSmAi7uAoAA +Bt0C/UAmFeACBQDRDwAAAGwQCCggBSYgB/qAaB2gGTUA6hYGKqAEgAD5AAwVYWYBACgiAvEZHA3g +CgUAE4CODG8RA/8IK/KeBmUC92AR/NIAnQAn8p1kcjT6QGgdoAslAFkbvemAgx0R+gAAKpII90AP +CJIAnQAoMq6VFA8CAPcAD8tSAJ0AJTKtZFHwK6z/K5YIZFHQHoEQ/MKAFeAMFQDmgQ4egQqAAO2A +0h5gCoAADswC7BYFK9AEgADs1kArSASAAAkghgoCYwkAhgoCYRiBwfpACBWgCQUAKRYAKICA+uQA +FeAMFQD/AiIF4A0FAOkWAixAQoAA+CAmFaAe5QBYBCL2IKgV4A8FAO4iCS1YBIAA+kAIFa4NBQD+ +QYYVoAwFAPwgJhWgDBUA/CAGFejuAQD72AAXMA0FAP4gRhWgHqUAWAQRH4CrJ/ZABmCGCgJnBkCG +CgJl6RIEKVAEgAD8ACId4A4FAOUhCSrYBIAA/yAAFLD/9QDzIABE8AilAOiWnSrgBIAAWJCMLCAV +/AgCHeALBQDrJBQq2ASAAFjf+8DW/HWmFeAcRQAsJAUEDkdo4gwvIDrAj/ngB/QiAJ0AwCDRDwAA +AAQJR2mS8oknJ5kU5HB0ZPCBAACLmRWBfvFuwA3vxgUA98AEB7AkpQCM4Mq9e8ErLbAAKbAHdNEi +I+EF7zgIDM8CgADpuwgEQQEAAOi7LH3oBIAA69QADv6uAAALzQwNqzhksKOPsnXxj+bvAQ393gAA +YACTAAAAAAAAAPNvAA7//1IA//44DaALBQDAoFkbLxmABSqSCPlf8KCSAJ0A2iD8QGgdoBvFAFgH +af/9RA2gCgUAwFDAigioNPkhBhWv+DIAAAAAK2wY6iQACWAEgABYB1///KQNoAoFAAAAANog/EBo +HaAbxQBYB1n//EQNoAoFAIonjRbAwOqsIC7YBIAAWABY0qDRD4rhK3wQK+UE5usBBVPBAADq5gEl +2QEAAHurJCzhBarKmuEef+qeoI0gwOHlpgIu7gKAAA7dAv1AJhXgAgUA0Q8ef+KeoI0gwOHlpgIu +7gKAAA7dAv1AJhXgAgUA0Q8AbBAEJSAHKCAiF4Bx8w8ADHFVAQAHVQnoJCIiqAsAACRRBqNEJFUG +IyAiiSv88egVoAoVAOQwHmHb/QAAAMEE4LsaDVAKgADrmQgFU/0AAAqZApkq0Q+NKZ0q0Q9sEAQo +IAbojP8pUASAAPhAxh2gCxUAW5sPwCDRDwAAAGwQBPRAhBXlQx0A4iIAKieCgAAMVRGlIgQiDCIt +//JH6BWkQwEA+oAEANAFFQAAVRrlIgEKAgqAAAICGdEPAABsEASIMw8CAAiIV2+EBIkiZZAniifl +MgQqWASAAOMyBSpoBIAA+0QAFaAMBQBYAATqJAAJ2ASAAAtQAMAg0Q8AbBAE+EBoHa/MBQAMjAHr +iQQpkASAAOJUDAoYBIAA7YIBKq8CgAAFuwzouzIJVwKAAKrSLYEFkoErhQSs2epaDATJAQAAeSs5 +yqCqJXWTPchObUkFAgCGAwJhhYEriQSqVXlRaOWGASqQBIAAyLDRDybMQJaB9wAGFaACBQAihQTR +Dw0iDPMAJhWv/v4AApcMB0sU60QMCagEgADTD225BQIAhgUCYeczCAYRAQAAbUkFAiCGAwJjLYkE +B6IMosIiLEDihgEu/UYAAGP/oiLMQPMAJhWv/mIAbBAEGn/8G3+0GX/5+VAQFa/+9QDrKwoJAQqA +APcwEBXgDBUA5Eg5DjAKgAD5UAYdp0YBAOdFAQnrgoAA5cU5CdPCgADjUSd7wASAAA2qAg5OA+53 +AQnoCoAADXcC+3QmFad3AQDnlIAkAHmAAMl/0Q8AAAAAAAAA73/gE/+ZgAAu8tLHLgLuAQ7OAi72 +0tEPFX/aI1LSx44IMwEjVtLRD2wQBBR/1Bt/0hWAiyNAgP7/pAWv/+UA/f/iHeAMFQDkMA1iulEA +ALAyIkSA0Q8AAPQAAh2gCEUA0w9timgpXQIqkQgpkQQosID6gAQA0AYVAPsg1g2gAxUAwGAAyRoJ +CUcIkgHiMjkMUASAAOYhLHsbgoAADZID4ogBCxPCgADjIgILGAqAAAOIAvL0JhWniAEA6LSAJQCR +gADJhbFE53wEIqgJAADRD/8fAA3gAxUAYAABwDAo4tIPiAEIOAL52kYVr/9qAAAAbBAEGn9q6CID +IVv7AAArsnwqon/HnOmIAQ3eQoAAq6oLgADSoNEPAGwQBByAUgIrCQy7Ciqyf4yhjaCdwI2g439b +FdgLAAAosQL9oCYVoAQFAJSg5KYBJUv7AAApkn7jMn8kQ/0AAPwAIh3viAEA6LUCLM5CgADpMwgE +AumAAIk3jzL6QAQA3/r1AO6ZFC7ACoAACogD+eAEB7AKBQDvNgInAYGAACqSCeJ+5RUBGYAAKKAA +AogKKIIQ7KAHLVgEgAD6YGgdoA01AAuAAGWv4NEPY//TAAAA77EDKkgEgAAJ5BYBAgAcfsgqwoIA +8QTgThoPgQqAAP2gAQff+PUACP8DD6oBDqoCKsaCCeQWY/9tAAAAbBAEhiCHYYlgmXCIYBR/IiMh +BPcAJhXgCgUAmmDqZgEjK/sAACVSfuRCfyGb/QAAAwNP4yUEKq5CgADlRAgBgGmAANJA0Q8AAAAA +AOIhBS1YBIAAC+QWAQIAHX6mLNKC+kAEANAPFQDgrhoJAQqAAP3gAQff8vUAAv8DD8wBDswC7NaC +KhAEgAAL5BbRDwAAbBAEJCELJEz4BARDIkz8sDgCgzjSMNEPbBAIGH79khTmEgQrEASAAPjAAEMw +ACIAyljNKSpigAo5AelJ8nKr/QAA8OEQDeACBQCacNEPANogWRLzY//cwCDRDwDeMO0SBCp4BIAA ++iAGFaALhQD8/dIFoAoVAFkcHMcr0Q8AAABsEAYafngVf9P1/8IdoAcFACNSrgACACmi0ASZASmm +0Bh/EyeGXFh2gVkeMZIQFn/KHX7cCCwQDDwCDcwCLFauG3/HJ7aEKmJb9P+MBeADBQDnf7UVAnmA +ABJ+ZBR/wSsihCpio6s7CbsRq6ouQoAtcIAAMAT1wAQHcN2dAO5GgCb8OIAALKIdyMPAsVjxrS1i +W7Ez7TPHciCDAADyIAgVr/TlAB9/sS7yggTuAe72giEsLQAAWHZb0Q8AAFj3YRh/qy+CyBl/qgn/ +Af8ZBhXv/5oAAGwQBP7/TgXgGBUA8wDyDeAZVQBzmzaMJ43DAzsJiMKY0I7CD7sKKrF+/cAmFeAP +BQCfw+/GAiVT/QAA/kBGFe+qAQDqtX4lAMmAANEP2zDsIgIpUASAAFkZQ9EPAAAAAOixfy/IBIAA +CeQWAQIAHH4oKsKC+wAEANAOFQDg/RoMAQqAAP3AAQdf+PUACO4DDqoBDaoCKsaCCeQW0Q8AAABs +EAQYf38DNQkOVRGoUyQxfvCEsA3gChUAKzF+LzI9Hn95KTF/HH5yhiLtIgcsgQqAAO7MCA04CoAA +B2YC7FwIBsAhAACY8Z/S7NYDJdgFAAArNX4oNj2WItEPAAAAAAD6b+QV4AQFAATkFgECABd+AChy +ggCxBP1AAQNf+fUACWkDCYgBCGYCJnaCBOQWY/+HAAAAbBAEiiBloFAdf1vqIgMp9sKAAK7d/a/o +FeAMFQD8gEAGMaoBAAaqAg3ILAjdKCclBe3MDARYBQAA/W0ADD/7xQDrqgEMTkKAAAlZAgOqApoj +CYgCKCUE0Q+PIxt/Rw8PQQv+EavrLbJ/GX48LLJ+ctkZ2cDzI94NoAwFAMDALLZ/LLZ++kAIFaAA +RgDYwPMMRg2gDAUActEcjSGa0I4gKbJ9neGcIOwmASTL/QAA+W+mFe/9WgAZfzEYfiipiKjoeKEg +6rZ/L4EuAADNrSqyfWqiGC2ye/1v5hXgAEoAAAAAAAAA7LZ/J/8pgAD6QAgVr/6mABx/IoghrJmp +6fkPAAzwDAUACcg4+W/GFa/+KgBsEAQjIQQVfxr0YAQB9kM5AAQzAiMlBNEPAAAAbBAEwEAE5BYB +AgAWfaklYoL6QAQA0AgVAOA3GgkBCoAA/QABBF/59QAJiAMIVQEHVQIlZoIE5BbRDwAAbBAEgiMC +AkHRDwAAbBAEhSODIBR/AvhAhBWhVQEA6n7+Gq7CgADkVAgBgLmAAPsABAQ2mDkACYgCKCUEIkJ/ +0Q8dfvUTfvQffesmQn4rIQQuQn+SYJYho//9YAQF9ss5AAy7Aq9f7yYAJygFAAAlRn8iRn7rJQQq +kASAANEPAABsEASFI4ggFn7i/P3EBaFVAQDkgGNq1sKAAKamKWJ/J2J+HX3U8yV+DaALBQByeSsr +Zn8rZn6EIYggmECFICNifZRRmyDrJgEhm/0AACNmfdEPAADy4AQEIgCdAHKRHIohmKCMIClifZrB +myHrJgAky/0AAClmfdEP0Q8ArN6urn6BMOhmfyqBrgAAzo0vYn1q8igjYnsjZn+FIYkgmVCIIJWB +myDrJgEno/0AACRmfdEPAADrZn8i/qmAAIUhiSCZUIggJGJ9lYGbIOsmASIj/QAAJGZ90Q+OIazf +r68P7wwPvjj+z8YVr/3SAGwQBPT9WAXgBhUA9EBoHaACNQD2gEADMAAaALAiKFJ/6GP3cquBAADR +DwAAbBAGiSKEM/EtrA3nRMEA5X0zGAQKgAD0gAQKUgCdAOxJEQgECoAA9IAEohIAnQClmSiSnvcA +BmHSAJ0AK5KdZLCmLAoA+kAIFaAIBQD4IAYVoA1FAPggJhWgDgUA+CBGFaAPBQBYAOMMThH1wABH +cA01AC3mnSwgBioiAvj9CAXgCxUA66oCBmAFAAAsJAYqJgL4YEYV4AIFANEPKyAG/vz2BeAKFQAK +mALoJgIl2AUAACskBv5gRhXgAgUA0Q8WfQaKaGqhRAxJEaWZLJKebsNLK5Kd5LBHZWP9AACcaGW/ +X2AAA8Ag0Q8CKgLrTBgpYASAAFgEYiIKAAYAAAAAAAAAAAD//NwNoAsFAMCgWRgbimhrobD//xQN +oAsFAMCwwNoNrTT8wQYV7/7aAAAAAGwQBownHn5W+4EoFa/LBQDpyRQmQIEAAAuIAet87hVTgQAA +6sYJJMiBAADpxRQkQQEAAOirC3nKAoAALcEVqtqayZugjyD1QKYV4AglAOmmAy/+AoAACP8Cn6GJ +Ip6i5KYELSgEgADxLWwN50MBAON8zxIh74AA7EkRCAQKgAD0gARKEgCdAKOZLJKe94AFodIAnQAr +kp1ksJYsCgD6QAgVoAgFAPggBhWgDUUA+CAmFaAOBQD4IEYVoA8FAFgAgQxOEfPAAEdwDTUALead +LCAGKiIC+PxEBeALFQDrqgIGYAUAACwkBiomAplS0Q8rIAb+/DQF4AoVAAqYAugmAiXYBQAAKyQG +n1LRDwAWfKeKaGqhNwxJEQOZCCySnm7DPSuSneSwOWVj/QAALGYIZb9oAioC7CQAAlhhAABYBATR +D9EPAP/9PA2gCwUAwKBZF7+KaGuhvf//UA2gCwUAwLDA2g2tNPzBBhXv/xYAAAAAbBAEKyAHFnyV +GX07/Pm2BeDLEQDqIQguYoKAAP2GAA5xuwEA7DYALdwCgAALqgIJqgKHIJk2lDiVOfZgRhWgIgUA +8mBmFaAIBQCYOpg7mjT84AATsAg1AAh3Auc2ASGQwQAA0Q8AAABsEAQsIAfrIgAp0ASAAPwAIh3g +DkUA/AIABjA/BQBZGUgdfJMYfLwefa3tAAUNSASAAAkCYQkCYQkCYSkgBy8hCAkJQe6mAizMAoAA ++eYAD/ALBQDo/wIFEMEAAO+mACVIQQAABCCGCQJjBACGCQJhK6QW0Q8AAABsEAQoIAcafKQIKEAK +iRAKmQKZMIcgHXxZFnxf6nymG74CgAAHVwKXMeYAFQG4IQAABwCKKyEI7TYELGQCgADsuwIKzwKA +AOq7AgTjoQAAnDX6YMYV4A4FAJ43BACJ6jYIJMtBAACZOeMhFwGQwQAA0Q8AAGwQBJc2GXw+HHw9 +/Ph+BeAehQD+YGYVoAs1AO02AirGwoAA7DYAKnhCgADo/wIJVgKAAAuqAhh9mg9vApoxixqbOYoZ +CSkCmTSaOIkYCP8CGHw1mTefNegAFQGQoQAAAgCKIjww0Q8AbBAEFn1TJmJ/iWGLYJuQimD5QCYV +4AgFAJhhhyGWcJdh4mYAKagEgADmJgEjMyEAAONkAAsQBIAAbUkFBQCGAwJh0Q9sEAQFBkdoYgXA +INEPAAAXfT8ncn+McYgnjnCewI1w/aAmFaALBQCbcYqN56YAJEjBAACZcPrgJhWgAgUA54YNI7sh +AABtSQUDAIYHAmHRD2wQBIgg+kCkFa/MBQDiIgMpOASAAAx8AeyqCApfAoAA6CE8dVEBAAAteQSo +uavdLXUEeaMxyTvJSeI0AAwYBIAAbUkFAgCGAwJhiXAPAgAPAgCrmeqRWXwQBIAAmXDRD8CgmnPR +DwAIqQzpugwBgaGAAAlLFO28CCmQBIAA7U02DDAEgABt2QUCAIYGAmEJMgjrTgwGGQEAAG3pBQIg +hgMCY6rPL/xA73YALBAEgADRDyLMQOJ2ACwQBIAA0Q8AAGwQDJQVkhgoEggmFgQnFgooggcnMgAl +FgnlEgkkQIEAAPghhhWn50EA9cAd4Rd3AQAiChDiFgMj+D0AAP6OAA/wAiUA5hIKJ9gFAADsEgwt +/wKAAO8/CAlHAoAAqGYnwQX2IWYVr80FAA3MAax25mxAL9AEgAD34B7SogCdANSg6+QADc/CgAD5 +wBItYgCdAI2hiBuPoA1dNp+A7YYBJUghAADpBgAEQCEAAAgAioehj6MNVQwNdwyv35ehiqJ9+wIq +rAGfQ5pC/CGmFaANFQD3rQAL8AgFAOfYOAXICQAA6J45BBeBgACPG4wd5FLkZ/hBAACNFe/dEQdA +BQAA/QAWkuIAnQAYe7DAcPPAAgNwBAUA6BYGJEBBAAD4IOYVoAC+AAAAAACLFusABQ/IBIAACQJh +CQJhiKBkgYfj5gsCiKmAALHp/SAIWuIAnQCLHCuxBay46IxAK1AEgAD4wBdaogCdAIugD3kL73YK +BMghAADrWDYFg3mAAAhVDOhmACVYIQAACyCICQSKhqOJoIuipoYImQyZoJaj6GsGciAFAACxu+um +AiKFaYAAZHIU/+MAFeAHBQDoEgcn8GiAAOgAFQ/IBIAACQCKCQCK+IJoHeAAUgCLFusABQ/IBIAA +CQJhCQJhi6HrWDYF+mGAAAhVDA95Cw92CuhmACVYQQAA60YABMghAAAJCIqGpYmhi6SmhgiZDJmh +lqXoawZyIAUAALG766YEIoFpgABkcZzoEgcn+GEAAPH/92cQBwUA6AAVD8gEgAAJAIoJAIr4gmgd +7/uaAIgb9IAAhLAK9QAKmQr+YEYdpJkdAOkiCAIgBQAA5IUBIRAFAACLGIkTL7EHHXuDGHsv/PZi +Bar/AQDusRov/wKAAAj/AogaBNw5jRmfgIuwmYOcguwSBC3+AoAADy8Cn4HvMgMkUEEAAFuXV9EP +AImhs+j5AgAPf/nCAACeEY0VlxCcHe/dEQdQBQAA/UAHuuAPBQDuFgEtOASAAOQWAi9gBIAAbQgr +4+sLDyAEgADmuyR90ASAAIugzrWLobH/5bBXY7gNAACzTtzg/OAFwuIAnQBj/80AihD7bwANP/9q +AACIGwtdNg1VDO2GASVIIQAA6WYABEAhAAAIDIqPo4igi6Kv3w2IDJigffsBsbufo/tARhXgANoA +AIgbC1k2CVUM6YYBJVhBAADrhgAEQCEAAAgQio+ljaGLpK+fCd0MnaF5+wGxu5+lm6SLEh18UYuw +DbsBjRub0ImgZZ00j6Gzzf+iAA9/9LYAAAAAAAD/+HQNoAcVAP/1nA2gBxUA//n0DaAEBQCOEQ/4 +CfnAAEc/9A4Av3/w5tAN5P8dAIka6DwQJMiBAABt+QUIAIYJAmGFGQ7+CfPgQBWgCRUA51UMA8BB +AADoFgMigKmAACsSBQ+7EfvPAA3wCgUAC6k5/AAiHeAMBQAJ3DhlzAH/+NANoAQFAAAA+s8ADX/0 +VgD37wANf/CaAMEgkhP/74ANoAIlAGwQBIQpgywEMwwDA0gjJR8jJSHRDwAAAGwQBIknipz5IoIV +oAIFAOWcICSgwQAA5KsMBVMhAADrojkEBQmAAIqZ8UVwDeAG1QAnCjzNNiugAHexR2i1LHa5Cyyg +EGjBO3a5AmjCNS2gB8DA6lQADtgEgABb+wIrWQSKUcm1Za/LYAAYACygEGnIzGAADgAAAAAAAAD/ +/5QNoAoFAPBBwA3gI9UALSAAc9EZji7AIO5PDAdzIQAAD+I5ZS/nwCDRDwAAAADrJAAKUASAAFvs +/uKkAA1+jgAAY//hAAD//YQNoAoFAGwQBAUGR2liUosniLj5YqQV780FAOeyCyXQgQAADa0B7ZkI +CmcCgADocTR0yQEAAC65FKyFrO4utRR1kyrIP8hNbUkFAwCGCAJhJaIADFUI+KsGDeACBQCVoNEP +wCDRD8AgkrvRDwAA6JUMAYFxgAAFRxS4duZGNgmQBIAAbWkFAgCGCAJhBTII50gMBpkBAABtiQUC +IIYDAmMFyQyp2SmcQPlABhXgAgUA0Q8r3ED7QAYV4AIFANEPAAAAbBAELiAHH3qWDi5A7XpOH3KC +gAAP7gKeMOgiACpQBIAA9PTOBaALRQD8YEYV4DwFAOw2AyxGAoAAC4gCG3qK6DYBKcgEgADkAAUB +mEEAAAMCYQMCYQMCYSwgByghCPwgAAYwBCUA5UQ2DmQCgAD9BgAMMNZNAOuIAgvkAoAA68wCBJEB +AADslgYkqIEAAOiWBCqYBIAAbUkFCgCGAwJhLVQG0Q9sEAT6QLAVoAW1APYBQh3gC4UA9gAiHaAT +JQD6ZZYNoAQFAHOhZfVABfWQA5UAdaF09UAENJIAnQBzqVeIImWAUtqw+kCmHeABNgDaIFiKjfpA +aB2gCwUAW/9eGXoLiyAjJAUqknMpkoirqgmqEaqZi5f7ZAAVr8wFAAyqAeS1FCVRAQAAmrmauCSU +BYoiZKCGKiAFwLn7QNYN7/JVANEP0kDRDwAAjCJlz+jaIFuuuWWv3fZAph3gCqUAjSJl39PaIFuu +mWWvyC8gBo4iIyQF5u4CB/gFAAD+QMYd4AqVAP5ARhWv/sIAjyJl/6baIFuuzWWvmykgBogiwKwq +JAXmiAIEyAUAAPhAxh3gCsUA+EBGFa/+BgAA+kBoHaALNQBZFRDmoKFtGASAABx51NMPisj3QAVA +kgCdABN50SsyrnWzZCsyrWSwYLCt7cYIJYMxgADaIPxBJBWgDQUA/h/iHeAOBQBYihj8RGQVoA0F +APtAaB3gDhUA+kBoHaAPJQBYihElNq0vIAaOIsGBKCQF5u4CB/gFAAD+QMYd4BoVAP5ARhWv+8IA +wLAHqTTpxggt/RYAANog/EBoHaAbxQBYARlj/ssAAADaIPxAaB2gG8UAWAEUZT64Y/+qAAAAwKBZ +FM8ceaaKyPlf+nCSAJ0AY//BAGwQBOIgcCkgBIAA4jgCAQBpgAAoRHDRDwAAAAD6gGgdoAsFAFv+ +7ipAcAw5EQk5AgqZAilEcNEPbBAGhifjIAcpyASAAJkQ9sHIFad1AQD86CCBUTMBAPSACCESAJ0A +9IAJiJIAnQD6QGgdoAslAFv/5MiiwCDRD4kQKZwQ6QMeC0AEgAAIAmEqIAVuqGcrIHJ+v2HaIFv/ +XWWgdywgBe4iAi5BTAAALSByft9I6Xl3HwMeAADsOhEBpd0AAKmqL6Ke9+AIslIAnQArop1ksPbc +YPpAaB2gDSUA/gACHaAPJQBb/yEdeWkMPBH9gABGcAtFACvGnWhyMoon+oBoHeAMBQDqrCAqaASA +AFv5ztKg0Q8AAOsSAClQBIAA7EQACugEgABb/uHSoNEPAMAg0Q8deVaM2PeABViSAJ0ADDoRqaor +op73YAXKUgCdACuinWSwsLDOnthlv3VgAGkAAI+S/vgAB/A4dQD5//eVIgCdAPpAaB2gC4UAW/+h +Za70iRApnBDpBx4LQASAAPgEqB2v++IA+kBoHaALRQBb/5hlrtGLEIuzKiEJCwtD5KoRDd7CgAD7 +RgANcBsFAAuqAvrABhWv+xYAKzwY6iQACWAEgABYAJdj/zsAAAAA//u0DaALBQDAoFkUUR15J4zY +GXkn+Z/6QJIAnQD//WgNoAsFAADAsMDqDs40/6EGFa/9KgAAAABsEAgbeo2bEPhACBWgCQUAmRKZ +E5MU5BYFKVAEgAD0IMYV4AwlAOYWByxGAoAA/QYADDANJQDoFgEo2ASAAFv/edEPAGwQBMAg0Q8A +bBAGlRCWESwgO4Yn4xYCI9kBAAD6IEgVr8gFAPTEABXj7AEA6FUBD3cCgAD/QABFMA0VAPtFABWg +AKYALCA7sd2xzCwkOy5hFeXoCAV4QQAA6IxAL9AEgAD54Ab6ogCdAImh6U82BP7RgADvRAwNSASA +AOkmAA3gBIAADASKCQCIDACKL7YBLqIDKaIBI6ICDv4ID5kMKaYB7qYDJdhBAADv6wd54ASAACw8 +AeymAiIOMwAAjhAvISKFERp6TSQhB4kSIyEJ+kDwFepEAQDpkgAqIwKAAAQzAiQhJPsgBASwuxEA +6njTHdqCgAD7JgAM84UBAOt43RxCAoAACEQCGHo9CpkCmXCMIJ51k3MSeNCUdJV24v8CDmYCgADv +dgImkBEAAAwsApxx6wAVA6jBAAAFAIoI2AKYftEPAP/vAA0//IYAbBAEKCEFhyH0QIIV78kFAOkp +AQpXAoAACncMClUIJSUE5yYBJNkBAAB7ewUIdwgnJgGokuQwGmERAQAAp6V1IxbiNAALmASAAG1J +BQIAhgMCYdJw0Q8AAAcpDAlIFOqMCCuwBIAA6ko2CZAEgABtqQUCAIYGAmEDkggITAxtyQUCIIYL +AmPScNEPAABsEAT48/QF4BgVAPMKVg3gBRUAAzoJDqoRqakrkX5ksGocefMYeO6LJy6SPi+RfuyI +CAXoIQAAneCes6ioLpF/mLLrIgIn+AUAAO+Vfi8BCoAA7ZY+KuAKgAAMuwKbItEPwfVz86wYefAI +OAoogn/cQOo0AAlYBIAAC4AAiSIAMQQAWhoKmQKZItEPAPkv5BWgCwUAC+QWAQIAHXhwLtKCAIEE +/KABBl//9QAPzwMP7gEOzAIs1oIL5BZj/2MAAABsEAQrIAceeGX0YgAVp1UBAPSgBfkRuwEADLkR +rpkokp73AAW6UAZFACmSneqUAASFqYAAH3hiHHioKSEHIyAHF3in+IEEFaqZAQDyIAAG8DMRAOoz +EAzPAoAA45kCDuwCgAANiAIHiAIMmQKZoIwgmKT3QMYV4AMFAJOlk6f/QEYV4D0FAO2mAy5mAoAA +BswC7KYBJUiBAAAEIIYJAmMEAIYJAmEMuhGuquamnSKUeQAAiif6AIId4AwFAPtEABWgDUUAW/ij +0qDRDwDRDwAAAAAAAPRgaB2v/QYA//0wDaAJBQAAjCLIxmhSFcAg0Q8AK7wY6iQACWAEgABb/5Bp +UumPJ41AKPkUL/EVHHmY/kAIFaAKVQD57wAPsDsFAFkVwIwnKckUKsIJ+YQAFa/LBQDriAEEyQEA +AOnFFCVTAQAA6sYJJEEBAAB4qwctwRUK2giayRl4GymmAC8iABh5hOimAi/+AoAA9+YAD7AOJQDv +pgElSEEAAG3qBQNAhgkCZcAg0Q8AAGwQBPygABQwCSUACYgC6EYBIYORgACJOBd4UPxhKBWgBgUA +6jIMJILpgAAlcomWO5nAjTgs1gEmNgj2YSYVr5tlAOs0BSV9ToAAKzIALzIHJjYM/O7IFa/IBQDm +9RQn8IEAAAjuAey7DAdxAQAALvYJ/+EGFaANFQD6qygVoAwFAFgAF+okAApYBIAA/ABCHaANJQBb +/3jRDysyEi5SawuKROqqDwtgBIAA/0ABBTANFQD7QAgVr7uBAFgACfZiRhWv/iYAAAAAAAAAAGwQ +BMBRAyQsAyIuAlI5pCLRDwAAbBAEKSEEhyD/IAAUtYMdAOl3CAxHgoAA+O8AC7AKFQD2/4AV5JMB +AOZyACyBCoAA/UABBV/49QAIqAPmqgEMggqAAPsgBADROp0A6GYBCkAKgAAIZgLmdgAigRGAACUh +AshKsFrqJQIpkASAANEPsVvrJQIpkASAANEPANIw0Q9sEAQnIQSIIA8CAPb/4BWvkzkA6SUFKy8C +gADlhQgM7wKAAA1dDA0AhyohA/oAIh3mwwEADDtgCgpGDwIA/GJgR1AMBQAMnRENXQwNIIcMO2Jv +Phf4wT4N7/31AMihc6EqCZIRojLRDwAAAADnIQQkyAUAAAkJTyklBXeRUbB2DGUR9QAAQv/+/gAA +AAmUEaQ0/uAAFzWUHQDuiAgMz4KAAAmIDPkfgBWkRAEA7oIAKgEKgADpIQUtsAqAAA1vAw/uAQ5m +ApaA+EAIFa/+hgAsJQX//pwNoAkFAAAAIAK28iACtuIgArbqIAK28iACtuIgArbiIAK24iACtuog +ArbyIAK28iACtuIgArbiIAK3RCACt6QgArdEIAK3RCACt6QgArekIAK3pCACt0QgArdEIAK3RCAC +t6QgArekIAK4USACuUsgArlVIAK4USACuUsgArlLIAK5SyACuVUgArhRIAK4USACuUsgArlLIALk +WSAC5XQgAuRZIALkWSAC5XQgAuV0IALldCAC5FkgAuRZIALkWSAC5XQgAuV0IALmRSAC5sUgAuc+ +IALneCAC54sgAuhNIALoyCAC6NsgAulFIALpdSAC6ZoAAAAAIALw+SAC8kUgAu/MIALv7yAC8OEg +Au+sIALvxCAC8mIgAvLAIAL2NSAC9PUgAvUvIALzUSAC88MgAvQxIAL0cCAC9KggAvWlIAL1nSAC +9ZUgAvVZIAL1UQAAAAAAAAAAIAMgUiADIGggAyH6IAMijSADIwkgAyOFIAMkcCADJS0BEBgBAAEA +AAAAAAAAAAAAIAO36SADt+kgA7X7IAO36SADtfsgA7fEIAO3nSADtfsgA7bRIAO1+yADtfsgA7bI +IAO1+yADt+kgA7X7IAO1+yADt+kgA7YEAAAAAAAAAAADAQACAAAAAAAAAAAAAAAAIAQ78iAEPCAg +BD2TIAQ78iAEPYsgBD11IAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAE +PWogBD1fIAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ7 +8iAEO/IgBD0wIAQ78iAEPRUgBD0VIAQ78iAEO/IgBDz1IAQ78iAEPRUgBDvyIAQ78iAEO/IgBDvy +IAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAEO/IgBDvyIAQ78iAEO/Ig +BDvyIAQ78iAEO/IgBDvyIAQ78iAEPNUAAAAAAAAAAAAAAAAgBF1WIARdViAEXCkgBF1WIARXRiAE +XUwgBF0oIARXRiAEV0YgBFdGIARXRiAEV0YgBFwMIARdViAEV0YgBFwMIARdVgAAAAAAAAAAAAAA +ACAEaokgBGreIARtMyAEbOIgBGyaIARsbyAEbFwgBGxWIARrrAAAAAAAAAAAAAAAAAEQGAEAAgAA +ARAYAQACAAAgBLh+IAS4UyAEtsMgBLgbIAS4GyAEuBsgBLbDIAS4GyAEtsMgBLf7IAS2wyAEtsMg +BLf7IAS4GwAAAAAAAAAAIATcCyAE19QgBNvfIATbsyAE24cgBNf7IATX+yAE2BIgBNtuIATYRyAE +2DMgBNf7IATYRyAE1/sgBNf7IATX+yAE3AsAAAAAAAAAAAAAAAAAAAAAIAUuoCAFJQggBSS4IAUi +vAAAAAAAAAAAAAAAACAFJPIgBSTuIAUk7iAFJO4gBSTyIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTu +IAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4g +BSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAF +JO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk +7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJPIgBSTuIAUk7iAFJO4gBSTyIAUk7iAFJO4gBSTu +IAUk8iAFJO4gBSTuIAUk7iAFJPIgBSTuIAUk7iAFJO4gBSTyIAUk7iAFJO4gBSTuIAUk8iAFJO4g +BSTuIAUk7iAFJPIgBSTuIAUk7iAFJO4gBSTyIAUk7iAFJO4gBSTuIAUk8iAFJO4gBSTuIAUk7iAF +JPIgBSTuIAUk7iAFJO4gBSTyIAUk7iAFJO4gBSTuIAUk8iAFJO4gBSTuIAUk7iAFJPIgBSTuIAUk +7iAFJO4gBSTyIAUk7iAFJO4gBSTuIAUk8iAFJO4gBSTuIAUk7iAFJPIgBSTuIAUk7iAFJO4gBSTu +IAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4g +BSTuIAUk8iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk8iAF +JO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk +7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk7iAFJO4gBSTuIAUk8iAFJO4gBSTuIAUk7iAFJPIgBSTu +IAUk7iAFJO4gBSTyAAAAAAAAAAAAAAAAIAUlQCAFJpUgBShDIAUoNSAFKCAgBSgSIAUn/SAFJ+8g +BSfaIAUnzSAFJ7ogBSetIAUnmiAFJ40gBSd6IAUlNiAFJ2cgBSdaIAUnRyAFJzogBScmIAUnHCAF +JwsgBScBIAUm8CAFJTYgBSU2IAUlNiAFJTYgBSU2IAUlNiAFJuMgBSVZIAUlNiAFJTYgBSU2IAUm +xiAFJq0gBSajIAUmhCAFJTYgBSZxIAUmVyAFJkQgBSYqIAUmFyAFJf8gBSXsIAUl2SAFJXMAAAAA +AAAAACAFLuQgBS7uIAUwWiAFMDIgBTArIAUwJCAFMB0gBTAWIAUwDyAFMAggBTABIAUv9yAFL+0g +BS/PIAUvbiAFLz4gBS81IAUvICAFLxYgBS8PIAUvAiAFLvsgBS7WAAAAACAFjNQgBYzqIAWOgCAF +jxUgBY+UIAWQDSAFkPIgBZGtIAW2kCAFs+wgBbKAIAWwVCAFrlAgBaNkIAWlsCAFrUggBaIIAAAA +AAAAAAAAAAAAAw8IEoOOk5IAAAAAAAAAACAF1MUgBdN5IAXTfiAF1MUgBdN5IAXTeSAF03kgBdN+ +IAXUxSAF1MUgBdN5IAXTeVJWAAAAAAAAQb3NZQAAAABjb25maWd1cmF0aW9uIGZpbGUgcGFyc2Vy +IGZvdW5kIGFkZGl0aW9uYWwgY29uZmlndXJhdGlvbiBhZnRlciBbZmluaV0KAAAwAAAAZmNvZQAA +AAB2bmljX2lkAHZsYW4AAAAAdG9zAGV0aGVydHlwZQAAAG1hY21hdGNoAAAAAG1wc2hpdHR5cGUA +AGZyYWdtZW50YXRpb24AAABiYXNpY3ZpcnR1YWwAAAAAc3lubWFwZW4AAAAAc3luNHR1cGVuaXB2 +NgAAAHN5bjJ0dXBlbmlwdjYAAABzeW40dHVwZW5pcHY0AAAAc3luMnR1cGVuaXB2NAAAAG9mZG1h +cGVuAAAAAHRubG1hcGVuAAAAAHRubGFsbGxrcAAAAGhhc2h0b2VwbGl0egAAAAB0cF9waW8AAHRw +X3RtX3BpbwAAAG5pY192bQAAbmljX3VtAABuaWNfdW1faXNnbABvZmxkAAAAAHJkZHAAAAAAcmRt +YWMAAABpc2NzaV9pbml0aWF0b3JfcGR1AGlzY3NpX3RhcmdldF9wZHUAAAAAaXNjc2lfaW5pdGlh +dG9yX2ZvZmxkAAAAaXNjc2lfdGFyZ2V0X2ZvZmxkAABmY29lX2luaXRpYXRvcgAAZmNvZV90YXJn +ZXQAcG9mY29lX2luaXRpYXRvcgAAAABwb2Zjb2VfdGFyZ2V0AAAAcHBwAGRjYngAAAAAIAKS1AAE +AAAAAAQAAAQAAAAAAAAgBfPwIAXbUCAF8+AgBdtgIAXbdCAF2oAgBdwcIAXaGAABAgMAAAAAIAOH +ZCADhvggBGQQAAAAACADhvAgA4boIAOG4AAAAAAwMTIzNDU2Nzg5YWJjZGVmQUJDREVGAAAAAAAA +AAAAAEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXow +MTIzNDU2Nzg5Ky8AAAAAAAAAAAAAAAAAAAAAIAAf9AABAAAgAB/UAAUAASAAH7gAAwAFIAAfmAAH +AABjglNjAAAAAP///////wAAAAQECAAHQwAAAAAAAAAAAP////////////////////8AIQAJAIEA +QQAhAAkAIQAJAIEAQQCBAEEAgQBBAIEAQQAhAAkAgQBBACEACQAhABEAgQBBAIEAQQAhAAkAgQBB +ACEACQAhAAkBAQBBAIEAIQCBACEAEBBhAQEAgQEBAIEDAgEAAAAAAAAAAAAAAAAAAAAAgAAAAQAA +AAIAAAAEAAAACAAAABAAAAAAAAAAAAAgQIAAAAAAAAAAAAAAAAAAIAKJOAAAAAAgAo2oAAAAACAC +iTwAAAABIAKNtAAAAAIgAolEAAAABCACiUwAAAAIIAKJVAAAABAgAo28AAAAICACiVgAAABAIAKJ +ZAAAAIAgAolwAAABACACiXwAAAIAAAAABQAAAAMAAAABAAAAAiAFupggBbpUIAW5RCAFuAwgBbfM +IAW3oCAFt/QAAAAAAAACAAAABAAAAAgATkEAAFYwAABWMQAAVjIAAFYzAABWNAAAVjUAAFY2AABW +NwAAVjgAAFY5AABWQQAAVkIAAFZDAABWRAAAVkUAAFZGAABhbGwAKgAAAG5vbmUAAAAAMHgAAHBv +cnQAAAAAcHJvdG9jb2wAAAAAZ2xvYmFsAABmdW5jdGlvbgAAAABmaW5pAAAAAHJlZwBmaWx0ZXJN +b2RlAABmaWx0ZXJNYXNrAAByc3NfZ2xiX2NvbmZpZ19tb2RlAHJzc19nbGJfY29uZmlnX29wdGlv +bnMAAHNnZV90aW1lcl92YWx1ZQB0cF9wbXJ4AHRwX3BtcnhfcGFnZXNpemUAAAAAdHBfbnJ4Y2gA +AAAAdHBfcG10eAB0cF9wbXR4X3BhZ2VzaXplAAAAAHRwX250eGNoAAAAAG10dXMAAAAAbnZmAHd4 +X2NhcHMAcl9jYXBzAABuaXFmbGludAAAAABuZXEAbmV0aGN0cmwAAAAAbnZpAHJzc252aQAAbmV4 +YWN0ZgBjbWFzawAAAHBtYXNrAAAAbmV0aG9mbGQAAAAAbnJvdXRlAABuY2xpcAAAAG5maWx0ZXIA +bnNlcnZlcgBuaGFzaAAAAHRwX2wydAAAdHBfZGRwAAB0cF9kZHBfaXNjc2kAAAAAdHBfc3RhZwB0 +cF9wYmwAAHRwX3JxAAAAaXNjc2lfbnRhc2sAaXNjc2lfbnNlc3MAaXNjc2lfbmNvbm5fcGVyX3Nl +c3Npb24AaXNjc2lfbmluaXRpYXRvcl9pbnN0YW5jZQAAAGlzY3NpX21heF9zZ2UAAABwcG1fbWF4 +X3pvbmVzAAAAcHBtX3pvbmVfcmFuZ2UwAHBwbV96b25lX3JhbmdlMQBwcG1fem9uZV9yYW5nZTIA +cHBtX3pvbmVfcmFuZ2UzAGZjb2VfbmZjZgAAAGZjb2VfbnZucAAAAGZjb2VfbnNzbgAAAGRjYgBi +Z19tZW0AAGxwYmtfbWVtAAAAAGh3bQBsd20AZHdtAHZlcnNpb24AY2hlY2tzdW0AAAAAMDEyMzQ1 +Njc4OWFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6AAAAAFllcwBTZXNzaW9uVHlwZQBPRk1hcmtl +cgAAAABJRk1hcmtlcgAAAABEYXRhRGlnZXN0AABIZWFkZXJEaWdlc3QAAAAARXJyb3JSZWNvdmVy +eUxldmVsAABJbW1lZGlhdGVEYXRhAAAARGF0YVBEVUluT3JkZXIAAERhdGFTZXF1ZW5jZUluT3Jk +ZXIASW5pdGlhbFIyVAAATWF4Q29ubmVjdGlvbnMAAE1heFJlY3ZEYXRhU2VnbWVudExlbmd0aAAA +AABJbml0aWF0b3JOYW1lAAAASW5pdGlhdG9yQWxpYXMAAERlZmF1bHRUaW1lMldhaXQAAAAARGVm +YXVsdFRpbWUyUmV0YWluAABNYXhCdXJzdExlbmd0aAAARmlyc3RCdXJzdExlbmd0aAAAAABNYXhP +dXRzdGFuZGluZ1IyVAAAAFRhcmdldE5hbWUAAFRhcmdldEFsaWFzAFRhcmdldEFkZHJlc3MAAABU +YXJnZXRQb3J0YWxHcm91cFRhZwAAAABBdXRoTWV0aG9kAABTZW5kVGFyZ2V0cz1BbGwAQ0hBUF9B +AABDSEFQX0kAAENIQVBfQwAAQ0hBUF9OAABDSEFQX1IAAERpc2NvdmVyeQAAAE5vcm1hbAAATm9u +ZQAAAABDUkMzMkMAAENSQzMyQyxOb25lAE5vbmUsQ1JDMzJDAENIQVAAAAAAQ0hBUCxOb25lAAAA +Tm9uZSxDSEFQAAAATm90VW5kZXJzdG9vZAAAAElycmVsZXZhbnQAAFJlamVjdAAATm8AADUAAABD +SE5ldCAxLjAwAAAAAAAMAAAAAAEAAXwADAEAAAAAEAAAABQgBgVQAAADFQ5AAAAf/AAAH/wAAB// +rKAf/6ygIAYO0CAGEkAgB28wIAdvMCAHwAAgCBBAIAhAACAIwAAAAAAA4QGOAAABkQyAAAAAIAkG +gCAJBjAgCQawIAkGYAAACAD///P/H/+QoOECFgDhAhoA///I////F////x//AACAAAAAEAAAAhkc +AAIZfAACGZwf/5q8///x/8AAAAAAAhqkAAIaKAACGqgAAho0AAIatAACGjAAAhqw///3/wAA/+nh +Ag4AAAAThyACgAAgAoAwIAKAYAAAQA0AAP/3AAAP/wAAD0IAAP/wIAjAYCAIwAAgCMAwAAAMAAAA +GAAAAhA04QAAAAAA//UAACBAAAAgAAAAxBAAAMABAADIICAIwJAAAMQAAABAAB//mqD+AAAAAF/2 +pwCyN8dAAAAAHf///2IAAAAAAMQwAADEMSAIwOAAAMRFAADIACAIwLAAACcQAADoACAIwUAgCMGA +IAjBECAFWZAAAMgQAAAQAQAAIHwAADIAAADMAAACSe/hAF4A4P/+AP//v/8AABAQAABQEOECGAAA +AH/9AAAQEeECFwThAhcAAAAMCf8AAP9/////ACAAAAAADA4AAAwMIAAAAAAADAvf////AAAMCh// +kTQAAMAQAAJiWgAAwzAgAoCQEBAAACAQAAAAEAdg/+/4nx7+AADhAhgMEAAAAPAAw3Af/5EwAAgA +ACACgMAAD0JAAAIQ4OECEgAAgAAAAEAAAAAAEgAAAhUAAAATiAAAIAEf/5mgHc1lAO////8gAoDw +AADDUPf///8gAoEQgH////+Af/+//////z///wAHoSD/wAA/IAkG0CAJBzAIAAAAH/zgdCAC90Qf +/50AAQAAACgAAAAgCMGwH/+FsB//hCAf/4agIAjCACAIwkAgCMKAIAKLYCACiOAgAouAIAKLACAJ +CYAgAorgIAkJsCAJCdAgACAUAAIAAOAAAAAgCMTAIAjEkCAIxSAgCMTwIAMt6CAJCGAf/5q0AP// +/yAIxWAgCQoAIAjFkCAIxdAgCMYwIAjG0CAIxgAgCQegIAkIACADQ2QgCQkgIANIOCAIxoAf/5qw +IAjHoCAGDOAAD/wAH/+WMAAAMAAgCMfQIAjIYCAIyQBVAAAADgAAACACi/gAAAgGIAjJMB//mgQA +AA/+IAjJ8AAA//8gCQqQIAjJkCADG1wgAxJwIAjKUCAIysAgCMsQIAkLYCADJewgAylMIAkLICAI +y1AgCMvAIAjMICAIzJAgBhIAIAYPECAIzRAgCM1wIAYRECACgVAgCQ3gIAkLsAAAUAAgBhHAFLAA +AIAAAAQgAx9wIAYRyiAJC/AgCQxQFaAAAAAAj/4gCQygFqAAACMoFQAgoAAAP/AAACOgAAAD/wAf +IAYKIB//kowgCQ0AF5AAACAJDUAUkAAAQAAABCAJDbAgCM4gIAjQYCAIz7AgCNAQIAjOgCAIzvAg +CM9QIAMrnCACi/Af/N4ADAAAAAQAAAiBAAAAH/+GEB//hxAgApBcH/+F8CAI0MAgCNEAP////8// +//8gCNFAH/+GzCAI0YAgCNHAIAkOUCAI0kAAAJxO///QTf//LlwAANGkf///qyAI0sAgCNKAIAjS +AB//hgwgCNMAAABIACAI08AgCNOQH/+GCB//hnAgCNPwIAjUwB//mqQgCNWAIAjVUP/9//8AmJaA +IANa/CAI1bAf/5rAIAjWACAJDnAD/9AAH/+a3ABQB/8gCQ7wAAEAACAJDyAgA1NUIAjWIP//QAAf +/5oQIAjWYAAAH/4gCNagIAkQMCAJEHAgCNbQIAkKYCAJCjAgCNcwCgAAACADYQggA1xEIANM6CAD +UFAAAMAAIAkPgCAJD8AgCNrQAgAAACAI22AAABdwIAkRQCAJEPAgCREgIANpgCAJEXAgCRGQIAYM +xB//mqjhAHoAIAjbkCAI27AgCNvQH/+SRB//kMAf/5kU4QB+AB//mkAAAPP/BAAAAB//nRAUAAAA +KgAAACADcXz/9///IAkRsB//mhQgCRJwIAkTQB//p9AaAAAAIAjccIP/twCD/7YgIAkTwB//myAf +/6j4MAAAECAJFAAgCRRgH/+SgCAJFJAgCRUQ4QH+AB//lawiIiIiH/+qdCAI3MAAAAy8AACJBiAI +3PDgAAkkAJwAACAI3RAgCN1gAAIEwOEAjgAAAJaAAACWQCAGDuAAAJagAACWYOECACz//wAAAAHg +AOEBkgAAAeMAH/+axCAI3YAgCN2wAAAabB//qRAAD///H/+oxB//mijhAZYAH/+SkCAGEYAAAGAA +IAYRigAAGloAAIP/IAKBcAhQAQAAwAAEH/+qeCAF5yggA6AMIAXm7N6tvv8awAAAIAYQiAAA/+og +BhGQAAAIFAAAiAAf/5qsABAAAB//mTwAHoSAIAO1uDgAAAAwAAB0IAKBgCAI3eAwAAAIMAAADDQA +AAjQAAAAAACJFDsAAAg0kAAAADAAAP8H//8FXUqAIAO74AAYAAAAOAAAIAkVwAYAAAAgA8m0+AAA +AAH//+cAAcAAIAAAgAQAEAAf/5kk4QGaAOEBmkDhAZo84QGaOOEBmjThAZowgAAAA4AAAAIAAIbd +H/+aLP/8///hAQ4AH/+auB//kiQf/5KkIAPXiCAJGzAgCRjgIAkZICAJGtAgCRsAIAkZUCAJGZAg +CRnAIAkaACAJGjAgCRpwIAkYsA////D/8AAAIAkbsB//qSAf/5dMIAkbcCAD5tggCRywIAkc4CAJ +HFAgCRvwH/+YTAAAIygf/5Y0AAD/gCAI31AABAAA//v//+EB4sAf/5pEkAAA8Pz/gO8gCN+gIAjf +4AAA+AAAAgEMAAIBCI////8AAPAAH/+aOOEBmAAgCOAwIAjggCAI4LAgCODw4QDeAAACAwgAAgIA +///wAOEA7gAf/5rM//9//wAA4AAAAPwAAAIDBAABERwAAREYABAIAIAACAAAAgEEH/+aIP//wAAA +AP/+AAAlgAACAwAf/5ow4P/iwCAJHRAgCR2gAAIQCCAJHdAgCR3wIAkdgAAA//MgCR4QIAkeMCAJ +HlAgCR6QAAAqMCAJHnAAAP/4AAD/jwAAUrUAAEgKAACPggAAj4YAADgAAACPigAA4z8AAIOuAAD/ +8SAI4UD//8+/AAAQQCACgdAgCOFwIAkesAAA//sgCOGw///f/yACgeAgCOJQIAjiICAJHuAAAhYI +fz///wAA+f8AAP7/AAD/wAAA/z8gCR8wIAjh4CAJH+AgCR+QIAjjACAI4sAgCOKQIAjjIB//qwwg +CONwBAEACAAAGmQAAN6tH/+ovCACgvAAAIMAIAjlsBAABQ3uAAAAAcCAAAkAAAAAAIIAIAjk0CAI +5SAgCOVgEAAHAgAA/P8gCOYQGwAAAAAFAAIgCOZAIAjmYCACg0AgCOaAIAOFWCADgiggA4SoIAjm +oCAGDwAA/8AAEgAAACAEeHAgCOdAIAjnACAI54AgCOfgIAkhUCAI6QAgAotwIAjpICAI6DAgCOiQ +AP///AAAEDb//+//IAKDcB//qQQgA8XcAAAIUCACg3gyAAAAAAAIQAD///oAAIAF3q2+74GAAAAA +AIP9MAAAHDAAAAQwAAAUAAD/7//+//8f/6m0IAKDgAD/8AAAKAAAIAjpYDAAAAAwAAA0AACAASAC +g8AAAIACEAAFEJkAAAA0AAAAIAkiMCAI6aAAGQAAIAjp8CACjAQAABshAACAwgAAgAczkAAAH/+Y +jAMVAAAFAAAAg/8AGyAI6qAgCOrw4QGRrAABkawgCOtQCwAAACAFCmQgCOvAIAjsMCAI7KAgCOzQ +IAkjACAJI6Af/5uAIAQkrOEADgDhABIAH/+YmAABOIDgAAYAAAInECAJJJB///8PH/+b6OEALgD8 +AP//4QCWAOEAmgAAAAn/AACwAB//mxggAoQQAwAAAOEAEgThABII4QASDOEAEhDhABIUEwAAABEA +AAAf/AAAH/+adCAI7VAgCSXAAAGUjwABlM///+/4IAKEMB//mZQgAocgIAjtkAACSfAf/5msIAKH +8B//kUQgCO9gH/+XuCAI8QAf/5h8AD///wAA//0AAP/VAADql8IAAA4F3AEAA/8AAMAAAAEgCPFg +IAjxoCAI8fAgCPIwIAjygCAI8sAf/6agAA8D/wMRAAAf/5vU/f//0B//lqAf/5JoAAL//wAAnEAg +CRVgIAj14CAI9lAAAP4AIAU/jCAI9xAAACEAIAVIXCAGC3ggBguIIAYLmCAGC6ggBgu4IAYLyCAG +C9gf/5o0H/+ShCAI90AAAwACIAj3wCAI93AAABkA4QIWJAEw+EAAAYagACYloAJiWgAF9eEAIAj5 +MCAI+bAgCPggIAj5ACAI+YAgCS+gIAkwICAJL+AgBV+oBAAAAQAAIcEgCPoA4QIABOECAgDhAoIA +AAQF7uECAQThAeIAH/+aXB//mYjgAAkIA+gAAB//myQAAHkEH/+aYAAn//8AAHYAH/+ZCB//mwAf +/5bs4QByAB//mmwgBoAAAAAUACAGgRAgBq6gIAbu8CAGhmAgBoVQIAaEQCAGgzAgBoIgH///8B// +qKAf/6rwIAKKuB//qQgf/6vEH/+rBEkAAAAgCS9gIAkusCAJLxAf/5mEH/+YiB//mkwf/5pU4QB2 +AP//8A8f/5okIAj9gB//mjwgAohQIAkyECAJMpAf/5oIIAYRCB//qLj/6A//ABCAACAI/vAgBaAU +IAKIcAHIQAbhAZngIAktIAABkPggCS1g//z4fyAJLdAgBgtsAAB+UAAAfkAAAH4YIAWz7B//mgAg +Ao2gIAKNpCACjaggAo2wAFAgBuEBmgwf/5m0AHAgBv/gAAAAAiAGIAj/sOEBmgThAZoIAAQgBiAI +/+AgAoigIAkAECAJAKAgCQBAIAkAcCAJARAf/5tgAAST4P/7bCD/4XuAIAkBQCAJAXAgCQHgIAkC +ECAJAkAgCQJwIAkCoCACiLAd//DvAAAKACAJAtAgCTMQIAkzQCAJM3Af/5es4AABAN///gAf/MAA +wAAABeEB3gAgBd6EIAkDAB//m0jhAFYAIAkzoP/v///hAZTQIAkDEB//koggCQNQHQAAACAJA5Af +/5scIAYNBCACizQgCTSgIAk1UCAJM9AgCTQQIAk10CAJNPAgCTRQIAYK9B//mnwgCQQwIAXfwB// +nKAf/6xUH/+sbB//rIQf/55gH/+sWB//rHAf/6yIH/+bNB//nTDhADEAH/+YZB//mFwf/OGAIAfA +AB//kbAAAAtIn////x//mLS///D/IAk2kB//ktz/D///H/+RQB//moAgBg8Ef/AAAAAf//9sEAQk +ICHz+EgF4AYFAA8CAPyYABIwCHUACEQCJDbBJjbCG/wf/MBoHaA9JQD7+DYFoA4VAPZ4ZhWgDwUA +W7tT56BUbRAEgADApP34LAWgG0UAWNeCZiB6JDbBJjbCG/wQ/AACHaA9JQD7+BgFoA4VAPZ4ZhWg +DwUAW7tE56BgbRAEgADAof34EAWgG0UAWNdz0Q8AAAAAAPv4BAXgDAUA/AZCHeAOFQD79/oFoAg1 +APh4ZhWgDwUAW7s056AZbRAEgADApP338gWgG0UAWNdjZy+E0Q8AAAD0eEgV7/3mAPinAAyyCgUA +CpkCKTbCG/vs/AACHaA9JQD799AFoA4VAP54ZhWgDwUAW7sg56ARbRAEgADAof33zAWgG0UAWNdP +0Q8AbBAEIiEc0Q9sEAQoSgD2AAIdoEkFAOk5AQsgBIAA6YQ5AeA0gAAY+9oIRAIEBE8lICHz96AF +4BcFAA8CAPy4ABKwCHUACFUCJTbBJzbCG/vL/AACHaA9JQD7944FoA4VAPZ4ZhWgDwUAW7r/56BU +bRAEgADApP33hAWgG0UAWNcuZiB6JTbBwYAoNsIb+7z8AAIdoD0lAPv3cAWgDhUA9nhmFaAPBQBb +uvDnoGFtEASAAMCh/fdoBaAbRQBY1x7RDwAAAPv3XAXgDAUA/AZCHeAOFQD791IFoAk1APh4ZhXg +DwUAW7rg56AZbRAEgADApP33SgWgG0UAWNcPZy+E0Q8AAAD2eEgV7/3mAAAAABr7oQp6AQoKTwpK +Aio2whv7l/wAAh2gPSUA+/cmBaAOFQD+eGYVoA8FAFu6y+egEW0QBIAAwKH99yIFoBtFAFjW+tEP +AGwQBBf7kPf3IAWgCSUA/EdgAd/4BQAJLDYMDEcDzBGmzCvCzAi7AQs7AivGzArqMCVyRapVBOow +BFQMakEObQgIDeowDV0MatECY//waCI3CSw2DAxHA8wRpswrwuwIuwELOwIrxuwK6jAO6jAlckUK +VQgOXgxq4Q5tCAgN6jANXQxq0QJj//BvImUW+3AJJTYFBUcDVRGmVSZSTAhmAQY2AiZWTATqMA7q +MCJyRaQiDi4MauEObQgICeowCSkMapECY//wJlJsCGYBBjYCJlZsBOowCuowInJFpCIKKgxqoQ5t +CAgI6jAIKAxqgQJj//DRDwBsEAQX+1YZ+1IY+1L8SQAB0AolAAotNg0NRwPdEQjdCCzSy+RPEQn2 +AoAAD+4CB8wBDswCLNbLC+owJpJFC2YIBeowBWUMalEObQgIDuowDm4MauECY//waCJBCi02DQ1H +A90RqN0s0uvkTxEJ9gKAAA/uAgfMAQ7MAizW6wvqMA/qMCaSRatmD28MavEObQgIDuowDm4MauEC +Y//wbyJwGPsuCiY2BgZHA2YRqGYoYkvkRREJngKAAAUzAgeIAQg4AihmSwXqMA/qMCKSRaUiDy8M +avEObQgICOowCCgMaoECY//wJWJrB1UBBTUCJWZrBOowCuowIpJFpCIKKgxqoQ5tCAgI6jAIKAxq +gQJj//DRDwBsEAQY+xIZ+xIX+xL39iYFoA0lAP32FAWgCgUA6/sJER2xAADllAANIASAAA0vNg8P +RwP/Eav/LvLfA51ADYU5Bj0B9cAEB3BTWQDtdDgKrIKAAPSGAApwU1EAA1URBe4CBO4CLvbfDeow +JcJFrVUO6jAOXgz9wmAg0A0lAG0ICATqMARUDGpBAmP/8GgiaO6UAA14BIAADSU2BQVHA1URq1Uk +Uv8Dm0ALjjn+gAQCMLNZAOY+AQ3cgoAA/uIAD7DjUQDr+wIPdMKAAA5EAgtEAiRW/w/qMA7qMCvC +Ra+7Dr4MauESbQgIDuowDr4MauEGY//wAAAAAPRABSlSAJ0AHvrRDSs2CwtHA7sRrrslsl/2YAQH +MgIFAPJgBAEwBBUA8o0ACTAPBQAOTzj+7QANcONRAPMNAAywQ1kA5ZUBCiSCgADqRAIPHMKAAAQz +AgU1AiW2XwTqMA/qMCLCRaQiDy8MavEObQgIDeowDS0MatECY//wJbJ/BZUBBTUCJbZ/BOowDuow +IsJFpCIOLgxq4Q5tCAgI6jAIKAxqgQJj//DRDwBsEARoI0X39VgFoAclAAcnNgcHRwN3EfbgAEMw +awUA7DQAC1AEgABYCuwa+qQrKgDTD+p6CApgBIAAWArnyEvaYPygaB2gG/UAWArj9/UmBa359QD0 +QARhH+oFAPv1MgWgByUAByc2BwdH+PgAE7BrBQDqeggJ4ASAAFgK18agHPqHrHwuwv8p2v8J7gEO +TgIuxv8N6jArYkUNuwgI6jAIuAxqgRBtCAgN6jANvQxq0QRj//AAAMpKLsLnCu4BDl4CLsbnDeow +DuowK2JFrbsOvgxq4Q5tCAgP6jAPvwxq8QJj//D0QAlBUgCdAC76n/302AXgDCUADCw2DAxHA8wR +DcwIL8JHDv8BDz8CL8ZHDeowCOowK2JFDbsICLgMaoEObQgIDeowDb0MatECY//wL8JfCf8BD08C +L8ZfDeowD+owK2JFrbsPvwxq8Q5tCAgI6jAIuAxqgQJj//AowmcOiAEIOAIoxmcP6jAN6jArYkWv +uw29DGrRDm0ICA3qMA29DGrRAmP/8C3CfwndAQ1NAi3GfwvqMA7qMCliRauZDp4MauEPbQgIDuow +Dp4MauEDY//wAGRAVy3CRwrdAQ1dAi3GRwvqMA/qMCliRauZD58MavEObQgIDuowDp4MauECY//w +LcJnCt0BDV0CLcZnC+owD+owKWJFq5kPnwxq8Q5tCAgO6jAOngxq4QJj//DRDwAAbBAEFvorJWKB ++fQ8BaAJlQDnYn0ig5mAAAJ3CAl3EQdXCCZwI/zE4AlQBAUAZmAfI3AsaDIiaDEfaDYcaDMZaDRP +wEIEIgoIIgoiIl3RDwB5YdxragJraQoEIgoIIgoiIl3RD2g1TWg3Pfxh4ARQBAUA/GZABNAFtQB1 +MSoEIgoIIgoiIl3RDwwiEaKCIiJd0Q8jcDZ5McBpOabAMQMiCggiCiIiXdEPwDIDIgoIIgoiIl3R +D8AxAyIKCCIKIiJd0Q8AAGwQBBr5+imigRX57fMnkA3gDLUAK6J9orsJuxGrmyqwI/1GQAlQDZUA +ZqAqKrAsaKIyaKUv9UAV2hIAnQD1QBVYkgCdAPVAFMISAJ0A8ABYDaAJJQAAAH2h0WuqB/lAEbSS +AJ0AwJACJAmklAVECiRCffRgD/SSAJ0A/GAPtCIAnQAECUIX+dDz854F4AYlAAYmNv8gABU3ZgEA ++NgAEz+L9QDjYwgBEPeAAC0ywAvdAQ2tAi02wAzqMClSRayZCOowCJgM9wAH+JIAnQBtCA0O6jAO +ngz3wAdwkgCdAGP/6wAAAPRADjESAJ0ALTLgC90BDa0CLTbgDOowD+owKVJFrJkPnwxq8RJtCAgO +6jAOngxq4QZj//AAAAAA8oAKJxIAnQD6QGgdoAsFAPSEAAayDAUAW/786iQAClgEgABb/pFzR2kc ++aotMtwE2kLs3QENVcKAAA2tAi023AvqMA/qMClSRauZD58MavEQbQgIDuowDp4MauEEY//wAACn +bi3ifAzdAQ2tAi3mfAvqMA/qMClSRauZD58MavERbQgIDuowDp4MauEFY//wAAAA2iD0UAAFscSZ +AFv+LfKABeWSAJ0A0Q8AAC0y4AvdAQ2tAi024AzqMA/qMClSRayZD58MavEQbQgIDuowDp4MauEE +Y//wAACnbC7CQAvuAQ6uAi7GQA3qMA/qMClSRa2ZD58MavEObQgID+owD58MavECY//wLsJgC+4B +Dq4CLsZgDeowCOowKVJFrZkImAz3H/bQkgCdAG0ICA/qMA+fDGrxCWP/8AAAAAAAAADwn/YnEgCd +ANog/AACHaBrBQBb/q5j/sL/+DQNoAlFAPpAaB2jtKkAW/290Q8CJAkFRAr0j6gVr/d+AGg1cWg3 +Zmg4BWg5YHwxXf/29A2gCQUALTLAC90BDa0CLTbADOowCOowKVJFrJkImAz3H/KAkgCdAA7qMA6e +DGvh9mP+PwAAAAAAL7A2+f/rLNIAnQD/9dwNoAkVACiwNv0f6hViAJ0AY/1iAAD/9XwNoAklAP/1 +XA2gCRUAbBAEF/k1JXKB5vkoEorpgAAocn2iiAmIEahYJ4Aj/OTACVAJlQBmcB4jgCxoMiZoMSNo +NiBoMx30YAqqEgCdAPAAUA2gAyUAeXHda3oH+OAJNJIAnQDAMAMlCgZVCiVSXRP5H+NTAQKIOIAA +wlT0ZgAK8AAmAMBYBTUC9/IaBeAJJQD8R6AB3xg1AAkrNgsLRwO7EQe7CCqyhAiqAQpaAiq2hATq +MCNiRQQzCArqMAo6DGqhDm0ICAzqMAw8DGrBAmP/8GgiOQkrNgsLRwO7EQe7CCqypAiqAQpaAiq2 +pATqMA3qMCNiRQQzCA09DGrRD20ICAzqMAw8DGrBA2P/8ABvImMU+OwJIzYDA0cDMxGkM4c0CHcB +B1cClzQE6jAN6jAiYkWkIg0tDGrRDm0ICATqMAQkDGpBAmP/8CcyJAh3AQdXAic2JATqMAfqMCJi +RaQiBycManEObQgICOowCCgMaoECY//w0Q8MJRGlZfSrqBXv+7oAAGg1PGg3MWg4B2g5K8CLeDEm +//ssDaADBQAjgDb4f/X0YgCdAPh/9QTSAJ0A//rADaADFQAAAAAA//qQDaADJQD/+nANoAMVAGwQ +BOokAAnYBIAAW/6XCqQC6zQACVAEgABYAjUT+LT78WgF4AUlAAUlNvRABtGSAJ0AA1kR+yAARPPU +qQAtlogM6jAqMkUMqggI6jAIqAxqgRFtCAgM6jAMrAxqwQVj//AAAAAE/UUtlokM6jAN6jAqMkXT +D6yqDa0MatEObQgIDuowDq4MauECY//wBK1ELZaKDOowD+owKjJF0w+sqg+vDGrxDm0ICA7qMA6u +DGrhAmP/8AR9Qi2WjQzqMA/qMCoyRdMPrKoPrwxq8Q5tCAgO6jAOrgxq4QJj//AEDEYslowK6jAP +6jApMkXTD6qZD58MavESbQgIDeowDZ0MatEGY//wAAAAAPRABqESAJ0AA1kR+yAARPPUqQAtlqgM +6jAO6jAqMkXTD6yqDq4MauEQbQgIC+owC6sMarEEY//wAAAE/EUslqkL6jAM6jAqMkWrqgysDGrB +EG0ICA3qMA2tDGrRBGP/8AAABKxELJaqC+owDuowKjJFq6oOrgxq4RBtCAgN6jANrQxq0QRj//AA +AAR8QiyWrQvqMA7qMCoyRauqDq4MauEQbQgIDeowDa0MatEEY//wAAAEC0YrlqwK6jAO6jApMkWq +mQ6eDGrhDm0ICAzqMAycDGrBAmP/8Bb4RfRABQlSAJ0AA1IR9kAARTO0qQCbqAzqMA3qMCkyRayZ +DZ0M96AGwJIAnQBtCA0N6jANnQz3oAY4kgCdAGP/6wAa+ECqKlgJchr4PwSnROoqCAvYBIAAWAlu +Gvg86ioIC9gEgABYCWsa+DkEd0LqKggL2ASAAFgJZhr4NuoqCAvYBIAAWAljGvgzBARG6ioIClgE +gABYCV8a+DDqKggKWASAAFgJWwUKRwOqEfdAAEUwDBUALKaiC+owKTJFq5kL6jALmwxqsRBtCAgL +6jALmwxqsQRj//AAAMDALKaiC+owDOowKTJFq5kMnAxqwQ5tCAgN6jANnQxq0QJj//DRDyumKAzq +MA7qMCkyRayZDp4MauEObQgIDeowDZ0MatECY//wBPtFm6kM6jAO6jApMkUMmQgOngz33/gwkgCd +AG0IDQ3qMA2dDPe/96iSAJ0AY//rAAAAbBAEJiAhwHHz78QFoAQFAAtmEQdmAiYmwSQmwhv33/wA +Ah2gPSUA6vfbG/AEgAD0WGYVoA8FAFu3E+egmm0oBIAAKgoE/e+qBaAbRQBY00FmUH4mJsEkJsIa +9877754F4AwFAPwGQh3gDhUA9FhmFaAPBQBbtwNnoBEqCgH975AFoBtFAFjTM8Ag0Q8a98gZ994D +pDkJeQEEmQIJCU8pJsIa97wb9738AAIdoD0lAP4AIh2gCBUA+FhmFaAPBQBbtvFnoAzAof3vcAWg +G0UAWNMhwCDRDwAA++9gBeAMBQD8BkId4A4VAPvvVgWgCDUA+FhmFaAPBQBbtuLnoBltKASAAMCk +/e9OBaAbRQBY0xFj/zwAAAAAAPZYSBXv/NIAbBAEKiAhHfeq+gDiHeAFBQD+oGgdoIMZAPmtAA8w +LAUAWJ1p5qBTbSAEgAAc97D6AEIdogkFAOo6AQrwBIAACp45KiAh/EACHeALdQBYnV7moCdtIASA +APpEMBWhDQUA+iACHeDDAQD9bQAKsAt1AP6gaB2gHAUAWJ1T0kDRDwBsEATAINEPAGwQBBj3mQMn +Eah3I3K7/mfAD9AFBQAY93337ygFoABCAAApcrvvnydyqAUAAHZRLAPqMCKCRaMiCuowCioMaqHg +bQgICeowCSkMapHUY//wKnK3+vbmFaACBQDRD8cr0Q8AAABsEAZvOgoU94EENAqEQApAAIMQ9e7M +BeAIJQAIKDb37sQFp4gBAPkYABQ/dwUA5YUIARDLgAApUsDTDweZAQk5AilWwATqMCJiRaQiCeow +CSkMapFGbQgICuowCioMaqE6Y//w9EAG8RIAnQAoUuAHiAEIOAIoVuAE6jAL6jAiYkWkIgsrDGqx +Dm0ICAnqMAkpDGqRAmP/8NEPAAApUuAHmQEJOQIpVuAE6jAK6jAiYkWkIgoqDGqhDm0ICArqMAoq +DGqhAmP/8BX3OqWFKVJAB5kBCTkCKVZABOowC+owImJFpCILKwxqsQ5tCAgI6jAIKAxqgQJj//Ao +UmDTDweIAQg4AihWYATqMAnqMCJiRaQiCSkM9z/7+JIAnQBtCAgJ6jAJKQxqkQJj//DRD/IQoh3v ++4YA8hDiHe/7ZgDyEQId7/tGAChSwAeIAQg4AihWwATqMArqMCJiRaQiCioM91/5oJIAnQAJ6jAJ +KQxrkfbRDwBsEAQX9wwW9w30YAUdUAglABT3IgQ0CoRACkAA9EAEmVIAnQACKQkHmQopkn3xIAWZ +kgCdAPRgBVwSAJ0A9GAFHJIAnQDAq/pgBMwiAJ0ACCo2A6oR90AARTCpBQAppoYE6jAickWkIgvq +MAsrDGqxPgvqMAsrDGux9tEPCCk2A5kR9yAARLD09QAkloYD6jAM6jAickWjIgwsDGrBEW0ICArq +MAoqDGqhAmP/8NEPANEPAAgpNgOZEfcgAESwBPUAJJaGA+owC+owInJFoyILKwxqsdptCAgK6jAK +Kgxqoc5j//AIKTYDmRH3IABEsARVACSWhgPqMAvqMCJyRaMiCysMarGpbQgICuowCioMaqECY//w +0Q8AbBAGbzoOFPbgBDQKhEAKQADAiJgQFvbB9e2EBeAIJQD8R4AB3/cFAAgqNgOqEaWqK6KAKRIA +B7sBC5kCKaaABOowI2JFBDMICeowCTkMapEObQgIC+owCzsMarECY//waCI1CCo2A6oRpaoroqCJ +EAe7AQuZAimmoATqMAzqMCNiRaQzDDwMasEObQgIC+owCzsMarECY//wbyJsCCM2AzMRpToprQSJ +kIgQB5kB6YkCBVATAACZoATqMAzqMCJiRaQiDCwMasEObQgIBOowBCQMakECY//wGfaTqTklkiAH +VQEFhQIlliAE6jAF6jAiYkWkIgUlDGpRDm0ICArqMAoqDGqhAmP/8NEPwLX6IAYV7/wSAMDH/CAG +Fa/76gAAbBAEF/aJJXKB5vZ8EotpgAAocn2iiAmIEahYJ4Aj/OTACVAJlQBmcB4jgCxoMiZoMSNo +NiBoMx30YAsqEgCdAPAAUA2gAyUAeXHda3oH+OAJtJIAnQDAMAMlCgZVCiVSXffszgXgCSUA/Elg +Ad/oBQAJKzYLC0cDuxEHuwgqsoMFnVH/sAAWscXZAA3MAgiqAQyqAiq2gwTqMCNiRQQzCArqMAo6 +DGqhDm0ICAzqMAw8DGrBAmP/8GgiRQkrNgsLRwO7Eae7KrKjBZ1R/7AAFrHF2QANzAIIqgEMqgIq +tqME6jAN6jAjYkWkMw09DGrRD20ICAzqMAw8DGrBA2P/8ABvInMa9kAJJzYHB0cDdxGqd4pz9DsA +AfFFyQDoqgEKJ4KAAAQzAgo6AppzBOowDeowImJFpCINLQxq0Q5tCAgJ6jAJKQxqkQJj//AlciMI +VQEFNQIldiME6jAK6jAiYkWkIgoqDGqhDm0ICAjqMAgoDGqBAmP/8NEPDCURpWX0q6gV7/t6AABo +NTxoNzFoOAdoOSvAi3gxJv/67A2gAwUAI4A2+H/1dGIAnQD4f/SE0gCdAP/6gA2gAxUAAAAAAP/6 +UA2gAyUA//owDaADFQBsEAgpICET9gD0RFAV4AcFAP04ABSwGuUACpkCKTbBGPYfKDbCGvX56/X6 +G+AEgAD8BkId4A4VAPZ4ZhXgDwUAW7UuFPX2/UBoHeAGNQDkTNAtHTIAABr17fvr2gXgDAUA/AZC +HeAOFQD2eGYVoA8FAFu1IuoWBC0dCgAALTLC5qONbSAEgADxoAaGkZ0ZAPUgCHCSAJ0A9SAQKRIA +nQD1IBCpkgCdACggK2WAsyogISsgICsWAf1YABUwC3UAC6oCKjbBGfX3KTbCGvXQ++ugBeAMBQD8 +BkId4A4VAPZ4ZhXgDwUAW7UF5qM/bSgEgAAa9cf7644F4AwFAPwGQh3gDhUA9nhmFaAPBQBbtPzm +oyltKASAACwywgwMT5wQ5lKvatAEgAAqICEc9d0d9d7/67wFoAt1AFibimeiJY8R//9gFeAOFQD/ +zQAKcA1VAO0kICoQBIAA0Q8AACggK2SPSyckKyclHiclHyogIf3rngWgC3UA/AECHeAOhQBYm3j8 +oGgd4ApFAP3rlAWgG0UAWNEOKiArwEFkrxHSQNEPAAApIR8JDkVo4SrAkZkSHPXB/ERQFeAKRQD+ +IEgV4BtFAFjRAiogIisgI4wSLCUfWAFhKSEfCQpF9UAHoRIAnQD1QAdgkgCdAPVACKQQCwUAKiAr +wMELyzl7oZz5f/sQ0gCdAPygaB3gCkUA/etWBaAbRQBY0O4uICH2RAYd4A8VAC8kK/3YABcwD3UA +D+4CLjbBwdMtNsIa9XX76uoF4AwFAPwGQh3gDhUA9nhmFeAPBQBbtKpmor8a9W376toF4AwFAPwG +Qh3gDhUA9nhmFaAPBQBbtKJmoq4qMsIoIR3r9Y8YBAqAAPMABI5SAJ0A+0AFBOIAnQDwAmgNoEoF +AAApIR8JDkX13/lZEgCdAMCS+CBGFe/76gApIR8JDkX13/icEgCdAMCo+iBGFa/7igAa9W4DWRGq +mSqStxv1eQuqAiqWtymSt/E/+CzQCwUA8z/37RIAnQD/+9QNoAsVAAArICIc9XADuxGsuxz1b6y7 +i7DAwv1gBAW/+2IAdacK+hgCHaAASgAAAAAd9T4LrAF9wSTAoP3qugWgC3UA+kPEHaANhQD6RDAV +oA4FAFibBGP+PwAAAAAA+hACHa//ZgAAAAAvICH9+AAXsAh1AAj/Ai82wR71Vi42whr1JPvqSAXg +DAUA/AZCHeAOFQD2eGYV4A8FAFu0WeehNG1oBIAA/eo6BaAKRQD8IGYV4BtFAFjQhokT5pAYbNAE +gAAqICEc9Tgd9Tj+IAgVoAt1AFia5GataHhfdIoR+19AFaAJFQD7LQAKMAhlAOgkICoQBIAA0Q8A +AAAAAPyAaB2gCkUA/CCGFeAbRQBY0HCKFGP8bisgK2W9SmP8k8Ck/eoABaAbRQBY0GqKFGP8U8Ck +/enyBaAbRQBY0GVj/OLApP3p7gWgG0UAWNBhY/zSAC0gIf24ABawDnUADt0CLTbBwMEsNsIa9Or7 +6dQF4AwFAPwGQh3gDhUA9nhmFeAPBQBbtB/moLRtOASAABr04fvpwgXgDAUA/AZCHeAOFQD2eGYV +oA8FAFu0Fuagnm04BIAAJTLCZnyIjxEFSED57wAPsA4VAA/kOegkICoQBIAA0Q8AABr0z/vpngXg +DAUA/AZCHeAOFQD2eGYVoA8FAFu0BNmg6hYDJQDlgADApP3pkAWgG0UAWNAyiRNj/qoAAAAAAAD0 +eEgV7/qGAMCk/el8BaAbRQBY0Cpj/VPApP3peAWgG0UAWNAmY/1DwKT96WwFoBtFAFjQImP/aMCk +/eloBaAbRQBY0B5j/1hsEAR/N2IqICH6ACId4AyVAPwAIh3gDhUAWJp7KiAh/eloBeALdQD8AAId +oA4FAFiadiogIf3poAXgCxUA/+meBaAMBQBYmnADmEHqICEsHIQAAP3plgWgC3UA/ABiHeAOJQBY +mmlgABnGKtEPAAAA/emIBaALdQD8AGId4A4VAFiaYfpEMBWgC3UA/el8BeAsBQBYu6f6RDAVoAt1 +APxAAh3gDAUAWLuiKiAh+gAiHeAMlQD8ACId4A4FAFiaUsAg0Q8AbBAEKDAIyILGKtEPKiAhFPR3 +/VgAFTAb5QALqgIqRsEZ9KkpRsIb9HP8BkId4A4VAPvo3gWgDAUA/JhmFaAPBQBbs6fmoDxtEASA +APvo1AXgDAUA/AZCHeAOFQD76MoFoAg1APiYZhWgDwUAW7Oc5qApbRAEgAApQsIImTIJiRKZM9EP +wKT96LgFoBtFAFjPyAiqMgqKEpoz0Q8AwKT96LAFoBtFAFjPwgi7MguLEpsz0Q8AbBAE+gCCHaAb +RQDs9IIZ6ASAAFjPuiogIfoA4h3gHAUA9AACHaCTAQD+gGgdoQgFAPkNAA9xDQUAWJoVZqBAHfRN +HPR1/oBoHaCjCQAK3jn6RDAVoAt1AFiaDWagIR30RvpEMBWgsxkA+60ACnAsBQD+gGgdoAt1AFia +BdKg0Q/SoNEPbBAEGPRMAyURCFUI6VKAIkUZAABoQkf8hiAA0AYVACpSgMe+C6oB6laAIkT1AAD0 +gAeJEgCdAPSACIiSmekAwCAsUoAGzAIsVoDRDwndUmnTzMAg0Q8J3lJl77dj//IJ31Jp8rFj/+nA +cOokAAnYBIAAWAhK6iQACdgEgABYqBVmoBnrNAAJUASAAFjEEClSgBr0QQqZAilWgChSgMCRGvQ/ +ZHDGK6KEKqKIorsJuxGrqiqhH//odAWlqgEA9UAFGJALpQDqZAAFY/kAAAy6OCJSgx/0NA4iAQr/ +LQL/Ai9Wgy1ShBz0MA7dAQrMLQ3MAixWhC5SgBL0LRv0LR/0LevuAQJD+QAACC84D+4CLlaALVKA +Bt0C7VaALJAEgADRDwAAAPYAAh3gChUA+F0ABnAIBQDsqDgGW/UAAOunOAQA4YAA//yIDaADJQDK +mS6c/vwAIh3gBwUADtc4//z8DaAJBQD6DIIdr/2iANKQL1KABv8CL1aA0Q/AMv/7rA2gBxUAAGwQ +BCkgIcFu8+eUBeAFBQALmREGmQIpNsEY9AYoNsIa88Xr88Ua4ASAAPwGQh3gDhUA9HhmFeAPBQBb +svoX88LAQdMP53zQLQRiAAAoCqMoNsIa87j753AF4AwFAP6AaB2gPSUA9HhmFaAPBQBbsu1moIEq +ICELqhEGqgIqNsEZ8+4pNsIa86v751gF4AwFAPwGQh3gDhUA9HhmFeAPBQBbsuBmoD0rCmMrNsIa +86L750QF4AwFAPwGQh3gDhUA9HhmFaAPBQBbstfxQ3gN4AIFANEP2kD84GgdoBtFAFjPBWP/jsCh +/OBoHaAbRQBYzwHAINEPwKH95ygFoBtFAFjO/WP/bcCh/ecgBaAbRQBYzvnAINEPAABsEAQmICH1 +5wgFoAUFAA8CAPzYABMwGOUACGYCJkbBJUbCG/N//AACHaA9JQD75vYFoA4VAPSYZhXgDwUAW7Kz +56BUbRAEgADApP3m7AWgG0UAWM7iZiB6JkbBJUbCG/Nw/AACHaA9JQD75tgFoA4VAPSYZhXgDwUA +W7Kk56BlbRAEgADAof3m0AWgG0UAWM7T0Q8AAAAAAPvmxAXgDAUA/AZCHeAOFQD75roFoAg1APiY +ZhWgDwUAW7KU56AZbRAEgADApP3msgWgG0UAWM7DZy+E0Q8AAAD2mEgV7/3mAAAAAAAAGvNTGfNq +A6U5CXkBBZkCCQlPKUbCG/NJ/AACHaA9JQD75ooFoA4VAP6YZhWgDwUAW7J956ARbRAEgADAof3m +hgWgG0UAWM6s0Q8AbBAGLCBqwFP8YAAGMAcFAOTzNhYHyYAAaMEExyXRDwD95uoFoApFAPxEUBXg +G0UAWM6eHPNxHfM8KiAh/+Z2BaALRQBYmP7mob9tMASAAB7zKRXzae4WASdowQAA/CAGFeAGRQAv +ICEPAgAPAgAL/xEG/wIvRsElRsIb8x38AAIdoD0lAPvmMgWgDhUA9phmFeAPBQBbslHmoFBtMASA +APvmKAXgDAUA/AZCHeAOFQD75h4FoAg1APiYZhWgDwUAW7JG5qA1bTAEgAAjQsJmYTj+cgAM0AZF +ACkgaioK8AqZAfhNRh3gAgUA0Q/ApPwgKBWgG0UAWM5tY//RwKT8IAgVoBtFAFjOaWP/wQAsICEP +AgAPAgD9mAAWMA11AA3MAixGwRvzNitGwhvy8fzgaB2gPSUA++XaBaAOFQD2mGYV4A8FAFuyJeag +wm0wBIAAG/Lo/AACHaA9JQD75cgFoA4VAPSYZhXgDwUAW7Ic5qCsbTAEgAApQsJmYI0uIR8JGkH9 +TUAB1e4BAOiibWVD/QAA/gAiHeAEBQAI9Dh04UrApP3mLgWgG0UA7SAiKngEgABYzj4kJR8qICLr +ICMqYASAAFv+nMusKiBqGfMO+GAGFeD7BQD7QAQFcAsVAAuqAuokaisQBIAA0Q/AINEPAGjo9//+ +pA2gBIUAaOLs//54DaAEJQDAINEP0mDRD8Ck/eVyBaAbRQBYziRj/1rApP3lbgWgG0UAWM4gY/9K +AABsEAgT8q0pICH2RFAV4AYFAPYgBhWgGuUAC5kRCpkCKTbBGPLbKDbCG/Km/MBoHaA9JQD75UQF +oA4VAPZ4ZhWgDwUAW7Ha1KDzXsgN4AU1ABvynPwAAh2gPSUA++UwBaAOFQD0eGYV4A8FAFux0Aqp +AuoWAy0e2gAAJjLC5pF0bKAEgAAIaDL4gAAkMGzVAPmAHnuiAJ0AKSEYDwIADwIAZJCCKiAh/VgA +FTAOFQAOqgIqNsEZ8skpNsIb8oH8AAIdoD0lAPvk+gWgCAUA+HhmFaAPBQBbsbXmo5xtIASAABvy +ePwAAh2gPSUA++ToBaAOFQD0eGYV4A8FAFuxrNmg6hYELRyCAAAqMsLmk4FsoASAAPNACE/SAJ0A +8AAkDaAFBQAAAADAUPCMqA3gCgUAKyAr9WAEjGIAnQD0oAjIkAsFACskKyslHuslHyUBIYAA/eVE +BaAKRQD4xwAPMBtFAPzgaB3k7g0AWM3EwPQvJCAqICEc8pL6A8Id4A0FAFi5biogIRzyjvoDwh3g +DQUAWLlpGvJpA3kRqpkokoLBtP3lIAWv+gUA+wAEBDAK5QDqiAIL6ASAAPkwRhWgCkUAWM2uKyAr +wEHOtCUgIPigFrpSAJ0A/L+AFaALFQD9bQAKMAlFAOkkICoQBIAA0Q8A0kDRD8BQx9X8gBDsYgCd +AMDgnhLaIPoAIh3gDAUAW/6k+iBIFa/8bgAAAAAAAAAA6iQACNgEgABb/ulmQKkpIR8JCUVoknBo +kW31IA38EgCdAMCQwKEJqTn1IGgd7/tuAAAAAAAAAAD6AIIdoBtFAOzyYRvoBIAAWM2E+kQwFaAM +FQD8RWYdoAsFAOskICDoEQAA+gDiHeAcNQBYuQMtIR0b8jbqEQIm5SKAAHusW/ABaA2gSgUAABvy +JAN6EauqK6K3HPIvDLsCK6a3KqK3/1AgBNAJBQDzX/vNEgCdAP/9xA2gCRUAAP/5MA2gBQUAdacJ ++hgCHaAAWgAAAB3x+QusAf2ACcxiAJ0AwKAsICEqJR79mAAVMBvlAAuqAio2wRnyKik2whrx6Rvx +6fwAAh2gPSUA/gAiHaAIBQD4eGYVoA8FAFuxHRXx5uRc0C0WygAAKQqjKTbCGvHcG/Hd/AACHaA9 +JQD+ACIdoAgVAPh4ZhWgDwUAW7ERZqLKKiAh/VgAFTAb5QALqgIqNsEZ8hApNsIa8c4b8c78AAId +oD0lAP4AIh2gCAUA+HhmFaAPBQBbsQJmon8pCmMpNsIa8cMb8cP8AAIdoD0lAP4AIh2gCBUA+Hhm +FaAPBQBbsPdmonUuIR/A1//f4BWgCmUADto4HPHVA3sRrLsssoLH0A3MAQyqAvtwRhWv9yoAKSAi +GvHdA5kRqpka8dyqmYmQwKL7IAQEv/i+AIsQ7PHzGVAEgABYypXAINEPAAAAAAAA+hACHa/7JgD9 +40YFoApFAPQgZhWgG0UAWM0MiRNj/CvApP3jPAWgG0UAWM0IiRNj/BnHS/QAAh3gChUA+iBGFa/2 +UgAAAAAA/eMmBaAKRQD0IIYVoBtFAFjM/IkUY/x60pDRD8Ck/eMaBaAbRQBYzPeJFGP8ZAAAKiAh +/VgAFTALdQALqgIqNsEZ8cwpNsIa8X8b8X/8AAIdoD0lAP4AIh2gCAUA+HhmFaAPBQBbsLPnoC5t +MASAAMCk/eLsBaAbRQBYzOJnYFj8v2AVoAsVAP1tAAowCVUA6SQgKhAEgADRDxrxahvxavwAAh2g +PSUA/gAiHaAINQD4eGYVoA8FAFuwnuegFG0wBIAAwKT94sYFoBtFAFjMzWAAAicywmZvpnB/G/y/ +QBWgCxUA/W0ACjAJZQDpJCAqEASAANEPAAAHmURplRr8v8AVoAsVAP1tAAowCSUA6SQgKhAEgADR +DwAqICH9WAAVMAt1AAuqAio2wcGTKTbCGvFFG/FF/AACHaA9JQD+ACIdoAgFAPh4ZhWgDwUAW7B5 +5qCMbTAEgAAa8Tsb8Tv8AAIdoD0lAP4AIh2gCDUA+HhmFaAPBQBbsG/moHNtMASAACcywmZu+AfZ +QPivAA5wCxUADLQ56SQgKhAEgADRDwDAofyAaB2gG0UAWMyWY/1E3ED6ACIdoBtFAFjMkmP9mcCh +/KBoHaAbRQBYzI5j/STcUPoAIh2gG0UAWMyKY/15wKT94jQFoBtFAFjMhmP/k8Ck/eIwBaAbRQBY +zIJj/4NsEAQoICH14p4FoBblAPPiGAXgBQUAC4gRBogCKDbBJDbCGvEI6/EIGuAEgAD8BkId4A4V +APR4ZhXgDwUAW7A9ZqDkGvEAG/EA/AACHaA9JQD+ACIdoAk1APh4ZhXgDwUAW7A0ZqDQKTLC+kQw +FaEHBQD/K4AF0AIVAAusEQbMAiw2wSQ2whrw7/vh3gXgDAUA/kBoHaA9JQD0eGYV4A8FAFuwJGag +oCU2whrw5vvhzAXgDAUA/AZCHeAOFQDyeGYVoA8FAFuwG2egV2AAnAAAAAALrREG3QItNsEkNsIa +8Nn74bIF4AwFAP5AaB2gPSUA9HhmFeAPBQBbsA5moFknNsIa8ND74aAF4AwFAPwGQh3gDhUA8nhm +FaAPBQBbsAVmoFjAINEPAMCk/eGQBaAbRQBYzDRj/zHApP3hjAWgG0UAWMwwY/8hwKH94YIFoBtF +AFjMLMAg0Q/Aof3hegWgG0UAWMwowCDRDwDAof3hdAWgG0UAWMwjwCDRD8Ch/eFsBaAbRQBYzB/A +INEPAAAAbBAGKCAhKQoH8+FSBeAGBQALiBEJiAIoNsEmNsIa8KXr8KYbYASAAPwGQh3gDhUA9nhm +FaAPBQBbr9oX8KL6ICYVoAQ1AOV80C0GkgAAGvCZ++EyBeAMBQD8BkId4A4VAPR4ZhWgDwUAW6/O +6hYBLQYaAAApMsKKEWagsSogIfMgBizSAJ0A+gAiHeAMlQD8ACId4A4VAFiWXPpEMBWgC3UA/eGi +BeAsBQBYt6EqICH94WgFoAt1APwAYh3gDgUAWJZRKiAh/eGSBeALFQD/4VQFoAwFAFiWTCogIf3h +CgXgC3UA/+EGBaAMBQBYlkb6RDAVoAt1AP3hfAXgDAUAWLeMKiAh+gAiHeAMlQD8ACId4A4FAFiW +PMAg0Q/ApPygaB2gG0UAWMvTixFnv02CEdEPAMCk/OBoHaAbRQBYy81j/zMAAAAAAP1YABYwDXUA +DcwCnBAsNsEmNsIa8Fb74KwF4AwFAPwGQh3gDhUA9nhmFaAPBQBbr4vnoFVtEASAANxQ+gCCHaAb +RQBYy7pmIHaOEC42wSY2whrwRvvgjgXgDAUA/AZCHeAOFQD2eGYVoA8FAFuve+egXW0QBIAAwKH9 +4H4FoBtFAFjLqtEPAAAAABrwOPvgcAXgDAUA/AZCHeAOFQD0eGYVoA8FAFuvbeegHG0QBIAA3HD6 +AIIdoBtFAFjLnGcviNEPAAAAAAAA9HhIFa/96gD4hwAPsggFAAj/Ai82whrwI/vgRgXgDAUA/AZC +HeAOFQD+eGYVoA8FAFuvWOevhG0QBIAAwKH94DwFoBtFAFjLh9EPAGwQBpISjBIswCL74DYFoAsF +APgCAh2gLYUA/YYADnACBQBtig0toZR80TDrvAElUAkAAMebZpF5FvBYHvALE/AF9+CsBeAEBQDu +FgAnc0EAAP4gJhWgAd4AAAAA5r/VbcgEgAAc8E8twoT7YAQA0AsVAP1gAQXf+vUA6roDDIEKgADt +rQEJcAqAAA7dAi3GhA3qMBnv+SmSRQmZCg2ZCg3qMA2dDPegBqCSAJ0AbQgNDeowDZ0M96AGGJIA +nQBj/+sAsUT2gAY0YgCdAC4SAg8CAC7gIf3YABcwH+UAD+4CLjbBJjbCGu/c+9+4BeAMBQD8BkId +4A4VAPJ4ZhWgDwUAW68R5qCKbRAEgAAa79Mb79P8AAIdoD0lAP4AIh2gCDUA+HhmFaAPBQBbrwfm +oHFtEASAACUywuYgPWlQBIAA/qagDlACBQAK6jAZ78spkkUJmQoKmQoK6jAKmgz3X/sIkgCdAG0I +DQrqMAqaDPdf+oCSAJ0AY//r0qDRDy3ChA2tAQ29Av2QhhXv+roAxyvRD8Ck/CAoFaAbRQBYyx5j +/5XApPwgCBWgG0UAWMsaY/+F0pDRDwAAbBAEGO/6qCgngoDHnwk5Awl3AQdHAieGgAfqMBbvqSZi +RadiBeowBSUMalEObQgICeowCSkMapECY//w0Q8AAGwQBB7vnxzvn4snJSAiGO+z+2HIFeAKJQDq +WjYKpMKAAPiAAEI//+UA5DB6bVTCgABuUgnwACANoJUBAAAAwJAPnQH/uAAWsJkBAA2ZAgmZEamp +rJkokoPC0A2IAiiWgw3qMCniRa2ZDeowDZ0MatEObQgIDuowDp4MauECY//wwNAvQoAY78oI/wEv +RoAtJCsttSMttSQttEIttEHttGEukASAANEPblIH8AAYDaCVAQDAkA+bAf94ABWwmQEAC5kCCZkR +qamsmSiSgyv63wuIASiWgw3qMAvqMCniRa2ZC5sMarEObQgIDOowDJwMasECY//wEu+SLUKA4t0C +CtAEgAD8kAYV4At1AFijXGagHfqgaB2gC3UAWL9WL0KAAv8CL0aA/pAIFaACBQDRD8Ag0Q8AbBAE +KSAjhScmICL4B+IdoDS1AOVSDiTL1QAA+QIACnHDpQAjJR3yQ4Qd4AcFACckLCckICZUQCdVIydV +JCdUQvaoJh3gKgUA51UiImgcgAB/Rwh9RwJvYgIkVSInVGEmVGAmICJuYgfwABgNoEYBAMBAG+83 +/f/CHeDEAQD8gAQG8AklAOlpNg7vwoAADcwC45kRDmZCgACsmauZKJKDCogCKJaDCOowFO8pJEJF +qEQI6jAISAxqgQ5tCAgO6jAOTgxq4QJj//AU7zgDYxGkMy8ygBTvagT/AS82gCckKydVIydVJCdU +QidUQfasJh3gAgUA0Q8AAABsEAQiGsrRD2wQBIUnhV4kUSL6qBAVr+h1AOhCAQHkKIAAKAoICCIC +/mDgBhAZBQAJIgJ6JwJ/JwV9JwtuogjGKtEPAAAAAADypEQdoAIFANEPAABsEATyQOgV4AIFAIM+ +IjUjIjUkIjRCIjRBIjRh0Q8AAGwQBPJA6BXgAgUAgz4iNSMiNSQiNEIiNEEiNGHRDwAAbBAEhicm +Yg4lYSL4AIIdoCoVAPrIEBXv2YUA6VUBAfBUgAApICMKVQLoVwIEy9UAAAl1OP5g4AeQAiUAAlUC +elcCf1cK/qFgB1ACBQBusgPGKtEPJWUi0Q8AAABsEAQmIgcPAgAmYg4lYSL4AIIdoCoVAPrIEBXv +2YUA6VUBAfBUgAApICMKVQLoVwIEy9UAAAl1OP5g4AeQAiUAAlUCelcCf1cK/qFgB1ACBQBusgPG +KtEPJWUiImUjImUkImRCImRBImRh0Q9sEAQY7uSoKJOACOowFe66JVJFqFIE6jAEJAxqQQ5tCAgJ +6jAJKQxqkQJj//DRDwBsEASNKyzQBBXusY3Q/ZgAFjAIhQD5hgAOMAclAAfdNuvu9x7tQoAArcwF +zAorxoAK6jAZ7qUkkkUKRAgD6jADQwxqMQ5tCAgO6jAOTgxq4QJj//CMKyvABIzAC7sRCLsCB8w2 +6u7nHmVCgACsuwW7Ciq2gAbqMA/qMCSSRaZED08MavEObQgIDeowDU0MatECY//wgysiMASDMAsi +EQgiAgczNgUzEaMiBSIKIiKAAvJA0Q9sEATyQWgV4ATFACIwBOMyACkWwoAABCICwEIEMzYFMxGj +IhPuyw4iEaMigiACAkTRDwAAbBAE8kFoFeAUNQAiMATjMgApFsKAAAQiAsBCBDM2BTMRoyIT7r4O +IhGjIoIgAgJH0Q8AAGwQBPJBaBXgFMUAIjAE4zIAKRbCgAAEIgLAQgQzNgUzEaMiE+6xDiIRoyKC +IAJCQtEPAABsEASFKyNQBBTuXfSgCBXgByUA/HgAEbAJdQD4ZgAJ8AiFAAdVNu8iCyqtQoAApTME +MwojMoAjJQQu8ASP8AvuEQjuAgf/Nu0iCy/9QoAAr+4E7gou4oAuJQMs0ASN0P2YABYwHvUADswC +B9026+6SHu1CgACtzATMCivGgArqMBbuPiViRapVA+owA1MMajEObQgICuowCloMaqECY//wjCsr +wASMwAu7EQfMNu0iCy5lQoAArLsEuwos0ASN0CuygAvMEfehAA7/jvUA7rsBDu1CgACtzATMCivG +gArqMAvqMCViRapVC1sMarEObQgIDeowDV0MatECY//wjCsrwASMwP14ABWwDrUADrsCB8w2jSsF +zBGsuyzQBAS7Co3Q67KALmbCgAAOzAL3oQAO9w4FAO67Ag7tQoAArcwEzAorxoAK6jAO6jAlYkWq +VQ5eDGrhDm0ICA3qMA1dDGrRAmP/8I0rLNAEjdDr7lAeZsKAAAjMAgfdNgXdEa3MBMwKK8aACuow +DuowJWJFqlUOXgxq4Q5tCAgO6jAOXgxq4QJj//COKy3gBI7gC90RCN0CB+427O5CH3VCgACu3QTd +CizWgArqMA/qMCViRapVD18MavEPbQgID+owD18MavEDY//wAI0rLNAEjdALzBEIzAIH3TYF3RGt +zATMCivGgArqMAPqMCViRapVA1MMajEQbQgIDuowDl4MauEEY//wAACIKyWABIiAC1URCVUCB4g2 +iisFiBGoVSigBARVCoqg5VKALEbCgAAJiAL3QQANf+sFAOtVAQ1VQoAAqogEiAolhoAD6jAP6jAi +YkWjIg8vDGrxDm0ICAnqMAkpDGqRAmP/8NEPAABsEASCK4IgE+4MAyIRoyKCINEPAGwQBIQrhEAV +7ggDRBGlRJNA0Q8AbBAGAiMCKzIJF+4D9dtgBaAFJQDxYASoUAJ1ACc1Ao87LvAEj/DtMQQvdsKA +AALuAgX/NgX/EQ/uCATuCi3mgAzqMArqMBvtoCmyRQyZCAqaDGqhD20ICAjqMAiYDGqBA2P/8ACP +Oy7wBC0xA4/w/dgAFzAIhQAI7gIF/zYF/xGv7gTuCi3mgAzqMArqMCmyRayZCpoMaqEObQgICOow +CJgMaoECY//wIjEC0Q8W7dsqMQIc7a/+IaId4Q1VAP1FTg3hDhUAetJyiTNkkPqLN+01AiTz/QAA +njMGuwEMuwL6YOYV4QJVANEPAAAvGgJ/ohH74Ah7IgCdAPhgaBXgAHoAAAD/QApLIAtFAPvACTsi +AJ0A6zYDLcgEgABkkLyCN+81AiTD/QAAmDMGIgEMIgLyYOYVoQIlANEPACc6A/dABSNiAJ0A+uAJ +4yIAnQCKM2ShQLCp6TYDKdAEgABb/u+LOAs8QvuACjmiAJ0AjTf6QAAHv851AO6+AQ//QoAAD+4C +njge7VcnNQIG3QEO3QL8YOYV4wI1ANEPAIk4CTlCa5YH+SATYhIAnQD1IBQjEgCdAPUgE2OSAJ0A +wKD6YGYVoAkFAGWfBIw4Hu2Vx90NzAEOvgEuNgksNggvSgj+YEQd7/jyAH+iRnrySYI3GO2NLjUC +BiIBCCIC4jYHLxAEgADRDygaBHipK4kzZJ+L+mDoFaECRQDiNQIk2/0AAJsz90AEBTILBQALqgKa +N9EPLBoGfKGk2jBb/sWNNy4aDS41AgbdAfxg5hXhAtUA0Q/A/3+p4MCwiTmxu/M/7eBQihUAmxN7 +qgob7W/6YEQd7/a+ANowW/5iHO096xIDJX7BgABgAEMsOgf9X/p0IgCdAGP/oY039GBmFeECRQAi +NQL3oAQGsg4FAA7dAp030Q+PNxLtDCc1Agb/AQL/Av5g5hXjAjUA0Q8AAI47LeAEjuD9uAAWsA+V +AA/dAgXuNgXuEa7dBN0KLdKAwIb86AAFd90BAG2KYw0fEvwCAAXwjQEA+CBGFaDtCQD/BEYNoNqN +ACg5CfggJhWgmgkAebEKsYn4YSQd4AAqAACwiCg1CXvhH4kS+mGCFaC6EQB7kQ2xrv5hhB2gADYA +AAAAALCoKDUM6tQAD+gEgAApMBb1IAbqEgCdACs5CfogJhXvCgUA+0AGueIAnQBqvwmKOPFADA+S +AJ0ALjEKtu4uNQovMBz14AhiEgCdACo5DCj6APsACFmiAJ0Aaq8JiTnxIA7YEgCdACoxDbaqKjUN +KzECLRoG/WANLGIAnQAvMQoe7Nx/4xIoMBYAiDJrhAmJOPE/85+SAJ0AKzENGuzV+1/vW+IAnQAt +MBwA3TL5v+7qEgCdAI458d/yaBIAnQBj/csAAAAA+ACiHeAPVQD+YGYV7/aaAPgBgh3gCMUA+GBm +Fa/2WgDAmZkz//YoDaAJlQCKOPFf+k+SAJ0AY/8Zizj8YOgVoA0FAC01Ci01CfeABAY//dUADbsB ++mEGFeINBQANzAKcN/FgBp9SAJ0A/mLQFeECZQDyYEQdr/61AA6+Ae42CCf4BQAA/mLGHeECZQDR +D4g58R/4qBIAnQBj/uqJOB3s2/pg6BWgCwUAKzUNKzUMizkGqgEMqgKaNw27AZs58SAH/9IAnQD+ +IMIdp9rBAP5gRB2v/OUA7JwBBugFAAAtNBz8YQYVoQJlANEPAAAAAAAA/mDoFeAIBQAoNQooNQn3 +4AQHsQgFAAj/Ap8380AIz1IAnQD4YtAV4QxlAPxgRB2gC0UAC6sC6zYIJMgFAAD4YsYd4QJlANEP +wPD+YsYd4Q5lAP5gRB2v/bUADb0B/GEGFeECZQDRDwAqMB/AgOg1AiUEEYAAwpp5oHga7Kv6YEQd +r+pqAAAAAPpg6BWgCwUAKzUNKzUMG+xSiTgGqgELqgKaN/MgBY/SAJ0ALhoG/mBEHaANFQD9JgAO +98rBAO02CCZgBQAA/GOGHaECZQDRD8CA+GOGHa//5QD/IAQH8QJlACI1Av5hBhXhAmUA0Q8AAAAA +2jBb/bvqFgAp0ASAAFv9q4wQAKsy8YcADjAZNQB8kgnA3vugBjtiAJ0ALDAQe8p3jDlyzk8rMBGx +uwsLR/piJh3gAToAwOD+YsYdoQ1lAPxgRB3gDEUADKwC/GEGFaECZQDRDwDAgPhjhh2gDxUA/yYA +D/ECZQAiNQL+YQYV4QJlANEPAMCQ+GImHeALBQAd7GoNzQLtNgktvNAAAB7saP5gRB2v5hIAfLoU +jDlyxiQrMBGxuwsLR/piJh3gAI4AwMD8YiYdoAsFAGi3z/piBh2v9A4AwND8YiYd4AsFAB7sWA7O +Af5hJhWv/4YAH+xW/mBEHe/k0gAAbBAEiyoqsAQV6/WLsP1YABUwByUAB6oCB7s2BbsRC6oI9UAB +BXA5BQAppoAI6jAW6+okYkUIRAgD6jADQwxqMQ5tCAgM6jAMTAxqwQJj//CJKiiQBImQ/RgAFDAK +NQAKiAIHmTYFmRGpiPUAAQRwBBUAJIaAA+owDeowImJFoyINLQxq0Q5tCAgK6jAKKgxqoQJj//DR +DwAAAAAAbBAEFOwsKEB98wAH39ANFQAZ7Ckc7CoqQi8b7CkMqgwKmzjvOiFt4ASAAB7sJg4+Co7g +CuAAAAAAHuwjG+wkLyz9D+s5C8sC+dhEBeAHJQAe69IHKjYDrBGuzCjCuC7CuB/sHAmIAQm5AQ/u +AQ6+Ai7GuPkABIxiAJ0AL0B8/edgEl/15QBuIjP+X8AV4As1AP4AIh2gBgUA7+Y4C5gEgAAGszkF +aQHo7Awcz8KAAAlmAglmEQhmDCZtWIZjLsKB0w8N7gIuxoEL6jApQiCrmQjqMAiYDGqBDm0ICA/q +MA+fDGrxAmP/8CjCgQWIASjGgVv0DylAfG+UVW4iUm4yC/AAKA2gkwEAwCDRD8CQBz42BZ0B/7gA +FrDJAQANzAId6+/j7hEOZkKAAK7MrcyWwAvqMClCIKuZC+owC5sMarEObQgIDuowDp4MauECY//w +0qDRDxrr1Bvr4vxigATTbgUAwPt/MQpvIgf717wF7/tqAC8s/Q+6OQrLAv9mAA2/+yYAAGwQBBbr +uKYmJWKAx38HNwMHVQEFRQIlZoDRDwBsEAYsIAH316AF4AWVAOMgACYCWYAAdcFDaMlAWMQx/OQo +FeAMBQBYx9otIgQuIgX9QZYN4AwFAHrZAnvrAcDB8YFgDeAIpQD4QCYdr5klAOkkAiyQBIAA0Q8s +IAEW600e67sd62X71pwFoAm1APmABcLgBAUAGeu2CckKiZAKkAAAAAAAWMQX/OQoFeAMBQBYx78f +67Ac66rTD++7CA3wBIAA/2DSDaANJQCxqpsl6iYELlgEgADtOjYJmBwAABvrkRzrpQOqEdMP/UAA +RTAMBQBb/8RYxAP85CgV4AwFAFjHqx7rbA8CAA8CAP9gAEewDBUA6/sGfWgEgACxrZ8nnSYsJAFY +w/f85CgV4AwFAFjHn44mLyIH+8GWDaANBQB66QJ/uwHA0cjUxyXRDwAA7OuEGZgcAAAc63P71w4F +4AolAAo6NgOqEeuqCA5YBIAAW/+kWMPj/OQoFeAMBQBYx4wd60ytvevbBn1gBIAAsaydJ/xAxhWg +DiUALiQBWMPZ/OQoFeAMBQBYx4GNJo4n+6GWDaAMBQB62QJ+uwHAwWXPhsCDKCQBL3CA0w9v9Af0 +f/uxUgCdAPpgaB2gC6UAW/8nZqNJwJQpJAH6YGgdoAulAFi7Vx3rCO7rXB0WWgAA2UAf614DPBGv +z+vq8hfAEwAAm4DrIQIn0BMAACSmABrrWAsIQNMP6Kk5BfhAgAAY6zoPAgAPAgAImQJ9twga61EP +AgAKmQLyIAYVoIsZAPqAaB2gQgUACCo54hIAJewogAAoCoAIqgL71fAFoIoxACYWAgimOQaZAuYS +AiXoKIAAGurbCpkCGurOqsqZoq3ILoa36Os9F9gTAAD5YAYVoAtVAPpAJh3gACoAAAM8EarKi6Hx +YAkO0gCdAMC6+kAmHe/5VQDpJAIskASAANEP8SATd5IAnQDA0vxAhB3gDHUA/EBmHaAKJQApIQIP +AgAPAgB8lw0uIQN75wfA+A+qAiolBHuXDSghA3yHB8GQCakCKSUEwLYrJAEqcIBvpAf0f/ExUgCd +AOsgAynQBIAAW/7TZqHhwMcsJAHrIAMp0ASAAFi7A2egEvpARh2gDaUA7SQBLRAEgADRDwAtIQQb +6wv4eAAVMBwFAPtAAEVw3SkADcQ5/IBoHaAbBQBb/yFYw2D85CgV4AwFAFjHCRzrAKy8e8sBsaqc +J/pAxhWgDYUALSQBWMNX/OQoFeAMBQBYxv+NJi4iB/1Blg3gDAUAetkCfrMBwMFkzX70QCYd4AIF +ANEPwCDRD3m3JRnq7o+r8eAHr5IAnQCIo3CHE5mk9UCmFa/yVQDRDyIgAgAiMtEPrcgogrf/H+n+ +IgCdAMLBi6PAkOQlAyWgZIAAwJEpJQP/YYAAUAkVAPxAZB2gKRUAebYHwKQKmQIpJQN6tgfA0g2d +Ai0lAy4hAsTw+oBoHaCOGQDo+jkHbCiAACkKgAmqAvvU9AWgyjEADKY52mBYUjIKbkD4gGgd4A2F +AO7ZOQVgJIAAwfAPmQIoIQMqIQIJiAIIqQHoJQMk/XSAAMCx+kCEHeAKhQAqJAPxP/HWkAoVAPoE +Ih2gLBUA/ECEHa/4qgAAAAAA+kBGHaANpQDtJAEtEASAANEPj6aIp/H/+QQSAJ0AmaT1QKYVr/JV +ANEPAAAAAAAA8T/up1IAnQAqIQTAxfxAZh2gC0UAC6oC+kCEHa/3WgD6QEYdoA2lAO0kAS0QBIAA +0Q8AAAAAAAD6QEYdoA6lAO4kAS0QBIAA0Q/A+v5AJh3v6aUA6SQCLJAEgADRDwAAbBAIKCEYgyf0 +RFAVoAeFAPoAQh3gBQUA4zIOJBTpgAD8giBBUA2VAPAALA2g5AEAAAAAAADeUPnUGAXv/OUADO8B +//gAF7COAQAPiAILTzbpiBEP/MKAAK+IqYgogscvMEEW6nfq6moUaF6AAGTx4f3gG6RiAJ0A9eAb +DJIAnQD94BTkYgCdACiggA8CAG+ESCkwQP7YiBWgCDUA7Jz+LJDoAAAMizgsYsiuvgnuEQ7MCC7C +Bwu6Au7iDieZqYAA9eAbOZIAnQD14BQDEgCdACo8QFv+fWAABgAqPEBb/nrA4erqOQ0wBIAA7aQA +AxRRgAD4ACIdoA8FAA2POGTxsCkxJNMP8SAG19IAnQAqMGH1QAZ7EgCdAOYwYCUNYYAA9UANI5IA +nQAL6jAc6kUswt+aFv1gVauiAJ0AHeo1GupALdIhK6bf+1vIFaAMBQBYxkIuMhovMhv/QY4NoA0F +AHrpAnv7AcDR6hIGJorhgAAf6fIuMiUP7gLuNiUh0cEAAFv8Bin6khvpuANqEauqJaZE9UjGFeAI +dQAoNGH4bEYd4AQiAAvqMBzqJizC3/1gUtOiAJ0AHeoWGuohLdIhK6bf+1vIFaAMBQBYxiMf6h3v +uwgN8ASAAH67AbGqKzYxKjYwGem3A0gRCYgIKIKNfo9PC+owGuoSKqLf+2BO66IAnQAd6gMa6g4t +0iErpt/7W8gVoAwFAFjGEC4yMC8yMfvBlg2gDQUAeukCf7sBwNHAoPfyQh2v/lUA/c0AC3AAGgDA +oWZg4C8gK3r5EtJg0Q8AKCArDwIADwIAZIGEwKDqJCslDdEAACUlHyUlHiU1IyU1JCU0QiU0QfRs +Jh3gAhUA0Q8AAAAA9UA0IRIAnQAa6e4pMiX0cgYd4As1ACs0YQqZASk2JceV5pQABPfBgAD//jwN +oAoFACwgK2TB8PqgaB2v/nYAAG+o2xjp4AioCoiACoAAAAAqMSTAkvRDxB3gqgkACpc5JyUfKTEj +/yHABxAKBQDEsPpDxB3gSgUAe5cILAqADKwCLCUe2kBYl+L0RAYd4AIVANEPAAAAAAD/93ANoAYF +APogRhWv/VUA/MAj/GIAnQAlNSMlNSQlNEIlNEH0bCYd7/v+ACrgQWShLS8KCf9ACTxiAJ0A9UAI +/JIAnQAuFgH1QAijEgCdAP/1sA2v+lUAKDEk8x/rn9IAnQAc6U8DSxGsuyqygcLADKoCKraBC+ow +GempKZLfnRX5YEK74gCdAB3pmRrppS3SISum3/tbyBWgDAUAWMWmH+mk77sIDfAEgAB+uwGxqo0V +KzYx+mYGFa/0ZgAoICtljnrAINEPACkgK2Web2P/8SvgQci7wNl9sQf5f/uM0gCdACngYciZaJYH ++T/7C9IAnQAowRhkjKacEPdAGrFSAJ0A8A1ADaCaAQAq4EEPAgAPAgDJoMCZeaEMaKkJnhH5X/lh +0gCdAO4WASHRAQAAW/2dixErsEFkvITAyf1/4/wiAJ0A9X/jvJIAnQCOEbG9/cgmHe/xrgAAAAAA +AAAA7hYBIdEBAABb/Y+NESvQQWS8TMD5/3/iPGIAnQD1f+H8kgCdALG4+agmHa/w1gAA0lDRDxro +7QNpEaqZKZJG8T/vJtIAnQDAtis0Yf/3ZA2gCQUAHujlA20Rrt0v0kbx/+4kUgCdAMCT+GwmHeAI +BQAoNisoNiopMTp1lw/xIB9lEgCdAP/x+A2v+bUAKTIl0w/zIAZY0GnhAHSWQgvqMBrpSCqi3/tg +OBOiAJ0AHek4GulDLdIhK6bf+1vIFaAMBQBYxUUuMiovMivTD/vBjg2gDQUAeukCe/MBwNFk0IAq +PHBb+w78ZKgV4QkFAOmpAQVcPIAAGukk0w8K3QItNiUf6TTAgQmJOe/dAQzxQoAADt0C7TYlJpEY +gAAL6jAZ6Sgpkt+dE/lgNIviAJ0AHekYGukjLdIhK6bf+1vIFaAMBQBYxSWNE/9gaB2j64UAC+sI +frsBsaorNisqNioNxlBkbMLAxCw0YSowkMDe/UAOsuD29QAe6RgOrgqO4ArgAG5iB/AAGA2gpgEA +wKAmNi4mNiwlNTolNh8lNIAlNIElNUElNUIlNIYlNUQlNUUlNIwd6Qse6QkvMiT6AcId4JoBAPtA +BAXwChUA+2YADT/IdQDr6Nod58KAAAj/AQycAuw0vC1XwoAA+yYADL/4tQAI/wEa6Pz8ZQgVr/jV +AAj/Afh2hh3v+OUACP8BKTIlGOj2LzYkDswBJTSQLzIkDcwB+yAEBPC+BQCuPi42JwqZAR3ouBro +5wj/AS82JA3MAfuABAZwvYUArT0b6N8sNigtNiYLmQEKmQHpNiUh0cEAAFv8ah/oYANuEf/AAEdw +DyUAL+ZEJeZGwNMt5kYL6jAc6M8swt/9YCiLogCdAB3owBroy54ULdIhK6bf+1vIFaAMBQBYxMwf +6NGNFO+7CA3wBIAAfrsBsaorNhv6Y0YVoAgVAPhsJh2gADIAHuhGA20Rrt0v0kbx/9pekgCdAMCC ++GwmHa/12gApMGLxJwAMv+ziAMCQx84MnAH/mAAWMLkBAP1mAA2wDCUADKw26bsRDmTCgACsuxzo +M6y7K7LH82ARTpIAnQAvMEFj+RAAAAAA2iD90NwFoAsFAFjBEPogSBWv6g4AHeiqLDIjKzIk9m4A +Fa/MQQDtuwEOZoKAAOy7AgtQBIAA+mSGFe+7MQBb+mUqMiQKak9qqyLBsHq6LRvoH/tAB/tiAJ0A ++2APeaIAnQAsreBlynRgAeEAAPdAGeCSAJ0A+V/S4RD29QApMij1QBmgkPb1AAeeEf3REAXs7g0A +se4ODkftnQEPdEKAAA7dAi02KC8yJ4/wGOgCA/8RqP8v8kEPD0dk8uUoMieIgBnn/QOIEamIKIJB +CApH6DSPJQHRgAApCip5oC8qMiT4ZQgV4AwVAPxx5h2vujEA9WAXyJIAnQAf6G0e5+YtMiUPnwEv +NigO3QItNiX6bgAVoAsFAFv6LygyJ4iAGefmA4gRqYgogkH4382OIgCdAMCV+HIGHe/m+gAc594D +axGsu/doxhXgClUA+mwmHa/mmgAAAAD5X8wmUPb1ACkyKPVAFRESAJ0AB54R/dCgBezuDQCw7g4O +R+2dAQ90QoAADt0CLTYoLzInj/AY58oD/xGo/y/yQQ8PR8z4wIb4cgYdr+VOACkyJ4mQGufCA5kR +qpn5KCgV4AsFAOk0jyHRwQAAW/oEKjIniqAb57oDqhGrqiqiQXpgCcC3+nIGHe/kWgAqMI9kqPTC +yv1fx34iAJ0A+m4AFaALhQBb+fYtMieN0B7nrAPdEa7dLdJBDQ1HZdDu9nIGHe/jdgCeESXlIyXl +JCXkQiXkQeXkYSdRAQAAW/w4ihD9z8IFoAsFAFjAg/4gKBWv9sYAACY8cNpgW/ncCgtHzLjAwvxy +Bh2v4l4ALTInjdAe55MD3RGu3e3SQStQBIAA/HHmHeALBQBb+dUmCv8uMieO4B/niwPuEa/uLuJB +/t/CLiIAnQDA8/5yBh3v4UoA9m4AFaAAmgAmPHDaYFv5wwoIR8yIwJz4cgYd7+DOAPrAaB2gCwUA +W/nB2mBb+bsrCv/7f8AOIgCdAMDN/HIGHa/gOgD2bgAVoAIKAPZuABWgAVYA9m4AFaAAqgAtMieN +0B7nawPdEf+gAEawCwUA7dJBIbHBAADtNI8rUASAAFv5q9pgW/mlLgr/euAJwPn+cgYd797uACsy +JPrAaB2vuzEAW/mj2mBb+ZwKDEfMzsDa/HIGHe/eZgAAAAAAAAD6wGgdoAsFAFv5mdpgW/mTLgr/ ++9+7DiIAnQDA+/5yBh3v3boAJjxw2mBb+YwoCv96gELAkfhyBh3v3VoAwKT6cgYdr90yAAD7X7lg +kgCdAGP/1A+cEfvPdgXszA0AscwMDEfrmwEOYkKAAAy7AvplBhXv8z4A2mBb+Xj6ceYdr9vmAAAA +AAAA/c9eBeAOJQAOrgIuNiQNnQH8ZQYV7/QuAA+fEf/PUAWs/w0AsP8PD0fungEP+kKAAA/uAv5l +BhWv9YYAGeeZKJLesYj5O8YVr9huABrnlSmi3rGZ+VvGFe/VDgAc55Eqwt6xqvubxhWv3oYAHeeN +LNLescz9u8YVr9Z6AB/niS3y3rHd/fvGFe/rngAf54Uu8t6x7v/7xhWv49oAGOeBL4Lesf//G8YV +7+WeAGwQCCQiGRzniCMgB/yAkBXgClUA/oAIFaA7BQD+gLAV4TMBAFjCZClABSgKcnmDCMAg0Q8A +AAAAABznfI9ILUAE/oAIFaAIFQD/4AgV50UBAOMWACIr+QAA9Q0ACvAKVQD0ICYV4DsFAFjCU/pA +aB2gC4UA7RwQKeAEgABbl6zu52wVAemAAI0gwPCfoQ7dAp2gHOdo6RIEKd8CgACsu+m2ACIWNQAA +iif6ACId4AwFAPtEABWgDRUAW6UMwCDRD9og7OddGtgEgABbl37AINEPAAAAbBBIG+cuGucAK7B9 +KKKAKaKIIxaF5RaALEZCgADpiAgF/ESAAC4KgK6O/jDGFaAAMgAvKoCvjy8WhogniI4ionkrgoWr +IgkiEaKS9oAJWJIAnQDl50UQ+QEAAO8WhCCYgQAAIxaC5RaBJDALAAD2MGYVoccFAPXOegXgBgUA +8854BeABSgAAAAAAKRKEbaoFCACGCQJhp2b2ISYV7kgFAKhEjieNIv3OZgWgClUA/8KCFaA7BQBY +wgvqJAAI2ASAAPwEAh2gDSUAW6Fx9oAFUJIAnQCKJyqsIFug+isSgdgQ/DDIFeDvFQD6AAgd4CkF +AG2aAggCYY4gkxCVEi8UGP3AABcwLwUAD+4CnhEu0Act0S4ODkEA7hEO3QIe5rErEoIoEoMO3QKd +FAzqMJwVJxUPCCCGCwJjCACGKBKFCwJhCGgI9P/6EyAaxQApEoAb5tTTD+oSCCSAUYAAC6oCKhYI +KhKE7EQADFgEgABYvLWUGf/8sA2gBAUAwCDRDwAAbBAEijcFQgj7QcgVoAsFACskACVAAPNgaB3g +PKUA/KAJFCApxQBkUTJtCBCxM6Q1J1AA7HEKesAEgADIcmP/6AAnUAErVAD45QYN4AMFAMpw9QBo +HeADBQBtCBEnUAKxM+lxDnKoBQAAyHZvNQRj/+cAAKg868QBIYKBgAD4DAId4AcFAPUAaB3gfKUA ++gciHeAo9QBtOi0jUAFziwpzswfyegAV4ABaAHObC3PDCPJ1IBXgACIAACM8yQd3CuN3CQKoBQAA +YAABwHD8AAId4AwFAPAAZA2gK+UALpAAsZgOiTnsXAIMoASAALHdaNQ3I0AA5D/0bmYCgAD6Z2YN +4AgFAMBQbQgaBVUK41UJBEAFAACkiSOQAOQ/v2KrQQAAezG3Y//eAADsppIlMAsAAPbERB3gAgUA +0Q/ZQP/+bA2gBQUAJUABK0QA+KRGDeADBQDJWviAaB2v++YAJUABK0QADwIA+KDmDeADBQBlX+P4 +gGgdr/v+AGwQBBvmnws7CyOwgNog67IhKeAEgABYvE0b5poY5psNRBGrS6hEJECA8mAARTA81QDs +pAAlUAUAAOuywSpgBIAAWLxCpDzzgABHMA0FAO3kAiYQCQAA0Q9sEASGIPpgBADQBBUAAEMadjAE +wCDRDwAGMwLjJgApkASAANEPAAAAbBAWgjcY5noc5oGCLugABQCogQAA9ACoHeOEBQD0QABCMoMF +AKMlL1D+LlD9LVD8KFD/mBArQACbESpAAZoSKUACKRYD+IBwFaA7BQD4IIYVoApVAFjBRRzmbi9A +Bi5ABS1ABChAB5gQK0AImxEqQAmaEilACpkT+IFwFaA7BQD4IIYVoApVAFjBOClQ2CkUNORQ2iDQ +4QAAW0TPKhw4+iaAFeAMFQBbRHopSoCpKSqQXvFBcA3gDAUAbQgMKpBfsczkoAdkyAUAAGP/7CtK +3usrCADQ4QAAW0Rt/IBoHaNbtQDrKwgA0OEAAFtEaeocOCDYgQAAW0QZwLD6JAAVoBwFANMPbcoT +LaAAoryjzCzA/LG77NkIdVAFAADAINEP/YDWDe/69QDAoWSv7sCi/cxyBaA7BQBYwQ3AIdEPAABs +EAYoIADDkHmJLCsgAR/mMvvMZAWgXIUA/WAJbCIAnQAtCnj9YAkUYgCdAC4KQn6xCigKYnixBMYq +0Q8ALCAC84aADeAHBQDyIEYV4D7VAP+AFqQiAJ0A28Dz5BAV4AYFAPnMPgXgBQUA+CAmFeAEBQAL +DUf8ZUYN4AsFAOrmGR/gBIAAbQgXKKCAsbvkgJ1lUAUAACnAIe2RB3ZgBQAAY//hiRGpufEoMA3t +bQUAGuYLCpkMrZlmkHPqVREDMAUAAOWVAgsguAAAiBL0gGAVoAYFAPUARh3vpYEA+wAGHaiVHQDp +hAEkQA0AAPggRhWgBQUAsXeieiygAuvEAAYA4YAA/5/7XSIAnQDIzH65HSugA+W/9mVQBQAAZGGP +9MAQ8RIAnQD0wBFBkgCdAMZK+gCiHaA7BQDs5ewaaASAAFjAutJA0Q8AAAArIALn5ecZqASAAPxA +QBXtjAUA8WKQDeAJBQBtCAwuIAOxmeTgCGEQBQAAY//sAAkLQAsIBgm4O/UACaCSAJ0AwCAr0ABk +sEXj8AAuoASAAPIgBhWgBgUACw5H880GDeALBQDs9AAL0ASAAG0IFyiggLG75IAVZVAFAAApwAHu +kSF2YAUAAGP/4QAAAMYq+gCiHaA7BQDs5cQZaASAAFjAkNEPHOW7/WAARj2KBQB6wdpmv9cqQAFk +r9Fquxj7f0AV4ABWAAAAHuWyKNqAeOG7KkABZK+19WBoHafqAQDzycYN4AsFAOz0AAvQBIAA0w9t +CBcpoICxu+SfkGVQBQAAKMAB7oEHdmAFAABj/98Z5aH5YABE/YoFAPs/+3wiAJ0AZr9narsW+39A +FeAATgAAGuWYLNqA/V/6lCIAnQClaOYSACp3AoAADr4C7oQAIRAFAAAGJgwNZAkrQABlvvhj/yvA +QMaK9QIACj/58gAAACTQACnwAPUohg2gDgUA63QAD5AEgAAosIBkjv8pIAHu7AEl2AUAAOSZ63EQ +BQAAquv9f/c8IgCdAObu32boBQAAausT+99AFeAASgAAAP1f9lQiAJ0Asd3b4Os0ACGoBQAA//mw +DaACFQAAAAAA68QACVAEgAD2AAIdoAUFAP/3RA2gBAUAjRL0gCAVpMUdAP2gBh2v/YIAjxL0gEAV +qoUdAPngBh2i5R0A/+AmHa/9GgBsEAwoIAUpCpX5AAlcYAYFAP3KugWgClUA/GJoFeA7BQBYwCcp +MhP8ACIdoYQFAP8igArRqfEA9UAIyJG54QD1YAiIkgCdAIUnhV4rUpCkVCZEkY0wLVaH7ESSJYFh +gAAY5R4c5LUd5UnouygJ0ASAAFs+oRrlRykyEwqZAuk2EynQBIAAWz6AHuUx+8msBa+bJQArJAUb +5QApoogqooArsH35yngFoIwFAOZEkS1WQoAA6pkIBfw4gAD9IABEsAAuAAAALSqArZkd5R+LIJgW +/iAGFaAMRQDtFgIt3gKAAAy7ApsRKpAHL5EuCglBAJkRCf8CCP8CnxQO6jCWF+4WBSLICwAA6WYA +ANCBAAAKDIoJQIgKCIoJIIgKBIoJAIgKAIrqJAAI2ASAAPwAgh2gDSUAW59O0Q/aIFs+T48t9kak +Ha/45QAI/wH+QaYV7/sOAAAA+mBoHaALBQD8AAIdoA0lAFtBIdEPAAAAbBAKkhiVGfaAC1iSAJ0A +8gACHaAGBQDwAPQNoDfVAAD3YAl0YgCdAMDQJmzq9ILAFa/rpQD8AAIdoA4FAIoYjxkLawyrO68v +W0NnoqJmISf2gAkgkgCdAKNvK/AAZL+/92AHdGIAnQBqQbzb8P6AAELwDQUAbQgaLrABsdrtpAAF +4AUAAOvEAAcAeYAAd+EKdcoEY//eAAB36Y4owAHAsOvEACVwBQAA5IOeZmAFAAD1wBtxogCdAMDg +bQgTse6t66+5KZAB5JAMZdAFAAB0qgZj/+UAALG6BKkMCbo476gIBUgFAAD3IABDMAsFACuEAOlE +DAzYBIAA99/6AZIAnQBk4oMvwABk8n0V5LglUtuZEOpQACcN44AAf6lw9CAmFeALBQBtCCbr6QwF +2AUAAPUgEqCSAJ0A9yAS6RIAnQCKEay1JVAAqroqoAB1qUBj/9Io8AH94CAVoAkFAOn0ACQXuYAA +9oATeRIAnQD//RwNoA0FAADAIPoAoh2gOwUA7OSrGWgEgABYv3LRDwDV8IsQnxd6UxH1QhYN4A8V +APAAIA2gDwUAAADH/2Tx2RXkjyVS18Dw6lAAJwzjgACIF5UWeKksbQgm7+kMB/gFAAD1IA2gkgCd +APcgDnESAJ0Aihas9SVQAKr6KqAAelkEY//ShRd6UxH1QhYN4A8VAPAAIA2gDwUAAADH/2TxeRXk +dyVSncDw6lAAJwzjgACIF5UVeKksbQgm7+kMB/gFAAD1IAqgkgCdAPcgC+kSAJ0AihWs9SVQAKr6 +KqAAelkEY//ShRd6UxH1QhYN4A8VAPAAIA2gDwUAAADH/2TxGRXkXyVShcDw6lAAJwzjgACIF5UU +eKksbQgm7+kMB/gFAAD1IAegkgCdAPcgCWESAJ0AihSs9SVQAKr6KqAAelkEY//ShRd6UxH1QhYN +4A8VAPAAIA2gDwUAAADH/2TwuRXkRyVStcDw6lAAJwzjgACIF5UTeKksbQgm7+kMB/gFAAD1IASg +kgCdAPcgCEESAJ0AihOs9SVQAKr6KqAAelkEY//ShRd6UxH1QhYN4A8VAPAAIA2gDwUAAADH/2Tw +WRXkLyVSn8Dw6lAAJwzTgACIF5USeKkobQghD+kM6JE5Z/gFAAD3IAXhEgCdAIoSrPUlUACq+iqg +AHpZBWP/1wCFF3pTD/VB1g3gDxUA8AAYDaAPBQDH/2X8tMCl/chSBaA7BQBYvvDHL9EPihGstSVQ +AKq6+0AQFa/3qgCKFqz1JVAAqvoqoABj/jqKFaz1JVAAqvoqoABj/ouKFKz1JVAAqvoqoABj/twA +9IAEYJIAnQDAkcDg/yAARHANBQDthAAk2AUAAPdgAEMwDQUA+o8ACn/w9gCKE6z1JVAAqvoqoABj +/wCKEqz1JVAAqvoqoABj/00E6wwLrjjZ4P8gAERwDgUA7oQAJNgFAAD3YABDMA4FAPqPAAp/794A +BOsMC644+cBoHe//WgBoQRT//gwNoAkVAAAAAAAA//3YDaAJBQD//bgNoAkFAGwQDi8wJPXHcgXg +BgUA9BJCHaCHBQDjIhAnhTmAAGjxL/ngBOISAJ0A9+AEoRIAnQDApf3HxAWgOwUAWL6oizouMAWK +uHThfNogWBFFwCDRD8Cl/ce2BaA7BQBYvqCLOi4wBYq49cALJCIAnQAsIhMPAgB4xyEqIgf6AEId +4AwFAPtEABWgDSUAW6FhKyITLPp/DLsBKyYT+8eWBe+NxQDtJGgpUASAAFuevSakEi8iE44iJqUI +B/8C7yYTJwexgADAINEPj6AoohMsoAWNMAWIAiimE5wQHOO8ibCZEflgsBWgClUA+CBGFaA7BQBY +vnuKN4quKxqA+0AARfAMNQAstJIpMAX1P/n1IgCdAP3G0gXvnlUALjQFHuM5HOOsLdB9LuKALMKD +Ce4R7swIBvw0gAD3gABE8AAqAAApKoCpyRzjiB7jmx3jiCa0kYgwnRSeGpwW/QAAFDAMRQAMiAKY +FS+QBy2RLg8PQQD/EQ/dAg7dAp0YDOownBmWG+mtAiDQwQAACWCICgyKCUCICgiKCSCICgSKCQCI +CgCK6xwQKdAEgAD8AIIdoA0lAFudtmP+lCsgB/pAaB2huwEA67wYKWAEgABbqA3AINEPj6AoohMs +oAWNMAWIAiimE5wQHON6ibCZEflgsBWgClUA+CBGFaA7BQBYvjmLN4u+KhqA+2AARTAMNQAspJIp +MAX1P/LdIgCdAP3GTgXvnlUALjQFHuL3HONqLdB9LuKALMKDCe4R7swIBvwwgAD3gABE8AAmACkq +gKnJGONHHeNZJqSRjzAa40WaFJ0amBb94AAXsAhFAAj/Ap8VLpAHLJEuDg5BAO4RDswCDcwCnBgK +6jDmFgslyAsAAOoWCSDQwQAACeCIChyKCcCIChiKCaCIChSKCYCIChCK6xwQKdAEgAD8AIIdoA0l +AFudc2P9rgAAbBAcGeNDLTAHKzAFKDAEJCIQLiAHLDAG6kIHLEYCgAD7BgAMce4BAO4WKSxGAoAA +DIgCiq7qFi0sRgKAAA2IAvkABARwCwUA+CVmFaIMBQBYuNYmMAEpMBgqMCQqFiwqMBkrIhfsMBos +zgKAAPsmAAyxVhEA6jAbLM4CgAD9JgAMsdYBAO0WKizOAoAA+yYADLd2OQD7IT4N4GYxALG8LCYX +/cY4BaAKVQD8QmgV4DsFAFi92hri/O3i+xrwBIAA+8YYBeBMdQDw3AAN4A8FAGRw0sCi/cYgBaA7 +BQBYvc8b4wQd4vAa4vD8COIdoA8FABnikx7jBhjivymSgC7igyiAfQmZEfnAAEdwiQUA6ekIBHwc +gABgAAQpKoCp6S4SLSgagKjoLISRiEAtFhorFh4qFhj9AAAUMApFAAqIAigWGSqQBymRLgoKQQCq +EQqZAguZAikWHAjqMCgWHS8WH+ntAiDR/QAA6WYABVAFAAAKDIoJQIgKCIoJIIgKBIoJAIgKAIrr +HGAqUASAAPwAgh2gDSUAW50M2iBYEEHAINEPAAAAAADeUP3f+iwiAJ0ALSIT7OLaH3zCgADTD/+m +AA7wClUA/EJmFeA7BQBYvZMoEivLjOs8MClQBIAA7RItLGAEgABb/bjnoCltSASAAMCi/cWWBaA7 +BQBYvYgb4rwd4qn7xVIFoEx1AP/7iA2gDwUAwJAqEiwpFigsEizxXGAN74t1AO0iACgECoAA9YAE +AJIAnQAc4rsvEiz+gAgVoAolAPpNBh3gOwUAWL1z7nQACvgEgAD9xWgFoAolAPwlSBXgOwUA7RYA +K2gEgABYvWsb4p8d4ov7xRgFoEx1AP/5tA2gDwUAAAAAAGR/FmRRjvi/+JDSAJ0ALhIqZO5Q9d/y +aJIAnQD+JUgVr/vyAAAAHOKe+k0GHeAKJQD+gAgVoDsFAFi9VfJDKBXgDBUALEYS/IKGFaALBQAr +RhH6gqYV75pVACpEBS8wBf5gCBWgCSUA+IJmFeB0JQD+gAmC4gCdAPoAoh2gOwUA7OKJGegEgABY +vUEvMAV08RUtCnP94A7kYgCdAC4Kdf/gD0wiAJ0AwCDApf3E/gWgOwUA7jIAKegEgABYvTVkIM+F +OCJSGRziTiNQB/xAkBXgClUA/kAIFaA7BQD+QLAV4TMBAFi9KiggBQ8CAPiABQKiAJ0AHOJDLyII +LiIALSAE/+AIFeAKVQDyIAYV4AkFAPggJhXgOwUAWL0d+qBoHaALhQDtHBAp4ASAAFuSdmSjKRzi +NYtQwNCdoQy7ApugGeIz4hIEKccCgACpiPMABhWgAgUA0Q8AAAAAAPpAaB2gCwUAW507KSITCdtB +b7JrLxIoKBIt+UCGFaCOBQAOngIvpQof4kqfoi4mE4kiZJJ8wCDRDy4SKmXugGP8xgAAAAAAAPxA +CBXgClUA/cSCBaA7BQBYvPYvMAV08dMoCnB48c36YQgVoAsFAPwAAh2gDSUAW457wCDRDwAA+X/v +GdIAnQAr+osrJGgpMBwrMB0sQhPtMB4szgKAAAuZAuswHyzOAoAADZkCCJkRC5kCfJkEsc0tRhMu +QG4vMCAsMCEpMA7oMCIv/gKAAAz/AuswDy/+AoAACP8C6DAjLM4CgAALmQLpRhEv/gKAAAj/Au9G +FC8CjgAAx8+cpCgiExviFftARhXgiQUACYgC+EJmFa/8cgCOOC0KdC00Bf3Aph3gAhUA/mCwFe/4 +hgCCOC8Kdy80Bf5Aph3gAhUA/mCwFe/4JgAc4gX8gAgV4ApVAP5ACBWgOwUAWLy2iif6AEId4AwF +APtEABWgDSUAW599K0AFLAqV/WAKTCIAnQD9w7wFoApVAPxCaBXgOwUAWLyoKSITe54VCe1R9aAK +OJIAnQAJzlH1wAngkgCdAIVHhV76sggV4YMFAPKgAEHwCQUAKTSRiCD4sOYVoA8VAO80kiWBYYAA +GOGcHOE0HeHI6LsoCVAEgABbOyAa4cUpIhMKmQLpJhMpUASAAFs6/x7hyBvhgv/CqAXvnCUALEQF +K7B9L/KALuKDCf8R7+4IBfw8gAApCoD5wABE8AAmACkqgKnpGOGhHeGz+8NCBeAKBQAqNJGPQJsY +nR6YGv3gABewCEUACP8CnxkukAcskS4ODkEA7hEOzAINzAKcHAvqMOsWDSLICwAA6hYPINEBAAAJ +4IgKHIoJwIgKGIoJoIgKFIoJgIgKEIrrHCAqUASAAPwAgh2gDSUAW5vNwCDRDysSKdog67wYKWAE +gABbpiXAINEP2kBbOsiMTcDg/oakHa/95QANzAH8gaYVr/qOAAAAAAAAAPpAaB2gCwUA/AACHaAN +JQBbPZnAINEPANpQ/cLYBaALBQBbkY3AINEPAAAAAAAAAGwQDB7hg400GOE7FOGPjzYogH0qQoos +QoT6j4gV6/8BAJ8cDt0B/CEmFeCJBQDkTPAt3kKAAOy7CAR8WIAAmh2pvfwhRhXgAFoAAAAAAAAA ++iGmFaKOBQCuvp4ahjmFHCRCeIc4lxilROcxDyomQoAApMSFSVuTqI8gn6COShzhc/xCaBXgGHUA ++ECGHaLuwQDqJgcvdYKAAP+mAA6wOwUA/EJmFeAKVQBYvBwoIAcd4WgpUAeLGixQDCpQDftg5BXg +DgUALiUbLiQi/EGGHaGZAQCtmSokDR3hXymQgP3CdgWg+rUACogB6hIILM+CgAAJiAL4QOYdoPnF +AAmIAS9QB5YsJiYVJiYUmiuaKSomFislB/uRSBXh/wEACP8C+iGoFaAIhQAoJAUvJAd72wcLbgyt +7i4mFR3hSCnCjA8CACjSgP+vqBWjx2EACswJ6NKCLAIKgAAOmQj5P+AV4O5NAAnuAf5fAA8wCSUA +Ce43+cEADzD69QAK7jYuJCMswQoPAgAszNj+IWYVr8wBAOwlGiPgNIAALMz0DAxPLCUa+qLQFeCO +BQDl4S0WcDOAAP5DRB2gjAUAKyQWKNJ9CFU2erEODwpBW2JSLCEaClU2DFU3DFgsCMgc6CUbKVAE +gABbnPiFGBzhHo0nLiAELyAFihuaEPhBSBXgOwUA+CAmFeAKVQBYu8Uc4ReNHI4ZJCYZ4kYIIVDh +AACaLvpB5hWgeTUAKUQFKSQFjzSWEJURKEAFlxP4IEYVoDsFAPhACBWgClUA+CCGFaf/wQBYu7P9 +wgwFoApVAPyB6BXgOwUAWLuuiifAsPtEABWgDBUAW6IPjEwb4P7rpgAmAHmAAOtCDylQBIAAC8AA +wCDRDwAAbBAEKyANLiAMLSA1jzLs4PQfdgKAAO67Ag7sAoAADbsCDLsCmzD4QUgVoAoFAPpgRB2g +KaUAKTUD6SEZJARMgAAY4JMEmREJ/wII/wIvNgLqPBYhENkAAPpAaB3gDGUAWLZiLkANL0APKEAR +K0AQLUAOLEAMCLsCD90CDswCDcwCDLsC5bAYYdBBAAD7wawF4AxlAFi2VWAAEAAAAAAAAPqBgBXg +DGUAWLZQ/8GeBeAKRQD6ZGYdoAxlACw0IhrgCSlCAChCAv5jph3gDoUA/mOGHaANFQAtNB/6ZCYd +oAsFACs0Hug0LylYBIAA+GSmHeiIHQD4ZcYdqJkdAPhkhh3oiB0A+GWmHaAJhQD4ZAYd6IgdAOg0 +LCHQmQAAWLYzLkATL0AVKEAXK0AWLUAULEASCLsCD90CDswCDcwCDLsCyLwqPDD6gkAV4AxlAFi2 +J4lB+GcmHeiZHQD4ZwYd6JkdAPhm5h3omR0A+GbGHeACBQDRDwAAAGwQBhzgnPxiRBXgClUA/kHo +FaA7BQBYuz8rMRIX4Jf0QGgdoAwFAPxhSBXrqwEA6OCTFRSbgAB6gh6JL2SSOCqRGeuqDA4gBIAA +CpQ4zEjUIPABkA2gEmUAhUcmcp749egV4IoFAOVSDiaBAYAAKHJPCWYRqWZtiRCLZ4u+K7K//WAG +/GIAnQCqZiJSwutSwCEJCYAAHOB6LVK/LlLA/rjIFeAKVQDyIAYVoDsFAFi7GfwAAh2gEgUAG9/f +LUAMK7KAKnKvrbvu4G8d3kKAAKuqLaEu/6AETCK7BQCNRxjgMBXgQY3eHuAsH+Asq9vuAAUNyASA +AAkCYQkCYQkCYQkCYYlAJday/7XGFeAORQDo1qwszgKAAA6ZAinWrSigBy+hLggIQQCIEQj/AgX/ +Ai/WsA7qMCzWs/+2JhWi2QUAqdkDIIYJAmMDAIYJAmH5oEAl4AxFAPM8xh2gDSUAW5pY0Q8c4Eku +YDWPYJ0R+iAGFeAKVQD94Ggd4DsFAFi65f7QYA3gDAUA9N/39CIAnQCNIP7GsBWgClUA/cB4BaA7 +BQBYutzAwPIMYh2v/DoAAAAAijpkoKyKOy1SxnqxAipWwIo8L1K/etECKlbGjjr/wATsYgCdACoq +IPqgAEUwBhUA5laoKcgEgAAJIIYKAmMJAIYKAmEJ4IYKAm8JwIYKAm0JoIYKAmsJgIYKAmkJYIYK +AmcJQIYKAmUb38Qc31vt4BwaUASAAFs5SNpAWzkrHOAZglDyYUgV4AslACtWqPpAaB2gO6UAW0Im +yK6WqPNBJhXgDQUAnaqMIsrBwCDRDwAAACxWvyxWwCxWxixWvf/5FA2gAgUA9YBoHa/3RgArIAf6 +QGgdobsBAOu8GClgBIAAW6RowCDRDwAAbBAIHN/+LSIA/kCQFaAKVQD+YrAV4DsFAFi6lxffuhbf +uBXfyhrf0PhGkBWgDAUA9b/cBaK/BQD7XYAV4o0FAPUABQsQbkUAKSAMKLKAKqKDqYgJiBGoqiih +LvUADiwiAJ0AhCeEThjfpa9L6AAFDcgEgAD4AKgd4AhFAAkCYQkCYQkCYY8gJUayJ0as5kauL/4C +gAAI/wIvRq0poAcooS4JCUEAmREJiAIFiAIoRrAP6jAsRrP+liYV4tkFAKlJAyCGCQJjAwCGCQJh +/IAARHAMRQD/DMYdoA0lAFuZ0cAg0Q8AACkwFR7fvvUgEyiSAJ0AmRT1IAl7kgCdAI4UwJn5wBMU +YAi1APnACkwiAJ0A/b92BaAKVQD8QAgV4DsFAFi6VRvfHvxQAh3gDAUA/gLCHaK/BQD7YoAVr/w2 +AMGWmRMb3xYsIAwa34crsoAqooOsuwm7EauqK6EuHN9o9WAEnCIAnQCNJ43eKyqwq9vsAAUNyASA +AAkCYQkCYQkCYQkCYYwgJday97XGFaAORQDn1qwuZgKAAA7MAizWrSmgByihLgkJQQCZEQmIAgWI +AujWsCnIBIAAD+ow/7YmFeLcBQD9oABGMA4FAC7WswlghgwCZwlAhgwCZf4gaBWijwUA/6AAR/AM +RQD/7MYdoA0lAFuZjI4TnhX9vwQFoApVAPxACBXgOwUAWLobjhUb3uPAwPxQAh3ivwUA5e4oZdBR +AADAINEPKjESCgpL91/4aRIAnQD73/grIgCdAIsv6xYALZCGAADAwvwgZhWv+9YAAAAAABzfbPxi +RBXgClUA/kHoFaA7BQBYugMsMRIMC0vqsh5pUASAAB3fWXvSEykiD2SSNS6RGf3PAA8wCgUADpo4 +ZKG0jqeO7ivsEOsWASnIBIAAmhIJYIYLAmcJQIYLAmUJIIYLAmMJAIYLAmEJ4IYLAm8JwIYLAm0J +oIYLAmsJgIYLAmn6IEgVoAgVACjmJS8gOywgOougwJDp5iYv+gKAAPmAABY320EA78wCDu4CgAAN +zAL9voIF57sBAAy7AivmJxzedhve3Vs4ZIoS/b52BaJb5QBbQUfMpv/7GA2gDsUAiRGZqIoSWzhA +ihKLomSxff/6uA2gDgUAAAAAAAAA6iQACdgEgABb/oH/QGgdr/pWABzfK/xACBXgClUA/mJkFaA7 +BQBYub+JLyoxE+olGCSAOYAAKpUYG96DLCAMGt71K7KAKqKDrLsJuxGrqiyhLvWABNQiAJ0ALSIH +LdIOHN7SKyqwC9sI7AAFDcgEgAAJAmEJAmEJAmEJAmEsIgAl1rL3tcYVoA5FAOfWrC5mAoAADswC +LNatKaAHKKEuCQlBAJkRCYgCBYgC6NawKcgEgAAP6jD/tiYV4A4FAP+2ZhWi3AUADNwICaCGDAJr +CYCGDAJp/lACHeAMRQD/oABH8A4FAP/sxh2gDSUAW5j4//bADaAOBQD/9qANoB5lACohGC4gDS0g +NSwgFiggBy8gDCK2EOshFi3IBIAAL5QMLpQNLZQ1KpUY65UWJNDZAADslBYhWNkAAPkg5h2gDGUA +WLRQjRAe3kSMKvhiRBWgDwUAnxMOzAIo1Rn9oUYVr/JCAAAAAAAA//dQDaAKBQAroAcLC0HrvBgt +YASAAFujMWP+bWwQBoMngz4c3s6NIP51CBWgClUA/nUoFeA7BQBYuWAsMqjzguAN4i4FAPWAETCQ +BAUAGt6XFd62Ft6P97z2BeK/BQDt3noWFFUAAGjDVSQ2qeQ2qCoQBIAA0Q8AKzKpHN6w9WAHc1IA +nQDiMgAl0AUAAPp1JhWgCSUA+HUGFeA7pQDjMpIpUASAAFtAucivlKrzQSYV4AwVAJyoiyJksdfA +INEPLCAMK6J7KqKDrLsJuxGrqiihLvUABFxiAJ0AjCeMzhjeWK/L6AAFDcgEgAD4AKgd4AVFAAkC +YQkCYQkCYYggJsayLcas58auLEYCgAAFiAIoxq0voAcpoS4PD0EA/xEPmQIGmQIpxrAI6jAkxrMo +xrH+YABEst8FAK/PCSCGDwJjCQCGDwJh+AxCHeKNBQD9gABGcA0lAPmMxh3gDEUAW5iCJDap9HUG +FaBiJQDRDwDaIFs3gBzecSgylC4ykoowKTKTKTbAmhGeEC42v/h4xhWi/wUArz/+d6YV4DulAFtA +e8mjixH8IAgV4AwVAJyonaqdqYuyZLD0G93JLCAMGt47K7KAKqKDrLsJuxGrqi6hLsDE9cAETGK7 +BQCNJ43eHt4YGN4Zq9vuAAUNyASAAAkCYQkCYQkCYQkCYY8gJtayJ9au6NasL/4CgAAM/wIv1q0u +oAcpoS4ODkEA7hEOmQIGmQIp1rAI6jAk1rP5tiYVot8FAP+gAEfyKQUAqTkJYIYPAmcJQIYPAmUp +KoD5oABE8AxFAPUsxh2gDSUAW5hCJDap9HUGFaACBQDRDwAA/bx4BaAKVQD8QAgV4i4FAP5gAEcw +OwUAWLjM2iBbNznAINEPKyAH+kBoHaG7AQDrvBgpYASAAFuijcAg0Q+MESvABwsLQeu8GC5QBIAA +W6KHY/70bBAIHN4nF92FKDAImBXoMgApaASAAI7QKXJ39vEIFeOIAQCYFKmI79AELEZCgACod+Ry +CioQBIAAkxDyICYVoApVAPQgRhXgOwUAWLirHN4V/uAIFaAKVQD+4JAV4DsFAOQWACvoBIAAWLij +6d4PGcAEgADTD20pBQgAhgkCYYkwGt4K/CCoFaACBQD5uzgFoBsFAOWmFiSoPIAA/YfgANAKZQBo +wmSOenTpFy76jX4hDNpQ6zQACWAEgABYt/3AINEPAN1A+gCiHaA7BQDs3fgZeASAAFi4iGP/zwAA +AC9wNI56jBT950ADUAkFACl0NOjqAgnYBIAA6nYKK9AEgABYm0vzQGgdr/5+AI1wCN0RnTMscDTA +IO5yCiY0dQAAY/+FAI56c+4SjBQqdDT7hgAOf/7+AAAAAHPuCf/9pA2gAgUAAAAd3X2MFCp0NA3t +AevMAgvQBIAA7XYKKdgEgABYmzPzQGgdr/z+AGwQChfdKxzd0Chyd4Ux8vEIFaOUAQCpiP0IABQw +ClUA+EAAQTA7BQD+RrAVp1VBAP5GkBXgVU0A5BYAKugEgABYuFIuIDQW3b7tIAwipCGAAIUxKnKA +LyA1+PEIFeALBQD9QABFd1VBAP1IABUwVU0A6pkIAoChgAD9xQBBUAh1APhGhh2gDnUA6t2wF0Bv +gAAY3a8I6AqIgJ8Z6RYILAAigAAAACskNBzdqy0gNRbdpC4hFhPdoi9iFpMQKSIK+CAmFeAKVQD0 +IEYV4DsFAFi4LypiFus0AArgBIAAWLea0Q8c3Z38wsgV4ApVAP4hKBXgOwUAWLglFt2aGt1FFd2X +6gAFC0gEgADpDAANOASAAAkCYQkCYQkCYR/cuxzdiysgDBjdECkgDRrdjuiAfS3eAoAAC5kCCpkC +6cYsKvAEgAD5uxIF4IgBAAj+OS7FXCnGLS0gNfohCBWgCwUA68TBLu8CgADtxMArWASAAOzdfxpo +BIAAWIU49UBoHe+L1QD7X/rcYgCdAGWvGxzdcCvBXAsLSyslFizBZB7ddf4hRhWqzAEALCUXKeAB +KuAAKiQ2KSQ3ihgo4AIv4AMvJDkoJDgt4AUu4ATuJDohKNkAAPxHZh3gDBUAWKW8jhgc3WUtIRYv +4BQo4Qgp4Qkr4A0u4AwvpBQopQgppQkrpA0upAwqJhEvIDYuIDeeEI4ZKyA4mxEqIDmaEikgOpkT ++EdwFaA7BQD4IIYVoApVAFi3148YHN1RKCEXLfEJLvEI/+KQFeAKVQD4IAYVoDsFAFi3z4ggKjwa +6IgRCtgEgAD4YGYVoAxlAFiyoRrdNdMPDwIAKqIWWLdZ/CFIFeALJQD6RoYd4ABSAAAAHd05F9zg +5Sw2JrPZAADnAAULSASAAAkCYQkCYQkCYQkCYRjdNBzdJy8hFhvdMvuLhB3gDhUALsYtCP8CL8Ys +KlABKVAAKdQAKtQBKFADL1ACL9QCKNQDLFAELlAFLtQFLNQE7N0fG1gEgADqIhEqaASAAFiE1vVA +aB3vg9UA81/upGIAnQBlrZTAk/hGhh3gAD4AF9y897ogBa+D1QD9ui4FoApVAPxDBBXgOwUA7xIJ +K3AEgABYt5LA4ecABQtIBIAACQJhCQJhCQJhCQJhHd0LG9z8Gt0LLCEWLrYtKrYuDcwCKiIR7LYs +KmgEgADs3PwbWASAAFiEtdWg81/qtGANRQBlrRb8RoYd4ABSAPe5OgXvg9UA97neBaANRQAc3PD/ +udAF4A4VAOcABQtIBIAACQJhCQJhCQJhCQJhGtzy+ELEFeAIBQAo9V0u9Vwt9i0e3O4u9jAKmQLp +9iwrWASAAOoiESpoBIAAWISY1aDzX+cUYgCdAGWsovW5ogXgC1UA+kaGHeAAUgDn3H4dKASAAPe5 +oAWvg9UAwLLnAAULSASAAAkCYQkCYQkCYQkCYRnc1xrc1yghFitWLSpWLyoiEQmIAhnc1ChWLP1B +kBXniMEA+QABBHAMJQD5DwgVoA5VAOoWCy7uAoAA7t0CC1gEgAALgACJGyxSLYuSDIxH8WTwDeDM +TQAd3LZk0EQrkA0qkAwZ3ATpkogljfGAAB3cvhzcAK2tLdB9LMKBq92tzAnMEaycLMyAjMeMzh3c +qZ3AlMHRD7HuDg5H/kaGHa/t3gDVwPOf3+RiAJ0AZcu8+kBoHaALNQBbSonA9v5Ghh3gACoAF9xE +FtyX5wAFC0gEgAAJAmEJAmEJAmEJAmEV3KH9uUQFoANVAPxCxBXgClUA/kIoFaA7BQBYtxUZ3J0o +IRYJiAIZ3IIqIhEoliyPKhvb3f+3QAWgDAUA/YBoHeD/4QAPvTkP7Dn9hgAOcA0VAA3MAiyWLf1B +kBXniMEABYgKKIJ46N0RC1gEgADzpgAO98wBAAuAABPcbiUyLfQkAAS3VUEA+zAgDeBVTQD1P9mQ +kgCdAPxBkBXgAEoAAAAAF9wU5txoHRgEgAAc3HouIA2PICogNZoQKSEWmRH4QUgVoDsFAPggRhWg +ClUAWLboG9xb5wAFC0gEgAAJAmEJAmEJAmEJAmEY3GwvIA0qIRYc3GopIAwLqgIsNi3qNVwszgKA +AAn/Agj/Ai82LC4gNfrAaB3gDQUA6hIIL3cCgAD+eAYdoAwFAFiEBO2kAAUAiYAAwKL9uLQFoDsF +AFi2zMCwKyQ00Q8c25MswoCqzAnMEaycjMeMzp3AlMHRDwBsEAaDJ4M+HNxPjSD+ZKgVoApVAP5k +yBXgOwUAWLa8KDIlF9vdFtt55dwWFBlBgAAoMiX1ABNpEAQFACgyJfUAFfoSAJ0AKTIl9SAIGpIA +nQArMiaxu/pkxhXgajUAe6tK/bhyBaAKVQD8QAgV4DsFAFi2pxrb4xvbbxzbm44nJDYlJDYmLMB9 +K7KAKqKDLyqA7uIOLd5CgADrqggGfGCAACwKgP1AAEUwAD4AjSJk0ofAINEPr6oroS4Z27j1fgYN +7+wVAIigLOTYJ+YyKeYw/QAAFDAZZQAJiAIo5jEvoAcPD0EA/xEPvwIG/wIv5jQN6jD9xqYV4SwF +AP3N5B2g6wUA+8AARfBo5QDo5PYhyEEAAAkghgsCYwkAhgsCYfhhyBXgywUAq+sp5kCIPyjmQSTm +Qv5iCBXgHGUA/8hmFeANJQBbld3AINEPAAAAAAAc2//8QAgV4ApVAO8gNSHwQQAA/iAGFaA7BQBY +tmkc2/j8QAgV4ApVAP5lSBWgOwUAWLZjG9ssGtueLDIqLTItLjIrjyckNiYkNiWePy42wC02EC02 +xpw+LDa/HNtPKqKDK7KALMB97/IOLd5CgADrqggGfESAACgKgPlAAEUwAC4AAAApKoCpqiuhLhzb +cIkQ9W+GDe/tFQCIoC302Cf2Miz2MP0AABQwHGUADIgCKPYxLqAHDg5BAO4RDr4CBu4CLvY0Deow +JPT2/eamFeDrBQD74ABF8SwFACz1bwlghgsCZwlAhgsCZfhhyBXgywUAq/sp9kCIPyT2Qij2Qf5i +CBWgHGUA/+hmFaANJQBblZeCMP23FgWgO6UA4zK/KVAEgABbPZtkrjeTqvNBJhXgDRUAnaiMImXO +JisgB/pAaB2huwEA67wYKWAEgABbn+TAINEPwKX9t1YFoDsFAFi2GBzbqfxACBXgClUA7yA1IfBB +AAD+IAYVoDsFAFi2ENog/bbqBaJb5QBbPYH8ACIdoAkFAOrJOAUAQYAAjRCdqP4AIh3gDgUACf44 +Ze1SY/2vHNuW/EAIFeAKVQDvIDUh8EEAAP4gBhWgOwUAWLX82iD9tx4FolvlAFs9bWStgYgQ+UEG +Fa/0cgArIAf6QGgdobsBAOu8GClgBIAAW5+4wCDRDwDaIFs0XMAg0Q8AAABsEAYvWtwvFQArIA0u +IAwtIDWEQOzbPB92AoAA7rsCDuwCgAANuwIMuwKbMIgqwKD6YEQdoknlAOk1AyQEYIAAKiEZKDIC +GdrbBKoRCogCCYgCmDIqPBD8ScIdoAsFAFiwuMdvJjQQJjQR5jQSIdBZAAD2YmYdoAxlAOY0FCEQ +2QAA5jQVKVgEgABYsKEmNDEe2l77tR4FoElFAPhmZh3gCAUA+GZGHaJMBQD8ZCYdqPYdAC80MPpk +ph2gDYUA/GOGHeALJQD6ZAYd4Ec1ACc0Nf5jph2gBQUA9GaGHeAOJQD+ZsYdoAUVACU0OvRnZh3g +B2UA9meGHeAbFQD6ZOYd4E0FAC00JO00JiHRWQAA/GPQFaj/HQD+ZeYd6P8dAP5lxh3iL8UA/mbm +HePMAQD9hgAOcP0FAP2ABAZwDVUA7cwCCVgEgADsNB4r4ASAAFiwcPpnwBWgi8UA+oAARfAMRQBY +sGv7tk4F4SplAPpgAEUwDEUAWLBmKQqw+GAARPA8VQAslHollHv1L4Yd4D11AC2UfStAF3i3B/cv +xh3gACYAwKUqlH4llH/3MCYd4Ag1ACiUgCtAFyIaMg8CAOIyCAXgPIAAKQoR6SQAIRAFAADAUvRA +Zh3gHKUA/EAGHaA6lQD6QEYdoBvFAOskASFQEQAA6xQACuAEgABYsEUb2pgrsoktsADxoZAN4AoF +ANmwbQgMLJABsarkwAdkyAUAAGP/7PpA5h2gPcUA/EDGHec6AQDsNAABUCEAAFiwNKI+JuQI9IQm +FeACBQDRDwAAbBAGL1rcLxUAKyANLiAMLSA1hEDs2qgfdgKAAO67Ag7sAoAADbsCDLsCmzAoIgoq +CgD6YEQdoknlAOk1AyQEYIAAKiEZKDICGdpHBKoRCogCCYgCmDIqPBD8ScIdoAsFAFiwI8dfJTQQ +JTQR5TQSIdBZAAD0YmYd4AxlAOU0FCEQ2QAA5TQVKVgEgABYsAwlNDEuMB4d2cgZ2fr4ZKYd4BgV +APhk5h2gCiUA+mQGHaAMhQD8Y4YdqPUdAP5mBh3iSwUAKzQh/GOmHeBHRQD2ZmYd4A0FAPxmhh3g +BxUAJzQ69mdmHeALJQD6ZsYd6P8dAP5l5h3iLMUA/GbmHaj/HQD+ZcYd4AxlAPxnhh2gTwUALzQk +/mTGHePuAQD/xgAPcP8FAP/ABAdwD1UA7+4CAdFZAAD+Y8YdoA8FAP5mRh3gTjUA7jQ1KVgEgABY +r9z6Z8AVoIvFAPqAAEXwDEUAWK/Y+7UoBeEqZQD6YABFMAxFAFiv0yoaL/pgAEUwtoUA9mAAQTA8 +VQD8TkYdoDtlACskdfZOZh3gm0UA+oAARfAHNQD2ToYd4AxFACwkdlivxCoaNfpgAEUwOyUA+k9m +HeAMRQD8T4YdoJuFAPqAAEXwDEUAWK+6wML8UEYdoDuVAPpQJh3hOrUA6joICNgEgABYr7Mb2gfT +DyuyiSywAPGBkA3gCgUA2bBtCAwskAGxquTAB2TIBQAAY//sLRo/+lDGHaA+xQD+UKYdpyoBAO06 +CAlgBIAAWK+ioy+m/yX0h/aEJhXgAgUA0Q8AbBAEJyAHiCIZ2ln0QggV4XcBAOWCLGvXAoAACaoI +KKKeDwIA9wARAtIAnQAkop3s2d8SEKmAACYiE40p0w/6QUgV4GZBAAxmCiZigO27DAMwwQAA92AO +w6IAnQArIBYoCv94sRL6QPAVoAwFAFt3POzZzxUPKYAALyEHHtluF9o9+7R2Bar/AQDpIRov/wKA +AAf/Ap9AiCAd2jj8gEYV4AdVAOqIAgxeAoAAB7sCm0EvIhOZRphE/ggABvL/UQDs2woP/YKAAOuy +gC7ugoAAD90CDt0CnUcLawzrRgUl2EEAAJtDKiIWiymmqqa7myn6QsYVr+kFAPiACkRiAJ0AFtmm +KUwg/ADCHeALBQD2AAgdoAoFAAkCYQkCYQkCYS1EICgwEipEJCtEJStEJitEJytEIvqEZh3giQUA +CYgCKEQh5gIVAkihAAAJAIouMBLvMQgnAHmAAP6Gph3o/x0AL0Q0il/6huYd6LsdAOtENiVQBQAA +ml9bPGz6hmYdqKodAPqGRh2oqh0A+oYmHaiqHQAqRDAoUhKxiSlWEviHZh2oiB0A+IdGHaiIHQD4 +hyYdqIgdAChEOC8iF/6H5h3o/x0A/ofGHej/HQD+h6Yd6P8dAC9EPOYABQJxAQAADgJhLSAHDQ1B +HtnhDN0Rrt0n1p0rIBYsCv98sQr6QPAVoDwFAFt2woon+gBCHeAMBQD7RAAVoA0lAFuXDCsiEyz6 +fwy7AfpCZhXgAgUA0Q8AAADqJAALWASAAFt2dezZXBVw6YAAwCDRDwDaIOwkAAPYYQAAW534wCDR +D9og63wSKWAEgABbnfTAINEPAABsEAwnIhCjRhLZwihwb4l3KyIVLCBQnBiJnvggphXgiAkA6BYN +K1AEgABYrvcd2bkqEggsEg0b2UL6wABFMDXVAOWkAC5nQoAAC8sIK7LdDcwILMCA7BYOJVAFAABY +ruqPGI4eKyIXLCBYr+73wABDMA8FAC9kAi1wb+wWCSdwCQAArkTygABDcN0RAO0WDStQBIAAWK7c +ihkc2Z6LHapqJaQADLsLLLCAnB7rsiElUAUAAFiu1Y8Zjh4rIhksIGCv7vfAAEMwDwUAL2QCLXBv +7BYKJ3AJAACuRPKAAENw3RkA7RYNK1AEgABYrseKGhzZiYsdqmolpAAMuwsssICcHuuyISVQBQAA +WK6/jxqOHisiG6/u98AAQzAPBQAvZAItcG8sIGjsFgsncAkAAP6AAEIw3QEA40YIBug5AADtFgYr +UASAAFiusB3Y/oobG9j8jBaqaiWkAAvLC+uywS5nQoAADcwILMCA7BYHJVAFAABYrqWNG4wXKyId +rcymzvZOEBWgDQUA7eQCJmAJAACsRONKCAtgBIAAWK6bEtlfpkQY2OKYHKNGJWQA63E0KOAEgADo +AAUI+ASAAP4AqB3gDqUA/iCGFe/9ZQDAkG0IHtqwDrstDb8or6qqKiqgAOrEAC5QBIAA5LAOZmAF +AABj/9gAAAAAAAAAKaQBehss2xBtCCLtsAAmc/8AACng/+3k/yVT/QAA6bQAJdgFAADquwl2Y/0A +AGP/1gAALxAA8eGQDeAFBQDZEG0IDCiQAbFV5IAHZMgFAABj/+yxausUAArgBIAAWK5ssVurRBvZ +LCWweKNKsarrsh8q4ASAAFiuZo8c6RIFItgFAACrRPKAAENwOtUAKmQA6ZKPKOAEgADvBAUI8ASA +AP4EqB2gDaUA/iCGFa/7ZQDA4G0IHt+QDZktC5goqP+vLy/wAO/EAC5QBIAA5JAIZmAFAABj/9gA +LqQBehss2xBtCCLusAAme/8AAC3w/+70/yVT/QAA7bQAJdgFAADquwl2Y/0AAGP/1gAAKBAA8QGQ +DeAFBQDZEG0IDCqQAbFV5KAHZMgFAABj/+yxausUAArgBIAAWK42sVurRBvY9iWwoANKCCqsAeuy +KSrgBIAAWK4v7xIMIsgFAACpRPKAAENwONUAKGQA6XIYKOAEgADvCAUI8ASAAP4IqB2gDaUA/iCG +Fa/7ZQBtCB7akA2ZLQueKK6qqioqoADqxAAuUASAAOSQCGZgBQAAY//aAMCAKKQBehss2xBtCCLt +sAAmc/8AACng/+3k/yVT/QAA6bQAJdgFAADquwl2Y/0AAGP/1gAALxAA8eGQDeAFBQDZEG0IDCiQ +AbFV5IAHZMgFAABj/+yxausUAArgBIAAWK4AsVurRBvYwCWwqANKCCqsAeuyKyrgBIAAWK357xIM +IsgFAACpRPKAAENwONUAKGQA6XIXKOAEgADvDAUI8ASAAP4MqB2gDaUA/iCGFa/7ZQDA4G0IHtqQ +DZktC58or6qqKiqgAOrEAC5QBIAA5JAIZmAFAABj/9gALqQBehss2xBtCCLtsAAmc/8AACng/+3k +/yVT/QAA6bQAJdgFAADquwl2Y/0AAGP/1gAALxAA8eGQDeAFBQDZEG0IDCiQAbFV5IAHZMgFAABj +/+yxausUAArgBIAAWK3KG9iLsVysRCWwsANKCCqsAeuyLSrgBIAAWK3D7hIMIrAFAACmRPKAAENw +P9UAL2QA6XIWKOAEgADuEAUI6ASAAPwQqB3gD6UA/CCGFe/+ZQD6IGgd4AoFAG0IHtiQD5ktDp0o +rYioKCiAAOjEAC5oBIAA5JAHZmAFAABj/9Iq1AF9uzfq1AAI2ASAAA8CANMPbQgi77AAJkP/AAAu +gP/vhP8lU/0AAO60ACXYBQAA6rsJdmP9AABj/9EAACkQAPEhkA3gAgUA2RBtCAwqkAGxIuSgB2TI +BQAAY//ssWrrFAAJYASAAFitkKQisiLRDwBsEA4mIhAU2FGHZ5YdJmBvJ3IOJxYGJ0BI60ITKdAE +gAD84GgdoGYxAFitgxvX0RjYRQ1mEatrqGYmYID2YABFcDXVAOWkACVQBQAA67LdK2AEgABYrXgr +QhWnaixAUJwfhh3zQABEcAcFACeEAuZgbyVQCQAAmhejqvohxhWgZjkAWK1tG9gvjB+KHgtrCyaw +gKyq5aQAJVAFAADrsiErYASAAFitZBzYKogfhBeJHqhopIT5AABEcApVAPcARh3gOwUA7SITIiAJ +AABYsoKJHSmQbu0iEySX+YAAwKX9sDoFoDsFAFiyfBvYGC0iE6NGLLBY/CIGFaHd4QDrshcm6AkA +AO0WCCtQBIAAWK1KHdeZKhIQG9eWjBgKagglpAALywvrssEuZ0KAAA3MCCzAgOwWCSVQBQAAWK0/ +LxIQG9gDjhkssGCv7qbvJ/QCLSITLBYR67IZJ3AJAAD+gABCMd3xAONGCAboCQAA7RYKK1AEgABY +rTAS1/Ud134qEhEb13yMGqpqJaQAC8sLK7LBDcwLLMCA7BYLJVAFAABYrSYtEhGMGysiG63Mps0m +IGjn1AImYAkAAKxE40oIC2AEgABYrR0Y12WmRKNGJWQA6AAFCJAEgAACAmGSFBLX2y8gAJgc9iAm +HeAFBQDvFAAngMmAANkQbQgMKJABsVXkgAdkyAUAAGP/7LFq6xQACuAEgABYrQmxW6tEG9fMJbCw +o0qxquuyLSrgBIAAWK0CjxzpEgYi0AUAAKpE8oAAQ3A61QAqZADvBAUEyAcAAOkWBSjgBIAA6ZGU +KPAEgAD+BKgdoA2lAP4ghhWv+2UAbQge3pANmS0Lnyiv7q4uLuAA7sQALlAEgADkkA1mYAUAAGP/ +2gAAAAAAACekAXobLNsQbQgi7bAAJnP/AAAp4P/t5P8lU/0AAOm0ACXYBQAA6rsJdmP9AABj/9YA +AC8QAPHhkA3gBQUA2RBtCAwokAGxVeSAB2TIBQAAY//ssWrrFAAK4ASAAFis0BvXlLFcrEQlsLij +SrGq67IvKuAEgABYrMqPHOkSBSLYBQAAq0TygABDcDrVACpkAOmRlSjgBIAA7wgFCPAEgAD+CKgd +oA2lAP4ghhWv+2UAbQge3pANmS0Lnyiv7q4uLuAA7sQALlAEgADkkApmYAUAAGP/2gAAACekAXob +LNsQbQgi7bAAJnP/AAAp4P/t5P8lU/0AAOm0ACXYBQAA6rsJdmP9AABj/9YAAC8QAPHhkA3gAgUA +2RBtCAwokAGxIuSAB2TIBQAAY//ssWrrFAAJYASAAFismqQisiLRDx/XYB7XYA/dAQ7dAfxCZhXv +89YAAGwQIIY3hm4uYo4c11r6AKIdoDsFAPygaB3h7rkAWLGzEtdW/KGgANAHBQDBiHhRP9Jw0Q8l +ICz6gGgdoDPVAOsiDCrgBIAAWKyBKyI2JiDUpUojpADsZAAFUAUAAFise6VipCjnhAIhEAkAANEP +AAAZ1miKPiuSeSmSiKuq4yBELVZCgACqmYmX+kJIFeA11QDpkg4p4ASAAOkWMCpQBIAAWKxqKxIw +o0wlxAArsALqsTBt0ASAACkSMCoagOqZCA5QBIAAbbkSLZBI7aQBJMgFAADk0HZlUAUAACoSMNMP +KqACGNajo6IoFjXoAAUAmIEAAAMCYfIhhhXigwUAo2srFjYssNgsFDTrsPsg0OEAAOsWLyEQCQAA +WzUPKhw4+iaAFeAMFQBbNLoqEjCjqSuQKPFicA3gDAUAbQgMLZApsczk0BdkyAUAAGP/7CoSMKvN +J9QB+0BQFa/+KgArKqjrqwgA0OEAAFs0qfwl6BWje8UA62sIANDhAABbNKXqHDgg2IEAAFs0VRzW +/C8QIi4QIS0QICgQI5gQKxAkmxEqECWaEikQJikWA/gk8BWgOwUA+CCGFaAKVQBYsUwc1vAvECou +ECktECgpECuZECgQLJgRKxAtmxIqEC6aE/gl8BXgOwUA+CCGFeAKVQBYsT8b1uIEKggPAgAssEws +Fi4rshRYrBIsEi4Z1mmsIqQq9UAGHeA/BQD1QCJoEH6FAC+kAS6kAu0cIC1gBIAA+AICHaB75QBt +ijL3YA/h0gCdAC7QAA5PQ/8gAEfz7gEArp4u4IDv8IAmYAkAAO/EASXb+QAA7sQCJugFAAD3RGYd +4CU1AMCl/a2GBaA7BQDsFjQq6ASAAFixGWZUDfoAoh2gOwUA7Na9GugEgABYsRQoYo74oCAV4A81 +APhAAEF4iLkA+eAdXiIAnQAP6jAF6jAc1rMd1rQZ1rQPXzge1rEJ+y0NtSgOuyil/xXWsAz/KK+7 +pbgLizoLjxIPuwMLTxIPuwMLC0IP6jAI6jAPjzgJ+i0NqCgOqiio/wz/KK+qpagKijoKjxIPqgMK +XxIPqgP/aAAVsqoBAAuqAgvqMA/qMAv7OAm5LQ2dKA6ZKK27DLsoq5lmk0IY1lYpFi0phhUuEi0O +jxIP7gMOXxLv7gMNR4KAAP4v4BXh7gEA6O4CB/hFAAAu9AAsEJD7rP4F4A0VAA3MNy0SNvRAAEU3 +zAEALBSQLNTYLLA0LBYyi75Yq6sf1m8sEjIqEjUpEJD8QABBMA6lAPRAAEYwO9UA68QAIOn9AADq +BAUGwIUAAOgsAAbohQAA+CWGFa/7ZQDYkA6ZLQuaKA8CAKqICPgIKIAA6NQALtAEgADln+Fm6AUA +ACscf+ekASXYhQAAers1bQgi77AAJsP/AAAugP/vhP8lU/0AAO60ACXYBQAA6rsUduv9AABj/9YA +ACfEA//40A2v5aUAKhx/KqwhK6AAwJDpFjElgPGAAG0IDCugAbGZ5LALZVAFAABj/+wAAAAAKRYx +6swBINn9AADsEjEl2IUAAFirciwSMevWPBZgBQAArCKkKiywPCwWM+uyECVQBQAAWKtqLxIz/Cao +FeNZtQDpaQgH+AUAAK8i9EAARTA+1QAupAANAIcJAmEJAmEJAmEJAmEJAmEJAmEJAmEJAmH6JagV +4AkFAPom5hWgGAUAbYq0CuowDOowHtYlH9YmG9YmCso4FNYjC6gtD4woBIgorKoOqiiqiKWMCMg6 +CIoSCogDCEoSCogDCAhCCuowDOowCso4C60tD9woBN0orKoOqiiq3aXcDc06DYoSCt0DDVoSCt0D +/wgAFDLdAQAI3QIM6jAI6jAMjDgLyy0PvygEuyivzA7MKKy7pbwLyzoLihIKugP3IABGMuqNAO6q +Aw7vgoAA84AARnGqAQANqgLqxNskyAUAAB7Vvi0SNioSN/vCphXgHgUALtTa9UAFkBIAnQAvyqX+ +wAcMYgCdABnVdy8SNv1AaB3ge4UA+0BGHeA8BQD9QCYdoHvlANMPbeotbrNhLvDbDkhD+SAARDPu +AQCuni7ggOiAgCboCQAA6NQBJdv5AADu1AIn+AUAAPdEZh3gIzUA+gCiHaA7BQDsEjQp6ASAAFiw +LWYwO/oAoh2gOwUA7NXXGegEgABYsCexP68i0Q8n1AP//ygNr+OlANEPAAAAAAAA//AcDa/lpQD/ +/sgNr+OlAMCl/auUBaA7BQBYsBrHL9EPGNWFpZkpFi35AqYV7/LqAMCl/auGBaA7BQBYsBLHL9EP +J6QB//3UDa/jpQAAAABsEAgmIhAU1NSWFIVuJ0J5iGckQogmYG6IjqdV59W2Gq5CgAClRIRHJXAk +KBYB63IKKdAEgADkQg4q4ASAAFiq1R3VI+vVIhtnQoAA9GAARXA21QAmpACryyuywa3MLMCA7BYC +JVAFAABYqsqKEqWqJXCEmhPzQABFcAsFAOukAiVQCQAA63IiKuAEgABYqsGME6XFo1ompAIrQAjx +YgAN4AwFANlAbQgMLZAJsczk0A5kyAUAAGP/7AAAAAAAAADqrAMiWCEAAFiqsi5ACPHBsA3gCQUA +BEoCbQgML6AJsZnk8AhlUAUAAGP/7ACllfKgAEVwCAUAKKQEKEDo5IEDYqgRAAArcIxqsR+jXOpy +JC5IBIAAbbkSLaAA7ZQAJVAFAADk0DFkyAUAAKtV8qAAQ3A/1QAvZAAuQOjxwrAN4AwFANlAbQgM +KJDpsczkgBlkyAUAAGP/7PuAAEVwCQUA+UAGHe//HgAAACsK6OtLCANQBQAAWKqHLEDo8YGQDeAJ +BQDaQG0IDC2g6bGZ5NAHZVAFAABj/+yynq5V8qAAQ3AEBQAkZACPFC/wbmjxYSgiEyJw3PrnCBXg +M9UA+sBoHaJ4yQDnfAYpYASAAFiqcRvUvxzUv6JqI6QADHwLI8CA63sLBVAFAADrssEp4ASAAFiq +aKI4pYKmiOSEAiEQCQAA0Q/AQPKgAEN//nYAAAAAK3IwLHC87BYAK1AEgABYql2LEY4QLRqArb2u +VfKgAENwOtUAKmQAKdDw8SGQDeAMBQDZ0G0IDC+Q8bHM5PAHZMgFAABj/+z8IKYV4ngFAOi7CANQ +BQAAWKpKiRUrkPDxYZAN4AoFAN2QbQgMLNDxsarkwAdm6AUAAGP/7LKtrVWjVvTABh2v/GIAAGwQ +DiYiEBzVFY0giWeOYChgbvkhyBXgClUA+CHmFeA7BQDoFgAp+ASAAFivWywgBxnU8AwMQQzIEamI +KoKenBr8IaYVoEslAPtAIuPiAJ0AJIKd/ajkBeBJJQDoRAACIkmAAJ0e/AAIHeA1BQBtmgIIAmEs +MQpkwBXrMgQiUUEAAFiqHSwxCvWGABXgABIAKCITCNpB80FQDeAHBQD1QBLYkgCdANVwjymOKqXF +8qYAFeGVAQAJOAy0iAmDOQ/uDPPADsPiAJ0AKyAWKQr/ebEN+kDwFaAMBQBbccJko+Ac1MUd1N8o +IQcf1MXp1MMR0L0AAPqOAA06iAEA6hYLLEcCgAAJiAKYQIsg70YCIfBBAACeQ51HDLwC7EYELd4C +gADrqgIJ6ASAAPqAJhWgOwUA/amYBaAKVQBYrxf6IegV4E01AC1EIP5CaBWgjxUA9oRGHeCJBQD2 +hGYd41wlAP1gAEWx7mkA/+IADLANdQDtnQIHc/0AAO7ZOAJQoQAA+CGGFeAMZQBYqdwuYhGKb/6F +5h2o7h0ALkQuWzcE+oZmHajqHQAuRDL6IYgVqO4dAP6GJh2o7h0ALkQw/MJIFaANFQAtRDX8h2Yd +oA0FAC1ENPwhyBXozB0A/IdGHajMHQD8hyYdqMwdACxEOP5C6BWotx0A+obGHej1HQD2huYd6I8d +APqEJh2omB0AKUQkKEQlL0QmLkQ/9ITmHejuHQD+h8YdqO4dAP6Hph2o7h0ALkQ87QAFAmEBAAAM +AmGKKSsiFqOqo7srJhaaKYkdGtRo6BILLM8CgACqmSiWnSsgFi8K/3+xCuogByngBIAAW3FIiif6 +AEId4AwFAPtEABWgDSUAW5GRKyITLPp/DLsB+kJmFeACBQDRDwAA6iQACdgEgABbcPtkrh3AINEP +ih8rKoCrqi2g2WTRWJoZ/gDiHab4yQD/3+7mYgCdAMCl/ajMBaA7BQBYrrCNGS3Q2fOgCk/SAJ0A +wYj9AAtg4gCdAMBQ/GFEFa/2wgAAZc2lpUXlFhAiqIEAAOokAArYBIAAW/vrKGBu7xIQLWAEgAD1 +AAuIkgCdABjUUS2AgGrRH6+q64IhLUAEgABt2RIpsADphCAl2AUAAOSQvWRABQAAG9NaHtQtrcWM +Hv6gAEfwPdUA7fQgIMBBAADsBAUMUASAAPoEqB2gDaUA+iEGFa/8ZQDZsA27LQy6KKqZqekpkADp +hAAsUASAAOW/5WRABQAA56QBINhBAAB6uyLtsAAkc/8AACzg/+3k/yVT/QAA7LQAJdgFAADqs+F0 +Q/0AACgcECmAANMP0w/xIRAN4AwFACqAAbHM5a/3ZEAFAAAsFhHq/CEg2EEAAFipPygSEaWF9KBA +Fe/7ugCtqfckBh3v/QYAAKVL67wgKVAEgABb/lHVoPxhRBWv8gIAANog5UwIC1gEgAD9hAAVoA0V +AFv8m44ZLeDZLwr+790BDSgEgAD92yYd7/p6ANog5UwIC1gEgADszCAsaASAAFv8kI4ZLeDZJQr3 +9aAEBvDv9QDv3QENKASAAP3bJh3v+aYAAAAAAAAA61QACVAEgABb+hT1QGgd7/lCAACIImWN/Isa +2iDrvBgpYASAAFuX/8Ag0Q+LGtog67wSKWAEgABbl/rAINEPAGwQCCggaPZCCBWgibUAeYEEwCDR +DwCONMB0+afABeAKBQD1wBLYEAUFABzT3fxACBXgOwUA6hYAIqDBAAD+gGgd4ApVAFiuH4siKiAH +Llxf/admBeTuHQD/e1wN4aoBAAyrEa27LLKemhWUFP+AFYuiAJ0AJLKd79M5EhUxgAAnIhP+QSgV +oHdBAA93CidygIwqpXfuzAwDuMEAAPeADkPiAJ0AKyAWKAr/eLEV+kDwFaAMBQBbcJYd05nv0ygV +E6mAACshBxjSxxzTlv+nKgWquwEA6dOVHd8CgAAMuwKbQIsg7CEaItF9AAD4gEYV5KodAO67Ag3O +AoAACakCmUEpIhObRJxG+AgAB3KZUQDv7AoMzYKAAOzCgC92goAACe4CCO4CnkcMfAzsRgUmYEEA +AJxDKyIWjCkV0wOnu6fMnCn6QsYV7+kFAPif9hxiAJ0A5QAFAkiBAAAJAmEJAmEJAmEnQCHAlPiE +Bh3giAUACHcCJ0QhLmISse8vZhL+h2YdqO4dAP6HRh2o7h0A/ocmHajuHQAuRDgsIhf8h+YdqMwd +APyHxh2ozB0A/IemHajMHQAsRDyONJoW+mCoFeAHBQD1wAbIGM4dAC5ENydEJydEJidEJSdEJCxE +NvqGZh3ozB0A/IamHajMHQD8hoYdqLsdAPqGRh3oux0A+oYmHei7HQArRDD2hGYd6McdACxEIuUA +BQJZAQAACwJhKSAHCQlBDJkRrZkqlp0rIBYoCv94sQcqIAeMFFtwIIon+gBCHeAMBQD7RAAVoA0l +AFuQaisiEyz6fwy7AfpCZhXgAgUA0Q8AAADqJAAL2ASAAFtv0x3TKu/SuRVxUYAAY/2PJZCAsVUF +CEH47wANMA8FAAj6OKWt+60ACr/2QgAAAB3S5f2ligWv+/UAK0Q3LEQ2/IamHeD+9QAuRDSKb7Gq +mm9bNYUb0zX6hmYdqModACxEMvNwEBXozB0A/IYmHajMHQDsRDAiUUEAAOuyISngBIAAWKhMHdMJ +6hIGIfAFAAD+hOYdqO4dAP6Exh2o7h0A/oSmHajuHQD+hIYdr/uuAIsV2iDrvBgpYASAAFuXLcAg +0Q+LFdog67wSKWAEgABblyjAINEPAGwQCCMiGdMP0w8vMAX+YAgVoHQlAH9Ld/oAoh2gOwUA7NKc +GegEgABYrVQvMAUoCnP14oYNoAIFAPngB1wgeVUA+eAH3GIAnQDApf2lJAWgOwUA7jIAKegEgABY +rUjKLIM40w8lMhkc0mEiMAf8oJAV4ApVAP6gCBWgOwUA/qCwFeEiAQBYrT0oUAV4QzzRD/xACBXg +ClUA/aUCBaA7BQBYrTYvMAX1/IYNoHkFAHnx3PphCBWgCwUA/AACHaANJQBbfrrRDwAAAAAAHNJJ +j1gtUASOUP/gCBXgClUA8iAGFaAIBQD4ICYVoDsFAFitI/pgaB2gC4UA7RwQKWAEgABbgnzu0jwV +AomAAI0wwMCcoQ7dAp2gG9I46BIEKU8CgACrmZiQ0Q8AgjgvCnQvNAX+QKYd4AIVAP5gsBXv/DYA +iTgoCncoNAX5IKYdoAIVAP5gsBXv+9YA2jD9pFAFoAsFAFuCSdEPAGwQFhzSvI0gLiAFjzAoMAX0 +ICYVoApVAPggBhWgOwUAWKz8G9IfF9IdFtIvHtHw/GDoFaAPBQD7pWAFoY0FAPQSQh3gmQUA7MIO +IgxZAABvRAf0gARRUgCdAGhEOsAg0Q8oMAV5iUiCPimieCjgfS6ifyqih+kiCA92QoAA7q4ICRZC +gACiqvEAB7fQiQUA+cAARPADzgAAiygqshPEwAyqAvtiZhWgAgUA0Q8AAAAA+gCiHaA7BQDs0pEa +aASAAFis1Is6LjAFKrII9cAJfGIAnQCKKFv/cMAg0Q8AAAAA/IBoHeAKVQD9pQwFoDsFAFisyIs6 +LjAFirj13/r9YgCdAI0wGdHIKKITj6AsoAUJiAIophOcEBzR+imyAPggJhXgAjUA+WCwFaAKVQD4 +IEYVoDsFAFist4s3i74qGoCquiKkkiwwBfWf+JViAJ0AHNGnH9F5/6TQBa+dVQAtNAUv8oAu4ocs +wH0J/xGv7vGAC9/SAJ0AKQqA+cAARPAF1gApKoCp6f2AAERwblUALoSRiKAnFhb6IoYV4A5FAOYW +GixeAoAADrsCKxYVKJAHLpEuCAhBAIgRCO4CBu4CLhYYC+owLxYb6xYZJkgLAADpZgAA2cEAAAsM +iglAiAsIigkgiAsEigkAiAsAiiscUPwAgh2gDSUAW4vywCDRD4+gGdGJKKITLKAFjTAJiAIophOc +EBzRu4qw+iAmFaAENQD5YLAV4ApVAPggRhXgOwUAWKx4izeLvioagKq6JKSSLDAF9Z/0bWIAnQAe +0isc0Wf/onQF751VAC00BSzAfS/ygC7ihwn/Ee/uCAZ8PIAAKQqA+cAARPAAJgApKoCp6cDALKSR +GtGHiDCXFpYamhT9AAAUMApFAAqIApgVL5AHLpEuDw9BAP8RD+4CBu4CnhgN6jCdGZwb6b0CINDB +AAAJ4IgKHIoJwIgKGIoJoIgKFIoJgIgKEIrrHBAp0ASAAPwAgh2gDSUAW4u2Y/3lKSqAqenAwCyk +kRrRaogwlxaWGpoU/QAAFDAKRQAKiAKYFS+QBy6RLg8PQQD/EQ/uAgbuAp4YDeownRmcG+m9AiDQ +wQAACWCICgyKCUCICgiKCSCICgSKCQCICgCK6xwQKdAEgAD8AIIdoA0lAFuLmcAg0Q8AAAAAAAAA +bBAEKzAF96LKBeAEBQD38gIdoJwlAP1gBXQglVUA9WAFNGCYBQD5YAY9IgCdAIk4InKJ6jIJJIBx +gACZoIs4mrGUOJQ5KHJ1ijclMgD7QcgVoAsFAPivAAq1bIUAWKb3lDiUOZQ6lDuUPJQ9lD6UPyQ2 +ECQ2ESQ2EiQ2EyQ2FCQ2FSQ2FiQ2FyQ2GCQ2GSQ2GiQ2GyQ2HCQ2HSQ2HuQ2HyrYBIAA9mCmHaAM +BQD6SwgVoA0VAFuWjysiWrC7+ktGFeACBQDRDwCOPS0iE8f9D+4B7jYNJrh+gAB8sTOUOvVh3g3g +AhUAiD3xAAXv0gCdAMAg0Q/aIFsqWxzRqCoiEyswBQyqAfpCZhWgmSUAebnLiTgicontMgkkgHGA +AJnQjjid4ZQ4lDkocnWKN4Uw+0HIFaALBQD4rwAKtWyFAFimv5Q4lDmUOpQ7lDyUPZQ+lD8kNhAk +NhEkNhIkNhMkNhQkNhUkNhYkNhckNhgkNhkkNhokNhskNhwkNh0kNh7kNh8q2ASAAPZgph2gDAUA ++ksIFaANFQBbllcrIlqwu/pLRhXgAgUA0Q8AG9F9HNBd7dF9GdAEgABbKkraMFsqLY43ju4u7QMk +5FkkNhH0YqYVoAwlACw2E409IjYSIjYUAt0C/GGmFeACBQDRDwAAAGwQBCwiBw8CACzCDivCwAO4 +AQS6AeihB3koBIAAI8LG/aLMBaANFQDzYAQHcA8FAP9PAA8wOwUA/6IAD7AKVQDtNAAKcASAAFir +nO/QkhGEOYAAGtFaL/B9K6J4KaKA/WgAFbAGFQDrmQgH/FiAACmSJ4meKZIQ+T/gFeAAQgAAACmS +p4meKZIQsJniooYkgImAAIIkbZkHiCJzgSoiLCjA0OLUAAaB0YAAyiouIQb6AKIdoDsFAOzRQhlo +BIAAWKt/0Q8AAAAA/EBoHe//WgAAAAAAAADAIP//TA2v/vUA2lD9oawFoDulAFsy6GSvuZOplKqW +qIlSZZ+uK1AH+qBoHaG7AQDrvBgq4ASAAFuVM2P/lWwQEBzRK4MpJyAHjSAuIAUrIhP6IAYV4ApV +APhA6BWnRQEA9J/AFeAJFQD1LQAK8XcBAOiCAir4BIAA+CAmFaA7BQBYq1krIhDsIhEp0ASAAFv/ +pvdAaB2gHEUA8NdMDeAKBQArIhP7gBWK4gCdAComE/SACWESAJ0Ajif9QGgdoAsVAPvEABWgDRUA +W44TYAEPAAAAACjhC8Ce6PMJd3AJAACx3X2b7R7RA/hBaBXgDwUA/iGGFeAIFQCYGCgWEC8WESgh +JQ6ZAiilAvlABhXniwEA5NkQDEOCgAAJiAIvIhEuISQupQOfoisiEPtAZhXmswEA7iAHLf/CgAD6 +oAAUt/8BAO8WDy/5AoAA+eYAD/HuAQDpYQYvd4KAAO/uAg5+AoAA/8YAD3APZQCfHe6mBSzPAoAA +CYgCHs+xGdAk/iHGFaPDGQAMiAIc0Nse0NsJiAIswn+ep5ikLMJQLmAT/iEmFaMpdQD5gAi8YgCd +APoi5hWjKbUA+YAHPGIAnQDqHCAg2UEAAFuKAWShF/oAoh2gOwUA7NDKGugEgABYqwKNLmTQDQIq +AvpB6BXgDBUAC9AAjC3IyfpB6BXgCgUAC8AAAioCWAEhIgoABgAAAAAAAPpAaB2gKwUA7RwQK+AE +gABbgE7xVGAN4QsFAIwq/aCSBeAO1QD8WAAGMA8VAP1tAA+wCwUA79pPf6gEgABgAAUA3xp1+gmx +u+vq9H2BCoAAHtClLzEYLuJ/8mLEFeANBQD+IsYVoAnlAO7hCyeF2YAA///y+6IAnQAuEhbA0P/A +QBWv+TYAAAD//xANoAsFABzPhythB/1gBTQiAJ0AGdCUCbkCmRv6IuYVr/wOAAAA+iLmFaLDQQD9 +iAAWMNM5AOy8Ag7sAoAADcwC/CFGFa/7egAtEhcvEhX9oQwFoApVAP+gxhXgOwUA7hIUL+gEgABY +qrgpCnIpJAUYz9XuEgQr/wKAAKj/7vYAIhStAACKJ/oAIh3gDAUA+0QAFaANFQBbjXnSoNEPL1rc +///tK6ANBQBj/0LAINEPAAAAAAAA+YBoHe/9ggDaIOu8ASlgBIAA6yYTI9hhAABblGbaIOzQZhrY +BIAAW3/ewCDRDwAAbBAQgyklIActIgD4QmgV4H4VAC4kBSkWACgiByoKBf2gpgWgOwUA+QBIFaAP +BQD4ICYVoVUBAFiqiysiEOwiESnQBIAAW/7Y9UBoHaAGBQDxRkwN4BtFACoiEw8CAPtgE/KiAJ0A +JiYTjS5k0A0CKgL6QegV4AwVAAvQACwiDWTACvpB6BXgCgUAC8AAAioCWACd7yIAKXAEgAD9oHgF +oApVAPoGAh3gDQUAWKpuwCDRDwAAAAAAAPpAaB2gKwUA7RwQKuAEgABbf8Ttz8IVETmAAI8qLhoA +/lgAB/AMFQAP7Dn3gGgd4AsFAP2gComgDtUAYAAHAAAA2Bp3igmxu+vq9H2BCoAAHdAbLjEYLdJ/ +8mLEFeAMBQD8IsYV4AjlAO3RCycLMYAAfeMeLRIWwMD9oEAV4ABGACnRC8CO6eMJdugJAACxzHyL +7ZYcJhYRGNAIjiv8RKQV4AkVAJkYKRYQLaUC+cYADzfbAQDupgAu64KAAOghJC5xAoAADt0CKSIR +maIopQPuQQYr3QKAAPhCCBWmwwEA6KYDLkfCgAD4QPAV54gBAOgWDy93AoAA7t0CDEECgAD/nmoF +oZkBAOuIAgzPgoAA+SYADLODGQDo3QIP3gKAAPsmAAzwCGUAmB2ZpRvP5A7dAp2kHs60LhYOK7J/ +Hc/gLaYHK7JQLUAT/CEmFeMpdQB5sVv6IuYVoyy1AHyxMOocICDZQQAAW4kLZKBz/OBoHeAKVQD9 +n6YFoDsFAFiqC2P+LQAAAAAA//sQDaALBQAczr0rQQf9YAQ0IgCdABnPygm5Apkb+iLmFa/+1gAA +APoi5hWis0EA/WgAFbDTOQDrywIO7AKAAA27AvohRhXv/kIALlrc/d/1y+AMBQBj/pIsEhcvEhX/ +gMYV4ApVAP2fbgWgOwUA7hIUL+gEgABYqesoCnIoJAUfzwjtEgQq9wKAAK/u/cAGFe/3CgAAAAD5 +gGgd7/4CACtcGOmsASlgBIAA6SYTKVAEgABbk6TaIP2fSAWgCwUAW38bY/2MAABsEASFIBvPoB3P +oSQhJYoqKNKc87ZIFeAGBQD6gABCd5oBAOhVDASB4YAAyySMJy/6wPZA5hWv+PUA6MYAJnCBAAAP +7gHmxRQncQEAAJ7Jnsj1IAYYkgCdAPUgBuESAJ0Amior0kzuIhElgeGAAP+dCAXgCgUAbQgpKPJ3 +LNKsqKgJiBGozIzHjM4pwr/umQ91UAUAACnCwrCZKcbCK9JMe6sCY//PligmJgkmJgomJgsmJgwm +Jg0mJg4mJg8mJhAmJhEmJhImJhMmJhQmJhUmJhYmJhf9ntwFoApVAPoGAh3gTQUAWKmd+qBoHeB6 +BQD6QKYdoAwFAPpqqBWgDRUAW5Qo6jJWKlgEgAD8AAIdoA0VAFuUJNEPLjJT+kFIFaFPxQDvPwgG +WCEAAJvhnsKfw/pqZhXv/LIAKTJR+kFIFaFLRQDrOwgGQCEAAJiRmcKbw/hqJhWv/C4AAABsEAwr +ITWDJxjPTMBS8mHIFeAMFQD7CBYN4AQFACogBSgKkvlACMQgmVUAeaEFwCDRDwAAJSYTLCYSLCYU +JCYRii3kJhUl6AUAAC0lNfFABt+SAJ0A0kDRD9ogWyfXHc6LGc4wjy3/nLgFoYoFAPpgAEU/+OUA +CP8Bny0fzpYlpJIu4H0rkoApkogkpJHqIgAt3kKAAPsgAETyjAUA/iDGFeCLBQDtFgAnfDCAAPsg +AETwABoArJn9nOgFoAtFAOwWAi1WAoAAC6oCmhEokAcukS4ICEEAiBEI7gIP7gKeFA3qMJ0V5BYH +IcgLAADpZgAA0IEAAAoMiglAiAoIigkgiAoEigkAiAoAiuokAAjYBIAA/ACCHaANJQBbiKT0RqQd +oAIFANEPAAAAAADqJAAJ2ASAAFgB+cAg0Q8AAAAA2iBbJ53AINEPbBAE8EJQDe/71QCEN4k9KjAF +hE4LmQH4YaYV4JhVAHihIygKkHihHcAg0Q/6AEIdoDsFAOzO8BnoBIAAWKkewCDRDwAAABzO7Cki +GS1CjiMmEPkhKBXgClUA+GGGFeA7BQBYqRUvQo4ezbkczuT8QmgV4Y/hAO7+AQxBAoAA+cYADzKP +yQDzGAAUMf+5AOjuAg/6QoAAD90C/6YADrAKVQD8QmYV4DsFAFipAxvOSiMgB/mbhgXgDBUA7CYX +KVAEgAD4QwYV74ilAPhNBh2hMwEAW4kq/EJoFeAPBQDvpQopYASAAP9AhhXgjgUA7t0CAdhhAADt +JhMpUASAAFuStsAg0Q9sED4jIhmDN4M+LTAA/KAABvA19QD1oBK+ECg1APmgEvwgKUUA95wwBeCG +BQD5pOYN4ChlAPmgBeQgOSUA+aAQ/GIAnQB10QzAov2dWAWgOwUAWKjY0Q8ALiIXLTAYLzAZJSAH +5DAaLu4CgAAP3QLvMBsu7gKAAATdAuQiEC7uAoAAD90C/6AH5SFVAQCx7i4mFy4wAf2dNAWgTQUA +/cAEBvAKVQD3wAQHMDsFAFiowfpAaB2gCwUAW4jvKCITL0Bu5ogCDTgEgADoJhMnjgGAAPmb5AXg +CgUAKnQSKnUImXKLImW/btog7CQAAthhAABbknjRDy4iFywwGCQiEC0wGS8wGuVCBy5mAoAADcwC +7TAbLmYCgAAPzALlUg4uZgKAAA3MAu7JB3doBQAALSYXLjACZe8e2iBb+z8vQG75//iY0gCdACtd +AvogaB2hXAUAWKNwG81hGs3TGM2MK7KAKqKD+Q+wFaAJJQDpFBAt3kKAAKuq8QAN/9IAnQD3QABE +sAbyAIJHwDT9nLwFoAolAPJByBWgOwUAWKiGG81PGs3BGM16K7KAKqKDLC0C6IB9Ld5CgAD7QABF +cEt1ACvEEf6ACBXiiQUA5xZqJHwwgAD3QABEsAAaAKmpGM2YGs2YKhZk6BZmL/4CgAAD/wIvFmUu +kActkS4ODkEA7hEO3QIH3QItFmgM6jDsFmkhSAsAAPogICWgCwUA6xZrJVH9AADpZgAFUMUAAAoM +iglAiAoIigkgiAoEigkAiAoAiusdASpQBIAA+2/gFeAMRQD7YiAV4A0lAFuHwtEPAAAAAOokAAnY +BIAAW+mb0Q8AAADqJAAJ2ASAAFsusdEPAAAA6iQACdgEgABb6kPRDy0wASwwBC8wBR7NhOgwBi5m +AoAAD8wC7zAHLmYCgAAIzAIIzBHvzAIB2MEAAO7MAQbhqoAA+oBoHaANBQBb5gEuMBQvMBXoMBYv +dgKAAA/uAu8wFy92AoAACO4CCO4RD+4CnnQtMBAuMBEfzXjoMBIu7gKAAA7dAu4wEy7uAoAACN0C +73YCLu4CgAAO3QL84KYV7/cKAAAAAAAA+oBoHaANFQBb5edj/ZoAACkqgKmpGM0/+5qABaALBQAr +FBGPQCoWVCcWWigWVv3gABewCEUACP8CLxZVLpAHLZEuDg5BAO4RDt0CB90CLRZYDOowLBZZ6xZb +INAHAADqrHAoyASAAAngiAocignAiAoYigmgiAoUigmAiAoQitpA+iAgJeAMRQD7agAV4A0lAFuH +adEPAABsEAgczdEazO2PICMgB/hDKBXnRQEA9J/AFeANFQAF1TktkASImv8gCBWge4UAK5QFCogC +KyQF+SFGFaEzAQDyIAYV4ApVAPQgJhXgOwUAWKfp+kBoHaAbBQDtHBAp4ASAAFt9QuzNuRUCOYAA +iyDA0C2kCQy7ApugiSmZoRjM/O4SBCn/AoAAqP/u9gAiFHkAACoiB/oAIh3gDAUA+0QAFaANFQBb +iqDAINEPwCDRD9og7M2nGtgEgABbfRHAINEPAAAAbBAMG8yUGMzAKbKIK7KAKIB9+kBoHaCMBQDj +OjkN3kKAAOuZCAR8OIAA/SAARjAALgAAACwqgKyc7czeGMgEgADzQZ4N7/v1APphaBXgABIADQCH +CQJhCQJhCQJhCQJh5AceAMiBAAAJAmMEAIYJAmEdzNEZzNKIoB/M4p8W+CAGFeAORQDtFgIsRgKA +AA6NAp0RKcAHLcEuCQlBAJkRCd0CD90C7RYEL2AEgAAJ6jApFgUlFDH6I4Qd4A8FAP4g5hXgDSUA +DYgC6BYJKNgEgABbhwLRDwAAbBAEE8xeKCEMJDJ5IzKIqEQJRBGkM4Q3KCAThE7JjvSBABXgCwUA ++qBoHaDsBQBYom7aUOwgEyFYgQAAWKJeKCASyoEpCuj4gABCcAsFAPqAaB2g7AUAWKJk2kDsIBIh +WAcAAFiiVCr6heo0BSmQBIAA0Q9sEAQUzMMpIQwoQnUjQoSpiAmIEagzijf0kUgVoAsFAPtByBWj +PAUAWKJSKkJXKyEM/AACHaANFQBbkfwbzMb6QYQd7/r1AJo70Q8AbBAEFcywJFKKKkJXKKECIyEM +yInbMFuKDcinwCDRD8Ag0Q8A6kJXKdgEgAD8ACIdoA0VAFuR6hjMISiCeSVShKg4CYgRqFWEVywg +E4ROZMAK6ywgIlAhAABYoicsIBLIzCoK6OpKCAFYBwAAWKIijFCcJZNb8kGEHe+LVQDrVAUqkASA +ANEPAGwQBOJJCAkwBIAA0w9tShIlMADlZAAhmAUAAORQBmMwBQAA0Q/AgCiUANEPbBAIKzKS+5oG +BaFEhQCkNCdBfiQykyyimyOisiiiTC2irCoyVQnMEa3M/0BEFeCOBQBtiRCNx43eKNK/9QAIDCIA +nQCuzMDgnhVk8QYoMlYogQJkgP2bFFuGTxjL6xXM7SiCeCVSrOqICA0wBIAA6jJWLEZCgACoVVuG +R4sUjhUfzPMYzPAp4AcnVSSWW5JfKFYMLlYJL1YNK1YQJFYRK1AHFMzpJFYO9ZnUBaD8xQAMuwH9 +mdAFoZkBAAuZAilUB+3gByl4BIAA9UAAQjA7BQD/xrAVoApVAPSkpB2h3QEAWKcAF8zMLTJVHMzb +LnJNLdEClRDoUgAreASAAPQgRhWgClUA+CAmFaA7BQBYpvXwpAAN4AQlAC8gbvqAaB2gDhUAD+o5 +/U3gANAMBQD1QAWBH+OlAMow2lBb/RPSMNEPKNLC7BYFJEAFAAD5uEYVr/vqAMAs0Q8AABzMwPyg +CBXgClUA/qDoFaA7BQBYpt0qIG4bzLuVKulSCiUE4YAAC5sCm1qMLQTMAuwmDSrQBIAAW/w70qDR +Dy1ysivSUy4aTK7dfbFIj7EpsgAp9gAosgAvhgEstgDstgElgqGAAO5SACX7/wAALvY+jFotvPid +V/uGAA4wAwUA/KFGFa/9YgAocrIrglEpGkSpiHi5C//9CA2v80UAAAAAAI2xj7Cf0I6wneGcsOy2 +AS39pgAA//yIDaADBQD4oUYV7/2mAGwQDBvLeR/L0RjLpCmyiCuygPpAaB2gDkUA+Q+wFaCMBQDk +NBEt3kKAAPsgAETyjQUA68vZFHwwgAD9IABEsAAaAK2ZGMvDjaCbFp8S6BYALu4CgAAO3QKdESyQ +ByiRLgwJQQCZEQmIAguIApgUD+ow/iCmFeAOBQDuFgcgyIEAAANgiAkMigNAiAkIigMgiAkEigMA +iAkAitsQ/ACCHaANJQBbhfPRD2wQBOLL0RkYBIAAJSKKKFJYKIEC9lCIFaCKZQDkgSZhI8EAAIk1 +KCJ1qYgJiBEIZggpYAV6kQUq+oYqZAUqUlhbhaMkQnoiIoSqRAlEEaQihCcfywgkQg7+QeYV4AcV +ACcmFPZCRhXvngUA/kCmHaANJQAtJhMsMgj7QGgd4czxAOwkbipQBIAAWzalx58pJhDoMgUp2ASA +APZBZhWgAwUA4yU1IlALAAD4QcYVoVwFAFihMipCiP9BoAEQDCUAKyBvDLsCKyRv/0GgANAORQAt +IG8O3QItJG//QeAAkAiFAC8gb9MPCP8CLyRvCoxX/0GgAVALNQApIG8HmQIpJG/9YaAdoB4FAC0g +bw7dAi0kb+giACJYBwAALLGSLCU0K7GTKyYWKkKLKiYYKUKMKSYXKEaGL1JakyjjJgkn+AUAAC9W +WtEPwCDRDwAAbBAGHMwT/GBIFeAKVQD+YGgVoAsFAFimLogwhjIZzA3kMgMoBAqAAPEABMKSAJ0A +9yMSDaALFQDGyupUAAnYBIAAWKWSwCDRDwAAAOBABAId8QAAiif4TvAV4AzVAPqABADQzJ0A6qIO +LdgKgADvxwp8uASAAC0gDWXfu+sWACMEeYAA6bkCA3AFAAD6gAEHt5kBAOkkdyf4FwAALvXo7vXp +I4JZgADdQP7AaB2gClUA/ZfSBaALBQBYpgX//egNoAwFAP/9yA2gDAUAGsqZKqKV81/78NIAnQDA +ov2XwAWgCwUAWKX6Y/9NAAAAAGSftcCl/Ze2BaALBQBYpfUbysrsy9gZUASAAFijcGP/l91A92Bo +HaAKVQD9l6YFoAsFAFil6ykgd8evCmoDCpkBCQlH6SR3I/wxgABln37Apf2XlgWgCwUAWKXi2iBb +JE5j/2kAAGwQBoQnFcvFKSB3hE72AAIdoAMFAPpgCADQB0UA9ICgJaCJnQB/h2cqQeiwqgoKT+pF +6C0C5gAA6RYCIZzxAAArIA3qIAwtg2YAAOkWAi1WAoAAGcr2CghHCYgKmBEogo4KihQqFgALgAAK +CUHokV9tWASAAGiTWihSf9ogC4AAKkHo0w8PAgDpEgIlA7mAAOZsBCKoEQAA5EwEIZgFAADgMAQD +u/0AAP73nA3giZ0AYABwG8ubiiArsn+ZEguqDP1AABUwCxUA+0YADX/+HgB8pxmNJ43eiRKm3f2g +wCXgDBUA/a0EHa/+pgAAAIgRKIKQ+iAIFa/5xQAJuwELgABj/3QqIHf6YAQA0AsVAP1gAQXf/PUA +DLsDC6oB+k7mHa/9wgAbymzsy3oZUASAAFijEsAg0Q8AAGwQBGP//AAAbBAEE8t4wIgoNlLAICI2 +U9EPAABsEATAov2W5gWgCwUAWKWGwKZbiWvAINEPAAAAbBAEwKT9ltoFoAsFAFilfxjKddMPKIB9 +e4dAHcpeGsoT/A8CHaALBQD9sIgV4BkFAG2aDC6hlOzhCHVQCQAAsbvHuwCwBPyfAA/wCiUA/gAA +B/ALFQAPujlYeTzAINEPbBAEwKT9lqwFoAsFAFilZ8Ag0Q9sEAYsCgH8IAYdoDqFAOwUASjYBIAA +WI65FctNFstOF8pA8h/iHeAE5QDmbOAtA3oAAMOp+iAgFeAMFQBYjq8pUH9moFf4gAAE8AsFAPUi +ng2gGgUAbaoMLGGU48EQczAJAACxux7KuS0QAZ3r0Q9mv/IqcoT5lWoFr/z1APtgBADQCRUA7xAB +LMgKgAAMnAOfiwyqAQqZAil2hNEPK1B/CwtEdLkY+gACHeAcBQBtyg0tYZRz0Q7rvAEjMAkAAB7K +o5rr0Q9mv/UpcoQfyqD7YAQA0AgVAP0AAQRf/PUADIwDmvsMmQEJiAIodoTRDwBsEASKJ4quKq0G +KqFvW//AG8m+HMqSK7KV/YFoFaC76QALuwoPuxErvHPssit9GASAAIkniZ7yAAIdr8MBAOTACmTI +FwAAI5Xu0Q8AKpHv+z3EHaACBQDRD8ClW4j5Y//QAAAAbBAEGssA6qJ/KVgEgAD8YGgdoA0VAFuP +ndKg0Q8AAABsEAQayvgqon/bIFuHs9Kg0Q8AAGwQBpQRkhDnyvMbYASAAO1UAAnwBIAAKBpAKHYQ +J3IR5xYDI4+RgAD4AAId4AoFAPoAAh3gAwUA8AKADaAFFQAAAAAA8mPwDeAnBQD67wAL8AQFAOcW +AiOSoYAAhhInCgD64AQA0AIVAOZs/yqYCoAAbWkP4CEEARAFAADjRAIKmAqAAANDAifiAAOGAePz +AQ2BCoAA4tIAKZgKgAADdwLmEgIrGAqAACfmAAMiAicSAOMSASsCCoAA86AGFaFvnQD24AYVoSid +APJgBhWgAwUAK6zg9SAJ9JIAnQCGEwCRBABXGvbABANwKAUA7mxMZMgFAAB2g3wvwCXowCQlUCEA +AGSvzvVf+d5SAJ0AhuDi0gAtgQqAAAD3GudmAgwYCoAA4yICDVgEgAD3wAYVoAMVAPOgBhWv/noA +AABuZFb0wATK0gCdACbAHO/BFyVQRQAA+YLEFaB2EQD44AATsGYhAOf/Ags0AoAA9wYADD/+UgAA +APzHgEfRBwUA9uAE46IPBQCIyPtAYBWi+AEA//3ADaKIGQBuYmL03/m50gCdAIjI+0BgFaL4MQD/ +/UwNoohJAAD2wAQnUI8FAPf/+KOiAJ0AiMj7QSAVqPhxAP/8wA2oiLkAAAAAAAAA/M6ARdAfBQD3 +//djogCdAO/AJyVQIQAA+YTQFa/8KgD43/ag0gCdAIjI+0AgFaD4YQD/+8ANoIhpAMAg0Q8AAP7f +9aViAJ0AKMAc+0AgFaD4MQD/+zwNoIg5AAAAAAAA+N/0ptIAnQDvwQ0lUEEAAPmBhBWv+soA+N/z +5FIAnQAmwBzvwRUlUEUAAPmChBWgdhkA+OAAE7BmKQDn/wILNAKAAPcGAAw/+f4AhhCCYACxBAD3 +GgciApJghhGCYACHGgciAvLABhWv+LYAAAAAAP/3XA2gAwUAbBAE9hYCHeCGBQDy4gALcJUFAKVl +4lY4AhP1AAAobEAChjjSYNEPAGwQBBXKPtMPJFJWJVKp/pgAEjEIBQDlRQsCeF+AAPUPAAwwCgUA +bYkHKVEAcpEDuFXRDypVAZpRKlUA0Q8AAABsEAQfyi4p8lYu8qnA0P84ABSxCwUA7poLBPmbgAAJ +uwxtuRwroQDcoOKxNXzABIAA8WQwDeeZAQDqzAgkSAUAAOzyqSaB2YAALVQADtYLDNwLImUAI8UB +9YAmFaACFQDRDyOlAZSh+KAGHeACBQDRDwAAAAAAAAD9IgAO//72AMcv0Q9sEAQXyg3TDylyVihy +qf84ABSxCgUA6JgLBPhjgAAJqgxtqQ0rgQBysQvpnAEkQCEAAMcv0Q8jhQGUgfigBh3gAgUA0Q8A +AAAAAAAAbBAEKCAEijP8AAId4An1APkBhg3nqsEAwCDRDwAAAADtJFQlAMmAACwiFB/J8SvBAB7I +kg+7AQ67AivFAIgiKyITKiISLSYS/EJmFe/55QAJiAH4QEYVoAwFAFijYcAg0Q8AAGwQBCghBxnJ +4ggISgyIEQmIApgwhyAWyd/pyYIbvgKAAAdHApcx5gAVAZAhAAACAIqVNek2BCGQYQAA0Q8AAABs +EAbrMgMqaASAAPpA6BWgBgUA5iQnK2AEgAD7YAAC/zuBAOtEAAVQgQAAW4aiKiAmwLHkyWkRiGmA +AOekAA1PAoAA9UAGQhIAnQCkmSySnpoQ94AIsdIAnQApkp1kkOwuIQcfybsODkoM7hEP7gKekI0g +HMm4/aAAFrAONQAO3QLtlgEk0CEAAOwAFQmYQoAACgCK/ZKoBe9/9QD+oAQH9oUBAO2WBCxDAoAA +CDMC/EMEFeAchQCclfxCCBWghTkA6iIRLEVCgAAI/wKIIOaWCS/8AoAAn5iTl/shZhWi3R0A6smd +HuwCgAANzAKcmgqIApiWgyILMwKTIuMSASv/AoAApP//86YVoAIFANEPHckJjNjqFgAmDXOAAAx5 +EaSZLpKebuNoKZKd5JBkZnP9AACe2GWfKPogBhWgAEoAAAAAAAD6SoYd7/vOAACLENog67wYKWAE +gABbh8wsICfLzMAg0Q8AAAAAAAAA//u0DaAJBQDAoFihCR3I7ozYihD9kwAI0AsVAP/+oA2gCQUA +wJDA6g7ONP+hBhWv/mYAiifAsPtEABWgDBUAW40aHMlsH8lqn6DtIgAp9AKAAA5eAv1ARhWgCxUA +7qYDLu4CgAAL3QKdofpE5h3gAgUA0Q9sEA4rIgouIAX7YQgVoJNVAHPhAdEPj6AcyVspohMooAWN +IAyZASmmE5gQjLCcESqwBf2SqgWgOwUA+iBGFaAKVQBYo1eLJ4u+KhqA+2AARTAOFQAupJItIAVz +2bYdyBn9kIwFr54lAC4kBSnSiC3SgCzAfe7IbR7uQoAA7ZkIBnw8gAAvCoD/IABE8AAmACgqgKiZ +GMhm/5DuBeAMBQAspJGKIJ8a/iDGFaANRQDoFgQtVgKAAA2qApoVKJAHLpEuCAhBAIgRCO4CD+4C +nhgN6jCcG+0WCSXICwAA6WYAANDBAAAKDIoJQIgKCIoJIIgKBIoJAIgKAIrrHBApUASAAPwAgh2g +DSUAW4KQ0Q8AAGwQDisiCi4gBfthCBWgkyUAc+EB0Q+PoBzIIimiEyigBY0gDJkCKaYTmBCMsJwR +KrAF/ZCkBaA7BQD6IEYVoApVAFijE4sni74qGoD7YABFMA41AC6kki0gBXPZth3H1f2QBAWvnlUA +LiQFKdKILdKALMB97sgpHu5CgADtmQgGfDyAAC8KgP8gAETwACYAKCqAqJkYyCL/kGYF4AwFACyk +kYognxr+IMYVoA1FAOgWBC1WAoAADaoCmhUokAcukS4ICEEAiBEI7gIP7gKeGA3qMJwb7RYJJcgL +AADpZgAA0MEAAAoMiglAiAoIigkgiAoEigkAiAoAiuscEClQBIAA/ACCHaANJQBbgkzRDwAAbBAa +FcjaJlKxKGJaKVJOZIHR68jVFI5xgAArFiYZyNQYyBPoFicg0MEAACoWJOrI0RChwQAAJBYl+CUm +FeAEBQDqFiolWUEAAOsWKyVSwQAA+iUGFaAAvgAAAAD0YAlpEgCdAPoAoh2gOwUA7BIrKegEgABY +osIsUk6xRPyACyKiAJ0A6mJYKlgEgABbjW7ox4UdfyIAACiCeidSq6qICYgRqHeNfIl6ctnLZJE1 +jphk4TBrMqVmP6Ip4hPzIAkjkgCdAIp980AI15CbJQAqcAX7QAiMYJxVAHypmmkxly0gNSwSKP/A +CBXgClUA/uAIFaA7BQBYoqKNfYx687/7v5CfVQAucAWKyP/f+1ViAJ0AjXAZyJQoohOPoCugBQmI +ASimE5sQicCZESjABfwkyBWgClUA+CBGFaA7BQBYopCLd4u+KhqA+2AARTAOFQAupJIscAUtCpX9 +n/jdYgCdAC36ki10BR3HTxzHey3SgClSqyzAfQndEa2Z8YAMz9IAnQAuCoD/IABEsAZOACwSKigg +By/gBykgFvgCAAQw+rUA6v8BDEeCgAAI/wIv5AcoIAf9wAgV4PvFAAv/AfnCxh3hiAEA+eYAD7AK +VQD/wOYd4DsFAP4gAAdw/xEAWKJoY/6TANEPZT7vLSA1LBIp/8AIFeAKVQD+4AgVoDsFAFiiYIx6 +LnAF+4EIFaCZJQD53/MlYgCdAI1wGcddKKITj6AroAUJiAIophObEInAmREowAX8JOgVoApVAPgg +RhWgOwUAWKJPi3eLvioagPtgAEUwDjUALqSSLHAFLQqS/Z/wrWIAnQAt+pUtdAUdxw4cxzopUqst +0oAswH0J3RHtmQgGfDyAAC4KgP8gAESwACYALyqAr5kcx139jtwF4AgFACikkRrHWS9yAC0WGiwW +FCoWFv3gABewCkUACv8CLxYVLpAHLJEuDg5B6hIlL3QCgAAOzAINzAIsFhgJ6jAoFhvpFhklyAsA +AAlgiAoMiglAiAoIigkgiAoEigkAiAoAiuscUCvQBIAA/ACCHaANJQBbgYZj/V8tKoCtmRjHPP+O +dAXgDgUALqSRGsdKjXCfFvgghhWgD0UA6hYKLu4CgAAP3QKdFSyQByiRLgwJQQCZEQmIAgqIAioS +JJgYD+ownxnuFgslyAsAAAngiAocignAiAoYigmgiAoUigmAiAoQiuscECvQBIAA/ACCHaANJQBb +gWZj/N5sEAiIICMWBCkSBCMgBxfHjPYAQh2gBKUA+QDyDeEzAQAERgL0YAlKEgCdAAw4EQeICCmC +nvcgExuiAJ0AKIKdCIQC6BYDJAopgAAZxwgJAIdtaQIIAmEpIQeLIBrHe/wgiBWqmQEADJkR6pkC +DdYCgAD9YAjToAUFAB/H2ZlA/47mBaAMhQCcQ55C+Y+sBeANJQANqgKaQQm5AplEKvKALvJ/6yEJ +KccCgAD3AABEcAwFAOaGnSdz/QAA/+/mFaANFQBbjFuKJ44i/0QAFe/IBQAI/wHlpRQn+QEAAJ+p +76YIJwKxgAD9j4AFoApVAPxACBXgOyUAWKG8iCJkgITAsPv+Ah2vCQUAbQgNeJANCIgU5IAcZdgh +AABj/+t4oAu0u/AAGA2kiB0AsbsIGBRlj/faIFuFx4onx58ppgAlJgdbgYglJATlJAUqEASAANEP +FccSiVj3IApQkgCdAAw4EaeIKoKe90AKk6IAnQAogp1kgUmwmvqhBhWv+xoAAAAAAAAA//6oDaAL +BQDSgNEPH8eXjhMcxiWVEfQgBhXgDUUA7asCDceCgAAtIAcMiAL5wIYVoCyFAJzjmeCb4RnHI/nA +RhXh3QEA7RYCKNAEgADv3QIBWYUAAP3AphXgDDUAWJxZtBr6S6AV4Aw1AFicVo8THsbZG8d+lfv1 +4UYV7/j1AJj5mPiY95X2jBCKEfhA5BXghAUA9eAAQjfMwQAMqgKa/IoSjRAYxwkLqgLrxwYe7gKA +AP+mAA66mQEA7fYNLM8CgAALmQIp9hCLICX2FiX2FyX2GCX2GSX2GiX2GyX2HCX2HSj2EvviphWg +LIUA/eJmFaAORQDsxewd1gKAAA6uAu72ES3HgoAADIgC+eKGFa/3ngAAAAAAAP/2gA2gCAUAwKBY +nteJWPk/9XiSAJ0A//YkDaAIBQAAwIAEmjT6oQYVr/XuAAAAAGwQCCggBcOuDwIA+wANpCIAnQCJ +JyokBQ8CAPskABXvxAUA9WAEBbADBQDjlRQl0QEAAJqZ6pYIKVAEgABbH6X6QGgdoItFAFgyrYMp +ZDE/945sBeBG5QD2IKYV4FdlAIk3KJkUhTsqMAXkkgkkAVGAAHehKvdABvwiAJ0A5jQFKdAEgABb +H5MZxykqkX9+pxjNSGAAwQAA//9YDaAEBQDaMFuBamAArwAAZECqjBWNQ45CiUCKQf5hBBXgOyUA +/iDmFeeZwQD4IMYV56oBAPoghhWgKAUA6jIALAIKgAD6IAYVoO6dAPggJhXgClUAWKELG8cOK7F/ +ihf/aoAHU/z1AHyhYo0WaNYoZEBK6jQAClgEgAD8IIgVoI9FAP6BBB3gDhUA/mKmHaANBQBYYX1g +ACSNFIo3LAoADwIA69QABVCBAABbg8L1QGgdr/76AAAAKzr/e6EP41QACvgmAADyQSgV4ACyAI03 +/aQAFa/OBQD/gAQGMA4FAO7VFCZhAQAAnNn9oQYVr/9CAAAAAADrIgohgXmAAMq8KbILDwIADwIA +yJ5tCAnpkgss2ASAAMiRY//vk7v6YYYV4A8FAJ8p0Q/RDwAAAPJBRhXgCAUAmCnRD2wQHCgwIhXG +1Q8CAAiICQyIEahTJTJ/DwIA6iQAAoIJgAASxgUtoAwuInsqIoMO3Qjp3REK2ASAAP1AAEVwDBUA +WI6R9gWiHaAnZQDwgRAN4Cw1AGhDCfSABWKSAJ0A0Q8voAXTDw8CAHzx8sKCKKQFWx8j8nBIFaGK +BQD6YABFMAsFAPtPJh3v+fUA6aR6KQFmAABj/8cAAAAAAPpgaB2gCxUAWEqIIzIJyDkrMAV2uemD +OWU/9IIpZC+iLCIVdcn0LSAFd9Hujycp+sDk8g4nwIEAAAmIAfZAph3gDgUA7vUUJEEBAACY+ej2 +CClQBIAAWx8DKkERgyqxqupFESn9ZgAAY/+vLKQFWx79IjKCZC9LH8aC7xYtIPBlAADuFi4g6HUA +AO0WLCDY4QAA+iXmFeAAqgAAAAAAAAD6YGgdoAsVAFhKYCMyCcg5KDAFdonpgzllP/SCKWQvAiki +FfU+ng3gK1UAKiAF+0AHjWIAnQDsEi0owASAAPJBSBXuDgUA/iVGFaANBQD8JWYV4AsFAPwAChWg +CkUA/YziBaAZVQBtmgIIAIqcEIgwKhQY+iJmHeP59QApFQj9AAAUMAm1AAmIApgRLzAE9eAGgpIA +nQAqEi76aeAV4Aw1AFibMioSLPppgBXgDDUAWJsvFMWSKDIVDwIAJEKDw5/pNAUsRkKAAKhE+iXo +FaAJVQD4JgYd4AgFACgUMegUMiJZAQAA+CZmHaAMhQBYmx/rTEgg0f0AAPtFoBWgDDUAWJsaLhIr +6jQACNgEgADTD/8OAA8wDLUA/iGmFaANJQBYRpeIJyr6wOSCDiRIgQAACpkB9kCmHeAPBQDvhRQk +yQEAAJmJ6YYIKVAEgABbHp0rQRGDKrG760URKfWuAABj/rgqEi76aQAV4Aw1AFia/yQcfyRMKS9A +Ae1AAiDwdQAALeQCL+QB9IAQFaAstQDk5AApoASAAPxgph2v/L4AAGwQBikwIhjGHgmZCQyZEamD +KzJ/ZLDxFcVRLSAMLlJ7KlKDrt39qAAWsAwVAO2qCAKTsQAAWI3d/IOAEdArJQDJRC+gBXv5F8KB ++UCmHaAASgAAAAAAAAD0gAkjEgCdAPpv6BXhhwUApzokoHsmoHrloHglhKmAAC2ggBrFOC4igCqi +g67dCd0R/UAARXAMFQBYjcYvoAcmpBb0AgAEcPm1AOn/AQxHgoAA+eYAD7D+xQD/4AQHsZUBAAn/ +Ai+kB+oyhy0QBIAAHMXwK6AHLSAFpzgOuwH7JgAM9/YBAOmkBypwBIAA+Q8wFaA7JQD4IAYVoApF +AFif3SMygsg5FcXj+JgAEjAALgDRD4M5ZD/4jTAqMRkuIAcpIBbpNBYq4ASAAP5g5h2rqgEA+oYA +DTA7JQD6YyQdoApFAFifzIo6zKZj/8WKqWSvwCwwBy0wFisxGYmqK6UnLaQW7KQHJP8xgAALC09t +CBMrlSIuoAcvoBYvlBYulAeJmGSfx2P/5SigBcKT+R/2vWIAnQD7QKYd7/s+AAAAAGwQDhvFvRnE +fCuwgCyShi6ShC2SiKLM4u4IDmZCgAAM3AjswgcvdkKAAA7dCPwiBhXgCgUA/YHIFaAIRQBtihEA +oAQLDRvv1wZ1cAUAAJ4csaomGoCmxi9g5ffgDcCSAJ0AG8WpGcWnH8Wl/4tKBaAMBQD+IUYVp9IB +AO8WCCFz/QAA/CFmFeAPBQD+ISYV4A0VAA7cOOwWBSlEwoAA6YgICVeCgADrqggBqAkAAPogxhWg +BwUA+CDmFaADFgCKFRnFk4gZCpg5mBkpEgn/cAAVsAoVAOsSBi2BCoAA/UABBVAIBQD7IABEsAqF +APl4ZhXgCwUAbaoX+wAEANOpAQDgqhoEQAkAAPtgAEW0mR0ALBIHK8aLLBIKLRIQLxILLhIPLdAi +/iAGFaAKRQD+IcgVoDslAFifZyoSECqgIogeHsV0Cq8J6RIPL/8CgACv7vnPxh3gDxUAL+R9IuR8 +KOR/WAP1K2Dl4zwDI7gFAADvAgACqA0AAPrgBNniAJ0A61QAANBBAAD0YDAVoAwlAFiaKcCB/CII +FaLkKQD+IcYVovQBAO4WDS8BCoAA78RfLEAKgAAoxF4tEQgtxTAqEQis7CzARPwh5hWgG4UA6hYA +KWgEgAD9ip4FoApVAFifPRvFTilg5yoRCGWfd3uhKBzFS40c/V/7ZSIAnQD5v/ixUgCdAOsSDSl1 +tgAAwOD+ISYVr/riANEPFMP4KEJ3JEKIoojsEggsRkKAAKhEjUAuQDUqQAeaEClAFvggJhXgOwUA ++IMkFaAPJQD4IEYVoApVAFifIChANPkf+ENSAJ0AIkQHiR6KH/qCxh2gCyUA6UUZKlAEgABb/Ddj +/uYAAABsEAQYw90cxSYkgobigoQpaASAACiCiK1E7SIICiZCgACkhIRH7jABKRZCgACoIvSByBWg +ClUA/kWmHaAbhQBYnwUpTQIpkGfIlNEPAAAAAPpAaB2gCxUAWG/s0Q8AAABsEAT3hygFoReFAAcn +KKdmJ2L1BHcoB3cK/vgAE7PohQAIdywaxQjiKQsJxwKAAKhmA5kJGMUFDJkRqpkIeAKYkPbWhhXg +lcUAJWaz0Q8AAGwQCBbDiygwANMPJWJ/JGJ9KWKBolXiRAgKrkKAAPUgAELwCoUA9KDoFeKIAQDo +qDgKJkKAAOlECAHYBQAA9KHIFeAMRQDoRFwg0EEAAFiZrYkUsDv4n+AVoA0FAPyLZh3jqQEA+olm +HaSZHQD8YZAVoAp1AG2qH/0LZh3jqQEA7IRUJdv9AAD7CWYdpJkdAOywDSRD/QAA7MTZHlgEgAAr +hFSOFC9ATylATidAUyhAUCpATS1AUStAUuNATC1UAoAA4N0RDEICgADtiAIN3gKAAOt3AgmaAoAA +6jMCDM4CgAAJ/wID/wIIdwLnFgApaASAAPKLkBXgClUA8iAmFeAbhQBYnqgsXQIswGcPAgBlwG0t +QFyDQChiffIAAh2gBhUA0w/oMwwGgsGAANow+kBoHeAMBQD0QABCsA0FAPSpkBXgDwUA/iAmFeAO +BQD+IEYV4GlFAPggBhXgDwUAW3yoZqAdBlw36jQACVgEgABbfIzmoA5hEAUAAChAXHgjq9EP0Q/R +DwAAbBAEwCHRDwBsEATAIdEPAGwQBMAh0Q8AbBAEGMNJJoKGJYKEKIKIombiVQgLNkKAAAaGCCZi +BwlVEQhVCOZiDiIB+YAA/YkYBaAKVQD+YBAVoBuFAO5ULSloBIAAWJ5v+qBoHaALFQBYb1oqbQEp +oaHAsguZAumloSmQBIAA0Q/AINEPbBAIFsMI42J/KdAEgAAoYn0lYoGiM+KICAmeQoAA8qAAQfAL +BQDyYOgV4A/1AP0IABQwAhUA+KAAQrAIhQDjMg4iBpGAAP1ACBWgBAUAbYojC10M+08ADPPsAQD/ +wAVkZMwdACTUWy7USymQC+nUUyXYBQAAjFAroAwrVFwmYn3AQObGDAWDeYAAmhTaYPqAaB3gDAUA +9IAAQ/ANBQD26ZAV4AkFAPggJhXgDgUA+CBGFeBoRQD4IAYVoA8FAFt8TWagGwJ8N+pkAApYBIAA +W3wx5qAKYiAFAAAoUFx4Q6srPQEpsaGKFAKZAum1oS0QBIAA0Q8rPQEpsaECmQLptaEtEASAANEP +AAAAAPOrZh2v/V4AwCDRD2wQBIgwKjAIKzAJ8QAJKlMoAQD0gAXq0A7VAPxiABXjuwEA+iAABjKq +IQDkwQ1mQ/UAAP4AQh3gBBUA6PQ4BQepgAD1QAdr0gCdAASmDAYGR6a5+cAG62IAnQBkYF4YxCDv +wsYZdMKAAA6+CujuCAtIBIAA7+8IDtgEgAD1IAa4kgCdAOi0AA3QBIAADwCH6wAHB3BBAADqBgAE +y/kAAOomAAf4QQAA6IceBdhBAADogx4M/k4AAA1rEQ29CgQOR2TgWfpAaB2gCyUAWAAoYABLAAAA +/YfuBeAfpQDvSVR5ZMKAANsw+AGiHeTIBQBtmhisia2ZKpKA6ZKBJdghAADqtgEkQCEAAJmw+kBo +HaALJQD8bgAV4Aw1AFgAFMDA6lQACdgEgABYnUXAINEPAAAAAAAA//+cDa/spQD/X0AN4AQFAOq4 +CAU7s4AA6OLkfTAEgABj/wYZwq2p6SqSgJqwKZKB+WAmFe/9PgBsEAQYw93HnOiCgCIAgYAAdJgI +GsPJaDELaDIIxirRDwAAAAAAKqCAACAECgobf6fq9GAK2RIAnQAXw9Ecw9AIA0FkMVX0YArgkAsV +AA8pER7CcBrDzO3CkhJ9fIAAwCTueAgNGASAAPhABeDSAJ0ArX8i8oCSMC/ygZ8x6bYJDZfCgADm +my9xeAUAAAqYCoNQ8qAoFaH/HQBt+RqHgKNzk1CGgHY7A7EiklGPgaLy4lYBJEAhAAC4Ve5HY30Y +BIAA/4AAQjACRQDvAgAJuASAAPhABEjSAJ0ArcImIoCWMCIigZIx6bcJDZfCgADnmy9xQAUAAAqU +CoNQ8qAoFaGIHQBtiRqKQKOjk1CJQHk7A7EiklGLQaKy4lYBIiAhAADAINEPAAAAAO80AAmwBIAA +CACH4wAHA7hBAADmBgABE/kAAOYmAARAQQAA74ceAZhBAADvgx4JeI4AAGP/HdgwBCCH4yAHBmBB +AADoRgABE/kAAOhmAAIgQQAA548eAZhBAADnix4JehYAAGP/VgAAHMN+94b8Be/6ogDAkP/6vA2g +C0UAHsN6Ay0Rrt2N0PoAQh3gCgUA/bVgJeAJRQD9QgAM//o2AABsEASIMP5hMBXgGqUA+mEQFe/s +pQDxAAd6UygBAPSABvrQF2UA/GIAFeAEFQD6IAAGde8BAP4HAAfyuyEA5MFXZkv1AAAoCgLphDgF +iiGAAPVgCePQCBUABLYMD485/u0ADXdmAQAG6Aj5QAkbIgCdAGRgbBrB9RjCafqAAh3lSQUAD7k5 +6e4KCXzCgAAP7gjo7ggO2ASAAOrvCAtIBIAA9SAIuJIAnQDotAAN0ASAAA8Ah+sABwdwQQAA6gYA +BMv5AADqJgAH+EEAAOiHHgXYQQAA6IMeDP5OAAANaxENvQoEDkfI6fpAaB2gCxUAW/9S8ABMDaAM +BQAAAAAAAAAA+oKGDaQIBQDqVAAJ2ASAAFicfcAg0Q8A7cMZGdgEgAD4WAAWMBl1ANMPbZoYrImt +mSqSgOmSgSXYIQAA6rYBJEAhAACZsChaQPpgaB3gGbUAbZoZrImtmSqSgOmSgSXYIQAA6rYvJEAh +AAApti7aIPwzAh3gCxUA/GAARvAMNQBb/y3//gQNoAwFAAAAAAAA//3QDa/spQD/f0AN4AQFAOvo +CAW7s4AAwJEPnzkPejl4otz3YGgdr/r2ABrBx6rqL6KAn7AqooH7YCYVr/w+AGwQBBrC/hfBnBnC +chjCxqc30w/TD20ITOhRTGpYBIAA3EAtgkAuktIK5gEGJgImltIvktIHAIcEAGEultLtktIiIEEA +AOwGAAGYQQAA7CYAA7hBAADrhx4Cq/kAAOuDHgKBgYAAY/+oK4JAL5LSCvcBBycCJ5bSJpLSFcGj +pTUmUoCWQSVSgZVAL5bSLpLS0Q/RDwBsEASLMMbK8WAFolCrOQD2gAVhUIYFAB/Bc+7BlhgECoAA +9IAEotIAnQAkMQQEzULxqgAN5EQBAPWgBMPQHAUA9aAARLAYFQAKyDn5AAQr4AwVAMCQ+4IADLMI +BQDphjkB4EEAAOZKCwXhzoAAKSAMG8K/BpkRqamrma+a9aAJsJIAnQDrxAAOeASAAAoAh+wABwTI +QQAA7wYABuv5AADvJgAFUEEAAOuHHgZgQQAA64MeDv5OAABgAD3AiXhBVOpUAAnYBIAAWJv3wCDR +DwAAAAAAAP//nA2v7KUAGcKlwLhtugkukqUODlLJ4riZwLCquyogN1v/nf//DA2gDAUAK5KkCwtJ +/3AAFb//mgAAAAAAAADot0Fx4CEAABnClcDYbdoJLpKlDg5Syee4mcCgpqv6RvAVoB0FAFv/jP/9 ++A2gDAUAKpKkCgpJ/1AAFT//hgAAAAAAAAAqIAwbwoYGqhGrqv9AAEXwGQUA6JE0bmgEgADfwAsg +h+wgBwVQQQAA70YABMv5AADvZgAF2EEAAO2PHgZgQQAA7YseDP5+AABj/5iuqCmCgJnAKIKB+YAm +Fa/+LgCumiuigJvAKqKB+4AmFa/80gBsEAQoIARohgXAINEPAAAUwmiMLitCfwnMEay7i7eLvi6w +HSmwHCqwGC2wGeywHizOAoAA7pkCDVYCgAANqgIusBrtsB8szgKAAAyZAuywGyzOAoAA7ZkCDVYC +gAAOqgItsBXusDUtVgKAAOyqAgTgBQAA/WPmHaiMHQDpywZ3cAUAALGqLLAUKLQeLrQ1KrQbLrAW ++2IQFaj6HQD/Y0Yd6IgdAPljph2o/x0A/2MmHeiIHQD5Y4YdqP8dAC+0GO+wES5mAoAADcwC7bAS +LmYCgADuzAINVgKAAA+qAu+wEy1WAoAADaoCLbAX7jELLVYCgADvqgIOZgKAAA3MAv3AAEYwDQUA +/4DSDaj8HQCxqiq0Eyy0F/9ixh3oih0A+WJGHaj/HQD/YqYd6IgdAPliJh2o/x0A/2KGHeiIHQAo +tBCMLStCfwnMEay7i7eLvi+wGSqwGCmwHCiwHeywHi1WAoAA76oCDM4CgAAImQIvsB/osBoszgKA +AAyZAuywGy1WAoAA6KoCDM4CgADvmQINVgKAAOyqAgTgBQAALLQf+YDSDeiMHQCxqiywWSq0G/lj +xh2o+h0A+2IQFaiIHQAotB3/Y0Yd6IgdAPljhh2o/x0AL7QZ+WIwFaj/HQDvtBgmYAUAACy0WSyw +FO+wFS1WAoAACKoC6LAWLmYCgAAPzALvsBIuZgKAAAjMAuiwEy1WAoAAD6oC77AXLVYCgAAIqgLq +2ggOZgKAAA/MAqzsfssBsaouITctITYqtBP9YuYdqJodAPliRh3ozB0A/WLGHaiZHQD5YiYd6Mwd +AP1iph2omR0A+WIGHejMHQD9YoYdoAolAP2DngWgOyUAWJuojTf+YSgVoAolAP2DlgWgOyUAWJuj +LSAFxOX/v+tdIgCdAMX1/kCmHeACBQDRDwAAbBAGKiAHGMHB/YOCBeGqAQAKpAnpwC8aJwKAAK1G +I2J/qUSoRPKBHg3gCwUAwCDRD44xmhGHMJfgjzAsORAn0qie8Zsw6zYBJgNBgACKN2SgXo2hGMGr +HMGv+Q/oFaidHQAMmQHqPBgszkKAAPkAAER33QEA6BYCK+AEgABbfkkawab6YSQV4AwFAPtIaBWg +DRUAW4YJKjz4W3tU3HDqEgIq8ASAAPogaB3gDQUAW2s9K2J/9X/7rCIAnQCMImXPa4sR2iDrvBgp +YASAAFuFMMAg0Q9sEAYTwXUCJAkMRBEEMwgrMiAkMH8mMH7lMHwliGGAABrAKC0whC6igCqiiA7d +CAndEf1AAEVwDBUAWIkoL6AHJqQW9AIABHD5tQDp/wEMR4KAAPnmAA+w/sUA/+AEB7GVAQAJ/wIv +pAfqMigtEASAACugBxzBUS0gBQ67AfsmAAz39gEA6aQHKnAEgAD4b7AVoDslAPggBhWgCkUAWJs/ +IzIjZDCBFcFF+JgAEjAAJgCDOWQwcY0wKjEZLiAHKSAW6TQWKuAEgAD+YOYdq6oBAPqGAA0wOyUA ++mMkHaAKRQBYmy6KOsynY//FAIqpZK+/LDAHLTAWKzEZiaorpSctpBbspAck/zGAAAsLT20IEyuV +Ii6gBy+gFi+UFi6UB4mYZJ/HY//lANEPAABsEAQpCoAJOgHyYAm+EoNBAKmJ9SAJr1IAnQAJlQLx +VCAN4pNBAC8gDBbBPBvBPfngCY1mowEAKSANLSBVLCBUHsE57cwIBIFpgADkkQ1mY/0AACjgfS1i +WSec/wh3KA/dCAfdCAvZCimSgAkJRnmhEi0gVf1AB2PiAJ0A/UAHIqIAnQApIA3sIAwkgYmAAOjg +fSSAiYAAL2JZsJ0I3Sis/A3MCAvJCimSgAkJRnmpCPAAVA2gCwUAACkgDSsgVcDBCck5C6sMq5sq +IhRbfZXov7EVBImAACiCgy1ipqWFCVURBdUIG8EQGcAD6QAFDcgEgAAJAmEJAmEJAmEJAmEewGQY +wGASwEfhShAKSIKAAPsmAAywDBUADJkCKSadKIKP/mYADzANVQDuJpwq0ASAAAuAACIinQKCR8km +0Q8AAAAAAAD/+0wNppMBAPUwABXv+zoAwoIoVAXRDwD94Ggd7/wWAP/99A2gBQUAbBAIJiAMFMDt +GL/fJSANmBPoAAUKSASAAAkCYQkCYQkCYQkCYR3ALRjAPBzA5R7ALO5GAStOAoAA6VkCAjpBAAD8 +gIQdoAoFAOpEESnfAoAA60QQKVAEgADogowqWASAAP0mAAzwDEUA+IAGFeANVQALgAApch0JiUfI +ktKQ0Q8awNIZvzgrcTwDPgkYwKMfwM3vFgQvdwKAAPnAAEQ7uwEAmxaYEvsP5hXhjQUArY2qmanu +nhUm1IAl1IEq8AEs8AAs5AAq5AEo8AMp8AIp5AIo5AMt8AUv8ATv5AQpUASAAP3Aph3gDBUAWIhW +ixUcwJQpIQgoIQkmIQflIA0tGASAAC0wJi8gDCogFA3dCS80DCg1CSk1COo0FC7vAoAArc0mNQf0 +YaYd4A71AC40BIUWjhMWv/kt0H8OAIfuEgQqSASAAAkCYQkCYQkCYQkCYRnAnvN/0AWgDEUA7HYd +LsUCgAAJiAICUgIidhwodTwosAApsAEp5AEo5AAtsAIvsAMv5AMt5AIpsAQqsAUq5AUp5AQoYo3A +1etEAAnQBIAAC4AALnIdDwIADwIADo5H8duADeFfBQD1wA2FEgCdAPuBCAWvjgEA6eQADHWGAAAe +wH8poQIpFQIqogAqFgAoMCYpEgMdwFYIiAnpAAUMRwKAAAjdCO3QfypIBIAACQJhCQJhCQJhCQJh +InYcKGKNLBECKREALxEB/ufEHeAKRQDqdh0qWASAAOl1PSnQBIAA7HU/Ls0CgAD/JgAMsAxFAPjn +hB3gDVUAC4AALnIdDwIADo5HZOHU9cAOjRIAnQD5wGgd7/4BAOgSAy/whgAA6AAFCkgEgAAJAmEJ +AmEJAmEJAmEoYo4Zv577gKQF4AIVAOJ2HSnQBIAA+uPGFeANVQDpWQIKWASAAOl2HClgBIAAC4AA +KXIdCYxH8ZacDeiZHQCME/oAgh2gCwUA7AAFCkgEgAAJAmEJAmEJAmEJAmEidTwoYpgZv4grdT0c +v4f646YVoA1VAOx2ICnQBIAA6VkCClgEgAD444YV4AxFAAuAAClyHQmNR/GwvA3omR0AihPqAAUK +SASAAAkCYQkCYQkCYQkCYShimxm/dft+6gXgDCUALHYd63YfKdAEgAD4pgAM8A1VAOl2HCpYBIAA +C4AAInIdAoJH0Q8AKHE8CAhJ+f/yUqIAnQCKE/wgSBXhjAUA6gAFCkgEgAAJAmEJAmEJAmEJAmGs +3SzQhC/QhSjQhinQgy7QguiIEQ/8AoAA6P8CDM4CgADt0IcvdAKAAAnuAg7MAg/dAg3MA/LjhhWs +3B0A/ZcADnALFQD/f/wFptwdAP2XAA5wCgUA/uOmFaXMAQBYm6/8AIIdoA1VAOhijS1IBIAA63Yf +KdAEgADpdh4qWASAAAuAAC5yHf/2eA2n7kEAAAAJAkfRDyhxPA8CAPkgAAQxXwUA+f/xCqIAnQAq +EgPqAAUKSASAAAkCYQkCYQkCYQkCYSwQAi4QACgQBCkQAS8QA+0QBSxGAoAA6JkRD3QCgADp7gIP +/AKAAAj/Ag/dAg7MAg3MA/LjhhWs3B0A/ZcADnALFQD/f5wFptwdAP2XAA5wCgUA/uOmFaXMAQBY +m3/8AIIdoA1VAOhijS1IBIAA63YfKdAEgADpdh4qWASAAAuAAC5yHf/1+A2n7kEAAABsEAaJMB6/ +iSsgDI0yJuJgKOF/KuJo+sAAQ3fdwQD8yAATMykBAOpmCAQEcYAAepZA7L+wGSFAAADwANwNoBRl +AJoR6RYAI4thgADaYPrgaB3gDBUAWIdBLqAFwvH/wA9sYgCdANpg6yQAC+AEgABYAJDAQNpQ6zQA +CmAEgABYmNbAINEPKOJkGb9qAisJ4ogIDd8CgACpueeR/yxGQoAA6KoIBvzpgAD9osAA0BRlAGP/ +wAAAAAAA9X1qBa/+4gAAAJsSmhHpFgAjjXGAABm/hBi96oQSqYjoRAgB0IEAAPqAaB3gDGUAWJQk +jzmNOABEBP+rAA707R0A/mEGFaBXBQDnNCAh0KEAAPxhJhXgDgUA/mTmHafdQQDi3QIKWASAAPxk +xh3gDGUAWJQUijuIOgBEBPsLAAw0mB0AmTrnNCgqWASAAPhhZhWviQUA+GXmHeeIQQDzBgAMMAxl +AOg0LiHQaQAAWJQFixDaYPt/5BXgDBUAW/4NCgRPZU712iBb/b+OES7gIh2/Ww7uCexgDC93AoAA +rt0t0ID9n/atYgCdANpg+iAoFeAMZQBb+QBj/sCIEQ8CACiAIgiICe9gDCxHAoAAqMgogID54AXs +IgCdAIlnLGICK5kU836OBaANFQDtzAIE0IEAAOxmAiWFiYAAK5IJZLCmLrAALwoqf+kFKLICcoFB ++gACHeAMJQBbgqcbvzodvvidoIxgkqKTpSSkHPVAxhXv+fUA+0CGFeANJQDppB0uZgKAAA3MAuym +ASrQBIAAWJiJwCDRD4oQKqKCyaEroAX9fk4FoC1VAP1/+nxiAJ0A2mDrJAAL4ASAAFgAD2P9+epk +AAlYBIAAW/4lCgRPZU3qY/5BixH6wGgdoAxVAFv4D2P/NgAAAAD6AAId4AwlAFt/QGP/ZAAAbBAG +Fb8G934IBeCPBQAPRgHygBBeEgCdAASJQq+Z9SAQN1IAnQCZEuy+/hMGUYAALSAM/kGwFaK0QQD7 +oAW9ZjQBACsgVSkgVOuZCAcPWYAA5OILZPv9AAApwH0rclmw6AmIKK27qLsFvQot0oANDUZ9MQgr +IFV7M3t/O3gpIA3KnOsgDCSAmYAAL8B9LnJZsJ0P3Sir6627BbgKKIKACAhGeDkH8ABQDaALBQAp +IA0rIFXA0QnZOQs7DKubKiIUW3tX7L7XFQ1JgAAavXGIEi+igy5ypqj/Cf8Rr+7uFgEjAPmAAAQD +Rm4+ISk8gPggBhXgAHYAwLDrFgErf04AAPRIAAGwiAUAqDNvPt2TEPDVUA3itEEAKiAMLSAN+0AK +PWY0AQArIFUpIFTrmQgGiImAAOTQE2Tz/QAAKMB9L3JZsNsIuyiq+quqBakKKZKACQlGeTESKyBV ++mAIW+IAnQD+YAgaogCdACkgDcqd6iAMJICZgAAuwH0tclmwmw67KKraq6oFrwov8oAPD0Z/OQjw +AFQNoAsFAAApIA0rIFXAwQnJOQs7DKubKiIUW3sc6L04FQWhgACJECiCgyJypqmICYgRqCIbvpcZ +vYnpAAUNyASAAAkCYQkCYQkCYQkCYRO9zxi95/l70gXgDBUALDadKIKP6UkCCVAEgAD4c4YV4A1V +AAuAACkynfogKBXnmUEA8SMQDeAqNQAqtAXRD//4CA2mlAEALJyA/CBGFa/35gAAAAAAAP8gaB3v ++O4A/yBoHa/8VgCOEcLy/kCmHeAtNQAt5AXRDwAAAAAAAAD7oGgd7/gSAP/9bA2gAgUAwID4ICYV +r/nKAAAAbBAIijAXvjGIIvl8fAXjqgEACqoJ675tHVcCgAD7IABEsCylAOaR/yQDOYAAiSctmRTk +01Zk0IEAAC2SCWTTSy7QACjSAnzpAnuBP/oAAh3gDCUAW4HLHb5dG75dl6CMIJOlJKQclab7QIYV +7/n1ACmkHS2mAv2AABYwDSUADcwC7KYBKtAEgABYl63AINEPmRD9fIYFoIoFAAptAfLAFp4SAJ0A +BolCqpn1IBZ3UgCdAJkV7r46FofRgAAoIAwrIA34IEYVopZBAPkAByVmdgEAKiBVKSBU6pkIBZbB +gACwmuoWASWXcYAAGb4uKZB96uJZJcP9AAAJiCiJEgmqCAiqCAyrCiuygAsLRntxFSogVfrgBOOi +AJ0AKBIB+OAEiqIAnQApIA3Lk+ogDCSAsYAAGL4cKIB9sJsIuygo4lmqiquqDKkKKZKACQlGeXkL +wLD8IMYV4AByAAAAKSANKyBV/CDGFeAIFQAJiTkLewyrmyoiFFt6ixy+Co0W7r4HFRSZgACLFSri +oSnipguqCAmqEQqZCOkWBCaBEYAABgdGbn4kK3yA+iBmFeAAggAAAADA8O8WBC7/NgAA9kgAA7CI +BQCod29+2pcT86PQDeKmQQAtIAwrIA37oBF9JnYBACogVSkgVOqZCAWOiYAA5LHpZPv9AAAZvesp +kH0q4lmwuAmIKK2qqKoMqworsoALC0Z7cRIqIFX64A+DogCdAP7gD0LiAJ0AKSANy5LqIAwkgLGA +AB+92y/wfS3iWbCbD7soqtqrqgyoCiiCgAgIRnh5CvAAYA2gCwUAAAAAKSANKyBVwMEJyTkLewwL +mwgqIhRbekxkoZMYvGeJExe9xyiCgydypqmICYgRqHcbvcYZvLnpAAUNyASAAAkCYQkCYQkCYQkC +YR68/xi9Fvl6MAXgDBUALOadKIKP6WkCC9AEgAD504YV4A1VAAuAABm89SmSnRa9wI0U+iAIFeeZ +QQDxLfAN4Cw1AIknLNQFKpkU/EBIFaAHBQAntoLkoJxk2IEAAOqSCSYHOYAAZKCPLqAAwvp/6RQY +va2MovmABiQiAJ0A95/rJCIAnQDasPwAQh2gCwUAW4ETGb2nHL1knKCLIJaik6UkpByVpvdDph3g +DCUA6aYELd4CgAAMuwLrpgEq0ASAAFiW9sAg0Q8AAAAAAAD/9OgNppYBAC6cgP4gphWv9MYAAAAA +AAD6AAId4AwlAFt9umP8vAAAZMBP2rD8AEIdoAsFAFt9tWP/iQAAAAAA+CAmFe/1agD/IGgd7/li +AMKS+OCmHe/8fgAAAAAAAAD6IEgVr/SuAPugaB2v+KYA95/6jSIAnQBj/JzaUPpgaB3gDAUAWJas +2iBYkKbAINEPAAAAAAAAAP/59A2gBwUAwKD6IIYVr/YeAAAAbBAGJjAIJzAJ9iAABLJmIQDoMgAj +BlGAAPTABhPQOoUA8QAGYlB7hQD0gAWS0gCdAPDgCdYSAJ0AGrxGGL1TmBDqAAUMUASAAAoCYQoC +YQoCYQoCYQmaCRm9VAyqEaqZIpIfZCB4GrvjLZCALqKAKqKIrt3p3REJWASAAP1AAEVwDBUAWITi +ixAfvUwYvJb/epgFpZcBAOmc/ytlAoAADJkCJOY/KeWAKIKS/kYAD/ANVQDv5j4qYASAAAuAABy9 +QCzCP/hiABXnzEEA6L0/FgOJgAAMDAbwABwNr8wBABy9OepUAAnYBIAAWJZowCDRD3uG6o0xcdbl +6bzqEiuLgAAoIARogUX1AAWiEgCdAGmFzAcIRQhvCA3/Ef//ABXgTgUAf+O4A4gL6QAVAwBRgABt +aQIIAIr//pwNoAwFAAAAbWkFCACICQCKY/+UBwhFqGsNuxErvPh7o4MDiAvpABUDfqmAAG1pAggA +imP/xyggBGiBcPUABQISAJ0A+R/68tIAnQAHCEWobQ3dEf2/ABXgTAUA/Z/6M+IAnQCKJ4qu6ogL +AchBAADkb4pkQ+EAAG1pBQgAiAkAimP/eQAABwhFqGwNzBEszPj9f/iLogCdAAOIC+kAFQN68YAA +bWkCCACKY/9QBwhFqG0N3REt3Pj9X/dT4gCdAIoniq7qiAsByEEAAORvLmRD4QAAbWkFCACICQCK +Y/8dBwhFqGwNzBEszPj9f/W7ogCdAIonKqIO6ogLAchBAADkbvpkQ+EAAG1pBQgAiAkAimP+6QAA +AGwQChu7wPJEUBWgBgUAJjQfJjQeJjQdJjQcJjQbJjQaJjQZJjQYJjQXJjQWJjQVJjQUJjQTJjQS +JjQRJjQQ6wQFCNAEgAAKAmPrAAUAyFEAAAkCYYgw6hYEIdBBAADpFgkkJFqAAAVaAvpgaB3gDAUA +WJXywCDRDxi8sxS7GQIpCQyZEfiAAEJwDGUA+IAAQjAr5QDrNA8qWASAAFiRUI81jTQARAT/qwAO +9O0dAP5ghhWgVwUAJzQQ7TYFKlgEgAD2YuYdp91BAOLdAgHQYQAA/GLGHeAMZQBYkUEfvKmINhu7 +BYo3/XlKBaSYHQD4YMYV4gA9AAqIGJg39mMGHeeIQQDzBgAMP4kFACk0H+g0HiDIUQAAlpCWkZaS +lpOWEJYR9iBGFafYBQCYE/wgZB2gGvUAKhUF+iBEHeANpQAtFQH+IUQd4A4VAP4kJh2g/fUALRUE +LRUO7BUNKNgEgADrDx4B0IEAAAoCZ+kLHgHAwQAA+AioHa/7vgAAbBAEiDDxAAUi0gCdACkyAWeQ +mRS7BSpCiyuhAmSxYFt1Zh27pYzfscyc3/VACogSAJ0AKEJ0HbtUJEKIqogJiBGoRO0ABQJIgQAA +CQJhCQJhCQJhCQJhCQJhCQJhLyAMLiANLSEHLCAHKyAWKSB6+kFIFaAIRQAoRAQvRAwuRA0tRQcs +RAcpRFP6gsYd4Dv1AOtEBSUHmYAAiajJn20ICemSCCzQBIAAyZJj/+/BxupUAAnYBIAAWJWCwCDR +D5So+oYGHeAGBQAmRgnmRggh2EEAAOtGAAJQ0QAA6oseAchhAADpJgACQPEAAOiHHgH4gQAA7wYA +AnFhAAAOAIotMgvtRhgh4MEAAOwDHgJZkQAA6wwAAlExAAD4QAgV4Aw1AOlGFSHYNQAAWJDOKkxG ++k3AFeAMZQBYkMsqTE/6SQAV4Aw1AFiQxxi8GI1Hj0D6ROQVr8kFAOpFIibwgQAACe4BCP8B7zYK +J3EBAACe2f+hBhWgDAUA96KEHa/80gAA//ysDaAMxQD0QUYVr/zSAGwQDBa7SRq8HYkw57wbGqAE +gAD1eAIF4Cu1AOqaAQSsJIAAjDFmwXN6lkSLMipyhQW7Ae0iAC3eQoAAq6ouoh3pPCAh+KEAAOus +OCVBAQAA/6AIpCIAnQDBxupEAAnYBIAAWJUzwCDRDwAAAAAAAADscnIkpdiAAIoyK3IjBaoBfKsE +rLt6s88lcoUJqBH4oABCsAxlAOo8EiLZoQAAWJCN+KcAFeAMBQDpRgABwGEAAOiLHgL5AQAA7yYA +AfCBAADuhx4C6UEAAO0DHgHYoQAA6wwAAtGBAADqBgAByOEAAPiCaB3v/dYAAGSvaoox7HJyKAQK +gADxX/roUgCdAIoyLXIjBaoB7KsOfUZCgACs3fu/+huiAJ0AJXKFjiqoVfXf+aRiAJ0AKVAF+yAS +zGIAnQDaUFhEqvqgaB2gCwUAWD9s2lBYPu/qVAAJWASAAFg+zypiEftf4BWgDAUA+sImFa/74gAA +AC08GA2giAsUigmAiPiiaB2gDAUA7wceBXFBAADuLAAB6OEAAO1mAAVZgQAA+ppoHe/7CgAqcoku +oQJk4dpbdKAvYhGx/y9mEfVADmASAJ0AG7o4KbJ1GLqOJnKFqpkJmRGpZugABQNIgQAACQJhCQJh +CQJhCQJhCQJhCQJhLyAWKCAHKSEHKiANLSAM/MGGHeAMVQD8wIYdoC61AC5kBSpkDS4hCSwhCCll +ByhkBy9kFi2ygCsgDCpyhS5lCa277GUILd5CgACrqvpCqBXgDBUAWIMeiyrnpAAFlnGAAIm56rQA +BIB5gADpkgks0ASAAGWf9JapkmiKICggNi8gUykhGSllJ/7PRh3gCwUAm2mbavrDphWgDGUA62YL +I1G5AADoZHghWQEAAFiQEBq7eR+7dxu7dfwiABXgDAUAnNCc0ZzSnNOcEJwR/CBGFafeBQCeE/og +ZB3g+fUAKRUE/iEEHeAIFQAoFB0pFQz6IWQd4AmlACkVARu5w/ogRB3gHPUA7BUFKPAEgADuCx4D +QUEAAAgCZe3GAAN5gQAADxiKjCqeGJ0ZdsEPL6JyjmAP7gz+IaYVoAAiAMCAmB0tobnruasW9byA +AGhFZ44yKjwY6hYMIZCBAADzwAjqUgCdAOoGAANA4QAA+IJoHaBbFQDi5gADeQEAAO+fHgtQBIAA +WDgEiWD1IAQE8AwFAPhgRhXv84YAAAAA//NYDaAMxQDqVAAJWASAAFg+P//zDA2gDAUAInAmG7mN +Ai0JDN0RrbsduyMqPBiaHP1gAEXwDGUAWI/GjzeONgBEBP/LAA90jh0A+GDGFaBfBQAvNBieN/4h +qBXn7kEAAu4CLjQeLzQfInAmG7l6Ai0JDN0RrbsduxAqPCCaG/1gAEXwDGUAWI+ziRuNHYw4+iGI +FeCOBQAO3QL+YSgVpIwdAPhhBhWgXwUA/mQGHeIAPQAOzBicOfxk5h3nzEEAAswCLDQm60YAA1Dh +AAAKCIrpJgADQQEAAPiKaB2v/DoALHAmHbr1nBoMzAnqEgwuZwKAAKy7/WAARfAMZQBYj5WON402 +AEQE/6sADrT9HQD+YMYV4F4FAC40GI8djhqdN/5j5h3n3UEADt0CLTQeJ3AmG7lIHbrgB3wJDMwR +7LsICVAEgAD9YABF8AxlAFiPgYgdjzj6IYgVoIkFAAmIAvhhKBXkzx0A/GEGFaBbBQD6ZAYd4gA9 +AAn/GJ85+GTmHaf/QQAH/wL+ZMYd7/jyAPZBRhWv9SYAbBAEiDDUUA8CAP8BQAJQHGUAKSAEaJEQ +6kQACdgEgABYk/3AINEPAAAoIRYoNREvIRgvNRAuIRnuNCQh0CkAAO0gNiFZAQAA/GFGFeAMZQBY +j1opPBjqLEghYOEAAOwmAAHYQQAA+opoHeAMNQDqBgABWUEAAOmDHgHQlQAAWI9PKSBTKTQxKiEX +/0FABBBNBQANmQIpNDH/QUAEUC4FAA6ZAik0Mf9BgAdQDAUAwfAPnwIvNDEoIDT4YIQdr/1uAAAA +AGwQBBm50ogwHrqn6lQACdgEgADjuTcUJQyAABi6XS2SECySEY8niZ8ogn+P/iO1BSO1BiO1B4/0 +n7Qj4n6TtZi2mbcv4oCfuC7if565nbr9YWYVp9kFACm1BMDAWJO9wCDRDwBsEASOMm7iD2jiPGjj +UWjkHsAg0Q8AAADqJAAJ2ASAAOxEAAroBIAAWDY90qDRDwDqJAAJ2ASAAOxEAAroBIAAWDSz0qDR +DwDqJAAJ2ASAAOxEAAroBIAAWAR50qDRDwDqJAAJ2ASAAOxEAAroBIAAWAII0qDRDwAAAAAAbBAG +iicWujAPAgCFqSipFClhf2SA5e6XB3qgBIAAZFDTKSAFxaYPAgD7IAgcIgCdAMS/6yQFKVAEgABb +Eo3wqzAN4/v1AIdRKiEII1UILGF/iFD/h0AHV3cBAPtABWxiAJ0ACIhX9QAGexIAnQDKQttA7HQA +CVAEgADygQQd4AkVAPhCph3gDQUAWFSNYAADAHuhd/pBqBXgXAUALCQFKmJoCbsRC6oIKqIKZKAV +K6xc+iBoHaAMRQBYjtf6IAgVoAAmABq405oQHro/LTroDa0sDt0o7RYAKVAEgABbEmSLEBy4ve26 +ORlQBIAAWxKA2iBbEmPRDwAAAAAA/ybgD5AFBQD//GQNoAQFAI8n/+QAFa/JBQD5wAQHcAgFAOj1 +FCdxAQAAnvn/4QYVr/2iANogW3Qt0Q/RD4on+uBoHeAMBQDqrCAr6ASAAFt2qPVAaB2v/HIAAABs +ECwVuRODLShSgwkzEaODizeLvokuKrAwLLAxCKoR7KoCDM5CgADpgggFUAUAAPtmJh2oqh0A6rQw +KVAEgABbEjaKKcmghKsrCopb/5fqRAAKf6YAAIopwEDrIgslALGAAGWzg/pBZhWgACYAAJq7m6yU +KRe5sCsgDBy4gvhDJBWgHaUALSRSLMKAKBZOKlKD/WAARbAZBQDnABUN3kKAAOuqCAjABIAAbZoC +CACKHrkIKqEuJSxM/0ARJCAGFQAeuMsfuMn8QAgV4OgVACgUGP4gRhXgDIUA7hYALu4CgAAM3QKd +ES4gB/9wuAXh7gEAAO4RDq4CD+4CnhQL6jCbFZ0Z+3O6BaBJBQApFQ+aGCggUigUMS8gBS8UMi4g +MCYUMC4UMy0iFe0WDSDogQAAi9WK1InTiNLv0gEg8QEAAJ/hmOKZ45rkm+WN0J3giyArFhYqIFIq +FF0pIAUpFGAoIDAmFFzkFF4hWNEAAOgUYSDRoQAAWI5SKhxw+keAFeAMhQBYjk8qHHr6SMAV4Axl +AFiOSyocffqgaB3gDDUAWI5I6yxYINH9AAD7QKAVoAyFAFiOQywSTi8RQigRQ/gmJB2gnCEA/g0A +BvDvcQD8LgANsKwpAOvLAg1XwoAA6e4RDu6CgAD+BQAH8IxZAO7dAg/+woAA/kGIFaC7AQD7JgAM +sKxBAOyqEQ3eQoAA/2YADfTumQD/ZgANsPxRAPoshh3g7DkA/AYABbDMSQDt7hEOZsKAAOyqAg3f +goAADrsC7iBkLEZCgADsIGUv/oKAAAj/Av9GAA1w7hkA/8gAFzD8OQD/pgAOsOwxAO7/EQ93woAA +D+4C/6YADrDMKQD9hgAOcD0FAA3MAiwUZYgsC6oCCpkC+CzmHeD4gQD4EQAHMIiRAOruEQxGQoAA +6O4CD/7CgAD/xgAPcA+FAA/uAi4UZownLckU5NE4ZlCBAACJyWSRLvogaB3gDIUAW3mEwZXkJRkg +wf0AAOcAFQRARQAAbZoCCACKHLlh7BYkIVk9AAD4QAgV4A21APQ0Zh2j+vUA9jUGHaAMNQDqFVAs +zgKAAO2ZAgDR/QAA6RYlJVCpAABYjePqHH8q2ASAAPtFwBWgDDUAWI3eJBTBJBTCJBTD/AICHaAL +NQDrFMAg0f0AAOqsRSHZQQAAWI3V6zxAINH9AAD7SqAVoAyFAFiN0Os8OCDR/QAA+0ugFaAMhQBY +jcvrPGAg0AcAAPtAgBWgDIUAWI3HJhWIJBTkJBT0+kBoHaAuBQD+OIYdoPz1AO4UxSDoBwAA5NQU +INn9AADsFYYl2EUAAPwBYh2gDSUAWDk9w/kvJAXRD4m7DwIAZJx8bQgK6ZILLNgEgABknG5j/+4A +AOokAAjYBIAA/AECHaANJQBbcj1j/sUAAGwQNhO49Be4xIstLTJ/HrkV6iAFLd5CgACr24u37Lfv +FVLtAAD/QAEHMAUVAPthyBXgGCUA+UFSDaAEBQCO4ArgAADaIFtzC8Ag0Q8cuQeNIP5GxBWgClUA +/kbkFeA7JQBYkriGLiMyfwlmEaYz5jxMINAVAAD6wGgd4Aw1AFiNiecAFQDAYQAA+3HwBeAZVQBt +mgIIAIqbFvhACBXgDDUALBQr9CYGHeP69QAqFRT9IAAUsAq1AAqZApkXKDAEKhwx9QAN0pIAnQAr +PE9YjXXbYPomoBWgDDUAWI1yJRRIJBRJJBRKJBRLJBRO6xwYKVAEgAD8AEId4AyVAPwpph2gDLUA +WDjs2iBbctrAINEP2iBbctjAINEP2iBbEPiILiMyf9MP5wAVDEZCgADoMwgAwf0AAPkIIBWgGVUA +bZoCCACKHLjLLBYw6SIOIbE9AADlFNgg0f0AAPQ6Zh2j+/UA+i0EHeAMNQD9IAAUsAu1AOuZAgVR +aQAA6RYxK1gEgABYjUjrPEwg0f0AAPtLwBWgDDUAWI1DJBTxJBTyJBTz+sBoHeAcJQDsFPAg0f0A +APtOwBWgDDUAWI062jD+QAgVoAy1AP4vhB2gDSUA7iE3INn9AADuFX0l2QUAAFg4tsAg0Q8AiS4J +mRGp2YmXiZ4okDuxiCiUOy+wX7H/77RfKVAEgABb/nfAINEPiScqmRTIoISZiUEowkT6QGgdoA0F +APqAaB3nyQEAC4AAwCDRDy8dAei4kBfZoQAAlLCUsZSylLOUtJS1lLaUtygWWokg6MJEKVAEgAD1 +74Yd4A4lAOT0eyzOAoAA7pkCCmgEgADpFlsvYASAAAuAAMAg0Q8rPEhYjQi1GSuQAeyQACDQ1QAA +LKQAK6QBKZAC+UBGHe/49gBsEAgtIScrIBYcuCqIJ4coKiB65SAHKvAEgACGdwqvCYiO6BYFL/8C +gACvzIZuLMJ//CDmFaD49QD5ZIYNoVUBAPwgxhXnzgEA/Z/AFaANFQAM3DlbVKWMF+0SBiUWuYAA +FLelDFkR9KARKhIAnQCkmS6SntMPDwIA98AVe1IAnQAjkp1kMjcatyfqAAUJyASAAAkCYQkCYQkC +YQkCYQkCYQkCYSohB/tvLAXinEEA/SAAFLaMAQD5BgAMeqoBAP9AABUwnDkA66oCDM1CgAD6YAYV +ra0dAOu3ix1VAoAACpkCCYgCiiD6YEYV4EyFAJwz/UAAFTAMZQAMqgKaMf5PUBXgDgUA6rgzHs0C +gAD+YUQdoD1FAO01Cy/8AoAACP8CGLc0CpkCmTbo/wIBWbkAAO82BCHQgQAAWIyx6jwmIVmhAAD6 +IIYV4AxlAFiMrB62chm4Ifhlph3gHwUA/mXGHeALdQD+ZuYdoIiVAPhlhh2gCiUA+mcGHaANFQD8 +ZmYd4Aw1APxmJh2gjQUA+mamHeAMBQD6ZyYdoAsFAOs0NCPZYQAA7DQwIdDpAAD8ZsYd4AxlAFiM +kisSBPpoQBWgD7UA/mgGHeAOVQD+aCYdoAxlAFiMiyo8SfpJABXgDDUAWIyH+mmAFaAHZQD6SAAV +4AyFAFiMgo8VLvAgKPAh6fAiL3YCgAAI7gLo8CMvdgKAAAnuAgjuEQjuArHu/+RmHajuHQD/5EYd +qO4dAP/kJh2o7h0ALvQgjWCMYS3cOO1mACZgBQAAnGGKJwxbEfVgAEW/yQUA57adJVCBAAD5QAQE +8AsFAOulBCTJAQAAmaAppgErIBYoCv/5YASkIgCdAPpPUBWgPEUAW1QDwCDRDxu28dMPirj3QAWI +kgCdAAxZEaSZL5Ke9+AGO1IAnQAjkp3kML5lc/0AAJ64ZT3HjyJk8FEft8aJJ/5ACBWgCDUAmBL+ +IAYV780FAPskABWgDxUA7a0BD3YCgAAP7gLuFgEm6QEAAO2WCSjYBIAA/SEGFeAIBQD5IoQdoAwV +AFt3yMAg0Q8AK1wY6iQACWAEgABbeydj/5wAAAAAAP/1UA2gAwUAiSJln4orIFPaIOu8EilgBIAA +W3seY/93nRb8IOYVoAoFAFiO2Ru2voq4jBeNFvlf+ciSAJ0A//04DaADBQDAMMDqDq40/2EGFa/8 +/gAAAABsEDgoIAX7bnQFoCnlAPkAJv1sCwUAKhZl6xYAIMAhAAD6AAoVoBlVAG2aAggAiuu3ghDg +hQAALBZc+iBGFeAItQD+QAgV4AQFAPQjZh2j+fUA+CGEHeAKFQDqFCAhUSEAAOoWZiDQ8QAA6hZd +L/4CgAAI/wIvFgMtIEkuIEguxAAtxAErIEorxAIkFDkkFDr0J2YdoAk1AOkUOCFZQQAAKxZeKBAA +LRAC7xABIPCVAAAv5AEt5AL5wAYdoBwFAFiL7xO2gxa2jBe3ZRi2mSUgQSogQBu3QOsWZyDJMQAA +KRZfKpQAJZQBLyBCLiBDLpQD75QCIPFRAAAuFmEsIEUtIEQtlAQslAUlIEcqIEYqlAYllActIDkv +IDgv5AAt5AEsIDoqIDsq5APs5AIg0fEAACoWYyUgPSkgPCnkBCXkBS0gPy8gPi/kBi3kBykgYSwg +YCykACmkASUgYi8gYy+kA+WkAiF44QAA7xZiISkBAAAlFmAuIGQtIGUtpAXupAQhaYEAAC0WZCkg +ZywgZiykBvlA5h3kHgUALhVBKIKsJBRcJBRs9DGGHaApBQApFD0pFDyJIIwn/iQkHaAKFQAqFUQH +mQL9gcgVoPX1ACUVQvZzphWgDVUA7BZaKVAEgAD4c4YV4AxFAAuAACsynRy27/grSBWoux0A+qAY +fmIAnQAvgDopgDsI/xEJ/wKx//8HZh3o/x0AL4Q6KdoAKRYsKRJlKBx/KIw5+AAKFeAZVQBtmgII +AIorEmYYtwIoFi6NIPQ5Zh2gDxUA/joGHeP+9QD+LIQdoAw1AP2gABawDrUA7t0CANH9AADtFi8l +UUkAAFiLgiQU6SQU6iQU6xi2LPov4BWgDDUA/D3mHaBrJQDrFOglYMUAACnAAivAAeiCrCVRWQAA +K6QBKaQCLMAALKQAiSCMJysSZweZAozO9nOmFaANVQDsFlspUASAAPhzhhXgDEUAC4AALTKdHraz +LxJb+W1uBajdHQD8oBQmYgCdAC7wOijwOwjuEQjuArHu/+dmHajuHQAu9DooEmUvqgD+IAYV4BlV +AOgAFQDAIQAAbZoCCACKKhJcKRJmGLbCmBKNIPQjZh2gDxUA/iQGHeP+9QAuFQz9oAAWsA61AA7d +Ap0TLJAAK5ABK6QBLKQAKxJeKZACKaQCJBQ5JBQ6JBQ7+iuoFaAINQAoFDgpEAIuEAHvEAAg6JUA +AC/UAC7UAfmgRh3gHAUAWIs4LhJgLRJfK+ABLOAALNQAK9QBKeADKuACKtQCKdQDL+AFKOAEKNQE +L9QFLOAHLuAGLtQGLNQHLRJiLBJhKtABK9AAK8QAKsQBKNADKdACKcQCKMQDLtAFL9AEL8QELsQF +K9AHLdAGLcQGK8QHLBJkKxJjKcABKsAAKrQAKbQBL8ADKMACKLQCL7QDGLXCLcAFLsAELrQELbQF +KsAHLMAGLLQGKrQH+RWIFaQZBQApFUEpFSEkFFz0LYYdoCsFACsUPCsUPSQUjCsSZ4Qn+EAIFeAK +FQAqFUSETiY2nfQoRB3gDVUA9yYADPAMRQDpNpwpUASAAAuAAC0ynRm2Sv9s4gXo3R0A/KAJeOIA +nQAoMqYTtj8jMn8JiAEJiBGoMxi2ao48CO4BD+4C7jYMKYlOAADCjOgkBSlQBIAAWw5+G7ZjHLSt +7bZiGVAEgABbDpraIFsOffpAaB2gCwUA/AACHaANBQBb/d7AINEPAAAAABu2LSoypinCfwuqAey2 +Ux1WQoAAqpmKnBu2UykWWAyqAQuqAuqWDCTnMYAAKhJY2xD7SYAVoAw1AFiKzeoSWCDYIQAA/AFi +HaANJQBYNk0sElgtwAX9hgYd4DsVAPuAph3v8rYAAAAvMqYu4n8I/wHptjof/kKAAK/uj+wYtjsu +FlkJ/wEI/wLv5gwna6GAACoSWfov4BXgDDUA67wxJVExAABYirMqEln6L+AV4Ay1APtnIBXgDSUA +WDYyLRJZw8j9oKYdr/TuAC5AOi9AOwjuEQ/uArHu/odmHajuHQD+h0Ydr/t+ACo8TPogaB3gDDUA +WIqf6xwIKdAEgAD8AWIdoA0lAFg2HygwBfhmBh2gTxUA/mCmHe/6rgAAbBAKKyAWJiAHhycqIFMs +IRnktb0aaASAAJwZnRgKqAnncg4sRwKAAKhE9I/oFaD49QD5Y6YNoWYBAAUMR/2fwBWgDxUADPw5 +W1I97BIJJRnJgAATtT4MaRH0wA+yEgCdAAOZCC2SnvegGKpSAJ0AJZKdZFIKGrTA6gAFCsgEgAAJ +AmEJAmEJAmEJAmEtIQcetTENDUrptTAe7wKAAP+mAA6y9EEA7VYAL/4CgAD6QAgV5uQBAP/GAA9w +OgUA+qBmFaANRQDpVgIt3gKAAA27AptR/EpwFeAIBQAoVQqYWJhZmFqYW5hcmF34ocYVoPQ5APih +5hWtjB0A5f8RDEUCgAAI/wLv7gIO7AKAAA7dAv9rjAXgKwUA7LTMHnUCgAArVQsP7gLs3AIC0IEA +AOxWBCFZAQAA/qDGFaAMZQBYikXqXCYhIWEAAPqAaB3gDGUAWIpAG7W2/2gKBeCJlQApVCz+puYd +4BgFAPilxh2gDCUALFQ17FQ4ItDpAAD8pyYdoA4VAPqlph3gDTUA7VQxKlgEgAD+pmYdoA0FAPym +Bh3gjgUA/qbGHaAMBQD8poYdoAxlAFiKJ49zjHIu/AH/wPIN4ApFACzMAYtxjXCec+x2AiXYBQAA +63YBJuCRAACccI0Y6CIHK08CgACjmfszphWgDAUA6owgLtgEgABbcgqIJ/8EABXvyQUA+eAEB/AJ +BQDphRQn+QEAAJ+Jn4grIBYuCv9+sQr6SnAVoCwFAFtRryogN/tf4BWg++UA+kbmHaeqAQD7QAR8 +YgCdAMAg0Q8AAB60lYro90AKIJIAnQAMaRGjmSuSnvdgCrJSAJ0AJZKd5FFNZVv9AACb6GVd9Iwi +ZMDkGbVqjif4QAgVoAolAJoW+CCGFe/PBQD7xAAVoAkVAO+vAQxGAoAACYgC6BYFJ/kBAADv5gkg +2EEAAP/BBhXgDQUA/cKEHeAMFQBbdW3AINEPAAActV4uIAf8QLAV4ApVAPhACBWgOyUA6BYAKXgE +gABYjv+KJyv6wPNByBXgLGUA7CQFJUiBAAD7IAQE8AsFAOulFCTJAQAAmanppggpUASAAFsNYCwx +EYIqsczsNREheLmAAPAAaA2gI9UAAAAAAAAA+kBoHaALFQBYOMiCKWQu9C0gBXPZ6YIpZS/0Y/7m +AAAAACtsGOokAAlgBIAAW3inY/8JAAAAAAD/87gNoAUFAI4iZe73KyBT2iDrvBIpYASAAFt4nmP+ +5PwhJhWgCgUAWIxZHrQ/iuiMGflf9VCSAJ0A//r8DaAFBQDAUMDaDa00/cEGFe/6wgAAAABsEAoo +IAUpCiX5ABIlYgCdAC0hGSsgFiUgByogUyYiBxe0xQqoCeZiDixHAoAACHcI9u/oFeD89QD9YuYN +oVUBAPwhBhXgDBUAW1FI7RIIJRnhgAATtEkMWRH0oA/KEgCdAKOZLpKe98AYylIAnQAkkp1kQgsa +s8vqAAUKSASAAAkCYQkCYQkCYQkCYSwhBx60PAwMSum0Ox5nAoAA/4YADjL3QQDsRgAv/gKAAPpA +CBXm5wEA/8YAD3A6BQD6gGYVoAxFAOlGAi3eAoAADLsCm0H8SnAVoAgFAChFCphImEmYSphL+IGG +FaD3OQDoRg0v/UKAAPiBxhWgKwUA+IHmFa2NHQDrRQssRQKAAAj/Ag/uAu+00B5kAoAADswC7bPV +HvUCgAAP7gLuRgYiUIEAAO3MAgFZAQAA/ICGFaAMZQBYiU/qTCYhOWEAAPrgaB3gDGUAWIlKHrMQ +GbS/+IWmHeAfBQAvRC7+huYdoIiVAPiFhh2gCyUAK0Q1K0Q4+ocmHeAMNQD8hiYdoA0VAO1EMyJQ +6QAA/AACHaCNBQD8hgYdoAxlAPyGxh3gCwUA60Q0K9gEgABYiTKOY4tisez/gNINoApFALG7iWCN +YZxj62YCJMiRAADpZgAm2AUAAJth/kDoFeALBQD+oAAUMAwFAPMAAERwDQUA6oadJ9CBAABbcRSI +J/8EABXvyQUA+eAEB/AJBQDphRQn+QEAAJ+Jn4grIBYuCv9+sQr6SnAVoCwFAFtQuSogN/tf4BWg +++UA+kbmHaeqAQD7QAR8YgCdAMAg0Q8AABuzn4q490AKIJIAnQAMWRGjmSySnveACrJSAJ0AJJKd +ZEFNsKycuGVN840iZNDnGrR1+EAIFe/IBQD+QOgV4AslAPogxhXgCxUA6hYELM4CgADrmQIH0IEA +AAioAfggphXgDgUA7vUUJEEBAAD54SYVoAwVAOj2CCDYQQAAW3R2wCDRDwActGguIAf8QLAV4ApV +APhACBWgOyUA6BYAKXgEgABYjgmKJyv6wPNByBXgLGUA7CQFJUiBAAD7IAQE8AsFAOulFCTJAQAA +manppggpUASAAFsMaiwxEYIqsczsNREheLmAAPAAaA2gI9UAAAAAAAAA+kBoHaALFQBYN9KCKWQu +9C0gBXPZ6YIpZS/0Y/7mAAAAACtcGOokAAlgBIAAW3exY/8GAAAAAAD/86gNoAQFAI4iZe70KyBT +2iDrvBIpYASAAFt3qGP+4fwhBhXgCgUAWItjG7NJiriNGPlf9VCSAJ0A//rwDaAEBQDAQMDKDKw0 +/WEGFa/6tgAAAABsEAYoIAUrIAf6YGgdp3UBAPKAaB3gGUUA+QAG/WG7AQAVs1/44AchUgCdAOSi +Bi1oBIAA7wIADbAEgAD1YARiEgCdAAy6EaWqLKKe94AHpNIAnQAqop1koLn6QAgV4AwVAFskphuz +rS4hCR2zUCwgBy8hIighJPloGAXgzBEA7f8CDmKCgAAMiAIJiAKYoIwgn6L/QGYVoA0lAOSmBS5m +AoAADcwCnKHrABUFSGEAAAkAigxuEfXAAEdwDaUA7eadK5WgAADAINEPAAAcswyJyGqRdwxqEaWq +L6Ke9+AExNIAnQAqop3koI9k8/0AAP+BBhWv/ZIAAAAAAADqJAAK2ASAAFt24tKg0Q8A9UBoFa/8 +kgCPIusWACeFKYAA7RYBI5WVAADAINEPiif6YGgd4AwFAOqsICnoBIAAW3BP0qDRDwD//DwNoAoF +AJ0R+iAGFeAKBQBYiwMcsuiJyIsQ7RIBKAQKgAD5P/tAkgCdAP/7jA2gCgUAwKDA6g6eNP+BBhWv ++1IAiifAsPtEABWgDBUAW3PRHrNjnqCNIBuzw4wR/aAAFrAOFQAO3QKdoYzGnKP7QEYV4AIFANEP +AACLEO0WASlQBIAA67wYKWAEgABbdyX8ICgV7/0aAGwQBBSzT/tk7gWgCRUA6iYAKcYCgAAJiALo +JgEhGCEAAOQAFQEQQQAAAwCK0Q8AAGwQBP1nUAXgCyUAKzQAKiAVHrOlGLJr6EkRDVECgAD7JgAN +MAtVAAuqApox6AAFAaBBAAAEAmEEAmEEAmEEAmEoIAf/ZzQF4YgBAOBVEQxEgoAACFUClTaFIJ4/ +nz78YgYV4AQFAPRhBhWgCzUA5DxQKubCgADsNgcjAdmAAPxCsBXgDhUALjRYLjRQ5zRZLukCgAAN +nQIO3QItNhUM6jDsRQUq1gKAAAuqAupGAyGRgQAA0Q/SQNEPAAAAbBAE8kBIFe/0FQAEMwGTItEP +AABsEATaIPxgaB2gCxUAWIvb0qDRD2wQCIdGiEcvQQspQQr0gQgV7IA9APxgaB2k/x0A+AIABvBp +cQD4AwAHcDXxAPQfAAL5uB0A6HgYDdwCgADvVRAJnAKAAOUzAg93woAA7t0CCzRCgAD0gIgV4ekB +AOYzAg93goAA+iDGFeFpYQD62AATMAsVAPggphWgiXkA6/83DEVCgADoZgIP/wKAAP/GAA9wiVkA +5jMCDEaCgAD4hgADcZkhAO7dAgzOAoAA7RYHKzfCgAD4xgALMIV5AOYzAgxDwoAA+QYADHFlYQD1 +YAAE8FVxAOUzAgswgoAA5bGgHMuCgAAJZgL4xgALNnfJAAdmAhezNgUzAuMWAylQBIAA9sYAC3AO +BQDmFgQo6ASAAFiKlNKg0Q9sEATaIPxgaB2gCwUAWIuQ0qDRD2wQCItHh0bjQgQp4ASAAOYhBylQ +BIAA+ICoFauAPQD3FwAE8VOhAPdAAAMw45EA8cgAFzL4uQDk/xALNEKAAOt3GAqswoAA9qYACrm7 +HQDpFgUt24KAAPngAASwaJkA52IRCzZCgADnFgYsz4KAAPRGAAl0eNEA65kCC74CgADyGQAF8lih +APdgABWwiPkA52YCDETCgADyuAASsXOBAOX/Agu8goAA+OYAC7CDwQD3CAAUMFOxAPsGAAxws7kA +71UQDduCgAD6pgAK8LPRAPimAAqwM5kA6TMCDdiCgAAL7gKTFwdVAhOy7wZVAg/uAvQgRhXgH4UA +D+4C7hYDKOgEgADyRgAJcAsFAPIghhWgDgUAWIpJ0qDRDwAAbBAEFLLiDwIADwIAKkKA2yBbbyzo +oRxtGASAAOpCfylYBIAA/AACHaANFQBbdwrSMNEPAOpCfyFYBQAA/AACHaANBQBbdwTqQoApWASA +APwAAh2gDRUAW3cAY/++AAAAbBAE82WWBeAIBQAessoo5sAdssko1sAcsskoxsAbssgotsAZssgq +CgD5OAYVoAnFAG2aEYkr46sKARPxAADptsAlUAUAABiynCg2vcD1Lza8WHvq4qQADQDOAAAoMuXH +L/8B4AfTmEEAaJMHIjLo0Q/RDwDRDwAAbBAEErKsIiJ/IiEC0Q8AAGwQCCQVBPllXAXgDSUAnRGZ +ECwgDCsgDQjMEQy7AusVBSlQBIAA6CEJKZRCgAACUgKZEJ0RGbFdJBUEKBYD6QAFAMBBAAAIAmHy +IIYVoAwFAOYWBSjYBIAAWE9z0Q8AAGwQCPtlMAXgDSUAnRGbEI8yDw9fLxUELiAMLCANCO4RDswC +LBUFKSEJmxDtFgEpUASAAOkWAyDAQQAA8ghoHeAMBQDoDAAI2ASAAFhPX9EPbBAEGbKFKHEOpDym +WqMjqsykOywlA6SiKrUKeYEFIjUJ0Q8ALSzYLTUK0Q9sEAbbMOxEAAlQBIAAW3JzL6ARLqEJKKAV +J6AU9kCkFa/NBQANLQHtFgElWIEAAO1tCA3gBIAA6HcIBukBAAD9YAVq4gCdACPMHOWhDCnYBIAA +/GAFEuIAnQDvwwgNoASAAO7/CAGYSQAA7PgICdgEgADvAgAEQFEAAPxgBBLiAJ0A6BYALZgEgADt +i3p8WASAAKV4KUEAp/2tXS3FAx2yUyi1AK6LfZFmKzUALqAVjxEtoBHroBQnAVGAAC6hCSYhBa7d +rbvvbwgF2EkAAOy7CAf5AQAA77tBfRAEgACbo9EPwPDvpgMtEASAANEPAAD3bwAOP/1OAPZvAA2/ +/XoA9m8ADb/9+gD3DwANv/4aAC282PxgJB3v/lYABr4M7qYDLRAEgADRD2wQCByyMY0gLsKeKTIA +LMKm7t0MCbAEgADlFgAu7oKAAP2AAEZwBRUA6swgJKlsgAAtMAnpPBAtWASAAPwHAAdw3TEACSCG +CwJjCQCGCwJhKMABKQrgCYgBKMQBLzAI+eYAD7C59QDp/wEPRoKAAPnmAA+w2fUA6f8BDsbCgAAI +/wIvxAEpMgDnsDgUpVCAAC5iASjAAQfuAfgHAAe0mAEA+MEGHeDYMQDp3REP+EKAAP/GAA9wiCkA +7mYBLEaCgADo3QIDWEEAAO1kCS1IBIAACWCGCwJnCUCGCwJlKWIAe5ZkLsABiGErCoD+BgAGsJ4p +APMADEgQ+PkAHrCr7gAFDXAEgAAOAmEOAmHAgCjEAS4gVPHDAA3gBAUAnBIesUjmFgMum8KAAO2x +6RzEAoAACDMCkxHzY8oF4ANSAIYT/CBIFaAFFQApwADTDw8CAP8hgA4QAhUAKsABeK8BwCDjEgAu +UASAAFswrR6wBgpfFA7/EQ/uDP/C4CWkqgEA7eJ/LQEKgAD8oAEEX/n1AOmIAwtYBIAA6N0BCXgK +gAD/pgAO8AwFAO3mfynQBIAAWIrMwCDRD6tmCqkCB2wCLNazKNK0JRIBDwIAA4gB+KYACrAMBQD1 +toYV4BgFAG2KHfHlgA3gBQUAJZEADlUC7cgKBMgJAADlhrUmYAUAACbWsykgVLFE+J/5ouIAnQAp +IA3KSywgVcCBCYk5rEwJyQwsIAwIzBEMmQILmQL/MMAGEmlBAP/+AA2maQEAY/+uAGSfzywgDMqe +GLFkFrGfKIB9JmJY4hYEJJP9AAAIIiisaaKZghQcsVsMmQopkoD//rgNppkBAAAA+YBoHe//pgAO +CEYLiAL5gCYdr/oeAAAAbBAEGrGQiyAsonuJMCqigwy7DP1wABWwBBUA66oIBKjYgAAtoADsoAEh +yEEAAOkHHg1YBIAACwJjCQCGCwJhKzAI/UAmHaDuBQAO3gEOuwIrpACJMHmWQSigABmvn48xCAtE ++mEGHeCIOQDp/wEMQEKAAOj/Ag1IBIAA7zYBIdhBAAAJYIYLAmcJQIYLAmX4YAgV4AsFACs1CP8l +gALQAhUAjDEdsB3mwH1tSASAACugAQ0AhwkCYQkCYSukAflAEBXgAC4AAAAAACmgAHifBy6gAXjv +AcAgWzAtGK+GClkUDpkRCYgM+QLgJaTaAQDvgn8ugQqAAPyAAQVf/PUA7KoDCdgEgADq/wEJSAqA +APnmAA/wDAUA74Z/KtAEgABYikzAINEPAAApoAD4wAAE8IsFAAuZAvlABh3v/k4AAABsEATpIgAp +IASAAJORiCGTgAQAiAMAipIgkiHRDwAAAGwQBCkgDSogIvlf7AWgCxUA6bk5DVYCgAAKkgICA0cI +MwooMo4CihQLgAAKCUFokQJpkxsoMpTaIAuAANug+kBoHaAMBQBYiirRDwAAAAAA//+oDaALBQBs +EATJNvRgBUiSAJ0AyTr0YAVokgCdAMAg0Q8AACghEw8CAOSECAn/RgAAE7AIZXCmc2EzjC/6QGgd +oAsFAPzAAEYwDQUAWIjjZqEXHLERLMF/+kBoHaALJQD1gABGMA0FAFiI3Gag73NRL4wv+kBoHaAL +BQDTD/ygAEYwDQUAWIjVZqDa+kBoHaALJQD8gGgdoA0FAFiIz2agvOokAApgBIAA+gAiHeANBQBY +iMrSoNEPjSz1oABCP/1WAAAAAAD6QGgdoAsVAOxEAAvoBIAAWIjA0qDRDwD6QGgdoAsVAPyAaB2g +DRUAWIi6ZqBpc1Eu+kBoHaALJQD8gGgdoA0VAFiItGagUCwiD/pAaB2gCwUA/KAARjANFQBYiK5m +oDtzYTQcsNsswX/6QGgdoAslAPWAAEYwDRUAWIimZqAYjC/6QGgdoAsFAPzAAEYwDRUAWIig0qDR +D9Kg0Q/SoNEP0qDRD9Kg0Q9sECKIIoc05K+3GjAEgACUFJQV+wBiyJJ36QDaIPYlhhWgC3UAWIf/ +90BoHa/4RQD5QGZkIgCdAO2wkR0E+gAAiTAqMQUvMQbmMQckrCSAAIsxZrH7LiAN0w9k4KwqFjZ0 +8QJk4UefFC8WNXRhAmThUZYVJhY0ZHCw9OAKsJIAnQDAYAb8UPoAIh3gCgUADLo4ZKBGijAPAgB6 +piRkckj04BKokgCdABywkPLpcA3gCxUA9OBMYJIAnQDAYGZgG4owDaQBfaAJjjHzwAqwUgCdAMhG +iTEJ31Jk8TTaIPwfoh2gCwUAWIkgKPqNeKECBqY42iDsEiwp2ASAAO1UAAtwBIAAWHag0qDRD2Ry +GvTgESiSAJ0AGa9zKRY29f/6JSIAnQBj/z8AAAAAJiESKhI290BgeqIAnQCKKisSNltsuh2wT/tA +YOgSAJ0AKxI1dLEahi73YGOqogCdACoiEFtssh2wRvtAZEASAJ0ALhI09d/4dCIAnQCGLvfAZLqi +AJ0A6iIQL1gEgABbbKcdsDz7QGUoEgCdACgSNfUAZfQiAJ0AGbBiKZB9ZZ7VYAzYii8K+gwqFjWa +FPTf9ZUiAJ0AY/6tiy8LawwrFjT6IKYV7/qeAIYrLBI294BdSqIAnQDqIg0uWASAAFtsjx2wJPtA +XbASAJ0ALhI19cBY5SIAnQAvEjT1//PMIgCdAGALCQDzIAeI0gCdAPE/9fkSAJ0AYAyLLBI27RI1 +KVAEgADuEjQr2ASAAFhqmOaunm0wBIAAGLAOhDD4gAQCP/oeAAAAAC4xE/pjZBXgCgUA9iIAFaAM +BQDuxjgAyFEAAOupOAgECoAA+uBKUBIAnQD04GKAkgCdAB+vGC8WNsBgZm5L+uBMKBIAnQD04E0Q +kgCdAC4gDfvATAASAJ0AKhI2iBQoFjV0gQf7wEyIEgCdACYSNYkVKRY0dJEH+8BMQBIAnQApEjQs +NQQqNQUpNQcmNQb/9sQNoAYFAAAoEjYmIRP4wABDP/bWAAAAKBI2hiz4wABDP/aaACwSNi0SNe4S +NCvYBIAA+kBoHaAPFQBb/t/3QGgdr/bmAAAAKSETCakM+CbGFe/3pgCLLAurDPomxhXv93IAAAAp +MQr4YQgVodlhAPwlphXg6XkA5e4RDu3CgAAO3QKOMQjqUPgaAAew7uEA4v8RD3TCgAD/xgAPcPj5 +AOCqEQ/7woAA/0YADXD5cQAB/xEPqgIOqgKPNA2qAi0gDQlJQf0gABSwiNkA/W0ADHDveQD32AAX +Md9hAPnGAA97nwEA4t0QDMuCgAAJ3QIpMQr/pgAOtOkxAP/YABcw/3EA/8YAD3D5WQDpiBEP/oKA +AAj/Ag+qAv9GAA0w6RkA/9gAFzCJEQAOiAIuMQv+YOgV5O4dAPvAQAdxmQEA7pkRD3cCgAAOmQIu +MgYJiAL6IWYVqZ8dAOgWDyzMAoAA+CHGFeyAPQD/ywAPdo7JAO4WDSlQBIAA+aYADrAOBQDs3AIA +6IEAAOwWDCtgBIAAWIcEHa+C+0BTeFIAnQCONOYWMycM2IAAGa6IKBItLyAHqYkpkIAmFjP2RcQd +oPu1AOv/AQzPgoAA+eYAD/D5xQAJ/wEI/wIvJAcrEjXWoPVgFZQiAJ0ALzEKDw9B9+BREVIAnQAp +EjWIL4o4wLPsEjMg6QEAAPkAAERzqqEA+iLmFaAOBQDoFjApUASAAFiG4Oar120wBIAALBIzhjiI +MfhhRBXgDQUALRYf+BwABDDmYQD4hgAH8JlZAOmZEQ/+AoAA+eYAD/CWaQDi7hEMzEKAAOnuAgxE +woAA+cYADzCGcQD/xgAPcPZ5AOCIEQ/7woAA+eYAD7CmCQD4JggVoJYRAO6qEAzLQoAA+yYADLFm +4QDsZhAMUoKAAPrGAAs6iB0ACO4C/iOmFaALJQDpZgIA6YEAAOb/AglQBIAA/iPGFeAOBQBYhrLm +qx9tMASAAIY7KzESiDqKOPonAAdwD0UAD+4CH69WKhYuKBYxL/B8JhYy9iZoFaCaWQDtmRAPxUKA +AAmIAikgDfol5hXgylEA+kQABfCqAQDoZgIEgHmAABmt3PjGAAtwChUAKTETLSEHJBY36BIxLyEC +gADsMgEucEKAAOTuAg2hwoAABO4C+mFEFehIuQAkFiUkEjIBdAT1CwAMOUQdAO6ZEQojgoAABJkC +FK2RKBYm5O4CCybCgAD1xgAPNY8dAOqush0nAoAA+IYACjDM4QDvEi4vwUKAAOTuAg5kAoAA/iRm +FaG7YQDqiAIN3IKAAP4l6BWqrQEA+UgAFTDfMQD7BgAMMK9JAO/dEA1TAoAA/YYADnBPGQD4hgAK +cJ9BAPcoABSw3nkA6pkCDuzCgAD+BwAFcf8hAP1mAA303lEA6N0RD/zCgADo/wINU4KAAPsmAAyw +CCUA+IYACjCuGQD9JgAMsu4BAOwSMC1WQoAA7aoCD3XCgAAP7gIkFicLmQIkEjf/WlgF4AsFAOqZ +AgDp/QAA6RYiJugFAADv7gIJUASAAP4khhWgDgUAWIZGHa7E5qlrbTAEgAAoEjQPAgAPAgD1H8nc +IgCdAIk8HK7pJCIP7hIzKVAEgAD9h+QVoAs1APiAAEIzmaEA6RYXIOkBAAD/gABGMA4FAFiGMuap +H20wBIAAKDEKjDwtEjP4hgADMIhZAPwCAAUwvAkA/AwAB7CccQDgmREP/IKAAO67EA1TQoAA6YgR +CzYCgAD4xgALMIx5APtGAA1wzGkA6zIBLmRCgADs/wIMQ8KAAAmIAhyuxPhhCBXgDgUA/iPmFaC7 +4QDswT8t3MKAAAv/AvSQABWxmeEA5v8CDMsCgAD7JgAM+mQdAAb/Ai8WHf2AAEZwDgUA+yYADLAL +JQDpiAIJUASAAOgWHiDpgQAAWIYC5qhdbTAEgAArMRqKPBauqYk/iD4oFjEpFjIoEjMvYHwmYT/6 +JUYVoJpZAOsWKyzLQoAA6GYID8VCgAD5BgAMcMpRAPhBsBXh6zkA+kQABfCqAQD4xgALMAhFAOju +AgSAeYAAGa0p+MYAC3AKFQApMRstIQclFjjoEjEvKQKAAOwyAS5wQoAA5e4CDanCgAAF7gL6YUQV +6Fi5ACUWJSUSMgF0BPULAAx5VR0A7pkRCquCgAAFmQIVrN4oFibl7gILLsKAAPXGAA91jx0A6q3/ +HS8CgAD4pgAKsMzhAO8SKi/BQoAA5e4CDmQCgAD+JGYVobthAOqIAg3cgoAA/iVoFaqtAQD5SAAV +MN8xAPsGAAwwr0kA790QDVMCgAD9hgAOcF8ZAPimAArwn0EA9ygAFLDeeQDqmQIO7MKAAA27Av6K +AAawrzkA91AAFTH/IQDqmQIP/MKAAOj/Ag7uAoAA/gMABTAIJQD4pgAKsu4BAOyZAg1WQoAA7aoC +D3XCgAAP7gILmQIlFiflEjgqYASAAP9Y8gXgCwUA6pkCAOn9AADpFiIm6AUAAO/uAglQBIAA/iSG +FaAOBQBYhZMdrhH3QGgdr9oCAAAAJRY4hDiINiUgDfQbAASw9PkA9/gAF7Dk8QDluTkPdAKAAA/u +Ao8x9GDoFeyAPQD6YUQVoETRAPiQABIw/+EA+fgAF7nVHQD15gAPsEpxAOWFGAokQoAABO4CD+4C +LzEL5DIELM5CgADlFg0u7AKAAPwhxhXk/x0A++BAB/HaAQDu3REP/wKAAP+mAA7w+hkA//gAF7Ba +EQD+pgAK8fohAP3gABe2iMkA/KYACvDUeQDlFg8u68KAAP+mAA7xVGEA9WAAB7BEcQDiVRAP+4KA +AP6mAAr0+jEA7VUCD//CgAD15gAPsUphAPimAAqwilkA7FUCDEaCgAD0IYYV4Kp5AOmIAg1VQoAA +5RI4Kk3CgAAKmQLp7gIA6IEAAOjuAgtgBIAA7+4CCVAEgAD+IWYVoA4FAFiFQu2twR0B4gAAiDQP +AgAPAgBzhiwbrMcpIAcLSwgrsID2RcQdoPy1AOyZAQ3fgoAA+yYADPD7xQALmQEEmQIpJAf3QGgd +r9QCAAAAiiosoQLpFigmCSmAAFtmlh2tqioWKeoWNiMAqYAAKiIQLqECZOMpW2aPHa2kmmAvEij7 +/7SQEgCdACoiECihAmSDKFtmiCkSKB2tnPsgBhWv2eIAAAAuEjYsIRP/gABGP9n2AMt3+P+0CNIA +nQArEjaKLPtAAEV/2dIALhI2jCz/gABGP9lmAIYv+MAAQz/ZwgArEjSJL/sgAET/2doAKxI2KiET ++0AARX/ZCgAAiScPAgAsmRQUrXbkwGFk0IEAACuSCWSwVi2wAC4KKn7ZBS+yAnTxQfoAAh3gDCUA +W3DZGa2jHK0qnKCLIJSik6UmpBz1QMYV7/j1APlAhhXgDCUA6KQdLd4CgAAMuwLrpgEq0ASAAFiG +u8Ag0Q8AAPoAAh3gDCUAW22GY/+0AAD/WPoFr/ZFAP4mxhWv1kIA5hIsKVAEgAD8QGgdoBvFAFtr +W2P/WQAAABythi8SNS4gDS0gDPgmiBWgCiUA+CAGFaAbJQBYhw8drVH/zRANr+alABytfS8SNvxB +kBXgCiUA9iAGFaAbJQBYhwb9WpAF7/9uABytdi0gDP5BsBWgCiUA/ibIFeAbJQBYhv79Wn4F7/7q +ABytbi8SNvxBkBXgCiUA9iAGFaAbJQBYhvb9Wm4F7/5mAAAAHK1nLSAM/kGwFaAKJQD+JsgV4Bsl +AFiG7f1aXAXv/doAAAAAHK1fLxI1LiAN/EGQFeAKJQD2IAYVoBslAFiG4/1aSgXv/T4AHK1XLSAM +/kGwFaAKJQD+JqgV4BslAFiG2/1aOAXv/LoAAAAAHK1PLxI0LiAN/EGQFeAKJQD2IAYVoBslAFiG +0f1aJgXv/B4AHK1HLSAM/kGwFaAKJQD+JogV4BslAFiGyf1aFAXv+5oAAAAAHK0/LxI0LiAN/EGQ +FeAKJQD4IAYVoBslAFiGv/1aAgXv+v4AAAAAAAAAABytNS0gDP5BsBWgCiUA/iaIFeAbJQBYhrX9 +We4F7/peAAAAAAAAAAAsEjYtEjXuEjQr2ASAAPpAaB2gDwUAW/v090BoHa/IPgCKLSuhAmS+F1tl +0x2s6PomxhWvzqIAAAD3QGgdr8dCAAAAHK0b/EGQFeAKJQD+QbAVoBslAFiGmx2s3f/GtA2v5qUA +KxIpiir8AAIdoA0VAFtxJh2s1v/NiA2v9kUAyGuLYPwAAh2gDRUAW3EgKxIpiir8AAIdoA0VAFtx +HGP/0mwQIogihzAkFhoPAgD7AEKgl3fBAPpAaB2gC0UAWIQt90BoHa/8RQD9QEFkIgCdAOSsph0Y ++gAAKDIA0w/pMgIkLCiAACoyAWakJS4gDYouJxYW5JkBBx0JgADXkPrgQ7qiAJ0A6iIQK9gEgABb +aRr7QERgEgCdAMCg5qQADRauAACKMPFAFWqSAJ0AHayGizQpIA2GMi8hEy8WIwRkAfgkRhXrZqEA +D2wMCcY4/WAEBf/LAQCNNQ/IDOmMOAszAoAABkQClDIMuwKJNikWJ4w3mzT2QegVr+0BAP4kJhWv +iwEA+eAAR7eqwQD2wABDcBglAHihESgKIXihCykSIwRIWwiZCCkWICwWHf4jhhXgi8EA+CUmFaBL +uQD0JUYVoJvJAPglBhXkTdEA9CXGFaCbsQD4JWYV4I35APglphWgnZkA+CXmFeCLkQAoFjAYrDn4 +YCgV4EvRACQWMfkP5BWiTbkA9CZGFaCZ4QD4JYYV4BmFAPkkAB2iTaEA5BYbJUO5AAD+pAId5UwF +APniAA4wAEIAAAAAAPQjZhWlTAUADQ1S+AIiHeH7oQD5QBkMYEuZAPwmphWgGCUA+UAnNCIAnQDB +k/lAG0xiAJ0AwoH5QDpsIgCdAIoVixSJFikWJisWJCoWJYsXihgpEicJeFgoFhEoEh0BdAQImRgp +FhL5WQoF6YgdAO7uEQxDgoAA+cYADzSMHQAJiAEpEiQOTgL+ImYVp5kBAOfeEQzNAoAACe4CKRIl ++fgAFrf4AQDl/xAMyYKAAAn/AikSHOwSGyzMQoAACf8C6xIyLc7CgAAP3QLu3QIOYcKAAPolCBWn +6gEA7xIwLdkCgAAMuwIsEjEtFhAtEibh/xAOYIKAAAz/AiwSL+v/Ag93AoAA+iXIFefdAQDp/wIO +70KAAP/GAA9y+CkAD90CDt0C7hIsLmZCgADtFg8t3gKAAAy7Ai0SKywSKQyqEODuEQ7rwoAA7t0C +DmNCgAAMqgIuEhQsEi0ODkfjzBEPdIKAAA7MAi4SKg7uEP9GAA0wDgUA7aoCAOjBAADsqgILYASA +APtGAA1wCwUA6hYOKVAEgABYg4HWoGZgH4owGav9CasBeaAKKjIB80AHGFIAnQDItokxCdtSZLC0 +2iD8H6IdoAsFAFiErvdX1AXvjNUAfKECBqY4jCcPAgAtyRTpIgImWIEAAOrCCSaDGYAAZJDR8UWw +DeAvpQAuoAB/6QsYq9osogJ4wXp3wT3asPwAQh2gCwUAW29CLBIaGavWHauSnaCLIJeik6WVpiak +HZmkLKQc/WAAFbAMJQAMuwLrpgEq0ASAAFiFJcAg0Q9kkHLasPwAQh2gCwUAW2vwY/+3hy/3LwAL +//F+AAAAAAAAAPMgKxDSAJ0A8T/5+RIAnQBgBW93yZFj/78AAAAAAAAA7BIWKVAEgAD64Ggd4A0V +AFhmh/dAaB2v+EUA+UAg9CIAnQBmrwQcq7eLMP1gBAW/+8oA2lDrNAALYASAAFiE3togWH7Y0qDR +DyoiEC2hAmTVLScWFltkloYvLhIW16D6wABDMBslAPvACwxiAJ0AwZP5wAq8YgCdAMBgZW6sHKvc +jS+KMi4gDafd7TYDK9gEgAAO2zgMqgH7RgANcAYFAPpgRhWv7toAKCBgCwlRAJAECAgb8QAbh9IA +nQApFhQmJQkaqpv4JAgVoAsFACskFCglCPpCph3gCBUAKBYkKyANqpoqoIALizkrFibrIgAtV4KA +AAqaAvpA5h2gChUAKhYl//LwDaAKFQAZq0ApkkAoIGALClHpaQoNAgqAAPkgCBXgiJ0A8QAX99IA +nQAqFhQpFh8sFjUvFjYtFjcrIAwjFjgoIQcTqnomlQkolQf7IYYd7/j1APklhh2gC4UAK5QEiJej +oysSICuVCPJwEBXgCwUAK5QVK5QUK5QG65QFKZ+CgAADowIjlAcjEiIjlA0jEjgoiRQoFh6bkouQ +6xY0LB9GAADAgfgkhhWgCoUA+yCmHaAIBQD4JMYVoAoVACoWJf/v7A2gChUAACoiEyuhAmS0Iltk +Ni4gDR2p0RmrCywiEivSfymSaOrKCA1ABIAAqrrsEhYtVkKAAKqa+UFGFaAfJQD/gA40YgCdAOoW +MycPCYAAHqr9jSAu4mEO3QweqY4NXxQO/xEP7gwu7Qf/wugVpI0BAPsABADQDxUA7KttH/gKgAD/ +wAQHcAoVAP9NAA8wCwUA/iMGFaAKVQBYhOYpEjMvEhgvlFcYqugogkAIaAr5AAYV7/gCABmq44s4 +LxY2KZJA/CbmFeu7gQArFhkJaQrpkgApUASAAPgj5hXgDBUAWHKlLRI3LxI27BI1JQupgACONCsg +YA4OUe4WFC8CCoAA/0TQFaC7nQDxYAqv0gCdACghBykSHyQWOSUWOiQgDPRBsBXgCwUAK5QVK5QU +m5IrlAYllA0rlAUlEhkolQcklAz1VBQFoIU5APoiiBXipUEA6KoRDEVCgAD7BgAMNlUBAAhVAhqr +MygSIaS0JECAKqCAJZUX5RI6KieCgAD1ZgANtqodAAqIDCQSHCuUB/UhBB2gC4UAK5QEJBI5izeK +NuaVCSxGgoAAC4sIeLsCKqwBKRIfmpibmSggDf8lhh2gCxUACLg5KBYmiJcrIHYrlBYoiRSLkCsW +NOgWFywTfgAALhIfwKgq5AX+YKgVoAkFAPgkhhXgCBUA+CSmFaAKFQD/59gNr+4BAOoWMycA+YAA +KdKBH6qMiCAv8mkJiAwKiBGo//9BxhXv+H4AHqsCLSAMLuCAANAE/l8ADzAKVQD9VfwFoO4BAP4i +phWgCwUAWIR5KRIzLxIV/yrmHe/5IgD/63ANr+alANog/EBoHaAbxQBbaLOMJyjJFOSA8mZQgQAA +i8lksOgpsADCynyZCB6qoC2yAn7RRPoAAh3gDCUAW24JH6rmKxIaHKqZHapZnaCIIJyik6UrpByV +pv9AhhXv+fUAKaQd/QAAFDAJJQAJiALopgEq0ASAAFiD6sAg0Q8AAAAAAAAA/VWsBaAbJQDtIAwr ++ASAAPogBhWgCiUAWIRM/94MDa/qpQAAAAAAAP1VmgWgCiUA/EGQFeAbJQDuIA0r+ASAAFiEQmP/ +1AAAKCBgCwlRAJAE+CKGFeCInQDxH/jf0gCdAMCA+CSmFaALFQD6JIYV4AoFAPokxhWgCwUA/+JM +DaAKBQAAAAAAAPoAAh3gDCUAW2qSY/8kjC/6QGgdoAsFAPeAAEZwDRUAWIJm90BoHa/nMgCML/pA +aB2gCwUA94AARnANBQBYgl/3QGgdr+a+ANbA9iLGFe/r1gAcqqEpEh7+QbAVoApVAPxBkBXgCAUA ++CAmFaAbJQDpFgAr+ASAAFiEEikSHy0SN4iXLBI1/mCoFaAPBQD/AoQd78sFAO8SNiRQgQAAC6oB +6xI0JVEBAAD7ASYVr+4BAPsBBhWv7uYAAAAAAAAAAOoiECvYBIAA/AACHaANFQBbbo7/6bANr/ZF +AByqgCkSF/5BsBWgClUA/EGQFeAIBQD4ICYVoBslAOkWACv4BIAAWIPwLhIfLRI3LxI2jucsEjUr +EjT7xAAVr8gFAPlABAUwCAUA6OUUJVEBAACa6fvBBhWv9PYAAGwQBh2qTQ0tCiTShAQESglEEfSA +CteSAJ0AGqnl+AACHeAMBQD7UBAVoA5FAG3qEQCQBAoLG++3BnTIBQAAsczTDxaqWRWqWfeACOCS +AJ0AH6pY/gACHaAKBQD79CgV4AiFANMPbYoQAKAECwkZCQlD6SEUdVARAADv/AQncAUAAP3a3g2g +CgUAZuC3GqiJAisKq2ssooQpsH4qoois7OOZHA5mQoAArKoqoTPAygyZLaWqCpw3DEwMZsDALLCA ++yBABT+ZxQAMmR0KSgypqWaQqi+wfw8/HMCKCP8tHKo1Hqiu/yEAD/OKjQD5AAAUM/+NAAj/Ai/W +oy7ggCo8f+yqAQ8QdAAACkkMZpBv/VBgBaCIBQComAh4EgyIAijWkizSiAwMSgnMEfuPAA00CQUA +eaJILq38Dn4S/7LmFaACBQDRDwIrCqtrKbB+A5kcwKoKmS0FnzcPTwxm8B/7VCYFr/1uAAAAAP/8 +gA2gDgUAHKiL/bRmFaACBQDRDxyqDi+wfumwfyloBIAA6RYAKfAEgAD5cBAVoAolAPggJhWgG4UA +WIN6xyTRDwAAbBAEGKmD91MEBeAGBQD6QGgdoAsVAOysgC0BCoAA4LkaDgEKgAD9YAEF0AIFAP1F +wBdQBQUALQoEbdoPBl4Kp+4u4sPumARyqAUAAOIsASMwgwAA6I0gKSdYAADAJNEPL4LCf7Dl0Q9s +EAjH/+ipxxlIBIAA7GQAClgEgAATp+njIwIBUgEAAOOGsylwIAAAYADYAPsWiBWkMgEA+mAEANAN +FQDjFgQu6AqAAOOpZhmBCoAA790DCvAKgAD+IKYVpeIdAP/QABcyquEA4+4ICoOmAADzUp4FrwYF +APQgaB3gA0UA0w9tOhsjIoQkIoQDA0cGRAHjVgAiqBEAAOQmhCEQgwAAJOKEIxIFEqlBBNQB5DMC +CKAEgADz0IYV4ANFAG06GyMihCMihOVCACIgEQAABjMBA1MC4yaEIRCDAABgABIAkhYj4oSCFQ0z +AQMiAiLmhIIWIuKIgxQAMQTtIgENmAqAAAMiAiLmiCWCtB2pqB6pqMAgCy05DlUBDVUCJYa0+0AE +ANAEFQDphrMqIAqAAO9CAwYBEYAAK4KvArsBC0sCK4avGamcBqUR+KAAQvADNQCTUNEPLIKvAswB +LIav0Q9sEAaDIBWplCwgWvhBCBXgCxUA+rNIFaAIBQD0s+gVoMw5AAy4OOozDAzOQoAA6UQIBAjJ +gAAvQH4uQH//wAfC4gCdAC1SqS3RAmTQ6i7sAS5EfypSqVtiHigKgAioAigkWixSVu+kAAYHOYAA +sMkJywF5wBVtCAywuuq7AQ3gBIAAesACY//sD8wRHad6K1JVDN0sLSUaDf0cLSUZezsVGqeoKqKD +KVKfo6oJqhH7IABEsAAaAMCQG6jKw+outhAtthHDyyy2EBypZQ8KRgiqEQyqAiq2EYuwHalhHKjB +7bsBCe4CgAD9ZgAN8C0FAA27AuvGACSAQYAAmpqYm40gLiEZnhArIRquu+ypVhXb/QAAmxEqQH/q +FgIp8ASAAPiP0BXgG6UA+CBmFeAKVQBYgrvAINEPAAD8YGgd4ApVAP1SlAWgG6UAWIK0wCDRDwD/ +/NwNoAwVAGwQCBSo8okw5JoBBKxAgACIMdMP8wAW0FIAnQDAYOepPRUASYAAjTFm0ZnAQPMgBJqS +AJ0AeZZ6KzEE2iD7YAAF8AwVAFhwb+KkAAUYoYAAK6AmLTEMDwIA590BDf8CgAAvNBAtNQwsoRrA +4QzsOA3MAiw1DOygWCHoKQAAWIKF5qAvbSAEgAAqMBHTD/FB8A3gCwUAbQgSLiA85OARYRAFAACx +u3q7B2+0BGP/5gAAKzQR2lDrNAAKYASAAFiB8MAg0Q8mMQT6QGgdq2YBAPrAaB3gDBUAWHBLZKKC +K6A282AT51IAnQAtMBAoIGENTUMA0AQICBvxABMv0gCdAB+nvi2kJq/f//AQFeCOBQD+wAQGMAgl +AAi4AuikNi//goAAD98CL6QHfmgP9kgABbCOBQD/YABFsAAeAAYLRi8iFCjxAy/xAnjxTePZEQXw +b4AAHqjxC18U+eABBPTbAQD/IABEsABCAAAYqOz5IABEstsBAB+nN6+fJvKA+6AEANAOFQD9wAEH +X/j1AAjoAwhmAQbuAi72gMrEGKi1LKAMHabaDb0CLYazKYK0Hajd7ZkBDmECgAAMmQIphrQrhrOJ +MGP+byQwEC8gYfhghBXjRCEAAEAEDw4b8cAMX9KZYQAqIhQooQLpFgQsAJYAAMfE9CCmFaAA9gAA +AAAAW2Fe6SANJQkJgAAsIFUtCgEJ2TkKzAgJyQwmIAzkFgUrNgKAAPcmAAswiAUA+MYACzAMBQDk +xAAOCrYAAAIqAvrAaB3gDAUAWG/v56QABQrhgABb/xUocDYmdSv65vAVoAkVAAmIAih0NlhbuysS +BewSBCvQBIAA7HRYIegpAABYggXmoUxtIASAAB2oox+opi4xBCwxDA/uAQ3MASw1DAbuAi41BCtx +GvpiMBWgDRUAC9s4/WYADbAGBQDrNQwtCZ4AAGAAIG9kHSqiqS6hAsnkW2Eqp2wqxDwrMBHqqJMT +MAUAAHtj3heoi4kw9mImHa/0/gAmMQT6QGgdq2YBAPrAaB3gDBUAWG+/7KQABQKhgADqJAALWASA +AFhjXYkw9SAEBT/z9gBknt/qIAwkgWGAAB2oEhyofS3QfSzCVbCbDbsoqsmrmRqoeQ6ZEaqZiZD/ ++xANppkBAAD5QGgd7/+mAP/1PA2v5KUAHKhyLiAN/EGQFeAKNQD0IAYVr+ilAPggJhWgG6UAWIHP +Y//TLSAMLiAN+gBiHaAbpQDsqGYaeASAAFiByGP9CuyoZBt4BIAA/EGQFeAKNQD+QbAVr+mlAPgg +BhXgG6UAWIG+Y/+RAAAcqFuPFC4gDfxBkBXgCjUA9CAGFaAbpQBYgbZj/MQAABqoTmP+0AAAbBAG +/GGAF1AJFQDwABwNpLMBAAMLQhWoGPtMegWgBwUAALEE4JgaDYEKgAD6RgAOP/v1AAuLAyxWxeB8 +GgnwVAAALVLGDb0BDc0C/LjGFeAAWgADXxQF/wou8scOvgEOzgIu9sciVsWXECZAJpcR6iQACNgE +gADtZAAA4BEAAFgFKBOoMYwRixDyQAIB8Uj1AOKDU3tswoAALTKBKTKA+sAEANAOFQAA7hrushds ++ASAAO3tAg4QlAAAB+kQ+eYADPAAagDHjwjvAw/fAez9OA95woAACP8DD5kBLTaB+HAGFeABXgAA +AP9QMgWiWDUA8wAGoqJJ9QAZphP/oABGsACSAMSQHqYPDZ0K+sAEANAJFQDvqA8cyAqAAACZEQ6Z +Aq/dHqZNrt0u0oD3YAWhUgCdAAnpAinWgOCtEQ5WAoAADaoCCroCCglH6zKAJIURgABpkUcZp/8K +Cl/puQEFcKeAABil6wioAihWsyVStAXFUghVEQWlAvUmAArwiAUA+KYACrAANgAlrIAIVREFlQJb +/dYoMoEoNoElNoDqQg4pWASAAFtj9smh6kIOKVgEgAD8AAIdoA0VAFtr1sAg0Q8AAAAAAAAA8z/5 +u6IAnQAKaRH4TwAM/r4FAP8gAES//JoAaLFB//0wDaAJBQAAAB2mkx6n2QwsEa7MLcaDx78rxoIt +xoErxoAnNoEap9TbIPZwBhXgDAUA+0/oFaANFQBba7xj/3UAGafO+cAEBP/8HgAAAAAAAGwQBAEE +BAQ5GPEhsA3gCgUAbQgMsJgImQHkkAtlUAUAAGP/7AAAAAD9TO4Fr7QBAPFhwA3gCQUA0w9tCAyw +vQ27AeSwCmTIBQAAY//qAAAA/gAiHa/49QAbp7IMXxGr/yz2gyj2giz2gSj2gAg7Ayv2gwhIAyj2 +giP2gST2gO+npBDogQAAjdD6AAAEMLkBAOi7EQxFwoAA64gCDoEKgADvXwsPcAqAAAjuAi72ge3d +CQtcwoAA+6AEANKHQQDoiBEN2AqAAPsGAAx25wEACO4C+UseBaC3OQAJuxEL7gII7gLu9oAhcFOA +APP/4h3gBBUA8AA4DaRiAQDHP/JAAAMwBBUAF6dP7KV0GwEKgAAARBoDQwMMXALsdsUpcFQAAC1y +xg09AQ1NAi12xiV2xdEPAl8UB/8KLvLHDj4BDk4CLvbHJXbF0Q9sEAQcpZvAkPlOeAWgCgUA+4MA +FeCHBQAIkgoiIsfLJi3CgyaygqrdCd0RrWZtCB9/JxEvMAwuYAwlMA0kYA1/6QJ1QQ0CEhTnZggB +AGGAAGP/2cAh0Q8AsZnqrCAspugAAMAg0Q8AAGwQCPtOrgXgiQUA/mIgDhQMBQADhkL4wABDcAAm +AAAAAwZGGaajCygLKIKA/wggBNAKFQDnpxcTcEuAAAYLRACxBP1AAQbQADYABg1CANEEAK0aG6U1 +Cy4C7nbFK3CQAAAvcsb/oAQH8AgVAA+POc71KEEACYgBDIgCKEUA0Q8AAAZaFAeqCiqix/ugBAUw +CxUACro5ZK/Y6lIOKVgEgABbYz0sQQEtQgH7TmIF4V8FAP9AaB2gCgUAbfoTKLKBeMkFKbKAedEH +67wQJVAFAADboPNABq0iAJ0A6xYEI3BfgAAGDkT7wAQA0A0VAP2gAQbQAEoABg5C+8AEANANFQAA +3RofpQkPvwIvdsX2wAjnUgCdAChyxvmgBAQwCRUACJg5ZYEdEqcOKhIEAqILLSKBLSaBKSKAHKUB +7JkCC1gEgAD4UAYV4AwVAAERAlgEv4oUK1AmARECWARjKUEA+qTQFeKZYQAuIoEoIoAuJoEdplAa +pwLruwkMzMKAAOxBAC2BCoAA4JkaDYEKgAD9QAEFX/v1AAuqAw3MASxFAAqIAQmIAigmgNEPAACe +FfoghhWhSvUA+0AE0uQMBQAXpu0rcn8rsQLppjoV9TmAANog62QACuAEgABb/o8qcn9bX26MQS5B +AOtBASn4BIAA7VAmLRAEgAD6wGgdou5hAO0WACloBIAAW/8SjxXI/OpSDilYBIAAW2LgZKDkGabZ +KEEACYgBAogCKEUA0Q8GWhQHqgoqosf7oAQFMAsVAAq6OWSu4RymGytBAAy7AStFANEPAADaIOtk +AArgBIAAW/5u4hIEI3BfgAAGDkT7wAQA0A0VAP2gAQbQAEoABg5C+8AEANANFQAA3RoYpKePFAj/ +Au92xStwXAAAKXLG+aAEBPAKFQD5TQAM8ABiAAZZFAeZCimSx/mgBATwChUACak5ZJAcBmsC+iCI +FaAMFQBYBF8qEgQrUCZYBARj/ysAAAAcpqCLFAy7Cy2ygS22gSqygBykkgyqAvtwBhWv/yIAAOpS +DilYBIAA/AAiHaANFQBbaoYZppsoQQAJiAECiAIoRQDRD2wQBP9JAAWgiQUA7aZYEeA+gAADi0L5 +YABF8AAeAAMLRvNLtAXj/NUA/E1eDaAPFQAqQQGHQRymhfgqAh3gAgUAbZoXKMKB0w/TD3ipBSnC +gHlxB+zMECEQBQAA9WANj1IAnQALCkQAoQT94AEE0AayAAAAAAtYFA2ICiiCx/kgBASwDBUACck5 +ZJGsKRpQ+EANNGIAnQAcpmkMLAsqwoDxQAys0gCdAP1iABdUiwEAAIEE/eABBNAAOgAACwlCAJEE +APkaDi4C7tbFLfBgAAAo0sb5IAQEsAgVAPkNAAzwAGYAAAtYFA2ICiiCx/kgBASwCBUACYk5ZJE9 +80AK7RIAnQBvvg0LCUQAkQT94AEE0AA2AAsKQgChBAD5Gu7WxS3wXAAAKtLG+yAEBLAIFQD5DQAM +8ABiAAtaFA2qCiqix/sgBASwCBUACYk5ZJC/b74J8AAkDaSbAQAAAAsJQsAw+yAEAN/49QDu1sUv +0AqAAOipAwyBCoAA4DoaDfBcAAAr0sYLmwELqwL7uMYV4ABiAAAAC18UDf8KLvLHDp4BDq4CLvbH ++0nEBa/49QAi1sUbpiYMKRGrmSqWgyiWgiqWgSiWgCPGgSPGgOokAArYBIAAW/6oZKByGqYd+kBo +HeAMBQD7T+gVoA0VAFtqBupiDilYBIAAW2IfyaHqYg4pWASAAPwAAh2gDRUAW2n+0Q8LDEIAwQQA ++RoOKAIo1sX3f/KPUgCdACzSxv0gBASwChUACak5ZZ5SLUEA86AEBvQOBQAO3QItRQDRDy5RLbDu +/qWkHa/+EgAAAADqJAALYASAAFv9o2P/YAAAbBAIKkEBG6W/j0GIKCeygvJIAALwiQUA7LJ7LEZC +gAD44ABDsA4VAOhwDSHgOoAA+KAAQvAAJgAAAAMFRolwLbKD7JkMBAChgAAKmBGo3SzQAPOAE5YS +AJ0AHKXh+CoCHeANBQBtmhcowoHTD9MPeKkFKcKAefEH7MwQJugFAADa0PegaB2hTPUA/YAE2+IA +nQDspZsS8EuAAAUNRADRBP3AAQTQADYABQ9CAPEEAOkamhQfo7kPrwLvxsUq8FwAACrCxvsgBASw +CBUA+Q0ADPAAYgAFXRQM3Qot0sf9IAQE8AsVAAm5OZ8V8yBoHeAIFQDpgzkEhVGAAPoAIh2gCQUA +A6k4ZJB9KkEAHaWq+yAABbP85QB8sV4NrQEG3QL8gAQd4AIFANEPLHEtLnEs6rKEJkAFAAD/gA4S +ogCdACh1LS+hAmT/v1teL4xBK0EB7kEAKfgEgADpICYtMASAAOpUAAtoBIAA+CAGFeLuYQBb/dNj +/5EAAOoiDitYBIAAW2GhZKDxEqWLL0EAAv8BBv8C/oAEHeACBQDRDwAAAADqEgQr2ASAAFv+F4wV +7qVUFQeBgABvXhIFCkT7QAQA0AkVAP0gAQTQAEoABQpC+0AEANAJFQAAmRrs5sUq8FwAACzixv0g +BASwCxUA+W0ADPAAYgAFXxQO/wov8sf/IAQE8A0VAAnZORilcicSBOh3CwSE8YAABVsC+iCIFaAM +FQBYAyYqEgQrICYBEQJYAsoqQQD8RNAVoqphAC1ygSlygC12gRulagzMCeOqEQ4BCoAA4KoaDgEK +gAD9YAEF3/z1AAy7AwuZAQqZAvjwBhXv+i4AAAAAAADqIg4rWASAAPwAIh2gDRUAW2lEEqVKL0EA +Av8BBv8C/oAEHeACBQDRDytxLbG7+uWkHe/8LgAAAC5ygS52gSxygB2jPA3MAvzwBhWv/U4AAA0h +hwoOPw8NPw0Ah/gFCB2knAEA+R/r0+IAnQAcpI8qQQAbo1YMqgELqgL6gAQdoAIFANEPxyTRDwAA +AGwQCpQY90n6BaWzHQDyQAAC8AoVAPQghhXgCRUA/GDAR1AFBQDAoPdgAQe0gwEA/iDGFeANBQDr +pScR8BuAAMCQ+CCmFaCMBQDp3DkO8ASAAAo+OZ4SGaNh/CBmFaBHBQD9RhgFoAQVAIoY+qAEANAu +BQDtogMqeAqAAOqiAiLgV4AA/6AEB/AOFQD/zQAP8ACOAADtXOAvAgqAAPugBADQ+p0AAEga+eAE +B7AIFQAPjzktICYK2hHqWggO7MKAAA1dCvugAEbxXgUA7qoICveCgACeF6ndLtKA8cAHEtIAnQCe +Ee0WACHwM4AA/CCoFeAAGgCNFADRBOyuAgpACoAA7mbFLoEKgAD94AEHX/31AO2NAwnwVAAAL2LG +D98BD+8C/tjGFeAATgAvEgYo8scNiAEI6AIo9scqZsUrICZYAkUZoyb7ScYF59oBAOyi0RaMbQAA +ZNBbHaLUKhIBDaoCLRIA+7AGFaADvgAepNv6ICgVr9qBAO6qAQbwm4AADNgCKGazL2K0D89SCP8R +D98C/0YADXCOBQD/RgANMAA2AC7cgAjuEQ6qAo8Q+/AGFaACngCKEMCA+VAGFaACbgBk8JPuEgUh +8B+AAGAAAY4UjRcA4QTgSBoPAQqAAOyuAg/4CoAA/timFa/+9QDujgMJ8FQAAChixg6IAQj4AvjY +xhWgAFoAkhmIFiKCxw4iAQLyAiKGx4IZLiAmKmbFLyAMAOEEAEga6P8RDEQCgAAPiAIfpBMD7hGu +3q/uLxICCP8CKBID0w8PiAIfpEPviAIHcBMAAJjgsHflfgxiqAUAACogJBuixI8YLSAmLrKEj/Er +soiu3QndEe27CAekXIAAZKBEKrAq66SaFQ1NAADJrtEPAP9ewA3gDQUAKrAqsKr8RIYd56oBAPtl +Rh2v/2oALSAmA90Rq92p3SzSgB6i0g7MASzWgNEPKrAqsar0RIYdp6oBAPtlRh2v/rYALiAmA+4R +q+6p7i3igAzdAi3mgNEPAGwQCpIVH6R+lBsYo5STGYkZlRQqgnwpkCaFGyiCgKqZ/SgAFLXVHQDp +iAgO74KAAOgWASLwM4AA/6AARPAAHgAZpHEWpDEXolb/RU4FoVgFAPSAAAHwChUA+mAEANADBQDu +nggNIAqAAG2KDQc5AilmxSjigHhIBLEzIxpQKxpP82AK4+IAnQDuXgZqyASAAMCQnRqZEK/Y+CBm +FaABHgCxM/agCS9RUgUAGaRWH6KOAyoM/yAAR/ANBQBtqhKj3gfpAilmxSjygOhIBnboBQAAo97z +wGgd4Ur1AP9AB8uiAJ0AihkSpDyKrgIyC5IS4iKAKdgEgABbYEaIFMiBaKGeyaOKGfpgaB3gDAUA ++0HIFaANFQBbaCOLGSuyEMq7jBkepDHswhAp7wKAAK7dLtKBjxl+yRUv8hHI/ygSCSnSgCiCEfkA +DcxiAJ0AdC9VGqND+mBoHeAMBQAPAgD7UEgVoA0VAFtoD+ISAinQBIAA+qBoHeAMBQBYAdIepBsM +PRGu3R6i0i7Wg8fPLNaCLtaBLNaAwLArJoH6UAYV4ABWAAAAAADaMOwSCSrYBIAAW/u4IhpQ6xIF +KdAEgABb/JRkoQH0v/cfUgCdAPggaBXv+3oAAAAAAAD8IUgV4AoVAI8ZBQhC7/AmLAEKgADm0ggN +SAqAAPggxhXhWAUA4hYHL/6CgAAI/wj+IQYV4AIFAO9eB2pIBIAAYAABiRaDGKMjBzgC6GbFKvBg +AAAqYsb7IAQEsAgVAPkNAAzwAFoAACwSByzCx/0gBASwCxUACbk5ZJAtAzoC+qBoHeAMBQBYAZmN +GS3QJhuj3gPdEQ0tCqvdGaIdqd0u0oBw7xTA4C7WgLEiaS2IjBkswCRkwKZgABKLGeuwJinQBIAA +WAEwY//fAAAAjhEt4Cqw3Q0NR+3kKiaBCYAAjxnA4P/khh2gAgUA0Q+JFSiRLbCI+SWkHa/7zgCK +GSygJh2jyAPMEa3MHaIBrcwrwoAdogoNuwH7kAYV4AkFAPlEhh3gAgUA0Q8sEgUqEgkrEgD9gZAV +oA0FAC2mEC2mEe2kVS5mAoAA/WYADbCNBQD9ZgAN8AwVAFgCrWP+FcAg0Q8AAGwQCOOjKxnwBIAA +iiiJ4PJv6BXgiwUA6aoRCrAEgAD4SAAC+4kBAOozCARgMoAA+qAAQvAAHgAJBUYoIDb/A4APn+Sl +ACkgVGSQbSYmEu4mEytQBIAAWHyGwCDRD4ngwEDq4gEkrByAAGahynqW1Ynhi+DzIA0qH/r1AP4g +JhWnmQEA+yAAhLu7AQDrFgMswPQAAPYghhWv66UAmxKKEoYU7hIBLSAEgAAsIDbA1A3MAvxGxh2v +/kIA2mDr5AAKYASAAFh8RsAg0Q8AAPE5QA3j/tUAkxCHEfYghhWgDQUA/CBGFeP/5QDnlQsLoASA +APbhABXgAQIAAAAAAP7MRg2hSPUAdoMa6xIDK1AEgADsdAAJaASAAFv8Cf5/oh2j/+UAuETvAgAD +uCEAAPSf+2xiAJ0AKUEE0w/xP/sEETlRAPxoAAFZaQEAaDM4/sAE+GIAnQApQQXqQgMs/Q4AAGWv +mdpg6xIDK+AEgADtEgApcASAAFv8ui46/f5/wh3v/pIAAAAAfmFWLEEFiUPxhLAN4AsVACwmECkm +ESskVecmFClQBIAA+iBoFeAMBQBYAj8uOv38coCBU//lAIgRGaKLLYEECd0BLYUELEEEDAxJ/ICE +Ha/9OgAAAAAAZZ+1wKAqJhAqJhH6SqYdr/7OANog6xIDK+AEgABb/TT+f6Ido//lAOoWAiV41YAA +hhT/+jwNoAoFAAAAAAAAAOtUAA9gBIAA7BYBKVAEgABb/ej+ICgVr/naAJ4R6jQACVgEgAD8oGgd +oA0VAFv+nokR6ZIALSAEgAD+ICgVr/hKAAAAAAAAAPYghhWgCgUA+iBGFa/4tgBsEAYbotWTEJQR +9UToBaAMFQAdoPcNLQIttsUrssbxa+AN4AgFACIK//i4ABcwDQUA/iBGFaAKBQD1wABHMIUFAG0I +IgCBBADJGnmwD+JUAAVQBQAAL+LCefABsd2xiO+IDWKoBQAAY//WAAAAAAAA/gACHeADBQAborgu +EgIL+wrrsscpwASAAP/wABKwJgUA/qAARzAFBQDk7ggFgVmAAG1qIwBRBADJGnmwEuKEAAVQBQAA +JuLDDwIAeWABsd3lXAEkQAUAALH/4zwgL6aoAACJEIgRmpCdgNEPAAAAAPi4ABUw8vUA+iBGFaAN +BQD//fANoAoFAGwQBBuilxqiNxOgu9MPAyMCI7bFJ7LG8OkQDeACBQADXBH7gABEMAUFAG0IEcFv +AmYMdnUEsVUpgsKxIm8oAmP/58CQC5cKJ3LH/zAAEzACBQD8wABEMC0FAOqICAOAsYAAbdoOwd8C +3Qx9dQSxVS6Cw7EisZlplMoMQgrqIggKkGAAACMtBIMwFaCo5TMCASATAACTQNEPJC0EhEAYoqro +RAEBKBMAAJRQ0Q8DXBH//jwNoAUFAABsEAbaIPogaB3gCAUA6BYAIOARAADoFgEp6ASAAFv/jIwR ++iAIFeFJ9QDzKVYNoA4VAB+ikQ8vCynygfpgBADf+PUA7fKAL3AKgADo4gMNkRAAAOnpAg4RjAAA +B+IQAtICKfaBCMgR4vaALRQCgAAIIgICsgLRDwD5RQIF4lg1AOKLTHnswoAAHqB7+aAARPAB8gAC +kgHsKTgPGcKAAAgzAwPdASn2gQjIEe32gC0UAoAACCICArIC0Q8p9oEIyBHt9oAtFAKAAAgiAgKy +AtEP+UTYBaJJ9QDzIlYNrr8FAAo5EQkpDP8gAETwABoAxJDvoGEZgQqAAO2ZCg9wCoAA6JkID3QC +gAAP7gIdoJ+tme2SgC2QcAAADt8CCMgR75aALRQCgAAIIgICsgLRDwAAaLEUwNAIyBHtloAtFAKA +AAgiAgKyAtEPHqJSDt0BCMgR7ZaALRQCgAAIIgICsgLRDwAAAGwQBOeiEBHwN4AA8AAgDaRjAQAA +AwZCAGEE9UBgBeAIFQD9AAEEX/n1AOmGAwsBCoAA5SUCCiAKgADldsUp8FgAAClyxglpAQlJAil2 +xiJ2xdEPAANbFAe7CiqyxwpqAQpKAiq2xyJ2xdEPAGwQCuagbRlIBIAA90RSBeAMFQD1Q+IF4V0F +APxhgBdQigUA/kGwFeAAGgDA8CiQJhKgEC6QDPxgwEdf+/UAwKDo7hEMAQqAAO7+Ag5ACoAA6u4C +DEQCgAAOiAIeoh/TDw6IAi6QWegWASIL0YAAZeFA/SsmHaSjAQD6IGYVorMBAPogRhXl4x0A9cAB +B3AEBQD+IIYVoEsFACqQJgOvEe9PCg1WgoAAqkqtqqf/pv8o8oDirgIIBAqAAPEABBLSAJ0A7xID +IfAfgABgAAGPEu5WxS+BCoAA/YABB9/+9QDu/gMJ8GgAAChSxpsXmRAI6AEI+AL4uMYVoABuAACS +GIgUIoLHmxeZEA4iAQLyAiKGx4IYjRDqVsUp2ASAAO3QJipgBIAAW/8UiRD6IOgV4AwVAPwqAh3g +AcoAAAAAAAAA6BIDIfAzgAD4IKYVoAAiAIgSmBWIFQCBBO5WxS5wCoAA/iDGFa/49QDo7gMJ8GwA +AChSxg6IAY4WCO4CLlbG/iEoFaAAdgAAkxqSGIMUKDLHghYOiAEIIgIiNseCGIMaKlbFjhEu9oCw +u+W+62IgBQAAL5AkwMDrn+YXgTmAACyUJCmQJiyyhCuyiKnMCcwRrLsqsCqwqgoIR+q0KiQHEYAA +0Q9k78r4IAYV4vMBAP4gRhXgCAUA+SsmHaTjAQD+IGYVpUMdAAVECvQghhWgBAUAjxAv8CbpEgMv +1oKAAOpKCA/8woAAD08Kp//tqggB8COAAGAAAgCJEuKuAgyBCoAA7lbFLkAKgAD7IAQA0A4FAADu +GuuJAwnwVAAAKFLGCYgBCOgC+LjGFaAAWgCSGIgUIoLHCSIBAuICIobHghgqVsWm+SiSgHCPFcCg +KpaAsUT4n/vm0gCdAIkQY/8SAACNENsw7dAmKmAEgABb/rL8KgId4AwVAP//UA2v+/UAGKGDA58R +qP+m/y7ygBifxQjuAS72gNEPbBAGH6GAHp9p/EGQFaALBQD8RNAV4AkVAOehbhpQBIAA9S0ADTJV +RQDl1QgO7MKAAOfdCAHwG4AA2bDq/jkOZgKAAP+GAA4wjgUA6b45AfBngAAoIA39BgAMNKMBAPnG +AA8wADoAAAD9xgAPMqMBAPlCSAXgBhUA759IHQEKgAD8wAEEX/z1AOyKAw0BCoAA718CCmAKgADv +lsUp8FQAAC+Sxg+vAQ/PAv84xhXgAFoAA18UCf8KKPLHCKgBCMgCKPbHE5+HJZbFo9kokoBmgAgu +loDRDwAAAAAiICbrFgAq0ASAAOsWASDgEQAA6xQACWgEgABb/iz6IAgVoUn1APUnlg3iXzUAHKEy +DFwLKcKBLcKA7hIBKQEKgADgaxoNEMgAAAm5AvfABPlSAJ0AB74QDt4CKcaBLsaA0Q8AAADl+yx5 +XMKAAKe5/T5ABaABdgDHr+q/Aw3BwoAACogDCNgBD58BDvk4KcaBKMaA0Q//QjQFokj1AHWDEgop +EfivAAz+vAUA/SAARLAAGgDEkO2fDxkBCoAA65kKC2AKgADumQgOZAKAAA3MAqOZ65KAJRBHgAD9 +QyAA0A8FAC+WgNEPDLgCKJaA0Q8pxoEtxoDRDxqhBQq6ASqWgNEPAAAAbBAEJiAmJwoB5Z/wEgeZ +gAD0wAYiEgCdAAxpEQWZCCiSnvcAB9HSAJ0AKZKdZJDZLSEHHqBEDQ1KDN0RDt0CnZCMIBugQf2A +ABYwDjUADswC7JYBJNAhAAD6AAoV4LM5AAoAivCIABQ2owEA/kMEFeAchQDslgUtUwKAAPsGAAw/ +evUA6joBDd1CgAALqgIbn9KblIsgLSIQ/EIoFaL/HQDolgcv/AKAAA/dAuyWCy1UAoAAmpgcoCX9 +IUYV4AoFAJqZDLsCm5aIIgeIApgiDG8Rpf8u9p3RDxufk4q4aqFGDGkRpZkskp5uw1Epkp3kkE1l +Y/0AAJy4ZZ8zYAAKAPZKhh3v/DYAAAArbBjqJAAJYASAAFteWi0gJ8re0Q8A//wkDaAJBQDAoFh3 +mRuffoq4a6Gr//8ADaAJBQAAwJDA6g6uNP9hBhWv/sIAiifAsPtEABWgDBUAW2OrG5/+Hp/8nqDs +IgAqbAKAAA09Apui7aYDLmYCgAAHzAKcoSckJ9EPAGwQBB2gqBaewxue3Bef4yhihBygYiZiiOSI +CAnQBIAA46CiHEZCgACoZhWeggUlAiXGsy7CtB+gne/uAQUoSQAADl4CLsa0IsazGZ/1A0gRqYIq +IsH1QAZa4gCdACpgNGShuSYiwaNLK7CA+T/cBaAMFQDxYA3v32YBAAhICiiCw/hgAASwAgUA+yAE +ANSIHQD9gAEFUAk1AG2aJ/hgAAS0uB0A+yAEANOYIQDgyRoMgQqAAOmpAg5QCoAA+yYADTSLHQDz +QGgd4Bn1AAKZDHk9ObEi/F6AglAZ9QAanrsqoH3zQAg/UgCdAPCACA/SAJ0AAFsRBBwUB8wKLcL0 +DQ1PDbsCK8b00Q8AAADqJAALWASAAFv102evt2P/vgAAAAAAAAD6oAYqogCdANpAWAcr5aQABQXB +gAAtYDRk0QQmIsEDTggu4ID5P24FoAwVAPHACIffZgEACEgKKILDCAlD+yAEANACBQD9gAEFVIgd +APNAaB3gCTUAbZon+GAABLS4HQD7IAQA05ghAODJGgyBCoAA6TkCDhgKgADzJgAJ9IsdAMGfApkM +eT0vsSL8XoCCUBn1ABqehCqgfX2vLeBbEQJ9DIAABBwUB8wKLcL0DQ1PDbsCK8b00Q8A62QACVAE +gABb9Z9nr8Fj/8jRDwQeFAfuCi3i9B+fng/dAQ1dAi3m9NEPBBgUB4gKL4L0GZ+YCf8BD18CL4b0 +0Q8pYCIDmRGtmauZJZaA9MMkHe/41gAAAOpEAAtYBIAAW/WJY/6ZAAAqYCIboBcDqhGrqhueS6uq +JaaA9MMkHe/7kgAAAAAAAOtkAApQBIAAW/V9Y/9DAABsEAqNMo8w+kbQFeCHBQD98AACcc1xAPwq +AAV7nwEA+CEmFeHtYQD/IgAOEd1BAA+GQvbAAENwACIAAA8GRhif/363C3SDMBmf/g8CAHSbJ/39 +Qh2gBAUAKiBV0w9koG9kQGwlJhLjJhMq0ASAAFh418Ag0Q8AAAD5PToF4AhFAAi4AugkNiepHIAA +nBieF50WKhYFeUFIBmoC7CAmKlgEgABb/zoqIFUrTBLrJRglAImAAIsZ+kBoHaAMBQBb/tLwAHgN +oAQVAAAAAAAAAMDA6lQACdgEgABYeJfAINEPAMBAjBj3gAyBUgCdAI0VGJ/V+gACHeAKFQD1oAdx +UlkFAC8gDI0VLCAmnBQNrTnpyQgOZMKAAOjMCANwG4AAwKCIFAq3ORqfwOidqxwBCoAA7ag5C/AE +gAD94AAVMA0VAOiqAg7oCoAA4N0RA3CTgAAoIA3/pgAPsAcVAPsGAAw01gEA+eYAD7AAZgAAAAAA +APvGAA+wBxUA/6YAD/LWAQAan2oA0QT84AEHX/j1AOjtAw6BCoAAGJ2KjhXomAIPcAqAAOimxStw +VAAAKKLGCNgBCOgC+VjGFaAAZgAGWBQKiAoqgscK2gEK6gIqhscan1Yenc2ZEymmxa7KLaKAmxLz +oAXC0gCdAC+mgI8XmxL34ASZUgCdAIgWb4JzihYZn5IYnd+MIC2SpC+Sn+qLOA52QoAArt0eneqK +2imSWg/MDA6qAQuqAovbecsH+aBoHeAAGgDAkB2ewsP6L9YQK9YRw+su1hAq1hGN0B+fXR6evO/d +AQ5GAoAA+aYADrAvBQAP3QLt5gAkgEGAAJqam5v/95ANoAwFAOokAAtYBIAAW/3pY/5l22DsEgcp +UASAAFv9L/ogSBXv/YIAAIoTiBItICadGugWACjYBIAA6BYBIOARAABb/EaLEooTjRr+IAgVoUn1 +AHqTUh+fSw+vCyrygSnygADRBOcSASvoCoAA7uIXbOAEgADq2gILkJQAAAfZEPmGAAzwAGoAx4/o +3AMO8cKAAAjuAw6ZAQysAQfKOCr2gfnwBhXv+04AKSpT6psSfvzCgAAdnzUZnTL94ABG8ADqACgq +T3qDEgrZEflPAAz+vAUA/SAARLAAGgDEkBifLOqdKB6BCoAA750KC8gKgAAAmREKmQKo3RqdZ6ra +7aKALxA8AAAJ2QL5UAYV7/myAGjhCf//xA2gCQUAAAAZnyD5oAQE//+SAABsEAwanbMnICaGKCui +g++ieyroBIAA5aJ/KzZCgACrZixgDNkg9qAAQvCOBQDvzAgKrkKAAOW1CA5mQoAA7LsIAeA+gAAD +g0L+YABBsAAeAAMDRvxioEdQDhUAGJ8VBjIRqCLyQAgVoACWAAAcnnYDWhQMqgooooQqoogDDEQA +wQTqiAIPEAqAAAgiASxRGKdq76B4IQB5gABlQVVl0VJgAAQAAGRCORic5i5hLyiCsJgY8cAJ9ZIA +nQD8IIYVoA4FAPvABADQCBUA7XwRDEAKgADsFgUuAQqAAP0AAQRf/PUA/RcADDAMFQCcFowYCMwB +GJzTAOEE7IawIgiJgACSHogVghbgIhoMAQqAAAAiGgLMAhKcy4gYLCaw4hIOJAgBgABkwaKfGZsa +mhudHPghphXgCBUA6BYHIggRgACPF5wR+CEIFeAKVQD4IAYV4AuFAOye2BvoBIAAWHghiR2NHIob +ixqPGSxgDMCB/Z8gFaAOBQD9AgAPMAwFAA6MOMrJ7FEYIQbBgACwyChVGCKgeLAiIqR4KLBjIpA2 +sIj5bGYdoPh1AAgiASKUNvwAIh2gCQUADsk47hIEJIEJgADsURgnBhGAAGTBHOmgeCeGIYAAmxrt +FgwkiWGAAC9gDGj3IS6wY9ow63QACmAEgABb9J7RDw64QWSA9sDh/CCGFa/7CgD//3QNoA4VAJIe +ghbAgA2COJIW8iHIFa/7kgBkzwMcndnAiCjGUigK4ijGUxychP2WCBWv+74AAJ0cnxmSHpsaghea +G/ghphXgCAUADYI4khfyIcgVr/uWALHIKFUYIqB4sSIipHgosGMikDaxiPlsZh2gCIUACCIC8ybG +Ha/8rgBkz0HAk/itZh3v/PIAmxrtFgwk+iGAAB6dDYtgLuJ7+qNoFaAMFQD/bwANsA0VAFtiXI0c ++iFIFeAPFQD+pcYd7/xeABydr8CIKMZSwIAoxlMcnFr9lggVr/kmAGXdwmP/CsCR+K1mHe/7dgCc +FPHf84QSAJ0A//cMDaAOJQAAHpzzi2Au4nv6o2gVoAwFAP9vAA2wDRUAW2JCjRz6IUgV7/reAAAA +AGwQBikgNv39Qh2gCkUA6pgCBPgegABgAKMoJDaJMB+c4f5gKBWgDQUA8SAEcttJAQAn8n8rICYm +8oOnt+0kJyu+QoAA9sAAQ3De4QD2IAYVoH75AP/OoAiQbvEALCBbKfJ/KPJ7fcE/qbmLKCrygwm7 +Eauvi/AJmRGpqui7DAcMMIAA7RYBJgoJgAAu8HPTDw8CALDu/CAmFefOAQDu9HMmCImAAC0kW+ok +AApYBIAA7HQAC2gEgABb/wbAwOpUAAnYBIAAWHbqwCDRDwAiMQSOEP08XAWgG4UA7uAoKWgEgABY +d3QfnM8WnFYUnil/IT7wRhAN4SjFAHKDK4kQjRApkCWKEO3SHSSG+YAAKqETeiMHjBAPKxErxRON +3GTQ2//+ZA2gDAUA//5EDa/spQCLECuwKGSw2owQsb0NDUf9hQYd4ApFAP08JgWgG4UAWHdZY//K +AIsQK7AoZL/JjBAtvP8NDUf9hQYd4ApFAP08FAWgG4UAWHdPjhAu4Chl756IEMCk/TwKBaAPBQD/ +BKYd4BuFAFh3R4kQKZIdipxkoKeLnWSwoooQC7AAY/9wAAAAKqIc/AACHaANFQBbYc/8ICgV7/uG +AC3wc7Hd/e5mHeAMFQD7Q4gVoA0VAFthx/wgKBXv+wYAjxDAgej0JSl3woAA/+JkHa/8jgCKECmg +IgOZEaSZppkpkoD5TKYd7/xGAIoQKqIdiqzJpYsQwND9YmQd4AwVACy0JftlEBXv/CYAjxAu8CID +7hGk7qbuLuKA/+ymHa//WgCPECjwIu/wZSxEwoAApIimiP8QBhXv+wYAAGwQBOokAApgBIAA+mIA +FeANNQBYOk/SoNEPAABsEARvY1xlMFnwwHAN4BjlAHSDTvzJAADXIgEAyWH6QGgdoAsFAPfgAAaw +HPUAWGKw8OMwDe/EAQAtUQD6QGgdoAsFAFhiqslh+kBoHaALBQD8A+IdoA0FAFhipcAg0Q9vS7jG +KtEPABObggsqEQrKAio2wRqbgBubgPwAAh2gPSUA/gAiHaAJpQD4eGYV4A8FAFtatGagCisywvqg +BB3v/qIAwKT9Nu4FoBtFAFh24WP/kwBsEAb6RDAVoAsFAPwgaB3gHDUA/gAiHaAPBQBb/8zpnZMd +AZIAAOgRACmMyAAACYgBKBUA+gACHeAcNQDqICEo6ASAAP4AIh2gDxUAW/+/0qDRDwDSoNEPAAAA +AOoRACGUHQAAaTPM6aoBCd+CgAALqgL6IAQdr/76AAAAbBAG/GFgBlAkZQB0MRbGKtEPKCBB9Qkm +DaAJBQApJEGCENEPAMCw+kQwFaAchQD8ACId4A4VAFhBGOagbG0YBIAAKiAh+gACHeAcJQD8BAId +4C4FAFhBEOQkQSmQBIAA0Q8qICH6AAId4ByFAPwAIh3gDgUAWEEI5qAubRgEgAAqICH6AAId4Bwl +APwEAh3gDgUAWEEB5qAQbRgEgADAoOokQSmQBIAA0Q/SMNEPAABsEATApf06ngWgG4UA7SAiKfAE +gABYdo/4CAId5AgFAPhgBATwBAUA6YQ5AeA0gAAYmx8IRAIEBE8jICEVmxX8eAARsAhFAAgzAiNW +wfs2JAXgDAUA/AZCHeAOFQD7NhoFoAmlAPi4ZhXgDwUAW1pF56AUbRAEgADApP02FAWgG0UAWHZ0 +0Q8AKVLCI1bBGpsICpkBCQlPCUkCKVbC+zX8BeAMBQD8BkId4A4VAPs18gWgCJUA+LhmFaAPBQBb +WjHnoBRtEASAAMCh/TXuBaAbRQBYdmDRDwDRDwAAbBAEwKX9OjIFoBuFAO0gIinwBIAAWHZY+kQw +FaALBQD0AAIdoIMBAP6AaB2hDQUA+a0ADzAMRQBYQLRmoCkqCgL6YAQFMgkFAPstAAowCwUA+kQw +FaAMlQD+gGgdog0FAFhAqtKg0Q/SoNEPbBAEHJ0A/ERQFeAKVQD+Q6QVoBuFAFh2PSMgIRSaywsz +ESNGwfs1lAXgDAUA/AZCHeAOFQD7NYoFoAilAPiYZhWgDwUAW1n95qBHbRAEgAApQsIjRsEamzgI +mTIPAgAKmQIpRsL7NXQF4AwFAPwGQh3gDhUA+zVqBaAIlQD4mGYVoA8FAFtZ7eagF20QBIAA0Q8A +wKT9NWIFoBtFAFh2G9EPAMCh/TVcBaAbRQBYdhfRDwAAAAAAAGwQBMCl/TmkBaAbhQDtICIp8ASA +AFh2D+ogISGA4YAA/TVGBeALBQD/NUIFoAwFAFhAbdKg0Q8A/TU6BeALBQD8AAIdoA4FAFhAZ+ag +Cm0YBIAALiEdd+8G0jDRDwAAAP05dgWgClUA/ERQFeAbhQBYdfgiICEUmobTDwsiESJGwRqahBua +hfwAAh2gPSUA/gAiHaAIpQD4mGYVoA8FAFtZuWagOClCwiJGwRqa9QiZMgqZAilGwhqadxuad/wA +Ah2gPSUA/gAiHaAIlQD4mGYVoA8FAFtZq2evfWAAEMCk/TTiBaAbRQBYddrSMNEPwKH9NNoFoBtF +AFh11tIw0Q9sEAQqICEUmnHzNMIF57MBAOSwR21WwoAAwIALqQIpNsEoNsIamlz7NLgF4D0lAP4A +Ih2gDwUA6DbDLGAEgABbWZHmoH1tEASAACQ2wsCh+nhmFaAAUgAAAAAAACo2wSQ2wsC5KzbDGppL +G5pL/AACHaA9JQD+ACIdoA8FAFtZgeagKm0QBIAACuowGZpKKZJFCpkKDOowDJwMasEObQgICuow +CpoMaqECY//w0Q/Aof00fAWgG0UAWHWmZy/JY//qAADAof00bAWgG0UAWHWhY//nAGwQCPpAaB2n +yTUA+EOEHeHINQD4Q6QdoAsFAFv/xGegCtKg0Q8AAAAAAAAA+kQwFaALBQD8A+IdoA0VAFhhPxea +JhaaIxOaHf9dWA3gBKUAKiAh0w8PAgD9WAAVMBs1AAuqAio2wRuaF/wAAh2gPSUA+zQmBaAOFQD0 +eGYVoA8FAFtZS+ejSG0oBIAAKgoE/MBoHaAbRQBYdXoFWgJmr4AqCgX9OGwFoBuFAPxEUBXgDhUA +WHVzKiAh/TQOBeALBQD/NAoFoAwFAFg/0megBNKg0Q8A+kQwFaALBQD9OFIF4Bz1AFhhFf9TaA3g +BUUAKyAhLAoYC7sRDLsCKzbBGpnw+zPgBeAMBQD8BkId4A4VAPR4ZhWgDwUAW1kl6hYGJReNgADA +pPzAaB2gG0UAWHVUihZmrur6RDAVoAsFAP04IAXgHPUAWGD9Zq7ULCAh0w8LzBEsNsEamdr7M7QF +4AwFAPwGQh3gDhUA9HhmFaAPBQBbWQ/qFgElGUWAANxg+gCCHaAbRQBYdT6KEWaukSogIfoAAh3g +HOUA/ABiHeAOBQBYP5xmrngqICH6AAId4BwlAP4AAh2gjQUAWD+WZq5fJSAiwKX9N94FoBuFAO4h +HSroBIAAWHUqLSAh0w8L3REtNsEambf7M24F4AwFAPwGQh3gDhUA9HhmFaAPBQBbWOyaE/VB+A3g +BgUAKRoALjLCLyEdDwIACe4C/+GgBd/uAQAfmbYP7gIODk/6RDAVoAsFAPwAAh2gDQUAWD91Zq3e +KiAh+gACHeAMRQD+AAIdo+0FAFg/b2atxSogIfoAAh3gDJUA/gACHaENBQBYP2lmrawcm8AtICL+ +Q6QVoApVAP4ghhWgG4UAWHT9iRT6RDAVoAsFAPggAh2gDEUA/sBoHaCZAQD5DQAPcQ0FAFg/WWah +CosULSoA/ABCHaIKBQDsuwELcASAAPtNAA9wDJUA+kQwFaALBQBYP05moN8cm6QtICL+Q6QVoApV +AP4gRhWgG4UAWHTijRL+CAId5A4FAO/fAQtIBIAAD+k56RYFJuAwgAAHmQIJCU+ZFScgIfz4ABOw +CEUACHcCJzbBGplk+zLIBeAMBQD8BkId4A4VAPR4ZhWgDwUAW1iZ5qLubSAEgAAqMsInNsEbmWCJ +FQuqAQoKTwqZAik2whqZVRuZVfwAAh2gPSUA/gAiHaAIlQD4eGYVoA8FAFtYieaixm0YBIAAZqAn +JiRA+qBoHaALJQBYaUxmrHcdmWQDXBGtzC3CgB6Zew7dAi3GgCzCgGasXeYkIC0QBIAA0Q8AAAAt +MsLAsPpEMBWv3QEA96YADvAcNQBYYFVmrDX6RDAVoAsFAPwD4h2gDQUAWGBQZqwf+kBoHaALBQBb +/shj/I0AAB+bXS0ywsCwDwIA/6AEBvAONQD/pgAOsByFAPpEMBWv3QEAWGBBZqvm+kQwFaALBQD8 +A+IdoA0FAFhgPGar0CggIdMPDwIA/RgAFDAZhQAJiAIoNsEamRb7MiwF4AwFAPwGQh3gDhUA9Hhm +FaAPBQBbWEvqFgAlC72AAMCk/MBoHaAbRQBYdHr6IAgVr/JaAB+bOi0ywisKAA8CAP+gBAbwbgUA +/6YADrAMBQD6RDAVr90BAFhgHWarVfpEMBWgCwUA/TZeBeAc9QBYYBhmqz/6RDAVoAsFAPwCQh2g +HSUAWGASZqsp+kQwFaALBQD9NkoF4BwVAFhgDWarE/pEMBWgCwUA/TZABeAcBQBYYAdmqv36RDAV +oAsFAPwCQh2gDQUAWGACZqrn+kQwFaALBQD8hEId4BwVAFhf/Gaq0fpEMBWgCwUA/TYiBeAcBQBY +X/dmqrv6RDAVoAsFAPwCQh2gPcUAWF/xZqql+kQwFaALBQD9Ng4F4BwVAFhf7Gaqj/pEMBWgCwUA +/TYEBeAcBQBYX+Zmqnn6RDAVoAsFAPwCQh2gDYUAWF/hZqpj+kQwFaALBQD9NfAF4BwVAFhf22aq +TfpEMBWgCwUA/TXoBeAcBQBYX9Zmqjf6RDAVoAsFAPwD4h2gDQUAWF/QY/uMHprsLTLC/6AEBrAL +BQD1pgAO8ByFAPpEMBWv3QEAWF/HY/sPAAAAAMCk/TFSBaAbRQBYdBP6IGgVr/YiAAAAAMCk/TFG +BaAbRQBYdA3nTUhqUASAAGP9aMCh/TE8BaAbRQBYdAf6YGgdr/S2AGwQBCkgIROYkv04ABSwGtUA +CpICIjbBGpiPG5iP/AACHaA9JQD+ACIdoAilAPh4ZhWgDwUAW1fDZ6ARwKT9MRIFoBtFAFhz82eg +T9EPKTLCIjbBK/oA+yAEBPAqFQAKmQIJCU8pNsIamHsbmHv8AAIdoD0lAP4AIh2gCJUA+HhmFaAP +BQBbV69noAzAof0w7AWgG0UAWHPfZs+vwCDRDwBsEAQpICETmGr9OAAUsBrVAAqZAik2wRqYZxuY +Z/wAAh2gPSUA/gAiHaAIpQD4eGYVoA8FAFtXm2agPCkywuogIST8eIAA+gACHeAc1QD8H+Id4O7l +AFg+LNKg0Q8AAAD6AAId4BzVAPwf4h3g7vUAWD4l0qDRDwDApP0wpAWgG0UAWHO8Y/+1bBAEIiEc +0Q9sEAQqCgX9NQgFoBuFAO0gIinwBIAAWHOzJCAhFZhBC0QRJFbB+zCABeAMBQD8BkId4A4VAPsw +dgWgCKUA+LhmFaAPBQBbV3PnoBRtEASAAMCk/TBwBaAbRQBYc6LRDwApUsIkVsEbmGEdmmwamm39 +IAQE8MMBAP1tAA0/mQEACpkCKVbC+zBQBeAMBQD8BkId4A4VAPswRgWgCJUA+LhmFaAPBQBbV1vn +oBRtEASAAMCh/TBCBaAbRQBYc4rRDwDRDwAAbBAEFphDGJgcBicBeHEVdScCdT8W9uFeDaACBQAG +NAF4QQ3RD3Y85sQg0Q8iCsDRDyIKgNEPAABsEAgkICL6RDAVoAsFAPwiABXgDBUAWF7780BoHeAH +FQDpmCAdAaIAAANGEalmKGK3G5gqC4gCKGa3K2K3KCAr8WAZxNIAnQDzYBmFEgCdACoRCAolQHhZ +CmRRaNIw0Q8AAAAA+kQwFaALBQD8IkAV4AylAFhe4+av3m0YBIAA8L9ADeAJBQAqIEDyAGId4Asl +APkv5gWgTwUA/ERQFeOqAQAcmAAPAgAD3hEM7ggs4rcIzAIs5rfs4rclDomAAPVADwiSAJ0A9UAP +SRIAnQD1QBQJkgCdAMAw9n/74JIAnQD6RDAVoAsFAPwigBXgHMUAWF7E5q9hbRgEgAAemgsrEQoq +IC/u4gAg6GEAAP+gBhWhy2EArcwswAAtCuftqgEOZ0KAAAyqAiokLyligP9j4AbSmekAH5f5+T/A +FaAKJQD6Q+QdoAkFAPntAAywAFYAG5f0JyUf/T+gFaAJBQAMuTnKlihigMeu0w8KiAEoZoAuYoAf +l+sPAgAP7gEOngIuZoAtYoAH3QItZoD6RDAVoAsFAPwjgBXgDFUAWF6Z5q62bRgEgAAsIR0bl8vq +EQ4mZdqAAPtABEziAJ0A8AIMDaBJBQAtICEVl5f0RBAVoAalAP24ABawHqUADt0CLVbBGpeR+y8k +BeAMBQD8BkId4A4VAPa4ZhWgDwUAW1bG6ZeOHQxiAAAuUsLxwAf9EgCdAChM/vjtAAmwDyUA7yQg +KZAEgADRD3WnCfgYAh3gAFoAAAAcl4MLqQH9IAm0IgCdAMCQKSUe9kVmHeANBQAtJCDdQOyZthr4 +BIAA/iEEFaAKRQD4IAYVoBuFAFhy3v/3mA2gAxUAKSQrKSUe+EPkHe//RgAAAAAAAAAA8YAGZBIA +nQAnJED/+PgNoAMFAAAAAAAA8YAF5BIAnQD6SAYd7/ieAPGABaQSAJ0AKgrwKOKBDwIADwIAD4gC +KOaBKOKBLPq/DIgBKOaBLCBACswBLMwQLCRAC8wCLCRACsoB+V/vJtIAnQDAof0zGgWgG0UAWHK5 +8kgGHe/3PgAAKSAh/TgAFLAKVQAKmQIpVsEal0L7LoQF4AwFAPwGQh3gDhUA9rhmFaAPBQBbVndm +oHEqUsIK2kAqJCAKSgwKcznSMNEPAAD/9gQNr/P1AP/15A2gAxUA+EgGHe/1vgD4SAYd7/WeAPgQ +Ah3v+zIAG5luKhEIC6oB+iEEHa/zKgAAAMCk/SBoHaAbRQBYcpMtTPv87QAJ8AxVAOwkICmQBIAA +0Q/ApP0uQgWgG0UAWHKLLUz7/O0ACfAMVQDsJCApkASAANEPAGwQBB6YkOyY7hl8woAA+y4kBeAJ +BQD4AAIdr/31APAAJA2gChUAsZlolEUPlQquVSVSw/6+8A3gAgUAC5YRbQgsACEEAKcad1AWC2MC +I8azI8K0DXQD9KAEAr0zAQADiDexIu8sv2MwBQAAZF+3Y//MrvUlUsLwo+AN4AIFAPYQAh2giXUA +bQgrACEEAKcad1AWC2MCI8azLsK0DX8D/qAEAv3uAQAOiDexZuaTCXEQBQAAyFFj/80iWu4IgjnR +D2wQBBqXHSwgIiuihi0wCCqiiKy76TIBLd5CgACrqoqn+mFwFe+ZgQDqog4mg6GAAPWgBGCSAJ0A +9aAIgRIAnQD1oAThkgCdAGjUFMCk/TIqBaAbhQBYcj/GKtEPAAAAAPUgBLMSAJ0A9SAFq5IAnQBp +mOQLvgn7wACHMN/lAK/uLeECLOEBLuEALjUH/GGGHeHMQQD8YaYdoAIFANEPAAD1IAdLEgCdAPUg +B2uSAJ0AaZikL6IU/mBmFeACBQDRD/UgBwsSAJ0A9SAHs5IAnQD1IARsH+KlANEPAAAAAAAA9SAH +4xIAnQD1IAgLkgCdAPUgBGQf4qUA0Q8LuQkKmQkpnHYrkQIqkQEskQAsNQf6YYYd4apBAPphph2g +AgUA0Q8LuQn7IACEsKylAKyZK5ECKpEBLJEALDUH+mGGHeGqQQD6YaYdoAIFANEPKyxU6wYAAdBB +AAD6gmgdoAIFANEPLqBc7jQPJWlRAADtJgAB4EEAAPyKaB2gAgUA0Q8AAC+gcP5hJh3gAgUA0Q+C +qvJgZhWgAgUA0Q+Ir/hgZhWgAgUA0Q8soDTsNA8lWLEAAOtGAAHIQQAA+JJoHeACBQDRDy+gSO80 +DyVxAQAA7mYAAehBAAD8mmgd4AIFANEPACKgZPJhJh2gAgUA0Q8ooGr4YSYdoAIFANEPAABsEAQU +lp4oQoQbloIkQoiiiOeW2RxGQoAAqET6iDAVoC+FAP4EYh2gLSUA4ywRCAQKgAD0YAQ+EgCdAOSg +CGk0woAAxirRD6tl/GAGTGIAnQD+YAdUIgCdAP5gBlRiAJ0AKkAjI0RB+JXCHeT45QDoVoElLO0A +AGimM2ikMGine2iiePVABBQQCZUAeaF6aKN39UAGfJALtQD7QAY8YgCdACxK/vywJhWgAgUA0Q8s +yv8MnAH8sCYVoAIFANEPq8v9QARkYgCdAP9ABQQiAJ0A/0AFTGIAnQCnwi8iwMeOCP8BLybALbKB +LvrdDt0B/XAmFeACBQAiREHRDwAsSqb8sCYVoAIFANEPLErM/LAmFaACBQDRDylSgBqWUQqZAviw +BhXv/PoAK1KBe7dep20s0sDA4Q7MAv24BhWv/JoAL1KAGJaJCP8C/rAGFe/8VgApsoAamFYKmQH5 +cAYV7/3uAAAAAPiJgh3v/RoALbKAHpdzDt0B/XAGFe/9fgAvsoEN/wL/cCYV7/1GAADrQCMpUASA +AFhmBWP/kgAAbBAQijCEMfZEUBWgBwUA/SycBaALNQD/Q2AC30SBABmYPcSB+IAEUqANFQAJSQqJ +kAqQAAAAwMB5pkSEMdMPDwIABARf9IAeEZAIhQD1AZYNoCl1APSAI7tSAJ0AeUE0HJgu7iAjK2gE +gAD+RtAV4AolAPQgBhWgG4UAWHFQxsrqVAAJ2ASAAFhwu8Ag0Q8AAAAAAAAsIh0swhDLyeokAAnY +BIAAC8AA/UBoHa//UgAAAByYGu4gIytoBIAA/kbQFeAKJQD0IAYVoBuFAFhxO2P/qgAAAAAA//6Q +Da/spQArIR0sIRz8IiYVodtJAPwhphXlSwEA9CIGFaH7MQD+IcYV4OtBAJ4fLyA2LiAjhDKUEvwg +BhWgClUA6xYBK2gEgAD9L/4FoBuFAFhxJCgiHWSGfikSESrqAAqZAvUgM5SiAJ0AKxIQBA1Ffbkk +jB4EbkF+yRyPHwSIQHj5FASZQekWDCS2oYAAih35QDZUYgCdAAS+QPKAG70QxGEA8oAbPNCkaQAf +lhfbcPvtAA2wDaoAAAAALCIdjMBkxkr6QGgdoAsFAAvAAOoyAC1gBIAAY/6EAAAsIh2MzmTE8utE +AAlQBIAAC8AA6jIALWAEgABj/mQAAOtEAAtQBIAAW/8h6jIALWAEgABj/kwAAAAAAC0gQcLm/6Al +/SIAnQAsIh2MzmTEyutEAAlQBIAAC8AA6jIALWAEgABj/hwAAAAALSRr//hIDaAMBQArJGv/+BwN +oAwFAOs8CClQBIAAWEIA6jIALWAEgABj/ez/96QNoAwFABSVoyogIShChCkwCCRCiKqI65biHEZC +gADoRAgE/QyAAC8xCC4wCZ8VLzEJ/UYAElDuIQCJFQCZEen5Ag18woAAq/8p9sgp8sD/rQAPP/jl +AAiZAQnpAin2wCkwCC8SEn6XRS8xCi4wCZ8WLzEL/UbgElDuKQCIFgCIEej4Ag18woAAq/8o9sko +8sDAkf8tAA8/+dUA6YgBD0/CgAAImQIp9sApMAgvEhN9l0UvMQwuMAmfFy8xDf1G4BJQ7jEAiBcA +iBHo+AINfMKAAKv/KPbKKPLAwJH/LQAPP/m1AOmIAQ9PgoAACJkCKfbAKTAILxIUfJdHLzEOLjAJ +nxgvMQ/9RyASUO45AIgYAIgR6PgCDXzCgAAL/wgo9sso8sApCgH/LQAPP/l1AOmIAQ9PQoAACJkC +KfbAKTAILxIVe5c4KTAJ4hYWK8AEgAD+YKQVoJkZAAOiEQsiCC4mxy8iwC4KEPnNAAx/6fUACf8B +CP8CLybAKTAIIhIWeZcxKzEH6ZcnFZ15gAAuQCLqvBIvdMKAAPnAAEd/qgEArO4q5oAqRRktRDQp +QC5kk2YpRC6KMP/wxA2gDAUAG5U0LSEeKiEfGZV0FJVy+OBoHaDqMQD/LQALsPo5AOmEAAxwBIAA +/o0ADHD9MQAPvjkkICQvICv/BgAMNaoBAOuU+h1SAoAA7iAsKiLCgAD05gAKMN05AO25OQ/4QoAA +Cv8CLSEcCf8CKSAjCP8CBP8CKCAhJCAgLTUG6yEdLM4CgADrNQcsRAKAAAmIAuj/AgomwoAABO4C +KiEZKjUID+4CnjL4RpAV4AgFAJg2mTckIDUkNBIvIC/+YmYd7+7iAAAAAADqJAAJ2ASAAFv94/1A +aB2v7oYAAAAAAAD7KnwF4AAyAPspiAXgpGkAKSAiH5cKA5kRr5kflRGvmSiSgB+XBw+IAQi4AiiW +gCkgLy8K/g+ZASkkLw6ZAvhF5h3g+NUACJkB6SQvLn/CgAAPnwL+ReYd4Pi1AOj/AQ1PgoAACfkC +KBIRLyQv+EXmHeYPBQB48EQEmkHLrosderE6LCIdjM+aHO0WBCYWWYAA6xIMKVAEgAALwAAYluou +IR2PHI0U6O4BD/3CgAAP7gL+Q6QdoAAqAAAAAADAoCgaAAhLAXhAS+oWCSaMYYAAKRIQmxr9IAjN +YgCdAJ0UjB/6IUYV4A8VAAv7OfuACBViAJ0AiB76ISYVoZQxAJkb+QAJZWIAnQDqMgAtYASAAGP6 +PACLH8q+KCIdiIWdFPpAaB2gCwUAC4AAKCIdiIT6QGgdoAsFAAuAABuWwykhHY0UC5kBKSUdLBIQ +fckEjh9k4TRk0ckv3P/94A4Y4gCdACwiHSzCA2TAFS0WBOokAApYBIAAC8AA7RIELXxiAAAelrMs +IR0OzAGOHg3MAvxDpB2htDEAe+kDjx/J8RiWrNMP6MgBDc6CgAAJiAIoJR0pICvqFgkk+omAACog +IlhC6ooZY/9BAAD/5hANoAwFAOpkAApYBIAAW/3o/UBoHa/m5gAAAAAAAP/lkA2gDAUAAAAoIh2I +hZ0U6iQAClgEgAALgAAdlpIsIR2aGQ3MAY0U+CHIFeG0MQCbGw3MAiwlHXuZC48ajh/AgQ+POX/h +JygiHdMPiITrRAAJUASAAAuAABuWgykhHYob65kBDVaCgAAKmQIpJR0oIh2IiNogC4AAG5Z5KSEd +ihn7IAQE8QsFAAuZAvhDpB3v+j4AKTEG//JIDaCZAQCMHgRrQfuf87xiAJ0A/EOkFa/8EgAnRDRb +/QctQDRl3GYvQCIYljcD/xGo/xiUa/ngAEe/6gEALvaA+oMkHa/xKgAclmIvIDYuICMpEhGZEPhD +pBWgCiUA9CBGFaAbhQDoFgEraASAAFhveP/4RA2v6qUAAAAAAADuICMraASAAP5G0BXgCiUA/Syk +BaAbhQBYb25j+HcAAByWTy8gNi4gIygSEZgQ/EOkFeAKJQD8ICYV4BuFAOQWAitoBIAAWG9jY/+m +AAAAAP/20A2gCgUAHJZCLyA2LiAjKhIRmhD4Q6QV4BuFAOkWAStoBIAA9CBGFaAKJQBYb1Vj/25s +EAYuMQvtIgAnRPUAAGjrEsCj/SxmBaALhQBYb03AINEPAAAcljCONo83iTiZEPhhKBWgCjUA+CAm +FaALhQBYb0TAINEPAI42/mDoFeAKNQD9LEoFoAuFAFhvPcAg0Q9sEATAINEPAAAAAABsEAiIIJMU +iRQjIAcXlMz2AEIdoASlAPkA0g3hMwEA1kD0YAlCEgCdAAw4EaeIKYKe9yATG6IAnQAogp0IhALo +FgMkCimAABmUSAkAh21pAggCYSkhB4sgGpS7/CCIFaqZAQAMmRHqmQIN1gKAAP1gCNOgBQUAH5UZ +mUD/KWYFoAyFAJxDnkL5KiwF4A0lAA2qAppBCbkCmUQq8oAu8n/rIQkpxwKAAPcAAERwDAUA5oad +J3P9AAD/7+YVoA0VAFtZm4onjiL/RAAV78gFAAj/AeWlFCf5AQAAn6nvpggnArGAAP0rzgWgClUA +/EAIFeA7JQBYbvyIImSAhMCw+/4CHa8JBQBtCA14kA0IiBTkgBxl2CEAAGP/63igC7S78AAYDaSI +HQCxuwgYFGWP99ogW1MHiifHnymmACUmB1tOyCUkBOUkBSoQBIAA0Q8VlFKJWPcgClCSAJ0ADDgR +p4gqgp73QAqTogCdACiCnWSBSbCa+qEGFa/7GgAAAAAAAAD//qgNoAsFANKA0Q8flNeOExyTZZUR +9CAGFeANRQDtqwINx4KAAC0gBwyIAvnAhhWgLIUAnOOZ4JvhGZRj+cBGFeHdAQDtFgIo0ASAAO/d +AgFZhQAA/cCmFeAMNQBYaZm0GvpLoBXgDDUAWGmWjxMelBkblL6V+/XhRhXv+PUAmPmY+Jj3lfaM +EIoR+EDkFeCEBQD14ABCN8zBAAyqApr8ihKNEBiUSQuqAuuURh7uAoAA/6YADrqZAQDt9g0szwKA +AAuZAin2EIsgJfYWJfYXJfYYJfYZJfYaJfYbJfYcJfYdKPYS++KmFaAshQD94mYVoA5FAOyTLB3W +AoAADq4C7vYRLceCgAAMiAL54oYVr/eeAAAAAAAA//aADaAIBQDAoFhsF4lY+T/1eJIAnQD/9iQN +oAgFAADAgASaNPqhBhWv9e4AAAAAbBAGLSAHkhAZlKz1KVgFod0BAA3dCeiTGR7vAoAApNQkQn+p +iKjY+IAFVCIAnQAXlWMWlKP3oABD8AsFAI0QjdBtCCMuSRCFQA8CAOJCBycA2YAALyIBD48UBv8B +f9Ea5XFxeqAEgABj/9WIsQiIFAaIAfm9Pg2gAgUAjSOOIvoAoh2gLwUA++AIANA7JQD9KpgFoO6d +AFhuYYlBi0CbkIpA6aYBKegEgAD6IAgVoAgFAPiABhWgDBUA6EYBKVgEgABYL/oqTPhbTjPUUPT/ ++2VgCwUAwCDRDwAAAGwQRiggBNMP+QAXUlIAnQAXkwsVk6cbkxOJMR2UPuaUjh3QBIAA8yAWoJAE +hQAssoANAIkrIAwjIRkqooj9YABFsBkFAOgcfy3eQoAA66oIBEDFAABtmgIIAIoqoS71QBSkYgCd +ABmTWRiTV/5ACBWg7xUALxTIKBYu6RYsL3YCgAAE7gIuFi0pIAcJCUEAmREJqQIHmQIpFjAI6jAo +FjEmFjT+JqYVoE8FAC8VZy0gUi0U4SwgBSwU4vpGEBXgDRUALRTgKxTj7iIVINH9AADuFjklUUUA +AIuljqSPo+iiAiDh/QAA6aIBJmHFAACZwZjCL8YDLsYEK8YFKqIAKsYA6iIAIVjRAADqFkIg8AcA +AOggUiDIBwAA6JQNIPgHAAD6QLAVoAyFAOr0ECDIBwAA6CAwIPgHAADt9Awg0AcAAPkiJh2gDQUA +7eQOJVBhAABYaNPrLDwg0AcAAPtEABWgDIUAWGjO6yxGINAHAAD7RUAVoAxlAFhoyussTCDQBwAA ++0WgFaAMNQBYaMXrLFgg0AcAAPtGgBWgDIUAWGjA/DNEFeBjIQDyBgAE8IMpAP4zZBXgozkA8i4A +D3CzWQDuPgIN3kKAAO8ViS1XQoAA7yIMLEfCgADoZgIMz4KAAPsmAAywg0EA8goABXDuAQDp7hEN +VoKAAPtGAA1ws0kA7IgRDd7CgAD7BgAMcD0pAOqIAgmewoAA88YAD3T/mQDv7gIA+AcAAC70FPxM +kBWgvWkA+kywFaDdcQDquxEO7kKAAP1mAA3wzBkA/4gAFjDaOQD9ZgANsMoxAO7dEQ5nwoAADcwC +/WYADbCqKQD7RgANcDsFAAuqAir0FYUsCYgCCGYC9+LmHaA1gQD0EQAHcFWRAOruEQquQoAA5e4C +CZ7CgAAD7gIE7gIu9BaDJy05FCo8IOkyCSahcYAAZJQmKxx/+2YgFeAMhQBbVAHAINEPAAD9YDFM +IgCdAIQp8IFADeBbZQAqQAX7QCZMYgCdAIRLZU/vwCDRDwAAAAArIAX6AqIdoE01AP14/g3gPPUA +/ScABaAOBQCeEfwwBhWuCwUAmxDsABUAwCEAAG2qAggAihyTiZwS+EAIFaALBQD6I2Yd4ApFAPok +Bh2j+fUAKRUM/QAAFDAJtQAJiAKYEy8gBCocIfXgKlKSAJ0A+kngFeAMNQBYaEoqHCX6SYAV4Aw1 +AFhoRhOSNygiFSMyiMOf6SQFLEZCgACoM8CQ6RQ5INEBAADpFDoh2QEAAPgnZh3gCFUA+CcGHaAM +hQBYaDgrPEj6IIAVoAw1AFhoNI4R6xwIKVAEgADTD/8OAA8wDLUA/iHmFaANJQBYE7IjIRkakhz6 +QZAV4B6VAC4kUiyigC0SgPtRCBWgGQUA7LsIAMH9AADtABUN3kKAAOuqCARAxQAAbZoCCACKKqEu +9UATXGIAnQAYkmUfkmP8QAgV4O4VAC4UyC8WLugWLC7uAoAABN0CLRYtKCAHCAhBAIgRCKgCB4gC +KBYwD+owLRY1JhY0/iYmFeBOBQAuFWcsIFIsFOErIAUrFOIqIDD6PGYdoA0VAC0U4OwiFSDJ/QAA +7BY5JMlFAACMlIiRj5LukgMg2f0AAOqSBSXZxQAAmrWesy+2Aii2ASy2BCmSACm2APhACBXgDIUA +6RZCIPAHAADvIFIgwAcAAO+EDSFY0QAA6iAFIMgHAADq5BAgwAcAAO8gMCDQBwAA75QRIPAHAAD9 +wYYd4A8FAO+EDiVQYQAAWGff6yw8INAHAAD7RAAVoAyFAFhn2ussRiDQBwAA+0VAFaAMZQBYZ9br +LEwg0AcAAPtFoBWgDDUAWGfR6yxYINAHAAD7RoAVoAyFAFhnzPgzRBXg0yEA8gYAA3BzUQDyCAAC +8INJAP4zZBXgw1kA/jEkHeGjHQD6ZgANMLM5AO27EQ5mQoAA64gRCq8CgADoVQILvoKAAOx3Ags3 +goAA+sYAC3DjKQD6QYgV4KoBAP1IABUwySkA51UCDmbCgADsqgIPH8KAAPOmAAn0u5kA66oCAOgH +AAAq1BT6TJAVoIlpAPZMsBXgmXEA6ogRDM5CgAD5BgAMcKoZAPYGAATwtzkA7rsRDM/CgADrmQIN +V0KAAAqIAvkGAAxwdykA+OYAC7A4BQAIdwIn1BWPLAZVAgUzAvOi5h3g74EA/hEABnD/kQDqzBEP +/kKAAO/MAg92woAADswCBMwCLNQWgycrORTksmJh0IEAAIs5ZLJYKxx/+2YgFeAMhQBbUw0UkXEo +IhUkQojpiBEJUASAAPiAAEIwi3UAW/4b2iBa6w+KKcmgg6srCodb2HDqNAAJ/6YAAIop6yILJQIp +gADOsPpBZhWgAMYAANog+i/gFeAMhQD7ZiAV4A0lAFtL/MAg0Q+Ju8iZ6ZILLNgEgABln/Sau5us +wMD8QSYVoAoFAItKcrkLiimNKPyBRhXgAKoAybctsggPAgAPAgBy0Qzr1AAGgEmAAI3YctnyyLcq +IgkuIggutgj6QLAV4A8FAJ8o6yQwLQI2AACIK8+MxJP5YA2EYgCdABqRPIsgLqJ0+1FoFaAMBQD/ +bwANsA0VAFtW/hyR2YvPw9/tJAUl2/0AAPuB5hXgAgUA0Q/E4v5Aph2gAgUA0Q8AAGRLPPtf2c1i +AJ0A2kBa6s0oMRyKMyomH4kyKCUIKSYeLzAfZPF8wMPlLEwg0AcAAOtUAAVRFQAAWGcsGJJIIzAf +wZXoABUAwAcAAPkLABWmMwEAbZoCCACKH5KW7xZWINAHAAD6gAgV4A01AP1NZh3gDhUA/04GHaP8 +9QAsFbT9YAAVsAy1AAy7AisWVykgBCqscfUgBvqSAJ0A+kngFeAMNQBYZxHqHQEq2ASAAPtOoBWg +DDUAWGcM+iAgJeAPFQAvtIjzcaYd4A4FAO60iSpQBIAA/3FGHaAMtQD/cWYdoA0lAO60jiXZYQAA +WBKEw4n4QKYdoAIFANEPAAAA+kkAFeAMNQBYZvgtEAAsEAHqEAIg2JUAACq0Auy0ASkYBIAA/WAG +HeAptQD4QKYd7+riANog+i/gFeAMhQD7ZiAV4A0lAFtLfGP9nAAakNiLICyidPtRaBWgDRUA/W8A +DbAMBQBbVpvAINEPw9/8QKYd4AIFANEP+kkAFeAMNQBYZtovHQEu/EUo4AHp4AAn+dUAACn0ACj0 +AS7gAv/gRh2v/GoA2kD6QGgd4AwFAFgW/sAg0Q8AAGwQBIknKiAHKJkUiZnTIPENEA3hqgEAH5GF +ZJDGDKsRr7sssp73gAX6UgCdACuynRKRguSRHRWFiYAAjJH4YOQVp8wBAJyRLDAHGpLM9GEEFeqI +AQD/AAAUMOwRAPXQABcxzAEA7ogCDmwCgAANVQIEVQIKiAKYsI0w9WDGFaA+BQCes5Ky9WCGFeAC +BQDzYKYVoAVFAOK2By7uAoAABd0C7bYBJdCBAAAJIIYKAmMJAIYKAmGINwzJEf8gAET/zgUA5Zad +JECBAAAOjgHihQQncQEAAJ6A/wAmFaBdJQAtNAXRD8Ag0Q+LMsi6xMn8YKYdoAIFANEPK6wY7DQA +CdAEgABbVXzEyfxgph2gAgUA0Q8AAGwQBoYrLyAEKiIJKPz7CGo48UYADeAGBQBtCC2Lpym5FP4A +Ih2gDAUA8SIADeANBQCJuYiSiZMEiAwI7DgFmQwJ7Th9yCiKq8qpY//LjmKIY/XPAA8wDRUA9Q8A +DHAMBQD5ogAOMAsFAA7bOHyw1tKg0Q8AACcgBx6RufMjcgXhdwEAB3cJ6JAmG78CgACjc5MQIzJ/ +qHeufv5gCRQiAJ0AbQgsKDkQizf8ACIdoAoFAPECAA3gCQUAjbKIswTdDAWIDAjKOA3JOHqYL4Mw +c+F2Y//MAItijGP1bwANsAoVAPWPAA5wCQUA/UIADLAIBQALqDj5GoAd4AsFAI0xLzIAL9YALjIA +LeYBJjYAJjYBLCAEacQNAioC/BBCHeAMFQBYLQv4YwAVr8kFAAmIAeY1ECRBAQAAmDfoNgYh0+EA +AFtLPsAg0Q+DEB6SSCMyfa5+fjkHYABmgzBz4WEoORCLN/wAIh2gCgUA8QJwDeAJBQCNsoizBN0M +BYgMCMo4Dck4epDSaPQ7HpI6/mEkHaACBQDRD4tijGP1bwANsAoVAPWPAA5wCQUA/UIADLAIBQAL +qDj5FAAd4AsFAGP/xcAg0Q8A2iD8EEId4AwVAFgs4BySJ/xhJB2gAgUA0Q8AAGwQEi0gBBeSI+Ug +ByrwBIAAGZFX63K9KjAEgAD9p+ACUVUBAPWgB3KSAJ0AaNYEwCDRDwCKLiySf48tCaoRrKroogcv +/kKAAK/MLBYWjMeIjigWFIzO/CKmFaAApgAAKCIVLJJ/7yIHLEZCgACozCwWFozHj/4vFhSMzuwW +FSlQBIAAJCAFLDAT+AhCHaA55QD4gDFsZfwRAPiAMSwgKdUA+IAw7GBI5QD4gDCsIgCdAJsa9CEG +FeCMAQAoFhf1oAVTEAQFAJoX6xYGJn2AgAD1oAbCEgCdAOUWCCeFAYAA9eAHWJIAnQDVQPW/+gsS +AJ0A6hIXIvnJgABkrzGKJ9sw6qwgK2AEgABbUVn1QsYd4AIFANEPjCciFhb9gcgVoAoFAPwiphWv +/XIAAI03jDafG5sa7hYJKVAEgABb/zjUoOUWCCUqaYAAixb6IOgVoAUVACkwEwkpRcqZmxb1ICyA +kgCdAC0gBGP/fgDuFgkpIASAAP//bA2gBQUAnhn0AAId4AQFAC1ABf23YBWgHxUA/4AMquIAnQAY +kb8IyAqIgOsWBiwAIoAAAAAA5RYIJ/5hgACbFvn/+XDSAJ0AjUebGp4Z5RYILoC+AABj/l+bFo1H +mxqeGeUWCCbyoYAA9AACHeAEBQAp2RTklqZm0IEAAIvZjBkMDEfowiVtuASAAI2xjBb84AAG8AsF +AFtNgY1HLtkUZOcri9n3YGgd4AAaAJMaiBj9AGgd4A6FAPUAM1oQCkUA6JBAHH8CgACo/ynyntug +B+s5+yBCg+IAnQAp8p1kloApFhHqFg0jhIGAAB+RiSxBBytABx2P0vKBBBXqzAEA+iAABHC7EQDq +uxAMRAKAAOgzAg5nAoAAC8wCGJAtDTMCD8wCnJCMQP0gxhXgDwUAn5WTlPkgRhWgOwUA65YDLmYC +gAAKzAKckYtxHJF3CwtH7LsCC/gEgADrdgEkmIEAAA8ghgMCYw8AhgMCYeoWDSTpAQAALRYRikeL +GuqsICtgBIAAW1DdLBIRjR3mpgEtGASAAPqAaB2gC4UA5705CdgEgABYI2PaQFro3tpAW0q7Y/47 +AMmhLxIULPA4mxbrEgYmYAUAACz0OC8SFp0e6xYGJ4B5gAApEhUokFyxiCiUXByRUi9BN45AjSD4 +IcgV4AolAPggBhXgOyUAWGpbjUcr2RTktNdm0IEAAIvZjLAMjFf8ImYVoD5FAP+ALcwiAJ0AwPD+ +IgYV4A2lACpBCPqC0BXj/PUA/U8ADTAJZQD7IgAOsPj1AHixIywSCSpAQfwhhhXnzAEA/Z/AFaAN +FQAM3DlbLNTtEgwlNiGAAI8Y3vD14COCEgCdABiP0gz/Eaj/KPKe/QA0q+IAnQAp8p1kkzcaj1Yb +j87qAAUM4ASAAJ4fnRwpFhIMAmEMAmEMAmEMAmEMAmEMAmEckDEvQQcuQEHoj8Ec0ASAAPiERBXq +/wEA7u0JD/8CgADo/wIO7wKAAK3M/Y/oFaANBQCdFJ+g+IAIFab8AQD7QEYV4rxBAP1BRB3gTcUA +7aYDLd4CgAAL/wL8BwAFvckdAOTMEQ3dQoAA/WYADbA8xQAspQsL/wLrkP8fdAKAAA/uAu+Q/RzN +AoAAC5kCG5D7KaYG7+4CDEYCgAD/QIYVoAzFAPtA5hXgCWUA6YgCAlkhAADopgElUIEAAFhk1CkS +EipBKvslph2oqh0AKpQsKEBX+ouAFeAchQD5J2YdqIgdAPknRh2oiB0A+ScmHaiIHQDolDgk0PEA +AFhkxStAdMTC/WAeLCIAnQAvEhL9IbgF744VAP/nhh2gCAUAKPYU6PUlINhBAAD56IYdoAw1AO0W +BCfRFQAAWGS1KhISKUB06aRYKlAEgABa6Ecbj/yMTSuyfwnMEay7i7rJtCu8XPoigBWgDEUAWGSp ++iCoFeAAJgAbjqWbFR2QESw66Ay8LA3MKOwWBSpQBIAAWug2ixUcjo/tkAsaUASAAFroUtpAWug1 +LUEILjr//6AJBCIAnQAvEhPDhPngCGwiAJ0AikcpqRRkkvuLqR+Qrh6OVoqwKLASjbEsEhL57QAP +N6rBAPoiZhWn3QEADt0C7bYBJmGBAADtEgwqUASAAFginikSEyUWGfYjRhWgOiUA+yALlCIAnQAr +EhMlFhn2I0YVoDxVAP1gCuQiAJ0AjkclEhkmEhr7xAAVr80FAP1ABAbwDwUA7+UUJukBAADt5gkp +2ASAAO3mCCtgBIAAW0/4Y/rSjhvTDw8CAGTjSfXAHCCSAJ0A6hIHKdgEgAD8wGgdoB1lAFgrLi0g +BP/osA2gBQUA3GD6YGgd4I1FAFgrKByQeo4yjzOJIJkQ+ECwFaAKJQD4ICYVoDslAFhpfcAg0Q+N +R2Xa8GP5NSoSEGWu8I4fH48N7RIML3cCgACv7i3mnSsgFiUWGfYjRhWg/PUA/X/5zCIAnQAqQEH6 +gtAV4DzFAFsr6SUWGfYjRhWv/IIAAI9CZPMmKEEIKTr/+QASVGIAnQAqEhPDtPtAEbxiAJ0AiUcs +mRTkwmJk0IEAAIuZh7H8IMgVp3cBAPzgaB3gCwUAW0wkikfbMOqsICtgBIAAW0+3jECLRwjMEQxs +AuymASXQgQAA6xIGK+AEgABbT7Bj+bAtQRQlQRLAYO0WGCb04YAA6nJCKtgEgAD8AAIdoA0VAFtT +1ChyQy4SGOZsASKoBQAACFUufmnYY/5tAADIqSsSFCmwQLGZKbRAKxIWyLktEhUs0GSxzCzUZI1C +6hYHJoCxgADa0FhELuukAApQBIAAW01JihfE2u1EBSUAeYAALxIULvBBse4u9EEvEhZk+y8pEhUo +kGWxiPksph2v7JIA/+ysDaALBQAcjo6MyPeAEriSAJ0AGI6zDO8RqP8o8p79ABNT4gCdACnynWSS +YRuOhLDK+2EGFa/t7gAAAAAAAP/lcA2gCwUAAByOfYzImh33gBJgkgCdABiOowzfEaj/KPKe2aAH +6Tn5ABLT4gCdACnynWSSUR2OcrDL+6EGFe/mAgCOQmThoo1H5HCKZtCBAADrEgorYASAAFtSoWP4 +cP/0CA2gCwUAKBISL4BIsf//CQYd7/DOAMipKRIUKJA6sYgolDopEhZkmlQrEhUqsF6xqvtrxh2v +6SYAAMS7+oCmHe/o+gDEyvyAph2v6NIA/+NIDaALBQAAjbGMFvzgAAbwCwUAW0uu6hYQLQOmAAD/ +6OgNoA1lAPohSBXvzgUA/0AEBzAPBQDv1RQncQEAAJ7Z7tYIK2AEgABbTzhj99AvEhBl/caJR/sk +ABWvyAUA+UAEBDALBQDrlRQkQQEAAOiWCStgBIAA6JYIKdgEgABbTypj95oAAP/2gA2gCwUA/AFC +HeBJpQD4QKYd7+cKAAAAjzOOMv0faAWgClUA/EAIFeA7JQBYaLmKF8ipLBIUK8A5sbsrxDksEhZk +zJEuEhUt4F2x3f3Lph3v8hoAAAAcj6eOMo8ziiCaEIk3mRP4YMgVoDslAPggRhWgClUAWGinixfI +uS0SFCzQQ7HMLNRDLRIWZNxILxIVLvBnse7/7OYdr/D2AAAAixjaQOu8GCpgBIAAW1JhY/zGixja +QOu8GCpgBIAAW1JdY/5KAAAA/+W4DaAJBQD/3swNoAkFAIxCZcycK0BB2kDrvBIqYASAAFtSUmP8 +iZ8f/CGGFeAKBQBYZg0cjfKMyI0cjh/5n+yYkgCdAP/koA2gCQUAwJAYjezA+g/PNP8BBhXv5FoA ++CHmFaAKBQBYZf8cjeWMyIodjR/5n+0AkA6FAP/c/A2gCQUAAADAkB+N3sDaDc00/eEGFe/crgBs +EAjqIAcqMASAAOUyACqgBIAAKCAE9OAAAvGqAQDqFgQiua0AAPUAE1oUdx0AKyAWKAr/eLEY+kgw +FafEAQD9n8AVoAkVAAycOVsq7WSi940UGY3unRXs2BEGpIEAAKmIJoKe9sAWw+IAnQAkgp3PR4ki +ZJKPwCDRDwAajbuJqPcgFziSAJ0AiBUbjeAMiBGriCuCnvdgF2viAJ0AJIKdZELksJubqGRPxhyN +Y+wABQpABIAAbXkCCAJh2iD6YGgd4AwlAFseHCYhBxiN0gYGSgxmEQhmApZAjSDvjc8S8TEAAJ5D +70YCLu4CgAANfQKdQSkgQSohIhiONAmcCesgBS5nAoAArIj5D+gVoF0FAP1ihg3gTOUA/WGGDaBd +ZQD9YBHtYgCdAAreFPjAAAYy2EEA6Y8THNwCgADpRgcu7gKAAP2GAA5w2DkA5O4RDu1CgAAO3QIN +zAIMuwLqjwgdZQKAAO2PDRKw8QAAJkULCroCDcwCnEb6gIYVoAwFAOxFCiFBIQAA6AceAniBAAAP +AmP6RUQV4A4FAC5EMS5EMv6GZh2gDQUALUQ1LUQ2LUQ3LEQu/IXmHaAKBQAqRDD6haYd4AkFAPiG +hh3oux0AK0QsKCBX+oeAFaAMRQD4h2YdqIgdAPiHRh2oiB0A+IcmHaiIHQDoRDghWXEAAFhixeYW +ASFBgQAA6CYAAkkBAAAJBIoIAIgJAIouIhzqTFQh2MEAAP6KZh2o7h0A/opGHajuHQD+iiYdqO4d +AO5EUCrgBIAAWGKzpUkoIHQolFiGFRiNbgxmEahmJ2adKyAWLwr/f7EHKiBBjBFbKlDEqCokBSgw +EmSN/RuM1RyMlh2OEuuLKAlQBIAAWuZY2iBa5jvAINEPkxLqJAAI2ASAAO0xCCngBIAA5hYDKnAE +gABbN44tCoh9oW+KEGStuIqnixLsEgMlUIEAAFtOHowQjcCLEwjdEQ27AuumAS0YBIAA6iQACdgE +gABbNr7eoOoSACcBeYAA2zDsEgMqaASAAFgoL8Ag0Q+LFNog67wYKWAEgABbUXDAINEPAAAAAAAA +APNAaB2v9CoAixLsEgMpUASAAFgpRMAg0Q8AAAAAAAAA//SsDaAEBQCMImXNKCsgQdog67wSKWAE +gABbUV7AINEPxcL8QKYdr/cGAMCgWGUYGoz+iaj5P+h4kgCdAP/0mA2gBAUAAMBAwNoNnTT9QQYV +7/RaAAAAAGwQBvyHIADQChUA/IIgAVALRQD0gAUJkAY1AGhEZdEPZFD5aVH36jQIIVkBAAD6YgAV +oAyFAFhiUdEPAAAAAAD5GIAF4AxVAOw0CCFYCwAAK7BEKpKGKZKIq6oJqhGqmSiQNfEMEA3gCgUA +LZBJ8atgDeAPFQAokF0I+jkJrhEuNAnRDys0CCU0CwVZCfMgAISw2uUAqpkskQIqkQEpkQAMDE/8 +YYYdoapBAPphph2vmQEAKTUH0Q8mNAgoIGr7AAQG8AyFAP0ABAcx+I0A++AEB/CojQAMqgH/2AAX +MAwlAOyJAQ7vQoAADt0C/0YADXLojQDs7gEMzsKAAPgAAAYwiDkA6O4CDmZCgAAJzAIOqgINqgIM +qgIqNAnRD8CQKTQIiC+YM9EPCasRKzQJ0Q9sEA4ZjAMqkoYokoQnkoiiquKICA1WQoAAqnqKp+IW +ECxGQoAAqHfqog4iFMmAAByNOCsKAP2QEBWgDUUAbdoOALAEDA4bf+cDsb+fHbG7KBqAqKiYHiiA +5ZoUkxXzBBAN4AIFABiNKxyNLpgZKBIQ+xpWBaAOFQD3GlAFoA0FAOYWCyxMwoAA6pkIDF+CgADs +uwgEe/0AAA/tOJ0W+iDmFe8GBQD4IQYV54gBAPghhhWgDAUA/CFGFaABwgAAsUQKGhRlr/ccjgT5 +HAQFr5QBAJkf9yAAR3f+QQAu4ESZEP4iJhWgClUA+aAEBDAbhQDtEhAsRgKAAOj/AgrwBIAAWGb6 +GY0L+KAGNGIAnQAajQl6UV2LHiuw5eM8BiEQBQAA+kAL6uIAnQAlMQAtMQEuMQIudF4ldTD+4AAF +Mc1BAOx0XyUEIYAAwEBtCA16YA0KihTkr29iICEAAGP/68fw+//65iIAnQC0RP/9SA2kqh0AiB31 +AAYpEgCdAIwbjxz85FAV4ApFAPgiKBXgOyUA+CAGFefkAQBYZtQqcCIrEhAcjOEKrQnuEhEu7wKA +AK3MLsR+9Y/mHaANFQAtxH0rxHxby2Nj/0v/++gNoAQFABWLkCkSEChSdyVSiKmI7BIJLEZCgACo +VS5QNY1QKlAHmhApUBb4ICYV4DsFAPijJBWgDyUA+CBGFaAKVQBYZrcoUDT5H/frUgCdACsSESkS +EClUB/qixh3npAEAKlUZ+qBoHaALJQBbw81j/tYsEhBkwHaPFh6Mt40aD+05nRorEg8lEgfpEgot +34KAAPtgBADQChUA/UABBVAIBQD7IABEsAsFAPi4ZhXgCoUAbaoX+wAEANOpAQDgqhoEQAkAAPtg +AEW0mR0AjBj7kWYV7/t6AI4ULu0BLeGh8iCoFaAPRQAP3QIt5aHRD8Dw/iFGFe/+PgDAINEPbBAQ +HIvEJsJ/K8KBKsKDombrJwgLNkKAAKam6GIbK75CgACnp4d3KYEDKIEC53IOKagEgAD5AAi8YgCd +ABiNdROLrhyNdR2LmR6LmZ4QnRKcGZMWCCgCmBj0oAk4kA81APSgB+kQChUA9KAKcZIAnQD0oA2a +EgCdACpiGycWFPQiZhWgCwUAW1EZ54vCHSAEgADlFhItEASAAPkWVgWgAToAAAAAAIuZwshbR09l +odLqVAAI2ASAAPwAgh2gDSUAW0XD/KAIFeAKRQD9GqgFoBuFAFhmVOpiGyFYBQAAW1EDGIsZ6kFo +fRAEgAAVi4oogoAPAgAlUoOiiAmIEahVKFEud4HQ6mIcKVgEgABbSPL/XCAN4A9FAI5QCO4RD+4C +nhEtUAeJVyxRLg0NQeuZFC7sAoAADcwC48wCBNCBAADsFgQt+xYAAP/9cA2gCwUAwKT9GmYFoBuF +AFhmMtEPAAAAZEEN+J/4gNIAnQDqFCgj2QEAAPomABWgDIUAWGEBY/71AMCV6RQoI8ALAAAogESr +iAmIEaiqL6A18eEQDeAJBQAroEnIti2gXcDBDck5CZ4R/iUmHa/7CgAvFCgocGrAuPsABAbwCUUA ++QAEBnHojQD5wAQHcKiNAP+4ABawCSUA66oBDmdCgAD9hgAOcLgBAP9GAA0y2I0A6d0BDd5CgAD5 +AAQE8Ig5AOjdAgzOwoAACbsCDaoCDKoCC6oC+iUmHa/5WgAAJBQr9IAAhrAORQAuFCj3oACG8N7l +AK7dKNEC79EBIPEBAAAv5QEo5QIt0QAt5QArESAqESEsESIsFCz6IuQd4apBAPolph2v+CoAwIAo +FCiPf/4hZhXv9+4AACmgKMqfaJE8aJNJjlcv4RX/xAAVr8kFAAnpAan56apEdVkBAAD7wGgdoCyF +AFtGzWSt+WP/yS8SEmnyyCgSE2WPwmAAJysSEmmyvCwSE2nBtmAAGAAtEhJp069gAA4AAAAAAAAA +/28ADf/+8gAsEhItEhPqEhQlWIEAAFv+QmP90QAAAABsEA7nivIZyASAAPIgxhXgGwUA+iAGFeGE +BQDkJAgJsASAAPJhSBXgOAUA+CBGFaAKJQDqFgEk+KEAAO8WCCTwUQAA/iEmFaAKNQCaH+MWByFA +CwAA4oBEKJgEgAAsYDUtYhCcGixgMYXUjtCP0onRiNOL1psbi9WK15oeKrACmB2ZHPzGBh2gmjEA ++MbGHeAIlQB4yxIYjKEIyAqIgJsV7BIKLAAigAAAKWA3LGA1ZJCv8YrADeAJFQCIHoobKWQxldSb +1Z7Qn9Ka1oocmtGKGpjXiB3o1gMlBXmAAGTAqosf4zwEI7gRAADrvP8jMFEAAOsWDy37PgAAwCDR +DyhgMvzHMBXgDAUA6xYFJBspgACfFC4WEIsdKmA6LGQ1KWA4LWQyjDD4AAAE8KoBAOqqEQzOQoAA +CpkCKVQCihtYYE8uEhCKF48UixWKoSxgNfzCCBXgCAUA6GQ3JVAFAAAqZDQoYDLpEgYkEXmAACmQ +I+oSBiSWIYAAKqAi80wQDeAJNQBj/zMAAGTPVIsWjBn6wBQsYgCdAPzAE2wiAJ0AjRj83/ndYgCd +AC5A5Pff+YCQBQUA2iD04AAGcAtFAFv+zi9A5LFVf1LqY/8TKVACiB6YHPEgDk4SAJ0A8UAODhIA +nQCbFfEgFQZSAJ0AmxUuFhDzQBSeUgCdAJsV/iCGFeAJtQApZDH4ACId4LopAPjzCBWgDAUAC5w4 +6xIOKVAEgAALgACLFSmwAsDh+AUABPAIBQAJ6DgoZDMoUAKPFPwb4h3gDAUA/QAEBvCIKQAI7Djs +ZDUtcASAAO1UAi4M9gAAiheKoexgNSVQBQAA+saGHaAGKgApYDdj/jL4xvAV4AwVACxkNf/4kA2g +DBUALFABKrABiBcMqjT6oAYdoAkFAClkNYiBKWA37GA1JEAFAAD4xoYdr/fmAChymOokAA/YBIAA ++iCGFeAMBQALgADA0C1kNS1kMylQAo8U+iCoFeAsBQAMmQLpVAItcASAAPjG8BXgDAUA/MIIFe/2 +zgAAAChymOokAA/YBIAA+iCGFeAMBQALgAD8IOgV4A4FAC5kNS5kM43Rsd0tZDQpUAKPFPogqBXg +LAUADJkCKVQCLGA16WA3LXAEgAD8wggV7/WCAChymOokAA/YBIAA+iCGFeAMFQALgADA0S1kMylQ +Ao8U+iCoFeDc9QAMmQEpVAIsYDXpYDctcASAAPzCCBXv9H4AAAAAAP/0eA2gCSUAmxX+IIYV4A7F +AC5kMShymOokAA/YBIAA+iCGFeAMBQALgAD+IIgV4AwFACxkMy5QAvogqBXgDRUA/AACHaDZ9QD5 +wAQE8O4pAA7cOOxkNS1wBIAA6VQCJgdBgAApYDf8wggV7/KyAADaIPoAYh3gDAUAW/45Y/zH2iD6 +AEId4AwFAFv+Ndog+gBCHeAMFQBb/jJj/KoAAAD/8fgNoAl1AChgO2SAkShQASmwASpQAAiZNHmh +B//xhA2gCVUAKLAAwJj7DwAMMAplAPlNAAy/8TIAmxWfFP4iBhWgCRUA/SIADn/yPgAAAAAuFhCL +HihynJ8UihQLgAAuEhCPFPogqBXgCZUA/SBoHaANpQAK3DksZDF5wUP1gASMkgCdAMCLeMEw9Z/3 +NRIAnQD8xrAVr/y2AAAAAAAA/+94DaAJRQCJF4mR7GA1JMgFAAD4xoYd7/wyACqwAmP9DChymNog ++iCIFeAMBQALgADA4C5kMylQAo8U+iCoFeAtBQD9JgAO8MkpACxkNe1UAi1wBIAA8z/2TpIAnQCI +F4iB7GA1JEAFAAD4xoYdr/rWAIsVK7AC+PMIFaAJFQD6BQAF8AwFAAucOOsSBClQBIAAC4AAixUp +sALA4fgFAATwCAUACeg4KGQzKFACjxT8G+Id4AwFAP0ABAbwiCkACOw47GQ1LXAEgADtVAIucq4A +AIoXiqHsYDUlUAUAAPrGhh2v+QYAAGwQCvsSPgXh2oUAqiouoGwtsoaTFSuyiK7d6hYILu5CgAAN +uwj6ISYV4AgFAPlsZh2gBgUA+WnmHaAMFQDotDspqASAAP1kRh2gAwUA6KRyLDgEgADaEPqgaB3g +DCUAWF8XKhEACplG4JAECAQKgAD1IATgkgCdAGuVN+CRBASU04AAwMHgzBoMggqAAPOGAAnws50A +/2LgB9czAQAoIovnxwIEQAUAAPhRZhWndwEAYAAHKCKMsYgoJowKCEimhuiMAiMwCQAA+KAAQr9m +AQB0Y4GFFeMWASF44QAA7xYEIXGZAAD+IGYVoA0FAO0WByEwQQAA9iDGFaCoZQD4QABEMAYFAPgg +RhWgAXIAAAAA+yAEANCznQDzYBsn0AgVAACIGggzAv/+RA2nMwEAAAD1IAsIkgCdAGiSWvUgBTmS +AJ0A9SAHShIAnQCmNug8AiMwCQAA+KAAQr9mAQD0wAuiogCdANoQ+qBoHeAMJQBYXtMjEQADmUb+ ++0AN6DMBAG+VrACQBAcIG3+Ho7I5+KAAQv//LgCMGcCx+4dmHeAaRQDzVLYN4AwFAG05EaXOos0t +0Dgu4ALt6Q12YAUAAGP/iAAAAAAAAP+g1g2v/PUAwMFkz3WKFOw0AALYCQAAWF63Y/9lAI8ZwOEu +9E/0f/rT0AwFAG05EaXOos0t0GYu4ALt6Qp2YAUAAGP/PQAAAP+g1g2v/PUAwMFkzy2KE+w0AALY +CQAAWF6lY/8dAAAA/n+AFeAIZQAI/yz6ISgVoAiFAAj/NogYwJEppGP/EaYd4D5FAPPf95PgDAUA +bTkRpc6izS3Qpi7gAu3pCnZgBQAAY/7VAAAA/6DWDa/89QDAwWTOxYoS7DQAAtgJAABYXotj/rWK +Fi9QAi8kDO5QAyLYEQAA/kGmHaAMhQBYXoONGYskiiKIF8CR+08ADXAMBQD9pEYdp4gBAAqYOfgg +5hWv+eoAjhdk4UqIGMDx/w5GHeAOFQCKGSmgNcAw6qIKJIlRgACLGSuwSWSxHY0ZLdBdwMENwznt +ogEpoASAAI8ZK6AAJ6ABhfss8RIp8CEmUAEp9CDv8CIkjLEAAPUgCbkSAJ0A9SAKiZIAnQD1IAtK +EgCdAPUgDNqSAJ0A9SAL+xIAnQB82QJkQWxk4Nlk8O7Ao4sZ6rQhKVAEgABb/bSIGSiANfEHgA3g +DgUAiRkpkElkkGuKGSqgXWSgY/BmMA3gDhUAixgrsHP1YAUQkgCdAIIZjBHyQ0gVoB3lAH3JNogg +z4GJGSmSFYmQypiKGSqiEIqgya+KGIsnmyH7TZAVoAwVAFv8JowY+kAGFaALFQArxG/RDwCOGMDR +LeRv0Q9kP6CNGP0UtAWgClUA/a2QFeArRQBYY1WKGMCx+02QFaAMBQBb/Mhj/3nAQP1AKBXv+7oA +jBj+AAIdoAsFAPuORh3v+s4AAP/8nA2gChUAjhjA0P3OZh3v/WoAAAAAAPbAgARwD1UA+W8ADDAK +RQD54gANP/v+AImhiBixmflAJhXgCRUA+Q5mHe/7bgAAACoiirGqKiaK0Q/AkZmhiRnAgJiiKJUS +KKAB+UAGHaAIFQD5JGYdr/q+ACegASZQAYkYB2g0+UAGHaAIFQD5LmYdr/pSAAAAAP/6XA2gCiUA +hVGIGPVARhXgCRUA+Q5mHe/51gCIGZIa8qBIFaAJFQAphCOJooVRIoUSghp1mdKIGcCgKoQj/b/y +jSIAnQBj/kYAAABsEAj/D7QF4c4FAP5AAEcxloUApiboYKwq2ASAAPfwyBXhpQUApSUv8oj44ABD +sekFAOkpCAu+QoAAp//540YV4BxVAPXiBhXgDSUA/+KmFaAIlQDq/DAn8REAAOixN3e5YQAA/WeA +BNAItQD5YApkIgCdAP1lIIVQGZUAdJMh7kQeYlP9AADBuvtrVg2gDDUADKosYABRmhD8gBDMIgCd +ANEPAJoQfEn3JBojpCTrNAAKUASAAFhdvBmJ5fIgCBXhOIUA+EAARDEK5QD6QABFMAsVACs0DZRR +mlL4oGYVoAFWAAAAAADAqPrZph2hZcUA5SUICdgEgADsRAAK0ASAAFhdqfkTqAXhiFUA+EAARDAK +JQD64aYdoAsFAPrh5h3hWjUAqiolZhMqZhToZhUrmASAACwwDJkSJzAPKjANhTQoMA6YFJUWmhWX +E4RQ+qBIFeHfBQD2oCgV4A1lAPSgaBXgCgUAbdoaoq6v7i3ggi7gfA8CAA8CAH3jF+7TBHVQBQAA +8YFMDeAKBQBgAHoAAAAAAPGHIA3gChUAaMF09YAFsRIAnQCPFpTwl/Gb8pXzLDQM0Q8AAAAAAAD4 +n/cJUgCdACwwAfpgEBXhSdUA+EAARPFYFQD4QABEMUr1AKoqK6QA/UAmHaC7OQAr9FMt9FEqJnEo +JnPpJnIvGASAAPkTLAXv/MIAAADAwfxhhh2gDBUA5UFvfhAEgACNFdRQ9aAJgRIAnQCbEfWgCfCS +AJ0AiBLqYKwqWASAAAuAAIk0+iAoFaALFQArNAWVk5qSl5GUkCI0DNEP0sD2gAaEYgCdAIwV1HD1 +gAixEgCdAOsWAS4O/AAAjhRk4MfrFgEr/ZYAAGAAvI8V0w8PAgBo8mz54ARY0gCdAIkUDwIAZJB+ +ZHB79OBoHaACJQD6ICYV7/4KAAAAJBoj5CQICdgEgADnMAAqUASAAFhdNxmJYfIgCBXhOIUA+EAA +RDEK5QD6QABFMLc5APph5h3gDCUALDQNlFGaUvigZhWv+OoAiRTJnIwT/5nADeAJBQCNE/WgBKCS +AJ0AmxH1P/iwkgCdAI4WlOCX4ZvileMiNAzRD48VDwIADwIAaPJbafHiiRTIkWV/2+sWAS2gBIAA +//uIDaACFQCMFOsWASZ2wYAAjRP/uowN4AkVAGP/OACOFOsWASd2AYAAZX8q+iAmFe/61gCPFGT/ +vYgTaIEg6xYBK/UeAABj/62JFGSfqIwTaMETZH+gY/95Za9sY/73Za+UY//YAABlr4xj/+UAAGwQ +BByJJyQgB/oAoh2gOwUA7iIAKWgEgAD+QEgV4UQBAFhiGhmJIBqJICciAPkgCBWnVQEA5oerEpQd +AAAjMgPqdwIEQAUAAOiWACpPAoAA9IAFohIAnQCmmSuSnvdgCflSAJ0ALZKdZNDSGocp6gAFDsgE +gAAJAmEJAmEaiQwch5wbh5qb0Ikg/aBGFaAbBQCb0/rmAA0wByUA6tYELM4CgAAHmQKZ0SggNRmG +lgiIEQmIAijVCi8xBu/VCyHYgQAA/mDkFaAMZQDu1Qwm0GkAAFhcxgxNEabd97OmFe+MBQDsNBIi +lHkAACoiB/oAIh3gDAUA+0QAFaANFQBbRLDSoNEPwCDRDxuHToq490AFeJIAnQAMSRGmmSySnveA +BclSAJ0ALZKd5NCwZWP9AAD9YQYVr/zSAAAAAGXfLI0iZdBkK0wY6iQACWAEgABbS5dpUq+KJ8Cw ++0QAFaAMFQBbSC4dh8GdoIwgG4jR80BmFeANFQDrpgIuZgKAAP2GAA5wOwUA7KYBKegEgAD9EZIF +oApVAFhhvcAg0Q8AAAAA//sQDaANBQD8QAgV4ApVAP0RhAWgOwUAWGG0wCDRDwDAoFhfORuHHoq4 ++V/6OJIAnQD//ZQNoA0FAMDQwOoOrjT/YQYVr/1aAAAAAGwQBBeHZyZyhopjKEoAbYoHiaBzkWUq +rBAqYgEroQJksIZbQMyNY+yqEQ1gBIAAqtrspQIlA6GAAOOmACpYBIAA+0FAFaAMZQBYXG0ahl4b +hooqooApcoAmcobrsH0tVkKAAKqZimLooQIl/FiAACeSJ4d+9uHoFeAAQgDOqWP/lyeSp4d+h3/J +jVtAsohkp6sKpgoIZgv6wMQd4AkFAJlg6WYBKwBGAADRDwAAkmaTYuVlBypYBIAA6SA1I1CBAAD4 +wmYd4AxlAFhcTfpAaB2gDCUA+/BCHeANJQDrZBIrWASAAFv/S+5hBitoBIAA/sDkFeAKVQD9EOwF +oDsFAFhhaNEPbBAG2iDyIAYV4DulAOyGwxsYBIAAWujV5qQABQGhgABkMA0DOwL7RYAVoAxlAFhc +M8h723D6xkAVoAxlAFhcL5RplWqJEJloiCLIhsAg0Q/ALNEPKyAH+kBoHaG7AQDrvBgpYASAAFtL +FcAg0Q8AAGwQBCIiv8BB4yUMAQBhgADAIAVCONEPAMAg0Q9sEAouQBAvQBEPAgDoQCovdgKAAP/G +AA9wCgUA9cAAQrAGFQD5ABGhX//1AMCEbYpHpKyjqyuwjCzALuvBOHVQBQAA68MGf9AEgADaYGWi +C4sgLEAs+2bAFeAKBQBtyROrraSsLMBGLdAAsar9oA99IgCdAGAACdMPY//TAAAAAAD9EGAFru1l +AP3AAEdwClUA/EAIFeA7BQBYYR36h0AV4JqFAPpgAEUwDEUAWFvw+BKCHeEbpQDrRAgBwEEAAPSA +DMrglwUAmBenN6k5+CDGFeCqBQD6YABFMQslAPpgAEXwrEUA/GAARjCdxQCtPZ0TnBUciBWbEfoh +BhWgNmUA7BYCJmDBAAD8IIYVoDM1ACtAAPNgBNNiAJ0Aezoa92TuDaA+VQB7YiKKFvqAQBXgDEUA +WFvPYAAS2nD6gEAV4AxFAFhby2AAAn6xDC9AAbL/r0R1Q7lgAQKMFI0gjxcuQAKeGf/jqBXgClUA +/aAIFeA7BQBYYOaJGWiSG2mVzIgXKIId+QAGodIAnQCKF8CV+UOmFe/+4gCLFyuyHflgBdlSAJ0A +jRfAxP2jphWv/n4AarZv/WtAI9AeFQB+uYyPFw8CAA8CAC/wBw8CAPH/+94SAJ0Ajxcr9PAuQAEu +9PEsQAEtGgANzDb6ICgVp8wBAOwWACJYCQAAWFud/CBIFaAKVQD8IAgV4DsFAFhgwGP/OYoY+oBA +FeAMRQBYW5Rj/ykAAGqzHPl/+QoSAJ0AihX6gEAV4AxFAFhbjWP/DAAAAAAA+X/4INIAnQCKE/qA +QBXgDEUAWFuGY/7v0Q8AfcMB32Bl//Rj/hYAAGwQBBKFcYg0KSJ38lEIFaOogQCqmQmZEaki8wAF +ElIAnQCEJ4ROKEIl9wAHWJIAnQD9D1YFoApVAPyEqBXgOwUAWGCYKDBGKTBHGoem/QAAFDALBQD5 +BgAMcPlFAPkABUNgvoUAwJTTD22aEy2ggKO8rswswH6xu+zZHHVQBQAA2kDrTBAh4IEAAFv/QsAg +0Q8AAAAAAAAA/YDWDe/69QDAoWSv2vxACBXgClUA/Q8cBaA7BQBYYHvAINEPAAAAAP0PFgWgClUA +/GFEFeA7BQDuIg8peASAAFhgcoov+AAiHaAPBQDxQnAN4AkFAC6hGS0xCg7dDA2pOMCgCYo4Co84 +6ZI5D/juAADAINEPAAAA//+UDaAJBQD8QAgV4ApVAP0O6AWgOwUAWGBewCDRDwBsEASCL8gnJCEZ +c0kC0Q8AwCDRD2wQGhiGTAg5EfggBhXgGVUA6AAVAMAhAABtmgIIAIrkhpcQ0IUAAPQgRhWgDrUA +/EAIFeP/9QD+IYQd4AUFAPQjZh3gBBUA5BQgLu4CgADu3QIBWSEAAPwgZhXgDDUAWFsYJRQ5JRQ6 +JRQ7KBACLBAB/CAQFeAONQDuFDggyJUAAO2UACDQ8QAA7JQBIVlBAAD5IEYdoBwFAFhbCSocTPpI +ABXgDIUAWFsGKhxU+kcAFeAMhQBYWwIqHHz6TAAV4AyFAFha/xuGVByFnBqGdRiFqSUUXCUUbCUU +jCQVRPULGgWkHQUALRVB/CQkHeApBQApFDwpFD2JII0nKIKs+yYADLD19QDi0g4pUASAACUVQvyT +phWgDVUA+JOGFeAMRQALgAAuQp0ZhmAahmL5DLoFqO4dAH5YPx2GMxKGLStCphyHGyIifw27Aew8 +DA2eQoAA8kAAQXALFQD+QYgV4AMFAAyzOAOoOQn/AQj/Au8mDCkBJgAA0Q8oIDopIDsIiBEJiAKx +iPhHZh2oiB0AKCQ60Q8AAAAqLEz6IGgd4Aw1AFhax+scCClQBIAA/AFiHaANJQBYBkf6QLAV4DoV +APpGBh3gSRUAA6k5KSQF0Q8AAAAAAGwQBuYkAAIKyYAAxu/6SQAVoAUFAOoWASFZQQAA6xYAIWEB +AADsFgIhOOEAAPMN2AWv/NUA+w3WBeABMgBolW9pmjEtMAQoMAXvMAYu7gKAAAjdAugwBy7uAoAA +D90C6yIBDu4CgAD5pgAOs++FAA/dLC1kNi8wAQPzCqX19KAFqqIAnQApMAD1IATgkgCdAGiSb2mU +pu4iAQHIEQAA6SYAC8AEgAD4imgdoAEmAAAAKDAC+GBwFe/a9QAKIgHqEgAsRgKAAOmIAgHYFQAA ++MMEHaAMNQBYWoWNEeuGwhH4IQAA/hBoHe/81QD8gmgd7+71ACowAQOjCqWldFOGYAA0AACKEvwA +wh2v+7UA6yIBAdgJAABYWnX7DWYF7/zVAP//PA2v7vUADCIBLTAD/MaGHe/9DgDKIBqFfotgLqJ0 ++1FoFaAMBQD/bwANsA0VAFtKIMK0K2QF0Q/RDwAAAADzDUAFr/9SAGwQCiogJhaFjAqoCQyIEahm +4yAHI0AHAAAogPn6QtAV4Pn1APIgAAHwBwUA5mJ/JBHpgAB5sRMFDEf9n8AVoAgVAAyMOVsiCmSi +vBWFDAw5EfRgEPISAJ0ApZktkp73oBTy0gCdACSSnWRCMBqEj+oABQpIBIAACQJhCQJhCQJhCQJh +CQJhHIUAGIT+/kDkFeaWAQD2BwAFMrZBAOi7EQ1VQoAA+0YADXr/AQDqmQIP/wKAAAj/Ap9AjiD5 +CV4FoD3FAPyAZhXgD1UA7EYCL3YCgAAP7gKeQR6Gai8gJidGEidGESdGEJdPl06XTZdMl0uXSpdJ +J0YIJ0UK7eECL/wCgAAJ/wIu4gAI/wIYg+ufRPiAxhWgL8UA70ULINhBAADutgAiUIEAAP1gRB3g +DGUAWFoULCAmFoVsG4PSDMwJDMwR7LsIAlCZAAD3YABFsAxlAFhaDPsLAgWgCxUAK0Qz+oWmHaCJ +lQD4hYYd4BgFAPiFxh2gDSUALUQ4/IcmHeAPRQD+hiYd4A5VAP6Gph2gDwUA/oYGHeAOBQAuRDQs +ICYbg7gMzAkMzBHsuwgCUOkAAPdgAEWwDGUAWFnywOT+iAYdoA01AC1EQSwgJhuDrZwYDMwJDMwR +7LsIANBhAAD3YABFsAxlAFhZ5ogXjxYARAT56wAPtJ8dAPggxhXgWAUAKBQY+CEIFaAGVQDvFgci +UREAAPYj5h3n/0EA6P8CANhhAAD+I8Yd4AyFAFhZ1YsnDDwR9YAARn/KBQDmxp0l2IEAAAq6Aee1 +BCVRAQAAmrCasSsgFikK/3mxDvpE0BWgLMUAWyFtwCDRD8Ag0Q8AABuEWYq490AFIJIAnQAMORGl +mS2SnvegBXLSAJ0AJJKdZEClsKycuGVNzo0iZNBKGYUvjif4QAgVoApFAJoS+CAGFe/PBQD7xAAV +oAkVAO+vAQxGAoAACYgC6BYBJ/kBAACf6e/mCCjYBIAA98KEHeAMFQBbRTPAINEPKzwY6iQACWAE +gABbSJJj/6MAAP/1lA2gBAUAiyJlv5QrICbaIOu8EilgBIAAW0iKY/+BwKBYXEcbhCyKuPlf+pCS +AJ0A//2QDaAEBQDAQMDKDKw0/WEGFa/9VgAAAABsEAjsJAAKsASAAOl0AAIEUYAAG4XG8wuMBaAK +BQD2IEYVr+f1APwgJhWv9bUA+CAGFe//1QBtCB8pMAAoMAHqiggEjSUAAGiSNWiUJ2iVFmiaCAOD +CnSrPWP/2QK7AfIghhXv/8IAJvrfBrsB9mBoHa//igAHuwH8YGgdr/9eAAW7AfxgaB3v/zIAAA+7 +Af5gaB2v/wIAyLLAIdEPiBEogCYShaUIiAkMiBGoIiIif2QhuPPAcBXgC2UA8AAwDaAOBQAAAACC +KWQhoI8n9gACHeAFBQD/4cgV4AQFAP4gZhXgDwUAbboTreui6iqgQCuwArHu+2AJpSIAnQD+AAId +oAuFANMPbboTrOui6iqgOCuwBLHu+2AJHSIAnQD+AAIdoAuFAG26E6brouoqoEgrsAix7vtgCKUi +AJ0A+gACHaALNQDTD226E6auoqsrsFAu4AWxqvvACB1iAJ0ALiA0DwIADwIAc+ECIyQ0/uAABHAO +BQD/FOwN4AtlAAQJR2WfQwUKR8isKixI+sEAFeAMhQBYWSkHC0fJtbVr+koAFaAMNQBYWSSNEyzR +GbHMLNUZjRQt0APzoAYH0gCdAIsUKrAELbAF7LAGLVYCgAANqgLrsActVgKAAAyqAu4gNi1WAoAA ++0YADXPrhQALqix64SmLEiokNvFgBS+SAJ0AjRMs0RjuEgAmYAUAACzVGI0g/cAGFeACBQDRDwCO +EI0g/cAGFeACBQDRDwAA+1/2Y+//9QD/+xANoA8VAPtf9uvv9PUA//tUDaAEFQD7X/dj7/X1AP/7 +kA2gBRUA/3/366/39QD/+9QNoAcVAIIQx//+QAYV4AIFANEP2iBa3ITAkCkkNokTKJA27hIAJEAF +AAAolDaNIP3ABhXgAgUA0Q/aIFrcey4gNhuDEhyCqR2FI+67KAlQBIAAWtyV2iBa3Hhj/zpsEAoo +IAQqIFMnIAcchAcKrQnmFggu7wKAAP2AAEZwK4UA7MJ/KSAEgAD8QLAV4AYFAPUAGdiRdwEA+6AZ +7GAuVQD/oBmsIP/1ACsgFpwZ/2PmDeANBQAFDEf9n8AVoA0VAAzcOVsgfsDQ7BIJJRrpgAAVg34M +eRH04BP6EgCdAKWZLpKe98AZutIAnQAjkp1kMpEagwEYg3fqAAUJyASAAAkCYQkCYQkCYQkCYQkC +YS8hBw8PSu4hGS//AoAACP8C/mAGFeBKBQD6QAgV4oxBAOmDaRxGAoAA+GBGFeAPVQDqNgMt3gKA +AP9mAA32/AEACP8CmzEqQCYtNQqdOJ05nTqdO508nT2dPp0//GIGFeA5BQD8YiYV7b4dAPxiRhXg +jDkA7TYTLEVCgADpNQst3QKAAAi7Ag+7Au+EAx1UAoAAC6oC64MIH3UCgAAP7gKeNguqAio2BORi +JGHQgQAA+sgAFeAMZQBYWIIsQCYWg9obgkAMzAkMzBHsuwgB0JkAAPdgAEWwDGUAWFh6HoPvG4I/ ++mbmHeAKBQD6ZoYdoBgFAPhlxh2gj5UALzQs/mWmHaANJQAtNDn8ZwYd4AkVACk0M/hmJh3gjAUA +/GbGHaAMZQD8ZqYdoAkFACk0MC1AJhuCJA3dCQzdEa275rsIAdDpAABYWF/A4/5oJh2gDUUALTRA +JEAmG4IbBEwJDMwR7LsIANBhAAD3YABFsAxlAFhYVCgSBy8SBvJYaB2gBmUADwIA+esAD7SfHQD4 +IMYV4FgFAOgUGCHREQAA/iDmFeAIBQD4I+Ydp/9BAOT/AgDYYQAA/iPGHeAMhQBYWEH2aYYdoA8V +AC80TY0nGIR/jd74aeYdoA6FAC40To/QjtEs0Q0v/DTv1gAncAUAAO7WASZgBQAA/aGkHaAEBQAM +exH1YABF8ApVACq2nSsgFikK/3mxCvpKcBWgPAUAWx/PiCf6BQIdr8kFAOokBSQQgQAACSIB5IUU +IREBAACSifMBBhWgAgUA0Q8AG4Kzirj3QAcgkgCdAAx5EaWZLpKe98AHstIAnQAjkp1kMO2wrp64 +ZT1tjyJk8Hkcg4mIJ4sgjhieEvwgBhWvyQUA+wQAFaAMFQDpqQEN3gKAAAy7AusWASTJAQAAmYn5 +AQYV4AwVAO2FFCjYBIAAW0OOwCDRD9Yg9EEIFa/zDgDAINEPABmEQO+RAiDAQQAAL4UC+SAIFeAM +ZQDphgAsWASAAFhX9WP9xit8GOokAAlgBIAAW0bh//3QDaANBQAAAAAAAAD/8zANoAMFAAAAAIoi +Za9ZKyBT2iDrvBIpYASAAFtG1f/9GA2gDQUA/CEmFaAKBQBYWo8bgnWKuIwZ+V/4UJANBQD//HAN +oAMFAMAwwOoOrjT/YQYVr/w2AAAAAGwQGvkF5AWuCQUA+CAGFeAEBQD0ICYVoBlVAOgAFQDAIQAA +0w9tmgIIAIotEAIvEAElEADogzgQ8BEAACrgAizgASgWAigiACQUGyMUOCQUOSQUOiQUO//AEBWj ++/UA+iGEHeAJRQDpFCAg2IUAACy0AftgRh2gCbUA7rQALEYCgADpiAIA8JUAACXkAO/kASDQ8QAA +/cBGHeAcBQDoFgMhWUEAAFhXrCocTPpIABXgDIUAWFepKhxU+kcAFeAMhQBYV6UqHHz6TAAV4AyF +AFhXovkCzgXgKAUAKBQ8+CemHaBfFQB/MS8pFSAkFFwkFGwkFIyOKOscCClQBIAA/8MkFaAMtQD+ +ROQdoA0lAFgDF8L7LyQF0Q8oECDAkgmIAvgkBh2v/x4AbBAEwHBtShGieKN0JEAAKIAA5IkOc7gF +AADAINEPAAAAAAAA9QEWDa/y9QDAIdEP0Q8AAGwQKCcyBBaB4fMFUgWjd4EAB3cJDHcRByII7mJ7 +IWgLAAAt0AAqYoMnIn8O3Qj9qAAWsAwVAO2qCAvYBIAAWEpnJCKC5aQAAgQBgAArMEwsME0IuxH9 +ZgANsAIFAIxKyc+Ky8mhbQgJLaE2e9EHiqvIpGP/7wDSoMwtLMIJ0w9lz97MI4RJZU/TGoHAiC0m +ooMegbfrgd4cRkKAAKhmjWeEaCkwVI3ejEctFkMdg5iMziwWQvUgB0CQDAUAaJIS0Q8AAAAAAAAA +//70DaACBQAAACsKyus7CANRoQAA+igGFaAMZQBYV0XrPD0jUSEAAPooJhWgDDUAWFdALDEvbs8K +HYOD/aAOgqIAnQDAlyoxLi8wmPoMAAWwDhUA+8IADPCqKQD7zQAMsI85APnCAAyw/xkAD+k4ZJG5 +i0p2uSwuEkMt4DIv4DMI3REP3QKx3f3GZh3o3R0ALeQyLRJCLNA5scz9pyYdoACyAAAoEkMvgDQp +gDUI/xEJ/wKx//8Gph3o/x0AL4Q0LxJCLvA6se4u9DraYFgLXNogWzyM0Q8AiEp2iSQvEkMp8DYo +8DcImREImQKxmfnm5h3omR0A+ebGHeAAkgAAAAAAKBJDL4A4KYA5CP8RCf8Csf//ByYd6P8dAC+E +OC8wWfXgC9qSAJ0AwIn54AdMIgCdACOigxiA8ClQDJwQnBGcEpwTnBScFZwWnBecGJwZnBoogoCc +G5wcqYjsFg0sRkKAAKgzLzEunB6cH/vgBJxiAJ0AKVAFwqP7IAQ0IgCdABuBNhiBN4ownhaYEJsS +/UAAFTALRQALqgKaESkwBwkJQQCZEQn5Ag6ZApkUCOowmBWcFy9QJhuAnw/+Ce3/Ag9vAoAArbuf +GB2CM/6ACBXgDjUAnhksFC2fGq277WIAINDpAAD8IaYV4AxlAFhW0eo0AAjYBIAA/ACCHaANJQBb +O1/aIFs8P9EPAAAAAAAA//jIDaAJBQApMFrCqfsgE9QiAJ0A2iBbPDfRDxmBYR6CJR2COI9gjGcY +gWsbghQrFj8ogqyMzg3/AuwWPitQBIAA/8fGFeAMRQD5x+YV4A1VAAuAAByCFynCP/kOAAzw/vUA +eeBGKxI+KrA6LLA7CKoRDKoCKqwB+2dmHaiqHQAqtDraYFgK6togWzwa0Q8A2iBbPBiLSvd/+u0i +AJ0A+sBoHaALRQBb/snRDwAagTIfge4ZgQAroqYpkoMPuwEJuxGrmRuCEo2cGIDCC90BCN0C7ZYM +JP1pgAAsEkApFkUegcgdgNkoUCYtFj0NAIcIiAntEj8sRwKAAKjuLuB/DQJhDQJhDQJhDQJhH4Hg +HYHp6YEoH3UCgAD/xgAPcApFACrWPwl5AhqB1ykWPO7VgC5YBIAA+afGFeAMZQBYVnkYgSYnEkUo +go3rEj8q0ASAAPwAgh2gDVUAC4AAHIHWLcI/DY1HZNRL9aAiRRIAnQDuZT4migmAAC8SQy7wPCjw +PQjuEQjuArHu/+emHajuHQDu9DwrUASAAFgKpRiA5h2AxR6AUf6hkBXgCQUAmRCZEZkSmROZFJkV +mRaZF5kYmRmZGpkbLuKAmRwt0oOv7ukWDS92QoAArt0v0S6ZHpkf+eAE/CIAnQAuUAXCg/nABJQi +AJ0AHoCVG4CojHAYgJSYEJsWnhL9gAAWMA5FAA7MApwRKtAHCgpBAKoRCvoCC6oCmhQJ6jD4IKYV +4AwFAJwXL1AmGIKAG3/7D/4J6P8CD3cCgACuu58YHoGPjUAsFC38IUYV4Ao1AJoZrrvpYgAg0OkA +APghphXgDGUAWFYt6nQACNgEgAD8AIIdoA0lAFs6u9ogWzub0Q8A2iBbO5mJSnaZEvrAaB2gC0UA +W/5L0Q8AAAAAAAD6wGgdoFsVAFv+RtEPGoCfHYB/HoAL/qGQFeALBQCbEJsRmxKbE5sUmxWbFpsX +mxibGZsamxsu4oCbHC3Sg6/u6xYNL3ZCgACu3S/RLpsemx/74AU0IgCdAC5QBcKD+cAEzCIAnQAc +gE8agGGLcB6ATp4QmhacEv1gABWwDEUADLsCmxEp0AcJCUEAmREJ+QIKmQKZFA/qMP4gphXgCAUA +mBctUCYegjkbf7UN3Anu3QIOZwKAAKy7nRgcgUn6gAgVoA0VAC0ULZoa/WAARbAMNQAsFgnpYgAg +0OkAAPghphXgDGUAWFXl6nQACNgEgAD8AIIdoA0lAFs6cy9ANsn/2kBa2XQuQDYbgAscf6Idghzu +uygKUASAAFrZjtpAWtlxKnw0+m4AFeAMhQBYVdMqfDz6bQAV4AyFAFhV0Cp8WPprgBXgDIUAWFXM +7DIZI9GRAAD84wYVoJuFANMP+mAARfAcBQBYVcUrPEH66YAVoAw1AFhVwo1KLnAFLnQwdtkRwIz4 +6kYdoD9lAP7gph3gAEYAwK766kYdoDl1ACl0BdpwWA/P2iBbOykbgS8cf3ntgS8bUASAAFrZZtpg +WtlJi0oPAgAPAgB2uRSCaWQgD/pAaB2gWxUAW/3SgillL+/rgeMbUASAAFv6dByAwS3aAO0WECDB +IQAA/AAKFaAZVQBtmgIIAIobgQ8rFhL6KCgV4A+1AP7ACBWj+fUA+CWEHeAIBQD4K2YdoAoVAOoU +YC92AoAA/8YAD3AMNQDuFhMg0YUAAFhVjfkAdAWgbSUA/C8GHeAPBQAvFHkvFHrvFHsg4QEAACnA +AvuAMBXgDjUALhR/7oDmENGVAAArpAEppAIrEj8ogqwswAAfgBsspACCZxqA8olggi7/x+YV4A1V +APsmAAywDEUA6eY+K1AEgAALgAAZgNUpkj/5DgAM8Pj1APkACCjiAJ0AGIABGYC8En/OKIKmIiKD +CYgB7IDhHEZCgACoIoosG4DiDKoBC6oC6iYMKQemAADrgaYbUASAAFv6LsKcKWQF0Q8uwYD/IAAH +MVoFAP9f3WqiAJ0ALRI8LxI9KRI/LhZEDwCHCQJhCQJhCQJhCQJhGoC0GYCsKaY/LaY+LGBqLmBo +KGBsKWBpL2Br7WBtLEYCgADomREPdAKAAOnuAg/8AoAACP8CD90CDswCDcwDDM0UDcwDDG0U/ZcA +DnALFQD8oAAGMAoFAFhcTh6AnRh/5tmgKeZA+RGoFaAMRQD7yCYV4A1VAOsSPyrQBIAAC4AAHICU +LcI/LhJE/+wADafdQQAuIDovIDsI7hEP7gKx7v5HZh2o7h0A/kdGHa/8UgAqLEz6KAAV4Aw1AFhV +IescSClQBIAA/AFiHaANJQBYAKHD+P5Aph3v+6YAAAAAbBAGGIFfeFEG0Q8AAAAAAOokAAnYBIAA +7EQACugEgADuZAAI+ASAAFv7gGWv2o0Q+wA8BaAnRQD1oAXgEAwVACOihgnYEagzjjeO7onl6uIE +JOgFAAAt5gX5oPIN4Cs1ACqsAZrkKSAFLDQ3+zMmDeAsZQAqMAV8oQJ3qYuON/XByBXvzwUA5zQF +J2iBAAD/oAQG8A8FAO/lFCbpAQAAnent5ggp0ASAAFrYhChREoQ6sYjoVRIiAImAAMJdKUAFdZEl +hEllT/T6QGgdoAsFAPwAAh2gDQUAW/qBizeLviqxDrGqKrUO0Q/aQFgDaoRJZU/JY//RAAD6QGgd +oAsFAPwAAh2gDQUAW/p1Gn/n0w/TDyqiiw8CACyhAmTO6ls5Jh5/GR9+wRx/4B1/Yy/ydizChivS +EKr67gAFDVZCgADqyggF2AUAAOvWECVwgQAADgJhDgJhDgJhDgJhDgJhDgJhmhEoIBYZf+wsIQct +IA3+QZAVoA8VAC+kBC6kDC8gBy2kDS4gJh2A+SylBw7rCe6kUy3fAoAAq5kpkn8pphUvpAcupFOS +qO2lFipgBIAA6KQWKdgEgABb+e8dgAMsICYbfmiDEQzMCeR/Ox5nAoAA7LsIAdFhAAD9YABF8Axl +AFhUoIpMLaECyNtbOPOOTQKvEa/uLjYYKiAmGX/HCqoJDKoRqpkqkoJkoGOJqciZ6ZIJLNAEgABl +n/STqSU1F/Zgph3gCwUAmznrNgoh7tmAAIw3jM6NxYrE5jUZJtgFAAB9uxctwQ7rxgUlcAUAAO7G +BCboBQAALcUO0Q8vwQ6bxerGBCf4BQAAL8UO0Q8A8zBGFe/+pgBsEA6VE5MS+mAIFeAONQDuFgsq +UASAAOoWBCnABIAAJoAY4yAHKaAEgAAngBP2IcYV57sBAPoh5hXhMwEA825wDeB2EQB9Zw0oCsD4 +IAYVoAA6AAAAAIgfKIxMmBAljB8FRRQoIARrhgf5ABjyEgCdACsgFiYK/w8CAHaxIoYTDwIA+kgw +FadmAQD838AVoAgVAAyMOVscEPtAU6gSAJ0A+P3QBaAPdQDvFgwjlCGAAOl/DRGkyQAADDgRqYgq +gp71QFIj4gCdACeCnWVwRooiZKXuixKMFO0SAylQBIAAW0FS0qDRD4mI9yBSgJIAnQAafv0MNxGq +dytynvVgUwviAJ0AJ3Kd+uBSwBIAnQCwm5uIZH+4HH5+0w/sAAULwASAAG1ZAggCYSghBxl+8Pwh +yBWqiAEA7RIALEcCgAAJiAKYcI4gH37qn3LtdgMvdgKAAO5eAglQBIAA7nYBKlgEgABbDystISIp +IAUYf00sQBiGLR5+ghp+DisgQS7igyqigOu/CQs2QoAArmaWGPbBCBWgzAkA7BYJL/8CgACviC9g +DIZnKIJ/Cv8IJmIO5hYNL/5CgAAP7gj+IOYVoFoFAHqRCy8KTn+RBSkKUikkBflgABY26AEA+gAC +HeL4QQD64UQd4LoFAOp1Cy/+AoAAD+4C+AcAB72NHQDkiBEP/UKAAAj/Ag/uAh9/bQ7MAu1+dB71 +AoAAD+4C7nYGI9CBAADtzAIBWSEAAPzghhWgDGUAWFPuLCBBHX9GG32sDMwJDMwR7LsIA9CZAAD9 +YABF8AxlAFhT5Rt/W/77VAWgiZUA6XQsI9DxAAD+5uYdoI0FAPzmxh3gGAUA+OXGHaAMFQD65aYd +4A8lAO90MSFZcQAA/OZmHaAPBQD+5gYd4ByFAFhT0ip8VOwSDyJYwQAAWFPOwNL85qYd4A0FAC10 +NChAMPUAHSISAJ0AKBYQ9QA9WpIAnQDF4f8AHPQiAJ0Aix2MsIqxLQq0rczstgAlUAUAAJqxGX57 +DD8Rqf8l9p31ABoCkgCdACsgFi4K/36xcowf6iBBJmDxAABbG1rAINEPAAAAAAAA//TcDaAFhQD0 +YAayEgCdABh+aww3Eah3LXKe9aBAi+IAnQAncp3nFgorhz4AAIoiZa13KzwY6iQACWAEgABbQpFj +/WaLEiuxCCw6/3yxDIsS7BIEKVAEgABYGmbAINEPAAAAjRLaIO4SAyDYEQAA7dEILuAEgABbKIgt +Coh9ocOMEWTP1orHixLsEgQlUIEAAFs/GIwRjsCNFAjuEQ7dAp2hKyAE5qQADSAEgAD1YDhaEgCd +AOokAAtYBIAAWye17BIBJRdhgADtEgMrWASAAOwSBC5QBIAAWBkkwCDRDwAAAImI9yA7WJIAnQAa +fjQMNxGqdy9ynvXgO5viAJ0AJ3KdZHdqsJubiOcWCiP5CYAAHX21iBoNAIdtWQIIAmHaIOwSDipY +BIAAWw5vLyEHF34l+iFIFar/AQAM/xEH/wKfoIsgGX4e7CEiLd4CgAALWwKboS4gQSwWBh9+h+7t +CQFhIQAA6KwgLu8CgADv3QgJvwKAAO8SDyIYwQAA6XcIBVDxAADpIAUhWXEAAOTyJ290AoAALxIK +Fn4MJvYCJhIAJvYD/a/oFeBfBQB/kRAvCk5/kQomClb3IDRlIgCdAPggyBXibUEA/MAAEzb9AQAG +/wL8BwADfdkdAOVmEQ7tAoAADWYCBv8CFn9XjRrv7wIMzQKAAAaZAhZ/TJnWGX9MBv8Chh/5oOYV +4AkFACnVCu/WBCMw8QAAJtULDACGCAJhJiEq96WmHaAPBQAv1DEv1DIv1DP5peYd4AkFAPmmhh3g +DwUAL9Q1L9Q2/6bmHehmHQD3pYYdoA8FAP+lxh3gDwUAL9QwJiBX96dmHahmHQD3p0YdqGYdAPen +Jh2oZh0AJtQ4L7ABKbAAKaQAL6QBL7ADJrAC5qQCJukBAADvpAMhSYEAAAkgiA0EigkAiA0Aiooa +KyIcjB/7SmYd6LsdAPtKRh3oux0A+0omHei7HQArpFDrNAAFUVEAAFhS+Y8fjhotIHSv7i3kWIwe +JXad9YAiKZIAnQAoQBJkhKgbfR8cfOAdflzriygJUASAAFrWotogWtaFY/zEAB1/Mowu/Z/l3WIA +nQCOF47i8d/lf9IAnQD6IOgVoAsVAFrVw2P8nIkdL5EUsf//IoQd4ABGAGiE7YodKaEWsZkppRaJ +GfwhiBXgDiUALnTI/vkmHaAsRQD85yYdoCtlAPrmph3gCgUA+uaGHaAPhQAJ/Tn85wYd7/CWAAAA +ACs8GOokAAlgBIAAW0G3Y/n/AAAAAADzgGgdr+ZWAIYaxPSfYx9/Cp9iFn0kjy0mYoMJ/xGvZoZn +LdJ/hm72IKYVoF8FAH+RCcRudpEExZIpJAWJFvxIAAf2bQEA/eAAF7DdOQD+xgALffkdAOXdEQ/9 +AoAAD90CH37GDWYCBuYCjRoefssPZgLm1gQszQKAAA6ZAo9NFn7Altfp1gYn+PEAAP+hZB3gDwUA +L9UKLsABKcAAKYQALoQBJsADL8ACL4QCJoQDLsAFKcAEKYQELoQFJsAHL8AGL4QGJoQHLsAJKcAI +KYQILoQJJsALL8AKL4QKJoQLLiEq/6WmHajuHQAu1CwsIFf9p2YdqMwdAP2nRh2ozB0A/acmHajM +HQD9pwYdoByFAFhSgIoa2zD7SwAVoBwFAFhSfYoaiRUcfTz9Q0YVoA2FAC2mGysgdCukdBt+viV2 +nSqiF40uKqxA+6AJJGAIBQAefNUu4oMJ3xGv7o7nju4m4AUj4AQt4AAv4AHl4AYpngKAAOYzAg7u +AoAA790CCZ4CgAAFMwIm4AIl4Afv4AMu7gKAAObdAgmeAoAA5TMCDu4CgAAP3QKtjQOjCHo7Ai3c +ASbgDS/gDC3kA/PA5h3oUx0A9cDGHeg9HQD9wRAV6FUdACXkBfPARh3oVR0A9cCGHegzHQAj5AH1 +wTAV6DMdAOPkAC/+AoAABv8CI+AO5uAKLu4CgADl3QIP/gKAAAP/AiXgD+PgCy7uAoAA5t0CD/4C +gADl/wIO7gKAAOPdAgeYBQAAfzsBsd0j5A/9wWYd6MMdAP3Bxh2ovR0A+8FGHejMHQD9waYdqLsd +APvBJh3ozB0A/cGGHai7HQAr5AgmkAUtkAQvkAArkAHukAYu7gKAAObdAg/+AoAA6/8CDu4CgAAO +3QIrkAIukAfmkAMv/gKAAOv/Ag7uAoAA7t0CD/4CgAAG/wKviK2tetsBsYgtlAcrkAkskA0olAP3 +IZAVqIgdAPkgRh2orR0A+yDGHaiIHQD5ICYdqKodAPsgph2oiB0A+SAGHaiqHQAqlAQokAjqkA4r +NgKAAAxmAuyQCis2AoAA6mYCDEYCgAALiAIrkA/qkAssRgKAAOyIAgs2AoAA62YCDEYCgADqiAID +aAUAAHbbAbGILZQPKJQL+iHIFejtHQD/IcYdqMgdAP0hRh2o7h0A/yGmHajMHQD9ISYdqO4dAP8h +hh2ozB0ALJQI+X/eGdIAnQAvIAXFZvf/yMwiAJ0A2iBbN1LAINEPAAAAAACNHSzREyp8ZusSCCZg +BQAA/aJkHaAOJQD+7IYdoAgFAP7sph2gDZUA/OcGHeAJ1QD45qYd4Ay1AOx0OSXZoQAA+OaGHaAM +ZQBYUcn4IggVr+BSAI4eixvA0u7bOAlQBIAAWA//Y/gjKqwZ+kngFeAMNQBYUb8qbB36SYAV4Aw1 +AFhRu/wgKBWv42YA/9b8DaAHBQAAaWIOiifbQOwSBCVQgQAAWz0+iyJluFsrIEHaIOu8EilgBIAA +W0CdwCDRD8CgWFRaGHw/iYj5P60wkgCdAP/XAA2gBwUAAAD/38gNoAcFAMBwwMoMnDT9AQYVr9ae +AADF8v5Aph3v5coAAMCgWFRKGHwwiYj5P8RYkgCdAP/igA2gBwUAAMBwwKoKmjT7AQYVr+JCAAAA +AGwQBIo6jCmILHopB/xhRhWgAH4AyaWLqdMPDwIAcrEM6rQABYBJgACLuXK58pyp+kGoFaAMBQCc +KvxBZhWgOQUA7CYJJABZgAApJAXRDwAAZa/1Gnxd+kAIFeAttQAtJAUuonQqoov/bwANsA0VAFtB +L9EPbBAGKAor6CQFKVAEgABa1QaDLBZ7YBR82/BncA3gVwUA5zQFKdAEgABa1P8rMg0qYogJuxEL +qggqogpkoBkrrFz6IGgdoAxFAFhRYfogCBWgADYAAAAAABp7XJoQHXzILDroDKwsDcwo7BYAKdAE +gABa1O3rEgAqaASAAOx7RRnQBIAAWtUIAzoCWtTrgztlP46DLOsiDSGAuYAAZbC/8kGmFeAAIgCT +u5s8wOCeLIMqyTDDviowBYU4e6EP41QACv+mAADAsJsq0Q8AANowWtTWhDrwh0AN4DvlAOdEBSpQ +BIAAWtTQi00qYogJuxGrqoqqZKAVK6xc+iCAFaAMRQBYUTP6ICgVoAAmABp7L5oRHXybLDroDKws +Dcwo7BYBKlAEgABa1MCLERx7Ge18lRpQBIAAWtTc2kBa1L+ESw8CAP6ZbA3gO+UAhDrsMgsiAZGA +AGXAQPRhZhWgAI4AibvTDw8CAGSfPW0ICumSCyzYBIAAZJ8vY//ulMucTMDQnTqOOcDw7zYIJwFB +gADEgvhgph2v/KYAicvTD9MPZJ/YbQgK6ZILLOAEgABkn8pj/+6JO2Wf1vpgCBXgP/UALzQFLmJ0 ++tFoFaAMBQD/bwANsA0VAFtAuBl7k4if+R/gFaA75QD5IeYVr/tSAAAAAGwQECUiCCggBQ8CAPSh +CBWgKtUA+wAYTCIAnQCJJyokBdMP+yQAFe/MBQD9YAQFsAYFAOaVFCXRAQAAmpnqlggpUASAAFrU +fBd8EvBuIA3gCkUAHXtnKUAMI3Jo6HJgIPBBAACW4JbhluKW45bkluWW5pbnluiW6ZbqluuW7KmI +5uYNLEZCgACoMysxLpbulu/9YATkYgCdACxABcLT/YAEfGIAnQAeexgceyqNMB97F58UnBqeFv2g +ABawDkUADt0CnRUqMAcKCkEAqhEKugIMqgL6IQYVoA81AAnqMBx8GZkZlhsuQCYYfQIben0O7QkI +7gLuFgwu7wKAAK27rLuIUJ8dmB4mFD3uIgAg0SkAAP4iJhWgDGUAWFCx6xwQKdAEgAD8AIIdoA0l +AFs1P8CkE3wBGHr0LFIVhFjoAAUJyASAAAkCYQkCYQkCYQkCYR18CBl7Rxt87CrWP+vVgCHQKQAA +6ckCAVmhAAD5p8YV4AxlAFhQmhh7RyiCjepEAAnYBIAA/ACCHaANVQALgACDKsk78AA4DaA05QAA +2jBbtHGDOMg5KTAFdJnwgzhlP/SDK2QxPf73agWgVmUA/iKmFaBF5QCJNy+ZFCowBeSSCSeBUYAA +dqEq9UAG7GIAnQDlNAUp0ASAAFrUEyhxf36HG81LYADCAAAAAAD//1gNoAQFANowWzXqYACtAABk +QKgsEhWNQ45CiUCKQf5hBBXgOyUA/iLmFeeZwQD4IsYV56oBAPoihhWgKAUA6jIALAIKgAD6IAYV +oO6dAPggJhXgClUAWFWKK3F/KhIX/2pgB1P89QB8oWAtEhZo1ihkQEjsEhQqWASAAPpgaB2gj0UA +/oEEHeAOFQD+YqYdoA0FAFgV/WAAIi0SFIo3wMAPAgDr1AAFUIEAAFs4QvVAaB2v/voAKzr/e6EO +gztlPwbAYPJBaBXgAL4AjTf9pAAVr84FAP+ABAYwDgUA7tUUJmEBAACc2f2hBhWv/0YAAAAAAAAA +AOsiDCGBSYAAyrQpsgsPAgAPAgDInm0ICemSCyzYBIAAyJFj/++Tu5s8livRD9EPAJMslivRDwAA +bBAEiScr+sDjkg4k0IEAAPtABAVwK2UA6yQFJVEBAACamfshBhWgCAUA6JUUKVAEgABa07YsMRGC +KrHM7DURIQFpgADwAGANoCPVAAAAAAD6QGgdoAsVAFv/HiIiCcgrLSAFc9npgillL/TRD9EPAGwQ +Ghh7LSkKFegAFQjABIAAbZoCCACKHXxWHHxWDwIABNw5LBYAKyIA+H/iHeAKFQD4IQQd4Ay1AOoU +GC3eAoAA7LsCANBlAAD6ICYV4Aw1AOwUEyHZPQAAWE/6KzxM+iOgFaAMNQBYT/fAoCoUMSoUMvom +Zh2gCyUA6xQwIgNRgAAfezwoIg0qFioqFDP/7+gV4Aw1AOoUMiDw4QAA6xQwLEZCgADo/wgA2QEA +AOoUMSfo4QAA7SYAANH9AADrhx4HwQEAAOgGAAVQpQAA7oMeB9khAABYT9soEioPAgAPAgAIiBQo +FhLqJAAI2ASAAPwBYh2gDSUAW/tX0Q8AAABsEBoYeu0pChXoABUIwASAAG2aAggAiht8GPogBhXg +BRUA+kAIFaAMNQD8ImYdo/n1APghBB3gC7UA5RQYLVYCgADrqgIB2T0AAOoWASDQZQAAWE+8Khwd ++mmAFeAMNQBYT7j6AQId4B8FAP4mJh3gDgUA/iZGHaAdRQD8JmYd4AwlAOwUMCIA0YAAKEAAKUAC +9QAGXBIAnQD6JsYd4ABKAIk8CQpQC6oRBaoCKhQ2FXrRDwIALVF/+iaGHeAfJQD9oAQCMC4lAAT+ +OS4WEP2uwB2gVGUAKCAF9QAJHCIAnQAkJAUqMAUpCjn5SF4N4At1ACtRf/9ngAeQPdUALCAFdMkx +KyINKlJoCbsRC6oIKqIKZKCt66xcINH9AAD7RSAVoAxFAFhPh/olSBWgAnYAKzRS0Q8qNDD8YKYd +4Ax1ACw0UtEPAAAA6iQACNgEgAD8AWIdoA0lAFv6/2P/hQAA8z/5rhCpOQDzP/luUNkxAI5De+cT +8d/5BpIAnQAYe78vMRkI/wEvNRkuNRkWeyOEPAZEARZ6UA6oEAhEAgZEARZ7uA/YEPiGAAow+SkA +5kkBD/wCgAAPmQL4YYYV7/uaAAAAGnleKhYqGXrKKDroCKgsCYgo6BYqKVAEgABa0u8rEioceUjt +esQZUASAAFrTC9ogWtLuwJcpNFLRDwAAAOokAAjYBIAA/AFiHaBO9QD+QKYdoA0lAFv6z2P+xQAA +bBAaGHplKQoV6AAVCMAEgABtmgIIAIoberL6IAYV4AYVAPpACBWgDDUA/CJmHaP59QD4IQQd4Au1 +AOYUGC1WAoAA66oCAdk9AADqFgEg0GUAAFhPNCocHfppgBXgDDUAWE8wwFDlFDEg0NEAAPQmRh3g +DCUA7BQwIllBAAD0JmYd4BwFAFhPJyocRPqIABXgDIUAWE8kKhxM+ocAFeAMhQBYTyArTGD6LoAV +oAyFAFhPHcKAKBQ0KBQ1LzIYLxYQ5hVAKVAEgADlFFQo2ASAAPQshh3gDLUA9DCGHeD+9QD+J8Qd +oA0lAFv6kyowBfpmBh2gOZUAKTQF0Q8AbBAaGHom/vT0BeALtQD4AqId4/31AOgAFQjABIAAbZoC +CACKnxCKIPwhBB3gDhUA/iMGHaAMNQDsFBMtVgKAAAuqApoRKTAEJxwd6hwZJK01AAArPE9YTvTa +cPppgBXgDDUAWE7x5RQ1KVAEgAD2JsYdoAkVAPgmBh3gCAUA6BQxKNgEgAD4JkYdoAy1APgmZh2g +DSUAW/pp0Q8AKzxIWE7i2nD6gKAV4Aw1AFhO3mP/swAAbBAyHHssHXsj0w8swn8aeiX6oGgd784F +AOXMVC5IBIAAbUkFAwCGCQJh+EDoFewDBQCTEOYiDSY5YQAA6qJ/JhjxAADkIg4kwIEAAO6PAQs2 +QoAA6mYIB/kBAAD8gAWEYgCdAAlEEaSkjUeI3v8hJhXgOpUA/yEGFeANBQDtlRQiBSGAACnAVMLQ +9yAGlhA+9QD5oAlTYDvVAC6AVC+AVeWAVi92AoAAD+4C74BXL3YCgAAF7gII7hEP7gKx7v8K5h2o +7h0A/wrGHajuHQD/CqYdqO4dAC6EVChABfsAOfQgNaUA9QBBnGIAnQD7ACgcYgCdANog60QACeAE +gAD8ASId4B7lAFv/kdEPAAAAAAD/AAQHsAoFAOqVFCf5AQAAn5kvlgjKbyjAVPUALRGSAJ0AaIVy +9QAuFhBrFQD7DP4N4CzFAChgBf0ADZQgLfUA/QANVGIAnQDRDwAAAAAAAPcgCCKSAJ0A+SAQoxIA +nQApgFgqgFkImREKmQKxmfkLJh3omR0AKYRYKEAF+RlAFaAO5QD/ACIaogCdABp6xwqKCoqgCqAA +ANog62QACeAEgAD8ASId4A4FAFv/ZNEPAMVy9yAK02A1tQD44BG7YgCdAC2AYC6AYe+AYi7uAoAA +Dt0C7oBjLu4CgAAP3QII3REO3QKx3f0MZh3o3R0A/QxGHejdHQD9DCYd6N0dAC2EYChABfigIAMi +AJ0A+wAfwyIAnQAqwhv4AAIdr/P1AP1AABUwDoUAbeoVpIsMiQgpkGQrsDQPAgDpuQx0QAUAAPAI +fA2gCAUA6bMGecAEgADAgWSP6mADzPkgB+HSAJ0AK4BQLIBRDwIA7YBSLd4CgAAMuwLsgFMt3gKA +AA27Agi7EQy7ArG7+wpmHei7HQD7CkYd6LsdAPsKJh3oux0AK4RQKEAF+wA7/CIAnQD/AB58IgCd +AOpEAAvYBIAAWAKz6KQABSbhgADaIOw0AApYBIAA+OAABzANdQBb/xj6gGgdoIulAFgCItEPAAAA +AINqyTQqPEz6IGgd4Aw1AFgDy2SjbIM4ZT/p2iBbM4rRDwDCwXyZQi2AWi6AWwjdEQ7dArHd/Qtm +HejdHQAthFooQAX1ACWcYgCdAPsAJVxiAJ0A2iDrRAAJ4ASAAPwBIh3gDgUAW/760Q/aIOtEAAng +BIAA/AFiHeAOBQBb/vTRDwDB4n6Z4iqAaCuAae2Aai1WAoAAC6oC64BrLVYCgAANqgLveHgdVgKA +AAuqAunBLyVQBQAA+w1mHaiqHQD7DUYdqKodAPsNJh2oqh0AKoRo/yA2xGIAnQCFS8heKFE3+QAS +vGIAnQCFW2Vf79og60QACeAEgAD8AOId4B51AFv+09EPAAAAKwph+z/65WIAnQAsgGQtgGXugGYu +ZgKAAA3MAu2AZy5mAoAADswCCMwRDcwC42IKJmAFAAD9DOYdqMwdAP0Mxh2ozB0A/QymHajMHQDs +hGQh6BGAACo8TPogaB3gDDUAWAN1ZKYZgzhlP+lj/OTA2G3aE6SLrIkpkFwrsDyxiPlgCcViAJ0A +KhYs+C/gFaAJBQD5BiAVoAs1ANMPbboXK4AApJoqoEzpnAEkQAUAAPtgCMUiAJ0AGXjLKBx/KIw5 ++AAKFeAZVQBtmgIIAIoZefPpFi4iWT0AAPxACBXgDxUA/joGHeAINQD4OWYdo/71AP4shB2gDDUA +/aAAFrAOtQDu3QIA0f0AAO0WLyVRSQAAWE2X60xMINH9AAD7SsAVoAw1AFhNkvrxvAXgCSUA+D0G +HeAPBQAvFOsvFOovFOkrsn+OLfg9Bh3gDDUA7xZYIOn9AADvFOsg0AcAAO8U6i92QoAA7rsIBVGB +AADvFOklwOEAAOgmAAb55QAA74ceBfEBAADuBgAG6cUAAO2DHgXZIQAAWE12LhJY2iD8AWIdoA0l +APov4BXo7h0A7hZAJdjlAABb+PPRDwDpswZ5wASAAMCBZI6+YABke6MBwDFkPuNgAFnaIOtEAAng +BIAA/AEiHeAe5QBb/lfRDwDaIOtEAAvgBIAAW/2ML3AC8f/YFpIAnQDaQFgHctEPAAAAAAAA+x/g +RGIAnQDaIOtEAAngBIAA/AEiHeAe5QBb/kbRDwAAZF2u+QAM3WIAnQApUTYowS75AAxtYgCdACvM +WfqroBWgDDUAWAL3ZaF3KlAFxbZ7oQTaUFsytdog+oBoHeAMBQBb/S3RDwD6YGgdoXslAFgEytEP +AAAA+oBoHaAMNQDsRFIr2ASAAFgBvuikAAUbSYAA2iDsNAAKWASAAPjgAAcwDXUAW/4j+oBoHaAL +BQBYAS3RDwAAAPrAaB2gC0UAWAKz5KQADRBmAADaIOtkAAngBIAA/AEiHeAulQBb/hXRDwDaIOtk +AAngBIAA/AEiHeAe5QBb/g/RDwD1YBqxkgCdANog60QACeAEgAD8ASId4B7lAFv+B9EPANog+oBo +HeAMBQBb/Pz8gLAV4A9FAC9EUvyGBh3gTjUAftEEw48oRAX6gGgdoIt1AFgBptEPAAAA2iD6gGgd +4AwFAFv87vrAaB2gCxUAW/wE2mBb+4frYggrUASAAFv7Z9EPANog+oBoHeAMBQBb/OOKaFv8xtEP +AAAAAAAA+oBoHaAJNQDpRFIq2ASAAFgA3QIqAutEAAtgBIAAW/2gBEoCWAcABgAAANog60QACeAE +gAD8AOId4B51AFv919EPAAAAAAAA+kBoHaAzlQD6gGgd4AwFAFv8yfqAsBWgC4UAK0RSKkQwI0QF +0Q/aIOtEAAvgBIAAW/0BLHAC84ASVpIAnQCNc/G/xm7QEgUAHnfquBj+AAoVoBlVAG2aAggAiht5 +FZsS/oAIFeP59QD4IYQd4AoVAPokBh2gCAUA+CNmHaAMNQD94AAXsAi1AOj/AgJZPQAA7xYDINCF +AABYTLgqHCX6iYAV4Aw1AFhMteIUOSpQBIAA+iEAFeAPhQD+J4Yd4C4FAP4nBh2gCAUA/ifGHaAs +JQD8IkYVoB1FAPwnZh3gDLUA+CdGHaANJQBb+CklRAXRDwAA23BYASvopAAFAmGAANog7DQAClgE +gAD44AAHMA11AFv9kPqAaB2gCwUAWACa0Q8A2iDrRAAL4ASAAFv8wilwAvE/vtaSAJ0A2kBYBqjR +DwAAAAAAAOpEAArYBIAAARECWAB7jkcPAgAPAgAu4g4t4FAv4FHo4FIu7gKAAA/dAu/gUy7uAoAA +CN0C6kxMLu4CgAD/pgAO8Aw1AOM8BSboBQAA/cpmHejdHQD9ykYd6N0dAP3KJh3o3R0A7eRQKdgE +gABYTHHqHQEp2ASAAPtMgBWgDDUAWExsKxJZ+O/KBei7HQArFlmITBx4ugmIAXy8Dhx4uQyMAvyB +hhWgADYAAB12eQ2NAp1M2iD6gGgd4A41AO5EUitgBIAAW/0S2kBYBnPRDwDqRAAK2ASAAFgARwIq +AutEAAtgBIAAW/0KBEoCWAZqBgAAAAAAAAAA6kQAC9gEgABYANbopAAFA5mAANog7DQAClgEgAD4 +4AAHMA11AFv9O/qAaB2gCwUAWABF0Q/aIPqAaB3gDAUAW/wu0Q/aQFgGVmP9sQDaIPqAaB3gDAUA +W/woL2B7+/+1+JIAnQD6YGgdoXslAFgDw9EPANog+oBoHeAMBQBb/B7RDyp8EPrIABXgDIUAWAHd +5qBUbUAEgABqoSnqRAAK2ASAAFgAFwIqAutEAAtgBIAAW/zZKAoD6ERSKlAEgABYBjgGAADaIOw0 +AApYBIAA+OAABzANdQBb/Q/6gGgdoAsFAFgAGdEPANog60QACeAEgAD8AcId4B6VAFv9BtEPAGwQ +BCosNPpjgBXgDIUAWEwLKiw8+mKAFeAMhQBYTAcqLFj6YQAV4AyFAFhMBCosZOgyBCHZEQAA+EMG +FaAcBQBYS/7RDwAAAGwQBBZ17SgiFdMPJWKI6YgRCVAEgADoVQgJ2ASAAFviltogWs+KiinIr4Sr +2zBbvOvqRAAKf64AAIopwNDrIgslANmAAGWwkfpBZhWgACIAmrubrPxBJhXgCgUAi1pyuQyKKYko ++KFGFeAApgAAybiMuHLBFG0IDOvEAAYAcYAAjMhywQRj/+wAAMi0iimMKJy4nSgrIAXrJDAtAcYA +AI0rzt7E436xTS5idIsg+tFoFaAMBQD/bwANsA0VAFs7hxl2Yoifw//vJAUkQ/0AAJif0Q/Ekikk +BdEPibsPAgAPAgBkn2ptCArpkgss2ASAAGSfXGP/7sOvKiQF0Q8AAABsEBr47bIFrgkFAPggBhXg +BAUA9CAmFaAZVQDoABUAwCEAANMPbZoCCACKGHbgmBL8QAgVo/71AP4hhB2gD0UA/iQGHeANtQDk +FBsuZgKAAA3MAiwWAysgBOocISgECoAA9WAEGpIAnQD6SeAV4Aw1AFhLoCocJfpJgBXgDDUAWEud +E3boKCIVIzJ/w5/pJAUsRkKAAKgzJBQ5JBQ65BQ7INEBAAD6aAAV4AhVAPgnBh2gDIUAWEuPKzxI ++iCAFaAMNQBYS4yJEescCClQBIAA+Q4ADPAMtQD4IeYV4A0lAFv3CdEPAAAA+kkAFeAMNQBYS4Ar +EAItEAHuEAAg4JUAAC7EAO3EASkYBIAA+4BGHeAqtQD6QKYdr/3+AGwQBCIxAyoxAhR3uPxF4EfQ +CBUA8oT2DaAFFQAnMQImMED2DAAEcAIFAPitAAkwdykA9q0ACXBmOQAGUjjRDykwQPoMAAWwAnUA ++w0ACXCqKQD7DQAJMJk5AAmCONEPAGwQFigKhvhgG0QiAJ0AKQqH+GAbPGIAnQAXdUgkIRksIAwt +coAbdnEqcojtzAgIwASAAOsAFQ5mQoAA/UAARTAZBQDTD22aAggAih51zyqhLv9AEYwgBgUAHHWS +HXWR+kAIFeDuFQAuFBj8IEYV4AWFAOwWAC3eAoAABbsCmxEsIAf86kgF4cwBAADMEQysAg3MApwU +CuowmhWbGfjtSgXgSAUAKBUPmRgvIFIvFDEuIAUuFDL8RhAV4A8VAC8UMC0UMywiFewWDSDggQAA +i8WKxInDiMLuwgEg6QEAAJ7RmNIp1gMq1gQr1gUswgAs1gArIgArFhYqIFIqFF0pIAUpFGAoIDDv +FFwq4ASAAOYUXiFY0QAA6BRhINGhAABYSxYqHHD6R4AV4AyFAFhLEiocevpIwBXgDGUAWEsPKhx9 ++kmAFeAMNQBYSwvrLFgg0f0AAPtAoBWgDIUAWEsHKBFC9AsAArDEIQD0BgAHMNQpAPooZBWhlB0A ++IYADPD0OQDqFTEv/0KAAOoiDC7vwoAA7cwCD3eCgADv7gIKrkKAAPQKAAew1EEA/6AAFrCZAQDp +mREP/oKAAPXmAA/wuCkA/XgAFbBUSQD7JgAM9KqZAOqZAgquwoAABd0CD90CKRRk9EyQFeBIaQD+ +TLAV4IhxAOmIEQomgoAA+IYACjBVGQD+qAASsI85APSGAApwXzEA7ogRCq/CgAAIVQL0hgAKcP8p +APXmAA+wNAUABP8CLxRliywO3QINzAL8LOYdoKuBAPoRAATwu5EA6pkRDd5CgADrmQINVsKAAPsm +AAywCoUACpkCKRRmhCcoSRTkgRpiUIEAAI5JZOEQ+iBoHeAMhQBbNkkoIhUlcojpiBEJUASAAOhV +CAnYBIAAW+FX2iBazkuKKcivhKvbMFu7rOpEAAp/rgAAiinrIgslANmAAGWwkfpBZhWgACIAmrub +rPZBJhWgCgUAi1pyuQyKKYko+KFGFeAApgAAybiMuHLBFG0IDOvEAAYAcYAAjMhywQRj/+wAAMi0 +iimMKJy4ligrIAXrJDAtAcYAAI0rzt7E436xfS5ydIsg+vFoFaAMBQD/bwANsA0VAFs6SRl1JIif +w//vJAUkQ/0AAJif0Q/EkikkBdEPibsPAgAPAgBkn2ptCArpkgss2ASAAGSfXGP/7sGm+kpGHa/y +hgDAtPpKRh3v8l4AAAAAAAAA6iQACNgEgAD8AQIdoA0lAFsvCWP+48PPLCQF0Q8AAABsEAQbdcgZ +dRAVdQUedegYdRyEJy0iACiCrCRCDu7dAglQBIAA/LOGFeAMRQD4s6YV4A1VAAuAACpSnR513vgf +4h3gAgUA8oAABviqHQDqkB9+60KAACtAOixAOwi7EQy7ArG7+odmHei7HQArRDrRDxl1pxJ1oihS +piIifwmIAQmIEagijCwOzAENzAKcLNEPAAAAbBAEwHBtShGieKN0JEAAKIAA5IkOc7gFAADAINEP +AAAAAAAA9QEWDa/y9QDAIdEP0Q8AAGwQRikwVMRy9OrWBeAKJQD1IA+wkAIFAPkgCnFSAJ0AKjEv +LTCYLzEu5HVTHXg8AAAYdnn7ABdCogCdAMCX/gwAB3AMFQD/jQAMsP8pAP+NAAzw3TkA/YIADPAa +VQDzMOAN7ggFAJIVBACJmBTtdVMQwGEAAG2qAggAip0WimDyJWYdoAxFAPwmBh2j+/UAKxUU/UAA +FTALtQALqgIqFgcpYAQqHDEPAgD1IBPakgCdAPrJ4BXgDDUAWEoSKhw1+smAFeAMNQBYSg8oYhUj +UmjDn+lkBSxGQoAAqDMiFEkiFEriFEsh2QEAAPwBAh2gClUA6hRIINFBAABYSgIrPEj6IoAVoAw1 +AFhJ/o4V6xwYK1AEgAD/DgAPMAy1AP4iZhWgDSUAW/V8KGIVJFJo6YgRC1AEgAD4gABCMIulAFvg +ktpgWs2GimnJoIOrKwqKW7rn6jQACf+mAACKaYtryqfMuPrBZhWgAG4A0Q+Ju8ib6ZILLNgEgADT +D2Wf8pq7m6zywSYVoAoFAItKdrkLimmJaPiBRhXgAJ4AybcssggPAgAPAgB2wQzrxAAGAEmAAIzI +dsnyyLSKaYxonLiSaCtgBetkMC0B7gAAjWvP08Tj/2AMZCIAnQAuUlSLYPqtaBWgDAUA/28ADbAN +FQBbOX8YdFqPj8Of6WQFJ/v9AACfj9EPJ2QF0Q8AACMwWcC++n/6vGIAnQAcdg8vYE4uYE0tYEwq +ZFIoYAX4xgYdoDslAPIgBhXgClUAWE7aKGIVJFJo6YgRC1AEgAD4gABCMIulAFvgTdpgWs1BimnJ +oIOrKwqKW7qi6jQACf+mAACKaetiCyUBaYAAzLj6wWYVoABuAAAAibvIm+mSCyzYBIAA0w9ln/Ka +u5us8sEmFaAKBQCLSna5C4ppiWj4gUYV4ACeAMm3LLIIDwIADwIAdsEM68QABgBJgACMyHbJ8si0 +immMaJy4kmgrYAXrZDAtAdYAAI1rz9DE436xfC5SVItg+q1oFaAMBQD/bwANsA0VAFs5Ohh0FY+P +w5/pZAUn+/0AAJ+P0Q8AACdkBdEPAAAA+EBoHe/0agD6yQAV4Aw1AFhJdC4cEC3gAevgAiDg1QAA +K8QCLcQB7uAAKxgEgAD/gAYdoCq1APrAph2v9gYAAMP/L2QF0Q8Aw48oZAXRDwDrPHAjUNEAAPov +xhWgDIUAWElg6zxoI1DxAAD6L+YVoAyFAFhJXOs8XCNRYQAA+jAGFaAMhQBYSVfsMhkjUZEAAPzD +BhWgm4UA+mAARfAcBQBYSVAtYAwec0AvYAX+xgYd4AcVACdkUi7igCdhGfytCBWgGQUA7t0IAMH9 +AADkABUO7kKAAO3MCARBBQAAbZoCCACKGHPELMEu+YAS5CADhQAfc4cYc4X+wAgVoOkVACkU2CgW +Mu8WMC92AoAAA+4CLhYxL2AH+OY0BaH/AQAA/xEPzwII/wIvFjQN6jAtFjUuFjn86TQFoEsFACsV +bywWOCpgUioU8SlgBSkU8vjGEBWgDBUALBTwKBTz72IVIPH9AADvFj0ncYUAAI3li+SK44ni6OIB +IPgHAACY8ZnymvOb9J31LuIALvYALWIALRZG6mBSINgHAAAqtB3oYAUgyAcAAOiUICD4BwAA7mAw +IOgHAADu9CEg2AcAAOK0HiDQBwAA7NQcJVChAADrEn4p4ASAAFhJA+sSfyDQBwAA+0YAFaAMhQBY +SP7rbEYg0AcAAPtHQBWgDGUAWEj662xMINAHAAD7R6AVoAw1AFhI9esSgCDQBwAA+0iAFaAMhQBY +SPAsEaL2BAAG8OcpAPYGAAfwl1kA/SgAFLCHOQDtiBEP/4KAAOj/Ag93woAA/6YADrCHUQD9EAAU +MOdBAPkGAAxwl0kA7O4RDM7CgAAJ7gII7gL4NGQV4YcdAAh4AikVkYls/AUABTCIAQDrqhEMRkKA +APsGAAw0mZkA6YgCANAHAAAopCT6zJAV4JxpAPjMsBWgzHEA6cwRDM6CgAD9JgAMsLsZAP9oABWw +yDkA+yYADPC4MQDuzBEN38KAAAy7AvsmAAzwiCkA+QYADHA5BQAJiAIopCWMbA/uAg7dAv1E5h3g +vIEA/BEABLDMkQDqmREOZkKAAOyZAg3ewoAAC5kCA5kCKaQmjWco2RTkgNhm0IEAAI/ZZPDOKxx/ ++2ggFeAMhQBbNDMsUX/zn9fPkgCdAOQAFQDABwAA+QoAFaAZVQBtmgIIAIrudOsTWT0AAP4qhhWg +DBUA+MAIFeP99QDtFbAg0AcAAPNMZh2gDbUA7KRoLM4CgAD9JgAM8Aw1AOkWVSVRpQAAWEiO62xM +INAHAAD7TaAVoAw1AFhIiesdAStQBIAA83BGHaAMtQDzcIYd4CkFAPlwBh3gDSUA+XDGHeAYBQD5 +cCYdoB9FAP9wZh3gLiUA7hZkJdlBAABb8/3DqipkBdEP2mD6L+AV4AyFAPtoIBXgDSUAWy0EY/8m +AGwQHBhzjPbnNAXsCgUA+iAGFaALBQCbESkiFSRyaAgAiemZEQDAIQAA+IAAQnAZVQBtmgIIAIr6 +JCAVoAw1APxACBXgBhUA9iNmHaAOtQD2JAYdo//1AO8VDC7uAoAA7t0CASk9AADtFgMq2ASAAFhI +VCYUOCMVICwQASkQAvwgEBXg/sUA/ieGHaAKJQDqFD0g2JUAAC20APlgRh3iHzUA/WAmHaF4JQD4 +Z+YNoAyFAP5gBKxiGHUA+GAGPCIZ9QAqFi15MTwtEiwedJLrHAgpUASAAP+mAA8wDLUA/iBGFaAN +JQBb87vRDwAA/ClmHaA/JQD+QKYd4B1FAPaPZh2v/yoA21DzQGgd4ASFAPoggBWgDDUAWEgqihEp +cX/0KeYdqKodAJoR+iJGFaCZCQD4zQAJ8B2FAPIpxh3gOEUA+ECmHa/+GgAAANtQ+iCAFaAMNQBY +SBqNEfqHABXo3R0A7RYBINExAAD8IkYV4AyFAFhIE/wDgh3gPlUA/kCmHa/9KgDbUPoggBWgDDUA +WEgMiBH2KcYdqIgdAPgiRhWgPUUA+CAmFaA/NQD+QKYd7/xuAABsECL45lwFoAkFAJkQiS0ogmgJ +mRGpgokojCokkhnkwC5iI8EAACoKQG0IC4vMCztUaLQGjMjJxmP/7S3ABS3FCfuAph2v/74AAAAA +AAAAAPaACZXSAJ0AjyopFiwacwjrc0ERYUEAAOwWMSDo8QAA7RYwIPCVAADuFi8gwIUAACgWLisW +OOoWLSDZMQAA6xYyIVEBAADqFjMgwVEAAOgWNCFw4QAA7hY1IOnxAADtFjYhYYEAACwWN7g89GIA +FeAOBQD8YGgd4AiFANMPbYoRJtAYoucncECx7uZ5GnboBQAAjTRm0KAkTPDjPBAiWy+AAGAAkgAA +APbg1g2v/fUAwNFk39wmEiyGastr/GBoHeAOBQAn0Bim6iqgQLHd56kOd3AFAAB82eqNNGP/tQAA +90DWDe/99QDA0WTf64Zp3TD+3PwN4A4FAOz0AAeGmYAAi8zdMPqTAAXwDgUA+WAF0lAIhQBtilQm +0Bis5ydwPLHu5nFFdugFAAD24Bdzr/31AGAC5ACPKuP0AA+ATgAAYAAgyT0oMAXjMggp0ASAAGmN +74msCTlUaZTnKwqGW/w5ZT/gwKAqJHvRD9MPjTTA8OjYEQjwBIAA+CAGFaALNQBtuhMm4ACs9SVQ +TLH/0w/laRR3cAUAACjBCSjEBf5BSBXv+8oAAAD2oNYNr/71AMDhZO/iKsxM+iBoHeAMNQBYR378 +YIgV7/9eAIzIZc8wGXKnKZF/fpcGjTRj/rUAAB5yDB9yFRty7RhyIYYniSAogqyGbguZAusSOClQ +BIAA/9OmFeAMRQD504YV4A1VAAuAABpx/yqinfsOAA0w+fUAepAlK2A6LGA7CLsRDLsCsbv6x2Yd +6LsdACtkOo00/kFIFe/5RgAAAAAYcfEZcqwWcocogqYmYmgJiAHtctIcRkKAAKhmjGwNzAEdcWsN +zALsZgwjfkGAAIk0uFvqbDwszgKAAPggBhXgDIUAWEdL5WxMKNgEgAD6oGgdoAw1AFhHRioSLSgc +CPoAChWgGVUAbZoCCACKKhIuGXKvmRL8wAgV4A8VAP4kBh3gCAUA+CNmHaP+9QAuFQz9oAAWsA61 +AO7dAgNZPQAA/CBmFeAMNQBYRzIrEjEoEi8pUAEqUAAqhAAphAEqEjAvUAL/AEYd4A41AP4nBh2g +DQUALRQ5LRQ6/CdmHeAcBQBYRyQuEjMtEjIs4AAr4AEr1AEs1AAq4AIp4AMp1AMq1AIo4AQv4AUv +1AUo1AQs4Acu4AYu1AYs1ActEjUsEjQr0AAq0AEqxAErxAAp0AIo0AMoxAMpxAIv0AQu0AUuxAUv +xAQr0Act0AYtxAYrxAcsEjcrEjYqwAApwAEptAEqtAAowAIvwAMvtAMotAIuwAQtwAUttAUutAQq +wAcswAYqtAf9YMYdoCkFAPgnhh3g+PUA+CemHeAOBQD+K4YdoA8VAP4thh2gDSUA7xVEK1AEgAD+ +MYYdoAy1AOgVQiDYIQAAW/Jww9n8wKYd7/ieAMDRZd2rY/1KAABsEC4oMFRoggLRDwDrPHAjKNEA +APqgaB2gDIUAWEbe6zxoIyDxAAD6gGgdoAyFAFhG2us8XCMRYQAA+kBoHaAMhQBYRtUrPHjpMhkj +UZEAAPjDBhXgHAUAWEbPHHJJimwrYAXnceoYwASAAP1ABAUwPBUA/WAa1CADFQAdckANrQKdbCtg +DBpwtS5hGSNkUiyigC4WUCqiiKy75wAVDd5CgAALqgj64oAF4BkFAG2aAggAiiqhLvtAETxiAJ0A +HHEBHXD/+sAIFeDuFQAuFBidEpwQ/WAAFbAMhQAMuwKbES1gB/7hKAWh3QEAAN0RDa0CDt0CnRQJ +6jCbGZkVGHIU+CEGFaBPBQAvFQ8uYFIuFDEtYAUtFDIrYDArFDMjFDAqYhXqFg0g0IEAAImljaGO +oo+j6KIEINkBAACYtJ+znrKdsZm1iqAqtgCJYCkWFihgUigUXS9gBS8UYC5gMP4sJh2gDQUA4xRc +KtgEgADtFF4g0aEAAFhGiNtA+i4AFaAMhQBYRoUqHHr6yMAV4AxlAFhGgSocffrJgBXgDDUAWEZ+ +6hx/KVgEgAD7QKAVoAyFAFhGeSkSUCwRQi0RQ/wmJB3gSSEA/A0ABTC8cQD4LgAMcFkpAOiYAgqv +woAA6bsRDVaCgAD8BQAGMNlZAOuqAg5mwoAA+sGIFeCIAQD0hgAKcFlBAOxVEQxGQoAA/QYADDS7 +mQD7BgAMcMlRAPgshh2guTkA+AYABHCZSQDtuxEMzsKAAOlVAgxHgoAAC4gC62BkLu5CgADpYGUu +ZoKAAA3MAvymAAqwuxkA/2gAFbDJOQD7RgANcLkxAO7MEQ3fwoAADLsC+0YADXCZKQD7JgAMsDoF +AAqZAikUZYJsCFUCBUQC9CzmHaDygQDyEQAHMCKRAOruEQkWQoAA4u4CD/7CgAD/xgAPcA+FAA/u +Ai4UZoxnLckUKswg7sIJJoipgABk4Q36IGgd4AyFAFsxui9gBfgGIh2sCQUA+f/ozSAKBQAHAIkq +FiXpFiQgwf0AAPkDIBWgGVUAbZoCCACK8sngFaAMNQD8wAgV4A61AOMUqyDR/QAA8jYGHeP/9QDv +FVQu7gKAAO7dAgVQyQAA7RYnKVgEgABYRhMjFMj6L+AVoh91AP4tBB3g+cUA+DmGHeAIJQDoFM0l +cEUAACjgAu3gASVI2QAALZQB6JQCKVgEgAD/wBAVoAw1AO6UACVQVQAAWEYAKBIl2mD+5KoFoAy1 +API7xh3oiB0A+CSmFaANJQD4JsYVoD81AO9kBSDZ/QAA7hYmJdhlAABb8XfRDxlxbgmpAvjBhhXv +8qIAAAAAAADqZAAI2ASAAPwBAh2gDSUAWyp7Y/7mAABsEBYab9cTcQIrIAwsooADAIkqooisu+Mh +GS3eQoAA66oICMAEgAD64MIF4BkFANMPbZoCCACKKqEu+0ASLGIAnQAccCAbcCD4QAgV4O0VAC0U +GPogBhXgBIUA7BYCLM4CgAAEmQKZESwgB/rfZgXhzAEAAMwRDKoCC6oCmhQI6jCZGZgVH3Ez/iEG +FeBOBQAuFQ8tIFItFDEsIAUsFDIrIDD6JmYd4A0VAC0UMCoiFeoWDSDQgQAAiaWMoY6ij6PoogQg +2QEAAJi0n7OespyxmbWKoCq2ACkiACkWFiggUigUXS8gBS8UYP5GEBWgDAUA7hRhINGhAADsFF4h +WNEAAO0UXCpgBIAAWEWkKhxw+keAFeAMhQBYRaEqHHr6SMAV4AxlAFhFnSocffpJgBXgDDUAWEWa +6yxYINH9AAD7QKAVoAyFAFhFlSoRQvIEAAfwYzEA8gUABvBTQQDyCgAD8JNZAP4oZBWgg0kA/iYk +HaGzHQD6ZgAN8MM5AO3MEQxGwoAA6ZkRC76CgADpdwIKrwKAAOhVAg7vwoAA7f8CCzeCgAAMZgL8 +QYgVoLsBAP1oABWw2ikA51UCDu7CgAD9ZgAN9MyZAAy7AisUZPpMkBXgmmkA9kywFeCqcQDqmREN +VkKAAPsmAAywuxkA9gYABXDHOQDuzBENV8KAAOyqAg3fQoAAC5kC+yYADLB3KQD45gAL8DgFAAh3 +AicUZY4sBlUCBf8C/izmHeDegQD+EQAGMO6RAOrMEQ92QoAA7swCDu7CgAANzAIEzAIsFGaJJyuZ +FCqcIOySCSWAqYAAyM36IGgd4AyFAFsw2NEPAADqJAAI2ASAAPwBAh2gDSUAWynZ0Q8AAABsEByJ +JycxCyiZFIaZ5ICvY7sRAAAqbBn6Z6AV4Aw1AFhFPCpsHfpoIBXgDDUAWEU5LjA8ii4YcX//26AV +oAsVAO6+OQ02QoAA+UAsTCIAnQAYb5SJLSiCg+xxhRzOQoAAqYqoZi1gBY+ni2eKqP/hyBXgGBUA +67IOJus9AAB42zEYcXwI2AqIgAqAACsWLSoWLPXAMVCSAJ0AKfA+KvA/CJkRCpkCsZn55+Yd6Jkd +ACn0PtogWyqL0Q8AAAAAAAD//UQNoAYFAAAAZeQOKTBU9SA6eJIAnQBpktfBp+pkUitQBIAAW/8k +Y//HZeQLKTBU9SAnQJIAnQBpkrZgBOtl5BUpMFT1IDb4kgCdAGmSosDFLGRSKzBY9WBBtBAJFQD+ +ACIdoA0FAAntOGTQYSsyGStlGRtwrYhsKjBaDwIA+wAEBHCqOQDrb9cdU4KAAAqIAihmDCowWvsA +BARwqjEA63E8HVPCgAAKiAIoZgwqMFovYAULiAH6BQAFMDvVAOtkBS1UAoAACogCKGYML2Qw/AAi +HeAMBQAJ3DhkzxQjYRkcbs0rYAwabz8swoAeb/YqooPsuwgAwEEAAO4AFQ3eQoAA+0AARXAZBQDT +D22aAggAih1vVCqhLv1f9rRiAJ0AHG8XHW8W+sAIFeDuFQAuFCj8IMYV4ASFAOwWBC3eAoAABLsC +mxUsYAf83VIF4cwBAADMEQysAg3MApwYCeowmRmbHRhwKvghhhWgSgUAKhUXL2BSLxRBLmAFLhRC +/MYQFeAPFQAvFEAtFEMsYhXsFhEg4MEAAIvFisSJw4jC7sIBIOlBAACe0SjWAinWAyrWBCvWBSzC +ACzWACtiACsWGipgUioUbSlgBSkUcPjGEBWgDgUA7xRsKmAEgADuFG4jWNEAAOgUcSDR4QAAWESZ +62w8INH9AAD7QCAVoAyFAFhElOtsRiDR/QAA+0FgFaAMZQBYRJDrbEwg0f0AAPtBwBWgDDUAWESL +62xYINH9AAD7QqAVoAyFAFhEhiwRSvILAAVwUyEA8gYABHBzKQD+KWQVodMdAPxmAA7wkzkA7hU5 +LM9CgADuYgwrv8KAAOdVAgxHgoAA6YgCDVZCgADyCgAE8HNBAP7gABOw3QEA6d0RDM6CgAD7JgAM +sPwpAP34ABewo0kA/6YADvTumQDu3QINVsKAAAp3Agl3Ai0UdPrMkBXgrGkA+MywFeDMcQDpzBEN +VoKAAP1GAA0wuxkA/2gAFbDJOQD7RgANcLkxAO7MEQ3fwoAADLsC+0YADXCZKQD7JgAMsDoFAAqZ +AikUdYNsCHcCB1UC9C7mHeDzgQDyEQAHcDORAOruEQmeQoAA4+4CD/7CgAAP7gIE7gIuFHaJZy2Z +FOTVDWSYgQAAiJlkhQPaMPoiABXgDIUAWy/JY/yOAABl4Q4pMFT1IBdQkgCdAPk/49lSAJ0AYALz ++cAIqNIAnQAqMS79QB8UIgCdABlwiflf4tViAJ0A+sBoHaF7JQBb+7tj/Ef5wAhI0gCdACoxLv1A +HhwiAJ0AG3B++1/hdWIAnQD6wGgdohs1AFv7sGP8G/nAB+jSAJ0AKjEu/UAdJCIAnQAccHP9X+AV +IgCdAPrAaB2iG/UAW/ulY/vvZeDxKTBU9SAT8JIAnQD5P97xUgCdAGAChy3wPi7wPwjdEQ7dArHd +/efmHejdHQD958Yd7+72AC7wPijwPwjuEQjuArHu/+fmHajuHQD/58Ydr+5+ACjwPinwPwiIEQmI +ArGI+efmHaiIHQD558Ydr+4GAAAAKfA+KvA/CJkRCpkCsZn55+Yd6JkdAPnnxh3v7YYAAAAq8D4r +8D8IqhELqgKxqvvn5h2oqh0A++fGHa/tBgAAACvwPizwPwi7EQy7ArG7++fmHei7HQD758Yd7+yG +AAAALPA+LfA/CMwRDcwCscz95+YdqMwdAP3nxh2v7AYAAAAt8D4u8D8I3REO3QKx3f3n5h3o3R0A +/efGHe/rhgDaIFspQtEPLrBwDwIADwIAse4utHAtMhsI3RH5IBMpUByFAMCg///iHaAPhQBt+hGm +pKOvL/BkJEA070kMdVAFAADwAFANoAoFAO9DBn9QBIAAwKFkr+pgAG/AiG2KEaako68v8FwkQDzv +SUV1UAUAAO0WACjQBIAA+ABiHaANBQDTD22KEyOgAKbfL/BMsd3TD+85LHVQBQAAKWAF+MYGHeA4 +1QD4wKYdr+jSAAAAAAAA70MGf1AEgADAocyqY/+vAHPzAcDhZO/PLGRS+ggCHaCLZQDqZAUrUASA +AFv4OmP5+QAAAAAAAADrPEUg0f0AAPtEIBWgDDUAWEOQLxIoKBIs/wMIFaj/HQAvFigtghkcbwj9 +wABFcCvVAPegAEbwL+UA7YYZJwu5gAAYbXR9i3MpEij9P81MogCdAGP5nAAAAAAqsFwssF0IqhEM +qgKxqvtrph2oqh0AKrRc2iDrNAAKYASAAO1UAAtwBIAAW/kyY/lnLLBcLbBdCMwRDcwCscz9a6Yd +qMwdACy0XNog6zQACmAEgADtVAALcASAAFv8gWP5Ni0wOCgwOdMP6TA6Lu4CgAAI3QLoMDsu7gKA +AAndAgjdEQjdAvugDGRiAJ0A/6AMJGIAnQAvEiguFisqFirs/F9x2VEAANxwWENU2iDrEisqYASA +AO1UAAtwBIAAW/tLKRIswID5IyYVr+M+ACqwXiywXwiqEQyqArGq+2vmHaiqHQAqtF71P8hZEgCd +APrGEBXgDGUALGRS+sCmHe/mGgDccFhDPdEPLbBxsd39biYd7+IeAC6wcrHu/25GHa/h6gAvsHKx +//9uRh3v4bYAKLBysYj5bkYdr+GCAAAAACxkUvrAaB2gSQUA+MCmHeCLZQBb98tj+D8AAC0SKP2/ +weSiAJ0ALTA4KDA56TA6Lu4CgAAI3QLoMDsu7gKAAAndAgjdEQjdAi0WKXvRB/+/wD1iAJ0AGG9y +KTEuLhYrKhYq+T/3BSIAnQDaIOxEAAHZUQAA7VQAC3AEgABb+wwcbosqEiotMDgoMDkuEivpMDou +7gKAAAjdAugwOy7uAoAA+aYADvAr1QD9oAAWsC/lAPmmAA6/+kYAAAAAAADrHBArUASAAPwBAh2g +DSUAWyeNY/eEAAAfb1ArMS5/sUYYb08uFisqFip4sVoqEizAkPlDJhXv3ZYAKjBa81++PhIAnQDz +X73+UgCdAPFfvb6SAJ0ACgxD/Z/gFaALBQD9YgAMv96SACgSLS+Aci4SLLH//w5GHeANBQD9wyYV +79xyAAAAAAAA7HQAAdlRAABYQtoZblcoEijTD/kfuAziAJ0A2iDrEisqYASAAO1UAAtwBIAAW/rO +Y/9xAGwQBisgB4gnDwIACwtB5IEsZGCBAAAtiRQPAgDqggkmiPGAAPFRYA3gHyUAiKAuoDAIiFeY +Ev/AFqRj/fUAKaEI/SAXPGBOtQAoIAX1QGgd4EnVAPnBjg2gT6UA/wAG8eIAnQD5AAa0YD0FAIoS +LvrADs4B7aEefbAEgAAowQUMShGqOq6O7uxALSgEgAD/QBaSogCdACgxC4da6W1nFEMRAADodzYN +xwKAAPVgESoSAJ0AqYjqgp4j4N0AAAxMFLTM/UAVM6IAnQAmgp3vbOUbA54AAIoi6xYAJROZgACL +EsPAfLlXiCcVbuYtiRQlUn/k0k9kUIEAAIiJhoH24AADMAsFAOxUAAtoBIAAWyqBiifbMOqsICpg +BIAAWy4UjCCLJwjMEQxMAuymASXQgQAA61QAC2AEgABbLg3RD9EPAAAAAOpukRPo3QAA/gAIHeTd +HQD8ICYV7/7FAO7RFHP4YQAA6dwEK0AEgADTD22ZAggCYSggB/wgKBWgmBEA7m0xHMqCgAAKmQKZ +YC0iACoSAi9mA+5mAi7uAoAADcwC/MAmFaA7BQB7oRoqIgf6gGgd4AwFAOqsICpoBIAAWypVKCAH +1aArIQgIDEHtbrIeZAKAAP1mAA2wDAUAnGUNuwKbZAUEiQYgi51ml2csIAwqbCjnZgcuZAKAAOy7 +AgvgBIAA62YEIdlRAABYQk0qXBn6Z6AV4Aw1AFhCSeRuWxHZBQAA+qOgFaAMNQBYQkQbbKGKUYgR +J1UL/EDkFeeqAQCaUS4gB+whCCxPAoAA+MAARPrdAQD/oAAWsK4RAPVQABUx7gEA6t0CD3wCgAAP +zAIabPQLzAIE3QKdkI0gnJSblvsgRhWgPwUA/yBmFeAKBQD7IKYVoA9FAOqWBy7uAoAAD90C7ZYB +JPiBAAAFIIYPAmMFAIYPAmEdbN8M7BHtzAgEWBEAAOvGnSlQBIAAWyeQ0Q8cbLCKyPdABLiSAJ0A +GWzVDGgRqYjugp4j+N0AAA9PFLT//8AE4+IAnQAmgp1kYJOwrf2BBhXv9w4AE21YKCIeIzJ/CYgR +6DMICVAEgABbJ3vaMFsnetEP6iQACdgEgADsRAAK6ASAAFv8u9EPAAAA//bMDaAIBQAAACu8GOok +AAlgBIAAWzDpY/1/AAAAAAD5TwAKv/S6AP/1dA2gBgUA+iAGFeAKBQBYRJ8cbIWKyIsQ+V/6uJIA +nQD/9OwNoAYFAMBgwNoNrTT9gQYV7/SyAAAAAGwQBBpsph9t9i4hByggBxxsP/xBBBXq7gEA+CAA +A7CIEQDqiBAPdwKAAOjuAgu0AoAABt0CDN0CD+4CnkCGIJ1E/IDGFaALBQCbRfqA5hXgOQUA+oBG +FaAIRQDpRgMrNgKAAAhmAuZGASIQgQAAAyCGAgJjAwCGAgJhEmwODH8Rov+V8NEPAABsEAYabQ+L +LSqifwm7EauqKqIKZKAVK6xc+iBoHaAMRQBYQbv6IAgVoAAmABprt5oQ/NfKBaPrhQALqywDuygM +uyjrFgApUASAAFrFR4sQHGug7W0cGVAEgABaxWPaIFrFRtEPbBAQGmwuG2z1LDEnjS4psn8oIAfv +MSYu7kKAAK2Z+4HmDaGIAQAuITf9wCLdIgCdACYhNvfgIoUiAJ0Ajidk4O4q6RSYH+XiCSUiwYAA +mR7lFhMpUASAAFrFKighCPxAsBWgDrUA9CImFaP/9QD/DwAP8F1lAP2AI+RgBHUAD+Q5+iHoFaP3 +9QDqFhIioRmAAIlQ0w8PAgD3ACOkZ5nBAPVAIKISAJ0A6mw/HUcCgACqiC2CnvWgKvuiAJ0AKIKd +IxYQ04DlbY4Zg34AAIoi6RYVJShxgABollWOJyvpFCNSveS0umdQgQAAhennVAACgSGAACVSAfTg +AALwCwUA7DQACugEgABbKV6KJ+qsICm4BIAAKxIQLBIRWyzwjCArEhEIzBEMuwLrpgEroIYAANEP +AAAAAAAA9SAkUxIAnQAda6TTD+0ABQnABIAAbUkCCAJhGW1xLCBBHmyBJyEHDM8J6GwSH/8CgAD/ +wABHencBAO7ifyu/AoAACHcCLyEi/kgAAzbeAQD8wAATMO45APemAA69bx0A5e4RCzUCgAAG7gIW +bZzu3QIOZAKAAA3MAu1tWB/9AoAA9+YAD7AGBQCWFJcwDcwCF2v6jiAmNQqZN/xghhWgSoUA+mFk +HaBbhQDvNgYh0IEAAPpgZhXgD3UA5zYCL3YCgADv7gIBWSEAAP5gJhWgDMUAWEEowID82MIFoAkF +APhnRh3gBgUA9mcGHaAq5QD6Z2YdoIuVAOs0LCHQ8QAA7DQtIVlxAAD4ZyYdoByFAFhBGR1tc/5p +EBWgBgUAJjRE5jUlIdEVAAD2YoYVr49FAO80PCdwBQAA7jRIINhBAAD8IIYV4Aw1AFhBCvrXHAXg +CQUAKTRULCBoLDRVLiE2LjUsLyE3+mXkHeBKJQAqNGQpNS4vNS0nIAXFhvjgF4wiAJ0AxdAtJAUo +IQguOv//ABX0IgCdACYSExltCB9rUy4gByshB/ZACBXgDEUA/gIABTHuAQD5wAAWursBAO2NAg3H +AoAA790CC94CgADsvAINUoKAAPsGAAwwOgUA+QYADHCZBQDpOQgLA6YAABZtPfYgxhWgBiUABrYC +lheGHitiH5sZJmIelx32IQYVoAslAPolZh3gBgUA9iGGFaALBQArNiErNiMsNh0qNh8tNiAvNiIo +NhwYa5DoNh4gwGEAAAgghgkCYwgAhgkCYRlrhwzoEamI9ROmFaAB8gAqEhMiFheGoRJs4AYGRwJm +ApahLDYdLTYgLzYi+GOGFaACBQAiNiEiNiMWa3z2Y8YVoDIFACI2H+ISFy1ABIAACGCGCQJnCECG +CQJlG2tw6RITL1cCgACrqiSmnYmQ+PgABPA3JQD3IAp0YgCdAMPF/SAKJCIAnQAtOv8tJQguIAUZ +a/H+CsId78sFAP/ADpxgDAUAjScq3CALqgHrIg4lUQEAAJrYmtkpkn+KLIgr7NUULd5CgADrmQgN +AGYAAPkhJhWgABoAmKvxAGAN4AwFAJqMnCuIm+wmDCQAQYAAkoyYK5Kb+kBoHaALNQBb/sbRDwDa +kOs0AApgBIAA/KBoHeCOVQBYAV/RDwAAAMBQ+CHGFe/uogAAAAAA/++wDaAJBQAVaxKOWCkWFffA +CviSAJ0AKBISGms2DIgRqogtgp71oAtjogCdACiCnWSBY+MWECdT/QAAmljzAGgd7+9OAIweLcAF +/YYGHeBLNQD7gKYd7+3eAAAAAAAA+T/cY1IAnQCPJ//kABWvxgUA98AEBzAJBQDp9RQncQEAAJ75 +/+EGFa/togCKJ9tw6qwgKuAEgABbK+TRDyshFCMhEsBA6xYUJfWhgADqUkIp2ASAAPwAAh2gDRUA +WzAJJlJDLBIU5EwBIZgFAAAGMy58Sdhj/oUAKBISGWsGDIgRqYj1E6YVr/nyAAAAAAAA/+0gDaAF +BQAcbJ6NIPhBBBXgClUA+CAGFeA7JQBYRWNj/PwAAACKJy0SEcDA6qwgLtgEgABbKCr6ImYVr+2S +AACLH9og67wYKWAEgABbLx8pEhVj+uAAABxsi40g/kbEFaAKVQD+RuQV4DslAFhFT9ogWyWa0Q8A +wIDyIgYV7+qWAADAoFhC0I5YKRIV+d/0uJIAnQDAgPIiBhXv+s4AAAAAAAAAAMCA8iIGFeAMpQAM +7DT8oQYVr/peAABsEAYXa1+MLSdyf+hsWR5mQoAArHyMx/pByBWgT7UA+meQFeBGpQD9gcgVoE6F +APlHJg2gjRUACaoRqnqHp4d+fbFlLSAF/6AJFCIAnQB98hV20hItCoT9YA/kYI5VAP9gCQwiAJ0A +0Q8AAAD9YAzMYgCdAC0gBf+gFvQiAJ0A/eAMI2IAnQD3oAvjIgCdAC8KhP9gDgxiAJ0AKAqF+WAV +XCIAnQDRDwAAKcBgK8Bh7cBiLM4CgAALmQLrwGMszgKAAA2ZAgiZEQuZArGZ+YxmHeiZHQD5jEYd +6JkdAPmMJh3omR0A6cRgJQIhgAArcDwscD3tcD4t3gKAAAy7AuxwPy3eAoAADbsCCLsRDLsCK7wB ++ufmHei7HQD658Yd6LsdAPrnph3oux0AK3Q8K6AFxMD7gc4N4E4lAMPe/X/5OeIAnQD/f/j8IFgF +AC8gBfngDwwiAJ0A6iQACdgEgADsRAAK6ASAAFv+D9EPKcBssZnpxGwld5GAACpwc7GqKnRz0Q8A +K8BtsbvrxG0lAhmAACxwdC1wde5wdi5mAoAADcwC7XB3LmYCgAAOzAIIzBENzAKxzPzu5h2ozB0A +/O7GHajMHQD87qYdqMwdACx0dMRt5GntGVAEgABawzPmJAUq6ASAAOhCTylQBIAA+GTkFeALBQD4 +RuQd4AwFAAuAANogWyUH0Q/RDyvAYC3AYe7AYi3eAoAADbsC7cBjLd4CgAAOuwIIuxENuwL7YCAV +4AoFAPuMZh3oux0A+4xGHei7HQD7jCYd6LsdAPuMBh3v+3oAAAAAAMRN5mnLGVAEgABawxHkJAUq +6ASAAOhiTylQBIAA+GTkFeALBQD4RuQd4AwFAAuAACowVNMP9UAGpxIAnQAaaruLLIwuKqJ/6SIL +LmZCgADsqggNgGYAAPlBJhXgABoAmbvIkJucwLCbK4mr6yYMJIBBgACSnJkrkqsaaqyLLQ8CACqi +fwm7EauqKqIKZKAVK6xc+iBoHaAMRQBYP1f6IAgVoAAmABppU5oQHGmBKzroC6ssDLso6xYAKVAE +gABawuSLEBxpPe1quRlQBIAAWsMA2iBawuPRDwAAAAAA6zQACmAEgAD8oGgd4I5FAFgAHdEPAAAA +LcBtsd39jaYd7/nuAC7AbLHuLsRs0Q8ALzEuZf8pKDEvZY8jKiBoKTBVsar7P/jFIgCdANogWySn +0Q8AbBAEwHBtShGieKN0JEAAKIAA5IkOc7gFAADAINEPAAAAAAAA9QEWDa/y9QDAIdEP0Q8AAGwQ +CBpqUR5p4S0gB5cU5WptGsgEgAD6SnAV4A8FAOciFSpgBIAA9K/oFeHdAQDruwkOxwKAAO6ICA3f +AoAA+0AARXAEZQDrISIrvkKAAPagAELwDnUA/iAGFeCHRQDnZwwKeASAAAfvOC6Cnp0SKqJ//8AQ +o+IAnQAngp0vCgH4EIIdoA51AOhoDAOP8YAA/NKUBeAMBQAI/DgM5DntAAULwASAAG1JAggCYRhp +ui8hB/pIAAa2mgEA/aAAFrCqOQD9JgAM/dsdAOWqEQ7tAoAA/UYADXr/AQDqmQIP/wKAAAj/Ap9w +LiIAHWmrLXYC7WsKH3YCgADuTgIN1QKAAP7gJhWgX4UA/UYADXBeBQD97QAPME+FAP7gZhWgTgUA +DP45+K9QFaANBQAtdQoqdgbsavQcRAKAAAmIAhlq8C51C+x2ByFZGQAA6YgCA9CBAAD44IYVoAxl +AFg+zitcaPrkwBWgDGUAWD7LJnQ8/tQGBaAJBQD46IYd4AgFAPjnRh2gCgUAKnQ5/uWmHaCPlQD+ +5YYd4CXlAPTnZh3gCwUAK3Q4FWlAKzEmKjEnLTBALDBJLHRJLXRAKnUnKDEnK3UmKXRI9QAFxGAN +BQAqfEH6SeAV4Aw1AFg+ryssTPrnoBWgDDUAWD6rH2jcKDBFjRAeawgAiDII/Tvu3QID0RUAAOjd +EQjYBIAA/CAGFeAMNQBYPqD4EIId4AuVAPjFJg3gDgUAK3RV/urmHaBMJQD864YdoA01AC10VooS +G2lUDKoRq6okpp3RD8Cg+uqGHa/89QAsdFUrMSYrdSwpMScldS8qdS745aQd4EglACh0ZI8SGGlG +DP8RqP8k9p3RDwD85OQd7/0iAACOIpwRmRPllAAHAmmAAPzVvgWgClUA/mTEFaA7JQDvMScq6ASA +AFhDoQUPR2jyAdEPiieLESmpFCihFQy7EauZ6YPrdVCBAADsEgEp2ASAAFsp+tEPAADr3BgsqASA +AOokAAlgBIAAWy1YY/+gAABsEAYbaqYCLAkMzBGsuyuyf2Sw5/AALA2r4wEAAACLuWSw2CixGQgI +S3jp8Ya6ZG/s+gACHaAJZQBtmhGkraasLMBoLdAA7NkOdVAFAADAoPAAVA2gDWUA/YDWDe/69QDA +oWWgZ2P/5QBt2hGkraasLMBuLdAG7NlGdVAFAACCatMPZCBq7UwGIhiFAADtFgAiOHUAANsw+kmA +FaAMNQBb/w3Mrdtw+kngFaAMNQBb/wnKqIIoZS/cYAA0AAAAAAD9gNYN7/r1AMChZK+whmnAoP7W +TA3gCWUAY/9BACosRvogCBXgDGUAW/76Za/E1iDJZC5gBGjkG8Ag0Q/AYPagBhWgAgUA0Q/2oAYV +oAIFANEPAACCacor+gACHaAPNQDTD236EaSsoqsrsF0swCHryR11UAUAAC0hNixBFn3BH4IrZS/S +llDRDwAAAAAAAAD9YNYNr/r1AMChZa/iY//WklDRD2wQDvrP/AXgCgUAmhCJNCiyhuSyiCGQuQAA ++3AAFeOZgQD1ICQSUgCdAKiYCYgRqESERwubCCuwgCRCDvFgI0eSAJ0AJU0BLFGCZMRa+mTAFeJa +JQD6gABFMAxlAFg99h9qVywagKxM7vACINgRAAAutAL/4AQV4AkFAP9gBB3gDTUA71GgLlAEgABk +0Uxm0Ult2hcNATANADEt3C8t3QENATEAAgANAjAt3AEtsAAuoNLqrAEl2AUAAP+gCNwiAJ0A6cTn +J6IBgAApMQvBjfkAHqriAJ0A9CCmFeAJBQD4IcYV4AgFAPgiJhWgCgUA+iHmFaALBQD6ISYV4pxV +APyAAEYynRUA/IAARvKOdQD+gABHMm/1AK9Pnx2eFp0YnBv6kIgVomuFAPqAAEXyeJUA+IAARDJ5 +dQCpSSkWBygWCvohhhXiiyUA+oAARfAGBQDrFhAlUAUAAPqQhhWgBwUAuBr6QGgd4AwlAFg9syUR +BPxhZBWo1QEA96AAQzZVSQDmbAIu8ASAAP6gaB3vZgEA/MAYuqIAnQDgUAQCoD+AAAcIG/MAHUfS +AJ0A9+ANopIAnQBr9iyeE/WgF3/SAJ0A+iIIFaAMlQDs3DQBWAkAAFg9mY4TYAIC0w//+4wNoAkV +AAD34AjkEAqFAP9Gjg3gePUA/UAVouCvdQCeE/3gFVPiAJ0A+iFoFaAMxQDs3DQBWAkAAFg9iI4T +YAG9AAAAAAAA+eANPSIAnQD3oBPiUgCdAP4gZhWh+fUA/SATY+IAnQDaEPpAQBXgDEUAWD16jRAa +adv+IGgVqP0dAPvtRg2n3QEAGGnX+eALfSIAnQDAmP0gCyriAJ0AwKz9QArb4gCdAI4eGGnP7BID +IVgZAACbGehGgid4BQAA/Z+AFafvAQD+IcYVp8wBAOwWBCpQBIAAW992KUKJ7hIDJMgFAAD4kSYV +4ARaAAAA+aASAVIAnQAfabssEhHvRoIhUBkAAOoWCSdb8QAA/YAgFee7AQD6IIYV580BAPwiJhWg +A3oAAABq9yz54AYkEgCdAJ4T+aAMulIAnQD6IQgVoAxFAOzcNAFYCQAAWD1DjhNgAKoAAAD54AS7 +UgCdAJ4T9aALV9IAnQD6IMgVoAylAOzcNAFYCQAAWD04jhNgAH0AAAAAAAD34AcBEgCdAGvzNGTR +OZ4T9aAJp9IAnQD6IagVoAyFAOzcNAFYCQAAWD0q/iBoFaAIRQAIdwLwAPgNp3cBAAAAavQka/Uk +nhP1oAfn0gCdAPohSBWgDJUA7Nw0AVgJAABYPRyOE2AAD2jzPC1Ch9MPDwIAsd0tRofqEhEneAkA +AO8iCAgECoAA9KAFClIAnQAAUAQHCBvzAATH0gCdAGAApgAAAAAAAADuFgMoBAqAAPmgBKFSAJ0A ++iDoFaAMJQDs3DQBWAkAAJsfWD0C/iBoFaAIhQAIdwL//nANp3cBAAAAAABq8TNr8oBk0FruFgMm ++V+AAPohiBWgDHUA7Nw0AVgJAABYPPP+IGgVoAglAAh3Av/9hA2ndwEAZf9MztbAgQh3Av/9PA2n +dwEAwJ55eRX1QASxUgCdAGVcv40fyt1gABjRDwAALEKFK0KGsczsRoUl2AUAACtGhtEP+6BoHeJa +xQD6gABFMAwlAFg82Yse7BIRLf52AABpwcaNGWTfwY4VLuGuZO+5BEoC7BIELtgEgABb3aAvQomx +/y9GidEPKEKDsYgoRoPRDytChypChSlChrG760aHJVAFAADqRoUkyAUAAClGhtEPLkKNLUKFLEKG +se7uRo0m6AUAAO1GhSZgBQAALEaG0Q8pQogoQoUvQoaxmelGiCRABQAA6EaFJ/gFAAAvRobRD2wQ +JOQyBCpwBIAA3yDyz7YFo0SBAARECQxEEaQiJCJ/ZEDgLxY5+M+oBeGIBQCoKCiAgCySYCUWOCqS +aOyICApYBIAA7hY3LEZCgAD5QABFMAwVAFgvlCswMSkwMC8wNy4wNiUwNOYwNS1oBIAA6qAHL3YC +gADv7gIKrgKAAOZVAgHg4QAA5iKCLM4CgADrmQIOOASAAPphRBXhqgEA7zAzIwMhgACIZ4iOKBY9 +aJEr/SuAAVAO5QD1IATRkgCdAGmUQGnyPctqLBYz7RY1IcjpAAD4J4YV4ARGAAD14CHIkgCdAGny +HIo2+iaGFeGqkQDsFjMtE9YAABto1/vAI0xgCgUA0Q/AgPgnphWv/oYAaPHwafLtGWeYKZF/8SAM +p1IAnQAuMDjAqH6i12rn1PXALXOSAJ0ALBI9K8EXK7wBK8UXKhI5LBI37RI4KdgEgABb5N7RD2jx +qmnyp2RfpPQAAh2gE0UA/CZmFaADjgAAAChwAQeHCqSEdUtjKXAAf5nuLnACKHADKmEZCO4RCO4C ++2AABTvuAQB66dQoGoCoKCiAewOIEQjoAihlGSgSMi+BD9pg7BI3KdgEgADtEjgn+AUAAP8B5B3g +DgUAW+NhKXABB5cKpJT0lBYN4A/lAIZp0w/TD8tsKhI1DwIAKqAW6mQWI1kBAAD6J4gVoAxlAFvk +pf9djA3gD+UAiWf2JmgV4AQFAOmSDiL+MYAA+CZGFe/9agDRDwAAAAD7X/alYgCdABxl+tMP0w8M +MwEtcAEH1wqk1PSAJTriAJ0AKnAAaKIy/VqAglALtQAmIoLG7+4zAQN0+YAAtH8vFi4qEi76yQAV +4AxlAFvkh2SvvoZpZW/pY/58JiKCx4voMwEDc6GAALJ5KRY7KhI7+sgAFeAMZQBb5Hxkr5OGaWVv +6WP+UQAAGGX2iTMSZy8ognEiImipiAmIEagiiScrmRRkslqLmYewFWa692BoHaAMpQD1QBKCF3fB +AAyqEaWqKKKe/wAsA6IAnQApop3VkPCobA3gPwUAiyJktLz+/++1YgCdAIknFWg9LJkUJVJ/5MSb +ZNCBAACLmSayAfygaB2nZgEA/MBoHeALBQBbI9iKJ9sw7BI3JVCBAABbJ2uNICwSN4snCN0RDcwC +7KYBJdCBAADrVAALYASAAFsnY9EPANrQ68QAD2gEgADuEjQq4ASAAFvmuNEPAC4gBxhn4Q4rQO0W +NS3agoAACLsCm1CIIBpmi/qgRhWgicUA6VYDLEYCgAAMiAKYUX9xGYonLRI3wMDqrCAu2ASAAFsj +tO4gBy0wBIAALCEIDg1B62gQHuwCgAD9hgAOcA0FAC1WBQvMAixWBAYEieUgFwLQoQAA+qDGFeB8 +RQDsVgch2VEAAFg7rhdm2Ygt0w8ncmgJiBEPAgD44ABDsMulAOs7CAPRoQAA+ibGFaAMZQBYO6Pq +fEgh2PUAAPonRhXgDDUAWDueG2XMHGVj7WcYG9AEgABav1DacFq/MysSOvrDIBWgDDUAWDuVKzxB ++sOgFaAMNQBYO5IjEjaIYfrAaB3gB0UA+kBoHaCsBQD8oABGN4gBAPjAJhWgDeUAW/miFWY0H2bh +HWYqFmbbHmbo/IYADvAIBQCYb5humG2YbJhrmGqYaZhomGeYZphlmGSYY5hiKGYBmGDn5j8p2ASA +AP/QBB3gDGUA7eY+I1ApAABYO3MoUo3qEjUrWASAAPwAgh2gDVUAC4AA2iBbIODRDyoSPSmgOLGZ +KaQ40Q8AAAAAAAD/9owNoAsFAB9l+o/4KhY+9+AZ4JIAnQAMqhGlqiiinv8AGruiAJ0AKaKdZJNO +HmXwsPub6PUgaB3v9mIAKxIz6hYAKuAEgADvFAAO0ASAAO4SNC9oBIAAW+HCZat5ihD1X9ugEgCd +AB9meSPyaAmoEagzizeLvimxDCmcAflhhB3gKFUAKDQFL/F/8f/aT1IAnQAiMgpkIhj4zLoF4AsF +APogRhXuCgUA6hYBIMBBAAD4AAoV4BlVAG2aAggAiupmphDgIQAAKcACKMABKhYE/kAIFaAPRQAv +FEAswADvFCgg6KUAACjUAenUAiDAEQAAK4AALNQA+wAwFaAMBQAsFCMsFEH8KEYdoA+1AOwUQy92 +AoAAD+4C/iCmFaP99QAtFRDogAIgyLUAACuUACqUAeocRCFZQQAA+SBGHaAcBQBYOxYqHFT6SAAV +4AyFAFg7EyocXPpHABXgDIUAWDsP6yxgINH9AAD7QKAVoAyFAFg7CsKAKBRF+CiGHaAJBQApFJQp +FHQpFGSOKO9kyhlQBIAA7xUkINhBAAD/wyQVoAy1AP5E5B2gDSUAW+aBwqsqJAXRDywSPSvBFbG7 ++4KkHe/pWgBlOg/2JmgV4AQFAPAAZA2gD7UAAIM5zzktcAEH1wqk1PSABLrgD7UALnAAf+npZGnh +iWrjlAAE/wmAAOkWLyPQJQAA6hYxI8AxAADoFjAjkAkAANog+m0AFeAMZQBb41Jlr7AqEjH6aQAV +4Aw1AFvjTmWvnyoSMPpoABXgDGUAW+NJZa+OKxIv82AHfGIAnQAssAXC3P2f+/1iAJ0A+mBoHaAL +FQBb6dTaMFvpV/pgaB2gWxUAW+LyY/9cjmeO7i3hELHdLeUQ0Q8AAP/tnA2gCwUAAAAA2iD8QGgd +oBvFAFsprf/syA2gPwUAAAAbZhAfZQIcZWbvAAUNyASAAAkCYQkCYQkCYQkCYR1nGCjCqx5mFYkw +H2VP/8fmFeAKBQD7yAYVoPL1AP0mAAzwDEUA+8gmFaANVQDp5j4p0ASAAAuAABtmCSuyPwuLFHso +HBhlNxll8hJlzCiCniIiaAmIAQmIEfhAAEE/9bIAijeKrimgN7GZKaQ30Q8A2mBb6mlj/pT/6gwN +oAkFAPwmphXgCgUAWD0/H2Ulj/gtEjX6J8gVoA7lAPn/5UiQDKUA//L4DaAJBQDAkBplHAz4NPlB +BhWv8roAAAAAAABsEAQTZgkqMn9bHtXUoOghCG0oBIAA0qDRDyoyf1se0OpJMn0QBIAAYABMAAAA +AADqMn8q2ASAAPwAAh2gDRUAWyos6jJ/KSgEgABbHsXqQSZ9EASAALFYeCnU6jKAKtgEgAD8ACId +oA0FAFsqItJQ0Q8AAAAAAADqMn8q2ASAAPwAAh2gDRUAWyoaxyTRDwBsEAT0zYgFoAMVAAQkCyRC +oShBAyRBAviPAAowAgUABDI40Q9sEAguIQiMJyUgBxNmaPmCghWgP0UA9H/iHaAHBQD6d6gV4VUB +AOSCamZQgQAAhsmWEvXAIAwiAJ0AjmD6IAYV507BAP6AFiRnjgEA/wAV5GAJBQD4ICYV4ApFAOoW +Ayv4BIAA6FRYasAEgAAZZPntEgMqxwKAAKmILIKes939gB5T4gCdAC6CnWXgaWhNCRpkJ4sSCkoC +mrDI/YonixD7RAAVoAwlAFso+YsiZbHf2iDsJAAC2GEAAFspF8Ag0Q8bZLuMuJUU94AcSJIAnQAZ +ZODuEgMsRwKAAKmILYKes+7/oBybogCdAC6CnWTjirDKmrhk75UdZGGLEx9mgPwACB3v/NUA/WJG +DaAdhQDpvAMvQASAAG2ZAggCYRxmdyohB4kSG2TN+MzmBaqqAQDlkQgtVwKAAAurApvgiyCX6Zfo +l+af5Zjn/cBmFeAINQDsvAIN3gKAAAi4ApzkmOEYZL+Y4oyRwPTvvwIKrgKAAPhBBBWnzAEADFUC +lZGFE4kR9IANxpIAnQAsIAezVfTIngWh3AEA+aAAFbDMEQDriwIOYoKAAOS7AgdBQQAA5GX8HIK+ +AACf7SfmESfmEyvmEBlkphtkQpnu+8JGFeA5BQCZ74sSDKkCBJkC+cGGFeA2JQALIIYIAmMLAIYI +AmEZZJjkEgIuxwKAAKmIJYadhEDwAVwNp0TBAClgFPE0YA3gNiUAJ+YTJ+YRn+0r5hAZZI+Z7v1G +AA2wOQUAme8EuwKb7IsRGWQlKeYSC2CGCAJnC0CGCAJlGWSC5BIBLscCgACpiCWGnYRABIRX9o7G +DaA6VQB6QW6MJ/uEABXvzQUADbsB58UUJdkBAACbyevGCClQBIAAWr1KLiAVZOC8wCDRDwDrFgAr +sASAAPXADLwiAJ0AiHAIhFd/QV8ICUd/kVn+AAId4AxFAPwgZhWgCwUA+iAmFeAKBQD6IEYVr/Za +AAAAAAAmIRQkIRL+2HAN4AUFAOoyQipYBIAA/AACHaANFQBbKVIoMkPlXAEiIAUAAAhELnZZ22P/ +WwDAsPwgCBWgDSUAWyGFmhEoYBSJEOkWAi0AVgAAZY9jYAACZIEOwKSaE//0rA2gDxUAjRKM0AjM +EP2gBhWv+QYA2iBbHvbAINEPACfmEZ/tK+YQGmWQGWQ+FGPaJOYS+cHGFeA9BQCd74kRCsYCluwm +kQiNkYSQ/MAAEzfdAQD8xgALd0TBAPcgJhWgNiUAdkEGhBKEQASEV4kRCaCGCAJrCYCGCAJpLCEH +LSAH/kEEFeCYBQD5wABEOswBAPwgAAXw3REA6t0QDcwCgADp/wIOZwKAAA3MAhlkHh1juQrMAizm +HIwgJ+YhJ+YjLeYiKeYe/eYAD/A5BQAp5h8v5iD9gAAWMA1FAA3MAizmHYkSCeCGCAJvCcCGCAJt +HGQKDLoRrKr1U6YV7/imANogWx67wCDRD8DY/CBmFe/7vgAAAP/w5A2gDgUA/iCmFeAKBQBYO+0b +Y9OMuI8ViBT5n+MYkgCdAP/x/A2gDgUAwODAigjINPlhBhWv8cIAAGwQDCgxCPrIngWj+fUA+QAF +FGIAnQAeY4sbY3gKAInqY3YYyASAAAkAigkAigkAigkAigkAigkAigkAigkAioggmhL+IMYVoAlF +AOsWACxGAoAACYgCmBEvIActMQgPD0EA/xEP3QIO3QKdFAzqMPwgphWgCwUA6xYHIMiBAAADIIYJ +AmMDAIYJAmGLJwhdEQ1NAiy5FC6yCe+xFSXQgQAA7RYJJgE5gADk4B9mQQEAAHj7B9EPAAAAAAAA ++iBoHeAMRQBbJI7RDwAAAOokAAjYBIAA/ACCHaANJQBbHY/RDwAAAGwQBhxlZIU1/mCIFaAKVQD4 +xrgFoDsFAPVoAAN3VQEA9CAGFef+wQDo7gELaASAAFg+Fhhi3ymCeBxlVyiCiKaW7yAFKzZCgACm +hvzAsBXgClUA/sFIFaA7BQBYPgzCk/igBHxgK1UA+qAEPGAsRQB8UX/8r4AGUH4FAC1gBX7RcS8i +GYhoZPBu6SAEJAOZgADBd+1iDiSDiYAAyNvaYPrB6BXgDBUAC9AAiydksGDwolAN4BxlAHxRHWhT +GndRF+okAAnYBIAA/IBoHaANJQBbD3rAINEPAPrBCBWgCwUA/g4iHaAMBQD+wKYdoA0lAFsPcsAg +0Q8A9kMmFa/+NgDywQYVr/42APZAhh3v/j4AWxVdjyCfoPpA5hWv/lIAAGwQBCUkA+RJEAnGAoAA ++QYADHAJFQD5BgAMcAYFACYkAOgmASEQQQAA0Q8AbBAEG2K+GmUT/soiBeAMBQDrOAIJT4KAAPsg +AEUwDVUA/yAARPAOFQD5IAYVoA8FAFshj9Kg0Q9sEAQjJHL6QGgdoAsVAFslctogWyX80qDRDwAA +bBAEiipypg/oYkodAHoAAAioApgq0Q8A0Q8AHGLMHWKnKyAFDKwBDcwB/EFGFaB5JQD5fEYN4H0F +AH2x2vpBCBWgCwUA/AACHaANJQBbDzPRDwAAbBAIHGTrIyAH9EMoFadVAQD2v8AVoAgVAAaGOY9I +LUAEjkD/4AgV4TMBAPIgBhXgClUA9iAmFaA7BQBYPZf6QGgdoBsFAO0cECngBIAAWxLwZKCFHWTY +jCDA4S6kCQ3MApygG2Ks6RIEKdcCgACrqpmg6yAiKVAEgABbIBWPSvoOQh3geEUA+oCwFaAMBQDs +JCMniISAAHihGWhSOIonwLH7RAAVoA0VAFsgSMAg0Q8AAAAA+0PGDeB8BQB8oRb6gQgVoAsFAPwA +Ah2gDSUAWw7+wCDRD8Ag0Q/aIOxktxtYBIAAWxKvwCDRDwBsEAYcZLPtIgAqeASAAP5AkBWgClUA +9CAGFeA7BQBYPWMcZKwtMgQuMBcvMgb4YOgVoApVAPggBhWgOwUAWD1bKSAE+kRQFeAadQB6kVnI +uNogWx/kwLArJCMqMAX6DsId4HxFAP1I5g2gfXUA+6XuDaACBQD7RO4N4H4lAP9D5g2gfwUAf6EX ++mEIFaALBQD8AAIdoA0lAFsO0MAg0Q8A0Q8AAAAAAADyQygV7/6KACs0BfpAph3gAgUA0Q8AAABs +EAQkIhkfYnaNNBxkg/5i8BWgClUA/6AEBvA7BQBYPTMoMBfCmnmBF+sgIilQBIAAWx+8wKDqJCMq +UASAAFv/cMAg0Q8AAABsEAQkIhkfYmSNNBxkcv5i8BWgClUA/6AEBvA7BQBYPSEqMBfChQ8CAPlA +BAwgKUUAeaF5KUIKG2Ho9gRiHaAdRQD/IUAIUBX1AAucAixGCv6AsBXgeEUA/UyGDeAe5QD/TIYN +oAw1AHWhTPdJJg2v/PUAePERjU7I3OtCDypQBIAAC9AAKjAXdaEidqEfHWIdiUr6QGgdoAsFAP0g +BATwDAUA+IFGFeANJQBb/1jAINEPAAAAAAAA//7cDaAMRQD//rwNoAwlAGP/pwBsEAYiIhlkIHAc +ZECIKI0gLyAFjoD5ALAVoApVAPggBhWgOwUAWDzsLiAFKQpz+cmGDeB6RQD7zWYNoHtlAPvEvg3g +fCUA/cOmDaB9BQB94RX6QQgVoAsFAPwAAh2gDSUAWw5pLiAF/EAIFeAKVQD8yFAFoDsFAFg82MAg +0Q+NLo8oLgp1LiQF7vQFJoCJgADaIPpB6BXgDBUAC9AA/kCwFa//GgCJKCgKdygkBSiUBf5AsBWv +/s4AAAAAAGwQBCggcsCUCYgC6CRyKVAEgABbJQHSoNEPAABsEAomIActIA0ZZAzuYYYa2ASAAPxB +kBWnewEA6pJQJodBgAAYYj2oyCiAfSXiga2IqFUJVREFpQglXID04AipEWYBAIkiZZFCKlAN8UTQ +DeAJBQAaY/oqoIAYYdXrYeUdLgKAAPQhJhXnVQEACFUKKFKOC6oBC4AACglBaJEH+SALCdIAnQAo +UpSKGQuAAOmkAA0AVgAAYAEtAAAAFWIuaGR0DGoRpaorop73YAlSUgCdACuinZQY5LQABYhhgADI +m4ow+mEAFeOqAQBatAzaIOtEAAngBIAAWyJzDGwR9YAARnALRQDrxp0jlGUAAIonjRjAwOqsIC7Y +BIAAWx9N0qDRD8Ag0Q8l4oCsVQlVEfVAAEL//KIAHGHnjMiZGveABkiSAJ0ADGoRpaotop73oAa6 +UgCdACuinWSwzh5h3eQWCCZr/QAAnejktAAN+5YAAGAAcogn+QQAFe/KBQD7IAQEsA8FAO+FFCTJ +AQAAmYnphggpUASAAFsRUisgBPl/9gxSAJ0AYACXAABocgXAINEPAACKJ8Cw+0QAFaAMNQBbIrsd +Yk6doIwg+sdKBeANNQDrpgIuZgKAAA3MAv1AJhWgAgUA0Q8rbBjqJAAJYASAAFsmE2P/ssCw9CEG +Fa/7ZgAA//qcDaAKBQDAoFg5yxxhsIzIiRr5n/lYkgCdAMCw9CEGFa/9EgDAsB5hqvQhBhWgDaUA +Dc00/cEGFe/8sgAfYVjrIQkoyASAAP4ACB3gDiUAbeoCCQJhGWOC+iBoHaAIZQBtihIqrPzsoggk +6BMAAOzWACTIEQAAGWN7+sMqBaAOZQDTD23qD++iByTIEQAA75YHJVPxAAAcY3IYYSEaYLAIuAL5 +n+YVo+uFALC7yLQpwv95qPXAoPpAph2v9pIAbBAI+sT6BeANJQCdEZsQjzIPD18vFQQuIAwsIA0I +7hEOzAIsFQUpIQmbEO0WASlQBIAA6RYDIMBBAADyCGgd4AwFAOgMAAjYBIAAW/9E0Q9sEAQYYYfT +DwhICiiC1OokAAnYBIAAC4AA0Q8AbBAG9sEmBaEXhQAHJyinZhdjSyNm8ydyf+tjSRvQBIAAWD3O +5bQADSAEgAD6YGgdoGtFAFg9yfwAAh2gbUUAWD0B2kDzYGgd4AwFAOtUAAnoBIAAWDz777EubfAE +gAAaYLoZYzgCKAvsYzgcRsKAAKmILIbF+t6mFaAJJQApZvQrhsErZvbRDwCTEBxjMJsTH2E0G2Ez +/MFYBeAKNQDtFgIrz0KAAAuZLP0jAAzwKwUA6RYBKWgEgABYO80cYSkfYKIeYyACLQvoYyAe7sKA +AK7dKNbF/t6mFeAOJQAuZvQs1sEsZvbRD2wQBvTAsgWhGIUACCgoqEQqQvLqRvMp2ASAAFg9lvwA +Ah2gbUUAWDzNFWMKJVJ/07DrYwka0ASAAFg9jvxgaB3gDAUAWDzF77EubfAEgAAaYIQZYwICKAvs +YwIcRsKAAKmILIbF+p6mFaAJJQApRvQrhsErRvbRDwCTEBxi+psTH2D+G2D9/MDsBeAKNQDtFgIq +z0KAAAuZLP0jAAzwKwUA6RYBKWgEgABYO5ccYPMfYGweYuoCLQvoYuoe7sKAAK7dKNbF/p6mFeAO +JQAuRvQs1sEsRvbRD2wQBCkwCAVUAvEicA3v7KUAaJEP6kQACdgEgABYOvPAINEPACkwCcqR/SLg +AN/spQBj/98pMAnKmWmR1/37Qh2v/1IA/ftCHa//MgDrPAgpUASAAFsaA/1AaB2v/uYAAAAAAADr +PAgpUASAAFsaRf1AaB2v/oYAAGwQBB5iIC/iWinibtpQ6zQAB4lRgAAJyVNkkR/5IAh40gCdAIkw +jSAj4p/31IgVoCUFAPOvAAnwFwUA8SAFapAEFQDoIRouzkKAAKlmGWKyjWqMs4Jr6d0BBAFRgAB/ +xwUYX+YI3QJ7xwUpCoAJ3QJ8xwTEgAjdAn3HAgXdAn7HAgfdAv0wAASz+PUA+SGGDaAMBQB/OxJg +ABEAABlgFAndAv5g1g3gDBUAwGAYYTTD+i+GECKGEcObKYYQLYYRGWHPiIAfYX/piAEJzgKAAAmI +AgWIAg+PAgz4ORlhKOiWACMAQYAAnWqSa4mwH1/8eZY8L/KDLeKko/8J/xGv3Y3aDQxZAMwRBMgC +7Yw6BuAcgAAHzAJ51wTAiAjMAnrXBMCUCcwCe9cEwNINzAKcs8DAWDqQwCDRDwAAAAD99yIdr//G +AGwQBIkw6lQACdgEgADsYnIUqKKAAHmWF4/AiMGYs5+yjcKOw561nbSIxYnEmbaYt8DAWDp/wCDR +DxliaCmSrnGWB/33Ih2v/7IAiTIJyVNvki39JKAA0Q/FAImyjbOdwZnAj7SItZjDn8KNto63nsWd +xImwY/+dAAAAAI4zf+jZ//64Da/spQBsEAQZYOQaYXYYX532vxIF6WIBAPrGAAswAgUA9z9mFaAF +pQDTD21aDSqS+wirAeexCHEQBQAAxyDRDwqtSfxgBhXpygEA/IAGFaACBQDRD2wQCuZgIhl4BIAA +LPANlRXr8AwpkASAAONigyYcIYAAGmBlqroqoH0pYnysqqqZCZkRCTkIKZyALZETLpESLPEaKyEE +De4I5MAgZ3P9AABks8ooCiD7AB4j4gCdACkhBQuZCPmAHbPiAJ0AiyAUYLXxYAxikgCdACohBe0W +AyUhYYAA+AAiHaAJBQD9AgAMsAsFAAmLOOkWBiWcsYAAKiEFJ/EZIyEE6ncIAShBAADzQBzf0HeN +APYCgh2gDAUAnxL2YBdpUAoFAP5gaB3hgx0AbYlgiVAAYAQJAxnwz4AN6TMBACZs9gBgBAkLGfDP +cA3puwEAJmz2/WAHs+IAnQD7wAdz4gCdAPxgBzPiAJ0A88AG8+IAnQCnqea4EQzLAoAACYgC6DgC +B/v5AADoRvslUAUAAJsRkxCeFC0WA/XgE/CSAJ0AjRaPEvoAIh3gCgUADbo44hYHJRGBgACLIJIX +8WARIlIAnQAmIQXyy4AN4AsFAC7xGuIWBycQcYAAHV8YHl8rGWECKCEFIyEEL/EZmyQrJQTm/wgB +OEEAAPEAD7fQb40ADxpJ+UYADXAIpQD6n2YVoA8FAG2KDSxC+w7IAe2BQnf4BQAA8AE0Da/8BQAA +AAAAAAD0oIAV4BZFAPigCBXv/A4AtFX9f/iS4BZFAJsR8iAGFeAIlgAAAAAA//1sDaAMBQAMqkn6 +IAYVqZwBAPggJhXgDAUA6WDdEzAFAADiFgcuCxYAAIgR7IgQAZv9AAD44AYVoA+lAPZgD8lQCgUA +ixGWGOIWBymoBIAA8iAIFeABhgAAAqNJ8iAGFemyAQD6ICYV4AwFAIgXZcEWKYEEspkphQSJcADx +BAA4GgiZAul2ACeDOYAAL/z2APEE5Vz+LcAKgADomAIFUAUAAOh2ACeDCYAA6WC5F/vZAABuUmuM +GKysDAxJ+YYADnAIpQD8n2YVoAwFAG2KDSJC+w4mAe1hgHZgBQAA/N/7xG/8BQBj/4MAAAAAAAAA +9uCAFeAPBQD+4AYV4AkFAP/+MA2gH0UA+MFEBeAfRQD24IAV4AgFAPjgBhWv/l4AAABpUWOCF4gY +HGCZqKgICEn9BgAMMAsFAPifZhWgDKUAbcoNLEL7DskB7ZEMddgFAADwAFwNr/wFAAyrSfogBhXp +rAEA+iAmFaAMBQDiFgcuAMYAAI4QjXAA8QTiFgcvcAqAAA7dAp1wihWLF1g5csAg0Q8AAAAA//qE +DaAfRQApYnurmQmZEfhgAET/8jIAAACfEp4UnRP4f+xQ0gCdAOenCAjYBIAA6nQAAOARAABb/veD +UABgBAMDGf1AaB2pMwEA4xYALQkOAAAoOv94MROJE/hgCIviAJ0AixTzYAg74gCdAI0R7H4QDu2C +gAAO3QINPQL8n2YV7/S2AMbK8iDmFa/9mgAA+kCGFe/1IgDAwP4gRhXv9EIAkhf4f/pI0gCdAJYY +8iDmFa/7bgCfEp4U7RYDK9AEgADsHAQo2ASAAFv+040Ti1COFI8S/UBoHam7oQDrFgEtA74AAH2z +b3vjbOgSACGb/QAA5roRC8sCgAD7JgAMsAalAOmIAgO4BQAA+J9mFa/wYgCfEooSnhSKoB1hFY4k +72J+LV5CgACrO4y6D6oM+2FoFenuoQDtzAEPdAKAAP+GAA4wDQUAWAg7jxKNE44U/eNEFa/uXgDy +IOYVr+ulAAq6OP1AaB2v+ioAAAAAAADyIOYVr+2lAAraOP1AaB2v+coAAGwQBIkiDwIADwIA+EBo +HaBZ4QD4HQADcZnxABRg9QSUCiJChPEwABO//wUA8EAE0lQyAQDtggArUMKAAOp1AgqxAoAA9qYA +CrRiQQDv3QELNgKAAPZmAAmz4pEADt0CnYAFMwKTgixCiOZg4hyuQoAA/RAABrACBQD3sAAWvcwB +AP2GAA5wE8UA7IYDLCAEgABtOhTlIwoCIBEAAOYzCAEQBQAAIzKAk0PyAAIdoBPFAG06FeUjCgRA +EQAA5jMIARAFAAAjMqAjhh/AINEPAABsEASFIowgHWDG4iIDKUAEgAD8YAAGMZXxAPQdAAXwpeEA +9IgAA/1CkQDzoAABNFUBACPSgOZguxH4LIAAxirRDwAAAO5eZRueAoAA41MCDnuCgAAPMwINnwoO +MwIj9oT4gAAXMAQFAO4uAgy+QoAA7vaIJYExgADzAGgdoBPFANMPbToUgyTnRQoBEBEAAOZVCAIg +BQAAI1aA8UKADeACBQAkCgD9KAATsBPFAG06FSOCIOdFCgRAEQAA5lUIAiAFAAAjVqDRD2wQBCky +AA8CAP8jAAqQDAUAeZ4i6lQACdgEgABYOKHAINEPAADaMFv/xIkwDwIA6ZbhfWAEgADaMFv/i/1A +aB2v/1IAbBAEKyEE9MEGBaAHFQD0AAId4AYFAPoPAATwA0UA+g4ABXDbaQD6iAAGcbsxAG06FS5C +hOnmDXIgEQAAAFEEAH8aD2YCsVUeYHNkkHwj4oB+P3JkYG/lYG8VAWGAACcKAPjA3AWgD0UAbfoZ +I1KIwU/2jwAKfTMBAOOLB3KoEQAAdG1BsXcs5owUYGUjIQX1ZgAKMAIFAOLmgSokAoAABDMCI+aC +JeKA7t8RDMfCgAD/BgAMf/+FAA9VAQWlAghVAiXmgNEPxirRDyjigMe964gBDNfCgAAKiAL50AYV +oAIFANEPbBAEiDD/AsAK0AwFAOpUAAnYBIAAWDhZwCDRDwAAANowW/++/UBoHa//lgBsEAiJMMBA +8SAE8pAIBQAqIAz7XyAVoAkVAAqUOASYOGSAdIoz62A7FQB9gAArsX/xYAdnUgCdAIwyGV7//mCI +FeBq+QD4YKgVo+rBAPlABAbzuqEA7hYCKVAEgAD6IGYV7+gBAPYgJhWrvKEA+YAEBndvgQD2IAYV +p5jBAPggphXvbwEA9iCGFaeIgQD4IMYVp//BAFg4bPgAIh3gCAUABJg4ZIBhKTIAeZZbLCESiysM +zBAMuwKbMikgYCogYS8hB4gu7KoQDMoCgAAKmQIJiAKYMy4gVPxFhBXj/2EA6P8QD3QCgAAP7gIO +3QKdNCsgICwgISoiEejMEA3cAoAADLsCC6oCmjXAwOpUAAnYBIAAWDgPwCDRDwAAAAAAAAD//5gN +r+ylAGwQBhldpOcyACmwBIAA/oAAFTAMBQDzQABCcA0VAPjgBAPwCIUA+wzKDaflAQCUEfQgBhXg +BQUA7tU4AaAhAACLYg8CAAuLV2+1VMuxGF/oCLgKiIDqJAAL4ASAAO1UAApYBIAAC4AA7KQAAzAh +AADloAxiICEAAIkRDwIAeUO/6hIAKdgEgABYN+fAINEPAJUQ//+oDaAMBQAAAAAAAAD//3ANr+yl +AGwQBBRdOShChCRCiKKCCSIRokKiMiIgRNEPAABsEAzjMgAp0ASAACshEy4gDQMMTwvNDP+iAA43 +M4EA7LsIAeQlAADGKtEPABhfsOlc7xIDCYAAFF++BLQC9R/mFaPkhQBtCAqwRGRA1iaC/3aQAmP/ +7hJfpfQkABWgAzUAbToh4y0EISgRAADjMgAiqBMAAONGByIj4QAA41IAIRAhAACTSIgf+UAmFaAC +BQDRDwAAZFCH1BDsogEsEASAAPwg5hWgAzUAbToh5UIHIRgTAADnQgYhMBEAAOU2ACIj4QAA5W0E +IRAhAACXUBNdoxJfhxpfmh1fmB9floY0jDWONoQ3lCie+BRflR5flo8znNiNMpaon0id6BZfk/dm +AAsz4oUA5ob/IRP9AADJJieC/+eY93ET/QAAwCDRD8cv0Q8AxyvRD8cr0Q9sEBwYX28ZXK4WXT2P +MCohEy4gDfq/BgXvzwEACs0M/6IADjcvgQDsqggBBcmAAPRACoiSAJ0AaCIHxirRDwAAAABlT/QG +AIfiMgEomASAAOMMAACggQAAAwJhH19tHV9q4l9wGRuCgACTHJIU7BIGLBAEgAD+IOgVoAM1AG06 +IeVCByEYEwAA50IGITARAADlNgAiI+EAAOVtBCEQIQAAl1ASX0gVX1mEFZ4onNiOFB1fWZRYjBOE +EhVfV574nNiUWPtGAA/z4oUA74b/IRP9AABkIVYlgv/lmPZxE/0AAMAg0Q9lT1KCMeYABQCZ/QAA +8mAgFeAMJQBtygIDAmHyL+AV4HXlAOJfLhlnwoAA7BYrIZiFAAD0JGYV4AVlANMPbVoSIzz87TII +IXATAADt5gAhEBEAAOJfIxCZ/QAA8mAgFeAPZQAPAgAPAgBt+g/lMgchEBEAAOUmByGb8QAAC6wC +/R/mFaPihQCwImQgwy2C//0gBg5iAJ0AY//sAAAAAAAAZU6y5gAFAKGBAADiMgEgmQEAAPIAqB3j +DgUAAwJhLhYU7V8YGX4CgAD+I4YV4AM1AO9fFhwQBIAAbToh5UIHIRgTAADnQgYhMBEAAOU2ACIj +4QAA5W0EIRAhAACXUBJe+OVfCRCZAQAAhDWMNo43niic2I40HV8GlFiMM4QyFV8Fnvic2JRY+0YA +D/PihQDvhv8hE/0AAMkhJYL/5Zj3cRP9AADAINEPxyvRD8cr0Q/HK9EPwCDRD2wQBoowCgZX/MOg +EdAdNQBlQYjbMOokAApgBIAAW/9p06BlMXjSMNEPdtN3/M6ARd+6AQDvXu4YBAqAAPTABGWSAJ0A +wYH4wAUEIgCdAPegC6OgGSUA+MALY+IAnQBlQWTo8msihbmAAIwvLiAN7LoMDcgEgAAOqTipzAjM +CozAZMFFijH8wATcYgCdAPVABdgSAJ0AKsQWwKDzQGgd7/4SAAAA+MAHplIAnQDrNAAJUASAAOxE +AAroBIAAW/7280BoHe/9fgAAAAAAAO4gDSIEIYAA6SEIJwVhgAArIRMLmwz6YCYV7/7KAIkvLiAN +KvJrCbwMDss4q5kKmQrpkgAiA0GAAOmRCCcEGYAALSETDZ0M/GAmFe/+BgAA//3oDa/69QBooGwu +wAct8o/78mgV4e4BAK7dCd0RrburqvtIkBWv/U4AAAAAAAAA+h/iHa/9FgAvIROIMQ+JDA6YOKj/ +/kEEHe/8zgAqIROLMQq8DA7LOKuq+yEEHa/8egAAAAAAAAD4YCYV7/xCAPhgJhXv/CIA+h/iHa/7 +9gDGOhxelC4gDS0gDOQWACt4BIAA9CAmFeAKJQDyIEYV4BslAFg3INIw0Q8uIA0cXootIAz0IAYV +oAolAOUWASt4BIAA+iBGFe/opQD4IGYVoBslAFg3FP/6kA2v6qUAAABsEAQWXE2CMBdefeYiAQIB +KYAA8uFSDaC5lQAYXnlyixgUXngWXnmkJHlLCQZGCoZgCmAAyVPGKtEPGFvBqCiIgPhgJhWgAgUA +0Q/HL9EPAGwQBBxebhleboswHVuS+AZCHaD+9QD2QGgdp6uBAPlBkg2gAgUACakKiZAKkADGKtEP +AAAAAAAAZEM3K2AhKmAgCLsRC6oC+mAmFaACBQDRD2RDgypgdv9AIywiAJ0A2aD4YCYV4AIFANEP ++rrEBeAKFQDpYA0iGVGAAGSTrS/CxI5gD+4MDlQUDkQRBNQMJE0H9ILoFaSeAQAAkQTsXVMdQAqA +AOhEAQlYBIAA5KQ5D2gEgAD+gGgdoApVAFg2zfRgJhWgAgUA0Q8AAAAAAAAAZE9ZKGANZIN/8mAm +FaACBQDRD2RPRilgDWSTgvJgJhWgAgUA0Q9kTzMqYA1kovfyYCYVoAIFANEPAAAAAABkTxsrYA1k +svnyYCYVoAIFANEPZE8ILGAN6WIOJhqhgACwnfxgJhXgAgUA0Q9kTu4uYA1k40ryYCYVoAIFANEP +ZE7bL2AN6WESJ5oZgACwmPhgJhWgAgUA0Q9kTsEpYA1kkzryYCYVoAIFANEPZE6uK9KsKtKrq6qw +qpox0Q9kTp2MZ4zOLMEinDHRD2ROjy7Sq54x0Q9kQeEoYGAvYGEIiBEI/wL+YCYV4AIFANEPZE5s +KWBUC4tH+WAMK+IAnQDHr/pgJhWgAgUA0Q9kTk+LZ4u+i72bMdEPZE5CLsJVLcJUrt2w3Z0x0Q9k +TjEvwlSfMdEPZE4nKcJTKMJSqYiwiJgx0Q9kThYqwlKaMdEPZE4Mi2eLviyyEIu/rLuwu5sx0Q9k +TfiMZ4zOjM+cMdEPZE3rjWeN3o7cjduu3bDdnTHRD2RN2I5nju6O654x0Q9kTcuPZ4/+iP6P/aj/ +sP+fMdEPZE24iGeIjomKiImpiLCImDHRD2RNpYlniZ6JmZkx0Q9kTZiKZ4qui6iKp6uqsKqaMdEP +ZE2Fi2eLvou3mzHRD2RNeIxnjM6NxozFrcywzJwx0Q9kTWWNZ43ejdWdMdEPZE1YjmeO7i/hKS7h +KK/usO6eMdEPZE1Dj2eP/i/xKJ8x0Q9kTTWIZ4iOKYEnKIEmqYiwiJgx0Q9kTSCJZ4meKZEmmTHR +D2RNEopniq4roSUqoSSrqrCqmjHRD2RM/Ytni74rsSSbMdEPZEzvjGeMzi3BIyzBIq3MsMycMdEP +ZFDR2mBYGG4tYAwI3RH9RgAO8I4FAA7dAvxgJhXgAgUA0Q9kUK6OMf7EBh2o7h0A/sQmHaACBQDR +D2RQl48x/swmHej/HQD+zAYd4AIFANEPZJEjL8LEjmAP7gwOWRQOmRH5rwAM9FsFAKuZ+ThoFaTu +AQAA4QQAqxoLiAL5OGYVoAIFANEPAGRQSYkxDwIADwIAaJAB3pDuZHYrUASAAFsU18Ag0Q8AKMF+ +ZI0BKsF3KcF2qpmwmfhgJhXgAgUA0Q8rwX5kvP8twXb8YCYV4AIFANEPxy/RDwAAAC1gDC6wgADQ +BP5fAA8wClUA+kBoHeAuAQDsXGwZcASAAFg16fJgJhWgAgUA0Q+PZ4/+iPOP8qj/sP/+YCYV4AIF +ANEPiGeIjoiC+GAmFaACBQDRD4pvqaqwqvpgJhWgAgUA0Q+Lb/pgJhXgAgUA0Q8sYROpzLDM/GAm +FaACBQDRDy1hE/xgJhXgAgUA0Q8AAAAAAAD/7nQNr/n1AChgDC6wgACBBACvGg/uAv9wBh2gAgUA +0Q8AAAAAAAAAbBAEKCAKIyAIGltFwFDrIAspoASAAOo6CwwBFgAALKK5fLMXKSEC75tdZOgFAAAl +JAn8QEQd7/JVANEPKKK4AioCDwIAC4AA8UMQDeALtQD0YoYNoAkVACQkCCUkC/hBRh3v8lUA0Q8q +IAvlJAolUAUAAPpBZh2v8lUA0Q+xNHtJzcAg0Q8AAPxgaB3gChUA/LomBaALhQBYNZzHK9EPAGwQ +BudaKRlQBIAA6VQAChAEgAD9WAASMAUFAOkWASGCKYAAkhADSAIodsEidsIbWiD8oGgdoD0lAPq0 +OAWgDhUA9PhmFeAPBQBbGVTnoLRtEASAAMCk/LQuBaAbRQBYNYNgAEMCSgIqdsHAmil2wxtaEPwA +Ah2gPSUA+rQYBaAOFQDyIAYVoA8FAFsZROegFG0QBIAAwKT8tBIFoBtFAFg1c2AAAiVywogRZiBU +x58JiAMIVQHwZZAN71UBAANKAip2wYkQKXbC+rP0BeAMBQD8BkId4A4VAPqz6gWgCAUA+PhmFaAP +BQBbGSznoGltEASAAMCh/LPgBaAbRQBYNVvRD9EPghDAs/r4ZhXv/Y4AAACOEA5OAi52wQVtAi12 +wsDJLHbD+rPEBeAMBQD6s74FoD0lAP4AIh2gDwUAWxkX56ARbRAEgADAofyzugWgG0UAWDVG0Q8A +BWgCKHbCwPH++GYV7/8GAGwQBBNbMiMyfwMiDNEPAABsEAYWWhwTWcoXWhsYWc6SEvQAAh2gEuUA +6BYAJENBAAD4ICYVoABGAAAAALFE9oAFfGIAnQCJEimQIQuZEQKZAik2wSY2whpZuxtZu/wAAh2g +PSUA/gAiHaAIBQD4eGYVoA8FAFsY7+ageW0QBIAAGlmxG1mx/AACHaA9JQD+ACIdoAg1APh4ZhWg +DwUAWxjl5qBgbRAEgAAlMsLmID1pUASAAP6moA5QEuUACuowGVmpKZJFCZkKCpkKCuowCpoM91/7 +OJIAnQBtCA0K6jAKmgz3X/qwkgCdAGP/69Kg0Q/HK9EPwKT8ICgVoBtFAFg1AWP/psCk/CAIFaAb +RQBYNP1j/5YAAABsEAYTWYkYWY0XWlT2uNoFoAoFAOgWACRDQQAA+CAmFaABugAAKSAh/TgAFLAa +5QAKmQIpNsHAgCg2whpZfPqy+AXgDAUA/AZCHeAOFQD4eGYVoA8FAFsYsWagbxpZdBtZdPwAAh2g +PSUA/gAiHaAINQD4eGYVoA8FAFsYqGagXyUywgUFT3dZO7FKdqEy1KAL6jAZWW4pkkUJmQoLmQoI +6jAImAz3H/vgkgCdAG0IDQrqMAqaDPdf+1iSAJ0AY//rwCHRD3ZB+MAg0Q/ApPwgKBWgG0UAWDTF +d1GsY//lAMCk/CAIFaAbRQBYNMBj/5VsEAQXWVYmCij2RgALMBMFAPTgaB3gAgUAbToMKFGU5oEK +cqgJAACxIscr0Q9mIFMWWZXTDyNihMCA+kAEANAFFQD8oAEC3/T1AORUAwkBCoAA40MBDEAKgAAI +MwIjZoQD6jAickUCIgoDIgoJ6jAJKQxqkRVtCA8I6jAIKAxrgQRgAAbRD9MPY//pKWKECUkBCVkC ++NCGFeACBQDRDwAAbBAG7SQAAgGxgAAeWV2LMB9b7fS4EAXg/PUA+vAABXAYdQD5QlINoAIFABlc +AwmpComQCpAAZEHvxirRD2Vfyscv0Q9kT/EqUjqaMdEPZE/nG1qLK7CAmzHRD2RP2pIx0Q9kT9Ms +4iILzBGcMdEPZE/GnDHRD2RPvy1SO50x0Q9kT7ULjhR+yK8ZWeGJm2aRs5kx0Q9kT6DHr5ox0Q8W +W+cpYID9IYACV6sBAPk//EnSAJ0AK/Ku82AMKFIAnQBkoc31QA8gkgCdAMAg0Q/33sAloHqFAPzA +aB2gHQUAbdoML8GU6vELdmAJAACxIiL62tEPZi/38JUADeebQQAdWTnxLLwN4A8VANtgwMD9sIgV +4BgFAG2KDimxlLK7+yAKHCIAnQCxzPAE5A2v/LUAZE8GLFKkKlI/K1JEDKoM/WAAFb+qgQALqgKa +MdEPZE7oLVKXnTHRD2RO3i5Slp4x0Q9kTtSSMdEPZE7NkjHRD2ROxpIx0Q9kTr+SMdEPZE64kjHR +D2ROsZIx0Q9kTqqSMdEPZE6jK+JxKlLFCbsRq6qKp2SgjiqsIFsTJApMFPxgJhWgAgUA0Q8AAGRO +e1gSnPpgJhWgAgUA0Q8AAAAAAAD5P/Mo0gCdANtg/BICHaAKBQD9sKgV4B8FAG36DSixlHyBJOqs +ASXYCQAAKuKEKVLFCaoRqpkpkGTAoQmpOfhgJhXgAgUA0Q8AoAQNCxl/t9n//6QNoAklACzyrnHG +UCL6udEPKlJV+18AFa/9qgAAIvq50Q/SkNEPAGSRD/k/70DSAJ0A+mAoFaALFQBYB8/SoNEPAMAE +DQ4Z/gAABzALJQAO+zn6YCYV4AIFANEPAIoxWFx2wCDRDwAAAAAAAADqMgEiBCmAAFhfyeatmm0Q +BIAAWF/AmjHRD2RNiyhggCrihClSxeIVAC0WQoAA4pIIBCRZAADApPy2vAWgC4UAWDPixirRDwAr +8q5xvgfAp1v/H2atUtogW/7hZq1K2iBb/p1mrUL6RDAVoBvlAPwgaB3gLAUAWB9c5q0sbRAEgAAs +EQCcMdEPACJSxSjihCnQDAqEFP0IABQ3OgEA6CIIDNYCgABYM10pYIBokyn5P+xCUgCdAOokAApY +BIAA7VJIKeAEgABYXLbSoNEPijFYAmbSoNEPAADqJAAKWASAAO1SSCngBIAAWFxQ0qDRDwBsEAQT +WvQlMoAUWJcjMn+kJCVGgCNGgdEPAAAAbBAEFlsp9LGoBeAEBQD4AAIdoAcVAPbP5BWgA6UAbToq +AEAEBgkb75cXciAFAAArUDAAsQQAehqwqvpABhWgABoAmCDlXAEhEBEAAMAg0Q9sEAQUWCoiRpYj +RpfRDwAAbBAEFVgmAkkUKVaRJFKSAghDD4gR+wAEANAHNQDgNhoMAQqAAPzgAQPf+PUACHcDB0QB +BkQCJFaS0Q8AbBAG0jCJINNQ5VhPFKVEgAAYWt4ogq7xAAmIUgCdAMBAKFG4KVJbmSMoJQgvUbkv +JQkuUbouJQotUbstJQwsUbwsJQ0rUb0rJQ4qUb4qJRApUb8pJRH4QAgV4AAaAMBAepYfiiMrUlt6 +tAnwAFANr+SlAAAALFG4KyEIKlZbe8QSwUbaMOskAApgBIAAWDLUwCDRDy1RuStVuCohCdMP0w96 +3NwuUboqVbkqIQp67NAvUbsqVboqIQx6/MQoUbwqVbsqIQ16jLgpUb0qVbwqIQ56nKwrUb4qVb0q +IRB6vKAsUb8qVb4qIRF6zJQqVb9YZDocWsctUbkuUbskUb8vUb0pUbwoUb4qUbrrUbgszAKAAOn/ +AgxEAoAA6EQCDVQCgADq7gIN3AKAAPumAA7wCkUA9CAGFaALBQBYMzpYEbrmrz9tIASAAGABmQAX +WrL8tWQFoA41AC5Vuv63ZB2gDRUA/LckHeAGBQAmVbgsduRYZQeLIfFgB/kSAJ0A+lgABXe7gQBY +ZCLmoU1tIASAAClyjikmCihyjygmCy9yjS8mCVhkFipyG/FSQA3gDiUAG1gTK7B9frdzJlW9LHLE +H1fOG1qXGFqVKVG/KlG+LVG7CJkBC6oBD90BLVW7+rfEHaANBQDpVb8mBXmAAPq1GgWgDEUAbQgx +L1KAK1KIr98J/xGvuy+xLyhyxAr/Af2gIBXvnwEA77UvJNgcgAAstTomtT4mtTZ422dj/8cZWBv7 +P+9rogCdACtyTRpYGPtf7vviAJ0AK1I7/X1ADeAKBQAtUoAsUohtCBatrgnuEa7O5uU2JVAFAAD7 +X+2i4gCdAGP/4gAAAAD6AKIdoAsFAFhj4+evG20gBIAAWIu0Y/3xAClRvypRvnunEC52sy52tP72 +RhWhDwUAL3a1f5cY/vYGFaAJhQD49eYV4CgFAPj1xhWv9XoAAPa35B2v9VYAK3JNZb7ZY/7fWIug +Y/2jAAAAAAAAWGGM9UBoHa/2XgBsEASIMBlYUIwx/EGQFeeIwQDpiAoJUASAAOiCeCnYBIAA/aAA +FrAOVQD/pgAOt8wBAAuAAIkxiiL6QbAV55lBAPFDsA3gmU0AHFeDy0ApwojqIAwlgXmAAB5YPK6u +LuB9LcKBq+6u3QndEa2dLdyAjdeN3pTQ9aAmFe+C1QDRD9KQ0Q8vwoCq/wn/Ea+fj/eP/pTw9eAm +Fe+C1QDRDwAAbBAMFFfFKyAM6iANKTAEgADkAAUIyASAAAkCYQkCYQkCYQkCYRdYIBlYEfywIgXg +BQUA5RQRKecCgAAsFBDtFgEtxgKAAAioAgmIAigWAPxBkBXniMEA54gKCNgEgADogngpUASAAP2g +ABawAlUA86YADrAMRQALgACDEdMPDwIAA4NHAwMGZjHoIhEE+sBoHasiAQD6QGgd4AwVAFggTeQA +BQjIBIAA6QwADSgEgAAJAmEJAmEJAmEYV/IbWff8sU4F4AkVACkWAS0VBPogZhXhjAUA7BUFKNgE +gAD4RgAMMAwFAPggBhWgDQUAW/+c5qGYbRgEgADkAAUIyASAAPgAqB3gDlUACQJhCQJhCQJhGFff ++LPEBeAKFQCaEZkSCCgCmBD8oZAV54jBAAeICuiCeCjYBIAA/aAAFrAMFQDu3QIK0ASAAAuAAIMR +A4NH+CBoHeAzTQDwdJgN4A5VAAQAhwkCYQkCYQkCYQkCYRhXyvivlAXgCxUA+iCEHeAKBQD6IKQd +oAxFAJwRmRQIKAKYEPyhkBXniMEAB4gKKIJ46N0RCtAEgADu3QII2ASAAAuAAIMRA4NHAwMG5jD+ +aMgEgAAEAIcJAmEJAmEJAmEJAmEYV7MZWbL4IGYV4AwlAJwRCCgCmBD8oZAV54jBAAeICuiCeCrQ +BIAA/aAAFrAOVQDu3QII2ASAAAuAAIMRA4NHAwMG5jC+aMgEgAAEAIcJAmEJAmEJAmEJAmEYV6EZ +WZ2ZEQgoApgQ/KGQFeeIwQDniAoK0ASAAOiCeCjYBIAA/aAAFrAOVQD/pgAOsAwVAAuAAIMRA4NH +AwMGZjCA0Q8AjWD6AEIdoAsFAOxZihnwBIAAWDID0jDRD41g+gBCHaALBQDsWYUZ8ASAAFgx/dIw +0Q+NYPoAQh2gCwUA7FmAGfAEgABYMffSMNEPjWD6AEIdoAsFAOxZexnwBIAAWDHw0jDRDwCNYPoA +Qh2gCwUA7Fl1GfAEgABYMerSMNEPjWD6AEIdoAsFAOxZcBnwBIAAWDHk0jDRDwAAbBAE8EXQDe8y +gQDwYgAN4CQFAAKIV8qCAslTypgC6lHkoDBiW/0AAAK0O9JA0Q8AIhH//3QNoBQFAAAACCIR9J8A +Fa//VgAMIhH0n4AVr/8+AAAADi0R7Ez9IhP5AAANwjvRD8Ag0Q9sEAQSVlYiItjRDwBsEAQSVlMi +ItfRDwBsEAQl+sAFJQEkURWTIfSAAEJwxQUApUSUINEPbBAEE1lF+K4qBeAMBQAsNv4sNvwsNvos +NvcsNuwsNuosNuYsNuUsNuAsNt4sNtksNtQsNtMsNtIsNtgsNuQsNvb4e0YV7A4FAC428S428/5/ +JhWgP/UALzbw/n5GFe/y9QAiNtXye2YVoA1lAC025/x/phXgG+UA+noGFeAapQD6esYVoAg1APh7 +hhWgGQUA+H6GFeP49QD4fwYVoBoVACo27htY0fp9phXgHbUALTboElgaH1kaLzbh8nvmFaAOFQD+ +fEYVoAL1ACI2/xxZFCw269EPAAAAbBAE51YcGS+CgAAWWRCnV5NwplUkVn/RDwAAAGwQBBhXboiA +GVkLE1dsCYgB+EYACTAUBQAEIgLyYAYVoAIFANEPAABsEAQYWCYaV2Mmglopgp8ngqR2KwyimQmZ +EfjgAEPwABoAwHDDyiymECOmEcO7K6YQJKYRG1f4iqAcV6frqgEJbgKAAP1GAA1wKwUAC6oCDKwC +Bco5G1dPwCDqtgAjgFGAAJR6k3vRD8Ag0Q9sEAQbV0f4rHIFoAoVAPYPAh3v+fUA67zgKQz4AAAL +tQL2AAIdoBwFAG3KDC1RlOfRCHKoCQAAsWbHay+ChABhBACuGgniAwL/AQ/uAv8QhhWgATYAAAAA ++EAFKVAGBQD1YGgd4BMFANMPbToMJFGU50EIcqgJAACxZsdrLIKE+sAEANANBQDg3RoLAQqAAACu +GgnuAw7MAQ3MAiyGhPNgaB2gBQUA/gICHaCWhQBt6gwvIZTm8QhxEAkAALFVx1sngoQTVfEAUQTk +MoQhmHEAAOMygS0wCoAACWsD63cBCiZCgACkMyIwNwdmAvcQhhWgBCUABCIC8mbmHaACBQDRD8Yq +0Q8AAABsEAj+sUwFrw0FAPqw0gXg/PUA4ioLC0gEgADzQACFcReFAOcnKA1XAoAA66oIB0PrAADo +dwgJtwKAAOdmCASDWYAAH1iXAikL6FZgHM7CgACrmRtYlPs4phXgCyUAK3b0KHb1KPF/mBYolsEo +dvYv8X6aFA9ILg9PLOxZCAfYBQAACL85G1iIDZkBGFXKBZs5mxd/g34LjBQAzREN/QItpsksZrMv +ZrTRDyji/Sly9i9y9eoWBCxHQoAACYgsCP8onxX14AVLogCdACRmsupy9SpYBIAAWDK8/CCoFeAM +BQBYMfPwqzAN4Pn1APigAEL/CAUA6FUBBYVJgAD8IIgV6KUdAACsEQy8AizWySpmsytmtNEPHFhl +ihaFFxlVpiji/eQWASloBIAA+CAGFeArBQDlFgMsR0KAAAqILOmIKAnwBIAA+CBGFaAKNQBYMMMZ +VZn8IIgVqKUdAACrEQubAivGySpmsylmtNEPAAAAAP6AaB3gCjUA/CCoFaArBQDsFgApaASAAOxY +ShnwBIAAWDCy9CCoFa/80gAVWENlv1oYWD7ogv0paASAAPQgJhWgCRUA6RYAKfAEgAD4/sgV4Ao1 +AOxYPB34BIAA5RYDLEdCgAAJiCz4IEYVoCsFAFgwn8CR/CCIFailHQAAqxELmwIrxskqZrMpZrTR +DwAAAGwQBvaqXAWhF4UABycoB2YIF1flI2bzI2byJ3J/61fjG9AEgABYMmjltAANIASAAPpgaB2g +a0UAWDJj/AACHaBtRQBYMZvaQPNgaB3gDAUA61QACegEgABYMZXvsS5t8ASAABpVVBlX0gIoC+xX +0hxGwoAAqYgshsX63qYVoAklAClm9CuGwStm9tEPAJMQHFfKmxMfVc4bVc38qowF4Ao1AO0WAivP +QoAAC5ks/SMADPArBQDpFgEpaASAAFgwZxxVwx9VPB5XugItC+hXuh7uwoAArt0o1sX+3qYV4A4l +AC5m9CzWwSxm9tEPbBAIE1UkJiAHKTKGIzKIppkJmRGpM4M3iCKDPsiEwCDRDwAAJz0BKHGgZIGz +KXGCZJGtKirD+mAARTJb5QD6YABF8AwlAFgrIh5XhC0ygv+lvg2gCSUAKXGg8yAYB9IAnQDChJgQ +8yAal5IAnQCYEPMgHUdSAJ0A+CBmFaACOgAqKs/6YABFMo0FAK09/CBGFeAOBQD/qOYdoA+lAC/U +TP+pph2gKBUAKNRJ6dRKIdgRAAD5qWYd4AwVAP2pxh2gGbUA+akGHeAMhQBYKwEpcaDzIAuP0gCd +AMOGmBHzIA2fkgCdAJgR8yAP11IAnQAZV7cvjNoPD0gJ/wKJEpgT/yjGHej/HQAvlEWJExdVr4sT ++GAARPKKBQD7IABEsAgFAOiUISXYxQAA6JQiK0cCgAD0wAaSFLsdAAeICCqCnvtAHYviAJ0AKoKd +ZKNIiRMbVSkpnDH6AAgd5JkdAOkWBC1ABIAAbZkCCAJhjxQsEgMdVZn4q+YF4qsVAAs7CCmmACgi +AC2mAu1UnxZwSQAA7qYDLEYCgAAI/wIvpgEfVUn+cAgVoAkFAOmlCiZgCQAALKUL7aYGK0QCgAAI +7gIP7gLupgQlUIEAAFgqwesSBCtnAoAAp8wrxp0qMo6xqio2jgUNR/W/8bESAJ0Aiif6gGgd4AwF +AOqsICpoBIAAWxKpwCDRDwAAGlVHiaj3IBdgkgCdAOwSAytHAoAAp4grgp4szDEMTBT9YBdbogCd +ACiCnWSC4rCbm6jqhAAMeIYAAGACUQAAjhIqKt36YABFMBgVAPnLBh2gCxUA+8tGHeANBQD9yyYd +4AxFACzkVy8wJu/kWyHYoQAA/cuGHeAM1QBYKpMpcaD/+UANoEiVAAAAAAAA+GAARzKqdQD7wABF +Mo8FAP/AAEdwCGUAKOQi+cQmHaAJFQD5xIYd4A0FAC3kIy8wYu/kJSHZkQAA/cTGHeAMJQBYKn6I +ESlxoPkBABWv+BIAHFQ4+GAARDGLBQCrO/t8kBXiqnUA+wAARTKNBQD9AABEf/mlAPs5AAzwDRUA +/QSGHeAHRQD47wAL8A8FAP8EZh3otwEADLsC+wRGHei7HQArhCEpMHTphCUj4/EAAO+EJiHZ2QAA +WCphiBGyefkAAER/9mYAAAAAACoqy/pgAEUyjAUA/GAARj/55QD5iKYd4BiVAPmIxh2gDwUA/4jm +He+OBQD/iQYdr80lAP2JJh3gC5UA+4lGHeEL5QD6YABF8BxVAFgqSSlxoP/yxA2gOPUAAAAAAAD4 +YABFMo0FAP1AAEbwCWUA+aRGHe+PBQD/pIYd784lAP+kph2gCAUA+aRmHa/75QD7pCYd4Ay1AP2k +xh2iq3UA+0AARXFL1QD6YABF8AwlAFgqMIgQKXGg+QEAFa/xWgD4YABEsqp1APsgAEUxhwUApzf2 +/JAV4osFAPsgAET/jgUA/ySGHaAIxQD5JMYdr80lAP0kph3gCwUAK5QjHVbcB3cJ/OCgFaFbNQD6 +YABF+MwBAO3MAgO4BQAA/SRGHajMHQDslCEr4ASAAFgqEogQtnn5AABEf++aACoyjytsGOqsASlg +BIAA6jaPKVAEgABbE3MFC0f5f9tBUgCdAIonwLD7RAAVoAwVAFsVjh1VIJ2gjCD6rYAF4A0VAOum +Ai5mAoAADcwC/UAmFaACBQDRDwAAAAAAAAD/8UgNoAoFAMCgWCyjGlSIiaj5P+hQkgCdAP/0nA2g +CAUAwIDA6g6eNP9BBhWv9GIAAAAAbBAE9AAiHeAHBQDmICIhhYGAACggLRNT1Q8CAOUkXSQBYYAA +JDKEIzKIDwIApkQJRBEEMwgUVeMiMR8EIgHz4AABMMQFAAQiAiI1H/MAaB2vCgUAFFUJA2MRpDMp +MoLAwQjCOfsgBAS3uAEAArU5CVkCKTaCJDKAcU4bJTKAGVPzGFQCApc5CFUBB1UC9HAGFeACBQDR +Dy4yhAruAQ5eAi42hCsygB1T6RxT+ALXOQy7AQe7AvpwBhXgAgUA0Q/AgPZLph3v/h4AAAAAbBAG +JDAAFVOA8IRgDeAGFQD0gA+4kgCdAPSAEFkSAJ0A9IAQ2ZIAnQDrVm4YBAqAAPSABCoSAJ0A+gCC +HaAbhQDsVmcaaASAAFguzMYq0Q8AAACIMfpAaB2gCSUAbZoy+GAABLS4HQD4ZAAGM9hBAPtfgBWj +6GEA+UnmHeSbHQD9ScYdpJkdAP1Jph3kiR0ALqRMKDAB8QALdhIAnQDoUn0iB3mAAPSABziSAJ0A +9IAG+RIAnQDAINEPJFJ/LyAiLVKBpP/uMAMv/kKAAK/djdcO5AkvMAWN3i8kXywxAw1PCSwlMCkw +BPhLxh3vzAEALPVvLCBfIxqA86AARXAYtQD7JgAM8cwBAOn1cS5mAoAACMwC/e4EHaALBQDrpAUn +SAUAACmk5CogXv/+Ah3vDAUA7ukJBQvxgAB6wA0KihTkoBxl2CEAAHrI8XrwC7S78AAYDaSqHQCx +uwoaFGWv9ywgX6nZ8yAARPL7AQD9+AAXsswBAA/MAiyUBiohMAqKFCqUByghMPkhBh2gAgUA0Q8q +IFyEIMAw6EQMBQLBgADaQPpgaB3gDAUA8mAAQrANBQD0qZAV4A8FAP4gJhXgDgUA/iBGFeBpRQD4 +IAYV4A8FAFsMgWagGwZcN+pEAAnYBIAAWwxl5qAKYZgFAAAoIFx4M6spIC3Ln/pAaB2gCxUAW/9M +0qDRD8Ag0Q8sMAfsJFwh2CEAAOsGAAFRMQAA+oJoHa/5wgAAuD7uJgABaVEAAPyKaB3v+XYA0qDR +DwAALDABwOL4AQIdoA1FAP2ABATwfI0A+YAEBTG8jQDtuwENV8KAAOh3AQzPQoAA/4AEBrCMAQDq +mQIMRkKAAPrmAAvyrI0A7qoBDu7CgAD9BgAMcMw5AAyqAgp3Agl3AvjmAAuwCwUA5yQtKVAEgABb +/yFj/d4pIF+k3/PgAEfymQEAKfQGKCEwCIgUKPQHLiEw7vQILZAEgADRDwAAbBAEG1LKjCAjsn8D +zAz7cCgVp8wBAKPDCTMRo6ODNyuyfYM+rLv9aAAVsA4lAOuqCAGgBwAA+JBEFaGFBQD0YABC8A0V +APqWJBXgDAUA6UGDJAdBgADsVMYkjR0AAGiSbPUgBZmSAJ0AKjKWKFDGsaoqNpbpRYMkALmAAPpA +aB2gCwUA/AACHaANJQBb/agbUwrsVZ4ZUASAAFgrgMAg0Q8vMo4qMon34ASaUgCdAC8ylgv4Lujc +OAUFmYAAKVDGLTaW7kWDJP5BgABj/60uIDVk4H8vIElk8HkoIF1kgHMuMpYL7i4O3DgsVMYrQa7k +sGxl+/0AAA8PT+9FrieDCYAAKjKWKFDGsaoqNpbpRYMke/GAAGP/Yywyli9Bri1UxitQxu/pOQZg +BQAALDaW6UWDJfrhgABj/0HAINEPZa97KDKWsYgoNpb4kGQd7/y+AAAAAPy4xh3v/lIAAAAAwLBb +/r3//mgNoAk1ACpQxrH7KzaW6UWDLXgmAABlzvxj/wwAAGwQCBlSjywgIiqShimSiKyqCaoRqpmD +l+tVXRT4wQAAnxGDPuyUByThYQAA/CBGFaHoBQD4YABEMc0FAPxgAEbxrgUADj4I7pYQKVAEgADt +lhUksIEAAOiWGiShEQAAW/7QG1VL5BYEKVAEgABb/szrVUkZUASAAFv+yetVRxlQBIAAW/7H61VF +GVAEgABb/sTrVUMZUASAAFv+wetVQhlQBIAAW/6+Jz0BLHGxK3GwGlL3DLscC6o2+vXkHaAFFQD0 +YyYd4AQFAPRg5hXgDMUA5DQYIdhhAADkNggp0ASAAFgoZpcTJGUCJGQAJWQB42YCIfgxAAD+wGYV +784FAC40TvRphh2gCQUA9GmmHeAKBQD0aeYdoIwFAPQgBhWgDYUAbdo7opsusESNEKk4+8BABTPu +AQD/oABGt6oBAO0WACS4J4AADN8RnxAtsEwthFQtsEysiCmExe2EvSTIBQAArDf+IAgV4TmVAOk6 +CAVwBQAALjRc/mKGFeLuAQDs7gII2ASAAP73Bh2gDEUAWCg76zxMIbCRAAD6wGgdoBxFAFgoNioa +DvpgAEUxO4UA+mAARfAcVQBYKDGOEQ8CACTkDCTkDSXkDiTkDyTkAyTkACXkASTkCyTkBS0wTvXB +Jh3g/TkA/8EGHeDdMQDt5Aoh4UEAAOw2ayHY4QAA6zZtIdDxAAAqNm8kNmgkNmkkNGz0baYd78kF +ACk0buQ0byHAoQAAKDZuKDZqJjZs/kWwFeAGhQD2biYdr46FAO80cCHZsQAA/vomHaAMZQDtIC0h +sYEAAO100itQBIAAWCgH9iCIFeFK1QD6YABFMVsVAPpgAEXwDCUAWCgAJHQMJHQNJXQOJHQPJHQD +JHQAJXQBJHQLJHQF+m3QFaDbpQD6YABF8YIFAKIy9OEmHeDKOQD84QYdoKoxAPrhRh2vyQUAKTTc +5DTaIcHBAADoNnMh+ZkAAO82dSHxqQAALjZ3JDZwJDZx5jZ0IemRAAAtNnYtNnIsIOQlNNvkNN0h +sckAAP2AAIYwDUUA7cwJC1AEgABYJ9r2IGgV4Vo1APpgAEUxi1UA+mAARfAclQBYJ9SIEiwK3qw8 +JIQFJIQLJYQBJIQAJIQDJIQPJYQOJIQNJIQM+HuQFeCtZQD8YABG8K6lAK4+9QEmHeCpMQD7AUYd +oJk5AOmECCH52QAALzZ6LzZ+JjZ8JDZ5JDZ4LjZ/LTZ9LDZ79FimHeALdQArdaAkNokkNoQkNo70 +8GQd4AIFANEPbBAEFFGjJUKEJEKIolXnU7YarkKAAKVEJkEfI0Ed9KW+BeBIBQD2wAQDcIkFAOZF +HyHkxIAAKkEeeKcm6kEfKTTCgAClZStSgMAh6KoCCAQKgADxYATI0gCdAPKFsBWgAkYAAyYR9MAA +QvACBQAo+gAtUoQsQR0I3QH8RgAO8AIFAO1WhCZgiIAALkEeeecXL1KAK0EfwCHpuwIHjXCAAPKF +sBWgAVIAJ1KCE1GmCHcBBycCJ1aCIzB94lFbEfyugAAoQR/iYggEYEiAACMilBRROAQzAiMmlNEP +KCKUGVGRCYgBKCaU0Q/RDwAAAAAA+oPkHa/96gD6g+Qd7/6yAGwQBPBrkA3v/PUA9IAF2RAFFQD4 +nwAV4AgFAPiiAAxwCQUAGlF0HVEp+gAiHeAEBQD2FwId4B4FAOcnAg6YBIAAbeoMLjGU5+EtcZgJ +AACxRNPQ9BYCHaAfBQD0RgAJMAQFANMPbfoMJTGU4lEucZgJAACxRNEPAGZP1SaihABBBOCeGgoB +CoAAAL8aDP8DD2YBDmYC91CGFa/+4gBmT9QiooQAQQTggxoKAQqAAAC1GgxVAwUiAQMiAiKmhNEP +AMCA//10DaAJBQDAgP/9TA2gCRUAbBAEiScpkg4okjMiICIrCgD5ACAVoAwFAOiWMylQBIAAW//C +HFJpAyoRDKwILsKEL/oAD+4BLsaEK8KAHVFvDbsBK8aAC+owGVDsKZJFCZkKC5kJC+owC5sMarEO +bQgIDeowDZ0MatECY//wG1EUHVD5ra0s0oAeUWYqvBwqooEOzAIs1oAssoTrsoYl8gEAAK4uLuCA +orvizAgN3kKAAKuri7cJzBGsquuyDid4JoAAwCDRDwDA4O62giX4BwAALvWhLvWgLvWu7vWCL1gE +gABb/R/AINEPbBAEHVIeFlPRGlEP/bwAFeAJFQDkMERjObEAAGgyPNjQ/BICHaALBQD/UKgVoB8F +AG36DiSBlLKI/IAHPCIAnQCxuyhyhCViowmIEahVJVBkZFGU9EAHoJIAnQD6YGgd4AwVAPONAA3w +CAUA9EAHIR/89QDegPQCAh2gj4UAbUoOJdGUst3+oAXUYgCdALHux1sIjQIkooQucoQsYqMvCiDr +/TkPdkKAAA7MCC/ANw3/Au/ENyqBCoAA4DwaCoEKgAD9IAEG3/71AA7dAw1EAQxEAiSmhGQwchpT +nSNiW/RABmiSAJ0AZDBh8gACHaAJNQBtCCskoHwAIAQEBBt/RxokcoQjYqOkJAlEEaQzKzBkyLQo +NGQpNGsjYluxInMrKmP/zQCwBA4IGfEf+K/SAJ0A+F/5MVIAnQBgAA4AAAAAAAAA9cBoHe/9KgDA +INEPAAAAAPUAaB3gHgUA0w9t6gwv0ZTo/ghm6AkAALFVx1vegCSihMDYC945L3KELWKjCf8Rr90v +0DcO/wLv1DcqgQqAAOA9GgqBCoAAAJ4aDO4DDkQBDUQC9VCGFa/8rgAAZD+YwCBtCC0uoHwAIAQO +DhvvYqMnfFyAACNyhKMjCTMRo/8p9Gsp9GQjYluxIvJf+1LiAJ0AY//LZS5vY/9cAGwQBBpRoiig +8cDO+kRwFeAeBQDqrOAkcMqAAP1tpg2gHQUALCAiDAxC/YYADnALBQBt2gwtoZTtwSl1UAkAALG7 +8AB8Da/7tQB8sT8sCmfAsG3qDC+hlOzxCXVQCQAAsbsr+vsYUH0ogoXBnwuZDHmNC8Gc+EWGHeAC +BQDRDyogIvFBUA3gAgUA0Q8ALCAiLQpg/YYADn/+5gDApPymZAWgG4UAWCuKwCDRDwBsEBIqIhvA +wCwkLimhAyihAvkACHxiAJ0AFFJ+GFCkF1CklxSYFhdQtJcaLyAiLSEeHlMiBP8CnxwfUBieHf+A +aB2gTTkA5P45D0gEgAAUUD3oIR8uWASAAPxFcBWg3TEADUs5FFB58YgAFjD4OQDvSTkM6ASAAPsm +AAz1+AEA6yAsL/oCgAAPzAIOzAIfUG8uICQJzAL4Q4QV4IgxAAj9Oe8gIy9ywoAADt0CDcwCLiAh +LSAgKRUe6CEdL/4CgADoFR8vdAKAAA/uAu7MAg7uwoAADbsCLyEZLxUgDLsCmx7+RpAVoA0FAC0W +Ei4WEywgNSwUQisgL/ooZh3gCwUAWxX6KhYY6lFSHRgEgAAVUA4WUKDqFhYlUgEAAPoi5hWgARIA +0Q8AAAAAAC1ADPWgBPMSAJ0AyJb1oAlIkgCdAPWgCQqSAJ0AZFG0FU//6iIbIdgFAABbFeUoEhjq +gcR9GASAAChSgCRSiKOICYgRqEQrQS73emYNoAlFAI9ACP8RCf8CnxUuQActQgcODkHs2RQvdAKA +AO6+AgbQgQAA98YAD3ALBQDuFggmBamAACvSCSwKKFsMDOtQER0P7gAAwFAusH0oCgHx3/r/0J4B +ACwgKyogIgyMOeqqCQYCuYAA6VFGFhizgADKxO1ADC1XAoAAqpkpkIDTD32ZKupEAAlYBIAAW4rs ++p/6BeAAWgAAaMMf9YAIqhIAnQBoxRRoxsgtQAwusH3//CgNoJ4BAAAAAAAvICIeUTEP/wntQAwv +/wKAAK/uLuCAfenX6kQACVgEgABbiiH6n9IF7/8aAGP/TgAALBIXGE+4LyArKyAi+Q7oFeAKFQAP +rzkogoirme8WFCzOQoAAqYgoFhWNgC6ANSqAByoWACmAFikWAfkDJBWgOwUA+CBGFaAKVQBYKt0p +EhUpkDQqEhT5P/RLUgCdAGSgufVABrCSAJ0A+V/zsVIAnQD+IqgV4AkFACiQAi6QAS70Byj1Gfkg +EBXgCyUA6fQWL9AEgABbh+plXkrrHBAqUASAAPwAgh2gDSUAWwov/IAIFeAKRQD8pNIFoBuFAFgq +wGP+IQAAAAAsEhYtQCIuIAIvIAH4QBAVoApFAPggBhWgOyUAWCq2KkAiG1DrCqwJDMwR/WAARbAO +FQAutHktIAAttHosIAIstHspIAEptHhbj0T6n0IF7/qaAPoiqBWgCwUAW4fG+iKoFaALBQBavgdj +/a4AAAAAAAAA+iKoFaALFQBbh776IqgVoAsVAFq9/2P9jtWgJRYZjlj6AIIdoBuFAOxSPxroBIAA +/kRQFePuAQBYKpKLWPr4AAfwGLUAePEyikctoRX7RAAVr8kFAAmpAenZCALZAQAA+KAHoeIAnQDC +yFsLdxtPe+WkAAVtYYAAY/+iLCAiCw1DfcnDjh0ODl9p47sZT0YeTxsrIR4lFhn0nwgF4AwFAP2A +aB3g+zkAD+05LiEf/4BoHeC7MQALnzn4RXAV4I45AOhcOQ5YBIAA/4YADnX+AQDhmRAP+gKAAA+Z +Ag2ZAgyZAiwgJB1PcQ5uQO7bOQ5iwoAADLsCC5kCKyAhLCAj6MwRDdwCgAAMuwILmQIrICAoICwL +uxELiAIrEhkJiAIpIRwptRYlIR2YuiW1Fy8hGS+1GP5GkBWgDQUAnb6evywgNSy0MikgLym0MxtP +RP/zQA2gBRUAAAD9bwAN//wyAGwQBCQgIsCSCUk245kRAhhHgAAaTuTA1fsgAEUwAF4AG07j65sI +AmP1AAD9YgANMA2lABtPHxZO06urGk7U9J3QBe/89QAM3APqmggBhJmAAANOEaXuKeKACdlSZJB4 +9SAJqJIAnQD1IAmpEgCdABlR1i+ihg/PAS+mhiiiiAjIAQjYAiimiCiygMTwD4gCKLaACOowL2JG +D58sKWJFD5koCYkID+owD58MavEObQgICOowCJgMaoECY//wKXr+KeaBKCIdiIHbMPpAaB2gDAUA +C4AA0qDRD//+WA2gSQUA7k60E3grAAAv8oQu4oGk/wn/Ea/uJ+AjKKKGCMgBCNgCKKaGL6KID88B +L6aIKLKAKfq/CYgBKLaAD+owKWJFD5kJD+owD58MavEICOowCJgMa4H2wJl5cQJpdAsq4R8PAgAK +CkVool/qRAAL2ASAAFgCi2agHut0AApQBIAAWB6GA0sRpbsssoAdTrYNzAIstoArsoAK6jAM6jAp +YkUKmQkMnAz3n/nQkgCdAAvqMAubDGux9mP/KfggAh3v+1oA+FACHe/7OgD6gGgdoAslAFge2WP/ +vgAAbBAIKCId0w8PAgCIguMgKylQBIAAC4AA90AY4JAHFQAqICsVTnWMJ/NAEGRiAJ0A40/bFRfh +gACMzivCMilSgeQgIiXYBQAAK8YyKlJ9/ABCHeAGRQDkqggC25EAAP1IABUwDAUA6pkIDkAEgAAe +UWkDShGuro7gDi9A/s0ADHD+GQAP3DkvkC8mCv4G/wH/JeYd4O4hAA/uAv8l5h2g/9UAD+4BLpQv +DOwC/SXmHaD9tQANzAEslC8IyAIolC8WTlqmpi5igB9OvQ/uAS5mgCxitx1RUQ3MAixmtyuyhClS +gaS771CBHd5CgACrmS6RHy2RHf/ABAdwCwUA7pUfJuSIgAAtkR541xejqi6igC2RH/HACWDSAJ0A ++yWwFeAEmgCjqi36ACiihC+RHQ2IAQi4AuimhCfgdIAAK5EeebcSLKKA8YAISNIAnQD7JbAV4AQO +AMCwL6KCHk56Df8BD78CL6aCLuB9f+8kKJEfeIcSKWKUG04PC5kC+NKGFeAASgAAACxilB1OZw3M +ASxmlCiigBlOQxZOPgmIAiimgCZihh5QICpSgaRm7k4ICzZCgACqZo9nLuCAj/7vFgIoBAqAAPPA +BO+SAJ0ALCEf2kD8oAAGMAsVAFv8yStSfYogKSEf+08ADXWZAQD1IAnIkgCdAOtOZBSUkQAA9SAK +ChIAnQD1IAoMEgCdAPUgCg2SAJ0A9SAKDhIAnQAcTewswkYtOugNvSwHzBENzCwDrRGj3SzWgVsI +m/ZFxh3gAgUA0Q/AscTgDt0C/SPkHe/7XgDAsS+RHygKgAj/Av8j5B3v+9oAGU4LKZKEpJkJmRGp +qlv7dytSf49gC/8M+rAoFaf/AQCr++5OAh3eQoAAq6uLtygSAi7ihCuyDu/uCARACwAA54UCJeAH +AADtwYIvdkKAAA6qCC7BsenBgyb4cYAALRqA/WAARvAIBQDo1MYoBAqAAPUgBECSAJ0A9SAGARIA +nQD1IAipkgCdAC+yli7Qxi/8AS+2lunFgycAuYAA+sBoHaALBQD8AAIdoA0lAFv4uhtOHOxQsBtQ +BIAAWCaSY/6mAAAAAPqhegXv+74A2iBb/KhnrqLSoNEPAAAAAPqhcAXv+14A+p2MBe/7PgD6oWoF +7/seAPqhaAXv+v4AKLKOKrKJ9wAF0lIAnQAospaYEQ6ILv4AIh3gDgUACP447hYAJQaxgAAp0Mb3 +csYV4AolAOrFgyz7RgAAY/9zAC9gNWTwkShgSWSAiy9gXWTwhS+ylpIX+AAiHaACBQAO/y4Pgjgi +1MaCFy7BrusWBScDeYAAsOj6IKYV74gBAOjFriQC6YAALrKWKtDGse4utpbpxYMteFYAAGP/FS7B +riiylifUxv+40BXgCiUA7qk5BEAFAAAotpbpxYMv9x4AAGP+7mWvYS+ylrH/L7aW+ZBkHe/7NgAA +97jGHe/+OgCdE/wghhWgCwUAW/m2jBSNE4sV//5ADaAJNQCKESjQxrGqKraW6cWDLHS+AACLEGW+ +jWP+nQAAAGwQBCkgN9MP8yAG5tIAnQAaTqj8mzQF4AMVAP4AAh2v//UA6qzgJPWEgADZoPvAaB3g +HAUAbcoMKJGU6I4JZMgJAACxuyv6+yzShOVNcx2BCoAAAOQa6SA3LYEKgADoUoQiqHEAAA8CAOVS +gSnACoAAD4gD+YAEBjD1tQAFmQEpJDcEzAIs1oT/LwAH0AsFAPgCAh3gnIUA0w9tmgwooZTsgQh1 +UAkAALG7x7ss0oQAsQTg6BoNgQqAAAA5Gg+ZAwnMASkgNwjMAv2whhWg+uUACpkB+EbmHeGZHQD4 +RuYd4AIFANEPAAD6AAIdoAsFAFv8UCkgNyoK7wqZAfhG5h3v/EIACRsU+kbmHeACBQDRDwAAAGwQ +BB1NWfqaHAWgCwUA/gAiHeCcBQD9sKgV4BgFAG2KDC6hlOzhSHVQCQAAsbsdUA8r0ltksErAoOxO +chbxsQAAbQgoKMCAAKAECAgb6dKjJHxcgAAr4oSrqwm7EauZL5RkL5RrK9Jbsap7qxRj/9AAsAQN +DBl/x7TAolv3AMAg0Q/AoVv2/cAg0Q8AbBAEGE1KDwIAKIB9wKH/AkAHEAMFACkgIisgLPMkgA3g +HvUAKiAjwLn7QBGEYAzlAP1AEUQiAJ0ALSAl/kUQFaAVBQD2mk4F4AQFAOZO+RaB4YAAKSETZOHH ++SAgFaAKFQD+gGgd4LgBAAuvOOglEyeA2YAAKSIdi5yMnelUAAWLUYAAZMFi2iALsAAtICJk0kku +IGoOSUNkkF/1IAUYkgCdAPUgBjESAJ0A9SAHyZIAnQD8n7AFoAolAPxEUBXgG4UAWCgkxjr6AEId +oBuFAOxP0hnoBIAAWCge8Aq8DaAEFQAAAAAAAPRNRh2gCkUA/ERQFeAbhQBYKBYcT8j6AIIdoBuF +AO0gIiYwwQAAWCgR+kBoHaALFQBb/cXjpAANBUYAAOUkailQBIAAW/4u/MBoHaAKRQD8RFAV4BuF +AFgoBS4gaxxPtcKg0w/szHAvHeAAAC0gZGXQbfpNRh2gG4UA/ERQFeAKRQBYJ/oWT6zDcPoAgh2g +G4UA7SAiI2NBAABYJ/T6QGgdoAsFAFv9qOOkAA0BpgAA3GD6AIIdoBuFAFgn7CckahxPnS4ga9MP +LMzA9d/5iJIAnQAtIGRl3ybaIFv+CdOgZzHAx+X+f/e9IgCdAMCk/J8mBaAbhQBYJ93wBqANoAQF +ACsgIgO7Eaa7KCAip7vrsoAsRMKAAKaIp4gvgoALS0D6jQAM/+r1AAr/AQn/Av8QBhXv+cYAAAAA +sJkJCU8pJRPzP/L30gCdAGWeP/REph2gCkUA/Jz+BaAbhQBYJ8MpIh2KnGShIoudZLEd2iALsABj +/i4qICJYGXNj/dIAAP9/7cQgDAUAG0yCKLKEJLKI9JpGBeBtdQD9CAAUMB8FAOhECAXb2wAAbfoM +KbGU7ZEIddgJAACxzMfLG0yO0w8rsoUAwQQArRp9uAUsQCx+ySktUCkjCv9z0Q/ApfyesAWgG4UA +WCehI1QpwDBnPUvSMNEP2iBb/uBj/a0qCv/8AGIdoKsFAFgYDOagTm0YBIAALVApfalXLVAoLlAq +feFGKUAsaJRAaJU9Kgr//ArCHaCrBQBYEZzmoCNtGASAABxPQfylUBXgClUA/qUQFaAbhQBYJ4Yv +UCgvVCpnP43aQFv7zmP/hQD//gQNoAMFAPoAoh2gG4UA7E80GfAEgABYJ3rypSYd7/5GACkgIugg +ZSzMwoAAppmnmfkwBhWv9BoAAADAQSogLsij2iBb++ZkTzwbTxrsTyUZUASAAFgk6tIw0Q8AAABs +EATqJAAJ2ASAAFtgL2ahrBlME/aYtAWgBxUAAyURqVQsQoAdTxkPAgANzAIsRoAqQoYbTEsLqgIq +RoYYTGKoVStSBBxPEgy7AitWBChSHSoqAAqIAuhWHSEIUYAA9EAIwJIAnQD0QAkxEgCdAPRACbGS +AJ0AKEKGGUyH6YgBDfoCgAAI/wIvRoYuYH3zwAQ/0gCdAOokAAnYBIAAW1Va6iQACdgEgABbVQ/q +JAAJ2ASAAFtUx/rECBXgCgUA/B9CHaACFgAAAOokAAnYBIAAW1RiaDEFbzc+bjQ7wKT8ndgFoAsF +AFgnL/yXugXgCiUACio2A6wRDcwILsK4H0vrD+4CLsa4K8K4HU37DbsBK8a4W1Q5ZqCpLUKAHkwG +Dt0BLUaAjFMHzAKcUytNBIuw57sCAmATAAD7gAYV4AIFANEPsap8oYAJ6jCrmQ/qMA+fDGrx7G0I +CA3qMA2dDGrR4GP/8CticAtMQ/+AABYzuwEA/WYADb/8AgArYnALzEP/gAAWM7tBAP1mAA2/+6oA +K2JwCxxQ/4AAFjC7gQD9ZgANv/tSAAAAK2JwCzxQ/4AAFjC7kQD9ZgANv/ryANKg0Q/SoNEPAABs +EARoMUnrS/sRlEEAAGg0Rmg4S2g7UGg8LRhLiCiCRik66Am5LAeIEQmILBpOqAMpEQqZCOiWAClQ +BIAAWwY10Q8AAAAAAAD6nSgF7/86APqdHgXv/xoA+p0cBe/++gD6mTgF7/7aAPqdFgXv/roAbBAE +GkvQ0w8joH0XS3DyYAZH0AsVAPIAAh2gJvUA9OBoHeAYBQBtig0pUZR2kQniLAEiqAkAAMcrZiCb +GUuu0w8tkoQAIQT9YAEDX/X1AAVlAw1dAQ1tAi2WhCyShPpABADQDQUA5cwBDugKgAANzAIsloQI +6jAM6jAkoiCoRAxMDGrBDm0ICAjqMAhIDGqBAmP/8CqShAWqAQpqAiqWhCZyRcBQ9sABAzfXBQD+ +2AATMAAqAACxVXdRHATqMAjqMKZECEgMaoHsbQgICOowCEgMaoHgY//w0Q8aS1MpCv75UCYV7/7y +AGwQCOJLwRlABIAA2TDiAAUIkASAAAICYQICYfUABMpSAJ0AEk3p9CBoHaADNQAPAgDTD9MPbToh +5UIHIRgTAADnQgYhMBEAAOU2ACIj4QAA5W0EIRAhAACXUBVL9xJN2xtN7x1N7R9N6xRN6YxUjlWD +VopXmiiTSIpTFE3pg1Ke+JzYmriTSBdN0BxLf+ZLDhxaAoAAC5sCDLsC+v/mFePihQBtCAmwIskg +LHL/fGACY//vwCDRDwDAINEPxyvRD2wQBBNM+fQAAh3gBIUA4yMKCTgEgADydCgV4AIFAA8CANMP +0w9tShf6QAQA00MBAOBEGgEQCQAA9KAAQrQzHQAZTIADeBGpiPUABhXgAgUA0Q8AAGwQBBRMffZA +aB2gA4UAbToKKEKlCAhSZIBRuEQnCgAZTHQYSzb6l9AFoIUFAPqYdAXgDAUA+OAAQjAiBQBtKigi +skAiotIJIwEDYwIjptIjotIsRqClc6gzIzKAIqbS4qLSIiARAAC0VdEPACdCpAcHSf7wABO//qYA +AABsEAQWTfn2AAId4AMFANMP8sBoHaAUdQDmbSAjuAUAANMPbUoKIyaA4yaBIRAhAADBR+l04msQ +BIAAEk3r9pvWBeAE1QDWINMPbUoKIyaw4yaxIRAhAADjZsojEIMAAPZcXg3gBNUAFk3gJwoADwIA +8sBoHaAUtQDmbSAjuAUAANMPbUoKIybQ4ybRIRAhAADBS+l04msQBIAA0Q9sEAQYTMOoKCiAgAMF +T/EABFfQDBUAGEyZCCgKKIKhwDD4YAAEsAIFAPsgBADUiB0A/YABBVAJNQBtmif4YAAEtLgdAPsg +BADTmCEA4MkaDIEKgADpqQIOUAqAAPsmAA00ix0A9UBoHaAZ9QADmQx5TRGxM/x+gIJQGfUA0Q8A +AAAAAADqNAAK2ASAAFuiD+ev320QBIAAY//hAADqJAAK2ASAAFuiCdKg0Q8AbBAE50xVGTAEgAAV +SnkFJQIldrMicrQUTJQTTaP0QAQBMBQFAPJGAAlwAwUA4na0K5AEgABtSgfjJrUhEBEAACZ2s9EP +AAAAbBAEFkq7piYlYoDHfwc3AwdVAQVFAiVmgNEPAGwQBMDBGE2QAyQRDwIACEQIGEx7JEIACCgI +KICA/w9gB99EAQAYTFEIKAoogqEICUP7IAQA0AIFAP2AAQVUiB0A80BoHeAJNQBtmif4YAAEtLgd +APsgBADTmCEA4MkaDIEKgADpOQIOGAqAAPMmAAn0ix0AwZ8CmQx5PQ+xIvxegIJQGfUA0Q8AAAAA +60QACVAEgABboclnr+HRD+okAApYBIAAW6HF0Q8AAABsEARb/2kcTWb8AAId4AMFAPmAaB2gGhUA +7M0EJugFAABtqgojhkDjhkEkQCEAAMGh6djkbkAEgAAUS/j0j+gVoAIFACoK//xAaB2gCxUAWGLa +Kgr/W/81sSJpLubcQPoAAh3g+vUAWGLU+JnQBaAaBQBtqgojhhDjhhEkQCEAABhM44iAGUzhwKIK +iAKYkNEPAAAAbBAEFE1DI0KAAjMMI0Z/0Q8AAABsEAQSS9wUTT4jIoF7NiApIooJCVX7IAQA0AgV +AACIGiIi/gIiFPMAAEEwACYAAAAiQX0kQX/jSgUSAFmAAAMiNaQi0Q/RDwBsEAQVS1TAiAgoAihW +Ug80ESRWU9EPAABsEAQTTSgCIgsLIhGjIoIg0Q8AAGwQBPaZaAXgCSUAFkn1HE0hBEgK8kACBbAK +FQDzYACF8A0FAPVCAA6xGoUA6iooDd8CgADnuwgMQ8KAAA3IOfrAAEM6iB0A6LbLKdcCgACqaiim +tQIlCwtVEadVJ1LC/ngAFTAIBQDkmDkNAQqAAOCIGg0BCoAA/SABBN/69QAKmQMJdwEIdwInVsIl +UsIlZvfRDwBsEAQXTI8CJgsLZhGnZiliwg89EQDRBOBaGg6BCoAA/IABBd/89QAMuwMLmQEKmQIp +ZsL2k4wF4RiFAAgoKCZiwqh3Jnb30Q9sEAQVTH0CJAsLRBGlRCNCwBVJtQUzAiNGwNEPbBAEFUx2 +AiQLC0QRpUQjQsAWSr0VSeoGMwEFMwIjRsDRDwAAbBAEG0xr67J/KdAEgABYJvD8AQId4AwFAFgm +GfxAaB3gDAUAWCYk0rDRDwBsEATylUYF4AIVACI2gCI2gdEPAGwQBBhMziqCf8GwC6oCKoZ/WCdL +0Q8AAGwQBMsnwFD3/gId7wYFANMPbQgNcmANAoIU5CAcYqghAABj/+lycAu0VfAAGA2kIh0AsVUC +EhRlL/fSUNEPwCDRDwAAbBAEyiCwIwMlAXMgF20IDLBU5FUBCpAEgAB0IAJj/+wPIhHRD9EPwCHR +DwBsEATjTK0ZFkKAAKMi0Q8AbBAEGErMwJDTDymGaimGaymGbAwCACiCbAjqMBNJdCMyRQMzCggz +CgLqMAIyDGohDm0ICArqMAo6DGqhAmP/8NEPAABsEAQTTJkkMoAjMn90OQUUTJdySwPAItEPwCDR +DwAAAGwQBPoQAh2lSQUA8zEACTE49QADozqjJPiAAEI/iAUACEIB0Q8AAABsEAQYSeDoAAUJn4KA +AG05AgICYdEPAABsEAQSTIPRD2wQBBhLFgIlCghVCuJSxCGAcYAAKVLDkjAJIgzRDypSwwoiDNEP +AABsEATAovxQABWwTAUAWHkf60x1FQJBgAAcTHQstn7stn8mYCEAAP1wBhWgDQUA7LaBJXDhAABt +KR2dr52uKbKAnpGcrymygOmmDiVRAQAA7raAJ3EBAADAINEPAMck0Q9sEAQSSV4oIociIogJiBGo +IgIqAlqi/hhJsQgAh/hA6BWgSQUAbZoCCAJhwJCZJ9EPAAAAbBAEE0xVIzJ/8GDgDeACBQAYTFLA +ICKGwNEP0Q8AAABsEAgWTE8SSogcSZ8qYo/40qgV4AMFAPwghhWgCAUA52w0LVZCgADqmQgDItEA +APggZhXgAHYAAPqwBhWgCAUA5EwBIZgFAAD0YAuKEgCdAClyhiVilak57WBULM5CgACpVSVSBwAw +BOVSDiaKqYAAKiCACgob60CAJX8YgAB+t74ucoYtYpWuPgnuEa7djdfaMP2hyBXgC3UA7RYFKOAE +gABYJBiPFIgV/gAIHeA5NQBtmgIIAmGMFSkqgPmAAETxjgUA/4AARzKqdQAKygj6IEYVoH2FAOPk +xCZgBwAA/ZXkHeAb5QD7liQd4A1FAP2WBB3geIUAKJRELZQx/ScGHeAPFQD/JCYd744FAP8kRh2v +zCUA/SRmHaAL5QD7JMYd4Ax1ACyUMP0nJh2gCzUA+ydGHe/OxQD/JcYdr4+FAP8lph3gDiUA/yXm +HaAPZQDvlEEo2ASAAP8oRh2gDQUA/ShmHeAMZQBYHv6KFfpWQh3gDGUA66oICNgEgABYHvmKFfog +SBXivLUA/UAARTAMZQBYHvSKFfpJgh3gDGUA66oICNgEgABYHu/qEgMp2ASAAFvxb+euf21ABIAA +0oDRDyth0yxAgP9hoAfQDRUADcwCLESAK2HT8X/0p1APJQAuQIAP7gL+kAYdr/oaAAAAbBAGFkkl +BgCHFkvSGUvT2GBtmgIIAmEYS9EeS9IdS9IaS9AXS9UUS9MTSQkSS9EfS88lMW0vNmEiNmAkNl8n +Nl4mNlwqNs8pMsgrMsItNtEuNqHsrDAm8CMAAOw20iboowAALTbK7jbJLd5CgACrmYmX6DZdJVFB +AAAqNqCJnvggBhXgBAUA5WUCJGP/AADlZQMiuf0AAPzABhWndx0A9sCEHeYlAQDkZQUhAXGAAAIq +AvqAaB3gDRUAWwL9aK4V+kBoHaALBQD8wAgVoA0VAFsC92mu6SgyXSeFBCSFBSWFAiWFA+WEAARg +QQAA7IYAIQFRgADaIPoAAh3gDRUAWwLsaK4V+kBoHaALBQD8oAgVoA0VAFsC5mmu6ScSACUyXidx +JyRVBSdVAudVAyLgQQAA7FYAI7H9AAD2wAABd2YdAOZVBCERUYAAAioC+gACHeANFQBbAtZorhX6 +QGgdoAsFAPygCBWgDRUAWwLRaa7pJTJfDwIAJlUE51UCKVAEgAD2oGQd4AsFAORVBSLgQQAA/KAG +FaANFQBbAsVorhX6QGgdoAsFAPygCBWgDRUAWwK/aa7pKDF4ZICZJTJgJzFxJFUFJ1UC9qBkHeYn +AQDmfH8i4EEAAPygBhWnZh0A5lUEIQFRgADaIPoAAh3gDRUAWwKvaK4V+kBoHaALBQD8oAgVoA0V +AFsCqWmu6SUyYQ8CAA8CACZVBCdVAidVA+RVBSLgQQAA7FYAIQFRgADaIPoAAh3gDRUAWwKdaK4V ++kBoHaALBQD8oAgVoA0VAFsCl2mu6SkyfiIyyiYK+/jPAAtwWgUA9ECkHaFcBQD8QEQdoAsFAPxA +ZB2gCDUA6CUEIWBBAAD8QAYVoA0VAFsCiGiuFfoKAh2gCwUA/EAIFaANFQBbAoJpruklMs8tbH8N +fRQtVQQmVQL2oGQdpiYBAORVBSLgQQAA7FYAIQFZgAACKgL6AAId4A0VAFsCdGiuFfpAaB2gCwUA +/KAIFaANFQBbAm9prukqMn9koJCwrg6oAX6gFW0IDLCP74gBDFAEgAB/oAJj/+wPqhEiMtLTDyQl +BeolAiUZ/QAA+kBkHaczHQAjJQT8QgAVpjoBAOwmACGBUYAA2jD6AAId4A0VAFsCV2iuFfpgaB2g +CwUA/EAIFaANFQBbAlFprunRDygyXyaFBCeFAieFA+SFBSRIQQAA+QAGFe/4ugAAAAAA//4kDaAK +FQBsEA4WSV8sIAwdSIkqYn3rYoUmNL0AABhIDyiAfQmqEftgAEUwgwUA46MIBHwcgABgAAIjrQOI +3vEBgA3gAgUA0Q+qwwkzEfNgAEH//64AAAAAAAAkYiQVSuPkFggiIf0AAAQ7FPVgBAXwCiUA+2IA +FeAcBQBYd3b4IQgVp5QdAOmlBC0QBIAA6KUCJWBBAAD5QGQdoAcFAPdApB3mSAEA7KYAIgFRgADa +QPrgaB3gDRUAWwIZaK4V+oBoHaALBQD8QAgVoA0VAFsCE2mu6SRiI9MP0w/kFgkiIf0AAPLRRhWj +tB0A9WAEBfAKJQD7YgAV4BwFAFh3VielBfQhKBWnhB0A6KUELRAEgADkpQIlYEEAAPVAZB2mRAEA +7KYAIgFRgADaQPoAAh3gDRUAWwH6aK4V+oBoHaALBQD8QAgVoA0VAFsB9Wmu6SRiIg8CAA8CAOQW +CiIh/QAA8tEmFaO0HQD1YAQF8AolAPtiABXgHAUAWHc3J6UF9CFIFaeEHQDopQQtEASAAOSlAiVg +QQAA9UBkHaZEAQDspgAiAVGAANpA+gACHeANFQBbAdtorhX6gGgdoAsFAPxACBWgDRUAWwHVaa7p +ImaIG0f8+gBCHaAcBQBYdx4bSoQZR8n4lQYFr/z1APt4hhWgCgUA+AAIHeAJxQBtmgIIAmEZSK// +LAAV4A41ACqUfCyUfiyUriyU3i6Ufy6Ury6U3yz0ri70r//1hh2gCCUA+TuGHaALFQArlKwkYiTB +wATENuQWECIh/QAABDsUBbsB+2IAFeAKJQBYdv8npQX4IggVp5QdAOmlBC0QBIAA6KUCJWBBAAD5 +QGQdpkgBAOymACIBUYAA2kD6AAId4A0VAFsBo2iuFfqAaB2gCwUA/EAIFaANFQBbAZ1prukaR+Li +pgwpAEYAAMck0Q8rEhDAovlwABWwHAUAWHbjHEfa8uBoHa/5RQAKkjjqxg0hADGAANEPHUpEG0pH +EkpEGEpE6BYPJaAhAAArFhEqYokrJn+dGymhAismgCQmgeQmgiSJOYAAWwGIH0ckL/J1LmKFqv/p +Egsv/kKAAK/uKOAH+TAQFeD6xQAKiAH+lGYF54gBAAmIAijkB58UjeCK5+4mgyDYQQAA/aAAFrAO +FQD/pgAOsAwVAO0WBSVQgQAAWwipKxIRjRuIH+IsMCIgwQAA67wwJugFAAD5f/tlIgCdAIQ3hE6E +ROQWDSIh/QAABDsU9WAEBfAKJQD7YgAV4BwFAFh2qSelBfQhqBWnhB0A6KUELRAEgADkpQIlYEEA +APVAZB2mRAEA7KYAIgFRgADaQPoAAh3gDRUAWwFNaK4V+oBoHaALBQD8QAgVoA0VAFsBR2mu6Y03 +Hkn6jd4cSf/zyYYVoApVAP2giBXgOyUAWCIYH0nzL/JM8uBoHa/+RQAP4jjIJdEPxyTRDwASRqAP +AgAvItufHo03HknpLdIOIiLcJ+aQLNIGLdIFLeaMLeaO/YAARnAKJQDv3wwGY/0AAP2PAA72/x0A +/9HmFebdHQDs5o0mof0AAPwhhhXjtB0A9WAEBfAcBQDt5kol2EEAAFh2bSelBfQhiBWnhB0A6KUE +LRgEgADkpQIlYEEAAPVAZB2mRAEA7KYAIgFRgADaQPoAAh3gDRUAWwERaK4V+oBoHaALBQD8YAgV +oA0VAFsBC2mu6RlJvuOWSSmAZgAA8AD0Da/yRQAcScGPHi6Sjf0xiBXgClUA8iAGFaA7JQBYIdgf +SbMcSbst8o//8cgVoApVAP/pSBXgOyUAWCHRwCDII9EPAAAAHke/LxpBLRpALeYQHEmmK+IRK8bF +L+YQKGG5KeIRKhoA6pkCBHgogAAYRmMImQL8AAIdoANlAPmAAh2gOvUAL+YQKeYRHUmYJ9Z6LNZT +LNZSLNZULNZZLNZYLNZeLNZgLNZlLNZkLNZmLNZqLNZsLNZ3LNZ2LNZ8LNZ+KNZxKNZz+a8mFa/7 +9QAr1lUr1lsj1mcq1nAq1nLzr6YV4AoVACrWYvqOJgXgEwUA866GFeAINQAo1lwTSS0j1mH4kFYF +o/P1ACPWeCjWX/thxhWgGBUA+a3GFaAbpQAr1lYaRvMq1lobSSMr1msbR34aSNIq1m37eEgV4Bzl +AP2qBhWgHLUA/a0GFaAM9QAs1n/RD2wQBBJH6iMigXs2GykiigkJVfsgBADQCBUAAIgaIiL+AiIU +ooLRDwASSWYiIX/RD2wQEhpJZNMPKKLB7EljFBWJgADyAAIdoAsFAPwAAh3gBgUA9gACHeAIBQD4 +IsYVoA8FAP4hRhXgDgUA/iEmFaAFBQD0IQYV4AQFAPQhhhWgAwUA8iFmFeAEBQD2IkYV4AMFAPYi +ZhWgBwUA/CKGFeAGBQD6IqYV4A0FAPwhxhXgCwUA+iDGFeAFBQAfRiUeSUIv8oAu4p2vLwn/Ea/u +nh0u4RLuFgAo0ASAAFhPd4kdiBAqlGLolRIk0LEAAFhPcuoSDS1YBIAA0w/rpFYlUOEAAFhPbY0d +/aJEFa+1AQAr1RMq1FfsVQgJUASAAFhPXiIWF4wegh0oEhYqEhMvIHGXL5YsIyRVLSE+KSBwKyBu +LiBUnhOquqiYrNwpIhEtIHKLKyoWE5weKBYWrjMoITIuEhUsEhSKLqtmixaqd6zcrv6NGi8hMyoh +NCsmEi4WFSwWFI4bjBmpuykhNayMrq6t/YoYjxwoITaeG6+fqooYSQopEhIiIG8ogHWfHKkp4hIX +JHxugAApFhIiFheIHYITkhUihH7yIugVoAA6AIgdKRYSKIB+mBWbFpoYGUj6nBmIFSmSwZ0a6EQI +ARAFAAD4X/Y74gCdABhI8yiCw2SBfvghyBXgAgUAbQgXAAEwAAAxIAxVIA0BAAExAAIAAAIwIAwB +JBYYFEXKJEKCIhYZpCQSSOUiIp3oEhMqJkKAAKQiJCBuqEgoFhMkIG8oEhKoSCgWEiQgcCgSFiIW +ECsmEqhIKBYWJCBxKBIVIyRVly+oSCgWFSQgcigSFJYsJSUTqEgkIT4oFhQoITKpSSQhM6yMKCE0 +rU0kITWujighNq9PJCESqoqIK6RVhC6oZhhIxqR3JCIRKIB1IiBUkh+kuyQSGKIz4hIZKAQKgADz +AAQ30gCdAJkeIhYXKBIQgh8iFhEihH7yIugVoAHmAAAAKcJSZJKZ+gACHaAEBQD2AAId4AYFAPQA +Ah3gCwUA8gACHeAMBQD8AAId4A8FAP4iphXgDgUA/iLGFaAPBQD8IkYV4A4FAPwiZhWgDQUA8iKG +FeAMBQD6IcYV4AMFAP/6vA2gCwUAAAAoEhCZHiiAfigWERlImCgSESmSw+hECAEQBQAAeSsIiR5j +/owAAAAA4hITJg0JgAAZSI8slfUtlfculfnvlfslAgmAALCoCKkBmRT5QArOIgCdAIoUbQgS6hYC +JUv9AADpqgENQASAAHmACPoghhWv/5IAAIkSD5kR6Uh8HNAEgAAvlfsulfktlfcslfUqlf4cSHgt +weYaSHXpwecmiJmAAC7B6CgSEi+gBSKkBA6POe+kBSSAsYAALxIWKBIVKKQHL6QGLxIUL6QIZNEf +KMJR48ZYJAWhgAD6IMYV4AIFABpFRhlIYw8CACqigSmSnQoqCOsWBi1WQoAACpkIKRYHKZES6RYB +INARAABYTpWMF4sRKsRi68USJlCxAABYTpDqEgctWASAAOukViVQ4QAAWE6LiReLFi+QVC6SEYie +KpRXI5RVK5YSl5+Mm5acLZESrGYcSEcllROtVS3Adah37rsIARAFAADvMwgG/DKAAP8vxh3gAB4A +L5B+LsJRr0T+X/rjogCdACXGTCbGTSfGTivGTyPGUyTGVI8e/4cGFeACBQDRDwAA+UBoHe/7NgBl +nu0owelljucuwegoEhIvoAUOjzn/QKYd7/wGAGXeX2XuXGX+WWSuthlIJCyV9S2V9y6V+f8/ZB3v ++W4AZZ7cLcHpZd7WZe7T+IpYBaANBQAtpAEtpAAtxRX5D7AVoO8FAP2DJB3n7gUA/YOEHeApBQD5 +gmQd4IgBAAj+Of+C5B2v+nIAAAAA8gACHaAEBQDyAAId4AcFAPYAAh2gDwUA/iKGFeAOBQD+IqYV +oA0FAPwixhXgCQUA+CHGFeALBQD6IkYV4AUFAP/4UA2gCwUAbBAIkhRYHPRb/pMWR/opYeL/JsAH +0A0VABlGbiqSgXumGSqSigoKVQChBADbGimS/gkpFPlgAETwAB4AKWEX+MamFeAALgAAAAAAKWI1 +LmI3L2HjKGHkK2Hl9gBiHeAMBQD4JAAEMf8BAP8tAA9xuwEA7mY3JZJpgABkglP6IGgd4AxFAOxm +VCDQQQAAWGWn5qHEbRAEgACKEFhljVgbf1hkteahsW0QBIAAWGQzWGQHWGMC5qGgbRAEgABYYh4r +Yd9+twpYYhrmoYxtEASAAFhhrOahgW0QBIAAWGFz5qF2bRAEgAAsYeLTD9MP84AK59IAnQAtYePT +D9MP/OALaOIAnQAqYeUuChj7wAuQogCdAAd/AvvgDFCgBwUAKGHk0w97hxrqEgQqYASAAOs0AAro +BIAAWGCl5qEcbRAEgABb+78URLoPAgAPAgArQnDzYA9o0gCdACIKAGYg+lv7POag9G0QBIAAWByb +KUB9DwIA6kehFOiSgAAdREUvonbHjQj/AS+mdiemcSzSyB5EXilAfQ7MASzWyHmfHiuidsfLDLsB +K6Z2GUd4KZJ/56ZyJIBRgAAdR3Un1sAuQnBz5hOEFC9ADYpHKUB3iq7rlAAHiJGAAB5G+Snirh9E +axpENfyI/AXgCwUA/yYADPBMdQD51cYV4BgFAG2KDCihlOyBH3VQCQAAsbsp0oIaR3z7IAQEsAoV +AAqZAvmwRhXgAOoAZr/jLtKE+2AEANAMFQD9gAEGX//1AA/PAw/uAQ7MAv2whhWgAE4AAAAAAFhh +BeeuoW0QBIAAWBxf2lDrNAAJYASAAFge6sAg0Q8AWGDt566QbRAEgABj/9wAAAAAAOoSBCnYBIAA +7EQACugEgABYYMzmr8FtEASAAPrcpBWv+c4AwHDqEgQp2ASAAOxEAAroBIAAW/xI565hbRAEgABj +/5QsZjgsZjn8x0YVr/a2ACxmPixmPSxmPPzH5hWv9n4AAMDIDJkC/UCgJeeZAQD4juYd4GxVACzV +7uzV7yWA4YAAwKX8imoFoAsFAP4Mgh2gDTUAWB9PY/65ZJ/kwKX8imIFoAsFAFgfShtEIOxFLhpQ +BIAAWBzGY//GAAAAAPoHAh3g+vUA/B+CHaCtpQBYCU/mrwFtEASAAPoHAh3g+vUA/AFiHaANNQBY +CUnzQGgdr/eiAAAAbBAEyTb0YAaAkgCdAMk39GAGgJIAnQDAINEPAAAnIRPkdwgJ/14AACghLh5E +iHeJAi4lLn5hNutkAAlQBIAA/AICHaANBQBYADLmoIRtGASAABxFjyzBfwIqAveAAEZwCyUAWB3i +5qBobRgEgAAdRHfTD9MPfVEw61QACVAEgAD8AgIdoA0FAFgAIeagQ20YBIAAAioC/OBoHaALJQBY +HdPmoC1tGASAAAIqAvzgaB2gCxUAWB3N5qAXbRgEgADqIgoqWASAAPwAAh2gDRUAWwmV0jDRDwAA +AIcs9OAAQ7/8ugDccPpAaB2gCxUAWB2/5q/ebRgEgADqIg0qWASAAPwAAh2gDRUAWwmG0jDRDwBs +EAYURt2GLyRCf6NmBGQKhEDkQHVrP4KAAOlEghKDaYAAJUAHBQVBDFsRqbsosp73AAYh0gCdACuy +nWSwucDA+kAIFaAIBQD4IAYVoA1VAPggJhWgDgUA+CBGFaAPBQBbBP8eRHAMXRH/oABGsAw1ACzW +nSsgBikiAioKAeqZAgXYBQAAKyQGKSYC2iD8wGgdoAsFAFgdkeagV20oBIAA6iIQKdgEgAD8AAId +oA0VAFsJWPCDwA3gBgUAikcmRAUqqRRloEL6gUgV4AwFAPpCaBWgLgUA/oBGFaANFQBbCU0fRqUv +8n+n/+b2ACqQBIAA0Q/SUNEPANog61wYKWAEgABbAvXHJNEPHEacLiANLSAM6hYAKfgEgAD4gEgV +oBslAPggJhWgCkUAWB6oi0cqQgIPAgD5ZAAV78wFAAyZAea1FCTJAQAAmbnptgglAhGAAP3gAh2g +CwUA+4JAHa/9BQAKihTkoB1l2CEAAHrI8XrQDLS78AAcDaSqHQAAsbsKGhRlr/faQFsCq2P/NwAA +///IDaALBQBsEAb8hNAVoIkFAPhgBAR2cwEA6BYAIeA+gAADhUL4oABC8AAaANVwGUZwKpKdKEBb +K5KhrKrskpktVkKAAPtAAEVwBgUA6hYBJAExgACOSAnuEa6+LeBzi+At3P/9zmYd590BAOy7DAaV +wYAAJkRb6zQAClAEgAD8AAIdoA0FAFul9OokAApYBIAA/KBoHaANBQBboJHrVAANGASAAPqAaB2g +DAUAW6OOKkAm+qBoHeJdBQDTD/1AAEVwDAUAW6K3G0THGELtCFgCKLaz/onKBeAIBQD/doYV4BkF +AG2aCuuJCgRABQAAJpa1KSANJbaz6yAMJIHZgADuRHsUgLGAAB1GOS7gfS3SVLCcDswoq9usuxhE +4g6/Eaj/j/APD0Z/eQnwAFgNoAsFAAAAKSANKyBVwMEJyTkLewyrmyoiFIcQ/AACHaANFQBbCMxk +caIpQCYXQxv//+IdoA8VAOOZEQLwa4AAGkTIBVwU+YABBPS1AQD7IABEsAA+AB1ExP0gAETytQEA +p5ooooAAsQTgbBoNgQqAAAD9Gg7dAw2IAQyIAiimgC5ANnznEykSASiRGCiM/wgIT+iVGCQL0YAA +bl4NGkTQBlkRqpmJkGAAIAAcRDEFWxQMuwoqsoQrsogFDEQAwQTrqgIPyAqAAAqZAcmVjhHaUPqE +0BXgDAUA/8MEFaANBQBbmq0rQFoaRfb8AAIdoA0VAPtVaBWmuwEAWwiWJkRaKkAmJiR/JkUZJkUa +JkQ2W6t6LEAmG0SrA8wR68wIDRAEgACnzCzCgI0R/UAERCIAnQAt0DRk0KkqQCZb+CIeQuou4H3p +QCYndbqAAH+XMgArER5D2QkdFA7dCizS9IJOKCEDIiECDAxPDLwC+E8ACT//JQAC8zns1vQpkASA +ANEPANsgHkPMCR0UDt0KLNL0gk4eQ/8oIQMiIQIOzAEMvAL4TwAJP/8lAALzOezW9CmQBIAA0Q+C +TighAyIhAvhPAAk//yUAAvM50jDRDygiFCmBAyiBAvkf8oRiAJ0A0jDRD4kRKpAiA6oRq6qnqiKm +gPMjJB2v/Q4AAACKEdxg+0OIFaANFQBbCFNj/TkAAACKESiiHYiB+gAiHeAMBQALgAD/+dANoA8V +AGwQBCUgDc4+ylziIAwigdGAABRD4ehAfSIgHwAAJEJ/sFMIMyiiQqMiE0RIDiIRoyKCIAICRtEP +IiBVwEEFRTmjIgUiDNEPABREQQ4iEaQigiACAkbRDwBsEAQoIhDTDymBAyiBAvkPhg3v9kUAwED6 +QGgdoAuFAFgbRuahcW0YBIAAKiIQ0w8roQMpoQL7J8YN4AUFANtAWwhEwMD1QGgdoA0FAOokAApY +BIAAW/6a5qE0bRgEgAAqIhDTD9MPLaEDLKEC7cEHcqgFAABpWMUpoQMooQLA8fkPAAxwDgUACP44 +ZO+J2iD8H6IdoAsFAFgcedOgZjDviioPAgAroQMqoQJ7oXfAMPpAaB2gC4UAWBsg5qDxbSAEgACK +KiyhAyuhAv1npg2gBQUA2zBbCB8dQskeQsjzQGgd4AsFAOokAAngBIAAW/4w5qCfbSAEgACKKi6h +Ay2hAu7RB3KoBQAAaVTGK6EDKaECwIH7LwAM8A8FAAmPOGT/jWAAAgDAMNog/B+iHaALBQBYHFPm +oFttIASAAIotLaEDLKECfcFL2zBbCAIdQqseQqvzQGgd4AsVAOokAAngBIAAW/4T6aQADSAEgADx +QigN4A8VAIotK6EDKKEC+w8ADHAOBQAI/jhk77vSkNEP0jDRD9JA0Q/3X/gNIgCdANog/EBoHaAb +xQBbAXtj/ux2qeDaIPxAaB2gG8UAWwF20kDRD2wQChZCni8gNRxCay0gDIUxKMJ7LiA0+ZBoFeAL +BQD9AABEd1VBAP0IABQwVU0A6JkIAoChgAD9xMBBUAh1APhGhh2gDnUA6kKQF0BngAAYRQwI6AqI +gJ8Z6RYILAAigAArJDQcQostIDUWQoQuIRYTQoIvYhaTECkiCvggJhXgClUA9CBGFeA7BQBYHQ8q +YhbrNAAK4ASAAFgcetJQ0Q8cQn38wsgV4ApVAP4hKBXgOwUAWB0FFkJ5GkIkFUJ30w/qAAULSASA +AOkMAA04BIAACQJhCQJhCQJhH0GaHEJqKyAMGEHvKSANGkJt6IB9Ld4CgAALmQIKmQLpxiwq8ASA +APiE0AXgiAEACP45LsVcKcYtLSA1+iEIFaALBQAPAgDrxMEu7wKAAO3EwCtYBIAA7EJdGmgEgABb +6hb1QGgd74zVAP1f+qQiAJ0AZa8UHEJOK8FcCwtLKyUWLMFkHkJT/iFGFarMAQAsJRcp4AEq4AAq +JDYpJDcqEggo4AIv4AMvJDkoJDgt4AUu4ATuJDohKNkAAPxHZh3gDBUAWAqaLhIIHEJDLSEWL+AU +KOEIKeEJK+ANLuAML6QUKKUIKaUJK6QNLqQMKiYRLyA2LiA3LhYAjhkrIDibESogOZoSKSA6mRP4 +R3AVoDsFAPgghhWgClUAWBy0jxgcQi4oIRct8Qku8Qj/4pAV4ApVAPggBhWgOwUAWBysiCAqPBro +iBEK2ASAAPhgZhWgDGUAWBd+E0IWKj3+KqIWWBw3/CFIFeALJQD6RoYd4ABeAB1CGOdBvx0YBIAA +5Sw2JrPZAADnAAULSASAAAkCYQkCYQkCYQkCYR9CERtCEf5CxBWgDBUALDYtKzVcD+4CLjYsKlAB +KVAAKdQAKtQBKFADL1ACL9QCKNQDLFAELlAFLtQFLNQE7EH9G1gEgADqIhEqaASAAFvptPVAaB3v +iNUA+V/uZCIAnQBlrYzAk/hGhh3gAD4AF0Ga5kHuHRgEgAD8g+oFoApVAPxDBBXgOwUA7xIJK3AE +gABYHHDA4ecABQtIBIAACQJhCQJhCQJhCQJhHEHpGkHqKyEWLjYtKjYuKiIRDLsC6zYsKmgEgADs +QdsbWASAAFvplPVAaB3vjtUA/1/qXCANRQBlrQv8RoYd4ABSAOdBex0YBIAA9oOaBaANRQD8g5wF +oA4VAOcABQtIBIAACQJhCQJhCQJhCQJhGkHQH0HQKSEW/muEHaAIBQAoNV0tNi0vNjAKmQLqIhEr +WASAAOk2LCpoBIAAW+l29UBoHe+L1QD7X+akYgCdAGWslMC1+kaGHeAAPgAXQVzmQbAdGASAAMCy +5wAFC0gEgAAJAmEJAmEJAmEJAmEZQbYaQbYoIRYrNi0qNi8lIhEJiAIZQbMoNiz8oZAV54jBAPkA +AQRwDCUA+Q8IFaAOVQDo3RELWASAAO7dAgrQBIAAC4AALDIti1IMjEfxZIAN4MxNAB1BlsvdK1AN +GUFYKlAM6ZKDJY5RgAAdQZ4cQOCtrS3QfSzCgavdrcwJzBGsmSmcgI6Xju4fQYmf4PXAJhWvgtUA +0Q8A9YBoHe+P1QD/gA1MYgCdAGXLvPpAaB2gCzUAWq9pwIb4RoYdoABGAAAAF0Ej5kF2HRgEgADn +AAULSASAAAkCYQkCYQkCYQkCYfyDAgWgBVUA/ELEFeAKVQD+QigVoDsFAFgb9BlBfCghFioiEQmI +Aig2LI8qGUC8/oEABaAMBQD9gGgd4P/hAA+dOQ/sORlBbv2GAA5wDRUADcwCLDYt/UGQFeeIwQAJ +iAoognjo3RELWASAAPWmAA73zAEAC4AAJTIt9CQABLdVQQD7MBAN4FVNAPU/2YiSAJ0A/EGQFeAA +RgAAABdA9OZBSB0YBIAAHEFaLiANjyAqIDWaECkhFpkR+EFIFaA7BQD4IEYVoApVAFgbyBtBO+cA +BQtIBIAACQJhCQJhCQJhCQJhGEFMLyANKiEWHEFKKSAMC6oCLDYt6jVcLM4CgAAJ/wII/wIvNiwu +IDX6wGgd4A0FAOoSCC93AoAA/ngGHaAMBQBb6OTlpAAFALmAAPoAQh2gOwUA7EE5GugEgABYG6rA +sOskNCqQBIAA0Q8AHEBwLMKAqswJzBGsmY6Xju6d4PXAJhWvgtUA0Q/SwNEPAAAAbBAEgieCLoIv +0Q8AbBAEgieCLiMiEIIvoyKwItEPAABsEASCJ4IugiTRDwBsEA4VQKHjUs4p0ASAACgyWpIU+iCm +FaAHBQDkgJRisAcAAPytaBWgAEYAAC0yWg8CAA8CAGTQev+fAA3gBAUA6jJYKlgEgABbBjIrYnpm +oFYpUsiquwm7EauZKZIKZJBGIpII8EQADeCNxQAsIGh9wTX6gWAF747FAO4kaClQBIAAWvujJ6QS +jyLnpQgvgNYAACsgB/pAaB2huwEA67wYKWAEgABbBTEsUmuxRHxDj2P/eCxSbPGO4A3vwgUA8AE4 +DaAEBQCOxy3sIALdAeflFCbpAQAAnemd6JfIl8mXypfLl8yXzZfOl88nxhAnxhEnxhInxhMnxhQn +xhUnxhYnxhcsUmwkTAH8gATiogCdAC1ieyxSyK1NCd0RrcwuwgzsFgYnfoiAACvCEu4yayZhIQAA +/CEmFaSrQQD7WgANMA0VAP9AAQUwDAUA+0AIFa+7gQBbBdCNFogZj9fnhgAn8IEAAALuAef1FCdx +AQAAnvme+JfYl9mX2pfbl9yX3Zfel98n1hAn1hEn1hIn1hMn1hQn1hUn1hYn1hcsUmyxRPyf+2Oi +AJ0AKTJZKsx/+CFGFeeqHQAqlQQnlQX9IEQdpkwBAOyVAyTgQQAA7JYAIgFhgADaQPoAAh3gDRUA +WvpCaK4XjBr6gGgdoAsFAP2ACBWgDRUAWvo8aa7nLFJpysbAQCxieCpSyKxMCcwR/UAARTALBQD7 +RAAVoEwFAFgV7yxSabFEfEPZLTJWLsx//CFmFefuHQAu1QQn1QX9oEQdpkwBAOzVAybgQQAA7NYA +IgFhgADaQPoAAh3gDRUAWvoiaK4XjBv6gGgdoAsFAP2ACBWgDRUAWvocaa7nLTJVJFJpLRYMJ9UF +JNUC5NUDJuBBAADs1gAiQf0AAPTAAAI3iB0A6NUEIgFpgAAESgL6AAId4A0VAFr6DGiuF4wc+oBo +HaALBQD9gAgVoA0VAFr6Bmmu5yxSa2TAccBAbQhoLmJ6LVLIrk4J7hGu3Y/XLvwgAu4B5/UUJ3EB +AACe+Z74l9iX2Zfal9uX3Jfdl96X3yfWECfWESfWEifWEyfWFCfWFSfWFifWFyfWGCfWGSfWGifW +GyfWHCfWHSfWHifWHyxSa7FEfEsDY/+QAC8yWJ8dJ/UF7PUCJiH9AAD94GQdp0QdACT1BP3iABWm +TAEA7PYAIgFhgADaQPoAAh3gDRUAWvnZaK4XjB36gGgdoAsFAP2ACBWgDRUAWvnTaa7nLFJqZMBO +wEAoYnkiUsioSAmIEagijif9xAAV788FAA/dAeflFCbpAQAA7eYJKlgEgAD9wQYV4AwFAPpq6BWg +DRUAWwUslyuXKpcplygsUmqxRHxDsiIyVynMfwl5FCklBCclBfxARB2mTAEA7CUDIWBBAADsJgAi +AVGAANpA+gACHeANFQBa+bBorhX6gGgdoAsFAPxACBWgDRUAWvmqaa7pGj94KVLIK2KAKqB9CbsR +65kIBXxYgAArkieLviuyELC7+iDmFeAAQgAskqeMzizCELDMnBctCoCtPZ0fLdC096ALeJIAnQAc +QmAdQl8tFg78IQYVoAsFACsWEShidyQSESJSyKhE7BIOKiZCgACkIi0iAC4gDCQiBy8gDSggNfSB +yBWgClUA+CAGFaA7BQBYGl4pIDT1IA8rEgCdAPpEAh2gCwUA+oAARTCcBQBYFTsqTBD8QgIdoAsF +AFgVN/peAh2gCwUA+oAARTAsxQBYFTL6ZAIdoAsFAPqAAEUwfAUAWBUuJCIPZECVLBIILUIALkAM +KUIHL0ANKCA1KZIO+CIGFeAKVQD4IAYVoDsFAFgaPioSEPwSAh2iKwUA+0AARXALBQBYFR0qEhDA +sPtCABWiHAUAWBUZKhIQ+l4CHeAsxQD7QABFcAsFAFgVEyoSEPwOAh2jKwUA+0AARXALBQBYFQ6X +SJdJl0qXS5dMl02XTpdPJ0YQJ0YRJ0YSJ0YTLBIRJyYTJyYSJyYRJyYQly+XLpctlyyXK5cqjR+X +KZcoLdC0LMwBLBYR/Z/1a2IAnQCFF4oUWvn7ijP+oAAWMAsFAFgU9Yo0BVwK/4gAFjALBQBYFPHk +MgEql8KAACgsfwh4FChFBCdFBeJFAiJgQQAA8oBkHaYiAQDsRgAhAVGAANog+gACHeANFQBa+SZo +rhX6QGgdoAsFAPyACBWgDRUAWvkgaa7pIjICKVx/DwIA9kCkHeeZHQApJQT0QEQd5jUBAOUlAyFg +QQAA7CYAIYFRgADaMPoAAh3gDRUAWvkRaK4V+mBoHaALBQD8QAgVoA0VAFr5DGmu6dEPAAAsEhH8 +QUgV4C4FAA7MAh4+8IsVDt0B7SYKKVAEgABb/Klj/fpsEAoVPvoZP90vIAwWPqAUQccYQAOYEytC +sSpigC5Csy1Csp0U/iDGFaADBQD+lcgVoAcFAPvgAEewDEUA6xYFL/5CgADv7ggMkASAACgh/y9i +hO1CriQFqYAArz8J/xGv3S3QIokT9aAFClIAnQAFAIcr4A2cGQ3YCR8/wCrgDOoWByxHAoAAqP+f +EQkCYQkCYQkCYQkCYS/x/+sWCCeDaYAAKxIDLBIHLhYAGD80HkGgGT84ihAp5h8ZP9rogowu7wKA +AC3kiAn/AokYHT8w7+VALmYCgAAMmQL9JgAM8AxFAPnDxhXgDVUAC4AAG0GQjBkPAgArsh+OEC0S +AfsOAA3w+vUAe6gCJ9Z/4zwBJmP9AADlzzVhEMEAABtBc+w/lxXIIQAAKcaFKcaGK8aD68aEJejB +AAAtxo/txpAl0OEAACrGkerGkiX5oQAA78adJcGBAAAoxpsoxpzvxp4kQMEAACjGp+jGqCf4wQAA +L8apL8aqgueCLiPCNoIk5zUFIeBBAACcMCI1AuI1AyF5/QAA8sAAATf/HQDvNQQhAVmAAAIqAvoA +Ah3gDRUAWviVaK4V+kBoHaALBQD8YAgVoA0VAFr4j2mu6RJBWg8CACMiQyIiRCc1BSI1AuI1AyHg +QQAA7DYAIUH9AADywAABN4gdAOg1BCEBUYAA2iD6AAId4A0VAFr4f2iuFfpAaB2gCwUA/GAIFaAN +FQBa+HlprukpQk3BMAkzNsk+wCAaPrv6QGgd4AwFAPtBiBWgDRUAWwPbsSJzKeQpQk3xJxAN4AIF +AChidiNCrqgoCYgRqDPaMFqXr4s3+2QAFa/JBQAJqgHntRQlUQEAAJq4mrmXOfZhRhXgK0UAKzQF +5QAFAeCBAAAMAmEMAmEMAmEMAmEMAmEMAmHqEgYpWASAAPwAAh2gDRUAWwO+K0JNsSJ7I5IrQkwj +CgDlFgIlh4mAABJBGZUSKGJ1JUKuLSKXqDgJiBGoVfWgBlRiAJ0AKSKj9SAF/GIAnQAqIq/1QAWk +YgCdACwiu/WABUxiAJ0A2lBal4SNV/+kABWvzwUAD+4BLuxAntie2SpSC+fVFCUAoYAAgqta+Vnq +JAAJf74AABJA/Ypc0w/IroKrWvlT6iQACX++AAASQPiKXQ8CAGSgD4KrWvlN6iQACX++AAASQPKX +WydWCigSAvahJhXgKbUAKVQF6AAFAtiBAAALAmELAmELAmELAmELAmELAmHqEgQp2ASAAPwAAh2g +DRUAWwOAK0JMsTP6f/jj4gCdAClCS/EqwA3gBQUAKGJ0I0KuqFgJiBGoM9owWpdSiTf7JAAVr8sF +AAuqASqsQJqYmpmKOeeVFCUAiYAAgqta+SfqJAAJf74AAIo6yKuCq1r5I+okAAl/vgAAijvIq4Kr +Wvkf6iQACX++AACXOYwS9mEGFeA59QApNAXsAAUB2IEAAAsCYQsCYQsCYQsCYQsCYQsCYeoSBSrY +BIAA/AACHaANFQBbA1QtQkuxVfy/+uPiAJ0AHj4rGT/VJ+YQJ+YRl+8nln8nlosnlpcnlqPRDwBs +EAQfQKr8gB4F7/71APaABAWgChUAJyAiKCIKK9KuAHEEAKoa66wBBAOhgAAMDEdkwKTgtxV94ASA +AAvIQnh5Cv9gBAZwCQUAKWSADqgDCMgBL2FP+bXGFaALNQAPAgB/sBEpIAwaPZNolnMqoH1/pwJo +kWorYU57twUsIAxoxXbqJAAJ2ASAAOxEAAroBIAAWABYCqICBgAAAAAAwMDgtxV9+ASAAAvIQnh5 +Ch9Af8CAKGSAD78B7qkDCdgEgADp+QEK0ASAACnWrlgX88Ag0Q8AAAAAAAD99yIdr/8OAOokAAnY +BIAA7EQACugEgABb/qBj/34AAOokAAnYBIAA7EQACugEgABb/OFj/3IAAGwQBIkyGj/LCRlSLKKu ++n98BeLcqQDtmQwMwsKAAAmMOf+JAAwQDRUAjjIfQF3/x2AIkk6hACS0gCkgIg54UO2IEAy1AoAA +6GYCCiQCgAAGRAIEzAIPzAIMD0fN8X/mDx49c/+ABAYwACYAAAApICIAkQQA3xoPzALspq4mQDCA +APAAGA2irGEAwK8dPOH4eooF4uypAP2ABAbw/PEA7LCAL/iCgADv3QIPc8KAAA7dAuiuEA5jAoAA +DswCDcwCnDIqsiGaMymQfsCA+mBoHe/8hQDpjDkK0ASAAFgXq8Ag0Q8AAGwQBIgiwnrmPi8cBlYA +ANogWA8VZaC9HEAq/EGQFeAKNQD+QbAVoBsFAFgYL4wnLckUFz5m6SICJliBAADqwgkmgymAAGSQ +dvFFwA3gL6UALqAAGD5cjKJ/6QV4wVl3wUDasPwAQh2gCwUAWwHEGz5YlqCMIJeik6UkpBz1QMYV +4A0lAPtAhhXgCQUA6aQdLmYCgAANzALspgEq0ASAAFgXpsAg0Q/Jldqw/ABCHaALBQBa/nFj/7V3 +ybJj/+MA2lD6YGgd4AwFAFgXdtogWBFw0qDRD4wnDwIADwIALckU5NBgZlCBAACLyWSwVi6wAHfp +CBg+NC+yAnjxP/oAAh3gDCUAWwGdHT4vGz/ulqCMIJOlJKQclab7QIYV7/n1ACmkHS2mAv2AABYw +DSUADcwC7KYBKtAEgABYF3/AINEPAAAAAPoAAh3gDCUAWv5KY/+0AABsEAQePz4oIA3t4q4kANmA +AOokAAnYBIAA7EQACugEgABb/6LSoNEPiTNnkBsfPMvaUO/dAgnYBIAA/dXGFeAMBQBYF0PAINEP +KCAiGTxoCIgRCNgCCYgCijIo5q5aliDAINEPbBAEijAKOkRuqRDaUPpgaB3v7KUAWBc1wCDRDxg/ +vQioCoiA6zQACmAEgADtVAAJUASAAAuAANKg0Q8AbBAEjDD6oGgd4pwBAOo0AASB+YAAaJE3aZI/ +6sYSfkgEgAAN6jAM6jD9jwAOcAAaAMDAeZYOD+owwICYow7qMA/uDK7MwNBYF0zSoNEPAAAt+tr/ +/8ANoAwFAMba//+YDaAMBQAAAABsEATiIA0pQASAAC2BByuADA0iESItMfpgAAXx3XEAFDxasdwL +xyikIvJACBWgBMUA9oAF2+IAnQAugAwWPu7+eHAF6iIBAPxAABEz7iEAAu4CD+4CgoDuZrshKTSA +AGSwRfoAAh2gCQUA+SABATAEBQBtyRGDJOZFCgEQEQAA41a8IiAFAAAkgAgu3AHumQgFUBEAAOiS +CgJxXIAA+1o2DeAEBQAiggB5JkTxZBAN4AkFAMCg+SABAjACBQBtyRHmIwoCIBEAAOMyvCEQBQAA +k0MvgAjqrAQmkAUAAPMgAESwAgUA6JQKB/AcgAB7o8zAINEPbBAE0jAqIgAPAgAPAgAKCULjVAAE +glGAAPUgBtCSAJ0AaJIX/f1CHeAMBQDqJAAJ2ASAAFgW+dKg0Q8ABOow80AMEpIAnQDzQAzyUgCd +AMDQZtFnDOow9Y8ADj//RgAL6jB5pr4qIAj5QAmhH+2lAGahLOkhBSUM6YAACQ1HGj1o/EEwFaAO +hQBt6govoqUPD1J/wVO4qsCQjyMcPNWp/xo9KCqiQC7C0hg9WwjoAQjdAi3G0irC0hg796j/7wAF +AUBBAADoAAcMUASAAC7G0izC0goAiAogiPiKaB2gDQUA+IJoHaAC7gApoqQJCUn/MAAUv/6aAATq +MCogCCwgDP5BUBXgDcUA80AFHhK6AQAMDEP9oAlroOoZACggCSkgC/HYABUw2iEA7jvoHukCgADt +qgIMzgKAAOn/AgxDAoAACogCGj5v6P8CDe0CgAAP3QIO3QKJIO2mmCSodIAAycXZIG3JDo+ULiAI +tJnvppkncHyAACkiAHmWFNkgbckPK6KZm5QoIAjshwR0yBEAAMDQcN4mDOow9Y8ADj/6QgAM6jD7 +jwAOf/oWAAAAAADaIFv/VuCm3X1oBIAA//mwDaAMBQAAKiAIKyAJLCAK/EFwFeGqMQABEQJYAP5m +oCyJIPE/81JSAJ0AKiAIKyAJ0w/8QVAVoaoxAFgHWmagDPpBZh2v+TIAAAAAAAD/+QQNr/31AHiX +B/AAHA2mmQEACYlCHTumKtKD+bEIFe/JAQCsqgmqEaqZZJ3p/SbwFe/5AgAAAP/9KA2v7aUAbBAG +ijKIMBk7Z+072hQlaIAA+yAEk6AbFQAYPSz/UAAVP/n1AG26B+mG1CRAEQAAEj0nDasCKya9Gj69 +Kia8WAZW56QABQFhgADqNAAK2ASAAPzgaB3gDAUAWBZd0qDRDwAAAAAAAAD//3gNr+elAAAAFD0W +Fj6vLCLw7DQQIZBFAADaIO1C7yjYBIAA/CAGFeAMRQBYEYUkTPzmSeRxEBEAAGP/owAA//54Da/n +pQBsEAoCJgIL6jAYPKgogn/5YBM7ogCdAB07lxc8DRo8oy3SICJyGSumf/tPyBWgDAUAWBevHDuQ +0w8swH3zbwAKsA0VAO10aCZwKIAALTAAaNMpx+7+wAQHMD+FAH/hHMCl/H0SBaALhQDvMAAqaASA +AOUWACtwBIAAWBaIwfP14Asy4gCdABc7FCZ2vRo+gBs7FPwMgh3gDAUA/gFCHaAINQD498YVoA8F +AFr6SB08f+KkAAUOsYAA9CDmFeAJBQDjFgYiCamAAJYU+nziBeDmAQDuFggiY/0AAOwWCSyoBIAA ++iCmFeADNQDwAEgNoAYVAAAAAAAAAPBkwA3gBhUAjxmIGH9TAcBg5IB4axfCgAAbOvPy98YVoAwF +APh8vAXgbUUA+ny0BaAOpQD4IAYV4A8FAFqnCuKkAAUE2YAAZiDGJVwBdFOvFDvCHTxYC+owKtJ/ ++2ALg6IAnQAeO0Yu4iAr1n8q0n79wGgd4AwFAFgXXytGGepGGCGHOYAAwPAvRGjRD4oWDwIApaoq +oAAqdr0aPj76daQF4AwFAPh8egWgCRUA+EYADPBtRQD498YV4A6lAPggBhWgDwUAWqbo4qQADXve +AAArcr7zf/uAUgCdAGAAL4wWK3K9pcz7gAYd7/16AAAAAPp8VgXgGkUABaoMWvURY/6MFDuV//04 +DaADNQAAACL6uYwVjxaOFI0XL/AAlhL0ICYV4ApFAPwgBhXgC4UA4hYDKmgEgABYFhuIGXhTZrAz +CuowGTqwKZJFCZkKCpkKCuowCpoMaqEICuowCpoMa6H2//psDaAFBQDAofx8GgWgC4UAWBYMwLD6 +jQYd7/K1ANEPHTwMLNJ+scz9r8YVr/ZGAC5yvvPf8ThSAJ0A8/ciHa/4fgDAkCl2vRo9+hs6jvwM +gh3gDAUA/gFCHaAIFQD498YVoA8FAFr5wmP/bwAAKtJ+sar7r8YVr/ouAAAAAGwQDP5AaB3gDOUA +9nrMBeD49QD0IiYd57QBAOsUECmwBIAA9kAAQ/ADFQD4Qd4NoAUFANpQ+iCmFeADPgAocID6IKYV +5IgBAHyJJBo6dvygaB3gewUA+kYADfAZBQBtmgwuoZTr4XF1UAkAALHdtC8ePdUA8QTp4IApwAqA +AAgLQysUEnmBfho9R/gAAh3gDZUA+iDGFeAPRQBt+hUroIALC0TtuwwEwAUAAOuJOAVQBQAAbpJP +Kgrg+iJAFeAMFQBb/xnxRAgN4AzlAB49vo0W/dAGHeAAzgBm35EYOpwvgoQA0QTgWRoOgQqAAPxg +AQVf+/UAC6oDCv8BCf8C/xCGFe/9sgDAoGaimwvqMBo7sS2if327CC6ifi7sAS6mfpYeHTqeGjur +HzsULdIgK6Z/L/IZKqJ+/iFmFeAMBQBYFrYdOpYeOwyGGy3QfYwe928ACzD65QDj5Ggm8CSAAI4V +aOM2Cs8B/iDmFe/45QD54AQHsDiFAHjxJQQPR/YgBhWgClUA/HsUBaALhQD+IOgVoA0lAFgVi2AA +BArJAZkX9CDoFaAaNQB2ow36ewgF4BpFAAaqDFr0ahU6ESRWvRo9fRs6EfwMgh3gDAUA/gFCHaAI +NQD4t8YVoA8FAFr5ReYWCS0AVgAAKVK+JhYJwDD8euQFoAY1APwhRhWgtAEA+iGGFeAOFQD8IYgV +4AQFAAPkOA9OEe4WDS6C3gAAKhwQqjoqoAAqVr0aPWIbOff0IQYVoAwFAPh6wgWgCRUA+cYADPBt +RQD4t8YV4A8FAPggBhWgDqUAWqYM5KQADQK+AAArUr5xvkz19yIdoAEyAAAAAAAAGj1PGznklBj4 +ep4FoAwFAPghqBXgbUUA+LfGFeAOpQD4IAYVoA8FAFql+uSkAA0AjgAA6lK9INhBAACrOyq0AGdB +R4wajRmOGC8QEJMRlBP+IEYVoApFAPwgBhXgC4UA/iDoFaANJQBYFTnONMCQKVa9Gj0zGznH/AyC +HeAMBQD+AUIdoAgVAPi3xhWgDwUAWvj7sGYL6jAK6jAZOcUpkkUJmQoLmQoKmgxqoQgK6jAKmgxr +ofbAMP7NfA3gDhUAC+owHDsn0w8swn8aOyUVOo39Y1INoAMVABo7IS2ifuU6iRboBQAA/U/GFeAD +FQAdOg4rpn8qon79pAgV4AwFAFgWKPqjJhXgDOUA6lYYKwDOAADAofx6GgWgC4UAWBUM/AHCHa/0 +tQDA4O5UaCpQBIAAL3CA0w8PD0R8+SIcOZz6DgId4A0FAPpGAA3wGAUAbYoMLsGU6+EKdmAJAACx +3dKg0Q9m3/gSOdwoIoQA0QT8YAEH3/n1AAn5AwmIAQj/Au8mhC0QBIAA0Q+xM/R/+XlSAJ0AY/8f +AAAAbBAEGTrbKzAI/HjEBaAN5QDpkPEk04EAAP1kABJQHgUArLwswID/KAAPFMwBAH3JDiwKYP1m +AA4wAOIAAHyfLPpAAAZwHQUA/YYADnALBQDTD23aDC2hlOzRKHVQCQAAsbvwAHgNr/u1AH3BwywK +Z8CwbeoML6GU7PEIdVAJAACxu8e7GDmuDwIAKIKFKQofC5kMeY1pKTIA/ylgAp/tpQArMAksMAoq +MAgtMBBb/tD9QGgd4AkFAPwfAAXwChUAC6k4ypSMMNMPecYeKzAJLDAKKjAI7jALIehBAABYBa39 +QGgd4AAeAHme4Now+qBoHeAMBQBYFFDSoNEPAAAAAP//nA2v7dUAbBAEijD8YIQV4Ah1APsABQii +AJ0AeaZc/A8ABP6tAQAM6jAbOw1w31YqtrPAgO6ytCnQBIAA/mDmFaAZBQAPAgDTD9MPbZoS64kK +BVAJAADpkrUkQAUAACmlDw/qMP3vAA4wDQUA6jQACtgEgABYFDDSoNEPwND//6wNoAwFAABpkTgZ +ORsJqQIptsUossYvMQUI/wIvNQUussqeMy2yyZ00KbLImTUossf4YMYVr/62AMba//64DaAMBQDG +2v/+kA2gDAUAAABsEAQWOQfkMEBpVsKAAAOoAihmwSRmwhs5BPwGQh3gDhUA+nIABaAMBQD82GYV +oA8FAFr4OOagV20QBIAAwJP42GYV4ABKAAAAAASsAixmwcC6K2bD+nHoBeAMBQD6ceIFoD0lAP4A +Ih2gDwUAWvgp5qAMbRAEgAAtYsItVQDRD8Ck/HHYBaAbRQBYFFbRDwDApPxxzAWgG0UAWBRS0Q8A +bBAEFjjf5DBAaVbCgAADqAIoZsEkZsIbONz8BkId4A4VAPpxsAWgDAUA/NhmFaAPBQBa+BDmoFNt +EASAACVmwsCR+NhmFeAASgAErAIsZsElZsLAuStmw/pxmAXgDAUA+nGSBaA9JQD+ACIdoA8FAFr4 +AOagBm0QBIAA0Q/AofxxjAWgG0UAWBQv0Q/AofxxgAWgG0UAWBQr0Q8AbBAGKTIAJDEEKAoH+QAK +kOIAnQD6cdwF5HQBAPDzcA3kREEALbKEK7KI+gACHaCMBQD9qAAWsAkVAP1gAEXwCEUAbYoULbAh +7LsIDZAEgAD1oAeEIgCdALGqizD/ZoACkAYFAJkSBuowZJEH7DEFKlAEgADtMQcr2ASAAFv/uYkS +izCaEA7qMPfPAAswACIAAAAAAPFgBqJSAJ0AD+ow7xYBJIhRgADiOI8aVsKAAOwxBSOB+YAAhBEH +qAIoJsEsJsIbOIr8BkId4A4VAPpxDAWgDAUA/FhmFaAPBQBa977moShtOASAAMCT+FhmFeAARgCE +EQytAi0mwcC6KybD+nD2BeAMBQD6cPAFoD0lAP4AIh2gDwUAWvew5qDebTgEgAAuIsIuNQfdcA/q +MAT/DK9m2jDrVAALYASAAFgTe9Kg0Q8A9V/4khIAnQBlfwr//BwNoAkFACgxBfcf9jZSAJ0Axtr/ +/ygNoAYFAPwgCBXv/woAKiAk6RYCJQMZgAAoIh3aQOiCByvYBIAA7DEFIeg5AAD+YMQVoA8VAAuA +AIkSizD6IAYVr/t6AAAAKSAky54iIh2CJ8ot6kQAC9gEgADsMQUh6DkAAP5gxBWgDwUACyAAhBH9 +QGgd7/1CAMeP+CAGFa/6hgCEEf/88A2v7aUAhBH//MgNr/31AMCk/HB8BaAbRQBYE6hj/xvApPxw +cAWgG0UAWBOkY/8LbBAEFDiFpCIjJoAiIoHRD2wQBIkw+nEABeKZAQDqO50UgxmAAGiRX+o7mhyV +kAAAiTD/JGACkAwFAA3qMIgyjjOrryj2gC72gQzqMIkw/Y8ADnAAHgAAAAB5lhYN6jCPMquuL+aA +LuKBnjMJ6jANmQypzMDQ6jQACtgEgABYEyTSoNEPY/+oAPp3CAWv/pIAxtr//3wNoAwFAAAAbBAE +iicoqRQXObPpIgIlWIEAAOqiCSQDGYAAZJBz8UWgDeAspQApoAAdOah8mQeMon3BV3fBPdqw/ABC +HaALBQBa/RAeOaUYOWGYoI8gl6KTpSSkHJWm90OmHaAIJQDupgQv/gKAAAj/Au+mASrQBIAAWBLz +wCDRDwDJlNqw/ABCHaALBQBa+b5j/7d3ybRj/+LaUOs0AAtgBIAAWBLD2iBYDL3SoNEPbBAEFjqi +GDhC5TfgGRoCgAAIMwLy3+YV4+KFANMPbQgJsCLIKyli/3lQAmP/7cAg0Q/HK9EPAABsEAaIMyYy +ABc5OeQyAipIBIAA8wANAFJmAQAoIgIpFgDtOakcDu4AAGRhSvTACqiSAJ0A9MAK4RIAnQDr0H0r +HFQAACrRPwCxBACqGvqAElqiAJ0A+kBoHaALJQBYENjmohhtOASAAIkw8yAFGpIAnQDzIAZCUgCd +ANtg+kBoHaAMBQBYEh/2crYFr4zVAHyhAgenOIwnLckU6SICJliBAADqwgkmhfGAAGSRH/FLYA3g +L6UALqAAGDlNLKICf+kK+YAHPCIAnQB2wTzasPwAQh2gCwUAWvyzjBAZOUcdOQOdoIsglqKTpZWm +J6QdmaQspBz9YAAVsAwlAAy7AuumASrQBIAAWBKWwCDRDwAAAAAO6jDaIOtkAApgBIAA7jhpEehB +AABYEL3moLdtOASAAA/qMIkw8T/6AlIAnQAI6jDsRAAJUASAAO08ECtYBIAAWBDo5qCcbTgEgAAJ +6jBj/xcAAGSQZdqw/ABCHaALBQBa+Utj/2Eq0iD6n/VzogCdAGABFivSIfqf9UPiAJ0AYAEIAC7Q +fSzRPwDhBADMGvyf9MOiAJ0AYADwAPef+U0iAJ0AY/9R2mBb/4PcoOs0AArQBIAAWBJBwCDRD9pQ +6zQAC+AEgABYEj3aIFgMNtKg0Q8AL/qN/1/6NGIAnQBj/ocAACj6jflf+wwiAJ0AY/53jCcpyRTk +kGFmUIEAAIvJZLBXLLAAwtp9yQcfOPSOsn/hpPoAAh3gDCUAWvxdjBAZOrsdOO6XoIsgnaKTpZWm ++UCGFe/49QAopB0spBz9YAAVsAwlAAy7AuumASrQBIAAWBI/wCDRDwAAAPoAAh3gDCUAWvkKY/+0 +AAD2cTgF7/5FAP9f+9UiAJ0A2iD8QGgdoBvFAFr8ZmP/Zf/3aA2v56UAbBAEiTCEMv8noAqQAgUA +eZ4Y6jQACtgEgAD8QGgdoA0FAFgSM9Kg0Q8AANpAWBS8WBTTCeowikCaMwjqMAmIDPhAAEE//zoA +COowiTOZQALqMOgiDApQBIAAWBSxWBTIiTBj/6kAAABsEASCJyYpFOIiCSMBgYAA8EKADeAopQAn +IAAaOLOJInh5GHqZFYsmLCAcjSWdMCxEAPqgBhXgAgUA0Q/HItEPbBAG6iQACNgEgADsHAQg6CEA +AFv/6ywSAGagOyk8EOkHHgZQQQAACgJjCQCGCgJhCeowGjfAKzkBKMIBCJkyC5kM+yEADL+IAQDo +xgEszAKAAAmIAijGAfpAaB2gCwUAWpAS0Q8AAABsEAQXOlsSOH4mcp0kck4CMgF2KwqmRHJLBcAg +0Q8AAChysAkiEaKC0Q8AAGwQBBc6UBI4cyZyniRyTwIyAXYrCKZEcksDwCDRDyhysAkiEaKC0Q9s +EAQUOGoSOGQiIn8ENAEJRBGkItEPAABsEAQUOEQkQIADAkMAIAQEBBvoNwASfCKAAMAg0Q8kgoQo +goikIgkiEaKC0Q8AAABsEAQpCoAJOgHyYAa+EoNBAKmJ9SAGr1IAnQDVkPFOMA3ik0EALyAMFjhR +GzhR+eAGlWajAQAtIFUsIFQpIA0eOE2tzOSQrGYb/QAA7GJZJIVhgAAo4H2wnQjdKA/MCA3MCAvJ +CimSgAkJRnmhEi0gVf1ABHviAJ0A80AEOuIAnQBkQEwpIA3sIAwkgYmAAOjgfSSAiYAAL2JZsJ0I +3Sis/A3MCAvJCimSgAkJRvlBHg3gCwUAYAAQACkgDSsgVcDBCck5C6sMq5sqIhRa9KnLoRg2xCiC +gyJipqWICYgRqCLRDwD//MwNppMBAPUwABXv/LYA84BoHe/95gD94Ggdr/2KAMAg0Q9sEAQpCoAJ +OgHyYAb+EoNBAKmJ9SAG71IAnQDUkPFOsA3ik0EALiAMFTgPGzgP+cAG1WajAQAtIFUsIFQpIA0f +OAutzOSQtGYb/QAA7FJZJIWhgAAo8H2wnQjdKA7MCA3MCAvJCimSgNMP0w8JCUZ5oRItIFX9QASb +4gCdAPNABFriAJ0AKSAN7CAMJIGBgADo8H0kgIGAAC5SWbCdCN0orOytzAvJCimSgAkJRvlBHg3g +CwUAYAAQACkgDSsgVcDBCck5C6sMq5sqIhRa9GfoNoMVAcmAACiCgyJSpqSICYgRqCLRDwAAAAAA +AP/8rA2mkwEA9TAAFa/8lgDzgGgd7/3WAP3AaB2v/WoAwCDRD2wQBCQgDchC0Q8AABY2cBg3LPJI +AAL3MwEA4mKIIYDRgACoWCiAfSRigaOIqEQJRBGkIiIsgNEPKWKApZkJmRGpItEPbBAE0Q8AAABs +EAQXNnmnJyN2gCZygSN2gMePCEgDCGYBBlYCJnaB0Q8AAABsEAbLTScgANMP9oXmDeAIBQAPAgDT +D9MPbQgP5HAUZEAFAACiiSeQAHdBEmP/4gAAAAAA8AAkDaACBQAA2SCxkmQh8BY5gypgAPFPwA3g +BAUAbQgMJWABsUTkUAdjMAUAAGP/7GRA4ScgAGRw2/aACZCSAJ0A+uAJVSAIBQAZOXT4jwALMABC +ACuwACqQAAhGDHupJvTABYiSAJ0A6ZwBJEAFAADiiwgDF4MAABo5aAKLCCuwAAqKCCqgAHqzD/tB +1g3gBBUA8AAYDaAEBQDHT2RAdRY5YCpgAPFGwA3gBAUAbQgMLGABsUTkwAdjMAUAAGP/7GRAUfaA +CgCSAJ0A90AJxWAIBQAZOVP4jwALMABOAAAqkACiiyuwAAhGDHupHOhhJGRABQAA62LmZMgFAAAa +OUiiiyuwAKqKKqAAerMT+0JWDeAEFQDHz/xgBhWgAgUA0Q/HT2RP7hY5P9MPLGAAwKDkpAAGA9mA +AG0IDC1gAbFE5NAHYzAFAABj/+xkQGD2gA4okgCdAPeADe1gCAUAGTkx+I8ACzAAigAAAAAAAAD6 +4Ggd7/xSAAAALJAAoosrsAAIRgx7yRzoYSRkQAUAAOti5mTIBQAAHDkjoosrsACsjCzAAHyzEfuC +Fg3gBBUA+mAGFaACBQDRD8dPZE/wFjkaLmAA+AciHeAo9QDx33AN4AQFAG0IDCxgAbFE5MAHYzAF +AABj/+xkQJFqQVH3yd4N4AwFAB05DPyPAAswAIYAxirRDwAAAPrgaB3v+/4ALtAAossrsAAMRgx7 +6SPoYV5mYAUAAOti5mboBQAAHjj+ossrsACuzv/AEBWgABoA23B+sxD7wfYN4AQVAPAAHA2gBAUA +AMdPykSaMCogAMBA+wAJSqALBQD7IAizogCdANyg+2AgFeACtgAAAGThR/Zx1AWgBAUA0w9tCAws +YAGxROTACGMwBQAAY//qAJowokcmcADw0ZAN4AQFAPLAaB2gagUA+gjCHeBsZQBtCFEMRBGUMHKL +D3KTDPJaABWgANIAAAAAAADzQpINoE0FAHLDDPJVIBWgAHIAAAAAAADzv/hqogCdAPN/+CuiAJ0A +IizJokSUMCJwAeQgtGO4BQAAY/+nAAAA+uBoHe/6JgAAepMborfkRAoGK0EAAAVECZQwKnAAsbvq +g+V9YASAAGSgfigKa/gJYh3gS9UA80BoHaBq1QBtCBZ4IRZ5ITh6IUJ7IU8icAHkIFZjuAUAAGP/ +4ig66AhIKPhgBhWgAgUA0Q/MqWAAOQAAAAAAAMug9kBoHe/+vgAGSRH4YAYV4AIFANEPGjWdCkoo ++mAGFaACBQDRDwxLEPpgBhXgAgUA0Q/AIJIQ0Q+aMCYgAP7fEA3gBAUA9kBoHe/7UgAAAABsEAQm +IAD2ZUYNoAcFAA8CANMP0w9tCA/kYA9juAUAAKJ4JoAAdjEHY//iwCDRDwCxgtEPsSLRD2wQBBU1 +XaUlI1aAJFaB0Q9sEAQjIAACJALwYXAN4AIFAG0IDChAAbEi5IAHYiAFAABj/+zRDwAAbBAEFTbM +FjUD8AAkDaAEBQCxRGhJKSNSvHw3HwPqMCJiRaMiCOowCCgMaoHjbQgICOowCCgMaoHXY//wwCDR +D8cv0Q9sEAQiLH/ycGgF4yIdAAMiASIsENEPAABsEAgeOF8ZOGAUOF4oIgApkrsXNrEsMgH5DwAM +f/aFAPggZhWv8vUA8YAFABCs+QDzgAuwUgCdAOw4VBUTwYAALMFhGjal84kgDeAdFQADPAJt2iD2 +YeYNoA8FAHpCB/+AqBXgABIAL6bALMz84qbUJVARAAAfOEUoPAgI7zkvdrxb/8jkpAAFD4GAAOk1 +QhoJqgAAiBISODwpkWryWegVoogdAAmIDAeIEagi6xIDKVAEgABa8tVkoinaUOs0AApgBIAAWA+T +wCDRDwDxgAbQUgCdABs4LdMPDwIAK7Fh3DD6IKYVoB0VAOp0AAWGOYAAbdog9mHmDaANBQB6Qgf9 +gKgV4AASAC2mwCzM/OKm1CVQEQAAHjgdHzgaKDwICP45Lna8W/+fZKFpZqCGGjgWjRIPAgAuoWCL +E/tZ6BWi3R0ADt0M7RYELu3CgAD9QABFcAwFAPogJhWgDRUAWvqQixEssQMrsQKOFHy5Fi9yvRg4 +CI0SCP8BD90CLXa9HDgFLHa8/HAKBaAKVQD8IEgV4AtlAFgP8B43+vogqBWgCQUA+CAGFe/6SgCa +Ff/8KA2v5KUAKvq5mhCKFf5v4gWv+eYAAAAbN/ArsWFksUgYNkL4AAId4BsVAG26CimGwOKG1CRA +EQAA2iAcN+gsdrxb/23kpAAFCDGAAMCQZUBMmRIaNjWLNSumwOs35BHD8QAAiIUotsDoN+IR++EA +AC/yBS+GwO832BHz0QAALuIFLvbALXK9HjZFDt0BDZ0CLXa9HDfYLHa8W/9X1KBmTmoSN86OEi8h +YPJZ6BWi7h0AD+4MB+gRqCIoIQMvIQJ48Uv19yIdr/kaACpy5X+nDX6nCgrIT/ggRhWv+BIA//fw +Da/0RQAscuXxn/jP0gCdAPGf+I+SAJ0ADMlP+CBGFe/58gAAAPQgCBWv+AoA/G92BaAKVQD8IEgV +4AtlAFgPov/3ZA2gBAUAAAAAAAD/9rANr+SlAOsSAylQBIAA/AAiHaANFQBa+ipj/b8AACly5X+X +Cn6XB//7zA2vmWEAx0T/+6QNoAkFAMZK//t8DaAJBQAAAABsEAbqNwQZeASAAPQgBh2gBuUA9CAm +HaAFFQD6QABCMPj1APhAC0wgewUAKECA0w/4gAAEMA4FAPcD3g2gGQUAHTQVCywCbZoOL9GUst39 +4Ab0IgCdALHutC8cN3YA8QTtoIMqwAqAAPmQEBXjeAEAJxQCLKCBeYFPKKCAwJD/UFAV5IgBAPke +4BWgDhUA+cIADLTMAQDonAEmY90AAP0CAAy0/wEA7pwBJ/vdAAD/wgAM9N0BAOycASbr3QAADck4 +9SAGwVIAnQDAoGag6vogaB3g+uUA+mAEBTAMFQBb+K5moNTlOgIA2AUAAPrgAAUwDBUAW/ioK0CA +ZqC7+mfKBaS7AQD3ZD4NoHwFAAwsAvoAAh3gHQUA0w9t2gwtoZTs0T51UAkAALG7IhAB0Q8AZu8k +GDQiL4KE+8AEANAJBQDgmRoPAQqAAPygAQZf/fUADcwDDP8BCf8C/xCGFe/76gBmv8QcNBUtwoT7 +YAQA3/71AOIQASrQCoAADq4DDt0BDaoCKsaE0Q8AAAAAAAAA//zcDaAKBQAAAAAAACoK4PogQBXg +DBUAW/h7Zq8cHzch5/SAJXjNgAAoQIAICER2iSMbM7T8DgIdoA0FAPxGAA4wGQUAbZoNLrGUfOEL +7dwBJdgJAADSoNEPZt/4EjPzKCKEANEE/KABB9/59QAJ+QMJiAEI/wLvJoQtEASAANEPAAAAbBAG +/mnsBeAK5QD2bPoF4H4FAPxAaB2gOAUA5BQAJ/uBAAD3AApLoAQVACgK//hACJQiAJ0ApykpkIDT +D/5GAA20mQEA+yQeDaAdBQD74GgdoAwFAG3aDiihlLKq+wAFdGIAnQCxzLQsGzbtAMEE0w/tsIAq +SAqAAPjwMBWjqQEAKhQBfZFSLXCAmhH68HAVoAkFAPzwUBWk3QEA/b7gFeALFQD9YgAM9IgBAO2c +ASRD3QAA+aIADLTMAQDrnAEmY90AAP1iAAy0qgEA6JwBJVPdAAAKiThvknPAoGagkvogaB3g+uUA ++mAEBTAMFQBb+CVmoHzkOgIK2ASAAPzAaB2nqgEAW/gfZqBmwCDRD2bPVB0zpSvShPuABADQCAUA +4IgaDgEKgAD8gAEE3/r1AAqZAwm7AQi7AvuwhhXv/KoAAAAA//5QDaAKBQAAACoK4PogIBXgDBUA +W/gK6zaxHXviAACJEflwBh3v/coAAADGqqcsLMCA/IAABjAN5QB9ySMcMz/6DgId4A0FAPpGAA3w +HgUAbeoNLsGUe+EN7dwBJmAJAADSoNEPAABm3/YSM34oIoQA0QT8gAEH3/n1AAn5AwmIAQj/Au8m +hC0QBIAA0Q8AbBAGIzAIJCAi7SAjKAQKgAD4YAUpkgCdAO8zghgECoAA9mAEqJIAnQAo8H3A7vpm +PgWgCwUA/wbADxAZBQD/oAScIsQBACkKEPmGAA5wCwUAbZoMKKGU7IExdVAJAACxu/AAnA2v+7UA +AAAAAAAAAP+sJg2gbHUA0w9tmgwooZTsgQh1UAkAALG7x7sZM1IpkoXBrwuqDPsgwQWv4tUA0Q8q +8H0PAgAPAgB8rwJ+2Q38aoABX+KlANEPxirRD9pA/AuCHaCrBQBb/tP/QiAOX8I1ANEPLApg/IYA +Dj/+cgDuPP8qUASAAPwMwh3gbIUA/6IADjCrJQD8IGgd4A4lAFv/StKg0Q8A+h/iHaCrBQD8IGgd +4CwlAPyAAIYwDiUAW/9C0qDRDwBsEA4eMuscNDb8AgId4ArlAOLifSkgBIAA+Z4wFaAFFQD/0CgV +oAuFAOJDCAZjgQAA648BCZ5CgADuMwgEcQ6AACgwIycwLCIwNvsKpg2gDgUADMsC+mawFaL0AQD9 +5gAP8AUFAG3aDCixlO+BCXXYCQAAse4u+vv3wGgdoAGKAORAH2lOQoAAqekqkDYrkCwrNCwqNDYp +kDX4ZqYd4AIFANEPKjA1IjA25zAsLlgEgAD+AAIdoBgFAPHm0A3gbXUAbYoMKbGU7ZEIddgJAACx +7sfrKwr/77Q5DzAEgAAeNiYYMvLp4gEg2IEAAJmx/8AIFaAd9QD/YAYVoA4FACiChSswLAbZDHmN +DX2xJ8Ag0Q8AAAAAAAAA/WALfWIAnQD+bGYdoAIFANEPLQpg/IYADv/+QgArMGPqFgwlkXGAAC8w +YrG4KDRje/vB+gCiHaAbhQDsNgoaaASAAFgN8sGd+GWGHeAKBQAqNGMqNDb6ZqYdoAsVAPplxh3g +DAUA+oBoHaCrBQBb/lpoownAzf1AIPUiAJ0ALBwgDFwK7BYNKlAEgAD9gBAVoKsFAFv+UMHd5qPr +bWAEgADyozAN4A4lAPVAF1oSAJ0A9UAXmRIAnQArMCwvCv9/wRUoMCPAng8CAPkAFgRiAJ0AKgoI +KjUf/WAM5GIAnQAvCv//gA88YPr1AJobnBr9YBB0YgCdACwSDQRKAv2AMBWgqwUAW/406hYOLR2i +AADqNDUigGmAAAqtCg/dES00NSswLPwAAh2g/fUAd7kSLjA2cukMiBwvMDX5//W8IgCdAI8anBOb +FIkb7RYCK3AEgADqFgEqaASAAPggBhXgCkUA/GuCBaAbhQBYDajAINEPAADBL/oAoh2gG4UA7DW7 +GmgEgABYDaHyZYYdoA4FAP5mph2gChUA6jQuIvNhgAArMCPAzv1gBfwiAJ0AxccaMi/6AAId4B0F +AG3aDS+hlHzxTOu8ASVQCQAAx7saMnEpooT4ZfYFr//1APwAIh3g8vUA7jRjLYEKgADg7BoNgQqA +AOKEKS7oCoAAD90DDZkBDJkC+VCGFeACBQDRDwAAGjJhKaKE+GXUBa//9QD8ACId4PL1AO40Yy2B +CoAA4OwaDYEKgADihCku6AqAAA/dAw2ZAQyZAvlQhhXgAgUA0Q8AZF3S6zAjKlAEgABYCa/6bHAV +7/cSAMXA/IYADj/9BgAAAAAAAADsFgoq8yYAANpA/ADCHaCrBQBb/dOMGv9AaB3gHdUA9UAO6JAO +JQD1QA6pEgCdAPVADmwSAJ0AKzAsfbECLjUfKAr/+f/xZSIAnQApCv/5n/ENYgCdAMDw/mPkHe/4 +XgD1QAm1kgCdAPVACiYSAJ0A9UAKZpIAnQD1QAqnEgCdAPplkBXv9wIAAIwd2kD9gFAVoKsFAFv9 +suoWDy0N4gAA/AGCHeAMtQD+AKIdoA9FAOoWECKF4YAACksU9WAEDNIAnQBouHnA4v5lhh2gCyUA +wf1/sTOMHdpA/YBwFaCrBQBb/Z/VoOahe21gBIAAKjQ19UAHWJIAnQBvpFfA2i00NvplkBXgABoA +wMAtEhD/9ogNoAoFAMHw/mPkHe/1EgAuNCz7wGgd7/R2AAAAAAAA+gAiHeAIFQD4ZYYdr/QiAGi5 +YXyxXm66Hi40LP/+AA2gC1UAb6YwwJv4ZsYd7/6SAAAAAAAAAAD6ZZAV7/2SAA2pAWiUc2iYe/pl +kBXv/U4AAAAAAAAAAPVf+6xSAJ0AwKz6ZsYdr/2uAC40LPvAaB3v8o4ALzQs//yQDaALRQDAsSs0 +LP/yLA2gCxUAAAAA+gDCHeAPZQD+ZYYd7/HiAPoAYh3gCDUA+GWGHa/xogDAmfhmxh3v/G4ALzQs +++BoHe/7fgAuNCz7wGgd7/tSAC40LP/4zA2gCyUAAAAAAADqFgop0ASAAFvhKoIa0Q8A6hYRLQJi +AADAovxp5gWgG4UA7hIRKmgEgABYDNbAINEPAAAAAAAAAOKkAAnQBIAAW+Ec0Q8AAADipAAJ0ASA +AFvhGNEP2jBb4RfSUNEPAADiEhEp0ASAAFvhEtEPAAAAbBAEHTGm/mNyBaAL5QD0YrIF4AyVAPpE +cBWgB4UA9ERQFaAPFQDwaZAN7/b1AHyhAnupRCjgfQBBBO4yIxRxuoAA+0zGDeAZBQD2hgAN8AoF +AG2aDCxRlOvBCHKoCQAAsarHqyjShAChBAD+GgbpAwmIAQjuAi7WhBwxVQNLEay7KrKAHDGIDKoB +KraA7UQACfAEgAD+QwQV4ApFAPxpbgWgG4UAWAybwCDRDyjgKAD9GgbZAwmIAQjdAv3FBh3v/uoA +fKENe6EK2iBYAO1j/7sAAAAo4H3TD/8JAA8QDAUA+0gGDeAZBQDnSwIOUASAAG2aDC5RlOvhCHKo +CQAAsarHqyjShAChBODJGg0BCoAAAPsaBrsDC4gBCYgC+bCGFa/+ogAeMejt4CgqAQqAAAD5GgaZ +A+ndAQ5ACoAACN0C/cUGHe/+EgAAAABsEAYjICMlCg70RFAVoAqVAPpg5g2gBwUAdTkUwY8oJCx1 +OR0pCtD4Q6Qd4AB2AAAAJyQs6kQACdgEgAABEQJYAPcqCsgqJR0nJCD6QGgdoAsVAPpIZh3gDAUA +W/+W5qDXbTAEgAArCgl7MQf0YAZNYgCdAAvqMBo0b9MP0w8som/9YAwbogCdAB0xRRo0ai3SICum +b/tNyBWgDAUAWA1fGjFALKB9mxDzgAjPEgCdAPRgCIxiAJ0AGjRgGzPvWvbPHTE3HDRciRAqJGIv +wh8eNFoYNFoJ/wyu/ujyB3vQBIAADuoCLsCAAEAEDgsbf7c6KNB9GzIkx//rvOAkcRyAAPeQBh3g +bnUA/AACHaAYBQBtigwpsZTukWJ12AkAALHM8AFgDa/8tQAvJGPAoeokLipQBIAAW/3b0mDRDwAA +AAAAAAD6gAQA0AgVAACIGg+IAwjoASjEgPRgBQxiAJ0AwZD4hgAPcAwFAG2aDCixlO6BCXXYCQAA +scws+vseMPTTD9MPK+KH+4AEANAJFQAAmRop5od7mJMJ6jAr0iAKuyirmQvqMAubDPd/++CSAJ0A +bQgNDOowDJwM95/7WJIAnQBj/+saMkQbM6xa9owdMPQcNBiJECokYi/CHx4yPxg0GAn/DO7+CAvQ +BIAA+f/3oyIAnQD7wGgdr/uyAC4KYP6GAA8//BYAL6Jusf//TcYV7/niAAAAAGwQBCMgI8BO9GEG +DaDChQDRDwAAIgrQ0Q8AAABsEAT4RHAVoA0VAOQgIikYBIAA+khQFaAJ5QD5AASMYAIFABsw0iuw +fcHo/2qgDxAfBQAOTgLrMG8ZYASAAG36DC+xlO7xCHXYCQAAsczHyx4wsyjihQDBBADbGni4GCni +hyvmh3uQN+00Qi0ApgAAYABMAAAAAADtNEIlAiGAAMAg0Q8ZMTEpkCkAQAQJCRsJC0DrNEIlATGA +AH+XVNEP4jRCJX7hgABgAEcAAAAAAOI0QiV+YYAAYAA3AAB/l78bMGQDShGrqiuigBwwlgy7ASum +gPtQCBWgAhUA3UD+aFAVoApFAPxnlAWgG4UAWAup0Q/aMFgAAv//gA2gAhUAbBAGFTBsJCAiGDBR +A0MRqDMuMo0cM8AoMoAvICwqIRiaECkgQvggJhXgG4UA6SBDKmgEgAD4IEYV4IhxAPggZhWgClUA +WAuTKiAs/EMEFaAZ9QD5QoYN4BvlAHuhDMjJLSBC7iBDJoAxgADRD2Tv+sCl/GdSBaAbhQDuMo0q +aASAAFgLhCgygAWIAig2gC8ygMCl/GdEBaAbhQDuMo0qaASAAFgLfMCl/Gc8BaAbhQDuMo0qaASA +AFgLdsCl/GcyBaAbhQDuMo0qaASAAFgLcd1A/GcqBaAKVQD+cagVoBuFAFgLbNEPAGwQBPRgCokQ +C7UA9GAKS5AKBQBoOS17MSroM4oR0J+AAAg4CoiACoAAwZAJqgL0YAqzkgCdAPRgCnESAJ0ALBoA +DKoCGDAJAyQRqEQoQoAZM34JiAEIqAIoRoAuQoYfMEIP7gIuRob8n8Id4AUVAO1GgSGtKQAAaDZC +aDQ/9GAG+5IAnQD0YAa5EgCdAPRgBrwQCZUA+GAGfGIAnQD0YAY5kgCdAPRgBrySAJ0A+mAGfGIA +nQD4/8Id4AAeAClKrvpgYgWs+/UAC5sBK0aBKqB90w9/r3bqJAAJ2ASAAFs3EOokAAnYBIAAWzad +6iQACdgEgABbNdUZL/YqkoQpkoiiqgmqEaqZKZEfHi/y+KAABPAKpQDrnP4kjf0AAAulONlQIkKD +Hy/sDiIBCf8tAv8CL0aDLUKEHC/pDt0BCcwtDcwC/JCGFaACBQDRD8Ag0Q8AAAAAAAAA+l/EBa/6 +3gD4lMId7/1yAPiZgh3v/VIAAAAAAAAYMzX5RgANP/siAPiJgh3v/PIAKUoA+UYADX/6vgAAAAAA +APgMgh3v/hoAbBAE6iQACdgEgABb45dmoDHqJAAJ2ASAAFv/kRkvqwMoEamIKYKAGy/BC5kCKYaA +wCDogoAlAF2AAGigA9Kg0Q/RD9Kg0Q8AbBAK/E1QFeAc9QD6ASIdoA4VAPRfNgXg/wUA9ERQFaNt +AQDjICMjAcmAAPzOoADQBwUALCArzsEoIEL4RBAV4AoVAPETsA3gDGUAK5z6C6c57CQgK5AEgADR +D9Jw0Q8ALSAsA0YRpWb9oA/kIgCdAPpgGOQiAJ0A2iBb/y0tIGrAqf4eAh3gHPUA/6AEBvAOFQD/ +pgAOsAcVAPxNRh3gAEYAAAADRhH0wABDcAcFACggLNMPDwIA/QAMPCAL5QD6YAxUIgCdAPpgDBRi +AJ0ALSAjIyAi7yBDLUgEgAD1oAZLEAolAPmgCiRiAJ0ALiRD//4CHe8N9QAoIEEjYo1kgPMsICv6 +YAQDMAkVAAaWOfzf+RwiAJ0A+mAKqKIAnQAqICIYMV/AwOwkKy1UwoAAqKoeL4euqimigA+ZAQuZ +AimmgCwgIgPMEajMrswqwoD9QAQFcO4FAA6qAirGgN1A4xYAK3gEgAD8ZYAFoApFAPoDAh3gDhUA +WAqT//rUDaAHFQAuICIfL00D7hGv7h8vcK/uLuKADj5ALiQg/y8ADzANFQAO1znScNEPwI/4IQYV +oAolAOkSCCnswoAApd2dFy3SkQndAQ0NRy0kQ3nRCcCA+EhmHaANBQBk8ghl3xCJFyySgB0vXA3M +ASyWgPswCBXgCwoALSAsfNEcKQocedEWLAoefNEQKCEY8QCgDe8N9QApIEJkkeIqICv/QZAN7w31 +AMBg//vYDaADBQAtICz5v/XKUAolAMCB+CEGFa/92gAP2QH4TUYd7/naANogW/54wKn8A+IdoA4V +AP/5vA2gC+UAAAAAAP/3HA2gBwUA+l3aBeAMFQD8RWYdoA0FAC0kICuylSogIpoV+jgAA/HbqQD8 +ISYV4MuhAPwghhWgu9kA+iDGFeAKRQD8ZOAFoAsFAFgKRIkZDwIA/SYgClAMdQBmkCkvEgUD/xEF +/wgo8oIq+vDqiAEM98KAAAjuAu72giuA/gAA8ACIDaAHNQD1IAj6EgCdAPUgCyKSAJ0AZH/k+P+g +FeAIBQAJhzj6AIIdoAsFAOwyVhvoBIAAWAopiRXrEgQjpKcAAGZwIQOcEaXMLcKCLvoP7t0BC9bC +gAANqgL7kEYVoABiAAAAAAD04AciEgCdAPTgCUqSAJ0A6hIGJYChgAADnhGl7i3igsDxD90CLeaC +ZK3hA5gRpYgvgoLBoAr/Av8QRhXv90YAKSEfCQlF/T8AFeALJQANqzjtYoAkxSEAAGiSXWmRBQ3a +UmijPScgI+pEAAvYBIAAW+KXZqyx63QAClAEgABb/pIsYoAdLsQNzAIsZoD60AgV7/JeAGTdB2AA +7AAADd9SZf+12kBb/ohj/HwoIENkjhYpIGRlnhBj/PYN2lJpoptj/98rIR/5f/c0UgCdAI4VA+4R +pe4t4oLH8A/dAQzdAv3QRhXv+zIALyEf+f/5DFIAnQADmhGlqiiigsfA/QAEBDAMdQAMiAL5UEYV +r/wSACshH/l/9MlSAJ0AjhUD7hGl7i3igsfwD90BDN0C/dBGFe/5/gAvIR/5//ahUgCdAAOaEaWq +KKKCx8D9AAQEMAx1AAyIAvlQRhWv+t4AAAAAAAAA3TD8Y94FoApFAP5IcBWgG4UAWAm//APiHaAL +5QD/8HANoAolANogW/4VY//SbBAEFS6BFjHk8w4ACjcyAQDiUoghjOEAAChSgKSICYgRqCIkIA0j +YvgYL9viIAwiAWmAACiAfeIzCAIr/QAACFUogmelMwozEaMi0Q8pUoGkmQmZEfhAAEF//yoAimcK +IhGiotEPAABsEAQbLmfzDgANN5IBAOiyiCSN+QAALLKAqswJzBGsiBsxxCqADR0vwiiADOKyByUA +mYAALdB9LLL4sKkNmSioyKmICokR6SIIAYKxgACKIYsgCgqO6wsWCUAEgAD6QCYV4Al1AG2aE4mC +6oYAJEAhAACKgQkJjpmBCgqO6oYAKVAEgABYC6raIFgLptEPAAAssoGqzAnMEf0AAEQ//hIAiiGL +IAoKjgsLjvpAJhXgCXUAbZoTiSLqJgAhECEAAIohCQmOmSEKCo6aINEPAAAAbBAEEzGYDCIRoyKC +INEPAGwQBBUxlQwkEaVEI0bAJELA0Q8AbBAEFTGR+F2aBahiHQDqZBELT0KAAOVFCAzPQoAA6JkI +BDnBAADnQggBgemAAPZAaB2gA4UADwIAbToQ45IcJMghAAAkkhsklhojlhsGYIYFAmcGQIYFAmUG +IIYFAmMGAIYFAmHRDwXghgICbwXAhgICbQWghgICawWAhvIQqB2gA4UADWIRCCILDwIA0w/TD206 +EOMiHCEQIQAAJCIbJCYaIyYb0Q8AbBAE8l1IBagyHQAKMxGjIiIscNEPAAAAbBAEBOowGC3IKIJF +AogoqEID6jADIwxqMQ5tCAgJ6jAJKQxqkQJj//DRDwBsEAQWLgmmJiVigMd/BzcDB1UBBUUCJWaA +0Q8AbBAELSANKyAMFC9I5y9KFothgAAocH0uQlmw3wj/KKvur+4oIAX9BUAB0Ao1AGiEefUACWKS +AJ0A9QAKOxIAnQD1AAqLkgCdAGiIBMAg0Q8AKiQFZNFcGDBk0w8I7gsq4sAfMTgKDEoIzBEPzAL9 +4AAGMAkFAP0XZhWpqmEAbakCKYa8KuLAHy2j0w8KDEoIzBEPzAL94AAGMAkVAP0XZhWpqmEAbakC +KYa89WAFaxIAnQAaLbzoQqYmh1GAABkudqm5KZB9I6KBrZmpMwkzEaODIzyACLYRKjIULqEDLaEC +ftF3wLBa85goMA3Lpy8wVcCRCJg5Cv8ICPgM9wYACrCIBQDoVQIJ0ASAAPqgaB3gDBUAW/aq3KDr +VAAJ0ASAAFvqSmP/sGSPw+owDCQBMYAALHB9K0JZsIkMmSiquKmIGS77CYgKKIKA//64DaaIAQAA +APlAaB2v/6YAwKUqJAXaIFvrJPFH6A3gDIUA7CQFLRAEgADRDwAAAAD/YGgdr/qOAPoAAh2gDIUA +7CQFLRAEgADRD8DY/ECmHeACBQDRDwAAI6KAqzMJMxHzAABB//yWABgw5QbvEaj/KPKQ8R/0o9IA +nQAIKkH4AIId4AgFAG2aBHqBBLGIY/55Kowk+/JGFa/5zgDSoNEPbBAEFi/+BiYLJWLBx38HNwMH +VQEFRQIlZsHRD2wQBBgv9yiCrnGGEYkizpraIFv/ec6jaFMHwCDRD8Ag0Q+KJ/qAaB3gDAUA6qwg +KmgEgABa613SoNEPAGhT3oonwLD7RAAVoAwVAFru7x0ugZ2gjCD6YXYF4A0VAOumAi5mAoAADcwC +/UAmFaACBQDRDwAAbBAELiANLSAMEy8X7C6rFwPBgAAswH0qMlWw6wy7KK2qq6oUL9IEqAsvgsEZ +LrgcMKn55gAP8Ao1AP8YJhXgGwUAWAhwKkKucaY0KyICz78CKgJb/0zPp4sgLjKa+nVIFaAMFQD/ +bwANsA0VAFry9y8gI7H/LyQj0Q8AAAAAAAD6QAgV7/9aAPugaB2v/l4AAIonwLD7RAAVoAwVAFru +vR8uUJ+giyD+YRQFoA0VAO6mAi3mAoAADcwC/UAmFa/+cgAAAAAAAABsEBAZLRcpkjsUL6YXMIH/ +OAAUsCgFAPkPAAxwAhUAEzB9K3IRIzLz6bz/LAIKgAD3YAZokTOdANaQ/T8gFaAFBQADCEFpgwJ8 +WRf0oCAV4jMdAOtZ63Mz/QAAYACiAAAAAAAdLP8t0oAqcl6tbQndEa2qLkKuLaAi4OcVf3gEgAAO +yEJ42QoeMCHAgCh0uA7+AQDRBPxAAQff+PUACP8DD+8BL0auKUKucZaeiaKaGCwWFOsWFSyApgAA +ihhb/v8rEhXsEhQlfCGAAIoYiqfAsPtEABWgDBUAWu58KxIVjRgeLg2eoI3QLBIUHjBH7qYCLu4C +gAAC3QL9QCYV7/06ACpyZiihAy+hAvngBRwiAJ0AFSybHDBA/CEmFaADBQDbMFryuBwszizCgCZy +EStyXurKCA0YBIAA6S4tHVZCgACqui6gDSmQfS2gDOoWFidD/QAACYgorWaoZg7WOARmCy9iwQ+P +SWXwUyliwQWZAilmwS9iwRgwKQj/AS9mwS5yViuiAPrsyBWgDAUA/28ADbANFQBa8nsqcmYuoQMt +oQLAwf+vAA6wCwUADcs4ZL9uEy4ELzKDcf4YwCDRD8Ch/CEoFaAbBQBYB9z6IsgVr/5uABswEyUy +uJUdHDASJTa4CwCH6wAHANBBAAAKAGGPFY4UiRbpFgAq6ASAAPgg6BWgGwUA+CAmFaAKVQBYB8st +MoMeLJcqchH/pgAOsAQFAO02gyUEQYAAZFCAFS//KQqAmRzkXwwCwmEAAOgWCyCwQQAA/iFGFeAA +wgAAKnIRjR2MHIsbDR0U7RYNJmAFAADsFgwl2AUAAOsWCyIgBQAAeks4jh3L448dgxrjQwgH/0CA +ABssdyuygCpyXqtLCbsRC6oIW/8ob0SxLDB9ZM+rjhvAwP/csBWgA3oAHC/fjxaOFY0U+CDoFaAK +VQD4IAYVoBsFAFgHnSgcEAggh8BABEJiASBj9J/2/xIAnQATLGArMoEqcl6kuwm7EauqW/8SAUSH +sUQEQmThRAcKd5AAAGP+tAAAAOlUAAIEoYAA+oBoHeAKBQD+gYAH0PuNAOpQfSLIBQAA5PAvZ9v9 +AADtkH0kwAkAAA8CANMPbboO64B8JEAJAACq2i2Ae6q66oB8LVgEgACr26uqqsoKXxQO/xEPbwz9 +4GgV5JoBAACRBAAoGgjdAu32AyZgBQAA/5/2VCIAnQDqEgwoBAqAAPmf+6hSAJ0AY//CAAAAAAAA +//7cDaAKBQBsEASKJ4kwK6EV90QAFa/NBQD8wAQG98UBAP1gAEX2iUEA67xALhVcAABkgIaJqwiM +EeycCAJT/QAA7K4RBmAHAAD7gATy4gCdAO7OCAHAQQAA/2AE46IAnQBoQQptqQUIAIYMAmGJY4iQ +sYiYkI8w8+AFjBIAnQDAINEPAIoxCgpHaaHy/kKQFaf5AQDv/AErUASAAP4uAA/wCxUA/8AAR3AM +BQD+QoYdoA0VAFrqBtKg0Q8lMBceL3QvqRTpoggiqAUAAOmmCyrnAoAArP8vpRSekIwgCMwRDFUC +9SAmFe/9PgAoYQX5jwAOP/1+AAAAAAy7DAtJFLieDq42bekFCACGDAJhA7gI6U8MBskBAADv/P8k +QEEAAG35BQgghgkCY2P/QBUsQSSQEIphI5AX9IABAnAHBQDpqW50qEEAAPrAaB2gCxUA/OBoHaAN +FQBa6d2NY43Q2iD4QpAV590BAO3cASrYBIAA+IIIFaHdHQDtmQgJ4ASAAPhChh3gDSUAC4AALmID +DwIAZO7q6zQAC1AEgAD8YGgd4AwFAFrpyvbAZhXgAgUA0Q+OINtQ6EIQKVAEgAD9wAAXMA8VAO/u +AgngBIAA/yAmFaANJQALgACJY2SeoS9pBOlmACGQBQAA52YDKRcCgAAC/wz+wIQd4AIFANEPAABs +EATRDwAAAGwQBBosei2ihCiihymih/lgAAQ7mYEAeYkB0Q8pooIi0AdvKwLRDwDApfxeMAWgCwUA +/kAAFzD/BQBYBtYZLL/sK20RE8UAAPBD8A3gDYUA/gHiHaB6FQAP6jArwkWvuw/qMA+/DGrxCAjq +MAi4DGuB9g4vNg+qDC2WUu8iDA1fwoAA65ZTKX6OAAAL6jAI6jAqwkWrqgioDGqBCAzqMAysDGvB +9i2WUi4K4i6WU9EPbBAEBOowFS72IlKAckMEJFaA0Q8oUn/kVoAkQAUAAChWf9EPbBAEEywciDhp +gA4K6jCJOQqZDGqRA8Ag0Q/AoVgEL4k4apEcGyw9DCoRq6orop5uvRwiop3kICVk4/0AAJw40Q/A +oFgEJok4a5HYwCDRD8DaDZ00/GEGFeACBQDRD8DaDZ00nTjRDwBsEASJJyiZFPskABWgAgUA65IJ +JAEBgADxYYAN4CylAB0sxSmwAIuyfJkIfbEIHizDfrEC0Q8AwLL8AAIdoA0lAFrpUtKg0Q9sEASJ +JyiZFOuSCSQAgYAAiSLInsAg0Q8AAAAA///ADaALBQAssB2Ktou1AMwyWAXn2iBb/+HSoNEPAABs +EASLNYg0LDAc7TIGKVAEgAALgADSoNEPAAAAbBAGLzIAJCIAGCvw/nQABff/wQD14AbG0gCdAAj4 +CiiCeGSA8BktvhgupCmSrg/1CuhVCASEPoAAKlB880AJ99IAnQDmUH0loYKAAAtsAQwMQ/1qXg2g +/fUAJ1B+fXEMizELC0f3YAetYgCdACdQgCpAIIswHCyhd6gLI1B/L0AhfLhJc/BGGS6NBkhDDwIA +CYgKKIJ/BEoCC4AA6iYAJQSJgADAINEPHC6GLkAN/IGQFeAKJQD6IAYV44YBAPggJhWgCwUAWAY8 +xirRDwAcLn0uQA0tQAyTEfogBhWgCwUA9iBGFeAKJQBYBjPHL9EPHC52/IGQFeAKJQD+gbAVoEkF +APggBhXgCwUAWAYrxirRDwAAAAAtQAz+gbAVoAolAPxc1AWgCwUAWAYjIvra0Q8cLmcvQCEuQA0t +QAwqQCCaEClQf5kR+LAQFaALBQD4IEYVoAolAFgGGMYq0Q8cLl0uQA0tQAz6IAYV4AolAPYgJhXg +CwUAWAYQxirRDy1ADP6BsBWgCiUA/FymBaALBQBYBgki+rnRDwAAAGwQCh8uTw0rEQ+7CCqwgOyw +gif6sQAADy8LKPDV8gAiHeAOBQDszAElU/0AAOyqAQRABQAA+kUABjeqAQDqtIIkAwmAAP1j6BXg +BAUADckKiZAKCEQAgAQJCRnJnG0IFH+fPrGq+C4ADPeqAQDqtIIkgFGAAGP/5AAAACmwgejw1SZg +BQAADJkMCUw4C8oR/8AgFaeqAQDqtIIkQAUAAHjjqh0qpwisEfuxCBXgHhUA/kAKJCIAnQAl0oCq +VQlVEeW1CA4YBIAAFCsBAwJHBCIKKCKOA4oUC4AAKCKS+mBoHaALBQALgAAoIpTaMAuAAIehDwIA +9UBoHad3AQD04Ahq0gCdACqiABkrSvagaB2n+sEA9eALHtOqoQAJ+worsnhksXYcLRgYLf0swq4P +8groIggGBD6AAC0gfPOgDl/SAJ0AmhgrIH3zQAaKEgCdAAq+AfohBhWj7gEA/0AF9SIAnQAqIH4o +Cv94oROJQfog5hWnmQEAmRT7IAtNIgCdAC0ggC5gIIpAfeggL2AhnhadFRgr8ywgf5wZ+UAFcKIA +nQCcGf3gBSYiAJ0AGS3dC0hD0w8JiAoogn/rpAALUASAAA8CAAuAAOWkAAUHaYAAwMBmwDqIQBkr +FgiIVwmICiiCeOpUAApYBIAA7HQACegEgAALgADRDyXSgapV48MCCq5CgAD1YABC//r+AADGyuo0 +AApYBIAAWATv0Q8cLcGJGC5gDfzBkBXjiwEA+CAmFaAKJQD4IAYV4AsFAFgFd//+OA2v7KUAAAAA +ABwtt4gVihYuYA0tYAyJGZkR+iAGFaALBQD4IEYVoAolAFgFa//9eA2v/PUAAAAcLaz8oZAV4Aol +AP6hsBWgSwUA+iAGFeALBQBYBWFj/6QtUAz+obAVoAolAPxbRAWgCwUAWAVb/ftCHa/8dgAcLZ4v +YCEuYA0tYAwqYCCaECkgf5kR+FAQFaALBQD4IEYVoAolAFgFT2P/WhwtlIgXLmANLWAM+CAGFeAK +JQD4ICYVoAsFAFgFRmP/OQAAAAAtUAz+obAVoAolAPxbEgWgCwUAWAU//fciHa/6ugBsEASJMNpQ +7S2FGdgEgADsMAgkqDyAAG7GLfAAGA2v7KUAwMDuKmkUpGSAAC/Qgi+0CCnSHq6ZCUkUmbQo0h+Y +tVgEm8Ag0Q8s1IL//1QNoAwFAABsEATmJAAJkASAAONEAAsgBIAADwIADwIAbTkP4yAAIRAFAADj +RAAiIAUAANJg0Q9sEATWINMP0w9tSQfjJAAhEAUAANJg0Q9sEAQpCmD4BeIdoHulAPIuAAqwOpUA +bVlaIjABcosMcqMJ9loAFeAAZgAAAOKbD3E7JQAAcrMH9lUgFeAAEgAiMADiiw9xmAkAAHKjB/Ja +ABWgAFoAcpsLcrMI8lUgFaAAIgAAIizJDCwRrHzsRQAiIAkAAMAg0Q9sEAQCHRRk0Hr8DAIdoAkF +APoF4h3gf6UA/gciHaAIBQD0AEId4AIFAOMnCAFQCQAAbVosInAADIgR4rsPc7gFAABy4wfyWgAV +oABaAHLLC3LzCPJVIBWgACIAACIsyagoBJII+SAgFeAFJQDoJAAtEASAAPJAAEPwCAUA7ZmxcVAJ +AADAINEPbBAEAjIUZCBn+gwCHaB8pQD4BeId4DuVAPRAAQcwAgUA8kAAQ/AIBQD8QQAV4AWFAG1a +LCJwAAyIEeKbD3O4BQAAcrMH8loAFaAAWgByqwtywwjyVSAVoAAiAAAiLMmoKOhGACIgEQAA7km0 +fpAEgADAINEPAAAAbBAE5yQAAYKBgAD6ByIdoCj1APoPQh3gaQUA8gACHaAGBQBtOS6nYyMwAAIi +CuOLD3MwBQAAc6MH8noAFeAAVgBzmwpzswfydSAV4AAeACM8yQMiCdEPwCDRDwBsEATwRSAN4AcF +AMO5/A9CHaAp9QD4AAIdoGoFAG0pLqNyIiAACIgK4psPc7gFAAByswfyWgAVoABWAHKrCnLDB/JV +IBWgAB4AIizJAogJ+IAGFaACBQDRD8CQ+IAGFeACBQDRDwAAAGwQBCMlAuMlAyFgQQAA/EAGFaAL +BQDrJQUhwf0AAPLAAAH3iB0A6CUEIYFBgAD6YGgdoA0VAFrjoGiuFfpgaB2gCwUA/EAIFaANFQBa +45pprunISykhBAyZESmcEJlA0Q/RDwBsEAQSKTYoIociIogJiBGoIogny4H8WWYFoApFAPxACBXg +CwUA7yIHKXAEgABYBGIbK/UcKP/tLKwZUASAAFqC7NogWoLP0Q/AofoIAh3gTAUAWFjO+kAIFe/8 +9QD6QOYVoA0FAFhBoWP/qQBsEAQTLIsDAIfjAAcBAEmAAAIAYdEP0Q9sEAQTKm4iMrgiNrjRDwAA +bBAEHilOHyyWGSyXEikcEyySFSySHCyTLDaOJTZ+IjaFKTZwKTZxLzaG7jaNJNEBAAAqNoDqNoEk +2IEAACs2ePpvJhXgCBUA+G6mFaBkRQDkNn0h69MAAO3SRSTJgQAAKTaIKTaJAtIokvAE1CiUUBIs +gQ7dKJ3AIjaPFCx9FSx7JTZ/JDaH0Q8AAABsEAQTLHoSLHr0AsId4AcFAPgD4h2gBNUAbUoi4jaA +IaALAADiNn8hEDEAAOhWNgKoBQAA50UCIZgxAAAmRQPRDwAAAGwQBBgpQAIERw8CAAhECihCjgKK +FAuAAPxiwIDRmgEAaJECaZMcKEKU2iALgADSoNEPKEKS+kBoHaALBQALgABj/+LAINEPAGwQBBIr +pSMioiIiXaMi0Q9sEAQaKegCKQnTDwqZCiOWZCr6wApKAfqmAA0wKwUAC6oCKpZlJ5ZmDAIAKZJm +CeowGCiKKIJFCIgKCYIKBuowBiYMamEObQgIC+owCysMarECY//w0Q8AbBAEFijLpiYlYoDHfwc3 +AwdVAQVFAiVmgNEPAGwQBBgsOA0nEQ8CAKh34nIAIYBRgAACyVMpNADwgHAN46LBACpEAPCgcA3p +smEAK1UA8MCQDerCAQAsZQDRD9EPAAAAbBAE5Sn9EYDRgADoUH0iqB8AACVSf7A0CEQoolKkItEP +0Q8AbBAEFSipJFKE+kAEANAHFQDgNhoJAQqAAPzgAQPf+PUACHcDB0QBBkQCJFaE0Q8AbBAE+AIC +HaAE5QD0akYNoFZ1ABIoT/pRMAXgAwUA/lJCBaD99QBtigwpIZTmkQhxEAkAALEzxzsssoTt5Ckp +gQqAAP3FRh3gChUA/UABBV/99QANrQMNzAEMqgIqtoTRD8Vg9kYACz/+sgAAbBAEFCiCJEKF+kAE +ANADFQAAMhoCQgECMjnRD2wQBBQoeyVChfpABADQAxUAADMa+GAAEb/29QAGNgMGVQEFMwIjRoXR +DwAAbBAE8lfMBeDJhQAJKSgYKIH4YABB8AoVAPpwRh2gCQUAKTSAKTSDKTU+KIB9DwIAf4cX2iBY +KRvipAANAOYAAMCrKjSA0Q8AAAAA2iBYKQzipAAFf2GAANEPAABsEATAoPoCAh3gDBUAWFu+8lea +BeDJhQAJKSj6AiId4Ax1AOkzCA1ABIAA+HAGHaAKBQBYW7X6cCYdoBtFAPwAIh2gCgUAWFuw+nBG +HaAbZQD8AOIdoAoFAFhbqxsoVyo0gyywfSkwgf+GoA+QAgUALbB8aJcq7zCCJoydAAD/LwAP9yoB +AAL/DC/8HfvgBADQDhUAAO4a/mRmFaACBQDRDyI2I9EPAABsEAQWKDCmJiVigMd/BzcDB1UBBUUC +JWaA0Q8AbBAEFSugDCQRpUSTQNEPAGwQBBMrnAwiEaMigiDRDwBsEAQqCmz8D+IdoBt1AFhbhcAh +AqIJAgJH0Q8AbBAEZEBRKSAAZJBLwHDoMAAiDMuAAHmJKm0IGgdGDOhhNWO4BQAAamIPo3iieSmQ +ACiAAHmJDGP/3qN4onkpkAAogAB4kwz5AjYN4AIVAMAg0Q8Axy/RD8Ag0Q/RDwAAAAAAAGwQBB0r +eRgrefmgaB3gulUAbaoFCACGCQJh6yt1HtAEgABYBU3RDwBsEAYTKm70VoQF4AgFAA8CACQyrhko +KAlJASk2rihWqChWqShWqihWq1heGhsnoio66Cq2RVheCuagqG0QBIAAWF3mWF2m0qBb/+NmIJVY +XRnmoI9tEASAAFv/3/6BgAiQBhUALFKA0w9/xxAdK1gNTQH8dcYV4Ao1AFqBSVhcfuagaW0QBIAA +WFwe5qBVbRAEgABYW77moEptEASAACIyrtMPDwIAdC9OHifeDi4BLjauWFufWFuP5qAobRAEgAAb +KKz8UVYFoAoVAFhXVxkrQOqWfSUG2YAA9zBGFaACBQBnIATAoVrmwdEPAABb/7pj/+1j//wAAPhQ +BgWiUkEACFcRBwRHCEQKKEKO6BYAKtAEgAAPAgALgAAKCUFokQf5IAVh0gCdAChClNpwC4AAzamI +ENpQC4AACglBaJECaZNlKEKU2nALgABkr+SWoRwqI5ygGysgGioOiBD6QAQF8pKBACmkgOs2rirQ +BIAAC4AAKEKS06D64GgdoAsVAAuAAPiSCBWv+8UA+mAEBfAMpQDsuwIK0ASAAAuAAPJf+pCSAJ0A +Y/8J//54DaAKBQD8VhQFoAoVAPoAIh3v/UUAWAKk//xoDa/yRQAAAAAAAP/9cA2gCgUAbBAEHSc2 +6zQACVAEgAD9qKgV4AwFAFgDruO0AA0QBIAA0Q8AbBAEA+owFiiYJGJ/dDMHI2Z/ImJ+0Q8iYn7j +Zn8hEAUAACJmftEPAGwQBPhA6BWv9fUAiYODIouCm5CKggVFAwUzAflAJhXgBgUAloKWg5Mi0Q8A +bBAE6zQACmgEgAD6QGgdoAwFAFqBCtogWoDs0Q8AAABsEAQVJ+WDWMgwySgYKccogqn5QAAEMYQF +APiBVg2giQUAmVjRD9EPx8+cWArqMBsnBSuyRSwa9Ay7KKuqmlnRDwAAAGwQBBQn1IRI8k/4BaAI +dQDoOCgBqCkAAHVCFCUirvijtg2gCQUAKiKtxyQKkjnRD8DA+gACHe/yRQAMsjnRD8Dg/AACHe/y +RQAO0jnRDwAAbBAEFCq1FSe/JECAhVi6OPCCgA3gAgUA+KRODaAJdQASJ+IoIq4JOSj5BBYN4AoF +ACMircckA6I50Q8A0Q/AwPoAAh3v8kUADLI50Q/AMPoAAh2v8kUAA6I50Q9sEARkMKL0YATCUgCd +AGQwkPhTEgWgCTUA0w/TD22aIetSByRIEwAA7VIGJGARAADrlgAiq+EAAOvNBCRAIQAAnbAYJ5ka +KX0GhjgYKY8bKY2JZR0pi49njGafqI9knNgdKYuZuIxjiWIbKYmfiJzYmbgcKXEZJyDrJrAZwgKA +AAhIAgmIAvmf5hWj6oUAbQgJsKrLrSnC/3mwAmP/78Ag0Q/HItEPAAAAGip0KqCAZK9e6iQACdgE +gAD8gGgd4IwFAO5UAAt4BIAAWACY0qDRDwAAAMcr0Q9sEATmJAABg1mAAG80X2QwXB0pU+wmkxnC +AoAACEgC+b/mFaPrhQBtCAqwu2SwuynS/3nAAmP/7vhSlAWgCTUADwIA0w9tmiHpjQQkWBEAAOmS +ACXYEwAA6VYHIqvhAADpsgAkQCEAAJlYwCDRD8ci0Q8aKkwqoIBkr5USJ1WJKOMnfRSNs4AAKzKu +ZLBzKjKtZKBvsJycKPjACBWgDxUAL6QA/0EGHeACBQDipAkqXgKAAA+7ApuhCeowKaUF/QAAFDAJ +NQAJiAKYoy1gBo5iLzat7+4CBugFAAAtZAb+wEYVpt0BAC1kBtEPxyvRDwDAoFv/UYkoa5GN//5o +DaAKBQDAoMDKDJw0/EEGFa/+LgAAAABsEAwbJuIPAgDrAAUIyASAAAkCYQkCYesABQDIgQAACQJh +CQJhZDCzGSZ69GAHaJIAnQD0YAepEgCdAPRgBLpSAJ0AZDCPGCkB+iBoHaAJNQBtmiHrogckSBMA +AO2iBiRgEQAA65YAJVPhAADrzQQkQCEAAJ2w6Sj2ENCBAAAfKQcbKQWIpR0pA4ymjqeemJzYjqQd +KQOYuIyjiKIbKQKe+JzYmLgeKOkYJpnsJigZ+gKAAA9PAgj/Av/f5hXj6oUAbQgKsKpkoHIo4v94 +wAJj/+7AINEPxyLRDwAAGSntKZCA6idQGtwCgAArFgLqFgok+qmAAOokAAnYBIAA/IBoHeCMBQDv +HCAo8ASAAFgADAqiAgYAAAAAAAAAAOkWCyrUwoAA+iBmFa/8TgDpFg0q3MKAAPogphXv/A4AxyvR +D2wQBBwm3orI5ycGG5gEgAD3QATAkgCdAChyrvoA4h3gCVUAA7k5+QAE4+IAnQApcq3kkJNla/0A +AJ3IwOLulAAk0EEAAAYghgoCYwYAhgoCYeQwN2TQwQAA8shoHeAIVQAKAmcDQIYKAmUIWhEKigKa +kS8gBih2rQT/Av5Axh3gAgUA0Q8AAAAAAAAA/KAAFrAMNQANzQKdkSsgBix2rQS7AvpAxh3gAgUA +0Q/AoFv+zRwmsorI+V/68JIAnQD//eQNoAkFAMCQwOoOrjT/gQYVr/2qAAAAAGwQCBgmXNMP0w/o +AAUIyASAAAkCYQkCYWQwnPRgBKpSAJ0AZDCNGCiD+iBoHaAJNQBtmiHrogckSBMAAO2iBiRgEQAA +65YAJVPhAADrzQQkQCEAAJ2wGiaTGSh3GCiKHCiIHiiGi6WNpo+nn5id6I+kHiiFm8iNo4uiHCiE +n4id6JvIHihsGSYb7CWqGcICgAAISAIJiAL53+YVo+qFAG0ICbCqy6gp4v95wAJj/+/AINEPAMci +0Q8aKXAqoIBkr2TqJAAJ2ASAAPyAaB3gjAUA/iBoHaAPBQBb/5PSoNEPxyvRD2wQBMo5bzQhyT4c +JZH6UKAF4+qFAG0ICrCqZKCqKLL/eMACY//uwCDRD8ci0Q8AABkpWSmQgGSf0CogBv9OwAYQBhUA +FSZfiVjjJoYUjf+AACsyrmSwiyoyrWSgh7CcnFiLICakAJahJqQIJKQJDOowLKUF/WAAFbAMNQAM +uwKbo4kiKCAGBpkC6SYCJEAFAAAoJAYvIAaOIvZ1phWvjdUA/gAABzb/AQD+QMYd4AIFAA7SOdEP +jiIt+o3+AAAHMAIFAA7SOdEPxyvRD8CgW/5WiVj5P/vQkgCdAP/+CA2gCgUAwKDA+g+fNP6hBhXv +/c4AAABsEASXI+gmXRrUAoAA6CYCKkqCgAAKmQLqJlgZ3gKAAAtrApshCpkC6SYAIRBBAADRDwAA +bBAEFiWBFCY95WKIIYDZgACkJCRAfSJigaNEpCIJIhGiUiIsgNEPACRigKJCCSIRolLRD2wQBBYl +1wIFRwZVCihSjgKGFAZqAguAAMecCakB6TkCAZ0NAADAOOOTAgIAqYAAGCf6KIKu/wDgAxAJRQAJ +MwIoUpL6QGgdoAsVAAuAAChSkOpkAAnYBIAAC4AA0Q8AAAAAAADzIGgd7/+aAGwQBBko84gwBAoG +KjQG+QAEBHeiAQDoNgAlLRkAAGijcBMltAOjCigyjgKEFNpAC4AAKDKS1aD6QGgdoAsVAAuAAPhy +CBWv+8UA+qAEBfAMpQDsuwIKUASAAAuAANEPABolQiuigPtRCBWowh0ArLsJuxGrqouni76NsMnT +/WAoFaAOBQCesO62ASnYBIAAC9AA0Q9sEAQCCkdopSgTJZXTDwOjCigyjgKCFNogC4AAKDKQ+0Bo +HeAMNQDsuwIJUASAAAuAANEPbBAEGSW6iCHpSTYJ0ASAAPkgABS/iAEA6YgCCuAEgADoJgEpWASA +AFv/w8Ag0Q8AbBAElCuVLiYmESMlEiggDSkhB4scjBuNGo4YLiRULSRg7CRhK9UCgAD6RYQd65kB +AAqZAuklByQAgYAAjx6DHSMkIS8kINEP0Q8AAGwQBBgmSGQgQ/pJqgXgBwUA+RAQFaAGBQBtKREA +YAQICRvvlwZzMAUAALh30w8qskgrsY8rRQCnqqo6+oBEHa+qgQD6gCQdoAIFANEPHSTELNJILdGP +LUUArDz8gEQdr8yBAPyAJB2gAgUA0Q8AAABsEAQZKIcokIAlkH8ikH7mJv0avgKAAOh3AgkWAoAA +BSIC9lcACXIFBQAFIgL2QAQDMPXlAPaAJh2oIh0ABSIB8oAGHaACBQArkIErRAIqkIIqRAMokIMo +RAQjRAXRDwBsEAQoIA3JgishK9ow/KBoHaa7AQBb/+LSoNEP2jDrRAAK4ASAAFv/wtKg0Q8AAABs +EAqWGBslDeMoYxnABIAAlxkrsa4qMh0pMH7lFgct3gKAAKul8yAH26IAnQAL6jAsMqcoFgP9YAdj +ogCdACs2px0khxYoVSoypv2oqBXgDAUAWAEAm1GIE+5iACLIQQAA8qHGHaAdhQD6oAYVoAIFAP6g +RhWgCsUA6FQPJ3gFAAD+wAYV4AjFAG2qBQQAhgkCYSJUz+gWAirQBIAA/iIAFaAJhQD+ICYVoASl +AORUziD4wQAA/iAGFeAkRQBtmje0iOgWAi9YBIAA+aHODaAZ1QBgABIAAAAAAAAA6YoGf9gEgADY +QJgSq4wszf8swj/spjQlUBEAAPqgaB2hCwUAWAH9HSSIKDE+LdIWsYj54AAEON0dAH2JBCI1PtEP +KDU+0Q8A0Q8uMqax7v50xhWv/D4AAA9EEQQUFAVKAmSgTMlMCk8E+16gFaAJFQDqmQwNAQqAAAVE +GPygAQLQBBoACl8EKqz1+0AEAN/pFQDqmQwNAHoAAABUGvQAAh3gA5YABQQZ/KABAtADagAADyIR +AhIU8mYACbAn+QABIhDmIgIJgFYAABQkmgQiAsAw0Q8PIhECEhQDKgJkoEvJLAovBPteoBWgCBUA +6ogMDQEKgAADIhj8YAEB0AI2AAo/BCqs9ftABADf6BUA6ogMDQB6AAAAMhryAAId4AGyAAMCGfxg +AQHQAYYAB/JQ8EgAETADBQDRDwT3UAF3EAciA3ZMBxQke9MPBCIC0Q8ABEgRBYgCZI/S4kQACpgE +gADRDwB1Mz5gAEUAAGwQAhYn1AQnA3YkwHZE1PNUAAQ6lKEAZJ7RZI9KBkQCGifOBiICCYgMCkQB +CiIB8oI2Da+APQByQb2wiOMiGAmYCoAABCIMdTsBsCL6ACId4DlFAPRvAAnwCgUA4yIYCZgKgADT +D22YJguqGOQjGH3YCoAAdCFIBCIM5TsHddgFAAAiLP8FMwzjIhgJmAqAACk6/umICATIEwAAeYtB +dCMHdCEjsbtksKLjtAAMQwKAAKiiB/dQAXcQByIC0Q8AAHU7s2P/wQAAdTPddTnVsbtksHgLGxT/ +eAAVv/8+AAAAZoAQ+SAgFaADBQD3AAARP/8SAAAICAbggAQEYFeAAOurGA2wCoAA+p8ADTAAagAA +b41A66YYDcgKgAD4ZgAJ8bqdAMCg8kYACXAIBQDII8CRCWYCZ29xsbvIvw9mEWVvZwsbFP94ABW/ +/YYA+0AgFa/9ZgAH8lDwSAARMAMFANEPAAAAbBACFid7diQy81QAAjlWoQAFRAxrTDBmQD2xRPZG +AAu6gD0A43UYAmTRAAAAQQQFBRkFAgYHUjvRDwAABCQRA0QCyELHL9EP+sgAEj/19QACVDvSQNEP +AMAg0Q9mIATSUNEPAAViEdEPAAAAAAAAAGwQCCMWASIWAOUWAynQBIAA5BYCKtgEgABYAM0oEgKC +EAODKAUiKKMi4qIIDZgEgADRDwAAAAAAbBAI21DqJAAJsASAAPCOcA3gLAUAdCsL8gACHeACBQDR +DwAAB08E58gMA5U5gAAAgAT64AQA0TKdAAVNGPZLAA+4AD0A/eAAB38tgQACNC4CMyzzwwAOf58B +AO9EGAnYBIAA7EsZelAEgACk2u2jD3Hb/QAAfKsH6toIAdv5AAAMrwwC+C4C/yzv7CgMdAKAAO6e +Ag/QBIAA7OsZfxAEgACu0u0jD3fT/QAAfCsH4tIIB9P5AADsIgwNnAKAAOOjAguBCoAA6jQACtgK +gABYAJJ6IxX6QAY1IgCdAABxBABoGvsABcLiAJ0A8n/gFeACBQDRDwAAAAD0QAVC4gCdAAlfBOSQ +D2yBCoAAAyIY4FsaCZgKgAD74AAGf9uBAA0kLg0iLPODAA04AD0A40QYCXgEgADqSxl6cASAAKtO +6+MPcXv9AAB66wfuvggBe/kAAPvPAA0/gwEADakuDa0s7c4oDOQCgAAMjALuyyN+0ASAAKvM68MZ +dtP9AAB+yxHg8xEG0/kAAPNGAAnwAgUA0Q8A8xHzRgAJ8AIFANEPwCDRDwAAZFFSDr8EZOFU7skM +DwEKgADguxoMggqAAPqfAAo/24EA+8AEAN/LAQANRS4NRCzgqBoMggqAAPvABADRJp0A5M4oCxgK +gAD4RgAJOAA9AOJVGAp4BIAA7lsZetAEgACrWuujD3J7/QAAfqsH6roIAnv5AAD/TwAMP1IBAA2E +LA2ILuTCKAxEAoAA6FUCCnAEgADiWxl60ASAAKta66MPcnP9AAByqwfquggCc/kAAOKiDA/8AoAA +D+8CDSQsDSUu9YMADTgAPQDjVRgKEASAAOpbGXrwBIAAq17r4w9yE/0AAHrrB+6+CAIT+QAA+88A +DT+DAQANqS4NrSztzigM5AKAAAyMAu7LNH7QBIAAq8zrwyp20/0AAH7LIuPc/ilEAoAA6DMCD5AE +gADRDwByQwJ1MxfyACId4AIFANEPACMR46MCD5AEgADRDwDyAAId4AIFANEPwLEFuyxj/qQLogz7 +8AAG/8sBAP/9NA2gDxUAAAAAbBACAwVf9F0AC39CgQADSxwPAgCrZvrA0g3gCQUAsZnyXQAN+AA9 +AOaZGAswCoAAq2Z7awIpnAHlQhwLGASAAKki0Q9sEALgQQQCZEcAAOMiGAmYCoAA0Q8AAAD8YAEB +UAMFANEPAABsEALgQAQCZEcAAPJLAAnxIp0A0Q8AAADynwAJsAIFANEPAABsEALLLfYAAh3gAFIA +AAAAbBACyi3yHwADsCItAOQvBAu4QoAAAEEEACUa9LgAEbslHQAlSh0EVQwMVRClIgciAtEPAMAw +0Q9sEAIC6jDRD2wQAswlA/AxYAAPAG8iBQPxMWAABW8jBQPyMQACANEPbBACzCUC8DDRDwAAbyIE +AvEw0Q9vIwQC8jDRD8Ag0Q9sEAIiCoAjCgBtKA4oN0AoN0QoN0goN0wjPQEDAgDRD2wQAiYnAAMC +ANEPAGwQAiUnAAMCANEPAGwQAgIERaQzIzw/A2MUbTkFJicAIixAAwIA0Q9sEAICBEWkMyM8PwNj +FG05BSQnACIsQAMCANEPbBACAgRFpDMjPD8DYxRtOQUlJwAiLEADAgDRD2wQAgMCANEPbBACAuQx +0Q8QAAAAAAAAACAFzeggBdU4AAAAAAAAAAAAAAAAIAXRTAAAAAAAAAAAIAXPNAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAACAFxrAgAtdcIALU3CAC6vggAtf4IALXECAC15wgAtcIAAAAACAC13wgAtYQ +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAEKaggBCioIAQzFCAEMhggBCaoIAQnhCAEMhAg +BCTIIAQn8CAEKnwAAAAAAAAAACAEMYggBDDoIAQl+CAEJXwAAAAAAAAAACACs6ggArswIAK1SCAC +o8wgArTIIAKjxAAAAAAgAqKgIAaWKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAtLkIALF +ICACyIAgAsCIIAKjzCACwgAgAqPEAAAAACAC0IggBpaIAAAAAAAAAAAgAs74IALECAAAAAAAAAAA +IALBTAAAAQIAAQAAAAAAAAAAAAABAAECAwQFAjIyAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAMQAAAA +AAAAAAAAAAAAAAAEAAAACACJBgAAAAAAAAAABAAAAQgAiRQAAAAAAAAAAAQAAAIgAAy8AAAAAAAA +AAAAAAAB/wAAAB/84TAAAAAA4AAA4AEAAAAAAAAAIAWhzAAAAAAgBaFoIAWfMCAFniAgBYCoIAUy +2CAFHpAgBR1oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAPXiCAD5tggA+bYIAPm2CAD9jggBAzc +IAQbgCAEIkggA9RoIAPR2CADjhQgBDtAIAOLsCADiHwgBR08IAUcFCAFFWAgA+bYIAUUiCAFE0Qg +BRLMIAXsCCADHgQgA2gsIAW/pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAOvZCAD +muAgA6mIIAOn+CADpnwAAAAAIAOkLCADrqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAdQ +iAAAAAEgB068AAAAAiAHShgAAAABIAdHqAAAAAEgB0WcAAAAASAHQ6AAAAABIAdBIAAAAAEgBzSI +AAAAASAHO1AAAAABIAczYAAAAAEgBzNYAAAAAQAAAAAAAAAAAAEAAQAAAAAAAAAAAAAAACAFtzgg +A9XIIABrqAAAAAAAAP8AAAAO/wABAAAAAAAACgEAgQAKAQABAAoBAAEACgEAAQAOAwEBAB7/gYEA +HgKBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEbBAMDARsCAwMBGwMDAwEbAgEBAR8E +gYEBK/+BgQEqAYGBASkBgYEBHwOBAQEfA4EBASz/gYEBPQKBBQE8/4UAATz/hQABOQEFBQE+DwUF +AS4EgYEBGwIBAQAOAoEBAS4CgYEACgIAAQAOAoEBAA4CAQEBGgGBgQEOAgEBAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAwEAAA4DAQEATwQBAQBfBAEBADwEAQAAAAAA +AABs/wEBAEwEAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACADatQgA2tQIANq +8CADbFQAAAAAHwAAAAAAAAEAAAAAAAAAAgEAAAAAAAAEAgAAAAAAAAcSAAAAAAAACAMAAAAAAAAP +EwAAAAAAABAEAAAAAAAAHxQAAAAAAAAgBQAAAAAAAD8VAAAAAAAAQAYAAAAAAACABwAAAAAAAMAW +AAAAAAABAAgAAAAAAAIACQAAAAAAAwAXAAAAAAAEAAoAAAAAAAgACwAAAAAADAAYAAAAAAAQAAwA +AAAAABgAGgAAAAAAIAANAAAAAABAAA4AAAAAAIAADwAAAAAAwAAaAAAAAADgABsAAAAAAQAAEAAA +AAABgAAcAAAAAAHAAB0AAAAAAeAAHgAAAAACAAARAAAA8tUSmPLVEpjy1RKY8tUSmPLVEpjy1RKY +8tUSmPLVEpjy1RKY8tUSmPLVEpgDhRsYA4UbmPLVEpjy1RKY8tUSmPLVEpjy1RKY8tUSmPLVEpjy +1RKYAAAAAAAAAAAAAAAA//8ABQAGAAcACAAJAAoACwAMAA0ADgAPABD///////8ACgAUAIwAggBk +AFoAoACWAHgAbgBQAEYAPAAyACgAHgAKBM4EkgnOCZICsgRWBOIEpgO2BBoHsglWBl4CdgniCaYH +TgI6CLYJGggWBiICxgRqAJYDegFyB3YAvgPeBPYEugRCA6ICYgc6Bg4AggPKBC4AbgBaAyoBNgHq +Az4HxglqAUoHEgWWCHoGwgH+BnICigNSBeYFvgjeAZoH2gn2CboJfgeeCUIIogkGAV4HYgJOByYD +FgEiBYIIZgWqCMoJLgiOAQ4FbgVaBUYG1ggqBjYCEgHCBuoIPgDmBoYC2gR+Ap4EBgZKAiYIAgNm +AKoDjgX6AEYB1gb+Bq4F0gGGB4oI8gMCCFIA+gUyAa4A0gPyB+4AMgaaAu4FHgAeBQoAAAnECYgE +2AScB6gJTAnYCZwIrAkQArwEYAFoB2wE7ASwAlgHMAPABCQDIAEsB7wJYAWMCHAGaAKABbQI1Ans +CbAJOAiYB1gCRAEYBXgIwAkkBWQFUAggBiwG4Ag0AtAEdAZAAhwAoAOEAcwG9AF8B4AISADwAMgD +6AaQAuQFAATEBIgCqARMA6wEEAZUAmwHRAIwCAwGGACMA3AAtAPUBDgDmAYEAHgAZABQAeADNAFA +BwgGuAH0A0gF3AGQB9AJdAeUCPwBVAccAwwIXAWgCIQBBAU8BswCCAG4ANwGfAKUA/wH+ANcBfAA +PAakBcgI6AL4BSgBpAfkACgFFAAUAAAEyQSNCckJjQKtBFEE3QShA7EEFQetCVEGWQJxCd0JoQdJ +AjUIsQkVCBEGHQLBBGUAkQN1AW0HcQC5A9kE8QS1BD0DnQJdBzUGCQB9A8UEKQBpAFUDJQExAeUD +OQfBCWUBRQcNBZEIdQa9AfkGbQKFA00F4QW5CNkBlQfVCfEJtQl5B5kJPQidCQEBWQddAkkHIQMR +AR0FfQhhBaUIxQkpCIkBCQVpBVUFQQbRCCUGMQINAb0G5Qg5AOEGgQLVBHkCmQQBBkUCIQf9A2EA +pQOJBfUAQQHRBvkGqQXNAYEHhQjtAv0ITQD1BS0BqQDNA+0H6QAtBpUC6QUZABkFBQAACb8JgwTT +BJcHowlHCdMJlwinCQsCtwRbAWMHZwTnBKsCUwcrA7sEHwMbAScHtwlbBYcIawZjAnsFrwjPCecJ +qwkzCJMHUwI/ARMFcwi7CR8FXwVLCBsGJwbbCC8CywRvBjsCFwCbA38BxwbvAXcHewhDAOsAwwPj +BosC3wT7BL8EgwKjBEcDpwQLBk8CZwc/AisIBwYTAIcDawCvA88EMwOTBf8AcwBfAEsB2wMvATsH +AwazAe8DQwXXAYsHywlvB48I9wFPBxcDBwhXBZsIfwD/BTcGxwIDAbMA1wZ3Ao8D9wfzA1cF6wA3 +Bp8FwwjjAvMFIwGfB98AIwUPAAAACgCMAG4AlgB4ADwAUACgAIIAZAAyAEYAWgAoAB4AFAAAAIcA +aQCRAHMANwBLAJsAfQBfAC0AQQBVACMAGQAAIAKN5CAHKHQgAo3oIAcvoCACjfQgBy7IIAKOACAH +LnggAo4UIActzCACjiwgByxYIAKOPCAHLDAgAo5EIAcsCCACjlggByvYIAKOZCAHK7AgAo5sIAcr +iCACjoAgBytUIAKOjCAHMFwAAAAAAAAAACACjpQgByg0IAKOmCAHJ7ggAo6gIAcngCACjqggBydI +IAKOtCAHJxAgAo64IAcm2CACjsQgByagIAKOyCAHJ/AgAo7QIAcmaCACjtggByYwIAKO4CAHJEAg +Ao7oIAcl+CACjvQgByXAIAKO/CAHJYggAo8EIAclUCACjwwgByUYIAKPFCAHJOAgAo28IAciSCAC +jxwgByIQIAKPJCAHIdggAo8sIAchoCACjzwgByFoIAKPRCAHITAgAo9MIAcg+CACj1QgByDQIAKP +YCAHIKggAo9sIAcgeCACj4QgByBQIAKPoCAHICggAo+wIAcgACACj8AgBx/YIAKP0CAHH7AgAo/g +IAcfiCACj/AgBx9gIAKQACAHHzggApAMIAcfECACkBggBx7oAAAAAAAAAAAgApAkIAcd0CACkCgg +Bx2gIAKQMCAHHXAgApA8IAcdQCACkEAgBx0QIAKQRCAHHOAgApBIIAccuCACkFAgBxyQIAKNyCAH +MqAgAo3QIAcxzCACjbQgBzEUIAKN3CAHMGQAABAhIEIwY0CEUKVgxnDngQiRKaFKsWvBjNGt4c7x +7xIxAhAycyJSUrVClHL3YtaTOYMYs3ujWtO9w5zz/+PeJGI0QwQgFAFk5nTHRKRUhaVqtUuFKJUJ +5e71z8Ws1Y02UyZyFhEGMHbXZvZWlUa0t1unepcZhzj33+f+153HvEjEWOVohninCEAYYSgCOCPJ +zNnt6Y75r4lImWmpCrkrWvVK1Hq3apYacQpQOjMqEtv9y9z7v+uem3mLWLs7qxpspnyHTORcxSwi +PAMMYBxB7a79j83s3c2tKr0LjWidSX6XbrZe1U70PhMuMh5RDnD/n+++393P/L8brzqfWY94kYiB +qbHKoevRDMEt8U7hbxCAAKEwwiDjUARAJXBGYGeDuZOYo/uz2sM90xzjf/NeArESkCLzMtJCNVIU +YndyVrXqpcuVqIWJ9W7lT9UsxQ004iTDFKAEgXRmZEdUJEQFp9u3+oeZl7jnX/d+xx3XPCbTNvIG +kRawZld2dkYVVjTZTMlt+Q7pL5nIiem5iqmrWERIZXgGaCcYwAjhOIIoo8t921zrP/sei/mb2Ku7 +u5pKdVpUajd6FgrxGtAqszqS/S7tD91szU29qq2LneiNyXwmbAdcZExFPKIsgxzgDMHvH/8+z13f +fK+bv7qP2Z/4bhd+Nk5VXnQukz6yDtEe8AAAMAQAADAQAABZCAAAWaQAAZQwAAAQJAAAEDAAABA8 +AAAQ3AAAeywAAHs0AAHijAAB5owAAeqMAAHujAAB8owAAfaMAAH6jAAB/owAAI3MAAB+dAAAj9wA +AZFYAACP/AAAdRwAAHUYAAB1EAAAd+AAAHfkAAB39AABnDwAARB0AAEQhAAAlAgAAJhcAACWDAAA +lhQAAJYgAACWLAAA0CgAAJAIAAIQ3AACMNwAAlDcAAJw3AABkFQAAGAcAAGg2AABkJAAAHfgAAB3 +5AAAd/QAAHl4AAB5+AABlAQAAePAAAHnwAAB68AAAe/AAAHzwAAB98AAAfvAAAH/wAABlAwAADAA +P///wAAAMAg////AAABZEKyAAAAAAFmsfiUAAAABlBAf////AAGUNAAAABEAAZQIH////wABlDgA +AAARAAAQKH////8AABAsf////wAAEDR/////AAAQOH////8AABBAD0QAAAAAeygAH//iAAB7MD// +7v8AAHs4AAAAAQAAe0A//+7/AAB8JAAf/+IAAeKIAAgAAAAB5ogACAAAAAHqiAAIAAAAAe6IAAgA +AAAB8ogACAAAAAH2iAAIAAAAAfqIAAgAAAAB/ogACAAAAACNyP////8AAI3Q/////wAAfnB/v/// +AAB+eH+///8AAH4AAMAAAAABkVQB////AAGRnAH///8AAI/YAH///QAAj/j////9AAB1FAAAAAcA +AHUMAAAACwAAd9wAAAADAAB38P////8AAZw4AAGAQAABnPgAAAADAACQBAAAAD4AARB4AP///wAB +EHwA////AAEQiAAAAAAAAJQEAAD//wAAlBAAAP//AACYVAAAAf8AAJhYAAAB/wAAlggAAAAAAACW +EAAf//8AAJYYAB///wAAlhwAD///AACWJAAP//8AAJYoAP///wAAljAA////AADQIAAAAAcAANAk +AAAABwACENgAAAADAAIw2AAAAAMAAlDYAAAAAwACcNgAAAADAAGQUAAAAC8AAaDUAAABgwABkIwA +OAAAAAGQmAA4AAAAAHl0AAAALwAAeXAAAAAFAAB59AAAAC8AAHnwAAAABeECDgAAAEAAAAD/8AAA +MNThAF4AAAgACAAA5AAAAMQwAADEMR//mNzhAGIA4QByAAAAYkgABAAphhAAAAAAYkCAAAAAgBQA +A4AWAAOAEgBDgBHSA4AQAAUAAHUEH/+aNB//koAf/5qgIAjt4B//maAAAEEeAADwAwAAQQ4AAEBA +AACgAAAAoCAAAEGIAAB//wAAQYYAAIAAAABBgQAAqBkAAKgaAADDAAAAqBsAAKgcAACoFwAA//8A +ABAEAADlnwAAHxEAAO4JAAD//gAA6v8gCO4QAAD/ACAI7lAgCO6QAAmJaAAAxFAgCO7AIAju4CAI +7wAAACAAAADEUQAAwAEAAMRSH/+YZAAPAA8AAGGoIFAAACAJJhAAAEANIAkmcCAJJjAgCSZQIE// +gCAGhuQgCSbgIAknQCAJJpAAAMAGAAgAAiAJJ4AAAIDXAAMHgAAAQIIAAMSCAACEAyAJKXAgCShw +AACApgAAgD0gCSfQAACAQCAJKNAgCSkgIAkoIB//mMgf/5mMIAkqECAI7yAf/5hgIAKMgOEAdgD/ +//AAIAKMIOEBmgAf/5isH/+RNAAACAD/wP//ABAAACAJKcAABggAH/+aiD////8AAZ4M4QGeAAAB +nnQAAZ6sAAGe1AABnuwAAZ8UIAjv8CAI8FAgCStQIAkrACAJKmAgCSqw4QAuACACjJAAAJAAH/+S +oAAsFACAAACA4QBaAIHw4IDhAC4IIAAAAOEAVgAMAAAA//OAAAAMOABGAAAAPz///4CAAADz//// +/+D//wABAAAf/5XAIAaAACAGhcQgBoEA4QGSAB//kTDhAIoA4QAOAOEAfgDhAHoAAAIAAAB/AEAA +AwAAAIAAgADBAMD//yP/AADIABAgASDhAI4APAAAAP//v/9QaOhH+P///wQAAACSAAAA8ADwAJ+/ ++/sgAAQEf/f//4AAAgD//+////+A///3/38AAH6wAAYAAAAAD/8AAH60AP///wBJJJIAAH4YCAEI +ARABEAEAAH5AIAEgARUVFRWEIYQhEBAQEOEBjgAAAP5/BAQBgB//mxwf/5igMzMzMyIiIiIRERER +4QDOAOEAjgThAI4I4QCODAAAj8Tg//4AgAABACAGh+QAAJAIAAAIwIABxBHEEcQRAP8A/wBAAEAA +D0JAAAAcIP//AAAgCSvAIAksMB//mFAzIhEAEREAADMzIiL/8P8AAAIAMyoqFRUf/5sUH/+aIAAA +//0gCSzgH/+aOCAI8MAgBzBkAFAAAACgAAAgoAAA4wACAOL//wDQAAAAz//+ACACiPAf/5ooH/+A +oB//mkggBg8QAAAQACAJLpAgCPMAIAjzQCAI82AgCPOAIAjz4CAI9DAgCPSQAAAf/yAI9MAgCPTg +IAj1ICAJLkAgCS4AIAkuYCAI9UAf/50A/wAAAOEAOQAf/4DQH/+SIOEBlgDhAN4A4QDuAOEB/gDh +Al4A4QI+AOECHgDhAeIAAAIBAOEBDgDhAJIACAAAAP//8P8f/5hI4QEOBOEBDgjhAQ4M//AAAAAC +gAb/+///IAj6MCAI+pAf/4EAH/+XoCAGDOAgAoq4IAj7ACAI+0Af/5Gg4AAAAAAAfWwADwAAEAAA +AB//lqAABAAAIAj7oCAI+9Af/5pQH/+BMP//x/+AAIAAH/+pICACjLDh//4AH/+QoAAIAAAf/4EQ +IAkwoCAJMRAf/5iYH/+SaB/84gAgBgogAAB7YB/83gDhAZgAH/+SiB//mSQf/5iQIAkxcCAJMbAf +/5qEIAj8AB//loggCPxAH/+bIB//mmAf/5X4H/+hkB//nRQf/58QIACYjB//78Qf/+7oH/+avCAA +mhwf/5pEAgCCEAIAAhACAAAQAQAAAAAaAAAA+saIACAAAAAA8AAf/5owH/+RdCAGCzQgBgokIAYK +rB//gVAgCP0gIAj88CAI/MAgCP1QH/+X+B//mZwgCTBg4QASAB//koSIAAIQAAD4AOEANgDhAEX8 +IAYM5B//l4QAAH5M//wAAAAD//8AEEEEAACP5AAAfUwgBojkH/+aLCAGC4Af/5gMIJ/wAABAAAAg +CgAAAAoAAB//mLwf/5i4H/+YTB//gdAf/5k4H/+ZPB//mUAf/5lwH/+ZbB//mWgf/5lkH/+ZYB// +mVgf/5lMH/+ZUB//mVQf/4HwH/+CcB//ligf/5gIH/+WJAPn/BggCP8QH/+CgB//mfAgAomMH/+Z +7A////8gAozAH/+XuCAI/3AgBoW0IAaFhCAGhFQgBoV8H/+ZkCAGg+QAAGUAAACAgP//CPoAAEME +AAB9M+EAagAAAGQIAAA8AACAAAD/AP8AH/+C0AEBAQHhAGIQAABkDB//gvBVqlWqAACqqlpaWlql +paWlAABikAARIjOIEgADIAKNIAAAagAAAGoY//9/f4AQAAAf/4MQAABqYAAAIQEf/4MgAAgAKQAA +YoAACgApAAB0BAAAYkQAAGIAAABqeAAAYtQf/4MwAABi2AAAYugAAGLcAABi+AAAYuRBvc1lAAAJ +wwAAYuwf/4NQAABi8B//g2AAAGL0H/+DgAAAYvwAAgjVAABjAAABBGsAAGMEAAII1gAAYwgAAGMM +H/+DkAAAYxAAAKLDAABjFAAAYxgAAGMgAAGGoAAAYyQAAGMoH/+DoAAAYywAAGMwAAAnEAAAYzQA +AGM4ABEREwF9eEAAAHUAH/+DsAAAYowAAHRQAAATiAAATiAAAHQcAABqBAAAahQAAGLAAABizAAA +YsQAAGLIH/+aXCAJBGDhAd4A4QHmAOEB6gDhAe4A4QHyAOEB9gDhAfoAH/+bYB//g8D//H//H/+R +RAAAfuiAAAcAgAAFAIAABgCAAAQAAAB9gPAAD/AADw//3//+AB/8wAAAAIBg///X3yAHbmAf/5E8 +IAkEsB//kbwgB28sIAKI4B//kUAgCQTgH/+awEAAAAAf/5rEVVVVX1VVVVUgBgt4H/+ShwCWAAAA +RgAAH/+WZAAAQAkAAAnEH/+YnCAGhKQAAmJa3q2+7yACjVDiAAYA4gAGCOIAAgDiAAIIIAk2UCAJ +BRDi//4AH/+afCAIQAAgCQVAH/+VzCAH0AAf/5rkH/+atGwQBCggIhn9uNMPA4gRqYgpgoAa/bYK +mQIphoAqICIrICMogoBbz0AqICH9+2IFoAt1APn7YAXhzrUA/kOEHaANhQD4RmQd4A6FAFulB9og ++gAiHeAMBQBbB0nAINEPAGwQBCggIhr9oAOJEaqZKpKAG/2eC6oCKpaA6ZKAJAHxgAAc/Z0PAgAP +AgArwoQd/ZsNuwIrxoQqICIrICNbzyL/+yoFoc+1AC8lHO4lMylQBIAAW6WNyK7HK9EPwKdbpcZn +r73SoNEP2iBbpUUqICH9+xgFoAsVAPwAQh3gDgUAW6ThKiAhHP2H+gPCHeANBQBbxicqICEc/YT6 +A8Id4A0FAFvGI9og+gAiHeAMBQBbC3rAINEPAABsEATIIsAg0Q8T/XrHS9owW6SndKEGZa/00qDR +D9Kg0Q8AAABsEAb4QGgd4AIFAOIWACSAaYAA0Q8AAAAAAAAA8kBoHeDEhQDAoVvRKrEzdDn1wFHz ++tIF4AZFAPYB4h3gKAUAKgooKjYwJjYzJDYxJTYyGf1iDwIAJ5bAKDbIKDbJKwoD/H0CHeAMNQDq +/Vwa8ASAAOU2ESj4BIAAWr4T5qGtbSAEgADA9fwAwh2gCYUAHv1ULjYgHf1QxLGb0Ck2IyI2IyY2 +NcWoKjY2KTY3wIcoNjgiNjksNjovNjsnNjzB5y42PSw2Piw2Pyw2QMDcLTZBLDZCKyoAKzZDJjZE +waAqNkUpCmQpNkYoOiAoNkclNkgvNkkvNkrA4y42S8HSLTZMJzZNLDoALDZO+/puBaAMBQD7+mgF +4+2FAPpiBhXgDhUA6/0yGPgEgABavefmoP1tIASAAPv6XAXgDAUA//paBePthQD7+lIFoA4VAO82 +ECj4BIAAWr3c5qDSbSAEgAD7+kYF4AwFAPn6RgWj7YUA+/o8BaAOFQDoNhAo+ASAAFq90uagp20g +BIAA+/owBeAMBQD5+jIF4+2FAPv6JgWgDhUA6TYQKPgEgABavcfmoHxtIASAABv9DRr9EfpiBhWg +DAUA+/oSBaPthQD+IGgd4A4VAFq9veagU20gBIAA+/oEBaAMBQD7+gwF4+2FAPpiBhXgDhUA6/z9 +GPgEgABavbLmoChtIASAAMTALDY0+/n6BaALNQD0YCYV4Aw1AFvQt8DS7TYBKhAEgADRD9JA0Q8A +AABsEAbj/PQZyASAAC8yW2TwZ8Bg/fniBaCHBQDpFgAh2bEAACiyhC0yo6ho7sCALEZCgACo3W0I +GgBgBA4JG3+XBskjKtAhzaHn3QgDMAUAAH9rJWP/3gAAKtAh3EDrEgAq6ASAAFvFbi8yWxz82+v8 +2xMwBQAAf2OpwCDRDwAAAGwQBv35rgWgCkUA8iAmFaAbRQBb2bQX/NPTDy1ygPX5nAXghgUA5NIe +Y5AHAADAQC8ihC5yyK9P7FCAL/5CgACv7m0IHQBABAwIG3+HCSrgIdMPDwIAzaDm7ggCIAUAAH1L +HGP/2wAAAAAc/L/9+X4F4BvlAFvFSi1ygLFEfUOvZNHEwEAvIoQucsgPTwjsUIAv/kKAAA/uCG0I +HgBABAwIG3+HCirgIQ8CAA8CAM2g5u4IAiAFAAB9Sxxj/9oAAAAAHPyr/IAiHeAb5QBbxTQtcoCx +RH1DrGTRbMBALFCA0w9tCA0AQAQMCRt/nwuxRH1LMWP/6QAAAAAtIoQqcsitTez8nB7uQoAA/UAA +RXALFQD7RDAVoB0FAFvFIS1ygLFEfUO3ZNEfwEAsUIBtCA0AQAQMDht/7wixRH1LLmP/6wAtIoQq +csitTez8ix7uQoAA/UAARXALFQD7RDAVoA0FAFvFDy1ygLFEfUO8ZNDXwEAsUIBtCA0AQAQMDht/ +7wixRH1LLmP/6wAtIoQqcsitTez8eh7uQoAA/UAARXALFQD7RDAVoA0FAFvE/S1ygLFEfUO8ZNCP +wEAsUIBtCA0AQAQMDht/7wuxRH1LLmP/6wAAAAArIoQc/GoqcsirS+38aR3eQoAAq6r7RDAVoBvl +AFvE6y1ygLFEfUO8ZNBHwEAsUIBtCA0AQAQMDht/7wqxRH1LMWP/6wAAACsihBz8WipyyKtL7fxZ +Hd5CgAALqgj7RDAVoBvlAFvE2S1ygLFEDwIAfUO5/fikBaAKBQD8L4Id4BvlAFv/Sf34mgWgCgUA ++gPCHeBNBQBb/0X9+IIFoAoFAPoAIh3gHQUAW/9A/fh+BaAKBQD9+HwF4BvlAFv/O/34gAWgCgUA ++gAiHeANBQBbxL79+HgFoAoFAP34dgXgCxUAW8S6/fhyBaAKBQD6ACId4B3lAFvEtf34agWgCgUA ++gAiHeANBQBbxLD9+GQFoAoFAPoAIh3gDZUAW8Sr/fhQBaAKBQD6ACId4A0FAFvEp/34SAWgCgUA +/fhOBeALFQBbxKL9+EIFoAoFAP34RgXgCxUAW8Sd/fg8BaAKBQD9+EAF4AsVAFvEmP34NAWgCgUA ++gAiHeANlQBbxJT9+CAFoAoFAPoAIh3gDUUAW8SP/fgYBaAKBQD9+B4F4AsVAFvEiv34FAWgCgUA +/fgcBeALFQBbxIX9+AwFoAoFAP34FAXgCxUAW8SB/fgEBaAKBQD6ACId4A2VAFvEfP338AWgCgUA ++gAiHeANhQBbxHf99+oFoAoFAP338AXgCxUAW8Ry/ffkBaAKBQD99/AF4AsVAFvEbv333AWgCgUA +/ffoBeALFQBbxGn999QFoAoFAPoAIh3gDZUAW8Rk/ffCBaAKBQD6ACId4A3FAFvEX/33ugWgCgUA +/ffABeALFQBbxFv997QFoAoFAPoAIh3gLRUAW8RW/fesBaAKBQD6ACId4A0lAFvEUf33pgWgCgUA ++gAiHeANlQBbxEwtcoAPAgBk0ETAQCxQgG0IDQBABAwOG3/vB7FEfUsuY//rLSKEKnLIrU3s+70e +7kKAAP1AAEVwG+UA+0QwFaANBQBbxDstcoAkTAF9Q7zApP33hAWgG0UAW9iH/fdmBaAKBQD6ACId +4A0FAFvEMf33WgWgCgUA+gAiHeANBQBbxCxkMdyCERT7tfJAAELwAwUA2hD6QGgd4AxFAFvTTo8Q +DwIADwIA7PujH/ICgAD14AQEON8dAOTdAQxGAoAA+cYADzf/wQD/pgAO8AoFAP+mAA6wCxUA/CAG +Fe/dgQBbxBT99ygFoAoFAPwgJBXgCxUAW8QP/fciBaAKBQD6ACId4C2VAFvEC7Qi5SOEcZgFAAAV ++3YS+3b+cAAWsApFAP33IAWgG0UAW9hT/fcGBaAKBQD6ACId4A0FAFvD/f329AWgCgUA+gAiHeAN +BQBbw/j99uwFoAoFAP326gXgCxUAW8P0/fbmBaAKBQD6ACId4A3FAFvD7/323gWgCgUA+gAiHeAN +BQBbw+r99tgFoAoFAPoAIh3gDZUAW8PlLXKA0w9k0MTAQC8ihC5yyA9PCOxQgC/+QoAAD+4IbQge +AEAEDAgbf4cKKuAhDwIADwIAzaDm7ggCIAUAAH1LHGP/2gAAAAAc+0f6A8Id4A0FAFvD0C1ygLFE +fUOs4vs8FoNhgADAMCwggG0IDQAwBAwJG3+fCLEzfTtFY//rABj7NCiChCRyyKg47Ps+HEZCgAD4 +gABCMBvlAPqEMBWgTQUAW8O8KkAhHPs3+gPCHeANBQBbw7gtcoCxM30zqGAAC9EPAAD/+sgNoAMF +ANEPAABsEAjpRAAJ0ASAAPygaB3nMgEA/CCmFeACBQD6IIYVoQUFAPggZhXgFEUA+mBoHaAb5QD8 +IGgd4QwFAFvDei4RALEi9cPAHe8iAQByS9z6AIIdoBtFAOz7KBloBIAAW9fqwCDRD4oUGPslHPsl +/CCoFeAJBQD7LQAMMBvlAOgWAinQBIAAW8OPwLCbEfpgaB2gG+UA/CBoFeEMBQBbw4nAIPpgaB2g +G+UA/CBoHeEMBQBbw1wsEQB1wBmxIgICT3JL3sCi/fYgBaAbRQBb187AINEPAPpgaB2gG+UA/CBA +FeEMVQBbw08qEQHLcXaoMokS6PsCEVARAACqmZkSeYuLixHsEgQl6AUAAA0LT5sR/WKSDaAOBQD+ +IEYVr/3GAHaozMAh0Q8AwKL99e4FoBtFAFvXtcAg0Q9sEATApP315gWgG0UAW9ew/fXkBeAb5QDy +4AABMQwFAO40AAlQBIAAW6IO7TQACVAEgAD8IAIdoBvlAFvDVO1kAAlQBIAA/fXKBaAb5QBbw0/t +VAAJUASAAP31tgWgG+UAW8NK7UQACVAEgAD99boFoBvlAFvDRdog/fW0BaAb5QD8ACId4A4FAFuh +9tEPAABsEAb0AoId4QQFAPIAAh2nMgEA+mBoHaAb5QD8IGgd4QwFAFvDDigRALEi9QFgHa8iAQBy +W9zAINEPwCHRDwAAbBAE8/WKBeAEBQD0GQId4AoFAPAAPA2gBhUAALFE5TMICgHWAAAoMIDTDw8C +AOkyISx/VgAAZJ/i5C/fagEKgAAAaxpkv9TaQFvT3uagDGIgBQAA5TMIAn5xgADSoNEPbBAG+GAJ +ANIAnQAW+m7TDyhihBn6qgmIAvjQhhWgGkUAW84tKmKE8/VMBe/7BQALqgH60IYVoAIFAMGkW84m +IiwBcyn0G/qfAEoRDwIA66oICtgEgABb/ZnApP31NgWgG0UAW9dPFPpqKkJbE/pq5KBRYimxAADA +ICswgAAgBAsMG/GABGfSAJ0ALVKEKkKjDS0I/agAFrALFQD9QABFcAwFAOqgISjoBIAAW8LELhkA +DwIADwIA6kJbLwRKAACxInojtPFGQA3gAgUAKzCAACAECw8bf/dGLVKEKkKjDS0I7Pp6Hu5CgAD9 +QABFcBvlAOqgISjoBIAAW8KwLhEADu4U6kJbLw1YAACxInojvGAAGbEi+l/7I6IAnQBj/6SxInoj +qmAABMYq0Q8AwKT99NAFoBtFAFvXGsAg0Q8AAAAAAAAA+gBCHaAbRQDs+mIZaASAAFvXEscr0Q8A +/EBoHeAKJQD99LoFoBtFAFvXDMcr0Q8AbBAM9CGmFeAKdQBboknqFgsoBAqAAPtASkhSAJ0A2iBb +ogfqFgohjCUAAMYq0Q8AiR0X+k0ARRGpWqeqK6B+KqB/4yAiLd4CgADrqgIEy/kAAPghhhXvqgEA +6hYJJJe5gACMHBv6O/mAaB3gDQUA61sIBnxggAAe+j0tsAAO3Qkt0X77YCAV790BAAkfFGTwiiyw +AA2OFA7MAx76NA7MCSzBfg0NR+qwAS7uAoAADc0D+WBAFae9QQDrqwMHy/0AAP9gAIW33QEA67F+ +Lu4CgABtmUEpgAANvQP9ADAV760BAPsOAA23ygEA65kDDl4CgADumQkEQAkAACmRfguZA/joAAT3 +uQEA6dkDDe4CgAAOmQkrkX4NvQMNDU+OGX3hGf30JgWgCiUA/iEoFaAbRQBb1r7HK9EPAAAAwKT9 +9BoFoBtFAFvWuez5/hnQBIAA+gPCHeANNQBbwmPs+fgZ0ASAAPwiABXgG+UAW8I37PntGdAEgAD8 +IkAV4BvlAFvCMuz57RnQBIAA/CKAFeAb5QBbwi36YGgdoBvlAPwiwBXhDAUAW8IoHPn0LxEKLhEJ +LREI+CFkFaAKRQD4IAYVoBtFAFvWmtow/fO2BeAb5QD/87IFoQwFAFug+dow/fOuBaAb5QD8CCId +4E4VAFug9Bz54+35lBnQBIAA//MkBaAb5QBboO8DOgL982QF4BvlAPwAAh2gDgUAW6Dp2jD981oF +4BvlAP/zVgWgDAUAW6Dk2jD981AF4BvlAPwAAh2gDgUAW6DfwED6YGgdoBvlAPwAAh3jDAUAW8Ij +sURpTecc+cft+XgZ0ASAAPoDwh3gDgUAW6DT7PmwGdAEgAD8IgId4BvlAFvCGIodGfm9epsGxyvR +DwAAAPQAAh2gFkUA+mBoHaAb5QD8IwAV4QwFAFvB5SwRDPSAIBWhDQUA/YbAHe9EAQB0a9b981wF +oAolAPw7oh3gG0UAW9ZUKxELLBEILREJ7hEKKdAEgABb/pvHK9EPAAAAAOz5ixnQBIAA/CACHeAb +5QBbwff6YGgdoBvlAP3zOgXhDAUAW8Hz2jBb/rJkpXH6YGgdoBvlAPwjQBXhDFUAW8HEKBEN8QAn +R9IAnQCJHGSSroIdwEDyX0AVoAGaAGSt4v/3FA2gDQUAAAAAiR0EmQwpnP71IAqQkgCdAPUgC/kS +AJ0A9SANyZIAnQD1IBBiEgCdANow/fKiBeAb5QD/8p4FoQwFAFugiPvy9gXgCgUAWrUHihzTD/qA +EiqiAJ0A7Pl0GdAEgAD8IAId4AulAP4AIh3gjgUAW/4VZKQa7PlTGdAEgAD8gGId4BvlAFvBwPpg +aB2gG+UA9PAABrEMJQBbwbv6YGgdoBvlAPXgAAaxDDUAW8G38oHSDaAGBQDwAMwNoAYFAAAA+mBo +HaAb5QD98rQF4QwFAFvBrSsK/Prf+UvhCQUA9y8ADL/8pgAAAAAAckvSpF6n7ijggy3ggi/gge7g +gCxGAoAACN0C+mBoHa/dAQDtFQ4v/gKAAP/GAA9wG+UA/iHkHaEMRQBbwZj6YGgdoBvlAPwh5BXh +DFUAW8GT+mBoHaAb5QD98ngF4QwFAFvBj/bAgBWg+8UA62OQciARAABj/17aMPSgAEawG+UA96AA +RvEMVQDt0IAiIAUAAFvBg9ow/fIiBaAb5QD84AId4Q4FAFugM2P+lKRdp90u0IEt0IDaMP3AABcw +G+UA/6YADrEMVQD0gEAVr90BAFvBc9ow/fICBaAb5QD84AId4g4FAFugJGP+VQAAAORWCAnQBIAA +9sAAQ3Ab5QD80FAV4QxFAFvBZS5ggS1ggOjuEQnQBIAA/6YADrAb5QD94AAG8QxVAFvBXeo0AAIg +DQAA/fHUBaAb5QD84AId4w4FAFugDGP9+ACkVqdmLmCDLWCC6O4RCdAEgAD/pgAOsBvlAP3gAAbx +DEUAW8FMLmCBLWCA6O4RCdAEgAD/pgAOsBvlAP3gAAbxDFUAW8FE6jQAAiARAAD98aAFoBvlAPzg +Ah3kDgUAW5/zY/2TAOz45BnQBIAA/CACHeALpQD+ACId4I4FAFv9hOb41hUZCYAA7PjCGdAEgAD8 +gGId4BvlAFvBL/pgaB2gG+UA/AACHeEMJQBbwSr6YGgdoBvlAPwAAh3hDDUAW8ElJBINDwIAJEz9 +9E4ACTAFBQDkFg4hBumAACcKBPZAAQPwBEUA+mBoHaAb5QD98YwF4QwFAFvBF/pgaB2gG+UA/CPA +FeEMVQBbwOspEQ/1DgAN96kBAAuqAwaqCSqhfgUIRwiIEQqIAwgFTwlVAwWFTwZVCSVRfvjgAAQx +DEUA7RwcLEYCgAD4twAKsBvlAPpgaB2vVQEAW8DXKREO9Q4ADfepAQALqgMGqgkqoX4FCEcIiBEK +iAMIBU8JVQMFhU8GVQklUX4ICEcIiBH4twAKt8QBAPGA/A3vVQEA+/EuBeAKBQBatCS0RPaf+cVi +AJ0AhB7aMPwgAh2gG+UA/gACHaQNBQBbn5n6YGgdrdSRAPwgQh2gG+UAW8Df+mBoHa/SAQD8IGId +oBvlAFvA2tow/fCoBeAb5QD/8KQFoQwFAFufi9owW/2UZKHJiRwJCUFkkfH1IBRwkgCdAPUgFfES +AJ0A9SAYMZIAnQArEQssEQgtEQnuEQop0ASAAFv9Y4oZ9UAHXGIAnQDAov3w3gWgG0UAW9URxyvR +DwAAAPoAQh2gG0UA/fDUBaItpQD+gGgd4A4FAFvVCCsRCywRCC0RCe4RCinQBIAAW/1PxyvRDwAA +AAAA7Pg/GdAEgAD6A8Id4A01AFvAq/pgaB2gG+UA/AVCHeEMJQBbwKf6YGgdoBvlAP3wpgXhDDUA +W8Ci+mBoHaAb5QD98J4F4QwFAFvAnez4RRnQBIAA/CACHeALpQD+ACId4I4FAFv85WSitccr0Q8A +AP3wigWgCiUA/D3CHeAbRQBb1OArEQssEQgtEQnuEQop0ASAAFv9J8cr0Q/aMP3wOgWgG+UA/Agi +HeBOFQBbnzoc+Bnt9/4Z0ASAAP/v+AWgG+UAW581wED6YGgdoBvlAPwAAh3jDAUAW8B5sURpTecc ++A3t+CkZ0ASAAPoDwh3gDgUAW58pjRqLG8fLDcs56xYLLZAEgADRDwAAAAAAAAD98D4FoAolAPxS +gh3gG0UAW9S4KxELLBEILREJ7hEKKdAEgABb/P/HK9EP0qDRDwD98CgFoAolAPxcAh3gG0UAW9Ss +KxELLBEILREJ7hEKKdAEgABb/PPHK9EPAAAAAAD6YGgdoBvlAPwkABXhDFUAW8AnKREQ9Q4ADfep +AQALqgMGqgkqoX4FCEcIiBEKiAMIBE8JRAMEhE8GRAkkQX744AAEMQxFAO0cICxGAoAA+JcACjAb +5QD6YGgdr0QBAFvAFCkREPUOAA23qQEAC6oDBqoJKqF+BAhHCIgRCogDCAVPCVUDBYVPBlUJJVF+ +CAhHCIgRCFUD//YsDa9VAQAA+mBoHaAb5QD8JAAV4QxVAFu//ygREPUOAAz3iAEACYgDBogJKIF+ +BQVHCFURBYUD//VIDa9VAQD6YGgdoBvlAPwkABXhDFUAW7/xKREQ9Q4ADfepAQALqgMGqgkqoX4F +CEcIiBEKiAMIBU8JVQMFhU8GVQklUX4ICEcIiBEIVQP/9AgNr1UBAPpgaB2gG+UA/CQAFeEMVQBb +v90pERD1DgAN96kBAAuqAwaqCSqhfgUIRwiIEQqIAwgETwlEAwSETwZECSRBfvjgAAQxDEUA7Rwg +LEYCgAD4lwAKMBvlAPpgaB2vRAEAW7/KJREQ9Q4ADDdVAQAIVQMGVQklUX4ECEcIiBEIVQP/8ewN +r1UBAAD97zoFoAolAPxCwh3gG0UAW9Q0KxELLBEILREJ7hEKKdAEgABb/HvHK9EPAGwQBBL3kioi +f1ue6igigP0AABQ/KoEACCIC0Q9sEAYU94wPAgArQrD4lagV7/gFAO9CryWYPQAACDMBojp681Nk +kFDqRrAtWASAABz3gi5CrvIgJhWgClUA+iAGFeAdBQD8IEYV4AsFAPIgZhXgDRUAW9QR40ZOIYEh +gADyigYVoA4VAP6J5hWgAgUA0Q8AAAAAAAD//swNoAMFAP3u3gWgChUA+gACHe/9RQBb1ALHJNEP +AGwQEhv3ahr3aB33aYuwKaB/KqIi+iAGFeAOBQAPAgDo0nElA3mAACzSchj3YvmABAY7+qEAD8wC +LNZyoZsrsAAsCgQMuwIr1nQu1nMqCggq1nob91n6IgAVoAlVAPmvZhXgbAUAW86/6vdSEMBBAADy +AAIdoBmFAA8CANMPbZoP6YIAJVARAADppj8kQBEAANEPLtZyK9J2x8sMuwH7rsYV7/6iAAAAAGwQ +EBb29hn3RRz3QhX3Q/MvsBWgKwUA8+6EBeAf9QD17iIFoQcFAPIAAAcwDRUA7t45CdAEgAD+7QAN +NAgFAP8NAAowBwUA9LwEHa9KAQDkVeEoBAqAAPJABBfSAJ0AiF9khFMpYXIiYWkrYWslYW0uYW+i +vaXd7t0IBIOpgAB00W3AgShleP1AJOviAJ0AAglEZZRlCwpEZaRfBQhEZYRZ/+AisKIAnQANTwwC +SQwpZWj+ziQd79kBAAvaDCplagWrDCtlbA+7DPrOBB3vuwEADr8M/s3EHeABxgAAImFpK2FrJWFt +LmFvor2l3Q7dCCdleP1AIYvkggEAZYP8CwlEZZP2BQpEZaPw/+AfaKIAnQACSQwpZWgNQgzyziQd +r9kBAAvaDCplaidleAubDAW7DCtlbA6/DAL/DP7OBB3vuwEADrgMKGVuKWVo6mVqLveCgAAoYWru +xoQsR4KAACjGhyJhbg6/Ee/GhSkXgoAAIsaGLmFu78b9L3eCgAD/n4YVoAIFAOYiz2lIBIAAJGFy +y0/2gB2N0gCdALBP9eAd+KIAnQAESgJbrmkZ9toskooe9twrYWbuzAENbAKAAA3MAiyWiiuW/iiS +gRr21wqIAiiWgcCoW8MFK2KwLmKu5aURDRAEgAD1bwAKf/oFAApEAf6AEVOiAJ0AKGKtZIIfGvbH +KaB99NYGFaBLBQALmQLppH0qWASAABz2xC9ir/QgJhXgClUA+iAGFeAdBQD8IEYV4AsFAPQgZhWg +DSUAW9NHZEIX5GbUIha5gAD0AAId4AQFACpi1MC4DwIA9UAARTAMBQBbzrbkJAgCqAUAAHNZ4cAg +5iHgaUgEgAAc9qUPAgAPAgArwoEd9qku+v4OuwENuwLrxoEg0IEAAFuff+ahJ20QBIAA6/ajENCB +AABasiTmoRRtEASAABn2nyhiOydmOv3tKAWgCgUA+QAEBH/z9QD4x2YVoB8VANMPbfoY2zDA2X2j +Adtw7s0EJVARAADr5gAmYBEAABr2kFufYBz2kPoAAh2gHxUAbfoU2zDCgXijAgd7AivGFOqsBCZg +EQAAGvaIW59WHPaF+gACHaAJRQDTD22aE9swwNl9owHbcCvGKOqsBCZgEQAAGvZ+W59LHPZ7+gAC +HaAOxQBt6hPbMMLxf6MB23ArxizqrAQmYBEAABr2dVufQRz2cfoAAh2gCEUAbYoT2zDAmXmjAdtw +K8Y46qwEJmARAAAa9mxbnzcc9mf6AAIdoAvFAG26E9swwtF9owHbcCvGPOqsBCZgEQAAGvZjW58t +5iCKaUgEgAAtYWcrYWslYW0uYW8jYXEvYXgkYXIiYWnpFhQngcmAAJUQkxGUE/3srgWgCkUA7hYC +LfgEgAD+QGgdoAtlAFvS0iISFNEPAAAAAAAAAP/31A2gBAUAHPZNlBOTEvQgBhXgCkUA7hYBLfgE +gADoYXMpcASAAPgghhWgC2UAW9LDKRIU0pDRD9KQ0Q8rYqYvYqX1YeAVr/gFAAhEAaRaevM8KWKj +y5bqZqYtWASAABz2Hi5ipPQgJhXgClUA+iAGFeAdBQD8IEYV4AsFAPQgZhWgDQUAW9KtY/2YAAAA +AP//MA2gBAUAjmRl66YrZWkrZWsnZXInZXjynyAlog4FAOJlcSJLgQAA+M0EHeTFBQD0zaQd79kB +AO5lbybTgQAA+s1EHa/w0gAAAN0g7hYAKvgEgAD97CwFoAolAP9gaB2gC2UAW9KR//GoDa/ipQD/ +9UQNr/JFAP6AaB2gCiUA/ewaBaALZQBb0oj/8RwNr/JFAAAAAAAA/IBoHeAKJQD97AwFoAtlAFvS +gGP8dQAA/IBoHeAKJQD97AIFoAtlAFvSemP8XQAAbBAMH/X99ABCHeAIZQAb9fssKkAs9qqKsYmy +h7OEtIO1kxWUFJcTmRKaEYuwmxAS9d0e9fMk8oUiIH34IQYVoAYFAPQhJhXiNKEA5T02AXxYgAAB +0gqCIALuLMIg88EADzAAYgAe9eYFPTYB1wqHcCIKgAfuLALuNhf14hr15PXADbYQAzUA9cAM1xAF +tQCVGvIhZhXgGDUA+O/mHaAJlQApdH4V9dsscH/679AV4oS5AOT10RxBAoAA6BYMLsnCgAAJiAKs +uxn10CxChwuLAgm7AgrMAf1mAA2wAjUA+pDmFe4MBQD2pwgVoAtVAA8CANMP0w9tKi/icH8iICEA +AONwfiKoIQAADGYBC2YCojICggIJIgImVjYjQocKMwEDIgIiRocmUjga9bsX9Z/yIYgV4AQVAOTU +NgsQBIAA5vWuGiHCgAAEMwLsIgEKwASAAOsiAgCooQAA4oY4IKCBAAAiYpCLQBn1rIhQ6iIBDdwC +gAALOwILiAIIIgLnIgICYBEAAOJmkCLYEQAAKJKQjMCLsOqIAQ5kAoAADDwCE/WfDLsCC4gCB4gC +KJaQGfWcK5LAHPWcDLsCK5bAKPK5GvWaCogBGvWZCNgCCogCKPa5FfWXJZbaI5bcI5beI5biwkAE +5DYIRBAkluQjluYrkugS9ZAc9ZECuwEMuwIrlugoksAa9Y4KiAEolsAj8qwV9YwU9YwFMwEEMwLz +9YYV4AIFANEPlRqTG/bv5h2gErUA8u/GHa/5vgCVGyh0fvbv5h2gCUUA+CFGFe/5agAAAGwQBBb1 +fQYmCuQ1CAMwCwAA42UHIqv9AAAlZQjRDwAAbBAEFfV29kAIFaAjBQBtOgaHUHZ7BbhVwiDRD5cg +IlAE0Q8AbBAIJgoA4xYCKtgEgADn9WsaUASAAOIWBSkgBIAA6xYEIRAFAADqFgMjqIEAACpyf1vB +UOskAA0YBIAA6nJ/KeAEgABbzorkoBFjuCEAAOV523MwIQAAwCDRDwCxPKxMKsAAxd39QAg8YA8F +AOX0AAjwBIAA8gACHeACBQD0BEIdoCf1AG0IE8mjyiN3oTxoIlmxytygKqAAfaFdY//lyDEnNABk +X6/0oAYdoAIFANEPdKna4iwBJlAFAADq5gAncBEAAP1AaB2v/zoA78QAIRAFAADqzAEuGASAAOrm +ACdwEQAA/UBoHa/+ugB0qaIvxAD1gGgd7/5yAMkmaCFCaCIyyDEnNABkX0z0oAYdoAIFANEPjRLi +1gAhgDmAACc0AMtfEvUn9KAGHabIBQCoIqJi0Q8AixT6ICgVoAwFAFu/9osT+iAIFaAMBQBbv/KJ +EuKWACGAOYAAJzQAyFEkVABmrvIS9RcoasCoIqJi0Q+JEhL1E/8gBhXmyAUAqCKiYtEPAGwQBCsy +ACawAMBw6Gl+bcgEgABkYHYLuQL4IAIdoAoFAPwBIh2gLTUAbQhdaGwVfGESfWEi6Iz/JVAFAADm +JAAhEAUAALF3q3kmkABoaVVkgGjPYmAATQAkkAD8iEAE0AUFAKt75rAALbgEgABtCBTkYDFiqAUA +ACZwAbF36Gkia8gEgABj/+TTD2P/m8CA6CQAJNAFAAD6YAYVoAIFANEPq3urWcmCwLDrJAAk4AUA +AOw2AC0QBIAA0Q/GKtEPAGwQCFv+yeanZm0QBIAAFfTfG/TdFPTc8+m+Ba/z9QD/6aYFoAZFAP3p +rAXgCRUA+emwBaAHBQAf9Ngv1qUu1qQn1qcc9NYs1qYa9NUq1qkf9NUv1qgu1qsc9NQs1qouUoIa +9NIf9NMPAgAK7gEP7gIuVoId9NAtVoYpVocsSkUsVqUqsvAGqgIqtvAf9Mse9Mue8CwiwB30yg3M +ASwmwCoi0CvqwPtABAVxG1UAC6oCKibQH/TELybRLCLYHvTDHfTDDswBDcwCLCbYKiLbG/TAC6oC +KibbH/S/L4Y1LCLSHvS+HfS+DswBDcwCLCbSKiLSKECAx74LqgHqJtIsEHAAACgi0xv0thr0twuI +AQqIAigm0yMm9CMm9S0i3h70sg7dAS0m3ioiwxz0sP1ABAU1CwUAC6oCKibDLyLBGfSs+eAEB/CI +BQAI/wIvJsEtIsIe9Kka9Kgb9KkO3QL8WEYV5BwFAFvNmxr0phv0phz0plvNmBr0pv3pTAWgC1UA +W8BoGvSi/elEBaALZQBbwGQa9J/96T4FoAt1AFvAYRr0m/3pNgWgC4UAW8BdGvSY/ekyBaALlQBb +wFoa9JT96SgFoAulAFvAVhr0kf3pIgWgC7UAW8BTGvSQGPRtHPSRH/SP/wHGFeArBQBbwE376RQF +oktFAPwAQh2gDSUAW78s++kMBaFLFQD8AAId4Pz1AFu/J/vpAgWhSxUA/AACHeD89QBbvyMb9Foa +9Hv96PwFoOlFAPlhRhXgKzUAW8A4GvR2/ejwBaArRQBbwDUa9HL96OoFoCtVAFvAMRLz8uz0chkg +BIAAHfRKnNyc28BQ9hkCHaAKBQD9oaYVoABKAAAAAACmROJJJ3KoBQAALkCA70IhL39+AABk/+fa +UFvNDOagDGKoBQAA5kQIAv8JgADmpLxtEASAABT0XQ8CAA8CAChC1Br0Wxn0WwqIAfkGAAxwCxUA ++JqGFaAq5QBbnPP6BcIdoAt1AFuc7PoFoh2gCxUAW5zu+gWiHaArlQBbnOf6BWIdoAsVAFuc6PoF +Yh2gK5UAW5zh+gZCHaALFQBbnOP6BkIdoCuVAFuc3PoF4h2gCxUAW5zd+gXiHaArxQBbnNb6BMId +oAsVAFuc2PoEwh2gK5UAW5zR+gdCHaBLdQBbnM76ACId4GoFAFucz/oFoh3gagUAW5zJ+gbCHaAL +NQBbnMr6BsIdoCvlAFucw/oG4h2gCxUAW5zE+gbiHaA7xQBbnL76ACId4KolAFucv/oFIh3gqiUA +W5y4+gSiHaALJQBbnLn6BKIdoAs1AFucs/oHYh2gCyUAW5y0+gdiHaALZQBbnK36ACId4Lo1AFuc +rhX0EdMPK1GBwSj6QB+44gCdAPoKwh3gujUAW5yj+gjiHaALFQBbnKQsUYH8QB8wogCdAPoI4h2g +O6UAW5yb+gjCHaALFQBbnJwtUYEPAgAPAgD8QB544gCdAPoIwh2gO5UAW5yR+ggCHaBLxQBbnI76 +BmIdoEvVAFucjPoIQh2gS/UAW5yJ+gciHaBL5QBbnIb6CaIdoAsVAFuch/oMIh3gStUAW5yBFvO+ +KGL+GfOOCYgCKGb+LkKQLwovD+4CLkaQW/w+5qK0bRAEgAAb8zDAkPtwEBXgDEUAbcoMAJAECwwb +f8cBsZqxmRTz1xLz2hvz2i5Re/9foBXgDUUAD9o4/+emBeDuEQDu2jkNSASAAB7z0CiygPyvZBXv +/LUADwIADIgBKLaA8aATD9IAnQD1IBjYkgCdAPUgGPESAJ0A9SAZMhIAnQAW858a8vkZ8xwpZowq +ZpAc88EpxowqxpAb88AptowqtpAY878phowqhpBb++jmogRtEASAABrzu/oCIh3gDAUAW8v7G/Ov +LrISFPO37hYEJwD5gADAoFurJBvzqqSvJ/aBiBQo9oIn9oMZ87Ap9oAqskTqFgUlAOGAAMChW6sb +pKwnxoGNFS3GgifGgxvzpyvGgBrzpv3nTgWgTgUA0w9t6hEron/9YAx0IgCdAKS/I/aAtKooUX5k +gjLA0BrziPwf4h2gK3UAW74rGvOEG/OaHPOaW79EGvOYKmZwGvOAHPOYHfOYGfOW+M8GFeJLBQBb +viErCkD35ygFoAw1AAy7LPPmpAXhyx0A/YBgFa/+xQDuzAEN34KAAOoyIi5mAoAA/WYADbAMFQAM +uwIc80n3QwALMD0lAA2qKCvGpVudwi0yIi4KZO7aKA0gBIAAW52+H/M+L/IiKDro6PooDRgEgABb +nbnr8z0SQ/0AAOitEQx0AoAA7t0CAeP9AAANzQIttuQAwAT2nwAMsBpFAAqZLCm27Sqy7JoWJ7bl +AIAEBgcZBy4ULrbmCngRKLbnB3kKKbboKLbpFvNlBnYoJrbqJApLBHQoJLbrHPNiDKoBCnoCKrbs +/ebABaJThQDy4wAJ8ApFAPN9xhXgDQUA6RYALHgEgAD4ICYVoAuFAFvPdJcQ7xIGK2gEgADjFgEq +cASAAPoAgh2gC4UA/eaeBa//gQBbz2soUX7MiSlRf8yUKlGAZKEH0Q+kvfewBhXv+dYAAAAAAOdG +BiSU8QAA9SAG+hIAnQBpoTQpQCga80AuoIcroIIsoH0npH0npIInpIepyam5qen4hQYd7/YaAAAA +AAAAAADuRgclDz0AAPlf63lSAJ0AL0AoLUAyLkA3KEAtJ0QtJ0Q3rt2o/y9EKPyGRh3v9ToAAAAA +AAAAAPoAQh3gujUAW5uqY/v+AAD6COIdoAslAFubpmP8DwAA+gjCHaALJQBbm6Jj/CYAAClRf2Wd +xipRgGWtwCtRgWW9uv/25A2gDcUAHPMW/IDGFa/zygAd8xUe8xSeRvyA5hXv84oAkkeeSJ9J9oDG +Fe/zUgCSR55I/oEmFe/8dgAAL1GBZf7xGfLFLpLgGPMJH/MJCO4BD+4CLpbgLJLAHfIjDcwCLJbA +KJLYG/KLGvLcHPMCC4gC+TsGFaArBQBbvprRDwAAAAAAbBAEEvL8IiF/wDXyQmCF4AQFABPy+SQ0 +gCQ0gSQ0giQ0g9EPbBAEE/LzFPL0IjF/BCIBIjV/0Q9sECjwU5AN4AcVAPRAEwiSAJ0A9EATYRIA +nQD0QBgiEgCdAPRAE4qf5qUA8AQEDaADBQAAACUSRiYchPagAEK/5qUA/OBoHeAKJQD95b4FoAsV +AFvO8MCi+gAiHeAJBQD4r6Yd4AilAOhUfCjgBIAAW87oG/LWKgoB6rSIKwVaAAAf8tIv8h38AAId +oA4FAP5OAAxwBBUA6oQABBXpgADt9w95wASAAARMAu4yACHAEQAAChoU5KAvZVv9AADpggAmYAkA +AG25E+uCASZgCQAA7p4IBEAhAACJgK6+7oIBL1AEgACqmKju/eVyBeGPAQDkgDFgyAcAAPOAAQXw +CkUACKoM67IAJMhBAACpiPoohhXgCQUAbakH6YQAJEAFAAAsEkSuzi7WHh/yqcDhLvSIyDb0QA4S +EgCdANJg0Q8AABjyQwA1EahT/qBoHaAKRQD95UAFoAsVAO0kAAn4BIAAW86swKX8YGgdoAsVAFvO +qSowACMWQPwwgBWgBQUA8VNgDeD79QD7QAn0YgCdAPf9Qh2gCQUA+CimFeAIBQD4KOYVoAEOAAAA +AAAAKhJHDwIADwIAZK59KxJBiKEsEkLtEkMo0ASAAAuAAOahCm0wBIAAKBJAKIAA1XDxCCAN4Pn1 +AHmBeuoUAADYBwAAW/0WKBAA6hZGIrgFAAAPAgD/HQAN4Fy1AHyJoSgchKilLVB7LgpdDwIAftmQ +LR0B69wEKNAEgADs3Agm6DEAAFv8peoWRyUKIYAALxJFZfEsGPJlhKF4SYv4KAgV4AoVACoWRRry +XgOZDPlDphXv/d4AAGZgdBzyWsCx+5EGHe/4VgAV8loY8bEAMxGlNfhgAEG/+yYAFfJWGPJWADMR +pTX4YABBv/raAAAAGvHPKqB9GfJR6PJRFX0MgAAjgcQHMxH4YABB//pWAAD1gGgd4AcFAP/1/A2v +5qUA9YBoHeAHBQD/9bwNr+alACUSRigchPigAEK/9YYAAAAjgcMHMxH4YABB//laAAAA6/HfGdAE +gABb0HT6AMIdoAsFAPwAAh2gDQUA/gACHaAPBQBbyj/SYNEPAN1w++RiBeAKZQDv8dEZrAKAAPyg +aB2gDhUAW8o2GPIsKIKAaIAW8+RQBe/37gAAAAAAAAAA//YwDaAOBQAT8iP/9yQNr/blAMCi/eRC +BaALFQBbzif/8xwNr+alAGwQBBbyHSliWihiWSRiWydinvkAAERwCQUA+IAAQj/49QDkQNBiE/0A +ACVipgl3EadVKVQhKVQgKVUTmVyZW5lfmV4pVhEpVhIpVFUpVFQpVH4pVH8pVSwpVTIpVTMpVTQp +VTUpVTYpVG4pVG8pVHApVHEpVHL4rmYd4AQVAOhUdiM54QAAbSlkInKAI2KmKVU64kIIAiAFAADp +VRIpFkKAAKI1KVRyKVRzKVQhKVQgmVyZWylVE5lfmV4pVhEpVhIpVFUpVFQpVH4pVH8pVSwoVHYp +VTIpVTMpVTQpVTUpVTYpVG4pVG8pVHApVHEpVRIpVTrRD9EPbBASGfHgIxYRJBYXhZiLlYiXipaM +lI2TjpLvkgEgsEEAAJ9hnmKdY5xkmmaYZ5tllWiJkOlmACETYYAAKxIXFvHS+CLoFa/JBQDzZWAN +4AeVAC1ihi5ihPZB5hXvBUUA4yYFLEaCgADl1QgEQP0AAAmIAfhgAEQ/+wUAC1UBE/E3KCYG/qAQ +g6BHBQApYoPqMH0kkCmAACVmhgeqAuo0fSroBIAA9eJiBaAKVQD+0KgV4AsFAPQgZhXg+MUA/CAG +FeAcBQD8IEYVoA0lAOgWASpgBIAAW82xGfEY6lQAAo5pgADqJhAlDgmAAIov9gACHeADBQD0ImYV +oA0FAOShH2CgQQAAKRYSLRYWKxIXikALqigrCmQLqizgcAQFUP0AAPpCCBXmqh0A+iKGFaGqnQAq +FhWjuysWGFu9PC1ihihigy5ihPuvAAq/+4UA61UBDXgEgAD+oAZbogCdAOrw/xQGGYAAKaB9JWaG +/iIGFeBLBQALmQLppH0q6ASAACwSEygSEC9ihfwgBhXgClUA9CBmFeANhQD8IEYV4AsFAPggJhWg +DSUAW8196lQAAoQRgAApEhjqlgAlBzmAACUSEfoiqBXgDAUAW8jtLRIWLBIYLxIU+uAEANAOFQDv +xgMvcAqAAJ7GncTlxgEvxoKAAKhVrf3tFhYm6/0AAO3GBSLbAQAAm8KKL+M8HCIgEQAA5RYRI7gF +AAD6//d7ogCdAMAg0Q/AUP4iBhXv/VIAAAAtYnwvYnsuEhD1oOAV7/iFAAhVAaXufvNGKWJ5DwIA +DwIAy5ruZnwvaASAACwSEigSEC5ievwgBhXgClUA9CBmFeANhQD8IEYV4AsFAPggJhWgDQUAW81F ++qBoHa/8mgD//yANoAUFAP/4JA2gBQUAxyTRD8Em0Q/ALNEPLWJ8L2J7/SBoHa/4BQDpYnkmqD0A +APigBAKw+sUAqlp680DLnepmfC1oBIAA/s9IFaAKVQD0IGYV4AsFAPwgBhXg+MUA+CAmFaAdBQD8 +IEYV4A0FAFvNJtpQ+eEYBe/3ZgAAAP//FA2gBQUAbBAQW5tb6iZgIRgHAABbm1UsMiD7QGgd4AfV +AP1PAA0wCcUA5fEVFVAFAAD6ZEYVoAhFAPviIAWgBBUA+mQmFeEmRQCmJiikSSg0oyg0nSU2G/R0 +Jh2gC+UAKzSmKTYcJ6RI9nSmHeAMJQAsNKIX8Kf4dIYd4AwFACw0oCdy2hnwbfhjphXgGQUA+HTm +He93gQAnNh7nNh8rWASAAG2KEi6wgADhBABNGuXRCHXYBQAAsczAxAwORy40nfXAEIoSAJ0A/eHc +BaAKVQD94dYF4DsFAFvM7C4yIC0yIQ7dDLHdDW0U6dQABpIBgAAND19k8s3CoAmIV2SC0AnLU2Sy +1wnsUWTC3LCuCeo7CqUCKgoF/eG2BaA7BQD+oGgdoB8VAFvM2MGB+KEADDEqBQDqKggES/0AAOg0 +nCyBCoAA4EUaBEgZAADlXP8sAQqAAOU2IypACoAA5TYkLIEKgADkjP8qeAqAAOQ2JSf7/QAA7zYm +IMlBAAAroIMsoIItoIEuoICekJ2RnJKbkxbwhv3hegWgClUA/NsoFeA7BQBbzLkvMiUK/xEvZtn9 +4W4FoApVAPzbKBXgOwUAW8yyHPC0LTIgLjIhLzIiKRIWKxIXKhIVKBIU6LsQDMwCgADrmQINVgKA +AAqIAvkGAAxwClUA+NtGFaA7BQBbzKPs8KUb+ASAAPxjyBXgClUA/mPoFaA7BQBbzJwW8Jcc8J8v +MiX+c5AVoApVAPhkyBXgOwUA6RYAKkaCgADoFgEq6ASAAFvMkRzwlR3wlv7JEBWgClUA+MkwFaA7 +BQD4IAYVoA/1AFvMiewUAAHZsQAA+AACHaAZFQBtmg2rieyKCARAEQAAiZCZoMCl/eEMBaA7BQBb +zH3Apf3hCAWgOwUA/D4CHeH+BQBbzHj94QAFoApVAPoGAh3gDVUAW8xz+mQIFeFqxQDqKggK5oKA +AFv+h8Ag0Q8A/eDuBaAKVQD94NAF4DsFAFvMaCwwpC0yG9MPAMEE4E4aDgIKgAANCxlksPEsMhyw +y+CwBAdL/QAA+J8ADP/69QBtCAoJGRTkkBVlUAUAAGP/7gAAAAAAAP/3iA2gBQUAAMEEAE0a69z/ +LYIKgAD6nwAN//n1AG0ICgsbFOSwCWTIBQAAY//uAAAKmQwpZHwsMhzsZIAk6AUAAC1kfSoyHLKb +62R+JVAFAAAqZIEvMhyzmOhkfyf4CQAAL2SCLjIcs+4uZIP6AAIdoA5FAG3qEihggACBBABPGuXx +CHMwBQAAsarApAoOR/5zph2v9B4AANkR//S0DaAaBQAImRH7XwAVr/SiAAAADJkR+1+AFa/0hgAO +mRH7X8AVr/RyAMCi/eBgBaALBQBbzCL94FwFoApVAP3gOgXgOwUAW8weY/zEAAAAbBAKG++LF+86 +KLB9LHLAKnLICcwR7KoIBHxAgAAtCoCtqluwfWAACAAuKoCuqluwehnwCy2SE+5ybCaBWYAAwCAs +cmorcmkvcmsucmySEpwR+iAGFeAKVQD94CQFoDsFAFvMA9EPGu9zyud+oyUvcmvL8H+jLityacu3 +e6M1LHJq8YBwDeBEBQB8SzT//vQNr+KlACxyaityaS9ya//+sA2v4qUALHJqK3Jp//54Da/ipQAA +LHJq//5IDa/ipQAAABvu8fIghhXhSEUA+EAARDFPxQCvLy8WBS8mUy8mVCgWBygmUfhKRhWiSgUA +W6cWKhYI+lACHeJKBQBbpxOIGCVyaiZysNMPCFUoLnKu9M8ADv+DBQAD3QHqFgYuoASAAP+gDvui +AJ0AKXKtDwIAZJHRG+8/KrB9/PYGFeBMBQAMqgLqtH0usASAABzvPS9yr/YgBhWgClUA9CAmFeCN +BQD8IEYV4AsFAPQgZhWgDSUAW8u/7UQAAhLhgADscmomjSmAAGTAf/ekABWgBAUA49wIJqjBAACV +3Bvuu5Xd/CFGFeAPBQD/ooQd4k4FAP+ipB2vzAUA/MAEBj/49QDo1gAmYQEAACzWCezWCCbQ4QAA +W5nl+91aBeJKBQBbptqPF4sYLCJRjhqltaa2rr2a4SlyapPBn+Oc4iMmUeOzCAIgBQAAeUOPjRYr +cmnAov1jAA3wjAUAWCAL3aDrcmklB2mAAGSwg+asICUowQAA80EAFeAEBQCV3JXd/CEmFe/59QD5 +oAYV4k8FAP+ipB3vzgUA/sAEBzAIBQDo1RQncQEAAO7WCSbQ4QAA/6EGFaKLBQBbmb36SAIdoosF +AFumsogVjBYuIlOPGaXFpsavzZrxK3Jpk+Eo9gMu9gIjJlPjwwgCIAUAAHtDi9qwW7sU26D8AgId +oAolAFgf4ityaeomViUCSYAAwMBbxuIqcmtbuwzBwPtAaB3gCiUAWB/ZL3Jr6iZYLQL2AAAscmod +71wrcmn+7YgVr/JFAP2iaBXv9ToAAP/5DA2gBAUALHJqHe9UL3Jr/u2IFa/yRQD9omgV7/SyACty +aR3vTi9ya/7tiBWv8kUA/aJoFe/0TgAAAAAAAAD74Ggd4AwFAFvGwSpyalu668HA+0BoHeAKJQBY +H7kscmrqJlclfeGAAPuAaB3gDAUAW8a3KnJpW7rhLAoQ+0BoHeAKJQBYH64rcmnqJlUle8mAAMDA +W8auKnJsW7rYwcD7QGgd4AolAFgfpS5ybOomWS0D9gAALHJqHe8oK3Jp/u1oFe/yRQD9omgV7/H6 +AAAtcqYPAgAPAgDvcqUmof0AAANEAQVMCHzzPShyo8uH7HamLmgEgAAc7oQucqT0ICYV4IkFAPgg +RhXgClUA/CAGFeALBQD0IGYVoA0FAFvLE/yAaB3v9VIA//8sDaAEBQD7wGgd4AwFAFvGhesSBClQ +BIAAW/3pG+8FLbITwMHqzTgNEASAAP1iZhXv744AAABsEAgb7nIV7iEpsH0tUsAsUsiTFORdAS7u +QoAA7cwIBPy0gAAmCoCmyluvXS9CgC5SyAn/Ea/u5uoIDSAEgABbr1X6jwALsACiAAAAACYqgKbK +W69TKUKAKFLICZkRqYjmiggNIASAAFuvSgpHDCZSsChSre5SriufAoAA8s8ACn/7BQALRAH+gBGr +oEwFAGSCLRruTimgfSRWsAyZAumkfSowBIAAL1KvHO5MnBb2IAYVoApVAPIgJhXgCwUA9CBmFaAY +BQD4IEYVoA0lAFvKz2RCA+QmAyIPIYAAGu7ax4D24AEB9JMdAOoABQmfQoAAbZkCBAJhJlKwLlKu +A2QMCEQB/oAOC6IAnQAoUq1kgbYa7i4poH30tgYVoEsFAAuZAumkfSowBIAALBIGL1Kv9iAGFaAK +VQDyICYV4B0FAPwgRhXgCwUA9CBmFaANJQBbyq5kQeHkJgQiCxGAANpA/GBoHaALBQBbxYwPehGa +FVu6SiZSsC5SrvrPAAo/+AUA6EQBDRgEgAD+gAobogCdAClSrWSROBvuDSqwffS2BhWgTAUADKoC +6rR9KjAEgACMFi9Sr/YgBhWgClUA8iAmFeAdBQD8IEYV4AsFAPQgZhWgDSUAW8qNZEG85CYBIgbp +gADaQPogqBXgDAUAW8YA2nBbuiomUrAuUq76zwAKP/gFAOhEAQ0YBIAA/oAJC6IAnQApUq1kkRYb +7ewqsH30tgYVoEwFAAyqAuq0fSowBIAAjBYvUq/2IAYVoApVAPIgJhXgHQUA/CBGFeALBQD0IGYV +oA0lAFvKbWRBkuQmAiIC2YAA2kD64Ggd4AwFAFvF4B3udf/cDgWgCwUA+AACHaAZBQBtmh4NiQIp +5vnpUs4kQAUAACri+euZCAXYCQAACgpNKpUKKhIE7lKAIXgHAAAu9DRaqjzAINEPxyTRD//3iA2g +BAUA//l4DaAEBQD/+3ANoAQFAChSpi9SpfUB4BWv+QUACUQBpDv74ATL4gCdACpSo2SgjutWpi3A +BIAAHO2pLlKk8iAmFeAKVQD0IGYVoB0FAPwgRhXgCwUA+CAGFaANBQBbyjlj/aYAAAD/+/gNoAQF +AChSpi9SpfUB4BWv+QUACUQBpDt780EqUqPLq+tWpi3ABIAAHO2TLlKk8iAmFeAKVQD0IGYVoB0F +APwgRhXgCwUA+CAGFaANBQBbyiJj/c4A//3UDaAEBQD//xwNoAQFAChSpi9SpfUB4BWv+QUACUQB +pD5+8zkqUqPLo+5Wpi9ABIAAHO17LlKk8iAmFeAKVQD0IGYVoB0FAPwgRhXgCwUA+CAGFaANBQBb +ygpj/fMA//88DaAEBQAoUqYvUqX1AeAVr/kFAAlEAaQ7e/M5KlKjy6PrVqYtwASAABztZS5SpPIg +JhXgClUA9CBmFaAdBQD8IEYV4AsFAPggBhWgDQUAW8n0Y/4dAP//PA2gBAUAbBAEF+4ACDUR5UUC +CTeCgACnZpVg0Q8AbBAKFO37iEmJSIpHi0aMRY1EhUGGQI5Dj0KfEp4TlhDlFgEgsEEAAJ1gnGGb +YppjmWSYZYVKlWb0gWgVoAVFAORmByEBIYAAaSEU8sBoHaAFhQBtWQmIIOOBCHEQEQAAxirRD8Ag +0Q/yIGgdr/+eAGwQBvfbwAWgBwUA9du+BeAJBQD4ICYV4AMFACtg5fIAIh2gDIUA7HwCBYHxgACc +EOp0AAlYBIAAW8Xv1KD8IAgVoAv1AFvBGI4RBU8K/mAARzCKBQAK7gIu9oAtYOWxM+0zzHEQBQAA +jxHmbAEjuAUAAP5gAEfwAwUA7xYBK6Z0AADRD2wQEhfsyikKAPrwEBXgCEUAbYoMAJAECwwbf8cB +sZqxmR7s1xXtUPlfoBXgCEUA+QIADX/79QD522gFoV0FAPnbZgXh+h0A/rAGFeAFBQDTD23aGSWG +gSWGgC6WgyuWgi6WgeuWgCRAIQAAKZwQG+2oHO2oHe2pHu2p+AACHaBJBQBtmiQLiQopnQSVkA6J +CimdBJWQDYkKKZ0ElZDsiQoEQAUAACmdBJWQW6Pc+ds4BaAKhQDTD9MPbaoH5YYwJEATAAAT7ZPz +2y4FoAQFACU2wiU2wyU2xCU2xeU2xipQBIAAW6OjG+0X7O0WGVAEgABbo5jkTAEhEIMAAOM9ICon +PAAA+dowBaAKhQAPAgDTD22qB+WGhCRAEQAAGu2DwID1VeYV4luFAG26FiWmxiWmxyWmyCWmySWm +yuimxSRABQAA+CBoHaAaBQAPAgAPAgBtqgflhgAkQBEAAPIRAh3gAgUA6iQACNgEgABbo2exInMp +7xjtZxbtbf3a2gWgCgUA8gBCHaAJRQBtmhgpgoAMmQIphoDmqQoFUAUAAOKWjSRAgwAAK3CA9dqy +BaADBQAAMAQLChvzQAjv0gCdALEz5E0gKaewAAAIuxEc7VctwoAe7VgO3QENuwIrxoAY7VYqgIAs +gIH00WYV4GNFAPtAAIU/9eUA7DsMDVXCgAADqiwFqgEMrCgLqigDzCzlzAEA8UEAAAOqLOWqAQDp +gQAA/EBABj/0hQD1gAQGMrwBAPpAQAUwDwUA+0AARXAJNQDqywgEQBUAAG2aUemAgCRAFQAAq//s +1gAm6BEAAOrmACdwEQAACZkJ6YB8LNXCgAADqiwFqgEJOwwJqSgLqigDmSwFmQEDqiwJKTf1QAQF +crkBAAoqNwScAauqqsuc0CrmAPvgAET2DwUA6ftdcJFBAADAsG0IHAK9CozQsbsLC0HozP4mFDEA +AOjWACTL+QAAefs2Y//c2jD8KAAVoAsFAFvItS4RIC5Gii0cQizRAC3RAetwgC5kAoAADcwC/JEm +Fa/68gAAAAAAAP8lkg3gCwUA0w9tCB0CvQqM0Cu8AQsLQejCDGZACQAA6NYAJMgJAAB/mwRj/9kA +ACkcUB3s+oiQ6NaEJPgRAAAY7PyP8O+GhCTwIQAAH+z5juDu9oQk4DEAAB3s94zALNaEKRxgHOzt +j5Dvxogk8BEAAB/s747g7vaIJOghAAAe7O2N0O3miCTYMQAAHOzrK7IAK8aILxIbLhIZLBIYLRIa +GuyF/G4ADjPuHQD8bgAO8/8dAO7/EA7tAoAA790CD3aCgAAOzAL9hgAOcCuVAFu4PMAg2iBbokSx +Imkk9cAg+kBoHaXr5QBbopqxImkk78Ag0Q9sEAgU7KgX7B4T7BkoQSQc7Cv2gmQVoBL1AO5BFSQL +8YAAK0EXJUEZKkEbrr2l3QrdCPzAGvPk/gEA8/LsDeSLAQDzEmwN5JUBAGWTHvpAGNiiAJ0ADmgM +DWIMIkUdKEUUC48MBf8M/oMEHe+IAQALiQwpRRYC/wz+g4Qd7/8BAAr5DOlFGixHgoAAIkEW6DaE +KReCgAAiNociQRoO/xHvNoUpF4KAACI2hixBGu82/S5ngoAA/H+GFaACBQBmIqUiQR7LKvZAF13S +AJ0AKCz/8wAXwKIAnQACKgJbo3QtMoosQRLn3QENdAKAAA7dAi02iiw2/ikygRvr4wuZAik2gSpB +EvfZIgWgAgUA5eyQFQF5gAAvMr3TD+b/AQlHAoAACP8CLza9JTa8W7f25KAIYRAFAADHLtEPKkES +eiPUCqsKKUHo6zaNJI2pgAAsMoEd7IANzAEsNoEiQR4jQR0qQRslQRkvQSQrQRcmQRPuQRUnjRGA +AJUQkxGSE+zsdh34BIAA6hYCK2gEgAD6AIIdoAtlAFvISMAg0Q8AKzKEKkESKUETC6oMCioUKkUV +CpkMKUUUJjKEKDKHJUEUCGYMBiYUJkUXBlUMJUUWLjKHLzKFD+4MDi4ULkUZLDKFJkETLTKGLkEV +K0EXDcwM9IMkFe+sEQAqRRuuvfWgAEb/zBEArNj4wA/7pP4BAGXx0gsIRGWBzAUJRGWRxvpADhii +AJ0ALEEkqtkObgwuRRQJaQz4g6Qd794BAAvfDO9FFiYIIYAABfsMK0UYCbkM+IOEHe+ZAQAKmwwr +RRoO2BEiQRboNoQpF4KAACI2hy9BGg6eEe42hS//goAALzaGLEEa7jb9LmeCgAD8f4YVoAIFAGYg +0ikygXuWWigyiggIVfsABADQAhUAACIaAgJP4kUeIXKBgAD2QAud0gCdALAp8yAMCKIAnQDaIFui ++C4yii1BEufuAQ18AoAAD+4CLjaKLTb+KzKBHOtnDLsC+nAmFe/4RgDAgPiDxB2v+B4AKUHpZZ5I +KkHqZa5CK0HrZb48Y/5FABzsEZITkxLlFgAraASAAOoWAS34BIAA+IPkFaAKRQD4IIYVoAtlAFvH +38Ag0Q8AAAvoDAWIDChFGAqMDAnMDPyDhB2vmAEACp8M/oNEHe/75gDRDwAAAADvVAAPaASAAOoW +AC3wBIAA+gBCHaALZQBbx8z/9MgNr+KlAAAAAAAA/sBoHaAKJQD9lgAVoAtlAFvHxP/0SA2v8kUA +AAAAAAD6AEIdoAtlAOzrQhloBIAAW8e8Y/02AAD6AEIdoAtlAOzrPRloBIAAW8e2Y/0e31D9wGgd +4AolAOwWAC3wBIAA/dZkBaALZQBbx67/+jQNr+KlABzrLurdCAtwBIAA+gDCHeAKJQBbx6f/+bwN +r/JFAAAAAAAAAAD6AEIdoAtlAOzrJBloBIAAW8eeY/y+AAD6AEIdoAtlAOzrHxloBIAAW8eYY/ym +AABsEBgS65ET6psf670pIRMoIjgq8AyM8u3wBCDwgQAA7eQEINihAACcsCq0BI/wn+AJiDf4JIYV +pAoFAPlANguiAJ0A+iQGFaAKFQAX6yYqdvFbxGMU66woQlL7AEVQEgCdABzrqRnrqfoAAh2gCwUA +L8CBI8CALZCCLpCBJZCAA7s3D7s3Bao3Dqo3L8CCLsCDDao3LZCDD7s3Drs3Dao3HOqMsar4AAId +4AMVAP2QEBWgCEUAbYoMAJAEDA0bf9cBsZqxmRzrkiZA6iVA6/1foBXgCUUA7Zo4BcAFAAAIVTcK +Zjf2nUYdoAtlAPSdZh3gCkUA9OAABvfmAQBbx1cc64UlFh8vQOwuQOktQOgoQO2YECtA7isWASpA +7yoWAilA8CkWA/ieMBWgC2UA+CCGFaAKRQBbx0n6JgAV4AoFAFuijhXrdRvrdYocL1Js66oIB4B5 +gAAsUmv7gEqYEgCdACtSZdMP+2BEcBIAnQAtUmf7oESwEgCdAClSafsgRMgSAJ0ALkJSZOehG+sv +L7Ho4uslF73hgAAtsoIuQiEsQiApsoQOzDYNmQzzIABEsB2FAAyZLA2YLCycMA3MLgyZDKmICogR +6hYeJEAzAACoqv9P4BXviAUACP8BLxYhL3bEW6GhLRIkKUJSKxIhCt037OsWHu5CgADtuwgEu0mA +AC8SIA8CAA//D+YWJS//QoAALxYjKMEe8QHQDe/GBQAd6i8e6nwt0XIrvD8GuwHr5owu7wKAAK27 +7+q0FfD9AAAG7gEuFiIu9gFbwwEe6swc6vQtEiIZ6vwrEiQNrQjokegm6P0AAAbdAQvbCO3m5SXY +/QAA92AEBb/PBQDqtAAEOGmAACsWEi1A7y5A8SpA7ShA7CZA8ClA7qqIrmatmQsuDC1CUqmI6GYI +DdAEgADmFh0mo0mAAP6dMBXgCiUA/iOGFeONHQD4I0YVoAsFAFuiKysSGlqxbikSGioWGwmqKFuh +XCwSGyoSHcC4DLsM+0MADXBrRQBasWYrEhsqFhXTD6q7+iLGFeAKhQALqgwrEhwqFhf7QwANcGtF +AFqxXBzqwC8SIysSGi5CICoWGAuqKPKFhhWg3k0ACtkB6UYtJ4EJgACv6LCICNgBCJgMKEYtoogu +QiAodsb4hagV4N5NAC9SZWT3UihSZ2SHYi9SaWT3cy9SbGTwBShSa2SHfyhSbi/6wOgWFCQAUYAA +KFJtZId+KBISoqoqRioMiDeujunaAQdz/QAADt4BLkYsDqoMoqouUBEqRi36IsgVoGgFAAjuAigS +GC5UEfsAAEQwDoUACO4MKEIhDr4o+iLoFaCITQAI7gEuRisuEhULqigL7ijzQABFPogFAKjuZGDP +KUDsZJYlBuss65soBVD9AAAPqgEqRi4PuwErRi+rqilA7WSWGAbrLOubKAVQ/QAAD6oBKkYwD7sB +K0Yxq6opQO5klgsG6yzrmygFUP0AAA+qASpGMg+7AStGMwuqCClA72SV/QbrLOubKAVQ/QAAD6oB +KkY0D7sBK0Y1C6oIKUDwZJXvBuss65soBVD9AAAPqgEqRjYPuwErRjcLqggpQPFkleEG6yzrmygF +UP0AAA+qASpGOA+7AStGOQuqCHrLCy1QES4KIA7dAi1UEVvDRPqECBXgCgUAW/x15qdBbRAEgAD6 +hCgV4AoVAFv8cQqiAu1CIS06AgAA/aKgQVAKBQBtCAqxqgChBAA/Gn37AmP/7iISJehCKyCwgQAA +pikpkAAqRiQNiCwJiS4JiAzoRiMgmKEAAKMvL/AALkIj7XbNL+iCgAAN7QIsQiQa6nXr6nUWY9UA +AO12zi5kAoAAW8JWL0IhHupwK0IgLEIjLRIfKEItAswsptkLiCwP7izpkAAmY/kAACxGJS5GJhzq +JB7p+wmJLgmIDChGIhjqZKPaKqAAKUIi63bLLVBCgAAKmQIvQiMrQiKvu/tmABWgH4UAD6ouCrsM +6XbMJdjBAAAqQiMpQiIPqiwPmSwNmSwCqiwd6b8AmREJqgIr1hsqdscqEh4qdsUKuRGpqimCYg+Z +LOrWGCzOgoAAqaoogmMPiCzq1hksRoKAAKiqD7ss6tYaLd6CgACrqi1CKitCLC12yCt2yhvpqC1C +Li9CLylCLq+Z7ebbJMv9AAAvQjAp5twoQjEtQjCo3e/m1ybr/QAAKEIyLebYKUIzL0Iyqf/otvUn ++/0AAClCMi+29i1CMyhCMq2I6ebfJEP9AAAtQjQo5uAvQjUpQjSvme229yTL/QAAL0I0Kbb4KEI1 +LUI0qN3v5uMm6/0AAClCNi3m5CtCNyhCNquI6ebhJEP9AAAtQjgo5uIvQjkrQjgPuwjt5ukl2/0A +ACvm6nrLCyhQESkKIAmIAihUEVvCucAg0Q8AGunU+UALi6IAnQAqFiD/5OQNoAolAAAAAAAAAC1C +hOsWEiaLQYAA/J0wFaPdHQD8IyYV4AolAPwjhhWgCwUAW6EPKxIZWrBSLhIZKhYTDqooW6BALBIT +KhIdwLgMuwz7QwANcGtFAFqwSisSE5odqrv6IcYV4AqFAAuqDCsSHJof+0MADXBrRQBasEEc6aUq +FhAiRiwpEhkuQiAvEiMJqSj4IiYV4N5NAPmgBATwC4UA6UYtJ4EZgACv6iqs/wraAQqaDCpGLQKq +CC5CICp2xviFqBXg3k0AL1JlZPNzKFJnZIODKlJpZKOVL1JsyPQoUmtkg7IqUm7TD/FAoA3vzwUA +KFJtZIOyKhISDKo3rqrp2AEFU/0AAAraASpGLAqIDKKIKlARKEYt+CHIFaBuBQAOqgIqVBEuEhAq +EhGo7qKqKBIZKkYqKkIhDr4MDo4oCgoGCu4Bih8uRiuOHQqKKAjuKPNAAEU+iAUA+cAARz/uOgAA +AAAAAPhgEOOiAJ0AIxYg/98QDaAKNQApQOhkkqgtQOntFhwmlRGAAChCISpCIKiy6ooIARP9AAD7 +zwAPMIhNAOndCA7QBIAA8wAEAT6GBQCm7iYSHSJGKg6qKK1mCe0oBqosBt0sDYgBLUIgKEYrqCLz +oABBMN1NAAraAepGLSET/QAAAt0BLUYs/UAARX/r7gAAACtChPt/upiSAJ0ALEIhLUIgDDw2DT02 +LUYg/IQmFa/c8gAAAC5ChGXoV2SyrGSStylSbmSYSy9SbWX4RSpWbflAAEV/4P4AACix6WWIQSmx +6mWYOyyx62XINWP4ai1ChGXYlC7B6GTiXi8SICt2xg//Dwv7C/YkphWgCAUA+CRmFa/iLgAtken5 +rwwN788FACiR6mWI5S2R62XY38ePKHbGwNAtds0tds4tdsstdswZ6MotlhstdscodsUolhgolhko +lhoodsgvUmXodsonkVGAAC9SaWTyLylSbmScTihSbWWMSCpWbflAAEV/8QoAAClSZupWZS1YBIAA ++yAART/dngAsUmgqVmf7gABFP92SAC1SaupWaS1IBIAA+6AART/dcgDHn/iFxhXgCAUA+IXmFa/n +lgDH3/yGBhXgCwUA+oYmFe/nygDHn/iGRhXgCAUA+IZmFa/oAgDH3/yGhhXgCwUA+oamFe/oOgDH +n/iGxhXgCAUA+IbmFa/ocgDH3/yHBhXgCwUA+ocmFe/oqgAa6In5QARTogCdACoWIP/WhA2gCkUA +AAAqVmv/QABFf9qqAChSZi9CLAiZDClGLan//qymFe/ibgAoUmgvQiwImQwpRi2p//6s5hXv4i4A +AChSai9CLAiZDClGLan//q0mFe/h6gAAAChCLA+ZDClGLamI+K1mFa/hxgAoEhQImQwoQiwpRi2p +iPitphWv4b4AGukBeKNoKhYg/9RUDaAKVQDH3/yFRhXgCwUAK0YrLUYs+oWmFe/ivgAoUmYvQiwI +mQwpRi2p//6sphXv8eoAL1JoKkIsD5kMKUYtqar6rOYVr/GqAAAAKlJqKEIsCpkMKUYtqYj4rSYV +r/FiAAAA+9EeBeAKBQD6JAYV79KeAChCLA+ZDClGLamI+K1mFa/w+gAoQiwKmQwpRi2piPitphWv +8PoAAAApwellnZotwepl3ZRj/Z0AAAAuUmYqVmXq6ggM6mYAAC9SaipWafvgAEU/9PoAAAAqUmYr +VmX7QABFf/dCAAAAK1JqKlZp+2AART/3GgAAAPyECBXgCiUA/dGGBaALhQBbxIrRD8Ci/dGABaAL +hQBbxIfRD2wQDhTovRjogBfovBPoIxLoCi5wAol3i3aMde1yBCDQgQAAnaCcoZui6aYDIPhBAAAu +9AIncQAn9QD2AGId7//1AB7oqixCS5+An4Gfgp+Dn4SfhSkypO+GBiDQQQAA/wDmFeANFQD/IAQH +MAsFAP+iAA2xmXEAqpnrJIEg0IEAAPkgEBXgC3UA+FAGHeAIhQBtig8ooQcoJUHsiwh1U/kAALC7 +x78sMqQe6JUa5+DuzAEN7UKAAA3MAuw2pCDIwQAAL6KH/UEAFej/gQDvlgAk8BEAAC3Sh/tCABXo +3YEA7eYAJOAhAAArsof/QwAV6LuBAOvGACTAMQAAL/KHKiB+Dw9YL4YAZKAh6KwQDVwCgADsuwIN +TgKAAAmpAguZAiggfyk2wSg2wiogfiUgf4scH+h06lUIDdwCgADqEg0qwgKAAOuLAgquAoAAC1sC +C6oC/0YADXAGFQAqNrGJHu4SDyzMAoAACYgCCFUCBe4CD+4CLjayHeetLdKHKzKC/FkABnLd4QAM +3TfszAIm6AkAAO/MEQ7uQoAA/YYADnx9FQANuwEMuwIrNoIf6Fca570mJLwsQeUtIUElIIEpMoIr +Qk0rJiH7IAQEsIgFAPqJaBWgTgUA6Y45CoEKgADu9IAu6AqAAC0mJCpGTComIiomI/zgCtiiAJ0A ++dCIBe/MBQDrvgkAwQEAAOqvCQ92goAA/fAAF7PuHQD3IAQV4/8dAOeFACf4/QAA7P8BB3D9AAAM +7gEpkAL5AEYd4AoFAOnoNBdxAQAA7iYmJ/kBAAD+RQYV4Af1ABjoLy0ypC4cQPkUiBWh3XEArt0t +0AAb6CsNiCj/0FIF4D31AA2ICy1CJwyIAe8mLCRBAQAA6CYqJsDHgAAL2wqLsAqwAAAtQiclMoMo +kqYvIiz7NOgV5QA9APlLAA0zVSEA9KFAFeSqAQC7rPuABADQC2UA/MABAlAKRQDs6BMacASAAFvD +zi4iLAQdFO7UOQqCCoAABAQZZEBYKiIhBKosW57EFeblKFITDogRAIEE4KsaC+gKgAAsMoT6REgV +r/L1AALSAwwsAQSqLAy7Ais2hFueuCtSEw67EQCxBACpGioyvQKqAQqZAvh3phXgAgUA0Q/AINEP +ACxKAAyqNyomIgq6N1uevComISlBGiomIupGIy0oBIAA6kYlJIyZgAAPnhEO7gnsQRknaA0AAA7t +O/vNmgXh3Q0ArcysrAy7NismISsmIgu6Alueqy4iIhzn3/xEKBXgC2UA5egMDXgEgAD4IAYVoApF +AFvDlSoiIVueoeoiIi1IBIAAKSYhW56eKiYiKyIhBa0MLUYmBbwM/ISGFa/4NgAtQiclMoMrkp7+ +RYgV4wA9APkz6BWjVQEA66oYAqgpAAD/+rANpKoBAC1CJyUygyuSzv5FiBXigD0A+TnoFaNV4QDr +qhgCqCkAAP/6DA2kqgEAJTKDLUInKpLJ/kWIFeNVwQDoksoiqCkAAP/5iA2kqgEALUInJTKDK5LD +/kWIFe2APQD5OIgVo1WhAOuqGAKoKQAA//jkDaSqAQAtQiclMoMrkr7+RYgV6wA9APk36BWjVYEA +66oYAqgpAAD/+EANpKoBAC1CJyUygyuStv5FiBXpAD0A+TboFaNVYQDrqhgCqCkAAP/3nA2kqgEA +LUInJTKDK5Ku/kWIFecAPQD5NegVo1VBAOuqGAKoKQAA//b4DaSqAQArQjYKuwkrJiH6REYV7/oq +AAAAAGwQBBrngiqif/mcAh2j64UAC6osqKhuiAorGpf7YA4SogCdACoKZBLnevpPxB2gCxUAW54Z +KiV/FOd3984gBaADBQD1zIYF4Af1ANowW54JAzoCW54BwCDaMPpAaB3gbEUAW53G6jQACVgEgAD8 +AEIdoA0lAFud5rEiaSva2jBbnbr2gEYVoAoVAFu56tow+gHiHeAOBQD+gEYVoGxFAFudt/pgaB2g +C/UA/ABiHaANJQBbndcS51iVQickAC8KAP6ARhXgAgUA6jQACVgEgAD8AGIdoA0VAFudzbEiaSvn +4zwBIiBBAAD4f/r6UgCdAPPNSgXgBwUA9gCiHaAsBQAHAkf4/6AV4AsFAOnLOAlQBIAAW52PKAoI +CHgCCAhHKDZSJTJTBSQR9G4ACjAKBQDqNlYiKAcAABrnOfoAQh3gDAUA9pgAFLANVQD3JgAMsA4V +APhrBhXgDwUAWqa05qB6bRAEgACxRHVJzMLAwLArNlixd+oyWCkDIgAAaXaAH+btHucn/c32BeAL +BQD6AAIdoBQFAAS8AgwMRyw2UgqJFACZEQ2ZAik2UwsIR+8ABQXYBQAA6TJTLEcCgADuiAgFUCMA +APkTqBWgiQUAbZoCCAJhaba+ZiACW5260Q8AAAAALepwra1u2AUuCs966wr/+MwNoDolAAAAAC/6 +OK+vbvgExYd6iwf/+GwNoBqVAP/4TA2gCqUAbBAEF+cCCTUR5UUCCTeCgACnZpVg0Q8AbBAE8kAG +FeVGBQD4AAId78wFAOklFCFYgQAA/WAEBbCKBQDlpToBYMEAAOwmDCpABIAA/EGmFaA0+QDjaDkF +2QEAAJsp6yYIIVDhAADoJRUq2ASAAFuQ2wNkOetUAApQBIAAW53QmiHRDwAAbBAGF+aQ0w8PAgAo +clwjCgDkgDRjkeEAACgigyRypgg4CAmIEQhECCpCBysaUPtByBWgDAUAW74DKXJc6kYOIZgFAADT +D3kzzxPm0PQAAh2gBgUA6zB9KlAEgABbvq/qZjcCIAUAAOlE6WGYBQAAK3JZLHJaKnJbnBHsuwgD +MAUAAPtAAEVwCwUA6xYDJQlxgAAb5ZHzzQoFoA4FAP4gRhWgAeoAACgwVC80Va+P7xYBL9AEgAD/ +wAfS4gCdACkKgP9PAA4wCgUAbckuLLKDKHKmrq2tzOavCA5mQoAArIiMMC+ENyWEDCSEDZyIAv8K +Cd0C7faAJVAFAACmpo0TKHJaL3JZ7nJbJugFAACdE6j/r+7/oAUqogCdACSygIMTKnKmpDPvEgEp +nkKAAKozJDAN3vDlMAwie3GAABnlZ4sSKZKDq5noMgAszkKAAKmpmRAllAzklA0qWASAAOiWCCrQ +BIAAW75tG+VcjhCMEuowVC1oBIAALeQ37DRVJmAFAADsFgIoBAqAAPdf+3lSAJ0AjhEPAgAPAgCu +qO40VSR7/QAA7xYBL9AEgAD/3/hz4gCdAP/9DA2gCgUA0Q8AAGwQEhTlRdMPKEG9JwqA+CAABDAF +BQAIdTn6oGgd7/r1AFudVfdAaB2gCwUA9CJmFe/69QBbnVAqFhf6SAIdoAsFAFudTSoWFvv/4h2h +CwUAW51JKhYV+//iHaELBQBbnUYqFhT7/+IdoQsFAFudQioWEvoAAh3v+vUAW50/mh37/+IdpAsF +AFudPCoWEfogAh3iSgUAW504KhYQ+rACHeJKBQBbnTUqFg/7ykIFo4sFAFudMZoe+gACHe/69QBb +nS4qFgz6AAId7/r1AFudKioWC/oAAh3v+vUAW50nmhr7/+IdpwsFAFudJJoZ+//iHacLBQBbnSCa +GPv/4h2nCwUAW50dKhYH+//iHaCLBQBbnRqaFvv/4h2hCwUAW50WmhX6AAId7/r1AFudE5oU+//i +HaOLBQBbnRDVoPoAAh3v+vUAW50NLhIXLUIjIxIVL0IlDt0oLkIiA/8oIxIWDmwonBOtzC1CJAPd +KCMSEq/dL0InrcwtQiYD/ygjEhQD3SgjEhCv3S9CLK3MLUIoA/8oIxIRA90ogx+v3S9CK63MLUIq +A/8ogx4D3SiDHa/dL0I6rcwtQjQD/yiDHAPdKIMar90vQjatzC1CNQP/KIMbA90ogxiv3S9CPK3M +LUI7A/8ogxkD3SiDFq/dL0I+rcwtQj0D/yiDFwPdKIMUr90vQkGtzC1CQAP/KIMVA90or90vQkSt +zC1CQgX/KArdKJUSr939gABGd/31AO7TD304BIAA8iBoFeAAJgAAAADAMKPF2lBbnMTbUPYgJhXg +jAUAWBYI+UBoHeCMBQDnpAABgnmAAC9CIicSE9MP8eOADeAFBQDqFhgtGASAAO10AAnQBIAA+//i +He/89QBb/tFaoWMoQiLjYwgCqAUAAHhT2/gjCBXgjAUABlco0w+nl2QmLsAw9iAGFaAFBQAmQoil +ZpNgLkJxKEIifjMJroj4YAbTogCdAC5CcilCI34zCa6Z+GAIe+IAnQAuQnMqQiTTD34zCa6q+mAJ +U6IAnQAuQnQrQiV+Mwmuu/pgCjviAJ0ALkJ1LUIm0w9+Mwmu3fxgCxPiAJ0ALkJ2L0InfjMJrv/+ +YAv74gCdAC5CdyhCKNMPfjMJroj4YAzTogCdAC5CeylCLH4zCa6Z+GAN++IAnQAuQnoqQit+Mwmu +qvpgDyOiAJ0ALkJ5K0IqfjMJrrv6YBAL4gCdAC5CeC1CKf5gEQOiAJ0Art38YBCy4B5FAP7Ahh2g +APoAAAAAAADqdAAJ2ASAAPwiaBXgDwUA/sCGHe/89QBb/oP4IAgVr/v1APtABhXgCQUAmWenh1qh +ECwKgOxVCAGYBQAA8n/2fSIAnQBgBOzqdAAJ2ASAAPwAAh3gDCUA/MCGHa/89QBb/nEtEhf6wOYV +oIwFAPegAEP//w4AAADqdAAJ2ASAAP4AYh2iTAUA/sCGHaANBQBb/mUvEhb6wOYVoIwFAPfgAEP/ +/k4AAADqdAAJ2ASAAP3/4h2gCEUA+MCGHaENBQBb/lkpEhX6wOYVoIwFAPcgAEP//Y4AAAD6YGgd +7/z1APoAoh2hDQUA6mQEK9AEgABb/k0rEhT6wOYVoIwFAPdgAEP//M4AAADqdAAJ2ASAAPwAIh2h +DQUA/MCGHa/89QBb/kEtEhL6wOYVoIwFAPegAEP//A4AAADqdAAJ2ASAAP3/4h2gHiUA/sCGHaQN +BQBb/jUoEhGaZ4+u9wAAQ/CMBQD34AYVr/s+AAAAAAAAAPpgaB3iTAUA+gMCHaENBQD6wIYdr5ll +AOlkBSvQBIAAW/4lKxIQ+sDmFaCMBQD3YABD//pOAAAA6nQACdgEgAD8AsIdpY0FAPzAhh2iTAUA +W/4ZjR/6wOYVoIwFAPegAEP/+ZIAAAAA7OPrG9AEgAD6YGgd4B5VAP7Ahh2jjQUAW/4Njx76wOYV +oIwFAPfgAEP/+NIALkJ/KEI60w9+MwmuiPhgCJOiAJ0ALkJ8KUI0fjMJrpn4YAl74gCdAC5CfSpC +NdMPfjMJrqr6YApTogCdAC5CfitCNn4zCa67+mALO+IAnQAuQoAtQjvTD34zCa7d/GAME+IAnQAu +QoEvQjx+Mwmu//5gDPviAJ0ALkKCKEI90w9+MwmuiPhgDdOiAJ0ALkKDKUI+fjMJrpn4YA674gCd +AC5ChCpCQNMPfjMJrqr6YA+TogCdAC5ChStCQX4zCa67+mAQe+IAnQAuQoYtQkR+Mwmu3fxgEWPi +AJ0ALkKHL0JC/n/qW6IAnQCu//5/6griAJ0A6nQACdgEgAD9/+IdoBilAPjAhh2gDQUAW/3FiRH6 +wOYVoIwFAPcgAEP/9FIAAAAA+mBoHe/89QD8AAId4AqFAOpkBCvQBIAAW/25ix36wOYVoIwFAPdg +AEP/85IAAAAA6nQACdgEgAD8AAId4AyVAPzAhh2v/PUAW/2tjRz6wOYVoIwFAPegAEP/8tIAAAAA +6nQACdgEgAD9/+IdoA6lAP7Ahh2gDQUAW/2hjxv6wOYVoIwFAPfgAEP/8hIAAAAA6nQACdgEgAD9 +/+IdoAi1APjAhh2gDQUAW/2ViRr6wOYVoIwFAPcgAEP/8VIAAAAA+mBoHe/89QD6AYIdpw0FAOpk +BCvQBIAAW/2Jixn6wOYVoIwFAPdgAEP/8JIAAAAA6nQACdgEgAD8AaIdpw0FAPzAhh2v/PUAW/19 +jRj6wOYVoIwFAPegAEP/79IAAAAA6nQACdgEgAD9/+IdoA7lAP7Ahh2nDQUAW/1xjxf6wOYVoIwF +APfgAEP/7xIAAAAA6nQACdgEgAD9/+IdoAj1APjAhh2gjQUAW/1liRb6wOYVoIwFAPcgAEP/7lIA +AAAA+mBoHe/89QD6AgIdoQ0FAOpkBCvQBIAAW/1ZixX6wOYVoIwFAPdgAEP/7ZIAAAAA6nQACdgE +gAD8AAId4BwVAPzAhh2v/PUAW/1NjRT6wOYVoIwFAPegAEP/7NIAAAAA6nQACdgEgAD9/+IdoB6V +AP7Ahh2jjQUAW/1BjxL6wOYVoIwFAPfgAEP/7BIAKEI79lICHeJzBQDTD/EI8A3gBQUAJkKAIkKI +plYJZhGmIoYnhm7AwOshEiNRgQAAW7tciyvjaggNQASAAPhBRhWgDAUAW7tXiy7naggNSASAAPhB +phXgDAUAW7tS3aD6QigV5KoFAKpq/EIGFeAMBQBbu0zdoPpKkBXmugUAqmr8QmYV4AwFAFu7RitC +O+omFCKoBQAA0w/6v/vL4gCdACxCPNMP8YjwDeAFBQAmQoEiQoimVglmEaYihieGbsDA6yESI1GB +AABbuzaLK+NqCA1ABIAA+EFGFaAMBQBbuzGLLudqCA1IBIAA+EGmFeAMBQBbuyzdoPpCKBXkqgUA +qmr8QgYV4AwFAFu7Jt2g+kqQFea6BQCqavxCZhXgDAUAW7sgK0I86iYUIqgFAADTD/q/+8viAJ0A +LEI90w/xiNAN4AUFACZCgiJCiKZWCWYRpiKGJ4ZuwMDrIRIjUYEAAFu7EIsr42oIDUAEgAD4QUYV +oAwFAFu7C4su52oIDUgEgAD4QaYV4AwFAFu7Bt2g+kIoFeSqBQCqavxCBhXgDAUAW7sA3aD6SpAV +5roFAKpq/EJmFeAMBQBbuvorQj3qJhQiqAUAAPq/+9viAJ0AwCDRDwBsEAYY48YW48YCJQroVQoB +A9mAAPRABICSAJ0A6lLFKRRIAAApUsR6mQ5bmo0iUsPRDyJSw9EPAAArUsEc45wDrQz7rwAO8ORN +AA7dAa27K1bDKWJIL2IWGONYrLz54ABH8AolAPvvAA/wDhUA+eAAR7ANBQBbu14f4s0u8H3EIALu +Ai70fSJSw9EPKFLFIlLDo4ioSPkf4BWglE0ACYgBKFbE0Q8AAAD6QGgdoAsFAFualvVH4BWvyAUA +CEQB6lLBKlgEgABbwXnAoVuaYZQQHOOV+gECHeANFQD3QGgd4A8FAP7gaB2gClUAW79AwKDSoBPj +E6NzKjaBJDaCKjaDAuQWAQIA2nD4cGgV4QslAFo7CyQyiMhJ+uBoHaELJQBaOwfeQALkFsCl/cb+ +BaALhQD+cQgV4A0VAFu/LCpi5ylSwqqZKWbnKFLE+N0mFaACBQAiVsEiVsIiVsMiVsQiVsXRD2wQ +CBzjHRfjcNMPKMIU5nKVJAIpgADAIN1g/soIFaAKVQD9xtQFoDsFAFu/Fx/jaBzjaS3yay7ymP/s +6BXhuQUA+CAGFeAKVQDyICYVoDsFAFu/DdEPACpydyhydP7uqBWuVgUA90AAQz/7BQALZgH+wAYD +ogCdAOvidBQFwYAAKbB99u7mFaBKBQAKmQLptH0rUASAAC9ydvYgZhWhvAUA/CAmFaANJQD6IAYV +oBsFAPogRhXgClUA/cTOBaALBQBbvvHtZAADBAmAAObUAAaDYYAA2tD8NgIdoAsFAFu5zhrirPby +phWhSwUAW6tD2yDiFgQp4ASAAOpmUCpoBIAA7lQAC1AEgABb89z8AAId4AkVAOqaOQ0QBIAA56QA +AQRhgAAKnThl3u1j/v8AAAAAAAAA//14DaAGBQD/+7QNr/JFAAAAAAAAKnJtL3Js90HgFa/4BQD4 +wAQDMbsFAKtre/M/KXJqy5nrdm0t0ASAABziLC5ya5YT+iAGFaG7BQD6ICYV4A0FAPoAAh3gGgUA ++iBGFaAKVQBbvrv8wGgd7/yyAP//JA2gBgUA3DDtRAAK8ASAAOsSBCtQBIAAW/KWHuKtwPHzQGgd +oAwFAP3CiBXgChUA56w4CUgEgAAC+TkC/Tjt5hQmcimAAMCACag4ZY4jY/41AGwQBBLinygiF8iH +wCDRDwAAAAAA+8TEBaFLFQBbqvkZ4vAd4pgPAgApkX/7xcAF4QwFAAysAv8hQAbQCgUADcwCKrZy ++8SsBaFLFQBbrhVbjNXA4f5C5hWgAgUA0Q8AAGwQBPPFwAXh+sUAFOJRCgs/KULfCVkUKTYcKELh +CGgUKDYdJELjBFQUJDYeEuIjIiLeAgJA8nIGHaACBQDRDwBsEAQS4tH2AAIdoANFAA8CAOUslCE5 +AQAAbTog5HJ/IRgLAADkNQQiqBEAAORyfyEQCQAABDQUJDUIJlagwCDRDwAAAGwQBBfiwRXiwhTi +wBziwv3DMgXgAgUA41wIKjAEgADoRAAKyASAAPpgaB2gGwUADwIADwIAbbol7IaDJFgLAADphn8k +QKEAAOmGdiTIoQAAKoZ36oZ4JVChAAAttQwb4q4c4q74wIAl4AgFAOiWHyFQSQAAW4zIGuFqKqCA +ACAECgobf68tHOKj/cL0BeKrBQCrZqt3qzPrVQgBEAUAAOtECAgECoAA+F/7olIAnQDAINEPABvh +XBrimiuyhRzhZSqigasr7eKXHd5CgAD7QABFcMuFAFo8w2P/qgBsEAQU4pIqQmnzw6YFoAkFAPp8 +AAU0CAUAbYoKDJsQ6yb7JMgFAABkoFFpoU4jQmoqQlZbmTVbmSP8BAIdoAuFAOc3PH0oBIAAHeKB +GuKC/8JMBeDjOQDTD+7aOQHkHIAAD6oCejcFGOFcCKoCezcTGeIV+UYADXAANgAAwCDRDwAa4nX+ +YYAHEAlFAB3htNMPDaoC7uJyEfRggADuqgIB+ECAAC9AfQ8CAH//AgyqAn83AgmqAguoAigm/MBr +BWYMBGMQIyb9GeJmCTkCKSb+Iyb/KC0EiIAa4cEb4mP9xMIFrzn1AAmIAeuIAgFIEwAA+SAGFaA7 +hQBbrXrq4bgbQwKAAORvEQtnAoAA7GwCC3YCgADv7gILagKAAO09Agt8AoAACP8CD90CDt0C/YYA +DnA7lQBbrWsoQlL2oAATMDMFANMP8QKQDeAFBQAY4PXTDw8CAAhmAtxg6uGgGdgEgABbrWApQlKx +VelT6nGYBQAAwDD6YGgdoAsFAPwAAh2gDQUAW4xesTNpPucjCgDaMFuMUbEzaTv1KiLBG+I0C6oC ++lgmFaACBQDRD2wQBMAg0Q8AbBAIFuIuDwIAKGJc9cRaBeAEBQDq4i0UGlGAAJoXG+IrGODD+cRQ +BeAPFQAvFgYpFgT4IAYVoAIFACIWAesWAiVREQAA6hYFJdkRAAD6IGYV4AIFABfgzydyhCNipKdH +CXcRpzOHNydyDitiWvrgaB2gDAUAW7ki+stIFeAMBQDqNhsj0IEAAFu5HSo2HCJ2MyJ2MixioMGQ +KTQErEycMC5QgPoAIh3gDVUA/sAABDXv5QD9DCAmVM4BACI0JPRkRh2gGPUAKDQhGOIBLlBQIjUc +KzQtIjUdIjUeIjUfIjQqIjQrIjRkIjYdLzUZIjQ0LTQpIjQsIjQ1IjRB8mZkHaTuAQAI6AqIgCI0 +aik0a+40IywAIoAAABjh7iQ0Iis0JCw0IS5QUCI1HCs0LSI1HSI1HiI1HyI0KiI0KyI0ZCI2HS81 +GSI0NC00KSI0LCI0NSI0QfJmZB2k7gEACOgKiIAiNGopNGvuNCMsACKAAAAAACk1H4oX+mOmFaDP +BQD+Y8Qd4AIWAG9DDYkQKJK4GuDUCogCKJa4+oBoHaALBQBblmf6IAgV4AMWAIoV+mOmFaAMhQD8 +Y+QdoMsFAPpjxB3gAR4Aihf6Y6YVoA6FAP5j5B2gzQUA/GPEHeAAtgAuUIj6IIgVoAyFAPXABRGQ +ywUA+gBCHaAbhQDs4bYaaASAAFu9RioyHYimAzoCC4AA6zAjLUgEgADpNRwqUASAAFuV1eahS21I +BIAAKDIdiInaMAuAANmg6hYBLQm6AADaMFuU4SkxHPMgBq7SAJ0A8yAHLxIAnQDxIAkvkgCdAPqA +aB2gCyUAW5Y2ixApYlzrvSAiqAUAAOsWACIgBQAA+J/uk+IAnQD4ICgV4ANmAAAqNh0sNR/6Y8Qd +7/26AAAALlCIihP9w0AC0M0FAPoAQh2gG4UA7OGIGmgEgABbvRdj/0EqNh38Y8Qd4A6FAP5j5B2v +/NoAAAAAjxbI/VuWNOagjm1IBIAAwICYFi5QiIoS/cNgBFAJJQD6AEIdoBuFAOzhdhpoBIAAW70E +Y/71ACo2Hfhj5B3v+8YAAAAAAAD6gGgdoBsFAFuWBfogCBXv/PYAAAAAAAD6gGgdoAuFAFuV//og +CBXv/JYA+gBCHaAbhQDs4WMaaASAAFu88IIR0Q/AkBrgXiqgfekWASVsKoAA0pDRDwAAW5RwiRFj +//HGKtEPbBAUFOFXGOFXK0IaKUIeLEIYKkIcJ0IgL4KzLYFsLoFqnhOdEi8WFycWEyoWFZwVKRYU +KxYWKULnK0LmLIFuKkLlnBEogXD7QABFcAIFAPsgAESwBwUA6BYAJJ2JgAD4IIYV7/L1APXCgAXg +DwUA/iJGFeALBQD0IwYV78UFAB7f5B/hOCjigCbyyah4CYgRqGaDZxrgMoM+KBIXKWE+mTOYMi1C +zKiYKBYXfaMLiRX8YIYV4AA2AAAAiRUsYTacNCmcPwWZASk2BS1AlO0WHCaDQYAAK0IZKmBuKhYO +KxYPW76I/COIFeAMBQBbvb8CqgH8ACId4AwFAAzcOQraOQyqAuW+AQUBKYAALBIYLRIP/iHIFaAK +JQD+I4gV4AsFAFu8nfAAMA2v66UA/mDGFaALBQBmss+JNSoSFog2DwIA6YgIBVD9AAAFqgEqNgfv +QJUkQP0AAAWIASgWBe8WGyeDQYAAK0IbKmBvKhYMKxYNW75k/CNoFeAMBQBbvZsCrAH+ACIdoA0F +AA3tOQzsOQ3MAuW/AQYBKYAALBIYLRIN/iGIFaAKJQD+I2gV4AsFAFu8efAAMA2v66UA/mEGFeAL +BQBmsj+KNykSFYw4DwIA6swIBMj9AAAFmQEpNgnoQJYmYP0AAAXMASwWFugWGiQDQYAAK0IdKmBw +KhYKKxYLW75A/CNIFeAMBQBbvXcCqgH8ACId4AwFAAzcOQraOQyqAuW9AQUBKYAALBIYLRIL/iFI +FaAKJQD+I0gV4AsFAFu8VfAAMA2v66UA/GFGFeALBQBmsa+JOS4SFIg6DwIA6YgIB3D9AAAF7gEu +NgvvQJckQP0AAAWIASgWFe8WGSeDSYAAK0IfKmBxKhYIKxYJW74c/CMoFeAMBQBbvVMCrwH4ACId +4AgFAAiYOQ+fOQj/AuW5AQeBKYAALBIYLRIJ/iEIFaAKJQD+IygV4AsFAFu8MfAAMA2v66UA+GGG +FeALBQBmsR8uMguNPCoSE48Srt3uEgElUP0AAAWqASo2DSxAl+oWHSbo/QAABd0B7RYUJgQ5gAAs +QJgrQiEqYHIqFgYrFgcsFhBbvfb8IggV4AwFAFu9LQKtAf4AIh3gDgUADv45Df05Dt0C6hIdJoF5 +gAAsEhgtEgf+IMgVoAolAP4iCBXgCwUAW7wLij3+YcgV7+ulAP4iJhXgAEoABbgBKBYR+GHGFaAL +BQCNEI4RjxL8IGgVoAA2AI0QjBOJPikWESkSEihhOiw1Iig2EJk/qYkpFhIoYTIoNSMvNSQpYTOs +jJwTKTUlLjUmKGE0r5+fEig1Jy01KClhNa6OnhEpNSkoEhGtnZ0QqKjpEgQkQP0AAAWIAegWEyO4 +BQAA+P/j5WIAnQDSsNEPANEPAABsEAQa39rTDyaiWRXgVPDDIA3gBAUAF+BS+cCkBaAJBQBtCBwi +cIAAQAQCAht/JwsFRgsoZkApZkEmolmxRHZLAmP/3CiiWvEFwA3gBAUAG97sbQhOL7KBLqKmr08J +/xGv7izhEy/gYiPgVobvIuBXjuztTAgrNYKAAOXdCwkRQoAA5iICCZ7CgAAD/wIC/wIv1kAA7hEO +zAIs1kEpolqxRHlLAmP/qtEPAAAAbBAGGN7UKoI78UGMDeAEBQBgAHYa4AIqokLjswgCIAUAAHpL +ZRPeyxLf/SMygCIij6NDCTMRoyIlIQcjIRMqIAz6QbAV41VhAFu30xvgHCkhByghEguZAfMmAAzw +CwUA6SUHJH2BgAAIXBEMqgJtCBUf4BOjvi0hEg/uCurmwCXYBQAAfbuMY//jAMDE/UEADjAIBQDo +FgAmBjmAABrf3x3foZ0SGd6riBCOEimSgC+ijy7g5amICYgR+eAAR7ALBQDvFgEnA/GAAIoR0w/q +oAwluAUAANtwW7rHJqEH46ETLSAEgAArQA37QZAVo2ZhAFu3qSlBB+rf8R0oBIAAKEESCpkB8yYA +DPACBQDpRQckAMmAANtg4yoICuAEgABb8X4rQRKxInsj6owSLMDloyPsc5V72ASAABrfuCyiQsDU +Dcw2jhCPEg8CALHu7hYAJ/gFAAAvFgL93/pLogCdAP+9oAWn+PUAc4MpGt/VG9/V888ADPANVQD6 +YAEFMAx1AG2ZEB/fpi/xzG70AnuhZyymwLSqGd+hKZHLwIN5gE8b358ishgtsocsshokshkrso8N +zAjiRAgOZkKAAAy7CCOxBw5ENiqwDPthsBXjM2EAW7dxGN+74k0MCc4CgAAJqQIIKApt2gfphsAk +QBEAANEPAAAAAAAA/VgGFe/+XgBsEAZb9/fmokltEASAAFv2reaiPm0QBIAA+73mBaArdQBbp4sZ +36n6AAAGsARFAP0vhh3gygkA/S+mHaC6EQD7L8Yd4IoZAPkv5h2gBxUAW/OM5qH9bRAEgAD7vcYF +oUsVAFunexLfmRbev/O9GAXg+kEALyS4LmLTDwIA6d7jHxBCAAAokX3zAA8/UgCdACuRfhTes+Xf +VR2AfgAALJF/zMQtkYBk0e/7vxQFoAslAPxAAh3gDAUA/gACHeAOJQD+gmYVoA4VAFqe0GagISdG +Ey1iwp1RLGLYnFIrYtmbUyli25lUKGLwmFUvYuwvVgbmoV9tEASAAC5S/h/ewAjuESjykAgIRwju +Ai72kFvyReahP20QBIAAW/FC5qE0bRAEgAApMoAm+sDl3owUgXmAACKcPwYiASI2gCJWoS8yfPHh +gA3gAgUA+kBoHeAKBQBblEEoMnwiLAF4I+spMoLKmSucPwa7ASs2gitWoioyffFBgA3gAgUA+kBo +HeAKFQBblDUsMn0iLAF8I+spMoTKmi6cPwbuAS42hC5Woy0yf/GhkA3gAgUA+kBoHeAKJQBblCkv +Mn+xItMPfyPqKDJ+8QFwDeACBQD6QGgd4Ao1AFuUISkyfrEieSPsKTKGyZIc3vQa3z0b3zssNoeq +mguqASo2hh3fNh7e6S3SEa7dHt48LearW/DmFt7+wCD9/oId4IwFAC5inm7jOStincuz+gACHaAM +FQD8AAId4AkFAPggJhXgDgUA+CBGFeAIFQD4IAYVoA8FAFqgycCjKmadZCBO0Q+wzPuAIBXgDxUA +6/s5BnAFAADu0jgN/VYAAGP/3RreXfooAh3jLHUAW6ocGd5iY/4IAAAoMH0EiAL4b6Ydr/fKAAAA +//jUDaAKBQAAABrfD/m+GgXgC4UA+IWmFeAMBQBbtqAa3wsb3sgc3sdbtp0U3wn/vLoFoAoFAP28 +sAWv//UA+p/gJeBNBQDTD23aDC2yf37RYKzYL4aAtLsrQn/qQoAiQCEAAP1gAEWwSVUA0w9tmhAp +gn8qtoAqgoDsmwgEQCEAACwwfOq2gC4QcAAAHt4YKOJ2LwoCD4gCKOZ2LeJ+D90CLeZ+W5VeKVKC +B5kCKVaC0Q+s2PsQBhWv/noAAAAAbBAEHd7kLNJZy8wozP8IygHowBt+WASAAG0IDLCp6aoBDVgE +gAB5sANj/+wAD7sRHt7aL8wf+8+GHeX/HQD/z6Yd4AoFACrkfvm0qBWgigUACAA/W5VICgE/0Q9s +EAwW3s+PIBXdZuPeHBnIBIAAmRUrUoctUoEoUoguUoAsUoLi8AwpOASAAJIXL/ANnxji3jAeZkKA +AOyMCA92QoAA7o4IDu5CgACtjZ0anhkuYjfsFgst3kKAAKuI6BYMJwK5gAAqCgBblXUDqQgokoBn +gAttCAUqkoBnoAJj//Mb3hwvYjcc3hr6AEIdoA0FAP/+ACXgDhUAW7YkLmI3IlZsGN6o4lZuJ0vD +AAApVm2o6ChWbyhWcCtiacq088AAQTAKFQBblV6jqSySgGfADG0IBSuSgGewA2P/8wAuYjdk449b +lXosUiotUisuUikvUiwiUigjUickUiYoUiUqUiMrUiIpUiQrVnKrqitSNCpWc6qZKVZ0qYgqUjUo +VnWoRClSNiRWdqQzKFI6I1Z3oyIkUjsiVnui/yNSPC9WeK/uIlI9LlZ6rt0vUj4tVnmtzC5SQCxW +fKy7K1Z9LVJBq6oqVn4sUkSqmSlWf6mIKFaAqEQkVoGkMyNWgqMi8rBmFaAEBQAkVnGi/y9WhK/u +LlaFrt0tVoatzCxWh1u139OgW7Xe0qBbtd3dQPm6DgXgSAUA/7qaBe+LBQDnFgQpADAAAPYghhXg +DSUA7wIADT5CgADzIARqogCdAClScC5SbgeSDAsiAf5AEsOiAJ0AKlJtZKJNK/B9IlZwCLsC6/R9 +KUgEgAAc3TwvUm/4IAYV4ApVAPYgJhXgjQUA/CBGFeALBQDyIGYVoA0lAFu5vmUgkB/eCSjyxST6 +gO/yxCQR/QAABCIBon7/4A87ogCdABneASmSwmSR2Rnd//AA3A2gDQUAGt38DdkKDwIACpkKKJLF +75LEJBH9AAALIgECfgj/4A2zogCdACuSwmSxq/WgDkESAJ0A7pbFL0AEgAAc3QkuksP2ICYV4IQF +ACQWAvIgZhWgClUA+CAGFaALBQBbuZniVoghD4GAAC1SOydShyRSgilSgOhSgSu+QoAA5ycICiZC +gADkJAgMzkKAAOkpCAxGQoAAqCjoFgYu7kKAAPghKBWkrR0AbakFCACGCQJh+iEoFaa9HQBblMMt +UjzpEgYu7kKAAPghSBWkrR0AbakFCACGCQJh+iFIFaa9HQBblLktUj3TDwndEfghaBWkrR0AbakF +CACGBAJh+iFoFaa9HQBblLAtUkLTDwndEfghiBWkrR0AbakFCACGBwJh+iGIFaa9HQBblKfAofoA +Ah3gDAUAW/npL1G9wON/4AnCkPAAMA2gCCUA+AACHeAIZQAtYsfI1qiaCtooW5Ss2jBb9zFb9sAu +YjfI7A48FPu7ugXgCiUAW/nYKGJpyIQrYjdksGQb3PP9uc4FoAoFAFv50voAAh2gCwUAW5SSG93T +HN3T/0BoHeANBQD+ACIdoAoVAFu1RYoXixhbuImNFIwVmtDzgAYV4AIFANEPAAAAAPm7EgXgDQUA +//mADaACBQD/9vwNoAIFAMCi+7t8BePIHQBb+blj/4oY3KMvgH3EoAr/Ai+Eff84iBXv+KoAAAAv +YmnAouzdHRlYBIAA/+AAR7ANBQD//gAl4A4VAFu1JiliaSJWbCJWbukoCATLwwAA6VZtJEPDAAAo +Vm/4rgYVr/DCAMck0Q9sEAbaIPogaB3gPNUAW6eJGN2iiRAign8Kkjvihn8tEASAANEPAAAAbBAG +2iD6IGgd4DzVAFunfxjdmYkQIoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog+iBoHeA81QBbp3Xp3ZAd +AKoAAIIQBEgKqYjihIAtEASAANEP0qDRDwAAAGwQBtog+iBoHeA81QBbp2np3YQdAKoAAIIQBEgK +qYjihH8tEASAANEP0qDRDwAAAGwQBtog+iBoHeA81QBbp13p3XgdAKoAAIIQBEgKqYjihH4tEASA +ANEP0qDRDwAAAGwQBtog+iBoHeA81QBbp1Hp3WwdAKoAAIIQBEgKqYjihH0tEASAANEP0qDRDwAA +AGwQBtog+iBoHeA81QBbp0Xp3PMdAKoAAIIQBEgKqYjihIAtEASAANEP0qDRDwAAAGwQCh/dWIv0 +iPbi8gcpUASAAIn1jPON8o7xnhGdEiwWAykWBSIWBygWBisWBO/yACoYBIAA/iAGFeA71QBbqDLm +pAAFAjGAACigAMCQ6tyiFAU5gAAJlALjFggguIEAANMQhTAPAgAPAgAFWgJbqDjrVAANEASAAOpk +AAlgBIAAW7VyyKe4M3c518Yq0Q+mLCvAAMLc7bEKflAEgABlv+RgAAGxyukyASV/CYAALqAA1qDk +lAIPfVYAABvch4oY+0AARXD/9QB/QT4Z3IIkpID+gaAH0AoVACyRfwrMAiyVf35HIC2Rf8DkDt0C +/S/kHeACBQDRDwAA+oAAR7ACBQAi9IDRD8Ag0Q/AIPNQBh2gAgUA0Q8AAABsEAbaIPogaB3gPNUA +W6bzGN0QiRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFum6RjdB4kQIoJ/CpI74oZ/ +LRAEgADRDwAAAGwQBtog+iBoHeA81QBbpt8Y3P6JECKCfwqSO+KGfy0QBIAA0Q8AAABsEAbaIPog +aB3gPNUAW6bVGNz1iRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFumyxjc7IkQIoJ/ +CpI74oZ/LRAEgADRDwAAAGwQBtog+iBoHeA81QBbpsEY3OOJECKCfwqSO+KGfy0QBIAA0Q8AAABs +EAbaIPogaB3gPNUAW6a3GNzaiRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFumrRjc +0YkQIoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog+iBoHeA81QBbpqMY3MiJECKCfwqSO+KGfy0QBIAA +0Q8AAABsEAbaIPogaB3gPNUAW6aZGNy/iRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzV +AFumj+jctR0AsgAAiRAigoAJIijihn4tEASAANEP0qDRDwAAbBAG2iD6IGgd4DzVAFumgxjcqokQ +IoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog+iBoHeA81QBbpnkY3KGJECKCfwqSO+KGfy0QBIAA0Q8A +AABsEAbaIPogaB3gPNUAW6Zv5qAfbRAEgADqNAAKWASAAPygaB2gfSUA/iAIFeAOFQBYEw3RDwAA +AGwQBtog+iBoHeA81QBbpmHmoB9tEASAAOo0AApYBIAA/KBoHaB9FQD+IAgV4A4VAFgS/9EPAAAA +bBAG2iD6IGgd4DzVAFumU+agH20QBIAA6jQAClgEgAD8oGgdoH0FAP4gCBXgDhUAWBLx0Q8AAABs +EAbaIPogaB3gPNUAW6ZF5qAfbRAEgADqNAAKWASAAPygaB2gbfUA/iAIFeAOFQBYEuPRDwAAAGwQ +Btog+iBoHeA81QBbpjfmoB9tEASAAOo0AApYBIAA/KBoHaBt5QD+IAgV4A4VAFgS1dEPAAAAbBAG +2iD6IGgd4DzVAFumKeagH20QBIAA6jQAClgEgAD8oGgdoH1FAP4gCBXgDiUAWBLH0Q8AAABsEBYb +3Ef6IGgdoIwFAFuygfpAaB2gO9UAW6cd4qQABQ6BgAAooAAjFiIlFiHkFiAkBDmAAPQv4BWgJcUA +9IAgFaAJBQD4JGYV4AFuALhm9MAM7CIAnQAnYgAHegJbpx7rdAANGASAAOokAAngBIAAW7RYZa/W +ojctcADl0TF78ASAAGXfxuliAScLMYAAKhIjKOAA6poCDxAEgADqFiMkAOmAAPYgaB2v/r4AAAAA +AP7gIBWv/0oAwLArFiMqEiIsEiH6JAgV4F3lAP4kaBXgDiUAWBKRLBIj+bUoBeAOJQAPAgD/gaAH +0A0VAC+Ruw7/Ai+VuygSI/8BoAdQAoUAKpG7AqoCKpW7KxIj/2GgBxAcBQAvkbsM/wIvlbsoEiPT +D9MPe4cIKpG8DaoCKpW8KxIj/2GgBpAjBQAvkb0N/wIvlb0oEiPTD3mHCCqRvQ6qAiqVvSgSICsS +Iy+SEyoKYAq6AQqPOe+WEyXgQIAAK5G+DwIADbsCK5W+LRIjd9cIL5G+Dv8CL5W+KBIjdocIKpG+ +DKoCKpW+KxIjdbcILZG+A90CLZW+LhIjdOcKL5G/wIUI/wIvlb8qEiNzpworkb/A1g27AiuVvy4S +I3LnCC+RvwL/Ai+VvygSI3GHFCqRvwyqAvs35B2gAgUA0Q8AxirRD8Ag0Q9sEAjaIPogaB3gPNUA +W6Wd5qCJbRAEgAAc2kbA0OzAgCDYQQAA+gAiHaAIRQBtig98oAmx3eq2ACXYEQAAD6oR8aWQDeAK +FQAmHBD+IAgVoA8FAPoAAh3gCEUA0w9tiid64Bx6wA7/RgAP8ABaAAAAAAAAAAANuS4GmQqJkA+f +Auu8AS1XwoAA2jDrRAAK4ASAAP4AIh2gbRUAWBIh0Q8AbBAG2iD6IGgd4DzVAFuldeagH20QBIAA +6jQAClgEgAD8oGgdoG3FAP4gCBXgDiUAWBIT0Q8AAABsEAbaIPogaB3gPNUAW6Vn5qAfbRAEgADq +NAAKWASAAPygaB2gbaUA/iAIFeAOJQBYEgXRDwAAAGwQBtog+iBoHeA81QBbpVnmoB9tEASAAOo0 +AApYBIAA/KBoHaBthQD+IAgV4A4lAFgR99EPAAAAbBAG2iD6IGgd4DzVAFulS+agH20QBIAA6jQA +ClgEgAD8oGgdoG1lAP4gCBXgDiUAWBHp0Q8AAABsEAbaIPogaB3gPNUAW6U95qAfbRAEgADqNAAK +WASAAPygaB2gbUUA/iAIFeAOJQBYEdvRDwAAAGwQBtog+iBoHeA81QBbpS/moB9tEASAAOo0AApY +BIAA/KBoHaB9xQD+IAgV4A4lAFgRzdEPAAAAbBAG2iD6IGgd4DzVAFulIeagH20QBIAA6jQAClgE +gAD8oGgdoG0FAP4gCBXgDhUAWBG/0Q8AAABsEAbaIPogaB3gPNUAW6UT5qAfbRAEgADqNAAKWASA +APygaB2gXYUA/iAIFeAOJQBYEbHRDwAAAGwQBtog+iBoHeA81QBbpQXmoB9tEASAAOo0AApYBIAA +/KBoHaBdRQD+IAgV4A4VAFgRo9EPAAAAbBAG2iD6IGgd4DzVAFuk9+agH20QBIAA6jQAClgEgAD8 +oGgdoE1FAP4gCBXgDkUAWBGV0Q8AAABsEAbaIPogaB3gPNUAW6Tp5qAfbRAEgADqNAAKWASAAPyg +aB2gPYUA/iAIFeAORQBYEYfRDwAAAGwQBtog+iBoHeA81QBbpNvmoB9tEASAAOo0AApYBIAA/KBo +HaAtRQD+IAgV4A4lAFgRedEPAAAAbBAG2iD6IGgd4DzVAFukzeagH20QBIAA6jQAClgEgAD8oGgd +oC0VAP4gCBXgDhUAWBFr0Q8AAABsEAbaIPogaB3gPNUAW6S/5qAfbRAEgADqNAAKWASAAPygaB2g +LQUA/iAIFeAOFQBYEV3RDwAAAGwQBtog+iBoHeA81QBbpLHmoB9tEASAAOo0AApYBIAA/KBoHaB9 +5QD+IAgV4A4VAFgRTxnalSiQfcChCogCKJR90Q8AbBAGaTEFbkQGZEADxirRD9og+iBoHeA81QBb +pJ3o2nUdAMIAAIkQqEgigH0JIjbihH0tEASAANEP0qDRDwAAAGwQDBzavcffnRSLwYjDicIpFgIo +FgMrFgHswgApUASAAPwgBhWgW7UAW6WO4qQABQuxgAAqoAAuCmB662wvCnp682bTEPQiABXgN6UA +hDDaQFullutEAA0wBIAA6iQAC2AEgABbstDKo7gzdTne8gACHaADBQD4ACId4AoFAPMiAA0wCAUA +Cpg4zY9gAReibCvAANrA92AQnGIAnQBlv8hgAgoAAAAAAAAAwDD8AAIdoF3VAP5AaB2gBAUA6xwg +KVAEgAD1YGgd4A+1ANMPbfoaKqAAfaEc5KA0ZmAFAAAqtACiyu6kAAXYBQAA/kFgFaAMtQDqHCAn +EAUAAOXICADYwQAA9QAGHaAMBQBbpFD6QGgdoDvVAFulU+KkAAUEQYAAK6AA0w/xYrAN4C31ANyg +bQgNfbEUK8AB5LAYZmAFAABj/+sAAAAAAAAA9CCGFaABcgAAAIkUZJBQwMD4JAAV4Aq1AG2qFSog +AOSgEWEQBQAAKpQA7MwBJMgFAADAy6XL+iQAFaAMBQDktAAg2NEAAFukLwr+UPwAIh3gDAUADtw4 +ZcC1xirRDwAA+iQAFaAMBQD+QGgdoA+1ANMPbfoYK+AAfbEa5LChZmAFAAArpADizggFUAUAAP5B +YBWgDLUA6hwgJxAFAADlyAgA2NEAAPUABh2gDAUAW6QV8Uy4DeBq+QDAwPgkABXgCrUA0w9tqhUq +IADkoBFhEAUAACqUAOzMASTIBQAAwMuly/okABWgDAUA5LQAINhBAABbpAT6ACId4AwFAAa8OP+V +YA3gmvkAwNAJvThk30nJNGg7VsHhfjE1wCDRDwAA//40Da/qpQAY2VqCHKgiKCKAiRT+IagV7/r1 +AAqZAwmIAQj/Av5QBhXgAgUA0Q8AGtk7ixyMFI0dW6PhwCDRD7HK0qDyYCgV7/cKABrZN4scjBSN +HVuj2sAg0Q8AAAAA+gAiHaAJBQAGqThln4Fj/sgAAABsEAbaIPogaB3gPNUAW6PY5qAYbRAEgAAo +EgAb2ekICUfotH4kqCeAAGiTAdEPxirRDwAAbBAG2iD6IGgd4DzVAFujyxjZ9okQIoJ/CpI74oZ/ +LRAEgADRDwAAAGwQBtog+iBoHeA81QBbo8EY2e2JECKAgAqSO+KEgC0QBIAA0Q8AAABsEAbaIPog +aB3gPNUAW6O35qAUbRAEgACJEBvZyAkIR+m0fyQYG4AA0Q/GKtEPAABsEAbaIPogaB3gPNUAW6Or +GNnYiRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFujoRjZtYkQIoB9CpI74oR9LRAE +gADRDwAAAGwQCPpAaB2gO9UAW6Sd46QABQnxgAD3sYYF4AQFAPewpgWgJcUA+mBoHaALBQD4AWId +4AwFAPwgphWgAPYAAAAAGdhKBB8UB/8KLfKux+8OmAPo3QEJ0ASAAO29AgIgBQAA/fXGFeAJtQD0 +gAcTUAsFAIgVZYDY3hBtmh0toADl0R99+ASAAOTQvWXYBQAALeQA47oIB3AFAAD6YWAVoA+1ACsc +EPHgAEdwDAUA80AgFeANBQDt5AAo0ASAAFuja9Kg5yBaadAEgAABGQL+AAId4Ai1AG2KFC2gAMnW +7ZQAJ/gFAADqrAEkyAUAAPphYBWgD7UAKxwQ8eAARvAMBQDzQCAV4AkFAOnUACjQBIAAW6NW5qA5 +bRAEgADA4S4WBRrZJY4UKqJ/DqsoLDroDLsse2Md8p/4T9IAnQAZ2Lr5YAAVv/wGAAD//dgNr+Kl +ANEPH9l0/bLoBaALFQAK/yz8gGgd4ApFAFu0zvuwAAXv/xYAAGwQDhvZbfogaB2gTIUAW6+g+kBo +HaA71QBbpDzipAAFA+GAACigANMPZIBv9ikAFaAHBQDyIGgd4AA2AAAAAAC4M3YxVoQw2kBbpELr +RAANKASAAOokAArgBIAAW7F8Za/dolwqwADC3O2hN35YBIAAZa/L6TIBJYEhgAAusADSsOeXAg99 +fgAALxoMf3AMEtlL9k/mFeACBQDRD8Yq0Q8AAAAA+4AgFe//MgBsEAT6QGgdoDvVAFukFeKkAAUA +2YAAE9k/2jBbpCPcoOs0AAlQBIAAW7FeyKLGKtEPGNk5Gtk6IoJ/GdjFCiIBCSIC8w/mFaACBQDR +DwAAAGwQEBvZM/ogaB2gbAUAW69h+kBoHaA71QBbo/3kpAAFA4GAACigAA8CAA8CAGSAmfYsABWg +BwUA8iBoHaAANgAAAAAAuCJ2IUaDINowW6QC6zQADSgEgADqRAAK4ASAAFuxPGWv3aRcKsAAwtzt +oU9+WASAAGWvy+kiASWAoYAALrAA1LDnlwIPfX4AAGAAO8YqZiAyGtkPL6F+ffwJLaV/0Q8AAAAA +AP9P5BWgCxUA/bIUBaAKRQBbtF7GKtEPAPuAIBXv/tIA0Q/AcN1w//8ADaACBQAAAGwQEBvY/fog +aB2gbAUAW68r+kBoHaA71QBbo8fkpAAFA4GAACigAA8CAA8CAGSAb/YsABWgBwUA8iBoHaAANgAA +AAAAuCJ2IUaDINowW6PM6zQADSgEgADqRAAK4ASAAFuxBmWv3aRcKsAAwtztoSd+WASAAGWvy+ki +ASWAoYAALrAA1LDnlwIPfX4AAGAAEcYq0Q8AAAAA+4AgFe//cgDAcB/Y1txw+6/gBaACBQD378Qd +4UsFAFujrtEPbBAEwCDRDwBsEAYtIADrNAAKYASAAPqgaB2gP9UA/6WmDeAGBQDFO3PRI94g0w/T +D20IFeTQSGMwBQAALeAB79EMd3AFAABz0QRj/98AABfYvpsS/CAmFaADBQDqFgAjoEEAACVyf9sg +7GQACtAEgABbsNPIrLh35HnocZghAADGKtEP2lBbo492qeka16H6YABFOVgFAHih5esSAiVAGwAA +KIItjBHtEgApUASAAAuAANKg0Q8AAGwQBtxA6iAAKugEgADyIGYVoAYFAP5gaB2gP9UA76EueRgE +gADFK3KhJNswDwIA0w9tCBXkoEhjMAUAACqwAe+hDHXYBQAAcqEEY//eAAAX2JGeEvwgJhWgAgUA +7RYAI6jBAAAkcn/bMOxkAApQBIAAW7ClyKy4d+V56HEQIQAAxirRD9pAW6NhdqnpGtdz+kAARTmI +BQB4oeXrEgIlQBsAACiCIYwR7RIAKdAEgAALgADSoNEPAABsEAbcQOogACroBIAA/mBoHaA/1QDi +FgMpGASAAP9Fhg3gAgUAxUt0oSLbMA8CANMPbQgV5KCYYRAFAAAqsAHvoQp12AUAAHShAmP/3hXY +ZZ0SnBH3sMYFoAcFAP4gBhWgADoAuGblYWZzuCEAACRif9sw7CQAClAEgABbsHVlr+LaQFujNHKp +2hrXRfrgAEU6uAUAeKE4ixBpsRcsEgEtOv99yQ4e2FAv4oAu4n8P7gguFgHrEgAlQBcAACiCFYwR +7RICKdAEgAALgADSoNEPxirRD2wQBtxA6iAAKugEgAD+YGgdoD/VAOIWAykYBIAA/0VGDeACBQDF +S3ShIAM7Am0IFeSgSGEQBQAAKrAB76EMddgFAAB0oQRj/+MAABbYM54S/CAmFaAHBQDtFgAjKaEA +ACRif9sw7CQAClAEgABbsEPIrLhm5Wnoc7ghAADGKtEP2kBbov9yqeka1xH64ABFOygFAHih5esS +AiVAEwAAKII5jBHtEgAp0ASAAAuAANKg0Q8AAAAAAABsEATAINEPAGwQBCUgBvJA8BWgChUAWASc +9aziBa/2tQD3QAccIAcFAOdGgikeAoAA4lsdcZmvAAAIUhEiLWvaIPoD4h3gHPUAW6ovIi0Bcyns +GtgEG9gEHNgEW6orKELHGtgCGdgDCogBCYgC+JjmFaACBQDAoVuqGSIsAWkp9PqY6BXgAgUAwKFb +qhQiLAFpKfQd1/gtRsosCk78hoYVoAIFAMChW6oNsSJpKfX+hogVoAIFAMChW6oIIiwBaSn0LxoA +/ojmFeACBQDAoVuqA7EiaSn1IkJHwCDAoVup/7EiaSn1wKNYBGh2oRr5r8QFoAIFAG1ZDSeGQCeG +fOeGfiRABwAA0Q/HJdEPbBAEGdfaCCgRqYgpgkEa19gb19joglEpZYKAAFup98Ah0Q8AbBAYhSYm +IAYa19H4QPAVoAsVAPgkRhWgDBUA0w9bqe4pEiL4wCqK4AMFABTXxwaXDCUWG6Y12lBb/+hkoMzi +WQkK1gKAAKSqK6JRK5UcwIAoplEolSUolS7olTchmAUAAHc5zx7XvC0SG8CQKRYY/6AEBrAMFQD8 +IoYV4AsFAA3LOCsWFSMSGBrXsQYzCOvXsBnlgoAAW6nQ6xIiK1AEgABYAubAoP2vWAWgCwUAWAFx +ZqBW6xIiK1AEgABYAt/AoP2tkAWgCwUAWAFqZqA7IxYTWAFJZKS/GtbD/CJoFaALBQD6JGYV4AMF +APokJhWgCQUA6RYgLmaCgAD1gAEGMAUFAPwj5hWgAI4AxyvRDwAAJVwBLhIjLRIg7uwBIZhBAADu +FiMug9YAACkSH+WWUiTwEQAA5eZSJOghAADl1lIk4DEAAOXGUiTYQQAA5bZSJNBRAADlplIkwGEA +AOWGUiT4cQAAJfZS6xIiK1AEgABYArIsEiHH/9MP78wDCdAEgADsFiEp2ASAAFgBOmavelgBGWWv +esCR+CQGFe/94gDjEiEvXwKAACsWHisWEvwiaBXgCQUA+COmFeAPBQD+IWYV4A4FAP4i5hWgBQUA +9CNGFeAOBQAuFhkC2AnoFhYu7gKAAPWgAEawDAUA/CIGFeAFBQD9qiYVoADeAAAAAAD0oAVhkgCd +ACsKAesWGiKoBQAALhIcLRIdLBIZLuwQ7hYeJsgFAADpFh0uBLYAAPokSBXv//UA7zMDC1AEgABY +An8rEh4DPALTD+sWHC3QBIAAWAEIZq6yWADnZa+hKhIL9V/1NdIAnQAtEhorEhYsrAENyjkrsRws +EhfqFgst38KAAP1gGBuiAJ0ALMwBLBYXLhIQLRIWKxIiLOZR7NUlK1AEgABYAmX//ZwNoAUFACkS +HSsSFioSF+q1JSTIBQAAH9cmjfKO8Yv0iPCM84r1mhWcE5gQmxSeEfwgRhXgDgUAnh4tEhMrEhKI +9ugWBiznAoAA7LsIDu6CgAAE3QotFh+P958X07DrEiIrUASAAAERAlgCStow7NcQGdgEgAABEQJY +ANRmreHyIaYV4AyFAPmuEgXgCwUA+iImFeAKBQDqFg8p6ASAAOkWIS6YBIAA7RIfKPAEgABtyiIv +0lIoCn/5/+0sIgCdAIngCQlA6fkIB3ARAADp1lIm6BEAAOsSIitQBIAAARECWAIsLBIh8iGGFe/6 +9QDqzAMJ2ASAAOwWISnQBIAAWACy7RIfLWriAADyIGgd4AUFAIswDwIA9WAKYJIAnQDjPAQiqAUA +AOlY52boEQAAjRD4IQAVoA4FAP4AIh3gDAUA/eIADnAJNQD8ICgV4MwBAA8CAG2aIPkACBXgCgUA +Df447YIBJEAhAAAM6wH54gANcA4FAAusAQ3+OC0SDHzgCf4hxhXgDhUAnh8uEhEpEg/9ogAV4AyF +AO7sAS6YBIAA7hYRJPgZgAAjEg0vEg4M6BEIMwjrNAAH9SGAACsSIikSFekWCCtQBIAAWAHxJRIh +KPr/6FUDCdAEgADrNAAK4ASAAFgAeeUWJC1jugAAJRIWKRIUDwIAJVEc5JCYYqvBAACTGiMSJCgS +ECsSIuWGUStQBIAAWAHfKxIK+iEmFe/59QAJMwPsNAAN0ASAAFgAZmasLFgARmSgVSwSFizBHO/M +EQKoBQAAdcNEjhmNGC7sEO4WCib9iYAA8iSGFeAA4gAAAAAA7RYlKtAEgABYACLtEiUtdU4AACkK +ACk2AC/SUij8/w+POP+qRhXv+koAKhIWJaU36xIiK1AEgABYAbwtEhYPAgAu0Tcs0SWuzAwcEi4S +ECsSGCzmUezVLiXYBQAAKxYY93/YjWIAnQDrEiIrUASAAFgBrsAg0Q8AAAAiEhb8RKQdr/K1ANEP +ABPVk//wJA2gCwUAAGwQBBXWbm8oQ/pABADQA0UA4tS+GqgKgABtOhMoIoQIWAEpIokJWQHpiSFx +EBEAABzUtyrCJcCwK8Yl+qAEBTD59QD7IMCFoAIVANEPwCDRDwAAAGwQBBzUrdfAJsKI+6ywBe/4 +9QD41wALMAIFAPfgAAMw/fUAKHKE+kCAFaAFBQD48SgV4A5FAG3qJQAgBAYPGe/3GnEQBQAAAFAE ++J8ACfFInQD04AACNzMBAHQ5GrhVtHfreb59EASAACjCJcCQKcYleNgDwCHRD8Ag0Q9sEAQY1I7T +D9MPJIaEJIaFJIaGJIaHIoaA+6xsBaALFQDzECYV4AwVAFuoTvoAIh3gDAUA/gAiHaPthQD7rFwF +oA8FAFqVOvgAAh3v8lUACpI70Q9sEBIlIAckIAYiFhZ1SzcZ1hwCSgnkXAwKRgKAAPkAAERwCwUA +bckbKYJBKaVA64ZBJVAJAADrpUgkQAcAACulUSulWgkHTxrWD/oAIh3gDBUAW6gv9IAmOuAJBQAp +FgsEWgwqFhMjEgsa1gYEMwjr1gYZ5YKAAFuoJupEAArYBIAAWAE8KgoA/awEBaALBQBb/8Zmoczq +RAAK2ASAAFgBNcCg/ao8BaALBQBb/8BmobHaQOMWDSrYBIAAWAEuKBIWiR0ImAkoFhcogUAqCgAq +Fhka1evj1REczgKAAAqZCPgjBhXgCgUA+iKGFaAGBQD5KCYVoAIFAOpEAArYBIAAARECWAEcKfr/ +6TMDC1AEgADrZAAJ4ASAAFv/pGahQ1v/hOwSFyUhMYAALMFAD8wRLMwQ94AJY+IAnQCxdy4SGS8S +GC0SFPbCABWgAgUA5/ZBJ0gFAADpFhkm/PGAAMAg+CEGFeAGBQDmFhUstwKAAOpEAArYBIAAWAD+ +KPr/6DMDC1AEgADrZAAJ4ASAAFv/h2agzlv/ZuSgsmEQBQAALBIYKxIXLRIVLMJBK7Fb9sIAFaAa +BQDsuwwG6AUAAPtABQviAJ0A7RYVKUKYAAAuEhcn5Vse1bQq4gMr4gIo4gUv4gYp4gSM4Y3gnRCc +EZkUnxaYFZsSmhPu4gcqUASAAO4WByrYBIAAWADaiBgnEhWod+zVpRufAoAA6jQACdgEgABb/2Jm +oDoiEhgiIk+xIpcZGtPt+as6BeALBQD6IkYV4AYFAPlRBhXgAQIAKRIYKJJB+R/gFaACBQD5KCYV +r/0CAMcl0Q8AAAAAAAAiLAEqEhIrEhgpbAHmlAABmEEAAOK2Ty0EXgAA6kQACtgEgABYALge09UD +OgL9qUAFoA0FAO3miCnYBIAAW/9AZq+y6kQACtgEgAABEQJYAK4Y08oc1XPv1XsZ0ASAAO+GiCnY +BIAAW/81Zq+IW/8V16Ae08Ic1I7t1XMZ0ASAAO3miCnYBIAAW/8tZq9nW/8N91/7WOIAnQCwKOKC +OQNIBQAAGNSDmBovEhgsCgAs9k8rEg36ISgVoA0FAC0WDx3TrwqaCCoWDP2xBhWgDgUA7NVQHVcC +gADuFg4lUEEAAOoWEC3egoAADLsK+iImFeAKhQDpEhEo8ASAANMPbaoiL5JHKwp/+//3ZGIAnQCM +4AwMQOz8CAdwEQAA7JZHJMgRAADqRAAK2ASAAAERAlgAdoMaKxIQx98NMwPqtAAJ4ASAAFv+/uMW +Ci11YgAAARMC9iIoFeAGBQCOMPXACziSAJ0A53wEIzAFAADpaOphmBEAAI0Q+CEAFaAOBQD+ACId +4AwFAP3iAA5wCTUA/CAoFeDMAQAPAgBtmiD5AAgV4AoFAA3+OO2CASRAIQAADOsB+eIADXAOBQAL +rAEN/jgqEg8vEhAM6QHuEg4lUAUAAOoWDyf4QQAA/iIGFeAIFQD5DQAPcAqFAO4WDid4OYAAKxIY ++oBoHaAGBQDitk8q2ASAAFgAQIccgx+nM4caDDMR8mIAFe/49QDodwMJ0ASAAOs0AAvgBIAAW/7F +IxYa5hYbLW4aAADmEhorEASAACMSGCMyQSM88CgSGNpA44ZBKtgEgABYACzHn+l3AwtQBIAA62QA +C+AEgABb/rVmrYVb/pRkoIGwM2QwfOQvyWMwQQAAKRIXKZFJLBIXJ8FbqXcHFxItEhgqEgsrEhMn +1kHnxVIlUAUAACoWC/tf2lViAJ0A6kQACtgEgABYABLAINEPAAAAANpgW/5pZa6UwJCZMChyR7CI ++OjmFa/6IgArEhgpEhkqEhfntkEkyAUAAPdLZB3v7/4AKhIXAwlP+UkkHe/+HgAAbBAE5NTCGUYC +gADyQ3IN7fr1AAI5DASICG2ZDSmCfAqZAemGfCRABwAAwKFbptDiOQwJRgKAAPUAAEQyCgUA0w9t +mg0pgnwKmQLphnwkQAcAAMChW6bGwCDRDwBsEAjkIAYpGASAAPZA8BXgCjUAWAErIvr780AITCIA +nQAW0v0lCgAPAgAlZoL7qUIFoAsVAPTRBhXgDBUAW6bA9oALYuAKBQCaFZMSBHsMmxaDFRrUmNMP +pDPr1JcZ5YKAAFumt4kSwFD4YABE8AMFAJkRJZQcihHTDw8CAPNEph3gChUAWAEO80AE1CIAnQDq +1JYZ5wKAAPymAA4w+/UAW6anKgoDWAEGcqF56kQAC9gEgABb/7vNXGUwGi8KAC9mgC9mgR7TqS5m +hB3UiC1mhS5mhi1mhxrUfvoAIh3gDBUAW6aX+6j0BaALFQD8fQId4AwFAP4AIh2gDwUAWpODZqAi +KGIl4ocjcZgFAAD4f/sl0gCdAOkSASKoBQAA+L/6elADBQDHJdEPAAAAiRWKFrGZmRX7P/jFIgCd +AIsW/iBIFaANFQD8IIYV4AwVAJwT/oAARzAKBQD+IAYVoAUFAG25O4MSpKijgyswJS8wHKv+Dg5H +LjQueEsZKDAkiRQLiAwIWTmZFCkwG4gTD5kMCVg5mBNkoK8NvTYM7DexqikSBGSQ0YoT4xICJQZh +gACnSwsbEqs7LbAlK7Ac6tRKHucCgAD9ZgAOMPv1AFumXPLEiBXgChUAWAC581/6PCIAnQAa1EHy +ZAAGcAg1AP2f4BWhMwEA7Fw1AZgJAADoMzQOZwKAAPxmAA4w+/UAW6ZMK2I6LGI7DLsM+mBAFaC7 +AQALqgMKCkAKOggqrAIqZjgpYkj8Y6BBUpkBAAk6CPtf4BWgAFYAAIwQLcAl/YXQFa/9NgAJmgIq +Zkj00EYV4Ao1AFgAl/Nf9eQiAJ0AIgoABgAAAAAAAP2PAA3//QYAbBAOGNQLIyAGJCAH7SIFKNAE +gAD2QHAV4As1APYiJhXgCZUA86S6BaAHBQDTD22aDimCQZmg54ZBJEAHAAC0qhnUDBbUDCcmI4xj +j2LlYgEg8MEAAJXhn+Kc44ZgluANWEHriDQA0MEAAAqICoiACAZA+AEAArCIEQDqVREMRcKAAOhV +Ags3goAA9qYACrCIBQAIWAIMiBEJiAL4QgYVoAYFAMChW6X7sWZpafX4QggVoAYFAMChW6X3sWZp +afUa0jsb0jv8fQId4AwFAP4oABXgDhUAWpLt8VGYDeAZBQD4RGYV4AYFAMChW6XqJmwBaWn0+kRo +FaAGBQDAoVul5bFmaWn1wKFbpeMa09v6AIId4AxFAFul6vunsgWgC0UA/H0CHeAMRQD+ACIdoA8F +AFqS1ugSES0F2gAA5Dsjec4CgAAa07sDSwwPAgAKmQjTD225DSuSYSmdAfNgBL7SAJ0AGtPF+gCC +HeAMBQBbpdT2RGYV4AoVAFulxh3TvQxcEQ3MAvxCBhWgAwUAwKFbpcGxM2k59f5CCBWgAwUAwKFb +pbwjPAFpOfQa0gAb0gH8fQId4AwFAP4oABXgDhUAWpKzZqAv6tOaGMAEgAD4ASId4A+FAP5EZhXg +AgUAbZoP6YIAJEARAADppkElUAcAANEPZY9FxyvRDwAAAGwQBCQgBhjTiyMgB+nR5BouAoAAqFX0 +bwAJv+QFAG06DSNSQAQzAeNWQCKoBwAAKJLAGtOUCogB+TgGFaACBQDRDwAAbBAEFNHVwjCKQgoK +QsinaKEFaKMCaaUX80bGDa/1tQBkIJFoITFoI19pJRhgAPQAsDNkMOrAoVulh2P/ymQw38ChW6WE +i0ILC0LrKe9xm/0AAMAg0Q8AAPVABbqSAJ0AwMH8gCYVoAUFAMChW6V5sVVpWfX8gCgV4AUFAMCh +W6V1sVVpWfVj/7tppVPA5P6AJhWgBQUAwKFbpW6xVWlZ9f6AKBXgBQUAwKFbpWqxVWlZ9WP/j8Ch +W//SdaFiwFCVQcChW6VksVVpWfX4gCgVoAUFAMChW6VfsVVpWfVj/2TAoVv/x3WhNykKAviAJhXg +BQUAwKFbpVexVWlZ9fqAKBWgBQUAwKFbpVOxVWlZ9WP/MgDAo1v/uvVf+iViAJ0AxyvRD8CjW/+2 +daHzwLP6gCYV4AUFAMChW6VGsVVpWfX8gCgVoAUFAMChW6VCsVVpWfVj/u8AAABsEAYW0X/oWRAK +Q8KAAOmIAgnPAoAACYgCGdM0CCgCCYgC+MIGFaACBQDAoVulM7EiaSn1+sIIFaACBQDAoVulL7Ei +aSn1+6LoBeAMBQD+ACIdo+2FAOrRbxj4BIAAWpIl+gACHe/ytQAKsjvRDwAAbBAKHNMfiiWIw4nC +i8GbEZkS+CBmFaEEBQD9gAgVoA1VAOwWACVcGIAAnRMKVkEBbQqN0PumKAWgAjUA/CAABnLdHQDn +3REOZkKAAP2GAA5ziwUAWAGfE9FOwFAlNiMrMjsrvPvzYIAFsAo1APpAAAXwDCUA/2gAFbANpQBb +/8TIpMcr0Q8AAPoAYh2gCwUA/ABiHaANpQBb/71lr+Ma0vPibTQA+EEAAA/dComhiKKOo57zmPKZ +8YqgmvCN0MDB/AAAB3AKNQD8AQAF8N0RAOq7EQ7twoAA7bsCD3eCgAD/ZgANsA2lAFv/qWWvk/YA +Ah2gB/UAwKFbpOSxZndp9cDoKzI6KjJBeutE/0ggB9CaAQCaGJkZmxr3QEAVoB8FAAb/NP5oJhXg +BgUAwKFbpNexZmlp9fhoKBWgBgUAwKFbpNKxZmlp9YwYihmLGqyqwNh60woqrPvwABwNoqoBAAoa +QiwyIP1/gBXi6gEA+9gAFzAKNQD8QAAF8N0ZAO7dEQ3fAoAA/2YADbDMiQDtuwIOZQKAAP1mAA2w +DaUA9WYADbAMBQBb/3plrtXAQMChW6S2JEwBd0n0+gCiHaALBQD8AAIdoA0FAFv/cWWussBAwKFb +pK4kTAF3SfT0ZoYV4AQFAMChW6SpsURpSfX+ZogV4AQFAMChW6SksURpSfUU0qL0eOYVoAQFAMCh +W6SfJEwBaUn0+HjoFaAEBQDAoVukmrFEaUn1wKFb/wPHm3mhOBTQ2CpCwQKqAvqYJhWgAgUAwKFb +pJGxImkp9fqYKBXgAgUAwKFbpI2xImkp9cDI/GRmFaACBQDRD8cl0Q8AbBAYhSQc0oWGJoclicOK +wovBmxGaEpkT/YAIFamHHQD8IAYVoAw1AHjAIRrSfhzSfPYKAAX312EA6N0RDdvCgAANuwIMuwJY +AX5gAAga0nUb0nZYAXv7pOoFoQsFAFgBePuk5gWgCxUAWAF1+6FeBaALNQD8fQId4Aw1AP4AIh2g +DwUAWpFjZqPV+6TUBaArBQBYAWsa0mj6PwId4fwFAFukafukzAWgC3UAWAFlG9CdGdJjK7LJgpKN +lI+T6JIBIPBBAACY4Z/j7eYEIOBBAADzwEYVorsxAAy7ComQ6eYAKpfCgADrsgApUASAAFqYCurS +VB1YBIAAWAFRG9EWBnpDC6oJKqEwBotRKxYkCloo4bsKDaeCgADrsgAtV4KAAFqX/eh/FH0YBIAA +CglA+AAiHaADBQAJgziqM+rSQxnYBIAAWAE+fzcBsTPq0kAZ2ASAAFgBOurSPhnYBIAAWAE4IxIk ++6R2BaALBQBYATT6oGgdoAdlAFuvWMBX7KQADegEgAD7pGgFoAsFAFut51uuPxvSMtxw+2DSDadd +JQDAxdtQ+6DSDaXetQDbwMDI+8DSDaTvFQDcsPvg0g2gC5UA28Aa0idYAR4c0iYtwgEuwgLvwgMg +2MEAAC+2A56ynbGMwJywq0vrsgApUASAAFqXye+nBn1YBIAAsasa0hpYAQ/9pDQF4LZxAOs7CQDh +AQAADLsKjtaP14rVidSI05jDmcSaxZ/HnsaP0o7RLsYBL8YCjdAtxgDrsgApUASAAFqXtRXQNytS +PCxSNxrSCKy7WAD7HNIHjcGOwu/CAyDZgQAAn7Oesp2xjMCcsKtL67IAKVAEgABal6fANAOpN++X +BnzQBIAAsZrAbgarNBrR+gERAlgA6uvR+RlQBIAAWpedA6k375cGfNAEgACxmgerNBrR81gA4uvR +8hlQBIAAWpeVCqMCJVI7/qEgD9CVAQB/pwGxo8iTfz8BsTP7o9QFoBsFAAO7NFgA1SMKA+vR5xlQ +BIAAWpeIBasDCwtAq6sa0eNYAM77o8YFogsFAFgAyxzR4Y3BjsLvwgMg2cEAAC+2Ay62Ai22AYzA +nLCrS+uyAClQBIAAWpd3A6k375cGfNAEgACxmgerNBrR1FgAvOvR0xlQBIAAWpdvwJoJqTfvlwZ8 +0ASAALGaKwo+C6s0GtHMWACy+6OYBaBLBQABEQJYAK/7o5IFoAslAFgArCUKBevRxxlQBIAAWpde +Bak375cHfNAEgAAqnAEGozTq0cEZ2ASAAFgAoerRvxnYBIAAWACfHNG9jcHuwgIg2f0AAO/CAyXY +BQAAn7Oesp2xjMCcsKtL67IAKVAEgABal0rAkwmpN++XBnzQBIAAsZoHqzQa0a9YAI7r0Z4ZUASA +AFqXQcCcCak375cGfNAEgACxmgarNBrRp1gAhevRphlQBIAAWpc476cGfVgEgACxqxrRolgAfvuj +RAWiCwUAWAB7GtFnG9GfWAB5wCDRD8cl0Q9sEAQV0HSlJShSgCn6/wk5AwmIAQhIAviwBhWgAgUA +wKFbo2WxImkp9fiwCBWgAgUAwKFbo2GxImkp9dEPAAAAbBAEKyIEGtGLWpcaFNFC80BoHeDWBQD2 +g0YVoAIFAMChW6NVIiwBaSn0+INIFaACBQDAoVujULEiaSn1wKFbo04a0Uv6AIId4AxFAFv/3Ckq +0fiDRhXgAgUAwKFbo0YiLAFpKfT6g0gVoAIFAMChW6NCsSJpKfXyAAIdoFUFAMChW6M9IiwBdSn0 +KwrX+oNGFeACBQDAoVujOCIsAWkp9PyDSBWgAgUAwKFbozOxImkp9cAgwKFbozAiLAFpJfQtCtX8 +g0YV4AIFAMChW6MqIiwBaSn0/oNIFaACBQDAoVujJrEiaSn1wKFboyP2g0YVoAIFAMChW6MgsSJp +KfX+g0gV4AIFAMChW6MbsSJpKfXAoVujGSIK0fKDRhWgAgUAwKFboxWxImkp9fiDSBWgAgUAwKFb +oxCxImkp9fQMgh3gAgUAwKFbowyxInUp9RrRA/oYQh3gjCUAW/+ZZDAMIgoAwKFbowSxInMp9fOe +iAXgAgUA8AA4DaA1JQDAqlui/rEidSERiUZ/l/B8l+0pMhJ+l+fAINEPxyXRD2wQBBTP/QQkCPKQ +BhXgAgUAwKFbovKxImkp9fiQCBWgAgUAwKFbou2xImkp9dEPAGwQBhPQUBTPK+My/yHj6wAALMJY +Hc+0/ECmFaIzHQDyQIYV5MwBAA3MCozAnCYa0Q8Z0Q/4mSgVoAuVACskB4mQ+CAGFeKICQAoJAMB +iAgogAD4QMYdoAs1AFv/3cChW6LT+6IIBaAbBQBb/9nq0P4Z2ASAAFqWjBvPRws7LOrQ/hXYCQAA +W//S9aH4BeACBQDAoVuixrEidSn1LAoB/JAGFaACBQDAoVuiwCIsAWkp9PyQCBXgAgUAwKFboryx +Imkp9fQMgh3gAgUAwKFborciLAF1KfQiCgAiRoDAoVuis7EiaSn1/pAIFaACBQDAoVuiriIsAWkp +9PWhwgXgAgUAwKFboqqxInUp9fuhvAWhCwUA/CACHaPthQD+ACIdoA8FAFqPoPFRaA3gAgUAJTro +wKFbop6xInUp9S8KAv6YBhXgAgUAwKFbopgiLAFpKfT4mAgVoAIFAMChW6KUsSJpKfUiCgDAoVui +kCIsAWkl9CkKA/iYBhXgAgUAwKFboouxImkp9fqYCBWgAgUAwKFbooYiLAFpKfQiCgDAoVuig7Ei +aSn1GtC4/AACHaErRQBbooke0GXH/w8CAIniD5kDCQlJmeKI4w+IAwgISSjmAy3iBBrQrg/dA/0g +AAbxO2UA/cCGFeAMlQBbonsDEhT6QGgdo+uFAFqWK3+nAbGq+6FIBa+6AQBb/3Hr0JMZUASAAFqW +JX+nAbGq+6E8Ba+6AQBb/2v7oTgFoMuFAFv/aPuhNAWh+0UAW/9lwCDRD8cl0Q8AAAAAbBAGG876 +5s/VGWgEgADwSeAN4EwFAPRABLCQVE0AHdCOKtKBKNJ+LtJ/A6IMAlIBfiN06bB9JAOJgAAi1oEM +mQLptH0pUASAABzO7C/SgJMR9CBGFaALBQD6IAYVoA0lAPIgZhWgClUAW6twzyMqYsUoYsKkou9i +xCET/QAA8qAEATANBQDjKwgNKASAAOvzbntQBIAAZIBm2mDwAOgNoA0FANEPAAAA//50DaACBQAN +2goGqgolosUuosL0oABEMCRNAO+ixCRD/QAACCIBoyl58yvK6GjSLqI1JabFHM66LqLDlRCTEfQg +RhWgCwUA8iBmFaAKVQBbq0zRDwAAAP//aA2gAgUAL7B9DP8CL7R9/1iIFe//EgAAAABsEATy4AAB +MAPVAPJDpg3gBOUAdCEV/EJAB1CIFQD4QUYNoIl1AHkhAtEPABvOqSqwfcDIDKoCKrR90Q9sEAZb +p/USzrv3n8AFoAkFAP9AaB2gAxUA+kyGHaAIhQBtihIAkAQOChvvpwd02AUAACtmf7GZ9Z6sBaAM +BQD1nsYF4AfVAPHABB/QC7UALCRpKlKcLVKdKVKhIyRt+LRIFaz6HQD+luQd7dmRAPxMph3jqmEA +9UAbM5c5kQD3QBr0YgCdAA8IR3eBGMCe6YETfGgEgABojgsoCoF40QUpCod52QotQBHAiAjdAi1E +EXuhBQ8JQ2maFipAEcHQDaoC+oImHaAALgAAAAAAANPA8cAEf5ANJQAtJG0jJGovUqQqUqX4tSgV +qAA9AA/PGPi1SBXrAD0ACMgYDwIA/pcEHe+YAQD4TMYd54gBAPhgAEGzrwEA9UAWu5IAnQD3QBZ8 +YgCdAA8IR3eBGSkKDumBE3xoBIAAaI4LKAqBeNEFKQqHedkKLUARwIgI3QItRBH7QBVkYgCdAA8J +Q/UgFQ0SAJ0A/8/AB1APRQD8tYgV4A41AC4kbSpSrSlSsS5SsvJNZh3qAD0A/UsADX0APQD5ywAP +f4oBAPiXJB2vjgEA+EzmHafuAQD+YABBs9oBAPWgEuuSAJ0A96ASrGIAnQAKCk9b/4AqQbn6YAAF +MAu1APtAEmRgDAUA9UASJRIAnQAuIGTA9HzndC8kbS1StCpStSlSuShSuvJNhh3sAD0A/UsADX8A +PQD5CwAMf+oBAP6XRB2vmAEA+E0GHeeIAQD4YABBs9oBAPWgECuSAJ0A96AP7GIAnQAKCk9b/2Iq +QbrTD/pgAAUwC7UA+0APlGAMBQD1QA9VEgCdAC4gZHvnSi1SvCpSvQHEBA2qGAoOT/6XZB2j2gEA +9aAOq5IAnQD3oA5sYgCdAAoKT1v/TipBu/pgAAUwC7UA+0AOJGAMBQD1QA3lEgCdAC4gZHrnTCpS +wgAUBArKGPy4aBXv6gEA/peEHaPaAQD1oA0rkgCdAPegDOxiAJ0ACgpPW/86KkG8+mAABTALtQD7 +QAykYAwFAPVADGUSAJ0ALiBkeedRKlLHAGQECsoY/LkIFe/qAQD+l6Qdo9oBAPWgC6uSAJ0A96AL +bGIAnQAKCk9b/yYqQb3TDw8CAPpgAAUwC7UA+0AK/GAMBQD1QAq9EgCdAC4gZP/I4AYVgD0AKlLM +LVLN0w8Kyhj6YAAGP9oBAO1FviY9hQAAd8FZCgpPW/8SKkG++mAABTAOtQB+oQJpqgorQBHBwAy7 +AitEES4gZBzPWi1ifyNmgCsgZZsQKiBmmhEpIGfpFgIp+ASAAPhNEBWgCwUA+CBmFaAKRQBbqkLR +DwAALEARwNINzAL8giYdr/5qAChAEcCSCYgC+IImHa/yagAtQBHAggjdAvyCJh3v9KYAKUARwaAK +mQL4giYd7/VeAC1AEcDiDt0C/IImHe/2jgAvQBHBgAj/Av6CJh3v9tIAKUARwNINmQL4giYd7/fu +AC5AEcHwD+4C/oImHa/4OgAoQBHAkgmIAviCJh2v+K4AKkARwdANqgL6giYdr/jyAC5AEcDyD+4C +/oImHa/5bgAoQBHBkAmIAviCJh2v+bIALUARwOIO3QL8giYd7/ouAC9AEcGACP8C/oImHe/6hgBs +EAoZzn7AMOccASigBIAA6pCAILAJAAD1mxAF4AIFAAAwBAoIG3+HUvpgaB2gCwUAW6YrmhjrRAAL +4ASAAPzAaB3gDgUAW6YVK0AAihgtQAEsQQEFqgvo3RAN2QKAAO27Ag5NAoAACSkCC5kCKabAGc5j +LMwBDCIIKpCAtETmbAQhmAUAAOk4lmO4EQAA+5xGBe/8NQD/RiAH0A0FACiyn/+d2gXniKEA6rKg +JHP9AADuihEPd4KAAAiuOCjykCqQgAyIAQjuAi72kH6nMiiypwGEBAjYGP+b2gXniAEA6rKoJHP9 +AADuihEPd4KAAAiuOCjykCqQgAyIAQjuAi72kH2nMCqyryiysAHEBAqIGAgIR+/O0hRz/QAA7ooR +D3eCgAAIrjgo8pAqkIAMiAEI7gIu9pB8pywosrj/nZIF54gBAOqyuSRz/QAA7ooRD3eCgAAIrjgo +8pAqkIAMiAEI7gIu9pB7pzQossAARATTDwjYGP+deAXniAEA6rLBJHP9AADuihEPd4KAAAiuOCjy +kCqQgAyIAQjuAi72kHqnNCiyxQCUBNMPCNgY/51eBeeIAQDqssYkc/0AAO6KEQ93goAACK44KPKQ +KpCADIgBCO4CLvaQeac0KLLKAOQE0w8I2Bj/nUQF54gBAOqyyyRz/QAA7ooRD3eCgAAIrjgo8pAq +kIAMiAEI7gIu9pB4pzEoss8BNATTDwjYGPudKgWniAEA7rLQJEv9AADujxEMz4KAAAj5OC6ikAzu +AQ6ZAimmkBbNivYgaB3gCQUA+CEmFeAEBQAqYOXxRJAN4AMVAOoSCSnYBIAAW6WdL3AAKHABLHEB +Ba4L6IgQD/kCgADo/wIObQKAAA0tAg/dAi3mwCtg5bHM7CIIAiAFAADrQ79xmAUAAIkZ53wEIzAF +AAD5ICAV4AQFAOkWCSymaAAA0Q8AAABsEAQYzMcSzmoXzF4ogH0TzZP0ACId4AQFAPMACf/f9vUA +JCYfJCYe9FAGHaAZhQAqMZT9nMAFpKoZAHmrLQysCozACsAAAAAAAC5yhABBBABdGgDdEQbfAw/u +AQ7dAvzwhhXgACYA2kBbpaPjPAIiIAUAAPyXAIXQGYUA85rwBaADBQD2AoIdoCV1APAAvA2gFAUA +AAo6RGiiUGiqeXahAmmhCvpgaB2gCxUAW6Vk4zwBIiP9AADkQIZhEAkAACohlHWpzxjMliiCWBnM +yAjoUQGIEQmIAilylhzONwyZAQmIAvjyxhWv/yIAANowW6V7Za+6LyGUHc4u/bAQFaL/AQD74AQA +0A4VAADuGg7MAv2wBh2v/m4A2jBbpXBlr44qIZQbziYKCkKrqyuwgAsLRFulTx3OH8DP/bAGHa/9 +ygBbpnESzhtbpmcqJh4rJh8ucof+8OYVoAIFANEPwCDRDwAAAGwQBhbM8w8CACZhwhjM8OPMnBs1 +woAACGYI+5wgBaALFQD8ACIdoA2lAPhAAh2gDgUA+GdGFaAPBQBajLwZzF8okH7izgcbIASAAPec +DAXgCxUA+2kADDAFBQDolH4tFAoAAJYQi0KKQSs2O4lAKjY8KTY9Gs36+gAiHeAMFQD+uAATMA2l +APbGAAxwDgUA+GdGFaAPBQBajKVmokL7m94FoAsVAPwBQh3gDgUA8sYADjAPBQD8Z0YVoAwVAFqM +m+aiHGKoBQAA6V6ZYiAxAACNEPebygXgBQUA4s3kFugbAADtFgAtD9IAAA3UAotCikErNjuJQCo2 +PCk2PRrN2PoAIh3gDBUA/rgAEzANpQDyxgAMMA4FAPhnRhWgDwUAWoyDZqG6+5uaBaALFQD8AUId +4A4FAPbGAA5wDwUA/GdGFaAMFQBajHnmoZRiqAUAAOlemWIgMQAAjRDAUObLvRboGwAA7RYALQvC +AADU0I1EjEMtNjsrQgIsNjwqQgErNj0pQgAqNj4pNj8azbT6ACId4AwVAP64ABQwDaUA9wYADDAO +BQD4Z0YVoA8FAFqMX+ahKGKoBQAA5EwUKvbIAACEEPeYyAWgBQUALU0KjdQsTQqMwy02OytNCouy +LDY8Kk0KiqErNj0pTQqJkCo2Pik2PxrNmvoAIh3gDBUA/rgAFDANpQD3BgAMMA4FAPhnRhWgDwUA +WoxF5qDIYqgFAADkTBQq5pgAAIQQ95hUBaAFBQAtTQwt0iQsTQwswiMtNjsrTQwrsiIsNjwqTQwq +oiErNj0pTQwpkiAqNj4pNj8azX/6ACId4AwVAP64ABQwDaUA9wYADDAOBQD4Z0YVoA8FAFqMKuag +oW0QBIAAsVXkTBQq5nwAAB7LyS7gfRrL+X/nRCyi4BvNcxrNcfx8AAcz3CEA/aAgFePMQQDu7AEm +YAUAAOTuEA5mAoAA7swCDu8CgAANzAJbpPvRD9Kg0Q/SoNEP0qDRDyyi4BvNYxrNYPxwAAez7CEA +/GgABrPMAQDt3AIncAkAAOzuEQf4CQAA4P8RDu4CgADv3QIGYAkAAA7MAg3MAluk59EPbBAEFM1T +E8xA9ZqkBeAIFQD4kAYVoAIFANogW6TqCglBaZEj6ikRBXCCgAADAIelmQkCYQkCYQkCYQkCYfpA +aB2gCwUAW6TbsSJpKMsqQoAbzUILqgL6kAYVoAIFANEPbBAEW/zmGsuf0w8pooUczTv9IAQEsCsF +AAuZAimmhSmilxjLsRvMDx7LnSiAgPsmAAz//fUA+VLmFe/61QD9AwARUAmFABjNF22aDSmCkAqZ +AemGkCRAEwAALeYgLeYhLeYiLeYjLeYkLeYlLeYm/cTmFeACBQDRDwAAAGwQBtogW4MUlBAczEj8 +QGgd4AuFAO80AA0wBIAA/sBoHaAKVQBbp/PAcBXLx6VlI1aBJFaCJ1aDB+QWAQIA2mD4sGgVoQsl +AFojvyNSiNMPDwIAyDn6wGgdoQslAFojuu0kAAnwBIAAB+QW/ZhiBaAKVQD+sQgV4AuFAFun3sAg +0Q8AAGwQBBPM//+V7gXgDhUA/APCHeAJRQD6YGgdoBgVAG2KCiugBXsgAn+3NbyqGsz2/fAQFaAL +BQAPAgD/UAYdoAIFAG2aGCigiOjTEHVQBQAAALEEAOkaCcwCLPSAsbvRD46gHMzp/cAQFeALhQD/ +wDAVoAolAFunvtkw/gIiHeD65QBt+g0okAUKiAHolAUkyDEAAMcr0Q8AbBAEGsvz6ioIAUgRAAD7 +UAgV4fj1AOmDB3ngBIAAKqKBW6miC0IB0Q8AAABsEAYoIAD6QGgdoIklAOmBCHEQEwAAxy7RDyas +FvLAB7qiAJ0AFMzJE8zIkxHzmZAF4IUFAPogBhWgAbIAvDN0MVUoMAUFiAHpMAQsd8QAAHeZ6dpg ++mAIFeAMJQBbpFv8AAIdr+ulAArLOGa/zo0RLDEDiDLacO3MCANYDQAAC4AA8UqoDeAPFQAuMAXT +Dw/uAi40BSdgAuPMrhPADQAAqGZya3LbMPrAaB2gDCUAW6RH48yiFQBpgAD2wFAV7/4SAACJELRq +eptdCWkMtJn/IgAH0AoFAIsQ6rAAJdgFAACbEAkbFMq4iBAtgADsgAEly/0AAOrdCARACQAAbZkO +KYAArcrsgAEkQAkAAKqdDcoIHsyQKuR9KgqAW/+I0qDRDwAAAAAAAP//mA2gCgUAjjAczIn9wBAV +4AolAP/AMBWgC4UAW6dZY/9JAGwQBBnMgyqSfymSgAmrEauZ+yAGFaAYpQAolARbowPAoFui/BvK +7CqygxzMegyqAiq2g1ui3cAg0Q8AAGwQBBjMdhnMdhrMdvIAAh2gC2UACwg/Agk/AgY/Agc/Ago/ +CgQ/CQU/+Q/oFaCKBQAIAD/TD1uCOB3MawoBP/Ovxh2gDoUA/6+GHaAMFQAs1H1bow5bourRDwAA +bBAGGcsq0w8iklnA2PuUwAXgDgUA8FVADe//9QD3wGgdoAgFAPYAAh3gBAUA/AAiHaAKxQBtCEkj +kp4lkqajYwkyEaJVk1ArVS4vVHaYX5dcJlQiLFQgLFQhLlQNJlQMLVQFIlESJFUTKlQEokSCW4Ve +I5JZonfliAgDMAUAAHNrAmP/ryqSWmSgnBXMQYwQ9f/iHaAKBQDwARQNoAYFAAAAwMEk1Aws1A0m +1CIv1HaY35fc86FoFe+CBQAi1CAi1CGC3qN3I5Ja4ogIBVP9AADr1S4jMAUAAONrS3ZgBQAAI5Kf +LZKmo2MJMhHzoABGsALVACLUBPOgBhXgA4UA49QFLX0OAAAqUH4kTAHlr5FiqAUAAG0IDCpQfrFE +5a+BYqgFAABj/+woklvLivWUIAXgBgUA+ADiHaAH5QBtCCUskqArkqasbAnNEa27nLAutA0otAwn +tAQqklvltS8jMAUAAHprAmP/08Ag0Q/Y4P/8SA2gBwUAAGwQBvuWuAXgChUA/Za2BaANBQD/mAQF +4A4VAFuizhrKvRPJ6xvLVBnKEywyZi0yZS4yZCk2pSk2pyk2qSk2qy8yYys2pCs2pio2oyo2qCgy +Yig2sioyaCsyZ6j/KTJsKDJpLzazr+4uNrSu3S8yay02ta3MLjJqLDa2rLstMnQrNrerqiwydSo2 +u6qZKzJ2KTa4qYgqMnooNrqo/ykyey82ua/uKDJ8Lja8rt0vMn0tNr2tzC4yfiw2vqy7LTKAKza/ +q6osMoEqNsCqmSsyhCk2wamIKDbCGsosqP8vNsMqNqIZyo6v7i42xPh1RhXgCAUAKDaxrt0tNsWt +zCw2xqy7KzbHW6KPKzKrKTKoLzKq82/gFa+IBQDoIgENbkKAAKLaevM+y5vqNqstWASAABzJ7y4y +qfIgZhWgClUA+iAGFeCIBQD8ICYV4AsFAPggRhWgDRUAW6Z+4jbIIQCBgADAINEP//8cDaACBQDH +JNEPAAAAAGwQBBXLmxrJfvIAAh3gAhUAI6aBI6aDI6aAI6aCKFB1HMna+AICHeDfVQDppookfMaA +AB3Kri3Sfx7KRg/dKB/KRw7dLCjCwA+IAQjYAijGwC7C4A/uAQ7dAi3G4CzC4BvK6f2XJAWgCgUA +W/5fwKH9lJgFoAsFAFv+W1v+PO/J9B0NmgAAwIgp8o/TDwkJQylUdC7yihvKxvnGAA8wiYUA//FG +FaAIBQBtmg0LiQsjlkDjlkEkQAUAAAM6Alv+E2ahcVv9R+TLeh0LWgAAF8lT8gACHeDGhQDaMFui +yOtQdS0KmgAAf78FInbALHLALUKh8a1ADeAKBQADOgJboqhnoMZgAS4AGsqeL1B185P2BeAORQBt +6gwroICxqv1gBf0iAJ0AwJDx4AXv0gCdABjLYSg2wCg2wFv80BnKbGag8ymSfyoKZNMPCpkswKMK +mSz5kk4FoOoFAP3+Ah2vC/UA+HeGFeAN5QDzlSQF4AlFAG2aHCmCggyZAQ2ZAimGgimCgguZAQqZ +AumGgiRAgwAAKjCAwCAAIAQKCxt/txj6QGgdoAsFAFuiPPxAaB2gC/UAW51lKjCAsSJpKNgcyaQq +xpxb+/3AINEPsTPmRAgB+EmAAPFF2A3g/PUAY/8nAP/9DA2nmx0AHcpBHsszLdJ/Dt0sLdz+DR0U +6lCILu7CgAD9JgAO8A6FAA7dAu02wCUkMQAA+V/4+dIAnQAuMsDG8v/ABAdwD1UAD+4C/ngGFa/8 +HgDSoNEPAAAAbBAGGMlXF8seH8seIoB9E8oiJIIv8kAPX9IAnQAWyXwtMtsERQouMtwrMtssMtwp +MtwqMt3+e4gVrQA9AOoy3SqvwoAA+nvoFaOZIQD3IACEuN2RAPkoBBXgDAUA8nwIFaS72QDqyBgH +NCyAAAlZLGAAFQAG3gkPsgkiIX4u4VACUiwOIigJKSz+e0gVoYgBAOoy2ywCCoAA/HtIFeGpnQAq +dn7ye2gVqAA9AA7OGPJ7SBWsgD0ADc0YKDLbKzLb+HuIFe8APQACiBj4e+gV44gBAPcAAIQ47gEA ++QgEFagAPQD7iwAN9N0BAOIy4CX8KIAACFUsYAAUBusJD9IJIiF+K7FQAlUsC1UoCFUs8nvoFa4A +PQAJyBj6fAgV4A0VAP57iBWhiAEA6DLdLAIKgAD1laoF4ZWdAPjv5hXvAD0A84sACToAPQD/iwAP +MCIBAALSOS0y3AJFOQVVCisy3SQy3fh7yBWugD0A/WsADfjuAQD9kfYF4AIFAPh7qBWkuwEA+iAG +FeEAPQDkxBgKr8KAAPp7yBXqAD0A+YsADDNEAQD2gACCM+yFAORBQCR8dIAADJssBF4sK9YgDKws +7NYhL3eCgAAudoDRD4IQBusJK7FQDyIJ8k/EFaPohQAIkywj1iACUiwLIigIqCwEIizo1iEpF4KA +APLwBhWgAgUA0Q8AJHZ+JHZ/E8qg8vAGFePphQAJSSwphiH5BAYV4AIFANEPAAAAbBCGGMmbGcqY +LYKAjpKPkZ8RnhIogoGJkPggBhXj3UEA9aAF0dIAnQAB0goiIgDwSpgN5AgFAOKKT3DQQQAAG8qL +LLKAGMqKK7KBDAyOLKYA+x8ADfB59QBtmhrpgoAkQCEAAOumASVQIQAAK4J/CQmOmaALC47rpgEg +0EEAAFv9k+egTm0QBIAAG8p6LLKAGMp6K7KB7AwWANBBAAAspgD7HwAN8Hn1AG2aGumCgCRAIQAA +66YBJVAhAAArgn8JCY6ZoAsLjuumASDQQQAAW/1/0qDHznwhFtEPANEPAMCi/ZTMBaALhQBbpSPH +K9EPwKL9lMYFoAuFAFulH9EPAGwQBBjKYBbJrimCgSlmpfkQSBWgCUUAKWaCKWaBKWaAKWaQKWaJ ++NGGFeADhQDyzoYV4AcFACdmnihmpveQ/gXgCBUAKGaOEsh6GshNI3B9IiKB/ZCWBeQOBQDyAAAG +dAsFAOy6OQE8JoAAKmV+0Q8IPwL+76Yd4P8BAA/tOS1lftEPAGwQBBzKQhjKPx7IJP2UfgXgCkUA ++xBGHaALBQArhUAthh7/A+YVoI8FAFuk8sAg0Q8AAABsEAQbyjYayjYYyjbAwOq2fyVRAwAA+w/m +FaCLhQBboGHRDwBsEAYayjDrrOwhDWkAAGgidokQ5JCBZJAFAAD8SGBBUAQVAGAADgAAAAAAaWQD +paiXgHJLLOo0AApYBIAAW6Qe6GEUYiAFAADlqQgLF3wAAPcgBB3v/3oApav3YAYd7/9SANEPK6J7 +KaKDo7sJuxHrmQgDDeUAAGhieGlk5KWcl8DRDwAAAAAA6EA3YhAFAAByQ6Fj/8sAACyygIQRKaKD +o8zpzBECIAUAAOyZCAMMgQAAaGIiaGQp8p/7y6IAnQBj/54ZyQGpOSmQfWP/RKWa90AGHe//kgCl +m/dgBB3v/2oApZz3gAYV7/9CAKWdJ9QA0Q+lniflANEPAAAAAAAAIAKNXAzAAAIgBe0cIAKNYAjA +AAggBe0cIAKNZCDAAAwgBeykIAKNaAbAADQgBe54IAKNbAjAADggBe0cIAKNcALAADwgBe54IAKN +dAjAAEAgBe0cIAKNeAiAAEQgBe2kIAKNfBiAAFggBe2kIAKNgBiAAGggBe2kIAKNhBiAAHggBe2k +IAKNiBiAAIggBe2kIAKNjBiAANggBe2kIAKNkBiAAOQgBe2kIAKNlBiAAPAgBe2kIAKNmBiAAPwg +Be2kIAKNnAiAATggBe2kcFsldV0gY2hhbmdpbmcgc3BlZWQgZnJvbSAlI3ggdG8gJSN4CgAAAAAA +AAAAAAAAcFsldV0gYmNtODQ4MzQgbGluayBzdGF0dXMgY2hhbmdlIFVQCgAAAAAAAAAAAAAAcFsl +dV0gYmNtODQ4MzQgbGluayBzdGF0dXMgY2hhbmdlIERPV04KAAAAAAAAAAAAaHdfY2w0NV91cGRf +c3BkX2FkdiAlI3gKAAAAAAAAAABwWyV1XSBjaGFuZ2luZyBzcGVlZCBmcm9tICUjeCB0byAlI3gK +AAAAAAAAAAAAAABwWyV1XSBjYWxpYnJhdGluZyBQSFkgU0VSREVTIGZvciBuZXcgc3BlZWQKAAAA +AABwWyV1XSBhcTEyMDIgbGluayBzdGF0dXMgY2hhbmdlIFVQCgAAAAAAAAAAAAAAAABwWyV1XSBQ +SFkgT1ZFUkhFQVRFRCAtIGZvcmNlZCBwb3dlciBkb3duICh0ZW1wPSVkKQoAAAAAAAAAAAAAAAAA +cFsldV0gYXExMjAyIGxpbmsgc3RhdHVzIGNoYW5nZSBET1dOCgAAAAAAAAAAAAAAaW5vZGVfZmMt +PmZsb3djX2ZsYWdzIFsweCV4XSwgaW5vZGVfZmMtPmZsb3djX2J1Zi0+Zmlmby5udW1fYnl0ZXMg +WyV1XQoAAAAAAAAAAABhdXRoZW50aWNhdGVfdGFyZ2V0OiBLRVlfQ0hBUF9SRVNQIC0gWzB4JXgl +eCV4JXgleCV4JXgleF0KAAAAAAAAYXV0aGVudGljYXRlX3RhcmdldDogS0VZX0NIQVBfUkVTUCAt +IFsweCV4JXgleCV4JXgleCV4JXhdCgAAAAAAAGF1dGhlbnRpY2F0ZV90YXJnZXQ6IEluY29ycmVj +dCBwYXNzd29yZAoAAAAAAAAAAHZhbGlkYXRlX2tleXZhbDogS2V5IENIQVBfQSwgdmFsIFslZF0K +AAAAAAAAAAAAAHZhbGlkYXRlX2tleXZhbDogS2V5IENIQVBfSSwgdmFsIFslZF0KAAAAAAAAAAAA +AENIQVBfQzogZGlnZXN0IGV4cGFuc2lvbiBlcnJvcgoAdmFsaWRhdGVfa2V5dmFsOiBLRVlfQ0hB +UF9OQU1FLCBsZW4gWzB4JXhdCgAAAAAAQ0hBUF9OOiBUYXJnZXQgdXNlcmlkIG1pc21hdGNoCgBD +SEFQX1I6IGRpZ2VzdCBleHBhbnNpb24gZXJyb3IKAFJlY2lldmVkIEF1dGhNZXRob2QgdmFsdWUK +AAAAAAAAdmFsaWRhdGVfa2V5dmFsOiBmbG93Y19mb2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhdCgAA +AAAAAAAAAAAAAAAAAHZhbGlkYXRlX2tleXZhbDogZmxvd2NfZm9pc2NzaV9jb25uX2ZsYWdzIFsw +eCV4XQoAAAAAAAAAAAAAAAAAAABOZWdvIEZCTCBbJXVdCgAAS0VZX01BWFJDVkRTTCBbJXVdCgAA +AAAAAAAAAAAAAABEdXBsaWNhdGUgaXNjc2kga2V5CgAAAAAAAAAAAAAAAGZvaXNjc2lfcGFyc2Vf +cmN2ZF9wYXJhbXM6IGVycm9yCgAAAAAAAAAAAAAAAAAAAGZvaXNjc2lfcGFyc2VfcmN2ZF9wYXJh +bXM6IHJsZW4gJWQKAAAAAAAAAAAAAAAAAGFzeW5jX3BkdTogbG9nb3V0IHJlcXVlc3RlZCBibG9j +a2luZyBzZXNzaW9uCgAAAGFzeW5jX3BkdTogc2Vzcy9jb25uIGRyb3AgcmVxdWVzdGVkIGJsb2Nr +aW5nIHNlc3Npb24KAAAAAAAAAAAAAABsb2dpbl9yZXNwOiBmbG93Y19mb2lzY3NpX2Nvbm5fZmxh +Z3MgWzB4JXhdCgAAAABsb2dpbl9yZXNwOiBmbG93Y19mb2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhd +LCByYyBbMHgleF0KAAAAAAAAAAAAaVNDU0kgU2VjLXBhcmFtcyByZWNlaXZlZGhhdmUgZXJyb3Jz +ISEKAAAAAAAAAAAAVGFyZ2V0IG1vdmVkIHRlbXAuIGNvbm4gJXgsIHNlc3MgJXgKAAAAAAAAAAAA +AAAATG9naW4gRmFpbGVkISEuIGNvbm5fZmMgWzB4JXhdLCBzZXNzX2ZjIFsweCV4XSwgc3RhdHVz +X2NsYXNzIFsweCV4XQoAAAAAAAAAAAAAAABsb2dpbl9yZXNwOiBzZXNzX2ZjLT5mbG93Y19pZCBb +JXVdLCBjb25uX2ZjLT5mbG93Y19pZCBbJXVdIGxvZ2dlZCBpbgoAAAAAAAAAAAAAAFByb3RvY29s +IEVycm9yIGNiaXQgJWQgdGJpdCAlZCBjc2cgJWQgbnNnICVkCgAAAGNvbm4gdGlkIFsweCV4XSwg +cnhfZGF0YS0+c2VxIFsweCV4XSwgcnhfZGF0YS0+bGVuIFsweCV4XSwgcnhfZGF0YS0+c3RhdHVz +IFsweCV4XQoAAAAAAAAAAAAAAAAAAGNza19mYy0+Zmxvd2NfY3NvY2tfb2Zmc2V0IFsweCV4XSwg +ZGxlbjE2IFsweCV4XQoAAAAAAAAAAAAAAAAAAABhY3RfZXN0OiBmbG93Y19mb2lzY3NpX2Nvbm5f +ZmxhZ3MgWzB4JXhdCgAAAAAAAABhY3RfZXN0YWI6IHRjYl9mYy0+Zmxvd2NfYnVmIFsweCV4XSwg +dGNiX2ZjLT5mbG93Y190eXBlIFsweCV4XSB0Y2JfZmMtPmZsb3djX3N0YXRlIFsweCV4XSwgbnBh +Z2VzIFsweCV4XSwgZmxvd2NfdHBfc25kX21heCBbMHgleF0KAAAAAAAAAAAAAAAAAABhY3RfZXN0 +YWI6IGF0aWQgWzB4JXhdLCB0aWQgWzB4JXhdLCBvcCBbMHgleF0sIHJjdl9pc24gWzB4JXhdLCBz +bmRfaXNuIFsweCV4XSwgY3NvY2stPmZsb3djX3N0YXRlIFsweCV4XSwgdGNwX29wdCBbMHgleF0s +IHRjYl9mYy0+Zmxvd2NfaWQgWzB4JXhdIAoAAAAAAAAAAAAAAAAAY3NrX2ZjLT5mbG93Y19jc29j +a19jb29raWUgWzB4JXhdIAoAAAAAAAAAAAAAAAAAbDNpbjRfZGV2X2NvbmZpZzogd3ItPnBhcmFt +LnZsYW5pZCBbJXVdLCBsMmRldl9mYy0+Zmxvd2NfbmV0X2wyZGV2X3ZsYW5kZXYgWzB4JXhdCgAA +AAAAAAAAAAAAAAAAbmV0X2wzaW40X2Rldl9jb25maWc6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgl +eF0sIGFkZHJlc3MgYWxyZWFkeSB1c2VkIGJ5IHBvcnQgJWQKAAAAAAAAAAAAAAAAAAAAbmV0X2wz +aW40X2Rldl9jb25maWc6ICBhZGRyIFsweCV4XSwgbWFzayBbMHgleF0sIGd3IFsweCV4XSwgcmVm +X2NudCBbMHgleF0gaW4gdXNlCgAAAAAAAAAAAAAAAAAAd3JoX2NobmV0X2lmY29uZjogbDJkZXZf +ZmMtPmZsb3djX2lkIFsweCV4XSwgbDJkZXZfZmMtPmZsb3djX3R5cGUgWyUweF0sIGlmY29uZl93 +ci0+c3Vib3AgWzB4JXhdCgAAAAAAAAAAAAAAAAAAAHdyaF9jaG5ldF9pZmNvbmY6IGwyZGV2X2Zj +LT5mbG93Y19pZCBbMHgleF0sIHVua25vd24gc3Vib3AgWzB4JXhdCgAAAAAAAAAAAAAAAAAAd3Jo +X2NobmV0X2lmY29uZjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgcmMgJWQKAAAAAAAAAAAA +AAAAAG5ldGlmX2lwX2NvbmZsaWN0X3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhd +LCBpbmRldmN0eHQtPnN0YXRlIFslZF0sIGluZGV2Y3R4dC0+cmV0cnlfY250IFslZF0KAAAAAAAA +AABuZXRpZl9pcF9jb25mbGljdF90aW1lcl9jYjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwg +aW5kZXZjdHh0IFsweCV4XSwgaW4gZnJlZSBzdGF0ZQoAAAAAAAAAAABjbWRoX2NobmV0X2lmYWNl +OiBmYyBbMHgleF0sIGZjLT5mbG93Y19pZCBbMHgleF0sIGZjLT5mbG93Y190eXBlIFsweCV4XSwg +cCBbMHgleF0sIGxlbjE2IFsldV0sIGxvYyBbMHgleF0KAAAAAAAAY21kaF9jaG5ldF9pZmFjZTps +MmRldl9mYyBbMHgleF0sIGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIGwyZGV2LT5mbG93Y190 +eXBlIFsldV0sIGwyZGV2X2ZjLT5mbG93Y19uZXRfbDJkZXZfZmxhZ3MgWyUweF0KAAAAAABjbWRo +X2NobmV0X2lmYWNlOiBsMmRldl9mYy0+Zmxvd2NfbmV0X2wyZGV2X2ZsYWdzIGNoYW5nZWQgZnJv +bSBbJTB4XSB0byBbJTB4XSwgcmMgWyVkXQoAAAAAAAAAAABjaG5ldF9sMmRldl91cF9tYl9jYjog +cmMgWyVkXSwgcG9ydCBbJXVdLCBzdGF0ZSBbJXVdLCBjb29raWUgWzB4JXhdCgAAAAAAAAAAAAAA +AGNobmV0X3F1ZXVlX3htaXQ6IGZjLT5mbG93Y19pZCBbMHgleF0sIGJ1Zl9sZW4gWzB4JXhdLCBi +dWZmZXJlZCBbMHgleF0sIGZpZm8ubnVtX2J5dGVzIFslMHhdCgAAAGRoY3BfcHJvY2Vzc19jYjog +bDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgZGhjdHh0LT5zdGF0ZSBbJTB4XSwgZGhjdHh0LT5y +dHJ5X2NudCBbJXVdCgAAAAAAAAAAAGRoY3BfdGltZXJfY2I6IERIQ1BESVNDT1ZFUiBzZW50LCBi +dXQgbm8gcmVwbHkgZnJvbSBhbnkgcG9zc2libGUgc2VydmVyIG9uIHRoZSBuZXR3b3JrLiBSZXRy +eWluZyBhZ2FpbgoAAAAAAAAAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4 +JXhdLCBzZW5kaW5nIERIQ1BESVNDT1ZFUiBmb3IgZGhjdHh0IFsweCV4XSBvbiBwaWQgWyVkXQoA +AABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBESENQT0ZGRVIgcmVj +ZWl2ZWQgZm9yIGRoY3R4dCBbJXhdIHBpZCBbJWRdCgAAAAAAAAAAAABkaGNwX3RpbWVyX2NiOiBs +MmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCAgREhDUEFDSyByZWNlaXZlZCBmb3IgZGhjdHh0IFsl +eF0sIHBpZCBbJWRdCgAAAAAAAAAAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQg +WzB4JXhdLCBkaGN0eHQtPmlwYWRkciBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAGRoY3BfdGltZXJf +Y2I6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIG5vIHJlcGx5IGZyb20gZGhjcCBzZXJ2ZXIs +IHRpbWluZyBvdXQKAAAAAAAAAAAAAAAAAAAAAGxvZ2luX3BhcmFtczogY29ubl9mYy0+Zmxvd2Nf +Zm9pc2NzaV9jb25uX2ZsYWdzIFsweCV4XQoAAAAAAAAAAABsb2dpbl9wYXJhbXM6IGNvbm5fZmMt +PmZsb3djX2ZvaXNjc2lfY29ubl9mbGFncyBbMHgleF0KAAAAAAAAAAAAYXV0aF9uZWdvX3NlY3Vy +aXR5OiBzZW5kX2ZsYWcgWzB4JXhdLCBhdXRoX3BvbGljeSBbMHgleF0KAAAAAAAAAGF1dGhfbmVn +b19zZWN1cml0eTogS0VZX0NIQVBfUkVTUCAtIGhhc2hbMHgleCV4JXgleCV4JXgleCV4XQoAAABh +dXRoX25lZ29fc2VjdXJpdHk6IEtFWV9DSEFQX1JFU1AgLSBoYXNoWzB4JXgleCV4JXgleCV4JXgl +eF0KAAAAYXV0aF9uZWdvX3NlY3VyaXR5OiBLRVlfQ0hBUF9SRVNQIC0gZXJyb3IgZW5jb2Rpbmcg +dG8gaGV4CgAAAAAAAGF1dGhfbmVnb19zZWN1cml0eTogS0VZX0NIQVBfUkVTUCAtIGVsZW4gWzB4 +JXhdCgAAAAAAAAAAAAAAAAAAAABhdXRoX25lZ29fc2VjdXJpdHk6IEtFWV9DSEFQX0NIQUwgLSBl +cnJvciBlbmNvZGluZyB0byBoZXgKAAAAAAAAYXV0aF9uZWdvX3NlY3VyaXR5OiBLRVlfQ0hBUF9D +SEFMIC0gZWxlbiBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAHNlbmRfbG9naW5fcmVxdWVzdDpjb25u +X2ZjLT5mbG93Y19pZCBbMHgleF0sIHNlc3NfZmMtPmZsb3djX2lkIFsweCV4XSwgY3RybF94bWl0 +IFsweCV4XSwgc2Vzc19mYy0+Zmxvd2NfZm9pc2NzaV9zZXNzX3R5cGUgWzB4JXhdCgAAAAAAAAAA +AAAAAAAAAHNlbmRfbG9naW5fcmVxdWVzdDogZmxhZyBbMHgleF0uCgAAAAAAAAAAAAAAAAAAAHNl +bmRfbG9naW5fcmVxdWVzdDogdHhfbGVuIFsldV0KAAAAAAAAAAAAAAAAAAAAAHhtaXRfc2VuZHRh +cmdldHM6IGNvbm4gdGlkIFsweCV4XSwgY3RybF94bWl0LT50dHQgWzB4JXhdLCBkYXRhX2xlbiBb +JXVdLCBwYWRfbGVuIFsldV0KAAAAAAAAAAAAAHBpbmdfdGFyZ2V0OiBwaW5nIHRpbWVvdXQgYmxv +Y2tpbmcgc2Vzc2lvbgoAAAAAAHNlbmRfbm9wX291dDogY29ubiBmbG93X2lkIFsweCV4XSwgcmVx +IFsldV0sIHR0dCBbMHgleF0KAAAAAAAAAABjc29ja19mYWlsZWQ6IGNza19mYy0+Zmxvd2NfaWQg +WzB4JXhdLCBjc2tfZmMtPmZsb3djX3N0YXRlIFsweCV4XSwgc2Vzc19mYy0+Zmxvd2NfaWQgWzB4 +JXhdLCBzZXNzX2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0sIGV2dCBbMHgleF0KAAAAAAAAAAAAAABj +b3NrY19mYWlsZWQ6IHNlc3Npb24gYmxvY2ssIGV2ZW50IFsweCV4XQoAAAAAAABjb3NrY19mYWls +ZWQ6IHNlc3Npb24gYmxvY2ssIGV2ZW50IFsweCV4XQoAAAAAAABjaG5ldF9maW5kX2wydF9lbnRy +eTogZGFkZHIgWyUwOHhdLCBbMHglMDh4XSwgbG9jYWwgbmV0d29yayBbJWRdCgAAAAAAAAAAAAAA +AAAAAGwydGVudCBbJTB4XSwgbDJ0ZW50LT5pZHggWyVkXQoAcmMgWyVkXSwgY3NrX2ZjIFsweCV4 +XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAGNzb2NrX2ZyZWU6IHNp +emVvZihjc2tfZmMtPnUuY3NvY2spIFsldV0sIGJ5dGVzCgAAAAAAAAAAAAAAAAAAAABUQ1AgY29u +biBlc3RhYmxpc2htZW50IGZhaWxlZCAlZAoAAAAAAAAAAAAAAAAAAABJbnZhbGlkIG9wY29kZSAw +eCV4IGluIGN0cmwgcGF0aAoAAAAAAAAAAAAAAAAAAABERFAgZXJyb3IgWzB4JXhdLCBhYm9ydGlu +ZyBjb25ubiBbMHgleF0KAAAAAAAAAABzZW5kX2Fib3J0X3JlcTogY3NrX2ZjLT5mbG93Y190eXBl +IFsweCV4XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIHRpZCBbMHgleF0sIHVscHR4Y2ggWyV1 +XSwgYnVmZmVyZWQgWyV1XQoAAAAAaXNjc2lfaGRyOiBiYWQgdGNiIHN0YXRlIHRvIHJ4IGRhdGEs +IHRjYl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCB0Y2JfZmMtPmZsb3djX3N0YXRlIFsweCV4XQoAAAAA +AAAAZHJvcF9hbGxfdGFzazogcmVxdWVzdGVkIGxpZHggWyV1XQoAAAAAAAAAAAAAAAAAZ2V0X3Jl +Zl90YXNrOiBpc3Rhc2stPmZsb3djX2lkIFsweCV4XSwgaXN0YXNrX2ZjLT5mbG93Y19zdGF0ZSBb +JXVdLCBpc3Rhc2tfZmMtPmZsb3djX2ZvaXNjc2lfdGFza19saWR4IFsldV0sIGxpZHggWyV1XQoA +AAAAAAAAAABwcm9jZXNzX3RtZl9yZXNwb25zZTogaXN0YXNrX2ZjLT5mbG93Y19idWYtPnNjaGVk +X25vZGUubmV4dCBbMHgleF0sIGlzdGFza19mYyBbMHgleF0sIGlzdGFza19mYy0+Zmxvd2NfaWQg +WyV1XQoAcHJvY2Vzc190bWZfcmVzcG9uc2U6IHVscHR4cGxlbjE2IFsldV0KAAAAAAAAAAAAcHJv +Y2Vzc190bWZfcmVzcG9uc2U6IGRlbGF5X3Byb2Nlc3NpbmcsIG9wIFsleF0KAAAAAAAAAAAAAAAA +AAAAAHByb2Nlc3NfdG1mX3Jlc3BvbnNlOjogd3Igb3Bjb2RlIFsweCV4XQoAAAAAAAAAAHByb2Nl +c3NfdG1mX3Jlc3BvbnNlOjogdGFzayBmdW5jdGlvbiBbMHgleF0KAAAAAGNhbGxpbmcgZHJvcF90 +YXNrLCBpc3Rhc2tfZmMtPmZsb3djX2ZvaXNjc2lfdGFza19saWR4IDB4JXgKAAAAAAB3cmhfZm9p +c2NzaV9ub2RlOiBub2RlX3dyLT5mbG93aWRfbGVuMTYgMiBbJXhdCgB3cmhfZm9pc2NzaV9jaGFw +OiBpZF9sZW4gWyV4XSwgc2VjX2xlbiBbJXhdCgAAAAB3cmhfZm9pc2NzaV9jaGFwOiB0Z3RfaWRf +bGVuIFsleF0sIHRndF9zZWNfbGVuIFsleF0KAAAAAAAAAAAAAAAAcGVlcl9jb246IGNza19mYyA9 +PiBmbG93aWQgWzB4JXhdLCBmbG93Y19idWYgWzB4JXhdCgAAAAAAAAAAAAAAAGZvaXNjc2lfY3Ry +bDogc3Vib3AgWzB4JXhdLCBzZXNzX3R5cGVfdG9fZXJsIFsweCV4XSwgc2Vzc190eXBlIFsweCV4 +XQoAAAAAAAAAAAAAd2F0Y2hkb2cgY21kIGhhbmRsZXIgKHRpbWUgJXUgYWN0aW9uICV1KQoAAAAA +AAAAV0FUQ0hET0c6IGRldmljZSBzaHV0ZG93bgoAAAAAAABXQVRDSERPRzogYnlwYXNzIHRpbWVv +dXQKAAAAAAAAAFdBVENIRE9HOiBGTFIgLSBub3QgaW1wbGVtZW50ZWQgeWV0CgAAAAAAAAAAAAAA +AGZpbHRlcjogcG9yZ3JhbW1pbmcgdGlkICV1IChsZSB0Y2FtIGluZGV4ICV1KS4uLgoAAAAAAAAA +AAAAAAAAAABmaWx0ZXI6IHJlcXVlc3RpbmcgY29tcGxldGlvbi4uLgoAAAAAAAAAAAAAAAAAAABG +Q09FIEZyZWU6IHN0aWxsIHlpZWxkZWQgd2hlbiBmcmVlaW5nLi4uZmxvd2NfaWQgJXggZmxvd2Nf +ZmxhZ3MgJXggCgAAAAAAAAAAAAAAAHBvcnQgJWQgcHJpb3IgJWQgc2VsZWN0ICVkIHByb3RvY29s +SUQgMHglMDR4CgAAAHBvcnQgJWQgc2V0IHBmY19lbiA9IDB4JXgKAAAAAAAAcG9ydCAlZCBzZXQg +cGdpZF8wXzcgPSAweCUwOHggcGdfcGVyY2VudGFnZSAweCUwOHhfJTA4eCBudW1fdGNzX3N1cHBv +cnRlZCAlZAoAAABwb3J0ICVkIHNldCBwZmNfZW4gPSAweCV4CgAAAAAAAEZDb0UgRERQIGZhaWxl +ZCA6IG94X2lkIDB4JXggcnhfaWQgMHgleAoAAAAAAAAAAEZDb0UgRERQIGZhaWxlZCA6IERkcFJl +cG9ydCAweCV4IERkcFZhbGlkIDB4JXgKAFBSTEkgUnNwIHRpbWVkb3V0IDogZmxvd2NfaWQgMHgl +eCBveF9pZCAweCV4IHJ4X2lkIDB4JXggCgAAAAAAAABjYW5ub3QgYWxsb2NhdGUgb2ZmbG9hZGVk +IGZpbHRlciBjb25uZWN0aW9uCgAAAABjYW5ub3QgYWxsb2NhdGUgb2ZmbG9hZGVkIGZpbHRlciBJ +UHY2IGNvbm5lY3Rpb24KAAAAAAAAAAAAAAAAAAAAdW9bJXVdOiB3ciAlcCB3ci0+bGVuZ3RoICV1 +IG1zcyAldQoAAAAAAAAAAAAAAAAAdW9bJXVdOiBmIDB4JTA4eCBkc3RfY3BsIDB4JTA4eCBzcmNf +Y3BsIDB4JTA4eCBpbW1kbGVuMTYgJXUKAAAAAHVvWyV1XTogbGFzdCBtc3MgJXUKAAAAAAAAAAAA +AAAAdW9bJXVdOiAhbGFzdCB3ci0+c2NoZWRwa3RzaXplICV1CgAAAAAAAAAAAAAAAAAAaW52YWxp +ZCBidWZmZXIgZ3JvdXBbJXVdIGNvbmZpZ3VyYXRpb246IG10dSAldSBsd20gJXUgaHdtICV1IGR3 +bSAldQoAAAAAAAAAAAAAAABmYyAldSB2ZiAldSBnb3QgaXZmPTB4JXgscmFuZ2U6ICUjeC0lI3gg +KCV1LyV1IHVzZWQpCgAAAAAAAAAAAAAAVkkgJXUgY2Fubm90IGdldCBSU1Mgc2xpY2U6IE5vIG1v +cmUgc2xpY2VzIGF2YWlsYWJsZSAodXNlZCAldS8ldSkKAAAAAAAAAAAAAAAAAABwZm4gJXUgdmZu +ICV1IHdpdGggcG9ydCBtYXNrIDB4JXggY2Fubm90IGFjY2VzcyBwb3J0ICV1LCByZXQgJWQKAAAA +AAAAAAAAAAAAAAAAAHBmbiAldSB2Zm4gJXUgY291bGQgbm90IGFsbG9jYXRlIHZpaWQsIHJldCAl +ZAoAAHBmbiAldSB2Zm4gJXUgY291bGQgbWFwIHZpaWQgIDB4JXggdG8gZmxvd2MsIHJldCAlZAoA +AAAAAAAAAAAAAABwZm4gJXUgdmZuICV1IGNvdWxkIG5vdCBhbGxvY2F0ZSB1d2lyZSBmdW5jICVk +IG1hYyBhZGRyLCByZXQgJWQKAAAAAAAAAAAAAAAAAAAAAG1paV9mb3JjZV9zcGVlZFsldV06IHJj +YXBzIDB4JXgKAAAAAAAAAAAAAAAAAAAAAG1paV9saW5rX3N0YXR1c1sldV06IGJtc3IgMHglMDh4 +IHN0YXR1cyAldSB4Z21fbHMgMHglMDh4CgAAAAAAAABwb3J0X2NtZF9oYW5kbGVyOiB1bmtub3du +IHUuZGNiLnR5cGUgMHgleAoAAAAAAABwb3J0WyV1OjB4JTAyeDoweCUwMnhdOiBwaHkgcmVzZXQg +bm90IGF2YWlsYWJsZQoAAAAAAAAAAAAAAAAAAAAAcG9ydFsldToweCUwMng6MHglMDJ4XTogdW5r +bm93biBhY3Rpb24gMHgleAoAAAAAcG9ydFsldToweCUwMng6MHglMDJ4XTogdW5rbm93biByZWFk +IGFjdGlvbiAweCV4CgAAAAAAAAAAAAAAAAAAAGNwbF9lcnJfbm90aWZ5OiB0aWQgJXUgY3BsIDB4 +JTA4eCUwOHgKAAAAAAAAAAAAAGNwbF9lcnJfbm90aWZ5OiB0aWQgJXUgY3BsIDB4JTA4eCUwOHgg +MHglMDh4JTA4eAoAAAAAAAAAAAAAAAAAAABjcGxfZXJyX25vdGlmeTogdGlkICV1IGxlbiAldQoA +AEZDT0UgRnJlZTogc3RpbGwgeWllbGRlZCB3aGVuIGZyZWVpbmcuLi5mbG93Y19pZCAleCBmbG93 +Y19mbGFncyAleCAKAAAAAAAAAAAAAAAARkNPRSBCUCBXUiBFUlI6IFdSIHdpdGggY29va2llICV4 +JXggZXJyb3JlZCBiYWNrIAoAAAAAAAAAAAAAAAAAAHNjc2lfYWJvcnQ6IEVudGVyaW5nIEFib3J0 +X3Rhc2ssIGJ1ZmZlcmVkIFsldV0KAHNjc2lfYWJvcnQ6OiB3ci0+aXFpZCBbMHgleF0sIGlzdGFz +a19mYy0+Zmxvd2Nfc2dlX2lxaWQgWzB4JXhdCgBzY3NpX2Fib3J0OjogbHVuX2lkeCBbMHgleF0K +AAAAAHNjc2lfYWJvcnQ6IHJlZiB0YXNrIG5vdCBvdXRzdGFuZGluZwoAAAAAAAAAAAAAAHNjc2lf +YWJvcnQ6IHNyZXEtPm9wY29kZSBbMHgleF0gZmxhZ3MgWzB4JXhdCgAAAHNjc2lfYWJvcnQ6IHRh +c2tfaWR4IFsldV0sIGl0dCBbMHgleF0KAAAAAAAAAAAAAGFib3J0L2Nsb3NlIFdSIHdpdGggY29v +a2llIDB4JWx4IHdhcyBpc3N1ZWQgb24gc3NuIDB4JXggaW4gd3Jvbmcgc3RhdGUgMHgleAoAAAAA +YWJvcnQgV1Igb24gc3NuIDB4JXggZGlkIG5vdCBmaW5kIFdSIHdpdGggY29va2llIDB4JXgleAoA +AAAAAAAAAGNsb3NlIFdSIHdpdGggY29va2llIDB4JWx4IG9uIHNzbiAweCV4O2RpZCBub3QgZmlu +ZCBXUiB3aXRoIGNvb2tpZSAweCVseAoAAAAAAAAAYWJvcnQgV1Igb24gc3NuIDB4JXggd2FzIGlz +c3VlZCBvbiB4Y2hnIDB4JXggd2l0aCByeF9pZCAweCV4IGluIHdyb25nIHN0YXRlIDB4JXgKAAAA +AAAAAAAAAAAAAAAAcG9ydCAlZCBhcHBsSUQgMHglMDR4IG91aSAweCUwNnggdXNlcl9wcmlvciAl +ZAoAc2VuZCBkY2J4IGluZm86Zmxvd2NpZCAldQoAAAAAAABzZW5kIGRjYnggY29tcGxldGUKAAAA +AAAAAAAAAAAAAERDQlggcG9ydCAldSBhbGxfc3luY2QgPSAldQoAAAAAY2huZXRfbDJ0X3VwZGF0 +ZTogbDJkZXZfZmMgWzB4JXhdLCBsMmRldl9mYy0+Zmxvd2NfaWQgWyV1XSBsMmRldl9mYy0+Zmxv +d2NfZmxhZ3MgWzB4JXhdCgAAAAAAAAAAY2huZXRfbDJ0X3VwZGF0ZTogbDJkZXZfZmMtPmZsb3dj +X2lkIFsldV0gYWxyZWFkeSBzY2hlZHVsZWQKAAAAAGNobmV0X2wydF91cGRhdGU6IGluIGRlbGF5 +ZWRfcHJvY2Vzc2luZywgbDJ0ZW50IFslMDh4XQoAAAAAAAAAAABjaG5ldF9sMnRfdXBkYXRlOiBs +MnRfdXBkYXRlIHJlcXVlc3Qgc2VudCBsMnRlbnQgWyUwOHhdLCBsMnRlbnQtPmlkeCBbJWRdLCBs +MnRlbnQtPnZsYW4gWyVkXQoAAABuZXRpZl9wcm9jZXNzX2RoY3A6IGwyZGV2X2ZjLT5mbG93Y19p +ZCBbMHgleF0sIHByb2Nlc3NpbmcsIG9wdF9sZW4gJXUKAAAAAAAAAAAAAGNobmV0X2RoY3BfcmVj +djogdmxhbmlkIFsldV0sIGwyZGV2X3BpZF9mYy0+Zmxvd2NfbmV0X2wyZGV2X3ZsYW5kZXYgWzB4 +JXhdLCBsMmRldl9mYyBbMHgleF0KAAAAAGNobmV0X2RoY3BfcmVjdjogbDJkZXZfZmMtPmZsb3dj +X2lkIFsweCV4XSwgZGhjdHh0LT5zdGF0ZSBbJWRdLCBtYWxhY2lvdXMgZGhjcCByZWN2IGZvciBu +byByZXF1ZXN0CgAAAAAAAAAAAAAAAABkaGN0eHQtPnN0YXRlIDogJWQKAAAAAAAAAAAAAAAAAGwy +ZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIEJhZCBESENQIGNvb2tpZSByZWNpZXZlZCwgYWJvcnRp +bmcKAABOX1BPUlQgMHgleCV4JXggcmVqZWN0ZWQgUExPR0kgd2l0aCByZWFzb24gY29kZSAleAoA +AAAAAAAAAAAAAAAAQUJUUyB3aGlsZSBhd2FpdGluZyBQUkxJIFJzcDogZmxvd2NfaWQgMHgleCBv +eF9pZCAweCV4IHJ4X2lkIDB4JXggCgAAAAAAAAAAAAAAAABBQlRTIGZha2UgUnNwOiBsb2MgMHgl +eCBveF9pZCAweCV4IHJ4X2lkIDB4JXgKAABjYW5ub3QgYWxsb2NhdGUgUE9GQ09FIGZpbHRlciBj +b25uZWN0aW9uIGZvciB4X2lkICV4IAoAAAAAAAAAAAAAcmVsZWFzZV90aWQ6IHNpemVvZih0Y2Jf +ZmMtPmZsb3djX2ZvaXNjc2lfY29ubikgWyV1XSwgYnl0ZXMKAAAAAGFjdF9vcGVuX3JwbDogYXRp +ZCBbMHgleF0sIHRpZCBbMHgleF0sIG9wIFsweCV4XSwgc3RhdHVzIFsweCV4XQoAAAAAAAAAAAAA +AAAAAAAAYWN0X29wZW5fcnBsOiBjc2tfZmMtPnRjYl9zdGF0ZSBbMHgleF0sIGNza19mYy0+Zmxh +Z3MgWzB4JXhdLCB0Y2JfZmMtPmZsb3djX3N0YXRlIFsweCV4XQoAAAAAAAAAc2VuZF9hYm9ydF9y +cGw6IGNza19mYy0+Zmxvd2NfdHlwZSBbMHgleF0sIGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCB0 +aWQgWzB4JXhdLCB1bHB0eGNoIFsldV0sIGJ1ZmZlcmVkIFsldV0KAAAAAHdyaF9vZmxkX3RjcF9j +bG9zZV9jb25fcmVwbHk6IHRjYl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCB0Y2JfZmMtPmZsb3djX3R5 +cGUgWzB4JXhdLCBsZW4xNiBbJXVdLCBsb2MgWyV1XQoAAAAAAAAAAAB3cmhfb2ZsZF90Y3BfY2xv +c2VfY29uX3JlcGx5OiBycGwtPm9wX1RpZCBbMHgleF0sIHJwbD5zdGF0dXMgWzB4JXhdLCBycGwt +PnNuZF9ueHQgWzB4JXhdLCBycGwtPnJjdl9ueHQgWzB4JXhdCgAAdGNwX2Fib3J0X3JwbF9yc3M6 +IHRpZCBbMHgleF0sIHN0YXR1cyBbMHgleF0KAAAAdGNwX2Fib3J0X3JlcV9yc3M6IHRpZCBbMHgl +eF0sIHN0YXR1cyBbMHgleF0KAAAAcGt0c2NoZWRfY2xfcmxbJXU6JXVdOiBtb2RlIHwgdW5pdCB8 +IHJhdGUgMHglMDZ4IG1pbiAldSBtYXggJXUgcGt0c2l6ZSAldQoAAAAAAABwYXJhbV9kbWFxWzB4 +JXg6MHgleF06IGRtYXEgMHgleCByZWFkICV1IHBmICV1IHJldCAlZAoAAAAAAAAAAAAATUMgaW5p +dGlhbGl6YXRpb24gbm90IGNvbXBsZXRpbmcsIE1DIGN1cnJlbnQgaW5pdCBzdGF0ZSBpcyAweCUw +MngKAAAAAAAAAAAAAAAAAABod19iY204NDgzNF9sb2Fkc2VxdWVuY2U6IFN0YXJ0ZWQKAAAAAAAA +AAAAAAAAAABod19iY204NDgzNF9sb2Fkc2VxdWVuY2U6IFVwbG9hZCBpbWFnZSB0byBQSFkgb24t +Y2hpcCBtZW1vcgoAAAAAaHdfYmNtODQ4MzRfbG9hZHNlcXVlbmNlOiBkb25lIGxvYWRpbmcgaW1h +Z2UgKGkgPSAldSkKAAAAAAAAAAAAAEZMQVNIIG5vdCByZWFkeTogaSAldSBudnJSZWcgJSN4CgAA +AAAAAAAAAAAAAAAAAEFRX0ZMQVNIX1JlYWR5IC0gVGltZW91dCAoMSkKAAAAQVFfRkxBU0hfUmVh +ZHkgLSBUaW1lb3V0ICgyKQoAAAAJQVFfUmV0dXJuQ29udHJvbE9mRkxBU0gKAAAAAAAAAHBoeTog +ZmFpbGVkIHRvIGFsbG9jYXRlZCBtZW1vcnkgZm9yIHBoeSBmdyBmaWxlLCByZXQgJWQKAAAAAAAA +AABQSFkgRlcgdmVyc2lvbiBpbmZvcm1hdGlvbiBub3QgYXZhaWxhYmxlIGZvciB0aGlzIHRlY2hu +b2xvZ3kKAAAAaHdfbGVfZmlsdGVyX2N0dXBsZTogdHVwbGUgJXUgbm90IHNwZWNpZmllZCBidXQg +cmVxdWlyZWQgZm9yIG1hc2sgMHgleAoAAAAAAAAAAABsZSBjb25maWd1cmF0aW9uOiBuZW50cmll +cyAldSByb3V0ZSAldSBjbGlwICV1IGZpbHRlciAldSBhY3RpdmUgJXUgc2VydmVyICV1IGhhc2gg +JXUKAAAAAAAAAAAAAABsZSBjb25maWd1cmF0aW9uOiBuZW50cmllcyAldSByb3V0ZSAldSBjbGlw +ICV1IGZpbHRlciAldSBzZXJ2ZXIgJXUgYWN0aXZlICV1IGhhc2ggJXUgbnNlcnZlcnNyYW0gJXUK +AAAAAAAAAAAAAAAAY2ZfcGFyc2U6IGZpbGUgbWVtdHlwZSAweCV4IG1lbWFkZHIgMHgleCBtYXBw +ZWQgQCAlcDoKAAAAAAAAAAAAAGNvbmZpZ3VyZWQgd2l0aCBjYXBzIG5ibXxsaW5rIDB4JTA4eCBz +d2l0Y2h8bmljIDB4JTA4eCB0b2V8cmRtYSAweCUwOHggaXNjc2l8ZmNvZSAweCUwOHgKAAAAAAAA +AG5ldCBWSSBhbGxvY2F0aW9uIGZhaWxlZCBmb3IgZmNfaWQgJXUgd2l0aCBlcnJvciAlZAoAAAAA +AAAAAAAAAABuZXQgVkkgbWFjIGFkZHJlc3MgcHJvZ3JhbW1pbmcgZmFpbGVkIGZvciBmY19pZCAl +dSB3aXRoIGVycm9yICVkCgAAAAAAAAAAAAAAAAAAAG5ldCBWSSByeG1vZGUgcHJvZ3JhbW1pbmcg +ZmFpbGVkIGZvciBmY19pZCAldSB3aXRoIGVycm9yICVkCgAAAABuZXQgVkkgcnNzIGluZGlyZWN0 +aW9uIHRhYmxlIHByb2dyYW1taW5nIGZvciBmY19pZCAldSBmYWlsZWQgd2l0aCBlcnJvciAlZAoA +AAAAAG5ldCBWSSByc3MgY29uZmlnIGNvbW1hbmQgZmFpbGVkIGZvciBmY19pZCAldSB3aXRoIGVy +cm9yICVkCgAAAABuZXQgVkkgY29tbWFuZCBmYWlsZWQgZm9yIGZjX2lkICV1IHdpdGggZXJyb3Ig +JWQKAAAAAAAAAAAAAAAAAAAAcHBtYXggWyV1XSwgYml0cyBbJXVdLCBGV19JU0NTSV9QQUdFUE9E +X1RBR19JRFhfTUFYX1NJWkUgWyV1XQoAAGRlZmF1bHQgdGFnbWFzayBbMHglMHhdCgAAAAAAAAAA +cHJvZ3JhbW1lZCB0YWdtYXNrIFsweCUweF0KAAAAAABwcG0tPmRkcF9pbmZvLmxsaW1pdCBbMHgl +MHhdLCBwcG0tPmRkcF9pbmZvLnVsaW1pdCBbMHglMHhdLCBwcG0tPmRkcF9pbmZvLnNpemUgWzB4 +JTB4XQoAAAAAAAAAAABwcG0tPmRkcF9pbmZvLm1heF90eHN6IFsweCUweF0gcHBtLT5kZHBfaW5m +by5tYXhfcnhzeiBbMHglMHhdIGlvc2l6ZSBbMHglMHhdCgAAAHBwbWF4IFsldV0sIGlkeF9iaXRz +IFsldV0sIGlkeF9tYXNrIFsweCUweF0sIHJlc3ZkX3RhZ19tYXNrIFsweCUweF0sIHRhZ21hc2sg +WzB4JTB4XQoAAAAAAAAAAAAAAHRhZyBpdHQgMHglMHgsIGJpdHMgJXUsIGFnZSAweCUweCwgYml0 +cyAldQoAAAAAAGN4Y25pYy0+aXNjc2lfcHBtIFsweCUweF0KAAAAAAAAc2NzaV9wbGRfc2l6ZSBb +JXVdLCBBTElHTihzY3NpX3BsZF9zaXplLCAxNikgWyV1XQoAAAAAAAAAAAAAAAAAAG1heF9wcG9k +X3pvbmVzIFsldV0KAAAAAAAAAAAAAAAAZm9pc2NzaV9pbml0OiBmb2lzY3NpX2luaXRfZG9uZSBb +JXVdLCBkZXYucmVzLmZvaXNjc2lfbnRhc2tzIFsldV0sIGRldi5yZXMuZm9pc2NzaV9uc2VzcyBb +JXVdLCBkZXYucmVzLm5jc29jayBbJXVdLCBkZXYucmVzLmZvaXNjc2lfbmluaXQgWyV1XSwgcmMg +WyVkXQoAAAAAAAAAAGNoX2NsX3JhdGVbJXUvJXVdOiBjYXBwZWQgY2xhc3MgcmF0ZSBmcm9tIHJl +cXVlc3RlZCAldSB0byBjb25maWd1cmVkIChlZmZlY3RpdmUpIGNoYW5uZWwgcmF0ZSAldQoAAAAA +AAAAAAAAAAAAAABjaF9jbF9yYXRlWyV1LyV1XTogaW5jcmVhc2VkIGRlZmljaXRfaW5jciBmcm9t +IHJlcXVlc3RlZCAldSB0byByZXF1aXJlZCBtaW4gb2YgJXU7IHJhdGUgJXUgKGVmZiAldSkgZGVm +aWNpdF9tYXggJXUKAAAAAAAAAAAAAAAAAHBrdHNjaGVkIGNoYW5uZWwgJXUgc2V0cyBzcGVlZCAo +ZnJvbSAldSkgdG8gJXUga2JwcwoAAAAAAAAAAAAAAABwb3J0X2NtZF9oYW5kbGVyOiB1bmtub3du +IHUuZGNiLnR5cGUgMHgleAoAAAAAAABpMmMgZXJyb3IgY2F1c2VkIGJ5IG1vZHVsZSB1bnBsdWcK +AAAAAAAAAAAAAAAAAABzZW5kdG8gcGVuZGluZzogd3JfcGVuZCAlcCBmb3IgcG9ydCAldSwgIHdh +bnQgdG8gc2VuZCB0byBwb3J0ICV1CgAAAAAAAAAAAAAAAAAAAHNlbmR0bzpmbG93Y2lkICV1CgAA +AAAAAAAAAAAAAAAAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXJbJXVdIGxlYXZpbmcgU1RBVEVfVVAg +KD0+cG93ZXJkb3duKQoAAAAAAHBvcnRfbGlua19zdGF0ZV9oYW5kbGVyWyV1XSBwb3dlcmluZyBk +b3duCgAAAAAAAHBvcnRfbGlua19zdGF0ZV9oYW5kbGVyWyV1XSBsZWF2aW5nIHBvd2VyZG93biAo +PT5kb3duKQoAAAAAAAAAAABwb3J0X2xpbmtfc3RhdGVfaGFuZGxlclsldV0gbGVhdmluZyBTVEFU +RV9ET1dOICg9PnBvd2VydXApCgAAAAAAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXJbJXVdIHBvd2Vy +aW5nIHVwCgAAAAAAAAAAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXIgbGVhdmluZyBwb3dlcnVwICg9 +PnVwKQoAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXJbJXVdIG9oIG15IHdoYXQgaXMgZ29pbmcgb24g +KHN0YXRlID0gJSN4CgAAAAAAAAAAAAAAAAAAAABwb3J0X2xpbmtfc3RhdGVfaGFuZGxlciBnb3Qg +cmVzY2hlZHVsZWQKAAAAAAAAAABwb3J0X2xpbmtfc3RhdGVfaGFuZGxlcjogU29tZXRoaW5nIHdl +bnQgdGVycmlibHkgd3JvbmcuIHJldCA9ICVkCgAAAAAAAAAAAAAAAAAAAHNldHRpbmcvdW5zZXR0 +aW5nIGhzcyByZXN5bmMgYml0CgAAAAAAAAAAAAAAAAAAAGxlIGluaXRpYWxpemF0aW9uOiBuZW50 +cmllcyAldSByb3V0ZSAldSBjbGlwICV1IGZpbHRlciAldSBhY3RpdmUgJXUgc2VydmVyICV1IGhh +c2ggJXUKAAAAAAAAAAAAAGxlIGluaXRpYWxpemF0aW9uOiBuZW50cmllcyAldSByb3V0ZSAldSBj +bGlwICV1IGZpbHRlciAldSBzZXJ2ZXIgJXUgYWN0aXZlICV1IGhhc2ggJXUgbnNlcnZlcnNyYW0g +JXUKAAAAAAAAAAAAAAB0cCBjaGFubmVsIGNvbmZpZ3VyYXRpb246ICV1IHJ4IGFuZCAldSB0eCBj +aGFubmVscwoAAAAAAAAAAAAAAAAAdHAgbWVtIGRpc3RyaWJ1dGlvblslJV0gcG10eCAldSBwbXJ4 +ICV1IGRkcCAldSBkZHBfaXNjc2kgJXUgc3RhZyAldSBwYmwgJXUgcnEgJXUgcnF1ZHAgJXUKAAAA +AAAAVFBfUE1NX1JYX1BBR0VfU0laRSAldSBpcyBub3Qgc3VwcG9ydGVkCgAAAAAAAAAAVFBfUE1N +X1RYX1BBR0VfU0laRSAldSBpcyBub3Qgc3VwcG9ydGVkCgAAAAAAAAAAY3hjbmljX2RldmljZV9p +bml0OiBjeGNuaWMgWzB4JTB4XSwgY3hjbmljLT5maWx0ZXIgWyUweF0KAAAAAAAAAGN4Y25pY19k +ZXZpY2VfaW5pdDogZGV2LnRwLm51bV90eF9wYWdlcyBbJXVdLCBkZXYubWNbMF0uc2l6ZSBbJXVd +LCBkZXYudHAudHhfcGFnZV9zeiBbJXVdLCBjeGNuaWMgc2l6ZSBbJWRdLCByYyBbJWRdCgAAAAAA +AAAAAAAAUG9ydFsldV06IFVua25vd24gU0dNSUkgc3ViLXR5cGUgJSN4CgAAAAAAAAAAAAAAUG9y +dFsldV06IFVua25vd24gQlRfWEZJIHN1Yi10eXBlICUjeAoAAAAAAAAAAAAAUG9ydFsldV06IFVu +a25vd24gQlRfWEFVSSBzdWItdHlwZSAlI3gKAAAAAAAAAAAAcG9ydF9pbml0WyV1XTogcG9ydCB0 +eXBlIDB4JXggaXMgbm90IHN1cHBvcnRlZAoARVEgcGZuICV1IHZmbiAldTogZGVzdHJveWluZyBl +cWlkICV1IHdpdGggcGVuZGluZyBXUihzKSAobnVtX2J5dGVzICV1IGFuZCBmbGFncyAweCUwOHgK +AAAAAAAAAAAAbDJkZXZfZmMtPmZsb3djX2lkIFsldV0sIGwyZGMtPnBmbiBbJXVdLCBsMmRjLT52 +Zm4gWyV1XSwgbDJkYy0+bHBvcnQgWyV1XSwgbDJkZXZfZmMtPmZsb3dpZCBbJXVdIGwyZGMtPnR4 +X2NoIFsldV0sIGRldi52cGQucG9ydHZlYyBbJXhdCgAAAAAAAAAAcG9ydHZlYyBbJXVdCgAAAEFo +IGhhLi4uZG91YmxlIGZyZWUgb3hfaWQgMHgleCwgcnhfaWQgMHgleAoAAAAAAEhvc3QgUFJMSSBS +ZXNwb25zZSB0aW1lZG91dDogb3hfaWQgMHgleCByeF9pZCAweCV4CgAAAAAAAAAAAAAAAABwZm4g +JXUgdmZuICV1IHZpYSBjb21tYW5kCgAAAAAAAGNvbmZpZ3VyYXRpb24gZmlsZSBwYXJzZXI6IHNn +ZSB0aW1lciB2YWx1ZVslaV0gaXMgdG9vIGxhcmdlLCBjaGFuZ2luZyBmcm9tICV1IHRvICV1dXNl +Y3MKAAAAAAAAAGZpbHRlcm1hc2sgMHgleCBpcyBub3QgZXF1YWwvc3Vic2V0IHRvL29mIGZpbHRl +cm1vZGUKAAAAAAAAAAAAAABod19sZV9jbGlwX2hhbmRsZXI6IHJlbW92ZWQgcG9zPSV1ICg9aWR4 +ICV1KQoAAABod19sZV9jbGlwX2hhbmRsZXI6IGFkZGluZyB0byBwb3M9JXUgKD1pZHggJXUpCgBt +b2R1bGVbJXVdOiBwb3J0IG1vZHVsZSBpbnNlcnRlZCBhbmQgcmVhZHkKAAAAAABtb2R1bGVbJXVd +OiBwb3J0IG1vZHVsZSByZW1vdmVkCgAAAAAAAAAAAAAAAAAAAABtb2R1bGVbJXVdOiB1bmtub3du +IG1vZHVsZSBpZGVudGlmaWVyIDB4JTAyeAoAAABtb2R1bGVbJXVdOiBncGlvICV1IHRyYW5zIDEw +RyAweCUwMnggMUcgMHglMDJ4IChsZW5ndGggJXUpIGNhYmxlIDB4JTAyeCAobGVuZ3RoICV1KSBt +b2R1bGVfdHlwZSAweCUwMngKAAAAAAAAAAAAY3g0X2NyX3Bkb3duWyV1XTogZW4gJXUgdmlfZW5f +Y250ICV1CgAAAAAAAAAAAAAAY3JfbW9kdWxlX3J4X2xvc1sldV06IHJ4X2xvcyBjaGFuZ2VkIHRv +ICV1CgAAAAAAaW5pdF9wb3J0WyV1XTogIGxpbmsgc3RhdHVzIDB4JXggbW9kX3R5cGUgMHgleCB2 +aV9lbl9jbnQgJXUgcnhfbG9zICV1IGhzc19zaWdkZXQgJXUgcG9ydF9jZmcuc2lnZGV0ICV1CgAA +AAAAAAAAAGluaXRfcG9ydFsldV06ICBsaW5rIHN0YXR1cyAweCV4CgAAAAAAAAAAAAAAAAAAAGlu +aXRfcG9ydFsldV06ICBsaW5rIHN0YXR1cyAweCV4CgAAAAAAAAAAAAAAAAAAAGluaXRfcG9ydFsl +dV06ICBsaW5rIHN0YXR1cyAweCV4CgAAAAAAAAAAAAAAAAAAAGluaXRfcG9ydFsldV06ICBsaW5r +IHN0YXR1cyAweCV4CgAAAAAAAAAAAAAAAAAAAGluaXRfcG9ydFsldV06ICBsaW5rIHN0YXR1cyAw +eCV4CgAAAAAAAAAAAAAAAAAAAGN4NF9jclsldV06IHJldCAlZCBzdGF0dXMgJXUgeGdtX2xzIDB4 +JTA4eAoAAAAAAHBmbiAldSB2Zm4gJXUKAABodyBwZiBiaXRtYXAgMHglMDJ4IHZmaWQgYml0bWFw +IDB4JTA4eDoweCUwOHg6MHglMDh4OjB4JTA4eAoAAAAAYWZ0ZXIgdmZpZCBmaXh1cCwgdmZpZCBi +aXRtYXAgMHglMDh4OjB4JTA4eDoweCUwOHg6MHglMDh4CgAAAAAAAHdvcmthcm91bmQxMzcyMzog +ZGV0ZWN0ZWQgV1IgQCAweCUwOHggb2Ygc2l6ZSAldSBieXRlcywgZHJpYmJsaW5nIGl0IGluICV1 +IGJ5dGVzIGF0IGEgdGltZQoAAAAAAHRpbWVyIHF1ZXVlICV1IGxvc3QgYSB0aWNrISBuZXh0ICVw +IGxhc3QgJXAgbnVtZSAldQoAAAAAAAAAAAAAAABmbHJfdGltZXJfc3RhcnQ6IGZsb3djX2lkICV1 +ICVwIGJ1ZiAlcAoAAAAAAAAAAABwY2llOiBucGYgJXUgKHBmYml0bWFwIDB4JTAyeCkgbnZmICV1 +IChwZiAwLi4zIDB4JTAyeCAweCUwMnggMHglMDJ4IDB4JTAyeCkKAAAAAGZhaWxlZCB0byBmaW5k +IHRoZSAlYyVjIFZQRCBwYXJhbWV0ZXIKAAAAAAAAAAAAAGZhaWxlZCB0byBwYXJzZSB0aGUgJWMl +YyBWUEQgcGFyYW1ldGVyCgAAAAAAAAAAAGZhaWxlZCB0byBzdWNjZXNzZnVsbHkgZmluZCBDaGVs +c2lvIFZQRAoAAAAAAAAAAGxvZyBpbml0aWFsaXplZCBAIDB4JTA4eCBzaXplICV1ICgldSBlbnRy +aWVzKQoAAHdyaF9mb2lzY3NpX3Njc2lfZXJyOiB3ciBbMHgleF0sIHF1ZXVlZCBvbiBmbG93YyBb +MHgleF0sIGZpZm8gWzB4JXhdIGJ5dGVzX2F2YWlsYWJsZQoAAAAAAAAAAAAAAGh3IHJlZ2lzdGVy +IG9wZXJhdGlvbiBub3QgY29tcGxldGluZywgcmVnIDB4JTA4eCBtYXNrIDB4JTA4eCB2YWx1ZSAw +eCUwOHggKHJlZyAweCUwOHgpCgAAAAAAAAAAAE1ESU8gQ0w0NTogZmFpbGVkIHRvIHNldCB1cCBN +TUQgYWRkcgoAAAAAAAAAAAAAAE1ESU86IGZhaWxlZCB0byB3cml0ZQoAAAAAAAAAAAAATURJTyBD +TDQ1OiBmYWlsZWQgdG8gc2V0IHVwIE1NRCBhZGRyCgAAAAAAAAAAAAAATURJTzogZmFpbGVkIHRv +IHJlYWQKAAAAAAAAAAAAAABzZW5kX2Nsb3NlX3JlcTogY3NrX2ZjLT5mbG93Y190eXBlIFsweCV4 +XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+dGNiX3N0YXRlIFsweCV4XQoAAABz +ZW5kX2Nsb3NlX3JlcTogY3NrX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19p +ZCBbMHgleF0sIHRpZCBbMHgleF0sIHVscHR4Y2ggWyV1XSxidWZmZXJlZCBbJXVdCgAAAAAAb2Zs +ZF90Y3BfZG9fYWN0aXZlX2Nsb3NlOiBjc2tfZmMgWzB4JXhdLCBjc2tfZmMtPmZsb3djX2lkIFsw +eCV4XSwgY3NrX2ZjLT50Y2Jfc3RhdGUgWzB4JXhdCgAAAAAAb2ZsZF90Y3BfZG9fYWN0aXZlX2Ns +b3NlOiBjc2tfZmMgWzB4JXhdLCBjc2tfZmMtPmZsb3djX2lkIFsweCV4XSwgY3NrX2ZjLT50Y2Jf +c3RhdGUgWzB4JXhdCgAAAAAAc2Vzc2lvbl9ibG9jazogc2Vzc19mYy0+Zmxvd2NfaWQgWzB4JXhd +LCBzZXNzX2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0sIGNvbm5fZmMtPmZsb3djX2lkIFsweCV4XSwg +Y29ubl9mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBjc2tfZmMtPmZsb3djX2lkIFsweCV4XSwgY3Nr +X2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0KAAAAAAAAAAAAAAAAAAAAb2ZsZF90Y3BfZGlzY29ubmVj +dDogdGNiX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2st +PnRjYl9zdGF0ZSBbMHgleF0KAAAAZGVjb2RlX2Jhc2U2NF9zdHJpbmc6IGRsZW4gWyVkXQoAAAAA +AAAAAAAAAAAAAAAAZGVjb2RlX2hleF9zdHJpbmc6IGRsZW4gWyVkXQoAAABsb2dnZWRfaW46IGZs +b3djX2ZvaXNjc2lfY29ubl9mbGFncyBbMHgleF0KAAAAAABmb2lzY3NpX3ZhbGlkYXRlX2xvZ2lu +X3N0YWdlOiAtIDEKAAAAAAAAAAAAAAAAAABTZXEgIyBtaXNtYXRjaCBzdGF0c24gPSAweCV4IGV4 +cHN0YXRzbiA9IDB4JXgKAAB0ZXh0X3Jlc3A6IGNfYml0IFsweCV4XSwgZl9iaXQgWzB4JXhdCgAA +AAAAAAAAAABuZXRfbDJkZXZfZmluZF9ieV9hZGRyOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhd +LCBsMmRjLT5scG9ydCBbJXVdLCBsMmRfZmMtPmZsb3djX2lkIFsweCV4XSwgbDJkYy0+aW40X2Rl +di5pbl9hZGRyLmFkZHIgWzB4JXhdLCBhZGRyIFsweCV4XQoAAABuZXRfbDJkZXZfbXR1X2NvbmZp +ZzogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgbXR1ICV1CgAAAAAAAAAAbmV0aWZfZG9fZGhj +cDogd3ItPnBhcmFtLnZsYW5pZCBbJXVdLCBsMmRldl9mYy0+Zmxvd2NfbmV0X2wyZGV2X3ZsYW5k +ZXYgWzB4JXhdCgBsMmRldl92aV9mc206IG1iIFsweCV4XSwgZGVmZXJyZWQsIHN0YXRlIFsweCV4 +XSwgcG9ydCBbMHgleF0KAAAAbDJkZXZfdmlfZnNtOiB2aWlkIFsweCV4XSBwb3J0IFsweCV4XSwg +bWFjLWlkIFslMDJ4OiUwMng6JTAyeDolMDJ4OiUwMng6JTAyeF0uIAoAAAAAAAAAAAAAAAAAAAAA +bDJkZXZfdmlfZnNtOiBzZ2VfZXFpZCBbMHgleF0sIHNnZV9pcWlkIFsweCV4XSwgc2dlX2VxY3Ig +WzB4JXhdLCByc3Nfc3ogWzB4JXhdCgBsMmRldl92aV9mc206IGwyZGV2X2ZjLT5mbG93Y19uZXRf +bDJkZXZfbXR1IFsldV0sIG1iX3NjcmF0Y2ggWzB4JXhdLCBwb3J0IFsweCV4XQoAAAAAAAAAAAAA +AAAAAABsMmRldl92aV9mc206IHZpaWQgWyVkXSwgdmlfZmMtPmZsb3djX3ZpX2ZsYWdzIFsweCV4 +XQoAAAAAAAAAAAAAbDJkZXZfdmlfZnNtOiBwZm4gWzB4JXhdLCB2Zm4gWzB4JXhdLCBsMmRldl9m +Yy0+Zmxvd2NfaWQgWzB4JXhdLCBscG9ydCBbMHgleF0sIHZpaWQgWzB4JXhdLCBmbGFncyBbMHgl +eF0KAAAAAAAAAGwyZGV2X3ZpX2ZzbTogRXJyb3IgZnJlZWluZyBWSSwgcmMgWzB4JXhdCgAAAAAA +AGwyZGV2X3ZpX2ZzbTogcGlkIFsweCV4XSwgdmlpZCBbMHgleF0sIG1iX2xvYyBbMHgleF0sIG1i +X29yaWdbMHgleF0sIGwyZGV2X2ZsYWdzIFsweCV4XSwgcmMgWzB4JXhdCgAAAAAAAAAAAAAAAABl +bmNvZGUgaGV4IHN0cmluZzogZGxlbiBbJWRdCgAAAHRjcF9zZW5kX2FvcGVuX3JlcTogY3NrX2Zj +LT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBidWZmZXJlZCBb +JXVdLCByZXNfY250IFsweCV4XSwgc2NoZWRfbm9kZS5uZXh0IFsweCV4XQoAYW9wZW5fcmVxOiBo +d19sZV9maWx0ZXJfY3R1cGxlIGZhaWxlZCA6ICVkCgAAAAAAb2ZsZF90Y3Bfc2VuZF9hb3Blbl9y +ZXE6IGNwbF9yZXEtPkZpbHRlciBbMHglMHhdLCBjdHVwbGVzWzBdIFsweCV4XSwgY3R1cGxlc1sx +XSBbMHgleF0KAAAAAAAAAAAAY3NvY2tfYWxsb2M6IHR4X2NoIFsweCV4XSwgbHBvcnQgWzB4JXhd +LCBjb29raWUgWyUwOHhdCgAAAAAAAAAAAGNzb2NrX2FsbG9jOiBhdmFpbGFibGUgWyV1XSwgbmNz +b2NrIFsldV0sIHBvczphdGlkIFsweCV4XSwgY3NrX2ZjIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19p +ZCBbMHgleF0sIHNwb3J0IFsldV0KAABmb2lzY3NpX3BlZXJfaW5pdDogY29ubl9hdHRyLT5oZGln +ZXN0X3RvX2RkcF9wZ3N6IFsweCV4XQoAAAAAAAAAZm9pc2NzaV9wZWVyX2luaXQ6IGNvbm5fZmMt +PmZsb3djX2ZvaXNjc2lfY29ubl9mbGFncyBbMHgleF0KAAAAAHRhc2tfZnJlZTogdHJ5aW5nIHRv +IGZyZWUgcXVldWVkIHRhc2sgWzB4JXhdISEhCgAAAAAAAAAAAAAAAAAAAABXQVRDSERPRzogTm8g +dGVtcGVyYXR1cmUgc2Vuc29yIGF2YWlsYWJsZS4KAAAAAABXQVRDSERPRzogQWN0aXZhdGluZwoA +AAAAAAAAAAAAAFdBVENIRE9HIC0gRW5hYmxlIGFjdGlvbiAldSB0aW1lICV1CgAAAAAAAAAAAAAA +AFdBVENIRE9HIC0gRGlzYWJsZSBhY3Rpb24gJXUKAAAAV0FUQ0hET0c6IERlLWFjdGl2YXRpbmcK +AAAAAAAAAABzZXNzaW9uX3VuYmxvY2s6IHNlc3NfZmMtPmZsb3djX2lkIFsweCV4XSwgc2Vzc19m +Yy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBjb25uX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNvbm5fZmMt +PmZsb3djX3N0YXRlIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+Zmxv +d2Nfc3RhdGUgWzB4JXhdCgAAAAAAAAAAAAAAAABzZXNzaW9uX2xpbmtfbm90aWZ5OiBwb3J0IFsw +eCV4XSBsaW5rIGRvd24gcGluZyByZWNvdmVyeSBkaXNhYmxlZCwgdHJ5aW5nIHRvIHJlY292ZXIg +c2Vzc2lvbiBbMHgleF0gY29ubiBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAHNlc3Npb25fbGlua19u +b3RpZnk6IHBvcnQgWzB4JXhdIGxpbmsgdXAgc2Vzc2lvbiBbMHgleF0gY29ubiBbMHgleF0KAAAA +AAAAAAAAAAAAZm9pc2NzaSBjb25uX2ZjIFsweCV4XSwgZmxvd2Nfc2NoZWRjbCBbMHgleF0sIGlu +Z19jaCBbMHgleF0sIGVncl9jaCBbMHgleF0KAAAAAABsMmRldl9ub3RpZnkgd2l0aCB1bmtub3du +IGZsYWcgWzB4JXhdCgAAAAAAAAAAAABGQ29FIEZDQiBsaW5rZG93bjogaW9fcmVxIDB4JXgleCBp +cWlkIDB4JXggZmxvd2lkIDB4JXggb3AgMHgleAoAZmNvZSBub3RpZnkgOiBVcGRhdGUgbmV3IERD +QlggdmFsdWVzIFZJIHN0YXRlIDB4JXggcHJpIDB4JXggc2NoZWRjbCAweCV4IGRjYnhfZG9uZSAw +eCV4CgAAAAAAAAAAZmNvZSBub3RpZnkgOiBGQ0YgZmxvd2lkIDB4JXgsIHVscGNoIDB4JXggCgAA +AAAAbmV0X2wyZGV2X25vdGlmeTogRXZlbnQgb24gbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwg +cG9ydCBbJWRdLCBldmVudCBbMHgleF0sIHVscHR4Y2ggWyV1XSwgY2xhc3MgWzB4JXhdLCBwcmlv +cml0eSBbMHgleF0KAAAAAABmY29lIG5vdGlmeSA6IERDQlggOiBwb3J0IDB4JXgsIHByaW9yaXR5 +IDB4JXggdWxwdHhjaCAweCV4IGNsYXNzIDB4JXgKAAAAAAAAAAAAAGNoX2NsX3JhdGVbJXUvJXVd +OiBjYXBwZWQgZGVmaWNpdF9pbmNyIGZyb20gcmVxdWlyZWQgJXUgdG8gJXU7IHJhdGUgJXUgKGVm +ZiAldSkgZGVmaWNpdF9tYXggJXUKAEZDb0UgRkNGIHRpbWVyOiBmbG93YyBzdGF0ZSAweCV4LCBw +b3J0IDB4JXggLGZjZiAweCV4LCBmbG93Y19pZCAweCV4CgAAAAAAAAAAAAAAY29yZV9wcm9ncmFt +X3RjYjogdGlkICUjeCB0X3N0YXRlICUjeCByY3ZfYWR2IDB4JTA4eCByY3Zfc2NhbGUgJSN4IHR4 +X21heCAlI3ggcmN2X254dCAlI3ggYXRpZCAlI3gKAAAAAAAAAAAAAAAAAAlvcHQwICUjeCV4IG9w +dDIgJSN4IGlwdjYgJSN4IGZsYWdzX3RpbWVyIDB4JTA4eAoAAAAAAAAAAAAAAAAAAABvZmxkX2Nv +bm5lY3Rpb25fd3I6IGNvbm5lY3Rpb24gd2l0aCA1LXR1cGxlIGxwIDB4JTA0eCBmcCAweCUwNHgg +bGlwIDB4JTA4eCUwOHggcGlwIDB4JTA4eCUwOHggZmlsdGVyIDB4JTA4eCBleGlzdHMgQCBMRSBp +bmRleCAldQoAAAAAAAAAAAAAAAAAAABvZmxkX2Nvbm5lY3Rpb25fd3I6IGNvbm5lY3Rpb24gd2l0 +aCA1LXR1cGxlIGxwIDB4JTA0eCBmcCAweCUwNHggbGlwIDB4JTA4eCBwaXAgMHglMDh4IGZpbHRl +ciAweCUwOHggZXhpc3RzIEAgTEUgaW5kZXggJXUKAAAAAAAAAG9mbGRfY29ubmVjdGlvbl93cjog +Y29ubmVjdGlvbiB3aXRoIDUtdHVwbGUgbHAgMHglMDR4IGZwIDB4JTA0eCBsaXAgMHglMDh4JTA4 +eCBwaXAgMHglMDh4JTA4eCBmaWx0ZXIgMHglMDh4CgAAAABvZmxkX2Nvbm5lY3Rpb25fd3I6IGNv +bm5lY3Rpb24gd2l0aCA1LXR1cGxlIGxwIDB4JTA0eCBmcCAweCUwNHggbGlwIDB4JTA4eCBwaXAg +MHglMDh4IGZpbHRlciAweCUwOHgKAAAAAAAAAAAAAAAASVFGTElOVCBwZm4gJXUgdmZuICV1OiBp +cWVzaXplICV1IHRvbyBzbWFsbAoAAAAASVFGTElOVCBwZm4gJXUgdmZuICV1OiBpcWlkICV1IHRv +byBsYXJnZSAobWF4ICV1KQoAAAAAAAAAAAAAAAAAAElRRkxJTlQgcGZuICV1IHZmbiAldTogaXFp +ZCAldSBub3QgYWxsb2NhdGVkCgAAAElRRkxJTlQgcGZuICV1IHZmbiAldTogZmwwaWQgJXUgdG9v +IGxhcmdlIChtYXggJXUpCgAAAAAAAAAAAAAAAABJUUZMSU5UIHBmbiAldSB2Zm4gJXU6IGZsMGlk +ICV1IG5vdCBhbGxvY2F0ZWQKAABJUUZMSU5UIHBmbiAldSB2Zm4gJXU6IGZsMWlkICV1IHRvbyBs +YXJnZSAobWF4ICV1KQoAAAAAAAAAAAAAAAAASVFGTElOVCBwZm4gJXUgdmZuICV1OiBmbDFpZCAl +dSBub3QgYWxsb2NhdGVkCgAASVFGTElOVCBwZm4gJXUgdmZuICV1OiBmbDFpZCAldSBpcyB2YWxp +ZCBidXQgbm90IGZsMGlkICV1CgAAAAAAAElRRkxJTlQgcGZuICV1IHZmbiAldTogZmwxaWQgJXUg +aXMgdmFsaWQgYnV0IGhlYWRlciBzcGxpdCBmZWF0dXJlIGlzIG5vdCBlbmFibGVkCgAAAAAAAAAA +AAAAAAAAAElRIHBmbiAldSB2Zm4gJXU6IGlxaWQgJXUgdG9vIGxhcmdlIChtYXggJXUpCgAAAElR +IHBmbiAldSB2Zm4gJXU6IGlxaWQgJXUgbm90IGFsbG9jYXRlZAoAAAAAAAAAAElRIHBmbiAldSB2 +Zm4gJXU6IGZsMGlkICV1IGZsMWlkICV1IGJ1dCBub3Qgc3VwcG9ydGVkCgAAAAAAAAAAAABod191 +bHB0eF93b3JrYXJvdW5kX3ByMTY5NDlfZW5hYmxlZF9wZjogcGYgJXUgZW5hYmxlZCAldQoAAAAA +AAAAaHdfdWxwdHhfd29ya2Fyb3VuZF9wcjE2OTQ5X2VuYWJsZWRfdmZpZDogdmZpZCAldSBlbmFi +bGVkICV1CgAAAEVRIHBmbiAldSB2Zm4gJXU6IGNyZWF0aW5nIEVUSCBlcWlkICV1IHdpdGggcGVu +ZGluZyBXUihzKSAobnVtX2J5dGVzICV1IGFuZCBmbGFncyAweCUwOHgKAAAAAAAAAEVRIHBmbiAl +dSB2Zm4gJXU6IGNyZWF0aW5nIENUUkwgZXFpZCAldSB3aXRoIHBlbmRpbmcgV1IocykgKG51bV9i +eXRlcyAldSBhbmQgZmxhZ3MgMHglMDh4CgAAAAAAAEVRIHBmbiAldSB2Zm4gJXU6IGVxaWQgJXUg +dG9vIGxhcmdlIChtYXggJXUpCgAAAEVRIHBmbiAldSB2Zm4gJXU6IGVxaWQgJXUgbm90IGFsbG9j +YXRlZAoAAAAAAAAAAGh3X2NpbV90cF93b3JrYXJvdW5kMTM3MjNfZW5hYmxlOiBwb3J0ICV1IHBy +b3RvY29sIDB4JXggZW4gJXUgY3VycmVudCAweCV4IHdvcmthcm91bmRfcHIxMzcyMyAweCV4CgAA +AAAAAAAAAAAAAABwb3J0X2JsaW5rX2xlZF9yZXN0b3JlCgAAAAAAAAAAAHBvcnRfYmxpbms6IGJs +aW5rZHVyPTB4JXggYmxpbmtfcmVmY250CgAAAAAAAAAAAHBvcnRfYmxpbms6IAlibGlua19yZWZj +bnQ9MHgleAoAcG9ydF9ibGluazogCWJsaW5rX3JlZmNudD0weCV4CgBtaWlfYWR2X2ZjWyV1XTog +cmNhcHMgMHgleAoAAAAAAG1paV9hZHZfc3BlZWRbJXVdOiByY2FwcyAweCV4CgAAbWlpX2FucmVz +dGFydFsldV06IGFjYXBzIDB4JXgKAABtaWlfaW5pdFsldV06IGFjYXBzIDB4JXgKAAAAAAAAAG1p +aV9wZG93blsldV06IHBvd2VyZG93biBlbiAldQoAcG9ydFsldV06IGdhdmUgdXAgZml4aW5nIGVy +cm9ycyEhIQoAAAAAAAAAAAAAAAAAcG9ydFsldToweCUwMng6MHglMDJ4XTogbDFjZmcsIHBjYXBz +IDB4JXggYWNhcHMgMHgleCByY2FwcyAweCV4CgAAAAAAAAAAAAAAAAAAAABwb3J0WyV1OjB4JTAy +eDoweCUwMnhdOiBsMWNmZywgaW52YWxpZCByZXF1ZXN0LCBwY2FwcyAweCV4IGFjYXBzIDB4JXgg +cmNhcHMgMHgleAoAAAAAAAAAAAAAAAAAAABwb3J0WyV1OjB4JTAyeDoweCUwMnhdOiBsMWNmZywg +bWRpIG4vYSBwY2FwcyAweCV4IGFjYXBzIDB4JXggcmNhcHMgMHgleAoAAAAAAAAAAHBvcnRbJXU6 +MHglMDJ4OjB4JTAyeF06IGwxY2ZnLCBjYW5ub3QgZm9yY2Ugbm8vbXVsdGlwbGUgc3BlZWQocyks +IHBjYXBzIDB4JXggYWNhcHMgMHgleCByY2FwcyAweCV4CgAAAAAAAAAAAAAAAABnZXRfcmVmX3Rh +c2s6IHJlcXVlc3RlZCBjb29raWU6IGhpZ2ggWzB4JTA4eF0sIGxvdyBbMHglMDh4XQoAAAAAZ2V0 +X3JlZl90YXNrOiB0YXNrIGNvb2tpZTogaGlnaCBbMHglMDh4XSwgbG93IFsweCUwOHhdCgAAAAAA +AAAAAGdldF9yZWZfdGFzazogaXN0YXNrLT5mbG93Y19pZCBbMHgleF0sIGlzdGFza19mYy0+Zmxv +d2Nfc3RhdGUgWyV1XQoAAAAAAAAAAAAAAAAAZ2V0X3JlZl90YXNrOiB0YXNrIG5vdCBmb3IgY29v +a2llICVseAoAAAAAAAAAAAAAcHJvY2Vzc19kaGNwX29wdHM6IHJvb3QgcGF0aCBsZW4gWyVkXSBi +eXRlcwoAAAAAbmV0aWZfcHJvY2Vzc19kaGNwX29wdHM6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgl +eF0sIE1TR19UWVBFIFslZF0sIGRoY3R4dC0+c3RhdGUgWyVkXQoAAAAAAAAAAAAAaWNtcF9yZWN2 +OiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBwaWQgWzB4JXhdLCBpY21wIHR5cGUgWzB4JXhd +CgAAAAAAAAAAAAAAAABBQlRTIEFDQyBhd2FpdGluZyBQUkxJIFJzcDogZmxvd2NfaWQgMHgleCBv +eF9pZCAweCV4IHJ4X2lkIDB4JXggaXFpZCAweCV4CgAAAAAAAGNobmV0X2FycF9yZWN2OiBpcCBj +b25mbGljdCBkZXRlY3RlZAoAAAAAAAAAAAAAAGNobmV0X2FycF9yZWN2OiBwaWQgWyV1XSwgdmxh +biBbMHgleF0sIGFycCBvcCBbMHgleF0sIHNpcCBbMHgleF0sIHJpcCBbMHgleF0KAAAAY3NvY2tf +cGVlcl9jbG9zZTogY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+dGNiX2ZjLT5mbG93 +Y19pZCBbMHgleF0sIGNza19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBjc2tfZmMtPmZsb3djX2Nz +b2NrX3RjYl9mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdCgAAAAAAAAAAAGNzb2NrX3BlZXJfY2xvc2U6 +IGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2tfZmMtPmZsb3djX3N0YXRlICBbMHgleF0KAAAA +AAAAAAAAaHdfdWxwdHhfd29ya2Fyb3VuZF9wcjE2OTQ5X2VuYWJsZWRfcGZfaXE6IGlxICV1IGVu +YWJsZWQgJXUgKHBmICV1KQoAAAAAAAAAAAAAAAB0Y2JfZmMtPmZsb3djX2lkIFsweCUwNnhdLCB0 +Y2JfZmMtPmZsb3djX3R5cGUgWzB4JXhdLCBjcGxvcCBbMHgleF0gCgAAAAAAAAAAAAAAAGNoX3Jh +dGVbJXVdOiBjYXBwZWQgdGljayBmcm9tIHJlcXVpcmVkICV1IHRvIHN1cHBvcnRlZCAldTsgcmF0 +ZSAldSAoZWZmICV1KSBkZWZpY2l0X2luY3IgJXUgdGljayAldQoAAAAAAAAAAAAAAABwa3RzY2hl +ZF9jaF9ybFsldV06IGNoYW5uZWwgcmwgbm90IGF2YWlsYWJsZSBpbiBjb25qdW5jdGlvbiB3aXRo +IGZsb3cgc2hhcGluZwoAAHBrdHNjaGVkX2NoX3JsWyV1XTogcmF0ZSAldSBtYXggJXUKAAAAAAAA +AAAAAAAAAHBrdHNjaGVkX2NsX3dyclsldToldV06IHdlaWdodCAldSB3ZWlnaHRlZF9tYXNrIDB4 +JXgKAAAAAAAAAAAAAABlcV9wYXJhbXNbMHgleDoweCV4XTogZG1hcSAweCV4IHJlYWQgJXUgcGYg +JXUgZXFpZF9hcGkgJXUgcmV0ICVkCgAAAAAAAAAAAAAAAAAAAGh3X2JjbTg0MzRfY2hlY2tyYW06 +IFN0YXJ0CgAAAAAAUEhZWyV1XSBwcm9jZXNzb3Igbm90IHJ1bm5pbmcKAABQSFlbJXVdIEZXIGhh +cyBiYWQgQ1JDCgAAAAAAAAAAAFBIWSBmaXJtd2FyZSBsb2FkIHN1Y2Nlc3NmdWwhCgAACUFRX1Rh +a2VDb250cm9sT2ZGTEFTSDogMWUuYzAwMT0lI3ggMWUuYzQ1MD0lI3ggMWUuYzQ1MT0lI3ggMWUu +MTAwPSUjeAoAAAAAAAAAAABBUV9BUElfV3JpdGVBbmRWZXJpZnlGbGFzaEltYWdlIC0gSW1hZ2Ug +aW50ZWdyaXR5IGNoZWNrIGZhaWxlZCAoY2FsYyAlI3ggdmFsICUjeCkKAAAAAAAAAAAAAAAAAABB +UV9BUElfV3JpdGVBbmRWZXJpZnlGbGFzaEltYWdlIC0gSW1hZ2UgaW50ZWdyaXR5IGNoZWNrIHBh +c3NlZAoAQVFfQVBJX1dyaXRlQW5kVmVyaWZ5Rmxhc2hJbWFnZSAtIFRpbWVvdXQgd2FpdGluZyBm +b3IgZmxhc2ggaW50ZXJmYWNlICgldSkKAAAAAABBUV9BUElfV3JpdGVBbmRWZXJpZnlGbGFzaElt +YWdlIC0gVGltZW91dCB3YWl0aW5nIGZvciBmbGFzaCBpbnRlcmZhY2UgKCV1KQoAAAAAAEFRX0FQ +SV9Xcml0ZUFuZFZlcmlmeUZsYXNoSW1hZ2UgLSBUaW1lb3V0IHdhaXRpbmcgZm9yIGZsYXNoIGlu +dGVyZmFjZSAoJXUpCgAAAAAAQVFfQVBJX1dyaXRlQW5kVmVyaWZ5Rmxhc2hJbWFnZSAtIFRpbWVv +dXQgd2FpdGluZyBmb3IgZmxhc2ggaW50ZXJmYWNlICgldSkgKHBwICUjeCBhcCAlI3gpCgAAAAAA +QVFfQVBJX1dyaXRlQW5kVmVyaWZ5Rmxhc2hJbWFnZSAtIFRpbWVvdXQgd2FpdGluZyBmb3IgZmxh +c2ggaW50ZXJmYWNlICgldSkKAAAAAABBUV9BUElfV3JpdGVBbmRWZXJpZnlGbGFzaEltYWdlIC0g +VGltZW91dCB3YWl0aW5nIGZvciBmbGFzaCBpbnRlcmZhY2UgKCV1KQoAAAAAAEFRX0FQSV9Xcml0 +ZUFuZFZlcmlmeUZsYXNoSW1hZ2UgLSBFcnJvciBvbiBidXJuaW5nIEZMQVNIIChjcmMxNiBtaXNt +YXRjaCkKAAAAAAAAbWFsbG9jX2RlY1sldV06IHN0YXJ0ICVwIGVuZCAlcCBuZXh0ICVwIHNpemUg +MHgleCBhbGlnbWVudCAweCV4IHAgJXAKAAAAAAAAAAAAAABtYWxsb2NfaW5jWyV1XTogc3RhcnQg +JXAgZW5kICVwIG5leHQgJXAgc2l6ZSAweCV4IGFsaWdtZW50IDB4JXggcCAlcAoAAAAAAAAAAAAA +AGxlIGNvbmZpZ3VyYXRpb246IGhhc2ggbW9kZSByZXF1aXJlcyBhdCBsZWFzdCAxNiBlbnRyaWVz +LCBuaGFzaCAldQoAAAAAAAAAAAAAAAAAbGUgY29uZmlndXJhdGlvbjogaGFzaCBtb2RlIHJlcXVp +cmVzIGF0IGVudHJpZXMgdG8gYmUgYSBwb3dlciBvZiAyLCBuaGFzaCAldQoAAABsZSBjb25maWd1 +cmF0aW9uOiByZXF1ZXN0ZWQgJXUgdGNhbSBlbnRyaWVzIGJ1dCBvbmx5ICV1IGF2YWlsYWJsZQoA +AAAAAAAAAAAAAAAAAGxlIGNvbmZpZ3VyYXRpb246IHRjYW0gcmVnaW9ucyBtdXN0IGhhdmUgbXVs +dGlwbGUgb2YgMzIgZW50cmllcywgbnJvdXRlICV1IG5jbGlwICV1IG5maWx0ZXIgJXUgbnNlcnZl +ciAldQoAAAAAAABvZmxkIHRwIHRpbWVyIHNldHRpbmdzIFRQX01TTCAweCUwOHggVFBfUlhUX01J +TiAweCUwOHggVFBfUlhUX01BWCAweCUwOHggVFBfUEVSU19NSU4gMHglMDh4IFRQX1BFUlNfTUFY +IDB4JTA4eAoAICAgICAgICAgICAgICAgICAgICAgICBUUF9LRUVQX0lETEUgMHglMDh4IFRQX0tF +RVBfSU5UVkwgMHglMDh4IFRQX0lOSVRfU1JUVC5pbml0X3NydHRfbWF4cnR0IDB4JTA0eCBUUF9J +TklUX1NSVFQuaW5pdF9zcnR0X2luaXRzcnR0IDB4JTA0eCBUUF9GSU5XQUlUMl9USU1FUiAweCUw +OHgKAAAAAAAAAAAAAABjb25maWd1cmF0aW9uIGZpbGUgcGFyc2VyIGVuY291bnRlcmVkIGVycm9y +IEAgbGluZSAldToKAAAAAAAAAAAAaHdfaTJjX3RyYW5zYWN0aW9uOiBuZGF0YSAldSBhZGRyX29w +IDB4JXggZGF0YVswXSAweCV4IGRpZmYgJXUKAGh3X2kyY190cmFuc2FjdGlvbjogbmRhdGEgJXUg +YWRkcl9vcCAweCV4IGRhdGFbMF0gMHgleCBkaWZmICV1IGRwb3MgJXUgY29udCAldSBmYWlsZWQg +d2l0aCBlcnIgJWQKAAAAAAAAAAAAAAAAAABpMmMgdHJhbnNhY3Rpb24gZmFpbGVkIHRvIGNvbXBs +ZXRlCgAAAAAAAAAAAAAAAABIT1NUIFBBR0VfU0laRSBbMHglMGx4XSB0b28gc21hbGwsIG1pbiBb +MHglMGx4XSByZXF1aXJlZAoAAAAAAAAAcGFnZSBzaXplIFslbHVdIG1pc21hdGNoCgAAAAAAAABQ +QUdFIHNpemUgJWx1IHVuc3VwcG9ydGVkLCBkZHAgZGlzYWJsZWQKAAAAAAAAAABIb3N0IHBhZ2Vf +c2l6ZSAlbHUsIGRkcF9pZHggJXUKAEZDb0UgRERQIGluaXQ6IGZjb2UgbGxpbWl0IDB4JXgsIGZj +b2UgdWxpbWl0IDB4JXggZ2JsIGxsaW1pdCAweCV4IGdibCB1bGltaXQgMHgleAoAAAAAAAAAAAAA +AAAAAEZDb0UgRERQIGluaXQ6IGZjb2UgcHBvZCBvZmYgMHgleCwgZmNvZSBzdCBwcG9kIGFkZHIg +MHgleCBmY29lIG51bSBwcG9kcyAweCV4CgAAZmNvZSB4Y2hnIG1nciBpbml0OiBOdW1iZXIgb2Yg +ZXhjaGFuZ2VzIGZvciBGQ29FIGlzICV4CgAAAAAAAAAAAFFTRlAgbW9kdWxlIHVucGx1ZyAtIHJl +aW5pdGlhbGl6aW5nIHJ4X2xvcyAgdG8gMHhmZgoAAAAAAAAAAAAAAABncGlvX3FzZnBfbW9kdWxl +X3VwZGF0ZTogY2hhbmdlZCByeF9sb3MgZnJvbSAweCV4IHRvIDB4JXgKAAAAAAAAZ3Bpb19xc2Zw +X21vZHVsZV91cGRhdGU6IGNoYW5nZWQgdHhfZGlzIGZyb20gMHgleCB0byAweCV4CgAAAAAAAENh +bGN1bGF0aW9uIG91dCBvZiBib3VuZHMgZnVyaW5nIGluaXQ6ICUjeCAlI3ggJSN4CgAAAAAAAAAA +AAAAAABxdWV1ZXNfcGVyX3BhZ2U6IHBmICV1IGhhcyBhIGJhcnNpemUgb2YgJXUtYnl0ZXMsIG9j +cV9zaXplICV1CgAAaHdfc2dlX21hbWVtX2NhbGM6IGVuY291bnRlcmVkIGVycm9yICVkCgAAAAAA +AAAAc2dlIHJlcXVpcmUgbmVxICV1IG5pcSAldSByb3VuZGluZyB0byAldSAldQoAAAAAaHdfc2dl +X21hbWVtX2luaXQ6IGVuY291bnRlcmVkIGVycm9yICVkCgAAAAAAAAAAaHdfZWRjX2Jpc3RbJXVd +OiBiaXN0X2NtZFsweCUwOHhdIGFkZHIgMHgleCBsZW4gMHgleAoAAAAAAAAAAAAAAGh3X2VkY19i +aXN0WyV1XTogZG9uZSwgZW5jb3VudGVyZWQgJXUgZXJyb3JzIG9uIGZpcnN0IGFuZCAldSBlcnJv +cnMgb24gc2Vjb25kIGF0dGVtcHQKAAAAAAAAAAAAAGZvaXNjc2lfYnllOmwyZGV2X2ZjLT5mbG93 +Y19pZCBbMHgleF0sIGwyZGV2X2ZjLT5mbG93Y19wY2llX3BmbiBbMHgleF0sIGwyZGV2X2ZjLT5m +bG93Y19wY2llX3ZmbiBbMHgleF0sIHBvcnQgWzB4JXhdCgAAAAAAAAAAAAAAZm9pc2NzaV9ieWU6 +dmxhbmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCB2bGFuZGV2X2ZjLT5mbG93Y19wY2llX3BmbiBb +MHgleF0sIHZsYW5kZXZfZmMtPmZsb3djX3BjaWVfdmZuIFsweCV4XSwgcG9ydCBbMHgleF0KAAAA +AABod194Z21fbGVkX2xpbmtfdXAgbGVkMCBjb25maWc6ICV1CgAAAAAAAAAAAAAAAABod194Z21f +bGVkX2xpbmtfdXAgbGVkMSBjb25maWc6ICV1CgAAAAAAAAAAAAAAAABoc3Nfc2lnZGV0WyV1XTog +aHNzX3NpZ2RldCBjaGFuZ2VkIHRvIDB4JXgKAAAAAABwZm4gJXUgdmZuICV1IGhhcyBwbmR0eG5z +ICV1IGFmdGVyIDEwMG1zCgAAAAAAAABiYWQgbWFpbGJveCBjbWQ6IHBmbiAweCV4IHZmbiAweCV4 +OyBvcGNvZGUgMHgleCA+IExBU1RDMkUgMHgleAoAbWFpbGJveCBjbWQgbm90IHlldCBzdXBwb3J0 +ZWQ6IHBmbiAweCV4IHZmbiAweCV4OyBvcGNvZGUgMHgleAoAAGJhZCBtYWlsYm94IGNtZDogcGZu +IDB4JXggdmZuIDB4JXg7IG9wY29kZSAweCV4IGlzIHZhbGlkIHBvc3QgZGV2aWNlIGluaXQgb25s +eQoAYmFkIG1haWxib3ggY21kOiBwZm4gMHgleCB2Zm4gMHgleDsgb3Bjb2RlIDB4JTAyeCByYW1h +c2sgMHgleCBjbWQgcmFtYXNrIDB4JXgKAABiYWQgbWFpbGJveCBjbWQ6IHBmbiAweCV4IHZmbiAw +eCV4OyBvcGNvZGUgMHglMDJ4IGxlbjE2IDB4JXggdmVyc3VzIGV4cGVjdGVkIGxlbjE2IDB4JXgK +AAAAAAAAAABpbnN1ZmZpY2llbnQgY2FwcyB0byBwcm9jZXNzIG1haWxib3ggY21kOiBwZm4gMHgl +eCB2Zm4gMHgleDsgcl9jYXBzIDB4JXggd3hfY2FwcyAweCV4IHJlcXVpcmVkIHJfY2FwcyAweCV4 +IHdfY2FwcyAweCV4CgAAAAAAAAAAAGluc3VmZmljaWVudCBjYXBzIHRvIHByb2Nlc3MgbWFpbGJv +eCBjbWQ6IHBmbiAweCV4IHZmbiAweCV4OyByX2NhcHMgMHgleCB3eF9jYXBzIDB4JXggcmVxdWly +ZWQgcl9jYXBzIDB4JXggd19jYXBzIDB4JXgKAAAAAAAAAAAAVlBEIHJlZ2lvbiBpcyB0b28gc21h +bGwgKFNFUkNGR19TUl9QRk5WUERTSVpFIDB4JXgpCgAAAAAAAAAAAAAAAGNmOiBmYWlsZWQgdG8g +YWxsb2NhdGVkIG1lbW9yeSBmb3IgY29uZmlndXJhdGlvbiBmaWxlLCByZXQgJWQKAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAACCAAABIAAAAAAAAACCAAABAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAGgIAAAAAAAAAAAAAAAACAAAAAAAAAAAACgAAAAAAAAAAAAAIAAwAAAAABYAgAAAAA +AwAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAgAAAAAAAAAAACAAAAAAAAAAAAAAAAEAA4AAAAAAAAAA +AAAAAgAAAAAAAAAAACADgAAAAAAAAAAAABACgACAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAA +AAAAAAAAAoAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAoAAAAAAAAAAAAEAAwAAAAAAAAAAAAACgwAA +AAAAAAAAABACgAAAAAAAAAAAADAAAwAAAAAAAAgAADAAAwAAAAAAAAAAADAFgwAAAAAAAAgAADAF +gwAAAAAAAAAAADAEgwAAAAAAAAgAADAEgwAAAAAAAAAAADADAwAAAAAAAAgAADADAwAAAAAAAAAA +ADgDAwAAAAAAAAAAADgFgwAAAAAAAAAAADgEgwAAAAAAAAAAADgAAwAAAAAAAAAAADQGggAAAAAA +AAAAADwDggAAAAAAAAAAADwAAwAAAAAAAAgAADwAAwAAAAAAAAAAADwEgwAAAAAAAAAAADwFAwAA +AAAAAAAAAD0EAwAAAAAAAAAAADwDgwAAAAAAAAAAACwAAgAAAAAAAAAAACwFggAAAAAAAAAAACwF +AgAAAAAAAAAAABAGgAAAAAAAAAAAABAGgsAAAAAAAAAAABAGgoAAAAAAAAAAAAAOggAAAAAAAAAA +ABAHgoAAAAAgAAAAAAAHggAAAAAgAAAAABAHAoAAAAAAAAAAABAHAoAAAAAAAAAAABAHAoAAAAAA +AAAAAAAHAgAAAAAgAAAAABAXgwAAAAAAAAgAABAXgwAAAAAAAAgAABAAAAAAAAAAAAAAABAGA4AA +AAAAAAAAAAAOAwAAAAAAAAAAABAGA0AAAAAAAAAAABAGAwAAAAAAAAAAABAGAAAAAAAAAAAAAAAG +A4AAAAAAAAAAAAAGAwAAAAAAAAAAAAAOAgAAAAAAAAAAAAAOAgAAAAAAAAAAABAGAgAAAAAAAAAA +ABAGAgAAAAAAAAAAABAGAoAAAAAAAAAAABAGAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAIAAAAAAAAAAAAQAwAAAAAAAAgAAAAAAAAAAAAAAAAAAP////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +/wAAACAAAAAAwAAAAAAAACAAAAAA4AAAAAAAAAACAAAAAAAAAEAAAAAAAAAAAAAAAAAAASEAAAAA +AAAAAAABASAAAAAAAAAAAAAAAgAAAAQABAAAAAAFAAAABAAAAAAAAAAAAKAAAAAAgAAAAACAAEAA +AAAAAAIAAACAACAAAAAAAAIAAAEAQAAAAAAAAAAAAAEAQgAAAAAAAAAAAAAAIAAAAAAAAAAAAAIQ +IAAAAAAAAAAAAAIMAgAAAAAAAAAAAACFAgAAAAQAAAAAAACAQgAAAAAAAAAAAAIAIgAAAAAAAAAA +AACAQQAAAAAAAAAAAACAQYAAAAAAAAAAAAIAIQAAAAAAAAAAAAAQIIAAAAAAAAAAAAIlAIAAAAAA +AAAAAAAFAAAAAAAAAAAAAAiIBIAAAAAAAAAAAAiIBIAAAAAAAAAAAAiiAIAAAAAAAAAAAAiiAIAA +AAAAAAAAAAijAIAAAAAAAAAAAAijAIAAAAAAAAAAAAikgIAAAAAAAAAAAAikgIAAAAAAAAAAAASk +gMAAAAAAAAAAAASiAMAAAAAAAAAAAASjAMAAAAAAAAAAAASIBMAAAAAAAAAAAAAJAYAAAAAAAAAA +AAIMAIAAAAAAAAAAAACIBMAAAAAAAAAAAACIBIAAAAAAAAAAAAILAIAAAAAAAAAAAACKgIAAAAAA +AAAAAAALgIAAAAAAAAAAAACMAIAAAAAAAAAAAAIgEIAAAAAAAAAAAAIKAIAAAAAAAAAAAAIKgIAA +AAAAAAAAAAAJAoAAAAAAAAAAAAABAQAAAAAAAAAAAAABAUAAAAAAAAAAAAABAIAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAgRAAAAAAAAAAAAAAgQgAAAAAAAAAAAAAgQQAAAAAAAAA +AAAAgYAAAAAAAAAAAACAAMAAAAAAAAAAAACAAKAAAAAAAAAAAAAACAAAAAAAAAAAAACBgAAAAAAA +AAAAAACBgIAAAAAAAAAAAACJgIAAAAAAAAAAAACJgMAAAAAAAAAAAAABggAAAAAAAAAAAAIBgAAA +AAAAAAAAAAIBgIAAAAAAAAAAAABBgYAAAAAAAAAAAAIBgYAAAAAAAAAAAABJgYAAAAAAAAAAAAIJ +gYAAAAAAAAAAAAIBgQAAAAAAAAAAAABBgQAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAIAAAAAAAAA +ABAAAAAAAAAAAAAAAACAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////wAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAACACSAAAAAAAAAANmACAAQAAAAAAIAJIAAAAAAAAAA3IBJQRA +AAAAAAAAAAAAAAAAAAADlgAgAEAAAAAACAAAAAIAiAOHAABWACAAQAAAAAAAAAAAAAAAAAAAA5YA +IABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAAAAAAAAAA +A5YAIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAAAAAA +AAAAA5YAIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAA +AAAAAAAAA5YAIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAA +AAAAAAAAAAIAA5YAJgRAAAAAAAhHIAEEAAACsgAC0gUgJEAAAAAAAAAAAAAAAAAAAAOWACAAQAAA +AAAARyABBgyhgrBAAZIEICRAAAAAAABHIAEEDKBCs4ACEgUgJEAAAAAACAAAAAIAiAOFAACWASAA +QAAAAAAIAAAAAgCIA4UAAJYBIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAAAAAAAAAAAAAAAAOW +ACAAQAAAAAANxRK6ArCA0xRUi+JKRiRAAAAAAAXFEroCt4DTFFSLYkmmJEAAAAAABcUSogawgNMU +VIviSkYkQAAAAAANxRKiBreA0xRUi2JJpiRAAAAAAAXFEqIGsIDTFFSL4kpGJEAAAAAADcUSoga3 +gNMUVItiSaYkQAAAAAAFxRKiBrCA0xRUi+JKRiRAAAAAAA3FEqIGt4DTFFSLYkmmJEAAAAAACcQQ +oAIAgJAAAItiacYkQAAAAAABxBCgBrCAkwZUi2JpxiRAAAAAAAHEEKAGsICTBlSLYmnGJEAAAAAA +AcUQuAawgJMWVItiSMYkQAAAAAAIoRCIAgCBWBIAC1IApiRAAAAAAAnAEJACsIADFlSKkgHGJEAA +AAAACcAQuAawgAMQlIviAkYkQAAAAAAJwBC4ArSAAxCUi2IBpiRAAAAAAAnAELgCtIADEJSLYgGm +JEAAAAAACcAQuAK0gAMQlItiAaYkQAAAAAAJwBC4ArSAAxCUi2IBpiRAAAAAAAGgEJAGtIADEJSL +YgGmJEAAAAAAAcAQgAKwgAMUVIpSAMYkQAAAAAABwBCAArCAAxRUilIAxiRAAAAAAAHAEIACsIAD +FFSKUgDGJEAAAAAACEcgAQQAAAKyAALSBSAkQAAAAAAAgQAAAgCFWAdAC1IApiRAAAAAAACBAAAC +AIVYB0ALUgCmJEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAAAAAABgChgABAAVYAIABAAAAAAAAA +AAAEAKBAAYAB1gAgAEAAAAAACIEAAAIAhVmABAtSAKYkQAAAAAAJYUAAAAAAGAAAA0IBJqRAAAAA +AAhAAAAAAAAAAAADUgEmJEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAIAAAAAgCIA4cAA9YAJgRA +AAAAAAgAAAACAIgDhwAD1gAmBEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAAAAAAAAAAA5YA +IABAAAAAAAAAAAAEAKBAAYAB1gAgAEAAAAAACcAQuAK0gAMQlItiAaYkQAAAAAAAAAAAAAAAAAIA +A5YAJgRAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAACAAAAAIAiAOFAACWASAAQAAAAAAAAAAABACg +QAGAAdYAIABAAAAAAAAAAAAEAKBAAYAB1gAgAEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAIoRCI +AgCBWBAACRIBpiRAAAAAAAAAAAAEAKBAAYAB1gAgAEAAAAAAAAAAAAYAoYAAQAFWACAAQAAAAAAI +AAAAAgCIA4VACNICRiRAAAAAAAnFEqIClIjSEICLIkimJEAAAAAACcAQgAKkiACHVItSAaYkQAAA +AAAJwBCABrSIAwEUi1IBpiRAAAAAAA3AAAACsIDDFlSL4gNGJEAAAAAAAAAAAAAAAAAAAAOWACAA +QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAgAMAAEAAAAAgAAAgAmJEAAAAAAAEcwAAYDIAK3AAgCAcAkQAAAAAAI +AwAAAgagCrUACAIAxiRAAAAAAAAAAAAAAAAAAgAAAgAmJEAAAAAAACBQAAQAAAACAAACACYkQAAA +AAAIYCAAhAAAAAAAAAYAIABAAAAAAAhgIACEAAAAAgEwAgAmJUAAAAAACGAAAAQAhAGABAQCAcYk +wAAAAAABwAAAAkOAAwIMiAIBpiRAAAAAAAgAYAAEAAAAAgAAAgAmJEAAAAAACABgAAQAAAAAAAAE +ASAAQAAAAAAAAAAAAAAAAAAAAAQBIABAAAAAAAQIFIAGCgAABwFMAiCmJkAAAAAACIAAAAYAhAGA +BAgCAaYmQAAAAAAAQAAAAgCgAAJACAIBpiRAAAAAAAAAAAAAAAAAAgAAAgAmJEAAAAAABAAAAAKE +AAMCiggCBKYkQAAAAAAAAAAAAAAAAAIAAAYBIEhAAAAAAAAgUAAEAAAAAgAAAgAmJEAAAAAACGAg +AIQAAAACAAAGACYEQAAAAAAIYCAAhAAAAAIAAAIBJiVAAAAAAAhgAAAEAIQBgAQEAgHGJMAAAAAA +CABgAAQAAAAAAAAEASAAQAAAAAAAAAAAAAAAAAAAAAIAJkxwAAAAAAAAAAAAAAAAAAAABgEgAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAACLSQBAkWBAIExiRAAAAAAAHAAAAItJAE +CRYEAgTGJEAAAAAABAh0gEwJAABQAFwCYeYkQAAAAAAMCHSARAAAAFIAQAJhJiRAAAAAAAgCEKAE +AAAAAAEAAgAmJEAAAAAACAIQoAQAAAAAAQACACYkQAAAAAAECHQAQgEAAAcAiAJgxiRAAAAAAA3I +FAACCQAABECcAmDmJEAAAAAACcgQgAa0kAQClIgCZcYkQAAAAAANyHQASLSQAwCUiAJgpiTAAAAA +AA3IdABItJADAJSIAmCmJMAAAAAACEcAAAQAAAAAAAACASAkQAAAAAAIRwAABAAAAAIAAAIFICRA +AAAAAABHIAEMByHCtwAIAgHAJEAAAAAAAEcgAQwHIcK3AAgCAcAkQAAAAAAARyABDAchwrcACAIB +wCRAAAAAAAAAIAEIAIQABUCIAgHGJMAAAAAAAAAgAQgAhAAFQIgCAcYkwAAAAAAAACABCACEAAVA +iAIBxiTAAAAAAAAAIAGGggABAsCIAgPGJMAAAAAAAAAgAYKCAAACwIgCA8YkwAAAAAAJwCABgqSA +AQVAiAIBxiTAAAAAAAgAAAAMAIQABUCIAgHGJMAAAAAAAAAgAYaCAAECwIgCA8YkwAAAAAAAACAB +goIAAADAiAICpiTAAAAAAAnAIAGCpIABBUCIAgHGJMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAIAAAABAAEJAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtnbG9iYWxdCnJz +c19nbGJfY29uZmlnX21vZGU9YmFzaWN2aXJ0dWFsCnJzc19nbGJfY29uZmlnX29wdGlvbnM9dG5s +bWFwZW4saGFzaHRvZXBsaXR6LHRubGFsbGxrcApyZWdbMHgxMDA4XT0weDQwODEwLzB4MjFjNzAK +cmVnWzB4MTAwY109MHgyMjIyMjIyMgpyZWdbMHgxMGEwXT0weDAxMDQwODEwCnJlZ1sweDEwNDRd +PTQwOTYKcmVnWzB4MTA0OF09NjU1MzYKcmVnWzB4MTA0Y109MTUzNgpyZWdbMHgxMDUwXT05MDI0 +CnJlZ1sweDEwNTRdPTkyMTYKcmVnWzB4MTA1OF09MjA0OApyZWdbMHgxMDVjXT0xMjgKcmVnWzB4 +MTA2MF09ODE5MgpyZWdbMHgxMDY0XT0xNjM4NApyZWdbMHgxMGE0XT0weGEwMDBhMDAwLzB4ZjAw +MGYwMDAKcmVnWzB4MTBhOF09MHgyMDAwLzB4MjAwMApzZ2VfdGltZXJfdmFsdWU9NSwxMCwyMCw1 +MCwxMDAsMjAwCnJlZ1sweDdkYzBdPTB4NjJmODg0OQpmaWx0ZXJNb2RlPWZyYWdtZW50YXRpb24s +bXBzaGl0dHlwZSxwcm90b2NvbCx2bGFuLHBvcnQsZmNvZQp0cF9wbXJ4PTMwCnRwX3BtcnhfcGFn +ZXNpemU9NjRLCnRwX25yeGNoPTAKdHBfcG10eD01MAp0cF9wbXR4X3BhZ2VzaXplPTY0Swp0cF9u +dHhjaD0wCltmdW5jdGlvbiIwIl0KbnZmPTE2Cnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTEK +bmlxZmxpbnQ9OApuZXRoY3RybD04Cm5lcT0xNgpuZXhhY3RmPTgKY21hc2s9YWxsCnBtYXNrPTB4 +MQpbZnVuY3Rpb24iMSJdCm52Zj0xNgp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT0xCm5pcWZs +aW50PTgKbmV0aGN0cmw9OApuZXE9MTYKbmV4YWN0Zj04CmNtYXNrPWFsbApwbWFzaz0weDIKW2Z1 +bmN0aW9uIjIiXQpudmY9MTYKd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9MQpuaXFmbGludD04 +Cm5ldGhjdHJsPTgKbmVxPTE2Cm5leGFjdGY9OApjbWFzaz1hbGwKcG1hc2s9MHg0CltmdW5jdGlv +biIzIl0KbnZmPTE2Cnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTEKbmlxZmxpbnQ9OApuZXRo +Y3RybD04Cm5lcT0xNgpuZXhhY3RmPTgKY21hc2s9YWxsCnBtYXNrPTB4OApbZnVuY3Rpb24iNCJd +Cnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTI4Cm5pcWZsaW50PTE3MApuZXRoY3RybD0xMDAK +bmVxPTI1NgpuZXhhY3RmPTQwCmNtYXNrPWFsbApwbWFzaz1hbGwKbmV0aG9mbGQ9MTAyNApucm91 +dGU9MzIKbmNsaXA9MzIKbmZpbHRlcj00OTYKbnNlcnZlcj00OTYKbmhhc2g9MTIyODgKcHJvdG9j +b2w9bmljX3ZtLG9mbGQscmRkcCxyZG1hYyxpc2NzaV9pbml0aWF0b3JfcGR1LGlzY3NpX3Rhcmdl +dF9wZHUKdHBfbDJ0PTMwNzIKdHBfZGRwPTIKdHBfZGRwX2lzY3NpPTIKdHBfc3RhZz0yCnRwX3Bi +bD01CnRwX3JxPTcKW2Z1bmN0aW9uIjUiXQp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT00Cm5p +cWZsaW50PTM0Cm5ldGhjdHJsPTMyCm5lcT02NApuZXhhY3RmPTQKY21hc2s9YWxsCnBtYXNrPWFs +bApuc2VydmVyPTE2Cm5oYXNoPTIwNDgKdHBfbDJ0PTEwMjQKcHJvdG9jb2w9aXNjc2lfaW5pdGlh +dG9yX2ZvZmxkCnRwX2RkcF9pc2NzaT0yCmlzY3NpX250YXNrPTIwNDgKaXNjc2lfbnNlc3M9MjA0 +OAppc2NzaV9uY29ubl9wZXJfc2Vzc2lvbj0xCmlzY3NpX25pbml0aWF0b3JfaW5zdGFuY2U9NjQK +W2Z1bmN0aW9uIjYiXQp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT00Cm5pcWZsaW50PTM0Cm5l +dGhjdHJsPTMyCm5lcT02NgpuZXhhY3RmPTMyCmNtYXNrPWFsbApwbWFzaz1hbGwKbmhhc2g9MjA0 +OApwcm90b2NvbD1mY29lX2luaXRpYXRvcgp0cF9kZHA9MgpmY29lX25mY2Y9MTYKZmNvZV9udm5w +PTMyCmZjb2VfbnNzbj0xMDI0CltmdW5jdGlvbiIxMDIzIl0Kd3hfY2Fwcz1hbGwKcl9jYXBzPWFs +bApudmk9NApjbWFzaz1hbGwKcG1hc2s9YWxsCm5leGFjdGY9OApuZmlsdGVyPTE2CltmdW5jdGlv +biIwLyoiXQp3eF9jYXBzPTB4ODIKcl9jYXBzPTB4ODYKbnZpPTEKbmlxZmxpbnQ9NApuZXRoY3Ry +bD0yCm5lcT00Cm5leGFjdGY9NApjbWFzaz1hbGwKcG1hc2s9MHgxCltmdW5jdGlvbiIxLyoiXQp3 +eF9jYXBzPTB4ODIKcl9jYXBzPTB4ODYKbnZpPTEKbmlxZmxpbnQ9NApuZXRoY3RybD0yCm5lcT00 +Cm5leGFjdGY9NApjbWFzaz1hbGwKcG1hc2s9MHgyCltmdW5jdGlvbiIyLyoiXQp3eF9jYXBzPTB4 +ODIKcl9jYXBzPTB4ODYKbnZpPTEKbmlxZmxpbnQ9NApuZXRoY3RybD0yCm5lcT00Cm5leGFjdGY9 +NApjbWFzaz1hbGwKcG1hc2s9MHg0CltmdW5jdGlvbiIzLyoiXQp3eF9jYXBzPTB4ODIKcl9jYXBz +PTB4ODYKbnZpPTEKbmlxZmxpbnQ9NApuZXRoY3RybD0yCm5lcT00Cm5leGFjdGY9NApjbWFzaz1h +bGwKcG1hc2s9MHg4Cltwb3J0IjAiXQpkY2I9cHBwLGRjYngKYmdfbWVtPTI1CmxwYmtfbWVtPTI1 +Cmh3bT0zMApsd209MTUKZHdtPTMwCltwb3J0IjEiXQpkY2I9cHBwLGRjYngKYmdfbWVtPTI1Cmxw +YmtfbWVtPTI1Cmh3bT0zMApsd209MTUKZHdtPTMwCltwb3J0IjIiXQpkY2I9cHBwLGRjYngKYmdf +bWVtPTI1CmxwYmtfbWVtPTI1Cmh3bT0zMApsd209MTUKZHdtPTMwCltwb3J0IjMiXQpkY2I9cHBw +LGRjYngKYmdfbWVtPTI1CmxwYmtfbWVtPTI1Cmh3bT0zMApsd209MTUKZHdtPTMwCltmaW5pXQp2 +ZXJzaW9uPTB4MTQyNTAwMGQKY2hlY2tzdW09MHgyNWMyZjc4MgoAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW2dsb2JhbF0KcnNzX2dsYl9j +b25maWdfbW9kZT1iYXNpY3ZpcnR1YWwKcnNzX2dsYl9jb25maWdfb3B0aW9ucz10bmxtYXBlbixo +YXNodG9lcGxpdHosdG5sYWxsbGtwCnJlZ1sweDEwMDhdPTB4NDA4MTAvMHgyMWM3MApyZWdbMHgx +MDBjXT0weDIyMjIyMjIyCnJlZ1sweDEwYTBdPTB4MDEwNDA4MTAKcmVnWzB4MTA0NF09NDA5Ngpy +ZWdbMHgxMDQ4XT02NTUzNgpyZWdbMHgxMDRjXT0xNTM2CnJlZ1sweDEwNTBdPTkwMjQKcmVnWzB4 +MTA1NF09OTIxNgpyZWdbMHgxMDU4XT0yMDQ4CnJlZ1sweDEwNWNdPTEyOApyZWdbMHgxMDYwXT04 +MTkyCnJlZ1sweDEwNjRdPTE2Mzg0CnJlZ1sweDEwYTRdPTB4YTAwMGEwMDAvMHhmMDAwZjAwMApy +ZWdbMHgxMGE4XT0weDIwMDAvMHgyMDAwCnNnZV90aW1lcl92YWx1ZT01LDEwLDIwLDUwLDEwMCwy +MDAKcmVnWzB4N2RjMF09MHg2MmY4ODQ5CmZpbHRlck1vZGU9ZnJhZ21lbnRhdGlvbixtcHNoaXR0 +eXBlLHByb3RvY29sLHZsYW4scG9ydCxmY29lCnRwX3Btcng9MzAKdHBfcG1yeF9wYWdlc2l6ZT02 +NEsKdHBfcG10eD01MAp0cF9wbXR4X3BhZ2VzaXplPTY0SwpbZnVuY3Rpb24iMCJdCnd4X2NhcHM9 +YWxsCnJfY2Fwcz1hbGwKbnZpPTI4Cm5pcWZsaW50PTE3MApuZXRoY3RybD05NgpuZXE9MjUyCm5l +eGFjdGY9NDAKY21hc2s9YWxsCnBtYXNrPWFsbApucm91dGU9MzIKbmNsaXA9MzIKbmZpbHRlcj00 +OApuc2VydmVyPTMyCm5oYXNoPTAKcHJvdG9jb2w9bmljX3ZtLG9mbGQscmRkcCxyZG1hYyxpc2Nz +aV9pbml0aWF0b3JfcGR1LGlzY3NpX3RhcmdldF9wZHUKdHBfbDJ0PTMwNzIKdHBfZGRwPTIKdHBf +ZGRwX2lzY3NpPTIKdHBfc3RhZz0yCnRwX3BibD01CnRwX3JxPTcKW2Z1bmN0aW9uIjEiXQp3eF9j +YXBzPWFsbApyX2NhcHM9YWxsCm52aT00Cm5pcWZsaW50PTM0Cm5ldGhjdHJsPTMyCm5lcT02Ngpu +ZXhhY3RmPTMyCmNtYXNrPWFsbApwbWFzaz1hbGwKbmhhc2g9MApwcm90b2NvbD1mY29lX2luaXRp +YXRvcgp0cF9kZHA9MgpmY29lX25mY2Y9MTYKZmNvZV9udm5wPTMyCmZjb2VfbnNzbj0xMDI0Cltm +dW5jdGlvbiIxMDIzIl0Kd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9NApjbWFzaz1hbGwKcG1h +c2s9YWxsCm5leGFjdGY9OApuZmlsdGVyPTE2CltmdW5jdGlvbiIwLyoiXQp3eF9jYXBzPTB4ODIK +cl9jYXBzPTB4ODYKbnZpPTEKbmlxZmxpbnQ9NApuZXRoY3RybD0yCm5lcT00Cm5leGFjdGY9NApj +bWFzaz1hbGwKcG1hc2s9MHgxCltmdW5jdGlvbiIxLyoiXQp3eF9jYXBzPTB4ODIKcl9jYXBzPTB4 +ODYKbnZpPTEKbmlxZmxpbnQ9NApuZXRoY3RybD0yCm5lcT00Cm5leGFjdGY9NApjbWFzaz1hbGwK +cG1hc2s9MHgyCltwb3J0IjAiXQpkY2I9cHBwLGRjYngKYmdfbWVtPTI1CmxwYmtfbWVtPTI1Cmh3 +bT0zMApsd209MTUKZHdtPTMwCltwb3J0IjEiXQpkY2I9cHBwLGRjYngKYmdfbWVtPTI1CmxwYmtf +bWVtPTI1Cmh3bT0zMApsd209MTUKZHdtPTMwCltwb3J0IjIiXQpkY2I9cHBwLGRjYngKYmdfbWVt +PTI1CmxwYmtfbWVtPTI1Cmh3bT0zMApsd209MTUKZHdtPTMwCltwb3J0IjMiXQpkY2I9cHBwLGRj +YngKYmdfbWVtPTI1CmxwYmtfbWVtPTI1Cmh3bT0zMApsd209MTUKZHdtPTMwCltmaW5pXQp2ZXJz +aW9uPTB4MTQyNTAwMGMKY2hlY2tzdW09MHg0YzU2NjYzOQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= +==== diff --git a/sys/dev/cxgbe/firmware/t4fw-1.8.4.0.bin.uu b/sys/dev/cxgbe/firmware/t4fw-1.8.4.0.bin.uu deleted file mode 100644 index 129a69f..0000000 --- a/sys/dev/cxgbe/firmware/t4fw-1.8.4.0.bin.uu +++ /dev/null @@ -1,8237 +0,0 @@ -/*- - * Copyright (c) 2013 Chelsio Communications, Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - */ -begin-base64 644 t4fw -AAADkgEIBAAAAQkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAA3cDhgONAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAENoZWxzaW8gRlcgUlVOTUVNIERFQlVHPTAgKEJ1aWx0IFRodSBGZWIgIDcgMTU6 -Mzg6MjYgUFNUIDIwMTMgb24gY2xlb3BhdHJhLmFzaWNkZXNpZ25lcnMuY29tOi9ob21lL2Zpcm13 -YXJlL2N2cy9mdy1yZWxlYXNlKSwgVmVyc2lvbiBUNHh4IDAxLjA4LjA0LjAwAAAAAAAAAJ/jNKZg -AMQA4QAwuHj///8f/OFAgAAAAeEAe3AAABAAH//7gOEAYBDhAZRwIAAAAOEBnAThAHkAAAIAQOEA -eYAABgBAAAIACgAGAArhAHkEAAoAAIAAAQDhAHs84QB7ROEAe+TiAAAAAAEAAOEAe5AgAAAAAACA -AOEAewAAAEAB4QB7nAAAQABERERC4AAAAOMABHNERERA4wAIACAAAlwAAAAAH/+NIAAAAAAf/40k -AAAAAB//jSgAAAAAH/+NLB//wAAAAAAAAAAAAMAAEv/OE//OhCAEMwGTIBH/zRL/zZIQEf/NEv/N -khAR/80B9DER/8yQEBH/zCIK/5IQAOQxAAUxAQIAEv/JAucxAhYAEf/IgRABAV/AIQIRAckUEf/F -Ev/FkhAR/8US/8WSEGAAEgAAABH/vxL/w5IQEf+/Ev/CkhCBEBH/wcAgkhES/8CSEsAgkhMS/7+S -EIIQAvJQZS/3Ef+9xy+SEBH/vJIQEv+8E/+8kyDAMpMhE/+7kyKCIhL/uhP/upMgIyIhFP+5BDMB -yTgT/7iDMAODFAgzERT/tqQzkyET/6qTImAACMIwkyET/6eTIhL/sZAgkCGQIpAjkCSQJZAmkCeQ -KJApkCqQK5AskC2QLpAvICYQICYRgiIS/6TAMC03MC03NC03OC03PCM9AXIz7QACABL/oSMKAC83 -AC83EC83IC83MCM9AXIz7QACABL/lsAwKDcwKDc0KDc4KDc8Iz0BcjPtAwIAEv+UwDAnNwAnNxAn -NyAnNzAjPQFyM+0DAgAS/44V/48W/4/AMNcgBWYBYAAWAAAAAAQ2BQACANMP0w8FMwxuOxQHRxQH -BEN2MeYENgUFMwxvO+0AAgAS/4IV/4AjCgACJwIHBEMEPgUFMwwHRxRvO/ADAgAS/3zJLoMghCGF -IrwidDsOhlC0VZYwtDN0M/Rj/+YAZT/iZV/fEv9wwDIDLgUDAgAS/2fAMCg3QCg3RCg3SCg3TCM9 -AXIz7QMCAAACABL/ai0nAMARAUkxAEgxAQIAwAAU/2YE0jEV/2WUUBT/ZQTTMRX/ZZRQFP9kBNQx -Ff9klFAU/2QE1TEV/2OUUBD/YwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/AAA -H/wAAOMACfgf/AAAH/wAAOMACfgf/AAAH/wAAOMACfgf/4AAH/+GAOMACfgf/4YAH/+GAOMAD/gf -/4YAH/+GAOMAD/gf/4YAH/+HdOMAD/gf/4d0H/+NIOMAEWwf/40gH/+nhOMAFxgf/6eEH/+nhOMA -MXwf/8AAH//8ZeMAMXwgAAAAIAABauMAbeQgAAF4IAABfOMAb1AgAAF8IAABheMAb1QgAAGYIAAB -nOMAb2AgAAGcIAABpeMAb2QgAAG4IAABvOMAb3AgAAG8IAABxeMAb3QgAAHYIAAB2OMAb4AgAAHc -IAAB4uMAb4AgAAH4IAAB+OMAb4ggAAH8IAAB/OMAb4ggAAIYIAACGOMAb4ggAAIcIAACHOMAb4gg -AAI4IAACOOMAb4ggAAI8IAACPOMAb4ggAAJYIAACWOMAb4ggAAJcIAACYuMAb4ggAAJ4IAACeOMA -b5AgAAJ8IAACguMAb5AgAAKYIAGaouMAb5ggAoAAIAKTYOMCB6QgApNgIAKTYOMCGwQgApNgIAYP -KOMCGwQgBg8wIAYT8OMFltQgBoAAIAaNUOMFm5QgBo1QIAdgsuMFqOQgB2DAIAdhjOMGfFQgCMAA -IAjAAOMGfSAgCMAAIAjAAOMGfSAgCMAAIAkvL+MGfSAAAAAAAAAAAAAAAAAgAAYvIAAGICAACjkg -AAYgIAAJpSAABiAgAAbZIAAJPSAACMIgAAYgIAAIcSAACCQgAAe5IAAGDSAAB2QgAAYgIAAGICAA -BiAgAAb6AAAAAP///////w/8///w////APwgAItrIACMqyAAjNsgAIyhIACMYSAAjFcgAIwcIACM -EiAAjAggAIu4IACM2SAAi64gAIuUAAAAAAAAAAAAAAAAAAAACgAAAAoAAAAUAAAACgAAAAoAAAAK -AAAACgAAAAoAAAAKAAAAAAAAAAAAAAAAAAAIAAAAEAAAAEAAAAEAAAAACAAAABAAAABAAAABAAAA -BAAAABAAAABAAAABAAAAIAbKiyAGycIgBsshIAbLCCAGyu8gBsrWIAbKvSAGyqQgQIAAAAAAAP8Y -MGBgAAAA/wABAgIAAAAQIEAAAAAAAAQAAgABAACAAEAAIAAQAAggBwDOIAcAziAHAIEgBwBIIAb/ -nSAG/2ggBv9oIAcAziAHAM4gBv9oIAb/gyAG/4MgBwDOIAcAziAHAM4gBwDOIAcAziAHAM4gBwDO -IAcAziAHAM4gBwDOIAcAziAHAM4gBwDOIAcAziAHAM4gBwDOIAcAziAHAM4gBwDOIAcAISACiqgA -AAABIAKKrAAAAAIgAo3wAAAA/yACidwAAAD/IAKJ3AAAAAAgAo3wAAAAACACieAAAAABIAKJ6AAA -AAQgAonwAAAACCACifwAAAAQIAKKBAAAACAgAooMAAAAQCACihQAAACAIAKKKAAAAQAgAoo8AAAC -ACACilQAAAQAIAKKaAAACAAgAop4AAAQACACioQAACAAIAKKmAAAQAAgAonIAAAAECACidAAAAAR -IAKJSAAAAQAgAolUAAAAgCACiWQAAABAIAKJdAAAACAgAomEAAAAECACiZQAAAAIIAKJoAAAAAQg -AomsAAAAAiACibgAAAABAAAAAAAAAAAgAojoAAAAASACjfwAAAACIAKI8AAAAAQgAoj4AAAACCAC -iQAAAAAQIAKOBAAAACAgAokEAAAAQCACiRAAAACAIAKJHAAAAQAgAokoAAACAAAAAAEAAAABAAAA -AQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAH -AAAABwAAAAYAAAAGAAw1AAAQRqoAFFhVABhqAAAAK2gAACODAAAYagAADQYAAAsqAAAAAAAAAAAA -AAAAAABoKwAAaCsAAGyCAABvnAAASmgAAEpoAABNKQAASmgAAE7qAABMmAAAUj0AAE+4AAGGoAAB -hqAAAgjWAAII1gACCNUAAgjVAAKLCwACiwsAAgjVAAK2cgACtnIAAw1AAAQGBwAAAAAAAAAAAAAA -AAACAgUFCAgLCw4OEREUFBcXGhodHSAgIyMmJikpLCwvLzIyNTU4ODs7AAAAAAAAACAEkYAgAWn4 -IAA1yCABQhggAWWAIAFe0CABJAggA6KkH//rIB//5uAgAI1sH//azCAAXFQgAE7gAAAAAAAAAAAg -AUOQIAB7CAAAAAAAAAAAH//U4B//xggf/8PoH//BmCAASnAgAEKsIAA/4CAAg/gf/99YAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgARGgIAFRqCAAlcggAJT8H//w -KB//z/wf/8tAIAB4VCAE6eggAQXwIADkxCAAzJggAMb8IAC5QCAArCwgAJiAIASVLCADu5QgAPcw -IAPbiCABliwgAFwUAAAAACAAliQgBVKUIACK4CABScQgADI4AAAAAAAAAAAAAAAAH//zUCAAlegg -A75EAAAAAAAAAAAgAw1UIAAq2CAAMUQgACdoAAAAACAAIRggACPYIAAdjAAAAAAgAC+cIAD66AAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAALKwgBJEgAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAgAC6IIAMYMCAALWAAAAAAAAAAAAAAAAAf/8AAAAQAICAGE/AgBhiw -BEEACAQBAAgf/6SggQAAADAAAAAf/5iApQAAAMAAAADABAAAH/zeACAGFEAf/5iQA4AAAAD/+AAB -AAAAABAAAIEEAQCBBAAAAQQAAAEEAQCAAAAAAAX//x//hBAGAAAAKgAAAB//zyggA/V0AgAAAIAQ -AABBQAAAQUABAIMAAAH//7//gYAAAAQAAAgf/5cAIAjhcB//jXD//wAA//8A/yAI4aAgCOIAIAjh -4B//jhAAAA0gH/+XcB//lkAf/5scH/ziAB//mpAf/5sUH/zg4B//klAP////H/+S1B//l6gf/5a0 -H/+XIAAAC5AAAP+AIAkE8B//lxQAAAo44QAuAOEAXgDhAZIAH/+X5B//lqTgAACg4QAwuAAAgADh -AGAQAABAAOECEADhAjAA4QJQAOECcADhABAIH/zhQB//p0Qf/6c8H/zgCB//p0Af/6dcH/+nVB// -p1gf/6d0H/+nbB//p3Af/5iA//7//wAgAAAgBhPwH/zeAAQAAAgFAAAAg/8AAIEAAAAAEAAAIAYU -QCoAAAAgAAOAIAKJkB//gAAgCMRgAAA/KCAIw7AgCMRQIAjEgCACkLzP////EAAAACAIw9A///// -AgAAACACisQgAorIIAKQuCACisxAAAAAIAjEEB/84HQf/5sgH/ziDAAAgAAgABEoH/+NcAAADDz/ -/3//H/+VmCAIx7AgCQyQH/+XcCAIx+AgAoiQAAAIAB//keSCAAAAgYAAAAwAAAAABgAAAABAAB/8 -4gAf/5scAAALOCAIyGAgCMjQIAjJQCAIyXAEAQAI4AAAAB//ljggCMmgIAjJAFMAAABRAAAAIAjJ -4FIAAAAwAAAA//v//w/+//8AA///AAAn/yAJDNAgABfUH4AAPx//liwgCMowAAQAAAABAAAgCMrw -H/+UzAAA//8gCMtQIAjLsCAIy4AgBg8wIAjMMB//lkgNAAAAIAAv2CAIzLAIAAAAIAjNAPf///8f -/6SgAQAAAB//lSgf/5SAIAjfIBQAAACAAAAAgAAAAngAAACAAAAGgACwAAAACgAA4zCS///wAIAA -sQDhAZoAAAIAACAI3uAAAH5AH/+OIAYAAAAFgAAAH/+YkB//lFQrAAAAIABFsDUAAAADgAAAAwAA -AB//lFgH////AD///4BAAAAID///H////wD///8gAAAAH/+WHD0AAAAf/5KMBwAAAIEEAQCBBAAA -AAA6mMMAAAAYAAAAH/+OYAAAD/8AQwAAH/+V5AQAAAAf/4QQH/+muB//pMDhAHoAH/+STB//lQQf -/5aAH/+UnCAJEzAAAweAIAkToABAAAAAAAkAAAAwAv/8+H/AAAAAo/+7AKP/ugDgAwAAg/+2AA// -//8P//gA/wAAACAJE+AgCOEAIAjhMCAJFHAACgAAAA8AAP//AA8f/5UQA//AAIP/wAAgCRTwIAkV -YB//lpgf/6Uw/2DwAB//pRAf/40wBIAACB//gFAARAAAAMAAAP8f//8AAIEADwAAAP//AAAf/5Y8 -H/+bGB/84ggf/5yoIAjmkB//kogf/4BgIAYSAAAAMAAAACcQH//Z4B//lPjerb7vNAAAAD8AAAAA -AIkGAJkAAB//pHgQAAcC7gAAAAHAgAAf/6NImQAAAB//pTQAiAAIgoAAAR//pMgf/6PUAxUAAAMR -AAAADwP/IAjqYCAAwCQgCOqQIAjq0CAJHUAAAI4CIAkeECAI6vAgCR2AIAkdwCAI6yAgCOtgIAjr -kCkAAAAgAMicIAYYMCAGEkAgANs48PDw8P8A/wCqqqqqzMzMzAAPQkAgA+F4H/+WoAAJAAAAgAAA -IAjtACAA++wAAEgAIAD/cB//lhQACQAIH/+kPB//pIQf/5SYAAAIBgAAiMwAAIkUfwAAAPAAAAAg -CR9AIAkgQCAJIHAgCR6gIAkgECAJH6AABAP/CgAAAB//o2Qf/6QkH/+UcIP/twCD/7YgIAjx8DMA -AADhAAAAH/+kRB//lVQf/6SMA//gAAA/9pAAABkUA//wAAAQAAEAABkcH/+kiAAP//8AAN6tH/+k -QB//lhAf/5UsIAYPQB//lIwf/5aIIABgWB//lSAgADWIH/+UhB//lFAf/5n0IAkhsCACjSAgAGD4 -H/+TiACBAADgAQAAAOABAAAA4AEgCSKAIAj0sAAADEQgAIgkIACFuCAJIgAgCSJQH/+WNCAJApAg -CQLASAAAAB//jgTv////IAkDAH////+/////3////yABddgf/5XwIAF3yB//klAf/5Ws4QAuAB// -lbThAF4A4QIOAP//v/8f/48s4QAOAOEBjgDhAHIA//++/x//lrQAAAo4H/+X+B//l/QAAAxwAAD/ -gB//l+wf/5hYIAF9dCABhcwD/wAA/7///x//l1Q8AAAAAAX//4MAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB -gAAAAAAAAB//+Wgf//loH//5LB//+Swf//ksH//5LB//9Ggf//b0H//1mB//9Zgf//WYIAXlwAAA -AAAAAAAAAAAAAAAAAAAgBelAIAXpQAAAAAAAAAAAAAAAAAAAAAAgAX9AIAXlwB//9/Qf//f0H//3 -9B//9/Qf//f0H//39AAAAAAf//RwAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAAAAAAAAAAEAAAA -AAAAAIGAAAAAAAAQBQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAgQAAAAAAABgFAAAAgAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAACgQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAgCgAR8X8T8X/TDwPmMQECABbxfRfxfndrBpBgtGZ3Y/hUDoBVk5kPFABj -//kAAABsEAQY8Xsd8XYrIAcc8XYqIQj6AgAHcbsBAO7cOQ3cAoAAC6oCnDDj8XAZsASAAAiqAhzx -biMwgPpACBXgDQUAnWXsZgIhuN0AAPrAhhWkdx0A6Xz/Ld4CgADrewIMzwKAAOtmASTL4QAAmWMC -BImTZyhmBgYgixjxXyUhCfTBZhWkMx0A5WYKK5AEgADoAAUDKMEAAG05AgUCYdEPAAAAbBAEHPFP -JiAHG/FOH/FU/kEEFaDWEQANyzmbMIcg++KWBaAJJQD6YEYVoBgFAOg2Ayu+AoAA+OYADHFmAQD4 -YCYVoAwFAOUgVys0AoAA98YADrArBQD/pgAO8Ao1AOjxPhKCAYAAnDWcN5szGfE9CnUClTGZNiUh -CZ00LyAHnDmUO/imAAkx/wEA4jYKL/wCgAAP7gII7gLuNggtEASAANEPJyEIKiEJnDWUNwZ3Agiq -Apo2CHcC5zYELJAEgADRDwAAAAAAAABsEAgoIAUnIAcpMQX4IIYV4BlFAPkADMVhdwEAiiIW8R8Y -8R/xVQwN4A2VAAx7Eaa7LLKe/YAMQ+AKpQArsp3rFgUljDmAAIyI94AMcJIAnQAtYq5k0TgrYq3k -sTRmc/0AAO6GCCWJuYAAKCAUpIgICEcoJBT1AAu90A8FABnxCS4iFiwhKYgVGvEIrsyagOoiHi5n -woAA/QBmFaANJQD9AEYV4AtlAO3w9x1WAoAAC6oCixSagekAFQRAQQAAiRUIAIooPBD9IMYV4EwF -AP0g5hWgDEUA7Ls2BMiBAABtuQUIAIYJAmHu8OkVoIeAAIgV7gAFDc8CgACpiOiMICWkNQAAC8kM -bZkCCAJhKCEp6iEoJEAFAAAICE8oJSn5QAhEIgCdAP/hwgXgDBUA+iCoFeAe5QDqIh4sbUKAAPwg -JhXgCQUA+CAGFeANBQDpFgIl2YEAAFhx1Ax+EffAAEcwDZUA/dOmFefFAQD5gAYpUgCdAMAg0Q8A -6iQACdgEgADsRAAK6ASAAFhzsdKg0Q8AwLAKzzTvhggt9o4AANog/EBoHaAbxQBYdABj/8oAAADq -JAAK2ASAAFh1PtKg0Q8A//nsDaALBQAAACt8GOokAAlgBIAAWHP0Y/+cwKBZjncY8LCMiPmf80CQ -CqUAY/+sKiEJ/EKwFa/9BQANjQENjgwuJBTttAMuYQKAAO+0AC1WAoAA/UYADTAJFQAJqgKasfjV -phXv+WIALyUp//vUDaAIBQCKJ+tEAApoBIAA+0QAFaAMBQBYbjDSoNEPAAAAbBAGKCAFKyIQ5CAH -KlAEgAD4AwId4B7FAPveAAzwGUUA+QAMXWFEAQCMIh/wiOoWAC4LHgAADEkRD5kILZKeDwIA96AL -41IAnQAnkp0MBj5kcW6LKSoiCguqDPdACQuiAJ0AKiBOLCBMsa37gAskIAsVAC0kTiowASkiGPNA -C0aSAJ0AKyAHLCEk/GAkFeAIVQD5QAQEMKsRAOCIEQ1SgoAACogCGvBuCN0CKCEHKyEJCswC+6YA -DrqIAQDq8GocQwKAAAi7AighIp1wjSCbc5x0+wYADDAKZQDodgIu7gKAAArdAp1xLCIQnHUrIDgY -8F78ACId4EwVAPzhJhXguxkAC805HPBZnnj7DQAOcAgFAJh3DcwCnHbt8E4U2AUAACsmGBvwRJh7 -mXrtABUDyMEAAAkAiut2DiHIQQAA7nYPI/EBAAAJIIYOAmMJAIYOAmEMTBGvzOrGnSMAqYAAjikt -IDim7p4p86AFV5IAnQAFD0f54ARRUgCdAMAg0Q8A6iQAC1gEgABYTV/B7O/wLxV2kYAA6iQACdgE -gADsEgAq6ASAAFhzFtKg0Q8AAAAA6iQACtgEgABYdKrSoNEPAAAAK0wY6iQACWAEgABYc2Jj/8GI -IsCUCYgC+EBGFa/+3gAAAAAAAAD8Q6gVpIkBAACBBAC9Gg3MAvxDphWv+h4AiieNEMDA6qwgLtgE -gABYbarSoNEP2iBYcsBj/1EAAGwQDC0gBSYiEC8gByshNeUWAynABIAA+wCIFac1AQDyf8AV4AwV -AAPDOftBAA1wFYUA64ICLGAEgAD3XgAKsf8BAPcAMBWgFUUA9aAf1WO7AQCJIigWAPM9XA3gDoUA -mBDywB4HEgCdAJ8SnxqbFhbv75MV6hYEL68CgADmVQgCMA0AAOYWCSJwBQAAiBouFggrEgn1AAZi -EgCdACpSnvtACaviAJ0AL1KdZPO7GO/giIj3AAlYkgCdABnv3CmSrgwDPurv2hSJ+YAAKqKtFu/Y -6hYLJGv9AADrEgslCWmAAO1mCCWbmYAAiCmHKgh3DPLgCWPiAJ0AKRoA8yIyDeD69QArIBacEftg -Ca0iAJ0AGO/QhhSNwyogOP3g5hXgCQUA+eEmFeBHBQD34QYVoKoZAAp5ORfvxysiF5v6KyIbm/uN -xAp4OfzADxLiAJ0AmBeeHYYVnBGZHOcSDCsIHgAAYAF+GO+ziIhqgSaKGSlSnnqTQytSnZsbjRvp -760UM/0AAO/UAAaB2YAAlphl/xxgAtWeHfwgJhWgCgUAWY1rGO+kiIiMEe4SDSQPBwAA//9oDaAP -BQAAwJD4IWYV7/7uABvvm8CqCoo0+2EGFa/+/gAAAAAAAAD/+zgNoA8FAACeHZ8e/CAmFaAKBQBZ -jVcY75CMEYiIjx6OHfkf9diSAJ0AYAJRwJCZG4obHe+JwLoLizTr1ggtdo4AAGACOACeHZ8enBHq -JAAJ2ASAAFhMrowRjx7uEg0ldfmAAGAB7wCeHZ8e+kDwFaAMBQBYTaWMEY8e7hINLXXGAABgAsYA -iBGOF/YgyBWvjAUALCQ7jBQGdgIG7gKsuQzaDJqE6SYbLFgEgADtIhApUASAAFhz744djBH6s6YV -oQcFAHN7CCsgFigK/3i5XoopKSA4o6rqJgkk+aaAAC8iEC0hNfuAiBXgCBUA+CCmFaAGNQCWEw27 -NvoghhXgHYUA/34ADv/2tgCKJ58eixDqrCAqYASAAFhwkI8emhErIhv9QIgV7/2GAAAAAAAA6iAH -KeAEgABYTV+MEf4hqBWv/kIA2iBYcfeMEf4hqBWv/kIAAC0iEIoWKyA7Fu9ICpkCCYkC5pgCDYn2 -AAAa70X4RIQV42kBAIfA6yAHKzICgAAGmQImIQf64AQDsLsRAOrvNR3agoAAC3cCKyEiCncCKiEJ -l/CHIJ31+eDGFapmAQDp9gQrMwKAAAaqAhbvK+r2Ayu+AoAA5+cCB8jBAADn9gEmQIEAAOa7AgJT -+QAA6/YCIhQ1AABtqQUIAIYJAmEoIBSkiAgIRygkFPUABq3SAJ0Aihj6s6YVoQkFAPMh8g3g/PUA -KyAW/WAJFSIAnQAtIhex3e0mFyGAqYAAjykuIDij/58p88AHv5IAnQCGFWVg0sAg0Q8AAAAAKCBO -ZIw9DpsCmyLrEgApUASAAO0SAypgBIAAWHHn0qDRDwDrEgMpUASAAFhzfNKg0Q8A2iD8QGgdoBvF -AFhyNWP/xwCLEtog67wYKWAEgABYcjBj/7QAAAAAAOokAA5YBIAA/CCIFa+OBQDuJDsscASAAFhz -bPohBhWgDwUALyYb/kdmHe/8ggCLGyohCfxCsBWv/QUADY0BDY4MLiQU5MwQDVYCgAAMqgL9YGYd -4A4FAP9gBh2gBhUABqoCmrEZ7tL3NaYVr/vKAACKJ+tEAApoBIAA+0QAFaAMBQBYbGXSoNEPAADa -IFhxe2P/BAAAAAAA6iAHKeAEgABYTNtj/tOLEtog67wSKWAEgABYcgFj/vdsEAgoIAXt7rwZ0ASA -APPdcgXgHkUA/wAKdSAMpQArIE4p0gjTD+oWAyXb/QAAKyRO9yAIWJAHFQAvMq5k8igqMq3mpAAF -EVGAALCY6NYIJQhBgAApIBSzmQkJRykkFPUgEO3SAJ0AKSBzKyId+yAEAN//9QDgehoEwAUAAP9X -AA/0iAEAKCRz+0AEBXAIFQAKijkPuwHrJh0tBv4AAIoifKcEKyBOyrR9pwgtIEwsIE59wxnMbC4g -FO8iAi9YHAAAZPH0wCDRDwAAAAAAAIgnx5MJqQHpJgIkUMEAAFhkOOPukhUBEYAAKKAAA4gKiIzs -oActWASAAPpAaB2gDUUAC4AAZa/hiSdkn6iKmsqnKpIJZK+eKKAAA4gKiIzsoActWASAAPpAaB2g -DTUAC4AAZa/hY/99AAD//1gNoAoFAMCgWYw0He5sidgsCgr5P/dAkB5FACYKACkgFLOZ+EKGHe/8 -GgAAAADqJAAK2ASAAFhy5tKg0Q8AACogBSsgBw8CAP9ADxUhuwEABQVH+KAPKVIAnQCOE+7iBi94 -BIAAnhQLvgL1YApyEgCdAAy6EQOqCCiinvcADnzSAJ0AKqKd7hYBJQrxgAD6QAgV4AwVAFgf9hvu -Si8hCR7uQCghIi0gBxzuUikhJP8GAAww3REA7hIELuqCgAANmQIMmQKZoIwgKKYC/0BmFeANJQDu -pgUuZgKAAA3MAv1AJhWgCQUA6wAVBVBhAACxmeqDHgyP6AAAjxEM/xHz4ABH8A6lAC72nfS/8sES -AJ0AKiIH60QACmgEgAD7RAAVoAwFAFhrwGP+OgAAAAAA//dYDaAKBQAMmzTr1ggtbu4AAGP+2QAA -LyEJ+EKwFaALBQD6wAYd7/oFAAqaASpkA+qaDAxBAoAA6iQUL/4CgAAI/wIH/wKfYfZ1phXv9soA -iifAsPtEABWgDBUAWG47He4anaCMIBvuGeumAi5mAoAAB8wC/UAmFaAbxQDsJAAJUASAAFhxRMAg -0Q8AAInY9yAEqJIAnQAM6hGjqiiinvcABXzSAJ0AKqKdZKCmsJiY2O4WAS11VgAAiSLrFgAkhRmA -AJ8S+L/rYVIAnQCKJ8Cw+0QAFaAMFQBYby4e7fqeoI0gG+377BICLu4CgAAH3QKdoYzGnKP7QEYV -7/TqAOtUAAlQBIAAWHJmY/0njxOP8/4ghhXv+I4AAAAAAAAA//jQDaAKBQAAnxKbEfogBhXgCgUA -WYudHe3WixCJ2I8SjhH5P/qIkAylAP/9jA2gCgUAwKAMmDT5oQYVr/1aAAAAAIsQ7xYCKVAEgADr -vBgpYASAAFhxCP4gSBXv/SIAbBAEKCAU74seahgEgACKJ/pgaB3gDAUA6qwgKegEgABYa1XSoNEP -AIsic75+FO24iUhqkXob7bXTDyyyrmTAWCqyrWSgVLCd7UYIJQLhgAApIBTpJBQs2twAAC8hCfhC -sBWgDQUA/UAGHe/8BQAMnAEspAPsnAwMQQKAAOwkFC/+AoAA+eYAD7AOFQAO/wKfof91phWv/eYA -wKDA6g6eNO5GCC19ZgAAjyLJ9cAg0Q/AoFmLXolI+T/70JIAnQBj/+UA2iD8QGgdoBvFAFhw0sAg -0Q9sEAgpIg/vITQpsASAAPZg6BXnhQEA7iAHKlgEgAD7H8AVoAQVAPqNAA0wHUUA/uEAC/HuAQDp -fR8MFHQAACggT+8gTSRABQAACAhHKCRP+eATC6IAnQAvIAWbEZoQ/eARLWIAnQCJIsej+UAN0OIA -nQAsIhmLMv1gE00iAJ0AjTgY7W3vEgEmkaGAAAzkEahEGO1r6BYCJ/gNAAD1wA0CEgCdAClCnv8g -GYviAJ0AKUKd7ZQABJHBgACLKSoiCgwFPg8CAAuqDPVACeviAJ0ALBoA9YIyDeD49QArIBbTD/lg -GAUiAJ0AGu1mKSEkKyEHCpkCKiEJCwtKDLsQC6oCKyAHHO1SCytA6O1eHdqCgAAMuwIsISKb0Isg -mdSa0wjMApzS/WAAFbAMVQAMuwKb0RvtVSoiDyrWBSkgOPvapgWgDAUA/aDmFaBIJQD3oQYV4JkZ -APlNAA3wCiUACYo5KWIEKdYJKGIFKNYK/MDIFaAJBQDs1gsjh+GAAOntRRzCgoAACYgCmNyMaJff -nN6MEolpKdYQiGoo1hHsABUGySEAAAkAioxn/OAKq6IAnQAZ7S0KuAIJiAKY1sD1/pOmFeEOBQD1 -wfIN4Pr1ACsgFvtgEgUiAJ0ALiIZjCktIE8rIDjlzAgHcAUAAO4mGSbr/QAALSRPnCnzYA4HkgCd -AI0QZdG+wCDRD58TnhSeFZ0W6iQACtgEgABYSjaNFo4U7xIDJXVhgACOEGXv14on2zDsEgElUMEA -AFhuHMAg0Q8a7P+KqPdADsiSAJ0AK0Ke/2APs+IAnQApQp0d7PjkkeplY/0AAJzY7ZQADPJ2AABg -AHoAKCA58R/4DhIAnQD/++QNoAkVAMGjevkSKSA6/iCmFaAL9QD7IBAlYgCdAOokAArYBIAAWHFq -0qDRDwAAAAAAAPAAGA2gGtUAwKGMNyshCY04jjLrrxEN3QKAAA+7AuS7AglQBIAAWHFMwCDRDwAA -AP//WA2gGoUAAAAr7BjqJAAJYASAAFhwEmP/KAAACrkCmdbAhfiTphWhDAUAdcsNKyAWKgr/+2AN -PSIAnQCLEGSxNYtqjGeKaat7B8wMnGf3YNIN4A0FALGqjGWbaotmmmms2qt7d7sBsaqbZppliCkt -IDiliJgp86AJN5IAnQCJJ4qayqWLmcqxnxMZ7L8osACeFJ4VCYgKiIwssAf6QGgdoA01AAuAAI4U -jxOLIsej+1/zaOIAnQAoITSHZ/xB6BXgCRUAmRD44QALsBxFAPz+AA5/85YAANogWG9SY/47iifq -rDArWASAAFhcw9Kg0Q8AAAAAAAAA//NIDaAJBQCfE54UnhWdFvpA8BWgDAUAWEq+jRaOFO8SAy1n -TgAAK+wS6iQACWAEgABYb81j/hPqIAcq4ASAAFhKn2P9tZ8TnhT+IKYVoAoFAFmKShrsgoqojhSP -E/lf8HiSAJ0A//iIDaAJBQDAkBzsfMC6C6s0+4EGFe/4QgCfE4onnhTuFgUp2ASAAOwSASVQwQAA -WG2O7hIELTAEgAD+IGgV7/qWAJ8TnhTuFgUpUASAAFhvHY4U/iBoFe/7JgAAwVP6QGgdoAsFAPwA -Ah2gDTUAWGjGKyAFjhX1f91NYgCdAGP9Y58TnhSeFeogByrgBIAAWEpyjhT+IGgV7/kaAAAAAAAA -bBAMlRMmIAUvIAeHL+oyBCnABIAA/EaEFec1AQDyf8AV4A4VAAPjOf1BAA1wG0UA56sfDGAEgAD6 -wB6lYf8BAIkiKBYA8zr8DeAOhQAmgAEoFgDywBy3EgCdAJ8SnxoZ7D6TFxbsPOoWBiJYDQAA6xYJ -L68CgADmVQgCcAUAAIganhiNGfUABVoSAJ0AK1Ke/WAII+IAnQAvUp1k85KImPcAB+iSAJ0AFuwr -JmKuDAM+6uwoEwiJgAAqoq3qFgska/0AAOsSCyUIEYAA7ZYIJZqBgACHKYYqB2YM8sAH6+IAnQAo -GgDzAjIN4Pr1ACsgFpwR+2AILSIAnQAW7CsqIDj72FAF4A0FAJ3394CIFeCqGQAKazmGFsSACo05 -9sAPguIAnQCdFI0X6xYFLoduAABgAZCImGqBIY0ZK1KefbM+L1KdnxuGG7CK72QAAwHhgACamGX/ -RmAC1gCeHPwgJhWgCgUAWYnDGev8iJiMEe4SDCQPGwAA//9kDaAPBQAAwLD6IWYV7/8CAMDaDY00 -/SEGFe//BgAA//v8DaAPBQAAnhyfHfwgJhWgCgUAWYmxGevqjBGImI8djhz5H/dIkgCdAGACWcBg -lhuKG8C6C4s065YILXf+AABgAkOeHJ8dnBHqJAAJ2ASAAFhJCYwRjx3uEgwld3GAAGAB+54cnx36 -QPAVoAwFAFhKAIwRjx3uEgwtd0YAAGAC05wR/iGGFa+IBQDoJDsmOEEAAOcDHgewgQAABgJhhhaW -+I3Hh8SIxq1tBncMl8R22wouFgzsFgEkQAUAAIwWixGGFI4VmLadtwbuAu0iDylQBIAAWHBBGeu6 -jhyMEfqzphWhBwUAc3sIKyAWKAr/eLlciykqIDiju+smCSV5qoAAhi8vITT9gIgV4AoVAPog5hWg -CDUAmBMP3Tb8IMYV4B9FAPe+AA+/9v4AAJ4ciiefHYsQ6qwgKmAEgABYbOHvEg0tYASAAP4hiBWv -/NoA6iAHKeAEgABYSbGMEY4c+dcwBe/+QgAA2iBYbkiMEY4c+dcmBe/+NgAmIDsX65vtuwIHyIEA -APmCABWjqwEA57cCCwjGAACTH43AE+uUA90BIyAHAyNACjMQA90CE+uIJiEkA90CIyEH6yEJLVIC -gAD6xgALOjMBAOohIimbAoAAA7sCgy+d8I0glvSX9pP1m/ODH+vrfB7uAoAADe0CnfELqgLq9gIi -DD0AALBKbakFCACGCQJhKCAUpIgICEcoJBT1AAZd0gCdACoSCPqzphWhCQUA8yHyDeD89QArIBb9 -YAilIgCdAMg/jiktIDij7p4p86AHr5IAnQCPF2Xw0sAg0Q8AJiBOZGxnDpsCmyLrEgApUASAAO0S -AypgBIAAWG4/0qDRDwDqJAAK2ASAAFhv1NKg0Q8A2iD8QGgdoBvFAFhujWP/xwCLEtog67wYKWAE -gABYbohj/7TbwPwgyBWvjgUALiQ7CCCGCQJj7PYIKVAEgADtIg8r8ASAAFhvw/ohBhWgDwUA/kdm -He/8qgCLGyohCfxCsBWv/QUADY0BDY4MLiQU5MwQDVYCgAAMqgL9YGYd4A4FAP9gBh2gBhUABqoC -mrEZ6yn3NaYVr/vyAACKJ+tEAApoBIAA+0QAFaAMBQBYaLzSoNEP2iBYbdNj/wYAAAAA6iAHKeAE -gABYSTNj/uGLEtog67wSKWAEgABYbllj/vdsEAYoIAUlIAckCgP3AAVkUVUBACggImSAoQIqAlhm -5vlABMDQBhUAKSAh4+sKGAQKgADzIAQv0gCdAOxZEQKlaQAAo5kqkp5uo3Qrkp1ksGopICH6QAgV -oPzlAAyZAfcmAAywDQUA+EQmHeAIBQD4IAYVoA6VAPggJhWgDwUA+CBGFaAMBQBYa/YMXRGj3fWz -phWgAgUA0Q8X6u+KeGqhJgxZEaOZLpKebuMtK5Kd5LApZWP9AACceGW/lMAg0Q///igNoAsFAMCg -WYiqinhroc7//4wNoAsFAMCwwNoNrTT84QYV7/9SAAAAAGwQCiwgBfhA8BXgCxUA+GBoHaelAQDo -FgElU/kAAOq6OQoYBIAA6hYFLCAEgAD9gcAEUZkBAMGz+4AZhWIAnQCMIhvqybQ+5cKxbMcCgACr -iJ4U7RIEKAQKgAD1IAQCEgCdACyCnv2ABxPiAJ0AL4Kd7xYGJ5SJgAAlIRuKQocpmBAFpTb1TwAL -cQ8FAHbzAdWghioHZgz0wAXT4gCdACoaAPVCMg3g/PUAKyAWmBD9YAX1IgCdAI0ppd2dKYpC+qAK -cqIAnQCZGIwVG+q+h0OZGZgQ63cBBgfpgABgAK0a6qOKqOgWACUMn4AAjBQrgp58sz8vgp0e6p3k -8Dhla/0AAJ3o7xYGL/uOAABgAfaZGPghJhXgCgUAWYhbGuqUiqiIEOkSCCUPFwAA//9UDaAPBQAA -wPAc6o3AugurNPuBBhXv/woAAAAAAAAA//yEDaAPBQAAmRiZGeokAArYBIAAWEewiBDpEggleamA -AGABipkYmRn6QPAVoAwFAFhIqIgQ6RIILXmOAABgAmDudAAKWASAAOWsDAroBIAA7xIGKVAEgADs -RgIp4ASAAFhr5okZiRiIEPsTphWhDQUAddsIKyAWLgr/frkxwPH+IKYV7/oOAACKJ4sR6qwgKeAE -gABYa6PAsuukAi0gBIAA+0BIFa/+bgAAAAAAAADqIAcq4ASAAFhIcYgQ+CEIFe/+9gCJQIwVh0P4 -IAYVp9kBAO0WAi4HpgAAKiAH+uBoHeGqAQBYJ3mJFteg6jz/IkBBAADpnCAhjDUAAG2pBQgAhgkC -YcCgmhMvIQcW6lyIEvvUtAWq/wEA6eo6H/8CgADm/wIEaD0AAPYgyBWk3R0A7iEaJugFAAANPQyf -YOsiACvgBIAA7ak5AbgFAADpZgIkQEEAAOhmAy3+AoAAD38C72YBKugEgADvQgMjUEEAAFhrmZcX -6iQACdgEgABYYfaPQOMSByep7oAAhxDy86YV4QYFAPTB8g3g+PUAKyAW+WAE3SIAnQCIE9KA0Q8A -iRVkkJvAINEPACucGOokAAlgBIAAWG1YY//kiif4IAYVp7lBAA8CAOqsICgECoAA9WAEUdIAnQCM -FisKAezMICnoBIAAWGek+iBmFa/8OgAAAACLFuw9EQlQBIAA/WAARfAMFQBYZazyYGAV7/3CAGWs -0Pmf5mjSAJ0ALyAg8f/mF5IAnQBj/3sAAAAAAAAA6iAHKuAEgABYSA2IE9KA0Q+KJ9ww6xIBJVCB -AABYazHAsvtARh3gAgUA0Q8AANsw/GBoHeAMBQBYZ4PbQOw0AAroBIAA6hYDK/AEgADvEgYpUASA -AFhrWfdAaB3v+2YAAAArnBLqJAAJYASAAFhtHmP+/ABsEAQU6fMkQIAIRBH6gGgdoAsVAFmEixjp -32SgQvhGAAwwCSUAmaHopgAhAcmAAGghHG8kGe4iFmVIIQAAA0CICQiKAyCICQSKAwCICQCK2kD6 -AEId4AwVAFmJWMAg0Q/HJNEPD+gwn6IO7jCeow3AMJ2kDLEw/UCmFaALBQCbpvtA5hXv/y4AAAAA -AGwQFOIWGynwBIAA/iNGFaAMFQD6I2gVp2UBAOjiACNb+QAAC8s5KaAHiqf6IaYV54gBAPgihhWh -mQEA6RYKJVCBAADqFh4qGASAAPTAL2ESAJ0ALRIbjdJl1B8f6aGP+BLpn/fgL8iQDqUAJiKuZGYc -KSKtZJYYGumasPiYqOiUAASvwYAALxIeKRIa++BoFa/FBQAF/wEvFhzvrwgEyIEAAO/8QCyoBIAA -/yAvkuIAnQAmEhotEhQlFhX2wGgVr/wFAOYWESboPQAADNkBpZbmFhArKASAAP7ALmLiAJ0AmBeZ -FZMWJBIb7xIKItgRAACbG/4iZhXkrR0A6hYWIbBBAADmFhIi0CEAAJocFul1lhgqEhomEhzkQQcv -/wKAAKL/7xYYIzEBAACWGRbphftBhBWqRAEA6hYZKicCgAAGRAKUH/XTAgWgB6IAJyAA6v8MBMgF -AADqEh4nQAUAAP8AaB2gaAEA6BIdJJWJgAArEhwsMACKowXMC6ur67xALmgEgAD7gBUC4gCdAAkM -QPoAIh3gCgUADLo4DasL7aoKBeghAAD6ACId4AwFAAa8OBbpZwh3C6bGJmCQ58sLDUAEgADnzAoF -2GEAAORkCAZgQQAAioANAIkPqjaawAsAi4yA4zwBIRAFAAD/n/rz4gCdAIMUD8sMCsIMkoD/oAgV -4AcVAPOgKBWgBgUAC3Y4qWmiopLReisBsf+f0PKAGefSAJ0AHOlNLRIbIhIaFulJGulI7hIPJ0AF -AAAGNgHqOgEMzgKAAAlmAikSHQqIAiMSGZiUllCPJygSFyYSFgP/DP5A5hXhNB0Ao2MvEhQS6TOT -Hp6AjdAuEh7ihgIhmAUAAO+GAy7OAoAA+GYADPALBQD5ACYV4ApVAOYWASmgBIAA6BIVJBBBAADo -FgApeASAAFmGcy8SHioSFiYSHI/zKBIVKxIQ5v8ICUgEgADmEhEn+QEAAPvgFVviAJ0AbakFCACG -CQJhAzQCKBIa6IIHKw0eAABkgaj10igFoPL1ABzpFy4SGi8SGC0SGy7hDfPzphXgClUA/aAIFeAL -BQBZhlgmEhsmYBbywAoFIgCdAC0SGy4SGigSGf2gCBXgClUA/8DoFeALBQDoFgAqYASAAFmGSy4S -Gy7gFiIK/3LhCioSG4sdWCgsZKKMLxITJhIYJxIS9eAFwhIAnQAmYp4pEhj2wBNT4gCdACmSnekW -FySHeYAAKhIaLxIZiVCKpy4SF/gghhXgBCUA++EAD7eZQQDvFhkkkRmAACoSHhPo1CsSHIqjo5Mj -MAAX6NGrqwUzC+00AAXZAQAA+mAQUuDJAQD6ACId4AoFAAy6OA2rC+2qCgXoIQAAjBXYoOeTCAuQ -BIAA/4AARjAOBQDsFh0mWGEAAP2CgBWv9u4AjRz6IWgVr/YOAAAA+48ADr/1ggAf6KyP+PfgDpiS -AJ0AJhIYJxISJmKeKRIY9sAOy+IAnQApkp0b6KPkkc1n0/0AAJq46RYXLPmGAABgABMrEhoqEhsr -sQ1YJ9Jj/rTAINEPAIsaLBIb67wYLlAEgABYa9bAINEPLGEAscz8wAQdr/liACUSGiYSGSVRDAZV -DGVSACYSGyZgBPTAENkSAJ0AIhIa4xIXKbcCgACIIaYzIiIC5oI2adgEgADzABKgUAcFACkSG4oW -KJAUhB6qiPaAAEJ3iAEA6JQUIiAFAAD1ABIeUgCdABzoly4SGi8SGC0SGy7hDST2nf2gCBXgClUA -9c8AD3ALBQBZhdYvEhsv8BYmCv928Q4rEhorsQ0qEhsFuwxYJ58qEhuNFoqnwMDqrCAu2ASAAFhl -/NKg0Q8nEh2LGPaAAgPwDwUA6wAVA7hBAACx/+eDHg+P6AAA9IAgFa/ylgAAAC0SFdMP7foMCUAE -gAD4IsgV5OodAPHBIA3gDwUADQCG6AwAB/gFAAB++fEoEheNGQ6eDPlAAEQwDwUA5O0mZEBBAAAN -IIboLAAH+AUAAH758WP9EBfoTY0c+iFoFa/4WgAAAPpvAA6/99oA//ZkDaAJBQCLGiwSG+u8Ei5Q -BIAAWGt4wCDRD8CgWYX7H+gzj/j5//EYkgCdAP/4/A2gCQUAwJAY6C7Aagb2NPcBBhWv+LYAAAAA -2+DtjA8qYASAAPojyBWk3R0AWQWy+iNGFaAOFQD+IaYVr+feAMCgWYXmH+gej/j5/8/okA6lAP/o -IA2gCQUALBIb+4BoHaAbxQBYa1jAINEPAADAkBjoFA72NPcBBhWv55IAAAD7LwAKv+g6APrPAAq/ -6NIAACwSGi7AFS3AFCvAEezBCSlQBIAA7t0IC3AEgABZBYdj/dwAACoSG4sWWF/PLxIaj/Dx//Dy -kgCdACsSF+oSGynvAoAA/WAARfAMBQBYY6L0YGAVr/gCAAAAKhIb6zQACWAEgABb9pgoEhqIgQyr -Ees7CA04BIAA8R/toFIAnQDqEhspYASAAFv2Z/dAAEP/9oYAjBf2I2gV7/8FAA+PAQ+GDCZ0FC1x -Cf7isBWgCwUAK8QAL8QD5O4QDu4CgAD/pgAOsAkVAAndAp3BGufY+VWmFe/2BgAAbBAIiCIvIAeV -FPQgZhWg+/UA8RgsDeH/AQAoIBZ7gSwrEgTTD9MP/iDGFee7AQD7f8AV4AkVAOubOQlQBIAAWCcU -LxIG808QDeD79QAsMA8V57od58EW57/lUIAuC4YAAIcTsHclXDf+IKYV5FUdAOV1CA/PAoAA5pkI -AqgNAAD14AbiEAylACiSnvUAFQviAJ0AJZKd5FQAAooBgACK2PdACjiSAJ0ALmKuZOEBKWKt5JD9 -ZXv9AADv1ggkiAGAACggFtMPe4EOmRDrMQYpUASAAFgm2YkQKiAEixP1QAk5EgCdACogFKuqCgpH -KiQU9UAM5lIAnQAsMA+JFPGRnA3nmQEA+SAOKVIAnQDpVAABwEEAAG15BQgAhgkCYcCgmhIMdBGk -VCggBPUACjkSAJ0AiTHkFgEqWASAAOUyAiyNYgAA8yAOQFAEBQCkeYoV4hICLVcCgACmqimmndEP -AIrY90APUJIAnQCJFQyZEaaZLpKe9cAQA+IAnQAukp2eEIgQ5YQABA/ZgACwqfmhBhXv/BYAAAAA -7BIDKVAEgADtEgQp2ASAAFhqV9Kg0Q8AwJAMrjTu1ggs+EYAANog/EBoHaAbxQBYaqZj/8onMA72 -4ACD//pGAAAAK/wY6iQACWAEgABYap5j/6zAoFmFIR3nWorYKwr/+V/1YJAMpQBj/7kAAAAAAOsS -AylQBIAAWF8fY/7hAAAAACwhBx3nZvvO0gXqzAEA7jAOLmcCgAANzAIstiiKIBjnaf1AABUwDDUA -DKoCKrYp6AQFAfhBAAD5IAnBUgCdAG3pDgQCYw9AhgQCZQ8AhgQCYcDQ/CBGFe/62gCOMPPACuqS -AJ0AjxXiEgIv/wKAAKb/J/ad0Q8rIQn8QrAVr/0FAA2tAQ2vDP5Chh3gDgUA7ZQDLmECgADulAAt -3gKAAP1mAA2wCBUACLsCm5H41aYVr/i6AIon/KBoHaALFQDtEgMlUIEAAFhkt/ogRhWv+O4AANog -60QACuAEgABb9b6LEYkxDKwR7LsIDSAEgADxP/IAUgCdAOokAArgBIAAW/WNpKSkeYoV4hICLVcC -gACmqimmndEP//WIDaAFBQAAACv8EuokAAlgBIAAWGpGY/5MAAAAAAD+IMYV4AoFAFmExh3m/4rY -/iDIFeD79QD5X+/wkAylAP/0iA2gBQUAwOD+IAYVr/gOAAyoNPmhBhWv9DYAiieFq/tEABWvyQUA -CakBqVkpnEBt6RMEAmMPgIYEAmkPYIYEAmd5+xnTD40TDwIA+6BoHeAMBQBYZH76IEYVr/VuAPXv -AA///4oA2iD6gGgd4AwFAFhih7N7jBXiEgIuZwKAAKbMK8ad0Q9sEAQjIAAkCu10MQYiIQO8ItEP -hiCFI4Qh9nAABDs2IQD4YABBs2YBAKYzDjMR8q8ACX1EAQDjPBohE8kAAAQkLAQzKKMi0Q9sEAiK -IicgB4kwlRT4QtAVoXcBAPFbDA3omQEA+CAmFeD79QB7gSArEgQLC0f7f8AV4AkVAOubOQlQBIAA -WCYE80/gDeD79QAa5rSIqBbmsfcADGCSAJ0ALWKuZNGsJWKtZFGosIiYqOlUAAKMeYAAFeaiJVCA -JVw3+CAGFeRVHQDlRQgLzwKAAOaZCAKoDQAA9OAIWhIAnQAokp71ABMD4gCdACWSnWRRbyogFvtD -Jg3g7NUAKzAQ/WASZCIAnQArMQu8u9ogWCXMLCAE9YAK+RIAnQAoIBSkiAgIRygkFPUADIZSAJ0A -ihQe5qKNESghBxzmghnmoP+h4BXqiAEA/wAAFDT/HQDpiAIH+AUAAA9PDJhQiyAP7Dn8oGYV56oB -AOxWAi3eAoAA60sCAshBAADrVgEhwEEAAPlACAFSAJ0A6EENYlP9AABtqQUIAIYJAmHAgJgT6SAE -Ilv9AAAMuxGrW/UgB5kSAJ0AiDHlMgIl2EEAAOsWAiwJ8gAA8wAK8FADBQCjTIgTDH0Rpt3s1p0s -EASAANEPAAAAAAAAAPcADXiSAJ0ADHkRppkukp71wA3T4gCdACWSnWRRsbCMnKhlXuRgAFHqJAAJ -2ASAAO0SBCpgBIAAWGk70qDRDwDAoFmEFBrmTIio+R/zUJD79QD/+cgNoAUFAADaIPxAaB2gG8UA -WGmGY/+8wFDA2g2INPlBBhWv+UoAK3wY6iQACWAEgABYaX5j/5wAAAAAAOokAApYBIAAWF4FY/6p -iif9IGgdoAsVAOqsICpoBIAAWGPL+iBmFa/8AgCLMPNgCOKSAJ0A4hIDK+cCgACmzCTGndEPjxAu -IQn4QrAV7/oFAAqKAQqMDCwkFOSZEA92AoAACe4C++BmHaALBQD74AYd4A0VAA3uAp7x/NWmFe/4 -6gAAAAAAAADqJAAK4ASAAFv0u4sSKDIB6hYFLWcCgADsuwgNGASAAPEf9VBSAJ0A6iQACuAEgABb -9ImIE6Ojo0wMfRGm3ezWnSwQBIAA0Q//9owNoAUFAI40izeNNf5wAAe7ziEA/4AARnPuAQCuzA7M -Ef1vAA293QEA7MwaJdvJAAANvSwNzCj9YABFv/YiAAArfBLqJAAJYASAAFhpNGP+dMCgWYO3GuXw -iKj5H/I4kPv1AP/5ZA2gBQUAAMBQwPoPjzT/QQYV7/kmALBLDLsR61sICVAEgAD7YgAV4AwFAFhh -i7NM4hIDK+8CgACm3SzWndEPAABsEATaIFgluIQ3JTAW+cvmBaKmBQAGpigX5fioaAVVCghVC6dV -iFC4RPUEBg3gBxUAiDLqUgEpAQqAAAB5GgmIApSgmkGVQJRRmDLRD9ogWCWmG+XqHeXqK7Iy6tKB -LWAEgACsu+8wFi3eQoAAq6oe5eYZ5eTo5doeZwKAAK7MqWkrkn3u5cUfgQqAAO/CASvoCoAADbsC -LZJ/CP8BK5Z9D90CDe04DbsCm8Ipkn9kn39YAraIMupSASkBCoAAAHkaCYgClKCaQZVAlFGYMtEP -bBAI2iBYJYTUoBvlzvnLmAXipgUABkQoFeW96UkICVcCgACrqoqgKZJ/GOXEpUX7IAQEsGMFAPgg -BhXgBxUA4QAFATO5AAD4gABCMADiAAAAAAM8CvWAAgZ8OEUA6MgICVAEgADogn8qWASAAP50ABWu -LQUA7cwIC2gEgAALgAABAYcDN2DhAQcJ9yAAANEPbBAEKCAFJSAH+mCoFa/01QD6QEgV4AMlAP0B -IBHRVQEAwCDRDwCIKRnlpJor+wAHfCIAnQAJWQkpnQIqkQgpkQT7IARbogCdAMGv+0AECOIAnQDa -IFhhN4siA7oBZK/AiicEuwHrJgIlUMEAAFhbGuPldBUBEYAAKKAAA4gKiIzsoActWASAAPpAaB2g -DUUAC4AAZa/hiSdkn4WKmsqnKpIJZK97KKAAA4gKiIzsoActWASAAPpAaB2gDTUAC4AAZa/hY/9a -AAD//1gNoAoFANogWGEnKyAi6rsMCVAEgABYYnfaUPoAIh3gDAUAWGMmiyIDugHzf/smYgCdACwg -B+S9AQlQBIAA/EBGFeG8AQDrvB8pYASAAFhof8Ag0Q8A6yAiKVAEgABYYmUqIAXB436hDGioKYsi -82AEBX/8hgAvIDrAj3j56vpAaB2gCwUA/AACHaANJQBYYZFj/9cAAPpAaB2gCwUA/AACHaANJQBY -YQ9j/78AAGwQCogrHeVPLiAhizf8YMgVoP/lAA/uAS4kIQ3MAQy7DOuJCHjIBIAAwCDRDwMAhgkC -YZsVKCAFJSAH+CEGFe/01QD8QEgV4AMlAP0bQEHRVQEAiimbK/tAB+xiAJ0AG+U4C1sJK70CLLEI -K7EE/WAEs6IAnQDBz/2ABGDiAJ0AAioCWGDOiyIDugFkr5qKJwS7AesmAiVQwQAAWFqx26Dj5QoV -ASGAACiwANMPA4gKiIwssAf6QGgdoA1FAAuAAOukAA1/JgAAiScPAgBkn1iKmiuSCcqnZL9OKLAA -A4gKiIwssAf6QGgdoA01AAuAAOukAA1/NgAAY/8tAAAAAAD//0wNoAsFANogWGC7KyAi6rsMCVAE -gABYYgvaUPoAIh3gDAUAWGK6iyIDugHzf/rWYgCdACwgB+S9AQlQBIAA/EBGFeG8AQDrvB8pYASA -AFhoE8Ag0Q8A6yAiKVAEgABYYfkqIAXB436hDGioKYsi82AEBX/8XgAvIDrAj3j56vpAaB2gCwUA -/AACHaANJQBYYSVj/9cAAPpAaB2gCwUA/AACHaANJQBYYKNj/78AAGwQBCkwFglZFPUgBliSAJ0A -8S2wDe/65QDj5L8UpfkAAGiVBMAg0Q8AKyAGsLsLC0frJAYt/34AAI0ijCcK3QHtJgImUMEAAFha -WcmsKKAAA4gKiIzsoActWASAAPpAaB2gDUUAC4AAZa/hiSdkn7OKmmSgmoqZZK+pKKAAA4gKiIzs -oActWASAAPpAaB2gDTUAC4AAZa/hY/+IKSAGsJkJCUfpJAYs++4AAIwiiScKzAGcIouaZLBOi5ko -sAADiAqIjNog/WDwFaANNQALgADAINEPAAAAAOokAAnYBIAA7EQACugEgABYaX3AINEPAOokAAnY -BIAA7EQACugEgABb/1PAINEPAP/+vA2gCwUA//2MDaAKBQBsEATRDwAAAGwQCBXknRTkfBfknZIS -+CBIFaAKBQD6IGYVoAlFAJkUGuSXCIIJ4IEECReCgAD2QABD8AgVAOoiCAxACoAA+CAmFa/59QD5 -FwAMcAYFAPggBhWgAIoAmxOMFLFm4iwMI7gxAADlXAImY/0AAOwWBCYE8YAALVHC+sAEANALFQDg -uxoOo0wAAC5xfmTvygIqAlhiyY8R+sAEANAIFQDgiBoNGASAAOgWAyeAaYAAiaKKEAqZAZkyijcq -rDBYWfXJrCigAASICoiM7KAHLVgEgAD6YGgdoA1FAAuAAGWv4Yk3ZJ90iprLpyqSCWSvaiigAASI -CoiM7KAHLVgEgAD6YGgdoA01AAuAAGWv4WP/SYsT+iBIFaAJFQALmzlYY5vRD///GA2gCgUAbBAG -HeRWCysRrbMqMn8Z5FQV5D6IoPigAETwBAUA6bkIBAGRgAAsMngvMnv5gAWEYgCdAGXw7Cw2fCsy -eSs2e91ADeQWlKAN5BbAyfxABhQiAJ0ALzJ7wcDt5EIXg5mAACIyfCohBI4g8+H+Daa6AQAkNnz0 -b2YVoAAeAC42fO2vAQXD/QAACP8C7yUEJYxZAAAiMnywzO8yeyEA8YAAycZj/7/aIFhiNmWgnSoh -BP9BAAwWmgEAyJjRD9ogWGNh0Q8A2iBYY5TRDwAAAAAAAPpAaB2gCwUAWGNh0Q8AAADq0mAhY+EA -APuABADQCxUA/WABBd/89QAMuwMLqgEq1mBZhiEkNnwkNnv6b+gVr/zKAFl781hh6C1So2TfNVl7 -xGP/LxzkEf5viBWgClUA+G9IFaALRQDoFgAha+UAAFmBQPpv6BWv+9IAKTJ74jZ8LPtGAAAiNnvR -DwAAbBAEFOQDGeP/6OPpGV7CgACktCNCf6mI6LgIAYJBgACKMHipAipCexzj+CsxBCpGfwy6Aeo1 -BCnQBIAAWGH5zq4pMQT/IQAMFtkBAMjX0Q/aMFhjJdEP2jBYY1jRDwAAAAAAAPpAaB2gCwUAWGMl -0Q8jRn/RDwAAbBAE8GDwDe/59QCIIgk5AwmIASgmAoonDwIADwIAKqwwWFlc4+O2FQERgAAooAAD -iAqIjOygBy1YBIAA+kBoHaANRQALgABlr+GJJ8uUiprKqIqZyawooAADiAqIjOygBy1YBIAA+kBo -HaANNQALgABlr+HRDwAAAAAAAP//UA2gCgUA0Q8AAGwQBPJdABXgGMUA+EAHXCczAQAU44v0YAXS -EgCdAAw5EaSZKJKe0w/3AAcG0gCdACmSnWSQzxzjnhvjtgIqCQyqCquqWGH7+kAEANAJFQD9IAEE -3/v1AOKkAASAcYAAiqILmwMLqgGaIoonDwIAKqwwWFkm4+OAFQERgAAooAADiAqIjOygBy1YBIAA -+kBoHaANRQALgABlr+GJJ2SQZCqSCsqmKpIJyawooAADiAqIjOygBy1YBIAA+kBoHaANNQALgABl -r+HRDwAAAP//XA2gCgUAFeNcilhqoTcMORGkmSuSnm69PimSneSQOmVb/QAAm1hlnz5gAAvaMFl7 -amWvM9EP0Q/RDwAAAAD//IwNoAkFAMCgWYESilhrob3//0gNoAkFAMCQwMoMrDT8oQYVr/8OAAAA -AGwQBBjjQQIDRwwzEagzKzKEGeNKKLAAKrIBCYgKCiGMAgo+KIIMAwI+/EBoHaANJQALgAAiNoQM -AgDRD2wQBBTjMgIDRwwzEaQzJDKEikEmQAAoQAj6mGgdoKklAAIFPgMCPnmBJRjjNQhoCoiM6lQA -ClgEgAD8QGgdoA0lAAuAACI2hAwCANEPAAAA6yQAClAEgABYYbvzQGgdr/8uAAAAAAAAbBAEGuM0 -KqJGK3rQC6ooFONL/0AAFTALFQALqgL6luYVoAkFAAnkMRXjRhjjKyhWhCVShCNCt2YwDW0IBStC -t2awBGP/8wAAHOM/IsaKY//8AAAAbBAEWX/sEuMCE+MdKSKC0w8JGo4DqAqIgAuAAGP/7ABsEAQq -IgcqrBBYYpjRDwAAbBAEiCcijBDaIFhid2ihAdEP2iBYYnES4ysLqBHoIggFAdmAAAzqMCsihSuy -ACKs/+y7CAlQBIAAWYTvHOMjKsJ/+kAEANALFQAAuxoLqgIqxn9ZhR7RDwAAAAD6AOIdoAsVAFhi -Tywifywmg9EPAGwQBCYiBw8CAOZsECnQBIAAWGKy7DQACmgEgADuVAANWASAAO8iACtQBIAAWGH1 -0Q8AAAAS4woD6DAE7jAFsTCTIJQhlSIS4wYT4tSEIAQzApMgEuMEwDAoN0AoN0QoN0goN0wjPQFy -M+0DAgAS4v4T4t2TIMcvE+L9AyMDEuL8hCAENAGUIBLi+4QgBDQBlCAS4vmEIAQ0AZQgEuL4hCAE -NAGUIMcvwDEDIwMS4vWEIAQ0AZQgY//8AAAAEuLygyADExQPMxGTIFf/2hDi75EAkgGTApQDEeLt -ghAB6jCiEQHwMcBABOQWAAIAEeLpghAjGgADIgKSEBHi5sAhkhAE5DGEA4MCggGBAADSMAEjAAAA -ABDi4ZEAkgGTApQDEeLfghAB6jCiEQHxMcBABOQWAAIAEeLXghAjKgADIgKSEBHi18AhkhAE5DGE -A4MCggGBAADTMAEzAAAAABDi0pEAkgGTApQDEeLQghAB6jCiEQHyMcBABOQWAAIAEeLFghAjSgAD -IgKSEBHiyMAhkhAE5DGEA4MCggGBAADUMAFDAAAAAABclAFdlAJelANflABDAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXJABXZACXpADX5AAUwAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJyUAB2QAZ2UAp6U -A5+UBAiUBQmUBgqUBwuUAEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACckAGd -kAKekAcdkAOfkAR4kAV5kAZ6kAd7kABTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAA3JQAHZAB3ZQC3pQD35QEBJQFBZQGBpQHB5QICJQJCZQKCpQLC5QAQwAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAANyQAd2QAt6QCx2QA9+QBLSQBbWQBraQB7eQCLiQCbmQCrqQC7uQAFMAAAAf//uQ -ANIxEP/+CgAAAAAAH//72ADTMRD//goAAAAAAB///CAA1DEQ//4KAAAAAAAA9DAKAAAAAAD0MAoA -AAAAAPQwCgAAAABsEAQqIhAooAUpCpL5AATlYgCdACsiGPrgAAZwjbUA/YAETWIAnQDzYAQr0gCd -AP9uwAwfyQUAi62Ot4jqjOiN6y/sIOn/AQZQwQAA790IBEDBAADo5gom6QEAAOrTYH5IBIAAfaFp -muga4RwKAIcJAmEJAmEJAmHAgejGBSlQBIAA+YDmFaAOBQD/gIYVoA0lAP+AxhWv//UA78YDL2AE -gABYA3vAINEPWMcSwCDRDxnhDAm5AfhDBhXgAgUA0Q8M2gwK+gwqrHD7wQYVr/5yAC38QP3BBhXv -/kYAbBAEE+EBAyIC0Q8AbBAEFuD/JCAHiWDAc/EyQA3hRAEAKSIYCehR9QAJiJIAnQDzwfAF4anh -APVACYiSAJ0A9IAGchIAnQAMSRGjmSuSnvdgCsnSAJ0AKpKdZKEzG+Do6wAFDUgEgAAJAmEJAmEJ -AmEpIQcb4Oj/wdAF6pkBAOzg5xzPAoAAC5kCmaAZ4OX+QAgVoD0FAJ2n/UCmFaAbhQCbo5mi7+4C -D0YCgACepPcGAAxwDgUAnqaYoSgiGAiIQe6mCCxHAoAAmKnt4NYafwKAAKP/J/adLCIYnmAqIhAN -zALsJhgpWASAAFi35QUKR2iiGIon+gAiHeAMBQD7RAAVoA0VAFheCdKg0Q/AINEPHODFi8j3YATQ -kgCdAAxJEaOZLZKe96AFIdIAnQAqkp3koJtl6/0AAJ3IZa8eYABPjiKxn+9mACcBqYAABQhH9QAE -SRIAnQDAINEPKhoACpkC+EMGFe/7JgAAACsqAAubAvpDBhXv+yYAAAAAACtMGOokAAlgBIAAWGOQ -Y/+9AACMImXPtitMGOokAAlgBIAAWGOKY/+lAAAAAAD/+qgNoAoFAMCgWX4KHOCbi8j5f/rgkgCd -AP/9xA2gCgUAwKDA2g29NP2BBhXv/YoAjCePyorJ/4QAFa/IBQDo7gEH+EEAAO/GCiVTwQAA6sYJ -J3EBAAB+qymJyx3giaqamsmdoIwg+8EOBeANFQDrpgIuZgKAAA3MAv1AJhWgAgUA0Q8d4H+doIwg -+8D8BeANFQDrpgIuZgKAAA3MAv1AJhWgAgUA0Q9sEAjkIhAqYASAAOdCByvQBIAA6+BzGXAEgADy -gsgVoBg1AOdyDiL76QAAePspGOBtCPgKiICaFJwS7hYBLAAigAAAAACSECqykexUAAnYBIAAWXzN -ZKYv8oLGFaACBQDRDwAAAAAAK+IYC5tS7hYBJf85gAAa4FriFgAp2ASAAOqisyrgBIAAWXy/ZKRZ -IiqAonKSFSIg3hrgUtsw6qK1KuAEgABZfLj7QEEAEgCdABrgTNsw6qK3KuAEgABZfLL7QEFoEgCd -ABrgRtsw6qK5KuAEgABZfKxkppQa4EHbMOqiuyrgBIAAWXyn+0BC4BIAnQDBOPJAHrhiAJ0AaScj -ixUjtN2LEPqCxhXgAgUA0Q+SECqyiexUAAnYBIAAWXyaZKbbixD6gsYV4AIFANEPAACSECqyl+xU -AAnYBIAAWXySZa8S+iBoHaALtQBYtNT6ACId4AMFAOqzOAUBiYAA6hICK1gEgABZedLDsOzgHh0o -BIAA/KBoHeAKVQBZfSTIWRzgGo0RDFw2LNYXZTTgjRD8gsYV4AIFANEPLkByZO61khAqsq3sVAAJ -2ASAAFl8dmWuovogaB2gG2UAWLS4+gAiHeACBQDqsjgFAKmAAOoSAitYBIAAWXm2LH0DKsUoZSSM -jRD8gsYV4AIFANEPAJIQKrKf7FQACdgEgABZfGJkovsa3/fbMOqiiyrgBIAAWXxdZa5A+iBoHaAL -VQBYtKD6ACId4AIFAOqyOAUpmYAA6hICK1gEgABZeZ4sQHPxgCju0gCdAGSlFYoU+gCiHeAM1QBY -tHzSoNEPkhAqsqXsVAAJ2ASAAFl8R2WutPogaB2gGyUAWLSKZKPzK0By+2BEIBIAnQDqEgIrWASA -AFl5iCxCF4sQK0YWCsw2/ILmFaACBQDRDwCSECqyo+xUAAnYBIAAWXw0ZKJzGt/J2zDqop0q4ASA -AFl8L2WuVPogaB2gC+UAWLRyZKOT6hICK1gEgABZeXMrfQIqtRSLEPqCxhXgAgUA0Q+SECqylexU -AAnYBIAAWXwgZKJ6Gt+02zDqoqEq4ASAAFl8G2SjtxrfsNsw0w/qoo8q4ASAAFl8FmWt7vogaB2g -C3UAWLRYZKMtK0ByZLfyGt+lixLqotsrYASAAFl8DGWm5ytAc8DIDLsCK0RzixD6gsYV4AIFANEP -AACSECqyq+xUAAnYBIAAWXwBZKI/Gt+W2zDTD+qijSrgBIAAWXv8Za2G+iBoHaALZQBYtD5kosUr -QHJkt3ka34uLEuqi2ytgBIAAWXvyZKeIK0BzLAr9DLsBK0RzixD6gsYV4AIFANEPAJIQKrKT7FQA -CdgEgABZe+dkogca33zbMNMP6qKHKuAEgABZe+Jkowoa33bbMOqipyrgBIAAWXvdZKw/Gt9y2zDq -oq8q4ASAAFl72GWsLMCl/b7gBaA7BQBZfHYa32qLEuqiyStgBIAAWXvQZaQYixErshgLmVLImWiS -B/kgBPnSAJ0AjRGMECvWGPyCxhWgAgUA0Q+SECqyg+xUAAnYBIAAWXvCZKG7Gt9X2zDqooUq4ASA -AFl7vWWsjPogaB2gCyUAWLQAZKHLGt9OixLqotsrYASAAFl7tWWsa4oU+gBCHeAM1QBYs+HSoNEP -AAAAAAAAAOoSASpYBIAAWLP7zayCFSIg3mP8FwAAAOoSAitYBIAAWXjw9UAq8pIAnQDHL9EPAPog -aB2gC/UAWLPlZKFi6hICK1gEgABZeOfoEgAjyAsAACqVFfiCxhWgAgUA0Q8AAPogaB2gGxUAWLPZ -ZKEyKkByZKXUKUBz8T/ez5IAnQDxP96P0gCdAOoSAitYBIAAWXjVLUIYHN8j+6EADrA7BQD8gwYV -4ApVAFl8JYsQ+oLGFeACBQDRDwD6IGgdoAulAFizw2Sg2i5ActMPZOTl6hICK1gEgABZeMMvQTb7 -4A8CogCdAIoU+gFCHeAM1QBYs6LSoNEPAAAA+iBoHaAbVQBYs7NkoJrqEgEqWASAAOwSAitoBIAA -WLM6ixD6gsYV4AIFANEPAAAA+iBoHaALlQBYs6dkoGooQHJkhIga3vWLEuqi2ytgBIAAWXtbZaHN -K0BzjRD8gsYV4AwVAAy7AvqOZh3gAgUA0Q8AAAAAAAAA+iBoHaALFQBYs5XKohre5IsS6qLbK2AE -gABZe0tlqsOKFPoAIh3gDNUAWLN30qDRD8Cl/b3CBaA7BQBZe+XAINEPAAAAAAAA+iBoHaALhQBY -s4P6ACId4AIFAOqyOAUBSYAALEByDwIAZMP5Gt7U6xICK2AEgABZezRlof0tQHPA6A7dAi1Ec2Uv -pY8Q/oLGFeACBQDRDwD6IGgdoBsFAFizb2SviihActMPZIOE6hICK1gEgABZeG8pQhmLECtGFgqZ -NviDJhXgAgUA0Q8AAPogaB2gCzUAWLNhZK9SGt6wixLTD+qiwStgBIAAWXsW4960HQO2AACLESuy -GAvJUciZaJIH+T/tkdIAnQCOEYwQA70BLeYY/ILGFaACBQDRD2UvDI8Q/oLGFeACBQDRD4gVwJgJ -IgIihN74IEgVpyIBAPj6xhWv5VYAAAAAAAAA6hICK1gEgABZeEYqRTaKEPqCxhWgAgUA0Q8a3o2L -EuqiwytgBIAAWXr0Za09ixErshgLyVFokQpokgf5P+lh0gCdAB7ejAO9AQ7dAo4RjBAt5hj8gsYV -oAIFANEPihT6ASId4AzVAFizFNKg0Q8AAPogaB2gC0UAWLMlZK5ijRH9vPwFoApVAP2jCBXgOwUA -WXt7Gt5vixLqosErYASAAFl61ePedh0N1gAAixErshgL6VHImWiSB/k/5XnSAJ0AjhGMEAO9AS3m -GPyCxhWgAgUA0Q8a3l+LEuqiyytgBIAAWXrFZayDixErshgLmVJokQpokgf5P+OR0gCdABLeYPgg -KBWijgUArn4CsgIihhgt4N38IAgVoA8VAA/dAi3k3fyCxhWgAgUA0Q+KFPoBAh3gDNUAWLLg0qDR -D4gV+iBIFaAPJQAPLwLvhN4rWASAAFl39IgVIoDe+xuGHa/fDgCKEo0V+7yOBeAJRQAJKQL5u8Yd -4AwlAFl6n2ShqYoS+7yEBeAMJQBZeptkoZkb3j/6IEgVoAwlAFl6l2ShoIoS+7x2BeAMJQBZepNk -oZCCFfJb0BWv3g4AAADAsPggqBXgGAUA+EYADDNjRQDy4ABB8IwFAOiU3inQBIAAWXdt+HyCHaAL -BQD44ABDsIwFAOMWAyvQBIAAWXdmhRLacOVcAiMb+QAA7DQACtgEgABZd1Ub3hz6IEgVoAwlAFl6 -dmShNBveGfogSBWgDCUAWXpyZKEjG94W+iBIFaAMJQBZem5koSKKEvu8JAXgDCUAWXpqZKESghXy -W9AVr9wiAAAAGt37ixLqosMrYASAAFl6YmWq9osRK7IYC+lRaJEKaJIH+T/XKdIAnQAe3gKMEQO9 -AQ7dAv2DBhXgClUA/bv8BaA7BQBZevaLEPqCxhXgAgUA0Q+KFPoA4h3gDNUAWLJ+0qDRDy8qgK9/ -IvDewIEIIgL+IKYV5yIBAPP7xh2v2KoAAIoU+gICHeAMxQBYsnLSoNEPihT6AUId4AzFAFiybtKg -0Q+KFPoBIh3gDMUAWLJq0qDRD4oU+gECHeAMxQBYsmXSoNEPAIoS/N/AFaNrRQDrewgFUAkAAFi0 -E2P+TYoS/N/AFaNrRQDrewgFUAkAAFizU2P+VtpQ6xIDKeAEgABYtAlj/svaUOsSAyngBIAAWLNL -Y/7cihT6AkId4AzFAFiyTdKg0Q+KFPoCIh3gDMUAWLJJ0qDRDwCKFPoAwh3gDMUAWLJE0qDRD4oU -+gDiHeAMxQBYskDSoNEPihT6AMId4AzVAFiyPNKg0Q8AAGwQBCgiGPjgAAQwicUAeYEn9EIIFeeV -AQD1IAmpEAcFAIk3iprkkgklAKGAAItD7EIFJYRlAADJwcAg0Q+Nc9Rw7nIFJoQdAABl7+wmIAf6 -QGgdoWYBAPrAaB3gPAUAWDArZKHUi0MpQgUPAgD1YAd4EgCdAGSRX/tC5h3vjgUA/0AmHaj7HQD/ -QsYd6P8dAP9Cph3o/x0AL6QULSIW/UPmHejdHQD9Q8Yd6N0dAP1Dph3o3R0ALaQcHN2EDGoR/UAA -RTAJVQCZoCogFvpA8BXg+PUA+UbGDaAZ9QD5uvoFoqwFAAy8HajIKIJ/CpkM+QALemIAnQAf3Xf1 -QAAWsDgFAOjdAg33AoAAr+6d4Ik4jEfqMgkkgJGAAJc7maCLOJqxJzYIJzYJ7t1sFgBpgAAtIhgO -3QItJhiKN/oAYh3gDAUA+0QAFaANNQBYWovAINEPizhkvslj/94AAAAAAAD5P/ig0gCdACekAC1S -E7Hf/qJmFejtHQD9Q2Yd6M4dACykGf9DRh2ozB0ALKQYKVIQHd0wsZkNnQL4ogYV6IcdAPlAxh2o -+B0A/0CmHejvHQAupAQnpAf9QmYd6M0dAP1CRh2ozB0A/UImHajMHQD9QgYdr/qWAADE0C2kAIxG -/UDmHajMHQD9QMYdqMwdAP1Aph2ozB0ALKQEKVIT+UNmHeiZHQD5Q0Yd6JkdAPlDJh3omR0AKaQY -iET5QmYdqIgdAPlCRh2oiB0A+UImHaiIHQD5QgYdr/kKAI44Ze35iS4a3SbqNgsh+IEAAO+WASFA -4QAAmDmZOP5BxhXgAgUA0Q8f3R8KrQoe3R+vzw/dC67dK9F/K7zQB7s1+6/kHe/6PgAAbBAEJCIQ -ZEB1KDAYKTAZKyIW6jAaLEYCgAAJiALpMBssRgKAAAqIAgiIEQmIAuuJB3XIBQAAKSYWKSIY0w/q -3QkUwCiAAAqaASomGCswECwwEe0wEi3eAoAADLsC7DATLd4CgAANuwIIuxEMuwJosBIsQAUtCpX9 -gAhMYgCdAMAg0Q8ALjAULzAV6DAWL3YCgAAP7gLvMBcvdgKAAAjuAgjuEQ/uAv3Y4ABfyQUAi02N -t4jajtjs0gsm+IEAAAn/AersMC9IBIAA78wIBEDBAADo1gomYQEAAPuABYOiAJ0A/UAFzCIAnQCa -2Bzct/wACB2gCjUAbaoCCQJhKTAUKjAV7DAWLM4CgAAKmQLqMBcszgKAAAyZAgiZEQqZApnjKDAQ -KTAR6jASLEYCgAAJiALpMBMsRgKAAPsGAAwwDAUA7OYFLEYCgAAJiAKY5C8wBCgwBekwBi/+AoAA -CP8C6DAHL/4CgAAJ/wII/xH55gAPsA0lAO/mBilQBIAAW/7/Y/7tANpAWMJawCDRDw7KDAr6DCqs -cPuhBhWv/UYALPxA/aEGFa/9GgAAAABsEAgW3K7Apf25XAWgOwUA9NYoFaANBQBZeZkoYk75uP4F -4AUFAPEc4A3gBhUAmRUY3KWYFoxMLcEEjsD7v+AV7/U5AO/FBS3PAoAA6ekID78CgAAHlwwHAIf3 -gGQV5qUBAAqmYP1DQEdWdwEADPgRCJgMCCCHwKAKpmL1QAwPUgCdAH+5Cch2+uAMpCIAnQAY3I4X -3IrogigvzkKAAKmpJ3KrqYgJiBGod4l68yAJxSIAnQDy4AmEYgCdAJcU/bkGBaAKVQD84AgV4DsF -AP7gsBWgCQUA+CAGFeAPBQBZeWiNFPe47AXvmHUAKNQFitj29igV755lAP+gph2gDAUA7NYKJQC5 -gAD8IMgVoAolAPwgiBXgOwUAWXlZHdxojBQt0p4qwh6MwA3MDOwWByV8/IAAixQqshkrshj+7ggV -qAA9APtrAA0wDAUA++AABTANFQD7WgANMC8FAO6qCg+CCoAA+0AIFaC7nQBYWSGLFI23jNrkwAlm -0IEAAI7ZYAABwOCN4Q0NR/ugaB3gDAUAWFltjhWLFIoX7gAFBciBAAAJAmEJAmEJAmEJAmEJAmEJ -AmGIt/8EABXvyQUA+eAEB/AJBQDphgon+QEAAP8BBhXgDAUA/wEmFeANFQDqcgwtWASAAFhZAhrc -NSqiTrFV+r/yC6AGFQDRDwAAAAAAAO3BBCf4BQAADw9PL8UFffFcsNsMuRH5wABE//lOAAAACfsR -+0AARf/59QD/oAATNfsdAObuCA//goAA/88AD3AGFQD/34AVpLsBAOjiAC2BCoAA78EFK1gKgAAJ -uQMJiAEIuwKb4P+ACBWv/loAwPAvxQX//mgNoA8FAABsEAyIIs6PKSIYGtwSF9vk9iBmFeGZQQDn -2+Yc3oKAAOsWAizPgoAA+yAARLAb5QD4IIYV4ARaAMAg0Q8uUhsc3AaurnrrAbGILlYb+KNGFaAI -BQAd3AKKGA2qCgiNCejcABRIBQAALiEHCJkCGNvRDg5KDO4RCO4CnkAY2/qOIPiARhWgSAUAmEMY -2/cO3REt3G/5xgAMNN0dAOhGBC92AoAADt4CGNvxnkEqoqEuYiUpRhQZ2+8IqgH/zwAPcAgFAA6Y -OY4SCO4CDqoCDKoCmkeKFigiFYkpqojqmQgEQMEAAOgmFSTIwQAAmSmOFwzuEafuLead+ELQFa+a -hQAqNAUqIAf/t44F4Pn1APkFZg3irgUADq4dr+8v8n/BnwiZDPngIzJiAJ0AHdvSCI8Q778CDU8C -gACtmZ+TKWImKGIl+QAdtGAb5QAsIAcMDEEMyBGniCqCnpwYnBf7QCDD4gCdACSCnY0T+iCIFeAZ -5QDoRAACIBmAAA0Ah+uyqCJ5gQAAnxVtmgIIAmGINyoiF40pjoqGjokqJYIJ7GImJxqhgAAoYiUu -YiwNmQwMiAwO7gkF7gsKiDYoFgvouwgHccEAAOsWBiXYwQAA6xYALGAEgAD7IBRr4gCdACogFhnb -lf5A8BXg/fUAfaF5HduilR70IaYVoqUFAAX1HQqkCq1dqVUFRAsV252THKVE5dJ+JRhBAAD6YAQA -0AMVAAA5GglVASnSfwWZAinWfyVCfwChBOMSDCnQCoAA5BYBIqgFAAAlRn8t0oCEHYUe+6AX2KIA -nQAd24cM+RENmQgpkgAJqgFkov0qXDjqBgACSKEAAPiCaB3gD1UAL0QgLTIb/IZmHejdHQD8hkYd -6N0dAPyGJh3o3R0ALUQwKmIk+obmHaiqHQD6hsYdqKodAPqGph2oqh0AKkQ0KSIW+IfmHeiZHQD4 -h8Yd6JkdAPiHph3omR0AKUQ8LWIo/IjmHej9HQD+iMYd6P8dAP6Iph3o/x0A70REJugFAAAtZigq -YicpYib4hOYdoA8FAP6EJh3o2B0A/ITGHej9HQAvRCX5QABFeN8dAC1EJPqJZh2oqh0A+olGHaiq -HQD6iSYdqKodACpESC9iJQn/DO+JCnJJYQAALfqALUQhKlIZDwIADwIA8VIADeANBQAtZiAtZiwK -ijbqRhUi4aEAAAwgiAkEii9iJqr/L2YmKVIZCowMKFIaCpkM6VYZLOUmAADxl5AN4AgFAP7ECBXg -2AEADvoKjxWKoA/ZCgrKNpqQKWIgDpkL798LBMghAADpRgAH+CEAAA8IiiliIC9iJg6ZCqr/L2Ym -j5AK/wyfkC9iIA75ComQsYjqzAwEgSmAAA7+C4XjHNsWj+KlpZXjelsBsf+f4v7EyBXv8QIAAAAA -APHjcA3gCgUAKWIsLuwY6mYgJMgFAAD4xYYV4A8FAIkVKpwY/U0ADPDYAQDpFgUuew4AAP22BAWv -/vYAwPEvZiD//2gNoA8VAACeGYsQ6BYKKVAEgABYN6qIG4wajhnrEgAlavGAAGP7si9iIA76Coqg -7v8LAmlhAADkrwNn+CEAAAqKNipGFQ9giA0MiiliICxiJg6ZCqrMLGYmj5AK/wyfkC9iIA79Co3Q -6owMBoLRgAAO/guP4xza4Yjir696+wGxiJ/j+cBGFaAIBQD+xMgV7+2eAAAAAP/ysA2gBQUAiDhk -izaJOcAgkjuYkIo4maGSOPJhJhWgAgUA0Q8c2s//+8ANoAgFAMn5LWIs/8MAFaAPBQDvZiAm6AUA -APzFhhXv+X4AwIH4xAYVr/lWAACNES3dAirRAinRAS3RBQqZAf0/6BrgChUAixjaIOu8EilgBIAA -WF1+wCDRD4sY2iDrvBgpYASAAFhdecAg0Q8AGdqqCI8KqekJ/wsZ2qip/4kWLfF/Cd0M/boAFeAJ -BQAJ3TX97+Qd7+4mAABsEAaLJycgB4i68wlgDeF3AQAjsgkFCEdogggpIHQImRApNgD9tVIFoApV -AO2yAilwBIAA/kAIFeA7BQBZd4P9tUYFoApVAPoGAh3gDUUAWXd/Ftpp9OASmhIAnQAMeRGmmSqS -nvdAFppSAJ0AJJKdZEKh/bUuBaAKVQD8YBAV4DsFAFl3ciowAMO0DwIA+0ASVGIAnQAqPQYloAHD -sA8CAP21GAWmVQEA/KBoHeAKVQBZd2bp2k0Z0ASAAPSgESCSAJ0A9KANIRIAnQD0oAzikgCdAMDA -CQCH6RYAKlgEgAALAmELAmELAmELAmEjIQcoIAce2nr+QQQV6jMBAPgCAAWxiAEA6rsQDEQCgADo -/wIJnwKAAAszAhjabxvaOw7/AggzApNAjSD+gIYV4DgFAPiAZhWgAwUAk0WTR/qARhXgCUUA7kYG -IliBAAD9oAAWsA5FAP+mAA6wDiUA7UYBLm4CgAAKIIYLAmMKAIbrDAABUMEAAA7dAu1GCSJZAQAA -CoCGCwJpCmCGCwJnCkCGCwJlDH8Rpv8p9p30oAqqkgCdABTaT/hBCBWvmnUAKiQF8pEoFe+ZZQD4 -QKYd4AYFAOYmCiQAuYAA+gBCHaA7BQDs2i8ZaASAAFl3HCsiHihCdiQiAOhEDAgECoAA82AEH9IA -nQArIgcpsgrkkO1l0IEAACuyCS2yAfQgCBXn3QEA+6BoHeAMBQBYVz7lAAUBSIEAAAkCYQkCYQkC -YQkCYQkCYQkCYY8n/+QAFa/IBQAI7gHm9goncQEAAO72CSpYBIAA/+EGFaAMBQD6YYgVoA0VAFhW -1sAg0Q8AAPxGUBWv+ZoAKiIZKyIY/m4IFagAPQAKuhgKCk8Kqg//QAEFMAwFAPtACBWgDRUAWFbI -Y/9TAAAA//W0DaADBQAV2dmKWPdABHiSAJ0ADHkRppkrkp73YAT6UgCdACSSnWRAlrCr+qEGFe/2 -bgAAAAD6YIAlr/bmAPwQQh2v97oA//xYDaALBQD9s/gFoApVAPoGAh3gDQUAWXbR6iIKKVgEgABb -/S9j/o2JJ4yay8+DmY0iZNBR/GAIFeAKVQD9s94FoDsFAFl2xsAg0Q8AAAD/9MANoAQFAMCgWXcg -ilj5X/tQkgCdAP/0ZA2gBAUAAP/+9A2gAwUAwEDA6g6uNP6hBhWv9AYAANog79ndGWAEgADvNgAj -2GEAAFhci2P/lWwQBoknIyAHKJIKAwNB55IJJA7xgAAFCEfogg1p0ASAACkgdAiZECl2ABnZkAw7 -EfRgDiISAJ0Aqbsssp73gBI6UgCdACuyneS0AAWPoYAAFtmDmhAT2YnmAAUKWASAAAsCYQsCYQsC -YQsCYS0gByghBxvZtvlAAAQwzREA6swQDEcCgAAMiAILiAKYQI4gw1D0gGYV4A9FAONGAi9mAoAA -D8wCnEErIDP0Q8gV4AMFAPxgaB2giJUAC4w58qAM35APJQAY2aMuIQiTReNGBy4uAoAA/qYACvHd -AQDoRgYu7AKAAA3uAvnGAA8wC0UA7kYEImiBAAAHIIYNAmMHAIYNAmGVSRXZkwyuEanu+9OmFe+d -dQAtJAWOKPSxKBWvmGUAKCQF4yYKJwC5gAD6AEIdoDsFAOzZcxloBIAAWXZgKCIeKVJ2hSDpVQwE -fdKAAIkni5rksOBk0IEAACuSCS2yAQ0NR/ugaB3gDAUAWFaG5gAFAUiBAAAJAmEJAmEJAmEJAmEJ -AmEJAmGPJ//kABWvyAUACO4B4/YKJ3EBAADu9gkq2ASAAP/hBhWgDAUA+oGIFaANFQBYVh7AINEP -AAAqIhkrIhj+jggVqAA9AAq6GAoKTwqqD/9AAQUwDAUA+0AIFaANFQBYVhJj/2IAAAD/+IgNoAcF -ABTZI4xI4xYAKAQKgAD3gAQ4kgCdAAyrEam7LbKe96AEwlIAnQArsp1ksI+wzZ1I5LQADfEuAABg -AA0AAAAAAAD//IwNoAsFANog7tlIGWAEgADudgAh2GEAAFhb9cAg0Q8AAI0q/bKEBaA7BQD9oAgV -4ApVAFl2FBnY/4oQ/EDwFeAPJQD8EaIdr/kOAAAAAP/28A2gCwUAwKBZdmqMSIoQ6dj0GAQKgAD5 -n/tAkgCdAP/96A2gCwUAwLDA6g7ONP6BBhWv/a4AbBAIiCcjIAeJigMDQeeCCSSPOYAABQhHaIIH -KSB0CJkQmXAqIDMV2OHyIKYV4AwFAPNAPA3gCwUAnBL6IIYV4ARFAPRgDcoSAJ0ADDkRpZkukp71 -wBgLogCdACiSnegWAyxQBIAA5tjNFBARgAD2AAgdoAMFAG1JAggCYSsgM2WyDSwhBy0gBxjZAvhB -BBXqzAEA/CAABfDdEQDq3RAOZwKAAO3MAg3cAoAAC5kCHdj3CJkCG9jCDcwCnKCOIJimk6WTp/tA -RhXgPwUAn6P5QIYV4A9FAOkSBC92AoAAD+4C7qYBJWCBAAAHIIYMAmMHAIYMAmEX2Of9IAAUsAsl -AAuZApmpiBXtIggsRwKAAKWI9ROmFa+fdQAvJAX08SgVr55lAC4kBeMmCiaAuYAA+gBCHaA7BQDs -2MMZaASAAFl1sCoiHihydoUgDwIADwIA6FUMBX3SgACIJ4mK6IIJJFCBAABkkMgtggENDUf7oGgd -4AwFAFhV1OYABQFAgQAACAJhCAJhCAJhCAJhCAJhCAJhjyf/5AAVr8gFAAjuAeP2CidxAQAA7vYJ -KtgEgAD/4QYVoAwFAPqBiBWgDRUAWFVswCDRDwAAKiIZKyIY/o4IFagAPQAKuhgKCk8Kqg//QAEF -MAwFAPtACBWgDRUAWFVgY/9iAAAA//hkDaAHBQAW2HGKaPdACriSAJ0AiRUMmRGlmSuSnvVgCyui -AJ0AKJKdZIFcsKv6wQYV7/jOAAD//MwNoAgFACggNSkgNiQgN+iZEQxEAoAACYgC+IYACjCIlQDk -FgIiIZ0AAPgghhWkRB0A9ICAFa/3bgCIJ4qKZKEEh4naIOvYjRlgBIAA63YAIdhhAABYWzjAINEP -AAAa2EuIEhnYhi0hCI4nKyEHLCAHju7+IAYVqrsBAPwgAAcwzBEA7LsRDmKCgADsuwIPdAKAAA7d -AhzYcY4TCd0CDLsCm+CMIOPmBSR5IQAAn+Pq5gIkWZ0AAP3AhhXkux0A6xYBLmYCgAAMuwKb4QcE -iQ4gi/nAxhXgugUAmucvIAz5BgAVoDwFAOjmBy/8AoAA790CAVjBAADt5gQnUKEAAFlxbIoTixDs -EgIlUWEAAFlxaIsRihMMuxH7QABFf/TSAAAAAAAAAP/0CA2gCAUAwKBZdYaKaPlf9RCSAJ0A//Os -DaAIBQAA//vkDaAHBQDAgMDKDKw0/MEGFa/zTgAAbBAEGthIKSIYGNhHCpkBKSYYLjIJ/wAWIKIA -nQAuIhMtMQsqIhQb2EEO3QgK2gztJhMlYQMAAHyzBR/YPXr7EvpAaB2gCwUA/AACHaANJQBYAgcr -IhIkCgDTD/NvkA3gPhUALbAwDQ1FftEvL7BIKLBJLCIW6bBKL/4CgAAI/wLosEsv/gKAAAn/Agj/ -EQj/Auz5B3ZABQAAKCYWKQoh+aAP7GAqJQD7oBCsICxVAP2gC0wiAJ0AftEXKgoC/bA6BaA7BQBZ -dOr0QkYVoAIFANEPLbAxLrA0irrxoAmWEgCdAC+wNeiwNi92AoAADwIAD+4C77A3L3YCgAAI7gII -7hEP7gJl4QgssFwtsF3usF4uZgKAAA3MAu2wXy5mAoAADswCCMwRDcwCZMDjLaIQLdIZ/aAG06IA -nQD9YOgVr52VAC20BR3XsYzO/AAIHeCZBQAJyQgJAmEJAmEvsFwosF3psF4v/gKAAAj/AuiwXy/+ -AoAACf8CCP8RCP8CL8YlLrBYL7BZ6LBaL3YCgAAP7gLvsFsvdgKAAAjuAuiiDy92AoAAD+4CLsYn -LbBELrBFGdfi77BGLu4CgAAO3QIusEfkxigu7gKAAA/dAuTGJi7uAoAADt0CLcYk6bYLJfCBAADu -hgAleOEAAC+2CPlhJhWgDSUA/0HmFaAMBQBb+5v0QkYVoAIFANEPAAAAAAAA9EJGFaACBQDRDwAA -KLAxf4ftLLBML7BNKiIQ7rBOLmYCgAAPzALtsE8uZgKAAA7MAumiFC5mAoAADcwCLaIVfJECLKYU -LLBQLrBRDwIA77BSLmYCgAAOzALusFMuZgKAAA/MAgjMEQ7MAnzRAiymFftgaB2gDAUA/ABCHeAL -BQBb/cf0QkYVoAIFANEPAAAA+2BoHaAMBQD8AEId4AsFAFv+b/RCRhWgAgUA0Q8AAAD7YGgdoAwF -APwAQh3gCwUAW/zU9EJGFaACBQDRDy8iEY/3j/4s8BAp8BEd15To8BIuZgKAAAnMAu/wEy5mAoAA -CMwCCMwRD8wCfNATDHtY/XAAFbWsAQD7RgANcAAeAADGqh/XZR3Xhi/yKC3Shqr/Cf8Rr90t3f4s -0n7AogrMAizWfhzXgPxACBXgOwUAWXRIY/zIAAAAAOsxCylQBIAAWLg/9EJGFaACBQDRDwAAAGwQ -BC4gBSgKdP8ACtuiAJ0AKyIYHtdx82AMA1A09QCNLIk2KjAgH9dt/GFEFaCItQD9IAp9ZaoBAP9m -AA3/+cUA6yYYJmNtAAD5gAQGd/sBAPngBhwiAJ0ArNiYLPVAB74QKTUA+UAHfGArZQD7QAc8YCxF -AP1ABvwgPSUA/UAGvGIAnQD1QAZ8IgCdACswMCwwMR/XTu0wMi3eAoAADLsC7DAzLd4CgAANuwII -uxH9ZgANv+mlAPvioB3oq7kA/VAAFTWbAQD7JgAMsAAWAAAb1x4a1z8rsigqooapuQmZEampK5yA -6yYSJMrBAAAqPCAKQIYJAmUKIIYJAmMKAIYJAmEsIhgOzAL8QwYVoAIFANEPAAAAAAD+AGId44vh -APn/+a4iAJ0AKzAkLzAl6DAmLd4CgAAPuwLvMCct3gKAAAi7Agi7Ee+7AgZIEQAA+y0ADn/8GgAA -KSIRiZf5IcgV7/42AAAAAP2uPAWgClUA/EAIFeA7BQBZc+EqIAUrCnh7oRL6QigVoAsFAPwAAh2g -DSUAWLWhwCDRDykiEsmYiZf5IcgV4AtlACo8IG25BQpghgkCZ8Ag0Q8pIhGJlysxC4mev7sLS0vl -v91kyMEAAGP/wmwQBBvXAyoxDNMPK7J/HNcB+GIQFeAUZQD7Q/YN4AUFAHyhF+okAArYBIAA7DQA -CmgEgABYtcjAINEPAGiRQWiSIWiUCcBA//9kDaAFBQB8odF7q87aMFi19tWg//8QDaAEBQD9QOYN -oBRlAHujAmAAAcBA2jBYtgL//pwNoAUFANowWLYT5aQABQERgAD9rcQFoApVAPxgKBXgOwUAWXOj -//38DaAEBQAAAAD//dANoATFAGwQBCkwE/EmcA3g9YUAaJEDwCDRD4QnDwIAhE4c1tP8YjAV4ogF -AAhICC2E3/5iUBWgClUA/xwGHaA7BQBZc478YjAVpHpFAOpKCAHYYQAAWW/CpTv8YlAVpVpFAKpK -WW+/6iQAClgEgABYtlbAINEPhCcPAgAPAgAkQg4c1rwtMBEtRAL+YlAVoApVAP6AZh2gOwUAWXN4 -/GIwFaHKhQDqSggB2GEAAFlvrKU7/GJQFaKqhQCqSllvqcAg0Q8AAGwQBIg3FtaqiI70wBAV4okF -APkAAEHwB3UA9npGHeAENQD0emYdoAcFACc01PZ6ph3g8vUA4lEPcsgFAAAnNNYlNNcpZADRD/zA -MBWgCxUAKzTX/HrGHaAKJQDqZAAmYAUAACxkAdEPbBAEjzj9rSIFoApVAPxiEBXgOwUA/+BoHaH/ -8QBZc0wpMBD1IASokgCdAGiSA8Ag0Q8S1oeDNiIifwkzEaMiiiqLLYqoj7ctohj94QgVoI7FAA7d -Ai2mGIj6jvvz5AAV78kFAOkzAQZowQAA4+4IBEDBAADo9goncQEAAH3jeP+gBDQiAJ0AnfgY1hjo -AAUOSASAAAkCYQkCYQkCYfOABhWgCQUA+YJEHeANJQDpxREs4ASAAFi1scAg0Q/aMFi2v/9WkA3g -DXUAi6eLviyyjgyeVn7QGfwAYh3o7LkAftAO+2BAJeAMBQBYtonAINEPWLXqwCDRDwAM6AwIOAwo -jHD54QYVr/4SACk8QPnhBhXv/eYAbBAEiC4jLDhzgQOJIsiUwCDRDwAAiy6Is+xEAAroBIAA67zg -KVAEgAALgACMLnPB3Y0iZN/eY//VAAAAbBAEKiIUKSIT/avQBec1AQDqmQwBlB0AAGSQkCwgBwwM -QQzKEa2qK6Ke92AFEVIAnQAqop3rpAAFBQGAABXV1xTV7R/WMAUAhwoCYQoCYS4hBxjV1/UmAAo6 -7gEA6tXXH3cCgAAI7gKesP5ACBWgGAUAmLOaspS1/8YAD/AEJQDvtgQvdgKAAATuAp6x5QIVBdBh -AAAKAIoMyBGtiCSGnS8iFKn/7yYUIZR1AACKJ/oAIh3gDAUA+0QAFaANFQBYUwLSoNEPwCDRDwAA -AAAAAP/9hA2gCgUAAIsiyLVoMhTAINEPK8wY6iQACWAEgABYWJ5pMuqMJ47Kisn9hAAV788FAO/d -AQdwQQAA7sYKJVPBAADqxgkm6QEAAH2rKYjLqoqayRzVqZygiyD5q+4F4AwVAOmmAi3eAoAADLsC -+0AmFeACBQDRDxzVoJygiyD5q9wF4AwVAOmmAi3eAoAADLsC+0AmFeACBQDRD2wQBBzV5y0yBv5h -ZBWgClUA/mPwFeA7BQBZcp4sMQskIhGILBrV4IVHrIiYLIlMwLD0ocgV4A0FAOqeAgSQRoAAnkz8 -g2YV4AAqAAAAACtCG+taCAHYgQAAWW7HLkIbLTELrt0tRhsqUAQrUAXpUAYtVgKAAAuqAuhQBy0u -AoAACVUC7NXJGq4CgAAIVQL0oGAV7/jFAPigBAKwOwUA/qBoHaAKVQBZcnspIhMoMQsrQhupiOgm -EyL4wQAAf7EJwCDRDwAAAAAAABzVuIpMDKoB6kYMKVAEgABYtmr6QGgdoAsFAPwAAh2gDSUAW/9p -wCDRDwBsEAiIIicgBykiFJkT8RL8DeF3AQAa1alkkQEW1UwqoIAMeBHmiAgFUN0AAPkTyBXkqh0A -qkrr1UsVUAkAAPsgCfOgDKUAKIKd6BYEJAnZgACNuPegCjiSAJ0ALmKu8c9wDeAJBQAqYq3koO5m -+/0AAO+2CCUHiYAAKyAUpLsLC0crJBT1YAleUgCdAIs5iRT4YgAVp8UBAPmACpFWux0A/IHgANAF -BQCwSm2pBQgAhgkCYYkTGtWCiZDoEgQiY/0AAOqZAgzuAoAADc0C/QAmFeAKBQBtuQfphgYkQQEA -AIgU6zIBLk8CgACpiJgV6TICLYwyAACaEPNgDThSAJ0AixDrSwgL5wKAAObMCAXb/QAA68adKpAE -gADRDwAFDEdowhiKJ/qAaB3gDAUA6qwgKmgEgABYUkzSoNEPwCDRD+okAAnYBIAA7EQACugEgABY -V5fSoNEPAADAoAzeNO62CC14vgAAjyJl/9TaIPxAaB2gG8UAWFfkY//EAAAAAAD/+xQNoAgFAIgi -ZY+yK3wY6iQACWAEgABYV9tj/6HAoFlyXhvU8I24+b/1eJAMpQBj/7ItIQn+QrAVr/8FAA+/AQ+4 -DCgkFO+kAy9xAoAA6aQALu4CgAD/pgAOsAwVAAzdAp2h/NWmFa/6kgAAAI4nnhGF6fnBSBWvyQUA -7OILJ2iBAAAJ2QGZEunJCApXAoAA6ogMAqhBAACV6ejmCiTJAQAA+KAIYuIAnQBoq0GlrCzM8P0g -BNuiAJ0A7xIEIgyFAACwTm3pBQUAhg8CYYzRDwIADwIArKzo0gImY8EAAPmABuRiAJ0A7NYBLigE -gABljj9gAKAAAOsSBSzgBIAA7BYGKVAEgABb4wOJFogVizHqFgAtbwKAAK2I8X/zCFIAnQDaIOyU -AAxYBIAAW+LSjhDurggKkASAAO5OCAv/AoAA5v8IB3P9AAAu9p3RDwAAAAWZDPwgiBWk+R0AbfkF -BSCGDAJjjBIPRQyPFCzMQOn/CAKMPQAAsFhtiQUMQIYPAmWFEozSCagMqFUlXDDl1gEubQYAAIkS -wKDq1gIkyQEAAPmgJhXgBQUA+aAGFe/2EgCOEQxVDPXBJhXv+74AhRIlXED1oCYV7/yeAAAAAGwQ -BB3UpRrU2w8CAC3SHSyixyqhcKPd6joMDu5CgAD9gABGcAsFACvEBCvEBVjxPfpAaB2gCwUAW/Bq -0Q8AAABsEBYrIAcjFhrlFhcqSASAAPghJhXgChUAmh8V1McmEhr8IugV4bsBACsWFodl+MCIFaP+ -9QD6uAQVp90BAPbB5BWgd/kA+AoAAbDIWQD8I2YVrEgdAPqPAA0wtnkA+iJmFe+qAQDqFhQkVEqA -AAYLSfohxhXgACYAAAAAnh4uEhotFhUv4T0o4B0oFAAvFhIu4h8uFhD1oDshEgCdAIki+yBCYJIA -nQDw5WAN4AwFAOwWESOASYAA2kBY2sX0AAId4AYFAC4SG9pw/ABiHeAMJQDu3DkJ2ASAAFjas/dA -AEMwD/UAdvBV9CEGFaSGHQDjFgckQAUAAPgjBhWgAT4AAAApEhJkl3cqEhqKpX2mn/wiCBWgCxUA -6xYRKlAEgADrEhIo6ASAAFja2manqfwAYh2gBQUACsU6ZFeTw2CUGPIg5hXk1h0ALRYYLxIWHtQh -E9Qa6RIYL6AEgAD14AhyEA2lAAz2EaNmKGKe+QBDA+IAnQAmYp3bYOa0AAW+QYAAj+ibFffgPniS -AJ0AKDKu0w/qEgkkPJGAACsyreS3iWfL/QAA6eYIJbxhgAApIBTTDw8CAKqZCQlHKSQU9SA9ZlIA -nQArEhsuEhTxYMAN4A01AP+gQAiiAJ0AZFDFjxcPAgDI8WRQY+tkAAlQBIAA/ABiHaAdhQBY2tDu -Eg4teASAAOYSCCKvWYAAKBIT+6faBeAMBQCc8pzznPSc9etrAg9UAoAA6/YALECCgAAKiALs1EIa -zsKAAPkGAAxwClUA+eAmFaAbxQBZcPEtEhX5oDqpUgCdAMAg7hIYKn8CgACj/y72ndEPAAAAAAAA -j+j34DtgkgCdAOkSGCo3AoAAo2YoYp75ADu74gCdACtinea0AAW7oYAAsPiY6PrAaB3v+2YAKhIR -ZKB66xIFKVAEgAD8AGIdoB2FAFjaoCsQABbUHh/UH44YJmL6GdQe/8YAD3H7HQDmtgsP+wKAAOn/ -AgX8pIAALBIQ7RISI1v/AAAosj8rsX2eoJ+hnaKco5uk+UCmFaAAdgAAACwSEC0SEithBYhjnqCf -oZuimKOdpJylJqwYLRITjB4C3RDtFgouZAKAAOwWCyum/gAAGtOh+CEIFaAPBQD+IMYV4A8lAJ8d -CogCKBYM62QACVAEgAD8AGIdoB2FAFjadI0cLxIaiRYrEhqP9fE1YA3j/vUAHNPyi7T/QEYVoI+Z -AP1ABhXgb4kA/UAmFaDfoQDw0AATMM+RAO7T6h7pQoAA7qYDLEECgAD9BgAMebsBAOumBC5gwoAA -DGYCCGYClqWMHemcASUwYQAA6RYGJmP9AADsFg0ue7YAAOtkAAlQBIAA/ABiHaAdhQBY2lEW09WJ -Go8b+iGIFeANBQCdEZ0SnROdFJ2k/UCmFe/+9QCeop6jm6AuEhrp/wIKxsKAAOj/AgDgMQAA5v8C -ANghAADtHBAlMGEAAO+mASDQEQAAWNkqwMHqyjkNKASAANmg6hYeIqHZgAAkFh/+ACIdoA0FAAnt -OOUWICbrUYAAE9O3iBuMGhrTtisSG4QYFdOv8XgAFLAOFQDr6zkKJ4KAAPSGAAp2DwUAC685/SYA -DLANNQD5JgAMMAwlAAvcOSwWHQn5AikWGfnmAA+wBQUA/iOGFeADIgAPVlD+GAAF8M/JAPwhiBXg -j7EA/UAGFeDveQDs7hEMRAKAAOvMEA3agoAA7LsCCzPCgAD4xgALMM+BAP2IABYxj2kA7O4CDEUC -gAAI7gIc04mcoSgQAAbuAvvGAA9wb7kA9MgAEzu/AQD3xgAPMAYlAObuAg3dAoAA7qYELEICgAAL -iAKYpRvTgZuiGNOB+UBmFa/5pgAAAAAAAAAAmaGUoJ6inqOepJ6lnaadp52onakvEh3lXAElMKEA -AP6gEZxiAJ0A62QACVAEgAD8AIIdoC2FAFjZ5eRQUWrOwoAA9KAKYJIAnQArEhzH7/smAAzwDQUA -45kCC/0uAACNEywSGo4SjxGLzCzCEJmhm6n1QAYVoAgFAJiimKafo56knaecpYwU/UEGFa/+JgAt -EhssEhkb01gMmQLrmQIGhBmAAPDiQA3v/vUAmaGUoJ6inqOepP9AphWgDQUAnaadp52o/UEmFe/9 -NgAvEhoiFiEr8hYm8Tgi8Tos8hXo8TkrNAKAAAYiAibxOy3yG+7yGixEAoAACGYCKPIXL/IZn6Ke -o52knKabp5iolqWZoZSgkqnyJCgVr/v2AAAAAAAAAADw4kAN7/v1AJmhlKCbopujm6T7QKYV4AgF -AJimmKeYqPlBJhWv+zoALBIajRIvwTsmwTkowTguwTrrwhgrNAKAAOb/AgxEAoAACO4CJsIUiMws -whCbpJinlqiZoZ2ilKCco5+lnqmMFP1AxhWv+hoAKxIb7BIZJYNRgAAb0xbH7/0mAAywDQUA65kC -A4DxgACZoZSgnqKeo56knqWdpp2nnaj9QSYV7/kyAC4SGiIWIS3iEiziEyviGIjthu4v4hSC7y7i -EZ6inaOcpJulmKaWp5+pmaGUoJKo8iQoFa/4VgArEhzH3/smAAzwDAUA45kCA4DxgACZoZSgnaKd -o52knaWcppynnKj9QSYVr/eaAJmhlKCOE/4gKBXgCAUAmKKYo5ikmKaYp5ion6X/QSYVr/cKACoS -GhnS6IqlE9J8JRIg5BIfJUwwgADj0ngThVmAABzS4osYDLsC+z9GFe/nwgCFH8DS960ACv/oRgDA -pf2luAWgG8UA7k4RCmgEgABZb39j+IcAAPoiiBWgDgUAnhGeEp4TnhRY2C3IqfoiiBWgCwUAWNgi -wKBZRRskFh/lFiAlYaGAAB/SvC/wFCQWH+UWIC/hHgAA+6WMBaFLFQBZY48s6v8MrAH7pYQFoUsV -AFlmoyQWH/QkBhXv7/IALRIQZdiBY/gmH9KYjhgP7gL/P0YVr+UmAMCgWUUDyKkY0qbTDyiAFGSA -XCoSFFjYDOkSHi1dbgAA+iKIFaALFQBY1//4I8gV7+5qAAAAAAD/38QNoDYFAOsSEipQBIAA7BIQ -KOgEgABY2Mlj+D8AACsSGowZ7RIXKVAEgABYVMjSoNEPAAAAAPulNgWhSxUAWWNjLBoADKwC+6Us -BaFLFQBZZndj/4MAwLAN+DTo5ggtw+YAANog/EBoHaAbxQBYUM1j/6orEhbaIOu8GClgBIAAWFDI -Y/+XwKBZb4we0h2P6Pn/wTiQDaUAY//HjB8tIQn+QrAVr/8FAA+fAQ+YDOgkFC9xAoAA/2BmHeAI -BQDotAAu7gKAAA7dAgzdAp2x/HWmFa/ghgCKJ40ZwMDqrCAu2ASAAFhPSNKg6xIYKmcCgACjzCvG -ndEPAAAAAAAA/96MDaAGBQD/4AgNoAVFAMCgWW9qHtH7j+j5/8RQkA2lAP/imA2gBgUAAAAAAAAA -/+IwDaALBQAN+DT5wQYVr+I2AAAAAAAAbBAGKCAFLSAHwZQPAgD5AA61Yd0BACkiAmWRky4wARbR -4f/BQAbQDKUALyBOZfJX7tHjHsgEgAD1oAnSEgCdAAzaEaaqKKKenRD3ABGU0gCdACqineekAAUN -AYAAi+iZEfdgDTCSAJ0ALWKuZNFYKmKt5KFUZfv9AADv5gglCrmAACsgFKS7CwtHKyQU9WAMvdAN -BQAY0cUf0eSOIP3lxhXgC0UA6O4CD1YCgAALqgIb0iwu9jTq9i0r6ASAAOsPHg3QBIAADQJnC0CG -DQJlCyCGDQJjCwCG7QwAA9kBAAAK4IYd0iALAm8KwIYLAm0KoIYLAmsKgIYLAmkqIQkvIAcuMAEo -MQErIST+IAAHMP8RAOr/EA90AoAAD+4CDrsCH9ISLiEiDbsCK3YgD+4CjSAqdiP45IYVoJqFAKp6 -GNILLnYi/aAAFrAOJQAO3QItdiGLMyt2JQgAiQoAigyaEaaq/VOmFaeFAQD5AAeZUgCdAMAg0Q+L -6J0R92AI0JIAnQAMmhGmqi+invfgCYTSAJ0AKqKdZKEnsL+f6OekAA117gAA/CAGFeABRgAAAAAA -6iQACdgEgADsRAAK6ASAAFhUEdKg0Q8AwKAMuDTo5ggtdY4AANog/EBoHaAbxQBYVGBj/8oAAADq -JAAK2ASAAFhVntKg0Q8AAIsQ2iDrvBgpYASAAFhUVmP/pMCgWW7ZHtFri+iJEfl/8nCQDKUAY/+y -AAAAAAAA+EKwFa/+BQAOvgEOvwwvJBQvIQntpAAsQQKAAO6kAy/+AoAA+eYAD7AOFQAO/wKfof7V -phWv+OIAiifrRAAKaASAAPtEABWgDAUAWE6T0qDRDwAAAAAAAP/3RA2gCgUAwLgLmwL6QEYV7/x+ -AAAAAPwgBhXgCgUAWW60HtFGi+iNEIkR+X/2kJAMpQD/+5ANoAoFAAAAwKAMvzT/wQYV7/tWAABs -EAgpIAUmIAfnNAAJwASAAPoCgh2gAzUA+yAOvSFmAQAFCUfl0S0UlFEAAIwi5GQABgORgADAINEP -AAAtIh1l0cmJJwxNEZ0TiJr/IWgV784FAOuSCCTggQAADs4BnhKr2q7/rYjolgon+QEAAPvgDVOi -AJ0AyXLJQAu5Am1JBQcAhgkCYY0TisCtqv9AEeRiAJ0AmsD5YGgdr/5KAAAAAAAAAOxqEQMkoQAA -BaoILqKe98AKcdIAnQAqop3Prtog7CQAA1hhAABYU/LAINEPF9EIiXiYFPcgD/CSAJ0ADEoRpaor -op73YBA50gCdACqineSh/mTb/QAAm3hkr78Z0QuZoI4g/aLOBeAPFQDvpgIvdgKAAAPuAp6hjoMt -0n8b0PL9or4FqO4dAK7d7aYDJUhBAAD8AAoVoAgFALGI6YMeDA/oAACbpvmirgWgGQUAmaeYqI8g -CP8RA/8Cn6nv0OUadwKAAKXuI+adiyIsIAb4QOgV4A0VAA27AusmAiZgBQAA7CQGJMiBAACIkYyS -/aKOBe/LBQDrmwEEQ0EAAOiWASZgwQAA7JYCJdkBAAB7iyCMk6jImJGfgI4g7YYCL3YCgAAD7gL/ -ACYVoAIFANEPAAAf0MifgI4gHdE07YYCL3YCgAAD7gL/ACYVoAIFANEPAOokAArYBIAAWFTo0qDR -DwD/+tQNoAoFAPqwyBXgGpUA+iAmFaACBgDr+gwDgbmAAApOFO3sCCvABIAA7U02DcgEgADTD23Z -BQgAhgkCYYkSqnjuTwwEyQEAAG35BQgghgkCY44TjRIK7gyu3S3cQP2ABhXv+L4AAChShC+ACCmA -B/ggBhXgqiUAevEuGNC3iIDAoAuAAIoQiREKmQzpFgEk7WmAACtSgn+3CSxSgn/PxmP9mQBZaBxj -/+8vgQsv/PgPD0Pv/Pwk8/0AAA/pOPggBhXv/uYAAIgSKIxA+YAGFa/3BgDAoFlt84l4iBT5P+/I -kgCdAP/4OA2gCgUAwKDAugubNPrhBhXv9/4AAAAAbBAIiCeJIvxA8BWvxgUA6oILKl8CgADrOwgE -QIEAAAaIAflAAEQwDzUA6IxALegEgAD5YCCSocwBAC7QB+3QZR6oBIAADMsR6uwDJzv5AADtuwgE -gEGAAMAg0Q8osp6aEe7QYhdIGQAA+QAfG+IAnQApsp0sFgDmlAAEnvmAACniCPcgHzCSAJ0ALNKu -ZMOVKtKt5KORZMP9AADo5gglHLGAACwgFCtQB6y7CwtHKyQU9WAendAOFQAZ0H4e0LyLEIogiDTs -0Ecd3wKAAO27CA1WAoAA8QAE+l/NBQAtIAcjUQH/RgAMcN0RAO0hJC7SgoAACaoCmGGaYBrQMvzA -RhWgGIUA+MBmFaAIJQDqAAUDUEEAAG2KAgoCYSwhCfpA8BWgCAUA+MCmFaA/pQDjZgkuZQKAAP+G -AA5xqgEA7GYGLVQCgAAK2gIOqgKaZCghCfpAaB2gDAUA/qAkFaAJNQDptp0sXQKAAP9mAA3wDQUA -WFQ5wCDRD48nsX4OrgKJ++kWAif4gQAADf0BnRWtme1cICTJAQAAedMEiBII3QyJ0Pj4AATwiBUA -eJkanmHp0IATw/0AAPjABhXhiB0A+MBGFaAATgAAnmEZ0HqZYIjRCFgUmGIY0HiJNh3QePkQCBWi -mR0ADZkBjfGpiJhjiPPvEgUicAkAAAzuEa7dr4/oFgMn+QEAAH/TAgjdDKdIsogMiBHuiAwL9wKA -AO3pCAQCIYAAKGwQmBT54A8S4gCdAA3/DPkAaB3krx0AbakFDQCGCQJhiRUKfQym+OqMECTJAQAA -bdkFCSCGCgJjiiDTDwiqERjQUq5p/6CuBaAPFQD/IMYV4A1FAA2qApiUGNBOmpWKUyiCfhbQTf+g -iAXoqh0Aqojolgck6IEAAP4AChXgCgUAsartgx4ND+gAAP0hRhWgKgUAmpuPNIhTijUG/wH3oIAF -p4gBAO6qAQxCQoAACP8CBv8Cn5woUAktUAsvUAomUAju0Dke6QKAAOb/EAxDAoAA+wYADDCmMQDt -/wINUcKAAAr/Agj/Aoo2GNAwn53+YUgV5dYdAO6qAQ7oQoAADaoC+yHGFaRmAQDo/wELMgKAAAb/ -AohVmJ+GViaWEI5XLpYRL5YSjVQtlhMqUAH/n7AF4BiFAO5RASgECoAA8UAED9IAnQAqIAcKKkDt -ISQtUoKAAA+qAiqWFI8gKJYX/eAAF7AINQAI/wIYz40slhbvlhUk0YEAAPgACB2gDyUAbfoCCgJh -LyEJLCAH++AAF7AYpQAI/wIvlhr/n/YF4cwBAADMEQzcAg/MAv4gKBXgCgUAKpYZLpYd7JYYJ/gN -AACfEY4RLradLVAHiif1oABGsAwFAOvUAAVQgQAAWEy70qDRDwAAAAAAAADphAAD8omAANMPbXkF -DUCGCQJlY/43wKDAigiYNOjmCC1jlgAA2iD8QGgdoBvFAFhSVMAg0Q8AAPtvAA6/77oAwJD8IAYV -r/CGACvMGOokAAlgBIAAWFJKwCDRD8CgWWzNHs9eiegdz1f5P+BokA81AGP/sAAAAAD4QrAVr/kF -AAm5AQm8DCwkFCwhCQSIEPlAZh3gCQUA6aQALmYCgAAIzAIOzAKcof+1phWv7/oAAGwQBikgBSYg -B9gw9gBiHeAaRQD7IA4NIWYBAAUJR/0iwAFfxQUAiiITzzvkZAAFA4mAAMAg0Q8AiCeOio2L64II -JGCBAAAFyQHpFgEqfwKAAKv6qd2v7u6GCibpAQAAnRD7oA3bogCdAO0SACGA2YAA6bQAAgCZgABt -SQUDAIYJAmEqwgAPqgj9QA8MYgCdAJrA+WBoHa/+QgAAAAAAAADsahEDJKEAAAOqCC6invfACbHS -AJ0AKqKdz67aIOwkAANYYQAAWFICwCDRDxvPGIm4mBL3IAjIkgCdAAxKEaOqLKKe94AJKdIAnQAq -op3koRxk4/0AAJy4ZK+/Gc8bmaCPIP+e7gWgCxUA66YCL/4CgAAH/wKfoY+DLuJ/HM8C/Z7eBej/ -HQCv7u6mAyVIQQAA/AAKFeAIBQCxiOmDHgwP6AAAnKYYz2f5QQYVoBkFAJmnjyAI/xEH/wKfqQxO -EaPuJ+adjSIsIAaJJwvdAu0mAiZgBQAA7CQGJMiBAACIkY2SH87r5ZwBBENBAADolgEm6MEAAO2W -AiZhAQAAfIsajZOo2JiRn4COIMAg4oYCL3YCgAAH7gKegdEPH87dn4COIMAg4oYCL3YCgAAH7gKe -gdEPAAAAAADqJAAK2ASAAFhS/tKg0Q8A//s0DaAKBQDAoFlsPBvOzYm4iBL5P/bYkgCdAP/7wA2g -CgUAwKDAygycNP1hBhWv+4YAAAAAAADr2gwBgbmAAApOFO3sCCnABIAA7U02DcgEgADTD23ZBQgA -hgkCYYkRqjjuTQwEyQEAAG3ZBQgghgkCY40RCv4Mrt0t3ED9gAYV7/imAI8RL/xA/4AGFe/4cgAA -AGwQBBXOpxbOxfCIABOwCUUA5M8QGcYCgAAJiAIoZi0FNQLnZi4qGASAAOVmNCkwBIAAA2CGBgJn -A0CGBgJlAyCGBgJjAwCG5gwAARkBAAD1yGgdoIoFAKoiAwJvBMCGAwJtBKCGAwJrBICGAwJp0Q8A -AAAAbBAGIyAHFM6HAwNBDDkRpJkokp79CCBB0AU1ACuSncu2H88AGM8A+kAIFaAJBQD4IAYV4AwF -APggRhXgDVUA+CAmFaAe5QBYTyYMOhGkqvVTphXgAgUA0Q/aIOs8GClgBIAAWFFfxyTRDwAAbBAG -KCBwwGTlzmwUdbSAACQgBwQEQQxJEaWZKpKe4yIALSFsAAAqkp1koFDbMFjqVcDB/AACHeAOFQD5 -nR4FoAkFAPggJhXgDwUA6RYCLVgEgADoFgAp0ASAAFhPBgxMEaXMJsadKiBwKwr7C6oB+k4GHaAC -BQDRD8Ag0Q/aIOtMGClgBIAAWFE7xyTRDwAAbBAEJCAHE87JFc5HBARB4zJ/Kk8CgAAFmQgokp4P -AgDkMwgMETgAACqSnWSgQwM7AvwAAh2gDSUA/gBCHaAfBQBZbV/9nXYFoA4VAOymACnuAoAADt0C -naGLIJuiDEkR9SAARPAIJQD5M6YVoAIFANEP2iDrTBgpYASAAFhRGcck0Q8AbBAWLjAQ95xOBeAf -RQDzwfAN4AYFAPXAQPCSAJ0AaOIDwCDRDyogBwUJR9MP+COGFeGqAQDqFh4slGgAACsgBfdgWDxS -AJ0ALCBy84BX55IAnQDaIFhRMmWnxI0iZde/LhIeiDUqIhD4IUYVoBmFAO4WECR4XQAA+x4ADLT/ -HQDvFgsn+A0AAJ8dnxz1wFDiEgCdACwSEAzMEafMK8Ket039YFrb4gCdACvCnftgWKASAJ0AjCmN -KgwOPi4WGgzdDH7beSogIikgIwqZDPsgWoASAJ0AKCAHGs52/VgAFeGIAQANiAkojQIugQYJ7zYP -7gwuhQYtICKv3Q0NRy0kIvugWbgSAJ0AKKJ/7iILJsv9AAD7AAQA0AgVAOCZGgxACoAA6e4IBEP9 -AAAI7gKeKigSGgzpDPkgWFuiAJ0AiR0ezl0sIAcoIQcdzjP+QSQV4MwRAPWQABY6iAEA7cwCDEMC -gAAI/wItISScsIogiBoczdLu3QINVgKAAAqZApmxKiEinbSfswyqApqyHM5LKSIQmbUZzkr8RxAV -4A8lAJ+5lrf5YQYVoA4VAP9hRhWgCnUA/AMABvBOdQAN6jkNyTkKmQKKG+a2CyHAQQAA6bYGJcjB -AABtqQUIAIYJAmEezbWevI0w86BEQpIAnQAqEhDpEgwtVwKAAKeqKaadKCAULxIapIjoJBQngMGA -AC0SGowpKyA4rcycKfNgTq+SAJ0ALhIc+cBNeVIAnQDAINEPKyAHKCAFKjAR/EBIFaG7AQArFh75 -AC48UKo5APuARjiQHqUADLwRp8wtwp4rFhAqFhn/oEdLogCdACnCnSkWEekWHSgECoAA+yBG2BIA -nQD6QGgdoAtFAFlrCxvNjPtARsBSAJ0Ai7j3YEbwkgCdACxyrveARE1SAJ0AKnKtHs2D7wIABev9 -AAD7QEdYEgCdAO3mCCgECoAA+0BDaBIAnQAtMBQtJDgrMBUmJDsrJDmJO4s8iDqPOY42jDgsJQkv -JSMuJSIoJSQpJSUrJEyJPSkkTSgyES4yECYkTiYkTyYmGyYmHSYkcCYkcvZOJh2gDxUALyUpLyYX -LyYYLyYZLyRzLiUoKCYVLiEaLDARx7z7wAQF88wBAPxHRh2gCCUA+aAEBjAPRQDo0Bx127EAAP8A -AAQwCRUA+S0ADDmeHQCpiA6IEQi7DBjN0f+gBAbwDhUADOw5C4ksDe05C4guCOg5Hs2m6YgIC0gE -gAAN6TkdzVrfYAzfOQn/Ai0gFAi5HOklNCXz8QAACOgcKRIZpN3oJTUvdAKAAA7+Ai4mEO0kFC3E -AoAA+eYAD7AsBQDvJg8kr+GAABvNtxnNZi4gB4wpnCyIPvgiRhWg/hEA6BIRL/qCgAAJ/wIpIQj/ -AAYV4e4BAO8iAC90AoAADpkC+yYADPAONQDr+wIP/gKAAA7/Ap+B/5o+BaAvBQCfg+6GAiR4wQAA -LxYdjiuWhZ6JnIj7AMYV4A8VAPkAhhXgCwUA+iJmFeAZZQD4I2YV4BxFAOwWCS7yAoAAD+4Cnof2 -QoYdoCwFAC0gBw0NQevNjhboUQAA6hYILoEKgADtMg8vyAqAAAuZAhvNIC0WFCkWFSm2QCkSHRvN -hZsXCyCGCQJjCwCGCQJhKyA4IxYg6mQACxgEgAD6AgAG8OsBAP+NAAmwDCUA/Y0ADXDrGQDq7gIL -SASAAP1gBAWwGgUAC6k5KiA572QAC0AEgAD4ZgAJ8IsFAP1ABAYwSQUA/WIADDCqAQAKnzgrEh0c -zWn6QAgVoA0FAJ0RCP8CA/8C/CAGFaANBQDyJAgV4AwVAO/uAgXYgQAA/8AAFzAPRQD/xgAPcA8F -AP4gRhWgDgUAWE18wMHvzVgdWASAAPpACBWkCQUA+CAGFeANBQD4IEYV4AgFAPggJhWgDhUAWE1x -KBIU6RISLVgEgAD6QAgVr/71AJ4Q/ESkFe//9QD8RIQVqJkBAPs4ABS4iAEA6YgCDuwCgAD9hgAO -cB6lAPggRhWgDQUA/CAmFaAMFQBYTV3boPpACBWv/fUA/CAGFeAMBQCcESkhIighCcHs+SAAFL// -9QD5BgAMcAwVAPggRhWgDQUAWE1PKhYWKiEoWVCH7c0qHWAEgAD6QAgVr/71AJ4QLhITLdCMG8zB -7t0CBmP9AADi6RAO6EKAAO2ZAg5mQoAADJkCC5kCmREoIhUZzRz//+Id4B7lAPoiyBXmiB0A+QYA -DHANBQD4IEYVoAwVAFhNNBjMpYwXLxIV74ZALUgEgAAMYIYJAmcMQIYJAmWJMPMgGCqSAJ0AG8yi -LxIQHc0GLCEHLhIb6tKYL/8CgACn/y72nSuyH48gjiAoIA0pIAyuu+4gFS3eQoAAq6oqFhcrIAcr -pAcppAwspQcopA2MOS6kFS3SHC4yEfhiCBWgCRUAKaUpKKUoL6Ye/UEkHaAbRQD7QKYd78wBACyl -I/ohCBXm7h0A/6AARrD/9QD8IwYVoA4FAP1CxhXgDRUAWOhULBIXKxIYJsQU/YKwFaAtBQBZQP8t -Ehlk0vUuIDrA///AF6xiAJ0AKTBXKApACYgMKBYOLQoB/h/iHeAOBQDsIQktWASAAOwWDylQBIAA -WOhAJiQUix8sIBWNHllA7cC8iicczDiKrokZDACHCgJhCgJhCgJhCgJhCgJhCgJhCgJhCgJhLRIZ -K3at+ECmHeAOFQDuJBcmgVGAAC8gOsCPePEdGcy7KDBQCYgKiIzsMFch2UEAAPpAaB2gDSUAC4AA -BQpH+UAbyVIAnQDAINEPAOokAAnYBIAA7EQACugEgABYTrXSoNEPAAULRysWHPlgBuFSAJ0AiSeM -mi2cIOTCl2TwwQAAjJmL4Cn6wPmgBATwCgUA7rgMBdshAADoujkGAyGAAJkViNB8gVgrwAD/YARc -YBlVAPlgBBxgGGUA+W9mDaAZhQD5bmYN4BiVAPltZg2gGaUAebFjixUpwAco0gMoFgbriAgMzwKA -AOnMCARBAQAA6Ms7flgEgADstAAN/TYAAMmows0roAB8sS6LrsCg6+0MBdshAAANujllr+ctIE76 -wGgd4BxlAP2NAA3wADoAixb7jwAN//8OACwgBeskcS5B8AAALSByft9x2iBYTv9loHmOImXgdCgg -FKSIKCQUjzB69lcqIAcKCkEMqxGnuyyyngqpAveAGxpSAJ0AK7Kd6RYfJZsRgAAvIHHllAAJ4ASA -APpAaB2g7qUA7+Y5CmgEgAD+wGgdoA8VAFhOjwxZEfcgAETwCEUAKJadKhIc+UATiVIAnQDAINEP -AOokAAnYBIAA7EQACugEgABYTlXSoNEPAOw0AApoBIAA+0QAFeAOBQD6QGgdoA8VAFhOeisSG7S7 -+iNmFe/zbgAuEh4bzEAdzED+ACId4Ak1AOuwgC8BCoAA6dSAL/AKgAD6IIYV594BAHvYL/gjyBXv -+PUACNgDCLsBGMvNCJkKGMvQKJahiBQZzC8L6wILC0frlIAkBdmAAGSwvsHj/iEmFaANFQD8ImYV -4AsFAPoiRhXgGTUA+CNmFe/otgAAAP/1MA2gC2UAxPD+IcYV7/RWAC4gcegSDSngBIAA6iQACmgE -gAD4HUId4A8VAO6WOQxHAoAA6LsIC3AEgABYTkeJHbSZ+CGGFe/dGgAby4SLuPdgELCSAJ0ALBIQ -DMwRp8wtwp63Tv+gEOOiAJ0AKcKdZJITHst6sL2d6NuQ+z+umJIAnQBgANv/9awNoAwFAGS/SPAA -GA2gCRUAwJAby/sostLH3g2IAQiYAvl6RhWv/LYAAAAAAADqJAAJ2ASAAOxEAAroBIAAWE330qDR -DwAAH8tiwOoOvjSe+Nog/EBoHaAbxQBYTkZj/8zAINEPAP/caA2gCQUAKxIe2iDrvBgpYASAAFhO -PmP/rNog/EBoHaAbxQBYTjpj/5zAoFlovRvLT4u4+X+4wJIAnQBj/6qKJ/qAaB3gDAUA6qwgKmgE -gABYSIfSoNEPHctEwMoMvDTs1ggoBAqAAPtfuKiSAJ0AY/92KxIe2iDrvBgpYASAAFhOI2P8SACK -J/qAaB3gDAUA6qwgKmgEgABYSHXSoNEPAADaIFhNi2P2JgAAAAAA/9KgDaALBQCKJ+tEAApoBIAA -+0QAFaAMBQBYSGnSoNEPKyAF9X/fwJIAnQCMIsDSDcwC/EBGFa/vpgCcKv+AaB2v074AKyAHGMuq -/68ADPG7AQAIuAnpJCIkQAsAAC6BBq/uLoUGLSAizNiMKfxBRhWgALIAKaJ//kFoFaAPFQDgkQQG -w/0AAOCIGg/4CoAA6O4IB/v9AAAP7gKeKiu8H+okAAlgBIAAWE3tY/txAAD/8oANoAsFAAAAK6wY -7CQACVAEgABYTeZj/NTAoFloaRvK+4u4+X/vAJIAnQD/9+gNoAkFAADAkB3K9cDKDLw0/aEGFa/3 -ngBsEAQbyxEpIgAYy2krsh8ogor7IABE8AsFAOskFCzOQoAA+QAARHAZBQApJAXrhBQpUASAAFvm -19EPAABsEAQZyzCKMimSfwmqEaqZLJAGiJLA2/0gph3v++UA64gBBmP9AADslAYs0ASAAPkgRhWg -CwUAW+bIwCDRDwAAbBAIiCIvIAeHMJUS9CBmFaH/AQDzA5wN53cBAO8WASOI4YAA63wBKVAEgABZ -aFnmogFtIASAAPZgaB2vhdUA4hYAI4aJgAAHcgnnPBApFwKAAPJAAEFwAJoAAAAAaYEIihCLZVjm -5dSgZkDX53wwIzDBAADywATkIgCdAChgEMiNaIFAaYLkKGARZY/PYABuKGARyIpogR1nT9B1Qc1g -AKKKEOtiBSvgBIAAWOck9UBoHa//mgCKEItlWOcb9UBoHa//XgAoYBHIi2iBH2dPm3VBmGAAbQCK -EOtiBSvgBIAAWOcW9UBoHa//lgAAihCLZVjnDfVAaB2v/1YAAAAAihDrYgUr4ASAAFjmwfVAaB2v -/WYAihD8H6IdoAsFAFlpbdSg9UAKDG8GBQCIMAaIAfhgBhWgAEIAAAAAAPIgBhWgBAUAiREWyoAX -ynnllAAMxwKAAPUgBUIQD6UAB4gIKoKeIhIA90AQGlIAnQArgp3otAAFjHGAAIlomBT3IAygkgCd -ACpyrmShWityreSxVmTj/QAA7GYIJYrJgACKEykgFKqZCQlHKSQU9SAL1lIAnQD8YGgdp+QBAO0S -AylQBIAA+wBoHeAPFQBYTR+LEv6gABawDEUA96AARve7AQDs1p0llGUAAIonjRPAwOqsIC7YBIAA -WEeV0qDRD8Ag0Q+JaIIQ9yALYJIAnQAMWBGniCuCnvdgC6JSAJ0AK4KdZLFrsJqaaOi0AA36dgAA -YADQAAAA8iAGFa/7RQD7X/glYgCdANog/EBoHaAbxQBYSObsEgMpUASAAO0SAinYBIAAWEzM0qDR -D4wSDAxHaMIOjTAG3QH8YAYV4AIFANEPjxCP94QTjvr14QgV78wFAO3yCye4gQAA7HwBCicCgACl -QqzdpO7u9gom6QEAAPOgB1uiAJ0AyTOIE8iP2VBtiQUDAIYJAmEicgAEIgj8QAkEYgCdAIhQknAG -iAH4oAYVoAIFANEPwLAPmjTqZggt9X4AANog/EBoHaAbxQBYSLpj/06LEdog67wYKWAEgABYSLZj -/zzAoFlneoloiBT5P/MYkA+lAGP/yS0hCf5CsBWv/wUAD58BD5oM+kKGHaAGBQDvtAMvcQKAAOa0 -AC7uAoAA/6YADrAMFQAM3QKdsfz1phWv+UIAAAAAAAAA//gADaALBQDAoFlnYolo+T/0aJAPpQD/ -+nwNoAsFAADAsA+YNPjBBhWv+kYAAAAA5d8MAYG5gACKEw9CFOssCCnABIAA66o2CsgEgABtqQUI -AIYJAmGNE6844t0MBkkBAABt2QUIIIYJAmOIUA9ODK7OLuxAnnAGiAH4oAYVoAIFANEPiFAvzECf -cAaIAfigBhWgAgUA0Q9sEAQoIAXNjioiByuiDC2iCu6iCSVIwQAA6bEHdeMhAABlwAPI3cjr+kBo -HaALBQBb5bjRDx3KURvKUizSX/+wxBXv+PUA+UAGFaAOBQDuJgclQCEAAJjBm6Mp0l+ZoujWXyf+ -gYAAKdF5iiB5q8MpIRpulArZ4P5DRB2gACIAAGiTr8CxC5sCCwtP6yUaLZ6QAAAs0YIMqgxY5m7R -DwAAbBAEHMnJGsn/LMIdK6LHo8wJzBGsuymxGsDy/SGgQlANBQD9Y0Qd4AAiAABokxAusRoP7gIO -Dk/utRonHEUAAPpAaB2gCwUAW+WK0Q8soXCKsAyqDFjmV2P/5ABsEDLjIAcp2ASAAB3JiQMDQeIW -Jyn/AoAArf8o8p4rFlHyKgYV4EmlAPkAevviAJ0AK/Kd7snxHbAEgAD7YHqgEC0FAIhI6xYxJ0vB -AAD/DMAAEHj5AA4AiekWMCD4wQAADwCKKEIQ6UIRLoIKgAD4IgYV4IidAJgfLkISL0IT/iJGFeDu -nQAuFhGLTIxN/CKGFaC7nQArFhOKTotP+iLGFeCqnQAqFhWJS/gi5hXgAKoAAAAAAAAADh+H6RYw -IPjBAAAPAmEPAmGMTSwWFYtMKxYWiksqFhcqHDBY5jcSyerTDw8CACghreshti0oBIAA+UBwoaIA -nQB7ogwpIbermflAcCNiAJ0AWOZJ+0B04B/1RQDacFk73CUhtiMWLScWKqWl+qB1oFIAnQAfyWgv -8h0Yyb4uIuqvX+wSUS/+QoAA/8AAR3ANFQAt5RovQSuVwS8WQxzJzSZCGiNCGCdCGS5CFCtCFylC -FikWRisWRQjoAfgo5hWjrsEA+iiGFaPu4QAuFiwpFgLqFgAq6ASAAPogJhXgClUA+CBmFaALBQBZ -Zjj9k3gFoAsFAOgSKivwBIAA6sm3G3gEgAD6ICYVoCkFAPjgAAQwClUA6BZILIIKgAD4IAYVoNOd -AFlmKS0SLPwQAh2gCRUA/OAEBjALBQDsnDkN0ASAAAqaOQyqAvWgUYEQDyUAKRY3/gACHaAIBQD4 -JqYVoAwFAOwWNCbD9QAA/ibGFaAOpQAI7TgYyVn8ACIdoAkFAAnJOQg4AQjIOQmIAvsAUHAQPnUA -AOAEAwkbCQlDKRY4AIQEBz4Y8MBJilIAnQAGWFD4KSYVoMahACwWSvLARysSAJ0AKSIYCYlBKRZL -8MBHFRIAnQAGzEEsFkzywEejUgCdACwiGA8CAAwsQfgAIh3gDwUA/y0AD/AYBQAIeAEImDkI/wL7 -4E0YEgCdAB/I2P4nJhXgCQUAKRY6BslQCfgTCYgC+wBMsBIAnQD/ka4F4AgFACgWOy8WPAbfUA/5 -Ew+ZAvsgTEgSAJ0A+ZGSBaAJBQApFj0oFj4G6FAI/xMI/wL74EvoEgCdAPmSugXgDwUALxY/KRZA -BrlQCfgTCYgC+wBLsBIAnQAtFiz/kiYF4AgFACgWQS8WQi4WVhvJIiwWVfwAAh3gDBUA/Y0ADvAp -BQAJeQEJyTn5pgAM8B8FAPpgBAXwCAUA68s5DHAEgAAJ/jn9ZgAN8IkFAOuYOQx4BIAAG8k+CO4C -CzsB+40ADfAJhQD9ZgAN8AhlAPstAA/wDUUACo05D90CDt0CLxJJLhJKKxJLGMkm5/8RD3WCgAAP -7gIfyS/4wAQEMQA9AP+mAA6xDgUA+e0ADzuTIQDnPxgN3AKAAP+mAA6+AD0A9msADHLmuQD30AAX -Mf8BAO6+Ag/9AoAA/6YADv+tjQD+KqgV77uNAOuqAgzNAoAA6xI6LEICgADu3QIP+oKAAPkGAAx/ -740ADrsCLhI5C6oCKxJMD+4CDt0CLxJW7hI2LdjCgAAL3QL78AAl8/8BAO8WKS93goAADrsCCP8C -LhI7nxIvEj8O3QIuEj0P7gIO3QIuEkELqgIrEjcO3QKdES0SPA27EQ27AguqAi0SQCsSPg27Aguq -Ai0SSCsSNObdEA3aQoAADbsCC6oCHcjyKxJCKfr/KRYA/WYADf//9QD7RgANcA4FAPopphWgDQUA -6xIxKtAEgABYSPr2CgAEN/YBAP2RzAWgDQUA/CAGFasAPQD2awAPc5PhAOj9OQzKAoAA87IAB/Xu -AQDoEiwvdYKAAO7dAg/5AoAACf8C6RJNLVgEgAD+JwgVoCoFAPtACADQDBUA+QAAFDCZnQDpFgIv -cwKAAOjuAgrQBIAA/8YAD3//9QD/pgAOsA4lAPwgJhXgDQUAWEjX9iUoFaAMFQD+Q0gV4A0FAOoS -Qy1YBIAA+CiIFe/49QD4IAYVr/8BAO8WTi1UAoAA+yYADLAORQDvFgEq0ASAAPggRhXv//UAWEjE -///iHe/99QD+KOgVoAwFAO4WAi1YBIAA7BYBKtAEgAD8IAYV4AwVAPwAAh3gDmUAWEi3/AAiHaAN -BQD4KcgVoA6FAPgoqBXv//UA6RYBLVgEgADvFgAq0ASAAPggRhWv//UAWEiqLhI1LPr/7BYALVgE -gADo7xAPaQKAAP3GAA707h0A7+4CCtAEgAD8IEYV4AwVAPwAAh3v//UA/iAmFaAOpQBYSJosCgH7 -QGgd4A0FAP5CyBWv//UA/iAGFeAPBQDvFgIq0ASAAP5YAAc///UA7hZPL3QCgAD+ICYVoA7FAFhI -i8e/+iAGFe8JBQCZESkiF/gp6BWgDBUA/AACHeAO5QD54AAE///1APsgABS/iIEA6YgCDVgEgADo -FgIq0ASAAFhIevtAaB3gDBUA+CjIFe/69QD6IAYVpgA9APZrAAvwDQUA9yAAA/mJsQD7MAAVM/n1 -AOmqAgvLAoAA+QYADHAeBQD6IEYVr//1AOgWASrQBIAAWEhlwDD//+Id7/31APcsAAdwDAUA7hYC -LVgEgADsFgEq0ASAAPwgBhXgDBUA/AACHeAeJQBYSFjAwfwAAh3gHkUA///iHeAJBQD4ICYV7/j1 -AOkWAi1YBIAA6BYAKtAEgABYSE39kHYFoB5lAPtAaB3v/fUA/CAGFeAKBQD6IEYVr//1AOwWASrQ -BIAA/AAiHaANBQBYSEDAwfwAAh3gHoUA///iHe/59QD4IAYV4AgFAOkWAi1YBIAA6BYBKtAEgABY -SDXppAADLXmAAPTALTkSAJ0A9MAx+JIAnQD0wDG6kgCdACYSKiMWGCMWGfosABXv/vUA7rYCIOn9 -AACes560nrWetp63nrieuZ66LrYLHsdz7JwgJPghAAD7JgAVoIsFAOubCAC5QQAA6xYzJtgFAADt -x24TIgGAACgSLRbHyekWKCuYBIAA58fWGpeCgAD2RgAJMYgBACgWUuIWVCq2AoAA8gACHaAIRQD4 -xgALMAg1AOYWUyywBIAAbYpxnmApElPpZgEvyASAAOcAFQf5AQAACQCKwpiZZSkSUigSVOhmBilG -woAACJkCGMfqnWTomQIBEAUAAOu88C3ABIAA6WYHKcgEgADoCx4Bm8EAAOjEAAMxAQAA6EwABmEB -AADpBx4NQASAAOgsAAVRAQAALxIo+CYIFeDGhQD34ABDMOoFAPvgAEUw+wUA++AARfADBQDpDAUA -wYEAAPgMqB2gCSUAbZqE/+YGFaAshQDoElMrSASAAOj2MSMxAQAA5wAVAcANAAAJAIot9jTpElQs -FsKAACz2Nen2NiGYBQAA/QDAQlAJFQDAkCgSUgiZEQKZAgmIAhnHuS/8QOmIAgCRgQAA6PYnLcgE -gADiCx4NQASAAOhMAACQwQAA4gceBdkBAADpLAAFUQEAACYSKCgaQPjAAEMwQ0UAKUEqKxIn8SAN -nBACRQAZx1ofx5KeYIqwLWYC/sCmFeAMhQAsZgP4pgAM8AwlAOlmBC1WAoAADKoCKmYB5wAVA0hh -AAAJAIrjPAIjMIEAAIhA8QANgpIAnQApElEpkAEAmTItQhooQhknQhj0KigV56kBAPol5hWhAD0A -CHcY9KAoFeF3AQAnFi7xQYAN6X0BAClCFBzHYgnKU+yZAQVT+QAACpU467IAK1AEgAD8GgAGcA5F -AP4GAh3gDRUAWWX+LRIwKRIuKxIv7QAFDWAEgAAMAmEMAmEMAmEdxwoYx3LopgIs5AKAAAx8Ag3M -AuymACJ4IQAA7wYABXBBAAAOAIqVpixCFAsNBv1Dph3jzOEA7KQcIfgRAAAoElAcxsHuElEsRwKA -AKyIL4ad88AGHaACBQDRDwAAACgiFQiYUCgWSsCQKRZJ8N+5GxIAnQAGDFEsFkvy37k1EgCdACgi -GNMP0w8IDED97QANsIgJAAuIAigWTPDfuKNSAJ0A/9xUDaHGcQD4ACId4AgFAPIrJhWjzgEA/Z/g -FaACBQD9IgAMMAwFAAKcOCISWXjAisCB+ClGFa/+OgAAAAAAAPE/9HRSAJ0AH8asLEIanmCKsPzA -RhXgGAUA+MBmFaAJBQCZZpxlnGcPXwKfZP1AABUwDCUADKoC6mYBIZgJAAD2xAAVr/k6ACkSUBrG -hugSUSzPAoAAqpkjlp3zAAYdoAIFANEPAAAA+CamFeAOFQD+JsYVoAwFAOwWNy/ABIAACrg5+CaG -Fa/XbgAuIhkODlP+JwYVr9fiAMCA+CcmFaAPBQD+J0YV79mGAMDw/idmFeAJBQD4J4YV79m6AMCQ -+CemFeAIBQD4J8YVr9nuAADAgPgn5hWgDwUA/igGFe/aHgAAAAAAAAD8JYYV4A8FAP4oJhXgCQUA -+ChGFe/aLgAqFiv4JggVoAoFACoWMhrGt+gQBQCxwQAA9hCoHaAIRQDjFh8qtgKAAAhmAiYWUyYS -LeMWICrHgoAA6ogCDNAEgAD4KoYVoWYBAPYqRhWgCCUA58a2G7AEgABtipYjEiueoPgqaBXgAhUA -+UAmFeAIBQDnABUPyASAAAkAiikSMgkoOOmcASyWwoAA6RYyLEYCgAAIIgIpElIYxtSdpOKZAgmQ -BIAA6JkCAZkBAAAjFisoElTppgcn+QEAAPlAxhWgKYUA67zwLcAEgADppgUuSASAAOgfHgZhAQAA -6ewAC0AEgADoGx4FUQEAAOLMAAMzwQAAJhIz//EgDaAzhQAA/AACHeAepQD9jXQFr//1APmNcgXg -CAUA6RYBLVgEgADsFgAq0ASAAPggRhWgDBUAWEa7/j/iHaAMFQD9jV4F7//1AO8WAC1YBIAA7RYC -KtAEgAD+ICYVoA0FAP+NSgXgHsUAWEavwMH8AAId4B7lAPgAAh3uDxUA+CAmFe/49QDpFgItWASA -AOgWACrQBIAAWEaj+UBoHe/nWgAAAAAAAPwAIh2gDQUA+EMIFaAepQD7QGgd7//1APqgaB2gCQUA -+CBGFeCIwQDvFgAsQ4KAAPggJhWv//UAWEaRwMH8AAId4B7FAP//4h3gCQUA+CAmFe/49QDpFgIt -WASAAOgWACrQBIAAWEaGwMH8AAId4B7lAP//4h3gCQUA+CAmFe/49QDpFgItWASAAOgWACrQBIAA -WEZ7+UBoHe/k0gAtQRYuQRfrQgkjh+mAABzGbClCEYpOL0INKEISJRYJKBYDKxYIKhYH+CAmFeAK -VQD+IKYV4AkFAPggBhXgDwUA/iCGFeALBQD6IMYV4AgFAPggRhWgK4UAWWLI+r+NCFIAnQD8KigV -oAJFAPok6BXvmeUA+/PCHaADBQD7gCYdr+umAP/CkA2gCwUALBIn6sQAAdhhAABYSJPHJNEPAAAA -AAAA8gCCHaAKVQD9jIwFoBuFAFlisS0SUSsSJ/n+gh3gAwUA9aAmHe/qggAAAAAAAAAA8gCCHaAK -VQD9jHYFoBuFAFlipS8SUfok6BXv+UUA8gACHe/+RQD/4CYdr+muAAAAAAAAABzGMYhMj02VEvog -JhXgClUA+CAGFaArhQBZYpb6v4bIUgCdAGP/NABsEAonIAccxXwHB0EMehGsqiiinsGV+QAW0+AO -NQArop3qtAAFlrmAACswAxbGAe3F8R2W1gAAJUIUBYhTmBf8oAQC84XhAPUADHGSAJ0AwFAuQSob -xWoZxWzxwAi0EA8lAI4xm6CIIAiIEQ+IApihGMW4maKWpQjpAh7F0flAhhXgCIUA6KYDJUhhAADu -ABUFUIEAAAkAirJViUDxIAjikgCdACkwAQCZMihCGSZCGC5CGgkLR/ohRhXhAD0A+MsACzn+AQD+ -IQYV4WYBAJYZ5jIBJYCpgAApQhQJy1PtmQEF2/kAAAuWOIsg/hoABjANFQD+BgId4A5FAFlkZYkY -ixmMGh3FOR7FdRjF3O0ABQ1oBIAADQJhDQJhDQJh6KYCLewCgAANnQIO3QLtpgAiECEAAOIGAAV4 -QQAADwCKlqYtQhQMDgb/Q6Ydo93hAO2kHCL4EQAAGMUoDHIRqCL+U6YV4A5FAP5gBh2gAgUA0Q8A -AADx3/kUUgCdAC5CGogxm6CGIJminqWep+7FMBs2AoAAD2YC90AmFaAWBQCWow6IAvlAhhWgDgUA -7qYGIqgJAAD7RAAVr/uOAAAMchGsIvRTphXgD0UA/mAGHeACBQDRDwAAAAAAAC5BKylCFuoyAS1Y -BIAAmhb4IKYV4AwVAP4ghhWgCAUA+CAGFaANBQD4ICYVoA8lAPggRhWgDgUAWEWo6MWjHVgEgAD6 -IMgVoAnFAPggBhXgDBUA+CAmFaAPhQD+IEYV4A0FAP+LNAXgDiUAWEWbjRf+IIgVoA8FAOzFlR1Y -BIAA/CAGFaAKBQD6ICYVoAwVAOoSBi90AoAA/6YADrAORQD8IEYV4A0FAFhFjJUS/AAiHaANBQD7 -QGgd4A5lAPogyBWgDwUA/iAmFe/49QD4IAYVoA8FAFhFgYsV+YACHeANBQD4IAYV4B4FAPtwABW5 -y7EA+iBGFeP/9QDsFgEtWASAAPogyBWgDBUAWEV0HMTEHcVC//WEDaAF9QD/9KQNoAsFANog7CQA -A9hhAABYR6vHJNEPaLMrweZ+sRbG+v5gJh3v6aUA//YcDaAFBQAAAAAAAPnzwh3vmOUA+GAmHa// -ngD+YAYdoAIFANEPAABsEBIrIAcZxKoLC0HlQggt1wKAAKmqKKKeKxYZ9wAT0tBV+QAnop3mxU8T -k3mAACxhgOnEmxYEMYAA8LFgDeAsBQDpAhUA0MEAAAoAii1CEO5CES4CCoAA/iIGFaDdnQCdHypC -EitCE/oiRhXgqp0AKhYRj0yITfgihhWg/50ALxYTjk4vQg/+IsYV4O6dAC4WFS1CCy0WFyocMFjh -Zy9hcythfP9ABnHiAJ0Ae6IMKGF9q4j5QAXzIgCdAOsiACqPZgAA2nD8AAIdoA0FAP4AYh2gLwUA -WWOcHMUjLWLEiyApQRYppQIuQRcNuwwMuwKboIhNmKKPTJ+jK0IZLEIYLqUD/UCGFaCNBQANuwKb -pYlJmab4g0gVoAwVAPlA5hWgDjUALxIZGMRiDP8RqP8u9p0sNAAtIAaLIuy7AgboBQAALSQG+kBG -FeACBQDRDwAAAAAA6QAFANDBAAAKAmEKAmGITSgWFY9MLxYWjkv+IuYVr/yaAC1BFi5BF4tJ6hYY -Io6ZgAAcxPApQhGPTShCEopOmheZEZsYnxX4IGYVoA8FAP4ghhXgCAUA+CBGFaALBQD6IMYV4AkF -AJkQ+CMIFeAKVQD4ISYV4CuFAFlhTSoSGNMPZq7jhTH9iWgFr53lAC00AfiDKBWgDkUA+oKIFaA/ -BQD2gwgVoQA9APiDSBXgDRUA/UAEBTO64QDoZhgF2/kAAPtCAArwydEA+uBoHaFmAQD6QAgV6SkB -AFljRh/EHNmg/gAIHeAONQBt6gIJAmEYxFQexLvupgIrfAKAAA8vAgj/Au+mACJoIQAA7QYABWBB -AAAMAIqVpitCFCkKYvlDph3ju+EA+0OGHeACRQAoEhkZxAoMiBGpiCKGnfJgBh2gAgUA0Q/aIOwk -AAXYYQAAWEbxxyTRDwDacPwAAh2gDQUA/gCiHaA/hQBZYyIYxKqPIClixC5BFi6lAitBFwn/DAj/ -Ap+gLUIRnaMsQhCcoilCE5mlKEISmKSPTZ+njkyepo1PnamMTpyoKEIYL0IZK6UD+UFGFaCJBQAJ -/wKfq45Jnqz8g0gV4AtVAP1BphXgCRUALBIZHcPhDMwRrcwrxp0pNAAqIAaIIumIAgVQBQAAKiQG -+EBGFaACBQDRDwAAHMR/KBIYj02JTJkQ+iAmFeAKVQD4IEYVoCuFAFlg5CoSGGatQWP+WgAAAGwQ -DNYw9OAABHAHFQD1AAdhEAUFAIkizZIpMBhkkHz1IARIkgCdAGiTBmiUGcAg0Q8mPBjbYOokAAng -BIAAW/owZKCIZq/lE8PAiTj3IAyQkgCdABvDtyqyrmSgfyqyreSge2Tj/QAA7DYIJQQBgAApIBSk -mQkJRykkFPUgC65SAJ0Aiif6gGgd4AwFAOqsICpoBIAAWEDt0qDRD9og7DQAAdhhAABb/vZj/5Tm -PBgpUASAAOw0AAtYBIAAW/4eKzAY+X/72dIAnQBj/2YsMBj5n/rKUgCdAGP/aAAAwKDA2g2dNO02 -CC18RgAA2iD8QGgdoBvFAFhGfcAg0Q8tMRYuMRePOIo5mh3/5+AAED/xABzEN5Mci26PbShiEili -EZkRnxWVEJUSlRSaGPggZhWgClUA+iDmFeAIBQD4IMYVoCuFAFlgj2AAHwAAHMQqkxyIHY9tiWz4 -IAYV4ApVAPggJhWgK4UAWWCHiSeImvMhCBXvzQUA75ILJNCBAADtrQEKXwKAAKO+rf+riOiWCif5 -AQAA/+AEo6IAnQDJbAZsAuk0AAIAuYAAbUkFDACGCQJhjqAPAgAPAgCr7v/ABiRiAJ0AnqAvEgxk -8KslNBglNBn0Y2Yd7/j1APhg5hWv+N4AwKBZYMaJOPk/8ziSAJ0AY/73JaQALCEJ/EKwFe/+BQAO -ngEupAPungwO6QKAAO4kFC5mAoAADcwCB8wCnKH3daYV7/l+AAAAAADj/gwDAbGAAA5PFOj8CCtI -BIAA6Eg2CeAEgADTD22JBQkghgwCYw5pCO9IDAbhAQAAbYkFCUCGDAJliRwOvAys3CzMQOymACz6 -xgAAwNP8YwYd7/1GAAAALtxA/0AGFa/87gAAbBAEFMNSBCIK8lQoFaBDcQDuRRAKI8KAAAVEAgQi -AQIyAtEPbBASKCAF5cPPGsgEgAAsIAeLMCVRfvaAQBXg9vUA+uAABfGsAQD9AQAEUFUJAMAg0Q+I -IukWCywaBgAALyAWHsNAmxf37gYNoA0VAPmGfAXiqAUACMgdqYnrkn4nsEEAAABhBADWGga7ASaS -fwtmAhvDJCaWfxbDNAuICA/7Cgi7Cwa7CCayfyZsASa2fymSgADxBOsWCS7YCoAA+yAXiOIAnQAM -yREOmQgpkgAJuwHqFgQll+mAABnDTSyQgO3C9RZg3QAA94XaBaTMHQAMfAnqFggmYA0AAPVAEhoS -AJ0ADK8Rpv8o8p6aGP0AJcuiAJ0AKfKdmRPqFgQkljmAAIvY92AWcJIAnQApYq5kkkssYq1kwkew -uurWCCYSeYAA68OKGpkOAAAqMCAtCu3TD/1AGYRiAJ0AwP5/oQooCu75QCNlIgCdAPwgphWgDQUA -7RYPIciBAAD4IoYV4AoFAJoemRwZw3ovEgwoICwuIRcv8gDqIg4sRAKAAAjuAgn/AQ/uAi4WE1jg -PBnDcQkAh8CBCohgjBP5QBfsIgCdAMCwLSAWLgr//6oGDaAKBQArFhcqEhRb24YvIAeME/mFmAWi -rQUADf0dLiAWqNgogn/6IugV4Bn1AA6ZDPkAHwpiAJ0AHcLXCOgQ6KgCD88CgACtmfkgZhWgCgUA -HsNYKCEHH8NUGcNV/2ABBzqIAQDu4gAsRwKAAAmIApjwjSAq9QUu9gPuEgcu7gKAAA19Au32ASHI -QQAA6QceB8BBAAAIAmPu9g8qk9YAACkKACkWEisgFAS7CAsLRyskFPVgFfZSAJ0AJRIAKRIL7Uz+ -KkcCgADoFgou9wKAAP4iBhWnmQEAKRYNH8Mz/4BoHaALBQDqEg0vyASAAOkLHgXYBQAA7kwADafQ -AAD5QAnxUAsFAO4SFCZ5AQAA/IJAAVAFBQAOYIbvbAAF2AUAAH258YseZbFELhISLxIQiR8oEhOs -/6nJ6JYQJ+EBAADsFhEvCeYAAIwxKxIR5DICLhLqAADAkCkWFfOAE8BSAJ0AqXKIGAyIEaaI4oad -KpAEgADRDwCL2JoU92AXQJIAnQCPGAz/Eab/KfKe/SAX26IAnQAo8p2YFYwV6cQABhe5gACwv/+h -BhXv9o4AAAAAAADAwMCKCLg06NYILm3OAADaIPxAaB2gG8UAWEUw6iQACdgEgADtEgsqYASAAFhE -1dKg0Q8AAIwZLM0CK8ECKcEBLMEFmhTrmQEO2ASAAP0/6BqiAJ0AixTaIOu8EilgBIAAWEUeY/+0 -K6wY7CQACVAEgABYRRpj/6PAoFlfnR3CLovY+X/pQJIAnQBj/4EALhISiyctFhmcE+XibGXQgQAA -wLLtRAAGYQEAAFg/ZI4ejBMtEhnlpAAHdfmAAIgW+YIGFaAPBQD/gkYV7/q2ABvCzSoSE8CQKRYS -66oCC7/CgAD6ImYVr/kSAC0gLB/CaQMCiesAFw7owoAALfYmC4CH+hAgAN/zIgCcFRjCvxnCv+8y -CCHowQAA/CGGFeAbBQDrFg8h0IEAACoWFJoeCf8BCP8C/iDGFe/zRgAAiy4vsADz4BDGEgCdAMDw -KrAB80ARthIAnQDAsA+7EQv7Ame842P7bR3CohvCSgOjjA0Aay8gLCuyJPvgBADQDhUA/cABB1j7 -uQD/wAQHcA31AP+gCBYiAJ0ALjAQ88AS59IAnQALC0L1YApIkgCdACm8/vgAIh2gDwUACY84/iJG -Fe/02gCPFS4hCfhCsBWv+QUACbkBCb0MLSQU5IgQD3YCgAAI7gIp9AP74AYdoA0VAA3uAp7x/NWm -Fe/0RgAA6iQACmAEgABb0BkrEhGMMeoWFS1vAoAA7bsIDUgEgADxn+yAUgCdACMSFeokAApgBIAA -W8/no66ufo8YDP8Rpv/u9p0qkASAANEPAAAAAAD/7SgNoAkFAOokAAnYBIAAWN7MwCDRDwAfwdAO -6AoZwc+v3w+IC6mIL4F/++8AD7AJBQD54CAH8AoFAP8P5B3v8FIAAAAAAAD6QAAG8AkVAP2/YBXg -CAUADZg4+CJGFa/xJgAAAAAAAPwjBhWgCgUAWV8MHcGei9iKFCwSGPl/6BiSAJ0A/+sUDaAJBQDA -8P4gphXv9CIAAMCKCLg0+aEGFa/qtgAbwdYpEhPA0C0WEguZAvgiZhXv78YAAI+7/2EoFa/IBQAI -qgGq++7sICXZAQAA+8AHCuIAnQCJGvU/4i4SAJ0AKBIQ7ogIBnkBAAD5YAfjogCdAPSf4VEQCwUA -DsCG78wABdgFAAB9ufFj/BQLAYeONi0xCw0OPw4NPwvgh/nBCB3krwEA+yAEmqIAnQD/9yQNoA8V -AAAAjhyO4vHABMDSAJ0ADs5PC0OHCyKHDg5J2OD4hIgdpJoBAPkA1g3gCxUAwLB6pwz5YGgd4ABS -AAAAAAAA+gAiHaAJBQALqTjvFhYs7B4AAIwy+kBoHaALFQD98AAGMA0FAFjeUYwTLxIW//WMDa/7 -9QDA0fwiRhXv69YAAP/PAA9//H4AAIwy2iD98AAGMAsFAFjeRYwTiy7/9JwNr//1AB7B+i0xDn7Z -av5h5BWv/YoAAAAA/28ADLALBQD4IEYV5JkdAOkWASSAuYAAiBEOYIbvbAAF2AUAAHi57wiJAo8S -7P8IBXEBAADpSQwH+QEAAPU/16kQCwUAKpz+DoCG74wABdgFAAB6ufFj+twAAAAAAAAA8V/ltlIA -nQAvFhb+IAIdr/yyAAAAAAAAbBAEJiAH9YJsBaKnBQAHZx0iIBakdCRCf8FfAlUMdU0TGsEwCCgQ -6DgCC08CgACqmZiQ0Q8cwS4bwS8CKgqsfAyqC6uqKaF/8y8ADPALBQALmTUppX/RD2wQBBvBJSYg -ByQgFvOCaAXiqgUACmodBEkKo6OrqgqZC/uCXgWgAhUA6DJ+IlhBAADnMn8tgQqAAOqZCAlQCoAA -CogBCHcCJzZ/JZJ/sVUlln8jMoAAQQQAJRp1OA4TwR4MYhGjIoIgAlIB0Q8lnQIoUQIkUQElUQUI -RAF1SwPAINEP0Q8AAABsEAYqIAeIIh/BPfeBwAWhqgEA5YDBbV8CgAAv8ICmu+6ynif43QAA/YG+ -BaT/HQDv/AMtOASAAP/ABqPgDaUAK7KdZLDTisibEPdABuiSAJ0AKGKuZICXKWKt5JCTZVv9AADr -xggkhLGAACogFKSqCgpHKiQU9UAGNlIAnQArIAT9ZOAEUPr1AAUMR2jCGIon+oBoHeAMBQDqrCAq -aASAAFg+AdKg0Q/AINEPKyAserHWiTGLEIwy7BYBLIYiAADzIAc4UAMFAAx8EabM85OmFe/+4gAA -AADqJAAJ2ASAAOxEAAroBIAAWENB0qDRDwDAkA2uNO7GCCz7lgAA2iD8QGgdoBvFAFhDkGP/ygAA -AP/8vA2gCwUAAAArrBjsJAAJUASAAFhDiGP/rMCgWV4LHMCdisj5X/jIkA2lAGP/vCghCfpCsBXv -/AUADKwBDK4M/kKGHaANBQDslAMt2QKAAO2UACxGAoAA+wYADHAPFQAPiAKYkf7VphXv/BIAAADr -EgApUASAAFvO04wRKxIAKTIB6hYCLW8CgADtuwgNGASAAPE/+QhSAJ0A2iBbzqLzQABB//xSAGwQ -BCIs7tEPbBAKlRGNQuYWACn4BIAA7xYCIjghAAD3oBA8YAMVAB7AwBXAufpABADQCwUA6xYEKbAK -gAD2IGYVr/j1APjXAAswDAUAitGdFYPQk6Dr0gAmy/sAAJkWI+J/mrGc0ZzQiEIpkn78gYQV4AsV -APcPAAxwCgUA6Lo4DM5CgACpM4kymhcoQQ0GmQGZMvhg6BXgAgUA5UUOJAVJgAAqkgwokgornDDr -qwwFUyEAAOuiOQQEQYAAKpIJKhYIZSBEjhjlwJIXAYGAABnA0CjgABXAjgmICoiM7OAHL1gEgAD6 -YGgdoA01AAuAAC1BEStBDZoYfbNUzCuIGGWPv/xgSBWgAU4AGcDBKCAACYgKiIzsIAcpWASAAPpg -aB2gDUUAC4AALEERK0EN7LuTfRAEgACMMs3NYAEKAAAA//3sDaAKBQD8gaQd7/1eAIwyzMNlIELP -rx7A23zgMNrAWUQF26D6YGgdoAIFAFg+oYgWizKKE48ViUILqgKaMp+RJ4aBKYaAn0IiRQ7RDwB+ -xx3H3Q3MAZwyiBaKE44ViUEMqgKaMp6QJIaAKYaBnkGLF8DA7EUNLYTWAACNFLHd7RYEJqA7gACN -Qv+ArgWv+foAjkB06U+PF2TwSh3Au4sQjhKJERrALOjioC2BCoAA/yAAFL/79QD7IABEsAoVAOyS -AS1QCoAAC6oDCogBG8BTKuKiKOagDcwBDKoCCro4CogCmJLRD9EPikAPAgAPAgB0oafqRAAL2ASA -AFjeX/yASBXv944AZa9Oixhlv0lj/wUsQQwfwBCNEY4QDN0R790ID3ICgAAOzAL9oGYVr/2SAABs -EAgGZAoDRAuLQJMQHMAF+oALBGANFQD5gE4F7/j1APpABADQDwUA7xYBKvcCgADs7ggOqAqAAO4W -AysBCoAA6FUDDtAKgAD6IEYVoAMFAIyxjrCewI2wnNGTsZOw7kIAJdP7AAAqon4okn/k7gwNVkKA -AKqIi4eHgpgUirz04AQD8AIFAPcARhXgDRUA+WFIFaAHBQDu1zgF4MEAAOysDAVTIQAA7KI5BANR -gACKudagzyHJbhnAOShgAAmICoiM7GAHK1gEgAD6IIgVoA01AAuAANagzC1lb9aLE4wSi7B8sFVg -ADQZwC0oIAAPAgAPAgAJiAooggzsIAcpWASAAPogiBWgDUUAC4AA80BoHa/+kgD//mANoAoFAM16 -jBGxzOwWASYgU4AA+oAIFeADBQD5f8AF7/xqAI1AdNkujBCPEi7CoMePCP8DD+4BjxMZv+YbwEGK -8SjCoi7GoAuqAQqIAgiYOAjuAp7y0Q/RDwAAAADgYQQKzwKAAOyZCA7QCoAAmhL4IGYV7/7WAAAA -bBAEGMAyhSAogn8TwDH4rwAKsqkFAAlZKKOTLTJ/DQ1f8aYgDeAMBQAfv5wbv4rHT/9gAEXwDgUA -+yAARfAPFQBtCBcosn/xAUAN4d0dAC62f7HM5NAvZdihAABj/+EpMn74cAgVoBr1AAyqDHqd3irM -EAChBAD5GgSZAwmIAfhwBhWv/z4AKTKAyZYrMn4JuwIdwBAMXBGtzPuABhXgAgUA0Q/aIFvb+h+/ -qy4ygC0yfg/uAg7dAh/ABwxeEa/u/cAGFeACBQDRDwAAbBAE9YAEBeKoBQAIKCioVS5QfSlSHXPh -AciR0Q8AwKT9f/gFoCsFAO0kAAn4BIAAWVxJI1Yg6iQACdgEgABZNh3AQNog7DQAClgEgAD+o6gV -oA0FAFj4mbFEaUvlY/+6bBAEwCDRDwBsEAT1foYFoqUFAAUiKBi/RKQk9I/oFaAV9QADVQyoInVF -DQM0CgJCCyItDSIhHNEPEr9m0Q8AAGwQBPt/uAXgCQUA+mAIFaAI1QD0QGgd7/z1APyixh2gAgUA -8qNkHaeqAQDjpAsFDMmAACowCBm/0PlAC+KiAJ0ACakKiZAKkAAAAIYz9kgAA7dmAQDqdAALWASA -AFleNBu/xSdUDCZUDSihB/ig5B2gBS4AKlAH+mBoFeGqAQBZOXIbv7z6osYdoATKAACMM/yixh2g -BJ4AijP1QAjqEgCdAPVACKsSAJ0AaKUqaKcn/USABFANlQD9QAf9YgCdAC5QIMCC+KCmHaAPRQAP -7gL+pAYdoAOeAClQIMCoCpkC+KQGHeADXgCMM/yjZB2gAzYAjTP8o0Qd4AMOACiyfY4zL7KCKbKA -qO7/3+AVoIhNAOjuAQyCCoAA/p8ADzAIJQAI7jf/wQAPcP/1AA/uNv6kZh2gAiIAjzP+oYYV4AH6 -AClQIoozmlvqVgkkgWGAACyygLCY+4AEANAMFQDgiBoOYAqAAOioCAZj/QAADIgC+KFGFaABHgD6 -oUYVoAD+AACNM/yhBB3gANIAGL98jzMuUAeo+CiAgCkK++nuAQxHgoAA+cYADzD4xQAI7gEP7gL+ -oOYdoAAaAMYquDP0f/OVIAjVAClRG2WQXBy/bS2yfSpQFitRGv2BAA5w+fUA+UumDeKvBQAtUAf/ -fXYFod0BAA/dHK7eLuJ/+0ABBLAf9QAK/wx/5SEevriu3g6ZCymdDSmRHAnPNgv/Nwv/LA+/HC9V -G9EPANEPGb7aCc82C/83C/8sD78cL1Ub0Q8AAAvILAi4HChVG9EPAGwQCvhAkBWgCRUA/X0GBaAP -BQD2YGgd56UBAPUADKkQ/RUA678RFTP5AADmljkIBAqAAPVABKkSAJ0ALyAHjiIPDUHp1AAPCq4A -ACogIQobQmWxt8DVCQpH9UAIChIAnQAMqxGsuy6ynpkV98AT6dIAnQArsp1ksdcpIBSkmSkkFI5w -88AO6pIAnQAqICH6LgAOMAt1AP1gEhCiAJ0AZGAm/EDoFeD+FQDurgEKWASAAP5EJh2gDAUA7UQA -BtCBAABYO5zSoNEPwCDRDykgBfUgEciSAJ0AaJcz9SAZzBIAnQBln1Uosl+KgYmAmaCOgIkgmuGf -gO+GASRT+wAA6aZ+JEPhAACYJy8kIC8kIRy+Yf1+FAXgCgUAKiQUKiQXKiUb+kNEHaALhQArJAXr -vwIZUASAAFvbCNogW9rrLCAhLQr+7cwBCVAEgADsJCEp2ASAAFv/GP18YAWv+4YAHr40juiaG5kV -98ATiJIAnQAMqxGsuy+ynvfgFFHSAJ0AK7KdGL4r5LJ+Z3v9AACfiGW+5vggphXgAu4AAADqJAAJ -2ASAAOxEAAroBIAAWECz0qDRDwCJMPoghhWg/sUA9UAJkReZAQCLIiogB/VlDA3hqgEADKkRrJkr -kp73YCLp0gCdACmSnWSUJysgFKS7KyQUjTDzoCJqkgCdAIwU+YAmGVIAnQDAINEPAAAA9WAIcJIA -nQD1YAlBEgCdAPVgGqGSAJ0A9WAcehIAnQDHlfgfAAVwD3UA+AAiHaAOBQD7AgAPMA1VAOn9Ow9w -ZgAAY/9KixXaIOu8GClgBIAAWEDdY/84ACggBy4hCB++I/ggAAGwiBEACogQ74gCCZwCgAAD7gIf -vm0TveiYsPhACBWgJQUAlbOTsv/GAA9wAzUA748CDEYCgAADiAKYsYUriCmetJ+2mLj1YSYV4AgF -AOi2BSyqAoAABdUClbcoJBQMpRGsVfKzphXv9tIAACkK8QmqAfpEJh2v9uIAAAD/9hgNoAsFAGSe -zgOXC/ZgaB2g/7UA8AcADaANtQAAAC2xeYwgfcsFLrGGZeQmwCDRD4grjyl48QnAkvhARhXv/AYA -Kwrx+0AEBfAORQAOuwIrJCHZ0PWgE9oSAJ0ADNoRrKouop73wBxx0gCdACuinZkX7RYGJZShgAAZ -vnP6QAgVoAwFAJwRmRCIcC0KgfjgAAQwDhUA+wAAFDAPBQD4IEYVoAwFAFg+UIgXHL2gDIgR/QAA -RDAPNQAvhp0oIAYtICGPIi4K8f+gBAawCRUA6f8CBEAFAAAoJAafIvxEJh3gDmUADt0C/EQmHe/5 -UgD8IUYV4AoFAFlbAB69khy9i4kVjuiNGoob+d/rsJIAnQD/9jgNoAsFAMCwGL2KwPoP7zT/AQYV -7/XyAIkniJr7IQgV78cFAOWSCyT4gQAA5/cBCjcCgACrbqdVpojolgoiqQEAAP6gFTuiAJ0AyTfZ -MOq0AAIAmYAAbUkFCQCGCgJhLvIABu4I9cAWdGIAnQCe8IqwwOL3YGgd7w8FAPlgaB3nigEAbYkH -KJAIaIELuJnAYf/uoA2gBTUAiJMPqgEIqgKasCggIQ2IAQ6IAvhEJh2v/3YAAAB9qQSJYykkFrhm -9t/oJGIAnQAqYAhkoGdooT5ooulooy5pqduJY26T3mmT24sn+2QAFa/IBQD5QAQFMAgFAOi2CiVR -AQAAmrn7YQYVr/7yAIlj+EEEHe/+ygAYvgiLYyogB6i4KICA76oBDEeCgAAIqgIOqgELqgL6QOYd -r/4yAItjC4pC+iEGFae7AQCbGVlcaBy9NCihB4kZ+iEIFeANtQD6QYYd4P7FAPhBph3g/7UA+EDk -Ha/9SgAAAAAAAADz3+Wn0gCdAPjgCBWg+8UA++AEBfD+FQD/QAQHMAmFAPnGAA9/CQUACYkB/SYA -DPeIAQALiAIoJAeZcP5EJh2gABoAiXD/8cQNp5kBAB69G47onRf3wAxAkgCdAAyaEayqL6Ke9+AN -AdIAnQArop1ksZcYvRKw75+ImRftFgYt66YAAIsW2iDrvBgpYASAAFg/9By9BP/whA2v+UUAK6wY -7CQACVAEgABYP+3qJAAJ2ASAAOxEAAroBIAAWD+T0qDRDwAAAAAAAP/umA2gCQUAKCAHIyEI/XpW -BeHoAQD5wAAXMIgRAO4zAgxCgoAADYgCmJAevPAYvXONIP8gRhWgLwUAn5P4ZgAJsA81AOjYAg7u -AoAAD90CnZGOK40pk5SemfkgxhWgDkUA/SEGFeAIBQDolgUt6gKAAA7dAp2XKCQUDKMRrDP+c6YV -7+zyAACKJ/qAaB3gDAUA6qwgKmgEgABYOhfSoNEPAAAAAAAAAP/x1A2gCwUA614MAYGxgAAORRTo -XAgpyASAAOhINg3QBIAA0w9tiQUJIIYKAmMOOQjlSAwD0QEAAG2JBQlAhgoCZQ5pDKl5KZxA+eAG -Fe/08gAqfED74AYVr/TGAMCw+kNEHeACBQDRDwAAAAAAAAD8IMYV4AoFAFlaIh68tBy8rY7ojRaJ -F/nf8wiSAJ0A//nYDaALBQAAwLAYvKzA+g/vNP8BBhXv+Y4AAABsEASJJyggBouaKpwg7ZIJJEP9 -AADxZzAN54gBAOgkBiQAWYAAwCDRDwAAAPGksA3gLKUAK9AAfLlA/yFoFa/4BQD5ogAV788FAO+v -AQJT/QAA7+4IDV8CgADoMR13cQEAAKvbK7wQ6+MsccBBAABoQQhtqQUIAIYJAmH6QGgdoAsVAFvY -e8Ag0Q8AAOgkBix8rgAAY//jDe0MLNzwDEwUuMsLqzZtuQUIAIYJAmGj2AxKDOn8QCUPEQAAsK1t -2QUIIIYJAmNj/7EAAABsEASMMYgy6iQACdgEgAD84AAGMA01AAuAANKg0Q8AAGwQBCggBCMgB/0B -AANRMwEAwCDRDxu9K9MPK7F++kBoHaK7HQBY/t5lr+XaIOs8GClgBIAAWD9IwCDRD2wQBhi9Ioou -JyAHHLyq+EDoFeAFBQD5QAccIXcBACXCfwmmEaZVhleGboia65IJJAahgAApsBTtsBUt0ASAAOO0 -AASAiYAA2iBb2PXAINEPAAAAAOnCfyaIIYAAiZeOmvwBAh2gBEUA65IJJwgBgAAtsBaw3e3EOA2Y -BIAAHLw47wIAC9gEgAD04AQKEgCdAAx7Eay7LrKemhD1wAvzogCdACyynWTAlS0gBfhgKBWgTrUA -/6AFbCAJBQDtvPUc3gKAAPxgBhXniAEAC4gCmDEvoBTuoBUvgO4AAGTg6SkwFu8CAAT7/QAA9SAE -OJIAnQAvNBbaIFvYysAg0Q9j/ykAAAAA//ywDaALBQAAHrwajeiaEPegCGCSAJ0ADLsRrLsosp71 -AAkjogCdACyynWTBG7Dfn+jqFgAue3YAAIkQ2iDovNQZYASAAOiWACPYYQAAWD7ywCDRDwAAAP/8 -dA2gBEUA+BAiHe/9TgD//AANoAsFANog6zQACmgEgABZJzNkX28qYCgrYCnsYCotVgKAAAuqAutg -Ky1WAoAADKoCCKoRC6oCsar6xWYdqKodAPrFRh2oqh0A+sUmHaiqHQD6xQYdr/zCANog6zQACmgE -gABZJx5kXxsrYCgsYCntYCot3gKAAAy7AuxgKy3eAoAADbsCCLsRDLsCsbv6xWYd6LsdAPrFRh3o -ux0A+sUmHei7HQD6xQYd7/tyAP/6FA2gDAUA9iAmFeAKBQBZWUAeu9KKEI3oHLvKixH5v/bokgCd -AP/7vA2gDAUAAMDAwPoP3zT/wQYV7/t+AABsEAgoIAQnIAf5ABzjkgCdAPcAHKIX1QEA9aAd+RF3 -AQAZvA2KLimSf+sxCC1WQoAAqpkpkAUrJQj6QtAV4DrlAPsgH9wgSCUA+SAfnCA61QD7ICBdIPz1 -AIg5DwIA+CAABLAERQAJRAwEBEH0geAVr/mFAAlEAaSIKIw06BYDIiH9AAD9YwYNpEQdAP2/wBWg -ChUADKw5KiBBWBl0ZKP/5buZG7AEgAD04BgKEgCdAAx6EaWqK6KetEzTD/1gHsOiAJ0AJqKdZGO1 -GLxdGbxb+kREFeAHBQCXEI45KiBBH7xZ+iCGFeANRQD7QACFMb4BAOvdDA1XAoAA++AAR7HdAQCd -Fq3uL/J/+EVEHeAMNQDvFgUncPEAAP4g5hWgD4UA7yRkKNgEgAD5pgAOsAh1AOgkXC7uAoAA7RYA -IVGVAABZVL4nJTUnJGiOFCshB/4gqBXgLOUA/ErmHaBdJQAtJAX9dtIFoE0lAC0kdP7AAARyn0EA -+0AABf3eHQDk3REN3wKAAOy7AgzOAoAA+QYADHD/OQDpu4gf/UKAAA/dAgjdAh+8KZtgiiCLF+lm -Ai91AoAA7+4CDVYCgAAKSgL6wCYVoEpFACpmAywgQRq8IC5mButlCy5kAoAADcwCHbwbJ2UKKmYH -DcwC7GYEIUkhAADpBx4DQIEAAAgCY/xFRBXgDwUAL2QxL2Qy/sZmHeAOBQAuZDUuZDb+xuYdoAwF -APzGBh2gCwUA+saGHeinHQAqZC4tZC32xeYd6N0dAC1kLCkgV+psPCFZcQAA+MdmHeiZHQD4x0Yd -6JkdAPjHJh3omR0A+McGHeAMRQBZVHPpbEAhQYEAAPhQaB2o5x0ACQSKCACI6YMeAcCBAAAnZFMu -ZFL9dkAFqO4dAP7KJh2o7h0ALmRQ7hIGI0lhAAAIYIgJDIoIQIjpix4KRwKAAK5t7GYaJ3AhAAAu -ZhsrIHQr1HSKMRm7RPxA5BXnqgEAmjErIAf4wABEOt0BAO67PR7vAoAA+kEEFaBrEQD00AATMbsB -AObdAg38AoAAD6oCCaoCDt0CnYCPIJyCmoSZhpeF9wDmFeA2BQCWg/3gABewBkUABv8C74YBJDCB -AAADYIYGAmcDQIYGAmUMuRHlmQgCQBEAACiWnSsgFi8K/w8CAH+xByogQYwTWBirJiEUIyES8MLQ -DeAEBQAVu7bKYupSfynYBIAA/AACHaANFQBYN80oUoDkTAEhmAUAAAgzLnZJ29ogWDSCwCDRDxm6 -24iY9wAIKJIAnQAMahGlqiuinrRM/WAIc6IAnQAmop1kYQWwi5uYZWzwYACjiScMThGeEoia9yFo -Fa/PBQDrkggk4IEAAA/PAZ8Rq+qvZq6I6JYKIzEBAAD6wAbjogCdAMk0yULZsG1JBQMAhgkCYS4S -AirCAA6qCPdACGQiAJ0AmsDzYGgd7++uAAAAAAAAAOokAAnYBIAA/IBoHaCPRQDvNQgq6ASAAFkt -bsAg0Q8A6iQACdgEgAD8gGgdoIhVAOg1CCroBIAAWS1mwCDRDwCJImWfI9og7CQAA9hhAABYPYzA -INEPAAD/8KwNoAYFAIoiZa8DKyBB2iDrvBIpYASAAFg9g8Ag0Q8AAMCgWVgFGbqXiJj5H/eIkgCd -AP/8FA2gBgUAAMBgwMoMjDT9IQYVr/vWAAAAAOtqDAGBuYAACk8U7vwIKcAEgADuTjYNyASAANMP -bekFCICGCQJpiRGqOO9ODATJAQAAbekFCKCGCQJrjxKOEQr/DK/uLuxA/4AGFa/7/gAAiBEojED5 -gAYVr/vGAAAAAGwQBvhA6BWgDQUAnRAqIEEbuzsnIAcKrAnpggouZwKAAKy7+2/oFeF3AQDrFgEk -mSmAAISJ8pGwDeBIlQAuQBLz0UAN4FtVACkgBfsgGExg/PUAKyAWKCQFfLETBQxH/Z/AFaANFQAM -3DlYGC5ko1/AMea6UhvABIAA9OAXKhAKxQAMeBEGiAgvgp4pCgQDqTn54Bmb4gCdACWCnRu6RGRT -CwsAh/wBgh2gCUUA48k5CsAEgADpFgIq0ASAAG2ZAggCYee6QhGNEYAALCEHHbo8DAxK7rsPHmcC -gAANzAKcUIog+XYIBeAPhQD2oEYV4GtFAOtWAy1WAoAAD6oCmlH4RUQd4Ah1APhLhh2gDDUA7yRk -KNgEgADuFgAhUZUAAFlTdCkhIvogKBWgXSUA/ECmHeAu5QD+SuYdoE8lAP5Ohh3gDgUALiU1LiRo -/kgwFea6AQD6SAAGPYkdAOSIEQ5mAoAA/WYADbCqOQDsuucdVUKAAAqIAv6hRB2gXUUALVULGrrf -C4gC7FYHL/wCgAAI/wLoutwczQKAAAqZAplWCP8C71YEIVkhAADrBx4C0IEAAAoCY/xFRBXgCQUA -KVQxKVQy+KZmHeAIBQAoVDUoVDb4puYdoA8FAC9ULv6l5h2gDAUALFQw/KWmHeALBQD6poYd6N0d -AC1ULCogV/pLgBXgDEUA+qdmHaiqHQD6p0YdqKodAPqnJh2oqh0A6lQ4ItDxAABZUzMoLGDoJgAC -0QEAAAoEiggAiAoAiioKgPqgAEUwCQUA+KpmHeAJBQD4qkYd4AkFAPiqJh3gCQUAKVRQKCB0KFRw -i0GIQBy6C/hA5BXnuwEAm0ErIAcfugj0QQQV6pkBAP8gABSw6xEA9dAAFzG7AQDumQIN7AKAAA1V -Ag9VAgyZApmgjCCXovVAhhXgPgUAnqP/QMYV4A0FAJ2lnaf9gAAWMA1FAP2GAA53iMEA7KYBJXiB -AAAEYIYPAmcEQIYPAmWOJ+8SAi3PAoAA9yAARL/NBQDvlp0ncIEAAP3ABAbwDwUA7+YCJukBAACd -4f3ABhXgPGUA/Q7mDaA6VQB6gXrKOCsgFiwK/3yxIPpIMBWgXEUAWBdlwCDRD8TfLSQFLiBose7u -JGgp/tYAAMAg0Q8oJAX/9EwNoAMFABW5nIlY5xYDJI33gAAMiBGmiC+CnvoBgh3gCkUAA7o5evN7 -KIKdZIB3sJqaWPUAaB3v9CIAZD+m2iBYMzJj/6PFsvpAph3v/f4AAIwiZc+g2iDsJAAD2GEAAFg8 -bsAg0Q8AAAAA//NADaAFBQCNImXffisgQdog67wSKWAEgABYPGXAINEPwKBZVuiJWIgT+T/70JIA -nQD//kgNoAgFAMCAwMoMnDT8oQYVr/4OAAAAAGwQFJUWlxQiFh3jFgUp+ASAAOMSHSpYBIAAmxeM -8OcyDiugBIAA5jAHK2gEgAD4aDAVp8wBAKz8IjEi8iFGFa/5BQDiuikWYP0AAAnMAZwZisEIiAn/ -AAAUMWYBAOgiCANAYQAAmBjiIn8mYEEAAPugL/qiAJ0AwODyICYVoAsFAA7SDB65ni7ifwl/Ea/u -LuE1KHr//wAxWqIAnQAVuWyWExe6Fydyf+8CAAuwBIAA+6AEWqIAnQCOGQKqDI/jlxKO4q8vcvsB -se6IFPcAKuCQBwUA90AqoJIAnQDAIG0IWgpJNAYoCglZNJmABikLL5YDLpYCKIIACEQMCKoMD4kI -6RYLIRAFAADomwd/eASAAC/sAe70AAO4BQAA7xILIQwxAAD2wwAVoAIFAPaAJ2CSAJ0A90AnIJIA -nQBj/56XEgy+Cwy6Coqgj+OO4gKqDK8vcvsBse7AIPIiBhWgAgUA9oAE+JIAnQD8I2YV4ADGACgS -EOh4CAXYBQAA6BYQJYwxAAD9gwAVoAsFAAy+Cwy6Coqgj+Pu4gIiDZ+AAP9c8A3gBwUAakHHbQhM -BikLBi0KCkg0CFg0CEQMCKoMmNCekp+T740IARAFAADo2wZ/eASAALHv7vQAA7gFAADoIQxu+ASA -APbDABWgAgUAZK9/9p/74JIAnQBj/6wAAAAAAC0SG/QgiBWgCwUAmxArMBaGEvwjBhXg+fUAebEa -jBb6aDAVp8wBAP2fwBWgDRUADNw5WBa3ZKSdLRIQ6bjbFp0JgAAauaqIGo0R7xIDIZGBAADiFhMh -uSEAAOcWESGpcQAAJRYS/iGmFebNAQD/4AAXvbgdAOn/CAxFAoAA+wYADDLtQQDoFhQvdgKAAO7M -Ag3dAoAA/iHmFeAOBQD+IyYVoN05AO+4vB7tQoAADbsC/CIIFeAFVQD+IYYV4AcFAP1mAA2wAgUA -6xYVJugVAAD8IuYV4AA+ACgSF/igGIwiAJ0AwJUJWS/kkm9iqAUAACoKgAp3CC0xBx64rPZAAQe6 -3QEA7LjVHu8CgAAO3QKdcIow/OBGFaBLRQCbc/1AABUwC4UAC6oCmnGJ8MCE+mgwFaGZAQAJiAwp -EhXvFhYtVAKAAAqZAhq5avwiKBWhiAEAKBYaCpkCmXQpEhT/4AgV4AoFACp1Cpl2qP/ouWEX+PEA -AC91C5h37AMeA9iBAAALAmH4ZUQVoAwFAPzmhh2gDQUALXQ1+OWmHaAOBQD+5uYdoAsFAPrmZh3g -CQUAKXQu+uXmHaAJBQD45gYd4AoFAPrmJh2gCwUA+uZGHeAOBQAudDYrEhL+IygVqIgdACh0LC0w -V6/u/iMmFaAMRQD852Yd6N0dAPznRh3o3R0A/OcmHejdHQDtdDgj0PEAAFlRs+kSEyPRAQAACSCI -CgSKCQCICgCKLzIcLhIX/upmHej/HQD+6kYd6P8dAP7qJh3o/x0AL3RQflkz+CNIFaBJJQApNHQZ -uSsqfEX6IGgd4YgBAPkGAAxwCYUA6TRlLEYCgAD4IAYVoAw1AFlRmAYtCykxNflyQAWgOmUAKjRX -6hIWJMgFAAApNTUodhaPoC92F47TLnYZjdItdhiNoCwyHIs/rcwsNhyKoCwSGA1EDKuqrNzsFhgh -EAUAAOo2DyEMMQAA9sMAFaACBQAcuDb8I0gV4AtVAAtbLyx2GufdCAbwIQAALnYbLDB07NR0Le7G -AAAvEhAF/wy2//f/7kFSAJ0Aih+JHimmnSswFigK/3ixCCowQSwSGVgV5I0V/CMIFaBPdQAvNAWc -1/WhJhWv5I0AntiLMmWwzNow6xIIKeAEgABYOwPRDwAvEhCIHQX/DP/gwBXgClUACv82Df8R7xYO -JCUFAACIHyiCnv8ABYviAJ0Ahx8ncp1kf56IHP7gaB2gCgUA6AAFB+rRgABtCA/uDAAFUAUAAP9f -6jxiAJ0AY//pGrgCiqhqoXyLHyuynv9gBLviAJ0Ahx8ncp1kcIwZt/uwqPkhBhWv/r4AixPAoOoW -GS3fAoAAqbubH44fjR4t5p0rMBYsCv98sQgqMEEsEhlYFa2LFYwX7RIGKdAEgABb/XXRDwCPwycW -EI7C+4AIFa/s6gAA//+wDaACBQD//VANoAcFAP4jhhXgCgUAWVVMGrfeiqgvEhz5X/tgkgCdAP/8 -xA2gBwUAwHAct9fAugurNPuBBhXv/H4AAI8Zj/SSEar/79NufXAEgADAsPPgaB2gDwUA7/wEKXAE -gADo9A9l2AUAACzMGP4AAh3gCwUArPKCIK4ictvb/7/OaqIAnQD9zwAJf+ciAAAAAAD2IGYVpAUF -AAXlNv/nPA2vVQEAKDBBKIwS+CEGFa/5NgAAAAAAAAAA//8ADaALBQBsEAoeuHwvISIqIEHsRAAK -6ASAAOcyACugBIAA5iAHKygEgACVFJQT/CBGFaAIBQD8ICYV4WYBAOgWACNIYQAAmRUKqAnrIBYs -RwKAAKju/8/oFaD49QD5ZSYNp3cBAIwRLxYI/iEmFafMAQD9n8AVoAkVAAycOVgVaY4Z7xIIJRNZ -gAAUt4wMaRH0wBG6EgCdAKSZLZKeDwIA96AUFFIAnQAlkp1kUkr5b2AFrZ8dAP7AAAUyvkEA/WAA -FbDOOQDrqgIOZUKAAOshByzNAoAADJkCHLd59mAAR3q7AQDqmQIN3wKAAAy7AptQG7hDhyD4oEYV -oEpFAOpWAydw/QAA++AAFT//BQD/wAQHcAiFAO4WByu+AoAACHcCl1GO4SggQftGAA1wDEUA+qDG -FaF+AQDnxwwMRAKAAAmIAvlwXgXhdwEA98AAR3APBQDvVQoncPEAAJ4WCYgCLlULmFQYuCjoVgch -aSEAAO0DHgLYgQAACwJh/kVEFaAJBQApVDUpVDb4puYd4AgFAChULv6l5h3gDQUA/KYGHeALBQD6 -poYd4AoFACpUMSpUMi5ULfqmZh2o7h0ALlQsKiBXKyxc+qdmHaiqHQD6p0YdqKodAPqnJh2oqh0A -6lQ4ItDxAABZUIIpLGDpJgAC0QEAAAoEigkAiAoAiigiHB64BesUAALRFQAA+KpmHaHXAQD/pgAO -uIgdAPiqRh2oiB0A+KomHaiIHQD4qgYdoA+FAP5Mph3gTiUA7iR0Lu4CgAD8IAYV4Aw1AFlQaadb -Hbcejhf+RqQV4DhlACgkV4rg7OIBJ/gFAAAvJTUsVhcqVhaJ4ylWGYjiKFYYj+EvJhyO4Z4v7VYa -I+AhAAAsVhsqIHQqtHQMaRH1IABEsAiFACiWnSsgFi8K/3+xByogQYwWWBTG7BICKVAEgADtEgEp -2ASAAFv8jdEPHbcBithqoVoMaRGkmSuSnm64cyWSneRQb2Vb/QAAm9hlXb9gAAcsIEEszBKcFYgT -/iCIFeBJdQD4QKYd4A4FAJ44nzeYOY0iZd+y2iDrEgUpYASAAFg51dEPAP/2BA2gBQUAnxj+ISYV -oAoFAFlUVB225YrYjhnvEgglDjcAAP/+dA2gBQUAwFDAugurNPuhBhXv/joAAGwQBCggBPkAB7OS -AJ0A9wAHchIAnQD6YGgd54UBAPUAB+kSAJ0AGbchii4pkn/ssgAtVkKAAKqZKJAFLbEI/EEEHeA6 -5QD7AAmUJ8wBACoKQvsACTwgPdUA/QAJxWBOdQAqIAX3LIAVr/cFAP1tygXgCAUA/0AJtCBPlQD/ -QAukYC7lAC4kVygkaCgkZvhGpB2vjwUA/kymHeBKFQD6ToYdoAmFACkkZCkkZykiHPlu8AWgWiUA -+EVEHaAIFQDoJFwkgDmAACgkaCokBYi7eNMyrL0t3D8H3QGN0A0NR2nRIi5hA3jjHNog7EQACugE -gAD/YMgV4A4FAFv+6sAg0Q/AINEP2iDsRAAK6ASAAP9gyBXgDgUAW/0mwCDRDwAAjyeO+vvhCBXv -xwUA7fILJ+CBAADnxwEKNwKAAKtqp92m7u72CibpAQAA+6AH+6IAnQDJN+m0AAIAqYAA2DBtSQUI -AIYJAmEqwgAGqgj9QAk0YgCdAPuABhWv+roA2iD8oGgd4IxFAOy1CCpgBIAAWSk2wCDRD9og/IBo -HaCNVQDttQgq6ASAAFkpMMAg0Q+KJ46qZOBbiKmKi3rTbwy/CC/8Pwf/AS/yAA8PR2nxXSuRNXqz -V+okAApgBIAA7oIHKugEgADvggksWASAAFv+rcAg0Q8A6iQACdgEgADsRAAK6ASAAFv75cAg0Q8A -AAAAAACKi3rTFay9Ldw/B90BjdANDUdp0QUukTV666fqJAAKYASAAO6CByroBIAA74IJLFgEgABb -/NrAINEPAOvaDAGBsYAACk0U79wIKcAEgADvTzYNyASAANMPbfkFCACGCQJhCjgI7U4MA8kBAABt -6QUIIIYJAmMKbwyvfy/8QP+ABhXv9lIAKHxA+YAGFa/2JgAAAABsEBYjFh8iFiArEiCMMCQWFC2x -Fflh6BWnzAEA/GAAQ7/6BQDusAcjuP0AAAp3ASuyHPojBhXh7gEALhYZ6xYaJCPBgAAsEiCOcysS -HyzBExO28vthaBXgCQUA85kQDevuAQCbUZlQLjJkKBIgDcoMKhYbIoEQL4ESJoERKIIW6BYAL/6C -gACv7i4WHCoymu22chlgBIAA8E7QDe/19QD7QGgd4A4FAG0pIIJzj3Ki4n4rAbH/BfgBDSkB6bYB -J3BDAADotgAl2CEAAPeABkqiAJ0AbQipiXT5YAAF8A4VAPvNAA32mQ0A+yAARPAOBQDkkKFsnQKA -AArLC4J3j3ai4u4rBnZgBQAAsf8F+AENKQGZsei2ACdwQwAA4+PcddghAAB2wXGJdflgAAXwDhUA -+80ADfaZDQD7IABE8A4FAOSQNGydAoAACssLgnkvcggPAgCi4g0pAZmx7isHdmAFAAAv/AEF+AHo -tgAncEMAAOPj13XYIQAA5sscc7hhAABj/08AAAAAAP7UfA3gDAUAYAAEAAB2yY0ftiQetj0UtckT -tcosEiAbtb8XtcIpwSMoEhwswED9MAAUsAKlAPkAAERwDQUA6BYcLhh2AAAoEhgIZgwsEhopEhsK -zAvsFh4km/mAACgSGQKVNgVcCeOEAA5nwoAA9QAUShIAnQAMixGnuyiynv0AHLOiAJ0AIrKd7SQA -ARUBgAArEhspEiAFuwwokhwikRUqkSMIWAqlIqWqIpUVErWbKpUjKJYc4gAFDsgEgABtyQIJAmEj -FhLrFhsik+mAACUWFy0WIYkQKhIc86BoHeACBQDsFiIszoKAAPgjphXgBwUAbVmsKxIdnjD8I8gV -pVodAPRgZhXgCCUAmDIlEiAoEh+sfIlQ9GCGFaBNBQCdNZs3/yYADvALZQDtNgYszgKAAAuZApkx -iIuYOPSh6BXgCQUA+GFmFeAIBQDoNgop6ASAAOU2CSlYBIAA5isjcaihAACPwY7A79YNJdgFAADu -1gwm6CEAAOXREXZgIQAAdrPgwPD//3wNoA4FAB613x+1xOd8ICEQEQAA6qxAIZmBAAAtEiErEhcX -tWHyIkgV4AwFAAy7NSwSIi4SGww/Eaf/7PadLwT+AAAuEhQpEiALsgnsEgApFsKAAPOgAEEwCgUA -KpUVKpUT6pYcLmaCgACc4CyRIfsiJBWgCBUA+SgGHaBYFQAolAUMqgwqlSHRDygSIJtRmVAtgRTi -hRAjKA0AAPcCJB2iVR0A5RYbLpp+AAALxBSzRAQkFOoSICIgDQAA7BQAClgEgABYCJsoEiAqFhwk -hRQpEhwqEiDlpRMs5SYAAMAg0Q/scgEnAKGAAP+AAEYwBhUA/Z4AJaAAGgDAYGrBE/1gAAawDxUA -/e0ADvbsDQCu3a1mjHAMDEfszP8rEASAAPef+zCSAJ0A3XCI1A8CAA8CAPlgAAcwDxUA/+0ADzaI -DQDo7ggGY/0AAO5mCAYA4YAAjtUOCkv77QANNu4NAA6qCOpmCAZj/QAA7dwYJg7zAABj/xQatRKK -qPdAFiCSAJ0ADDsRp7sosp79ABbrogCdACmynWSS1Bu1CbComLjtlAAM60YAANLQ0Q+Mcy4SIAwM -S/3B5hWv7gIAAAAAAAAAAP/5tA2gCwUALBIgKBIfjM+IhwsAh/ghABXgBRUA/K0ADjyIHQD5gABG -MAVFAG1aAgkCYSzM/wwMQeXAnGDIIQAA6WwLDNgEgAD8IqYVoAg1AOhoNA1gBIAA+CNGFaAIRQBt -iicpEhV5uw2FwfmACBXgAEIAAAAAAPQAAh3gCQUAlbmZuOzMCCXYIQAAYACwACsSICgSFIIQLbUV -LbUT/WOGFeAPFQAvtEAusSH9YiQVoFoVAOq0BSkWgoAAkoAOzAzstSEqkASAANEPAAAAAAD/8bQN -oAIFAACxyOwWEyQpO4AAwLD5gAIC8AhFAOyIDA1gBIAAbYkxdrsMicCIwfgixhWgAD4AAMCQ+CLG -FeAJBQDpVggl2AUAAOgSFiZgIQAA6FYJIqghAAAsEhPAswy7DHa7B/ojRhXgAB4AJhYaKRIZKRYS -9SAIShIAnQAMmxGnuyyynveAC3NSAJ0AIrKd+EBoHeACpQDllAAEimGAAJ6QKRIcKZzACVkUmVMp -EiD4IAgVoAslAJtSjJD0oIYVoEsFAOtWBSxGgoAAmFcPywL6oMYV4AhlAOsSHy5mAoAACMwCnFGL -u/qhBhXgCAUA6ZIPIuDBAADpVgkg2IEAAPihZhWgCQUA+KFGFeAIVQBtigULAIgMAIooEhLrEhos -RwKAAPcAAERwDGUALIade2sH8AAoDaAGBQApEhoJZgzoEiAjYA0AAPgjSBXizB0ALBYbKYYcKYUh -LYRA/QJkHa/rTgAsEiArwRIqMmQswhbsFgAt3oKAAKuq+iOGFa/y/gCMOOoWIyYN34AAKxISDLsR -p7sosp73AAQjUgCdACmynWSQe7DI+GEGFa/7tgD8JEYVoAoFAFlRyhq0XB60zIqoH7SxLBIi+V/p -GJIAnQD/9OANoAkFAMCQGLRUAqs0+wEGFe/0ogAqEiDtpRMskASAANEPAAD/+lQNoAIFAMCgWVG4 -HrS6jDgftJ8qEiP5n/vIkA0FAP/59A2gCQUAwJACyzT6YQYV7/nCAAAAAGwQBhe1EoYw+uuIFaAN -BQDuIAcpKASAAPhB6BWv8gUA/0BEFedmAQD9QIQVoe4BAOuhBSQOYYAAiaDv/P8mY/0AAO+lAi5n -AoAA7JkIDd8CgAD7LwAM8ADWACuhBSyhBOmiACXYBQAA+Z/gFa+7AQDrpQUsRwKAAPuACORiAJ0A -6JkIDf8CgAAPmQwJAIcNvWDpAAcF8xeAAC1yoSihBf70SBXgCRUAKVUT6VUULEZCgACouChVEuj/ -CAxGgoAA6N0ID2AEgADvVhYmilGAABu0BQzpEfXAB5ISAJ0Aq5kqkp73QAuTUgCdACmSneqUAASJ -SYAAGbRy9mAARzWNHQDopgMnaP0AAPlABhXgDiUAnqIC3QEetFASs/fpUgAv/oKAAP9A5hXgSAUA -mKWSpP8mAA8wAmUA7qYGLM4CgAACmQKZoYg7mKiJX/lBJhXgDgUAnqueqojTmK2O0p6siNMZtErt -0gIkcEMAAHjrNAnpAemmDybABQAAmK7vRgAuRwKAAKuI8xOmFaBZFQDpVAUtEASAANEPAC2lBf/7 -hA2gCwUAGbQ5na4J6QGZr+9GAC5HAoAAq4jzE6YVoFkVAOlUBS0QBIAA0Q8AAB6zzIro90AEaJIA -nQAMyRGrmSiSnvcABVNSAJ0AKZKd5JChZUP9AACY6OqUAAz35gAAYAAZpjkpnD8CmQGJkwkJS/ih -5hXv+J4AwCDRDwAmURQjURLAQOoWAyMBUYAA6nJcKdgEgAD8AAIdoA0VAFgwmyhyXYoT5EwBIZgF -AAAIMy52SdnSoNEPAAAAAP/6RA2gCQUAAJ8QnRH8IEYVoAoFAFlRER6zoxuznI0RiuiPEIwS+V/6 -sJIAnQD//awNoAkFAMCQwIoIqDT5wQYVr/1yAAAAAGwQGiggBOkgByk4BIAA+QAn05IAnQD3ACeS -EAoVAOMWKSp/AoAA9OAABHGZAQDpFigkY/kAAOysOQwVhAAAhieOavrBCBXvwgUA7WILI2CBAAAC -wgGr+gLdCA/uCO5mCibpAQAA+6ArO6IAnQDJN8lF6bQACcAEgABtSQUIAIYJAmEqwgAPqgj9QCx0 -YgCdACrGAPolJhXgDBUAGLO/iX4ogn/uEikszkKAAKmIKIAFLuEI/uEEHaA95QD9ACeMYEklAPkA -J0xgOtUA+wAqtSBLlQAtcAX7oCt0YP71ACtwFn6xCypwQVgRMWSlhS1wBSJwB8Xx/6vmDeEiAQDF -hHjRVSoSKRmzeYqrepMiKxIpjLAMDEesu/tn4BXv/AUADLsBK7IACwtH9WAioJIAnQDrEikr0ASA -AO0cCCjgBIAAW/0TZKRPLhIpjxD/wSYV4A0FAJ3oLXAF8iTmFaBWRQD3oAsMIAMVAJMUFrOBJXEI -LRIpG7QRFLQPGrOB/2gaBeACBQCSF5IWkhiSHiIWEiIWFCIWGi8WFfokBhWv+PUAKBYbKBYhJBYT -+iHmFeAONQD+IUYVoBulACsWHPQk6BWgDiUA/iEmFaAYtQD4IgYVoB7lAC4WFonbjNgsFhgGVQKN -2ZUd/CMmFe9VjQDlFgws0gKAAPoj5hWomR0AKRYe9IAaIhIAnQAdsw8MTBGtzC/CnsBvdvMCIsKd -ZCN3H7MNjXDuswoQyEEAAPTg5BWgFoUA/aAAEbAFNQD0ZgAJ8CUFAOWzARqCCoAA9UAAAjAKVQDu -3QIKJwKAAOVEAglABIAA5bL7HpAEgABtqjeUgJOBn4KWg5KEipWLk4yQjZTukgIkyGEAAJqH+wEm -FeCtnQD1hgAN8M6dAJuFmobshggkQMEAACoSJxuy5g8CAAyqEftAAEVwCfUA+VOmFeBYRQAodAUr -Eif1YBIiEgCdAB2y3Qy8Ea3MLcKe96AcC9IAnQAiwp1kIqwZs6YvcQcWs6MTstX4JSgVqv8BAOxx -Ii//AoAAA/8CnyCLcP1lpAXgXoUA/kBmFaADdQDtJgIt3gKAAAO7ApshiocqFiT5AMgVoA8FAC8W -JigWJS91NS1wBS90Z/7sxh3gKOUAKHRX9uVEHaAOVQD+64YdoAuFACt0ZC5waProMBXvipUA+uym -HaBGJQAmdHTrugkHcAUAAO50aC1XAoAAqpn5L+gV4F4FAH7RDsRudtEJxYb5oBY9IgCdAC8lCvjA -AAb9TB0A+2bwBaLpQQDqJgcvdgKAAO7dAgolAoAA+AkCHeDpOQDpJQsvdUKAAATuAg7dAu6zah3c -AoAADbsC7LNoHm0CgAAO3QKdJgy7AusmBCPBIQAA6AceASCBAAAEAmP85UQVoAoFAPpGZh2gCQUA -+EaGHeAIBQD4RqYdoAQFACQkNv5F5h3gCwUAKyQy/EWmHaAOBQD+RgYdoA0FAPxGJh3gDgUA/kbm -HajfHQD8RcYd6MwdACwkLCtwV/pHgBWgDEUA+kdmHei7HQD6R0Yd6LsdAPpHJh3oux0A6yQ4I9lx -AABZS7oofGDoJgABSQEAAAkEiggAiAkAii9yHCosVPov4BXgDMUA/kpmHej/HQD+SkYd6P8dAP5K -Jh3o/x0A7yRQJdhFAABZS6kpcHQpJGQoEigZslgMiBGpiCOGnStwFiYK/3axCvroMBWgTIUAWBAW -xKX64KYdoAIFANEPwCDRDx2yU43Y96ALmJIAnQAsEiceskkMzBGuzC7CnvfAC7vSAJ0AIsKdZCFu -H7JIsN6e+GUtpWAATwAAHbJFjdj3oAs4kgCdACwSJx6yOwzMEa7MLsKewP//wAtL4gCdACLCnWQh -YB+yOrDe/+EGFa/yfgDrEikr0ASAAO0cCCjgBIAAW/3zZauviHJlj3ArEijacOu8GCvgBIAAWDUV -wCDRDwArEinacPygaB3gjEUA7LUIKmAEgABZJOPAINEPAAAAAOvaDAGBsYAACk0U7twIKcAEgADu -TjYNyASAANMPbekFCECGCQJlCjgI7U4MAUkBAABt6QUIYIYJAmcK+AyoKCiMQPmABhWv6fYAKSxA -+YAGFe/pygArEincQPygaB3gilUA6rUIK9AEgABZJMbAINEPAAAAAAAAAOp0AAnYBIAA7EQACugE -gABY973AINEPAP/yCA2gAgUAxdL84KYd7/TeAACOcmXukytwQdpw67wSK+AEgABYNN7AINEPwKBZ -T2EdsfKN2Pm/9BiSAJ0A//p4DaACBQDAIB+x7cDqDt40/+EGFa/6MgDaIFlPVh2x543Y+b/0eJIA -nQD/7TQNoAIFAMAgH7HiwOoO3jT/4QYVr+zuAGwQCMCl/WVoBaA7BQBZTukdsfj4QggVp2UBAOgW -BSMVHQAAiDeOivRgaB3gBAUA6IIJJw/JgADTgI8iZPH3hlhlZAuKLxuypetWCyLAgQAA6KYAIUjh -AACZWJpZ+EHmFaACBQDRDyjSsYiMFrHkFbHgKYECLYEE+wCkFaD+tQDrggAknYmAAOyc/ybL/QAA -7IUCLM8CgADpuQgNVwKAAPsvAAywANYAKYEFKoEE7IIAJMgFAAD9X+AV75kBAOmFBS7vAoAA+UAK -nGIAnQDtyQgM3wKAAAuZDAkAh8CgCqpg6QAHBXMPgAAvIAwogQUtIAcmYijlUqssRkKAAKioqGbo -IQcrNkKAAKZVLFAHJiANKFUH+KDoFaDdEQDuzAEO74KAAA3MAvyg5h2g/sUADswB/EDwFe+ZlQAp -VAWSWi9UDPahph2gCwUAm1mbWPtjAAXh3QEADcwCLFQHiI76AAgd4AnFAG2aAggCYfKsUA3vywUA -h1eGeox47nILI+iBAADr2wEKfwKAAKz6q+7vZggOSASAAOZ2CidxAQAA+8Al26IAnQDJM8lBbUkF -AwCGCQJhitAPAgAPAgCvqv9AJzQiAJ0AmtCGUOjCACtOAoAACUkCFLGH+YAmFeeIwQAoVHQkQp4t -wQjkZAwOGASAAO1VCCIgBQAA9WAABbaUHQDksilsykKAAAQIRQmIAvijZhWv+KIAAAAAAAAAAPgA -Ah3gCwUA+wCkHe/6lgD/+BwNoAgFAAAAHLIq/GEEFeAKVQD+oQQVoDsFAFlOWi4wKC0wKRyyJP3A -ABcwClUA/6YADrA7BQBZTlMcsiAfsWH+YOgVoApVAPZgyBXgOwUA/iBmFaAmBQDv8rErAgqAAP4g -hhXg150AWU5HGbFVKZJOwIDnFgIkjXmAACQWAY4Ujuwr4QSE4Pt/4BWv2DkA7eUFLWcCgADsTAgO -zwKAAAnJDAkghwgGRv/AZBXgCRUABpli/SQAR1b/AQAM2REJyQwJQIf2AAIdoAkVAAaZZPUgBYdS -AJ0AfakEyPF58VsWsTsUsTjmYigu1kKAAKqZJEKrqWYJZhGmRIpHi6rpQgolhWmAAIyp8yAG7SIA -nQCOEovCjcMOuwyOE/oAIh2gBwUAC6c4/68ADrAJBQANqTj44AWmYgCdAGAApAnaEeqaCA23AoAA -/cCkFeXKHQDmRggOZ4KAAPzPAAswBBUA9t+AFaSqAQDqYgAtAQqAAPyAAQJf/PUADEwDDKoBCkQC -lGCE4OvhBCboBQAADQ1PLeUFe9EMsLoMrBH8gABGP/x6AMDQLeUF//+oDaANBQDzJt4NoAwFAPog -SBWgCQUAh5KJkwp3DIoT9gAiHaAOBQAHbjj7LwAMsA8FAAlvOH/gB/SNXg3gKQUAGrD2KqJOsYj7 -H/RTogCdAGAAKgAAAP/3dA2v6KUA6iQACmAEgAD7Y1gF4A0lAOs2ASnYBIAAWA3ewCDRDwAcsaf+ -IGgV4ApVAP4gSBWgOwUAWU3TwKX9Y0QFoDsFAFlNz8Ag0Q8A/YBIFeAKVQD0IOYVoDsFAO7CAyyC -CoAA/WMyBaDdnQBZTcWEFxyxlvyACBXgClUA/oCwFaA7BQBZTb9kT6+IR46KyOf5ASgVoAAiAAAo -CgAcsY0tQhv/AGgV4ApVAP8ASBWgOwUAWU20JyAH+kBoHaF3AQD64Ggd4DwFAFgDReoWACVZ+YAA -KDwg6BceDUgEgAAJAmsIgIYJAmkIYIYJAmcuEgAcsXknFgb9wBAV4ApVAP/AMBWgOwUAWU2fiRWG -ECmSE/jDZh3omR0A+MNGHeiZHQD4wyYd6JkdAClkGCgiFoMW+MPmHaiIHQD4w8YdqIgdAPjDph2o -iB0AKGQcLlIbHLFi/CAoFeAKVQD+wmYdqP4dAP7CRh3o/x0A/sImHej/HQD+wgYd4DsFAFlNgo8Q -JkIb9+LmHahmHQD34sYdqGYdAPfiph2oZh0AJvQULkIc/+RmHajuHQD/5EYdqO4dAP/kJh2o7h0A -LvQgHbB5DDwR/YAARnALVQCbwCwgFioK/3rBNisgB/dg5gXiqgUACrodp6cncn/BjwyIDPjgBJIi -AJ0AH7Bt9YAAFrA2BQDm3QIN9wKAAK/uneCIWGSOD4pZwJCZW5igi1iasZlY+KEmFeACBQDRDwAA -AAAA7OoMAYGxgAAKThTm7AgpwASAAOZGNg5IBIAA0w9taQUIwIYJAm0KOAjuRgwFyQEAAG1pBQjg -hgkCbwr4DKi4KIxA+aAGFa/skgApvED5oAYV7+xmAB+wTAzNCh6wTK+vD90Lrt0r0X/7egAV4A4F -AA67Nfuv5B3v/Z4AAGwQBCogBP1A4AvQGHUAa6QKeKEfwCDRDwAAAADqJAAJ2ASAAOxEAAroBIAA -WPaVwCDRDwDqJAAJ2ASAAOxEAAroBIAAW/44wCDRDwBsEAbEcvlhtgXgBgUA9iAGFaAFNQD4RUQd -4AsVAPpisBWgKOUA6CRXIgMhgAD0gATIkgCdAGhCQPSAByGSAJ0ACmsUe1AFLDAULCRgKixl7bDm -GNgEgAD8IAYV4Aw1AFlJRSYkaCYkaSYlNSYmHCckdB6wQS4lN9EPwIb4S4YdoA+FAP5Mhh3v/uYA -AAApMDDBotMPepFo6yRkIVF1AAD8AGIdoCslAOskXCHYdQAAWUkxKixh+mMgFeAMNQBZSS0qMBVj -/3kAAAAAKixd+mOgFeAsBQD8TIYdoA0lAO0kXCrgBIAAWUkjLjAYf+fRKixh+mMgFeAMNQBZSR5j -/8AAH7AkKDEcL/J/CYgRqP8o8TYoNRyP8P5DxhXv/fYAAADosJwa4ASAAPpMhh3gKTUA6SRcIVGV -AADoFgAo2ASAAFlJDCYkaCYkaSYlNSYmHCckdNEPbBAG9OAABHAHBQDmIhAkFFUAANUwiyJkseqM -WGTBwsAg0Q8AGK/rKIKJiIwVr+kpgQIqgQUtgQTrggAklwGAAOyc/ybL/QAA7IUCLM8CgADpuQgN -VwKAAPsvAAywANYAKYEFKoEE7IIAJMgFAAD9X+AV75kBAOmFBS7vAoAA+UAKrGIAnQDtyQgM3wKA -AAuZDAkAhwenYOkABwVzF4AAKYEFGK+4LiAMLyANKIIo5VKDLM5CgACpqamI7CAHLEZCgACoVStQ -ByghB/ig5B2g/bUA+KDoFaDMEQDtuwEOZ4KAAAy7Avqg5h3g/cUADbsB/EDwFa+ZlQApVAWSWpdY -J1YJL1QNLlQM/17oBaHMAQAMuwIrVAcogg7+AAgdoAnFAG2aAggCYeRSMWpHAoAAjleYEY3q+8Fo -Fe/JBQDs4ggneIEAAAn5AZkQrIqpu6jd7eYKJdkBAAD7YBEDogCdAMow6cQAAgDxgADtEgEpwASA -AG1JBQgAhgkCYSryAA8CAA2qCPtAEiRiAJ0AmvCIUIrA6a+PHF4CgAALSwL7gCYV56rBACpUdCmS -di/BCAmIDO9VCCRABQAA+WAABzaYHQDk4U9sykKAAAgIRQmIAvijZhWv+QoAJ4UF//qgDaAJBQCM -Lx2wLe1WCyLQgQAAmsDsVgkhWOEAAJtY+kHmFaACBQDRDyQgBw8CAA8CAPpAaB2hRAEA+oBoHeA8 -BQABEQJYAd3krfJhwMEAAOgPHg1IBIAACQJnCECGCQJlCCCGCQJjKaAA6GITJIbRgAD5Q2YdqLgd -APtDRh3oux0A+0MmHei7HQArpBgpIhYnpAT5Q+Yd6JkdAPlDxh3omR0A+UOmHeiZHQAppBwoUhv5 -QmYdqIgdAPlCRh2oiB0A+UImHaiIHQAopBAfrywMThH/wABHcA1VAJ3gKCAWLAr/fIE2KSAH+15M -BeKqBQAKmh2rqyuyf8HPCMwM/WAH4iIAnQAdrx/1AAAVsD4FAO67AgznAoAArcybwIhYZI0hj1mX -W5jwglifIZdY9qEmFeACBQDRDwD/+twNr+ilAPTgaB3v+B4A+UNmHa+LFQD7QCYd4A0VAP1ABh3o -yB0A/UNGHajMHQD9QyYdqMwdAOykGCRIBQAA+MJmFe/8RgDqJAAKYASAAO6vxBnYBIAA/mAmFaAN -JQBYC/bAINEPAOy6DAGBuYAACksU7bwIKcAEgADtTTYOSASAANMPbdkFCICGCQJpiRCqOOtODATJ -AQAAbekFCKCGCQJrjRGLEArdDK27K7xA++AGFe/3HgAAjhAu7ED/4AYVr/bmAByu5AiJChuu5Kys -DJkLq5kvkX8v/NAH/zX/L+Qd7/wKAAAAbBAGKCAE/QDgC9AZdQBrhF55iRv04AAFcAcFAOYiECUU -UQAA1TCNImTR/45YZOHXwCDRDxiu6CiCiYiMFa7mKYECKoEFLYEE64IAJJehgADsnP8my/0AAOyF -AizPAoAA6bkIDVcCgAD7LwAMsAE+AOokAAnYBIAA7EQACugEgABY9+PAINEPAAAAKYEFKoEE7IIA -JMgFAAD9X+AV75kBAOmFBS7vAoAA+UAKjGIAnQDtyQgM3wKAAAuZDAkAhwenYOkABwVzF4AAKYEF -GK6vLiAMLyANKIIo5VKDLM5CgACpqamI7CAHLEZCgACoVStQByghB/ig5B2g/bUA+KDoFaDMEQDt -uwEOZ4KAAAy7Avqg5h3g/cUADbsB/EDwFa+ZlQApVAWSWpdYl1kvVA0uVAz/XNQFocwBAAy7AitU -B4iO/gAIHaAJxQBtmgIIAmHkUi1qRwKAAI9XmBGO+vvhaBXvyQUA7PIIJ+iBAAAJ2QGZEKyKqbuo -7u72CiXZAQAA+2AQ46IAnQDJPOnEAAIA0YAA7hIBKcAEgABtSQUIAIYJAmGK0A6qCPtAEiRiAJ0A -mtCIUIrA6a6HHF4CgAALSwL7gCYV56rBACpUdCmSdgmIDOnBCCRABQAA+KEEHev4AQDx9SAN5pgd -APUoABS1iAEACYgC+KNmFa/4tgAnhQX/+rANoAkFAIwvHa8k7VYLItCBAADqxgAhWOEAAJtYnFn6 -QeYVoAIFANEPJCAH+kBoHaFEAQD6gGgd4DwFAAERAlgA1mSt4+mkAAHAwQAACGCGCQJnCECGCQJl -CCCGCQJjKaAA6GITJIcBgAD5Q2YdqLgdAPtDRh3oux0A+0MmHei7HQArpBgpIhYnpAT5Q+Yd6Jkd -APlDxh3omR0A+UOmHeiZHQAppBwoUhv5QmYdqIgdAPlCRh2oiB0A+UImHaiIHQAopBAfriUMThH/ -wABHcA1VAJ3gKCAWLAr/fIE2KSAH+1w+BeKqBQAKmh2rqyuyf8HPCMwM/WAIEiIAnQAdrhn1AAAV -sD4FAO67AgznAoAArcybwIhYZI0Uj1mXW5jwglifIZdY9qEmFeACBQDRDwAAAAAAAAD/+uQNr+il -APTgaB3v+C4A+UNmHa+LFQD7QCYd4A0VAP1ABh3oyB0A/UNGHajMHQD9QyYdqMwdAOykGCRIBQAA -+MJmFe/8LgDqJAAKYASAAO6uvBnYBIAA/mAmFaANJQBYCu7AINEPAOy6DAGBuYAACksU77wIKcAE -gADvTzYOSASAANMPbfkFCICGCQJpiRCqOOtODATJAQAAbekFCKCGCQJrjhGLEAruDK67K7xA+6AG -Fe/3HgAAjxAv/ED/oAYV7/bmAB2t3AiLChyt3K2tDbsLrLspsX8pnNAHmTX5b+Qd7/vyAAAAbBAE -FK3siCjykSgV75llAPhAph3gBQUA5SYKJAC5gAD6AEIdoDsFAOytzxloBIAAWUq7KiIeKEJ2hCDo -RAwFfcaAAIkni5rksJVk0IEAAIuZjbENDUf7oGgd4AwFAFgq4h6tlu4ABQFIgQAACQJhCQJhCQJh -CQJhCQJhCQJhiCf/BAAV78kFAAn/AeWGCif5AQAA74YJKlgEgAD/AQYV4AwFAPphiBWgDRUAWCp5 -0Q8qIhkrIhj+bggVqAA9AAq6GAoKTwqqD/9AAQUwDAUA+0AIFaANFQBYKm5j/2UAAAD//bQNoAsF -AGwQBMCQGq2TBAhH51wvLEcCgAD7AABENHcdAJeAJCAW8kDwFaAb9QD7WxgFoPb1APaEhg2iqAUA -CCgdqooqon8Euwx7rSscrYUIShDqWgIJXwKAAKy7mrCCOOsyCSEAkYAAmTuSsIw4m8GZOJk50Q/R -DxKtfQROCh+tfaKCAu4Lr+4t4X8F3QwJ3TX9z+Qd7/8mAABsEASIIsiDwCDRDwDorVESMEEAAPSF -4BXncwEA9OAMehRVHQAMehGoqCmCntMP9SAPU+IAnQAqgp1kocssIhgdrW2IKfpBSBXgzEEADcwK -LMKoCLsMLSAipMT1bdINoAkVACwgIxetvQ3MDOTBtWPrAQAAKyAHCwtBDbsJK70CLrEGDO82D+4M -LrUGLCAir8z+QWgVp8wBAOwkIiYNIYAAK3J/4LEEBmv9AADg3RoM2AqAAO3uCAXb/QAAC+4CLiYK -CO0M9aAMI6IAnQAoIBb7WqQF4P71AO6BYXQ4QQAALCAHLiqgDs4dq+stsn4AcQTnsn8s+AqAAA/d -AR+tNg13Aie2fx2tRgiHCq/uDncLrXctcn+x3S12fyuygACBBACYGvlgBdCiAJ0AGa06DM8RCf8I -L/IAD4gBZIC6G60BH60FHK0x6wAFDUAEgABtWQIIAmEuIQcODkrprQEfdwKAAA/uAp6giyCZopaj -7LsCDe4CgACbpA1dAp2hKCIYH60k+AgABzKIUQDmiBEPdoKAAAjuAg/uAp6nLCIVjSmkzKTdnSns -JhUlEIEAANEPABys7onI9yAHwJIAnQAMehGoqC+CnvXgCCviAJ0AKoKd5KD8ZNv9AACbyGWuX2AA -KAAtfQIu0QIs0QEt0QUOzAH9n/oy4AgVANog7CQAAdhJAABYL8LAINEP2iDsJAAB2GEAAFgvvsAg -0Q8AAAD/+GQNoAoFAC4gBfXf7uCSAJ0AjyLAggj/Av5ARhXgAgUA0Q/egPhBRhWv+e4AAAAoIAcb -rVP/jwAOcYgBAAuLCewkIiXYCwAAKrEGr6oqtQYsICLMyYkp+EFGFeAAngAALnJ/iivg4QQGa/0A -AODdGgzYCoAA7aoIBdv9AAALqgKaKtog64wfKWAEgABYL5jAINEPwKBZShscrKyJyBispfk/99iS -AJ0A//xADaAKBQDAoMD6D580/4EGFe/8BgBsEAYZrXbikl0pcASAAO1EAAngBIAA8mAIkqAPBQAl -klyVECtRBOVSACYj/QAA8k8ACfAIFQDsuxEOEASAAPVgAEXwADoAsf/z4AcEYgCdAA9WFA5mEQa2 -DCZt//bH6BWkrwEAAKEEAIka6WYBDQIKgADyQCAVoWadAP7cjA3gCQUA6ME8Z7AFAABtSS4GVxQO -dxEHtwwnff/25+gV5FYBAABRBACKGup3AQqCCoAABwcZ5XAGYzAFAACxmQnKDGmhg2TAR4cQKnEE -Kfr/7KoRD5gEgABtyTTy4AgVpUMdAP6QABI0UwEA4FEEAZgFAADqIggMKAqAAAQiDOlSAwEj8QAA -hkACYgECUgKSQBKtMyzlEygioi/lEiIioaj4mNDo5hYvroKAAKUi0Q8ZrSwpkqIs5RMv5RKp+ZnQ -+cLGFeACBQDRDwAAbBAMkh2CMIwdlBH7gmQV5yIBAPJgAEE/+QUA5MAHIRD9AAAJIgGKI+zBFSnA -BIAA/CBGFaFEAQD5WiwF66oBAOoWDC2gZgAAiyHntAAFHFGAAKq7+34AJeAGFQBqsRT7YAAG8A8V -AP3tAA726w0Art0NZgiJIAkJR7CZ6pFVaxgEgADbIG0ISIy0sJn/YKgV4A4VAPeAAEP7rAEA+80A -DTbMDQD9QABFO98BAOpmCASAyYAADe059+AAQ/b/DQCv3e1mCATL/QAA67wYJIwfgABj/7CKHSOl -ECalESmAE2STPZdRih36wGAV4AwFAPygBhWiux0A6xYIKOAEgABb/26OHZoUjRjt5RQlFMGAAO6s -cBnIBIAA8nFQDe/19QAarNwqopr5QGgdoA8FAG05IIsjgyKr+3+7AbEzBTwBDr0B7YYBJ/hDAADs -hgAkQCEAAJQe9yAFwqIAnQD0ACIdoAwVAIgkCAtL+40ADfaIDQD7AABEcA8FAOSNNQQBoYAACpgL -bdopiyeDJg8CAKv7Dr0BLYYB77sHdMgFAAAjPAHlPAEH+EMAAOyGACRAIQAA9ysmDaAMFQAoIgUI -C0v7jQAN9ogNAPsAAERwDwUA5I01BAGBgAAKmAtt2iWLKYMoq/vvuwZ0yAUAALEzBTwBDr0B7YYB -J/hDAADshgAkQCEAACIsGPc/+tOgDBUAhB6PEu4SCC/GwoAAqKiYGYgU6vkRD/+CgAAPZgypiOgW -BCcTQYAAwFoF6jaaFwqqCeQWAy1XwoAAmhb0gAyiEgCdAIgTGau2DIgRqYgsgp77gBF7ogCdACiC -negWBSQQyYAAiBWJFowXjh2LGBqrqC3hFQy7DJsYrN0t5RUKAIdtmQIIAmGOF9MPZOGNFKuoGKwa -EqwA/CCoFaAJBQD/wACGsAUFAP4gCBXgAyUA6hIELu7CgADtzAgOWASAAOwWCy/+goAA/iFGFeXq -HQCMHJiwk7KPGZ6zjR2OGq9fjdDktgQlUQEAAPdhBhXgQwUA7LYJIqiBAADzYKYV4AxlAP9g5hWg -AwUA82FmFeAOBQDutgotmASAAOLeAg7uAoAA7rYGLPAEgADs3QIEyBEAAP1gJhXgDFUAbcol98HS -DaAEBQCE8f3gCBXgABoAwNCUPe02DCdwBQAA7/wIIZghAACMGxSrc/tsABXgAyUA/X/65SXqHQCN -F8DgDt01iRMaq2iPGOgSBizPAoAAqpnolp0ngEmAAMAg0Q8AihCLEYIV7dgJDVaCgACasIsdC4gR -+EAAQTAJBQD5YqQd4FoVACq0BdEPAAAAAAAA//IADaAGBQATq1mOOPfABniSAJ0AiBMZq0/sEgYs -RwKAAKmIK4Ke/WAGa6IAnQAogp1kgMSw6Zk46BYFLHLeAABgAGgAAAAA9wDGFe/y+gD//XgNoA0F -APDBEA3gCQUAGqwWlB77U0gVr/RqABqsEvtTSBWv9w4AKZJkihKGHfZgyBXgDAUAnFCXUSxiFgq6 -DJoYKmESnBAjYRDmYREtVoKAAKqZ+CCGFe/yOgCCFdEPAAAAAAAAAP/3UA2gCAUAjh2CEPggKBWg -DwUA/8KkHeBdFQDt5AUpFoKAAJKA0Q/AoFlIkI44+d/5UJIAnQD//RgNoAgFAADAgAXpNPhhBhXv -/OIAAAAAbBASHqtMJuKJkh0iYl0nYl/0zSgV55UBACtiXisWEvUgLikSAJ0AjzeM+pMe5MDvZ+iB -AACD+Y8xkxiI0///4BXvzgUA/6AEBzffAQDujggO7wKAAK096tQAB3EBAAD/oEDqogCdACoWFIgd -ioLoghAlAHmAAIkeiZhklULAINEPhB2NGIoeJEAHmBPqoh4m6MEAAPwgBhXhRAEAlBLzQCLfUAMV -AI4YiB6P4CqCGfkDCBWgCwUA7RYELeAEgAAKPDj4YgANt/8BAK/uLhYV/WAruKIAnQAoEhSIgZQS -lBeVERmrxxuq2ZgZ6BIOKlcCgACrqpoc+iKoFaAMBQAsFhcpFhHogholWQEAAOsWBiVQ4QAA+iJm -FaAA2gAAAAAA//xMDaADBQCKHIweiR8npp0owhoJiAzoxhokI5mAAIwZwLGbGqw8nBmNGmTTro4X -wPDvFgosMASAAPXAGtoSAJ0AwJQJiTaIHOiCnizOgoAAKZwnCUkU+QA4a+IAnQCEHCRCneQWCyI2 -yYAALxIRKhIV+iJIFeAJRQAJaTaOrZkf+0GIFaAFBQDi6wgNggqAAOu8/yzPgoAA+CLGFeG7nQD7 -IQAM96oBAG2ZaCsSFIuyJhIUJBIX5LH1YqgFAACGYCwSFSkSFO2rAhMPKYAAi88GJwwOdzYNuwH7 -geYV4AgFAJiSKRITKxIVJhIV6QYAD8AEgAAIAIqIbo69hm+oRAfuDKYmlr/iawZ3+CEAALFElL6e -vS8SFttQ/qAFlGIAnQAsEgb5X+AVoA0FAOgWECQE+YAAJRIS/iIoFeCNAQAMhgqOYCkSFg+/C+Lu -CAqCCoAA7IULB3P9AAD7LwAM8e6dAO6ZNgboBQAA6RYYItAhAADTD22ZM+QSFy0YBIAA4yYAD/AE -gAAOBIqJUodTg2CpRKcn4nsHd/ghAAAkTAGUUpdTAyk2CTkMmWAvEhgpEhD6IsgVoA4FAA/+Oa67 -e6ENKswYCKw5+b/7TWIAnQCFHYgZjRuLHxmqzJnQ/XAAEbWIHQD5oGYVpXMdAJfShVDuqlIRuJ0A -AP+ghhWkdx0A49YFKuYCgAD85gAOMA8FAOzWASXvmYAAKRIUiBuLHo0RHKqfK7IbihgMXAINuwGN -HyqiEemSACwgBIAAbdkNnIabh5qI6YYJJEEBAACMH8CEZMFAbckXDAEwDAAxLMwmLM0BDAExAAIA -DAIwLMwB/CLIFeAJBQD4gWYV4A4FAP6BRhWgBgUA/eWSDeAFBQAVqxWx/wX1C+mqjhKoFwAAJlI7 -JVI6+MAEA3AAOgAAAP5BAAu/+MIAKRIWlk30gYYV4AYFAPnkUg3gBQUAFasFsf8F9Qvpqn4SqBcA -ACZSOyVSOvjABANwABIAKRIWlk/0gcYV4AYFAPnkkg3gBQUAFar5sf8F9QvpqnISqBcAACZSOyVS -OvjABANwABoAAAApEhYmRhH0ggYV4AYFAPnkUg3gBQUAFarrsf8F9QvpqmQSqBcAACZSOyVSOvjA -BANwABIAKRIWJkYTJUYS+eQSDeAOBQAeqt8O/gvpqlkXcBcAAC/iPS7iPPngBAfwABoAwPAuRhTv -RhUiIQEAAOiMBCx4BIAAY/xuHanqjdj3oB5wkgCdAI4cwPQPbzbu4p4v/oKAAC/8Jw9PFP/AHlvi -AJ0AhBwkQp1kQ8AZqd6w2JiY5BYLKmS2AABgA2OKHfogSBXgPAUAW/x97qQABVtBgADoEgAtaASA -AAhAhg0CZQgghg0CYwgAhg0CYcDxL6QAih0sohaJE/3D5h2gDQUA/cCGHejMHQD9w8YdqMwdAP3D -ph2ozB0ALOQcKJITCIsU+8NGHei7HQD7wyYd6LsdACvkGIseKOQbL7Ib7BICJEAFAAAolhP/wmYd -6P8dAP/CRh3o/x0A/8ImHej/HQD/wgYd4D0FAFv8MMAg0Q+KHimiHsC0C5kC+UPGFe/uNgCNHY8e -gt8YqpDo9gsn4IEAAOwmACbw4QAAnviS+f2h5hWgAgUA0Q8Aih1YBxaaFeoWDiUWaYAAiqfbMOqs -ICpgBIAAWCqAjhWaGIzgKKEI7aIAIkgFAADv4gcuZgKAAP0mAAywCwUA+UAmFefdwQD9zoYd4AwV -AOjlCCfQgQAAWCpx+iKGFa/okgArEhWLv8fPDHwDDLsBLBIUihibwCqiEauqKxISqirgsAQFU/0A -AP4hyBWhqp0As60NLRQt5hpZLWwYqmUbqmEXqmLvqi4VYA0AAP1UvgXizB0AB8cBD88BDc0B+4AE -BfAOFQAL6zkN7TkP7zkH5zn5gAQGMAolAP3NAA4wCAUA+QBoHeAeBQDsqTkMUASAAA/qOfjmAAvw -DIUA7mJvLEgEgAANyTn7JgAMsApFAAuoOQmIAgh3AvfAEiPiAJ0AKWJwB3gPCYgKiIAtgQJk0j4q -gQSPgC6BBenc/yVr/QAA6YUCLu8CgADt/QgPdwKAAP+vAA6wAL4ALYEF74EEJugFAAANDU8thQX9 -4AeUYgCdAImAsPoMqhHqnQgO9wKAAA7dDA1gh8DgDu5m7WAHB3MngAApgQXgfxEMzkKAAPnAAET/ -14EA+aYADvAIBQCLHg+OAvoAAh2gDxUA++0ADT+IjQD9BgAMd94BAO62GS7gBIAADfw5DKoC6LYY -LQq2AAApYnD6IcgV6AA9AA6NGB6pVyqyHv9gCBXv3QEADd0PA6oCKrYeLuJ2Cd0KitYO/gyx7g4J -S+qIKASCqYAAitQOD0X5QABHNp4dAPUoABS/7gEA6f8CD3aCgAAP7gKJHisSFC6WG4zR47YCLEaC -gACoyPlgJhWv4nYAAAAAAAD8AAId4AoFAPsApB2v/BoA//8sDa/upQAAjB2LEurEAAXYYQAAWCvm -LRIUjBn9oCYVr9/2AAAAAPmvAA0/344A/+PgDaAEBQDAoFlGYh2o843Y+b/hQJIAnQD/8TANoAQF -AMBAH6juwOoO3jT/4QYVr/DqAAAAAADyIQYV4IjlAIod+CEIFeAMJQD9AAAUMA0lAP0GAAxwDSUA -6JYBLNgEgABYBfKOHvvfvFASAJ0AiOjIjovpwJCZ65iwjOibwZnomemNFI4Yih6N0Z3hW/sawCDR -D8CQ+71AFaAIBQD74gAMMA4FAAn+OHjgNIwY+4AoFeCI1QD7gaYV7/4aAAAA/gACHeANBQD/+QwN -oBhlAP4AAh3gDQUA//jMDaAIJQAAjh6MHfqDABXgDwUA/8MmFeANBQDt5hguUASAAFgroGP26gBs -EDYiFlgoElgogAQjFlflFlYkLGmAAMJQ+QAry5/PBQD3ACuKEgCdACwSVysSWCbCACmwBywWUCsW -WfggAAT3ZgEA5hZRIzGtAAD4KUYV5GYdACYWUvUAYpoSAJ0AKBJZKIAFLQpO/QAprGIAnQApClF5 -gSsrClR7gSUqElkrElDsHAQg6CEAAFv8QvtAfeASAJ0AKhJQKBJZiRGZpyiABcW0+wAPVGIAnQAm -ElkSqWAeqV4TqS7yIeYV4AoFAJoX+iVmFaAHNQCXGvYmhhXgCQUAmRb4JUYV4D31AC0WJPwkxhXv -9PUAJBYbJBYh/iKmFaAIBQD4JcYVoAwVAJwU8iJmFaAbBQD6JQYV4BK1ACIWEPwqCBWsCwUAKxYl -KxYnKxYt/ilIFaAIJQD4ISYVoAQFAJQYlBwkFg4kFhL0IoYVoB3lAC0WFiQWGPQjRhWgCGUAKBYx -JBYwJBYyLhZTJBY29CcGFaP59QApFiwpFjkXqJ4mYQgaqKEqFiAmFjf2IaYV4BulAPojhhXgGRUA -KRYi/4DIFeAH9QAnFjMswgfsFhkvkgKAAPIj5hWo/x0ALxYe9cBSwhIAnQAjElMWqEAMMxEGMwgt -Mp4uCht+0wIkMp36gHIgEgCdABaoNdhA9gAIHaAZtQBtmgIIAmEnElkfqDfmqDQQyEEAAPLgCBWg -CpUA53EHKoIKgAD5UFoFoAU1AOYiAgkeAoAA9GYACfp3AQDlqCkbvwKAAPjmAAuwFoUAbao3l0CT -QZ9ClkOSRIqVi5OMkI2U7pICJMhhAACaR/qBJhXgrZ0A9YYADfDOnQCbRZpG7EYIIiDBAAArElMc -qBPpElkt3wKAAP1gAEWwGrUA+3OmFaBYRQAolAUrElkPAgArsBYsCv98sSMsElYqEln84AAGMA0V -AOqgQSZj+QAADNw5WAXb+0Bo8BIAnQAtEkotFlMPAgD1oEf6EgCdABan+gzTEQYzCCYSUi8ynvfg -aWOiAJ0AJDKd+oBmSBIAnQAWp+4pElLmAAUKQASAAG2ZAggCYSgSVyoSWflRcgXgDgUALhZA+UVE -HeAr5QD7SuYd4AxlAP1Lhh2gDYUALaRkKIAV0w/4zgAMMAc1APjgZcCiAJ0AKhJZHKjH7BZAINgH -AAD7TKAVoAw1AFlBJSkSUigSWSwSUf9QRgWgDwUAL4YcL4U1LoU3/QDkFeBOJQAuhHQep87/DSYd -6t0BAO+EaC7vAoAADt0CnUCKgBuny+tGAiZhMQAA7EYDLVYCgAAKmQKZQS6AQS+BIh2ojw7mCeiA -BSs3AoAApt39r+gV4FYFAHaBDsRudoEJxXb3AGK1YgCdABmohyISURWohPzAAAVybUEA+VEGBaAD -BQDygUQd4L05APiA5hWtzx0A5MwRDd1CgADsuwILbgKAAO2qAg/lAoAABcwC7EYGIRDxAAAiRQsL -qgLrElkvRAKAAAqIAgmIAuhGBCWxIQAA5gMeAiiBAAAFAmH9ZUQVoA0FAPyGBh3gDgUA/oYmHaAP -BQD+hkYd4AUFAPSGhh3gBgUA9oamHaAJBQD4huYd4AoFAPqFxh2gCAUAKEQ2LEQt8oXmHeADBQDy -hmYd6MwdACxELCiwV/qHgBWgDEUA+IdmHaiIHQD4h0YdqIgdAPiHJh2oiB0A6EQ4JdlxAABZQMUo -ElntTEAkQYEAAAggiA0EiggAiA0AiiwSWSzCHCsSUPyKZh2ozB0A/IpGHajMHQD8iiYdqMwdAOxE -UCJRUQAA7BJRJdjBAABZQLIvElErElmvTy6wdC70WC0SUx6nX+wSUi7vAoAArt0s1p0rsBYtCv99 -sQ0qElnqoEEpYASAAFgFGyoSWSgSUCkKRSmkBSiAEsqEHKeBG6hEHahFKhJZC4soW8QdKhJZW8QA -wCDRD8HHfIEIwdl9gQPAINEPF6eBInKJJhJWIyJdJSJpKCJfKSJeKRZc+CjmFadmAQD0wDQxEgCd -ACkSV42XiNopFlTkgSJmyIEAAIvZjrGNk+sWSydz/QAA/yAEBneeAQDs3AgMzwKAAKm56pQABmEB -AAD9IE0SogCdACoWXikSWIqS6ZIQJQGpgAAqElSKqGWveSwSWC4SVI/PEqgT4uYLJ1iBAADr9gAm -aOEAAJ3on+n7geYV4AIFANEPJBJYLhJLJhJUJEAHKRZE5mIeJ3DBAAD+KCYVoUQBACQWQ/LAJI9S -AJ0AKRJLLBJULhZFipAtwhkswhj6ACId4AgFAP1iAAxwBwUA/WIAC7eqAQCqmSkWX/jgNgiiAJ0A -KRJeiZEkFkMpFkwkFkglFkImEl8oElQfp+scpv0vFlvoghoqXwKAAOy7CANRAQAA6hZGIzDhAAAm -Fl36KeYV4AsFAPosJhXgAQYAAAD/+4ANoAsFAAAAACoSTy4SVCkSVS+mnSjiGgmIDOjmGiQlAYAA -LBJMLRJJwLErFk2s3CwWTC4STWTjzi8SSMBg5hZNLCgEgAD14Bu6EgCdACcST8CECFg253KeLEaC -gAAojCcISBT44EJzogCdACQSTyRCneQWTigECoAA+oBAgBIAnQApElsvEl/6K4gVoAhFAAhYNo79 -KBZV/+GIFeAEBQDj6ggNAgqAAOqs/yxHgoAA+CwGFaGqnQD7AQAMN/8BAG2JaSYSXoZiJRJeZGIH -hVAqEl8nEl7rpyQSj+GAAIivBTIMDiI2C4gB+UHmFaAGBQCWci4SYScSXSgSXyUSX+dGAAywBIAA -BgiKhl6FX4qNpu6lNeWGDyIgBQAA41sGdMghAACx7p6OAq4Mno0sEmAESwL8gAVkIgCdACwSRv// -4BWgDQUA7hZaJwTJgAAvEmAqElz4K2gV4I0BAAyFCoZQDIQLCbkLo2bmbP8tAgqAAPvvAA/xZp0A -5v82BugFAADvFmIiUCEAAG35L96gDmCI7hJhLLgEgAAHDIqGQoJDj1Cm7qIykkMPNjYG9gzjKwZ0 -yCEAALHunkKWUCoSYi4SWvYsCBXgCQUACqk5CbsI63EPdnhhAAAI/Dn/v/t9IgCdACkSWCYSVSoS -Ti0STB6m6+6mACtegoAA+ikmFeXdHQD9QGYV5csdAJyiiZDspnEV+J0AAPtAphXk/x0A7KYELMYC -gAD55gAMMA4FAOimASNuuYAAKBJOKhJLKxJUHKa9LRJCK7IbDJwCKRJeDbsBLRJVKqIR6ZIALCAE -gABt2Q2chpuHmojphgkkQQEAACwSVcCUDwIAZMFAbckXDAEwDAAxLMwmLM0BDAExAAIADAIwLMwB -/CwIFeAGBQD2gUYVoAcFAPaBZhXgAgUA/cWSDeAFBQAVpzGx7gXlC+amqhKoFwAAIlI7JVI69kAE -ATAAOgAAAP5hAAk/+GYAJhJgkk30gYYV4AIFAPfEUg2gBQUAFachse4F5QvmppoSqBcAACJSOyVS -OvZABAEwABIAJhJgkk/0gcYV4AIFAPfEkg2gBQUAFacVse4F5Qvmpo4SqBcAACJSOyVSOvZABAEw -ABoAAAAmEmAiRhH0ggYV4AIFAPfEUg2gBQUAFacHse4F5QvmpoASqBcAACJSOyVSOvZABAEwABIA -JhJgIkYTJUYS98QSDaAFBQAVpvsF7gvmpnUXcBcAACXiPS7iPPagBAKwABoAwOAlRhXuRhQiIQEA -AOmcBCzwBIAAY/xJAAASpgaCKPZALTiSAJ0AJhJPwHQHVzbmYp4rvoKAACd8JwdHFPbALSPiAJ0A -JBJPJEKdZEWYGKX5sCaWiOQWTipkFgAAYASGACoSWPooaBXgPAUAW/iX6aQABVgxgADoEkEtaASA -AAhghg0CZwhAhg0CZQgghg0CY8DRLaQAKhJYK6IWJhJE+yPmHeAMBQD9IIYdqLsdAPsjxh3oux0A -+yOmHei7HQArlBwvYhMrElT/I2Yd6I8dAPkjRh2oiB0A+SMmHaiIHQAolBgushvsEkMn+AUAAC9m -E/8iZh2o7h0A/yJGHajuHQD/IiYdqO4dAP8iBh2gPQUAW/hJwCDRDy8SVC7yHsBkBu4C/+PGFa/t -lgASpcKCKPZAJhiSAJ0AIxJTFqW45xJSKZ8CgACmMyYynvbAJhPiAJ0AJDKdZES5GKW2sCaWiPqf -t3CSAJ0AYAOrEqWygij2QCV4kgCdACMSUxalqAwzEaYzJjKewXv2wCWL4gCdACQynWREqBilp7Am -loj6n6ywkgCdAGADzgAqElhYAxnXoOoWVCUk0YAAiqcrElfqrCAqYASAAFgmgyoWSy+hCIhwjaCO -d+iIEQIwBQAA+MYACzALBQD3QCYVoAwVAP7hBB3n3cEA7XR0J1CBAABYJnX6K8YVr+WiAC0SVyoS -WO4SVijYBIAA7dEILuAEgABYEMAtCoj9QCRcYgCdAIIQZCjJhyeGevrhCBXvzAUA7XILI/iBAADs -/AEKdwKAAKvqrN2uZuZ2CibpAQAA+6Ano6IAnQAmElfJZclD2bBtSQUGAIYJAmGK8A8CAA8CAK6q -/UAo9GIAnQCa8Ikg6BJYLM4CgAAJSQKZsSiABfoqBhXgPOUA/QAknCIAnQDEovsAJEwiAJ0Aw839 -ACeNIgCdAPIrJhWvy9oAKxJfLBJHi7/H3w3MAwy7ASwSXioSS5vAKqIRq6orElyqOuCwBAVT/QAA -/iqIFeGqnQCzrg4uFC72GlkpQB6mOBmmNR+mNu2mARVQDQAA+0xkBeKqHQAPrwENrQELqwH5QAQE -8AwVAAnJOQvLOf2NAA7wCCUA/40AD/AGBQDuqgELOASAAPuNAA0wHAUA+w0AC7AKhQDn/wILQASA -AO3IOQs4BIAAC6c5KyJv+OYAC7AIRQAJhjkHZgIG/wL/YBuD4gCdACoicA/5DwqZComQLZECZNNq -KJEEhpAukQXn3P8ka/0AAOeVAi7vAoAA7W0ID3cCgAD/rwAOsAC+AC2RBe6RBCboBQAADQ1PLZUF -/cAHxGIAnQCHkLDoDIgR6H0IDrcCgAAG3QwNgIfA4A7uaO2ABwdzJ4AAJpEF4PcRCzZCgAD3wABD -P9+BAPemAA6wCQUA+iqIFeAIFQD3JgAPcAoFAPsNAA0/mY0A/SYADPfeAQDuthku4ASAAA2MOQyq -Aum2GC0TzgAAJiJw+iqIFagAPQAOnRgepSkooh7/QAgV790BAP26AA7wCxUAC4gCKKYeLuJ2Bt0K -i9YO/gyx7g4KS+uZKAUCiYAAh9QOD0X44ABHdm4dAPTIABM/7gEA5v8CD3aCgAAP7gIsElQoEl4u -xhuK0cCx64YCLM6CgACpqfkAJhXv3QoAwNAtlQX//AwNoA0FAAD//zwNr+6lACwSWCsSQ+rEAAXY -YQAAWCe4LRJeLBJM/aAmFa/Z3gAA/S8ADX/ZegD/3uANoAQFAC4SWY7i+9+u2JIAnQArEkosElnr -vBguUASAAFgnqcAg0Q8sElmMwvufrciSAJ0ALBJZK8BB67wSLlAEgABYJ6DAINEPLBJXLRJZLMAU -/awGHa/M/gAAAAD/y1wNoAQFAC0SWY3S+7+r2JIAnQArEkosElnrvBguUASAAFgnkcAg0Q8mElnF -wvzAph2vzpYAACgSWYiC+x+qWJIAnQArEkosElnrvBguUASAAFgnhcAg0Q8AwKBZQgcSpJmCKPhf -0niSAJ0A/+nUDaAEBQAAwEAYpJPAagYmNPcBBhWv6YoAwKBZQfwSpI2CKPhf2ZiSAJ0A/+1MDaAE -BQDAQBikiMBqBiY09wEGFa/tBgDaQFlB8RKkgoIo+F/aOJIAnQD/7ZANoAQFAMBAGKR9wGoGJjT3 -AQYVr+1KACgSV/gpZhWgieUAKhJY/iloFaAMJQD9IAAUsA0lAP0mAAzwDSUA6eYBL1gEgABYAYEu -ElT736OgEgCdAInoyJ6M6cCgmuuZwI3onNGa6JrpLhJFLxJLKhJUjuGe8Vv2qMAg0Q8qEljrElcq -YASAAFkYPcAg0Q/AcPm9QBXgBgUA+QIAC3APBQAHjzh28DsrEkv7YCgVoInVAPthphWv/boAAAAA -AAAAAPYAAh3gDQUA//RcDaAZZQD2AAId4A0FAP/0HA2gCSUAAAAtElTAwCzWGCwSWPqDABXgDgUA -7tYZLlAEgABYJyhj9D7aIPwqyBXgj0UA77UIKmAEgABZFvfAINEPJhJX69gMAwG5gAAIQxTpPAgr -OASAAOlJNg3QBIAAbZkFB6CGCgJrJxJXA00M6HcIBlEBAABt2QUHwIYKAm0I6QypySmcQPngBhXv -67IAKsxA++AGFa/rhgDaIPwqyBXgjFUA7LUIKmAEgABZFtvAINEPAABsEAgdpQoPAgAo0X/EZeWk -kBEhlQAA8QAM35An5QC4GvqAaB3gDDUAWT1YjBIMjBScEoo2BasBmxMpIAUsMB4rMCJ2mUr3gAq8 -YD1lAP2ACtViAJ0ALiBoLyE1+8AKZWIAnQAsMRCx//+ACf1iAJ0ALCU16yRoKlAEgADoMgkg2DEA -APhDhhWgDDUAWT1AijbzQAgyEgCdABmk5vlAB9zgSyUAKjAf+0AHhWIAnQAsIAX3gActIgCdACUh -CIknKCEHKiAHjZqJmfogAAU6iAEA5NDGbEcCgAAdo99kkLsMqxGtuyyynveAEfJSAJ0AK7KdE6Pc -5KQRFZGBgACMkQwMR5yRLCAH+0gWBaD8EQD18AAXscwBAO+IAg50AoAADlUCBFUCCogCmLCOIPVg -xhWgPwUAn7OTsvVghhXgAwUA82CmFeAFRQDjtgcvdgKAAAXuAu62ASXQgQAACSCGCgJjCQCGCgJh -iCcMyRH9IABE/88FAOWWnSRAgQAAD48B44YCJ/kBAACfgP8AJhXgXiUA7iQFKZAEgADRD8Ag0Q8A -ACwxEPpkUBXv+yYAxbX6QKYd7/t+AI4nj+pk8VaI6ZgUGqP0KSE3+yAKnCIAnQCNNtoQ+oBoHefd -wQD8IKYV4Aw1AFk86ooQCo0UnRCPNo4VBf8BnxErIAX5wAog0gCdAHa5liwwHnfBB/NACZnSAJ0A -e94dKCB0xJJ5iBUqIFd3oRouIGgtMCJ+0RFgAREAAAAALyBX9+AIPWIAnQCOLy0xC4oUrt2dLyig -E2SAsYqm+6AFTSIAnQDE+C8kBfeABTxgS4UAw4b5gAatIgCdACowIikgaPsgBj0iAJ0ALSE1LDEQ -sd39gAW9YgCdAB2kaSwlNR6kZiokaIoRLuF/DawB88AGX5IAnQD9QASeYgCdAB+jty0hNywxCg8C -AH/ZfCwlN3yneXmudn+uc3qucHuubXymBygwH8SSeYBitBv6YSgVoAw1AOomHCpQBIAAWTynwCDR -DwAAAAAAAAB9oz/3n/sNYgCdACwxEPpkUBWv/foAwLD6IIYV7/qeACwxCvxG5B2v+qoAjSLK1sTp -/kCmHaACBQDRDwAAAAAAfNGC93/ytSIAnQDF9f5Aph3gAgUA0Q8rrBjsJAAJUASAAFgmLMTp/kCm -HaACBQDRDwAAGKQxwJEMnDnoqBx+aASAAB+jhC4hNiwxCg8CAH/hICghNw8CAHyJp/wAIh2gCQUA -Dck4ZZ8cY/+WAAAAAAAAAPxGxB2v/5IAbBAEwCDRDwBsEAQqICIpICMeo6X7LwAMsA8VAOSQXWcj -AQAALCAHDAxBBMwJLM0CK8EGCb02DbsMK8UGKiAijCmtqvpBaBXnqgEA6iQiJQIpgAAo4n/ggQQF -S/0AAOCZGg/ACoAA6bsIBEP9AAAIuwKbKgy5DHOTJsAg0Q8qIAVooXKLIsDCDLsC+kBGFe/yRQDR -D4spmyr9YGgdr/9eACsgB/1PAA1xuwEABLkJ6iQiJMgLAAAokQatiCiVBiogIsulKeJ/jCvgkQQF -Q/0AAOCIGg/oCoAA6MwIBuv9AAANzAKcKtog7CQABdh9AABYJdrHJNEPxyTRD4op+kFGFa//lgBs -EAQrIAceouT0YgAVp1UBAPSgBnkRuwEADLkRrpkokp73AAY6UAZFACmSneqUAASGKYAAHKLVE6Lc -HaMPDACHCQJhCQJhCQJhCQJhLCEHJyAHGKMK+IEEFerMAQD2IAAH8HcRAOp3EA5nAoAA58wCD/wC -gAAPmQIImQINzAKcoI0g+UDGFaAHBQCXpZen80BGFeA/BQCfo+mmBC7uAoAABt0C7aYBJUiBAAAE -IIYJAmMEAIYJAmEMvRGu3ebWnSKUdQAAiif6AIId4AwFAPtEABWgDUUAWB/30qDRD9EPAAAAAAD0 -YGgdr/zGAP/88A2gCQUAAIwiyMZoUhXAINEPACu8GOokAAlgBIAAWCWRaVLpjyeNQIj6j/sco5j+ -QAgVoApVAPnvAA+wOwUAWT+vjCeJyorJ+YQAFa/LBQDriAEEyQEAAOnGCiVTAQAA6sYJJEEBAAB4 -qwWNy6ramskZopWZoI8gGKOG6KYCL/4CgAD35gAPsA4lAO+mASVIQQAAbeoFA0CGCQJlwCDRDwAA -bBAEGqK7JaKJhVwkUQL2oKQVoAkFAPqghBXvk5UA51IAIgepgADoTP8lo/0AAOhVAionAoAA5HQI -CzcCgAD2jwAKMADeAAAAJlEFJ1EE5FIAIzAFAAD6/+AV72YBAOZVBS3fAoAA9uAFFCIAnQDrRAgL -RwKAAAhEDAQAhwlpYOQABwNzF4AALCANGKKGK1EFLSAMKIIo5aKDLd5CgACra6uI6yEHLEZCgACo -VS1UDCRQByxUDSggBxyiUCtVB/gCAAQw+7UA60QBDEeCgAAIRAL0oOYdoPvFAAtEASggByNUBZlY -mVmSWvKg6BWhiAEACEQCJFQHDACH8kHIFaADxQBtOgICAmHSUNEPAClVBf/9bA2gBgUAwCDRDwBs -EAT1RK4F4qcFAAcnKKV1JVJ/wW8DZgx2XRQaolIIOBDoSAIJTwKAAKqZmJDRDwAcolAbolADOgqs -fAyqC6uqKaF/9S8ADLALBQALmTUppX/RDwBsEAQbolgDOAr1RKoFoqkFAAkpKBqiQqSUJkJ/6pkI -AeBBAADnQn4uAQqAAPkAAgRwChUA64gIDUgKgAAJdwEHZgImRn8lgn+xVSWGfyRCgAAxBACjGnNI -DhSiQAwiEaQigiACMgHRDymNAiuRAiWRASmRBQtVAXlbA8Ag0Q/SoNEPAABsEAr2QggVp4UBAPUA -KuESAJ0AiDeKitUw44IJJRpZgACLIsi5jFhkw0XAINEPAAAoIhgtYHMnIAf5Q+wF4AolAPugBAcw -+EEA/iDGFeF3AQDuFgcm+DiAAHaHBogWCogCmBYMeBGpiCmCnvcgLaVSAJ0AJIKdG6IQ+iDIFaAJ -xQDooeASLPGAAOgABQpABIAAbZoCCAJhC6oKKqKoiRfrIgklUMEAAOoWCCSbqYAAKSIXKDIRCYg2 -qoycGIoqC6oMixiYGftAFnviAJ0AKiAW/UQEBaD99QD9ToYN4A4VAC8gB/1D/AXiqQUACfkdK6wQ -7Z0IDYEKgADu0n4vWAqAAAvuASvSfw67Ah6h4yvWfwqrCq6eDrsLHqHyrrsusn+x7i62fy3SgPtA -BADQChUA6xYELVAKgAD7oCXAoA4VAAz7Eay7K7IA0w8LqgFkpMHtTCAh0MEAAPqIaB2gDgUADQJl -CiCGDQJjCgCGDQJhwJEpRCAvIhYvRD/+hIYdqP8dAP6Hxh3o/x0A/oemHej/HQAvRDwrYhMfoaP6 -h2Yd6NsdAPyHRh3o3R0A/IcmHejdHQAtRDgqYhMpUhsrVhzrocIVUAUAAPrCZhWv6IEA+iDoFaho -HQD4hmYd6JkdAPiGRh3omR0A+IYmHeiZHQDpRDAlDdmAAI1Xjd4oRCcmRCYuRCUuMhkqTFDqFgUi -UYEAAOTiEmGxwQAAkhr/AQAPMAIFACLWLCLWIO5GFSHJoQAA6aYAAhFhAAACFIopMhkOiAyCGg6Z -DOk2GSSSuYAAKjIbKDIaqup+qwGxiCo2Gyg2GsCgLiEHiRcYoWsODkrpvzkPdwKAAAjuAhihlJ5A -jiD+gEYV4E0FAJ1DCOgCmET7QACEMG0FAA2ICuiMDy92AoAA/UMOBeSIHQAOjgKeQQ19Ch6hhy3S -oQ7dAY4WCu4RDt0CHqJO7t0CBVAFAADtRgckgHGAAB+he4kVD68Cn5CPGCkiFY4pr5mv7p4pKSYV -HaFIDHsRrbsotp34QtAVr5qFAPqgph2irgUA+kDwFaD59QD5BYYN4B31ABuhWg6uHavrK7J/CN0M -/WAYKmIAnQCPGAypEeyZCAxaAoAAC/8Cn5OIWPqhKBXgCgUA/Q1wDeACBQCaW5iwjFibwZpYmlnR -DwAAAP/y1A2gAwUAjy8YoiToVgsi6IEAAO32ACFw4QAAnlifWfxB5hXgAgUA0Q8AAAAAAOsSCClQ -BIAAW/336BIJJWkxgABj/HbAoIkXZZ6vjRcaoUIpIQcNvzkdoRb/QoQFqpkBAOp6CgzPAoAADZkC -mUCNIP6ARhXgSAUAmEP/pgAPMAhVAO5GBC7uAoAACN0CHqE2nUEqoqGNFu6qAQ7ugoAADaoCHaH9 -DaoC+oDmFa/7MgAAAAAAAAD/8mANoAgFAC7SIJ4TA+4KLuIcZOBsgxOSGg6ONgY5C+5GFSTIIQAA -6cYAAhFhAAACGIop0iAGmQqCkA4iDJKQI9IgBjkKiZAOiAziEgokgOGAAAY4C4ODioKj4347AbGq -k4P7AEYVr/dyAGQxWSnSLMDg7tYgJMgFAADp1iwjMGEAAMCQ6RYCJAl5gAAj0iCaEYkRihIGPgqO -4PIhRhWgOgEACTIKDo42niAi0iCTEAYiC+k5CwEQIQAA4mYABMghAAAJDIoj0iAGMwqCMA4iDJIw -I9IgBjkKiZDuiAwFUAUAAOISCiSA4YAABjgLhoODgqbmfmsBsTOWg/MARhXv+kYAyzMp0iz2wwAV -oA4FAO7WICTIBQAA+aWGFeADBQCJEY4Q6hYCJNBhAAAOqTnpFgEsev4AAGAAfcAxI9Yg//90DaAD -FQAAAAAA2iBb/iflpAAFB2GAAIqnAzsC6qwgKmAEgABYIZGIUOqiAC0YBIAA6aGdHF4CgAALSwL6 -YCYV56rBACpUdCmSfwmIDLGICAtLyrkIaRT1KAAUtYgBAAmIAihWGyoxCPqhBB2v6VIAAAAAAAAA -APogSBWv91IA//98Da/opQDA4f+kBhWv+tYAAAApvQIqkQIvkQEpkQXTD+r/AQ9QBIAA+f/Z+uIA -nQArfBLqJAAJYASAAFgjbGP6ASt8GOokAAlgBIAAWCNoY/nwHaCZHKCZCIsKre0Nuwusu4wYKrF/ -/U8ADTAMBQAMqjX7b+Qdr/O2AAAAAADqJAAKYASAAO6hThnYBIAA/mAmFaANJQBb/YDAINEPAGwQ -DiggBBegZw8CAPkAGCOQHHUA9wAX4hIAnQCJMCogB5Md+iAABTeZAQDpFg4kya0AAPohhhWkmR0A -KRYP9QA08hBO5QAoIAX/ABekIE91AP8ATFxiAJ0AKyAWJgr/drEd+kgwFafFAQD9n8AVoAgVAAyM -OVv+IftATOASAJ0AjRzV0PWgLyoSAJ0AGaBC7xIPLscCgAAJiAgugp7/wEz74gCdACSCnfqASqAS -AJ0AGqA1iR/toQUaQASAAPoACB2gBoUAbZkCCAJhwICYEfxFRB3gLuUA/krmHaAPZQAvJFwmJGQs -MBX8zgAOMAs1AP1gSeiiAJ0AKixl6aERENgRAAD4ICYV4Aw1AFk5cIodjR4uIQf/QNwF4AkFACkk -aCkkaSklNS8lN/9ANgXgSCUA+EOGFeruAQDoJHQvdwKAAA/uAp5AjCDrEg8m6TEAAJ1D50YCLmYC -gAAMuwKbQSqgE2SlSi0gQS4hIhqg2g3bCeggBS3fAoAAq6r7T+gVoFsFAHuBDsTOfIEJxfb/AEW9 -YgCdABeg0Ryg0CMSDvrAAAQy+kEA90GcBaALBQD6gUQd4Jo5AOZGByzNQoAA/eAAF72uHQDviAIN -VQKAAOqZAgGY8QAAI0UL6YgCD1UCgAAMqgLqRgYutAKAAAhmAgdmAuZGBCF5IQAA7wMeAnCBAAAO -AmH2RUQV4A0FAPyGhh3gDAUALEQw+oXmHeAKBQD6hcYdoAkFAClENylENviGph3gCAUAKEQzKEQy -J0Qt+IYmHah3HQAnRCwmIFfqTDwhWXEAAPaHZh2oZh0A9odGHahmHQD2hyYdqGYdAPaHBh2gDEUA -WTkVKCxg6CYAAlEBAAAKBIoIAIgKAIosIhyLHfyKZh2ozB0A/IpGHajMHQD8iiYdqMwdAOxEUCJR -UQAA7BIOJdjBAABZOQSJHiggdKlJKJRYFp+z7hIPKv8CgACm/y72nSsgFi0K/32xCuogQSngBIAA -W/1wiB3ElikkBSiAEmSASRugmxyf1h2gmuuLKAlQBIAAW7xy2iBbvFXAINEPfIkp/kIIFafVAQDu -FgspqASAAPWgI4ESAJ0AiDePimTzcYOJiCLIh4lYZJN7wCDRD4obKCIYKqBzCIxA/CEGFaAJJQAJ -qwHrFgkleDiAAHaHBosYCbsCmxgtIAcZn4kNDUEM2BGpiCyCnp0XnRb3gDetUgCdACSCnWRG6h6f -fdhA/gAIHaAJxQBtmgIIAmEZn6WIGAmICiiCqI8ZKIww6BYKJ6aJgAApIhcoMhGKGgmINqqKKhYK -KyIJiioLqgyLGigWENMP+0AhU+IAnQApIBb9PzgFoP31AH2RZyogBx+fif8/MgWirQUADa0dCZsK -rt6v3Q27Cx2flebifiT4QQAA++AEANAPFQDtuwgP6AqAAA1mAS3ifwbdAi3mfyayf7FmJrZ/LuKA -AJEEAPka+cAwWOIAnQAMrhGs7o7gDpkBZJYQ6kwgIcjBAAAJYIYKAmcJQIYKAmUJIIYKAmPAYSZE -IC8iFoob/ofmHeAOBQD+hIYdqP8dAP6Hxh3o/x0A/oemHej/HQAvRDwrohP6h2Yd6NsdAPyHRh3o -3R0A/IcmHejdHQAtRDgdn2QpohMmUhsrVhzroC0UyAUAACmmE4oZ9oZmHahmHQD2hkYdqGYdAPaG -Jh2oZh0A5kQwJRlhgACNV/2hyBXo6B0ALkQm+ITmHa+ogQAqRCXqMhkieUEAAO8WBSJxgQAAnhTk -o2xh8cEAAPsBAA0wCQUAKdYgKdYs6kYVIfmhAADvRgACSWEAAAkIii8yGQqIDAr/DO82GSedkYAA -KTIbHZ88KDIaqal6mwGxiCk2Gyg2GsCQLiEHH58IDg5K6J80H3cCgAAP7gKeQI8g/z5eBaBKBQCa -Qwj4AphE+SAAhHBqBQAKiArojA8v/gKAAPohKBWkiB0AD48Cn0EK5zkfnyGOF5dCD+4KLuKhjxjt -7gEP/oKAAA/uAuvuAgTIBQAA7kYHJQBxgAAfnxeKFQ+fAp+gjRouIhWLKa3urbubKS4mFYoWG57k -DKoRq6oopp0oIBYp+pj4oKYd4Pb1AHaBMSkgB/898gXiqgUACpodr68v8n/BbwhmDPfgJAIiAJ0A -ixoMnRHs3QgMcgKAAA67ApvTiFhkjOuPWcDgnluY8IJYnyGeWP6hJhWgAgUA0Q8ans+KqPdAILiS -AJ0AGZ7G7BIPKscCgACpiCuCnv1gINOiAJ0AJIKdZEQRHJ7FsKubyGVKDWADWgAAAP/yMA2gAwUA -jh0t4hP9wMYV7+qyAIkvGp+x6lYLIviBAADvlgAhQOEAAJhYmVn+QeYV4AIFANEP2iDrFAAJ4ASA -AO0xCCrwBIAAWAnpLQqI/UAfPGIAnQCMEGTMO4bHDEgRmBOPav7BaBWvyQUA62III2iBAAAJ2QGZ -EquKqe6o/+9mCidxAQAA+8AgG6IAnQDJO8lJ6bQACcAEgABtSQUIAIYJAmGPE4rQDwIAD6oI/0Ah -ZCIAnQCa0IrACKoRCkoCmrEoIAX6IaYV4DblAPcAHOwiAJ0AxNL9ABycYgCdAMPt/wAgNSIAnQDz -gGgdr+MKANogW/v75aQABRqhgACKpwM7AuqsICpgBIAAWB9liFDqogAtGASAAOmfcRxeAoAAC0sC -+mAmFeeqwQAqVHQpkn8JiAyxiAgLS2Sx2QhpFPUoABS1iAEACYgCKFYbKjEI+qEEHa/s6gAAAAAA -AADrEgopUASAAFv7O+gSECVeWYAAY/sdwJCOGWXtTBmeho8XCf8KGZ6GKCEHDpc5GZ5YCAhK6p6E -HEcCgAAJiAKYQPhACBXgTgUAnkOXQvsmAA0wCFUA6kYELM4CgAAImQKZQS/yoYkY7f8BDM6CgAAJ -/wIL/wL+gOYV7/W+AAAAAP/s/A2gCAUAKdIgA5oKKqIcZKBrDp8LCoo26kYVJ/ghAADvZgACSWEA -AAkMii/SIA7/ConwCpkMmfAp0iAOnwqP8OqIDAeA+YAADpgLjoMdnl6Jgq6ueusBsZmeg/kARhXv -8h4AZJDfL9IswJAPAgDp1iAn+AUAAO/WLCdwYQAA8QvADeAJBQAj0iAOOgqDFIqgCQZAA28KCoo2 -mvAv0iAO/wvjYwsH+CEAAO+GAAGYIQAAAxCKL9IgDv8Kg/AKMwyT8CPSIA4/Co/wsZnqiAwHgSmA -AA44C4ODHZ47joKjo3o7B+2eORdwBQAAk4P/AEYVr/qaAMo8KtIs/8MAFaAPBQDv1iAlUAUAAPul -hhWgAwUAihQvrBgG+jnqFgQse2YAAGAAGcAxI9Yg//+QDaADFQAAAAAAAP/4wA2v6KUA/TxEBe/5 -UgDAkfmkBhXv/MoAAAAAAAAA6iQACmAEgADuMgsq6ASAAO8yBynYBIAAWADfwCDRDwCKImWpO4sc -2iDrvBgpYASAAFggz8Ag0Q+MImXJIysgQdog67wSKWAEgABYIMnAINEPLDAU/EwGHa/bAgAAAAAA -/9mQDaAEBQDF8v5Aph3v3R4AKr0CKaECJqEBKqEFCWYB+t/PgqAJFQCLF9og67wSKWAEgABYILZj -+MCLF9og67wYKWAEgABYILJj+K7AoFk7NRqdxoqo+V/e+JIAnQD/7/ANoAQFAADAQBydwMC6C6s0 -+4EGFe/vpgAfndcendcIjQqvrw/dC67djhos0X//jwAOMA4FAA7MNf2v5B2v7coAANog6zQACmAE -gABZEY/AINEPAAAAAOokAAnYBIAA6J6IGmAEgAD4YCYVoA0lAFv6usAg0Q8A3VD7gGgdoIlFAOm1 -CCpgBIAAWRBewCDRDwAAAAAAAADr7gwBgbmAAA5GFO9sCCnABIAA7082DdAEgADTD235BQiAhgoC -aYoSrjjmSQwFUQEAAG2ZBQighgoCa4gTjxIOiAyo/y/8QP+gBhXv734AAIkSKZxA+aAGFe/vRgAq -CoXqtQgq6ASAAOrEAApgBIAAWRA+wCDRDwBsEAQpIAeIIi0hB/067AWhmQEA65QADASOAAAMmBGs -iCqCnvVABNuiAJ0AKIKdGp1u751wFARpgACOMikgBw0NSvgCAAT37sEA4O4RDMqCgADumQIO7wKA -AA2ZAgqZApmAjSCwSu+GAi13AoAA7oYDLu4CgAD8hgAO95UBAO2GASyVSAAA+QIAFeACBQDoPBAi -DDUAAG2pBQgAhgkCYQy+EazuJOad0Q/qJAAJ2ASAAOxEAAroBIAAWB/j0qDRDwAAACucGOokAAlg -BIAAWCA0Y//UhyeCefrhaBWvxgUA5XIKI+iBAAAG1gHmowgKTwKAAOlVDAEQQQAAknnldgohmQEA -APJABULiAJ0AaJs4opoqrPDqMz10OEEAAOhBHWvABIAAsE5t6QUCAIYIAmEq0gEKmgjl0gIlU8EA -AHOheurWAS0QBIAAZFBMDL0RrN0k1p3RDwI6DApPFNMPbfkFAiCGBwJjD0IM6o4IA0EBAADv7BAh -DEUAALAu0w9t6QUIQIYPAmWP0gqSDKJiIiww4tYBL/2+AADAIOLWAiNBAQAAmNCY0Qy9EazdJNad -0Q8KIgzy4SYVr/1WACJsQPOgJhWv/hoAAABsEBYiFiDnEiAr6ASAAChwB95g/CBmFeBKdQD+4LAV -4YgBAOgWDSRAYQAA+CEmFaBMZQDs8Qx5kASAAPvgOD0iAJ0AJHEijH6VFiMgFYkTJiITKHBBiyAd -ncEIiAn4wQALd7sBAOsrCAxHAoAA+aAARr//BQDt0n8l2P0AAA+7AYqxmxrtFgwl2EEAAPvAMyqh -MyEA/AACHeAFBQAN7wwdnTQt0n8JzBGs3CzBNfQgphWn/fUAfNsKFJ0D8iCGFeAASgAkSgAExDby -IIYV70QBABydqCzCf+8CAA4YBIAA+8AEwqIAnQCNGg+qDIjTnBKN0qj4mBd/iwGx3ZIb7RIHLuAE -gAD2wCy4kA8FAJIb90AsaJIAnQDAIG0IWwpoNAMpCghINJiQAygLnYOcgomQDwIADwIACWYMCaoM -rZjoFg4hEAUAAOmLBn5oBIAAsc3s1AAH+AUAAO0SDiEMMQAA8mMAFeACBQD2wCkgkgCdAPdAKOCS -AJ0AY/+dnBKSGwtdCwtaCoqgidON0g+qDKn5mRh/mwfiFgsm6AUAANzQ/CEIFeAPBQD+I6YV4AIF -APbABQCSAJ0A/iPGFaAAzgAAACgSHejoCAKoBQAA6BYdIowxAAD7YwAV4AUFAAtcCwtaCoqgjcPs -wgIjDZuAAP9c8A3gDgUAamHHbQhOAykLAy8KCmg0CEg0CGYMCKoMmPCcki2WA+2PCAEQBQAA6PsH -fmgEgAAtzAHs1AAHcAUAAOghDG/oBIAA8mMAFeACBQBkr3323/vQkgCdAGP/qgAALhIegxL2IWgV -oAgFAJgQiBMmYhMrcBYuFhr4wQALMPn1AHmxGowW+ugwFafMAQD9n8AVoAkVAAycOVv6PmSkty0S -HemcYhadaYAAFJ0xghWKHIwd7pxaE/khAAAvFhPuFg8j6XEAAC0WFCwWEPpIAAW2igEA/4AAFj1S -HQDpzAgJFQKAAOQiAgqtAoAA8iLGFaCqOQDsFhIt3gKAAOuIAgPhgQAA7BYVLVVCgAD6pgAKsAsF -ACsWG4oU+KYACrA0VQD0IwYV4AgVAPtaQBWgBQUA+wIACrAyZQD0jQAJcAUFAPIi5hWgBAUA8ABA -DaACBQAALhId/qAYXCIAnQDA9Q9fL+TyXmKoBQAAKAqAqEQrcQccnC/yQAEG+rsBAOqcWB3fAoAA -DLsCm0CIcPqARhWgSUUAmUP9AAAUMAmFAAmIAphBj9AuCgT46DAVof8BAA/uDC8SGO0WGSxEAoAA -CP8CGJzs+iJoFaHuAQAuFhwI/wIvRgQvEhb9oAgV4AgFAChFCi9GBg7dCO6c4xbo8QAALUULLkYH -6gMeAkiBAAAJAmH+5UQVoAoFACpENP6Fph2gDAUA/IbmHaAJBQApRDP4heYdoAsFAPqGph3gDwUA -L0Qu+iKIFeAPBQD+hgYd4AgFAPiGJh2gCQUA+IZGHeAMBQAsRDb8I2gVqO4dAC5ELPjq8BXv3QEA -DNwI7BYbIlDxAAD4h2Yd6JkdAPiHRh3omR0A+IcmHeiZHQD4hwYd4AxFAFk1M+kSFSJRAQAACSCI -CgSKCQCICgCKLXIcLBId/IpmHejdHQD8ikYd6N0dAPyKJh3o3R0ALURQfFkz/iOIFaBPJQAvdHQf -nNIqTEX6IGgd4e4BAP/GAA9wD5UA73RlL3YCgAD+IAYVoAw1AFk1GCsSGihxNQMsCx+cn+kSFyRA -BQAAKHU1KBIZKXRXL0YWjoAuRheNwy1GGYzCLEYYioCJf6urK3YciIAKZgwrFhrpiAgBEAUAAOh2 -DyEMMQAA8mMAFeACBQAbm7j8I4gVoApVAApaLytGGuTMCAZoIQAALUYbK3B068R0LW6mAAAuEh0F -7gyx7vff7iFSAJ0AKRISKBIRKJadK3AWLwr/f7EIKnBBLBIbW/lljRssEhqc25bXinLEt+t0BSUH -yYAA0Q8uEh0vEhAF7gz/wCAVoApVAAruNg3uEe4WESelDQAALxISL/Ke/+AG06IAnQAkEhIkQp1k -T7KIH/yAaB3gCgUA6AAFB2s5gABtCA/tDAAFUAUAAP9f6qQiAJ0AY//pGpuIiqj3QAUgkgCdACsS -Eiuynv9gBcuiAJ0AJBISJEKdZECtGZt/sKj5IQYVr/6iAIsdwKDqFhst3wKAAKm7KxYSLhISLRIR -LeadK3AWLAr/fLEIKnBBLBIbW/kwjxsv8BPI/4gbiX+IhnmJB8SYKXQF0Q8AxKYqdAXRDwCNsy8W -HYyy+2AIFa/sUgAA//+wDaACBQDacOsSCSvgBIAAWB5J0Q8A//ywDaAEBQD+I+YVoAoFAFk4yBqb -WoqoLhIf+V/6SJIAnQD//CQNoAQFAMBAHJtTwLoLqzT7gQYV7/veAI8aL/IECv8I7+NXfWgEgAAl -CgD+ICYV4A8FAO0SASf4EQAA6PQPYqgFAAArvBj+AAId4AUFAKv4iICtiJgReOvZ/d/LEuIAnQD/ -rwAPv+V2ANEPKXBBKZwS+CEmFe/5MgAAAP//aA2gBQUAbBAIlBEqIgcmMQv4QPAV4EyFAP1BSBXg -R2UA+ECwFaBLVQD22IAVoZkBAOWiCSaLyYAA/QAQjSIAnQAoUBLIi+kWBSlQBIAAW7fMiRWEUJUS -9CBmFedEwQD0gBXbH8sFAIgTiIoqMF/3ABcjogCdAOWUAAUKOYAAJ2w3B0cUtHf1IAo6EgCdABqb -DQyYEaqIKoKe90AeS+IAnQAogp0VnAaYEOgWBCQViYAAHZsADQCHbXkCCAJh9IAcSxIAnQAuMF8c -mwIZmzXrMF4vDT4AAMPz/oAK1GIAnQD0gArTEgCdAIgSKIATZIFVhBKNL4RG/IAbpWIAnQBlsXfA -8I0TiNEuIQf94AAVN4gBAAqIApjRKCAHKyEI/0AABzCoEQDs7hENUoKAAAruAvnGAA9xiAEA6hIE -LEwCgAAJuQIbmxieoI4gnKKbpguZAvlAhhXgCwUAm6Wbp/3AABcwC0UA6+4CBWCBAAD/QCYVoDsF -AOumAy7IBIAACSCGDAJjCQCGDAJhG5rO6RIDLFcCgACrqiemnYmQ+PgABPA6JQB6kVraIFgUcdEP -AP0ABaUgBQUAwMAswBJlzodj/pEtMF5l3rb/+uwNoAdFAAAAGprCjKj3gBYgkgCdAB2auQxYEa2I -LoKe98AWm+IAnQAogp1kgsqwzv9BBhWv+p4AJiEUIyES/tmwDeAEBQDqUkIp2ASAAPwAAh2gDRUA -WBeZKFJD5EwBIZgFAAAIMy52Sdtj/29kvsdgADwAAGS+v2AANAAAZL63YAAsAAD3H+98YgCdAPsf -7zxiAJ0AY/9JAAAAAAD3H/pkYgCdAPsf+iRiAJ0AY/8xLCAHihAemsn6QQQV4NwRAPWwABaxzAEA -7t0CDmQCgAAMuwKdoB2ajfxACBWgDwUA76YFI3BhAACeo+4SAyMg3QAA/UBGFeREHQDtmsAeZgKA -AAxMApyhDbsCm6QOBImWp52mCiCLLCAM5qYHLmQCgAAMuwLrpgQrYASAAOs8VCVQoQAAWTO/jhAZ -mqjsmnMaRwKAAPnAAEcwj5UA/iCGFa/3qgAAiieHEeyiCyu/AoAA5zcIBVCBAAALqgGqyuqsQCvA -BIAA+uANmqIAnQD4IGYVr/RyAAAAAAAAAAD3AGgdr/RyAI0iZNF89J/yIxIAnQCIJ46KJ1K95OFg -ZFCBAACFiYVRJvrA9OAAAvALBQDsdAAK6ASAAFgXk44njRGM6oro6OILJ1iBAADmtAEO7wKAAK2p -pIitzJzq6IxALeAEgAD5AAwz4gCdAMk+jhHvpAAHANGAAG3pBQNAhg8CZYwnKbIA7ZkIBmCBAAD5 -IA2kIgCdAJmwiyCJEQbCAebCAC3eAoAAC5kCmaGIw+vCAirPAoAAppqiiKm768YCJEEBAAD7AAbz -ogCdAMl203DvZAACgJGAAG1ZBQNghg8CZ4rACpoI+UAKpCIAnQCawNEPiieNEcDA6qwgLtgEgABY -F2GaEvogZhWv8ZIAAP/w6A2gCAUAdNsUjxINTgzu9gYt7/4AAP4RYh3v8gYAihIE2AzopgYt71YA -AP4Rgh3v8bIAAAAA+CCmFeAKBQBZN3oamgyMqIkV+Z/pUJIAnQD/76ANoAgFAMCAwNoNzTT9QQYV -7+9mAAAAAAAAAAD/+ogNoAUFAAAAK5wY6iQACWAEgABYHORj/nEAAAAAAPzvAAw/+TYA5ooMA4Gx -gAAKSxTuvAgreASAAO5eNgvABIAA0w9t6QUIgIYPAmkKeAjrXQwBeQEAAG3ZBQighg8CawqeDK4u -LuxAnsDRDwAA6okMAYHhgACOEQlMFO/MCCnABIAA7+42DXgEgABt6QUIwIYPAm2OEak47O4MAnkB -AABt6QUI4IYPAm+MJyzMIAneDK5OLuxA/2AGFa/5egAvLECfwNEPAChMQPlgBhWv+S4AAGwQCBma -uysxCicwRPxgiBXgLiUA7zBFKWAEgADygGgdoAoFAPU1agWj3YEA4PYRB+AegAB6/3GMMo8z8YAW -61IAnQDxgBarEgCdABuZ2iuyHSiSaa+76hYALd5CgACriJgRZHMWHJpmDGwBdMk1KjA8aKEy9UAR -4ZIAnQBopVz1QBJLkgCdAH6hHMLTfakX6hIBKdgEgADsJAAK6ASAAFkD7tEPeWYc0Q8YmeovMSf5 -4Aa0IgCdAPogBhWv/p4AAAAAAADqEgEp2ASAAOwkAAroBIAAWARB0Q8AAACNESnQBcSmepnAideL -mmSx9iuSCS/QaBmaVyyyAeqwFSf4BQAA/60GHeAOFQD/q4YdoAiFACjUZyjUZPmlRB3gCAUAKNRm -+aymHaAp1QD+adAVoaohAO8wTyVTSQAA+aakHaAo5QDqmDgPdgKAAA/uAvmq5h2gTxUAL9R0LtU3 -LrAV/s4ADzAKNQD/QUAdp8wBACmwFCnUYO4yFS7QBIAA7zIWKugEgABb/F3RDy8wPA8CAA8CAGj2 -Y37xYJoQjRHu0TchyPEAAOkDHgbBcQAACAJh7zEmINAhAAD/psQd4Aw1AO7VNybZdQAAWTKiixHA -w+q8XSXZhQAAWTKeihErHAgPAgD7TCAVoAw1AFkymf7nXA3gLiUAYAGEAAAvwAT14AezEgCdABqa -RQ3cCQzMEayqKqJ/ZK6RjDb7YAAG+MxBAC+hGQ8PS3/ZDouqyLkosT58gQuLuWW/9IqpZa/i0Q+K -upsU6hYAJQFZgAArPEGbEyqsTPogaBXgDDUAWQcd8UiwDeAuJQCKEIqo6hYALX8WAACLFGS+MB2a -Hi3Rf+wwPCb4MIAA9YAEOxIAnQB+wXSNFC3RCOoSBCDYEQAA7DQACvAEgABYBF2NEWXe72P99wAA -AAAA6hIBKdgEgADsJAAK6ASAAFkDZNEPAAAA6hIBKdgEgADsJAAK6ASAAFv939EPAAAA//ggDaAL -BQCPEP4ghhXv/f4AmhCcEf2AaB3v+noAAAB914f8f+Id7/4mACiwBPUf+7ISAJ0A0Q8ZmfXTD9MP -KZF/DwIA8T/r15IAnQDqFgAh4IEAAOrUAAjoBIAAWQeu7aQADQJOAAAqMDwrCoH7X+qNYgCdAIoQ -ZK1H2zDtFgEpYASAAPygaB3gjkUAWQbk0Q8AAAAAAADqEgEp2ASAAOwkAAroBIAAWQXu0Q/C4vog -JhWv8y4AAGwQBikxDxeZ3iowLO0wLSyj7gAAHJkE65kAHVYCgAANqgJ8oS8dmdcemdj9QATMYgCd -AP9AFUwiAJ0AH5meGJnT/0AXHGIAnQD5QBPcIgCdAMAg0Q+JNCiyI/b9aBWjqYEAqogJiBGoZvMg -FFpSAJ0AKzA39WAWQJIAnQD9eiADUBwVAHy5yS0wQi4wQwjdEf+mAA6wTjUAftm1LjBELzBFCO4R -/8YAD3BPRQB/6aHqJAAJ2ASAAOxEAAroBIAAWOo+wCDRDwAAKTAuKjAvhjTrMDEszgKAAAqZAv0h -gADTZoEA+T/7U1IAnQAqMDAIqhELqgL9X/rNIgCdAC4wNC8wNQjuEQ/uAmjhB/nf+hFSAJ0ALzBG -KjBHGJk96zBIL/4CgAAK/wLqMEkv/gKAAAv/AumZlx/+AoAACv8CCPgB+R/4bGIAnQAYmZMZmMUI -+AH5H/fkYgCdACkwPCowPRyZjuswPizOAoAACpkC6DA/LM4CgADrmQILaASAAO4WACzOAoAA+SYA -DLAKVQD/IGgdoDsFAFk1jhiYoCiCI4o0InLrqGgJiBGoIvNAD9JSAJ0AFZj9LDBJKzBGLjBHJCIH -7TBILd4CgAAOuwLkQg4t3gKAAA27Agi7Eey7AgpQBIAAWOl1ZK5oLEJh9YALaRIAnQAtQmH1oAsR -kgCdAMCl/TLOBaA7BQDtVAALcASAAFk1bxyZYygwRy4wRi8wPCcwPeYwSC92AoAA6O4CD/4CgAAH -/wL2aTAV4ApVAOgwPi92AoAA98YADzA7BQDmMD8v/gKAAOj/Ag92AoAA5+4CD/4CgADm/wIJaASA -AFk1WCkwNCowNQiZEQqZAvUgC4CSAJ0A+T/uSVIAnQArMDwsMD3tMD4t3gKAAAy7AuwwPy3eAoAA -7bsCCVAEgADouxEK6ASAAOy7AgHg2QAAWOj9wCDRDwAAAADqJAAJ2ASAAOxEAAroBIAAWQiOwCDR -DwDqJAAJ2ASAAOxEAAroBIAAWQc0wCDRDwDrMQorUASAAFjp/fwAIh3gDgUA+6IADzAMBQAO3Djq -pjkOar4AAGP9LwAAAAAAAADqJAAJ2ASAAOxEAAroBIAAW/5KwCDRDwCNYC5gOP5oUBXgClUA/TIq -BaA7BQBZNR7AINEPLzA8KTA9KEJK6jA+L/4CgAAJ/wLpMD8v/gKAAAr/Agj/EQn/Avn/880iAJ0A -KEJhaIMEwJMpRmHApf0yCAWgOwUAWTUMwCDRDwAAAP0yAgWgClUA/GFEFeA7BQD+QmgVoA8FAFk1 -AyUxCuokAArYBIAAWOnK/AAiHaANBQD7ggAOsAsFAA3LOOqiOQ3ubgAAY/xhACswPCwwPe0wPi3e -AoAA7LsCCVAEgADsMD8t3gKAAO27AgGw2QAA6LsRCugEgADsuwILYASAAFjooytCYC8wSSUwPygw -SCkwPS0wPC4wRuwwRylQBIAA5zA+Lu4CgADp3QIPdgKAAOzuAg7uAoAA590CD3YCgADo7gIO7gKA -AOXdAg92AoAA/8YAD3AMJQDmFgAreASAAFjoP8Ag0Q8icSgvchUpdSkJIgLidSgn+AUAAP7iphXg -AgUA0Q8AbBAIHZe3GJfr4yAHKdgEgADlIgcq0ASAAOKX5Rk4BIAA+SLkFeDzEQD18AAXsTMBAOL/ -AgnkAoAADJkCCJkCn6CPcP1ARhXgPAUAnKP5QIYV4A4FAPlAxhWgAkUA7qYFL/4CgAAC/wKfofih -SBWvzgUA71ILIuCBAAAOzgGCWe79CARDQQAA6FYKJukBAAD8QAia4gCdAOWsICF4wQAA/6AIc+IA -nQDiCx4KyASAAAkCZQIghgkCYwIAhgkCYYLBIiww/EAJrGIAnQCSwYjCZIBh7XAsInv9AADsogwv -/wKAAO+rCA31AoAADt0CDcwCnKzqUgEl2IEAAJsS/KBIFaAJBQDsFgEtAmIAAOkWAyUFsoAAjFH8 -wAAWt8wBAA3MApxRG5eH6UgICdcCgACrqpig0Q/A8O/GAidpAQAA/YAmFeACBQD9gAYV7/4iAAAA -AAAAAOsSAivQBIAAW6WviFErEgLsEgEtSASAAOoWAy1vAoAA7bsIBAZwgADacFulf49RjhMIaBH/ -QABHN/8BAAj/Ap9RGJdq7k4ICf8CgACo/57w0Q8PIgzyoSYVr/uqAALZDAlIFOgWACroBIAA0w9t -iQUCYIYNAmeIEOmvCAdpAQAA7/wgJBxZAACSFIIQwIMCiAxtiQUNgIYPAmkJ4gwiLHDzgCYVr/tW -ACLsQPOAJhWv+yoAAGwQBiQwBxmXjBWXL/kwEBXhRAEADEoRparoop4kyN0AAAlJFLiZ+QAF0+IA -nQApop3rlAAEhbmAABqXHwoAhwkCYQkCYQkCYQkCYQkCYRiYK/kv9AXgDBUA+kAIFaAOBQD+ICYV -oA0FAPggBhXgDwUA+CBGFaAONQBYF8IoMQcZlxP/MD4F6ogBAOuXExxHAoAACYgCmKD+QAgVoA0V -AP1DJh3gHAUAnKObou/vAg92AoAA/0CGFeAPJQAP7gKeoQxJEfUgAETwCFUA+TOmFaAPdQDvJAQl -EIEAANEPAAAAAAAAAP/9JA2gCQUA0pDRD2wQCBeW+yYgB9MPjHgUlvL3gAsAkWYBAClCrmSRfytC -rWSxe7DMnHgel0jfsPF14A3gBRUAK+CAK7w3C0sU67wWK1AEgAD0wAeCEgCdAAxqEaSqLKKe+4AN -U+IAnQArop3xdMAN4AoFAIknKiRUjJqHmWTA9oxxKSAUDAxHDJkICQlHKSQU9SAKJlIAnQAUl+Ef -lxwtcRclcgn44QgVoAYFACbmMijmM/SgABM4VR0AJeY4JuY5/6YADvAmBQD9x+YV792NAO3mPiIp -4QAALkJ/ijApQoEoQoLvQoMrAgqAAPyQiBWgmZ0A+CAmFeANBQD8IAYVoP+dAPggRhWgDBUAWBdk -JEwY5UnDfVgEgACOdPpAaB2gHwUA/8YAD3AcNQDudgQt6ASAAPpgCBXgDgUAW/710qDRDwAAlhX3 -gAZgkgCdAAyqEaSqKKKe+wAHI+IAnQArop3ksNtma/0AAPzhBhXv+/oAAAAAAAD3QGgd7/wWAMCg -WTQMjHj5n/TIkgCdAP/6hA2gCwUAAAAAAI4iZOCy9EqGHeACBQDRD8CwwPoPzDT84QYVr/n+AAAA -AACIImWP3StsGOokAAlgBIAAWBl09EqGHeACBQDRDywhCfxCsBXv9gUABpYBBpgMKCQU5vQDLukC -gADq9AAuZgKAAA3MAgXMApzx9JWmFe/6QgAAAP/5ZA2gCwUAmxT+IMYV4AoFAFkz5B6Wy48WjHiL -FIoV+Z/44JIAnQD/+MQNoAsFAMCwwIoIyDT44QYVr/iKAAAAAADaIPxAaB2gG8UAWBlQ9EqGHeAC -BQDRDwAAbBAIiScdlmIlIAcokgr7LLQFoAYFAP2hCBWhVQEA5JIJJBERgAAuQgEnQQr2QoYVoAml -APeAEiCX7gEAL6KuZPJvI6KtZDJrsMyc2O80AAGSiYAAGZalI5CAIzw3/qAAFbQzHQDquwgBmJ0A -APSgDtoSAJ0AKLKe8wAWQ+IAnQAjsp1kMjgpIBQOmQgJCUcpJBT1IBJGUgCdACoKAlkI8WWieJUV -9CCGFaAKBQBZCMgUl0Eclnwbl0EVlo2OFBaXPiVSx/nC5BWgBwUAJ2ZRjeknst0rscyO6C5mUuyI -Ag7yAoAA/ssGFajdHQAtZlcoZl6rqvrgAEO/iI0A6GZdK75CgACnVSUmFPKhBhWgJwUALkJ/ilAp -QoH4kEgVoAwVAO9CgyuCCoAA+pCIFeCZnQD4ICYV4A0FAPogBhXg/50A6BYCKdgEgABYFrokTBjm -Sb59GASAAIQVLCEHixQdlgfzLBIF6swBAOixCi5nAoAADcwCnKD+oAgVoA0FAJ2rnar9QMYV7//1 -AJ+pn6ifp/8suAXgCUUA46YCLzYCgADpZgIPd4KAAA/uAh+XBZahnqQPTwL/QKYV4C+FAJ+jibeL -ti+mEy2mFi2mFy2mGC2mGS2mGi2mGy2mHC2mHS6mFCymECOmEvdCJhWggwUAo6PmlvQd5gKAAP0G -AAw3u8EAC5kCmayYrfaGAAowDgUA9UKmFaAsRQCPFMCQKSRVjfT6QGgdoBgFAPmmAA6wCwUA7fYE -KegEgABb/hvSoNEPAAAAAP/3eA2gBAUA94AH4JIAnQAMWxGquyiynvMACKviAJ0AI7Kd5DEMZkP9 -AAD5oQYVr/hCAAAAAAAA7hYHK1AEgABZMzAdlcKM2I4XGpW6+Z/tOJAJpQD/9rwNoAMFAIkiZJDd -wKH6SqYdoAIFANEPwDAJzDT9oQYVr/ZGAIsiZb/hK1wY6iQACWAEgABYGJnAwfxKph2gAgUA0Q8u -IQn4QrAVr/sFAAubAQucDCwkFOv0AyxBAoAA5vQAL3YCgAD5xgAPMA0VAA3uAp7x/VWmFe/2HgAA -AAAAAPoAgh2gK+UA7JapG+gEgABZMqf+EQIdoAxFAPQghhWv+3YAAAAAAAD/9OwNoAMFAJ8W/iDm -FaAKBQBZMvwdlY0alYeM2I4Xjxb5n/dYkgCdAP/0SA2gAwUAwDDAigjINPmhBhWv9A4A2iD8QGgd -oBvFAFgYacCh+kqmHaACBQDRDwAAAGwQBIYwxIL4EIId4DflAPb4AAMwNAUA9MeGDaA6NQD3QS4N -oDx1AMOxe2oK94cODaA9VQB9YjAiIAV3IU74SWYNoD7VAP5D5g2gj1UA/mEEHeACFQDRDyIgBXch -DvhBZg2gJNUAdCEDwCDRDygwMP0eoALT+/UAKjEI+0MGDeACFQApNQjRDwAAAAAA+GEEHeACFQDR -D8Ah0Q8AAGwQBC0wPCYxCycgB/5ByBWgCgUA6yIAI2MRAAD1oAvokXcBAB+WPPmgDGtQOdUALfJp -75VCH0ZCgACo3SjQBQx+Ee/uCAMwTQAA+QAMlWRmHQAp4p73IAy7ogCdAC7inc3gjyJk8SQFCEf1 -AAZBEgCdANEPGpVqKSEHKCAHJNEI9EEEHaqZAQD4AgAHsYgBAOr/EAxEAoAA6EQCDM8CgAAPmQLo -vxEGQP0AAPksdAWkuB0ACpkCD7sCmeCJIP3B5B2v7xUA7+QYJlDBAACa45vpCEQCG5Ue5OYELM4C -gAAJaQKZ4fksVgXgBAUAlOWb4gnJApnoKtIfmuvp0h4h2VEAAOnmCidRAQAAWS5aiycelQv+4AAW -v8wFAO7dCAXQgQAADKoBJtad5LYKJVEBAACauZq40Q+JJ4ia/SEIFa/PBQDtkgsk2IEAAO+/AQp3 -AoAArOqv3a6I6JYKJukBAAD7oASjogCdAOnEAAGAoYAAyExtSQUDAIYJAmGKsArqCP1ABaRiAJ0A -mrDRDyt8GOokAAlgBIAAWBfYY/7JjCf7hAAV780FAA27AerGCiXZAQAAm8mbyNEPwuJ+2d8o8X99 -h9nqJAAJ2ASAAPyAaB2j+fUA6SUIKugEgABY8xHRD8Wl6iQFKVAEgABYDn/RDwD/QGgdr/myAOzd -DAGBcYAADUkUuJjoSDYJ0ASAAG2JBQoghgwCYwlMDO05CAfRAQAAbckFCUCGCgJlDegMqPgojECY -sNEPAAAp/ECZsNEPAGwQFP0rqgWgBwUAlzCXEZcQiUHqwkMqQASAAOaCACtYBIAAJCAHLqECL6EF -9vgAAzc5AQD1yFAN4UQBACWhBO6iACdr/QAA6xYCIqv9AADtpQIqrwKAAOXuCA//AoAA/88AD3AA -2gAAKaEFK6EE7qIAJMgFAAD9f+AVr5kBAOmlBS5nAoAA+WAT/GIAnQDs7ggM/wKAAA/uDA4AhweX -YO4ABwTzF4AAHpWtK+JLjbEsoQWPsJ/Qj7AJzBGsnP3gJhXvnAEA57YAJav/AADntgEl+GEAAPVg -H1QfzQUAnBeXuA3/Af4iphXlSgUA6rYJJ/kBAACfGY0gn7efti1WPvTAEIsSAJ0AKRYRLiAEKxYW -mBP1wBqyEDoFACkgevrAGQQiAJ0AH5R1jBGNEO0WEypXAoAA7BYUKnAEgAD0gBEKEgCdAK+qLKKe -94AjmdIAnQAqop0clIsETQkM3RGs3JwYHJV/7N0ICecCgADtFgYlGymAACMWFyMhByQWGBSUYAMD -SgwzEQQzAhSUYJOggyDyIWYV4C0FAJ2j9UBGFaANNQDjEhcppgKAAA1EApShLSAEJBIYnR/1oA8E -EgCdAB2VaCQWGSIWGhSVZwmSCewiEQbrsQAAot0iEhkt0n+dGgQiAiQSGo0fIhYSIkEiJEEnnhXp -Fg0m6+0AAA1COCQSGZIcIhIaLhITLRIUl6b2IQgV6J4dAPlBRB3n7sEADt0CKRISLhIRnacdlUsu -pQuZpC3SvIkW/CIGFeMutQD/oAw0IgCdAC46J/+gDawiAJ0AHZVFDk4RDe4C/0EmFaANBQCdqI4e -nqotIAcNLUDzsAAWt/71AA7dAp2rjhXqkn8vdwKAAK/u/y/oFeANNQAt5p0tUkkuUkib8B+VNKzu -KlZBD38IL1ZAK5Z/KxIVL1JGLlZIC9sI78oIBdkBAAD7YBUrogCdAMmF6fQAAYCZgABtOQUIAIYJ -AmEqUkYKygj7QBZsYgCdACpWRogX9MAHux+IAQCY+4kgCJkRCTkC+eAmFeACBQDRDyelBf/1+A2g -CQUAHJRJKoEn/V/wPSIAnQApFhEqIAQrFhaYE/VAGJKSAJ0AKxYWmRSYE/VACyoSAJ0AixO0Gvto -IBXgDDUAWS04iBOJFPoiyBXv9yoAAAAck+yMyJgT94AS4JIAnQAM6hGvqi2invegFIHSAJ0AKqKd -ZKKHHZPj4hYbJhP9AACS2PIjaBWv9vYAIxYXHZTvIyEXkxojICyTHS3Ss4MbDTMMHZTvmRyeFQ0z -AiMWEvIi6BXv+QoAhxyOHR2U6u/uEQu/AoAADncCDXcClx72IQgV7/m6AAAIaRAJiQKZ8IIgCCIR -AjIC8+AmFaACBQDRDyIWG4Iajh0CDUbv7hEO7wKAAP3GAA9y0kEA97gAFrAiOQDt7gIJEwKAAPPG -AA8wAhUAAu4Cnh7yI2gVr/hSAC+AGJgTKxYW6RYEJ/0agACLE7Qa+2OgFeAMNQBZLPWIE4kU+iLI -Fe/y9gDaEPpJ4BXgDDUAWSzvtBr6SYAV4Aw1AFks7IgTKxIW+EpwFe/yWgCLE9oQ+2MgFeAMNQBZ -LOVj/6vaEPpJ4BXgDDUAWSzhLCBT/CCGFa/6LgAiCojRDwDbkPwAAh2gDRUAWBB8IgqI0Q+KGO2U -qB64BIAAraqNEvWgCJGSAJ0ALnKBm+AuVkEqVkArdoEuEhUmUkYtUkgrUkmmyqzdDrsI7VZIJdkB -AAD7YApDogCdAMmICIQC72QAAYCZgABtOQUEIIYPAmMqUkYKygj7QAtsYgCdACpWRixygovCjRft -VYklhpGAAI4gCO4RDj4C/sAmFaACBQDRDwAAAADvuwwEAZGAAAtOFO3sCCxIBIAA7T02D9AEgADT -D23ZBQlAhgoCZauIiRkOOgxtqQUIYIYJAmctEhULzgyu3S3cQPyoxhXv9PoAiBn4qMYVr/TSAAAA -AAAA/+5ADaAKBQCUFSsWFvgghhXgCgUAWTC9iBMck06JFCsSFozIH5NGjhX5n+wYkgCdAP/tfA2g -CgUALXKAm9EqVkEtVkD68AYV7/vGAMCgwNoNzDQdk0D9oQYVr+zqAAAAK8AHCwtB67wYLlAEgABY -FiKMIAjMEQw8AvzAJhWgAgUA0Q/aEPpJABXgDDUAWSx5LSB6/CCGFe/ztgAAAAAAAOa7DAQBkYAA -C04U7+wILEgEgADvPzYLUASAANMPbfkFCYCGCgJpq4iJGQ46DG2pBQighgkCay0SFQvODK7dLdxA -/KjGFe/6egCPGf6oxhXv+lIAAGwQCoo1G5Qs/yhgBeuKQQAIiAnpky4cRwKAAK+PL/J/q5mpiPng -IDQgDgUAifGM8JyQi/As8ggptgHu9gAn6/8AAO72ASYOcYAAJfIHKFIAJ1IL+yckBedIwQDmUgEi -S+kAAAmHOBmUGfNuKBXohh0ACYgB6ZQXHEZCgAAIMwgo0YkKC0f7KCYFp2YBAPkADSxvdwEAZbPl -7JLoF8PhAAD0gAvDEgCdACtRCJsS6SIAIVkhAACbGSnWPpgn7AAFAUiBAAAJAmEJAmEJAmEJAmEJ -AmEJAmEsMAQtLE71gCVikgCdAC4xIhuT/CwyFY8wK7KNny6cLe4lIi5mQoAA7LsIDtAEgAD9b1AV -4AxlAO0kQSXZoQAAWSwaihn6aMAV4AxlAFksFyosYfpp4BXgDDUAWSwTKixd+mmAFeAMNQBZLBCN -OfggSBXgTPUA/EFmFeALBQDrJgwmgDGAAJLckjkbk90tMBYqskMoMQcvMA3uMAwlUAUAACq2Qysw -ByklCCwkBSskBy0kFi4kDC8kDY4g+EDkHaAPBQD+QEYV4AhlAOgkBC92AoAADm4CnlEnJQn0gBB7 -EDsFAPqADPxgPDUA9YVODaA9FQD8hE4N4D7lACowBSclNv9AFAwgTyUA/0ATzGA41QD5QCANIgCd -ABiTJQhICoiM6iQACtgEgAD8wGgdoA0lAAuAAMAg0Q8AAAAAAAD1wGgd7/jWABmTICmRj/E/9BdS -AJ0AKzr/+iBGFe/58gAALKJDwFbu1YkmY/0AAOymQy2KVgAAGJJ7iyDr1j4ny+EAAJkn6AAFAUiB -AAAJAmEJAmEJAmEJAmEJAmEJAmEsMAQtLEjtFgkhITkAAPWAHPKSAJ0ALTEijjDsMhUkW/sAACuy -cZwtni7tJSIuZkKAAOy7CApQBIAA7LB6JdmhAADsJEEq4ASAAFkrsIoZ+mjAFeAMZQBZK60qLGH6 -aeAV4Aw1AFkrqSosXfppgBXgDDUAWSumjTn8QWYV4AwFAOwmDCaAMYAAktySOSUkBCgwBykxCR+T -cisxBywwDS0wDC0kDCwkDSslB//oaBWj+vUAKiUIKSUJ6CQHJ3AFAAAu9kMvMBb+QsYd4E71AP5A -ph2gDQUAnSLnJQkpUASAAFgL58Ag0Q8ALzAEJyU29eAGkhIAnQDaMOtUAAlgBIAAW/y+ZK506iQA -CtgEgAD8wGgdoA0lAFkE88Ag0Q8YksKLgCqiRJ+xKNZB+QAIFeAMBQDp1kAr2ASAAP8ABhXgDRUA -WA8VwCDRDwAAAAAAAADnJTci+PEAAO8DHgFxcQAA7gwAANARAAD8pMQV4Aw1AO0lNiEZdQAA5yU3 -KdgEgABZK2IqIGEpIGIpNAHqNAAg2BEAAPhMcBWgDDUA6DQCIVGFAABZK1nqJAAK2ASAAPzAaB2g -DSUAW/y4wCDRDwAAAAAAACpcGfpp4BXgDDUAWStPKlwd+mmAFeAMNQBZK0tj/xIAAAAAAOokAAtg -BIAA+hCCHeANJQDrVQgq2ASAAFkEuMAg0Q8AAAAlokMp0kko0kf4IMYVr8IFAOkWBSfYYQAAArsB -6xYHKxcCgAACzAws1kjrmQgCq/0AACWmQ+WivCTJAQAA6RYILFgEgAD5AA1q4gCdAOUWBCEB6YAA -iBirJfUADVviAJ0A2bDqEgQjAKmAAG1pBQkghgoCYyXSRyzSSKUliBgPAgD4oA5MIgCdACXWR4UU -7RYKJgfhgAAZkvEPAgAtkhyIGtow79YBJOHBAADshkEo2ASAAP8jiBWgDQUA7oZAKuAEgAD/I4YV -4A4lAFv9APvgAAcwjYUAfekYaEYVL1EIKDr/ePEM2jDrVAALYASAAFkFnBqS2frgaB3gDAUA+0iI -FaANFQBYDqLAINEPAAAfknqIMJ0TLjEnLTB6LiUi/EgmHeAMZQDoJg0t0ASAAO8mDiHZuQAAWSry -ihP6bQAV4AxlAFkq7407/EFmFeALBQAPAgDrJgwmgDmAACLWDPggSBXgTPUA8mFmFa/t4gDqJAAL -YASAAPqgaB3giVUA+KEEHeANJQBZBFTAINEPAIoXnRru1kglUQEAACrWR/uoxhWv+9YAAIoZKzB6 -HZJSLDEnjjCeLSwlIu0mDirgBIAA6yRBIdm5AABZKs7aQPptABXgDGUAWSrLLTIL/EFmFeAPBQDv -JgwmgDmAACLWDPJhZhWv8kIAiBWLFgi7DPuo5hXv+TIAAAAAC4UM+CCIFeSlHQBtqQULQIYJAmUK -aAyJF4oU5aoIBMkBAABtiQUJYIYKAmeLFwUsDIUUrLvs0kgl2QEAAPuo5hXv+RYAAIUXJVxAJdZH -9CCIFe/40gBsEAQrMgX7IwAFoZuhAOySfBSH8YAA9SAJ8JIAnQD1IAaxEgCdAC2iLGmTbPuYyBWr -60EADt0ICd0RDaoIiKLHnvkABAR3uwEA6KYCJYGpgAD9aQAB0B9lAH+5JYmniJqLmWSASom0jLHB -4P8mAAywDVUA+WCGFefMAQBYAczAINEPIqYU6iYIKVgEgABb+kGMKMijj8Jk8EbAINEPKMFywNHx -AUAN4AsFAFv60mP/3//+xA2gCwUAAAApogctpFYskgrrphQmADmAACuSCYyx/OAABjANNQBYAbRj -/7EAACvABwsLQeu8GC5QBIAAWBQOwCDRDwAAAOokAAnYBIAA7EQACugEgABb/gbAINEPAC2iLPuY -yBWr60EArt0J3RGtqomnH5GRjTSOmu/dAQcCCYAAjJn9gOYV54sBACjEGy+gBrD//0DGHeALFQBb -rQHAINEPAAAAAOokAAnYBIAA7EQACugEgABZBUfAINEPAP//BA2gDAUAbBBIGZFoKiAHJRaEKBKE -5TIAIjv9AAD2MMYV4aoBACoWg/igBAL3iAEA9QALYRIAnQCJIi0ShhqQ9eaQ7hyPVgAA6xKDJugN -AAAF1znrFoUj+A0AAPVgCGoQDKUADLkRppkukp7/wBJ74gCdACuSnesWgiWOwYAAiKj3AA8QkgCd -AC5irmThpStireSxoWR7/QAA76YIJY0hgAAoIBSkiAgIRygkFPUADl5SAJ0A6DwQIgxVAADqTP8o -yASAAG2pBQgAhgkCYSIWgOsUAADQCwAAWSjQCqgC6haHJQkBgAAqCgPrFAAMYASAAFkwHclT6xKC -KVAEgADtdAAB4CEAAFgRTtug6EEVaMAEgADqTP8tyASAAG2pBQgAhgkCYSwShtMP7TIDLmcCgACs -u+wyAilQBIAAWBEJLBKFiifszBEKaASAAObMCAPYDQAA68adJVCBAAD6gGgd4AwFAFgN7NKg0Q8A -AIio9wAKoJIAnQApEoUMmRGmmS2SnrN+/6AKy6IAnQArkp1ksVCwjZ2o6xaCLfcuAABgALGJJ4ia -9yFoFa/OBQDrkggk4IEAAA7OAe4WgSpvAoAAq9quZq2I6JYKIzEBAAD6wAjrogCdAMk1yUPZsG1J -BQMAhgkCYYrADwIADwIArar3QApsIgCdAJrA82BoHe/48gAAAIgQGZGjLRKE/CAoFaeIwQAJiAoo -gngqEoD6IGgd58wBAAuAAPgw6BWv+vIAwCDRDwAAwLAMiTTppggt8yYAANog/EBoHaAbxQBYE1rA -INEPKxKD2iDrvBgpYASAAFgTVcAg0Q/AoFkt2BqQaYio+R/woJAMpQBj/8UtIQn+QrAVr/8FAA+P -AQ+KDPpChh2gCQUA77QDL3ECgADptAAu7gKAAP+mAA6wDBUADN0CnbH81aYVr/f+AAAAAAAA//bQ -DaALBQDAoFktwBqQUYio+R/1EJAMpQD/+uQNoAsFAMCwDIk0+UEGFe/6sgAA62oMAYHRgAAKTxTu -/AgpwASAAO5ONg3IBIAA0w9t6QUIAIYJAmEpEoGqONMP704MBMkBAABt6QUIIIYJAmMuEoEK3wyv -7i7sQP+ABhWv+vYAKBKBKIxA+YAGFa/6vgAAbBAEhj6NPxqRUQJlDJbQjj4YkU39wCYV4AwFAJw/ -nD4rgn/02QAVoAIFAOVCOQG44QAAl7GaPymCf5k+J4Z/0Q8AAABsEASKIseN/0GAB5OakQAIqAGY -ItEPAMieWRP826DsIgIpUASAAFktcdEPAGwQBIkniJz0BGId4CZFAPMmABWgCwUA4okMBEMhAAD5 -DQAN8COVAPFj0A3gJLUAYAAQir7AsOosDAVTIQAADKs5yrUssAAPAgBzyeUtsBAqsB902dx1oQJ2 -qdbaIFv/zOukAA1+/gAA0Q/RD2wQBBWQhw8CACNRhuhReSGBUYAAhCAlIgcq+sDoQzpykIEAAPpA -BAUwCQUA6SYCJVEBAACaIZog0Q+MJ/2EABXvzgUA/6AEBrALBQDrxgom6QEAAJ3JncjRD49aZP/E -hVlkX78jUADCSnQ5txmRAohUeYmv0Q8AAGwQBCggcHyHEyogB/pACBXgqhEAWQSKyKbSoNEPwCDR -DysgcCwK9wy7AeskcC0QBIAA0Q9sEATIMdEPAIkni5qHmIib+yQAFa/MBQDsqgEDmEEAAOqICAXY -QQAA65YKJEEBAABzgxx4MUGTmB6Pwp5wjSDA4eR2Ai7uAoAADt0CnXHRDwePDA+vDOWPuhf5QQAA -n5iVcIMgwFHkdgIpngKAAAUzApNx0Q8AAADlj7IVQQEAAJiYlXCDIMBR5HYCKZ4CgAAFMwKTcdEP -AGwQBGQgjmQwi/CogA3nRAEAFo+eaERUDEgRpogpgp4qPB8KShR6k3crgp1ksGYZj5Pvj5cdwASA -AO2PmBHgfQAA+AAIHeTMHQBtyQIIAmGfsI4gnFCTs+22Ai92AoAADs4C7rYBJZBBAADRDxePjol4 -apEzDEgRpogqgp4rPB8LSxR7ozQrgp3ksDBk0/0AAJp4Zb+YwCDRDwAAAAAAAAD//hwNoAsFAMCg -WSzsiXhrkcH//3ANoAsFAMCwwMoMnDT84QYVr/82AAAAAGwQCoo29mDoFe/PBQD4QPAV7wsFAPtA -BAVwBgUA+uAEA/eFAQD9D+CBUVkBAIgnjYvuggokWIEAAA+/ASYmFK/d7IIIKjcCgACm7p6K7G4I -BukBAAD/oAyaogCdAOzZDAGB0YAA/4BoHaSJHQDoFgMkQCEAAOhINgnoBIAAbYkFDQCGDgJhiBOp -PehIDAfxAQAAbYkFDSCGDgJjCW0Mrf0t3ECdsAzDAo4iyOLAINEPH5BuHI9JiTQej54Wj0HxIAr2 -0gCdAC0xCukxCyqgBIAA9KAQ0hIAnQAMXBGmzCjCnvcAJrnSAJ0AK8KdZLI6LCEHHo80DAxKDMwR -DswCnLCMIPkeZgWgLgUA+WBGFaAINQDutgMudgKAAAjuAp6xLiAE9cAQ1BIAnQAsIScoISLpnwkH -c+0AAA7IOByQOx6P8JgS7FwCD/8CgACv7i7if+4WASzwBIAALbULnLT9HugFp5rBAPjmAAzwCAUA -mLb9lKgVp//1APlg5hXoih0A+WFEHaMotQD5gA6MIyl1APmAEWxiAJ0AGJAl+WFGFeANBQDttggq -94KAAAjuAp65LCAHDCxABswQD8wCnLsMShH3QABFMAg1ACimnY00xu8O3QGdNIoiwMEMqgL6QEYV -oAIFANEPAAAAAAAAAOnEAAGAoYAAyExtSQUDQIYJAmWOsAbuCO8CAAfBAQAA/cAEpWIAnQD5YAYV -r/o2AAAAAADxIARHEgCdABuPDSuyHfv5KBWseR0AB7sICbsRC6oIKiYU9KAP0hAN5QAMXBEGzAgu -wp79wB0r4gCdAC3CnWTSCi7xePHA8A3v9nUAKPFr+OAai6IAnQDbIOw0AApoBIAAW/ed6SICLQJu -AABlnhzaIOwkAALYYQAAWBG4wCDRDwAAAAD/YAYVr/f2ACkgVMid6yIUKVAEgABb98vSoNEPKiBV -ZKG2K/F4ZL3f2iBb+F7SoNEPwNEtJFYNnQKdIow0BswB/GCGFaACBQDRDwCLyJkXmhn3YBhYkgCd -AAxMEabMKMKe9wAZIdIAnQAswp1kwxsYjrHiFgolk/0AAJKIghrrxAAObk4AAIkiZZ182iDsJAAC -2GEAAFgRkMAg0Q8u8sCZEg7MDB6PuyghF5gRDswC/kWQFa/4BgAAGo+3+R9mBaANBQDpEgIvZ8KA -AO22CCr3goAACO4C7rYJLM8CgAAMmQIKmQKZuiwgBwwsQAbMEA/MApy7DEoR90AARTAINQAopp2N -NMbvDt0BnTSKIsDBDKoC+kBGFaACBQDRDxiPm4oR/9gAFLANBQDttggq94KAAPnGAA82ygEA7rYJ -LmcCgAD9JgAMsspBAPeYABYwqjkA7JkCDVMCgAD7JgAMsAoVAAqZApm6LCAHDCxABswQD8wCnLsM -ShH3QABFMAg1ACimnY00xu8O3QGdNIoiwMEMqgL6QEYVoAIFANEPi8iaFvdgD7iSAJ0ADFwRpswu -wp79wBAz4gCdAC3CnWTR/RiOXbC+nohl3fTaIOwkAALYYQAAWBFBwCDRDykgVmScKIvI92APOJIA -nQAqYq5kohAtYq1k0gywu5vI6tQABo9hgAAn4IAnfDcHRxTvAgADuB0AAPSgBRISAJ0ADFwRpswo -wp73ABPT4gCdAC3CnefUAAaO+YAAKSAUpJkJCUcpJBT1IA8mUgCdACoiFOkyBCUEyYAAwMj9JgAO -MA4FAPxghhWsuR0AwPAvJFYtMgDzoAR6kgCdACkyAegyAivYBIAA6BYALI8SAADzIBAIUAMFAOoi -ByrfAoAA92AARbAMBQDjtp0qaASAAOqsICpYBIAAWAth0qDRDwCdFfdgD1CSAJ0ADFwRpswtwp73 -oA/D4gCdAC3CnWTR7x+OF7C+/+EGFa/9MgAAAAD6AAId4BgFAPkmAAwwjoUA+GCGFa/9pgDaIPzg -aB3gDEUAW/ZQ0qDRDwAAAAAAAAD/7LANoAsFAAd6AutUAA7gBIAAWAIL61QACVAEgADsjyQb6ASA -AFgN9SoKASokVikyBAaZAfhghhXgAgUA0Q8A//F4DaANBQD8IQYV4AoFAFkrYBuN8ooZjRiLuIkX -H48T+X/m4JIAnQD/8+QNoAwFAMDAwIoIuzQYjen7AQYV7/OeAMCgWStTG43li7gfjweKFvl/79CQ -DeUA//g8DaANBQDA0B6N3sDKDLw0/cEGFa/39gDAoFkrRxyN2IvIHo4t+X/wYJIAnQD/+FANoA0F -AI0iZdoZ2iD8QGgdoBvFAFgQt8Ag0Q8AwNDA+g+7NPuBBhXv97oAAIgiZYny2iDrXBgpYASAAFgQ -rsAg0Q8AACwhCfxCsBXv/gUADp4BDp8M7yQULukCgAD/QGYdoA8FAO+kAC5mAoAA/YYADnALFQAL -zAKcofrVphXv95oA2iDrdAAMYASAAFub/Ykx6hYELV8CgADrewgNGASAAPE/8DhSAJ0A7BIAKVAE -gABbm8zzQABB//fSAP/2JA2gDQUAwKBZKxAbjaGLuIoV+X/wUJIAnQD/9bQNoA0FAAAAwNAejZvA -ygy8NP3BBhWv9WYAbBAEEo688k/oFaADBQCEIYkgmUCIIJSBkyDjJgEhE+EAANEPbBAEiiiJp4ia -65IJJAF5gAD9QEgV4A8FAC8kBf5Ahh3v/uUADt0BnaKMscDT80KGFafMAQBb/grSoNEP//9EDaAL -BQBsEAguIASVFPXAFaOQF3UA98AWjGdVAQD0oA55EgCdACswEPcdNgXgCRUA+AACHaAmtQD3YCMs -ICrVAPtgJMwgPCUA/WAIjCAtZQD9YBHMYgCdACkgB/SgBTkRmQEAiiLAsOsWAy0gVgAA6RYCLNcC -gAD1IAVSEgCdABuNWKuqLqKeKRYA9cAlu6IAnQAqop1ko80uIAcfjYkOLkAK7hAP7gKeoIwgHY1R -7aYCLmYCgAAMTAKcoYswCwtH66YDJUhBAAD4oCE5UgCdAOg8ECIMPQAAsEptqQUIAIYJAmHAMIYS -GI0+DGYRqGYkZp0vIAToIAUvgE4AAMyBZDTj0jDRD4snirwrvDD7X/qUYgCdACysyGTPR8DR/CBm -FeANUgAcjTWLyPdgIPiSAJ0AihIdjSsMqhGtqi2invWgIWOiAJ0AKqKdZKQjsL2dyGWvQ/ggBhXg -DDoAAPi/97lSAJ0AKiAiZKBFLyAHFo2vDw9BBv8J6CQiJ/gLAAAu8Qaq7i71BiogImSkg41+hivg -0QQFY/0AAODMGgzYCoAA7GYIBdv9AAALZgKWKigkIykgIP5AsBWgCkUACpkCKSQg+d/0kVIAnQAJ -C0P5f/Q9UgCdAMDA7CQgKVAEgABbqbDAgCgkFPhAph2v+bYAAIQyG43BJyAH/RxQBeGkgQDrqwgB -wCEAAPtwEBXgpiUA/xngBeD5tQDkJQgm4bEAAOl3AQ3fgoAA+uYAC/D5xQDpdwEH8AsAAPrmAAu3 -tMEA5yQHJsnxAAD3YBmkIgCdAA8Ahw4CYeMGAA4wBIAA9oJoHaPk4QBt6QUIAIgJAIoN5hG/ZARE -FObUbyIgBQAAJNRz84BoHe/2igAAAAD4v+45UgCdAIknZJDei5zH4+wiAiTIwQAA+WAE3WAKxQD7 -gAYGIgCdAA7GAfZARhWgAtYAAAAAAOokAAnYBIAA7EQACugEgABb/zrsIggtB3YAAIjCZIDkwCDR -DwCFMv0b2AWgClUA9PgAAvA7BQDtIgAq+ASAAFkpzMJm9qAIhCIAnQDCe/agCPRiAJ0Awo34oAlk -IgCdAMOSeVm66iQACdgEgADtEgQqYASAAFkCB8Ag0Q8AAAAA6sAKddshAAAOygEqJgLJuyywAMLd -fcFYLrIOwLDTD+6fDAdzIQAAD+s5Zb/i2iBb/MXAgCogBfFF8A3gCYUALyAgCfkCKSQg+V/mOVIA -nQAJBkP43+XlUgCdAMCA6CQgKVAEgABbqT3/+MwNoAgFAADakJoRW/xeiRHrpAANfJYAAGP/pyvA -BwsLQeu8GC5QBIAAWA9xwCDRDx2NrS3SjI/RitCa8IbQjiCfYZjQ6NYBJvv7AADu9n4m6+EAAJ0n -KSQg+EQmHaAMdQD8QKYdr/ESAAAAAAAA6iQACdgEgADtEgQqYASAAFkCS8Ag0Q8A6iQACdgEgADt -EgQqYASAAFkCGcAg0Q8A6iQACdgEgADtEgQqYASAAFkCAcAg0Q8AAIsQ2iDrvBgpYASAAFgPSuok -AAnYBIAA7RIEKmAEgABYDTCMImXOV40TZN5S+kBoHaALBQBbqEvAINEPKTAfwuMPAgD/P/HEIgCd -AC8KJP8/8WxiAJ0AJgol9z/xFCIAnQD6QGgdoAslAFgB2P/uCA2gCAUAAAAA+kBoHaALJQBYAaL/ -7bANoAgFAAAAAIwni8yNsY+wn9COsC3mAei2ACZgwQAA6LYBJdNhAABtSQUKIIYJAmMYjV4tgo4a -jVib0ZqxKYKOmbArho6GwMAw7GgMAzMhAAD4zQAJv+6WAAD/7TANoAoFAPggBhXgCgUAWSmWHIwo -i8iJEPl/3niQCAUA/++YDaAKBQDAoMDqDr40/4EGFa/vXgAAACQxCw9Ah+5MAAJT4QAA8pBoHeOq -AQDnTPwlU/EAAOp0OA5QBIAA+pJoHaAWBQAGTjb+bgANP/flAHehCrKvbfkFCGCICQyKsqYNZhG/ -ZP+xZh2kRB0A5tRvIiAFAAD1rmYdr/KCABiNKyiB4GSAGBqNKSkiACqh03qbDCgiB4uKyLQsggll -yvnaIFgAsdIw0Q+OKf5BRhWv7l4AAABsEA4YjSAfjB/kjB4aWASAAI2CiYPuggEg4EEAAJ7BmcOd -wuiCAClQBIAA+YAGFaANBQD0ICYVoAgFAPggBhWgDgUA+CBGFaAMFQBYDI3A0P4AYh2gDwUA+RkM -BeAMBQDsFgEtWASAAOwWAilQBIAA+CAGFeAMFQBYDIEqFhAUi9LprAgtWASAAP8XlAXhYwEA8xjc -BeAIRQDvFg8pPgKAAOh3AgVogQAA6IwoFWDBAADvAAUA8IEAAO4MAAkvgoAA/xeIBeAOBQD4pgAK -sAglAG2KeIoflLDntgEskASAAPoEChWgKIUAAgCK9WDGFeACFQCftPlgphWgCgUA7io4BMkBAADr -6BENVgKAAOqIAg4QBIAA6GgCBmEBAADjiAIHcAUAAOi2ByDAQQAA6AseDtAEgADqTAAAwIEAAOgH -HgbpAQAA4iwABdkBAAAiEhAoCoCoItEPAGwQDB+LyhWLyRmMFx2MyCggB+NCBCnYBIAAjNGG0urS -AyDwQQAAmuMJMwGW4v3AJhWhKAEA/aAIFeAMFQD9wAYV4AYFAOYWACnQBIAA9iBGFaANBQD0ICYV -4A4FAFgMMsDB/xhaBaAPBQD+ICYV4A0FAO8WAi1YBIAA7hYAKdAEgAD+AGIdoA8FAFgMJx+MGRiL -2RyLcvxgABKwBkUABlUC44t2GaeCgADzFuIFoWIBAPwh5hWgDQUA6EQCBUghAADsAAUA2IEAAOsM -AAVggQAA+0YAFeAIJQBtiniIH5Kg5aYBLPAEgAD4BAoVoCeFAA4AivVAxhWgDhUAk6T3QKYV4AgF -AO3oOATJAQAA69cRDEYCgADodwIN8ASAAOdnAgXZAQAA73cCBugFAADnpgcguEEAAOcLHg5ABIAA -6EwAALiBAADnBx4GYQEAAO4sAAVRAQAAwC7RDwAAAGwQBB2L1xyL14snKNGG/6voFe/59QD5YAYV -4A4FAO4mByXIIQAAmfGcsyrSX5qy6dZfJABhgAAr0XmKIHujAdEPKSEabpQJ2eD+Q0QdoAAeAGiT -6sDBDJwCDAxP7CUaLh98AAAt0YINqgxYp/PRDwBsEAQrIAfsjE8ZUASAAPogAAXwDQUAWAsg0Q8A -bBAGJyAHHYslGYse+Rc6BaF3AQDsMgQrtwKAAKlm+tPIFaAO5QAE7jcIzAH/QAqDoAulACpineik -AAUKeYAAitiXEZgQ90AKuJIAnQAokq5kgPQokq1kgPCwq+vWCCQHsYAAKiAUpKoKCkcqJBT1QAqG -UgCdABuLzRiLA40QK7F/7osEG7cCgAD4wABDd1UBAOvDV3bIQQAAjzCY0IwgsEr/oEYVp/8BAO/W -Ay5mAoAA7EwCAcBBAADs1gEiDDUAAG2pBQgAhgkCYeRmnSKV1QAAKiIH+oBoHeAMBQDqrCAqaASA -AFgILtKg0Q8ci2WLNOy7AQlQBIAA6xYDKmgEgADrEgAp4ASAAFv/QyMSA+pmnSKUdQAAKiIH+oBo -HeAMBQAPAgDqrCAqaASAAFgIHOokAAvYBIAA7IwEGegEgABYCs7AINEPAMCAC6407tYILHiWAADa -IPxAaB2gG8UAWA246iQACdgEgADsRAAK6ASAAFgNXdKg0Q8AAAAAAAAA//rMDaAKBQAAACt8GOok -AAlgBIAAWAlpY//GAAAAAAD8IEYVoAoFAFkoKh2KvIwSitiHERmKtPlf9JCQC6UAY/+SJiEJ+kKw -Fe/9BQANrQENrwz+QoYd4A4FAO2EAy3ZAoAA7oQAKzYCgAD6xgALcA8VAA9mApaB/zWmFe/56gBs -EASFIOJUDAKbIQAAwCAEMjnRD2wQBCogICsK8/tABAVwBAUA6iQgIZSdAABpMRj/QqAHkPzVAAys -ASwkINogW/qcLSAgZNBx0Q8AAAAAAP9eoAfQAxUALgr+Dq4B7iQgKVAEgABb+rEoIAccixn4RFAV -4YgBAAyICeQkIiRACwAAL4EGqf8vhQYpICKKKy7Cj+SQMmTr/QAAAOEE4N0aCdgKgADtqggF2/0A -AAuqApoq9ERmHa/+IgAA2iBbpyEkJBQkJAXRD48p/kFGFe//kgAAAGwQBCogBcCIeoM4Foub8USA -DeAFBQAqICDzRECF4AQVAAOpAukkICGVxQAA2iBb+mzaIFv6UCogIAoKQWqjT9EPAAAA6iQACdgE -gABY/y1lr+z6QLAVr/7WAIsnZb+2LGK+jsGIwJjgj8CNIJ7xlcDlxgEmc/sAAO3mfiZj4QAAnCcl -JCD0RCYd7/42AAAA2iBb+i0kJAXRD9ogW/pvKiAHHIrW+kRQFeGqAQAMqgnlJCIlUAsAACmhBquZ -KaUGKSAiiysuYkDkkCRk6/0AAADhBODdGgpgCoAA7bsIBmP9AAAMuwKbKvREZh3v/QYAjyn+QUYV -7//KAAAAAGwQCpQVKiAHiTCVEvZiEBXhqgEA+iBmFaeZAQCZFPTgDrSQDrUA/uAO9CAPBQCfEYgi -G4om+iBoFaAJBQDpFgAsC/4AABaKG+oWBi1PAoAA9UAHYhAMpQCmmS2SnrRO/6Aeq6IAnQAlkp3t -iqYSjeGAACoKGvrgB9QiAJ0ALiAE6LIIJwfBgAD3ABq4kgCdAClirmSRDylireSRC2RT/QAA6rYI -JIhxgAAoIBSkiAgIRygkFPUAGgZSAJ0A9OAMLBIAnQCKEhyJ/x6J+55QiyCNFO1WAyLIQQAA7FYC -Ld4CgADrSwIBwEEAAPqgJhXnqgEA+UAUeVIAnQDoQQ1iU/0AAG2pBQgAhgkCYcCAjzDz4AoSkgCd -AIsW6hIFLd8CgACmuyq2nSkgBPEg/A3gDLUAfHFULSAFzNFkg6vSgNEPiLj3ABoQkgCdAIkWDJkR -ppkukp60T//AGnPiAJ0AKZKd5ZQABJpZgACwivthBhWv++4ALdGGZN8DYAM+LiAUpO7+QoYdr/ze -AB+KXi/xhmT/oRqKXIkgKqF5epuW2iBb/p3AINEPwJAMjTTttggs99YAANog/EBoHaAbxQBYDKyO -EWTiquokAAnYBIAA7RICKmAEgABYCpGPImX/xIgQZI+/+kBoHaALBQBbpazAINEPAAAAAAAAAPpA -aB2gCxUAW/9AYAAMAAD6QGgdoAsVAFv/DIkSCQlH9SARkRIAnQDAofogJhWv+CoALCAEixPlwg1l -2GEAAOokAAlgBIAAWAyMY/962iBY/71kooSMImTOcWP/ai8gBy4gBByJzvxACBXgvxEA5FkIDdqC -gAAMuwLk4s5u5gKAAB6JiiuUEvsTIgWgPwUAL5Qe+yNGHaANBQD9I6Yd6LsdAPsiJh3gDQUALZQb -+xVsBai7HQD7IgYd4A8FAP8jhh3oux0AK5QP+yMmHaAPRQAPzwIvlBb7FGoFqP8dAC+UFfsjBh2o -/x0A/yKGHeCKFQD7IuYdqP8dAP8iZh3gDTUA7gAFBNh9AABt2gILAmEfiaQcip4bip4aip8uIQj0 -QPAV4O0FAC2UJyqUKPslJh3hVQEA7JQqKqwCgAD1xgAPcAUlAARVNu/uAgTgvQAA/yRGHajuHQD/ -JCYdqO4dAP8kBh2o7h0A7pQfLlgEgADTD21ZBQMAhgsCYcCg6sQGIkgRAAD4IKYV7/ZeAACLEegi -ByWM6YAAi4yOsYqwmuCPsP/gJhWgDQUA7bYAJGDBAADttgElw2EAAG1JBQgghgkCYx6J0iniYRiK -ZZuRmLEv4mGfsCvmYY3AwIDs3gwG6yEAAP+tAAw/9LoAwKBZJqcbiTmIuPkf5PiQDKUAY/26KyEJ -/EKwFa/9BQANjQENjgzuJBQuYQKAAP0gZh3gDgUA7pQALd4CgAD9ZgANsAoVAAq7ApuR+tWmFa/y -KgAAAP/wuA2gBQUA6iQACWAEgABYB8hj/XGOJ4jsLuww/x/uPCIAnQAvjMhk/bzAgfggBhWv9XIA -AAAA6iQACdgEgADtEgIqYASAAFgLpdKg0Q8AwKBZJn4biQ+IuPkf5aCQDKUA/+8wDaAFBQAAAAAA -AAD/8tQNoAkFAAyJNPlhBhXv7s4A6iQACdgEgADtEgIqYASAAFv92dKg0Q8qIAX5X+ukUgCdAMCy -+kCmHe/1qgAAHImHLMGG6BYHJgE5gAAeiYONIC7heZgXftsViSePmugWByeAcYAAipnoFgctYT4A -ANogW/2ighfRDwAAAAAAAP0gaB2gCxUA6owgKmgEgABYBiX5QGgdr+86ABOJZOQhCCJwDQAA/iCm -FairHQD7IiYdoV8BAPsiRh3oqh0A+yIGHaALBQD7I2Yd6KodAOqUDyqsAoAA9IYACnAKNQAKygIV -iM4llBoqlBYDTALzpgAJ8CQFACSUHvUT8AXoqh0AKpQV9SMmHeiqHQAqlBT1EvYF6KodACqUE/Uj -Bh3gCgUA+yOGHaCFFQD1IuYd4AUFACWUHYopiyslIBQslCIrlDbjlCoqqgKAAPsmRh2oMx0A8yUm -HeiqHQD7JiYdqLsdAPsmph3oQx0A9SUGHai7HQD7JoYd6KodAPsmBh2oux0A+yZmHeiqHQD7JeYd -oAMFAPMkph3o5B0A/yTmHaAEBQD1JMYdoA4FAP8khh2gAwUA8yRmHeAKFQD6pgAKuDwdACOUIfUl -xh3owx0A/SQGHahVHQD1JaYd6OwdAP8j5h2oVR0A9SWGHehVHQAllCv0QoYdr+nyAABsEAQkIBSj -RCQkFNEPAAAAbBAKiCIdiXcrIAfsMgAiS/0AAJkU+CBmFeG7AQDrFgUieB0AAP2ABAZwDaUA7BYG -LAa+AACJFRaIcwyYEaaILoKeHIh2mRL/wAer4gCdACmCnSggBOeUAASHeYAAZICXiMj3ABWQkgCd -AC5irmTgrytireSwq2R7/QAA78YIJYVxgAAoIBSkiAgIRygkFPUAFR5SAJ0AihYdiOTriOQdBg4A -APhiABWn5QEA+cAHOVIAnQDoQQ9ryASAALBKbakFCACGCQJhwICJFI8WDJkR6XcID4qGAACKMPNA -DGqSAJ0AjBLrEgMuZwKAAKbM68adLBAEgADRDwAtIBSk3fxChh3v/lYAAAAA6iQACdgEgADsRAAK -6ASAAFgK09Kg0Q8AwLANjjTuxggt+tYAANog/EBoHaAbxQBYCyJj/8oAAAD//DgNoAkFAIsV5IIq -ZdhhAADqJAAJYASAAFgG2GP/p4gV+QKAFaAPFQDoiEccAQqAAAD/Gu3/AgzgBIAA/wgGFeAOJQBt -6gULAIYMAmH3JAAV7/xGAI4nnhCI6fvBSBXvygUA7OILJyiBAAAKWgGaEerKCApPAoAA6bsMBEBB -AACY6evmCiVRAQAA+wAQ2qIAnQBom0SonOsWByZjwQAA/UANM6IAnQDoQR1r2ASAALBObekFCCCG -CwJjjFGPUqyc7xYHJmPBAACLF/uAEswiAJ0A7FYBLkAEgABlvqlgAawAAIkV+SKAFeAPFQDpiBYc -gQqAAOuIfR/4CoAA7f8CC+AEgAD/KAYV4A4lAG3qBQtAhgwCZYoU6qwEI7iBAAD6IGYVr/nOAAAA -LiAELyAHjSAaiBz7D84F4J8RAOjcEQzKgoAA6pkCBwt5gACbch2H2fjgBhXgPwUA/uBmFeAORQAO -zgL+4CYVoAo1AO0ABQPIQQAAbaoCCQJhHIgLLSAHKyEI/xIIBaAKJQD1QQANMd0BAO52Bi7sAoAA -DbsC7LsCA/iBAADrdgQvyASAANMPbakFA2CGCQJnixPAwOz0BiXYEQAAjBIMzBGmzOvGnSwQBIAA -0Q8A+CEGFeAKBQBZJSwch76IyIkY+R/p4JANpQBj/fcuIQn+QrAV7/oFAAqKAQqMDOwkFC/5AoAA -+2BmHaAMBQDstAAvdgKAAP/GAA9wDRUADe4CnrH81aYV7/SeAAAAAAAA6iQACWAEgABYCo9j/YEA -AAAACKwM+uBoHeT8HQBt+QUIgIYLAmmIEQx7CA9PDOiMQCeMQQAAKvz/bakFCKCGCwJriBGLUgya -DKqIKIww6FYBLef2AACLEcDA7FYCJdkBAAD6oCYV4AgFAPqgBhXv84oAjhAMiAz5wSYVr/eCAACZ -cJty9EEEFeAkBQD04GYVoA41AP+GAA8xrwEA7nYBLVQCgAAKVQIeiAGDKyQgFA7aAg5VAo4pmnae -eOV2BCoiAoAA8uEmFeAFFQD0hgAKcAMFAJN1lHcjJBSCE7MigxIMMxGmM+I2nSwQBIAA0Q8AiBEo -jED4oCYVr/aqAAAAAGwQBGhDBmhCPsAg0Q8oIAawiAgIR+gkBix/hgAAiSIsMAHHrvsgBASw+9UA -6SYCLhigAAB7ydH6QGgdoAsFAFujTcAg0Q8AAOs8EClQBIAAWP4fwCDRDwDqJAAJ2ASAAFj+L8Ag -0Q8AbBAG+RAQBaKpBQAJKSgciHz5AABEcApFAOWCfyHYQQAA+2AEANAJFQDgmRoJaASAAOlVAgnw -BIAA5YZ/KngEgAD0IAYV4CsFAFkkS9og6zQACmAEgABZCr/AINEPAAAAbBAIHIholxAoEhEpEhD4 -IIYV4CsFAOkWASloBIAA6BYFKtYCgADoFgIqfAKAAOr/AgnwBIAA/sYAD/AKRQBZJDYfh0EZiFn7 -DngFoAsVAP0QrgWgDQUA8IiQDe/39QBoQQXGKtEPAAAoKqAIKCgkEhKqjq+IihUDPwoI/wvoEgQp -gQqAAOn/CA1XgoAA5KQ4DdgKgADkpDgEBYGAACT1ei3ifxmIQ4wVDb0CLeZ/LPV/6fY7IoVZgABp -UaWNFYwU2iD/z+gVo90dAO3MKAnYBIAA/e9EFePvhQAPzCxYwGfAINEPx4/6YAQA0qcFAOcnKA2g -CoAACEQDqn4o4n+vdwSIASjmfwM0CgdEC6lELEY77UV/IoNxgAD4v/oo0gCdAI8VjBT6QGgdo/8d -AO/MKAnYBIAA/8/oFaPvhQAPzCxYwE7AINEPAAAo4n8HuQMJiAEo5n8t9X/s9jsq+u4AAPjf9/DS -AJ0ALfF67BIEKVAEgADu4n8p2ASAAFjAQMAg0Q8AyW343/bI0gCdAOwSBClQBIAA7uJ/KdgEgABY -wDfAINEP2iDsEgQp2ASAAFiREsAg0Q8AAABsEAYpMAJkkHb1IATYkgCdAP0gwAFf4qUA0Q8iMAb5 -DbAFoqkFAAkpHamIKIJ/JDAF4zIDJADZgADApP0P4AWgKwUAWSPHxirRDwAAAAAAAPoAgh2gKwUA -7IfqGWgEgADuRAAJ+ASAAFkjvWRAoWlB1OokAAnYBIAAWP2QwCDRDyowBiswBywwAy0wBC4wBY8y -iDOYECkxCZkRKDEKmBJb/2rSoNEPAAAiMAYkMAf/Dq4F4qUFAAUlHf0PlgWgCkUA9eAAR/ArBQDp -8n8iKEEAAPqgBADQDhUA4zEIL3AKgADumQIJaASAAOn2fypwBIAA6RYAKfgEgABZI5naIOtEAAng -BIAAWQoNwCDRDwAAAOokAAnYBIAAWP2iwCDRDwBsEATAINEPAGwQBCYiEfDDAA3gBQUAKCISJyB2 -GoeyGYaabQgZI5IsIqKEqFSkMwkzEaMi5yQWIqgFAAB2WwJj/9/RD2wQBBOGafUNEgWgAgUAKDKC -CAhECBqOaKYOBKgKiIALgACxImku5tEP0Q8AbBAEgiPRDwBsEATkh4gRGCEAAClCfxiG7pORmCMl -Qn+VIiNGf9EPAGwQBBiHHxWGsY4rjS76QYgVoAMFAOxSxy9YBIAA+aAIbCBUZQAJ2RHpzAgFA1GA -AJ6riyvIsJq8kyvjJgwpUASAAFui9Iwn+4QAFe/GBQAGuwHjxgol2QEAAJvJm8gqIAUjJBX1QAks -IgCdACMgB/UOHgWgSPUAKCQFK1Fm5EJ/KVAEgADyIAAB8rsdAFiNmWShEdEPAInJ0w8PAgBymVPu -xgkvWASAAOrABSWAMYAAk7zEsnupgI3J7sILLvveAABl73P7gAgV4D/1AC/EBS5Ssvq5SBWgDRUA -/28ADbAMBQBYAw0ZhiGInrCI+SHGFa/9IgCJy4rKcpkGnsuLK2P/pXKpCtvg/4FGFa/+dgAALSAF -dNmRLSE2/kbkFaAKVQD9DpYFoDslAFkjH9EPjy0J/xHvzAgNd84AAIjL8wAGJSIAnQCey4sryLCT -vCnABcOg+z/3FSIAnQCLy2W+2I3MZd7Tjs1l7s77gAgV4C+1AC/EBS5Ss/q5aBWgDRUA/28ADbAM -BQBYAuRj/qotITb+RuQVoApVAP0OXgWgOyUAWSMB0Q+OJx+HLJ9AjSDAUeviCC7uAoAABd0CnUGI -6ozrLewg5t8BBdBBAADvzAgEQEEAAOjmCiZhAQAAesNIyEkEAIYLAmGK6CqsEHyhfJrQiyJlvpza -IOs8GClgBIAAWAjD0Q+NzXLZCdvg/4GmFa/85gCPzPP/+X0iAJ0A2+D/gYYVr/yWAOvMDAIBkYAA -DE4UuOjoWDYKSASAAG2JBQkghgsCY6xJ6vxAJwxJAAAOWwzTD225BQlAhgoCZQz+DC7sUP+gBhWv -/iYAKPxA+aAGFa/9+gAAbBAIFYXdGIb3J1I7KIB9K1It6lI1IqP3AAAsQpTsFgYt3kKAAOuqCAR8 -xIAAIwqAo6pZEbwrUi0pQvUJuxGrmeOaCA0QBIAAWRGzCiwM/CCmFaAArgAAAAAAIyqAo6pZEbEu -Ui0tQvUJ7hGu3ePaCA0QBIAAWRGoCi8MnxWIFvcABwiQBgUA0mD2IIYV4AIqAHOmEB+G1Q+vAe92 -CivQBIAAWRFqKjJgyK9ZEVwqPQH8EgIdoAsFAFke4ioyNMivWRFWKjxQ/BYCHaALBQBZHt36OgId -oAsFAPpgAEUwLMUAWR7YKj0C/A4CHaALBQBZHtUchr6NcC5wNi9wN/biZhWgClUA8iAGFaA7BQBZ -IoiLFrEicrFKKFIjJ0L1qCgJiBGod4p6g3fjMg4ley2AAPNf+ujSAJ0A2nD6AAId4AwFAFkRUBuG -qop6C6oBG4apC6oBG4apC6oB+uFGFa/80gAAhxSCFcCw6nIOKWcCgABZHrSKfwIsCv+IABYwCwUA -WR6winL+WAAVsAwFAFkfQtsg+uBoFaAMBQBZHz8rQpfxbsAN78MFAMAgbQhoLlImLUL1ri4J7hGu -3Y/XLvwgA+4B5vYKJ3EBAACe+Z74ltiW2ZbaltuW3Jbdlt6W3ybWECbWESbWEibWEybWFCbWFSbW -FibWFybWGCbWGSbWGibWGybWHCbWHSbWHibWHytCl7EieysCY/+QZLBzwCBtCGgoUicvQvWoKAmI -Eaj/ifconCADiAHmlgokQQEAAJiZmJiW+Jb5lvqW+5b8lv2W/pb/JvYQJvYRJvYSJvYTJvYUJvYV -JvYWJvYXJvYYJvYZJvYaJvYbJvYcJvYdJvYeJvYfK0KXsSJ7KwVj/5AAAAD64WgVoAwFAFke/ytC -lmSwVvYghhXgAgUAKFIlJ0L1qCgJiBGod4536hIEJ2iBAAAD3QHm5gom6QEAAO3mCSlYBIAA/cEG -FeAMBQD7QUgVoA0VAFgB75Z7lnqWeZZ4K0KWsSJ7I7KHFPrhSBWgDAUAWR7lK0KVyrbAICxSJCpC -9awsCcwR/UAARTALBQD7RAAVoFxFAFkeRytClbEieyPZ+uEoFaAMBQBZHtcqcgj6kqgV4AwFAFke -1CtCmGSwcMAgbQhoLlIoLUL1ri4J7hGu3Y/XLvwgA+4B5vYKJ3EBAACe+Z74ltiW2ZbaltuW3Jbd -lt6W3ybWECbWESbWEibWEybWFCbWFSbWFibWFybWGCbWGSbWGibWGybWHCbWHSbWHibWHytCmLEi -eysCY/+Q+uGIFaAMBQBZHrPRDwAAAGwQBPhACBWvyQUA6SkBAYJJgADTD20ILXOBPCowACwwB3Sh -M4oj6asIDmcCgADsMwgF2QEAAOs7Fnm4BIAA43QAA4CxgABj/8kAAAAAAAAA+m8AC7//qgDzDwAP -cA0FAA7TONIw0Q8AbBAEKSAHG4TfJyEI+AIABXGZAQDohSwczAKAAOl3Ag1SgoAAC6oCG4Sj+mAG -FaAsBQAIdwKNIJsy/GBmFaAONQDo2AIO7gKAAA7dAp0xiismIBT4QSgV4AUFAJU1lzSYNpk46jYJ -KzICgAAGRgKWN+UkFCGQwQAA0Q8AAGwQBCQgIhiFC/JBaBXgBRUA5EAhYjP9AAAogn8AgQTgZhoK -qAqAAOYzCAKr/QAABTMCkyrRD4kpmSrRD2wQBPUJ+gXgBBUAJVJ/hiuDKQBRBPyAAQPf+PUA5jIM -A7v9AAAIdwMHZgHmMwwKggqAAPKNAAkxM50AoyLRDwBsEAQoIAUqIAfTUPkABYxRqgEAjSuMKf2A -BS1iAJ0AjyeP+sHg/8AEu+IAnQAXhF8MqRGnmSiSnvcABWHSAJ0AKZKdwGHxKnAN4AUFAB6EWy0g -BxiE3huEjfxBBBWg/REA9fAAF7HdAQDr/wIO7AKAAA3MAgjMAp+Q/EAIFeArBQCbk/8gRhWgCzUA -6NgCDu4CgAAL3QKdkY8pLSAUjiuemZ+YmJaclOWWBS7qAoAABt0CnZclJBQMrBEHzAgrxp0DDkdp -4gTAINEPAIon+oBoHeAMBQDqrCAqaASAAFgBetKg0Q8AAAAA//1cDaAJBQCLImSwjAMMR2nCaYkn -jprk4HVk6IEAAIqZE4Vw8UgwDe/EBQDwACANoC+lAABkoHKL0OTeAQUBkYAAerEqKKAAf4Ekh9Ms -oAfueQgOZwKAAOyqCATJAQAA6askfWAEgADqxAAOfrYAAAq+DA5aOMuhiKJzibfAINEPAAAAAAAA -APdPAA5//3IA//40DaAKBQAAACusGOwkAAlQBIAAWAb2Y/9hi9KK0eTZAQXYQQAA69YCJVPBAADq -1gEkyQEAAHmrIYzTHoQFqsqa0Z6gjSDjpgIu7gKAAAbdAv1AJhXgAgUA0Q8eg/2eoI0g46YCLu4C -gAAG3QL9QCYV4AIFANEPbBAIKCAFJiAH+oBoHaAZNQDqFgYqoASAAPkADDVhZgEAiCIPAgAPAgDx -GNwN4AoFABOD4gxvEaP/K/KeBmUC92ARvNIAnQAn8p1kciz6QGgdoAslAFkhXumD3x0RugAAKpII -90AOyJIAnQAoMq6VFA8CAPcAD4tSAJ0AJTKtZFHoK6z/K5YIZFHIHoRV/MKAFeAMFQDmhFMegQqA -AO2D6B5gCoAADswC7BYFK9AEgADs1kArSASAAAkghgoCYwkAhgoCYRiFB/pACBWgCQUAKRYAKICA -+uQAFeAMFQD/CKoF4A0FAOkWAixAQoAA+CAmFaAe5QBYBGD2IKgV4A8FAO4iCS1YBIAA+kAIFa4N -BQD+QYYVoAwFAPwgJhWgDBUA/CAGFejuAQD72AAXMA0FAP4gRhWgHqUAWARPH4PBJ/ZABmCGCgJn -BkCGCgJl6RIEKVAEgAD8ACId4A4FAOUhCSrYBIAA/yAAFLD/9QDzIABE8AilAOiWnSrgBIAAWJ+O -LCAV/AgCHeALBQDrJBQq2ASAAFj4OcDW/HWmFeAcRQAsJAUEDkdo4gwvIDrAj/ngB7QiAJ0AwCDR -DwQJR2mS9Ykni5rksHBk8IEAAIuZFITF8W6ADe/FBQD1wAQH8COlAIzgyrx7wSotsAApsAdz0SGG -4+9oCAzPAoAA6bsIBEEBAADouyl96ASAAOvUAA7+tgAAC80MDas4ZLCgj7J08ZTl7wEN/eYAAGAA -kAAAAAD3bwAOv/9eAP/+SA2gCwUAwKBZINIZg2Mqkgj5X/DgkgCdANog/EBoHaAbxQBYBkb//VgN -oAoFAMBQwIoIqDT5IQYVr/hSAAAAACtsGOokAAlgBIAAWAY8//y4DaAKBQAAAADaIPxAaB2gG8UA -WAY2//xYDaAKBQCKJ40WwMDqrCAu2ASAAFgAiNKg0Q+M4orh5esBBmBBAADs5gIlU8EAAOrmASXZ -AQAAe6sjjeMfgz6q2prhn6COIMDx5KYCL3YCgAAP7gL/QCYVoAIFANEPH4M2n6COIMDx5KYCL3YC -gAAP7gL/QCYVoAIFANEPAABsEAQlIAcoICIXg7fzDwAMcVUBAAdVCegkIiKoCwAAJFEGo0QkVQYj -ICKJK/zx6BWgChUA5DAeYdv9AAAAwQTguxoNUAqAAOuZCAVT/QAACpkCmSrRD40pnSrRDwAAAABs -EAQpIQSHIP8gABS1gx0A6XcIDEeCgAD47wALsAoVAPb/gBXkkwEA5nIALIEKgAD9QAEFX/j1AAio -A+aqAQyCCoAA+yAEANE6nQDoZgEKQAqAAAhmAuZ2ACKBEYAAJSECyEuwWuolAimQBIAA0Q8AsVvr -JQIpkASAANEP0jDRD2wQBCchBIgg0w/2/+AVr5M5AOklBSsvAoAA5YUIDO8CgAANXQwNAIcqIQP6 -ACId5sMBAAw7YAoKRvxiYEdQDAUADJ0RDV0MDSCHDDtibz4X+ME+De/99QDIoXOhKgmSEaIy0Q8A -AAAA5yEEJMgFAAAJCU8pJQV3kVGwdgxlEfUAAEL//v4AAAAJlBGkNP7gABc1lB0A7ogIDM+CgAAJ -iAz5H4AVpEQBAO6CACoBCoAA6SEFLbAKgAANbwMP7gEOZgKWgPhACBWv/oYALCUF//6cDaAJBQAA -AGwQBNgg/wAoFa/MBQAMjAHrggIq1wKAAO2CAymQBIAA4lQMChgEgAAKuwzrhgIpLwKAAAWqDKzZ -peLihgEkyQEAAHkrN8mvqiV1kzvITW1JBQIAhgMCYYWBi4KqVXlRZ+WGASqQBIAAyLDRDybMQJaB -9wAGFaACBQCSgtEPDSIM8wAmFa//BgAClwwHSxTrRAwJqASAAG25BQIAhgUCYeczCAYRAQAA0w9t -SQUCIIYDAmONggeiDKLCIixA4oYBLv1WAABj/6QAIsxA8wAmFa/+ZgAAbBAEiDMIiFdvhAOJIs6W -iiflMgQqWASAAOMyBSpoBIAA+0QAFaAMBQBb/8DqJAAJ2ASAAAtQAMAg0Q8AbBAEGoMFG4KeGYMC -+VAQFa/+9QDrKwoJAQqAAPcwEBXgDBUA5Eg5DjAKgAD5UAYdp0YBAOdFAQnrgoAA5cU5CdPCgADj -USd7wASAAA2qAg5OA+53AQnoCoAADXcC+3QmFad3AQDnlIAkAHmAAMl/0Q8AAAAAAAAA74LpE/+Z -gAAu8tLHLgLuAQ7OAi720tEPFYLjI1LSx44IMwEjVtLRD2wQBBSC3RuC2xWDlSNAgP8FtgWv/+UA -/f/iHeAMFQDkMA1iulEAALAyIkSA0Q8AAPQAAh2gCEUA0w9timgpXQIqkQgpkQQosID6gAQA0AYV -APsg1g2gAxUAwGAAyRoJCUcIkgHiMjkMUASAAOYhLHsbgoAADZID4ogBCxPCgADjIgILGAqAAAOI -AvL0JhWniAEA6LSAJQCRgADJhbFE53wEIqgJAADRD/8fAA3gAxUAYAABwDAo4tIPiAEIOAL52kYV -r/9qAAAAbBAEGoJv6CIDIVv7AAArsnwqon/HnOmIAQ3eQoAAq6oLgADSoNEPAGwQBByDXAIrCQy7 -Ciqyf4yhjaCdwI2g44JgFdgLAAAosQL9oCYVoAQFAJSg5KYBJUv7AAApkn7jMn8kQ/0AAPwAIh2v -iAEA6LUCLM5CgADpMwgEAumAAIk37jICKQEKgAD9gAEH3/j1AAj/Aw/uAS42Ai2SCuqSCSaBeYAA -4oKAFQERgAAooAACiAqIjOygBy1YBIAA+mBoHaANNQALgABlr+HRDwAAAP//RA2gCgUA77EDKkgE -gAAJ5BYdgeIq0oIA8QTgThoPgQqAAP2AAQff+PUACP8DD6oBDqoCKtaCCeQWY/9wAABsEASGIIdh -iWCZcIhgFIIoIyEE9wAmFeAKBQCaYOpmASMr+wAAJVJ+5EJ/IZv9AAADA0/jJQQqrkKAAOVECAGA -SYAA0kDRDwDiIQUtWASAAAvkFh2BwizSgvpABADQDxUA4K4aCQEKgAD94AEH3/L1AAL/Aw/MAQ7M -AuzWgioQBIAAC+QW0Q8AbBAEJCELJEz4BARDIkz8sDgCgzjSMNEPbBAGFYL7+QNaBe/05QDTDyNS -rgACACiS0ASIASiW0FiHIlkjaJIQFoLzHYIGCCwQDDwCDcwCLFauG4LvGoJe0w8qtoQpYlv1BdwF -4AMFAOeBwhSCqYAAFILpEoLqK3IxKmKkqzsJuxGrqi5CgC0ggAAwBPXABAdw3Z0A7kaAJvxQgAAs -oh/IyfoAIh3gDAUAWQMhLWJbsTPtM8FyIIMAAPIgCBWv9OUAH4LYLvKCBO4B7vaCISwtAABYhvnR -DwAAGILTG4LTwKAqtsAvgsgZgtEJ/wH/GQYV7/+GAGwQBP8FnAXgGBUA8wDyDeAZVQBzmzaMJ43D -AzsJiMKY0I7CD7sKKrF+/cAmFeAPBQCfw+/GAiVT/QAA/kBGFe+qAQDqtX4lAKmAANEP2zDsIgIp -UASAAFkew9EP6LF/L8gEgAAJ5BYcgV4qwoL7AAQA0A4VAOD9GgwBCoAA/cABB1/49QAI7gMOqgEN -qgIqxoIJ5BbRDwAAbBAEGIKoAzUJDlURqFMkMX7whHAN4AoVACsxfi8yPR6CoikxfxyBaYYi7SIH -LIEKgADuzAgNOAqAAAdmAuxcCAbAIQAAmPGf0uzWAyXYBQAAKzV+KDY9liLRDwD6b+QV4AQFAATk -FheBOChyggCxBP1AAQNf+fUACWkDCYgBCGYCJnaCBOQWY/+OAABsEASKIGWgUB2ChuoiAyn2woAA -rt39r+gV4AwVAPyAQAYxqgEABqoCDcgsCN0oJyUF7cwMBFgFAAD9bQAMP/vFAOuqAQxOQoAACVkC -A6oCmiMJiAIoJQTRD48jG4JyDw9BC/4Rq+stsn8ZgTUssn5y2RvZwPMkHg2gDAUAwMAstn8stn76 -QAgVoABOAAAA2MDzDIYNoAwFAHLRHY0hmtCOICmyfZ3hnCDsJgEky/0AAPlvphXv/VIAABmCWxiB -IamIqOh4oSHqtn8vgTYAAM2uKrJ9aqIZLbJ7/W/mFeAATgAAAAAAAAAA7LZ/J/8hgAD6QAgVr/6e -AByCTIghrJmp6fkPAAzwDAUACcg4+W/GFa/+IgBsEAQjIQQVgkT0YAQB9kM5AAQzAiMlBNEPAAAA -bBAEwEAE5BYWgOElYoL6QAQA0AgVAOA3GgkBCoAA/QABBF/59QAJiAMIVQEHVQIlZoIE5BbRDwBs -EASCIwICQdEPAABsEASFI4MgFIIt+ECEFaFVAQDqgikarsKAAORUCAGAuYAA+wAEBDaYOQAJiAIo -JQQiQn/RDx2CIBOCHx+A5CZCfishBC5Cf5JgliGj//1gBAX2yzkADLsCr1/vJgAnKAUAACVGfyJG -fuslBCqQBIAA0Q8AAGwQBIUjiCAWgg39BBoFoVUBAOSAZ2rWwoAApqYpYn8nYn4dgM3zJf4NoAsF -AHJ5LytmfytmfoQhiCCYQIUgI2J9lFGbIOsmASGb/QAAI2Z90Q8AAAAAAADy4AQEIgCdAHKRHIoh -mKCMIClifZrBmyHrJgAky/0AAClmfdEP0Q8ArN6urn6BMOhmfyqBrgAAzo0vYn1q8igjYnsjZn+F -IYkgmVCIIJWBmyDrJgEno/0AACRmfdEPAADrZn8i/qmAAIUhiSCZUIggJGJ9lYGbIOsmASIj/QAA -JGZ90Q+OIazfr68P7wwPvjj+z8YVr/3SAGwQBPUDrAXgBhUA9EBoHaACNQD2gEADMAAaALAiKFJ/ -6GP3cquBAADRDwAAbBAGiSKEM/EtrA3nRMEA5YBqGAQKgAD0gAQKUgCdAOxJEQgECoAA9IAEohIA -nQClmSiSnvcABiHSAJ0AK5KdZLCmLAoA+kAIFaAIBQD4IAYVoA1FAPggJhWgDgUA+CBGFaAPBQBY -AQMMThH1wABHcA01AC3mnSwgBioiAvkDXAXgCxUA66oCBmAFAAAsJAYqJgL4YEYV4AIFANEPKyAG -/wNKBeAKFQAKmALoJgIl2AUAACskBv5gRhXgAgUA0Q8WgESKaGqhPAxJEaWZLJKebsNDK5Kd5LA/ -ZWP9AACcaGW/X2AAA8Ag0Q/aIOtMGClgBIAAWAMgwCDRDwAA//z8DaALBQDAoFkdoIpoa6G4//80 -DaALBQDAsMDaDa00/MEGFe/++gAAAABsEASII4ch9EBIFe/JBQDpKQEKVwKAAAp3DKpVlSLnJgEk -2QEAAHt7BKh3JyYBqJLkMBphEQEAAKeldSMW4jQAC5gEgABtSQUCAIYDAmHScNEPAAAHKQwJSBTq -jAgrsASAAOpKNgmQBIAAbakFAgCGBgJhA5IICEwMbckFAiCGCwJj0nDRDwAAbBAGjCcegWD7gSgV -r8sFAOnCCiZAgQAAC4gB64ACFVOBAADqxgkkyIEAAOnGCiRBAQAA6KsKecoCgACNy6ramsmboI8g -9UCmFeAIJQDppgMv/gKAAAj/Ap+hiSKeouSmBC0oBIAA8S1MDedDAQDjf+YSIe+AAOxJEQgECoAA -9IAEUhIAnQCjmSySnveABanSAJ0AK5KdZLCVLAoA+kAIFaAIBQD4IAYVoA1FAPggJhWgDgUA+CBG -FaAPBQBYAIEMThHzwABHcA01AC3mnSwgBioiAvkCWAXgCxUA66oCBmAFAAAsJAYqJgKZUtEPKyAG -/wJKBeAKFQAKmALoJgIl2AUAACskBp9S0Q8AABZ/xYpoaqE3DEkRo5kskp5uwz4rkp3ksDplY/0A -AJxoZb9p2iDsJAACWGEAAFgCotEP0Q8AAAAA//04DaALBQDAoFkdIopoa6G9//9IDaALBQDAsMDa -Da00/MEGFe//DgAAAABsEAQrIAcWf6gZgEH8/7YF4MsRAOohCC5igoAA/YYADnG7AQDsNgAt3AKA -AAuqAgmqAocgmTaUOJU59mBGFaAiBQDyYGYVoAgFAJg6mDuaNPzgABOwCDUACHcC5zYBIZDBAADR -DwAAAGwQBCwgB+siACnQBIAA/AAiHeAORQD8AgAGMD8FAFkeqh1/fxh/vB6Atu0ABQ1IBIAACQJh -CQJhCQJhKSAHLyEICQlB7qYCLMwCgAD55gAP8AsFAOj/AgUQwQAA76YAJUhBAAAEIIYJAmMEAIYJ -AmErpBbRDwAAAGwQBCggBxp/pAgoQAqJEAqZApkwhyAdf2wWf9nqf6gbvgKAAAdXApcx5gAVAbgh -AAAHAIorIQjtNgQsZAKAAOy7AgrPAoAA6rsCBOOhAACcNfpgxhXgDgUAnjcEAInqNggky0EAAJk5 -4yEXAZDBAADRDwAAbBAElzYZf1Ecf1D8/qQF4B6FAP5gZhWgCzUA7TYCKsbCgADsNgAqeEKAAOj/ -AglWAoAAC6oCGICkD28CmjGLGps5ihkJKQKZNJo4iRgI/wIYf6+ZN5816AAVAZChAAACAIoiPDDR -DwBsEAQWgF0mYn+JYYtgm5CKYPlAJhXgCAUAmGGHIZZwl2HiZgApqASAAOYmASMzIQAA42QACxAE -gABtSQUFAIYDAmHRD2wQBAUGR2hiBcAg0Q8AABeASSdyf4xxiCeOcJ7AjXD9oCYVoAsFAJtxio3n -pgAkSMEAAJlw+uAmFaACBQDnhg0juyEAAG1JBQMAhgcCYdEPbBAEjSKJIPpAaBWvzAUA7CwBCl8C -gACpuKyqq93tJgIlUQEAAOijL3k4BIAAyTvJSeI0AAyYBIAAbUkFAgCGAwJhiHAPAgAPAgCriOqB -UXyQBIAAmHDRDwmoDOi6DAGBmYAACEsU7bwIKZAEgADtTTYMsASAAG3ZBQIAhgYCYagy604MBhkB -AABt6QUCIIYDAmOqzy/8QO92ACyQBIAA0Q8izEDidgAskASAANEPAAAAAAAAbBAEGoAUliL0QGYV -oZcxABh/D6qZKZCACDgCmCAJWQyZIdEPbBAMlBWVGpIZhRmWFIkwhVcnFgvnEgop8ASAAPSkABXn -yUEA9YAeqReZAQD7IeAVoB0FAPwgZhXgCyUA+iEGFeSqHQCDU4IbiBj7QCAV788FAO9fAQ3vAoAA -7e0IDEcCgACoIpIcrzLiLEAu0ASAAPOgIwKiAJ0A1qDrxAANz8KAAPmAEpViAJ0AiKGDHImgCHg2 -CHcMmTDoNgElSCEAAOkGAAGYIQAAAwCKjaGDYoqjCN0MnWGqinirAbEzmmPywEYV4AkVAP0tAA7w -CAUA7Zg4BcgJAADonDkEGEmAAI0c5HL/ZuhBAACEFe9EEQZABQAA9QAXaqIAnQAYfpnAIP+AAgWw -BgUA6BYGJEBBAAD4IOYVoACuAIkW6QAFDpgEgAADAmEDAmGLoGSxnu7LCwOIoYAAscj1AAhSogCd -AINTrznpnEAt0ASAAPlgG+riAJ0Ai6ANKQvksHtkyCEAAAt4Ng0rCui2ACVYIQAAC0CICQiKi6OD -oAh3DKuLCDMMI6YAI6ICK6YD6LsHczAFAAAjPAHjpgIjhWmAAGQiNP2jABXgAgUA6BIHJvBwgADo -ABUOmASAAAMAigMAivKCaB3gAFoAAACJFukABQ6YBIAAAwJhAwJhi6Fkv0sLeDYNKQsNKwrotgAl -WEEAAOuGAATIIQAACRCKi6WDoQh3DKuLCDMMk6GDpJul6LsGczAFAACxM+OmBCOBaYAAZCG86BIH -JuhhAADxv/dvEAIFAOgAFQ6YBIAAAwCKAwCK8oJoHe/7ngAbfneCGIQZLOQCihz2wACBsAj1AAgz -Cuh+SRNoBQAALaUB+IDkFeQzHQCjIhp+QPIgaBXqmQEA7bg5DM8CgAAKmQKKG40aG35nmaCJQCRB -Gpii46YDIRAFAADjf2Qc/gKAAA8vAp+hj+MLmQKUpvlAhhXh/zEAo/8v8ICDFJOnD90MnaXRDwCD -obPL82IADn/5ZgCcEpMRhBWWEJ8d70QRBlAFAAD1QAgCoA0FAOwWAi0YBIAA7xYNLjAEgAAPAgDT -D9MPbQgr7ssLDngEgADiuyR90ASAAIugzrSLobHd5bBXYZgNAACz/NbA9GAF0qIAnQBj/8YAihH7 -bwANP/9qAI8cC302DXcM7fYBJRghAADjpgAH+CEAAA8Uio+gi6ODog3/DKvbn6CPHX27AbEzm6Pz -QEYV4ADiAI0cC3g2CHcM6NYBJXhBAAAPwIjvEg0m6CEAAA0YiouliaGDpKuLCJkMmaF4uwGxM5ul -k6SIEBl/UIiACYgBiRyYkIOgZT0Yi6GzafsiAA5/9EYAAAD/9/wNoAIVAP/1IA2gAhUAnx3/+WwN -oAYFAIwSDd8Jr8z+IagV7/OaAL+a8S2QDeSqHQCDG+LsECGYgQAAbakFAgCGAwJhhxrsrAkEwEEA -APggZhWgAxUA6XcMBUAJAADoFggjgKGAAIsVD7sR+48ADfAJBQALkzn+ACId4A0FAAP9OGXb6YsZ -hBgqsQcdffAcfcTyIWgV6qoBAOkSAy1XAoAADKoCmjAcfcEafuyCsCuxGvhgZhXgDwUAD9w57DYC -KUYCgAAIRAKIGpQxFH3hieObNgQiAvJghhWhmTEAqpmCGCmQgIoUmjcJiAyYNdEPAAAAAAAAAPNv -AA1/8g4A868ADX/uggDB0PwgZhXgCyUA+iEGFe/tagAAAGwQBIQpgywEMwwDA0gjJR8jJSHRDwAA -AGwQBIknipz5IUgVoAIFAOWcICSgwQAA5KsMBVMhAADrojkEBQmAAIqZ8UVwDeAG1QAnCjzNNiug -AHexR2i1LHa5CyygEGjBO3a5AmjCNS2gB8DA6lQADtgEgABb+sqLUopRybZlr8xgABkAACygEGnI -zGAADgAAAAAAAAD//5ANoAoFAPBBwA3gI9UALSAAc9EZji7AIO5PDAdzIQAAD+I5ZS/nwCDRDwAA -AADrJAAKUASAAFvtQeKkAA1+jgAAY//hAAD//YQNoAoFAGwQBAUGR2hiA8Ag0Q+OJ43q+8EIFa/M -BQDp4gsnQIEAAOyMAQpfAoAAqrWsmavd7eYKJMkBAAB1kyXJMslAbUkFAwCGCgJhJYIADwIABbUI -+KoGDeACBQCVgNEPAAAAAOqVDAGBcYAABUcUuHbmRjYJkASAAG1pBQIAhgoCYQUyCOdJDAYZAQAA -bZkFAiCGAwJjBboMqsoqrED7AAYVoAIFANEPK8xA+wAGFeACBQDRDwAAAGwQBC4gBx99cA4uQO19 -Ox9ygoAAD+4CnjDoIgAqUASAAPT6WgWgC0UA/GBGFeA8BQDsNgMsRgKAAAuIAht9ZOg2ASnIBIAA -5AAFAZhBAAADAmEDAmEDAmEsIAcoIQj8IAAGMAQlAOVENg5kAoAA/QYADDDWTQDriAIL5AKAAOvM -AgSRAQAA7JYGJKiBAADolgQqmASAAG1JBQoAhgMCYS1UBtEPbBAE+PzOBeAYFQDzClYN4AUVAAM6 -CQ6qEampK5F+ZLBuHH5gGH0piycukj4vkX7siAgF6CEAAJ3gnrOoqC6Rf5iy6yICJ/gFAADvlX4v -AQqAAO2WPirgCoAADLsCmyLRD8H1c/OsGH5aCDgKKIJ/3EDqNAAJWASAAAuAAIkiADEEAFoaCpkC -mSLRDwAAAAAA+S/kFaALBQAL5BYdfOou0oIAgQT8oAEGX//1AA/PAw/uAQ7MAizWggvkFmP/YgAA -bBAE+kCwFaAFtQD2AUId4AuFAPYAIh2gEyUA+mWWDaAEBQBzoWr1QAY1kAOVAHWhfPVABHSSAJ0A -c6leiCJlgFnasPpAph3gAVIA2iBYmPv6QGgdoAsFAFv/MIsgGnzwGX1KIyQFKqIfKZKKq6oJqhGq -mSuSB/tkABWvzAUADKoB5LYKJVEBAAAqtgmauCSUBYsi0w9ksIcqIAXAyf1A9g2v8lUA0Q8A0kDR -DwAAjSJl3+faIFuuRWWv3PZAph3gCqUAjiJl79LaIFuuJWWvxyggBo8iIyQF5v8CBEAFAAD4QMYd -oAqVAP5ARhXv/r4AiCJlj6XaIFuuWWWvmisgBokiwKwqJAXmmQIF2AUAAPpAxh3gCsUA+EBGFe/+ -AgAA+kBoHaALNQBZGhvmoJ5tGASAABx8mtMPisj3QAUQkgCdABN8kCsyrnWzZCsyrWSwYLCt7cYI -JYMxgADaIPxBJBWgDQUA/h/iHeAOBQBYmIT8RGQVoA0FAPtAaB3gDhUA+kBoHaAPJQBYmH0lNq0v -IAaOIsGBKCQF5u4CB/gFAAD+QMYd4BoVAP5ARhWv+74AwLAHqTTpxggt/RYAANog/EBoHaAbxQBb -/15j/sraIPxAaB2gG8UAW/9aZT66Y/+twKBZGdwcfG2KyPlf+qCSAJ0AY//HAAAAbBAE4iBwKSAE -gADiOAIBAEmAAChEcNEP+oBoHaALBQBb/sAqQHAMOREJOQIKmQIpRHDRD2wQBoYn4yAHKcgEgACZ -EPbByBWndQEA/OgggVEzAQD0gAghEgCdAPSACYiSAJ0A+kBoHaALJQBb/+XIosAg0Q+JECmcEOkD -HgtABIAACAJhKiAFbqhnKyByfr9h2iBb/11loHcsIAXuIgIuQUwAAC0gcn7fSOl8OB8DHgAA7DoR -AaXdAACpqi+invfgCLJSAJ0AK6KdZLD23GD6QGgdoA0lAP4AAh2gDyUAW/7xHXwqDDwR/YAARnAL -RQArxp1ocjKKJ/qAaB3gDAUA6qwgKmgEgABb+WjSoNEPAADrEgApUASAAOxEAAroBIAAW/6z0qDR -DwDAINEPHXwejNj3gAVYkgCdAAw6EamqK6Ke92AFylIAnQArop1ksLCwzp7YZb91YABpAACPkv74 -AAfwOHUA+f/3lSIAnQD6QGgdoAuFAFv/omWu9IkQKZwQ6QceC0AEgAD4BKgdr/viAPpAaB2gC0UA -W/+ZZa7RixCLsyohCQsLQ+SqEQ3ewoAA+0YADXAbBQALqgL6wAYVr/sWACs8GOokAAlgBIAAW/7e -Y/87AAAAAP/7tA2gCwUAwKBZGV4de++M2Bl76Pmf+kCSAJ0A//1oDaALBQAAwLDA6g7ONP+hBhWv -/SoAAAAAbBAIG31CmxD4QAgVoAkFAJkSmROTFOQWBSlQBIAA9CDGFeAMJQDmFgcsRgKAAP0GAAww -DSUA6BYBKNgEgABb/3nRDwBsEATAINEPAGwQBpUQlhEsIDuGJ+MWAiPZAQAA+iBIFa/IBQD0xAAV -4+wBAOhVAQ93AoAA/0AARTANFQD7RQAVoACiACwgO7HdscwsJDuOa+XoCAV4QQAA6IxAL9AEgAD5 -4AbCogCdAImh6U82BP7ZgADvRAwNSASAAOkmAA3gBIAADASKCQCIDACKn7GOo4mhg6Ku/g+ZDJmh -7qYDJdhBAADv6wZ54ASAALE87KYCIg5TAACOEC8hIoURGn0EJCEHiRIjIQn6QPAV6kQBAOmSACoj -AoAABDMCJCEk+yAEBLC7EQDqe/Id2oKAAPsmAAzzhQEA63wDHEICgAAIRAIYfPQKmQKZcIwgnnWT -cxJ7j5R0lXbi/wIOZgKAAO92AiaQEQAADCwCnHHrABUDqMEAAAUAigjYAph+0Q8A/+8ADT/8ogBs -EAQEAIfIVgIjYAQAYdEPAiNg0Q8AAABsEAQpIQImIQSEIPRApBXgCAUA5mz/JMv9AADpJQIrNwKA -AOZECAqvAoAA9I8ACnAAvgAlIQUmIQSxVfRACBWvVQEA5SUFI0v9AADlYSl8zwKAAOlECAq/AoAA -B0QMBACHCFhg5AAHAvMvgAAiIQUJIhGiUtEPAAAoJQX//1ANoAUFAAAAAAAAbBAEKCAG6Iz/KVAE -gAD4QMYdoAsVAFuXScAg0Q8AAABsEAT0QIQV5UMdAOIiACongoAADFURpSIEIgwiLf/yR+gVpEMB -APqABADQBRUAAFUa5SIBCgIKgAACAhnRDwAAbBAEwFEDJCwDIi4CUjmkItEPAAAgAyciIAMnRCAD -KC4gAylJIAMp9SADKnIgAyrVIAMrbiADTQIgA0zyIANM+iADTQIgA0zyIANM8iADTPIgA0z6IANN -AiADTQIgA0zyIANM8iADTVQgA020IANNVCADTVQgA020IANNtCADTbQgA01UIANNVCADTVQgA020 -IANNtCADTmEgA09bIANPZSADTmEgA09bIANPWyADT1sgA09lIANOYSADTmEgA09bIANPWwMPCBKD -jpOSAAAAAAAAAAAgA4eRIAOIrCADh5EgA4eRIAOIrCADiKwgA4isIAOHkSADh5EgA4eRIAOIrCAD -iKwgA4l9IAOJ/SADinYgA4qwIAOKwyADi4UgA4wAIAOMEyADjH0gA4ytIAOM0gAAAAAgA5RBIAOV -jSADkxQgA5M3IAOUKSADkvQgA5MMIAOVqiADlgggA5l9IAOYPSADmHcgA5aZIAOXCyADl3kgA5e4 -IAOX8CADmO0gA5jlIAOY3SADmKEgA5iZARAYAQABAAAgA+OoIAPjqCAD4bsgA+OoIAPhuyAD44Qg -A+NdIAPhuyAD4pEgA+G7IAPhuyAD4oggA+G7IAPjqCAD4bsgA+G7IAPjqCAD4cQAAAAAAAAAAAMB -AAIAAAAAAAAAAAAAAAAgBGA9IARe8SAEXvYgBGA9IARe8SAEXvEgBF7xIARe9iAEYD0gBGA9IARe -8SAEXvEgBGVqIARlmCAEZx8gBGVqIARnFyAEZv0gBGVqIARlaiAEZWogBGVqIARlaiAEZWogBGVq -IARlaiAEZWogBGVqIARm6CAEZtMgBGVqIARlaiAEZWogBGVqIARlaiAEZWogBGVqIARlaiAEZWog -BGVqIARlaiAEZWogBGVqIARlaiAEZqggBGVqIARmjSAEZo0gBGVqIARlaiAEZm0gBGVqIARmjSAE -ZWogBGVqIARlaiAEZWogBGVqIARlaiAEZWogBGVqIARlaiAEZWogBGVqIARlaiAEZWogBGVqIARl -aiAEZWogBGVqIARlaiAEZWogBGVqIARlaiAEZWogBGVqIARmTQAAAAAAAAAAAAAAACAEqrYgBKq2 -IASpiSAEqrYgBKSmIASqrCAEqoggBKSmIASkpiAEpKYgBKSmIASkpiAEqWwgBKq2IASkpiAEqWwg -BKq2AAAAAAAAAAAAAAAAIAS5vCAEuhEgBLxjIAS8EiAEu8sgBLugIAS7jSAEu4cgBLrdAAAAAAAA -AAAAAAAAARAYAQACAAABEBgBAAIAACAFCAYgBQfbIAUGQyAFB6MgBQejIAUHoyAFBkMgBQejIAUG -QyAFB4QgBQZDIAUGQyAFB4QgBQejAAAAAAAAAAAgBSuwIAUnfCAFK4QgBStYIAUrLCAFJ6MgBSej -IAUnuiAFKxMgBSfvIAUn2yAFJ6MgBSfvIAUnoyAFJ6MgBSejIAUrsAAAAAAAAAAAAAAAAAAAAAAg -BX9kIAV12CAFdYggBXGIAAAAAAAAAAAAAAAAIAV1wiAFdb4gBXW+IAV1viAFdcIgBXW+IAV1viAF -db4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1 -viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+ -IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4g -BXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1wiAFdb4gBXW+IAV1viAF -dcIgBXW+IAV1viAFdb4gBXXCIAV1viAFdb4gBXW+IAV1wiAFdb4gBXW+IAV1viAFdcIgBXW+IAV1 -viAFdb4gBXXCIAV1viAFdb4gBXW+IAV1wiAFdb4gBXW+IAV1viAFdcIgBXW+IAV1viAFdb4gBXXC -IAV1viAFdb4gBXW+IAV1wiAFdb4gBXW+IAV1viAFdcIgBXW+IAV1viAFdb4gBXXCIAV1viAFdb4g -BXW+IAV1wiAFdb4gBXW+IAV1viAFdcIgBXW+IAV1viAFdb4gBXXCIAV1viAFdb4gBXW+IAV1wiAF -db4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1 -viAFdb4gBXW+IAV1viAFdb4gBXXCIAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+ -IAV1viAFdb4gBXXCIAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4g -BXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXW+IAV1viAFdb4gBXXCIAV1viAF -db4gBXW+IAV1wiAFdb4gBXW+IAV1viAFdcIAAAAAAAAAAAAAAAAgBXYeIAV3HSAFeMsgBXi9IAV4 -qCAFeJogBXiFIAV4dyAFeGIgBXhVIAV4QiAFeDUgBXgiIAV4FSAFeAIgBXYLIAV37yAFd+IgBXfP -IAV3wiAFd64gBXekIAV3kyAFd4kgBXd4IAV2CyAFdgsgBXYLIAV2CyAFdgsgBXYLIAV3ayAFdjcg -BXYLIAV2CyAFdgsgBXdOIAV3NSAFdysgBXcMIAV2CyAFdvkgBXbfIAV2zCAFdrIgBXafIAV2hyAF -dnQgBXZhIAV2UQAAAAAAAAAAIAV/uiAFf98gBYECIAWA2iAFgNMgBYDMIAWAxSAFgL4gBYC3IAWA -sCAFgKkgBYCfIAWAlSAFgHcgBX/1IAV/lyAFf+wgBX/EAAAAAAAAAAAgBdCAIAXN5CAFzHggBcrE -IAXHrCAFwcwgBcUIIAXFuFJWAAAAAAAAQb3NZQAAAABjb25maWd1cmF0aW9uIGZpbGUgcGFyc2Vy -IGZvdW5kIGFkZGl0aW9uYWwgY29uZmlndXJhdGlvbiBhZnRlciBbZmluaV0KAABmY29lAAAAAHZu -aWNfaWQAdmxhbgAAAAB0b3MAZXRoZXJ0eXBlAAAAbWFjbWF0Y2gAAAAAbXBzaGl0dHlwZQAAZnJh -Z21lbnRhdGlvbgAAAGJhc2ljdmlydHVhbAAAAABzeW5tYXBlbgAAAABzeW40dHVwZW5pcHY2AAAA -c3luMnR1cGVuaXB2NgAAAHN5bjR0dXBlbmlwdjQAAABzeW4ydHVwZW5pcHY0AAAAb2ZkbWFwZW4A -AAAAdG5sbWFwZW4AAAAAdG5sYWxsbGtwAAAAaGFzaHRvZXBsaXR6AAAAAHRwX3BpbwAAdHBfdG1f -cGlvAAAAMAAAAG5pY192bQAAbmljX3VtAABuaWNfdW1faXNnbABvZmxkAAAAAHJkZHAAAAAAcmRt -YWMAAABpc2NzaV9pbml0aWF0b3JfcGR1AGlzY3NpX3RhcmdldF9wZHUAAAAAaXNjc2lfaW5pdGlh -dG9yX2ZvZmxkAAAAaXNjc2lfdGFyZ2V0X2ZvZmxkAABmY29lX2luaXRpYXRvcgAAZmNvZV90YXJn -ZXQAcG9mY29lX2luaXRpYXRvcgAAAABwb2Zjb2VfdGFyZ2V0AAAAcHBwAGRjYngAAAAAIAKQgAAE -AAAAAAQAAAQAADB4AAAwWAAAMEIAACAF+SQgBd3wIAX5FCAF3gAgBd4UIAXdICAF3rwgBdy4AAEC -AwAAAAAAAAAAAAAAACADsxwgA7KwIASzrAAAAAAgA7KoIAOyoCADspgAAAAAY4JTYwAAAAAAAAAA -AAAAAAAAAAAAAAAEAAAABAAAAAhBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWpr -bG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OSsvPQAAAAAAAAAAAAAAAAAAAAsAAAAgApDACAAAACAC -kMwIAAAAIAKQ2AoAAAAgApDkDAAAACACkPASAAAAIAKRAA0AAAAgApEUDgAAACACkSQTAAAAIAKR -NAoAAAAgApFIDgAAACACkVQYAAAAIAKRZA0AAAAgApGADgAAACACkZAQAAAAIAKRoBIAAAAgApG0 -DgAAACACkcgQAAAAIAKR2BEAAAAgApHsCgAAACACkgALAAAAIAKSDA0AAAAgApIYFAAAACACkigK -AAAAIAKSQA8AAAAgApJMBgAAACACklwGAAAAIAKSZAYAAAAgApJsBgAAACACknQGAAAAIAKSfAkA -AAAgApKEBgAAACACkpAEAAAAIAKSmAYAAAAgApKgCwAAACACkqgLAAAAIAKStAQAAAAgApKYBAAA -ACACksAJAAAAIAKSyAkAAAAgApLUAAAAAAAAAAANAAAAIAKS4AoAAAAgApLwBgAAACACkvwCAAAA -IAKTBAMAAAAgApC8AQAAACACkwgAAAAAAAAAAP///////wAAAAdDAAAAAAD///////////////// -////AAAAgAAAAQAAAAIAAAAEAAAACAAAABAAAAAAAAAAAAADAgEAAAAAAAAAAAAAAAAAAAAABQAA -AAMAAAABAAAAAiAF1IwgBdREIAXTPCAF0fwgBdG8IAXRkCAF0eQAAAAAAAACAAAABAAAAAgAAAAA -AAAEBAhOQQAAVjAAAFYxAABWMgAAVjMAAFY0AABWNQAAVjYAAFY3AABWOAAAVjkAAFZBAABWQgAA -VkMAAFZEAABWRQAAVkYAAGFsbAAqAAAAbm9uZQAAAAAweAAAcG9ydAAAAABwcm90b2NvbAAAAABn -bG9iYWwAAGZ1bmN0aW9uAAAAAGZpbmkAAAAAcmVnAGZpbHRlck1vZGUAAHJzc19nbGJfY29uZmln -X21vZGUAcnNzX2dsYl9jb25maWdfb3B0aW9ucwAAc2dlX3RpbWVyX3ZhbHVlAHRwX3BtcngAdHBf -cG1yeF9wYWdlc2l6ZQAAAAB0cF9wbXR4AHRwX3BtdHhfcGFnZXNpemUAAAAAbXR1cwAAAABudmYA -d3hfY2FwcwByX2NhcHMAAG5pcWZsaW50AAAAAG5lcQBuZXRoY3RybAAAAABudmkAcnNzbnZpAABu -ZXhhY3RmAGNtYXNrAAAAcG1hc2sAAABuZXRob2ZsZAAAAABucm91dGUAAG5jbGlwAAAAbmZpbHRl -cgBuc2VydmVyAG5oYXNoAAAAdHBfbDJ0AAB0cF9kZHAAAHRwX2RkcF9pc2NzaQAAAAB0cF9zdGFn -AHRwX3BibAAAdHBfcnEAAABpc2NzaV9udGFzawBpc2NzaV9uc2VzcwBpc2NzaV9uY29ubl9wZXJf -c2Vzc2lvbgBpc2NzaV9uaW5pdGlhdG9yX2luc3RhbmNlAAAAaXNjc2lfbWF4X3NnZQAAAHBwbV9t -YXhfem9uZXMAAABwcG1fem9uZV9yYW5nZTAAcHBtX3pvbmVfcmFuZ2UxAHBwbV96b25lX3Jhbmdl -MgBwcG1fem9uZV9yYW5nZTMAZmNvZV9uZmNmAAAAZmNvZV9udm5wAAAAZmNvZV9uc3NuAAAAZGNi -AGJnX21lbQAAbHBia19tZW0AAAAAaHdtAGx3bQBkd20AdmVyc2lvbgBjaGVja3N1bQAAAABDaGVs -c2lvX0ZPaVNDU0kAMDEyMzQ1Njc4OWFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6AAAAADBiAABZ -ZXMAU2Vzc2lvblR5cGUAT0ZNYXJrZXIAAAAASUZNYXJrZXIAAAAARGF0YURpZ2VzdAAASGVhZGVy -RGlnZXN0AAAAAEVycm9yUmVjb3ZlcnlMZXZlbAAASW1tZWRpYXRlRGF0YQAAAERhdGFQRFVJbk9y -ZGVyAABEYXRhU2VxdWVuY2VJbk9yZGVyAEluaXRpYWxSMlQAAE1heENvbm5lY3Rpb25zAABNYXhS -ZWN2RGF0YVNlZ21lbnRMZW5ndGgAAAAASW5pdGlhdG9yTmFtZQAAAEluaXRpYXRvckFsaWFzAABE -ZWZhdWx0VGltZTJXYWl0AAAAAERlZmF1bHRUaW1lMlJldGFpbgAATWF4QnVyc3RMZW5ndGgAAEZp -cnN0QnVyc3RMZW5ndGgAAAAATWF4T3V0c3RhbmRpbmdSMlQAAABUYXJnZXROYW1lAABUYXJnZXRB -bGlhcwBUYXJnZXRBZGRyZXNzAAAAVGFyZ2V0UG9ydGFsR3JvdXBUYWcAAAAAQXV0aE1ldGhvZAAA -U2VuZFRhcmdldHM9QWxsAENIQVBfQQAAQ0hBUF9JAABDSEFQX0MAAENIQVBfTgAAQ0hBUF9SAABE -aXNjb3ZlcnkAAABOb3JtYWwAAE5vbmUAAAAAQ1JDMzJDAABDUkMzMkMsTm9uZQBOb25lLENSQzMy -QwBDSEFQAAAAAENIQVAsTm9uZQAAAE5vbmUsQ0hBUAAAAE5vdFVuZGVyc3Rvb2QAAABJcnJlbGV2 -YW50AABSZWplY3QAAE5vAAA1AAAAAAAADAAAAAABAAF8AAwBAAAAABAAAAAUIAYKWAAAAxUOQAAA -H/wAAB/8AAAf/6eIH/+niCAGE/AgBhiwIAdhkCAHYZAgB8AAIAgQQCAIQAAgCMAAIAjAACAJBvAg -AqRsIAkHUCAGFEAIAAAAH/zgdCAIwFAoAAAAAQAAAOAAAAAf/44EAAgAAB//l3Af/5YoH/+WNP/9 -//8AmJaAAACAACACszwgCMDgH/+WRCAIwTAgAo0QAAAIBgAACAAABAAAAAD//yAJCJAD/9AAABAA -AABAAAAf/5ZgAFAH/yAJCRAgAqyQAAAQAADAAAAAAA//ACAAAAAP//AgCMFQ//9AAB//lZAgCMGQ -AAAf/h//ljjXaqR46Me3ViQgcNvBvc7u9XwPr0eHxiqoMEYT/UaVAWmAmNiLRPev//9bsYlc175r -kBEi/Zhxk6Z5Q45JtAgh9h4lYsBAs0AmXlpR6bbHqtYvEF0CRBRT2KHmgefT+8gh4c3mwzcH1vTV -DYdFWhTtqePpBfzvo/hnbwLZjSpMiv/6OUKHcfaBbZ1hIv3lOAykvupES97Pqfa7S2C+v7xwKJt+ -xuqhJ/rU7zCFBIgdBdnU0Dnm25nlH6J8+MSsVmX0KSJEQyr/l6uUI6f8k6A5ZVtZw48MzJL/7/R9 -hYRd0W+ofk/+LObgowFDFE4IEaH3U36CvTryNSrX0rvrhtORIAKLcCACiJAgAoxwIAKMACACkJAf -/5iAIAkKICACi1AgCMHQIAjCED/////P////IAKLfCAJCkBnRSMB782riZi63P4QMlR2IAkKYCAJ -CoAgCQqgIAkKwCAJCuAgApC4IAKKwCACjCwgAotsIAjCUCAJCwDAAAAAIAkLQAAAIAAgCMKA4QAA -ACACixAgCMLQIAjC8CAIw4AgCMMgIAjDUB/83gAgCQfQIAkIMCAJC4AgBVgAGgAAACAJDDAAD0JA -IAACmAACAAAgAovQIAkL4AD///8gAuVoIAjEoAQAAAiBAAAAAABIAAwAAAAgCMVAIAKLaAAAQAAg -AueYIAKKRCAIxaAgCMVwIAjGACAIxdAgAwYEIAjGMCAJDGAgCMZgIAjGoCAIxwAgCMeAIAjG0CAI -xzAgAAAAIAMC9CAIymAgBhP0CgAAACAC1ewgAqg8IAKlgAAAwAAgCQlQIAkJsCAIy/ACAAAAIAjM -gCAIzUAf/5RwIAYSAAAP/AAAADAAIAjNcCAIzgAgCM6gVQAAAAAAD/4f/5YwAAAMIPAAAAAgCM7Q -IAMvtB//lqAf/41wIAKLICAIzyAgCM9wH/+VhCAI0DAgCQ0AIAjP0CADGnAgCNCQIAjRACAI0VAg -CQ2QIAjRkCAI0gD/9///H/+VmCAJDdAmAAAAIAjSYB//liQgCNLQIAYXMCAI01AgBhbwIAkOUBeQ -AAAgBg9Af////yACgADAAAABIAjVMCAI1ZCAAAAAIAjTsCAGFkAAAFAAFLAAAIAAAAQgAy0YH/+P -OCAI1KAVoAAAAACP/iAI1NAWoAAAIygVACCgAAA/8AAAI6AAAAP/AB8gBhb6IAjT8CAI1EAgCNXQ -//8AABAAAAAgCNYgIAjWgA4AAAAgCNagKgAAACADLZQgCNbAIAjXECAI2VAf/5ZoIAjYoCAI2QAg -CNdwIAjX4CACieQgCNhA4QGOACAJDpAAAZEMIAkO4CAJDxD///P/4QIWAOECGgD//8j///8X//// -H/8AAhkcAAIZfAACGZwf/5ZA///x/wACGqQAAhooAAIaqAACGjQAAhq0AAIaMAACGrD///f/AAD/ -6eECDgAAABOHIAKAICACgFAgAoCAAABADQAA//cAAA9CAAD/9QAA//AgCNoQIAjZsCAI2eAAAAwA -AAAYAAACEDQAACBAAADEEAAAwAEAAMggIAjaQAAAxAD+AAAAAF/2pwCyN8dAAAAAHf///2IAAAAA -AMQwIAkPYAAAxDEgCQ8wAADoACAI2pAgCNrQIAjaYAAAyAAgCQ+AAAAnECAJD7AAAMRFIASK0AAA -yBAAABABAAAgfAAAMgDhAF4AAAJJ7wAAzAAgBhCMIAKAsCAI2wAgCNuQIAjbMCAI22D//7//IAjc -AB//luAAHoSAAAGGoP/he4AABJPg//tsICAI3DAgCNygIAjc0CAI3QAgCN0wIAjdYCAI3cAgCN2Q -AAIQCOD//gAgCN4QIAkP4CAJEBAgCRBAIAkQcAAAEBAAAFAQ4QIYAAAAf/0AABAR4QIXBOECFwAA -AAwJ/wAA/wAADA4AAAwMAAAMC9////8AAAwKAADAEAACYloAAMMwIAKAwBAQAAAgEAAAABAHYP/v -+J8e/gAA4QIYDPAAw3Af/44AIAKA8AACEODhAhIAAIAAAAAAEgAAAhUAAAATiAAAIAEf/5VwHc1l -AO////8gAoEgAADDUPf///8gAoFAgH////+Af/+//////z///wAHoSD/wAA/IAjeQAAAF3AgCRDw -IAkQoCAJENAgA5voIAkRICAJEUAgBhHkH/+WLOEAegAgCN5wIAjekCAI3rAf/5SU4QB+AB//lcQA -APP/BAAAAB//mJAUAAAAIAOjRB//o1AgCN9Qg/+3AIP/tiAgCRFgH/+keDAAABAgCRGgIAkSAB// -jywgCRIw4QH+AB//kfwiIiIiH/+l9CAI36AAAAy8AACJBiAI39DgAAkkAJwAACAI3/AgCOBAAAIE -wOEAjgAAAJaAAACWQCAGFAAAAJagAACWYOECACwAAeAA4QGSAAAB4wAf/5ZIIAjgYCAI4JAAABkc -H/+kkAAP//8f/6REH/+PPOEBlgAf/5WsIAYWsAAAYAAgBha6AAAZCgAAg/8gAoF4CFABAADAAAQf -/6X4IAXniCADy8QgBedM3q2+/xrAAAAgBhW4AAD/6iAGFsAAAAgUAACIAB//lLwgA+F4OAAAADAA -AHQf/4QQIAKBgCAI4MAwAAAIMAAADDQAAAjQAAAAAACJFDsAAAg0kAAAADAAAP8H//8FXUqAIAPn -oAAYAAAAOAAAIAkS4AYAAAAgA/V0+AAAAAH//+cAAcAAIAAAgAQAEAAf/5Sk4QGaAOEBmkDhAZo8 -4QGaOOEBmjThAZowgAAAA4AAAAIAAIbd//z//wABAADhAQ4AAAAVsB//ljwf/47QH/+PUCAEA1Ag -CRhQIAkWACAJFkAgCRfwIAkYICAJFnAgCRawIAkW4CAJFyAgCRdQIAkXkCAJFdAP///w//AAAB// -pKAgBBKgIAkZUCAJGYAgCRjwIAkYkB//lJwAACMoH/+ShAAA/4AgCOIw//v//+EB4sCQAADw/P+A -7yAI4oAgCOLAAAD4AAACAQwAAgEIj////wAA8AAf/5W44QGYACAI4xAgCONgIAjjkCAI49DhAN4A -AAIDCAACAgD///AA4QDuAB//llD//3//AADgAAAA/AAAAgMEAAERHAABERgAEAgAgAAIAB//laAA -AgEE///AAAAA//4AACWAAAIDAB//lbDg/+LAIAkZsCAJGkAgCRpwIAkakCAJGiAAAP/zIAjkICAJ -GrAgCORAIAka8AAAKjAAAP/4AAD/8QAA/48AAFK1AABICgAAj4IAAI+GAAA4AAAAj4oAAOM/AACD -riAJGtAgCORg///PvwAAEEAgAoHQIAjkkCAJGxAAAP/7IAKB4B3/8O8AAAoAIAjk0P//3/8gAoIQ -IAjlcCAI5UAgCRtAAAIWCH8///8AAPn/AAD+/wAA/8AAAP8/IAkbkCAI5QAgCRxAIAkb8OAABgAf -/5NwH/+PBAAC//8AAJxAIAkSgCAI5bAgCOYQAACAwgAA/gAgBG8kIAjm0AAAIQAgBHf8IAYQmCAG -EKggBhC4IAYQyCAGENggBhDoIAYQ+CAGFCAgCOcAAAGQ+CAI50AgCOewIAjn4OECFiQBMPhAIAjo -ECAJHRAgCOiQIAjoUOECAAQbAAAAAAMAAiAI6SAAJiWgAmJaAAX14QAgCOjQIAjpsCAI6XAgCOlA -IAjp0B//powgCOogBAEACAAAGRQAAN6tH/+kPCACgyAAAIMAIAjsoBAABQ3uAAAAAcCAAAkAAAAA -AIIAIAjrwCAI7BAgCOxQEAAHAiAI7WAAAPz/IAjt4AAFAAIgCO4QIAjuMCACg3AgCO5QIAOxCCAD -rjAgA7BUIAjucCAGFCgA/8AAEgAAACAEx6ggCO8QIAju0CAI71AgCO+wIAkeQCAI8NAgAoqgIAjw -8CAI8AAgCPBgAP///AAAEDb//+//IAKDoB//pIQgA/GcAAAIUCACg6gyAAAAAAAIQAD///oAAIAF -3q2+74GAAAAAAIP9MAAAHDAAAAQwAAAUAAD/7//+//8f/6U0IAKDsAD/8AAAKAAAIAjxMDAAAAAw -AAA0AACAASACg/AAAIACEAAFEJkAAAA0AAAAIAke8CAI8XAAGQAAIAjxwCACjRgAABshAACABzOQ -AAAf/5QMAxUAAAUAAACD/wAbIAjyMCAI8oAAAZGsIAVbjCAI8uAgBhQsCwAAACAI83AgCPPgIAj0 -UCAI9IAgCSDAIAkhYB//lwAgBE9E4QAOAOEAEgAf/5QYAAE4gAACJxAgCRygf///Dx//l2jhAC4A -/AD//+EAlgDhAJoAAAAJ/wAAsAAf/5aYIAKEQB//lfThABIE4QASCOEAEgzhABIQ4QASFBEAAAAf -/AAAIAj1ACAJIsAAAZSPAAGUz///7/ggAoRgH/+VECACh1Af/5XAAAJJ8B//lbQf/5UwIAKIIB// -jhQgCPbAH/+WcCAI+BAf/5RkAD///wAA//0AAP/VAADql8IAAA4F3AEAA/8AACAI+HAgCPiwIAj5 -ACAI+UAgCPmQIAj50B//onAADwP/AxEAAB//l1T9///QAAAZAOECAgDhAoIAAAQF7uECAQThAeIA -H/+V3OAACQgD6AAAH/+WpAAAeQQf/5XgACf//wAAdgAf/5SIH/+WgB//lewgBoAAAAAUACAGgRAg -Bq6gIAbu8CAGhmAgBoVQIAaEQCAGgzAgBoIgH///8B//o3AgAopwH/+kiAAAGdQf/6aESQAAACAJ -K4AgCSrQIAkrMB//lQwf/5XQH/+V2OEAdgDhAHIA///wDx//laQgCQHwIAkCUB//lYggBhY4QAAA -BBSQAAAf/6Q4/+gP/wAQgAAgCQOAIAW+bCACiHAByEAG4QGZ4AAAflAAAH5AAAB+GCAFzeQf/5WA -IAKN6CACjewgAo3wIAKN+ABQIAbhAZoMH/+VPABwIAb/4AAAAAIgBiAJA6DhAZoE4QGaCAAEIAYg -CQPQH/+UUOAAAQDf//4AH/zAAMAAAAXhAd4AIAXg5B//lbwgCQQAH/+WyOEAVgAgCSwA/+///+EB -lNAgCQQQH/+PNCAJBFAgCQSQH/+WnCAGEiQgAot0IAktACAJLbAgCSwwIAkscCAJLjAgCS1QIAks -sCAGEBQf/5X8IAkFMCAF4hwf/5ggH/+nPB//p1Qf/6dsH/+Z4B//p0Af/6dYH/+ncB//lrQf/5iw -4QAxAAQAAAEAACHBIAkFYB//jvz//H//IAkFkB/84YAgB8AAH/+OgJ////8f/5Q0AwAAAL//8P8g -CS7wH/+WACAGFDAf/494/w///x//jhB/8AAAAB///2wQBIMoKCIQ6yISKdAEgAALgACKMsunwLD9 -/gId7wwFAG0IDXrADQqKFOSgHWXYIQAAY//retAMtLvwABwNpKodAACxuwoaFGWv99owW7dxijfx -QiAN4AQFAPtEABWgCxUA/IBoHaANFQBbtimKN8efmaCUN1uygiQ2DiQ2DyQ2ECQ2ESQ2EiQ2EyQ2 -FCQ2FSQ2FiQ2FyQ2GCQ2Gf33mgWgClUA+gYCHeA9BQBY1eYkNAQkNAUkNgIkNCAkNCEkNCIkNCOU -OZQ6lDuUPCQ1GuQ1GylQBIAAWANe0Q9sEAiEKBz7vC0gBCRCES4iAP5AsBXgClUA9IoQFaA7BQBY -1dIpIAX6QEgVoHglAPkABWrnNQEAya38Y2CBUAsVACU8/gW1Odog7PusGtgEgABbqOjAINEPHPuq -LSAEjiCPLvR/wBXgCBUABYU59CAGFaAKVQD0ICYV4DsFAFjVuxb7oSpiF2Sgb/pAaB2gC4UA7RwQ -KmAEgABbqPzv+5sVAkGAAI4uwNCdoQ/uAp6gHPuXLWYX6RIEKl8CgACsu+m2ACGUhQAAiif6ACId -4AwFAPtEABWgDRUAW7XW0qDRD8Ag0Q/AINEPK0wY6iQACWAEgABbu3hj/02xq+wkAAlQBIAA62YX -IlhhAABbu3Jj/zUAAABsEBYc+36NIC4gBY8wKDAF9CAmFaAKVQD4IAYVoDsFAFjVjRf7dxb7dxX7 -dxr7ePpg6BXgDzUA/fbsBeGOBQD8EkIdoJgFAOuyDiIMeQAA/IIgElACBQBuQgmKOigwBYqofIEj -0Q8AAAAkMAX4gAjkIgCdACoyCiqiCHxBVSoiCFgPBcAg0Q8AKaIYrr4NmQIpphgv5JIoMAV8icf7 -9rgFr5xVACw0BRz7Wxn7WyqgfSzCLSmSh8CA6OSRLmZCgADsmQgFfVSAAC0KgP0gAETwAT4AKaIY -rr4NmQIpphgv5JIoMAV8iZUs+pUsNAUc+0kZ+0oa+0Yswi0pkocqoH0JzBGsmfFACe/SAJ0ALQqA -/SAARPAE3gAAAC8qgK+ZjTCWFvYghhXgD0UA5RYKLu4CgAAP3QKdFSyQByqRLgwMQQDMEQyqAgWq -ApoYCeowmBvpFgklyAsAAOlmAADQwQAACgyKCUCICgiKCSCICgSKCQCICgCK6xwQKdAEgAD8AIId -oA0lAFuapsAg0Q8d+yKMPxj7ISnSLS3SJSiChy+gfe3KCAzOQoAA6YkIDVZCgADqiggH/DyAAC8K -gP8gAETwACYAKCqAqJn/YABGsGxVACzUkYigJRYa9iKGFeAMRQDmFhYsRgKAAAyIAigWFS+QBy2R -Lg8PQQD/EQ/dAgXdAi0WGAzqMPwjJhWgCQUA6RYbJcgLAADp5gAA2cEAAAscignAiAsYigmgiAsU -igmAiAsQiiscUPwAgh2gDSUAW5p4wCDRDy8qgK+ZwIAo5JGNMJYW9iCGFeAPRQDlFgou7gKAAA/d -Ap0VLJAHKpEuDAxBAMwRDKoCBaoCmhgJ6jAoFgspFgnpvQIg0MEAAAlgiAoMiglAiAoIigkgiAoE -igkAiAoAiuscECnQBIAA/ACCHaANJQBbmlpj/cEAbBAEKzAF9/WsBeAEBQD38gIdoJwlAP1gBcQg -lVUA9WAFhGCYBQD5YAZlIgCdAIk4InKK6jIJJIBxgACZoIs4mrGUOJQ5iTzIliySErDMLJYSKHJ1 -ijclMgD7QcgVoAsFAPivAAq13IUAWNERlDiUOZQ6lDuUPJQ9lD6UPyQ2ECQ2ESQ2EiQ2EyQ2FCQ2 -FSQ2FiQ2FyQ2GCQ2GSQ2GiQ2GyQ2HCQ2HSQ2HuQ2HyrYBIAA9mCmHaAMBQD6QWgVoA0VAFu0kost -sLv6QaYV4AIFANEPjj4tIhjH/Q/uAe42Dia4aoAAfLEulDp1uQmIPvEABn/QBRUAwCDRD9ogW1RC -HPqZKiIYKzAFDKoB+kMGFaCZJQB5udCJOCJyiu0yCSSAcYAAmdCOOJ3hlDiUOYk8yJYvkhKw/y+W -EihydYo3JTIA+0HIFaALBQD4rwAKtdyFAFjQ15Q4lDmUOpQ7lDyUPZQ+lD8kNhAkNhEkNhIkNhMk -NhQkNhUkNhYkNhckNhgkNhkkNhokNhskNhwkNh0kNh7kNh8q2ASAAPZgph2gDAUA+kFoFaANFQBb -tFiLLbC7+kGmFeACBQDRDwAAAAAAAAAb+mkc+mrt+moZ0ASAAFtULtowW1QQgjeCLiQ2EiQ2FvRi -ZhXgCwUA9GKmFeAMJQD8YoYVo2pFAPpAAEUwjAUAWNCr+nyCHaALBQD6QABFMIwFAFjQpiwqgPxA -AEY0bUUArS0k1AAk1AEk1AIk1AMk1AQk1AUk1AYk1Ack1Agk1Akk1Aok1Ask1Awk1A0k1A4k1A8k -xNwkxN0kxN6LPgW7AvphxhXgAgUA0Q9sEAgmIgcPAgAmYg4rYngDuAEEugHooQd5KASAACNifuz6 -OhpwBIAA+AAiHaAPBQDjuQEJ6ASAAPlPAAzwOwUA+QIAD/AKVQBY1Dnq+iYRhDmAABz6Jhv6LSqg -fSzCLSmygP2IABYwBxUA7JkIBXxQgAApkieJnimSEPk/4BXgADoAKZKniZ4pkhCwmeKyhiSAiYAA -gi9tmQeIInOBKSIsKMDQ4tQABoHJgADKKS4hBvoAoh2gOwUA7PoWGWgEgABY1BvRDwAAAPxAaB3v -/14AAAAAAAAAwCD//1ANr/71AB/6DS1iYO0WBCLY6QAA+iBGFeYa5QCq2i7xAi4VAo/w/iAGFeAp -pQD5oKYV4AxlAFjQQIYU+iBoHeYahQD6wABFMAxlAFjQOx/5/fnz9gXlrYUArW2dEyfUfyfUhfmv -ph3gDGUALNSC/7AmHeAOhQD/sAYdoAiFAPmvhh2opx0AKtR++7CGHaALRQAr1IP6IEgV5irlAKpq -WNAmiBMvajj+wABH+JQdAOmEjirQBIAA9RHmHaiZHQD5EaYd6JkdAPkRhh3gDgUA7vUCK1gEgAD/ -4AYVqNMdAPMTJh3onR0A+RLmHej5HQD/EsYd4AwlAP0TBh3gDjUA/sDGHaANJQBYIEJj/sQAAGwQ -CIQqG/nMGvnN8gACHeAM1QBtCA+xM+PCDnmBCoAAAKgae4oDY//pABz5xS4gBY0gJiBQ/kNIFeAL -FQD+IAYV53UBAOkiByP7+QAAD785nxX5IEgV4ApVAPggJhXgOwUAWNO5KyIV7CIXKlAEgABb/2nl -pAANAs4AACoiGsGE+wAMYqIAnQDAwOwmGiOUTQAAiifAsftEABWgDRUAW7PcLSIRZNANAioC+kJI -FeAMFQAL0AAsIhBkwAr6QkgV4AoFAAvAANogWAEhwCDRDwAc+YQqwhhkoU76QGgdoCsFAO0cECtg -BIAAW6bfZKEAH/mVji0oITAopQIsISwP7gKeoC0iF52iLKUDKFEGKyIVm6OLLC0gU/JKEBXnkwEA -7yBSLMuCgADsiBEO8QKAAP5wABGyu8EA6xYGL/kCgAD55gAP/5ONAPkGAAx03R0A6P8CBYdpgAD9 -8vgFoAsFAAvYAgzpAgk7AokW6PgCDM4CgAAJuwIZ+XWbpRv5dQmIApikK7J/GPlzmKcrslwoOif5 -YAW8IgCdACk6K/lgByRiAJ0AwND9QMYV4DsFAP3y1AWgClUAWNNkLQpyLSQFHPlK6hIEK18CgACs -u+q2ACOUdQAAiif6ACId4AwFAPtEABWgDRUAW7OK0qDRD8Ag0Q8rbBjqJAAJYASAAFu5LYsV7PlX -GVAEgABbpnHAINEPALGr7CQACVAEgADrJhojWGEAAFu5I2P/1bGt6iQAA1hhAADtxhgpYASAAFu5 -HWP/vRz5SP/8YA2gCwUAiEv8onAV4Pg5APjAAAcyiEEA7O4RDEPCgADo7gIP+wKAAO/uAg7vwoAA -Dt0CHvk7/6YADr/8mgAZ+TkrUQd5sSMe+TgMvREO3QIvUBMe+TMP/xEP3QL/pgAOv/wCAAAAAAAA -AAD98mAF7/+GAGwQCIQqG/keGvkf+A4iHaADBQD4QKYdoAzVAG0ID7Ez48INeYEKgAAAqRp7mgJj -/+mNICYgUCkiGpkQiCfApf3yJAWgOwUA+QBIFaB+FQD4ICYVoA8FAFjTDisiFewiFypQBIAAW/6+ -5aQADQJGAAAqIhrBtPtgD9KiAJ0ALSIRwMDsJhomgJGAAAIqAvpCSBXgDBUAC9AALCIQyMn6QkgV -4AoFAAvAANogWAB7YAD8AAAAABv43SqyGGShEPpAaB2gKwUA7RwQK2AEgABbpjhkoY4X+O6PLSgh -MCilAi0hLAf/Ap+gLiIXnqItpQMoUQYsIhWcoy8gUvxKcBXnswEA4yBQLduCgADnIgwsRwKAAPOg -ABc03R0A7jMRD/kCgAD75gAP/7ONAPsGAAxyd8EA6P8CA4XxgAD98aoFoAsFAAvYAgzpAgj4Auk7 -AgvOAoAACbsCGfjPm6Ub+M8JiAKYpCuyfxj4zZinK7JcKTon+WAEVGIAnQApOiv5YAXMYgCdAMDQ -/UDGFeA7BQD98YgFoApVAFjSvi0Kci0kBRz4pOoSBCtfAoAArLuasO8iAClwBIAA/fGCBaAKVQD6 -BgId4A0FAFjSssAg0Q8AALGu7CQACVAEgADuthgjWGEAAFu4hdog/fFeBaALBQBbpcpj/7kc+K3/ -/RwNoAsFAIhL/KJwFeD4OQD4wAAHMohBAOzuEQxDwoAA6O4CD/sCgADv7gIO78KAAA7dAh74oP+m -AA6//U4AAAAZ+J4rUQd5sU4e+JwMvREO3QIvUBMe+JcP/xEP3QL/pgAOv/yuAAAAAAArbBjqJAAJ -YASAAFu4YmP/bytsGOisASlgBIAA6CYaKVAEgABbuFxj/1YAAAAA/fEUBe/+2gBsEASFIBv4iB34 -iSQhMIosKNKc87ZoFeAGBQD6gABCd5oBAOhVDASB4YAAyySMJy/6wPZA5hWv+PUA6MYAJnCBAAAP -7gHmxgoncQEAAJ7Jnsj1IAZYkgCdAPUgBwkSAJ0Amiwr0kzuIhclgeGAAP/wogXgCgUAbQgpKPIj -LNKtqKgJiBGozIzHjM4pwnfumQ91UAUAACnCerCZKcZ6K9JMe6sCY//PliiWKZYqliuWLJYtli6W -LyYmECYmESYmEiYmEyYmFCYmFSYmFiYmFyYmGCYmGSYmGiYmGyYmHP3wqAWgClUA+gYCHeBdRQBY -0kL6oGgd4HoFAPpAph2gDAUA+mEIFaANFQBbshfqMgkqWASAAPwAAh2gDRUAW7IT0Q+ONuoiDCZY -IQAAm+HuxgIh+GEAAJ/D+mDGFe/8ngCJNOoiDCZAIQAAmJHpxgIh2EEAAJvD+GCGFa/8JgBsEAwr -ITeDJxj4NMBS8mHIFeAMFQD7CBYN4AQFACogBSgKkvlACOwgmVUAeaEFwCDRDwAAJSYULCYTLCYV -JCYSii7kJhYl6AUAAC0lN/FABx+SAJ0A0kDRD9ogW1GrHff5GfgeG/f9jy7/7/IFoYoFAPpgAEU/ -+OUACP8Bny4f9/MlpJIu4H0rsi0pkoMkpJHqIgAt3kKAAPsgAETyjAUA/iDGFeCLBQDtFgAnfDCA -APsgAETwABoArJn978YFoAtFAOwWAi1WAoAAC6oCmhEokAcukS4PAgAICEEAiBEI7gIP7gKeFA3q -MC0WBeQWByHICwAA6WYAANCBAAAKDIoJQIgKCIoJIIgKBIoJAIgKAIrqJAAI2ASAAPwAgh2gDSUA -W5dQ9EbkHaACBQDRDwAAAAAAAOokAAnYBIAAWBSqwCDRDwDaIFtRcMAg0Q8AAABsEASKIIQihyOF -IY4wBHsDC1sBC3sDq+urqhv33YgxBUkD+0AARXyAPQAKqhiqWgmpAQlJA6mIqHcY99YKVgOJMvjg -AEO6AD0AB3cYp6cGdgEGVgOmlqZEFvfQB6gD9oAAQjeAPQAERBiGM6R0CEgBCKgDqGamVRb3yYs0 -B0wD9qAAQrUAPQAFVRilRQxcAQx8A6y7HPfDiDWsu/tAAEV8gD0ACqoYBFsDqloLqwELSwOriBv3 -vIY2q4j44ABDugA9AAd3GAWoA6enCHgBCFgDqGYY97WNN4s4qGYY97SmRPdXAAt3gD0ABEQYpHQH -TAMGRgEGpgOm1qhm9qAAQrUAPQAFVRilRQxcAQx8A6y7HPeohjkEWAOsu/tAAEV8gD0ACqoYG/ek -qloIqAEISAOoaKuIBasD+OAAQ7oAPQAHdxinp4g6C3sBC1sDq4gb95oc95uriIs7qET3VwAMd4A9 -AAREGKR0B08DCEgBCKgDqLisiKhV/GGIFaUAPQAFVRilRQ9fAQ9/A6/MH/eNiD2vzP1AAEU8gD0A -CqoYBFwDqloMrAEMTAOsiBz3hh/3h6yIjD744ABDugA9AAd3GAWoA6enCHgBCFgDqMiviAevA/iA -AEI3gD0ABEQYiD+kdA9PAQ+vA6+IH/d5r4ioVf5gKBXlAD0ABVUYpUUEWAMIeAEISAOo/xj3cqj/ -r6r4YMgVrYA9AAqqGKpaBa8DD08BD18Dr4gf92uviKh3/+7WBeuAPQAHdxinpweoAwhYAQioA6i4 -r4gf92X4gABCOQA9AAREGKR0B0gDCKgBCHgDqOiviKhV/mCoFeYAPQAFVRilRQRYAwh4AQhIA6j/ -GPdYqP+vqvhhSBWtgD0ACqoYqloFrwMPTwEPXwOviB/3Uq+I+OAAQ7uAPQAHdxiIP6enB68DD18B -D68Dr4gf90uviPiAAEI5AD0ABEQYiDSkdAdPAw+vAQ9/A6+IH/dEr4ioVfnuhgWmAD0ABVUYpUUE -XwMPfwEPTwOvb6j/r6r/7noF7YA9AAqqGKpaBagDCEgBCFgDqMiviPjgAEO7gD0AB3cYiDOnpwev -Aw9fAQ+vA6+IH/cxr4j4gABCOQA9AAREGIg4pHQHTwMPrwEPfwOviB/3K6+IqFX+YagV5gA9AAVV -GKVFBFgDCHgBCEgDqP8Y9ySo//9AAEV9gD0ACqoYH/chqloFqAMISAEIWAOomK+IH/cd+OAAQ7uA -PQAHdxinpweoAwhYAQioA6jYr4j4gABCOQA9AAREGIg8pHQHTwMPrwEPfwOviB/3Ea+IqFX+YKgV -5gA9AAVVGKVFBFgDCHgDqP8Y9wuo/6+q+GEIFa4APQAKqhiqWgWvAw9PA6+IH/cFr4iod//uCAXq -gD0AB3cYp6cHqAMIWAOouK+IH/b/+IAAQjgAPQAERBikdAdIAwioA6jIr4ioVf5gKBXkgD0ABVUY -pUUEWAMIeAOo/xj29Kj//0AARX4APQAKqhiINKpaBa8DD08Dr4gf9u6viB/27vjgAEO6gD0AB3cY -p6cHqAMIWAOo2K+I+IAAQjgAPQAERBiIOqR0B08DD68Dr4gf9uKviKhV/mGoFeSAPQAFVRilRQRY -Awh4A6j/GPbcqP+vqv/tuAXuAD0ACqoYqloFqAMISAOo6K+I+OAAQ7qAPQAHdxiIM6enB68DD18D -r4gf9tGviPiAAEI4AD0ABEQYiDakdAdPAw+vA6+IH/bLr4ioVfntlAWkgD0ABVUYpUUEXwMPfwOv -b6j/r6r4YYgVrgA9AAqqGKpaBa8DD08Dr4gf9sCviPjgAEO6gD0AB3cYp6eIPwevAw9fA6+IH/a6 -r4gf9rr4gABCOAA9AAREGKR0B0gDCKgDqJiviPigAEK0gD0A9KsACv/49QAIfwOlRQ9fAg9PA6/u -H/atr+7/QABFPQA9AAqqGAhOA6paDq4CDl4Drt0e9qeu3fzgAEP7AD0AB3cYCF0Dp6cNfQINrQOt -zB32oK3MCK0D/IAAQjiAPQAERBikdIw1DU0CDX0Drcwd9pqtzAh9A/ygAEK1gD0ABVUYpUWMPA1d -Ag1NA63MHfaTrcwITQP9QABFPQA9AAqqGKpajDMNrQINXQOtzB32jK3MCF0D/OAAQ7sAPQAHdxin -p4w6DX0CDa0Drcwd9oWtzAitA/yAAEI4gD0ABEQYpHSMMQ1NAg19A63MHfZ/rcwIfQP8oABCtYA9 -AAVVGKVFjDgNXQINTQOtzB32eK3MCE0D/UAART0APQAKqhiqWow/Da0CDV0Drcwd9nGtzAhdA/zg -AEO7AD0AB3cYp6eMNg19Ag2tA63MHfZqrcwIrQP8gABCOIA9AAREGKR0jD0NTQINfQOtzB32ZK3M -CH0D/KAAQrWAPQAFVRilRYw0DV0CDU0Drcwd9l2tzI0g/UAART0APQAKqhgITAOqWgysAgxcA6y7 -HPZWqt2su6t3+kBoFesAPQAHdxinp6e7myMIWwMIqAMLewILqgOqmRr2TY8hnSCqmfiAAEJ4gD0A -BEQYiSKkdAhIAgh3A6dmF/ZGpJmZIqdm9qAAQrWAPQAFVRilRKT/nyHRDwAAbBAGiiCIISMWAApJ -CykmAOqbCnoYBIAAKIwBKCYBA9tS+wAARfVKGQDrJgEiBLmAAPKAAEUwTAUA5MwMBVBhAAD8YAe7 -ogCdAIsQWMwVJSwY+KBoHaAZBQBtmikpgAEqgAMrgALpgAAs5gKAAAiqEQq6AuyZAg1UAoAACpkC -6YYAJEARAADrVAABUCEAAFv9+C0SAOTeDAJ7AQAA7zMIB2kBAADtFgAh6JOAAMBgixAKbBGry+w8 -DArQBIAAWMv40Q8AAOUsGCnrkAAA9mBoHeAGBQDiEgAhICEAANpQ+kBoHeBMBQBYy+74oGgdoBkF -AG2aKSmAASqAAyuAAumAACzmAoAACKoRCroC7JkCDVQCgAAKmQLphgAkQBEAAOpEAArYBIAAW/3S -53zAIzAFAADiLEAj6p+AAGP/cesSACngBIAAWMvW0Q8AAABsEAyjRhX16yciECkiESkWBShwcytS -FSxQUPwhBhWgiAkA6BYOK1AEgABYy8od9eOKGCwSDhv14PrAAEUwMtUA4qQALmdCgAALywjtzAgF -2BMAACuyGSzAgOwWDyVQBQAAWMu8jxiOHytSFyxQWK/u98AAQzAPBQAvZAItcHPsFgkncAkAAK5E -8oAAQ3DdEQDtFg4rUASAAFjLrooZHPXHix6qaiKkAAy7CyywgJwf67IhJVAFAABYy6ePGY4fK1IZ -LFBgr+73wABDMA8FAC9kAi1wc+wWCidwCQAArkTygABDcN0ZAO0WDitQBIAAWMuZihoc9bKLHqpq -IqQADLsLLLCAnB/rsiElUAUAAFjLkY8ajh8rUhuv7vfAAEMwDwUAL2QCLXBzLFBo7BYLJ3AJAAD+ -gABCMN0BAONGCAboOQAA7RYGK1AEgABYy4Id9ZyKGxv1mYwWqmoipAALywvrsv0uZ0KAAA3MCCzA -gOwWByVQBQAAWMt3jRuMFytSHa3Mps72rhAVoA0FAO3kAiZgCQAArETjSggLYASAAFjLbRX1iaZE -GPWImByjRiJkAOtxNijoBIAA6AAFCPgEgAD+AKgd4A6lAP4ghhXv/GUAwJBtCB7asA67LQy/KK+q -qloqoADq1AAu0ASAAOSwDmboBQAAY//YAAAAAAAAACmkAXobLNsQbQgi7LAAJvP/AAAp4P/s5P8l -U/0AAOm0ACXYBQAA6rsJduv9AABj/9YAAC8QAPHhwA3gAgUA2RBtCAwokAGxIuSACmTIBQAAY//s -AAAAsWrrFAAJYASAAFjLPffqqgWgClUA/eqyBaA7BQDsFg0paASAAFjO/eJgeCFYBQAAq0QrYh+j -SuwkAAVQBQAAWMswjhzpEgUhWAUAAKtE8oAAQ3A61QAqZADpkhko6ASAAO4EBQjgBIAA/ASoHa/7 -ZQD8IIYVoA6lAMDwbQge3JAOmS0LmCiozKxcLMAA7NQALtAEgADkkAlm6AUAAGP/2AAAL6QBehss -2xBtCCLusAAm+/8AACzw/+70/yVT/QAA7LQAJdgFAADquwl26/0AAGP/1gAAKBAA8QHADeACBQDZ -EG0IDCqQAbEi5KAKZMgFAABj/+wAAACxausUAAlgBIAAWMr/+gCiHaA7BQDsEg0paASAAFjOwSss -AQtECBv1ECKwoANKCCqsAeuyKSlgBIAAWMrz7hIMITAFAACmRPKAAENwP9UAL2QA6XIZKOgEgADu -CAUI4ASAAPwIqB2v+2UA/CCGFaAOpQBtCB7YkA6ZLQuaKKqIqFgogADo1AAu0ASAAOSQCGboBQAA -Y//aAMDALKQBehss2xBtCCLvsAAmw/8AAC6A/++E/yVT/QAA7rQAJdgFAADquwl26/0AAGP/1gAA -KRAA8SHADeACBQDZEG0IDCqQAbEi5KAKZMgFAABj/+wAAACxausUAAlgBIAAWMrD+gCiHaA7BQDs -Eg0paASAAFjOhSssAQtECBv01CKwqANKCCqsAeuyKylgBIAAWMq37hIMITAFAACmRPKAAENwP9UA -L2QA6XIYKOgEgADuDAUI4ASAAPwMqB2v+2UA/CCGFaAOpQDA8G0IHtiQDpktC5ooqoioWCiAAOjU -AC7QBIAA5JAIZugFAABj/9gAL6QBehss2xBtCCLusAAm+/8AACzw/+70/yVT/QAA7LQAJdgFAADq -uwl26/0AAGP/1gAAKBAA8QGQDeACBQDZEG0IDCqQAbEi5KAHZMgFAABj/+yxausUAAlgBIAAWMqI -FvSf+gCiHaA7BQDsEg0paASAAFjOSeJgsCFYBQAAq0QrYi2jSuwkAAVQBQAAWMp87hIMIRAFAACi -RPKAAENwP9UAL2QA6XIXKOgEgADuEAUI4ASAAPwQqB2gAqUA/CCGFa//ZQD6IGgd4AoFAG0IHtiQ -ApktD5worIioWCiAAOjUAC7wBIAA5JAIZugFAABj/9IAKuQBfrs56uQACNgEgAAPAgDTD9MPbQgi -77AAJsP/AAAugP/vhP8lU/0AAO60ACXYBQAA6rsJduv9AABj/88AACkQAPEhkA3gAgUA2RBtCAwq -kAGxIuSgB2TIBQAAY//s4xINI1AFAADrFAAJYASAAFjKRvxgaB2gClUA/EBoHeA7BQBYzgmkIrIi -0Q9sEA4V9F4kIhCUHiZQSCdCByRAcytSE+dyDinQBIAA/MBoHaBEMQBYyjaXFRv0Thj0TuY6CAon -QoAAC0sICEQI9JAQFaA81QAspADrvQQlUAUAAOuyGSpgBIAAWMoppkorUhWEHvNAAENwBwUA52QC -JVAJAACaGCZQUCRAc6Oqmh/8wGgdoEQ5AFjKHRv0N4ofC0sLJLCA90AARTA81QDspAAlUAUAAOuy -ISpgBIAAWMoUpkiEGCkSDxz0MQSECPkAAERwClUA9wBGHeA7BQDtIhgiIAkAAFjN0YgeKIBy7SIY -JBppgADApf3oTAWgOwUAWM3KKSIYK1IXo0b8qxAVoZnhAOwWECTICQAA6RYJK1AEgABYyfod9BUq -EhAb9BGMGfrAAEUwPtUALqQAC8sL67L9LmdCgACtzCzAgOwWCiVQBQAAWMnuLxIQjhorUhmv7qbv -J/QCLSIYLFBg7BYRJ3AJAAD+gABCMd3xAONGCAboCQAA7RYLK1AEgABYyeAd8/sqEhEb8/eMG/rA -AEUwMtUAIqQAC8sLK7L9DcwLLMCA7BYMJVAFAABYydUtEhGMHCtSG63Mps0mUGjn1AImYAkAAKxE -40oIC2AEgABYycwY8+imRKNGImQA6AAFCKgEgAAFAmGVFBXz4i9QAJgd9iAmHeACBQDvFAAngNmA -ANkQbQgMKJABsSLkgAlkyAUAAGP/7AAAsWrrFAAJYASAAFjJtxbz1foAoh2gOwUA7SQAC2AEgABY -zXmxK6tEG/PPIrCwA0oI5hYGJVAFAADrsi0pYASAAFjJqo4d6RIFIVAFAACqRPKAAENwOtUAKmQA -7gQFBMgHAADpFgco6ASAAOmRlCjgBIAA/ASoHa/7ZQD8IIYVoA6lAG0IHtyQDpktC58or8ysXCzA -AOzUAC7QBIAA5JAKZugFAABj/9oAAAAnpAF6GyzbEG0IIuywACbz/wAAKeD/7OT/JVP9AADptAAl -2AUAAOq7CXbr/QAAY//WAAAvEADx4ZAN4AIFANkQbQgMKJABsSLkgAdkyAUAAGP/7LFq6xQACWAE -gABYyXgW85b6AKIdoDsFAOwSBiloBIAAWM054mC4IVgFAACrRCtiLwNKCOwkAAVQBQAAWMlsjh3p -EgchWAUAAKtE8oAAQ3A61QAqZADpkZUo6ASAAO4IBQjgBIAA/AioHa/7ZQD8IIYVoA6lAG0IHtyQ -DpktC58or8ysXCzAAOzUAC7QBIAA5JAKZugFAABj/9oAAAAnpAF6GyzbEG0IIuywACbz/wAAKeD/ -7OT/JVP9AADptAAl2AUAAOq7CXbr/QAAY//WAAAvEADx4ZAN4AIFANkQbQgMKJABsSLkgAdkyAUA -AGP/7OMSBiNQBQAA6xQACWAEgABYyTr8YGgdoApVAPxAaB3gOwUAWMz9pCKyItEPH/NWHvNWD90B -Dt0B/EMGFe/yngBsECaHN+MWQilQBIAA6hY/KcAEgADncg4qkASAAPRANOCQBQUA2lAZ8tuGjxPy -2ymSJSMyh6lmCWYRpjODN/JhyBXgGYUAeSED0qDRDxvzPyaw9NpA67I+K2AEgABYyRf2gABFMcuF -APpgAEXwPNUALKQA7DACJVAFAABYyRApMAKmmegSPyTIBQAAKRZBpJkpFkAllAAoghAZ8r4W8r+C -hymSJYiPgi4mYof5AABEdG1FAO0tCAxGQoAAqGb2wOgVoogFAAgrCCqw3CZiDiXUDyXUDiXUDSXU -DCXUCyXUCiXUCSXUCCXUByXUBiXUBSXUBCXUAyXUAiXUASXUACyw5PGBcA3gAwUAbQgMLLDlsTPk -wAdl2AUAAGP/7BzzDeoUACDoEQAAldCV0ZXSldOV1JXVldaV15XYldmV2pXbldyV3ZXeld8l1hAl -1hEl1hIl1hMl1hT1oqYV4DsFAPwmxhWgClUAWMycGPL7HvL9H/L7GfL4HPL77BY3INARAACVoJWh -laKVo5WklaWVppWnlaiVqZWqlauVrJWtla6VryWmECWmESWmEiWmEyWmFCWmFSkWAy8WBf4gxhWg -OwUA+CCGFaAKVQBYzIO0GvogaB3gDBUAW/yR/eXIBaAKVQD8JwYVoDsFAFjMeyoqgKpoK4Ao0w/x -YZAN4AwFAG0IDC2AKbHM5NAJZEAFAABj/+wAACsqqOtrCADQEQAAW/x//eWmBaAKVQD8JyYVoDsF -AFjMafxgaB2ja0UA6ysIANARAABb/HYiFjX95ZIFoApVAPwnRhWgOwUAWMxfKBIBIhwc+KMABDA8 -9QDozAwA0BEAAPsAAEU/iwUA66QYIJgxAADqrBkmQdeAACsKAFjIl/hAaB2gGQUA0w9tmikpgAEq -gAMrgALpgAAs5gKAAAiqEQq6AuyZAg1UAoAACpkC6YYAJEARAADqNAAJWASAAFv6byocHJWglaGV -opWjlaSVpZWmlaeVqJWplaqVq5Ws9UGmFeAAVgAAAAAAw8f5jwAOMAsFAFjIefhAaB2gCeUA0w9t -mikpgAEqgAMrgALpgAAs5gKAAAiqEQq6AuyZAg1UAoAACpkC6YYAJEARAAAtEgIuEgHuFhUpWASA -AO0WFinQBIAAW/pN+GBoHaAJRQDTD22aKSmAASqAAyuAAumAACzmAoAACKoRCroC7JkCDVQCgAAK -mQLphgAkQBEAACoSNfpgaB3kbEUADwIA/UAARTAcBQBYyEX95OYFoApVAPwnZhWgOwUAWMwHG/Jk -KhJADwIAI7D8KqwB67JAKeAEgABYyDoqEkHr8mgR4AUAAKyqKhZB9UAARTA91QD6KAYVoAwlAO2k -ACVQBQAAWMgv9+S+BaudxQD84DmkYgCdACvKHPrgOUxiAJ0AIjqAAnsILrDk/XyQFeXuEQAObggu -4IAutGT/fLAVoD8FAOsWPi7vAoAAD90B/XywFaPuIQAO3QINbQgt0IAttGUtsOb/kAAWMD7FAA7M -Aft80BWh3TEADcwC/MAARjAINQD9kBAVoAlFAOy0ZiXYEQAAbZpi6HkIBdgRAACziPMgAES1qgEA -qmoqoIAqtF8qkOQKKkWqaiqggCq0YCqQ5CyQ5QyqEf9ABAVzzCEADKoCqmoqoIAqtGEqkOUskOYO -qhH/QAQFMcwxAAyqAqpqKqCAKrRiKpDmIhI+++QqBaXKAQCsbCzAgCy0Yygg8yqgBCokevpPZh2l -mBEACWkI6ZCALEcCgADTD/hPBh3gOQUACYgBqG8v8ID+TyYd4BKFACoSQCs65Ot7CAlgBIAA6xY9 -JVANAABYx9otEkGzLq7epO8l9AAsco79wCAV4As1APwoJhXozLkA/WAKBiIAnQD8JsgVpGhFAPjg -AEQyiQUA+OAARPOCBQCiciIWPiaQ3yIg7CKU3CWEACWEASWEAiWEAyWEBCWEBSWEBiWEByWECCWE -CSWECiWECyWEDCWEDSWEDuWEDyD5gQAAlfCV8ZXylfOV9JX1lfaV95X4lfmV+pX7lfyV/ZX+JfYP -JfYQJfYRJfYSJfYTJfYU9eKmFeAKVQDyK4YdoDsFAFjLcBvx0Brx0Bzxzu3xzBDxgQAAleCV4ZXi -leOV5JXlleaV55XolemV6pXrleyV7ZXuJeYPJeYQJeYRJeYSJeYTJeYUJeYVLRYaLBYbKhYd+iOG -FeAKVQD8JugVoDsFAFjLWCocYPorgBXgDBUAW/tlwKX8JwgVoDsFAFjLUShKgKh4L4DU8eZADeAM -BQBtCAwpgNWxzOSQVGRABQAAY//s0tDRDwAT8bAmMCzaQOsyDCtgBIAAWMd7pkryepAV4DvVACuk -ABvxm7Gq67JiKeAEgABYx3QoEkKmPOTMCAZQCQAA9YBGHe/kpgAAAAArWlTrewgA0YEAAFv7QsCl -/CcoFaA7BQBYyy78wGgdpHtFAOt7CADRgQAAW/s6wKX8J0gVoDsFAFjLJi0SGPovABXgPPUA+ieG -FeXdGQDtzAwA0YEAAPugAEU/iwUA66QYIJmhAADqrBkmQdOAAMCwWMdd+CeIFaAZBQDTD22aKSmA -ASqAAyuAAumAACzmAoAACKoRCroC7JkCDVQCgAAKmQLphgAkQBEAAOsSPCnQBIAAW/k1Lhx4leCV -4ZXileOV5JXlleaV55XolemV6pXrlez1waYV4ABWAAAAAADDx/2PAA5wCwUAWMc/+CeIFaAJ5QDT -D22aKSmAASqAAyuAAumAACzmAoAACKoRCroC7JkCDVQCgAAKmQLphgAkQBEAACsSPC0SGS4SGC4W -LO0WLSnQBIAAW/kU+GBoHaAJRQBtmikpgAEqgAMrgALpgAAs5gKAAAiqEQq6AuyZAg1UAoAACpkC -6YYAJEARAAD6YGgd5GpFAPrgAEUwHAUAWMcOKgoF/CdoFaA7BQBYytEb8S4qEkEmsOSkquuyOitg -BIAAWMcFKxJBHvEfGfEgprsrFkH1YABFv/1lAPooBhXgOtUA6rQAIMH9AADpAAUEWQUAAPoAqB3g -BqUA6xY0JEEFAADcIAYiLQ0vKK/MrOwswADshAAsYASAAOUv5WRABQAALRx/5cQBJukFAAB82ypt -CCLv0AAkM/8AAC5g/+9k/yZj/QAA7tQAJugFAADs2wl0Q/0AAGP/1gAAKBx/KIxBKYAA8SFwDeAG -BQBtCAwpgAGxZuSQB2RABQAAY//sKhJA6xx/K2AEgADqrAEl2QUAAFjG0foAoh2gOwUA7PDsG2gE -gABYypMqEkGxa6uqG/DuKhZBJrDspKoqrAHrsjwrYASAAFjGxC4SQeoSPSN4BQAAr+4uFkH1wABH -MAsFAP4oBhWgPdUA/cAGHeCMBQBYxsUmupz24AtMIgCdACjKHPjgCvQiAJ0AIjqAonouoOQT8OH6 -J8gV5e4RAK4+LuCALrRkLaDkLqDl/6AAFrA/BQD/oAQG8+4hAA7dAq09LdCALbRlLKDlLaDm/5AA -FjA+xQD/gAQGMd0xAA3MAqw8/ZAQFaAINQD9bMYdoAlFAOqg5iXYEQAAbZpi6HkIBdgRAACziPMg -AES1qgEAqjoqoIAqtF8qkOQKKkWqOiqggCq0YCqQ5CyQ5QyqEf9ABAVzzCEADKoCqjoqoIAqtGEq -kOUskOYOqhH/QAQFMcwxAAyqAqo6KqCAKrRiKpDmLBI+/+FCBeWKAQCoOCiAgC/wBCi0Yy3A8y/E -ei/Ee/+gABW13REA/GAARvA+BQAOuwGrOy3QgC3EeCuwgPuPJh3gE4UAKhJAG/Cb+0AgFaAMJQBY -xmkqEkArEj3qrAMp4ASAAFjGZSISQbM4qCKkKOWEACEQBQAA0Q8AAAD/5+ANr/L1AP/+8A2v8/UA -bBAIF/AQFPAQJiIQlhQkQocnciWIZ4VvJmByiI6nVefwhRquQoAApUSERyVwJJgR63IKKdAEgADk -Qg4q4ASAAFjGSh3wZevwYhtnQoAA9GAARXA21QAmpACryyuy/a3MLMCA7BYCJVAFAABYxkCKEqWq -JXCEKhYD80AARXALBQDrpAIlUAkAAOtyIirgBIAAWMY2jBOlxaNaJqQCK0AI8WHQDeAMBQDZQG0I -DC2QCbHM5NALZMgFAABj/+wAAAAA6qwDIlghAABYxiguQAjxwbAN4AkFAARKAm0IDC+gCbGZ5PAI -ZVAFAABj/+wApZXyoABFcAgFACikBChA6OSBA2KoEQAAK3CMarEfo1zqciQuSASAAG25Ei2gAO2U -ACVQBQAA5NAxZMgFAACrVfKgAENwP9UAL2QALkDo8cKwDeAMBQDZQG0IDCiQ6bHM5IAZZMgFAABj -/+z7gABFcAkFAPlABh3v/x4AAAArCujrSwgDUAUAAFjF/SxA6PGBkA3gCQUA2kBtCAwtoOmxmeTQ -B2VQBQAAY//ssp6uVfKgAENwBAUAJGQAjxQv8HJo8WEoIhgicNz65wgV4DPVAPrAaB2ieMkA53wG -KWAEgABYxecb8AAc8AGiaiOkAAx8CyPAgOt7CwVQBQAA67L9KeAEgABYxd6iOKWCpojkhAIhEAkA -ANEPwEDyoABDf/52AAAAACtyMCxwvOwWACtQBIAAWMXTixGOEC0agK29rlXyoABDcDrVACpkACnQ -8PEhkA3gDAUA2dBtCAwvkPGxzOTwB2TIBQAAY//s/CCmFeJ4BQDouwgDUAUAAFjFwIkVK5Dw8WGQ -DeAKBQDdkG0IDCzQ8bGq5MAHZugFAABj/+yyra1Vo1b0wAYdr/xiAABsEATwQlAN7/vVAIQ3iT4q -MAWETguZAfhhxhXgmFUAeKEiKAqQeKEcwCDRD/oAQh2gOwUA7O/aGegEgABYyWvAINEPAAAmIhGL -aimyEhzv1CMmEOs2DCTIBQAA+WJGFeAKVQD8kcgV4DsFAFjJYC9Cjh7vzBzvzfxDCBXhj+EA7v4B -DEECgAD5xgAPMo/JAPMYABQx/7kA6O4CD/pCgAAP3QL/pgAOsApVAPxDBhXgOwUAWMlOHe+9JTIN -LiIYKEKP+qDoFaCPpQAP7gL4wyYVoA8VAP5CxhXgCwUA/ELmFeAMNQDuJhglUIEAAFutGOOmACrY -BIAA80AmFaANJQDvMHItcASAAP9CZB3gCQUA6eYGLOAEgADp5gIpUASAAFgEIyIKAAYAAGwQSBvv -HRrvHhnvHiuwfSiiLSmShyMWheUWgCxGQoAA6YgIBfxEgAAsCoCsjPwwxhWgADIALSqArY0tFoaI -J4iOIqIlK4KFqyIJIhGikvaACWCSAJ0A5e9xEPkBAADvFoQgmIEAACMWguUWgSQwCwAA9jBmFaHH -BQD13foF4AYFAPPd9AXgAUoAKRKE0w9tqgUIAIYJAmGnZvYhJhXuSAUAqEQuIgctIgL93u4FoApV -AP/BSBWgOwUAWMkC6iQACNgEgAD8BAIdoA0lAFuOb/aABViSAJ0AKiIHKqwgW6WFKxKB2BD8MMgV -4O8VAPoACB3gKQUAbZoCCAJhjiCTEJUSLxQY/cAAFzAvBQAP7gKeES7QBy3RLg4OQQDuEQ7dAh7v -WysSgigSgw7dAp0UDOownBUnFQ8IIIYLAmMIAIYoEoULAmEIaAj0//nrIBrFACkSgBvu5dMP6hII -JIBRgAALqgIqFggqEoTsRAAMWASAAFjFDZQZ//ykDaAEBQDAINEPAABsEASKNwVCCPtByBWgCwUA -KyQAJUAA82BoHeA8pQD8oAkUICnFAGRRMm0IELEzpDUnUADscQp6wASAAMhyY//oACdQAStUAPjl -Bg3gAwUAynD1AGgd4AMFAG0IESdQArEz6XEOcqgFAADIdm81BGP/5wAAqDzrxAEhgoGAAPgMAh3g -BwUA9QBoHeB8pQD6ById4Cj1AG06LSNQAXOLCnOzB/J6ABXgAFoAc5sLc8MI8nUgFeAAIgAAIzzJ -B3cK43cJAqgFAABgAAHAcPwAAh3gDAUA8ABkDaAr5QAukACxmA6JOexcAgygBIAAsd1o1DcjQADk -P/RuZgKAAPpnZg3gCAUAwFBtCBoFVQrjVQkEQAUAAKSJI5AA5D+/YqtBAAB7Mbdj/94AAOymkiUw -CwAA9sREHeACBQDRD9lA//5sDaAFBQAlQAErRAD4pEYN4AMFAMla+IBoHa/75gAlQAErRAAPAgD4 -oOYN4AMFAGVf4/iAaB2v+/4AbBAEG+7kCzsLI7CA2iDrsiEp4ASAAFjEpRvuvRjuvw1EEatLqEQk -QIDyYABFMDzVAOykACVQBQAA67L9KmAEgABYxJqkPPOAAEcwDQUA7eQCJhAJAADRD2wQBIYg+mAE -ANAEFQAAQxp2MATAINEPAAYzAuMmACmQBIAA0Q8AAABsEBKCN4IuIyqAoyQrQN/sItYlgymAAC/A -AGTwWiU6gPRAAEdwCAUA7uD0JYzzgAB/6TTasG0IJui/DAUM8QAA6IwBJVP9AAD34AnREgCdAKKO -rI8v8ACl7i7g9H/pCGP/0gAAAAAAAP/gCCOiAJ0A/8AH8+AIFQAc7pIpQNz4IgYd4AYFAJYQlhGW -EuYWAyDAUQAAloCWgZaCloOWhJaFloaWh5aIlomWipaLloyWjZaOlo8mhhAmhhEmhhImhhP3AoYV -oApVAPcCphWgOwUAWMgdHO6AGO57He59Hu587+56EMhRAAAmlhUmlhQmlhMmlhImlhEmlhCWn5ae -lp2WnJablpqWmZaYlpeWlpaVlpSWk5aSlpGWkJ8Ynhn8IUYV4ApVAPgg5hWgOwUAWMgGKhwU+iIA -FeAMFQBb+BTApf3czAWgOwUAWMf/KEqAqCgqgNTTD/FDwA3gDAUAbQgMKYDVsczkkCxkQAUAAGP/ -7MePZI8CwKL93NAFoDsFAFjH8sAh0Q+ijqyPL/AApe4u4PRj/tIrWlTrKwgA0FEAAFv3+sCl/dya -BaA7BQBYx+b6IoAVpGtFAPpAAEXwHAUAW/fywKX93IwFoDsFAFjH3ogVJBws+KMABDA89QDozAwA -0FEAAPsAAEU/iwUA66QYIKhxAADqrBkmQcuAAMCwWMQX+IBoHaAZBQBtmikpgAEqgAMrgALpgAAs -5gKAAAiqEQq6AuyZAg1UAoAACpkC6YYAJEARAADqVAAKWASAAFv17ykcLJaQlpGWkpaTlpSWlZaW -lpeWmJaZlpqWm5ac9yGmFaAAVgAAAAAAw8f5jwAOMAsFAFjD+fiAaB2gCeUA0w9tmikpgAEqgAMr -gALpgAAs5gKAAAiqEQq6AuyZAg1UAoAACpkC6YYAJEARAAAtEgYuEgXuFhkqWASAAO0WGirQBIAA -W/XNwJRtmikpUAEqUAMrUALpUAAs5gKAAAiqEQq6AuyZAg1UAoAACpkC6VYAIqgRAADs7fsQ0HEA -AIiij6OJoZkRLxYDKBYC+0AIFaA7BQD6IAYVoApVAFjHisCg+CBoHaAbBQBtuhMsgACiq6O7K7Dk -sarryQt0QAUAAMAg0Q8AAAD9YNYNr/j1AMCBZI/rwKL92+IFoDsFAFjHesAh0Q8AAGwQBiggAPEX -oA3gBAUAbQgIsUSiSimgAMiRY//wZCFjZEFgZDFdwLP1YArAogCdACqt/yyg/8P9/4AKZGIAnQDA -0MLP+g9CHeAltQD+C0IdoGoFAPCXMA3gBgUAwLDivggJuASAALS4+9CAFeAJRQDoFgIo8ASAANMP -bZqMKrB8AKoy/0AH7GIAnQDsoSF12AUAAPVEJg3gSAUA+wQqDaBZpQB6khn7V+AVoAECAAAA8AE4 -DaA69QDwARgNoDrlACgKYPsCKg2geaUAepIJ+1cgFaAAYgAAAPuABUGgOJUA+wAFAyIAnQC0quCp -MggECoAA80AEdhIAnQD1IAQ2kgCdAOrkACdwBQAAKRACKxAD/TAAFzDIBQD5wAQHNbsBAA67Ai4Q -ASt0Av/AABQw+wUA+wAEBHOZEQAJiAIrEACJEih0Af9wABWw+MUA+WAEBbHuIQDuuwIDMAUAAOt0 -ACzYBIAA4r4IA7gNAAD1P/ezogCdAP4LQh2gagUA+g9CHeABLgDHL9EPKqD+wJL7WGAV4A4VAAue -OA5LDAsNQfWgCLESAJ0AadMP/0AJRGIAnQD9bwAKf/o2AMCi/dr+BaA7BQBYxwfHL9EPAAZoCegW -ASaH+YAAAmYK5myEKLgEgABt2XgkYHwARDJ/QZbsQR9zMAUAAPSD5g3gSAUAdIofdOIc9JfgFaAA -7gAAAAAAAPABBA2gNPUA8ADkDaA05QB0qgx0sgn0lyAVoABiAAAA9Z/6gaA5lQD1P/pDIgCdALRE -AEky8p/53hIAnQD1P/mekgCdAOR0ACO4BQAAjxEqEAD6IDAV4PjFAOP8CAf4BQAA7xYBLVeCgAD5 -QAQFMeshAA6qAurEAC6dIAAAKRACghH/YAAUMPoFAPsABAQzmREACYgCojnolAAhEAUAANEPAAAA -AAAAAP9f96xiAJ0AwKL92nwFoDsFAFjGxccv0Q+CEdEPwKL92nQFoDsFAFjGwMcv0Q8AAGwQBCYg -APDFAA3gBwUAAiUCbQgMJFABsXfkQAdiqAUAAGP/7Msiy3DKPvwHIh3gK/UA/g9CHaAPFQD+7OAH -0GwFAPdgBtKiAJ0A96AGk6IAnQD42gAVoAA2AMcv0Q8AAChsyeg0ACgECoAA9uAFCRIAnQDAoQp4 -DOmMASRACQAACZg780AARLCIjQAPiDVtin4ikAEmkAByuxVy0xL4WgAVoACeAGpxZ///JA2gCgUA -4ssUcUMlAABy4wz4VSAVoAAmAAAAAAAA5rsUfBAEgAB20wz42gAVoACGAAAAAAAA5ssUc0MlAAB2 -4wz41SAVoAAmAAAAAAAA46QIDH8CgADvLwIEyAkAAO9EACVQBQAA5HwBI5AJAAAEQjsCEhLRD/ef -+eKiAJ0A99/5o6IAnQD41SAVr/y+AGwQCCMiEQ8CAC8wBRXs5v5gCBWgdCUA/oAEauIAnQD6AKId -oDsFAOzs4BnoBIAAWMZkLzAFKApz9eKGDaACBQD54An0IHlVAPngCnRiAJ0AwKX92awFoDsFAO4y -ACnoBIAAWMZXZCCXgjgc7DgtMAQiIhGOMP5gsBXgClUA8koQFaA7BQBYxk4oMAWJMnhLb2SQjdow -/dhcBaALBQBbmWrRDwAAAAAAAPxACBXgClUA/dmABaA7BQBYxkEvMAX158YNoHoFAHrxNiIwUIQ4 -+mBoHaALhQDsJAAA6FEAAFuZgM2tKywY6jQACeAEgABbrA7aMP3ZYAWgCwUAW5lT0Q/RDx7srY1A -Dt0CnaAMLBGlzIsV68adKdAEgABb8BfRDwAc7AwtMASOMP5hyBXgClUA8iAGFaAIBQD4ICYVoDsF -AFjGHxTsBSpCF2SgdfpgaB2gC4UA7RwQKWAEgABbmWBkoE4e6/6NPsDAnKEO3QKdoOxGFylfAoAA -pbuJFCm2ndEPgjgvCnQvNAX+QKYd4AIVAP5gsBXv+uoAiTgoCncoNAX5IKYdoAIVAP5gsBXv+ooA -KywY6jQACeAEgABbq9pj/s8rLBjqrAEp4ASAAOpGFynQBIAAW6vUY/62bBAMKCAFKQqV+QAJfGAG -BQD92OYFoApVAPxjCBXgOwUAWMXwKTIY/AAiHaGEBQD/IoAK0anxAPVACQiRueEA9WAIyJIAnQCF -J4VeK1KQpFQmRJGNMC1Wh+xEkiWBYYAAGOxhHOvUHexg6LsoCdAEgABbRZca7F4pMhgKmQLpNhgp -0ASAAFtFdhvrxBrrxfnXygXvnCUALCQFKqItKZKDK7B97+u6HVZCgAD7IABEsI0FAOrruBX8OIAA -/SAARPAALgAAAC4qgK6ZHuuxJkSRjCCfEPogxhWgDUUA7hYCLmYCgAANzAKcESuQByiRLgsJQQCZ -EQmIAgqIApgUD+ownxXmFgciyAsAAOlmAADQgQAACgyKCUCICgiKCSCICgSKCQCICgCK6iQACNgE -gAD8AIIdoA0lAFuLHdEPANogW0VEiC72RuQdr/nlAAmIAfhBxhWv+v4AAAAAAAAA+mBoHaALBQD8 -AAIdoA0lAFtHh9EPAAAAbBAGKCIYJCIQ+OAABDCJtQB5gQTAINEPAIs3/WFIFaAHRQD72CwFoAkF -APdhKBWgDwUA8ZKgDeALBQCNY/WgCWASAJ0AwKXs7A4VqMEAAP6gaB2gOwUAWMWGJyAH+kBoHaF3 -AQDsVAAL2ASAAFt7F+mkAAUMkYAALKAB+iAGFaAORQD/QAYdoI0FAA3MAiykASpCE7GrK0YT+yNm -HaiqHQD7I0YdqKodAPsjJh2oqh0AKpQYKCIW+SPmHaiIHQD5I8YdqIgdAPkjph2oiB0AKJQcjWMv -YgT1oAV4EgCdAC2UF/8iZh3gCAUA+SDmHaitHQD7IsYdoAgFAPkgxh2oqh0A+yKmHaj/HQD/IkYd -6KodAPsihh2o/x0A/yImHeAIBQD5IKYdqP8dAP8iBh3gCAUAKJQE6iQACdgEgADsdAAK6ASAAFt6 -vIo3+gBiHeAMBQD7RAAVoA01AFuld8Ag0Q+Nk9aQ+b/24FIAnQAroICxuwsIQfjvAA+wDgUACO84 -q/z/jQAN//r+AIYQHes2/dd6Ba/79QArZBcsZBb8wqYd4P71AC5kFCpCELGqKkYQW0cWG+uy+sJm -HajKHQAsZBL1cBAVqMwdAPzCJh2ozB0A7GQQI1DBAADrsiEqYASAAFjBXLFN/MDmHejdHQD8wMYd -6N0dAPzAph3o3R0A/MCGHe/8zgCOOGXuCIkuGuue6jYLIfiBAADvlgEhQOEAAJg5mTj+QcYV4AIF -ANEPAABsEA4mIhCIN4pniYqFiYqu6hYPJJUhgAAc65GNII5gKVET+CAGFeAKVQD4zlAVoDsFAOgW -ASr4BIAAWMUBLCAHGet5DAxBDMgRqYgqgp4sFgv8IcYVoCslAPtAIpviAJ0AJIKdF+tNZERNBEgC -9gAIHeApJQBtmgIIAmGMVsnF61ICIlFBAABYwSeMVvuGABWgACIAAADDoCsiGAveQfPB4A3gCAUA -9cATEJIAnQDXgI8pjiqnx/TmABXhpwEAClkMtJkKlTkP7gz1wA6b4gCdACsgFioK/3qxDfpA8BWg -DAUAW4WcZKPdHethGOteKSEHHutd6utbEti9AAD6jgAN+pkBAOsWDCzPAoAACpkCmUDsIgAi+EEA -AC9GAy5GByhGAu3NAg5mAoAADLsC/ICGFeAKVQDrRgEq6ASAAP3WmAWgOwUAWMS++iHoFeBNNQD8 -hAYd4IgVAP5DCBXgCQUA+IRGHeNcJQD4hGYd4I0FAP1gAEWx/2kA/wIADvAOdQDu3gIH+/0AAO/t -OAJQoQAA/CGmFeAMZQBYwOIuYhIqYhD+heYdqO4dAC5ELltGi/qGZh2ouh0A+oZGHei7HQD6hiYd -6LsdACtEMCpiE4kd+odmHaiqHQD6h0YdqKodAPqHJh2oqh0A+ocGHaAMFQD8QsgV6OcdAPyGph2o -/h0A+IQmHeiPHQAoRCQvRCUuRCYtRD/2hOYd6N0dAPyHxh3o3R0A/IemHejdHQAtRDyKKfpCqBXg -DAUALEQ0paqluysmFZopiR4a6vfoEgwszwKAAAqZCCiWnSsgFi8K/3+xCuogByrgBIAAW4UliDiN -OfEBAA3gDAUAnDuY0I44neGcOJw5ijf6AGId4AwFAPtEABWgDTUAW6ScwCDRDwAAAADqJAAK2ASA -AFuEK2SuIok4ZZIOYAJGAAD/9XANoAUFAIcfKSqAqXcvcN1k8bL8AOId5uvJAP+/7q4iAJ0A8+AL -P9IAnQDB2P+/7h5iAJ0A6kwIC1gEgADszCApUASAAFv3Wteg/KDIFa/2ogBlzZ6qS+sWECXYgQAA -6xYJKVAEgABb9kAuURPtEhAtYASAAPXACyiSAJ0AGOrPLoCAauEfrarrgiEtQASAAG3pEi+wAO+E -ICXYBQAA5PDcZEAFAAAb6sYf6owOzAgsFgr9gABG8DrVAOrUICDAQQAA5wAFDEgEgAD4AKgd4A6l -APghBhXv/GUA2bAOuy0Muiiqman5KZAA6YQALFAEgADlv+VkQAUAAMCw66QBINhBAAB6uyLusAAk -e/8AACzw/+70/yVT/QAA7LQAJdgFAADqs+F0Q/0AACgcECmAANMP0w/xIRAN4AcFACqAAbF35a/3 -ZEAFAAAq3CHsdAAA2EEAAFjARScWEvoAoh2gOwUA7OpgG+gEgABYxAeIGicSEqh3snf8oMgVr/H2 -AAD/QABFsAkFAPlkBh3v/HIA5xYRK1gEgAD6gABGMA0VAOzMIClQBIAAW/cBLhIRLeDdLwr+D90B -7eTdLTgEgAD8oMgVr/DWAACqS+u8IClQBIAAW/nL16D8oMgVr/B2AADrEgkpUASAAFv0S/dAaB3v -/iIAAAAAAAD/7sANoAQFAIwiZMCFjThk0F3AINEPixvaIOu8EilgBIAAW6m1jDhlz+ePLhjqaOg2 -CyHogQAA7fYBIXDhAACeOZ84/EHGFeACBQDRD4wuHepf7TYLIdCBAADqxgEhWOEAAJs5nDj6QcYV -oAIFANEPiC4Z6lbpNgsh8IEAAO6GASF44QAAnzmYOP5BxhWgAgUA0Q+LG9og67wYKWAEgABbqZZj -/2cAAABsEAqSGJUZ9oALWJIAnQDyAAIdoAYFAPAA6A2gN9UAAPdgCXRiAJ0AwNAmbOr0gsAVr+ul -APwAAh2gDgUAihiPGQtrDKs7ry9bRiOiovaACTiSAJ0Ao28r8ABkv8L3YAeMYgCdAGpBv9vw/oAA -QvANBQBtCBousAGx2u2kAAXgBQAA68QABwB5gAB34Qp1ygRj/94AAHfpkSjAAcCw68QAJXAFAADk -g6FmYAUAAPXAG4miAJ0AwOBtCBOx7q3rr7kpkAHkkApl0AUAAHSqBGP/5bG6BKkMCbo476gIBUgF -AAD3IABDMAsFACuEAOlEDAzYBIAA99/6KZIAnQBk4ogvwADTDw8CAGTyfRXqByVSqpkQ6lAAJw3j -gAB/qXD0ICYV4AsFAG0IJuvpDAXYBQAA9SASoJIAnQD3IBLpEgCdAIoRrLUlUACquiqgAHWpQGP/ -0ijwAf3gIBWgCQUA6fQAJBe5gAD2gBN5EgCdAP/9EA2gDQUAAMAg+gCiHaA7BQDs6esZaASAAFjD -V9EPANXwixCfF3pTEfVCFg3gDxUA8AAgDaAPBQAAAMf/ZPHZFeneJVKmwPDqUAAnDOOAAIgXlRZ4 -qSxtCCbv6QwH+AUAAPUgDaCSAJ0A9yAOcRIAnQCKFqz1JVAAqvoqoAB6WQRj/9KFF3pTEfVCFg3g -DxUA8AAgDaAPBQAAAMf/ZPF5FenGJVJswPDqUAAnDOOAAIgXlRV4qSxtCCbv6QwH+AUAAPUgCqCS -AJ0A9yAL6RIAnQCKFaz1JVAAqvoqoAB6WQRj/9KFF3pTEfVCFg3gDxUA8AAgDaAPBQAAAMf/ZPEZ -FemuJVJUwPDqUAAnDOOAAIgXlRR4qSxtCCbv6QwH+AUAAPUgB6CSAJ0A9yAJYRIAnQCKFKz1JVAA -qvoqoAB6WQRj/9KFF3pTEfVCFg3gDxUA8AAgDaAPBQAAAMf/ZPC5FemWJVKEwPDqUAAnDOOAAIgX -lRN4qSxtCCbv6QwH+AUAAPUgBKCSAJ0A9yAIQRIAnQCKE6z1JVAAqvoqoAB6WQRj/9KFF3pTEfVC -Fg3gDxUA8AAgDaAPBQAAAMf/ZPBZFel+JVJuwPDqUAAnDNOAAIgXlRJ4qShtCCEP6QzokTln+AUA -APcgBeESAJ0AihKs9SVQAKr6KqAAelkFY//XAIUXelMP9UHWDeAPFQDwABgNoA8FAMf/Zfy0wKX9 -0tIFoDsFAFjC1ccv0Q+KEay1JVAAqrr7QBAVr/eqAIoWrPUlUACq+iqgAGP+OooVrPUlUACq+iqg -AGP+i4oUrPUlUACq+iqgAGP+3AD0gARgkgCdAMCRwOD/IABEcA0FAO2EACTYBQAA92AAQzANBQD6 -jwAKf/D2AIoTrPUlUACq+iqgAGP/AIoSrPUlUACq+iqgAGP/TQTrDAuuONng/yAARHAOBQDuhAAk -2AUAAPdgAEMwDgUA+o8ACn/v3gAE6wwLrjj5wGgd7/9aAGhBFP/+DA2gCRUAAAAAAAD//dgNoAkF -AP/9uA2gCQUAbBAQKiIQK6IKKKAF+2EIFeCdJQD9AAlkYAYFACMiES8wBRXpDP5gCBWgdCUA/oAE -uuIAnQD6AKIdoDsFAOzpBhnoBIAAWMKKLzAFLApz9eKGDaACBQD94Ay8IH1VAP3gDTxiAJ0AwKX9 -0foFoDsFAO4yACnoBIAAWMJ9ZCDBIjIIHOheLTAEIiIRLjIA/mCwFeAKVQDyShAVoDsFAFjCdCgw -BYky+IAEuqIAnQBkkO/aMP3QpgWgCwUAW5WPwCDRDwAAAAAAAAD8QAgV4ApVAP3RyAWgOwUAWMJl -LzAF9evGDaB6BQB68VYiMFCEOPpgaB2gC4UA7CQAAOlRAABblaTNrissGOo0AAngBIAAW6gy2jD9 -0agFoAsFAFuVd8Ag0Q8AHujRjUAO3QKdoAwsEaXMKxIV68adKdAEgABb7DrAINEPH+g5jKcushiM -zg/uAv9jBhWhiwUA+4AARfAINQAotJIvoAX9//WNYgCdAC76lS6kBR7oLRnoTh3oKi7iLSmSgy3Q -fQnuEa6Z8aAFr9IAnQAvCoD/IABE8AK+AAAc6BmPPo4w/GCQFeAKVQDyIAYVoAgFAPggJhWgOwUA -WMIsFOgRKkIXZKDv+mBoHaALhQDtHFApYASAAFuVbc+vKywY6jQACeAEgABbp/tj/r6KOCkKdCk0 -BflAph3gAhUA/mCwFe/5hgCMOCsKdys0BfuAph3gAhUA/mCwFe/5JgAY5/qPPpahCP8Cn6DmRhcp -dwKAAKXuLRIU/dOmFeACBQDRDwAtKoCtmR/n9Ca0kYigHufx/iCGFaALRQDvFgYsRgKAAAuIApgV -G+ftmxotkAcpkS4NDUEA3RENmQILmQKZGAjqMJgZlhvpzQIg2MEAAAlgiAsMiglAiAsIigkgiAsE -igkAiAsAiiscEPwAgh2gDSUAW4dgY/1gKywY6awBKeAEgADpRhcp0ASAAFunwmP922wQDi0wGC8w -GS4iFuQwGi7uAoAAD90C7zAbLu4CgAD1pgAOsAVFAOQiEC7uAoAA/6YADvAGBQD/oAplIIcFAC7s -AS4mFi4wAf3Q0AWgTQUADwIA/cAEBvAKVQD3wAQHcDsFAFjBzoVNKlIHKwoA+0QAFaAMNQBbpaIb -6B7WoOsABQ1IBIAACQJhCQJhCQJhLEByZMGyiVfA4C5lEo2aLmURlGDkIhAmm+mAACaSCSsgB/pA -aB2huwEA+iImFeA8BQBbd03jpAAFIPmAAC4KBi6kACxhEg8CAAfNAu2kASYAkYAAL2ER/0KmHej/ -HQAvpBQqQhCxqipGEFtDj/piZh2ouh0A+mJGHei7HQD6YiYd6LsdACs0EChCEyqMAfqCZhWomB0A -+GNGHej5HQAvNBn4Y2YdqP8dAC80GC4iFiwSEfqgaB3gPQUA/mPmHajuHQD+Y8YdqO4dAP5jph2o -7h0A7jQcKVAEgABbdv6KV/oAYh3gDAUA+0QAFaANNQBbobnAINEPAACCR/3QMAWgCiUA8kHIFaA7 -BQBYwYAd52wY52wa520Z540ogH37RagVoEt1AOmSgyFgCwAAK8QR70IALVZCgADqmQgEfDSAAPcg -AETwACoAACoqgKqZnRYa51kY51mYEuoWAC/+AoAABf8CnxEukAcskS4ODkEA7hEOzAINzAKcFAvq -MJsV5hYHIUgLAADpZgAA0IEAAAoMiglAiAoIigkgiAoEigkAiAoAiupEAAjYBIAA/ACCHaANJQBb -hsjAINEPLDAELjAFLTAB7zAGLmYCgAAOzALuMAcuZgKAAA/MAgjMEe7MAgHYwQAA86ANthIAnQD6 -gGgdoA0FAFv4FS8wFCgwFekwFi/+AoAACP8C6DAXL/4CgAAJ/wII/xEI/wKfYy4wEC8wEegwEi92 -AoAAD+4C7zATL3YCgAAI7gII7hEP7gKeZC0iGCMiEPzgAAbwjrUA/7/1FSIAnQCKV4iq6eewFAp5 -gACGqS1iA/WgCnASAJ0A/gACHeAKBQDDsOznqRUgwQAA/oBoHaAKVQBYwSErIAfTDw8CAPpAaB2h -uwEA6xYQKmAEgABbdrHppAAFDrmAAC+gAcCEKKQAB/8CL6QBLTITsd4uNhP9Q2Yd6N0dAP1DRh3o -3R0A/UMmHejdHQAtpBgsIhb9Q+YdqMwdAP1Dxh2ozB0A/UOmHajMHQAspByNYyoWEvWgBqgSAJ0A -KmIELZQX+yJmHaALBQD7IOYd6M0dAP0ixh2gCwUA+yDGHejMHQD9IqYdoAsFAPsgph3ozB0A/SKG -HaALBQD7IIYd6KodAPsiRh2oqh0A+yImHaiqHQAqlBDqJAAK2ASAAOwSECpoBIAAW3ZYilf6AGId -4AwFAPtEABWgDTUAW6ETwCDRDwAAAAAAAAD/8hgNoAYFAPqAaB2gDRUAW/eoY/xawNCN0/m/9dBQ -BgUAKpCAsar6IAAFsA9FAPvvAA/wCAUAC484qv7/zQANf/qCAAAmEhId5sn9zqAFr/v1ACtkFyxk -FvzCph3g/vUALmQUKjIQKqwBKjYQW0KpG+dF+sJmHajKHQAsZBLzcBAV6MwdAPzCJh2ozB0A7GQQ -I1DBAADrsiEp4ASAAFi877E9/MDmHejdHQD8wMYd6N0dAPzAph3o3R0A/MCGHe/8OgCOWGXslIku -GudA6lYLIviBAADvlgEhQOEAAJhZmVj+QcYV4AIFANEPi1hlvGyOLh/nJ+9WCyLggQAA7OYBIWjh -AACdWZ5Y/EHGFaACBQDRDwBsEBwoMAQkIhArMAUsMAbqQgcsRgKAAAuIAukwByxGAoAADIgCiq7q -Fi0sRgKAAPkGAAxwCwUA+CVmFaIMBQBYvM4mMAEpMBgqMCQqFiwqMBkuIhbsMBoszgKAAPsmAAyx -VhEA6jAbLM4CgAD9JgAMsdYBAO0WKizOAoAA+yYADLd2OQD/IT4NoGYxALHsLCYW/c4UBaAKVQD8 -QwgV4DsFAFjAcN5Q/cyyBeBKdQD/zLAF4AwFAOvmVxMN8YAAZHDQwKL9zf4FoDsFAFjAZhvmUR/m -Tx3mTvoI4h2gDAUAGeZQHuZwGOZMKZItLuKDKIB9CZkR+cAAR3CJBQDp6QgEfByAAGAABCkqgKnp -LhItKBqAqOgqhJGIQC8WGvwjBhXgCkUA6xYeLEYCgAAKiAIoFhkqkAcpkS4KCkEAqhEKmQILmQIp -FhwI6jAoFh0sFh/p7QIg0f0AAOlmAAVQBQAACgyKCUCICgiKCSCICgSKCQCICgCK6xxgKlAEgAD8 -AIIdoA0lAFuFqdogW/nGwCDRDwDeUPvf+jwiAJ0ALSIY7ObJH3zCgADTD/+mAA7wClUA/EMGFeA7 -BQBYwCooEivLjOs8MClQBIAA7RItLGAEgABb/GrnoCltSASAAMCi/c10BaA7BQBYwB8b5gof5gn9 -zA4F4Ep1AP/7kA2gDAUAwJAqEiwpFikPAgDxXiAN4Ix1ACsiGA8CAAy7AiwSLGjBev3NVAWgCiUA -6yYYKWgEgAD+gGgdoDsFAFjACu50AAr4BIAA/c1GBaAKJQD8JUgV4DsFAO0WACtoBIAAWMABG+Xt -H+Xr/cvSBeBKdQD/+bgNoAwFAAAAAGR/FmRQ/vi/+JDSAJ0ALhIqZO5S9d/yeJIAnQD+JUgVr/vy -ABzmjo0g+kMGFeAKJQD+gAgVoDsFAFi/7BXmZfJCKBXgDBUALEYT/IKmFaALBQArRhL6gsYV75lV -AClEBf5gsBXgCiUAKkYU/mAIFaB0JQD+gATq4gCdAPoAoh2gOwUA7OZUGegEgABYv9gvMAV08RUt -CnP94CYUYgCdAC4Kdf/gJnwiAJ0AwCDApf3MlAWgOwUA7jIAKegEgABYv8tkLlCCOBzlrC0wBCIi -EY4w/mCwFeAKVQDyShAVoDsFAFi/wigwBfif8VKiAJ0AiTJkkqTaMP3LQgWgCwUAW5LdwCDRDy4S -KmXvEGP9WAAAAAAAAPxACBXgClUA/cxgBaA7BQBYv7EvMAX1/+88IgCdACgKcPn/7uQiAJ0AIjBQ -JDII+mBoHaALhQDsJAAA6FEAAFuS7mWiHyssGOo0AAngBIAAW6V72jD9zDoFoAsFAFuSwMAg0Q+K -TSoWKIqnwLD7RAAVoAw1AFujcSwiGP9AaB2hnGkA9yAgsVIAnQD5P/EJ0gCdAC8Kiw/MAiwmGCsw -HC0wHSxCFOgwHi3eAoAADbsC7TAfLd4CgAAIuwIIuxENuwJ8uQSxzS1GFChAcikwIC0wISswDuow -IizOAoAADZkC7DAPLM4CgAAKmQLqMCMt3gKAAAy7AutGEizOAoAACpkC6UYVLA6uAADHryrmAysi -GPJCCBXnuwEA/3/nJWIAnQApEigpkgcskgrn5e4WH3GAACWSCS1SA/WgH2ASAJ0A/gACHeAKBQDD -sOzl5xUgwQAA/oBoHaAKVQBYv18mIAfTDw8CAPpAaB2hZgEA7EQAC1gEgABbdO/npAAFIjmAACug -AcDU/UAGHeCMBQAMuwIrpAEpMhOxmio2E/jjZh3omR0A+ONGHeiZHQD44yYd6JkdACl0GCgiFvjj -5h2oiB0A+OPGHaiIHQD446YdqIgdACh0HI1T9aAbkBIAnQCOVC10F/7iZh2gDwUA/uDmHeiNHQD4 -4sYdoA8FAP7gxh3oiB0A+OKmHaAPBQD+4KYd6IgdAPjihh2gDwUA/uCGHejuHQD+4kYdqO4dAP7i -Jh2o7h0ALnQQ6xIoKVAEgADsZAAKaASAAFt0lioSKIqn+gBiHeAMBQD7RAAVoA01AFufUMAg0Q8e -5ZqNQA7dAp2gDCwRpcyLFevGnSnQBIAAW+kEwCDRDxzk+Y8+LjIA/GCQFeAKVQDyIAYVoAgFAPgg -JhWgOwUAWL8MFOTyKkIXZKIa+mBoHaALhQDtHBApYASAAFuSTWWhsSssGOo0AAngBIAAW6TbY/0H -AAAc5Zz8gAgV4ApVAP5ACBWgOwUAWL76KUAFKgqV+yAQJCIAnQD9yuoFoApVAPxDCBXgOwUAWL7y -LCIYe84VDOtR9WAOUJIAnQAMzVH1oA34kgCdAIVHJVIO/rIIFaGDBQDyoABB8AkFACk0kSgiAPiw -5hWgDxUA7zSSJwFhgAAb5WAc5NMd5V/r6ygJUASAAFs+lh3lXSwiGA3MAuwmGClQBIAAWz51/8mG -Be+YJQAoRAUY5MIe5OIv8H0ogi0u4oMJiBHo7ggH/DyAACkKgPnAAETwACYAKSqAqekY5LMd5LT7 -yWIF4AoFACo0kY9AmxidHpga/eAAF7AIRQAI/wKfGS6QByyRLg4OQQDuEQ7MAg3MApwcC+ow6xYN -IsgLAADqFg8g0QEAAAngiAocignAiAoYigmgiAoUigmAiAoQiuscICpQBIAA/ACCHaANJQBbhB0q -EiiKp/oAYh3gDAUA+0QAFaANNQBbntfAINEPjDgrCnQrNAX7gKYd4AIVAP5gsBXv7O4AjjgtCnct -NAX9wKYd4AIVAP5gsBXv7I4AG+R+iT7AgJihC5kCmaDoRhcpFwKAAKUijxT+U6YV4AIFANEPKxIo -KBIpLxItkqGUoClAcvnCZB3gDAUA/8BGFeANJQDo5gYpUASAAFv5dMAg0Q8rLBjqrAEp4ASAAOpG -FynQBIAAW6RYY/r6AAAA+kBoHaALBQD8AAIdoA0lAFtAYWP/LtpAWz4Qi07A0PyG5B3v/OUADLsB -+oHGFe/3ogAAAMDQjdP5v+DgUAUFACpwgLGq+iAABLAPRQD57wAP8AgFAAmPOKr+/80ADX/wCgAA -AMe/K3QXG+TmK3QWG+Rd+uKmHeD79QArdBQqMhCxqio2EFtAQRvk3friZh2oyh0ALHQS83AQFejM -HQD84iYdqMwdAOx0ECPQwQAA67IhKeAEgABYuoexPfzg5h3o3R0A/ODGHejdHQD84KYd6N0dAPzg -hh3v8d4ALhIojuhl6DUpEiiKLhvkyOuWCyT4gQAA76YBIUDhAACYmZqY/kHGFeACBQDRDwAAAGwQ -CBrk1ogihCj4QYgV4HuFACskBStEBSRCEQqZAvhBhhXnNQEA5EBQJAE5gAD8Y+CBUAwVACU8/gXF -Odog7OTIGtgEgABbkUnAINEPAAAAABzkxC0gBI4gjy70f8AV4AgVAAWFOfQgBhWgClUA9CAmFeA7 -BQBYvhsW5LuKYGSgZfpAaB2gGwUA7RwQKmAEgABbkVzo5LYVAzmAAP5ByBXgDQUALaQJjigI/wKf -oI7pnqEc4/SdYOkSBCpfAoAArLvptgAhlHUAAIon+gAiHeAMBQD7RAAVoA0VAFueNNKg0Q/AINEP -ALGr7CQACVAEgADrZgAiWGEAAFuj1GP/PCtMGOokAAlgBIAAW6PQY/8rbBAMGOPhG+PiGeQCKIB9 -K7ItKZKD+kBoHaCMBQDjOjkN3kKAAOuZCAR8MIAA/SAARjAAJgAsKoCsnO3kPBjIBIAA80HeDe/7 -9QD6YWgV4AAaAAAADQCHCQJhCQJhCQJhCQJh5AceAMiBAAAJAmMEAIYJAmEd48MZ48GIoB/jwp8W -+CAGFeAORQDtFgIsRgKAAA6NAp0RKcAHLcEuCQlBAJkRCd0CD90C7RYEL2AEgAAJ6jCZFSUUMfoj -hB3gDwUA/iDmFeANJQANiALoFgko2ASAAFuDMtEPbBAEFOOtKCEME+OsJEIlIzKHqEQJRBGkM4Q3 -LCAThE7IyessICJQIQAAWLntLCASyMwqCujqSggBWAcAAFi56Cv6hes0BSmQBIAA0Q8AAABsEAQY -45kpIQwU45kogiUjQoSpiAmIEagzijf0kUgVoAsFAPtByBWjPAUAWLnlikorIQz8AAIdoA0VAFud -eBrjmPpBhB2v+fUAmTvRDwAAAGwQBBXjhyRSiopKKKECIyEMyInbMFulL8iowCDRD8Ag0Q8AAOpC -CinYBIAA/AAiHaANFQBbnWUY43gogiUlUoSoOAmIEahVhFcsIBOETmTACussICJQIQAAWLm5LCAS -yMwqCujqSggBWAcAAFi5tIxQnCWTW/JBhB3vi1UA61QFKpAEgADRDwBsEASJNw8CACiSCiUiEOaS -CSQG0YAAJyAH+kBoHaF3AQD64Ggd4DwFAFtzAeSkAAUGIYAAKgoGKkQAKGESKQqACYkC6UQBJACR -gAArYRH6gqYd6LsdACtEFCpSELGqKlYQWz9D+oJmHai6HQD6gkYd6LsdAPqCJh3oux0AK0QQKFIT -sYr6omYVqJgdAPiDRh3o+R0AL0QZ+INmHaj/HQAvRBguIhbccPpgaB3gPQUA/oPmHajuHQD+g8Yd -qO4dAP6Dph2o7h0A7kQcKVAEgABbcrOKN/oAYh3gDAUA+0QAFaANNQBbnW3AINEPAP/8mA2gBgUA -izjIssAg0Q+OLh/jyu82CyHggQAA7OYBIWjhAACdOZ44/EHGFaACBQDRDwBsEAgsMpL7xnAFoUWF -AKU1K1F+JTKTJqKbKaKtKKJM5KKzKzZCgAD4wABDcI4FAG2JEI1njd4o0nf1AAU8YgCdAK5mwGCK -SC6hAmThRo9JL/ECZPE+nBebFlukihjjBRPjIiiCJCMyreqICA04BIAA6kIJLEZCgACoM1ukgosX -ljoiNhIY47KXPR7jrRzjrylgOR3jrC02ECk0UCw2EZ4/HOMSLmEaqKiYFS/Cs58UKDUw7/EjJwkx -gACKFv/GNg3gDQUAjBT8AAId4A/lAG0ID7Hd7fMadmAJAAAowSN44w9j/+kp0nqxmfmvRhXv/WIA -LPqufDECLTRSHOOVKDBSL2ILLmA4LWA59GLmFeb/AQDrNhUv/8KAAPplhB2n/wEALzRT8iAmFaAK -VQD4IAYVoDsFAFi83xzjh41IFeLriBUt0QIuUk2TEOkyACv4BIAA+CAmFeAKVQD4IEYVoDsFAFi8 -1Mo8LyBywGL6wGgdoA4VAA/qOf1OoADQDAUA9UAFuRIAnQDGSshN2jBb6kvSQNEPAMAs0Q8AHONv -/GAIFeAKVQD+YOgVoDsFAFi8wSggcpMq6TIMJAWhgAAa42gKmgKaPIsuBrsC6yYOKdAEgABb6ZTS -oNEPAAAAAPogyBWl3sUA/9/4S+ANBQBj/tQtUrOL1i3cGH2xSS6yASiyACjmAC+yAC72ASy2AOy2 -ASWCoYAA7TIAJfP/AAAt5j6JPCy8+Jw3+yYADLAEBQD4YYYV7/1aAAAAAC9Ss4v0L/wQf7kL//0A -Da/0RQAAAAAAiLGNsJ2AibCYkZyw7LYBLf2mAAD//IANoAQFAPhhhhXv/VIAbBAMH+J5HuJ5GOJ6 -G+J8GeKcKIB9K7It6ZKDKVAEgAD8UAIdoA1FAOQ0ES3eQoAA65kIBHxAgAArCoD7IABE8AAeAACs -mRjiaoygnxCeEugWBi5mAoAADcwCnBErkAcvkS4LCUEAmREJ/wII/wKfFA7qMP4gphWgDQUA7RYH -IMiBAAADYIgJDIoDQIgJCIoDIIgJBIoDAIgJAIrbEPwAgh2gDSUAW4HY0Q8AAGwQBOLiVRkYBIAA -DwIAJCKKKEILKIEC98ScBaCKZQDlIoQkCtGAACkyBShiJQmICAmIEQhVCClQBXqRBSr6hipUBYpL -W6PHHuJOKGImJ2InJiKEqoLqdwgJFkKAAOJiCAu+QoAA9sAAQ3+YZQD4wKYdr58FAP5Aph3gByUA -JyYU/kIGFaAHFQAnJhMnJhUtMgj8QAgVod3xAO0kcilYBIAAW0jO+kDoFa/79QArJhEpMgUmJg2V -K4Wu+mBoHeFcBQD4QeYV4AMFAOMlNyLQCwAAWLhpKlKI0w/TD/9BoAEQDSUALCBzDcwCLCRz/0Gg -ANAPRQAuIHMP7gIuJHP/QeAAkAmFACggc9MPCYgCKCRzCo1X/0GgAVAMNQArIHMHuwIrJHP9gaAd -4B8FAC4gcw/uAi4kc/hACBWjWoUA6loIAuAHAAAtwZItJTYswZMsJhcrUosrJhkpUoz4QwYV4nzF -APiwxhWgCwUAWLhPi02TKeMmCCXYBQAAm03RD8Ag0Q8AAABsEDYrIhGLt4u+LbAA/KAABvA69QD1 -oAZ+ECw1AP2gBnwgLkUA/6AGfCAvZQD/pAYN4DglAPmgBTwiAJ0AetEMwKL9xTwFoDsFAFi78dEP -AAAjIhApsAGEN+RCDiTjwIAAKLAYKbAZKiIW7LAaLEYCgAAJiALpsBssRgKAAAyIAgiIEQmIAuqJ -B3VIBQAAKSYWKrACZa+12iBb9W0rMHJpsaorTQL6IGgdoVwFAFi4ERzhxRrhxhnh5izAfSqiLSmS -g8Cy6xQQLVZCgADqmQgGfMCAAC0KgP0gAETwAKoAANogW/kv0Q8A2iBbQb7RDwDaIFv7LtEPANog -W/ne0Q8ALiqArpke4a4d4az9w1gFoAsFACsUEYgwLBZW/CqGFeAKRQDuFlosRgKAAAqIAigWVS+Q -By2RLg8PQQD/EQ/dAg7dAi0WWAzqMCwWWesWWyDQBwAA6qxwKMgEgAAJYIgKDIoJQIgKCIoJIIgK -BIoJAIgKAIraMPogICXgDEUA+2oAFeANJQBbgRTRDwBsEAwe4iWNNBXhjhThi4g2K1I7JEB9L1I1 -/KWoFauIAQCYHP+gBAawiQUA7RYJLmZCgADvzAgCfFSAAJsdqcj4IUYVoABWAAAAAAAA+iGmFeKN -BQCtzZ0ahhyHOCRSJIU5lximROcxDyomQoAApPQmQgpbkN6PIJ+gjkwc4i78QwgV4Bh1APhAhh2i -7sEA6iYHL3WCgAD/pgAOsDsFAPxDBhXgClUAWLt3HOIjih0rIAeIGh7iIi1gOfkA5BWgCQUAKSUb -rt4u4IApYDcvYDaVLCUmFCUmEyglBykkDf5Bhh3gCYUA+ECmHeD/tQAPuwGIGJgr6CYJL3eCgAAO -uwL/w2YF4P7FAA67AQ27Ah3iDCskByvyiigmFfnxiBWgDiUA+6GSDeP3YQALWQytmSkmFIvDLcII -KcIGC4gI+R/gFaC7TQDouwEMggqAAPvgAIUwu50ADrs3/WEADfD/9QAPuzYrJCMqoSIqrNj6IWYV -76oBAOpFJyPgNIAAKqz0CgpPKkUn/UGAF1CLBQD6hOQd4IoFACtgQBbh6yskFojDKiUaCGY2f7EL -KiAHCgpBW175CmY2KyEbZLC5AioCW5mShhgc4eGNJy4gBC8gBYkbmRD4QUgVoApVAPggJhWgOwUA -WLsoHOHajRyOGSQmESJGCO5GDiFQ4QAAKiYO+kHmFaB5NQApRAUpJAUvMgQlFgAmFgEoQAUnFgP4 -IEYVoDsFAPhACBWgClUA+CCGFaf/wQBYuxT9w44FoApVAPyCSBXgOwUAWLsPiifAsPtEABWgDBUA -W57ljE8b4b/rpgAmAHmAAOtCEilQBIAAC8AAwCDRDwAALCEaDG0sDcwc/ENkHa/85gAAAABsEAYq -MRLUIOjhsh0QdAAAeoMVKSIT4pQABIWpgAAqJSHwABgNoAIFAMEmKUIVGuDwKZEuHOFI+yAElCGb -BQCKR4quH+DaHeDXq6vsAAUNyASAAAkCYQkCYQkCYQkCYRzg0i5CFYhALaZk/01GFeAJRQDspmYs -RgKAAAmIAiimZSjgBy7hLggIQQCIEQjuAg/uAi6maA3qMP1NJhXhuQUA+UAARPAMBQAspmsDIIYJ -AmMDAIYJAmEurQHz2MYdoAxFAPqCqBWgDSUAW4A+0Q8W4YEqYouKoC+hAsn6W6I7GOC2KIIjImKF -qogJiBH4QABBMAAmAAAAAMAgzCb//KwNoALFAClCFS1AOS5AOC9ANyhANoUnKkEai0uFXiJGEyQm -FC8kNy4kOC0kOSkmFeolGiLgEQAA6yYLIVDpAADsJhEiWOkAAPhGxh2gDGUAWLbkKmKLmhCKoYcn -KKEC53IOJAE5gABbohmJEBvhWymSEAurKKuZKpUC9yAGFeALFQD7IMYd4AAaAMCQ6VZgJPtxgAAn -YouKcYYnLKEC5mIOJgEpgABbogkb4UwpchALqyirmfsgRB2gCBUAKJQG9yAGFaAAGgDAkOlWNCT5 -iYAAKjESHOFC/EFGFa/5FgAAAABsEAQc4T/8YkQV4ApVAP5CaBWgOwUAWLqBKjES1SD9Q8BBUA4F -ABjhMnqDEykiE2SSwSuRIeq7DA8oBIAAC5U4ZFKphFeETixCNGTCrilMUAPghgkCbwPAhgkCbQOg -hgkCawOAhgkCaQNghgkCZwNAhgkCZQMghgkCYwMAhgkCYS9CNBvg5v3AsgWmE4UAo/b2hqYVok3l -AP3gphXgBhUAJkY2KCA+KiA/h1Ad4RbuRjctUgKAAPkAABQ3l0EA6ogCDM4CgAD5BgAMd3cBAAh3 -AudGOCrQBIAAWzoL2lBbOe4iQjTAsA8CAPJAAEVyTOUAWLaP+oAIFeYa5QD6QABFNh2FAPxAAEb/ -9fUA9aAGFeAMZQDl1QIl2OkAAFi2eBzgzffAcgXls0UAoyP0cKYd4A0lAPxuhh3iTgUALjR19nHG -HaBLRQD2ceYdqJUdAPpw5h3oiR0A+HBmHaAPhQAvNHAnNHEsNHn4cIYd4AoFAPpwxh2gSTUA+HEm -HeZa5QD6QABFMAxlACw0kP5uUBXgFxUA9m9mHeiIHQD4cEYdoEcFACc0ePZvRh3j/wEA9+YAD/D3 -BQD34AQH8AdVAAf/Ai80cvqACBXgCAUA+HEGHaIuxQD+cWYdoA0lAO00iiXY6QAAWLZGC+owGuDH -KKJ/+WAJA6IAnQAd4MUrpn8qon79qKgV4AwFAFi9pBzghCpqRqoqrLv6cuYd6LsdAPpyxh3g6wUA -+oAARfAMRQBYtjTANvvBbgXnKuUA+kAARTAMRQBYti8b4EciQjX7cSgV4RilAKgiIyQHJyQEJiQF -JiQC9kAmHaAdxQD8QSYd4B6lAP5BBh2gDzUA/kDGHeA4dQD4QGYdoDlVACkkACywAPGCAA3gCgUA -2bBtCAwskAGxquTADmTIBQAAY//sAAAAAAAAAPpBZh2gPcUA/EFGHec6AQDsNAABUDEAAFi2DKI+ -9cGGHeANJQAtRjaKQPqGiBXgLEUAWAY8wCDRD8Em0Q8AAAD1wGgd7/UiAPygCBXgClUA/cEIBaA7 -BQBYucPALNEPAC+ifrH//0/GFe/7bgAAAABsEAgc4Hz8YkQV4ApVAP5CaBWgOwUAWLm4KjES1CD8 -YUgV4AcFAOngaR0QnAAAepMfKSITZJMQK5Eh6rsMC6AEgAALlDjMSNQg8AGEDaASZQCFR/nA0gWg -igUA5VIOJoExgAAmgp4pgrAogk8JZhGpZm2JEItni74rsnf9YAZsYgCdAKpmIlJ67FJ4IQgxgAAc -4FstUncuUnj+r8gV4ApVAPIgBhWgOwUAWLmTwSAsQhUd344swS79gAR8YZsFAIpHGN94iq4d3+Ie -33erq+0ABQ3IBIAACQJhCQJhCQJhCQJhGd9vj0AtQhUopmb/TUYVoAhFAOmmZC/+AoAACP8CL6Zl -L9AHLdEuDw9BAP8RD90CDt0CLaZoDOowLKZp901mFeG5BQCpqQMghgkCYwMAhgkCYSqtAfNYxh2g -DEUA+oKoFaANJQBbft7RDxzgLS5gOI9gnRH6IAYV4ApVAP3gaB3gOwUAWLlkZG8Y9N/4rCIAnQCN -IP7HEBWgClUA/cBCBaA7BQBYuVzyDGIdr/yGAACLOuoyCyWM4YAALVJ+esECKlZ4ijwvUnd60QIq -Vn6OOv/ADFRiAJ0A+GBoHeAIFQDoVmEi0AcAAAkghgoCYwkAhgoCYQnghgoCbwnAhgoCbQmghgoC -awmAhgoCaQlghgoCZwlAhgoCZRvfvxzfMu3gAhpQBIAAWzj22kBbONmGUB7fMiJSYPJhSBXgDyUA -/qwmFeYa5QCqKvvARBXgDGUA7uIAIOhBAAD/oAYVoCmlAOvVAiMg6QAA6SYFKlgEgABYtWIrHBDy -IMYV5hqFAPpAAEUwDGUAWLVcJRIGHd8d/742BeYq5QD6QABFNaOFAPJAAEHwCUUAKTSD/m+mHeAO -hQD+b4YdoAxlACw0gvxwJh3gCBUAKDR/+HCmHaALhQD6cAYd4AgFACg0fug0hCpYBIAAWLVF9nHm -Hej3HQD+ccYd5j6FAP5AAEc4/x0A/nGmHej/HQD+cYYd6NUdAPfARB3ozR0A98AGFeicHQDpNJYr -UASAAOU0mSlYBIAA/HLmHaAINQD8cwYd4AwlAPhAxh2gDSUAWAViwCDRDwAAAAAAJ1Z3J1Z4J1Z+ -J1Z1//WoDaACBQD04Ggdr/PmAGwQBBzfro0g/kCQFaAKVQD+YrAV4DsFAFi44xfezRbezRXezRTe -3vhBSBWgCgUA/jYCHeGbBQD9vmQFoY0FAPEIqA3gbkUAKSIVKZEudJF4hCeETqtL7AAFDcgEgAD4 -AKgd4AhFAAkCYQkCYQkCYSkiFYwgJ0ZkJkZm5UZqLmYCgAAIzAIsRmUskAcpkS4MDEEAzBEMmQIF -mQIpRmgI6jCvSSpGayhGaQMghgkCYwMAhgkCYa1N/6jGHaAMRQD6QqgVoA0lAFt+KsAg0Q8uMBVo -4Wz1wAQLkAiVAPnABGQgCbUAeeEx/b7sBaAKVQD8QAgV4DsFAFi4rMCg/b4CBaGNBQD6MgId4b8F -AP/84A2gHmUAAAAAAADrNAAJUASAAFv+Gt6g/EAIFeAKVQD9vsoFoDsFAFi4nMAg0Q8AAAAA6zQA -CVAEgABb/tn/QGgdr/9aAAAAAAAA6zQACVAEgABb/ZL/QGgdr/76ABzfV/xACBXgClUA/mJkFaA7 -BQBYuIopIhMqMRPqJRokgDmAACqVGioiFQ8CACqhLvVABMwiAJ0AiieKrhze1isakAurCOwABQ3I -BIAACQJhCQJhCQJhCQJhLiIVLyIAJaZq90zGFaAIRQDnpmQv/gKAAAj/Ai+mZS/gBy7hLg8PQQD/ -EQ/uAgXuAi6maA3qMP1NJhXgDAUA/U1mFaG5BQAJqQgDYIYJAmcDQIYJAmUpGoD5QABE8AgFAPko -xh2gDEUA+kKoFaANJQBbfc7/+6QNoA4FAGwQCoMngz4c3yEtIgD+bCgVoApVAP5sSBXgOwUAWLhS -KDJhZIPmKTJhGt4597x0BeANRQD1IB6okAQFACsyYf+9QAWhnwUA9byKBeG8BQDm3jIVlHUAACgy -YfUACfmSAJ0AJDZi5DZhKhAEgADRDwArMmIY3jb1YA4LUgCdAC2BAoyAhTDiMmAl+AUAAP5sRhXg -DiUA/mwmFaYa5QCqKvJpSBXgK6UA7BYAIrDpAAD8IEQd4AxlAOsmBStYBIAAWLRj+iBoHeYahQD6 -QABFMAxlAFi0Xh3eHvm8PgXmKuUA+kAARTWnhQCnJ/jwJh3gD0UA/vBmHeAOFQAudH/+8KYdoAiF -APjwBh2gDIUALHR8/O+mHeALZQD68EYd4A0FAO10fitYBIAA/PCGHeAMZQBYtEb08eYdqNQdAPzx -xh3mPIUA/EAARjjdHQD88aYd6N0dAO10jCrQBIAA5MYAKVgEgAD1gEQdoA41APLzJh3okx0A+PMG -HeiJHQD48uYdqPgdAP7yxh3gDSUA/kDGHaAMJQBYBGTAINEPAAAAKCIVKIEu9QAENGIAnQCFJ4Ve -r1vuAAUNyASAAAkCYQkCYQkCYQkCYY4gKSIVJlZqJ1Zm6lZkL3YCgAAN7gIuVmUukAcpkS4ODkEA -7hEOmQIGmQIpVmgI6jCsXChWaeRWayHIBwAACSCGDAJjCQCGDAJhKBqA+KAARDBvJQD/CMYd4AxF -APpCqBWgDSUAW31BJDZi9GwmFaBiJQDRDwDaIFs3ZRjdwyoySoswLzJMKTJLLTJgnRgpNngvNn6b -FZoU+m7mFaHcBQCsPPxuphWmGuUAqtrugQIl2OkAAJsW6IIAIPghAACY8P/gRB2gKaUA+aCmFeAM -ZQBYs+2KGPrDAh3gDGUA66oIANghAABYs+iKGBjdqP+7UAWlrYUAra38IOYV4A9lAP+wRh3gDBUA -LNR//bCmHaYr5QCrqi7Ugfmvph2gDoUALtSA+iDIFeAIhQD5r4YdoAwFACzUfv2whh2gDEUA/bBm -HaAMZQBYs9ArEggpEgcoEgT5MeYdpj6FAP9gAEc4qB0A+zHGHajKHQD9MaYdqNwdAC2UjCTlAiTm -ACiUmS2UliqUmP0y5h2gDzUA+iCoFaAMJQD/YMYd4A0lAFgD8C8iFS/xLvXgBJxiAJ0AKiIHiq4Y -3dIrGpCrq+gABQ3IBIAACQJhCQJhCQJhCQJhGN1fjyAuIhUmpmonpmYopmT94AAXsAhFAAj/Ai+m -ZS/gBy7hLg8PQQD/EQ/uAgbuAi6maA3qMC2mafVNZhWhvAUA7KwIAcgHAAAJYIYMAmcJQIYMAmUp -GoCpqfUoxh2gDEUA+kKoFaANJQBbfMwkNmL0bCYVoAIFANEPLj0B/bxABaAKVQD8QAgV4DsFAFi3 -UdogWzbrwCDRD2wQDCoiCiggBftBCBWgnFUAfIEB0Q8e3hSLJy2iGIu+Dt0B/UMGFeGKBQD7YABF -MA4VAC6kki0gBXzZ1/26WgWvnSUALSQFHd0sGd1MLMB9LdItKZKDLgqA/agAFrKPBQDtmQgGfDCA -AP8gAESwABoAr5n/ujoF4A4FAC6kkYggHd0Z/CAGFeAKRQDvFgIsRgKAAAqIApgRGt0VmhYskAco -kS4MCUEAmREJiAIKiAKYFA/qMJ8V7hYHJcgLAADpZgAA0IEAAAoMiglAiAoIigkgiAoEigkAiAoA -iuokAAjYBIAA/ACCHaANJQBbfIbRD2wQDCoiCiggBftBCBWgnCUAfIEB0Q8e3PuLJy2iGIu+Dt0C -/UMGFeGKBQD7YABFMA41AC6kki0gBXzZ1/254gWvnVUALSQFHdzwGd0QLMB9LdItKZKDLgqA/agA -FrKPBQDtmQgGfDCAAP8gAESwABoAr5n/ucIF4A4FAC6kkYggHdzd/CAGFeAKRQDvFgIsRgKAAAqI -ApgRGtzZmhYskAcokS4MCUEAmREJiAIKiAKYFA/qMJ8V7hYHJcgLAADpZgAA0IEAAAoMiglAiAoI -igkgiAoEigkAiAoAiuokAAjYBIAA/ACCHaANJQBbfErRD2wQFhXdoiZSsYhtKVJNZIFg59zBFIrp -gADq3Z0Q4YEAAOwWISDogQAA/CQGFeAEBQDqFiIlUUEAAPokZhWgAL4AAAAA9GAGoRIAnQD6AKId -oDsFAOwSIynoBIAAWLa/LlJNsUT+gAhSogCdAOpiCypYBIAAW5a163ImLX8iAAAoUququgmqEaqK -j6yJqnL5zmSQ3o6YZODZazKoZj+lLeIY86AGa5IAnQCMrvOABh+QnyUAK6AF/2AF1GCYVQB4uZ1p -MZqPpxzdcI/+DNwB/cMGFaGLBQD74ABF8AgVACi0kimgBSwKlf0/+6UiAJ0A+bkQBa+ZJQAppAUs -ci0pUqsogH0JzBGsmfEACg/SAJ0ALAqA/SAARLAE7gAALBIiKCAHL+AHKSBA+AIABDD6tQDq/wEM -R4KAAAj/Ai/kByggB/3ACBXg+8UAC/8B+cLGHeGIAQD55gAPsApVAP/A5h3gOwUA/iAAB3D/EQBY -tntj/uzRD2U/Ro+nHNxmj/4M3AL9wwYVoYsFAPvgAEXwCDUAKLSSKaAFLAqS/T/2DSIAnQD5uLYF -r5lVACmkBSlSqyxyLSiAfQnMEeyZCAR8PIAALAqA/SAARLAAJgAtKoCtmfm4mgWgDgUALrSRG9xK -jaAoFhL6IgYV4AhFAOvcSB7uAoAACN0CKxYWLRYRLJAHKZEuDAxBAMwRDJkCC5kCKxIhKRYUCOow -KBYV7hYXJ8gLAAAJYIgLDIoJQIgLCIoJIIgLBIoJAIgLAIorHED8AIIdoA0lAFt7t2P+EgAsKoCs -mfm4WgWgDQUALbSRG9wpjqCYEvogBhXgCEUA69woH3YCgAAI7gKbFp4RLJAHKJEuDAlBAJkRCYgC -C4gCKxIgmBQO6jCeFe0WByfICwAACeCICxyKCcCICxiKCaCICxSKCYCICxCK2xD8AIIdoA0lAFt7 -mGP9lwBsEAwY3BEa3BIZ3DIogH0qoi0pkoP9SAAVMIYFAOqZCAR8MIAA9yAAQzAAJgAmKoCmlhjc -bugABQjIBIAACQJhCQJhCQJhCQJhGdwPKmEuGNv7H9v7+UzGDeALRQAZ2/mOIJ8SmBDpFgYvdgKA -AAvrApsRKGAHCAhBAIgRCKgCCYgCmBQP6jCfFRvc0ATuAv4hZhWgDQUA/CDmFeAMJQCcGQtbAusW -CCG8ZQAA6mQACNgEgAD8AIIdoA0lAFt7Z9EPKyw6+idAFaAMZQBYsipj/9kAAGwQCBzcvhfcvogw -Gdvc4jAIKWgEgACO0CmSI/bxCBXjiAEAmBSpiO/QBCxGQoAAqHcmcgojFgD0ICYVoApVAPQgRhXg -OwUAWLXeHNyu/uAIFaAKVQD+4JAV4DsFAOYWACvoBIAAWLXW6dyoGcAEgADTD21JBQgAhgkCYYow -GNu25YYTJSi8gAD0QAdQkgCdAO5yCiEUyQAAwCB24Rf6AKIdoDsFAOzcmRtoBIAAWLXEYAABwCDa -UOs0AAlgBIAAWLgGwCDRD4tw0w8IuxHrNgMnC4iAAGfvvxTcjhzcDyJyFuwABQpABIAACAJhCAJh -CAJhCAJhHNyH/OFoFeAKVQD+RtAVoDsFAFi1rR/cgxjcgx7bkYl7+RHoFaAMFQDs5q0pUASAAO+Z -AgpYBIAA+dWGFeANVQALgAAS24ciIq0Cgkfo3HcZe34AAI16CN0B7XYKKXsWAABgADEAihT5oAQE -MAsFAPjhRhWgDAUAWGKujnpj/yQALBIEB3oC4MwRCdgEgABYAAIiCgDRD2P/ywBsEA4W3F+JJxXb -cIoqiZ79t7wF77SBAOciFS2YBIAA4q4nfPAEgAAf3FsEDE/1gAiMUgCdAA/PCo/wLBYRmxvpFgov -gCKAAAAAAIggCIgR6Fa/LS1CAAD6QGgdoAt1APxHEBXgDDUAW/9NHdvHIyIW7QAFC0gEgAAJAmEJ -AmEJAmEJAmEc3ED8QWgV4ApVAP5m0BWgOwUAWLVmHdw7iSsY3Dse3D3uVq0p0ASAAOiCjytYBIAA -/SYADPAMFQD4tYYV4A1VAAuAACNSrdMPDwIAA4NH5CIKIYQRgADkFhIhhEmAABzcLigSEi0gOi4g -Oy8gPCsgPZsQKiA+mhEpID/4IEYV4DsFAPggZhWgClUAWLVIEtwZ/bhEBaAKVQD8omgV4DsFAO80 -AAlwBIAAWLVAKlIT6yQACeAEgABYt4PSMNEPjCAIzBHsVr8leRWAAME2+iJGFa/+OgAd3A0NRAH0 -QUYVr/3iAAAe3A8ORAIkFhL0QUYVr/26AAAc3AstUhP+IigVoApVAP4haBXgOwUAWLUnKlITWLeS -Hdt7HtwEnR/tAAULSASAAAkCYQkCYQkCYQkCYRzbJBvb/hnb/h3bCR/b/SogNiggNy/mLe3QfS1W -AoAACogCCYgC+cWGFaDdAQANyzkr5VwpIDgMmREp5MD5t8wF4AoFACrkwfzhkBXniMEA+QABBHAM -RQDogngrWASAAP2gABawDlUA7t0CC9AEgAALgAAZ2+Eski2Ochvb4/IhJhXnzEEA8d8QDeDMTQDj -Fgklj0mAACxwDRna7ypwDOmSgCYeaYAAHtvZHdrjrq4u4H0t0i6s7q7dCd0RrZkpnICPl4/+m/D1 -4CYVr4LVANEP7RYPI1ApAADqFgwhQOkAAJgdwKX9t5QFoDsFAO1kAAnwBIAAWLThixyMHy0SDf+3 -fAWgBxUA7AAFC0gEgAAJAmEJAmEJAmEJAmEc274f274qIgsn5i0v5VwMqgIq5iwp0AAo0AEotAEp -tAAv0AIs0AMstAMvtAIq0AQp0AUptAUqtAQoUqwqIhYZ258s4i39QZAV54jBAOmICgtYBIAA+Q8I -FaAOVQDqFhAu7gKAAP+mAA63zAEAC4AAHdubKRIQLNItiJIb25zyISYV58xBAPMKsA3gzE0A4xYJ -JZUZgAAskA0qkAwZ2qjpkoAmHwGAAB7bkh3anK6uLuB9LdIurO6u3QndEa2ZKZyAj5eP/pvw9eAm -Fa+C1QDRD/wh5hXvh9UA/bcSBaAKVQD8Q0QV4DsFAO5kAAn4BIAAWLSbih/qAAULSASAAAkCYQkC -YQkCYQkCYSoiFpMZH9t9HNtyjiv7tvgF4A0VAC3GLQ/uAivGLu7GLCtYBIAA7NtvGmgEgABYlv/T -oPdf6WxiAJ0AzqqDGfhgABIwCEUA+IYACjAAwgAAAAAAAAAA84BoHe+J1QD5gBCEYgCdAGTCHIQq -9CJGFa/yagD8IeYV74fVAIwfG9tV/AACHeAORQDsAAULSASAAAkCYQkCYQkCYQkCYSoiFhzbUJMZ -/kFoFeAIFQAotVwuti0ttV0e21Md21MtVrDu/gIKaASAAO62LCtYBIAAWJbX06D3X+RsYgCdAGWv -ioQZ+IAAEjAIVQD4hgAKMAAyAPwh5hXvh9UAiR/9tnQFoAolAOkABQtIBIAACQJhCQJhCQJhCQJh -iysd2zwqVq0a2zwqVq8NuwLqIhYqaASAAOtWrCtYBIAAWJa906D3X+EkYgCdAGWvIY4nwEH/wcgV -oAAyAPQAIh2gE2UAF9o1J3KGinEvoQLuFg4ngQmAAFubrRva8ClyEAurKIgeq5kqlQKYkPUgxh2g -ABoAwJCMGunGYCSHGYAAGtomKqKGmhiKoYcnLaEC53IOJoERgABbm52JGBva3ymSEAurKKuZKpUC -JJQG9yAGFeAAGgDAkIoaHdp3KaY06iIKJIRxgAAb2rwLqgL6QUYVoAAaAME2/mBoHeAOFQDzzQAP -8AwFAA/sOOoWEiZYIYAAiCDqFhIsRgKAAOhWvy1XkgAAZTp0Y/pbwDD6IkYVr+uKACf6jefBQH4Y -BIAAZc4vgxn4YAASMAg1APiGAAo/9iIAHNnxLMItqswJzBGsmY+Xj/6b8PXgJhWvgtUA0Q/APPoi -RhWv6m4A0sDRD/RBSBWgA8UA9CJGFa/qHgAe2tMr4Vwu4WQvLDr+IaYV6u4BAJ4s/7W6Bau7AQCb -K54cLeAALOABLCQ7LSQ6KuACKOADKCQ9KiQ8LeAFLuAE/kfGHaAMFQDtJD8r0ASAAFipdRzazylw -DChwDSRxCS9xCI0rLnAULqQUL6UIKKQNJKUJKaQMhBsqJhYvIDorIDubEOogPC0YBIAAmhEpID2Z -EiggPpgT+EfwFe9EAQDpFgQqcASAAPhBiBWgOwUA+CCmFaAKVQBYs8Yc2rYtMAQvcQkpcQj4IAYV -4ApVAPjikBWgOwUA6BYBKnAEgABYs7yDGfiAABIwCCUA+IYACj/tJgAc2aYswi2qzAnMEayZj5eP -/pvw9eAmFa+C1QDRD2wQBoUxKCAEBA5f9OgAAvAZJQD5A2YN4FVNABjZmBLaeA8CACiCIyIiiK6I -CYgRCCIIGdqW/bUoBaAKVQD8oGgd4DsFAPiABAJ/ZAEA5BYAK3gEgABYs5rwoWAN4Ap1AApEAtog -6zQACmAEgABb/gjRD7Fr+oYACn//rgBsEAgkFgIpIgr5tQQFp2UBAOYWAyMUHQAAIzID7iEhJIxI -gAAE6hEIqgL6IIYVoAAiAMCwmxQc2nj8QAgV4ApVAP4giBXgOwUAWLN+/bToBaAKVQD8YKgV4DsF -AFizeYU1FNnxKSA56RYFIsBBAADoFgEiqL0AAPUgBbIUVR0ADJgRBIgIKoKe9UAHw+IAnQAqgp1k -oM4Z2cHpAAUNQASAAG1ZAggCYRjZ8BzZ7pygiSCLEZuj6KYCLM4CgAAJWQKZoSYgNi8gN44U6CA4 -KzYCgAAG/wL3tKQFphuFAOs7CAxEAoAACP8CBv8Cn6SMNSylC/9AxhWgDQUA7aUKJVCBAABYr4mO -FY0TDO4RpO7l5p0mlGkAAIonjRLAwOqsIC7YBIAAW5N50qDRDwDAINEPABzZKorI90AFkJIAnQCI -FQyIEaSIK4Ke9WAGE+IAnQAogp3kgLllW/0AAJvI6oQADHmuAACMIukWACYBCYAAwKX9tFgFoDsF -AFizMsAg0Q8AAAAA//wsDaAKBQArnBjqJAAJYASAAFuZBYwTacKMiicrCgD7RAAVoAwVAFuW/h/a -Hp+gjSAb2h3zQGYV4A4VAOumAi7mAoAA/4YADjA7BQDspgEp8ASAAP20KgWgClUAWLMYwCDRDwAA -AAD4IAYV4AoFAFizchzY+YrIiRD5X/ngkgCdAP/9TA2gCAUAwIDAagamNPeBBhWv/RIAAAAAbBAW -gyeDPhzaA40g/mbIFaAKVQD+ZugV4DsFAFizASgyNvsAQ5ASAJ0AF9jpKDI2FtlvFdj59QAaqRAE -BQAoMjb1AC46EgCdACkyNvUgCDKSAJ0AKzI3sbv6ZuYV4Go1APtAB2LiAJ0A/EAIFeAKVQD9s9IF -oDsFAFiy6hvZ6BzY1h3Y1yuydyQ2NiQ2Ny3SLSzAfQndEe27CAZ8RIAAKgqA+2AARTAALgAAACoq -gKq6G9ky6wAFCMgEgAAJAmEJAmEJAmEJAmEJAmEroS51sX8Z2L6IoPYgRhXg7BUALBQYmRD9AAAU -MAlVAAmIApgRL6AHDw9BAP8RD78CBv8CnxQO6jCeFfokABXgHQUA/CHkHeBs5QDsFDYhyUEAAAkg -hgsCYwkAhgsCYSgyHigWEC8yHyQWEu8WESjYBIAA/mQIFaAMVQD+ImYVoA0lAFt4J8Ag0Q8AHNmy -/EAIFeAKVQDvIDgh8UEAAP4jxhWgOwUAWLKsjSD9s1YFoApVAP5naBWgOwUAWLKnGdiTG9mkLDI7 -LjI8LTI+LTZ+LTYgLjZ4LjYfLDYeLDZ3K7J3HNiMJDY2JDY3LMItKZB9CcwR7LsIBPxEgAAqCoD7 -YABFMAAuAAAAKiqAqrob2OgS2I3rAAUIyASAAAkCYQkCYQkCYQkCYQkCYSuhLnWxfBjYdI+g9iBG -FeDsFQAsFBiYEP3gABewCFUACP8CnxEuoAcODkHpEh4vdAKAAA6+AgbuAp4UDeownRX0JsYdoBwF -AOwVDyDYgQAACWCGCwJnCUCGCwJlKDIeKBYQLzIfLxYR5BYSKNgEgAD+ZAgVoAxVAP4iZhWgDSUA -W3fdGNhjKzIAKTJ3LTJgLRYfKRYa+iOmFeYa5QAK2gjugQIl2OkAAOsWGyD5QQAALvUC+QAIFaYW -hQD54AYVoCmlAPmgphXgDGUAWK6RKhIf8gAiHeAFZQD6KgAV4AdFAPdAAEUwDGUAWK6KKhIfKxIb -/7CSBeWuhQCuri4WHCXkgvPQJh2okh0AKeSAJ+SDI+R/I+SF/8+mHeANhQD9z4Yd6IMdAPnPxh2m -LOUA/UAARTAGNQD50IYdoAxlAFiudCsSHygSHC8SGv8R5h3mPYUA/WAARvifHQD5EcYd6KkdAPsR -ph2oyh0ALISMlNAk1QIvhJkphJgshJYqhJf6I6gVoA0lAPdgxh2gDCUAW/6WwCDRDwAAAADApf2y -SgWgOwUAWLIi/bJIBaAKVQD8QAgV4DsFAO8gOCHxQQAAWLIbKjI0KwoA+iRmFaYdhQD9QABFckzl -AFiuWi4SI/pgCBXmGuUA+8AARTYfhQD/wABHf/31AP3ABhXgDGUA7eUCJdjpAABYrkMuEiMY2AP7 -sSwF5lrlAPvAAEU1v0UAr+4uFhn7zyYd4AwlACzkdPnOJh2gSQUA+c8GHeJNBQD9zqYd4A+FAP/O -Bh3gTTUA/dEmHeAPBQD/0MYd4AklAPnRRh3gSEUA+dDmHaAMBQD90QYdoivFAPvRZh3gDGUA/dIG -HaAbFQD7z2Yd4AgVACjkjvnR5h2gSQUAKeR6KOByH9hoL+SE/6++BeOIAQD5BgAMcPkFAPkABARw -CVUACYgCKORy+mAIFe/99QD90KYd4AxlAP/QZh3g//UA7+SCJdjpAABYrgsL6jAc2M8swo39YB3D -ogCdAB3XuhrYyy3SICumjftRiBWgDAUAWLVoH9hI6hIjLfAEgACv7v4jKBXg6wUA+mAARfZMZQCs -qv/y5h2o7h0A//LGHaAMRQBYrfUqEiMrei6rqvuw7AXgDEUAWK3wG9i5KDI1+2aIFeEZpQD5AABE -cDxVAP0ABh2gHsUA/wEmHaA6dQD7AGYdoB+lAP8BBh3gCVUA+QCGHeAPZQD/AOYd4Ak1APkAxh3g -ChUAKoQFKoQCKoQBLrAA+CQGFaA9xQDxwZAN4AwFANmwbQgMLpABsczk4AdkyAUAAGP/7CoSIC2k -Cv1BZh2nzAEA7BYYJVAxAABYrcotEiAsEhj9gABGf/v1APuBhh3gDSUALTY2ijD6ZogV4CxFAFv9 -9mP6SQAA/bEUBaAKVQD8QAgV4DsFAO8gOCHxQQAAWLF/KjI0KwoA+iRGFaYdhQD9QABFckzlAFit -vi4SIvpgCBXmGuUA+8AARTYfhQD/wABHf/31AP3ABhXgDGUA7eUCJdjpAABYracuEiIY12f7r/QF -5lrlAPvAAEU1v0UAr+4uFhb7zyYd4AwlACzkdPnOJh2gSQUA+c8GHeJNBQD9zqYd4A+FAP/OBh3g -TTUA/dEmHeAPBQD/0MYd4AklAPnRRh3gSEUA+dDmHaAMBQD90QYdoivFAPvRZh3gHBUA/c9mHaAL -ZQD70gYd4AgVACjkjvnR5h2gSQUAKeR6KOByH9fML+SE/66GBeOIAQD5BgAMcPkFAPkABARwCVUA -CYgCKORy+mAIFe/99QD90KYd4AxlAP/QZh3g//UA7+SCJdjpAABYrW8L6jAc2DMswo39YArDogCd -AB3XHhrYLy3SICumjftRiBWgDAUAWLTMH9es6hIiLfAEgACv7v4iyBXg6wUA+mAARfZMZQCsqv/y -5h2o7h0A//LGHaAMRQBYrVkqEiIrei6rqvuvtAXgDEUAWK1UKjI1Kwro+mAARfEcpQD9QABFMA1F -APokJhWgOVUA+UAGHeAIFQD5QCYdoA81AP9ARh3gPmUA/0BmHaAMRQDtpAQlUBUAAFitQioSISsK -7PpgAEXwDUUA/UFGHeA8JQAspAn7QWAVoAxFAFitORvYAiuyNC6wAC0KPPHBoA3gDAUAC7kCbQgM -LpABsczk4AdkyAUAAGP/7CoSIS2kD/1CBh2nzAEA7BYXJVBFAABYrSguEiEtEhf/oABGv/z1ACzU -EfpgCBWgCzUA+mbGFeAsRQD6ZogV4A0lAFv9U2P3u9ogWzB9wCDRDxjX3i+CjLH//xGGFe/xAgAZ -19ookoyxiPkxhhWv+oIAAAAAbBAEJCAh86+2BeAIBQD8mAAUsAp1AAqZAik2wSg2whbX1hXXi/h4 -ZhWgOSUAKzLD4L4MdMv9AADwAJANoAIFAGWQqf2vnAXgChUA/69EBaALhQD8wGgdoA8FAFiwwccr -ZyA2wKT9r4wFoBtFAFiwvGYgd/qAaB2t/fUA/YAEBvALdQD94AAG8g4FAP+mAA6wDAUAWKQk0qDR -D8Dj/nhmFaA5JQAvMsPg/g10y/0AAPAAlA2gAgUAAGWQXu3XsBtgBIAA/68IBaAKFQD6AQId4A8F -AFiwo8crZyA0wKT9r1IFoBtFAFiwnmcvh9EPC+owKlJFq6oI6jAIqAz3H/lwkgCdAAzqMAysDGvB -9mP/HQD8eEgVr/1yAAAAC+owDeowKlJFq6oNrQz3v/vAkgCdAAzqMAysDGvB9mP/Z2wQBCIhHNEP -bBAEKEoA+gACHeBJBQDpOQENoASAAOmEOQHgNIAAGNZ6CEQCBARPIyAhFdeB/HgAFTAMdQAMqgIq -VsHBkClWwhfXfRbXMvq4ZhXgOSUALVLD4N4MdMv9AADwAJANoAIFAGWQpP2u6gXgChUA/66SBaAL -hQD84GgdoA8FAFiwZ8crZyAxwKT9rtoFoBtFAFiwY2Ygch3XbO29AQnQBIAA/eAABvAcBQD8hgAO -8At1AFijzNKg0Q/A4/64ZhWgOSUAL1LD4P4NdMv9AADwAJQNoAIFAABlkF7t11gb4ASAAP+uWAWg -ChUA+gECHeAPBQBYsEvHK2cgNMCk/a6iBaAbRQBYsEZnL4zRDwvqMCpiRauqCOowCKgM9x/5mJIA -nQAM6jAMrAxrwfZj/yIA+rhIFe/9hgAAAAvqMA3qMCpiRauqDa0M97/7wJIAnQAM6jAMrAxrwfZj -/2dsEAQY1uz3rnQFoAklAPxHgAHf9wUACSw2DAxHA8wRpswrwswHuwELOwIrxswK6jAlgkWqVQTq -MARUDGpBD20ICA3qMA1dDGrRA2P/8ABoIjYJLDYMDEcDzBGmzCvC7Ae7AQs7AivG7ArqMA7qMCWC -RapVDl4MauEObQgIDeowDV0MatECY//wbyJlFtcaCSU2BQVHA1URplUmUkwHZgEGNgImVkwE6jAO -6jAigkWkIg4uDGrhDm0ICAnqMAkpDGqRAmP/8CZSbAdmAQY2AiZWbATqMArqMCKCRaQiCioMaqEO -bQgICOowCCgMaoECY//w0Q8AbBAEGdavF9b/GNb8/EkAAdAKJQAKLTYNDUcD3REI3Qgs0svkTxEJ -9gKAAA/uAgfMAQ7MAizWywvqMCaSRQtmCAXqMAVlDGpRDm0ICA7qMA5uDGrhAmP/8GgiQQotNg0N -RwPdEajdLNLr5E8RCfYCgAAP7gIHzAEOzAIs1usL6jAP6jAmkkWrZg9vDGrxDm0ICA7qMA5uDGrh -AmP/8G8icBjW2AomNgYGRwNmEahmKGJL5EURCZ4CgAAFMwIHiAEIOAIoZksF6jAP6jAikkWlIg8v -DGrxDm0ICAjqMAgoDGqBAmP/8CViawdVAQU1AiVmawTqMArqMCKSRaQiCioMaqEObQgICOowCCgM -aoECY//w0Q8AbBAEHNZqGNa7Gda796tABeANJQD3q2AFoAoFAOvWsxEdsQAA5ZQADSAEgAANLzYP -D0cD/xGr/y7y3wOdQA2FOQY9AfXABAdwU1kA7XQ4CqyCgAD0hgAKcFNRAANVEQXuAgTuAi723w3q -MCXCRa1VDuowDl4M/cJgINANJQBtCAgE6jAEVAxqQQJj//BoImTulAANeASAAA0lNgUFRwNVEatV -JFL/A5tAC445/oAEAjCzWQDmPgEN3IKAAP7iAA+w41EA6/sCD3TCgAAORAILRAIkVv8P6jAO6jAr -wkWvuw6+DGrhDm0ICA7qMA6+DGrhAmP/8PRABSlSAJ0AHtZ8DSs2CwtHA7sRrrslsl/2YAQHMgIF -APJgBAEwBBUA8o0ACTAPBQAOTzj+7QANcONRAPMNAAywQ1kA5ZUBCiSCgADqRAIPHMKAAAQzAgU1 -AiW2XwTqMA/qMCLCRaQiDy8MavEObQgIDeowDS0MatECY//wJbJ/BZUBBTUCJbZ/BOowDuowIsJF -pCIOLgxq4Q5tCAgI6jAIKAxqgQJj//DRDwBsEARoI0X3rKoFoAclAAcnNgcHRwN3EfbgAEMwawUA -7DQAC1AEgABYDjsa1k0rKgDTD+p6CApgBIAAWA42yEvaYPygaB2gG/UAWA4y96vgBa359QD0QARh -H+oFAPushAWgByUAByc2BwdH+PgAE7BrBQDqeggJ4ASAAFgOJsagHNYyrHwuwv8p2v8J7gEOTgIu -xv8N6jArYkUNuwgI6jAIuAxqgRBtCAgN6jANvQxq0QRj//AAAMpKLsLnCu4BDl4CLsbnDeowDuow -K2JFrbsOvgxq4Q5tCAgP6jAPvwxq8QJj//D0QAlBUgCdAC76n/2sLgXgDCUADCw2DAxHA8wRDcwI -L8JHDv8BDz8CL8ZHDeowCOowK2JFDbsICLgMaoEObQgIDeowDb0MatECY//wL8JfCf8BD08CL8Zf -DeowD+owK2JFrbsPvwxq8Q5tCAgI6jAIuAxqgQJj//AowmcOiAEIOAIoxmcP6jAN6jArYkWvuw29 -DGrRDm0ICA3qMA29DGrRAmP/8C3CfwndAQ1NAi3GfwvqMA7qMCliRauZDp4MauEPbQgIDuowDp4M -auEDY//wAGRAVy3CRwrdAQ1dAi3GRwvqMA/qMCliRauZD58MavEObQgIDuowDp4MauECY//wLcJn -Ct0BDV0CLcZnC+owD+owKWJFq5kPnwxq8Q5tCAgO6jAOngxq4QJj//DRDwAAbBAEFdXUF9V8JVKB -+OFAJaAJlQDogjEigxmAAKKICYgRqFgmgCNrYh5mYBsjgCxoMh5oMRtoMxhoNEwCIgmyIgciCiIi -XdEPeWHga2oCa2kKAiIJByIKIiJd0Q9oNU1oNz1oOAr8ZuAE0AS1AHQxLwIiCQciCiIiXdEPAiIJ -ByIKIiJd0Q8AACOANnkxwmk5qQIiCbEiByIKIiJd0Q8AAAIiCbIiByIKIiJd0Q8CIgmxIgciCiIi -XdEPAABsEAQZ1aUpkoEV1UzzKBAN4Ay1ACtdCiuyMaK7CbsRq5sqsCP9RoAJUA2VAGagLCqwLNMP -0w9oojBopS31QBXiEgCdAPVAFWCSAJ0A9UAUyhIAnQDwAFANoAklAH2hz2uqB/lAEcySAJ0AwJAC -JAmklAVECiRCdfRgEAySAJ0A/GAPzCIAnQAECUIX1XzzqvQF4AYlAAYmNv8gABU3ZgEA+NgAEz+L -9QDjYwgBEQOAAC0ywAvdAQ2tAi02wAzqMClSRayZCOowCJgM9wAIEJIAnQBtCA0O6jAOngz3wAeI -kgCdAGP/6wAAAAAAAPRADjESAJ0ALTLgC90BDa0CLTbgDOowD+owKVJFrJkPnwxq8RJtCAgO6jAO -ngxq4QZj//AAAAAA8oAKJxIAnQD6QGgdoAsFAPSEAAayDAUAW/786iQAClgEgABb/pJzR2kc1VMt -MtwE2kLs3QENVcKAAA2tAi023AvqMA/qMClSRauZD58MavEQbQgIDuowDp4MauEEY//wAACnbi3i -fAzdAQ2tAi3mfAvqMA/qMClSRauZD58MavERbQgIDuowDp4MauEFY//wAAAA2iD0UAAFscSZAFv+ -LvKABeWSAJ0A0Q8AAC0y4AvdAQ2tAi024AzqMA/qMClSRayZD58MavEQbQgIDuowDp4MauEEY//w -AACnbC7CQAvuAQ6uAi7GQA3qMA/qMClSRa2ZD58MavEObQgID+owD58MavECY//wLsJgC+4BDq4C -LsZgDeowCOowKVJFrZkImAz3H/bQkgCdAG0ICA/qMA+fDGrxCWP/8AAAAAAAAADwn/YnEgCdANog -/AACHaBrBQBb/q5j/sL/+CgNoAlFAPpAaB2jtKkAW/2+0Q8CJAkFRAr0jqgVr/dyAGg1cWg3Zmg4 -BWg5YHwxXf/26A2gCQUALTLAC90BDa0CLTbADOowCOowKVJFrJkImAz3H/KAkgCdAA7qMA6eDGvh -9mP+PwAAAAAAL7A2+f/rJNIAnQD/9dANoAkVACiwNv0f6g1iAJ0AY/1fAAD/9XANoAklAP/1UA2g -CRUAbBAEFdTeJVKB5tSFEorpgAAobQoogjGiiAmIEahYJ4Aj/ORgCVAJlQBmcBsjgCxoMiNoMSBo -Mx30YAqqEgCdAPAAUA2gAyUAeXHga3oH+OAJNJIAnQDAMAIlCaU1BlUKJVJdE9Qh41MBAog4gADC -VPRmAArwACYAwFgFNQL3qW4F4AklAPxHYAHfGDUACSs2CwtHA7sRp7sqsoQIqgEKWgIqtoQE6jAj -YkWkMwrqMAo6DGqhDm0ICAzqMAw8DGrBAmP/8GgiOQkrNgsLRwO7EQe7CCqypAiqAQpaAiq2pATq -MA3qMCNiRQQzCA09DGrRD20ICAzqMAw8DGrBA2P/8ABvImMU1JcJIzYDA0cDMxGkM4c0CHcBB1cC -lzQE6jAN6jAiYkWkIg0tDGrRDm0ICATqMAQkDGpBAmP/8CcyJAh3AQdXAic2JATqMAfqMCJiRaQi -BycManEObQgICOowCCgMaoECY//w0Q8CJQkGVQr0q6gV7/u+AGg1PGg3MWg4B2g5K8CLeDEm//ss -DaADBQAjgDb4f/X0YgCdAPh/9QTSAJ0A//rADaADFQAAAAAA//qQDaADJQD/+nANoAMVAGwQBOok -AAnYBIAAW/6XCqQC6zQACVAEgABYAjsT1BH7qL4F4AUlAAUlNvRABpGSAJ0AA1kR+yAARPPUqQAt -logM6jAqMkWsqgjqMAioDGqBEG0ICAzqMAysDGrBBGP/8AAABP1FLZaJDOowDeowKjJFrKoNrQxq -0RBtCAgO6jAOrgxq4QRj//AAAAStRC2WigzqMA/qMCoyRayqD68MavEQbQgIDuowDq4MauEEY//w -AAAEfUItlo0M6jAP6jAqMkWsqg+vDGrxEG0ICA7qMA6uDGrhBGP/8AAABAxGLJaMCuowD+owKTJF -qpkPnwxq8Q5tCAgN6jANnQxq0QJj//D0QAahEgCdAANZEfsgAETz1KkALZaoDOowDuowKjJF0w+s -qg6uDGrhEG0ICAvqMAurDGqxBGP/8AAABPxFLJapC+owDOowKjJFq6oMrAxqwRBtCAgN6jANrQxq -0QRj//AAAASsRCyWqgvqMA7qMCoyRauqDq4MauEQbQgIDeowDa0MatEEY//wAAAEfEIslq0L6jAO -6jAqMkWrqg6uDGrhEG0ICA3qMA2tDGrRBGP/8AAABAtGK5asCuowDuowKTJFqpkOngxq4Q5tCAgM -6jAMnAxqwQJj//AW0/L0QAUJUgCdAANSEfZAAEUztKkAm6gM6jAN6jApMkWsmQ2dDPegBsCSAJ0A -bQgNDeowDZ0M96AGOJIAnQBj/+sAGtPqqipYDMQa0+kEp0TqKggL2ASAAFgMwBrT5uoqCAvYBIAA -WAy9GtPjBHdC6ioIC9gEgABYDLga0+DqKggL2ASAAFgMtRrT3QQERuoqCApYBIAAWAyxGtPa6ioI -ClgEgABYDK0FCkcDqhH3QABFMAwVACymogvqMCkyRauZC+owC5sMarEQbQgIC+owC5sMarEEY//w -AADAwCymogvqMAzqMCkyRauZDJwMasEObQgIDeowDZ0MatECY//w0Q8rpigM6jAO6jApMkWsmQ6e -DGrhDm0ICA3qMA2dDGrRAmP/8AT7RZupDOowDuowKTJFDJkIDp4M99/4MJIAnQBtCA0N6jANnQz3 -v/eokgCdAGP/6wAAAGwQBCIgIfWnJgXgBAUA/FgAFDAJFQAJiAIoVsEkVsIX00T0uGYVoDklACpS -w+CuDHTL/QAA8ACQDaAGBQBlkKn9pw4F4AoVAP+mtgWgC4UA/acEBaAPBQBYrHnHa2dgN8Ck/ab+ -BaAbRQBYrHVmYCId05Ae0m7Asf1ABAbwDAUA880ACn/dAQDtTQIJUASAAFif3MAg0Q8AwOP+uGYV -oDklAC9Sw+D+DHTL/QAA8ACIDaAGBQBlkGEc02gd02j/pnoFoAoVAPoBAh3gDwUAWKxcx2tnYDnA -pP2mxgWgG0UAWKxXY/+GAAAAAAvqMCpyRauqCOowCKgM9x/5cJIAnQAM6jAMrAxrwfZj/x0AAAAA -+rhIFa/9ZgAAAAvqMA3qMCpyRauqDa0M97/7sJIAnQAM6jAMrAxrwfZj/2VsEAQqICEd0kX6AOId -4AUFAP6gaB2ggxkA+a0ADzAsBQBYi77moFNtIASAABzTU/oAQh2iCQUA6joBCvAEgAAKnjkqICH8 -QAId4At1AFiLs+agJ20gBIAA+kQwFaENBQD6IAId4MMBAP1tAAqwC3UA/qBoHaAcBQBYi6jSQNEP -AGwQBMAg0Q8AbBAEGNM8AycRqHcjcrv+Z8AP0AUFABbTOPmlqAWgAD4AKXK7758ocqgFAAB2US0D -6jAigkUDIggK6jAKKgxqod9tCAgJ6jAJKQxqkdNj//Aqcrf69uYVoAIFANEPxyvRDwAAAGwQBm86 -DBTTJAQ0CoRACkAAAACDEPWmFgXgCCUACCg296V0BeeIAQD5GAAUP3YFAOWFCAEQ04AAKVLABpkB -CTkCKVbABOowInJFpCIJ6jAJKQxqkUptCAgK6jAKKgxqoT5j//AAAAAA9EAG8RIAnQAoUuAGiAEI -OAIoVuAE6jAL6jAickWkIgsrDGqxDm0ICAnqMAkpDGqRAmP/8NEPAAApUuAGmQEJOQIpVuAE6jAK -6jAickWkIgoqDGqhDm0ICArqMAoqDGqhAmP/8BXS36WFKVJABpkBCTkCKVZABOowC+owInJFpCIL -KwxqsQ5tCAgI6jAIKAxqgQJj//AoUmDTDwaIAQg4AihWYATqMAnqMCJyRaQiCSkM9z/7+JIAnQBt -CAgJ6jAJKQxqkQJj//DRD/IQoh3v+34A8hDiHe/7XgDyEQId7/s+AChSwAaIAQg4AihWwATqMArq -MCJyRaQiCioM91/5oJIAnQAJ6jAJKQxrkfbRDwBsEAQX0mMW0rL0YAUdUAglABTSxAQ0CoRACkAA -9EAEmVIAnQACKQkHmQopknXxIAWZkgCdAPRgBVwSAJ0A9GAFHJIAnQDAq/pgBMwiAJ0ACCo2A6oR -90AARTCpBQAppoYE6jAickWkIgvqMAsrDGqxPgvqMAsrDGux9tEPCCk2A5kR9yAARLD09QAkloYD -6jAM6jAickWjIgwsDGrBEW0ICArqMAoqDGqhAmP/8NEPANEPAAgpNgOZEfcgAESwBPUAJJaGA+ow -C+owInJFoyILKwxqsdptCAgK6jAKKgxqoc5j//AIKTYDmRH3IABEsARVACSWhgPqMAvqMCJyRaMi -CysMarGpbQgICuowCioMaqECY//w0Q8AbBAGbzoOFNKCBDQKhEAKQADAiJgQF9IY9aTOBeAIJQD8 -R4AB3/YFAAgqNgOqEaWqK6KAKRIABrsBC5kCKaaABOowI3JFBDMICeowCTkMapEObQgIC+owCzsM -arECY//waCI1CCo2A6oRpaoroqCJEAa7AQuZAimmoATqMAzqMCNyRaQzDDwMasEObQgIC+owCzsM -arECY//wbyJsCCM2AzMRpToprQSJkIgQBpkB6YkCBVATAACZoATqMAzqMCJyRaQiDCwMasEObQgI -BOowBCQMakECY//wGdI4qTklkiAGVQEFhQIlliAE6jAF6jAickWkIgUlDGpRDm0ICArqMAoqDGqh -AmP/8NEPwLX6IAYV7/wSAMDH/CAGFa/76gAAbBAEFdIsJVKB5tHTEotpgAAobQoogjGiiAmIEahY -J4Aj/ORgCVAJlQBmcBsjgCxoMiNoMSBoMx30YAsqEgCdAPAAUA2gAyUAeXHga3oH+OAJtJIAnQDA -MAIlCaU1BlUKJVJd96QYBeAJJQD8SSAB3+gFAAkrNgsLRwO7Eae7KrKDBZ1R/7AAFrHF2QANzAII -qgEMqgIqtoME6jAjYkWkMwrqMAo6DGqhDm0ICAzqMAw8DGrBAmP/8GgiRQkrNgsLRwO7Eae7KrKj -BZ1R/7AAFrHF2QANzAIIqgEMqgIqtqME6jAN6jAjYkWkMw09DGrRD20ICAzqMAw8DGrBA2P/8ABv -InMa0eUJJzYHB0cDdxGqd4pz9DsAAfFFyQDoqgEKJ4KAAAQzAgo6AppzBOowDeowImJFpCINLQxq -0Q5tCAgJ6jAJKQxqkQJj//AlciMIVQEFNQIldiME6jAK6jAiYkWkIgoqDGqhDm0ICAjqMAgoDGqB -AmP/8NEPAiUJBlUK9KuoFe/7fgBoNTxoNzFoOAdoOSvAi3gxJv/67A2gAwUAI4A2+H/1dGIAnQD4 -f/SE0gCdAP/6gA2gAxUAAAAAAP/6UA2gAyUA//owDaADFQBsEAYkICIc0ccqICH8IGgd4BvlAFid -xvNAaB3gBxUA80XYDeAFBQApEQAPAgB6l3kJOUH1IAYQkgCdAPUgDEkSAJ0A9SAMyZIAnQAoICtl -gF4kICAqICEc0bT8IIAV4At1AFids2agKiogIRzRrx3Qkv+jXAWgC3UAWIoNZqATKiAhHNGr/CDA -FeALdQBYnahnofUqTPv67QAJsAlVAOkkICmQBIAA0Q8AACsgK2S/oCUkKyUlHiwiESUlHyogIf2A -IBWgC3UA/EImFaANhQD9ozIFoA6FAFiJ9vyAaB3gCkUA/aMqBaAbRQBYqmsqICvAMWSvW9Iw0Q8p -IR8JDkXo4S1rsASAAMCk/aMYBaAbRQDtICIreASAAFiqXyYlHyogIusgIytgBIAAWAERKSEfCQlF -5tBUGAQKgAD1IAXJEgCdAPUgBYiSAJ0A9SAGzBALBQAqICvA0QvbOXuhk/l/+nDSAJ0A/IBoHeAK -RQD9ougFoBtFAFiqSCUkIC4iECckK/pEMBWgC3UA/8AgFaAcNQDuJhAg6AkAAFidZS8hHRvRaeoR -ASgECoAA8+AErlIAnQD7QAT84gCdAPACZA2gSgUAAAAAAAApIR8JDkX13/rxEgCdAP/8tA2gBiUA -AAApIR8JDkX13/o0EgCdAP/8VA2gBoUAAAAa0UYDSRGqmSqStxvRUQuqAiqWtymSt/E/+gTQCwUA -8z/5xRIAnQD//MANoAsVAAArICIc0UgDuxGsuxzQi6y7i7DAwv1gBAW//E4AdacI+hgCHaAANgAA -C6wBdsEhwKD9om4FoAt1APpDxB2gDYUA+kQwFaAOBQBYiY9j/nYAAPoQAh2v/3IALSArZd4pY/3H -KiAhHNEnHdAK/iBEFaALdQBYiYVmrfIuEQN47xkoTPr47QAJsA9lAO8kICmQBIAA0Q8AAAAAAPpE -MBWgC3UA/CDAFeAMFQBYnRdmrbwpEQMJSUApJCAJSQwJcznSMNEPAAAAbBAEfzdiKiAh+gAiHeAM -lQD8ACId4A4VAFiJaiogIf2f0gXgC3UA/AACHaAOBQBYiWUqICH9ohYF4AsVAP+glgWgDAUAWIlf -A5hB6iAhLByUAAD9ogoFoAt1APwAYh3gDiUAWIlYYAAdxirRDwAAAAAAAAD9ofoFoAt1APwAYh3g -DhUAWIlP+kQwFaALdQD9oe4F4CwFAFidNvpEMBWgC3UA/EACHeAMBQBYnTEqICH6ACId4AyVAPwA -Ih3gDgUAWIlAwCDRDwBsEAQoMAjOjiwgIRTQu/2YABYwHeUADcwCLEbBG9DjK0bCFtC2FdBr+AZC -HeAKBQD6mGYVoACCAMYq0Q8AALCZZJB4C+owKlJFq6oN6jANrQxr0UgsQsNwzuPAIGYgp/gGQh3g -DTUA/JhmFeAAagCwmWSQbwvqMA7qMCpSRauqDq4Ma+EnLELDcM7jwCBmII4tQsII3TINjRKdM9EP -bQgIDuowDq4MauGqY//wAG0ICA/qMA+vDGrxy2P/8P2hIgXgChUA/6DKBaALhQD8wGgdoA8FAFip -g//+BA2v8rUAAAAAAADt0IcbYASAAP+gtgWgChUA+gECHeAPBQBYqXn//igNr/K1AMCk/aD8BaAb -RQBYqXQIiDIIiBKYM9EPAMCk/aDyBaAbRQBYqW4ImTIJiRKZM9EPAABsEAT6AIIdoBtFAOzQmhno -BIAAWKlmKiAh+gDiHeAcBQD0AAIdoJMBAP6AaB2hCAUA+Q0AD3ENBQBYiOJmoEAdz08c0I3+gGgd -oKMJAAreOfpEMBWgC3UAWIjaZqAhHc9Z+kQwFaCzGQD7rQAKcCwFAP6AaB2gC3UAWIjS0qDRD9Kg -0Q9sEAQY0GcDJRHTD6hV6VKAIkUdAABoQkj8hiAA0AYVACpSgMe+C6oB6laAIkT9AAD0gAehEgCd -APSACKCSmekAwCAsUoAGzAIsVoDRDwndUmnTzMAg0Q8ACd5SZe+2Y//xCd9SafKwY//oAMBw6iQA -CdgEgABYDAvqJAAJ2ASAAFimxGagGes0AAlQBIAAWEHiKVKAGs+zCpkCKVaAKFKAwJEbzxBkcMca -0DMrsjEqooGiuwm7EauqKqEf/6CeBeWqAQD1QAUIkAylAOpkAAVr+QAADco4KFKDEtBID4gBCiIt -CCICIlaDLlKEHdBFD+4BCt0tDt0CLVaEL1KAGNBBHNBCEtBC7P8BAlv5AAALgjgC/wIvVoAuUoAG -7gLuVoAskASAANEPAPYAAh3gCxUA+F0ABvAKBQDtujgG4/UAAOy3OAUA4YAA//yEDaADJQDKnC+c -/v4AIh2gBwUAD+c4//z4DaAJBQD6DIIdr/2qACJSgAYiAuJWgCyQBIAA0Q/AMv/7nA2gBxUAAABs -EAQsICETz+r4AAId4BrlAAvMEQrMAiw2wRvQGis2whbP5fWfNAWgOyUA96AuBeAFFQD4eGYV4ACC -AACwu2SxYg7qMC1CRa7dDuowDt4M+cAGkJIAnQAvMsNw/t4oCqMoNsLDsvR4ZhXgAIIAALC7ZLD4 -DuowDOowLUJFrt0M3Az5gARgkgCdAC8yw3D+3isgIQu7EQq7Ais2wRjP/Cg2wvh4ZhXgOyUALDLD -cM4+LQpjLTbC9HhmFeA7JQAuMsNw5iSwu2SwcwrqMA/qMClCRaqZD58MavHjbQgIDOowDJwMasHX -Y//wwCDRDwAAsLtksOgK6jAN6jApQkWqmQ2dDGrRpAzqMAycDGvB9mP/mABtCA0O6jAO3gz33/tY -kgCdAGP/620IDQ/qMA/fDPf/+SiSAJ0AY//rAAAA7c+fG2AEgAD/nuYFoAoVAPoBAh3gDwUAWKiR -wKH84GgdoBtFAFiojsAg0Q8AAAAA/Z8mBeAKFQD/ns4FoAuFAPzAaB2gDwUAWKiFwKH84GgdoBtF -AFiogsCQ//vUDaAa5QAAAAAAAAD9nwoF4AoVAP+esgWgC4UA/MBoHaAPBQBYqHfAof2fZgWgG0UA -WKh0wJD/+vQNoBrlAAAAAAAAAO3PdxtgBIAA/56WBaAKFQD6AQId4A8FAFioacCh/Z9KBaAbRQBY -qGbAINEPbBAEJCAh957QBaAFBQDTD/yYABQwGeUACYgCKGbBJWbCF88Y9NhmFeA5JQAqYsPgrg50 -y/0AAPAAmA2gAgUAAABlkKn9nrYF4AoVAP+eXgWgC4UA/Z6sBaAPBQBYqE3HK2cgN8Ck/Z6mBaAb -RQBYqElmIHUdz2QezkLBvv1ABAbwDAUA880ACv/dAQDtXQIKUASAAFibsNKg0Q8AwOP+2GYVoDkl -AC9iw+D+DHTL/QAA8ACIDaACBQBlkGEczzwdzzz/niIFoAoVAPoBAh3gDwUAWKgwxytnIDnApP2e -bgWgG0UAWKgrZy+J0Q8AAAvqMCpyRauqCOowCKgM9x/5YJIAnQAM6jAMrAxrwfZj/xsAAAAA+thI -Fa/9ZgAAAAvqMA3qMCpyRauqDa0M97/7sJIAnQAM6jAMrAxrwfZj/2VsEAQqICEUzxj9WAAVMBvl -AAuqAipGwRnPQClGwhbPExXOyfgGQh3gCAUA+JhmFaAAdgAAAACwmWSQeAvqMCpSRauqC+owC6sM -a7FJLELDcM7jwCBmIKf4BkId4A01APyYZhXgAGoAsJlkkG8L6jAO6jAqUkWrqg6uDGvhJyxCw3DO -48AgZiCOLULCCN0yDY0SLTUA0Q9tCAgO6jAOrgxq4alj//BtCAgP6jAPrwxq8ctj//D9nd4F4AoV -AP+dhgWgC4UA/MBoHaAPBQBYp+H//gQNr/K1AAAAAAAA7c7lG2AEgAD/nXIFoAoVAPoBAh3gDwUA -WKfX//4oDa/ytQDApP2duAWgG0UAWKfSCIgyCIgSKDUA0Q/ApP2drgWgG0UAWKfMCJkyCYkSKTUA -0Q8AbBAGJSAi6iQACNgEgABb/7DnzuIdGASAAPggBBXgBBUA8VT4DeAGBQAoCm35ABzj4gCdACoh -GNMP0w/xRqAN4AsFABzO9iogIe0cAipYBIAAWJra5qOEbRgEgAArEQHxYAmn0gCdACkgcGSR7vUg -FZiSAJ0AwLBmMVkpIR8JCUX1IAjpEgCdAPUgCKiSAJ0A9SANVBIAnQDAkMChCak59SBoHaAAIgAA -ANRg8GzYDeAGBQAqICv1QAScIgCdAPSACNCQDAUAKyIRLCQrLCUe7CUfJdgFAADrJhEjAPGAAMCk -/Z2eBaAbRQDuEQAq6ASAAFinjMDULSQgKiAhHM7E+gPCHeANBQBYmvgqICEczsH6A8Id4A0FAFia -891QA18Rp/8u8oL9nX4Fr/gFAPnABAcwCOUA+cYADzAKRQD/8EYVoBtFAFindyogK8AxzaskICD4 -gBRSUAlFACkkIPifgBWgAhUACCM50jDRD9Iw0Q8AAAAA9MBoHaALBQDHlfhgD9RgBgUAAioC+gAi -HeAMBQBb/v9j/xvAQP/8OA2gCwUAA1oRp6osorcdzooNzAIsprcqorfxX/cM0AkFAPNf9s0SAJ0A -//tEDaAJFQAAAAAAAAAA//tMDaAEBQD6AIIdoBtFAOzOkRroBIAAWKdNKiAh/kIIFaALdQD8AmId -oA8VAP5FZh3gCAUA6CQgJ3AFAADuJhAg6CEAAFiaaCkhHRzObCoRBPMgBVZSAJ0A/UAF7KIAnQDw -AtwNoEoFACkgIhrOZQOZEaqZGs2oqpmJkMCi+yAEBL/5EgAAACogIRzOc/wgwBXgC3UAWJpUZq4E -KhEDLiEfChpB9UAIeZXuAQD1QAj5EgCdALCt/AAiHaALBQANyzibE/vf7sxiAJ0AHM5k/ERQFeAK -RQD+IGgV4BtFAFinHCogIisgI4wTLCUfW/3OZKD8G85b9E4GHa/2pgAAAHWnCfoYAh2gAFoAAAAf -zQsMrgH/wAaMYgCdAMCg6iUeKVAEgABb/iMrIR/Ap/t/4BXgCGUAC6g4A1kRp5kqkoLHsAuqAQqI -AvkwRhWv+KIA/ZyKBaAKRQD8RFAV4BtFAFim+yogIRzOQB3M//+Z/gWgC0UAWIZ8Zq0mKiAhHM46 -/CCAFeALRQBYmhfsEQItaJIAAHPP4yYkcP/0GA2gCwUAAAAAAAAAAOzOMRlQBIAAWKc+wCDRDwD1 -3+csEgCdAMDY/CBmFe/8GgAAAAAAAAD13+ZpEgCdAMDy/iBmFe/7ugAAAAAAAAD6EAIdr/zGAP/y -vA2gCwUA9gAiHaAEBQD/9rgNr/O1ANKg0Q8qICEczhj8IUAV4At1AFiZ82agbykRBXCfFvifQBWg -CWUA+EQGHeACFQAIIznSMNEPCZhEaYUc+J/AFaAJJQD4RAYd4AIVAAgjOdIw0Q8AAAAAAAD6RDAV -oAt1APwhQBXgHDUAWJndZqAZKREFCdlAKSQg+I8ADHACFQAIIznSMNEPAAD4n2AVoAlVAPhEBh3g -AhUACCM50jDRDwBsEAQTza4kICEWzeH2AAId4BzlAAtEEQxEAiQ2wSY2whXNqPWaugWgOSUA9nhm -FeAAhgAAALCZZJF1C+owKkJFq6oI6jAIqAz5AAbIkgCdAC0yw3De3vgGQh3gDjUA/nhmFaAAggCw -mWSRFAvqMA/qMCpCRQuqCA+vDPngBJiSAJ0ALTLDcN7dKTLCKiAh8yAFRdELBQALrhEM7gIuNsEm -NsL2eGYV4DklAC8yw3D+Oys2wsCB+HhmFaA5JQAqMsNwpiSwmWSQhwzqMAvqMCpCRayqC6sMarHj -bQgIDeowDa0MatHXY//wwCDRD7CZZJDuDOowKkJFrKoO6jAOrgxq4acN6jANrQxr0fZj/5sAAABt -CA0O6jAOrgz33/sgkgCdAGP/620IDQ/qMA+vDPf/+PCSAJ0AY//rABzNlfoDwh3gDQUAWJnJwCDR -DwAAAADtzV0a4ASAAP+aYgWgChUA+gECHeAPBQBYpk/Aof2bEgWgG0UAWKZMwCDRDwAAAAD9mqIF -4AoVAP+aSgWgC4UA/KBoHaAPBQBYpkPApP2algWgG0UAWKZA//t8DaAc5QD9mooF4AoVAP+aMgWg -C4UA/KBoHaAPBQBYpjfApP2afAWgG0UAWKY0//q8DaAc5QDtzTka4ASAAP+aGgWgChUA+gECHeAP -BQBYpivAof2azgWgG0UAWKYowCDRD2wQBCkgIfOaVAXgCAUA/TgAFLAKdQAKmQIpNsEoNsIWzSX1 -mbQFoDklAPh4ZhWgAH4AsJlkkUwL6jAqQkWrqgvqMAurDPlgCICSAJ0ALDLDcM7ewJDmkXZsqASA -APgGQh3gDTUA/HhmFeAAfgCwmWSROQvqMA7qMCpCRauqDq4M+cAHSJIAnQAsMsMPAgAPAgBwztjA -kOaRSmyoBIAAKTLCZlE66iAhJMxwgAD6AOId4AwFAPxAAh3iDgUAWIV90qDRDwD6ACId4AyVAPwA -Ih3gDhUAWIV3+kQwFaALdQD9mnAF4CwFAFiZXiogIf2aNAWgC3UA/ABiHeAOBQBYhW0qICH9mmAF -4AsVAP+aJAWgDAUAWIVoKiAh/ZfMBeALdQD/l8gFoAwFAFiFYvpEMBWgC3UA/ZpKBeAMBQBYmUgq -ICH6ACId4AyVAPwAIh3gDgUAWIVYwCDRD20IDQ3qMA2tDPe/9ziSAJ0AY//rbQgNDuowDq4M99/4 -cJIAnQBj/+sAAAD9mZoF4AoVAP+ZQgWgC4UA/MBoHaAPBQBYpb//+sgNr/m1AAAAAAAA7czDG2AE -gAD/mS4FoAoVAPoBAh3gDwUAWKW1//ssDa/5tQDApP2ZdAWgG0UAWKWwZ17E0lDRDwDApP2ZbAWg -G0UAWKWrY/6sbBAGLCAiFcxkwLD4AgIdoC2FAO3MAgrQBIAA0w9tig0uoZR84QrrvAElUAkAACv6 -+x3M6S7ShPtgBADQDBUA/YABBl/79QALywPuvgEOVAKAAA6uAi7WhA7qMClSRQmZCg6ZCg/qMA+f -DGrxDm0ICA7qMA6eDGrhAmP/8C/ShBTM1wrIAg+/AfnmAA+wAwUA/7CGFeAALgAAALEzdDFBKiAh -HMzP/CBoHeAb5QBYmKRmoCkoEQB5jyMK6jApUkUJmQoKmQoK6jAKmgxqocttCAgK6jAKmgxqob9j -//DSoNEPxyvRDwAAAGwQBiMwCNMP5CAiKAQKgAD4YATJkgCdAB3LV/ZgBHCSAJ0AKNB9+5hEBaAC -FQD8DOIdoAsFAP8DwAcQGQUAbZoMLqGU7OE0dVAJAACxu/AAqA2v+7UAAAD0QAAGMB8FAP+GAA5w -CwUA0w9t+gwuoZTs4Qh1UAkAALG7x7sfzJ0v8oXBjwuIDHj1BcYt0Q8AACjQffWZNAXgWcUA/wLA -BxD29QD0YAgJH+KlANEPxirRDwAAAAApFATpFAUqAQqAAOZBF3lYCoAAKlCAKxQG9UAExSIAnQDA -oGagJCoKoPoggBXgDBUAWEXSZqATKgqh+iCgFeAMFQBYRc5moAIqEAXpp15x8/0AAPwMwh3gbIUA -Dtw4LBQAdkEW71CAKgEKgAAAKBooFAd0+VgiCgBmIC8qCqL6IGgd4AwVAFhFveagHm0QBIAAKgqj -+iBAFeAMJQBYRbfmoAhtEASAAMAg0Q/RDyL6w9EPAAAAKgrg+iDAFeAMFQBYRa5mr4T0sAYdr/1m -ACoK4Pog4BXgDBUAWEWo5q/LbRAEgAD0sAYdr/5CAAAAAAAAAAD4BEId4KoFAOlJCQjYBIAA+CAG -HeAMFQBYRZvmoB5tEASAACoKofogQBXgDCUAWEWW5qAIbRAEgADAINEP0Q8AbBAOHcuxGMrhHMwG -HsxDKIB9K8KBieEswn3u4gAg0IEAAJmh/0AGFaAJhQAJhgHzgABCMAcVAOZ2OQomQoAA+oAAQnAf -BQDnQCwpGASAAPKG0BWgDgUA6kA1JHGWgAADDELvzAIO2ASAAG36DC+xlOzxCHXYCQAAse7H69Xg -+ZhEBaBfdQD6AAId4B71ACiChSxALAXpDHmNDX7Bd8Ag0Q8AAAAAAAAA/4ANpSIAnQD6jWYd4AIF -ANEPAAAAAAAA8GJADeAOBQAJzxGvvyLwNijwLChELC/wNSJENv6Gph3gAgUA0Q8AAPugaB3gbHUA -+AICHaDz9QDTD22KDCmxlOyRCHXYCQAAse7H6/XAaB3v/boAACxAa+oWDCYPoYAAKkBqsc0tRGv9 -X/uKogCdAPoAoh2gG4UA7Mv5GegEgABYpKXA8O9EaynQBIAA/obGHeCrBQD+hqYd4B7VAP6Fhh2g -DAUAWJW9aKMJwI35QCB9IgCdACwcIAxsCuwWDSnQBIAA/YAQFaCrBQBYlbQtCh3mo9ttWASAAPLD -sA3gDiUA9UAXQhIAnQD1QBdZEgCdACxALC8K/3+xBSgKCChFH/2ADaRiAJ0AKQr/+WAP/GD69QCa -G5sa/YARNGIAnQAsEg0DOgL9gDAVoKsFAFiVm+oWDi0dogAA6kQ1IwBpgAAKrQoP3REtRDUsQCz8 -H+Id4AsFAHfJEi5ANnLpDIgcL0A1+f/zvCIAnQCPGpwUmxOJG+0WAirwBIAA6hYBKegEgAD4IAYV -4ApFAP2XagWgG4UAWKRhwCDRDwAAAAAAAAD0A+Id4FJ1APoAoh2gG4UA7MutGegEgABYpFf0hYYd -4AsFAOtENSNxSYAAGssP/AACHaAdBQBt2g0uoZRy4T3szAElUAkAABrKMikK//lFJh3v/LUAEsuU -LyKEx5/7gAQA0AgVAOtEayxACoAACYgDCP8B/lCGFeACBQDRDxrKJCkK/ymkKRLLiC8ihMef+4AE -ANAIFQDrRGssQAqAAAmIAwj/Af5QhhXgAgUA0Q8AAGRuDNrQ/AACHaAeBQBt6g0ooZR/gQnszAEl -UAkAAMfLGst2KaKEH8oO/AAiHeD+9QDsQGsuAQqAAO70KS7oCoAA/+VGHa/+9QDu3gMO/AKAAA/d -Ag6ZAQ2ZAvlQhhXv9soAAAAAAAAA6xYKK3JmAADaMPwAwh2gqwUAWJU0ixr/QGgd4B3VAPVADiiQ -DiUA9UAN6RIAnQD1QA2sEgCdACxALH3BAi5FHygK//n/8KUiAJ0AKQr/+X/wTWIAnQDA8P6D5B3v -9/4A9UAI5ZIAnQD1QAlmEgCdAPVACaaSAJ0A9UAJ5xIAnQD8hZAVr/biAACMHdow/YBQFaCrBQBY -lRPqFg8tDSIAAP4Bgh2gDbUA/ACiHaAPRQDqFhAjBWGAAApLFG+5cWi4bi8KAv6Fhh3gDCUAKAod -eME1LBINAzoC/YBwFaCrBQBYlQDWoOahZG1YBIAAKkQ19UAGoJIAnQBvpEjA2i1ENvyFkBWgABoA -wLAtEhD/9iwNoAoFAC5ELP3AaB2v9IIA/AAiHaAPFQD+hYYd7/RCAGi5V32xVG66HixELP/+MA2g -DFUAb6YpwIv4hsYdr/7OAAAAAAAAAAD8hZAVr/3CAA6pAWiUa2iYdvyFkBWv/X4Ab6iLwJz4hsYd -7/4aAAAALkQs/cBoHa/y1gAvRCz//OgNoAxFAAAA/AAiHaAKFQD6hYYdr/JiAPwAwh2gD2UA/oWG -He/yIgD8AGIdoAg1APiFhh2v8eIAwJn4hsYd7/zKAC9ELP3gaB2v+84AAAAA/IWGHa/7ogAuRCz/ -+SwNoAwlAAAAAAAA6hYKKlAEgABYRR+CGtEPAOoWES0CYgAAwKL9lc4FoBuFAO4SESnoBIAAWKOP -wCDRDwAAAAAAAADipAAKUASAAFhFEdEPAAAA4qQAClAEgABYRQ3RD9pAWEUM0mDRDwAA4hIRKlAE -gABYRQfRDwAAAGwQBBrKOR3KyBfJYfWS0AXgDJUA+kRwFeAGhQD0RFAVoA4VAPBnwA3v//UAfLlB -KFB99oYADjALBQDzAAWXEBkFAG2aDCihlOyBCHVQCQAAsbvHuynShACxBADqGu+sAw1EAoAACKoC -DJkBCpkCKdaEG8p/A0oRq6opooAbyrQLmQEppoDtRAAJ8ASAAP5DBBXgCkUA/ZVcBaAbhQBYo1bA -INEPfLk/LFB9wLDTD/+LwA8QGAUABkwCbYoNKaGU7JEKdVAJAAArvAEr+vsq0oQAsQQA7BoPyAPo -qgEOZAKAAAyqAirWhAIqAlgAiGP/lOpwKCoBCoAAAOkaD5sDC6oBCpkC+OUGHe/9pgAAAAAA7HAo -KgEKgAAA6Br/FwAMcA0FAOjMAQ7oCoAADcwC/OUGHa/+1gAAAGwQBCMgI/REUBWgB5UA9mJeDeAG -BQDBj/hFhh2gAFoAAAAAACYkLOpEAAnYBIAAWDvgJiQg+kBoHaDJhQD4Q6Qd4AsVAPpJZh3gDAUA -W/+e5qB3bSgEgAB3OW8L6jATym/TDyoyb/tgCpuiAJ0AHckBKzZvKjJu/aQIFeAMBQBYprAeyPwu -4H3s50V9uASAABrKZBvKZFuKuCokaigyHxrKYBnKYQeIDKqK6YJHe3gEgAD/QGgd4AD+AC4kaykK -AekkLilQBIAAWAB8BVICBgAAGspWG8pUW4qoKiRqKzIfGspTHMpTB7sMqrrssgZ7eASAAN+gKTCA -AEAECQwbf8e7HcjcLdB9Gsmq/6XABx/+9QD2cAYdoAwFAPgCAh2gbXUAbYoMKaGU7ZFEdVAJAACx -zPAA6A2v/LUAAAAAQQT8ACIdoBsFAOtNAg5gCoAADswDDJwB/HAGHaAMBQBtugwooZTtgQl1UAkA -ALHMLPr7G8ogKrKH+4AEANAJFQAAmRoptof7P/moogCdAAnqMBrIuSqiIA+qKAqZCArqMAqaDPdf -+KiSAJ0AbQgNC+owC5sM93/4IJIAnQBj/+ssMm6xzPxtxhWv+qIAAABsEAQiCsjRD2wQBhXJSCQg -IhjJ1gNDEagzLjKNHMoTKDKALyAsKiEYKhYAKSBK+CAmFeAbhQDpIEsqaASAAPggRhXgiHEA+CBm -FaAKVQBYoqkqICz8QwQVoBn1APlChg3gG+UAe6EMyMktIEruIEsmgDGAANEPZO/6wKX9k/gFoBuF -AO4yjSpoBIAAWKKaKDKABYgCKDaALzKAwKX9k+oFoBuFAO4yjSpoBIAAWKKRwKX9k+AFoBuFAO4y -jSpoBIAAWKKMwKX9k9gFoBuFAO4yjSpoBIAAWKKH3UD9k9AFoApVAP5xqBWgG4UAWKKC0Q9sEAYk -ICIjICzlIR8qUASAAFv9hu8gLC0wBIAA58mYHQCiAADBr3oxGnrxQGVgWdJg0Q8A8+8AC3AIFQD3 -DQALP/+yAHrx5CshH/qgAAXwDZUA/38AFaAGJQD/ogALNcUBAP1gBLQiAJ0AYABDA0kRp5kqkoAb -ybgLqgEqloApkoD+RZAV4AYVAN1A7MnBGfAEgAD6RtAVoBuFAPogBhWgCkUAWKJY0mDRDwAAAAAA -AAD6AIIdoBuFAOzJthtoBIAAWKJQ6kQAC1gEgABYn+hmoDTrZAAKUASAAFg7BgNMEafMLcKAHsjV -Dt0CLcaA/ZAIFaAAVgAAAAAAAADrZAAKUASAAFg6+9ogW/+DLyAs//3YDaAGFQAAAAAAAGwQDCMg -IiwgI/WSqgWgBgUA/GBoHeAHlQD3gAfkYAUVANpg7SBLLtgEgAD1gAsjEgCdAPeADmRiAJ0AJSRL -/f4CHa8N9QDoIEkpvMKAAKR3J3KNZIF5/kVwFaALJQD64AQF8AkVAAubOf9gBPwiAJ0Amxry4A0P -kgCdABnJgC4gIi8iEYoa5iQrL3TCgADp7ggH+AUAAC8mERjJeajuK+KA/WAEBbAP5QAPuwIr5oAv -ICID/xGp/wj/CC7ygP3ABAdw6AUACO4CLvaAlxDsyW0Z6ASAAP9AaB3gG4UA/gAiHaAKRQBYogAu -ICvAoc3nLyBKLCAg8+UgDeALZQArJCB7wQTAIdEPANKg0Q9lr/P//2gNoAoFAAAAKCArZILz2mAZ -x94pkH0vIErzIBJ/EgCdABvIqfwAAh2gHoUA/6YADzAYBQBtigwosZTugQl12AkAALHMLPr7Hskw -0w/TDynihQDBBOzihyrYCoAA+WAOeOIAnQD7gA9+YgCdACvmh+UkSieYuYAALSAi/ERwFa/6UgDA -7wO/EaT/LPKRDswBDAxHLCRLfsEH9klmHaAMBQBk0fNlzoYp8oAcySAMmQEp9oCbFZoc+fAIFaAK -wgAAKyAswY94sRTBnHmxD8HufrEKLyEYyPQoIEpkgccuICtk7xj2AAId4AoFAPohRhWv+fIAKSAs -+T/xilIAnQD//gwNoA4VAAAALCIQJSQrG8ef5iQgJmAFAAAsJhArsmgqICL6IMYVodupAPwhZhXh -68EA/iDmFaDLoQD8ISYVoLvZAPohBhXgCkUA/ZIWBaALBQBYoaEqEgspEgf9RyAKUA51AGagMS8S -BgP/EQT/CCjygiv68OuIAQ1vwoAACN0C7faCLIE+AAD2IMgVoAg1APgg5hWgAIYA9UAIwhIAnQD1 -QAtikgCdAGSf3Cqc/QppOJkXhhb9keIFoApFAPwg6BXgCwUAWKGEiReKGosY7BIJJKSbAABmkB4D -bhGk7i/igij6D+j/AQzuwoAAD90C/dBGFeAAVgAA9SAG6hIAnQD1IAmKkgCdAMjMA2gRpIgvgoIF -/wIvhoJkvZ8DaxGkuymygsHADJkC+XBGFe/2PgDlJEov8iYAAGABTysgIh3IkwO7Ea27HcjKrbsr -soD/9mwNoLsZAAAAJiRKnRTqFgwviv4AAPxEUBXv+EoAGcdAKZApANAECQkbCQxA7CRKJ4cBgADz -P++f0gCdAJ0U+iGGFaAEugAAAGTMkpsV+iGGFaAEngArIEtkvjEuIGxl7itj/JEvIR/5//dsUgCd -AIoWA6oRpKooooLHsAuIAQ6IAvlQRhWv+04ALSEf+b/5RFIAnQADbxGk/y7ygseA+cAEBzAIdQAI -7gL/8EYVr/wuAAAA2iBb/rP8RFAV7/QWACghH/kf9IlSAJ0AixYDuxGkuyqygsfADKoBDqoC+3BG -Fa/53gAtIR/5v/ZhUgCdAANvEaT/LvKCx4D5wAQHMAh1AAjuAv/wRhWv+r4AAAAA8T/ov9IAnQBg -AB+NFf2RCAWgCkUA/klwFaAbhQBYoRb6IYgVr+6qAAAAAJ0UA94RpO4v4oAYyGUI/wEv5oCaHC7i -gI0U/ZDuBaAKRQD+SVAVoBuFAFihCPohiBWv8vIA2iBb/kpj/9raIFv+SGP/mmwQBBjIZ6goJ4KA -x58JOQMJdwEHRwInhoAH6jAWx7cmYkWnYgXqMAUlDGpRDm0ICAnqMAkpDGqRAmP/8NEPAABsEAQf -x60cx/uLJyUgIhjIDPthyBXgCiUA6lo2CqTCgAD4gABCP/7lAOQwe21UwoAAblIJ8AAgDaCVAQAA -AMCQDp0B/7gAFrCZAQANmQIJmRGpqayZKJKDwtANiAIoloMN6jAp8kWtmQ3qMA2dDGrRDm0ICA7q -MA6eDGrhAmP/8MDQL0KAGMglCP8BL0aALSQrLbUjLbUkLbRCLbRB7bRhLpAEgADRDwBuUgnwACAN -oJUBAAAAwJAOmwH/eAAVsJkBAAuZAgmZEamprJkokoMr+t8LiAEoloMN6jAL6jAp8kWtmQubDGqx -D20ICAzqMAycDGrBA2P/8AASx0EtQoDi3QIK0ASAAPyQBhXgC3UAWJ5JZqAd+qBoHaALdQBYOWYv -QoAC/wIvRoD+kAgVoAIFANEPwCDRDwBsEAQpICOFJyYgIvgH4h2gNLUA5VIOJMvVAAD5AgAKccOl -ACMlHfJDhB3gBwUAJyQsJyQgJlRAJ1UjJ1UkJ1RC9qgmHeAqBQDnVSIiaByAAH9HCH1HAm9iAiRV -IidUYSZUYCYgIm5iB/AAGA2gRgEAwEAbx5L9/8Id4MQBAPyABAbwCSUA6Wk2Du/CgAANzALjmREO -ZkKAAKyZq5kokoMKiAIoloMI6jAUxzYkQkWoRAjqMAhIDGqBDm0ICA7qMA5ODGrhAmP/8BTHkANj -EaQzLzKAFMfEBP8BLzaAJyQrJ1UjJ1UkJ1RCJ1RB9qwmHeACBQDRDwAAAGwQBCIaytEPbBAEhSeF -XiRRIvqoEBWv6HUA6EIBAeQogAAoCggIIgL+YOAGEBkFAAkiAnonAn8nBX0nC26iCMYq0Q8AAAAA -APKkRB2gAgUA0Q8AAGwQBPJA6BXgAgUAgz4iNSMiNSQiNEIiNEEiNGHRDwAAbBAE8kDoFeACBQCD -PiI1IyI1JCI0QiI0QSI0YdEPAABsEASGJyZiDiVhIvgAgh2gKhUA+sgQFe/ZhQDpVQEB8FSAACkg -IwpVAuhXAgTL1QAACXU4/mDgB5ACJQACVQJ6VwJ/Vwr+oWAHUAIFAG6yA8Yq0Q8lZSLRDwAAAGwQ -BCYiBw8CACZiDiVhIvgAgh2gKhUA+sgQFe/ZhQDpVQEB8FSAACkgIwpVAuhXAgTL1QAACXU4/mDg -B5ACJQACVQJ6VwJ/Vwr+oWAHUAIFAG6yA8Yq0Q8lZSIiZSMiZSQiZEIiZEEiZGHRD2wQBBjGgKgo -k4AI6jAVxsclUkWoUgTqMAQkDGpBDm0ICAnqMAkpDGqRAmP/8NEPAGwQBI0rLNAEFccMjdD9mAAW -MAiFAPmGAA4wByUAB90268dnHu1CgACtzAXMCivGgArqMBnGsiSSRQpECAPqMANDDGoxDm0ICA7q -MA5ODGrhAmP/8IwrK8AEjMALuxEIuwIHzDbqx1ceZUKAAKy7BbsKKraABuowD+owJJJFpkQPTwxq -8Q5tCAgN6jANTQxq0QJj//CDKyIwBIMwCyIRCCICBzM2BTMRoyIFIgoiIoAC8kDRD2wQBPJBaBXg -BMUAIjAE4zIAKRbCgAAEIgLAQgQzNgUzEaMiE8c7DiIRoyKCIAICRNEPAABsEATyQWgV4BQ1ACIw -BOMyACkWwoAABCICwEIEMzYFMxGjIhPHLg4iEaMigiACAkfRDwAAbBAE8kFoFeAUxQAiMATjMgAp -FsKAAAQiAsBCBDM2BTMRoyITxyEOIhGjIoIgAkJC0Q8AAGwQBIUrI1AEFMa49KAIFeAHJQD8eAAR -sAl1APhmAAnwCIUAB1U27yILKq1CgAClMwQzCiMygCMlBC7wBI/wC+4RCO4CB/827SILL/1CgACv -7gTuCi7igC4lAyzQBI3Q/ZgAFjAe9QAOzAIH3TbrxwIe7UKAAK3MBMwKK8aACuowFsZLJWJFqlUD -6jADUwxqMQ5tCAgK6jAKWgxqoQJj//CMKyvABIzAC7sRB8w27SILLmVCgACsuwS7CizQBI3QK7KA -C8wR96EADv+O9QDuuwEO7UKAAK3MBMwKK8aACuowC+owJWJFqlULWwxqsQ5tCAgN6jANXQxq0QJj -//CMKyvABIzA/XgAFbAOtQAOuwIHzDaNKwXMEay7LNAEBLsKjdDrsoAuZsKAAA7MAvehAA73DgUA -7rsCDu1CgACtzATMCivGgArqMA7qMCViRapVDl4MauEObQgIDeowDV0MatECY//wjSss0ASN0OvG -wB5mwoAACMwCB902Bd0RrcwEzAorxoAK6jAO6jAlYkWqVQ5eDGrhDm0ICA7qMA5eDGrhAmP/8I4r -LeAEjuAL3REI3QIH7jbsxrIfdUKAAK7dBN0KLNaACuowD+owJWJFqlUPXwxq8Q9tCAgP6jAPXwxq -8QNj//AAjSss0ASN0AvMEQjMAgfdNgXdEa3MBMwKK8aACuowA+owJWJFqlUDUwxqMRBtCAgO6jAO -Xgxq4QRj//AAAIgrJYAEiIALVREJVQIHiDaKKwWIEahVKKAEBFUKiqDlUoAsRsKAAAmIAvdBAA1/ -6wUA61UBDVVCgACqiASICiWGgAPqMA/qMCJiRaMiDy8MavEObQgICeowCSkMapECY//w0Q8AAGwQ -BIIrgiATxnwDIhGjIoIg0Q8AbBAEhCuEQBXGeANEEaVEk0DRDwBsEAYCIwIrMgkXxnP1jBYFoAUl -APFgBKhQAnUAJzUCjzsu8ASP8O0xBC92woAAAu4CBf82Bf8RD+4IBO4KLeaADOowCuowG8WtKbJF -DJkICpoMaqEPbQgICOowCJgMaoEDY//wAI87LvAELTEDj/D92AAXMAiFAAjuAgX/NgX/Ea/uBO4K -LeaADOowCuowKbJFrJkKmgxqoQ5tCAgI6jAImAxqgQJj//AiMQLRDxbGSyoxAhzFRv4hoh3hDVUA -/UVODeEOFQB60nKJM2SQ+os37TUCJPP9AACeMwa7AQy7Avpg5hXhAlUA0Q8AAC8aAn+iEfvgCHsi -AJ0A+GBoFeAAegAAAP9ACksgC0UA+8AJOyIAnQDrNgMtyASAAGSQvII37zUCJMP9AACYMwYiAQwi -AvJg5hWhAiUA0Q8AJzoD90AFI2IAnQD64AnjIgCdAIozZKFAsKnpNgMp0ASAAFv+74s4CzxC+4AK -OaIAnQCNN/pAAAe/znUA7r4BD/9CgAAP7gKeOB7Epyc1AgbdAQ7dAvxg5hXjAjUA0Q8AiTgJOUJr -lgf5IBNiEgCdAPUgFCMSAJ0A9SATY5IAnQDAoPpgZhWgCQUAZZ8EjDgexWjH3Q3MAQ6+AS42CSw2 -CC9KCP5gRB3v+PIAf6JGevJJgjcYxJAuNQIGIgEIIgLiNgcvEASAANEPKBoEeKkriTNkn4v6YOgV -oQJFAOI1AiTb/QAAmzP3QAQFMgsFAAuqApo30Q8sGgZ8oaTaMFv+xY03LhoNLjUCBt0B/GDmFeEC -1QDRD8D/f6ngwLCJObG78z/t4FCKFQCbE3uqChvF3fpgRB3v9r4A2jBb/mIcxNTrEgMlfsGAAGAA -Qyw6B/1f+nQiAJ0AY/+hjTf0YGYV4QJFACI1AvegBAayDgUADt0CnTfRD483EsRcJzUCBv8BAv8C -/mDmFeMCNQDRDwAAjjst4ASO4P24ABawD5UAD90CBe42Be4Rrt0E3Qot0oDAhvzoAAV33QEAbYpj -DR8S/AIABfCNAQD4IEYVoO0JAP8ERg2g2o0AKDkJ+CAmFaCaCQB5sQqxifhhJB3gACoAALCIKDUJ -e+EfiRL6YYIVoLoRAHuRDbGu/mGEHaAANgAAAAAAsKgoNQzq1AAP6ASAACkwFvUgBuoSAJ0AKzkJ -+iAmFe8KBQD7QAa54gCdAGq/CYo48UAMD5IAnQAuMQq27i41Ci8wHPXgCGISAJ0AKjkMKPoA+wAI -WaIAnQBqrwmJOfEgDtgSAJ0AKjENtqoqNQ0rMQItGgb9YA0sYgCdAC8xCh7EF3/jEigwFgCIMmuE -CYk48T/zn5IAnQArMQ0axBD7X+9b4gCdAC0wHADdMvm/7uoSAJ0Ajjnx3/JoEgCdAGP9ywAAAAD4 -AKId4A9VAP5gZhXv9poA+AGCHeAIxQD4YGYVr/ZaAMCZmTP/9igNoAmVAIo48V/6T5IAnQBj/xmL -OPxg6BWgDQUALTUKLTUJ94AEBj/91QANuwH6YQYV4g0FAA3MApw38WAGn1IAnQD+YtAV4QJlAPJg -RB2v/rUADr4B7jYIJ/gFAAD+YsYd4QJlANEPiDnxH/ioEgCdAGP+6ok4HcSu+mDoFaALBQArNQ0r -NQyLOQaqAQyqApo3DbsBmznxIAf/0gCdAP4gwh2n2sEA/mBEHa/85QDsnAEG6AUAAC00HPxhBhWh -AmUA0Q8AAAAAAAD+YOgV4AgFACg1Cig1CffgBAexCAUACP8CnzfzQAjPUgCdAPhi0BXhDGUA/GBE -HaALRQALqwLrNggkyAUAAPhixh3hAmUA0Q/A8P5ixh3hDmUA/mBEHa/9tQANvQH8YQYV4QJlANEP -ACowH8CA6DUCJQQRgADCmnmgeBrFGfpgRB2v6moAAAAA+mDoFaALBQArNQ0rNQwbw6KJOAaqAQuq -Apo38yAFj9IAnQAuGgb+YEQdoA0VAP0mAA73ysEA7TYIJmAFAAD8Y4YdoQJlANEPwID4Y4Ydr//l -AP8gBAfxAmUAIjUC/mEGFeECZQDRDwAAAADaMFv9u+oWACnQBIAAW/2rjBAAqzLxhwAOMBk1AHyS -CcDe+6AGO2IAnQAsMBB7yneMOXLOTyswEbG7CwtH+mImHeABOgDA4P5ixh2hDWUA/GBEHeAMRQAM -rAL8YQYVoQJlANEPAMCA+GOGHaAPFQD/JgAP8QJlACI1Av5hBhXhAmUA0Q8AwJD4YiYd4AsFAB3D -/w3NAu02CS280AAAHsTV/mBEHa/mEgB8uhSMOXLGJCswEbG7CwtH+mImHeAAjgDAwPxiJh2gCwUA -aLfP+mIGHa/0DgDA0PxiJh3gCwUAHsTFDs4B/mEmFa//hgAfxMP+YEQd7+TSAABsEASLKiqwBBXE -UIuw/VgAFTAHJQAHqgIHuzYFuxELqgj1QAEFcDkFACmmgAjqMBbD9yRiRQhECAPqMANDDGoxDm0I -CAzqMAxMDGrBAmP/8IkqKJAEiZD9GAAUMAo1AAqIAgeZNgWZEamI9QABBHAEFQAkhoAD6jAN6jAi -YkWjIg0tDGrRDm0ICArqMAoqDGqhAmP/8NEPAGwQBBTDDShAffMAB//QDRUAGcSWHMSXKkIvG8SW -DKoMCps47zolbeAEgAAexJMOPgqO4ArgAAAAAAAAAAAexI8bxJAvLP0P6zkLywL5iRwF4AclAB7E -KgcqNgOsEa7MKMK4LsK4H8SICYgBCbkBD+4BDr4CLsa4+QAEjGIAnQAvQHz952ASX/XlAG4iM/5f -wBXgCzUA/gAiHaAGBQDv5jgLmASAAAazOQVpAejEeBzPwoAACWYCCWYRCGYMJm1YhmMuwoHTDw3u -Ai7GgQvqMClCIKuZCOowCJgMaoEObQgID+owD58MavECY//wKMKBBYgBKMaBW/DEKUB8b5RVbiJS -bjIL8AAoDaCTAQDAINEPwJAHPjYFnQH/uAAWsMkBAA3MAh3EW+PuEQ5mQoAArsytzJbAC+owKUIg -q5kL6jALmwxqsQ5tCAgO6jAOngxq4QJj//DSoNEPGsNpG8O+/GKABNNuBQDA+38xCm8iB/uIkgXv -+2oALyz9D7o5CssC/2YADb/7JgAAbBAEFsQkpiYlYoDHfwc3AwdVAQVFAiVmgNEPAGwQBiwgAfeI -dgXgBZUA4yAAJgJZgAB1wUNoyUBYnKb85CgV4AwFAFigTi0iBC4iBf1Blg3gDAUAetkCe+sBwMHx -gWAN4AilAPhAJh2vmSUA6SQCLJAEgADRDywgARbCmx7Cjh3DvfuHUgWgCbUA+YAFwuAEBQAZxCAJ -yQqJkAqQAAAAAABYnIz85CgV4AwFAFigMx/DExzDhtMP77sIDfAEgAD/YNINoA0lALGqmyXqJgQu -WASAAO06NgmYHAAAG8MmHMQOA6oR0w/9QABFMAwFAFv/xFicePzkKBXgDAUAWKAfHsPDDwIADwIA -/2AAR7AMFQDr+wZ9aASAALGtnyedJiwkAVicbPzkKBXgDAUAWKATjiYvIgf7wZYNoA0FAHrpAn+7 -AcDRyNTHJdEPAADsw2AZmBwAABzDCPuH4AXgCiUACjo2A6oR66oIDlgEgABb/6RYnFj85CgV4AwF -AFigAB3Do62969sGfWAEgACxrJ0n/EDGFaAOJQAuJAFYnE785CgV4AwFAFif9Y0mjif7oZYNoAwF -AHrZAn67AcDBZc+GwIMoJAEvcIDTD2/0B/R/+7FSAJ0A+mBoHaALpQBb/yZmo0nAlCkkAfpgaB2g -C6UAWASVHcNg7sIvHRZaAADZQB/DxwM8Ea/P68IxF8ATAACbgOshAifQEwAAJKYAGsPBCwhA0w/o -qTkF+ECAABjCPQ8CAA8CAAiZAn23CBrCMQ8CAAqZAvIgBhWgixkA+oBoHaBCBQAIKjniEgAl7CiA -ACgKgAiqAvuGoAWgijEAJhYCCKY5BpkC5hICJegogAAawo0KmQIawymqypmircguhrfow6UX2BMA -APlgBhWgC1UA+kAmHeAAKgAAAzwRqsqLofFgCQ7SAJ0AwLr6QCYd7/lVAOkkAiyQBIAA0Q/xIBN3 -kgCdAMDS/ECEHeAMdQD8QGYdoAolACkhAg8CAA8CAHyXDS4hA3vnB8D4D6oCKiUEe5cNKCEDfIcH -wZAJqQIpJQTAtiskASpwgG+kB/R/8TFSAJ0A6yADKdAEgABb/tJmoeHAxywkAesgAynQBIAAWARB -Z6AS+kBGHaANpQDtJAEtEASAANEPAC0hBBvDc/h4ABUwHAUA+0AARXDdKQANxDn8gGgdoBsFAFv/ -IVib1fzkKBXgDAUAWJ99HMNorLx7ywGxqpwn+kDGFaANhQAtJAFYm8z85CgV4AwFAFifc40mLiIH -/UGWDeAMBQB62QJ+swHAwWTNfvRAJh3gAgUA0Q/AINEPebclGcNWj6vx4AevkgCdAIijcIcTmaT1 -QKYVr/JVANEPIiACACIy0Q+tyCiCt/8f6f4iAJ0AwsGLo8CQ5CUDJaBkgADAkSklA/9hgABQCRUA -/EBkHaApFQB5tgfApAqZAiklA3q2B8DSDZ0CLSUDLiECxPD6gGgdoI4ZAOj6OQdsKIAAKQqACaoC -+4WkBaDKMQAMpjnaYFgzewpuQPiAaB3gDYUA7tk5BWAkgADB8A+ZAighAyohAgmIAgipAeglAyT9 -dIAAwLH6QIQd4AqFACokA/E/8daQChUA+gQiHaAsFQD8QIQdr/iqAAAAAAD6QEYdoA2lAO0kAS0Q -BIAA0Q+Ppoin8f/5BBIAnQCZpPVAphWv8lUA0Q8AAAAAAADxP+6nUgCdACohBMDF/EBmHaALRQAL -qgL6QIQdr/daAPpARh2gDaUA7SQBLRAEgADRDwAAAAAAAPpARh2gDqUA7iQBLRAEgADRD8D6/kAm -He/ppQDpJAIskASAANEPAABsEAgoIRiDJ/REUBWgB4UA+gBCHeAFBQDjMg4kFSmAAPyCIEFQDZUA -8AAsDaDkAQAAAAAAAN5Q+YTOBe/85QAM7wH/+AAXsI4BAA+IAgtPNumIEQ/8woAAr4ipiCiCxy8w -QRbC3+rC1RRoXoAAZPHh/eAcJGIAnQD14BuMkgCdAP3gFWRiAJ0AKKCADwIAb4RIKTBA/tYoFaAI -NQDsnP4skOgAAAyLOCxita6+Ce4RDswILsIHC7oC7uIOJ5opgAD14Bu5kgCdAPXgFIMSAJ0AKjxA -W/59YAAGACo8QFv+esDh6uo5DTAEgADtpAADFNGAAPgAIh2gDwUADY84ZPG4KTEk0w/xIAbX0gCd -ACowYfVABnsSAJ0A5jBgJQ2hgAD1QA1jkgCdAAvqMBzCrSzCy5oW/WBWK6IAnQAdwqAawqgt0iEr -psv7WUgVoAwFAFieti4yGi8yG/9Bjg2gDQUAeukCe/sBwNHqEgYmiyGAAB/CRS4yJQ/uAu42JSHR -wQAAW/wGKfqSG8ITA2oRq6olpkT1SMYV4Ah1ACg0YfhsRh3gBEIAC+owHMKOLMLL/WBTU6IAnQAd -woEawokt0iErpsv7WUgVoAwFAFielx/Che+7CA3wBIAAfrsBsaorNjEqNjAZwg8DSBEJiAgogo1+ -j08L6jAawnoqosv7YE9rogCdAB3CbhrCdi3SISumy/tZSBWgDAUAWJ6ELjIwLzIx+8GWDaANBQB6 -6QJ/uwHA0cCg9/JCHa/+VQD9zQALcAAaAMChZmDwLyArevkS0mDRDwAoICsPAgAPAgBkgZTAoOok -KyUN8QAAKSIRJSUf5SUeJMgFAAApJhElNSMlNSQlNEIlNEH0bCYd4AIVANEPAPVANGESAJ0AG8JU -KjIl9HIGHeAMNQAsNGELqgEqNiXHleaUAAT3gYAA//4cDaAKBQAtICtk0fj6oGgdr/5WAABvqNsY -wkYIqAqIgAqAAAAAKjEkwJL0Q8Qd4KoJAAqXOSclHykxI/8hwAcQCgUAxLD6Q8Qd4EoFAHuXCCwK -gAysAiwlHtpAWDr+LSIQ5SQgJugFAAD8QgYV4AIVANEPAAD/9zANoAYFAPogRhWv/lUA/sAj/CIA -nQAlNSMlNSQlNEIlNEH0bCYd7/u+ACrgQWShLS8KCf9ACTxiAJ0A9UAI/JIAnQAuFgH1QAijEgCd -AP/1cA2v+lUAKDEk8x/rH9IAnQAcwaMDSxGsuyqygcLADKoCKraBC+owGcINKZLLnRX5YEK74gCd -AB3CABrCCS3SISumy/tZSBWgDAUAWJ4WH8II77sIDfAEgAB+uwGxqo0VKzYx+mYGFa/0JgAoICtl -jmrAINEPACkgK2WeX2P/8SvgQci7wNl9sQf5f/uM0gCdACngYciZaJYH+T/7C9IAnQAowRhkjJac -EPdAGrFSAJ0A8A1ADaCaAQAq4EEPAgAPAgDJoMCZeaEMaKkJnhH5X/lh0gCdAO4WASHRAQAAW/2Z -ixErsEFkvHTAyf1/43wiAJ0A9X/jPJIAnQCOEbG9/cgmHe/xbgAAAAAAAAAA7hYBIdEBAABb/YuN -ESvQQWS8PMD5/3/hvGIAnQD1f+F8kgCdALG4+agmHa/wlgAA0lDRDxrBRANpEaqZKZJG8T/u5tIA -nQDAtis0Yf/3RA2gCQUAHsE8A20Rrt0v0kbx/+3kUgCdAMCT+GwmHeAIBQAoNisoNiopMTp1lw/x -IB9lEgCdAP/xuA2v+bUAKTIl0w/zIAZY0GnhAHSWQgvqMBrBrCqiy/tgOBOiAJ0AHcGfGsGnLdIh -K6bL+1lIFaAMBQBYnbUuMiovMivTD/vBjg2gDQUAeukCe/MBwNFk0IAqPHBb+wr8ZKgV4QkFAOmp -AQVcPIAAGsD80w8K3QItNiUfwZjAgQmJOe/dAQzxQoAADt0C7TYlJpEYgAAL6jAZwYwpksudE/lg -NIviAJ0AHcF/GsGHLdIhK6bL+1lIFaAMBQBYnZWNE/9gaB2j64UAC+sIfrsBsaorNisqNioNxlBk -bLrAxCw0YSowkMDe/UAOsuD29QAewXwOrgqO4ArgAG5iB/AAGA2gpgEAwKAmNi4mNiwlNTolNh8l -NIAlNIElNUElNUIlNIYlNUQlNUUlNIwdwW8ewW0vMiT6AcId4JoBAPtABAXwChUA+2YADT/IdQDr -wKkd58KAAAj/AQycAuw0vC1XwoAA+yYADL/4tQAI/wEawWD8ZQgVr/jVAAj/Afh2hh3v+OUACP8B -KTIlGMFaLzYkDswBJTSQLzIkDcwB+yAEBPC+BQCuPi42JwqZAR3BDhrBSwj/AS82JA3MAfuABAZw -vYUArT0bwUMsNigtNiYLmQEKmQHpNiUh0cEAAFv8Zh/AtwNuEf/AAEdwDyUAL+ZEJeZGwNMt5kYL -6jAcwTMswsv9YCiLogCdAB3BJxrBL54ULdIhK6bL+1lIFaAMBQBYnTwfwTWNFO+7CA3wBIAAfrsB -saorNhv6Y0YVoAgVAPhsJh2gADIAHsCdA20Rrt0v0kbx/9oekgCdAMCC+GwmHa/12gApMGLxJwAM -v+zCAMCQx84MnAH/mAAWMLkBAP1mAA2wDCUADKw26bsRDmTCgACsuxzAiqy7K7LH82ARTpIAnQAv -MEFj+QAAAAAA2iD9gX4FoAsFAFiZzfogSBWv6c4AHcEOLDIjKzIk9m4AFa/MQQDtuwEOZoKAAOy7 -AgtQBIAA+mSGFe+7MQBb+mEqMiQKak9qqyLBsHq6LRu/a/tAB/tiAJ0A+2APeaIAnQAsreBlymxg -AeEAAPdAGeCSAJ0A+V/SoRD29QApMij1QBmgkPb1AAeeEf2B2AXs7g0Ase4ODkftnQEPdEKAAA7d -Ai02KC8yJ4/wGMBZA/8RqP8v8kEPD0dk8uUoMieIgBnAVAOIEamIKIJBCApH6DSPJQHRgAApCip5 -oC8qMiT4ZQgV4AwVAPxx5h2vujEA9WAXyJIAnQAfwNEewBctMiUPnwEvNigO3QItNiX6bgAVoAsF -AFv6KygyJ4iAGcA9A4gRqYgogkH4381OIgCdAMCV+HIGHe/m2gAcwDUDaxGsu/doxhXgClUA+mwm -Ha/megAAAAD5X8vmUPb1ACkyKPVAFRESAJ0AB54R/YFoBezuDQCw7g4OR+2dAQ90QoAADt0CLTYo -LzInj/AYwCED/xGo/y/yQQ8PR8z4wIb4cgYdr+UuACkyJ4mQGsAZA5kRqpn5KCgV4AsFAOk0jyHR -wQAAW/oAKjIniqAbwBEDqhGrqiqiQXpgCcC3+nIGHe/kOgAqMI9kqOzCyv1fxz4iAJ0A+m4AFaAL -hQBb+fItMieN0B7AAwPdEa7dLdJBDQ1HZdDu9nIGHe/jVgCeESXlIyXlJCXkQiXkQeXkYSdRAQAA -W/w0ihD9gGQFoAsFAFiZQP4gKBWv9sYAACY8cNpgW/nYCgtHzLjAwvxyBh2v4j4ALTInjdAev+oD -3RGu3e3SQStQBIAA/HHmHeALBQBb+dEmCv8uMieO4B+/4gPuEa/uLuJB/t/B7iIAnQDA8/5yBh3v -4SoA9m4AFaAAmgAmPHDaYFv5vwoIR8yIwJz4cgYd7+CuAPrAaB2gCwUAW/m92mBb+bcrCv/7f7/O -IgCdAMDN/HIGHa/gGgD2bgAVoAIKAPZuABWgAVYA9m4AFaAAqgAtMieN0B6/wgPdEf+gAEawCwUA -7dJBIbHBAADtNI8rUASAAFv5p9pgW/mhLgr/euAJwPn+cgYd797OACsyJPrAaB2vuzEAW/mf2mBb -+ZgKDEfMzsDa/HIGHe/eRgAAAAAAAAD6wGgdoAsFAFv5ldpgW/mPLgr/+9+6ziIAnQDA+/5yBh3v -3ZoAJjxw2mBb+YgoCv96gELAkfhyBh3v3ToAwKT6cgYdr90SAAD7X7kgkgCdAGP/1A+cEfuAPgXs -zA0AscwMDEfrmwEOYkKAAAy7AvplBhXv8z4A2mBb+XT6ceYdr9vGAAAAAAAA/YAmBeAOJQAOrgIu -NiQNnQH8ZQYV7/QuAA+fEf+AGAWs/w0AsP8PD0fungEP+kKAAA/uAv5lBhWv9YYAGb/9KJLKsYj5 -OUYVr9guABq/+SmiyrGZ+VlGFe/UzgAcv/UqwsqxqvuZRhWv3oYAHb/xLNLKscz9uUYVr9Y6AB+/ -7S3yyrHd/flGFe/rngAfv+ku8sqx7v/5RhWv49oAGL/lL4LKsf//GUYV7+WeAAAAAABsEAYcv+z8 -YEgV4ApVAP5gaBWgCwUAWJhMiDCGMhm/5uQyAygECoAA8QAE4pIAnQB2mxTGyupUAAnYBIAAWJqI -wCDRDwAAAAD0gAQhkAsVAOoiByoCCoAA+E7wFeAM1QD8QbAV4MydAOqiDioBCoAA78cHfLgEgABl -37fguxoDcAUAAOsWACMEYYAACbkC+oABB7eZAQDpJHcn+BcAAC716O716SOCaYAA3UD+wGgdoApV -AP1/hAWgCwUAWJgj//3MDaAMBQAAAP/9pA2gDAUAGr7aKqKN81/7sNIAnQDAov1/cAWgCwUAWJgX -Y/9EAAAAAGSfs8Cl/X9mBaALBQBYmBIbv1Xsv7AZUASAAFiYZWP/ld1A92BoHaAKVQD9f1YFoAsF -AFiYCCkgd8evCmoDCpkBCQlH6SR3I/whgABln3zApf1/RgWgCwUAWJf/2iBbF5hj/2cAAGwQBoQn -Fb+dKSB3hE72AAIdoAMFAPpgCADQB0UA9ICgJaCJnQB/h2cqQeiwqgoKT+pF6C0C5gAA6RYCIZzx -AAArIA3qIAwtg2YAAOkWAi1WAoAAGb45CghHCYgKmBEogpAKihQqFgALgAAKCUHokV9tWASAAGiT -WihSf9ogC4AAKkHo0w8PAgDpEgIlA7mAAOZsBCKoEQAA5EwEIZgFAADgMAQDu/0AAP73nA3giZ0A -YABwG79ziiArsn+ZEguqDP1AABUwCxUA+0YADX/+HgB8pxmNJ43eiRKm3f2gwCXgDBUA/a0EHa/+ -pgAAAIgRKIKS+iAIFa/5xQAJuwELgABj/3QqIHf6YAQA0AsVAP1gAQXf/PUADLsDC6oB+k7mHa/9 -wgAbvvfsv1IZUASAAFiYB8Ag0Q8AAGwQBOokAAnYBIAAWJVGZqAx6iQACdgEgABYMGMZvsUDKBGp -iCmCgBu+MguZAimGgMAg6IKAJQBdgABooAPSoNEP0Q/SoNEPAGwQBGP//AAAbBAEE78+wIgoNlLA -ICI2U9EPAABsEATAov1+cgWgCwUAWJeRwKZbeMzAINEPAAAAbBAEwKT9fmYFoAsFAFiXihi9d9MP -KIB9e4dAHb7TGr5C/A8CHaALBQD9sIgV4BkFAG2aDC6hlOzhCHVQCQAAsbvHuwCwBPyfAA/wCiUA -/gAAB/ALFQAPujlYd7fAINEPbBAEwKT9fjgFoAsFAFiXcsAg0Q9sEAbAwfwgBh2gOoUA7BQBKNgE -gABYOAdmoBLDqfogIBXgDBUAWDgDZqACKhABGL4hKIKNCNhQ+QABBDB5NQAJiAl6gxOKJ4quKq0F -KaHv+V3EHeACBQDRD8ClW3iWiieKriqtBSmh7/ldxB3gAgUA0Q8AAGwQBBq+/OqifylYBIAA/GBo -HaANFQBbdyrSoNEPAAAAbBAEGr70KqJ/2yBbfufSoNEPAABsEAaUEZIQ577vG2AEgADtVAAJ8ASA -ACgaQCh2ECdyEecWAyOPkYAA+AACHeAKBQD6AAId4AMFAPACgA2gBRUAAAAAAPJj8A3gJwUA+u8A -C/AEBQDnFgIjkqGAAIYSJwoA+uAEANACFQDmbP8qmAqAAG1pD+AhBAEQBQAA40QCCpgKgAADQwIn -4gADhgHj8wENgQqAAOLSACmYCoAAA3cC5hICKxgKgAAn5gADIgInEgDjEgErAgqAAPOgBhWhb50A -9uAGFaEonQDyYAYVoAMFACus4PUgCfSSAJ0AhhMAkQQAVxr2wAQDcCgFAO5sTGTIBQAAdoN8L8Al -6MAkJVAhAABkr871X/neUgCdAIbg4tIALYEKgAAA9xrnZgIMGAqAAOMiAg1YBIAA98AGFaADFQDz -oAYVr/56AAAAbmRW9MAEytIAnQAmwBzvwRclUEUAAPmCxBWgdhEA+OAAE7BmIQDn/wILNAKAAPcG -AAw//lIAAAD8x4BH0QcFAPbgBOOiDwUAiMj7QGAVovgBAP/9wA2iiBkAbmJi9N/5udIAnQCIyPtA -YBWi+DEA//1MDaKISQAA9sAEJ1CPBQD3//ijogCdAIjI+0EgFaj4cQD//MANqIi5AAAAAAAAAPzO -gEXQHwUA9//3Y6IAnQDvwCclUCEAAPmE0BWv/CoA+N/2oNIAnQCIyPtAIBWg+GEA//vADaCIaQDA -INEPAAD+3/WlYgCdACjAHPtAIBWg+DEA//s8DaCIOQAAAAAAAPjf9KbSAJ0A78ENJVBBAAD5gYQV -r/rKAPjf8+RSAJ0AJsAc78EVJVBFAAD5goQVoHYZAPjgABOwZikA5/8CCzQCgAD3BgAMP/n+AIYQ -gmAAsQQA9xoHIgKSYIYRgmAAhxoHIgLywAYVr/i2AAAAAAD/91wNoAMFAGwQBPYWAh3ghgUA8uIA -C3CVBQClZeJWOAIT9QAAKGxAAoY40mDRDwBsEAQVvjrTDyRSVSVSqf6YABIxCAUA5UULAnhfgAD1 -DwAMMAoFAG2JBylRAHKRA7hV0Q8qVQGaUSpVANEPAAAAbBAEH74qKfJVLvKpwND/OAAUsQsFAO6a -CwT5m4AACbsMbbkcK6EA3KDisTV8wASAAPFkMA3nmQEA6swIJEgFAADs8qkmgdmAAC1UAA7WCwzc -CyJlACPFAfWAJhWgAhUA0Q8jpQGUofigBh3gAgUA0Q8AAAAAAAAA/SIADv/+9gDHL9EPbBAEF74J -0w8pclUocqn/OAAUsQoFAOiYCwT4Y4AACaoMbakNK4EAcrEL6ZwBJEAhAADHL9EPI4UBlIH4oAYd -4AIFANEPAAAAbBAEKCAEijP8AAId4An1APkBBg3nqsEAwCDRD+0kVCUAyYAALCIUH73vK8EAHrw8 -D7sBDrsCK8UAiCIrIhMqIhItJhL8QmYV7/nlAAmIAfhARhWgDAUAWJh9wCDRDwAAbBAEKCEHGb3g -CAhKDIgRCYgCmDCHIBa93em8txu+AoAAB0cClzHmABUBkCEAAAIAipU16TYEIZBhAADRDwAAAGwQ -BusyAypoBIAA+kDoFaAGBQDmJCcrYASAAPtgAAL/O4EA60QABVCBAABbdkwqICbAseS8kRGIaYAA -56QADU8CgAD1QAZCEgCdAKSZLJKemhD3gAix0gCdACmSnWSQ7C4hBx+9uQ4OSgzuEQ/uAp6QjSAc -vbb9oAAWsA41AA7dAu2WASTQIQAA7AAVCZhCgAAKAIr9eRIF73/1AP6gBAf2hQEA7ZYELEMCgAAI -MwL8QwQV4ByFAJyV/EIIFaCFOQDqIhEsRUKAAAj/Aogg5pYJL/wCgACfmJOX+yFmFaLdHQDqvZse -7AKAAA3MApyaCogCmJaDIgszApMi4xIBK/8CgACk///zphWgAgUA0Q8du8eM2OoWACYNc4AADHkR -pJkukp5u42gpkp3kkGRmc/0AAJ7YZZ8o+iAGFaAASgAAAAAAAPpKhh3v+84AAIsQ2iDrvBgpYASA -AFt3ZywgJ8vMwCDRDwAAAAAAAAD/+7QNoAkFAMCgWJYmHbusjNiKEP2TAAjQCxUA//6gDaAJBQDA -kMDqDs40/6EGFa/+ZgCKJ8Cw+0QAFaAMFQBbeIEcvWkfvLGfoO0iACn0AoAADl4C/UBGFaALFQDu -pgMu7gKAAAvdAp2h+kTmHeACBQDRD2wQCIggIxYEKRIEIyAHF7wi9gBCHaAEpQD5APIN4TMBAARG -AvRgCUoSAJ0ADDgRB4gIKYKe9yATG6IAnQAogp0IhALoFgMkCimAABm78AkAh21pAggCYSkhB4sg -Grwe/CCIFaqZAQAMmRHqmQIN1gKAAP1gCNOgBQUAH70/mUD/eCwFoAyFAJxDnkL5eBAF4A0lAA2q -AipGAQm5AilGBCrygC7yf+shCSnHAoAA9wAARHAMBQDmhp0nc/0AAP/v5hWgDRUAW3VXiico+sDl -pgoleIEAAAj/AY4iL/xAn6nvpggnArGAAP16SgWgClUA/EAIFeA7JQBYlW+IImSAhMCw+/4CHa8J -BQBtCA14kA0IiBTkgBxl2CEAAGP/63igC7S78AAYDaSIHQCxuwgYFGWP99ogW3bSiifHnymmACUm -B1tx6iUkBOUkBSoQBIAA0Q8Vuz6JWPcgClCSAJ0ADDgRp4gqgp73QAqTogCdACiCnWSBSbCa+qEG -Fa/7GgAAAAAAAAD//qgNoAsFANKA0Q8fvPyOExy8JJUR9CAGFeANRQDtqwINx4KAAC0gBwyIAvnA -hhWgLIUAnOOZ4JvhGbvG+cBGFeHdAQDtFgIo0ASAAO/dAgFZhQAA/cCmFeAMNQBYkW20GvpLoBXg -DDUAWJFqjxMeuy0bvOOV+/XhRhXv+PUAmPmY+Jj3lfaMEIoR+EDkFeCEBQD14ABCN8zBAAyqApr8 -ihKNEBi7rAuqAuu7qR7uAoAA/6YADrqZAQDt9g0szwKAAAuZAin2EIsgJfYWJfYXJfYYJfYZJfYa -JfYbJfYcJfYdKPYS++KmFaAshQD94mYVoA5FAOy76x3WAoAADq4C7vYRLceCgAAMiAL54oYVr/ee -AAAAAAAA//aADaAIBQDAoFiVYolY+T/1eJIAnQD/9iQNoAgFAADAgASaNPqhBhWv9e4AAAAAbBAI -KCAFw64PAgD7AA2kIgCdAIknKiQFDwIA+yQAFe/EBQD1YAQFsAMFAOOWCiXRAQAAmpnqlggpUASA -AFsUhfpAaB2gi0UAWDsFIyIJZDE+93k0BeBG5QD2IKYV4FdlAIk3iJqFOyowBeSSCSQBUYAAd6Eq -90AG/CIAnQDmNAUp0ASAAFsUcxm7kyqRf36nGM1IYADBAAD//1gNoAQFANowW3FnYACvAABkQKqM -FY1DjkKJQIpB/mEEFeA7JQD+IOYV55nBAPggxhXnqgEA+iCGFaAoBQDqMgAsAgqAAPogBhWg7p0A -+CAmFeAKVQBYlL4bu3grsX+KF/9qgAdT/PUAfKFijRZo1ihkQErqNAAKWASAAPwgiBWgj0UA/oEE -HeAOFQD+YqYdoA0FAFhqXWAAJI0UijcsCgAPAgDr1AAFUIEAAFt02vVAaB2v/voAAAArOv97oQ/j -VAAK+C4AAPJBKBXgALIAjTf9pAAVr84FAP+ABAYwDgUA7tYKJmEBAACc2f2hBhWv/0IAAAAAAOsi -CiGBeYAAyrwpsgsPAgAPAgDInm0ICemSCyzYBIAAyJFj/++Tu/phhhXgDwUAnynRD9EPAAAA8kFG -FeAIBQCYKdEPbBAcKDAiFbw5CIgJDIgRCFMIJTJ/y14eum4tIAwSuo0u4i0qIoMO3Qjp3REK2ASA -AP1AAEVwDBUAWIoM9gWiHaAnZQDwgRAN4Cw1AGhDCfSABWKSAJ0A0Q8voAXTDw8CAHzx8sKCKKQF -WxQF8nBIFaGKBQD6YABFMAsFAPtPJh3v+fUA6aR6KQFmAABj/8cAAAAAAPpgaB2gCxUAWFNkIzIJ -yDkrMAV2uemDOWU/9IIpZC+iLCIVdcn0LSAFd9Hujycp+sDk8g4nwIEAAAmIAfZAph3gDgUA7vYK -JEEBAACY+ej2CClQBIAAWxPlKkERgyqxqupFESn9ZgAAY/+vLKQFWxPfIjKCZC9LH7vw7xYtIPBl -AADuFi4g6HUAAO0WLCDY4QAA+iXmFeAAqgAAAAAAAAD6YGgdoAsVAFhTPCMyCcg5KDAFdonpgzll -P/SCKWQvAikiFfU+ng3gK1UAKiAF+0AHjWIAnQDsEi0owASAAPJBSBXuDgUA/iVGFaANBQD8JWYV -4AsFAPwAChWgCkUA/XeuBaAZVQBtmgIIAIqcEIgwKhQY+iJmHeP59QApFQj9AAAUMAm1AAmIApgR -LzAE9eAGgpIAnQAqEi76aeAV4Aw1AFiQSCoSLPppgBXgDDUAWJBFFLobKDIVDwIAJEKDw5/pNAUs -RkKAAKhE+iXoFaAJVQD4JgYd4AgFACgUMegUMiJZAQAA+CZmHaAMhQBYkDXrTEgg0f0AAPtFoBWg -DDUAWJAwLhIr6jQACNgEgADTD/8OAA8wDLUA/iGmFaANJQBYT3OIJyr6wOSCDiRIgQAACpkB9kCm -HeAPBQDvhgokyQEAAJmJ6YYIKVAEgABbE38rQRGDKrG760URKfWuAABj/rgqEi76aQAV4Aw1AFiQ -FSQcfyRMKS9AAe1AAiDwdQAALeQCL+QB9IAQFaAstQDk5AApoASAAPxgph2v/L4AAGwQBikwIhi7 -hAmZCQyZEQmDCCsyf2Sw8BW5uSwgDBK52C1SLSoigw3MCAnMEf1AAEUwDBUAWIlY/IOAEdArJQDJ -RC6gBXvpF8Lx/0CmHeAASgAAAAAAAAD0gAkjEgCdAPpv6BXhhwUApzokoHsmoHrloHglhKmAAB65 -oS2ggC7iLSoig67dCd0R/UAARXAMFQBYiUEvoAcmpBb0AgAEcPm1AOn/AQxHgoAA+eYAD7D+xQD/ -4AQHsZUBAAn/Ai+kB+oyhy0QBIAAHLtWK6AHLSAFpzgOuwH7JgAM9/YBAOmkBypwBIAA+Q8wFaA7 -JQD4IAYVoApFAFiTkiMygsg5FbtJ+JgAEjAALgDRD4M5ZD/4jTAqMRkuIAcpIBbpNBYq4ASAAP5g -5h2rqgEA+oYADTA7JQD6YyQdoApFAFiTgYo6zKZj/8WKqWSvwCwwBy0wFisxGYmqK6UnLaQW7KQH -JP8xgAALC09tCBMrlSIuoAcvoBYvlBYulAeJmGSfx2P/5SigBcKT+R/2vWIAnQD7QKYd7/s+AAAA -AGwQDBi5WBu7IuK6ehlIBIAALIIzKIIxIiKBqczpiAgOZkKAAKwsLMIH67CALEZCgAD4QABBMAoF -AP2ByBWgCEUAbYoRAKAECw0b79cGdXAFAACeHLGqJRqApcUvUOX34A2AkgCdAJkWFrsM6rsMFOv9 -AAD/dhAFoAwVAP4hZhWgCwUADcs46xYHLMeCgADqiAgM/MKAAOb/CAGgCQAA/iEmFeAGBQD4IQYV -oAgFAPghRhWgAuIAjxoPAgAJjzkvFgrpEgot34KAAACxBACqGgqZCCoSCPgAAh2gCwUA+VhmFeAK -hQBtqhf7AAQA06kBAOCqGgRACQAA+2AARbSZHQCMGSvGi4wbLSAiLhAULxAT+CJQFaAKRQD4IAYV -oDslAFiTISogIikQExu63gqsCe0QEi5nAoAA/WAARbAOFQAutH0ttH4ptHwsEBQstH8BEQJYA+Ut -UOUjPAPkTAMjMAUAAPzABWHiAJ0A5zABINBBAAD6gGgd4AwlAFiPRAdeQv4hphWgCBUA/iKGHaL3 -AQDi6wgPAQqAAO8kZyxACoAAKCRmLREILSU0KhEILLBUjRYtFBMsFBUrsEwrFBL9dXQFoBuFAPog -BhWgClUAWJL2Grq3KVDnKxEIZZ93erE0HLq0jRz9f/tlIgCdAPm/+KlSAJ0AjhaLHfgg6BXgChUA -6LqoH3WWAADA8P4hRhXv+s4A0Q+KFvwiQBWgCyUAWD/8Y/8vbBAE4rjPGWgEgAAcuqEYufAkIjMi -IjEogoGtRO0iCAomQoAApISER+4wASkWQoAAqCL0gcgVoApVAP5Fph2gG4UAWJLQKE0CKIBnyIXR -DwAAAAAA+kBoHaALFQBYMObRDwAAAGwQBPdzBgWhF0UABycop2YnYucEdygHdwr++AATs+iFAAh3 -LBq6g+IpCwnHAoAAqGYDmQkYuoAMmRGqmQh4ApiQ9tTmFeCVxQAlZqbRDwAAbBAIFLiiKDAAFrnE -JUIzJEIxKWKBolXiRAgKrkKAAPUgAELwCoUA9KDoFeKIAQDoqDgKJkKAAOlECAHYBQAA9KHIFeAM -RQDoRGQg0EEAAFiO2YkUsDv4n+AVoA0FAPyMZh3jqQEA+opmHaSZHQD8YZAVoAp1AA8CANMP0w9t -qh/9DGYd46kBAOyEXCXb/QAA+wpmHaSZHQDssA0kQ/0AAOy6Uh5YBIAAK4RcjhQvQFcpQFYnQFso -QFgqQFUtQFkrQFrjQFQtVAKAAODdEQxCAoAA7YgCDd4CgADrdwIJmgKAAOozAgzOAoAACf8CA/8C -CHcC5xYAKWgEgADyjJAV4ApVAPIgJhXgG4UAWJJxLF0CLMBnDwIAZcBtLUBkg0AoYn3yAAIdoAYV -ANMP6DMMBoLBgADaMPpAaB3gDAUA9EAAQrANBQD0qpAV4A8FAP4gJhXgDgUA/iBGFeBpRQD4IAYV -4A8FAFtuFGagHQZcN+o0AAlYBIAAW2345qAOYRAFAAAoQGR4I6vRD9EP0Q8AAGwQBMAh0Q8AbBAE -wCHRDwBsEATAIdEPAGwQBBW4OBi5WyZSMyVSMSiCgaJm4lUICzZCgACmhoZnCVURqFXmYg4iAfmA -AP10CgWgClUA/mAQFaAbhQDuVC0paASAAFiSOPqgaB2gCxUAWDBSKW0BKJGhwKIKiALolaEpkASA -ANEPwCDRD2wQCBi4HRa5QOOCMynQBIAAKIIxJWKBojPiiAgJnkKAAPKgAEHwCwUA8mDoFeAP9QD9 -CAAUMAmFAPigAEKwAhUA4zIOIgZ5gAD9QAgVoAQFAG2aIwtdDPtPAAxz7AEA/8AFTGTMHQAk1GMu -1FMogAvo1Fsl2AUAAItQKaAMKVRkJmJ9wEDmtgwEg4GAACoWBNpg+oBoHeAMBQD0gABD8A0FAPbq -kBXgCQUA+CAmFeAOBQD4IEYV4GhFAPggBhWgDwUAW224ZqAbAnw36mQAClgEgABbbZzmoApiIAUA -AChQZHhDqys9ASmxoYoUApkC6bWhLRAEgADRDys9ASmxoQKZAum1oS0QBIAA0Q/zrGYdr/1qAMAg -0Q9sEASIMCowCCswCfEACSpTKAEA9IAF6tAO1QD8YgAV47sBAPogAAYyqiEA5MENZkP1AAD+AEId -4AQVAOj0OAUHqYAA9UAHa9IAnQAEpgwGBkemufnAButiAJ0AZGBeGLmZ77hCGXTCgAAOvgro7ggL -SASAAO/vCA7YBIAA9SAGuJIAnQDotAAN0ASAAA8Ah+sABwdwQQAA6gYABMv5AADqJgAH+EEAAOiH -HgXYQQAA6IMeDP5OAAANaxENvQoEDkdk4Fn6QGgdoAslAFgAKGAASwAAAP1y4AXgH6UA70lUeWTC -gADbMPgBoh3kyAUAbZoYrImtmSqSgOmSgSXYIQAA6rYBJEAhAACZsPpAaB2gCyUA/G4AFeAMNQBY -ABTAwOpUAAnYBIAAWJPlwCDRDwAAAAAAAP//nA2v7KUA/19ADeAEBQDquAgFO7OAAOji5H0wBIAA -Y/8GGbj5qekqkoCasCmSgflgJhXv/T4AbBAEGLlWx5zogoAiAIGAAHSYCBq5Q2gxC2gyCMYq0Q8A -AAAAACqggAAgBAoKG3+n6vRgCtkSAJ0AF7lKHLlJCANBZDFV9GAK4JALFQAPKREet+wauUXtuN4S -fXyAAMAk7ngIDRgEgAD4QAXg0gCdAK1/IvKAkjAv8oGfMem2CQ2XwoAA5psvcXgFAAAKmAqDUPKg -KBWh/x0Abfkah4Cjc5NQhoB2OwOxIpJRj4Gi8uJWASRAIQAAuFXuR2N9GASAAP+AAEIwAkUA7wIA -CbgEgAD4QARI0gCdAK3CJiKAljAiIoGSMem3CQ2XwoAA55svcUAFAAAKlAqDUPKgKBWhiB0AbYka -ikCjo5NQiUB5OwOxIpJRi0GisuJWASIgIQAAwCDRDwAAAADvNAAJsASAAAgAh+MABwO4QQAA5gYA -ARP5AADmJgAEQEEAAO+HHgGYQQAA74MeCXiOAABj/x3YMAQgh+MgBwZgQQAA6EYAARP5AADoZgAC -IEEAAOePHgGYQQAA54seCXoWAABj/1YAABy49/dx7gXv+qIAwJD/+rwNoAtFAB648wMtEa7djdD6 -AEId4AoFAP21YCXgCUUA/UIADP/6NgAAbBAEiDD+YTAV4BqlAPphEBXv7KUA8QAHelMoAQD0gAb6 -0BdlAPxiABXgBBUA+iAABnXvAQD+BwAH8rshAOTBV2ZL9QAAKAoC6YQ4BYohgAD1YAnj0AgVAAS2 -DA+POf7tAA13ZgEABugI+UAJGyIAnQBkYGwat3EYt4D6gAId5UkFAA+5OenuCgl8woAAD+4I6O4I -DtgEgADq7wgLSASAAPUgCLiSAJ0A6LQADdAEgAAPAIfrAAcHcEEAAOoGAATL+QAA6iYAB/hBAADo -hx4F2EEAAOiDHgz+TgAADWsRDb0KBA5HyOn6QGgdoAsVAFv/UvAATA2gDAUAAAAAAAAAAPqChg2k -CAUA6lQACdgEgABYkx3AINEPAO24khnYBIAA+FgAFjAZdQDTD22aGKyJrZkqkoDpkoEl2CEAAOq2 -ASRAIQAAmbAoWkD6YGgd4Bm1AG2aGayJrZkqkoDpkoEl2CEAAOq2LyRAIQAAKbYu2iD8MwId4AsV -APxgAEbwDDUAW/8t//4EDaAMBQAAAAAAAP/90A2v7KUA/39ADeAEBQDr6AgFu7OAAMCRD585D3o5 -eKLc92BoHa/69gAauBOq6i+igJ+wKqKB+2AmFa/8PgBsEAQat5oXtxgZtx4YuEqnN9MP0w9tCEzo -UUxqWASAANxALYJALpLSCuYBBiYCJpbSL5LSBwCHBABhLpbS7ZLSIiBBAADsBgABmEEAAOwmAAO4 -QQAA64ceAqv5AADrgx4CgYGAAGP/qCuCQC+S0gr3AQcnAieW0iaS0hW376U1JlKAlkElUoGVQC+W -0i6S0tEP0Q8AbBAEizDGyvFgBaJQqzkA9oAFYVCGBQAftu/ut+IYBAqAAPSABKLSAJ0AJDEEBM1C -8aoADeREAQD1oATD0BwFAPWgAESwGBUACsg5+QAEK+AMFQDAkPuCAAyzCAUA6YY5AeBBAADmSgsF -4c6AACkgDBu4NwaZEampq5mvmvWgCbCSAJ0A68QADngEgAAKAIfsAAcEyEEAAO8GAAbr+QAA7yYA -BVBBAADrhx4GYEEAAOuDHg7+TgAAYAA9wIl4QVTqVAAJ2ASAAFiSl8Ag0Q8AAAAAAAD//5wNr+yl -ABm4HcC4bboJLpKlDg5SyeK4mcCwqrsqIDdb/53//wwNoAwFACuSpAsLSf9wABW//5oAAAAAAAAA -6LdBceAhAAAZuA3A2G3aCS6SpQ4OUsnnuJnAoKar+kbwFaAdBQBb/4z//fgNoAwFACqSpAoKSf9Q -ABU//4YAAAAAAAAAKiAMG7f+BqoRq6r/QABF8BkFAOiRNG5oBIAA38ALIIfsIAcFUEEAAO9GAATL -+QAA72YABdhBAADtjx4GYEEAAO2LHgz+fgAAY/+YrqgpgoCZwCiCgfmAJhWv/i4ArporooCbwCqi -gfuAJhWv/NIAbBAEKCAEaIYFwCDRDwAAFLfgjC4rQn8JzBGsu4u3i74usB0psBwqsBgtsBnssB4s -zgKAAO6ZAg1WAoAADaoCLrAa7bAfLM4CgAAMmQLssBsszgKAAO2ZAg1WAoAADqoCLbAV7rA1LVYC -gADsqgIE4AUAAP1j5h2ojB0A6csGd3AFAACxqiywFCi0Hi60NSq0Gy6wFvtiEBWo+h0A/2NGHeiI -HQD5Y6YdqP8dAP9jJh3oiB0A+WOGHaj/HQAvtBjvsBEuZgKAAA3MAu2wEi5mAoAA7swCDVYCgAAP -qgLvsBMtVgKAAA2qAi2wF+4xCy1WAoAA76oCDmYCgAANzAL9wABGMA0FAP+A0g2o/B0AsaoqtBMs -tBf/YsYd6IodAPliRh2o/x0A/2KmHeiIHQD5YiYdqP8dAP9ihh3oiB0AKLQQjC0rQn8JzBGsu4u3 -i74vsBkqsBgpsBwosB3ssB4tVgKAAO+qAgzOAoAACJkCL7Af6LAaLM4CgAAMmQLssBstVgKAAOiq -AgzOAoAA75kCDVYCgADsqgIE4AUAACy0H/mA0g3ojB0AsaossFkqtBv5Y8YdqPodAPtiEBWoiB0A -KLQd/2NGHeiIHQD5Y4YdqP8dAC+0GfliMBWo/x0A77QYJmAFAAAstFkssBTvsBUtVgKAAAiqAuiw -Fi5mAoAAD8wC77ASLmYCgAAIzALosBMtVgKAAA+qAu+wFy1WAoAACKoC6toIDmYCgAAPzAKs7H7L -AbGqLiE3LSE2KrQT/WLmHaiaHQD5YkYd6MwdAP1ixh2omR0A+WImHejMHQD9YqYdqJkdAPliBh3o -zB0A/WKGHaAKJQD9bo4FoDslAFiPcY03/mEoFaAKJQD9boYFoDslAFiPbC0gBcTl/7/rXSIAnQDF -9f5Aph3gAgUA0Q8AAGwQBiogBxi3Of1ucgXhqgEACqQJ6bYcGicCgACtRiNif6lEqETygR4N4AsF -AMAg0Q+OMZoRhzCX4I8wjDgn0qie8Zsw6zYBJgNJgACKN2SgXy2iARi3Ixy3J/kP6BWonR0ADJkB -6jwYLM5CgAD5AABEd90BAOgWAivgBIAAW293Grce+mEkFeAMBQD7SGgVoA0VAFtvHCo8+FtrzNxw -6hICKvAEgAD6IGgd4A0FAFtdZStif/V/+6wiAJ0AjCJlz2uLEdog67wYKWAEgABbdQvAINEPbBAG -E7buAiQJDEQRBDMIKzIgJDB/JjB+5TB8JYh5gAAetRctMIQatTYu4i0qooMO3QgJ3RH9QABFcAwV -AFiEti+gByakFvQCAARw+bUA6f8BDEeCgAD55gAPsP7FAP/gBAexlQEACf8CL6QH6jIoLRAEgAAr -oAcctsotIAUOuwH7JgAM9/YBAOmkBypwBIAA+G+wFaA7JQD4IAYVoApFAFiPByMyI2QwgRW2vviY -ABIwACoAAIM5ZDBwjTAqMRkuIAcpIBbpNBYq4ASAAP5g5h2rqgEA+oYADTA7JQD6YyQdoApFAFiO -9oo6zKdj/8UAiqlkr78sMActMBYrMRmJqiulJy2kFuykByT/MYAACwtPbQgTK5UiLqAHL6AWL5QW -LpQHiZhkn8dj/+XRDwAAAGwQBCkKgAk6AfJgCZ4Sg0EAqYn1IAmPUgCdANWQ8VPwDeKTQQAvIAwe -trQbtrT54Al1ZqMBACkgDS0gVSwgVBa2sO3MCASBUYAA5JEKZmP9AAAo4H0tYliwlwh3KK/dp90L -2QopkoAJCUZ5oRItIFX9QAdj4gCdAP1AByKiAJ0AKSAN7CAMJIGJgADo4H0kgImAAC9iWLCdCN0o -rPwNzAgLyQopkoAJCUZ5qQjwAFQNoAsFAAApIA0rIFXAwQnJOQurDKubKiIUW3ZP6LSgFQSJgAAo -gjAtYqalhQlVEQXVCBu2iBm1AekABQ3IBIAACQJhCQJhCQJhCQJhHrV7GLV7ErSJ4UoQCkiCgAD7 -JgAMsAwVAAyZAikmnSiCj/5mAA8wDVUA7iacKtAEgAALgAAiIp0CgkfJJtEPAAAAAAAA//tcDaaT -AQD1MAAV7/tGAMKCKFQF0Q8A/eBoHe/8FgD//fQNoAUFAGwQCCYgDBS2ZRi03SUgDZgT6AAFCkgE -gAAJAmEJAmEJAmEJAmEdtWEYtVcctl0etWDuRgErTgKAAOlZAgI6QQAA/ICEHaAKBQDqRBEp3wKA -AOtEEClQBIAA6IKMKlgEgAD9JgAM8AxFAPiABhXgDVUAC4AAKXIdCYlHyJLSkNEPGrZKGbUlK3E8 -Az4JGLYdH7ZF7xYEL3cCgAD5wABEO7sBAJsWmBL7D+YV4Y0FAK2Nqpmp7p4VJtSAJdSBKvABLPAA -LOQAKuQBKPADKfACKeQCKOQDLfAFL/AE7+QEKVAEgAD9wKYd4AwVAFiD5YsVHLYNKSEIKCEJJiEH -5SANLRgEgAAtMCYvIAwqIBQN3QkvNAwoNQkpNQjqNBQu7wKAAK3NJjUH9GGmHeAO9QAuNASFFo4T -FrUULdB/DgCH7hIEKkgEgAAJAmEJAmEJAmEJAmEZthbzajYFoAxFAOx2HS7FAoAACYgCAlICInYc -KHU8KLAAKbABKeQBKOQALbACL7ADL+QDLeQCKbAEKrAFKuQFKeQEKGKNwNXrRAAJ0ASAAAuAAC5y -HQ8CAA8CAA6OR/HbgA3hXwUA9cANhRIAnQD7a/gFr44BAOnkAAx1hgAAHrX3KaECKRUCKqIAKhYA -KDAmKRIDHbXPCIgJ6QAFDEcCgAAI3Qjt0H8qSASAAAkCYQkCYQkCYQkCYSJ2HChijSwRAikRAC8R -Af7nxB3gCkUA6nYdKlgEgADpdT0p0ASAAOx1Py7NAoAA/yYADLAMRQD454Qd4A1VAAuAAC5yHQ8C -AA6OR2Th1PXADo0SAJ0A+cBoHe/+AQDoEgMv8IYAAOgABQpIBIAACQJhCQJhCQJhCQJhKGKOGbTR -+2uUBeACFQDidh0p0ASAAPrjxhXgDVUA6VkCClgEgADpdhwpYASAAAuAAClyHQmMR/GWnA3omR0A -jBP6AIIdoAsFAOwABQpIBIAACQJhCQJhCQJhCQJhInU8KGKYGbS7K3U9HLS6+uOmFaANVQDsdiAp -0ASAAOlZAgpYBIAA+OOGFeAMRQALgAApch0JjUfxsLwN6JkdAIoT6gAFCkgEgAAJAmEJAmEJAmEJ -AmEoYpsZtKj7aVAF4AwlACx2Het2HynQBIAA+KYADPANVQDpdhwqWASAAAuAACJyHQKCR9EPAChx -PAgISfn/8lKiAJ0AihP8IEgV4YwFAOoABQpIBIAACQJhCQJhCQJhCQJhrN0s0IQv0IUo0IYp0IMu -0ILoiBEP/AKAAOj/AgzOAoAA7dCHL3QCgAAJ7gIOzAIP3QINzAPy44YVrNwdAP2XAA5wCxUA/2rs -BabcHQD9lwAOcAoFAP7jphWlzAEAWJID/ACCHaANVQDoYo0tSASAAOt2HynQBIAA6XYeKlgEgAAL -gAAuch3/9ngNp+5BAAAACQJH0Q8ocTwPAgD5IAAEMV8FAPn/8QqiAJ0AKhID6gAFCkgEgAAJAmEJ -AmEJAmEJAmEsEAIuEAAoEAQpEAEvEAPtEAUsRgKAAOiZEQ90AoAA6e4CD/wCgAAI/wIP3QIOzAIN -zAPy44YVrNwdAP2XAA5wCxUA/2qMBabcHQD9lwAOcAoFAP7jphWlzAEAWJHT/ACCHaANVQDoYo0t -SASAAOt2HynQBIAA6XYeKlgEgAALgAAuch3/9fgNp+5BAAAAbBAGiTArIAwesz0atAiNMibiLSih -fyqiafrAAEN33cEA/MgAEzMpAQDqZggEBJmAAHqWROy1KBkhUAAA8ADsDaAUZQAAKhYB6RYAI4t5 -gAAGagL64Ggd4AwVAFiCzyugBSwKIf1gDzQiAJ0A2mDrJAAL4ASAAFgAjsBA2lDrNAAKYASAAFiP -dMAg0Q8v4jEZtOICKwni/wgN3wKAAKm555H/L/5CgADvqggG/NGAAP2i4ADQFGUAY//AAAAAAAAA -9WY6Ba/+3gAAAJsSmhHpFgAjjTGAABm0+hiz1YQSqYjoRAgB0IEAAPqAaB3gDGUAWIlMjzmNOABE -BP+rAA707R0A/mEGFaBXBQDnNCAh0KEAAPxhJhXgDgUA/mTmHafdQQDi3QIKWASAAPxkxh3gDGUA -WIk8ijuIOgBEBPsLAAw0mB0AmTrnNCgqWASAAPhhZhWviQUA+GXmHeeIQQDzBgAMMAxlAOg0LiHQ -aQAAWIktixDaYPt/5BXgDBUAW/4MCgRPZU702iBb/b2OES7gIh200Q7uCexgDC93AoAArt0t0ID9 -n/alYgCdANpg+iAoFeAMZQBb+RJj/r+IESiAIgiICe9gDCxHAoAAqMgogID54AXEIgCdAIxi+MDo -FeANFQANzAKcYouaErS75LCwZNCBAACLmWSwpi6wAC8KKn/pBSiyAnKBQfoAAh3gDCUAW2+SG7Sy -HbPDnaCMYJKik6UkpBz1QMYV7/n1APtAhhXgDSUA6aQdLmYCgAANzALspgEq0ASAAFiPKsAg0Q+K -ECqigsmhK6AF/Wk+BaAtVQD9f/q8YgCdANpg6yQAC+AEgABYAA9j/gDqZAAJWASAAFv+JQoET2VN -8WP+SYsR+sBoHaAMVQBb+CVj/zsAAAAA+gACHeAMJQBbcH5j/2QAAGwQBhW0fvdo/AXgjwUAD0YB -8oAQXhIAnQAEiUKvmfUgEDdSAJ0AmRLstHQTBlGAAC0gDP5BsBWitEEA+6AFvWY0AQArIFUpIFTr -mQgHD1mAAOTiC2T7/QAAKcB9K3JYsOgJiCitu6i7Bb0KLdKADQ1GfTEIKyBVezN7fzt4KSANypzr -IAwkgJmAAC/AfS5yWLCdD90oq+utuwW4CiiCgAgIRng5B/AAUA2gCwUAKSANKyBVwNEJ2TkLOwyr -myoiFFt0Eey0TRUNSYAAGrJgiBIvojAucqao/wn/Ea/u7hYBIwD5gAAEA0ZuPiEpPID4IAYV4AB2 -AMCw6xYBK39OAAD0SAABsIgFAKgzbz7dkxDw1VAN4rRBACogDC0gDftACj1mNAEAKyBVKSBU65kI -BoiJgADk0BNk8/0AACjAfS9yWLDbCLsoqvqrqgWpCimSgAkJRnkxEisgVfpgCFviAJ0A/mAIGqIA -nQApIA3KneogDCSAmYAALsB9LXJYsJsOuyiq2quqBa8KL/KADw9GfzkI8ABUDaALBQAAKSANKyBV -wMEJyTkLOwyrmyoiFFtz1uiyJxUFoYAAiRAogjAicqapiAmIEagiG7QPGbKH6QAFDcgEgAAJAmEJ -AmEJAmEJAmETshEYswL5ZgAF4AwVACw2nSiCj+lJAglQBIAA+HOGFeANVQALgAApMp36ICgV55lB -APEjEA3gKjUAKrQF0Q//+AgNppQBACycgPwgRhWv9+YAAAAAAAD/IGgd7/juAP8gaB2v/FYAjhHC -8v5Aph3gLTUALeQF0Q8AAAAAAAAA+6BoHe/4EgD//WwNoAIFAMCA+CAmFa/5ygAAAGwQCIowF7L8 -iCL5Z3AF46oBAAqqCeuz5R1XAoAA+yAARLAspQDmkf8kAzmAAIknLZIK5NNOZNCBAAAtkglk00Mu -0AAo0gJ86QJ7gT/6AAId4AwlAFtuth2z1Ruz1ZegjCCTpSSkHJWm+0CGFe/59QAppB0tpgL9gAAW -MA0lAA3MAuymASrQBIAAWI5OwCDRD5kQ/Wd2BaCKBQAKbQHywBZeEgCdAAaJQqqZ9SAWN1IAnQCZ -Fe6ztBaH0YAAKCAMKyAN+CBGFaKWQQD5AAclZnYBACogVSkgVOqZCAWWgYAAsJrqFgEllzGAABmz -pCmQferiWCXD/QAACYgoiRIJqggIqggMqworsoALC0Z7cRUqIFX64ATjogCdACgSAfjgBIqiAJ0A -KSANy5PqIAwkgLGAABizkiiAfbCbCLsoKOJYqoqrqgypCimSgAkJRnl5C8Cw/CDGFeAAcgAAACkg -DSsgVfwgxhXgCBUACYk5C3sMq5sqIhRbc0Ucs4KNFu6zgRUUWYAAGrGSixUqojAp4qarqgmqEaqZ -6RYEJoEJgAAGB0ZufiMrfID6IGYV4AB+AAAAwPDvFgQu/z4AAPZIAAOwiAUAqHdvftuXE/OjUA3i -pkEALSAMKyAN+6ARPSZ2AQAqIFUpIFTqmQgFjkmAAOSx4WT7/QAAGbNhKZB9KuJYsLgJiCitqqiq -DKsKK7KACwtGe3ESKiBV+uAPQ6IAnQD+4A8C4gCdACkgDcuS6iAMJICxgAAfs1Ev8H0t4liwmw+7 -KKraq6oMqAoogoAICEZ4eQrwAFwNoAsFAAAAACkgDSsgVcDBCck5C3sMq5sqIhRbcwZkoYwYsVaJ -ExezQiiCMCdypqmICYgRqHcbsz8ZsbfpAAUNyASAAAkCYQkCYQkCYQkCYR6xQRiyMflkYAXgDBUA -LOadKIKP6WkCC9AEgAD504YV4A1VAAuAABmxNymSnRazOI0U+iAIFeeZQQDxLYAN4Cw1AIknLNQF -ipr8QEgVoAcFACe2guSglmTYgQAA6pIJJgcJgABkoIkuoADC+n/pFBizJYyi+YAF9CIAnQD3n+s0 -IgCdANqw/ABCHaALBQBbbf4ZsyAcsi+coIsglqKTpSSkHJWm90OmHeAMJQDppgQt3gKAAAy7Auum -ASrQBIAAWI2XwCDRD//1CA2mlgEALpyA/iCmFa/05gAAAAAAAPoAAh3gDCUAW276Y/zEAABkwE/a -sPwAQh2gCwUAW271Y/+PAAAAAAD4ICYV7/WKAP8gaB3v+YIAwpL44KYd7/yaAAAAAAAAAPogSBWv -9M4A+6BoHa/4xgD3n/q9IgCdAGP8pNpQ+mBoHeAMBQBYjU7aIFiF0sAg0Q8AAAAAAAAA//oQDaAH -BQDAoPoghhWv9kIAAABsEAYmMAgnMAn2IAAEsmYhAOgyACMGeYAA9MAGO9A6hQDxAAaKUHuFAPSA -BbrSAJ0A8OAJ/hIAnQAasUYYss2YEOoABQxQBIAACgJhCgJhCgJhCgJhCZoJGbLODKoRqpkikh9k -IH0esNQtkIAasPQu4i0qooOu3endEQlYBIAA/UAARXAMFQBYgHOLEB+yxhixsv9ligWllwEA6Zz/ -K2UCgAAMmQIk5j8p5YAogpL+RgAP8A1VAO/mPipgBIAAC4AAHLK5LMI/+GIAFefMQQDosrgWA5GA -AAwMBvAAJA2vzAEAAAAcsrLqVAAJ2ASAAFiNCcAg0Q97huqNMXHW5emybRIri4AAKCAEaIFE9QAF -ohIAnQBphcwHCEWobw3/Ef//ABXgTgUAf+O5A4gL6QAVAwBRgABtaQIIAIr//qANoAwFAAAAbWkF -CACICQCKY/+VBwhFqGsNuxErvPh7o4QDiAvpABUDfqmAAG1pAggAimP/xwAoIARogXP1AAUaEgCd -APkf+vLSAJ0ABwhFqG0N3RH9vwAV4EwFAP2f+jPiAJ0AiieKruqICwHIQQAA5G+JZEPhAABtaQUI -AIgJAIpj/3gAAAcIRahsDcwRLMz4/X/4i6IAnQADiAvpABUDeumAAG1pAggAimP/TwAAAAcIRaht -Dd0RLdz4/V/3O+IAnQCKJ4qu6ogLAchBAADkbypkQ+EAAG1pBQgAiAkAimP/GQcIRahsDcwRLMz4 -/X/1o6IAnQCKJyqiDuqICwHIQQAA5G72ZEPhAABtaQUIAIgJAIpj/uUAAAAAAAAAbBAKG7C98kRQ -FaAGBQAmNB8mNB4mNB0mNBwmNBsmNBomNBkmNBgmNBcmNBYmNBUmNBQmNBMmNBImNBEmNBDrBAUI -0ASAAAoCY+sABQDIUQAACQJhiDDqFgQh0EEAAOkWCSQkXoAA2lD6YGgd4AwFAFiMkcAg0Q8AABiy -KRSxBQIpCQyZEfiAAEJwDGUA+IAAQjAr5QDrNA8qWASAAFiGeY81jTQARAT/qwAO9O0dAP5ghhWg -VwUAJzQQ7TYFKlgEgAD2YuYdp91BAOLdAgHQYQAA/GLGHeAMZQBYhmofsh+INhuwI4o3/WQ4BaSY -HQD4YMYV4gA9AAqIGJg39mMGHeeIQQDzBgAMP4kFACk0H+g0HiDIUQAAlpCWkZaSlpOWEJYR9iBG -FafYBQCYE/wgZB2gGvUAKhUF+iBEHeANpQAtFQH+IUQd4A4VAP4kJh2g/fUALRUELRUO7BUNKNgE -gADrDx4B0IEAAAoCZ+kLHgHAwQAA+AioHa/7ugBsEASIMPEABULSAJ0AiTFnkJ4UsNQqQosroQJk -sWVbcXUdr+aM3rHMnN71QAqwEgCdABiv6yiCIB2wUSRCiKqICYgRCEQI7QAFAkiBAAAJAmEJAmEJ -AmEJAmEJAmEJAmEvIAwuIA0tIQcsIAcrIBYpIHr6QUgVoAhFAChEBC9EDC5EDS1FByxEBylEU/qC -xh3gO/UA60QFJQehgAApogjJn20ICemSCCzQBIAAyZJj/+/BxupUAAnYBIAAWIwgwCDRD5So+oYG -HeAGBQAmRgnmRggh2EEAAOtGAAJQ0QAA6oseAchhAADpJgACQPEAAOiHHgH4gQAA7wYAAnFhAAAO -AIotMgvtRhgh4MEAAOwDHgJZkQAA6wwAAlExAAD4QAgV4Aw1AOlGFSHYNQAAWIX2KkxG+k3AFeAM -ZQBYhfMqTE/6SQAV4Aw1AFiF7xixjo1Hj0D6ROQVr8kFAOpFIibwgQAACe4BCP8B7zYKJ3EBAACe -2f+hBhWgDAUA96FGFa/80gAA//ysDaAMxQD0QUYVr/zSAGwQDBaviRqvookw57FFGqAEgAD1Yu4F -4Cu1AOqaAQSsJIAAjDFmwXN6lkSLMipyhgW7Ae0iAC3eQoAAq6ouoh3pPCAh+KEAAOusOCVBAQAA -/6AIpCIAnQDBxupEAAnYBIAAWIvRwCDRDwAAAAAAAADscnIkpdiAAIoyK3IjBaoBfKsErLt6s88l -coYJqBH4oABCsAxlAOo8EiLZoQAAWIW1+KcAFeAMBQDpRgABwGEAAOiLHgL5AQAA7yYAAfCBAADu -hx4C6UEAAO0DHgHYoQAA6wwAAtGBAADqBgAByOEAAPiCaB3v/dYAAGSvaoox7HJyKAQKgADxX/ro -UgCdAIoyLXIjBaoB7KsOfUZCgACs3fu/+huiAJ0AJXKGjiqoVfXf+aRiAJ0AKVAF+yASzGIAnQDa -UFhNoPqgaB2gCwUAWEha2lBYR93qVAAJWASAAFhHvSpiEPtf4BWgDAUA+sIGFa/74gAAAC08GA2g -iAsUigmAiPiiaB2gDAUA7wceBXFBAADuLAAB6OEAAO1mAAVZgQAA+ppoHe/7CgAqcoouoQJk4dpb -cK4vYhCx/y9mEPVADmASAJ0AG68lKbIhGK+KJnKGqpkJmRGpZugABQNIgQAACQJhCQJhCQJhCQJh -CQJhCQJhLyAWKCAHKSEHKiANLSAM/MGGHeAMVQD8wIYdoC61AC5kBSpkDS4hCSwhCCllByhkBy9k -Fi2yLSsgDCpyhi5lCa277GUILd5CgACrqvpCqBXgDBUAWH6riyrnpAAFlnGAAIm56rQABIB5gADp -kgks0ASAAGWf9JapkmiKICggNi8gUykhGSllJ/7PRh3gCwUAm2mbavrDphWgDGUA62YLI1G5AADo -ZHghWQEAAFiFOBqwox+w7Ruw6/wiABXgDAUAnNCc0ZzSnNOcEJwR/CBGFafeBQCeE/ogZB3g+fUA -KRUE/iEEHeAIFQAoFB0pFQz6IWQd4AmlACkVARuu4PogRB3gHPUA7BUFKPAEgADuCx4DQUEAAAgC -Ze3GAAN5gQAADxiKjCqeGJ0ZdsEPL6JyjmAP7gz+IaYVoAAiAMCAmB0tobnrr5YW9byAAGhFZ44y -KjwY6hYMIZCBAADzwAjqUgCdAOoGAANA4QAA+IJoHaBbFQDi5gADeQEAAO+fHgtQBIAAWEDxiWD1 -IAQE8AwFAPhgRhXv84YAAAAA//NYDaAMxQDqVAAJWASAAFhHLf/zDA2gDAUAInAmG694Ai0JDN0R -rbsdsJkqPBiaHP1gAEXwDGUAWITujzeONgBEBP/LAA90jh0A+GDGFaBfBQAvNBieN/4hqBXn7kEA -Au4CLjQeLzQfInAmG69lAi0JDN0RrbsdsIYqPCCaG/1gAEXwDGUAWITbiRuNHYw4+iGIFeCOBQAO -3QL+YSgVpIwdAPhhBhWgXwUA/mQGHeIAPQAOzBicOfxk5h3nzEEAAswCLDQm60YAA1DhAAAKCIrp -JgADQQEAAPiKaB2v/DoALHAmHbBrnBoMzAnqEgwuZwKAAKy7/WAARfAMZQBYhL2ON402AEQE/6sA -DrT9HQD+YMYV4F4FAC40GI8djhqdN/5j5h3n3UEADt0CLTQeJ3AmG68zHbBWB3wJDMwR7LsICVAE -gAD9YABF8AxlAFiEqYgdjzj6IYgVoIkFAAmIAvhhKBXkzx0A/GEGFaBbBQD6ZAYd4gA9AAn/GJ85 -+GTmHaf/QQAH/wL+ZMYd7/jyAPZBRhWv9SYAbBAEiDDUUA8CAP8BQAJQHGUAKSAEaJEQ6kQACdgE -gABYipvAINEPAAAoIRYoNREvIRgvNRAuIRnuNCQh0CkAAO0gNiFZAQAA/GFGFeAMZQBYhIIpPBjq -LEghYOEAAOwmAAHYQQAA+opoHeAMNQDqBgABWUEAAOmDHgHQlQAAWIR3KSBTKTQxKiEX/0FABBBN -BQANmQIpNDH/QUAEUC4FAA6ZAik0Mf9BgAdQDAUAwfAPnwIvNDEoIDT4YIQdr/1uAAAAAGwQBBmu -EogwHrAb6lQACdgEgADjr2wUJQiAABiv142fLJIQjyeJniiCf4/+I7UFI7UGI7UHj/SftCPifpO1 -mLaZty/igJ+4LuJ/nrmduv1hZhWn2QUAKbUEwMBYilzAINEPAABsEASOMm7iD2jiPGjjUWjkHsAg -0Q8AAADqJAAJ2ASAAOxEAAroBIAAWD8p0qDRDwDqJAAJ2ASAAOxEAAroBIAAWD2f0qDRDwDqJAAJ -2ASAAOxEAAroBIAAWAR50qDRDwDqJAAJ2ASAAOxEAAroBIAAWAII0qDRDwAAAAAAbBAGiicWrq4P -AgCFqSiiCilhf2SA5e6XB3qgBIAAZFDTKSAFxab7IAg0IgCdACsKT+skBSlQBIAAWweB8KtQDeP7 -9QCHUSohCCNVCCxhf4hQ/4eAB1d3AQD7QAV8YgCdAAiIV/UABosSAJ0AykQESwLsdAAJUASAAPKB -BB3gCRUA+EKmHeANBQBYXYFgAAQAAHuhd/pBqBXgXAUALCQFKmJpCbsRC6oIKqIKZKAVK6xc+iBo -HaAMRQBYg//6IAgVoAAmABqvCJoQHq8aLTroDa0sDt0o7RYAKVAEgABbB1iLEByuSu2vrBlQBIAA -Wwd02iBbB1fRDwAAAAAA/ybgD5AFBQD//GQNoAQFAI8n/+QAFa/JBQD5wAQHcAgFAOj2CidxAQAA -nvn/4QYVr/2iANogW2Q+0Q/RD4on+uBoHeAMBQDqrCAr6ASAAFtn1PVAaB2v/GoAAABsECwVra6D -LShSgwkzEaODizeLvokuKrAwLLAxCKoR7KoCDM5CgADpgggFUAUAAPtmJh2oqh0A6rQwKVAEgABb -ByqKKcmghKsrCopb/5fqRAAKf6YAAIopwEDrIgslALGAAGWzgvpBZhWgACYAAJq7m6yUKRevMCsg -DBytb/hDJBWgHaUALSRSLMItKBZOKlKD/WAARbAZBQDnABUN3kKAAOuqCAjABIAAbZoCCACKHq1w -KqEuJSxM/0ARHCAGFQAerVkfrVn8QAgV4OgVACgUGP4gRhXgDIUA7hYALu4CgAAM3QKdES4gB/9b -rAXh7gEAAO4RDq4CD+4CnhQL6jCbFZ0Z+16gBaBJBQApFQ+aGCggUigUMS8gBS8UMi4gMCYUMC4U -My0iFe0WDSDogQAAi9WK1InTiNLv0gEg8QEAAJ/hmOKZ45rkm+WN0J3giyArFhYqIFIqFF0pIAUp -FGAoIDAmFFzkFF4hWNEAAOgUYSDRoQAAWIN6Khxw+keAFeAMhQBYg3cqHHr6SMAV4AxlAFiDcyoc -ffqgaB3gDDUAWINw6yxYINH9AAD7QKAVoAyFAFiDaywSTi8RQigRQ/gmJB2gnCEA/g0ABvDvcQD8 -LgANsKwpAOvLAg1XwoAA6e4RDu6CgAD+BQAH8IxZAO7dAg/+woAA/kGIFaC7AQD7JgAMsKxBAOyq -EQ3eQoAA/2YADfTumQD/ZgANsPxRAPoshh3g7DkA/AYABbDMSQDt7hEOZsKAAOyqAg3fgoAADrsC -7iBkLEZCgADsIGUv/oKAAAj/Av9GAA1w7hkA/8gAFzD8OQD/pgAOsOwxAO7/EQ93woAAD+4C/6YA -DrDMKQD9hgAOcD0FAA3MAiwUZYgsC6oCCpkC+CzmHeD4gQD4EQAHMIiRAOruEQxGQoAA6O4CD/7C -gAD/xgAPcA+FAA/uAi4UZownjcrk0TlmUIEAAInJZJEv+iBoHeAMhQBbasDBleQlGSDB/QAA5wAV -BEBFAABtmgIIAIocrtTsFiQhWT0AAPhACBXgDbUA9DRmHaP69QD2NQYdoAw1AOoVUCzOAoAA7ZkC -ANH9AADpFiUlUKkAAFiDC+ocfyrYBIAA+0XAFaAMNQBYgwYkFMEkFMIkFMP8AgIdoAs1AOsUwCDR -/QAA6qxFIdlBAABYgv3rPEAg0f0AAPtKoBWgDIUAWIL46zw4INH9AAD7S6AVoAyFAFiC9Os8YCDQ -BwAA+0CAFaAMhQBYgu8mFYgkFOQkFPT6QGgdoC4FAP44hh2g/PUA7hTFIOgHAADk1BQg2f0AAOwV -hiXYRQAA/AFiHaANJQBYQivD+S8kBdEPibvTD9MPZJx8bQgK6ZILLNgEgABknG5j/+4AAOokAAjY -BIAA/AECHaANJQBbTAtj/sQAAGwQNhOuahyuiostLTJ/Hq6J6iAFLd5CgACr24u3564+FVLtAAD/ -QAEHMAUVAPthyBXgGCUA+UFSDaAEBQCO4ArgAADaIFtjHMAg0Q8crnuNIP5GxBWgClUA/kbkFeA7 -JQBYhn+GLiMyfwlmEaYz5jxMINAVAAD6wGgd4Aw1AFiCsecAFQDAYQAA+1zYBeAZVQBtmgIIAIqb -FvhACBXgDDUALBQr9CYGHeP69QAqFRT9IAAUsAq1AAqZApkXKDAEKhwx9QAN0pIAnQArPE9Ygp3b -YPomoBWgDDUAWIKaJRRIJBRJJBRKJBRLJBRO6xwYKVAEgAD8AEId4AyVAPwpph2gDLUAWEHa2iBb -YuvAINEP2iBbYunAINEP2iBbBeyILiMyf9MP5wAVDEZCgADoMwgAwf0AAPkIIBWgGVUAbZoCCACK -HK4/LBYw6SIOIbE9AADlFNgg0f0AAPQ6Zh2j+/UA+i0EHeAMNQD9IAAUsAu1AOuZAgVRaQAA6RYx -K1gEgABYgnDrPEwg0f0AAPtLwBWgDDUAWIJrJBTxJBTyJBTz+sBoHeAcJQDsFPAg0f0AAPtOwBWg -DDUAWIJi2jD+QAgVoAy1AP4vhB2gDSUA7iE3INn9AADuFX0l2QUAAFhBpMAg0Q8AiS4JmRGp2YmX -iZ4okDuxiCiUOy+wX7H/77RfKVAEgABb/nfAINEPiSeKmsighJmJQSjCQPpAaB2gDQUA+oBoHefJ -AQALgADAINEPLx0B6K4EF9mhAACUsJSxlLKUs5S0lLWUtpS3KBZaiSDowkApUASAAPXvhh3gDiUA -5PR7LM4CgADumQIKaASAAOkWWy9gBIAAC4AAwCDRDwArPEhYgjC1GSuQAeyQACDQ1QAALKQAK6QB -KZAC+UBGHe/49gBsEAgtIScrIBYcraKIJ4coKiB65SAHKvAEgACGdwqvCYiO6BYFL/8CgACvzIZu -LMJ//CDmFaD49QD5ZIYNoVUBAPwgxhXnzgEA/Z/AFaANFQAM3DlbRp6MF+0SBiUWuYAAFKxPDFkR -9KARKhIAnQCkmS6SntMPDwIA98AVe1IAnQAjkp1kMjcarCPqAAUJyASAAAkCYQkCYQkCYQkCYQkC -YQkCYSohB/tYmgXinEEA/SAAFLaMAQD5BgAMeqoBAP9AABUwnDkA66oCDM1CgAD6YAYVra0dAOus -Qh1VAoAACpkCCYgCiiD6YEYV4EyFAJwz/UAAFTAMZQAMqgKaMf5PUBXgDgUA6q2nHs0CgAD+YUQd -oD1FAO01Cy/8AoAACP8CGKydCpkCmTbo/wIBWbkAAO82BCHQgQAAWIHZ6jwmIVmhAAD6IIYV4Axl -AFiB1B6rjxmtlfhlph3gHwUA/mXGHeALdQD+ZuYdoIiVAPhlhh2gCiUA+mcGHaANFQD8ZmYd4Aw1 -APxmJh2gjQUA+mamHeAMBQD6ZyYdoAsFAOs0NCPZYQAA7DQwIdDpAAD8ZsYd4AxlAFiBuisSBPpo -QBWgD7UA/mgGHeAOVQD+aCYdoAxlAFiBsyo8SfpJABXgDDUAWIGv+mmAFaAHZQD6SAAV4AyFAFiB -qo8VLvAgKPAh6fAiL3YCgAAI7gLo8CMvdgKAAAnuAgjuEQjuArHu/+RmHajuHQD/5EYdqO4dAP/k -Jh2o7h0ALvQgjWCMYS3cOO1mACZgBQAAnGGKJwxbEfVgAEW/yQUA57adJVCBAAD5QAQE8AsFAOum -AiTJAQAAmaAppgErIBYoCv/5YASkIgCdAPpPUBWgPEUAW0X8wCDRDxurMdMPirj3QAWIkgCdAAxZ -EaSZL5Ke9+AGO1IAnQAjkp3kML5lc/0AAJ64ZT3HjyJk8FEfrTqJJ/5ACBWgCDUAmBL+IAYV780F -APskABWgDxUA7a0BD3YCgAAP7gLuFgEm6QEAAO2WCSjYBIAA/SEGFeAIBQD5IUYVoAwVAFtpBMAg -0Q8AK1wY6iQACWAEgABbawBj/5wAAAAAAP/1UA2gAwUAiSJln4orIFPaIOu8EilgBIAAW2r3Y/93 -nRb8IOYVoAoFAFiFeBuq/oq4jBeNFvlf+ciSAJ0A//04DaADBQDAMMDqDq40/2EGFa/8/gAAAABs -EDgoIAX7WXQFoCnlAPkAJv1sCwUAKhZl6xYAIMAhAAD6AAoVoBlVAG2aAggAiuus9RDghQAALBZc -+iBGFeAItQD+QAgV4AQFAPQjZh2j+fUA+CGEHeAKFQDqFCAhUSEAAOoWZiDQ8QAA6hZdL/4CgAAI -/wIvFgMtIEkuIEguxAAtxAErIEorxAIkFDkkFDr0J2YdoAk1AOkUOCFZQQAAKxZeKBAALRAC7xAB -IPCVAAAv5AEt5AL5wAYdoBwFAFiBFxOqwxarvhes2RirsiUgQSogQBustusWZyDJMQAAKRZfKpQA -JZQBLyBCLiBDLpQD75QCIPFRAAAuFmEsIEUtIEQtlAQslAUlIEcqIEYqlAYllActIDkvIDgv5AAt -5AEsIDoqIDsq5APs5AIg0fEAACoWYyUgPSkgPCnkBCXkBS0gPy8gPi/kBi3kBykgYSwgYCykACmk -ASUgYi8gYy+kA+WkAiF44QAA7xZiISkBAAAlFmAuIGQtIGUtpAXupAQhaYEAAC0WZCkgZywgZiyk -BvlA5h3kHgUALhVBKIKsJBRcJBRs9DGGHaApBQApFD0pFDyJIIwn/iQkHaAKFQAqFUQHmQL9gcgV -oPX1ACUVQvZzphWgDVUA7BZaKVAEgAD4c4YV4AxFAAuAACsynRysZfgrSBWoux0A+qAYfmIAnQAv -gDopgDsI/xEJ/wKx//8HZh3o/x0AL4Q6KdoAKRYsKRJlKBx/KIw5+AAKFeAZVQBtmgIIAIorEmYY -rHYoFi6NIPQ5Zh2gDxUA/joGHeP+9QD+LIQdoAw1AP2gABawDrUA7t0CANH9AADtFi8lUUkAAFiA -qiQU6SQU6iQU6xirRfov4BWgDDUA/D3mHaBrJQDrFOglYMUAACnAAivAAeiCrCVRWQAAK6QBKaQC -LMAALKQAiSCMJysSZweZAozO9nOmFaANVQDsFlspUASAAPhzhhXgDEUAC4AALTKdHqwpLxJb+Vha -BajdHQD8oBQmYgCdAC7wOijwOwjuEQjuArHu/+dmHajuHQAu9DooEmUvqgD+IAYV4BlVAOgAFQDA -IQAAbZoCCACKKhJcKRJmGKw1mBKNIPQjZh2gDxUA/iQGHeP+9QAuFQz9oAAWsA61AA7dAp0TLJAA -K5ABK6QBLKQAKxJeKZACKaQCJBQ5JBQ6JBQ7+iuoFaAINQAoFDgpEAIuEAHvEAAg6JUAAC/UAC7U -AfmgRh3gHAUAWIBgLhJgLRJfK+ABLOAALNQAK9QBKeADKuACKtQCKdQDL+AFKOAEKNQEL9QFLOAH -LuAGLtQGLNQHLRJiLBJhKtABK9AAK8QAKsQBKNADKdACKcQCKMQDLtAFL9AEL8QELsQFK9AHLdAG -LcQGK8QHLBJkKxJjKcABKsAAKrQAKbQBL8ADKMACKLQCL7QDGKrbLcAFLsAELrQELbQFKsAHLMAG -LLQGKrQH+RWIFaQZBQApFUEpFSEkFFz0LYYdoCsFACsUPCsUPSQUjCsSZ4Qn+EAIFeAKFQAqFUSE -TiY2nfQoRB3gDVUA9yYADPAMRQDpNpwpUASAAAuAAC0ynRmrwP9XygXo3R0A/KAJeOIAnQAoMqYT -q7UjMn8JiAEJiBGoMxir3o48CO4BD+4C7jYMKYlOAADCjOgkBSlQBIAAWwNyG6vXHKnK7avWGVAE -gABbA47aIFsDcfpAaB2gCwUA/AACHaANBQBb/d7AINEPAAAAABuroyoypinCfwuqAeyrxx1WQoAA -qpmKnBurxykWWAyqAQuqAuqWDCTnMYAAKhJY2xD7SYAVoAw1AFh/9eoSWCDYIQAA/AFiHaANJQBY -PzssElgtwAX9hgYd4DsVAPuAph3v8rYAAAAvMqYu4n8I/wHpq64f/kKAAK/uj+wYq68uFlkJ/wEI -/wLv5gwna6GAACoSWfov4BXgDDUA67wxJVExAABYf9sqEln6L+AV4Ay1APtnIBXgDSUAWD8gLRJZ -w8j9oKYdr/TuAC5AOi9AOwjuEQ/uArHu/odmHajuHQD+h0Ydr/t+ACo8TPogaB3gDDUAWH/H6xwI -KdAEgAD8AWIdoA0lAFg/DSgwBfhmBh2gTxUA/mCmHe/6rgAAbBAKKyAWJiAHhycqIFMsIRnkqzUa -aASAAJwZnRgKqAnncg4sRwKAAKhE9I/oFaD49QD5Y6YNoWYBAAUMR/2fwBWgDxUADPw5W0Q27BIJ -JRnJgAATqegMaRH0wA+yEgCdAAOZCC2SnvegGKpSAJ0AJZKdZFIKGqm86gAFCsgEgAAJAmEJAmEJ -AmEJAmEtIQceqegNDUrpqece7wKAAP+mAA6y9EEA7VYAL/4CgAD6QAgV5uQBAP/GAA9wOgUA+qBm -FaANRQDpVgIt3gKAAA27AptR/EpwFeAIBQAoVQqYWJhZmFqYW5hcmF34ocYVoPQ5APih5hWtjB0A -5f8RDEUCgAAI/wLv7gIO7AKAAA7dAv9WdAXgKwUA7Ko1HnUCgAArVQsP7gLs3AIC0IEAAOxWBCFZ -AQAA/qDGFaAMZQBYf23qXCYhIWEAAPqAaB3gDGUAWH9oG6sq/1JEBeCJlQApVCz+puYd4BgFAPil -xh2gDCUALFQ17FQ4ItDpAAD8pyYdoA4VAPqlph3gDTUA7VQxKlgEgAD+pmYdoA0FAPymBh3gjgUA -/qbGHaAMBQD8poYdoAxlAFh/T49zjHIu/AH/wPIN4ApFACzMAYtxjXCec+x2AiXYBQAA63YBJuCR -AACccI0Y6CIHK08CgACjmfszphWgDAUA6owgLtgEgABbYzaIJ/8EABXvyQUA+eAEB/AJBQDphgon -+QEAAJ+Jn4grIBYuCv9+sQr6SnAVoCwFAFtDqCogN/tf4BWg++UA+kbmHaeqAQD7QAR8YgCdAMAg -0Q8AAB6o1Yro90AKIJIAnQAMaRGjmSuSnvdgCrJSAJ0AJZKd5FFNZVv9AACb6GVd9IwiZMDkGare -jif4QAgVoAolAJoW+CCGFe/PBQD7xAAVoAkVAO+vAQxGAoAACYgC6BYFJ/kBAADv5gkg2EEAAP/B -BhXgDQUA/cFGFeAMFQBbZqnAINEPAAAcqtIuIAf8QLAV4ApVAPhACBWgOyUA6BYAKXgEgABYgsaK -Jyv6wPNByBXgLGUA7CQFJUiBAAD7IAQE8AsFAOumCiTJAQAAmanppggpUASAAFsCVCwxEYIqsczs -NREheLmAAPAAaA2gI9UAAAAAAAAA+kBoHaALFQBYQbaCKWQu9C0gBXPZ6YIpZS/0Y/7mAAAAACts -GOokAAlgBIAAW2iAY/8JAAAAAAD/87gNoAUFAI4iZe73KyBT2iDrvBIpYASAAFtod2P+5PwhJhWg -CgUAWIL4Hqh/iuiMGflf9VCSAJ0A//r8DaAFBQDAUMDaDa00/cEGFe/6wgAAAABsEAooIAUpCiX5 -ABIlYgCdAC0hGSsgFiUgByogUyYiBxeqPQqoCeZiDixHAoAACHcI9u/oFeD89QD9YuYNoVUBAPwh -BhXgDBUAW0NB7RIIJRnhgAATqPMMWRH0oA/KEgCdAKOZLpKe98AYylIAnQAkkp1kQgsaqMfqAAUK -SASAAAkCYQkCYQkCYQkCYSwhBx6o8wwMSumo8h5nAoAA/4YADjL3QQDsRgAv/gKAAPpACBXm5wEA -/8YAD3A6BQD6gGYVoAxFAOlGAi3eAoAADLsCm0H8SnAVoAgFAChFCphImEmYSphL+IGGFaD3OQDo -Rg0v/UKAAPiBxhWgKwUA+IHmFa2NHQDrRQssRQKAAAj/Ag/uAu+qRB5kAoAADswC7ak+HvUCgAAP -7gLuRgYiUIEAAO3MAgFZAQAA/ICGFaAMZQBYfnfqTCYhOWEAAPrgaB3gDGUAWH5yHqgtGaoz+IWm -HeAfBQAvRC7+huYdoIiVAPiFhh2gCyUAK0Q1K0Q4+ocmHeAMNQD8hiYdoA0VAO1EMyJQ6QAA/AAC -HaCNBQD8hgYdoAxlAPyGxh3gCwUA60Q0K9gEgABYflqOY4tisez/gNINoApFALG7iWCNYZxj62YC -JMiRAADpZgAm2AUAAJth/kDoFeALBQD+oAAUMAwFAPMAAERwDQUA6oadJ9CBAABbYkCIJ/8EABXv -yQUA+eAEB/AJBQDphgon+QEAAJ+Jn4grIBYuCv9+sQr6SnAVoCwFAFtCsiogN/tf4BWg++UA+kbm -HaeqAQD7QAR8YgCdAMAg0Q8AABun34q490AKIJIAnQAMWRGjmSySnveACrJSAJ0AJJKdZEFNsKyc -uGVN840iZNDnGqnp+EAIFe/IBQD+QOgV4AslAPogxhXgCxUA6hYELM4CgADrmQIH0IEAAAioAfgg -phXgDgUA7vYKJEEBAAD54SYVoAwVAOj2CCDYQQAAW2WywCDRDwAcqdwuIAf8QLAV4ApVAPhACBWg -OyUA6BYAKXgEgABYgdCKJyv6wPNByBXgLGUA7CQFJUiBAAD7IAQE8AsFAOumCiTJAQAAmanppggp -UASAAFsBXiwxEYIqsczsNREheLmAAPAAaA2gI9UAAAAAAAAA+kBoHaALFQBYQMCCKWQu9C0gBXPZ -6YIpZS/0Y/7mAAAAACtcGOokAAlgBIAAW2eKY/8GAAAAAAD/86gNoAQFAI4iZe70KyBT2iDrvBIp -YASAAFtngWP+4fwhBhXgCgUAWIICG6eJiriNGPlf9VCSAJ0A//rwDaAEBQDAQMDKDKw0/WEGFa/6 -tgAAAABsEAYoIAUrIAf6YGgdp3UBAPKAaB3gGUUA+QAG/WG7AQAVqAn44AchUgCdAOSiBi1oBIAA -7wIADbAEgAD1YARiEgCdAAy6EaWqLKKe94AHpNIAnQAqop1koLn6QAgV4AwVAFsVxRupLS4hCR2o -BywgBy8hIighJPlTAAXgzBEA7f8CDmKCgAAMiAIJiAKYoIwgn6L/QGYVoA0lAOSmBS5mAoAADcwC -nKHrABUFSGEAAAkAigxuEfXAAEdwDaUA7eadK5WgAADAINEPAAAcp0yJyGqRdwxqEaWqL6Ke9+AE -xNIAnQAqop3koI9k8/0AAP+BBhWv/ZIAAAAAAADqJAAK2ASAAFtodNKg0Q8A9UBoFa/8kgCPIusW -ACeFKYAA7RYBI5WVAADAINEPiif6YGgd4AwFAOqsICnoBIAAW2F70qDRDwD//DwNoAoFAJ0R+iAG -FeAKBQBYgaIcpyiJyIsQ7RIBKAQKgAD5P/tAkgCdAP/7jA2gCgUAwKDA6g6eNP+BBhWv+1IAiifA -sPtEABWgDBUAW2UNHqgsnqCNIBupN4wR/aAAFrAOFQAO3QKdoYzGnKP7QEYV4AIFANEPAACLEO0W -ASlQBIAA67wYKWAEgABbZv78ICgV7/0aAGwQBBSoz/tODgWgCRUA6iYAKcYCgAAJiALoJgEhGCEA -AOQAFQEQQQAAAwCK0Q8AAGwQBP1SOAXgCyUAKzQAKiAVHqkZGKdn6EkRDVECgAD7JgANMAtVAAuq -Apox6AAFAaBBAAAEAmEEAmEEAmEEAmEoIAf/UhwF4YgBAOBVEQxEgoAACFUClTaFIJ4/nz78YgYV -4AQFAPRhBhWgCzUA5DxQKubCgADsNgcjAdmAAPxCsBXgDhUALjRYLjRQ5zRZLukCgAANnQIO3QIt -NhUM6jDsRQUq1gKAAAuqAupGAyGRgQAA0Q/SQNEPAAAAbBAE8kBIFe/0FQAEMwGTItEPAABsEATa -IPxgaB2gCxUAWIJ50qDRD2wQCIdGiEcvQQspQQr0gQgV7IA9APxgaB2k/x0A+AIABvBpcQD4AwAH -cDXxAPQfAAL5uB0A6HgYDdwCgADvVRAJnAKAAOUzAg93woAA7t0CCzRCgAD0gIgV4ekBAOYzAg93 -goAA+iDGFeFpYQD62AATMAsVAPggphWgiXkA6/83DEVCgADoZgIP/wKAAP/GAA9wiVkA5jMCDEaC -gAD4hgADcZkhAO7dAgzOAoAA7RYHKzfCgAD4xgALMIV5AOYzAgxDwoAA+QYADHFlYQD1YAAE8FVx -AOUzAgswgoAA5acVHMuCgAAJZgL4xgALNnfJAAdmAheoqgUzAuMWAylQBIAA9sYAC3AOBQDmFgQo -6ASAAFiBM9Kg0Q9sEATaIPxgaB2gCwUAWIIu0qDRD2wQCItHh0bjQgQp4ASAAOYhBylQBIAA+ICo -FauAPQD3FwAE8VOhAPdAAAMw45EA8cgAFzL4uQDk/xALNEKAAOt3GAqswoAA9qYACrm7HQDpFgUt -24KAAPngAASwaJkA52IRCzZCgADnFgYsz4KAAPRGAAl0eNEA65kCC74CgADyGQAF8lihAPdgABWw -iPkA52YCDETCgADyuAASsXOBAOX/Agu8goAA+OYAC7CDwQD3CAAUMFOxAPsGAAxws7kA71UQDduC -gAD6pgAK8LPRAPimAAqwM5kA6TMCDdiCgAAL7gKTFwdVAhOoYwZVAg/uAvQgRhXgH4UAD+4C7hYD -KOgEgADyRgAJcAsFAPIghhWgDgUAWIDo0qDRDwAAbBAEFKhWDwIADwIAKkKA2yBbZ+TooRxtGASA -AOpCfylYBIAA/AACHaANFQBbYBvSMNEPAOpCfyFYBQAA/AACHaANBQBbYBXqQoApWASAAPwAAh2g -DRUAW2ARY/++AAAAbBAE81B+BeAIBQAeqD4o5sAdqD0o1sAcqD0oxsAbqDwotsAZqDwqCgD5OAYV -oAnFAG2aEYkr46sKARPxAADptsAlUAUAABimISg2vcD1Lza8WHd24qQADQDOAAAoMuXHL/8B4AfT -mEEAaJMHIjLo0Q/RDwDRDwAAbBAEEqggIiJ/IiEC0Q8AAGwQCCQVBPlQRAXgDSUAnRGZECwgDCsg -DQjMEQy7AusVBSlQBIAA6CEJKZRCgAACUgKZEJ0RGaZZJBUEKBYD6QAFAMBBAAAIAmHyIIYVoAwF -AOYWBSjYBIAAWFkO0Q8AAGwQCPtQGAXgDSUAnRGbEI8yDw9fLxUELiAMLCANCO4RDswCLBUFKSEJ -mxDtFgEpUASAAOkWAyDAQQAA8ghoHeAMBQDoDAAI2ASAAFhY+tEPbBAEGKf5JyEOpDumWaMjqbuk -OislA6SSKaUKeHEFIjUJ0Q8ALCzYLDUK0Q9sEATbMOxEAAlQBIAAW2OvL6ARLqEJJaEMKKAVgyP3 -QpAVr80FAO0tAQVYgQAA7T0IDeAEgADoZggG6QEAAP1gBLLiAJ0AIswc7wIACVgEgAD8QARa4gCd -AO/CCA2gBIAA7v8IARBJAADs9wgJWASAAO0rc3O4UQAApvnpWQgNkASAAO17aXvYBIAAKEEAKcUD -pWkptQCumxmnyXmBWSslACugFS+hCe6gESWA6YAAK6AUr+6uuyu8Eqy77btEfRAEgACbo9EPAMAg -4qYDLRAEgADRDwAAAADzbwAOf/2qAPJPAA3//dYA8k8ADf/+NgDy7wAN//5eACi82PhAJB2v/ooA -A7kM6aYDLRAEgADRD2wQBBOlhCMyNgMiDAJiFNEPAAAAbBAGFqdsiCAPAgAqYp+JMCZip+qIDAng -BIAA5RYALEaCgAD4wABDMAoVAOVsICSpdIAALTAJ6TwQKtgEgAAPAgD8BwAHcN0xAAkghgsCYwkA -hgsCYShgASkK4AmIAShkAS8wCPnmAA+wufUA6f8BD0aCgAD55gAPsNn1AOn/AQ7GwoAACP8CL2QB -iTDnpksUpVCAAC7CAShgAQfuAfgHAAe0mAEA+YEGHeDYMQDp3REP+EKAAP/GAA9wiCkA7sYBLEaC -gADo3QIGWEEAAO3ECSrIBIAACWCGCwJnCUCGCwJlKcIAe5ZkLmABiMErCoD+BgAGsJ4pAPMADAgQ -+PkAHqWn7gAFCvAEgAAOAmEOAmHAgChkAS4gVPHDAA3gBAUAlhIep1/sFgMum8KAAO2nXRzEAoAA -CDMCkxHzTrAF4ANSAIwT9iBIFaAKFQApYAD/IYAOEAsVAC1gAXjfAcCwH6UoLvI2Dm4MDmkU+U6e -BaWZHQDv/fYsz4KAAPnvAA///fUA+eAAR7TuMQDu8n8vAQqAAOoSAC1ICoAADZkD6e4BDcAKgADo -7gIOWASAAP/v5hWgDAUAWIFpwCDRDwAAq2bZUAdqAirWsyjStIoRA4gB+UYADTAMBQD7toYVoBgF -AG2KHfHlgA3gCgUAKpEADqoC7cgKBMgJAADqhrUmYAUAACbWsykgVLFE+J/5ouIAnQApIA3KSyog -VcDBCck5qkoJqQwqIAwIqhEKmQILmQL/MWAGEmlBAP/+FA2maQEAY/+uAGSfzywgDMqWGKbYFqbZ -KIB9JmJYsJoIqiisaaqZGqbTCpkKKZKA//7YDaaZAQAAAPmAaB3v/6YADghGC4gC+MAmHa/6PgAA -AGwQBBynB40gLsJ7iTAswoPu3QwK0ASAAOrdEQnYBIAA7cwIBKjYgAAvwADuwAEhyEEAAOkHHg5o -BIAADQJjCQCGDQJhLTAI/4AmHaDoBQAI+AEI3QItxACJMP8ooAJQDxUAIsAAGKWxjrH9YgAV5JIB -APlhBh3gIjkA6O4BCRBCgADi7gIOSASAAP9gJhWgCAUACWCGDQJnCUCGDQJlibAotQh7liaJse6l -GhyEQgAALcAB7gAFDkgEgAAJAmEJAmEpwAD9gCYd4AAiAAApwAD/IYAOEA0VACjAAXiPAcDQHqSl -KeI2CckMCWwU+U2YBaXMHQDu7fYuZ4KAAAzuDPnAAEc0mTEA6eJ/LIEKgAD94AEH3/j1AAj/A++Z -AQ7gCoAADJkC+c/mFeAMBQBYgOjAINEPKcAA+MAABPCNBQANmQL5gAYd7/4qAAAAbBAE6SIAKSAE -gACTkYghk4AEAIgDAIqSIJIh0Q8AAABsEAQpIA0qICL5ScQFoAsVANMP6bk5DVYCgAAKkgICA0cI -MwooMpACihQLgAAKCUFokQJpkx0oMpYCKgILgADboPpAaB2gDAUAWIDG0Q8AAAAAAAD//6QNoAsF -AGwQBMk29GAFSJIAnQDJOvRgBWiSAJ0AwCDRDwAAKCETDwIA5IQICf9GAAATpG5lcKZzYTOML/pA -aB2gCwUA/MAARjANBQBYf39moRccpoQswX/6QGgdoAslAPWAAEYwDQUAWH94ZqDvc1EvjC/6QGgd -oAsFANMP/KAARjANBQBYf3FmoNr6QGgdoAslAPyAaB2gDQUAWH9rZqC86iQACmAEgAD6ACId4A0F -AFh/ZtKg0Q+NLPWgAEI//VYAAAAAAPpAaB2gCxUA7EQAC+gEgABYf1zSoNEPAPpAaB2gCxUA/IBo -HaANFQBYf1ZmoGlzUS76QGgdoAslAPyAaB2gDRUAWH9QZqBQLCIP+kBoHaALBQD8oABGMA0VAFh/ -SmagO3NhNBymTizBf/pAaB2gCyUA9YAARjANFQBYf0JmoBiML/pAaB2gCwUA/MAARjANFQBYfzzS -oNEP0qDRD9Kg0Q/SoNEP0qDRD2wQIogihzTkpB0aMASAAJQUlBX7AGLIknfpANog9iWGFaALdQBY -fpz3QGgdr/hFAPlAZmQiAJ0A7aQUHQT6AACJMCoxBS8xBuYxBySsJIAAizFmsfsuIA3TD2TgrCoW -NnTxAmThR58ULxY1dGECZOFRlhUmFjRkcLD04AqwkgCdAMBgBvxQ+gAiHeAKBQAMujhkoEaKMA8C -AHqmJGRySPTgEqiSAJ0AHKYC8ulwDeALFQD04ExgkgCdAMBgZmAbijANpAF9oAmOMfPACrBSAJ0A -yEaJMQnfUmTxNNog/B+iHaALBQBYf7wo+o14oQIGpjjaIOwSLCnYBIAA7VQAC3AEgABYcizSoNEP -ZHIa9OARKJIAnQAZo9kpFjb1//olIgCdAGP/PwAAAAAmIRIqEjb3QGB6ogCdAIoqKxI2W2VwHaPS -+0Bg6BIAnQArEjV0sRqGLvdgY6qiAJ0AKiIQW2VoHaPJ+0BkQBIAnQAuEjT13/h0IgCdAIYu98Bk -uqIAnQDqIhAvWASAAFtlXR2jv/tAZSgSAJ0AKBI19QBl9CIAnQAZpdUpkH1lntVgDNiKLwr6DCoW -NZoU9N/1lSIAnQBj/q2LLwtrDCsWNPogphXv+p4AhissEjb3gF1KogCdAOoiDS5YBIAAW2VFHaOn -+0BdsBIAnQAuEjX1wFjlIgCdAC8SNPX/88wiAJ0AYAsJAPMgB4jSAJ0A8T/1+RIAnQBgDIssEjbt -EjUpUASAAO4SNCvYBIAAWGpJ5q6ebTAEgAAYo5GEMPiABAI/+h4AAAAALjET+mNkFeAKBQD2IgAV -oAwFAO7GOADIUQAA66k4CAQKgAD64EpQEgCdAPTgYoCSAJ0AH6N+LxY2wGBmbkv64EwoEgCdAPTg -TRCSAJ0ALiAN+8BMABIAnQAqEjaIFCgWNXSBB/vATIgSAJ0AJhI1iRUpFjR0kQf7wExAEgCdACkS -NCw1BCo1BSk1ByY1Bv/2xA2gBgUAACgSNiYhE/jAAEM/9tYAAAAoEjaGLPjAAEM/9poALBI2LRI1 -7hI0K9gEgAD6QGgdoA8VAFv+3/dAaB2v9uYAAAApIRMJqQz4JsYV7/emAIssC6sM+ibGFe/3cgAA -ACkxCvhhCBWh2WEA/CWmFeDpeQDl7hEO7cKAAA7dAo4xCOpQ+BoAB7Du4QDi/xEPdMKAAP/GAA9w -+PkA4KoRD/vCgAD/RgANcPlxAAH/EQ+qAg6qAo80DaoCLSANCUlB/SAAFLCI2QD9bQAMcO95APfY -ABcx32EA+cYAD3ufAQDi3RAMy4KAAAndAikxCv+mAA606TEA/9gAFzD/cQD/xgAPcPlZAOmIEQ/+ -goAACP8CD6oC/0YADTDpGQD/2AAXMIkRAA6IAi4xC/5g6BXk7h0A+8BAB3GZAQDumREPdwKAAA6Z -Ai4yBgmIAvohZhWpnx0A6BYPLMwCgAD4IcYV7IA9AP/LAA92jskA7hYNKVAEgAD5pgAOsA4FAOzc -AgDogQAA7BYMK2AEgABYfaEdowX7QFN4UgCdAI405hYzJwzYgAAZo64oEi0vIAepiSmQgCYWM/ZF -xB2g+7UA6/8BDM+CgAD55gAP8PnFAAn/AQj/Ai8kBysSNdag9WAVlCIAnQAvMQoPD0H34FERUgCd -ACkSNYgvijjAs+wSMyDpAQAA+QAARHOqoQD6IuYVoA4FAOgWMClQBIAAWH195qvXbTAEgAAsEjOG -OIgx+GFEFeANBQAtFh/4HAAEMOZhAPiGAAfwmVkA6ZkRD/4CgAD55gAP8JZpAOLuEQzMQoAA6e4C -DETCgAD5xgAPMIZxAP/GAA9w9nkA4IgRD/vCgAD55gAPsKYJAPgmCBWglhEA7qoQDMtCgAD7JgAM -sWbhAOxmEAxSgoAA+sYACzaIyQAI7gL+I6YVoAslAOlmAgDpgQAA5v8CCVAEgAD+I8YV4A4FAFh9 -T+arH20wBIAAhjsrMRKIOoo4+icAB3APRQAP7gIfpMkqFi4oFjEv8HwmFjL2JmgVoJpZAO2ZEA/F -QoAACYgCKSAN+iXmFeDKUQD6RAAF8KoBAOhmAgSAeYAAGaKL+MYAC3AKFQApMRMtIQckFjfoEjEv -IQKAAOwyAS5wQoAA5O4CDaHCgAAE7gL6YUQV6Ei5ACQWJSQSMgF0BPULAAw5RB0A7pkRCiOCgAAE -mQIUo8AoFibk7gILJsKAAPXGAA81jx0A6qQwHScCgAD4hgAKMMzhAO8SLi/BQoAA5O4CDmQCgAD+ -JGYVobthAOqIAg3cgoAA/iXoFaqtAQD5SAAVMN8xAPsGAAwwr0kA790QDVMCgAD9hgAOcE8ZAPiG -AApwn0EA9ygAFLDeeQDqmQIO7MKAAP4HAAVx/yEA/WYADfTeUQDo3REP/MKAAOj/Ag1TgoAA+yYA -DLAIJQD4hgAKMK4ZAP0mAAyy7gEA7BIwLVZCgADtqgIPdcKAAA/uAiQWJwuZAiQSN/9EsAXgCwUA -6pkCAOn9AADpFiIm6AUAAO/uAglQBIAA/iSGFaAOBQBYfOMdokfmqWttMASAACgSNA8CAA8CAPUf -ydwiAJ0AiTwcpFwkIg/uEjMpUASAAP2H5BWgCzUA+IAAQjOZoQDpFhcg6QEAAP+AAEYwDgUAWHzP -5qkfbTAEgAAoMQqMPC0SM/iGAAMwiFkA/AIABTC8CQD8DAAHsJxxAOCZEQ/8goAA7rsQDVNCgADp -iBELNgKAAPjGAAswjHkA+0YADXDMaQDrMgEuZEKAAOz/AgxDwoAACYgCHKQ3+GEIFeAOBQD+I+YV -oLvhAOzBPy3cwoAAC/8C9JAAFbGZ4QDm/wIMywKAAPsmAAz2ZMkABv8CLxYd/YAARnAOBQD7JgAM -sAslAOmIAglQBIAA6BYeIOmBAABYfJ/mqF1tMASAACsxGoo8FqQciT+IPigWMSkWMigSMy9gfCZh -P/olRhWgmlkA6xYrLMtCgADoZggPxUKAAPkGAAxwylEA+EGwFeHrOQD6RAAF8KoBAPjGAAswCEUA -6O4CBIB5gAAZodj4xgALcAoVACkxGy0hByUWOOgSMS8pAoAA7DIBLnBCgADl7gINqcKAAAXuAvph -RBXoWLkAJRYlJRIyAXQE9QsADHlVHQDumREKq4KAAAWZAhWjDSgWJuXuAgsuwoAA9cYAD3WPHQDq -o30dLwKAAPimAAqwzOEA7xIqL8FCgADl7gIOZAKAAP4kZhWhu2EA6ogCDdyCgAD+JWgVqq0BAPlI -ABUw3zEA+wYADDCvSQDv3RANUwKAAP2GAA5wXxkA+KYACvCfQQD3KAAUsN55AOqZAg7swoAADbsC -/ooABrCvOQD3UAAVMf8hAOqZAg/8woAA6P8CDu4CgAD+AwAFMAglAPimAAqy7gEA7JkCDVZCgADt -qgIPdcKAAA/uAguZAiUWJ+USOCpgBIAA/0NKBeALBQDqmQIA6f0AAOkWIiboBQAA7+4CCVAEgAD+ -JIYVoA4FAFh8MB2hlPdAaB2v2gIAAAAlFjiEOIg2JSAN9BsABLD0+QD3+AAXsOTxAOW5OQ90AoAA -D+4CjzH0YOgV7IA9APphRBWgRNEA+JAAEjD/4QD5+AAXudUdAPXmAA+wSnEA5YUYCiRCgAAE7gIP -7gIvMQvkMgQszkKAAOUWDS7sAoAA/CHGFeT/HQD74EAH8doBAO7dEQ//AoAA/6YADvD6GQD/+AAX -sFoRAP6mAArx+iEA/eAAF7aIyQD8pgAK8NR5AOUWDy7rwoAA/6YADvFUYQD1YAAHsERxAOJVEA/7 -goAA/qYACvT6MQDtVQIP/8KAAPXmAA+xSmEA+KYACrCKWQDsVQIMRoKAAPQhhhXgqnkA6YgCDVVC -gADlEjgqTcKAAAqZAunuAgDogQAA6O4CC2AEgADv7gIJUASAAP4hZhWgDgUAWHvf7aFEHQHiAACI -NA8CAA8CAHOGLBuh7SkgBwtLCCuwgPZFxB2g/LUA7JkBDd+CgAD7JgAM8PvFAAuZAQSZAikkB/dA -aB2v1AIAAACKKiyhAukWKCYJKYAAW2KiHaEtKhYp6hY2IwCpgAAqIhAuoQJk4ylbYpsdoSeaYC8S -KPv/tJASAJ0AKiIQKKECZIMoW2KUKRIoHaEf+yAGFa/Z4gAAAC4SNiwhE/+AAEY/2fYAy3f4/7QI -0gCdACsSNoos+0AARX/Z0gAuEjaMLP+AAEY/2WYAhi/4wABDP9nCACsSNIkv+yAARP/Z2gArEjYq -IRP7QABFf9kKAACJJw8CACySChSi6uTAYWTQgQAAK5IJZLBWLbAALgoqftkFL7ICdPFB+gACHeAM -JQBbXcAZoxYcofGcoIsglKKTpSakHPVAxhXv+PUA+UCGFeAMJQDopB0t3gKAAAy7AuumASrQBIAA -WH1YwCDRDwAA+gACHeAMJQBbXsBj/7QAAP9BxgWv9kUA/ibGFa/WQgDmEiwpUASAAPxAaB2gG8UA -W1x2Y/9ZAAAAHKL5LxI1LiANLSAM+CaIFaAKJQD4IAYVoBslAFh61B2g1P/NEA2v5qUAHKLwLxI2 -/EGQFeAKJQD2IAYVoBslAFh6y/1BlgXv/24AHKLpLSAM/kGwFaAKJQD+JsgV4BslAFh6w/1BhAXv -/uoAHKLhLxI2/EGQFeAKJQD2IAYVoBslAFh6u/1BdAXv/mYAAAAcototIAz+QbAVoAolAP4myBXg -GyUAWHqy/UFiBe/92gAAAAAcotIvEjUuIA38QZAV4AolAPYgBhWgGyUAWHqo/UFQBe/9PgAcosot -IAz+QbAVoAolAP4mqBXgGyUAWHqg/UE+Be/8ugAAAAAcosIvEjQuIA38QZAV4AolAPYgBhWgGyUA -WHqW/UEsBe/8HgAcorotIAz+QbAVoAolAP4miBXgGyUAWHqO/UEaBe/7mgAAAAAcorIvEjQuIA38 -QZAV4AolAPggBhWgGyUAWHqE/UEIBe/6/gAAAAAAAAAAHKKoLSAM/kGwFaAKJQD+JogV4BslAFh6 -ev1A9AXv+l4AAAAAAAAAACwSNi0SNe4SNCvYBIAA+kBoHaAPBQBb+/T3QGgdr8g+AIotK6ECZL4X -W2HfHaBr+ibGFa/OogAAAPdAaB2vx0IAAAAcoo78QZAV4AolAP5BsBWgGyUAWHpgHaBg/8a0Da/m -pQArEimKKvwAAh2gDRUAW1o1HaBZ/82IDa/2RQDIa4tg/AACHaANFQBbWi8rEimKKvwAAh2gDRUA -W1orY//SbBAgiCKHMCQWFw8CAPcRTA3nd8EA+kBoHaALRQBYesr3QGgdr/xFAP1AN2QiAJ0A5KIa -HRh6AACIMOkyASQsHIAAZpN9LiANiTKKLicWFuSZAQcY+YAA15D64DmaogCdAOoiECvYBIAAW2HR -ZKdIwKDmpAANFnYAAIowHaEi8UAVUpfqwQCLNCkgDYYyLyETLxYhBGQB+CQGFetmoQAPbAwJxjj9 -YAQF/8sBAI01D8gM6Yw4CzMCgAAGRAKUMgy7AikyBikWJSwyB/pghhXvrQEAKhYf9kHoFa+LAQAI -/wgvFhn2wABDcBglAHjhESgKIXjhCykSIQRIWwiZCCkWHvwjRhWgS7kA9CUGFaCLwQD4JOYVoJvJ -APgkxhXgjfkA+CVmFaCbsQD4JSYV5E3RAPQlhhWgnZkA+CWmFeBL0QD0JeYVoIuRACgWLhigtvhg -KBXiTbkAJBYwKIF//FQAAnCZ4QD4JUYV4BmFAPkkAB2i3YEA5BYYJ0O5AAD+pAId5UwFAPniAA4w -AEIAAAAAAPQjBhWlTAUA+AIiHeH7oQD5wBP0YEuZAPwmRhWgGCUA+cAfRCIAnQDBk/nAFjxiAJ0A -woH5wDCEIgCdAIsVjhSJFikWJC4WIisWIy4SBysSCCkSJQl4WCgWESgSGv9QABU7gD0A+SsADLmI -HQDpFhIsQ4KAAAiqAhmh9gpKAioWEyoSIgxIFPkABAR3qgEA59kRDVUCgAAKmQIqEiP5+AAWt/gB -AOX/EA1RgoAACv8CKhIZ7BIYLVRCgAAK/wIP3QLqEjAuYcKAAOndAg9OwoAA+iWIFefrAQDvEi4t -UQKAAAyqAiwSLy0WEC0SJOH/EA5ggoAADP8C7BItL3cCgADq/wIN3gKAAPokyBWn3QEA6f8CDu9C -gAD/xgAPcvgpAO/dAg5mQoAADLsCDt0CLBInLRYPLhIqLRIpDKoQ4O4RDmNCgADsqgIO68KAAA7d -Ai4SGywSKw4OR+PMEQ90goAADswCLhIoDu4Q/0YADTAOBQDtqgIA6MEAAOyqAgtgBIAA+0YADXAL -BQDqFg4pUASAAFh6INagZmAYijAZn4MJqwF5oASKMXGuVci1iTEJ21LLu9og/B+iHaALBQBYe04s -+o18oQIGpjjaIOwSFynYBIAA7VQAC3AEgABYbb7SoNEPhy/3LwAL//OGAAAAAADzICUQ0gCdAHSW -t2AEtAAA7BIWKVAEgAD64Ggd4A0VAFhmX/dAaB2v+EUA+UAbtCIAnQBmr4wcn2CLMP1gBAW//e4A -KiIQLaECZNSTJxYWW2DOhi8uEhbXoPrAAEMwGyUA+8ALBGIAnQDBk/nACrRiAJ0AwGBlb0ocoXuN -L4oyLiANp93tNgMr2ASAAA7bOAyqAftGAA1wBgUA+mBGFa/xbgAuIGALCVEAkAQODhvxwBb30gCd -ACkWGyYlCRif7f4jyBWgCwUAKyQULiUI+kKmHeAOFQAuFiIrIA2omCiAgAvrOY4g6xYkLEeCgAD5 -JgAMMAsVAPhA5h2gCBUA+CRmFa/1ggAZn+cpkkD+TBAVoYuBACgWG+lpCgwCCoAA+SAIFeDunQDx -wBM30gCdACkWHCwWMi8WMy0WNB6fzSsgDCghByiVB/shhh3gCAUAKJQFKJQGKxIbmJIolBSuvi7g -gPkiph2gCIUAKJQE6JIHL3eCgAAOuwL7IOYd7/71AC6ULCsSII6QLhYxK5QNKxIeiIooFh0mlQnr -lQgsGnYAAMCB+CRGFaALhQD7IKYd4AgFAPgkhhWgCxUAKxYj//KADaALFQAqIhMsoQJkw4FbYG4d -nugZn7QsIhIr0iwpkmnqyggNQASAAKq67hIWLVZCgACqmvlBRhWgHyUA/8ALZGIAnQAbn6gsIBcs -pFcrskALawr7YAYVr/lyAAAtFjQdn6GLOC3SQP4mZhXru4EAKxYVDW0K7dIAKVAEgAD8I4YV4AwV -AFhuci0SNC8SM+wSMiUJ8YAAiTQoIGAJCVHuoCYsggqAAPgjZhXgiJ0A8QAI99IAnQAoIQcpEhwk -FjUlFjYkIAz0QbAV4AsFACuUFSuUFJuSK5QGJZQNK5QFJRIVKJUHJJQM9T7kBaCFOQD6I2gV4qVB -AOiqEQxFQoAA+wYADDZVAQAIVQIaoOcoEh+ktCRAgCqggCWVF+USNiongoAA9WYADbaqHQAKiAwk -EhkrlAf1IQQdoAuFACuUBCQSNYs3ijbmlQksRoKAAKuLeLsBsaopEhyamJuZKCAN/yWGHaAOFQAI -6DkoFiSIly4gdi6UFoiKjpAuFjHoFhQsEV4AACoSHMCYKaQF+mCoFaALFQD6JGYV4AgFAPgkRhWg -CxUA/+vkDa+qAQArIA1kvpEv0i4cn0uOICzCag/uDAruEa7M/UHGFa/57gAAAAD/8EwNr+alANog -/EBoHaAbxQBbWh6JJ42aFqBp5NDoZNCBAACLmWSw3i6wAC8KKn/pBSiyAnaBQfoAAh3gDCUAW1tA -GaCmLRIXHp9wnqCLIJaik6UtpByVpvlAhhXv/PUALKQd/WAAFbAMJQAMuwLrpgEq0ASAAFh62MAg -0Q8AAP1BMAWgGyUA7SAMK/gEgAD6IAYVoAolAFh4Y//jCA2v6qUAAAAAAAD9QR4FoAolAPxBkBXg -GyUA7iANK/gEgABYeFlj/9QAACggYAsJUQCQBPgjZhXgiJ0A8R/5H9IAnQDAgPgkZhWgDhUA/iRG -FaALBQD6JIYV4A4FAP/nSA2gCwUAAAAAAAD6AAId4AwlAFtcHmP/LIwv+kBoHaALBQD3gABGcA0V -AFh5VPdAaB2v7BIAjC/6QGgdoAsFAPeAAEZwDQUAWHlN90BoHa/rngDWwPYixhXv7j4AHKBjKRId -/kGwFaAKVQD8QZAV4AgFAPggJhWgGyUA6RYAK/gEgABYeCktEjQpEhwvEjMsEjKIly4SMfoAAh3v -ygUA64YKJFiBAAAKuwHqMgUl2QEAAJuJm4j/8WQNr6oBAAAAAAAA6iIQK9gEgAD8AAIdoA0VAFtX -8f/sOA2v9kUAHKBEKRIU/kGwFaAKVQD8QZAV4AgFAPggJhWgGyUA6RYAK/gEgABYeAkrEhwtEjQv -EjOLtywSMi4SMftkABWvyAUA+UAEBTAIBQDotgolUQEAAJq5+2EGFa/2BgAAbBAGHaATDS0KJNKE -BARKCUQR9IALF5IAnQAan6/4AAId4AwFAPtQEBWgDkUAbeoRAJAECgsb77cGdMgFAACxzNMPFqAd -FaAd94AJIJIAnQAfoBz+AAIdoAoFAPv0KBXgCIUA0w9tihAAoAQLCRkJCUPpIRR1UBEAAO/8BCdw -BQAA/dreDaAKBQBm4LsanuwcnccCKwqrayzCMSmwfiqigazs45kcDmZCgACsqiqhN8DKDJktpaoK -nDcMTAxmwMUssID7IEAFP5nFAAyZHQpKDKmpZpCvL7B/Dz8cwIoI/y0cn/ken0j/IQAP84qNAPkA -ABQz/40ACP8CL9ajLuCAKjx/7KoBDxB0AAAKSQxmkHT9PSoFoIgFAKiYCHgSDIgCKNaSLNKIDAxK -CcwR+48ADTQJBQB5ok0urfwOfhL/suYVoAIFANEPAAIrCqtrKbB+A5kcwKoKmS0FnzcPTwxm8CP7 -P6wFr/1qAAAAAAAAAAD//GANoA4FABydjP20ZhWgAgUA0Q8cn9AvsH7psH8paASAAOkWACnwBIAA -+XAQFaAKJQD4ICYVoBuFAFh3kcck0Q8AAGwQBBifSvc+kgXgBgUA+kBoHaALFQDsrIAtAQqAAOC5 -Gg4BCoAA/WABBdACBQD9RcAXUAUFAC0KBG3aDwZeCqfuLuLD7pgEcqgFAADiLAEjMIMAAOiNICkn -WAAAwCTRDy+Cwn+w5dEPbBAIx//on4sZSASAAOxkAApYBIAAE55M4yMCAVIBAADjhrMpcCAAAGAA -2AD7FogVpDIBAPpgBADQDRUA4xYELugKgADjny0ZgQqAAO/dAwrwCoAA/iCmFaXiHQD/0AAXMqrh -AOPuCAqDpgAA8z4sBa8GBQD0IGgd4ANFANMPbTobIyKEJCKEAwNHBkQB41YAIqgRAADkJoQhEIMA -ACTihCMSBRKfCATUAeQzAgigBIAA89CGFeADRQBtOhsjIoQjIoTlQgAiIBEAAAYzAQNTAuMmhCEQ -gwAAYAASAJIWI+KEghUNMwEDIgIi5oSCFiLiiIMUADEE7SIBDZgKgAADIgIi5oglgrQdnS8en2nA -IAstOQ5VAQ1VAiWGtPtABADQBBUA6YazKiAKgADvQgMGARGAACuCrwK7AQtLAiuGrxmfXQalEfig -AELwAzUAk1DRDyyCrwLMASyGr9EPbBAGgyAVnscsIFr4QQgV4AsVAPqzaBWgCAUA9LQIFaDMOQAM -uDjqMwwMzkKAAOlECAQIyYAAL0B+LkB//8AHwuIAnQAtUqot0QJk0Oou7AEuRH8qUqpbXnwoCoAI -qAIoJFosUlbvpAAGBzmAALDJCcsBecAVbQgMsLrquwEN4ASAAHrAAmP/7A/MER2c9itSVQzdLC0l -Gg39HC0lGXs7FRqc5SqiMClSoKOqCaoR+yAARLAAGgDAkBuemsPqLrYQLbYRw8ssthAcnyUPCkYI -qhEMqgIqthGLsB2fIRyeke27AQnuAoAA/WYADfAtBQANuwLrxgAkgEGAAJqamJuNIC4hGZ4QKyEa -rrvsnxYV2/0AAJsRKkB/6hYCKfAEgAD4j9AV4BulAPggZhXgClUAWHbSwCDRDwAA/GBoHeAKVQD9 -PhQFoBulAFh2y8Ag0Q8A//zcDaAMFQBsEAgUnMcpMgDkmgEErDyAACgyAfMAFtBSAJ0AwGDnnv0V -AEmAAI0xZtGZwEDzIASakgCdAHmWeisxBNog+2AABfAMFQBYbEzipAAFGKGAACugJi0xDA8CAOfd -AQ3/AoAALzQQLTUMLKEawOEM7DgNzAIsNQzsoFgh6CkAAFh5dOagL20gBIAAKjAR0w/xQfAN4AsF -AG0IEi4gPOTgEWEQBQAAsbt6uwdvtARj/+YAACs0EdpQ6zQACmAEgABYeN7AINEPJjEE+kBoHatm -AQD6wGgd4AwVAFhsKGSigiugNvNgE+dSAJ0ALTAQKCBhDU1DANAECAgb8QATL9IAnQAfnTYtpCav -3//wEBXgjgUA/sAEBjAIJQAIuALopDYv/4KAAA/fAi+kB35oD/ZIAAWwjgUA/2AARbAAHgAGC0Yv -IhQo8QMv8QJ48U3j2REF8G+AAB6esQtfFPngAQT02wEA/yAARLAAQgAAGJ6s+SAARLLbAQAfndGv -nybygPugBADQDhUA/cABB1/49QAI6AMIZgEG7gIu9oDKxBieeSygDB2dPQ29Ai2GsymCtB2ene2Z -AQ5hAoAADJkCKYa0K4aziTBj/m8kMBAvIGH4YIQV40QhAABABA8OG/HADF/SmWEAKiIUKKEC6RYE -LACWAADHxPQgphWgAPYAAAAAAFtdvOkgDSUJCYAALCBVLQoBCdk5CswICckMJiAM5BYFKzYCgAD3 -JgALMIgFAPjGAAswDAUA5MQADgq2AAACKgL6wGgd4AwFAFhrzOekAAUK4YAAW/8VKHA2JnUr+ubw -FaAJFQAJiAIodDZYW3krEgXsEgQr0ASAAOx0WCHoKQAAWHj05qFMbSAEgAAdnmMfnmYuMQQsMQwP -7gENzAEsNQwG7gIuNQQrcRr6YjAVoA0VAAvbOP1mAA2wBgUA6zUMLQmeAABgACBvZB0qoqouoQLJ -5FtdiKdsKsQ8KzAR6p5TEzAFAAB7Y94XnkuJMPZiJh2v9P4AJjEE+kBoHatmAQD6wGgd4AwVAFhr -nOykAAUCoYAA6iQAC1gEgABYY1+JMPUgBAU/8/YAZJ7f6iAMJIFhgAAdndYcnj0t0H0swlWwmw27 -KKrJq5kanjkOmRGqmYmQ//sQDaaZAQAA+UBoHe//pgD/9TwNr+SlAByeMi4gDfxBkBXgCjUA9CAG -Fa/opQD4ICYVoBulAFh15mP/0y0gDC4gDfoAYh2gG6UA7J4mGngEgABYdd9j/QrsniQbeASAAPxB -kBXgCjUA/kGwFa/ppQD4IAYV4BulAFh11WP/kQAAHJ4bjxQuIA38QZAV4Ao1APQgBhWgG6UAWHXN -Y/zEAAAang5j/tAAAGwQBvxhgBdQCRUA8AAcDaSzAQADC0IVndz7OUAFoAcFAACxBOCYGg2BCoAA -+kYADj/79QALiwMsVsXgfBoJ8FQAAC1Sxg29AQ3NAvy4xhXgAFoAA18UBf8KLvLHDr4BDs4CLvbH -IlbFlxAmQCaXEeokAAjYBIAA7WQAAOARAABYBSgTnfGMEYsQ8kACAfFI9QDig1N7bMKAAC0ygSky -gPrABADQDhUAAO4a7rIXbPgEgADt7QIOEJQAAAfpEPnmAAzwAGoAx48I7wMP3wHs/TgPecKAAAj/ -Aw+ZAS02gfhwBhXgAV4AAAD/O7IFolg1APMABqKiSfUAGZuA/6AARrAAkgDEkB6bfA2dCvrABADQ -CRUA753PHMgKgAAAmREOmQKv3R6c567dLtKA92AFoVIAnQAJ6QIp1oDgrREOVgKAAA2qAgq6AgoJ -R+sygCSFEYAAaZFHGZ2/Cgpf6bkBBXCngAAYnE4IqAIoVrMlUrQFxVIIVREFpQL1JgAK8IgFAPim -AAqwADYAJayACFURBZUCW/3WKDKBKDaBJTaA6kIOKVgEgABbXP7JoepCDilYBIAA/AACHaANFQBb -VTfAINEPAAAAAAAAAPM/+buiAJ0ACmkR+E8ADP6+BQD/IABEv/yaAGixQf/9MA2gCQUAAAAdm0se -nZkMLBGuzC3Gg8e/K8aCLcaBK8aAJzaBGp2U2yD2cAYV4AwFAPtP6BWgDRUAW1UdY/91ABmdjvnA -BAT//B4AAGwQBAEEBAQ5GPEhcA3gCgUAbQgMsJgImQHkkAdlUAUAAGP/7P02YgWvtAEA8WHADeAJ -BQDTD20IDLC9DbsB5LAKZMgFAABj/+oAAAD+ACIdr/j1ABuddAxfEav/LPaDKPaCLPaBKPaACDsD -K/aDCEgDKPaCI/aBJPaA751mEOiBAACN0PoAAAQwuQEA6LsRDEXCgADriAIOgQqAAO9fCw9wCoAA -CO4CLvaB7d0JC1zCgAD7oAQA0odBAOiIEQ3YCoAA+wYADHbnAQAI7gL5Nh4FoLc5AAm7EQvuAgju -Au72gCFwU4AA8//iHeAEFQDwADgNpGIBAMc/8kAAAzAEFQAXnRXsm9kbAQqAAABEGgNDAwxcAux2 -xSlwVAAALXLGDT0BDU0CLXbGJXbF0Q8CXxQH/wou8scOPgEOTgIu9scldsXRD2wQBP06CgWgCQUA -+ToCBaAKBQD7NawF4IcFAAiSCiIix8snLbIwJsKCqt0J3RENZghtCB9/JxEvMAwuYAwlMA0kYA1/ -6QJ1QQ4CEhTnZggBAGGAAGP/2QDAIdEPsZnqrCAspuQAAMAg0Q8AAGwQCPs6MAXgiQUA/mHgDhQM -BQADhkL4wABDcAAeAAMGRhmcdAsoCyiCgP8IIATQChUA55zcE3BLgAAGC0QAsQT9QAEG0AA2AAYN -QgDRBACtGhubmQsuAu52xStwiAAAL3LG/6AEB/AIFQAPjznO8yhBAAmIAQyIAihFANEPBloUB6oK -KqLH+6AEBTALFQAKujlkr9rqUg4pWASAAFtcRyxBAS1CAfs55gXhXwUA/0BoHaAKBQBt+hMosoF4 -yQUpsoB50QfrvBAlUAUAANug80AGrSIAnQDrFgQjcF+AAAYORPvABADQDRUA/aABBtAASgAGDkL7 -wAQA0A0VAADdGh+bbg+/Ai92xfbACOdSAJ0AKHLG+aAEBDAJFQAImDllgR0SnNAqEgQCogstIoEt -JoEpIoAcmn/smQILWASAAPhQBhXgDBUAARECWATBihQrUCYBEQJYBGUpQQD6pNAV4plhAC4igSgi -gC4mgR2cIhqcxOu7CQzMwoAA7EEALYEKgADgmRoNgQqAAP1AAQVf+/UAC6oDDcwBLEUACogBCYgC -KCaA0Q8AAJ4V+iCGFaFK9QD7QATS5AwFABecrytyfyuxAumcDBX1SYAA2iDrZAAK4ASAAFv+kSpy -f1tbzoxBLkEA60EBKfgEgADtUCYtEASAAPrAaB2i7mEA7RYAKWgEgABb/xOPFcj86lIOKVgEgABb -W+pkoOQZnJsoQQAJiAECiAIoRQDRDwZaFAeqCiqix/ugBAUwCxUACro5ZK7hHJvtK0EADLsBK0UA -0Q8AANog62QACuAEgABb/nDiEgQjcF+AAAYORPvABADQDRUA/aABBtAASgAGDkL7wAQA0A0VAADd -GhibDI8UCP8C73bFK3BcAAApcsb5oAQE8AoVAPlNAAzwAGIABlkUB5kKKZLH+aAEBPAKFQAJqTlk -kBwGawL6IIgVoAwVAFgEYSoSBCtQJlgEBmP/KwAAABycYosUDLsLLbKBLbaBKrKAHJoQDKoC+3AG -Fa//IgAA6lIOKVgEgAD8ACIdoA0VAFtT6RmcXShBAAmIAQKIAihFANEPbBAE/zXKBaCJBQDtnB4R -4D6AAAOLQvlgAEXwAB4AAwtG8zdYBeP81QD8TV4NoA8VACpBAYdBHJxH+CoCHeACBQBtmhcowoHT -D9MPeKkFKcKAeXEH7MwQIRAFAAD1YA2PUgCdAAsKRAChBP3gAQTQBrIAAAAAC1gUDYgKKILH+SAE -BLAMFQAJyTlkkawpGlD4QA00YgCdABycKwwsCyrCgPFADKzSAJ0A/WIAF1SLAQAAgQT94AEE0AA6 -AAALCUIAkQQA+RoOLgLu1sUt8GAAACjSxvkgBASwCBUA+Q0ADPAAZgAAC1gUDYgKKILH+SAEBLAI -FQAJiTlkkT3zQArtEgCdAG++DQsJRACRBP3gAQTQADYACwpCAKEEAPka7tbFLfBcAAAq0sb7IAQE -sAgVAPkNAAzwAGIAC1oUDaoKKqLH+yAEBLAIFQAJiTlkkL9vvgnwACQNpJsBAAAACwlCwDD7IAQA -3/j1AO7WxS/QCoAA6KkDDIEKgADgOhoN8FwAACvSxgubAQurAvu4xhXgAGIAAAALXxQN/wou8scO -ngEOrgIu9sf7MzgFr/j1ACLWxRub6AwpEauZKpaDKJaCKpaBKJaAI8aBI8aA6iQACtgEgABb/qhk -oHIam9/6QGgd4AwFAPtP6BWgDRUAW1Np6mIOKVgEgABbWynJoepiDilYBIAA/AACHaANFQBbU2HR -DwsMQgDBBAD5Gg4oAijWxfd/8o9SAJ0ALNLG/SAEBLAKFQAJqTllnlItQQDzoAQG9A4FAA7dAi1F -ANEPLlEtsO7+paQdr/4SAAAAAOokAAtgBIAAW/2lY/9gAABsEAgqQQEbm4aPQYgoJ7KC8kgAAvCJ -BQDssnssRkKAAPjgAEOwDhUA6HANIeA6gAD4oABC8AAmAAAAAwVGiXAtsoPsmQwEAKGAAAqYEajd -LNAA84ATlhIAnQAcm6P4KgId4A0FAG2aFyjCgdMP0w94qQUpwoB58QfszBAm6AUAANrQ96BoHaFM -9QD9gATb4gCdAOybYRLwS4AABQ1EANEE/cABBNAANgAFD0IA8QQA6RqaFB+aHg+vAu/GxSrwXAAA -KsLG+yAEBLAIFQD5DQAM8ABiAAVdFAzdCi3Sx/0gBATwCxUACbk5nxXzIGgd4AgVAOmDOQSFUYAA -+gAiHaAJBQADqThkkH0qQQAdm2z7IAAFs/zlAHyxXg2tAQbdAvyABB3gAgUA0Q8scS0ucSzqsoQm -QAUAAP+ADhKiAJ0AKHUtL6ECZP+/W1qPjEErQQHuQQAp+ASAAOkgJi0wBIAA6lQAC2gEgAD4IAYV -4u5hAFv91GP/kQAA6iIOK1gEgABbWqtkoPESm00vQQAC/wEG/wL+gAQd4AIFANEPAAAAAOoSBCvY -BIAAW/4XjBXumxoVB4GAAG9eEgUKRPtABADQCRUA/SABBNAASgAFCkL7QAQA0AkVAACZGuzmxSrw -XAAALOLG/SAEBLALFQD5bQAM8ABiAAVfFA7/Ci/yx/8gBATwDRUACdk5GJs0JxIE6HcLBITxgAAF -WwL6IIgVoAwVAFgDKCoSBCsgJgERAlgCzCpBAPxE0BWiqmEALXKBKXKALXaBG5ssDMwJ46oRDgEK -gADgqhoOAQqAAP1gAQXf/PUADLsDC5kBCpkC+PAGFe/6LgAAAAAAAOoiDitYBIAA/AAiHaANFQBb -UqcSmwwvQQAC/wEG/wL+gAQd4AIFANEPK3Etsbv65aQd7/wuAAAALnKBLnaBLHKAHZi6DcwC/PAG -Fa/9TgAADSGHCg4/Dw0/DQCH+AUIHaScAQD5H+vT4gCdAByaYSpBABuZ3gyqAQuqAvqABB2gAgUA -0Q/HJNEPAAAAbBAKlBj3NYYFpbMdAPJAAALwChUA9CCGFeAJFQD8YMBHUAUFAMCg92ABB7SDAQD+ -IMYV4A0FAOua6RHwG4AAwJD4IKYVoIwFAOncOQ7wBIAACj45nhIZmf38IGYVoEcFAP0y4gWgBBUA -ihj6oAQA0C4FAO2iAyp4CoAA6qICIuBXgAD/oAQH8A4VAP/NAA/wAI4AAO1c4C8CCoAA+6AEAND6 -nQAASBr54AQHsAgVAA+POS0gJgraEepaCA7swoAADV0K+6AARvFeBQDuqggK94KAAJ4Xqd0u0oDx -wAcS0gCdAJ4R7RYAIfAzgAD8IKgV4AAaAI0UANEE7K4CCkAKgADuZsUugQqAAP3gAQdf/fUA7Y0D -CfBUAAAvYsYP3wEP7wL+2MYV4ABOAC8SBijyxw2IAQjoAij2xypmxSsgJlgCRxmZwvs1SgXn2gEA -7Jk2FoxtAABk0FsdmFIqEgENqgItEgD7sAYVoAOyAB6anfogKBWv2oEA7qoBBvCbgAAM2AIoZrMv -YrQPz1II/xEP3wL/RgANcI4FAP9GAA0wADYALtyACO4RDqoCjxD78AYVoAKSAIoQwID5UAYVoAJi -AGTwkO4SBSHwH4AAYAABjhSNFwDhBOBIGg8BCoAA7K4CD/gKgAD+2KYVr/71AO6OAwnwVAAAKGLG -DogBCPgC+NjGFaAAWgCSGYgWIoLHDiIBAvICIobHghkuICYqZsUvIAwA4QQASBro/xEMRAKAAA+I -Ah+Z3APuEa7er+6PEgj/AogTD4gCH5gb74gCB3ATAAAo5gCwd+V+D2KoBQAAKiAkLSAmHpgDjxgb -mSUu4jGP8Suyga7dCd0R7bsIB6RcgABkoEQqsCrrmlwVDU0AAMmu0Q8A/17ADeANBQAqsCqwqvxE -hh3nqgEA+2VGHa//agAtICYD3RGr3andLNKAHpjVDswBLNaA0Q8qsCqxqvREhh2nqgEA+2VGHa/+ -tgAuICYD7hGr7qnuLeKADN0CLeaA0Q8AbBAKkhUfmkAYl+WUGxqX25MZiRmVFCqiMSmQJoUbKIKA -qpn9KAAUtdUdAOmICA7vgoAA6BYBIvA3gAD/oABE8AAiAAAZmjIWmfYXmLr/MoQFoVgFAPSAAAHw -ChUA+mAEANADBQDunggNIAqAAG2KDQc5AilmxSjigHhIBLEzIxpQKxpP82ALA+IAnQDuXgZqyASA -AMCQnRqZEK/Y+CBmFaABJgAAALEz9qAJP1FSBQAZmhcfmSkDKgz/IABH8A0FAG2qEqPeB+kCKWbF -KPKA6EgGdugFAACj3vPAaB3hSvUA/0AH26IAnQCKGRKZ/SqiDgIyCyIWAuIigCnYBIAAW1lOiBTI -gWihnMmjihn6YGgd4AwFAPtByBWgDRUAW1GEKxIJK7IQZLAtLBIJHpnx7MIQKe8CgACu3S7SgS8S -CX7JFC/yEcj+iBkp0oAoghH5AA20YgCdAHQvUhqXkPpgaB3gDAUADwIA+1BIFaANFQBbUW/iEgIp -0ASAAPqgaB3gDAUAWAHSHpnaDD0Rrt0el4ku1oPHzyzWgi7WgSzWgMCwKyaB+lAGFeAASgAA2jDs -Egkq2ASAAFv7uCIaUOsSBSnQBIAAW/ySZKEB9L/3D1IAnQD4IGgV7/tyAAAAAAAA/CFIFeAKFQCP -GQUIQu/wJiwBCoAA5tIIDUgKgAD4IMYV4VgFAOIWBy/+goAACP8I/iEGFeACBQDvXgdqSASAAGAA -AYkWgxijIwc4AuhmxSrwYAAAKmLG+yAEBLAIFQD5DQAM8ABaAAAsEgcswsf9IAQEsAsVAAm5OWSQ -LQM6AvqgaB3gDAUAWAGZjRkt0CYbmZ4D3RENLQqr3RmYt6ndLtKAcO8UwOAu1oCxImktiIwZLMAk -ZMCjYAASixnrsCYp0ASAAFgBMGP/3wAAAI4RLeAqsN0NDUft5ComgQmAAI8ZwOD/5IYdoAIFANEP -iRUokS2wiPklpB2v+84AihksoCYdmYgDzBGtzB2Ym63MK8KAHZgLDbsB+5AGFeAJBQD5RIYd4AIF -ANEPjBWKGYsQ/YGQFaANBQAtphAtphHtpFUuZgKAAP1mAA2wjQUA/WYADfAMFQBYArBj/hvAINEP -AGwQCOOY8hnwBIAAiiiJ4PJv6BXgiwUA6aoRCrAEgAD4SAAC+4kBAOozCARgPoAA+qAAQvAAKgAA -AAAJBUYoIDb/A6APn+SlACkgVGSQbiYmEu4mEytQBIAAWHN1wCDRDwCJ4MBA6uIBJKwcgABmocp6 -ltSJ4Yvg8yANKh/69QD+ICYVp5kBAPsgAIS7uwEA6xYDLMD0AAD2IIYVr+ulAJsSihKGFO4SAS0g -BIAALCA2wNQNzAL8RsYdr/4+ANpg6+QACmAEgABYczTAINEPAADxOUAN4/7VAJMQhxH2IIYVoA0F -APwgRhXj/+UA55ULC6AEgAD24QAV4AECAAAAAAD+zEYNoUj1AHaDGusSAytQBIAA7HQACWgEgABb -/Aj+f6Ido//lALhE7wIAA7ghAAD0n/tsYgCdAClBBNMP8T/7BBE5UQD8aAABWWkBAGgzOP7ABPhi -AJ0AKUEF6kIDLP0OAABlr5naYOsSAyvgBIAA7RIAKXAEgABb/LguOv3+f8Id7/6SAAAAAH5hVixB -BYlD8YSwDeALFQAsJhApJhErJFXnJhQpUASAAPogaBXgDAUAWAJBLjr9/HKAgVP/5QCIERmYWy2B -BAndAS2FBCxBBAwMSfyAhB2v/ToAAAAAAGWftcCgKiYQKiYR+kqmHa/+zgDaIOsSAyvgBIAAW/0y -/n+iHaP/5QDqFgIleNWAAIYU//o8DaAKBQAAAAAAAADrVAAPYASAAOwWASlQBIAAW/3m/iAoFa/5 -2gCeEeo0AAlYBIAA/KBoHaANFQBb/pyJEemSAC0gBIAA/iAoFa/4SgAAAAAAAAD2IIYVoAoFAPog -RhWv+LYAbBAGG5iZkxCUEfUwdgWgDBUAHZdaDS0CLbbFK7LG8WvgDeAIBQAiCv/4uAAXMA0FAP4g -RhWgCgUA9cAARzCFBQBtCCIAgQQAyRp5sA/iVAAFUAUAAC/iwnnwAbHdsYjviA1iqAUAAGP/1gAA -AAAAAP4AAh3gAwUAG5h8LhICC/sK67LHKcAEgAD/8AASsCYFAP6gAEcwBQUA5O4IBYFZgABtaiMA -UQQAyRp5sBLihAAFUAUAACbiww8CAHlgAbHd5VwBJEAFAACx/+M8IC+mqAAAiRCIEZqQnYDRDwAA -AAD4uAAVMPL1APogRhWgDQUA//3wDaAKBQBsEAQbmFsal/4Tlx7TDwMjAiO2xSeyxvDpEA3gAgUA -A1wR+4AARDAFBQBtCBHBbwJmDHZ1BLFVKYLCsSJvKAJj/+fAkAuXCidyx/8wABMwAgUA/MAARDAt -BQDqiAgDgLGAAG3aDsHfAt0MfXUEsVUugsOxIrGZaZTKDEIK6iIICpBgAAAjLQSDMBWWFeUzAgEg -EwAAk0DRDyQtBIRAGJhq6EQBASgTAACUUNEPA1wR//48DaAFBQAAbBAG2iD6IGgd4AgFAOgWACDg -EQAA6BYBKegEgABb/4yMEfogCBXhSfUA8ylWDaAOFQAfmFEPLwsp8oH6YAQA3/j1AO3ygC9wCoAA -6OIDDZEQAADp6QIOEYwAAAfiEALSAin2gQjIEeL2gC0UAoAACCICArIC0Q8A+TCCBeJYNQDii0x5 -7MKAAB6V6PmgAETwAfIAApIB7Ck4DxnCgAAIMwMD3QEp9oEIyBHt9oAtFAKAAAgiAgKyAtEPKfaB -CMgR7faALRQCgAAIIgICsgLRD/kwWAWiSfUA8yJWDa6/BQAKOREJKQz/IABE8AAaAMSQ75XOGYEK -gADtmQoPcAqAAOiZCA90AoAAD+4CHZc5rZntkoAtkHAAAA7fAgjIEe+WgC0UAoAACCICArIC0Q8A -AGixFMDQCMgR7ZaALRQCgAAIIgICsgLRDx6YEg7dAQjIEe2WgC0UAoAACCICArIC0Q8AAABsEATn -l9QR8DeAAPAAIA2kYwEAAAMGQgBhBPUtJgXgCBUA/QABBF/59QDphgMLAQqAAOUlAgogCoAA5XbF -KfBYAAApcsYJaQEJSQIpdsYidsXRDwADWxQHuwoqsscKagEKSgIqtscidsXRDwBsEArmlwcZSASA -APcv0gXgDBUA9S9qBeFdBQD8YYAXUIoFAP5BsBXgABoAwPAokCYSlnMukAz8YMBHX/v1AMCg6O4R -DAEKgADu/gIOQAqAAOruAgxEAoAADogCHpff0w8OiAIukFnoFgEiDAGAAGXhQP0rJh2kowEA+iBm -FaKzAQD6IEYV5eMdAPXAAQdwBAUA/iCGFaBLBQAqkCYDrxHvTwoNVoKAAKpKraqn/6b/KPKA4q4C -CAQKgADxAAQS0gCdAO8SAyHwH4AAYAABjxLuVsUvgQqAAP2AAQff/vUA7v4DCfBoAAAoUsabF5kQ -COgBCPgC+LjGFaAAbgAAkhiIFCKCx5sXmRAOIgEC8gIihseCGI0Q6lbFKdgEgADt0CYqYASAAFv/ -FIkQ+iDoFeAMFQD8KgId4AHKAAAAAAAAAOgSAyHwM4AA+CCmFaAAIgCIEpgViBUAgQTuVsUucAqA -AP4gxhWv+PUA6O4DCfBsAAAoUsYOiAGOFgjuAi5Wxv4hKBWgAHYAAJMakhiDFCgyx4IWDogBCCIC -IjbHghiDGipWxY4RLvaAsLvlvutiIAUAAC+QJPssjgXgDQUA7JUhF4E5gAAtlCQpkCYswjErsoGp -zAnMEay7KrAqsKoKCEfqtCokBvmAANEPZO/E+CAGFeLzAQD+IEYV4AgFAPkrJh2k4wEA/iBmFaVD -HQAFRAr0IIYVoAQFAI8QL/Am6RIDL9aCgADqSggP/MKAAA9PCqf/7aoIAfAfgABgAAGJEuKuAgyB -CoAA7lbFLkAKgAD7IAQA0A4FAADuGuuJAwnwVAAAKFLGCYgBCOgC+LjGFaAAWgCSGIgUIoLHCSIB -AuICIobHghgqVsWm+SiSgHCPE8CgKpaAsUT4n/vu0gCdAIkQY/8NjRDbMO3QJipgBIAAW/6x/CoC -HeAMFQD//1gNr/v1ABiXQgOfEaj/pv8u8oAYlcYI7gEu9oDRDwBsEAYflz8elOT8QZAVoAsFAPxE -0BXgCRUA55ctGlAEgAD1LQANMlVFAOXVCA7swoAA590IAfAfgAALuQLq/jkOZgKAAP+GAA4wjgUA -6b45AfBzgAAoIA39BgAMNKMBAPnGAA8wAEYAAAAAAAD9xgAPMqMBAPktzAXgBhUA75WpHQEKgAD8 -wAEEX/z1AOyKAw0BCoAA718CCmAKgADvlsUp8FQAAC+Sxg+vAQ/PAv84xhXgAFoAA18UCf8KKPLH -CKgBCMgCKPbHE5YfJZbFo9kokoBmgAguloDRDwAAAAAiICbrFgAq0ASAAOsWASDgEQAA6xQACWgE -gABb/ir6IAgVoUn1APUnlg3iXzUAHJbwDFwLKcKBLcKA7hIBKQEKgADgaxoNEMgAAAm5AvfABPlS -AJ0AB74QDt4CKcaBLsaA0Q8AAADl+yx5XMKAAKe5/SkWBaABdgDHr+q/Aw3BwoAACogDCNgBD58B -Dvk4KcaBKMaA0Q//LbAFokj1AHWDEgopEfivAAz+vAUA/SAARLAAGgDEkO2UehkBCoAA65kKC2AK -gADumQgOZAKAAA3MAqOZ65KAJRBHgAD9QyAA0A8FAC+WgNEPDLgCKJaA0Q8pxoEtxoDRDxqWwwq6 -ASqWgNEPAAAAbBAEJiAmJwoB5ZToEgeZgAD0wAYiEgCdAAxpEQWZCCiSnvcAB9HSAJ0AKZKdZJDZ -LSEHHpYSDQ1KDN0RDt0CnZCMIBuWD/2AABYwDjUADswC7JYBJNAhAAD6AAoV4LM5AAoAivCIABQ2 -owEA/kMEFeAchQDslgUtUwKAAPsGAAw/evUA6joBDd1CgAALqgIblNeblIsgLSIQ/EIoFaL/HQDo -lgcv/AKAAA/dAuyWCy1UAoAAmpgclfP9IUYV4AoFAJqZDLsCm5aIIgeIApgiDG8Rpf8u9p3RDxuU -IYq4aqFGDGkRpZkskp5uw1Epkp3kkE1lY/0AAJy4ZZ8zYAAKAPZKhh3v/DYAAAArbBjqJAAJYASA -AFtPxS0gJ8re0Q8A//wkDaAJBQDAoFhuhhuUDIq4a6Gr//8ADaAJBQAAwJDA6g6uNP9hBhWv/sIA -iifAsPtEABWgDBUAW1DiG5XLHpUTnqDsIgAqbAKAAA09Apui7aYDLmYCgAAHzAKcoSckJ9EPAGwQ -BB2WZxuVdRiT/ReVsxaVICiCMRyWIyZigeSICAnQBIAA45ZeHEZCgACoZhWU4g8CAAUlAiXGsy7C -tB+WWu/uAQUoSQAADl4CLsa0IsazGZW5A0gRCYIIKiLB9UAGYuIAnQAqYDRkobomIsEDSwgrsID5 -K2IFoAwVAPFgDe/fZgEACEgKKILD+GAABLACBQD7IAQA1IgdAP2AAQVQCTUAbZon+GAABLS4HQD7 -IAQA05ghAODJGgyBCoAA6akCDlAKgAD7JgANNIsdAPNAaB3gGfUAApkMeT05sSL8XoCCUBn1ABqT -xSqgffNACD9SAJ0A8IAID9IAnQAAWxEEHBQHzAotwvQNDU8NuwIrxvTRDwAAAOokAAtYBIAAW/XN -Z6+3Y/++AAAAAAAAAPqgBiqiAJ0A2kBYBuflpAAFBcGAAC1gNGTRBCYiwQNOCC7ggPkq9AWgDBUA -8cAIh99mAQAISAoogsMICUP7IAQA0AIFAP2AAQVUiB0A80BoHeAJNQBtmif4YAAEtLgdAPsgBADT -mCEA4MkaDIEKgADpOQIOGAqAAPMmAAn0ix0AwZ8CmQx5PS+xIvxegIJQGfUAGpOOKqB9fa8t4FsR -An0MgAAEHBQHzAotwvQNDU8NuwIrxvTRDwDrZAAJUASAAFv1mWevwWP/yNEPBB4UB+4KLeL0H5SE -D90BDV0CLeb00Q8EGBQHiAovgvQZlH4J/wEPXwIvhvTRDylgIgOZEa2Zq5klloD0wyQd7/jSAAAA -6kQAC1gEgABb9YNj/pkAACpgIhuV1AOqEauqG5Thq6olpoD0wyQd7/uSAAAAAAAA62QAClAEgABb -9Xdj/0MAAGwQCo0yjzD6RtAV4IcFAP3wAAJxzXEA/CoABXufAQD4ISYV4e1hAP8iAA4R3UEAD4ZC -9sAAQ3AAIgAADwZGGJW7frcLdIMwGZW6DwIAdJsn/f1CHaAEBQAqIFXTD2Sgb2RAbCUmEuMmEyrQ -BIAAWG/CwCDRDwAAAPkmogXgCEUACLgC6CQ2J6kcgACcGJ4XnRYqFgV5QUgGagLsICYqWASAAFv/ -OCogVStMEuslGCUAiYAAixn6QGgdoAwFAFv+0PAAeA2gBBUAAAAAAAAAwMDqVAAJ2ASAAFhvgcAg -0Q8AwECMGPeADIFSAJ0AjRUYlZH6AAId4AoVAPWgB3FSWQUALyAMjRUsICacFA2tOenJCA5kwoAA -6MwIA3AbgADAoIgUCrc5GpV86JMjHAEKgADtqDkL8ASAAP3gABUwDRUA6KoCDugKgADg3REDcJOA -ACggDf+mAA+wBxUA+wYADDTWAQD55gAPsABmAAAAAAAA+8YAD7AHFQD/pgAP8tYBABqVKgDRBPzg -AQdf+PUA6O0DDoEKgAAYk+mOFeiYAg9wCoAA6KbFK3BUAAAoosYI2AEI6AL5WMYVoABmAAZYFAqI -CiqCxwraAQrqAiqGxxqVFh6UY5kTKabFrsotooCbEvOgBcLSAJ0AL6aAjxebEvfgBJlSAJ0AiBZv -gnOKFhmVThiT5YwgLZKlL5Kg6os4DnZCgACu3R6UfIraKZJaD8wMDqoBC6oCi9t5ywf5oGgd4AAa -AMCQHZSOw/ov1hAr1hHD6y7WECrWEY3QH5UZHpSI790BDkYCgAD5pgAOsC8FAA/dAu3mACSAQYAA -mpqbm//3kA2gDAUA6iQAC1gEgABb/eZj/mXbYOwSBylQBIAAW/0r+iBIFe/9ggAAihOIEi0gJp0a -6BYAKNgEgADoFgEg4BEAAFv8QosSihONGv4gCBWhSfUAepNSH5UHD68LKvKBKfKAANEE5xIBK+gK -gADu4hds4ASAAOraAguQlAAAB9kQ+YYADPAAagDHj+jcAw7xwoAACO4DDpkBDKwBB8o4KvaB+fAG -Fe/7TgApKlPqmxJ+/MKAAB2U8RmSm/3gAEbwAOoAKCpPeoMSCtkR+U8ADP68BQD9IABEsAAaAMSQ -GJTo6pKRHoEKgADvnQoLyAqAAACZEQqZAqjdGpP9qtrtooAvEDwAAAnZAvlQBhXv+bIAaOEJ///E -DaAJBQAAABmU3PmgBAT//5IAAGwQCicgJhySmeWSdxrQBIAAhigrwoMvUi3lUjErNkKAAKtmLWAM -2SD2oABC8I4FAO/dCAquQoAA5bUIDu5CgADtuwgB4EKAAAODQv5gAEGwACIAAAMDRvxigEdQDhUA -GJTQBjIRqCLyQAgVoACSAB2UOANcFA3MCijChCzCiAMNRADRBOyIAg8QCoAACCIBL1EYp2ztwHgh -AMGAAGVBV5oUnRbrFgUtCoYAAGAADQAAnRabFeoWBCIRcYAAGpMYLmEv66KjK+9CgADxwAldkAoV -AMDgGJMS7RYHLwEKgADgqhoOgQqAAP1AAQVf/fUA7aoDDwEKgAD7YAQFMA0VAOqGoyIIiYAAiBfg -3RoMAQqAAOiTAh7oCoAADaoCHZPp6oajJYgxgABkoaafGPwhJhWgDRUA6RYKIghRgAAclJrqFgEu -+ASAAPogBhXgClUA/OBoHeALhQBYbDWJGowZjxgtYAwrCgH9vyAV4A4FAP1iAA9wCgUADro4yq/q -URghBvGAACus/ytVGCjAeCsSBSiM/yjEeC2wYyiQNi3c//1sZh3g+3UAC4gBKJQ2+gAiHeANBQAO -vTjJ2+pRGCeGeYAA7BYJJQm5gACOFunAeCcG0YAAZJE6L2AM7hIFJ7y9AAAu4GPqNAAL2ASAAO0S -BCpgBIAAW/SY0Q8OuEFkgOz/+0QNoA4VAAAAAAAA//9QDaAOFQCIFPIhZhWgAgUACC048iFoFa/7 -igBkrv3AqCrWUhqSuigK4ijWU/tUaBWv+7IAnxicGYgUkhv4IUYV4AIFAAgtOPIhaBWv+44Asa0t -VRgrwHiNFbG7K8R4KNBjK5A2sYj5rGYdoA2FAA27Avsmxh3v/KYAAAAAAADsFgklecmAANpQ+gAC -HeAMBQBYUGX8ISgVr/ySAGSfKR6R8ItgLuJ7+qOoFaAMFQD/bwANsA0VAFtLtcDx/qXGHe/8JgDA -qCrWUhqSkcCAKNZT+1RoFa/5IgBlrdJj/wrx3/OEEgCdAP/3cA2gDiUA+qBoHaAMBQBYUEv8ISgV -r/r6AAAAHpHWi2Au4nv6o6gVoAwFAP9vAA2wDRUAW0ucY/6mAGwQBikgNsDE7JgCBPgygADwApQN -r+ylACgkNokwH5HH+yNMBaAGBQDxIARa20kBACsgJiiiMSfyg44xqLjmJCcsRkKAAPjgAEOw3uEA -9iAGFeBu8QD/zeAIkH75ACwgWymiMSjye33BOqm5iygq8oMJuxGrr4vwCZkRqarouwwHDDCAAO0W -ASYKIYAALvBzsO78ICYV584BAO70cyYIyYAALSRb6iQAClgEgADsdAALaASAAFv/BsDA6lQACdgE -gABYbdTAINEPIjEELhIADMoC/SfSBaAbhQDu4CgpaASAAFhrhh+RgxaS6xSS6X8hQ/BGYA3hKMUA -coMwiRCNECmQJYoQ7dIfJIchgAAqoRN6IweMEA8rESvFE43c0w8PAgBk0Nv//kQNoAwFAP/+JA2v -7KUAixArsChksNqMELG9DQ1H/YUGHeAKRQD9J5gFoBuFAFhramP/ygCLECuwKGS/yYwQLbz/DQ1H -/YUGHeAKRQD9J4YFoBuFAFhrYI4QLuAoZe+eiBDApP0nfAWgDwUA/wSmHeAbhQBYa1iJECmSH4qc -ZKCni51ksKKKEAuwAGP/cAAAACqiHvwAAh2gDRUAW0sq/CAoFe/7ZgAu8HPAweqiHidwBQAA/+5m -HaANFQBbSyL8ICgV7/rmAIgQwJHphCUpf8KAAP8CZB3v/HoAixAqsCIDqhGkqqaqKqKA+22mHa/8 -RgCLECuyH4u8ybWLEMDQ/WJkHeAMFQAstCX7ZRAV7/wmAI8QLvAiA+4RpO6m7i7igP/tph2v/1oA -jxAo8CLv8G0sRMKAAKSIpoj/EAYV7/sGAABsEATqJAAKYASAAPpiABXgDTUAWEQ00qDRDwAAbBAE -b2NcZTBZ8MBwDeAY5QB0g078yQAA1yIBAMlh+kBoHaALBQD34AAGsBz1AFheg/DjMA3vxAEALVEA -+kBoHaALBQBYXn3JYfpAaB2gCwUA/APiHaANBQBYXnjAINEPb0u4xirRDwDaIPygaB3gCwUAWF4n -Y//ObBAGJCAh+gACHeAc9QD6gGgdoA0VAFhea/qAaB2gCwUA/CBoHeAcNQBYXhv6gGgdoAsFAPwD -4h2gDQUAWF5h6ZNTEY2BAABoMkJoMz8iICH6AAId4Bz1APpAaB2gDRUAWF5Y+kBoHaALBQD8IAQV -4Bw1AFheVPpAaB2gCwUA/APiHaANBQBYXk/AINEPKBEA6YgBCdeCgAAKiAL4IAQdr/66ACoRAAmq -AfogBB2v/oIAAAAAbBAG/GGgBlAkZQB0MRjGKtEPAAAoIEn1CWYNoAkFACkkSYIQ0Q8AwLD6RDAV -oByFAPwAIh3gDhUAWEpK5qBubRgEgAAqICH6AAId4BwlAPwEAh3gLgUAWEpD5CRJKZAEgADRDwAA -KiAh+gACHeAchQD8ACId4A4FAFhKOuagLm0YBIAAKiAh+gACHeAcJQD8BAId4A4FAFhKM+agEG0Y -BIAAwKDqJEkpkASAANEP0jDRDwAAbBAEwKX9JhAFoBuFAO0gIinwBIAAWGqg+AgCHeQIBQD4YAQE -8A0FAOmNOQHgNIAAHpCVDt0CDQ1PKiAhG5Gc/VgAFDAJRQAJiAIotsH/IpwFoA+lAP94ZhXgOSUA -LLLD4MYkdMv9AADLnA/qMCziRa/MD+owD88MavHhCOowCMgMa4H2Y//VACmywhuRjQuZAfngAATw -DEUA+aYADvALBQBYXe7SoNEPHJGCHZGC/yKuBaAKFQD6AQId4A8FAFhqdsCk/SL8BaAbRQBYanPH -K9EPAAAAAAAAbBAEwKX9JaYFoBuFAO0gIinwBIAAWGpq+kQwFaALBQD0AAIdoIMBAP6AaB2hDQUA -+a0ADzAMRQBYSedmoCnAovpgBAUyCQUA+y0ACjALBQD6RDAVoAyVAP6AaB2iDQUAWEnd0qDRDwDS -oNEPbBAEHJK6/ERQFeAKVQD+Q6QVoBuFAFhqTyogIRyRUwupESnGwf0iDgXgCKUA+ZhmFaA5JQAr -wsNwtiSwmcudDuowK9JFDrsIDuowDr4MauHjbQgID+owD78MavHXY//wLcLCHpHG/eAABvALBQD/ -pgAOsAwFAFhdqNKg0Q8AHJE7HZE7/yIiBaAKFQD6AQId4A8FAFhqL8Ck/SJuBaAbRQBYaizHK9EP -bBAEwKX9JSAFoBuFAO0gIinwBIAAWGol6iAhIYEBgAD9IDwF4AsFAP8gOAWgDAUAWEmk0qDRDwAA -AAAA/SAuBeALBQD8AAIdoA4FAFhJneagCm0YBIAAKCEdd48D0jDRD9ogW/+90jDRDwAAbBAEFJDL -FpACKSAhFZET8yIiBeejAQDkoLpszsKAAMCwCpwCLDbBKzbCw5L6eGYV4ABqALCZZJDWC+owKkJF -q6oN6jANrQxr0XYsMsNwzuPAIGYg7SY2wsDRLTbD8ABwDaA5JQCwmWSQfQvqMA7qMCpCRdMPq6oO -rgxr4TMsMsNwzuHAIGYgqmYgIArqMClCRQqZCg3qMA2dDGrRDm0ICAvqMAubDGqxAmP/8NEPAAAA -bQgIDOowDKwMasG/Y//wAG0IDQ3qMA2tDPe/++CSAJ0AY//rKTbBJjbCwOn+eGYVr/3yAAAAAO2Q -3RrgBIAA/yFiBaAKFQD6AQId4A8FAFhpz//9+A2v8rUAAAAAAAD9IaYF4AoVAP8hTgWgC4UA/KBo -HaAPBQBYacX//IwNr/K1AMCh/SH6BaAbRQBYacBj/0TAof0h9gWgG0UAWGm8Y/80AGwQBvpAaB2n -yTUA+EOEHeHINQD4Q6QdoAsFAFv/pGegCtKg0Q8AAAAAAAAA+kQwFaALBQD8A+IdoA0VAFhdHGav -3vpEMBWgCwUA/CBoHeAcNQBYXMxmr8gej6AtEQDTDw7dAg0NT/wgBB3gCwUA+kQwFaAcNQBYXQ5m -r6T6RDAVoAsFAPwD4h2gDQUAWF0IZq+O+kBoHaALBQBb/4Rmr4AqCgX9I/IFoBuFAPxEUBXgDhUA -WGmOKiAh/R8OBeALBQD/HwoFoAwFAFhJDmegBNKg0Q8A+kQwFaALBQD9I9gF4Bz1AFhc8mavNvpE -MBWgCwUA/CBAFeAchQBYXKJmryAekeQtEQHTD/+gBAawDjUADt0CDQ1P/CAkHeALBQD6RDAVoByF -AFhc4mau9PpEMBWgCwUA/APiHaANBQBYXNxmrt76RDAVoAsFAPwgQBXgHIUAWFyMZq7IHpHPLREB -0w//oAQGsA5FAA7dAg0NT/wgJB3gCwUA+kQwFaAchQBYXMxmrpz6RDAVoAsFAP0jgAXgHPUAWFzG -Zq6G+kQwFaALBQD8IIAV4AwFAFhcdmaucB6Rui0RAtMP/6AEBrBuBQAO3QINDU/8IEQd4AsFAPpE -MBWgDAUAWFy2Zq5E+kQwFaALBQD9I1wF4Bz1AFhcsGauLvpEMBWgCwUA/AJCHaAdJQBYXKtmrhj6 -RDAVoAsFAP0jSAXgHBUAWFylZq4C+kQwFaALBQD9Iz4F4BwFAFhcoGat7PpEMBWgCwUA/AJCHaAN -BQBYXJpmrdb6RDAVoAsFAPyEQh3gHBUAWFyVZq3A+kQwFaALBQD9IyAF4BwFAFhcj2atqvpEMBWg -CwUA/AJCHaA9xQBYXIpmrZT6RDAVoAsFAP0jDAXgHBUAWFyEZq1++kQwFaALBQD9IwIF4BwFAFhc -f2ataPpEMBWgCwUA/AJCHaANhQBYXHlmrVL6RDAVoAsFAP0i7gXgHBUAWFx0Zq08+kQwFaALBQD9 -IuYF4BwFAFhcbmatJvpEMBWgCwUA/APiHaANBQBYXGlmrRAqICH6AAId4BzlAPwAYh3gDgUAWEh4 -Zqz3KiAh+gACHeAcJQD+AAIdoI0FAFhIcWas3iMgIsCl/SK6BaAbhQDuIR0p6ASAAFho5fpEMBWg -CwUA/CDAFeAMBQBYXAb9SwgN4AQFAC4RAy8hHSUaAAXuAv/jIAXf7gEAH47eD+4CDg5P/iBkHaAA -LgAAAAAALhUD+kQwFaALBQD8AAIdoA0FAFhIVGasaSogIfoAAh3gDEUA/gACHaPtBQBYSE5mrFAq -ICH6AAId4AyVAP4AAh2hDQUAWEhIZqw3JiEdwKX9IkgFoBuFAO0gIitwBIAAWGi7KiAh+gACHeAM -RQD+gGgdoIYBAPitAA8xDQUAWEg5ZqBhwLD6AEIdogkFAOpqAQpwBIAA+y0ADzAMlQD6RDAVog0F -AFhIL2agOeshHSlQBIAAW/4AZqvIJCRI+mBoHaALJQABEQJYAV1mq7Qcj74DOxEMuwgssoAdjysN -zAIstoArsoBmq5nkJCAtEASAANEPAAAAbBAEKiAhG4+Z0w/9WAAUsBzVAAyZAim2wf0elgXgCKUA -+XhmFaA5JQAussPg7i10y/0AAC2ywi76AP+gBAawHNUA/eAABvAuFQD/pgAOsAsFAFhb8mbwTMAg -0Q8AyZsO6jAs0kWuzAjqMAjIDGqBuA/qMA/PDGvx9mP/rByPfR2Pff8epAWgChUA+gECHeAPBQBY -aHHApP0e8gWgG0UAWGhuZ4+y0Q8AbBAG+kQwFaALBQD8IGgd4BzVAFhbjSgRAOogISR8bIAA+gAC -HeAc1QD8H+Id4O7lAFhH5dKg0Q/6AAId4BzVAPwf4h3g7vUAWEff0qDRDwBsEAQiIRzRD2wQBMCl -/SGSBaAbhQDtICIp8ASAAFhoUCogIRyPVAupESnGwf0eEgXgCKUA+ZhmFaA5JQArwsPgtiV0y/0A -AGSQSg7qMCvSRa67DuowDr4MauHgD+owD78Ma/H2Y//UAB+OrhmQsy7Cwh2QssCw+cAEB3CDAQD5 -7QAOv+4BAP+mAA6wDAUAWFul0qDRDxyPOB2POf8eHAWgChUA+gECHeAPBQBYaC3ApP0eagWgG0UA -WGgpxyvRDwBsEAQWj1IYjiEPAgAGJwF4cRV1JwJ1Pxf24V4NoAIFAAY0AXhBDtEPdjzmxCDRDwAi -CsDRDyIKgNEPAABsEAgjICL6RDAVoAsFAPwiABXgDBUAWFs59UBoHeAHFQDpjy4dAaIAAAM2Ealm -KGK3G484C4gCKGa3K2K38WAUXNIAnQDzYBQdEgCdACoRCCggKwokQHhJCmRCgdJQ0Q8AAAAA+kQw -FaALBQD8IkAV4AylAFhbIeav3m0oBIAA8JoQDeAJBQAqIEj0AGId4E8FAPkb0AWgCyUA/ERQFeOq -AQAcjw4PAgAD3hEM7ggs4rcIzAIs5rfs4rclDBGAAPVADEiSAJ0A9UAMYRIAnQD1QA6JkgCdAMCg -7wIADSgEgAD3X/ugkgCdAPpEMBWgCwUA/CKAFeAcxQBYWwDmr1ltKASAACogL/8gngWg63UAC6oB -KiQvKxEK7uIAIOhhAAD/oAYVocthAK3MLMAADcwRDKoCKiQvKWKA/2QgBtKZ6QAcjv/9P8AV4A4l -AP5D5B2gCQUA/Y0ADPAAXgAAAB+O+iclH/k/oBWgCQUACPk5ypEtYoDH7g7dAS1mgCtigByO8Qy7 -AQubAitmgCpigAeqAipmgPpEMBWgCwUA/COAFeAMVQBYWtXmrq5tKASAAC8hHRuO1+oRDifkPoAA -e6wh8ACADaBJBQB1pwj4GAId4ABWAAAZjZ8LqAH5AAc0YgCdAMCQKiIQKSUe9kVmHeALBQDrJCAl -UAUAAComEN0w7hEIKngEgAD8IAYVoApFAP0gHAWgG4UAWGeT//jsDaAFFQAAAC0iESkkKyklHukl -HyboBQAA/EImFe//EgBwx2snJEj/+kgNoAoFAABwx2T6SQYd7/oSAHDHYSgK8CzigQ/MAizmgSzi -gSr6vwrMASzmgSogSAiqASqsECokSAuqAiokSAioAfkf8mbSAJ0AwKH9H9wFoBtFAFhncvRJBh3v -+N4A//jEDa/69QD/+KQNoAoVAPhJBh3v+H4A+EkGHe/4XgD4EAId7/xyABuP4SoRCAuqAfohBB2v -9d4AACMgIPpEMBWgCwUA/CPAFeAcpQBYWoJmoEUsEQ90xxYuPP7+7QAKsA0lAO0kICqQBIAA0Q8A -APpEMBWgCwUA/CPAFeAMVQBYWnVmoBIvEQ8P30AvJCAPPwwPdTnSUNEPKTz7+O0ACvAIVQDoJCAq -kASAANEPAABsEAT0YAqJEAu1APRgCkuQCgUAaDktezEq6I+5EdCfgAAIOAqIgAqAAMGQCaoC9GAK -s5IAnQD0YApxEgCdACwaAAyqAhiOUQMkEahEKEKAGY+tCYgBCKgCKEaALkKGH401D+4CLkaG/J/C -HeAFFQDtRoEhrSkAAGg2Qmg0P/RgBvuSAJ0A9GAGuRIAnQD0YAa8EAmVAPhgBnxiAJ0A9GAGOZIA -nQD0YAa8kgCdAPpgBnxiAJ0A+P/CHeAAHgApSq77GgIFrPv1AAubAStGgSqgfdMPf6956iQACdgE -gABbubDqJAAJ2ASAAFu5PeokAAnYBIAAW7hzGoz1GY4YKqIxKZKBoqoJqhGqmSmRHx+ONPigAATw -C6UA7Jz+JI3xAAAMtTjZUChCgxKOLw+IAQkiLQgiAiJGgy5ChB2OKw/uAQndLQ7dAvyQhhXgAgUA -0Q/AINEPAAAAAPscSgWv+t4A+JTCHe/9cgD4mYId7/1SAAAAAAAAGY9k+UYADX/7IgD4iYId7/zy -ACxKAP1GAA0/+r4AAAAAAAD4DIId7/4mAGwQBB6Ol+yO8hl8woAA+xtqBeAJBQD4AAIdr/31APAA -JA2gChUAsZlolEUPlQquVSVSw/6+8A3gAgUAC5YRbQgsACEEAKcad1AWC2MCI8azI8K0DXQD9KAE -Ar0zAQADiDexIu8sv2MwBQAAZF+3Y//MrvUlUsLwo+AN4AIFAPYQAh2giXUAbQgrACEEAKcad1AW -C2MCI8azLsK0DX8D/qAEAv3uAQAOiDexZuaTCXEQBQAAyFFj/80iWu4IgjnRD2wQBBuMmiwgIhqM -oCuyMy0wCCqigKy76TIBLd5CgACrqoqn+mFwFe+ZgQDqog4mg4mAAPWgBEiSAJ0A9aAIaRIAnQD1 -oATJkgCdAGjUEcCk/R4uBaAbhQBYZpXGKtEPAPUgBLMSAJ0A9SAFq5IAnQBpmOcLvgn7wACHMN/l -AK/uLeECLOEBLuEALjUH/GGGHeHMQQD8YaYdoAIFANEPAAD1IAdLEgCdAPUgB2uSAJ0AaZinL6IU -/mBmFeACBQDRD/UgBwsSAJ0A9SAHs5IAnQD1IARsH+KlANEPAAAAAAAA9SAH4xIAnQD1IAgLkgCd -APUgBGQf4qUA0Q8LuQkKmQkpnHYrkQIqkQEskQAsNQf6YYYd4apBAPphph2gAgUA0Q8LuQn7IACE -sKylAKyZK5ECKpEBLJEALDUH+mGGHeGqQQD6YaYdoAIFANEPKyxc6wYAAdBBAAD6gmgdoAIFANEP -LqBc7jQPJWlRAADtJgAB4EEAAPyKaB2gAgUA0Q8AAC+gcP5hJh3gAgUA0Q+CqvJgZhWgAgUA0Q+I -r/hgZhWgAgUA0Q8soDTsNA8lWLEAAOtGAAHIQQAA+JJoHeACBQDRDy+gSO80DyVxAQAA7mYAAehB -AAD8mmgd4AIFANEPACKgZPJhJh2gAgUA0Q8ooGr4YSYdoAIFANEPAABsEAQYjBsUjT4ogjEbjUgk -QoGiiOeNsBxGQoAAqET6iTAVoC+FAP4EYh2gLSUA4ywRCAQKgAD0YAQuEgCdAOSgCGk0woAAxirR -D6tl/GAGNGIAnQD+YAc8IgCdAP5gBjxiAJ0AKkAjI0RJKUr+6VaBJSztAABopjNopDBop31oonr1 -QAQkEAuVAHuhfGijefVABoyQDLUA/UAGTCIAnQAtSv78sCYV4AIFANEPKUquLcr/DZ0B/LAmFeAC -BQDRD6vL/UAEXGIAnQD/QAT8IgCdAP9ABURiAJ0Ap8gigsDHngkiASKGwC6ygS/63Q/uAf9wJhWg -AgUAIkRJ0Q8tSqb8sCYV4AIFANEPLUrM/LAmFeACBQDRDypSgBuMVguqAvqwBhWv/QYALFKBe8de -p24t4sDA8Q/dAv3YBhXv/KYAKFKAGYvKCYgC+LAGFa/8YgAqsoAdjlgNqgH7cAYVr/3yAAAAAPiJ -gh3v/R4ALrKAH4ycD+4B/3AGFa/9ggAosoENiAL5cCYVr/1KAADrQCMpUASAAFv+g2P/kgAAbBAQ -ijCEMfZEUBWgBwUA/RpQBeBIFQD/QwAC30SBAPiABDqgCxUAGY49CUkKiZAKkAAAwMB5pj+EMQQE -X/SAHrmQCIUA9QGWDaApdQD0gCR7UgCdAHlBNByOMu4gIytoBIAA/kbQFeAKJQD0IAYVoBuFAFhl -qcbK6lQACdgEgABYZ+vAINEPAAAAAAAALCIfLMIQy8nqJAAJ2ASAAAvAAP1AaB2v/1IAAAAcjh7u -ICMraASAAP5G0BXgCiUA9CAGFaAbhQBYZZRj/6oAAAAAAP/+kA2v7KUAKyEdLCEc/CImFaHbSQD8 -IaYV5UsBAPQiBhWh+zEA/iHGFeDrQQCeHy8gNi4gI4QylBL8IAYVoApVAOsWAStoBIAA/RwGBaAb -hQBYZX0oIh9khpYpEhEq6gAKmQL1IDRUogCdACsSEAQNRX25JIweBG5Bfskcjx8EiEB4+RQEmUHp -Fgwkt2GAAIod+UA3FGIAnQAEvkDygBx9EMRhAPKAG/zQpGkAH4tn23D77QANsA4KAAAAACwiH4zA -ZMZi+kBoHaALBQALwADqMgAtYASAAGP+iQAALCIfjM5kxQrrRAAJUASAAAvAAOoyAC1gBIAAY/5p -AADrRAALUASAAFv/I+oyAC1gBIAAY/5RAAAAAAAtIEnC5v+gJr0iAJ0ALCIfjM5kxOLrRAAJUASA -AAvAAOoyAC1gBIAAY/4h+kBoHaAMBQBYScGKMP/4RA2gDAUA3ED6QGgdoAsFAFhJu2P/5QAAAAAA -6zwIKVAEgAABEQJYA4PqMgAtYASAAGP93gD/92gNoAwFABiLHSogIRSMPyiCMSkwCCRCgaqI7Izl -HEZCgADoRAgE/QyAAC8xCC4wCZ8VLzEJ/UYAElDuIQCJFQCZEen5Ag18woAArP8p9sgp8sD/bQAP -P/jlAAiZAQnpAin2wCkwCC8SEn6XRS8xCi4wCZ8WLzEL/UbgElDuKQCIFgCIEej4Ag18woAArP8o -9sko8sDAkf8tAA8/+dUA6YgBD0/CgAAImQIp9sApMAgvEhN9l0UvMQwuMAmfFy8xDf1G4BJQ7jEA -iBcAiBHo+AINfMKAAKz/KPbKKPLAwJH/LQAPP/m1AOmIAQ9PgoAACJkCKfbAKTAILxIUfJdFLzEO -LjAJnxgvMQ/9RuASUO45AIgYAIgR6PgCDXzCgACs/yj2yyjywMCR/y0ADz/5dQDpiAEPT0KAAAiZ -Ain2wCkwCC8SFXuXNykwCeIWFivABIAA/mCkFaCZGQADohGsIi4mxy8iwC4KEPnNAAx/6fUACf8B -CP8CLybAKTAIIhIW8T/yFlIAnQAsMQfpjSQWHXGAAC5AIurMEi90woAA+cAAR3+qAQCt7irmgCpF -GStENClALmSTZfiFxh3v+C4AABuLTi0hHiohHxmKvhSMRvjgaB2g6jEA/y0AC7D6OQDphAAMcASA -AP6NAAxw/TEAD745JCAkLyAr/wYADDWqAQDriqQdUgKAAO4gLCoiwoAA9OYACjDdOQDtuTkP+EKA -AAr/Ai0hHAn/AikgIwj/AgT/AiggISQgIC01BushHSzOAoAA6zUHLEQCgAAJiALo/wIKJsKAAATu -AiohGSo1CA/uAp4y+EaQFeAIBQCYNpk3JCA1JDQSLyAv/mJmHe/ujgAAAAAAAAAA6iQACdgEgABb -/d/9QGgdr+4mAAAAAAAA+xgiBeAAMgD7FsYF4KRpACkgIh+NCAOZEa+ZH4vnr5kokoAfjQUPiAEI -uAIoloApIC8vCv4PmQEpJC8OmQL4ReYd4PjVAAiZAekkLy5/woAAD58C/kXmHeD4tQDo/wENT4KA -AAn5AigSES8kL/hF5h3mDwUAePBEBJpBy66LHXqxOiwiH4zPmhztFgQmFlmAAOsSDClQBIAAC8AA -GIzoLiEdjxyNFOjuAQ/9woAAD+4C/kOkHaAAKgAAAAAAwKAoGgAISwF4QEvqFgkmjGGAACkSEJsa -/SAIzWIAnQCdFIwf+iFGFeAPFQAL+zn7gAgVYgCdAIge+iEmFaGUMQCZG/kACXViAJ0A6jIALWAE -gABj+ikAix/KvigiH4iFnRT6QGgdoAsFAAuAACgiH4iE+kBoHaALBQALgAAbjMEpIR2NFAuZASkl -HSwSEH3JBI4fZOE0ZNHJL9z//eAOGOIAnQAsIh8swgNkwBUtFgTqJAAKWASAAAvAAO0SBC18YgAA -HoyxLCEdDswBjh4NzAL8Q6QdobQxAHvpA48fyfEYjKrTD+jIAQ3OgoAACYgCKCUdKSAr6hYJJPqJ -gAAqICJYBHKKGWP/QQAA/+XEDaAMBQDqZAAKWASAAFv95P1AaB2v5oYAAAAAAAD/5UQNoAwFAAAA -KCIfiIWdFOokAApYBIAAC4AAHYyQLCEdmhkNzAGNFPghyBXhtDEAmxsNzAIsJR17mQ2PGi4SDygK -AQ+POX/hJSgiH4iE60QACVAEgAALgAAbjIEpIR2KG+uZAQ1WgoAACpkCKSUdKCIfiIjaIAuAABuM -dykhHYoZ+yAEBPELBQALmQL4Q6Qd7/o+ACkxBv/yTA2gmQEAjB4Ea0H7n/O8YgCdAPxDpBWv/BIA -J0Q0W/0DLUA0ZdxnL0AiGIw0A/8RqP8Yi0H54ABHv+oBAC72gPqDJB2v8S4AHIxgLyA2LiAjKRIR -mRD4Q6QVoAolAPQgRhWgG4UA6BYBK2gEgABYY8v/+EQNr+qlAAAAAAAA7iAjK2gEgAD+RtAV4Aol -AP0YoAWgG4UAWGPBY/hfAAAcjE0vIDYuICMoEhGYEPxDpBXgCiUA/CAmFeAbhQDkFgIraASAAFhj -tmP/pgAAAAD/9tANoAoFAByMQC8gNi4gIyoSEZoQ+EOkFeAbhQDpFgEraASAAPQgRhWgCiUAWGOo -Y/9ubBAI/xhsBa8NBQD7GGYF4Pz1AOIqCwtIBIAA80AAhXEXRQDnJygNVwKAAOuqCAdD6wAA6HcI -CbcCgADnZggEg5GAAB+MJwIpC+iJkRzOwoAAq5kbjCT7OKYV4AslACt25ih25yjxf5gVKJbBKHbo -L/F+mhQPSC4PTyzsWQgH2AUAAAi/ORuMGA2ZARiKyAWbOZsWf4NyC4wUAM0RDf0CLabJLGamL2an -0Q8AAAAAAAAAK3LlmhT1YAUzogCdACRmpepy5ypYBIAAWGfa/PyoFeAMBQBYZxHwqrAN4Pn1APig -AEL/CAUA6FUBBYUJgAD8IIgV6KUdAACsEQy8AizWySpmpitmp9EPAByL+IoVhRYZiqco4qnkFgEp -aASAAPggBhXgKwUA5RYDLEdCgAAKiCzpiCgJ8ASAAPggRhWgCjUAWGNWGYqa/CCIFailHQAAqxEL -mwIrxskqZqYpZqfRD99A/RfGBaAKNQDrFgApaASAAP5gaB2gKwUAWGNI9PyoFa/89gAAFYvYZb9i -GIvU6IKpKWgEgAD0ICYVoAkVAOkWACnwBIAA+P0IFeAKNQDsi9Ed+ASAAOUWAyxHQoAACYgs+CBG -FaArBQBYYzTAkfwgiBWopR0AAKsRC5sCK8bJKmamKWan0Q9sEAgZiRsmIAcTiSEpkjMjMoCmmQmZ -EakzgzeIIoM+yITAINEPAAAnPQEqcaBkobArcYJksaoqKsP6YABFMlvlAPpgAEXwDCUAWF9THoux -LTKC/6YeDaAJJQApcaDzIBfv0gCdAMKEmBDzIBp/kgCdAJgQ8yAdL1IAnQD4IGYVoAJGAAAAACoq -z/pgAEUyjQUArT38IEYV4A4FAP+o5h2gD6UAL9RM/6mmHaAoFQAo1Enp1Eoh2BEAAPmpZh3gDBUA -/anGHaAZtQD5qQYd4AyFAFhfMSlxoPMgC1/SAJ0Aw4aYEfMgDW+SAJ0AmBHzIA+nUgCdABmLhy+M -2g8PSAn/AokSmBP/KMYd6P8dAC+URYkTF4lhixP4YABE8ooFAPsgAESwCAUA6JQhJdjFAADolCIr -RwKAAPTABmIUux0Ap4gqgp77QB1j4gCdACqCnWSjQ4kTG4kuKZwx+gAIHeSZHQDpFgQtQASAAG2Z -AggCYY8UjBMdiVn5FPgF4qsVAKs7maCIIJ2i7Yk5FnBJAADupgMsRgKAAAj/Ai+mAR+JvP5wCBWg -CQUA6aUKJmAJAAAspQvtpgYrRAKAAAjuAg/uAu6mBCVQgQAAWF7z6xIEK2cCgACnzCvGnSoyjrGq -KjaOBQ1H9b/xyRIAnQCKJ/qAaB3gDAUA6qwgKmgEgABbQt/AINEPAAAaiJGJqPcgF2CSAJ0A7BID -K0cCgACniCuCnizMMQxMFP1gF1uiAJ0AKIKdZILisJubqOqEAAx4rgAAYAJRAACOEioq3fpgAEUw -GBUA+csGHaALFQD7y0Yd4A0FAP3LJh3gDEUALORXLzAm7+RbIdihAAD9y4Yd4AzVAFhexSlxoP/5 -WA2gSJUAAAAAAAD4YABHMqp1APvAAEUyjwUA/8AAR3AIZQAo5CL5xCYdoAkVAPnEhh3gDQUALeQj -LzBi7+QlIdmRAAD9xMYd4AwlAFhesIgRKXGg+QEAFa/4KgAciG74YABEMYsFAKs7+3yQFeKqdQD7 -AABFMo0FAP0AAER/+aUA+zkADPANFQD9BIYd4AdFAPjvAAvwDwUA/wRmHei3AQAMuwL7BEYd6Lsd -ACuEISkwdOmEJSPj8QAA74QmIdnZAABYXpOIEbJ5+QAARH/2fgAAAAAAKirL+mAARTKMBQD8YABG -P/nlAPmIph3gGJUA+YjGHaAPBQD/iOYd744FAP+JBh2vzSUA/YkmHeALlQD7iUYd4QvlAPpgAEXw -HFUAWF57KXGg//LQDaA49QAAAAAAAPhgAEUyjQUA/UAARvAJZQD5pEYd748FAP+khh3vziUA/6Sm -HaAIBQD5pGYdr/vlAPukJh3gDLUA/aTGHaKrdQD7QABFcUvVAPpgAEXwDCUAWF5iiBApcaD5AQAV -r/FmAPhgAESyqnUA+yAARTGHBQCnN/b8kBXiiwUA+yAARP+OBQD/JIYdoAjFAPkkxh2vzSUA/SSm -HeALBQArlCMdiq4Hdwn84KAVoVs1APpgAEX4zAEA7cwCA7gFAAD9JEYdqMwdAOyUISvgBIAAWF5E -iBC2efkAAER/76YAKjKPK2wY6qwBKWAEgADqNo8pUASAAFtDmgULR/l/21lSAJ0AiifAsPtEABWg -DBUAW0XUHYjznaCMIPsVJAXgDRUA66YCLmYCgAANzAL9QCYVoAIFANEPAAAAAAAAAP/xXA2gCgUA -wKBYYkwah9KJqPk/6FCSAJ0A//ScDaAIBQDAgMDqDp40/0EGFa/0YgAAAABsEAT0ACId4AcFAOYg -IiGFgYAAKCAtE4jwFIfL5SRlJAFhgAAkQjEjMoEPAgCmRAlEEQQzCBSKXyIxHwQiAfPgAAEwxAUA -BCICIjUf8wBoHa8KBQAUiYoDYxGkMysygsDRCNI5+2AEBbfIAQACxTkLWwIrNoIpMoBxnhslMoAZ -iLcYiVIClzkIVQEHVQL0cAYV4AIFANEPLjKECu4BDl4CLjaEKzKAHYitHIlIAtc5DLsBB7sC+nAG -FeACBQDRD8CA9kymHe/+HgAAAABsEAYkMAAViMHwhGAN4AYVAPSAD/iSAJ0A9IAQmRIAnQD0gBEZ -kgCdAOuKQBgECoAA9IAEOhIAnQD6AIIdoBuFAOyKORpoBIAAWGGdxirRDwAAAIgx+kBoHaAJJQBt -mjL4YAAEtLgdAPhkAAYz2EEA+1+AFaPoYQD5SuYd5JsdAP1Kxh2kmR0A/UqmHeSJHQAupFQoMAHx -AAu2EgCdAOhSfSIHuYAA9IAHeJIAnQD0gAc5EgCdAMAg0Q8AABSHcC8gIiRCMy1SgaT/7jADL/5C -gACv3Y3XDuQJLzAFjd4vJGcsMQMNTwksJTQpMAT4TMYd78wBACz1bywgZyMagPOgAEVwGLUA+yYA -DPHMAQDp9XEuZgKAAAjMAv3uBB2gCwUA66QFJ0gFAAAppOQqIGb//gId7wwFAO7pCQUMCYAAesAN -CooU5KAdZdghAAB6yPF68Ay0u/AAHA2kqh0AALG7ChoUZa/3LCBnqdnzIABE8vsBAP34ABeyzAEA -D8wCLJQGKiE0CooUKpQHKCE0+SEGHaACBQDRDwAAKiBkhCDAMOhEDAUCwYAA2kD6YGgd4AwFAPJg -AEKwDQUA9KqQFeAPBQD+ICYV4A4FAP4gRhXgaUUA+CAGFeAPBQBbPPNmoBsGXDfqRAAJ2ASAAFs8 -1+agCmGYBQAAKCBkeDOrKSAty5/6QGgdoAsVAFv/StKg0Q/AINEPLDAH7CRkIdghAADrBgABUVEA -APqCaB2v+aIAALg+7iYAAWlxAAD8imgd7/lWANKg0Q8AACwwAcDi+AECHaANRQD9gAQE8HyNAPmA -BAUxvI0A7bsBDVfCgADodwEMz0KAAP+ABAawjAEA6pkCDEZCgAD65gAL8qyNAO6qAQ7uwoAA/QYA -DHDMOQAMqgIKdwIJdwL45gALsAsFAOckLSlQBIAAW/8fY/3WKSBnpN/z4ABH8pkBACn0BighNAiI -FCj0By4hNO70CC2QBIAA0Q8AAGwQBBqICYwgI6J/A8wM+1AoFafMAQCjw+uG4BmeQoAAo6ODNyuy -MSMyDgy7CP1oABWwDiUA66oIAaAHAAD4kEQVoYUFAPRgAELwDRUA+pYkFeAMBQDpQYMkB0mAAOxU -xiSNIQAAaJJt9SAFoZIAnQAqMpYoUMYqrAEqNpbpRYMkALmAAPpAaB2gCwUA/AACHaANJQBb/aQb -h1HsiWwZUASAAFhhJcAg0Q8vMo4qMon34ASaUgCdAC8ylgv4LujcOAUFmYAAKVDGLTaW7kWDJP5B -gABj/60uIDVk4H8vIElk8HkoIF1kgHMuMpYL7i4O3DgsVMYrQa7ksGxl+/0AAA8PT+9FrieDCYAA -KjKWKFDGsaoqNpbpRYMke/GAAGP/Yywyli9Bri1UxitQxu/pOQZgBQAALDaW6UWDJfrhgABj/0HA -INEPZa97KDKWsYgoNpb4kGQd7/y+AAAAAPy4xh3v/lIAAAAAwLBb/rn//mgNoAk1ACpQxrH7KzaW -6UWDLXgmAABlzvxj/wwAAGwQCBqGgiwgIhmGiCqiMymSgKyqCaoRqpmDl+uJKhT4wQAAnxGDPuyU -ByThYQAA/CBGFaHoBQD4YABEMc0FAPxgAEbxrgUArj7ulhApUASAAO2WFSSwgQAA6JYaJKERAABb -/ssbiRnkFgQpUASAAFv+yOuJFhlQBIAAW/7F64kUGVAEgABb/sLriRMZUASAAFv+v+uJERlQBIAA -W/6964kPGVAEgABb/ronPQEtcbEscbAbhmTTDw3MHAy7Nvr15B3gBRUA5TQZKdAEgAD0YOYV4AQF -APRjBh2gDMUA5DYIIdhhAABYXJMnFgMkZQIkZAAlZAHjZgIhwDEAAPjAZhWvzwUALzRO9GmGHaAJ -BQD0aaYd4AoFAPRp5h2gjAUA9CAGFaAOhQBt6juimy6wTI0QqTj7wEAFM+4BAP+gAEa3qgEA7RYA -JLgngAAM3xGfEC2wVC2EVC2wVKyIKYTF7YS9JMgFAACsN/4gCBXhOZUA6ToIBXAFAAAuNFz+YoYV -4u4BAOzuAgjYBIAA/vcGHaAMRQBYXGjrPEwhsJEAAPrAaB2gHEUAWFxjKhoO+mAARTE7hQD6YABF -8BxVAFhcXY4RDwIADwIAJOQMJOQNJeQOJOQPJOQDJOQAJeQBJOQLJOQFLTBO9cEmHeD9OQD/wQYd -4N0xAO3kCiHhQQAA7DZrIdjhAADrNm0h0PEAACo2byQ2aCQ2aSQ0bPRtph3vyQUAKTRu5DRvIcCh -AAAoNm4oNmomNmz+RbAV4AaFAPZuJh2vjoUA7zRwIdmxAAD++iYdoAxlAO0gLSGxgQAA7XTSK1AE -gABYXDP2IIgV4UrVAPpgAEUxWxUA+mAARfAMJQBYXCwkdAwkdA0ldA4kdA8kdAMkdAAldAEkdAsk -dAX6bdAVoNulAPpgAEXxggUAojL04SYd4Mo5APzhBh2gqjEA+uFGHa/JBQApNNzkNNohwcEAAOg2 -cyH5mQAA7zZ1IfGpAAAuNnckNnAkNnHmNnQh6ZEAAC02di02ciwg5CU02+Q03SGxyQAA/YAAhjAN -RQDtzAkLUASAAFhcBvYgaBXhWjUA+mAARTGLVQD6YABF8ByVAFhcAIgSLArerDwkhAUkhAslhAEk -hAAkhAMkhA8lhA4khA0khAz4e5AV4K1lAPxgAEbwrqUArj71ASYd4KkxAPsBRh2gmTkA6YQIIfnZ -AAAvNnovNn4mNnwkNnkkNnguNn8tNn0sNnv0WKYd4At1ACt1oCQ2iSQ2hCQ2jvTwZB3gAgUA0Q9s -EAQVhZQUhrclUjEXh18kQoGiVeaIKxquQoAApUQlQR/yg6QV4EgFAPqDxBWgiQUA5lUBCTTCgADl -RR8h5MyAAHinK+pBHyk0woAAp2UrUoDAIeiqAggECoAA8WAEyNIAnQDyhbAVoAJGAAAAAAAA9sAA -QvACBQAo+gAtUoQsQR0I3QH8RgAO8AIFAO1WhCZgiIAALkEeeecXL1KAK0EfwCHpuwIHjWiAAPKF -sBWgAUoAJ1KCE4VlCHcBBycCJ1aCIzB94oaTEfyugAAoQR/iYggEYEiAACMilBSGTAQzAiMmlNEP -KCKUGYZECYgBKCaU0Q/RDwAAAPqD5B2v/fIA+oPkHe/+ugBsEAoL6jAWhh3TDyhif/lgGtOiAJ0A -K2Z/HYVKF4gBKmJ+LdIg9OAoFeAMBQBYYvgehUUu4H3ltQwHcCiAAC8wAGjzKceO+EAEBDA5hQB5 -gRzApf0P6AWgC4UA7zAAKmgEgADlFgApcASAAFhfScGTdZMsCeowGoUzKqIgKwoUBbsMC6ooCpkI -CuowCpoMaqEObQgIC+owC5sMarECY//wFoZBkhQiZr0XhfbyIMYV4GlFAPQgphXgDDUA/NfGFaAA -jgCwmWSRlwvqMCpyRQqqCguqCQ7qMA6uDPnACPiSAJ0AK2K+cL7awCBkImtkQT8Vhi7vEgQic/0A -AJ4Z9CDmFeADBQD+AAAH8AU1AP4hBhXgANIAALCZZJEcC+owCOowKnJFCqoKC6oJCKgMa4E4K2K+ -cL7fwCBkINVmIUexM3Q7NMtRjBnA0Z0afDMDwOCeGo8Yihrk8FJtV8KAACkKZPrXxhWv/y4AbQgI -C+owC6sMarG6Y//wC+owGoXALKJ//WAPo6IAnQAdhO4rpn8Th6Qqon79pAgV4AwFAFhinJsx6jYA -Io0RgADRD48Wo/8v8AAvZr3A4f9GAA8waUUA/tfGFaAAegCwmWSRSgvqMAjqMCpyRQqqCguqCQio -DGuBPitivnC+38AgZS9NKGK+8x/6OFIAnQBgAIcAAG0IDQzqMAysDPef9sCSAJ0AY//rjhYtYr2j -7v3ABh3v/H4AAG0ICA/qMA+vDGrxtGP/8P/9EA2gBTUA/Q74BeAKFQD/C2IFoAuFAPwg6BWgDwUA -WF7P//uEDa/ytQAAAAAAAP0O5AXgChUA/wtOBaALhQD9C5wFoA8FAFhexf/5rA2v8rUAIvq5jhSP -FowaiRUv8ACZEJMR8iBmFaAKRQD8IEYVoAuFAOyHYRpoBIAAWF64iBl4OzTAsCtmvfoAIh2gaUUA -+tfGFaAAegCwmWSQwAvqMCpyRQqqCguqCQzqMAysDGvBVitivnC+37BVCuowDOowKXJFCZkKCpkK -DJwMasEICuowCpoMa6H2//jUDaADBQAAAAAAAAD9DogF4AoVAP8K8gWgC4UA/CDoFaAPBQBYXpf/ -+swNr/K1AAvqMAurDGux9mP/nADAof0OcgWgC4UAWF6PxyvRDyxivvOf7GhSAJ0A8/ciHa/2FgAt -Yn6x3fzPxhXv8oYAGoVALqJ+se7/T8YVr/gSAAAAAAAAAAD9DkwF4AoVAP8KtgWgC4UA/CDoFaAP -BQBYXnlj/zsAAGwQBBiEZCiAffsKYgWgCwUA+AICHeBsdQD/A8AHEB4FAG2aDC2hlOzRMHVQCQAA -sbvwAJgNr/u1AAAALCAiDAxC/4YADjALBQBt6gwtoZTtwQh1UAkAALG7x7seha0u4oXB/wv/DH/t -C8H8/kWGHeACBQDRDyggIvEAcA3gAgUA0Q8AwKT9Df4FoBuFAFheVMAg0Q9sEATAsPxEUBXv9PUA -8woWBaAPBQD/CzIFoAMVAPwXAh2gGAUA7NwCCVAEgABtigwooZTsgW51UAkAALG72iD8FgIdoAsF -AP2mAA4wGQUA0w9tmgwooZTsgXl1UAkAALG7HIX2A9oRrKwowoQp+gAJiAEoxoQrwoAehcwOuwEr -xoAL6jApIkUJmQoLmQkL6jALmwxqsWptCAgO6jAOngxq4V5j//Bmv5Qo4oQAsQQAOhrgsQQNTAKA -AOSqAw/gCoAADJkCCogBCYgC+dCGFa/9vgAAAGa/iSjihACxBAA5GuSaAw2BCoAA4PwaDMwCgAAM -mQIKiAEJiAL50IYVr/2SAB6EARmFMKmpKJKAHIZmGoUiG4P1rNwqooELiAIoloAr4jMu4jEswICt -u+3uCA3eQoAAq6uLtwnuEa6q67IOJngygADAINEPAAAAAO+2giXgBwAAL8WhL8WgL8Wu/5BEHeAL -BQBb/BbAINEPbBAGFoPmIyAiF4UIKmIxFYWw+PAoFeAPRQDzQABFcAQlAP1IABUwCwUA6pkIDcAE -gAAdhpUDOhGtrY3Q/yXwFaDNEQD97QAMMM0ZAPyNAA2w/+UAD+4B/yXmHaDdIQAO3QL9JeYd4P7V -AA7dAS2ULwvbAvsl5h3g/LUADLsBK5QvCLgCKJQvFIT0pKQuQoAfhWcP7gEuRoAsQrcdhnwNzAIs -RrcrYjEpcoGju+6GVx3eQoAAq5ktkR8skR0rkR4O3QHtlR8mZKiAAHi3IiuRH6WqLKKAxNANuwLx -gAyw0gCdAP0lsBWgBkIAAAAAAAAA9UAARXAMBQAt+gAvooQukR0N/wH/hgAP8AwFAO+mhCdgmIAA -KJEeeYcbLpEfK6KALwqAD+4C8WAKoNIAnQD9JbAVoAU6AMCxL6KCHoOWDf8BD88CL6aCLuB9f+8i -KJEfeIcQKUKUHIR/DJkC+JKGFeAAQgAtQpQehHYO3QEtRpQkooAVhNIFRAIkpoAkYjMfhe4qcoGj -RO8/CAomQoAAqkSFRy/wgIVe8+AHZ5IAnQApIR/1CJYF7/T1APMJsgWgvYUA/GYADvWZAQD1IAwR -EBgFACyc+PoAIh2gDgUA/UIADzAPBQD6oGgdoAwFAG2KDCihlO2BMHVQCQAAsczaUPwWAh3gDAUA -/GYADvAZBQDTD22aDC+hlO3xOXVQCQAAsczAINEPAABmz9IoIoQAwQQAuhrgwQQNTAKAAOSqAw/o -CoAADZkCCogBCYgC+FCGFa/+tgBmz8kvIoQAwQQAuBrkiQMOAQqAAODqGgxEAoAACogCCf8BCP8C -/lCGFeACBQDRD8DB+yPkHe/5+gDAwf8j5B2v+soAKGIxo4gJiBGoqlv8vyxyfy9CAAz/DPrwKBWn -/wEADPwICcwRDKwILMIHLmIxLMIOKF0C/8AAR3ALFQDrhQImaAcAAO/Rgi92QoAADqoILtGx6dGD -J/YZgAAlGoD1gABC8AgFAOhUxiSNcQAA9SAEgRIAnQD1IAbBkgCdACrClihQxiqsASrGlunVgyQA -uYAA+oBoHaALBQD8AAIdoA0lAFv6ABuDreyFyBpQBIAAWF2B//mMDaALFQDA8f/6PA2gDgUAAC/C -jirCiffgBVJSAJ0AJsKW+AAiHaAHBQAOby7vhzgFBmmAAChQxvuSxhXgCSUA6dWDLHzOAABj/6QA -AC9ANWTwiShASWSAgy9AXWTwfS/ClvgAIh2gBgUADv8uD4Y4JlTGLtGuZOBrsOgICE/o1a4kAxmA -AC7ClipQxrHuLsaW6dWDLXpGAABj/1MALtGuKMKWK1TG/rjQFeAKJQDuqTkEQAUAACjGlunVgy/5 -BgAAY/8rAGWvbC/ClrH/L8aW+bBkHe/8JgAAAAAAAPq4xh3v/koAnRD8ICYVoAsFAFv7Co0QjBH/ -/jANoAk1AChQxrFqKsaW6dWDLHaeAABlfstj/tsAbBAEKSA30w/zIAZm0gCdABqDnP0IVgXgDxUA -/ysgB1/+9QDZoPoAAh3gGAUAbYoMLJGU6M4JZMgJAACxuyv6+yPShBSCwhyD5SkgN+RCMS2BCoAA -7MKBL6AKgAD+lwAMMPy1AAyZASkkN+gzAQokAoAABDMCI9aE/y8AB9ALBQD4AgIdoJyFANMPbYoM -KaGU7JEIdVAJAACxu8e7KNKEALEEAPkaDpoDCogB6iA3LMwCgAAJiAL5sIYVoPzlAAyqAfpG5h2h -qh0A+kbmHaACBQDRDwAAAAAA+gACHaALBQBYPOspIDcqCu8KmQH4RuYd7/yCAAkbFPpG5h3gAgUA -0Q8AAABsEAgagpETg7QpojHycCgV4AsFAPUFCAWgbHUA/SgAFLAYBQDpMwgFU9sAANMPbYoMKKGU -7IEIdVAJAACxu8e7GYPfLEAp0w8pkoX7YAQA0AoVAP1AAQVQ8vUA+yGghaAb9QAqMCwPAgB7qR/z -gAZ0IgCdAMCl/QpiBaAbhQBYXIPyhSYdoAIFANEPAPwAYh3gqgUA7RQQINhBAAD8IiYd4AwVAFv9 -FWagwSoKofoiIBXgDBUAW/0R4hARLQWCAABmIHItQCl9KXoqQCguQCr7zSYNoAIFACkwLGiUXmiV -WysKCP0KLgWg/fUA+iJmHaBfZQD+IkYd4K4FAPogBhWgCkUAWFxiKgqg+iJAFeAMJQBb/PpmoGQc -hQstQCrzQGgdoBuFAP6FEBWgClUAWFxXL0AoL0QqZiAl0Q8A0Q/AINEPAAD6AKIdoBuFAOyE/xlw -BIAAWFxN8oUmHa/9ugDaMFv90tEPAAAAAAAA569TbRAEgABj/74AAAAAAPNAaB2v/toAbBAQGIIu -0w/TDyiAfSMgItMP5CArJHAcgABkNAopICXAYfEj0A3gBQUAKiAoHIOcF4Ob6SETJRwxgAAtnAH6 -oGgd4O0BAA5rOO0lEyWAsYAAKSIfi5xksMaPnWTwwdogC7AAZDQRKCIfiILaIAuAAOekAA0YBIAA -90AZYJIAnQAqICt0oW1ko4naIFv+J9OgZjBxG4ItKiIAKSEfK7J/+08ADXWZAQD1IBuokgCdAGiS -H/UgHdISAJ0A9SAeFBIAnQD1IB4VkgCdAPUgHhYSAJ0AG4KNHILILMJGLTroDb0sB8wRDcwsHoS4 -A60Rrt2c0Fr/ryoiHSUkLi6hAy2hAn7ZV8Awx/V/cQ0bg1jsg0UZUASAAFhcU2YylcAg0Q8ALSAi -A90R96AARvAaBQApICKs3e3SgCzMwoAAp5msmSiSgA1NQPytAA1/6/UAC4gBCogC+TAGFa/8MgAZ -hJwfgd4uIR4UhJsdgdQcgdEbgdGbFpwUnRooICL0IaYVoE45AOT1OQrgBIAAFIJtKyEf/YBoHeDu -MQAOTTkeg2QJiAL4IYYVoJs5AOnsOQ54BIAALiAr+ESQFaWbAQDtzAIMygKAAO0gLC9wQoAACe4C -GYHPBe4CDO4C/EOEFaC7MQALnznpICMsQsKAAAj/Ag/uAiggIS8gICwVHushHSzOAoAA6xUfLEQC -gAAJiALo7gIP/sKAAA/dAikhGSkVIA7dAp0e+EaQFaAPBQAvFhIoFhMuIDUuFEItIC/8KGYd4AsF -AFs7rSoWFRaBrRiBnhSBvuyDaR0YBIAA/CKGFaABIgAAAAArQAz1YAULEgCdAMiW9WAMMJIAnQD1 -YAvykgCdAGRRvOoiHSHYBQAAWzubLRIVGIGM5IGtHRgEgAD7v/McIgCdACiCLSRCg6OICYgRqEQr -QS4ZgYH3eQYNoA5FAIhACIgRDogCmBUvQAcPD0HtQgcv/AKAAA+/Agn/Ap8YLNIKKtwg69IJJgW5 -gAAsCihbOa0egXLlpAANEI4AAMBQLeB98b/659CdAQAsICsvICLAkQycOe//CQYC0YAA6oNfFhi/ -gADKx+tADC//AoAAr6oqoIDTDw8CAHupKupEAAlYBIAAW8eg/wK6BaAAWgAAaMMf9YAKKhIAnQBo -xRRoxsUrQAwt4H3//AgNoJ0BAAAAAAApICIYg0kJmQnrQAwszwKAAKmIKICAe4nX6kQACVgEgABb -xtf/ApIFr/8aAP/9JA2gCwUAKiAuZazRY/1Twbz6RYYd4AIFANEPsJkJCU8pJRPzP+TX0gCdAGWc -gPREph3gCkUA/QdcBaAbhQBYW0kpIh+KnGShBIudZLD/2iALsABj/GoAACsgK/pEUBWgDBUA+40A -DfAMBQBYCFhj/mzaIFv86fNAaB3v8dIA+wUmBe/yxgAtICzB7/+/32QiAJ0AW/6RY/vhAAAAAADr -HBAqUASAAPwAgh2gDSUAWyCf/IAIFeAKRQD9B7wFoBuFAFhbKWP+GQAAAAAAAAD7B7QF7/GGANog -W/4/Y/vl+wIqBe/xRgD7B6oF7/EmAPsHqAXv8QYAAAAAAAAsEhQvIAEuIAItQCL4QBAVoApFAPgg -BhWgOyUAWFsTKkAiG4L3CqwJDMwR/WAARbAOFQAutHktIAAttHosIAIstHspIAEptHhby9j/AeoF -r/naAC4gIu0gbS90woAAp+4fgmiv7v3QBhXv7XYAAI5Y+gCCHaAbhQDsg7Ma6ASAAP5EUBXj7gEA -WFr4i1j6+AAH8Bi1AHjxMopHjav7RAAVr8kFAAmpAenZCALZAQAA+KAHweIAnQDCyFs5FB6A2OWk -AAVs8YAAY/+jACwgIgsNQ33Jw44dDg5faeO7GYFxHoDXKyEeJRYW9QTSBeAMBQD9gGgd4Ps5AA/t -OS4hH/+AaB3guzEAC585+EVwFeCOOQDoXDkOWASAAP+GAA51/gEA4ZkQD/oCgAAPmQINmQIMmQIs -ICQdgM4ObkDu2zkOYsKAAAy7AguZAisgISwgI+jMEQ3cAoAADLsCC5kCKyAgKCAsC7sRC4gCKxIW -CYgCKSEcKbUWJSEdmLoltRcvIRkvtRj+RpAVoA0FAJ2+nr8egKQsIDUstDL4RfAV4AUVAPlmZh3v -8v4AAAAA/W8ADf/8IgBsEAYuMQvtIgAnROkAAGjrEMCj/QbCBaALhQBYWqfAINEPHINejjaPN4k4 -mRD4YSgVoAo1APggJhWgC4UAWFqewCDRD442/mDoFeAKNQD9BqgFoAuFAFhamMAg0Q8AAABsEATA -INEPAGwQCIggkxSJFCMgBxeBCvYAQh2gBKUA+QDSDeEzAQDWQPRgCUISAJ0ADDgRp4gpgp73IBMb -ogCdACiCnQiEAugWAyQKKYAAGYDYCQCHbWkCCAJhKSEHiyAagQb8IIgVqpkBAAyZEeqZAg3WAoAA -/WAI06AFBQAfgieZQP8B/AWgDIUAnEOeQvkB4AXgDSUADaoCKkYBCbkCKUYEKvKALvJ/6yEJKccC -gAD3AABEcAwFAOaGnSdz/QAA/+/mFaANFQBbOj+KJyj6wOWmCiV4gQAACP8BjiIv/ECfqe+mCCcC -sYAA/QYsBaAKVQD8QAgV4DslAFhaV4giZICEwLD7/gIdrwkFAG0IDXiQDQiIFOSAHGXYIQAAY//r -eKALtLvwABgNpIgdALG7CBgUZY/32iBbO7qKJ8efKaYAJSYHWzbSJSQE5SQFKhAEgADRDxWAJolY -9yAKUJIAnQAMOBGniCqCnvdACpOiAJ0AKIKdZIFJsJr6oQYVr/saAAAAAAAAAP/+qA2gCwUA0oDR -Dx+B5I4THIEMlRH0IAYV4A1FAO2rAg3HgoAALSAHDIgC+cCGFaAshQCc45ngm+EZgK75wEYV4d0B -AO0WAijQBIAA790CAVmFAAD9wKYV4Aw1AFhWVbQa+kugFeAMNQBYVlKPEx6AFRuBy5X79eFGFe/4 -9QCY+Zj4mPeV9owQihH4QOQV4IQFAPXgAEI3zMEADKoCmvyKEo0QGICUC6oC64CRHu4CgAD/pgAO -upkBAO32DSzPAoAAC5kCKfYQiyAl9hYl9hcl9hgl9hkl9hol9hsl9hwl9h0o9hL74qYVoCyFAP3i -ZhWgDkUA7IDTHdYCgAAOrgLu9hEtx4KAAAyIAvnihhWv954AAAAAAAD/9oANoAgFAMCgWFpKiVj5 -P/V4kgCdAP/2JA2gCAUAAMCABJo0+qEGFa/17gAAAABsEAYtIAeSEBmBtvUDbAWh3QEADd0J6ICY -Hu8CgACk1CRCf6mIqNj4gAVUIgCdABeCkhaBrfegAEPwCwUAjRCN0G0II45IJUIADwIA4kIHJwDZ -gAAvIgEPjxQG/wF/0RrlcXF6oASAAGP/1YixCIgUBogB+b0+DaACBQCNI44i+gCiHaAvBQD74AgA -0DslAP0E9gWg7p0AWFm8iUGLQJuQikDppgEp6ASAAPogCBWgCAUA+IAGFaAMFQDoRgEpWASAAFgw -gipM+Fs2PdRQ9P/7ZWALBQDAINEPAAAAbBBGKCAE+QAXIlIAnQAXgBkVf6MWgZiJMR2BUhh/k/Mg -FpiQBIUADQCJKyAMGoBvLIItIyEZKqKI/WAARbAZBQDoHH8t3kKAAOuqCARAxQAAbZoCCACKKqEu -9UAUhGIAnQAZf3wYf3z+QAgVoO8VAC8UyCgWLukWLC92AoAABO4CLhYtKSAHCQlBAJkRCakCB5kC -KRYwCOowKBYxJhY0/iamFaBPBQAvFWctIFItFOEsIAUsFOL6RhAV4A0VAC0U4CsU4+4iFSDR/QAA -7hY5JVFFAACLpY6kj6PoogIg4f0AAOmiASZhxQAAmcGYwp/DnsSbxYqgKsYA6iIAIVjRAADqFkIg -8AcAAOggUiDIBwAA6JQNIPgHAAD6QLAVoAyFAOr0ECDIBwAA6CAwIPgHAADt9Awg0AcAAPkiJh2g -DQUA7eQOJVBhAABYVZHrLDwg0AcAAPtEABWgDIUAWFWM6yxGINAHAAD7RUAVoAxlAFhViOssTCDQ -BwAA+0WgFaAMNQBYVYPrLFgg0AcAAPtGgBWgDIUAWFV+/DNEFeBjIQDyBgAE8IMpAP4zZBXgozkA -8i4AD3CzWQDuPgIN3kKAAO8ViS1XQoAA7yIMLEfCgADoZgIMz4KAAPsmAAywg0EA8goABXDuAQDp -7hENVoKAAPtGAA1ws0kA7IgRDd7CgAD7BgAMcD0pAOqIAgmewoAA88YAD3T/mQDv7gIA+AcAAC70 -FPxMkBWgvWkA+kywFaDdcQDquxEO7kKAAP1mAA3wzBkA/4gAFjDaOQD9ZgANsMoxAO7dEQ5nwoAA -DcwC/WYADbCqKQD7RgANcDsFAAuqAir0FYUsCYgCCGYC9+LmHaA1gQD0EQAHcFWRAOruEQquQoAA -5e4CCZ7CgAAD7gIE7gIu9BaDJ406Kjwg6TIJJqF5gABklCcrHH/7ZiAV4AyFAFs808Ag0Q8AAAD9 -YDFMIgCdAIQp8IFADeBbZQAqQAX7QCZMYgCdAIRLZU/vwCDRDwAAAAArIAX6AqIdoE01AP14/g3g -PPUA/QEsBaAOBQCeEfwwBhWuCwUAmxDsABUAwCEAAG2qAggAihyAl5wS+EAIFaALBQD6I2Yd4ApF -APokBh2j+fUAKRUM/QAAFDAJtQAJiAKYEy8gBCocIfXgKlKSAJ0A+kngFeAMNQBYVQgqHCX6SYAV -4Aw1AFhVBBN/mygiFSMyiMOf6SQFLEZCgACoM8CQ6RQ5INEBAADpFDoh2QEAAPgnZh3gCFUA+CcG -HaAMhQBYVPYrPEj6IIAVoAw1AFhU8o4R6xwIKVAEgAD/DgAPMAy1AP4h5hWgDSUAWBQ2IyEZKyAM -HH6f+v7+BaAdlQAtJFIswi0tEoD7UQgVoBkFAOy7CADB/QAA7QAVDd5CgADrqggEQMUAAG2aAggA -iiqhLvVAE1RiAJ0AGH6JH36J/EAIFeDuFQAuFMgvFi7oFiwu7gKAAATdAi0WLSggBwgIQQCIEQio -AgeIAigWMA/qMC0WNSYWNP4mJhXgTgUALhVnLCBSLBThKyAFKxTiKiAw+jxmHaANFQAtFODsIhUg -yf0AAOwWOSTJRQAAjJSIkY+S7pIDINn9AADqkgUl2cUAAJq1nrOfsii2ASy2BCmSACm2APhACBXg -DIUA6RZCIPAHAADvIFIgwAcAAO+EDSFY0QAA6iAFIMgHAADq5BAg+AcAAOggMCDwBwAA7eQMINAH -AAD5IiYdoA4FAO70DiVQYQAAWFSd6yw8INAHAAD7RAAVoAyFAFhUmOssRiDQBwAA+0VAFaAMZQBY -VJTrLEwg0AcAAPtFoBWgDDUAWFSP6yxYINAHAAD7RoAVoAyFAFhUivgzRBXg0yEA8gYAA3BzUQDy -CAAC8INJAP4zZBXgw1kA/jEkHeGjHQD6ZgANMLM5AO27EQ5mQoAA64gRCq8CgADoVQILvoKAAOx3 -Ags3goAA+sYAC3DjKQD6QYgV4KoBAP1IABUwySkA51UCDmbCgADsqgIPH8KAAPOmAAn0u5kA66oC -AOgHAAAq1BT6TJAVoIlpAPZMsBXgmXEA6ogRDM5CgAD5BgAMcKoZAPYGAATwtzkA7rsRDM/CgADr -mQINV0KAAAqIAvkGAAxwdykA+OYAC7A4BQAIdwIn1BWPLAZVAgUzAvOi5h3g74EA/hEABnD/kQDq -zBEP/kKAAO/MAg92woAADswCBMwCLNQWgyeLOuSyY2HQgQAAKzIJZLJYKxx/+2YgFeAMhQBbO98U -ftUoIhUkQojpiBEJUASAAPiAAEIwi3UAW/4d2iBa15mKKcmgg6srCodb0AbqNAAJ/6YAAIop6yIL -JQIpgADOsPpBZhWgAMYAANog+i/gFeAMhQD7ZiAV4A0lAFsdYMAg0Q+Ju8iZ6ZILLNgEgABln/Sa -u5uswMD8QSYVoAoFAItKcrkLiimNKPyBRhXgAKoAybctsggPAgAPAgBy0Qzr1AAGgEmAAI3Yctny -yLcqIgkuIggutgj6QLAV4A8FAJ8o6yQwLQI2AACIK8+MxJP5YA2EYgCdABp+oIsgLqJz+1FoFaAM -BQD/bwANsA0VAFs3pRx9r4vOw9/tJAUl2/0AAPuBxhXgAgUA0Q/E4v5Aph2gAgUA0Q8AAGRLPPtf -2c1iAJ0A2kBa11coMRyKMyomH4kyKCUIKSYeLzAfZPF8wMPlLEwg0AcAAOtUAAVRFQAAWFPqGH9e -IzAfwZXoABUAwAcAAPkLABWmMwEAbZoCCACKH3+g7xZWINAHAAD6gAgV4A01AP1NZh3gDhUA/04G -HaP89QAsFbT9YAAVsAy1AAy7AisWVykgBCqscfUgBvqSAJ0A+kngFeAMNQBYU8/qHQEq2ASAAPtO -oBWgDDUAWFPK+iAgJeAPFQAvtIjzcaYd4A4FAO60iSpQBIAA/3FGHaAMtQD/cWYdoA0lAO60jiXZ -YQAAWBMIw4n4QKYdoAIFANEPAAAA+kkAFeAMNQBYU7YtEAAsEAHqEAIg2JUAACq0Auy0ASkYBIAA -/WAGHeAptQD4QKYd7+riANog+i/gFeAMhQD7ZiAV4A0lAFsc4GP9nAAafjyLICyic/tRaBWgDRUA -/W8ADbAMBQBbN0LAINEPw9/8QKYd4AIFANEP+kkAFeAMNQBYU5gvHQEu/EUo4AHp4AAn+dUAACn0 -ACj0AS7gAv/gRh2v/GoA2kD6QGgd4AwFAFgXhMAg0Q8AAGwQBIknKiAHiJqJmdMg8Q0QDeGqAQAf -fcVkkMYMqxGvuyyynveABgJSAJ0AK7KdEn3P5H0xFYWRgACMkfhg5BWnzAEAnJEsMAcaf/30YQQV -6ogBAP8AABQw7BEA9dAAFzHMAQDuiAIObAKAAA1VAgRVAgqIApiwjTD1YMYVoD4FAJ6zkrL1YIYV -4AIFAPNgphWgBUUA4rYHLu4CgAAF3QLttgEl0IEAAAkghgoCYwkAhgoCYYg3DMkR/yAARP/OBQDl -lp0kQIEAAA6OAeKGAidxAQAAnoD/ACYVoF0lAC00BdEPwCDRDwCLMsi6xMn8YKYdoAIFANEPK6wY -7DQACdAEgABbPOvEyfxgph2gAgUA0Q8AAGwQBoYrLyAEKiIJKPz7CGo48UYQDeAGBQBtCCyLp4m6 -/gAiHaAMBQDxIgAN4A0FAIm5iJKJkwSIDAjsOAWZDAntOH3IKIqryqtj/8yOYohj9c8ADzANFQD1 -DwAMcAwFAPmiAA4wCwUADts4fLDW0qDRDwAAAAAnIAcefsTy/YoF4XcBAAd3Ceh9pxu/AoAAo3OT -ECMyf6h3rn7+YAkEIgCdAG0IK4g4izf8ACIdoAoFAPECAA3gCQUAjbKIswTdDAWIDAjKOA3JOHqY -L4Mwc+F2Y//NAItijGP1bwANsAoVAPWPAA5wCQUA/UIADLAIBQALqDj5GoAd4AsFAI0xLzIAL9YA -LjIALeYBJjYAJjYBLCAEacQNAioC/BBCHeAMFQBYLZX4YwAVr8kFAAmIAeY2CCRBAQAAmDfoNgYh -0+EAAFszSsAg0Q+DEB5/eSMyfa5+fjkHYABlgzBz4WCIOIs3/AAiHaAKBQDxAnAN4AkFAI2yiLME -3QwFiAwIyjgNyTh6kNNo9Doef2v+YSQdoAIFANEPi2KMY/VvAA2wChUA9Y8ADnAJBQD9QgAMsAgF -AAuoOPkUIB3gCwUAY//FwCDRD9og/BBCHeAMFQBYLWocf1n8YSQdoAIFANEPbBASLSAEF39V5SAH -KvAEgAAZfmTrcr0qMASAAP2noAJRVQEA9aAHYpIAnQBo1gPAINEPii4skn+PLQmqEayq6KIHL/5C -gACvzCwWFozHiI4oFhSMzvwiphWgAKIAKCIVLJJ/7yIHLEZCgACozCwWFozHj/4vFhSMzuwWFSlQ -BIAAJCAFLDAT+AhCHaA55QD4gDFcZfwRAPiAMRwgKdUA+IAw3GBI5QD4gDCcIgCdAJsa9CEGFeCM -AQAoFhf1oAVDEAQFAJoX6xYGJn18gAD1oAayEgCdAOUWCCeE8YAA9eAHSJIAnQDVQPW/+hsSAJ0A -6hIXIvnZgABkrzOKJ9sw6qwgK2AEgABbOi31QsYd4AIFANEPjCciFhb9gcgVoAoFAPwiphWv/XIA -jTeMNp8bmxruFgkpUASAAFv/OtSg5RYIJSphgACLFvog6BWgBRUAKTATCSlFypibFvUgLHiSAJ0A -LSAEY/9/7hYJKSAEgAD//3ANoAUFAJ4Z9AACHeAEBQAtQAX9t2AVoB8VAP+ADKriAJ0AGH7yCMgK -iIDrFgYsACKAAAAAAOUWCCf+YYAAmxb5//mA0gCdAI1HmxqeGeUWCC6AvgAAY/5jmxaNR5sanhnl -Fggm8sGAAPQAAh3gBAUAidrklqdm0IEAAIvZjBkMDEfowiVtuASAAI2xjBb84AAG8AsFAFs2RY1H -jtpk5y2L2fdgaB3gAB4AAJMaiBj9AGgd4A6FAPUAM2IQCkUA6HyCHH8CgACo/ynyntugB+s5+yBC -i+IAnQAp8p1kloEpFhHqFg0jhImAAB9+vSxBBytABx176PKBBBXqzAEA+iAABHC7EQDquxAMRAKA -AOgzAg5nAoAAC8wCGHx8DTMCD8wCnJCMQP0gxhXgDwUAn5WTlPkgRhWgOwUA65YDLmYCgAAKzAKc -kStyARx+qgsLR+y7Agv4BIAA63YBJJiBAAAPIIYDAmMPAIYDAmHqFg0k6QEAAC0WEYpHixrqrCAr -YASAAFs5sSwSEY0d5qYBLRgEgAD6gGgdoAuFAOe9OQnYBIAAWCP22kBa1WraQFsyZGP+PADJoS8S -FCzwOJsW6xIGJmAFAAAs9DgvEhadHusWBieAeYAAKRIVKJBcsYgolFwcfoUvQTeOQI0g+CHIFeAK -JQD4IAYV4DslAFhVuo1Hi9rktNhm0IEAAIvZjLAMjFf8ImYVoD5FAP+ALdQiAJ0ALwoA/iIGFeAN -pQAqQQj6gtAV4/z1AP1PAA0wCWUA+yIADrD49QB4sSMsEgkqQEH8IYYV58wBAP2fwBWgDRUADNw5 -WxZl7RIMJTYhgACPGN7w9eAjghIAnQAYfBQM/xGo/yjynv0ANKviAJ0AKfKdZJM4GnvqG3wd6gAF -DOAEgACeH50cKRYSDAJhDAJhDAJhDAJhDAJhDAJhHH1BL0EHLkBB6HwQHNAEgAD4hEQV6v8BAO7t -CQ//AoAA6P8CDu8CgACtzP2P6BWgDQUAnRSfoPiACBWm/AEA+0BGFeK8QQD9QUQd4E3FAO2mAy3e -AoAAC/8C/AcABb3JHQDkzBEN3UKAAP1mAA2wPMUALKULC/8C634yH3QCgAAP7gLvfjAczQKAAAuZ -Aht+LimmBu/uAgxGAoAA/0CGFaAMxQD7QOYV4AllAOmIAgJZIQAA6KYBJVCBAABYUZQpEhIqQSr7 -JaYdqKodACqULChAV/qLgBXgHIUA+SdmHaiIHQD5J0YdqIgdAPknJh2oiB0A6JQ4JNDxAABYUYUr -QHTEwv1gHiwiAJ0ALxIS/PweBe+OFQD/54YdoAgFACj2FOj1JSDYQQAA+eiGHaAMNQDtFgQn0RUA -AFhRdSoSEilAdOmkWCpQBIAAWtTTG30KjE0rsn8JzBGsu4u6ybUrvFz6IoAVoAxFAFhRafogqBXg -ACoAABt8cZsVHXyELDroDLwsDcwo7BYFKlAEgABa1MKLFRx7tO19FhpQBIAAWtTe2kBa1MEtQQgu -Ov//oAj8IgCdAC8SE8OE+eAIZCIAnQCKR4mqZJL7i6kffeEeewuKsCiwEo2xLBIS+e0ADzeqwQD6 -ImYVp90BAA7dAu22ASZhgQAA7RIMKlAEgABYIzEpEhMlFhn2I0YVoDolAPsgC5QiAJ0AKxITJRYZ -9iNGFaA8VQD9YArkIgCdAI5HJRIZJhIa+8QAFa/NBQD9QAQG8A8FAO/mCibpAQAA7eYJKdgEgADt -5ggrYASAAFs4zGP6044b0w8PAgBk40n1wBwgkgCdAOoSBynYBIAA/MBoHaAdZQBYK7otIAT/6LgN -oAUFANxg+mBoHeCNRQBYK7Qcfa2OMo8ziSCZEPhAsBWgCiUA+CAmFaA7JQBYVNzAINEPjUdl2vBj -+TkqEhBlrvGOHx97T+0SDC93AoAAr+4t5p0rIBYlFhn2I0YVoPz1AP1/+cwiAJ0AKkBB+oLQFeA8 -xQBbFXolFhn2I0YVr/yCAAAAj0Jk8yUoQQgpOv/5ABJMYgCdACoSE8O0+0ARtGIAnQCJR4ya5MJi -ZNCBAACLmYex/CDIFad3AQD84Ggd4AsFAFs06IpH2zDqrCArYASAAFs4i4xAi0cIzBEMbALspgEl -0IEAAOsSBivgBIAAWziEY/mxLUEUJUESwGDtFhgm9OGAAOpyQirYBIAA/AACHaANFQBbNH0ockMu -EhjmbAEiqAUAAAhVLn5p2GP+bQAAyKkrEhQpsECxmSm0QCsSFsi5LRIVLNBkscws1GSNQuoWByaA -sYAA2tBYO2TrpAAKUASAAFs2AIoXxNrtRAUlAHmAAC8SFC7wQbHuLvRBLxIWZPsvKRIVKJBlsYj5 -LKYdr+ySAP/sqA2gCwUAHHpmjMj3gBK4kgCdABh69QzvEaj/KPKe/QATU+IAnQAp8p1kkmEbelyw -yvthBhWv7e4AAAAAAAD/5WwNoAsFAAAcelWMyJod94ASYJIAnQAYeuUM3xGo/yjyntmgB+k5+QAS -0+IAnQAp8p1kklEdekqwy/uhBhXv5f4AjkJk4aKNR+RwimbQgQAA6xIKK2AEgABbNyJj+HH/9AgN -oAsFACgSEi+ASLH//wkGHe/wzgDIqSkSFCiQOrGIKJQ6KRIWZJpUKxIVKrBesar7a8Ydr+kmAADE -u/qAph3v6PoAxMr8gKYdr+jSAP/jQA2gCwUAAI2xjBb84AAG8AsFAFs0cuoWEC0DpgAA/+joDaAN -ZQD6IUgV784FAP9ABAcwDwUA79YKJ3EBAACe2e7WCCtgBIAAWzgMY/fRLxIQZf3HiUf7JAAVr8gF -APlABAQwCwUA65YKJEEBAADolgkrYASAAOiWCCnYBIAAWzf+Y/ebAAD/9oANoAsFAPwBQh3gSaUA -+ECmHe/nCgAAAI8zjjL8+c4FoApVAPxACBXgOyUAWFQYihfIqSwSFCvAObG7K8Q5LBIWZMyRLhIV -LeBdsd39y6Yd7/IaAAAAHHzajjKPM4ogmhCJN5kT+GDIFaA7JQD4IEYVoApVAFhUBosXyLktEhQs -0EOxzCzUQy0SFmTcSC8SFS7wZ7Hu/+zmHa/w9gAAAIsY2kDrvBgqYASAAFs50mP8x4sY2kDrvBgq -YASAAFs5zmP+SgAAAP/luA2gCQUA/97IDaAJBQCMQmXMnStAQdpA67wSKmAEgABbOcNj/IqfH/wh -hhXgCgUAWFREHHnKjMiNHI4f+Z/smJIAnQD/5KANoAkFAMCQGHnEwPoPzzT/AQYV7+RaAPgh5hWg -CgUAWFQ2HHm9jMiKHY0f+Z/tAJAOhQD/3PgNoAkFAAAAwJAfebbA2g3NNP3hBhXv3KoAbBAI6iAH -KjAEgADlMgAqoASAACggBPTgAALxqgEA6hYEIrmtAAD1ABNaFHcdACsgFigK/3ixGPpIMBWnxAEA -/Z/AFaAJFQAMnDlbFH5koveNFBl6MJ0V7NgRBqSBAACpiCaCnvbAFsPiAJ0AJIKdz0eJImSSj8Ag -0Q8AGnmTiaj3IBc4kgCdAIgVG3oiDIgRq4grgp73YBdr4gCdACSCnWRC5LCbm6hkT8YceffsAAUK -QASAAG15AggCYdog+mBoHeAMJQBbBnYmIQcYeiEGBkoMZhEIZgKWQI0g73oeEvExAACeQ+9GAi7u -AoAADX0CnUEpIEEqISIYe0QJnAnrIAUuZwKAAKyI+Q/oFaBdBQD9YoYN4EzlAP1hhg2gXWUA/WAR -7WIAnQAK3hT4wAAGMthBAOl8RhzcAoAA6UYHLu4CgAD9hgAOcNg5AOTuEQ7tQoAADt0CDcwCDLsC -6nw7HWUCgADtfEASsPEAACZFCwq6Ag3MApxG+oCGFaAMBQDsRQohQSEAAOgHHgJ4gQAADwJj+kVE -FeAOBQAuRDEuRDL+hmYdoA0FAC1ENS1ENi1ENyxELvyF5h2gCgUAKkQw+oWmHeAJBQD4hoYd6Lsd -ACtELCggV/qHgBWgDEUA+IdmHaiIHQD4h0YdqIgdAPiHJh2oiB0A6EQ4IVlxAABYT4XmFgEhQYEA -AOgmAAJJAQAACQSKCACICQCKLiIc6kxUIdjBAAD+imYdqO4dAP6KRh2o7h0A/oomHajuHQDuRFAq -4ASAAFhPc6VJKCB0KJRYhhUYebAMZhGoZidmnSsgFi8K/3+xByogQYwRWxPhxKgqJAUoMBJkjf0b -ea4cebsdex3riygJUASAAFrS5NogWtLHwCDRD5MS6iQACNgEgADtMQgp4ASAAOYWAypwBIAAWyFM -LQqIfaFvihBkrbiKp4sS7BIDJVCBAABbNvKMEI3AixMI3RENuwLrpgEtGASAAOokAAnYBIAAWyCG -3qDqEgAnAXmAANsw7BIDKmgEgABYKLvAINEPixTaIOu8GClgBIAAWzjhwCDRDwAAAAAAAADzQGgd -r/QqAIsS7BIDKVAEgABYKdDAINEPAAAAAAAAAP/0rA2gBAUAjCJlzSgrIEHaIOu8EilgBIAAWzjP -wCDRD8XC/ECmHa/3BgDAoFhTTxp41omo+T/oeJIAnQD/9JgNoAQFAADAQMDaDZ00/UEGFe/0WgAA -AABsEA4deNQbebQt0iMrsoii3ex7rx7uQoAArbKNIC4gOCogB5oQKSBA6RYBKfgEgAD4SDAVoDsF -APggRhWgClUAWFLVF3i/Fni/FXi/HHjQHXko6ni+EYCxgAD0YAbgkgCdAPRgDWkSAJ0A0Q8femKO -KisiEg/uAe4mCiWAwYAA+kBoHaALBQBbm+0ceMAaeK8deRgbeLAZeZAooH0rsi0pkoguIDjtAAUN -3kKAAOuZCAR8QIAAKgqA+yAARTAAKgAAKiqAqpopHBAJAmEJAmEJAmEJAmEtoS580Y6IIJUa9iCG -FeAJRQDmFgYsRgKAAAmJApkVL6AHDw9BAP8RD90CBd0CnRgM6jCYHx95cfwhJhWgCSUA+CGmFeAL -BQD6IWYV4AxFAP/GAA9wDSUA7hYMINhBAABbGArRDx55zosqKSIS/2YADbAEFQDrJgokgMGAAOok -AApYBIAAW5u4HHiLGnh7HXjjG3h7GXlbL6B9K7ItKZKILiA47QAFDd5CgADrmQgH/DyAACoKgPsg -AEUwACYAKiqAqpopHBAJAmEJAmEJAmEJAmEtoS79v/XkIgCdAI8glRr2IIYV4AhFAOYWBi/+AoAA -CPgCmBUsoAcMDEEAzBEM3AIFzAKcGAvqMAT/AvohJhXgCCUAmB348nIFoAkFAJkb7xYPINhBAAD5 -xgAMMAxFAPghhhWgDSUAWxfU0Q+IKitAACskQCpAAiokQSlAASkkB/Ef8fiSAJ0A+kBoHaALJQBb -m4HRD2wQBvyGoADQChUA/IIgAVALRQD0gAUJkAY1AGhEZdEPZFD5aVH36jQIIVkBAAD6YgAVoAyF -AFhOgtEPABl4P/rwbAWgDFUA7DQIIVgLAAArsEQqojMpkoCrqgmqEaqZKJA18QwgDeAKBQAtkEnx -q3AN4A8VACiQXQj6OQmuES40CdEPACs0CCU0CwVZCfMgAISw2uUAqpkskQIqkQEpkQAMDE/8YYYd -oapBAPphph2vmQEAKTUH0Q8mNAgoIGr7AAQG8AyFAP0ABAcx+I0A++AEB/CojQAMqgH/2AAXMAwl -AOyJAQ7vQoAADt0C/0YADXLojQDs7gEMzsKAAPgAAAYwiDkA6O4CDmZCgAAJzAIOqgINqgIMqgIq -NAnRD8CQKTQIiC+YM9EPCasRKzQJ0Q9sEAwYd/kWeRwpgjMogjEmYoGimeKICAzOQoAAqWkpkgfi -Fg8sRkKAAKhm6ZIOIhHJgAAcebgrCgD9kBAVoApFAG2qDgCwBAwOG3/nA7G/nxyxuygagKiYmB0o -gOWZFZMW8R4QDeAHBQAYeawaea2FH/LzUgWgDBUA8iFmFaALBQDierkS6/0AAO3LOArPgoAAqpmZ -GOsWByqswoAA+KAAQrALBQCbGpUZ9eACHeAB6gAAsbsPHxRl//cceqwrFBICqQH8IegV74sBAJge -/CImHef+QQDmjggMzgKAAAn/AingVCkUE//JkBWgClUA/iIGHaAbhQDoFgAqcASAAFhRyxp5i/qA -BmQiAJ0AG3mKe0FejB0swOXjPAYjuAUAAPzgCRqiAJ0AJDEAKjEBLjECLmRmJGU0/uAAB7HaQQDt -ZGcnhFGAACsKAG0IDX9QDQ+PFOT/ZGXYIQAAY//rx4D/H/qOYgCdALS7//0cDaT/HQCJHNMPaJJu -jBsvEBEuEBItYCL4IhAVoApFAPggBhWgOyUAWFGmKmAiKRARG3ljCqwJ7RAQLmcCgAD9YABFsA4V -AC60fS20fim0fCwQEiy0f1vCamP/SgAAAAAA//uoDaALBQCKH/wiABWgCyUAW/6tY/8tAAAAjR9k -0HGIFx95TY4aCP45nhqLHukSCi3fgoAA+2AEANAKFQAAqhqqmYoY+AACHaALBQD5WGYV4AqFAG2q -F/sABADTqQEA4KoaBEAJAAD7YABFtJkdAIwZ+5FmFe/82gCOFS7tAS3hofIgyBWgD0UAD90CLeWh -0Q/A8P4hRhXv/lIAwCDRD2wQEBZ3Xhp3fiZiMSuigSqig6Jm6ycICzZCgACmpuhiHSu+QoAAp6eH -dymBAyiBAudyDimoBIAA+QAIjGIAnQAYehETd0scei8dd0ged0eeEJ0SnBmTFggoApgY9KAI6JAP -NQD0oAehEAoVAPSgCiGSAJ0A9KANQhIAnQAqYh0nFhT0ImYVoAsFAFsxSed3SR0gBIAA5RYSLRAE -gAD47m4FoAEuAACLmcLIWy9tZaHK6lQACNgEgAD8AIIdoA0lAFsWsfygCBXgCkUA/PQeBaAbhQBY -UTvqYh0hWAUAAFsxNBh3JupBZX0QBIAAFXdFKIItDwIAJVKDoogJiBGoVShRLneB0OpiHilYBIAA -WzjK/1wgDeAPRQCOUAjuEQ/uAp4RLVAHLFEuDQ1B6VIHLuwCgAANzAIDzAKcFIua5b9lZNCBAAD/ -/XwNoAsFAMCk/PPeBaAbhQBYURrRD2RBC/if+MjSAJ0A6hQoI9kBAAD6JgAVoAyFAFhNS2P+/sCV -6RQoI8ALAAAogESriAmIEaiqL6A18eEQDeAJBQAroEnIti2gXcDBDck5CZ4R/iUmHa/7MgAvFCgo -cGrAuPsABAbwCUUA+QAEBnHojQD5wAQHcKiNAP+4ABawCSUA66oBDmdCgAD9hgAOcLgBAP9GAA0y -2I0A6d0BDd5CgAD5AAQE8Ig5AOjdAgzOwoAACbsCDaoCDKoCC6oC+iUmHa/5ggAkFCv0gACGsA5F -AC4UKPegAIbw3uUArt0o0QLv0QEg8QEAAC/lASjlAi3RAC3lACsRICoRISwRIiwULPoi5B3hqkEA -+iWmHa/4VgDAgCgUKI9//iFmFe/4GgAAKaAoyp5okTxok0mOV4/r/8QAFa/JBQAJ6QGp+emqRXVZ -AQAA+8BoHaAshQBbLu5krgJj/8ovEhJp8skoEhNlj8NgACgAKxISabK8LBITacG2YAAYAC0SEmnT -r2AADgAAAAAAAAD/bwAN//7uACwSEi0SE+oSFCVYgQAAW/5bY/3ZbBAO53cCGcgEgADyIMYV4BsF -APogBhXhhAUA5CQICbAEgADyYUgV4DgFAPggRhWgCiUA6hYBJPihAADvFggk8FEAAP4hJhWgCjUA -mh/jFgchQAsAAOKARCiYBIAALGA1LWIQnBosYDGF1I7Qj9KJ0YjTi9abG4vViteaHiqwApgdmRz8 -xgYdoJoxAPjGxh3gCJUAeMsRGHlfCMgKiICbFewSCiwAIoAAKWA3LGA1ZJCv8YrADeAJFQCIHoob -KWQxldSb1Z7Qn9Ka1oocmtGKGpjXiB3o1gMlBWmAAGTAqIsf4zwEI7gRAADrvP8jMFEAAOsWDy37 -RgAAwCDRDyhgMvzHMBXgDAUA6xYFJBsRgACfFC4WEIsdKmA6LGQ1KWA4LWQyjDD4AAAE8KoBAOqq -EQzOQoAACpkCKVQCihtYTJouEhCKF48UixWKoSxgNfzCCBXgCAUA6GQ3JVAFAAAqZDQoYDLpEgYk -EWGAACmQI+oSBiSWCYAAKqAi80vgDeAJNQBj/zNkz1aLFowZ+sAUJGIAnQD8wBNkIgCdAI0Y/N/5 -7WIAnQAuQOT33/mQkAUFANog9OAABnALRQBb/tIvQOSxVX9S6mP/FSlQAogemBzxIA5GEgCdAPFA -DgYSAJ0AmxXxIBT+UgCdAJsVLhYQ80AUllIAnQCbFf4ghhXgCbUAKWQx+AAiHeC6KQD484gVoAwF -AAucOOsSDilQBIAAC4AAixUpsALA4fgFAATwCAUACeg4KGQzKFACjxT8G+Id4AwFAP0ABAbwiCkA -COw47GQ1LXAEgADtVAIuDO4AAIoXiqHsYDUlUAUAAPrGhh2gBiYAKWA3Y/40+MbwFeAMFQAsZDX/ -+JgNoAwVACxQASqwAYgXDKo0+qAGHaAJBQApZDWIgSlgN+xgNSRABQAA+MaGHa/37gAocpzqJAAP -2ASAAPoghhXgDAUAC4AAwNAtZDUtZDMpUAKPFPogqBXgLAUADJkC6VQCLXAEgAD4xvAV4AwFAPzC -CBXv9tYAAChynOokAA/YBIAA+iCGFeAMBQALgAD8IOgV4A4FAC5kNS5kM43Rsd0tZDQpUAKPFPog -qBXgLAUADJkCKVQCLGA16WA3LXAEgAD8wggV7/WOAChynOokAA/YBIAA+iCGFeAMFQALgADA0S1k -MylQAo8U+iCoFeDc9QAMmQEpVAIsYDXpYDctcASAAPzCCBXv9IoAAAAAAP/0hA2gCSUAmxX+IIYV -4A7FAC5kMShynOokAA/YBIAA+iCGFeAMBQALgAD+IIgV4AwFACxkMy5QAvogqBXgDRUA/AACHaDZ -9QD5wAQE8O4pAA7cOOxkNS1wBIAA6VQCJgdBgAApYDf8wggV7/K+AADaIPoAYh3gDAUAW/49Y/zK -2iD6AEId4AwFAFv+Odog+gBCHeAMFQBb/jZj/K0AAAD/8gQNoAl1AChgO2SAkShQASmwASpQAAiZ -NHmhB//xkA2gCVUAKLAAwJj7DwAMMAplAPlNAAy/8T4AmxWfFP4iBhWgCRUA/SIADn/ySgAAAAAu -FhCLHihyoJ8UihQLgAAuEhCPFPogqBXgCZUA/SBoHaANpQAK3DksZDF5wUP1gASMkgCdAMCLeMEw -9Z/3NRIAnQD8xrAVr/y2AAAAAAAA/++EDaAJRQCJF4mR7GA1JMgFAAD4xoYd7/wyACqwAmP9DShy -nNog+iCIFeAMBQALgADA4C5kMylQAo8U+iCoFeAtBQD9JgAO8MkpACxkNe1UAi1wBIAA8z/2TpIA -nQCIF4iB7GA1JEAFAAD4xoYdr/rWAIsVK7AC+POIFaAJFQD6BQAF8AwFAAucOOsSBClQBIAAC4AA -ixUpsALA4fgFAATwCAUACeg4KGQzKFACjxT8G+Id4AwFAP0ABAbwiCkACOw47GQ1LXAEgADtVAIu -cq4AAIoXiqHsYDUlUAUAAPrGhh2v+QYAAGwQCht1OPzqXgXh2oUAqiouoGwt0jOTFSuygK7d6hYI -Lu5CgAANuwj6ISYV4AgFAPlsZh2gBgUA+WnmHaAMFQDotDspqASAAP1kRh2gAwUA6KRyLDgEgADa -EPqgaB3gDCUAWEtiKhEACplG4JAECAQKgAD1IAUIkgCdAGuVOeCRBASU24AAwMHgzBoMggqAAPOG -AAnws50A/2LgB9czAQAoIovnxwIEQAUAAPhRZhWndwEAYAAJAAAoIoyxiCgmjAoISKaG6IwCIzAJ -AAD4oABCv2YBAPTf+/uiAJ0AhRXjFgEheOEAAO8WBCFxmQAA/iBmFaANBQDtFgchMEEAAPYgxhWg -qGUA+EAARDAGBQD4IEYVoAFqAAD7IAQA0LOdAPNgGyfQCBUAAIgaCDMC//44DaczAQAAAPUgCwiS -AJ0AaJJa9SAFOZIAnQD1IAdKEgCdAKY26DwCIzAJAAD4oABCv2YBAPTAC6KiAJ0A2hD6oGgd4Awl -AFhLHSMRAAOZRv77QA3oMwEAb5WsAJAEBwgbf4ejsjn4oABC//8uAIwZwLH7h2Yd4BpFAPNUtg3g -DAUAbTkRpc6izS3QOC7gAu3pDXZgBQAAY/+IAAAAAAAA/6DWDa/89QDAwWTPdYoU7DQAAtgJAABY -SwFj/2UAjxnA4S70T/R/+tPQDAUAbTkRpc6izS3QZi7gAu3pCnZgBQAAY/89AAAA/6DWDa/89QDA -wWTPLYoT7DQAAtgJAABYSu9j/x0AAAD+f4AV4AhlAAj/LPohKBWgCIUACP82iBjAkSmkY/8Rph3g -PkUA89/3k+AMBQBtORGlzqLNLdCmLuAC7ekKdmAFAABj/tUAAAD/oNYNr/z1AMDBZM7FihLsNAAC -2AkAAFhK1WP+tYoWL1ACLyQM7lADItgRAAD+QaYdoAyFAFhKzY0ZiySKIogXwJH7TwANcAwFAP2k -Rh2niAEACpg5+CDmFa/56gCOF2ThSogYwPH/DkYd4A4VAIoZKaA1wDDqogokiVGAAIsZK7BJZLEd -jRkt0F3AwQ3DOe2iASmgBIAAjxkroAAnoAGF+yzxEinwISZQASn0IO/wIiSMsQAA9SAJuRIAnQD1 -IAqJkgCdAPUgC0oSAJ0A9SAM2pIAnQD1IAv7EgCdAHzZAmRBbGTg2WTw7sCjixnqtCEpUASAAFv9 -s4gZKIA18QeADeAOBQCJGSmQSWSQa4oZKqBdZKBj8GYwDeAOFQCLGCuwc/VgBRCSAJ0AghmMEfJD -SBWgHeUAfck2iCDPgYkZKZIViZDKmIoZKqIQiqDJr4oYiyebIftNkBWgDBUAW/w/jBj6QAYVoAsV -ACvEb9EPAI4YwNEt5G/RD2Q/oI0Y/O4uBaAKVQD9rZAV4CtFAFhOPooYwLH7TZAVoAwFAFv8ymP/ -ecBA/UAoFe/7ugCMGP4AAh2gCwUA+45GHe/6zgAA//ycDaAKFQCOGMDQ/c5mHe/9agAAAAAA9sCA -BHAPVQD5bwAMMApFAPniAA0/+/4AiaGIGLGZ+UAmFeAJFQD5DmYd7/tuAAAAKiKKsaoqJorRD8CR -maGJGcCAmKIolRIooAH5QAYdoAgVAPkkZh2v+r4AJ6ABJlABiRgHaDT5QAYdoAgVAPkuZh2v+lIA -AAAA//pcDaAKJQCFUYgY9UBGFeAJFQD5DmYd7/nWAIgZkhryoEgVoAkVACmEI4mihVEihRKCGnWZ -0ogZwKAqhCP9v/KNIgCdAGP+RgAAAGwQCB9z8fbn0AXhzgUA/kAARzGWhQCmJuhgrCrYBIAA9uZo -FeGlBQClJS/ygPjgAEOx6QUA6SkIC75CgACn//njRhXgHFUA9eIGFeANJQD/4qYVoAiVAOr8MCfx -EQAA6LE3d7lhAAD9Z4AE0Ai1APlgCkwiAJ0A/WUghVAZlQB0kyHuRB5iU/0AAMG6+2r2DaAMNQAM -qixgAE6aEPyAELQiAJ0A0Q8AmhB8SfckGiOkJOs0AApQBIAAWEoFGXai8iAIFeE4hQD4QABEMQrl -APpAAEUwCxUAKzQNlFGaUvigZhWgAUoAAMCo+tmmHaFlxQDlJQgJ2ASAAOxEAArQBIAAWEnz+O0i -BeGIVQD4QABEMAolAPrhph2gCwUA+uHmHeFaNQCqKiVmEypmFOhmFSuYBIAALDAMmRInMA8qMA2F -NCgwDpgUlRaaFZcThFD6oEgV4d8FAPagKBXgDWUA9KBoFeAKBQBt2hqirq/uLeCCLuB8DwIADwIA -feMX7tMEdVAFAADxgUwN4AoFAGAAegAAAAAA8YcgDeAKFQBowXT1gAWxEgCdAI8WlPCX8ZvylfMs -NAzRDwAAAAAAAPif9yFSAJ0ALDAB+mAQFeFJ1QD4QABE8VgVAPhAAEQxSvUAqiorpAD9QCYdoLs5 -ACv0Uy30USomcSgmc+kmci8YBIAA+OymBe/8wgAAAMDB/GGGHaAMFQDlQW9+EASAAI0V1FD1oAmB -EgCdAJsR9aAJ8JIAnQCIEupgrCpYBIAAC4AAiTT6ICgVoAsVACs0BZWTmpKXkZSQIjQM0Q/SwPaA -BoRiAJ0AjBXUcPWACLESAJ0A6xYBLg78AACOFGTgx+sWASv9lgAAYAC8jxXTDw8CAGjybPngBFjS -AJ0AiRQPAgBkkH5kcHv04GgdoAIlAPogJhXv/goAAAAkGiPkJAgJ2ASAAOcwACpQBIAAWEmBGXYe -8iAIFeE4hQD4QABEMQrlAPpAAEUwtzkA+mHmHeAMJQAsNA2UUZpS+KBmFa/46gCJFMmcjBP/mcAN -4AkFAI0T9aAEoJIAnQCbEfU/+LCSAJ0AjhaU4Jfhm+KV4yI0DNEPjxUPAgAPAgBo8ltp8eKJFMiR -ZX/b6xYBLaAEgAD/+4gNoAIVAIwU6xYBJnbBgACNE/+6jA3gCRUAY/84AI4U6xYBJ3YBgABlfyr6 -ICYV7/rWAI8UZP+9iBNogSDrFgEr9R4AAGP/rYkUZJ+ojBNowRNkf6Bj/3llr2xj/vdlr5Rj/9gA -AGWvjGP/5QAAbBAEJCA5/OvGBaAKVQD+QAgVoDsFAO8iAiloBIAAWE0EGXXdGnXehyD5IAgVp1UB -AOZzeBKUGQAAgzPqdwIEQAUAAOiWACpPAoAA9IAFqhIAnQCmmSuSntMP92AJ0VIAnQAtkp1k0M8a -c0jqAAUOyASAAAkCYQkCYRp1yRxzdhtzdJvQiSD9oEYVoBsFAJvT+uYADTAHJQDq1gQszgKAAAeZ -ApnRKCA4GXLWCIgRCYgCKNUKLzEG79ULIdiBAAD+YOQVoAxlAO7VDCbQaQAAWEkRDE0Rpt33s6YV -74wFAOw0EiKUdQAAiif6ACId4AwFAPtEABWgDRUAWyz/0qDRD8Ag0Q8bcrGKuPdABViSAJ0ADEkR -ppkskp73gAWpUgCdAC2SneTQrGVj/QAA/WEGFa/81gAAZd8vjSJl0GIrTBjqJAAJYASAAFsyk2lS -sYonwLD7RAAVoAwVAFswjh1zrZ2gjCAbdZDzQGYV4A0VAOumAi5mAoAA/YYADnA7BQDspgEp6ASA -APzrEAWgClUAWEyowCDRDwAA//skDaANBQD8QAgV4ApVAPzrAgWgOwUAWEyfwCDRDwDAoFhM/Bty -goq4+V/6WJIAnQD//ZwNoA0FAMDQwOoOrjT/YQYVr/1iAAAAAGwQBhtyi/QgRhWmGuUACjoIKbEC -+CBEHeAMZQD7YAgV4CilAOsWACEg6QAA6DYFKlgEgABYSL7AxvYiAAv2GoUA6joIC9gEgABYSLka -cnqMEv7k8gWlp4UA9mAAQ/AJhQD474Yd4A8FAC90fv7wJh2gDYUA/PAGHeAIFQAodH8sdIX676Yd -pirlAPpgAEU4vB0A+vCGHeAMZQD88EYdoAtFAOt0gypYBIAAWEih9vHmHaY9hQD6IYgV6IYdAPjx -xh2oiB0A+PGmHaiIHQDodIwtgLYAAPxgAEbwDAUAnND9oEQdoABKACpqOPpgAEUwDGUAWEiP2iD0 -8yYd4A0lAPUOAA5wCzUA/PMGHajMHQD88uYdqMwdAPzyxh2gDCUA6zQGKdgEgABbmLjAINEPAABs -EAQXcj0mcoaKbihKAG2KB4mgc5FlKqwQKmICK6ECZLCGWzOyjW7sqhENYASAAKra7KUCJQOhgADj -pgAqWASAAPtBQBWgDGUAWEhtGnIjG3IgKqItKXKAJnKG67B9LVZCgACqmYpj6KECJfxYgAAnkieH -fvbh6BXgAEIAzqlj/5cnkqeHfod/yY1bM5iIb6erCqYKCGYL+sDEHeAJBQCZYOlmASsARgAA0Q8A -AJJmk2LlZQcqWASAAOkgOCNQgQAA+MJmHeAMZQBYSE36QGgdoAwlAPvwQh3gDSUA62QSK1gEgABb -/wHuYQYraASAAP7A5BXgClUA/OnSBaA7BQBYTAfRD2wQBCIid8BB4yUMAQBhgADAIAVCONEPAMAg -0Q9sEAgkMiAlQCgpQCnoQEIqrgKAAAlVAvSgAEKwCgUA9KMAFe/+9QD5AA1hUA8VACgKBG2KSKSs -o6srsJAswEbrwTl1UAUAAOvDBn9QBIAA2vBloYKLICxARPtnQBXgCgUAbckTq62krCzAXi3QALGq -/aALLSIAnQBgAAoA0w9j/9IAAAAAABx0vvxACBXgClUA9K8ADz7P5QD/wABHcDsFAFhL1vqKQBXg -msUA+mAARTAMRQBYSAr66WYFoTslAPqAAEJwn0UA9IAIYuCnhQCaEac3rz/+IKYV4JaFAPZgAEMw -qEUACDgI9iCGFeCpBQAJOQgpFgL4IAYVoDdlAPYgZhWgNjUAK0AAdrJ6e2of92WODeA8VQD64ATL -YgCdAIoT+oBAFeAMRQBYR+1gAISKFfqAQBXgDEUAWEfpYAB0fLlxjBEvMiKNIC5AAv4gxhWgClUA -/aAIFeA7BQBYS6eJFmiSEmmVTC4yImnjacD1/mRGFeABBgAoMiJpglnAlPhkRhXgAMYAarMmarQS -abYjihD6gEAV4AxFAFhH0WAAE4oU+oBAFeAMRQBYR81gAAMAaLESKkABsqqqRPSf+jviAJ0AYAAQ -AIoS+oBAFeAMRQBYR8Nj/9zRD33DAd7wZe/1Y/6hbBAEGXF0iDQSclQpkiPyUQgVo6iBAKqZCZkR -qSLzAAV6UgCdAIQn0w+ETipCNiVCNPdAB5iSAJ0A/Oi0BaAKVQD8hsgV4DsFAFhLcys8IPqjABWi -TOUAWEepKFA+KVA/GnRS/QAAFDALBQD5BgAMcPlFAPkABRtgvgUAwJRtmhctoIClvK7MLMB+K7wB -DwIA7NkUdVAFAADrTFAqUASAAFv/XsAg0Q8A/YDWDe/69QDAoWSv4vxACBXgClUA/Oh2BaA7BQBY -S1TAINEPAAAAAPzocAWgClUA/GFEFeA7BQDuIhMpeASAAFhLSyoiE/gAIh2gDwUA8UJgDeAJBQAu -oSEtMQoO3QwNqTjAoAmKOAqPOOmSOQ/4fgAAwCDRDwAA//+YDaAJBQD8QAgV4ApVAPzoQgWgOwUA -WEs3wCDRDwBsEAQiIhPIJiQhIXNJAdEPwCDRD2wQGhhy3gg5EfggBhXgGVUA6AAVAMAhAABtmgII -AIrkcxwQ0IUAAPQgRhWgDrUA/EAIFeP/9QD+IYQd4AUFAPQjZh3gBBUA5BQgLu4CgADu3QIBWSEA -APwgZhXgDDUAWEdSJRQ5JRQ6JRQ7KBACLBAB/CAQFeAONQDuFDggyJUAAO2UACDQ8QAA7JQBIVlB -AAD5IEYdoBwFAFhHQyocTPpIABXgDIUAWEdAKhxU+kcAFeAMhQBYRzwqHHz6TAAV4AyFAFhHORty -3Bxx4Bpy+xhx1CUUXCUUbCUUjCQVRPThvgWkHQUALRVB/CQkHeApBQApFDwpFD2JII0nKIKs+yYA -DLD19QDi0g4pUASAACUVQvyTphWgDVUA+JOGFeAMRQALgAAuQp0ZcuYacuj45cYFqO4dAH5YPx1y -uxJytStCphxzyCIifw27Aew8DA2eQoAA8kAAQXALFQD+QYgV4AMFAAyzOAOoOQn/AQj/Au8mDCkB -JgAA0Q8oIDopIDsIiBEJiAKxiPhHZh2oiB0AKCQ60Q8AAAAqLEz6IGgd4Aw1AFhHAescCClQBIAA -/AFiHaANJQBYBkf6QLAV4DoVAPpGBh3gSRUAA6k5KSQF0Q8AbBAG5iQAAgqpgADG7/pJABWgBQUA -6hYBIVlBAADrFgAhYQEAAOwWAiE44QAA8uc0Ba/81QD65zIF4AEyAGiVbWmaMS0wBCgwBe8wBi7u -AoAACN0C6DAHLu4CgAAP3QLrIgEO7gKAAPmmAA6z74UAD90sLWQ2LzABA/MKpfX0oAWKogCdACkw -APUgBMCSAJ0AaJJraZSm7iIBAcgRAADpJgALwASAAPiKaB2gAR4AKDAC+GBwFe/a9QAKIgHqEgAs -RgKAAOmIAgHYFQAA+MMEHaAMNQBYRsCNEetzcBH4IQAA/hBoHe/81QD8gmgd7+71ACowAQOjCqWl -dFOIYAAyihL8AMIdr/u1AOsiAQHYCQAAWEax+ubEBe/81QD//0QNr+71AAwiAS0wA/zGhh3v/R4A -yiAachSLYC6ic/tRaBWgDAUA/28ADbANFQBbKkXCtCtkBdEP0Q8AAAAA8uaeBa//UgBsEAoqICYW -chgKqAkMiBGoZuMgByNABwAAKID5+kLQFeD59QDyIAAB8AcFAOZifyQR6YAAebETBQxH/Z/AFaAI -FQAMjDlbCxdkorwVcMoMORH0YBDyEgCdAKWZLZKe96AU8tIAnQAkkp1kQjAacJ/qAAUKSASAAAkC -YQkCYQkCYQkCYQkCYRxwyxhwyf5A5BXmlgEA9gcABTK2QQDouxENVUKAAPtGAA16/wEA6pkCD/8C -gAAI/wKfQI4g+OJYBaA9xQD8gGYV4A9VAOxGAi92AoAAD+4CnkEecxkvICYnRhInRhEnRhCXT5dO -l02XTJdLl0qXSSdGCCdFCu3hAi/8AoAACf8CLuIACP8CGHCPn0T4gMYVoC/FAO9FCyDYQQAA7rYA -IlCBAAD9YEQd4AxlAFhGUCwgJhZx9htw0QzMCQzMEey7CAJQmQAA92AARbAMZQBYRkj65BIFoAsV -ACtEM/qFph2giZUA+IWGHeAYBQD4hcYdoA0lAC1EOPyHJh3gD0UA/oYmHeAOVQD+hqYdoA8FAP6G -Bh3gDgUALkQ0LCAmG3C3DMwJDMwR7LsIAlDpAAD3YABFsAxlAFhGLsDk/ogGHaANNQAtREEsICYb -cKycGAzMCQzMEey7CADQYQAA92AARbAMZQBYRiKIF48WAEQE+esAD7SfHQD4IMYV4FgFACgUGPgh -CBWgBlUA7xYHIlERAAD2I+Yd5/9BAOj/AgDYYQAA/iPGHeAMhQBYRhGLJww8EfWAAEZ/ygUA5sad -JdiBAAAKugHntgIlUQEAAJqwmrErIBYpCv95sQ76RNAVoCzFAFsKesAg0Q/AINEPAAAbb62KuPdA -BSCSAJ0ADDkRpZktkp73oAVy0gCdACSSnWRApbCsnLhlTc6NImTQShlxt44n+EAIFaAKRQCaEvgg -BhXvzwUA+8QAFaAJFQDvrwEMRgKAAAmIAugWASf5AQAAn+nv5ggo2ASAAPfBRhXgDBUAWy2DwCDR -Dys8GOokAAlgBIAAWy9/Y/+jAAD/9ZQNoAQFAIsiZb+UKyAm2iDrvBIpYASAAFsvd2P/gcCgWEn6 -G2+Airj5X/qQkgCdAP/9kA2gBAUAwEDAygysNP1hBhWv/VYAAAAAbBAI7CQACrAEgADpdAACBFGA -ABtydfLk6gWgCgUA9iBGFa/n9QD8ICYVr/W1APggBhXv/9UAbQgfKTAAKDAB6ooIBI0lAABokjVo -lCdolRZomggDgwp0qz1j/9kCuwHyIIYV7//CACb63wa7AfZgaB2v/4oAB7sB/GBoHa//XgAFuwH8 -YGgd7/8yAAAPuwH+YGgdr/8CAMiywCHRD4gRKIAmEnJUCIgJDIgRqCIiIn9kIbjzwHAV4AtlAPAA -MA2gDgUAAAAAgilkIaCPJ/YAAh3gBQUA/+HIFeAEBQD+IGYV4A8FAG26E63rouoqoEArsAKx7vtg -CaUiAJ0A/gACHaALhQDTD226E6zrouoqoDgrsASx7vtgCR0iAJ0A/gACHaALhQBtuhOm66LqKqBI -K7AIse77YAilIgCdAPoAAh2gCzUA0w9tuhOmrqKrK7BQLuAFsar7wAgdYgCdAC4gNA8CAA8CAHPh -AiMkNP7gAARwDgUA/xTsDeALZQAECUdln0MFCkfIrCosSPrBABXgDIUAWEVlBwtHybW1a/pKABWg -DDUAWEVgjRMs0RmxzCzVGY0ULdAD86AGB9IAnQCLFCqwBC2wBeywBi1WAoAADaoC67AHLVYCgAAM -qgLuIDYtVgKAAPtGAA1z64UAC6oseuEpixIqJDbxYAUvkgCdAI0TLNEY7hIAJmAFAAAs1RiNIP3A -BhXgAgUA0Q8AjhCNIP3ABhXgAgUA0Q8AAPtf9mPv//UA//sQDaAPFQD7X/br7/T1AP/7VA2gBBUA -+1/3Y+/19QD/+5ANoAUVAP9/9+uv9/UA//vUDaAHFQCCEMf//kAGFeACBQDRD9ogWsiMwJApJDaJ -EyiQNu4SACRABQAAKJQ2jSD9wAYV4AIFANEP2iBayIMuIDYbb2ccbtodcdLuuygJUASAAFrIndog -WsiAY/86bBAKKCAEKiBTJyAHHHCTCq0J5hYILu8CgAD9gABGcCuFAOzCfykgBIAA/ECwFeAGBQD1 -ABnYkXcBAPugGexgLlUA/6AZrCD/9QArIBacGf9j5g3gDQUABQxH/Z/AFaANFQAM3DlbCYvA0OwS -CSUa6YAAFW88DHkR9OAT+hIAnQClmS6SnvfAGbrSAJ0AI5KdZDKRGm8RGG9C6gAFCcgEgAAJAmEJ -AmEJAmEJAmEJAmEvIQcPD0ruIRkv/wKAAAj/Av5gBhXgSgUA+kAIFeKMQQDpbzQcRgKAAPhgRhXg -D1UA6jYDLd4CgAD/ZgAN9vwBAAj/ApsxKkAmLTUKnTidOZ06nTudPJ09nT6dP/xiBhXgOQUA/GIm -Fe2+HQD8YkYV4Iw5AO02EyxFQoAA6TULLd0CgAAIuwIPuwLvcIsdVAKAAAuqAutvhR91AoAAD+4C -njYLqgIqNgTkYiRh0IEAAPrIABXgDGUAWES+LEAmFnBkG28/DMwJDMwR7LsIAdCZAAD3YABFsAxl -AFhEth5wdxtucPpm5h3gCgUA+maGHaAYBQD4ZcYdoI+VAC80LP5lph2gDSUALTQ5/GcGHeAJFQAp -NDP4ZiYd4IwFAPxmxh2gDGUA/GamHaAJBQApNDAtQCYbbyMN3QkM3RGtu+a7CAHQ6QAAWESbwOP+ -aCYdoA1FAC00QCRAJhtvGgRMCQzMEey7CADQYQAA92AARbAMZQBYRJAoEgcvEgbyWGgdoAZlAA8C -APnrAA+0nx0A+CDGFeBYBQDoFBgh0REAAP4g5hXgCAUA+CPmHaf/QQDk/wIA2GEAAP4jxh3gDIUA -WER99mmGHaAPFQAvNE2NJxhxLo3e+GnmHaAOhQAuNE6P0I7RLNENL/w079YAJ3AFAADu1gEmYAUA -AP2hpB2gBAUADHsR9WAARfAKVQAqtp0rIBYpCv95sQr6SnAVoDwFAFsI3Ign+gUCHa/JBQDqJAUk -EIEAAAkiAeSGCiERAQAAkonzAQYVoAIFANEPABtuB4q490AHIJIAnQAMeRGlmS6SnvfAB7LSAJ0A -I5KdZDDtsK6euGU9bY8iZPB5HHARiCeLII4YnhL8IAYVr8kFAPsEABWgDBUA6akBDd4CgAAMuwLr -FgEkyQEAAJmJ+QEGFeAMFQDthgoo2ASAAFsr3sAg0Q/WIPRBCBWv8w4AwCDRDwAZcO/vkQIgwEEA -AC+FAvkgCBXgDGUA6YYALFgEgABYRDFj/cYrfBjqJAAJYASAAFstzv/90A2gDQUAAAAAAAAA//Mw -DaADBQAAAACKImWvWSsgU9og67wSKWAEgABbLcL//RgNoA0FAPwhJhWgCgUAWEhCG23JiriMGflf -+FCQDQUA//xwDaADBQDAMMDqDq40/2EGFa/8NgAAAAAAAAAAbBAa+N8KBa4JBQD4IAYV4AQFAPQg -JhWgGVUA6AAVAMAhAADTD22aAggAii0QAi8QASUQAOhvvhDwEQAAKuACLOABKBYCKCIAJBQbIxQ4 -JBQ5JBQ6JBQ7/8AQFaP79QD6IYQd4AlFAOkUICDYhQAALLQB+2BGHaAJtQDutAAsRgKAAOmIAgDw -lQAAJeQA7+QBINDxAAD9wEYd4BwFAOgWAyFZQQAAWEPnKhxM+kgAFeAMhQBYQ+QqHFT6RwAV4AyF -AFhD4CocfPpMABXgDIUAWEPd+NsuBeAoBQAoFDz4J6YdoF8VAH8xLykVICQUXCQUbCQUjI4o6xwI -KVAEgAD/wyQVoAy1AP5E5B2gDSUAWAMYwvsvJAXRDygQIMCSCYgC+CQGHa//HgBsEATAcG1KEaJ4 -o3QkQAAogADkiQpzuAUAAMAg0Q8AAPUBFg2v8vUAwCHRD9EPAABsECiHNB5tb/LebAWjd4EAB3cJ -5m2NG78CgAAHIgju4i0haAsAAC3QACpigycifw7dCP2oABawDBUA7aoIC9gEgABYPQckIoLlpAAC -A+GAACswTCwwTQi7Ef1mAA2wAgUAjErJy4rLyaBtCAktoTZ70QaKq8ijY//v0qDMKozJZc/izCOE -SWVP1xptb4gtJqKD621aHEZCgACoZo5nhGgpMFSO7o1HLhZDHnBHjd4tFkIdbzX1IAdQkAwFAGiS -EtEPAAAAAAAAAP/+9A2gAgUAAAArCsrrOwgDUaEAAPooBhWgDGUAWEOB6zw9I1EhAAD6KCYVoAw1 -AFhDfCwxL27PCh1wMv2gDoKiAJ0AwJcqMS4vMJj6DAAFsA4VAPvCAAzwqikA+80ADLCPOQD5wgAM -sP8ZAA/pOGSRuYtKdrksLhJDLeAyL+AzCN0RD90Csd39xmYd6N0dAC3kMi0SQizQObHM/acmHaAA -tgAAKBJDL4A0KYA1CP8RCf8Csf//BqYd6P8dAC+ENC8SQi7wOi7sAS70OgZqAlgLZgIqAlsjsNEP -iEp2iSEvEkMp8DYo8DcImREImQKxmfnm5h3omR0A+ebGHeAAhgAAKBJDL4A4KYA5CP8RCf8Csf// -ByYd6P8dAC+EOC8wWfXgC/qSAJ0AwIn54AdUIgCdACOigxhs8SlQDJwQnBGcEpwTnBScFZwWnBec -GJwZnBoogi2cG5wcqYjsFg0sRkKAAKgzLzEunB6cH/vgBKRiAJ0AKVAFwqP7IAQ8IgCdABls2xps -2YgwG2zamxaaEJkS/QAAFDAJRQAJiAKYESowBwoKQQCqEQr6AguqApoUCeowmRWcFyhQJhttnQiP -CQ6IAugWCC/3AoAArrutu/6ACBXgDjUAnhksFC2fGu1iACDQ6QAA/CGmFeAMZQBYQw3qNAAI2ASA -APwAgh2gDSUAWwxB2iBbI2TRDwAAAAAAAP/4yA2gCQUAKzBawsn9YBRUIgCdANogWyNc0Q8Zbace -bq8dbsCPYIxnGG2YG26eKxY/KIKsjM4N/wLsFj4rUASAAP/HxhXgDEUA+cfmFeANVQALgAAcbqEp -wj/5DgAM8P71AHngSysSPiqwOiywOwiqEQyqAiqsAftnZh2oqh0AKrQ6BmoCWAr0AioCWyM+BgAA -ANogWyM8i0r3f/rVIgCdAPrAaB2gC0UAW/7J0Q8AAAAabIUfbnYZbK4roqYpkoMPuwEJuxGrmRtu -mI2cGGyGC90BCN0C7ZYMJP1BgAAsEkApFkUeblEdbOgoUCYtFj0NAIcIiAntEj8sRwKAAKjuLuB/ -DQJhDQJhDQJhDQJhH25pHW5y6W1sH3UCgAD/xgAPcApFACrWPwl5AhpuYCkWPO7VgC5YBIAA+afG -FeAMZQBYQrQYbVEnEkUPAgAogo3rEj8q0ASAAPwAgh2gDVUAC4AAHG5eLcI/DY1HZNRT9aAihRIA -nQDuZT4mikmAAC8SQw8CANMPLvA8KPA9CO4RCO4Cse7/56YdqO4dAO70PCtQBIAAWAqsGGxeHWxx -HmxP/qGQFeAJBQApFgApFgEpFgKZE5kUmRWZFpkXmRiZGZkamRsu4i2ZHC3Sg6/u6RYNL3ZCgACu -3S/RLpkemR/54AT8IgCdAC5QBcKD+cAElCIAnQAebDUbbDaMcBhsMpgQmxaeEv2AABYwDkUADswC -nBEq0AcKCkEAqhEK+gILqgKaFAnqMPggphXgDAUAnBcvUCYYbysbbPYP/gno/wIPdwKAAK67nxge -bhWNQCwULfwhRhXgCjUAmhmuu+liACDQ6QAA+CGmFeAMZQBYQmXqdAAI2ASAAPwAgh2gDSUAWwuZ -2iBbIrzRDwDaIFsiuolKdpkS+sBoHaALRQBb/kjRDwAAAAAAAPrAaB2gWxUAW/5D0Q8abBcdbCoe -bAj+oZAV4AsFAJsQmxGbEpsTmxSbFZsWmxebGJsZmxqbGy7iLZscLdKDr+7rFg0vdkKAAK7dL9Eu -mx6bH/vgBTQiAJ0ALlAFwoP5wATMIgCdABxr7xpr74twHmvsnhCaFpwS/WAAFbAMRQAMuwKbESnQ -BwkJQQCZEQn5AgqZApkUD+ow/iCmFeAIBQCYFy1QJh5u5BtssA3cCe7dAg5nAoAArLudGBxtz/qA -CBWgDRUALRQtmhr9YABFsAw1ACwWCeliACDQ6QAA+CGmFeAMZQBYQh3qdAAI2ASAAPwAgh2gDSUA -WwtRL0A2yf/aQFrFeC5ANhtsXBxrzx1ux+67KApQBIAAWsWS2kBaxXUqfDT6bgAV4AyFAFhCCyp8 -PPptABXgDIUAWEIIKnxY+muAFeAMhQBYQgTsMhkj0ZEAAPzjBhWgm4UA0w/6YABF8BwFAFhB/Ss8 -QfrpgBWgDDUAWEH6jUoucAUudDB22RHAjPjqRh2gP2UA/uCmHeAASgAqCg766kYdoDl1ACl0BQd6 -AlgP1gIqAlsiSRttshxrpu1tshtQBIAAWsVqBmoCWsVMK0IKdrkVImIJZCAP+kBoHaBbFQBb/c+C -KWUv7+tujhtQBIAAW/pyHG1RLdoA7RYQIMEhAAD8AAoVoBlVAG2aAggAihttkysWEvooKBXgD7UA -/sAIFaP59QD4JYQd4AgFAPgrZh2gChUA6hRgL3YCgAD/xgAPcAw1AO4WEyDRhQAAWEHF+NjGBaBt -JQD8LwYd4A8FAC8UeS8Ueu8UeyDhAQAAKcAC+4AwFeAONQAuFH/ubWwQ0ZUAACukASmkAisSPyiC -rCzAAB9sXSykAIJnGm12iWCCLv/H5hXgDVUA+yYADLAMRQDp5j4rUASAAAuAABltWymSP/kOAAzw -+PUA+QAIKOIAnQAYa1EZbUISa3kogqYiIoMJiAHsbWUcRkKAAKgiiiwbbWYMqgELqgLqJgwpB6YA -AOtuURtQBIAAW/oswpwpZAXRDy7BgP8gAAcxWgUA/1/dKqIAnQAtEjwvEj0pEj8uFkQPAIcJAmEJ -AmEJAmEJAmEabToZbTIppj8tpj4sYGouYGgoYGwpYGkvYGvtYG0sRgKAAOiZEQ90AoAA6e4CD/wC -gAAI/wIP3QIOzAINzAMMzRQNzAMMbRT9lwAOcAsVAPygAAYwCgUAWEmwHm0jGGwP2aAp5kD5EagV -oAxFAPvIJhXgDVUA6xI/KtAEgAALgAAcbRotwj8uEkT/6+ANp91BAC4gOi8gOwjuEQ/uArHu/kdm -HajuHQD+R0Ydr/xSACosTPooABXgDDUAWEFZ6xxIKVAEgAD8AWIdoA0lAFgAn8P4/kCmHe/7pgAA -AABsEAYYbgp4UQbRDwAAAAAA6iQACdgEgADsRAAK6ASAAO5kAAj4BIAAW/t8Za/ajRD62WAFoCdF -APWgBeAQDBUAI6KGCdgRqDOON47uieXq4gQk6AUAAC3mBfmg8g3gKzUAKqwBmuQpIAUsNDf7MyYN -4CxlACowBXyhAnepi4439cHIFe/PBQDnNAUnaIEAAP+gBAbwDwUA7+YKJukBAACd6e3mCCnQBIAA -WsSIKFEShDqxiOhVEiIAiYAAwl0pQAV1kSWESWVP9PpAaB2gCwUA/AACHaANBQBb+n2LN4u+KrEO -saoqtQ7RD9pAWANohEllT8lj/9EAAPpAaB2gCwUA/AACHaANBQBb+nEabHkqoossoQJkzvFbLEYe -aycfar8cbHQdarUv8iIswoaL36r67gAFDVZCgADqyggF2AUAAOvWDyVwgQAADgJhDgJhDgJhDgJh -DgJhDgJhmhEoIBYZbHYsIQctIA3+QZAVoA8VAC+kBC6kDC8gBy2kDS4gJh1tpiylBw7rCe6kUy3f -AoAAq5kpkn8pphUvpAcupFOSqO2lFipgBIAA6KQWKdgEgABb+e4dbIssICYba2WDEQzMCeRqjR5n -AoAA7LsIAdFhAAD9YABF8AxlAFhA2opLLaECyNtbLBOOTAKvEa/uLjYYKiAmGWxRCqoJDKoRqpkq -koJkoGOJqciZ6ZIJLNAEgABln/STqSU1F/Zgph3gCwUAmznrNgoh7xmAAIw3jM6NxYrE5jUZJtgF -AAB9uxctwQ7rxgUlcAUAAO7GBCboBQAALcUO0Q8vwQ6bxerGBCf4BQAAL8UO0Q8A8zBGFe/+pgBs -EA6VE5MS+mAIFeAONQDuFgsqUASAAOoWBCnABIAAJoAY4yAHKaAEgAAngBP2IcYV57sBAPoh5hXh -MwEA825wDeB2EQB9Zw0oCsD4IAYVoAA6AAAAAIgfKIxMmBAljB8FRRQoIARrhgf5ABjyEgCdACsg -FiYK/w8CAHaxIoYTDwIA+kgwFadmAQD838AVoAgVAAyMOVsFG/tAU6gSAJ0A+NR0BaAPdQDvFgwj -lCGAAOlqyRGkyQAADDgRqYgqgp71QFIj4gCdACeCnWVwRooiZKXuixKMFO0SAylQBIAAWynI0qDR -D4mI9yBSgJIAnQAaarkMNxGqdytynvVgUwviAJ0AJ3Kd+uBSwBIAnQCwm5uIZH+4HGqM0w/sAAUL -wASAAG1ZAggCYSghBxlqufwhyBWqiAEA7RIALEcCgAAJiAKYcI4gH2qzn3LtdgMvdgKAAO5eAglQ -BIAA7nYBKlgEgABa9v8tISIpIAUYa9csQBiGLR5qLxpqDSsgQS7igyqiLeu/CQs2QoAArmaWGPbB -CBWgzAkA7BYJL/8CgACviC9gDIZnKIJ/Cv8IJmIO5hYNL/5CgAAP7gj+IOYVoFoFAHqRCy8KTn+R -BSkKUikkBflgABY26AEA+gACHeL4QQD64UQd4LoFAOp1Cy/+AoAAD+4C+AcAB72NHQDkiBEP/UKA -AAj/Ag/uAh9r8w7MAu1q7x71AoAAD+4C7nYGI9CBAADtzAIBWSEAAPzghhWgDGUAWEAoLCBBHWvO -G2qpDMwJDMwR7LsIA9CZAAD9YABF8AxlAFhAHxtr4f7TsgWgiZUA6XQsI9DxAAD+5uYdoI0FAPzm -xh3gGAUA+OXGHaAMFQD65aYd4A8lAO90MSFZcQAA/OZmHaAPBQD+5gYd4ByFAFhADCp8VOwSDyJY -wQAAWEAIwNL85qYd4A0FAC10NChAMPUAHSISAJ0AKBYQ9QA9WpIAnQDF4f8AHPQiAJ0Aix2MsIqx -LQq0rczstgAlUAUAAJqxGWo3DD8Rqf8l9p31ABoCkgCdACsgFi4K/36xcowf6iBBJmDxAABbBGXA -INEPAAAAAAAA//TcDaAFhQD0YAayEgCdABhqJww3Eah3LXKe9aBAi+IAnQAncp3nFgorhz4AAIoi -Za13KzwY6iQACWAEgABbKXxj/WaLEiuxCCw6/3yxDIsS7BIEKVAEgABYGmzAINEPAAAAjRLaIO4S -AyDYEQAA7dEILuAEgABbEcAtCoh9ocOMEWTP1orHixLsEgQlUIEAAFsnZowRjsCNFAjuEQ7dAp2h -KyAE5qQADSAEgAD1YDhaEgCdAOokAAtYBIAAWxD37BIBJRdhgADtEgMrWASAAOwSBC5QBIAAWBkq -wCDRDwAAAImI9yA7WJIAnQAaafAMNxGqdy9ynvXgO5viAJ0AJ3KdZHdqsJubiOcWCiP5CYAAHWnD -iBoNAIdtWQIIAmHaIOwSDipYBIAAWvZDLyEHF2nu+iFIFar/AQAM/xEH/wKfoIsgGWna7CEiLd4C -gAALWwKboS4gQSwWBh9rEe7tCQFhIQAA6KwgLu8CgADv3QgJvwKAAO8SDyIYwQAA6XcIBVDxAADp -IAUhWXEAAOTyJ290AoAALxIKFmnVJvYCJhIAJvYD/a/oFeBfBQB/kRAvCk5/kQomClb3IDRlIgCd -APggyBXibUEA/MAAEzb9AQAG/wL8BwADfdkdAOVmEQ7tAoAADWYCBv8CFmwEjRrv7wIMzQKAAAaZ -AhZr+ZnWGWv5Bv8Chh/5oOYV4AkFACnVCu/WBCMw8QAAJtULDACGCAJhJiEq96WmHaAPBQAv1DEv -1DIv1DP5peYd4AkFAPmmhh3gDwUAL9Q1L9Q2/6bmHehmHQD3pYYdoA8FAP+lxh3gDwUAL9QwJiBX -96dmHahmHQD3p0YdqGYdAPenJh2oZh0AJtQ4L7ABKbAAKaQAL6QBL7ADJrAC5qQCJukBAADvpAMh -SYEAAAkgiA0EigkAiA0AiooaKyIcjB/7SmYd6LsdAPtKRh3oux0A+0omHei7HQArpFDrNAAFUVEA -AFg/M48fjhotIHSv7i3kWIweJXad9YAiKZIAnQAoQBJkhKgbaXIcaX8dauHriygJUASAAFrCqNog -WsKLY/zEAB1r34wu/Z/l3WIAnQCOF47i8d/lf9IAnQD6IOgVoAsVAFrBx2P8nIkdL5EUsf//IoQd -4ABGAGiE7YodKaEWsZkppRaJGfwhiBXgDiUALnTI/vkmHaAsRQD85yYdoCtlAPrmph3gCgUA+uaG -HaAPhQAJ/Tn85wYd7/CWAAAAACs8GOokAAlgBIAAWyiiY/n/AAAAAADzgGgdr+ZWAIYaxPSfYx9r -t59iFmjRjy0mYoMJ/xGvZoZnLdJ/hm72IKYVoF8FAH+RCcRudpEExZIpJAWJFvxIAAf2bQEA/eAA -F7DdOQD+xgALffkdAOXdEQ/9AoAAD90CH2tzDWYCBuYCjRoea3gPZgLm1gQszQKAAA6ZAo9NFmtt -ltfp1gYn+PEAAP+hZB3gDwUAL9UKLsABKcAAKYQALoQBJsADL8ACL4QCJoQDLsAFKcAEKYQELoQF -JsAHL8AGL4QGJoQHLsAJKcAIKYQILoQJJsALL8AKL4QKJoQLLiEq/6WmHajuHQAu1CwsIFf9p2Yd -qMwdAP2nRh2ozB0A/acmHajMHQD9pwYdoByFAFg+uooa2zD7SwAVoBwFAFg+t4oaiRUcaQX9Q0YV -oA2FAC2mGysgdCukdBtrayV2nSqiF40uKqxA+6AJJGAIBQAeaIIu4oMJ3xGv7o7nju4m4AUj4AQt -4AAv4AHl4AYpngKAAOYzAg7uAoAA790CCZ4CgAAFMwIm4AIl4Afv4AMu7gKAAObdAgmeAoAA5TMC -Du4CgAAP3QKtjQOjCHo7Ai3cASbgDS/gDC3kA/PA5h3oUx0A9cDGHeg9HQD9wRAV6FUdACXkBfPA -Rh3oVR0A9cCGHegzHQAj5AH1wTAV6DMdAOPkAC/+AoAABv8CI+AO5uAKLu4CgADl3QIP/gKAAAP/ -AiXgD+PgCy7uAoAA5t0CD/4CgADl/wIO7gKAAOPdAgeYBQAAfzsBsd0j5A/9wWYd6MMdAP3Bxh2o -vR0A+8FGHejMHQD9waYdqLsdAPvBJh3ozB0A/cGGHai7HQAr5AgmkAUtkAQvkAArkAHukAYu7gKA -AObdAg/+AoAA6/8CDu4CgAAO3QIrkAIukAfmkAMv/gKAAOv/Ag7uAoAA7t0CD/4CgAAG/wKviK2t -etsBsYgtlAcrkAkskA0olAP3IZAVqIgdAPkgRh2orR0A+yDGHaiIHQD5ICYdqKodAPsgph2oiB0A -+SAGHaiqHQAqlAQokAjqkA4rNgKAAAxmAuyQCis2AoAA6mYCDEYCgAALiAIrkA/qkAssRgKAAOyI -Ags2AoAA62YCDEYCgADqiAIDaAUAAHbbAbGILZQPKJQL+iHIFejtHQD/IcYdqMgdAP0hRh2o7h0A -/yGmHajMHQD9ISYdqO4dAP8hhh2ozB0ALJQI+X/eGdIAnQAvIAXFZvf/yMwiAJ0A2iBbHnXAINEP -AAAAAACNHSzREyp8ZusSCCZgBQAA/aJkHaAOJQD+7IYdoAgFAP7sph2gDZUA/OcGHeAJ1QD45qYd -4Ay1AOx0OSXZoQAA+OaGHaAMZQBYPgP4IggVr+BSAI4eixvA0u7bOAlQBIAAWBAMY/gjKqwZ+kng -FeAMNQBYPfkqbB36SYAV4Aw1AFg99fwgKBWv42YA/9b8DaAHBQAAaWIOiifbQOwSBCVQgQAAWyWM -iyJluFsrIEHaIOu8EilgBIAAWyeIwCDRD8CgWEILGGeRiYj5P60wkgCdAP/XAA2gBwUAAAD/38gN -oAcFAMBwwMoMnDT9AQYVr9aeAADF8v5Aph3v5coAAMCgWEH7GGeCiYj5P8RYkgCdAP/igA2gBwUA -AMBwwKoKmjT7AQYVr+JCAAAAAGwQBIo6jCmILHopB/xhRhWgAH4AyaWLqdMPDwIAcrEM6rQABYBJ -gACLuXK58pyp+kGoFaAMBQCcKvxBZhWgOQUA7CYJJABZgAApJAXRDwAAZa/1Gmdt+kAIFeAttQAt -JAUuonMqoov/bwANsA0VAFshUtEPbBAGKAor6CQFKVAEgABawQyDLBRpYRZoP/BncA3gVwUA5zQF -KdAEgABawQUrMg0qYogJuxELqggqogpkoBkrrFz6IGgdoAxFAFg9m/ogCBWgADYAAAAAABpoo5oQ -HWi1LDroDKwsDcwo7BYAKdAEgABawPPrEgAqaASAAOxn5BnQBIAAWsEOAzoCWsDxgztlP46DLOsi -DSGAuYAAZbC/8kGmFeAAIgCTu5s8wOCeLIMqyTDDviowBYU4e6EP41QACv+mAADAsJsq0Q8AANow -WsDchDrwh0AN4DvlAOdEBSpQBIAAWsDWi00qYogJuxGrqoqqZKAVK6xc+iCAFaAMRQBYPW36ICgV -oAAmABpodpoRHWiILDroDKwsDcwo7BYBKlAEgABawMaLERxnuO1pGhpQBIAAWsDi2kBawMWESw8C -AP6ZbA3gO+UAhDrsMgsiAZGAAGXAQPRhZhWgAI4AibvTDw8CAGSfPW0ICumSCyzYBIAAZJ8vY//u -lMucTMDQnTqOOcDw7zYIJwFBgADEgvhgph2v/KYAicvTD9MPZJ/YbQgK6ZILLOAEgABkn8pj/+6J -O2Wf1vpgCBXgP/UALzQFLmJz+tFoFaAMBQD/bwANsA0VAFsg2xlm5Yie+R/gFaA75QD5IcYVr/tS -AAAAAGwQEIUoKCAFDwIA9KEIFaAq1QD7ABiUIgCdAIknKiQF+yQAFe/MBQD9YAQFsAYFAOaWCiXR -AQAAmpnqlggpUASAAFrAgxdnovBu0A3gCkUAHWbiHGbTKUAM43JpIPBBAACW4JbhluKW45bkluWW -5pbnluiW6ZbqKMItluuW7KmI5uYNLEZCgACoMysxLpbulu/9YAUkYgCdAC1ABcLj/6AEvCIAnQAY -ZrodZrqPMBlmt5kUnRqYFv3gABewCEUACP8CnxUuMAcODkEA7hEOuwINuwL6IQYV4Ag1AArqMJoZ -JhYLL0AmGWmvHWieD/4J6f8CBlvbAADvFgwvZwKAAAy7CA27CClSACgWDSkWDiYUPe8iACDRKQAA -/iImFeAMZQBYPOnrHBAp0ASAAPwAgh2gDSUAWwYdwKQTaIcbZwAsUhWEWOsABQnIBIAACQJhCQJh -CQJhCQJhHmiOHWeIH2mXL+WA6uY/IVmhAADtzQIB0CkAAP3HxhXgDGUAWDzSGGdwKIKN6kQACdgE -gAD8AIIdoA1VAAuAAIMqyTzwADwNoDTlANowW6uVgzjTD8g5KTAFdJnugzhlP/SDK2QxPP7QfAWg -VmUA/iKmFaBF5QCJN4+aKjAF5JIJJ4FRgAB2oSr1QAbsYgCdAOU0BSnQBIAAWsAXKHF/focbzUtg -AMIAAAAAAP//WA2gBAUA2jBbHQtgAK0AAGRAqCwSFY1DjkKJQIpB/mEEFeA7JQD+IuYV55nBAPgi -xhXnqgEA+iKGFaAoBQDqMgAsAgqAAPogBhWg7p0A+CAmFeAKVQBYQGErcX8qEhf/amAHU/z1AHyh -YC0SFmjWKGRASOwSFCpYBIAA+mBoHaCPRQD+gQQd4A4VAP5iph2gDQUAWBYBYAAiLRIUijfAwA8C -AOvUAAVQgQAAWyB+9UBoHa/++gArOv97oQ6DO2U/B8Bg8kFoFeAAvgCNN/2kABWvzgUA/4AEBjAO -BQDu1gomYQEAAJzZ/aEGFa//RgAAAAAAAAAA6yIMIYFJgADKtCmyCw8CAA8CAMiebQgJ6ZILLNgE -gADIkWP/75O7mzyWK9EP0Q8AkyyWK9EPAABsEASJJyv6wOOSDiTQgQAA+0AEBXArZQDrJAUlUQEA -AJqZ+yEGFaAIBQDolgopUASAAFq/uiwxEYIqsczsNREhAWmAAPAAYA2gI9UAAAAAAPpAaB2gCxUA -W/8cIiIJyCstIAVz2emCKWUv9NEP0Q8AbBAaGGe9KQoV6AAVCMAEgABtmgIIAIodaQEcaQEPAgAE -3DksFgArIgD4f+Id4AoVAPghBB3gDLUA6hQYLd4CgADsuwIA0GUAAPogJhXgDDUA7BQTIdk9AABY -PDIrPEz6I6AVoAw1AFg8L8CgKhQxKhQy+iZmHaALJQDrFDAiA1GAAB9nwigiDSoWKioUM//v6BXg -DDUA6hQyIPDhAADrFDAsRkKAAOj/CADZAQAA6hQxJ+jhAADtJgAA0f0AAOuHHgfBAQAA6AYABVCl -AADugx4H2SEAAFg8EygSKg8CAA8CAAiIFCgWEuokAAjYBIAA/AFiHaANJQBb+1XRDwAAAGwQGhhn -fSkKFegAFQjABIAAbZoCCACKG2jD+iAGFeAFFQD6QAgVoAw1APwiZh2j+fUA+CEEHeALtQDlFBgt -VgKAAOuqAgHZPQAA6hYBINBlAABYO/QqHB36aYAV4Aw1AFg78PoBAh3gHwUA/iYmHeAOBQD+JkYd -oB1FAPwmZh3gDCUA7BQwIgDRgAAoQAApQAL1AAZcEgCdAPomxh3gAEoAiTwJClALqhEFqgIqFDYV -Zl8PAgAtUX/6JoYd4B8lAP2gBAIwLiUABP45LhYQ/a7AHaBUZQAoIAX1AAkcIgCdACQkBSowBSkK -OflIXg3gC3UAK1F//2eAB5A91QAsIAV0yTErIg0qUmkJuxELqggqogpkoK3rrFwg0f0AAPtFIBWg -DEUAWDu/+iVIFaACdgArNFLRDyo0MPxgph3gDHUALDRS0Q8AAADqJAAI2ASAAPwBYh2gDSUAW/r9 -Y/+FAADzP/muEKk5APM/+W5Q2TEAjkN75xPx3/kGkgCdABhoai8xGQj/AS81GS41GRZnpIQ8BkQB -FmVdDqgQCEQCBkQBFmhjD9gQ+IYACjD5KQDmSQEP/AKAAA+ZAvhhhhXv+5oAAAAaZqMqFioZZrUo -OugIqCwJiCjoFiopUASAAFq+8ysSKhxl5e1nRxlQBIAAWr8P2iBavvLAlyk0UtEPAAAA6iQACNgE -gAD8AWIdoE71AP5Aph2gDSUAW/rNY/7FAABsEBoYZvUpChXoABUIwASAAG2aAggAihtnNfogBhXg -BhUA+kAIFaAMNQD8ImYdo/n1APghBB3gC7UA5hQYLVYCgADrqgIB2T0AAOoWASDQZQAAWDtsKhwd -+mmAFeAMNQBYO2jAUOUUMSDQ0QAA9CZGHeAMJQDsFDAiWUEAAPQmZh3gHAUAWDtfKhxE+ogAFeAM -hQBYO1wqHEz6hwAV4AyFAFg7WCtMYPougBWgDIUAWDtVwoAoFDQoFDUvMhgvFhDmFUApUASAAOUU -VCjYBIAA9CyGHeAMtQD0MIYd4P71AP4nxB2gDSUAW/qRKjAF+mYGHaA5lQApNAXRDwBsEBoYZrb+ -zfwF4Au1APgCoh3j/fUA6AAVCMAEgABtmgIIAIqfEIog/CEEHeAOFQD+IwYdoAw1AOwUEy1WAoAA -C6oCmhEpMAQnHB3qHBkkrTUAACs8T1g7LNpw+mmAFeAMNQBYOynlFDUpUASAAPYmxh2gCRUA+CYG -HeAIBQDoFDEo2ASAAPgmRh2gDLUA+CZmHaANJQBb+mfRDwArPEhYOxracPqAoBXgDDUAWDsWY/+z -AABsEDIcZ9cdZ87TDyzCfxpmq/qgaB3vzgUA5cxULkgEgABtSQUDAIYJAmH4QOgV7AMFAJMQ5iIN -JjlhAADqon8mGPEAAOQiDiTAgQAA7o8BCzZCgADqZggH+QEAAPyABYRiAJ0ACUQRpKSNR4je/yEm -FeA6lQD/IQYV4A0FAO2WCiIFIYAAKcBUwtD3IAaWED71APmgCVNgO9UALoBUL4BV5YBWL3YCgAAP -7gLvgFcvdgKAAAXuAgjuEQ/uArHu/wrmHajuHQD/CsYdqO4dAP8Kph2o7h0ALoRUKEAF+wA6NCA1 -pQD1AEIEYgCdAPsAKBxiAJ0A2iDrRAAJ4ASAAPwBIh3gHuUAW/+R0Q8AAAAAAP8ABAewCgUA6pYK -J/kBAACfmS+WCMpvKMBU9QAtUZIAnQBohXL1AC5mEGsVAPsM/g3gLMUAKGAF/QANlCAt9QD9AA1U -YgCdANEPAAAAAAAA9yAIIpIAnQD5IBCjEgCdACmAWCqAWQiZEQqZArGZ+QsmHeiZHQAphFgoQAX5 -GUAVoA7lAP8AIhqiAJ0AGmdyCooKiqAKoAAA2iDrZAAJ4ASAAPwBIh3gDgUAW/9k0Q8AxXL3IArT -YDW1APjgEatiAJ0ALYBgLoBh74BiLu4CgAAO3QLugGMu7gKAAA/dAgjdEQ7dArHd/QxmHejdHQD9 -DEYd6N0dAP0MJh3o3R0ALYRgKEAF+KAgAyIAnQD7AB/DIgCdACrCG/gAAh2v8/UA/UAAFTAOhQBt -6hWkiwyJCCmQZCuwNA8CAOm5DHRABQAA8AiADaAIBQDpswZ5wASAAMCBZI/qYAPM+SAH4dIAnQAr -gFAsgFHtgFIt3gKAAAy7AuyAUy3eAoAADbsCCLsRDLsCsbv7CmYd6LsdAPsKRh3oux0A+womHei7 -HQArhFAoQAX7ADxUIgCdAP8AHtQiAJ0A6kQAC9gEgABYArropAAFJzmAANog7DQAClgEgAD44AAH -MA11AFv/GfqAaB2gi6UAWAIo0Q8AAAAAAAAAg2rJNCo8TPogaB3gDDUAWAPRZKN0gzhlP+naIFsa -q9EPAMLBfJlCLYBaLoBbCN0RDt0Csd39C2Yd6N0dAC2EWihABfUAJdxiAJ0A+wAlnGIAnQDaIOtE -AAngBIAA/AEiHeAOBQBb/vrRD9og60QACeAEgAD8AWId4A4FAFv+9NEPAMHifpniKoBoK4Bp7YBq -LVYCgAALqgLrgGstVgKAAA2qAu9j8B1WAoAAC6oC6cEvJVAFAAD7DWYdqKodAPsNRh2oqh0A+w0m -HaiqHQAqhGj/IDdUYgCdAIVLyF4oUTf5ABK8YgCdAIVbZV/v2iDrRAAJ4ASAAPwA4h3gHnUAW/7T -0Q8AKwph+z/69WIAnQAsgGQtgGXugGYuZgKAAA3MAu2AZy5mAoAADswCCMwRDcwC42IKJmAFAAD9 -DOYdqMwdAP0Mxh2ozB0A/QymHajMHQDshGQh6CGAACo8TPogaB3gDDUAWAN8ZKYrgzhlP+lj/OYA -AADA2G3aE6SLrIkpkFwrsDyxiPlgCb1iAJ0AKhYs+C/gFaAJBQD5BiAVoAs1ANMPbboXK4AApJoq -oEzpnAEkQAUAAPtgCL0iAJ0AGWVaKBx/KIw5+AAKFeAZVQBtmgIIAIoZZp7pFi4iWT0AAPxACBXg -DxUA/joGHeAINQD4OWYdo/71AP4shB2gDDUA/aAAFrAOtQDu3QIA0f0AAO0WLyVRSQAAWDnP60xM -INH9AAD7SsAVoAw1AFg5yvrKxgXgCSUA+D0GHeAPBQAvFOsvFOovFOkrsn+OLfg9Bh3gDDUA7xZY -IOn9AADvFOsg0AcAAO8U6i92QoAA7rsIBVGBAADvFOklwOEAAOgmAAb55QAA74ceBfEBAADuBgAG -6cUAAO2DHgXZIQAAWDmuLhJY2iD8AWIdoA0lAPov4BXo7h0A7hZAJdjlAABb+PHRD+mzBnnABIAA -wIFkjr9gAGR7owHAMWQ+5GAAWdog60QACeAEgAD8ASId4B7lAFv+V9EPAAIqAutEAAvgBIAAW/2M -L3AC8f/YDpIAnQAESgJYB3oGAAAAAAD7H+BEYgCdANog60QACeAEgAD8ASId4B7lAFv+RtEPAABk -Xa75AA0tYgCdAClRNijBLvkADL1iAJ0AK8xZ+qugFaAMNQBYAv1loYEqUAUrClZ7oQUFWgJbGdYC -KgL6gGgd4AwFAFv9LNEPAAAAAAAA+mBoHaF7JQBYBM7RDwAAAPqAaB2gDDUA7ERSK9gEgABYAcLo -pAAFG0mAANog7DQAClgEgAD44AAHMA11AFv+IfqAaB2gCwUAWAEw0Q8AAAD6wGgdoAtFAFgCt+Sk -AA0QZgAA2iDrZAAJ4ASAAPwBIh3gLpUAW/4T0Q8AAADaIOtkAAngBIAA/AEiHeAe5QBb/g3RD/Vg -GtmSAJ0A2iDrRAAJ4ASAAPwBIh3gHuUAW/4F0Q/aIPqAaB3gDAUAW/z6/ICwFeAPRQAvRFL8hgYd -4E41AH7RBMOPKEQF+oBoHaCLdQBYAarRDwAAANog+oBoHeAMBQBb/Oz6wGgdoAsVAFv8ANpgW/uD -62IIK1AEgABb+2PRDwDaIPqAaB3gDAUAW/zhimhb/MTRDwAAAAAAAPqAaB2gCTUA6URSKtgEgABY -AOACKgLrRAALYASAAFv9ngRKAlgHBgYAAAAAANog60QACeAEgAD8AOId4B51AFv91dEPAAAAAPpA -aB2gM5UA+oBoHeAMBQBb/Mf6gLAVoAuFACtEUipEMCNEBdEP2iDrRAAL4ASAAFv8/yxwAvOAEoaS -AJ0AjXPxv8Yu0BIFAB5keLgY/gAKFaAZVQBtmgIIAIobZb6bEv6ACBXj+fUA+CGEHeAKFQD6JAYd -oAgFAPgjZh2gDDUA/eAAF7AItQDo/wICWT0AAO8WAyDQhQAAWDjuKhwl+omAFeAMNQBYOOviFDkq -UASAAPohABXgD4UA/ieGHeAuBQD+JwYdoAgFAP4nxh2gLCUA/CJGFaAdRQD8J2Yd4Ay1APgnRh2g -DSUAW/glJUQF0Q8AAAd7AlgBL+ikAAUCWYAAAioC7DQAClgEgAD44AAHMA11AFv9jfqAaB2gCwUA -WACdBgAAAAAA2iDrRAAL4ASAAFv8vylwAvE/vm6SAJ0A2kBYBq3RDwDqRAAK2ASAAAERAlgAfo5H -DwIADwIALuIOLeBQL+BR6OBSLu4CgAAP3QLv4FMu7gKAAAjdAupMTC7uAoAA/6YADvAMNQDjPAUm -6AUAAP3KZh3o3R0A/cpGHejdHQD9yiYd6N0dAO3kUCnYBIAAWDin6h0BKdgEgAD7TIAVoAw1AFg4 -oisSWfjIzgXoux0AKxZZiEwcZWMJiAF8vA4cZWIMjAL8gYYVoAA2AAAdYmgNjQKdTNog+oBoHeAO -NQDuRFIrYASAAFv9ENpAWAZ50Q8A6kQACtgEgABYAEoCKgLrRAALYASAAFv9CARKAlgGcAYAAAAA -AAAAAOpEAAvYBIAAWADa6KQABQPpgADaIOw0AApYBIAA+OAABzANdQBb/Tn6gGgdoAsFAFgASNEP -AAAAAAAA2iD6gGgd4AwFAFv8KtEP2kBYBlpj/asAAADaIPqAaB3gDAUAW/wkL2B7+/+1eJIAnQD6 -YGgdoXslAFgDxdEPAAAA2iD6gGgd4AwFAFv8GtEPKnwQ+sgAFeAMhQBYAd/moFVtQASAAGqhJ+pE -AArYBIAAWAAXAioC60QAC2AEgABb/NXAg+hEUipQBIAAWAY70Q/aIOw0AApYBIAA+OAABzANdQBb -/Qv6gGgdoAsFAFgAGtEPAAAAANog60QACeAEgAD8AcId4B6VAFv9AdEPAABsEAQqLDT6Y4AV4AyF -AFg4PiosPPpigBXgDIUAWDg6KixY+mEAFeAMhQBYODcqLGToMgQh2REAAPhDBhWgHAUAWDgx0Q8A -AABsEAQWYsYoIhUlYojpiBEJUASAAOhVCAnYBIAAW+IN2iBau4mKKcivhKvbMFuz9upEAAp/rgAA -iinA0OsiCyUA2YAAZbCX+kFmFaAAIgCau5us/EEmFeAKBQCLWnK5EoopiSj4oUYV4AC+AAAAAAAA -AADJuIy4csEUbQgM68QABgBxgACMyHLBBGP/7AAAyLSKKYwonLidKCsgBeskMC0BxgAAjSvO3sTj -frFNLmJziyD60WgVoAwFAP9vAA2wDRUAWxuiGWGsiJ7D/+8kBSRD/QAAmJ7RD8SSKSQF0Q+Juw8C -AA8CAGSfZG0ICumSCyzYBIAAZJ9WY//uw68qJAXRDwAAAGwQGvjGxgWuCQUA+CAGFeAEBQD0ICYV -oBlVAOgAFQDAIQAA0w9tmgIIAIoYY2KYEvxACBWj/vUA/iGEHaAPRQD+JAYd4A21AOQUGy5mAoAA -DcwCLBYDKyAE6hwhKAQKgAD1YAQakgCdAPpJ4BXgDDUAWDfSKhwl+kmAFeAMNQBYN88TY2goIhUj -Mn/Dn+kkBSxGQoAAqDMkFDkkFDrkFDsg0QEAAPpoABXgCFUA+CcGHaAMhQBYN8ErPEj6IIAVoAw1 -AFg3vokR6xwIKVAEgAD5DgAM8Ay1APgh5hXgDSUAW/cB0Q8AAAD6SQAV4Aw1AFg3sisQAi0QAe4Q -ACDglQAALsQA7cQBKRgEgAD7gEYd4Cq1APpAph2v/f4AbBAEIjEDKjECFGRd/EXgR9AIFQDyhPYN -oAUVACcxAiYwQPYMAARwAgUA+K0ACTB3KQD2rQAJcGY5AAZSONEPKTBA+gwABbACdQD7DQAJcKop -APsNAAkwmTkACYI40Q8AbBAWKAqG+GAbRCIAnQApCof4YBs8YgCdACQhGR1hPywgDBdiHi3SLRti -+ypyiO3MCAjABIAA6wAVDmZCgAD9QABFMBkFAG2aAggAih5hQSqhLv9AEXQgBgUAHGEqHWEq+kAI -FeDuFQAuFBj8IEYV4AWFAOwWAC3eAoAABbsCmxEsIAf8w1AF4cwBAADMEQysAg3MApwUCuowmhWb -GfjGQgXgSAUAKBUPmRgvIFIvFDEuIAUuFDL8RhAV4A8VAC8UMC0UMywiFewWDSDggQAAi8WKxInD -iMLuwgEg6QEAAJ7RmNKZ05rUK9YFLMIALNYAKyIAKxYWKiBSKhRdKSAFKRRgKCAw7xRcKuAEgADm -FF4hWNEAAOgUYSDRoQAAWDdIKhxw+keAFeAMhQBYN0UqHHr6SMAV4AxlAFg3QSocffpJgBXgDDUA -WDc+6yxYINH9AAD7QKAVoAyFAFg3OSgRQvQLAAKwxCEA9AYABzDUKQD6KGQVoZQdAPiGAAzw9DkA -6hUxL/9CgADqIgwu78KAAO3MAg93goAA7+4CCq5CgAD0CgAHsNRBAP+gABawmQEA6ZkRD/6CgAD1 -5gAP8LgpAP14ABWwVEkA+yYADPSqmQDqmQIKrsKAAAXdAg/dAikUZPRMkBXgSGkA/kywFeCIcQDp -iBEKJoKAAPiGAAowVRkA/qgAErCPOQD0hgAKcF8xAO6IEQqvwoAACFUC9IYACnD/KQD15gAPsDQF -AAT/Ai8UZYssDt0CDcwC/CzmHaCrgQD6EQAE8LuRAOqZEQ3eQoAA65kCDVbCgAD7JgAMsAqFAAqZ -AikUZoQniErkgRxiUIEAAI5JZOES+iBoHeAMhQBbHo8oIhUlcojpiBEJUASAAOhVCAnYBIAAW+DO -2iBaukqKKcivhKvbMFuyt+pEAAp/rgAAiinrIgslANmAAGWwk/pBZhWgACIAmrubrPZBJhWgCgUA -i1pyuQ6KKYko+KFGFeAArgAAAADJuIy4csEUbQgM68QABgBxgACMyHLBBGP/7AAAyLSKKYwonLiW -KCsgBeskMC0BxgAAjSvO3sTjfrF9LnJziyD68WgVoAwFAP9vAA2wDRUAWxpkGWBuiJ7D/+8kBSRD -/QAAmJ7RD8SSKSQF0Q+Juw8CAA8CAGSfaG0ICumSCyzYBIAAZJ9aY//uwab6SkYdr/KGAMC0+kpG -He/yXgAAAAAAAADqJAAI2ASAAPwBAh2gDSUAWv/hY/7hw88sJAXRDwAAAGwQBBtiSBlhTBVgTx5i -ZhhhP4QnLSIAKIKsJEIO7t0CCVAEgAD8s4YV4AxFAPizphXgDVUAC4AAKlKdHmJc+B/iHeACBQDy -gAAG+KodAOqQH37rQoAAK0A6LEA7CLsRDLsCsbv6h2Yd6LsdACtEOtEPGWInEmIiKFKmIiJ/CYgB -CYgRqCKMLA7MAQ3MApws0Q8AAABsEATAcG1KEaJ4o3QkQAAogADkiQ5zuAUAAMAg0Q8AAAAAAAD1 -ARYNr/L1AMAh0Q/RDwAAbBBGKTBUxHL0weYF4AolAPUgD7CQAgUA+SAKcVIAnQAqMS8tMJgvMS7k -Yd0deDwAABhjHvsAF0KiAJ0AwJf+DAAHcAwVAP+NAAyw/ykA/40ADPDdOQD9ggAM8BpVAPMw4A3u -CAUAkhUEAImYFO1h1RDAYQAAbaoCCACKnRaKYPIlZh2gDEUA/CYGHaP79QArFRT9QAAVMAu1AAuq -AioWBylgBCocMQ8CAPUgE9qSAJ0A+sngFeAMNQBYNkQqHDX6yYAV4Aw1AFg2QShiFSNSacOf6WQF -LEZCgACoMyIUSSIUSuIUSyHZAQAA/AECHaAKVQDqFEgg0UEAAFg2NCs8SPoigBWgDDUAWDYwjhXr -HBgrUASAAP8OAA8wDLUA/iJmFaANJQBb9XQoYhUkUmnpiBELUASAAPiAAEIwi6UAW+AI2mBauYSK -acmgg6srCopbsfHqNAAJ/6YAAIppi2vKp8y4+sFmFaAAbgDRD4m7yJvpkgss2ASAANMPZZ/ymrub -rPLBJhWgCgUAi0p2uQuKaYlo+IFGFeAAngDJtyyyCA8CAA8CAHbBDOvEAAYASYAAjMh2yfLItIpp -jGicuJJoK2AF62QwLQHuAACNa8/TxOP/YAxkIgCdAC5SVItg+q2IFaAMBQD/bwANsA0VAFsZmhhf -pI+Ow5/pZAUn+/0AAJ+O0Q8nZAXRDwAAIzBZwL76f/q8YgCdABxitC9gTi5gTS1gTCpkUihgBfjG -Bh2gOyUA8iAGFeAKVQBYOasoYhUkUmnpiBELUASAAPiAAEIwi6UAW9/D2mBauT+Kacmgg6srCopb -sazqNAAJ/6YAAIpp62ILJQFpgADMuPrBZhWgAG4AAACJu8ib6ZILLNgEgADTD2Wf8pq7m6zywSYV -oAoFAItKdrkLimmJaPiBRhXgAJ4AybcssggPAgAPAgB2wQzrxAAGAEmAAIzIdsnyyLSKaYxonLiS -aCtgBetkMC0B1gAAjWvP0MTjfrF8LlJUi2D6rYgVoAwFAP9vAA2wDRUAWxlVGF9fj47Dn+lkBSf7 -/QAAn47RDwAAJ2QF0Q8AAAD4QGgd7/RqAPrJABXgDDUAWDWmLhwQLeAB6+ACIODVAAArxAItxAHu -4AArGASAAP+ABh2gKrUA+sCmHa/2BgAAw/8vZAXRDwDDjyhkBdEPAOs8cCNQ0QAA+i/GFaAMhQBY -NZLrPGgjUPEAAPov5hWgDIUAWDWO6zxcI1FhAAD6MAYVoAyFAFg1iewyGSNRkQAA/MMGFaCbhQD6 -YABF8BwFAFg1gi1gDB5fNy9gBf7GBh3gBxUAJ2RSLuItJ2EZ/K0oFaAZBQDu3QgAwf0AAOQAFQ7u -QoAA7cwIBEEFAABtmgIIAIoYXzYswS75gBLkIAOFAB9fHxhfH/7ACBWg6RUAKRTYKBYy7xYwL3YC -gAAD7gIuFjEvYAf4vzwFof8BAAD/EQ/PAgj/Ai8WNA3qMC0WNS4WOfzCLgWgSwUAKxVvLBY4KmBS -KhTxKWAFKRTy+MYQFaAMFQAsFPAoFPPvYhUg8f0AAO8WPSdxhQAAjeWL5IrjieLo4gEg+AcAAJjx -mfKa85v0nfUu4gAu9gAtYgAtFkbqYFIg2AcAACq0HehgBSDIBwAA6JQgIPgHAADuYDAg6AcAAO70 -ISDYBwAA4rQeINAHAADs1BwlUKEAAOsSfingBIAAWDU16xJ/INAHAAD7RgAVoAyFAFg1MOtsRiDQ -BwAA+0dAFaAMZQBYNSzrbEwg0AcAAPtHoBWgDDUAWDUn6xKAINAHAAD7SIAVoAyFAFg1IiwRovYE -AAbw5ykA9gYAB/CXWQD9KAAUsIc5AO2IEQ//goAA6P8CD3fCgAD/pgAOsIdRAP0QABQw50EA+QYA -DHCXSQDs7hEMzsKAAAnuAgjuAvg0ZBXhhx0ACHgCKRWRiWz8BQAFMIgBAOuqEQxGQoAA+wYADDSZ -mQDpiAIA0AcAACikJPrMkBXgnGkA+MywFaDMcQDpzBEMzoKAAP0mAAywuxkA/2gAFbDIOQD7JgAM -8LgxAO7MEQ3fwoAADLsC+yYADPCIKQD5BgAMcDkFAAmIAiikJYxsD+4CDt0C/UTmHeC8gQD8EQAE -sMyRAOqZEQ5mQoAA7JkCDd7CgAALmQIDmQIppCaNZ4ja5IDZZtCBAAAv0glk8M4rHH/7aCAV4AyF -AFsceSxRf/Of18+SAJ0A5AAVAMAHAAD5CgAVoBlVAG2aAggAiu5hkBNZPQAA/iqGFaAMFQD4wAgV -4/31AO0VsCDQBwAA80xmHaANtQDspGgszgKAAP0mAAzwDDUA6RZVJVGlAABYNMDrbEwg0AcAAPtN -oBWgDDUAWDS76x0BK1AEgADzcEYdoAy1APNwhh3gKQUA+XAGHeANJQD5cMYd4BgFAPlwJh2gH0UA -/3BmHeAuJQDuFmQl2UEAAFvz9cOqKmQF0Q/aYPov4BXgDIUA+2ggFeANJQBa/dxj/yYAbBAcGGAW -9r5EBewKBQD6IAYVoAsFAJsRKSIVJHJpCACJ6ZkRAMAhAAD4gABCcBlVAG2aAggAivokIBWgDDUA -/EAIFeAGFQD2I2YdoA61APYkBh2j//UA7xUMLu4CgADu3QIBKT0AAO0WAyrYBIAAWDSGJhQ4IxUg -LBABKRAC/CAQFeD+xQD+J4YdoAolAOoUPSDYlQAALbQA+WBGHeIfNQD9YCYdoXglAPhn5g2gDIUA -/mAErGIYdQD4YAY8Ihn1ACoWLXkxPC0SLB5hN+scCClQBIAA/6YADzAMtQD+IEYVoA0lAFvzs9EP -AAD8KWYdoD8lAP5Aph3gHUUA9o9mHa//KgDbUPNAaB3gBIUA+iCAFaAMNQBYNFyKESlxf/Qp5h2o -qh0AmhH6IkYVoJkJAPjNAAnwHYUA8inGHeA4RQD4QKYdr/4aAAAA21D6IIAVoAw1AFg0TI0R+ocA -FejdHQDtFgEg0TEAAPwiRhXgDIUAWDRF/AOCHeA+VQD+QKYdr/0qANtQ+iCAFaAMNQBYND6IEfYp -xh2oiB0A+CJGFaA9RQD4ICYVoD81AP5Aph3v/G4AAGwQIvi9bAWgCQUAmRCJLSiCaQmZEamCiSiM -KiSSGeTALmIjwQAAKgpAbQgLi8wLO1RotAaMyMnGY//tLcAFLcUJ+4CmHa//vgAAAAAAAAAA9oAJ -ldIAnQCPKikWLBpfkutfwRFhQQAA7BYxIOjxAADtFjAg8JUAAO4WLyDAhQAAKBYuKxY46hYtINkx -AADrFjIhUQEAAOoWMyDBUQAA6BY0IXDhAADuFjUg6fEAAO0WNiFhgQAALBY3uDz0YgAV4A4FAPxg -aB3gCIUA0w9tihEm0Bii5ydwQLHu5nkadugFAACNNGbQoCRM8OM8ECJbL4AAYACSAAAA9uDWDa/9 -9QDA0WTf3CYSLIZqy2v8YGgd4A4FACfQGKbqKqBAsd3nqQ53cAUAAHzZ6o00Y/+1AAD3QNYN7/31 -AMDRZN/rhmndMP7c/A3gDgUA7PQAB4aZgACLzN0w+pMABfAOBQD5YAXSUAiFAG2KVCbQGKznJ3A8 -se7mcUV26AUAAPbgF3Ov/fUAYALkAI8q4/QAD4BOAABgACDJPSgwBeMyCCnQBIAAaY3viawJOVRp -lOcrCoZb/DllP+DAoCoke9EP0w+NNMDw6NgRCPAEgAD4IAYVoAs1AG26EybgAKz1JVBMsf/TD+Vp -FHdwBQAAKMEJKMQF/kFIFe/7ygAAAPag1g2v/vUAwOFk7+IqzEz6IGgd4Aw1AFgzsPxgiBXv/14A -jMhlzzAZXi8pkX9+lwaNNGP+tQAAHl1WH15RG19rGF5EhieJICiCrIZuC5kC6xI4KVAEgAD/06YV -4AxFAPnThhXgDVUAC4AAGl1JKqKd+w4ADTD59QB6kCUrYDosYDsIuxEMuwKxu/rHZh3oux0AK2Q6 -jTT+QUgV7/lGAAAAABhdOxlfLBZeDyiCpiZiaQmIAe1fUBxGQoAAqGaMbA3MAR1dVg3MAuxmDCN+ -QYAAiTS4W+psPCzOAoAA+CAGFeAMhQBYM33lbEwo2ASAAPqgaB2gDDUAWDN4KhItKBwI+gAKFaAZ -VQBtmgIIAIoqEi4ZXyyZEvzACBXgDxUA/iQGHeAIBQD4I2Ydo/71AC4VDP2gABawDrUA7t0CA1k9 -AAD8IGYV4Aw1AFgzZCsSMSgSLylQASpQACqEACmEASoSMC9QAv8ARh3gDjUA/icGHaANBQAtFDkt -FDr8J2Yd4BwFAFgzVi4SMy0SMizgACvgASvUASzUACrgAingAynUAyrUAijgBC/gBS/UBSjUBCzg -By7gBi7UBizUBy0SNSwSNCvQACrQASrEASvEACnQAijQAyjEAynEAi/QBC7QBS7EBS/EBCvQBy3Q -Bi3EBivEBywSNysSNirAACnAASm0ASq0ACjAAi/AAy+0Ayi0Ai7ABC3ABS20BS60BCrAByzABiq0 -B/1gxh2gKQUA+CeGHeD49QD4J6Yd4A4FAP4rhh2gDxUA/i2GHaANJQDvFUQrUASAAP4xhh2gDLUA -6BVCINghAABb8mjD2fzAph3v+J4AwNFl3atj/UoAAGwQLigwVGiCAtEPAOs8cCMo0QAA+qBoHaAM -hQBYMxDrPGgjIPEAAPqAaB2gDIUAWDMM6zxcIxFhAAD6QGgdoAyFAFgzBys8eOkyGSNRkQAA+MMG -FeAcBQBYMwEcXseKbCtgBededBjABIAA/UAEBTA8FQD9YBsMIAMVAB1evg2tAp1sHVy7K2AMGlzM -HFyrLmEZI2RSLMItLhZQKqKDDLsI5wAVDd5CgAD7QABFcBkFAG2aAggAiiqhLv1AEVRiAJ0AHlyY -H1yY/MAIFeDoFQAoFBj+IEYV4AyFAO4WAC7uAoAADN0CnREuYAf+uiwF4e4BAADuEQ6uAg/uAp4U -C+ownRmbFRpej/ohBhWgSQUAKRUPKGBSKBQxL2AFLxQyLmAwLhQzIxQwLWIV7RYNIOiBAACL1Y/R -iNKJ0+rSBCDxAQAAmuSZ45jin+Gb5Y3QLeYAi2ArFhYqYFIqFF0pYAUpFGAoYDDyK4Yd4A8FAO8U -XirYBIAA6BRhINGhAABYMrjbQPouABWgDIUAWDK1Khx6+sjAFeAMZQBYMrEqHH36yYAV4Aw1AFgy -ruocfylYBIAA+0CgFaAMhQBYMqkpElAsEUItEUP8JiQd4EkhAPwNAAUwvHEA+C4ADHBZKQDomAIK -r8KAAOm7EQ1WgoAA/AUABjDZWQDrqgIOZsKAAPrBiBXgiAEA9IYACnBZQQDsVREMRkKAAP0GAAw0 -u5kA+wYADHDJUQD4LIYdoLk5APgGAARwmUkA7bsRDM7CgADpVQIMR4KAAAuIAutgZC7uQoAA6WBl -LmaCgAANzAL8pgAKsLsZAP9oABWwyTkA+0YADXC5MQDuzBEN38KAAAy7AvtGAA1wmSkA+yYADLA6 -BQAKmQIpFGWCbAhVAgVEAvQs5h2g8oEA8hEABzAikQDq7hEJFkKAAOLuAg/+woAA/8YAD3APhQAP -7gIuFGaMZ43KKswg7sIJJoixgABk4Q76IGgd4AyFAFsZ/i9gBfgGIh2sCQUA+f/olSAKBQAHAIkq -FiXpFiQgwf0AAPkDIBWgGVUAbZoCCACK8sngFaAMNQD8wAgV4A61AOMUqyDR/QAA8jYGHeP/9QDv -FVQu7gKAAO7dAgVQyQAA7RYnKVgEgABYMkQjFMj6L+AVoh91AP4tBB3g+cUA+DmGHeAIJQDoFM0l -cEUAACjgAu3gASVI2QAALZQB6JQCKVgEgAD/wBAVoAw1AO6UACVQVQAAWDIxKBIl2mD+vfAFoAy1 -API7xh3oiB0A+CSmFaANJQD4JsYVoD81AO9kBSDZ/QAA7hYmJdhlAABb8W7RDxld6wmpAvjBhhXv -8oYAAAAAAAAA6mQACNgEgAD8AQIdoA0lAFr7UWP+5QAAbBAWHVvaKyAMHFvKGlvrE12ILMItKqKD -AwCJ7LsICMAEgADjIRkt3kKAAPtAAEVwGQUA0w9tmgIIAIoqoS79QBJMYgCdABxbth1btvpACBXg -7hUALhQY/CBGFeAEhQDsFgAt3gKAAAS7ApsRLCAH/LhoBeHMAQAAzBEMrAINzAKcFArqMJsZmhUZ -Xa34IQYV4EgFACgVDy8gUi8UMS4gBS4UMi0gMPwmZh3gDxUALxQwLCIV7BYNIOCBAACLxY7BiMKJ -w+rCBCDpAQAAmtSZ0yjWAi7WASvWBSzCACzWACsiACsWFiogUioUXSkgBSkUYPhGEBWgDgUA7xRc -KmAEgADuFF4hWNEAAOgUYSDRoQAAWDHSKhxw+keAFeAMhQBYMc8qHHr6SMAV4AxlAFgxyyocffpJ -gBXgDDUAWDHI6yxYINH9AAD7QKAVoAyFAFgxwyoRQvIEAAfwYzEA8gUABvBTQQDyCgAD8JNZAP4o -ZBWgg0kA/iYkHaGzHQD6ZgAN8MM5AO3MEQxGwoAA6ZkRC76CgADpdwIKrwKAAOhVAg7vwoAA7f8C -CzeCgAAMZgL8QYgVoLsBAP1oABWw2ikA51UCDu7CgAD9ZgAN9MyZAAy7AisUZPpMkBXgmmkA9kyw -FeCqcQDqmRENVkKAAPsmAAywuxkA9gYABXDHOQDuzBENV8KAAOyqAg3fQoAAC5kC+yYADLB3KQD4 -5gAL8DgFAAh3AicUZY4sBlUCBf8C/izmHeDegQD+EQAGMO6RAOrMEQ92QoAA7swCDu7CgAANzAIE -zAIsFGaJJ4uaKpwg7JIJJYCxgADIzvogaB3gDIUAWxka0Q8AAADqJAAI2ASAAPwBAh2gDSUAWvqt -0Q8AAABsEByJJycxC4iahpnkgLBjuxEAACpsGfpnoBXgDDUAWDFrKmwd+mggFeAMNQBYMWcuMDyK -LhheIP/boBWgCxUA7r45DTZCgAD5QCxUIgCdABhbNoktKIKD7F4nHM5CgACpiqhmLWAFj6eLZ4qo -/+HIFeAYFQDrsg4m6z0AAHjbMhheHgjYCoiACoAAACsWLSoWLPXAMVCSAJ0AKfA+KvA/CJkRCpkC -sZn55+Yd6JkdACn0PtogWxGi0Q8AAAAAAAD//UANoAYFAAAAZeQLKTBU9SA6eJIAnQBpktfBp+pk -UitQBIAAW/8iY//HZeQJKTBU9SAnQJIAnQBpkrZgBOtl5BUpMFT1IDb4kgCdAGmSosDFLGRSKzBY -9WBBtBAJFQD+ACIdoA0FAAntOGTQYSsyGStlGRtdJIhsKjBaDwIA+wAEBHCqOQDrWtodU4KAAAqI -AihmDCowWvsABARwqjEA613dHVPCgAAKiAIoZgwqMFovYAULiAH6BQAFMDvVAOtkBS1UAoAACogC -KGYML2Qw/AAiHeAMBQAJ3DhkzxQjYRkcWsArYAwaWuAswi0eXHwqooPsuwgAwEEAAO4AFQ3eQoAA -+0AARXAZBQDTD22aAggAih1awiqhLv1f9rRiAJ0AHFqrHVqs+sAIFeDuFQAuFCj8IMYV4ASFAOwW -BC3eAoAABLsCmxUsYAf8tlIF4cwBAADMEQysAg3MApwYCeowmRmbHRhco/ghhhWgSgUAKhUXL2BS -LxRBLmAFLhRC/MYQFeAPFQAvFEAtFEMsYhXsFhEg4MEAAIvFisSJw4jC7sIBIOlBAACe0SjWAinW -AyrWBCvWBSzCACzWACtiACsWGipgUioUbSlgBSkUcPjGEBWgDgUA7xRsKmAEgADuFG4jWNEAAOgU -cSDR4QAAWDDH62w8INH9AAD7QCAVoAyFAFgwwutsRiDR/QAA+0FgFaAMZQBYML7rbEwg0f0AAPtB -wBWgDDUAWDC562xYINH9AAD7QqAVoAyFAFgwtCwRSvILAAVwUyEA8gYABHBzKQD+KWQVodMdAPxm -AA7wkzkA7hU5LM9CgADuYgwrv8KAAOdVAgxHgoAA6YgCDVZCgADyCgAE8HNBAP7gABOw3QEA6d0R -DM6CgAD7JgAMsPwpAP34ABewo0kA/6YADvTumQDu3QINVsKAAAp3Agl3Ai0UdPrMkBXgrGkA+Myw -FeDMcQDpzBENVoKAAP1GAA0wuxkA/2gAFbDJOQD7RgANcLkxAO7MEQ3fwoAADLsC+0YADXCZKQD7 -JgAMsDoFAAqZAikUdYNsCHcCB1UC9C7mHeDzgQDyEQAHcDORAOruEQmeQoAA4+4CD/7CgAAP7gIE -7gIuFHaJZ42a5NUOZJiBAACImWSFBNow+iIAFeAMhQBbGAtj/I9l4REpMFT1IBdokgCdAPk/4/FS -AJ0AYAL2+cAIwNIAnQAqMS79QB8sIgCdABldK/lf4u1iAJ0A+sBoHaF7JQBb+7hj/Er5wAhg0gCd -ACoxLv1AHjQiAJ0AG10g+1/hjWIAnQD6wGgdohs1AFv7rWP8HvnACADSAJ0AKjEu/UAdPCIAnQAc -XRX9X+AtIgCdAPrAaB2iG/UAW/uiY/vyZeD0KTBU9SAUCJIAnQD5P98JUgCdAGACii3wPi7wPwjd -EQ7dArHd/efmHejdHQD958Yd7+8CAAAu8D4o8D8I7hEI7gKx7v/n5h2o7h0A/+fGHa/uhgAAACjw -PinwPwiIEQmIArGI+efmHaiIHQD558Ydr+4GAAAAKfA+KvA/CJkRCpkCsZn55+Yd6JkdAPnnxh3v -7YYAAAAq8D4r8D8IqhELqgKxqvvn5h2oqh0A++fGHa/tBgAAACvwPizwPwi7EQy7ArG7++fmHei7 -HQD758Yd7+yGAAAALPA+LfA/CMwRDcwCscz95+YdqMwdAP3nxh2v7AYAAAAt8D4u8D8I3REO3QKx -3f3n5h3o3R0A/efGHe/rhgDaIFsQWdEPLrBwDwIADwIAse4utHAtMhsI3RH5IBMpUByFAMCg///i -HaAPhQBt+hGmpKOvL/BkJEA070kMdVAFAADwAFANoAoFAO9DBn9QBIAAwKFkr+pgAG/AiG2KEaak -o68v8FwkQDzvSUV1UAUAAO0WACjQBIAA+ABiHaANBQDTD22KEyOgAKbfL/BMsd3TD+85LHVQBQAA -KWAF+MYGHeA41QD4wKYdr+jSAAAAAAAA70MGf1AEgADAocyqY/+vAHPzAcDhZO/PLGRS+ggCHaCL -ZQDqZAUrUASAAFv4NmP5+QAAAAAAAADrPEUg0f0AAPtEIBWgDDUAWC++LxIoKBIs/wMIFaj/HQAv -FigtghkcW4L9wABFcCvVAPegAEbwL+UA7YYZJwu5gAAYWgd9i3MpEij9P81MogCdAGP5nAAAAAAq -sFwssF0IqhEMqgKxqvtrph2oqh0AKrRc2iDrNAAKYASAAO1UAAtwBIAAW/kuY/lnLLBcLbBdCMwR -DcwCscz9a6YdqMwdACy0XNog6zQACmAEgADtVAALcASAAFv8fWP5Ni0wOCgwOdMP6TA6Lu4CgAAI -3QLoMDsu7gKAAAndAgjdEQjdAvugDGRiAJ0A/6AMJGIAnQAvEiguFisqFirs/F9x2VEAANxwWC+C -2iDrEisqYASAAO1UAAtwBIAAW/tHKRIswID5IyYVr+M+ACqwXiywXwiqEQyqArGq+2vmHaiqHQAq -tF71P8hZEgCdAPrGEBXgDGUALGRS+sCmHe/mGgDccFgva9EPLbBxsd39biYd7+IeAC6wcrHu/25G -Ha/h6gAvsHKx//9uRh3v4bYAKLBysYj5bkYdr+GCAAAAACxkUvrAaB2gSQUA+MCmHeCLZQBb98dj -+D8AAC0SKP2/weSiAJ0ALTA4KDA56TA6Lu4CgAAI3QLoMDsu7gKAAAndAgjdEQjdAi0WKXvRB/+/ -wD1iAJ0AGFwTKTEuLhYrKhYq+T/3BSIAnQDaIOxEAAHZUQAA7VQAC3AEgABb+wgcWwUqEiotMDgo -MDkuEivpMDou7gKAAAjdAugwOy7uAoAA+aYADvAr1QD9oAAWsC/lAPmmAA6/+kYAAAAAAADrHBAr -UASAAPwBAh2gDSUAWvhhY/eEAAAfW/ErMS5/sUYYW/AuFisqFip4sVoqEizAkPlDJhXv3ZYAKjBa -81++PhIAnQDzX73+UgCdAPFfvb6SAJ0ACgxD/Z/gFaALBQD9YgAMv96SACgSLS+Aci4SLLH//w5G -HeANBQD9wyYV79xyAAAAAAAA7HQAAdlRAABYLwgZWtEoEijTD/kfuAziAJ0A2iDrEisqYASAAO1U -AAtwBIAAW/rKY/9xAGwQBisgB4gnDwIACwtB5IEqZGCBAACNig8CAOqCCSaI6YAA8VFQDeAfJQCI -oC6gMAiIVygWAv/AFqRj/fUAKaEI/SAXPGBOtQAoIAX1QGgd4EnVAPnBjg2gT6UA/wAG4eIAnQD5 -AAakYD0FAIoSLvrADs4B7aEdfbAEgACIwwxKEao6ro7u7EAtKASAAP9AFpqiAJ0AKDELh1rpWRcU -QxEAAOh3Ng3HAoAA9WARMhIAnQCpiOqCniPg3QAADEwUtMz9QBU7ogCdACaCne9Y6BsDpgAAiiLr -FgAlE6GAAIsSw8B8uVaIJxVbh42KJVJ/5NJRZFCBAACIiYaB9uAAAzALBQDsVAALaASAAFsStIon -2zDqrCAqYASAAFsWV4wgiycIzBEMTALspgEl0IEAAOtUAAtgBIAAWxZQ0Q/RDwAAAAAAAOpbMhPo -3QAA/gAIHeTdHQD8ICYV7/7FAO7RFHP4YQAA6dwEK0AEgADTD22ZAggCYSggB/wgKBWgmBEA7lju -HMqCgAAKmQKZYI0gihKfY+5mAi7uAoAADcwC/MAmFaA7BQB7oR0qIgf6gGgd4AwFAA8CAOqsICpo -BIAAWxKHKCAH1aArIQgIDEHtW1MeZAKAAP1mAA2wDAUAnGUNuwKbZAUEiQYgi51ml2csIAwqbCjn -ZgcuZAKAAOy7AgvgBIAA62YEIdlRAABYLnsqXBn6Z6AV4Aw1AFgud+Ra/BHZBQAA+qOgFaAMNQBY -LnIbWCWKUYgRJ1UL/EDkFeeqAQCaUS4gB+whCCxPAoAA+MAARPrdAQD/oAAWsK4RAPVQABUx7gEA -6t0CD3wCgAAPzAIaWLELzAIE3QKdkI0gnJSblvsgRhWgPwUA/yBmFeAKBQD7IKYVoA9FAOqWBy7u -AoAAD90C7ZYBJPiBAAAFIIYPAmMFAIYPAmEdWI8M7BHtzAgEWBEAAOvGnSlQBIAAWw6n0Q8cV/aK -yPdABLiSAJ0AGViFDGgRqYjugp4j+N0AAA9PFLT//8AE4+IAnQAmgp1kYJOwrf2BBhXv9woAE1nU -KCIeIzJ/CYgR6DMICVAEgABbDpLaMFsOkdEP6iQACdgEgADsRAAK6ASAAFv8u9EPAAAA//bEDaAI -BQAAACu8GOokAAlgBIAAWxfIY/1+AAAAAAD5TwAKv/S2AP/1cA2gBgUA+iAGFeAKBQBYMkQcV8uK -yIsQ+V/6uJIAnQD/9OgNoAYFAMBgwNoNrTT9gQYV7/SuAAAAAAAAAABsEAQaWGIfWpYuIQcoIAcc -V8L8QQQV6u4BAPggAAOwiBEA6ogQD3cCgADo7gILtAKAAAbdAgzdAg/uAp5AhiCdRPyAxhWgCwUA -m0X6gOYV4DkFAPqARhWgCEUA6UYDKzYCgAAIZgLmRgEiEIEAAAMghgICYwMAhgICYRJXowx/EaL/ -lfDRDwAAbBAGGlmKiy0PAgAqon8JuxELqggqogpkoBUrrFz6IGgdoAxFAFgt5/ogCBWgACYAGljw -mhD8sFQFo+uFAAurLAO7KAy7KOsWAClQBIAAWrE/ixAcWDHtWZMZUASAAFqxW9ogWrE+0Q9sEBAa -V5obWW8sMSeNLimyfyggB+8xJi7uQoAArZn7geYNoYgBAC4hN/3AIrUiAJ0AJiE29+AiXSIAnQCO -J2Tg7IrqmB/l4gklIqGAAJke5RYTKVAEgABasSMoIQj8QLAVoA61APQiJhWj//UA/w8AD/BdZQD9 -gCOsYAR1AA/kOfoh6BWj9/UA6hYSIqDhgACJUA8CAA8CAPcAI2RnmcEA9UAgYhIAnQDqV+0dRwKA -AKqILYKe9aAqu6IAnQAogp0jFhDTgOVaLRmDPgAAiiLpFhUlKDGAAGiWU44ni+ojUr3ktLNnUIEA -AIXp51QAAoEZgACFUfTgAALwCwUA7DQACugEgABbEY6KJ+qsICm4BIAAKxIQLBIRWxUwjCArEhEI -zBEMuwLrpgEroFYAANEP9SAkUxIAnQAdV6bTD+0ABQnABIAAbUkCCAJhGVoSLCBBHlj/JyEHDM8J -6FfPH/8CgAD/wABHencBAO7ifyu/AoAACHcCLyEi/kgAAzbeAQD8wAATMO45APemAA69bx0A5e4R -CzUCgAAG7gIWWj3u3QIOZAKAAA3MAu1Z+R/9AoAA9+YAD7AGBQCWFJcwDcwCF1e3jiAmNQqZN/xg -hhWgSoUA+mFkHaBbhQDvNgYh0IEAAPpgZhXgD3UA5zYCL3YCgADv7gIBWSEAAP5gJhWgDMUAWC1W -wID8sbwFoAkFAPhnRh3gBgUA9mcGHaAq5QD6Z2YdoIuVAOs0LCHQ8QAA7DQtIVlxAAD4ZyYdoByF -AFgtRx1aFP5pEBWgBgUAJjRE5jUlIdEVAAD2YoYVr49FAO80PCdwBQAA7jRIINhBAAD8IIYV4Aw1 -AFgtOPqt+AXgCQUAKTRULCBoLDRVLiE2LjUsLyE3+mXkHeBKJQAqNGQpNS4vNS0nIAXFhvjgF4wi -AJ0AxdAtJAUoIQguOv//ABX0IgCdACYSExlZqR9W1y4gByshB/ZACBXgDEUA/gIABTHuAQD5wAAW -ursBAO2NAg3HAoAA790CC94CgADsvAINUoKAAPsGAAwwOgUA+QYADHCZBQDpOQgLA6YAABZZ3vYg -xhWgBiUABrYClheGHitiH5sZJmIelx32IQYVoAslAPolZh3gBgUA9iGGFaALBQArNiErNiMsNh0q -Nh8tNiAvNiIoNhwYV03oNh4gwGEAAAgghgkCYwgAhgkCYRlXNwzoEamI9ROmFaAB8gAqEhMiFheG -oRJZgQYGRwJmApahLDYdLTYgLzYi+GOGFaACBQAiNiEiNiMWVzn2Y8YVoDIFACI2H+ISFy1ABIAA -CGCGCQJnCECGCQJlG1cg6RITL1cCgACrqiSmnYmQ+PgABPA3JQD3IAp0YgCdAMPF/SAKJCIAnQAt -Ov8tJQguIAUZWG3+CsId78sFAP/ADpxgDQUAjCftxgomUIEAAAuqAesiDiVRAQAAmsmayIosKZJ/ -6CILLd5CgADrmQgNAG4AAPkhJhWgAB4AAJir8QBgDeAOBQCajJ4riJvuJgwkAEGAAJKMmCuSm/pA -aB2gCzUAW/7G0Q/akOs0AApgBIAA/KBoHeCOVQBYAV7RDwAAAMBQ+CHGFe/usgAA/+/QDaAJBQAV -VliOWCkWFffACviSAJ0AKBISGlbmDIgRqogvgp714AtjogCdACiCnWSBY+MWECdT/QAAmljzAGgd -7+9uAIweLcAF/YYGHeBLNQD7gKYd7+36AAAAAAAA+T/co1IAnQCPJ//kABWvxgUA98AEBzAJBQDp -9goncQEAAJ75/+EGFa/twgCKJ9tw6qwgKuAEgABbFCbRDyshFCMhEsBA6xYUJfWhgADqUkIp2ASA -APwAAh2gDRUAWxAgJlJDLBIU5EwBIZgFAAAGMy58Sdhj/oUAKBISGVa2DIgRqYj1E6YVr/nyAAAA -AAAA/+08DaAFBQAcWT+NIPhBBBXgClUA+CAGFeA7JQBYMDBj/PwAAACKJy0SEcDA6qwgLtgEgABb -EFz6ImYVr+2SAACLH9og67wYKWAEgABbFf4pEhVj+ugAABxZLI0g/kbEFaAKVQD+RuQV4DslAFgw -HNogWwyx0Q8AwIDyIgYV7+q2AADAoFgwdY5YKRIV+d/0uJIAnQDAgPIiBhXv+s4AAAAAAAAAAMCA -8iIGFeAMpQAM7DT8oQYVr/peAABsEAYXV9uMLSdyf+hY+h5mQoAArHyMx/pByBWgT7UA+meQFeBG -pQD9gcgVoE6FAPlHJg2gjRUACaoRqnqHp4d+fbFlLSAF/6AJFCIAnQB98hV20hItCoT9YA/kYI5V -AP9gCQwiAJ0A0Q8AAAD9YAzMYgCdAC0gBf+gFvQiAJ0A/eAMI2IAnQD3oAvjIgCdAC8KhP9gDgxi -AJ0AKAqF+WAVXCIAnQDRDwAAKcBgK8Bh7cBiLM4CgAALmQLrwGMszgKAAA2ZAgiZEQuZArGZ+Yxm -HeiZHQD5jEYd6JkdAPmMJh3omR0A6cRgJQIhgAArcDwscD3tcD4t3gKAAAy7AuxwPy3eAoAADbsC -CLsRDLsCK7wB+ufmHei7HQD658Yd6LsdAPrnph3oux0AK3Q8K6AFxMD7gc4N4E4lAMPe/X/5OeIA -nQD/f/j8IFgFAC8gBfngDwwiAJ0A6iQACdgEgADsRAAK6ASAAFv+EdEPKcBssZnpxGwld5GAACpw -c7GqKnRz0Q8AK8BtsbvrxG0lAhmAACxwdC1wde5wdi5mAoAADcwC7XB3LmYCgAAOzAIIzBENzAKx -zPzu5h2ozB0A/O7GHajMHQD87qYdqMwdACx0dMRt5FeIGVAEgABary3mJAUq6ASAAOhCSylQBIAA -+GTkFeALBQD4RuQd4AwFAAuAANogWwwe0Q/RDyvAYC3AYe7AYi3eAoAADbsC7cBjLd4CgAAOuwII -uxENuwL7YCAV4AoFAPuMZh3oux0A+4xGHei7HQD7jCYd6LsdAPuMBh3v+3oAAAAAAMRN5ldmGVAE -gABarwvkJAUq6ASAAOhiSylQBIAA+GTkFeALBQD4RuQd4AwFAAuAACowVNMP9UAGpxIAnQAaVzeL -LIwuKqJ/6SILLmZCgADsqggNgGYAAPlBJhXgABoAmbvIkJucwLCbK4mr6yYMJIBBgACSnJkrkqsa -VyiLLQ8CACqifwm7EauqKqIKZKAVK6xc+iBoHaAMRQBYK4X6IAgVoAAmABpWjpoQHFXIKzroC6ss -DLso6xYAKVAEgABart6LEBxV0O1XMhlQBIAAWq762iBart3RDwAAAAAA6zQACmAEgAD8oGgd4I5F -AFgAHdEPAAAALcBtsd39jaYd7/nuAC7AbLHuLsRs0Q8ALzEuZf8pKDEvZY8jKiBoKTBVsar7P/jF -IgCdANogWwu+0Q8AbBAEwHBtShGieKN0JEAAKIAA5IkOc7gFAADAINEPAAAAAAAA9QEWDa/y9QDA -IdEP0Q8AAGwQCBpWzx5VkS0gB5cU5VbpGsgEgAD6SnAV4A8FAOciFSpgBIAA9K/oFeHdAQDruwkO -xwKAAO6ICA3fAoAA+0AARXAEZQDrISIrvkKAAPagAELwDnUA/iAGFeCHRQDnZwwKeASAAAfvOC6C -np0SKqJ//8AQo+IAnQAngp0vCgH4EIIdoA51AOhoDAOP8YAA/KqYBeAMBQAI/DgM5DntAAULwASA -AG1JAggCYRhVdy8hB/pIAAa2mgEA/aAAFrCqOQD9JgAM/dsdAOWqEQ7tAoAA/UYADXr/AQDqmQIP -/wKAAAj/Ap9wLiIAHVVoLXYC7VerH3YCgADuTgIN1QKAAP7gJhWgX4UA/UYADXBeBQD97QAPME+F -AP7gZhWgTgUADP45+K9QFaANBQAtdQoqdgbsV5UcRAKAAAmIAhlXkS51C+x2ByFZGQAA6YgCA9CB -AAD44IYVoAxlAFgq/CtcaPrkwBWgDGUAWCr5JnQ8/q0ABaAJBQD46IYd4AgFAPjnRh2gCgUAKnQ5 -/uWmHaCPlQD+5YYd4CXlAPTnZh3gCwUAK3Q4FVSuKzEmKjEnLTBALDBJLHRJLXRAKnUnKDEnK3Um -KXRI9QAFxGANBQAqfEH6SeAV4Aw1AFgq3SssTPrnoBWgDDUAWCrZH1YpKDBFjRAeV6kAiDII/Tvu -3QID0RUAAOjdEQjYBIAA/CAGFeAMNQBYKs74EIId4AuVAPjFJg3gDgUAK3RV/urmHaBMJQD864Yd -oA01AC10VooSG1UEDKoRq6okpp3RD8Cg+uqGHa/89QAsdFUrMSYrdSwpMScldS8qdS745aQd4Egl -ACh0ZI8SGFT2DP8RqP8k9p3RDwD85OQd7/0iAACOIpwRmRPllAAHAmmAAPyvAAWgClUA/mTEFaA7 -JQDvMScq6ASAAFgubgUPR2jyAdEPiieLEYmqiKsMuxGrmemD7XVQgQAA7BIBKdgEgABbEj3RDwAA -AADr3BgsqASAAOokAAlgBIAAWxQ3Y/+gAABsEAYbV0cCLAkMzBGsuyuyf2Sw5/AALA2r4wEAAACL -uWSw2CixGQgIS3jp8Ya6ZG/s+gACHaAJZQBtmhGkraasLMBoLdAA7NkOdVAFAADAoPAAVA2gDWUA -/YDWDe/69QDAoWWgZ2P/5QBt2hGkraasLMBuLdAG7NlGdVAFAACCatMPZCBq7UwGIhiFAADtFgAi -OHUAANsw+kmAFaAMNQBb/w3Mrdtw+kngFaAMNQBb/wnKqIIoZS/cYAA0AAAAAAD9gNYN7/r1AMCh -ZK+whmnAoP7WTA3gCWUAY/9BACosRvogCBXgDGUAW/76Za/E1iDJZC5gBGjkG8Ag0Q/AYPagBhWg -AgUA0Q/2oAYVoAIFANEPAACCacor+gACHaAPNQDTD236EaSsoqsrsF0swCHryR11UAUAAC0hNixB -Fn3BH4IrZS/SllDRDwAAAAAAAAD9YNYNr/r1AMChZa/iY//WklDRD2wQDvin4gWgCgUAmhCJNBtW -VeVT9RGQuQAA+QZoFaOZgQD1ICMaUgCdACVSgKiYCYgRqFWFV6ubK7CAhV7xYCJHkgCdACRdASpB -gmSkOvpkwBXiWiUA+qAARTAMZQBYKiQfVvcsGoCsXO7wAiDYEQAALrQC/+AEFeAJBQD/YAQd4A01 -AO9BoC5QBIAAZNFRZtFObdoXDQEwDQAxLdw0Ld0BDQExAAIADQIwLdwBLbAALqDS6qwBJdgFAAD/ -oAkEIgCdAOnE5yeg+YAAKTELwY35AB2q4gCdAJQU+rCIFaAGBQD2IeYVoA4FAP4iJhWia4UA+qAA -RfAPBQD+IcYV4nl1APigAETwCAUA+CEGFaKcVQD8oABGMp0VAK1dnRqcG/gg5hXieJUAqFj6IYYV -4m/1AP6gAEfyjnUArl6eFi8WDfghJhWiiyUA+qAARfAHBQDrFhAlUAUAAPqwhhWgBgUAuBr6QGgd -4AwlAFgp4SQRBPhhZBXo1AEA96AAQzZESQDmbAIu8ASAAP6AaB3vZgEA+MAXuuIAnQDgQAQCID+A -AAcIG/MAHEfSAJ0A9+AOIpIAnQBr9jRk0tGeE/WgFmfSAJ0A+iIIFaAMlQDs3DQBWAkAAFgpxv4g -aBWgAWYA0w//+3gNoAkVAAAAAPfgCSQQCIUAf4InZNKRnhP1oBRn0gCdAPohaBWgDMUA7Nw0AVgJ -AABYKbb+IGgVoABmAC0Kf33xNi9Shw8CAA8CAC/8AS9Wh+oSESdACQAA6CIICgIKgAD0gBFSUJed -APMgET/SAJ0AYAI0AAAAAADuFgMo0ASAAPpAQBXgDEUAWCmgjRAaVnT+IGgVqP0dAPvrhg2n3QEA -GFX5ePmpwJh9m6TArH2jn44eGFX07BIDIVgZAACbGOhWgid4BQAA/Z+AFafvAQD+IcYVp8wBAOwW -BSrQBIAAW99XKVKJ7hIDJMgFAAD4sSYV7/1+AAAAAPmgEIFSAJ0AH1ZYLBIR71aCIVAZAADqFggn -W/EAAP2AIBXnuwEA+iCmFefNAQD8IiYVr/yaAAAAavcs+f/4VBIAnQBk0WmeE/WgCyfSAJ0A+iFI -FaAMRQDs3DQBWAkAAFgpbI4TY/7v+f/261IAnQBk0TyeE/WgCb/SAJ0A+iDIFaAMpQDs3DQBWAkA -AFgpYY4TY/7CAAAA9+AFYRIAnQBr8zRk0QmeE/WgCCfSAJ0A+iGoFaAMhQDs3DQBWAkAAFgpVP4g -aBWgCEUACHcC//oYDad3AQAAAGr0LPn/81KSAJ0AZNDJnhP1oAYn0gCdAPohKBWgDJUA7Nw0AVgJ -AABYKUSOE2P+T/n/8enSAJ0A7hYDKAQKgAD5oAShUgCdAPog6BWgDCUA7Nw0AVgJAACbH1gpOP4g -aBWgCIUACHcC//hQDad3AQBq8Tj5/+/REgCdAG7SWe4WAyb5W4AA+iGIFaAMdQDs3DQBWAkAAFgp -Kf4gaBWgCCUACHcC//dgDad3AQBl/cHO1cCBCHcC//cYDad3AQDAnnl5FPVABKlSAJ0AZUzejR/K -3GAAF9EPACxShStShrHM7FaFJdgFAAArVobRD/ugaB3iWsUA+qAARTAMJQBYKQ+LHuwSES3+fgAA -acHHjRhk38KOFC7hrmTvugVaAuwSBS7YBIAAW92KL1KJsf8vVonRDyhSg7GIKFaD0Q8rUocqUoUp -Uoaxu+tWhyVQBQAA6laFJMgFAAApVobRDy5SjS1ShSxShrHu7laNJugFAADtVoUmYAUAACxWhtEP -KVKIKFKFL1KGsZnpVogkQAUAAOhWhSf4BQAAL1aG0Q9sECTkMgQqcASAAN8g8qjCBaNEgQAERAkM -RBEEIggkIn9kQOcvFjkaU2D4pSYF4YgFAAgoCCiAgCmSLSUWOCqiaemICApYBIAA7hY3LEZCgAD5 -QABFMAwVAFgiLiswMSkwMC8wNy4wNiUwNOYwNS1oBIAA6qAHL3YCgADv7gIKrgKAAOZVAgHg4QAA -5iKCLM4CgADrmQIOOASAAPphRBXhqgEA7zAzIwM5gACIZ4iOKBY9aJEu/SvgAVAO5QD1IATpkgCd -AGmUQ2nyQMttLBYz7RY1IcjpAAD4J4YV4ARSAAAAAAD14CHIkgCdAGnyHIo2+iaGFeGqkQDsFjMt -E74AABtVffvAI0xgCgUA0Q/AgPgnphWv/noAaPHwafLtGVMiKZF/8SAMp1IAnQAuMDjAqH6i12rn -1PXALXOSAJ0ALBI9K8EXK7wBK8UXKhI5LBI37RI4KdgEgABb5NbRD2jxqmnyp2RfpPQAAh2gE0UA -/CZmFaADjgAAAChwAQeHCqSEdUtjKXAAf5nuLnACKHADKmEZCO4RCO4C+2AABTvuAQB66dQoGoCo -KCiAewOIEQjoAihlGSgSMi+BD9pg7BI3KdgEgADtEjgn+AUAAP8B5B3gDgUAW+NZKXABB5cKpJT0 -lBYN4A/lAIZp0w/TD8tsKhI1DwIAKqAW6mQWI1kBAAD6J4gVoAxlAFvknv9djA3gD+UAiWf2JmgV -4AQFAOmSDiL+MYAA+CZGFe/9agDRDwAAAAD7X/alYgCdABxTPNMP0w8MMwEtcAEH1wqk1PSAJTri -AJ0AKnAAaKIy/VqAglALtQAmIoLG7+4zAQN0+YAAtH8vFi4qEi76yQAV4AxlAFvkgGSvvoZpZW/p -Y/58JiKCx4voMwEDc6GAALJ5KRY7KhI7+sgAFeAMZQBb5HVkr5OGaWVv6WP+UQAAGFHviTMSUrko -gh0iImmpiAmIEagiiSeLmmSyW4uZh7AVUnH3YGgdoAylAPVAEooXd8EADKoRpaooop7/ACwLogCd -ACmindWQ8Kh8DeA/BQCLImS0vf7/771iAJ0AiScVVOSMmiVSf+TEnWTQgQAAi5mGsfygaB2nZgEA -/MBoHeALBQBbDBGKJ9sw7BI3JVCBAABbD7SNICwSN4snCN0RDcwC7KYBJdCBAADrVAALYASAAFsP -rNEPANrQ68QAD2gEgADuEjQq4ASAAFvmtdEPAAAAAC4gBxhUiA4rQO0WNS3agoAACLsCm1CIIBpS -TvqgRhWgicUA6VYDLEYCgAAMiAKYUX9xGYonLRI3wMDqrCAu2ASAAFsL7O4gBy0wBIAALCEIDg1B -61S3HuwCgAD9hgAOcA0FAC1WBQvMAixWBAYEieUgFwLQoQAA+qDGFeB8RQDsVgch2VEAAFgn4hdS -Y4gt0w8ncmkJiBEPAgD44ABDsMulAOs7CAPRoQAA+ibGFaAMZQBYJ9fqfEgh2PUAAPonRhXgDDUA -WCfSG1IZHFGM7VOYG9AEgABaq1DacFqrMysSOvrDIBWgDDUAWCfJKzxB+sOgFaAMNQBYJ8YjEjaI -YfrAaB3gB0UA+kBoHaCsBQD8oABGN4gBAPjAJhWgDeUAW/mpFlJZH1NjHVJnFVNdHlNq/IYADvAI -BQCYX5hemF2YXJhbmFqYWZhYmFeYVphVmFSYU5hSKFYBmFDn5j8p2ASAAP/QBB3gDGUA7eY+ItAp -AABYJ6coYo3qEjUq2ASAAPwAgh2gDVUAC4AA2iBbB/3RDyoSPSmgOLGZKaQ40Q8AAAAAAAD/9ogN -oAsFAB9RRo/4KhY+9+AZ4JIAnQAMqhGlqiiinv8AGruiAJ0AKaKdZJNOHlE8sPub6PUgaB3v9l4A -KxIz6hYAKuAEgADvFAAO0ASAAO4SNC9oBIAAW+G6Zat5ihD1X9ugEgCdAB9SAyPyaQmoEagzizeL -vimxDCmcAflhhB3gKFUAKDQFL/F/8f/aT1IAnQAiMgpkIhj4pdIF4AsFAPogRhXuCgUA6hYBIMBB -AAD4AAoV4BlVAG2aAggAiupTJRDgIQAAKcACKMABKhYE/kAIFaAPRQAvFEAswADvFCgg6KUAACjU -AenUAiDAEQAAK4AALNQA+wAwFaAMBQAsFCMsFEH8KEYdoA+1AOwUQy92AoAAD+4C/iCmFaP99QAt -FRDogAIgyLUAACuUACqUAeocRCFZQQAA+SBGHaAcBQBYJ0oqHFT6SAAV4AyFAFgnRyocXPpHABXg -DIUAWCdD6yxgINH9AAD7QKAVoAyFAFgnPsKAKBRF+CiGHaAJBQApFJQpFHQpFGSOKO9Q8xlQBIAA -7xUkINhBAAD/wyQVoAy1AP5E5B2gDSUAW+Z7wqsqJAXRDywSPSvBFbG7+4KkHe/pWgBlOg/2JmgV -4AQFAPAAZA2gD7UAAIM5zzktcAEH1wqk1PSABLrgD7UALnAAf+npZGnhiWrjlAAE/wmAAOkWLyPQ -JQAA6hYxI8AxAADoFjAjkAkAANog+m0AFeAMZQBb40tlr7AqEjH6aQAV4Aw1AFvjR2WvnyoSMPpo -ABXgDGUAW+NCZa+OKxIv82AHfGIAnQAssAXC3P2f+/1iAJ0A+mBoHaALFQBb6c7aMFvpUfpgaB2g -WxUAW+LrY/9cjmeO7i3hELHdLeUQ0Q8AAP/tlA2gCwUAAAAA2iD8QGgdoBvFAFsQkv/sxA2gPwUA -AAAbUpIfUQocUYvvAAUNyASAAAkCYQkCYQkCYQkCYR1TvijCqx5Sl4kwH1GN/8fmFeAKBQD7yAYV -oPL1AP0mAAzwDEUA+8gmFaANVQDp5j4p0ASAAAuAABtSiyuyPwuLFHsoHBhQgxlSdBJRViiCniIi -aQmIAQmIEfhAAEE/9bIAijeKrimgN7GZKaQ30Q8A2mBb6mVj/pT/6ggNoAkFAPwmphXgCgUAWCrq -H1Bxj/gtEjX6J8gVoA7lAPn/5UiQDKUA//L4DaAJBQDAkBpQaAz4NPlBBhWv8roAAGwQBBNSiioy -f1sR8NSg6CEMbSgEgADSoNEPAAAAACoyf1sR6upJMn0QBIAAYABMAAAAAADqMn8q2ASAAPwAAh2g -DRUAWwpJ6jJ/KSgEgABbEd/qQSZ9EASAALFYeCnU6jKAKtgEgAD8ACIdoA0FAFsKP9JQ0Q8AAAAA -AADqMn8q2ASAAPwAAh2gDRUAWwo3xyTRDwBsEAT0ptQFoAMVAAQkCyRCoShBAyRBAviPAAowAgUA -BDI40Q9sEAguIQiMJyUgBxNTD/mBSBWgP0UA9H/iHaAHBQD6d6gV4VUBAOSCamZQgQAAhsmWEvXA -IAwiAJ0AjmD6IAYV507BAP6AFiRnjgEA/wAV5GAJBQD4ICYV4ApFAOoWAyv4BIAA6FRYasAEgAAZ -UK/tEgMqxwKAAKmILIKes939gB5T4gCdAC6CnWXgaWhNCRpRZIsSCkoCmrDI/YonixD7RAAVoAwl -AFsM7osiZbHf2iDsJAAC2GEAAFsP/MAg0Q8bUAeMuJUU94AcSJIAnQAZUJbuEgMsRwKAAKmILYKe -s+7/oBybogCdAC6CnWTjirDKmrhk75UdUGmLEx9TJvwACB3v/NUA/WJGDaAdhQDpvAMvQASAAG2Z -AggCYRxTHSohB4kSG1CQ+KYyBaqqAQDlkQgtVwKAAAurApvgiyCX6Zfol+af5Zjn/cBmFeAINQDs -vAIN3gKAAAi4ApzkmOEYUIKY4oyRwPTvvwIKrgKAAPhBBBWnzAEADFUClZGFE4kR9IANxpIAnQAs -IAezVfSfsgWh3AEA+aAAFbDMEQDriwIOYoKAAOS7AgdBQQAA5FKjHIK+AACf7SfmESfmEyvmEBlQ -aRtPzJnu+8JGFeA5BQCZ74sSDKkCBJkC+cGGFeA2JQALIIYIAmMLAIYIAmEZUE7kEgIuxwKAAKmI -JYadhEDwAVwNp0TBAClgFPE0YA3gNiUAJ+YTJ+YRn+0r5hAZUFKZ7v1GAA2wOQUAme8EuwKb7IsR -GU+vKeYSC2CGCAJnC0CGCAJlGVA45BIBLscCgACpiCWGnYRABIRX9o7GDaA6VQB6QW6MJ/uEABXv -zQUADbsB58YKJdkBAACbyevGCClQBIAAWqlKLiAVZOC8wCDRDwDrFgArsASAAPXADLwiAJ0AiHAI -hFd/QV8ICUd/kVn+AAId4AxFAPwgZhWgCwUA+iAmFeAKBQD6IEYVr/ZaAAAAAAAmIRQkIRL+2HAN -4AUFAOoyQipYBIAA/AACHaANFQBbCW8oMkPlXAEiIAUAAAhELnZZ22P/WwDAsPwgCBWgDSUAWwm9 -mhEoYBSJEOkWAi0AVgAAZY9jYAACZIEOwKSaE//0rA2gDxUAjRKM0AjMEP2gBhWv+QYA2iBbBhPA -INEPACfmEZ/tK+YQGlI3GVABFE9kJOYS+cHGFeA9BQCd74kRCsYCluwmkQiNkYSQ/MAAEzfdAQD8 -xgALd0TBAPcgJhWgNiUAdkEGhBKEQASEV4kRCaCGCAJrCYCGCAJpLCEHLSAH/kEEFeCYBQD5wABE -OswBAPwgAAXw3REA6t0QDcwCgADp/wIOZwKAAA3MAhlP4R1PQwrMAizmHIwgJ+YhJ+YjLeYiKeYe -/eYAD/A5BQAp5h8v5iD9gAAWMA1FAA3MAizmHYkSCeCGCAJvCcCGCAJtHE/ADLoRrKr1U6YV7/im -ANogWwXYwCDRD8DY/CBmFe/7vgAAAP/w5A2gDgUA/iCmFeAKBQBYKZgbTx+MuI8ViBT5n+MYkgCd -AP/x/A2gDgUAwODAigjINPlhBhWv8cIAAGwQDCgxCPqhtgWj+fUA+QAFHGIAnQAeTxUbTxIKAInq -TxIYyASAAAkAigkAigkAigkAigkAigkAigkAigkAioggmhL+IMYVoAlFAOsWACxGAoAACYgCmBEv -IActMQgPD0EA/xEP3QIO3QKdFAzqMPwgphWgCwUA6xYHIMiBAAADIIYJAmMDAIYJAmHrIgcq5gKA -AAxMApwZjLrtsgkl0IEAAO6yCyYBMYAA5NAeZnkBAAB/6wbRDwAAAAAA+iBoHeAMRQBbDNbRDwAA -AOokAAjYBIAA/ACCHaANJQBa7mnRDwAAAGwQBiMgUIQo+kBoHaALhQDtFAAJ4ASAAFr8N/FFMA3n -VQEAHU9rLEIADcwCLKYAG07S6BIAKc8CgAD7IABE8AMFAOiWACKUiQAAKiIH+gAiHeAMBQD7RAAV -oA0VAFsJEPNAaB3gABIA2iBbUsnSMNEPACs8GOokAAlgBIAAWw6w+r/AFeAMFQALyznsT1AZUASA -AFr788Ag0Q8AAAAAAABsEAgcUeIkMgX+YIgVoApVAPienAWgOwUA9WgAAbdEAQD0IAYVp/7BAOju -AQnoBIAAWCjBGU6wGE+QKZIkHFHUKIKIo5PvIAUpnkKAAKOD/GCwFeAKVQD+YYgVoDsFAFgotsKj -+oAFzCArVQD6gAWMYCxFAPyABUwiAJ0A9IAFDhB+BQAtMAX/oAS0IgCdAC8iEYg4ZPDw6SAEJAep -gADBd+0yESSHmYAAyNvaMPpiSBXgDBUAC9AAFk8e5U8YEgQZgADBtntBeWhDdndBcyIwUIQ4+mBo -HaALhQDsJAAA6EEAAFr73c+rKywY6jQACeAEgABbDmvaMPyeGgWgCwUAWvuvwCDRDwCOQAbuAp6g -DC0Rpd2MFezWnSnQBIAAW1J0wCDRD4lABpkCmaAMKBGliI8U74adKdAEgABbUm3AINEPhDgiMFD6 -YGgdoAuFAPwigBXgfBUA7DQFKWAEgABa+75lr6IrLBjqNAAJ4ASAAFsOS9ow/J3aBaALBQBa+5DA -INEPAAAAAPJCJhXv/C4A8mEGFa/8LgD2QIYd7/w2AGwQBCUkA+RJEAnGAoAA+QYADHAJFQD5BgAM -cAYFACYkAOgmASEQQQAA0Q8AbBAEGE5jG09eHE8U6DgCCW+CgACr2/l9ZhWgCVUAKrLreqYjsJnK -kg7qMCrCRa6qDuowDq4MauHkbQgID+owD68MavHYY//wwCDRDxxPThhRXh5OT/oAIh2gC4UA+aAA -RrAPBQBYKEHHK9EPbBAEIyRy+kBoHaALFQBbDY3aIFsORdKg0Q8AAGwQBooscqYO6E8UHQBqAAAI -qAKYLNEP0Q8cT8kdT6orIAUMrAENzAH8QYYVoHklAPl8Zg3gfQUAfbHbIyBQJCII+kBoHaALhQDt -FAAJ4ASAAFr7bM2sKzwY6iQACWAEgABbDfraIPydOAWgCwUAWvs/0Q8AG06aiUALmQLppgApUASA -ABhOAO4SACn/AoAAqP+e8FtSAtEPbBAIhiiIIiRiEQUDR+RAUCQBGYAA/GNggVAIFQAlPP4FhTna -IOxRIRrYBIAAWvspwCDRDxxRHy0gBI4gjy70f8AV4AkVAAWVOfQgBhWgClUA9CAmFeA7BQBYJ/wX -URaKcGSg8vpAaB2gGwUA7RwQKmAEgABa+z1koMsfUQ+OLvyc2AWgDRUALaQJD+4C/0AGFaAFBQDl -dgAqXwKAAKy7ihQqtp3rYCIrUASAAFsHq4gsKQpy5WQjJAnGgAAqIAX5TMYN4HsFAHuhXiQgUIUo -+kBoHaALhQDsRAAA6FEAAFr7I86hK0wY6iQACWAEgABbDbHaIPycpgWgCwUAWvr1aTIpwCDRDwAY -Tk+PUAj/Ap+gHk5H7BIFKm8CgACu3ezWnSlQBIAAW1G3aDLViif6ACId4AwFAPtEABWgDRUAWwf1 -0qDRDwArTBjqJAAJYASAAFsNmGP+y7Gr7CQACVAEgADrdgAiWGEAAFsNkmP+swBsEAgcUNLtIgAq -eASAAP5AkBWgClUA9CAGFeA7BQBYJ68cUMuNNC4wFy8yBvhg6BWgClUA+CAGFaA7BQBYJ6cpIAT6 -RFAV4Bp1APsgBTQiAJ0AyLjaIFsHZcCwKyQjKjAF+g7CHeB8RQD9QAR8IH11APuqDg2gAgUA+0kO -DeB+JQD/SAYNoH8FAH+hOCIwUIQ4+mBoHaALhQDsJAAA6EEAAFr61s2vKywY6jQACeAEgABbDWTa -MPycDAWgCwUAWvqpwCDRD9EPHE4Di0AMuwKboBpNaugSBClPAoAAqpnolgAp0ASAAFtRa8Ag0Q8A -AAAAAAAA8kIoFe/9agArNAX6QKYd4AIFANEPAAAAbBAEJCIRH033jTQcUI/+YvAVoApVAP+gBAbw -OwUAWCdsKDAXwpp5gRfrICIpUASAAFsHK8Cg6iQjKlAEgABb/yvAINEPAAAAbBAEJCIRH03lLTIE -HFB+/mLwFaAKVQD/oAQG8DsFAFgnWiowF8KD+U2mDaApVQD5TKYN4CtFAHuhXYlMG06K/yHgCFB8 -hQAsRAULnQKdTCwkBS1CEfGh8A3gHkUA/0jmDaAf9QD/RuYN7/z1AOtCEipQBIAAC9AAGU7biEz6 -gGgdoAsFAPkABARwDAUA+IGGFaANJQBb/ynAINEPAAAAAP//JA2gDDUA//8EDaAMJQBsEAgiIhFk -IKEcUFOIKC0iAC8gBS6CAPkAsBWgClUA+CAGFaA7BQBYJywuIAUpCnP5z4YN4HpFAPvABOQge2UA -+8qeDeB8JQD9yYYNoH0FAH3hRCMgUIQo+kBoHaALhQDsNAAA6EEAAFr6Y2SgfhtNmIlADwIAC5kC -KaYAGEz/7hIEKf8CgAAI/wju9gApUASAAFtQ/y4gBfxACBXgClUA/KBeBaA7BQBYJwvAINEPAC0i -EY4oLAp1LCQF7OQFJoCJgADaIPpCSBXgDBUAC9AA/kCwFa//EgCIKC8Kdy8kBS+EBf5AsBWv/sYA -AAArPBjqJAAJYASAAFsM0dog/JrmBaALBQBa+hZj/4kAbBAEKCBywJQJiALoJHIpUASAAFsM+NKg -0Q8AAGwQCi0gDR5M2eYgByrYBIAA/EGQFad7AQDq4jUmhzmAABhNx6jIKIB9JeIurYioVQlVEaWl -JVyA9OAIqRFmAQCJImWRQipQDfFE0A3gCQUAGk/6KqCAGE0o601aHS4CgAD0ISYV51UBAAhVCihS -kAuqAQuAAAoJQWiRB/kgCwnSAJ0AKFKWihkLgADppAANAFYAAGABLQAAABVNPmhkdAxqEaWqK6Ke -92AJUlIAnQArop2UGOS0AAWIYYAAyJuKMPphABXjqgEAWp922iDrRAAJ4ASAAFsKFQxsEfWAAEZw -C0UA68adI5RlAACKJ40YwMDqrCAu2ASAAFsG39Kg0Q/AINEPJeItrFUJVRH1QABC//yiABxMjYzI -mRr3gAZIkgCdAAxqEaWqLaKe96AGulIAnQArop1ksM4eTIPkFggma/0AAJ3o5LQADfuWAABgAHKI -J/kEABXvygUA+yAEBLAPBQDvhgokyQEAAJmJ6YYIKVAEgABa+V8rIAT5f/YMUgCdAGAAlwAAaHIF -wCDRDwAAiifAsPtEABWgDDUAWwpdHU19naCMIPqfSgXgDTUA66YCLmYCgAANzAL9QCYVoAIFANEP -K2wY6iQACWAEgABbDFJj/7LAsPQhBhWv+2YAAP/6nA2gCgUAwKBYJtAcTFaMyIka+Z/5WJIAnQDA -sPQhBhWv/RIAwLAeTFD0IQYVoA2lAA3NNP3BBhXv/LIAH0y66yEJKMgEgAD+AAgd4A4lAG3qAgkC -YRlPgvogaB2gCGUAbYoSKqz87KIIJOgTAADs1gAkyBEAABlPe/qYdgWgDmUA0w9t6g/vogckyBEA -AO+WByVT8QAAHE9yGE1BGk0pCLgC+Z/mFaPrhQCwu8i0KcL/eaj1wKD6QKYdr/aSAGwQCPqcrgXg -DSUAnRGbEI8yDw9fLxUELiAMLCANCO4RDswCLBUFKSEJmxDtFgEpUASAAOkWAyDAQQAA8ghoHeAM -BQDoDAAI2ASAAFv/RdEPbBAEGE0G0w8ISAoogtTqJAAJ2ASAAAuAANEPAGwQBvaZyAWhF0UAByco -p2YXT0sjZuUncn/rT0kb0ASAAFgqhuW0AA0gBIAA+mBoHaBrRQBYKoH8AAIdoG1FAFgpudpA82Bo -HeAMBQDrVAAJ6ASAAFgps++xLm3wBIAAGk1VGU6fAigL7E83HEbCgACpiCyGxfrc5hWgCSUAKWbm -K4bBK2bo0Q8AkxAcTy+bEx9MAhtMAfyajgXgCjUA7RYCK89CgAALmSz9IwAM8CsFAOkWASloBIAA -WCX6HEv3H009Hk6HAi0L6E8fHu7CgACu3SjWxf7c5hXgDiUALmbmLNbBLGbo0Q9sEAb0mVQFoRhF -AAgoKAhECOpC5SnYBIAAWCpO/AACHaBtRQBYKYUVTwvTDyVSf9Ow608JGtAEgABYKkb8YGgd4AwF -AFgpfe+xLm3wBIAAGk0fGU5pAigL7E8BHEbCgACpiCyGxfqc5hWgCSUAKUbmK4bBK0bo0Q8AkxAc -TvmbEx9LzBtLy/yaIgXgCjUA7RYCKs9CgAALmSz9IwAM8CsFAOkWASloBIAAWCXEHEvBH00HHk5R -Ai0L6E7pHu7CgACu3SjWxf6c5hXgDiUALkbmLNbBLEbo0Q8AAAAAbBAEKTAI1FDxImAN7+ylAGiR -DupEAAnYBIAAWCf3wCDRDykwCcqX/SOgAN/spQBj/+ApMAnKn2mR2P37Qh2v/1YAAAAAAAAA/ftC -Ha//HgDrPAgpUASAAFsByf1AaB2v/tIAAAAAAADrPAgpUASAAFsCC/1AaB2v/nIAAGwQBB5N9C/i -WinibtpQ6zQAB4lRgAAJyVNkkR/5IAh40gCdAIkwjSAj4qD31KgVoCUFAPOvAAnwFwUA8SAFapAE -FQDoIRouzkKAAKlmGU6vjWqMs4Jr6d0BBAFRgAB/xwUYTF0I3QJ7xwUpCoAJ3QJ8xwTEgAjdAn3H -AgXdAn7HAgfdAv0wAASz+PUA+SGGDaAMBQB/OxJgABEAABlMqQndAv5g1g3gDBUAwGAYTRjD+i+G -ECKGEcObKYYQLYYRGU2jiIAfS2jpiAEJzgKAAAmIAgWIAg+PAgz4ORlNDOiWACMAQYAAnWqSa4mw -H0tNeZY8L/IwLeKlo/8J/xGv3Y3aDQxZAMwRBMgC7Yw6BuAcgAAHzAJ51wTAiAjMAnrXBMCUCcwC -e9cEwNINzAKcs8DAWCeSwCDRDwAAAAD99yIdr//GAGwQBIkw6lQACdgEgADsTm8UqKKAAHmWF4/A -iMGYs5+yjcKOw561nbSIxYnEmbaYt8DAWCeBwCDRDxlOZSmSrnGWB/33Ih2v/7IAiTIJyVNvki39 -JKAA0Q/FAImyjbOdwZnAj7SItZjDn8KNto63nsWdxImwY/+dAAAAAI4zf+jZ//64Da/spQBsEAQZ -TMoaTU8YS5H2mAAF6WIBAPrGAAswAgUA9z9mFaAFpQDTD21aDSqS+wirAeexCHEQBQAAxyDRDwqt -SfxgBhXpygEA/IAGFaACBQDRD2wQCh1LAOZLIBl4BIAALPANlRXr8AwpkASAAONigyYcCYAAKm35 -qroqoH0p0i6sqqqZCZkRqTkpnIAtkRMukRIs8RorIQSt7uTAH2dz/QAAZLPJwoD7AB4j4gCdACkh -BQuZCPmAHbPiAJ0AiyAUTJvxYAxikgCdACohBe0WAyUhYYAA+AAiHaAJBQD9AgAMsAsFAAmLOOkW -BiWcsYAAKiEFJ/EZIyEE6ncIAShBAADzQBzf0HeNAPYCgh2gDAUAnxL2YBdpUAoFAP5gaB3hgx0A -bYlgiVAAYAQJAxnwz4AN6TMBACZs9gBgBAkLGfDPcA3puwEAJmz2/WAHs+IAnQD7wAdz4gCdAPxg -BzPiAJ0A88AG8+IAnQCnqea4EQzLAoAACYgC6DgCB/v5AADoRvslUAUAAJsRkxCeFC0WA/XgE/CS -AJ0AjRaPEvoAIh3gCgUADbo44hYHJRGBgACLIJIX8WARIlIAnQAmIQXyy4AN4AsFAC7xGuIWBycQ -cYAAHUuPHksfGUzbKCEFIyEEL/EZmyQrJQTm/wgBOEEAAPEAD7fQb40ADxpJ+UYADXAIpQD6n2YV -oA8FAG2KDSxC+w7IAe2BQnf4BQAA8AE0Da/8BQAAAAAAAAD0oIAV4BZFAPigCBXv/A4AtFX9f/iS -4BZFAJsR8iAGFeAIlgAAAAAA//1sDaAMBQAMqkn6IAYVqZwBAPggJhXgDAUA6Uy2EzAFAADiFgcu -CxYAAIgR7IgQAZv9AAD44AYVoA+lAPZgD8lQCgUAixGWGOIWBymoBIAA8iAIFeABhgAAAqNJ8iAG -FemyAQD6ICYV4AwFAIgXZcEWKYEEspkphQSJcADxBAA4GgiZAul2ACeDOYAAL/z2APEE5Vz+LcAK -gADomAIFUAUAAOh2ACeDCYAA6UySF/vZAABuUmuMGKysDAxJ+YYADnAIpQD8n2YVoAwFAG2KDSJC -+w4mAe1hgHZgBQAA/N/7xG/8BQBj/4MAAAAAAAAA9uCAFeAPBQD+4AYV4AkFAP/+MA2gH0UA+Jj2 -BeAfRQD24IAV4AgFAPjgBhWv/l4AAABpUWOCF4gYHExyqKgICEn9BgAMMAsFAPifZhWgDKUAbcoN -LEL7DskB7ZEMddgFAADwAFwNr/wFAAyrSfogBhXprAEA+iAmFaAMBQDiFgcuAMYAAI4QjXAA8QTi -FgcvcAqAAA7dAp1wihWLF1gmdMAg0Q8AAAAA//qEDaAfRQAp0i2rmQmZEfhgAET/8joAAACfEp4U -nRP4f+xQ0gCdAOenCAjYBIAA6nQAAOARAABb/veDUABgBAMDGf1AaB2pMwEA4xYALQkOAAAoOv94 -MROJE/hgCIviAJ0AixTzYAg74gCdAI0R7H4QDu2CgAAO3QINPQL8n2YV7/S2AMbK8iDmFa/9mgAA -+kCGFe/1IgDAwP4gRhXv9EIAkhf4f/pI0gCdAJYY8iDmFa/7bgCfEp4U7RYDK9AEgADsHAQo2ASA -AFv+040Ti1COFI8S/UBoHam7oQDrFgEtA74AAH2zb3vjbOgSACGb/QAA5roRC8sCgAD7JgAMsAal -AOmIAgO4BQAA+J9mFa/wYgCfEooSnhSKoB1NEo4k72J+LV5CgACrO4y6D6oM+2FoFenuoQDtzAEP -dAKAAP+GAA4wDQUAWAe5jxKNE44U/eNEFa/uXgDyIOYVr+ulAAq6OP1AaB2v+ioAAAAAAADyIOYV -r+2lAAraOP1AaB2v+coAAGwQBIkiDwIADwIA+EBoHaBZ4QD4HQADcZnxABRM8gSUCiJChPEwABO/ -/wUA8EAE0lQyAQDtggArUMKAAOp1AgqxAoAA9qYACrRiQQDv3QELNgKAAPZmAAmz4pEADt0CnYAF -MwKTgixCiOZM3xyuQoAA/RAABrACBQD3sAAWvcwBAP2GAA5wE8UA7IYDLCAEgABtOhTlIwoCIBEA -AOYzCAEQBQAAIzKAk0PyAAIdoBPFAG06FeUjCgRAEQAA5jMIARAFAAAjMqAjhh/AINEPAABsEASF -IowgHUzD4iIDKUAEgAD8YAAGMZXxAPQdAAXwpeEA9IgAA/1CkQDzoAABNFUBACPSgOZMuBH4LIAA -xirRDwAAAO5JhxueAoAA41MCDnuCgAAPMwINnwoOMwIj9oT4gAAXMAQFAO4uAgy+QoAA7vaIJYEx -gADzAGgdoBPFANMPbToUgyTnRQoBEBEAAOZVCAIgBQAAI1aA8UKADeACBQAkCgD9KAATsBPFAG06 -FSOCIOdFCgRAEQAA5lUIAiAFAAAjVqDRD2wQBCkyAA8CAP8jAAqQDAUAeZ4i6lQACdgEgABYJaPA -INEPAADaMFv/xIkwDwIA6ZbhfWAEgADaMFv/i/1AaB2v/1IAbBAEKyEE9JkABaAHFQD0AAId4AYF -APoPAATwA0UA+g4ABXDbaQD6iAAGcbsxAG06FS5ChOnmDXIgEQAAAFEEAH8aD2YCsVUeTHBkkHwj -4oB+P3JkYG/lTGwVAWGAACcKAPiY1gWgD0UAbfoZI1KIwU/2jwAKfTMBAOOLB3KoEQAAdG1BsXcs -5owUTGIjIQX1ZgAKMAIFAOLmgSokAoAABDMCI+aCJeKA7t8RDMfCgAD/BgAMf/+FAA9VAQWlAghV -AiXmgNEPxirRDyjigMe964gBDNfCgAAKiAL50AYVoAIFANEPbBAEiDD/AsAK0AwFAOpUAAnYBIAA -WCVbwCDRDwAAANowW/++/UBoHa//lgBsEAiJMMBA8SAE8pAIBQAqIAz7XyAVoAkVAAqUOASYOGSA -dIoz60w4FQB9gAArsX/xYAdnUgCdAIwyGUrZ/mCIFeBq+QD4YKgVo+rBAPlABAbzuqEA7hYCKVAE -gAD6IGYV7+gBAPYgJhWrvKEA+YAEBndvgQD2IAYVp5jBAPggphXvbwEA9iCGFaeIgQD4IMYVp//B -AFglb/gAIh3gCAUABJg4ZIBhKTIAeZZbLCESiysMzBAMuwKbMikgYCogYS8hB4gu7KoQDMoCgAAK -mQIJiAKYMy4gVPxFhBXj/2EA6P8QD3QCgAAP7gIO3QKdNCsgICwgISoiEejMEA3cAoAADLsCC6oC -mjXAwOpUAAnYBIAAWCURwCDRDwAAAAAAAAD//5gNr+ylAGwQBhlIxucyACmwBIAA/oAAFTAMBQDz -QABCcA0VAPjgBAPwCIUA+wzKDaflAQCUEfQgBhXgBQUA7tU4AaAhAACLYg8CAAuLV2+1VMuxGEvl -CLgKiIDqJAAL4ASAAO1UAApYBIAAC4AA7KQAAzAhAADloAxiICEAAIkRDwIAeUO/6hIAKdgEgABY -JOnAINEPAJUQ//+oDaAMBQAAAAAAAAD//3ANr+ylAGwQBBhIihRJrSiCMSRCgaKCCSIRokKiMiIg -TNEPAAAAbBAeijAKBldvYz5lQuEeS7QfSWwnIRMtIA34kcYF74oBAAeMDA3IOOh3CAMZsYAA9MAE -uJIAnQD0wAmxEgCdAMaa8yBoHeAB8gDB0/egFQOiAJ0A9sAUxdIAnQD0wA4Fn7oBAP6XXgXgHhUA -/sAOdCIAnQD3oBUTogCdAMGC+MAUw6IAnQBlQpBkUeOJLy4gDSjya+m6DA3gBIAADqw4qcwIzAqM -wGTCc4ox/MAOTGIAnQD1QA9IEgCdACrEFsCQ05BlMizSMNEPAACKMekABQDJQQAACQJhCQJh2OD9 -QAAWMAk1APwkBhWjCwUA6xYYINHBAABtmiHrogckSBMAAO2iBiRgEQAA65YAJVPhAADrzQQkQCEA -AJ2w6UtyENFBAAAcS4EYS3+Npounm5idiIulGEt+jaSbyBxLfYujnYgYS32NopvInYgcS3sMfAL9 -3+YVo+qFAG0ICrCqZKHwLeL/ffACY//u//tYDaAJBQAAAIox6QAFAMhBAAAJAmEJAmEOqRDoS20Q -0MEAAOgWCC9ABIAA+CIGFeAJNQBtmiHrogckSBMAAO2iBiRgEQAA65YAJVPhAADrzQQkQCEAAJ2w -6UtIENBBAAAYS1ccS1WLpo2nnZibyI2lHEtUi6SdiBhLU42jm8gcS1OLop2Im8gYS1H45gAMM+qF -AOjm/yVT/QAAZKFQKeL/6fj2dVP9AAD/+LANoAkFAAAAAAAAAO4gDSIEIYAA6SEIJwVhgAAqIRMK -mgz6YCYVr/oSAIkvLiANKvJrCbwMDss4q5kKmQrpkgAiA0GAAOmRCCcEGYAALSETDZ0M/GAmFe/5 -TgAA//kwDa/59QBooGwdR+QuwAct0jH78ogV4e4BAK7dCd0RrburqvtJkBWv+IoAAAAA+h/iHa/4 -XgAvIROIMQ+JDA6YOKj//kEEHe/4FgArIROKMQusDA7KOKuq+yEEHa/3wgAAAAAAAAD4YCYV7/eK -APhgJhXv92oA+h/iHa/3PgDGOhxLEy4gDS0gDOQWACt4BIAA9CAmFeAKJQDyIEYV4BslAFghz9Iw -0Q8uIA0cSwktIAz0IAYVoAolAOUWASt4BIAA+iBGFe/opQD4IGYVoBslAFghw//12A2v6aUAAAD/ -87gNr/m1AP/zmA2v+bUAAAAJAIfqMgEgyf0AAPkiIBXgCyUAbboCCQJh+JWyBeB75QDvrBEA0f0A -AOwWLyVQxQAA+iTmFeALZQDTD226Eiqs/O2iCCTAEwAA7YYAJMgRAADpSswQ0f0AAPtCIBWgC2UA -0w9tug/rogckyBEAAOuWByVT8QAAHErYDHwC/d/mFaPqhQCwqsisLeL/ffj1//E4DaAJBQD/8RgN -r/m1AGwQBBZIGIIwF0rQ5iIBAgEpgADy4VINoLmVABhKzHKLGBRKyxZKzKQkeUsJBkYKhmAKYADJ -U8Yq0Q8YR/eoKIiA+GAmFaACBQDRD8cv0Q8AbBAE5iQAAgGJgACLMBxKvvyQcAXg/vUA+vAABXA4 -JQD5QfINoAIFABlKuQmpComQCpAAxirRDwBlX8/HL9EPAAAAAAAAAGRC4StgISpgIAi7EQuqAvpg -JhWgAgUA0Q9kQwIqYHb/QB08IgCdANmg+GAmFeACBQDRD2RC3CxgF/xgJhWgAgUA0Q9kT6YtYA1k -0xryYCYVoAIFANEPZE+TLmANZOMd8mAmFaACBQDRD2RPgC9gDWTyx/JgJhWgAgUA0Q8AAAAAAGRP -aChgDWSCyfJgJhWgAgUA0Q9kT1UqYA3pYg4lF3mAALCb+mAmFeACBQDRD2RPOyxgDWTC5fJgJhWg -AgUA0Q9kTygtYA3pYRImlvmAALCe/mAmFaACBQDRD2RPDi9gDWTy1vJgJhWgAgUA0Q9kTvsp0pso -0pqpiLCImDHRD2RO6opniq4qoSKaMdEPZE7cK9KamzHRD2RB4S1gYCxgYQjdEQ3MAvxgJhWgAgUA -0Q9kTrkuYFQLi0f/YAwrogCdAMf//mAmFeACBQDRD2ROnIhniI6IjZgx0Q9kTo8qwlYpwlWqmbCZ -mTHRD2ROfivCVZsx0Q9kTnQuwlQtwlOu3bDdnTHRD2ROYy/CU58x0Q9kTlmIZ4iOKYIQiI+piLCI -mDHRD2RORYlniZ6Jn5kx0Q9kTjiKZ4qui6yKq6uqsKqaMdEPZE4li2eLvou7mzHRD2ROGIxnjM6N -zozNrcywzJwx0Q9kTgWNZ43ejtqN2a7dsN2dMdEPZE3yjmeO7o7pnjHRD2RN5Y9nj/6I+I/3qP+w -/58x0Q9kTdKIZ4iOiIeYMdEPZE3FiWeJnoqWiZWqmbCZmTHRD2RNsopniq6KpZox0Q9kTaWLZ4u+ -LLEpK7EorLuwu5sx0Q9kTZCMZ4zOLMEonDHRD2RNgo1njd4u0Sct0Sau3bDdnTHRD2RNbY5nju4u -4SaeMdEPZE1fj2eP/ijxJS/xJKj/sP+fMdEPZE1KiGeIjiiBJJgx0Q9kTTyJZ4meKpEjKZEiqpmw -mZkx0Q9kXS/aYFgO8CxgDAjMEf1GAA0wiwUAC6oC+mAmFaACBQDRD2RdDI0x/MQGHejdHQD8xCYd -4AIFANEPZFz1jjH+zCYdqO4dAP7MBh2gAgUA0Q+PMf7C5h3gAgUA0Q9kXNKJMWiQAgmeAu5kditQ -BIAAWv0TwCDRDwAowYBkjTEqwX0pwXyqmbCZ+GAmFeACBQDRDyvBgGS9Ly3BfPxgJhXgAgUA0Q+O -Z47uj+OO4q/usO7+YCYVoAIFANEPj2eP/o/y/mAmFeACBQDRD4hvqYiwiPhgJhWgAgUA0Q+Jb/hg -JhXgAgUA0Q8AKmETqaqwqvpgJhWgAgUA0Q8rYRP6YCYV4AIFANEPAAD/8WwNr/n1AGwQBpIQHEc0 -G0d+F0d85DBmaW7CgAAD2QIpdsEkdsLAgPj4ZhWgOSUAKnLD4K4MdMv9AADwALQNoAIFAGWQ5PyO -4gXgChUA/o6KBaALhQD8jtgFoA8FAFggZBtHafyOPAWv8rUAZyCPwKT8js4FoBtFAFggXWAAVQTf -Ai92wcDqLnbDw5IocsPgjgx0y/0AAPAAkA2gAgUAZZBm/I60BeAKFQDuRy4d4ASAAP4AAh3gC4UA -WCBNxytnIA/ApPyOpgWgG0UAWCBIYAACK3LCZiAk+iAIFa/99QANXQMNvQH8gGgdr90BAO1tAgnY -BIAAWBOv0qDRD9EPwOP++GYVr/4WAA7qMA/qMC3CRa7dD98M9//7iJIAnQAP6jAP3wxr8fZj/2AO -6jAtwkWu3QjqMAjYDPcf95iSAJ0AD+owD98Ma/H2Y/7iAABsEAQTSWsjMn8DIgzRDwAAbBAGwMH8 -IAYdoDqFAOwUASjYBIAAW8C6ZqAWw6n6ICAV4AwVAFvAtuIQAS0AMgAA0Q/SoNEPAABsEAYUR2IV -RtDwACgNoAMFAACxM3QxQSogIRxHXfwgaB3gG+UAWBMyZqApKBEAeY8jCuowKVJFCZkKCpkKCuow -CpoMaqHLbQgICuowCpoMaqG/Y//w0qDRD8cr0Q8AAABsEAYVRfoUSUEWRrfwAJgNoAoFAAAAAAD6 -RDAVoBvlAPwgaB3gDAUAWBMZKBEAdYkqsTp0oSzToAvqMCliRQmZCguZCgvqMAubDGqxym0ICArq -MAqaDGqhvmP/8HQxA8Ag0Q/AIdEPAGwQBBhGnyUKAPICAh3gJoUA5iYCDBAEgABtOgwpIZTmkQhx -EAkAALFVx1sXRyXTDyNyhPqgBADQBhUA/MABA1/19QAFZQPjUwELJAKAAANDAiN2hAPqMCKCRQIi -CgMiCgrqMAoqDGqhDm0ICAjqMAgoDGqBAmP/8ClyhARqAglZAQqZAvjwhhXgAgUA0Q8AAGwQBB1G -expHCvSSBgWgDBUA5DBLZrArAABoMkPb0P4SAh3gDgUA9VCoFeAYBQBtihIpsZT/IAhEYgCdAO7s -ASXYCQAALmIxK0KkDwIACe4RrrsrsGxksez0QAnokgCdAPpgaB3gDxUAA/s59EAJiRAFBQDeUPgC -Ah2gj4UAbYoSKdGU/yAGzGIAnQDu7AEm6AkAACn6++dUAArgBIAAKKKELWIxL0KkCd0R/eAAR/At -BQDr1zkMgQqAAP/m8BWgDRUAAN0aC9w5B+4C7vQ3LvQCgAD/hgAOP/71AA7dAw2IAQyIAiimhGQw -rhdHP+tCWygECoAA9EAEWJIAnQBksJjyEAId4AIFAC1iMSpCpK0t7HCALu5CgACtqm0IHQAgBAwO -G3/nCS+gbNMPDwIAz/jjqggBEAUAAHsrXWP/2wAAAOAEBQgZ8R/319IAnQD4X/hxUgCdAGAAPwAA -AAAAAAD5wGgd7/zKAAAAJaRs+gACHeAMBQBYA+QrQluxInsjh2AAFQDJscAgLHCAACAEDAkbf599 -sSJ7I/HAINEPAAAA+KBoHeAeBQDTD23qDS/RlGj+D+mcASboCQAA+f9iHeAMFQDtVAAKuASAAC+i -hMCIC405LmIxKEKkCe4RrogugDft7gIMgQqAAO6ENy5ACoAA64c5DGwCgAD85gAL//31AA2IAwj/ -AQf/Av9QhhXv+2YAKGIxI0KkqCgJiBH4YABBsAsVAPpgaB2gDAUAWAO2wJEpNGwrQluxIvpf+lPi -AJ0AY/9TZS4XY/9NAGwQBBdGeBJF5/YPAh2gBQUA9vCIFeATBQBtOgwoIZTmgQpxEAkAALFVwCLR -DwBQBAcJGf8+QAfQAhUA0Q8AAABsEAbtJAACAjGAAIswHkUI9JDABeD89QD68AAFcBglAPlEsg2g -AgUAGUhbCakKiZAKkAAWSFkpYID1IAuKF6sBAPUgC0mSAJ0AxirRD2Vfuscv0Q8AAGRP7ypSOZox -0Q9kT+ULjRR9yN9b/t5moaD6YCYVoAIFANEPAABkT8oeRrcu4ICeMdEPZE+9x/+fMdEP/d7AJeB6 -hQD9oGgdoBgFAG2KDCnBlOqRDXZgCQAAsSIi+trRDwAAZi/18JLwDeebQQDLmmmRgNrQHUY2/BIC -HaALBQD9sKgV4B8FAG36Ly+hlOz5J3VQCQAAALAEDQwZ8YAGv9IAnQBgAQsAAAAAAFv/r/pgJhWg -AgUA0Q+xu2AAuGRPMipSoyhSPilSQwqIDP0gABS/iIEACYgCmDHRD2RPFCtSlpsx0Q9kTwosUpWc -MdEPZE8AkjHRD2RO+ZIx0Q9kTvKSMdEPZE7rkjHRD2RO5JIx0Q9kTt2SMdEPZE7WkjHRD2ROzyvi -HSpSxQm7EauqiqfLpyqsIFr7RgpMFPxgJhWgAgUA0Q8AAABkTqdYCPz6YCYVoAIFANEPG0fdL7Ku -cf4xZKBZaKFwwCDRDypSVPtfABWv/wIAKuIxKVLFCaoRqpkpkGzAsQm5OfhgJhXgAgUA0Q8i+rnR -D2SQ5/k/8qDSAJ0A+mAoFaALFQBb/tzSoNEP//9MDaAJJQDSoNEP6jIBIgPpgABYSvPmriZtEASA -AFhK6pox0Q9kThctYIAo4jEvUsXiFQAsFkKAAOLyCAakWQAAwKL8j6gFoAuFAFgeh8Yq0Q8AKbKu -cZZ/2iBb/oVmrd7aIFv+a2at1vpEMBWgG+UA/CBoHeAsBQBYEaLmrcBtEASAACoRAJox0Q8AIlLF -KOIxKdAMCoQU/QgAFDc6AQDoIggM1gKAAFgg3ClggGiTMfk/9/pSAJ0A6iQAClgEgADtUkcp4ASA -AFhH5tKg0Q+KMVgCYdKg0Q/Ap1v+f2P/dwAA6iQAClgEgADtUkcp4ASAAFhHftKg0Q8AbBAEFEVg -IkaWI0aX0Q8AAGwQBBVFXAJJFClWkSRSkgIIQw+IEfsABADQBzUA4DYaDAEKgAD84AED3/j1AAh3 -AwdEAQZEAiRWktEPAGwQBtIwiSDTUOVHkRSlRIAAGEdwKIKu8QAJaFIAnQDAQChRkClSR5kjKCUI -L1GRLyUJLlGSLiUKLVGTLSUMLFGULCUNK1GVKyUOKlGWKiUQKVGXKSUR+EAIFeAAGgDAQHqWHooj -K1JHerQI8ABMDa/kpQAALFGQKyEIKlZHe8QTwUbaMOskAApgBIAAWCBrwCDRDwAtUZErVZAqIQl6 -3N8uUZIqVZEqIQp67NMvUZMqVZIqIQx6/McoUZQqVZMqIQ16jLspUZUqVZQqIQ56nK8rUZYqVZUq -IRB6vKMsUZcqVZYqIRF6zJcqVZdYTvwcR1ktUZEuUZMkUZcvUZUpUZQoUZYqUZLrUZAszAKAAOn/ -AgxEAoAA6EQCDVQCgADq7gIN3AKAAPumAA7wCkUA9CAGFaALBQBYHftYCE7mr0JtIASAAGABqQAU -R0T8jogFoA41AC5Vkv6yZB2gDRUA/LIkHeAGBQAmVZAsRspYT8mLIRdD0/FgCiESAJ0A+lgABXe7 -gQBYTuPmoVltIASAAB9HMinydJkqKPJ1mCsv8nOfKVhO1xpHLQ8CANMPKqI1HEPM0w/xQVAN4A8l -ABtDxw8CACuwffFgBZ+SAJ0AJlWVLlInGET4HUciG0ciKlGWKVGXJ1GTC6oBDZkBCHcBJ1WT+rLE -HaANBQDpVZcnAlmAAPqOMgWgDkUAbQiiKMItK1J1qNgJiBGouymxL9MP6pkBBugFAAD5ZeQd74kB -AOlSJyRYHIAALrU6JrU+JrU2edNqKVGXKlGWe6cQL1YWL1YX/qKmFeEKBQAqVhh/l3z+omYV4AyF -APyiRhWgKwUA+qImFe/2ugAAAAAAAPr/7QuiAJ0AK1In/XlgDeAKBQAtwi0sUnVtCButrgnuEa7O -5uU2JVAFAAB7owdj/XPTD2P/VtMPY//dAAAAAAD6AKIdoAsFAFhOk+eu1m0gBIAAWHP4Y/2sAAAA -AAAAAPay5B2v9QYAWHPyY/2XAAAAAAAAAFhMSvVAaB2v9ioAbBAEiDAZRF+MMfxBkBXniMEA6YgK -CVAEgADogngp2ASAAP2gABawDlUA/6YADrfMAQALgACJMYoi+kGwFeeZQQDxQ+AN4JlNAB1Dh8tD -KiAMHENk6dKDJYGBgAAv3fmvry/wfS7CLqv/r+4J7hGuni7sgI7nju6U4PXAJhXvgtUA0Q/SkNEP -ACLCLaoiCSIRopKCJ4IulCD0QCYV74LVANEPAABsEAwUQ7YrIAzqIA0pMASAAOQABQjIBIAACQJh -CQJhCQJhCQJhEkQuGUQ4/IhwBeAFBQDlFBEp5wKAACwUEO0WAS3GAoAACKgCCYgCmBD8wZAV54jB -APMAAQQwB1UA6IJ4KNgEgADo3RELUASAAPemAA7wDEUAC4AAIxIBDwIADwIAA4NHAwMGZjH2IhEE -E0QU+sBoHasiAQD6QGgd4AwVAFgSzuQABQjIBIAA6QwADSgEgAAJAmEJAmEJAmEYRBcZRRIbRoL6 -IGYV4YoFACoVBfgghB3gDBUAnBEIKAKYEPyhkBXniMEAA4gKKIJ46N0RCtAEgADn3QII2ASAAAuA -AIMR/ofuBaczQQD4IGgd4DNNAPB4WA3gDxUABACHCQJhCQJhCQJhCQJhnxEYQ/8ZRmiZEggoApgQ -/KGQFeeIwQAOiArogngq0ASAAOjdEQjYBIAA96YADvAMFQALgACDEQODR/6HvgWgM00A5jFFaMgE -gAAEAIcJAmEJAmEJAmEJAmEYQ+v4h9YF4AsVAPoghB3gCgUA+iCkHaAMRQCcEZkUCCgCmBD8oZAV -54jBAA6ICiiCeOjdEQrQBIAA590CCNgEgAALgACDEQODRwMDBuYw+2jIBIAABACHCQJhCQJhCQJh -CQJhGEPUGUY6+CBmFeAMJQCcERlDuggoApgQ/KGQFeeIwQAJiAoognjo3REK0ASAAOfdAgjYBIAA -C4AAgxEDg0cDAwbmMLxoyASAAAQAhwkCYQkCYQkCYQkCYRlDqxhDppkRGUOmCCgCmBD8oZAV54jB -AAmICuiCeCrQBIAA6N0RCNgEgAD3pgAO8AwVAAuAAIMRA4NHAwMGZjCA0Q+NYPoAQh2gCwUA7EYT -GfAEgABYHLvSMNEPAI1g+gBCHaALBQDsRg0Z8ASAAFgctdIw0Q+NYPoAQh2gCwUA7EYIGfAEgABY -HK/SMNEPAI1g+gBCHaALBQDsRgIZ8ASAAFgcqNIw0Q+NYPoAQh2gCwUA7EX9GfAEgABYHKLSMNEP -jWD6AEIdoAsFAOxF+BnwBIAAWByc0jDRDwAAbBAE8EXADe8ygQDwYhAN4CQFAAKIV8qBAslTypkC -6lHkoC9iW/0AAAK0O9JA0Q8AACIR//9wDaAUBQAIIhH0nwAVr/9aAAAADCIR9J+AFa//OgAOLRHs -TP0iE/kAAA3CO9EPwCDRDwBsEAQSQ4QiItjRDwBsEAQSQ4EiItfRDwBsEAQSQy8qIouKoCihAsmD -WwPpGEJkKIIjIiKFqogJiBGoItEPwCDRDwAAAGwQBCX6wAUlAYRbkyH0gABCcMUFAKVElCDRDwBs -EAQTRcL4hMYF4AwFACw26iw26Cw25iw24yw22Cw21iw20iw20Sw2zCw2yiw2xSw2wCw2vyw2viw2 -xCw20Cw24vh4xhXsDgUALjbdLjbf/nymFaA/9QAvNtz+e8YV7/L1ACI2wfJ45hWgDWUALTbT/H0m -FeAb5QD6d4YV4BqlAPp4RhWgCDUA+HkGFaAZBQD4fAYV4/j1APh8hhWgGhUAKjbaG0VR+nsmFeAd -tQAtNtQSQjcfRZcvNs3yeWYVoA4VAP55xhWgAvUAIjbrHEWRLDbX0Q8AAABsEATnQu0ZL4KAABZF -jadXk3CmVSRWf9EPAAAAbBAEGEPUiIAZRYgTQ9IJiAH4RgAJMBQFAAQiAvJgBhWgAgUA0Q8AAGwQ -BBhEfBlCDhpDyCaCWimSMCeCpXYrDKKZCZkR+OAAQ/AAGgDAcMPKLKYQI6YRw7srphAkphEbRE2K -oBxCEuuqAQluAoAA/UYADXArBQALqgIMrAIFyjkbQ7XAIOq2ACOAWYAAlHqTe9EPAMAg0Q9sEAQb -QsD4hp4FoAoVAPYPAh3v+fUA6SFCbagEgAD2AAIdoBMFAG06DCRRlOdBCHKoCQAAsWbHayWChABh -BACsGunNAw50AoAADswCDVUBDFUC9RCGFeABEgAAAPhABSlQBgUA9WBoHeAfBQDTD236DCNRlOcx -CHKoCQAAsWbHaySChABhBACsGgnNA+1EAQ5kAoAADEQCJIaE82BoHaAFBQD+AgIdoJaFAG3qDC8h -lObxCHEQCQAAsVXHWyaChORBxBqBCoAA40LmHTgKgAAJewMkQjHjMoEr5AKAAAx3AutmAQomQoAA -pDMiMDcHZgL3EIYVoAQlAAQiAvJm5h2gAgUA0Q/GKtEPAAAAbBAEHUMN+oT4BaALBQD2ACIdoJwF -AP2wqBXgGAUAbYoNLqGUfOEy67wBJVAJAAAURPwrQltksFkTQ270g0QF4AIFACowgG0IDQAgBAoP -G3//GbEieys6Y//rALAEDQgZf4fLwKJb/6PAINEPLVIxKkKkrS0J3RH9QABFcAsVAPdNhh2gDAUA -WAAiK0JbsSJ7I7DAoVv/l8Ag0Q8AAAAAAGwQBGgxSetCGBGUQQAAaDRGaDhLaDtQaDwtGEJPKIJG -KTroCbksB4gRCYgsGkQ/AykRCpkI6JYAKVAEgABavzTRDwAAAAAAAPqIfAXv/zoA+oW+Be//GgD6 -iHAF7/76APqC6gXv/toA+ohqBe/+ugBsEAYoIGzIgWQxrCUgIsCSCVk245kRAphHgAAaQofA1fsg -AEUwAF4AG0KG65sIAuP1AAD9YgANMA2lABdCKxZCjB5C0/qE8gXv/PUADNwDrq7rmwgBhJmAAANa -EaaqKaKACdlSZJB49SAJ6JIAnQD1IAnpEgCdABlEwC+yhg/PAS+2hiiyiAjIAQjYAii2iCjigMTw -D4gCKOaACOowL3JGD58sKXJFD5koCYkID+owD58MavEObQgICOowCJgMaoECY//wKXr+KaaBKCIf -iIHaIOs0AApgBIAAC4AA0qDRD//+WA2gSQUA70JXE8ArAAAogjEv8oGliAmIEQj/CCrwIyiyhgjI -AQjYAii2himyiAnJASm2iCnigCj6vwiZASnmgAjqMClyRQiZCQjqMAiYDGqBCAvqMAubDGux9sDJ -fKEH6hYALSRIAAAt8R8NDUXqFgAmlbEAAOsSACrQBIAAWBjAZqAe6xIAKtAEgABbs94DXhGm7i/i -gBhBrQj/Ai/mgC7igArqMA/qMClyRQqZCQ+fDPf/+ZCSAJ0AC+owC5sMa7H2Y/8h+CACHe/7OgD4 -UAId7/saAMAg0Q8AAAAA+qBoHaALJQBbg11j/7YAAGwQBBpA9tMPI6B9F0HD8mAGB9ALFQDyAAId -oCb1APTgaB3gGAUAbYoNKVGUdpEJ4iwBIqgJAADHK2YgkxlCRy6ShAAhBP1gAQLf9vUABlYD7m4B -CuQCgAAMVQIOXgIuloQtkoQG3QENzAIsloQI6jAM6jAkoiCoRAxMDGrBDm0ICAjqMAhIDGqBAmP/ -8CqShAaqAQpaAiqWhCZyRcBQ9sABAzfXBQD+2AATMAAmALFVd1EcBOowCOowpkQISAxqgextCAgI -6jAISAxqgeBj//DRDxpB8ykK/vlQJhXv/vYAbBAE8ofuBaBjRQAiIn8DIizAMwMiLBNB0SI2vNEP -AABsEAQTQv30AAId4ASFAOMjCgk4BIAA8nQoFeACBQAPAgDTD9MPbUoX+kAEANNDAQDgRBoBEAkA -APSgAEK0Mx0AGUKJA3gRqYj1AAYV4AIFANEPAABsEAQUQoX2QGgdoAOFAG06CihCpQgIUmSAUbhE -JwoAGUGgGEIS+oJIBaCFBQD6hJwF4AwFAPjgAEIwIgUAbSooIrJAIqLSCSMBA2MCI6bSI6LSLEag -pXOoMyMygCKm0uKi0iIgEQAAtFXRDwAnQqQHB0n+8AATv/6mAAAAbBAEFkP29gACHeADBQDTD/LA -aB2gFHUA5m0gI7gFAADTD21KCiMmgOMmgSEQIQAAwUfpdOJrEASAABJD6PaH0AXgBNUA1iDTD21K -CiMmsOMmsSEQIQAA42bKIxCDAAD2XF4N4ATVABZD3ScKAA8CAPLAaB2gFLUA5m0gI7gFAADTD21K -CiMm0OMm0SEQIQAAwUvpdOJrEASAANEPbBAEGELEqCgogIADBU/xAARX0AwVABhCnQgoCiiCocAw -+GAABLACBQD7IAQA1IgdAP2AAQVQCTUAbZon+GAABLS4HQD7IAQA05ghAODJGgyBCoAA6akCDlAK -gAD7JgANNIsdAPVAaB2gGfUAA5kMeU0RsTP8foCCUBn1ANEPAAAAAAAA6jQACtgEgABbok/nr99t -EASAAGP/4QAA6iQACtgEgABboknSoNEPAGwQBOdCWxkwBIAAFUEeBSUCJXazInK0FEKWE0Og9EAE -ATAUBQDyRgAJcAMFAOJ2tCuQBIAAbUoH4ya1IRARAAAmdrPRDwAAAGwQBBZBl6YmJWKAx38HNwMH -VQEFRQIlZoDRDwBsEATAwRhDjQMkEQ8CAAhECBhCfCRCAAgoCCiAgP8PYAffRAEAGEJVCCgKKIKh -CAlD+yAEANACBQD9gAEFVIgdAPNAaB3gCTUAbZon+GAABLS4HQD7IAQA05ghAODJGgyBCoAA6TkC -DhgKgADzJgAJ9IsdAMGfApkMeT0PsSL8XoCCUBn1ANEPAAAAAOtEAAlQBIAAW6IJZ6/h0Q/qJAAK -WASAAFuiBdEPAAAAbBAEW/9pHENj/AACHeADBQD5gGgdoBoVAOzNBCboBQAAbaoKI4ZA44ZBJEAh -AADBoenY5G5ABIAAFEH+9I/oFaACBQAqCv/8QGgdoAsVAFhTXioK/1v/NbEiaS7m3ED6AAId4Pr1 -AFhTWPiGJgWgGgUAbaoKI4YQ44YRJEAhAAAYQw6IgBlDDMCiCogCmJDRDwAAAAAAAABsEAQUQz8j -QoACMwwjRn/RDwAAAGwQCOJAKhlABIAA2TAPAgDiAAUIkASAAAICYQICYfUABJJSAJ0AEkLv9CBo -HaADNQBtOiHlQgchGBMAAOdCBiEwEQAA5TYAIiPhAADlbQQhECEAAJdQFT+lEkLjG0L2HUL0H0Ly -FELwjFSOVYNWileaKJNIilMUQvCDUp74nNiauJNIF0LYHECn5kCPHFoCgAALmwIMuwL6/+YV4+KF -AG0ICbAiySAscv98YAJj/+/AINEPAMAg0Q/HK9EPbBAEEkGyFELmIyKBezYgKSKKCQlV+yAEANAI -FQAAiBoiIv4CIhTzAABBMAAmAAAAIkF9JEF/4z+TEgBZgAADIjWkItEP0Q8AbBAEFUE4wIgIKAIo -VlIPNBEkVlPRDwAAbBAEE0L0AiILCyIRoyKCINEPAABsEAT2hC4F4AklABZAQhxC7QRICvJAAgWw -ChUA82AAhfANBQD1QgAOsRpFAOoqKA3fAoAA57sIDEPCgAANyDn6wABDOogdAOi2yynXAoAAqmoo -pqgCJQsLVRGnVSdSwv54ABUwCAUA5Jg5DQEKgADgiBoNAQqAAP0gAQTf+vUACpkDCXcBCHcCJ1bC -JVLCJWbp0Q8AbBAEF0HyAiYLC2YRp2YpYsIPPREA0QTgWhoOgQqAAPyAAQXf/PUADLsDC5kBCpkC -KWbC9oAmBeEYRQAIKCgmYsKodyZ26dEPbBAEFUHgAiQLC0QRpUQjQsAVQCoFMwIjRsDRD2wQBBVB -2QIkCwtEEaVEI0LAFj+hFUB9BjMBBTMCI0bA0Q8AAGwQBBtCZ+uyfynQBIAAWB2k/AECHeAMBQBY -HM38QGgd4AwFAFgc2NKw0Q8AbBAE8n9eBeACFQAiNoAiNoHRDwBsEAQYQpoqgn/BsAuqAiqGf1gd -/9EPAABsEATLJ8BQ9/4CHe8GBQDTD20IDXJgDQKCFOQgHGKoIQAAY//pcnALtFXwABgNpCIdALFV -AhIUZS/30lDRD8Ag0Q8AAGwQBMogsCMDJQFzIBdtCAywVORVAQqQBIAAdCACY//sDyIR0Q/RD8Ah -0Q8AbBAE40J5GRZCgACjItEPAGwQBBhAsMCQ0w8phmophmsphmwMAgAogmwI6jATP8EjMkUDMwoI -MwoC6jACMgxqIQ5tCAgK6jAKOgxqoQJj//DRDwAAbBAEE0JlJDKAIzJ/dDkFFEJjcksDwCLRD8Ag -0Q8AAABsEAT6EAIdpUkFAPMxAAkxOPUAA6M6oyT4gABCP4gFAAhCAdEPAAAAbBAEGD8+6AAFCZ+C -gABtOQICAmHRDwAAbBAEEkJP0Q9sEAQYQOwCJQoIVQriUsQhgHGAAClSw5IwCSIM0Q8qUsMKIgzR -DwAAbBAEwKL8UAAVsEwFAFhqz+tCQRUCQYAAHEJALLZ+7LZ/JmAhAAD9cAYVoA0FAOy2gSVw4QAA -bSkdna+drimygJ6RnK8psoDppg4lUQEAAO62gCdxAQAAwCDRDwDHJNEPbBAEGD6tEj60KII0IiKA -CYgRqCLaIFqYVBk/DvhA6BWgCgUA+AAIHeBJBQDTD22aAggCYZon0Q9sEAgXPp8WQh8SQGgqci/4 -0sgV4AMFAPp+AgXgCAUA6xYELVZCgADqmQgDItEAAPggZhXgAIYAAAAAAAD6sAYVoAgFAORMASGY -BQAA9GALihIAnQApcjMlYpapOexgVCzOQoAAqVUlUgcAMATlUg4mCqmAACoggAoKG+tAgCV/GIAA -fre+LnIzLWKWrj4J7hGu3Y3X2jD9ocgV4At1AO0WBSjgBIAAWBsfjxSIFf4ACB3gOTUAbZoCCAJh -jBUpKoD5gABE8Y4FAP+AAEcyqnUACsoI+iBGFaB9hQDj5MQmYAcAAP2V5B3gG+UA+5YkHeANRQD9 -lgQd4HiFACiURC2UMf0nBh3gDxUA/yQmHe+OBQD/JEYdr8wlAP0kZh2gC+UA+yTGHeAMdQAslDD9 -JyYdoAs1APsnRh3vzsUA/yXGHa+PhQD/JaYd4A4lAP8l5h2gD2UA75RBKNgEgAD/KEYdoA0FAP0o -Zh3gDGUAWBSOihX6VkId4AxlAOuqCAjYBIAAWBSJihX6IEgV4ry1AP1AAEUwDGUAWBSEihX6SYId -4AxlAOuqCAjYBIAAWBR/6hIDKdgEgABb+uLnrn9tQASAANKA0Q8rYdMsQID/YaAH0A0VAA3MAixE -gCth0/F/9KdQDyUALkCAD+4C/pAGHa/6GgAAAGwQBhY+iQYAhxZBohlBo9hgbZoCCAJhGEGhHkGi -HUGiGkGgF0GlFEGjEz7WEkGhH0GfJTHJLzaNIjaMJDaLJzaKJjaIKjb8KTL1KzLvLTb+LjbN7Kww -JvAjAADsNv8m6KMAAC029+429i3eQoAAq5mJl+g2iSVRQQAAKjbMiZ74IAYV4AQFAOVlAiRj/wAA -5WUDIrn9AAD8wAYVp3cdAPbAhB3mJQEA5GUFIQFxgAACKgL6gGgd4A0VAFr/c2iuFfpAaB2gCwUA -/MAIFaANFQBa/21prukoMoknhQQkhQUlhQIlhQPlhAAEYEEAAOyGACEBUYAA2iD6AAId4A0VAFr/ -YmiuFfpAaB2gCwUA/KAIFaANFQBa/1xpruknEgAlMooncSckVQUnVQLnVQMi4EEAAOxWACOx/QAA -9sAAAXdmHQDmVQQhEVGAAAIqAvoAAh3gDRUAWv9MaK4V+kBoHaALBQD8oAgVoA0VAFr/R2mu6SUy -iw8CACZVBOdVAilQBIAA9qBkHeALBQDkVQUi4EEAAPygBhWgDRUAWv87aK4V+kBoHaALBQD8oAgV -oA0VAFr/NWmu6Sgx0GSAmSUyjCcxzSRVBSdVAvagZB3mJwEA5nx/IuBBAAD8oAYVp2YdAOZVBCEB -UYAA2iD6AAId4A0VAFr/JWiuFfpAaB2gCwUA/KAIFaANFQBa/x9pruklMo0PAgAPAgAmVQQnVQIn -VQPkVQUi4EEAAOxWACEBUYAA2iD6AAId4A0VAFr/E2iuFfpAaB2gCwUA/KAIFaANFQBa/w1prukp -MqoiMvcmCvv4zwALcFoFAPRApB2hXAUA/EBEHaALBQD8QGQdoAg1AOglBCFgQQAA/EAGFaANFQBa -/v5orhX6CgIdoAsFAPxACBWgDRUAWv74aa7pJTL8LWx/DX0ULVUEJlUC9qBkHaYmAQDkVQUi4EEA -AOxWACEBWYAAAioC+gACHeANFQBa/uporhX6QGgdoAsFAPygCBWgDRUAWv7laa7pKjKrZKCQsK4O -qAF+oBVtCAywj++IAQxQBIAAf6ACY//sD6oRIjL/0w8kJQXqJQIlGf0AAPpAZB2nMx0AIyUE/EIA -FaY6AQDsJgAhgVGAANow+gACHeANFQBa/s1orhX6YGgdoAsFAPxACBWgDRUAWv7Haa7p0Q8oMosm -hQQnhQInhQPkhQUkSEEAAPkABhXv+LoAAAAAAP/+JA2gChUAbBAOFj7xLCAMHT0xKmJ+62KGJjS9 -AAAYPTUogH0JqhH7YABFMIMFAOOjCAR8HIAAYAACI60DiN3xAYAN4AIFANEPqsMJMxHzYABB//+u -AAAAAAAAJGIkFUCz5BYIIiH9AAAEOxT1YAQF8AolAPtiABXgHAUAWGks+CEIFaeUHQDppQQtEASA -AOilAiVgQQAA+UBkHaAHBQD3QKQd5kgBAOymACIBUYAA2kD64Ggd4A0VAFr+j2iuFfqAaB2gCwUA -/EAIFaANFQBa/olprukkYiPTD9MP5BYJIiH9AADy0WYVo7QdAPVgBAXwCiUA+2IAFeAcBQBYaQwn -pQX0ISgVp4QdAOilBC0QBIAA5KUCJWBBAAD1QGQdpkQBAOymACIBUYAA2kD6AAId4A0VAFr+cGiu -FfqAaB2gCwUA/EAIFaANFQBa/mtprukkYiIPAgAPAgDkFgoiIf0AAPLRRhWjtB0A9WAEBfAKJQD7 -YgAV4BwFAFho7SelBfQhSBWnhB0A6KUELRAEgADkpQIlYEEAAPVAZB2mRAEA7KYAIgFRgADaQPoA -Ah3gDRUAWv5RaK4V+oBoHaALBQD8QAgVoA0VAFr+S2mu6SJmiRs9i/oAQh2gHAUAWGjUGEBUGT0t -/f/iHaANNQDqhvAkQA8AAPgACB3gCcUAbZoCCAJhGT6O/ywAFaAKBQAqlHwslH4slK4slN4tlH8t -lK8tlN8s5K4t5K/91YYd4A8lAP87hh3gCBUAKJSsJGIkwcAExDbkFhAiIf0AAAQ7FAW7AftiABXg -CiUAWGi1J6UF+CIIFaeUHQDppQQtEASAAOilAiVgQQAA+UBkHaZIAQDspgAiAVGAANpA+gACHeAN -FQBa/hlorhX6gGgdoAsFAPxACBWgDRUAWv4Taa7pGjyK4qYLKQBGAADHJNEPKxIQwKL5cAAVsBwF -AFhomRw8gvLgaB2v+UUACpI46sYMIQAxgADRDx1AEx9AFR49URtAFBJAEa/u7hYPJaAhAAArFhEq -YoorJn+dGyyhAismgCQmgeQmgiYJUYAAWv39Hzx3L/IhLmKGCv8I6RILL/5CgAAP7ggo4Af5MBAV -4PrFAAqIAf6AAAXniAEACYgCKOQHnxSN4CriB+4mgyDYQQAA/aAAFrAOFQD/pgAOsAwVAO0WBSVQ -gQAAWvpLKxIRjRuIH+IsMCIgwQAA67wwJugFAAD5f/tNIgCdAIQ3hE6EROQWDSIh/QAABDsU9WAE -BfAKJQD7YgAV4BwFAFhoXSelBfQhqBWnhB0A6KUELRAEgADkpQIlYEEAAPVAZB2mRAEA7KYAIgFR -gADaQPoAAh3gDRUAWv3BaK4V+oBoHaALBQD8QAgVoA0VAFr9u2mu6Y03Hj/Ijd4cP8zzzwYVoApV -AP2giBXgOyUAWBZFHz/BL/J48uBoHa/+RQAP4jjIJdEPxyTRDwASPUMPAgAvItufHo03Hj+3LdIO -IiLcJ+a8LNIGLdIFLea4Lea6/YAARnAKJQDv3wwGY/0AAP2PAA72/x0A/9dmFebdHQDs5rkmof0A -APwhhhXjtB0A9WAEBfAcBQDt5nYl2EEAAFhoISelBfQhiBWnhB0A6KUELRgEgADkpQIlYEEAAPVA -ZB2mRAEA7KYAIgFRgADaQPoAAh3gDRUAWv2FaK4V+oBoHaALBQD8YAgVoA0VAFr9f2mu6Rk/jOOW -dSmAZgAA8AD0Da/yRQAcP46PHi6Suf03CBXgClUA8iAGFaA7JQBYFgUfP4EcP4gt8rv/90gVoApV -AP/uyBXgOyUAWBX+wCDII9EPAAAAHj2lLxpBLRpALeYQHD90K+IRK8bxL+YQKGG5KeIRKhoA6pkC -BHgogAAYO/cImQL8AAIdoANlAPmAAh2gOvUAL+YQKeYRHT9mJ9amLNZ/LNZ+LNaALNaFLNaELNaK -LNaMLNaRLNaQLNaSLNaWLNaYLNajLNaiLNaoLNaqKNadKNaf+bSmFa/79QAr1oEr1ocj1pMq1pwq -1p7ztSYV4AoVACrWjvp3cgXgEwUA87QGFeAINQAo1ogTPyoj1o34d5AFo/P1ACPWpCjWi/thphWg -GBUA+bNGFaAbpQAr1oIaO8Eq1oYbPyAr1pcbPWYaPtIq1pn7eEgV4BzlAP2vhhWgHLUA/bKGFaAM -9QAs1qvRD2wQBBI9xCMigXs2GykiigkJVfsgBADQCBUAAIgaIiL+AiIUooLRDwASPzMiIX/RD2wQ -Ehk7mtMP0w8qnf0ooqcPAgDsPy0UFNmAAPIAAh2gCwUA/AACHeAGBQD2AAId4AgFAPgixhWgDwUA -/iEmFeAOBQD+IQYVoAUFAPQg5hXgBAUA9CGmFaADBQDyIUYV4AQFAPYiRhXgAwUA9iJmFaAHBQD8 -IoYV4AYFAPoiphXgDQUA/CHGFeALBQD6IMYV4AUFAB87dh48My/yLS7i9a8vCf8Rr+6eGy7hEu4W -ACjQBIAAWEOjiRuIECqUYuiVEiTQsQAAWEOe6hILLVgEgADrpFYlUOEAAFhDmY0diBsrEhOPHpeP -lowlhRMjhFUugTUsgG4qhFcpgT4qgFSaE6+fq8ut7SwSFC4SFSkSFp8eqjOdHSsWEy2AciuBEiqA -cC+AcatVqamu/qzcL4IRjRiKiykWFi4WFSwWFIsWLIEzK4YSLoEyiY6qZiqBNKl3re2dGK+7jhmP -GimBNq7Or6+MFxo+2SiAb6ycKqBxKRISnhnvFgohEAUAAOmJCAV8YoAAKRYSihuIE5gVKKR++nfq -BaAARgCIGxo78ykWEiiAfpgVmxaIFSmip5wXCEQI+F/3A+IAnQAZO+spkqnqEg0ki/mAAPghyBXg -AgUAbQgXAAEwAAAxIAxRIA0BAAExAAIAAAIwIAwBJBYXFDsgJEIvIhYYpCQSPrQiIp3oEhMqJkKA -AKQiJCBuqEgoFhMkIG8oEhKoSCgWEiQgcCgSFiIWECsmEqhIKBYWJCBxKBIVIyRVly+oSCgWFSQg -cigSFJYsJSUTqEgkIT4oFhQoITKpSSQhM62NKCE0rk4kITWvjyghNqpKJCESrIyIK6RVhC6oZhg+ -laR3JCIRKIBxIiBUkh+kuyQSF6Iz4hIYKAQKgADzAAQX0gCdAJkeIhYZKBIQgh8iFhEihH7yIygV -oAHWACnCUWSSl/oAAh2gBAUA9gACHeAGBQD0AAId4AsFAPIAAh3gDQUA/gACHaAMBQD8ImYVoA8F -AP4iphXgDAUA/iLGFaAPBQD8IkYV4A4FAPIihhXgDQUA+iHGFeADBQD/+sQNoAsFACgSEJkeKIB+ -KBYRGTuQKBIRKZKp6EQIARAFAAB5KwiJHmP+kAAAAADiEhMmjQmAABk7hy2VxS6Vxy+VyeqVyyYC -CYAAsMgIyQGZFPmACs4iAJ0AjBRtCBLsFgImS/0AAOnMAQ5ABIAAeYAI/CCGFa//kgAAiRIPmRHp -O3Qc4ASAACqVyy+VyS6Vxy2VxSyVzhw+SC3B5Bo7benB5SaImYAALsHmKBISL6BzIqRyDo8576Rz -JICxgAAvEhYoEhUopHUvpHQvEhQvpHZk0R8owlDjxlckBaGAAPogxhXgAgUAGjqdGT4zDwIAKqIu -KZKdCioI6xYGLVZCgAAKmQgpFgwpkRLpFgEg0BEAAFhCx4wcixEqxGLrxRImULEAAFhCwuoSDC1Y -BIAA66RWJVDhAABYQr2JHIsWL5BULpIRiJ4qlFcjlFUrlhKXn4yblpwtkRKsZhw+FyWVE61VLcBx -qHfuuwgBEAUAAO8zCAb8MoAA/y/GHeAAHgAvkH4uwlCvRP5f+uOiAJ0AJcZLJsZMJ8ZNK8ZOI8ZS -JMZTjx7/huYV4AIFANEPAAD5gGgd7/s2AGWe7SjB52WO5y7B5igSEi+gcw6POf9OZh3v/AYAZe5f -Zf5cZa5ZZM62GTscLZXFLpXHL5XJ+zlkHa/5bgBlntwtwedl3tZl7tP4dKgFoA0FAC2kcS2kcC3F -F/kPsBWg7wUA/YNkHefuBQD9g8Qd4CkFAPmCpB3giAEACP45/4MkHa/6cgAAAADyAAIdoAQFAPIA -Ah3gBwUA9gACHaAPBQD+IoYV4A4FAP4iphWgDQUA/CLGFeAJBQD4IcYV4AsFAPoiRhXgBQUA//hQ -DaALBQBsEAqSGFgTulv+lxY9yilh4P8mwAfQDBUAGTxMKpKBe6YZKpKKCgpVAKEEAMsaKZL+CSkU -+WAARPAAHgApYRn4xoYV4AAuAAAAAAApYjQuYjYvYeEoYeIrYeP2AGId4A0FAPgkAAQx/wEA/y0A -D3G7AQDuZjYll+GAAGSDAvoiABXgDEUA7GZTINCBAABYV9TmofxtEASAAIoUWFe6WBERWFcX5qHp -bRAEgABYVpNYVmdYVWTmodhtEASAAFhUtCth3X63ClhUsOahxG0QBIAAWFRD5qG5bRAEgABYVAnm -oa5tEASAACxh4POADMfSAJ0ALWHh0w/TD31wMSwa/AwLPxg7CtMPK4LfC1sUK2YeKYLhCWkUKWYf -KILjCFgUKGYgHzuiL/LeDw9AL2SYKmHjwdgPAgD7oAt4ogCdAPrgDHiiAJ0ALmHi0w975zLqEggq -YASAAOs0AAroBIAAWFJW5qEsbRAEgACKGFhR++ahH20QBIAAWFD15qEUbRAEgABb+7EUOdIrQmjz -YAsI0gCdACIKAGYg+Fv7L+ag8m0QBIAAWBNTKUB96j1kFOiagAAoonbHnQmIASimdsDwL6ZxHTrb -LNLIHjrwKUB9DswBLNbIeZ8VLaJ2x+sO3QEtpnbAsCumchw9VSvGwC9CaHP2E4QYKEANikcpQHeK -ruuUAAQMkYAAHjzwKeKuHzr6Gjp+/HYaBeALBQD/JgAM8Ex1APnVxhXgGAUAbYoMKKGU7IEfdVAJ -AACxuynSgho9QfsgBASwChUACpkC+bBGFeABCgBmv+Ms0oT7YAQA0A4VAP3AAQdf//UA7+8DD0QC -gAAI7gIPzAEOzAL9sIYVoABOAAAAAABYU43nrmVtEASAANpQ6zQACWAEgABYFeXAINEPAAAAAAAA -AOoSCCnYBIAA7EQACugEgABYU2nmr9FtEASAACph49MP+v/zziIAnQDqEggp2ASAAOxEAAroBIAA -W/w/565ebRAEgABj/6HApPwf4h3gC4UA9nhqBaCopQD4IqYdoP/FAP4ihh3gPoUA6BYAK2AEgABY -E3/DqPoigBXgDCUAW7QY5q5obRAEgADcYPwf4h3gC4UA/gcCHaAPtQD2IqYd4Aq1APoihh2gCTUA -+CAGFeAKRQBYE2/DqPoigBXgDCUAW7QI80BoHa/4mgAtZjctZjj8xyYV7/P6AC1mPS1mPC1mO/zH -xhXv88IAAADAyAyZAv1AoCXnmQEA+I7mHeAMtQAs1e7s1e8lgOGAAMCl/HXqBaALBQD8AGId4A6l -AFgTVGP+OWSf5MCl/HXiBaALBQBYE08bOpPsOu4aUASAAFgTo2P/xmwQBMk39GAGoJIAnQDJOPRg -BqCSAJ0AwCDRDwAAACchE+R3CAn/VgAAKCEuHjk9DwIAd4kCLiUufmEa62QACVAEgAD8AgIdoA0F -AFgAMuaghG0YBIAAHDtQLMF/AioC94AARnALJQBYFMzmoGhtGASAAB05K9MP0w99URrrVAAJUASA -APwCAh2gDQUAWAAh5qBDbRgEgAACKgL84GgdoAslAFgUveagLW0YBIAAAioC/OBoHaALFQBYFLfm -oBdtGASAAOoiCipYBIAA/AACHaANFQBa8vLSMNEPAAAAhyz04ABDv/yqANxw+kBoHaALFQBYFKnm -r95tGASAAOoiDSpYBIAA/AACHaANFQBa8uPSMNEPAGwQBhQ8kIYvJEJ/o2YEZAqEQORAdWs/goAA -6Tl4EoNpgAAlQAcFBUEMWxGpuyiynvcABhHSAJ0AK7KdZLC3wMD6QAgVoAgFAPggBhWgDVUA+CAm -FaAOBQD4IEYVoA8FAFr2hx45ZgxdEf+gAEawDDUALNadKyAGKSICKgoB6pkCBdgFAAArJAYpJgLa -IPzAaB2gCwUAWBR75qBWbSgEgADqIhAp2ASAAPwAAh2gDRUAWvK18IOwDeAGBQCKRyZEBYqqZaBC -+oFIFeAMBQD6QmgVoC4FAP6ARhWgDRUAWvKqHzxZL/J/p//m9gAqkASAANEP0lDRD9og61wYKWAE -gABa9F7HJNEPABw8UC4gDS0gDOoWACn4BIAA+IBIFaAbJQD4ICYVoApFAFgSu4tHKvrA5rYKJciB -AAAKmQGKQimcQJm56bYIJQIJgAD94AIdoAsFAPuCQB2v/QUACooU5KAcZdghAAB6yPF60Au0u/AA -GA2kqh0AsbsKGhRlr/faQFr0GGP/PgAA///IDaALBQBsEAYsQCb6cR4FoIkFAPhgBAR2cwEA6BYA -IeBKgAADhUL4oABC8AAmAAAAANVwGTvaKqIxKEBbK5KhrKrtkpktVkKAAPtAAEVwBgUA6hYBJAFB -gACOSAnuEQ6+CCzgcyviACzM//3OZh2nzAEA7bsMBhXBgAAmRFvrNAAKUASAAPwAAh2gDQUAW6X0 -6iQAClgEgAD8oGgdoA0FAFugi+tUAA0YBIAA+oBoHaAMBQBbo4sqQCb6oGgd4l0FANMP/UAARXAM -BQBborMbOocYOUwIWAIotrP+cNAF4AgFAP92hhXgGQUAbZoK64kKBEAFAAAmlrUpIA0ltrPrIAwk -gdmAAO46OxSAsYAAHTujLuB9LdJTsJwOzCir26y7GDqeDr8RqP+P8A8PRn95CfAAWA2gCwUAAAAp -IA0rIFXAwQnJOQt7DKubKiIUhxD8AAIdoA0VAFryKWRxoilAJhc5sf//4h2gDxUA45kRAvBrgAAa -OoQFXBT5gAEE9LUBAPsgAESwAD4AHTqA/SAARPK1AQCnmiiigACxBOBsGg2BCoAAAP0aDt0DDYgB -DIgCKKaALkA2fOcTKRIBKJEYKIz/CAhP6JUYJAvRgABuXg0aOowGWRGqmYmQYAAgABw59AVbFAy7 -CiqyhCuyiAUMRADBBOuqAg/ICoAACpkByZWOEdpQ+oTQFeAMBQD/wwQVoA0FAFuaqStAWho7YPwA -Ah2gDRUA+1VoFaa7AQBa8fMmRFoqQCYmJH8mRRkmRRomRDZbqzYsQCYbOmgDzBHrzAgNEASAAKfM -LMKAjRH9QAREIgCdAC3QNGTQqSpAJlv33B439C7gfelAJid1uoAAf5cyACsRHjmnCR0UDt0KLNL0 -gk4oIQMiIQIMDE8MvAL4TwAJP/8lAALzOezW9CmQBIAA0Q8A2yAeOZoJHRQO3Qos0vSCTh445Sgh -AyIhAg7MAQy8AvhPAAk//yUAAvM57Nb0KZAEgADRD4JOKCEDIiEC+E8ACT//JQAC8znSMNEPKCIU -KYEDKIEC+R/yhGIAnQDSMNEPiREqkCIDqhGrqqeqIqaA8yMkHa/9DgAAAIoR3GD7Q8gVoA0VAFrx -sGP9OQAAAIoRKKIfiIH6ACId4AwFAAuAAP/50A2gDxUAbBAEJSANzj7KXOIgDCKB0YAAGDmhFDsI -KIB9JEJ/sFMIMyiiQqMiEzoFDiIRoyKCIAICRtEPAAAiIFXAQQVFOaMiBSIM0Q8AFDn9DiIRpCKC -IAICRtEPAGwQBCgiENMPKYEDKIEC+Q+GDe/2RQDAQPpAaB2gC4UAWBIx5qFxbRgEgAAqIhDTDyuh -AymhAvsnxg3gBQUA20Ba8aHAwPVAaB2gDQUA6iQAClgEgABb/prmoTRtGASAACoiENMP0w8toQMs -oQLtwQdyqAUAAGlYxSmhAyihAsDx+Q8ADHAOBQAI/jhk74naIPwfoh2gCwUAWBNj06BmMO+KKg8C -ACuhAyqhAnuhd8Aw+kBoHaALhQBYEgvmoPFtIASAAIoqLKEDK6EC/WemDaAFBQDbMFrxfB03fR43 -fPNAaB3gCwUA6iQACeAEgABb/i/moJ9tIASAAIoqLqEDLaEC7tEHcqgFAABpVMYroQMpoQLAgfsv -AAzwDwUACY84ZP+NYAACAMAw2iD8H6IdoAsFAFgTPeagW20gBIAAii0toQMsoQJ9wUvbMFrxXx03 -Xx43X/NAaB3gCxUA6iQACeAEgABb/hLppAANIASAAPFCKA3gDxUAii0roQMooQL7DwAMcA4FAAj+ -OGTvu9KQ0Q/SMNEP0kDRD/df+A0iAJ0A2iD8QGgdoBvFAFry5GP+7Hap4Nog/EBoHaAbxQBa8t/S -QNEPbBAEGjdGKykC+0/oFaADBQDyQMYd7/z1APxARB2gDRUA6qIBKeAEgABa8RaTINEPbBAEEzfu -jSAoMnPApfmvAAkwOwUA7DrAGXAEgABYETEqMov6QGgd4AwFAPtACBWgDRUAWvEI0Q9sEAQVN4AW -N/3TDwUAh+UiFitIBIAACQJhCQJhCQJhCQJhHDf3/EFoFeAKVQD+ptAVoDsFAFgRHR4384krFzcB -GDfy4UoQCfiCgAD75gAPsAwVAAz/AiiCj+92rStYBIAA/yYADLANVQDpdqwq0ASAAAuAAClyrQmJ -R8iS0pDRDxs344oqC6oB6iYKLJAEgADRDwAAbBAEgieCLoIv0Q8AbBAEgieCLiMiEIIvoyKwItEP -AABsEASCJ4IugiTRDwBsEAoVN1AZOK8vIAwWNucUOoUYONOYEytCsipiLS5CtC1Csy0WBP4gxhWg -AwUA/pXoFaAHBQD74ABHsAxFAOsWBS/+QoAA7+4IDJAEgAAoIf8vYjHtQq8kBaGAAK8/Cf8Rr90t -0CKJE/WgBQJSAJ0ABQCHK+ANnBkN2AkfOJIq4AzqFgcsRwKAAKj/nxEJAmEJAmEJAmEJAmEv8f/r -Fggng2GAACsSAywSBy4WABg3ph46Xhk6XioSACnmHxk4quiCjC7vAoAALeSICf8CKRIIHTpY7+VA -LmYCgAAMmQL9JgAM8AxFAPnDxhXgDVUAC4AAGzpNjBkrsh+OEC0SAfsOAA3w+vUAe6gCJ9Z/4zwB -JmP9AADlzzZhEMEAABs6NOw4aRXIIQAAKcaFKcaGK8aD68aEJejBAAAtxo/txpAl0OEAACrGkerG -kiX5oQAA78adJcGBAAAoxpsoxpzvxp4kQMEAACjGp+jGqCf4wQAAL8apL8aqgueCLiPCNoIk5zUF -IeBBAACcMCI1AuI1AyF5/QAA8sAAATf/HQDvNQQhAVmAAAIqAvoAAh3gDRUAWvf9aK4V+kBoHaAL -BQD8YAgVoA0VAFr392mu6RI6Gg8CACMiQyIiRCc1BSI1AuI1AyHgQQAA7DYAIUH9AADywAABN4gd -AOg1BCEBUYAA2iD6AAId4A0VAFr352iuFfpAaB2gCwUA/GAIFaANFQBa9+FprukpQk3BMAkzNsk+ -wCAaNlX6QGgd4AwFAPtBaBWgDRUAWvBGsSJzKeQpQk3xJxAN4AIFAChiIiNCr6goCYgRqDPaMFqP -/Ys3+2QAFa/JBQAJqgHntgolUQEAAJq4mrmXOfZhRhXgK0UAKzQF5QAFAeCBAAAMAmEMAmEMAmEM -AmEMAmEMAmHqEgYpWASAAPwAAh2gDRUAWvApK0JNsSJ7I5IrQkwjCgDlFgIlh4mAABI52ZUSKGIh -JUKvLSKXqDgJiBGoVfWgBlRiAJ0AKSKj9SAF/GIAnQAqIq/1QAWkYgCdACwiu/WABUxiAJ0A2lBa -j9KNV/+kABWvzwUAD+4BLuxAntie2SpSC+fWCiUAoYAAgqta7MTqJAAJf74AABI5vYpc0w/IroKr -Wuy+6iQACX++AAASObiKXQ8CAGSgD4KrWuy46iQACX++AAASObKXWydWCigSAvahJhXgKbUAKVQF -6AAFAtiBAAALAmELAmELAmELAmELAmELAmHqEgQp2ASAAPwAAh2gDRUAWu/rK0JMsTP6f/jj4gCd -AClCS/EqwA3gBQUAKGIgI0KvqFgJiBGoM9owWo+giTf7JAAVr8sFAAuqASqsQJqYmpmKOeeWCiUA -iYAAgqta7JLqJAAJf74AAIo6yKuCq1rsjuokAAl/vgAAijvIq4KrWuyK6iQACX++AACXOYwS9mEG -FeA59QApNAXsAAUB2IEAAAsCYQsCYQsCYQsCYQsCYQsCYeoSBSrYBIAA/AACHaANFQBa778tQkux -Vfy/+uPiAJ0AHjXFGTjKl+8n5hCX7ieWfyeWiyeWlyeWo9EPAABsEAQfOWr8cgQF7/71APZx7AWg -ChUAJyAiKCIKK9KuAHEEAKoa66wBBAOhgAAMDEdkwKTgtxV94ASAAAvIQnh5Cv9gBAZwCQUAKWSA -DqgDCMgBL2FP+bXGFaALNQAPAgB/sBEpIAwaNatolnMqoH1/pwJokWorYU57twUsIAxoxXbqJAAJ -2ASAAOxEAAroBIAAWABYCqICBgAAAAAAwMDgtxV9+ASAAAvIQnh5Ch85P8CAKGSAD78B7qkDCdgE -gADp+QEK0ASAACnWrlgR68Ag0Q8AAAAAAAD99yIdr/8OAOokAAnYBIAA7EQACugEgABb/qBj/34A -AOokAAnYBIAA7EQACugEgABa7Mlj/3IAAGwQBIkyGji+CRlSLKKu+nFkBeLcqQDtmQwMwsKAAAmM -Of+JAAwQDRUAjjIfOR3/x2AIkk6hACS0gCkgIg54UO2IEAy1AoAA6GYCCiQCgAAGRAIEzAIPzAIM -D0fN8X/mDx43E/+ABAYwACYAAAApICIAkQQA3xoPzALspq4mQDCAAPAAGA2irGEAwK8dNk74aroF -4uypAP2ABAbw/PEA7LCAL/iCgADv3QIPc8KAAA7dAuiuEA5jAoAADswCDcwCnDIqsiGaMymQfsCA -+mBoHe/8hQDpjDkK0ASAAFgRo8Ag0Q8AAGwQBIgiwnrmNlIcBk4AANogWAgWZaC8HDjq/EGQFeAK -NQD+QbAVoBsFAFgPUIwnjcoXNzbpIgImWIEAAOrCCSaDKYAAZJB18UXADeAvpQAuoAAYNyyMon/p -BXjBWXfBQNqw/ABCHaALBQBa8gcbNyiWoIwgl6KTpSSkHPVAxhXgDSUA+0CGFeAJBQDppB0uZgKA -AA3MAuymASrQBIAAWBGfwCDRD8mU2rD8AEIdoAsFAFrzB2P/tXfJsmP/49pQ+mBoHeAMBQBYEW/a -IFgJ8tKg0Q8AjCeNyuTQYGZQgQAAi8lksFYusAB36QgYNwYvsgJ48T/6AAId4AwlAFrx4h03ARs4 -sJagjCCTpSSkHJWm+0CGFe/59QAppB0tpgL9gAAWMA0lAA3MAuymASrQBIAAWBF6wCDRDwAAAAD6 -AAId4AwlAFry4mP/tAAAbBAEHjgzKCAN7eKuJADZgADqJAAJ2ASAAOxEAAroBIAAW/+k0qDRD4kz -Z5AbHzWa2lDv3QIJ2ASAAP3VxhXgDAUAWBE9wCDRDyggIhk08AiIEQjYAgmIAooyKOauWo5uwCDR -D2wQBIow+oMABTAIhQB6ixDaUPpgaB3v7KUAWBEuwCDRDxg4fQioCoiA6zQACmAEgADtVAAJUASA -AAuAANKg0Q9sEAbkFAApAQqAAPQgJh2g+PUA+EKmDaAEFQAVNifTDylQgABKGioUAnKZMvogaB3g -+uUA+mAEBTAMFQBbr2tmoDXkOgIA2AUAAPrgAAUwDBUAW69m4hABLQD6AADRDyoK4OxEAADYCQAA -W69gZqAH4lSAJX3FgADSoNEPbBAE4iANKUAEgAAtgQcrgAwNIhEiLTH6YAAF8d1xABQ1KrHcC8co -pCLyQAgVoATFAPaABdviAJ0ALoAMFjfd/mo8BeoiAQD8QAARM+4hAALuAg/uAoKA7ma7ISk0gABk -sEX6AAIdoAkFAPkgAQEwBAUAbckRgyTmRQoBEBEAAONWvCIgBQAAJIAILtwB7pkIBVARAADokgoC -cVyAAPtaNg3gBAUAIoIAeSZE8WQQDeAJBQDAoPkgAQIwAgUAbckR5iMKAiARAADjMrwhEAUAAJND -L4AI6qwEJpAFAADzIABEsAIFAOiUCgfwHIAAe6PMwCDRD2wQCiwyAA8CAPxAAASwBhUA8SswDeD6 -9QD1IApQkgCdAGiSG/39Qh3gDAUA6jQACtgEgABYEO7SoNEPAAAAAAAC6jAXNcHzgBJikPvlAHnG -ZiQwCSwwCC0wCi0UE/wihh3hzDEAesEf7nCALgEKgADsFgcreAqAAC8UFf3ADb0iAJ0AwKBmoCkL -SgH6ImAV4AwVAFuu+magGOZKAgDYUQAA+uAABTAMFQBbrvRmoAIqEBRmoaYqNAvA0GbRbgzqMPOP -AA4//aIADuow8Z/6qlIAnQAqMAjTD/lACakSAJ0AZqEt6TEFJQvpgAAJDEcaNhj6YTAV4A2FAG3a -Ci+ipQ8PUn+xU7iqwJCPMxs0uan/GjXkKqJALbLSGDUvCNgBCMgCKLbSKrLSGDSrqP/vAAUBwEEA -AOgABwxQBIAALbbSK7LSCgCICiCI+IpoHaANBQD4gmgdoAL6ACmipAkJSf8wABS//poAAuowKjAI -LTAM+GEwFeAMxQDzQAUeEroBAP5qtAXj3QEA/YANQ+DqIQAoMAr6YXAVoMoZAOTuEA5gwoAA7swC -DMsCgADsmQINVgKAAAqIAho3QemIAg31AoAACO4CD+4CjDDuppgmKHCAAMnU2TBt2Q6IlC8wCLSZ -6KaZJ/B4gACMMHnGFNkwbdkPLKKZnJQrMAjstwR0yBEAAMDQcN4lDOow848ADj/4fgDG2gzqMP+P -AA4/+EoAANowW/864KbefWgEgAD/9/ANoAwFAAAAKgrg+iKgFeAMFQBbro7/RqgN4PvlAI0X/PAG -He/4zgAAAAAAAAD/+WgNr/31AHiXB/AAHA2mmQEACYlCGjPVHDX/KqIw+ZBIFe+5AQCrqgmqEaqZ -ZJ2W/SbwFa/5dgAAHDaKKTAKLTAIKDALLjAJ/iEGFaHdMQD8IMYV4PT1APgiJh2gCkUA+CIGHeAL -hQDoFgAs+ASAAFgNz4oWdKEx63CALQEKgAAAbBosFBJ6sRsqCuD6IkAV4AwVAFuuYmagJI0W/PAG -HeAAHgAAwKBmoBSKGPofwh3gDCUA66oBANhBAABbrlhmrzz8YAgVoPvlAPof4h2v9I4AAAAAAAD/ -+ywNr+2lAGwQBooyiDAZM63tM7IUJWiAAPsgBJOgGxUAGDW6/1AAFT/59QBtugfphtQkQBEAABI1 -tQ2rAismvRo3PSomvFgE/OekAAUBYYAA6jQACtgEgAD84Ggd4AwFAFgQFtKg0Q8AAAAAAAAA//94 -Da/npQAAABQ1pBY3Lywi8Ow0ECGQRQAA2iDtQu8o2ASAAPwgBhXgDEUAWAnHJEz85knkcRARAABj -/6MAAP/+eA2v56UAbBAIGDN0GjRCKIB99gAiHeALBQD4AgId4Gx1AP8EAAcQHgUA0w9tmgwtoZTs -0TF1UAkAALG78ACcDa/7tQAAACwwCAwMQv+GAA4wCwUAbeoMLaGU7NEJdVAJAACxuyv6+x40u//Q -qBWgH/UAC/8MGzS7/8AEkmD89QCJMC4K/vMgBfqf7aUA/y1AAlA/BQAiMAgkMAkmMAsoMAooFBP3 -4ASzogCdAHwhGOmwgCkBCoAAAHoaKhQU8yr+DaANBQBm0DIOSgH6ImAV4AwVAFut8OagIW1oBIAA -50oCC2AEgAD6YgAV56oBAFut6eagBm1oBIAAwNDaMPqgaB3gDAUAWA/B0qDRDwAA//+kDa/t1QAA -ACoK4PoigBXgDBUAW63c/UBoHeD+5QDrNI0dfkoAAPNwBh2v/i4A//7kDa/tpQAAABw15CgwEPhh -UBXg8vUA9GEQFaAKRQD2YTAVoAuFAOgUESz4BIAA6RQQKmgEgADoFgArcASAAFgNKXJBORo0d+qg -gCoBCoAAAHsaKxQSdKEgKgrg+iJAFeAMFQBbrbzmoCltaASAABs0bfVwBh2gABoAwNBm0BT6IgAV -4PrlAPrABAUwDCUAW62x3aAN/lD8ACIdoAsFAA7LOGS/Fhs0X/hgCBXg/PUA/h/CHa/6agAAAABs -EASKMPxghBXgCHUADwIA+wAE0KIAnQB5plX8DwAE/q0BAAzqMBs1GXDfTyq2s8CA7rK0KdAEgAD+ -YOYVoBkFAG2aEuuJCgVQCQAA6ZK1JEAFAAAppQ8P6jD97wAOMA0FAOo0AArYBIAAWA9p0qDRD8DQ -//+sDaAMBQAAaZE4GTPICakCKbbFKLLGLzEFCP8CLzUFLrLKnjMtssmdNCmyyJk1KLLH+GDGFa/+ -tgDG2v/+uA2gDAUAxtr//pANoAwFAAAAbBAEFzOVFjPd6kQACU7CgADkM9sRhLmAAAOZAilmwSpm -wvgGQh3gCAUA+NhmFaAAagCwmWSQsAvqMCpyRauqC+owC6sMa7FULGLDcM7jwCBmIMfA0y1mw/AA -cA2gOSUAAACwmWSQWAvqMA7qMCpyRauqDq4Ma+EULGLDcM7jwCBmIIctYsItVQDRDwAAbQgIDuow -Dq4MauHeY//wAG0ICA/qMA+vDGrxnmP/8AqbAitmwcCK+NhmFa/+ggAAAAAA7TOxGmAEgAD+ZwoF -oAoVAPoBAh3gDwUAWAyj//6EDa/ytQAAAAAAAPxnTgXgChUA/mb2BaALhQD8gGgdoA8FAFgMmf/9 -JA2v8rUAwKT8Zz4FoBtFAFgMlNEPAMCk/Gc0BaAbRQBYDJDRDwAAbBAEFzNKFjOS6kQACU7CgADk -M5ARhJmAAAOZAilmwSpmwvgGQh3gCAUA+NhmFaAAagCwmWSQrAvqMCpyRauqC+owC6sMa7FQLGLD -cM7jwCBmIMMlZsLA0S1mw/AAdA2gOSUAAAAAsJlkkFAL6jAO6jAqckWrqg6uDGvhDCxiw3DO48Ag -ZiB/0Q9tCAgN6jANrQxq0eZj//AAbQgIDuowDq4MauGiY//wCpgCKGbBJWbCwPn+2GYV7/6SAADt -M2caYASAAP5mdgWgChUA+gECHeAPBQBYDFn//qQNr/K1AAAAAAAA/Ga6BeAKFQD+ZmIFoAuFAPyA -aB2gDwUAWAxP//00Da/ytQDAofxnDgWgG0UAWAxK0Q8AwKH8ZwoFoBtFAFgMRtEPAABsEAYpMgAk -MQQoCgf5AAeQ4gCdAPxkXgXkdAEA8O1wDeREQQAbM08t0jErsoH6AAIdoIwFAP2oABawCRUA/WAA -RfAIRQBtihQusCHsuwgNkASAAPXABGwiAJ0AsaqLMP9mIAKQBgUAmRIG6jBkkNfsMQUqUASAAO0x -ByvYBIAAW/+WiRKLMJoQD+ow9+8ACzAAFgAA7RIAKAQKgADxYAUiUgCdAAjqMOgWASSDCYAA6kQA -C9gEgADsMQUh6DkAAFv/O92gCeowihEKmQypZgM6AutUAAtgBIAAWA6H0qDRDwAAAAD1X/uqEgCd -AGV/bf/9qA2gCQUAKzEF93/5NlIAnQDG2v//GA2gBgUALCAkDwIADwIAZMCDIiIfIiIHZCBi6kQA -C9gEgADsMQUh6DkAAP5gxBWgDwUACyAA/UBoHe/+EgBj/4YoICTpFgIkAfGAACgiH9pA6IIHK9gE -gADsMQUh6DkAAP5gxBWgDxUAC4AAiRKLMPogBhWv/DoAAAAAAAAA//zwDa/tpQDHr/ogBhWv+9oA -AAAAAAAA//yQDa/99QBsEAQUM0GkIiMmgCIigdEPbBAEiTD6ZngF4pkBAOo1bxSDGYAAaJFf6jVs -HJWQAACJMP8kYAKQDAUADeowiDKOM6uvKPaALvaBDOowiTD9jwAOcAAeAAAAAHmWFg3qMI8yq64v -5oAu4oGeMwnqMA2ZDKnMwNDqNAAK2ASAAFgONdKg0Q9j/6gA+mqsBa/+kgDG2v//fA2gDAUAAABs -EASKJ4iqFzOb6SICJViBAADqogkkAyGAAGSQdPFFsA3gLKUAKaAAHTORfJkILKICfcFXd8E92rD8 -AEIdoAsFAFruax4zjRgynJigjyCXopOlJKQclab3Q6YdoAglAO6mBC/+AoAACP8C76YBKtAEgABY -DgTAINEPAMmU2rD8AEIdoAsFAFrvbGP/t3fJtGP/4tpQ6zQAC2AEgABYDdPaIFgGV9Kg0Q9sEAQW -NK4YMiflMmUZGgKAAAgzAvLf5hXj4oUA0w9tCAmwIsgrKWL/eVACY//twCDRD8cr0Q8AAGwQBogz -JjIAFzJ05DICKkgEgADzAAzAUmYBACgiAikWAO0zkBwOrgAAZGFD9MAKcJIAnQD0wAqhEgCdAOvQ -fSscVAAAKtE/ALEEAKoa+oASGqIAnQD6QGgdoAslAFgL6eaiEG04BIAAiTDzIATykgCdAPMgBhpS -AJ0A22D6QGgdoAwFAFgNL/ZmhgWvjNUAfKECB6c4jCeNyukiAiZYgQAA6sIJJoXBgABkkRjxSwAN -4C+lAC6gABgzNYyif+kK+YAHDCIAnQB2wTzasPwAQh2gCwUAWu4OjBAZMy8dMj+doIsglqKTpZWm -J6QdmaQspBz9YAAVsAwlAAy7AuumASrQBIAAWA2nwCDRDwAO6jDaIOtkAApgBIAA7jEcEehBAABY -C8/moLRtOASAAA/qMIkw8T/6KlIAnQAI6jDsRAAJUASAAO08ECtYBIAAWAv55qCZbTgEgAAJ6jBj -/xxkkGTasPwAQh2gCwUAWu77Y/9mKtIg+p/1q6IAnQBgARUr0iH6n/V74gCdAGABBy7QfSzRPwDh -BADMGvyf9QOiAJ0AYADwAPef+X0iAJ0AY/9X2mBb/4XcoOs0AArQBIAAWA1TwCDRD9pQ6zQAC+AE -gABYDU/aIFgF0tKg0Q8AL/qN/1/6TGIAnQBj/o8AACj6jflf+yQiAJ0AY/5/jCeJyuSQYmZQgQAA -i8lksFgssADC2n3JCB8y3i6yAn/hpPoAAh3gDCUAWu26jBAZNI8dMtiXoIsgnaKTpZWm+UCGFe/4 -9QAopB0spBz9YAAVsAwlAAy7AuumASrQBIAAWA1SwCDRDwAAAPoAAh3gDCUAWu66Y/+0AAD2Y7IF -7/5FAP9f+9UiAJ0A2iD8QGgdoBvFAFrws2P/Zf/3iA2v56UAbBAEiTCEMv8noAqQAgUAeZ4Y6jQA -CtgEgAD8QGgdoA0FAFgNRtKg0Q8AANpAWA+CWA+ZCeowikCaMwjqMAmIDPhAAEE//zoACOowiTOZ -QALqMOgiDApQBIAAWA93WA+OiTBj/6kAAABsEASCJ4Yq4iIJIwGBgADwQoAN4CilACcgABoynYki -eHkYepkViyYsIByNJZ0wLEQA+qAGFeACBQDRD8ci0Q8AbBAG6iQACNgEgADsHAQg6CEAAFv/6ywS -AGagOyk8EOkHHgZQQQAACgJjCQCGCgJhCeowGjCcKzkBKMIBCJkyC5kM+yEADL+IAQDoxgEszAKA -AAmIAijGAfpAaB2gCwUAWol40Q8AAABsEAQXNC8SMmgmcp0kck4CMgF2KwqmRHJLBcAg0Q8AAChy -sQkiEaKC0Q8AAGwQBBcxRhIyXSZynSRyTgIyAXYrCKZEcksDwCDRDyhysAkiEaKC0Q9sEAQUMlQS -Mk4iIn8ENAEJRBGkItEPAABsEAQUMjAkQID4Yw4FoyMBAAAgBAQEG+iCgSJ8JoAAwCDRDwAUMF0k -QjGkIgkiEaKC0Q8AbBAEKQqACToB8mAG3hKDQQCpifUgBs9SAJ0A1ZDxTnAN4pNBAC8gDB4yOhsy -OvngBrVmowEALSBVLCBUKSANEzI2rczkkLBmM/0AAOjgfSSFgYAALDJYsJ0I3SivzA3MCAvJCimS -gAkJRnmhEi0gVf1ABKPiAJ0A90AEYqIAnQBkQEwpIA3sIAwkgYmAAOjgfSSAgYAALzJYsJ0I3Sis -/K3MC8kKKZKACQlG+UE+DeALBQBgABEAACkgDSsgVcDBCck5C6sMq5sqIhRa8dXLphgwJSiCMCIy -pqWICYgRqCLRDwAAAAAAAP/8vA2mkwEA9TAAFe/8pgD3gGgdr/3SAP3gaB2v/XYAwCDRD2wQBCkK -gAk6AfJgBr4Sg0EAqYn1IAavUgCdANSQ8U4wDeKTQQAvIAweMfcbMff54AaVZqMBAC0gVSwgVCkg -DRMx863M5JCsZiv9AADo4H0khWGAACwyWLCdCN0or8ytzAvJCimSgAkJRnmhEi0gVf1ABIviAJ0A -9UAESuIAnQApIA3sIAwkgZmAAOjgfSSAgYAALzJYsJ0I3Sis/K3MC8kKKZKACQlG+UF+DeALBQBg -ABMAAAAAKSANKyBVwMEJyTkLqwyrmyoiFFrxkugv4xUBoYAAKIIwIjKmpIgJiBGoItEPAP/8zA2m -kwEA9TAAFa/8tgD1gGgd7/3eAP3gaB2v/YIAwCDRD2wQBCQgDchC0Q8AABcv8hYv0PJIAAL3MwEA -4nKDIYDxgAAoffmoWCiAfSRiLqOIqEQJRBGkIiIsgNEPACliLaWZCZkRqSLRD2wQBNEPAAAAbBAE -FzE2pycjdoAmcoEjdoDHjwhIAwhmAQZWAiZ2gdEPAAAAbBAGy0knIADTDw8CAPaFBg3gCAUAbQgP -5HAUZEAFAACiiSeQAHdBEmP/6QAAAAAA8AAkDaACBQAA2SCxkmQh8BYzVypgAPFPwA3gBAUAbQgM -JWABsUTkUAdjMAUAAGP/7GRA4ScgAGRw2/aACZCSAJ0A+uAJVSAIBQAZM0j4jwALMABCACuwACqQ -AAhGDHupJvTABYiSAJ0A6ZwBJEAFAADiiwgDF4MAABozPAKLCCuwAAqKCCqgAHqzD/tB1g3gBBUA -8AAYDaAEBQDHT2RAdRYzNCpgAPFGwA3gBAUAbQgMLGABsUTkwAdjMAUAAGP/7GRAUfaACgCSAJ0A -90AJxWAIBQAZMyf4jwALMABOAAAqkACiiyuwAAhGDHupHOhhJGRABQAA62LmZMgFAAAaMxyiiyuw -AKqKKqAAerMT+0JWDeAEFQDHz/xgBhWgAgUA0Q/HT2RP7hYzE9MPLGAAwKDkpAAGA9mAAG0IDC1g -AbFE5NAHYzAFAABj/+xkQGD2gA4okgCdAPeADe1gCAUAGTMF+I8ACzAAigAAAAAAAAD64Ggd7/xS -AAAALJAAoosrsAAIRgx7yRzoYSRkQAUAAOti5mTIBQAAHDL3oosrsACsjCzAAHyzEfuCFg3gBBUA -+mAGFaACBQDRD8dPZE/wFjLuLmAA+AciHeAo9QDx33AN4AQFAG0IDCxgAbFE5MAHYzAFAABj/+xk -QJFqQVH3yd4N4AwFAB0y4PyPAAswAIYAxirRDwAAAPrgaB3v+/4ALtAAossrsAAMRgx76SPoYV5m -YAUAAOti5mboBQAAHjLSossrsACuzv/AEBWgABoA23B+sxD7wfYN4AQVAPAAHA2gBAUAAMdPykSa -MCogAMBA+wAJSqALBQD7IAizogCdANyg+2AgFeACtgAAAGThR/ZlfAWgBAUA0w9tCAwsYAGxROTA -CGMwBQAAY//qAJowokcmcADw0ZAN4AQFAPLAaB2gagUA+gjCHeBsZQBtCFEMRBGUMHKLD3KTDPJa -ABWgANIAAAAAAADzQpINoE0FAHLDDPJVIBWgAHIAAAAAAADzv/hqogCdAPN/+CuiAJ0AIizJokSU -MCJwAeQgtGO4BQAAY/+nAAAA+uBoHe/6JgAAepMborfkRAoGK0EAAAVECZQwKnAAsbvqg+V9YASA -AGSgfigKa/gJYh3gS9UA80BoHaBq1QBtCBZ4IRZ5ITh6IUJ7IU8icAHkIFZjuAUAAGP/4ig66AhI -KPhgBhWgAgUA0Q/MqWAAOQAAAAAAAMug9kBoHe/+vgAGSRH4YAYV4AIFANEPGi9SCkoo+mAGFaAC -BQDRDwxLEPpgBhXgAgUA0Q/AIJIQ0Q+aMCYgAP7fEA3gBAUA9kBoHe/7UgAAAABsEAQVMCmlJSNW -gCRWgdEPbBAEJiAA9mVGDaAHBQAPAgDTD9MPbQgP5GAPY7gFAACieCaAAHYxB2P/4sAg0Q8AsYLR -D7Ei0Q9sEAQjIAACJALwYXAN4AIFAG0IDChAAbEi5IAHYiAFAABj/+zRDwAAbBAEFTC0Fi9i8AAk -DaAEBQCxRGhJKSNSvHw3HwPqMCJiRaMiCOowCCgMaoHjbQgICOowCCgMaoHXY//wwCDRD8cv0Q9s -EAQiLH/yZCAF4yIdAAMiASIsENEPAABsEAgeMjMZMjQUMjIoIgApkroXMJksMgH5DwAMf/aFAPgg -ZhWv8vUA8YAFABCs+QDzgAuwUgCdAOwyKBUTwYAALMFhGjCN84kgDeAdFQADPAJt2iD2YeYNoA8F -AHpCB/+AqBXgABIAL6bALMz84qbUJVARAAAfMhkoPAgI7zkvdrxb/8jkpAAFD4GAAOkvGxoJqgAA -iBISMhApkcbyWcgVoogdAAmIDAeIEagi6xIDKVAEgABa8AFkoinaUOs0AApgBIAAWAqlwCDRDwDx -gAbQUgCdABsyAdMPDwIAK7Fh3DD6IKYVoB0VAOp0AAWGOYAAbdog9mHmDaANBQB6Qgf9gKgV4AAS -AC2mwCzM/OKm1CVQEQAAHjHxHzHuKDwICP45Lna8W/+fZKFpZqCGGjHqjRIPAgAuoWCLE/tZyBWi -3R0ADt0M7RYELu3CgAD9QABFcAwFAPogJhWgDRUAWugVixEssQMrsQKOFHy5Fi9yvRgx3I0SCP8B -D90CLXa9HDHZLHa8/GOyBaAKVQD8IEgV4AtlAFgIKx4xzvogqBWgCQUA+CAGFe/6SgCaFf/8KA2v -5KUAKvq5mhCKFf5jigWv+eYAAAAbMcQrsWFksUgYMCr4AAId4BsVAG26CimGwOKG1CRAEQAA2iAc -Mbwsdrxb/23kpAAFCDGAAMCQZUBMmRIaMB2LNSumwOsxuBHD8QAAiIUotsDoMbYR++EAAC/yBS+G -wO8xrBHz0QAALuIFLvbALXK9HjAuDt0BDZ0CLXa9HDGsLHa8W/9X1KBmTmoSMaKOEi8hYPJZyBWi -7h0AD+4MB+gRqCIoIQMvIQJ48Uv19yIdr/kaACpy5X+nDX6nCgrIT/ggRhWv+BIA//fwDa/0RQAs -cuXxn/jP0gCdAPGf+I+SAJ0ADMlP+CBGFe/58gAAAPQgCBWv+AoA/GMeBaAKVQD8IEgV4AtlAFgH -3f/3ZA2gBAUAAAAAAAD/9rANr+SlAOsSAylQBIAA/AAiHaANFQBa569j/b8AACly5X+XCn6XB//7 -zA2vmWEAx0T/+6QNoAkFAMZK//t8DaAJBQAAAABsEAQWMXUVLbXzDgAKNzIBAOJi/SGM4QAAKFIt -pIgJiBGoIiQgDSNirxgvl+IgDCIBaYAAKIB94jMIAiv9AAAIVSiCYaUzCjMRoyLRDylSLqSZCZkR -+EAAQX//KgCKYQoiEaKi0Q8AAGwQBBsxWxwtm/MOAA03kgEA6LL9JI3tAAAtwi2q3QndEa2IKoAN -HS9+grHogAwlAKGAAC3QfSyyr7CpDZkoqMgJiAgKiRHpIggBgrGAAIohiyAKCo7rCxYJQASAAPpA -JhXgCXUAbZoTiYLqhgAkQCEAAIqBCQmOmYEKCo7qhgApUASAAFgMRNogWAxA0Q8AAC3CLqrdCd0R -/QAARH/+HgCKIYsgCgqOCwuO+kAmFeAJdQBtmhOJIuomACEQIQAAiiEJCY6ZIQoKjpog0Q8AAABs -EAQTMSgMIhGjIoIg0Q8AbBAEFTElDCQRpUQjRsAkQsDRDwBsEAQVMSH4WqoFqGIdAOpkEQtPQoAA -5UUIDM9CgADomQgEOcEAAOdCCAGB6YAA9kBoHaADhQAPAgBtOhDjkhwkyCEAACSSGySWGiOWGwZg -hgUCZwZAhgUCZQYghgUCYwYAhgUCYdEPBeCGAgJvBcCGAgJtBaCGAgJrBYCG8hCoHaADhQANYhEI -IgsPAgDTD9MPbToQ4yIcIRAhAAAkIhskJhojJhvRDwBsEATyWlgFqDIdAAozEaMiIixw0Q8AAAAA -AAAAbBAELSANKyAMFC8Z5y8XFouBgAAocH0uQliw3wj/KKvur+4oIAX9BWAB0Ao1AGiEdvUACYKS -AJ0A9QAKWxIAnQD1AAqrkgCdAGiIBcAg0Q8AACokBWTRXxgwVgjuCyriwB8w2QoMSgjMEQ/MAv3g -AAYwCQUA/RdmFamqYQBtqQIphrwq4sAfLYwKDEoIzBEPzAL94AAGMAkVAP0XZhWpqmEAbakCKYa8 -9WAFoxIAnQAaLQPoQqYmh4mAABkt9am5KZB9I6IurZkJMwgJMxGjgyM8gAi2ESoyFA8CAC6hAy2h -An7ReisKAFrnASgwDcumLzBVwJEImDmq/wj4DPcGAAqwiAUA6FUCCdAEgAD6oGgd4AwVAFv8kNyg -61QACdAEgABb9FVj/61kj8TqMAwkAUmAACxwfStCWLCJDJkoqripiBkuygmICiiCgP/+uA2miAEA -AAAAAAD5QGgdr/+aAMClKiQF2iBb9TDxR+gN4AyFAOwkBS0QBIAA0Q8AAAAA/2BoHa/6fgD6AAId -oAyFAOwkBS0QBIAA0Q/A2PxAph3gAgUA0Q8AACOiLaszCTMR8wAAQf/8fgAYMIUG7xGo/yjykPEf -9IvSAJ0ACCpB+ACCHeAIBQBtmgR6gQSxiGP+diqMJPvyRhWv+cIA0qDRD2wQBBYv7wYmCyViwcd/ -BzcDB1UBBUUCJWbB0Q9sEAQYL+gogq5xhhGJIs6a2iBb/3jOo2hTB8Ag0Q/AINEPiif6gGgd4AwF -AOqsICpoBIAAWubh0qDRDwBoU96KJ8Cw+0QAFaAMFQBa6oMdLaKdoIwg+mC2BeANFQDrpgIuZgKA -AA3MAv1AJhWgAgUA0Q8AAGwQBC4gDS0gDBMwUuwudxcDwYAALMB9KjJUsOsMuyitqquqFC/DBKgL -L4LBGSyVHDBK+eYAD/AKNQD/GCYV4BsFAFgGjypCrnGmNCsiAmWwP9ogW/9Lz6eLIC4ymvp1SBWg -DBUA/28ADbANFQBa5mAvICOx/y8kI9EPAAAAAAAA+kAIFe//WgD7oGgdr/5eAACKJ8Cw+0QAFaAM -FQBa6lEfLXGfoIsg/mBUBaANFQDupgIt5gKAAA3MAv1AJhWv/nIAAABsEBAZLF0pnfwpkucUL5gX -MCL/OAAUsCgFAPkPAAxwAhUAEzAeK3IRIzLz6bz/LAIKgAD3YAZQkTOdANaQ/T8gFaAFBQADCEFp -gwJ8WRL0oCAV4jMdAOtZ63Mz/QAAYACfHSxFLdItKnJfrW0J3RGtqi5Cri2gIuDnFX94BIAADshC -eNkKHi/gwIAodLgO/gEA0QT8QAEH3/j1AAj/Aw/vAS9GrilCrnGWo4mimhgsFhTrFhUsgKYAAIoY -W/8AKxIV7BIUJXxJgACKGCqiBysKAPtEABWgDBUAWuoRKxIVjRgeLS+eoI3QLBIUHi/o7qYCLu4C -gAAC3QL9QCYV7/1GACpyZyihAy+hAvngBRQiAJ0AFS0HHC/i/CEmFaADBQDbMFrmIhwsFCzCLSZy -EStyX+rKCA0YBIAA6S36HVZCgACqui6gDSmQfS2gDOoWFidD/QAACYgorWaoZg7WOARmCy9iwQ+P -SWXwVCliwQWZAilmwS9iwRgvywj/AS9mwS5yV4ug+uzoFaAMBQD/bwANsA0VAFrl5SpyZy6hAy2h -AsDB/68ADrALBQANyzhkv28TLdQvMoNx/hrAINEPAADAofwhKBWgGwUAWAX8+iLIFa/+agAbL7Ul -MriVHRwvtCU2uAsAh+sABwDQQQAACgBhjxWOFIkW6RYAKugEgAD4IOgVoBsFAPggJhWgClUAWAXr -LTKDHi0hKnIR/6YADrAEBQDtNoMlBDGAAGRQfhUvoCkKgJkc5F8MAsLxAADoFgsgsEEAAP4hRhXg -AL4AKnIRjR2MHIsbDR0U7RYNJmAFAADsFgwl2AUAAOsWCyIgBQAAeks3jh3L4o8dgxrjQwgH/0CA -ABsrvSuyLSpyX6tLCbsRq6pb/ylvRLIsMH1kz6yOG8DA/9gwFaADbgAcL4KPFo4VjRT4IOgVoApV -APggBhWgGwUAWAW9KBwQCCCHwEAEQmIBIGP0n/b/EgCdABMrpisyLipyX6S7CbsRq6pb/xMBRIex -RARCZOFEBwp3kAAAY/606VQAAgShgAD6gGgd4AoFAP6BgAfQ+40A6lB9IsgFAADk8C9n2/0AAO2Q -fSTACQAADwIA0w9tug7rgHwkQAkAAKraLYB7qrrqgHwtWASAAKvbq6qqygpfFA7/EQ9vDP3gaBXk -mgEAAJEEACgaCN0C7fYDJmAFAAD/n/Z0IgCdAOoSDCgECoAA+Z/7qFIAnQBj/8IAAAAAAAD//twN -oAoFAGwQBNEPAAAAbBAEGiv8LaKEKKKHKaKH+WAABDuZgQB5iQHRDymigiLQB28rAtEPAMCl/F5w -BaALBQD+QAAXMP8FAFgFdR0sMOktGRETxQAA8EPwDeAMhQD+AeIdoHoVAA/qMCvSRa+7D+owD78M -avEICOowCLgMa4H2Di82D6oMLJZS7yIMDV/CgADrllMpfo4AAAvqMAjqMCrSRauqCKgMaoEIDeow -Da0Ma9H2LJZSLgriLpZT0Q9sEAQE6jAVLxYiUoByQwQkVoDRDyhSf+RWgCRABQAAKFZ/0Q9sEAQT -KzSIOGmADgrqMIk5CpkMapEDwCDRD8ChWAWmiThqkRwbK78MKhGrqiuinm69HCKineQgJWTj/QAA -nDjRD8CgWAWdiThrkdjAINEPwNoNnTT8YQYV4AIFANEPwNoNnTSdONEPAGwQBIkniJr7JAAVoAIF -AOuSCSQBCYAA8WGQDeAspQAdLRMpsAArsgJ8mQh9sQgeLRF+sQLRDwDAsvwAAh2gDSUAWuVW0qDR -D2wQBIkniJrrkgkkAImAAIkiyJ/AINEPAAAAAAD//7wNoAsFACywHYq2i7UAzDJYB13aIFv/4dKg -0Q8AAGwQBIs1iDQsMBztMgYpUASAAAuAANKg0Q8AAABsEAYvMgAkIgAYK+H+dAAF9//BAPXgBsbS -AJ0ACPgKKIJ4ZIDwGS4vGC7EKZKuD/UK6FUIBIQ+gAAqUHzzQAn30gCdAOZQfSWhgoAAC2wBDAxD -/WpeDaD99QAnUH59cQyLMQsLR/dgB61iAJ0AJ1CAKkAgizAcLO13qAsjUH8vQCF8uElz8EYZLq0G -SEMPAgAJiAoogn8ESgILgADqJgAlBImAAMAg0Q8cLqYuQA38gZAV4AolAPogBhXjhgEA+CAmFaAL -BQBYBNvGKtEPABwunS5ADS1ADJMR+iAGFaALBQD2IEYV4AolAFgE0scv0Q8cLpb8gZAV4AolAP6B -sBWgSQUA+CAGFeALBQBYBMrGKtEPAAAAAC1ADP6BsBWgCiUA/F0UBaALBQBYBMIi+trRDxwuhy9A -IS5ADS1ADCpAIJoQKVB/mRH4sBAVoAsFAPggRhWgCiUAWAS3xirRDxwufS5ADS1ADPogBhXgCiUA -9iAmFeALBQBYBK/GKtEPLUAM/oGwFaAKJQD8XOYFoAsFAFgEqCL6udEPAAAAbBAKHy5vDSsRD7sI -KrCA7LCCJ/qxAAAPLwso8NXyACId4A4FAOzMASVT/QAA7KoBBEAFAAD6RQAGN6oBAOq0giQC+YAA -/WPoFeAEBQANyQqJkAoIRACABAkJGcmabQgUf588sar4LgAM96oBAOq0giSAQYAAY//kACmwgejw -1SZgBQAADJkMCUw4C8oR/8AgFaeqAQDqtIIkQAUAAHjjrBsqju0qbB1mAoAA+3BoFeAeFQD+QAoM -IgCdACXSLapVCVUR5bUIDhgEgAAUKsUDAkcEIgooIpADihQLgAAoIpT6YGgdoAsFAAuAACgiltow -C4AAh6H1QGgdp3cBAPTgCGrSAJ0AKqIAGSs79qBoHaf6wQD14Ase06qhAAn7CiuyeGSxdhwtiRgu -HSzCrg/yCugiCAYEPoAALSB886AOX9IAnQCaGCsgffNABooSAJ0ACr4B+iEGFaPuAQD/QAX1IgCd -ACogfigK/3ihE4lB+iDmFaeZAQCZFPsgC00iAJ0ALSCALmAgikB96CAvYCGeFp0VGCw/LCB/nBn5 -QAVwogCdAJwZ/eAFJiIAnQAZLf0LSEPTDwmICiiCf+ukAAtQBIAADwIAC4AA5aQABQdpgADAwGbA -OohAGSsHCIhXCYgKKIJ46lQAClgEgADsdAAJ6ASAAAuAANEPJdIuqlXjwwIKrkKAAPVgAEL/+woA -AMbK6jQAClgEgABYBmXRDxwt4YkYLmAN/MGQFeOLAQD4ICYVoAolAPggBhXgCwUAWAQW//44Da/s -pQAAAAAAHC3XiBWKFi5gDS1gDIkZmRH6IAYVoAsFAPggRhWgCiUAWAQK//14Da/89QAAABwtzPyh -kBXgCiUA/qGwFaBLBQD6IAYV4AsFAFgEAGP/pC1QDP6hsBWgCiUA/FuEBaALBQBYA/r9+0Idr/x2 -ABwtvi9gIS5gDS1gDCpgIJoQKSB/mRH4UBAVoAsFAPggRhWgCiUAWAPuY/9aHC20iBcuYA0tYAz4 -IAYV4AolAPggJhWgCwUAWAPlY/85AAAAAC1QDP6hsBWgCiUA/FtSBaALBQBYA9799yIdr/q6AGwQ -BIkw2lDtLaUZ2ASAAOwwCCSoPIAAbsYt8AAYDa/spQDAwO4pvxSkZIAAL9CCL7QIKdIerpkJSRSZ -tCjSH5i1WAYRwCDRDyzUgv//VA2gDAUAAGwQBOYkAAmQBIAA40QACyAEgAAPAgAPAgBtOQ/jIAAh -EAUAAONEACIgBQAA0mDRD2wQBNYg0w/TD21JB+MkACEQBQAA0mDRD2wQBCkKYPgF4h2ge6UA8i4A -CrA6lQBtWVoiMAFyiwxyown2WgAV4ABmAAAA4psPcTslAAByswf2VSAV4AASACIwAOKLD3GYCQAA -cqMH8loAFaAAWgBymwtyswjyVSAVoAAiAAAiLMkMLBGsfOxFACIgCQAAwCDRD2wQBAIdFGTQevwM -Ah2gCQUA+gXiHeB/pQD+ByIdoAgFAPQAQh3gAgUA4ycIAVAJAABtWiwicAAMiBHiuw9zuAUAAHLj -B/JaABWgAFoAcssLcvMI8lUgFaAAIgAAIizJqCgEkgj5ICAV4AUlAOgkAC0QBIAA8kAAQ/AIBQDt -mbFxUAkAAMAg0Q9sEAQCMhRkIGf6DAIdoHylAPgF4h3gO5UA9EABBzACBQDyQABD8AgFAPxBABXg -BYUAbVosInAADIgR4psPc7gFAAByswfyWgAVoABaAHKrC3LDCPJVIBWgACIAACIsyago6EYAIiAR -AADuSbR+kASAAMAg0Q8AAABsEATnJAABgoGAAPoHIh2gKPUA+g9CHeBpBQDyAAIdoAYFAG05Lqdj -IzAAAiIK44sPczAFAABzowfyegAV4ABWAHObCnOzB/J1IBXgAB4AIzzJAyIJ0Q/AINEPAGwQBPBF -IA3gBwUAw7n8D0IdoCn1APgAAh2gagUAbSkuo3IiIAAIiArimw9zuAUAAHKzB/JaABWgAFYAcqsK -csMH8lUgFaAAHgAiLMkCiAn4gAYVoAIFANEPwJD4gAYV4AIFANEPAAAAbBAEIyUC4yUDIWBBAAD8 -QAYVoAsFAOslBSHB/QAA8sAAAfeIHQDoJQQhgUGAAPpgaB2gDRUAWuqGaK4V+mBoHaALBQD8QAgV -oA0VAFrqgGmu6chLKSEEDJkRKZwQmUDRD9EPAGwQBBgo+xIpAiiCNCIigAmIEQgiCIgny4T8WaQF -oApFAPxACBXgCwUA7yIHKXAEgABYAwAbK5McKPPtLMsZUASAAFqCt9ogWoKa0Q8AAADAofoIAh3g -TAUAWFTy+kAIFe/89QD6QOYVoA0FAFg8aWP/pgAAbBAEEyyqAwCH4wAHAQBJgAACAGHRD9EPbBAE -Eyq6IjK4Ija40Q8AAGwQBB0poR4pZB8ssxkstRIqJhMsrxUsrxwssSw2jiU2fiI2hSk2cCk2cS82 -hi42je3SRSTRAQAAKjaA6jaBJNiBAAArNnj6byYV4AgVAPhuphWgZEUA5DZ9JMmBAAApNogpNokC -0igE1CiUUJLwFCyeFSycEiyeDt0oncAiNo8lNn8kNofRDwBsEAQTLJkSLJn0AsId4AcFAPgD4h2g -BNUA0w/TD21KIuI2gCGgCwAA4jZ/IRAxAADoVjYCqAUAAOdFAiGYMQAAJkUD0Q8AAABsEAQYKQMC -BEcPAgAIRAooQpACihQLgAD8YsCA0ZoBAGiRAmmTHChCltogC4AA0qDRDyhClPpAaB2gCwUAC4AA -Y//iwCDRDwBsEAQSKuEjIqIiIlyjItEPbBAEGipAAikJ0w8KmQojlmQq+sAKSgH6pgANMCsFAAuq -AiqWZSeWZgwCACmSZgnqMBgpSyiCRQiICgmCCgbqMAYmDGphDm0ICAvqMAsrDGqxAmP/8NEPAGwQ -BBYp66YmJWKAx38HNwMHVQEFRQIlZoDRDwBsEAQYLFYNJxEPAgCod+JyACGAUYAAAslTKTQA8IBw -DeOiwQAqRADwoHAN6bJhACtVAPDAkA3qwgEALGUA0Q/RDwAAAGwQBOgqRxGAyYAAFSutKIB9JVJ/ -sDQIRCiiUqQi0Q8A0Q8AAGwQBOokAAnYBIAAW2VBZqGwGSl+9lCaBaAHFQADJRGpVCxCgB0sNQ8C -AA8CAA3MAixGgCpChhsoYAuqAipGhhgp3QhVCCtSBBwsLQy7AitWBChSHSoqAAqIAuhWHSEIUYAA -9EAIwJIAnQD0QAkxEgCdAPRACbGSAJ0AKEKGGSjK6YgBDfoCgAAI/wIvRoYuYH3zwAQ/0gCdAOok -AAnYBIAAW1ci6iQACdgEgABbVtfqJAAJ2ASAAFtWj/rECBXgCgUA/B9CHaACFgAAAOokAAnYBIAA -W1YpaDEFbzc+bjQ7wKT8WA4FoAsFAFgCKvxSjgXgCiUACio2A6wRDcwILsK4HyiUD+4CLsa4K8K4 -HSqhDbsBK8a4W1YAZqCpLUKAHilyDt0BLUaAjFMHzAKcUytNBIuw57sCAmATAAD7gAYV4AIFANEP -sap8oYAJ6jCrmQ/qMA+fDGrx7G0ICA3qMA2dDGrR4GP/8CtiaAtMQ/+AABYzuwEA/WYADb/8AgAr -YmgLzEP/gAAWM7tBAP1mAA2/+6oAK2JoCxxQ/4AAFjC7gQD9ZgANv/tSAAAAK2JoCzxQ/4AAFjC7 -kQD9ZgANv/ryANKg0Q/SoNEPAABsEAYkCqDyUngFr/71APhSigWgDRUA/FFQBaAG5QD2AsId4A8F -AP8D5hXgJXUA/wPGFeATBQD/EAYd4ADiAAAA+UPeDaALBQD6UTgFoBkFANMPbZoMKKGU5IF/dVAJ -AACxu+/8ASGb/QAA5DGaZmAJAAAqwZTTD/VABbxiAJ0ACjoU90AHlCIAnQBopQr3QOYN4Bl1AHmp -JCgihADxBADZGurBlCzcAoAAC5kCDpkDCYgBCLsC+lCGFeOqHQBooj/5X/vlUBhFACoihcG/D7sM -+0AGoWAYBQBj/4Zmv4MpIoQAsQQA2BoAihEKigIOiAMImQEKmQL4UIYV7/2iAAAAKyKF+lIQBaAY -9QAPiAz5f/qCIgCdACjBlPlQEBXiiAEAAIEEANsaC5kC+VAGHe/80gAqIoTpK4AfgQqAAADbGg64 -AymSEuiqAQ3cAoAAC6oCKiaEGigfCelRAZkRCpkCKyKWGCt2KsGUCLsBC5kC+FLGFe/8MgAAKCKE -APEEANka6sGULNwCgAALmQIOmQMJiAH5ZgANs6odAPpQhhXv+7IAAAAAAAAA+lCIBaALBQDTD22K -DimhlMWH6JEIdVAJAACxu8e7KCKEGSdlKgr/6pQpLYEKgADqlCou0AqAAACpEQmpAg6qAwqIARoo -zgmIAvhQhhWgCfUA+VAGHe/5lgAAAAAAAAAA+FaYBeAIBQCYEPogCBWgaAUA+TYQFeADhQD0AgId -4B+FAOakAA0CCoAA/sYAD/CZnQDlZQIE/ayAAAhmAvNGAAnwCwUA+lA0BaAcBQBtylAsoZR8OSEk -IoQAsQTsoZQuuAqAAO54AwvMAoAACXcCCEQBB0QCJCaEfPEFfFECfGkXKCKFALEEANwaAMwRDskD -CYgBCMwCLCaF67wBJVAJAACPEOkrIxf4BQAAnxD5//rKUgCdAB8nLyjwfXuHbBkn/PoAAh3gGgUA -baoULJGU7wIABMgJAAD1gARvEgCdALG7xzv6T+YFoAsFAPgCAh2gjIUA0w9tigwpoZTskQl1UAkA -ALG7K/r7LCKEALEE4NoaCYEKgAAA2BoIqgIAqhEOqAMIzAEMqgIqJoQL6jAZKHspkm95szgaKHkt -8iArpm/7TcgVoAwFAFgEvRwodCvGHyrGHisih/pQ5hXgAgUA0Q8AAAAAAAAA82BoHe/93gAeKGst -4m6x3f3NxhXv/u4AbBAEFih1piYlYoDHfwc3AwdVAQVFAiVmgNEPAGwQBATqMBgnwyiCRQKIKKhC -A+owAyMMajEObQgICeowCSkMapECY//w0Q8AbBAEKCAKIyAIGifSwFDrIAspoASAAOo6CwwBFgAA -LKK5fLMXKSEC75tdZOgFAAAlJAn8QEQd7/JVANEPKKK4AioCDwIAC4AA8UMQDeALtQD0YoYNoAkV -ACQkCCUkC/hBRh3v8lUA0Q8qIAvlJAolUAUAAPpBZh2v8lUA0Q+xNHtJzcAg0Q8AAPxgaB3gChUA -/FVwBaALhQBYANfHK9EPAGwQBBooOxwnkPpAAEUwAC4AAABkUEHNaiuigAs9Ae1J8XKr/QAAynr6 -4AYV4AIFANEPAAAJ6jArwkUGuyirmQ7qMA6eDGrhzw3qMA2dDGvR9mP/w8Ag0Q/tJAAJ8ASAAP6A -aB3gChUA/E+EBaALhQBYALnHK9EPAGwQBBYoHaYmJWKAx38HNwMHVQEFRQIlZoDRDwBsEAQVKo8M -JBGlRJNA0Q8AbBAEEyqLDCIRoyKCINEPAGwQBCoKbPwP4h2gG3UAWFaDwCECogkCAkfRDwBsEARk -QFEpIABkkEvAcOgwACIMy4AAeYkqbQgaB0YM6GE1Y7gFAABqYg+jeKJ5KZAAKIAAeYkMY//eo3ii -eSmQACiAAHiTC/kCNg3gAhUAwCDRD8cv0Q8AwCDRD9EPAABsEAQdKmkYKmn5oGgd4KoFAG2qBQgA -hgkCYespAR7QBIAAWAVD0Q8AbBAGEymr9FRcBeAIBQAPAgAkMq4ZKBIJSQEpNq4oVqgoVqkoVqoo -VqtYWWQbJzEqOugqtkVYWVTmoKhtEASAAFhZMFhY8NKgW//jZiCVWFhj5qCPbRAEgABb/9/+gYAI -kAYVACxSgNMPf8cQHSpHDU0B/HXGFeAKNQBaf99YV4/moGltEASAAFhXHuagVW0QBIAAWFa+5qBK -bRAEgAAiMq7TDw8CAHQvTh4nzQ4uAS42rlhWn1hWj+agKG0QBIAAGyhn/FDMBaAKFQBYUkkZKi/q -ln0lBtmAAPcwRhWgAgUAZyAEwKFa4YLRDwAAW/+6Y//tY//8AAD4TSgFolJBAAhXEQcERwhECihC -kOgWACrQBIAADwIAC4AACglBaJEH+SAFYdIAnQAoQpbacAuAAM2piBDaUAuAAAoJQWiRAmmTZShC -ltpwC4AAZK/klqEcKhCcoBsqEBopTIgQ+kAEBfKSgQAppIDrNq4q0ASAAAuAAChClNOg+uBoHaAL -FQALgAD4kkgVr/vFAPpgBAXwDKUA7LsCCtAEgAALgADyX/qQkgCdAGP/Cf/+eA2gCgUA/FP0BaAK -FQD6AAId7/1FAFgAD//8aA2v8kUAAAAAAAD//XANoAoFAGwQBAPqMBYmwyRif3QzCCNmfyJiftEP -ACJifuNmfyEQBQAAImZ+0Q9sEArjKeYZwASAAJYYlxkrMT4qMh0pMH7lFgct3gKAAKul8yAH06IA -nQAL6jAtMqeYE/1gB2PiAJ0AKzanHSasFinYKjKm/aioFeAMBQBYA4ybUYgT7mIAIshBAADyocYd -oB2FAPqgBhWgAgUA/qBGFaAKxQDoVA8neAUAAP7ABhXgCMUAbaoFBACGCQJhIlTP6BYCKtAEgAD+ -IgAVoAmFAP4gJhWgBKUA5FTOIPjBAAD+IAYV4CRFAG2aN7SI6BYCL1gEgAD5oc4NoBnVAGAAEgAA -AAAAAADpigZ/2ASAANhAmBKrjCzN/yzCP+ymNCVQEQAA+qBoHaELBQBYBIkdKFAoMT4t0sKxiPng -AAQ43R0AfYkEIjU+0Q8oNT7RDwDRDy4yprHu/nTGFa/8PgAAbBAE+EDoFa/19QCJg4Mii4KbkIqC -BUUDBTMB+UAmFeAGBQCWgpaDkyLRDwBsEATrNAAKaASAAPpAaB2gDAUAWn9fAioCWn9B0Q8AAGwQ -BBUlhoNYyDDJKBgowiiCqflAAAQxhAUA+IFWDaCJBQCZWNEP0Q/Hz5xYCuowGyZRK7JFLBr0DLso -q6qaWdEPAAAAbBAEFCV1hEjyTA4FoAh1AOg4KAGoKQAAdUIUJSKu+KPWDaAJBQAqIq3HJAqSOdEP -wMD6AAId7/JFAAyyOdEPAMDg/AACHe/yRQAO0jnRDwBsEAQUKWQVJWAkQICFWLo48IJwDeACBQD4 -pC4NoAl1ABIl7Sgirgk5KPkD9g3gCgUAIyKtxyQDojnRD9EPwMD6AAId7/JFAAyyOdEPwDD6AAId -r/JFAAOiOdEPAGwQBGQwnvRgBKJSAJ0AZDCM+FEIBaAJNQBtmiHrUgckSBMAAO1SBiRgEQAA65YA -IqvhAADrzQQkQCEAAJ2wGCU7Gih5BoY4GCiKGyiIiWUdKIaPZ4xmn6iPZJzYHSiGmbiMY4liGyiE -n4ic2Jm4HChtGSY86yYlGcICgAAISAIJiAL5n+YVo+qFAG0ICbCqy60pwv95sAJj/+/AINEPxyLR -DwAAABopJCqggGSvYuokAAnYBIAA/IBoHeCMBQDuVAALeASAAFgAmNKg0Q8AAADHK9EPbBAE5iQA -AYNZgABvNF9kMFwdKE/sJggZwgKAAAhIAvm/5hWj64UAbQgKsLtksLsp0v95wAJj/+74UIwFoAk1 -AA8CANMPbZoh6Y0EJFgRAADpkgAl2BMAAOlWByKr4QAA6bIAJEAhAACZWMAg0Q/HItEPGij8KqCA -ZK+VEiT3iSjjJYkUjbOAACsyrmSwcyoyrWSgb7CcnCj4wAgVoA8VAC+kAP9BBh3gAgUA4qQJKl4C -gAAPuwKboQnqMCmlBf0AABQwCTUACYgCmKMtYAaOYi82re/uAgboBQAALWQG/sBGFabdAQAtZAbR -D8cr0Q8AwKBb/1KJKGuRjf/+aA2gCgUAwKDAygycNPxBBhWv/i4AAAAAbBAMGyVADwIA6wAFCMgE -gAAJAmEJAmHrAAUAyIEAAAkCYQkCYWQwsxklUfRgB2iSAJ0A9GAHqRIAnQD0YAS6UgCdAGQwjxgn -/fogaB2gCTUAbZoh66IHJEgTAADtogYkYBEAAOuWACVT4QAA680EJEAhAACdsOkn8hDQgQAAHygC -GygAiKUdJ/6Mpo6nnpic2I6kHSf+mLiMo4iiGyf9nvic2Ji4HiflGCW17CWdGfoCgAAPTwII/wL/ -3+YV4+qFAG0ICrCqZKByKOL/eMACY//uwCDRD8ci0Q8AABkonSmQgOomyRrcAoAAKxYC6hYKJPqp -gADqJAAJ2ASAAPyAaB3gjAUA7xwgKPAEgABYAAwKogIGAAAAAAAAAADpFgsq1MKAAPogZhWv/E4A -6RYNKtzCgAD6IKYV7/wOAMcr0Q9sEAQcJICKyOclEhuYBIAA90AEwJIAnQAocq76AOId4AlVAAO5 -OfkABOPiAJ0AKXKt5JCTZWv9AACdyMDi7pQAJNBBAAAGIIYKAmMGAIYKAmHkMDdk0MEAAPLIaB3g -CFUACgJnA0CGCgJlCFoRCooCmpEvIAYodq0E/wL+QMYd4AIFANEPAAAAAAAAAPygABawDDUADc0C -nZErIAYsdq0EuwL6QMYd4AIFANEPwKBb/s4cJFSKyPlf+vCSAJ0A//3kDaAJBQDAkMDqDq40/4EG -Fa/9qgAAAABsEAgYJLrTD9MP6AAFCMgEgAAJAmEJAmFkMJz0YASqUgCdAGQwjRgnf/ogaB2gCTUA -bZoh66IHJEgTAADtogYkYBEAAOuWACVT4QAA680EJEAhAACdsBokNRkncxgnhRwngx4ngYuljaaP -p5+YneiPpB4ngJvIjaOLohwnf5+IneibyB4naBklN+wlHxnCAoAACEgCCYgC+d/mFaPqhQBtCAmw -qsuoKeL/ecACY//vwCDRDwDHItEPGiggKqCAZK9k6iQACdgEgAD8gGgd4IwFAP4gaB2gDwUAW/+T -0qDRD8cr0Q9sEATKOW80Ick+HCUG+k6YBePqhQBtCAqwqmSgqiiy/3jAAmP/7sAg0Q/HItEPAAAZ -KAkpkIBkn9AqIAb/TsAGEAYVABUkAYlY4ySSFI3/gAArMq5ksIsqMq1koIewnJxYiyAmpACWoSak -CCSkCQzqMCylBf1gABWwDDUADLsCm6OJIiggBgaZAukmAiRABQAAKCQGLyAGjiL2daYVr43VAP4A -AAc2/wEA/kDGHeACBQAO0jnRD44iLfqN/gAABzACBQAO0jnRD8cr0Q/AoFv+V4lY+T/70JIAnQD/ -/ggNoAoFAMCgwPoPnzT+oQYV7/3OAAAAbBAElyPoJHYa1AKAAOgmAipKgoAACpkC6iRxGd4CgAAL -awKbIQqZAukmACEQQQAA0Q8AAGwQBBcj8RYjz+VygyGA6YAAJH35pCQkQH0iYi6jRKQiCSIRolIi -LIDRDyRiLaJCCSIRolLRDwAAbBAEFiQlAgVHDwIABlUKKFKQAoYU2mALgADHnAmpAek5AgGc9QAA -wDjjkwICAKmAABgm8yiCrv8A4AMQCUUACTMCKFKU+kBoHaALFQALgAAoUpLqZAAJ2ASAAAuAANEP -8yBoHe//sgBsEAQZJ6OIMAQKBio0BvkABAR3ogEA6DYAJS0ZAABoo3MTJAMDowooMpAChBTaQAuA -ACgylNWg+kBoHaALFQALgAD4ckgVr/vFAPqgBAXwDKUA7LsCClAEgAALgADRDwAbI5EaI7Ersi37 -UGgVqMIdAKy7CbsRq6qLp4u+jbDJ0/1gKBWgDgUAnrDutgEp2ASAAAvQANEPAGwQBAIKR2ilJhMj -4wOjCigykAKCFNogC4AAKDKS+0BoHeAMNQDsuwIJUASAAAuAANEPAABsEAQZI4MoIgHpSTYJ0ASA -APkgABS/iAEA6YgCCuAEgADoJgEpWASAAFv/wsAg0Q9sEASUK5UuJiYRIyUSKCANKSEHixyMG40a -jhguJFQtJGDsJGEr1QKAAPpFhB3rmQEACpkC6SUHJACBgACPHoMdIyQhLyQg0Q/RDwAAbBAEGCUh -ZCBD+khCBeAHBQD5EBAVoAYFAG0pEQBgBAgJG++XBnMwBQAAuHfTDyqySCuxjytFAKeqqjr6gEQd -r6qBAPqAJB2gAgUA0Q8dJBAs0kgt0Y8tRQCsPPyARB2vzIEA/IAkHaACBQDRDwAAAGwQBBknNiiQ -gCWQfyKQfuYl0Bq+AoAA6HcCCRYCgAAFIgL2VwAJcgUFAAUiAvZABAMw9eUA9oAmHagiHQAFIgHy -gAYdoAIFACuQgStEAiqQgipEAyiQgyhEBCNEBdEPAGwQBCggDcmCKyEr2jD8oGgdprsBAFv/4tKg -0Q/aMOtEAArgBIAAW//C0qDRDwAAAA9EEQQUFAVKAmSgTMlMCk8E+16gFaAJFQDqmQwNAQqAAAVE -GPygAQLQBBoACl8EKqz1+0AEAN/pFQDqmQwNAHoAAABUGvQAAh3gA5YABQQZ/KABAtADagAADyIR -AhIU8mYACbAn+QABIhDmIgIJgFYAABQi+QQiAsAw0Q8PIhECEhQDKgJkoEvJLAovBPteoBWgCBUA -6ogMDQEKgAADIhj8YAEB0AI2AAo/BCqs9ftABADf6BUA6ogMDQB6AAAAMhryAAId4AGyAAMCGfxg -AQHQAYYAB/JQ8EgAETADBQDRDwT3UAF3EAciA3ZMBxQi2tMPBCIC0Q8ABEgRBYgCZI/S4kQACpgE -gADRDwB1Mz5gAEUAAGwQAhYmzgQnA3YkwHZE1PNUAAQ6lKEAZJ7RZI9KBkQCGibIBiICCYgMCkQB -CiIB8oI2Da+APQByQb2wiOMiGAmYCoAABCIMdTsBsCL6ACId4DlFAPRvAAnwCgUA4yIYCZgKgADT -D22YJguqGOQjGH3YCoAAdCFIBCIM5TsHddgFAAAiLP8FMwzjIhgJmAqAACk6/umICATIEwAAeYtB -dCMHdCEjsbtksKLjtAAMQwKAAKiiB/dQAXcQByIC0Q8AAHU7s2P/wQAAdTPddTnVsbtksHgLGxT/ -eAAVv/8+AAAAZoAQ+SAgFaADBQD3AAARP/8SAAAICAbggAQEYFeAAOurGA2wCoAA+p8ADTAAagAA -b41A66YYDcgKgAD4ZgAJ8bqdAMCg8kYACXAIBQDII8CRCWYCZ29xsbvIvw9mEWVvZwsbFP94ABW/ -/YYA+0AgFa/9ZgAH8lDwSAARMAMFANEPAAAAbBACFiZ1diQy81QAAjlWoQAFRAxrTDBmQD2xRPZG -AAu6gD0A43UYAmTRAAAAQQQFBRkFAgYHUjvRDwAABCQRA0QCyELHL9EP+sgAEj/19QACVDvSQNEP -AMAg0Q9mIATSUNEPAAViEdEPAAAAAAAAAGwQCCMWASIWAOUWAynQBIAA5BYCKtgEgABYAM0oEgKC -EAODKAUiKKMi4qIIDZgEgADRDwAAAAAAbBAI21DqJAAJsASAAPCOcA3gLAUAdCsL8gACHeACBQDR -DwAAB08E58gMA5U5gAAAgAT64AQA0TKdAAVNGPZLAA+4AD0A/eAAB38tgQACNC4CMyzzwwAOf58B -AO9EGAnYBIAA7EsZelAEgACk2u2jD3Hb/QAAfKsH6toIAdv5AAAMrwwC+C4C/yzv7CgMdAKAAO6e -Ag/QBIAA7OsZfxAEgACu0u0jD3fT/QAAfCsH4tIIB9P5AADsIgwNnAKAAOOjAguBCoAA6jQACtgK -gABYAJJ6IxX6QAY1IgCdAABxBABoGvsABcLiAJ0A8n/gFeACBQDRDwAAAAD0QAVC4gCdAAlfBOSQ -D2yBCoAAAyIY4FsaCZgKgAD74AAGf9uBAA0kLg0iLPODAA04AD0A40QYCXgEgADqSxl6cASAAKtO -6+MPcXv9AAB66wfuvggBe/kAAPvPAA0/gwEADakuDa0s7c4oDOQCgAAMjALuyyN+0ASAAKvM68MZ -dtP9AAB+yxHg8xEG0/kAAPNGAAnwAgUA0Q8A8xHzRgAJ8AIFANEPwCDRDwAAZFFSDr8EZOFU7skM -DwEKgADguxoMggqAAPqfAAo/24EA+8AEAN/LAQANRS4NRCzgqBoMggqAAPvABADRJp0A5M4oCxgK -gAD4RgAJOAA9AOJVGAp4BIAA7lsZetAEgACrWuujD3J7/QAAfqsH6roIAnv5AAD/TwAMP1IBAA2E -LA2ILuTCKAxEAoAA6FUCCnAEgADiWxl60ASAAKta66MPcnP9AAByqwfquggCc/kAAOKiDA/8AoAA -D+8CDSQsDSUu9YMADTgAPQDjVRgKEASAAOpbGXrwBIAAq17r4w9yE/0AAHrrB+6+CAIT+QAA+88A -DT+DAQANqS4NrSztzigM5AKAAAyMAu7LNH7QBIAAq8zrwyp20/0AAH7LIuPc/ilEAoAA6DMCD5AE -gADRDwByQwJ1MxfyACId4AIFANEPACMR46MCD5AEgADRDwDyAAId4AIFANEPwLEFuyxj/qQLogz7 -8AAG/8sBAP/9NA2gDxUAAAAAbBACAwVf9F0AC39CgQADSxwPAgCrZvrA0g3gCQUAsZnyXQAN+AA9 -AOaZGAswCoAAq2Z7awIpnAHlQhwLGASAAKki0Q9sEALgQQQCZEcAAOMiGAmYCoAA0Q8AAAD8YAEB -UAMFANEPAABsEALgQAQCZEcAAPJLAAnxIp0A0Q8AAADynwAJsAIFANEPAABsEALLLfYAAh3gAFIA -AAAAbBACyi3yHwADsCItAOQvBAu4QoAAAEEEACUa9LgAEbslHQAlSh0EVQwMVRClIgciAtEPAMAw -0Q9sEAIC6jDRD2wQAswlA/AxYAAPAG8iBQPxMWAABW8jBQPyMQACANEPbBACzCUC8DDRDwAAbyIE -AvEw0Q9vIwQC8jDRD8Ag0Q9sEAIiCoAjCgBtKA4oN0AoN0QoN0goN0wjPQEDAgDRD2wQAiYnAAMC -ANEPAGwQAiUnAAMCANEPAGwQAgIERaQzIzw/A2MUbTkFJicAIixAAwIA0Q9sEAICBEWkMyM8PwNj -FG05BSQnACIsQAMCANEPbBACAgRFpDMjPD8DYxRtOQUlJwAiLEADAgDRD2wQAgMCANEPbBACAuQx -0Q8AAAAAAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAIANt4CADcvAAAAAAAAAAAAAAAAAgA3DkAAAA -AAAAAAAgA28YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIANmGCADepQgA3gQIAOOMCADezAgA3pI -IAN61CADekAAAAAAIAN6tCADeUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIARTmCAEUywg -BFt0IARagCAEUUAgBFIYIARaeCAET2AgBFKEIARU7AAAAAAAAAAAIARaKCAEWYAgBFCMIARP2AAA -AAAAAAAAIANJmCADUUAgA0tUIAM5vCADStQgAzm0AAAAACADOHggBpYQAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAACADZTAgA1pEIANctCADVCwgAzm8IANWLCADObQAAAAAIANjPCAGlnAAAAAA -AAAAACADYTAgA1g8AAAAAAAAAAAgA1T0AAAAAAAAAQIAAQAAAAAAAAAAAAABAAECAwQFAjIyAAAA -AAAAAgAAAAAAAAAAAAAAAAAAAAMQAAAAAAAAAAAAAAAAAAAEAAAACACJBgAAAAAAAAAABAAAAQgA -iRQAAAAAAAAAAAQAAAIgAAy8AAAAAAAAAAAAAAAB/wAAAB/84TAAAAAA4AAA4AEAAAAAAAAAIAXA -HAAAAAAgBb+4IAW9iCAFvHggBarAIAWCtCAFcMAgBW+YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -IAQDUCAEEqAgBBKgIAQSoCAEILggBDdYIARGECAETNwgBAAgIAP9lCADucwgBGTAIAO3aCADtDQg -BW9sIAVuRCAFZ5AgBBKgIAVmuCAFZXQgBWT4IAXsaCADJBggA5qQIAXZlAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAIAPbJCADxpggA9VIIAPTtCAD0jgAAAAAIAPP3CAD2mAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAIAdBiAAAAAEgBz+YAAAAAiAHOwQAAAABIAc4aAAAAAEgBzZc -AAAAASAHNGAAAAABIAcx4AAAAAEgByVIAAAAASAHLBAAAAABIAckIAAAAAEgByQYAAAAAQAAAAAA -AAAAAAEAAQAAAAAAAAAAAAAAACAF0SggBAGMIABb2AAAAAAAAP8AAAAO/wABAAAAAAAACgEAgQAK -AQABAAoBAAEACgEAAQAOAwEBAB7/gYEAHgKBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAEbBAMDARsCAwMBGwMDAwEbAgEBAR8EgYEBK/+BgQEqAYGBASkBgYEBHwOBAQEfA4EBASz/gYEB -PQKBBQE8/4UAATz/hQABOQEFBQE+DwUFAS4EgYEBGwIBAQAOAoEBAS4CgYEACgIAAQAOAoEBAA4C -AQEBGgGBgQEOAgEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAwEA -AA4DAQEATwQBAQBfBAEBADwEAQAAAAAAAABs/wEBAEwEAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAACADnYQgA54AIAOdoCADnhQAAAAAHwAAAAAAAAEAAAAAAAAAAgEAAAAAAAAE -AgAAAAAAAAcSAAAAAAAACAMAAAAAAAAPEwAAAAAAABAEAAAAAAAAHxQAAAAAAAAgBQAAAAAAAD8V -AAAAAAAAQAYAAAAAAACABwAAAAAAAMAWAAAAAAABAAgAAAAAAAIACQAAAAAAAwAXAAAAAAAEAAoA -AAAAAAgACwAAAAAADAAYAAAAAAAQAAwAAAAAABgAGgAAAAAAIAANAAAAAABAAA4AAAAAAIAADwAA -AAAAwAAaAAAAAADgABsAAAAAAQAAEAAAAAABgAAcAAAAAAHAAB0AAAAAAeAAHgAAAAACAAARAAAA -8tUSmPLVEpjy1RKY8tUSmPLVEpjy1RKY8tUSmPLVEpjy1RKY8tUSmPLVEpgDhRsYA4UbmPLVEpjy -1RKY8tUSmPLVEpjy1RKY8tUSmPLVEpjy1RKYAAAAAAAAAAAAAAAA//8ABQAGAAcACAAJAAoACwAM -AA0ADgAPABD///////8ACgAUAIwAggBkAFoAoACWAHgAbgBQAEYAPAAyACgAHgAKBM4EkgnOCZIC -sgRWBOIEpgO2BBoHsglWBl4CdgniCaYHTgI6CLYJGggWBiICxgRqAJYDegFyB3YAvgPeBPYEugRC -A6ICYgc6Bg4AggPKBC4AbgBaAyoBNgHqAz4HxglqAUoHEgWWCHoGwgH+BnICigNSBeYFvgjeAZoH -2gn2CboJfgeeCUIIogkGAV4HYgJOByYDFgEiBYIIZgWqCMoJLgiOAQ4FbgVaBUYG1ggqBjYCEgHC -BuoIPgDmBoYC2gR+Ap4EBgZKAiYIAgNmAKoDjgX6AEYB1gb+Bq4F0gGGB4oI8gMCCFIA+gUyAa4A -0gPyB+4AMgaaAu4FHgAeBQoAAAnECYgE2AScB6gJTAnYCZwIrAkQArwEYAFoB2wE7ASwAlgHMAPA -BCQDIAEsB7wJYAWMCHAGaAKABbQI1AnsCbAJOAiYB1gCRAEYBXgIwAkkBWQFUAggBiwG4Ag0AtAE -dAZAAhwAoAOEAcwG9AF8B4AISADwAMgD6AaQAuQFAATEBIgCqARMA6wEEAZUAmwHRAIwCAwGGACM -A3AAtAPUBDgDmAYEAHgAZABQAeADNAFABwgGuAH0A0gF3AGQB9AJdAeUCPwBVAccAwwIXAWgCIQB -BAU8BswCCAG4ANwGfAKUA/wH+ANcBfAAPAakBcgI6AL4BSgBpAfkACgFFAAUAAAEyQSNCckJjQKt -BFEE3QShA7EEFQetCVEGWQJxCd0JoQdJAjUIsQkVCBEGHQLBBGUAkQN1AW0HcQC5A9kE8QS1BD0D -nQJdBzUGCQB9A8UEKQBpAFUDJQExAeUDOQfBCWUBRQcNBZEIdQa9AfkGbQKFA00F4QW5CNkBlQfV -CfEJtQl5B5kJPQidCQEBWQddAkkHIQMRAR0FfQhhBaUIxQkpCIkBCQVpBVUFQQbRCCUGMQINAb0G -5Qg5AOEGgQLVBHkCmQQBBkUCIQf9A2EApQOJBfUAQQHRBvkGqQXNAYEHhQjtAv0ITQD1BS0BqQDN -A+0H6QAtBpUC6QUZABkFBQAACb8JgwTTBJcHowlHCdMJlwinCQsCtwRbAWMHZwTnBKsCUwcrA7sE -HwMbAScHtwlbBYcIawZjAnsFrwjPCecJqwkzCJMHUwI/ARMFcwi7CR8FXwVLCBsGJwbbCC8CywRv -BjsCFwCbA38BxwbvAXcHewhDAOsAwwPjBosC3wT7BL8EgwKjBEcDpwQLBk8CZwc/AisIBwYTAIcD -awCvA88EMwOTBf8AcwBfAEsB2wMvATsHAwazAe8DQwXXAYsHywlvB48I9wFPBxcDBwhXBZsIfwD/ -BTcGxwIDAbMA1wZ3Ao8D9wfzA1cF6wA3Bp8FwwjjAvMFIwGfB98AIwUPAAAACgCMAG4AlgB4ADwA -UACgAIIAZAAyAEYAWgAoAB4AFAAAAIcAaQCRAHMANwBLAJsAfQBfAC0AQQBVACMAGQAAIAKOLCAH -GqwgAo4wIAcgaCACjjwgByAYIAKOUCAHH2wgAo5oIAceLCACjnggBx4EIAKOgCAHHdwgAo6UIAcd -tCACjpwgBx2MIAKOsCAHIRwgAo64IAcabCACjrwgBxnwIAKOxCAHGbggAo7MIAcZgCACjtggBxlI -IAKO3CAHGRAgAo7oIAcY2CACjuwgBxooIAKO9CAHGKAgAo78IAcYaCACjwQgBxZ4IAKPDCAHGDAg -Ao8YIAcX+CACjyAgBxfAIAKPKCAHF4ggAo8wIAcXUCACjzggBxcYIAKOBCAHFIAgAo9AIAcUSCAC -j0ggBxQQIAKPUCAHE9ggAo9gIAcToCACj2ggBxNoIAKPcCAHEzAgAo94IAcTCCACj4QgBxLgIAKP -kCAHErAgAo+oIAcSiCACj8QgBxJgIAKP1CAHEjggAo/kIAcSECACj/QgBxHoIAKQBCAHEcAgApAU -IAcRmCACkCQgBxFwIAKQMCAHEUggApA8IAcRIAAAAAAAAAAAIAKQSCAHEAggApBMIAcP2CACkFQg -Bw+oIAKQYCAHD3ggApBkIAcPSCACkGggBw8YIAKQbCAHDvAgApB0IAcOyCACjhAgByNgIAKOGCAH -IowgAo38IAch1CACjiQgByEkAAAQISBCMGNAhFClYMZw54EIkSmhSrFrwYzRreHO8e8SMQIQMnMi -UlK1QpRy92LWkzmDGLN7o1rTvcOc8//j3iRiNEMEIBQBZOZ0x0SkVIWlarVLhSiVCeXu9c/FrNWN -NlMmchYRBjB212b2VpVGtLdbp3qXGYc499/n/tedx7xIxFjlaIZ4pwhAGGEoAjgjyczZ7emO+a+J -SJlpqQq5K1r1StR6t2qWGnEKUDozKhLb/cvc+7/rnpt5i1i7O6sabKZ8h0zkXMUsIjwDDGAcQe2u -/Y/N7N3NrSq9C41onUl+l262XtVO9D4TLjIeUQ5w/5/vvt/dz/y/G686n1mPeJGIgamxyqHr0QzB -LfFO4W8QgAChMMIg41AEQCVwRmBng7mTmKP7s9rDPdMc43/zXgKxEpAi8zLSQjVSFGJ3cla16qXL -laiFifVu5U/VLMUNNOIkwxSgBIF0ZmRHVCREBafbt/qHmZe451/3fscd1zwm0zbyBpEWsGZXdnZG -FVY02UzJbfkO6S+ZyInpuYqpq1hESGV4BmgnGMAI4TiCKKPLfdtc6z/7Hov5m9iru7uaSnVaVGo3 -ehYK8RrQKrM6kv0u7Q/dbM1Nvaqti53ojcl8JmwHXGRMRTyiLIMc4AzB7x//Ps9d33yvm7+6j9mf -+G4XfjZOVV50LpM+sg7RHvAAADAEAAAwEAAAWQgAAFmkAAGUMAAAECQAABAwAAAQPAAAENwAAHss -AAB7NAAB4owAAeaMAAHqjAAB7owAAfKMAAH2jAAB+owAAf6MAACNzAAAfnQAAI/cAAGRWAAAj/wA -AHUcAAB1GAAAdRAAAHfgAAB35AAAd/QAAZw8AAEQdAABEIQAAJQIAACYXAAAlgwAAJYUAACWIAAA -liwAANAoAACQCAACENwAAjDcAAJQ3AACcNwAAZBUAABgHAABoNgAAZCQAAB34AAAd+QAAHf0AAB5 -eAAAefgAAZQEAAHjwAAB58AAAevAAAHvwAAB88AAAffAAAH7wAAB/8AAAZQMACEACQCBAEEAIQAJ -ACEACQCBAEEAgQBBAIEAQQCBAEEAIQAJAIEAQQAhAAkAIQARAIEAQQCBAEEAIQAJAIEAQQAhAAkA -IQAJAQEAQQCBACEAgQAhABAQYQAAAAAAAAAAAAAwAD///8AAADAIP///wAAAWRCsgAAAAABZrH4l -AAAAAZQQH////wABlDQAAAARAAGUCB////8AAZQ4AAAAEQAAECh/////AAAQLH////8AABA0f/// -/wAAEDh/////AAAQQA9EAAAAAHsoAB//4gAAezA//+7/AAB7OAAAAAEAAHtAP//u/wAAfCQAH//i -AAHiiAAIAAAAAeaIAAgAAAAB6ogACAAAAAHuiAAIAAAAAfKIAAgAAAAB9ogACAAAAAH6iAAIAAAA -Af6IAAgAAAAAjcj/////AACN0P////8AAH5wf7///wAAfnh/v///AAB+AADAAAAAAZFUAf///wAB -kZwB////AACP2AB///0AAI/4/////QAAdRQAAAAHAAB1DAAAAAsAAHfcAAAAAwAAd/D/////AAGc -OAABgEAAAZz4AAAAAwAAkAQAAAA+AAEQeAD///8AARB8AP///wABEIgAAAAAAACUBAAA//8AAJQQ -AAD//wAAmFQAAAH/AACYWAAAAf8AAJYIAAAAAAAAlhAAH///AACWGAAf//8AAJYcAA///wAAliQA -D///AACWKAD///8AAJYwAP///wAA0CAAAAAHAADQJAAAAAcAAhDYAAAAAwACMNgAAAADAAJQ2AAA -AAMAAnDYAAAAAwABkFAAAAAvAAGg1AAAAYMAAZCMADgAAAABkJgAOAAAAAB5dAAAAC8AAHlwAAAA -BQAAefQAAAAvAAB58AAAAAXhAg4AAABAAAAA//AAADDU4QBeAAAIAAgAAOQAAADEMAAAxDEf/5W0 -H/+PLB//l3AgCPVAAABBHgAA8AMAAEEOAABAQAAAoAAAAKAgAABBiAAAf/8AAEGGAACAAAAAQYEA -AKgZAACoGgAAwwAAAKgbAACoHAAAqBcAAP//AAAQBAAA5Z8AAB8RAADuCQAA//4AAOr/IAj1cAAA -/wAgCPWwIAj18AAJiWgAAMRQIAj2ICAI9kAgCPZgAAAgAAAAxFEAAMABAADEUgAPAA8AAGGoIFAA -ACAJIxAAAEANIAkjcCAJIzAgCSNQIE//gCAGhsQgCSPgIAkkQCAJI5AAAMAGAAgAAiAJJIAAAIDX -AABAggAAxIIAAIQDIAkmcCAJJXAAAICmAACAPSAJJNAAAIBAIAkl0CAJJiAgCSUgH/+USB//lQwg -CScQIAj2gOEBmgAf/5TYH/+OBAAACAD/wP//ABAAACAJJsAABggAIAj3ACAI92AgCShQIAkoACAJ -J2AgCSew4QAuACACjTAAAJAAH/+PTAAsFACAAACA4QBaAIHw4IDhAC4IIAAAAOEAVgAMAAAA//OA -AAAMOABGAAAAPz///4CAAADz/////+D//wABAAAgBoAAIAaFpCAGgQDhAZIAH/+OAOEAigDhAA4A -4QB+AOEAegAAAgAAAH8AQAADAAAAgACAAMEAwP//I/8AAMgAECABIOEAjgA8AAAA//+//1Bo6Ef4 -////BAAAAJIAAADwAPAAn7/7+yAABAR/9///gAACAP//7////4D///f/fwAAfrAABgAAAAAP/wAA -frQA////AEkkkgAAfhgIAQgBEAEQARABCAEAAH5AIAEgARUVFRWEIYQhEBAQEOEBjgAAAP5/BAQB -gB//lpwf/5RwMzMzMyIiIiIRERER4QDOAOEAjgThAI4I4QCODCAGiMThAHYAIAKNUP//8ADg//4A -gAABACAGh8QAAJAIAAAIwIABxBHEEcQRAP8A/wBAAEAAD0JAAAAcIP//AAAgCSjAIAkpMB//lKAz -IhEAEREAADMzIiL/8P8AAAIAMyoqFRUf/5aUH/+VoAAA//0gCSngH/+VuCAI99AgByEkAFAAAACg -AAAgoAAA4wACAOL//wDQAAAAz//+ACACiKAf/5WsH/+AoB//lcjhADkAH/+A0B//j1Af/4EgH/+V -1OH//gAf/4EAAAP////8AAAABAAAH/+TcB//jvDhAZYA4QDeAOEA7gDhAf4A4QJeAOECPgDhAh4A -4QHiAAACAQDhAQ4A4QCSAAgAAAD///D/H/+UmB//lcz/8AAAAAKABuEBngD/+///IAj6ECAI+nAf -/4EoIAYSACACinAgCPrg4AAAAAAAfWwADwAAEAAAAAAAEAAgCPtAIAj7cB//j2Qf/4E4IAYUQB// -lQD//8f/gACAAB//pKAf/5QYH/ziAIAAAAAAAHtgH/+YgB/83gDhAZgAH/+PNB//lnAf/5SkH/+W -YCAJKrAgCPugIAj74CAI/AAgCPwgIAj8kCAI/PAgCP1QAAAf/yAI/YAgCP2gIAj94CAJKmAgCSog -IAkqgB//lcD/AAAAIAj+ACAI/pAgCP6gIAj/8CAJAKAAAAwgIAj/QCAI/6Af/5agIAYPQB//klAf -/50QH/+akB//mJQgAIgkH//vmB//7sgf/5ZAIACJtB//lcQCAIIQAgACEAIAABABAAAAABoAAAD6 -xogAIAAAAADwAB//lbAf/45EIAYQUCAGD8gf/4FQIAkBkAABhqAgBIrQIAkBYCAJATAgCQHAIAkr -wOEAEgCIAAIQH/+PMB//lgQAAPgA4QA2AOEARfwgBhIEH/+UOAAAfkwAEEEEAACP5AAAfUwACAAA -IAaJJCAGEKAf/5M8AEAAACAKAAAACgAAH/+UPB//lJwf/4HQH/+UuB//lLwf/5TAH/+U8B//lOwf -/5ToH/+U5B//lOAf/5TMH/+U0B//lNQf/4HwH/+WCB//gnAf/5KAH/+UYB//knwf/5RkH/+CgB// -lXAgAok4H/+VbA////8f/4LQIAaFlCAGhWQgBoQ0IAaFXB//lRAgBoPk4QBiAAAAZQAAAICAAABl -HAAA9wUAAEMEAAB9M+EAagAAAGQIAAA8AACAAAD/AP8AH/+DIAEBAQHhAGIQAABkDB//g0BVqlWq -AACqqlpaWlqlpaWlAABikAARIjOIEgADIAKNYAAAYkAAAGoAAABqGP//f3+AEAAAH/+DYAAAamAA -ACEBAAB1BOEAcgAf/4NwAAgAKQAAYoAACgApAAB0BAAAYkQAAGJIAABiAAAAangAAGLUH/+DgAAA -YtgAAGLoAABi3AAAYvgAAGLkQb3NZQAACcMAAGLsH/+DoAAAYvAf/4OwAABi9B//g9AAAGL8AAII -1QAAYwAAAQRrAABjBAACCNYAAGMIAABjDB//g+AAAGMQAACiwwAAYxQAAGMYAABjIAAAYyQAAGMo -H/+D8AAAYywAAGMwAAAnEAAAYzQAAGM4ABERE+EAAAABfXhAAAB1AB//hAAAAGKMAAB0UAAAE4gA -AE4gAAB0HAAAagQAAGoUAABiwAAAYswAAGLEAABiyB//ldwABAAphhAAAIAUAAOAFgADgBIAQ4AR -0gOAEAAFH/+PcB//jnAgCQXg4QHeAOEB5gDhAeoA4QHuAOEB8gDhAfYA4QH6AAAAfuiAAAcAgAAF -AIAABgCAAAQAAAB9gPAAD/AADw//3//+AB/8wAAAAIBg///X3yAHYMAf/44MIAkGMB//jowgB2GM -IAKIkB//jhAgCQZgH/+WREAAAAAf/5ZIVVVVX1VVVVUgBhCYH/+PMwCWAAAf/5S0AEYAAB//jhQA -AEAJAAAJxB//lSwf/5QcIAaEpAACYlrerb7vIAKNkOIABgDiAAYI4gACAOIAAgggCS6wIAkGkOL/ -/gAf/5T4H/+V/CAIQAAgCQbAH/+SWCAH0AAf/5ZoH/+WOGwQBCggIhn9ztMPA4gRqYgpgoAa/cwK -mQIphoAqICIrICMogoBbciQqICH9+44FoAt1APn7jAXhzrUA/kOEHaANhQD4RuQd4A6FAFu45dog -+gAiHeAMBQBbLMvAINEPAGwQBCggIhr9tg8CAAOJEaqZKpKAG/20DwIAC6oCKpaA6ZKAJAHBgAAc -/bIrwoQd/bENuwIrxoQqICIrICNbcgb/+1YFoc+1AC8lHO4lNylQBIAAW7lHyKzHK9EPwKdbuV5j -/8MAANogW7kpKiAh/ftEBaALFQD8AEId4A4FAFu4wCogIRz9nvoDwh3gDQUAW8ynKiAhHP2a+gPC -HeANBQBbzKLaIPoAIh3gDAUAWzDJwCDRDwAAAABsEAbj/ZIZyASAAC8yW2Twbxv9j/37IAWgBgUA -+CAGFeCHBQAowjEtMqSoaO6wgCxGQoAAqN1tCCEAYAQOCRt/lw3JKirQIQ8CAA8CAGWgEufdCAMw -BQAAf2slY//XAAAq0CHcQOsSACroBIAAW8yBLzJbHP146/12EzAFAAB/Y6LAINEPAAAAbBAG/frm -BaAKRQDyICYVoBtFAFvZBRL9bSct/S1yrBX9avG9oA3ghgUAJAoALyIxLnL1D08I7FCAL/5CgAAP -7ghtCB4AQAQMCBt/hwoq4CEPAgAPAgDNoObuCAIgBQAAfUscY//aAAAAABz9Wv36tAXgG+UAW8xd -LXKssUR9Q6xk0XzAQC8iMS5y9Q9PCOxQgC/+QoAAD+4IbQgeAEAEDAgbf4cKKuAhDwIADwIAzaDm -7ggCIAUAAH1LHGP/2gAAAAAc/Ub8gCId4BvlAFvMRy1yrLFEfUOsZNEkwEAsUIDTD20IDQBABAwJ -G3+fC7FEfUsxY//pAAAAAC0iMSpy9a1N7P03Hu5CgAD9QABFcAsVAPtEMBWgHQUAW8w0LXKssUR9 -Q7dk0NfAQCxQgG0IDQBABAwOG3/vCLFEfUsuY//rAC0iMSpy9a1N7P0mHu5CgAD9QABFcAsVAPtE -MBWgDQUAW8wiLXKssUR9Q7xk0I/AQCxQgG0IDQBABAwOG3/vB7FEfUsvY//rLSIxKnL1rU3s/RUe -7kKAAP1AAEVwCxUA+0QwFaANBQBbzBAtcqyxRNMPfUO7ZNBGwEAsUIBtCA0AQAQMDht/7wuxRH1L -MGP/6wAAAAArIjEc/QQqcvULSwjt/QMd3kKAAAuqCPtEMBWgG+UAW8v9LXKssUR9Q7r9+foFoAoF -AP35+AXgG+UAW/9Z/fn0BaAKBQD8L4Id4BvlAFv/Vf356gWgCgUA+gPCHeBNBQBb/1D9+dIFoAoF -APoAIh3gHQUAW/9L/fnQBaAKBQD9+c4F4BvlAFv/Rv350AWgCgUA+gAiHeANBQBby9/9+cgFoAoF -AP35xgXgCxUAW8va/fnCBaAKBQD6ACId4B3lAFvL1f35vAWgCgUA+gAiHeANBQBby9D9+bQFoAoF -APoAIh3gDZUAW8vM/fmgBaAKBQD6ACId4A0FAFvLx/35mAWgCgUA/fmeBeALFQBby8L9+ZQFoAoF -AP35mAXgCxUAW8u9/fmMBaAKBQD9+ZAF4AsVAFvLuf35hAWgCgUA+gAiHeANlQBby7T9+XAFoAoF -APoAIh3gDUUAW8uv/flqBaAKBQD9+XAF4AsVAFvLqv35ZAWgCgUA/flsBeALFQBby6b9+VwFoAoF -AP35ZAXgCxUAW8uh/flUBaAKBQD6ACId4A2VAFvLnP35QgWgCgUA+gAiHeANhQBby5f9+ToFoAoF -AP35QAXgCxUAW8uT/fk0BaAKBQD9+UAF4AsVAFvLjv35LAWgCgUA/fk4BeALFQBby4n9+SYFoAoF -APoAIh3gDZUAW8uE/fkSBaAKBQD6ACId4A3FAFvLgP35CgWgCgUA/fkQBeALFQBby3v9+QQFoAoF -APoAIh3gLRUAW8t2/fj+BaAKBQD6ACId4A0lAFvLcf349gWgCgUA+gAiHeANlQBby20tcqxk0EXA -QCxQgG0IDQBABAwOG3/vCLFEfUsvY//rAC0iMSpy9a1N7PxmHu5CgAD9QABFcBvlAPtEMBWgDQUA -W8tcLXKsJEwBfUO7wKT9+NYFoBtFAFvX5f34uAWgCgUA+gAiHeANBQBby1L9+KwFoAoFAPoAIh3g -DQUAW8tNZDHbghEU/F7yQABC8AMFANoQ+kBoHeAMRQBb1A6PENMPDwIA7PxMH/ICgAD14AQEON8d -AOTdAQxGAoAA+cYADzf/wQD/pgAO8AoFAP+mAA6wCxUA/CAGFe/dgQBbyzX9+HoFoAoFAPwgJBXg -CxUAW8sw/fh0BaAKBQD6ACId4C2VAFvLLLQi5SOFcZgFAAAV/CAS/CD+cAAWsApFAP34cgWgG0UA -W9ey/fhYBaAKBQD6ACId4A0FAFvLHv34RgWgCgUA+gAiHeANBQBbyxn9+D4FoAoFAP34PAXgCxUA -W8sV/fg4BaAKBQD6ACId4A3FAFvLEP34MAWgCgUA+gAiHeANBQBbywv9+CoFoAoFAPoAIh3gDZUA -W8sGLXKs0w9k0MTAQC8iMS5y9Q9PCOxQgC/+QoAAD+4IbQgeAEAEDAgbf4cKKuAhDwIADwIAzaDm -7ggCIAUAAH1LHGP/2gAAAAAc+/D6A8Id4A0FAFvK8S1yrLFEfUOs4vvmFoNhgADAMCwggG0IDQAw -BAwJG3+fCLEzfTtFY//rABj73iiCMSRy9ag47PvnHEZCgAD4gABCMBvlAPqEMBWgTQUAW8rdKkAh -HPvg+gPCHeANBQBbytktcqyxM30zqGAAC9EPAAD/+sgNoAMFANEPAABsEAjpRAAJ0ASAAPygaB3n -MgEA/CCmFeACBQD6IIYVoQUFAPggZhXgFEUA+mBoHaAb5QD8IGgd4QwFAFvKeC4RALEi9cPAHe8i -AQByS9z6AIIdoBtFAOz70RloBIAAW9dJwCDRD4oUGPvOHPvO/CCoFeAJBQD7LQAMMBvlAOgWAinQ -BIAAW8qwwLCbEfpgaB2gG+UA/CBoFeEMBQBbyqrAIPpgaB2gG+UA/CBoHeEMBQBbylosEQB1wBmx -IgICT3JL3sCi/fdyBaAbRQBb1y3AINEPAPpgaB2gG+UA/CBAFeEMVQBbyk0qEQHLcXaoMokS6Pur -EVARAACqmZkSeYuLixHsEgQl6AUAAA0LT5sR/WKSDaAOBQD+IEYVr/3GAHaozMAh0Q8AwKL990AF -oBtFAFvXFMAg0Q9sEATApP33OAWgG0UAW9cP/fc2BeAb5QDy4AABMQwFAO40AAlQBIAAW7aO7TQA -CVAEgAD8IAIdoBvlAFvKde1kAAlQBIAA/fccBaAb5QBbynDtVAAJUASAAP33CAWgG+UAW8pr7UQA -CVAEgAD99wwFoBvlAFvKZtog/fcGBaAb5QD8ACId4A4FAFu2dtEPAABsEAb0AoId4QQFAPIAAh2n -MgEA+mBoHaAb5QD8IGgd4QwFAFvKDCgRALEi9QFgHa8iAQByW9zAINEPwCHRDwAAbBAG+GAJANIA -nQAW+z7TDyhihBn7agmIAvjQhhWgGkUAW9XNKmKE8/bMBe/7BQALqgH60IYVoAIFAMGkW9XGIiwB -cyn0G/tfAEoRDwIA66oICtgEgABb/b/ApP32tgWgG0UAW9bGE/ssKjJbFfst5PsrFQKJgADAICtA -gAAgBAsMG/GABGfSAJ0ALVIxKjKkDS0I/agAFrALFQD9QABFcAwFAOqgISjoBIAAW8naLhkADwIA -DwIA6jJbLwRKAACxInojtPFGQA3gAgUAK0CAACAECw8bf/dGLVIxKjKkDS0I7Ps6Hu5CgAD9QABF -cBvlAOqgISjoBIAAW8nGLhEADu4U6jJbLw1YAACxInojvGAAGbEi+l/7I6IAnQBj/6SxInojqmAA -BMYq0Q8AwKT99lAFoBtFAFvWkcAg0Q8AAAAAAAAA+gBCHaAbRQDs+yIZaASAAFvWiccr0Q8A/EBo -HeAKJQD99joFoBtFAFvWg8cr0Q8AbBAMwKdbtpzaIFu2geoWCiGMJQAAxirRDwAW+xMARxGleaaZ -KpB+KZB/4iAiLVYCgADqmQICw/kAAPghZhWvmQEA6RYJJBfZgACKGxv7AflAaB3gDQUA63sIBXxg -gAAe+wMtsAAO3Qkt0X77YCAV790BAAkfFGTwiiywAA2OFA7MAx76+g7MCSzBfg0NR+qwAS7uAoAA -Dc0D+WBAFae9QQDrqwMHy/0AAP9gAIW33QEA67F+Lu4CgABtmUEpgAANvQP9ADAV760BAPsOAA23 -ygEA65kDDl4CgADumQkEQAkAACmRfguZA/joAAT3uQEA6dkDDe4CgAAOmQkrkX4NvQMNDU+OGX3h -Gf31sgWgCiUA/iEoFaAbRQBb1jvHK9EPAAAAwKT99aYFoBtFAFvWNuz6xRlQBIAA+gPCHeANNQBb -yaLs+r8ZUASAAPwiABXgG+UAW8lT7Pq0GVAEgAD8IkAV4BvlAFvJTuz6tBlQBIAA/CKAFeAb5QBb -yUn6QGgdoBvlAPwiwBXhDAUAW8lEHPq6LxEKLhEJLREI+CFkFaAKRQD4IAYVoBtFAFvWF9og/fVE -BeAb5QD/9UAFoQwFAFu1l9og/fU8BaAb5QD8CCId4E4VAFu1khz6qe36ahlQBIAA//TQBaAb5QBb -tY0CKgL99PIF4BvlAPwAAh2gDgUAW7WH2iD99OgF4BvlAP/05AWgDAUAW7WC2iD99N4F4BvlAPwA -Ah2gDgUAW7V9wDD6QGgdoBvlAPwAAh3jDAUAW8lisTNpPecc+o3t+k4ZUASAAPoDwh3gDgUAW7Vx -7Pp3GVAEgAD8IgId4BvlAFvJVxn6g3WbCMcr0Q8AAAAAAPIAAh3gFEUA+kBoHaAb5QD8IwAV4QwF -AFvJASsRDPJgIBXhDAUA/WbAHa8zAQBzS9b99OgFoAolAPw7Qh3gG0UAW9XRKxELLBEILREJ7hEK -KVAEgABb/rnHK9EPAAAAAOz6UhlQBIAA/CACHeAb5QBbyTb6QGgdoBvlAP30xgXhDAUAW8ky2iBb -/tBkpWH6QGgdoBvlAPwjQBXhDFUAW8jgKBEN8QAmx9IAnQCJG2SSpvq/QBXgAwUA+iGGFeABagBk -nd7/9wQNoA0FAAADWQwpnP71IApQkgCdAPUgC7kSAJ0A9SANiZIAnQD1IBAiEgCdANog/fQwBeAb -5QD/9CwFoQwFAFu1JlqyIIob0w/6YBIqogCdAOz6PBlQBIAA/CACHeALpQD+ACId4I4FAFv+NWSk -Euz6HBlQBIAA/IBiHeAb5QBbyQH6QGgdoBvlAPLwAAbxDCUAW8j8+kBoHaAb5QDz4AAG8Qw1AFvI -+Isc+mGSDeAEBQDwALwNoAQFAPpAaB2gG+UA/fRCBeEMBQBbyO4sCvz8n/mboQkFAPUvAAy//MYA -ihx6O9QDfggG7ggo4IMt4IIv4IHu4IAsRgKAAAjdAvpAaB2v3QEA7RUOL/4CgAD/xgAPcBvlAP4h -5B2hDEUAW8jZ+kBoHaAb5QD8IeQV4QxVAFvI1PpAaB2gG+UA/fQGBeEMBQBbyND0gIAVoPvFAOtD -jHGYEQAAY/9e2iDy4ABG8BvlAPegAEaxDFUA7dCAIZgFAABbyMTaIP3ztAWgG+UA/OACHeEOBQBb -tNNj/pyjfabdLtCBLdCA2iD9wAAXMBvlAP+mAA6xDFUA8mBAFe/dAQBbyLTaIP3zlAWgG+UA/OAC -HeIOBQBbtMRj/l0AAADjdAgJUASAAPaAAEIwG+UA/JBQFeEMRQBbyKYuQIEtQIDo7hEJUASAAP+m -AA6wG+UA/eAABvEMVQBbyJ7qJAABmA0AAP3zZgWgG+UA/OACHeMOBQBbtKxj/gAAo3SmRC5Agy1A -gujuEQlQBIAA/6YADrAb5QD94AAG8QxFAFvIjS5AgS1AgOjuEQlQBIAA/6YADrAb5QD94AAG8QxV -AFvIheokAAGYEQAA/fMyBaAb5QD84AId5A4FAFu0k2P9mwDs+awZUASAAPwgAh3gC6UA/gAiHeCO -BQBb/aRkoxHs+YwZUASAAPyAYh3gG+UAW8hx+kBoHaAb5QD8AAId4QwlAFvIbPpAaB2gG+UA/AAC -HeEMNQBbyGcjXP3yTgAL8AUFAOMWDSOG6YAA9fMUBaAGRQD24AEDMANFAPpAaB2gG+UA/fMcBeEM -BQBbyFr6QGgdoBvlAPwjwBXhDFUAW8gKKREP0w/1DgAN96kBAAuqAwSqCSqhfgUIRwiIEQqIAwgF -TwlVAwWFTwRVCSVRfvjgAAQxDEUA7RwcLEYCgAD4twAKsBvlAPpAaB2vVQEAW8f2KREO9Q4ADfep -AQALqgMEqgkqoX4FCEcIiBEKiAMIBU8JVQMFhU8EVQklUX4ICEcIiBH4twAKt8MBAPGAfA3vVQEA -WrFAtDP2f/n1IgCdACMSDdog/CACHaAb5QD+AAIdpA0FAFu0PPpAaB2t05EA/CBCHaAb5QBbyCL6 -QGgdr9cBAPwgYh2gG+UAW8geAioC/fI+BeAb5QD/8joFoQwFAFu0LdogW/23ZKHDiRvTDwkJQWSR -6fUgFHCSAJ0A9SAWMRIAnQD1IBixkgCdACsRCywRCC0RCe4RCilQBIAAW/2Fihn1QAdcYgCdAMCi -/fJwBaAbRQBb1JLHK9EPAAAA+gBCHaAbRQD98mYFoi11AP5gaB3gDgUAW9SJKxELLBEILREJ7hEK -KVAEgABb/XHHK9EPAAAAAADs+QoZUASAAPoDwh3gDTUAW8fu+kBoHaAb5QD8BUId4QwlAFvH6vpA -aB2gG+UA/fI4BeEMNQBbx+X6QGgdoBvlAP3yMAXhDAUAW8fg7PkPGVAEgAD8IAId4AulAP4AIh3g -jgUAW/0HZKLNxyvRDwAA/fIcBaAKJQD8PWId4BtFAFvUYSsRCywRCC0RCe4RCilQBIAAW/1JxyvR -D9og/fHQBaAb5QD8CCId4E4VAFuz3Bz45O34yRlQBIAA//GOBaAb5QBbs9fAMPpAaB2gG+UA/AAC -HeMMBQBbx7yxM2k95xz42O348hlQBIAA+gPCHeAOBQBbs8uMGvv/Yh3gAgUADLI50Q8AAAD98dQF -oAolAPxSIh3gG0UAW9Q7KxELLBEILREJ7hEKKVAEgABb/SPHK9EPAAAAAAD98b4FoAolAPxboh3g -G0UAW9QvKxELLBEILREJ7hEKKVAEgABb/RfHK9EPAAAAAAD6QGgdoBvlAPwkABXhDFUAW8dJKhEQ -Gfi79Q4ADne6AQAMuwMJuwkrsX4FCEcIiBELiAMIA08KMwMDg08JMwkjMX78JAAV54gBAP0AABQx -DEUA+HcACbAb5QD6QGgdrzMBAFvHNSoREBn4p/MOAA53ugEADLsDCbsJK7F+AwhHCIgRC4gDCAVP -ClUDBYVPCVUJJVF+CAhHCIgRCFUD//Y0Da9VAQAAAAD6QGgdoBvlAPwkABXhDFUAW8cfKBEQ9Q4A -DPeIAQAJiAMZ+I4JiAkogX4FBUcIVREFhQP/9TwNr1UBAAAAAAAA+kBoHaAb5QD8JAAV4QxVAFvH -DyoREBn4gfUOAA53ugEADLsDCbsJK7F+BQhHCIgRC4gDCAVPClUDBYVPCVUJJVF+CAhHCIgRCFUD -//PcDa9VAQAAAAAAAPpAaB2gG+UA/CQAFeEMVQBbxvkqERAZ+Gv1DgAOd7oBAAy7Awm7CSuxfgUI -RwiIEQuIAwgDTwozAwODTwkzCSMxfvwkABXniAEA/QAAFDEMRQD4dwAJsBvlAPpAaB2vMwEAW8bl -JREQ8w4ADHdVAQAIVQMY+FQIVQklUX4DCEcIiBEIVQP/8ZQNr1UBAAAAAP3wwAWgCiUA/EJiHeAb -RQBb068rEQssEQgtEQnuEQopUASAAFv8l8cr0Q8AbBAEEvhVKiJ/W7N+KCKA/QAAFD8qgQAIIgLR -D2wQBhT4Tw8CACtCsPiVqBXv+AUA70KvJZg9AAAIMwGiOnrzU2SQUOpGsC1YBIAAHPhFLkKu8iAm -FaAKVQD6IAYV4B0FAPwgRhXgCwUA8iBmFeANFQBb04zjRk4hgSGAAPKKBhWgDhUA/onmFaACBQDR -DwAAAAAAAP/+zA2gAwUA/fBkBaAKFQD6AAId7/1FAFvTfcck0Q8AbBAKGfguF/grFvgrKJB98/BY -BeAU9QD78AQF4Q8FAPgAAAcwChUA7q45CeAEgAD/7QAONA0FAP+tAA2wDwUA+tHEHe8sAQDiZY8o -BAqAAPMABBfSAJ0AKGIYZIMKKWGaLmGRK2GTKmGVJWGXrr2q3eXdCASDsYAActFuwPEvZZz9gBrj -4gCdAA4IRGWDHwsJRGWTGQoMRGXDE/SAGIDiAJ0ADS8MDikMKWWQ/tMkHe/ZAQAL3AwsZZIKygwq -ZZQPqgz60wQdr6oBAAWvDP7SxB3gAdoALmGRK2GTKmGVJWGXDr0ICt0IBd0IL2Wc/YAXe+SOAQDz -C1wN5JsBAPMq3A3kygEAZcKl9IAVEOIAnQAOKQwpZZANIgzy0yQdr9kBAAvcDCxlki9lnAuYDAqK -DCpllAWuDALuDP7TBB2vqgEABagMKGWWKWWQ7GWSLseCgAAiYZLodoQpF4KAACJ2hy9hlg6uEe52 -hS//goAAL3aGK2GW7nb9Ld+CgAD6/4YV4AIFAOYhgGlIBIAAJGGay032gBNd0gCdAClM//UgE8Ci -AJ0ABEoCW7nmLXKKH/fFLGGO790BDXQCgAAO3QItdoosdv4qcoEb98ALqgIqdoHAqFvKcCtiwi5i -wOWlEQ0QBIAA9W8ACn/6BQAKRAH+gAbzogCdAChiv9MPZIDRGvevKaB99NhGFaBLBQALmQLppH0q -WASAABz3rS9iwfQgJhXgClUA+iAGFeAdBQD8IEYV4AsFAPQgZhWgDSUAW9LsZEDI5GbnIgyJgAD0 -AAId4AQFACpi58C49UAARTAMBQBbz73kJAgCqAUAAHNZ5MAg5iCUaUgEgAAtcoGZGB/3lCRhmiNh -mSVhlyphlSthky5hkSJhj/zThBWv+OUACN0BD90C7XaBJgGJgACTEZUSlBPs94gZaASAAOoWAC34 -BIAA+gCCHaALZQBb0smCGNEP//0MDaAEBQAc94CUE5MS5RYBKWgEgADqFgAt+ASAAPjTZBXgCkUA -+CCGFeALZQBb0ryJGNKQ0Q/SkNEPK2K4L2K39WHgFa/4BQAIRAGkWnrzPSlitcuX6ma4LVgEgAAc -918uYrb0ICYV4ApVAPogBhXgHQUA/CBGFeALBQD0IGYVoA0FAFvSpmP+5wAAAAAA//8sDaAEBQAv -ZZr+04Qd4CsFACtlketlkyFLgQAA+NIEHeNKBQD60qQdogUFAPTS5B3ljgUA/k8ACT/ZAQDiZZkm -44EAAPzSRB2v9fYAlRDs90sfaASAAO+kAA3wBIAA+gBCHaALZQBb0on/9tQNr+KlAAAAAAAA//pQ -Da/yRQD+QGgdoAolAP3ufAWgC2UAW9J///Y0Da/yRQAAAAAAAPyAaB3gCiUA/e5uBaALZQBb0ndj -/bkAAPyAaB3gCiUA/e5kBaALZQBb0nFj/aEAAGwQDB/3LvQAQh3gCGUAG/csLCpALPaqirGJsoez -hLSDtZMVlBSXE5kSmhGLsJsQEvcXHvckJPKFIiB9+CEGFaAGBQD0ISYV4jShAOU9NgF8WIAAAdIK -giAC7izCIPPBAA8wAGIAHvcXBT02AdcKh3AiCoAH7iwC7jYX9xMa9xX1wA22EAM1APXADNcQBbUA -lRryIWYV4Bg1APjv5h2gCZUAKXR+FfcMLHB/+u/QFeKEuQDk9wIcQQKAAOgWDC7JwoAACYgCrLsZ -9wEsQocLiwIJuwIKzAH9ZgANsAI1APqQ5hXuDAUA9qcIFaALVQAPAgDTD9MPbSov4nB/IiAhAADj -cH4iqCEAAAxmAQtmAqIyAoICCSICJlY2I0KHCjMBAyICIkaHJlI4GvbsF/bZ8iGIFeAEFQDk1DYL -EASAAOb23xohwoAABDMC7CIBCsAEgADrIgIAqKEAAOKGOCCggQAAImKQi0AZ9t2IUOoiAQ3cAoAA -CzsCC4gCCCIC5yICAmARAADiZpAi2BEAACiSkIzAi7DqiAEOZAKAAAw8AhP20Ay7AguIAgeIAiiW -kBn2zSuSwBz2zQy7AiuWwCjyuRr2ywqIARr2ygjYAgqIAij2uRX2yCWW2iOW3COW3iOW4sJABOQ2 -CEQQJJbkI5bmK5LoEvbBHPbCArsBDLsCK5boKJLAGva/CogBKJbAI/KsFfa9FPa9BTMBBDMC8/WG -FeACBQDRD5Uakxv27+YdoBK1APLvxh2v+b4AlRsodH727+YdoAlFAPghRhXv+WoAAABsEAQV9q72 -QAgVoCMFAG06BodQdnsFuFXCINEPlyAiUATRDwBsEAgmCgDjFgIq2ASAAOf2oxpQBIAA4hYFKSAE -gADrFgQhEAUAAOoWAyOogQAAKnJ/W8kU6yQADRgEgADqcn8p4ASAAFvRH+SgEWO4IQAA5XnbczAh -AADAINEPALE8rEwqwADF3f1ACDxgDwUA5fQACPAEgADyAAId4AIFAPQEQh2gJ/UAbQgTyaPKI3eh -PGgiWbHK3KAqoAB9oV1j/+XIMSc0AGRfr/SgBh2gAgUA0Q90qdriLAEmUAUAAOrmACdwEQAA/UBo -Ha//OgDvxAAhEAUAAOrMAS4YBIAA6uYAJ3ARAAD9QGgdr/66AHSpoi/EAPWAaB3v/nIAySZoIUJo -IjLIMSc0AGRfTPSgBh2gAgUA0Q+NEuLWACGAOYAAJzQAy18S9l/0oAYdpqgFAKgiomLRDwCLFPog -KBWgDAUAW8e7ixP6IAgVoAwFAFvHt4kS4pYAIYA5gAAnNADIUSRUAGau8hL2TyhqoKgiomLRD4kS -EvZL/yAGFeaoBQCoIqJi0Q8AbBAEKzIAJrAAwHDoaX5tyASAAGRgdgu5AvggAh2gCgUA/AEiHaAt -NQBtCF1obBV8YRJ9YSLojP8lUAUAAOYkACEQBQAAsXereSaQAGhpVWSAaM9iYABNACSQAPyIQATQ -BQUAq3vmsAAtuASAAG0IFORgMWKoBQAAJnABsXfoaSJryASAAGP/5NMPY/+bwIDoJAAk0AUAAPpg -BhWgAgUA0Q+re6tZyYLAsOskACTgBQAA7DYALRAEgADRD8Yq0Q8AbBAIW/7R7PYSGAQKgAD7QEGA -UgCdABP2Fxj2Ev/sJgXv9fUA9+wkBeAEBQD77BoF4AkVAPPsHgWgBkUAHfYPLbalLLakJLanGvYN -KramHvYMLrapHfYMLbaoLLarGvYKKraqLHKCHvYJHfYJDswBDcwCLHaCG/YHK3aGKXaHKkpFKnal -LvLwBu4CLvbwHfYCHPYDnNAqMsAb9gILqgEqNsAuMtAv6sD/wAQHcR9VAA/uAi420B31+y020Soy -2Bz1+hv1+gyqAQuqAio22C4y2x/1+A/uAi422x319i0mNSoy0hz19Rv19QyqAQuqAio20ioy0iiA -gCv6/guqAeo20iwQcAAALjLTGPXuH/XuCO4BD+4CLjbTJTb0JTb1KzLeHPXq0w8MuwErNt4oMsMa -9ef7AAQENQkFAAmIAig2wy0ywR/14/+gBAbwjgUADt0CLTbBKTLCHPXgGvXeG/XgDJkC+HhGFeQc -BQBb0C8a9dwb9d0c9d1b0Cwa9dz967oFoAtVAFvIHBr12f3rsgWgC2UAW8gZGvXV/eusBaALdQBb -yBUa9dL966QFoAuFAFvIEhr1zv3roAWgC5UAW8gOGvXL/euaBaALpQBbyAsa9cf965AFoAulAFvI -Bxr1xP3riAWgC7UAW8gEGvXEHPXGHfXE/EHGFeArBQBbx//7634FoktFAPwAQh2gDSUAW8bt++t2 -BaFLFQD8AAId4Pz1AFvG6PvrbAWhSxUA/AACHeD89QBbxuQa9bH962YFoO5FAP5BRhWgKzUAW8fr -GvWs/etcBaArRQBbx+ga9aj961QFoCtVAFvH5Br1qRb1qZosKiYLKiYNL2LUGfWmGPWnDwIACf8B -+eYAD7Aq5QD+2oYV4AsVAFuyRPoFwh2gC3UAW7I9+gWiHaALFQBbsj/6BaIdoCuVAFuyOPoFYh2g -CxUAW7I5+gViHaArlQBbsjL6BkIdoAsVAFuyNPoGQh2gK5UAW7It+gXiHaALFQBbsi76BeIdoCvF -AFuyJ/oEwh2gCxUAW7Ip+gTCHaArlQBbsiL6B0IdoEt1AFuyH/oAIh3gagUAW7Ig+gWiHeBqBQBb -shr6BsIdoAs1AFuyG/oGwh2gK+UAW7IU+gbiHaALFQBbshX6BuIdoDvFAFuyD/oAIh3gqiUAW7IQ -+gUiHeCqJQBbsgn6BKIdoAslAFuyCvoEoh2gCzUAW7IE+gdiHaALJQBbsgX6B2IdoAtlAFux/voA -Ih3gujUAW7H/F/Vc0w8rcYHBKPpAIbjiAJ0A+grCHeC6NQBbsfT6COIdoAsVAFux9SxxgfxAITCi -AJ0A+gjiHaA7pQBbsez6CMIdoAsVAFux7S1xgQ8CAA8CAPxAIHjiAJ0A+gjCHaA7lQBbseL6CAId -oEvFAFux3/oGYh2gS9UAW7Hd+ghCHaBL9QBbsdr6ByIdoEvlAFux1/oJoh2gCxUAW7HY+gwiHeBK -1QBbsdIoMv4Z9OIJiAIoNv4uYpAvCi8P7gIuZpBb/Ktmo9Eb9I7AkPtwEBXgDEUAbcoMAJAECwwb -f8cBsZqxmRL1JR/1Jhb1Ji1xexj1Jf9foBWgDEUA/4IADTDdEQDtyjkNSASAABz1Gy6CgPzvZBXv -+7UAC+4BLoaA8aAVZ9IAnQD1IBugkgCdAPUgG7kSAJ0A9SAcAhIAnQAW9OwZ9HspZowY9GQoZpAe -9Q/TDynmjCjmkB31DSnWjCjWkBv1DCm2jCi2kBj1Cypicca+C6oBKmZxGvUI6YJ/JEARAAD5SAYV -4BlVAG2aD+mCfyVQEQAA6aZAJEARAAAZ9P/A6C6WeirCMi0KBe2WeyUWMYAAH/T67/IAIMBBAAD/ -AAYV67qhAC2Sch709i/Av+7dAQDAQQAACP8IL/AADbsC+y5GFeAIRQAI/wIvlnQS9O0owjIklnPo -FgUkAOGAAFu29AKqCCSmgSsSBSumgiSmgxn05immgBr05f3pygWgTQUAbdoRK6J//WAMlCIAnQCi -viXmgLSqL3F+ZPI/wNAa9MT8H+IdoCt1AFvF8xr0wRv02Rz02VvG/Rn02ClmcBr0vBz01x302Bj0 -1fjPBhWiSwUAW8XpxLD36agFoAw1AAy7LPvpGgWhyx0A/YBgFa/+xQDuzAEN34KAAOqiIi5mAoAA -/WYADbAMFQAMuwIc9IT3QwALMD0lAA2qKCvGpVuzDRv0fSuyIiwKZOy6KA0oBIAAW7MIHPR4LMIi -LTro7cooDRAEgABbswOwWOisEQxsAoAA7cwCAVv9AAAMvAIsNuQAsAT2nwAMsBpFAAqZLCk27Soy -7JoWJDblAIAEBgYZBi4ULjbmCmgRKDbnBmkKKTboKDbpFfSlBWUoJTbqxEsEZCgkNusb9KLTDwuq -AQpqAio27P3pQAWiUoUA8sMACTAKRQDyfcYVoAuFAPggBhXgDQUA6BYBLHgEgABbz3eWEO8SBiro -BIAA4hYBKnAEgAD6AIIdoAuFAP3pHgWv/4EAW89uKHF+zI4pcX/MmSpxgMykK3GBZLEdwCDRD6K9 -9bAGFa/5xgAAAAAAAOTGJiSU8QAA9SAHihIAnQBpoTQpwKga9H4uoIcroIItoH0kpH0kpIIkpIep -2am5qen5lQYd7/TuAAAAAAAAAADvxiclDz0AAPlf6SFSAJ0AKMCoLsCyL8C3KcCtJMStJMS3r+6p -iCjEqP+WRh2v9A4AAAAAAAAAAPoAQh3gujUAW7DrY/u+AAD6COIdoAslAFuw52P7zwAA+gjCHaAL -JQBbsONj++YAAPUuRhWv9dYAKnF/Za25K3GAZb2zLHGBZc2t//awDaANxQDSoNEPAAAd9FH9hMYV -7/JmAB70UB/0Ti/GJv+E5hWv8iIAJsYnL8YoIsYp9YTGFa/x3gAmxicvxijzhSYVr/wmACwy4B70 -RB30RA7MAQ3MAiw24CoywBvzewuqAio2wCgy2BnzzRr0FRz0PQmIAvh7BhWgKwUAW8ZPwCDRDwBs -EAQS9DgiIX/ANfJCYIXgBAUAE/Q1JDSAJDSBJDSCJDSD0Q9sEAQT9C8U9DAiMX8EIgEiNX/RD2wQ -KPBTkA3gBxUA9EATCJIAnQD0QBNhEgCdAPRAGCISAJ0A9EATip/mpQDwBAQNoAMFAAAAJRJGJhyE -9qAAQr/mpQD84Ggd4AolAP3oNgWgCwUAW87vwKL6AAId4AkFAPivph3gCKUA6FR8KOAEgABbzucb -9BIqCgHqtIgrBVoAAB/0Di/yHfwAAh2gDgUA/k4ADHAEFQDqhAAEFemAAO33D3nABIAABEwC7jIA -IcARAAAKGhTkoC9lW/0AAOmCACZgCQAAbbkT64IBJmAJAADunggEQCEAAImArr7uggEvUASAAKqY -qO795+oF4Y8BAOSAMWDIBwAA84ABBfAKRQAIqgzrsgAkyEEAAKmI+iiGFeAJBQBtqQfphAAkQAUA -ACwSRK7OLtYeH/PlwOEu9IjINvRADhISAJ0A0mDRDwAAGPN8ADURqFP+oGgdoApFAP3nuAWgCwUA -7SQACfgEgABbzqvApfxgaB2gCwUAW86oKjAAIxZA/DCAFaAFBQDxU2AN4Pv1APtACfRiAJ0A9/1C -HaAJBQD4KKYV4AgFAPgo5hWgAQ4AAAAAAAAqEkcPAgBkroArEkEoogEsEkLtEkMo0ASAAAuAAOah -DG0wBIAAKBJA0w8ogADVcPEIIA3g+fUAeYF66hQAANgHAABb/RYoEADqFkYiuAUAAA8CAP8c4A3g -XLUAfImhKByEqKUtUHsuCl0PAgB+2ZAtHQHr3AQo0ASAAOzcCCboMQAAW/yl6hZHJQohgAAvEkVl -8SwY86GEoXhJifgoCBXgChUAKhZFGvOaA5kM+UOmFe/91gAAZmB0HPOWwLH7kQYd7/hWABXzlhjy -+QAzEaU1+GAAQb/7JgAV85IY85IAMxGlNfhgAEG/+toAAAAa8xEqoH0Z843o840VfQyAACOBxAcz -EfhgAEH/+lYAAPWAaB3gBwUA//X8Da/mpQD1gGgd4AcFAP/1vA2v5qUAJRJGKByE+KAAQr/1hgAA -ACOBwwczEfhgAEH/+VoAAADr8xgZ0ASAAFvS/voAwh2gCwUA/AACHaANBQD+AAIdoA8FAFvLodJg -0Q8A3XD75toF4AplAO/zChmsAoAA/KBoHaAOFQBby5gY82gogoBogBbz5sgF7/fuAAAAAAAAAAD/ -9jANoA4FABPzX//3JA2v9uUAwKL95roFoAsFAFvOJv/zHA2v5qUAbBAEFvNZKWJZKGJYJGJaqYgZ -8oioRGRA2yeSLSVipgl3EfagAELwCAUAKFQhKFQgKFUTmFyYWyhWDyhWDihWEShWEihUVShUVChU -fihUfyhVLChVMihVMyhVNChVNShVNihUbihUbyhUcChUcehUciIT/QAA+K5mHa/39QD2rsYd4AQV -AG0pZCKSLSNipihVOuJCCAIgBQAA6FUSKRZCgACiNShUcihUcyhUIShUIJhcmFsoVROYX5heKFYR -KFYSKFRVKFRUKFR+KFR/KFUsJ1R2KFUyKFUzKFU0KFU1KFU2KFRuKFRvKFRwKFRxKFUSKFU60Q/R -DwBsEBIZ8xwjFhEkFheFmIuViJeKloyUjZOOku+SASCwQQAAn2GeYp1jnGSaZphnm2WVaImQ6WYA -IRNhgAArEhcW8w74IugVr8kFAPNlYA3gB5UALWKGLmKE9kBGFe8FRQDjJgAsRoKAAOXVCARA/QAA -CYgB+GAARD/7BQALVQET8nkoJgH+oBCDoEcFAClig+owfSSQKYAAJWaGB6oC6jR9KugEgAD15OYF -oApVAP7QqBXgCwUA9CBmFeD4xQD8IAYV4BwFAPwgRhWgDSUA6BYBKmAEgABbzbAZ8l/qVAACjmmA -AOomAyUOCYAAiiL2AAId4AMFAPQiZhWgDQUA5KEfYKBBAAApFhItFhYrEheKQAuqKCsKZAuqLOBw -BAVQ/QAA+kBoFeaqHQD6IoYVoaqdACoWFaO7KxYYW8UALWKGKGKDLmKE+68ACr/7hQDrVQENeASA -AP6gBluiAJ0A6vJBFAYZgAApoH0lZob+IgYV4EsFAAuZAumkfSroBIAALBITKBIQL2KF/CAGFeAK -VQD0IGYV4A2FAPwgRhXgCwUA+CAmFaANJQBbzXzqVAAChBGAACkSGOqWACUHOYAAJRIR+iKoFeAM -BQBbyk0tEhYsEhgvEhT64AQA0A4VAO/GAy9wCoAAnsadxOXGAS/GgoAAqFWt/e0WFibr/QAA7cYF -ItsBAACbwooi4zwcIiARAADlFhEjuAUAAPr/93uiAJ0AwCDRD8BQ/iIGFe/9UgAAAC1ifC9iey4S -EPWg4BXv+IUACFUBpe5+80YpYnkPAgAPAgDLmu5mfC9oBIAALBISKBIQLmJ6/CAGFeAKVQD0IGYV -4A2FAPwgRhXgCwUA+CAmFaANBQBbzUT6oGgdr/yaAP//IA2gBQUA//gkDaAFBQDHJNEPwSbRD8As -0Q8tYnwvYnv9IGgdr/gFAOlieSaoPQAA+KAEArD6xQCqWnrzQMud6mZ8LWgEgAD+z0gVoApVAPQg -ZhXgCwUA/CAGFeD4xQD4ICYVoB0FAPwgRhXgDQUAW80l2lD546YF7/dmAAAA//8UDaAFBQBsEAQX -8lgINRHlRQIJN4KAAKdmlWDRDwBsEAoU8lOISYlIikeLRoxFjUSFQYZAjkOPQp8SnhOWEOUWASCw -QQAAnWCcYZtimmOZZJhlhUqVZvSBaBWgBUUA5GYHIQEhgABpIRTywGgdoAWFAG1ZCYgg44EIcRAR -AADGKtEPwCDRD/IgaB2v/54AbBAGF/I4G/I4FfHUE/I4KrACKhQCK7EA+iAEHeAINQAmUqQpMeMq -MkwrMkorNksrdiEqdiD5AAk44gCdACRxPyhwfY4g+0AAhr/PBQDruQkO7oKAAP0wABSz3R0A/afg -FeOZHQDv3QEHcP0AAO/uAQTI/QAAD5kB7iYALAEKgADudiQqIAqAAIwgLXYlLlahrczsJgAmYP0A -AA/MAZwgLHYmiCApdicsVqKpiOgmACRA/QAAD4gBKCYAKHYoBu5BAe4ILuAALDJMKFajBO4o/EAI -FeA19QAF7gsP7gEudin/oABGsAUFAO0mACYAyYAA+qBoHeAKBQBbsuouMkyxVdMPflPqLzJL8eFw -DeACBQD6QGgd4AoVAFuy4igyS7EieCPs8IFADeACBQD6QGgd4AolAFuy3LEidCnvKTJK0w/xIXAN -4AIFAPpAaB3gCjUAW7LUKjJKsSJ6I+zAINEPACxKAAy7NwuqN1uziCkxHCo2Iuo2JC0gBIAA5JEi -bO/CgAAN3QnrMRsm4A0AAA3cO/viHAWhzA0ArLurSwuqNpoSW7N6mhOKEluzeB3x0Sp2ISo2Sywy -JgSvDIsTK3YgKzZMLzYl5LgMDUgEgADoNiMmQJ+AAB7xxw7OCo7gCuAAAAAuUoMs0qb/tOgV494h -AP2hQBXkzFEA6RYBJgS5gAAa8b6IIBnxvfsAAEQwBBUA6YgBBmAtAADp8boeAQqAAABEGvjkRhWh -RB0A5Jk2DoIKgAD45GYV4USdAAS6LKmImCBbs0EY8a8ogr8OiBH7AAQA0A/1AOCtGg/4CoAALlKE -ihEEqiwk+v8E9AMOTgEO3QItVoRbszQb8aMrsr8OuxEAsQQAqRoqUr0EqgEKmQIpVr0qMkz6aWgV -7/aOAAAAKjI19UAAhT/74gAuUoMs0p4ODkPv0p8naCkAAP/84A2kzDEALlKDLNLODs5T79LPJ2gp -AAD//HwNpMwpAC5SgyzSyQ6OU+/SyidoKQAA//wYDaTMAQAuUoMs0sMOTlPv0sQnaCkAAP/7tA2k -zNkALlKDLNK+Dg5T79K/J2gpAAD/+1ANpMyxAC5SgyzStg7OQ+/StydoKQAA//rsDaTMkQAuUoMs -0q4OjkPv0q8naCkAAP/6iA2kzHEAAABsEAb34tQFoAcFAPXi0gXgCQUA+CAmFeADBQArYMHyACId -oAyFAA8CAOx8AgWB+YAALBYA6nQACVgEgABbyanUoPwgCBWgC/UAW8VQjhEFTwr+YABHMIoFAAru -Ai72gC1gwbEz7TPMcRAFAACPEeZsASO4BQAA/mAAR/ADBQDvFgErpmQAANEPbBASFvBsKQoA+tAQ -FaAIRQBtigwAkAQKDBt/xwGxm7GZGvB4FfDg+X+gFeAIRQD5AgAN//71APniegWhXQUA+eJ4BeH7 -HQD+sAYV4AUFANMPbdoZJYaBJYaAKpaDLpaCKpaB7paAJEAhAAApnBAb8TEc8TEd8TIe8TL4AAId -oEkFAG2aJAuJCimdBJWQDokKKZ0ElZANiQopnQSVkOyJCgRABQAAKZ0ElZBbsdr54koFoAqFANMP -0w9tqgflhjAkQBMAABPxHPPiQAWgBAUAJTbCJTbDJTbEJTbF5TbGKlAEgABbsaEb8Kfs8KYZUASA -AFuxluRMASEQgwAA4z0gKic8AAD54VAFoAqFAA8CANMPbaoH5YaEJEARAAAX8QzAgPT15hXiW4UA -bboWJXbGJXbHJXbIJXbJJXbK6HbFJEAFAAD4IGgdoBoFAA8CAA8CAG2qB+WGACRAEQAA8hECHeAC -BQDqJAAI2ASAAFuxZbEicynvGPDwFPD2/eHsBaAKBQD8AEId4AlFAG2aGCmCgAyZAimGgOSpCgVQ -BQAA7ZaNJECDAAAqYIDz4cQF4AIFAAAgBAoLG/NgCQ/SAJ0AIiwB4z0gKSesAAAIqxEscoAd8OIN -zAEMuwIrdoAY8OAqgIAtgIH0kWYV4GJFAPtAAIU/9OUA7SsMDVXCgAACqi0EqgH9QwAO8A4FAPtD -AA1wDyUAAt0sAqos/eBABv/zxQDzoAQG8b0BAPVABAUwCTUA6vo3AOGBAADtxgAkQBUAAOuqCAZg -EQAA6tsIAOlBAABtmk7pgIAkQBUAAKvu6tYAJugRAAAJmQnpgHws1cKAAAKqLQSqAQkrDAmpKAuq -KAKZLAn5NwKqLPVABAUxuQEAA5kBCvo36cYAJmARAACrqqqbC+kI+6AGFaYPBQDp+1xw6UEAACoK -AG0IHA2sCovAsaoKCkHuvP4llDEAAO7GACTL+QAAefs0Y//c2iD8KAAVoAsFAFvN4y0RIC02iiwc -QivBACzBAepggC3cAoAADLsC+nEmFe/64gAAAAAvWv/55PYN4AoFAG0IHA2sCovAsaoKCkHosgxl -8AkAAO7GACTICQAAefMCY//cKRxQjpDudoQk6BEAAO3SACPwEQAA7eaEJOAhAADswgAj6CEAAOzW -hCTYMQAA67IAI+AxAAArxoQpHGAskgDsdogk2BEAAOuyACPgEQAA68aIJNAhAADqogAj2CEAAOq2 -iCTAMQAA6IIAI9AxAAAopogsEhv74CwFo8wdAO7PEA5tAoAA790CDnaCgAAOzAL9hgAOcCuVAFvC -TMAg2iBbsESxImkk9cAg+kBoHaXr5QBbsJqxImkk78Ag0Q9sEAgV8FkU77YoUSL+ouQVoBz1APqj -JBXgAwUA51EVJBVhgAAmURsqUR2uvabdqt384CTD5P4BAPXmbA3kiwEA9QXsDeSWAQBllFb7gCKY -ogCdAA54DA1yDCJVHyhVFguPDAb/DP6jRB3viAEAC4kMKVUYAv8M/qPEHe//AQDq+QwJ2ASAAOlV -HCxHgoAAIlEY6EaEKReCgAAiRociURwO/xHvRoUpF4KAACJGhixRHO9G/S5ngoAALEb84lEgLZ76 -AADLLfZAIR3SAJ0AKSz/8yAhgKIAnQACKgJbsaQuQooY74MtURTo7gENfAKAAA/uAi5Gii1G/itC -gRzvfgy7AitGgSpRFPfgMgXgAgUA5vAYFQGhgAAoQr0PAgAPAgDniAEJTwKAAAmIAihGvSZGvFvC -EuSgCWEQBQAAxy7RDwAqURR6I88Krgod72X6AAId7/r1AP6RphWgHBUAbcoY3KDA+X+zAdww6N0E -JdgRAADshgAm6BEAAB3v/voAAh3gGRUA0w9tmhXcoC4KIX6zAgM8AizWFOu8BCboEQAAHe/1+gAC -HeAPRQBt+hPcoMCJeLMB3DAs1ijrvAQm6BEAAB3v7PoAAh3gCcUA0w9tmhXcoC4KIX6zAgM8AizW -LOu8BCboEQAAHe/j+gACHeAPRQBt+hPcoMCJeLMB3DAs1jjrvAQm6BEAAB3v2voAAh3gCUUA0w9t -mhXcoC4KIX6zAgM8AizWPOu8BCboEQAAHe/R+gACHeAPxQBt+hPcoMKBeLMB3DAs1jzrvAQm6BEA -AB3vyPoAAh3gCcUA0w9tmhXcoC4KIX6zAgM8AizWLOu8BCboEQAAL1HmZPGyKEKBGe++CYgBKEaB -IlEgI1EfKlEdJlEbLFEiK1EZJ1EV7lEXJg0ZgACWEJMRkhPs77Qd+ASAAOoWAivoBIAA+gCCHaAL -ZQBbylXAINEPACZChCJRFC9RFQYiDAIiFCJVFwL/DC9VFi1ChC5ChytRFg7dDA0tFC1VGQ27DCtV -GClChypChQqZDAkpFClVGyJChSdRFS5RFyhChitRGSZRGwgiDP9gAEa/ohEAKlUd96AARr8iEQCi -3/7gEDPiAJ0ADghEZYHWCwlEZZHQBg9EZfHK+4AOOKIAnQAoUSKq2Q5+DC5VFgl5DPij5B3v3gEA -C98M71UYJAhBgAAG+wwrVRoJuQz4o8Qd75kBAAqbDCtVHA7bEShRGOtGhCxHgoAAKEaHL1EcDp4R -7kaFL/+CgAAvRoYsURzuRv0uZ4KAAPyfhhWgCwUAZrDWLEKB8YAFMtIAnQAoQooICFX7AAQA0AIV -AAAiGgICT+JVICFo0YAA9kALldIAnQCwKfMgDACiAJ0A2iBbsNouQooY7rotURTo7gENfAKAAA/u -Ai5Gii1G/itCgRzutAy7AvqQJhXv82IAKFHnZY5GKVHoZZ5AKlHpZa46Y/5DHO9OkhOTEuYWACvo -BIAA6hYBLfgEgAD4pCQVoApFAPgghhWgC2UAW8nrwCDRDwDypAQd7/IyAAvoDAaIDChVGgqMDAnM -DPyjxB2vmAEACp8M/qOEHe/71gDSsNEP32Ds7pkfaASAAOoWAC3wBIAA+gBCHaALZQBbydf/7+AN -r+ulAAAAAAAA/uBoHaAKJQD93RwFoAtlAFvJz//vYA2v+0UAAAAAAAD6AEIdoAtlAOzuhxloBIAA -W8nHY/wBAAD6AEIdoAtlAOzughloBIAAW8nBY/vpkhDs7nsbeASAAP3AaB3gCiUA/2BoHaALZQBb -ybn/+iQNr+ulABzuc+rdCAvwBIAA+gDCHeAKJQBbybL/+awNr/tFAAAAAAAAAAD6AEIdoAtlAOzu -aRloBIAAW8mpY/uJAAD6AEIdoAtlAOzuZBloBIAAW8mjY/txAABsEBIa7vQS7f8c7vkpoRUoojcr -wAyNwu7ABCD4gQAALvQEjMCc8OmINwDgoQAALcYAKBYb+4CGHeQLBQD5YDATogCdAPojJhXgChUA -F+5qKnbxW8kDFO6SLkIyZOb/Gu7lGe7l9AACHeACBQAjoIMooIItoIEuoIAmkIMrkIIskIEvkIAO -IjcNIjcPVTcMVTcIIjcDIjcLVTcGVTca7eMlXAH4AAId4AMVAPtQEBWgCEUAbYoMAJAECgsbf7cB -sZWxmRzuziIWGC9Aci5AcS1AcChAc5gQK0B0KxYBKkB1KhYCKUB2KRYD+I7wFaALZQD4IIYVoApF -AFvJYxLutvomABXgCgUAW7B/Gu69iRyqmekWDSDQ0QAAW/xdKyHm5u6JFbAxgACIQy1CMo5Cpt35 -wQAPMB+FAA7dLA/cLOsSDSbwwQAAD+4uDt0MrcwKzBHrFhcmYDMAAKy7/2/gFa+PBQAP7gGeHS52 -xFuvoS0SGyhCMosdCt037O6XHu5CgADtuwgELfGAAC8SGQ//Dw3/ES8WGijBIPEBoA3vwgUALUHO -Hu3qK7w/ArsB6+aMLu8CgACtuyy8PwLMAZwdHe4WLNYBW8aRix0c7l4Y7jGquxnugeoSGyXY/QAA -ArsBLZHmqrrrhuUlUP0AAAKqAeukAAaniYAAmh6bHS9AcyJAdShAdylAdi5AdC1AcqiZou6v3S9C -Mq7d7ZkIDVgEgADpFg8skASAAOptDAehaYAA+I4wFeOvHQD6IoYVoAsFAPgixhXgCiUAW7AvKxIU -WrC8KxIUKhYVC6ooW68xLBIVih/AuAy7DPtDAA1wa0UAWrC0KxIVKhYQqrv6IiYV4AqFAAuqDCsS -FioWEvtDAA1wa0UAWrCrHO4qKhYTKRIUi0IoEhoJrSj2gcYVoPtNAA3+Ae5GDyQA+YAAqLiwiAj/ -AQ/uDJ5Ppu6LQi52xv6B6BWg+00Aih6m3Z1MHe2eDKo3q6rr0H0lU/0AAAr6AfqBxhWgaAUACLsC -CuoMpqqaTygSEyoSESvUffsAAEQwDYUACN0MiEMNnSj6IkgV4IhNAAjdAZ1NLRIQCbsoCd0o92AA -Rb6IBQD5oABGv8oFAGQgzilAcmSUKgLeLO6eKAXY/QAACrsBK0YQCu4BLkYRrrspQHNklB0C3izu -nigF2P0AAAq7AStGEgruAS5GE667KUB0ZJQQAt4s7p4oBdj9AAAKuwErRhQK7gEuRhWuuylAdWSU -AwLeLO6eKAXY/QAACrsBK0YWCu4BLkYXrrspQHZkk/YC3izunigF2P0AAAq7AStGGAruAS5GGa67 -KUB3ZJPpAt4s7p4oBdj9AAAKuwErRhoK7gEuRhuuu3vLDhjtVS+AfSkKIAn/Ai+EfVvIFItCKhIX -+iGmFaAKBQBb+4DmpBxtEASAAPqAaBXgChUAW/t70qDtQgMtIOIAAP2ioEFQCgUAbQgKsaoAoQQA -Oxp9uwJj/+6ITfy/oBWgC0UA7LU4AJiBAACjWSmQAJpGDYgsCYkuCYgM6EYFIJChAACiXy/wAI5F -7XbNL+iCgAAN7QKMRhrt3Ovt3BZj1QAA7XbOLmQCgABbxfKPQx3t2ItCjEUuEhiITwXMLKPpC4gs -D90s6ZABJmP5AACcR51IHO2cCYkuCYgMmEQY7a6i6iqgAYlE63bLLVBCgAAKmQKPRY1Er937pgAV -oB+FAA+qLgrdDOl2zCbowQAAi0SKRbHuD7ssD6osBaosDrssHu00ALsRC6oCLeYbKnbHix3rdsUu -zoKAAKm7KYJED5ks6+YYLM6CgACpuyiCRQ+ILOvmGSxGgoAAqLsP3Szr5hou7oKAAK27jkyNTi52 -yC12yhrtHi5CEC1CESlCEK2ZHe1E7tbbJMv9AAAvQhIp1twoQhMuQhKo7u/W1ydz/QAAKEIULtbY -KUIVL0IUqf/opvUn+/0AAClCFC+m9i5CFShCFK6I6dbfJEP9AAAuQhYo1uAvQhcpQhavme6m9yTL -/QAAL0IWKab4KEIXLkIWqO7v1uMnc/0AAClCGC7W5CpCGShCGKqI6dbhJEP9AAAuQhoo1uIvQhsq -Qhqvqu7W6SVT/QAAKtbq+4AFGuIAnQAf7Mku8H3CIALuAv/vph2gAgUA0Q8b7XP5YAQ7ogCdACsW -Gf/n4A2gCiUALkBwZOGSL0Bx7xYWJ4xhgACIQ67y70ICL9gEgACikqimr4r23+AVoIhNAAaGAQrd -DPaBhhWuigUAqt0NuygO2igCuywCqiwKiAGYTahm9+AAQzD/TQAL+wHrRg8jM/0AAAb/Af6BxhXv -ygUA/2AARf/x2gDAINEP+EAIY6IAnQAiFhn/5bQNoAo1AC2R52XbDC6R6GXrBi+R6WX7AMePKHbG -wKAqds0qds4qdssqdswZ7LoqlhsqdscodsUolhgolhkolhoodsj4+UYVr/kuACsh52W59ywh6GXJ -8S0h6WXZ64sdY/oaAAAALsHmZODnLxIZK3bGD/8PC/sLwID4I0YVr+jqAIlDikIJKTYKKjaaQviA -ZhXv48IAx//+ggYV4A4FAP6CJhWv74IAx5/4gkYV4AgFAPiCZhWv77YAx//+goYV4A4FAP6CphWv -7+oAx5/4gsYV4AgFAPiC5hWv8B4Ax//+gwYV4A4FAP6DJhWv8FIAx5/4g0YV4AgFAPiDZhWv8IYA -AAAb7Hx4syYrFhn/4XwNoApFAMf//oGGFeAOBQCeTf6BxhXvygUA/oHmFa/s1gAb7OB4swwrFhn/ -4MgNoApVAAAAGuy1KhYZ/+CIDaAKBQAAAC3B52XfES7B6GXvC2P/FAD8gEgV4AolAP3Z5gWgC4UA -W8eN0Q/Aov3Z4AWgC4UAW8eK0Q9sEAoW7O0U7O0Y7F8b7O2MRY5Ej0OCQiNAAuMUAiDoQQAAktCf -0Z7SnNMkQQD0IAQdr/n1ABrsvRfs45mwmbGZspmzmbSZtZm2I4Kkmbcncn/6YAQFMTNxAOEzCACg -QQAA8mAQFeAFBQDyzQYd4AkVAPsiAAqwAoUA9M0mHeAFdQBtKg8pQQcpZTXnmwhyI/kAALBVx18q -gqQc7MsU7CHsqgEK3UKAAAuqAuqGpCCYgQAAKUKH9IEAFeiZgQDpNgAhuBEAACVSh/6CABXoVYEA -5XYAIZAhAAAv8of8gwAV6P+BAO8mACHwMQAALdKHJGBmDQ1YLeYAZEAh6E0QCmQCgADtzAIKXgKA -AAtLAgy7AipgZyuGwSqGwiRgZh3srC5gZ4UYgxmk7uBVEQ96AoAA5fUCD3YCgAAF5QIFMwINMwIj -hrGCGuwSCykUAoAAAv8CD+4CDswCDcwCLIayG+vwK7KHKYKC+lkABXK74QAKuzfqrAIl2AkAAO+q -EQ3eQoAA+0YADXx7FQALmQEKmQIphoIV7AAjgoL/2RwF4AcVAPbShh3gggUA9GAEAfBOBQADLjn/ -8AYdoAIFANEPAAAAbBAEGuyEKqJ/+ZwCHaPrhQALqiwIqAhuiAorGpf7YA7CogCdACoKZBbrd/rN -RB2gCxUAW63KKmVr9djuBaACBQD32OwF4AVFAC5ggAAgBNMPDg4b88AIZ9IAnQDlXP8iIEEAAOVf -4WEQBQAA89eyBeAHBQD2AKIdoCwFAPL/oBWgCwUA84IADbcnAQDaIFutYSgKCAh4AggIRyg2UiUy -UwUkEQ8CAPRuAAowBQUA5TZWIigHAAAa7Fr6AEId4AwFAPaYABSwDVUA9yYADLAOFQD4awYV4A8F -AFvGDOaggW0QBIAAsUR1SczCwCsKACs2WCd8AeoyWCkDSgAA+P/741IAnQAf7Ege7Ej92EwF4AsF -APoAAh2gFAUABLwCDAxHLDZSCokUAJkRDZkCKTZTCwhH7wAFBdgFAADpMlMsRwKAAO6ICAVQIwAA -+ROoFaCJBQBtmgIIAmFptr5mIAJbrYrRDwDaIFutdNogW61swDDaIPpgaB3gbEUAW60x6iQACdgE -gAD8AEIdoA0lAFutUSM8AWk72QIqAlutJB3rz/yARhXgChUAW8Wm2iD6AeId4A4FAP6ARhWgbEUA -W60g+kBoHaAL9QD8AGIdoA0lAFutQZdCwPD+gEYV4AMFAOokAAnYBIAA/ABiHaANFQBbrTmxM2k7 -52P+YijqcKiobogFKQrPepsH//h0DaA6JQAr+jirq264BMXHessH//ggDaAalQD/+AANoAqlAGwQ -BBfr/wk1EeVFAgk3goAAp2aVYNEPAGwQBJMg+AACHa/MBQD4QUYVoIoFAOWlOgFYgQAA/WAEBbVJ -BQDklDoBYMEAAJwsnC3kJgsl2QEAAOsmCSFQ4QAA6yYIKtgEgABbqgbqRAAK2ASAAFutf5oh0Q8A -bBAGF+umKHJbEurX8QMQDeADBQAoIjAkcqaoOAmIEahEikcrGlD7QcgVoAwFAFvDPylyW+pGDiGY -BQAA0w95M9IT69P0AAIdoAYFAOswfSpQBIAAW8Pt6mY3AiAFAADpROlhmAUAACtyWCxyWSpyWpwR -7LsIAzAFAAD7QABFcAsFAOsWAyUJcYAAG+q389ckBaAOBQD+IEYVoAHqAAAoMFQvNFWvj+8WAS/Q -BIAA/8AH0uIAnQApCoD/TwAOMAoFAG3JLiyyMChypq6trczmrwgOZkKAAKyIjDAvhDclhAwkhA2c -iAL/CgndAu32gCVQBQAApqaNEyhyWS9yWO5yWiboBQAAnROo/6/u/6AFKqIAnQAksi2DEypypqQz -7xIBKZ5CgACqMyQwDd7w5TAMIntxgAAZ6o2LEimSMKuZ6DIALM5CgACpqZkQJZQM5JQNKlgEgADo -lggq0ASAAFvDqxvqgo4QjBLqMFQtaASAAC3kN+w0VSZgBQAA7BYCKAQKgAD3X/t5UgCdAI4RDwIA -DwIArqjuNFUke/0AAO8WAS/QBIAA/9/4c+IAnQD//QwNoAoFANEPAABsEBIU63bTDyhBlSUKgPgg -AAQwAwUACFM5+mBoHe/69QBbrQf3QGgdoAsFAPIiZhXv+vUAW60CKhYX+kgCHaALBQBbrP8qFhb7 -/+IdoQsFAFus+yoWFfv/4h2hCwUAW6z4KhYU+//iHaELBQBbrPQqFhL6AAId7/r1AFus8Zoc+//i -HaKLBQBbrO4qFhH6AAId7/r1AFus6ioWEPogAh3iSgUAW6znKhYP+sACHeJKBQBbrOMqFg771IYF -o4sFAFus4CoWDfoAAh3v+vUAW6zcmhv6AAId7/r1AFus2Zoa+gACHe/69QBbrNYqFgn7/+IdpwsF -AFus0poY+//iHacLBQBbrM+aF/v/4h2nCwUAW6zMKhYG+//iHaCLBQBbrMiaFfv/4h2hCwUAW6zF -mhT6AAId7/r1AFuswtWg+//iHaOLBQBbrL7XoPoAAh3v+vUAW6y7LRIXLkIWiB6LHylCFy9CLCIW -GSxCLYIUIxIQBcwoAv8oCTMoIkIYrP8sEhYLIigrQhAJiCiJHQy7KIxPCe4oKUISDcwoLRIUqO4o -QhQNmSgtEhGjIiNCEw2IKC0SEg0zKKgzLRIVKEIRDYgoqYiJTgltKKzcq8yozCtCJqPMosyCHChC -IIMZArsoghuuzC5CIQKIKCJCIquIqMwDIiiDGosXiBUD7igjQiqi7iJCMK7MCDMoLkIuKEIoByIo -Cu4oC4goou6LGCJCJwsiKKgiosyIFiJCKZUSCCIolxOjIqLMIhIZr8z/gABGN/j1AHmDDtPQ+iAm -FaAARgAAAAAAAPogJhWgAwUAo8UFWgJbrG/6oGgd4IwFAFgXY/lAaB3gjAUA56QAAYJJgACNTicS -E/GjcA3gBQUA6hYYLRgEgADtdAAJ0ASAAPv/4h3v/PUAW/7RWqHnjk7jYwgCqAUAAH5T3PgjCBXg -jAUABlcop5dkJoHAMPYgBhWgBQUAJkJ1pWYjZgAuQl2ITg8CAH4zCg6ICPhgB0uiAJ0ALkJeiU9+ -MwmumfhgCPviAJ0ALkJfKkIQ0w9+MwmuqvpgCdOiAJ0ALkJgK0IRfjMJrrv6YAq74gCdAC5CYS1C -EtMPfjMJrt38YAuT4gCdAC5CYi9CE34zCa7//mAMe+IAnQAuQmMoQhTTD34zCa6I+GANU6IAnQAu -QmcpQhd+MwmumfhgDnviAJ0ALkJoKkIY0w9+MwmuqvpgD9OiAJ0ALkJmK0IXfjMJrrv6YBD74gCd -AC5CZS1CFn4zCa7d/GAR4+IAnQAuQmQvQhX+YBLbogCdAK7//mASiuAYRQD4wIYdoADmAOp0AAnY -BIAA/CJoFeAJBQD4wIYd7/z1AFv+f/ogCBXv/fUA/UAGFeAMBQCcZ6e3WqGQLAqA7FUIAZgFAADy -f/XlIgCdAGAFLOp0AAnYBIAA/f/iHaAOJQD+wIYdoA0FAFv+bS8SF/rA5hWgjAUA9+AAQ///DgAA -AOp0AAnYBIAA+ABiHaJMBQD4wIYdoA0FAFv+YSkSFvrA5hWgjAUA9yAAQ//+TgAAAPpgaB3v/PUA -+gCCHaENBQDqZAQr0ASAAFv+VSsSFfrA5hWgjAUA92AAQ//9jgAAAOp0AAnYBIAA/ACiHaENBQD8 -wIYdr/z1AFv+SS0SFPrA5hWgjAUA96AAQ//8zgAAAOp0AAnYBIAA/f/iHaAOFQD+wIYdoQ0FAFv+ -PS8SEvrA5hWgjAUA9+AAQ//8DgAAAOp0AAnYBIAA/f/iHaAYJQD4wIYdoo0FAFv+MZpnia4qEhH3 -IAYVoIwFAPdAAEP/+z4AAAAAAAAA+uBoHaAchQD8wIYdr5tlAPrAph3gDQUA+mBoHe/89QBb/iGa -Z/wiCBXgDgUAnmj+wSYVoIwFAPegAEP/+ioAAOp0AAnYBIAA/EgCHa+fZQD+wKYd4BiVAPjAhh2h -DQUAW/4RiR/6wOYVoIwFAPcgAEP/+VIAAAAA+mBoHeJMBQD6AsIdpg0FAOpkBCvQBIAAW/4Fix76 -wOYVoIwFAPdgAEP/+JIAAAAA+uBoHaAcVQDsZAQp2ASAAP3R5AWjjQUAW/35jR36wOYVoIwFAPeg -AEP/99IALkJsL0Im0w9+Mwmu//5gCJPiAJ0ALkJpKEIgfjMJroj4YAl7ogCdAC5CailCIdMPfjMJ -rpn4YApT4gCdAC5CaypCIn4zCa6q+mALO6IAnQAuQm0rQifTD34zCa67+mAME+IAnQAuQm4tQih+ -Mwmu3fxgDPviAJ0ALkJvL0Ip0w9+Mwmu//5gDdPiAJ0ALkJwKEIqfjMJroj4YA67ogCdAC5CcSlC -LNMPfjMJrpn4YA+T4gCdAC5CcipCLX4zCa6q+mAQe6IAnQAuQnMrQjB+Mwmuu/pgEWPiAJ0ALkJ0 -LUIu/n/oW6IAnQCu3fx/6AriAJ0A6nQACdgEgAD9/+IdoB61AP7Ahh2gDQUAW/2xjxH6wOYVoIwF -APfgAEP/81IAAAAA6nQACdgEgAD9/+IdoAiFAPjAhh2gDQUAW/2liRz6wOYVoIwFAPcgAEP/8pIA -AAAA+mBoHe/89QD8AAId4AqVAOpkBCvQBIAAW/2Zixv6wOYVoIwFAPdgAEP/8dIAAAAA6nQACdgE -gAD8AAId4AylAPzAhh2v/PUAW/2NjRr6wOYVoIwFAPegAEP/8RIAAAAA6nQACdgEgAD9/+IdoA61 -AP7Ahh2gDQUAW/2Bjxn6wOYVoIwFAPfgAEP/8FIAAAAA6nQACdgEgAD9/+IdoAjFAPjAhh2nDQUA -W/11iRj6wOYVoIwFAPcgAEP/75IAAAAA+mBoHe/89QD6AaIdpw0FAOpkBCvQBIAAW/1pixf6wOYV -oIwFAPdgAEP/7tIAAAAA6nQACdgEgAD8AcIdpw0FAPzAhh2v/PUAW/1djRb6wOYVoIwFAPegAEP/ -7hIAAAAA6nQACdgEgAD9/+IdoA71AP7Ahh2gjQUAW/1RjxX6wOYVoIwFAPfgAEP/7VIAAAAA6nQA -CdgEgAD9/+IdoBgFAPjAhh2hDQUAW/1FiRT6wOYVoIwFAPcgAEP/7JIAAAAA+mBoHe/89QD8AAId -4BoVAOpkBCvQBIAAW/05ixL6wOYVoIwFAPdgAEP/69IAAAAA6nQACdgEgAD8A0Ido40FAPzAhh2v -/PUAW/0tjRP6wOYVoIwFAPegAEP/6xIALkIn9lICHeJzBQAPAgDxyRAN4AUFABboFCZiLSJCdaZW -CWYRpiKGJ4ZuwMDrIRIjUYEAAFvAfYsr42oIDUAEgAD4QUYVoAwFAFvAeIsu52oIDUgEgAD4QaYV -4AwFAFvAc92g+kIoFeSqBQAKagj8QgYV4AwFAFvAbd2g+kqQFea6BQCqavxCZhXgDAUAW8BnK0In -6iYUIqgFAAD6v/u74gCdACxCKPGJEA3gBQUAFufuJmIuIkJ1plYJZhGmIoYnhm7AwOshEiNRgQAA -W8BXiyvjaggNQASAAPhBRhWgDAUAW8BSiy7naggNSASAAPhBphXgDAUAW8BN3aD6QigV5KoFAApq -CPxCBhXgDAUAW8BH3aD6SpAV5roFAKpq/EJmFeAMBQBbwEErQijqJhQiqAUAAPq/+7viAJ0ALEIp -8YkQDeAFBQAW58gmYi8iQnWmVglmEaYihieGbsDA6yESI1GBAABbwDGLK+NqCA1ABIAA+EFGFaAM -BQBbwCyLLudqCA1IBIAA+EGmFeAMBQBbwCfdoPpCKBXkqgUACmoI/EIGFeAMBQBbwCHdoPpKkBXm -ugUAqmr8QmYV4AwFAFvAGytCKeomFCKoBQAA+r/7u+IAnQDAINEPbBAEG+ivAiUK61UKAQP5gAAm -vNT0QASgkgCdAOpSxSkUUAAAKFLEeokOW6okIlLD0Q8AACJSw9EPKVLBHOiKA6oM+U8ADXDUTQAN -qgGqmSlWwy+yJfnQqgWgDhUA/SAARjANBQD57wAP8AolAOj/CAzYBIAAW8CBHOfQK8B9xNANuwIr -xH0iUsPRDwAuUsUiUsOj7q5O/9/gFaD0TQAP7gEuVsTRDwAAAAAAAPpAaB2gCwUAW6os80fgFe/I -BQAIMwHqUsEp2ASAAFvHw8ChW6n3FOgYwCCkqiKmgSOmgiKmgxnoFflQBhXgChUAW6nvpKkrkoBn -sAUskoBmz/kvYs0uUsKv7i5mzS1SxC1mzyJWwSJWwiJWwyJWxCJWxdEPbBAKF+hZFuhnKHIU4mJ/ -JABJgADAINEPAFumb+omYiEYBwAAW6ZpLjIi/08ADzAFFQDqNiMncAUAAP5khhWhjAUA+896BaAL -RQD66qYd4A3VAC10VC1ifyqi2iQyHazc+YYQFe+qgQAqFgoqNiDqNiEspUgAAAzKAvoAAh3gD0UA -bfoSKaAsAJEEAFga6EEIdVAFAACxu8C0+4YGHeE+BQCu3i4WCC7ggPXAEjoSAJ0A/IBoHeAKVQD9 -0HYFoDsFAFvCwi4yIi0yIw7dDLHdDW0U6dQABo8xgAAND19k8ePCoAmIV2SB5gnLU2Sx7QnsUWTB -8rCuCeo71KDApf3QVgWgOwUA/oBoHaAfFQBbwq/BgQhINraJ6DScJFv9AADqYn8tgQqAAPygAQJR -iwUA5Ez/LAEKgADrqggKwAqAAOQ2JSyBCoAA5DYmJEP9AADoFgkq+AqAAOg2KCf7/QAA7zYpIMhB -AAAroCssoCotoCkuoCiekJ2RnJKbkxbnlv3QGAWgClUA/NsoFeA7BQBbwo8vMijTDwr/ES9m2f3Q -DAWgClUA/NsoFeA7BQBbwocc6AItMiIuMiMvMiSJFosXihWIFOi7EAzMAoAA65kCDVYCgAAKiAL5 -BgAMcApVAPjbRhWgOwUAW8J5hhkc5/QtMiD+ZCgVoApVAP4hSBXgOwUAW8JyHOfvLjCc/mUIFeAK -VQD4ZSgV4DsFAOkWACtGgoAA6BYBKmgEgABbwmgc5+Ud5+b+6pAVoApVAPjqsBWgOwUA+CAGFaAP -9QAPAgBbwl8c594vMi4oMi2YEJ8RKTIwLjIv/iBGFaAKVQD4IGYV4DsFAFvCVcCl/c+qBaA7BQD8 -PgId4f4FAFvCUP3PpAWgClUA+gYCHeANVQBbwkv6ZEgV4bpFAOoqCApmgoAAW/Rh9OKGFeACBQDR -D//47A2gBAUAANkR//hcDaAaBQAImRH7XwAVr/hKAAAADJkR+1+AFa/4LgAOmRH7X8AVr/gaAAAA -+gCiHaA7BQDs57caaASAAFvCMSpifywagA8CAKysLMAsLaJdAMEE4F4aDgIKgAANCxlksL0tol4r -3P/gsAQHY/0AAPyfAA4/+fUADBwU5c/5ZMgFAAAA0QQAXBrszP8tggqAAPyfAA4/+/UADBwU5c/5 -ZdgFAAD5bwAN8SnFAKmpK5R8LKJe7JSAJegFAAAtlH0vol6yuOiUfif4BQAAL5SBLaJes77ulH8m -6AkAAC2UgiyiXrPMLJSDKmJ//DACHaALBQD9QABFMA5FAG3qEy6gLADhBABdGn1BCeu8ASVQBQAA -wLSPGAsOR//wBh2v8zoAwKX9zvgFoDsFAFvB9vyAaB3gClUA/c7yBaA7BQBbwfFj/LkAAGwQBhzn -dRvmVynCpxjmoPWLCBXgigUAqpkllOQogH0rsi0pwqEJuxHrmQgEfDCAAPsgAEMwACYAJiqAppYY -50coghJlgP8d52X/zXAFoAsFAPgAAh2gGQUAbZoeDYkCKeb56cKnJEAFAAAq4vnrmQgF2AkAAAoK -TSqVIvagBliQAwUA9cxuBaACBQDwAWQNoAdFAAAc51MipAcipDgipDkvoDcuoDb9QAgV4AkFAPlI -Jh3v+/UAK6RAkhKdEZMQ+JAQFaA7BQD4IGYVoApVAFvBvCxAgAAwBAwMG3/PUbEz5TFmcRAFAABb -pTtkoGovYA0oYAwopDYmphX3QiYV5d7FAC6lGi+kNylAgAAgBAkNG/O/+//SAJ0AbQgPsSIAIAQJ -Cxvzf/tn0gCdAGP/6QD6AKIdoDsFAOznKxnoBIAAW8GfY/+XwCDRDx3nBMDB/aJGFaACBQDRD8As -0Q8AAABsEBAY5koS5f8PAgAogH0rIi0qIjXkLf0t3kKAAOuqCAR9BIAAIwqAo6pbsIorIi0pQvUJ -uxGrmeOaCA0oBIAAW7CBLCItK0L16lUMDlZCgACquqOqW7CE90BoHaAA8gAAACMqgKOqW7B7LiIt -LUL1Ce4Rrt3j2ggNKASAAFuwciwiLStC9epVDA5WQoAAqrqjqluwdQqmAhzm/C5CmB3m1y9ClylC -lS3SFikWAPiSyBWgClUA+CAmFaA7BQBbwWge5s8iQvsu4hb6kwgVoAMFAP6gABOxyUUA6XcIBwKZ -gAAc5uouIlzvIgkpaASAAPIgJhXgClUA9iBGFeCIBQD4IAYVoDsFAFvBVsAgHObhjUcuQjKPQ5UQ -9iAmFaAKVQDyIEYVoDsFAFvBTdEPAAAA6+YAFSMhgAD7YCLjogCdACpClw8CAGSkTvtgIluiAJ0A -KkKVZKRA+2Ah66IAnQAqQpb1QyAN4EkFAPsgIVOiAJ0ADFcR9iKGFeHIRQD44ABDsAolAPrgaB3g -HAUAWBMw4qQABSBhgAD8OIIdoAsFAFu9dCkSFPvNPAWhyEUAqCiYLvoACB2kmR0AbZkCCAJhBVMK -/mgAEbAKJQD6YGgd4BwFAFgTH+omDyUeMYAA/GBoHaALBQBbvWMd5qorQpQqCgIPAgD9YwAN8BwF -AFgTFOomECUc4YAAKkKUW7h+80BoHeAcBQD6YGgd4AolAFgTDOomACUb2YAA+pKIFeAMBQBbveUa -5k4qotQPqhFbuHHqFg0tWASAAPwCAh2gCiUAWBL/6iYBJRpJgAAb5kTTD9MPK7LU/3gAFbAMBQBb -vdYPWhGaHFu4Y+oWCy1YBIAA/AICHaAKJQBYEvHqJgIlGImAAPohiBXgDAUAW73L2lBbuFjqFgot -WASAAPwCAh2gCiUAWBLn6iYDJRcxgAD6oGgd4AwFAFu9wOvlRBFoQQAALRYRnSTtJgUhYGEAAJwe -nCb8QOYVokoFAFun6ioWEvpQAh3iSgUAW6fmLRISK0KW+iHmFaCMBQD9YwAN8AolAFgSz2SiiC5C -lg8CAA8CAOMWBCcCUYAA+iJmFaADBQD6ImgVr/v1AP3KUgXiTAUAW/o/LRITLhISiyQsEhHoQpYl -SCEAAJmxm6IspgMN7QgtFhPpJgQhmAUAAHgzwY0fK0KVwKL9YwAN8IwFAFgStOmkAAUQ4YAAKkKV -0w9koEz4IgYV4AMFAPoiCBWv+/UA/EgCHaKNBQBb+iUsEhCNHygiBusSDi1IBIAA6kKVJPghAAAv -hgEolgIrlgMM3AgsFhDvJgYhmAUAAHozulu4CfNAaB3gHAUA+mBoHeAKJQBYEpfqJgklDUmAAPqS -qBXgDAUAW71xKkKXW7f++iEmFaAcBQD7QGgd4AolAFgSjOomCyUL6YAA+pLoFeAMBQBbvWYqQpZb -t/P6IQYVoBwFAPtAaB3gCiUAWBKB6iYKJQqJgAD6ksgV4AwFAFu9WypClVu36Pog5hWgHAUA+0Bo -HeAKJQBYEnbqJgglCSmAACtClfIgphXgDAUAW71PKkKYW7fcmhaMFIkYjhWNGogZgxeu3QmICC4S -DSkSCwozCA7MCAyZCO2ZCA1YBIAA+QAARHAKJQD4YABBsBwFAFgSYOomDCUGYYAA+pMIFeAMBQBb -vTke5XAd5cDyn2YVoAvFAPpLxhXhjAUArCwtJl3+S+YVoAkFAPmFBh3gDyUA/4VGHeAO1QD/haYd -oA3lAP2Fxh3gCBUA+YUmHaAKRQAqxCsrxCz7hgYdoBsFACvEL/vKigWhSwUAW7RqLRIUjhsc5dIZ -5aoqJlz+IKgV4AgVACiWFv4gBhXgOwUA/iFIFeAKVQBbwDsc5cmNGf4g6BWgClUA/iDIFeA7BQBb -wDVj+08AAAAAAAAA/+3ADa/ipQD/7aANr/JFAGwQBBLllCgiEciDwCDRDwD7yk4FoUsVAFu0Sxnl -tx3liA8CACmRf/vLagXhDAUADKwC/yFABtAKBQANzAIqtnL7yjYFoUsVAFu3V1ujs8Dh/kImFaAC -BQDRDwAAbBAEEuWo9gACHeADRQAPAgDlLJQhMQEAAG06IORifyEYCwAA5DUEIqgRAADkYn8hEAkA -AAQ0FCQ1CCdWoMAg0Q8AAABsEAQX5ZgV5ZgU5Zj9yzIFoAIFAP3I+gXgGwUA41wIKjAEgADYQOlU -AAnQBIAADwIA0w/TD226JeyGgyRYCwAA6YZ/JEChAADphnYkyKEAACqGd+qGeCVQoQAALbUMG+WF -HOWF/sCAJeAOBQDu9h8hUEkAAFujthjkUCiAgAAgBAgIG3+PMhzlev3IvgXiqQUAqWapd/hgAEHw -GwUA6VUIARAFAADpRAgIBAqAAPhf+5pSAJ0AwCDRDxvkQBrlcCuyMhzkSSqigasr7eVtHd5CgAD7 -QABFcMuFAFo/imP/pWwQBBTlaCpCafPJTAWgCQUA+nwABTQIBQBtigoMmxDrJvskyAUAAGSgTmmh -SyNCaipCVlumplumlPwEAh2gC4UA5zc4fSgEgAAd5Vca5Vj/yDIF4OM5AO7aOQHkHIAAD6oCejcF -GORACKoCezcRGeUU+UYADXAALgDAINEPGuVM/mGABxAJRQAd5IjTDw2qAu7lSRH0YIAA7qoCAfhA -gAAvQH0PAgB//wIMqgJ/NwIJqgILqAIoJvzAawVmDARjECMm/RnlPQk5Aikm/iMm/ygtBIiAGuSW -G+U6/cpwBa859QAJiAHriAIBSBMAAPkgBhWgO4UAW7bM6uSNG0MCgADkbxELZwKAAOxsAgt2AoAA -7+4CC2oCgADtPQILfAKAAAj/Ag/dAg7dAv2GAA5wO5UAW7a9KEJS9qAAEzAzBQDTD/ECkA3gBQUA -GOTp0w8PAgAIZgLcYOrkdRnYBIAAW7ayKUJSsVXpU+pxmAUAAMAw+mBoHaALBQD8AAIdoA0FAFuj -TLEzaT7nIwoA2jBboz+xM2k79SoiwRvlCwuqAvpYJhWgAgUA0Q9sEATAINEPAGwQCFukjxblBBzl -BihiXPXKBgXgBAUA/gAiHaACBQDkgnJmaREAAJ4ULRYBIhYFGOT8nBDoFgImYvEAAPwgZhWgAhUA -F+O6J3IxI2Klp0cJdxGnMycyBydyDitiWvrgaB2gDAUAW7wi+stIFeAMBQDqNh0j0IEAAFu8HSti -ofpjxhWgGQUAKTQEq0ubMCtQgP4D4h2gDQUA+sAABHAJBQD9AeAmVPsBAC40Ifxkhh3gACoAIjQk -LzQhJDQiLlBQKTUcIjQtKTUdKTUeKTUfKTYQKTYRKTQqKTQrKTRsKTYfKTQ0KTQs+GamHeXo5QAo -NRkY5M0pNEn4ZuQd5O4BAAjoCvkACBWgD1UALzQpKTRw7jQjLAAigAAa5K36Y+YVoAuFAPpj5B3g -yQUA+GPEHeABHgCKE/pj5hWgDYUA/GPkHeDMBQD8Y8QdoAC2AC5QiPogSBWgDIUA9cAEYZDLBQD6 -AEIdoBuFAOzksRpoBIAAW78FKjIfiKbaMAuAACgyHw8CAIiJ6jUcKdAEgAALgADqFgUtCHIAANow -+gAiHeAMBQBbo3spMRzzIAYnEgCdAPEgB+eSAJ0A+oBoHaALJQBbo1cb5Jvs5JsZ0ASAAFu/RSli -XOVcASIgBQAA+J/zI+IAnQBgALEAKjYfLDUf+mPEHe/+EgAAAC5QiIoR/cNAAtDNBQD6AEIdoBuF -AOzkihpoBIAAW77cY/9XKjYf/GPEHeAOhQD+Y+Qdr/0yAAAAAI8UyP1bo8rqFgUtAzIAAMCAmBQu -UIjqEgAnRHUAAPoAQh2gG4UA7OR5GmgEgABbvspj/w0AAAD6Y+YVr/wqAPqAaB2gC4UAW6MpY/9E -+gBCHaAbhQDs5G4aaASAAFu+voIV0Q/AkJkVGuNuKqB9e68FghXRDwAAW6L1ghXRDwDGKtEPbBAU -FOO6KkIQK0LeKUISKEIUJ0IWL0IYLEHILUHGLkHEnhOdEpwRLxYTJxYUKBYVKRYWKxYXmhUrQqgq -QqcpQqkoQcr7QABFcAIFAPsgAESwBwUA6BYAJJ1hgAD4IIYV78UFAPPIlgWgDwUA/iJGFeALBQDy -IwYVr/L1AB7i/yjiLSZC9ah4CYgRqGaDZxrjRYM+KBIXKWE+mTOYMi1CjqiYKBYXfaMJiRX8YIYV -4AAuAIkVLGE2nDQpnD8FmQEpNgUtQHLtFhwmg0GAACtCESpgbioWDisWD1vC5PwjiBXgDAUAW8Ib -AqoB/AAiHeAMBQAM3DkK2jkMqgLlvgEFASmAACwSGC0SD/4hyBWgCiUA/iOIFeALBQBbvm7wADAN -r+ulAP5gxhWgCwUAZrLPiTUqEhaINg8CAOmICAVQ/QAABaoBKjYH70BzJED9AAAFiAEoFgXvFhsn -g0GAACtCEypgbyoWDCsWDVvCwPwjaBXgDAUAW8H3AqwB/gAiHaANBQAN7TkM7DkNzALlvwEGASmA -ACwSGC0SDf4hiBWgCiUA/iNoFeALBQBbvkrwADANr+ulAP5hBhXgCwUAZrI/ijcpEhWMOA8CAOrM -CATI/QAABZkBKTYJ6EB0JmD9AAAFzAEsFhboFhokA0GAACtCFSpgcCoWCisWC1vCnPwjSBXgDAUA -W8HTAqoB/AAiHeAMBQAM3DkK2jkMqgLlvQEFASmAACwSGC0SC/4hSBWgCiUA/iNIFeALBQBbvibw -ADANr+ulAPxhRhXgCwUAZrGviTkuEhSIOg8CAOmICAdw/QAABe4BLjYL70B1JED9AAAFiAEoFhXv -Fhkng0mAACtCFypgcSoWCCsWCVvCePwjKBXgDAUAW8GvAq8B+AAiHeAIBQAImDkPnzkI/wLluQEH -gSmAACwSGC0SCf4hCBWgCiUA/iMoFeALBQBbvgLwADANr+ulAPhhhhXgCwUAZrEfLjILjTwqEhOP -Eq7d7hIBJVD9AAAFqgEqNg0sQHXqFh0m6P0AAAXdAe0WFCYEOYAALEB2K0IZKmByKhYGKxYHLBYQ -W8JS/CIIFeAMBQBbwYkCrQH+ACId4A4FAA7+OQ39OQ7dAuoSHSaBeYAALBIYLRIH/iDIFaAKJQD+ -IggV4AsFAFu93Io9/mHIFe/rpQD+IiYV4ABKAAW4ASgWEfhhxhWgCwUAjRCOEY8S/CBoFaAANgCN -EIwTiT4pFhEpEhIoYTosNSIoNhCZP6mJKRYSKGEyLzUkKDUjKWEzrIycEy41Jik1JShhNK+fnxIt -NSgoNScpYTWujp4RKTUpKBIRrZ2dEKio6RIEJED9AAAFiAHoFhMjuAUAAPj/5A1iAJ0A0rDRDwDR -DwAAbBAEGuLo0w8molgV42DwwyAN4AQFABjjXvfGvAXgCQUAbQgcInCAAEAEAgIbfycLBUYLKGZA -KWZBJqJYsUR2SwJj/9woolnxBcAN4AQFABviCG0ITi+yLi6ipq9PCf8Rr+4s4RMv4GIj4FaG7yLg -V47s7UwIKzWCgADl3QsJEUKAAOYiAgmewoAAA/8CAv8CL9ZAAO4RDswCLNZBKaJZsUR5SwJj/6rR -DwAAAGwQBhrjOiqiQvFBjA3gBAUAYAB2GuM2KqJC47MIAiAFAAB6S2UT4ecS4zEjMi0iIpCjQwkz -EaMiJSEHIyETKiAM+kGwFeNVYQBbuwcb4ykpIQcoIRILmQHzJgAM8AsFAOklByR9gYAACFwRDKoC -bQgVH+Mgo74tIRIP7grq5sAl2AUAAH27jGP/4wDAxP1BAA4wCAUA6BYAJgY5gAAa4xMd4qSdEhnh -x4gQLhICKZItL6KQLuDBCYgICYgR+eAAR7ALBQDvFgEnA+GAAIoR6qAMJbgFAADbcFu/byahB+Oh -Ey0gBIAAK0AN+0GQFaNmYQBbut0pQQfq4v4dKASAAChBEgqZAfMmAAzwAgUA6UUHJADJgADbYOMq -CArgBIAAW/AgK0ESsSJ7I+qMEizAwaMj7HOXe9gEgAAa4uwsokLA1A3MNo4QjxIPAgCx7u4WACf4 -BQAALxYC/d/6S6IAnQD/w8gFp/j1AHODKRri4hvi4vPPAAzwDVUA+mABBTAMdQBtmRAf4tov8cxu -9AJ7oW8spsC0qhni1SmRy8CDeYBXHeJjG+LS7dK/JuATAAAishgswi0kshkrspANzAjiRAgOZkKA -AAy7CCOxBw5ENiqwDPthsBXjM2EAW7qjGOLG4k0MCc4CgAAJqQIIKApt2gfphsAkQBEAANEPAAAA -AAAA/VgGFe/+PgBsEAZb9ezmoXxtEASAAFv1eeahcW0QBIAA+8P4BaArdQBbsSEZ4rTANPoAAAaw -ByUA/S+GHeDKCQD9L6YdoLoRAPsvxh3gihkA+S/mHaAFFQBb80/moS5tEASAAPvD2AWhSxUAW7EQ -FOKkEuGe98OKBaD6QQAvRFwZ4e0uYtPokX0vCboAAPMACN9SAJ0AK5F+4+G7HYCGAAAskX9lwAUt -kYBk0SIa4pX6AEId4AwFAP4AIh2iDQUA9mJmFeAPBQBbu/9moCYlNhMsYsIsRi4rYtgrRi8pYtkp -RjAoYtsoRjEvYvAvRjIuYuwuRjPmoJVtEASAAC1C9x7hyg8CAAjdES/ikA8PRw/dAi3mkFvxu+ag -cm0QBIAAW/C65qBnbRAEgAAf4hsuQgcP7ggf4Xou9qtb8JIU4in6EAIdoAIFAP3+gh2gBgUAKEKe -boM5K0Kdy7P6AAIdoAwVAPwAAh3gDwUA/iAmFeAOBQD+IEYV4AkVAPggBhXgDwUAWqBBwIMoRp1k -IEvRD7Cq+0AgFeAOFQDr6zkFaAUAAO3COA39VgAAY//dGuGZ+igCHeMsdQBbs9UZ4Z5j/tQvIH0D -/wL+T6Yd7/sOAAD/+/QNoAoFAAAAGuJM+cSUBaALhQD4ZaYVoAwFAFu6BhriSBviSBziR1u6Ax3h -nhzhmhrhm///4h2gSQUAbZoMK6J/fbFqrL8u9oC0qhjiPtMPK4J/+xAIFaBJVQDsuwgEQCEAAG2a -ECmCfyq2gCqCgOybCARAIQAAHOEo0w/TDyzAfOq2gC4QZAAAHuFVL+J2B/8CL+Z2LeJ+B90CLeZ+ -W6M5GeFEKJKCBYgCKJaC0Q+sufcwBhWv/lIAAGwQBB3hmizSWcvLKMz/CMoB6MAaflgEgABtCAyw -qemqAQ1YBIAAebACY//sD7sRHuIYL8wf+8+GHeX/HQD/z6Yd4AoFACrkfvm0yBWgigUACAA/W6Mk -CgE/0Q8AbBAMFeC2kxSGICxSNC9SLStSNS5SLi1SLyhgDJgXJmANlhjm4gUe7kKAAO29CA92QoAA -7r4ID/5CgAAPvwgvFgouFgsoYn/tFgwuZkKAAOy7CAKr/wAA6xYNJAJxgABbo1MZ4UepqSqSgGeg -C20IBSqSgGegAmP/8xvhXxzhXvoAQh2gDQUA/s/oFeAOFQBbuY4rYn8c4VgsVlgrVlksVlqsuytW -WytWXFujZC5SFSNSGC9SFyRSFCdSEyhSEilSESpSEItf/KHIFaANBQCdGS1WXSxWXi1SFqy7LFIg -K1Zfq6oqVmCqmStSISlWYamIKlIiKFZiqHcpUiYnVmOnRChSJyRWZydSKK9EJFZopDMjVmSj7i5W -ZiRSKa/uI1IqL1IsLlZlrt0tVmmtzCxWai5SLay7K1ZrLVIwq6oqVmyqmSlWbamIKFZuqHcnVm+n -RCRWcKQzI1Zxo/8vVnKv7i5Wc67dLVZ0W7lT06BbuVLXoFu5UY0ZGeBi/8FEBeBIBQD84MBAX4sF -AMDS7wIADTZCgAD3IARq4gCdAClSXC5SWgaXDAt3Af7gEqOiAJ0AKlJZZKJJK/B9J1ZcCLsC6/R9 -K8gEgAAc4JMvUlv4IAYV4ApVAPYgJhWgjQUA/CBGFeALBQD2IGYV4A0lAFu70mVwjB/hRijyxSn6 -gO/yxCQ5/QAACXcBp27/4A8bogCdABnhPimSwmSR1RnhPPAAzA2gDQUAGuE5DdkKCpkKKJLF75LE -JDn9AAALdwGnbv/gDbOiAJ0AK5LCZLGr9aANwRIAnQDulsUvQASAABzgZi6Sw/YgJhWghAUAJBYC -9iBmFeAKVQD4IAYVoAsFAFu7rudWdSOM0YAAFuAVKWItKmIu6GI0IyPzAAAtQufmYi8szkKAAOl5 -CAxGQoAA6HgIDVZCgACqeioWBegWBi7uQoAA6BIKKzZCgAD24ABDNK0dAG2pBQgAhgkCYfohSBWm -vR0AW6KsLULo0w/pEgUu7kKAAPghaBWkrR0AbakFCACGCQJh+iFoFaa9HQBboqItQunTDwndEfgh -iBWkrR0AbakFCACGBgJh+iGIFaa9HQBbopktQu7pEgYu7kKAAPghqBWkrR0AbakFCACGCQJh+iGo -Faa9HQBboo/AofoAAh3gDAUAW/g6iF7JjC1RlYsZ/CAABvAMhQD9jQAN8Ao1AAuqNwqKKFuildow -W/VoW/T5GOEqKIJ/yIvAovvCUAXjyB0AW/gqG+BA/cBsBaAKBQBb+Cb6AAIdoAsFAFuifhvhIBzh -IP9AaB3gDQUA/gAiHaAKFQBbuLyKF4sYW711iRSaIPMgBhXgAgUA0Q8AAAAA+cGOBeANBQD/+YAN -oAcFAP/3DA2gBwUAG9//KrB9xMAMqgIqtH3/OIgV7/jqAMck0Q8AAAAAAABsEAbaIPogaB3gPNUA -W7F4GOEEiRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFuxbhjg7okQIoJ/CpI74oZ/ -LRAEgADRDwAAAGwQBtog+iBoHeA81QBbsWTp4PEdAKoAAIIQBEgKqYjihIAtEASAANEP0qDRDwAA -AGwQBtog+iBoHeA81QBbsVjp4OUdAKoAAIIQBEgKqYjihH8tEASAANEP0qDRDwAAAGwQBtog+iBo -HeA81QBbsUzp4NkdAKoAAIIQBEgKqYjihH4tEASAANEP0qDRDwAAAGwQBtog+iBoHeA81QBbsUDp -4M0dAKoAAIIQBEgKqYjihH0tEASAANEP0qDRDwAAAGwQBtog+iBoHeA81QBbsTTp4E4dAKoAAIIQ -BEgKqYjihIAtEASAANEP0qDRDwAAAGwQCh/guYv0iPbi8gcpUASAAIn1jPON8o7xnhGdEiwWAykW -BSIWBygWBisWBO/yACoYBIAA/iAGFeA71QBbsiTmpAAFAjGAACigAMCQ6uAIFAU5gAAJlALjFggg -uIEAANMQhTAPAgAPAgAFWgJbsibrVAANEASAAOpkAAlgBIAAW7oxyKe4M3c518Yq0Q+mLCvAAMLc -7bEKflAEgABlv+RgAAGxyukyASV/CYAALqAA1qDklAIPfVYAABvf7YoY+0AARXD/9QB/QT4Z3+gk -pID+gaAH0AoVACyRfwrMAiyVf35HIC2Rf8DkDt0C/S/kHeACBQDRDwAA+oAAR7ACBQAi9IDRD8Ag -0Q/AIPNQBh2gAgUA0Q8AAABsEAbaIPogaB3gPNUAW7DiGOBxiRAign8Kkjvihn8tEASAANEPAAAA -bBAG2iD6IGgd4DzVAFuw2BjgaIkQIoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog+iBoHeA81QBbsM4Y -4F+JECKCfwqSO+KGfy0QBIAA0Q8AAABsEAbaIPogaB3gPNUAW7DEGOBWiRAign8Kkjvihn8tEASA -ANEPAAAAbBAG2iD6IGgd4DzVAFuwuhjgTYkQIoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog+iBoHeA8 -1QBbsLAY4ESJECKCfwqSO+KGfy0QBIAA0Q8AAABsEAbaIPogaB3gPNUAW7CmGOA7iRAign8Kkjvi -hn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFuwnBjgMokQIoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog -+iBoHeA81QBbsJIY3wyJECKCfwqSO+KGfy0QBIAA0Q8AAABsEAbaIPogaB3gPNUAW7CIGOAfiRAi -gn8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzVAFuwfujgFR0AsgAAiRAigoAJIijihn4tEASA -ANEP0qDRDwAAbBAG2iD6IGgd4DzVAFuwchjgCokQIoJ/CpI74oZ/LRAEgADRDwAAAGwQBtog+iBo -HeA81QBbsGgY4AGJECKCfwqSO+KGfy0QBIAA0Q8AAABsEAbaIPogaB3gPNUAW7Be5qAfbRAEgADq -NAAKWASAAPygaB2gfSUA/iAIFeAOFQBYExXRDwAAAGwQBtog+iBoHeA81QBbsFDmoB9tEASAAOo0 -AApYBIAA/KBoHaB9FQD+IAgV4A4VAFgTB9EPAAAAbBAG2iD6IGgd4DzVAFuwQuagH20QBIAA6jQA -ClgEgAD8oGgdoH0FAP4gCBXgDhUAWBL50Q8AAABsEAbaIPogaB3gPNUAW7A05qAfbRAEgADqNAAK -WASAAPygaB2gbfUA/iAIFeAOFQBYEuvRDwAAAGwQBtog+iBoHeA81QBbsCbmoB9tEASAAOo0AApY -BIAA/KBoHaBt5QD+IAgV4A4VAFgS3dEPAAAAbBAG2iD6IGgd4DzVAFuwGOagH20QBIAA6jQAClgE -gAD8oGgdoH1FAP4gCBXgDiUAWBLP0Q8AAABsEBYb36f6IGgdoIwFAFu2C/pAaB2gO9UAW7EP4qQA -BQ6BgAAooAAjFiIlFiHkFiAkBDmAAPQv4BWgJcUA9IAgFaAJBQD4JGYV4AFuALhm9MAM7CIAnQAn -YgAHegJbsQzrdAANGASAAOokAAngBIAAW7kXZa/WojctcADl0TF78ASAAGXfxuliAScLMYAAKhIj -KOAA6poCDxAEgADqFiMkAOmAAPYgaB2v/r4AAAAAAP7gIBWv/0oAwLArFiMqEiIsEiH6JAgV4F3l -AP4kaBXgDiUAWBKZLBIj+b7kBeAOJQAPAgD/gaAH0A0VAC+Rxw7/Ai+VxygSI/8BoAdQAoUAKpHH -AqoCKpXHKxIj/2GgBxAcBQAvkccM/wIvlccoEiPTD9MPe4cIKpHIDaoCKpXIKxIj/2GgBpAjBQAv -kckN/wIvlckoEiPTD3mHCCqRyQ6qAiqVySgSICsSIy+SGSoKYAq6AQqPOe+WGSXgQIAAK5HKDwIA -DbsCK5XKLRIjd9cIL5HKDv8CL5XKKBIjdocIKpHKDKoCKpXKKxIjdbcILZHKA90CLZXKLhIjdOcK -L5HLwIUI/wIvlcsqEiNzpworkcvA1g27AiuVyy4SI3LnCC+RywL/Ai+VyygSI3GHFCqRywyqAvs5 -ZB2gAgUA0Q8AxirRD8Ag0Q9sEAjaIPogaB3gPNUAW6+M5qCJbRAEgAAc3brA0OzAgCDYQQAA+gAi -HaAIRQBtig98oAmx3eq2ACXYEQAAD6oR8aWQDeAKFQAmHBD+IAgVoA8FAPoAAh3gCEUA0w9tiid6 -4Bx6wA7/RgAP8ABaAAAAAAAAAAANuS4GmQqJkA+fAuu8AS1XwoAA2jDrRAAK4ASAAP4AIh2gbRUA -WBIp0Q8AbBAG2iD6IGgd4DzVAFuvZOagH20QBIAA6jQAClgEgAD8oGgdoG3FAP4gCBXgDiUAWBIb -0Q8AAABsEAbaIPogaB3gPNUAW69W5qAfbRAEgADqNAAKWASAAPygaB2gbaUA/iAIFeAOJQBYEg3R -DwAAAGwQBtog+iBoHeA81QBbr0jmoB9tEASAAOo0AApYBIAA/KBoHaBthQD+IAgV4A4lAFgR/9EP -AAAAbBAG2iD6IGgd4DzVAFuvOuagH20QBIAA6jQAClgEgAD8oGgdoG1lAP4gCBXgDiUAWBHx0Q8A -AABsEAbaIPogaB3gPNUAW68s5qAfbRAEgADqNAAKWASAAPygaB2gbUUA/iAIFeAOJQBYEePRDwAA -AGwQBtog+iBoHeA81QBbrx7moB9tEASAAOo0AApYBIAA/KBoHaB9xQD+IAgV4A4lAFgR1dEPAAAA -bBAG2iD6IGgd4DzVAFuvEOagH20QBIAA6jQAClgEgAD8oGgdoG0FAP4gCBXgDhUAWBHH0Q8AAABs -EAbaIPogaB3gPNUAW68C5qAfbRAEgADqNAAKWASAAPygaB2gXYUA/iAIFeAOJQBYEbnRDwAAAGwQ -Btog+iBoHeA81QBbrvTmoB9tEASAAOo0AApYBIAA/KBoHaBdRQD+IAgV4A4VAFgRq9EPAAAAbBAG -2iD6IGgd4DzVAFuu5uagH20QBIAA6jQAClgEgAD8oGgdoE1FAP4gCBXgDkUAWBGd0Q8AAABsEAba -IPogaB3gPNUAW67Y5qAfbRAEgADqNAAKWASAAPygaB2gPYUA/iAIFeAORQBYEY/RDwAAAGwQBtog -+iBoHeA81QBbrsrmoB9tEASAAOo0AApYBIAA/KBoHaAtRQD+IAgV4A4lAFgRgdEPAAAAbBAG2iD6 -IGgd4DzVAFuuvOagH20QBIAA6jQAClgEgAD8oGgdoC0VAP4gCBXgDhUAWBFz0Q8AAABsEAbaIPog -aB3gPNUAW66u5qAfbRAEgADqNAAKWASAAPygaB2gLQUA/iAIFeAOFQBYEWXRDwAAAGwQBtog+iBo -HeA81QBbrqDmoB9tEASAAOo0AApYBIAA/KBoHaB95QD+IAgV4A4VAFgRVxnd+iiQfcChCogCKJR9 -0Q8AbBAGaTEFbkQGZEADxirRD9og+iBoHeA81QBbrozo3cYdAMIAAIkQqEgigH0JIjbihH0tEASA -ANEP0qDRDwAAAGwQDBzeHsffnRSLwYjDicIpFgIoFgMrFgHswgApUASAAPwgBhWgW7UAW6+A4qQA -BQuxgAAqoAAuCmB662wvCnp682bTEPQiABXgN6UAhDDaQFuvhOtEAA0wBIAA6iQAC2AEgABbt4/K -o7gzdTne8gACHaADBQD4ACId4AoFAPMiAA0wCAUACpg4zY9gAReibCvAANrA92AQnGIAnQBlv8hg -AgoAAAAAAAAAwDD8AAIdoF3VAP5AaB2gBAUA6xwgKVAEgAD1YGgd4A+1ANMPbfoaKqAAfaEc5KA0 -ZmAFAAAqtACiyu6kAAXYBQAA/kFgFaAMtQDqHCAnEAUAAOXICADYwQAA9QAGHaAMBQBbrj/6QGgd -oDvVAFuvReKkAAUEQYAAK6AA0w/xYrAN4C31ANygbQgNfbEUK8AB5LAYZmAFAABj/+sAAAAAAAAA -9CCGFaABcgAAAIkUZJBQwMD4JAAV4Aq1AG2qFSogAOSgEWEQBQAAKpQA7MwBJMgFAADAy6XL+iQA -FaAMBQDktAAg2NEAAFuuHgr+UPwAIh3gDAUADtw4ZcC1xirRDwAA+iQAFaAMBQD+QGgdoA+1ANMP -bfoYK+AAfbEa5LChZmAFAAArpADizggFUAUAAP5BYBWgDLUA6hwgJxAFAADlyAgA2NEAAPUABh2g -DAUAW64E8Uy4DeBq+QDAwPgkABXgCrUA0w9tqhUqIADkoBFhEAUAACqUAOzMASTIBQAAwMuly/ok -ABWgDAUA5LQAINhBAABbrfP6ACId4AwFAAa8OP+VYA3gmvkAwNAJvThk30nJNGg7VsHhfjE1wCDR -DwAA//40Da/qpQAY3MCCHKgiKCKAiRT+IagV7/r1AAqZAwmIAQj/Av5QBhXgAgUA0Q8AGtydixyM -FI0dW63QwCDRD7HK0qDyYCgV7/cKABrcmoscjBSNHVutycAg0Q8AAAAA+gAiHaAJBQAGqThln4Fj -/sgAAABsEAbaIPogaB3gPNUAW63HGN1kiRAign8Kkjvihn8tEASAANEPAAAAbBAG2iD6IGgd4DzV -AFutvRjdW4kQIoCACpI74oSALRAEgADRDwAAAGwQBtog+iBoHeA81QBbrbMY3VKJECKCfwqSO+KG -fy0QBIAA0Q8AAABsEAbaIPogaB3gPNUAW62pGN1JiRAigH0KkjvihH0tEASAANEPAAAAbBAI+kBo -HaA71QBbrqjjpAAFCVGAAMBQ97h8BaAHBQDyAAIdoCTFAPAAvA2gCwUAABzb2gUdFAbdCijSrsef -Cc4DDogBCLgC6NauIqgFAAD0oAdDUAsFAGVw4N0Q+mBoHaAOtQBt6h0soADkwR998ASAAOTAvWXY -BQAALNQA47oIBugFAAD6YWAVoA61APoiABXgDAUA4e8IBRgFAADi9AAo0ASAAFutefFFdA3gDgUA -6RQACLgEgAD6YGgdoAi1AG2KFCugAMm265QAJ3AFAADqrAEkyAUAAPphYBWgDrUA+iIAFeAMBQDn -6QgFGAUAAOKUACjQBIAAW61k8UPIDeAHFQAb3JaMFCuyfwy7KCw66Ay7LJsU8r/4t9IAnQDs3EAd -3AKAAPoghhXv/CYAAAAAAAD//cQNr+qlANKg0Q9sEA4b3PP6IGgdoEyFAFuzUPpAaB2gO9UAW65U -4qQABQPhgAAooADTD2SAb/YpABWgBwUA8iBoHeAANgAAAAAAuDN2MVaEMNpAW65W60QADSgEgADq -JAAK4ASAAFu2YWWv3aJcKsAAwtztoTd+WASAAGWvy+kyASWBIYAALrAA0rDnlwIPfX4AAC8aDH9w -DBLc0fZP5hXgAgUA0Q/GKtEPAAAAAPuAIBXv/zIAbBAE+kBoHaA71QBbri3ipAAFANmAABPcxdow -W6433KDrNAAJUASAAFu2Q8iixirRDxjcvxrcwCKCfxncQgoiAQkiAvMP5hWgAgUA0Q8AAABsEA4b -3Ln6IGgdoFwFAFuzEfpAaB2gO9UAW64V4qQABQOBgAAooAAPAgAPAgBkgHD2KgAVoAcFAPIgaB3g -ADYAAAAAALgzdjFGhDDaQFuuFutEAA0oBIAA6iQACuAEgABbtiFlr92iXCrAAMLc7aEnflgEgABl -r8vpMgElgKGAAC6wANKw55cCD31+AABgABLGKtEPAAAAAPuAIBXv/3IAAMBw3HD7t14FoUsFAFut -7MAg0Q9sEATAINEPAGwQBi0gAOs0AApgBIAA+qBoHaA/1QD/paYN4AYFAMU7c9Ej3iDTD9MPbQgV -5NBIYzAFAAAt4AHv0Qx3cAUAAHPRBGP/3wAAF9x6mxL8ICYVoAMFAOoWACOgQQAAJXJ/2yDsZAAK -0ASAAFu18MisuHfkeehxmCEAAMYq0Q/aUFut23ap6RrbYfpgAEU5eAUAeKHl6xICJUAbAAAogiWM -Ee0SAClQBIAAC4AA0qDRDwAAbBAG3EDqIAAq6ASAAPIgZhWgBgUA/mBoHaA/1QDvoS55GASAAMUr -cqEk2zAPAgDTD20IFeSgSGMwBQAAKrAB76EMddgFAAByoQRj/94AABfcTZ4S/CAmFaACBQDtFgAj -qMEAACRyf9sw7GQAClAEgABbtcLIrLh35XnocRAhAADGKtEP2kBbra12qeka2zP6QABFOagFAHih -5esSAiVAGwAAKIIZjBHtEgAp0ASAAAuAANKg0Q8AAGwQBtxA6iAAKugEgAD+YGgdoD/VAOIWAykY -BIAA/0WGDeACBQDFS3ShItswDwIA0w9tCBXkoJhhEAUAACqwAe+hCnXYBQAAdKECY//eFdwhnRKc -Efe4PgWgBwUA/iAGFaAAOgC4ZuVhZnO4IQAAJGJ/2zDsJAAKUASAAFu1kmWv4tpAW62AcqnaGtsF -+uAARTrYBQB4oTiLEGmxFywSAS06/33JDh7cDC/igC7ifw/uCC4WAesSACVAFwAAiI0sEgHtEgIp -0ASAAAuAANKg0Q/GKtEPbBAG3EDqIAAq6ASAAPIgZhWgBwUA/mBoHaA/1QDvoSp5GASAAMUrcqEg -AzsCbQgV5KBIY7gFAAAqsAHvoQx12AUAAHKhBGP/4wAAFtvvnhL8ICYVoAIFAO0WACMpQQAAJGJ/ -2zDsdAAKUASAAFu1YMisuGblaehxECEAAMYq0Q/aQFutS3ep6Rra0fpAAEU7KAUAeKHl6xICJUAT -AAAogjmMEe0SACnQBIAAC4AA0qDRDwAAAAAAAGwQBMAg0Q8AbBAEJSAG8kDwFaAKFQBYBJz1t5wF -r/a1APdABwQgBwUA50aCKR4CgADiWx1xma8AAAhSESIta9og+gPiHeAc9QBbtM0iLQFzKewa28Eb -28Ec28FbtMka28Ab28Ac28FbtMbAIMChW7TLsSJpKfX4mOgVoAIFAMChW7TGsSJpKfUa27kqRsop -Ck74hoYV4AIFAMChW7TAIiwBaSn0+oaIFeACBQDAoVu0u7EiaSn1LBoA/IjmFaACBQAqCgFbtLUi -LAFpKfP8iOgV4AIFACoKAVu0sLEiaSn0wKNYBGl2oRz5t0QFoAIFANMPbVkNJ4ZAJ4Z854Z+JEAH -AADRD8cl0Q8AAABsEAQZ25gIKBGpiCmCQRrblhvbluiCUSllgoAAW7SVwCHRDwBsEBiFJiYgBhrb -j/hA8BWgCxUA+CRGFaAMFQDTD1u0jCkSIvjAKorgAwUAFNuFBpcMJRYbpjXaUFv/6GSgzOJZCQrW -AoAApKorolErlRzAgCimUSiVJSiVLuiVNyGYBQAAdznPHtt6LRIbwJApFhj/oAQGsAwVAPwihhXg -CwUADcs4KxYVIxIYGttvBjMI69tuGeWCgABbtG7rEiIrUASAAFgC5sCg/bbUBaALBQBYAXFmoFbr -EiIrUASAAFgC38Cg/bUYBaALBQBYAWpmoDsjFhNYAUlkpL8a2of8ImgVoAsFAPokZhXgAwUA+iQm -FaAJBQDpFiAuZoKAAPWAAQYwBQUA/CPmFaAAjgDHK9EPAAAlXAEuEiMtEiDu7AEhmEEAAO4WIy6D -1gAAKRIf5ZZSJPARAADl5lIk6CEAAOXWUiTgMQAA5cZSJNhBAADltlIk0FEAAOWmUiTAYQAA5YZS -JPhxAAAl9lLrEiIrUASAAFgCsiwSIcf/0w/vzAMJ0ASAAOwWISnYBIAAWAE6Zq96WAEZZa96wJH4 -JAYV7/3iAOMSIS9fAoAAKxYeKxYS/CJoFeAJBQD4I6YV4A8FAP4hZhXgDgUA/iLmFaAFBQD0I0YV -4A4FAC4WGQLYCegWFi7uAoAA9aAARrAMBQD8IgYV4AUFAP2qJhWgAN4AAAAAAPSgBWGSAJ0AKwoB -6xYaIqgFAAAuEhwtEh0sEhku7BDuFh4myAUAAOkWHS4EtgAA+iRIFe//9QDvMwMLUASAAFgCfysS -HgM8AtMP6xYcLdAEgABYAQhmrrJYAOdlr6EqEgv1X/U10gCdAC0SGisSFiysAQ3KOSuxHCwSF+oW -Cy3fwoAA/WAYG6IAnQAszAEsFhcuEhAtEhYrEiIs5lHs1SUrUASAAFgCZf/9nA2gBQUAKRIdKxIW -KhIX6rUlJMgFAAAf2uSN8o7xi/SI8IzzivWaFZwTmBCbFJ4R/CBGFeAOBQCeHi0SEysSEoj26BYG -LOcCgADsuwgO7oKAAATdCi0WH4/3nxfTsOsSIitQBIAAARECWAJK2jDs2s4Z2ASAAAERAlgA1Gat -4fIhphXgDIUA+bWOBeALBQD6IiYV4AoFAOoWDynoBIAA6RYhLpgEgADtEh8o8ASAAG3KIi/SUigK -f/n/7SwiAJ0AieAJCUDp+QgHcBEAAOnWUiboEQAA6xIiK1AEgAABEQJYAiwsEiHyIYYV7/r1AOrM -AwnYBIAA7BYhKdAEgABYALLtEh8tauIAAPIgaB3gBQUAizAPAgD1YApgkgCdAOM8BCKoBQAA6Vjn -ZugRAACNEPghABWgDgUA/gAiHeAMBQD94gAOcAk1APwgKBXgzAEADwIAbZog+QAIFeAKBQAN/jjt -ggEkQCEAAAzrAfniAA1wDgUAC6wBDf44LRIMfOAJ/iHGFeAOFQCeHy4SESkSD/2iABXgDIUA7uwB -LpgEgADuFhEk+BmAACMSDS8SDgzoEQgzCOs0AAf1IYAAKxIiKRIV6RYIK1AEgABYAfElEiEo+v/o -VQMJ0ASAAOs0AArgBIAAWAB55RYkLWO6AAAlEhYpEhQPAgAlURzkkJhiq8EAAJMaIxIkKBIQKxIi -5YZRK1AEgABYAd8rEgr6ISYV7/n1AAkzA+w0AA3QBIAAWABmZqwsWABGZKBVLBIWLMEc78wRAqgF -AAB1w0SOGY0YLuwQ7hYKJv2JgADyJIYV4ADiAAAAAADtFiUq0ASAAFgAIu0SJS11TgAAKQoAKTYA -L9JSKPz/D484/6pGFe/6SgAqEhYlpTfrEiIrUASAAFgBvC0SFg8CAC7RNyzRJa7MDBwSLhIQKxIY -LOZR7NUuJdgFAAArFhj3f9iNYgCdAOsSIitQBIAAWAGuwCDRDwAAACISFvxEpB2v8rUA0Q8AE9lX -//AkDaALBQAAbBAEFdosbyhD+kAEANADRQDi2hsaqAqAAG06EygihAhYASkiiQlZAemJIXEQEQAA -HNoUKsIlwLArxiX6oAQFMPn1APsgwIWgAhUA0Q/AINEPAAAAbBAEHNoK18Amwoj7tCwF7/j1APjX -AAswAgUA9+AAAzD99QAocoT6QIAVoAUFAPjxKBXgDkUAbeolACAEBg8Z7/cacRAFAAAAUAT4nwAJ -8UidAPTgAAI3MwEAdDkauFW0d+t5vn0QBIAAKMIlwJApxiV42APAIdEPwCDRD2wQBBjZ69MP0w8k -hoQkhoUkhoYkhocihoD7s+gFoAsVAPMQJhXgDBUAW7Ls+gAiHeAMBQD+ACIdo+2FAPuz2AWgDwUA -W7Mf+AACHe/yVQAKkjvRD2wQEiUgByQgBiIWFnVLNxnZ2gJKCeRcDApGAoAA+QAARHALBQBtyRsp -gkEppUDrhkElUAkAAOulSCRABwAAK6VRK6VaCQdPGtnN+gAiHeAMFQBbss30gCY64AkFACkWCwRa -DCoWEyMSCxrZxAQzCOvZxBnlgoAAW7LE6kQACtgEgABYATwqCgD9s4AFoAsFAFv/xmahzOpEAArY -BIAAWAE1wKD9scQFoAsFAFv/wGahsdpA4xYNKtgEgABYAS4oEhaJHQiYCSgWFyiBQCoKACoWGRrZ -qePY1RzOAoAACpkI+CMGFeAKBQD6IoYVoAYFAPkoJhWgAgUA6kQACtgEgAABEQJYARwp+v/pMwML -UASAAOtkAAngBIAAW/+kZqFDW/+E7BIXJSExgAAswUAPzBEszBD3gAlj4gCdALF3LhIZLxIYLRIU -9sIAFaACBQDn9kEnSAUAAOkWGSb88YAAwCD4IQYV4AYFAOYWFSy3AoAA6kQACtgEgABYAP4o+v/o -MwMLUASAAOtkAAngBIAAW/+HZqDOW/9m5KCyYRAFAAAsEhgrEhctEhUswkErsVv2wgAVoBoFAOy7 -DAboBQAA+0AFC+IAnQDtFhUpQpgAAC4SFyflWx7ZciriAyviAijiBS/iBiniBIzhjeCdEJwRmRSf -FpgVmxKaE+7iBypQBIAA7hYHKtgEgABYANqIGCcSFah37NljG58CgADqNAAJ2ASAAFv/YmagOiIS -GCIiT7Eilxka2Ur5srYF4AsFAPoiRhXgBgUA+VEGFeABAgApEhgokkH5H+AVoAIFAPkoJhWv/QIA -xyXRDwAAAAAAACIsASoSEisSGClsAeaUAAGYQQAA4rZPLQReAADqRAAK2ASAAFgAuB7ZMgM6Av2w -yAWgDQUA7eaIKdgEgABb/0Bmr7LqRAAK2ASAAAERAlgArhjZJxzZMe/ZORnQBIAA74aIKdgEgABb -/zVmr4hb/xXXoB7ZHxzYUu3ZMRnQBIAA7eaIKdgEgABb/y1mr2db/w33X/tY4gCdALAo4oI5A0gF -AAAY2EeYGi8SGCwKACz2TysSDfohKBWgDQUALRYPHdkMCpoIKhYM/bEGFaAOBQDs2Q4dVwKAAO4W -DiVQQQAA6hYQLd6CgAAMuwr6IiYV4AqFAOkSESjwBIAA0w9tqiIvkkcrCn/7//dkYgCdAIzgDAxA -7PwIB3ARAADslkckyBEAAOpEAArYBIAAARECWAB2gxorEhDH3w0zA+q0AAngBIAAW/7+4xYKLXVi -AAABEwL2IigV4AYFAI4w9cALOJIAnQDnfAQjMAUAAOlo6mGYEQAAjRD4IQAVoA4FAP4AIh3gDAUA -/eIADnAJNQD8ICgV4MwBAA8CAG2aIPkACBXgCgUADf447YIBJEAhAAAM6wH54gANcA4FAAusAQ3+ -OCoSDy8SEAzpAe4SDiVQBQAA6hYPJ/hBAAD+IgYV4AgVAPkNAA9wCoUA7hYOJ3g5gAArEhj6gGgd -oAYFAOK2TyrYBIAAWABAhxyDH6czhxoMMxHyYgAV7/j1AOh3AwnQBIAA6zQAC+AEgABb/sUjFhrm -FhstbhoAAOYSGisQBIAAIxIYIzJBIzzwKBIY2kDjhkEq2ASAAFgALMef6XcDC1AEgADrZAAL4ASA -AFv+tWathVv+lGSggbAzZDB85C/JYzBBAAApEhcpkUksEhcnwVupdwcXEi0SGCoSCysSEyfWQefF -UiVQBQAAKhYL+1/aVWIAnQDqRAAK2ASAAFgAEsAg0Q8AAAAA2mBb/mllrpTAkJkwKHJHsIj46OYV -r/oiACsSGCkSGSoSF+e2QSTIBQAA90tkHe/v/gAqEhcDCU/5SSQd7/4eAABsEATk2IAZRgKAAPJD -cg3t+vUAAjkMBIgIbZkNKYJ8CpkB6YZ8JEAHAADAoVuxgOI5DAlGAoAA9QAARDIKBQDTD22aDSmC -fAqZAumGfCRABwAAwKFbsXbAINEPAGwQCOQgBikYBIAA9kDwFeAKNQBYASsi+vvzQAhMIgCdABbY -WiUKAA8CACVmgvuwvgWgCxUA9NEGFeAMFQBbsV72gAti4AoFAJoVkxIEewybFoMVGthW0w+kM+vY -VRnlgoAAW7FViRLAUPhgAETwAwUAmREllByKEdMPDwIA80SmHeAKFQBYAQ7zQATUIgCdAOrYVBnn -AoAA/KYADjD79QBbsUUqCgNYAQZyoXnqRAAL2ASAAFv/u81cZTAaLwoAL2aAL2aBHtdtLmaEHdhG -LWaFLmaGLWaHGtg8+gAiHeAMFQBbsTX7sHAFoAsVAPx9Ah3gDAUA/gAiHaAPBQBbsWhmoCIoYiXi -hyNxmAUAAPh/+yXSAJ0A6RIBIqgFAAD4v/p6UAMFAMcl0Q8AAACJFYoWsZmZFfs/+MUiAJ0Aixb+ -IEgVoA0VAPwghhXgDBUAnBP+gABHMAoFAP4gBhWgBQUAbbk7gxKkqKODKzAlLzAcq/4ODkcuNC54 -SxkoMCSJFAuIDAhZOZkUKTAbiBMPmQwJWDmYE2Sgrw29NgzsN7GqKRIEZJDRihPjEgIlBmGAAKdL -CxsSqzstsCUrsBzq2Age5wKAAP1mAA4w+/UAW7D68sSIFeAKFQBYALnzX/o8IgCdABrX//JkAAZw -CDUA/Z/gFaEzAQDsXDUBmAkAAOgzNA5nAoAA/GYADjD79QBbsOorYjosYjsMuwz6YEAVoLsBAAuq -AwoKQAo6CCqsAipmOCliSPxjoEFSmQEACToI+1/gFaAAVgAAjBAtwCX9hdAVr/02AAmaAipmSPTQ -RhXgCjUAWACX81/15CIAnQAiCgAGAAAAAAAA/Y8ADf/9BgBsEA4Y18kjIAYkIAftIgUo0ASAAPZA -cBXgCzUA9iImFeAJlQDzr3QFoAcFANMPbZoOKYJBmaDnhkEkQAcAALSqGdfKFtfKJyYjjGOPYuVi -ASDwwQAAleGf4pzjhmCW4A1YQeuINADQwQAACogKiIAIBkD4AQACsIgRAOpVEQxFwoAA6FUCCzeC -gAD2pgAKsIgFAAhYAgyIEQmIAvhCBhWgBgUAwKFbsKuxZmlp9fhCCBWgBgUAwKFbsKexZmlp9RrX -rBvXG/x9Ah3gDAUA/igAFeAOFQBbsNLxUZgN4BkFAPhEZhXgBgUAwKFbsJombAFpafT6RGgVoAYF -AMChW7CVsWZpafXAoVuwkxrXmvoAgh3gDEUAW7CI+68wBaALRQD8fQId4AxFAP4AIh2gDwUAW7C7 -6BIRLQXaAADkOyN5zgKAABrXeQNLDA8CAAqZCNMPbbkNK5JhKZ0B82AEvtIAnQAa14T6AIId4AwF -AFuwcvZEZhXgChUAW7B2Hdd7DFwRDcwC/EIGFaADBQDAoVuwcbEzaTn1/kIIFaADBQDAoVuwbCM8 -AWk59BrXcRvW4fx9Ah3gDAUA/igAFeAOFQBbsJhmoC/q11gYwASAAPgBIh3gD4UA/kRmFeACBQBt -mg/pggAkQBEAAOmmQSVQBwAA0Q9lj0XHK9EPAAAAbBAEJCAGGNdJIyAH6ddBGi4CgACoVfRvAAm/ -5AUAbToNI1JABDMB41ZAIqgHAAAoksAa11MKiAH5OAYVoAIFANEPAABsEAQU1zLCMIpCCgpCyKdo -oQVoowJppRfzRsYNr/W1AGQgkWghMWgjX2klGGAA9ACwM2Qw6sChW7A3Y//KZDDfwKFbsDSLQgsL -Qusp73Gb/QAAwCDRDwAA9UAFupIAnQDAwfyAJhWgBQUAwKFbsCmxVWlZ9fyAKBXgBQUAwKFbsCWx -VWlZ9WP/u2mlU8Dk/oAmFaAFBQDAoVuwHrFVaVn1/oAoFeAFBQDAoVuwGrFVaVn1Y/+PwKFb/9J1 -oWLAUJVBwKFbsBSxVWlZ9fiAKBWgBQUAwKFbsA+xVWlZ9WP/ZMChW//HdaE3KQoC+IAmFeAFBQDA -oVuwB7FVaVn1+oAoFaAFBQDAoVuwA7FVaVn1Y/8yAMCjW/+69V/6JWIAnQDHK9EPwKNb/7Z1ofPA -s/qAJhXgBQUAwKFbr/axVWlZ9fyAKBWgBQUAwKFbr/KxVWlZ9WP+7wAAAGwQBhbW3OhZEApDwoAA -6YgCCc8CgAAJiAIZ1vMIKAIJiAL4wgYVoAIFAMChW6/jsSJpKfX6wggVoAIFAMChW6/fsSJpKfX7 -rKgF4AwFAP4AIh2j7YUA6tbgGPgEgABbsAr6AAId7/K1AAqyO9EPAABsEAoc1t6KJYjDicKLwZsR -mRL4IGYVoQQFAP2ACBWgDVUA7BYAJVwcgAAtFgMKUkEBLQot0gD7raQFoAY1APwgAAZy3R0A590R -DmZCgAD9hgAOc4sFAFuvtsAwwKFbr7uxM2k59R7Wrv/DCBWgAwUAwKFbr7axM2k59RPWosBQJTYj -KzI7K7z792CABbAKNQD6QAAF8AwlAP9oABWwDaUAW/+7yKnHK9EPAAAAAAAAAPoAYh2gCwUA/ABi -HaANpQBb/7Nlr94a1qfmLTQA+EEAAA/dComhiKKOo57zmPKZ8YqgmvCN0MDB/AAAB3AKNQD8AQAF -8N0RAOq7EQ7twoAA7bsCD3eCgAD/ZgANsA2lAFv/n2WvjvIAAh2gBvUAwKFbr4qxInYp9cDoJzI6 -KjJBeutB/0fAB9CaAQCaGSkWCPNAQBWgHwUAAv80/mgmFeACBQDAoVuvfbEiaSn1+GgoFaACBQDA -oVuvebEiaSn1ixmKGKuqwMh6wwoqrPvwABwNoqoBAAoaQiwyIPz/gBXi6gEA+9gAFzAKNQD8QAAF -8N0ZAO7dEQ3fAoAA/2YADbDMiQDtuwIOZQKAAP1mAA2wDaUA9WYADbAMBQBb/3FlrtMiCgDAoVuv -XbEidin1+gCiHaALBQD8AAIdoA0FAFv/aGWusMAgwKFbr1SxInYp9fRmhhXgAgUAwKFbr1AiLAFp -KfT+ZogV4AIFAMChW69LIiwBaSn0EtZXDwIA8njmFaACBQDAoVuvRbEiaSn1+HjoFaACBQDAoVuv -QLEiaSn1KgoBW/75x5t5oToa1kv6AGId4Aw1AFuvMsAgwKFbrzexImkp9RrWRftYKBWgAgUAwKFb -rzKxImkp9cC4+mRmFeACBQDRD8cl0Q8AAGwQGIUkHNY7hiaHJYnDisKLwZsRKhYCKRYD/YAIFamH -HQD8IAYVoAw1AHjAIhrWMxzWMvYKAAX312EA6N0RDdvCgAANuwIMuwJYAYJgAAkAGtYrG9YrWAF/ -+6xUBaELBQBYAXz7rFIFoAsVAFgBefusTgWgCzUA/H0CHeAMNQD+ACIdoA8FAFuvPWajzvusQAWg -KwUAWAFvGtYf+j8CHeH8BQBbrvz7rDgFoAt1AFgBaRvWDxnWGiuyySKSAo2Uj5PokgEg8EEAAJjh -n+Pt5gQg4EEAAPPARhWiuzEADLsKiZDp5gAql8KAAOuyAClQBIAAWpem6tYKHVgEgABYAVUb1MoG -ekMLqgkqoTAGi1ErFiQKWijhuwoNp4KAAOuyAC1XgoAAWpeZ6H8UfRgEgAAKCUD4ACIdoAMFAAmD -OKoz6tX5GdgEgABYAUJ/NwGxM+rV9hnYBIAAWAE+6tX0GdgEgABYATwjEiT7q+IFoAsFAFgBOPqg -aB2gB2UAW7RewFfspAAN6ASAAPur1AWgCwUAW7LtW7NFG9Xo3HD7YNINp10lAMDF21D7oNINpd61 -ANvAwMj7wNINpO8VANyw++DSDaALlQDbwBrV3VgBIhzV3I3BjsLvwgMg2MEAAJ+znrKdsYzAnLCr -S+uyAClQBIAAWpdm76cGfVgEgACxqxrV0VgBFP2rogXgtnEA6zsJAOEBAAAMuwqO1o/XitWJ1IjT -mMOZxJrFn8eexo/SjtGewZ/CLdIALcYA67IAKVAEgABal1IV1YkPAgArUjwsUjca1b8MuwhYAP8c -1b2NwY7C78IDINmBAACfs56ynbGMwJywq0vrsgApUASAAFqXQ8A0A6k375cGfNAEgACxmsBuBqs0 -GtWwARECWADu69WvGVAEgABalzkDqTfvlwZ80ASAALGaB6s0GtWpWADm69WoGVAEgABalzHToCVS -O/6hIA/QlQEAf6cBsaPIk38/AbEz+6tABaAbBQADuzRYANnAM+vVnRlQBIAAWpckBasDCwtAq6sa -1ZpYANP7qzIFogsFAFgA0BzVl43BjsLvwgMg2cEAAJ+znrKdsYzAnLALSwjrsgApUASAAFqXFAOp -N++XBnzQBIAAsZoHqzQa1YtYAMHr1YoZUASAAFqXDCkKCgmpN++XB3zQBIAAKpwBw74LqzQa1YNY -ALf7qwQFoEsFAFgAtPurAgWgCyUAWACxwFXr1PoZUASAAFqW/AWpN++XBnzQBIAAsZoGozTq1XgZ -2ASAAFgAp+rVdhnYBIAAWAClHNV0jcHuwgIg2f0AAO/CAyXYBQAAn7Oesp2xjMCcsKtL67IAKVAE -gABalujAkwmpN++XBnzQBIAAsZoHqzQa1WZYAJTr1VYZUASAAFqW38CcCak375cGfNAEgACxmgar -NBrVXlgAi+vVXRlQBIAAWpbW76cGfVgEgACxqxrVWVgAhPuqsgWiCwUAWACBGtUbG9VWWAB/wCDR -D8cl0Q9sEATbMOxEAAlQBIAAW64JwDDAoVuuDrEzaTn1GNVNqCKCIMAgwKFbrgqxImkp9dEPAAAA -bBAEiyQa1UZalrsU1PnzQGgd4NYFAPaDRhWgAgUAwKFbrf4iLAFpKfT4g0gVoAIFAMChW636IiwB -aSn0KgoBW633GtUD+gCCHeAMRQBb/98pKtH4g0YV4AIFAMChW63vIiwBaSn0+oNIFaACBQDAoVut -6iIsAWkp9PIAAh2gVQUAwKFbreaxInUp9SsK1/qDRhXgAgUAwKFbreCxImkp9fyDSBWgAgUAwKFb -rdwiLAFpKfQiCgDAoVut2CIsAWkl9C0K1fyDRhXgAgUAwKFbrdOxImkp9f6DSBWgAgUAwKFbrc6x -Imkp9cChW63M9oNGFaACBQDAoVutySIsAWkp9P6DSBXgAgUAwKFbrcQiLAFpKfQqCgFbrcEiCtHy -g0YVoAIFAMChW629sSJpKfX4g0gVoAIFAMChW624IiwBaSn09AyCHeACBQDAoVuttLEidSn1GtS6 -+hhCHeCMJQBbrajAIMChW62tsSJpKfUZ1KD5IAgV4AIFAMChW62osSJpKfXIOsAgwKFbraSxInMp -9fOpIgXgAgUA8AA4DaA1JQDAqlutnrEidSERiUZ/l/B8l+0qMhJ+p+fAINEPxyXRD2wQBBTTsQQk -CPKQBhXgAgUAwKFbrZKxImkp9fiQCBWgAgUAwKFbrY2xImkp9dEPAGwQBhPT1hTUmeMyqyHj6wAA -LMJYHdNk/ECmFaIzHQDyQIYV5MwBAA3MCozAnCYa1MEZ1MH4mSgVoAuVACskB4mQ+CAGFeKICQAo -JAMBiAgogAD4QMYdoAs1AFv/3cChW61z+6lsBaAbBQBb/9nq1LAZ2ASAAFqWJBvTBws7LOrUsBXY -CQAAW//S9alcBeACBQDAoVutZrEidSn1LAoB/JAGFaACBQDAoVutYCIsAWkp9PyQCBXgAgUAwKFb -rVyxImkp9fQMgh3gAgUAwKFbrVciLAF1KfQiCgAiRoDAoVutU7EiaSn1/pAIFaACBQDAoVutTiIs -AWkp9PWpJgXgAgUAwKFbrUqxInUp9fupIAWhCwUA/CACHaPthQD+ACIdoA8FAFutdfFQ6A3gAgUA -JTrowKFbrT6xInUp9S8KAv6YBhXgAgUAwKFbrTixImkp9fiYCBWgAgUAwKFbrTSxImkp9cAgwKFb -rTGxImkl9SkKA/iYBhXgAgUAwKFbrSyxImkp9fqYCBWgAgUAwKFbrSciLAFpKfQiCgDAoVutJLEi -aSn1GtRr/AACHaErRQBbrRge1BPH/4niD5kDCQlJmeKI4w+IAwgISZjjjeQa1GIP3QP9IAAG8Ttl -AP3AhhXgDJUAW60LAxIU+kBoHaPrhQBalcV/pwGxqvuosAWvugEAW/9z69RGGVAEgABalb9/pwGx -qvuopAWvugEAW/9t+6igBaDLhQBb/2r7qJwFoftFAFv/Z8Ag0Q/HJdEPAAAAAGwQBhbTeOvStRlo -BIAA8EngDeBMBQD0QASwkFRNAB3UQirSgSjSfi7SfwOiDAJSAX4jdOmwfSQDiYAAItaBDJkC6bR9 -KVAEgAAc0qgv0oCTEfQgRhWgCwUA+iAGFaANJQDyIGYVoApVAFut6c8jKmLFKGLCpKLvYsQhE/0A -APKgBAEwDQUA4ysIDSgEgADr8257UASAAGSAZtpg8ADoDaANBQDRDwAAAP/+dA2gAgUADdoKBqoK -JaLFLqLC9KAARDAkTQDvosQkQ/0AAAgiAaMpefMryuho0i6iNSWmxRzSey6iw5UQkxH0IEYVoAsF -APIgZhWgClUAW63F0Q8AAAD//2gNoAIFAC+wfQz/Ai+0ff9YiBXv/xIAAAAAbBAG9gACHeDChQDn -FgArmASAAMChW6yusTNyOfXAQfOnNAXgBUUA9gHiHaAoBQDCqCo2MCU2MyI2MSQ2MhnTtA8CAA8C -ACaWwCg2yCg2ycCz/H0CHeAMNQDq07QacASAAOQ2ESj4BIAAW6zM5qGnbRAEgADA9fwAwh2gCYUA -HtPkLjYgHdOBxLGb0Ck2Iyc2IyU2NcWoKjY2KTY3wIcoNjgnNjksNjovNjsmNjzB5y42PSw2Piw2 -Pyw2QMDcLTZBLDZCKyoAKzZDJTZEwaAqNkUpCmQpNkYoOiAoNkckNkgvNkkvNkrA4y42S8HSLTZM -JjZNLDoALDZO+6b4BaAMBQD7p4gF4+2FAPpiBhXgDhUA69LmGPgEgABbrKDmoPdtEASAAPulxAXg -DAUA/6d2BePthQD7ptwFoA4VAO82ECj4BIAAW6yV5qDMbRAEgAD7pa4F4AwFAPmnYgWj7YUA+6bG -BaAOFQDoNhAo+ASAAFusi+agoW0QBIAA+6WYBeAMBQD5p04F4+2FAPumsAWgDhUA6TYQKPgEgABb -rIDmoHZtEASAABvSwRrTn/piBhWgDAUA+6acBaPthQD+IGgd4A4VAFusduagTW0QBIAA+6aOBaAM -BQD7pygF4+2FAPpiBhXgDhUA69KxGPgEgABbrGvmoCJtEASAAMTALDY0+6aGBaALNQD0YCYVoAw1 -AFusKcDSnTHRD9EPAAAAbBAE8uAAATAD1QDyQ4YN4ATlAHQhFPxCIAdQiBUA+EEmDaCJdQB5IQHR -DxvR3iqwfcDIDKoCKrR90Q8AbBAGW6x9EtNz96YOBaAJBQD/QGgdoAMVAPpIBh2gCIUAbYoSAJAE -Dgob76cHdNgFAAArZn+xmfWm0AWgDAUA9aSqBeAH1QD/z+AH0Au1ACwkRSpSnC1SnSlSoSMkSfi0 -SBWs+h0A/pSkHe3ZkQD8SCYd46phAPVAGxOXOZEA90Aa1GIAnQAPCEd3gRjAnumBE3xoBIAAaI4L -KAqBeNEFKQqHedkKLUARwIgI3QItRBF7oQUPCUNpmhIqQBHB0A2qAvqCJh2gAB4AANPA8cAEf5AN -JQAtJEkjJEYvUqQqUqX4tSgVqAA9AA/PGPi1SBXrAD0ACMgYDwIA/pTEHe+YAQD4SEYd54gBAPhg -AEGzrwEA9UAWu5IAnQD3QBZ8YgCdAA8IR3eBGSkKDumBE3xoBIAAaI4LKAqBeNEFKQqHedkKLUAR -wIgI3QItRBH7QBVkYgCdAA8JQ/UgFQ0SAJ0A/8/AB1APRQD8tYgV4A41AC4kSSpSrSlSsS5SsvJI -5h3qAD0A/UsADX0APQD5ywAPf4oBAPiU5B2vjgEA+EhmHafuAQD+YABBs9oBAPWgEuuSAJ0A96AS -rGIAnQAKCk9b/4EqQaf6YAAFMAu1APtAEmRgDAUA9UASJRIAnQAuIEDA9HzndC8kSS1StCpStSlS -uShSuvJJBh3sAD0A/UsADX8APQD5CwAMf+oBAP6VBB2vmAEA+EiGHeeIAQD4YABBs9oBAPWgECuS -AJ0A96AP7GIAnQAKCk9b/2MqQajTD/pgAAUwC7UA+0APlGAMBQD1QA9VEgCdAC4gQHvnSi1SvCpS -vQHEBA2qGAoOT/6VJB2j2gEA9aAOq5IAnQD3oA5sYgCdAAoKT1v/TypBqfpgAAUwC7UA+0AOJGAM -BQD1QA3lEgCdAC4gQHrnTCpSwgAUBArKGPy4aBXv6gEA/pVEHaPaAQD1oA0rkgCdAPegDOxiAJ0A -CgpPW/87KkGq+mAABTALtQD7QAykYAwFAPVADGUSAJ0ALiBAeedRKlLHAGQECsoY/LkIFe/qAQD+ -lWQdo9oBAPWgC6uSAJ0A96ALbGIAnQAKCk9b/ycqQavTDw8CAPpgAAUwC7UA+0AK/GAMBQD1QAq9 -EgCdAC4gQP/I4AYVgD0AKlLMLVLN0w8Kyhj6YAAGP9oBAO1FrCY9hQAAd8FZCgpPW/8TKkGs+mAA -BTAOtQB+oQJpqgorQBHBwAy7AitEES4gQBzSkS1ifyNmgCsgQZsQKiBCmhEpIEPpFgIp+ASAAPhI -kBWgCwUA+CBmFaAKRQBbrDXRDwAALEARwNINzAL8giYdr/5qAChAEcCSCYgC+IImHa/yegAtQBHA -ggjdAvyCJh3v9KYAKUARwaAKmQL4giYd7/VeAC1AEcDiDt0C/IImHe/2jgAvQBHBgAj/Av6CJh3v -9tIAKUARwNINmQL4giYd7/fuAC5AEcHwD+4C/oImHa/4OgAoQBHAkgmIAviCJh2v+K4AKkARwdAN -qgL6giYdr/jyAC5AEcDyD+4C/oImHa/5bgAoQBHBkAmIAviCJh2v+bIALUARwOIO3QL8giYd7/ou -AC9AEcGACP8C/oImHe/6hgBsEAoZ0a3AMOccASigBIAA6pCAILAJAAD1oWoF4AIFAAAwBAoIG3+H -UvpgaB2gCwUAW6mBmhjrRAAL4ASAAPzAaB3gDgUAW6lrK0AAihgtQAEsQQEFqgvo3RAN2QKAAO27 -Ag5NAoAACSkCC5kCKabAGdGSLMwBDCIIKpCAtETmbAQhmAUAAOk4lmO4EQAA+6IsBe/8NQD/RiAH -0A0FACiyn/+kSAXniKEA6rKgJHP9AADuihEPd4KAAAiuOCjykCqQgAyIAQjuAi72kH6nMiiypwGE -BAjYGP+iJAXniAEA6rKoJHP9AADuihEPd4KAAAiuOCjykCqQgAyIAQjuAi72kH2nMCqyryiysAHE -BAqIGAgIR+/SCRRz/QAA7ooRD3eCgAAIrjgo8pAqkIAMiAEI7gIu9pB8pywosrj/pAAF54gBAOqy -uSRz/QAA7ooRD3eCgAAIrjgo8pAqkIAMiAEI7gIu9pB7pzQossAARATTDwjYGP+j5gXniAEA6rLB -JHP9AADuihEPd4KAAAiuOCjykCqQgAyIAQjuAi72kHqnNCiyxQCUBNMPCNgY/6PMBeeIAQDqssYk -c/0AAO6KEQ93goAACK44KPKQKpCADIgBCO4CLvaQeac0KLLKAOQE0w8I2Bj/o7IF54gBAOqyyyRz -/QAA7ooRD3eCgAAIrjgo8pAqkIAMiAEI7gIu9pB4pzEoss8BNATTDwjYGPujmAWniAEA7rLQJEv9 -AADujxEMz4KAAAj5OC6ikAzuAQ6ZAimmkBbQr/YgaB3gCQUA+CEmFeAEBQAqYMHxRJAN4AMVAOoS -CSnYBIAAW6jzL3AAKHABLHEBBa4L6IgQD/kCgADo/wIObQKAAA0tAg/dAi3mwCtgwbHM7CIIAiAF -AADrQ79xmAUAAIkZ53wEIzAFAAD5ICAV4AQFAOkWCSymaAAA0Q8AAAAAAAAAbBAGFtB7DwIAJmHC -GNB449AgGzXCgAAIZgj7ozYFoAsVAPwAIh2gDaUA+EACHaAOBQD4Z0YVoA8FAFuqZRnP7SiQfuLR -khsgBIAA96MiBeALFQD7aQAMMAUFAOiUfi0UCgAAlhCLQopBKzY7iUAqNjwpNj0a0YX6ACId4AwV -AP64ABMwDaUA9sYADHAOBQD4Z0YVoA8FAFuqTmaiQvui9AWgCxUA/AFCHeAOBQDyxgAOMA8FAPxn -RhWgDBUAW6pE5qIcYqgFAADpXpliIDEAAI0Q96LgBeAFBQDi0W8W6BsAAO0WAC0P0gAADdQCi0KK -QSs2O4lAKjY8KTY9GtFj+gAiHeAMFQD+uAATMA2lAPLGAAwwDgUA+GdGFaAPBQBbqixmobr7orAF -oAsVAPwBQh3gDgUA9sYADnAPBQD8Z0YVoAwVAFuqIuahlGKoBQAA6V6ZYiAxAACNEMBQ5tBhFugb -AADtFgAtC8IAANTQjUSMQy02OytCAiw2PCpCASs2PSlCACo2Pik2PxrRP/oAIh3gDBUA/rgAFDAN -pQD3BgAMMA4FAPhnRhWgDwUAW6oI5qEoYqgFAADkTBQq9sgAAIQQ95/YBaAFBQAtTQqN1CxNCozD -LTY7K00Ki7IsNjwqTQqKoSs2PSlNComQKjY+KTY/GtEl+gAiHeAMFQD+uAAUMA2lAPcGAAwwDgUA -+GdGFaAPBQBbqe7moMhiqAUAAORMFCrmmAAAhBD3n1wFoAUFAC1NDC3SJCxNDCzCIy02OytNDCuy -Iiw2PCpNDCqiISs2PSlNDCmSICo2Pik2PxrRCvoAIh3gDBUA/rgAFDANpQD3BgAMMA4FAPhnRhWg -DwUAW6nT5qChbRAEgACxVeRMFCrmfAAAHs9XLuB9Gs99f+dELKLgG9D+GtD8/HwABzPcIQD9oCAV -48xBAO7sASZgBQAA5O4QDmYCgADuzAIO7wKAAA3MAlup3NEP0qDRD9Kg0Q/SoNEPLKLgG9DuGtDr -/HAAB7PsIQD8aAAGs8wBAO3cAidwCQAA7O4RB/gJAADg/xEO7gKAAO/dAgZgCQAADswCDcwCW6nI -0Q9sEAQU0N4Tz+31oboF4AgVAPiQBhWgAgUA2iBbqcsKCUFpkSPqKREFcIKAAAMAh6WZCQJhCQJh -CQJhCQJh+kBoHaALBQBbqbyxImkoyypCgBvQzQuqAvqQBhWgAgUA0Q9sEARb/T8azyTTDymihRzQ -xv0gBASwKwUAC5kCKaaFKaKXGM81G8+/Hs8iKICA+yYADP/99QD5UuYV7/rVAP0DABFQCYUAGNCm -bZoNKYKQCpkB6YaQJEATAAAt5iAt5iEt5iIt5iMt5iQt5iUt5ib9xOYV4AIFANEPAAAAbBAEE9Cr -/51cBeAOFQD8A8Id4AlFAPpgaB2gGBUAbYoKK6AFeyACf7c1vKoa0KL98BAVoAsFANMP/1AGHaAC -BQBtmhgooIjo0xB1UAUAAACxBADpGgnMAiz0gLG70Q8AjqAc0JX9wBAV4AuFAP/AMBWgCiUAW6oq -2TD+AiId4PrlAG36DSiQBQqIAeiUBSTIMQAAxyvRDwBsEAQaz1/qKggBSBEAAPtQCBXh+PUA6YMH -eeAEgAAqooFbrpkLQgHRDwAAAGwQBiggAPpAaB2giSUA6YEKcRATAADHLtEPAAAmrBbywAfKogCd -ABTQdRPQc5MR86DoBeCFBQD6IAYVoAG6AAAAvDN0MVUoMAUFiAHpMAQsd8QAAHeZ6dpg+mAIFeAM -JQBbqVz8AAIdr+ulAArLOGa/zo0RLDEDiDLacO3MCANYDQAAC4AA8UqoDeAPFQAuMAXTDw/uAi40 -BSdgAuPQWRPADQAAqGZya3LbMPrAaB2gDCUAW6lI49BNFQBpgAD2wFAV7/4SAACJELRqeptdCWkM -tJn/IgAH0AoFAIsQ6rAAJdgFAACbEAkbFMq4iBAtgADsgAEly/0AAOrdCARACQAAbZkOKYAArcrs -gAEkQAkAAKqdDcoIHtA7KuR9KgqAW/+H0qDRDwAAAAAAAP//mA2gCgUAjjAc0DT9wBAV4AolAP/A -MBWgC4UAW6nEY/9JAGwQBBnQLiqSfymSgAmrEauZ+yAGFaAYtQAolARbptHAoFumyhvOkCqygxzQ -JQyqAiq2g1umqcAg0Q8AAGwQBBjQIRnQIRrQIfIAAh2gC2UACwg/Agk/AgY/Agc/Ago/CgQ/CQU/ -+Q/oFaCKBQAIAD/TD1uQeh3QFgoBP/Ovxh2gDoUA/6+GHaAMFQAs1H1bpttbprjRDwAAbBAGGc7S -IpJY+5wsBeAOBQDwVYAN7//1APfAaB2gCAUA9gACHeAEBQD8ACIdoArFAG0ITi2SniKSpq1tCdMR -oyKdICslLi8kdpgvlywmJCIsJCAsJCEuJA32QYYdoAWFACUkBSMhEiQlEyokBKNEgyuCLi2SWKN3 -4ogIAzAFAAB9awJj/6oikllkIJsVz+yMEPX/4h2gCgUA8AEQDaAGBQAAwMEk1Aws1A0m1CIv1HaY -35fc86FoFe+CBQAi1CAi1CGC3qN3I5JZ4ogIBVP9AADr1S4jMAUAAONrS3ZgBQAAIpKfLZKmomIJ -IxED3QjzoAYVoAPVAPOghh3gA4UA49QFLX0OAAAqUH4kTAHlr5FiqAUAAG0IDCpQfrFE5a+BYqgF -AABj/+woklrLivWbigXgBgUA+ADiHaAH5QBtCCUskqArkqasbAnNEa27nLAutA0otAwntAQqklrl -tS8jMAUAAHprAmP/08Ag0Q/Y4P/8TA2gBwUAAGwQBsCgW5AtEs5P0w+iqSiSgGeAC20IBSqSgGeg -AmP/88ChW5AmoqkrkoBnsA1tCAUskoBnwARj//MAAPud5AXgChUA/Z3iBaANBQD/nz4F4A4VAFum -jR/OVxPOLhjO6R7NuSkykioykSsykC420S420y421S421ywyjyg20Cg20i82zy821C0yji023i8y -lCgyk63MLjKYLTKXLDbfrLsrNuCrqiwylSo24aqZKzKWKTbiqYgqMqAoNuOo/ykyoS825ygyoq3/ -Lzbor+4uNuSuzCw25i8ypq3MLjKnLTKoLDblrLsrNumrqiwyqSo26qqZKzKqKTbrqYgqMqwoNuyo -/ykyrS827a/uKDKwLjburt0tNu8fzcGtzCw28C82zh7OJ6y7Kzbx/nrGFaANBQAtNt2rqio28qqZ -KTbzqYgoNvRbpk4rMtcvMtYPAgDzb+AVr4gFAOgiAQ1uQoAAotp680gpMtQPAgDLn+o21y1YBIAA -HM2RLjLV8iBmFaAKVQD6IAYV4IgFAPwgJhXgCwUA+CBGFaANFQBbqNjiNvUhAKGAAMAg0Q8AAAAA -//8MDaACBQDHJNEPbBAEE881+5piBaAEBQD3noIFoAcVACSmgSSmgySmgCSmghvN1ygwdf2bxAXg -3lUA/MsIFaAZBQDppookfKKAAA7MKB7N3Q3MLC+ywA7/AQ/PAi+2wC2y4A7dAQ3MAiy24Cuy4MCg -W4+nFc3IEs3JGc54Ba8IKfaBGM8oKPaCJPaD8/AGFaAKFQBbj56lqiSmgRvN2iumgiSmgyKmgFv+ -Quah1W0QBIAAHc19LgoIL9KPDw9DLzR0LNKKG85S/4YADjAIBQD9sUYVoImFAG2aDQuJCySWQOSW -QSRABQAABEoCW/4Z5qGRbRAEgABb/UvmoYZtEASAACkwdX+fCxjOmCeGwCiCwCkwdR3NzCzSgC/S -gSrSgP+wKBWgzIEALGR4LNKAK9KB+7AIFeKqiQAqZHn9sCgV4MyhAPzPRh2iu7EA62R7JPjegABo -py8oMHRogSkMrgwL7gwu7B0A4QQAfRrtZiEmgNGAAPEgDD/SAJ0AW/q380BoHaAAJgAkZiHAIBXO -5mYg8fqgaB2g/PUA+G6wFaAPRQDTD236DCugsLGq/WAGvSIAnQDAoBnNaPEAB5fSAJ0AGs7aKpbA -KpbAKzB1DwIA0w/xYAkf0gCdAPWZdgWgAwUA/ZoeBeDsBQD3nBYFrwn1APP+Ah2gB+UAK1CAKEKC -0w/TDwKIAQeIAihGgi9Cgi5gfOn/AQmCCoAA/eYAD7DunQDvRoInfa6AAG8zCCpCuA2qAipGuOM8 -ASIggwAA6TS3YqgFAADAIPBDeA3gAwUAKmCAADAECgsbf7cY+mBoHaALBQBbpcz8YGgdoAv1AFuh -cypggLEzaTjYHM0LKsacW/w30Q8A//ysDaerHQAAAADaMFulyfnh4h3g7AUA7czgFXylgADzQGgd -r/56AB7OoC1iWA7dLC3c/g0dFOswiC7uwoAA/UYADvAOhQAO3QLtlsAlpDEAAPl/92nSAJ0AL5LA -xoL54AQHsAhVAAj/Av84BhXv+1YAW6YjY/7aJ2SCJGSAFc6LJGSD9MfEHa/0tQDaUFunENKg9V/z -dCIAnQBlr+1j/mEAAABsEAYYzLsXzoEfzoEigH0TzUMkgi/yQA9f0gCdABbM1i0y2wRFCi4y3Csy -2ywy3Cky3Coy3f57iBWtAD0A6jLdKq/CgAD6e+gVo5khAPcgAIS43ZEA+SgEFeAMBQDyfAgVpLvZ -AOrIGAc0LIAACVksYAAVAAbeCQ+yCSIhfi7hUAJSLA4iKAkpLP57SBWhiAEA6jLbLAIKgAD8e0gV -4amdACp2fvJ7aBWoAD0ADs4Y8ntIFayAPQANzRgoMtsrMtv4e4gV7wA9AAKIGPh76BXjiAEA9wAA -hDjuAQD5CAQVqAA9APuLAA303QEA4jLgJfwogAAIVSxgABQG6wkP0gkiIX4rsVACVSwLVSgIVSzy -e+gVrgA9AAnIGPp8CBXgDRUA/nuIFaGIAQDoMt0sAgqAAPWccAXhlZ0A+O/mFe8APQDziwAJOgA9 -AP+LAA8wIgEAAtI5LTLcAkU5BVUKKzLdJDLd+HvIFa6APQD9awAN+O4BAP2YvgXgAgUA+HuoFaS7 -AQD6IAYV4QA9AOTEGAqvwoAA+nvIFeoAPQD5iwAMM0QBAPaAAIIz7IUA5EFAJHx0gAAMmywEXiwr -1iAMrCzs1iEvd4KAAC52gNEPghAG6wkrsVAPIgnyT8QVo+iFAAiTLCPWIAJSLAsiKAioLAQiLOjW -ISkXgoAA8vAGFaACBQDRDwAkdn4kdn8TzgPy8AYV4+mFAAlJLCmGIfkEBhXgAgUA0Q8AAABsEIYY -zLwZzfstgoCOko+RnxGeEiiCgYmQ+CAGFePdQQD1oAXR0gCdAAHSCiIiAPBKmA3kCAUA4opPcNBB -AAAbze4ssoAYze0rsoEMDI4spgD7HwAN8Hn1AG2aGumCgCRAIQAA66YBJVAhAAArgn8JCY6ZoAsL -juumASDQQQAAW/1I56BObRAEgAAbzd0ssoAYzd0rsoHsDBYA0EEAACymAPsfAA3wefUAbZoa6YKA -JEAhAADrpgElUCEAACuCfwkJjpmgCwuO66YBINBBAABb/TTSoMfOfCEW0Q8A0Q8AwKL9m5IFoAuF -AFunRMcr0Q/Aov2bjAWgC4UAW6dA0Q8AbBAEGM3DFs3DKYKBKWaj+RBIFaAJRQApZoApZn8pZn4p -Zo4pZof40UYV4AOFAPLORhXgBwUAJ2acKGak95fGBeAIFQAoZowSy94ay7gjcH0iIoH9l2wF5A4F -APIAAAZ0CwUA7Lo5ATwmgAAqZX7RDwg/Av7vph3g/wEAD+05LWV+0Q8AbBAEHM2mGM2jHsuP/ZtG -BeAKRQD7EEYdoAsFACuFQC2GHv8D5hWgjwUAW6cTwCDRDwAAAGwQBBvNmhrNmhjNmsDA6rZ/JVED -AAD7D+YVoIuFAFuj49EPAGwQBhvLcOrNkxENaQAAaCJ2iRDkkIFkkAUAAPxIYEFQBBUAYAAOAAAA -AABpZAOlqJeAckss6jQAClgEgABbqRboYRRiIAUAAOWpCAsXfAAA9yAEHe//egClq/dgBh3v/1IA -0Q8ssi0pooOjzAnMEeyZCAMN5QAAaGJ4aWTkpZ2X0NEPAAAAAADoQDdiEAUAAHJDoWP/ywAALLIt -hBEpooOjzOnMEQIgBQAA7JkIAwyBAABoYiJoZCnyn/vLogCdAGP/nhnMSqk5KZB9Y/9EpZr3QAYd -7/+SAKWb92AEHe//agClnPeABhXv/0IApZ0n1ADRD6WeJ+UA0Q8AAAAAAAAAAAAAAAAAACACjaQM -wAACIAXtfCACjagIwAAIIAXtfCACjawgwAAMIAXtBCACjbAGwAA0IAXu2CACjbQIwAA4IAXtfCAC -jbgCwAA8IAXu2CACjbwIwABAIAXtfCACjcAIgABEIAXuBCACjcQYgABYIAXuBCACjcgYgABkIAXu -BCACjcwYgABwIAXuBCACjdAYgAB8IAXuBCACjdQYgAC4IAXuBCACjdgYgADEIAXuBCACjdwYgADQ -IAXuBCACjeAYgADcIAXuBCACjeQIgAEYIAXuBGNzb2NrX2Nsb3NlZDogc2l6ZW9mKHRjYl9mYy0+ -dS5vZmxkLm8uZm9pc2NzaV9jb25uKSBbJXVdLCBieXRlcwoAAAAAAAAAAAAAAAAAAAAAY3NvY2tf -ZmFpbGVkOiBjc2tfZmMtPmZsb3djX2lkIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19zdGF0ZSBbMHgl -eF0sIHNlc3NfZmMtPmZsb3djX2lkIFsweCV4XSwgc2Vzc19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhd -LCBldnQgWzB4JXhdCgAAAAAAAAAAAAAAY2huZXRfZmluZF9sMnRfZW50cnk6IGRhZGRyIFslMDh4 -XSwgWzB4JTA4eF0sIGxvY2FsIG5ldHdvcmsgWyVkXQoAAAAAAAAAAAAAAAAAAABsMnRlbnQgWyUw -eF0sIGwydGVudC0+aWR4IFslZF0KAHJjIFslZF0sIGNza19mYyBbMHgleF0sIGNza19mYy0+Zmxv -d2NfaWQgWzB4JXhdCgAAAAAAAAAAAAAAAAAAAABjc29ja19mcmVlOiBzaXplb2YoY3NrX2ZjLT51 -LmNzb2NrKSBbJXVdLCBieXRlcwoAAAAAAAAAAAAAAAAAAAAAbG9naW5fcGFyYW1zOiBjb25uX2Zj -LT5mbG93Y19mb2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhdCgAAAAAAAAAAAGxvZ2luX3BhcmFtczog -Y29ubl9mYy0+Zmxvd2NfZm9pc2NzaV9jb25uX2ZsYWdzIFsweCV4XQoAAAAAAAAAAABUQ1AgY29u -biBlc3RhYmxpc2htZW50IGZhaWxlZCAlZAoAAAAAAAAAAAAAAAAAAABpbm9kZV9mYy0+Zmxvd2Nf -ZmxhZ3MgWzB4JXhdLCBpbm9kZV9mYy0+Zmxvd2NfYnVmLT5maWZvLm51bV9ieXRlcyBbJXVdCgAA -AAAAAAAAAHVzZXJuYW1lIG1pc21hdGNoCgAAAAAAAAAAAAAAAAAAUmVjdmQgYW5kIENvbXB1dGVk -IGRpZ2VzdCBtaXNtYXRjaAoAAAAAAAAAAAAAAAAAYmFzZTY0IEVSUiwgJWQgbGVmdCwgd2l0aCAl -ZCBwYWQuCgAAAAAAAAAAAAAAAAAAYmFzZTY0IEVSUiwgJWQgbGVmdCwgd2l0aCAlZCBwYWQuCgAA -AAAAAAAAAAAAAAAAYmFzZTY0IEVSUiwgJWQgbGVmdCwgd2l0aCAlZCBwYWQuCgAAAAAAAAAAAAAA -AAAAUmVjaWV2ZWQgQXV0aE1ldGhvZCB2YWx1ZQoAAAAAAAB2YWxpZGF0ZV9rZXl2YWw6IGZsb3dj -X2ZvaXNjc2lfY29ubl9mbGFncyBbMHgleF0KAAAAAAAAAAAAAAAAAAAAdmFsaWRhdGVfa2V5dmFs -OiBmbG93Y19mb2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhdCgAAAAAAAAAAAAAAAAAAAE5lZ28gRkJM -IFsldV0KAABLRVlfTUFYUkNWRFNMIFsldV0KAAAAAAAAAAAAAAAAAER1cGxpY2F0ZSBpc2NzaSBr -ZXkKAAAAAAAAAAAAAAAAc2VuZF9sb2dpbl9yZXF1ZXN0OmNvbm5fZmMtPmZsb3djX2lkIFsweCV4 -XSwgc2Vzc19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBwYXJhbSBbMHgleF0sIHBhcmFtLT5zZXNzX3R5 -cGUgWzB4JXhdLCBzZXNzX2ZjLT5mbG93Y19mb2lzY3NpX3Nlc3NfdHlwZSBbMHgleF0KAAAAAAAA -AAAAAHNlbmRfbG9naW5fcmVxdWVzdDogdHhfbGVuIFsldV0KAAAAAAAAAAAAAAAAAAAAAGZvaXNj -c2lfcGFyc2VfcmN2ZF9wYXJhbXM6IGVycm9yCgAAAAAAAAAAAAAAAAAAAGZvaXNjc2lfcGFyc2Vf -cmN2ZF9wYXJhbXM6IHJsZW4gJWQKAAAAAAAAAAAAAAAAAFNlcSAjIG1pc21hdGNoIHN0YXRzbiA9 -IDB4JXggZXhwc3RhdHNuID0gMHgleAoAAHRleHRfcmVzcDogY19iaXQgWzB4JXhdLCBmX2JpdCBb -MHgleF0KAAAAAAAAAAAAAGxvZ2luX3Jlc3A6IGZsb3djX2ZvaXNjc2lfY29ubl9mbGFncyBbMHgl -eF0KAAAAAGxvZ2luX3Jlc3A6IGZsb3djX2ZvaXNjc2lfY29ubl9mbGFncyBbMHgleF0sIHJjIFsw -eCV4XQoAAAAAAAAAAABpU0NTSSBTZWMtcGFyYW1zIHJlY2VpdmVkaGF2ZSBlcnJvcnMhIQoAAAAA -AAAAAABUYXJnZXQgbW92ZWQgdGVtcC4gY29ubiAleCwgc2VzcyAleAoAAAAAAAAAAAAAAABMb2dp -biBGYWlsZWQhIS4gY29ubiAlZCwgc2VzcyAlZAoAAAAAAAAAAAAAAAAAAABsb2dpbl9yZXNwOiBz -ZXNzX2ZjLT5mbG93Y19pZCBbJXVdLCBjb25uX2ZjLT5mbG93Y19pZCBbJXVdIGxvZ2dlZCBpbgoA -AAAAAAAAAAAAAFByb3RvY29sIEVycm9yIGNiaXQgJWQgdGJpdCAlZCBjc2cgJWQgbnNnICVkCgAA -AGRyb3BfYWxsX3Rhc2s6IHJlcXVlc3RlZCBsaWR4IFsldV0KAAAAAAAAAAAAAAAAAGdldF9yZWZf -dGFzazogaXN0YXNrLT5mbG93Y19pZCBbMHgleF0sIGlzdGFza19mYy0+Zmxvd2Nfc3RhdGUgWyV1 -XSwgaXN0YXNrX2ZjLT5mbG93Y19mb2lzY3NpX3Rhc2tfbGlkeCBbJXVdLCBsaWR4IFsldV0KAAAA -AAAAAAAAcHJvY2Vzc190bWZfcmVzcG9uc2U6IGlzdGFza19mYy0+Zmxvd2NfYnVmLT5zY2hlZF9u -b2RlLm5leHQgWzB4JXhdLCBpc3Rhc2tfZmMgWzB4JXhdLCBpc3Rhc2tfZmMtPmZsb3djX2lkIFsl -dV0KAHByb2Nlc3NfdG1mX3Jlc3BvbnNlOiB1bHB0eHBsZW4xNiBbJXVdCgAAAAAAAAAAAHByb2Nl -c3NfdG1mX3Jlc3BvbnNlOiBkZWxheV9wcm9jZXNzaW5nLCBvcCBbJXhdCgAAAAAAAAAAAAAAAAAA -AABwcm9jZXNzX3RtZl9yZXNwb25zZTo6IHdyIG9wY29kZSBbMHgleF0KAAAAAAAAAABwcm9jZXNz -X3RtZl9yZXNwb25zZTo6IHRhc2sgZnVuY3Rpb24gWzB4JXhdCgAAAABjYWxsaW5nIGRyb3BfdGFz -aywgaXN0YXNrX2ZjLT5mbG93Y19mb2lzY3NpX3Rhc2tfbGlkeCAweCV4CgAAAAAAcHJjb2VzX2Rh -dGFfaW5fcmVzcG9uc2U6IGNvbm4tPmZsb3djX2lkIFsweCV4XSwgaXN0YXNrX2ZjLT5mbG93Y19p -ZCBbMHgleF0KAAAAAABERFAgZXJyb3IgZm9yIGNvbm4gWzB4JXhdLCBtYXNrIFsweCV4XQoAAAAA -AAAAAABzZW5kX2Fib3J0X3JlcTogY3NrX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3NrX2ZjLT5m -bG93Y19pZCBbMHgleF0sIGNza19mYy0+Zmxvd2NfY3NvY2tfdGlkIFsweCV4XSwgdWxwdHhjaCBb -JXVdLCBidWZmZXJlZCBbJXVdCgAAAAAAAAAAAAAAAAAAAABpc2NzaV9oZHI6IGJhZCB0Y2Igc3Rh -dGUgdG8gcnggZGF0YSwgdGNiX2ZjLT5mbG93Y19pZCBbMHgleF0sIHRjYl9mYy0+Zmxvd2Nfc3Rh -dGUgWzB4JXhdCgAAAAAAAAB3cmhfZm9pc2NzaV9ub2RlOiBub2RlX3dyLT5mbG93aWRfbGVuMTYg -MiBbJXhdCgB3cmhfZm9pc2NzaV9jaGFwOiBpZF9sZW4gWyV4XSwgc2VjX2xlbiBbJXhdCgAAAAB3 -cmhfZm9pc2NzaV9jaGFwOiB0Z3RfaWRfbGVuIFsleF0sIHRndF9zZWNfbGVuIFsleF0KAAAAAAAA -AAAAAAAAcGVlcl9jb246IGNza19mYyA9PiBmbG93aWQgWzB4JXhdLCBmbG93Y19idWYgWzB4JXhd -CgAAAAAAAAAAAAAAAGZvaXNjc2lfY3RybDogc3Vib3AgWzB4JXhdLCBzZXNzX3R5cGVfdG9fZXJs -IFsweCV4XSwgc2Vzc190eXBlIFsweCV4XQoAAAAAAAAAAAAASW52YWxpZCBvcGNvZGUgMHgleCBp -biBjdHJsIHBhdGgKAAAAAAAAAAAAAAAAAAAAcnhfZGF0YS0+c2VxIFsweCV4XSwgcnhfZGF0YS0+ -bGVuIFsweCV4XSwgcnhfZGF0YS0+c3RhdHVzIFsweCV4XQoAAAAAAAAAAAAAAAAAAABjc2tfZmMt -PmZsb3djX2Nzb2NrX29mZnNldCBbMHgleF0sIGRsZW4xNiBbMHgleF0KAAAAAAAAAAAAAAAAAAAA -YWN0X2VzdDogZmxvd2NfZm9pc2NzaV9jb25uX2ZsYWdzIFsweCV4XQoAAAAAAAAAYWN0X2VzdGFi -OiB0Y2JfZmMtPmZsb3djX2J1ZiBbMHgleF0sIHRjYl9mYy0+Zmxvd2NfdHlwZSBbMHgleF0gdGNi -X2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0sIG5wYWdlcyBbMHgleF0sIGZsb3djX3RwX3NuZF9tYXgg -WzB4JXhdCgAAAAAAAAAAAAAAAAAAYWN0X2VzdGFiOiBhdGlkIFsweCV4XSwgdGlkIFsweCV4XSwg -b3AgWzB4JXhdLCByY3ZfaXNuIFsweCV4XSwgc25kX2lzbiBbMHgleF0sIGNzb2NrLT5mbG93Y19z -dGF0ZSBbMHgleF0sIHRjcF9vcHQgWzB4JXhdLCB0Y2JfZmMtPmZsb3djX2lkIFsweCV4XSAKAAAA -AAAAAAAAAAAAAGNza19mYy0+Zmxvd2NfY3NvY2tfY29va2llIFsweCV4XSAKAAAAAAAAAAAAAAAA -AG5ldGlmX2RvX2RoY3A6IHdyLT5wYXJhbS52bGFuaWQgWyV1XSwgbDJkZXZfZmMtPmZsb3djX25l -dF9sMmRldl92bGFuZGV2IFsweCV4XQoAbmV0aWZfZG9fZGhjcDogcmwyZGV2X2ZjLT5mbG93Y19p -ZCBbMHgleF0sIGRoY3BfY3R4dCBpbml0aWFsaXphdGlvbiBlcnJvcgoAAAAAAABsM2luNF9kZXZf -Y29uZmlnOiB3ci0+cGFyYW0udmxhbmlkIFsldV0sIGwyZGV2X2ZjLT5mbG93Y19uZXRfbDJkZXZf -dmxhbmRldiBbMHgleF0KAAAAAAAAAAAAAAAAAABuZXRfbDNpbjRfZGV2X2NvbmZpZzogbDJkZXZf -ZmMtPmZsb3djX2lkIFsweCV4XSwgYWRkcmVzcyBhbHJlYWR5IHVzZWQgYnkgcG9ydCAlZAoAAAAA -AAAAAAAAAAAAAABuZXRfbDNpbjRfZGV2X2NvbmZpZzogIGFkZHIgWzB4JXhdLCBtYXNrIFsweCV4 -XSwgZ3cgWzB4JXhdLCByZWZfY250IFsweCV4XSBpbiB1c2UKAAAAAAAAAAAAAAAAAAB3cmhfY2hu -ZXRfaWZjb25mOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBsMmRldl9mYy0+Zmxvd2NfdHlw -ZSBbJTB4XSwgaWZjb25mX3dyLT5zdWJvcCBbMHgleF0KAAAAAAAAAAAAAAAAAAAAd3JoX2NobmV0 -X2lmY29uZjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgdW5rbm93biBzdWJvcCBbMHgleF0K -AAAAAAAAAAAAAAAAAAB3cmhfY2huZXRfaWZjb25mOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhd -LCByYyAlZAoAAAAAAAAAAAAAAAAAbmV0aWZfaXBfY29uZmxpY3RfdGltZXJfY2I6IGwyZGV2X2Zj -LT5mbG93Y19pZCBbMHgleF0sIGluZGV2Y3R4dC0+c3RhdGUgWyVkXSwgaW5kZXZjdHh0LT5yZXRy -eV9jbnQgWyVkXQoAAAAAAAAAAG5ldGlmX2lwX2NvbmZsaWN0X3RpbWVyX2NiOiBsMmRldl9mYy0+ -Zmxvd2NfaWQgWzB4JXhdLCBpbmRldmN0eHQgWzB4JXhdLCBpbiBmcmVlIHN0YXRlCgAAAAAAAAAA -AGlmYWNlX2NtZF9oYW5kbGVyOiBmYyBbMHgleF0sIGZjLT5mbG93Y19pZCBbMHgleF0sIGZjLT5m -bG93Y190eXBlIFsweCV4XSwgcCBbMHgleF0sIGxlbjE2IFsldV0sIGxvYyBbMHgleF0KAAAAAABp -ZmFjZV9jbWRfaGFuZGxlcjpsMmRldl9mYyBbMHgleF0sIGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgl -eF0sIGwyZGV2LT5mbG93Y190eXBlIFsldV0sIGwyZGV2X2ZjLT5mbG93Y19uZXRfbDJkZXZfZmxh -Z3MgWyUweF0KAAAAAGZvaXNjc2lfaWZhY2VfY21kX2hhbmRsZXI6IGwyZGV2X2ZjLT5mbG93Y19u -ZXRfbDJkZXZfZmxhZ3MgY2hhbmdlZCBmcm9tIFslMHhdIHRvIFslMHhdCgAAAAAAAAAAAGNobmV0 -X2wyZGV2X3VwOiBtYiBbMHgleF0sIGRlZmVycmVkLCBzdGF0ZSBbMHgleF0sIHBvcnQgWzB4JXhd -CgB2aWlkIFsweCV4XSBwb3J0IFsweCV4XSwgbWFjLWlkIFslMDJ4OiUwMng6JTAyeDolMDJ4OiUw -Mng6JTAyeF0gcnNzX3NpemUgJXUKAAAAAHZpIHR5cGUgWzB4JXhdLCBwb3J0IFsweCV4XSwgZmxv -d2Nfc2dlX2VxaWQgWzB4JXhdLCBmbG93Y19zZ2VfZXFpZCBbMHgleF0sIGZsb3djX3NnZV9lcWNy -ICV1CgAAAG5ldGlmX3NldF9tYWM6IG1iX3NjcmF0Y2ggWzB4JXhdLCBwb3J0IFsweCV4XQoAAG5l -dGlmX3NldF9yeG1vZGU6IGwyZGV2X2ZjLT5mbG93Y19uZXRfbDJkZXZfbXR1IFsldV0sIG1iX3Nj -cmF0Y2ggWzB4JXhdLCBwb3J0IFsweCV4XQoAAAAAAAAAAAAAAGNobmV0X2wyZGV2X3VwOiBsMmRl -dl9tYWMgWyUwMng6JTAyeDolMDJ4OiUwMng6JTAyeDolMDJ4XSwgZmxvd2NfbmV0X2wyZGV2X2Zs -YWdzIFsweCV4XQoAAAAAAAAAAGNobmV0X2wyZGV2X3VwOiBtYl9sb2MgWzB4JXhdLCBtYl9vcmln -IFsweCV4XSwgcmMgWyVkXQoAAAAAAAAAAABjaG5ldF9sMmRldl91cF9tYl9jYjogcmMgWyVkXSwg -cG9ydCBbJXVdLCBzdGF0ZSBbJXVdLCBjb29raWUgWyV1XQoAAAAAAAAAAAAAAAAAAGNobmV0X3ht -aXQ6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIHZsYW5pZCBbJXVdLCBMNENoa0Rpc2FibGVf -dG9faVZsYW5UYWcgWzB4JXhdCgAAAAAAAAAAAAAAAGNobmV0X3htaXQ6IHR4X2RsZW4gWyV1XQoA -AAAAAAAAY2huZXRfeG1pdDogYWxyZWFkeSBzY2hlZHVsZWQKAABjaG5ldF94bWl0OiBsMmRldl9m -Yy0+Zmxvd2NpZCBbMHgleF0sIG5idWYgWzB4JXhdIGluIGRlbGF5ZWRfcHJvY2Vzc2luZwoAAAAA -AAAAAGRoY3BfcHJvY2Vzc19jYjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgZGhjdHh0LT5z -dGF0ZSBbJTB4XSwgZGhjdHh0LT5ydHJ5X2NudCBbJXVdCgAAAAAAAAAAAGRoY3BfdGltZXJfY2I6 -IERIQ1BESVNDT1ZFUiBzZW50LCBidXQgbm8gcmVwbHkgZnJvbSBhbnkgcG9zc2libGUgc2VydmVy -IG9uIHRoZSBuZXR3b3JrLiBSZXRyeWluZyBhZ2FpbgoAAAAAAAAAAABkaGNwX3RpbWVyX2NiOiBs -MmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBzZW5kaW5nIERIQ1BESVNDT1ZFUiBmb3IgZGhjdHh0 -IFsweCV4XSBvbiBwaWQgWyVkXQoAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQg -WzB4JXhdLCBESENQT0ZGRVIgcmVjZWl2ZWQgZm9yIGRoY3R4dCBbJXhdIHBpZCBbJWRdCgAAAAAA -AAAAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCAgREhDUEFDSyBy -ZWNlaXZlZCBmb3IgZGhjdHh0IFsleF0sIHBpZCBbJWRdCgAAAAAAAAAAAABkaGNwX3RpbWVyX2Ni -OiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBkaGN0eHQtPmlwYWRkciBbMHgleF0KAAAAAAAA -AAAAAAAAAAAAAGRoY3BfdGltZXJfY2I6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIG5vIHJl -cGx5IGZyb20gZGhjcCBzZXJ2ZXIsIHRpbWluZyBvdXQKAAAAAAAAAAAAAAAAAAAAAHBbJXVdIGNo -YW5naW5nIHNwZWVkIGZyb20gJSN4IHRvICUjeAoAAAAAAAAAAAAAAHBbJXVdIGJjbTg0ODM0IGxp -bmsgc3RhdHVzIGNoYW5nZSBVUAoAAAAAAAAAAAAAAHBbJXVdIGJjbTg0ODM0IGxpbmsgc3RhdHVz -IGNoYW5nZSBET1dOCgAAAAAAAAAAAGh3X2NsNDVfdXBkX3NwZF9hZHYgJSN4CgAAAAAAAAAAcFsl -dV0gYXExMjAyIGxpbmsgc3RhdHVzIGNoYW5nZSBVUAoAAAAAAAAAAAAAAAAAcFsldV0gUEhZIE9W -RVJIRUFURUQgLSBmb3JjZWQgcG93ZXIgZG93biAodGVtcD0lZCkKAAAAAAAAAAAAAAAAAHBbJXVd -IGFxMTIwMiBsaW5rIHN0YXR1cyBjaGFuZ2UgRE9XTgoAAAAAAAAAAAAAAG1vZHVsZVsldV06IHBv -cnQgbW9kdWxlIGluc2VydGVkIGFuZCByZWFkeQoAAAAAAG1vZHVsZVsldV06IHBvcnQgbW9kdWxl -IHJlbW92ZWQKAAAAAAAAAAAAAAAAAAAAAG1vZHVsZVsldV06IHVua25vd24gbW9kdWxlIGlkZW50 -aWZpZXIgMHglMDJ4CgAAAG1vZHVsZVsldV06IGdwaW8gJXUgdHJhbnMgMTBHIDB4JTAyeCAxRyAw -eCUwMnggKGxlbmd0aCAldSkgY2FibGUgMHglMDJ4IChsZW5ndGggJXUpIG1vZHVsZV90eXBlIDB4 -JTAyeAoAAAAAAAAAAABjeDRfY3JfcGRvd25bJXVdOiBlbiAldSB2aV9lbl9jbnQgJXUKAAAAAAAA -AAAAAABpbml0X3BvcnRbJXVdOiAgbGluayBzdGF0dXMgMHgleCBtb2RfdHlwZSAweCV4IHZpX2Vu -X2NudCAldSByeF9sb3MgJXUgaHNzX3NpZ2RldCAldSBwb3J0X2NmZy5zaWdkZXQgJXUKAAAAAAAA -AAAAaW5pdF9wb3J0WyV1XTogIGxpbmsgc3RhdHVzIDB4JXgKAAAAAAAAAAAAAAAAAAAAaW5pdF9w -b3J0WyV1XTogIGxpbmsgc3RhdHVzIDB4JXgKAAAAAAAAAAAAAAAAAAAAaW5pdF9wb3J0WyV1XTog -IGxpbmsgc3RhdHVzIDB4JXgKAAAAAAAAAAAAAAAAAAAAaW5pdF9wb3J0WyV1XTogIGxpbmsgc3Rh -dHVzIDB4JXgKAAAAAAAAAAAAAAAAAAAAaW5pdF9wb3J0WyV1XTogIGxpbmsgc3RhdHVzIDB4JXgK -AAAAAAAAAAAAAAAAAAAAbmV3IG1vZHVsZSBuZXcgc3BlZWQgKHRlY2hfdHlwZT0lI3gpCgAAAAAA -AAAAAAAAY3JfbW9kdWxlX3N0YXR1c1sldV06IHR5cGUgY2hhbmdlZCBmcm9tIDB4JTAyeCB0byB0 -eXBlIDB4JTAyeCBzdHlwZSAweCUwMngKAAAAAABjeDRfY3JbJXVdOiByZXQgJWQgc3RhdHVzICV1 -IHhnbV9scyAweCUwOHgKAAAAAAB3YXRjaGRvZyBjbWQgaGFuZGxlciAodGltZSAldSBhY3Rpb24g -JXUpCgAAAAAAAABXQVRDSERPRzogZGV2aWNlIHNodXRkb3duCgAAAAAAAFdBVENIRE9HOiBieXBh -c3MgdGltZW91dAoAAAAAAAAAV0FUQ0hET0c6IEZMUiAtIG5vdCBpbXBsZW1lbnRlZCB5ZXQKAAAA -AAAAAAAAAAAAZmlsdGVyOiBwb3JncmFtbWluZyB0aWQgJXUgKGxlIHRjYW0gaW5kZXggJXUpLi4u -CgAAAAAAAAAAAAAAAAAAAGZpbHRlcjogcmVxdWVzdGluZyBjb21wbGV0aW9uLi4uCgAAAAAAAAAA -AAAAAAAAAEZDT0UgRnJlZTogc3RpbGwgeWllbGRlZCB3aGVuIGZyZWVpbmcuLi5mbG93Y19pZCAl -eCBmbG93Y19mbGFncyAleCAKAAAAAAAAAAAAAAAAcG9ydCAlZCBwcmlvciAlZCBzZWxlY3QgJWQg -cHJvdG9jb2xJRCAweCUwNHgKAAAAcG9ydCAlZCBzZXQgcGZjX2VuID0gMHgleAoAAAAAAABwb3J0 -ICVkIHNldCBwZ2lkXzBfNyA9IDB4JTA4eCBwZ19wZXJjZW50YWdlIDB4JTA4eF8lMDh4IG51bV90 -Y3Nfc3VwcG9ydGVkICVkCgAAAHBvcnQgJWQgc2V0IHBmY19lbiA9IDB4JXgKAAAAAAAARkNvRSBE -RFAgZmFpbGVkIDogb3hfaWQgMHgleCByeF9pZCAweCV4CgAAAAAAAAAARkNvRSBERFAgZmFpbGVk -IDogRGRwUmVwb3J0IDB4JXggRGRwVmFsaWQgMHgleAoAUFJMSSBSc3AgdGltZWRvdXQgOiBmbG93 -Y19pZCAweCV4IG94X2lkIDB4JXggcnhfaWQgMHgleCAKAAAAAAAAAGNhbm5vdCBhbGxvY2F0ZSBv -ZmZsb2FkZWQgZmlsdGVyIGNvbm5lY3Rpb24KAAAAAGNhbm5vdCBhbGxvY2F0ZSBvZmZsb2FkZWQg -ZmlsdGVyIElQdjYgY29ubmVjdGlvbgoAAAAAAAAAAAAAAAAAAAB1b1sldV06IHdyICVwIHdyLT5s -ZW5ndGggJXUgbXNzICV1CgAAAAAAAAAAAAAAAAB1b1sldV06IGYgMHglMDh4IGRzdF9jcGwgMHgl -MDh4IHNyY19jcGwgMHglMDh4IGltbWRsZW4xNiAldQoAAAAAdW9bJXVdOiBsYXN0IG1zcyAldQoA -AAAAAAAAAAAAAAB1b1sldV06ICFsYXN0IHdyLT5zY2hlZHBrdHNpemUgJXUKAAAAAAAAAAAAAAAA -AABpbnZhbGlkIGJ1ZmZlciBncm91cFsldV0gY29uZmlndXJhdGlvbjogbXR1ICV1IGx3bSAldSBo -d20gJXUgZHdtICV1CgAAAAAAAAAAAAAAAGZjICV1IHZmICV1IGdvdCBpdmY9MHgleCxyYW5nZTog -JSN4LSUjeCAoJXUvJXUgdXNlZCkKAAAAAAAAAAAAAABWSSAldSBjYW5ub3QgZ2V0IFJTUyBzbGlj -ZTogTm8gbW9yZSBzbGljZXMgYXZhaWxhYmxlICh1c2VkICV1LyV1KQoAAAAAAAAAAAAAAAAAAHBm -biAldSB2Zm4gJXUgd2l0aCBwb3J0IG1hc2sgMHgleCBjYW5ub3QgYWNjZXNzIHBvcnQgJXUsIHJl -dCAlZAoAAAAAAAAAAAAAAAAAAAAAcGZuICV1IHZmbiAldSBjb3VsZCBub3QgYWxsb2NhdGUgdmlp -ZCwgcmV0ICVkCgAAcGZuICV1IHZmbiAldSBjb3VsZCBtYXAgdmlpZCAgMHgleCB0byBmbG93Yywg -cmV0ICVkCgAAAAAAAAAAAAAAAHBmbiAldSB2Zm4gJXUgY291bGQgbm90IGFsbG9jYXRlIHV3aXJl -IGZ1bmMgJWQgbWFjIGFkZHIsIHJldCAlZAoAAAAAAAAAAAAAAAAAAAAAbWlpX2Fkdl9mY1sldV06 -IHJjYXBzIDB4JXgKAAAAAABtaWlfYW5yZXN0YXJ0WyV1XTogYWNhcHMgMHgleAoAAG1paV9mb3Jj -ZV9zcGVlZFsldV06IHJjYXBzIDB4JXgKAAAAAAAAAAAAAAAAAAAAAG1paV9saW5rX3N0YXR1c1sl -dV06IGJtc3IgMHglMDh4IHN0YXR1cyAldSB4Z21fbHMgMHglMDh4CgAAAAAAAABwb3J0X2NtZF9o -YW5kbGVyOiB1bmtub3duIHUuZGNiLnR5cGUgMHgleAoAAAAAAABwb3J0WyV1OjB4JTAyeDoweCUw -MnhdOiBwaHkgcmVzZXQgbm90IGF2YWlsYWJsZQoAAAAAAAAAAAAAAAAAAAAAcG9ydFsldToweCUw -Mng6MHglMDJ4XTogdW5rbm93biBhY3Rpb24gMHgleAoAAAAAcG9ydFsldToweCUwMng6MHglMDJ4 -XTogdW5rbm93biByZWFkIGFjdGlvbiAweCV4CgAAAAAAAAAAAAAAAAAAAGNoX2NsX3JhdGVbJXUv -JXVdOiBjYXBwZWQgY2xhc3MgcmF0ZSBmcm9tIHJlcXVlc3RlZCAldSB0byBjb25maWd1cmVkIGNo -YW5uZWwgcmF0ZSAldQoAAAAAAAAAAAAAAGNoX2NsX3JhdGVbJXUvJXVdOiBpbmNyZWFzZWQgZGVm -aWNpdF9pbmNyIGZyb20gcmVxdWVzdGVkICV1IHRvIHJlcXVpcmVkIG1pbiBvZiAldTsgcmF0ZSAl -dSAoZWZmICV1KSBkZWZpY2l0X21heCAldQoAAAAAAAAAAAAAAAAAcGt0c2NoZWQgY2hhbm5lbCAl -dSBzZXRzIHNwZWVkIChmcm9tICV1KSB0byAldSBrYnBzCgAAAAAAAAAAAAAAAHBvcnRfY21kX2hh -bmRsZXI6IHVua25vd24gdS5kY2IudHlwZSAweCV4CgAAAAAAAGh3X2kyY190cmFuc2FjdGlvbjog -bmRhdGEgJXUgYWRkcl9vcCAweCV4IGRhdGFbMF0gMHgleCBkaWZmICV1CgBod19pMmNfdHJhbnNh -Y3Rpb246IG5kYXRhICV1IGFkZHJfb3AgMHgleCBkYXRhWzBdIDB4JXggZGlmZiAldSBkcG9zICV1 -IGNvbnQgJXUgZmFpbGVkIHdpdGggZXJyICVkCgAAAAAAAAAAAAAAAAAAaTJjIHRyYW5zYWN0aW9u -IGZhaWxlZCB0byBjb21wbGV0ZQoAAAAAAAAAAAAAAAAAaTJjIGVycm9yIGNhdXNlZCBieSBtb2R1 -bGUgdW5wbHVnCgAAAAAAAAAAAAAAAAAAUVNGUCBtb2R1bGUgdW5wbHVnIC0gcmVpbml0aWFsaXpp -bmcgcnhfbG9zICB0byAweGZmCgAAAAAAAAAAAAAAAGdwaW9fcXNmcF9tb2R1bGVfdXBkYXRlOiBj -aGFuZ2VkIHJ4X2xvcyBmcm9tIDB4JXggdG8gMHgleAoAAAAAAABncGlvX3FzZnBfbW9kdWxlX3Vw -ZGF0ZTogY2hhbmdlZCB0eF9kaXMgZnJvbSAweCV4IHRvIDB4JXgKAAAAAAAAc2VuZHRvIHBlbmRp -bmc6IHdyX3BlbmQgJXAgZm9yIHBvcnQgJXUsICB3YW50IHRvIHNlbmQgdG8gcG9ydCAldQoAAAAA -AAAAAAAAAAAAAABzZW5kdG86Zmxvd2NpZCAldQoAAAAAAAAAAAAAAAAAAGNwbF9lcnJfbm90aWZ5 -OiB0aWQgJXUgY3BsIDB4JTA4eCUwOHgKAAAAAAAAAAAAAGNwbF9lcnJfbm90aWZ5OiB0aWQgJXUg -Y3BsIDB4JTA4eCUwOHggMHglMDh4JTA4eAoAAAAAAAAAAAAAAAAAAABjcGxfZXJyX25vdGlmeTog -dGlkICV1IGxlbiAldQoAAEZDT0UgRnJlZTogc3RpbGwgeWllbGRlZCB3aGVuIGZyZWVpbmcuLi5m -bG93Y19pZCAleCBmbG93Y19mbGFncyAleCAKAAAAAAAAAAAAAAAARkNPRSBCUCBXUiBFUlI6IFdS -IHdpdGggY29va2llICV4JXggZXJyb3JlZCBiYWNrIAoAAAAAAAAAAAAAAAAAAHNjc2lfYWJvcnQ6 -IEVudGVyaW5nIEFib3J0X3Rhc2sKAAAAAAAAAAAAAAAAAAAAAHNjc2lfYWJvcnQ6OiB3ci0+aXFp -ZCBbMHgleF0sIGlzdGFza19mYy0+Zmxvd2Nfc2dlX2lxaWQgWzB4JXhdCgBzY3NpX2Fib3J0Ojog -bHVuX2lkeCBbMHgleF0KAAAAAHNjc2lfYWJvcnQ6IHJlZiB0YXNrIG5vdCBvdXRzdGFuZGluZwoA -AAAAAAAAAAAAAHNjc2lfYWJvcnQ6IHJlZiB0YXNrIGZvdW5kIGl0dCBbMHgleF0gY29va2llIFsw -eCVwXQoAAAAAAAAAAAAAAABzY3NpX2Fib3J0OiBzcmVxLT5vcGNvZGUgWzB4JXhdIGZsYWdzIFsw -eCV4XQoAAABzY3NpX2Fib3J0OiB0YXNrX2lkeCBbJXVdLCBpdHQgWzB4JXhdCgAAAAAAAAAAAABh -Ym9ydC9jbG9zZSBXUiB3aXRoIGNvb2tpZSAweCVseCB3YXMgaXNzdWVkIG9uIHNzbiAweCV4IGlu -IHdyb25nIHN0YXRlIDB4JXgKAAAAAGFib3J0IFdSIG9uIHNzbiAweCV4IGRpZCBub3QgZmluZCBX -UiB3aXRoIGNvb2tpZSAweCV4JXgKAAAAAAAAAABjbG9zZSBXUiB3aXRoIGNvb2tpZSAweCVseCBv -biBzc24gMHgleDtkaWQgbm90IGZpbmQgV1Igd2l0aCBjb29raWUgMHglbHgKAAAAAAAAAGFib3J0 -IFdSIG9uIHNzbiAweCV4IHdhcyBpc3N1ZWQgb24geGNoZyAweCV4IHdpdGggcnhfaWQgMHgleCBp -biB3cm9uZyBzdGF0ZSAweCV4CgAAAAAAAAAAAAAAAAAAAHdyaF9mb2lzY3NpX3Njc2lfZXJyOiB3 -ciBbMHgleF0sIHF1ZXVlZCBvbiBmbG93YyBbMHgleF0sIGZpZm8gWzB4JXhdIGJ5dGVzX2F2YWls -YWJsZQoAAAAAAAAAAAAAAG5ldF9sMmRldl9ub3RpZnk6IEV2ZW50IG9uIGwyZGV2X2ZjLT5mbG93 -Y19pZCBbMHgleF0sIHBvcnQgWyVkXSwgZXZlbnQgWzB4JXhdLCB1bHB0eGNoIFsldV0sIGNsYXNz -IFsweCV4XSwgcHJpb3JpdHkgWzB4JXhdCgAAAAAAcG9ydCAlZCBhcHBsSUQgMHglMDR4IG91aSAw -eCUwNnggdXNlcl9wcmlvciAlZAoAc2VuZCBkY2J4IGluZm86Zmxvd2NpZCAldQoAAAAAAABzZW5k -IGRjYnggY29tcGxldGUKAAAAAAAAAAAAAAAAAERDQlggcG9ydCAldSBhbGxfc3luY2QgPSAldQoA -AAAAY2huZXRfbDJ0X3VwZGF0ZTogbDJkZXZfZmMgWzB4JXhdLCBsMmRldl9mYy0+Zmxvd2NfaWQg -WyV1XSBsMmRldl9mYy0+Zmxvd2NfZmxhZ3MgWzB4JXhdCgAAAAAAAAAAY2huZXRfbDJ0X3VwZGF0 -ZTogbDJkZXZfZmMtPmZsb3djX2lkIFsldV0gYWxyZWFkeSBzY2hlZHVsZWQKAAAAAGNobmV0X2wy -dF91cGRhdGU6IGluIGRlbGF5ZWRfcHJvY2Vzc2luZywgbDJ0ZW50IFslMDh4XQoAAAAAAAAAAABj -aG5ldF9sMnRfdXBkYXRlOiBsMnRfdXBkYXRlIHJlcXVlc3Qgc2VudCBsMnRlbnQgWyUwOHhdLCBs -MnRlbnQtPmlkeCBbJWRdLCBsMnRlbnQtPnZsYW4gWyVkXQoAAABuZXRpZl9wcm9jZXNzX2RoY3A6 -IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIHByb2Nlc3NpbmcsIG9wdF9sZW4gJXUKAAAAAAAA -AAAAAGNobmV0X2RoY3BfcmVjdjogdmxhbmlkIFsldV0sIGwyZGV2X3BpZF9mYy0+Zmxvd2NfbmV0 -X2wyZGV2X3ZsYW5kZXYgWzB4JXhdLCBsMmRldl9mYyBbMHgleF0KAAAAAGNobmV0X2RoY3BfcmVj -djogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgZGhjdHh0LT5zdGF0ZSBbJWRdLCBtYWxhY2lv -dXMgZGhjcCByZWN2IGZvciBubyByZXF1ZXN0CgAAAAAAAAAAAAAAAABkaGN0eHQtPnN0YXRlIDog -JWQAAAAAAAAAAAAAAAAAAGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIEJhZCBESENQIGNvb2tp -ZSByZWNpZXZlZCwgYWJvcnRpbmcKAABOX1BPUlQgMHgleCV4JXggcmVqZWN0ZWQgUExPR0kgd2l0 -aCByZWFzb24gY29kZSAleAoAAAAAAAAAAAAAAAAAQUJUUyB3aGlsZSBhd2FpdGluZyBQUkxJIFJz -cDogZmxvd2NfaWQgMHgleCBveF9pZCAweCV4IHJ4X2lkIDB4JXggCgAAAAAAAAAAAAAAAABBQlRT -IGZha2UgUnNwOiBsb2MgMHgleCBveF9pZCAweCV4IHJ4X2lkIDB4JXgKAABjYW5ub3QgYWxsb2Nh -dGUgUE9GQ09FIGZpbHRlciBjb25uZWN0aW9uIGZvciB4X2lkICV4IAoAAAAAAAAAAAAAYWN0X29w -ZW5fcnBsOiBhdGlkIFsweCV4XSwgdGlkIFsweCV4XSwgb3AgWzB4JXhdLCBzdGF0dXMgWzB4JXhd -CgAAAAAAAAAAAAAAAAAAAABhY3Rfb3Blbl9ycGw6IGNza19mYy0+dGNiX3N0YXRlIFsweCV4XSwg -Y3NrX2ZjLT5mbGFncyBbMHgleF0sIHRjYl9mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdCgAAAAAAAABz -ZW5kX2Fib3J0X3JwbDogY3NrX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19p -ZCBbMHgleF0sIGNza19mYy0+Zmxvd2NfY3NvY2tfdGlkIFsweCV4XSwgdWxwdHhjaCBbJXVdLCBi -dWZmZXJlZCBbJXVdCgAAAAAAAAAAAAAAAAAAAAB3cmhfb2ZsZF90Y3BfY2xvc2VfY29uX3JlcGx5 -OiB0Y2JfZmMtPmZsb3djX2lkIFsweCV4XSwgdGNiX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgbGVu -MTYgWyV1XSwgbG9jIFsldV0KAAAAAAAAAAAAd3JoX29mbGRfdGNwX2Nsb3NlX2Nvbl9yZXBseTog -cnBsLT5vcF9UaWQgWzB4JXhdLCBycGw+c3RhdHVzIFsweCV4XSwgcnBsLT5zbmRfbnh0IFsweCV4 -XSwgcnBsLT5yY3Zfbnh0IFsweCV4XQoAAHRjcF9hYm9ydF9ycGxfcnNzOiB0aWQgWzB4JXhdLCBz -dGF0dXMgWzB4JXhdCgAAAHRjcF9hYm9ydF9yZXFfcnNzOiB0aWQgWzB4JXhdLCBzdGF0dXMgWzB4 -JXhdCgAAAHBrdHNjaGVkX2NsX3JsWyV1OiV1XTogbW9kZSB8IHVuaXQgfCByYXRlIDB4JTA2eCBt -aW4gJXUgbWF4ICV1IHBrdHNpemUgJXUKAAAAAAAAcGFyYW1fZG1hcVsweCV4OjB4JXhdOiBkbWFx -IDB4JXggcmVhZCAldSBwZiAldSByZXQgJWQKAAAAAAAAAAAAAGh3X2JjbTg0ODM0X2xvYWRzZXF1 -ZW5jZTogU3RhcnRlZAoAAAAAAAAAAAAAAAAAAGh3X2JjbTg0ODM0X2xvYWRzZXF1ZW5jZTogVXBs -b2FkIGltYWdlIHRvIFBIWSBvbi1jaGlwIG1lbW9yCgAAAABod19iY204NDgzNF9sb2Fkc2VxdWVu -Y2U6IGRvbmUgbG9hZGluZyBpbWFnZSAoaSA9ICV1KQoAAAAAAAAAAAAARkxBU0ggbm90IHJlYWR5 -OiBpICV1IG52clJlZyAlI3gKAAAAAAAAAAAAAAAAAAAAQVFfRkxBU0hfUmVhZHkgLSBUaW1lb3V0 -ICgxKQoAAABBUV9GTEFTSF9SZWFkeSAtIFRpbWVvdXQgKDIpCgAAAAlBUV9SZXR1cm5Db250cm9s -T2ZGTEFTSAoAAAAAAAAAcGh5OiBmYWlsZWQgdG8gYWxsb2NhdGVkIG1lbW9yeSBmb3IgcGh5IGZ3 -IGZpbGUsIHJldCAlZAoAAAAAAAAAAFBIWSBGVyB2ZXJzaW9uIGluZm9ybWF0aW9uIG5vdCBhdmFp -bGFibGUgZm9yIHRoaXMgdGVjaG5vbG9neQoAAABsZSBjb25maWd1cmF0aW9uOiBuZW50cmllcyAl -dSByb3V0ZSAldSBjbGlwICV1IGZpbHRlciAldSBhY3RpdmUgJXUgc2VydmVyICV1IGhhc2ggJXUK -AAAAAAAAAAAAAABsZSBjb25maWd1cmF0aW9uOiBuZW50cmllcyAldSByb3V0ZSAldSBjbGlwICV1 -IGZpbHRlciAldSBzZXJ2ZXIgJXUgYWN0aXZlICV1IGhhc2ggJXUgbnNlcnZlcnNyYW0gJXUKAAAA -AAAAAAAAAAAAY2ZfcGFyc2U6IGZpbGUgbWVtdHlwZSAweCV4IG1lbWFkZHIgMHgleCBtYXBwZWQg -QCAlcDoKAAAAAAAAAAAAAGNvbmZpZ3VyZWQgd2l0aCBjYXBzIG5ibXxsaW5rIDB4JTA4eCBzd2l0 -Y2h8bmljIDB4JTA4eCB0b2V8cmRtYSAweCUwOHggaXNjc2l8ZmNvZSAweCUwOHgKAAAAAAAAAG5l -dCBWSSBhbGxvY2F0aW9uIGZhaWxlZCBmb3IgZmNfaWQgJXUgd2l0aCBlcnJvciAlZAoAAAAAAAAA -AAAAAABuZXQgVkkgbWFjIGFkZHJlc3MgcHJvZ3JhbW1pbmcgZmFpbGVkIGZvciBmY19pZCAldSB3 -aXRoIGVycm9yICVkCgAAAAAAAAAAAAAAAAAAAG5ldCBWSSByeG1vZGUgcHJvZ3JhbW1pbmcgZmFp -bGVkIGZvciBmY19pZCAldSB3aXRoIGVycm9yICVkCgAAAABuZXQgVkkgcnNzIGluZGlyZWN0aW9u -IHRhYmxlIHByb2dyYW1taW5nIGZvciBmY19pZCAldSBmYWlsZWQgd2l0aCBlcnJvciAlZAoAAAAA -AG5ldCBWSSByc3MgY29uZmlnIGNvbW1hbmQgZmFpbGVkIGZvciBmY19pZCAldSB3aXRoIGVycm9y -ICVkCgAAAABuZXQgVkkgY29tbWFuZCBmYWlsZWQgZm9yIGZjX2lkICV1IHdpdGggZXJyb3IgJWQK -AAAAAAAAAAAAAAAAAAAAbGUgaW5pdGlhbGl6YXRpb246IG5lbnRyaWVzICV1IHJvdXRlICV1IGNs -aXAgJXUgZmlsdGVyICV1IGFjdGl2ZSAldSBzZXJ2ZXIgJXUgaGFzaCAldQoAAAAAAAAAAAAAbGUg -aW5pdGlhbGl6YXRpb246IG5lbnRyaWVzICV1IHJvdXRlICV1IGNsaXAgJXUgZmlsdGVyICV1IHNl -cnZlciAldSBhY3RpdmUgJXUgaGFzaCAldSBuc2VydmVyc3JhbSAldQoAAAAAAAAAAAAAAHRwIG1l -bSBkaXN0cmlidXRpb25bJSVdIHBtdHggJXUgcG1yeCAldSBkZHAgJXUgZGRwX2lzY3NpICV1IHN0 -YWcgJXUgcGJsICV1IHJxICV1IHJxdWRwICV1CgAAAAAAAFRQX1BNTV9SWF9QQUdFX1NJWkUgJXUg -aXMgbm90IHN1cHBvcnRlZAoAAAAAAAAAAFRQX1BNTV9UWF9QQUdFX1NJWkUgJXUgaXMgbm90IHN1 -cHBvcnRlZAoAAAAAAAAAAHBwbWF4IFsldV0sIGJpdHMgWyV1XSwgRldfSVNDU0lfUEFHRVBPRF9U -QUdfSURYX01BWF9TSVpFIFsldV0KAABkZWZhdWx0IHRhZ21hc2sgWzB4JTB4XQoAAAAAAAAAAHBy -b2dyYW1tZWQgdGFnbWFzayBbMHglMHhdCgAAAAAAY3hjbmljLT5kZHBfaW5mby5sbGltaXQgWzB4 -JTB4XSwgY3hjbmljLT5kZHBfaW5mby51bGltaXQgWzB4JTB4XSwgY3hjbmljLT5kZHBfaW5mby5z -aXplIFsweCUweF0KAAAAAAAAAAAAAAAAAAAAAGN4Y25pYy0+ZGRwX2luZm8ubWF4X3R4c3ogWzB4 -JTB4XSBjeGNuaWMtPmRkcF9pbmZvLm1heF9yeHN6IFsweCUweF0gaW9zaXplIFsweCUweF0KAAAA -AAAAAAAAAAAAAHBwbWF4IFsldV0sIGlkeF9iaXRzIFsldV0sIGlkeF9tYXNrIFsweCUweF0sIHJl -c3ZkX3RhZ19tYXNrIFsweCUweF0sIHRhZ21hc2sgWzB4JTB4XQoAAAAAAAAAAAAAAHRhZyBpdHQg -MHglMHgsIGJpdHMgJXUsIGFnZSAweCUweCwgYml0cyAldQoAAAAAAGN4Y25pYy0+aXNjc2lfcHBt -IFsweCUweF0KAAAAAAAAc2NzaV9wbGRfc2l6ZSBbJXVdLCBBTElHTihzY3NpX3BsZF9zaXplLCAx -NikgWyV1XQoAAAAAAAAAAAAAAAAAAG1heF9wcG9kX3pvbmVzIFsldV0KAAAAAAAAAAAAAAAAbDJk -ZXZfZmMtPmZsb3djX2lkIFsldV0sIGwyZGMtPnBmbiBbJXVdLCBsMmRjLT52Zm4gWyV1XSwgbDJk -Yy0+bHBvcnQgWyV1XSwgbDJkZXZfZmMtPmZsb3dpZCBbJXVdIGwyZGMtPnR4X2NoIFsldV0sIGRl -di52cGQucG9ydHZlYyBbJXhdCgAAAAAAAAAAcG9ydHZlYyBbJXVdCgAAAGN4Y25pY19kZXZpY2Vf -aW5pdDogY3hjbmljX2RldmljZV9pbml0X2RvbmUgWyV1XSwgZGV2LnJlcy5mb2lzY3NpX250YXNr -cyBbJXVdLCBkZXYucmVzLmZvaXNjc2lfbnNlc3MgWyV1XSwgZGV2LnJlcy5uY3NvY2sgWyV1XSwg -ZGV2LnJlcy5mb2lzY3NpX25pbml0IFsldV0KAAAAAABhcnBfdGFibGVfc2l6ZSBbJXVdLCBhcnBf -dGJsX2JtX3NpemUgWyV1XSwgbnN0YWNrX25sMnRfYm1fc2l6ZSBbJXVdLCBvZmxkX3Nwb3J0X2Jt -X3NpemUgWyV1XQoAAABpc2NzaV9uc2Vzc19ibV9zaXplIFsldV0sIGNzb2NrX2JtX3NpemUgWyV1 -XSwgaXNjc2lfc2NzaV9udGFza3NfYm1fc2l6ZSBbJXVdCgAAAGN4Y25pY19kZXZpY2VfaW5pdDog -Y3hjbmljIFsweCUweF0sIGN4Y25pYy0+ZmlsdGVyIFslMHhdLCBjeGNuaWMtPm9mbGRfdGNwX3Nw -b3J0X2JtIFsleF0gc2l6ZW9mKHN0cnVjdCBmbG93YykgWyV1XSwgdG90YWxfaXNjc2lfYm1fc2l6 -ZSBbJXVdLCB0b3RhbF9tZW1fc2l6ZSBbJXVdCgAAAAAAAAAAAAAAAAAAY3hjbmljX2RldmljZV9p -bml0OiBkZXYudHAubnVtX3R4X3BhZ2VzIFsldV0sIGRldi5tYy5zaXplIFsldV0sIGRldi50cC50 -eF9wYWdlX3N6IFsldV0gbnN0YWNrX25sMnQgWyV1XSwgZm9pc2NzaV9udGNiIFsldV0sIHJjIFsl -dV0KAAAAAAAAAAAAAAAAUG9ydFsldV06IFVua25vd24gU0dNSUkgc3ViLXR5cGUgJSN4CgAAAAAA -AAAAAAAAUG9ydFsldV06IFVua25vd24gQlRfWEZJIHN1Yi10eXBlICUjeAoAAAAAAAAAAAAAUG9y -dFsldV06IFVua25vd24gQlRfWEFVSSBzdWItdHlwZSAlI3gKAAAAAAAAAAAAcG9ydF9pbml0WyV1 -XTogcG9ydCB0eXBlIDB4JXggaXMgbm90IHN1cHBvcnRlZAoARVEgcGZuICV1IHZmbiAldTogZGVz -dHJveWluZyBlcWlkICV1IHdpdGggcGVuZGluZyBXUihzKSAobnVtX2J5dGVzICV1IGFuZCBmbGFn -cyAweCUwOHgKAAAAAAAAAAAAbmV0X2wyZGV2X2ZyZWU6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgl -eF0sIHBvcyBbJXVdCgAAAAAAAAAAAAAAAEFoIGhhLi4uZG91YmxlIGZyZWUgb3hfaWQgMHgleCwg -cnhfaWQgMHgleAoAAAAAAEhvc3QgUFJMSSBSZXNwb25zZSB0aW1lZG91dDogb3hfaWQgMHgleCBy -eF9pZCAweCV4CgAAAAAAAAAAAAAAAABsMmRldl9mYy0+Zmxvd2NfaWQgWyV1XSwgbDJkZXZfZmMt -PmZsb3djX25ldF9sMmRldl9wZm4gWyV1XSwgbDJkZXZfZmMtPmZsb3djX25ldF9sMmRldl92Zm4g -WyV1XSwgbmV0X2wyZGMtPmxwb3J0IFsldV0KAAAAAAAAAAAAAHBmbiAldSB2Zm4gJXUgdmlhIGNv -bW1hbmQKAAAAAAAAaHdfbGVfY2xpcF9oYW5kbGVyOiByZW1vdmVkIHBvcz0ldSAoPWlkeCAldSkK -AAAAaHdfbGVfY2xpcF9oYW5kbGVyOiBhZGRpbmcgdG8gcG9zPSV1ICg9aWR4ICV1KQoAcGZuICV1 -IHZmbiAldQoAAGh3IHBmIGJpdG1hcCAweCUwMnggdmZpZCBiaXRtYXAgMHglMDh4OjB4JTA4eDow -eCUwOHg6MHglMDh4CgAAAABhZnRlciB2ZmlkIGZpeHVwLCB2ZmlkIGJpdG1hcCAweCUwOHg6MHgl -MDh4OjB4JTA4eDoweCUwOHgKAAAAAAAAd29ya2Fyb3VuZDEzNzIzOiBkZXRlY3RlZCBXUiBAIDB4 -JTA4eCBvZiBzaXplICV1IGJ5dGVzLCBkcmliYmxpbmcgaXQgaW4gJXUgYnl0ZXMgYXQgYSB0aW1l -CgAAAAAAdGltZXIgcXVldWUgJXUgbG9zdCBhIHRpY2shIG5leHQgJXAgbGFzdCAlcCBudW1lICV1 -CgAAAAAAAAAAAAAAAGZscl90aW1lcl9zdGFydDogZmxvd2NfaWQgJXUgJXAgYnVmICVwCgAAAAAA -AAAAAHNldHRpbmcvdW5zZXR0aW5nIGhzcyByZXN5bmMgYml0CgAAAAAAAAAAAAAAAAAAAE1DIGlu -aXRpYWxpemF0aW9uIG5vdCBjb21wbGV0aW5nLCBNQyBjdXJyZW50IGluaXQgc3RhdGUgaXMgMHgl -MDJ4CgAAAAAAAAAAAAAAAAAAcGNpZTogbnBmICV1IChwZmJpdG1hcCAweCUwMngpIG52ZiAldSAo -cGYgMC4uMyAweCUwMnggMHglMDJ4IDB4JTAyeCAweCUwMngpCgAAAABmYWlsZWQgdG8gZmluZCB0 -aGUgJWMlYyBWUEQgcGFyYW1ldGVyCgAAAAAAAAAAAABmYWlsZWQgdG8gcGFyc2UgdGhlICVjJWMg -VlBEIHBhcmFtZXRlcgoAAAAAAAAAAABmYWlsZWQgdG8gc3VjY2Vzc2Z1bGx5IGZpbmQgQ2hlbHNp -byBWUEQKAAAAAAAAAABsb2cgaW5pdGlhbGl6ZWQgQCAweCUwOHggc2l6ZSAldSAoJXUgZW50cmll -cykKAABzZW5kX2Nsb3NlX3JlcTogY3NrX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3NrX2ZjLT5m -bG93Y19pZCBbMHgleF0sIGNza19mYy0+dGNiX3N0YXRlIFsweCV4XQoAAABzZW5kX2Nsb3NlX3Jl -cTogY3NrX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNz -a19mYy0+Zmxvd2NfY3NvY2tfdGlkIFsweCV4XSwgdWxwdHhjaCBbJXVdLGJ1ZmZlcmVkIFsldV0K -AG9mbGRfdGNwX2RvX2FjdGl2ZV9jbG9zZTogY3NrX2ZjIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19p -ZCBbMHgleF0sIGNza19mYy0+dGNiX3N0YXRlIFsweCV4XQoAAAAAAG9mbGRfdGNwX2RvX2FjdGl2 -ZV9jbG9zZTogY3NrX2ZjIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+ -dGNiX3N0YXRlIFsweCV4XQoAAAAAAHRjcF9zZW5kX2FvcGVuX3JlcTogY3NrX2ZjLT5mbG93Y19p -ZCBbMHgleF0sIGNza19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBidWZmZXJlZCBbJXVdLCByZXNf -Y250IFsweCV4XSwgc2NoZWRfbm9kZS5uZXh0IFsweCV4XQoAb2ZsZF90Y3Bfc2VuZF9hb3Blbl9y -ZXE6IGNwbF9yZXEtPkZpbHRlciBbMHglMHhdCgAAAAAAAAAAAAAAAAAAAGNzb2NrX2FsbG9jOiB0 -eF9jaCBbMHgleF0sIGxwb3J0IFsweCV4XSwgc21hY19pZHggWyV1XSwgbXNzX2lkeCBbJXVdIGNv -b2tpZSBbJTA4eF0KAAAAAAAAAAAAAAAAAGNzb2NrX2FsbG9jOiBhdmFpbGFibGUgWyV1XSwgbmNz -b2NrIFsldV0sIHBvczphdGlkIFsweCV4XSwgY3NrX2ZjIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19p -ZCBbMHgleF0sIHNwb3J0IFsldV0KAABlbmNvZGVfbnVtYmVyOiBhbGVuIFsldV0KAAAAAAAAAGNo -YXBfY2FsY19kaWdlc3RfbWQ1IC0xCgAAAAAAAAAAY2hhcF9jYWxjX2RpZ2VzdF9tZDUgLTIKAAAA -AAAAAABjaGFwX2NhbGNfZGlnZXN0X21kNSAtMwoAAAAAAAAAAGNoYXBfY2FsY19kaWdlc3RfbWQ1 -IC00CgAAAAAAAAAAY2hhcF9jYWxjX2RpZ2VzdF9tZDUgLTUKAAAAAAAAAABjaGFwX2NhbGNfZGln -ZXN0X21kNSAtNgoAAAAAAAAAAGZvaXNjc2lfcGVlcl9pbml0OiBjb25uX2F0dHItPmhkaWdlc3Rf -dG9fZGRwX3Bnc3ogWzB4JXhdCgAAAAAAAABmb2lzY3NpX3BlZXJfaW5pdDogY29ubl9mYy0+Zmxv -d2NfZm9pc2NzaV9jb25uX2ZsYWdzIFsweCV4XQoAAAAAb2ZsZF90Y3BfZGlzY29ubmVjdDogdGNi -X2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2stPnRjYl9z -dGF0ZSBbMHgleF0KAAAAeG1pdF9zZW5kdGFyZ2V0czogcGFyYW0tPnR0dCBbMHgleF0sIGRhdGFf -bGVuIFsldV0sIHBhZF9sZW4gWyV1XQoAAAAAAAAAAAAAAAAAAABsb2dnZWRfaW46IGZsb3djX2Zv -aXNjc2lfY29ubl9mbGFncyBbMHgleF0KAAAAAABmb2lzY3NpX3ZhbGlkYXRlX2xvZ2luX3N0YWdl -OiAtIDEKAAAAAAAAAAAAAAAAAAB0YXNrX2ZyZWU6IHRyeWluZyB0byBmcmVlIHF1ZXVlZCB0YXNr -IFsweCV4XSEhIQoAAAAAAAAAAAAAAAAAAAAASW52YWxpZCBvcGNvZGUgMHgleCBpbiBkYXRhIHBh -dGgKAAAAAAAAAAAAAAAAAAAAbmV0X2wyZGV2X2ZpbmRfYnlfYWRkcjogbDJkZXZfZmMtPmZsb3dj -X2lkIFsweCV4XSwgbDJkYy0+bHBvcnQgWyV1XSwgbDJkX2ZjLT5mbG93Y19pZCBbMHgleF0sIGwy -ZGMtPmluNF9kZXYuaW5fYWRkci5hZGRyIFsweCV4XSwgYWRkciBbMHgleF0KAAAAbmV0X2wyZGV2 -X210dV9jb25maWc6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIG10dSAldQoAAAAAAAAAAGZv -aXNjc2kgY29ubl9mYyBbMHgleF0sIGZsb3djX3NjaGVkY2wgWzB4JXhdLCBpbmdfY2ggWzB4JXhd -LCBlZ3JfY2ggWzB4JXhdCgAAAAAAbDJkZXZfbm90aWZ5IHdpdGggdW5rbm93biBmbGFnIFsweCV4 -XQoAAAAAAAAAAAAAY2huZXRfdmlfZW5hYmxlOiB2aWlkIFslZF0sIHZpX2ZjLT5mbG93Y192aV9m -bGFncyBbMHgleF0KAAAAAAAAAGh3IHJlZ2lzdGVyIG9wZXJhdGlvbiBub3QgY29tcGxldGluZywg -cmVnIDB4JTA4eCBtYXNrIDB4JTA4eCB2YWx1ZSAweCUwOHgKAAAAAAAATURJTyBDTDQ1OiBmYWls -ZWQgdG8gc2V0IHVwIE1NRCBhZGRyCgAAAAAAAAAAAAAATURJTzogZmFpbGVkIHRvIHJlYWQKAAAA -AAAAAAAAAABNRElPIENMNDU6IGZhaWxlZCB0byBzZXQgdXAgTU1EIGFkZHIKAAAAAAAAAAAAAABN -RElPOiBmYWlsZWQgdG8gd3JpdGUKAAAAAAAAAAAAAHBbJXVdIGNoYW5naW5nIHNwZWVkIGZyb20g -JSN4IHRvICUjeAoAAAAAAAAAAAAAAHBbJXVdIGNhbGlicmF0aW5nIFBIWSBTRVJERVMgZm9yIG5l -dyBzcGVlZAoAAAAAAGh3X3hnbV9sZWRfbGlua191cCBsZWQwIGNvbmZpZzogJXUKAAAAAAAAAAAA -AAAAAGh3X3hnbV9sZWRfbGlua191cCBsZWQxIGNvbmZpZzogJXUKAAAAAAAAAAAAAAAAAGhzc19z -aWdkZXRbJXVdOiBoc3Nfc2lnZGV0IGNoYW5nZWQgdG8gMHgleAoAAAAAAGNyX21vZHVsZV9yeF9s -b3NbJXVdOiByeF9sb3MgY2hhbmdlZCB0byAldQoAAAAAAFdBVENIRE9HOiBObyB0ZW1wZXJhdHVy -ZSBzZW5zb3IgYXZhaWxhYmxlLgoAAAAAAFdBVENIRE9HOiBBY3RpdmF0aW5nCgAAAAAAAAAAAAAA -V0FUQ0hET0cgLSBFbmFibGUgYWN0aW9uICV1IHRpbWUgJXUKAAAAAAAAAAAAAAAAV0FUQ0hET0cg -LSBEaXNhYmxlIGFjdGlvbiAldQoAAABXQVRDSERPRzogRGUtYWN0aXZhdGluZwoAAAAAAAAAAEZD -b0UgRkNCIGxpbmtkb3duOiBpb19yZXEgMHgleCV4IGlxaWQgMHgleCBmbG93aWQgMHgleCBvcCAw -eCV4CgBmY29lIG5vdGlmeSA6IFVwZGF0ZSBuZXcgRENCWCB2YWx1ZXMgVkkgc3RhdGUgMHgleCBw -cmkgMHgleCBzY2hlZGNsIDB4JXggZGNieF9kb25lIDB4JXgKAAAAAAAAAABmY29lIG5vdGlmeSA6 -IEZDRiBmbG93aWQgMHgleCwgdWxwY2ggMHgleCAKAAAAAABmY29lIG5vdGlmeSA6IERDQlggOiBw -b3J0IDB4JXgsIHByaW9yaXR5IDB4JXggdWxwdHhjaCAweCV4IGNsYXNzIDB4JXgKAAAAAAAAAAAA -AGNoX2NsX3JhdGVbJXUvJXVdOiBjYXBwZWQgZGVmaWNpdF9pbmNyIGZyb20gcmVxdWlyZWQgJXUg -dG8gJXU7IHJhdGUgJXUgKGVmZiAldSkgZGVmaWNpdF9tYXggJXUKAEZDb0UgRkNGIHRpbWVyOiBm -bG93YyBzdGF0ZSAweCV4LCBwb3J0IDB4JXggLGZjZiAweCV4LCBmbG93Y19pZCAweCV4CgAAAAAA -AAAAAAAAY29yZV9wcm9ncmFtX3RjYjogdGlkICUjeCB0X3N0YXRlICUjeCByY3ZfYWR2IDB4JTA4 -eCByY3Zfc2NhbGUgJSN4IHR4X21heCAlI3ggcmN2X254dCAlI3ggYXRpZCAlI3gKAAAAAAAAAAAA -AAAAAAlvcHQwICUjeCV4IG9wdDIgJSN4IGlwdjYgJSN4IGZsYWdzX3RpbWVyIDB4JTA4eAoAAAAA -AAAAAAAAAAAAAABvZmxkX2Nvbm5lY3Rpb25fd3I6IGNvbm5lY3Rpb24gd2l0aCA1LXR1cGxlIGxw -IDB4JTA0eCBmcCAweCUwNHggbGlwIDB4JTA4eCUwOHggcGlwIDB4JTA4eCUwOHggZmlsdGVyIDB4 -JTA4eCBleGlzdHMgQCBMRSBpbmRleCAldQoAAAAAAAAAAAAAAAAAAABvZmxkX2Nvbm5lY3Rpb25f -d3I6IGNvbm5lY3Rpb24gd2l0aCA1LXR1cGxlIGxwIDB4JTA0eCBmcCAweCUwNHggbGlwIDB4JTA4 -eCBwaXAgMHglMDh4IGZpbHRlciAweCUwOHggZXhpc3RzIEAgTEUgaW5kZXggJXUKAAAAAAAAAG9m -bGRfY29ubmVjdGlvbl93cjogY29ubmVjdGlvbiB3aXRoIDUtdHVwbGUgbHAgMHglMDR4IGZwIDB4 -JTA0eCBsaXAgMHglMDh4JTA4eCBwaXAgMHglMDh4JTA4eCBmaWx0ZXIgMHglMDh4CgAAAABvZmxk -X2Nvbm5lY3Rpb25fd3I6IGNvbm5lY3Rpb24gd2l0aCA1LXR1cGxlIGxwIDB4JTA0eCBmcCAweCUw -NHggbGlwIDB4JTA4eCBwaXAgMHglMDh4IGZpbHRlciAweCUwOHgKAAAAAAAAAAAAAAAASVFGTElO -VCBwZm4gJXUgdmZuICV1OiBpcWVzaXplICV1IHRvbyBzbWFsbAoAAAAASVFGTElOVCBwZm4gJXUg -dmZuICV1OiBpcWlkICV1IHRvbyBsYXJnZSAobWF4ICV1KQoAAAAAAAAAAAAAAAAAAElRRkxJTlQg -cGZuICV1IHZmbiAldTogaXFpZCAldSBub3QgYWxsb2NhdGVkCgAAAElRRkxJTlQgcGZuICV1IHZm -biAldTogZmwwaWQgJXUgdG9vIGxhcmdlIChtYXggJXUpCgAAAAAAAAAAAAAAAABJUUZMSU5UIHBm -biAldSB2Zm4gJXU6IGZsMGlkICV1IG5vdCBhbGxvY2F0ZWQKAABJUUZMSU5UIHBmbiAldSB2Zm4g -JXU6IGZsMWlkICV1IHRvbyBsYXJnZSAobWF4ICV1KQoAAAAAAAAAAAAAAAAASVFGTElOVCBwZm4g -JXUgdmZuICV1OiBmbDFpZCAldSBub3QgYWxsb2NhdGVkCgAASVFGTElOVCBwZm4gJXUgdmZuICV1 -OiBmbDFpZCAldSBpcyB2YWxpZCBidXQgbm90IGZsMGlkICV1CgAAAAAAAElRRkxJTlQgcGZuICV1 -IHZmbiAldTogZmwxaWQgJXUgaXMgdmFsaWQgYnV0IGhlYWRlciBzcGxpdCBmZWF0dXJlIGlzIG5v -dCBlbmFibGVkCgAAAAAAAAAAAAAAAAAAAElRIHBmbiAldSB2Zm4gJXU6IGlxaWQgJXUgdG9vIGxh -cmdlIChtYXggJXUpCgAAAElRIHBmbiAldSB2Zm4gJXU6IGlxaWQgJXUgbm90IGFsbG9jYXRlZAoA -AAAAAAAAAElRIHBmbiAldSB2Zm4gJXU6IGZsMGlkICV1IGZsMWlkICV1IGJ1dCBub3Qgc3VwcG9y -dGVkCgAAAAAAAAAAAABFUSBwZm4gJXUgdmZuICV1OiBjcmVhdGluZyBFVEggZXFpZCAldSB3aXRo -IHBlbmRpbmcgV1IocykgKG51bV9ieXRlcyAldSBhbmQgZmxhZ3MgMHglMDh4CgAAAAAAAABFUSBw -Zm4gJXUgdmZuICV1OiBjcmVhdGluZyBDVFJMIGVxaWQgJXUgd2l0aCBwZW5kaW5nIFdSKHMpIChu -dW1fYnl0ZXMgJXUgYW5kIGZsYWdzIDB4JTA4eAoAAAAAAABFUSBwZm4gJXUgdmZuICV1OiBlcWlk -ICV1IHRvbyBsYXJnZSAobWF4ICV1KQoAAABFUSBwZm4gJXUgdmZuICV1OiBlcWlkICV1IG5vdCBh -bGxvY2F0ZWQKAAAAAAAAAABod19jaW1fdHBfd29ya2Fyb3VuZDEzNzIzX2VuYWJsZTogcG9ydCAl -dSBwcm90b2NvbCAweCV4IGVuICV1IGN1cnJlbnQgMHgleCB3b3JrYXJvdW5kX3ByMTM3MjMgMHgl -eAoAAAAAAAAAAAAAAAAAcG9ydF9ibGlua19sZWRfcmVzdG9yZQoAAAAAAAAAAABwb3J0X2JsaW5r -OiBibGlua2R1cj0weCV4IGJsaW5rX3JlZmNudAoAAAAAAAAAAABwb3J0X2JsaW5rOiAJYmxpbmtf -cmVmY250PTB4JXgKAHBvcnRfYmxpbms6IAlibGlua19yZWZjbnQ9MHgleAoAbWlpX2Fkdl9zcGVl -ZFsldV06IHJjYXBzIDB4JXgKAABtaWlfaW5pdFsldV06IGFjYXBzIDB4JXgKAAAAAAAAAG1paV9w -ZG93blsldV06IHBvd2VyZG93biBlbiAldQoAcG9ydFsldV06IGdhdmUgdXAgZml4aW5nIGVycm9y -cyEhIQoAAAAAAAAAAAAAAAAAcG9ydFsldToweCUwMng6MHglMDJ4XTogbDFjZmcsIHBjYXBzIDB4 -JXggYWNhcHMgMHgleCByY2FwcyAweCV4CgAAAAAAAAAAAAAAAAAAAABwb3J0WyV1OjB4JTAyeDow -eCUwMnhdOiBsMWNmZywgaW52YWxpZCByZXF1ZXN0LCBwY2FwcyAweCV4IGFjYXBzIDB4JXggcmNh -cHMgMHgleAoAAAAAAAAAAAAAAAAAAABwb3J0WyV1OjB4JTAyeDoweCUwMnhdOiBsMWNmZywgbWRp -IG4vYSBwY2FwcyAweCV4IGFjYXBzIDB4JXggcmNhcHMgMHgleAoAAAAAAAAAAHBvcnRbJXU6MHgl -MDJ4OjB4JTAyeF06IGwxY2ZnLCBjYW5ub3QgZm9yY2UgbXVsdGlwbGUgc3BlZWRzLCBwY2FwcyAw -eCV4IGFjYXBzIDB4JXggcmNhcHMgMHgleAoAAGNoX3JhdGVbJXVdOiBjYXBwZWQgdGljayBmcm9t -IHJlcXVpcmVkICV1IHRvIHN1cHBvcnRlZCAldTsgcmF0ZSAldSAoZWZmICV1KSBkZWZpY2l0X2lu -Y3IgJXUgdGljayAldQoAAAAAAAAAAAAAAABod19pMmNfdyBwb3J0ICV1IGRldiAleCByZWcgJXUg -ZGF0YSAweCV4CgAAAAAAAABnZXRfcmVmX3Rhc2s6IHJlcXVlc3RlZCBjb29raWU6IGhpZ2ggWzB4 -JTA4eF0sIGxvdyBbMHglMDh4XQoAAAAAZ2V0X3JlZl90YXNrOiB0YXNrIGNvb2tpZTogaGlnaCBb -MHglMDh4XSwgbG93IFsweCUwOHhdCgAAAAAAAAAAAGdldF9yZWZfdGFzazogaXN0YXNrLT5mbG93 -Y19pZCBbMHgleF0sIGlzdGFza19mYy0+Zmxvd2Nfc3RhdGUgWyV1XQoAAAAAAAAAAAAAAAAAZ2V0 -X3JlZl90YXNrOiB0YXNrIG5vdCBmb3IgY29va2llICVseAoAAAAAAAAAAAAAbmV0aWZfcHJvY2Vz -c19kaGNwX29wdHM6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIE1TR19UWVBFIFslZF0sIGRo -Y3R4dC0+c3RhdGUgWyVkXQoAAAAAAAAAAAAAaWNtcF9yZWN2OiBsMmRldl9mYy0+Zmxvd2NfaWQg -WzB4JXhdLCBwaWQgWzB4JXhdLCBpY21wIHR5cGUgWzB4JXhdCgAAAAAAAAAAAAAAAABBQlRTIEFD -QyBhd2FpdGluZyBQUkxJIFJzcDogZmxvd2NfaWQgMHgleCBveF9pZCAweCV4IHJ4X2lkIDB4JXgg -aXFpZCAweCV4CgAAAAAAAGNobmV0X2FycF9yZWN2OiBwaWQgWyV1XSwgcGt0LT5haGRyLnNpcCBb -MHgleF0sIHBrdC0+YWhkci5yaXAgWzB4JXhdLCBwa3QtPmFoZHIub3Bjb2QgWzB4JXhdCgAAAGNo -bmV0X2FycF9yZWN2OiB2bGFuIGV4dHJhY3RlZCwgdmxhbmlkIFsldV0sIGwyZGV2X2ZjLT5mbG93 -Y19uZXRfbDJkZXZfdmxhbmRldiBbMHgleF0sIGwyZGV2X2ZjIFsweCV4XQoAAAAAAAAAAABjaG5l -dF9hcnBfcmVjdjogaXAgY29uZmxpY3QgZGV0ZWN0ZWQKAAAAAAAAAAAAAABjaG5ldF9hcnBfcmVj -djogdmxhbmlkIFslMHhdLCBwaWQgWyV1XQoAAAAAAAAAAABjaG5ldF9hcnBfcmVjdjogbDJkZXZf -ZmMgWyV4XSwgcGt0LT5haGRyLnJpcCBbMHgleF0sIHBrdC0+YWhkci5zaXAgWzB4JXhdCgAAAAAA -AGNzb2NrX3BlZXJfY2xvc2U6IGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2tfZmMtPnRjYl9m -Yy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2tfZmMtPmZsb3djX3N0YXRlIFsweCV4XSwgY3NrX2ZjLT5m -bG93Y19jc29ja190Y2JfZmMtPmZsb3djX3N0YXRlIFsweCV4XQoAAAAAAAAAAABjc29ja19wZWVy -X2Nsb3NlOiBjc2tfZmMtPmZsb3djX2lkIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19zdGF0ZSAgWzB4 -JXhdCgAAAAAAAAAAAHRjYl9mYy0+Zmxvd2NfaWQgWzB4JTA2eF0sIHRjYl9mYy0+Zmxvd2NfdHlw -ZSBbMHgleF0sIGNwbG9wIFsweCV4XSAKAAAAAAAAAAAAAAAAcGt0c2NoZWRfY2hfcmxbJXVdOiBj -aGFubmVsIHJsIG5vdCBhdmFpbGFibGUgaW4gY29uanVuY3Rpb24gd2l0aCBmbG93IHNoYXBpbmcK -AABwa3RzY2hlZF9jaF9ybFsldV06IHJhdGUgJXUgbWF4ICV1CgAAAAAAAAAAAAAAAABwa3RzY2hl -ZF9jbF93cnJbJXU6JXVdOiB3ZWlnaHQgJXUgd2VpZ2h0ZWRfbWFzayAweCV4CgAAAAAAAAAAAAAA -ZXFfcGFyYW1zWzB4JXg6MHgleF06IGRtYXEgMHgleCByZWFkICV1IHBmICV1IGVxaWRfYXBpICV1 -IHJldCAlZAoAAAAAAAAAAAAAAAAAAABod19iY204NDM0X2NoZWNrcmFtOiBTdGFydAoAAAAAAFBI -WVsldV0gcHJvY2Vzc29yIG5vdCBydW5uaW5nCgAAUEhZWyV1XSBGVyBoYXMgYmFkIENSQwoAAAAA -AAAAAABQSFkgZmlybXdhcmUgbG9hZCBzdWNjZXNzZnVsIQoAAAlBUV9UYWtlQ29udHJvbE9mRkxB -U0g6IDFlLmMwMDE9JSN4IDFlLmM0NTA9JSN4IDFlLmM0NTE9JSN4IDFlLjEwMD0lI3gKAAAAAAAA -AAAAQVFfQVBJX1dyaXRlQW5kVmVyaWZ5Rmxhc2hJbWFnZSAtIEltYWdlIGludGVncml0eSBjaGVj -ayBmYWlsZWQgKGNhbGMgJSN4IHZhbCAlI3gpCgAAAAAAAAAAAAAAAAAAQVFfQVBJX1dyaXRlQW5k -VmVyaWZ5Rmxhc2hJbWFnZSAtIEltYWdlIGludGVncml0eSBjaGVjayBwYXNzZWQKAEFRX0FQSV9X -cml0ZUFuZFZlcmlmeUZsYXNoSW1hZ2UgLSBUaW1lb3V0IHdhaXRpbmcgZm9yIGZsYXNoIGludGVy -ZmFjZSAoJXUpCgAAAAAAQVFfQVBJX1dyaXRlQW5kVmVyaWZ5Rmxhc2hJbWFnZSAtIFRpbWVvdXQg -d2FpdGluZyBmb3IgZmxhc2ggaW50ZXJmYWNlICgldSkKAAAAAABBUV9BUElfV3JpdGVBbmRWZXJp -ZnlGbGFzaEltYWdlIC0gVGltZW91dCB3YWl0aW5nIGZvciBmbGFzaCBpbnRlcmZhY2UgKCV1KQoA -AAAAAEFRX0FQSV9Xcml0ZUFuZFZlcmlmeUZsYXNoSW1hZ2UgLSBUaW1lb3V0IHdhaXRpbmcgZm9y -IGZsYXNoIGludGVyZmFjZSAoJXUpIChwcCAlI3ggYXAgJSN4KQoAAAAAAEFRX0FQSV9Xcml0ZUFu -ZFZlcmlmeUZsYXNoSW1hZ2UgLSBUaW1lb3V0IHdhaXRpbmcgZm9yIGZsYXNoIGludGVyZmFjZSAo -JXUpCgAAAAAAQVFfQVBJX1dyaXRlQW5kVmVyaWZ5Rmxhc2hJbWFnZSAtIFRpbWVvdXQgd2FpdGlu -ZyBmb3IgZmxhc2ggaW50ZXJmYWNlICgldSkKAAAAAABBUV9BUElfV3JpdGVBbmRWZXJpZnlGbGFz -aEltYWdlIC0gRXJyb3Igb24gYnVybmluZyBGTEFTSCAoY3JjMTYgbWlzbWF0Y2gpCgAAAAAAAG1h -bGxvY19kZWNbJXVdOiBzdGFydCAlcCBlbmQgJXAgbmV4dCAlcCBzaXplIDB4JXggYWxpZ21lbnQg -MHgleCBwICVwCgAAAAAAAAAAAAAAbWFsbG9jX2luY1sldV06IHN0YXJ0ICVwIGVuZCAlcCBuZXh0 -ICVwIHNpemUgMHgleCBhbGlnbWVudCAweCV4IHAgJXAKAAAAAAAAAAAAAABsZSBjb25maWd1cmF0 -aW9uOiBoYXNoIG1vZGUgcmVxdWlyZXMgYXQgbGVhc3QgMTYgZW50cmllcywgbmhhc2ggJXUKAAAA -AAAAAAAAAAAAAGxlIGNvbmZpZ3VyYXRpb246IGhhc2ggbW9kZSByZXF1aXJlcyBhdCBlbnRyaWVz -IHRvIGJlIGEgcG93ZXIgb2YgMiwgbmhhc2ggJXUKAAAAbGUgY29uZmlndXJhdGlvbjogcmVxdWVz -dGVkICV1IHRjYW0gZW50cmllcyBidXQgb25seSAldSBhdmFpbGFibGUKAAAAAAAAAAAAAAAAAABs -ZSBjb25maWd1cmF0aW9uOiB0Y2FtIHJlZ2lvbnMgbXVzdCBoYXZlIG11bHRpcGxlIG9mIDMyIGVu -dHJpZXMsIG5yb3V0ZSAldSBuY2xpcCAldSBuZmlsdGVyICV1IG5zZXJ2ZXIgJXUKAAAAAAAAb2Zs -ZCB0cCB0aW1lciBzZXR0aW5ncyBUUF9NU0wgMHglMDh4IFRQX1JYVF9NSU4gMHglMDh4IFRQX1JY -VF9NQVggMHglMDh4IFRQX1BFUlNfTUlOIDB4JTA4eCBUUF9QRVJTX01BWCAweCUwOHgKACAgICAg -ICAgICAgICAgICAgICAgICAgVFBfS0VFUF9JRExFIDB4JTA4eCBUUF9LRUVQX0lOVFZMIDB4JTA4 -eCBUUF9JTklUX1NSVFQuaW5pdF9zcnR0X21heHJ0dCAweCUwNHggVFBfSU5JVF9TUlRULmluaXRf -c3J0dF9pbml0c3J0dCAweCUwNHggVFBfRklOV0FJVDJfVElNRVIgMHglMDh4CgAAAAAAAAAAAAAA -Y29uZmlndXJhdGlvbiBmaWxlIHBhcnNlciBlbmNvdW50ZXJlZCBlcnJvciBAIGxpbmUgJXU6CgAA -AAAAAAAAAEhPU1QgUEFHRV9TSVpFIFsweCUwbHhdIHRvbyBzbWFsbCwgbWluIFsweCUwbHhdIHJl -cXVpcmVkCgAAAAAAAABwYWdlIHNpemUgWyVsdV0gbWlzbWF0Y2gKAAAAAAAAAFBBR0Ugc2l6ZSAl -bHUgdW5zdXBwb3J0ZWQsIGRkcCBkaXNhYmxlZAoAAAAAAAAAAEhvc3QgcGFnZV9zaXplICVsdSwg -ZGRwX2lkeCAldQoARkNvRSBERFAgaW5pdDogZmNvZSBsbGltaXQgMHgleCwgZmNvZSB1bGltaXQg -MHgleCBnYmwgbGxpbWl0IDB4JXggZ2JsIHVsaW1pdCAweCV4CgAAAAAAAAAAAAAAAAAARkNvRSBE -RFAgaW5pdDogZmNvZSBwcG9kIG9mZiAweCV4LCBmY29lIHN0IHBwb2QgYWRkciAweCV4IGZjb2Ug -bnVtIHBwb2RzIDB4JXgKAABmY29lIHhjaGcgbWdyIGluaXQ6IE51bWJlciBvZiBleGNoYW5nZXMg -Zm9yIEZDb0UgaXMgJXgKAAAAAAAAAAAAQ2FsY3VsYXRpb24gb3V0IG9mIGJvdW5kcyBmdXJpbmcg -aW5pdDogJSN4ICUjeCAlI3gKAAAAAAAAAAAAAAAAAHBmbiAldSB2Zm4gJXUgaGFzIHBuZHR4bnMg -JXUgYWZ0ZXIgMTAwbXMKAAAAAAAAAGJhZCBtYWlsYm94IGNtZDogcGZuIDB4JXggdmZuIDB4JXg7 -IG9wY29kZSAweCV4ID4gTEFTVEMyRSAweCV4CgBtYWlsYm94IGNtZCBub3QgeWV0IHN1cHBvcnRl -ZDogcGZuIDB4JXggdmZuIDB4JXg7IG9wY29kZSAweCV4CgAAYmFkIG1haWxib3ggY21kOiBwZm4g -MHgleCB2Zm4gMHgleDsgb3Bjb2RlIDB4JXggaXMgdmFsaWQgcG9zdCBkZXZpY2UgaW5pdCBvbmx5 -CgBiYWQgbWFpbGJveCBjbWQ6IHBmbiAweCV4IHZmbiAweCV4OyBvcGNvZGUgMHglMDJ4IHJhbWFz -ayAweCV4IGNtZCByYW1hc2sgMHgleAoAAGJhZCBtYWlsYm94IGNtZDogcGZuIDB4JXggdmZuIDB4 -JXg7IG9wY29kZSAweCUwMnggbGVuMTYgMHgleCB2ZXJzdXMgZXhwZWN0ZWQgbGVuMTYgMHgleAoA -AAAAAAAAAGluc3VmZmljaWVudCBjYXBzIHRvIHByb2Nlc3MgbWFpbGJveCBjbWQ6IHBmbiAweCV4 -IHZmbiAweCV4OyByX2NhcHMgMHgleCB3eF9jYXBzIDB4JXggcmVxdWlyZWQgcl9jYXBzIDB4JXgg -d19jYXBzIDB4JXgKAAAAAAAAAAAAaW5zdWZmaWNpZW50IGNhcHMgdG8gcHJvY2VzcyBtYWlsYm94 -IGNtZDogcGZuIDB4JXggdmZuIDB4JXg7IHJfY2FwcyAweCV4IHd4X2NhcHMgMHgleCByZXF1aXJl -ZCByX2NhcHMgMHgleCB3X2NhcHMgMHgleAoAAAAAAAAAAABWUEQgcmVnaW9uIGlzIHRvbyBzbWFs -bCAoU0VSQ0ZHX1NSX1BGTlZQRFNJWkUgMHgleCkKAAAAAAAAAAAAAAAAY2Y6IGZhaWxlZCB0byBh -bGxvY2F0ZWQgbWVtb3J5IGZvciBjb25maWd1cmF0aW9uIGZpbGUsIHJldCAlZAoAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIAAAEgAAAAAAAAAIIAAAEAAAAAAAAAAIAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAgAAAAAAAAAAAAAAAAIAAAAAAAAAAAAKAAAAA -AAAAAAAAAgADAAAAAAFgCAAAAAADAAAAAAAAAAAAAAADAAAAAAAAAAAAAAACAAAAAAAAAAAAIAAA -AAAAAAAAAAAAAQADgAAAAAAAAAAAAAACAAAAAAAAAAAAIAOAAAAAAAAAAAAAEAKAAIAAAAAAAAAA -AAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAACAAAAAAAAAAAAAAACgAAAAAAA -AAAAAQADAAAAAAAAAAAAAAKDAAAAAAAAAAAAEAKAAAAAAAAAAAAAMAADAAAAAAAACAAAMAADAAAA -AAAAAAAAMAWDAAAAAAAACAAAMAWDAAAAAAAAAAAAMASDAAAAAAAACAAAMASDAAAAAAAAAAAAMAMD -AAAAAAAACAAAMAMDAAAAAAAAAAAAOAMDAAAAAAAAAAAAOAWDAAAAAAAAAAAAOASDAAAAAAAAAAAA -OAADAAAAAAAAAAAANAaCAAAAAAAAAAAAPAOCAAAAAAAAAAAAPAADAAAAAAAACAAAPAADAAAAAAAA -AAAAPASDAAAAAAAAAAAAPAUDAAAAAAAAAAAAPQQDAAAAAAAAAAAAPAODAAAAAAAAAAAALAACAAAA -AAAAAAAALAWCAAAAAAAAAAAALAUCAAAAAAAAAAAAEAaAAAAAAAAAAAAAEAaCwAAAAAAAAAAAEAaC -gAAAAAAAAAAAAA6CAAAAAAAAAAAAEAeCgAAAACAAAAAAAAeCAAAAACAAAAAAEAcCgAAAAAAAAAAA -EAcCgAAAAAAAAAAAEAcCgAAAAAAAAAAAAAcCAAAAACAAAAAAEBeDAAAAAAAACAAAEBeDAAAAAAAA -CAAAEAAAAAAAAAAAAAAAEAYDgAAAAAAAAAAAAA4DAAAAAAAAAAAAEAYDQAAAAAAAAAAAEAYDAAAA -AAAAAAAAEAYAAAAAAAAAAAAAAAYDgAAAAAAAAAAAAAYDAAAAAAAAAAAAAA4CAAAAAAAAAAAAAA4C -AAAAAAAAAAAAEAYCAAAAAAAAAAAAEAYCAAAAAAAAAAAAEAYCgAAAAAAAAAAAEAYCgAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAABADAAAAAAAACAAAAAAAAAAAAAAA -AAAA//////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -////////////////////////////AAAAIAAAAADAAAAAAAAAIAAAAADgAAAAAAAAAAIAAAAAAAAA -QAAAAAAAAAAAAAAAAAABIQAAAAAAAAAAAAEBIAAAAAAAAAAAAAACAAAABAAEAAAAAAUAAAAEAAAA -AAAAAAAAoAAAAACAAAAAAIAAQAAAAAAAAgAAAIAAIAAAAAAAAgAAAQBAAAAAAAAAAAAAAQBCAAAA -AAAAAAAAAAAgAAAAAAAAAAAAAhAgAAAAAAAAAAAAAgwCAAAAAAAAAAAAAIUCAAAABAAAAAAAAIBC -AAAAAAAAAAAAAgAiAAAAAAAAAAAAAIBBAAAAAAAAAAAAAIBBgAAAAAAAAAAAAgAhAAAAAAAAAAAA -ABAggAAAAAAAAAAAAiUAgAAAAAAAAAAAAAUAAAAAAAAAAAAACIgEgAAAAAAAAAAACIgEgAAAAAAA -AAAACKIAgAAAAAAAAAAACKIAgAAAAAAAAAAACKMAgAAAAAAAAAAACKMAgAAAAAAAAAAACKSAgAAA -AAAAAAAACKSAgAAAAAAAAAAABKSAwAAAAAAAAAAABKIAwAAAAAAAAAAABKMAwAAAAAAAAAAABIgE -wAAAAAAAAAAAAAkBgAAAAAAAAAAAAgwAgAAAAAAAAAAAAIgEwAAAAAAAAAAAAIgEgAAAAAAAAAAA -AgsAgAAAAAAAAAAAAIqAgAAAAAAAAAAAAAuAgAAAAAAAAAAAAIwAgAAAAAAAAAAAAiAQgAAAAAAA -AAAAAgoAgAAAAAAAAAAAAgqAgAAAAAAAAAAAAAkCgAAAAAAAAAAAAAEBAAAAAAAAAAAAAAEBQAAA -AAAAAAAAAAEAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAACBEAAAAAAAAAAAAACB -CAAAAAAAAAAAAACBBAAAAAAAAAAAAACBgAAAAAAAAAAAAIAAwAAAAAAAAAAAAIAAoAAAAAAAAAAA -AAAIAAAAAAAAAAAAAIGAAAAAAAAAAAAAAIGAgAAAAAAAAAAAAImAgAAAAAAAAAAAAImAwAAAAAAA -AAAAAAGCAAAAAAAAAAAAAgGAAAAAAAAAAAAAAgGAgAAAAAAAAAAAAEGBgAAAAAAAAAAAAgGBgAAA -AAAAAAAAAEmBgAAAAAAAAAAAAgmBgAAAAAAAAAAAAgGBAAAAAAAAAAAAAEGBAAAAAAAAAAAAIAAA -AAAAAAAAAAAAEAAAAgAAAAAAAAAAEAAAAAAAAAAAAAAAAIAAwAAAAAAAAAAAAAAAAAAAAAAAAAAA -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAJIAAAAAAAAAA2YAIABA -AAAAAAgAkgAAAAAAAAADcgElBEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAIAAAAAgCIA4cAAFYA -IABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAAAAAAAAAA -A5YAIABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAACAAAAAIAiAOFAACWASAAQAAAAAAAAAAAAAAA -AAAAA5YAIABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAACAAAAAIAiAOFAACWASAAQAAAAAAAAAAA -AAAAAAAAA5YAIABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAACAAAAAIAiAOFAACWASAAQAAAAAAA -AAAAAAAAAAAAA5YAIABAAAAAAAAAAAAAAAAAAgADlgAmBEAAAAAACEcgAQQAAAKyAALSBSAkQAAA -AAAAAAAAAAAAAAAAA5YAIABAAAAAAABHIAEGDKGCsEABkgQgJEAAAAAAAEcgAQQMoEKzgAISBSAk -QAAAAAAIAAAAAgCIA4UAAJYBIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAACAAAAAIAiAOFAACW -ASAAQAAAAAAAAAAAAAAAAAAAA5YAIABAAAAAAA3FEroCsIDTFFSL4kpGJEAAAAAABcUSugK3gNMU -VItiSaYkQAAAAAAFxRKiBrCA0xRUi+JKRiRAAAAAAA3FEqIGt4DTFFSLYkmmJEAAAAAABcUSogaw -gNMUVIviSkYkQAAAAAANxRKiBreA0xRUi2JJpiRAAAAAAAXFEqIGsIDTFFSL4kpGJEAAAAAADcUS -oga3gNMUVItiSaYkQAAAAAAJxBCgAgCAkAAAi2JpxiRAAAAAAAHEEKAGsICTBlSLYmnGJEAAAAAA -AcQQoAawgJMGVItiacYkQAAAAAABxRC4BrCAkxZUi2JIxiRAAAAAAAihEIgCAIFYEgALUgCmJEAA -AAAACcAQkAKwgAMWVIqSAcYkQAAAAAAJwBC4BrCAAxCUi+ICRiRAAAAAAAnAELgCtIADEJSLYgGm -JEAAAAAACcAQuAK0gAMQlItiAaYkQAAAAAAJwBC4ArSAAxCUi2IBpiRAAAAAAAnAELgCtIADEJSL -YgGmJEAAAAAAAaAQkAa0gAMQlItiAaYkQAAAAAABwBCAArCAAxRUilIAxiRAAAAAAAHAEIACsIAD -FFSKUgDGJEAAAAAAAcAQgAKwgAMUVIpSAMYkQAAAAAAIRyABBAAAArIAAtIFICRAAAAAAACBAAAC -AIVYB0ALUgCmJEAAAAAAAIEAAAIAhVgHQAtSAKYkQAAAAAAAAAAABACgQAGAAdYAIABAAAAAAAAA -AAAGAKGAAEABVgAgAEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAIgQAAAgCFWYAEC1IApiRAAAAA -AAlhQAAAAAAYAAADQgEmpEAAAAAACEAAAAAAAAAAAANSASYkQAAAAAAAAAAABACgQAGAAdYAIABA -AAAAAAgAAAACAIgDhwAD1gAmBEAAAAAACAAAAAIAiAOHAAPWACYEQAAAAAAAAAAAAAAAAAAAA5YA -IABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAJwBC4ArSAAxCU -i2IBpiRAAAAAAAAAAAAAAAAAAgADlgAmBEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAIAAAAAgCI -A4UAAJYBIABAAAAAAAAAAAAEAKBAAYAB1gAgAEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAAAAAA -BACgQAGAAdYAIABAAAAAAAihEIgCAIFYEAAJEgGmJEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAA -AAAABgChgABAAVYAIABAAAAAAAgAAAACAIgDhUAI0gJGJEAAAAAACcUSogKUiNIQgIsiSKYkQAAA -AAAJwBCAAqSIAIdUi1IBpiRAAAAAAAnAEIAGtIgDARSLUgGmJEAAAAAADcAAAAKwgMMWVIviA0Yk -QAAAAAAAAAAAAAAAAAAAA5YAIABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAwAAQAAAACAAACACYkQAAAAAAA -RzAABgMgArcACAIBwCRAAAAAAAgDAAACBqAKtQAIAgDGJEAAAAAAAAAAAAAAAAACAAACACYkQAAA -AAAAIFAABAAAAAIAAAIAJiRAAAAAAAhgIACEAAAAAAAABgAgAEAAAAAACGAgAIQAAAACATACACYl -QAAAAAAIYAAABACEAYAEBAIBxiTAAAAAAAHAAAACQ4ADAgyIAgGmJEAAAAAACABgAAQAAAACAAAC -ACYkQAAAAAAIAGAABAAAAAAAAAQBIABAAAAAAAAAAAAAAAAAAAAABAEgAEAAAAAABAgUgAYKAAAH -AUwCIKYmQAAAAAAIgAAABgCEAYAECAIBpiZAAAAAAABAAAACAKAAAkAIAgGmJEAAAAAAAAAAAAAA -AAACAAACACYkQAAAAAAEAAAAAoQAAwKKCAIEpiRAAAAAAAAAAAAAAAAAAgAABgEgSEAAAAAAACBQ -AAQAAAACAAACACYkQAAAAAAIYCAAhAAAAAIAAAYAJgRAAAAAAAhgIACEAAAAAgAAAgEmJUAAAAAA -CGAAAAQAhAGABAQCAcYkwAAAAAAIAGAABAAAAAAAAAQBIABAAAAAAAAAAAAAAAAAAAAAAgAmTHAA -AAAAAAAAAAAAAAAAAAAGASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAItJAE -CRYEAgTGJEAAAAAAAcAAAAi0kAQJFgQCBMYkQAAAAAAECHSATAkAAFAAXAJh5iRAAAAAAAwIdIBE -AAAAUgBAAmEmJEAAAAAACAIQoAQAAAAAAQACACYkQAAAAAAIAhCgBAAAAAABAAIAJiRAAAAAAAQI -dABCAQAABwCIAmDGJEAAAAAADcgUAAIJAAAEQJwCYOYkQAAAAAAJyBCABrSQBAKUiAJlxiRAAAAA -AA3IdABItJADAJSIAmCmJMAAAAAADch0AEi0kAMAlIgCYKYkwAAAAAAIRwAABAAAAAAAAAIBICRA -AAAAAAhHAAAEAAAAAgAAAgUgJEAAAAAAAEcgAQwHIcK3AAgCAcAkQAAAAAAARyABDAchwrcACAIB -wCRAAAAAAABHIAEMByHCtwAIAgHAJEAAAAAAAAAgAQgAhAAFQIgCAcYkwAAAAAAAACABCACEAAVA -iAIBxiTAAAAAAAAAIAEIAIQABUCIAgHGJMAAAAAAAAAgAYaCAAECwIgCA8YkwAAAAAAAACABgoIA -AALAiAIDxiTAAAAAAAnAIAGCpIABBUCIAgHGJMAAAAAACAAAAAwAhAAFQIgCAcYkwAAAAAAAACAB -hoIAAQLAiAIDxiTAAAAAAAAAIAGCggAAAMCIAgKmJMAAAAAACcAgAYKkgAEFQIgCAcYkwAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAEAAQkBAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAW2dsb2JhbF0KcnNzX2dsYl9jb25maWdfbW9kZT1iYXNpY3ZpcnR1YWwKcnNzX2ds -Yl9jb25maWdfb3B0aW9ucz10bmxtYXBlbixoYXNodG9lcGxpdHosdG5sYWxsbGtwCnJlZ1sweDEw -MDhdPTB4NDA4MTAvMHgyMWM3MApyZWdbMHgxMDBjXT0weDIyMjIyMjIyCnJlZ1sweDEwYTBdPTB4 -MDEwNDA4MTAKcmVnWzB4MTA0NF09NDA5NgpyZWdbMHgxMDQ4XT02NTUzNgpyZWdbMHgxMDRjXT0x -NTM2CnJlZ1sweDEwNTBdPTkwMjQKcmVnWzB4MTA1NF09OTIxNgpyZWdbMHgxMDU4XT0yMDQ4CnJl -Z1sweDEwNWNdPTEyOApyZWdbMHgxMDYwXT04MTkyCnJlZ1sweDEwNjRdPTE2Mzg0CnJlZ1sweDEw -YTRdPTB4YTAwMGEwMDAvMHhmMDAwZjAwMApyZWdbMHgxMGE4XT0weDIwMDAvMHgyMDAwCnNnZV90 -aW1lcl92YWx1ZT01LDEwLDIwLDUwLDEwMCwyMDAKcmVnWzB4N2RjMF09MHg2MmY4ODQ5CmZpbHRl -ck1vZGU9ZnJhZ21lbnRhdGlvbixtcHNoaXR0eXBlLHByb3RvY29sLHZsYW4scG9ydCxmY29lCnRw -X3Btcng9MzAKdHBfcG1yeF9wYWdlc2l6ZT02NEsKdHBfcG10eD01MAp0cF9wbXR4X3BhZ2VzaXpl -PTY0SwpbZnVuY3Rpb24iMCJdCm52Zj0xNgp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT0xCm5p -cWZsaW50PTgKbmV0aGN0cmw9OApuZXE9MTYKbmV4YWN0Zj04CmNtYXNrPWFsbApwbWFzaz0weDEK -W2Z1bmN0aW9uIjEiXQpudmY9MTYKd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9MQpuaXFmbGlu -dD04Cm5ldGhjdHJsPTgKbmVxPTE2Cm5leGFjdGY9OApjbWFzaz1hbGwKcG1hc2s9MHgyCltmdW5j -dGlvbiIyIl0KbnZmPTE2Cnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTEKbmlxZmxpbnQ9OApu -ZXRoY3RybD04Cm5lcT0xNgpuZXhhY3RmPTgKY21hc2s9YWxsCnBtYXNrPTB4NApbZnVuY3Rpb24i -MyJdCm52Zj0xNgp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT0xCm5pcWZsaW50PTgKbmV0aGN0 -cmw9OApuZXE9MTYKbmV4YWN0Zj04CmNtYXNrPWFsbApwbWFzaz0weDgKW2Z1bmN0aW9uIjQiXQp3 -eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT0yOApuaXFmbGludD0xNzAKbmV0aGN0cmw9MTAwCm5l -cT0yNTYKbmV4YWN0Zj00MApjbWFzaz1hbGwKcG1hc2s9YWxsCm5ldGhvZmxkPTEwMjQKbnJvdXRl -PTMyCm5jbGlwPTMyCm5maWx0ZXI9NDk2Cm5zZXJ2ZXI9NDk2Cm5oYXNoPTEyMjg4CnByb3RvY29s -PW5pY192bSxvZmxkLHJkZHAscmRtYWMsaXNjc2lfaW5pdGlhdG9yX3BkdSxpc2NzaV90YXJnZXRf -cGR1CnRwX2wydD0zMDcyCnRwX2RkcD0yCnRwX2RkcF9pc2NzaT0yCnRwX3N0YWc9Mgp0cF9wYmw9 -NQp0cF9ycT03CltmdW5jdGlvbiI1Il0Kd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9NApuaXFm -bGludD0zNApuZXRoY3RybD0zMgpuZXE9NjQKbmV4YWN0Zj00CmNtYXNrPWFsbApwbWFzaz1hbGwK -bnNlcnZlcj0xNgpuaGFzaD0yMDQ4CnRwX2wydD0xMDI0CnByb3RvY29sPWlzY3NpX2luaXRpYXRv -cl9mb2ZsZAp0cF9kZHBfaXNjc2k9Mgppc2NzaV9udGFzaz0yMDQ4CmlzY3NpX25zZXNzPTIwNDgK -aXNjc2lfbmNvbm5fcGVyX3Nlc3Npb249MQppc2NzaV9uaW5pdGlhdG9yX2luc3RhbmNlPTY0Cltm -dW5jdGlvbiI2Il0Kd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9NApuaXFmbGludD0zNApuZXRo -Y3RybD0zMgpuZXE9NjYKbmV4YWN0Zj0zMgpjbWFzaz1hbGwKcG1hc2s9YWxsCm5oYXNoPTIwNDgK -cHJvdG9jb2w9ZmNvZV9pbml0aWF0b3IKdHBfZGRwPTIKZmNvZV9uZmNmPTE2CmZjb2VfbnZucD0z -MgpmY29lX25zc249MTAyNApbZnVuY3Rpb24iMTAyMyJdCnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwK -bnZpPTQKY21hc2s9YWxsCnBtYXNrPWFsbApuZXhhY3RmPTgKbmZpbHRlcj0xNgpbZnVuY3Rpb24i -MC8qIl0Kd3hfY2Fwcz0weDgyCnJfY2Fwcz0weDg2Cm52aT0xCm5pcWZsaW50PTQKbmV0aGN0cmw9 -MgpuZXE9NApuZXhhY3RmPTQKY21hc2s9YWxsCnBtYXNrPTB4MQpbZnVuY3Rpb24iMS8qIl0Kd3hf -Y2Fwcz0weDgyCnJfY2Fwcz0weDg2Cm52aT0xCm5pcWZsaW50PTQKbmV0aGN0cmw9MgpuZXE9NApu -ZXhhY3RmPTQKY21hc2s9YWxsCnBtYXNrPTB4MgpbZnVuY3Rpb24iMi8qIl0Kd3hfY2Fwcz0weDgy -CnJfY2Fwcz0weDg2Cm52aT0xCm5pcWZsaW50PTQKbmV0aGN0cmw9MgpuZXE9NApuZXhhY3RmPTQK -Y21hc2s9YWxsCnBtYXNrPTB4NApbZnVuY3Rpb24iMy8qIl0Kd3hfY2Fwcz0weDgyCnJfY2Fwcz0w -eDg2Cm52aT0xCm5pcWZsaW50PTQKbmV0aGN0cmw9MgpuZXE9NApuZXhhY3RmPTQKY21hc2s9YWxs -CnBtYXNrPTB4OApbcG9ydCIwIl0KZGNiPXBwcCxkY2J4CmJnX21lbT0yNQpscGJrX21lbT0yNQpo -d209MzAKbHdtPTE1CmR3bT0zMApbcG9ydCIxIl0KZGNiPXBwcCxkY2J4CmJnX21lbT0yNQpscGJr -X21lbT0yNQpod209MzAKbHdtPTE1CmR3bT0zMApbcG9ydCIyIl0KZGNiPXBwcCxkY2J4CmJnX21l -bT0yNQpscGJrX21lbT0yNQpod209MzAKbHdtPTE1CmR3bT0zMApbcG9ydCIzIl0KZGNiPXBwcCxk -Y2J4CmJnX21lbT0yNQpscGJrX21lbT0yNQpod209MzAKbHdtPTE1CmR3bT0zMApbZmluaV0KdmVy -c2lvbj0weDE0MjUwMDBjCmNoZWNrc3VtPTB4NzY4ZWY3YTUKAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AABbZ2xvYmFsXQpyc3NfZ2xiX2NvbmZpZ19tb2RlPWJhc2ljdmlydHVhbApyc3NfZ2xiX2NvbmZp -Z19vcHRpb25zPXRubG1hcGVuLGhhc2h0b2VwbGl0eix0bmxhbGxsa3AKcmVnWzB4MTAwOF09MHg0 -MDgxMC8weDIxYzcwCnJlZ1sweDEwMGNdPTB4MjIyMjIyMjIKcmVnWzB4MTBhMF09MHgwMTA0MDgx -MApyZWdbMHgxMDQ0XT00MDk2CnJlZ1sweDEwNDhdPTY1NTM2CnJlZ1sweDEwNGNdPTE1MzYKcmVn -WzB4MTA1MF09OTAyNApyZWdbMHgxMDU0XT05MjE2CnJlZ1sweDEwNThdPTIwNDgKcmVnWzB4MTA1 -Y109MTI4CnJlZ1sweDEwNjBdPTgxOTIKcmVnWzB4MTA2NF09MTYzODQKcmVnWzB4MTBhNF09MHhh -MDAwYTAwMC8weGYwMDBmMDAwCnJlZ1sweDEwYThdPTB4MjAwMC8weDIwMDAKc2dlX3RpbWVyX3Zh -bHVlPTUsMTAsMjAsNTAsMTAwLDIwMApyZWdbMHg3ZGMwXT0weDYyZjg4NDkKZmlsdGVyTW9kZT1m -cmFnbWVudGF0aW9uLG1wc2hpdHR5cGUscHJvdG9jb2wsdmxhbixwb3J0LGZjb2UKdHBfcG1yeD0z -MAp0cF9wbXJ4X3BhZ2VzaXplPTY0Swp0cF9wbXR4PTUwCnRwX3BtdHhfcGFnZXNpemU9NjRLCltm -dW5jdGlvbiIwIl0Kd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9MjgKbmlxZmxpbnQ9MTcwCm5l -dGhjdHJsPTk2Cm5lcT0yNTIKbmV4YWN0Zj00MApjbWFzaz1hbGwKcG1hc2s9YWxsCm5yb3V0ZT0z -MgpuY2xpcD0zMgpuZmlsdGVyPTQ4Cm5zZXJ2ZXI9MzIKbmhhc2g9MApwcm90b2NvbD1uaWNfdm0s -b2ZsZCxyZGRwLHJkbWFjLGlzY3NpX2luaXRpYXRvcl9wZHUsaXNjc2lfdGFyZ2V0X3BkdQp0cF9s -MnQ9MzA3Mgp0cF9kZHA9Mgp0cF9kZHBfaXNjc2k9Mgp0cF9zdGFnPTIKdHBfcGJsPTUKdHBfcnE9 -NwpbZnVuY3Rpb24iMSJdCnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTQKbmlxZmxpbnQ9MzQK -bmV0aGN0cmw9MzIKbmVxPTY2Cm5leGFjdGY9MzIKY21hc2s9YWxsCnBtYXNrPWFsbApuaGFzaD0w -CnByb3RvY29sPWZjb2VfaW5pdGlhdG9yCnRwX2RkcD0yCmZjb2VfbmZjZj0xNgpmY29lX252bnA9 -MzIKZmNvZV9uc3NuPTEwMjQKW2Z1bmN0aW9uIjEwMjMiXQp3eF9jYXBzPWFsbApyX2NhcHM9YWxs -Cm52aT00CmNtYXNrPWFsbApwbWFzaz1hbGwKbmV4YWN0Zj04Cm5maWx0ZXI9MTYKW2Z1bmN0aW9u -IjAvKiJdCnd4X2NhcHM9MHg4MgpyX2NhcHM9MHg4Ngpudmk9MQpuaXFmbGludD00Cm5ldGhjdHJs -PTIKbmVxPTQKbmV4YWN0Zj00CmNtYXNrPWFsbApwbWFzaz0weDEKW2Z1bmN0aW9uIjEvKiJdCnd4 -X2NhcHM9MHg4MgpyX2NhcHM9MHg4Ngpudmk9MQpuaXFmbGludD00Cm5ldGhjdHJsPTIKbmVxPTQK -bmV4YWN0Zj00CmNtYXNrPWFsbApwbWFzaz0weDIKW3BvcnQiMCJdCmRjYj1wcHAsZGNieApiZ19t -ZW09MjUKbHBia19tZW09MjUKaHdtPTMwCmx3bT0xNQpkd209MzAKW3BvcnQiMSJdCmRjYj1wcHAs -ZGNieApiZ19tZW09MjUKbHBia19tZW09MjUKaHdtPTMwCmx3bT0xNQpkd209MzAKW3BvcnQiMiJd -CmRjYj1wcHAsZGNieApiZ19tZW09MjUKbHBia19tZW09MjUKaHdtPTMwCmx3bT0xNQpkd209MzAK -W3BvcnQiMyJdCmRjYj1wcHAsZGNieApiZ19tZW09MjUKbHBia19tZW09MjUKaHdtPTMwCmx3bT0x -NQpkd209MzAKW2ZpbmldCnZlcnNpb249MHgxNDI1MDAwYwpjaGVja3N1bT0weDRjNTY2NjM5CgAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== -==== diff --git a/sys/dev/cxgbe/firmware/t4fw_cfg.txt b/sys/dev/cxgbe/firmware/t4fw_cfg.txt index 2a9db62..be55453 100644 --- a/sys/dev/cxgbe/firmware/t4fw_cfg.txt +++ b/sys/dev/cxgbe/firmware/t4fw_cfg.txt @@ -15,10 +15,14 @@ sge_timer_value = 1, 5, 10, 50, 100, 200 # usecs # TP_SHIFT_CNT - reg[0x7dc0] = 0x64f8849 + reg[0x7dc0] = 0x62f8849 filterMode = fragmentation, mpshittype, protocol, vlan, port, fcoe + # TP rx and tx channels (0 = auto). + tp_nrxch = 0 + tp_ntxch = 0 + # TP rx and tx payload memory (% of the total EDRAM + DDR3). tp_pmrx = 38 tp_pmtx = 60 @@ -137,7 +141,7 @@ [fini] version = 0x1 - checksum = 0xfdebb6ef + checksum = 0x6cc2514b # # $FreeBSD$ # diff --git a/sys/dev/cxgbe/firmware/t4fw_cfg_uwire.txt b/sys/dev/cxgbe/firmware/t4fw_cfg_uwire.txt index ca8de49..30a9f9f 100644 --- a/sys/dev/cxgbe/firmware/t4fw_cfg_uwire.txt +++ b/sys/dev/cxgbe/firmware/t4fw_cfg_uwire.txt @@ -109,7 +109,7 @@ reg[0x10a8] = 0x2000/0x2000 # SGE_DOORBELL_CONTROL sge_timer_value = 5, 10, 20, 50, 100, 200 # SGE_TIMER_VALUE* in usecs - reg[0x7dc0] = 0x64f8849 # TP_SHIFT_CNT + reg[0x7dc0] = 0x62f8849 # TP_SHIFT_CNT # Selection of tuples for LE filter lookup, fields (and widths which # must sum to <= 36): { IP Fragment (1), MPS Match Type (3), @@ -124,6 +124,9 @@ # TP RX payload page size tp_pmrx_pagesize = 64K + # TP number of RX channels + tp_nrxch = 0 # 0 (auto) = 1 + # Percentage of dynamic memory (in either the EDRAM or external MEM) # to use for TP TX payload tp_pmtx = 50 @@ -131,6 +134,9 @@ # TP TX payload page size tp_pmtx_pagesize = 64K + # TP number of TX channels + tp_ntxch = 0 # 0 (auto) = equal number of ports + # Some "definitions" to make the rest of this a bit more readable. We support # 4 ports, 3 functions (NIC, FCoE and iSCSI), scaling up to 8 "CPU Queue Sets" # per function per port ... @@ -514,8 +520,8 @@ dwm = 30 [fini] - version = 0x1425000b - checksum = 0x7690f7a5 + version = 0x1425000d + checksum = 0x25c2f782 # Total resources used by above allocations: # Virtual Interfaces: 104 diff --git a/sys/dev/cxgbe/firmware/t4fw_interface.h b/sys/dev/cxgbe/firmware/t4fw_interface.h index a4d7f6d..d9e4997 100644 --- a/sys/dev/cxgbe/firmware/t4fw_interface.h +++ b/sys/dev/cxgbe/firmware/t4fw_interface.h @@ -3430,6 +3430,7 @@ enum fw_memtype_cf { FW_MEMTYPE_CF_EXTMEM = 0x2, FW_MEMTYPE_CF_FLASH = 0x4, FW_MEMTYPE_CF_INTERNAL = 0x5, + FW_MEMTYPE_CF_EXTMEM1 = 0x6, }; struct fw_caps_config_cmd { @@ -3518,6 +3519,7 @@ enum fw_params_param_dev { */ FW_PARAMS_PARAM_DEV_INTFVER_FCOEPDU = 0x15, FW_PARAMS_PARAM_DEV_MCINIT = 0x16, + FW_PARAMS_PARAM_DEV_ULPTX_MEMWRITE_DSGL = 0x17, }; /* @@ -3576,7 +3578,8 @@ enum fw_params_param_dmaq { FW_PARAMS_PARAM_DMAQ_EQ_CMPLIQID_MNGT = 0x10, FW_PARAMS_PARAM_DMAQ_EQ_CMPLIQID_CTRL = 0x11, FW_PARAMS_PARAM_DMAQ_EQ_SCHEDCLASS_ETH = 0x12, - FW_PARAMS_PARAM_DMAQ_EQ_DCBPRIO_ETH = 0x13 + FW_PARAMS_PARAM_DMAQ_EQ_DCBPRIO_ETH = 0x13, + FW_PARAMS_PARAM_DMAQ_CONM_CTXT = 0x20, }; /* @@ -3603,6 +3606,7 @@ enum fw_params_phyfw_actions { enum fw_params_param_dev_diag { FW_PARAM_DEV_DIAG_TMP = 0x00, + FW_PARAM_DEV_DIAG_VDD = 0x01, }; #define S_FW_PARAMS_MNEM 24 @@ -6767,6 +6771,8 @@ struct fw_sched_cmd { __u8 type; __u8 minmaxen; __u8 r3[5]; + __u8 nclasses[4]; + __be32 r4; } config; struct fw_sched_params { __u8 sc; @@ -7581,7 +7587,7 @@ struct fw_hdr { __u8 intfver_fcoe; __u32 reserved2; __u32 reserved3; - __u32 reserved4; + __u32 magic; /* runtime or bootstrap fw */ __be32 flags; __be32 reserved6[23]; }; @@ -7620,14 +7626,40 @@ enum fw_hdr_chip { (((x) >> S_FW_HDR_FW_VER_BUILD) & M_FW_HDR_FW_VER_BUILD) enum { - FW_HDR_INTFVER_NIC = 0x00, - FW_HDR_INTFVER_VNIC = 0x00, - FW_HDR_INTFVER_OFLD = 0x00, - FW_HDR_INTFVER_RI = 0x00, - FW_HDR_INTFVER_ISCSIPDU = 0x00, - FW_HDR_INTFVER_ISCSI = 0x00, - FW_HDR_INTFVER_FCOEPDU = 0x00, - FW_HDR_INTFVER_FCOE = 0x00, + T4FW_VERSION_MAJOR = 0x01, + T4FW_VERSION_MINOR = 0x08, + T4FW_VERSION_MICRO = 0x0b, + T4FW_VERSION_BUILD = 0x00, + + T5FW_VERSION_MAJOR = 0x01, + T5FW_VERSION_MINOR = 0x08, + T5FW_VERSION_MICRO = 0x16, + T5FW_VERSION_BUILD = 0x00, +}; + +enum { + T4FW_HDR_INTFVER_NIC = 0x00, + T4FW_HDR_INTFVER_VNIC = 0x00, + T4FW_HDR_INTFVER_OFLD = 0x00, + T4FW_HDR_INTFVER_RI = 0x00, + T4FW_HDR_INTFVER_ISCSIPDU = 0x00, + T4FW_HDR_INTFVER_ISCSI = 0x00, + T4FW_HDR_INTFVER_FCOEPDU = 0x00, + T4FW_HDR_INTFVER_FCOE = 0x00, + + T5FW_HDR_INTFVER_NIC = 0x00, + T5FW_HDR_INTFVER_VNIC = 0x00, + T5FW_HDR_INTFVER_OFLD = 0x00, + T5FW_HDR_INTFVER_RI = 0x00, + T5FW_HDR_INTFVER_ISCSIPDU= 0x00, + T5FW_HDR_INTFVER_ISCSI = 0x00, + T5FW_HDR_INTFVER_FCOEPDU= 0x00, + T5FW_HDR_INTFVER_FCOE = 0x00, +}; + +enum { + FW_HDR_MAGIC_RUNTIME = 0x00000000, + FW_HDR_MAGIC_BOOTSTRAP = 0x626f6f74, }; enum fw_hdr_flags { diff --git a/sys/dev/cxgbe/firmware/t5fw-1.8.22.0.bin.uu b/sys/dev/cxgbe/firmware/t5fw-1.8.22.0.bin.uu new file mode 100644 index 0000000..bfc993f --- /dev/null +++ b/sys/dev/cxgbe/firmware/t5fw-1.8.22.0.bin.uu @@ -0,0 +1,8112 @@ +/*- + * Copyright (c) 2013 Chelsio Communications, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +begin-base64 644 t5fw +AAEDhAEIFgAAAQQFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAA2kDeAN/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAENoZWxzaW8gRlcgUlVOTUVNIERFQlVHPTAgKEJ1aWx0IE1vbiBKdWwgIDEgMTI6 +MDk6MzEgUERUIDIwMTMgb24gY2xlb3BhdHJhLmFzaWNkZXNpZ25lcnMuY29tOi9ob21lL2Zpcm13 +YXJlL2N2cy9mdy1yZWxlYXNlKSwgVmVyc2lvbiBUNXh4IDAxLjA4LjE2LjAwAAAAAAAAAErb7x1g +AMAAH/zhSOEAMLh4////H/zhQIAAAAHhAHtwAAAQAB//9sggAAAA4QGcBOEFAAAAAgBA4QUIAAAG +AEAAAgAMAAYADOEFAAQACgAAgAABAuEAezzhAHtE4QB75OIAAAAAAQAA4QB7kCAAAAAAAIAA4QB7 +AAAAQAHhAHucAABAAERERELgAAAA4wAEc0REREDjAAgAIAACXAAAAAAf/49gAAAAAB//j2QAAAAA +H/+PaAAAAAAf/49sH//AAAAAAAAAAAAAwAAR/88iCoeSEIIQEv/OE//OhCAEMwGTIBH/zBL/zZIQ +Ef/MEv/NkhAR/8wB9DEA5DEABTEBAgAS/8oC5zECFgAR/8iBEAEBX8AhAhEByRMR/8YS/8aSEBH/ +xhL/xpIQYAARAAAR/8AS/8SSEBH/wBL/w5IQgRAR/8LAIJIREv/BkhLAIJITEv/AkhCCEALyUGUv +9xH/vscvkhAR/72SEBL/vRP/vZMgwDKTIRP/vJMigiIS/7sT/7uTICMiIRT/ugQzAck4E/+5gzAD +gxQIMxEU/7ekM5MhE/+rkyJgAAjCMJMhE/+okyIS/7KQIJAhkCKQI5AkkCWQJpAnkCiQKZAqkCuQ +LJAtkC6QLyAmECAmEYIiEv+lwDAtNzAtNzQtNzgtNzwjPQFyM+0AAgAS/6IjCgAvNwAvNxAvNyAv +NzAjPQFyM+0AAgAS/5fAMCg3MCg3NCg3OCg3PCM9AXIz7QMCABL/lcAwJzcAJzcQJzcgJzcwIz0B +cjPtAwIAEv+PFf+QFv+QwDDXIAVmAWAAHgAAAAAAAAAAAAAAAAQ2BQACANMP0w8FMwxuOxQHRxQH +BEN2MeYENgUFMwxvO+0AAgAS/4EV/38jCgACJwIHBEMEPgUFMwwHRxRvO/ADAgAS/3vJLoMghCGF +IrwidDsOhlC0VZYwtDN0M/Rj/+YAZT/iZV/fEv9vwDIDLgUDAgAS/2bAMCg3QCg3RCg3SCg3TCM9 +AXIz7QMCAAACABL/aS0nAMARAUkxAEgxAQIAwAAU/2UE0jEV/2SUUBT/ZATTMRX/ZJRQFP9jBNQx +Ff9jlFAU/2ME1TEV/2KUUBD/YgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/AAA +H/wAAOMACfgf/AAAH/wAAOMACfgf/AAAH/wAAOMACfgf/4AAH/+H8OMACfgf/4fwH/+H8OMAEegf +/4fwH/+H8OMAEegf/4fwH/+JoOMAEegf/4mgH/+PYOMAE5gf/49gH/+rjOMAGVgf/6uMH/+rjOMA +NYQf/8AAH//3xeMANYQgAAAAIAABauMAbUwgAAF4IAABfOMAbrggAAF8IAABheMAbrwgAAGYIAAB +nOMAbsggAAGcIAABpeMAbswgAAG4IAABvOMAbtggAAG8IAABxeMAbtwgAAHYIAAB2OMAbuggAAHc +IAAB4uMAbuggAAH4IAAB+OMAbvAgAAH8IAAB/OMAbvAgAAIYIAACGOMAbvAgAAIcIAACHOMAbvAg +AAI4IAACOOMAbvAgAAI8IAACPOMAbvAgAAJYIAACWOMAbvAgAAJcIAACYuMAbvAgAAJ4IAACeOMA +bvggAAJ8IAACguMAbvggAAKYIAGDZuMAbwAgAoAAIAKXlOMB79AgApeUIAKXlOMCB2QgApeYIAXg +GOMCB2ggBeAgIAXkAOMFT/AgBoAAIAaZwOMFU9AgBpnAIAd+UOMFbZAgB35QIAd/0OMGUiAgCMAA +IAjAAOMGU6AgCMAAIAjAAOMGU6AgCMAAIAk9z+MGU6AAAAAAAAAAAAAAAAAgAA/uIAAP4CAAE/kg +AA/gIAATZSAAD+AgABCVIAAS/SAAEoUgAA/gIAASMCAAEeIgABF1IAAPzSAAER8gAA/gIAAP4CAA +D+AgABC1AAAAAP///////w/8///w////APwgAId9IACIpyAAiNggAIifIACIZSAAiF4gAIgiIACI +GiAAiBIgAIfDIACI1iAAh7sgAIekAAAAAAAAAAAAAAAAAAAACgAAAAoAAAAUAAAACgAAAAoAAAAK +AAAACgAAAAoAAAAKAAAAAAAAAAAAAAAAAAAIAAAAEAAAAEAAAAEAAAAACAAAABAAAABAAAABAAAA +BAAAABAAAABAAAABAAAA/xgwYGAAAAD/AAECAgAAABAgQAAAAAAAAAAAAAAAAAAEAAIAAQAAgABA +ACAAEAAIIAKO5AAAAAEgAo7oAAAAAiACkbQAAAD/IAKNBAAAAP8gAo0EAAAAACACkbQAAAAAIAKO +HAAAAAEgAo4kAAAABCACjiwAAAAIIAKOOAAAABAgAo5AAAAAICACjkgAAABAIAKOUAAAAIAgAo5k +AAABACACjngAAAIAIAKOkAAABAAgAo6kAAAIACACjrQAABAAIAKOwAAAIAAgAo7UAABAAAgEAgAA +AAAAAAAAAAAAAAAgAo4IAAAAECACjhAAAAARIAKNiAAAAQAgAo2UAAAAgCACjaQAAABAIAKNtAAA +ACAgAo3EAAAAECACjdQAAAAIIAKN4AAAAAQgAo3sAAAAAiACjfgAAAABAIDA/wAAAAAgAV5pIAFe +/yABXikgAV7SIAFesSABXowgAV4/AAAAACAHZ1ggB2cSIAdnTiAHZ04gB2cSIAdnEiAHZ1ggB2dY +IAdnEiAHZ1ggB2cSIAdnWCAHZ04gB2cSIAdnEiAHZxIgB2cSIAdnEiAHZ1ggB2cSIAdnEiAHZxIg +B2cSIAdnEiAHZ1ggB2dYIAdnWCAHZ1ggB2dYIAdnWCAHZ1ggB2dYIAdnEiAHZxIgB2cSIAdnEiAH +ZxIgB2cSIAdnEiAHZxIgB2cSIAdnEiAHZxIgB2cSIAdnEiAHZxIgB2cSIAdnEgACAgUFCAgLCw4O +EREUFBcXGhodHSAgIyMmJikpLCwvLzIyNTU4ODs7AAAAAAAAAAEDEREICBAJAwEAAAAAAAAgA+38 +IAFGcCAANdAgASw4IAFCWCABPRAgARGoIAMgtB//5Wgf/+IkIACJZB//1tAgAFmwIABM2AAAAAAA +AAAAIAEtmCAAd9gAAAAAAAAAAB//0ewf/8WIH//DZB//wXAgAElEIABB5CAAQEggAIBwH//bSCAF +sRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAFMcCABNhggAJCsIACP +0B//6ggf/804H//J0CAAdZAgBET4IAD1eCAA2JAgAMP4IAC+KCAArmggAKTcIACSpCAD8BwgAz4w +IADqfCADXqwgAXLUIABZbAAAAAAgAJEMIASnkCAAhvAgATGQIAADVAAAAAAAAAAAAAAAAB//7Tgg +AJDQIANAyAAAAAAAAAAAIAK/nCAAJcQgABwIIAAk/AAAAAAgADCoIAAueCAAK7QAAAAAIAA1kCAA +7ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgADKUIAPtnCADEcgAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAIAA0RCACxoQgADNIAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAE +AAAACAsAAAAgApToCAAAACAClPQIAAAAIAKVAAoAAAAgApUMDAAAACAClRgSAAAAIAKVKA0AAAAg +ApU8DgAAACAClUwTAAAAIAKVXAoAAAAgApVwDgAAACAClXwYAAAAIAKVjA0AAAAgApWoDgAAACAC +lbgQAAAAIAKVyBIAAAAgApXcDgAAACAClfAQAAAAIAKWABEAAAAgApYUCgAAACACligLAAAAIAKW +NA0AAAAgApZAFAAAACACllAKAAAAIAKWaA8AAAAgApZ0BgAAACACloQGAAAAIAKWjAYAAAAgApaU +BgAAACAClpwGAAAAIAKWpAkAAAAgApasBgAAACAClrgEAAAAIAKWwAYAAAAgApbICwAAACACltAL +AAAAIAKW3AQAAAAgApbABAAAACAClugJAAAAIAKW8AkAAAAgApb8AAAAAAAAAAANAAAAIAKXCAoA +AAAgApcYBgAAACAClyQCAAAAIAKXLAMAAAAgApTkAQAAACAClzAAAAAAAAAAANdqpHjox7dWJCBw +28G9zu71fA+vR4fGKqgwRhP9RpUBaYCY2ItE96///1uxiVzXvmuQESL9mHGTpnlDjkm0CCH2HiVi +wECzQCZeWlHptseq1i8QXQJEFFPYoeaB59P7yCHhzebDNwfW9NUNh0VaFO2p4+kF/O+j+GdvAtmN +KkyK//o5Qodx9oFtnWEi/eU4DKS+6kRL3s+p9rtLYL6/vHAom37G6qEn+tTvMIUEiB0F2dTQOebb +meUfonz4xKxWZfQpIkRDKv+Xq5Qjp/yToDllW1nDjwzMkv/v9H2FhF3Rb6h+T/4s5uCjAUMUTggR +ofdTfoK9OvI1KtfSu+uG05EHDBEWBwwRFgcMERYHDBEWBQkOFAUJDhQFCQ4UBQkOFAQLEBcECxAX +BAsQFwQLEBcGCg8VBgoPFQYKDxUGCg8VH//AAAAEACAgBeQAIAXncARBAAgEAQAIH/+oEDAAAACB +AAAAH/+b8MAAAADABAAApQAAAB/84gAf/5wAA4AAAAD/+AABAAAAABAAAIEEAQCBBAAAAQQAAAEE +AQCAAAAAAAf//yoAAAAf/4MgBgAAAB//zKAgA3ccAgAAAIAQAABBQAAAQUABAIMAAAH//7//H/+X +YAAAP/8f/5SQBAAACCACj3AMAAAAgYAAAB//mnAgCN0QH/+PsP//AAD//wD/IAjdQCAI3aAgCN2A +H/+QUAAADlAf/5mwH/+ejB//noQf/ODgH/+eAOD//gAf/5UcD////x//miQf/5sYH/+VgB//luDh +A/4A4QRuAAAAhYQAAIWAIAkHcCAJCDAgCQewIAkH8B//mpAAAAzAAAD/gCAF5EAgBeAgIAkIcOEA +LgAf/5qEAAALaOEBkgAf/N4AH/+bVB//mhTgAACg4QAwuAAAgADhAGAQAABAAOEDCADhA0gA4QOI +AOEDyADhABAIH/zhQOEAe3Af/6tMH/+rRB/84Agf/6tIH/+rZB//q1wf/6tgH/+rfB//q3Qf/6t4 +H/ziACABXDwf/6gQAQAAACAF5AAEAAAIBQAAAIP/AACBAAAAABAAACoAAAAgAAZEIAKOyB//hzAf +/4MgH/+cAGdFIwHvzauJmLrc/hAyVHYf/4AAIAjCoAAAPyggCMHwIAjCkCAIwsAgCMEAIAKU5M// +//8gCMEwIAjBgCAIwbAQAAAAIAjCED////8CAAAAQAAAACAIwlD//3//H/+b8CAAIQggCMVQCAAA +AAD///8gCMWw9////yAIzEAgAB0I//7//yAI0tAAIAAADAAAAAAAQAAgCNMAAAD//wAAgAANAAAA +IAAjtP/7//8P9oAAAAP//wAAJ/8gCNWAAAEAAAAEAAAfgAA/H/+ZsCAAMKggADJQIAAueCAAK7Qg +CNWwIAjWEB//mQQgCNZwIAkWoCAI1qAgCNcQIAjXgCAI1/AgCNgg4AAAAAQBAAgf/5mkIAjYUCAI +17BTAAAAUgAAAFEAAAAgAXusH/+YOCAI2HAgCNjQIAjYoCAI2VAf/5m0IALefB//mKAgCNrAFAAA +AIAAAACAAAACeAAAAIAAAAaAAAAFAAAKAIAAsAAA4zCS///wAIAAsQDhAZoAAAIAACAI2oAf/5ag +AAB+QCgAAAAmAAAABYAAAAYAAAAf/5fAKwAAACAARGgf/N4AH/+PsDUAAAADgAAAA0AAAB//l8QH +////AD///4BAAAAID///H////yAAAAAf/5mIPQAAAB//lRgHAAAAgQQBAIEEAAAAADqYwwAAABgA +AAAf/5BgAAAP/wBDAAAf/5lQAAAIAAQAAAAf/6gwH/+qwB//lJDhAHoAH/+X8B//mewf/5iQH/+Y +iCAJHAAgCRxwAAMHgB//l2wAQAAAAAAJAAAAMAL//Ph/wAAAAKP/uwCj/7oA4AMAAIP/tgAP//// +D//4AP8AAAAgCRywIAjcoCAI3NAgCR1AAA8AAAAKAAD//wAPH/+YeAP/wACD/8AAIAkdwCAJHjAf +/5oIH/+ejAAADGgf/6ig/2DwAB//qIAf/56QBIAACB//j3Af/4BQAEQAAADAAAD/H///AAANbAAA +gQAf/OIMDwAAAP//AAAf/5moH/+eiB/84ggf/5UUH/+AYCAF4gAAADAAAAAnEB//1kAf/5hc3q2+ +7zQAAAA/AAAAH/+n6ACZAAAAAIkGgYAAABAABwLuAAAAAcCAAB//priZAAAAH/+opACIAAiCgAAB +H/+oOB//p0QADwP/AxEAAAMVAAAgCOIwIAjiYCAI4qAgCSagIAkncCAI4sAgCSbgIAknICAI4vAg +COMgIAC3FCkAAAAgAL+8/wD/AMzMzMyqqqqq8PDw8B//qrAf/6i4IADOSAAPQkAgA2SoH/+aEAAJ +AAAAgAAAAABIAIIAAAAgAO4QAAkACB//p6wwAAAAH/+n+AAACAYAAIjMAACJFH8AAADwAAAAIAkq +YCAJKvAgCSkgIAkqwB//lngf/OLkAAQD/woAAAAf/6bUMwAAAOEAAAAf/6bEH/+YwAP/4AB///8A +AAD//gA/9pAf/6gAAAAaSAP/8AAf/6oAGgAAACAI58AgASOgH/+n/AAP//8f/5mAAADerR//p7Ag +BeAgH/+X+B//mfQf/5mEH/+d0B//nVgf/5aIIAksMMAEAAAf/5aEH/+X9AAA4AEA4AEA4AEAACAJ +LXAgCOpgIACEdAAADXQgAIH8IAks8CAJLUAgAoygH/+ZoB//lpwgCOvAH/+enCAI84Dg//4AIAkj +kB//mZwf/5FgIAj6MCAI+sAgBeRAIAj60CAI+wBIAAAAIAFU8B//mVwgAVbk4QBeAB//mNQf/4JA +AE01oAAASLkf/5UcH/+ZHOEALgAf/5kg4QMGAP//v//hAA4AH/+aJAAAC2gf/5toH/+bZAAADaAA +AP+AH/+bXB//m8gD/wAA/7///x/8v/88AAAAAAf//4MAAAAgCQuwIAF2KB//msQAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAACBgAAAAAAAAB//9NAf//TQH//0kB//9JAf//SQH//0kB//7mAf//K0H//w8B//8PAf//Dw +IAWy+AAAAAAAAAAAAAAAAAAAAAAgBbVoIAW1aAAAAAAAAAAAAAAAAAAAAAAgAWA8IAWy+B//87Qf +//O0H//ztB//87Qf//O0H//ztAAAAAAf/+5oAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAAAAAAA +AAAEAAAAAAAAAIGAAAAAAAAQBAAAAAAAAAKBAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAgCgAR8fsT8fvTDwPmMQECABbx+Rfx+ndrBpBgtGZ3Y/hUDUhV +h9UPFABj//kAAABsEAQX8fMrIAcV8fILKED5IQgkBQBF8PU2ACIAADDw8/HuEAAQYDD18e0aIAFc +MPoiACsABD7g8zCAKAkAXnD8ZgUoCQAucJlk+fHlEG4COPD3RxQLgAQ6oPlmAiH+AkHw+noCCcAE +OiD6ZgEh8AJCMJhjGPHcAEKNlWaTZwIGjwNDFCkhCSlmCvRmCyBgAimw8AgHAgAAEfBtOQIARWHR +DwAAAGwQBB/xyi0gBx7xyRjxzPchCCQCAWww+/HMHgUAK/CeMB7xyPwiACADEEgw+zYGIAAQMDD2 +NgcgIBBQMPY2BSwgAWww+jYDLQAEP2D4NgIsCQBt8PjMEQwJAHdw/TYELAkASzCcMSUgB5Y5JiEJ +9fG3EiABKDAAIhECcgL0NgsiCQAosPI2CCYJACmw9jYKIgAAEnDRDwAAAAAAAGwQBikgBSogB/gx +BSAUEFgw+gpBDgCp2lCLIi4gFBzxpfcKCSEbALbgDKYRrGYtYjr/AgAKAKG/UC1iOfvcAAFCADdg +KcJKZJENLcJJZNEHDuSH/iQUKgCxF6Af8ZcuIhYsISkZ8ZYptgD5Ih4gBhBQMP7MCAACEGgw/bYC +ICACcPD/zBEJgAQ+YPy2AygJAFZw+bYBIAQQaDDwDxcAIAJS8PIaHgwDAGowGfF9+bYGIEAQeDD/ +tgcgQAJK8G3JBQAOhgBJYfzIEQRCALsgGvF1qLj82QwAQAJCMPAKBwQYADsg0w9tmQIASGEoISkp +ISixiAgIT/glKSYATMZQK7xg//FvEAEQYDD6Ih4gABBIMPkWAC1QBD4g/RYBIB4QcDD5FgIgABBo +MFhpcgUOR/dmOSLaAjugwCDRDwAAAAAA+iwAAgAAWPD8TAACAABpcFhrM9Kg0Q8A2iD7ChwiAABg +sFhuBGP/1/osAAIAAFlwWGx50qDRDwDz/sBgABBoMAAAK6wY/CwAAgAAULBYbflj/6zA8C8lKfP/ +YmAAEEAwiif7TAACAABpMPqsICAAEGAwWGZV0qDRD8eg+SAVKgBAU7AK7wwvJBQvIQn61AMoQAQ+ +YPj/EQABEFAw+QoALgkAT/D51AAuCQBX8J/RKsZJY/5mbBAGKCAF+yIQIBgQSDD/IAciAABRMP4K +HCIAACFw/pswABQQSDD/D0EOANFKEIwiGPEk+hYAIWgAtyAM9xGody1yOv8CAAYAt8NgJXI5DQY+ +ZFFhiikpIgoKmQz/AgAKAJY2UCsgTCogTsDx/KwBJgC2VtAsJE4qMAEpIhj9MQEiALXqkBzxEigg +ByshJAoPQvD/EQgCAUAw/LsCCKAEOiD4IQcuCQBH8P8hCSwJAH9w/CEiLAkAZ3D9VgApQAFAMP3x +BBjABDog+CIALgkAR/CbVP9WAyAGEFgw/cwCCYAEOiD8VgIoCQBaMJhRGPD6LyIQn1UtIDgf8Pn8 +CkEgARBYMP5WCCwDAWww+1YJLgUAbjD78OwSAABC8PwKACgFAGsw+PDiHgkAR/CcV/9WBiACAmpw +LSYYnFuZWvALFwBgAklwAAmK/lYPICACUPAuXED4Vg4gBhBIMAIKhgBOYwAKhgBOYfl2OSATADWg +iikpIDimqvomCSIAUHpQBAtH/wIAAgBAGuDAINEP+iwAAgAAWbBYbT/+ChwuyQA2oPosAAIAAFjw +/BIAIgAAaTBYap/SoNEPK/wY+iwAAgAAYLBYbW9j/9cAAAAAAPosAAIAAFlwWGvj0qDRDwCMIsDU +DcwCnCJj/7YAAAAA+CIdLIABSDAAwQQA+xoLiAIoJh1j/oEAiieNEMDA+qwgIgAAW3BYZcDSoNEP +2iBYaktj/1sAAABsEAwsIhAqIAeVFPMhNSIAAEDwjoQA9Y71IAUgFBAwMPOCAi4DABuw+gpBABgQ +WDD+vDACAABiMPMDQw4BmjFQKSICKBYA9woIIv4AtmAmgAH4FgAgBgJZMPylEQIBcHGQmhMW8I6T +F/8WBiACAkkw/hYFJAAgNXAnUjr5FgsqAFTd0ChSOf6MAAL3ADYgGvCDKqJK+PCCEsgANqAogkkN +Az5kgrqNKYoqmBKbHA2qDP4WCCoAPp6QLhoA/wr/KgAIm5AoIBabHPwWAS4AQnoQhhWHGC4gOPrC +AyAAEHgwn3mWeJp3GvB2KCIXmHr9IhsuAwFwMP12CyBAEDgw9/BvHgUAdfCIxP8WCSYFAHaw9xYK +KgCUwZCOFpscmR38FgEg2wA3oGAARvP/WmAAEEAwAJkdnBH6LAACAABY8FhszIwRiR37EgwvcAA2 +oGAB+ACZHSogB/wKACIAAFowWGyijBGJHfsSDC9oALagYALEjhqGGYwV+xIBL4AQUDAqJDsMiQyI +F/m2BCIAAFCw/SIQLgAgZ3D/JhsmCQBBsP8SCC4JADOwWGtoixyJHYwRLRoA+lY5KgAGm1AoIBYu +Cv9+iVKGKS8gOKNm9iYJIL4A+/AuITWNxP8iECABEFAw+hYGIAMQQDD4FgQsAwB3cP0WBSAYEHAw +De9wY/57iieLEPqsICIAAGEwWGh2mhEtIhuIpGP/WSogB/w8AAIAAFowWGxajBGJHYscY/+V2iBY +ab2MEYkdixxj/5YAAIsXihktIhAe8CD7IDsqCQBasP/wHhgJAFHw/o4CBmABRDD1sTFmgAQ94IvA +JiAHD7sB//APFgIBMDAKZhD6IQcqCQA28P8SCCoJAH7w+iEkKUABUDCb8CshCfYhIijABDog9/AE +GgkAOrD4IgAqCQBG8JvznfX+9gYmCQA5sPb2AimABDog+vYEKAkAQnD49gEgYAJL8PjMICIgADkg +Kkz+bakFAAiGAElhKCAUCISH+CQUKgBmFiD6EgshABBIMPpWOSoACRpQKCAWKwr//wIADgCK2hAs +IhexzPwmFyATADTgjiktIDij7v4mCSIAePtQjxZl8MzAINEPAAAAAAAAJiBOZG0dB5sCmyL7EgAi +AABQsP0SBCIAAGEwWGmr0qDRDwDaIPsKHCIAAGCwWGx8Y//X+xIEIgAAULBYavHSoNEPAACLE9og ++7wYIgAAYLBYbHNj/7TbwPwSBS+AEHgwLyQ7/xIIIgAAULBYauf6FgsgABAwMCYmGyYkO2P/KYwS ++yEJL/AQcDD9IBUuAEByMA6PDC8kFPTdEAuABD7g/QoAKgkAbvD9xAAgARBIMP7EAyoJAE7wm8Ea +76kppklj/vQAiif7TAACAABpMPqsICAAEGAwWGS30qDRDwAA2iBYaUFj/woqIAf8PAACAABaMFhr +12P+3YsT2iD7vBIiAABgsFhsRmP/AQAAbBAGKCAF3UD675MQFBBwMPcKAS4AknIQKyBOKaJKK7z/ ++yROIQMANmAmoklkYPopIBQpnAMJCUf5JBQqANwWYCsgcxTvkPwiHSABEEAw8LEEAAICSvDwexoI +gAFMMPkkcy//EHgw/78DCgBAZvD7izkMAEB7MPwmHSDOALbgiiJ8pwQsIE7KxH2nCC4gTC0gTn7T +GcxsLyAU+CICKg4BP+BkgYjAINEPAAAAAAAAiSfHswuqAfomAiBgAlJwWFw18+9yECcANqAooADT +D9MPA4gKKIIQ/KAHIgAAWrD9CgQiAABQsAuAAGWv3Ikn0w9kn6EqmRTKp4qZZK+XKKAAA4gKKIIQ +/KAHIgAAWrD9CgMiAABQsAuAAGWv4GP/dQAA8//VYAAQUDDAYCkgFLOZKSQUY/8KAAAA+iwAAgAA +WXBYam3SoNEPAC8gBSwgB/wLQQ4Ap3PQBQ5H/wIAAgCom6CPNgy5EaqZKJI6/wIAAgB8wiAqkjlk +oO4oIST770QcAgFgMPMhCSygBDsg/O8tGAkAYjD7ISIoCQBaMJigiCD/pgUqCQBm8POmAyACEGAw +8+8qGYAEOiD7pgIoCQBiMPimASAwAlqw8AMXAAAQUDCxqvIbHgH0Aj6g/JY5I/9QA6CKJ9vQ+qwg +IAAQYDBYZC5j/okrIQkvIBX8+vAgABBAMPhkACwAQGJwLGQD9P8QC4AEPuD8nAwKCQB+8PwkFCoJ +AD7wm2Enpklj/hKKJ8Cw+qwgIAEQYDBYasmUoIwg++8UHYAEOyD7pgIsCQA7MPymASAcEFgw/CwA +AgAAULBYa6zAINEPAI0iZNBK/wIAA/8Gm6CKJ8Cw+qwgIAEQYDBYZ0aUoI0gCN0R++8CHAkAP3Cd +oYw2nKObomP93wAA+1wAAgAAULBYahNj/c+PM2P+rwAAAAAA/hYAIDACWvD6LAACAABgsFhrko4Q +Y/+cbBAEKSAUb5sYiif7TAAAABBgMPqsICIAAGkwWGPv0qDRD4sic75YGu7XLKJKZMBNLKJJZMBH ++SQUK54BPmD/IBUv8BBAMP4hCSgAQEJw+MQDIAEQaDD4mAwOQAQ/4PgkFC+ABDug/woALgkAe7D/ +xAAuCQBrsJ7BLaZJY/+KyLLAINEP2iD8LAAAHBBYMFhrbcAg0Q8AAABsEA79IAcu4AEoMP/s/iAB +EEAw9BYNLgUAfjD/Fg4gARAgMP0NQQJyAjug+jwQIgAASHD0ChYAAxBgMPwWDSIAAFhwAEllAgqG +AEljAAqGAElhAAOIAAuK+xYMIgAAGHAoITSHN48v8xYPIgAAMPD4dzYAFBBQMPevMAIuAjugKyBP +KSBNsbsLC0f7JE8qARVeUC4gBf8CAA4A/tOQjCLHo/4SDygA2OKQLyIZjuL/AgAOAR97kI8fGO6N +jh2P+P7sAyPABD9g9PH1YgAgRPAf7ogpMjr/AgAKANT2UCQyOQ0FPmRBm4spiioLqgz/AgAKAKGu +kCwaAHXLECsgFigK/w8CAP8CAA4BbkLQGe6JKCEkKiEH+SEJKAkASjAKCkoMqhD6IAcoCQBWcBvu +dAoqQPzugBqgBDqg+yEiKgkAWrCaQIogmET5RgMqCQBm8JtC+KoRAAUQWDD77ncaCQBasJpBiS+Z +RSggOBnudMTC90YIKAMBQDD5CgAqBQBGcPlGByACEFAw+GIEKgUAQzCYSRjua4xlnEopYgb5Rgsg +ABBIMPwgOSDJADXgCpwQCMwCnEyJaJdPmU6IaShGEIxqLEYR8A8XAJACSTAACYqJZ/8CAAoAks3Q +H+5PCr4CD+4Cnkb9CgUhABBgMP02OSoACSsQKyAWKAr//wIADgENwtAsIhkrIE+KKfkgOCACAmMw +/CYZIf4CWvD7JE8qACAqsPomCSIA03pQjR5l0aTAINEPAAAvFhAuFhEtFhL6LAACAABZcFhqni0S +Ei4SEf8SEC6jADagjh5l79KKJ4sf/BINIGACUrBYZk7AINEPAAD/AgAB/5vjEPP/L2ABEEgwAAAr +3Bj6LAACAABgsFhqx2P/wgAAAMEzc+kMLiA6wP/9FhIuAOZ7kPosAAIAAFlwWGk30qDRDwDwAAZg +HRBQMMChKyEJjh/6LAAPsAQ+oPziBytABD7g/eIIKgkAfvD+4gIqCQAm8FhpGMAg0Q8AAPP/zmAY +EFAwAAq5AplG+AoFIQAQYDD4NjkqAAkrECsgFioK//8CAA4AvNLQix5ksQaMZ4tqimkHzAz8Zgcq +ACBd8Pe7BnAAEGAwsaqJZohlmmn7ZgoqACBN8Pe7BnoAIEMwsaqbZppliCksIDiliPgmCSIAd3sQ +iScqmRTLoYuZ/RYSIC0ANuAZ7eoosAAvFhAuFhEJiAooghAssAf6LAAAAxBoMAuAAC0SEi4SES8S +EIsix6P/AgAJ/0LakCghNIdn+SIPIAEQYDCcHvgKFCYDAEXwB4lwY/0HANogWGdpY/5Viif6rDAi +AABZsFhXztKg0Q8vFhAuFhEtFhL6IAcgABBgMFhqEC0SEi4SEf8SEC0KALagK9wS+iwAAgAAYLBY +amZj/j4A+iAHIgAAYXBYae5j/doAAC8WEC4WEYonLRYSix/8Eg0gYAJSsFhl2C0SEi4SES8SEPP+ +1GIAADKwLxYQLhYR/RYSIgAAULBYZ0UtEhIuEhEvEhBj/vgAAPosAAAAEFgw/AoAIAMQaDBYYUor +IAX9EhIv/gma0GP9xC8WEC4WES0WEvogByIAAGFwWGnOLRISLhIRLxIQY/5qAAAAbBAMlRQA9Y4m +IAUtITSKNC4gB4cv/DwAABQQWDD+DkEKAwBqsPq3MA4BpdmQiSKTEPcKCCMXALZgJjAB8xYAIAYC +WTD85RECAXzxkBbte54T/xYGIAICSTD6FgUkACA1cCdSOvkWCSoASl3QKFI5/4wAAxIANiAa7XAq +okr47W4S4wA2oCiCSQ0DPmSC1Y0piiqYEg2qDPsWCioANJ6QLhoA9gr/KgAIm5AoIBabGvwWASDm +CDIwF+10LiA49u1xEAAQUDCa9/jCBC4DAXAw9xIFJgUAcfDE0PYWByoFAHNw+hYIKgC0wdCGFvsW +CiESADWgYABSAAAAAAAA8/9vYAAQQDCZG58cnBH6LAACAABY8FhpvowRjxyJG/sSCi+AADagYAIl +mRufHCogB/wKACIAAFowWGmTjBGPHIkb+xIKL3UAtqBgAvWcEfcSBS+AEDAw9iQ7ICACczDwDhYA +QAJr8ABNYZf4isSNx5saiMb3qgwMACBt8PrGBCoACLtQmxopFgv8FgEgAgJCMJkbjBWLEYYYjheY +tv22ByIAAFCw/SIPLgkAM7BYaE6LGokbjBEnGgD6VjkqAAaZ0CggFioK/3qJXY4pLSA4o+7+Jgkg +1gD7cCohNIjE/SIPIAEQMDD2FgYgAxB4MP8WBCgDAFIw+BYFIBQQUDAIrXBj/mAAmRuKJ58cixD6 +rCAiAABhMFhlW48ciRuLGvP/K2IAAGKwAAAqIAf8PAACAABaMFhpPowRiRuLGmP/igDaIFhmoIwR +iRuLGmP/igAAAAAmIDuNFx7tA/v8ICAgAkMw+u0BHAkAV3D1YS1uCQBzcIbAJyAHkx76ISQmAEBR +sP0DQwYCATww+DMQDKAEPeDz7O4aCQAasPYhBywJAG2why/zIQksCQAfcP32ACdAATAw/SEiJsAE +OaD2IgAiCQA08Jf1nvaT8/Ps4ReABDmg+vYEJgkAMnD29gEh/gJRMPMSDiwJAB9w/fYCIBoAPSBt +qQUACIYAS2EoIBQIhIf4JBQqAGMWIPoSCSEAEEgw+lY5KgAJGlAoIBYrCv//AgAOAIhaEMg+jSks +IDgD3Qj9JgkiAHl7EI4WZeDPwCDRDwAAAAAmIE5kbQQHmwKbIvsSACIAAFCw/RIEIgAAYTBYZpHS +oNEPANog+wocIgAAYLBYaWJj/9f6LAACAABZcFhn19Kg0Q8AAIsT2iD7vBgiAABgsFhpWWP/tCb6 +gCYkOwIIhgBLY/wSBSIAAFswnPj9Ig8iAABQsFhny/oWCSAAEEAwKCQ7Y/8vjBL7IQkv8BBwMP0g +FS4AQHIwDo8MLyQU9N0QC4AEPuD9CgAqCQBu8P3EACABEEgw/sQDKgkATvCbwRrsjimmSWP++oon ++0wAAgAAaTD6rCAgABBgMFhhnNKg0Q/aIFhmJmP/CQAAAAAqIAf8PAACAABaMFhou2P+4osT2iD7 +vBIiAABgsFhpK2P++gAAAGwQBiggBSMgByQKA/MDQQj0ATogKCAiZIBvAioCWF+U+aFmYAEQaDAq +ICEY7G4PAgD8MxEAqgD+sAgzCCkyOg8CAG6TRCsyOcu+Lgr+/q4BAAAQYDD6IgAsCQBvsP0kISAA +EEgw+RYAIAAQeDD5FgEgCRBwMPkWAiAAEGgwWGRp9DY5IAAQEDDRD8Ag0Q8AAGwQCiwgBfS1GgAT +EGgw+CAHIgAASPD5FgAiAAAZMPsWAyIAACJw+AhBCBgAOyD/AgAOAZBrEI4i9uxHH8AEPiD14qxg +CAJI8Kb/nxWNFS3SOv4SBSoBU09QLuI5LxoA/hYEIpgAN6AlIRuKQvciCSQDAC6wBaYM+BYJKgAD +t9AKpQKGKgdmDHVjMyoaAPwK/yoAB6qQKyAW+BYJIHgIYvCKQv8CAAoAmlFQjRMf7ECOQ5gZ9NCW +bgBAe7BgADSZGPosAAIAAFlwWGiXiBn5EggvuQA2oGACF5kY+iAHIAAQYDBYaG+IGfkSCC+1ALag +YALiAB3sLy3Qf2TQfiYhGx/sLXbzdSshGowp+RYILkABXDD4FgkgawC34PkWCC5AAWQw+BYJIFsA +N+D5Fggn8AQ64PgWCSoAJamQDQhA/7UMCSAEOiDwADhuCQBDsJ4WiieZGIsQ+qwgIgAAYPBYZE+I +GYkY/hIGIAIQWDArpAL6ogIiAAAisGP/eACMKZkYmBmPFPWtDAIAAFkw+iwADAAgKzD9RgIiAABp +cPwmCSIAAGDwWGRuiRiIGY8VLhoA+vY5KgAGq5ArIBYmCv92uQfAoZoTY/6EAPogByIAAGFwWGgc +iBmJGGP/5Y4p+RIELgAgK7CeKYhDi0CME/eMAABAAkpw+w1HAgAAcjD9FgEhKAC3ICcgBxjr7AcH +QQh3CidymQ7qQP+qEAAgAkEw+jz/JgBAVfD35wIAIgA84G2pBQAIhgBJYY5Di0DAgJgSLCEaFOvf +JiEH/RIEKiYBcDD469saACAisPTr3BdAATAw+qCAJ8AEOaD469cWCQBBsJbQhhEKWgyPIJfXnNaa +1fzrsBACAlDw9mwPICACSbD51gMoCQBD8PZGFA+ABD/g+NYEIAICMbD2NgwOCQB+sP/WASwFADEw +nNIoIBTziAgCAAAisPgkFCCGAKrwihWIEvwK/yEAEEgw9KY5KgAHqlArIBb/AgAOAETi0NKA0Q8A +jRNk0IvAINEPAADaIPuMGCIAAGCwWGhDY//kixT8TRECAABQsP27CAABEGAwWF5+8/+oYAYCITCK +J/gWBy7oAVgw+qwgItQAv6CMFMCx/MwgIgAAaPBYYJiOQ4tAmhJj/uxlvOD/AgAB/m6fIC4gIP8C +AAH+aXuQY/+JAAAAAAD6IAciAABhcFhnsogS0oDRD4on3DD7EgAgQAJSsFhjw8Cy+6QCIAAQEDDR +DwAAAAD7PAAAABBgMP08AAIAADowWGB920D8PAACAABpcPoWAiIAAHHw/xIEIgAAULBYY+OLQGP+ +49og+4wSIgAAYLBYaA1j/woAAABsEAQU63jTD9MPJECACEQR+woBIgAAUTBZeLEY615koEMIKAL4 +pgAgAhBIMPmmASA5ADSgaCEcbyQZ/iIWYBACSrAEA4gAiYoCA4gASYoAA4gACYraQPsKAiABEGAw +WX3jwCDRD8ck0Q8P6DCfog7uMJ6jDcAwnaQMsTD8pgUgABBYMJumm6dj/8kAAAAAAABsEBSUGyIW +G/oSGyABEGAw+TIAIgAAcPDzFhom4AEoMPOgByH8Almw+qIHKgUAXzD7Fg4o4AFMMCkWFPMDQQBA +AlKw+hYdIgKwgaAtEhuN0mXTzBLrIi4iSmTlcC8iSS8WFSYSFWRlbCwSHSrBBfkSGi/AEGgw9hYI +LABAazD8FhwsACBisPmcICCAAmMw9ZwACgKrYlAuEhQmEholFhf+7A8v8BBoMPZiAygAQG+w9hYS +LgAgLnAvFhH1/AAKAplj0JMXFOslmRaLGywSGhbrBP5PFAAQAkFwmB0vFhb2FgkgCAJRcJocFusX +/xIbK8AEOOD4EhwqACASsCoWGC/xByzBDPwWGSAgAlrw+xYTL0ABfDD4jEAvwAQ/4PgWCi4JADfw +LxYQYAHyJzAA+ZwBIAICe7D6IgwCAABz8PoSHSLCADZgJhIcKqEFLNAA9qYIAAEQWDD1zAsAgAIx +sPTMAAoBVDMQ+goALAABSDAMujgEqwv0qgoAEAIi8PsSBCYAAXgw/AoAIAEQeDAG/DgW6vP7dwsG +ACAzMCZgkPfLCwIAAHqw98wKADACWvD4aAgAIAJjMIrw8AQXCgMAErCawAALj4zwsd3zPAEr/68X +EIsVAsMM+sYMAAEQEDD29gAgABAwMAMmOI1BgxSCQPlpCAwAIG6w/UYBKgADU1CxIvJGACIBGn4Q +LRIbJBIZHOrU8hIaK4AEOmD26tIQAgJLsP4SECwAQGLw/OrPGAkAZnCZNPkSFCYAQDLw+BMUBgkA +UbCWUI8nKBIWJhIVBP8M/yYHIgAgHjCTHx/qvZ5g/dIAIAUQUDD+Eh0gABBYMP9mAiACAhjw+WYD +JYAEO2D5EhckCQAg8PRmASAgAhGw+RYAIgAAeLD4FgEiAAAg8Fl+HikSHSoSHCmRBS0SEfsSGigA +IFZw+BIXIIACSnD6EhYqAM1uUPksAAIAACDwbakFAAiGAElhKhIS0w8PAgBlodaLt2Sx4BTqnBzq +oC4SGi8SGC0SGy7hDfP2OSAFEFAw/dIAIAAQWDBZfgMmEhsmYBYnCv//AgAOAHu5kC0SGy4SGigS +Gf3SACAFEFAw/+IHIAAQWDD4FgAiAABhMFl99i4SGy7gFi8K/3/hCioSG4seWChSZKI6LxIYJhIT +L/I68xIYKgBft9AjMjkqEhryEhkgsQA04IqniVD96mUQAhBAMPkWBSIDAFCw+hIdKOgBTDDyFhkh +6QA2YCsSHPqhBSwAIG5wLdAAq6v13QsAgAJa8PTcAAoA61tQIxYV9+pUHAABSDD7CgEgABBQMAy6 +OASrC/SqCgAQAiLwLhIVjBbfoPN8AAwAID5w/goALAAgczD8FgQgMAJbMPP9tmAoAmMwhB2KHGP9 +cQrEDGP9VSsSGioSGyuxDVgoB2P+/QDAINEPixcsEhv7vBgiAABTMFhm2sAg0Q+MGcBw84ILAAIC +QjDwDBcAIAIQsLF38hIeAfQCPeBj/a4AAAAtEhcmEhYPAgANngz+SBQCAAB4sPkKACAUADYg8A0W +AAICSnDwD6AB6AhCcC8SFf0SCiAAEEgw+GgMDgAgf7D0jjhgIAJ78PINFgACAkpw8A+iAegIQnAo +EhJkjigqEhIpoQCxmSmlAGP+GgAlEhomEhnTDyVRDAZVDGVRHiYSGyZgBP8CAAIAnQGgIhIa8xIV +J8AEOOCIIfIiAiIAIDTw9oFdYgAAWPD3CgAiALwGECkSG4obhB8okBSnRPiKBQACAiEw+JQULAC3 +kiAc6hIuEhovEhgtEhsu4Q0k9jn90gAgBRBQMPXuDAAAEFgwWX1zLxIbL/AWJgr/dvEOKxIaK7EN +KhIbBbsMWCe0KhIbjRuKp8DA+qwgIgAAW3BYXu3SoNEPF+nkhB2KHCMWFWP+TgrUDGP+J4sXLBIb ++7wSIgAAUzBYZn7AINEPAC0SFNxA+hIdIB4Ca3D9TRQCAABbsFjnNvoWGiABEHAwnh5j+n3A8C8W +FWP6jCwSG/sKHCIAAFMwWGZuwCDRDwAKlQxj+qcAAAr1DGP6ywAALBIaLxIXLsAVLcAUK8AR/MEJ +IgAAULD+bAAMACB3cFjnEWP+uygSGykSCyaAFC8SGglmCCaEFC/yAP8CAAH/eSvQKxIV+hIbLcAE +POD9uwgAABBgMFhclPP+1GAGAiDwAAAAAAAqEhv7PAACAABgsFv3yCgSGoiB/KsRAgAAOrD7OwgB +/0gGEPoSGyIAAGCwW/eX8/59ZgAgPrAmEhuMGPthCS/wEGgw/mAVLABAbjD9ggwAARBIMPJkFCAA +EHgw9O4QC4AEPuD9xAMqCQB28P/EACoJAE7wm8Ea6YIppklj/kwAbBAIiCIrIAeVEvwgFiD/EHgw +9YEGaiABXDD7FgUgNgR7MIsS9LsaAgAAULBYJ2SLFfSiS2D/EHgwF+lxHulqLDAP/L0RAf4CMTD+ +4IAsACA/cP0WBCDuALcg/dI6IG4Cc7AOThSubrPu+hIEKgBz91AqojmaE/WsAADkADagK3JKZLCv +KnJJZKCpLCAW+hYBIB4EezD7MQYiAABQsFgnLy0gBCogFPSqCAIAYoNgCgpH+iQULACWkqArMA+K +EvWws2rgAVAw+DwQIgCumqD5EgMgABAgMG1pBQAIhgBJYYUTDGgRqFUpIAT/AgACAG+CYCkyAfUW +ACIAAFlw9zICIACiLmD1CgAiAK6GUKVqixT6tjkiAAARMNEPAAD6LAACAABY8P0SAiIAAGEwWGMP +0qDRDwDaIPsKHCIAAGCwWGXgY//XJjAOBmYJY/8MAAAAAAAAAPP/HGAAEFAwAAArvBj6LAACAABg +sFhl1WP/rCokFGP/Qy4hBx/pPP3pQR9AAXAwDO4R+zAOLgkAe7Au1iiMIBjpQfjMEQADEHAwDswC +/NYpICACSPDyCAcCAHIaoG25DgBFYwQJhgBFZQAJhgBFYfP/H2AAECAwAI8w/wIAAgCEK9CCFPYm +OSIAABEw0Q+LEfkhCS/wEGAw/SAVLABAYrD8rwwAARBAMP8kFCAAEHAw9N0QCYAEPmD8tAMoCQBu +cP60ACgJAEZwmbEodklj/pQAAACKJ/1MAAABEFgw/BIDIEACUrBYXgbz/p9iAAAisNog+1wAAgAA +YfBb9xiJMYsQ/KwRAgAAKrD8uwgB/1WGUPosAAIAAGHwW/bnpaWlaosU+rY5IgAAETDRDyu8Evos +AAIAAGCwWGWNY/6KiictoRX8+sAgQAJSsAysAazcLMxAbbkVAEVjCAmGAEVpBgmG8AWmCgAN4lDT +D9tA/UwAAAAQYDBYXeLz/hZiAAAisA2ZDGP/4tog+1wAAAAQYDBYW7fyTAAABgJZsIwUK8Y50Q8A +AGwQBCMgACQK7XQxByIhA7wi0Q8AhiCFI4Qh9ghTA2QBNDD4MwgGYAEwMKYzDjMR81IMBaABIDDz +PBoh5AIQsAQkLAQzKKMi0Q8AAABsEAiLIikgB4owlRP8IBYoIAFMMPWxSGsAAVAwKwr/+hYCIDoE +WzCLE5kV9LsaAgAAULBYJpKJFfSiX2D/EFgwF+ifLHJKZMFGJnJJ+GwAAUgANaAe6JMu4IAMlRGn +Vf1SOiBuAnOwDk4Urk6z7v8CAAoAhHdQJlI5ZGD9LyAWmBH5Cu0gLgRb8CgwEPsxCyYA6U4QvLsC +KgJYJl8sIAQoIBT0iAgCAIEDIAgIR/gkFCwAl5IgHuieHOh8KCEHjRIZ6Jn6EgMpQAFAMPyIEQAe +Antw/08UCAkASjD4ZgAq4AFQMPsiACACAnvw/08MACACSbD4PBAsBQB7sP1mAyuABD7g/GYCKgkA +XTD7ZgEiAE+aoPhBD2AAEDgwsEptqQUACIYASWH5IAQh/gJZMAy7Eatr+7wQIgBKAmCIMSYyAvsW +ACAAci4g8woAIgB+hhCjTPxWOSIAABHw0Q8AAAAA+iwAAgAAWPD9EgMiAABhMFhiLdKg0Q8AAAAr +nBj6LAACAABgsFhk/WP/1AAAAAAA8/64YAAQMDDaIPsKHCIAAGCwWGT2Y/+3KCQUY/8Giif8nAAA +ARBYMPqsICIAAGkwWF1T8/9fYgAAOrCLMP8CAAIAbarQ9FY5IgAAEfDRDwCOEf0hCS/wEHgw+SAV +LgBAfjD/iwwAARBgMPskFCAAEFAw9JkQDYAEP2D/5AMsCQBPcPrkACwJAGdwneEsdklj/pIAAAAA +AAD6LAACAABhsFv2TosQiDGaFPOsAA3ABDqg/LsIAf+FhhD6LAACAABhsFv2HaOjo0z8VjkiAAAR +8NEPjjSLN401/g9TDWQBcDD/zAgOYAFwMK7MDswR/LsMDaABbDD8zBoh5AJa8A29LA3MKPP9/2oA +IGbwK5wS+iwAAgAAYLBYZLVj/rOwSwy7EftrCAIAAFCw+7wQIAAQYDBYWu/yfAAABgJhMCxWOdEP +AAAAbBAG2iBYJmwlMBb46BcSoBAwMAamKBfoG/VVCggAIEGwCFUL+jIHJAAgPXCIUAAhBPcKASAQ +AiKw+1IBIDYEKjAAeRqIMpSwlaKbo/RWASgJAEowmDLRD9ogWCZXHegKLNJ9+tKAIgAAWrCrzAnM +Ef4wFioAIGKwGOf9HOgEHefa8OEEC8AEPuDwfxoMACBhsP3CfSoAIG7whrEuwn8P3QL9xn0mAEBB +sPTgQGYJADOwAN4R/BYBIBAIcbCbEJ2ymxBYAx2KESqifQaqAosQACEEiVEAeBqaspSQjzKZQZVA +9FYBLgkAR/CfMtEPBtgCACEEAH4aj1GYsowylPCVQJ9B9FYBLAkAczCcMtEPAABsEAjaIFgmKNSg +HOfe+ufcEqAQKDD1RCgLwAQ8oKy7+7IAKgAgUTAqon8mLO7158oQYBAYMPjn1BoAQFqw+hYAIAEQ +ODDwAQcEACAtMPAANmQAIEEwAAM8CvXMCw70EEAw+MgIAgAAULD4ghsiAABZMP48oC9QEGgw/WwA +DAAgazALgAAAEYsHM2DwgYAPkAI44NEPbBAEFeeaFue89TUCAgAgMLAlJoAkIoBnQAttCAUoIoBn +gAJj//PRD2wQBCggBSUgB/oyBS/9ECAw+yICIAIQGDD1BUECEgC+IMAg0Q8AiCkZ56v6JgsmAHzW +EAlZCSqR6CmR5P8CAAoATFZQwa//AgAIAEdakNogWFqGiyLTDw8CAAO6AWSvwIonBLsB+yYCIGAC +UrBYVDvz53gQJwA2oCigANMP0w8DiAooghD8oAciAABasP0KBCIAAFCwC4AAZa/ciSfTD2SffiqZ +FMqniplkr3QooAADiAooghD8oAciAABasP0KAyIAAFCwC4AAZa/gY/9SAADz/9VgABBQMNogWFpz +KyAi+rsMAgAAULBYW6baUPsKASAAEGAwWFyXiyLzugEP/6+e0CwgB/S9AQIAAFCw/SYCKiABZDD7 +vB8iAABgsFhj78Ag0Q8AAAAA+yAiIgAAULBYW5QqIAXB436hDGioKYsi8/8ZagBAGvAvIDrAj3j5 +6vosAAAAEFgw/AoAIAIQaDBYWt5j/9cAAPosAAAAEFgw/AoAIAIQaDBYWltj/78AAGwQCos3HedU +jDYpICEoIgv6Cv4sAEBrMPy7DAgAQFZw+SQhIBgIWjDAINEPAAAAAPADFgIAAEBwAEhhmxUuIAUl +IAf4Fggv/RAgMPwiAiACEBgw9QVBA6IBP6CJKRrnPfsmCyYAel5QCloJK6HoKqHk/wIACgBJ3pDB +v/8CAAgAROLQ2iBYWhmLIgO6AWSvl4onBLsB+yYCIGACUrBYU8/boPPnCxAjADagKLAAA4gKKIIQ +LLAH+iwAAAQQaDALgAD7rAAP5QC2oIknZJ9ZKpkUK5IJyqhkv04osAADiAooghAssAf6LAAAAxBo +MAuAAPusAA/lALagY/8sAAAAAADz/9JgABBYMNogWFoHKyAi+rsMAgAAULBYWzraUPsKASAAEGAw +WFwriyLzugEP/6+e0CwgB/S9AQIAAFCw/SYCKiABZDD7vB8iAABgsFhjg8Ag0Q8AAAAA+yAiIgAA +ULBYWygqIAXB436hDGioKYsi8/8ZagBAGvAvIDrAj3j56vosAAAAEFgw/AoAIAIQaDBYWnJj/9cA +APosAAAAEFgw/AoAIAIQaDBYWe9j/78AAGwQBCkwFglZFP8CAAAAbYZg+/r+IOsANmDz5sEUAEGC +YGiVBMAg0Q8AKiAGsKoKCkf6JAYv7wC2oIwiiicLywH7JgIgYAJSsFhTeMmtKKAAA4gKKIIQ/KAH +IgAAWrD9CgQiAABQsAuAAGWv4IknZJ+yKpkUZKCoiplkr6cooAADiAooghD8oAciAABasP0KAyIA +AFCwC4AAZa/gY/+FAAApIAawmQkJR/kkBi94ALZgiSeMIiqZFPuSCSwAQFsw/CYCIFUANqAosAAD +iAooghDaIPywByADEGgwC4AAwCDRDwAAAAAAAAD6LAACAABY8PxMAAIAAGlwWFrswCDRDwD6LAAC +AABY8PxMAAIAAGlwW/9PwCDRDwDz/6tgABBYMPP/VWAAEFAwbBAE0Q8AAABsEAgV5qAU5p4X5pyS +EvAhBAAAEEgw+RYDIAQQQDD4FgQgARBQMACqGgIiCfoWAS//EFgw+6oDA+AEOKD6FgAmACA8sPTm +axIAICCw8AAiYAAQMDCYE4kUsWbyLAwgGAI58PVcAiH+Akpw+RYEIKMANmAqUbLwYQQAARBAMPCI +GgWmATqgK3F+ZL/K2iBYXIqMEfBhBAABEGgw8N0aAgAAGrD9FgMgDQA3II8QjqIP7gGeooo3Kqww +WFMQya8ooADTDwSICiiCEPygByIAAFqw/QoEIgAAUPALgABlr96JN2SfciqZFMuuiplkr2gooAAE +iAooghD8oAciAABasP0KAyIAAFDwC4AAZa/gY/9GAACLE8CR+hICKgUAXnBYXWjRDwAAAAAAAPP/ +vmAAEFAwbBAE+OZVEMwQSDAJKSipiCiA6PiHCmIAACCwwCDRDwAAwMDVwAXkFgECAMDRGuZLASsR +qrr9poEgyBBIMG0IEC6igg4OQvjhCmH+AkpwZJCGY//owCD2IJZiAAAYsPymgSDIEEgwbQgQL6KC +Dw9C9PAKYf4CSnBkkGVj/+jAIPYgpWIAABiwGeY20w/85jYYACBO8CyWixjmNCiWi/2mgSDIEEgw +bQgPK6KCCwtC+LEJYf4CSnDKnmP/6cAg9iB/YgAAGLDA0i2mgSyigQXkFmYwMtIw0Q8A8/96b/sQ +EDDz/5tv+xAQMPP/0W/7EBAw+goCIAgQWDD85h0SAABpMFl5cWP/xt1A/OYaEAIQUDDzDgYACBBY +MFl5a8CkWFxc0jDRDwAAAAD6CgIgCBBYMPzmERIAAGkwWXljY/+OAAD6CgIgCBBYMPzmDBIAAGkw +WXldY/92AABsEAYd5ggLKxGtsyoyfxnmBhfl6IigwED5eQgAARAoMPSANGgAIE7wLDJ4/zJ7JgBY +zxBl8SssNnwrMnkrNnvdQA3kFgECACSmAA3kFiwKCf8CAAYAXGSQLzJ7wcD95fMQbwA34CIyfCoh +BI4g+gtGAB4IE/AkNnwkNntgAAQAAC42fP2vAQH+AkLwCP8C/yUEICwAPuAiMnywzP8yeyAeADSg +ycZj/7/aIFhbnmWg1yohBPoJRgASAMKwyJnRDwDaIFhc1tEPANogWF0M0Q8A+iwAAAAQWDBYXNfR +DwAAAPrSYCHwAnCwAOEE8FsaD/8QYDAMuwMLqgEq1mBZe4gkNnwkNnsqMn9j/zMAFuXJL2BgZPCC +WXA+WFtVKHDR9eXFEEQA/jApUP1okX//AgACAEIGYP8CAAQAQgZgKVD9sZkpVP0rYGBkvw0sUkCw +zPxWQC8FALcgWFrqKlZAY/73AAAc5bX+MnwgBRBQMP0yeiAEEFgw/RYAIfICaLBZePwqMn9j/rIA +AC4ye/I2fC8uALegIjZ70Q8f5akv8q7/AgAB/7mH0CVkYGP/aMCgW/8+Y/+HwKFb/zxj/38kVP1j +/3kAAGwQBBTlnvnllxuwBDyg+OV4FAAgIvAjQn+piPQwTWgAIELwKjIAeKkCKkJ7HOWPKzEE+kZ/ +KgBAYvD6NQQiAABQ8FhbR8+gKTEE+Q1GABIAwnDI2dEPANowWFx/0Q8A2jBYXLXRDwAAAAAAAPos +AAAAEFgwWFx/0Q8jRn/RDwAAbBAE+fr/IA4ANOCIIgk5AwmIAZgiiicqrDBYUgXz5UEQIwA2oCig +AAOICiiCEPygByIAAFqw/QoEIgAAULALgABlr+CJJ8uSKpkUyqWKmcmtKKAAA4gKKIIQ/KAHIgAA +WrD9CgMiAABQsAuAAGWv4NEPAADz/9dgABBQMNEPAABsEAT65RsR0AJIsAkJRwyZEaqZKJI6DwIA +DwIA/wIADABaRiAqkjlkoKsc5TEb5VQCKgkMqgoLqghYW0zwIQQAARBIMPCZGg//EFgw8qwAAA4A +NmCKogubAwuqAZoiiicPAgAPAgAqrDBYUdHz5Q4QKAA2oCigANMPDwIAA4gKKIIQ/KAHIgAAWrD9 +CgQiAABQsAuAAGWv24kny5oqmRTKqYqZya0ooAADiAooghD8oAciAABasP0KAyIAAFCwC4AAZa/g +0Q8AAAAAAADz/9NgABBQMNEP0Q/RDwAAbBAEGOTkAgNHDDMRqDMrMiAZ5O2KsSiwAPmICgoACDgg +Ago+KIIQAwI+/QoCIgAAYLALgAAiNiAMAgDRDwAAAGwQBBjk1AIDRwwzEagzKzIgGeTdirEosAD5 +iAoKAAg4IAIKPiiCEAMCPv0KAiIAAGCwC4AAIjYgDAIA0Q8AAABsEAQY5OQogjYpetAJiCgV5QMM +iBEoVrf1UrcgABAgMATkMQECABTlAMEwAyMCI0aKY//8bBAEWXUeEuT8E+TVKSKC0w8IqY4DqAqI +gAuAAGP/7ABsEAQqIgcqrBBYXB/RDwAAbBAEiCcijBDaIFhb+2ihAdEP2iBYW/US5O0LqBH0oDti +ACBAsAzqMCsihSuyACKs//y7CAIAAFCwWXpjHOTlKsJ/8CEEAAEQWDAAuxoLqgIqxn9ZepLRDwAA +AAD6CgcgARBYMFhb0ywifywmg9EPAGwQBCYiBw8CAPZsECIAAFDwWFw4/DwAAgAAaTD+XAACAABa +sP8iACIAAFGwWFt80Q8AAABsEAT65J0YJgE8MBjknPYmAigAIFZwKZCA9CYDKAkAQPCYIAlZDJkh +0Q8AABLkwQPoMATuMAWxMJMglCGVIhLkvRPkfIQgBDMCkyAS5LvAMCg3QCg3RCg3SCg3TCM9AXIz +7QMCABLktcAwkyDHLxPktAMjAxLktIQgBDQBlCAS5LKEIAQ0AZQgEuSxhCAENAGUIBLkr4QgBDQB +lCDHL8AxAyMDEuSshCAENAGUIGP//BLkqoMgAxMUDzMRkyAS5KfAMCMmAFf/2RDkppEAkgGTApQD +EeSkghAB6jCiEQHwMcBABOQWAAIAEeSgghAjGgADIgKSEBHkncAhkhAE5DGEA4MCggGBAADSMAEj +AAAAABDkmJEAkgGTApQDEeSWghAB6jCiEQHxMcBABOQWAAIAEeSOghAjKgADIgKSEBHkjsAhkhAE +5DGEA4MCggGBAADTMAEzAAAAABDkiZEAkgGTApQDEeSHghAB6jCiEQHyMcBABOQWAAIAEeR8ghAj +SgADIgKSEBHkf8AhkhAE5DGEA4MCggGBAADUMAFDAAAAAGwQBCQgFKNEJCQU0Q8AAAAAXJQBXZQC +XpQDX5QAQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AFyQAV2QAl6QA1+QAFMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAACclAAdkAGdlAKelAOflAQIlAUJlAYKlAcLlABDAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAnJABnZACnpAHHZADn5AEeJAFeZAGepAHe5AAUwAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAANyUAB2QAd2UAt6UA9+UBASUBQWUBgaUBweUCAiUCQmUCgqU +CwuUAEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADckAHdkALekAsdkAPfkAS0kAW1kAa2kAe3kAi4 +kAm5kAq6kAu7kABTAAAAH//24ADSMRD//goAAAAAAB//9ygA0zEQ//4KAAAAAAAf//dwANQxEP/+ +CgAAAAAAAPQwCgAAAAAA9DAKAAAAAAD0MAoAAAAAbBAGiSKMM/WQmmz4AWAwGOG+b8RqDMQRqEQt +Qjr/AgACAETHYCtCOWSwfsDA+iIAIAAQSDD5FgAgBBBoMPkWASAAEHAw+RYCIAAQeDBYWV8uIAYa +4a78IgIgAxBYMPtGOSABEGgw+jYCIAICc7D+JAYsCQBrMPwmAiAAEBAw0Q8rIAb/4aIQARBQMP82 +AigJAFJw+CYCIAICWvD7JAYgABAQMNEPwCDRDwArzBj6LAACAABgsFhd5cAg0Q9sEAiIIiogBywi +FPWBBWogAVAwHeGQZMDSGOGMLdCADKYRqGb7YjogbgJrcA1NFK1Nst3/AgAKAILu0CliOfucAAEE +ADZgLoJKZODfKYJJZJDZKiAUCqSH+iQULACAEqCNOfg8EC7gASgw/W0UAgCWG6D4QRVgABAoMPpM +/yIAAErwbakFAAiGAElhicAa4XL8TP8iAABC8PzPEQ+ABDpg+pkCDgkAczD+tgEqACB+8A8CAA8C +AA8CAG3ZB/mGBiCAAkIwiDGbEIcy9oFmYAAQSDD5FgEiAL8GEIoRqkqwqvpmOSIAABFw0Q8AAAUL +R2iyGYon+0wAAAAQYDD6rCAiAABpMFhWB9Kg0Q8AwCDRDwAAAAD6LAACAABY8PxMAAIAAGlwWFrF +0qDRDwDaIPsKHCIAAGCwWF2WY//X8/7+YAAQSDAAACusGPwsAAIAAFCwWF2PY/+8AAAAAAD+IQkv +8BA4MP8gFSYAQD6wB60MLSQU9P8QAAEQaDD3lAMvgAQ7oP8KAC4JAHuw/5QALgkAa7CekS2GSWP+ +xY4nnhOF6fnpFC/AEHgw9+EVIEACU7D3FgQuAEB+sP8WBSnABDkg+JkMACACKXD15gkmACB98PiZ +MgCAAjnw+eUUKgB8OVD5FgIqlAA+IAWJCCmc8P8CAAoAQk3Q+EEiYgAAevAuTP9t6QUABYYAT2GJ +of+pBCgAIE4w/xYCIeACSnD/AgAGAGA+UJmh+RICIgAAKnBlnllgAIf6LAACAABh8Fvu0IgxKxIA ++hYBLcAEOqD8uwgB/0UGEPosAAIAAGHwW+6fjRH9rQgCAAARcK1NsN0tZjnRDwAAAAAFdwz3TxQC +AABK8G35BQIFhgBJY4kV/0UMDgAgPvD5nEAgHgA9YLBebekFBAmGAE9lhRUvqQQHiQypVSVcMPWm +AS3TALfgjhXA8P+lBCCAAnOwnqGeoPP9u2AAECgwjxSOEw9VDJXpY/7/hRX5EgIggAIpcJWhY/8+ +AGwQBB7g2iwgB4ngwPP0kNNsIAFgMCoiEwrtUf8CAAAAbodgHeDOCshR/MsRAABthiCtuymyOv8C +AAIAd8ZgLbI5ZNDkLCEHGODKDAxKDMwR+ODJHAkAQzD81gAqKAFQMPwiACvABDqg+tYJIDAQUDCa +1/rgwhmABD8g+OC/HAkAQzCY1ZrS/NYEKAkAfnD51gEgGBBgMPzWAyAAEEgwmdiZ1hjgty+2OS8i +EynmAPoiEC4JAEPw/iYTIgAAWLBYqjMFDUdo0hiKJ/sKASAAEGAw+qwgIAEQaDBYVVbSoNEPwCDR +D4sisZ395gAgKgA24AUOR2jiSMAg0Q8AACgaAAiqAiomE2P/GikqAAmqAiomE2P/HAAAK8wY+iwA +AgAAYLBYXN9j/8gAAIoiZa/BK8wY+iwAAgAAYLBYXNlj/7CMJ/3JFC/AEHAw+sIJIEACWzAOuwH7 +vEAgIAJrcP3FFCHgAlKw+sYJKgAY2pAvwRX54IUaACBT8JrJmaCIIMCR8uCCGYAEOiDypgIoCQBK +MPimASAAEBAw0Q8Z4HqZoIggwJHy4HkZgAQ6IPKmAigJAEow+KYBIAAQEDDRD2wQGJIQjiAV4HKJ +I4shiiIqFiIrFiT5FiMgARAgMPQWByAAEEAw+BYFIAQQYDD8FgogAxBoMJ0Z9RYGIAIQeDAvFgj1 +4GQQChB4MP8WECALEGgw/RYRIAwQYDD8FhIgCBBAMPgWDiAJECAw9BYPIAcQSDD5Fg0gBRBYMPsW +CyAGEFAw+hYMIA0QWDD7FhMgDhBQMCoWFPTgUBAPEEgw+RYVIAQQQDAoFgSGFokVJ2F+ImF/B5ko +KxIk/BIiKAAgTLD4QuQoYAFMMAOZCv6SACIAAFOwJmI+LRIj/1CALgAgQ7ALYACOFwfuKCwSJP0S +Ii4AIHCw+ELlLmABcDAD7gqO4C9QgfoWFiIAAFqw+hIjLgAgQ7ALYACOGAfuKCwSFv0SJC4AIHCw ++ELmLmABcDAD7gqO4C9QgvoWFyIAAFqw+hIiLgAgQ7ALYACOGQfuKCwSF/0SFi4AIHCw+ELnLmAB +cDAD7gqO4C9Qg/oWGCIAAFqw+hIkLgAgQ7ALYACOGgfuKCwSGP0SFy4AIHCw+ELoLmABcDAD7gou +4gAvUIT6FhkiAABasPoSFi4AIEOwC2AAjhsH7igsEhn9EhguACBwsPhC6S5gAXAwA+4KjuAvUIX6 +FhoiAABasPoSFy4AIEOwC2AAjhwH7igsEhr9EhkuACBwsPhC6i5gAXAwA+4KjuAvUIb6FhsiAABa +sPoSGC4AIEOwC2AAjh0H7igsEhv9EhouACBwsPhC6y5gAXAwA+4KjuAvUIf6FhwiAABasPoSGS4A +IEOwC2AAjh4H7igsEhz9EhsuACBwsPhC7C5gAXAwA+4KjuAvUIj6Fh0iAABasPoSGi4AIEOwC2AA +jh8H7igsEh39EhwuACBwsPhC7S5gAXAwA+4KjuAvUIn6Fh4iAABasPoSGy4AIEOwC2AALhIQB+4o +LBIe/RIdLgAgcLD4Qu4uYAFwMAPuCo7gL1CK+hYfIgAAWrD6EhwuACBDsAtgAC4SEQfuKCwSH/0S +Hi4AIHCw+ELvLmABcDAD7gqO4C9Qi/oWICIAAFqw+hIdLgAgQ7ALYAAuEhIH7igsEiD9Eh8uACBw +sPhC8C5gAXAwA+4KjuAvUIz6FiEiAABasPoSHi4AIEOwC2AALhITLBIhB+4oLRIg/1CNLgAgcLD4 +QvEuYAFwMAPuCo7gmhP6Eh8iAABasPsWAS4AIEOwC2AALhIUjBEH7igtEiH/UI4uACBwsPhC8i5g +AXAwA+4KjuCaEvoSICIAAFqw+xYjLgAgQ7ALYAAuEhUsEiMH7iiNE/9Qjy4AIHCw+ELzLmABcDAD +7gqO4PoSISIAADqwJxYi+O4IAgAAWfALYACOESoWJCkSEi0SFY8VKxITLBIU+BIRICACe/D/FgUg +IAJa8PsWEyAgAmMw/BYUICACQjD4FhEgIAJrcP0WFSAgAkpwKRYSjR+JHIgbjB6LHf8SECAgAkIw ++BYLICACYzD8Fg4gIAJa8PsWDSAgAnvw/xYQICACSnD5FgwgIAJrcJ0fiRaNGY8a+xIHICACKXD8 +EgggIAJrcP0WCSAgAnvw/xYKIIACITD/EgQgIAJjMPwWCCAgAlrw+xYHIBACSnD5FgYh/gJ78P8W +BCvvALfgiRCLEo8TjpCNkYyS+JIDLgAge7D+lgAsACBXcP2WASwAIDsw/JYCKAAgWjCYk9EPAABs +EAQpIhUr+oDTD/kJRQA3EEAw+YwMCgAgEnD7pBAgIAIgsPqsESwAXMoQwLBZavMsIhUrIhTx1AQN +0AQ/IP0mEiIAAECw/LsYAAMQSDD7JhMgAhBQMG2qDI6EBO6O/oYEIAgCQjAPAgDTD9MPbZoh+YIE +ICACQjCKgYuCjIMEmY4Eqo4Eu44EzI6ZgJqBm4Kcg/tMAAIAAFCwW/6diiCIIokhjyMEiI4EmY4E +/44Eqo6aIJ8jKSYB+CYCIgAAQLAZ3wsAAoYAQ2HwCRcACxBIMG2aAgAIitEPAAAAAAAAAPsKACAQ +AmMwWWrE+CwAAAQQSDDTD22aIfmCBCAgAkIwioGLgoyDBJmOBKqOBLuOBMyOmYCagZuCnIP6LAAC +AABZMFv+e9pA8/8AYDgQYDAAbBAGKiIV+CIUIEAQMDAPAgD6SggIoAFUMPlmDAoAA6KQKIwBKCYU +KiYVBioM+qxQKgB7tRD7PAACAABhsFlql/gsAAAEEEgwDwIA0w9tmiH5ggQgIAJCMIqBi4KMgwSZ +jgSqjgS7jgTMjpmAmoGbgpyDJSwQ+iwAAgAAWXBb/lgGRwz/AgAMAFdF4PY0CAIAAFFw9nwAAAAQ +GDD0FgAiAABBMPYIFgAEEEgwAEpnBAiGAEplAgiGAEpjAAiG8AqgAgAAQLBtmiH5ggQgIAJCMIqB +i4KMgwSZjgSqjgS7jgTMjpmAmoGbgpyD+iwAAgAAWXBb/jv6XAAAAgIY8PZswCCAAiEw/22aYgAA +QTCLEPo8EQIAAFFw/HwMCgAgXzBZal/RDwAAAAD7PAACAABhMFlqWtEPpjycEPP/0GAAEBgwAAAA +bBAEGN6gGd6eGt6cE96fkyOYIpkh+iYAIAAQWDArJhUrJhTRDwAAAGwQBt4g9OIQIgAAYTAb3o/3 +QgciAABR8P9c+iATEEAw80IVIgAAEPD3cg4qABRD0BjejZoTCPgKiICcEp4RCoAAkxAqspX8XAAC +AABYsFluS2SmN/NGFSAAEBAw0Q8AAAAAK+ITC5tS/hYBL+gANuAa3nfzFgAiAABYsPqityIAAGFw +WW4+ZKXKGt5w2yD6orkiAABhcFluOWSnUBrebNsg+qK7IgAAYXBZbjT0pwRjfBAwMBreZtsg+qK9 +IgAAYXBZbi5kp1oa3mHbIPqivyIAAGFwWW4pIyqA/wIAAgAgHfD/AgAABJsqoCsw2cFY/wIABAL0 +qtBptyElNNmLEPtGFSAAEBAw0Q+TECqyjfxcAAIAAFiwWW4ZZKenixD7RhUgABAQMNEPAJMQKrKb +/FwAAgAAWLBZbhFlrxf6HAAACxBYMFimjPsKASAAEBgw+rM4ADEANqD6EgIiAABZsFlqksOw/N5B +EgAAKrD6CgUiAABpcFlxV8hZHN48jREMXDYs1hhlNLWNEP1GFSAAEBAw0Q8uQG5k7rqTECqysfxc +AAIAAFiwWW31Za6n+hwAABYQWDBYpnD7CgEgABAQMPqyOAAVADag+hICIgAAWbBZanYsfQMqxShl +JGGNEP1GFSAAEBAw0Q8AAJMQKrKj/FwAAgAAWLBZbeFkos8a3hTbINMP+qKPIgAAYXBZbdxlrkL6 +HAAABRBYMFimV/sKASAAEBAw+rI4BVgANqD6EgIiAABZsFlqXCxAb/8CAAACoW8QZKU6ihP7CgUg +DRBgMFimMtKg0Q+TECqyqfxcAAIAAFiwWW3GZa6y+hwAABIQWDBYpkFko8UrQG7/AgAABBSq4PoS +AiIAAFmwWWpHLEIWixD7RhUsAwBTMPxGFiAAEBAw0Q+TECqyp/xcAAIAAFiwWW2yZKJEGt3l2yAP +AgD6oqEiAABhcFltrWWuTvocAAAOEFgwWKYoZKNh+hICIgAAWbBZajErfQIqtRSLEPtGFSAAEBAw +0Q8AkxAqspn8XAACAABYsFltnWSiRxrd0Nsg+qKlIgAAYXBZbZhko9Qa3cvbIPqikyIAAGFwWW2T +Za3p+hwAAAcQWDBYpg9kovwrQG5kt5Ma3cGLEvqi3yIAAGGwWW2KZab2K0BvwMgMuwIrRG+LEPtG +FSAAEBAw0Q8AkxAqsq/8XAACAABYsFltf2SiDxrdstsg0w/6opEiAABhcFltemWtgvocAAAGEFgw +WKX1ZKKVK0BuZLcbGt2nixL6ot8iAABhsFltcGSnKytAbywK/Qy7AStEb4sQ+0YVIAAQEDDRDwCT +ECqyl/xcAAIAAFiwWW1lZKHXGt2Y2yDTD/qiiyIAAGFwWW1gZKMqGt2S2yD6oqsiAABhcFltW2Ss +Pxrdjtsg+qKzIgAAYXBZbVZlrCzApfzdkRAwEFgwWXCoGt2GixL6os0iAABhsFltTmWk5IsRK7IT +C5lSyJlokgf/AgACARaeYI0RjBAr1hP8RhUgABAQMNEPkxAqsof8XAACAABYsFltQGShixrdc9sg ++qKJIgAAYXBZbTtlrIj6HAAAAhBYMFilt2ShmxrdaosS+qLfIgAAYbBZbTNlrGeKE/sKAiANEGAw +WKWW0qDRDwAAAAAAAAD6HAAADxBYMFilqGShYvoSAiIAAFmwWWmxixAsfQIqxRX7RhUgABAQMNEP +AAAAAAD6HAAAERBYMFilnGShMi1AbmTVpylAb/8CAAH+AvpQ/wIAAf3+/lD6EgIiAABZsFlpny1C +F8Ow/N1QHAMAV3D9RhcgBRBQMFlwZIsQ+0YVIAAQEDDRDwAA+hwAAAoQWDBYpYZkoNouQG7TD2Tl +B/oSAiIAAFmwWWmNL0E0/wIACgEMU9CKE/sKCiANEGAwWKVj0qDRDwAAAPocAAAVEFgwWKV2ZKCa ++hIBIgAAWTD8EgIiAABpsFik+4sQ+0YVIAAQEDDRDwAAAPocAAAJEFgwWKVqZKBqKEBuZISrGt0d +ixL6ot8iAABhsFls5WWiwCtAb/0SACABEGAw/UYVKgkAZvD7RG8gABAQMNEPAAAAAPocAAABEFgw +WKVYyqIa3QyLEvqi3yIAAGGwWWzVZarvihP7CgEgDRBgMFilONKg0Q/ApfzdDhAwEFgwWXAjwCDR +DwAAAAAAAPoSAiIAAFmwWWlS+wowIgAAarD83QUQBRBQMFlwGfoSAiIAAFmwWWlL/wIABAGKBqDH +L9EPAAAA+hwAAAgQWDBYpTj7CgEgABAQMPqyOAApADagLEBuDwIAZMPkGtz0+xICIgAAYbBZbLBl +osItQG/A6A7dAi1Eb2UvbY8Q/0YVIAAQEDDRDwD6EgEiAABZMFilLWWvmisw2WP6BgAAAAD6HAAA +EBBYMFilHmSvOihAbtMPZINW+hICIgAAWbBZaSUpQhiLEPtGFSgDAFZw+UYYIAAQEDDRD/ocAAAD +EFgwWKUQZK8CGtzEixLTD/qixSIAAGGwWWyM89zOERYAtqCLESuyEwvJUciZaJIH/wIAA/+QHmCO +EfwSACwAQB7wLeYT/EYVIAAQEDDRD2UuuY8Q/0YVIAAQEDDRDwAAAAAA+hICIgAAWbBZaQIqRTSC +EPJGFSAAEBAw0Q8AAAAAAAD2cwgAABBYMPo8AACAEGAwWWhm+hICIgAAWPBYpUUjKoCjcysw2cDE +DLsC+jT7KuABXDArNNlj+P8jKoCjcygw2cCS+hICKAkASjD4NNkiAABZsFlo6MOw+jTYLOABVDD8 +3J0QBRBQMFlvrWP4x4oSWVAp+wowIgAAarD83JcQBRBQMFlvp4oSWVAj/KwAA/0QWDD6EgIqACBd +8FlsS2ShqsCi/NyOEDAQWDBZb53HL9EPGtx5ixL6osciAABhsFlsQmWuC4sRK7ITC8lRaJEKaJIH +/wIAA/79HmAe3IEDvQH+EgEsCQB3cIwQLeYT/EYVIAAQEDDRD4oT+woJIA0QYDBYpJjSoNEPAAAA +AAAAAPocAAAEEFgwWKSqZK1qjRH83HEQBRBQMP3SEyAwEFgwWW97GtxZixL6osUiAABhsFlsIfPc +aRCyALagixErshML6VHImWiSB/8CAAP+up5gjhH8EgAsAEAe8C3mE/xGFSAAEBAw0Q8AGtxIixL6 +os8iAABhsFlsEGWtRYsRK7ITC5lSaJEKaJIH/wIAA/6aHmAS3FKIEf4qgCIJABLw8oYTLgAgcfAt +4NnA8fwSACwJAH9wLeTZ/EYVIAAQEDDRD4oT+woIIA0QYDBYpGLSoNEPIyqAo3MrMNnAwQy7AgsL +Rys02WP3QQAAGtwnixL6osciAABhsFlr8GWsxIsRK7ITC+lRaJEKaJIH/wIAA/5ZnmAe3DOMEQO9 +AQ7dAv3GEyAFEFAw/NwvEDAQWDBZbziLEPtGFSAAEBAw0Q8jKoCjcysw2cDIDLsCCwtHKzTZY/bW +AAAAAAAA9nUIAAAQWDD6XAAAgBBgMFlnzMFg+hICIgAAWXBYpKorMNkGuwL6NPsq4AFcMCs02WP2 +nIoT+woHIA0QYDBYpC/SoNEPihP7ChAgDBBgMFikK9Kg0Q+KE/sKCiAMEGAwWKQm0qDRDwCKE/sK +CSAMEGAwWKQi0qDRD4oT+woIIAwQYDBYpB7SoNEPAIoT+woSIAwQYDBYpBnSoNEPihP7ChEgDBBg +MFikFdKg0Q+KE/sKBiAMEGAwWKQR0qDRD4oT+woHIAwQYDBYpAzSoNEPAIoT+woGIA0QYDBYpAjS +oNEPAAAAbBAEJCIQKyAHKSIT0w/0QHdqIAFcMCwwGC0wGf4wGi2ABDsgDcwC/TAbLYAEOyD6Ihcs +CQBzMAjMEQ3MAvrJB3ACAmqwLSYXLjAQLzAR+DASL4AEO6AP7gL/MBMvgAQ7oAjuAgjuEQ/uAmjg +If/bzxAUAEJwD58BLyYTKEAFKQqV/wIABgB2ThDAINEPAAAqMBQsMBX9MBYrgAQ6oAyqAvwwFyuA +BDqgDaoCCKoRDKoCaKC4jSf+2RQvwBB4MPrSCSBAAmNwD8wB/MxAIEACc7D+1RQhwAJSsPrWCSoA +BeKQKNEVqoqa2R3bstmg8A0HAAIQYDBtygIASWEf25CfoI4g+O4RAAIQeDAP7gKeoS0wFC4wFfgw +Fi2ABD9gDt0C/jAXLYAEP2AI3QL/26IdgAQ/YP+mAiwJAHdw/aYEIBACYPDxDBYAMAJKsAAJii8i +E44iKAqACP8C/yYTLx4At6DaIPu8GCIAAGCwWFe7Y/8J2kBYwa7AINEPAABsEAYc246NII42LzEL ++DAfIAUQUDD4FgAgMBBYMFlujiQiGSwxC4gshUeJSvrbhRgAIGIw+CYMIAAQWDD1Ug4gNACScPtG +FCwJAFZwnUrwAAtgABBYMAAAAAArQhT7PCAqACBZcFlnEy5CFC0xC67dLUYUKlAELFAF+1AGK4AE +OqAMqgL5UAcrgAQ6oPjbbhoJAFqwCKURCVUC/NtrFABARXD1XAMv/BBAMPhVAQAwEFgw+goFIgAA +cXBZbmcpIhQoMQupiCgmFCtCFC9cMH+xA8Ag0Q8c212KSgyqAfpGCiIAAFCwWLxH+iwAAAAQWDD8 +CgAgAhBoMFgBrMAg0Q8AbBAGHNtTjSD0IgcgBRBQMP4yBSAwEFgw9QVHAAEQQDD0SRQh/AJ5cPQW +AC4FAH4wWW5JiSL32z8QrwA2YP8CAAIAURlgiCeMiPqBFS/AEHgw+YILIEACcjAP7gH7iRQqACBy +sPqsQCYAjeZQKQqg+bsICAAgTzD7hRQqAIrOkP8CAAYAj9ZQmYjZwPAHBwIAAEMw8AigAAoQUDAA +SGEASGEASGEASGEASGEASGEASGEASGEASGEf2wJtqgUAA4YASWGfwI4gHdsj+O4RAAoQeDD9xgIu +CQB7sP7GASAAEBAw0Q/AINEPACggBxna6wgIQfoyBSfABDogqWYpYjokrB8ERBR0k2suYjlk4GXw +BwcCAABDsG1JAgBIYRva5JvgiSD4MgQgQAJg8P3a4xAgAluw/eYCKYAEPmD65gMoCQBNMPnmASIA +AFCwC4AA9GY5IjoAOWCKJ/sKCiAAEGAw+qwgIAoQaDBYT4LSoNEPwCDRDwDaIPuMGCIAAGCwWFcX +Y/65wLCbi/P+/mIAAGJwAAytDP3tDADgEHgwr92diGP+5i/sQJ+IY/7eAAAAAAAAbBAEhycf2t8q +eRT5cRUvwBBwMPhyCCCgEGgw/HILKgAgarD7fCAqADvWUA67AauZ+ZxAINwEQzD6dRQqACBqMPqT +bHIAADIweaF2mnjwDwcCAAA5sABHYQBHYQBHYQBHYQBHYQBHYQBHYQBHYQBHYQBHYRfap5dghSCT +ZfRmBCAKEDgw8trIFYAEPWDyZgIkCQA9cPVmASIAABGw0Q/AINEPwICYe/P/o2IAADMwAAAImgz6 +ugwA4BBgMKyqmnhj/4osvECceGP/ggAAbBAEx48IWAMIOAIISAOoaPBxBAIAIECwAiIYojLRDwBs +EAQEOAMIWAOoaPBxBAIAIECwAiIYojLRDwAAbBAEBDgDCFgBCEgDqGjwcQQCACBAsAIiGKIy0Q8A +AABsEAQFSAMIOAEIWAOoaPBxBAIAIECwAiIYojLRDwAAAGwQBCMiECsgB9MPKDAF/QqLIJIQSDAP +AgD7C0EAbAhKMCwgaP4KgCBWCGswKSITeJ8gcJcCeZcf/9qKEGQAPnAu+r8OngEP7gH+JhMgABAQ +MNEPwCDRDwDApfzaghAwEFgwWW1/2jBYwNbAINEPjSf42RQvwBBIMPrSCSBAAntwCf8B//xAIEAC +QjD41RQhwAJSsPrWCSoABvqQLNEVCsoIKtYJH9pm2aDwDwcAAhBoMG3aAgBJYR/aRJ+gjSDHj/jd +EQACEHgw+KYELAkAf3CdoSkiE4giHNpa/KYCKAkAdnD5JhMvbQC2IAIqAvu8GCIAAGCwWFZ7wCDR +D2wQBBPaWgMiAtEPAGwQBCcgB4giGdok9iIQJiABPDD1gm5rwAQ54AmqCCiiOtMPDwIA/wIABAEv +xiAkojn82icSVAA1ICUiE40p+yIKJAgBLDAMVQolUoD9uwwAYAIpcP8CAAoA+C7QKyAWKAr/eLES ++iAHIAAQYDBYVf782hgSJwA2oCchBxjaDAcHSgx3EQh3ApdAjSAb2jYf2gr43hEABRA4MP9GAi4J +ADuwnkEqIhMpIRr42i8aCQBfcPqPQApKAVAw+UYGK2AEOqD8/goPoAQ/4P7igC4JAFfw+0YELgkA +R/CfRw5eDP5GBSAgAnOwnkOLKSoiFvW7CA/gEEgw+yYJKgAgKrD6JhYmAMJNEI802nD82hgQARBA +MPn8ASAAEHAw+Y44ADAQWDBZbQ0b2gQpTCD4+oAgABBgMPALBwBAEHgwAElhAElhAElhL0QgLEQl +LEQmLEQnLEQkKEQhLWISLUQ7DY0ULUQ6DY0ULUQ5DY0ULUQ4KiIXKkQ/CooUKkQ+CooUKkQ9CooU +KkQ8ijT5+v8g/xBwMPg8GCBQAnkw/dn2EABhgqAa2ekACIgAD4opRDMtRDEuRDAqRDIqMgQsRCMq +RDcMjxQKjhQvRCIuRDYOjhQuRDUOjhQuRDTwCwcAgAJpMABNYSsgBwsLQR3ZrAy7EQ27CCe2OSsg +FikK/3mxCvogByAwEGAwWFWCiDRogCeKJ/sKAiAAEGAw+qwgIAIQaDBYTlQrIhMs+n8MuwH7JhMg +ABAQMNEPHtnQLSITDt0CLSYTY//IAAAAAAAA+iwAAgAAWXBYVaf82Z8eBQA2oGAAJo9vGNnAsf// +Zg8uCQBH8C9EMw+PFC9EMg+PFC9EMQ+PFC9EMGP/McAg0Q/aIPwsAAAwAlnwWFXSwCDRDwDaIPt8 +EiIAAGCwWFXNwCDRD2wQBCsiFSoiFAUDR/uqDAIOADjgZKB0LCAHG9l0DAxBDMkR+CEHKAAgXnAt +kjoICEr8iBECwAE7YCuSOR7ZcR3Zi//ZchBPADbg/NmgGAkAcjCYsPgiACwJAG6w/bYFIAgQcDCe +s/+2AiACEHAw+I8RCAkAYjD4tgQuCQB38J+xLpY5LSIVCt0ILSYVaTIQwCDRDwAAiSLJnmgyLcAg +0Q+KJ/sKASAAEGAw+qwgIAEQaDBYTgTSoNEPK8wY+iwAAgAAYLBYVZppMtGMJ/3JFC/AEHAw+sIJ +IEACWzAOuwH7vEAgIAJrcP3FFCHgAlKw+sYJKgAY2pAvwRX52UYaACBT8JrJmaCIIMCR8tlxGYAE +OiDypgIoCQBKMPimASAAEBAw0Q8Z2TyZoIggwJHy2WgZgAQ6IPKmAigJAEow+KYBIAAQEDDRDwBs +EAQa2WIpIhMY2WEsIhT7MQsoAEBWcCkmE405KiIR/YhxfAAgWzD8JhQglAA2oI2sfdc4KCISwLD8 +CgAgAhBoMAuAACsiFSoiFBnZUguqDCutQPzZURoADt5Q+sMVcAAQSDD5JhEiAAAScNEPwCDRDwAA +APosAAAAEFgw/AoAIAIQaDBb/4zAkPkmESIAABJw0Q8A/NlCEAIQUDD+IgAgMBBYMFlsL/osAAAA +EFgw/AoAIAIQaDBZbHbAINEPANogWLoTY/98AGwQBi4gBSgKdP/ZNBoBm/YQGNkxLiITCO4C/iYT +IgGjN5CMLIk2KzAg+jEKIIsQQDD7C0UOAWPiUC0gaPoKTgAxECAw+qwDL/wQSDD5qgEGAI5HUPrM +CAAiEHAw/CYMICEQaDD9sRJwJRBgMHyxCnSxB/8CAA4BnXLQKjAwKDAx+TAyK4AEOqAIqgL4MDMr +gAQ6oPXZExoJAEqwCKoRCKoC+nhYDgFzrpD6iBEKoAFQMAiqAhXZDChScyVSgKqICYgRqFUqXIAp +oAUoCpn/AgAOAWHCUP2xdHAEECgwfLFsiKwFiAKYrH2xBXyxAn65JikwOCYwOfgwOimABD5gBpkC +9jA7KYAEPmAImQIImREGmQKxmSkmF/omESYASObQ/wIABgCBptD/AgAGAODu0P8CAAYA8PbQKxAA +ZbHcLCITD8wC/CYTIAAQEDDRDykwI8CBCYk5KaRBKKBB+BQAIQIIYvBj/4AAAAAAAAD5CgMsfAF0 +MP8CAA//bm5QKDAkKTAl/TAmKYAEOiAJiAL5MCcpgAQ6IA2IAgiIEfmIAgAIAnKw8/6tagUAQ7AA +KTAh/wIAAf+2flAsMDwuMD0rIhD9MD4tgAQ7IA7MAv4wPy2ABDsg/bITLAkAazAIzBEOzAJ80QIs +thMsMEAuMEH9MEItgAQ7IA7MAv4wQy2ABDsg/bIULAkAazAIzBEOzAJ80QIsthSOrP3YtB4JACuw +nqwtJhJj/xAoMCH/AgAAAGfiECkwJCswJfwwJimABD5gC5kC+zAnKYAEPmAMmQIImRELmQJlkKUr +MEwsME39ME4rgAQ+4Ay7AvwwTyuABD7gDbsCCLsRDLsCZLCALCIQLMIYe8N3K6YSKDBIKTBJ/DBK +KYAEOiAJiAL5MEspgAQ6IAyIAgiIEQmIAiimFC4wNCgwNfwwNi+ABDug/diMHgkAQ7D4MDcvgAQ7 +oPzuAgAAEEgw+aYTL4AEO6D5phUuCQBDsJ6tLSYSY/5MAAAZ2IEpJhJj/kEAAAAAAAAA+iwAAAAQ +WDD8CgAgAhBoMFlrrsAg0Q8AG9h4KyYSiqcpPCDTD/qiDiADEGAwbcoFAAmGAEphLCITD8wC/CYT +IAAQEDDRDwAA/NhtEAUQUDD9IgAgMBBYMFlrUSsgBSwKeHy5m2P/qwApIhFkkEuJl4me+ZwwIAYQ +WDAqPCBtuQUCCoYASWPAINEPAAAAAAAA8/0kb+oQUDAc2FouXf/94IUgAhBQMP7iICAwEFgwWWs8 +Y/9LKiIZY/9jKSIZiZcrMQuJnr+7C0tL9b+tYGACSnBj/z5sEAgX2EsqCgX82EoQMBBYMPVysSIA +AGkwWWssKHJO9goAIfkANiCSFBfYQ/cWBiABEDgwLFJZLcEEjsD73P8v5wE0MPzyEQnABD7g/8UF +KAAgT7ACkgwAAovywQMqwAEwMAeqYPICRg4qATqgDPgRCJgMAgiLwKAHqmJvrnh/uQTIIXohLxjY +IxLYKSiCcwn5EfIiqygAIE6wqYgJiBGoIv8CAAYAo5yQiScqmRRkoG+KmWAAbAn/Ea+v/1gUCcAE +P2D+iBEOACBLsPjuDA6AAXww8PEEAfgCc7CI4PB7Gg//EEgwCbkDCYgB/8EFKgkARvCb4I7ALcEE +sf8PD0//xQUgIgRr8LDbDLkR8/9daAAgT7DAoCrFBfP/6mAAEHgwwKAqrChY87KMFIsq/6wADgBd +4tD/AgAOAFmikBzX/40g/iAFIAUQUDD0FgAgMBBYMFlq3hnX9v0iCC+XEFAwKiQFKZKx+RYFL5YQ +cDD+JAUgkgC3YIss+RYFIFoAfvArIhIukmsLikT6qg8AABBgMP6qCgABEGgw+qIAK/ABXDBYS97A +8C8mEooViyAuIgcc1+D4CgAvwBB4MPgmDCBAAmuw/MKeLABAf3D45RQggAJrcC3mCQy7DP3mCCAA +EGAw+qJZIAEQaDBYS8wd19Et0k6xZv8CAAv/Hm2QYAAcAAAAAAD6CgIgMBBYMPwSBiIAAGiwWWqt +iRVj/1nRDwAAbBAEiif1IAciAABJcA8CACipFPeiDiQgASwwDwIA86IJIfIANiAJCEf/AgACASWa +IPzXuxAwEFgw/aICIgAAcLD/IgAgBRBQMFlqmPzXthAFEFAw+wowIAQQaDBZapMY12MMVBHTD6hE +KUI6/wIABAD2wmAmQjlkYeL816sQBRBQMP0wACAwEFgwWWqIKTAAw6T/AgAGAMNWUCo9BiWgAcOw +/NeiFMABLDD6CgUiAABpcFlqfh7XVR/XnishBy0gByohCPjXnBAArgVg/wIAAgCcAWD8CgAkAJgF +YPsLSggCAWww+pkQC8AEPuD9DUEKCQBO8PDdEQoJAEbw+2YAIgAASPD4IgAqCQBqsP9mBiAwEGgw +/WYDKgkAerD+ZgIgBBBYMPjNEQACEHAw+mYEIAAQUDD6ZgUpgAQ6IPpmBygJAFow+GYBIEACWbAC +CYYAS2MACYbwC6AABBBIMA7dAv1mCSCAAlmwCAeGAEtpBgeGAEtnBAeGAEtl+UY5JABXBWAU123/ +IggvlxBIMCkkBfNCiS+WEEAw+CQFIOgAt+CLLH+3KCsiEi4yawuKRPqqDwAAEGAw/qoKAAEQaDD6 +ogAr8AFcMFhLTcCgKiYSiyCOJ5osLEJ2//rAIEACa7D65RQsAEB/cPy7DACAAmtwnen95gggABBg +MPoyWSABEGgwWEs+wCDRDyxwAmP+zQAAAAAAAPP+DmAAEBgwKj0EY/56AADz/rRgghBgMCo8KFjy +6MOw/NdCEgAAGrD6CgUiAABo8FlqGYoq+ywAAgAAYPBb/uPz/ypgABBQMACIIsuM/TIAIAUQUDD8 +1zUQMBBYMFlqDsAg0Q8pIEAImRCZMGP9rQD6CgIgMBBYMPzXIxIAAGiwWWoF8/8FYAAQUDCNMNog +/NcoHPgBbDD9JEAgMAJZcPw2ACIAAGCwWFMdY/+fAAAAbBAGiScuIAcomRT1CkcMIAFwMPaSCSFZ +ADYg/wIAAgCsmqAvIEEMxxHzCgQgABBoMPsKACFOALfgGNa7qHcocjr/AgAKAMGeEClyOfqcAAGB +ADZg+xYAIZwAt+AkIQcZ1wMd1wP+JUAFQAEgMPpVEAXABDkg+Na0FAkAKTD/IQgkCQBpMJSg/SIA +JQAEPyD4pgIgABAgMPSmBS4JAC/w9KYHIDAQKDD1pgMuCQBP8P+mBCACEHAw+N0RAAQQeDD5pgYs +CQB/cP2mASBAAkqwAgaGAEljAAaGAElhCL0R9dblHAkAd3CdqSgiCPN2OS+XEGAwLCQF81KJL5YQ +SDD5JAUhFgC2IC8iDH/3JisiEi4yawuKRPqqDwAAEGAw/qoKAAEQaDD6ogAr8AFcMFhKwiQmEosg +jieULCxSdv/6wCBAAmuw9OUULABAf3D8uwwAgAJrcJ3p/eYIIAAQYDD6MlkgARBoMFhKtMAg0Q8A +AADz/qdgABAwMCggQAiIEJhgY/6fiJ4tgAQrgAX6gAYtgAQ/YAvdAviABy2ABD9g89aNHAkAV3AI +3REI3QID3QEj3GfzQxQAiRBYMPP+e2AIAhjwAAAAAAAA8/6AYAAQSDAAj2DaIP7Wqx74AXww/yRA +IDACWzD+ZgAiAABgsFhSn8Ag0Q8s3Ej73GciAABwsPtLFAIAAHmwWWlSLiAHixDz/klsIAFwMAD6 +CgIgMBBYMPzWjRIAAGiwWWlvY/7XAABsEASJJy0gByiZFA0LQfySCSE+ADYgBQlH/tY3EgCvmmAM +uhGuqi6iOv8CAAQAlkOgKaI5GNaD/9Y4HgIBaDD0kRZuoAQ7oCUhBwUFSgxVEQ5VAghVApWQiCDD +4P+WAiAEECgw/pYDKYAEOiD+1nQYCQAqMJiR+CEIIAAQaDD/IEEgABAYMPOWBSsABD7g85YHKAkA +WjD18O5oCQByMP6WBiWABDtg+JYEIAIQQDD7nCAkCQBBMAIMhgBLYwAMhgBLYZSZFNZgjCj1pjkv +lxB4MC8kBfVCiS+WEHAw/iQFILAAtyCJLH+XJisiEi5SawuKRPqqDwAAEGAw/qoKAAEQaDD6ogAr +8AFcMFhKPyMmEosgjieTLCxCdv/6wCBAAmuw8+UULABAf3D8uwwAgAJrcJ3p/eYIIAAQYDD6Ulkg +ARBoMFhKMcAg0Q8AAAAAAADz/sJgABBgMACJwNog+NY+GPgBTDD5JEAgMAJa8PjGACIAAGCwWFIx +wCDRDyogQAiqEJrAY/6ZAPP/EmCJEGgw+goCIDAQWDD81iMSAABosFlpBWP/PQAAbBAEiiqOrxjW +K/gmCyBAAkiw+eYAIHACerD/JggiAABYsP4mCSAAEGAw+aYPL5gQQDD4JAUgAhBoMFhSSMAg0Q8A +AABsEAQb1hwqMQzTDyuyfxzV9fkwECAWECAw+6MfcAAQKDB8oRf6LAACAABZcPw8AAIAAGkwWLfT +wCDRDwBokUFokiFolAnAQPP/2WAAECgwfKHRe6vO2jBYuADVoPP/xGAAECAw/KEHcBYQIDB7owJg +AAHAQNowWLgX8/+nYAAQKDDaMFi4J/WsAAAiADag/NX6EAUQUDD9MgEgMBBYMFloy/P/f2AAECAw +AAAA8/90YAwQIDBsEAQpMBP0kGtg+BAoMGiRA8Ag0Q+EJ9MPDwIAhE4c1eotMBEoTQQpTQMtlPz+ +MBIgBRBQMP6E3SAwEFgwWWi2+zwYI/0QUDD8MBEqACBRMFi4KPpK3ioAICzw/DASKgAgUTBYuCT6 +LAACAABZMFi4LMAg0Q+EJw8CAIROHNXULTARLUQC/jASIAUQUDD+RAMgMBBYMFlooPs8GCHIEFAw +/DARKgAgUTBYuBL6KqgqACAs8PwwEioAIFEwWLgOwCDRDwAAbBAE84sUAtgQKDClJSNUf/tUfiBA +EFAw+lR6IAAQSDD5VHsgBxBAMPhUfCBDECAwJFR90Q8AAABsEASPOPzVsxAFEFAw/TAQIDAQWDD/ +71ECAABz8FlofykwEPiRC2ADEBAwaJI9wCDRD9owWLi8+AoHL/MANqCLp4u+LLKODJlW/H1YDgAL +zhB9IA/7vQIgABBgMFi4h8Ag0Q8AWLfvwCDRDwAS1ZuDNiIifwkzEaMigiqCKC4iE//6jCCAEBgw +/yRoIEoAY7CKJ/sKAiAAEGAw+qwgIAIQaDBYSeQrIhMs+n8MuwErJhOMJ/7JFC/AEHgw+sIJIEAC +azAP3QH93EAgQAJzsP7FFCHAAlKw+sYJKgAF6pAowRWqiprJHNVE2aDwDAcAAhBYMG26AgBJYRvV +I5ugiSD/1XcQABBAMPiZEQACEFgw+KQSKAkAXnCZoS4iE40in6L4pQguCQAbsP4mEy8CALdgKyAH ++wtBAgAAULD7vBgiAABgsFhRV8Ag0Q8AAGwQBIguIyw4c4Etiy6Is/xMAAIAAGlw+7zgIgAAULAL +gACMIsDh/QoAIA8AtyCPLgP/DA/tOGTf0cAg0Q8AAABsEBYrIAclFhbzFhgiAABJMPkWCSABEFAw +mh4T1U4mEhj9EhYqIAFcMCsWFYdl+GIEI/8QcDD6MWIs4AFsMPZhDyYfATww+MUUDAsBQDD8Fhkk +CgFAMPpaDAoPATQw+xYSK+ABUDD6FhMgGADWMAYLSZsdYAABnh0uEhgtFhQPAgAv4T0o4B0oFAAv +FhEu4h/+Fg8iA5uDYIkiDwIADwIA/wIAAgQSKmD8CgAgTgA14PwWECAJADXg2lBYuknzCgAgABAw +MC4SGdpw/QoDIAIQYDD+3DkCAABZMFi6N/8KDyYAIDKw9RYILgAoN9CUFwZFFPAASGACAilwKBIR +ZIdXKRIYiZV9lqcrEhGMH/0cAAABEFAw+hYQIgAAUXBYul9mp4z7CgMgABAYMAqzOmQ3dvUWCCAw +EDAwBkUUlBckEhUf1KMMRBEPRAgsQjr/AgAKA+OvEClCOfacAAfEADZgKPJKZIecKfJJ+BIJJ5YA +NmAuIBQO6If+JBQsA96ToCkSGSwSE/sKAyAMADZg/wIACAP/4tBkMH+NF2TQAmQwZPtsAAIAAFCw +/AoDIBgQaDBYumSOHf8SCCYFADTgGNSK/NTmEAAQSDD5pgIoCQBD8P4SEi8ABD+gmaP5pgQgHBBY +MPmmBS4gBDug/+4CD7AEPOD4pgAuCQB7sP6mASAFEFAwWWejKhIU/wIAAgO1GqDAICVGOdEPACsS +EGSwcvtsAAIAAFCw/AoDIBgQaDBYukUsEAAW1Mgf1MmOGCZizRnUyPwfFA4JAHuw9sYLDsAEP+D5 +/wIARAB/MIwfK23/LRIRKLI/K7F9nqCfoZ2inKObpJilYAAWAIwfLRIRK2EFiGOeoJ+hm6KYo52k +nKUmrBgtEhKMHQ8CAALdEP0WCi0ABDsg/BYLJUAAteD71E8QABBQMCoWBSoSCCgKAvgWBioJAFqw +KhYM+2wAAgAAULD8CgMgGBBoMFi6GiYSGIkVjxaGZf0SGCG4ADZgBh5Q9itQCBMBMDD90gQsFAEw +MPXMEAhABDog87sQDiAEO6D71JUeCQBbsPwSDCgJAGIw/KYALgkAQ7D7pgEj/xBAMJii/qYFLSAB +bDCdpB7Uiy6mA//8/yAwAjKw/xYGIAICSnD5FgUvcwC34PtsAAIAAFCw/AoDIBgQaDBYufYe1ID7 +EgogAxBgMPkSCyAYEGgw9hIMIAAQQDD2pgAiAAB6sPv6/ygJAF5w+6YCJ7AEOOD49gQiAABQsPj2 +BSYJAEmw+/YDLgkAcbD+9gEgMAJb8Fi54R7Ua/8SDCAAEGAwnBGcEpwTnBSfoJyi/KYEIBACWHD8 +pgUv/xBoMP2mAy4JAHGw/qYBICACaHD+EhggMAIysPocBCAYAmBwWLifwIH6ijkCAAAasNmg+hYc +JFYANOAkFh0lFh77CgEgABBQMAm6OPMWHy1jADagE9RPKRIZhBgb1Ez8CgEiAABScPwSCioFAEsw +iBv1agAoMAQ+YPq1OQgJAGZw+JgCCAkATXD5FhckCQBFcCUWGhXUOfkKAyACEEAw/kQRCAUAUnD4 +FhskCQApMPAAzWAAECgwAAAAAPwSDC4tATAw9v1AChYBNDD2CFALAAQ+4PmIEQ3ABD9g+N0CCBUB +MDD07hEI8AQ6IP7dAg4YATAw+u4QCAkAWjD2m1AMCQBHcPgQACqwBD7g++4CC2ABNDD8pgArQAQ+ +4P7dAg4XATAw+e4QCIAEOiD71BQYCQBaMPumASwJAHdw+KYFIAIQcDD+1BYcCQB3cJ2knqMY1BKY +omP+BAAAmaGUoJyinKOcpPymBSAAEFgwm6abp5uom6ktEhuxVfasKCYBGm1Q+2wAAgAAULD8CgQg +KBBoMFi5c/RQTGmwBD1gKxIa/wIAAACohWD7mQIP/xBgMPV/p2gJAB5wjRMsEhiOEo8Ri8wswhCZ +oZup9KYAIAAQQDCYopimn6OepJylnaeMFJyoY/+PLRIZLBIXG9PtDJkC9NCIaAkAXnD++v8gIQA1 +4JmhlKCeop6jnqT+pgUgABBoMJ2mnaedqJ2pY/9WIhYgJhIYJRYiIxYhLmIaLGIbLWIVK2IZKGE5 +I2E4L2E6JWIW8mIXIwAEPODzEiEuCQAf8CZhO56jnaacpJuin6mZoZSglaeSqPISICkABDog9RIi +JgkAQbCWpWP++AD7+v8gIQA14JmhlKCbopujm6T7pgUgABBAMJimmKeYqJipY/7SIhYgIhIYLiIY +jCwoIhQvITktITsrITj2ITovAAQ/4P8SBCwJAH9wIiIQnqSdpfymBysABD7g+KYIJgkAWbCWqZmh +kqOUoIISn6aSoiISIGP+gAAoEhksEhcb06lkgGP8mQIP/xBwMPRwIWgJAF5wmaGUoJ6inqOepP6m +BSAAEGgwnaadp52onalj/kYuEhgiFiAt4hIs4hMr4hiI7YbuL+IUgu8u4hGeop2jnKSbpZimlqef +qZmhkqiUoCISIGP+EQAAKxIax9/7mQIAABBgMPRwG2gJAB5wmaGUoJ2inaOdpJ2lnKacp5yonKlj +/eOZoZSgjhP/EgEgABBAMJiimKOYpJimmKeYqJ+lnqlj/cIqEhgZ03zTD4qlIxIfJRIe9BIdIA4A +TrBkcK8c03eLGAy7AiuW+mP52YMewNLz+fdiBQA/cADApfzTcBAcEFgw/l4RAgAAaXBZZixj+LQA +AAAAAPoSEyAAEHAwnhGeEp4TnhRYt5bIqfoSEyAAEFgwWLeLWLeXJBYdJRYe8xYfLCQANqAY014o +gIAkFh0lFh7zFh8sEAC2IPrTWhFBEFgwWUNW+xpBLv8QYDD601YcAEBisFlGiyQWHSUWHiMWH2P7 +4QCNH2XYomP4Tx/TG44YD+4CLpb6Y/kpAAAAAFi3fcipGNNH0w8ogIBkgF0qEhNYt3P5EhwrlAC2 +oPoSEyABEFgwWLdmKRIcY/t+AAAAAAAAAPP4GWAwEDAw+xIRIgAAUXD8Eg8iAABocFi4V2P4XAAA +KxIYjBn9EhYiAABQsFhMOtKg0Q8AAAAA+tMuEUEQWDBZQyn7GkEhABBgMPrTKRwJAGKwWUZfY/+A +AADaIPsKHCIAAGCwWEkjY/+0AAAAAADz+DxgABBIMCsSFdog+7wYIgAAYLBYSRtj/5QAAAAAAP0h +CS/wEEAw+iAVKABAQ7AI7AwsJBT8Eg4gABBYMPSqEA2ABD9g+JQDLAkAV3D7lAAsCQBncJ2RLPZJ +Y/gIiieNGSwKAPqsICIAAFtwWEdI0qAlRjnRDwDz+ARgBBAYMGwQDBjSzymCgCqCeCiN9iiA0fQK +gCuQBDqg/4cMeAAgVnDwAAlkACAicCQqgKSUGNKp8AgHAgAASHAASWEASWEASWEASWEZ0rIqQS4b +0swd0n3/0uwQ5ARKsI4g/RYCIAQQYDD7FgYvgAQ7oP8WACwJAGOwnBEpQAcJCUEAmREJqQILmQKZ +FAjqMBzS3/gWBSAAEHgwnxcrIDUD7gL+FgsgAhBoMP0WCSoJAGbw+xYIIjIAPOD6TAACAABYcPwK +BCACEGgwWEMQ0Q8rLDb8CgYgdAJQcFleH2P/2QAAAAAAbBAEKCAFLSAHwZT9DEEOAHjKEIkiZZC/ +LjAB/MsRABQAb7AqIE5loWYZ0kupuy+yOv8CAAIAbcPgKrI5/6wAANoANqAskkpkwKUqkklkoJ8s +IBQMxIf8JBQqAGsXIBrSTRbSsychJP4JQQgCAWgw+ogQDQAEPmD80q0cCQBHcPghCSwJAG3w9yEi +LAkAN3Cd8IYg+TEBIAIQaDD59gQmCQBl8Pj2AyeABDmg9/YCJgkAabCW8YwznPXwChcAMAJL8AAJ +igUJR/22OSIAVZpgwCDRDwAAAAAA+iwAAgAAWPD8TAACAABpcFhLl9Kg0Q8A2iD7ChwiAABgsFhO +aGP/1/osAAIAAFlwWEzd0qDRDwDz/yhgABBQMAAAK8wY+iwAAgAAYLBYTl1j/6wAAAAAAP4hCS/w +EDAw9yAVJgBAMzD2zQwAABBAMP0kFCABEGgw9HcQD4AEO6D2pAMuCQA7sPikAC4JAGuwnqEtlkku +MAEtIAdj/ueKJ/tMAAIAAGkw+qwgIAAQYDBYRqnSoNEPAMC4C5sCmyJj/z0AAGwQBiggBSYgB/c8 +AAIAAFjw+QoUIAMQGDD2BkEOANfKEAUIR/XR5hIoADogjCL0wH9rwAQ5oMAg0Q8AAC0iHWXRmYon ++6IIL8AEOSD8oRUvwBBoMPmiCyBAAnqw+KkULABAb/D9FgEsACBrMPzMQCYAu95Qroj4pRQqACBb +sP4WAioA1VcQyXr5vAAAGAA1II0SbUkFAAeGAElhKvIADwIADaoI/wIABgDoZpCa8GP/eqWqLqI6 +buMQLKI5GNHjHtI2/dHNEBYAtyDaIPwsAAAwAlmwWE4KwCDRDwCYwI8g+P8RAAEQQDD4xgIuCQAf +8J/Bj7Mu4n8PjxSv7v7GAyAgAksw8A0XAAAQQDD+0iQQEBB4MLGI8hkeAfQCPiCfx57IGNGumMaN +IAjdEQPdAp3JI6Y5KyAGiif80aoQARBwMP0iAiACAlrw+yQGIEACUrD7qQQvwBBIMPiiASgAQE6w +/t0CAIACSnD9JgIgYAJa8PulBCGgAkIw+KYBKgAUyhApoQWomJihnICLIPrSBRuABD7g+oYCKgkA +HvD7hgEgABAQMNEPHNGPnICLIPrR/BuABD7g+oYCKgkAHvD7hgEgABAQMNEPAAAAAAD6LAACAABZ +cFhMQ9Kg0Q8AGNHy8AA2YIoQSDDA4J6r8/49YgAAWnAAGNHtKVIgiIApkAf5FgAgABBQMAuAAIoQ +iRMKmQz40eQeLQA2YCuCgvkWAyGoAP7wY/4aAAAAAAD7ygwANwA14ApMFP3MCCIAAEHw/U02AgAA +SvDTD23ZBQAIhgBJYYkRqnj8TgwAgAJKcG3pBQIIhgBJY40SjBEK3QytzCzMQJzwY/2zjhEu7ECe +8GP9qQAAbBAKiCeJIiwgByqBFf/6wCBAAkIw/EsRCABAejD7OwgIACBCsPiMQCIAACrw/AxBCgIf +wtAuUAf10UASAABZcAzPEfbsAyH8Amuw9JAKbgAgL/DAINEPAAAo8jq25/8CAAoCCz4QKfI5+pwA +BBMANmAoUkpkg+YpUklkk+AsIBQMzof8JBQqAgiXIBnRfYg0jCAV0aUe0TD4zBEAAF0mEC0gB8Fo +8yEkIAMQQDD0sQEsAgFsMPewASygBD9g/qYCLAkAT3D9pgAoCQBDMP3RQRwBATgw+KYBIAAQODD2 +pgMgAhBAMPANBwAgAmqwbYoCAE1hLSEJKSAH9KYJIDoQQDD3pgUvYAQ7IPkMQQ1ABD9g/t0CDQAE +OyD8PAIMCQBHcP2mBiwJACswnKQpIQn6LAAAABBgMP6xASAAEGgw+QoDK0AEPmD59jkqCQBG8FhL +ssAg0Q8AiScokRX1+sAgQAJKcPkWBSgAQC5w+BYCKAAgSjD1vCAggAJCMPkWCCoABMVQiBIIVQz5 +UgAgAgJDcAjIApgW+AqBKPgBTDD3FgEgNghCcBjRYYkWmaH4pgAh/gJLcAkZFJmiYAAPiBYZ0VyZ +oJihiFEIWBSYoiUyBhnRWRjRWQUlFCmSgPgSBSQAQEVw9YIBKAAgLnAogQUppgMpEggoFgP5iAgA +BAJJMPyZEQCAAkIw+BYJJAAgTXD5FgcqAAbFUCgSAycWAQhVDPcSBygAIG0wspkMmRH3mQwAIAJC +sPSQR2fABD9gmBSIGaV5/wIACgEAyhCJFAWMDJwQDEwUbckFAAWGAElhDNgMjBApEggKzAj5nEAg +IAJjMG2JBQIJhgBMYywiAAjMERjRK/0KASoAIFHwnab4pgQgBBBIMPjRJxgJAE8wmaWMsyiCfh3Q +tAyMFPyICAAAEEgw+KYHICACYrDwDRcAQAJSsLGZ8hoeAfQCPmAa0Rz+xgYgIBBoMJ3HiTSNs/jR +GhgAQFZw+tEWHOABbDD1MgUskAQ/YPcyBigJAG5w+jIKKAkAVnCZyCOwCRnRDviwCyYAQEXwLbAI ++bAKJABATXD0iBACwAQ84PUzAgQGAWww91UQCGAEPmD9WBQICQBGcPGIEAgJAC5w9dCnFgkARfD3 +xgooCQAecJnJg7WTy/OyBiyAAWww88YMLIAEP2D5sgcqAEAqsPnGDSoJAGqwms6ItJjPI7AB/wIA +AABN/NAoIAcZ0LsIKED1sQEooAQ6IPohJCgJAEowKMYQhiD9ChgiAQEcMPnQhxADEEAw/sYSJ4AE +OaD9xhMmCQBBsPbGESCgAmsw8AkHAAIQQDD2EgEgABBIMG2KAgBNYS0gBychCcGK+cYVL2AEOOD9 +DUEHQAQ94P7QyRYJAHXw9cYZLQAEP2D9rQIGCQBF8PfGFiwJAHdwLcYUJvY5LbAHiif03QgAABBg +MPvcAABAAlKwWET00qDRDwAAAPkSBC40ADdg0w9t2QUEBYYASWVj/hvaIPsKHCIAAGCwWEyEwCDR +DwAKtQxj+74AAPP77WAAEEgwK8wY+iwAAgAAYLBYTHzAINEPAAAAAAAA+CAVL/AQcDDzFgouAEBz +MA7DDCMkFCMhCf6UAyhABDog+DMRAAEQcDD4CgAiCQBE8PiUACIJAHTwk5GDGi5WSWP7rwBsEAYo +IAUsIAfA8/kKFCzgASww/AxBDgDOyhD1+sAiLAA7YIgiG9AN9IBya8AEOyDAINEPAIoni6gmoRX5 +ogsgQAI6sP2pFCgAQCnw+BYAJgAgQbD2bEAmALZeUAxJEand/aUUKgAgWnD5FgEqALPVkMk3+bwA +ABUANSCNEW1JBQADhgBJYSpyAA2qCP8CAAYAyDaQmnDz/4liAAAa8KuqLqI6buMVJKI5GNAP/dBj +EAEQWDD1QBZgIAJJMCvMGPosAAIAAGCwWEw2wCDRD5hAjiAI7hH7RgIuCQB7sJ5BjjMt0n8OjhT8 +z+wcACB3cJ1D/c/iEAAQQDDwDBcAEBBgMLGI8hkeAfQCPiCcR51GGdBLmUiIIAiIEQ+IAphJL6Y5 +LiAGiieNIrHu/iQGIEACUrD8qQQsCQBfcPiiASgAQC6w/qEFIIACSnD9JgIgYAJjMPylBCGgAkIw ++KYBKgAXShD5z8gYACBDsJihmYCCIPgiEQAAEEgw+YYCIgkAeLDyhgEgABAQMNEPAAAZz76ZgIIg ++CIRAAAQSDD5hgIiCQB4sPKGASAAEBAw0Q8AAAAAAAAA+iwAAgAAWXBYSnHSoNEPAMCwm6vz/ldi +AAAacAAAAAD7agwANwA04ApOFP3sCCIAAEDw/U02AgAASvDTD23ZBQAIhgBJYYkQqjj+TQwAgAJK +cG3ZBQIIhgBJY44RjRAK7gyu3S3cQJ1wY/51iBAojECYcGP+awAAbBAGLCAHFM+KDAxBDMMRpDMo +Mjr+gzpgAxAgMCsyOcq/H9AIHdAI+iIAIAAQcDAuFgAuFgL9FgEgABBgMP0KBSAeEHAwWEcr9DY5 +IAAQEDDRDyvMGPosAAIAAGCwWEvFxyTRD2wQBiggcMBU9M9xENAAdjArIAcLC0EMsxGkMykyOvQi +ACSsATpgKjI5ZKBL20BYyw3Awf0KACABEHAw+M+YEAAQSDD5FgEgABB4MPkWAiIAAFqw+BYAIgAA +UTBYRw0lNjkqIHArCvsLqgH6JHAgABAQMNEPwCDRD9og+7wYIgAAYLBYS6PHJNEPAAAAbBAEKyAH +GM9OFM/TCwtBDLMR9EJ/IgAgRPAoMjr+gkNkACBZMCoyOcuoBEsC/AoAIAIQaDD+CgIgEBB4MFlh +ZsCB/s/GH4AEPSD+pgAuCQBH8J+hjSCdosDC/DY5IAAQEDDRD9og+7wYIgAAYLBYS4XHJNEPAAAA +bBAaLjAQ988wEBQQeDD2CgAiEAA3oP8CAAAEHwegaOIDwCDRDyogBwUJR9MP+RYhKiABUDD6FiIi +NAI6YCsgBf8CAAgFfkLgLSBy/wIAAgV4+1DaIFhI82Wn5I8iZfffKBIi/jIFKcAEOiD8IhAoACA6 +MPgWFSAOAkkw+II6IC4CU7D6ShQAGBBYMP68MAAGAmqw/RYQKgVWzhArEhUrsjn/FgQgBU+q4I8p +iCoNBz4PiAz/AgAKAEM6ECwgIikgIwyZDP8CAAAFiapgIxYkLCAHE8+FDAxBA8wJKMHmCYM2A4gM +KMXmLCAikxkMw4csJCLzEiQgBX4rIBjPeyiCf4krIxYk8IEEAf4CQzDwiBoAARAYMAAzGvM8/ygA +IEZw8xIkKAkAHnCZHJkqKRIMD5kM/wIACgVhvlAsIhAvIAcZzuX4IQcuAgF8MAr/EPkhCS4JAE/w +/7YAKUABQDD/ISIowAQ6IPgiACgJAEZwmbMpISSctRzO3Qz/Ap+yHM9bLxIQ+IgRCAkAZnD5tgQu +CQBH8J+xLCA4Gc9W+AoHIEcQeDD+tggsAwFgMP/PUhgFAGPwlreWu/wKAi4FAGZw/LYJIAEQSDCZ +uvm8MC4JAEfw/7YGICACQPBtqQUACIYASWEZzsGZvIgw/wIAAgRaqhArEhUttjkqIBSkqvokFCAT +ADXgjSksIDin3f0mCSIEy3sQLhIh/wIAAgS5G6DAINEPLiAHLzARKCAFiSL/fUAKIAF0MPsWIigC ++Rog/wIAC8AEOuD/AgACBGeqYKeqKKI6wZr+Fg0qBIBOECmiOSkWFP6cAAAEfSpgKHJK/wIACgRf +wiApckn5Fh8gBFoqYCUWJycWKCoWKSQWJisWKigwFCgWHSgkOCswFSskOSYkO4Q2ijqJO4c8hTiM +OSwlIyUlCSklJSolJCckTCQlIv8hGiZgAXwwLxYRiz37JE0v/BAgMPQSJi4AQCfwKjIQKTIRJiRO +JiRPJiYbJiYdJiRwJiRy9iRxIAEQKDAlJSklJhclJhglJhklJHMnJDoqJSgpJhUqEin3EiggAhBI +MPcWKCoAQE4wKxYe+xIqIAEQYDD3zvER2AJ78PUSJy4AEs4QKBIRIhYr+AJIAAEQSDD4mBQCBQAS +cKgiDiIRAv8MIhIrD3gs9RYnIAEQSDAPdy71Eh4mBQA+cPgSHSYAIEXw8xYkIAQQGDD1lTkIAEAa +MPnOcRgFAEJw+hYpIgAAUbD5IBQqBQAqcBXOq/SZCAIAABmw9/gcAgUARXD4JTQqCQAasPkkFCH4 +Ahvw9zccBQAEP+D1pQIDAAQ84PMSJCoJABqwlS8nJTUlEicnEigqJhD6EikmCgA3YC4SFBvOhIgd +JBYmjCkUzjicLP8yDigCAUAw/xYWKKAEOiD7IQgoCQBaMJjg/yIAICAQQDCY45Ti+PgRAAMQIDAE +iAKY4YQrluWc6PwSIiABEEAw9OYJJIAEOmD4ChQkCQBBMPTmBy0ABDsg/M6lGgkAZvD4Fg4gABAg +MCQWF/QSJi4JAGfw/+YGKgkAZvCb5CsgB/wKASAWEHgw/xYgIGACc7D2JBQqIAFcMJ0fKhYVH86C ++M6UECgCSvAAkQQAyRr4Mg8oCQBGcCgWGCkWGSn2MB/Ojv8WCyIAAEuwAg+GAEljAA+GAElhKiA5 +xLD6DEACAABpsPy9OACAEEgw/CA4IAIQWDD7qgECAAB5sPqfOAIAAEGw/CpAAgAASbD/3QIIBQBS +8PoKECoAQF8w+6k5AgAAebD8C0AAIBBQMPw8QA4FAF6w+iIAIAAQWDD7FgEsCQBDMP4KACBAAluw ++c5sHgkAT/D5FgAsCQB/cP3MAgAAEHgw/MwRAAQQaDD9CgAsCQBrMPwWAiABEGAwWEWAwMH/zl8S +AABasPoiACQAEEgw+RYAIAAQaDD5FgIgABBAMPgWASABEHAwWEV1LBIY/RIWIgAAWrD6IgAv/xBA +MJgQLiEk/yElLQABbDD8DEgNcAQ/YA3MAvD/EQAAEGgw/BYCLgkAe7D8CgEv/xB4MP4WASAaEHAw +WEVi26D6IgAv/xBgMPwWACAAEEgwmREoISIpIQnA0PCIEQAcEHAw+JkCD/8QeDD5FgIgARBgMFhF +VCoWGiohKFlKlP3OMhIAAGKw+iIAL/8QcDCeEC4SFy3QjBvOLf7dAgH+AmMw8ukQDBAEP2D5zBEI +CQBucAyZAguZAikWASgiFRnOJP/6/yAeEHAw+GgUAAAQaDD7EhooCQBKMPgWAiABEGAwWEU4GM4C +jBsvEhn/hjAiAABKsAYMhgBJZwQMhgBJZYkw/wIAAgGFqlAfzb8sIQcpEhX4EiAhQAJr8CrSmCiW +OYggL/JrKSAMLiAV+yAHLgAgR/D4IA0vkAQ/4P8iACoAIHqwKhYbK6QHKaQMLKUHKKQNjDkupBUt +0hwuMhH4MhAgARBIMCmlKSilKP5uFAAUEFgwK6QFLKUJ/6YeLeABYDD8pSMg/xB4MPsSHywAIHdw +/BYcIAAQcDD9phYgARBoMFjJCSwSGysSHCbEFPzAFSAgEGgwWRZSjR9k0wouIDrA//8CAAYBhX+Q +KTBXxIAJiAwoFhLA0f8K/yAAEHAw/CEJIgAAWrD8FhMiAABQsFjI9iYkFCsSEywgFS0SElkWQMDM +iycdzWWLvoke8A0HAAEQUDAAS2EAS2EAS2EAS2EAS2EAS2EAS2EAS2GOHyx2SSkkBfokFyArADeg +LyA6wI948R4ZzT0oMFAJiAooghD8MFcgoAJY8PosAAACEGgwC4AABQpH/wIAAgGgmqDAINEPAAAA +AAAA+iwAAgAAWPD8TAACAABpcFhGmdKg0Q8ABQtH+xYhIgB2GuCJJyyZFC2cIPTCcWBgAnJwjJmI +4Cn6wPnZAQAAEFAw/osMAZACQjD0wHNqBQBaMJkYiNB8gWcrwAD/AgAAFRBIMP8CAAYASX7Q/wIA +ABYQQDD/AgAGAEFO0PixenAYEEgw+bFycBkQQDD4sWpwGhBIMHmxYosYKcAHKNEFmBr7iAgJwAQ+ +YPiMQCwAIEsw+Ms7cgAAWzD8vAAPlwC24Mmows0roAB8sS6LrsCg++0MAZACWvANujllr+ctIE78 +ChYiAABZsPAADmoFAG8wixoLywxj/8AAACwgBfskcSjgATsgLSByft9l2iBYRrVloGyOImXgZygg +FKSIKCQUjzB69ksqIAcKCkEMqRGnmSuSOv8CAAQBKcLgK5I5+RYjIkgANuAvIHH1nAACAABg8P4K +6iIAAFCw/+Y5AgAAaTD/CgEiAABxsFhGdMCEKFY5KRIh/wIAAgD6mmDAINEP+iwAAgAAWPD8TAAC +AABpcFhGOdKg0Q8A/DwAAgAAaTD7rCAgABBwMP8KASIAAFCwWEZiKhIgtKoqFiBj/NIAAB/NR/gS +IiADEEgwKfSAH81EAIEEAMkaL/CA+RYGKOABTDCZF/8WBSgAI3pQiRf7EiIv/xBAMPgSBigRAEZw ++c05HgBAT/D4EgUuCQB+MAm7ChnNDCm2mRnNMg8PR/+UgCCHADYgZPCKKyAHCwtBwJH5FhcgExB4 +MP8WDiAAEEAw+BYWIBMQeDAvFiBj+hYAAPP9N2AGEGAwxIAoFhJj/PwAACkSEPggcSIAAGDw+iwA +AgAAaTD+CuogARB4MPjmOQnABD5g/mwACgAgTvBYRistEhDz9xpgCAJrcAAAAAAA8/2RYAAQYDBk +/3zwAAZgARBIMMCQGM0ML4LSx777IAcuAEBf8A+fAi+G0vP/X2ogAVwwAAAAAAD6LAACAABY8PxM +AAIAAGlwWEXj0qDRDwDaIPsKHCIAAGCwWEi0Y//XwCDRDysSItog+7wYIgAAYLBYSK5j/OgA8/cD +YAAQSDArEiLaIPu8GCIAAGCwWEinY/+kiif7TAAAABBgMPqsICIAAGkwWEEG0qDRD4on+0wAAAAQ +YDD6rCAiAABpMFhBANKg0Q/aIFhFi2P2ZYon+0wAAgAAaTD6rCAgABBgMFhA+NKg0Q8AAAAAK6wY +/CwAAgAAULBYSI1j/eQrIAX/AgAB/i8G4IwUwNINzAKcImP8TZ8qnxxj9TKIGSogBxnMugjLDPsk +IiogAVAwCa8JLvHmqO4u9eYsICLMx4wpnCpgACYAACiSf40r8IEEAf4CezDw/xoAARBwMADuGv7s +/ywAIH9wDt0CnSorrB/8LAACAABQsFhIbWP75ABsEAQYzFyJICuCa/iCgCAQEGAw/CQFKAAgXnD5 +mREAABBYMPskFCgAIEow+4QUIgAAULBb5nPRD2wQBBnMa4oyKZJ/CaoRqpkskAb4kgIgABBYMP36 +/iALEHAw/pQFIf4CYzD8lAYoAEBqMPiWAiIAAFJwW+ZjwCDRDwAAbBAGiCIqIAeHMCUWAvoKQQAA +EDAw9YGXZuABPDD6FgEg7wA14Pt8ASIAAFCwWVyg9fqNIACyrqDyFgAgsQA14PdyCQIAADDw9zwQ +I8AEOKDwABxiACAYsGmBBooQi2VYx8tmoLImbDD3fDAmAECVkChgEMiNaIE3aYLpKGARZY/WYABY +KGARyIpogRhnr9V1odJgAIKKEPtiBSIAAGHwWMgFY//mihCLZVjH/WP/3AAoYBHIjGiBGmevqXWh +pmAAVgAAihD7YgUiAABh8FjH+WP/5IoQi2VYx/Jj/9qKEPtiBSIAAGHwWMeuY/90ihD8Cv0gABBY +MFldsvb6ACYAZa6QiDAGiAGYMGAACwAAAADyFgAiAABRsIcRGMu1DHcRCHcIKXI68hIAJACZwmAp +cjn7nAABNAA2YCmCSmSRDSmCSWSRBywgFAzEh/wkFCwAmJMgAzwC+g5HAgAAaTD/CgEiAABQsFhF +T40S/Q1HAAQQcDD+djkiOgA7YIon+0wAAAAQYDD6rCAiAABpMFhATtKg0Q/AINEPAMe08hYAL/+8 +2pDaIPsKHCIAAGCwWEID+iwAAgAAWPD9EgIiAABhMFhFB9Kg0Q8AAIwSDAxH+cJyYAAQEDCIEIiH +jYjygRUvwBBYMPmCCyBAAiowC1sBqyLyLEAmAGTuUCmJFAxHEf16CAgAID5w+YUUKgBm1JDJNclD +2dBtSQUAA4YASWGKUA8CAA8CAKeq/wIABgCGFpCL0PpWACoAQDbw+9YAIAAQEDDRD4wwBswBnDDR +D9og+wocIgAAYLBYQdlj/1KCEPP+zmAAEEgwAACLEdog+7wYIgAAYLBYQdFj/zQAAAAAAP4hCS/w +EDAw/yAVJgBAMzAGzQwtJBT0/xAAARBoMPaUAy+ABDug/woALgkAe7D/lAAuCQBrsJ6RLYZJY/6U +i5DAoPqGCyoAQDbw+5YAIAAQEDDRDwAAAAD9KgwANgA04ApMFP7MCCIAAEDw/k42AgAAS3DTD23p +BQAIhgBJYQo4CPxPDACAAkrwbfkFAgiGAEljCngM+9IAKAAgQvAojED4VgAqAEA28PvWACAAEBAw +0Q8AAAAAAAD70gAggAJK8PlWACoAQDbw+9YAIAAQEDDRDwAAbBAEKCAFzYuKJ4usLakU/qIJIGAC +SrD8vMggDARK8MzCyN/I7fosAAAAEFgwW+WA0Q8AABjLsxvLs/yCfy//EHAw/qYAIAAQaDD9Jgcg +EAJ6sJ/Bm6Mpgn+Zoi+Gf9EPbBAEHMtQGsuoLMJpK6LIo8wJzBGsuymxGsDy/pQKYAAQaDAttRpg +AAJokxAusRoP7gIODk/+tRoiJgA/oPosAAAAEFgwW+Vi0Q8AACyhboqwDKoMWMdtY//iAABsEDIu +IAcfyvYODkEM7RGv3SjSOvIWUSBKEEgw8xYmKggEThAl0jktFlD2XAAACAKpYI9I88uHH/8QaDD5 +yvgQIBBYMP/yUAAASAPQ8AkXAGACeHAAD4oACY0AsASPSZ8eKkIQLEIRLBYQCgobmh8oQhIpQhMp +FhIICBsoFhGMTI9NLxYUDAwbLBYTiU6KTyoWFgkJGykWFYhL+BYXIMACSHAACYotFhstFhwtFh0t +Fh4tFh8tFiAtFiEtFiItFiMuFi0oMjwpMjspFhkoFhpgAFEAAAAAAADx+QcAYAJ4cABPYQBPYQH5 +iyhCCSgWFC9CDS8WFSxCDCwWFipCC/oWFyDAAnhwAE9hAE9hLRYhLRYiLRYjLhYtKTI8KjI7KhYf +KRYgK/r/KxYj+xYiIGACUHD7FiEgwAJYcFjHNC8xadMP96wACAcz/pAvMXJ/ogwoMXOviP8CAAwH +KkKQWMdw9/r0IAdyKqD1FiciAABQsFjHRiUxcqWl/wIAAAd6LWAfytov8mkuMsr4ysAeACB9cPwS +Ji+QBD/g/+4IAAEQaDAt5RovQSuVwS8WQhzLKiZCGiNCGCdCGS5CFCtCFylCFikWRfsWRCgAQEOw ++BZGKngBcDD6FkMufAFwMC4WKykWAvoWACIAAGlw+xYBIAUQUDD4FgMgABBYMFldqRzLFvnLFxAF +EFAw+RYBKOABEDD4FkcgABBYMPgWACAgEGgw8NAEAgAAcfDzDRsCAAB5sFldm8Dy/RIrIAEQSDD7 +CgAggBBgMPx8AQIAAFLw/Jw5CgUAUnD8qgICBTuDYCkWNiIWLPgKCiH6AmNw/I04AAAQcDD+FjMg +ABBgMPwWNCAAEEAwKBY1GMqAwMH4OAEAABBIMPnJOQgFAEMw8srxGAkASjD+CjcgBSaqIADgBAMJ +GwkJQykWNwCEBPc+GAAEuSWQBlhQ+BZILBQBMDD8FkkiBJixkIkoCYlB+RZKIASX0ZAGzEH8Fksi +BJ+1kIwoDCxB+QoBIBAQQDD4eAEAABB4MP+fOQgFAEJwCP8C/wIAAAT3q+AfymT/FjggABBIMCkW +OQbJUAn4EwmIAv8CAAAE8Cog/8o0EAAQQDAoFjovFjsG31AP+RMPmQL/AgAABOiqYPjKVRAAEEgw +KRY8KBY9BuhQCP8TCP8C/wIAAAThK+D5yrwQABB4MC8WPikWPwa5UAn4EwmIAv8CAAAE2aogLRYr +/8o9EAAQQDAoFkAvFkHwJAQAEBBoMPQWViAgEHgw8hZVIAAQQDD8FlcuYAFwMPwKASAAEBAw/hYp +IgAASjD0ynIeAEB98PLCOQ4FAH8w/y8CAgAAWjD0NAEIBQB7cP/KnBQFACMw/QqAJAkAETD9Cggq +BQAncP8/AQAEECAw+woGKAkAWjD/zzkEBQBS8PsSSCpXATAw8v8CA2QBGDD0IhEIBQB/cPkSSSQJ +AEkw/cp7GuAEOqD4EkokCQBBMPe7EQlgBD5g/W0BCAkAXnD7yoEZAAQ6IPlEAgoJAFIw+PgTAQAQ +SDD7EjkoBQBu8Pc5GAQJAEkw/RJXKCABTDDxxAQJQAQ+YPc/GAgJAE0w9PQTDoAEP+D4EkskCQBB +MPL/AggJAFZw+hI4L/8QEDDyFgAsoAQ/YPISVS4JAHuw/hYCL/8QeDD+Ej4qCQBqsP39EwgwBDog ++hI1KAkAVnD9EjoqCQBu8PsSRyQJAFkw+PgTCAkARnD9mQIL4AQ6oPoSPCgJAFIw/RJAKmAEPuD4 +EjYkCQBBMP4SPyoJAHKw+hI7KAkAVnD9Ej0oCQBucPkWASnQBDog+hIzKAkAUjD5ykYcCQB3cPgS +QSQJAEEw+aoQAAAQcDD9RAIKCQBasPmIAgQJAFEw+xInJAkAQTD0FkwgABBoMPQSViIAAFFwWEFE +KxI3LBIrKBJM8WQEDgoBNDD3PRgAIBBwMPDgBAAAEEgw/Q1FDuABMDD/+v8oBQB/sPgIGw58ARgw +8MwRDWAEP2D8uxAICQBucPy7AgAAEGgw+O4QDbIBGDD4FgIsQAQ7IPjKHhwJAHMw+BYAIAIQcDD8 +CgEqCQBm8PusAAgJAF5w+RYBIgAAUXBYQSEmEikvEkP9IgogARBgMPgSQiIAAFqw/vr/IgAAUXD+ +FgAt4AFsMP0WTSkABDog/RYBLgkAR/D/FgIgBBBwMP0KAC//EHgwWEEP/AoBIAAQaDD+CgYv/xB4 +MPsSRiAAEEgwDwIA+xYCIgAAWrD5FgEv/xBQMPoWACIAAFFwWEEB/RJNL/8QeDD+EkQv/xBgMP4W +ASIAAFqw/BYAIgAAUXD9FgIgARBgMP0KACAIEHAwWED0+BI0IAEQYDD9CgAv/xB4MP8WACAKEHAw ++EkUCoAEPiD7mQIKQAQ+IPuIAg//EHgw+RYBIgAAWrD4FgIiAABRcFhA5C4KDP/6/yIAAFqw/CIG +L/8QaDD9FgAgABBoMP0WAiIAAFFw/IxSAAAQaDD8Fk4tAAQ7IPwWASABEGAwWEDUx7/7FgAvABBI +MJkRiSf4Ek4gARBgMP0KACAOEHAw+QlPD/8QeDD4CF8JQAQ+YPmIAgIAAFqw+BYCIgAAUXBYQMQo +Ov/9EkUv/xBgMPDEBAIAAFqw9z4YAgAAUXD8FgAvIAFwMP4WTyABEGAw/O4QD2AEP2D9bVkOCQBH +8P8WAiwJAHdw/RYBIBAQcDD9CgAv/xB4MFhArsBw+xJPL/8QGDD8CgEgABBoMP4KEiAAEEgw+RYB +KywBXDD7FgIv/xB4MPusAA//EFAw+hYAIgAAUXBYQJ/Awf0KACAUEHAw//r/IAAQSDD5FgEv/xBA +MPkWAiIAAFqw+BYAIgAAUXBYQJT8yYcQFhBwMP36/yIAAFqw/RYAIAAQUDD6FgIv/xB4MPwWASIA +AFFw/AoBIAAQaDBYQIfAwf0KACAYEHAw//r/L/8QSDD5FgAgABBAMPkWAiIAAFqw+BYBIgAAUXBY +QHz5rAAFtwA1oP8CAAIC14Gg/wIAAAMjhaD/AgAEAx+FoCcWGPcWGSDAAlhw87YCIP4CaHCTs5O0 +k7WTtpO3k7iTuZO6k7v+yL4QEAIycPycICBgAlJw+BIsIIAQWDD7mwgAoAIYcPsWMiACAltw/ci3 +FDIANiApFigoEi32yRASAAB5sBfIuf5SEQggAUAw+BZSIgkAMLDyFlQngAQ5YPIKACAEEEAw+AoD +JgkAQbD2FlMiAAAycG2Kc55gKRJT+WYBIgAAS/DwBxcAgAJ78AAJisKYmWUpElIoElT4ZgYpsAQ4 +oPjJOBgJAEZwnWT4mQIAAgIQsPu88CIAAELw+WYHIgAASPD0CBYB4AIY8PjMAACAAjGw8AikAIAC +YzDyCRYCAABCsPAIogCAAlKwGMkf+xIoIPAQYDD2CgAg4BBQMPYWGCDIEBgw87MIAAAQMDD5goIq +ACBS8PiCgyIAAHrw+RYZKgAgZvD4FhogAhBIMG2ahv72MCAoEGAw+BJTIgAASPD49jEggAIY8PAH +FwAGAkGwAAmKLfY0+RJUI7AEOiAs9jX59jYgAgIxsP6EBmABEEgwwJAoElIImRECmQL5yQIYCQBK +MC/8QPIcYCgJAEow+PYnIgAASvDyAhYCAABCsPAIogBgAhBw8AIWAIACWvDwCaAAgAJSsCYSKPga +QCBEEBgw8hImJgAgQbApQSr/AgAAAM/CUBnIfCoSURzI1y5mACqiAC1mAvxmBSAIEFgw+2YDKAkA +TXD4qhEAAhBYMPlmBCoJAFqwKmYB8AcXADACSbAACYrzPAIgQAIxsItA/wIAAADPKtApIAEAmTKF +IQAkBCxCGStCGP1CGirgAUgwKhYvDLsY/QdJCiABXDD7Fi4gGAA2oC5CFBjITg7PU//8/i4AQEOw +D+U4KxJR+mwAAAQQcDD9rFAAMBB4MPuyACABEGgwWVo+Hcg/KxIu/BIvIAQQSDDwDQcCAABqsABN +YQBNYQBNYR7IYQC9EfjIthwJAG3w+KYCLAkAd3D9pgAgEAJ5MPEPFgAgAnKwAA6KlaYoQhQMDQb9 +pB0ofAFAMPikHCAIAnDwLxJQLvY5+SQAIAAQEDDRD4glCJhQKBZJwJD5Fkgh+2uxkAYMUfwWSiP7 +bNGQiCgPAgAIDED4GEAKBQBn8AuIAvgWSyH7ZLWQ8/bGbC4BMDD5CgEgABBAMPIWVSxgAXAw/Mz/ +IAAQEDD8mDgAABBgMAKcOPISVS//zMcQwIEoFklj/5QAAAAAAP8CAAH/VMZQG8f/KhJRLEIanmCK +oP1mAiAQEHgwn2OcZfxmByoJAF1w+2YEIAAQSDD4qhEAAhBYMPlmBioJAFqw+mYBIAQCGPDz/mBg +QAIxsCwSUPPGOSAEEFgw+yQAIAAQEDDRDwAAKRY0IhYs/PwAAAEQQDD4FjUgABBwMP4WNiwFAFLw +LBYzY/WRiCkICFMoFjdj9bcAwPD/FjggABBIMCkWOWP2EsCQ+RY6IAAQQDAoFjtj9iHAgPgWPCAA +EHgwLxY9Y/YwwPD/Fj4gABBIMCkWP2P2P/0WKyAAEEgw+RZAIAAQQDAoFkFj9ksAACoWKhrHyCwW +MfQKBwAAEFAw+hYwIOACQHAASGUax/8nIoInFh/yIoMgBBBAMPIWICOABDlg9xItIgkAQLDyFlMp +4AQ5YPISJigJAFIw+BZUJiABPDD3FlIiAABScPfHmRACEEAwbYqgLBIqIhZVnqAoElOYoSgSMfAH +FwIAAEmwAAmKKRIw0oD4jEAgARB4MPgWMSAAEEAwCfg4+ZwBL7AEPmApFjApElIIiBH9pgQuCQBH +8P/IHhgJAH5wKBJUmKb/CigoCQB+cPmmByIAAEsw/6YFIIACYzD8FioiAABC8PoIFgCAAjGw8AKq +AeACWvDyElUiAAB48PgPFgHgAhjw8AmoAIACUrAmEjLz/FpgOBAYMAAAAAD8yAYSAABasPrIBRAA +EEgw+RYCIAAQaDD8FgAgGhBwMPoWAS//EHgw+lwAAAEQYDBYPwD+Gv8gARBgMP3H+R//EHgw/xYA +IgAAWrD9FgIiAABRcP4WASAAEGgw/8fvEBwQcDBYPvTAwf0KACAeEHAw+QoALgEQeDD5FgEv/xBA +MPkWAiIAAFqw+BYAIgAAUXBYPujz+c5iAABKsAAAAAAA/AoBIAAQaDD4IgggGhBwMP/6/yIAAFqw ++QoAIgAAUXD5FgIoGAFAMP8WACjgBDog+BYBL/8QeDBYPtbAwf0KACAcEHAw//r/IAAQSDD5FgEv +/xBAMPkWAiIAAFqw+BYAIgAAUXBYPsvAwf0KACAeEHAw//r/IAAQSDD5FgEv/xBAMPkWAiIAAFqw ++BYAIgAAUXBYPsDz+SxiAABKsItJLUEW/kEXIN4ANKAcx7YpQhEqQg4vQg0oQhInFgkoFgMrFggq +Fgf5FgEgBRBQMP8WBSAAEEgw+RYAIAAQeDD/FgQgABBYMPsWBiAAEEAw+BYCICgQWDBZWib/AgAB ++Kit4CISJir6nvokAS+eEEgw8/sDYAAQGDAAAC0WUPPv+2AAECgwLBJR+swAADACW7BYQznHJNEP +AAAA8hImIAUQUDD8x5IQGBBYMFlaEfckAS/0EEgw8/q+YAAQGDAAAAAAAPISJiAFEFAw/MeJEBgQ +WDBZWgf3JAEv9BBIMPP6lmAAEBgwABzHg4hMj02XEvsWASAFEFAw+BYAICgQWDBZWfz/AgAB+FSt +4GP/VABsEAosIAcYxscMDEEMxhGoZihiOsGV/QoDKgFlThArYjn6vAACxwA24CswAxfHUvzG6BLL +ALbgJUIUBYhT+BYHLHwBLDD8VQECAMMHYMBQLUEqG8a5+ca7EAIQcDD4xukQAInDUI8xm6CNIJel ++aYCLgkAR/D/pgQtgAQ/YPnGuBwJAHdw/aYBIAgQaDCdo/AJFwAwAkqw8hkeAEACUrCyVY5A/wIA +AACKq5ApMAEAmTIAJAQtQhonQhn/Qhgq4AFMMPsWCi8gAWgwnhgH/xj3MgEuIAF8MP8WCSAVADbg +KEIUCMlT/IgBAfwCSnAJhziLIP2sUAAEEHAw/wowIAEQaDBZWK6JGIwaHcatixkYxtbwDQcCAABq +sABNYQBNYQBNYQCyEf/HJxIJABJw/6YCIgkAQLDypgAgEAJxMPEOFgAgAmqwAA2Kl6YiQhQMCAb4 +pB0ifAEQMPKkHCAIAnlw/2Y5IAQQcDD+NAAgABAQMNEPAAD/xo8R/5THUChCGo0xm6CHIPmmAiwJ +AH9wnaSYpZin+HcRABAQQDD4pgMmCQB18PemASAAEDgw96YGIAQCKXDz/upgQAJSsAD1ZjkgBBBA +MPg0ACAAEBAw0Q8AH8cGGccGKEIW+kErIgAAWrCYFZoU+jIBIAEQYDD6FgYgCBBAMPgWAiAMEHAw +/hYAIAAQaDD5FgEgAhBwMFg99o4XjxT9xvcSAABasPoSBiAAEGAwnBH9FgAgARBgMPD/EQAAEGgw +/woALgkAe7D+FgIgBBBwMFg96JUS/AoBIAAQaDD+CgYiAABasPoSBi//EEgw+RYAIAAQQDD4FgEg +ABB4MFg93YsVwND1EgYgEBBwMPtsWQtgBD7g+xYCI/8QeDD8FgEiAABasPrKACABEGAw+hYAIgAA +UXBYPc/8CgEgABBoMP4KACAAEEAw+BYAIAIQeDD4FgEiAABasPgWAiIAAFFwWD3EHMY+8/1xYA8Q +KDAAAPP9OWAAEFgwK8wY+iwAAgAAYLBYQlzHJNEPaLMqwZZ5sRHGuvs0AS/qEEgw8/2dYAAQKDAt ++p4tNAHz/+5vnhBIMAAAAAAAAP00ACAAEBAw0Q8AAGwQGCsgBxfF+QsLQQy2EfpCCCYAIDmwKGI6 ++vdQBADcxiAsYjn1xqURrgA3IC1RghnGFvv6/yEVADdg/QogIABGgpDwKRcAYAJQcAAKiiwWJgAp +jQDQBI9Jnx4qQhAuQhEuFhAKChuaHy9CEihCEygWEg8PGy8WEYpMjk0uFhQKChsqFhOPTohPKBYW +Dw8bLxYVjkv+FhcgwAJQcAAKiisWGysWHCsWHSsWHisWHysWIClSPyhSQCgWGikWGSsWISsWIisW +I2AASwAAAPAJBwBgAlBwAEphAEphLBYmAAmLj0kvFhSOTS4WFY1MLRYWKkIL+hYXIMACUHAASmEA +SmErFiErFiIrFiMoUkApUj8pFh8oFiArFiMrFiIrFiH6HDAgwAJYcFjCPC1RcSwSJvusAAgAWu6Q +KlF6/lF7LAAHUtCq7v8CAAwAUHLQ+yIAIbkAteDA0P4KAyIAAFMw/wogIAAQYDBZV8cYxlUpUsWP +IC5BFi6lAgn/DPtBFy4JAEfwn6CNTZ2ijEycoy9CGShCGPulAyCAEEgw+KYELgkAT/CfpY5Jnqb9 +QhogAxBgMP2mByABEFAwLGY5KjQAKyAGiSKxu/skBigJAFZw+SYCIAAQEDDRD9og/CwAADACWvBY +QdPHJNEPLUEWLkEXKxYkj0n/FiUhsQA14BzGKYhOiU0qQhIrQhGbEZ8YmhMpFgX4FgcgABBIMPkW +BCAAEEAwKBYG/xIkIAAQUDD6FgIgABBYMPsWACAFEFAw/xYJICgQWDBZWJktEiT8EiYh/38vYIcx +ACQE/cWQH54QcDAuNAEqQhT4QhkgMBB4MPVCGCAEEHAw+UIaKnwBVDD9CgEqAEBqsPhVGAH8Alrw ++6c4AgAAUzD5rFAEIAEsMPsiACMgAUgwWVd3GMV42aDwCAcAAxB4MG36AgBJYRjFnQBZEf/F8hIJ +AEiw/6YCIgkAQLDypgAgEAJxMPEOFgAgAmqwAA2Kl6YsQhQrCmL7pB0sfAFgMPykHCAEEEgwKWY5 ++TQAIAAQEDDRD8DQ/goFIgAAUzD/CjggABBgMFlXWhnF6YggK1LFL0EWL6UCC4gM/EEXKAkASjCY +oC5CEZ6jLUIQnaIrQhObpSlCEpmkiE2Yp49Mn6aOT56pjU6dqChCGSlCGPylAyCAEFgw+aYKKAkA +WjCYq49Jn6z+QhogBRBoMP6mDSABEFgwLWY5KzQALCAGiiKxzPwkBioJAFqw+iYCIAAQEDDRDxzF +wSgSJCkSJY9NKkIMKhYA+RYBICgQWDD4FgIgBRBQMFlYOCsSJPwSJiH+vK7gY/53AABsEAzWMPUI +RwABEDgw9QoAIgBQgiCJIsydKTAYZJBYaJFlaJMGaJQZwCDRDyY8GNtg+iwAAgAAYPBb+f1koGRm +r+UZxPMqkkpkoU8qkklkoUkrIBQLtIf7JBQsAKiS4Ion+0wAAAAQYDD6rCAiAABpMFg5ndKg0Q/a +IPw8AAAwAljwW/7oY/+z9jwYIgAAULD8PAACAABZsFv+FCswGGmzmmP/iiwwGP8CAAX/vpsgY/+M +LTEWLjEXjziKOZod/+NQAHwAA/AcxYmTHItuj20oYhIpYhGZEZ8VlRCVEpUUmhj4FgMgBRBQMPsW +ByAAEEAw+BYGICgQWDBZV/VgAB4AHMV8kxyIHY9tiWz5FgAgBRBQMPgWASAoEFgwWVftjieD6P/h +FS/AEGgw/OILIEACU7ANrQGt///8QCYAU58QKOkUDEsRC4gI+OUULgAgGvD/AgAKAFJ30MlsBmwC ++TwAABcANSBtSQUADIYASWGOoA8CAA8CAKvu/wIABgBif5CeoC8SDGTwZSU0GCU0GfU0Gy//EEAw +mDdj/nnaIPwsAAAcEFgwWEDrwCDRDywhCf4gFS/wEGgw9aQALABAbvAtpAP07hANgAQ7IP29DAwJ +AHMw/SQULAkAOzCcoSeWSWP+fI8c08D15gsvngC34MCDKDQYY/+UAADz/gwANgA1oA5PFPj8CCIA +AEmw+Eg2AgAAYPDTD22JBQIJhgBMYw5pCP9IDACAAmNwbYkFBAmGAExlDrkMqdkpnECZoGP/QgAr +3ECboGP/OWwQFiggBfXFKRIAAElwLCAHizAlUX79Cv8gBAI5MPsLRwogAWAw9RVACBAAOiDAINEP +iCL5FhUi6AC2IC4gFhbEYhnE3P3henABEHgwKCqgCMgdIhYi+cUWEgAgSjD+6QoIACBKMPKZCwAg +AhOwACEEIoJ+IxYjAPMa84J/IgBAGLDyxQwSCQAU8POGfygAIBZwIpJ/AOEE8P4aAAICELAiln8o +goAjEiMpFhDyEiIoAUXyEAzMEQbMCCzCAAzsAWTCjh7EQynggAysEabM+MI6IG4CSnAJSRQJeQmz +mf8CAAoBSU4QnBspwjn8nAACdAA2YC5iSmTiGS5iSWTiE/nE7hLdALVgKjAgKArt/wIABgF2RpDA +nnmhCigK7v8CAA4CD8KQnhr5CgAgQAJ48PkWFyAAEFAw+hYYIgAAU/AYxGQZxN6OLiiCgZ4cLhYS +CO4MiKD5ICwoAEBKMC0hFwCZEfnE1xwJAE9wAAmLDm4U+AoBLAkAR3AIjmD/AgAGAVVHkMDgKiAW +KAr/eKFmLhYcLRYeKxYhnBOfFCoSBFva6Y8ULRIeLhIcG8TGKCAHLCAW+BYTIqAQSDAJiB0sFhT4 +Fg8oACBaMPiCfyAfEEgwDJkMjBP7EiEmAbvKECkSEygSFPiIEAnABD5g+KgCCAAgNnCYkyghBxrE +tPnEtBlAAUAwDIgRCogCKJYAGMSxKiIACOgK+IIAK4AEOqD4lgMqCQBR8PqWASAAEFAw+pUFICAC +QPD0CBYAIAJScABKZfuWDyIRALVgKQoAKRYbKSAUCZSH+SQULAEwEmAmEhUMRRH1FhEm4AEwMPYW +FiH8AjEw9RIAK8AEOaAqFhkexJP7zAAAABBQMPgSFiIAAEuw9gkWAAICUrDwC6YF6AI6oPv8AAIA +bpog/sxAIAAQUDD4QhRgABAoMPgLFgACAlKw8A6oAegIMrApEhfTD2WQ6S4SGCsSGSoSG/y7CAwA +IHMw/cYQIIACYvD8Fhog3QC2oIkxhDL2kgViAABbMPMKACIBD4ZQo3yNG/zWOSIAABFw0Q/aIPsK +HCIAAGCwWD/7+iwAAgAAWPD9EhUiAABhMFg9IdKg0Q8AAAAAKJ0CKYECLoEBKIEFCe4B/PwAC/65 +Q5ArrBL8LAACAABQsFg/62P/vCusGPwsAAIAAFCwWD/nY/+rnBvz/XFgABBIMAAAACkSG4snLRYe +nBP1kiNgQAJS8IwT/xYEIAIQWDD8zEAiAABpMFg4PowTLhIXjxQtEh71rAAPGgA3oIke+cYQIAAQ +QDAoxhJj/wUbxELAoPoWGyfwBD3g8/6ibAkAX3AAKCAsGsN7ACON8AkfCDAEOiAopiYKCYsBEGtj +/QmeGhrEN4g4+cQ1EBAQeDAvFhj/PCAoAEBSMP8WFygJAEowmB7z/RpgYAJQ8I4cKOAA+BYJIgDs +4hDAkJkdKeAB/wIAAgECYlDAkI4dD5gRCO4CZ+0yY/vYG8QYGsNeDDOMAAttKSAsKqIk8JEEAAEQ +WDDwvhoJFwFQMPjuAQAPEEgw/wIADgCC9lAuMBD/AgACARp/kAoJQv8CAAAAhAZgK5z++goBIAAQ +QDALqDgoFhtj/ZwAAAAAAAAA/hIKL/AQUDD4IBUqAEBScAqbDCskFCshCfrkAyhABDog+LsRAAEQ +UDD4CgAqCQBG8PjkACoJAFbwm+EqZklj/WIAAAAAANvA+iwAAgAAYTBb0PwrEhqJMfOsAA3ABDqg +/LsIAf70hlD6LAACAABhMFvQy6OtrX2OG/3mOSIAABFw0Q8AAAAAAPosAAIAAFjwWMAMwCDRDwAZ +w5kiFiKIHyISFPIiCggAIEowCCILGMPeqCIpIX/6mQwAABBAMAiZNSklfyISImP8cgAAAAAAAPoL +QgABEEgw+7z7IAAQQDALmDgoFhtj/Kwew0nAgCgWG/P8oWwJAHdwAC6xFfuyCS/AEEAwCKoB+hYH +KgAgU7D6rEAgQAJa8P8CAAoAe1LQKRIR/wIADf50gmAoEhmriP7MQCoAlkaQ+goAI/5qASD+CxYA +AgJSsPAOrgHoCDKwY/y8KhYdiDYpMQuZFQkPP5gWKRISCA4/iBkCGYsACYstFh77FiEogAFAMAAp +Y/wWAyoAS0JQwIGYHWP99Iqi+RYIIABejpAKyk+IGAY+iwQuiwoOSfgIRAIAAEuwBhll+JMGcAEQ +UDDAoIkYepcI8AAQYgAASrAA+AoBIAAQSDAKiTgtFh6fFCsWIfwWAy2uALZgjDL6LAAAARBYMPwM +XwAAEGgwWL+ajBMrEiGPFC0SHvP9iW//EEgwwOEuFhtj+4MOuwxj/weMMv8WBCIAAFCw/RIFIAAQ +WDD+EgYt8AFgMFi/i4wTKxIhjxQtEh4qEh3+Ig4v/xBAMJgdY/0yABrDdykxDnqZeCoxD2P/OgAL +qQyZEvlJFAAAEFAw+RYBICEANmCIEfgLFgACAlKw8A6oAeQIQrAlFiCJESYWHyYSH4oSjhclFiD5 +SQwAABBYMPyqCACAAnOw+qxAI/2xgmD2Fh8h/AIqcPoOFgACAlrw8AqqAegIKvAlEiAmEh9j+z2I +GP8CAAH+WuYQLRYenxQrFiGcE/P++W8gAXAwAABsEAQmIAf0w0USoBA4MAdnHfIgFiQAICHwJEJ/ +wV8CVQx1TRYaw0f8aREIgAQ4oPqZCAgJAEDwmJDRDxzC9BvDPvIqCgwAIGHwDKoLq6opoX/zmQwA +ABBYMAuZNSmlf9EPAAAAbBAEG8MpHcLoJiAHJCAW88MlEqAQYDAMbB30SgoAIAIpMPBRBAIAIB8w +KDJ+9zJ/IAEQEDAAKRr5iAEMACBrMPyqCwYJAEXw9zZ/KgAgWrAlon+xVSWmfyMygABBBAAlGnU4 +DxPCVgxiEaMigiACUgHRDwAlrQIoUQIkUQElUQUIRAF1SwPAINEP0Q9sEAYrIAeIIh3CTPrCSRog +AVww9YCZZ8AEOuAt0ICqZvxiOiBuAmtwDU0Us93/AgAKAFPvECliOfycAACmADZgLqJKZOCBKaJJ +ZJB7KyAUC7SH+yQULABREuAtIAT6Cv8oTgA7YAUOR2jiGIon+0wAAAAQYDD6rCAiAABpMFg24tKg +0Q/AINEPKyAserHWiTGcEIcy9pCgYgAAWzDzCgAiAF2GUCNmOWP/ugAAAAAAAPosAAIAAFjw/EwA +AgAAaXBYO5fSoNEPANog+wocIgAAYLBYPmhj/9fz/1xgABBIMAAAK7wY+iwAAgAAYLBYPmFj/7wA +AAAAAP8gFS/wEDgw/iEJJgBAPvD3uAwAARBoMPgkFC5ABD/g95QDL4AEO6D/CgAuCQB7sP+UAC4J +AGuwnpEtpklj/yHbwPosAAIAAGHwW8/IixCJMZoR86wADcAEOqD8uwgB/6aGUPosAAIAAGHwW8+X +8/86YgAgHrAAAGwQBBPCMSMygQMiDAJiFNEPAAAAbBAEIizu0Q9sEAqVEY1C9hYAIBACOTD/PAAA +ARAYMP8WAiYBDb9QFcIX+cI/H/0QeDDwIQQAABBYMPsWBCAAEHAw8DYaD/8QQDD2FgMmEQBBsIzR +iNCYwIPQnRUr3f6cMSOSf57RntCMQiiyfvsWBiAAEFAw/UEMIAEQWDD3zAwJkAQ6IPy6OAIAIETw +iDKaFyxBDfoyBygAQDIw+DYCIAAQEDD1RQ4gtAA3ICyiDCupFPqiCSBgAmqw/c0MAZACYzD0sI5i +BQBrMCoWCGUgR4oY9cHsEDYANqAZwcIooAAVwekJiAooghD8oAciAABasP0KAyIAAFDwC4AALEER +K0ENx/36FggqAC1m0MwoiBhlj7mMMmAAUxnBsyggAAmICiiCEPwgByIAAFiw+jwAAAQQaDALgAAs +QRErQQ3H/fy7jXIAABKwjDLNz2ABBAAAAAAAAPP/cmAAEFAwLUUNY/9JjDJlwARlIELPrx7CWXzg +MtrAWT6A26DyCgAiAABQ8Fg314syihOIFolC/xIFKgkAWrCaMp+RJ4aBKYaAn0IiRQ7RD37HHg/M +AZwyiROOFohB/RIFKAkAZnCZMp2AJOaAKOaBnUGKF8Dg/kUNII8AtqCLFLG7+xYEJBgAuuAZwdKN +QmP+aoxAdMlPjRdk0EqIEIkSjxEAgQQYwWz8wjUfwAQ/4P6SoC4AIEfwivH4kqIgARBYMPC7Gg// +EGgw/bsDCgBAYrD77gEICQBSMP6WoC4JAEOwnvLRDwDRD4lAdJGt+kwAAgAAWfBYv6aNQmP902Wv +VooYZa9RY/8NK0EMjRD8EgEsgAQ/YP3BUBoJAG7wDMwRrcybw2P/aQAAAGwQCAZkCgNEC41AkxAc +wUf7CgEmALBtEBPBpPAhBAAAEHAw/hYDK8AEOWDwtRoKACBisJoS8GEED/8QQDDwuBoEEQBFcPgW +ASAAEEgwh9GK0JpwiNAi3f4uMn+XgZnQmdEiIn6IQAkiEfSIDA4AIBOwnhT94gcgABA4MPziAiAB +EBAwCCc4+tIMIAAQEDD42RQsAEArMPzmAiBgAltw+6sMAZACUrD0gGpiBQBasIrZ1qDPIslvGcEr +KGAACYgKKIIQ/GAHIgAAWbD6EgQgAxBoMAuAANagzC1lb9WLEowRi7B8sFFgADMZwR8oIADTDw8C +AAmICiiCEPwgByIAAFiw+hIEIAQQaDALgADz/6RiAAASsPP/mGAAEFAwzXeME7HM/BYDJCIAuyAT +wV+NQPP/GmAAEEgwjUB02S8cwcaJEI8SixEokqKK8S6SoMff/bsDCgBAYrD77gEICQBSMP6WoC4J +AEOwnvLRDwDRDwAAAAAAAPBhBAPABDlg8L0aAgAgYLD5EgAv/xBwMP7BshwRAHdwiiEvkqAokqIO +qgH6iAIOAEBv8P+WoC4JAEfwnyLRDwBsEAQYwaiFICiCfxPBp/hVDAKgEEgwCVkoo5MtMn8NDV/8 +CgAgYAA3YB/BjhvBTiT6//+7CAAAEHAw+5sIAAEQeDBtCBcosn/9HRQAFAA2IC62f7HM9NAsYFAC +WvBj/+EpMn7BrwyqDPgygCf/8lJQKswQAKEEAPkaBJkDCYgBKDaAY//NKTKAyZcrMn4JuwIdwYcM +XBGtzPvGACAAEBAw0Q8A2iBb26UtMoAsMn4NzAIewX4MXRGu3fzWACAAEBAw0Q8AAAAAAGwQBMAg +0Q8AbBAE9MFoEqAQKDAFIij4wSEUACAgsCRCf8FfA1UM9UUScgAgQLADNAoCQgsiLQ4iITTRDxLA +3NEPAAAAbBAE+8FoEAAQSDD6MgAgDRBAMPz6/yIAACiw/FQWIAAQEDDyVRsq4AFQMPOkCwGCADag +KjAIGcFc/wIACgCywpAJqQqJkAqQAIYz9odCBuABMDD6fAACAABZsFlSuBvBUSdUDCZUDSihByhV +B2ABMypQB/syAyogAVAwWQ7iG8FJKlQWYAEcjDMsVBZgARSKM/8CAAQAh4Kg/wIABgCDgqBopSto +pyj4qCVgCRBoMP8CAA4AeOqQLlAg/woEIAIQQDD4VAUuCQB7sC5UIGAA0ylQIMCoCpkCKVQgYADF +jDMsVRtgAL2NMy1VGmAAtSmyfY4zKLKA8IAEDgAgS7D5DwYB/gJzsP+ygi4AQHuw/g4ZAAIQQDAI +7jf/7jYA/xB4MA/uNi5UI2AAeYozmlxgAHIpUCKKM5pb+lYJICoANmAtsoDw0QQB/gJicPDMGgAB +EGgwAN0a/dz/LAAgYrANzAKcWmAAPZpaYAA4jjMuVQhgADAZwQ6IM/9QBygAIE4wKZCAKgr7+v8B +CeAEPmD5/wIA/BBIMAn/AQj/Ai9UB2AAAcYquDP4Cg0v/0Sg0ClRG2WQWB7A7RzA/i2yfSpQFitR +Gv3MNgD/EGgw/yqgIKoEarAtUAcNDUEP3Ryu3i7if8H/Cv8M+qkKBAAS/5AewJqu3g6ZCymdDimR +NAnPNgv/Nwv/LA+/HC9VG9EP0Q8ZwFYJzzYL/zcL/ywPvxwvVRvRDwALyCwIuBwoVRvRDwBsEAoo +IAT8wA0W4AEoMPds/iABEEgw95c5AgCygiAnFgr/AgACAAA48P8CAAIASIGgjSIuIAf10RpqIAFw +MCsgIQsZQmWRjMCVCgZHDGYRrGYoYjr/AgACAItGIChiOZkU+BYJIQkANiD6LAACAABZMFvbeIlw +/wIAAgDPqlArICH7HBQABxBQMP0SCigBC+KQytX6Igcg8RBgMPy7AQIAAGkw+yQhIAAQYDD6rCAi +AABZMFg0mNKg0Q/AINEPKSAF/wIAAAEEhmBolzn/AgAIAVMCYGWfWR7Aci7if4nhi+CbkIrgjyAo +7f75pgEgABBoMJ3gneH/hn4h8AJzsJ4nLSQgLSQhG8CfHMAD/cCfEAAQeDAvJBQvJBcvJRv/JRog +CBBAMPgkBSIAAFCwW9rU2iBb2rcpICEqCv76mQECAABY8PkkISIAAFCwW/8hHL+7Y/7c+iwAAgAA +WPD8TAACAABpcFg5MdKg0Q8AAAArrBj8LAACAABQsFg8AWP/1Ikw+QlHAgCVgaCLIiogB/Wzomog +AVAwDKcRrHcrcjr/AgACAcJG4ChyOfgWBSN5ADYg+iwAAgAAWTBb2yaJMP8CAAIBxSpQ/wIAAgII +GaDAINEPAAD/AgAAAH0GYP8CAAIAiIJg/wIAAgF2BmD/AgAEAZUCYMel+v9QAAcQaDD+CgEgABBY +MP/rOAAFEEgw+tk7DjcAtuBj/zopIAcYv9r8EgkuAgFMMAr/EAj/Ap/AiCD9v4oQAxBQMP8hCCAg +EHAw/sYDK4AEPiD9xgIqCQBW8PvGASggAUww/SILKQAEPmD5IgkuCQBP8C4gFBvAAZnI/cYJLoAE +O6D9EgQuCQBf8P/GBCgJAFow+MYGIAAQWDD7xgUsCQB3cJ3HKyQUKmY5Y/3ZKArxCLsBKyQhY/3g +ZJ7VH8Ay85oLAgAAOPD6Fggg+xBwMPABZmALEGgwwCDRD44rjSl+0QbA8p8iY/8TKArx+LgBAAQQ +SDAJiAIoJCEMphGsZiliOv8CAAIBfMZgK2I5ZLLuGcAe+iIAIAAQYDCcEZkQiHAtCoH4CEcAARBw +MPSIEQAAEHgw+BYCIAAQYDBYNvMcv0HAoypmOY8iKSAGwOb9ICEgARBAMPj/AgACAkpw+SQGIPEQ +QDD/JgIsAEBHcP0kISwJAHdwLSQhY/6AAAAAiieHqP2hFS/AECgw+6ILIEACcrAF5QGl3f3cQCYB +Pj7QKKkUDE8R9/sICAAgejD4pRQqATnfUMk72TD6fAAAFwA1IG1JBQAJhgBKYYvgDwIADwIAr7v/ +AgAGAUpu0JvgKnIA+g1HAgAASfBt2QcukAho4Q24mcDxnxrz/D1gAxAoMIuTLfoADaoBC6oCmnAo +ICErCvH7CgIoAEBaMAuIAigkIWP/zX2pBIhzKCQWiRi4d/8CAAf+rs3QKnAIZKBmaKE6aKLnaKMs +aanZiXNuk9xpk9mLJ/j6wCBAAlLw+AoAKgBAQrD4tRQggAJSsJq5mrhj/7gAiXMpJQhj/6+Lc/og +BygAIHrwKICA/qoBCeAEOiD4qgIA/BBAMAiqAQuqAiokB2P/hotzC4pC+hYGKuABXDCbF1lRFxy+ +4x+/siihB4kXixYrJAwpJA34JQcgCxBoMPP/VmD7EHAwAAD/AgAD/o5/UP9yAC8AEEgw+Ar8IPEQ +aDD9vQEIAEBDsPn5AQ7gAXww+pkCDgkAR/D/JAcgCBB4MPl2ACwJAH9wLSQhYAABiXDz/NZq4AFI +MAAAK6wY/CwAAgAAULBYOxP6LAACAABY8PxMAAIAAGlwWDg50qDRDwAoIAcavw37EgUoAgFEMAqZ +EP4hCCgJAFZwmbD9IgAgIBB4MPy+uxggAUAw/LYCIAMQSDD/tgMrgAQ7YP+/OhoJAEqw+rYBKQAE +OiD4IgkuCQBDsIor/CAULgkAe7CetPi2CCwJAH9wnbb4zBAABBBoMPq2CSAAEFAw+rYFLAkAazCc +tyokFPl2OSP9/AGgiif7TAACAABpMPqsICAAEGAwWDNJ0qDRDwAAACusGPwsAAIAAFCwWDrfHL6O +8/vrb/QQUDDA0J2r8/2/YgAAOvAA99sMADYANOALTRT43AgiAABI8PhINgIAAFHw0w9tiQUCCYYA +SmMqXED9SAwIACBc8G2JBQQJhgBKZQv5DKlZKZxAmeBj/XIAKlxAmuBj/WlsEASJJyggBiuZFCqc +IP2SCSH+AkIw9LB+aOABQDD4JAYgDgA2IMAg0Q8AAAAAAAD8CiogTgA3YCvQAHy5Q/6RFS/AEHgw ++kz/LgBAfrD8qxEP8BBAMPvbCA4AIHuw/uxAIEAEQPD53BAgIAJa8Pg8ECoAGN+QaEEIbakFAAiG +AElh+iwAAAEQWDBb2LbAINEPAAAAAAAAAPgkBi+KALYgY//eDe0MLNzwDEwUuMsLqzZtuQUACIYA +SWH8SgwIACAbcPn8QCF4AD6gLaz/bdkFAgiGAEljY/+oAAAAbBAEjDGIMvosAAIAAFjw/AxHAAMQ +aDALgADSoNEPAAAAAAAAbBAEKCAEIyAH8wNBBhAAOiDAINEPG78C0w8rsX77KxQCAABQsFjXQ2Wv +5dog+zwYIgAAYLBYOnfAINEPbBAEGL75ii4uIAccvoH5IgcgABAYMP4OQQYAW0aQI8J/CaQRpDOE +N4ROKJkU+5IJIKMANiApsBTasP2wFSAOADZg2iBb2QTAINEPAPnCfyCMADdgiZcvmRT8CgggBBBo +MPuSCSCHADfgL7AWsP8PzTgfvggM7BGvzCjCOv8CAAoAXG4QLMI5+QpLIK0ANyCPsSggBR6+1p6w +/w9HAI4ESjDAkAiYEQj/Ap+xLqAU+KAVIBUAt6BkgJgpsBb4kTRh/gJScCq0FtogW9jjwCDRD2P/ +VgDz/11gABBYMPP/kWAEEGgw8/+7YIEQSDDz/3lgABBYMNogWP7nZD/KK0AoLEAp/UAqK4AEPuAM +uwL8QCsrgAQ+4A27Agi7EQy7ArG7K0QrC4sUK0QqC4sUK0QpC4sUK0QoY/+OHL6u/KYAIDACW7D6 +LAACAABgsFg6I8Ag0Q/aIFj+z2Q/bC1AKC5AKf9AKi2ABD9gDt0C/kArLYAEP2AP3QII3REO3QKx +3S1EKw2NFC1EKg2NFC1EKQ2NFC1EKGP/MAAAbBAKKCAE9yAHJgHVjiD2CgAkAdGiIAUNR/cHQQIB +zgNgGb4Vii4pkn8JqhEKmQgpkAX7MQggQhBAMPslCCA+EFAw+yAWJgH3VlD6Cj0mAfNGUPwK/y4C +C1JQKDIJ+AlBAAQQIDAJRAwEBEH0TA8v+BBIMAlEAfRMfygAICIw9EQUAGgCQjD4FgUgNARi8Pzc +/iABEFAw+iBBLAUAYrBYOYtko+cZvZYMehEPAgCpqiuiOrRI/wIACgHORtAlojn4FggjkQA1YBi+ +Zi4hIiYWACcyCS0gQfy+YRAIEFgw/hYGIAQQSDD93QkKIAE4MPqZDAAHEFAw/N0RCCABTDD5FgQs +ACBrMPzCfygJAEJw+iRcJgAgTfD7JGQgeAI58PwWByIAAFhw+r5PEAMQYDD6JSopgAQ6IPgWACDK +AlCwWUk2jhcmJTUmJGj5IQcgLhBQMPokVyBSEFgwKyQF+r1tEEIQWDD7JHQpQAFMMPu+QBnABD5g ++hIGKAkAVnCZUBm+PPgiACBEEHgw/1YDLMABdDD+j0IOBwFwMPrcFA+ABD/g+IgRDAkAf3D/vjIY +CQBBMPhWAStABDqg+L4rGgkAWrD4VgIvUAQ7oPggQS1ABDsg91ULLAkAczD6VgYsCQBrMPZVCikA +BDog/1YHKAkAYjD2jxQICQBKMPhWBCCQAnCw8g4WAEACaXAATWP6ISogABBgMCxUMSxUMvxUMyAA +EFgwK1Q1K1Q2+1Q3IAAQSDD5VDAgABBAMChUNC9ULipULSZULwqKFCpULC4gVy5UOw6OFC5UOg6O +FP5UOSC4Aliw/o4UAAQQYDD+VDggeAJRcFlI6faMFADAAkCw8wgWAIACSXAASYoACIgACYomVFMX +vRssVFKIFPyMFABAAkjw/FRRILACUXD8jBQAEAJqMPxUUCoAIEVwBgmIAMqKBAmIAIqKLVYbGb0V +KVYaKiB0KrR0iDGMGPshByjgAUAwmDEoIAcfvVf9vVcfwAQ5IPsLSgoCAUAw/LsRCqAEOqD6uwIO +ACBxcPQhCCoJAG7wm+CNIPnmAiggAUAw9uYFKwAEOiD25gckCQBRMP/mBiQJAHkw9OYEIAQQeDD4 +3REAMBAgMPTmAywJAH9w/eYBIEACI7AGA4YARGcEA4YARGUMjxGn/yz2OSsgFi4K/36xCCogQSwS +BVg4viYhFCMhEvQKACAtADWgFb28ymL6Un8iAABY8PwKACABEGgwWDEbKFKA9EwBIAICGPAIMy52 +SdvaIFgupMAg0Q+KJ4uo/KEVL8AQeDD5ogsgQAJysP4WAy4AQHuw/hYBLAAgczD8zEAmAGJeUCmp +FAxIEQiZCPmlFCoAIFow+BYCKgBdVxDJOslIC7kCbUkFAAOGAElhihOOEg8CAIqgDwIArqr/AgAG +AHNmkIwTmsDz+/ViAAAa8AAAAAD6LAACAABY8P0KhCIAAGEw/TUIIgAAaXBZBCfAINEPAI4iZe9b +2iD8LAAAMAJZ8Fg498Ag0Q8AAPosAAIAAFjw/wqFIgAAYTD/NQgiAABpcFkEGcAg0Q8AiCJljyMr +IEHaIPu8EiIAAGCwWDjowCDRD5ar8/t2YgAAGnAAAAAAAPvKDAA3ADTgCkwU/swIIgAAQPD+TjYC +AABK8NMPbekFCAiGAElpiRGqOPxPDACAAkpwbfkFCgiGAElrjhKMEQruDP4SAywAIHMwLMxAnOBj +/yGPEYgTL/xAn4Bj/xUAAGwQBvgiByAAEGgwnRAqIEEbvU4nIAcKrAn5iRQtwAQ7IPOCCSoAIGbw ++7J/JiABPDD7FgEjKQA2YPgKSSMhADTgLjAS+wpVIxoAN6ApIAX8Cv8mAYfeUCsgFvgkBSAaBGLw +AMWOWDhUZKMywEEZvF78eBEADBBwMPmICAABEFAw/YI6IgAAeTD0rzkABBAwMA/mOf8CAAoBdLdQ +JYI5+7x5EuYANWD3vFgSAABBcPALBwIAAFFwbWkCAEhhZEGkKiEHG7xOCgpKDKoR/b0nGgkAWrAq +VgApIgAYvR36CmQgCBBwMPdWAimABD5g+lYDKAkAdnApVgH4JSogBxB4MP8kXCADEGAw/iRkIgAA +WHD9FgAgygJQsFlH+x29EIkR/iEiIC4QWDD7JFcgQhBgMPwkdCBSEFgwKyQF/CBBIAAQWDArJTUO +3xT7JGgvQAQ7oPkIRgpIAUgw9P8RCAcBTDD4qhENAAQ7IPqIAglQBD5g+bz8HgkAT/D7VQogVBBQ +MPi89h4JAEfw+lULLAkAezD5VgcsCQBrMPxWBC4JAEOw/lYGIJACQLDyCBYAQAJ5cABPY/ohKiAA +EHAwLlQxLlQy/lQzIAAQaDAtVDUtVDb9VDcgABBgMCxULvtULyAAEEgwKVQw+lQtIAAQQDAoVDQK +ihQqVCwvIFcvVDsPjxQvVDoPjxT/VDkguAJYsP+PFAAEEGAw/1Q4IHgCUXBZR7n5XEAgwAJAsPMI +FgAAEGAwAEmKAAiIAAmK/FRTIAAQaDD9VFIgABBoMP1UUSAAEGgwLVRQ+yB0IIAQUDD7VHAqACBR +cIgxHLwxLyEH/SEIKOABQDCYMSkgBxu8LYgw/w9KDgIBSDD8/xEOoAQ7oPiIVw4JAHfw+QlBDgkA +X/D/pgAvAAQ6YP4iACwJAHdw96YCIDAQWDD7pgMsCQBncP2mBCAEEFgw/KYGIAAQYDD8pgUvgAQ7 +oPymBy4JAFuw/qYBIEACerAGA4YAT2cEA4YAT2WMJx67vfv6wCA1EHgw/J0RAEACYzD7ywEMACB3 +cPbWOSAAEGgw/cUEIIACWvD7xgEgNhBQMPvGACCEBFIwf4FFykgrIBYoCv94sSD6IEEgVBBgMFg3 +hcAg0Q/EnykkBSogaLGq+iRoL9oAtSDAINEPKCQF8/0EYAAQIDBkT9vaIFgtb2P/2MWyKyQFY/+x +8/0aYAAQKDCMImXP0Nog/CwAADACWfBYN+XAINEPjSJl37orIEHaIPu8EiIAAGCwWDfewCDRDwBs +EBKVFpcUIhYb8xYFIgAAWTCbF/MSGyIAAHjwErxdjPD2MAciAABpsPgwQS/wEEgw9DEiLOABYDD0 +FgosACBj8PR8AAB+AmMw9zIOLABASzCcGYrBCIgJ9gZBCcAEOiD4bBgiACBAsPgWCCAgAmMw8iJ/ +KgLPU1DA4PIWASAAEFgwDtIMHrvJLuJ/CX8Rr+4u4Tcoev//AgAKAuRyEBW79yYWAxe8RCdyf/8C +AAIAADHw/wIACgBK01AuEgkv4gMCqgz3FgIuACB8sP7iAioAA5PQLuwBiBT3CgAgApImIP8CAAAC +jiagwCBtCFoKSDT2KQoIAQDBcJiQBigLn4OegomQCUQM+aoMAAICELD/7AAIACB6cPgWCyoAA0oQ +se/+/AAAAgI58P8SCyAYADyg8goAIDACMbD/AgAAAlolIP8CAAACViagY/+eDLoKDL4Lj+OKoJcS +/uICLgAgfLDyqgwKAAMT0LHuwCDyFg8gABAQMP8CAAAAUqUgLRYaYAAriB/7vAEoACBB8PgWDyAY +AD7g+woAIDACYzAMvgsMugqKoI/j/uICIAA4JSD3CgAv0AA2oGpByA8CANMPbQhU9ikLCAEA0TD2 +LQoIAQDBcAhEDAiqDJjQ/pYCIAICELD/lgMsACB+MPjbBnIAAHuwse/+/AAAAgI58PghDGIAAHtw +8goAIDACMbBkr3P/AgAB/7glIGP/nwAtEhrAsJsQKzAWhBT2EgIg/xBIMP0WFyAkBErwjBYqMEEA +zI5YNvBkpDGNH/m6+hNoADdgHLvUixqFE/8SASCQAlDw+hYQILgCQPD4FhEgwAI48CcWEv8ORgAA +EDgw/4JCBcAEPWD73RQLQAQ+4PTdEQoJAGbw+xYTJAAgTXD1Fg4jgAQ4oPK7Cx4JABOw8hYMLgcB +fDD1Eg8vUAQ/4P8KACwJAH9w/xYYLAkAd3D9FhQgCgIpcPUWFiAAEBAw8AAQYAUQKDAAKBIW/wIA +BgFvRVDAlQlZL/SScWACAilwKgqAqncpMQcautEJCUoMmREKmQKZcIgw/LulEEQQeDD+u6EQCBBI +MP52AimABDog/3YDKAkASjCYcS0wQQYoCoqAKxIU+BYVIAQQSDDw3REKIAFQMPqZDAoJAG7w+ruU +GgkAZvCbdPsSECggAUwwKRYZKIIA+nYHIAAQUDAqdQr5EhMoACBKMPl2BiB4AkIwKHUL8AsWAEAC +SfAASWEpMSr6dC8gABBoMC10M/l0LSAAEHgw/3QwIAAQWDD7dDQgABBgMPx0MiAAEHAw/nQxIAAQ +YDD8dDcgABBwMP50NiAAEFgw+3QuIAAQeDAvdDUrEhEvEhgJiRQpdCz+MFcuACBH8C8WGC50Ow6O +FC50Og6OFC50Of6OFAB4AlHw/nQ4IAQQYDBZRkv5EhIggAJR8AIJiABKigAJiAAKiisyHCoSFit0 +UwuLFCt0UguLFCt0UQuLFPt0UCB0CFFwLBIZ/btYEIoCUfD7HAAAQhBwMP40dCwgAWAw/QoILAkA +azD9NGUtgAQ7IPwWACADEGAwWUYxBigLLDE1+7tLEDYQaDAtNFf9EhUgAgJjMCw1NSt2ForQKnYX +iYMpdhmIgih2GIjQLzIc/jIPLgAgR/AvNhwvEheN0CIsAfhEDA4AIH4w/xYXLAAgd3D9Ng8gGAA8 +oPIKACAwAjGwGLpYKHYaKBIZwOUOXi+4jy92G/8wdCgAIDow/4R0LdEAt6CJHwWZDLaZ/wIAA/7h +QmCMHosdK8Y5KzAWKgr/erEIKjBBLBIYWDYaKBIXjxX0/hMARxBIMCk0BZ74lPmY940yZdCW2jD7 +EggiAABg8Fg2hNEPjx+KHvX/DAAFEGgw+qI6IAwCe/AN/zYN/xH/Fg0qAEL+kIceJ3I5ZH+riBz+ +fAAAABBQMPAIBw1gADfgbQgJsarwDqAH/qn+kGP/74sT/LsRAAAQUDD6FhgqACBO8Jsejh6NHS3m +OSswFiwK/3yxCCowQSwSGFg18osVjBf9EgYiAABQ8Fv9l9EPAI/DjsKKwJcfY/t3AAAAAADz/+xg +ABAQMPP/gGAAEDgwAACPGY/0+v8IAgAAcrDyFgEqAC9/UMCw8vwAAAAQeDD//AQiAABwsPj0D2AC +AlrwLMwY/woAIAAQWDCs8oIgriJy29v/AgAL/RVzUA3iDGP6IiVKAPYWAyQDAC+w8/ozZeABLDAo +MEEojBKYGGP+uvP/0GAAEFgwbBAILiEi+iBBIgAAaXD1IAciAABhMPYyACIAACGw9BYEIgAAefCf +E5wSnRH6qAkAABA4MPcWACbgATAw97qzFCABLDD7IBYgMAJJcPkWBSnABDog+Ar/JgAgRfD3cn8g +MARC8CwSAS4WBwDMjlg1wv4SByI5ADagGLnMDFQRqEQtQjr/AgAIARfDYCVCOWRSJB+5yi0hBw7Z +FPeMQgrAATww9jcICgcBODD1qhEJQAQ+YPjMEQ1AAWww/LsCDcAEP2D8upUcCQB/cP1WACgJAFZw ++CIAIEQQUDD7uo4YCQBecPpWAyB+Ajnw+IgRAAgQUDD7VgIoCQBSMP66iRtABDug+FYBL/AQWDD4 +IEEmAEBd8P1yASoJAGKwmlb+VgcgBBBgMPCIEQYgAWgw9sYMCAkASjD5unoWIAEwMPbdCAAAEHAw +/lUKIHgCa3D9FgYoCQBKMJhU/VULIJACWLDwCxYAQAJRcABKYf0hKiAAEEAwKFQ1KFQ2+FQ3IAAQ +eDAvVC7+VC8gABBYMPtUMCAAEFAw+lQ0IAAQSDApVDEpVDItVC0pVDMNjRQtVCwpIFcpVDsJiRQp +VDoJiRQpVDn5iRQAeAJRcPlUOCC4AliwWUU9KSxg8wkWAIACUXAASooACYgACoopIhwYulIpVFMJ +iRT5VFIgigJRcPmJFAIAAFhw+VRRLiABMDD5iRQOCQBDsPlUUCAIEEAw+CRlIEIQeDD/JHQvgAQ7 +oP4WACADEGAwWUUkH7ll/iE1IDYQQDAoJFeMcP1yASACAnOwLiU1LVYXLFYWi3MrVhmKcipWGIlx +KSYcKHIBKCYP/1YaIBACcbAuVhv8IHQsACA1cCzUdCsKCCtGOSsgFioK/3qxCCogQSwSBlg1IfwS +AiIAAFCw/RIBIgAAWPBb/MXRDykgQSmcEikWBY0T/BIEIEcQcDD+JAUgABBYMJs4nDedOYoiZa/X +2iD7EgUiAABgsFg1g9EPAABsEAYoIAT/AgAGAHcOIPs8AAQAcyIgBQhH/QoAIgB9AiAZuYeMLimS +fwnMEfqyACgAIGZwKJAFLrEI/Ao+KuABUDD+JQgmAJ3mECwKQv4KPSYAmGYQ/LmuHgCg8hAoIAX/ +Ckcg0AI6cPb68CYApH4Q/rnvEEkQSDD/CggmAMBOEC0kaC0kZi0lNS8kZC8kZ/4lKiAuEEAwKCRX +/iIcL4AQSDD5JGUgARBAMPgkXCBBEHgw/yR0IAcAN6AoJGjFgigkBYi7qrkpnD/2mQEKABfHEImQ +CQlHaZEiKnEDeKMc2iD8TAACAABpcP+yBiAAEHAwW/8KwCDRD8Ag0Q/aIPxMAAIAAGlw/7IGIAAQ +cDBb/WHAINEPAACIJ/uCCCfABD0g/IEVL8AQcDD5ggsgQAIyMP+JFC4AQHGw/hYALAAgczD8zEAm +AIfeUPt6CA4AID/w/4UUKgCH1xDJN/m8AAAVADUg2DBtSQUACIYASWEqYgAHqgj/AgAGAJtmkJpg +Y/6f2iD8CoQiAABpcPy1CCIAAGEwWQBIwCDRD9og/QqFIgAAYTD9tQgiAABpcFkAQcAg0Q8AiCcu +iRRk4FeIiS2CC33Dbwq/CC/8Pwb/AS/yAA8PR2nxXSqRN32jV/osAAIAAGEw/oIHIgAAaXD/ggki +AABaMFv+ycAg0Q8A+iwAAgAAWPD8TAACAABpcFv8M8Ag0Q8Ajdv9wxpwABBAMKq8LMw/BswBjMAM +DEdpwQUukTd966f6LAACAABhMP6CByIAAGlw/4IJIgAAWjBb/RHAINEPAJ2L8/3HYgAAWnAAAAAA +AAD7ygwANwA04ApMFP/MCCIAAEDw/082AgAASvDTD235BQAIhgBJYYkQqjj8TgwAgAJKcG3pBQII +hgBJY4wQCn4MrswszECcYGP9co8QL/xAn2Bj/WhsEBYjFiEiFiIrEiKMMCQWFv2xFS/wEFAw/rAH +LOABYDD4sg8mACBk8PuyHCB+Ajnw+xYcLiABcDD+Fh0mAEBV8PsWHiRCADYgLBIijnMrEiEswRMU +uVL7sgsgABBIMPTDkW9gAXAwm1GZUCgSIg3DDC5CZC+BEiKBECaBEfiCFi+gBD/g+BYALgAge7Au +FhUqQpr9uMoSAABgsPX6/yD1ADSg+6wAAAAQcDBtKSWCc6Li/3ICKgADcJCx//7tECgAQGyw+bYB +KABAK/D4tgAgEAJa8P8CAAoAZ7MQIxYjbQiriXTA4fnJEgtgAUww/goAKgUAX7D6ywsIACBecPSQ +n2NABD5ggnePdvzMASIAIBOw/SkBCgADcJCx/y7tEPm2ASgAQCvwmLDz49lwEAJa8HbBb4l1wOH5 +yRILYAFMMP4KACoFAF+w+ssLCAAgXnD0kDJjQAQ+YIJ5/MwBIgAgE7D/cggoAEBssPm2ASoAA3CQ +sf/+7RAoAEAr8Jiw8+PWcBACWvD3fBgqAA0zEGP/TQAAAPwKAC9EALWgYAAHAAB2yY8jEiMfuBwe +uJUUuB8oEiIbuBYsEhUpgSMogEAduDr6mREAABAQMPWCzmwAIEswKBIc0w8IZgwpEh4KmQv5FiAj +OAA04CUSHQxVEfsKCiQAIF1w+lI6KgMAXPALtwkPdxH/AgAKAag+kC1SOWTTSSoSIgszDCiiHCmh +FSKhIwi4CiimHPi4IBIAIFiw8qUjKAAgXnAppRXwCAcCAABLcG15AgBJYScWGiUWGfMWIyJCADbg +KxYTiRAtFhT6zAACAAAbcPqZEQAAEBAw+RYfIAAQODBtubApEh+eMCsSIgpdFP02AyACECgwlTKI +sJk39DYEIEAQYDCcNfwSISAGECgw+I0RCAkAejD4NgYsCQAvcJ0xjMucOPwSICAAEEgw+7IPIFAC +KPD5NgsgABBAMPs2CSIAAGjw+DYKIgAAWLD2KyN8ACBh8I/BjsD/1g0gAgJa8P7WDCAQAmtw9dES +cBACYzB2s+DA8PP/32AAEHAwAB64Ox+3wPd8ICAIAhCw+qxAIMACGPApEhPzEiMgABBQMP0SFCgA +gFZwLBIZKxIa+8Y5IKMAtOCOEC8SFgruEZ7wLxIi+ZIJAAAQYDAs9RUs9RMs9hwq8SH48REgARBY +MPv0QCBREHAwLvQF+ogMA7AEOKD49SEiACATcNEPm1EoEiL5VgAgBgIpsAUlFC+BFCKFECaFEfNc +AALxALfgC8sUs7sLKxT6EiIgBgJa8PsWGyIAAGBwARECWAdDLRIiKhYVLBIbLNUULhIVLxIi9fUT +LKoAt6DAINEPAAAAAAAA/HIBIBEAN6CuzCzN8PAABmABEDAwwGBqwRP8DUsAARB4MPzOEgwFAG/w +rt2tZoxwDwIADwIADAxHsMzybAAB/68nIN1wiNQPAgD4DksAARB4MPjIEg4FAHPw/Mz/LgAgQ7D0 +wCJmACBxsI7VDwIADwIADgpL/s4SCgUAU/AOqgj8zP8mACBRsP3cGCH/3I8gY/8Jj3MoEiIPD0uf +j2P7tPP+pWAAEEgwJRIiKBIhhV+IhwANi/cKASAQAkhw+MgUBAUALfD4VQgABBA4MG16AgBJYbBX +BwdB9XCQYBACKHDAhPVpCwADEDgw+RYXJgEAvbD3Fh4iAAA6sG2KJigSF3hbDINxiXBgAA0AAAAA +AADzCgAgABBIMJNZmVj3fAggEAIpcGAApwAqEiIvEhb+EgAgARBoMP2kQCBREEgwKaQFIqUVIqUT +LKEhK6ER8qYcL6AEO6Ce8Ay7DPulISIAABHw0Q/AINEP0tDRD7F49xYSJJgAviAFcwv5CgQgABAo +MPeZDAIAADqwbZkudlsJiXCIcSgWGGAACcCQ+RYYIAAQSDD5NgggAgIpcPgSGCAQAjnw+DYJIBAC +GPAnEhLAUwdVDHZbBSUWHmAAAiYWHigSHQyIEauIKBYZKII6/wIABgB0wiApEhkpkjkpFhQoEhT3 +jAAA3QA2IP52ACACEEAwmHL4EiIhgAIrMAVVFJVziYD4lREICQB+cPl2BiAGEEgw+RIAJAkATXD0 +dgQpoAQ+YJl3KRIh9XYBIEAQKDCVdYmbKXYI+IIPIAAQSDD5dgogABAoMCV2C/V8MCBAAkhw+HYJ +IAUQQDBtigUACYgABYopEhnAhiiWOSkSHnlrB/AACmAAEDAwKBIeCGYMKRIi+BIeIAYCGbADIxQo +lhwolSEilEAjlRNj+zorEiIqsRIpQmT7shYroAQ6oPsWACgAIFZwKRYVY/0dwIAoFhRj/xspEiIi +lRMiEhTRDwAAAGwQGiggBCkgB/csAAYArI4g+goBJACooiAjFir1CEcIIAFMMPkWKSH8AmIw/Kw5 +AtgCOiCKJ4uo/KEVL8AQEDD5ogsgQAJqsPapFCIAQBNw8swID8AEPSD8zEAmAyzeUK9m9qUUKgAg +W/D/AgAKAy1XEMkyyUALuQJtSQUAA4YASWEq0gAPqgj/AgAGA1BmkJrQ07DzFiogARBgMBq3Bot+ +KqJ/CbsR/RIqKgAgWrAqoAXD7v3RCCBCEFgw/XUIJgLs9pD+Cj0mAujekPIKSS4DIHKQKnAFwFH2 +Cv8mAyuWkCtwFnaxCypwQVgyh2SnLSpwBSJwB8Wx8gJBBgBO3pDFlP8CAAYASc6QLBIqGrcdjMt8 +o1ooEiqJgAkJR6mI+Iw/L/AQSDAJiAGNgA0NR2nRPYp/ZKU9E7dlKjJcLqEELaEFL6ECjKD+7P8t +wAQ/YPzuEQH+Anvw/6UCLAAgczANzAxgBAXAINEPAAAAAAAA+xIqIgAAUfD9HAgiAABgcFv96mSk ++SgSKvkSACAAEHgwn4gphgkqcAUdtmcMLBH9zAgAVBBYMPwWKCYAqt6QlRQctqErcQj4EiogABAw +MJYYlh4mFhImFhT2FhogABBIMPkWBi//EHgw/xYbIAAQUDCaF/8WISAeEFAwKhYW/YILIAIQeDCf +GYmJKRYZLxIo/Lc1GgkAZvAsFhObHYiIKBYY/Y0UDoAEO2D7+xMAAxAwMJYa//I6IBoQMDAmFhwu +Fh+bHC0WHvi2dhAbEGgwLRYQKBYgG7ckHrci/hYPIA8QMDD7FhUqAhS30CISKCIiOWQkGx+2PYtw +/LY5ECACSHD0cQcgGBAwMPizEQADECgw9QogIgkALPDwUAQABRBQMPW2LhIAAECw9ARKCgkAZvDy +vAAFwAQ5IPW2KhQJACkwbao1lICTgZ+CloOShIqVi5CMk46U+5ICLAkALvD6hgcgMAJKcJyJDgob +CwsbnYWahvuGCCBgAkIwKhIoKQoP+aY5IFQQQDD4dAUgVBBQMCsSKCuyOiISKP8CAAYBucbgIiI5 +HrYOGLbg/xIqI2IANKAtcQcNDUoM3RH8cSIsCQB3cJ0giXD+ttoQWBBYMPsmAyAHECAw+7YEGYAE +PmD7JgIoCQAmcJkhhvcmFiSP9v8WJSAAEEgw+RYmIC4QeDD/dFcgCBBYMPt0ZC+JEDAw9nRlIAUQ +aDAtdFwudSopdTUpdGcpdGYpcEH9cGggQhBwMC50dPmbCQBQEDAw/LsRAAICa3D9dGgoACBaMPiC +fyAmBDKwxO5+oQnF9v8CAA4CI3qQHra2E7a0+wpIL0AEPyDwnREEwAFEMPiKQgYHAUAw+yULIAAQ +SDD5JQonUAQ5oPzYFAuABDqg/LapGUAEOiD6VQIGCQBBsPP/AgQJADVw/yYGLAkAL3D8JgcsCQB3 +cP0mBCCQAlHw8goWAEACQLAASGP4cSogABAoMPUkMSAAEBgw8yQyIAAQeDD/JDMgABBwMP4kNCAA +EGgw/SQ1IAAQYDD8JDYgABBYMPskNyAAEFAwKiQuKSQv+CQtIAAQMDAmJDAIiBQoJCwmcFcmJDvT +DwaGFCYkOgaGFPYkOSB4AlCw9oYUALgCWfD2JDggBBBgMFlBYyh8YPMIFgCAAkiwAEmKAAiIAAmK +KHIcKCRTCIgUKCRS+IgUAKgCULD4JFEgDBBgMPiIFAD+Alhw+CRQICICWvBZQVIrcHQrJGQqEikb +tYkMqhGrqiSmOStwFikK/3mxCvpwQSBIEGAwWDFexMX8dAUgABAQMNEPACyhBS2hBP+iACACAmMw +/AxPAf4CI3D8pQUmAIdnUAxEEfT8CA/ABDsgDswMBAyLwNAN3WTwDIQPkAC7YC+hBSwyoiV1E/oy +oS+QBD/g9XUULAAgf3D9dRIvoAQ7YP3MCAoAIHKw/HYWIs8ANqAetWIMKRGumSkWKCmSOv8CAAYB +PUJgJBIoJEI5ZEJuHrVeCloUFrXW9kYAIAIQSDCZQppD+hIqIEAQeDD8cgAtoAQ/IJ9F/UYHIAYQ +SDD+zgINgAQ7IP5GBiwJAEswnEEetVKeRIqrmkj2cg8gABBwMP5GCyAAEHgwn0qWSYyDnE2KgppM +hoMsbRD6ggIqAAMzELGqH7WpDwIADwIA+kYOLgBAfzCfTy4SKC0WACnmOSt0BfP7H2IAAFEwwJAp +pQXz/u1gABBgMIqDCgpLmn9j+rcAi3JluuArEinacPu8GCIAAGHwWDF6wCDRDysSKtpw/AqEIgAA +aXD8tQgiAABhMFj8nsAg0Q/A0J2r8/nXYgAAGnAAAAAAAAAA+8oMADYANOAKTBT+zAgiAABA8P5O +NgIAAErw0w9t6QUGCIYASWcKOAj8TgwAgAJIsG3pBQgIhgBJaQr4DKgoKIxAmNBj+YIAKxIq2nD5 +CoUiAABhMPm1CCIAAGlwWPyAwCDRDyosQJrQY/ldiHcrcAcsiRT0yiZoIAFcMIiJZIocHLT7DJoR +rKouojr/AgAEAJRDoCyiOWTBHRO1Ri5xBx+1RoKB+ytAD0ABcDD6uxAPwAQ7oPICRw4JAFuw8oYB +LgkAe7D+xgAgMBAQMP608BsABD5g/3IAIEACSzDzxgYqCQBfcPLGAyoJAB7w+8YEIAAQEDDyxgUg +BBBYMPLGBy+ABD/g/sYCLgkAX/D/xgEgAhBwMG3qBQoIhgBJa4h3wJDy+sAgQAJCMPumOSIAQBIw ++YUEIIACELCSgPKGASBSEHgw/3QFIAAQEDDRD8WiKnQFY/u1i3JluUIrcEHacPu8EiIAAGHwWDES +wCDRDwAAwEDAwPwWJyfgAWgw+jJcIgAAWbD8CgAgARBoMFgo/CgyXSoSJ7FmCGYusar/AgAB/vuG +oCoWJ2P/0QAAAAAA8/kHYAAQUDCKcsis8nQFIAAQEDDRDwAAAAArnBj6fAACAABh8Fgw9/J0BSAA +EBAw0Q8AAGwQCtcw+goFIDAQWDD1DUcAARBAMP0WCCH8Amtw/LWEHAUAbjBZR8mOGBO04f8iECAB +ECgw/xYFIgMQG6AqMrEqolkmoQJkZipYJQgctNIswnMrMquqzAnMEf0gByoAIGbwLLAH/gr7LAIB +bDD+3REMAEBzMPYgDCwJAGswLLQH/SAHL5gQeDD2tAwg/BBwMP+0BSwAQHMw8rYKIAAQcDD+tggs +IAFsMP62CSwJAGswLLQHlxT7FgklwwA24IoZiqf9oggvwBAwMP6hFSBAAnqw+aILJgBAM/D2Fgct +wAQ5IPapFC4AIDOw/uxAJgLM7lCsZvalFCoAIGsw+BIEKgLO15DJhclD2dBtSQUACIYASWGK8A8C +AA8CAKyq/wIABgLk9pCa8IqwCK4RDk4CntEsMp4Mqgz9FgogAgJSsP/RCC1gAVAw/7UIJUoANyAK +bBT6CkUMkAQ7IAyqApq+jSIqIAf+tEoUxgC3YAoKQfoWBivABDqgrqovojr/AgAEAk/H4CqiOfy0 +TxSUADagJCITjSn7IgokCAEgMAxECiRCgP27DABgAiEw+hYCKgFHptArIBYmCv92sRL6IAcgABBg +MFgwJvy0PxUsADagLiEHH7Q09xICL0ABcDAM7hEP7gKecI8g+bRcEAUQWDD9tC8bgAQ74P12AioJ +AFqwmnEmIhMoIRr+tFUeCQBP8PaNQAZKATAw+HYGJ2AEOaD82woNoAQ/YPuygCwJADdw/3YELAkA +d3CddwtLDPt2BSAgAlrwm3OKKSkiFvSqCA/gEEAw+iYJKAAgJnD5JhYmAehF0I0aLhIJHLTz/dEI +IAUQUDD+4QggMBBYMFlHNIoaKqwoWM/7+wowIgAAarD8tOsQBRBQMFlHLSQysY4a/LToECAQeDAA +8ASH5i7iB/4WAyAFEFAw9w0bADAQWDBZRyMmMk7A0PcWASGMADWgLkJZKOEEieD8jP8r5wFoMPyv +EQfABD8g+uUFJgAgPnAPfwwAD4v/4QMqwAFsMAW7YP8PRg42ATrgDKYRBnYMAgaLKwoABbti/wIA +DgBTEuB6yQTI8XvxWBa0HCZicwmoEf8yqygAIELwqGYJZhGm/4z3KMkU+/IKIKcANiD5wgkuAG2S +0I4Ri5KMkw67DI4T+goBIAAQODALpzj+zAwAABBAMAyoOP8CAA4AWUXQYACgCawRrLz8WhQHwAQ+ +IP6qEQYAID5w+ncMCIABZDDwkQQB+AI58Ilw8FYaD/8QUDAKagMKmQH64QUmCQBJsJZwieAo4QSx +qgoKT/rlBSAkBEKwsIwMxxHz/y5mACA+cADAoCrlBfP/6WAAEFAwAAAA8rk4cAAQSDD4EgEgABA4 +MIZyh3MIZgyIE/4KASAAEFgwBus4+HcMAAAQYDAH7Dh8sAmIGfj5dnAgEFgwKTJOsd3/AgAL/03P +UGAAGwAAAAD6LAACAABZMFgvp/yznx1mADagYAHaAAActHv/EgMgBRBQMP4SASAwEFgwWUa5wKX8 +tHYQMBBYMFlGtcDQihqMFIsZ+iwADAUAUrBYLwvAINEPwLD7FgAiAAAS8NEPjpMctGuNkp8b8LAE +AAUQUDD9DRsAMBBYMFlGpoQbHLRl/UIAIAUQUDD+QAUgMBBYMFlGoGRPmIkSiBr4jCAgQAJKcAgI +hgBJaQYIhgBJZwQIhgBJZY0SLdAgzNqPEsTi/vQgIEIQaDCOEvy0UxAFEFAw/uAhIDAQWDBZRo2I +FYYSKIISKGQ7CIgUKGQ6CIgUKGQ5CIgUKGQ4LyIXjhkvZD8PjxQvZD4PjxQvZD0PjxQvZDwu4g4c +tEEuZDMOjxQvZDIPjxT/ZDEgBRBQMP+PFAAwEFgw/2QwIAAQaDBZRnWNEolOKdQ3CYkUKdQ2CYkU +KdQ1CYkUKdQ0/EIPIAAQcDD+1CQgABB4MP/UJSAAEDgwJ9Qi99QmIAAQQDAo1CMs1EMo1CcMjBQs +1EIMjBQs1EEMjBQs1EArIAcLC0Ecsy0MuxH8uwgABRBQMCq2OSsgFikK/3mxCvogByAwEGAwWC8B +ihlkroyIqGSOh4upwJCZq5iwjKibwZmo+aYJIAAQEDDRD4sW2iD7vBgiAABgsFgvaYwZjMhlzlmP +GYYvGLQI+PYLIEACa/D9ZgAgcAJwsJ74lvn9Jg8gABAQMNEPiXcqmRSXFPcWCSCoADagjZmdGmP6 +7gAAAAAA8/o7YAAQWDCXFPP992COEGgwwNCdq/P6mGIAAGpwAADz+sRv6hBQMIYU/e4MADgANaAO +RxT4fAgiAABJsPhINgIAAFNwbYkFCgmGAEpriRSKFwdGDP6ZCACAAlKwbWkFDAmGAEpthhcOyAyo +ZiZsQJbwY/o8iRcpnECZ8GP6MgAAixbaIPu8EiIAAGCwWC8zY/8lAAAAAADz/1pgABBoMGwQBCog +BPunB2AXEEAwa6QGeKEbwCDRD/osAAIAAFjw/EwAAgAAaXBYz1TAINEPAPosAAIAAFjw/EwAAgAA +aXBb/irAINEPAGwQBsRy+bOkEAAQMDD2FgAgAxAoMPklKiABEFgw+jAVIC4QQDD4JFcgYAA1IP8C +AAAASIUgaEJA/wIAAgBuBSAKaxR7UAUsMBQsJGAqLGX9s6wSAABYcP0WACADEGAwWT57JiRoJiRp +JiU1JiYcJyR0HrLlLiU30Q/AhvgkXCAIEHgwLyRkY/+2KTAwwaJ6kWb7JGQgugJQsPwKAyAiEFgw ++yRcIDoCWPBZPmgqLGH8CgMgMgJY8Fk+ZSowFWP/fwAAKixd/AogIDoCWPD8JGQgAhBoMP0kXCIA +AGFwWT5bLjAYf+fTKixh/AoDIDICWPBZPlZj/8IAH7LtKDEcL/J/CYgRqP8o8TYoNRyP8C8mHmP/ +fAAAAAD4s2YSAABhcPskZCAjEEgw+SRcIMoCULD4FgAiAABYcFk+RCYkaCYkaSYlNSYmHCckdNEP +bBAG9rLLEAAQODD7IhAq4AEoMPsWAiIBwpqgKmKJDwIAKqJZLKECZMN5WCLmHLKvLMJzK2KDqswJ +zBH9IAcqACBm8CywB/4K+ywCAWww/t0RDABAczD4IAwsCQBrMCy0By0gB/i0DC+YEHgw/7QFIPwQ +cDDytgosAEBzMPe2CCwgAWww97YJLAkAazAstAf1vAADGQA24Ii3+4IILcAEOSD/gRUvwBBQMPmC +CyBAAjIw/YkUKgBAUbD6FgEuACBX8P/8QCYBfF5Q+8oIDAAgZ3D9hRQqAX/X0Mk3yUX5vAACAABA +8G1JBQAIhgBJYSpiAAyqCP8CAAYBk36QmmCIUPmyjBuABDogCkoCmrEpknYtsQgJiAz9VQggAgJC +MPhpFA1gAUAw9MKiaJAEPmAICEUJiAKYXooiKSAH+LIqEi8AtqAJCUH5FgApwAQ+YKiZK5I6/wIA +BAEERuAkkjn8si8R/QA1ICYiE4sp+iIKJggBMDAMZgomYoD7qgwAYAIxsP8CAAoAx7aQKyAWKQr/ +ebEV+iAHIAAQYDBYLgYYshH8sh8ShAA2oC4hBx+yEw4OSgzuEQ/uAp5AiyAZsj0dshH4uhEABRB4 +MP1GAioJAHqwmkEtIhMuIRr6sjYaCQBO8P2JQAxKAWww/kYGLWAEP2D8ngoJoAQ+YP7igCgJAG5w ++0YEKAkAVnCZRw5uDP5GBSAgAnOwnkONKSsiFsag9t0IAGACSPD9JgkqACA28PsmFiYAndUQ9AkW +AEACUTAASmUCCYYASmMACYYASmEqQCCJEvmSEiDWADagKUQ7CYoUKkQ6CooUKkQ5CooUKkQ4J0Qn +B4kUCYsUK0QlKUQmC4sUK0QkKiIXKkQ/CooUKkQ+CooUKkQ9CooUKkQ8jl4pRCIuRDMnRCMOjhQu +RDIOjhQuRDEOjhQuRDAtIAcNDUEM3RGo3S/WOSsgFiwK/3yxCvogByAwEGAwWC2fylCIWMmMjVmX +W5jQjlid4ZdY91YJL5kQYDD8VAUgABAQMNEPL/qZ/1QFIAAQEDDRDwAAAAAAAAD6LAACAABZsFgt +xxixsfyxvh5jADagYABAKUQ7ixL5jRQPgRBgMCxEIf1EOiABEHAwLkQgDY0ULUQ5DY0U/UQ4IAIC +UnAqthJj/xCLENog+7wYIgAAYLBYLe+MWMjCwCDRD48vGLKQ+FYLIEACaXD99gAgcAJwsJ5Yn1n9 +Jg8gABAQMNEPAAAA8/2WYgAAKPDz/OdiAABZ8Nog/QqOIgAAYPBYLRXAINEPl4vz/TtiAABacAAA +AAAA8/1kb+oQQDD7+gwANwA04ApOFP3sCCIAAEDw/U02AgAASvDTD23ZBQYIhgBJZ4kRqjj+TwwA +gAJKcG35BQgIhgBJaY0RCs4Mrt0t3ECdYGP8348RL/xAn2Bj/NWLENog+7wSIgAAYLBYLbxj/zMA +AGwQBiggBNMP+4cMYBcQSDD/AgAEAboKIP8CAA4BgkoQ9rG1EAAQODD7IhAq4AEoMPsWAiIB0hqg +KmKJ0w8qolksoQJkw5lYIdAcsZkswnMrYoOqzAnMEf0gByoAIGbwLLAH/gr7LAIBbDD+3REMAEBz +MPggDCwJAGswLLQHLSAH+LQML5gQeDD/tAUg/BBwMPK2CiwAQHMw97YILCABbDD3tgksCQBrMCy0 +B/W8AAM5ADbgiLf9gggvwBBQMPaBFSvABD0g+YILIEACYjD+iRQqAEBTMPoWASYAIFGw9mxAJgGM +blD9uggOACBbsP6FFCoBj9WQyTfJRfncAAIAAEDwbUkFAAiGAElhKsIAC6oI/wIABgGjNpCawIhQ ++bF2G4AEOiAKSgKa0SmSdizRCAmIDPxVCCACAkIw+GkUC2ABRDD0ssJokAQ+YAgIRQmIApheiiIp +IAf4sRQSVQC2oAkJQfkWACnABD5gqJkrkjr/AgAEARdG4CSSOfyxGRIjADUgJiITiyn6IgomCAEw +MAxmCiZigPuqDABgAjGw/wIACgDLtpArIBYpCv95sRX6IAcgABBgMFgs8Biw+/yxCRKkADagLyEH +GbD9Dw9KDP8RCf8Cn0CLIP6w/BAFEGgw+bElG4AEOuD+RgIqCQBqsJpBLiITLyEa+rEgGgkATvD+ +iUAOSgFwMP9GBi9gBDug/J8KCaAEPmD/8oAoCQB2cPtGBCgJAFZwmUcPbwz/RgUgIAJ78J9Djikr +Ihb27ggP4BBQMP4mCSoAIDbw+yYWJgCw1RApPDD0CRYAQAJRMABKZQIJhgBKYwAJhgBKYSpAIIkS ++ZISINsANqApRDsJihQqRDoKihQqRDkKihQqRDgnRCcHiRQJixQrRCUpRCYLixQrRCQqIhcqRD8K +ihQqRD4KihQqRD0KihQqRDyPXidEIy9EMylEIg+PFC9EMg+PFC9EMQ+PFC9EMC4gBw4OQQzuEaju +LeY5KyAWLAr/fLEK+iAHIDAQYDBYLIjKVYhYyoGNWZdbmNCOWJ3hl1j3VgkvmRBgMPxUBSAAEBAw +0Q8AwCDRDy/6mf9UBSAAEBAw0Q8AAAAAAAAA+iwAAgAAWbBYLK8YsJn8sKYeWwA2oGAAXilEO4sS ++Y4UD4EQYDAsRCH+RDogARB4MC9EIA6OFC5EOQ6OFP5EOCACAlJwKrYSY/8LAAAAAAD6LAACAABY +8PxMAAIAAGlwWM+MwCDRDwAAixDaIPu8GCIAAGCwWCzPjFhlz2qPLxixcfhWCyBAAmlw/fYAIHAC +cLCeWJ9Z/SYPIAAQEDDRD/P9dmIAACjw8/zHYgAAWfDaIP0KjiIAAGDwWCv3wCDRD5eL8/0bYgAA +anAAAAAAAPP9RG/qEEAw/WoMADcANOAKTxT+/AgiAABA8P5ONgIAAEtw0w9t6QUGCIYASWeJEao4 +/04MAIACSnBt6QUICIYASWmOEQq/DK/uLuxAnsBj/L+IESiMQJjAY/y1ixDaIPu8EiIAAGCwWCye +Y/85AABsEAYZsTDykl0iAABwsP1MAAIAAGDw/woAKgCMkNAlklyVECtRBPVSACH+AiMw8yMMAAEQ +QDD8uxECAAATMPAADmoAIC7wsf//AgAGAHOf0A9WFA5mEQa2DCZt//ZiPyqAAXgwAKEEAIka8KAE +BgBASbD2BhkAAgIQsPkKAC/IALWg+ME8YAICM/BtSS4GVxQOdxEHtwwnff/3cj8kgAE0MABRBACK +GvBQBAYAQFXwBwcZ9XAGYAICMbCxmQnKDGmhg2TAR4cQKnEEKfr//KoRAgAAG/BtyTTycgAkgAEc +MPNUFAACAhjw8FEEBeAEPSDwghoEACBQsPVFDAQRAEiwJVz8hlAEZAEEIgKSUBKw7SUioizlEyIi +of/lEiQAIC/w9dYAI6AEP+D15hYiACAYsNEPFbDkJVKiLOUT/+USJAAgL/CV0PXmFiAAEBAw0Q9s +EA6UEZIfhB+CMPhBEy/wEFAw90EVIuABEDD3FgUiACAQ8PcyBiB+AhCw9EAHIgBAULCKI/k8AAAE +EFgw9ARBDCABODD8uwwLYAFQMPoWDiogAVww+xYCI8sAtiCIIfeMAAOVADagqoj4jfAgARAwMGqB +E/gLSwABEGgw+MwSCgUAX3Csu6tmiCAICEewiPqBWWIAABmw2yBtCEuNtLCIDwIA/QpLAAEQcDD9 +zBIKBQBTsPfXCAoAIGKw9IAhZgAgUbCKtQoPS/rMEg4FAH+w+Iz/LgAgZ/D3pwgGACB5sPu8GCAA +BCYgY/+tAI4fI+UQJuURLZATZNMFl1H6Eg8gBgJZsPsrFAAAEGAwnFD7FgkiAABgcFv/Zo4fmheN +Gf3lFCKgADag/rAaEgAASPD1+v8i3QA04Bqwjiqimv8KACIAAEKwbTkiiyODIqv7/r0BCgADetCx +My/9EP2GASwAQCjw/IYAIBACQjD0FhAqAGCyUMBBiCT4C0sAARBgMPjIEgoFAF8w+4gIAAAQeDD0 +gD1sAIAmMAqYC23aMosnDwIADwIA+ZwBKgAgX/DzIgYsAEB28P2GASoAA/rQIzwB//0QLABAKPD8 +hgAgEAJCMPaRWXABEGAwKCIFCAtL+MgSCgUAXzD7iAgAABB4MPSAM2wAgCYwCpgLbdooiymDKPmc +ASoAIF/w/r0BCgADetCxMy/9EP2GASwAQCjw/IYAIBACQjDyLBgr/6Y2UCQSEIoViReOGf6oEQug +BDqg+GYMCAAgVnD5FgciEAA3oByvZAxLEfwSCSoAIGbw+xYEIAoQaDD7sjosAwBrMJwYDMwJD8wR +/BYDKgEBZtCNFC3SOf0WBiH5ADdgih+IGI8ZKaEVHq96CP8M/xYJKAAgRnAppRWJE4gWAA6LbZkC +AEhhihhkoVIYr8cZr00esC2CEgqvCYQWihf3IggPsAQ/4PIWDC4AIH0wnx2CEI8V/uKaIAAQWDD6 +XRQAABAoMPv/EQOgBDig8hYLLgAge7D+FgoiAAA5MPKvPhBAECAwgxuPHJ1zmHD8Eg8gAhBwMJ5y +jh6MwJJ0lHWfeJN3/nYJIAAQaDCde/0KACIAAHLw/XYKIAgCWvD/EgoiAAAZ8PjNEQwJAEsw/HYG +IAYQYDD83QIOACAv8P12ASAFEGAwbcoj9usMcAAQIDCE8Y3wYAACAMDQlD39NgwgAgJzsP/8CCAQ +Ahjwjx30CkAgQAIpcPd8YCCAAlKw+l0UD/+x+dCNGMDgDt01jxmJFIgT+JY5IAkAN+DAINEPAIoQ +ixH92AkLoAQ6oJqwix+CFvuIEQAAEEgw+bUVIFEQUDD6tAUiACBAsNEPAAAAAPP8dWAAEDAwl5Zj +/PQAAADz/6lgABBoMPkKAC4cADWgGq/WJBYQKqKaY/1Ol1GNFYYf+6/REAAQcDCeUCxiFiuyZJwQ +LGESI2EQDY0M/RYJLaAEOyD2YREqACBm8JsXY/zMgh+JEPoSASAAEEAw+CUVIFEQeDD/JAUpoAQ+ +YJmg0Q/AINEP0tDRDwAAAAAAAGwQEB6vKCfiiSIWEygiEyZyWyJyXSlyZipyXJoe+RYQIEYAZjAt +Co4pEhH6EhMiBQBOcPsSEiIAAGDwWCpRwCDRDwAABQpH/wIAAgS5GqAqclktoQL/AgAABL+rYFgf +NhuvAB6vECuycykSEyXig6q6CaoR+JAHJAAgVXAvUAf4KEAA+xBQMP6IEQ4AQFfw/JAMLgkAR/Av +VAf4kAcvmBBYMPxUDCD8EFAw+1QFLgBAV/D5VgogABBIMPlWCCggAUAw+VYJLgkAR/AvVAf1FhIv +VAA1YIpX2zD6rCAiAABhMFgmkIxQ+hYRLYAEOyD7oQgsCQBhMJyhK1UILRITjdL/AgACBDIrYC4S +EiQSEY7sJEIA+woCL/8QYDD0BEcCAPH/kC4SEQTvCC/yDykSEgwoAwj/AS+WFC7iEf8SDi4AIHuw +Dm4I8PAEAf4Cc7AODhkODk/+lSsgBgJDsPgoEg6UEHgw+JUqJgQl/dAoEhIp+rT/AgAGBB7OEP8C +AAAEGqugKuz/+u0BDgAO15BtCA//3P8iAABzcP/dAQ4AA/+QY//pD+4Rs+3+rzYQEBBIMPWvYBAB +EHgw/S0UAAAQQDD+3gECAABSMPXVAQ4FAHPw9fU5CgUAcnD+CggiAABKMPWvVhgFAC+wHq9T+q9U +GAkAVnD+3gEEAEAvcPX1OQ4FAHPw+owADABAV3D9/TkKBQBy8PoKBCQJAFVw/3JqKAUAarAJiAII +VQL/AgAKA8Mv0CpyawVfDwr6CoqgLqECDv8R/xYAJ+oAN6BYHruIEC9ya6j/ifb48gEpoAQ+YAmp +KPkSEigAIEow+JYTL/8QYDD48gYgAhBYMPmubhIAAGqw//IELwAEO2D9iCgLgAQ5YP0KAC4JAFOw ++P8IDgkAS7AoEhIO2gL6DUcAFhBIMPqGEiYDos9QZddHGq56KRISKqJ2iZAKmQyxmQkKS2SnV/lu +FA3gAXww+QpFDpAEO6D+qgIJoAQ/YAqZAigSEo+M+/8CAAEQUDD5hg4uCQBX8J+MLxISL/EqZPRE +KhIRGa8M8hISKhEAZLD5FgwgABBwMJ4VmxQergzyIhMqACAisPIWCyCAAmqw/RYGIHACWrCbEvAB +sWAAEBAwha2LHv4SDygAIDVw8LAEAf4CSnAJCRn57jYAABBoMPcWAyPTADegwLCHH4wSEq5z+3cM +AAAQaDD5zAAGAwBN8PEJFggAIFtwAogLKI0bAAiKha2Dr/nMAAACAmtw/qIOLgMALbD/VQwCACAf +8PWmDSAQADVg86YPKgADeNCx7p6ud9m7iB+r2/8CAA4BHVoQZFIyixOMryy2f4muKbZ+jhcpEhOL +GIgZjBsdrladgAxcFJyDC10UnYKJkPyt3BAAEBAw/RIKIAAQeDD8hgQpgAQ+YPuGBS4JAEuw/oYB +II8AN2CHGB6uRYMZ/a3MEAAQEDD+/wsABBAoMPc3CAIAACDw8zwwIGACOfAoEhOIgA2IAphGKBIS +LBIQi44pEhH//RsqAEBm8JtHKZIRmUj4ghQiAABg8PhGCSCAAhjw8kYLIAAQSDDyRgoggAIhMPMP +FgACAkpw8lweBegCPmD1XAQiAAB5cP7/CwFACDjwKxITK7AHCwtBKRISiBovkSoeraP4/wwLwAQ+ +4PgSByoAIHbw+LY5L+ABfDD/lSoiaAA34I0ajBsK3RGtzJwbJRITJVAHBQVB/FQRAAQQODD+RAgM +AwA/8PhCOiOgBD9gLzwnD08U/wIACgIYfhApQjn8roYUJQA2YCgSEiuBK50a+RYJJ+AEP2D0ogwm +AwBd8Jcf/HcLAAAQWDArdn4idn+IjJMYnxf0BEcB/vP6EI6ujRWPr/4SBCwAQHdw/woBLgBAe7D+ +/jkMBQBv8A7dAvcWAyGSADdgjhKNHBit3QQOiACNii/Cfy4SEinCfvnGfi4AQEfwL8Z/LuIUj60O +bgwP7jYO/wz/pg0gFgA34I+vr+/9og4qAANz0LHdn6+dri0SEovcx+0OuwGb3IWtix6IH6ZZ8LAE +Af4CSnD5CRkB/gJCMAmINv0KACFEADYg8/1nYAEQWDD5EgYh/gJ5MJ8d+RYWIAAQQDD4FhUgIgC3 +4GP9uygSFPzMASAwAnuw/BYVLgUAQ/D+FhYn/tLvECcSFY8eKBIW/RIPJgABPDAnFhQIdwqFcAvd +DCMSFPgSFi4AIDFw8PAEAf4Cc7AODhn4MwsMAwB3cP0WASBYADdgjBGOHCI8CP69CwwAIFsw/swL +AgAASLD3CRYCAABDcADIioVw9W82ABACa3D/VQwCAABIsPV2ACAXADVghDOOMqT09DYDKgAD+RAu +7AGeMnzZxI0R+BIPIAAQSDD8EhUoBQBvcP4SFioAIE7w/RINL/+aWhBkXywsEhYrEhQMuwuME42z +LcZ/i7Irxn5j/NAAAAAAAACFrYse/hIPKAAgNXDwsAQB/gJKcAkJGQnuNv0KACw1ALeg8/yKYAAQ +WDDz/IJgARBYMCYSE4piJmAH9aIMZiABMDAarP4MaRGqmSiSOvcK/yQBGcYgI5I5ZDIoKxITJLIT +Eq0EjLn7sgokCAEgMAJECiRCgPy7DABgAiEw/wIACgDRJtArEhMrsBZ3sRAqEhP6oAcgABBgMFgo +3GSiJS0SEynRBxqs6gkJSgyZEQqZApkwitD+rRQQBRAwMPis5x+ABD6g+DYCLgkAN/CfMSvSEyzR +GvmtDRoJAHKw+4hACkoBXDD6NgQrYAQ+4PKPCgmgBDog//KAKAkAWjD8NgYoCQBKMJg3D08M/zYF +ICACe/CfM47ZLNIW9O4ID+AQWDD+1gksACAjMPzWFiYAj1zQKRIR/jwgIAEQaDD5nDAgAxBQMG2q +BQAJhgBOYSsSEy00IC6yFy8SEi40Pw6OFC40Pg6OFC40PQ6OFC40PIz+KrIQLDQzDIwULDQyDIwU +LDQxDIwULDQwLqIS/oQUAAICS7ApphL+NDsgABBAMCg0I/Q0OiAAEEAwKDQiBIQUJDQ5BIgUKDQ4 +LLAH/vYPLCABYDAerJ4MzBEOzAgmxjkrsBZ3sQ0qEhP6oAcgMBBgMFgocysSEsqyibjJno25wMCc +u5nQjrid4Zy4/LYJL5kQUDD6tAUgABAQMNEPIhISL/qZ/yQFIAAQEDDRDwAAAAAAAAD6EhMiAABZ +MFgomWSuU2AAFgAsEhP6zAAAMAJZcFgozykSEogbKJYTKhISiqj/AgAD+2aqoCwSEy4SEo/PEq1y +8uYLIEACW7D79gAgcAJrMJ3on+n7xg8gABAQMNEPAAAAACwSE/rMAAAwAlmwWCi7Y/+0wODz+Ohg +FhBoMIk3KJkU8xYSIHoANiCKmSoWEWP3KAAAAAAAAPP28WAAECgwAAAsEhP6zAAAJAJZsFgoq2P/ +dAAAAAAA8/YsYI0QaDAAACwSEyvABy4SEsDQ+wtBAgAAUzD95hIgMAJa8Fgon2P/RAAAAAAA8/i/ +b+oQSDDA4PP4a2ACEGgwAAAAAAAA8/+IYAAQUDBsEDgvIAQjFmIPAgD1FmAlWgA34PUKGCYCoo/g +/wIABAKeo+AmEmIsIAeLYCIWY/YWYSwgAWAw/BZbKuABXDD7Fl0g1gJa8AtLFPsWXiQCkYPgLxJj +L/AFJwpO/wIABgKFv9AmClF28SsoClR48SUqEmMrEmH8HAQgEAJocFv8LP8CAAAHt6qgKBJhLxJj +hhGWhy/wBSoSYYSm9AdBAAQQMDAHZgwGBkH2RAgAVBBIMPSmBiYA58/Q9IsUAAAQMDCWGJYclh4m +FhImFhQmFhgmFhomFjAmFjImFjb2FjgsABBAMCgWJSgWJ/gWLSP/EDgwJxYs9xY5ID8QSDApFiT5 +FiYv/xBQMCoWG/oWISAAEHgwnxcvFiv7Fh4gEBBoMP0WKCyABDkg/BYfIAEQcDD+FgQgAxBgMJwa +/BY0IAAQcDCeFv4WKiAAEGgw/RYuIAIQWDCbGS8SYRqsLvmsnhAGEFgwKxYxHawgF6zR9xYVIBoQ +cDAuFhz9FiAgERBgMCwWIisSY5kfGKzJmh34FhMgDxBQMCoWMykSWxqr3S/yB/8WGSnABD5g+7EI +KAAgVnApFl8pkjr7FjcgGxBQMPoWECAeEDAw9hYWKgJcVlAkEl8kQjlkRKoWq/UESALwBgcAGxBI +MG2aAgBIYRKr0ScSYxirzBarzfNyACAJEFAw93EHICAQSDDwkAQAAxBgMPkcECuABDzg9jMCB0AB +PDD2q8MXwAQ94Py7AgYJAEXw+EwAAgAAIvBtqjWXgJSBkoKVg5OEipWLkIyTjpT7kgIsCQA28PqG +ByAwAkpwnIkOChsLCxudhZqG+4YIIGACQjArEl8pEmPBq/q2OSBUEEAwKJQFKxJj0w8rsBYsCv98 +sRYsEmAqEmMAzI4qoEFYJ5D/AgAABoiqoC0SWx6rmdMPDN0R/hJeLAAgd3AtFl8t0jr/AgAKAdB3 +UCQSXyRCOWRDkhartvAGBwIAAEEwbekCAEhhKBJiKhJj+axjEAAQcDAuFkD5pSogLhBYMPukVyAG +EGAw/KRcIAgQaDAtpGQogBX4aBQAAxA4MP8CAAgGXUHQKx0BKhJjHKxuLBZA+qxlIAMQYDBZNz0u +EmPAkCnkaCnkaSnlNSnmHPjhByBCEEgwKeR0Gatz9xJdKUABQDD6q6IZwAQ6IPrlNygJAEowmECG +4P8SXiCYAjnwl0P3q2wXgAQ5oPdGAi4JADfwn0Et4EEYrDcv4AUN2Qn8mREAUBAwMP7hIigAIEow ++IJ/ICYEM/DErnrxCcW2/wIADgYU29AXrDAjEl0ZrC0O3BT1rC4XAAQ7YPgKRg5IAUQw9UYHKgcB +RDD0zBEJQAQ7oP4KAC+ABD/g/kUKK1AEPuD5iAIAeAIY8Py7AgoJAHqw+xJjKgkAWrDzRQsmCQBR +sPhGBiYJADmw9kYEIJACevDwDxYAQAJpMABNYS2xKv5ELyAAEHgw/0QuIAAQEDDyRDcgABAoMPVE +NiAAEDAw9kQ1IAAQODD3RDQgABBAMPhEMyAAEEgw+UQyIAAQUDAqRDH9RC0gABBgMCxEMA2NFC1E +LCywVyxEOwyMFCxEOgyMFPxEOSB4AlEw/IwUALgCWvD8RDggBBBgMFk23CgSY/1MQCDAAkIwAgiI +AE2KAAiIAA2KLBJjLMIcKxJhLERTDIwULERSDIwULERRDIwU/ERQIKgCUTD8El0gYAJa8Fk2yysS +Yy8SXf6wdC4AIH0wLvRYLRJfLBJeLNY5K7AWLQr/fbENKhJj+qBBIgAAYPBYJtUqEmMoEmHElSmk +BSiAEsqHHKsnG6vwHavwKhJjC4soW8YAKhJjW8XjwCDRD39SCcHH/wIACABi59DAINEPAAAALRJi +2iD+EmAiAABYcP3RCCIAAGNwWA/wLQqI/wIABgVXbpCMEGTP0IrHi6j/oRUvwBAwMPmiCyBAAmqw +BtYB9hZBLgAgN/D//EAmBdNeUCepFAxOEa5396UUKgAgW7D/AgAKBc5X0CgSYsmByE/ZsG1JBQAI +hgBJYSrSAA6qCP8CAAYF5/6QmtCPwAj/EQ9PAp+xLyAFw977FmEmBZ3v0MRi/wIABgWYt9DDff8C +AA4F17vQLBZjY/omGKsMJYKJKSITI1JbJ1JdKlJmK1JcKxZV+hZXILQAZnAtCo4uEkIsEmLaIPsS +WCwFAHOwWCY2wCDRDy8SY4/yZf78KxJbLBJj+7wYIgAAUzBYJvbAINEPLBJjjMJlzt8rElssEmP7 +vBgiAABTMFgm7sAg0Q8AACwSYAwMR/8CAAIFCpsgKlJZLaEC/wIAAAUPq2BYGwwbqtYYquYrsnMp +goOqugmqEf8gBygAIFZwLpAH9gr7LgIBfDD+/xEOAEAzsPsgDC4JAHuwLpQH/yAHL5gQUDD7lAwg +/BAwMPqUBS4AQDOw8pYKIAAQMDD2lgguIAF8MPaWCS4JAHuwLpQHKRZF+RZYLxoANmCKlysSYvqs +ICIAAGEwWCJmLBJFjcAI3RH7oQgsCQBtMJ2hK8UIjiL/AgACBISroC8SWISgj/zAwvcWQy//EHAw +9ARHAgDz/9Ckr4//KBJYDnYDBv8BL4YULaIR/xJVLAAgf3CtPfDwBAH+AmtwDQ0ZDQ1P/YUrIAYC +O3D3JxIOlBAwMPeFKiYEejVQJhJYJ/q0/wIABgRzPZD/AgAABG8rYLDY+NkBDgALx1D7nP8iAABq +cPuZAQn/+ltQD90RGKs9Fqs/Gas996sPEAYCe3D/LxQAARBYMP2rOBgAQE/w9/cBBgBAM/D4+AEG +BQAy8Pi4OQYFAD7w+bk5DgBAb/D7CgAuBQB+8N2w/7wADAUAfzD9ChAoCQBucAffOfcKCCIAAGrw +CH05/woELAkAf3D3UmoqBQA38A27AguZAv8CAAoEHU3QLVJrCZcPDX0KjdAm0QIpFkQqFkL/AgAH +4AQ94P8CAAAESymg2tBYGpMvUmun/4b2/fIBJ6AEOaAGpij2ElgsACA3cCsSRC1mE/byBi//EHAw ++KpIEAIQYDD/8gQrgAQ+4PpmKA0ABD6g+90CAAAQSDD2/wgMCQBHcCgSWPoSQiYJAG5w9wlHABYQ +MDD3hhImA/S2UPcSQyfuALZgGapRKBJYKZJ2iIAJiAyxiAgJS2SX+/htFAvgAXww+AlFDJAEP2D9 +mQIJoAQ64AmIAiYSWC9iDPz/AgABEEgw+GYOLgkAT/AvZgwpElgpkSpklHYoElj8quMQABAwMCYW +TPwWUyoRAHXw+xZLKgAgJrD7FkcggAJq8C0WTSiCE/gWUiBwAlrwKxZIYAG8LRJVhL0A0AT9ElYs +ACAZMPUWSiH+AmMw/AwZAAAQSDD+FkksAwBncPoWQiQBADdgwKAoEkclElYrEkgfqkf6VQwAABBI +MPy8AAQDAGVw9QwWBgAgUnAPZgsmbRsAhoqEjY6P9D02AAICSnD9RAwOACBzcPSGDSAPADUgjI59 +6wGxzJ6PnI71mcRyAABi8CYSVqqa/wIADgEs0ZBkQlEoEkcpEkorgg8rln8ogg4oln4qEkItElEo +Ek8vElArElIcqiic8AtbFJvzCFwUnPKGIC4STvmprhAAEGAw+fYEJ4AEOaD49gUuCQAzsP72ASCO +ADdgKxJPGaoYLhJQGKmf+c0LAAQQIDD76wgCAAB7sP7sMCBgAlrwhSAIVQKV9iUSWCwSV4Ze/d0b +LABAYbCc9yaiEZb49VIUIAAQYDD89gsgABAwMPb2CiAAEGAw9fYJIgAAK7D3DRYAAgJjMPLVHgXo +Aj8g//xAIIACc7D0TAQiAABhMPnNCwE8CFuwLCAHDAxBJhJYKxJRKWEqHal4+5kMDcAEOyD7Ek4s +ACBrMPvGOSngAUww+WUqIpIANmAuElEtElIK7hGu3S0WUi4gBx+paw4OQfztEQAEEEAw/90ICAMA +QnD/0jotoAQ6ICnMJwlJFP8CAAoCY8/QLdI5+xJHJLwAN2AvElgm8SsoFlH9FlAl4AQ+IPaqVBQD +ADVwjrwlFlb2VQsAABAwMPZWfyAAEDAwJlZ+j/wsFk8pFk7+DkcB/uZ70Im+KBJMjL/5EksoAEBK +MPwKASgAQGZw+ck5CAUAQzD1FkooCQBKMP4WSSGlADYgHqmtKRJIKBJTHao6CAmIAQiKLNJ/KRJY +L9J+/9Z+LABAczAs1n8pkhSMvQk5DAyZNgnMDPy2DSAWADcgjL+snPiyDioAA0sQsYicv5i+LhJY +jezH/Q/dAZ3sLRJVhL0A0AQtElajTLDM/AwZAf4Ca3D83TYAABBIMPoWQiFRADdg8/1GYAEQUDAm +EkkpEk35FlwgABBAMPgWWiH+AjGw9hZUICMAtaBj/Z4AKBJU93wBIDACWnD3FlooBQBm8PkWXCf+ +w8XQJBJaKxJVJhJc+BJWJAABIDAkFlkGRAqPQC4SXAqIDPCwBAgAIB/w/RJZIf4CSnD5CRkAABA4 +MPYSUygDAEow+BZGIGAANiAlEkYO3QsGqAv73AgkACBVcPZVCwIAAErw+wkWAgAAMjABRoqPQA8C +AA88Nvz/DAAQAkIw/0YAIBkAN+CO0ynSAg7OCP7WAyoAA+OQKZwBmdL1icRyAABK8CgSRiYSVvkS +XCYFAEYw/BJZKgAgOrD3Elov/5XRkGT/IykSXCgSWQmICykSSouDK5Z/iIIoln5j/KgALRJVhL0A +0AT9ElYsACAZMLDMDAwZ/N02AAAQSDD6FkIsBwC3YPP8XWAAEFAw8/xVYAEQUDCNIiUgByoWQg8C +APXSemQgASwwGajHDFgRCYgIJoI6/wIABAFMxaAjgjlkMo4kIhMdqM4rIgn6IgokCAEgMA1ECiRC +gPuqDABgAiEw/wIACgD8JpArIBYmCv92sRL6IAcgABBgMFgkpv2owBKWADagKyEHHKi0CwtKDLsR +DLsCmzCPIPio3hAFEHAw+qixGYAEP+D6NgIoCQB2cJkxJiITJyEa/KjXHgkAR/D2i0AGSgEwMP82 +BCdgBDmg/boKC6AEPuD6ooAqCQA28Pc2BioJAGbwmzcKSgz6NgUgIAJSsJoziSkoIhb0mQgP4BA4 +MPkmCSgAICIw+CYWJgDHPNAoEkIpPCD4jDAgAxBgMG3KBQIIhgBJY8DRLTQgLCIXLDQ/DIwULDQ+ +DIwULDQ9DIwULDQ8LBJYi84qIhArNDMLixQrNDILixQrNDELixQrNDArohILhhT2jxQAAgJK8Cmm +EvY0OiAAEDgwJzQj+zQ7IAAQQDAoNCIPjRQtNDgvNDkqIAf7xg8qIAFQMBuoaQyqEauqLqY5KyAW +KQr/ebEK+iAHIDAQYDBYJD8uElhk4ISI6GSAf4zpwLCb65jAjeic0Zvo++YJL5kQSDD55AUgABAQ +MNEPLhJjjuL/AgAD+tYroCwSYyvAQfu8EiIAAFMwWCSgwCDRDwAsEmItEmMswBQs1GBj8zoAJhJj +xfIvZAVj888oEmOIgv8CAAP6tyogKxJbLBJj+7wYIgAAUzBYJJHAINEPLRJYLPqZ/NQFIAAQEDDR +DwAAAPosAAIAAFkwWCRN/ahFHf0ANqBgACraIPsSYiIAAGEwWPCrwCDRDwAAACvsGPosAAIAAGCw +WCR9LxJYLhJSLvYTJhJYhmj/AgAD+nwpoCoSWIsvHKkh/KYLIEACQrD4tgAgcAJIsJmom6n4Jg8g +ABAQMNEPK1wY+iwAAgAAYLBYJGtj/7sAAAD6FkIgABBoMPP4N2AWEEgwLhJiiectmRT+FlggdAA3 +YIqZY/aEAAAA8/ZOYAAQSDAAACtcEvosAAIAAGCwWCRZY/91KhZC8/VUYI0QaDAAAC0SWCsgB/os +AAAAEGAw/NYSKiABXDD8LAAAMAJa8FgkTWP/RAAAAADz+Btv6hBAMMDQ8/e9YAIQSDAAAAAAAADz +9hZgABBQMC0SYPrMAACEEHAw/rUIIgAAYTBY72nAINEPwPCfq/P0kGIAAFpwAAAmEmL79wwAPAA1 +oAdIFPmMCCIAAFGw+Uk2AgAAevBtmQUECoYAT2UqEmIvEkEIRgz3qggAgAJ78NMPbWkFBgqGAE9n +JhJBB+gMqGYmbECW0GP0NikSQSmcQJnQY/QrAAD9EmAghRBQMCq1CPrMAAIAAGEwWO9HwCDRDwAA +bBAIHajHKNF/xGX1p/EQLhA4MPQsZSAAyXoQuBr7TAAAAxBgMFkzhowSDIwUnBKKNgWrAZsTKSAF +LDAe+zAiIJgIMnD9CjYmAKg/EP8CAA4AqOsQLiBo/yE1LgCjW5AsMRCx//8CAA4AnPsQLCU1+yRo +IgAAUTD4MgkgGAJYcPgmHCADEGAwWTNuijb5qKYSAIIikPsKQiwAfk6QKjAf/wIADgB42pAsIAX/ +AgAOAHMzEIknLCAHLZkUiZkoIQj00NFqIAFgMB2nl2SQxgyrEa27LrI6/wIABAEWQ6AtsjkVp+L+ +p+IUAgFgMPTSFm0ABDqgIyEHj5H6RBADQAEcMP8PRwPABDzg/5YBKgkAIPD0p40aCQBysPrWACgJ +AGIw/yIAKAkAKjCY1PXWBiAAEGAw9NYCIDAQGDDz1gMgBBBwMPzWBS+ABD/g/NYHLgkAd/D/1gEg +QAJTcAIJhgBKYwAJhgBKYYon+frAIEACUrD+tjkoAEBOsPylBCCAAkpwmaD5pgEgUhBAMPgkBSIA +ABMw0Q/AINEPLDEQKzAiY/7KxbUrJAVj/uKOJy/pFGTxQ4jpmBQap5EpITf/AgAGAJ7WUI022hD9 +jVcCAABZMP0WBSADEGAwWTMaihAKjRSdEI82jhUF/wEvFgH7IAUgAJafoHa5nSwwHnfBB/8CAAIA +jh6Qe94ZKCB0xJJ5iBEqIFd3oRguIGgtMCJ+0Q9gAPovIFfTD/8CAA4AeTvQji8tMQuKFK7dnS8o +oBNkgKSKpv8CAA4ATlNQ+wpIIEgQeDD/JAUmAEu/EMOG/wIADgBewxAqMCIpIGj/AgAOAFfSUC0h +NSwxELHd/wIADgBP6xAdqCksJTUeqCYqJGiKES7hf/2sAQIAXXuQfaB+H6dXLSE3/DEKIOQIe3As +JTd8p2p5rmd/rmR6rmF7rl58pgcoMB/EknmAU7Qb+jIJIAMQYDD6JhwiAABRMFky2cAg0Q99ozf/ +AgAP/7i7ECwxECowImP/i8CwmxRj/rgsMQosJTdj/r2NIsrVxOn+JAUgABAQMNEPAAAAAHzRkf8C +AA//OjLQxfX/JAUgABAQMNEPK6wY/CwAAgAAULBYI0vE6f4kBSAAEBAw0Q8AAAAAAAAYp/bAkQyc +OfioGHIAAGswH6cnLiE2/DEKIDYEe7AoITd8iaf8CgEgABBIMA3JOGWfK2P/liwlNmP/6ABsEATA +INEPAGwQECgiEyciEPY8AArgASww8woAIgNUZhD/AgACA3sa4BunLiqyiSqiWS2hAmTW91gXTxin +GRWnKSiCcyVSg6qICYgR/CAHJAAgRXArUAf9CvssAgFgMP7MEQoAQG7w/yAMKgkAZvArVAcsIAf/ +VAwvmBBwMP5UBSD8EGgw8lYKKgBAbvDzVggsIAFgMPNWCSoJAGbwK1QHZFYhilfbYPqsICIAAGEw +WB6tiVAImxELSwKbofqnChIAADKwKqJ2CpkMsZn5ahQLYAFMMPS2YGqQBDqgCQlFCpkCmV4rYQgr +VQiMIpcZ+goCI3oAtyAsIhMtcG/8iRQMCAFgMPrXAQAUAHtwCp4BDswCLSAHHqagDQ1B/RYNLcAE +P2Cu3S/SOv8CAAoC2UPgJNI5E6an/woAJaQANSCKKYkqA8MKIzKAkxwKmQz0c69gYAIY8CgiGCti +EQi7NqOz+xYRKgFynlAqIBYoCv//AgAGAEdGkCUWFCMWEikgB5kY9acAEqAQGDADmR0Tpz0kFhP6 +pAoEACAucPVECwgAIB5w9ZJ+ICACGrDwMQQAARAYMAA4GviSfyQAQEVw9acxGAkAKjD4ln8kACAp +MCVCfwChBAA6GvMSEiACAilwJUZ/KZKAlBUkEhP1EhQoAoHSUIgYDIgRroiIgAiqAWSlCPpMICBg +Akmw9AkWAAEQQDAASmUCCYYASmMACYYASmEoRCAqIheJGSpEPwqKFCpEPgqKFCpEPQqKFCpEPCqS +EgqIFChEOipEOwiIFChEOQiIFChEOIheKEQzCIgUKEQyCIgUKEQxCIgUKEQwKEA5CopXCKoR+EA6 +KgkAQrAIqhH4QDsqCQBCsAiqEfiSEioJAEKwml8apkn6FgsgAgJCMCiWEv9WFyHPADXgL0QjK0Qn +C4kU+UQmIKACQTCYGgmJFClEJQmJFClEJCpiGf+IFADAAkkw+RYAIOACSbD4RCIiKAA2oP9WFioD +AFLw+kYVINACQbD7CBYAsAJ5MAFPiihiGQq7DAqIDPhmGSKEADYgKWIb+2IaKAAgTrD5FgYqAANS +ULG7K2YaihYqZhsvCgAoIQcZph4ICEr2pvIZwAQ6IPkSCygJAEowmED7IgAgQBBQMJpD9qZDGAUA +PbAP+gmZQvmmpBBgEEAwCKoK+BINIB4CUrD6ShQGCQAy8PZGBCuABD7g9hIMKgkAXrCbQQmIChmm +cCiCmfY2DAugBD8g+acAGABASjD7IRooCQBaMJtG9kYFKAkASjD4RgcgEwA14Bum+LH5+xIKKAkA +XnCZsCgiFo8po4j4JhYuACAf8J8pKtY5KiAWLAr/fKExKyAH+aaoEqAQYDAMvB2pySmSf8HfCt0M +/wIABgGbalD4rRAPwAQ+4P09Ag4AIHfwnfOJWPpSCSAAEEAw9JJab5kQEDCYW5mgi1iasZhYIlQF ++FYJIAAQEDDRD50fLBYQ+iwAAgAAWPBYIeYrEhEsEhCNHx6lzf8KAC0AADagjFhkwjDAINEPwPBl +frUbpqKKGy8hBxilyv8PSgoFADrw+6ZZH8AEP+D4pfMeCQBH8J9AjyD6RgIgQBBIMJlD+RINKAkA +Q/D4RgQgBRBQMPgSDC+ABD/g+5kKDgkAV/CfQRumISmSmfg4DA+gBD8g+6axGABAXnD/IRooCQB+ +cJ9G+EYFKAkAXnCZR2P+1gAAAAAAAPP8XGAAEFgwKlIWBqoKKqIcZKB7Cro2KkYVKFIWCYgLuIj9 +CBYAsAIxMAGGiihSFgmICoaACmYMloAoUhaYFwmICoiAmR76uwwAJwA2IIsXCbsLibP2sgIoACBO +sPkWASoAA9JQJmwBlrKIEZizY/27ihfTD9MPZKEfKFIXDwIA/1YWIAICQjD4VhcgMAJKcPYSACAA +EFAw+hYEIPkANuAoUhaYF4gXjxQJigqKoCUWFfIWFyIAAXgw9iUKCgMAUvCaUCUSFSVSFioWFglV +C/YqCwAQAilwDgWIJRIVuKoByoolUhaSEyoSFglVCoJQCiIMKhIVmR6SUCiiFioSFpgXCYgKiIAl +EhXyEhcgAgJ78Pq7DAAsADYgixcJuwuIs/ayAigAIEKw+BYCKgADUhCxZpayiBL4tgMs9gC14GP+ +OIoX/xYEIDEANqAoUhfAoPpWFiAAEFAw+hYHIAICQjD4VhcgMAJKcIoTKGwY9b80ZgUAUjBgABzA +gfhWFiABEFAwmhdj/+AAKfqZ+VQFIAAQEDDRD48UY/3cwKEqVhZj/u2NLx6mQf5WCyBAAllw+9YA +IHACYLCcWJ1Z+yYPIAAQEDDRD9og//Y5AgAAWXD8bAAAjhBoMFggusAg0Q+LHdog+7wYIgAAYLBY +IXxj/XuJFSmdAiqRAiiRASmRBQqIAfoKASv9fEoQix3aIPu8EiIAAGCwWCFxY/1QiWcsmRT1bAAA +RAA3IIaZY/m8AAAA8/lsYgAAKPDz+aZv6hBIMBilkR+l2/quCggAIEMwCO4Lr+4t4X/z3QwAABB4 +MA/dNS3lf2P8uADz+X5iAAAw8GwQFCggBBelEA8CAPwKFyYBhA4g/wIABAGAIiApIAcvMgDzFg8o +IAFMMPkWDC7gAXww/xYQINYCe/APTxT/FhEkA34CICggBS0KTv8CAAYDie4QLgpH/wIABgVfdhAr +IBYvCv9/sRAAxY4qIEFYIOL/AgAABWIqoCUSDBak6wxVEfgSESQAIDVwJlI6/wIACgUMRZAkUjn/ +AgAABQapIBilCSkSEfAIBwIAAEEwbZkCAEhh+6W3EAAQeDD/FgEgCBBwMP4kZCAGEGgw/SRcIC4Q +YDAsJFcrJSoqMBUPAgAPAgD6ahQAAxBIMP8CAAgFMdJQKixl+KXAEAgCWHD4FgEgAxBgMFkwj/0h +ByAAEHAwLiRoLiRpLiU1/iYcIEIQcDAuJHQepMb8EhAtQAFsMP+k9B3ABD9g/yU3LAkAd3CdQIsg +KhIR+RIPIJgCYzD8RgMrgAQ+4PdGAioJAFqwKkYBKZAT/wIAAAQpKmAtIEEoIAUapYUN2wn+ISIr +wAQ+4PuqCABQEHgw+qJ/ICoEejAsCk58gQovClb/AgAOBPJ6EBilfv7fFAcABD9g9qV9GUAEP6D6 +C0YCSAFUMPZGBywHAVAw+qV1H0AEP+D4MxENUAQ7IP/MAgoJAB7w8xIQKgkAZvD6mQIGCQBd8PlG +BiYJAEXw90YEIAAQSDD5RQogeAIY8PNFCyCQAnCw8g4WAEACaTAATWP4ISogABBgMCxEMSxEMvxE +MyAAEFgwK0Q1K0Q2+0Q3IAAQUDAqRC75RC8gABA4MCdEMPhELSAAEDAwJkQ0CIgUKEQsLyBXL0Q7 +D48UL0Q6D48U/0Q5IHgCUTD/jxQAuAJYsP9EOCAEEGAwWTAwKCxg8wgWAIACUTAASooACIgACoos +IhyLHyxEUwyMFCxEUgyMFCxEUQyMFPxEUCCoAlEw/BIQIGACWvBZMCEmEhD/IHQmACAxMC9kWC4S +ES5WOSsgFi0K/32xCvogQSIAAGDwWCAtiB/ElikkBSiAEmSEahulSRykfx2lSPuLKAIAAFCwW79Y +2iBbvzvAINEPAAAAAP8CAA4CI2IQLSITJiIQ9Q5HAgOp51AZpJH/AgACA9sboCqSiSqiWS+hAmT3 +wlgUsBikehWkiiiCcyVSg6qICYgR/CAHJAAgRXArUAf9CvssAgFgMP7MEQoAQG7w/yAMKgkAZvAr +VAf8IAcvmBBwMP9UDCD8EGgw/lQFKgBAbvDyVgogABBoMP1WCCwgAWAw/VYJKgkAZvArVAdkVseK +V9sw+qwgIgAAYTBYHAyJUPukax2ABDpgDEwCnKErsnYLmQyxmfkLSwIAAEKw/KEIJykANuAJaxT5 +CUUKkAQ+4AuZApleLFUIjSL7CgIjjAC3YCwiEy5gb/yKFAwIAWAw++kBABQAe7ALrQENzAItIAce +pAANDUH9Fg4twAQ/YK7dLtI6/wIACgMsQ6Ak0jkTpAZkRkoDwwojMoCPKiMWDfST3mBgAhjwLiIY +K4IRDrs29hYIIgAgHvAmIgkoFhgG/wz7FhYqAXYf0CogFi4K//8CAAYAS3aQLiAHIxYZJRYbE6Se +9aReEqAQeDAP7x0kFhr6pAoEACAv8PVECw4AIB/w9fJ+ICACGrDwMQQAARAYMAA2GvbyfyQAQDVw +9aSQFgkAKbD29n8kACApMCVCfwChBAA6GvMSGSACAilwJUZ/L/KAlBckEhr1EhsoAt7T0CIWHB+j +xwziEa8iIiIA8hIcKgBAErBkpbgqjDD4ChYAQAJxMABOaQYKhgBOZwQKhgBOZcChKkQgJiIXJkQ/ +ihgGhhQmRD4GhhQmRD0GhhQmRDwmohIGjxQmRDsvRDoPjxQvRDkPjxQvRDiOXi5EMw6OFC5EMg6O +FC5EMQ6OFC5EMC+iEh6j2vZWDyACAnvw/6YSIAAQUDD6VhciFgA2YCtEJ/uKFACgAnEwnhv6RCYg +ABB4MC9EIwqKFCpEJQqKFCpEJCqCGf5MYCAAEHgw/hYKIOACcjD/RCIiYQA2oMBg9lYWKgMAUvD6 +RhUg0AJ6MPUPFgCwAjEwAIaKL4IZCrsMCv8M/4YZIrkAN+Avghseo7f7ghouACB+sP8WCSoAA1PQ +sbsrhhqKGSqGG8CAKyEHH6OBCwtKDLsR9qRUGgkAfvCbQI8gCWc59hIOKgkAc/CaRPiKCQBgEFgw ++6oKAEAQWDCbQ/ukBhAeAlKw+koUD4AEP+D3RgIuCQB+sJ9BC2YKG6PWJmKZCs8R+6RnFgBAWbD/ +IRomCQB5sJ9Gjx0LZgKWRw8/DP9GBSATADZgHqRfsYz+EgssCQBzMJzgKCIWhimjiPgmFiYAIBmw +likq1jkoIBYvCv9/gTUpIAf7pA8SoBBQMAqaHaurK7J/wc8IzAz/AgAGAi5i0B2jSfycEQqABD4g +/cwICgkAXPArxgOIWGSCpoJZwPCfW5ggiViSkZ9Y/1YJL5kQcDD+VAUgABAQMNEP2iD7HAACAABg +8P0xCCIAAHFwWAhELQqI/wIABgIf7pCMEGXCf8Ag0Q8AAC0WFCwWFSkWF/osAAIAAFjwWB9BKBIY +KRIXKxIWLBIV/RIULPQANqCKWGWvzI0vHqQo/lYLIEACWXD71gAgcAJgsJxYnVn7Jg8gABAQMNEP +wIBlnncrIQcfox8LC0oMuxH6o/IaCQB+8JtAjyD7o6sWBQBOsPdGAiBAEDAw9kYDKAkAc/D4RgQg +BRBQMPgSDi+ABD/g9hINLgkAV/CfQQuIChujdiiCmfY2DA+gBD8g+6QGGABAWjD/IRooCQB6MJ9G +9kYFKAkAWjCYR2P+jQCWGPP8MWAAEFgwKlIWCKoKKqIcZKB5Cro2KkYVL1IWDv8LuP/3DxYAsAJB +MADIii9SFg7/CojwCogMmPAoUhYOjwqP8Pq7DAAtADfgDosLhrOIsv6jGhYAIDKw9hYEKgAGUZD+ +oxYQAgJCMJiyihSas2P9hgBkgScvUhfAgA8CAPhWFiACAnvw/1YXIDACc7D4CgAhBQA24CZSFv5q +CgYAAUAwjxqKoCIWHP9iCgoDAFLwmiAiUhaWFg4iC/9vCwAQAhCw8QIWABACe/AAD4omUhYOZgqC +YAoiDJJgJlIWDm8Kj/AKuwzyEhwgAgJCMPYWEyA9ADfgDmsLjrKPsy4WEv6i7hIAADKw+hISLgAg +frD/FgUqAAYz0P6i6BACAlKwmrKPFf+2AyzUALZgY/5U8hYcIEEANaAqUhf/CgAgMAJzsP9WFiAC +AlKw+lYXIAAQMDCCGo8WKiwY/moKAgUAerDyFgomAAFAMPISHC81ALbgYAAjwGEmVhbz/9VgARAw +MIkfKJITmJZj96cq+pn6VAUgABAQMNEPHqLIY/3iAMDxL1YWY/7nAACIx4uI/YEVL8AQeDD5ggsg +QAJyMA/vAf8WAiwAIH9w/dxAJgDe3lAviRQMShGaE/r/CAoAIFqw/4UUKgDZ11DJO8lJ+bwAAgAA +QPBtSQUACIYASWGPE4rgDwIAD6oI/wIABgDsbpCa4IrACKoRCkoCmrEoIAXDbvsWDyYApjYQxNL/ +AgAGAKFuEMPt/wIADgDb8hDz9eViAAATMNog//M5AgAAWXD8PAAAjhBoMFgd8MAg0Q+LHtog+7wY +IgAAYLBYHrJj/OeMImXMtIsc2iD7vBgiAABgsFgerMAg0Q+PFy/9AibxAi7xAS/xBQbuAfoKASv9 +JHuQix7aIPu8EiIAAGCwWB6hY/ykiDcsiRT1PAAAnAA3IIqJ8/kAYgAAQrAAAAAAAADz+KZgABAo +MPP45W/qEEgw+iwAAgAAYTD+MgsiAABpcP8yByIAAFjwWABFwCDRDwCNImXcJCsgQdog+7wSIgAA +YLBYHojAINEPLDAULCRgY/WXGaKuH6L4+I4KCAAgTrAJ7guv7i3hf/PdDAAAEHgwD901LeV/Y/uW +xbIrJAVj9hcAAAAAAAAA8/9mYAAQUDDaIPs8AAIAAGEwWOqbwCDRD9rA/EwAAIQQaDD9tQgiAABp +cFjpl8Ag0Q/A4J6L8/6AYgAAWnAAAPvdDAA3ADTgDUYU/2wIIgAAQPD/TzYCAABS8NMPbfkFCgiG +AEprihKtOPZJDACAAlKwbZkFDAiGAEptiBOPEg2IDKj/L/xAn+Bj/i2JEimcQJngY/4jAAAqCoX6 +tQgiAABpcPrMAAIAAGEwWOl3wCDRDwAAAAAAAGwQFCIWHvcSHiIAAGnwDwIA+HAHIgAAcbD6Ckcg +RhBgMP9wBSIAABDw/RYDKCABQDD4Fg0gMAJCMPgWCSAYBGPw/wIADgNN09AkcSKMfpUWJiITIyAV +KHBBiyAdorn4iAkP8BBIMPsLRwnABDog+ysIDAAgR3D4EgMgfgJa8P3SfyoAQE7wirH9FgwiJAEc +MPsWCiYDAEGw+7wQKgL6U5D9CgAgABAoMA3vDB2iLC3SfwnMEazcLME3LXr/9BYFKgAGY1AUolqT +FGAADSRKAATENvMWBCXgASAwHKKiLMJ//wIAAgAAGzD/AgAKAE/TkI0aKNIDD6oMLBYC/dICKAAg +Q/D4FgcqAAP6EC3cAcDw8hYLIgAAY3D9EgcgAqoloPIWCyACpiagwCBtCFoKaTTzKAoIAQDNMJmA +AykLnZOckoiACGYM+KoMAAICELD9zAAIACBuMPkWDioAA0JQsc383AAAAgJ78P0SDiAYADyg8goA +IDACGPD/AgAAAnOloP8CAAACb6agY/+enBILXQsLWgqKoIjTkhuN0v+qDAgAIEPw+BYIKgAGehDy +FgsgAgJrcNzQ/RIIIAAQeDD/FhwgABAQMP8CAAAAU6WgLhYdYAAuAAAoEhz1XAEoACBDsPgWHCAY +AD1g9QoAIDACWvALXAsLWgqKoI3D/MICIAA3paD+CgAvzwA2oGphx20IVPMpCwgBANGw8y8KCAEA +wTAIZgwIqgyY8PyWAiACAhCw/ZYDLgAgbjD4+wZyAABrMLHN/NwAAAICc7D4IQxiAABr8PIKACAw +AhjwZK93/wIAAf+6JaBj/6QAAAAAAC4SHfYSCyAAEEAwmBArcBaIEyZiE4MS/hYZIP8QSDD4ZjYA +JgRK8CwSBipwQQDMjlgdRGSkPi0SHPmhThNrADdgFKIojByCFYUd/aFxEJACefD/FhIguAJx8C4W +E50f8tgUBcAEPWD8CkYDQAQ4oPx7QAIJACCw/IxCADUQIDD1uxEJQAQ6IPIWFSQAIE1w9RYRIAAQ +EDD7iAIAABAoMPsSBC2ABDsg/KoCAMACYfD8FhQoCQBSMPgWFyABEFAw+7zSIAAQQDD7pTgANhBQ +MPgWGioFACkw+hYWIAAQKDDwAA9gABAgMC0SHP8CAAYBZ+1QwOUOXi/04l1gAgIpcC8KgK9ELHEH +HaEgDAxKDMwRDcwCnECLcP+h9BBEEFAw+aHwEAgQYDD5RgIrgAQ+4PpGAyoJAGbwm0EocEEDKwqN +sC4SF/sWGCAEEGAw8IgRDCABbDD9zAwOCQBDsP2h4x4JAHuwnkT+EhIsIAFgMCwWG4uw/UYHIAAQ +aDAtRQr8EhUqACBm8PxGBiB4AlrwK0UL8A4WAEACYTAATGEscSr9RC8gABBAMChEM/xELSAAEEgw ++UQxIAAQUDD6RDAgABBwMP5ENCAAEHgw/0QyIAAQcDD+RC4gABB4MP9ENyAAEFAw+kQ1IAAQSDAp +RDYqEhoMjBT8RCwr4AFcMPsSEyoAIFLwKXBXKhYaKUQ7CYkUKUQ6CYkUKUQ5+YkUAAQQYDD5RDgg +eAJRMFksmfkSFCCAAlEwAgmIAEqKAAmIAAqKLnIcLRIcLkRTDo4ULkRSDo4ULkRRDo4U/kRQIHQI +aXAvEhv4ockQigJRMPscAABCEEgw+XR0LiABfDD4CgkuCQBH8Ph0ZS+ABD/g/xYAIAMQYDBZLH8r +EhkocTUDLAsfoZj5EhYgAgJCMCh1NSgSGCl0Vy9GFo6ALkYXjcMtRhmMwixGGIqA+XIPKgAgXrAr +dhyIgPpmDAACAhCw+xYZKAAgSjD4dg8gGAA8oPIKACAwAhjwHKCoLEYaLBIbwKUKWi+4yytGG/tw +dCwAICMw+8R0LdUAtqAtEhwF3Qyx3f8CAAP+4sNgKBIRLxIQL4Y5K3AWLgr/frEIKnBBLBIaWBxq +jBsrEhmby5bHiXLEp/p0BSC5ADZg0Q8uEhwtEhH17gwABRB4MP3SOiACAnOwD+42De4R/hYQKgBR +91AkEhEkQjlkT7soEg/9TAAAABBQMPAIBw1wADegbQgJsarwDaAH/rH2kGP/74sd/LsRAAAQUDD6 +FhoqACBO8CsWES4SES0SEC3mOStwFiwK/3yxCCpwQSwSGlgcRI8bL/ATyP6IG4l/iIZ5iQbEmCl0 +BdEPxKYqdAXRD42zjLKKsC8WHGP7VQDz/+9gABAQMNpw+xIJIgAAYfBYHKjRDwDz/2NgABAgMI8a +j/Sq///jVnIAAGqwwFD/FgEgABB4MP0SASAIAnvw+PQPYAICKXArvBj/CgAgABAoMKv4iICtiPgW +ASv/7cOQ/wIAC/zp65AO3wxj+csA0Q8pcEEpnBKZGWP+wAAAAPP/3WAAECgwbBAIlBEpIgcmMQv3 +IAcgSBBQMP2ZFCBGEGAw+CAFIEUQWDD3B0EBiAIxsPWSCSGJADdg/wIADgD40hAqUBLIo9ogW7sa +hFDaUPn6wCT4ASAw9RYCJgFKgSCIEoiKKzBf/wIACgFaNhD0sV9pwAQ54CxsNwxMFLTMnBQboBv+ +EgQoACBaMC2COvWhHhoBSndQKII5mBD4FgMikQA2IB2gOYkUAA2LbZkCAEhh/wIABgHCgSAuMF8b +oBT3oF0QMxB4MPwwXiGEALeg/wIABgCh/RD/AgAGAKGBICigE/SiBiFAADYgjS//AgAOAbBpEGXB +V8CgjRKM0fiuEQzgAWAw+iEHLAkAczCc0SggBwoKSvyqEQwCAUAw/iEILKAEOyD8EgMqCQBisP+g +QRggAUAw8IkRCgkAOrD6xgAuCQBLsPkiACAAEFAwmsWax/vGAi4JAHuw/sYEIEACWzD/xgYgBBBw +MPiZEQAwEHgw/8YDKAkAdnD5xgEiAABTcAIKhgBLYwAKhgBLYRmf2P0SAi/ABD4g/hIELgAgT/Au +9jkt0gD9jVcAMhBwMH7RLtogWBGg0Q8AAAAAAAD6iX9wABAoMMCgKqASZa53Y/55KzBeZb6ewMSc +FGP+oQAAJiEUIyES9AoAL8cANaD6UkIiAABY8PwKACABEGgwWBP/KFJD9EwBIAICGPAIMy52Sdtj +/5sAZM7dYAAyAABkztVgACoAAGTOzWAAIgAA/wIAB/8H5hD/AgAH/wPeEGP/dHyBgf8CAAf/v14Q +Y/9mLCAHihD7IQggbgIhsPREFAwCAWQw/AxBDKAEP2DwzBEMCQA/cP2mACoJAGbw/CIAIDACabD9 +pgMgABBwMJ6lHaCfHp+f/qYCLYAEOyD+EgIsCQBhMPymASoJAG7wm6QATo2Wp52mAgqPLCAMAMwR +9qYHKgkAZvD7pgQiAABhsPs8VCBQAlKwWStMjhAMTxH7n4weACB7sJ4T8/4NYIkQUDCLJ4URLLEV +K7wgCbsB+8sIBcAEPWD7vEAkACAs8PhcAAoAxFlQmBJj/UQAAAAA8/1MYgAAMjDz/W9gABBAMAAA +jSJk0VL/AgAH/z6BIIwnLskUJlK99OE1YEACUzCFyYVRJPrA9QVHAAAQWDD8bAACAABpcFgUGIwn +icgowRX7wgsgQAI7MAR9Af2ICAIAAFHw+IxAJgCNTtCLES7JFAy7Eavu/sUULAAgWnD/AgAKAIvm +EMk/jhH/nAAAGwA3oG3pBQQDhgBPZSoiByxyAPqsICwAIFsw/wIABgDGRxCccI2jKKEFjiCLEfKi +ACwAQCKw/IgID4AEO6D4jEAqCQB28PuWASYAWxdQL6kEDFkR+SsIDgAgT/D/pQQqAIHeEMlr02D/ +LAAAFwA1YG1ZBQYDhgBPZ4ugDwIADwIAqbv/AgAGAJjG0Jug0Q+KJ40RwMD6rCAiAABbcFgT35oS +Y/xodNsSDU4M/qYGLfUAtyDz/JdgixBQMATfDP+mBi3iALcg8/yEYIwQUDAAAAAAAPP+zWAAECgw +AAArfBj6LAACAABgsFgbZ2P+mwxYDGP+dcCAmMvz/yliAABK8MCQmaPRDwAAAAAA+YQMADwANOCM +EQRKFP6sCCIAAEDw/sw2AgAAenBtyQUICIYAT2mMEaQ4+swMAIACe3BtyQUKCIYAT2uKJyqsIAS8 +DKzcLMxAnHDz/sxvwBAgMAAAAAAAAPKEDAA2ADWgBEsU/bwIIgAAeLD9XTYCAABBsNMPbdkFDAiG +AE9tBGgI+14MAIACezBt6QUOCIYAT28Enwyvzy/8QJ+g0Q8AACTcQJRw8/5xb8AQIDAozECYoNEP +bBAIGZ/fKzEKJzBE/TIEICIQcDD/MEUiAABgsPoKACIAABEw9J/ZHHABbDDw9hEADgDj8Hr/cYwy +/zIDIAFqNxD/AgAAAWYzEBufECuyaSiSaK+7CbsR+hYAKAAgWjCYEWRzBxyfjAxsAXTJNiowPGih +M/8CAAIBGoagaKVV/wIABgEhBqB+oR3C032pGPoSASIAAFjw/CwAAgAAaXBY3vXRDwB5ZhTRDxie +7C8xJ/8CAAYAZ0fQmhBj/6T6EgEiAABY8PwsAAIAAGlwWAMl0Q8AAACNESnQBcSmepnIidcrmRRk +sfWLmS/QaBmfgCyyAfqwFSACAnvw/9RoIAEQcDD+1FwgCBBAMCjUZyjUZPnVKiAAEEAwKNRmKNRl +/jBOIC0QSDD/ME8qJAFQMPjVNSGkAlKw+O4RAC4QQDD6mDgOCQB7sPjUVyBBEHgwL9R0LtU3LrAV +/m4UAAMQUDD8DEcOAAV2kCmwFCnUYP4yFSIAAFNw/zIWIgAAaXBb/InRDy8wPA8CAA8CAGj2Y37x +YJoQjRH+0TcgeAJI8PAJFgC4AkNwAEhh/zEmIBACUHD/1TYgAxBgMP7VNyC6AltwWSo4ixHAw/q8 +XSDCAlrwWSo0ihErHAgPAgD6rGEgAxBgMFkqL/4KIi58ALXgYAF8AAAvwAT/AgAGAHoD4Bqfag3c +CQzMEayqKqJ/ZK6ZjDb7DUsNCAFgMC+hGQ8PS3/ZDouqyLkosT98gQuLuWW/9IqpZa/i0Q+KupsU ++hYAICsANqArPEGbEyqsTvsSAyADEGAwWOHM/goiIIsANqCKEIqo+hYAL+IAtqCLFGS+OB2fRC3R +f/wwPCAYAHtw/wIABgBCAyB+wXCNFC3RCPoSBCAIAlhw/DwAAgAAcXBYA0eNEWXe72P9/wAAAAAA ++hIBIgAAWPD8LAACAABpcFjebdEPAAAA+hIBIgAAWPD8LAACAABpcFv98dEPAAAA8/4IYAAQWDCP +EJ8UY/99AJoQnBHz/qBiAABrMH3Xi/P/jWP/EGgwACiwBP8CAAX/vIIg0Q8ZnxvTDymRf/8CAAH+ +xXpQ+hYAIEACYPD63AACAABocFjiXP2sAABJALagKjA8KwqB/wIAD/6w2pCKEGStV9sw/RYBIgAA +YLD9XAAAhBBwMFjhltEPAAAAAAAA+hIBIgAAWPD8LAACAABpcFjgqdEPmhHz/NpgIhBwMABsEAgp +MQ8qMCwfno77MC0kgQC2YB2eO/iqEQ/7EHAw+57/GgkAWrD83OAgVgR6sP8CAAYAUN6QHJ76/Z7J +FgFhZpD+nvgWAYFukP8CAAYBTXaQwCDRD4s0KNJv9sKIKnABWDD9pwdyAABKsA6pAamICYgR+GYI +AgFQptArMDf/AgAAAW8G4Pi2yGAREEgwebnAKjBCKzBDCKoR+wpDKgkAWrB7qawrMEQsMEUIuxH8 +CkQqCQBm8Hy5mPosAAIAAFjw/EwAAgAAaXBYxL/AINEPAAAAAIs0KTAuKjAv+DAwKYAEPmD6mQIK +cAFYMPiRDGIAACKw/wIAB/+tGmApMDEIiBEJiAL/AgAP/6T6ECYwNCgwNQhmEQhmAmhhB/8CAAP/ +mRmgJzBGLzBH8jBIJ4AEPeAPdwL/MEkngAQ94PieWhYJABXw+Z64F4AEPeAPdwIIeAH/AgAH/33O +EBietBmd9wh4Af8CAAf/dU4QfacCDqQBKNJvIsKIpIgJiBH4IggCASGm0BWeLByeqi8wPP4iByAF +EFAw+DA9IDAQWDD5MD4iAABpMP7iDi+ABD/g+DA/LgkAR/D+FgQvgAQ/4P7ivy4JAE/w9xYAL4AE +P+D2FgEuCQBH8FkwuCswRiwwR/0wSCuABD7g9hIEKgkAZvD8MEkrgAQ+4A27Agi7Efy7AgIAAFGw +WMPKZK5GKmKo/wIAAgC1AqD/AgACALEGoCswPCwwPf0wPiuABD7gDLsC/DA/K4AEPuANuwIIuxEM +uwIoMDUvMDSbECYwRicwR/1MAAAFEFAw+TBIJ4AEOaD8nnUWCQA5sPcwSSeABDmg+WYCAgAAcXD4 +ZhEAMBBYMPj/EQYJADmw9hYBLgkAR/BZMIopMDQqMDUImREKmQL/AgAAAMWGYP8CAAP+1JpgKzA8 +LDA9/TA+K4AEPuAMuwL8MD8rgAQ+4P27AgIAAFCw+LsRAgAAaXD8uwIAbAJg8FjC3sAg0Q8AAAD6 +LAACAABY8PxMAAIAAGlwWOMzwCDRDwD6LAACAABY8PxMAAIAAGlwWOHewCDRDwD7MQoiAABRsFjE +d/0KASAAEHAw+t44AAAQYDAO3Dj1zUFmBQBSsGP9EAAAAAAAAAD6LAACAABY8PxMAAIAAGlwW/5G +wCDRDwCNYC5gNf8wQiAFEFAw/J4yEDAQWDBZMFDAINEPKzA8LDA9/TA+K4AEPuAMuwL8MD8rgAQ+ +4P9ikioJAG7wCLsRDLsC/wIAD/9M29BoowTAwyxmqMCl/J4hEDAQWDBZMD7AINEPJTEKDwIADwIA ++iwAAgAAWXBYxEr+CgEgABB4MPrvOAAAEGgwD+049NxjYgUAUrAnMEYoMEcqMEj2MDQngAQ94Pkw +NSYJAEXw+DBJJ4AEPeD4ZhEGCQBV8PlmAgeABD3g8/1gZgkARfAuMD0sMDz9MEYiAABQsP8wRyAC +EFgw+DA+LYAEOyD43REMCQBzMP4wSCwJAH9w/zBJLYAEOyD43REMCQBDMP4wPywJAHdw+MwRDYAE +P2D/3QIAbAJ48P78AAwJAHMwWMMNwCDRDx+d6yLxfy7yQfn1gCIJAEiw8vV/IAICc7D+9kEgABAQ +MNEPbBAIGZ0hLMEX9SIHIgAAUXAfnR7zIAciAABY8ChZFPJSCSIAADiw8y5AAiABHDDwPREOoAQ7 +oP9RFS4JAHuw/qYALAkAazD+cgAsCQBLMPymBCAwEGgw+aYGIaACQjD8nMEQBBBIMPymAi+ABDug +/FwgLgkAS7D+pgEvwBBwMP2mAy4AQHMw/v0IAAAQSDD5pgUggAJrcPhVFCoAiOiQ/ywwIEACKrD5 +XAAKAIT/UAQChgBJZQIChgBJYwAChgBJYYLBIiww/wIABgCZbJCSwSjJBGSAYi1wLIysBL4R/t0C +Af4CWTD8uxEMCQBrMPymDCoAIF6w/VIBIEACWvCbEvxSAiAAEEgw/BYBIAAkL2D5FgMg0ACHcItR ++GwRCuABXDAMuwKbURqdmgw4EflPCAgAIFIwn4DRD8Dw/8UEIIACa7CdwZ3A8/+LYAAQEDAAAAAA +APsSAiIAAFHwW6pGiFErEgL8EgEiAABKsPoWAy3ABD6g8YagegAgbvDacFuqFY9RjhP4aBEO4AF8 +MAj/Av9WAS4AIHKwGJ1+DD8R/k4IDgAgR/Ce8NEPAAAPIgySWWP+6gLZDAlIFPgWACIAAGlwbYkF +BgKGAE1niBD5rwgAgAJrsP/8ICIsAD4gkhSCEMCDAogMbYkFCA2GAE9pCeIMIixwksFj/tUAACLs +QJLBY/7LbBAGJDAHGZxQGJxN+ZCAJCABIDAMRBGoRPhCOiBuAkpwCUkUuJn/AgAKAFXOECtCORqc +avm8AAChADbgAAqLAElhAElhAElhAElhAElhGJ1Q+Z0hEAEQYDD6IgAgABBwMP4WASAAEGgw+RYA +IAAQeDD4FgIgAxBwMFgT4ikxBxucNQkJSgyZEfidQxgJAF5wmaAZnDP/IgAgARBgMPykGSAQEFgw +m6P5pgIgAhBwMPj9EQ4JAEfw/6YELAkAd3CdocCF+EY5IAcQeDD/JAQgQAISsNEPwCDRD9Kw0Q8A +AABsEAYanBcsIAcookrAQfSBBmwgAWAwK6JJ/rwAAQYANuAdnBEo0IAMyxGqu/+yOiBuAkIwCEgU +KIwW/wIACgB7x9ArsjlksOyJJ8DALCRUL5kUh5lk8LiPcSkgFA8PRwmfh/kkFCwAdhJgFJ0TGZw8 +KHEXjHkvcgj/1jMgABBwMC7WMvyKFAyABDsgLNY5+tY4KAkASjAo1j/4+BMAIBAwMPjWPiDwAikw +ijAuQn8tQoQpQoIvQoMoQoEAYAQPDxsICBuZEv0WACABEGAw+BYBIAAQaDBYE5MkTBj1ScpyAABa +sIl0+iwAABAQYDD8mQIAABBwMPl2BCIAAGrw+zIAIBMQYDBb/wXSoNEPAAAAAPP/Q2IAADsw8/79 +YAAQWDAAAACNImTQYvQkVCAAEBAw0Q8AAACOImXv7SvMGPosAAIAAGCwWBgX9CRUIAAQEDDRDyUg +Ff8hCS/wEDAwBpYB9pgMBEAEPWD4JBQvgAQ/4PzkAC4JAC/w9uQDLgkAJ/Cf4SSmSWP+4QAAANog ++wocIgAAYLBYGAP0JFQgABAQMNEPAABsEASGMMSC+QqEID4QODD2hlcAMBAgMPRhPHAzEFAw9qIJ +cDcQYDDDsXtqCvbCOHA1EGgwfWIwIiAFdyFO+CFLcD0QcDD/CoUgPgRwsP81CCABEBAw0Q8iIAV3 +IQ74IQtwLRAgMHQhA8Ag0Q8oMDD7Ov8l6gA+ICoxCPuhGHABEBAwKTUI0Q8AAAAAAPk1CCABEBAw +0Q/AIdEPAABsEAYvMDwuIAcrMQuGLv0iACogAXAw/LzEIADIh+AXnH/0FgAmANMb4C9yaAloEfeb +fB4AIEfwKPAF/KYRAD0QSDD3vBMmACA5sPdHFA4A0soQKWI6d5MFJGI5ZUB5iCJkgTYFCUf/AgAC +AJYaYIonjxCLqP2hFS/AEBAw/KILIEACcrD4qRQiAEATsPLdCA/ABD/g/dxAJgC1XxCviPilFCoA +IHrw/wIACgCvV1CIEMk0+bwAABIANiBtiQUAA4YASWGK4A+qCP8CAAYAwm6QmuDRDwAAAAD48Qgp +gAQ/YP0hByAGAirwBUUU+CUIJAkALnD8RQ8oCQA+cJlB9UYJIegCWvD+JUAJAAQ+oPqcWx9AAWgw ++0YDIAAQaDD9RgUv4RBYMPmcVhgJAEow+lUQD8AEO6D7RBguCQArsPWbihoJAFMw+kYIKAkASjCY +RPqbPB4JACuwnkCaQinyH5lL+PIeIKgCWPD4RgoggAJRMFkm8oknKvrA92Y5IEACQnD6CgAoAEBS +MPqVFCCAAkIwmJmYmNEP0Q8AACusGPwsAAIAAFCwWBdvY/63jCf9+sAgQAJbMP0KACoAQG7w/cUU +IIACWvCbyZvI0Q/C4n752i9xf3331PosAAIAAFjw/BIAI/8QQDD4JQgiAABpcFjPNNEPxZX5JAUi +AABQsFgM2tEPwLCbq9EP+90MADYANOAsEgANSRQonAj4zDYCAABQ8G3JBQIKhgBLY4sQKixA0w/5 +uwwIACBs8G25BQQJhgBKZQ38DKwsLMxAnODRDwAALSxAneDRDwBsEBD6nAoQABA4MJcQlxGLQSqi +fyggB/ZCACIAAEmwLKEC9zYAKCABQDD2hlcC4AFcMPuhBCPSADcgmRaOoC2hBf/M/yH+AmLw/6UC +LcAEOyD87AgNwAQ/YA3MDGAAKgAAACmhBSyhBLGZ/qIAKeABTDD5pQUmAUXPELDMDMwR/OwIDcAE +PmANzAwADIsH52DwDIAPnAC7oBmb5iySSy2hBY/BhcD19gAtkAQ/YPvCACwAIG+wnRwlzf//tgEl +QBBwMPfGAC/AEFgw98YBKAHyAyD+xREgMAJTMPfFECoAQFqw+yIAIIACarCdF53Hncb7Vj4mAQwB +oJodjhwtIAScHvgWDy/gAXAw/hYKJAE8g2DD8P8CAAYBJP2QwJEfmqoMjhGv7iviOo0QmRX/EgEk +AW7C4CniOWSS0iMWECMhByQWERSapv0WBCNAARww8hYSI8AEPODwhAQCCQAk8JOQiyAsFhObGPsK +KCOABD7g+5YDIAQQIDD0mpwSCQAk8JORlJIkEhErIATzEhAh/hBgMPMWECIfAXww+xYJKADCguD/ +AgAEANaG4C0gTCsiEpsTnRIdm6ANjQKdG5OWghQTm5/ychQLFwEUMPMSBSIAQBiw/JuZGgBAZvCN +E/MSCiIJABiw85ULLABAY/DylQougAQ/YJ+d/5uSHfAEOyD8EgIqCQBm8IIbkpSblw3MGPyWDCAA +EFgw/BISLeAEPiD7lggsCQB/cJ2ZLMAHDCxA/Xr/LGAEOyANzAKcmyISExybgQiLCf9RkSvABD7g ++VJJLAAgYvAsFhUswn/zEhUgBBBoMC3mOR2beC4yf5LAHJrR/lZBLgAgU/D/EhQsACBrMPISEyoA +IGbwK1ZAIjZ/LVJGIxIQ8hISIIACc7D83AAGARPuUC1ZkAw/Ef/HCAwAIH9w/VWQKgEQv5D5zAAA +GQA1IMkxbTkFAASGAElhJ1JG0w8PAgCvd/8CAAYBInXQJ1ZGiRz5CU8GngA5oJnLiiAIqhEKOgL6 +xgEgABAQMNEPJ6UF8/1yYAAQSDAdmmUrQSf/AgAGAFLu0PP9/2AAEEgwG5tDjRgrsrML3Qwbm0cL +3QKdG2P+gghuEA6eAp7AjSAI3RENPQL9xgEgABAQMNEPKyBQLSITnRObEmP+UwAuQBiaHZwe+BYP +IIAA/7C0GvwKAyA6AlkwWSXaiB+MHoodY/2VANoQ/AoDIKICWLBZJdS0GvwKAyCcAliwWSXRiB+M +HoodY/1xAADaEPwKAyAyAlkwWSXLY/+zmh2PHCkgBJwe+BYPL+ABfDD/FgokAMYGYJodnB74Fg8k +NAA6YLQa/AoDIIICWTBZJb6IH4weih1j/yPaEPwKAyCiAliwWSW4Y//ZAAAiCojRDxubEAiJCfa9 +/inABD5gppb7EgYoACBecP8CAAIAf4bgK2KBnLArVkEpVkAsZoEsUkYuUZEpUkmq7v7sQCYAkWZQ +J1mQDD8RD3cI91WQJgAgZ/D/AgAKAIq/kMlF+cwAABMANOBtOQUCBIYASWMnUkYPdwj/AgAGAJ51 +0CdWRipigoii+RIMIgAAIzD5VYkgnQA2IIogCKoRCjoC+sYBIAAQEDDRD4scwMD7C08AARBoMFgO +BiIKiNEPAAAnVknz/hRiAABicAAAAAAA/O0MADYANSANThT77AgiAABBMPs7NgIAAEsw0w9tuQUE +CIYASWUoEgf+OwwIACBtMG25BQYJhgBIZw3+DK6uLuxALlZGY/3CjxcvVkZj/booYoCcgSlWQShW +QCxmgGP/ASugBwsLQfu8GCIAAGKwWBXxjCAIzBEMPAL8RgEgABAQMNEP2hD8CgMgkAJYsFklX2P+ +cydWSfP/GGIAAGJwAPztDAA2ADUgDU4U++wIIgAAQTD7OzYCAABLMNMPbbkFCAiGAElpKBIH/jsM +CAAgbTBtuQUKCYYASGsN/gyuri7sQC5WRmP+yo8XL1ZGY/7CbBAELCAHjSLzIhkvwBAgMPQhRGwg +AWAwZdE8HZl5DMsRrbsusjr/AgACAJBDoCqyOR6ZmvmsAAESADagHZl5AA6L/pl0H/AQeDAASWEA +SWGeoIwg+QoIIAIQcDD9pgIpgAQ7IPmmAygJAHIw+KYBJgB0fpAfmoYPzwKfpC62OSoiAmSgDVkW +UfusAAIAAFCwWA+oiD2KOIs/C4AAiSf9mfIQABAoMPuZ7x//EHgw9JAsYEACQnAEiAH1lRQggAJC +MJiZmJgusn+fkPUmByAQAlJwmuGdkyyyf5ySKrZ/lS6VLyUmECUmESUmEiUmEyUmFCUmFSUmFiUm +FyUmGCUmGSUmGiUmG/yaYhAFEFAw+wowIDgQaDBZLGolJAQlJAWVIiUkICUkISUkIiUkI5UplSqV +K5UsJSUa9SUbIgAAUPBYeVvAINEPAAAAK8wY+iwAAgAAYLBYFXsFCUdokgPAINEPiyctuRT6sgkg +QAJi8ATMAfzMQCAgAmtw/bUUIeACUrD6tgkqABlikC6xFfiZJh4AIFOwnrmY4I8gHZo++P8RAAEQ +EDD95gIuCQAX8P/mASAAEBAw0Q8YmRyYoIIgH5o1+CIRAAEQQDD/pgIiCQBAsPKmASAAEBAw0Q9s +EAqKNRuaJ/+aLRloAVAwCIgJ+Zl/GcAEOiCvjy/yf6uZ+YgIAAAQcDD9/f8mAfxH0InxjPCckIvw +LPkQmbGe8P72ASHPADcghfcrUgAnUgsLhFf2UgEh9AIZMAO3OPqaGRrgAVQwGZoWBogUI6KMCYgB ++ZoVGZAEOiD40YkiACBE8AYGR/cHTwYA0s4QZbPi/CIAJgDDgSAoUQiYEizWPvmZBxHwAlvw+yYH +IJACWLCbGfAJBwBAAkiw8AmgAJwCaLAASWEASWEASWEASWEASWEvMAT/AgAEAlgH4C4xIi8yACwy +FiuijCwmDf8mDi2QBDsg/iUiKgAgZvD7FgoiAABTcPiwfCAGEGAw+CRBINgCWvBZJIqLGooZ+7xy +IAYQYDBZJIcqLGH8CgMgogJY8FkkgyosXfwKAyCcAljwWSSAiRIuMgkameH+JgsgABBoMP0mDCAG +ADegkuySOS8wFiyiQy4wBysxB/gwDCACAmMwLKZDKjANKSUILiQHLyQWKyUHKCQMiCD9JgIgBhBY +MPokDSBPEFAw+iQFKYAEOiD7JAQoCQBBsPhWASAwEGgw9yUJJgEDgSD+CjMmAMntEPTiKXAxEHgw +/0IhcD4QQDAqMAXEkvclNiYBPUaQ+wo9JgE5TpD/AgAOAf1akBiYmwhICiiCEPosAAIAAFlw/GwA +AAIQaDALgADAINEPAAAAAAAA8/4zYgAAK7Apocf/AgAB/zt2UCs6/5sSY/5uFpmnLGJDwFb+1Ykh +/gJjMPxmQyFBALbgGJieiyD71j4h8AJL8Jkn8AgHAEACSLAASWEASWEASWEASWEASWEASWEsMAT0 +LE4gkAJosP0WCSQBzYcgjTAroowsMhacLZ0u/TEiLZAEOyD9JSIqACBm8JsaLLB8/CRBIgAAUTD8 +XAAA2AJa8FkkIosaihn7vHIgBhBgMFkkHyosYfwKAyCiAljwWSQbKixd/AoDIJwCWPBZJBiOOf4m +CyAAEGAw/CYMIAYAN6CS7JI5JSQELzAWKDAHKTEJLmJDKzEHLDANLTAMLSQMLCQN+yUHI/8QUDAq +JQj5JQkgAgJzsC5mQygkB/8kFiBPEHAw/iQFIAAQaDCdIvclCSIAAFCwWAoIwCDRDy8wBPclNiQA +bIPg2jD7XAACAABgsFv8gGSugvosAAIAAFlw/GwAAAIQaDBY36bAINEPAAAsohsbmMH6YkQiAABC +sJ/BK9ZB+YIbIAAQYDD51kAiAABZ8P+GGyABEGgwWAxhwCDRDwAAAAAAAPclNyB4Anlw8A8WALgC +cLDwDqAACAJQcP1RJiADEGAw/SU2ILoCGLD3JTciAABY8Fkj1CogYSkgYik0Afo0ACAIAlhw+CBj +IAMQYDD4NAIgwgJQsFkjy/osAAIAAFlw/GwAAAIQaDBb/HjAINEPAAAAAAAAKlwZ/AoDIKICWPBZ +I8EqXB38CgMgnAJY8FkjvWP/CwAAAAAA+iwAAgAAYbD7CoQgAhBoMPtVCCIAAFlwWN9pwCDRDwD5 +mRYQMAJD8PvRkSIAABKw+xYFL8AQUDD1kkMoAEBSMJgX+NJHKgAgRvD4FgYh/gIpcPWWQyXABD2g +BcwMKZK8+RYIIIACWvD4zDICAABSMPzVkCoAztoQ+xYEID0ANWCIFKpb/wIACgDLXhDZoPoSCCAa +ADWgbWkFAgmGAEpjK9JH0w/82ZAqACBdcIgU/wIABgDVRtAr1kf9Fgsg8wA3IIwYKSIbjhsYmFyf +kfjmQSIAAFDw+SIbIgAAWHD55kAgABBoMP8mGyACEHAwW/zG/QqIK+ABUDB9qR5oRhsrEgjTDyux +CCw6/3yxDQM6AvsSCCIAAGGwWOAoGpjX+3wAAAAQYDD6okQgARBoMFgL7MAg0Q8AH5h7iDCdEy4x +KS0wfC4lIv0kQSAGEGAw+CYNIgAAUvD/Jg4g5AJY8FkjY4oT/AoGINgCWPBZI2COO/4mCyAAEGgw +/SYMIAYAN6CS7IkSGpi9kjtj+34AAAAAAPosAAIAAGGw+QqFIgAAWXD5VQggAhBoMFjfBcAg0Q8A +ihedG/7VkCCAAlKwKtZHKtZGY/77AIoZKzB8HZhWLDEpjjCeLSwlIv0mDiIAAGFw+yRBIOQCWPBZ +I0DaQPwKBiDYAljwWSM9jjv+JgsgABB4MP8mDCAGADegkuySO2P8kogVihYIqgwq1kdj/lmJGAqL +DAtMFG3JBQQKhgBJZYkXihgMaAz5nEAqACBasG2JBQYJhgBKZ4gXC1kMqYj82ZAggAJCMCjWR2P+ +XIoXKqxAKtZHY/5RAGwQBCsyBQtJUfqXmRDrADZg/wIAAACVhmD/AgACAGGCYCyid2mTbvqigC1o +AVwwDcwICcwRDKoIiKLHnvsLRwgAQEow+KYCIDgANuD4s0pgFhBwMH65KImnL5kUi5lk8F6ItIyx +wZD5iAIABRBoMPi2BCzgAWAwWAE4wCDRDwAAIqYU+iYIIgAAWLBb+x+MKMiiisLLoMAg0Q+Jp8DR +LaRWLJkUwLD7phQgBgA3IIuZjLH8DEcAAxBoMFgBJ2P/zfP/nWAAEFgwK8AHCwtB+7wYIgAAUzBY +E3XAINEPAAAA+iwAAgAAWPD8TAACAABpcFv+FMAg0Q8ALKJ3+qKALWgBXDCtzAnMEayqiacel0KN +NCyZFPTAQGwAQHdwjJn9xgcu4AFcMC/EGy6gBrDu/qQGIAEQWDBbsXHAINEPAAAA+iwAAgAAWPD8 +TAACAABpcFjfucAg0Q8A8//CYAAQYDBsEEoZl3AsIAclFoaHMPVM/yjgASgw/AxBAgAAMXD5dwEC +AIECIIsi+iAUIAYCeXD4lvYWBQA78PWxlGAGAnGwDM0RCN0ILRaHLdI6LhaF+RKHKgDy91Apkjn5 +FoQhhwA2YCuCSmSxaymCSWSRZQqkh/okFCwAwZKg+DwQICoAPSD6TP8iAABIcG2pBQAIhgBJYSIW +gPodAiIAAFhwWSFlCqgC+haIIP4ANqAqCgP7HAACAABiMFkpMMlz+xKEIgAAULD9bAAAEAJg8FgO +Y9ug+EEXYgAAQHD6TP8iAABK8NMPbakFAAiGAElhjTP8XBECAABQsPwyAioAIGbwWA4bLBKHiif7 +EoUiAABpMPvGOSBAAlKw+0wAAAAQYDBYC3DSoNEPiif7oggpwAQ5IP2hFS/AEHgw+aILIEACcrD+ +FoMuAEB7sP4WgSwAIHdw/dxAJgB3XlApqRSomfmlFCoAIFow+BaCKgB011DKMclP2bBtSQUAA4YA +SWEqEoMuEoIPAgCKoA8CAP6qCAIAADFw/wIABgCKbpAtEoOa0PP+hWIAABrwiBAZl8MtEob8EgEo ++AFAMAmICiiCSCoSgPwMRwIAAFhwC4AAKBKIY/7bAMAg0Q/aIPsKHCIAAGCwWBLbwCDRDyvMGPos +AAIAAGCwWBLWwCDRDwD9IBUv8BBwMPwhCS4AQHKw/q8MAAEQWDD/JBQsQAQ/YP6UAy2ABDsg/QoA +LAkAazD9lAAsCQBbMJyRK4ZJY/5A8/4eYAAQSDDA8J+r8/3eYgAAGnAAAAAA+9oMADoANOAKTxT9 +/AgiAABA8P1NNgIAAErw0w9t2QUACIYASWEpEoGqONMP/04MAIACSnBt6QUCCIYASWMuEoItEoEK +7gz+EoMsACB3cC3cQJ3gY/71AC8SgSgSgy/8QJ+AY/7mAABsEASGPo0/GJd+AmUMltCOPv3mASAA +EGAwnD+cPiuCf/qXeRBwAjjwl7GaP/mCfyGQAiGw+TYOIAAQEDD3hn8iBQApMNEPAABsEASKIseN ++ilTABYAerAIqAGYItEPyJ5ZEy7boPwiAiIAAFCwWSbT0Q8AAGwQBIkniJz1CiMgJBAwMPKcMCAA +EFgw8okMAZACQjD5izkAKRAYMPQKKyBBADbgYAARir4rCgD6LAwBkAJSsAyrOcq4LLAA0w/TD3PJ +4y2wEPqwHyG6CCNwdaECdqnS2iBb/8r7rAAP3AC2oNEP0Q9sEAT0IgcvwBBAMCVMIPhVAQAAEBgw +80UUIIACKXCVSZVI0Q9sEAQoIHDTD3yHFCogB/siACoCAVAwWN8YyKfSoNEPAMAg0Q8rIHAsCvcM +uwH7JHAiAAASsNEPAGwQBoo3izb5IAcvwBA4MPUIRw8AEGAw/LsBCgBAYrD5BUECAEqaII4nwIAo +JhSM6C3hFfbiCyBAAnuw9/cBAAAQSDD46RQsACA/cP3cQCAcCGGwmevwAF9iAAAZsAxGEaaI+OUU +LgAgYbD82QwKAMVzUP08AAA1ADTgCUgU+BYCIBACQjD4SDYCAABzMG2JBQANhgBOYYgSqT34SAwA +gAJx8G2JBQINhgBOYwltDK19LdxAnfAMwwKOIsjiwCDRD4w0HZXT/pcAEAEQMDD8WREAAIPvEK2Z +L5I6/TEKJAFFw+Askjn/lc8QKBAgMPiV0BJ4ADcgLiEHDg5KDO4RD+4CnsCHIMD0+MYCL4AEOeD0 +xgMuCQB7sJ7BJCAE8IQECADyASD+ltYUAPgFIC8gTCgiEpgRnxAOXgIfltGHEYQQ+HgQDgBAfrD3 +RBgP8AQ/4PjGDSYfAVQw98YGKRcBWDD0xgwh/hA4MPeW1RgAQDow9JbFGAkAejCYxydw+wt4FPSW +whgAQCIwLcUL/sYEL+AEPWD4dwIOCQAn8PfFCiAAECAwlMifyS8gBw8vQPR6/y5gBD/gBP8Cn8vA +hCiWOYQ0xn8HRAGUNI8iBv8C/yYCIAAQEDDRDwD6CggiAHNzECkgVMuW+yIUIgAAULBb+XDSoNEP +AAAAAPnMAAAUADTgyExtSQUEA4YASWWO8AbuCPh8QC4AVOuQmPBj/pcpIFVlnpgrIFZkvpIu0kpk +4Vwr0klksVYZlXgpkIAMXxGt//jyOiBuAkpwCUkUt5n/AgAKAJVOECfyOWRxHykgFAmUh/kkFCwA +nZJgKyIUZLDT/MsUDAkAVzD9NgQgABBwMMCQKSRWiDD/AgACAGcqEIkxhTL2kUpiAABZ8PYKACIA +tQZQiifbQPwKACIAAGkw9vY5IEACUrBYCgzSoNEPnvBj/fIr4nQq4osMzBSsu/m7EQIAAGkw+6oI +AgAAYPD6JhQiAABYsFv4+vkiAiA8ALagZZ3I2iD8LAAAMAJZcFgRlcAg0Q8elnEu4oIflmIOfgzz +/iVuCQB7sC8gUCgiE5gRnxBj/hAAAAD2JFYsCQAycJwiijTHtwuqAfo2BCAAEBAw0Q/B0A3NAv02 +BCAAEFgw8/8rYIgQcDDaIPwKBCIAAGnwW/ha0qDRD9og/CwAADACWXBYEXjAINEPANog/CwAADAC +WXBYEXPAINEP2iD8LAAAHBBYMFgRb8Ag0Q8AAAD+IQkv8BAoMPggFSQAQC5wBZwM/CQUIAAQYDD0 +iBAPgAQ7oPW0Ay4JAEOw/LQALgkAM7CesSbWSYw0Y/6LAAAA/xYDIgAAULD7fAACAABhcFui1Ikx +LxID/KsRAgAAMrD7ewgB/08GUJ8T+iwAAgAAYXBboqOPE/P+h2YAIDKwAGwQBBKVlPIifyAAEBgw +hCGJIJlAiCCUgZMg8yYBIfACELDRD2wQBIooiacomRT7kgkgLgA2II2iwPD/JAUv/hBwMP8kBCwA +QHdwnaKMscDT8qYULOABYDBb/uHSoNEPAPP/0mAAEFgwbBAGLiAElRL5ChcmARIHoPUFRwYBIM+Q +/wIAAgBoAWArMBD4CgEgKxAwMPoKLSYCMjbQ/AoyJgJI1tD9CiYmAJTm0P8CAAYA1O7QKSAHjiLA +8PkIQQIAegFg/xYBI3oAt6AclMkMixGsuyayOiwKAwxMN/8CAAoBqmWQKrI5/5UUHgIBSDD0o0Fu +oAQ7oA/uAi6mAC0iACmsEP6Uwx2ABD9g/qYCLAkAbzD9pgEuAasjEC8yAA8PR/+mAyIBwJlg+DwQ +IB4APSCwSm2pBQAIhgBJYcCALLY5JiAE+SAFIAkAtaDMkWSEJ9KA0Q+KJ4gyFpTN9KPiavgBRDAc +ldLwBgcOfAFAMPZtAiAQAkDw8AagACACSzDxAxYCAABrMPIdHgIAABswbekFAAiIAAmK+JXGF9AE +O6C/ZAREFPaEeyACAiEwJIR/Y/7YhieKbCZsMP8CAAf/graQK6zIZL76wPGfEWACcQAA/wIAA/9v +mWApICJkkEMtIAcelQvA8P8kIiwgAWwwDt0JLNHmqcws1eYpICJkk6scla0swiOGK/DBBAH+Alpw +ALsaAIoa+qz/JgAgWbAKZgKWKiggIC0gBcCUCYgC+CQgI/9BG2AICkP/AgAL/zuaoMCw+yQgIgAA +ULBbr1rAwCwkFCwkBWP+Wv8CAAP/K5lgiCdkgOqKjMfj+SICIGACQjD/AgAADBBgMP8CAA4ATcKQ +/wIADgBjZlAOnQGdImAAuQAAAAAAAAD6LAACAABY8PxMAAIAAGlwW/9e/CIIIOkAtqCOwmTg38Ag +0Q8AhTL8lX4QBRBQMPWFVwAwEFgw/SIAIgAAeXBZJ3bCZv8CAAYAhDVQwnv/AgAGAIs9UMKN/wIA +BgCSRVDDknlZuvosAAIAAFjw/RICIgAAYTBY3azAINEPAAAAAPusyC4ABWZQDpoBKiYCyrEssAAt +Ci34FgAgpARrMC6yDsCw0w/+jwwBkAJzsA/rOWW/3NogW/4WKSAF+AoIIFYANmAvICAI+AL4JCAj +/qcaYAgGQ/8CAAv+oZmgwID4JCAiAABQsFuvDWP+yNqAW/3GiBD7rAAPmQC2oGP/tAAAK8AHCwtB ++7wYIgAAUzBYEGPAINEPHpVBLuLZieGL4JuQiuCPICbt/vmmASAAEGgwneCd4f9mfiHwAnOwnico +JCD9JCEgBxBgMCwkBWP8ywD6LAACAABY8P0SAiIAAGEwWN3mwCDRDwD6LAACAABY8P0SAiIAAGEw +WN2rwCDRDwD6LAACAABY8P0SAiIAAGEwWN2TwCDRDwAAAADaIPuMGCIAAGCwWBA9+iwAAgAAWPD9 +EgIiAABhMFgLxo8iZf5fhhFkblr6LAAAABBYMFuuR8Ag0Q8flIb+IQggABAwMCamBfamByAgEGgw +/aYDKQAEPiD5lQweCQBLsCmmBvmsIC4JAHuw/qYEI/5DgWCNJ4rcjqGGoJbgj6D+9gEgABBwMP6m +ACBgAmtw/qYBIbACQrBtSQUCCIYASWMelPgo4tsWlPOagZahL+Lbn6Aq5tuJ0MCA/Z4MAZACSnDz +/EZoBQBycCgwHykKI/8CAAf+2c4QKgok/wIAB/7UVhArCiX/AgAH/s7eEPosAAACEFgwWABVY/uF +AAAA+iwAAAIQWDBYACNj+3QAAAAflHsIDVH8IAcuACB/cC/wgC4K+/7MAQ/gBD/g/gr8LAkAezAO +zAH4JQgsCQBrMCwkB2P77AAAFpTPiicblDb8Ytkv/xBwMP6mACAAEGgw/SYHIBACErCSwZujKWLZ +maLyZtkiAAASMNEPhimWKmP8bwAAbBAEhSDyVAwBkAIZcMAgBDI50Q9sEAQqICArCvPTD/uqAQAA +ECAw+iQgIlIAOOBpMRn8Cv0gLAB6sAysASwkIAIqAlv9Yy0gIGTQZdEPAAAAAAAA/6f0cAEQGDAu +Cv4OrgH+JCAiAABQsFv9YiggBxyT+ykgIvQkIiggAUAwDIgJL4Hmqf8vheYpICKKKy7Cf/SQKmH+ +AmpwAOEEAN0aADsa+7z/KgAgarALqgKaKmP/jdogW65SJCQUJCQF0Q+PKZ8qY/95AABsEAQqIAXA +iHqDOBaUjvUKACBGADagKiAgwEHzqQIIAA+akPkkICLUADjg2iBb/TbaIFv9GSogIAoKQWqjSNEP +AAAAAPosAAIAAFjwWNxjZa/rKiAFY/+yiydlv7gsYtqPwYnAmfCIwI0gLs3+n4GVwJXB/eZ+IfAC +YzCcJyUkICUkIWP/jwDaIFv8+CQkBdEP2iBb/SYrIAcdk74sICL1JCIqIAFcMA27CSqx5qyqKrXm +KSAijCsvYiT0kB5h/gJycADxBADuGgBNGv3c/ywAIHMwDcwCnCpj/08AiCmYKmP/RwBsEAgrIAf6 +MgAiAAAxMPgwECALEGAw+BYAKiABXDD7FgQq4AFQMPoWBigAkwYg+BYAJgCXZhDA0J0TjiKHFPiT +FBAAEHgw/xYCINEAt6AMdxGodylyOrRK+hYBKgCSVlApcjkqIAT5FgUhHgA2YGSgji2CSmTQlimC +SWSQkCogFAqkh/okFCwBVJKgKxIA/wIACACHAuCPFYgWGZMCmfCOIPWTAxzgASww9fYCICACS/D4 +9gMvgAQ7oPg8EC4JAHEw/vYBIgB2G2D4QQ1h/gJRMG2pBQAIhgBJYcCgizD/AgACAJgq0CZ2OSwg +BP0gBSAJALcgzNFkotHSoNEPAAAA+iwAAgAAWTBbrmdj/3zaIPsKHCIAAGCwWA8ujhNk4n/6LAAC +AABY8PxMAAIAAGlwWAq2jyLM/YgSyIn6LAAAABBYMFutOMAg0Q8AAAAAAAD6LAAAARBYMFv/cGAA +DAAA+iwAAAEQWDBb/z8FCUf/AgACAQYCYMChmhNj/rwAAADz/t9gABBIMIsU9aHiYDACWvD6LAAC +AABgsFgPDmP/etogWNzSZKIPjCJkzuhj/2oAjRP4IgciSQA3YIqMj6GMoJzwi6D/tgEgABBwMP6m +ACBgAkIw/qYBIbACWrBtSQUAC4YASWEek98r4oAp7QKasZmhL+KAn6Aq5oCNgMCg+N4MAZACa3Dz +/tFqBQBzcAAAAC4gBCwgBx2S8IkV+yIAKAIBYDAKiBD9iAIIACAmcPTh5G2ABD7gJZQaHJK8KJQS +BY8U/5QZIDAQcDD+lB4gABBYMCuUHfiIFAAAEFgwK5QbKJQR/48UAAAQcDAulBz/lBggBBBwMPiI +FA4JAHNwLpQWKJQQD48UL5QXCIgUDo4ULpQVKJQPDo4ULpQUDo4U/pQTIAMQWDDwDAcAPgJCcG26 +AgBIYRiSxxuTqx2TqywgBx6Tq/UhCCDgEHgw/5QnLCABYDD+lCotAAQ7IP2UKSQJAGVw+5QoJAkA +RXAllCIFhRQllCH1hRQAAhB4MPWUIC4DACfw9YUUAF4CInD1lB8iAABBMNMPbfkFAgOGAEhjwGAm +RAaGEWP9uQAAAAD8IQkv8BBoMP4gFSwAQG6w/asMAAAQeDD7JBQgARBYMPTuEA2ABDsg/ZQDLAkA +czD/lAAsCQBbMJyRK4ZJY/0a+iwAAgAAYLBYCLhj/ZyOJ4jsLuww/wIAB/729hAvjMhk/eLAgZgS +Y/2FAAAAAAAA+iwAAgAAWPD8TAACAABpcFgLs9Kg0Q8AKSAF/wIACf70mmDAoiokBWP93ByTZo4n +H5LK+MJ+L/8QWDD75gAgABBIMPkmByAQAluwm4Gf4y3Cfp3i+8Z+IgAAErDRDwAA/JwAAAEQWDD6 +jCAiAABpMFgG1WP8xQAAKJQSJZQaCIMU9Y8UAAAQMDAmlB3/lBkgAxBwMPOUESAAECgw9ZQcLgkA +c3AulBbzgxQAIBBAMCiUHg+PFBiSmy+UGCOUEA6OFC6UFQODFA6OFA+PFC6UFA6OFC6UEy4hCP+U +Fy4gAWQw85QPLwAEP+D/7gIAABAYMPOUGy4JAEOwDo8UhikjIBSFKyWUNiaUMv+UISgJAELwKJQq +LpQiCIgU/48UAAAQcDAulCUGhhQFhRQllDUmlDH/lCAgABBwMC6UJPiUKSAAEHAwLpQjCIgUD48U +BoYUBYUUJZQ0JpQwL5Qf+JQoIAAQeDAvlCYIiBQGhhT1hRQCgAQ84PWUMyABECgw9pQvIgkALPAj +lC4olCcDgxQjlC0DgxQjlCwDgxQjlCsvJBTz+6JgBgIxMGwQCIgiHZLRKyAH/DIAIf4CSTD5FgQg +DgJ5MPkWAyogAVww+xYFLABAazD8FgYgsQC2IIcVGJHEDHcRqHcucjr6IAQqAGJ/kClyOfacAADB +ADZg+RYAIHkANqAtgkpk0JYpgklkkJAqIBQKpIf6JBQsATeSoCsSBhySQv6SQhCqALbgBQ9H+DwQ +IgBtG+D4QRBiAABJsCpM/22pBQAIhgBJYcCAihSJFgyqEfWRR2YAIFGwizD/AgACAL4q0IwT/HY5 +IgAAEjDRDwAAAAAAAAD6LAACAABZMFutIWP/lgAA+iwAAgAAWPD8TAACAABpcFgLEdKg0Q8A2iD7 +ChwiAABgsFgN4mP/1/P/P2AAEEgwixX0ogpgMAJa8PosAAIAAGCwWAf8Y/+3AI8VL/wU8PEEAgAA +S7D/kf8QARBwMADuGvoSAC4JAGOw/vYwIAIQaDBt2gUACYYASmGGEPP/I2BAAjGwjieeEfjiCS/A +ECgw++kUIEACa7D64RUkAEAvcPUWAinABD0g+bsMACACQjD45gkkACAusPi7MgCAAilw++UUKgD2 +KhBom0Somiqs8PsWByoAv1VQ+EEkYgAAWbCwTm3pBQIIhgBLY4rRDwIA/9kEKgAgUnD/Fgch4AJS +sPsSByYBFS6Q+tYBIgAAQrBlvrBgAYGOFfmR4xAoAnOwAOEE/pHMEAEQaDAA3Rr83QICAABRsP3m +MCACEFgwbboFBAmGAEpljxS0/58T8/6CYEACMbAtIAcuIAQakZX8IgAoAgFsMAqZEPuRRxgJAFZw +9OFFa4AEOyCbYh2RYilmAP8KBCAwEHAw/mYDLgkAfrD/ZgEgAxBgMPANBwAgAkmwbcoCAElhLiAH +HJGA+yEIIAIQUDD9kmQeIAFwMP9sIC8ABDug/rsCAgAAS/D9ZgYqCQBm8PtmBCoDACKwbakFBgOG +AElnghPAkPn0BiAIAhCw8nY5IgAAEjDRDwAAAAD8IQkv8BBoMP4gFSwAQG6w/asMAAAQeDD7JBQg +ARBYMPTuEA2ABDsg/ZQDLAkAczD/lAAsCQBbMJyRK4ZJY/1U+iwAAgAAYLBYDVhj/bEAAAAACFsM ++08UAgAAUbBt+QUICIYASmmIEv9PDAoAIFmw+IxAIB4AP+Cw/m3pBQoIhgBKa4gSL9kEC5oMqogo +jDD41gEtMAC34IsSwOD+1QQggAJa8JvRm9Dz/RhgABBAMI8RCogMmPlj/g0TkXiZYPtmAiAgEHAw +/mYDIAMQeDD+IQguCQB+sP9mASQgAWww9CAUJQAEPWD/IgkuCQArsPUiCy4JABuwnmSVaf9mCCQJ +AB8w8woAJIAEOSD1ZgYgARAoMPNmBSQJACkwlGcjJBSCE7Mi8nY5IgAAEjDRD4gSKIxAmNFj/dds +EARoQwZoQj7AINEPKCAGsIgICEf4JAYv8AC2IIkiLDABx677Cv0oAEBWcPkmAiJQAT8ge8nR+iwA +AAAQWDBbqyHAINEPAAD7PBAiAABQsFjbWcAg0Q8A+iwAAgAAWPBY22nAINEPAGwQBviRfRKgEEgw +CSkoHJHn+YgIAAQQUDD1gn8gIAJY8PCxBAABEEgw8JkaAgAAaLD5VQICAABw8PWGfyIAAHkw9RYA +ICAQWDBZI8/aIPs8AAIAAGEwWHrqwCDRDwAAAGwQCJcQHJHS+hIQICAQWDD4EhEiAABosPgWBSIA +AHDw+BYCKYAEPWD6FgQvAAQ9IPoWAS4JAE/w+goELgkAfbBZI7kckcQZkcT/kUYQARBYMP6RABAA +EGgw+vr/IJ8ANSBoQQbGKtEPAAAAJCqgBCQoiBTzNwoOACBxMP8SBSQAIHkwDncLLhIS8DEEBgAg +TfDwuRoP4AQ/4P7+OADfADYgDv44LnV6K0J/GJGs+hIFKgkAXnArRn8qdX/4djsg1AA1YGlRnYoU +ixVZJZv9CgggABBgMFkkyvwKACPoEGgwWSTV2iD9cXoiAABi8P5CfyIAAFjwWOUOwCDRDyoqoAoq +KAAxBPC4GgQAIHqw90J/L/8QYDAMiAPzPAoKACBysPrMCwYAQEXw90Z/LAAgSzAtxX8XkYj3xjsg +ewA1YP8CAAH/kR1gihSLFVkle/0KCCAAEGAwWSSq/AoAI+gQaDBZJLXaIP5CfyIAAGLw/QoAIgAA +WPBY5O7AINEPK0J/Cp4DDrsBK0Z/LXV//HY7LzQAtWD/AgAB/2adoC1xevwSBCIAAFCw/kJ/IgAA +WPBY5ODAINEPyW3/AgAB/1SdoPwSBCIAAFCw/kJ/IgAAWPBY5NjAINEP2iD8EgQiAABY8Fh6j8Ag +0Q8AbBAGKTACZJB2/wIAAABNhmD4kgZv6hAQMNEPIjAG+JDXEqAQSDAJKR2piCiCfyQwBfMyAyAb +ADYgwKT8kU8QIBBYMFkjP8Yq0Q8AAAAAAAD6CgQgIBBYMPyRSRIAAGiw/kwAAgAAePBZIzVkQKFp +QdT6LAACAABY8FjavsAg0Q8qMAYrMAcsMAMtMAQuMAWPMogzmBApMQmZESgxCpgSW/9e0qDRDwAA +IjAGH5DB9DAHIqAQKDAFJR38kSoQBBBQMPMxCC4AIC/w+fJ/ICACKTDwUQQAARBwMPDuGgAgEFgw +/pkCAgAAaLD59n8iAABxMPkWACIAAHjwWSMR2iD7TAACAABg8Fh6LMAg0Q8AAAD6LAACAABY8Fja +1MAg0Q8AbBAEFZEXwCAiNAIlUBglNAglNAklNAolNAvRD2wQBMAg0Q8AAAAAAGwQBCYiEdMP9QoA +IDgANaAakQsoIhL3IHYgIAJKsG0IHyOSd/KihCQAIEFwpDMJMxH1XAEiACAYsPckFioAA7FQY//Z +0Q8AAGwQBCIhBdEPbBAGFY/H/pD6EAAQIDD2CgAiAABI8PkWACAAEDgw/uF+IAEQYDDwADZgABAY +MAAA+goAIgAAYbBZJO6PES4SAvszAgABEGAw9vYIBgkAVfD1XAEgAgIhMPhJLGAIAhCwAEAEDggb +f4fmiyBosCkqUDCeEgChBADJGgkJBvoWAS//2F5QxirRD4sQk7H3tgAgABAQMNEPAAD9TAAAAhBQ +MPyQ1RAAEFgwWSK/xirRDwBsEAQABIvIVgMiYAAEYdEPAyJg0Q8AAABsEAQoIQQlIQUpIQKEIPiM +/yXABD1g/IgRAf4CSnD5JQIkACBBMAVEDPAAMGAAEEAwJSEFJiEE9CIAIAICKXD1BU8B/gJJsPUl +BSnABD5g9WEidAAgSTAMVxEHRAwABIsIWGDwBIAPlAC5YCIhBQkiEaJS0Q8oJQXz/9tgABAoMGwQ +BPWQqxKgEEAwCCgoqFUuUn/5UnwgDAQbsMiR0Q8AwKT8kKQQIBBYMP0sAAIAAHjwWSKLI1Z/+iwA +AgAAWPBY5IgWkJcmYBj0CgAv0AA1oNog/DwAAgAAWTD+UnwgABBoMFjkAbFEdknlY/+uAABsEAQq +IAeIIhyPSv0hByggAVQw9YCRa8AEPmCsuyyyOv8CAAoATycQKLI5/I9GGgIBUDD0gItqoAQ6oC4y +Ag6OV/0NSg8ABDug/N0RCgkAcrANqgIMqgIqhgD+IgAh/gJRMPmPOx/ABD6g/4YDLOABLDD5hgIv +gAQ7oPmMEC4JAHEw/oYBIpoCO2AoPBD4QQ1gABAQMG2pBQAIhgBJYSS2OdEPAAAAAAD6LAACAABY +8PxMAAIAAGlwWAiZ0qDRDwAAACucGPosAAIAAGCwWAtpY//UhieCafNpFC/AECgw+mEVIEACYbD8 +SREEAEAvMPkzDAAgAhCw8mYJLAAgLrD4MzIAgAJrcPNlFCoAUOiQaJs6opoqrPD2jBAqAB1XUPhB +H2IAAEGwsE5t6QUAAoYASGEqwgEPAgCqmvPJBCHgAlKwfaFu+sYBIgAAErBkMEgktjnRDwLdDA1K +FNMPbakFAgKGAEZjCk8M+FxALgAgajD67BAgIgA/4LD+0w9t6QUECIYASmUvyQQNkgyiUiIsMPLG +AS+7ALfgwCDyxQQggAJBcJjAmMEktjnRDwoiDJJpY/9aIlxAksFj/5BsEAgrEhCSFfeQIRIAAEnw +9hIFIgAAEbCbF5kU949QFgAgObBgAARkUGzNLCpigAo8AfxJ8XH+AilwjRRk0Er61gAgABAQMNEP +AI8XZPA/COowGY9DKZI1wKUKKjcKmSipiJgWihcpcoL4jz0YAEBWcAipjgioCoiAC4AADOowixYM +uwxrsdxj/6HAINEPANogWRw5Y/+U3jD9EgUiAAB5MPoWACAIEFgw/I/5EAEQUDBZIeDHK9EPbBAE +BeowFo8oKGI1wJUJKTcJiCgUjyTwABVkACBFcAaoCoiAC4AACeowCVkMapEQKkKCCjoBCKqOZS/i +aabf0Q/RDwBsEAT0jzYQEAIYsClCfxiPNJORmCMlQn+VIiNGf9EPAGwQBhiPEBmP3CiA0SaSiyqS +ffmShSCAEFgwq2b2YLQrkAQ6oP+HDHgAIFZw8AAJZgAgXnAnKoCnl/8CAAAAeKWg1GD1j84QABAY +MPAAZ2AAEBAwI6Q1LqAMjaApoAf4+v8g/BBYMPikFiAAEGAw/KUZKABAXnD8j8IYCQBMsCmkB5IS +nRGTEPhQgCAwEFgw+BYDIAUQUDBZIaApUIAAMAQJCRt/n3HyLAEgAgIY8PNhfHACAiEwHI+wL3AN +LsJ0LXAMLMKF/joIDgAgcTD57hELkAQ6oPyqCAwAIHMwnK/9pAwl3BBAMCilGC+kDSlQgAAgBAkL +G/8CAAP/rP7QbQgPsSIAIAQJDRv/AgAD/6N/UGP/6QAAAAD6CgUgMBBYMPyPmRIAAGjwWSF7Y/93 +0Q9sEASIJxuOb/f6wCACEFAw9YkUIgAAMLDyggkgQAIiMPmBFSQAQDkw9ExAIEACKXD1hRQhwAIQ +sPKGCSoABCCQopKSiQALi/2OQhIAACiw0w9tqgIARWGdIIxg+MwRAAIQaDDzJgIsCQBrMJwh0Q8A +bBAEGI8CjS4VjseOK/oiDCAAEBgw/FLIIFYQIDD77AAGAILHUAnZEfSgZ2wAIEswnquLK8iwmryT +K/MmDCIAAFCwW6kOjCf2+sAgQAJbMAa7AfPFFCCAAlrwm8mbyCogBfMkFSYAkCaQLCAH9I70EE8Q +QDAoJAUrUWT0Qn8iAABQsPsrFAQgAWQwWHW6ZKEN0Q8AiclymVD+xgkiAABbsPrABSAGADbgk7zE +snupiI3J/sILL4MAt2Bl73v7wgAgPxB4MC/EBS5StPpSyyABEGgw/rsMAAAQYDBYAjsZj0KInrCI +mJ5j/06Jy/rCCiAWCBJwnsuLK2P/pXKpCp7K8/+dYgAAW7AALSAFdNmRLSE2/iE3IAUQUDD8jzQQ +MhBYMFkhFdEPjy0J/xH1rwFsACB7MIjL/wIADgBvkhCey4sryLCTvCnABcOg/wIAD/91UlCLy2W+ +4I3MZd7bjs1l7tb7wgAgKxB4MC/EBS5StfpSzCABEGgw/rsMAAAQYDBYAhJj/rItITb+ITcgBRBQ +MPyPGBAyEFgwWSD30Q8AjScajxWaQCzRFfkiACABEDgw+9IIIEACc3D40gsuAEA3sP/MCAmABD5g +/MxAKAkAPnD5RgEg0ARaMCjZFPq8ECAgAkIw+NUUKgAw1xDISgAEhgBLYSrSCCqsEP8CAAYARmaQ +muCLImW+h9og+1wYIgAAYLBYCfrRDwCNzXLZCp7N8/8eYgAAW7AAj8z/AgAP/4mT0J7M8/8JYgAA +W7CT22P/wQAAAAAAAAD7zAwAMgA1IAxNFLjY+Hg2AgAASTBtiQUCCYYAS2OsSfr8QCAkAD9gDXsM +0w9tuQUECYYASmUM/Qwt3FCd4GP/eSj8QJjgY/9xAAAAAAAAAGwQBPgiAC/AEEgw9DBJaABATLDT +D20IMHOBPCowAPwwByBsBCKwKiEF+asIDcAEOyD7vEAiACBk8Ps7D3IAADjw83wAABMANeBj/8YK +Nwxj/+4AAAAAAADzjgwAABBoMA7TONIw0Q8AbBAEKyAH9o2+EAMQaDALJUAKVRD3IQgkCQA1cJUw +iCAajfP+jW0QIBB4MP82Ay2ABDog/jYCLAkAazCcMfkiCSogAVww9iAUKwAEPuD7IgsmCQBd8Ps2 +CSAAECgw+TYIKAkAUjD4NgYmCQBV8Pc2BCaABDmg9TYFJgkAMTCWN/UkFCBgAhDw0Q8AAABsEAQk +ICIYjdHzIgsgARAoMPRAH2H+AjEwKIJ/AIEEAGYaAFUa9Vz/IgAgNPAFMwKTKtEPiSmZKtEPAABs +EAT1jcMQARAgMCVSf4YrgykAUQQARxr3fP8v/xBAMPYyDAYRAEXw8FAEBgBAObAGMwzzAxkCBQAR +MKMi0Q8AbBAGKCAFLCAH01D8CkEIAFiaIIspjiv/AgAOAFLbkI0nLdEUwZD/AgAKAEtuUB2NIAyp +Ea2ZL5I6wGH/AgAAABAoMP8CAAIARMfgLZI5ZNB+Fo1pDC9ACv8Q/I0dHgkAN/Cf0I8g9iEIICAQ +QDCY0/j3EQADEEAw/NYCJgkARfCX0feNmB0ABDqg/CAUJgkAYbCV1Z7Z+9YILIAEOyD3ZgIOCQA/ +8P/WBiABEHgw9tYELAkAezCc1yUkFIwRKJY5AwhH/wIAAgBImiDAINEPAIkiZJCsAwpHaaJyiScr +mRQtnCD7FgAgkQA24IqZFI5A9KCfb8AQODDwAAdgKhAYMGSgj4vQ9KA3bgBAO3B6sS8soADTD/mg +ByBOBBswL9EF/vgICcAEPmD4jEAqACBKsPirHnIAAGKw+swAD9EAtyAKvAwMWjhkoEmOonTpscAg +0Q8PrAxj/9+KJ/tMAAAAEGAw+qwgIgAAaTBYAYfSoNEPAAAAAAAAAPP/cWAAEFAwAAArrBj8LAAC +AABQsFgJGWP/QYsQitErvBD71QQqAEA/cPqs8CCAAlrw+tYBKgAVWpAs0QX+jMgaACBTMJrRnqCN +IAjdEfSmAiwJADdw/aYBIAAQEDDRDx6MwJ6gjSAI3RH0pgIsCQA3cP2mASAAEBAw0Q9sEAgoIAUv +IAf5ChMiAABRMPoWBCIAACFw/w9BDgCfyhCIIsCh/AoAIUwAtiATjKMM9xGjdylyOv8CAAgA7EZg +JnI5/mwAAdUANaAoMkr/AgAGANVCICYySWRhn/uNJhAoAmvwANEEAKkaGo0P9Y0iGAkAXnCZFimm +MPrsAAIAAElwAgmGAEpjAAmGAEphGI3c+iIAIAAQSDCZECiAgPwKASAAEGgw/40qEEACW7D5FgIo +EAQ6IPgWASAeEHAwWAQwwPD+IgkiAABasPoiAC4AEGgw/iYMIAAQYDD8FgEgARBgMP0WAC8AAXAw +9+4RAAAQaDD+FgIgGhBwMFgEIRiM6i8SBi+GMAYFhgBKZwQFhgBKZQZrAvUhCSIAAFCw/QoBIAAQ +cDD5Cgog/xB4MPl2OSIAAGFwWIgTLCAV/QpAIAAQWDD7JBQiAABZcFjVW8DW/TZJIBQQYDAsJAUE +Dkdo4gwvIDrAj/8CAAYAZMfQwCDRDwAABAlHaZLziScrmRQvnCD7FgUgbQA24IuZFo2d9LC1b8AQ +ODD38wEAKhAoMI3wyr970S0usAD5sAcgTgQrsCTxBfNICAnABD5g+IxAKgAgTvD4uyVyAABy8Pvs +AA/TALegC94MDss4ZLBqiLJ2gYv1v7liAEA/8GAAWgS+DGP/2PP/lWAAEFgw2iD7ChwiAABgsFgI +fsDA8/9mYAEQUDAA8/4rYgAAMzAr/Bj6LAACAABgsFgIdsDA8/9FYAEQUDCKJ40UwMD6rCAiAABb +cFgA1NKg0Q+MFYvxLMwQ/PUELABAO/D7vPAggAJjMPv2ASoAFGLQLfEFq9ub8R+MHZ+wjiAI7hH2 +tgIuCQBTsP62ASAAEBAw0Q8AH4wWn7COIAjuEfa2Ai4JAFOw/rYBIAAQEDDRD2wQBCggIiUgBxeM +igOIDPgkIiQgASwwB1UJJFHmo0QkVeYjICKJK/xyfyABEFAw9DAcYf4CWPAAwQQAuxoAqhr6rP8o +ACBecAqZApkq0Q+NKZ0q0Q8AAABsEAQoIAb4jP8iAABQsPgkBiABEFgwW6ZOwCDRDwAAAGwQBMBR +AyQsAyIuAlI5pCLRDwAAbBAEFIz5ASIRojKkIoIg0Q8AAABsEAYYjSIBKRGpM/AACWIAIEDwAMpo +zXoqIoAKSwH7WfJx/gIxsIkc8goAIBAANmCakNEP2nBZGVBj/9vAINEP3TD+TAACAAB5cPoWACAI +EFgw/I0PEAEQUDBZHvbHK9EPAAAAbBAEGI0JAScRpzeodyZygMePCEgDCGYBBlYCJnaA0Q9sEAQp +IQSHIPNYFAnABD5g+XcICeAEOiAIdwwnfPz2cgAogAEcMPCRBAABEEAwAIga8JAECgBANjD7AxkP +/xBQMPCRBAgRAFIw8EgaBgBAQbAIZgL2dgAgIQA1YCUhAshKsFr6JQIiAAAQ8NEPsVv7JQIiAAAQ +8NEP0jDRDwAAAGwQBANUFCUhBIIgDFUR9SIIBeAEOSAEIgwiLf/yIj8kgAEYMPBBBAABECgwAFUa +8EAEAgBAKLACAhnRDwAAAABsEAQnIQSIINMP9nz/KecBHDD5JQUlwAQ9oPWFCA3ABDpgDFwMAAyL +KiED/QoBKsABHDANO2AKCkb+PhNgABBgMAybEQtbDAILiw08Ym8+E/lpCX//EFgwyKFzoSMJkhGi +MtEPJyEEsZkJCU/5JQUgoAQ6cLB2DGUR8//EZAAgLjAJnxGvP/9UFA/ABDng/kQRDgAgcjD07gwO +gAF8MPDxBAH4AnOwj+AA2BoLhAME/wH5IQUoCQB6MJjgiCBj/6MsJQXz/61gABBIMABsEASIMwiI +V2+EA4kizpaKJ/UyBCIAAFkw8zIFIgAAaTD6rCAgABBgMFgABPosAAIAAFjwC1AAwCDRDwBsEAT4 +LAALwAQ5YP2CASIAABDw+4kEIgAAGTDyVAwFwAQ8oP2BBSIAICtw+rsMD8AQYDD1qgwMAEBiMPi7 +MggAIGdw8oYBIIACSnD7hQQqACHIkMqkCiUIdZM/yUFtSQUAAoYAQ2GFgfuJBCQAIFVweVFl9YYB +IgAAEXDIsdEPACbMQJaB9oYAIAAQEDAihQTRDw0iDJKBY/+4AAKXDAdLFPtEDAIAACjwbbkFAAKG +AEVh8sxAIgAgPPBtSQUCAoYAQ2MtiQQHogyiwiIsQPKGAS+rALdgY/+mIsxAkoFj/5kAAABsEAQb +i6YZi6QAIQQnsID2kIAgARBgMADIGvqLoRjgAUAw9EY5BABAPjD1xTkCAAAh8PaUgCBgBBlwx+/6 +KgoOEQByMPA9GgYAQHXw/zkQBgkAbfD5ppkm4AE8MPe0gCAMADUgyXzRDwAAAADyi44f9gA14C8i +0sc+A/8BD88CLybS0Q8Yi4glgtLHnglVASWG0tEPbBAEFow3FYw9E4w+gmn4jDwQBhBIMPeK/y7/ +ECAw8yMKBhIAvKCDMAowAIhqsIj4Zgov/xAQMNEPK1KqKoKACytXK7ym+4Z/IPMANqCZaSwKZC1S +qi5KAPdiCiAAEHgw/2YJLAkAd3AtVqr3wgwIAGDl0KJzk2rRDylSqioaAPgKASABEBAw8mYJKABA +PnD4ZgooCQBWcClWqtEPKlKqG4wb/IwZGxEBUDALqhwbi5L5ZgkqACBisAuqLCqGgGP/jS1Sqoxq +wLX7ZgksAEAncP1WqiACAmMw/GYKIAEQEDDRDy9SqvNiCiMAEBAw9/8BAAQQcDD+ZgkuCQAX8P9W +qiACAhjw82YKIAEQEDDRDyhSqoNqwCLyZgkoAEAiMPhWqiACAhjw82YKIAEQEDDRD7F5+WYKIAEQ +EDDRD8CjmmkvUqrzYgojABAQMPf/AQAEEHAw/mYJLgkAF/D/VqogAgIY8PNmCiABEBAw0Q8AAABs +EAQUiyQVi+YXiyQjQIAbiyL+iyMf/hB4MP36/yANADTgsDIiRIDRDwAAwMH0CgAgBBBAMG2KXSpR +6ClR5CiwgPBBBAABEDAw+pMGcAEQGDDAYADJGgkJRwiSAQIyOfYhKXIAAFIwDZID8GIaCABAEjDy +iAIC8AQ5oPJ2mSjgAUAw+LSAIBIANqDJhbFE93wEIAQCKXDRD/MKAS/wADYgYAABwDAo4tIPiAEI +OAIo5tJj/9dsEASIIxqKwCst/iuyfCqif/m7EQ/8EEgw+6oICABASjALgADSoNEPbBAEHYuxAiwJ +DcwKKsJ/E4q0i6EszQKOoJ6wjaAowQIprf771gEgABAgMJSglKEpkn7zMn8h/gJCMP0KASngAUAw ++MUCKZAEPmD0gF5iACBM8I8yKTIHACEEANga/pkUL/8QUDAKiAP6kgkuAEBH8P82AiAwADeg8opJ +ECMANqAooAACiAooghD8oAciAABasP0KAyIAAFDwC4AAZa/g0Q8AAADz/9BgABBQMP/BAyIAAEkw +CeQWAQIAG4qkKrKCAPEEAE4aAPEE8N8aD/8QQDAI/wMPqgEOqgIqtoIJ5BZj/24AbBAEhiCHYSMh +BIlgmXCIYBSKeyVt/veGASAAEFAwmmCaYSVSfvRCfyH+AhjwAwNP8yUEJZAEPWD0MAxkACApMNJA +0Q8AAAAA8iEFIgAAWrAL5BYBAgAdioQs0oIAIQQArhrwIQQAARB4MPD/Gg//EBAwAv8DD8wBDswC +/NaCIgAAETAL5BbRD2wQBBaLFQElEaU1plWUUNEPAAAAbBAIGIs+khT2EgQiAAARsPAACGYAIEGw +yljNKSpigAo5AflJ8nH+Ailw8goAIBEANeCacNEPANogWRdrY//cwCDRDwDeMP0SBCIAAHkw+hYA +IAgQWDD8iyoQARBQMFkdEccr0Q8AAAAAAAAAbBAEGopXFos28/r+IAAQODAkYq4AAgApotADmQEp +ptAYim4nhlxZH0sViy4dijcILBAMTAINzAIsZq4biyIntoQqUlsUiyr2ig4QABAQMPeLExBGADag +E4skK2J8KlKkqysJuxGrqi4ygC1wgAAgBP0NGw4AQCOw/jaAIBwAf3Asoh3Iw8CxWOe/LVJbsSLz +PUAr/+PskMc+H4sVLvKCA+4BLvaCWG4P0Q8AAGwQBP+LERAREEAw8zsJCgAEmhDBlXObM4wnjcOI +wpjQjsIPuwoqsX795gEgABB4MJ/C/8YDIf4CUrD/JgIr4AFQMPq1fiAWADag0Q/bMPwiAiIAAFCw +WRo40Q8A+LF/IgAAS/AJ5BYBAgAcihIqwoIAgQQA/RrwgQQAARBwMPDuGg//EEAwCO4DDqoBDaoC +KsaCCeQW0Q8AbBAEGIrrAzUJDlURqFMkMX76CgEgTwA1ICsxfoYiH4rlKTF/jSccif4uMj3wkQQA +EAJDcPCnGgwAIHsw+OYBLAAgYXCc0/7WAiACAlrwKzV++DY9JgkAObCWItEPAAAAAAAAAPsxfyAA +ECAwBOQWAQIAF4nqKHKCALEE8KYaD/8QSDAJaQMJiAEIZgImdoIE5BZj/4MAAABsEASKIGWgVR2K +xgs+Ea7dLdJ/+iIDIAEQYDAMTDcNyCz43SgKIAFQMPclBSoJADKw/cwMAAICWjD7+vwoBQBi8Puq +AQmQBD4g+VkCCgkAGrD6JgMoCQBKMCglBNEPjyMbirEPD0EL/hGr6y2yf/yyfiA2CBNw2MDyiRtw +ABBgMMDALLZ/LLZ+iiBgAAzZwPKRVnAAEGAwctEajiGa4I8gLbJ9nvGcIPwmASH+AmtwLbZ9Y/9S +GYqcGIm0qYio6HihGfq2fyAeALfgzaYqsn1qohEtsnsttn9gAAgA/LZ/L+wAN+CKIGP/sByKjxmJ +p4ghrJmp6fmJDAAAEGAwCcg4KLZ+Y/+QAABsEAQjIQQViofzdEYCAEAs8AQzAiMlBNEPAAAAbBAE +wEAE5BYBAgAWiZUlYoIAIQQANxrwIQQAARBAMPCIGg//EEgwCYgDCFUBB1UCJWaCBOQW0Q9sEASC +IwICQdEPAABsEASFI4MgFIpw+CEEJCABLDD6imwVsAQ9YPQwF2QAICFw+HlGCABAUjAJiAIoJQQi +Qn/RDxaKYh+JeishBCNCfh2KYP5CfyzHAVgw8jYALgAgN/DzJgEuACB9cP8mACACAiuw9UZ/KgBA +bvDyRn4qCQBm8PslBCIAABFw0Q8AAGwQBIUjiCAWik38ik0UIAEsMPSAY2uwBDlgpqYpYn8nYn4d +iV/ymStwABBYMHJ5KytmfytmfoQhiCCYQIUgI2J9lFGbIPsmASH+AhjwI2Z90Q8AAP8CAAYAQBXQ +cpEciiGYoIwgKWJ9msGbIfsmACH+AkpwKWZ90Q/RDwCs3q6ufoEw+GZ/IDUAtWDOjS9ifWryKCNi +eyNmf4UhiSCZUIgglYGbIPsmASH+AiPwJGZ90Q8AAPtmfy/VADVghSGJIJlQiCAkYn2VgZsg+yYB +If4CITAkZn3RD44hrN+vrw/vDA++OC5mfmP/cQAAbBAE9YoXEAEQMDD0LAAAAxAQMPAABmYBADEw +sCIoUn/1XOAr//vFkNEPAABsEAQrIAcWiK0ciPb7CkEKAgFcMPiJRxqgBD7g+SEIKgkAZvCbMIcg +9DYIKwAEOqD1NgkoCQBWcPY2AigJAEZw+DYGICAQEDDyNgMgAxBAMPk2BCAAEEgw+TYKJ4AEPeD5 +NgsmCQBF8Pc2ASBgAhDw0Q8AAGwQBCwgB/siACIAAFDw/QoBIAQQcDD8LEAAMBB4MFkaqB2IqBiI +0h6JuPANBwIAAEqwAElhAElhAElhKSAHLyEICQlB8JkRAAAQWDDyrDAuCQBP8P6mAi4JAEfw/6YA +ICACSrACBIYASWMABIYASWErpBbRDwAAAGwQBCggBxqIvAgoQAqJEAqZApkwhyD2iHUXgAQ94AdX +Apcx8AYXABACOPAAB4r7IQgpwAQ9YPqJZR0ABDog/YhkEGACEPD9NgQqCQBm8Pyc6CoJAFbw+zYG +IaACSnD8NgUgABBwMJ43AASNmjiZOQITj9EPbBAElzYeiFP5iFIQAxBAMPqIUxAYEFgw+zYDL4AE +PKD6NgItsAQ9YPk2ACwQBDkg/YmqHAkAazD4EgouCQBH8Jg5nzH/EgksCQBhsP82CC4JAHCw/YhJ +HAkAazCeNJw1jhieN/ANFwBQAhDwAAKKIjww0Q9sEAQWiV0mYn+JYYtgm5CKYPmmASAAEEAwmGGH +IZZwl2HyZgAiAAAo8PYmASGQAjGw82wAAgAAEbBtSQUABYYAQ2HRD2wQBAUGR2hiBcAg0Q8AABeJ +SSdyf4xxiCeOcJ7AjXD81gEgABBYMJtxio33pgAgYAJKMJlw+nYBIAAQEDD3hg0hkAI58G1JBQAD +hgBHYdEPbBAEiCD6IQUvwBBgMPIiAyIAADiw/EsRDABAYfD4uQgKACBisPqsQCBuBECwLXkEq939 +dQQqABjOkMk2yUTyPAACAAAaMG1JBQAChgBDYYlwC5kI+pFZcgAAEjCZcNEPwKCac9EPAAipDPm6 +DAA0ADTgCUsU/bwIIgAAEPD9TTYCAAAyMG3ZBQAChgBGYQkyCPtODACAAhswbekFAgKGAENjqs8v +/ED/dgAiAAASMNEPIsxA8nYAIgAAEjDRDwAAbBAMlBWXGpIYiBiWFIcwiIeVGfUSCS7oATgw9wdH +AEACQjD4FgwiAe0DoCIKEPIWAyAeAnnw/08UAAIQEDCMHP8SCiACAlvw98EFJ8AEOKD2/wgPwBBo +MP8WCywAQGsw/HYID8AEPuD2bEAuACB88Pr8AAoB/DPQ/7gRAgAAIrD77AAOAS9DkIgbiaGKoPqG +ACgDAE1w+YYBIBACUTDxChYAEAJCMAAIiodBj0MJVQyKQvl3DA4AIH5w90YBKgADS9Cxqp9DmkL8 +Fg0gARBIMPeXOQAAEGgw9504AAQCQvD00whuBQBqMI8bjB30UvxgIAJ78I0V/90RAAICQ7D/AgAK +AXVqEBiHwvPmCwAAEDgw+BYGICACQjD4FgcgABAgMPAALGIAAFGwixbwCwcCAABL8ABJYQBJYYig +ZIGZ9FEiYAICS7AD5gv6bAAKAIvqUIscK7EFrLgojED/AgAKAYLBkIug/3YKAIYANuD/ewsIAwBZ +cJhg+FUMABACMrD1BhYAEAJa8ACLiomghqMrogL4mQwAAgIhMPmmACYAIDIw9qYDKgADwZArvAH7 +pgIgtAA1YGRyJP/8GCAAEDgw+BIHIDgAc/DwCBcCAABL8AAJigAJigAJimAAEwAAAACLFvALBwIA +AEvwAElhAElhi6Fkv0QPdgr/ewsIAwBZcJhg+FUMACACMrD5BhYAEAJa8AELiomhhqWLpPiZDAAC +AiEw+aYBJgAgMjD2pgUqAANBkLG7+6YEICwANWBkcaT//BggABA4MPgSByH/b3PQ8AgXAgAAS/AA +CYoACYoACYpj/tUALjQCiBv0SQkADxBQMAqZCglJFPRMASIAIEiw9IUBIAICELCOGCnhB4wUGoc+ ++BIKKUABTDD/iBEZwAQ+YP2HPBgJAFZwmYCJE4vg/uEaLAUAJ/Cdgv0SCS+ABD7g+YYDLgkAfLCf +gf8yAyAgAlIwW6JG0Q+IobPrCL44Y/5bjRWeEfcWACAAEHgw/90RAAICU7D8Fg0qAH1qkP4WASIA +ADqw9BYCIgAAY7APAgBtCCnz6wsCAAAjsPa7IXIAAFLwi6DNv4uhsf/1sFRgBgI58LNO/OwACgBd +adBj/8yKEAq6DGP/2okbC102/ZYBIBACWrD7CxYAEAJKcAFJioigj6MNVQyLov2IDA4AIH9w+KYA +KgADa9Cxu5+jm6JgADcAiRsLXTb9lgEgIAJasP0LFgAQAkpwAYmKiKGPpQ1VDIuk/YgMDgAgf3D4 +pgEqAANr0LG7n6WbpI0SH4hVjdD/EgssAEB/cJ3wi6BlvRaIobPPCP44Y/0MAPP+D2ABEDgw8/1R +YAEQODDz/nRgABAgMI4RD/gJ8/zrbgAgQ7C/f/9PFABrADXgiRr4PBAgQAJKcG35BQAIhgBJYYUZ +Dv4J+QoBIAQCE/D3VQwAIAJB8PgWAyAVADVgKxIFD7sR++sMAAAQUDALqTn9CgEgABBgMAncOGXL +4/P+KWAAECAwAAALagxj/PgAAAf6DGP8BcEgkhPz+8RgAhAQMAAAbBAEhCmDLAQzDAMDSCMlHyMl +IdEPAAAAbBAEiSeKnPiZFCAAEBAw9ZwgIGACInD0qwwBkAJSsPSAoWIFAFqwipn2Cg0gVwA2oCcK +PM02K6AAd7FHaLUsdrkLLKAQaME7drkCaMI1LaAHwMD6XAACAABbcFv7VitZBIpRybVlr8tgABgA +LKAQacjMYAAOAAAAAAAAAPP/5WAAEFAw8wotIBwANKAtIABz0RmOLsAg/k8MAZACc7AP4jllL+fA +INEPAAAAAPssAAIAAFEwW/A18qwAD9EAtqBj/+EAAPP/YWAAEFAwbBAEBQZHaWJahSeIWPlRFS/A +EGAw91ILIEACUXD9WRQsAEBisPyZCAvABD0g+ZxAIG4EQfCr3f1VFCQAIF4wdZMtyTLJQG1JBQAD +hgBIYSWiAA8CAAtVCPlRWHAAEBAwlaDRD8Ag0Q/AIJJb0Q8AAPiVDAAuADTgBUcUuHb2RjYCAAAQ +8G1pBQAChgBIYQUyCPdIDACAAhswbYkFAgKGAENjBbkMqckpnED5pgAgABAQMNEPK8xA+6YAIAAQ +EDDRDwAAAGwQBC4gBx+Gow4uQAruEP2GVx4JAHuwnjD4IgAiAABRMPSGcRAEEFgw/TYCIDAQYDD8 +NgMpgAQ6IPuGlRgJAFow+DYBIgAASPDwBAcAIAIY8ABDYQBDYQBDYS0gB/ghCC0ABDng8pxAIAIQ +IDD1RDYMIAFsMPWcIC0ABD9g+8wCCAkAajD8lgYoCQBaMPiWBCIAABlwbUkFAAqGAENhBg4GLlQG +0Q8AAGwQBCogBfUKCyAIEFgw9goBIBIQGDD6MzVwABAgMHOhcPMKCSoAYIagdaF1/wIACABFBqD/ +AgAGAG6ekMCJ+KMGf/UQEDDRD9JA0Q8AAADaIFiB9vosAAAAEFgwW/9aGYZTiyAjJAUqkmspkoCr +qgmqEaqZi5f8+sAgQAJS8AyqAfS1FCCAAlKwKrYJKrYIJJQFiiLzhgQQjQA2oCogBWP/mYsiZb+U +AioCW7aLZa/rwMr8JAUgChBQMI0iZd982iBbtmxlr9QvIAaOIvMkBSACAnvw/yQGLgkAM7CeIvP/ +WmAJEFAwiCJlj1DaIFu2nWWvqIkiKiAGwLz7JAUoCQA2cPkmAiACAlKwKiQG8/8rYAwQUDCMImXP +ISskBfP/G2IAAFLwLTJKDwIADwIAddNcKzJJZLBW2iD8IQkgABBoMP8K/yAAEHAwWIGI/CEjIAAQ +aDD+CgEiAABasP8KAiIAAFCwWIGBLyAGjiL1NkkgERBAMPgkBSACAnvw/yQGLgkAM7CeIvP+smAR +EFAw2iD7ChwiAABgsFgCE2P+/QAAAAAAAGwQBPIgcCIAACCw9CAJaAkAEPAoRHDRD/pMAAAAEFgw +W/8AKkBwDDkRCTkCCpkCKURw0Q9sEAaGJ/cgByjgASgwmBCGbvcHQQKUAjogGIcV/wIACgBsGhD/ +AgACAHyBIP8CAAAAkgUg+iwAAAIQWDBb/+PIosAg0Q8rPBDwCxYCAABRsABKYSwgBW7IYC0gcn7f +WtogW/9xZaB0LiAF+CICKJgBO6AvIHJ+/0EahZVlgF0MeREKmQgqkjr/AgAEAIVCoCuSOfkWASD/ +ADbg85wAAgAAYbD6LAAAAhBoMP4KACACEHgwW/8zwLQrNjmMEGjCNIon+0wAAAAQYDD6rCAiAABp +MFv6NNKg0Q8AAAAA+iwAAgAAWPD8TAACAABpcFv+89Kg0Q8AwCDRD9owWRh8+6wAA/+RwqBoonn/ +AgAF/4wWoP8CAAP/iEag2iBZGFzAINEPizL7i1cANxBgMP8CAA//fuLQ+iwAAAgQWDBb/6Rlrv8t +PBDyDRYCAABhsABMY2P/AAAA+iwAAAQQWDBb/5tlrt6PMy4hCQ8PQ/TuEQ+wBD/g/woQLgkAe7AP +7gKeYGP+0Igz/wIAAf9ObhDaIFkYUMAg0Q8rfBj6LAACAABgsFgBm2P/NQAAAAAAAGwQCBuGsZsQ ++CIAIAAQSDCZEvkWAyIAAFCw8xYEIAIQaDD0FgUgAhBgMPUWBimABDog9hYHKAkAYjD4FgEiAABY +cFv/hNEPAGwQBMAg0Q8AbBAGkxD9CgEggAJZ8PogOyIAAGFw9iIHIgAASbD8FgIvwBBAMPkWASpg +AVAw9WwgK8AEOqD6OggEAEBFcPAAJ2BQAlKwKCA7sYgoJDssYRX93AEuACAvMP6sECCAAnvw+uwA +CgB2e5D/ogEiAABKsPMJFgIAAGLwAEyK8QkWDgMAfTAADIqfsYihg6KOo/9EDAAgAlrw/4gMAgAA +YPD4pgEuACBz8P6mAyoAA3uQsTz8pgIh/8iNIByFDyshIi4hCS8hJIgQGYZtKiAHiIAjIQf0EgEq +AgFQMPmFABgAQEow8wNKCqAEOqD0BUMICQBSMPmFBhgJAEow+HYAJIAEPWD6IgAuCQAv8P92BCoJ +AGbw9HYGIsAEOOD7dgIuCQATsP52AyAIAhNw+xICK4AEOqD7dgUqCQBQsJpxAAmN+YZQEGACKfAA +BYoJ2QKZftEPDOoMY/8RAABsEAQrIAcchNwLCkEMqRGsmSiSOvRcAAQAVcIgLJI5H4Uo+y5AAAAQ +QDD0wJVuoAQ7oC0hBw0NSgzdEfsxECwJAHdw+oUeHwAEOqD/hNMcCQB/cJ3A/iIAKgkAdvCaxvjG +BSoJAFbwm8T/xgIgQAJbMPjGByAEEHgw+O4RADAQQDD4xgMuCQB7sP7GASAgAlDwAgqGAEtjAAqG +AEthBQ5H/5Y5IjoAO6CKJ/sKAyAAEGAw+qwgIAMQaDBb+WXSoNEP0Q+LIsi4BAxHaMIXwCDRDyus +GPwsAAIAAFCwWAD3Y//kAAAAjyeN0Cj5FC/xFY4g/IYOEAUQUDD4/wwAMBBYMFkXzcAg0Q9sEAQl +KQSHIfghBS/AEEgw/EoRCABATLD6dwwEACBVcPUlBCCAAlpw9yYBKgAEWdCod5ch96UIAgAgQnD0 +MBpggAIQsHUjGPI8AAIAABnw0w9tSQUAAoYAQ2HScNEPAAAHKQwJSBT6jAgiAAAx8PpKNgIAABDw +bakFAAKGAEZh+EwMAgAgGnDTD23JBQIChgBLY9Jw0Q8AAGwQBIsnHYR+9rIJL8AQUDD5uRQgQAJC +8P6F3hgAQFIw+IxAIaACMbD2tgkgYAJKcPm1FCoABkGQKbEVppYmtgmdYCwiAPsKAiAgAkmw/woC +IAMQaDD+ZgItgAQ7IPheEQwJAGsw/GYBLgkAe7BtugUABIYASWH+ZgUgbgA04Ik4F4Sp+/qWIAAQ +KDD4MgkgFgA2YJU7mYCJOJiRlTj1NgkiAABJcCRyifs0BSCEALZgjDx/z0eLMI43JTYMLHJ2Lewg +9eUULABAV3D8uwwAgAJrcC3mCf3mCCAAEGAw+kJZIAEQaDBb+ID6LAACAABZsPwKAyADEGgwW/9Z +0Q8rMhIuQmsLikT6qg8AABBgMP6qCgABEGgw+qIAK/ABXDBb+HIlNhLz/41vwBBQMAAAAAD6CgIg +MBBYMPyEcxIAAGjwWRdV8/9pb8AQUDAAbBAE9YThEqAQODAHJyildSVSf8FvA2YMdl0YGoTk/CkR +CIAEOOD6mQgICQBBMJiQ0Q8AAByEkRuE2/M6CgwAIGHwDKoLq6opoX/0mQwAABBYMAuZNSmlf9EP +AABsEAQbhMYDOQr0hMMSoBBgMAwsKP2EghAgAijw8FEEBAAgIzAnQn72Qn8gARBQMACoGvh3AQwA +IGsw/JkLBgkAObD2Rn8oACBecCWSf7FVJZZ/JEKAADEEAKMac0gOFIP0DCIRpCKCIAIyAdEPKJ0C +K4ECJYEBKIEFC1UBeFsDwCDRD9Kg0Q8AbBAEKiAiKSAjHoRvCpkM/woBIFYANmAsIAcMDEEOzAkr +weYJvTYNuwwrxeYqICKLKwqth/okIiBIADagKOJ/8IEEAf4CYrAAzBrw+BoKACBm8PwiCSH+AkIw +CLsCmyoMuQxzkybAINEPKiAFaKFuiyLAwgy7AvsmAi/0EBAw0Q+LKZsq8//XYgAAYvArIAcNrAz8 +JCIqIAFcMA65CSiR5g2ICCiV5iogImSgNSzify0iC/DBBAH+AkqwAJkaAPga+Iz/LAAgT3AI3QKd +Ktog/CwAAD4CWvBYAAXHJNEPxyTRD40pnSpj/+MAAABsEAT1CgEgERBAMPmFCxoAKx4QAzoJDqoR +qakrkX5ksHIehQaLJxiEICySPv+RfiAQAmrw/pF/KAAgcjCdwPy2AygAIEKwmLIA4QT7IgIgAgJ7 +8C+VfgBcGv2WPioJAGbwmyLRD8H1c/OoGIUDCDgKKIJ/3ED6PAACAABYsAuAAIkiADEEAFoaCpkC +mSLRDwAAAAAA+JF/IAAQWDAL5BYBAgAdhAAu0oIAgQTwXBoP/xB4MA/PAw/uAQ7MAizWggvkFmP/ +WwAAAGwQDIgizoYpIhMag4j9g3kYKAFMMPqbEQngBD5g+xYGKAAgVnCZF/ADB2AeEFAwwCDRDwAs +IBYpCv/4IAcmAEXPEJgZkxyVHhOEJfWD5RKgEEgwCYkdlB38xAoEACAucPVECwgAIB5w9ZJ+ICAC +GzDwMQQAARAYMAA4GviSfyQAQEVw9YQXGAkAKjD4ln8kACApMCVCfwDBBAA8GvMSDCACAilwJUZ/ +KZKAlBQkEg31Eg4oAqviUCgSCQyIEa2IiIDTDwjMAWTFWy60J5Ue9BYNIAAQSDAptCMptCH+hRQA +BRAgMCS0IPW0JiAAECAwJLQiBYUUJbQlBYUU9bQkIHACYrDxDBYAUAJC8AAIioU+JbQzBYUUJbQy +BYUUJbQxBYUUJbQwjD30tDogABAoMCW0OSy0Nym0O/yMFAAAEEgwKbQ4LLQ2DIwULLQ1DIwULLQ0 +LCIXKbRMKbRAJbRNJbRBJLROLLQ/JLRCDIwULLQ+DIwULLQ9DIwU/LQ8IAAQYDAstE8stEMoMhUp +jAEpNhUotEcIiBQotEYIiBQotEUIiRQptEQkMhMlMhQEVQgltEsFhRQltEoFhRQltEkFhRQltEgp +MhKFHtMPBJkM9BINICAIS7AosCEpCoAJiAIotCEsohnAkA8CAPTCWWDQAkKwKTYW+TYXLAMAY7As +thXzCBYAsAIq8ABFiikyEw8CAA8CAKyZKTYTKKIZDOUMDIgM+KYZIqcANiAnohslohqnx/emGyoA +A+HQJVwB9aYaIAAQUDAoIQcZgvAICEoMiBH8g8QYCQBKMJiwCqgJiSD8tgIgQBAoMJWzHIMV9YN5 +GeAEOiAojG8ISBT19QoMCQBicPy2BCmABD5g/CEaKAkATjCZsSVSmZy2+YNFEGACY7CctYwWCVUB ++oPWEAICSrD1g9McCQArMAqZAvm2FCwJACswnLeMGioiFokprKr6rDAoACBmcPomFiBgAkpwmSkZ +g4QoRjkqIBb8KqAg/xAoMPsgByAfEHAw+u4MAE4EKrAMvB2pySmSf/8CAAYBlPJQ+K4QD8AEPuD+ +bgIOACBv8C72AygyEy8yEvoKHiYBQ0fQLyAHDw9BDPQRrUQpQjr/AgAKAVrWUCtCOfSyqmDAAlLw +iTclIhgnMhcomRQuMhKMKfoWCCJFADYgipmIKgd3CYYXKTITCncLJmKA+e4MAOACOfD8iAwOAwAr +sPkgIyYAIHGw9hYKIGACMbD17AAL/kmyECggIgiZDBiDGmSStJQdCPgJJIHm8xYMIgMATTADRAwk +heYpICKTE4QdCZOHKSQi8xIMIqoANmCTHBODDSMyfwAxBIMrsJgAiBr4CgEiACBE8ACIGrCI+RYA +IgkARPCTFZMqgxyIFQyIDP8CAAv+ETIQjROJECsgBw2cDCwkIhyC/AsLQQy8CSrB5q2qKsXmKSAi ++RYAIlEAtmCNKZ0qYAJtLDIWB8wKjMD0wHpgsAJC8AzsNiy2FSkyFgeZC7iZBAmIAIiKJTITKjIW +96oKBAAgZXAlNhOJoAyZDJmgKTIWB5gKiIAM5Qz5FgsgIwA2IAeVC4dTilKnx/dWAyoAA2HQsaqa +UvP9lmAAEFAwAABkkTkoMhfAkPk2FiACAkIw+DYXIDACOfD6CgAhDAA1YCkyFgecCozAiRjyFg8o +AAFQMPmCCgwDAGFwnCAiMhaYEgciC/mJCwAQAhCw/wIWABACSnAByYooMhMiMhb3IgoIACBiMCg2 +E4kgDJkMmSApMhYHmAqIgAxVDPISDyACAlKw+RYLICIANiAHlQuIU4dSqMj4FgEqAANiELF3l1KI +EZhTY/zpAADyFg8gOQA2YCwyF/gKACAwAjnw+DYWIAICYzD8NhcgABBIMIwYiBIizBjyEg8sBQBA +sPwWCC9FALVgY/yqwJEpNhbz/91gARBIMAAAAAAAAPP9vWAAEFAwiTjKmow5wLCbO5nAjTic0Zs4 ++zYJL5kQUDD6NAUgABAQMNEPAAAAAPP8ZGAAEFAwLvqZ/jQFIAAQEDDRD8CBKDYWY/7S2iD8LAAA +MAJb8Fv+TcAg0Q+IFNMPKI0CLIECKYEBKIEFDJkB/AoBK/1SwlDaIPwsAAAkAlvwW/5CwCDRDx6C +avqrCg4AIHMwDrsLHoKy/hIKKgAgdvApsX8OmQz5nNAgABBwMA6ZNSm1f2P8vS8gBf8CAAH84Qfg +iCLAkgmIAvgmAiAAEBAw0Q+cKpwVmRBj/X0AHoJiLuJ/iivw4QQB/gJqcPDdGgABEGAwAMwa/Mz/ +KgAgarAMqgKaKtog+7wfIgAAYLBb/h7AINEPAAAAbBAEyDDRD4gn9okUL8AQODDzggkgQAIqMAdV +AfVcQCAgAjGw9oUUIeACGPDzhgkqABSo0CqBFfuBxxoAIBqwmomboIkg+JkRAAEQWDD0pgIoCQBe +cJmh0Q8cgb6cMIsg+LsRAAEQYDD0NgIqCQBm8Jsx0Q9sEARkIGJkMF9kUFyIIvmBqhA+AlDw+koU +AE8AtiAECEcMiBGpiCmCOnqTQCyCORmByfjMAAA3ADcgAAmLbakCAEhhHoGinsCNIJpQG4Gj88YD +LYAEP2D7xgIsCQBusP3GASAgAhMw0Q/AINEP2iD7TBgiAABgsFv94cAg0Q8AACAC0HUgAtCLIALS +GCAC0qcgAtMnIALToiAC1JggAtVUARAYAQABAAAAAAAAAAAAACADZuIgA2biIANk7iADZuIgA2Tu +IANmvSADZpYgA2TuIANlySADZO4gA2TuIANlwCADZO4gA2biIANk7iADZO4gA2biIANk+wAAAAAA +AAAAAwEAAgAAAAAAAAAAAAAAACAD5fIgA+YgIAPnpCAD5fIgA+ecIAPnhSAD5fIgA+XyIAPl8iAD +5fIgA+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIgA+d6IAPnbyAD5fIgA+XyIAPl8iAD5fIgA+XyIAPl +8iAD5fIgA+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIgA+XyIAPnRCAD5fIgA+c8IAPnPCAD5fIgA+Xy +IAPnHyAD5fIgA+c8IAPl8iAD5fIgA+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIg +A+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIgA+XyIAPl8iAD5fIgA+cCAAAAAAAA +AAAAAAAAIAQD2CAEA9ggBAMkIAQD2CAD/uggBAPQIAQDriAD/uggA/7oIAP+6CAD/uggA/7oIAQD +ByAEA9ggA/7oIAQDByAEA9gAAAAAAAAAAAAAAAAgBBCRIAQQ5yAEEzwgBBLqIAQSniAEEnIgBBJi +IAQSXCAEEbgAAAAAAAAAAAAAAAABEBgBAAIAAAEQGAEAAgAAIARhziAEYaMgBGALIARhayAEYWsg +BGFrIARgCyAEYWsgBGALIARhTCAEYAsgBGALIARhTCAEYWsAAAAAAAAAACAEhbggBIFxIASFjCAE +hWAgBIU0IASBkyAEgZMgBIGqIASFGyAEgd8gBIHLIASBkyAEgd8gBIGTIASBkyAEgZMgBIW4AAAA +AAAAAAAAAAAAAAAAACAEzaAgBMgAIATHqCAExcgAAAAAAAAAAAAAAAAgBMfoIATH4iAEx+IgBMfi +IATH6CAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+Ig +BMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAE +x+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH +4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfo +IATH4iAEx+IgBMfiIATH6CAEx+IgBMfiIATH4iAEx+ggBMfiIATH4iAEx+IgBMfoIATH4iAEx+Ig +BMfiIATH6CAEx+IgBMfiIATH4iAEx+ggBMfiIATH4iAEx+IgBMfoIATH4iAEx+IgBMfiIATH6CAE +x+IgBMfiIATH4iAEx+ggBMfiIATH4iAEx+IgBMfoIATH4iAEx+IgBMfiIATH6CAEx+IgBMfiIATH +4iAEx+ggBMfiIATH4iAEx+IgBMfoIATH4iAEx+IgBMfiIATH6CAEx+IgBMfiIATH4iAEx+ggBMfi +IATH4iAEx+IgBMfoIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+Ig +BMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+ggBMfiIATH4iAEx+IgBMfiIATH4iAE +x+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+ggBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH +4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfiIATH4iAEx+IgBMfi +IATH4iAEx+ggBMfiIATH4iAEx+IgBMfoIATH4iAEx+IgBMfiIATH6AAAAAAAAAAAAAAAACAEyDgg +BMmNIATLOyAEyy0gBMsYIATLCiAEyvUgBMrnIATK0iAEysUgBMqyIATKpSAEypIgBMqFIATKciAE +yDAgBMpfIATKUiAEyj8gBMoyIATKHiAEyhQgBMoDIATJ+SAEyeggBMgwIATIMCAEyDAgBMgwIATI +MCAEyDAgBMnbIATIUSAEyDAgBMgwIATIMCAEyb4gBMmlIATJmyAEyXwgBMgwIATJaSAEyU8gBMk8 +IATJIiAEyQ8gBMj3IATI5CAEyNEgBMhrAAAAAAAAAAAgBM3gIATN6iAEzzogBM8PIATPCCAEzwEg +BM76IATO8yAEzuwgBM7lIATO3iAEztQgBM7KIATOrCAEzkIgBM3VIATOOSAEziMgBM4ZIATOEiAE +zgUgBM3+IATN0iAEzfcgBQJqIAUCYCAFAmYgBQJqIAUCYCAFAmAgBQJgIAUCZiAFAmogBQJqIAUC +aiAFAmAgBQJqIAUCYCAFAmQgBQJqAAAAAAAAAAAAAAAAAAAAACAFKsIgBSrYIAUsZiAFLPYgBS11 +IAUt6SAFLs4gBS+LIAVPeCAFTNwgBUtwIAVJVCAFR2AgBUCwIAVBYCAFRjAgBUAoAAAAAAMPCBKD +jpOSIAV+PSAFfpwgBX6PIAV+giAFfnEgBX5kIAV+VyAFfkogBX7JIAV/NCAFfycgBX8aIAV/DSAF +fvwgBX7rIAV+2iAFf2EgBX/IIAV/tyAFf6YgBX+VIAV/iCAFf3sgBX9uIAV/+SAFgFwgBYBPIAWA +QiAFgDUgBYAkIAWAEyAFgAYgBYCJIAWA7CAFgN8gBYDSIAWAxSAFgLggBYCnIAWAliAFj1AgBY/K +IAWPvCAFj64gBY+aIAWPhiAFj3IgBY9eIAWP2CAFkG4gBZBaIAWQRiAFkDIgBZAeIAWQBSAFj+wg +BZCCIAWRLCAFkRMgBZD6IAWQ4SAFkMggBZC0IAWQmyAFkUUgBZHvIAWR1iAFkb0gBZGkIAWRiyAF +kXIgBZFeIAWSCCAFkrIgBZKZIAWSgCAFkmcgBZJOIAWSNSAFkhwgBZLLIAWTeiAFk2EgBZNIIAWT +LyAFkxYgBZL9IAWS5CAFk4ggBZQnIAWUGSAFlAUgBZPsIAWT0yAFk7ogBZOhIAWUQCAFlOogBZTR +IAWUuCAFlKQgBZSLIAWUciAFlFkgBZUDIAWVrSAFlZQgBZV7IAWVYiAFlU4gBZU1IAWVHCAFlcYg +BZZwIAWWVyAFlj4gBZYlIAWWDCAFlfggBZXfIAWWiSAFlzMgBZcaIAWXASAFluggBZbPIAWWtiAF +lqIgBZdMIAWX5iAFl9IgBZe+IAWXpSAFl4wgBZdzIAWXWiAFl/ogBZieIAWYhSAFmGwgBZheIAWY +RSAFmCwgBZgTIAWGDyAFjwsgBZkvIAWZFiAFmP0gBZjpIAWY0CAFmLcgBaFIIAWh9yAFod4gBaHF +IAWhrCAFoZMgBaF6IAWhYSAFogsgBaK6IAWioSAFooggBaJvIAWiViAFoj0gBaIkIAWi0yAFo4Ig +BaNpIAWjUCAFozcgBaMeIAWjBSAFouwgBaObIAWkRSAFpCwgBaQTIAWj+iAFo+EgBaPIIAWjryAF +pF4gBaUNIAWk9CAFpNsgBaTCIAWkqSAFpJAgBaR3IAWlJiAFpcogBaW8IAWloyAFpYogBaVxIAWl +WCAFpT8gBaXjIAWmkiAFpnkgBaZgIAWmRyAFpi4gBaYVIAWl/CAFpqsgBadKIAWnMSAFpyMgBacP +IAWm9iAFpt0gBabEIAWnYyAFqAcgBafuIAWn1SAFp7wgBaejIAWniiAFp3wgBYo3IAWKUCAFqJ0g +BaiEIAWoayAFqFIgBag5IAWoICAFmUggBZn3IAWZ3iAFmcUgBZmsIAWZkyAFmXogBZlhIAWKryAF +itAgBZqIIAWabyAFmlYgBZo9IAWaJCAFmgsgBZqcIAWbQSAFmyggBZsUIAWbACAFmucgBZrOIAWa +tSAFm1ogBZv6IAWb5iAFm80gBZu0IAWbmyAFm4IgBZtuIAWcDiAFnLggBZyfIAWchiAFnG0gBZxU +IAWcQCAFnCcgBZzRIAWdeyAFnWIgBZ1JIAWdMCAFnRwgBZ0DIAWc6iAFnZQgBZ4zIAWeGiAFngYg +BZ34IAWd3yAFncYgBZ2tIAWeTCAFnvYgBZ7iIAWeySAFnrAgBZ6XIAWefiAFnmUgBZ8PIAWfviAF +n6UgBZ+MIAWfcyAFn1ogBZ9BIAWfKCAFn9IgBaB8IAWgYyAFoEogBaAxIAWgGCAFn/8gBZ/mIAWg +lSAFoS8gBaEWIAWg/SAFoOQgBaDQIAWgvCAFoK5SVgAAAAAAAEHNzWUAAAAAQS6EgAAAAAAQAAAA +Y29uZmlndXJhdGlvbiBmaWxlIHBhcnNlciBmb3VuZCBhZGRpdGlvbmFsIGNvbmZpZ3VyYXRpb24g +YWZ0ZXIgW2ZpbmldCgAAMAAAAGZjb2UAAAAAdm5pY19pZAB2bGFuAAAAAHRvcwBldGhlcnR5cGUA +AABtYWNtYXRjaAAAAABtcHNoaXR0eXBlAABmcmFnbWVudGF0aW9uAAAAc3J2cnNyYW0AAAAAZmNv +ZW1hc2sAAAAAY29tcGFjdABiYXNpY3ZpcnR1YWwAAAAAc3lubWFwZW4AAAAAc3luNHR1cGVuaXB2 +NgAAAHN5bjJ0dXBlbmlwdjYAAABzeW40dHVwZW5pcHY0AAAAc3luMnR1cGVuaXB2NAAAAG9mZG1h +cGVuAAAAAHRubG1hcGVuAAAAAHRubGFsbGxrcAAAAGhhc2h0b2VwbGl0egAAAAB0cF9waW8AAHRw +X3RtX3BpbwAAAG5pY192bQAAbmljX3VtAABuaWNfdW1faXNnbABvZmxkAAAAAHJkZHAAAAAAcmRt +YWMAAABpc2NzaV9pbml0aWF0b3JfcGR1AGlzY3NpX3RhcmdldF9wZHUAAAAAaXNjc2lfaW5pdGlh +dG9yX2ZvZmxkAAAAaXNjc2lfdGFyZ2V0X2ZvZmxkAABmY29lX2luaXRpYXRvcgAAZmNvZV90YXJn +ZXQAcG9mY29lX2luaXRpYXRvcgAAAABwb2Zjb2VfdGFyZ2V0AAAAcHBwAGRjYngAAAAAIAKXNAAE +AAAAAAQAAAQAACAFx+wgBXooIAXH2CAFejggBXpMIAV5kCAFetAgBXlsAAECAwAAAAAAAAAAAAAA +ACADNbQgAzVAIAQKEAAAAAAgAzU4IAM1MCADNSgAAAAAMDEyMzQ1Njc4OWFiY2RlZkFCQ0RFRgAA +AAAAAAAAAABBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3 +eHl6MDEyMzQ1Njc4OSsvAAAAAAAAAAAAAAAAAAAAACAAH+AAAQAAIAAfwAAFAAEgAB+kAAMABSAA +H4QABwAAY4JTYwAAAAD///////8AAAAEBAgAB0MAAAAAAAAAAAAAIQAJAIEAQQAhAAkAIQAJAIEA +QQCBAEEAgQBBAIEAQQAhAAkAgQBBACEACQAhABEAgQBBAIEAQQAhAAkAgQBBACEACQAhAAkBAQBB +AIEAIQCBACEAEBBhAQEAgQEBAIEDAgEAIECAAAAAAAAAAAAAIAKNBAAAAAAgApG0AAAAACACjQgA +AAABIAKRwAAAAAIgAo0QAAAABCACjRgAAAAIIAKNIAAAABAgApHIAAAAICACjSQAAABAIAKNMAAA +AIAgAo08AAABACACjUgAAAIAIAKNWAAAIAAgAo1kAABAACACjXAAAIAAAAAAAAAAAAAAAAIEAAAA +RAAAAAQAAABAIAVTsCAFU2wgBVJEIAVQ+CAFULQgBVCIIAVQ4AAAAAAAAAIAAAAEAAAACABOQQAA +VjAAAFYxAABWMgAAVjMAAFY0AABWNQAAVjYAAFY3AABWOAAAVjkAAFZBAABWQgAAVkMAAFZEAABW +RQAAVkYAAFZHAABWSAAAVkkAAFZKAABWSwAAVkwAAFZNAABWTgAAVk8AAFZQAABWUQAAVlIAAFZT +AABWVAAAVlUAAGFsbAAqAAAAbm9uZQAAAAAweAAAcG9ydAAAAABwcm90b2NvbAAAAABnbG9iYWwA +AGZ1bmN0aW9uAAAAAGZpbmkAAAAAcmVnAGZpbHRlck1vZGUAAGZpbHRlck1hc2sAAHJzc19nbGJf +Y29uZmlnX21vZGUAcnNzX2dsYl9jb25maWdfb3B0aW9ucwAAc2dlX3RpbWVyX3ZhbHVlAHRwX3Bt +cngAdHBfcG1yeF9wYWdlc2l6ZQAAAAB0cF9ucnhjaAAAAAB0cF9wbXR4AHRwX3BtdHhfcGFnZXNp +emUAAAAAdHBfbnR4Y2gAAAAAbXR1cwAAAABwY2llX21hX3JzcF90aW1lcnZhbHVlAABwbF90aW1l +b3V0X3ZhbHVlAAAAAGJhcjJ0aHJvdHRsZWNvdW50AAAAY3BsdHhkYXRhX21lbWFsaWduAABudmYA +d3hfY2FwcwByX2NhcHMAAG5pcWZsaW50AAAAAG5lcQBuZXRoY3RybAAAAABudmkAcnNzbnZpAABu +ZXhhY3RmAGNtYXNrAAAAcG1hc2sAAABuZXRob2ZsZAAAAABucm91dGUAAG5jbGlwAAAAbmZpbHRl +cgBuc2VydmVyAG5oYXNoAAAAdHBfbDJ0AAB0cF9kZHAAAHRwX2RkcF9pc2NzaQAAAAB0cF9zdGFn +AHRwX3BibAAAdHBfcnEAAABpc2NzaV9udGFzawBpc2NzaV9uc2VzcwBpc2NzaV9uY29ubl9wZXJf +c2Vzc2lvbgBpc2NzaV9uaW5pdGlhdG9yX2luc3RhbmNlAAAAaXNjc2lfbWF4X3NnZQAAAHBwbV9t +YXhfem9uZXMAAABwcG1fem9uZV9yYW5nZTAAcHBtX3pvbmVfcmFuZ2UxAHBwbV96b25lX3Jhbmdl +MgBwcG1fem9uZV9yYW5nZTMAZmNvZV9uZmNmAAAAZmNvZV9udm5wAAAAZmNvZV9uc3NuAAAAZGNi +AGJnX21lbQAAbHBia19tZW0AAAAAaHdtAGx3bQBkd20AdmVyc2lvbgBjaGVja3N1bQAAAAAwMTIz +NDU2Nzg5YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoAAAAAWWVzAFNlc3Npb25UeXBlAE9GTWFy +a2VyAAAAAElGTWFya2VyAAAAAERhdGFEaWdlc3QAAEhlYWRlckRpZ2VzdAAAAABFcnJvclJlY292 +ZXJ5TGV2ZWwAAEltbWVkaWF0ZURhdGEAAABEYXRhUERVSW5PcmRlcgAARGF0YVNlcXVlbmNlSW5P +cmRlcgBJbml0aWFsUjJUAABNYXhDb25uZWN0aW9ucwAATWF4UmVjdkRhdGFTZWdtZW50TGVuZ3Ro +AAAAAEluaXRpYXRvck5hbWUAAABJbml0aWF0b3JBbGlhcwAARGVmYXVsdFRpbWUyV2FpdAAAAABE +ZWZhdWx0VGltZTJSZXRhaW4AAE1heEJ1cnN0TGVuZ3RoAABGaXJzdEJ1cnN0TGVuZ3RoAAAAAE1h +eE91dHN0YW5kaW5nUjJUAAAAVGFyZ2V0TmFtZQAAVGFyZ2V0QWxpYXMAVGFyZ2V0QWRkcmVzcwAA +AFRhcmdldFBvcnRhbEdyb3VwVGFnAAAAAEF1dGhNZXRob2QAAFNlbmRUYXJnZXRzPUFsbABDSEFQ +X0EAAENIQVBfSQAAQ0hBUF9DAABDSEFQX04AAENIQVBfUgAARGlzY292ZXJ5AAAATm9ybWFsAABO +b25lAAAAAENSQzMyQwAAQ1JDMzJDLE5vbmUATm9uZSxDUkMzMkMAQ0hBUAAAAABDSEFQLE5vbmUA +AABOb25lLENIQVAAAABOb3RVbmRlcnN0b29kAAAASXJyZWxldmFudAAAUmVqZWN0AABObwAANQAA +AENITmV0IDEuMDAAAAAAAAwAAAAAAQABfAAMAQAAAAAQAAAAFCAF23AAAAL9DkAAAB/8AAAf/AAA +H/+rkB//q5AgBeQAIAXncCAHf9AgB3/QIAfAACAIEEAgCEAAIAjAAAAAAAAgCQyAIAkM4AgAAAAf +/OLkIAKm0B//mbAf/5vwAQAAACgAAAAgCMAA4QAAAAAgAAAf/4SwH/+FoB//gyAgCMBQIAjAkCAI +wNAgAo8gIAKMoCACj3AgAo7wIAkPMCACjtAgCQ9gIAkPgAAAgAAAD0JAIAAgAAACAADgAAAAIAjD +ECAIwuAACAAAIAjDcCAIw0AgAt58IAkOEB//j7Af/5mkAP///yAIw7AgCQ+wIAjD4CAIxCAgCMSA +IAjFICAIxFAgCQ1QIAkNsCAC9IwgCQ7QIAL5UCAIxNAgCMXwIAXiAAAP/AAf/5UUAAAwACAIxiAg +CMawIAjHUFUAAAAgCRBADgAAABAAAAAgAo/oAAAIBgAACAAgCMeAH/+Y8AAAD/4gCMhAAAD//yAJ +EGAgCMfgIALLTCACwkAgCMigIAjJECAIyWAgCREwIALWGCAC2YwgCRDwQAAAACAIyaAgCMoQIAjK +cCAIyuAgBecwIAjLYCAF5EAgCMuQ7////yAIy/AgBeZAIAKAACAJE7AgCRGAAABQACAF5vAUsAAA +AAAQAIAAAAQgAs+QIAXm+iAJEcAgCRIgFaAAAAAAj/4gCRJwFqAAACMoFQAgoAAAP/AAACOgAAAD +/wAfIAXgIB//mZAf/5CcIAkS0BeQAACAAAAAIAkTEBSQAABAAAAEIAkTgCAIzKAgCM7gIAjOMCAI +zpAgCM0AIAjNcCAIzdAgAtv8IAkUIAAAQAAgAo/gH/ziAAQAAAgMAAAAgQAAAB//hRAf/4YQIAKU +vB//hPAgCM9AIAjPgD/////P////IAjPwB//hcwgCNAAIAjQQCAJFEAgCNDA///QTf//LlwAANGk +AACcTn///6sgCNFAIAjRACAI0IAf/4UMIAjRgAAASAAgCNJAIAjSEB//hQgf/4VwIAjScCAI00Ag +CNQAIAjT0B//mZT//f//AJiWgCADC7AgCNQwIAjUgCAJFGAD/9AAAEAAAABQDAAAAA//AAEAACAJ +FOAf/5nMIAkVECADBFQgCNSg//9AAB//mPwgCNTgAAAf/iAI1SAgCRYgwAAAACAJFmAAACAAIAjV +UCAJEBAgCQ/gIAjWUB//maAgAwz8IAL96AAAwAAgAwFYIAkVcCAJFbAgCNkQAgAAACAI2aAAABdw +IAkXMCAJFxAAACcQIAMZ2CAJF2AgCReAH/+ZmCAI2dAgCNnw4QBeACAI2hAf/5jUIAjaQB//mADh +AH4AH/+ZMAAA8/8EAAAAH/+cABQAAAAqAAAAIAMhVP/3//8gCRegH/+ZBCAJGGAgCRkwH/+mwBoA +AAAgCNrwIAkZsB//mhAf/6foMAAAECAJGfAgCRpQH/+RYCAJGoAgCRsA4QL+AB//lNCIiIiIH/+p +ZCAI20AAAAy8AACJBiAI23DgAAYAAJwAAOAACSQgCNuQIAjb4AADBMDg//4A4QCOAAAAloAAAJZA +IAXkEAAAlqAAAJZg4QMALAADAAAf/N4A4QB6AAAB4ADhAZIAAAHjAB//mbQgCNwAIAjcMAAAGlAf +/6gEAA///x//p7Qf/5EEIAXmsAAAYAAgBea6AAAaOgAAg/8gAoAgCFABAADAAAQf/6loIAWzsCAD +TtggBbN03q2+/xrAAAAgBeW4AAD/6iAF5sAAAAgUAACIAB//mZwAEAAAH/+YKAAehIAgA2SoOAAA +ADAAAHQgAoAwIAjcYDAAAAgwAAAMNAAACNAAAAAAAIkUOwAACDSQAAAAMAAA/wf//wVdSoAgA2pU +ABgAAAA4AAAgCRuwBgAAACADdxz4AAAAAf//5wABwAAgAACABAAQAB//mBDhAZoA4QGaQOEBmjzh +AZo44QGaNOEBmjCAAAADgAAAAgAAht3//P//4QEOAAAAFuAf/5moH/+RCB//kYggA4S4IAkhICAJ +HtAgCR8QIAkgwCAJIPAgCR9AIAkfgCAJH7AgCR/wIAkgICAJIGAgCR6g//8AAA////D/8AAAIAkh +oB//qBAf/5YwIAkhYCADk7AgCSKgIAki0CAJIkAgCSHgAAAu4B//lTgf/5ZgAAD/gCAI3dD/+/// +AAQAAOEB4sCQAADw/P+A7yAI3iAgCN5gAAD4AAADAQwAAwEIj////wAA8AAgCN6wIAjfACAI3zAg +CN9w4QDeAAADAwgAAwIA///wAOEA7gAf/5m8//9//wAA4AAAAPwAAAAMAAADAwR/////AAERHAAB +ERgAEAgAgAAIAAADAQQf/5msH/+YQP//wAAAAP/+AAAlgAADAwAf/5kc4P/iwCAJIyAgCSNQIAkj +cCAJIwDhAY4AAAGRDCAJJCAAAP/zIAkkkP//8/8gCSRwIAkksCAJJNAAABIAIAklECAJJEAAACow +IAkk8AAA//gAAP+PAABStQAASAoAAI+CAACPhgAAOAAAAI+KAADjPwAAg64AAP/xIAjfwP//z78A +ABBA4QMGAAAA//sgAoCA4QMKACAI3/AgCOAwIAKAkCAI4NAgCOCgIAklMAAA+f8AAP8/AAD+/wCA +AAAAAP/AIAklgCAI4GAgCSYwIAkl4CAI4YAgCOFAIAjhECAI4aAf/6oAIAjh8AAAGkgAAN6tH/+n +rCACgaAEAQAIAACDACAI5DAQAAUN7gAAAAHAgAAJAAAAAACCACAI41AgCOOgIAjj4BAABwIAAPz/ +IAjkkBsAAAAABQACIAjkwCAI5OAgAoHwIAjlACADM7AgAy/cIAMycCAJJ6AA/8AAEgAAACAEHmgg +CShQIAkoECAI5SAgCOWAIAkokCAI5qAgAo9gIAjmwCAI5dAgCOYwAP///AAAEDb//+//IAKCIB// +p/ggA3PEAAAIUCACgigyAAAAAAAIQCAJKXAgCSmwIAkp8AD///oAAIAFAACABzOQAADerb7vgYAA +AAAAg/0wAAAcMAAABDAAABQAAP/v//7//x//qKQgAoIwAP/wAAAoAAAgCOcAMAAAADAAADQAAIAB +IAKCcAAAgAIQAAUQmQAAADQAAAAgCSoQIAjnQAAZAAAgCOeQH/+YpCACj/QAABshAACAwv//9/8D +FQAABQAAAIP/ABsgCOgAIAjoUAABkazhAZGsv////9////8gCOiwCwAAACAErnggCOkgIAjpkCAI +6gAgCOowIAkrQCAJK+Af/5pwIAPQxOEADgDhABIAH/+XhAABOIAAAicQIAksgH///w8f/5rY4QAu +APwA///hAJYA4QCaAAAACf/hAJ4AAACwAB//mgggAoLAAwAAAOEAEgThABII4QASDOEAEhDhABIU +EwAAABEAAAAf/AAAH/+ZZCAI6rAgCS2wAAGUjwABlM///+/4IAKC4B//mIQgAoXQIAjq8CAI6yAf +/5icIAKGoB//l3gf/5acH/+YaOEBngD/v///AAGfNCAI7BAgCOxQIAjtsB//l2gAP///AAD/9wAA +/9UAAP/9AADql8IAAA4F3AEAA/8AAMAAAAEgCO4QIAjuUCAI7qAgCO7gIAjvMCAI73Af/6WwAA8D +/wMRAAAf/5rE/f//0B//j9gf/5WwH/+RTAAC//8AAJxAIAkbUCAI8pAgCPMAAAD+ACAE31wgCPPA +AAAhACAE50ggBeCoIAXguCAF4MggBeDYIAXg6CAF4PggBeEIH/+ZIB//kWQgCPPwAAMAAiAI9HAg +CPQg9////wEwGGAAAYagACYloAJiWgAF9eEAAAAgBOEDLgD//984IAj14CAI9mAgCPSQIAj2MCAI +9NAgCPWwIAkzcCAJM/AgCTOwIAT9YCAChwDhAwAEIAKHQOEDADDhAwIA4QQCAAAEBe7hAwEE4QHi +AB//mUwf/5h0H/+aFAAFAAQf/5FwH/+YfB//mVAAF///AAQUAB//mFQf/5f0H/+Z7CAGgAAAABQA +IAausCAG7wAgBoZgIAaFUCAGhEAgBoMwIAaCICAGgRAf/5iwH/+Y9B////Af/6awH/+p4CACjqAf +/6f8H/+quB//qfhJAAAAIAkzMCAJMoAgCTLgLgA2AB//mHAf/5dsH/+ZOB//mUjhAHYAIAk1kB// +mRQgCPnQH/+ZuCACh1AgCTYAIAk2gCAF5jgf/6eo/+gP/wAQgAAgCPtAIAU+MCAAAAAgAodw4QBa +AAHIQAbhAZngIAXkMCAI+2AAAZD4//z4fyAF5DggCPugIAj8ECAJI/AAAH5QAAB+QAAAfhggBUzc +H/+Y7CACkawgApGwIAKRtCACkbwAUCAG4QGaDABwIAb/4AAAAAIgBiAI/SDhAZoE4QGaCAAEIAYg +CP1QIAk3oOEDMgD//8j////x////388gAoeYIAj9sCAI/YAgCP4QIAj94P//v/8gCP6AIAk3ACAJ +N3Af/5pIAAST4P/7bCD/4XuAIAj+sCAI/uD7///OBAAAAf4+AA8AACAM///fMAADMADhAw4AABgA +AwAAuZMAAD/g4QMSAPP/5//hA0YAIAk0MCAI/xAAAwg0H/+UsOAAAQDf//4AIAXksOEB4kAABAAE +AAQACCAI/0AABACAAAP/ACAI/3Dh//4AIAKHoCACh8AgAofgIAKIACACiCAf/5EAAAAxgAAALUDA +AAAGIAKIQCACiGAgAoiAIAKIoCACiMAgAojgIAKJACACiSAgAolAIAKJYCACiYAgAomgIAKJwCAC +ieAAH///IAKKACACiiAgAopAIAKKYCACioAgAoqgIAKKwCACiuAgAosAIAKLICACi0AgAotgIAKL +gCACi6AgAovAIAKL4CACjAAgAowgIAKMQCACjGAgAoyARIAAUAAAH/8gBai4H/+RgCAJBsAAADGE +AAAtRB//mjRAAABEH/+RdCAJORD/7///4QBW4CAJBvAf/5koH/+QmB//kTAAADFEAAA1hCAJBzDh +AFYAHQAAAB//mgwgBeIkIAKPBCAJOgAgCTqwIAk5MCAJOXAgCTswIAk6UCAJObAf/5loIAkIsCAF +rOAf/5uQH/+rRB//q1wf/6t0H/+dUB//q0gf/6tgH/+reB//miQf/5wgH/+ZJO3/////5b//ABhA +AP/AAAAAExwc//wAAAABqhkAAwkEIAkI4OEDCAgf/5Z4H/+WdOAACgDgAA2EIAkJACAHwAAf/5CA +AAALaB//l6AgCQpQv//w/yAJPZAf/5HA/w///yAJCvAgCQqAIAkLYCAF5DwgCQwQCgAAACAF14x/ +8AAAAAAAAGwQCCQiGRz8MCMgB/1ABCAFEFAw/kIAIDAQWDD/QAUiIAEcMFjL2ilABSgKcnmDA8Ag +0Q8c/Cb/QgggBRBQMP1ABCABEFgw/kIAJOABKDD/8gAh/AIpMPMWACQFAC7w9RYBIDAQWDBYy8r6 +LAAACBBYMP0cECIAAGDwW7bn/fwUEEIANqCMIMDg/qYBLAkAazCcoBv8EAw5EfgSBCgAIF5w+JYA +IxYAOSCKJ/sKASAAEGAw+qwgIAEQaDBbrTvAINEPANog/PwEEgAAWXBbtrXAINEPbBBIGvwBKaKA +KKJ4K632K7DRIxaF9RaAKZAEOiD/tw94ACBKMC4KgK6OLhaGYAAHLyqAr48vFoaIJ4iOIqJxK4KF +qyIJIhHykggAAJylIBX77/aNAiCAAnhwLxaEJhaD9RaBIEACGHAjFoIV++nz++kRwBA4MPAAX2AA +EDAwAAAAAAAA+RKEIBwQUDDTD22qBQAIhgBJYfjqQCYAIDmw9xYJJAAgQTCOJ40i/PvbEAUQUDD+ +6RQgMBBYMFjLgPosAAIAAFhw/AogIAIQaDBbqP//AgAAAFelIIonKqwgW6iLKxKB2BD9EoYgIBB4 +MPALBwAgEEgwbZoCAEhhjiDzFgAg4RBAMPUWAi+ABDug+BQYLgkAe7CeES7QBy3RLg4OQQDuEf77 +vhwJAHdwKxKC+BKDLAkAd3CdFAzqMCwWBScVDwIIhgBLYwAIhigShQBLYfhoCA3/l6HQKRKAG/ux ++hIIIAkANmALqgKaGCoShPxMAAIAAFowWMPolBnz/ydgABAgMMAg0Q9sEASKNwVCCPqiDiAAEFgw +KyQAJUAA+QosIDoQYDDzvAAGAJLlUGRRNW0IELEzpDUnUAD8cQpyAABBcMhyY//oACdQAStUAPlx +JnAAEBgwyX71jAAAABAYMG0IESdQArEz+XEMcAICKXDIdG81AmP/56g8+8QBIFEANOD5CmAgABA4 +MPWMAAB6EGAw+wo5IC8QQDDTD206LCNQAXOLCnOzB/AAFWGgAhjwc5sKc8MH8AAHYVICGPAjPMkH +dwrzdwkAAgIpcGAAAcBw/QoAIAAQYDDwAB5gLhBYMAAAAAAALpAAsZgOiTn0nAAMCQBhcLHdaNQ4 +I0AA9D/0bYAEOyD7MTpwABBAMMBQbQgd9VUKAAICQjDzVQkIACAmMCOQAPQ/vGGgAilwezG0Y//b +LKaSJq0C92UiIAAQEDDRD9lA8/+cYAAQKDAlQAErRAD5UR9wABAYMMlX8/72YgAAQTAlQAErRAD5 +UQdwABAYMGVf5vP+/WIAAEEwbBAEG/tICzsLI7CA2iD7siEiAABg8FjDgBj7Q/37RBvQBD0g8joI +BAAgQvD0QIAgPRBgMCykAPqsASoAIG7w+7LBIgAAYTBYw3SkOfKbCAAAEFAw+rQCIAQCEnDRDwAA +bBAEhiDwMQQAARAgMABDGnYwA8Ag0Q8GMwLzJgAiAAAQ8NEPbBAWgjcY+yCCLvAIBwBAAihw8AWg +AoAQGDD8+yQUACAcsC9Q/i5Q/S1Q/PhQ/yOAECAw+BYAJAAgILArQACbESpAAZoSKUACmRP4QAMg +MBBYMPgWBCAFEFAwWMq3HPsUL0AGLkAFLUAEKEAHmBArQAibESpACSoWAilACikWA/hACyAwEFgw ++BYEIAUQUDBYyqopUNgpFDT0UNogcAJQcFtY5iocOPwKASBoAlhwW1iSKUqAqSkqkF78CgAgFwA2 +oG0IDCqQX7HM9KAHYAICSnBj/+wrSt77KwgAcAJQcFtYhvs6WyIAAGEw+ysIAHACUHBbWIH6HDgg +QAJYcFtYMsCw/AoQIEACUHBtyhaivP2gACwAIBswLMD8sbv82QhwAgJSsMAg0Q/9wwZ//xBQMMCh +ZK/uwKL8+t8QMBBYMFjKfsAh0Q8AAGwQBiggAMOQeYkoKyAB//rYEFgQYDD6+tcWAJRm0C0KeP8C +AAYAju7QxOJ+sQwoCmJ4sQbGKtEPAAAALCAC9woAImQANyDD7fMWAiYBancQ28Dz8FAgABAwMPn6 +xxAAECgw+RYBIAAQIDALDUf9MSpwABBYMPr6wRIAAGPwbQgXKKCAsbv0gJ1gAgJSsCnAUf2RB3AC +AmMwY//hiRGpufSQg20wEGgwGvqzCpkMrZlmkHP6VREAAgIxsPWVAgRcATmgiBL1iRQABgIhMPWE +AivwASgw+oQAIAAQMDD5hAEgBgJCMPgWAiAAECgwsXeieiygAvvMAAAcADcg/wIAD/+18xDIzH65 +HSugA/W/9mACAlKwZGGR/wIAAgEPAaD/AgACARMFoMZK+goFIDAQWDD8+pQSAABpMFjKLdJA0Q8A +AAArIAL3+o8SAAAo8P0sAi1QEGAw+QoAICkANuBtCAwuIAOxmfTgCGACAhCwY//sAAkLQAsIBgm4 +O/8CAAAAmgYgwCAr0ABksEXz8DAiAAAjcPIWACAAEDAwCw5H8+FocAAQWDD8/AACAABR8G0IFyig +gLG79IAVYAICUrApwDH+kSFwAgJjMGP/4QAAAMYq+goFIDAQWDD8+mwSAABosFjKA9EPHPpj/LwI +DVAQUDB6wdpmv9cqQAFkr9FquxjwABVh9AJa8AAAHvpaKNpQeOG7KkABZK+1+g5HAgAAIvDz4U5w +ABBYMPz8AAIAAFHw0w9tCBcpoICxu/SfkGACAlKwKMAx/oEHcAICYzBj/98Z+kn5uQgNUBBQMP8C +AAf/t9ZQZr9narsW8AATYfQCWvAAGvpALNpQ/wIAB/+pZpAMSBH2EgAoACAtsAi4AviUACACAhCw +BiYMDWQJK0AAZb73Y/8qAMBAxpoElDhj/ncAACTQACvwMPSxRHAAEHAw+3wAAgAAE/AosIBkjv8p +IDH+7AEgAgJa8PSZ63ACAhCwquv/AgAH/3Pm0Pbu32ACAmtwausT8AASYfQCW7AAAP8CAAf/ZWaQ +sd3b4Ps0ACACAijw8/5sYAEQEDAAAAAA+8wAAgAAULD2CgAgABAoMPP90WAAECAwjRIFTBQs1ADz +/2RgAgIhMI8SBS4UBagUKPQALvQB8/9OYAQCITAAAGwQDCggBSkKlfYKACYAmM4Q/PoGEAUQUDD9 +MhMgMBBYMFjJmykyE/wKASGAECAw+epRACgArnD5y1EAAI6GoP8CAAAAiobghSeFXvtSkCQAICFw +JkSRLTIALVaH/ESSICwANuAY+fQc+fId+fP4uygCAABQ8FtRZxr58SkyEwqZAvk2EyIAAFDwW1FG +G/nU//nWH5IQYDAsJAUqsngpsoD7vfYggBBoMPuw0SuQBDqg+vnkGAAgVnD2RJEigBBwMPwiACAY +AH7w8AAGaAAgbnCumZoW/xYAIAQQaDD++cIdgAQ7IP4WAiwJAGswnBErkAcokS4LCUEAmREJiAIK +iAKYFA/qMJ8VlhcpXQL3CRYAQAJQcADKigQJiACKigIJiABKigAJiAAKivosAAIAAFhw/AoEIAIQ +aDBbptnRD9ogW1EUiC3HnvYlNSgAQEowmC1j/rwAAAAA+jwAAAAQWDD8CgAgAhBoMFtVQtEPAAAA +bBAKkhj1FgkgALalIPIKACAAEDAw8ABEYD0QODAAAAD/AgAGAJY+0MDQJmzq+/rqICwCITD8CgAg +ABBwMI8ZKhIIC2sM+zsIDgAgfLBbV3+iomYhIv8CAAAAj6Ugo28r8ABkv7r/AgAGAHO+0GpBt9vw +/QoAJAAgfTBtCBousAGx2v2sAAACAmLw+8wAAA8AN6B34Qp1ygRj/94AAHfpiSjAAcCw+8QAIAIC +crD0g7dgAgJjMP8CAAgBw6eQwOBtCBOx7q3rr7kpkAH0kApgAgJS8HSqBGP/5bG6BKkMCbo4+awB +IAAQWDD5RAwIACB6sPuEACYAIDJw+5wAA/+gJ6Bk4osvwABk8oUV+WElUtuZEPpQACAAPCegf6lw +9RYBIAAQWDBtCCQL6Qz7vAEgATCGYIoR/wIAAgE0ImCstfVQACoAIFLwKqAAdalCY//UKPAB+QoA +IAICY/D59AAjGQA2IP8CAAIBRKEg8/9OYAAQaDAAAADAIPoKBSAwEFgw/PlVEgAAaLBYyOXRDwDV +8IsQ/xYHKgAKVVD1ow5wARB4MPAABmAAEHgwx/9k8eAV+TglUtfA8PpQACAAHaegiBf1FgYgYghC +sG0IJA/pDP/8ASAA3oZgihb/AgACAOsiYKr6+qAAJAAgZ/AlUAB6WQZj/9QAAIUXelMP9aMOcAEQ +eDDwAAZgABB4MMf/ZPF/FfkgJVKdwPD6UAAgAB0noIgX9RYFIGAIQrBtCCQP6Qz//AEgAK4GYIoV +/wIAAgDDomCq+vqgACQAIGfwJVAAelkFY//UAIUXelMP9aMOcAEQeDDwAAZgABB4MMf/ZPEfFfkI +JVKFwPD6UAAgAB0noIgX9RYEIGAIQrBtCCQP6Qz//AEgAH4GYIoU/wIAAgCdImCq+vqgACQAIGfw +JVAAelkFY//UAIUXelMP9aMOcAEQeDDwAAZgABB4MMf/ZPC/FfjwJVK1wPD6UAAgAB0noIgX9RYD +IGAIQrBtCCQP6Qz//AEgAE4GYIoT/wIAAgCPImCq+vqgACQAIGfwJVAAelkFY//UAIUXelMP9aMO +cAEQeDDwAAZgABB4MMf/ZPBfFfjYJVKfwPD6UAAgAB0noIgX9RYCIGAIQrBtCCQP6Qz4kTxgAgJ7 +8IoS/wIAAgBoImCq+vqgACQAIGfwJVAAelkFY//UAIUXelMP9aMOcAEQeDDwAAZgABB4MMf/Zfys +wKX8+NEQMBBYMFjIYccv0Q+KEay19VAAKgAgUvAqoABj/dyKFqz19VAAKgAgU/AqoABj/jKKFaz1 +9VAAKgAgU/AqoABj/oAAihSs9fVQACoAIFPwKqAAY/7NAAAAAAAA/wIAAABKBSDAka+e+5wBIAAQ +aDD95AAmACAy8PtEDAAAEHAw8/wlYAAQaDCKE6z19VAAKgAgU/AqoABj/umKEqz19VAAKgAgU/Aq +oABj/zcE6wwLrjjZ4P+YCAACAlpw+0QMAAAQcDD+hAAmACAy8PP72WAAEHAwBOsMC6448//WYgAA +S7AAAGhBFPP/e2ABEEgwAAAAAADz/25gABBIMPP/ZmAAEEgwbBAOLzAk9fiPEAAQMDD0CpIggBA4 +MPMiECCqADfgaPE0/wIABABPi+D/AgACAEuj4MCl/PiFEDAQWDBYyBOLOi4wBYq4/wIABgBAJ5Da +IFgRlsAg0Q/Apfz4fRAwEFgwWMgJLjAFizrTD/qyCCYAtSeQLCITeMcgiif7CgIgABBgMPqsICAC +EGgwW6mFKyITLPp/DLsBKyYT+/htH4wQaDD9JGgiAABQsFumfSakEi8iE44i9qUILgkAP/D/JhMg +/AA3oMAg0Q8AKKITj6AsoAX9MgAoCQAqMCimE5wQHPhdibCZEfiwBSAFEFAw+BYCIDAQWDBYx+SK +N4quKxqA+6sIAAMQYDAstJIpMAX/AgAP/54iUP34UB+VEHAwLjQFHvgtHPhOLdDRLuJ4LMKDCe4R +/9cMfAAgczDwAAloACA/MCkqgKnJHvg8HPglHfgjJrSRiDCdFpwU+IgRAAQQYDD+FgooCQBiMJgV +L5AHLZEuDw9BAP8RD90CDt0CnRgM6jCcGZYb+a0CIGACUHAGCYgAyooECYgAiooCCYgASooACYgA +Cor7HBAiAABQ8PwKBCACEGgwW6U4Y/6QKyAH+wtBAgAAULD7vBgiAABgsFuwz8Ag0Q8AACiiE40w +j6D8oAUoCQAqMCimE5wQHPgaibCZEfiwBSAFEFAw+BYCIDAQWDBYx6GLN4u+KhqA+roIAAMQYDAs +pJIpMAX/AgAP/ymiUP34DR+VEHAwLjQFHvfpHPgKLdDRLuJ4LMKDCe4R/9cMfAAgczDwAAloACA/ +MCkqgKnJHff4GPfiJqSRjzAa99+aFpgU+P8RAAQQQDD9FgouCQBH8J8VLpAHLJEuDg5BAO4RDswC +DcwCnBgK6jCWGym9AvoWCSBgAlBwDgmIAcqKDAmIAYqKCgmIAUqKCAmIAQqK+xwQIgAAUPD8CgQg +AhBoMFuk9GP9pgBsEBwZ9+QoMAQkIhAuMAX8MAYgABBYMPpCBymABDog/TAHKAkAcjD+IAcpgAQ6 +IPqiDigJAGIw+hYtKYAEOiD+DkEICQBqMP4WKSgAQEow+BYrIgAQYDBYv/wmMAEpMBgqMCQqFiwq +MBkrIhf8MBopgAQ+YPYlQQgJAFZw+jAbKYAEPmD2d0cICQBmcPYNQQmABD5g/RYqKAkAVnD2ZkAA +EghacLG8LCYX/Pe7EAUQUDD9IhMgMBBYMFjHQN5Q+veVEEcQYDD995IQABB4MPv3pxGyADWgZHDQ +wKL897AQMBBYMFjHNhv3oR33iRr3ivwKRyAAEHgwGfeEHvelGPejKZJ4LuKDKIDRCZkR+QqALgAg +S7D/hwd4ACBPsGAABCkqgKnpLhItKBqAqOgshJGIQC0WGioWGPiIEQAEEFAw+xYeKAkAUjAoFhkq +kAcpkS4KCkEAqhEKmQILmQIpFhwI6jAoFh0vFh/57QIg/gJQcPcJFgACAlKwAMqKBAmIAIqKAgmI +AEqKAAmIAAqK+xxgIgAAUTD8CgQgAhBoMFuki9ogWBCOwCDRDwDeUP8CAAf/o+eQLSIT8+8RAAUQ +UDDTD/z3dxwJAH9w/SYTIDAQWDBYxvooEivLjPs8MCIAAFCw/RItIgAAYjBb/az3oCliAABKsMCi +/PdrEDAQWDBYxu8b91od90P690MQRxBgMPP+5GAAEHgwwJAqEiwpFigsEiz0obZvhxBYMP0iACDw +AD8gHPddLxIs/kIAIAIQUDD7JGggMBBYMFjG3P58AAIAAHlw/PdWEAIQUDD9EiogMBBYMP0WACIA +AGmwWMbUG/c/Hfcn+vcoEEcQYDDz/ndgABB4MGR/ImRRjf8CAAH/jx1gLhIqZO5e/wIAAf8th6Au +Eipj/wUc90L7JGggAhBQMP5CACAwEFgwWMbA8yIZIAEQYDAsRhL8RhQgABBYMPtGES+VEFAwKkQF +LzAF+0YVIAIQSDD5RhMgchAgMP4yACoAmfkQ+goFIDAQWDD89y0SAABo8FjGrS8wBdMPdPEVLQpz +/wIABgDy79AuCnX/AgAGAPh30MAgwKX89yMQMBBYMP4yACIAAGjwWMagZCDThTgiUhkc9usjUAf9 +IAQgBRBQMP4iACAwEFgw/yAFIiABHDBYxpYoIAUPAgAPAgD/AgAKAFDBEBz24I8ojiAtIAT/8gAg +BRBQMPMWACAAEEgw+RYBIDAQWDBYxoj6XAAACBBYMP0cECIAAGDwW7GlZKMxHPbSi1DA0P2mASoJ +AGbwm6AZ9s8MOBHyEgQoACBKMPKGACAAEBAw0Q8A+iwAAAAQWDBbpPspIhMJ20FvsmsvEigoEi2Y +pC+lCv/28BCAEHAw/6YCLgkAcnAuJhMpIgJkkoDAINEPLhIqZe6BY/zVAAAA/SIAIAUQUDD89uUQ +MBBYMFjGYS8wBXTx1igKcHjx0PoyCCAAEFgw/AoAIAIQaDBbmarAINEPAAD/AgAD/vWe4Cv6iysk +aCkwHCwwHfswHimABD5gDJkC/DAfKYAEPmD7QhMoCQBecAiZEQyZAnuZBLG8LEYTLjAgKDAh/zAi +L4AEO6D4MA4uCQBDsPkwDy+ABDug/zAjLgkAe7D9QG4pgAQ6IPjuEQgJAEow+EYRLgkAe7D+RhQg +TgC3YMe/m6QvIhP59rcQgBBAMPmmAi4JAEfwLyYTY/8RjTgsCnQsNAUs1AUvMAXz/hpgARAQMI84 +Lgp3LjQFLvQFLzAF8/4EYAEQEDAAHPan/UIAIAUQUDD+IgAgMBBYMFjGH4on+woCIAAQYDD6rCAg +AhBoMFunoCtABSwKlf8CAAYApebQ/PZ9EAUQUDD9IhMgMBBYMFjGEikiE3ueFQntUf8CAAAApQdg +Cc5R/wIAAACfh6CFRyVSDvMagCAAEEgw+1KQIgAgHXApNJEoIgD4VocgARB4MP80kiAsADbgGPZp +HPZnHfZo+LsoAgAAULBbTdwa9mYpIhMKmQL5JhMiAABQsFtNux72axv2af/2Rx+SEGAwLEQFK7DR +L/J4LuKDCf8R/7cPfgAge7ApCoDwAAloACBPsCkqgKnpHfZUGPY++/Y8EAAQUDAqNJGPQJsamBj4 +/xEABBBAMP0WDi4JAEfwnxkukAcskS4ODkEA7hEOzAINzAKcHAvqMJsdKV0C+hYPIIACUHAOCYgB +yooMCYgBiooKCYgBSooICYgBCor7HCAiAABRMPwKBCACEGgwW6NPwCDRDysSKdog+7wYIgAAYLBb +rufAINEP2kBbTYWMTf36/iAAEHAw/kU1LABAazCcTWP+nAAAAAAAAAD6LAAAABBYMPwKACACEGgw +W1GwwCDRDwDaUPz2BxAAEFgwW7C4wCDRDwAAAGwQDBr2Jh/2Aok0jTYs8oAr8nj4/fYigBBwMPiA +0S1gAWww/RYMKABAVnD5FgkrkAQ+4Py7CACAEEgw+vKGLAAgTvD/hwt+ACBy8JodnRpgAAOaHZ4a +hRwk8nCGOfcxDyQAICkw9TIIJZAEOSD1FggkACAjMIVJW51njyCfoI5KHPYV/SITIDAQWDD+jlIA +FxBAMPgkBC9gBDug+iYHLAkAd3D9JhMgBRBQMFjFhiggBx32CSxQDIoaK1ANKVAH+qEHIAAQcDAu +JRv+JCIoIAFMMP32AhgAIG5wKiUHLCQMKZCAKyQN/PXYEPsQWDD7iAEJ4AQ+YPsSCCgJAEowKCQH +L1AHliwmJhUmJhSbK/smCSAIEFAw+yYWIPwQSDD7wpUoAEBKMPokBS4gAXww+hINLgkAR/D/JAcq +AAZbUAtuDK3uLiYVHvXmK8KXKOJ9LOKA+eKCKgAgRvD4CAYB/gJa8PDABAgAQFow+AgbAAIQWDD9 +Cv8oAQBaMPfMQwgDAEow+swJCAMAajAoJCMswQoszNj4Fgst4AFgMPwlGiAaAGHwLMz0DAxPLCUa ++1AWIIAQQDD19cweGAC7IPglGiCAEGAwKyQWKOJ9+FU2ACYEavAPCkFbcWEsIRoKVTYMVTcMWCwI +yBz4JRsiAABQsFukuoUYHPW9jScuIAQvIAWKG5oQ+SIKIDAQWDD5FgEgBRBQMFjFLBz1tY0cLhIJ +JCYZ8kYIIHACULAqJg76Jg8gcxBIMClEBSkkBS8yBCYWACUWAShABScWA/gWAiAwEFgw+CIAIAUQ +UDD4FgQu+AF8MFjFGPz1oxAFEFAw/UIPIDAQWDBYxROKJ8Cw+qwgIAEQYDBbqdOMTBv1m/umACAP +ADcg+0IPIgAAULALwADAINEPAABsEASIKikgNfSGEXAEEDAw8AALagkAMnAAAAAAANqQw7D89YwU +4AFUMPoKBSIAAGlwWMT7LyAMLCAN/fWHH4AEP+DwXhEMCQB7MA7MAvgyAiwJAGswnDD5IgogABBY +MPs1AiAqEFAwKjUD+iEZICQABnAZ9XoEqhEKiAIJiAKYMvo8FiBsAhCw/AoGIgAAWLBYvXouQBEv +QA0sQAwoQA8tQA4rQBD43QIMCQB7MP67AgwJAGswDLsC9bAUYCACUPD79WgQBhBgMFi9bGAADAAA +/AoGIBgCWTBYvWga9WMf9WH2NCMgBhBgMCw0IolAiEL/NB0gCBBwMP40HCABEGgwLTQf+jQhIAAQ +WDArNB4oNC8pNCUIiBQJiRQpNCT4NC4gCBBIMCk0IAiIFCg0LfiIFAIAAFiw+DQsIEwCUPBYvU8t +QBcuQBMrQBIvQBUsQBQqQBb/zAIKCQB28P2qAgoJAGbwC6oCyKwqPDD8CgYgJAJZMFi9QoJBIjQ5 +AoIUIjQ4AoIUIjQ3AoIU8jQ2IAAQEDDRD2wQBhz1Nf0xEiAFEFAw/iIPIDAQWDBYxJ0rMRIX9TD0 +LAAAABBgMP0yCitgAVgw+PUsEgATIqB6gh6JL2SSTCqRGfuqDAIAACMwCpQ4zEjUIPAAZ2AWEBAw +hUcmcp/5crAggBBQMPVSDiAgADdgKHJPCWYRqWZtiRCLZ4u+K7K//wIABgB17tCqZiJSwg8CAPtS +wCEpADSgHPUTLVK/LlLA/1LGIAUQUDDyFgAgMBBYMFjEdvwKACAQEBAwG/THLUAMK7J4KnKwrbsJ +uxH+9QYaACBasC2hLvsqsCYASPdQjUcY9MCN3h70vRX01P/0vBoAIF9w8A4HAgAASvAASWEASWEA +SWEASWGJQPXWsiAEEHAw/9auKYAEPmD41qwoCQB2cCnWrSigBy+hLggIQQCIEQj/AgX/Ai/WsA7q +MCzWs/7WsSLQEEgw8gMWCAAgT3AASWMAA4YASWH53QIgBBBgMPKU5iACEGgwW6HM0Q8c9N8uYDWP +YJ0R+xYAIAUQUDD7CjAiAABr8FjEQPwKAC76ADWg/wIAB/95JZCNIP5gNSAFEFAw/PTSEDAQWDBY +xDfAwPP/BWBjEBAwAACKOmSgtYo7/VLGIA4EUvAqVsCKPP9SvyAOBFNwKlbGjjr/AgAGAFF/kPk8 +AAABEDAw9laoIiAQUDDyCRYKACBRcABKYwAJhgBKYQ4JhgBKbwwJhgBKbQoJhgBKawgJhgBKaQYJ +hgBKZwQJhgBKZRv0gRz0f/30sBIAAFEwW0v12kBbS9gc9K2CUPMyCiACEFgwK1ao+wo6IgAAULBb +ViLIrpao86YJIAAQaDCdqowiysTAINEPAAAAAAAALFa/LFbALFbGLFa98/40YAAQEDDz/b1iAAAj +MCsgB/sLQQIAAFCw+7wYIgAAYLBbrRrAINEPAABsEAgc9JItIgD+IAQgBRBQMP8wFSAwEFgwWMPw +F/RGFvREKCA0GvRA9fRZEAAQYDD09IISgBBoMPus9CYAVAIgLgpkKCAML6J4KrKDqP8J/xGvqi+h +Lhn0NfsqsCYA3CfQjyeP/qv78AkHAgAASvDwCaAABBAgMABJYQBJYQBJYYkgJvau9/asKYAEPmD1 +9rIoCQAmcCn2rSigBymhLggIQQCIEQiZAgWZAin2sAjqMCj2sfz2syLQEEgw8gMWCAAgT/AASWMA +A4YASWH9/wgABBBgMP70ZiACEGgwW6FDwCDRDwAvMBX+9FIQASyH4PgKCSYAkwfg+QoLJgEvR9D/ +AgAGAJ7P0N7w/PRREAUQUDD9IgAgMBBYMFjDsBv0JcDA/goWIoAQaDDz/xZgGAJS8MGmmhMb8/ws +IAwa9B0rsngqooOsuwm7EauqK6Eu/PP3FgBLptCNJ43eKyqwq9vwDAcCAABK8ABJYQBJYQBJYQBJ +YYwg9dayIAQQSDD21q4tgAQ7IPfWrCwJAEswLNatKKAHL6EuCAhBAIgRCP8CBf8C/9awIgAAYPAO +6jD+1rEgABBAMPjWsyLQEHgw9gwWDgAgf3AAT2cEDIYAT2X/KoAgBBBgMP4SAy4AIH9w/vRmIAIQ +aDBboQGOE54U/PQZEAUQUDD9IgAgMBBYMFjDd44UG/Pr/SqAIAAQYDD17jJgGAJS8MAg0Q8qMRIK +Ckv/AgAD/4cioP8CAA3/g1OQiy/7FgAiDwC24MDCnBNj/vQc9Ab9MRIgBRBQMP4iDyAwEFgwWMNi +LDESDAtL+rIeYgAAULAd8/N70hMpIg9kkjsukRn87gwAABBQMA6aOGShuo6nju4r7BD7FgEiAABI +8JoSBgmGAEtnBAmGAEtlAgmGAEtjAAmGAEthDgmGAEtvDAmGAEttCgmGAEtrCAmGAEtp+hICIAEQ +QDAo5iUsIDovIDv7ogAgABBIMCnmJvj/EA0ABDsg+41HCuABXDD/zAINgAQ/YP3z2RwJAGsw/POf +GgkAZvAr5icb851bSxSKEvzz0xJeEFgwW1VGzKbz/slgDBBwMIkRmaiKEltK8IoSi6JksX3z/rFg +ABBwMAAAAAAAAPosAAIAAFjwW/6A8/6YYgAAcrAAABzzwv0iACAFEFAw/jETIDAQWDBYwxuJLyox +E/olGCAHADZgKpUYG/NqLCAMGvOKK7J4KqKDrLsJuxGrqiyhLv8CAAYATCcQjSeN3hzzYisqsKvb +8AwHAgAASvAASWEASWEASWEASWGMIPXWsiAEEHAw9tauLYAEOyD31qwsCQBzMCzWrSmgByihLgkJ +QQCZEQmIAgWIAvjWsCIAAEjwD+owL9ax/goAItAQYDD+1rMsACBjcAoJhgBMawgJhgBMaf8qgCAE +EGAw/98IAAAQcDD+9GYgAhBoMFugbvP9s2AAEHAw8/2rYBYQcDAqIRguIA0tIDUsIBYoIAcvIAwi +thD7IRYiAABK8C+UDC6UDS2UNSqVGPuVFiBsAlJw/JQWIGwCWLD4lAcgBhBgMFi7bI4QH/N3jSr4 +MRIgABBgMJwT+OUZLAkAf3Cd6mP8jgAAAAAAAPP9zmAAEFAwK6AHCwtB+7wYIgAAYrBbq+dj/m1s +EAaDJ4M+HPNnjSD+MqggBRBQMP8yqSAwEFgwWMK9LDKo9MI+YiAQcDD98xAQARsHIBrzCx/zCxXz +TvbzIhAAECAw9/MJEioAOyBow1IkNqn0NqgiAAARMNEPACsyqfzzSBYAehLg8jIAIAICUvD6Nqkg +AhBIMPk2qCA6EFgw8zKSIgAAULBbVLnIr5Sq86YJIAEQYDCcqIsiZLHqwCDRDywgDCuieCqigKy7 +CbsRq6oooS77KrAmAEguEIwnjM77ywgC0BAoMPAPBwIAAErw8AmgAAQQQDAASWEASWEASWGPICbG +sv3GrC+ABD/g98auLgkAR/Avxq0poAcooS4JCUEAmREJiAIGiAIoxrAP6jAkxrP/xrEoACB08PIJ +Fg4AIC8wAE9jAAmGAE9h+SqAIAIQaDD5yQgAYhBAMPiUZiAEEGAwW5/3JDap9DaoIGIQEDDRDwAA +2iBbSi8rMpKKMC0ylC4yky42wC02xpoR+xYAIvAQYDD7Nr8sACBg8Cw2vfzy/xA6EFgwW1R4yaOP +EfkSACABEEAwmKiZqpmpj/Jk8P0b8q8sIAwa8s8rsngqooOsuwm7EauqK6EuHvKp/CrQJgBIrtCN +J43eKyqw8A4HCgAgX3D+8qUSAABK8ABJYQBJYQBJYQBJYYkgJtayLtas+JkRAAQQcDD31q4oCQB2 +cCnWrSigBy+hLggIQQCIEQj/Agb/Ai/WsA7qMPTWsyIgEEgw/taxKAAgTPD2CRYOACBncABPZwQJ +hgBPZS8qgP/fCAAEEGAw9PRmIAIQaDBbn7QkNqn0NqggABAQMNEPAAD88tEQBRBQMP4qICAwEFgw +/SIALgAgcPBYwiXaIFtJ5cAg0Q8rIAf7C0ECAABQsPu8GCIAAGCwW6s/wCDRD4wRK8AHCwtB+7wY +IgAAUzBbqzlj/utsEAgc8rwX8mgqMAiIMClyb/oWBSIAAGiw93KAKGABQDD4FgQoACBKMP7SACmQ +BDog/9AEJgAgRfD0cgoiAAARMJMQ8hYBIDAQWDD1FgIgBRBQMFjCAhzyqP5yACAFEFAw/3AEIDAQ +WDD0FgAiAABp8FjB+vnyohIAAEDw0w9tKQUACIYASWEc8p4Y8p4tMAn+MAogBRBQMPWGFSAwEFgw +WMHuKTAJjnr68j0QCQA2YAruAp56izCMFfjydxAAEBAw+rYPcAYQUDD4wTpgEBBYMGjCX3TpFy76 +jX4hDNpQ+zwAAgAAYLBYwQnAINEPAN1A+goFIDAQWDD88oMSAAB4sFjB1mP/zy9wNIwU+PZkYAAQ +SDApdDT46gICAABY8Pp2CiIAAFHwWJa+jnrz/6RiAAASsI1wCN0RnTMscDRpxpJz5o+MFB/ycfp0 +NCIAAFHw/+4BDAkAWzD+dgoiAABY8FiWr4568/9qYgAAErAAAAAAAAD/AgAD/64PkIwUKnQ08/+S +bAkAWzAAAABsEAoX8gYc8l8ocm+FMfJygChgASQw+YgIAAUQUDD1hUcJkAQ6IPUFBgIAIECw/iA1 +IDAQWDD/IDQhwAI58PQWACIAAGlwWMGiLiA0FvJLGvHz/SAMJIAANWCFMSqieC8gNflyiCAAEFgw +/aoIBOgBLDD1BQYLkAQ6oPRQFGgAIFZw/uIjYAcQYDD8JDQgBxBwMPryPRgsALugGPI8COgKiICf +GZkYCoAAKyQ0HPI5LSA1FvIxLiEWE/IuL2IVkxCJKvkWASAFEFAw9RYCIDAQWDBYwX8qYhX7PAAC +AABhcFjAp9EPHPIr/WIVIAUQUDD/EgkgMBBYMFjBdRbyKBrxyBXyJfAKBwIAAEmw8AmgAgAAOrAA +SWEASWEASWEc8hoY8eArIAwpIA0a8h34gNErgAQ+4P/yHBgJAF5w+pkCAgAAcXD5xiwoAAFAMPny +Fx4FAEPwLsVcKcYtLSA1+hIIIAAQWDD7xMEtwAQ/YP3EwCIAAFmw/PINEgAAaTBYgO4r+o31rAAH +/65ekGWvHRzx/ivBXAsLSyslFizBZB7yBP4WCi1AAWAwLCUXKeABKuAAKiQ2KSQ3ihgo4AIv4AMv +JDkoJDgt4AUu4AT+JDogbAIosP0kOyABEGAwWJ/vjhgc8fUtIRYv4BQo4Qgp4Qkr4A0u4AwvpBQo +pQgppQkrpA0upAwqJhEvIDYuIDeeEI4ZKyA4mxEqIDmaEikgOpkT+CA7IDAQWDD4FgQgBRBQMFjB +J48YHPHgKCEXLfEJLvEI//AUIAUQUDD4FgAgMBBYMFjBH4ggKjwa+IgRAgAAWXD4NgMgBhBgMFi5 +sBrxww8CACqiFVjAZ/0SCiACEFgwKyQ0YAAPAAAd8coX8WX1LDYh7AIzcPAHBwIAAEmwAElhAElh +AElhAElhGPHEHPG2LyEWG/HD+8VcIAEQcDD+xi0uCQBH8C/GLCpQASlQACnUACrUAShQAy9QAi/U +AijUAyxQBC5QBS7UBSzUBPzxrxIAAFmw+iIRIgAAaTBYgI4j+o31rAAH/u4ekGWtncCTKSQ0YAAL +ABfxQvbxoB+NEBgw/PGoEAUQUDD9IRggMBBYMP8SCSIAAHGwWMDlwOHwBwcCAABJsABJYQBJYQBJ +YQBJYR3xnRvxjBrxnCwhFi62LSq2LvoiESwJAGsw/LYsIgAAaTD88Y0SAABZsFiAbsDU9awAB/6u +npBlrR4tJDRgABMAAAAA9/EiH40QGDD28X8QBBBoMBzxgf/xdxABEHAw8AcHAgAASbAASWEASWEA +SWEASWEa8YL5IRYgABBAMCj1XS71XC32LR7xfv72MCIAAFmw+iIRKAkAVnD59iwiAABpMFiAUPWs +AAf+c56QZayo9fFhEAUQWDArJDRgABAA9/EDEgAAKrD28WAfjRAYMMCy8AcHAgAASbAASWEASWEA +SWEASWEZ8WgoIRYa8WcqVi8qIhErVi358WUYCQBKMChWLP2gDCj4AUAw+YgKAAIQYDD4gkggBRBw +MPoWCy2ABD9g/t0CAgAAWbALgACJGyxSLYuSDIxH/AwGAFoANuAd8UZk0E8rkA0qkAwZ8VH5kogh +ywA24B3xT/zw3BwAIG6wLd0BLdBNLMJ5q92tzAnMEaycLMyAjMeMzh3xN53AlMHRD7HuDg5HLiQ0 +Y/t4AAAAAAAAAPXMAAf9+58QZcu4+iwAAAMQWDBbWrfA9i8kNGAABwAAF/DGFvEk8AcHAgAASbAA +SWEASWEASWEASWEV8S/88TEQBRAYMP0hFiAFEFAw/iIRIDAQWDBYwGQZ8SwoIRb58RAYCQBKMCiW +LI8qGvEC/vEnEAAQYDD/z1ACAABrMA+tOfoiESwFAHuw/QoBLAkAazANzAIsli39oAwo+AFAMAWI +CiiCSPjdEQIAAFmw/AxHDAkAH3ALgAAT8PolMi30SUEE6AEsMPUFBgr6ADZg/wIAAf2UhmAtIAxg +AAoX8Jf28PUSAAAasBzxCi4gDY8gKiA1mhApIRaZEfgiCiAwEFgw+BYCIAUQUDBYwDcb8OnwBwcC +AABJsABJYQBJYQBJYQBJYRjw/CogDCkhFi8gDRzw+vuZAguABDqg/DYtLgkAV/D5NVwuCQBH8C82 +LC4gNf0KACIAAFmw+hIIL8AEO6D+NMAgABBgMFh/uf2sAAARADagwKL88OkQMBBYMFjAGsCgKiQ0 +0Q8AG/BrK7J4qrsJuxGrm4u3i76dsJSx0Q8AbBAGgycPAgCDPhzw3S0iAP4yJSAFEFAw/zImIDAQ +WDBYwAkoMiUX8F328F8QABAgMPXwnBM2ADYgKDIl/wIAAgE9giAoMiX/AgAEAWeCICkyJf8CAAQA +gwZgKzIm+7wBIGMQUDD7NiYqACfakPzwxRAFEFAw/SIAIDAQWDBYv/Ia8Gcb8EQc8GSOJyQ2JSQ2 +JizA0SuyeCqigy8qgP7iDiuQBD7g/8cZegAgWrAsCoDwABBqACBisI0iZNKSwCDRDwCvqiuhLnWx +8hzwNYig9+YyL+EQSDAp5Nj4iBEAFhBIMPzmMCgJAEowKOYxL6AHDw9BAP8RD78CBv8CL+Y0Deow +/eY1ICACSPD4Cm4hIBBgMPzlbyDgEFgw+OT2KgAgX7ACCYYAS2MACYYAS2GMPizmQIg/+OZBIAIQ +aDD05kIgwBBYMP8yECoAIF+w/+ZDIBYQYDBbnUDAINEPHPCL/SIAIAUQUDD/IDUgIAJw8P4WACAw +EFgwWL+0HPCE/SIAIAUQUDD+MiogMBBYMFi/rhvwARrwIi0yLSwyKi4yK48nJDYmJDYlnj8uNsCc +Piw2vy02EC02xh3wGCqigyuyeC3Q0f/yDiuQBD7g/9cRegAgWrAoCoDwAAtqACBCsAAAKSqAqaor +oS797+4f4RBgMPkSACYAQS7QiKAn9jIs9Nj4iBEAFhBgMP32MCgJAGIwKPYxLqAHDg5BAO4RDr4C +Bu4CLvY0DeowJPT2/fY1ISAQYDD89W8g4BBYMPYJFgoAIF/wAEtnBAmGAEtljD4s9kCIP/T2QiAC +EGgw+PZBIMAQWDD+MhAqACBf8P72QyAWEGAwW5z5gjD88A8QOhBYMPMyvyIAAFCwW1GFZK4uk6rz +pgkgARBwMJ6ojSJl3h0rIAf7C0ECAABQsPu8GCIAAGCwW6iGwCDRDwAAwKX88DQQMBBYMFi/YBzw +M/0iACAFEFAw/yA1ICACcPD+FgAgMBBYMFi/Wdog/O/5El4QWDBbUWv8CgEgABBIMPrJOAAJADag +jRAtpgj/CgEgABBwMAn+OGXtQ2P9owAc8B/9IgAgBRBQMP8gNSAgAnDw/hYAIDAQWDBYv0TaIPzw +GBJeEFgwW1FXZK10iBCYqGP9CgArIAf7C0ECAABQsPu8GCIAAGCwW6hawCDRDwDaIFtG98Ag0Q9s +EAaIKvRCACXcEEgwKRUA+SA1IBwAEjDApPAABmoJAFJw2pDDsPzwARTgAVQw+goFIgAAaXBYvycp +IAwuIA3/77MZgAQ+YPBYEQ4JAEuwCO4CD+4CnjCLKsDQ/TUCIk4QYDD8NQMgLgAG8CwhGYoyG++o +BMwRDKoCC6oCmjIqPBD8Kk4gABBYMFi3tcdvJjQQJjQR9jQSICwCUPD2NBMgBhBgMPY0FCBsAhCw +9jQVIgAAWLBYt54mNDEV75gGhxT879wQQxBIMPk0NSAAEEAwKDQ0/DQlIAAQUDD6NDIgRBBYMCs0 +M/c0MCJAEHAwLjQh9TQdIAIQaDD9NCAgCBB4MP80HCAREGgw/TQnIEAQeDAvNCQvNCb+MB4gAhAo +MCU0NveHFAABECgwJTQ6JTQ7JzQv94cUAgAAWLD3NC4grAJQ8PcqLC5gAXAw9zQ3LgkAe7D/CvAg +BhA4MP8KBS4AQHuw9zQ8LgkAe7D+NB4iAABh8Fi3b/o8PiCMEFgw+0sIAAQQYDBYt2r776oRJhBQ +MPo6CAAEEGAwWLdlKQqw+TkIADUQYDAslHollHv1lHwgNxBoMC2UfStAF3i3ByeUfmAABgAAwKUq +lH4llH/3lIEgAxBAMCiUgCtAFyIaMvi3DnIAIBDwwZH5JAAgAgIQsMBS9SQDIBoQYDD8JAAgORBQ +MPokAiAcEFgw+yQBIAgCULD7HAACAABhcFi3RRvvDiuylC2wAPoKACAZADdg2bBtCAwskAGxqvTA +B2ACAkpwY//s+iQHIDwQaDD9JAYi4AFUMPw8AAAQAlCwWLc0oj4m5Aj1RiEgABAQMNEPAABsEAaI +KvRCACXcEEgw+RUAIAQQMDD5IDUgGAASMPAABmoJADJw2pDDsPzvZBTgAVQw+goFIgAAaXBYvooo +IAwtIA3+7xYZgAQ6IPBfEQwJAEdwD90CDt0CnTCKKsDA/DUCIk4QWDD7NQMgLgAGsCshGYkyGu8L +BLsRC5kCCpkCmTIqPBD8Kk4gABBYMFi3GMdfJTQQJTQR9TQSICwCUPD1NBMgBhBgMPU0FCBsAhCw +9TQVIgAAWLBYtwIlNDEpMB4Y7vsc7z/1ixQAQBBQMCo0JCo0Jis0MCw0Jfg0HSACEGgw/TQgIAgQ +eDD/NBwiQBBwMP40ISAAEHgw/zQ0IiwQcDD+NDcgAhBoMP00NiBDEEAw+DQ1IAEQYDAsNDosNDsL +ixT7NC8gBhBgMPw0PChgAUww+4sUCAkAVnD7NC4g8BBQMPqZAQAREFgw+zQnIAUQUDD6mQICAABY +sPk0HiBEEFAw+jQzIAAQSDD5NDIgrAJQ8Fi20/o8PiCMEFgw+0sIAAQQYDBYts777w4RJhBQMPo6 +CAAEEGAwWLbJ/AoEIAEQQDD7CpQguBA4MPcyCAA1EHgw/yRyIDYQcDD+JHUgAxBoMPYkdiEvEFAw +/SR0KgAgUPD4JHMqACBdMFi2uPYkfCAEEGAw+woyITUQUDD7JHsgmBBYMPo6CAoAIF0wWLawwML8 +JIIgORBYMPskgSE7EFAw+xwACgAgUPBYtqgb7nIrspQssAD6CgAgIAA3INmwbQgMLJABsar0wA5g +AgJKcGP/7AAAAAAAAAD9Gj8gAxAwMPokhiA8EHAw/iSFIuABUDD8LAAKACBo8Fi2lKMvp/8l9If2 +RiEgABAQMNEPbBAEJyAHiCIZ7tD1IhAmIAE8MPWCIGvABDngCaoIKKI6/wIABAELxiAkojn87koS +DAA1ICYiEy0iCfsiCiYIATAwDGYKJmKA/bsMAGACMbD/AgAKAOg20CsgFigK/3ixEvogByAAEGAw +W6ai/O46Ed0ANqAvIQcX7rUPD0oM/xEH/wKfQIggG+6yHu6y+I0RAAUQODD+RgIsCQA/cJ1BKSIT +KiEa/+6mGAkAWjD5jkAISgFMMPpGBilgBD5g/O0KD6AEO6D90oAuCQBLsPhGBC4JAHuwnkcNbQz9 +RgUgIAJrcJ1DKyIJKiIW9rsID+AQSDD7JgkqACAysPomFiYAnM0QFu4M/AoGIEACSTDwBgcAABBQ +MABJYQBJYQBJYSxEIPgwEiAAEGAwLEQjLEQiLEQnLEQm/EQlIIAQSDD6RCQoCQBKMChEIfAmFwBQ +AkkwAAmKLTAS/jEIIA0AN2AuRDUOjhQuRDSKXwyLFCxEN/tENiACAlKwml9bUEEKjRQqRDMtRDIN +jRQtRDENjRQtRDAqUhIKixT7iRQAAgJisCxWEitEOipEOwmIFClEOShEOC8iFy9EPw+PFC9EPg+P +FC9EPQ+PFC9EPPAGBwCAAnEwAE5hLSAHDQ1BHu5bDN0Rrt0n1jkrIBYsCv98sQr6IAcgMBBgMFum +KIon+woCIAAQYDD6rCAgAhBoMFue/CsiEyz6fwy7AfsmEyAAEBAw0Q8AAAD6LAACAABZsFumU/zt +yR4lADagwCDRDwDaIPwsAAAwAlnwW6aIwCDRD9og+3wSIgAAYLBbpoTAINEPAABsEAwnIhAS7jwm +cG+IdysiFSwgUJwY+IIOJgEBMDD2Fg0mACAZMPgWBSIAAFGwWLXsHO4yix2KGB3tr/27EQA9ECgw ++moIDAAgYvD1pAAqACBu8Cuy3SzAgPwWDiACAlKwWLXfjhiNHq7d9t8IAAAQcDAu9AIscG8rIhf8 +LEAABAJrcPwWDSQAIGkw/CBYJgAgGTD8FgkiAABRsFi10YoZHO4Xix2qaiWkAAy7CyywgJwe+7Ih +IAICUrBYtcmPGY4e+yIZLgAge7D25ggAABB4MC9kAi1wb/wgYCAEAnOw/BYKJAAgcTD9PUAGACAZ +MP0WDSIAAFGwWLW6ihoc7gCLHapqJaQADLsLLLCALBYO+7IhIAICUrBYtbKPGo4e+yIbLgAge7D2 +5ggAABB4MC9kAi1wbywgaPwWCyAEAnOw/Q1ABAAgcTDzRggAHAJrcP0WBiIAAFGwWLWiihsb7WaM +Fv3tYxoAIFGwJaQA+8sLDdAEOyD7ssEsACBrMCzAgPwWByACAlKwWLWWjRuMF/siHSwAIGsw9iBw +LgAgMzD8zAIgABBoMP3kAiQAIGEw/GwACgAgGTBYtYoS7dH47UYUACAxMPgWDCYAIBkwJWQA+3E0 +IgAAYHDwCAcCAAB4cPAPoAAKEHAw/xYEL/YQaDDAkG0IHtqwDrstDb8or6qqKiqgAPrEACIAAFMw +9LANYAICYzBj/9gAAAAAAAD5pAEqABbQUNsQbQggLbAALs3/KeD//eT/If4CUrD5tAAgAgJa8Pq7 +B3H+AmMwY//YLxAA9QoAIBkAN+DZEG0IDCiQAbFV9IAHYAICSnBj/+yxavscAAIAAGFwWLVasVv7 +7Z8UACBZMA8CAA8CACWweKNKsar7sh8iAABhcFi1Uf8SDCACAllw+RIFJAAgWTDzRggAPRBQMCpk +APmSjyIAAGBw8g8HAgAAcHDwDqIAChBoMP4WBC/2EFgwwOBtCB7fkA2ZLQuYKKj/ry8v8AD/xAAi +AABTMPSQDWACAmMwY//YAAAAAAAA/qQBKgAW0FDbEG0IIC6wAC/N/y3w//70/yH+AlKw/bQAIAIC +WvD6uwdx/gJjMGP/2CgQAPUKACAZADYg2RBtCAwqkAGxVfSgB2ACAkpwY//ssWr7HAACAABhcFi1 +ILFb++1lFAAgWTAlsKCjSrGq+7IpIgAAYXBYtRmxWf8SDCQAIEkw80YIAD0QQDAoZAD5chgiAABg +cPQPBwIAAHBw8A6kAAoQaDD+FgQv9hBYMG0IHtqQDZktC54orqqqKiqgAPrEACIAAFMw9JAIYAIC +YzBj/9oAwID4pAEqABbQUNsQbQggLbAALs3/KeD//eT/If4CUrD5tAAgAgJa8Pq7B3H+AmMwY//Y +LxAA9QoAIBoAN+DZEG0IDCiQAbFV9IAIYAICSnBj/+wAsWr7HAACAABhcFi06rFb++0vFAAgWTAl +sKijSrGq+7IrIgAAYXBYtOOxWf8SDCQAIEkw80YIAD0QQDAoZAD5chciAABgcPYPBwIAAHBw8A6m +AAoQaDD+FgQv9hBYMMDgbQge2pANmS0LnyivqqoqKqAA+sQAIgAAUzD0kAlgAgJjMGP/2AAA/qQB +KgAW0FDbEG0IIC2wAC7N/yng//3k/yH+AlKw+bQAIAICWvD6uwdx/gJjMGP/2C8QAPUKACAbADfg +2RBtCAwokAGxVfSACWACAkpwY//sAACxavscAAIAAGFwWLSzG+z5sVz1sLAkACBhMKNKsar7si0i +AABhcFi0rLFW/hIMJAAgMTDzRggAPRB4MC9kAPlyFiIAAGBw+A4HAgAAaHDwDagAChB4MP0WBC/2 +EHAw+goAIgAAWHBtCB7YkA+ZLQ6dKK2IqCgogAD4xAAiAABrMPSQCWACAmMwY//SAAD61AEqABrq +0PrcAAIAAFhw0w9tCCAvsAAozf8ugP//hP8h/gJSsP60ACACAlrw+rsHcf4CYzBj/9YpEADyCgAg +GQA2YNkQbQgMKpABsSL0oAdgAgJKcGP/7LFq+xwAAgAAYLBYtHqkIrIi0Q9sEA4mIhAU7L+HZyYW +DSZgb4d+JxYGJ0BI+0ITIgAAUPD8fAAGBgEwMFi0bRjstPzsMRvQBD2g9zoIBgAgQvD2YIAgPRAo +MCWkAPqsASoAIGbw+7LdIgAAYbBYtGErQhUsQFD2Eg0qACA5sPOoCAAAEDgwJ4QCJmBv/BYPIAQC +UrD6FgcqACAasPoWDiYHATAwWLRTG+yajB+KHgtrCyawgKyq9aQAIAICUrD7siEiAABhsFi0Sxzs +lIQfiB6JF/RkCAAFEFAw+EgIADAQWDD3hAIkACBJMP0iEyAEAiEwWLupiB0ogG79IhMjHQA2IMCl +/OyGEDAQWDBYu6IsIhP77IEcPAFgMLLMnBgssFj8FhAmACAZMPuyFyIAAFGwWLQwHev0ixgqEhD9 +uwsN0AQ64B3r7wpqCCWkAPuywSwAIGswLMCA/BYJIAICUrBYtCQuEhCNGa7dpt4n5AIsIhP77Gkc +PgFgMLLM/BYKIAQCa3D8sGAkACBpMPwWESYAIBkw+7IZIgAAUbBYtBUS7F4qEhEb69iMGv3r1hoA +IFGwJaQAC8sLK7LBDcwLLMCA/BYLIAICUrBYtAotEhEsEgsNzAj2IGgsACA3MPsiGyAEAmMw99QC +JAAgYTD8bAAKACAZMFiz/xLsRvnruxQAIDEw+RYMJgAgGTAlZAAuIADwCQcCAABAcABIYZgU9xQB +IAAQKDD+FAAgGQA3oNkQbQgMKpABsVX0oAdgAgJKcGP/7LFq+xwAAgAAYXBYs+mxW/vsMRQAIFkw +JbCwo0qxqvuyLSIAAGFwWLPiiRb/EgwgAgJRcPoKPSQAIFEw+Z0BJgAgGTAqZAACD4v5FgUiAABg +cPmRlCIAAHBw8A6iAAoQaDD+FgQv9hBYMG0IHt6QDZktC58or+6uLi7gAP7EACIAAFMw9JANYAIC +YzBj/9oAAAAAAAD3pAEqABbQUNsQbQggLbAALs3/KeD//eT/If4CUrD5tAAgAgJa8Pq7B3H+AmMw +Y//YLxAA9QoAIBsAN+DZEG0IDCiQAbFV9IAJYAICSnBj/+wAALFq+xwAAgAAYXBYs68b6/ixXA8C +APWwuCQAIGEwo0oqrAH7si8iAABhcFizp/8SDCACAllw+RIFJAAgWTDzRggAPRBQMCpkAPmRlSIA +AGBw9A8HAgAAcHDwDqQAChBoMP4WBC/2EFgwbQge3pANmS0Lnyiv7q4uLuAA/sQAIgAAUzD0kAdg +AgJjMGP/2vekASoAFtBQ2xBtCCAtsAAuzf8p4P/95P8h/gJSsPm0ACACAlrw+rsHcf4CYzBj/9gv +EADyCgAgGQA34NkQbQgMKJABsSL0gAdgAgJKcGP/7LFq+xwAAgAAYLBYs3ikIrIi0Q8f68Ie68IP +3QEO3QEtJhNj/NQAAGwQIoY3hm4uYo4c67z6CgUgMBBYMP5+UQIAAGlwWLrSEuu4+FENYAAQODDB +iHhRQdJw0Q8lICzzCj0iAABRMPsiDCIAAGFwWLNfJiDU+yI2KgAgKTAjpAD8bAAAAgJSsFizWKVi +pCj3hAIgBAIQsNEPABnrEIo+K5JxKZKAq6oJqhH8IEQoACBWcImXLBY3KyIS+ZIOID0QKDD5FjAi +AABRMFizSCoSNywSMKpNJdQALMAC+sExYgAAWzApEjArGoD73AAIACBecG3JEi6QSP60ASACAkpw +9OB9YAICWvArEjAPAgArsAL56vQSgBAYMPkWNSwAIBmwLBY28AkHAEACQHAASGGYHC3A2P0UNCIA +IFLw/MD7IHACUHD8Fi8gBAIQsFtI0iocOPwKASBoAlhwW0h9KhIwA6kIK5Ao/AoAICkANuBtCAwt +kCmxzPTQGWACAkpwY//sKxIwrN4n5AErsAJj/4EAAAAAKyqo+hw4KgAgXrBbSGz6HDgjfBBYMPwS +LyoAIF2wW0hn+hw4IEACWHBbSBkc61svECIuECEtECAoECOYECsQJJsRKhAlmhIpECYpFgP4ECcg +MBBYMPgWBCAFEFAwWLpoHOtPLxAqLhApLRAoKRArmRAoECyYESsQLZsSKhAumhP5EC8gMBBYMPkW +BCAFEFAwWLpbG+tALLBMLBYu+7IUKgAgILBYsu0sEi4Z6rr8IggAMBB4MPQqCAB4EHAw9aQAIAIy +gqAvpAEupAL9HCAiAABisPgKECB+EFgwbYo1/wIAAgEARuAv0AAPDkP+nggOZAF8MP7ggC4AIH5w +//CAIAQCYzD/xAEh/AJa8P7EAiACAmtw96QjICMQKDDApfzrIRAwEFgw/BY0IgAAaXBYujNmVCH6 +CgUgMBBYMPzrGhIAAGlwWLouKWKOwIP5eVgAAgJRcPoiCA4B404QD+owDOowHusSGesTD884HesQ +HOsSCfstDbUoDrso9esQHgAgL/AM/yivu6W4C4s6C48SD7sDC08SD7sDCwtCD+owCOowD484Cfot +Dago/qooDgAgR/AM/yivqqWoCoo6Co8SD6oDCl8SD6oD/bsRCkABUDALqgIL6jAP6jAL+zgJuS0N +nSj+mSgKACBu8Ay7KKuZZpNUHeqtKRYtKdYULhItDo8SD+4DDl8S/qgRDhEAe7D/HH8uIAFwMP/8 +ES4JAEOwLvQALBCQwNH9EjYsAQBrMPvq2RzgAWAwLBSQLNTYLLA0LBYy+7IOKgAgILBYsoMsEjIf +6sr6EjUgChBwMPkQkCIAIGCw9CwIAD0QWDD7xAAg/gJocPIKBwBCAkNw8AiiAEICa3D4Fiwv9hBY +MNiQDpktC5ooCogICPgIKIAA+NQAIgAAU3D1n+NgAgJrcCscfyu8IfekASoAHNLQbQggL7AAKN3/ +LoD//4T/If4CUrD+tAAgAgJa8Pq7FXH+AmtwY//YJ8QD8/4zb+oQKDAAAAAqHH8qrCEroADAkPkW +MSAfADbgbQgMK6ABsZn0sAxgAgJSsGP/7AAAAAAAKRYx+swBIP4CWHD8EjEgQgJa8FiySiwSMRvq +mNMPscz8sDwiACBgsPwWMyoAICCw+7IQIAICUrBYskEtEjOx3fsSNSIAIGiw9CoIAD0QYDD8pAAj +WxBIMPALBwgAIE2wAElhAElhAElhAElhAElhAElhAElhAElh+xItIAAQSDD6FjggEBBwMG3qvQzq +MA3qMB/qfxvqgAzcOB7qfh3qfwvKLQ6kKP+qKAwAICMwDcworKqlpApKOgqMEgyqAwpMEgyqAwoK +QgzqMATqMAxMOAvILQ6EKP+IKAwAICMwDcworIilhAhIOgiMEgyIAwhcEgyIA/2qEQhAAUAwCogC +DOowBOowDEw4C8stDr4o/7soDAAgczANzCisu6W0C0s6C48SD78DD1QS/ogRDhEAJ/D/D0EEACAy +cPj/AgQAIBkw/0TbIAICSnAqEjgY6g8vEjb7hhQgEBBwMP702iAAWoKgKcql/wIABgBxzZD56cIQ +MBB4MP+kASB4EGgw/aQCIH4QWDD/EjYiAABqsG3qMG6zZCzw2wwIQ/iYCAxkAWAw+ICALAAgYnD8 +wIAgBAJrcPzUASH8Alrw+NQCIAICe/D3pCMgIxAYMPoKBSAwEFgw/BI0IgAAaPBYuUJmMDv6CgUg +MBBYMPzqLxIAAGjwWLk8sT2tItEPJ9QD8//Kb+oQGDDRDwAAAAAAAPP78m/qECgw8/+yb+oQGDDA +pfzqIhAwEFgwWLkvxy/RDx7p16WZKRYtKeYUY/ylAMCl/OobEDAQWDBYuSfHL9EPJ6QB8/92b+oQ +GDBsEAgmIhAU6XSWFIVuJ0JxiGckQoD36hAUACA9cCZgbviCDiWQBD1g9XAkJAAgKTAkQgcoFgH7 +cgoiAABQ8PRCDiIAAGFwWLGoHels/OlrG9AEPaD2Cj0qACAo8CakAPy8CAoAIG7wK7LBLMCA/BYC +IAICUrBYsZyKEsCw9XCEKgAgKrD6FgMqACAasPukAiAEAlKw+3IiIgAAYXBYsZKME6XFo1ompAIr +QAj8CgAgHQA24NlAbQgMLZAJscz00AtgAgJKcGP/7AAAAAD6rAMgEAJZMFixhC5ACPkKACAbADeg +BEoCbQgML6AJsZn08AhgAgJSsGP/7ACllfNaCAAAEEAwKKQEKEDo9IELYAgCKXArcIxqsR+jXPpy +JCIAAEswbbkSLaAA/ZQAIAICUrD00DFgAgJKcKtV81YIAD0QeDAvZAAuQOj8CgAgKwA3oNlAbQgM +KJDpscz0gBlgAgJKcGP/7PkKACoAIFswKaQAY//EAAAAACsK6PpsASoAIF0wWLFZLEDo+QoAIBoA +NyDaQG0IDC2g6bGZ9NAIYAICUrBj/+wAsp6uVfNWCAAAECAwJGQAjxQv8G5o8WcoIhMicNz7cjgg +PRAYMPiXUgIAAFGw93wGIgAAYLBYsUMc6Qb76QcaACARsCOkAAx8CyPAgPt7CwACAlKw+7LBIgAA +YPBYsTmiOPWCCAgAIDIw9IQCIAQCELDRD8BA8/+WZgAgGXAAACtyMCxwvPwWACIAAFGwWLEtjhCL +Ef5VCAA9EFAw81YIAYAQaDD6ZAAsACBu8CnQ8PwKACAcADZg2dBtCAwvkPGxzPTwCmACAkpwY//s +AAAA+CpwIAICUbD9FgUqACBG8FixGIkVK5Dw+goAIBkANuDdkG0IDCzQ8bGq9MAHYAICa3Bj/+yy +ra1Vo1YkZABj/wYAAABsEA4mIhAc6WeNIIlnjmAoYG75kg4gBRBQMPkWDiAwEFgw+BYAIgAAePBY +uGonIAcY6UIHB0H3FgonwAQ94Kh3KnI6xIL/AgAKAifGkCRyOfnotRREADUgmR3wCQcAMBAoMPmM +AAIAAEEwbZoCAEhhLDEKycX7MgQgoAJRMFiw7CwxCvAABWBgAiswACoiEwrbQfgKACIIADbg/wIA +AAEkhuDVgCsiCfoiCiQAIC8w9Q5BAGACGXAOPQwt3AT7qgwCBQB3cP8CAAoA4Z6QKyAWLgr/frEN ++iAHIAAQYDBboQFko8sZ6RcsIQcb6RYd6RP/PC8tQAFgMP9PFA3ABDsg/xYLLAkAazCcQBzpKIgg ++0YCICACUPCaQ/mJAgmABDog+UYELgkAR/D/RgEiAABo8PnpHRAFEFAw+UYHIDAQWDBYuCT7Eg4g +QxBIMPlEICBQAlEw/yITIAYQYDD4CgAggBBoMPhEIiCBEEgw+EQjLi0BfDD/nTgABxBwMP7eAgH+ +Anvw/+04A1IQQDD9FgwqACBG8FiwpitiEYpvK0QvC4sUK0QuW0qyKkQzBYgU+okUAAEQaDAtRDUp +RDIIjxQJiRQPjhQpRDEJiRQpRDApYhL5RDsgABBoMC1ENAmJFClEOo0cCYkUKUQ5CYkUKUQ4iR0q +IhclRCcvRCUuRCT9RCEgABBgMPxENyAAEFgwK0Q2KkQ/KEQmCooUKkQ+CooUKkQ9CooUKkQ88AkH +AIACQTAASGGPKS4iFqP//yYJLgAgG7AuJhaNGy12OSsgFiwK/3yxCvogByIAAGDwW6CKiif7CgIg +ABBgMPqsICACEGgwW5leKyITLPp/DLsB+yYTIAAQEDDRDwAAAAAA+iwAAgAAWPBboLVkrjLAINEP +ix4tKoCtuy2w2WTQRf4KBy7ZAVQw+xYJL/71/5DApfzovBAwEFgwWLfDjRkt0Nn/AgACAKj/UMH4 +/wIACAC5a9DAUCwxCmP9vMnO8/23YgAAKjClS/u8ICIAAFCwW/6TLDEK8/2fYgAAKrClRfUWECBA +Ailw+iwAAgAAWXBb+80oYG4vEhDTD/ysAAAArQYgGOihLYCAatEfr6r7giEiAABCsG3ZEimwAPmE +ICACAlrw9JDBYAICQjAb6HYe6H38Eg0kACBvMP9fCAA9EGgw/fQgICACQHDyDAcCAABSMPAKogAK +EGgw+hYIL/YQYDDZsA27LQy6KKqZqekpkAD5hAAiAABSMPW/5WACAkIwwLD7pAEgIAJYcHq7IC2w +AC6N/yzg//3k/yH+AlKw/LQAIAICWvD6s+Nx/gJCMCgcECmAAPwKACARADZgKoABscz1r/dgAgJC +MJwf+vwhICACWHBYsAyJH6WV8/7XYAQCKXAAAAAAAAD7CgAuACBqsCvkIGP/NNog9UwIAgAAWbD8 +zCAgARBoMFv8jY4ZLeDZLwr+D90BLeTZ8/6YYgAAKrDd8PVMCAIAAFCw/MwgIgAAWbBb/IOOGS3g +2S8K9//dAQDvEHgwD90BLeTZ8/5lYgAAKrAAAAAA+1wAAgAAULBb+fDz/k5iAAAqsACIImWN/Isa +2iD7vBgiAABgsFuga8Ag0Q+LGtog+7wSIgAAYLBboGbAINEPAGwQCCggaCkKi/UiECASBEowwCDR +DwCONMB0+eg2EAAQUDD2CgAgASWDoBzoM/0iACAwEFgw+hYAIGACIbD6CgUiAAB5MFi3MosiKiAH +/egJEL4CObAHRxT1v7VqIAFQMAyrEa27LLI6mhT0FgUqAU4/ECSyOfznghKRADUgKCIT/yIJKAgB +QDAMiAoogoAuIgoGhgj/7gwAYAIxsP8CAAoA3DeQKyAWLwr/0w9/sRj6IAcgABBgMFuf2h3n7hzn +cPSiWWD/EHgwLiEHGOfrDg5KDO4RCO4CnkCKIBvn6fjn5xmABD6g+0YCKAkATfCZQSsiEy4hGvnn +3RoJAEKw+4hACkoBXDD+RgYrYAQ+4PyOCgmgBDog/uKAKAkAWjD6RgQoCQBKMJhHDm4M/kYFICAC +c7CeQ4spKiIW9rsID+AQSDD7JgkqACAysPomFif/Yc0QFudDKUwg8AYHAAQQUDAASWEASWEASWEo +QCEpCoD6RCAoCQBKMChEIStSEguMFPyKFAACAnLwLlYSLEQ6K0Q7CokUKkQ5KUQ4KCIXKEQ/CIgU +KEQ+CIgUKEQ9CIgUKEQ8LjIE+zIFIAAQUDD+iBQAAGeDoC5ENypEJypEJipEJSpEJChENitEMwiM +FCxENQuLFCtEMgyMFCxENAuLFCtEMQuLFCtEMCpEIwqOFC5EIvAGBwCAAmEwAExhKyAHCwtBDLsR +DbsIJ7Y5KyAW0w9/sQcqIAeMFVufZoon+woCIAAQYDD6rCAgAhBoMFuYOisiEyz6fwy7AfsmEyAA +EBAw0Q8AAAAAAPosAAIAAFmwW5+RHeeE/OcGHjoANqBj/Z8mkICxZgYIQfh6DAAAEHgwCPo4pq3z +/aBmBQBTcAAAHec3/OcVH/8QWDArRDcsRDb9RDUg/xBwMC5ENIpfsaqaX1tJPipEMwqMFBvnjixE +MgyMFCxEMSOwgCuyIfyMFACgAlEw/EQwIgAAYPBYryP952UQAgJw8C5EJw6OFC5EJg6OFC5EJQ6O +FP5EJCD/EHgw8/7yYAAQUDCLFNog+7wYIgAAYLBbn5/AINEPixTaIPu8EiIAAGCwW5+awCDRD2wQ +CCMiGdMP0w8vMAUkCnL+MgAqAD55EPoKBSAwEFgw/ObuEgAAaPBYtm0vMAUoCnP08RRwABAQMPkK +dSYAd0fQ/wIABgB+T9DApfzm5BAwEFgw/jIAIgAAaPBYtmHKLIM40w8lMhkc5qwiMAf9UAQgBRBQ +MP5SACAwEFgw/1AFIiABEDBYtlYoUAV4QzzRD/0iACAFEFAw/ObTEDAQWDBYtk8vMAX5CnAhyAQj +8Hnx3PoyCCAAEFgw/AoAIAIQaDBbiZfRDwAAAAAAHOaUj1gtUASOUP/yACAFEFAw8hYAIAAQQDD4 +FgEgMBBYMFi2PPo8AAAIEFgw/RwQIgAAYLBboVn+5ocQUQA2oI0wwMD8pgEsCQB3cJ2gG+aCDCkR ++BIEKAAgXnCYkNEPgjgvCnQvNAUvJAUvMAXz/wxgARAQMIk4KAp3KDQFKJQFLzAF8/72YAEQEDAA +2jD85nMQABBYMFuhJNEPAGwQFhznGI0gLiAFLzIAKDAF9BYBIAUQUDD4FgAgMBBYMFi2FRvmaxfm +afwyByAEEHgw+eZkEAAQcDD25nsRgBBoMPzCDiCSECgw+p32ICwAPSBvRAf/AgACAEuRIGhERcAg +0Q8oMAUpCpB5iVIS5lWIPikicSQieCIigPmg0SgAIEow+UQRCZAEOiD0JAgKACBAsP3ICAAAfX5Q +KQqA8AD0aAAgTTCLKCqyE8TADKoC+rYTIAAQEDDRDwAAAAAAAPoKBSAwEFgw/OboEgAAaTBYteku +MAWLOvqyCCYAlC+Qiihb/23AINEPAAAAAAAAAP1MAAAFEFAw/ObdEDAQWDBYtd0uMAWLOvqyCC// +qiuQGeZJKKITjTCPoPygBSgJAEowKKYTnBAc5kcpsgD5FgEgAxAQMPiwBSAFEFAw+BYCIDAQWDBY +tcyLN4u+KhqAqroipJIsMAX/AgAP/4KrEBTmxBzmOfjmFx+VEGgwLTQFLMDRKIJ4JEKHCYgR+EQI +AAC8fxApCoDwAXJoACBNMAAAKSqAqUktCmUthJGIoCcWFvsWFCmABDog9hYaKAkAejAoFhUtkAcr +kS4NDUEA3RENuwIGuwIrFhgJ6jAuFhspFhkpzQL3CRYA4AJYcADLigQJiACLigIJiABLigAJiAAL +iiscUPwKBCACEGgwW5MiwCDRDxnmDCiiE40wj6D8oAUoCQBKMCimE5wQHOYKirD6FgEgAxAgMPmw +BSAFEFAw+RYCIDAQWDBYtY+LN4u+KhqAqrokpJIsMAX/AgAP/0krEBTmhxzl/Pjl2x+VEGgwLTQF +LMDRKIJ4JEKHCYgR/8cPdAAgQTApCoDwAAloACBNMCkqgKlJwMAspJEa5dGIMJcWmhT4iBEABBBQ +MPYWCigJAFIwmBUvkAcukS4PD0EA/xEP7gIG7gKeGA3qMJ0ZnBv5vQIgYAJQcA4JiAHKigwJiAGK +igoJiAFKiggJiAEKivscECIAAFDw/AoEIAIQaDBbkuVj/ecpKoCpScDALKSRGuWziDCXFpoU+IgR +AAQQUDD2FgooCQBSMJgVL5AHLpEuDw9BAP8RD+4CBu4CnhgN6jCdGZwb+b0CIGACUHAGCYgAyooE +CYgAiooCCYgASooACYgACor7HBAiAABQ8PwKBCACEGgwW5LHwCDRDwBsEAQrMAX35bUQABAgMPb6 +kCCSEGAw9QqVJgBU5tD4CpAmAFCu0PJyiS4AYELQiTj6MgkgDgA2YJmgiziasZQ4lDkocnWKN4Uw ++qIOIAAQWDD4VQwFaBBgMFitzpQ4lDmUOpQ7lDyUPZQ+lD8kNhAkNhEkNhIkNhMkNhQkNhUkNhYk +NhckNhgkNhkkNhokNhskNhwkNh0kNh70Nh8iAABZcPY0BSAAEGAw+iJYIAEQaDBblikrIlqwu/sm +WiAAEBAw0Q+OPS0iE8f9D+4B/jYNIDoAu3B8sTP0NgogHAgq8Ig98goBIABffhDAINEP2iBbPMYc +5gQqIhMrMAX5CpIqAEBisPomEyGgCErwiTgicon9MgkgDgA2YJnQjjid4ZQ4lDkocnWKN4Uw+qIO +IAAQWDD4VQwFaBBgMFitlpQ4lDmUOpQ7lDyUPZQ+lD8kNhAkNhEkNhIkNhMkNhQkNhUkNhYkNhck +NhgkNhkkNhokNhskNhwkNh0kNh70Nh8iAABZcPY0BSAAEGAw+iJYIAEQaDBblfErIlqwu/smWiAA +EBAw0Q8b5dkc5UD95dgSAABQ8Fs8ttowWzyZjjeO7i7tAyTkWSQ2ESQ2Ff0yDSACEGAwLDYTIjYS +8jYULAkAF3D9Ng0gABAQMNEPAABsEASMJw8CAA8CACzCDivCwPO4AQoAQCLw+KEHcgAAKLAjwsb8 +5cAQARBoMPO+AQAAEHgw/q4MADAQWDD+3zgABRBQMP08AAIAAHEwWLSzGuUGZDB8KaKAK6J4L632 +L/DR+bsRAAEQMDD/9xR4ACBecCmSJ4meKZIQ8AAOYf4CSnApkqeJnimSELCZ8qKGIBEANmCCJG2Z +B4gic4EmIiwowNDy3AAANgA3YMomLiEG+goFIDAQWDD85ZwSAABosFi0l9EP8//aYgAAaLAAAAAA +AADAIPP/12//EHAw2lD85SoQOhBYMFtGo2SvvZOplKqWqIlSZZ+yK1AH+wtBAgAAUXD7vBgiAABh +cFudpWP/mWwQEhzlhoMpjSD5IAcgBRBQMP4gBSAwEFgw/yITJOABKDD2TP4gARBAMP8WACYFADIw ++CIVJCABTDD4FgEiAAB5sFi0cisiECwiEfYWGSIAAFDwW/+n9qwAAAAQODD5ChQhegC2oCoiE/8C +AAoBRVJQ9yYTIgCdASCKJ/x8AAABEFgw+qwgIAEQaDBbleZgAR0o0QvAnvjzCnAEAmtwLMwBfJvs +GOVfKSEllxiXHCcWEfTPEAzgAVww8wtGDOAEP2D/vBEMCQB/cPTvEQzgAWAw/BYPLEAEOyD/Igss +CQB7MBfk3CmlAvkhJC4JAEfwn6AoIhEppQMvYQaYoigiEJijKSAH9xYOL8AEP+D/3QIOYwEcMP/d +AgggAUww/+VCGeAEPmD8EhgoCQBmcBflQBjlPv/dAg2ABDsg/aYEKAkAZnCZpS8iFfxhByABEEgw +KRYQ+AoGLgkAR/CYHZ+nLWAT/RYJJgCHvxAX5TH6FhYmCQA/MPcWCyhIARgw83lACZAEOiDwmREI +CQBC8PocICgJAEow+BYKIKACWHBbkTFkoNnApfzlJBAwEFgwWLQXjS7I29og+yIPIAEQYDAL0AAs +Ig1kwAr7Ig8gABBQMAvAAAIqAlgBCcAg0Q8A+iwAACgQWDD9HBAiAABhcFufKfShGWEAEEgwiyr8 +5JsQDRBoMPuLUgABEHgw+xYYLgUAXnD/yldyAABz8PAACmAAEFgwAM8afvoJsbvwsQQJ//pfUB3l +AS8xGC3Sf/MxFiAAEGAw/RYXIA4QSDD90QsglgA34P8CAAv/J2/QLRIXwMDz/jtgBAJrcAAAAAAA +8//BYAAQWDAqFhZj/vkAABzk8CkSFSgSFi4SFPCEBA6ABD5gn4kJ7hieiC0SFJ0Q+RIVIAUQUDD5 +FgEgMBBYMFiz1y0Kci0kBRzkJgxbEfoSBCoAIGbw+rYAIlYAOSCKJ/sKASAAEGAw+qwgIAEQaDBb +lVHSoNEPL1rc/AoAK/7c79Bj/2fAINEPALGr/CwAAgAAULD7JhMgMAJZcFuc4SsSGfzkzBIAAFCw +W57CwCDRDwAAbBAQHOS+JCAHgymNIPgiEyBxEHAw/iQFIAUQUDD4FgAgMBBYMPgiFSAAEHgw+BYB +JCABIDBYs60rIhD8IhEiAABQ8Fv+4/WsAAAAEDAw+QoUIFoAtqAqIhP/AgAKASzSUCYmE40uyNva +IPsiDyABEGAwC9AAjC3IyfsiDyAAEFAwC8AAAioCWACV/yIAIgAAcLD85KQQBRBQMPsKMCAAEGgw +WLOSIgoABgAAAPosAAAoEFgw/RwQIgAAYTBbnq33rAACCQA2oI8qwO385B8RABBQMP+PUgABEFgw ++goAKgUAfrD9vAAIALbfEGAABQDIGn2KCbGq8KEECf/6V5Ac5IYuMRgswn/zMRYgABBYMPwWFiAO +EEAw/MELIUEAN6B84x8sEhbAsPAAEmAEAmMwACnBC8CO+eMJcAQCYzCxu3uL7ZYY9hYML0AEO2D2 +FhEoQAQ+4PvkaxjgAVAw8wpGCOAEOiD/rBEICQBKMPkiCyzgAWAw/BYPIAYQMDD2Fg0sQAQ7IP4h +JSwJAHMwLnUC/iEkKAkAXnCZcCsiES51AylRBptyLiIQnnP7IAcpwAQ+YPmIAghjARww+eRSGAkA +SjAW5FL+5FEaIAFcMPmIAgvgBD7g/LsCDYAEO+D4dgQqCQBm8Ct2BfwiFSABEEAwKBYQK1EH/uPP +HAkAczAuFg4sdgcpUBP5FgkgFAQy8BbkQAa2AvYWCyhIARgw83lACZAEOiDwmREICQBCsPscUCgJ +AEow+BYKIEACUHBbkEHKqcCl/OQ0EDAQWDBYsyhj/hIAAADz/qZgABBQMC5a3PsKACv/b+eQY/63 +AAAoEhUc5CsuEhTwhAQOgAQ+IJ95CO4YnngtEhSdEPkSFSAFEFAw+RYBIDAQWDBYsxQsCnIsJAUb +42MMShH5EgQqACBasJmgY/3UACtMGP2sASIAAGCw/SYTIgAAULBbnCnaIPzkFBAAEFgwW54KY/2t +bBAEhSAb5BEd5BIkISWKKijSnfPSsyAAEDAw+0QICOABVDD4VQwAPAA2YMskjif4+v8vwBB4MPYm +ByBAAmOw+OYALABAezD25RQggAJjMJzp/OYIIABhhmD/AgACAG8CYJoqK9JM/iIRIDwANuD/4zsQ +ABBQMG0IKSjybyzSraioCYgRqMyMx4zOKcK//pkPcAICUrApwsKwmSnGwivSTHurAmP/z5YoJiYJ +JiYKJiYLJiYMJiYNJiYOJiYPJiYQJiYRJiYSJiYTJiYUJiYVJiYWJiYX/OPfEAUQUDD7CjAgQBBo +MFiyyvoKcCIAAFlw+iQFIAAQYDD6MlUgARBoMFuT1/oyViIAAFkw/AoAIAEQaDBbk9PRDywyU/oi +CiAQAluw+8YBIUwQeDD85gIuACB88J/jKzZTY/8lKTJR+iIKIBACQ7D4lgEhRBBYMPnmAioAIFzw +m+MoNlFj/wIAAGwQDCshNRjjvIMnwFL8CgEgABAgMPMyDioAHd4QKiAFKAqS+QqVJgCMxpB5oQPA +INEPJSYTLCYSLCYUii0kJhH0JhUgAgJq8P0lNSAAcnqQ0kDRD9ogWzpXjy0Z4ugd4ur4+v4hgBBQ +MP6d9i4AQEfw/yYNKgAgUPAlpJIrkngpkoD/4vcSgBBgMP7g0SuQBD7g9KSRKAAgXnD6IgAggBBY +MP8WBiAgAH+w8AAKaAAgXnAAAAAArJn9FgAgBBBYMPzi0RuABDqg/BYCKgkAWrCaESiQBy6RLggI +QQCIEQjuAg/uAp4UDeownRWUFyk9AvcJFgBAAlBwAMqKBAmIAIqKAgmIAEqKAAmIAAqK+iwAAgAA +WHD8CgQgAhBoMFuP6PQlNSAAEBAw0Q8AAAAAAAD6LAACAABY8FgB38Ag0Q8A2iBbOhzAINEPAAAA +bBAE9CAtYJUQQDCJPYQ3KjAF+/r9IJAQYDD0Qg4oAEBecPk2DSBOBEKwfKEfwCDRDwAAAPoKAiAw +EFgw/ONdEgAAaPBYskfAINEPAAAc41kuIhktQo4jJhD+4gkgBRBQMP42DCAwEFgwWLI+L0KOHuNS +/8hRAAUQUDD0iBAOAEBz8P0iEy4JAEOw/5hSDjcBfDD5/xAIcAQ6IPjuAgwJAH9w/ONGHAkAd3D9 +JhMgMBBYMFiyLBviqyMgB/njQRABEGAw/CYXIgAAULD5JhgvihBAMPgkaCIgARwwW5Co/SITIgAA +YLD/CgAgMAJY8P+lCiCAEHAw/6YELAkAd3D9JhMiAABQsFubOMAg0Q8AAABsED4jIhmDN4M+LTAA +/Q1FAD8QKDD4CiMsASmDYPfieRYBLcdQ+QokIIAQMDD50SdwJhBAMPkKMiYAYEdQ/wIABgENz1B1 +0QzAovzjGhAwEFgwWLIA0Q8ALTAYLzAZ/jAaLYAEP2D1IAcsCQB/cP8wGy2ABD9g/iIXLAkAd3AI +3RH0IhAsCQB/cPUFQQ4AfHNQse4uJhcuMAH84wcQBRBQMPsKMCBAEGgw/e0BDgBAM7BYsej6LAAA +ABBYMFuQaygiEy9AbvaIAgIAADqw+CYTIbgAN+D54lEQABBQMCp0Eip1CJlyiyJlv2raIPwsAAAw +AllwW5r40Q8sMBgtMBkvMBr0IhAtgAQ7IP4iFywJAGsw/TAbLYAEOyD1QgcsCQB7MAjMEQ3MAvVS +DiASCHMwse0tJhcuMAJl7xnaIFv7TS9Abv8CAAH/hx/gEuIVK10C/BpQIgAAUHBYqlUY4jIa4jIr +IngogNEqooPAkvkUECuQBD7g+6oIAADd/hDwAbhoACA2sIJHE+IG/OLMEAIQUDDyIg4gMBBYMFix +rhriIhjiISsyeCqigyiA0Qm7EfstAioAIFqw/4cJeAAgNrBgAAYAACkqgKmp+OH4EEcQUDAqtBEa +4fWPQCcWaigWZPj/EQAEEEAw+hZmLgkAR/AvFmUukActkS4ODkEA7hEO3QIH3QItFmgM6jAsFmkp +LQL6HQEgABBYMPsWayD+AlKw9wkWAGICUrAAyooECYgAiooCCYgASooACYgACor7HQEiAABRMPu8 +fyAEEGAw+7wRIAIQaDBbjwPRDwAA+iwAAgAAWPBb6VnRDwAAAPosAAIAAFjwW0KC0Q8AAAD6LAAC +AABY8FvqBNEPLDAELTAF+DAGLYAEOyD+4eUcCQBrMP8wBy2ABDsg/TABLAkAQzAIzBH7PDAsCQB7 +MP7MAQDMAONw+kwAAAAQaDBb5bMuMBQvMBX4MBYvgAQ7oA/uAv8wFy+ABDugCO4CCO4RD+4CnnQt +MBAuMBH4MBItgAQ/YA7dAv4wEy2ABD9gCN0C/+HTHYAEP2D/dgIsCQB3cJ11Y/3CAAD6TAAAARBo +MFvlmmP9ogAAKSqAqakY4Zz64ZsQABBYMCsUEY9AKhZWKBZU+P8RAAQQQDD3FlouCQBH8C8WVS6Q +By2RLg4OQQDuEQ7dAgfdAi0WWAzqMCwWWSsWWyodAfqscCIAAEhwDgmIAcqKDAmIAYqKCgmIAUqK +CAmIAQqK2kD7HQEgBBBgMPu8UCACEGgwW46r0Q8AAGwQBMCl/OI/EDAQWDBYsSIpIhEoPCD6CgYg +GAA2YImXiZ4pnDBtqQUACIYASWHAINEPKSIZiZcqMQuJnr+qCkpL9a/gYGACSnBj/+EAAAAAbBAM +GOFkKYKAK4J4KI32KIDR+iwAAIAQYDDzOjkLkAQ+4P+HDHgAIF5w8AAJbAAgYnAsKoCsnP3hWBAU +CBqwiztgAAIAx7/wDQcCAABIcABJYQBJYQBJYQBJYfIEFgBAAkhwAEljAASGAElhH+FNGeFLiKCZ +Ev8WACAEEHAw/+FeGYAEOiD/FgYsCQB2MJ0RKcAHLcEuCQlBAJkRCd0CD90C/RYEIgAAY7AJ6jCZ +FSUUMSsVHP0KAiAAEHgw/xYHKAkAajD4FgkiAABYcFuOYtEPAABsEAQT4S8oIQwkMnEjMoCoRAlE +EaQzhDcoIBOETsmO9UwIIAAQWDD6XAAA4BBgMFipdNpQ/CATIEACWLBYqWQoIBIPAgBkgCMpCuj5 +RAgAABBYMPpMAADgEGAwWKlpKy0B/CASIgAAUTBYqVkq+oX6NAUiAAAQ8NEPAAAAbBAEFOHZKSEM +KEJ1I0KEqYgJiBGoM4o39EKKIAAQWDD6og4jMBBgMFipVipCVyshDPwKACABEGgwW5HDG+FG+yUM +L/8QUDCaO9EPAGwQBBXhxiRSiipCVyihAiMhDMiJ2zBbkdnIp8Ag0Q/AINEPAPpCVyIAAFjw/AoB +IAEQaDBbkbEY4PAognElUoSoOAmIEahVhFcsIBOETmTACvssICAQAlEwWKkrLCASyMwqCuj7LQEq +ACBRMFipJoxQnCWTW/MlDC+FEFgw+1QFIgAAEXDRDwBsEATySQgCAAAwsNMPbUoSJTAA9WQAIAIC +GPD0UAZgAgIxsNEPwIAolADRD2wQCBrhjSsykiQyky6irf2inCFIEGAw86KzLAAgYPD4okwggBB4 +MPfBfi2QBD9g+jJVLAAgd3BtiRCO147uKOK//wIABgCGJhCv3cDwnxYooQJkgQwpMlYpkQJkkQOc +FZsUW42tGOC3FeF00w8ognAlUq2qiPmIEQIAADKw+jJWJAAgRXBbjaQf4XwrUAeOFowUGOF2KeAH +J1UklluSX5hcnlkkVhEsVhD04XEQ/BBgMPRWDioAQGbw9OFuGCABTDD84W4YCQBecPlUByAwEFgw +/eAHJAAgIrD/Vg0gBRBQMP7gNSIAAHiw9FUlLCABbDBYsEEX4VEtMlUc4WEuck0t0QKVEPhSACIA +AHmw9BYCIAUQUDD4FgEgMBBYMFiwNvQKAiA+ADVgLyBu/goBIgAAUTAP6jn8CgAgAE0GoPP66iIA +bAKgyjDaUFv9J9Iw0Q8p4sL9FgYgAgJKcCnmwmP+7MAs0Q8AAAAAHOFG/VIAIAUQUDD+UgcgMBBY +MFiwHiogbhvhQZUq+VIKIMQANqALmwKbWo4tjRX93QEuCQAjsJ4tLNAhL9Ai/tAjLYAEOyAPzAL9 +0CQtgAQ7IA7MAgjMEQ3MAvxWFSIAAFFwW/xP0qDRDy9ysyvyUygaTKj/f7FFibGOsJ6QjbAp1gEs +tgD8tgEgVAA24Cm9/4hQKJY+j1ojvPjzVgcuCQBX8J9a8/8zYAAQGDAAAAAtcrMr0lEuGkSu3X25 +C/P/Gm/0EBgwAAAAAI+xibCZ8Iiwn4GcsPy2AS+0ALbg8/76YAAQGDCZWmP/PwAAAGwQDBjgOh/g +PB7gOimCgCuCePiN9iIAAFCw+IDRIAQQaDD8KoArkAQ+4PQ0ESgAIF5w+wqAIBgAfjDwAAZoACBe +cKyZjKAY4EKfEP4WAi2ABDsg+BYGLAkAazCcESuQBy+RLgsJQQCZEQn/Agj/Ap8UDuow/hYFIAAQ +aDD9FgcgQAJIcAYDiADJigQDiACJigIDiABJigADiAAJitsQ/AoEIAIQaDBbjULRDwBsEATy4NgS +AAAYsCUiiihSWCiBAvYihCCGEFAw9IEnYCACILApMgUoInUJiAgJiBEIZggpYAV6kQUq+oYqZAUq +UlhbjPQkQnIiIoSqRAlEEaQihCcf4DqETv8mDyABEDgwJyYU9yYSL5AQcDD+JAUgAhBoMC0mE4w4 +/OxRAgAAWrD8JG4iAABRMFtHBfpNAi//EEgwKSYQ+DIFIgAAWPD2JgsgABAYMCMlNfgmDiFQEGAw +WKgnKkKIDwIA9KYNcAIQYDArIG8MuwIrJG/zpg1wBBBwMC0gbw7dAi0kb/KmD3AIEEAwLyBv0w8I +/wIvJG8KjFf1pg1wAxBYMCkgbweZAikkb/giAC4AB+bQLSBvweAO3QItJG8rTQEssZIsJTQrsZMr +JhYqQosqJhgpQowpJhcoRoYvUlqTKPMmCSACAnvwL1Za0Q/AINEPAGwQBhzgjv0yAiAFEFAw/jID +IAAQWDBYr2SGMogwGeCI9DIDIABGKhD2mxVwDRBgMMbK+lwAAgAAWPBYrofAINEPiicAQAQpIHcM +DBv6og4gARBYMP/HCnIAADpwLSANZd/NAEEE8LsaAAICcbD7FgAgagA1oPpPCggJAE7w//0FKOAB +TDApJHcu9ej+9ekgKwA14N1A/mwAAAUQUDD84GkQABBYMFivQPP/hmAAEGAw8/9+YAAQYDAAAGSf +1cCl/OBiEAAQWDBYrzgb4GD84GASAABQsFisrGP/t91A+goFIgAAMvD84FsQABBYMFivLikgd8ev +CmoDCpkBCQlH+SR3L6YANeBln57ApfzgUxAAEFgwWK8l2iBbNuRj/4kAAGwQBoQnFd/kKSB39EIO +IAAQGDAAMAT5ChsAABAwMPRNBSAEEDgwf6dmK0HosLsLC0/7ReggWwC24PkWAiJ2ADzgLCAN+iAM +IGsAtyD5FgIrgAQ6oBnfbgoIRwmICpgRKIKYCooUmhALgAAKCUH4kV9iAABasGiTWihS8NogC4AA +KkHo0w8PAgD5EgIgdwA2oPZsBCAIAilw9EwEIAICGPDwMAQB/gI58PkKGw96ALXgYABuG+AiiiAr +sn+ZEguqDPiqEQABEFgw8/+IagkAWrB8pxqNJ43e+RICLAAgN3D93QYgARBgMCzVaGP/ogCIESiC +msec+hIAKgBATvALgABj/3QqIHfwMQQAARBYMPC7Gg//EGAwDLsDC6oBKiR3Y/9tG+AC/OACEgAA +ULBYrE7AINEPbBAEY//8AABsEATAovzf/xAAEFgwWK7PwKZbkcDAINEPAAAAbBAEwKT83/kQABBY +MFiuyBrfPCig0XuHQh7f9cCw/PrnIeAQaDD+4oQgFBBIMG2aDy+hdAz/Af3xCHAEAlKwsbvHuwCw +BP4IGQACEFAw+AhAAAEQWDAIujlYdMLAINEPbBAEwKT83+MQABBYMFiusMAg0Q9sEAQe3yId398u +4oYf33D90n8uOAFwMA/uCi7i9P8KZCwAC2uQgieCLiItBv8lbiAAEBAw0Q8AwKH839MQABBYMFiu +nsClW5GPgieCLvItBiBkEHgw/yVuIAAQEDDRDwBsEAQa38r6on8iAABYsPw8AAABEGgwW4+l0qDR +DwAAAGwQBBrfwiqif9sgW4/A0qDRDwAAbBAEFN+9wDH0Qn8gABAQMChBAyRBAghEDAQyONEPAABs +EAiUEZIQ+9+1EgAAePD+XAACAABpsCwaQCy2ECuyEWSyIBfe4fe3AQABECgw9xYDIgELQtDAkPoK +ACAAEGAw8ACUYAAQGDD3CiAijAA04Px3DAAAECAw9xYCIswANeCGEicKAPBxBAABEBAw8FMaAf4C +MbBtaQ/wIQQAAgIQsPBTGgQJABkwA0MCgvAAwQT3EgQmAEBA8ABmGgYiAvPiACYAQDjwkvAAZhqC +EvYSACIJADTwk+AAIAQHBxmCEQgDGSNmAPcmACAAEBgwLKzg/wIACAC4BmAAkQQAVhr2tgEAIBA4 +MP5sdmACAkpwiBP/AgAKAE410CbQJWSBxScK//8CAA4ApzmQJtAksqr4ChEmAPSBoPcKhSYA9EWQ ++AoBLgCYuZCYFMCDZK+i8hIELf+LkqCD8ADBBIzgAIYa8CIaAgkANPDz9gAsCQATMPzmACABEBgw +8/91YgAAYrAAbmRQ9xIDJABMlaAi0Bwo0Rb0cZRmBAEQMAlnEQeIAvgWBCAQAlKw8/+fYP8QQDAA ++BoALogBPaD/AgAKAF42EIfY9whCBkMBPDCXFPP/emAGAlKwbmJw/wIAA/+KlaCH2PdoQgZJATww +lxTz/1tgBgJSsAAAAAAA+AqALgBOQaD/AgAL/3Y2EIfY9+hIBxcBPDCXFPP/MmASAlKwAAAAAP8C +AAAQEEAw/wIACgBCRaD/AgAL/142ECjQJyfQJpcU8/8GYBACUrD/AgAB/1IdoIfY98hABg0BPDCX +FPP+6mACAlKwwCDRD3+/B/8CAAH+89rQxirRDwAoKgD/AgAP/zjBkCfQHPdoQAYHATwwlxTz/rZg +AgJSsP8CAA3/Kh2gKNENJ9EMlxTz/p5gIAJSsP8CAAn/HhmgJtAcJ9EUBlhAAIgR+NEVJgkARfD6 +rBEmAwEwMPcWBCcABDmg8/5qaAkAMjAn0CT3FgQiAABBsPP+V2AQAlKwAIYQhGAAwQQAhxr3EgEk +CQA5MIIUlGCGcAAiGgJmApZwY/3RwHOXFGP+JcCCmBRj/h4AZxEHiAKYFCjRFwInQPqsEScABD3g +8/4HaAkAOjAA8/1fYAAQGDBsEAT3CrAggBAwMPN2OADAECgwpWXyVjgB+gIRMChsQAKGONJg0Q8A +bBAEFd7h0w8kUlUlUqn4GgAl8AQ5IPVFCw4uAL0g9IgMAAAQUDBtiQcpUQBykQO4VdEPKlUBmlEq +VQDRDwAAAGwQBB/e0SnyVS7yqcDQ+xoAKfAEPmD+mgsOvAC+YAm7DG25HCuhANyg8rE1cgAAQnD0 +sDxo4AFMMPrMCCACAkow/PKpIDMAN2AtVAAO1gsM3AsiZQAjxQH0xgEgARAQMNEPI6UBlKH5VAAg +ABAQMNEPDZ04Y//BAMcv0Q9sEAQX3rLTDylyVShyqfoaACnwBD5g+JgLDjAAvmAJqgxtqQ0rgQBy +sQv5nAEgEAJCMMcv0Q8jhQGUgflUACAAEBAw0Q8AAABsEAQoIASKM/wKACAPEEgw+opXABAESjDA +INEP/CRUIBkANqAtIhQf3pgr0QAe3fEPuwEOuwIr1QCIIisiEyoiEvwmEi/+EEgw/CYTKABASjD4 +JgIgABBgMFisgMAg0Q9sEAQoIQcZ3okICEoMiBEJiAKYMIcg9t6GF4AEPeD53icWCQA9MJcx8AYX +ABACEPAAAoqVNfk2BCAwAhDw0Q8AbBAE+zIDIgAAaTD6IgcgABAwMPYkJyIAAGGw+wVLA/ABXDD7 +TAAAQAJSsFuOvisgJhreD/QKASDMADTgDLkRqpkskjr/AgACAGNHICqSOR/eZ/zeZxC4ADagLiEH +Dg5KDO4RD+4CnqCNIPjdEQADEHgwD90C/aYBIBACWrDwDBcOEAQ44AALivvd/RbAASww+AoYL38Q +YDD4pgUsBwEsMPghGC1QBD9g+6YELABAYXD7IhEmwAQ94PciEC4JADuw/SIALAkAazAIKBSWqZ6n +/t5JHQAEOyD7pgspAAQ6IPymCCYJAEXw96YKLAkAd3CdpowiBMwCnCL/ljkgABAQMNEPAAAkJFRj +/zEAAAAAK7wY+iwAAgAAYLBbkD8sICfIwsAg0Q+KJ8Cw+qwgIAEQYDBblSoe3jGeoIwgAD0R+94v +HAkAbXD7pgItgAQ7IP2mAywJACMwnKH0JCcgABAQMNEPAABsEA4uIAWLKiMKlfqyCCAMBBuw0Q8c +3iEpohONII+g+KAFKABAZnApphOYEIywnBEqsAX83hsQMBBYMPoWAiAFEFAwWKzZiyeLvioagPq6 +CAABEHAwLqSSLSAFc9m0HN0lLfqSLSQFKcKALcJ4LM32LMDRCd0RrZn93SIQHgB/MC4KgPAACWgA +IHZwLyqAr5nA8C+kkYggHt0Z/hYGIAQQUDD9FgQpgAQ6IPrdKxgJAFIwmBWaGiyQBymRLgwMQQDM +EQyZAgqZApkYCOownxuYGSm9AvcJFgBgAlBwAMqKBAmIAIqKAgmIAEqKAAmIAAqK+xwQIgAAULD8 +CgQgAhBoMFuKLdEPAABsEA4uIAWLKiMKkvqyCCAMBBuw0Q8c3REpohONII+g+KAFKAkAZnApphOY +EIywnBEqsAX83Q4QMBBYMPoWAiAFEFAwWKyXiyeLvioagPq6CAADEHAwLqSSLSAFc9m0HNzjLfqV +LSQFKcKALcJ4LM32LMDRCd0RrZn93OAQHgB/MC4KgPAACWgAIHZwLyqAr5nA8C+kkYggHtzX/hYG +IAQQUDD9FgQpgAQ6IPrc6RgJAFIwmBWaGiyQBymRLgwMQQDMEQyZAgqZApkYCOownxuYGSm9AvcJ +FgBgAlBwAMqKBAmIAIqKAgmIAEqKAAmIAAqK+xwQIgAAULD8CgQgAhBoMFuJ69EPAABsEBoV3aQm +UrEoYlopUk1kgdL63Z8RzwA2YBndnyoWJvjc0RDgAnhwLxYlKBYnGt2b+RYpIGACIHAkFiT6Fiog +oAJisPwWKyFgAlKwKhYo8AAtYAAQIDAA/wIAAgCXgOD6CgUgMBBYMPwSKyIAAGjwWKxJK1JNsUT/ +AgAKALTZEPpiWCIAAFkwW42H+NyWEf/yLqAognInUquqiAmIEah3jHz5cgohmggTMGSRN46YZOEy +azKiZj+fKeIT/wIAAgCTOlAqcg37CpIiAI36kCpwBfwKlSYAid6QfKmWaTGTLSA1LBIo/+IAIAUQ +UDD+cgAgMBBYMFisKI19jHr/CpUj/7n7UC5wBfrCCC//tHuQGd1fKKITjXCPoPugBSgAQEowKKYT +mxCJwJkRKMAF/BImIAUQUDD4FgIgMBBYMFisFot3i74qGoD6uggAARBwMC6kkixwBS0Klf8CAA// +i+sQLfqSLXQFHdxfHNx/KVKrLdJ4LMDRCd0R/ZkIAADM/xAuCoDwAZNoACB2cCggBy/gB/kK+ygC +AUAw+f8BCeAEOiD5IBYuCQBH8C/kByggB/wK/CAFEFAw/eIALgBAZ/D8EiooIAFAMPnkFi4JAEfw +/+QHIDAQWDD/DkEOAgF8MFir7mP+jdEPAGU+7S0gNSwSKf/iACAFEFAw/nIAIDAQWDBYq+UucAWM +eikKkvrCCC//McuQGdxQKKITjXCPoPugBSgJAEowKKYTmxCJwJkRKMAF/BInIAUQUDD4FgIgMBBY +MFir1Yt3i74qGoD6uggAAxBwMC6kkixwBS0Kkv8CAA//CWsQLfqVLXQFHdweHNw+KVKrLdJ4LMDR +Cd0R/8cPeAAgbnAuCoDwAAloACB2cC8qgK+ZHNwW/dwsEAAQQDAopJEa3BKPcC0WGioWFvj/EQAE +EFAw/BYULgkAV/AvFhUukAcskS4ODkEA7hEOzAL6EiUsCQBrMCwWGAnqMCgWGykWGSm9AgYJiADK +igQJiACKigIJiABKigAJiAAKivscUCIAAFHw/AoEIAIQaDBbiSZj/V0tKoCtmR/b9Pjb9BAAEHAw +LqSRGtwIjXCYFJ8W+N0RAAQQeDD6FgosCQB/cJ0VLJAHKJEuDAlBAJkRCYgC+hIkKAkAUjCYGA/q +MJ8ZnhspvQIOCYgByooMCYgBiooKCYgBSooICYgBCor7HBAiAABR8PwKBCACEGgwW4kGY/zebBAE +KiAHG9xYCgpBDKoRq6ooojr/AgACAI5CICOiOWQxFRvbzPALBwIAAEjwAElhAElhKCEHGdxN/9y0 +GUABQDD83LMZwAQ6IP7cShgJAEowmDD7IgAgCBBoMJ0z/jYCIAIQQDD4uREKCQBm8Ps2BCgJAEZw +KTYBLvJ/KyEJ+KY5IAAQYDD68oAh/gJzsP72fyABEGgwW4xviieOIvv6wCBAAkqw+5kBAAAQIDD0 +pRQggAJKcJmp+aYIIFkAN6D83JUQBRBQMP0iACAyEFgwWKtNiiJkoFTAsP368C8AEGAwbQgNesAN +CooU9KAfYBACWvBj/+t60A4KShTwAAhgCAJa8AAAsbsKGhRlr/faIFuOWoonx8+coJQnW4lsJCQE +9CQFIgAAEPDRDwAA8//dYAAQWDDAINEP0jDRD2wQCCggBcOuDwIA/wIABgDSVhCJJyokBQ8CAPT6 +wCBAAlpw9LsBAAAQGDDzlRQggAJS8JqZ+pYIIgAAULBbMuP7CoQiAABQsFgxV4MpZDEv99xjEE4Q +MDD3FgUgVhA4MIk3KJkUhTsqMAX0kgkgKgA2IHehKv8CAAYAa7aQ9jQFIgAAUPBbMtEZ3FYqkX9+ +pxbNRmAAuQAA8//WYAAQIDDaMFuJq2AAp2RApIwVjUOJQIpBLzEIjkL/FgcgIBBAMACABP4OGwrg +AVAw+hYEKPgBTDCZFoow+hYAIDIQWDD5FgEgBRBQMFiq+BvcPSuxf4oX/Dr/IKgAdvD9EgYgvgRi +sGjWKGRAR/o8AAIAAFkw/BIEIIQQeDD/RQggARBwMP40FSAAEGgwWF8zYAAhjRSKNywKAPvcAABA +AlKwW4xo8//BYgAAIrAAACs6/3uhDPNcAA8MALVggylgACKNN/76wCBAAmNw/goALABAczD+1RQg +gAJjMJzZnNhj/9EAAPsiCiAvADTgyrwpsgsPAgAPAgDInm0ICfmSCyIAAFpwyJFj/++Tu/s2DCAA +EHgwnynRD9EPAAAA8yYKIAAQQDCYKdEPbBAcKDAiFdwGDwIACIgJDIgRqFMlMn8PAgD6LAAAQQA1 +YBLbLS2gDC4ieyoigw7dCPndEQIAAFlw/aoIAAEQYDBYiWL2Ci0gJhA4MPwKIyARADUgaEMJ/wIA +BABXBSDRDy+gBdMPDwIAfPHywoIopAVbMmXyMoMhgBBQMPo6CAAAEFgw+6R5L/8QSDD5pHogLAC0 +oGP/xwAAAAAA+jwAAAEQWDBYSXcjMgnIOSswBXa56YM5ZT/0gilkL6IsIhV1yfQtIAV30e6PJ/n6 +wCAAEHAw9PIOIEACQ/D3JAUoAEBKMP71FCCAAkIwmPn49ggiAABQsFsyRCpBEYMqsar6RREvqgC0 +4GP/rSykBVsyPiIyg2QvSR/btP8WLSAyAnBw/hYuIDoCaHD9FiwgcAJYcCsWL2AAJQAAAAAAAPo8 +AAABEFgwWElPIzIJyDkoMAV2iemDOWU/9IIpZC8CKSIV9Zn0cCUQWDAqIAX/AgAOAHvakBvbrPwS +LSIAAEBw8yIKLgAQcDD+FiogABBoMP0WKyAAEFAw8AwXABUQSDBtmgIACIqbEPgyACAEEEgwKRQY ++hQTIAsQSDD6Ov8pgAQ6IPoVCCgJAEowKBYBLzAEDwIA/wIABABoh+AqEi78CgMgogJY8Fii3ioS +LPwKAyCcAljwWKLbFNq4KDIWJEKD+YgRAD8QSDD5NAUkACBBMPoSLyAFEEgw+RQwIAAQQDAoFDH4 +FDIggAJZMPgUMyAIEGAwWKLL+0xIIP4CUHD6rC0gAxBgMFiixi4SK/o8AAIAAFhw/o4UAAsQYDD+ +Fg0gAhBoMFhFzogn+vrAIAAQeDD0gg4gQAJKMPckBSgAQFZw/4UUIIACSnCZifmGCCIAAFCwWzHd +K0ERgyqxu/tFES6tALTgY/6wKhIu/AoDIJACWPBYoqstHH8t3Ckk0AL/0AEgOgJwcC/kASTkAi3Q +AP3kACArEGAwLDQF8/8xYgAAIPAAAABsEAYpMCIY200JmQkMmRGpgysyf2Sw9BXaVS0gDC5SeCpS +gK7d+d0RAAEQYDD9qggB6AIRcFiIrP9DFGAiEFgwyEwvoAV7+Q/CgSikBWAAB/8CAAYAmgEgJxqA ++zJ/KgAgOPAkoHsmoHr1oHggnwA24B7aPi2ggA8CAC7ieCoig67dCd0R/aoIAAEQYDBYiJb6oAci +AAASsPwK+yoCASww/rsRCgBAYrD4CvwqCQBasPUJQQoAQEKw9iQWKgkASrAqJAcqMoguoAf9IAUu +4AE0MPzbHB4AQEOw/pkCADIQWDD5pAcoACA48PiAeSIAAHEw+BYAIAQQUDBYqckjMoPIORXbEfAA +C2UwBDkg0Q+DOWQ/+C0xGS4gB/wgFiAEEFAw/DQWLWABbDD+NAcsCQBtMP01GSAyEFgw/TIAIgAA +YXBYqbeKOsynY//CAIqpZK+8LjAHLzAWKzEZiaorpSkvpBb+pAcv5gA2YAsLT20IEyuVIiigByyg +FiyUFiiUB4mYZJ/HY//lAC2gBcLj/wIAD/9j81ArpAVj/rwAbBAOGtnzLaJ+LqKAL6J8ot382ucd +kAQ/YPL/CAwAIG+w/dIHL5AEP+D8wIAuACB7sP4WECAAEFgw/dIOIAQQQDBtihEAsAQMDhv/5wZw +AgJ68J8csbsmGoCm1ihg5f8CAAAA5CYgGNrVGtrV/trTFyAEPKD/2tAR/gJosP8WByABEGAw/hYK +LuABFDD/FgsgABBwMP4WCSAAEFgw/cs4CeAEPKD7FgUoACBWcPkWBiYAIEXw9xYIIAQCKPDwANRg +ABA4MAAAAIoVGdq+iBkKmDmYGYkW+hIJLeAEOyDwwQQABBBYMAC7GquqKpazixjAgPq2jCAAEFgw ++ZKzIAgQUDBtqhfwgQQKYAFIMPCqGgAEAkIw+UkUCgAgVvAuEggLLRQPAgAt5ossEgotEhAuEg6P +Hy3QIv8WACAEEFAw/xILIDIQWDBYqU8qEhAqoCIe2p4Krwn4Eg4vwAQ/4PkSDy4AIHuw+eR+IAEQ +eDAv5H0i5Hwo5H9YBBMrYOXzPAMgAgI58P8CAAAGAilw/wIACABNXdD0MAEgIAJQcPtcAAACEGAw +WKHO/BIQLkUBIDCeHp4d8OEEAAEQQDAAiBr4xF4uQAEkMC/EXy0RCC3FMPoRCCwAIGOwLMBE/BYP +IBgQWDD6FgAiAABosPzaeBAFEFAwWKkkKWDnG9p2+hEIL3oAtmD82nQQSgRasP0SDC//tWKQ/wIA +A/+Im2D8Eg0uqAC0oMDgnhlj/qjRDxjZaRTZ2iiCbyRCiKKICYgR/BIHJAAgQTCNQC5ANSpAB5oQ +KUAW+RYBIDAQWDD4QRkgAhB4MPgWAiAFEFAwWKkGKUA0/wIAB/+CmmAiRAeKHosfK0QWKkUZ+kwA +AAIQWDBb/Jdj/uUAbBAE8tlOEgAAaLAkIn4oIoCtRPIifCWQBDkgpIT0QgcgBRBQMPzaRxIAIGiw +/jABI5AEOKD0Qg4iACBAsP4kLSAYEFgwWKjqKE0CKIBnyIbRDwAAAAAAAPosAAABEFgwWGxD0Q8A +AABsEAT32jcQAhBIMBbZUwRICvIrCwEYEFAwCioo87sJCPAEOiAIqBT6ZggLwAQ+4Pe7CAvABDjg ++LbLKgAgUbAopqoCJQsLVRGnVSdSwv86EQAAEEAw8KEECAUAInAAiBoAoQTwmRoP/xBQMAqZAwl3 +AQh3AidWwiVSwiVm7NEPAGwQBPbZNREYEDgwBycop2YnYuoEdygHdwr4Ougn8AQ94Ah3LBjaEBva +EAIpCwOZCfw6EQnABD5g+HgCCAAgXnD4lgAmACBRsPdmqSCcECgwJWao0Q8AAABsEAgW2P7TDyVi +fiocEPligCACAljw+DAAJAAgFXD0YnwlkAQ9YPWVCAAEEGAw9VIHIAgQaDDyRAgIQAFAMPjYOAWQ +BDkg9VIOJAAgSTD4RFwh+AIxsFihLfgSBCAAEGAw+kwAAAgQSDDTD9MPbZod/KRbKGABRDD5pEsh +/gJSsPkwDCH+AhjwCEgUKaRUjhQvQE8pQFMrQFAoQEwsQE0tQFEqQFLwzBEIgAQ6IPDdEQqABD7g ++KoRCgkAbvD6QE4oCQBWcPyIAgIAAGiw/NnRGAkAXnD4qhEAGBBYMPkWAC4JAFfw+EBcLgkAR/D4 +FgEgBRBQMA8CAFiobStdAiuwZ2WwayxAXINAKGJ98goAIAEQMDD4MwwAWAA3INow+ywAAAAQYDD0 +JQgAABBoMPVQTCAAEHgw/xYBIAAQcDD/FgIgZBBIMPkWACAAEHgwW4SOZqAdBlw3+jwAAgAAWLBb +hHL2oA5gAgIQsChAXHgjq9EP0Q/RDwAAbBAEwCHRDwBsEATAIdEPAGwQBMAh0Q8AbBAEFdiaDwIA +DwIAJlJ+KFKA9VJ8JgAgEbAJZhGmhvZiByQAIBVwCVURCFUI9mIOID8ANSD82ZQQBRBQMP4wACAY +EFgw/lQtIgAAaLBYqDT6XAAAARBYMFhrkSltASiRocCiCogC+JWhIgAAEPDRD8Ag0Q9sEAgW2H3z +Yn4iAABQ8PVigCAAEFgw+GJ8IgAgFPD5MxEADxB4MPNTCAH4AjGw8zIHKAAgEjD5iBEAARAQMPgK +CCQAIEVw8zIOIMwANSD8ogAgABAgMG2KIwtdDPupDA5gAWAw/EwUBgBUf5Ak1Fsu1EspkAv51FMg +AgJa8IxQK6AMK1RcJmJ9wED2xgwAbwA24JoU2mD7TAAAABBgMPVHCAAAEGgw93BMIAAQSDD5FgEg +ABBwMPkWAiBkEEAw+BYAIAAQeDBbhC9moBsCfDf6bAACAABZMFuEE/agCmACAiEwKFBceEOrKz0B +KbGhihQCmQL5taEiAAASsNEPKz0BKbGhApkC+bWhIgAAErDRDyLUW2P/WMAg0Q8AAGwQBIgwKjAI +KzAJ+AJDAACQphD+Cg0kAFyVIPsLQwAgAmjw+gxBCkQBUDD0wQlh+gJDMP8KAiABECAw+PQ4APEA +NqD/AgAGAHSWoASmDAYGR6a5/wIADABsy5BkYFkY2Sf/2CMfIAQ4oA6+CvjuCAIAAEmw/+8IAgAA +W3D4vAAAAGmGYAu6AgAPi/ALgAAgAnOw8QoWAfwCSnDzChYAIAJ78PJYHgAgAlrw8hgeD84AtmAN +axENvQoEDkdk4Fr6LAAAAhBYMFgAKGAATAAAAAD/ChotIAQ4oP3Y/BCoCHkw2zD5Cg0kwBBAMG2a +GKyJrZkqkoD5koEgEAJa8Pq2ASAQAkIwmbD6LAAAAhBYMP08cCADEGAwWAAUwMD6XAACAABY8Fim +x8Ag0Q8AAAAAAADz/+dv6hBgMPQKAC/0ADag/6fsaAAgUvD44uRyAAAysGP/ChnY66npKpKAmrAp +koGZsWP/TAAAAGwQBBjY5sec+IKAIBAANSB0mAga2NBoMQdoMgTGKtEPACqggAAgBAoKG3+n7v3Y +3BIAn4DgF9jbCANBZDE6/ykRAACghODAwR/X0BvY1/7Y0hC6AH0wwCTzvAAIACB58Po8AAAAVhyg +rnImIoCWMCIigZIxC5gKCccJ/8oRCgAXulCDUPJSASACAjKwBhYUbWkaioCjo5NQh4B3OwOxIpJR +hoGiYvJWASAQAkIwuFX+R1lyAAAa8P/UCAAEEBAw+SF9YgAAOPCu2CqCgJowKIKBmDELlAoJzQn/ +yhEKABfqUINQ8lIBIAICcrAOHhRt6RqGQKNjk1CPQH87A7EiklGIQaKC8lYBIBACITDAINEP1jAA +CIvwA4AAIAI58PEGFgH8AhCw8wYWACACQjDyWh4AIAIY8PIaHg8nALSgY/8z2DACBIvwA4IAIAJr +cPUIFgH8AhCw9wgWACACITDy1x4AIAIY8PKXHg9WALSgY/9iHdiPF9iPY/6+wJDz/slgBBBgMBzY +jAIrEay7i7DAoPu9qyAEEEgwC6k48/6qYAIQYDAAAGwQBIgw/zAJIBoQUDD7MAgv6hBgMPgCQwAA +daYQ9woWJABtlSD0CgEgIAJo8PsMQQ6gAXgw/39ACkQBXDD0wVNh+gJLMCgKAvmEOAFAADbg+AoB +JgCcFuAEtgz/jzkG4AEwMPboCAoFAHnw/wIADACOwpBkYGga11v7SgAlQBBIMPjYZBgFAH7w+e4K +DyAEPKAP7gj47ggCAABbcPrvCAIAAEmw+LwAAACKBmDasAAPi/ALgAAgAnOw8QoWAfwCSnDzChYA +IAJ78PJYHgAgAlrw8hgeD88AtmANaxENvQoEDkfI6fosAAABEFgwW/9b8AARYAAQYDAAAAAAAP3Y +MBAoBFEw+lwAAgAAWPBYpgnAINEPAPhKACIAAFjw+QoXLSAEOKDTD22aGKyJrZkqkoD5koEgEAJa +8Pq2ASAQAkIwmbAoWkD7PAAAGxBIMG2aGayJrZkqkoD5koEgEAJa8Pq2LyAQAkIwKbYu2iD9Gpgg +ARBYMP09CAADEGAwW/838/+BYAAQYDAAAAAAAPP/dG/qEGAw9AoAL/QANuD/t+xgARBIMA+fOf96 +OQgAIFuweKLZ8/7AYgAAMvAAABrYDqrqL6KAn7AqooGasWP/CgAAbBAEF9cEGdgQGNgQ9zcIDwAQ +aDAPAgDTD20IT/hRT2IAAFEw20AMAgAsgkAuktIN5gEGJgImltIvktIAB4sABGEultL8ktIgIAIh +MPELFgAgAhjw8wsWACACOfDyWh4B/AIpcPIaHgA0ADVgY/+kDAIAKoJAL5LSDfcBBycCJ5bSJpLS +FdfopTUmUoCWQSVSgZVAL5bSLpLS0Q8A0Q8AAGwQBCsyACz66vt6QAAAY6bQ/tecEgBfwSD/1tYQ +gBA4MPbX2BQAVRUgJDEEBM1C9NCxZIABIDD/AgAAEBBgMP8CAAYAUJdgKAoR+sg5CAAgJ3D/AgAA +ARBgMP8CAAoAQ04Q+QoAIwAQQDD6yTgAIAJg8PnX0BYFAE4w90oLANwA4vApIAwb18oGmREJqQgL +mQgPmgj7zAAAAJ4HYN7AAAqL8AyAACACSnDxDhYB/AJrcPMOFgAgAlKw8lseACACYzDyGx4PzwC3 +YGAARwAAAMCJeEFX+lwAAgAAWPBYpXnAINEPAPP/7G/qEGAwwLhtugkvkqUPD1LK8biZwLAp4n8o +IgAPAgAPAgD5igwKACBW8Fv/k/P/vGAAEGAwK5KkCwtJ8//Xa+AEPuAAAPi3SXAQAmDwGdegwNht +2gkvkqUPD1LJ/riZwKAp4n8oIgAHqwj5igwAEBBoMFv/gfP/dGAAEGAwKpKkCgpJ8//aa+AEOqAA +AAAAAAAAKiAMG9ePBqoRq6r/qwgAEBBIMPiRNGIAAGsw3sACC4vwDIIAIAJSsPUOFgH8Akpw9w4W +ACACWvDy3R4AIAJjMPKdHg/PALZgY/+Xpq8o8oCYwC/ygZ/BY/+IAKaaK6KAm8AqooGawWP/MABs +EAQoIARohgPAINEPFNdyjC4rQn8JzBGsu4u3i74osBIusBoqsBgpsBwtsBkssB34mRELgAQ6oP2w +HioJAGqw/LAfKAkAZnD4qhEJgAQ+YP2wGygJAG5w/qoCCYAEPmD4qhEICQBmcPycASoJAGqw/I4U +CgADyxAqrAEvsDUqtBsutB4stB8KjRQssBQttBoOjhQqsBAutB0NjRQttBkOjhQutBwNjRQusBH9 +tBggAgJ78P2wFS2ABDsg/7Q1K4AEOqD/sBcqCQBysP6wFiwJAGsw/bATK4AEOqD4qgINgAQ7IP4x +CywJAHMw+KoRDYAEOyD9qgIMCQB7MPzsCAAAEGgw/I8UCgADcxCxqiq0Eyy0Fy+0FgqIFCi0Eg+P +FC+0FQiIFCi0EQ+PFC+0FAiIFCi0EIwtK0J/CcwRrLuLt4u+KbAdL7AcKrAYLLAZ+LAeL4AEP+D4 +qhEOCQBP8PmwHyoJAGKw/LAaL4AEP+D4qhEOCQBH8PiwGy+ABD/g/KoCDgkAT/D5sFkrgAQ6oPz8 +ASoJAEKw+LAVKgADexCxqi+wESy0Hyq0GwyMFAqKFCq0Giy0HgqKFAyMFCy0HSq0GQyMFAqKFCq0 +GCy0HCqwEPywFCACAkpwKbRZKbAS+MwRC4AEOqD/sBYqCQB6sPiwFywJAEMw+KoRDYAEOyD/sBMs +CQB7MPmqAg2ABDsg+KoRDAkAQzD/qgIMACBjsP7LBnoAIFNwsaoqtBMstBcMjhQKjRQttBIutBYc +1ugOjhQNjRQttBEutBUNjRQOjhQutBQttBD9ITYgAhBQMP4hNyAyEFgwWKVyjTf+MgkgAhBQMPzW +2xAyEFgwWKVtLyAFxIX/AgAP/sHD0MWV+SQFIAAQEDDRDwAAbBAGKiAH/dbSGiABUDAKpAn51dUV +wAQ5IPjWzBYAIGkwI2J/qUSoRPNJCHAAEFgwwCDRD44xmhGHMJfgjzAsORAn0qee8Zsw+zYBIGcA +NyCKN2SgXRjWui2iARzWviiCfw2JFAyZAfo8GCmQBD5g+YgIDOABbDD4FgIiAABh8FuGzBrWtfsx +CSAAEGAw+qJDIAEQaDBbhlQqPPhbg3HccPoSAiIAAHFw+xwAAAAQaDBbdxcrYn//AgAH/7sm0Iwi +Zc9sixHaIPu8GCIAAGCwW45TwCDRDwAAbBAGE9aAAiQJDEQRpDMrMiAkMH8mMH71MHwhEAA24BrV +ey0whC6ieCqigK7dCd0R/aoIAAEQYDBYg9MuoAf4CvsuAgEsMP7/EQ4AQEOw/Qr8LgkAe7D1CUEO +AEBrsPakFi4JAEuwLqQH+jIpIgAAErAroAcc1lz2D0cKAEBu8P0gBSgJAF5w+aQHIgAAcTD4MH0g +MhBYMPgWACAEEFAwWKUIIzIkZDCCFdZQ8AAJZTAEOSCDOWQwco0wKTEZ/iAHIgAAYXD4IBYgBBBQ +MPg0FilgAUww/jQHKAkATTD5NRkgMhBYMFik9oo6zKdj/8MAiqlkr70sMActMBYrMRmJqiulKS2k +FvykBy/mADZgCwtPbQgTK5UiLqAHL6AWL5QWLpQHiZhkn8dj/+XRDwAAAGwQBvOIQgCAEEgw+ToB +AgCg4NCpif8CAA4An5JgCZUC9KF0aEgBHDAuIAwqIA0W1SvzDEYOALHLkC8gVSsgVPShHWoAIH7w +/WKAIf4CSvD7YnkhKQA2oBfWPwfnCCdw5Qp3CAe3CAl3EQfXCPkWACEAAjnwKHIAC4gMeMEa+RIA +KgCL/xD/AgAKAIfLEMulHdU1K9J8LdKD+NYvEMkANqCo6CiA5aqIqLgJiBGo3S3cgInQC5kMeckM +8AAVYAAQWDAAAAAAAMDR/8sMCgUAU3CrqyoiFFuF4v7VIxC8ADagKGJ7LuKDpYUJVRGl5RvWGh/U +/PAPBwIAAErwAElhAElhAElhAElhGtVqEtVL+NVkEAUQaDDxTBAIIAQ9IPwKASgJAGZw+IJfKAkA +ZnD5Jp0qCQBQ8PomnCIAAFFwC4AAIiKdAoJHyivRDwAAAAAAAPP+yWjAARww8/7EYQACKnCbEGP/ +FylieK6ZCZkR8/9AbAAgT3DCoipUBdEPJ2J4rnf5FgAnkAQ94PP+52YAID9wAAAAAAAAAPP/UWAA +ECgwbBAIJiAMFNXsGNTNJSANmBTwCAcCAABJMABJYQBJYQBJYQBJYf3VJhEgAjkw+NU0EgAAULD5 +1eESAABZMP/VIhAEEGAw/0YBIAAQcDD+RBEvwAQ84PlFBCmABD2g+IJcKAkATXD/RBAoCQBucPlG +ACAFEGgwC4AAKXIdCYlHyJPSkNEPABnVzxjUzitxPAM8CR7Vyx3Vnp4V/MwRC2ABXDD7FgYsACBv +MP0WAiGAEFAw+9Z/KgAgU3AlpIEmpID54AEmACBKMPrgACYAIDMwKmQAKWQBL+ADKOACKGQCL2QD +LeAFLuAE/mQEIAEQYDD9ZAUiAABQsFiC8IsVHNWOKSEIJSEHLyAN/iAMIgAAGrAtMCYoIQkqIBQN +3QkS1PkoNQkpNQgqNBQuNAwvNA0lNQf1EgYtwAQ/YP4SBCAPEHgw/zQELAAgbzAt0H/wDgcCAABJ +MABJYQBJYQBJYQBJYRrU3/7VmRAEEGAw/HYdKgkAUXD6FgMpQAQ/YPp2HCgJAHZwKXU8L2ABKGAA +KLQAL7QBLWADLmACLrQCLbQDKWAFKmAEKrQEKbQFKCJdwNX6PAACAABZMAuAAC1yHQ2NR/TRvmIA +EHgw/wIACgDbA2ANDk/53AAOqQC3oIsSGtV7HtV6K70CKaECKRUCJrUEiqCaECgwJh3VT4kUCIgJ +/IgRAAQQMDDwCQcMACBHcP3QfyIAAEkwAElhAElhAElhAElhJnYdKCJdjBMrEQAqEQEpEQIpdT/6 +dT4tQAQ/YPt1PSIAAFDw/HYcIgAAWTD+3QIABBBgMP11PCAFEGgwC4AALXIdDwIADwIADY1HZNHc +/wIACgDsg2D9Dk8CAABLcP8SBC38ALeg8A8HAgAASTAASWEASWEASWEASWEoIl751JISAABQ8P7V +ShIAAFkw/nYeIAEQYDD8dh0oCQBNcPl2HCAFEGgwC4AAKXIdCY9H+YkUAXQAt+CMFPoKASAAEFgw +8AwHAgAASTAASWEASWEASWEASWEmdh0oImgZ1H0d1H0rdT36dTwgBBBgMPo8AAIAAFkw/XYgKAkA +TXD5dhwgBRBoMAuAAClyHQmOR/mJFAEWALegihTwCgcCAABJMABJYQBJYQBJYQBJYSgia/nUahIA +AFDw/tRpEgAAWTD+dh8gAhBgMPx2HSgJAE1w+XYcIAUQaDALgAAich0CgkfRDyZxPA8CAAYGSf8C +AAv/ILPQiBQsGoDwCAcCAABJMABJYQBJYQBJYQBJYY0SDN0IL9CFKdCDLtCCKNCG/NCEKYAEPmD9 +0IcvAAQ7oPiIEQ8ABD/g+P8CDgkAS7D+zAIMCQB/cP4SAywRAGsw/M0UAAEQWDD+dhwsEQBrMPxt +FAAAEFAw/tTzHBEAazD+dh0soAFgMFilifwKBCAFEGgw+CJdIgAASrD7dh8iAABQ8Pl2HiIAAFkw +C4AALXId8/2ObOgBbDAAAAkCR9EPL3E80w8PAgD+KgAvIAF8MP8CAAv/C/uQiBTwCAcCAABJMABJ +YQBJYQBJYQBJYSwQAi4QAC8QAygQBCkQAS0QBfiIEQ8ABD/g+JkRDwAEO6D57gIOCQBH8P/dAgwJ +AHMw/hIDLBEAazD8zRQAARBYMP52HCwRAGsw/G0UAAAQUDD+1MEcEQBrMP52HSygAWAwWKVX/AoE +IAUQaDD4Il0iAABKsPt2HyIAAFDw+XYeIgAAWTALgAAtch3z/W5s6AFsMAAAbBAGG9OKiTAoIAwm +sniNMiqygPixryYAIEGwDY1X+QJDB5AEOaD0gJlmACBRsHqWRCyyfG4kWPAAPWAWECAwAAAAKhYB ++RYAIXMANeAGagL7fAAAARBgMFiB0ymgBSoKIf8CAAYA+dZQ2mD7LAACAABh8FgAkcBA2lD7PAAC +AABhMFiiQ8Ag0Q8AAAAAAAAA+dRbHAAgEzDyKwkNkAQ7IPyqCAvABD7g/NSIGAAgTvD3kf8vjgA3 +YPjRDWAWECAwY/+0FNOeY/+umxKaEfkWACGvADXgGdR3GNN2hBKpiPhECABAAlDw/AoGIgAAWTBY +m5OPOABEBIg5/0kUAFACUPD5NgggUBA4MPc0ICIAAFkw+P8YAAAQcDD/Ngks6AF8MP40JywJABdw +/TQmIAYQYDBYm4KPOgBEBIg7D0kU+TYKIgAAWTD3NCggNAJQ8Pj/GA+AEHAw/zYLLOgBfDD+NC8s +CQAXcP00LiAGEGAwWJtzixDaYPux/yABEGAwW/30CgRPZU7x2iBb/aWOES7gIh3UTg7uCQzuEfxg +DCwAIHdwLdCA/wIAD/9oaxDaYPsSASAGEGAwW/jCY/67iBEogCIIiAkMiBH/YAwoACBDMCiAgP8C +AAYAX0fQKWIHLGICK5kU8tQ6EAEQaDD6nCAsCQBrMPxmAiCxADbgK5IJZLCmLrAALwoqf+kFKLIC +coFD+woAIAIQYDBbiuUb1C0d0+udoIxgkqKTpfSkHC//EEgw9aYGIAIQaDD7pgQtgAQ7IPmkHSwJ +AGsw/KYBIgAAUXBYofTAINEPihAqooPIqyugBcLV/NQZF/+qbtDaYPssAAIAAGHwWAAQY/35AAAA +APpsAAIAAFiwW/4ZCgRPZU3mY/5AixH6bAAABRBgMFv3z2P/NQAAAAD7CgAgAhBgMFuHTmP/ZAAA +bBAI99LcEIAQUDD6RQECAQjhEASJQqqZ/wIADgEGEmCZFfzT8hHoAjHw9FDIbEgBJDAvIAz0A0YO +AF7r0C4gVSkgVC0gDftygCgAIHZw9NHeYf4CUnCaEfpyeSIPADdgrPgogOWtiKioCYgRqLgojICY +EokSiZAKmQx5MQ9+M3WKEXo7cMrdKmJ8K2KDZNGprPgogOWtiKioCYgRqLsrvICJsAqZDHk5DPAA +FWAAEFgwAAAAAADA8f47DAwFAG/wq9sqIhRbg4z808kRzAA2oIoVKXJ7KGKDCpkICZkRqYj4FgQg +HAA1YAQDRm4+His8gJsTYAAYwND9FgQv7AC1YPgKgCJIASQwqDNvPuCTE/RRfWpIASAwLyAMLSAN +9ANGDgC309AuIFUpIFT00QZoACB2cPtigyH+AlJwmhD6YnwhOQA3YKz1JVDlrVWlpQlVEaW1JVyA +iFAKiAx4MRn/AgAKAJd00IkQ/wIACgCSSNDK2ipifCtig2TQzqz4KIDlrYioqAmIEai7K7yAibAK +mQx5OQnwABJgABBYMAAAwMH+OwwMBQBvMKvbKiIUW4NS+RIDINwANqAocnsiYoOpiAmIEagiG9OK +GtJs8AoHAgAASvAASWEASWEASWEASWEZ0toY0tUT0rraIPiCXyABEGAw/DadKAkATTD5NpwgBRBo +MAuAACkynfsSBCjoAUww+gojIEYANmAqtAXRDwAAAPP9/GjAASQwLJyAnBVj/fGZEWP+R5kQY/8j +KHJ4r4gJiBHz/ltqACBG8ClyeK+ZCZkR8/82agAgTvCLFMLC/CQFICMQUDAqtAXRDyhyeK+ICYgR +qLiYEmP9+CVyeK9VCVUR8/7QZAAgLvAAAAAAAADz/zFgABAQMMCAmBRj/ksAbBAKijAX0xsoIgL5 +0yYaYAFQMAqqCfvTVxvABDqg+pkIACoQYDD2kf8gbgA2IC0iBy7ZFCrcIP3SCSNFADegZNM9KNAA ++dICIA4IYjB7kUD7CgAgAhBgMFuJ/x7TRhzTRpegjSCTpSSkHJWmnKT+pgIv/xBYMPjdEQACEHAw ++6QdLAkAd3D9pgEiAABRcFihD8Ag0Q8AAAD5FgAggBBYMPtuAQIBZmGQBolCq5n/AgAOAWOSYJkY +9ODtaEgBMDArIAwsIA32B0YOAG/C0C0gVSkgVJsX9MLKaAAgbnAb0f2wmJgTKrJ5+7KAIu8ANyAY +0xeJF6iZKZDlrJmpqQmZEam5KZyAmRWJFSmSAAqZDHlxHf8CAAoASW3QKhID/wIACgBD0dDLwhvS +DSqyfCuyg2TCeRnTBogXqYgogOWsiKioCYgRqLsrvICIsAqIDHh5CZ4Z8AAWYAAQWDDAgf17DAwF +AGIw/hYJKgAgXzAqIhRbgrkf0dj+EgkitgA2oIsYKvJ7KfKAq6oJqhGqmfkWASAnADegBgdGbn4p +KnyAmhZgACMAAAAAAP/RyxAAEFgw+xYBL+EAt6D4CoAmSAE0MKh3b37Vlxb04l1qSAEwMC4gDCwg +DfYHRg4BJ9OQLSBVKSBU9MHBaAAgbnAb0dywmJgSKrJ8+7KDIfcANyAZ0tOp6SmQ5ayZqakJmRGp +uSmcgJkUiBSIgAqIDHhxHP8CAAoBA+3QiRL/AgAKAP7J0MrOG9HKKrJ8K7KDZMGEGNLDqOgogOWs +iKioCYgRqLsrvICJsAqZDHl5B/AAEGAAEFgwwOH9ewwMBQBjsKvLKiIUW4J5ZKGxGNGXiRYX0bgo +gnsncoOpiAmIEah3G9KxGdGS8AkHAgAASvAASWEASWEASWEASWEZ0gAY0fwe0eHacPiCXyABEGAw +/OadKAkATbD55pwgBRBoMAuAABrR2YkRKqKdjSf+EgAgIxB4MPbSpxroAVAw9KDpYEACW3AvlAUs +2RT5IgIgABA4MPfmgyCRADcg+tIJIQQANmBkoIQooADCmnmJFB3Sl4yi/wIABgBw7xD/AgAH/rU3 +ENqw/AoCIAAQWDBbiUge0pIY0k6YoI8glqKTpSSkHPWmBiACEEAw96QdL4AEP+D+pgQuCQBH8P+m +ASIAAFFwWKBYwCDRD/P9QWjAATQwKpyAmhhj/Tb7CgAgAhBgMFuFwmP8zAAAZJB32rD8CgIgABBY +MFuFvWP/lJkTY/1pmRJj/m8Z0UmIFymSeKiZCZkR8/2LagAgTvAo8niuiAmIEfP+g2oAIEbwwqIq +dAVj/xIY0T6JFyiCeKmICYgRqLiYFWP9GAAAKfJ4rpkJmRGpuZkUY/4TAP8CAA//mjMQY/yF2lD7 +PAAAABBgMFigCNogWJgMwCDRDwAAAAAAAADz/l9gABA4MMCgmhFj/WAAbBAGJjAIJzAJ9glBBkQB +MDD4MgAgzQA1oPoKOCYAYpWg+wp4IABnphD/AgAEAFqVIPjSORAAn2HQGtEZmBDwCgcCAABSMABK +YQBKYQBKYQBKYQmaCRnSOAyqEaqZIpIfZCB+GtEOLZCALqJ4KqKArt353RECAABYsP2qCAABEGAw +WH9lGNF3G9Iy/dIwGKABPDD5nP8tQAQ5oPS2PygJAGZwKbWA+IJiLAkAbLD9tj4iAABhMPsSACAF +EGgwC4AAHNIkLMI/+TwQLOgBYDD40iIQcwA3IAwMBvAACG3gAWAwABzSHPpcAAIAAFjwWJ/EwCDR +D3uG6i0yAXHW5PnRzRXCAL0gKCAEaIFF/wIABABaAiBphcsHCEUIbwgN/xH//PggQBBwMH/jtwOI +C/AJFwAKADWgbWkCAAiK8/+mYAAQYDAAAG1pBQAIiAAJimP/kwcIRahrDbsRK7z4e6OCA4gL8AkX +D9UANaBtaQIACIpj/8coIARogXD/AgAEAFACIP8CAAX/rp4gBwhFqG0N3RH93PggQBBgMP8CAAv/ +ou8QiieKrvqICwAgAkjw9G+KYfACQjBtaQUACIgACYpj/3kAAAcIRahsDcwRLMz4/wIAC/+IZtAD +iAvwCRcPXgA1oG1pAgAIimP/UAcIRahtDd0RLdz4/wIAC/907pCKJ4qu+ogLACACSPD0by5h8AJC +MG1pBQAIiAAJimP/HQcIRahsDcwRLMz4/wIAC/9bZtCKJyqiDvqICwAgAkjw9G76YfACQjBtaQUA +CIgACYpj/ukAAABsEAob0JLyICIgABAwMCY0HyY0HiY0HSY0HCY0GyY0GiY0GSY0GCY0FyY0FiY0 +FSY0FCY0EyY0EiY0ESY0EPILBwIAAFBwAEpj8AsHACgCSHAASWGIMPoWBCAgAlDw+RYJICwApjAF +WgL7PAAAABBgMFifTsAg0Q8Y0ZYU0JQCKQkMmRH5RAgABhBgMPhECAAuEEgw+TQPIgAAWTBYmK6O +NABEBI81DkgU+DYEIFAQODD3NBAiAABZMP/uGAAwAlDw/jYFLOgBdDD2NBcsCQAXcP00FiAGEGAw +WJifGNGMHNBvHdGJizYARASONwtPFJ82JzQY/rsYD4AQUDD7Ngco6AFcMPo0HygJABZw+TQeICgC +UHCWoJahlqKWo5YQlhH2FgIn0BBIMJkT/RUDIB8QWDArFQX8FQIgChBwMC4VAfgVCiABEHgw/xQh +IP8QcDAuFQQuFQ79FQ0iAABgcPYMFgBAAljwAEtn9AoWAGACSPAASWVj/u4AbBAEiDD/AgAAAFQu +EIkxZ5CeFNChKkKLK6ECZLFlW30hHdCCjN6xzPzWDiAArAKgGNAoKIJsJEKI/dAmGAAgUjAJiBGo +RPANBwBAAkkwAElhAElhAElhAElhAElhAElhLyAMLiANLSEHLCAHKyAWKSB8+iIKIAQQQDAoRAQv +RAwuRA0tRQcsRAcpRFX7RBYgPxBYMPtEBSD0ADagKaIIyZ9tCAn5kggiAABScMmSY//vwcb6XAAC +AABY8Fie3sAg0Q+UqPtEMCAAEDAwlkn2RgggIAJY8PULFgBoAlEw8poeADACSPDzCRYAeAJBMPJY +HgBAAnjw8Q8WALgCcTAADoqNO/1GGSBgAmDw8AwWANACWTDwC6AAnAJRMPkiACADEGAw+UYWIBoC +WPBYmC0qTFH8CgMgkAJYsFiYKRjRAY5AKyEpKiITKSBQjEcpREz6RhIvwBB4MPtFIiBAAmsw+O4B +DABAf3D+NgoggAJrcJ3JncgmxRTz/zlgABBgMAAAAAAAAPP/K2AMEGAwlCpj/zIAAABsEAwX0QAa +0QCJMPbQIxIAACFw9dDmECsQWDD6mgEAEgAucIwxZsFsepZEizIqcoUFuwEJuxH9IgAqACBasC6i +Hvg8ICBwAmDw+zwYIHACSrD/rEAmAId3UMHG+kwAAgAAWPBYno/AINEPAAAAAAAA/HJyIPIAJnCK +MgWqAftyIioABOKQrLt6s84lcoUJqBH4VQgABhBgMPo8EiDYAllwWJfqKFw49QgWADACePDynx4A +gAJxcPMOFgBAAmjw8l0eAKgCYXDwDBYAUAJY8PALoADIAlFw8QoWAHACSPAACYrz/3ZgABBgMAAA +AABkr2iJMYoyLHJy/wIAAf+vBlD1coUqAEAqsPmoEQoACOKQLXIirN3/AgAL/6DXUI4qqFX/AgAH +/5qvkClQBf8CAAYBKN5Q2lBYQ0D6XAAAABBYMFg+C9pQWD2T+lwAAgAAWLBYPXMqYhCwqipmEPP+ +/GAAEGAwCguIAUmKCAiI8x8eAFACcPDyDhYAqAJqsABNY/cMFgDIAlqwAMuK8/7NYAAQYDAAAAAq +cokPAgAsoQJkwdZbfFstYhCx3f1mECAA5YKgG89iKLJtJnKF/s9hGAAgUjAJiBGoZvAOBwBAAkmw +AElhAElhAElhAElhAElhAElhKiAWKCEHLyEJLSEIKSAHLiANLCAMLGQMLCAMLmQNKWQH+mQWIAUQ +SDD5ZAQgKxBQMCpkBSpyhS6yeCsiFS9lCf1lCCwAIHMw+GUHLZAEOyD8CgEqACBisFh9n4sq96wA +As4ANuCJufq8AAAPADZg+ZIJIgAAUnBln/SWqZJoiCAvIRn+IDYgABBIMJlpmWqZay5kSyhmHv9l +KSDkAlGw/SBTIIACWLD9ZHwgBhBgMFiXbh7QWxnQWfsKACAgAmBwm8CbwZvCm8ObEJsR+xYCJ9AQ +aDCdE/kVAyD/EEAwKBUE/hUIIAEQeDAvFB0oFQz5FQsgChBAMCgVARnPLfkVAiAfEFgw+xUFIgAA +aHD0DRYAqAJ5sABPZf0MFgDIAnGwAY6Kiyoa0D+dGPwWCSAkBDLwLqJyjWAO3QydHWAABADA8J8d +KKG5+88mEM4AdjBoRV+JMvI8ICAwAlDw+hYMIgCQplDxChYAcAJpsPIdHgBREFgw/wIWAIACYbDz +3B4CAABRsFg12I5gBe4BnjLz/OhgABBgMADz/N9gDBBgMPpcAAIAAFiwWDzl8/zMYAAQYDAicCYb +zwoCLQkM3RH90AkaACBu8Po8GCAGEGAw+hYMKgAgbvBYlyWPHYg2AEQEiTcISxT7NgYgUBBQMCo0 +GAmIGPg2By7oAUAw/zQfLgkAE7AuNB4icCYbzvUCLQkM3RH9z/QaACBu8Po8ICAGEGAw+hYLKgAg +bvBYlxCPHIkdijgARASLOQpOFJ44+6oYAFAQaDD9NCAggBBgMP0SCygJAGZw+jYJKOgBUDD5NCco +CQASMCg0JvUPFgBwAnGwAI6K8w0WAIACYbAATIpj/wUscCYdz9ecGgzMCQzMEfoSDCoAIGbw/bsI +AAYQYDBYlvKOGo8diDYARASJNwhLFPs2BiBQEFAwKjQYCYgY+DYHLOgBRDD/NB8sCQB3cC00Hidw +JhvOwh3Pwwd8CQzMEfy7CAIAAFCw/bsIAAYQYDBYlt6KHABEBI44jzmNHQ5LFPs2CCBQEEgw+TQg +IIAQQDD/7hgMCQBHcP42CSzoAXAw/TQnLAkAOzAsNCZj/jSWKmP9RwAAAGwQBIgw1FAPAgD5hgpw +FhBgMCkgBGiREPpMAAIAAFjwWJ1ZwCDRDwAAKCEWKDURLyEYLzUQLiEZ/jQkIBQCUPD9IDYggAJY +sP02CiAGEGAwWJa4KTwY+ixIIHACYLDzDBYAIAJY8PJbHgADEGAw8QoWAKACWLDyGR4ASgJQ8FiW +rSkgUyk0MSohF/CnCnBAEGgwDZkCKTQx8acKcCAQcDAOmQIpNDH9pwxwABBgMMHwD58CLzQxKCA0 +KDUEY/9YAGwQBBnOr4gwHs+L+lwAAgAAWPDzzyoQhAAmMBjPQY2fLJIQjyeJniiCf4/+I7UFI7UG +I7UHj/SftCPifpO1mLaZty/igJ+4LuJ/nrmduvy2CyfQEEgwKbUEwMBYnRvAINEPAABsEASOMm7i +E2jiQGjjVWjkIsAg0Q8AAAAAAAAA+iwAAgAAWPD8TAACAABpcFg0MdKg0Q8A+iwAAgAAWPD8TAAC +AABpcFgyvtKg0Q8A+iwAAgAAWPD8TAACAABpcFgEW9Kg0Q8A+iwAAgAAWPD8TAACAABpcFgCDNKg +0Q8AAAAAAGwQBoonFs8RDwIAhakoqRQpYX9kgN3+lwdyAAAhcGRQzSkgBcWmDwIA/wIABgB8VlDE +v/skBSIAAFCwWyV/9FCtY/8QWDCHUSohCCNVCCxhf4hQ9wdHAHQAdzD/AgAGAFLekAiIV/8CAAYA +YoIgykLbQPx8AAIAAFCw80UIIAEQSDD5JBUgABBoMFhR9mAAAwB7oW/7Ig0gUBBgMCwkBSpiaAm7 +EauqiqrJoSusYPwKBCIAAFBwWJY2ihBgAAQazsaaEB7PJC066A2tLA7dKP0WACIAAFCwWyVYixAc +zm39zx4SAABQsFsldNogWyVW0Q8AAAD+nzRwABAoMPP/IWAAECAwjyf5+sAgQAJz8PnuAQAAEEAw ++PUUIIACc7Ce+Z74Y/9u2iBbfCXRD9EPAIon+3wAAAAQYDD6rCAiAABp8Ft/AvP/JmIAACKwbBAs +Fc3ugy0oUoMJMxGjg4s3i74qsDAssDH5Ig4rgAQ6oAyqArGq+rQxKZAEPmD6ihQCACBKMPq0MCIA +AFCwWyUriinJoISrKwqKW/+a+kwAD/QAtSCKKcBA+yILIBIANqBls5aaK2AAA5q7m6yUKSsgDCwi +FhfOlR3NrighGfgWTiAaEHAwLiRULdJ4+lKDIBAQSDDwBxcCAABAcP27CA2QBDsg+bsRDAAgYrD8 +Fk8qACBasG2aAgAIih/N4iqhLsBh9SxOJgEWfpAezZz9IgAg4RB4MC8UGP4WAiAIEGAw/s2XHYAE +P2D+FgAsCQBncJ0RLiAH/82UHiABcDAA7hEOrgIP7gKeFAvqMJsVnRn6zsAQQBBIMCkVD5oYKCBU +KBQxLyAFLxQyLiAwJhQwLhQzLSIW/RYNIEACaHCL1YrUidOI0v/SASCAAnBwn+GY4pnjmuSb5Y3Q +neCLICsWFiogVCoUXSkgBSkUYCggMCYUXPQUXiBoAliw+BRhINACUHBYlbAqHHD8CgggeAJYsFiV +rCsSTyocevu8ciAGEGAwWJWoKhx9+1wAAAMQYDBYlaX7LFwg/gJQcPqsBSAIEGAwWJWgLBFCKxFD +KxUx+xJOKg4BYDD82UALkAQ6oPqZEQwFAWAw+2hADAQBXDD7zBEICQBWcPsaFA4FAVgw+69ACgkA +UvD6/xEKAAFQMP/uEQuQBDqg/CIMKgkAYrD+3QIOBwFYMP6IEQ/QBDug/ogCDJMBYDD7jkAKCQBi +sPu8QAoJAVww/O4RC7AEPuD6FGQtkAQ7IPwgaC4JAGfwC+4C/yBpLgkAe7AMPEANzBH/akAKBwF8 +MP67EQvwBDqg/JkCCgkAWrD/X0AICQBWcPkKMC4JAE/wCf8CLxRljCwI7gL+3QIKEAFkMPwaUAwS +AWAw+qoRDZAEOyD7uxEKCQBisPsKCCoJAFqw/RRnKgkAWrAqFGaMJynJFPSROmBAAlMwLcIJZNEv ++xwAAAgQYDBbgYDBlfQlGSD+AkBw8AcXACICQjBtmgIACIoazkL6FiQgogJYsPkiACADEGAw/jr/ +IAsQaDD0FKMg/gJQcPYUqCmABD5g/hVQKAkAbnD5FiUgVAJSsFiVP/ocfyIAAFlw+qwuIAMQYDBY +lTokFMEkFMIkFMP8ChAgAxBYMPsUwCD+AlBw+qxFIKgCWPBYlTH7PEAg/gJQcPqsVSAIEGAwWJUs ++zw4IP4CUHD6rF0gCBBgMFiVKPodASDIAljw+qwEIAgQYDBYlSMmFYgkFOQkFPT6LAAACxBgMP8d +ASACEGgw9PQUIP8QcDD+FYYgIBBAMPgUxCD+Alhw+BTFICICWvBYOCPDmSkkBdEPibvTD9MPZJxk +bQgK+ZILIgAAWnBknFZj/+4AAPosAAIAAFhw/AoIIAIQaDBbefNj/sQAAGwQNhPN1xfNpYstLTJ/ +HMzG+iAFK5AEPuD+zfMaACBfcPuyByABECgw+qy7IAAQIDD+rgoAEhBAMPuyDioABMKQjuAK4ADa +IFt6/cAg0Q8AAAAAHM3mjSD+ITYgBRBQMP8hNyAyEFgwWJxThi4jMn8JZhGmM/Y8TiAKAlBw/AoD +IgAAWbBYlOPwBxcAMAJAcPrN2BAVEEgw0w9tmgIACIqaFokg/AoDI/8QWDD8FCsgCxBQMPUUMCmA +BD5g+xUUKAkAVnApFgcoMAT6HDEkAN4GICs8UViUz9tg/AoDIGoCUHBYlMwlFEgkFEkkFEokFEsk +FE76LAAACxBgMP0KAiAJEFgw+xRNIDACWHBYN9DaIFt6y8Ag0Q/aIFt6ycAg0Q/aIFsj5oguIzJ/ +0w/wBxcJkAQ6IPgcfyIAIETw+IxBIBUQSDBtmgIACIr7zaoQAxBgMPsWMCCiAjDw+SIOIP4CUHD1 +FNgj/xBYMPsVaCC0AlKw+JkRAAsQWDD0FNMoCQBecPkWMSIAAFmwWJSi+zxOIP4CUHD6rF4gAxBg +MFiUnSQU8SQU8iQU8/tsAAASEGAw/BTwIP4CUHD8CgMg7AJSsFiUlNow/iIAIAsQYDD+FXwgAhBo +MP4hNyD+Alhw/hV9IIICWvBYN5rAINEPiS4JmRGp2YmXiZ4okDuxiCiUOy+wX7H//7RfIgAAULBb +/nDAINEPiScqmRTIoISZiUEowkT6LAAAABBoMPkMRwIAAFkwC4AAwCDRDy8dAfrNbhDQAlvwlLCU +sZSylLOUtJS1lLaUtyoWWokg+MJEIAIQcDD9TAACAABjsPX0fCmABD5g9PR7KAkAdnD5FlsiAABQ +sAuAAMAg0Q8AKzxIWJRhtRstsAH+sAAgagJgcC7EAC3EASuwAivEAmP+OGwQCC0hKSsgFiYgBxzN +B/UiCCIAAHFwKiB8iSeHVwqvCfmSDiD/EEAw+RYEL8AEP+D3cg4sACB7MPzCfyYgATAw/BYGIC4E +QvAtFgUAzo5bhHOMFv0SBSKPADagGMyFDGQRDwIACEQIK0I6/wIABgEGwuAjQjn5y/kSAgA04PAJ +BwIAAEjwAElhAElhAElhAElhAElhAElhLiEHH8x2/g5KAEgQWDD8CUYPwAQ7oP/uAg5IAWQw/jYA +L4AEP+D/zCEYCQB+cPgiACoHAWAw+zYDK1AEOqD7zGkQBhBgMPs2AimABDog/dsUCAkAYjD4NgEp +QAQ7YPS7EQAAEGgw/iB8KgkAWrD9NQogNBBYMPrNEBgJAFZwKzUL+yxyLwAEO6D57gIICQBSMPg2 +Bi4JAHuw/jYEIEACUPBYlAv6PCYg2AIwsPwKBiIAAFmwWJQGHM0B+MvWEAIQaDAtNDj9NDkgEBBI +MPk0LiCwAllw+DQ3IAcQcDD8NC0giRBQMPo0LCABEHgw/zQzIHQCUPD+NDUgAxB4MP80MSAAEHAw +/jQ0IAAQeDD/NDAggBB4MP80NiAGEGAwWJPsBmsC+QoLIIQCUPD5NEAgBRBAMPg0QSAGEGAwWJPl +KjxJ/AoDIJACWLBYk+H6PEwgBhAoMPwKCCCAAliwWJPciBQvgCApgCH6gCIvgAQ/4An/AvmAIy+A +BD/gCv8CCP8RCf8Csf8vhCMPjxQvhCIPjxQvhCEPjxQvhCCOcI1xLuw4/nYAIAICa3CdcYwnwND7 ++sAgQAJjMPVGOSoAQF8w/cUEIIACWvCbwJvBKyAWKgr/erFk+iB8IDQQYDBbg9LAINEPAIgiZIBU +GMy1jSf/IgAgAxBIMPkWAi/AEHAw+BYAIAEQQDD4/xEAQAJTcP6uAQ4JAEfw/xYBIIACc7D+1gki +AABYcP7WCCAAEEgw+dUUIAEQYDBbf9LAINEPACtsGPosAAIAAGCwW4QrY/+ZiiJlr5QrIFPaIPu8 +EiIAAGCwW4QlY/+BAGwQOCggBfrMOhAuEEgw+8oALgJxShAqFmX7FgAgEAJAcPAKFwAVEEgwbZoC +AAiK+8yCEEICYHAsFlybEv8iACAAECAw9BQbIAEQUDD6FCAj/xBIMPkVDCCQAlCw+hZmIAsQQDD6 +HDwvgAQ/4PoWXS4JAEfwnxMtIEkuIEguxAAtxAErIEorxAIkFDkkFDr0FDsgAxBIMPkUOCCoAliw +KxZeKBAALRAC/xABIEoCcHAv5AEt5AL45AAgEBBgMFiTahfMZxPLfBbLhxjLlCkgQSwgQBvMQPsW +ZyCYAlBwKhZfLKQAKaQBJSBCLyBDL6QD9aQCIKgCeHAvFmEtIEUuIEQupAQtpAUpIEcsIEYspAYp +pAcuIDklIDgl9AAu9AEtIDosIDss9AP99AIg+AJgcCwWYykgPSogPCr0BCn0BS4gPyUgPiX0Bi70 +ByogZS0gZC3EACrEASUgZykgZinEAiXEAy4gaS8gaC/EBP7EBSCAAniw/xZgIHACcLAuFmIqIGst +IGotxAb6xAcgyAJosC0WZPiCfCQQEEgwKRVB+RUhICAQKDAlFDwlFD0kFFwkFGwkFIyNJ/kiACAB +EGAwLBVE/dIOIP8QKDD1FUIiAABQsPY2nSAEEGAw/RZaKAkAPnD5NpwgBRBoMAuAAC0ynSoSWhjL +8A2NFPvL9B4Bim1QKaA6K6A7CJkRC5kCsZkppDsJiRQppDoqEmX52gAg/gJAcPkWLCByAkIw8AoX +ABUQSDBtmgIACIorEmYfzAL/Fi4gAxBgMP0iACD+AlBw9BTLIAEQcDD+FNAj/xB4MPjdEQALEHAw +/xVkLAkAd3D9Fi8gpAJSsFiS/BjLKCQU6SQU6iQU6/wKAyD+AlBw/BTvIGIQWDD7FOggYgJisCnA +AvvAASCsAlKwK6QBKaQCLMAALKQAiSCMJyiCfCsSZ/zCDigJAD5w+TacIAUQaDD8FlsiAABQsPY2 +nSAEEGAwC4AALTKdLxJbHsuzDY0U+Mu2HgFB7VAu8Doo8DsI7hEI7gKx7i70Ow6OFC70OigSZS+q +AP8WACAVEEgw8AgXABACQHBtmgIACIoqElwpEmYfy8KfEo0g9BQbIAEQcDD+FCAj/xB4MPjdEQAL +EHAw/xUMLAkAd3AtFgMskAArkAErpAEspAArEl4pkAIppAIkFDkkFDokFDv6El0gAxBAMCgUOCkQ +Ai4QAf8QACBKAmhwL9QALtQB+dQCIBAQYDBYkrItEmAsEl8q0AEr0AArxAAqxAEo0AMp0AIpxAIo +xAMu0AUv0AQvxAQuxAUr0Act0AYtxAYrxAcsEmIrEmEpwAEqwAAqtAAptAEvwAMowAIotAIvtAMt +wAUuwAQutAQttAUqwAcswAYstAYqtAcrEmQqEmMpsAAosAEopAEppAAYyr8usAMvsAIvpAIupAMs +sAUtsAQtpAQspAUpsAcrsAYppAcrpAb4gnwkEBBYMCsVQSQUjCQUbPQUXCAgEGAwLBQ8LBQ9iSCE +J/sVISABEFAwKhVEKxJn9EIOKAkAPnD5NpwgBRBoMPY2nSAEEGAw9RVCIgAAULALgAAsMp0Zy0sf +y3EMjBT+y24YAJdhUCgyphPLQSMyfwmIAQmIEQgzCC0yDA/dAQ7dAv02DCElALTgKAos+CQFIgAA +ULBbIY0by2IcyjL9y2ISAABQsFshqNogWyGL+iwAAAAQWDD8CgAgABBoMFv9/sAg0Q8AAAAAACoy +pimCfwuqAQmqEfzLUhgAIFZwipwby1IMqgH5FlgqCQBasPqWDCzfADZgKhJY2xD6rE4gAxBgMFiS +R/oSWCAQAlhw/AoLIAIQaDBYNVEsElgtwAX9xDAgMRBYMCvEBWP8owAvMqYu4n8I/wEJ/xH5yzke +ACB7sI/sGMs6Cf8B/hZZLgkAR/D/5gwtcAA3oCoSWfscfyADEGAw+7wxIJwCUrBYki0qEln7HH8g +CxBgMPu8OSACEGgwWDU2LRJZw8gs1AVj/TQuQDovQDsI7hEP7gKx7i5EOw6OFC5EOmP+3io8Tvsc +AAADEGAwWJIa+xwIIgAAUPD8CgsgAhBoMFg1JSgwBfg0MCBBEHgwLzQFY/6sAGwQCi4hGSsgFoYn +JyAHKiBT9Mq8EgAAYTCcGPqpCQD/EEAw9wdBCcAEPmD2Yg4kACBJMPRCfyAoBELwnhkAxY5bgi3+ +Egki7AA2oBjKQAxzEagzLzI6/wIABAE2Q+AlMjn5ybUSYQA1YPAJBwIAAElwAElhAElhAElhAElh +KyEHHcrr/MozEDAQSDD4yjMbQAFcMPQPRgvABD7g9IdCCgkAZvD7VgAngAQ94PoiAC4JAD/w+FYC +JgcBJDD5VgMnUAQ94P7ZFAAEEFgw9JkRC4AEOqD7ydMaCQBasPpWASYJAE3w+iBTICAQSDD5VQsg +ABBAMChVCihWCChWCZha+FYLLUAEO6D4VgwsCQBrMPxWBi4JAD/w+FYNIAYQYDD4Vg4rAAQ6oPhW +DyoJAHqw+6oCAIACWLD6VgQgQAJRcFiRwcBE+lwmILACOLD8CgYiAABZ8FiRvB7JjBnKtflULSAQ +EHgwL1Qu/lQ3IIAQaDD9VDYgiRBAMPhULCACEFgwK1Q1+1Q4IAEQYDAsVDP7VDkgAxBgMPxUMSAA +EGAw/FQwIHQCUXD8CgYgABBYMPtUNCIAAFnwWJGjjWOKYrHcfcsBsaqLYY1gmmL8ZgMgAgJa8Ptm +ASBIAmNwnGCNGIon9DY5IAAQYDD6rCAiAABbcFt6hIgn+frAIEACejD5CgAuAEBP8PmFFCCAAnvw +n4mfiCsgFi4K/36xCvogUyAgEGAwW4GeLCA3sMz7Cv4q4AFgMPwkNyAQBFqwwCDRDxzKhS0gBf4g +ByAFEFAw+CIAIDIQWDD4FgAiAAB4sFiY44onK/rA86IOICYQYDD8JAUgQAJKsPsKACgAQF5w+6UU +IIACSnCZqfmmCCIAAFCwWyCXLDERgiqxzPw1ES+eADSg8AAVYC0QGDAA+iwAAAEQWDBYN62CKWQv +gC0gBXPZ6YIpZS/0Y/9yjiJk4FYcylqIJ/siACACEGgw/RYGL8AQSDD8FgQgARBgMPi7EQBAAlIw ++akBCgkAZvD7FgUggAJKcPmGCSAAEHgw+YYIIAEQYDD/hRQgIAJYcFt9dsAg0Q8AAAArfBj6LAAC +AABgsFuBz2P/l44iZe+SKyBT2iD7vBIiAABgsFuByWP/fwBsEAooIAXClf8CAA4BHEoQLSEZKyAW +F8noKiBTJiAHhSf6qAkA/xBgMPYGQQnABDog9VIOJgAgRfD3cn8gLgRi8P0WCCABEGAwW4FY/RII +Iu8ANqAYyWsMYxGoMy4yOv8CAAQBN8OgJDI5+cjgEmQANSDwCQcCAABJMABJYQBJYQBJYQBJYSoh +BxvJXgoKSvbJXxvABDqg+8kPGgkAWrCaQPkiAC1ABDtg9kYCIDAQQDD4RgMgBBBQMP3YFAmABD5g +/coHGAkAVnD5RgEuwAE4MPogUyAAEDAw9kUKLkgBPDD2RggvgAQ/4PZGCS4JAHuw9kYKLgcBPDD2 +RgsvUAQ/4PZGDClABDog9kYNLgkAR/D2Rg4uCQB7sPZGDyAgEEgw+UULLAkAazD8RgYrAAQ6oP6q +AgAGEGAw+6oCAIACWLD6RgQgQAJRMFiQ68B0+kwmILACMLD8CgYiAABZsFiQ5h7IthnJ4PlELSAQ +EHgwL0Qu/kQ3IIAQaDD9RDYgiRBAMPhELCACEFgwK0Q1+0Q4IAEQYDAsRDP7RDkgAxBgMPxEMSAA +EGAw/EQwIHQCUTD8CgYgABBYMPtENCIAAFmwWJDNjVOKUrHbfbsBsaqMUY1QmlL7VgMgAgJjMPxW +ASBIAltwm1CKJ8Cw/AoAIAAQaDD3NjkgQAJSsFt5ro8n+PrAIEACc/D4CgAuAEBDsPj1FCCAAnOw +nvme+CsgFi0K/32xCvogUyAgEGAwW4DIKyA3sLv6Cv4o4AFcMPskNyASBFJwwCDRDwAcya8tIAX+ +IAcgBRBQMPgiACAyEFgw+BYAIgAAeLBYmA2KJyv6wPOiDiAmEGAw/CQFIEACSrD7CgAoAEBecPul +FCCAAkpwman5pggiAABQsFsfwSwxEYIqscz8NREvnQA0oPAAFWAtEBgwAPosAAABEFgwWDbXgilk +L38tIAVz2emCKWUv9GP/cY4iZOBWHMmEiCf7IgAgAhBoMP0WBi/AEEgw/BYEIAEQYDD4uxEAQAJS +MPmpAQoJAGbw+xYFIIACSnD5hgkgABB4MPmGCCABEGAw/4UUICACWHBbfKDAINEPAAAAK2wY+iwA +AgAAYLBbgPlj/5eOImXvkisgU9og+7wSIgAAYLBbgPNj/38AbBAEKCAFKyAHwZT7CkEOAErKEP3I +pRTgASww/KkRAgBKmWCMNq2ZLZI6/tJnYAEQMDAtkjn/yV8QXAA3YC4hJAsoQPrInBigBDog+yEJ +LgkAQ7D4ISIuCQB7sJ7QHsjy/yIAKAkAUjCY0pvT+P8RAAIQWDD81gUuCQBf8J/R8A4XADACU3AA +Cor7ljkiWAI5YMAg0Q+JImSQa2hSNMAg0Q8AAAD6LAACAABZcFt/P9Kg0Q8AjDNj/2uKJ/tMAAAA +EGAw+qwgIgAAaTBbeSTSoNEPiifAsPqsICABEGAwW3xcHsjTnqCNIAjdEfvJMxwJADdwnaGMNpyj ++6YCIAAQEDDRDwAAACusGPwsAAIAAFCwW4CtY/+CAAAAAABsEAT0yMIQARBAMPnH1xWABDzg+SYA +JAkARXD1JgEgEAIYsPAEFwAgAhCwAAOK0Q9sEAT9yRsQAhBYMCs0ACogFR7JGBjHzfhJEQpABDqg ++poCAAUQWDD/yRQaCQBasJox8AgHACACIPAARGEARGEARGEARGEoIAcICEHwVREJIAQ6IAhVApU2 +hSD/Ng4gABAgMPQ2CCADEFgw/TYQIKACIPD+Ng8tsAQ5YPw2ByA8ADWgLSAVwOH3NFksQAQ/YP40 +WCwJAG5w/jRQLAkAd3AtNhUM6jAIWhH8RQUqCQBasPpGAyDAAhDw0Q/SQNEPAABsEATzIgIv8RAg +MAQzAZMi0Q8AAGwQBNog/DwAAAEQWDBYlcXSoNEPbBAIh0QBlASJRotIL0ELjkfyQQoiAABQsA9P +FP6TFAIAAGDw8uhABiwBEDD77VAKHwFcMPq7EQdwBDmg+90RCcAEOiDwMxEICQBqMP6eGAwPARQw ++ZlWDVAEP2DzFgYiAwEUMP8zEQYJAGmw/hYFLAIBFDDyDkEMCQAfcP7uEQYJAFmw8kJBAAEQWDD4 +IhEOAQBf8PhmAggsATgw8ogQD8AEP+D/7gIPYAE8MP7dAg4PATgw9+dADuAEP+D/iAIO8AQ7oPdm +Ag4JABOw98goGAkAcjD5yLAYCQBKMJ0X92YCAgAAaHD2FgMoCQBKMPgWBCAAEHAwWJSX0qDRDwAA +AGwQBNog/DwAAAAQWDBYlYDSoNEPbBAIAXQEhUWORPNCBiIAAGDw8kIHIgAAULD3oQcsEwF0MPN2 +WA/gASww9XhSClQBLDD+qVAEEwEsMPKZEA/gBD/g97sQCEAEOiD2FgUnQAE8MPF3EQY0AXAw8jMY +CAkAWjDzFgYqGAF0MPKSFArQBD7g82YRAuAEOKD3ZgIGEgF0MPF3EA4JABfw/pJQBgkATfD+aVAM +CQB/cP5/UALABDig/RYHIgAAaHDyuwIGCQBF8P7/EAAYEEAw/5kQDjABcDDy7hEICQB+cPh3AggJ +AF5w+VsRBXAEPWD2yGoUCQA1cPcWAyoJAHbw+5kCAAAQcDD5FgIkCQA1cPUWBCAAEFgwWJRP0qDR +DwAAAGwQBBTIXtMPKkKA2yBbd+z4oRxiAAAasPpCfyIAAFiw/AoAIAEQaDBbd8XSMNEPAPpCfyAC +Aliw/AoAIAAQaDBbd7/6QoAiAABYsPwKACABEGgwW3e7Y/++AAAAbBAE9MhIEAAQQDAeyEco5tQd +yEYo1tQcyEYoxtQbyEUottQZyEUqCgD4ltQgDBBIMG2aGYkrBKsKjTsptsDzPPwh+AIQsP221CAC +AlKwGMgXKEa9wPUvRrxYdxbyrAAAGQC2oChC5ccv+IlDAB4AfjBokwciQujRD9EPANEPAABsEAQT +yCcqMn9bc8rUoPghDGIAACqw0qDRDwAAAAAqMn9bc8T6STJyAAASsGAATAAAAAAA+jJ/IgAAWXD8 +CgAgARBoMFt3h/oyfyIAACiwW3O5+kEmcgAAErCxWHgp1PoygCIAAFlw/AoBIAAQaDBbd33SUNEP +AAAAAAAA+jJ/IgAAWXD8CgAgARBoMFt3dcck0Q8AbBAEEsgCIiJ/IiEC0Q8AAGwQCBjGryQVBPvI +AxACEGgwnRGbEC4gDCwgDQjuEfAIBwwJAHMwLBUFKSEJmxD9FgEiAABQsPkWAyAgAkBw9BUEIxAE +OODwCKACCQARcPIWBCAAEGAw9hYFIgAAWHBYTTLRDwBsEAj7x+0QAhBoMJ0RmxCPMg8PXy8VBC4g +DCwgDQjuEQ7MAiwVBSkhCZsQ/RYBIgAAULD5FgMgIAJAcPADFgAAEGAw8AigAgAAWHBYTR7RD2wQ +BBnH2vhxDioAIDFw9DwIAgAgHLD0OwgMACBTMPwlAyIAICKw+rUKIBQESjAiNQnRDwAtLNgtNQrR +D2wQBtsw/EwAAgAAULBbet8mIQX/oBEvwBBoMPigFSwAQGyw/RYBLAAgbbD7rCAggAJrcPy8AAoA +Y2rQJ6AU9aEMIDgCGzD+oQkiAABY8Ph3CAoAWOjQ/8MIAgAAIvDzPBIuACB38Pz4CAIAAFjw+IwU +KgBL6ND4FgAiAAAa8P8CAAIAAFow/wIACgBDahAdx6j5QQAoACA78PV2CAgAIEFw+MUDLgAgcbD2 +tQAg1gRqcC41ACmgFS6hCS2gEfugFCAwADZg9iEFLAAgd3D9EgEqACBu8P1tCAAkAlrw/dxAKgAg +ZvD9uzhyAAASsJuj0Q/A8P+mAyIAABKw0Q8GvAxj/zcGOwxj/0wGOwxj/2YABosMY/93AAAt7Ngt +NQFj/5IGvgz+pgMiAAASsNEPAABsEAYZxkiNIC6SfCsyACyShP7dDAIAADDw9RYALaAEP2D9zAgA +ARAoMPrMICC2ACrwLjAJ+zwQIgAAarD+f0AOBgFwMAILhgBNYwALhgBNYSvAAS0K4A27ASvEASgw +CP0KvygJAFow+vsRCABAajD9Ct8oCQBaMPvrEQgAQGowC4gCKMQBKzIA98Z7EKIAJvAjwAGPYdug +9/8BCAcBGDDzbkAMgAEcMP1kCC+QBDug8YgQAgUBHDD6MxEOCQBH8P9mAS4JABuw/mQJICACabAG +C4YATWcEC4YATWWLYHu2ZC7AAYhhKwqA/m1ACAUBdDD4/1ACAMYCEB7F6vAOBwIAAHKwAE5hAE5h +wIAoxAEuIFT0CgAgMAA3oJwSlhMTxznwnhEM8AQ/YP7GkxwJAHdwnREdxzVgAM0AAACGE/wSAiAB +ECgwL8AA+P8McAEQEDAowAF4jwHAIPMSACIAAFMwW0BbHscqHcXuClgUDogR+N0MDoABVDDw8QQM +ACB3cCnSf/BcGg//EHAw/swDAgAAWbDwKhoIAEBmcPqZAgAAEGAw+dZ/IgAAUPBYlJXAINEPAACr +ZtmgB2wCLNazKNK0hREDiAH4VQIAABBgMPXWtCAQEEAwbYod9QoAIFwAN+AlkQAOVQL9yAoABAJK +cPWGtSACAmMwJtazKSBUsUT/AgAL/5zJECkgDcpOLCBVwIH8TAgIBQBOMAnJDCwgDAjIEQiZAguZ +AvmGQgEQAGJw8/+CZsABSDAAY/+qFsW6ZJ/JLCAMJWKD9mJ8ICAANmAYxrGoyCiA5amJqWkJmRGp +WSmcgImQBpkMY/+yGcWMKZJ4rJkJmRHz/+loACBNcAAADghGC4gCKMQBY/6BbBAEGsbgiyAsonuJ +MCqigwy7DPq7EQABECAw+pY2egAgWrAtoAD8oAEgIAJI8PIJFgIAAFqwAEtjAAmGAEthKzAILgrg +Dt4B/KQBKgkAdvArpACJMPzF5BCGACZwKKAAjzEKqQL4C0QIBwFAMPz/AQgQBDog+zQILgkAR/D/ +NgEgIAJY8AYJhgBLZwQJhgBLZfkyACAAEFgwKzUI+5YmcAEQEDCMMR3FW/bAeGIAAEqwK6ABAA2L +AElhAElhK6QBKaAAYAACKaAAeJ8HLqABeO8BwCBbP9sZxqoYxW4KWxQOuxH7iAwKgAFQMPChBAgA +IEowL4J/8EoaD/8QYDD8qgMCAABY8PApGg4AQFfw+f8CAAAQYDD/hn8iAABRcFiUFcAg0Q8poAD7 +CoAowAFMMAuZAimkAGP/jwAAAGwQBPkiACIAACCwk5GIIZOAAASIAAOKkiCSIdEPAAAAbBAEKSAN +KiAi+MU4EAEQWDD4qhEIBQBO8AqSAgIDRwgzCigymAKKFAuAAAoJQWiRAmmTGygyntogC4AA26D6 +LAAAABBgMFiT9NEPAAAAAADz/+pgABBYMGwQBMk2/wIAAABUhODJOv8CAAAAVoTgwCDRDwAAKCET +DwIA9T/oZAAgIjATxVBlcKZzYTOML/osAAAAEFgw/GwIAAAQaDBYktJmoRccxmIswX/6LAAAAhBY +MPTMCAAAEGgwWJLLZqDvc1EvjC/6LAAAABBYMNMP/FwIAAAQaDBYksRmoNr6LAAAAhBYMPxMAAAA +EGgwWJK+ZqC8+iwAAgAAYTD7CgEgABBoMFiSudKg0Q+NLPP/VWQAICNwAAAAAPosAAABEFgw/EwA +AgAAafBYkq/SoNEPAPosAAABEFgw/EwAAAEQaDBYkqlmoGlzUS76LAAAAhBYMPxMAAABEGgwWJKj +ZqBQLCIP+iwAAAAQWDD8XAgAARBoMFiSnWagO3NhNBzGLCzBf/osAAACEFgw9MwIAAEQaDBYkpVm +oBiML/osAAAAEFgw/GwIAAEQaDBYko/SoNEP0qDRD9Kg0Q/SoNEP0qDRD2wQJIgihzT0xP8SAAAx +MCQWBCQWBffXUgIGFSogAioC9hYsIAcQWDBYkd/HhPasAAYGT8aQ/cXiEABOrqCJMCoxBS8xBvYx +ByASAC5wizFmse8uIA1k4Kz6FjsgDgQj8GThPJ8U/xY6IA4EIbBk4UKWFSYWOWRwqf8CAAAAogXg +wGAG/FD7CgEgABBQMAy6OGSgQooweqYhZHI4/wIAAAEhheD7CgEiggA14P8CAAAEvwXgwGBmYB2K +MP2kAQ4AB26QjjH/AgACAKWHkMhGiTEJ31Jk8SnaIPwK/SAAEFgwWJL1KPqNeKECBqY42iD8Eiwi +AABY8P1cAAIAAHGwWHGP0qDRD2RyCP8CAAABCIXgGcS9KRY7/wIAD/+jI9Bj/0EAJiESKhI7/wIA +CgXzspCKKisSO1t1UP3FohAF+yqgKxI60w90sReGLv8CAAoGITLQKiIQW3VI/cWaEAYrKqAuEjn/ +AgAH/4ynkIYu/wIACgYwM5D6IhAiAABbsFt1Pv3FkBAGN6qgKBI6/wIABgZCphAZxbcpkH1lnuNg +DJcAii8K+gwqFjr6FgQv/2ChkGP+vIsvC2sMKxY5mxVj/rSGKywSO/8CAAoFxDMQ+iINIgAAWzBb +dSj9xXoQBcoqoC4SOv8CAA4FgSOQLxI5/wIAB/9HJ9BgCu8AAAAAAAAA/wIAAgB2DlD/AgAB/2US +UGAMQywSO/0SOiIAAFCw/hI5IgAAWfBYZsn2rqliAAAysBjFY4Qw8/6SZABAQTAAAAAALjET+zEb +IAAQUDD2HBAgABBgMP7GOAAoAkhw+6k4AAScqeD/AgAABgeF4B/EZS8WO8BgZm5d/wIAAAS3qeD/ +AgAABMYF4C4gDf8CAAAEtSugKhI7iBT4FjogGAQiMP8CAAAEvKugJhI6iRX5FjkgGAQicP8CAAAE +t6ugKRI5LDUEKjUFKTUHJjUG8/3DYAAQMDAoEjsmIRPz/cVmACBBsCgSO4Ys8/24ZgAgQbAALBI7 +LRI6/hI5IgAAWfD6LAAAARB4MFv+5PP9yWIAADKwKSETCakMKRY7Y/34iywLqwwrFjtj/e0AKSAN +ijEvMQotMgQlFj30FjwoJAF4MP3EQQVgAWww/lUQBCAEOSD1RAIEDwFsMPiIEQTwBD1g+spQBAkA +RXD1MggkCQApMP/sQA4sAXgw/hYtL3AEO6D8zBEIGwEoMP3tQAgFAErw/cwCCZAEOiD17VAOCQBD +sPX4UAQaASww86oRBSAEPWD1MQsqCQAqsPvdEQggAXwwDwIA9UUUCeAEPmD6iBEEAQBdcPjdAgXA +BD1g/yhACAkALnD/NUAODwF8MPGUBA9QBD/g/1URCgkAerD1iAIKCQBysP4yBygJAEow/TIGKgkA +arD4Fg8qCQBisCoWC/6fFATZAWww/t0YDwAEP+D1xP8UCQApMP8WDiIAAGGw/RYNIgAAULD1Ej0k +CQApMPQWDCAAEHAw9BI8IEACaHBYkOP9xNgQBRYuoIg09hY4IHYADjAcw9IrEi35IAcsACBi8CzA +gC4K+/6ZAQ3gBDsg/JkCAPwQYDD2FjgoAEBmcPYlLigJAF5wKSQHLhI69qwABgFap5AvMQoPD0H+ +IA0iBO1D4CoSOvsyCCCAAmhw+SIPIAEQYDD+zjkAABBAMPtLUwzQBDug/LsCAgAAcjD8EjgoACBW +cPsWFyIAAFCw+RYwIAMQWDBYkLn2q8piAAAysCYSMIkx/TIIIAAQQDAoFh/2qxQGoAQ5oP3PUQwB +AWgw/f5ACBwBTDD9KkAIcAQ+YP2qEA7wBDug/swQDsAEP+D2/wIMCQBzMP+qAgAAEHAw/KoCDAwB +aDD6Fh4sDQFsMP3dEAIAAFCw/swQCAkAbnD9HGAoCQBmcPwSOCgJAF5w+RYdIAIQWDBYkJT2qzdi +AAAysCYSOBjEsos6jziKOyoWMi8WLisWMfiAfCwKAXgw/BYzKAsBfDD4Fjco0AQ+YP8bQAlQBDog ++TESKAkASjD7FjUuAAF8MPggDSYJAEGw+RYvKkcBSDD6FjQoRAFMMPkWNiAPADYgGcNX+WYCAAEQ +eDCJMSghBywxCgF0BCoSMi0xEysSMQqeFP7dEQ7gBDug+roYDAkAd3D+EjcrFwFcMCsWJSoWJv5f +FAvABD/g/8QOGgkAfvAqEi75yVAOUAQ7oPCZEQ4JAHuw+A9KCAMBUDD9iAIPEAQ/4P/uAg4GAVQw ++o1ADvAEP+D/mQIOCQFUMP3dEA7ABD/gD90C+n9ACiQBUDD+/xALMAQ6oP4SLyoJAHKw/90CDiwB +ZDAC/xH+PEAOQAFwMPnMEQ9wBDug+hIzLgkAU7D8EjQuCQBn8PTMEAoQBDqg/BI1KgkAYrD5CgIs +CQBPcAmIAvgWJyxQBDsg/BI2KgkAYrD/w1wcCQB/cC0WIv0cfyxwBDsg/MNFGgkAYrD/7gIAAgJr +cP4WJCAAEHAw/KoCDbAEOaD8EjAqCQBisPsKACoJAFqw+hYjIgAAULBYkCUdxBn2qXViAAAysC4S +OdMPDwIA/wIAB/yiJ5CELxzEPiYgDf8yDCIAAFCw/ME/IAEQQDD4EjkmBQAyMP9PUwbQBDmg9hI4 +LgkAN/D9HEAgAxBYMP8WFyAAEHAw+EQIDAAgMzBYkAv2qRJiAAAysIg8HMQpjzEtEjj8wT8gABBw +MP/PUAoNAUQw+BlABgwBQDD4+kAG4AQ5oP+qEAjgBD5g/bsQDnAEP+D7/wIKoAQ9IPgoQAgJAFZw ++jIILAAgazD+Fh8gwAJocP2IEAAAEHAw9v8CCjwBUDD0phQKwAQ6oPb/AgoJAFqw/xYdKAkAUjD5 +iAIAAhBYMPgWHiIAAFCwWI/k9qh1YgAAMrAoEjgZxAKMPos/jzwvFiorFjIsFjErIA0mkT/5kHwq +CwF4MPkWNywKAXgw/BYzKtAEOqD4MRomACBBsPgWKylQBD5g+pkCCgEBeDD/D0AGCQBJsPoWNShH +AUQw+RY0KEQBQDD4FjYgDwA24BrCpfpmAgABEHgwiTEoIQcsMQoBdAQqEjItMRsrEjEKnhT+3REO +4AQ7oPq6GAwJAHdw/hI3KxcBXDArFiUqFib+XxQLwAQ/4P/DXBoJAH7wKhIq+clQDlAEO6DwmREO +CQB7sPgPSggDAVAw/YgCDxAEP+D/7gIOBgFUMPqNQA7wBD/g/5kCDgkBVDD93RAOwAQ/4A/dAvp/ +QAokAVAw/v8QCzAEOqD+EisqCQBysP/dAg4sAWQwAv8R/jxADkABcDD5zBEPcAQ7oPoSMy4JAFOw +/BI0LgkAZ/D0zBAKEAQ6oPwSNSoJAGKw+QoCLAkAT3AJiAL4FicsUAQ7IPwSNioJAGKw/8KqHAkA +f3AtFiL9HH8scAQ7IPzCkxoJAGKw/+4CAAICa3D+FiQgABBwMPyqAg2wBDmg/EwACgkAYrD7CgAq +CQBasPoWIyIAAFCwWI9zHcNn8/aMYgAAMrAtMQoqMgQoIA38MggkJAFoMPrOQQgOAWww+g9LCcAE +PmD+/xAOIAQ7oP/uAg4PAVQw+EQRDvAEP+D66kAOCQAn8P/uAg4bAWQw+DIBLgUARvAKmQL86lAE +HwFgMPysUAgcAUAw8swRCTAEOiD8iAIMDwFoMAXMEfwxCygJAGIw+6oRBaAEOSD8TBQKCQAisP0E +QQwBAFsw/kQRDcAEOyD8RAIMAwFoMP0tQA3wBDsgDN0C9DEKLAkAJ3AExEH5/xENcAQ5IPGUBAwJ +AHsw/DIHKAkAYjD6MgYoCQBSMP0WDygJAEowKBYL/J0UDtkBVDD8qhgCAABhsP/DQR4JAHuw+hYN +LQAEP2D9Fg4iAABQsP0cIC4JAHuw/hYMIAAQcDBYjyf9wxwQAB4uoCgyBA8CAHOGLhvCFvkgByoA +IF0wK7CALAr7/JkBC+AEPuD7mQIA/BBYMAuZAfYlLigJACZwKSQH8/UhYgAAMrAAAIoqLKEC+RYo +IR0ANyBbbsgdwwUqFin6FjsgFQA1oCoiEC6hAmTi9ltuwR3C/5pgLxIo/wIAAftRq+AqIhAooQJk +gvVbbropEigdwveakGP2hy4SOywhE/P2k2wAIHMwy3j/AgAB+0ud4CsSO4os8/aKagAgWrAuEjuM +LPP2b2wAIHMwhi/z9ohmACBBsAArEjmJL/P2j2gAIF5wKxI7KiET8/ZXagAgWrCJJyyZFBTC0/TA +YWBAAlJwK5IJZLBWLbAALgoqftkFL7ICdPFD+woAIAIQYDBbeYEZwwAcwoecoIsglKKTpfakHC// +EEAw9aYGIAIQYDD5pgQrgAQ+4PikHSoJAGbw+6YBIgAAUXBYkJDAINEP+woAIAIQYDBbdf5j/7QA +AB7B0S4WO/P1q2/0EDAwAAD2EiwiAABQsPsKHCIAAGCwW3R0Y/9cAAAAHMLjLxI6LiANLSAM+BI5 +IAIQUDD4FgAgEhBYMFiRKB3CrvPzc2/qEDAwHMLaLxI7/SAMIAIQUDD2FgAgEhBYMFiRHx3CpWP/ +2BzC0y0gDP4gDSACEFAw/xI7IBIQWDBYkRcdwp1j/7kcwswvEjv9IAwgAhBQMPYWACASEFgwWJEQ +HcKVY/+aHMLGLSAM/iANIAIQUDD/EjsgEhBYMFiRCB3CjWP/ewAcwr8vEjouIA39IAwgAhBQMPYW +ACASEFgwWJD/HcKFY/9YHMK3LSAM/iANIAIQUDD/EjogEhBYMFiQ9x3CfWP/ORzCsC8SOS4gDf0g +DCACEFAw9hYAIBIQWDBYkO8dwnRj/xccwqktIAz+IA0gAhBQMP8SOSASEFgwWJDnHcJtY/74AAAc +wqIvEjkuIA39IAwgAhBQMPgWACASEFgwWJDeHcJkY/7UABzCmi0gDP4gDSACEFAw/xI5IBIQWDBY +kNYdwlxj/rQALBI7LRI6/hI5IgAAWfD6LAAAABB4MFv8CvPyYmIAADKwii0roQJkvj9bbhEdwk8q +Fjtj8+YAAAAA8/IhYgAAMrD8woMQAhBQMP0gDCASEFgwWJC/HcJF8/IDb+oQMDAAACsSKYoq/AoA +IAEQaDBbccwdwj7z86Zv9BAwMMhri2D8CgAgARBoMFtxxisSKYoq/AoAIAEQaDBbccJj/9IAAABs +ECCIIicyACQWGv8CAAb4ATww/wIAAgQXKiD6LAAABBBYMFiOI8fE9qwABgQGZpD0wg8QAYuuoIgw ++TICIBQALjAqMgFmpBsuIA2KLvcWFigAQCZw95wAA5oAN6D/AgAKBCvR0PoiECIAAFnwW3HE/wIA +AAQ2KqAqCgD2rAACzAC2oCoyAP8CAAABUSqQLCETKTICLTIEKyAN+xYiJ3QBSDD8aAwP4AFoMAzv +DAv+OAuGOB/CP/gyBiQAQCJw+zIFJsAEOaD4FiUkCQAxMCQ2AvgyBywAQH9w+BYmLAkAd3D9NgQq ++AFQMPYiDyASEEAw+w5PD+ABbDD+FiEuACB/MPihE3YAIDmwKQoheaEIBEhbCMgIKBYg/xYdJBgB +aDD0FigoFgFsMPkWKigZAWgw+BYnLBcBaDD8FikoEwFYMCgWLBjBofkyASwaAWgw/BYuJBIBaDD4 +gX8sVwFYMPQWLSgcAUww+RYrIBgQSDD7RFIOABBGUCwWHPQWGyHcAkKw/1ogJUAQSDAI+TgpFi9g +AA0sFhz0FhslQBBIMCkWLwsPUvgKESw0AWgw/TRQBgGKRpDBgvwWMyYCaUaQwYP/AgAGAbLGkMKR +/wIABgOZzpCNFooVixQrFiMqFiSLF4oYKRIlCXhYKBYRKBImAXQECJkYCJgU/u4RCOAEOiAI7gL4 +Ei8uCQBxMP3B6hTgAWgwKRYS+EoUCOABVDD9RBEKAEBqsP0SGyhFAVAw+BIcJAkAQTAuFhMuEi33 +3RAIQAQ6IP0SLigJAGow/JkRCuABUDDx7hAMIAQ/YPWqEA4JAGuw/RIdLgkAQ7D7EiQpsAQ64PgS +Iy4JAEOw8d0RCAkAdnD3/hEECQBJMPkSJypgBD7g9BYPKgkAWrDzyxEO4AFEMPoSLCwJAGqw/RIr +L0AEP+D8EioqCQBm8P8SKC4JAHuw/hIpKgkAdvD7FhAowAQ+YPDdEQAAEFgw/f8QDPAEOyD9EhQs +CQBrMP7uEAgJAH5w+aoRCAkAdnD9DUcAABBwMPyZAg0gBD9g/aoCAgAAYbD9HDAoCQBWcPkWDiIA +AFCwWI101qBmYCCKMBnBZ/mrAQ4AB06QijH/AgACAHGGkMi2iTEJ21JksLTaIPwK/SAAEFgwWI6a +98FTH40QYDD5IgIgDgRisAamOIwnDwIALckUK8wg+sIJIGYAN2BkkMz/CiogXgA2oC6gAH/pCxjB +QyyiAnjBenfBQNqw/AoCIAAQWDBbd/YZwUAsEhodwPudoIsgl6KTpZWmJqQdLKQc+LsRAAIQYDD5 +pgQqCQBm8PumASIAAFFwWI8GwCDRD2SQatqw/AoCIAAQWDBbdHNj/7SHLweXDGP8YQAAAAAA/wIA +AgKhDlD/AgAB/5+SUGAFT3fJkWP/wgAAAAAAAAD8EhYiAABQsPt8AAABEGgwWGLNx4T2rAAGAgZG +kGavChzBIosw8/74agBAZvAA2lD7PAACAABhsFiOwdogWIbF0qDRDyoiEC2hAmTVEicWFlts1y4S +FoYv96wAABIQWDD6ZggGAK5fkMGT/wIABgCpT5DAYGVusx7BSIoyjC8tIA33zAgCAABZ8P3LOAoA +QHKw/DYDKgkAWrCaMvP7xGAAEDAwKCBgDQlRAJAECAgb/wIAAAGu/hApFhQmJQktIA0Yv/n6EiAg +ARBYMCsWI/olCCAAEFAw+iQUKAAgQnAogIAqJBX7IgAsBQBu8P6IEQABEFAw+hYkKAkAQnAoJAfz +/L5gARBQMAAZwKgrIGD5kkAqMAFoMACgBAsLGwlpCvmSACABdv7QKhYUKRYfLBYzLxY0G7/cKCEH +LSAMJpUJKJUH/ZQML/8QQDD4lCwgCBBoMC2UBP2SByoAIF6wK7CAKBIi+JQNIAAQQDAolAUolAb4 +lBQr4AQ+4PiUFSoJAF6wK5QHKxIgK5UIi5At2RQrFjKYkv0WHiPTALdgwIH4FiMgARBoMP0WJCAI +EFAw+pQFIAAQaDDz/AdgARBQMAAAKiITK6ECZLQGW2x5Hb+ELCISK9J32KD60oAsACBDMPwSFioA +IGbw+bsRABIQeDD+IA0qACBasPimCiYA4v8Q+hYwIdoAN6AewGiNIC7iYQ7dDB6/kw1fFA7/EQ/u +DC7tB/7iDCiAAWgw8IEEAAEQeDDw/xoABRBQMP/uAQABEFgw/MDWHgUAcvD+FhggABBYMFiPDykS +MC8SGC+UVxjAUiiCQAhoCpmAY/4GGcBPizgpkkD/FjQrcAFcMCsWGQlpCvmSACIAAFCw+RYfIAEQ +YDBYbbEvEjT8EjMhdQA2oI00+yBgLDABbDAtFhQA0AQLCxv9oCYgAK1+0C4SGSQWNishByQSHykg +DPogDSAAEEAwKEQVKEQUmEIoRAYoRAUrRQcqRA0bv28qEhT5RAwoSAF0MPiZEQgHAXAw+6sIDsAB +cDD7sIApUAQ6IPkSHSgJAEow+UUILgkAQ7D4wKEQCBBIMClEBC5FF/4SISvgBD7g+ICAKgkAWrAq +RAcrMgcIaBQI7gz6MgYvoAQ7oPZFCSoAIF+w9BI2KgAD8tAqrAEoEh+Ohy2ELJuJmoiLgCkgdi0g +DSmEFi7pFPsWMiABEEgw/hYXLAUAbnD9FjEiXQC3oC4SH8CoKuQF/jIFIAAQSDD5FiMgARBAMPgW +JCABEFAw8/oLb+ABcDAAAAAAAAD6FjAgGQA3oCnSeYggL9KBCYgMCogRqP+frmP+IR7AcS0gDC7g +gADQBP4OGwAFEFAw/MBtHgABcDD+FhUgABBYMFiOoykSMC8SFS+UV2P+TPP682/qEDAw2iD7Chwi +AABgsFtx3ownKMkU9IDqYEACUzCLyWSw4CmwAMLKfJkIHsAPLbICftFH+woAIAIQYDBbdsMbwAop +EhofwFQcv8icoIggk6WVpi+mBCmkHPumAiACEEgw+IgRD/8QWDD7pB0oCQBKMPimASIAAFFwWI3R +wCDRDwAAAAD8wEYQEhBYMP0gDCIAAHnw+hYAIAIQUDBYjnfz96Rv6hBQMAAAAAAA/MA9EAIQUDD9 +IAwgEhBYMP4gDSIAAHnwWI5tY//UAAAoIGANCVEAkAQICBv5FhQh/5B+EP0KACAAEFgw+xYkIAEQ +UDD6FiMgABBYMPP4sWAAEFAwAAAAAPsKACACEGAwW3MeY/8sjC/6LAAAABBYMPfMCAABEGgwWIx1 +8/nsYgAAMrCML/osAAAAEFgw98wIAAAQaDBYjG7z+c9iAAAysCcWFvP7DWIAADMwHMATKRIe/iAN +IAUQUDD9IAwgABBAMPgWASASEFgw+RYAIgAAefBYjj8pEh8vEjSKlywSM/sSMi/AEGgw+KwgIAAQ +cDD+pRQoAEBqMP4yBSCAAkIwmKmYqPP71W/gAXAwAAAAAAD6IhAiAABZ8PwKACABEGgwW28/8/qN +b/QQMDAcv/QpEhf+IA0gBRBQMP0gDCAAEEAw+BYBIBIQWDD5FgAiAAB58FiOHy4SHy8SNCwSM47n +KxIyLRIx+PrAIEACU7D4CgAqAEBCsPjlFCCAAlKwmuma6GP9TWwQBha/wAYkCi5ChA4OSwnuEf8C +AA4AwwegGr9X+QoAIAAQYDD6oIAgBBB4MG36EQCQBAoLG/+3BnACAkpwsczTDxe/zvUKgCAApacg +H7/M/QoAIAAQUDD78pkgCBBAMNMPbYoQAKAECwkZCQlD+SEUcAgCUrD//AQgAgJrcPzZ1nAAEFAw +ZtDiGr5DG7++AiwK/KJ8KgAgZvD6ooAoACAu8CmQzqzcCcwR85kcCgAgYrAqoTPAygyZLaeqCpw3 +DOwMZsDepbwvwNAt+pz/2R0KAQBScArqDKmpZpDGLcDPDT0cwPoP3S36ehIIAwBucPl5EgsABDqg ++pkCC8AEOKCmrSnW6bSspswpxum4qKaIKYbpvK+m/yn26R++QBy/mi/w0Co8f/yqAQI6ATvgCukM +ZpBv/L6PEIAQQDComAh4EgyIAihGkixCiAwMSwnMEfrKDAQAEEgweaJILa38DX0S/UaXIAAQEDDR +DwAbv4YCLAqsu6W5KZDOA5kcwKoKmS0HnzcP7wxm8Bkav3xj/zQAAAAA8/7xYAAQaDDAINEPAAAA +APy/ehgAICrwL4DO+YDPIgAAaLD5FgAiAABw8PiA0CACEFAw+BYBIBgQWDBYjZ/HJNEPAABsEAQY +vur3vukQABAwMPAhBAABEFgw8LkaAQACYLDwwQQCAABQsPC7GgAAEBAw/64uYAAQKDAtCgRt2g8G +Xgqn7i7iw/6YBHACAilw9m1AIAICELD4jUAlrAI4oMAk0Q8vgsJ/sOXRD2wQBMCh978vH/8QSDAT +vkj4LIAiCQAcsPN2sy6YALigKHK0CMhSHb7WAlwUDcwKL8KEAg5EAOEEAKsa8OEEChEATvDwUxoO +AEB+8AP/Ai/GhC3CiADhBPBNGgoAQG7wDbsCK8aIY///K3K0Hb85HL85wOD07DkKAEBu8Ay7Ait2 +tACBBCJ2swCkGvRgImIRAEkwKXKvCSkBCUkCKXavFb8uBoMR9TMIAAMQeDCfMNEPKnKvCioBKnav +0Q8AbBAGgyAVvogsIFr5IgggARBYMPpSmyAAEEAw9FKgLAcBYDAMuDj6MwwJkAQ+YPSBKWQAIEkw +L0B+LkB//wIACgCEe5AtUqot0QJk0Pqx7i5EfypSqltqhigKgAioAigkWixSVg8CAA8CAP+sAADy +ADcgKcz/+csBDgAPzxBtCA/6vP8iAABi8Pq7AQ4ABNcQY//pAAAPzBEdvcArUlUM3SwtJRoN/Rz9 +JRkqAA1Y0Bq9eyqieylSoKOqCaoR8AAGaAAgVnDAkBu+V8PqLrYQLbYRw8ssthAcvvIPCkYIqhEM +qgIqthGLsB2+7xy+Tv27AQ2ABDzg/QogKgkAbvANuwL7xgAgCAA2YJqamJuNIC4hGZ4QKyEarrv8 +vuMR/gJa8JsRKkB/+hYCIgAAcPD5QH4gGhBYMPkWAyAFEFAwWI0EwCDRDwAAAP08AAAFEFAw/L7X +EBoQWDBYjP3AINEPAPP/NGABEGAwbBAIFL5/iTD0mgEAIAAucIgx0w//AgACAXUGEMBg977KEAkA +NqCNMWbRocBA/wIAAgBJqlB5lnorMQTaIPsLSwABEGAwWGua8qwAAywANqAtMQwroCYPAgAH3QH9 +NQwvwAQ+4C80ECyhGsDhDOw4DcwCLDUM/KBYIBQCaPBYjI72oC9iAAAisCowEdMP+woAIB8ANqBt +CBIuIDz04BFgAgIQsLG7ersHb7QEY//mAAArNBHaUPs8AAIAAGEwWIv2wCDRDyYxBPYGSwIAAFCw +/AoBIgAAWbBYa3ZkoporoDb/AgACAUp20CwwECggYQxMQwDABAgIG/8CAAABPv4QH70/r8//8IAi +AABrMPykJiACEEAw/gqAKAkAQvD4pDYv4AQ/4P/PAgwAQHGw/6QHKAAKcZD+CoAqSAE0MPAAB2oA +IHbwBgtGLyIUKPEDL/ECePFM8tkRDjQAuuAevnwLXxT5+QoMgAFcMPAAD2gAIHZwGL53+JkIDEAB +XDAfvfevnybygPDRBAABEHAw8O4aD/8QQDAI6AMIZgEG7gIu9oDKxBi+PyygDB29WQ29Ai2GsymC +tB2+aPTMEAgAQG5wDJkCKYa0K4aziTBj/mckMBAvIGH5MQQkZAEgMABABA8OG/nJQgAAzf+QKiIU +KKEC+RYEIBIAtiCUFfAAQW/0EGAwAAAAAFtpwPkgDSEpADagLCBV+yAMIAEQaDD6zAgIBQBPcAnJ +DPi2EQAAEGAw+AqAJgkAMnD0FgUmCQBBsPTMAAFiALcg2iD7bAAAABBgMFhrF/esAAFpADagW/8P +KHA2wJH2dSsoCQBKMPh0NirAATAwWFiLixX8EgQiAABR8Px0WCAUAmjwWIwL9qFZYgAAIrAdvi0s +MQwfvi8uMQT/7gEMAEBrMPw1DC4JADOwLjUEK3Ea+jARIAEQaDAL2zj8uwIAABAwMPs1DCE8ALag +YAAfb2QcKqKHLqECyeNbaYqnbCrEPCswEbFm+rySG//yXZAXvhUmNBGJMGP9LgAAAAAmMQT2BksC +AABQsPwKASIAAFmwWGrm/KwAAFwANqD6LAACAABZsFhfwYkw8/ztagBAInBkntcdvH8rIAwq0nn9 +0oAgIAA2YBy9mKy8LMDlqcmpqQmZEanZKZyAiZAKmQxj/sAZvHMpknirmQmZEfP/6WgAIE9w8/03 +b+oQIDAcvfcuIA39IAwgAxBQMPQWAC/qEEAw+BYBIBoQWDBYjBJj/9MtIAwuIA36CgMgGhBYMPy9 +6xIAAHkwWIwLY/zy/L3pEgAAebD9IAwgAxBQMP4gDS/qEEgw+RYAIBoQWDBYjAFj/5EAABy94I8U +LiAN/SAMIAMQUDD0FgAgGhBYMFiL+WP8rAAAGrxLY/7HAABsEAYVvaP6vL0eHAC44PAACWyAARgw +AAADDEL5CgEgABA4MPDBBA4JAFCwLlbF8JsaD/8QaDDwwQQKEQBu8PB8Gg4mATjgL1LGD78BD88C +L1bGYAARA1kUBZkKKJLHCLgBCMgCKJbHIlbFlxAmQCaXEfosAAIAAFhw/WwAAAgCYHBYBVcTvbaM +EfsSACH/EGgw8yMLCgAxl1AtMoEpMoDwYQQAARBwMADuGv6yGGIAAHpw/e0CAmQBOyAH6RDwACdo +CQBP8ADH//IWAiIRAHuw9+gQAgBAE3D8LTgIEQB6MPISAigAQEZwLTaBKTaAYABXAAAAAAAAAPJt +EQMDEEAw/r2YGgBmkhAZvBzwACdsACB3cMSQH72THrwY8GEEAAEQQDAAiBr9nQoJAAQ+IP/dCAgJ +AHZwHr0Ert3+0oAiAFTC4AnpAinWgPCtEQuABDsgDaoCCroCCglH+zKAIJYANmBpkUcZvYAKCl/5 +uQEOUgC6oBi8YgioAihWsyVStAXFUghVEQWlAvgKgCQJAC5w8AANZAkARXAlrIAIVREFlQJb/fAo +MoEoNoElNoD6Qg4iAABYsFtsvMmh+kIOIgAAWLD8CgAgARBoMFtsl8Ag0Q8pKv//AgAL/52WUApp +EQkpDCmd/mP/LGixP/P/V2AAEEgwAB28EB69XQwsEa7MLcaDx78rxoItxoErxoAnNoEavVjbIPc2 +gCAAEGAw+qJ/IAEQaDBbbIBj/4EZvVLz/xRoAEBPsAAAbBAEAQQEBDkY+goAIBsANmBtCAywmAiZ +AfSQC2ACAlKwY//sAAAAAP279RvgASQw+QoAIBwANuDTD20IDLC8DLsB9LAKYAICSnBj/+oAAAD/ ++v8gARBYMBy9NwxYEayILYaDL4aCLYaBL4aADz4DLoaDD0wDLIaCI4aBJIaA+gxAAEACcHD+4gAo +AAFIMPiIEQ1wBDsg+L0jHAkAQzAA4QQAuxr4WAsKCQBm8CuGgQNsEf7uCQpIATww8OEEDsABODDw +zBoLgAQ+4Py7AgwHATgw+7voHgkAW7AJzBEM7gIL7gL+hoAuIgC4oMAx8AAPZIABEDAAAADyBEIA +ARAYMBa81h278ABBBAA0Gv9DAwwJAG1w/WbFLioBOKAuYsYOPgEOTgIuZsYlZsXRDwJXFAZ3Ci9y +xw8/AQ9PAi92xyVmxdEPbBAEHLzGwJD4vMMQABBQMPvMCCCAEDgwCJIKIiLHyyctsnsmwoKq3Qnd +Ea1mbQghfycTLzAMLmAMJTAN9GANIA4Ie7B1QQ0CEhT0IAtmACA5sGP/18Ah0Q+xmfqsICVyAjpg +wCDRDwBsEAj7vN0QgBBIMPxKACAeAODwA4ZC8AAHZgAgSbADBkYZvCsLKAsogoDzhz9wARBQMPe8 +nh4gALmgBgtEALEEAK0aYAAIBg1CANEEAK0aG7uyCy4C/nbFLkgBOaAvcsb/3wEAARBAMA+POc71 +KEEACYgBDIgCKEUA0Q8AAAZaFAeqCiqix/raAQABEFgwCro5ZK/Y+lIOIgAAWLBbbAksQQEtQgH7 +vLgSABB4MP6sAAAAEFAwbfoTKLKBeMkFKbKAedEH+7wQIAICUrD7rAAOAGoSkPsWBC4uALmgBg5E +8OEEAAEQaDAA3RpgAA8AAAYOQvDhBAABEGgwAN0aH7uGD78C/3bFLgCQwaAocsb42AEAARBIMAiY +OWWBIhK8l4oUAqILLSKBLSaBKSKAHLtD/JkCAgAAWbD5JoAgARBgMAERAlgE9ooUK1AmARECWASX +KUEA/FAmKEwBTDAtIoEoIoAtJoEbvIsMzAnwwQQJMAQ+YACZGgDBBPC7Gg//EGAw+kEAKhEAZvD7 +u9EYAEBaMAmIAvgmgCoAQFqwKkUA0Q8AAAD6FgQh/xBQMP4WBSoAT9qQF7x20w8rcn8rsQIsSgD5 +u8MepwA24Nog+2wAAgAAYXBb/pEqcn9bZ86MQS5BAPtBASIAAHjw/VAmIgAAErD+zkICAABRsP0W +ACIAAGiwW/8UjxXI/PpSDiIAAFiwW2usZKDkGbxgKEEACYgBAogCKEUA0Q8GWhQHqgoqosf62gEA +ARBYMAq6OWSu3By7pCtBAAy7AStFANEPAADaIPtsAAIAAGFwW/5w8hIELioAuaAGDkTw4QQAARBo +MADdGmAADQYOQvDhBAABEGgwAN0aGLsljxQI/wL/dsUuLgE5oClyxvnZAQABEFAw8AAYaAUATrAG +WRQHmQopksf52QEAARBQMAmpOWSQHgZrAvoSBCABEGAwWASUKhIEK1AmWAQ2Y/8tAAAAAAAcvCeL +FAy7Cy2ygS22gSqygBy60wyqAiq2gGP/wwAAAPpSDiIAAFiw/AoBIAEQaDBba00ZvCIoQQAJiAEC +iAIoRQDRD2wQBP66/RCAEEgw/bvgEB4A4PADi0LwAAdqACBO8AMLRvw6/SABEHgw87thEM4IYLAq +QQGHQRy8DPkqACAAEBAwbZoXKMKB0w/TD3ipBSnCgHlxB/zMECACAhCw/wIADgDTkuALCkQAoQQA ++RpgAZ8LWBQNiAoogsfTD/iZAQABEGAwCck5ZJGiKSoA/wIABgDOTJAcu/EMLAsqwoD/AgAAAMXO +kPsIRA4aALrgAIEEAPkaYAAICwlCAJEEAPkaDi4C/tbFLi4BOuAo0sb4CgEoAEBGcPAAGGgFAE4w +C1gUDYgKKILH+AoBKABARnAJiTlkkTf/AgACAKpSkG++DAsJRACRBAD5GmAACQALCkIAoQQA+Rr+ +1sUuLgE64CrSxvqZAQABEEAw8AAYaAUATjALWhQNqgoqosf6mQEAARBAMAmJOWSQvP++DGAAEBgw +8AAHaoABWDALCkIu1sUAoQTw+RoP/xBAMPChBAgRAEZw8DoaDiYBOuAr0sYLmwELqwIr1sZgABEL +XxQN/wou8scOngEOrgIu9sf6umUf/xBAMCLWxRu7sQwpEauZKpaDKJaCKpaBKJaAI8aBI8aA+iwA +AgAAWXBb/qxkoHIau6j7LAAAABBgMNMP+qJ/IAEQaDBbatD6Yg4iAABYsFtq7cmh+mIOIgAAWLD8 +CgAgARBoMFtqyNEPAAsMQgDBBAD5Gg4oAvjWxS//LMLgLNLG/JkBAAEQUDAJqTllnlwtQQD+SgAs +AEAfcA7dAi1FANEPLlEtsO4uVS1j/4EAAPosAAIAAGGwW/2pY/9jAABsEAgqQQEbu0yGQYgoJ7KC ++QqAIAEQcDDzhUIJkAQ6IPyyeyYAIEXw+HANIB4A4PDwAApkACBNcAAAAAMFRolwLbKD/JkMABQA +NiAKnxGv3SzQAP8CAAIBKWMQHLs1H7tr+CoAIAAQaDBtihMp8oF5qQUo8oB4YQf//BAgAgJrcPka +/yIAAFNw9twACgBOblD6FgQuIAC5YAULRACxBADpGmAACAUNQgDRBADpGh+6Ow+vAv/GxS4yATlg +KsLG+pkBAAEQQDDwABpoBQBOMAAABV0UDN0KLdLH/ZkBAAEQWDAJuTmfFfgKASIAABpw9JCmYgUA +TjD6CgEgABBIMAOpOGSQeSpBAB27OPw6/isgAVQw/a0BALQEYvAG3QL9RQAgABAQMNEPAC5xLCxx +LSqyhPjMASoA0/MQKHUtL6ECZP/BW2aVjEErQQH+QQAiAAB48PkgJiIAADKw+lwAAgAAabD5FgAu +TAFwMFv922P/k/oiDiIAAFmwW2pzZKDhErsaL0EAAv8BBv8C/0UAIAAQEDDRDwAAAAD6EgQiAABZ +8Fv+Hhy6444V/woBIN0ANqBvXgwFCEQAgQQA+RpgAAkABQlCAJEEAPka/sbFLi4BOWArwsb7mQEA +ARBQMPAAGGgFAE6wBV4UDO4KLuLH/pkBAAEQaDAJ2TkYuwEnEgT4dwsAkgA2YAVbAvoSBCABEGAw +WANjKhIEKyAmWAMFKkEA/CAmKkwBUDAtcoEpcoAtdoEbuvkMzAnwwQQLMAQ6oACqGgDBBPC7Gg// +EGAwDLsDC5kBCpkCKXaAY/6ZAAAAAPoiDiIAAFmw/AoBIAEQaDBbahUSut0vQQAC/wEG/wL/RQAg +ABAQMNEPK3EtsbsrdS1j/xsucoEudoEscoAduYgNzAIsdoBj/1wCHYsKDz8GDj8ADYsMCEQAL2P/ +AgAL/s5H0Bu6JClBABq61QuZAQqZAvlFACAAEBAw0Q/HJNEPbBAIikH8QgAiAABJMPv6/yIAAGiw ++gpHD+oQEDD7qgkJYAFgMPgWBygOATqg0Q8A/goBIgIANqCdEYIX9BYAL38QQDD/ug4WwAFkMP8W +BCQHAWQw9KQLAf8QeDD8CgAlUAQ9YPwWAybABD3g/Dr+IgBAQLD3FgUiCQAosPAiEQAQAjpw8hYG +IgAAKnDwAC5j/RAQMNow+xIHIgAAYfBb/yAsOv7/Gv8gARBwMPoWAyAAwS6guFX3fAgmALolUClR +BPmrQQAAtMJQ+QZJApYAOuBos0N8ZLwoUQUPAgAPAgD7UgMhEQA2IP8CAAYAhhWQdvPA+xIHIgAA +UbD8fAACAABo8Fv9qP4KASP+EGAw8/+iYf8QeDAAAPsWAiYAghWQK1EFiVNksPQrNhApNhEuNFUq +MCYduXIMqRH+NFQoACBucCuSOvc2FCIAeMbgK5I5ZLDmKDEHGrnICAhKDIgRCogCmLCNMIoU+N0R +AAMQQDAI3QL9tgEgEAJq8PAKFwAYEFAwAA2KGLlgLTEYmrWYtCgyEA0tFPoyAC0ABD9g/TIRKAkA +ajCdu5i6Hbm1iBWYt/0SBioJAGqwnbj6tgYgABBQMJq5iDIOiAKYMsDTLZY5ixL/AgAD/36a4IkQ +GrmlKJEECogBKJUELVEEDQ1JLVUEY/6+Zb7v2mD7EgciAABh8P0SASIAAHDwW/4u/goBI/4QYDDz +/pth/xB4MGWfB8DQLTYQLTYRLTRVY/8CghPRD8Ag0Q/AINEPK6wY/DwAAgAAUPBba5coMCf+CgEj +/hBgMPWPemH/EHgwijfAsPqsICABEGAwW3CAixKOFxi5hZigjTCeox65hJ6i+N0RAAEQcDD8Ov4s +CQB3cP2mASH/EHgw/jQnI/8eGuBj/zsAbBAKlBkWuerzWRQEQAEcMPUWBCABEGgw/j4GYAAQKDDA +0P8+BmABEFAwwKD2nAoAQBA4MPm5jRCAEHAw/BYGKoABHDD7FgUgABB4MPu6DhIAAEPw/LjyHgUA +U/D+FgMoBQBo8PgWAiABECAwihkAUQQATxr9ogMgIBBwMPqiAiwoALlg/98BAAEQcDDwACBuBQB/ +sADgBPoPGwHAAmlwANEEAEga+AoBLgBAR/APjzktICYOXhGeF/raEQ0gBD9g/V0KCgAgUXD6rQIs +ACBfcKndLtKA/wIAAABtr5CdEP4WAS4SALjgjhVgAAGOFPDhBAwJAGawLWbF8E0aD/8QQDDw4QQM +EQBHcPD+Gg4oATjgL2LGD98BD+8CL2bGYAAOAI8WKPLHDYgBCOgCKPbHKmbFKyAmARECWAHdGblL ++7nRHOABVDD8uLUQNAA/YGTQWB24e4oR/RIAKgkAarAq1oBgAO8eucn6EgEt8AFUMP6qAQ5MALtg +DNgCKGazL2K0D89SCP8RD98C/gqAKgkAerDwAA1qCQBysC7cgAjuEQ6qAo8QKvaAYACpihDAgCim +gGAAn2TwnP0SBS4SALjgnRhgAAOOFJ4YjReIGACBBABOGgCBBPD/GggJAGKw+GbFL/8QQDD47gMO +JgE44Chixg6IAQj4AihmxmAAEZIaiBYigscOIgEC8gIihseCGi4gJipmxS8gDADhBABIGvj/EQkA +BDog/xICKAkAejD4uQAeCQBH8ALuEa7e+BIDLgAgQ7D/uTMYCQB6MP7tBCgJAHowmOCwd/V+EmAC +AilwG7f5iBktICYusnyIgSuygPogJCwAIHdwCd0R+YYbegAgbvBkoEYqsCr7uYcQqgA+oMqg0Q8A +AAAAAP0KAC/oADagKrAqsKr9JCQq4AFQMCq0KmP/0y0gJgLdEavdqd0s0oAeuXoOzAEs1oDRDyqw +KrGq9CQkKuABUDAqtCpj/6gAAC4gJgLuEavuqe4t4oAM3QIt5oDRDwAAAGwQCpIVlBsYt9GTGYkZ +lRQqgnwpkCaFGyiCgP+5ZhgAIFZw9V0UCZAEPmD5iAgN4AQ/YPgWAS4aALlg8AAIaAAgf3AAGbld +FrkcF7g2/rjIEgAQQDD1A0QAARBQMPAxBAAAEBgw8KQaDgAgcnBtig0HOQIpZsUo4oB4SASxMyMq +ACsa//8CAAoArB7Q/l4GYgAASXDAkJ0a+RYAKAAge3CYE2AAQSIa//M8AS4Ak8FgGblCH7iv+ioA +IAAQaDDzqwwOACB+cG26EqPeB+kCKWbFKPKA+EgHcAICa3AD3gjz7AAKAHr0kCoSCRK5JiqiDgIy +C5IS8iKAIgAAWPBbaHSIFMiBaKGdyaOKGfs8AAAAEGAw+qIOIAEQaDBbaE2LGQ8CACuyEMq+Hrkb +jBkMPRH8whAsACB3cC7Sgf8SCSAyCHMwL/IRyP6IGSnSgCiCEf8CAAYA0s4QdC9RGrd8+zwAAAAQ +YDDTD/qigiABEGgwW2g38hICIgAAUPD7XAAAABBgMFgBaR65Aww9Ef63tBwAIHdwLtaDx88s1oIu +1oEs1oDAsCsmgSsmgGAADNow/BIJIgAAWXBb+xwiGv/7EgUiAABQ8Fv792Sg8f8CAA//cJFgiRNj +/tr9EgogARBQMI8ZBQhCAIEEL/Am8KIaCAAgN3CZF/IWBi+gBD/gL/0C/xYIIAAQEDD/XgdiAABJ +MGAAAYkWgxijIwc4AvhmxS4wATlgKmLG+pkBAAEQQDDwABZoBQBOMAAsEgcswsf8mQEAARBYMAm5 +OWSQLQM6AvtcAAAAEGAwWAE0jRkt0CYbuMsC3RENLQqr3Rm4QandLtKAcO8UwOAu1oCxImktiIwZ +LMAkZMCrYAASixn7sCYiAABQ8FgAyGP/3wAAAI4RLeAqsN0NDUf95CogHwA3YI8ZwOD+9CQgABAQ +MNEPiRUokS2wiCiVLWP/AIoZLKAmHbi3AswRrcwduCatzCvCgB24tA27AfvGgCAAEEgw+aQkIAAQ +EDDRDwAAjRWPGf3QDCABEGAw+xIAIAAQcDD+9hAiAABT8P72ES2ABD9g/bsCAIAQaDD+9FUqCQBu +8FgCPGP+JMAg0Q8AbBAEFrgbiTCKKPZifyCAEFgw+QhLBkgBTDD7dwgLkAQ6oPiPB3YAIFGwYAAC +CQdGKCA20w/+jxx/6hAgMCkgVGSQVSUmEvMmEyIAAFFwWIXvwCDRD4kwwED6MgEgDgAucGagS3qW +1YsxeLYP23D6LAACAABg8Fv+VmAADtpg+ywAAgAAYPBb/arUoCwgNsDUDcwCLCQ2Y/+j2lD7PAAC +AABhMFiFtcAg0Q8AAAAAAAD6bAACAABYsPx8AAABEGgwW/8BiTDz/5tiAAAisAAAAGwQBhu4K5MQ +lBH0t8kQARBgMB23Qg0tAi22xSuyxvgKACC+ADbgIgr//QoAIAAQUDDyXhEAgBAoMP4WAi4AICOw +bQgiAIEEAMkaebAP8lwAAAICUrAv4sJ58AGx3bGI/4gNYAICKXBj/9YAAAAAAAD/CgAgABAYMBu4 +Di4SAgv7CvuyxyIAAEDw/vURACAQMDD1CgAuACBxcPSwK24AICOwbWojAFEEAMkaebAS8owAAAIC +UrAm4sMPAgB5YAGx3fVcASACAkIwsf/zPCAlVAI74IkQiBGakJ2A0Q8AAAAA8gr/KyAEOWD6FgIg +ABBoMPP/fGAAEFAwbBAEG7ftGreME7cG0w8DIwIjtsUnssbyCgAgkQA14AJcEfrICAAAECgwbQgR +wW8CZgx2dQSxVSmCwrEibygCY//nwJALlwoncsf+lhEAABAQMPxoCAAgEGgw9HAWaAAgUjBt2g7B +3wLdDH11BLFVLoLDsSKxmWmUygxCCv5SGGIAIFCwIy0EgzAVtoX0LQQiCQAs8JNA0Q8kLQSEQBi3 +//UtBCQAQEEwlFDRDwJcEfP/j2AAECgwAGwQBtog+xwAAAAQQDD4FgAgCAJgcPgWASIAAGjwW/+M +jBH7EgAh/xBIMPKTSnABEHAwH7fmDy8LKfKBADEE/fKAL/8QQDDw7hoCnAE64PnpAgLsATsgB+MQ +A9MCKfaB+MgRAwAEOqAIIgLz9oAiCQAS8NEPAAAAAPm31hMDEEAw8j0RCgAuEhAetljwAIVoACBP +cAAAAAAA+OIDAnAEP6D4MwMCAEAScPwpOAwAQB9wKfaB+MgRAwAEOqAIIgL99oAiCQAS8NEPKfaB ++MgRAwAEOqAIIgL99oAiCQAS8NEPGLe9H7ZB8DEEAv8QSDDw7hoKAAgWUAo5EQkpDCmd/mAAAcSQ +/ZkKDwAEO6D4mQgOCQB7sB+3Ka+Z/ZKAIjgBOuAO2AL4zxEDAAQ6oA8iAviWgCIJABLw0Q9osRbA +0PjIEQMABDqgCCIC/ZaAIgkAEvDRDx63pA7dAfjIEQMABDqgCCIC/ZaAIgkAEvDRDwAAbBAE+Ldj +HhgAuODwAAdmgAEcMAMHQhW2efBxBAABEDAw8GYaD/8QSDDwcQQGEQBJsPBEGgQJACyw9YbFLioB +OOApgsYJaQEJSQIphsYihsXRDwNbFAi7CiqyxwpqAQpKAiq2xyKGxdEPAAAAbBAK9rb2EgAASLD1 +t0YQARBgMPe3eRAAEHgw+7eDH/8QaDD6CoAuFAC44C4gDWAAAcDgKJAm8rZWHgwBOODa8ACBBCiQ +DAiIEQjoAvDKGggJAFIwAKoRCKoCC6oCmhEqkFlkQWZloTMslFnzWhQOQAEYMP4WAiqAARwwmxP1 +qgoAABAgMPoWBCBAEFgwLpAm+uoRDyAEO6D+TgoKACBRMPqtAi4AIDuwpu4o4oDyrwIAAEGuEP4S +Ay4OALjgYAABjhIvVsUA4QQAzxr9/gMOOgE44ChSxvsWBygAQEOw+RYAKAkAQ/AoVsZgABuSGIgU +IoLH+xYHIgBAcLD5FgAiCQAT8CKGx4IYjRD6VsUiAABY8P3QJiIAAGEwW/8UiRD7EgcgARBgMPAA +ZW//EGgwAAAAAAD4EgMuEgC44JgVYAADiBKYFYgVL1bFAIEEAM8anxb9/wMONAE44ChSxv8SBigA +QHowCP8CL1bGjxlgABeTGpIYgxQoMseCFg+IAQgiAiI2x4IYgxoqVsWPES/mgLC79b73YAICITDA +8CiQJPy1hhAnADYgL5QkKZAmLcJ8LMKAqd0J3RGtzCvAKrC7CwpH+8QqINYANqDRD/NeFA/MADag +mRAvlFn17goIgAEYMCgWA/4WBCpAARgw+hYCIAAQIDCKECqgJvsSAy8gBDqg/k4KC6AEOqD6SggO +ACA7sPqtAi4OALjgYAABixLwsQQICQASsChWxQDJGvCxBAgRAG5w8PsaDigBOOAoUsYJiAEIuAIo +VsZgABIAkhiIFCKCxwkiAQKyAiKGx4IYKlbFpukokoBwjxMvloCxRGlNgokQ8/8lYAAQeDAAAI0Q +2zD90CYiAABhMFv+uPwKAS//EGgw8//UYAAQeDAYtt8CnxGo/6b/LvKAGLbcCO4BLvaA0Q9sEAYq +IAwfttz+tX0QABBYMP0gJiABEEgw97bJEgAAYTD1OgQsBQAicPLdEQQAIC9w/z4GbAAgP3DZsPio +EQCAEFAw/P45CgUASvD+iQIOMgC44C4gDfMMRA4JAEuw8AAObgkAcrAAAPMMQg4JAEqw+baAEAEQ +MDAftZkAwQTwahoP/xBAMPDBBAoRAEKw8EwaDgkAfXD/lsUuJgE44C+Sxg+vAQ/PAi+WxmAAEQNf +FAn/CijyxwioAQjIAij2xxO2GiWWxaPZKJKAZoAELpaA0Q8iICb7FgAiAABRcPsWASAIAmBw+xwA +AgAAaLBb/jT6EgAh/xBIMP86AyoAHi5QHLaPDFwLKcKBACEEjhH9woAv/xB4MPBrGgJsATqg+bkC +AgBQw6AHvhAO3gIpxoEuxoDRDwAAAADyKxEKABor0By1BvAAXWgAID7wAAAAAAD/ugMIcAQ64P+I +AwoAQFJw/qk4CABAQ3ApxoEoxoDRDx62dR20+fAhBAL/EEAw8GwaCgAILhAKKREJWQwpnf5gAAHE +kPuZCg0ABDsg/pkIDAkAazCjmfuSgCIiALqg+KEZYAAQaDAtloDRDwy+Ai6WgNEPKcaBLcaA0Q8f +tmIPvwEvloDRDwAAbBAEKyAmGrVP9QoBIMsANSAMuRGqmSiSOv8CAAIAYsYgKpI5H7WnHLWn9goD +ILQANqAuIQcODkoM7hEP7gKeoI0gCN0RBt0C/aYBIBACWrDwDBcOEAQ9IPIbHgAYEGAwLiEYG7U7 +/KYFKMABGDD+LhQMBwEYMPXMEQjABDog+6YELgkAR/D9IhAvfxBAMPsiACgAQEDw/CIRKAkAYjCf +p/ymCy8ABDug/LWIHAkAd3D9pgopAAQ6IPimCCAAEEAw+KYJKgkAZvCbpo8iBf8CnyImljnRDwAA +JSRUY/8yAAAAACu8GPosAAIAAGCwW2d/LSAnyNLRDwAAiifAsPqsICABEGAwW2xqHrVxnqCMIABN +Efu1bxwJAGzw+6YCLYAEOyD9pgMsCQArMJyhJSQn0Q8AAABsEAQethsdtYUYtJwXtY4WthkojQoo +gnwctdMmYoH6thYYACAiMPmIEQIAAFjw+GYIAIAQGDAZtOYPAgAPAgAJKQIpxrMvwrQYtg31vBIu +AEBH8A9fAi/GtCLGsxm1YgJIEamCKyLB/wIACgBcqtArYDRksaf4tVwcACAasPYiwSwAIGEwLMDM +CEgKKIKzKwoA9gZPAADP/xD4SBQIIgFEMPCRBAABEGAw8MoaAAYQSDBtmhL4SBQIIgFEMPCRBAoJ +AFbwAMoawCD5Ch8iCQBW8AKZDHk9NLEi+ST0YB8QSDAatGYqoNH/AgACAIF2kPBbEQAAfn0QBBwU +B8wKLcL0DQ1PDbsCK8b00Q8A+iwAAgAAWbBb9dJnr7xj/8MAAAAAAAAA/wIACgBi2VDaQFgG4PWs +AAC4ADagLWA00w/TD2TRAB61zfi1KB4AIBuw9iLBLgAgcTAu4Mz7CgAgARBgMPhICgfgATAw+IKz +IAB7/5D4SBQIIgFEMPCRBAAAEBAw8MoaAAYQSDBtmhL4SBQIIgFEMPCRBAoJAFbwAMoa+QofIgkA +VvACmQx5PS6xIvkk9GAfEEgwGrQxKqDRfa8s8FsRAIQAfTAEHBQHzAotwvQNDU8NuwIrxvTRD/ts +AAIAAFCwW/WeZ6/CY//J0Q8EHhQH7got4vQftW0P3QENXQIt5vTRDwQYFAeICi+C9Bm1Zwn/AQ9f +Ai+G9NEPKWAiApkRrpmtmSWWgCVlGWP+RAAAAAD6TAACAABZsFv1iGP+ngAAKmAiG7WKAqoRq6ob +tPOrqiWmgCVlGWP+5QAAAAAAAAD7bAACAABRMFv1fGP/RAAAbBAKizKOMP8gNiCAEDgw+wRfDC4B +WDD7qkEJYAF0MPkWBSwsAVww+4tBAB4A4nAOhkLwAAdmACA5sA4GRvi1cxAeAHvw+bVyGgAXphB0 +myf8+uogABAgMCogVdMPZKE3ZEE0JSYS8yYTIgAAUXBYgsPAINEPAAAA+bQHEAQQQDD/CgAoCQBD +8PgkNiAAhSuQnBSdE5sS+hYHIAEQcDD/FggmAIZNEAZqAvwgJiIAAFkwW/82KCBV+UwSIAEQcDD5 +JRggxQA2ICsgJhq0NAy5Ef4kVCgAIFZwKpI6/wIAAgG+RqAqkjlko3EvIQcYtIsPD0oM/xEI/wKf +oI0gHLSI+N0RAAMQeDAP3QKdofAMFwAQAlqwAAuKhBUbtCP4IRggGBBgMJylm6QIKBQtIhH/IhAs +wAEgMPsiACzABDsgnKf9pgspAAQ6IPgSCC4JAEfwmKn8tHMffxBoMP1NAQQHASAw/6YKJVAEOSD0 +3QIKCQBm8PumBi0ABD9gnaiEIg5EApQiwPMvljnwACRgARAgMAAAAAAAAMDA+lwAAgAAWPBYglHA +INEPAAAAAAAAAMBAjRT/AgACAL7DYI8XixcdtRX6CgEiAGsT4CkgJpkW/xIGKgUAXrD5nQMtIAQ6 +YP0gDCwAIGsw8PEEDgwAuaDAoPcSCCIAAHnwGLOi+rT+HgUAVfD7qDkLgAQ7YPDrGgoJAEKw8LsR +DjQAuaAoIA0GDUT/vwIICQBSMPAAD24JAEfwCv8C9g1CDgkAfvAatK0bs8fw0QQKCQBecCumxQDr +GgDRBI0Xx48IuwPw3RoOJgE5oCiixgi4AQjYAiimxmAAEQZYFAqICieCxwe3AQfXAieGxx20SZka +KabFrcorooD/AgACAGOu0C+mgI4T/wIAAgBTw6CPEm/yfYkSG7NyGLTajhiMIC2CpR+zi/m+OAuQ +BDsg+YKgLAAgV3CK2iiCWovb+cwMCgBAerD+qgIKAAbDEPAAB2IAAEtwAMCQHbQHw/ov1hAr1hHD +6y7WECrWEY3QH7SiHrQB+MgRDABAf3D43QIAIBB4MA/dAv3mACAIADZgmpqbm/P9LGAAEGAwAAAA +3ND6LAACAABZsFv90PP+dmABEHAw3OD7bAACAABQsFv9HmP/TAAAAIcYlxCXEYca2xD9ICYgCAJg +cP0WCSIAAFHwW/wy+hIJIf8QQDD7EgAqAC6+EB20jQ19CynSgQChBPrSgCABEHAwAO4ajxH+shli +AAA6sPnpAgJWATvgB+oQ8AAgagkAUfAAAMd/9+sQDBEAO7D3uwMMAEBicP/JOAoAQFqwKdaBKtaA +Y/65KDoD8q0RCgAJOhAatHUZsvrwADlqACBTcCwq/3fDCwqpEQl5DCmd/mAAAcSQHLLyHrRs8KEE +AAEQeDAA/xr9mgoJAAQ/4PyZAgoAIHKwHbPera360oAiGgE64AmqAirWgGP+VWixB/P/82AAEFAw +HrRh8//oagBAcrArvBj6LAACAABgsFtlty8gJ/4KAS0YALfgiifAsPqsICABEGAwW2qhHbOonaCL +IByzp/ymAiABEHAw/BIFK4AEPuD8pgMqCQB28JuhLiQnY/zaAAAAbBAGGbK0higtkoDyICYiAABQ +sPeSfCeQBDmg/5J4JgAgabAuYAyid/wKgCeQBD3g99cIDgAge7D57hEAARB4MPg/D3wAIHdwA4NC +8AAHYgAgZPADA0ZuPg4btEQGORGrmYmQYAAhAAAes6UDXBQOzAorwoQswogDDkQA4QTw+RoKCQBm +8AuZAfxxGCoAIBWw/rB4IA4ANmBlQKFlUJ5gAAMAZEEKKGAM8hYBIAAQeDAPAgD4jPkgARAQMPgv +OAAAEEAwDyg48hIBIC4ANiD0kHFh/gJDMCh1GCmweLCZKbR4KNBjKaA2KIz/+NRjIPcQQDAImQEp +pDb6CgEgABBIMA+pOMmVKXEYZMBdZJCnKbB4ZOBj/RYAIKgANmArYAz4tx1gARBwMC7QY/o8AAIA +AFiw/EwAAgAAaXBb9JDRDwBj/+axySl1GCiweLGIKLR4KdBjKKA2sZn51GMgCBBIMAmIAiikNmP/ +jmSfocCjKnRrY/+ZAAAAAP0WAC+gADZgHrJ3i2DTDy7ie/pyGyABEGAwDwIA/rsMAAEQaDBbYw79 +EgAgARB4MC90LmP/bQAAZV7xY/+GwIEodGtj/08AAB6yZ4tgLuJ7+nIbIAAQYDD+uwwAARBoMFti +/40QY/87bBAGKSA2wPT/mAIAGAD6cPAAuW/qEGAwKCQ2iTD6sjUQABBgMPkESwAAUS5QKyAmLqJ8 +LaKArr75IggvkAQ7oP4yASwAIHdwLCQn/RYAKZAEPmD+91AGHgFwMP7NUAD6AIuwLyBbKKJ8/KKA +IJYEa/CTE/OieCoAIEsw+6IAKAAgQvAJiBHzuwwMACBDMPMSAyAcAA+wnBH9FgIhLwA34C+gc7D/ +/RYCLuABeDD/pHMhBwA3oC0kW/osAAIAAFkw/HwAAgAAabBb/1XAwPpcAAIAAFjwWIDgwCDRDyIx +BC4SAA/6AvyzqhAYEFgw/uAoIgAAaLBYgawfskN/IS/0IF5hLBBAMPkSACoAJxYQKZAl+hIAINMA +NmAqoRN6IzCMEA8rESvFE2AAJQAAAACLECuwKGSww4wQsb0NDUf9xCggBBBQMPyzkxAYEFgwWIGW +8/95YAAQYDDz/3Fv6hBgMIsQK7AoZL/vjBCwvQ0NR/3EKCAEEFAw/LOIEBgQWDBYgYqOEC7gKGXv +xYgQwKT8s4MQABB4MP+EJSAYEFgwWIGCiRApkh2KnGSvpIudZL+fihALsABj/5cqwhz9CgEgABBg +MFtijY0SY/7pLaBzsd0tpHOKEcDB+qIcIAEQaDBbYoaNEmP+zQCPEMCB+PQlL/AEOKAu9RNj/1WK +EMDA/KUTIAEQSDAppCVj/ylsEAT6LAACAABhMP0KAyAgAljwWDhQ0qDRDwAAbBAEb2NcZTBZ+Aoe +IAcANaB0g07yAkcAkAA9oMlh+iwAAAAQWDD2DU8AHxBgMFhd6vRwM23gASAwLVEA+iwAAAAQWDBY +XeTJYfosAAAAEFgw/AofIAAQaDBYXd/AINEPb0u4xirRDwATs0QLKhEKygIqNsEas0Ibsgv8CgAg +MhBoMP4KASAKEEgw+TbDIAAQeDBbZBJmoAorMsIrVQBj/6UAAMCk/LM2EBQQWDBYgTRj/5MAbBAG ++iAhIAAQWDD8ChMiAABocP4KASAAEHgwW//M+bMsEAAZLqD4EQAgZAI84AmIASgVAPsKACATEGAw ++iAhIgAAaHD+CgEgARB4MFv/v9Kg0Q8A0qDRDwAAAAD6EQAiDgA44GkzzP47EQoAQEqwC6oCKhUA +Y/+7bBAG+DwNYCYQIDB0MR3GKtEPAAAoIEH0gUlwABBIMCkkQYIQ0Q8AAAAAAAD6ICEgGBBYMPwK +ASABEGgwWALa9qBjYgAAGrD6ICEgEhBYMPwKICAgEGgwWALU9CRBIgAAEPDRD/ogISAYEFgw/AoB +IAAQaDBYAsz2oCtiAAAasPogISASEFgw/AogIAAQaDBYAsb2oBBiAAAasMCg+iRBIgAAEPDRD9Iw +0Q8AAGwQBMCl/LLqEBgQWDD9ICIiAABw8FiA5PkKQCQAEEAw+TkBAAAQIDD5hDkAGgBg8BixcAhE +AgQETyMgIRWy2fszEQAEEEAwCDMCI1bB+7GfEAAQYDD9CjIgARBwMPqy0RAKEEgw+VbDIAAQeDBb +Y6X3oBRiAAASsMCk/LLLEBQQWDBYgMnRDwApUsIjVsEasskKmQEJCU8JSQIpVsL7sYsQABBgMP0K +MiABEHAw+rK9EAkQQDD4VsMgABB4MFtjkfegFGIAABKwwKH8srsQFBBYMFiAtdEPANEPAABsEATA +pfyythAYEFgw/SAiIgAAcPBYgK0qICH0CgAoAAEYMP1MAAEAEGAw+M05AAQQWDBYAntmoCb7Cgkg +AhBQMPkqACoAQFDw+iAhJAUAUnD9TAACABBgMFgCcdKg0Q/SoNEPbBAEHLKf/SAiIAUQUDD+IR0g +GBBYMFiAlCMgIRSykQszESNGwfuxWRAAEGAw/QoyIAEQcDD6sosQChBAMPhGwyAAEHgwW2Nf9qBH +YgAAErApQsIjRsEasosImTIPAgAKmQIpRsL7sUkQABBgMP0KMiABEHAw+rJ7EAkQQDD4RsMgABB4 +MFtjT/agF2IAABKw0Q8AwKT8snQQFBBYMFiActEPAMCh/LJ0EBQQWDBYgG7RDwAAAAAAAGwQBMCl +/LJyEBgQWDD9ICIiAABw8FiAZvogISAWADTgHLD2/bD1EAAQWDBYAjbSoNEPHLDx+woAIAAQaDBY +AjH2oApiAAAasC4hHXfvCdIw0Q8AAAAAAAD8slwQBRBQMP0gIiAYEFgwWIBRIiAhFLJO0w8LIhEi +RsEaskwbsRb8CgAgMhBoMP4KASAKEEAw+EbDIAAQeDBbYx1moDgpQsIiRsEaskoImTIKmQIpRsIa +sj8bsQj8CgAgMhBoMP4KASAJEEAw+EbDIAAQeDBbYw9nr3pgABDApPyyNhAUEFgwWIAz0jDRD8Ch +/LI1EBQQWDBYgC/SMNEPbBAEKiAhFLCU87IpGuABHDD0sEBrsAQ6oMCAC6kCKTbBKDbCGrIk+7Dt +EDIQaDD+CgEgABB4MPg2wyIAAGIwW2L19qB1YgAAErAkNsLAoSo2w2AACio2wSQ2wsC5KzbDGrIV +G7De/AoAIDIQaDD+CgEgABB4MFti5/agK2IAABKwCuowGbCBKZI1CpkKDOowDJwMasEObQgICuow +CpoMaqECY//w0Q8AwKH8sgcQFBBYMFiAAWcvyGP/6cCh/LIHEBQQWDBYf/xj/+kAbBAI+XrDIgAA +ULD5JRwhwxBAMPglHSAAEFgwW//GZ6AK0qDRDwAAAAAAAAD6ICEgABBYMPwKHyABEGgwWFyBF7B9 +FrHqE7Hn9q/VYAoQIDAqICHTDw8CAPuqEQATEFgwC6oCKjbBG7Cq/AoAIDIQaDD6sd0QARBwMPQ2 +wyAAEHgwW2Kx96MIYgAAKrAqCgT7ChQiAABhsFh/1QVaAmavgCoKBfyx2hAYEFgw/SAiIAEQcDBY +f84qICEcsF79sF4QABBYMFgBnmegCQqiAtEPAAAAAAD6ICEgABBYMP2xzhAfEGAwWFxX9q82YAQQ +KDArICEsChgLuxEMuwIrNsEasbr7sIMQABBgMP0KMiABEHAw9DbDIAAQeDBbYov6FgYgAViyoMCk ++woUIgAAYbBYf6+KFmau6vogISAAEFgw/bG1EB8QYDBYXD9mrtQsICHTDwvMESw2wRqxpPuwbRAA +EGAw/QoyIAEQcDD0NsMgABB4MFtidfoWASABcrKg3GD6CgQgFBBYMFh/mYoRZq6R+iAhIB4QWDD8 +CgMgABBoMFgBaGaue/ogISASEFgw/QoAIIAQYDBYAWJmrmUcsZf9ICIgBRBQMP4hHSAYEFgwWH+H +LSAh0w8L3REtNsEasYP7sEwQABBgMP0KMiABEHAw9DbDIAAQeDBbYlSaE/aj3GAAEDAwKRoALTLC +LiEdCd0C/Q1PABoAX7AesCoO3QINDU8qICH7CgAgABBgMAERAlgBRGat6/ogISAEEFgw/QoAI+AQ +YDABEQJYAT1mrdL6ICEgCRBYMP0KACEAEGAwWAE4Zq28HLFnLSAi/iEdIAUQUDD+FgQgGBBYMFh/ +XIgUKiAh/xoAIAQQWDD4CEACAABpsPwaACwFAEfwWAEpZqDhihT8KgAiABBIMP1sAAACEFgw+woJ +KgBAWrD6ICEsBQBWcFgBH2aguRyxSy0gIv4hHSAFEFAw/hYCIBgQWDBYf0OMEv4KQCQAEGgw/s4B +AgAASbAO2Tn5FgUgGABjMAeZAgkJT5kVJyAh0w/TDwt3EQV3Aic2wRqxNPuv/RAAEGAw/QoyIAEQ +cDD0NsMgABB4MFtiBfait2IAACKwKjLCJzbBG7EtiRULqgEKCk8KmQIpNsIasSUbr+78CgAgMhBo +MP4KASAJEEAw+DbDIAAQeDBbYfX2oo9iAAAasGagAiYkQGasm/YkICIAABKw0Q8ALTLCwLD9DU8A +ExBgMPogISwJAD9wWFunZqx1+iAhIAAQWDD8Ch8gABBoMFhbomasX/osAAAAEFgwW/7aY/zNAAAf +sRItMsLAsA8CAP/dAQADEHAw/t0CABgQYDD6ICEt4AFsMFhbk2asJvogISAAEFgw/AofIAAQaDBY +W45mrBAoICHTDw8CAPuIEQAYEEgwCYgCKDbBGrDw+6+5EAAQYDD9CjIgARBwMPQ2wyAAEHgwW2HB ++hYAIAC4MqDApPsKFCIAAGGwWH7lihBj/NQfsPAtMsLAsP4KYCwAQH9w/t0CAAAQYDD6ICEt4AFs +MFhbcWarnPogISAAEFgw/bDmEB8QYDBYW2tmq4b6ICEgABBYMPwKEiASEGgwWFtmZqtw+iAhIAAQ +WDD9sNwQERBgMFhbYGarWvogISAAEFgw/bDXEBAQYDBYW1tmq0T6ICEgABBYMPwKEiAAEGgwWFtV +Zqsu+iAhIAAQWDD9SiIgERBgMFhbUGarGPogISAAEFgw/bDIEBAQYDBYW0pmqwL6ICEgABBYMPwK +EiA8EGgwWFtFZqrs+iAhIAAQWDD9sL4QERBgMFhbP2aq1vogISAAEFgw/bC5EBAQYDBYWzpmqsD6 +ICEgABBYMPwKEiAIEGgwWFs0Zqqq+iAhIAAQWDD9sK8QERBgMFhbL2aqlPogISAAEFgw/bCrEBAQ +YDBYWylmqn76ICEgABBYMPwKHyAAEGgwWFskY/vTHrCjLTLC/t0BAAAQWDD13QIAGBBgMPogIS3g +AWwwWFsbY/tWwKT8sIMQFBBYMFh+gYoTY/2TAMCk/LB+EBQQWDBYfnzz/XxiAABRMAAAAMCh/LB8 +EBQQWDBYfnbz/WRiAABQ8GwQBCkgIROwcPuZEQAdEFAwCpICIjbBGrBtG682/AoAIDIQaDD+CgEg +ChBAMPg2wyAAEHgwW2E9Z6ARwKT8sGQQFBBYMFh+YmegT9EPKTLCIjbBK/oA+5kBACEQUDAKmQIJ +CU8pNsIasFkbryL8CgAgMhBoMP4KASAJEEAw+DbDIAAQeDBbYSlnoAzAofywVBAUEFgwWH5OZs+v +wCDRDwBsEAQpICETsEj7mREAHRBQMAqZAik2wRqwRRuvDvwKACAyEGgw/goBIAoQQDD4NsMgABB4 +MFthFWagMCkywvogISAsAH5wwb38Cv8g7hBoMFgADNKg0Q8AKwod/Ar/IO8QaDBYAAgKogIGAADA +pPywMBAUEFgwWH4uY//BbBAEIiEc0Q9sEAQWsCgLKREJMwIjZsH7rvAQABBgMP0KMiABEHAw+rAi +EAoQQDD4ZsMgABB4MFtg9vagSWIAABKwKWLCI2bBx68KSgMKmQEJCU8JWQIpZsL7rt8QABBgMP0K +MiABEHAw+rAREAkQQDD4ZsMgABB4MFtg5fagF2IAABKw0Q8AwKT8sAoQFBBYMFh+CNEPAMCh/LAK +EBQQWDBYfgTRDwAAbBAEwKX8sBgQGBBYMP0gIiIAAHDwWH39JCAhFa/6C0QRJFbB+67DEAAQYDD9 +CjIgARBwMPqv9RAKEEAw+FbDIAAQeDBbYMj3oBRiAAASsMCk/K/uEBQQWDBYfezRDwApUsIkVsEb +rwAdsAEasAHzDEAIAEBucPy6OQngAUwwCpkCKVbC+66rEAAQYDD9CjIgARBwMPqv3RAJEEAw+FbD +IAAQeDBbYLD3oBNiAAASsMCh/K/aEBQQWDBYfdTRD9EPbBAIJCAi+iAhIAAQWDD9HBAgARBgMFha +PPagKWIAABqwFq/kAkcRpnYuYo0rEQgpICv4r+EQFAD7sAi7ASsVCAslQHlZDWRRGtIw0Q8AAAAA +AAAA+iAhIAAQWDD9HBIgChBgMFhaKPav22IAABqw+woAIVQANWAqICH9HBQgHBBgMFhaIfavvWIA +ABqwGa/LLREK/iAvIDACQHD5kgAuLAFsMPmGAC4AIEfwL/AAKArn+O4BD9AEP+D/7gIP8xAYMP4k +LyAiAG9wwKIqJR/wAA5gAhBQMMCx+yUfIAEQUDAZr7ipef2S1CIAoYKg/wIAAAC6hqAqksAbrf0L +qgIqlsAqICEZr5D7qhEABRBYMAuqAiqWwfuuVhAAEGAw/QoyIAEQcDD6r4gQChBAMPiWwyAAEHgw +W2Bc9qGwYgAAGrAdr20ar4ArIR3AwfqiwiIAVubQ/wIADABfbpDwALhgQBBIMAAqICEkICAZr3b7 +qhEAGhBYMAuqAiqWwRqvcxuuPPwKACAyEGgw/goBIAoQQDD4lsMgABB4MFtgQ2ahXxuvaSuywv8C +AAAAb1LQ/QoBIfwCcTD+0zkAAhBgMPwkICIAABDw0Q8rJCsrJR4rJR8ETQIcr3z+EQgiAAB5cPhi +jSAEEFAw+BYAIBgQWDAPAgBYfVbz/k5gARAYMHWnB/AAFGDAEEgwG63jDakB/wIABgBp3lDAkCkl +HvwkKyAAEGgwLSQgY/+nAAAAAP0uQQABEHgw+Oz+IAAQUDD4+jgCKgA7oCuS1PO7AQAIEGAwDLsC +K5bU/QoBIAAQYDAK3DhlzpFj/poNLkH/AgAB/0oHoC+S1PP/AQAEEEAwCP8CL5bUY/5vAAAqICEZ +ry77qhEABRBYMAuqAiqWwRqvKxut9PwKACAyEGgw/goBIAoQQDD4lsMgABB4MFtf+2agZx2vIS3S +wg3dQP1MDAABEFgwDLM5/SQgIgAAEPDRDwAAAAAAAADz/y9ggBBIMMCk/K8XEBQQWDBYfRVj/UkA +AADApPyvEhAUEFgwWH0Q/woBIfYCQTD48zkABRBwMP4kICIAABDw0Q8AwKT8rwgQFBBYMFh9Bv8K +ASH2AkEw+PM5AAUQcDD+JCAiAAAQ8NEPAABsEAQerkz8rqsfIAQ8oPutxBAAEEgw+AoAL/8QaDDw +AAlgARBQMLGZaJRJD5UKrlUlUsPyCgAv7wA1YAuWEW0IMAAhBACnGndQGgtkAiTGsyPCtNMP/XQD +A6ABHDD0VQEIAQAaMLEi/yy7YAICMbBkX7Nj/8iu9SVSwvIKACBAADVg9gqAIIcQSDBtCC0AIQQA +pxp3UBgLbwIvxrMuwrT9fwMPoAFwMP9VAQgBAHIwsWb2kwlwAgIQsMhRY//LIlruCII50Q8AAGwQ +BBqtHywgIiuifiqigKy7/TAIK5AEPuD5MgEqACBasIqn+zALKfABTDD6og4gdQA3YP8CAAAARodg +/wIAAgCQg2D/AgACAFKHYGjUFSoKBPyu1xAYEFgwWHy2xirRDwAAAAD/AgAGAFMCYP8CAAYAYoZg +aZjkC74J+u4JAN4QeDCv7i3hAizhAS7hAC41B/00DCwoAWAw/DQNIAAQEDDRDwAA/wIABgB8gmD/ +AgAGAH6GYGmYpC+iFP82AyAAEBAw0Q//AgAGAHiCYP8CAAYAgwZg/wIAD+oQEDD/AgAIAEqCYNEP +AAAAAAAA/wIABgCCAmD/AgAGAISGYP8CAA/qEBAw/wIACABGAmDRDwu5CQqZCSmcdiuRAiqRASyR +ACw1B/s0DCooAVAw+jQNIAAQEDDRDwu5CfqZCQCqEGAwrJkrkQIqkQEskQAsNQf7NAwqKAFQMPo0 +DSAAEBAw0Q8rLFTxCxYAIAJQ8PIaHgAAEBAw0Q8uoFz+NA8gqAJqsPMNFgAgAmDw8lweAAAQEDDR +DwAAL6Bw/zQJIAAQEDDRD4Kq8jYDIAAQEDDRD4iv+DYDIAAQEDDRDyygNPw0DyBYAlqw9QsWACAC +SPDymR4AABAQMNEPL6BI/zQPIIACcrD3DhYAIAJo8PLdHgAAEBAw0Q8AIqBk8jQJIAAQEDDRDyig +avg0CSAAEBAw0Q8AAGwQDo0whzH0ICIgABAwMPytkxADEFgw9wdfAD4AL3D/CgEgQRBAMP6skhoA +RcHQGa5dCXkKiZAKkADAwP6tQBCIACdwhzEHB1/4CggiAigF4PeDDHAnEEgw/wIABgKLkeB5cTQc +rlH+ICMiAABpMP8gNiACEFAw9xYAIBgQWDBYfCnGyvpcAAIAAFjwWHtRwCDRDwAAAAAAACwiHSzC +EMvJ+iwAAgAAWPALwADz/9RiAABisAAAHK49/iAjIgAAaTD/IDYgAhBQMPcWACAYEFgwWHwUY/+q +AAAAAADz/6Rv6hBgMCshHSwhHPwWDSwpAVww/RYJJqABXDD3FgwuJgFcMP8WCi4IAVgwnhsvIDYu +ICOHMpcS/BYAIAUQUDD7FgEiAABpMPyuIhAYEFgwWHv9LCIdZMZxiB0p6gAJiAL/AgAMAzM+EIoc +Bw1FfakkixoHbkF+uRyPGweIQHj5FAeZQfkWBybGADZgihn/AgAGA15OkI8dLmoA/wIADgFFf5AH +mkFkon+IGf8CAAYBPVYQjM+aF/0WBCabADcg+xIHIgAAULALwAAcrgMpIR2LF/e7EQgAQGZw/RIE +KAkAXnApJR1gAkIsIh2MwGTGDfosAAAAEFgwC8AAjTDz/l1iAABisCwiHYzOZMS4+3wAAgAAULAL +wACNMPP+QGIAAGKw8/44b9oQYDAuIEHC9v8CAA4BvfuQLCIdjM5kxRb7fAACAABQsAvAAI0w8/4O +YgAAYrAALyRr8/4CYAAQYDArJGvz/fdgABBgMPs8CCIAAFCwWD8+jTDz/eJiAABisAAA8/3YYAAQ +YDAqICEo4nwpMAgn4oCqiAmIEf+XQHYAIEXwKzAJLjEILTEJ+0tABF4AuqDyqBEJAAQ/oPyNCAgJ +AE9wKdbIKdLAx477+zkIAEBGcAm5AinWwCkwCI0efpdDKzAJLjEKLTEL+1tABG4AuqDyqREJAAQ7 +oPydCAgJAENwKNbJKNLAwJH5+v0qBQBecPmIAQnwBD7gCJkCKdbAKTAIjR99l0QrMAkuMQwtMQ37 +a0AEcAC6oPKpEQkABDug/J0ICAkAQ3Ao1soo0sDAkfn6+yoFAF5w+YgBCeAEPuAImQIp1sApMAgt +EhB8l0QrMAkuMQ4tMQ/7e0AEcAC6oPKpEQkABDug/J0ICAkAQ3Ao1sso0sDAkfn69yoFAF5w+YgB +CdAEPuAImQIp1sApMAgtEhF7ly0oMAndYPkxBSgDAUAwAqsRrLsptscpssDG7/4KECgAQHZwCO05 +DZkCKbbAKTAIeZc0KTEHHK1H+6yxE6wANmAtcCL6nBItIAQ/YPzdCAvgAVAwq90q1oAqdRkvdDQp +cC5kk2IpdC6NMPP8OWAAEGAwwKD8rWsRABBAMPh7AQ4AwMXQ+hYFIFoAN2CJHPsWBi4BXupQjhvA +gfsWBioFAF4w/RYELgFU25CJGvoWBSomATww+xYIJgEj3lAoIh2IhPt8AAIAAFCwC4AAG61VKSEd +ihj6qhEIAEBecAqZAiklHSgiHYiI2iALgAAbrU4pIR37mQEBABBYMPoSBSgJAF5wKSUdYAH2LSEe ++6uJEgAAebD4IR8iAAAhsP1qQAwHAWww+6vyFAUAavD9ICsmBgFEMPf8AAYFADuw+a08FgUAVvD7 +ICwsEAQ/YPh6QAigAUAw+IgQDgUAVnD6IRwsCQBHcPggJC4JAD/w9yAjLAkAJ3D0ICEsCQB/cP8g +ICiwBDog+HcRCAkAQbD6NQYlAAQ5IPkhHS+wBD/g90QCDAkAR3D5NQcsCQAncPghGSoJAH7w+DUI +KgkAbvCbMvcgNCAAECAwlDaXNy8gNS80Ei0gLy00E2P7FgAAAAAAAAD6LAACAABY8Fv+HPP7AWIA +AGKwAAAAAADz+vRv2hBgMAAAjhvL4ygiHYiFnRT6LAAAABBYMAuAACgiHYiE+iwAAAAQWDALgAAb +rQApIR2NFPys/RgAQF5wKSUdjhx96QSPG2TxjmTSH7DY/wIACAENahAuIh2O42TgGC0WBPosAAIA +AFnwC+AALRIE/KzuEABIrqAZrO8oIR2PGg8CAAmIAfdrQQwJAG4w/SUdIBYIW/COGw8CAMjs+rgR +DgBAZ3AI/wIvJR0pICtkkFMeqwwrICIdrKku4nwt0oGr7gnuEa7dL9EfLtEdDP8B/9UfIJIAZ7Av +0R549z4cq/sCuxGsuyiygP8CAAAAYA4QKdAtYAC3wJAtsoIO3QENnQIttoKNMPP5omIAAGKwAAAA +AAAA8/mUYAAQYDAcq+wCuxH8uwgAABBIMC76ACiyhC/RHQ6IAQiYAvi2hCFyAGPwKdEeeZeuLLKA +c8ZuKdAtYABqACgiHYiFnRT6LAACAABZ8AuAAByssyshHfwSBCoAQGbwiRr6FgUqJgE4MPoWCCoJ +AGbw+yUdL/6b0lCOFo0bwPEO/jn/AgAH/qZ3UGP9HgAA8/kEYAAQYDDAkSjRH8TADIgCKNUfY/9t +wJEv0R8oCoAI/wIv1R9j/yopMQbz/JZoAAFMMI0aB2tB/wIAB/+R31AtIR1j/rAAAAAmdDRb/Wku +cDRl7GkocCIZrFYCiBGpiBmrv/mICA/gAVQwL4aAKnUZY/xKHKyHLyA2LiAjih2aEPkhHSAYEFgw ++RYBIgAAaTD3FgIgAhBQMFh6VfP+v2/qEFAwAAAA/iAjIgAAaTD/IDYgAhBQMPyseBAYEFgwWHpL +Y/iHAAAcrHUvIDYuICOIHZgQ/SEdIAIQUDD9FgEgGBBYMPcWAiIAAGkwWHpAY/+pAAAAAADz/mRg +ABBQMBysaC8gNi4gI4odmhD5IR0gGBBYMPkWASIAAGkw9xYCIAIQUDBYejJj/3EAbBAGLjEL/SIA +KHoAO6Bo6xLAo/ysWRAIEFgwWHoqwCDRDwAAHKxWjjaPN4k4mRD4MgkgAxBQMPgWASAIEFgwWHoh +wCDRDwCONv8yByADEFAw/KxLEAgQWDBYehrAINEPbBAEwCDRDwBsEAQqIAcbqu4KCkEMqhGrqiii +Ov8CAAIAjkIgI6I5ZDEVG6pi8AsHAgAASPAASWEASWEoIQcZquP/q0oZQAFAMPyrSRnABDog/qrg +GAkASjCYMPsiACAIEGgwnTP+NgIgAhBAMPi5EQoJAGbw+zYEKAkARnApNgEu8n8rIQn4pjkgABBg +MPrygCH+AnOw/vZ/IAEQaDBbWwWKJ44i+/rAIEACSrD7mQEAABAgMPSlFCCAAkpwman5pgggWQA3 +oPysFxAFEFAw/SIAIDIQWDBYeeOKImSgVMCw/frwLwAQYDBtCA16wA0KihT0oB9gEAJa8GP/63rQ +DgpKFPAACGAIAlrwAACxuwoaFGWv99ogW1zwiifHz5yglCdbWAIkJAT0JAUiAAAQ8NEPAADz/91g +ABBYMMAg0Q/SMNEPbBAGLSAHGasz9KszHCABbDAN3Qn4qjcdwAQ/YKTUJEJ/CYgICNgI8hYAJgBV +RRAXq+0Wqyr31wgAABBYMI0QjdBtCCMuSRCFQA8CAPJCByAbADegLyIBD48UBv8Bf9Ea9XFxcgAA +IXBj/9WIsQiIFAaIAfjZ6XAAEBAwjSOOIvyr2hAgEHgw8PAEAAUQUDD+DhsAMhBYMFh5oolBi0Cb +kIpA+aYBIgAAaPD6EgAgABBAMPhGACABEGAw+EYBIgAAWLBYLuEqTPhbV8fAsPRcAA//tinQwCDR +DwAAAGwQRiggBP8CAAQBdZogFqokiTEcqsX1qd4QCBAgMPerExIBa4pQAAyNKiAMK1J4I1KA9SIW +IBAQSDD7qggA/gJAcPiMMSuQBDqg+VURCgAgUPD1IRkiACAs8G2aAgAIiiqhLv8CAAYBRzaQHanL +/CIAIOEQcDAuFMgtFi79qcgdgAQ7IP0WLCwJACMwLBYtLSAH/qnEHCABbDAA3RENrQIO3QItFjAL +6jAsFjUnFjT7FjEgQBBQMCoVZykgVCkU4SggBSgU4iYgMPYU4yABEGgwLRTg/yIWIP4CcHD/Fjkg +ogJzsInjhuGL5fjiAiD+Anhw+uIEIOICe/Ca9Jjym/WW8ZnzJh0BKR0BKx0BjuCe8C4dAYwgLBZC +KiBULB0BKrQNKh0BKCAFKJQQLyAwL2QR/eQMIAAQWDD7xA4gMAJSsPwKCCBoAliwWHHV+h0BIHgC +WLD6rCAgCBBgMFhx0PodASDkAljw+qwqIAYQYDBYccz6HQEgnAJYsPqsLSADEGAwWHHH+h0BILgC +WLD6rDQgCBBgMFhxwi8dAS4RmiYRm/WqQAoLASww9RMUCAkBKDD1aUAJsAQ6IP6ZEQIJAB1w+bsR +C6AEOqD2FYkqCQBasPYiDCoHASww8wNABgUBdDD5MxEHsAQ94PY2VAIJADzw/t1AAgkANPDz9BQr +0AQ+4PYgaCgJAF5w/CBpLg4BcDD63REPkAQ7oPWHQAwJAHdw/G5ABgMBMDD8c0AH0AQ5oP4zEQ/w +BDug8+4CDAkAN3D8XEAMCQB3cP0KMCwJAGsw/HcRDAkAazD89BUmCQBF8PgiDCYJAFXw+XcCBgUB +KDD1Q0AH8AQ5oPYzAgYQAUAw+B5QCBIBQDD67hEJkAQ6IPtmEQ4JAEOw9zMCDgkAM7Dz9BcuCQAj +sC70FoQnLUkUKkwg+EIJJDQAN2BkhCwrHH/7vDEgCBBgMFtdocAg0Q/Dz/8CAAYDFGbQhCn7ClYg +FAA1ICpABf8CAAYCZN6QhEtlT+/AINEPKyAFxNP9uc9wFRBQMCwWgPAMFwAAEHAw/hYBLgAQWDD7 +FgAgEAJAcG2qAgAIihuqD5sS+CIAIAQQSDD5FCAgABBQMPoUGyALEEgw+jr/KYAEOiD6FQwoCQBK +MCgWAy8gBA8CAPocISQCqYfg/AoDIKICWLBYcUwqHCX8CgMgnAJYsFhxSROpdigiFiMyiPmIEQA/ +EEgw+SQFIgAgRPDAkPkUOSCAAlBw+RQ6IIACWPD5FDsgBRBAMPgUOCAIEGAwWHE5KzxI/AoDIAgC +UHBYcTaOEfscCCIAAFCw0w/+jhQACxBgMP4WDyACEGgwWBQ9LBKAKiAM86laEBkQQDAoJFQrUnjz +MoggEBBIMPUiFiD+AkBw+6oIAGICQjDwDBcLkAQ6oPo6CAWQBD1g9SEZIgAgLPBtmgIACIoqoS7/ +AgAGATW2kB2o1vwiACDhEHAwLhTILRYu/ajTHYAEOyD9FiwsCQAjMCwWLS0gB/6ozxwgAWwwAN0R +Da0CDt0CLRYwC+owKxYxJxY0/BY1IEAQUDAqFWcpIFQpFOEoIAUoFOL2IDAgARBoMC0U4CYU4/8i +FiD+AnBw/xY5IKICc7CJ44bhi+X64gQg/gJ4cPjiAiDiAnvwmPKa9Jv1JvYBKfYDJh0BKR0BKx0B +LuIALvYALh0BLCIALBZCKiBULB0BKrQNKh0BKCAFKJQQLyAwL2QR/eQMIAAQWDD7xA4gMAJSsPwK +CCBoAliwWHDf+h0BIHgCWLD6rCAgCBBgMFhw2vodASDkAljw+qwqIAYQYDBYcNb6HQEgnAJYsPqs +LSADEGAwWHDR+h0BILgCWLD6rDQgCBBgMFhwzC8dAS4RmiYRm/WqQAoLASww9RMUCAkBKDD1aUAJ +sAQ6IP6ZEQIJAB1w+bsRC6AEOqD2FYkqCQBasPYiDCoHASww8wNABgUBdDD5MxEHsAQ94PY2VAIJ +ADzw/t1AAgkANPDz9BQr0AQ+4PYgaCgJAF5w/CBpLg4BcDD63REPkAQ7oPWHQAwJAHdw/G5ABgMB +MDD8c0AH0AQ5oP4zEQ/wBDug8+4CDAkAN3D8XEAMCQB3cP0KMCwJAGsw/HcRDAkAazD89BUmCQBF +8PgiDCYJAFXw+XcCBgUBKDD1Q0AH8AQ5oPYzAgYQAUAw+B5QCBIBQDD67hEJkAQ6IPtmEQ4JAEOw +9zMCDgkAM7Dz9BcuCQAjsC70FoQnLUkU9NJaYEACUTAoQglkgk8rHH/7vDEgCBBgMFtcqxSorCgi +FiRCiPmIEQIAAFCw+EQIAIcQWDBb/hnaIFr/oYopyaCDqysKh1vaEPo8AA/0ALTgiin7IgsgRQA2 +oM6wmitgAC8A2iD7HH8gCBBgMPu8MSACEGgwW1VVwCDRDwAAAIm7yJn5kgsiAABacGWf9Jq7m6zA +wPwmCSAAEFAwi0pyuQqKKY0onUpgACAAAMmwjbhy0Qz73AAACQA3YI3YctnyyLcqIgkuIggutgj7 +IAUgABB4MJ8o+yQwIEYAtqCIK8+MxJP/AgAGANZO0BqoeYsgLqJ0+qKLIAAQYDD+uwwAARBoMFtY +wRyoV4vOw9/9JAUh/gJa8PvGDiAAEBAw0Q/E4v4kBSAAEBAw0Q8AZEs8/wIAD/2c2pDaQFr/YSgx +HIozKiYfiTIoJQgpJh4vMB9k8XvAw/odASCcAiiw+1wAAIoCUrBYcCwYqM4jMB8ACI34HQEgFRBI +MPMDRgCwAkIwbZoCAAiKKh0BHqkaLhZW+0IAIAMQYDD8pGsgARBoMP2kcCALEGAw/Tr/K4AEPuD9 +FbQqCQBm8CsWVykgBA8CAPqscSQAb4Zg/AoDIKICWLBYcBH6HQEiAABZcPqsdSADEGAwWHAM+x0B +IAEQeDAvtIjztI0gABBwMP60iSIAAFEw/rSKIAsQYDD+tIsgAhBoMP60jiCwAlrwWBMOw4n4JAUg +ABAQMNEPAAAA/AoDIJACWLBYb/gtEAIsEAH6EAAgSgJYcCq0ACy0Af20AiArEEgwKSQF8/q1YgAA +GLAA2iD7HH8gCBBgMPu8MSACEGgwW1TWY/2lLFJsiyD6UoMgARBoMPy7DAAAEGAwW1hfwCDRDwDD +3/0kBSAAEBAw0Q8AAAAA/AoDIJACWLBYb9ovHQEu/EUo4AH54AAg6gJ78Cn0ACj0AS7gAi70AmP/ +F9pA+ywAAAAQYDBYFz7AINEPbBAEJiACKCAAJyAB9AoAIBAQKDDzIAMjgAQ6IPBBBAIJABHw8CIa +B4AEOaDwUQQCCQA08AAzGgMiAtEPbBAGJiILLyAEiiko/PsIajj2CgAgXwA2oG0ILYunKbkU/goB +IAAQYDD9CgAgIQA2YIm5iJKJkwSIDAjsOAWZDAntOH3IKYqryqhj/8sAjmKIY/TuDAABEGgw9YgM +AAAQYDD43DgAABBYMA7bOHyw1dKg0Q8nIAfzqHgWIAE8MAd3Cf6odBfABD3g+Kd5EgAgHfCTECMy +fwh3CA5+CP8CAAYAkXTQbQgsKDkQizf8CgEgABBQMPkKACAgADYgjbKIswTdDAWIDAjKOA3JOHqY +L4Mwc+F2Y//MAItijGP0uwwAARBQMPXMDAAAEEgw/Kk4AAAQQDALqDj5gNRwABBYMI0xLzIAL9YA +LjIALeYBJjYAJjYBLCAEacQNAioC/QqCIAEQYDBYLCj5+sAgMAJA8AmIAfY1ECCAAkIwmDf4NgYh +8AJQ8FtVCMAg0Q+DEB6pByMyfa5+fjkHYABmgzBz4WEoORCLN/wKASAAEFAw+QoAICcANiCNsoiz +BN0MBYgMCMo4Dck4epDSaPQ7Hqj5/jUJIAAQEDDRD4tijGP0uwwAARBQMPXMDAAAEEgw/Kk4AAAQ +QDALqDj5gKBwABBYMGP/xcAg0Q8A2iD9CoIgARBgMFgr/Ryo5vw1CSAAEBAw0Q8AAGwQEi0gBBeo +4vUgByIAAHFwGagU+3K9IgAAMTD1BUEEgAA7YP8CAAQAewdgaNYEwCDRDwAvkn+KLowtCaoR/6oI +DZAEOyD4ogcsACBj8CwWFYzHiI4oFhKMziwWFGAAJigiFi+SfwmIEfgiBy4AIEfwLxYVj/cogg4o +FhIv8g7/FhQiAABQsCQgBSwwE/gKQiA+EEgw/C9FBgMQzRD5Ci0mAwzFEPgKTiYDCM0Q/wIABgME +xRD7Fg0gABAgMPUWCygAAWAw+BYWJgBVg2AqFgf7FgYgugB/MP8CAAQAbANg9RYLIKAAN+D/AgAA +AHSH4NVA/wIAB/+cg2D6EhYvMQA1YGSvKYon2zD6rCAiAABhsFtbLfWkFiAAEBAw0Q+PJyIWFY/+ +LxYU8/9bYAAQUDAAjTeMNp8emx3+FgwiAABQsFv/NtSg9RYLJUUANqCLFvoSByABECgwKTATCSlF +ypz7FgYgAt2GYC0gBGP/gwAAAAAAAP4WDCIAACCw8//YYAAQKDCeHPUKACAAECAwLUAF/Ny7IBEQ +eDD/AgAKANP7EBiofAjICoiAmxYKgAAAAAAAAAD1FgsvzAA34PsWBiH/mB/giUebHZ4c9RYLIBcA +tmBj/lmbFolHmx2eHPUWCy5OADZg9QoAIAAQIDArmRT0tehgQAJScIuZjBwMDEf4wipiAAA68I2x +jBb9DUcAABBYMFtXsIlHLpkU9OYdYEACUnCLmfAABmIAADrwkx2PGxim+8DI/P8RAAQQWDD4/wgA +ARBIMPjyOiIAAGnw+bwADAUAPnANyTn5FhAqA9HOECjyOSgWEywSE/7MAAV2ADcg/BYYIJgANeAs +QActQQcTpnsfqEX9DUoIAgFgMPqIEA3ABD9g+UEILAkAR3D8DEEMCQB/cP3mAC0ABDsg/0IAIAAQ +QDDz5gYoCQBmcPjmBSgJAB5w+eYEIDAQUDCa4/qm1x+ABD/g+uYCLgkAX/Cf4Y1xH6guDQ1HD90C +/XYBIEACG7ACB4YAQ2MAB4YAQ2GKRyfsQPcWGCBAAlKwJxIY+xINIgAAYbBbWqv9EhAiAABh8Pam +ASIAABqw+kwAAgAAWPBYI7HaQFr9odpAW1SBY/4jyK0sEhKbFivAOLG7K8Q4ixYsEhWdGPsWBiAP +ADcgLhIULeBcsd0t5FwcqAwvQTeOQI0g+BIIIAIQUDD4FgAgMhBYMFh1zYlHK5kU9LQ5YEACUnCL +mSyyAPyMVwA0EHAw/BYRJgKH9xAvCgD/Fg8gChBoMCpBCCtAFvgK/yP/EGAw/KoMAAYQSDD6nTgA +NgRC8CwSDC0WCSpAQQDMjlteev0SCSYgADagjhsfpowM7hGv7i/iOv8CAAoCI+/QKeI5ZJQ8KRYT +H6YAHKaHnhrwDwcCAABacC0WCQBLYQBLYQBLYQBLYQBLYQBLYS5AQShBBxmm6A7qCQyqEfqmeRgA +IFZw+ZJ/KUABQDAMiBH6iAIAABBoMPoSEypIAUww+Q9GC4AEPuD7QSIuCQBf8C0WBPimAC8ABDug ++9gUCAcBTDD1mREJQAQ6IPS7EQgJAEZw+EIALgkAT/D9pQogBhBIMPymAiBMEGgw/6e/HgkAe7D8 +p7wZgAQ6IP2mAygJAEow+KYBLgkAe7D+pgQqCQBm8PumBiA8EGAwLKULG6ez+6YHIAwQYDD7TEgg +QAJSsFhuCS4SEy9BKi/kLQ+PFC/kLC1AVy3kOw2NFC3kOg2NFP3kOSC4Alkw/Y0UABgQYDD95Dgg +eAJTsFht+yhAdMSS/wIABgFizhAvEhP9p5wfgRBwMP70PCAAEEAwKPYU+PUlICACWHD49EQgAxBg +MP0WBCCKAlPwWG3rKhITKUB0+aRYIgAAUTBa/REbprmMTSuyfwnMEay7i7rJsSu8YPwKBCAoAlBw +WG3fixVgAAQbpm+bFR2mzSw66Ay8LA3MKPwWBSIAAFEwWv0BixUcphb9pscSAABRMFr9HdpAWv0A +LUEILjr/0w//AgAGAIh3UC8SEcOE/wIABgB/R9CJRyqZFGSh3IuZGKduH6WYjbApsBKOsfwSEy4F +AE4w/g5HDPgBbDD9FhEuCQB7sP62ASIAAFEw/RIJIMACYzBYIvMqEhH1FhkgMhBYMPYWGiYAdN6Q +LBIR9RYZIDUQaDD2FhomAGtvEI9H9goAL8AQcDD29RQgQAJT8PYSGi4AQHKw9RIZIIACc7D+9gki +AABY8P72CCIAAGGwW1nPY/rYjx5k8nz/AgAAAVoH4PoSByIAAFjw/GwAABYQaDBYKk0tIATz+jxg +ABAoMNxg/QqEIgAAWPBYKkccpzyOMo8ziiCaEPkgBSAyEFgw+RYBIAIQUDBYdPbAINEPix9lvwCP +Go4ZLvY5LCAW9RYZIP8QaDD2Fhon/6nvECpAQftAFiA8EGAwW12XJRYZJhYaY/83iUdlmshj+QcA +AChBFCVBEsBg+BYXLyIANiD6ckIiAABZcPwKACABEGgwW1XwKHJDKRIX9mwBIAICKXAIVS55adhj +/vPIqSsSEimwQLGZKbRAKxIVyLktEhQs0GSxzCzUZC1CAg8CAPoWByAXADdgDdoCWF6N+6wAAgAA +UTBbV+SKF8Ta/UQFIA8ANqAvEhIu8EGx7i70QS8SFWT7zSkSFCiQZbGIKJRlY/u/AADz+8lgABBY +MPP+IWAAEFgw8/oaYAAQWDCJQmSR62Rw7/sSDSIAAGGwW1zlY/ltAAArEhMqsEixqiq0SGP9MMip +LBISK8A6sbsrxDosEhVky2wuEhQt4F6x3S3kXmP7XgDE6y5EBWP7VcT6L0QFY/tN8/nlYAAQWDCI +QmSBpClBCCo6//8CAAYAolZQKxIRw8T/AgAGAJlm0IlHLZkU9NFfYEACUnCLmYex/BIGJuABPDD7 +CgAiAABp8FtWE4pH2zD6rCAiAABhsFtZTIxAi0cIzBEMbAL8pgEgQAJS8PsSBiIAAGHwW1lFY/iw +jbGMFv0NRwAAEFgwW1YE+hYPIDoAtqDz+uVgBhBoMAAAAAAAAPsSDS/AEHAw/q4BAAAQeDD/pQQg +gAJzsJ6h/qYAIgAAYbBbWTJj+GPE+i8kBfP6qmAKEGgwjzOOMvymqRAFEFAw/SIAIDIQWDBYdGWI +F8iJKhISKaA5sZkppDkqEhVkrV4sEhQrwF2xuyvEXWP9UAAcpp2OMo8ziSCZEIg3mBP9MgYgBRBQ +MP0WAiAyEFgwWHRUihfIqSwSEivAQ7G7K8RDLBIVZM0YLhIULeBnsd0t5Gdj/QoAjh9l7syIR//6 +wCBAAlIw/68BAAAQSDD5hRQggAJ78P+GCSIAAFjw/4YIIgAAYbBbWQFj96AAAAAAAPP+o2AAEFgw +AIsb2kD7vBgiAABhMFtdV4pH8/3/YEACUrCLG9pA+7wYIgAAYTBbXVFj/kjAwCwWE2P4Xo1CZd47 +K0BB2kD7vBIiAABhMFtdSWP+KGwQCPogByIAADEw9TIAIgAAIXAoIATTD/UFRwogAVAw+hYEINYC +OXD3RxQEARaCICsgFigK/9MPeLELAMSOKiBBW1zaZKKxiRQapO0MmRGqmZkVKZI69BIFKgD7PlAk +Qjn4pGIR6wA1IPAIBwIAAEEwbXkCAEhhAioC+zwAAAIQYDBbLgooIQcZpN8ICEoMiBEJiAKYQI4g +9qTdEJgCeXD2RgIvgAQ7oP9GAy4JAHHwnkEpIEEYpUArIAUJnQn6ISItwAQ/YP2ICABQEGAw+IJ/ +ICwEYvDEzvyxDHBWEGgw/wIADgEXatAbpi8Wpij63hQMwAFAMPiPQgwHAUQw9KoRD0AEO6D2Rgcg +eAIxcPZFCykABDpg+aYcHVAEP2D4/xEMCQB3cP/MAgoJAFqw/cwCAAAQWDD6RgYoCQBiMPtFCigJ +AEow+EYEIJACeLDyDxYAQAJxMABOY/ohKiAAEGgwLUQxLUQy/UQzIAAQYDAsRDUsRDYsRDcrRC77 +RC8gABBIMClEMPpELSAAEEAwKEQ0CooUKkQsLyBXL0Q7DwIAD48UL0Q6D48U/0Q5ILgCWLD/jxQA +BBBgMP9EOCB4AlEwWGxN9hYDIMACQLDzCBYAgAJJMABJigAIiAAJii4iHC5EUw6OFC5EUg6OFP5E +USCoAlEw/o4UAGACWPD+RFAiAABhcFhsPPggdCgAIC0wKJRYhhUnZjkrIBYvCv9/sQgqIEEsEgNb +XErEqCokBSgwEsqAG6QDHKRwHaUh+4soAgAAULBa+3baIFr7WcAg0Q+MImTAf8Ag0Q+TEfosAAIA +AFhw/TEIIgAAYPD2FgIiAABxMFtFaC0KiH2ha4oQZK/TiqeLEfwSAiBAAlKwW1hGjBCNwIsSCN0R +DbsC+6YBIgAAGrD6LAACAABY8FtEnN6g+hIAIBcAN6DbMPwSAiIAAGkwWCfCwCDRDwAA8/1gYgAA +ErAAixTaIPu8GCIAAGCwW1yPwCDRD4sR/BICIgAAULBYKLTAINEPjCJlz1YrIEHaIPu8EiIAAGCw +W1yFwCDRD8XCLCQFY/3NAABsEAb4QTRgARBQMPhCEWAEEFgw9goDIgBOhSBoRF7RD2RQ+GlR9/o0 +CCCAAliw+jwQIAgQYDBYa+nRDystAvmjoxAFEGAwLDQIK7BEKpJ+KZKAq6oJqhGqmSiQNfoKACDI +ADYgLZBJ/woBIL0AN2AokF0I+jkJrhEuNAnRDyU0CwVZCfKZCQDeEFAw+zQIKAAgVnAskQIqkQEp +kQAMDE/8NAwqKAFQMPo0DSngAUwwKTUH0Q8mNAgsIGrA4vxfEgAIEEAw/BoSCAcBZDD8PRIKAEBC +sPvdAQgAQEMw/v8BDgBAczD77hEJ8AQ6IPn/AgoJAGqw+80BCgkAerD8DEAN0AQ/YPjdAg2QBDsg +/swCCgkAarAMqgIqNAnRD8DwLzQIji+eM9EPAAmoESg0CdEPbBAOGqNmK6J+J6KA+KJ8KgAgFvAJ +uxGre/uyBygAIBIwCYgR8hYQJgAgRfD7sg4ioAA1IB6kUsDA/uCAIAQQaDBt2g4AwAQOCBt/hwOx +yZkdscwqGoCqupoeKqDlmxSTFfIKACJOADagHKRHHqRIGqREmhgqEhD5pEMQARAwMPkWCyAAEHgw ++Kz/KyAEPqD4bzgN4AQ+oP8WBiwAIHdw/RYHKgAgZvD7Fgkq4AFQMPoWDCAAEHAwnhrwAG9vABAw +MAAAsUQOHhRl7/cYpSQtEhD6j0cCAABxcPi4AQvgASQw+xYPLAAgOvD8wEQgBRBQMPwWESmABDog ++xYALgkAR/D8pRcQGBBYMFhy0RmkJP8CAAYAYs1QGqQielFYix4rsOWxIvM8BioAxdiQJTEAKzEB +KjECKnReJXUw+g5HDCgBWDD8dF8giQA3oMBAbQgNfmANDo4U9O9xYBACITBj/+vH0P8CAA//r3dQ +Dk4U8/9TYAgCITCOHf8CAAIAZ4OgjBstcCL/EhEgBBBQMP8WACAyEFgw/xIMLuABIDBYcqwqcCIZ +o/wKqwn4EhArwAQ+4PwSESgAIF5wLJR+9JR/IAEQWDArlH0olHxbzXFj/0zz/vdgABAgMBii8SkS +EBWjYSiCbyVSiKmICYgR/BIIJAAgRXAuUDWNUCpQB5oQKVAW+RYBIDAQWDD4URkgAhB4MPgWAiAF +EFAwWHKNKVA00w//AgAH/3waYCoSECwSEfxUFirgASQwK1UZKlQH+lwAAAIQWDBbxhxj/tEtEhBk +0HaIFh+jz44aCP45nhqMH4kX+hIKLeAEOyDwwQQABBBYMAC7GquqKpazixnAgPq2jCAAEFgw+ZKz +IAgQUDBtqhfwgQQKYAFIMPCqGgAEAkIw+UkUCgAgVvCOGQstFC3mi2P+zIIUIi0BLyGhwIQI/wIv +JaGCFdEPAMCAmBpj/40AwCDRD2wQEByisSbCfCrCgCvCfqJmCWYR+ycIBgAgMrD4YhsnkAQ94Ken +h3cpgQMogQLVMPdyDiYAkE4QGKSWE6K8GaSVHKKjHqKknhAsFgL5FgkgAxB4MPMWBigJAECw+BYI +IACWBWD6CgEiAH8BYP8CAAIAqgVg/wIABADeAWAqYhsnFhT0FhMgABBYMFtTgBei0hiijiUWEvWi +rhIAACKw8ABRYgAAErAAAAAAi5nCyFtRe2Wh1/pcAAIAAFhw/AoEIAIQaDBbT7H9UgAgBBBQMPyk +chAYEFgwWHIp+mIbIAICWLBbU2oYongVopr6QWVyAAASsCiCeCVSgw8CAKKICYgRqFUoUS53gdD6 +YhwiAABYsFtTTv8KBC/CADagjlAI7hEP7gKeES1QB4lXLFEuDQ1B+5kULQAEP2ANzAL6nCAsCQAb +MPwWBC9iALbg8/9cYAAQWDDApPykURAYEFgwWHIH0Q8AAABkQRb/AgAB/4edIPoUKCCAAlnw+hww +IAgQYDBYapVj/vQAAAAAAPh9AiAFEEgwKRQoKIBEq4gJiBGoqi+gNfkKACARADfgK6BJyLYtoF3A +wQ3JOQmeES4UKWP+uQAALxQoLXBq/VgSAAQQcDD9MhIACBBIMP0cEgoHAWgw+cwBAgBAcLD+3gEI +AEBPcPIKAiwJABMw/5kRD9AEO6D57gIIAEASMPLSAQwAAWww+yIRCAkAUjD53REMCQBDMPLdAgwJ +AHMwDcwCLBQpY/5IACQUK/RLCQDeEGAw97sJAAQQaDD9FCgqACBm8C6xAv2xASCAAmBwLcUBLsUC +K7EAK8UAKBEhKREgKhEiKhQs+RUXKCgBQDAoFC1j/fvA0C0UKIx/nBtj/e8poCjLkWiRP2iTTI5X +L+EV+PrAIEACc7AI6AGo+PusQCgAIEaQ+uwAACgQYDBbUPhkrfRj/8kAAC8SEmnyxigSE2WPwGAA +HwArEhJpsrksEhNpwbNgAA8ALRISadOsYAAFD7sMY/+9LBISLRIT+hIUIEACWrBb/j5j/dIAbBAO +kxYoLQL3MgogAxBoMP0WECAQEGAw/BYAIAIQWDD7FgEgMBBQMPoWAiBQAiDw9BYJIgAAMPD3Fggh +gBAgMPeh7hQAICCw8oBEICgCGPDzFgoiAAAYcCxgNS1iEJwbLGAxhdSO0I/SidGI04vWmxyL1YrX +mh8qsAKYHvkWDSAJEEAw/GQwKAYBVDD5ZDYqAArDEBijwQjICoiAmxWMGwqAAAAAKWA3LGA1ZJC3 ++QoBILQANyCIH4ocKWQxldSb1Z7Qn9Ka1oodmtGKG5jXiB741gMgtwA2oGTAsisSEPM8BCAIAjnw ++7z/ICgCMbD7FhAvZQC24MAg0Q8sYDKbFfhgOSAAEGgw+BYHI2IANyCfFC4WEYwwihwrYDotZDUp +YDiNFy1kMvkJQAoAAVww+rsRCZAEPmD7Eg4oCQBecClUAlhp4y4SEYoYjxSLFYqhLGA1/WIQIAAQ +QDD4ZDcgAgJSsCpkNChgMvkSBiInADYgKZAj+hIGIrwANmAqoCL5CgMiuQA2oGP/KwAAZM9Mixb8 +EgomAT7dkP0SCSYBMeWQ/wIAD/+b6ZAuQOT1CgAh/5YnoNog9QxHAAQQWDBb/s4vQOSxVX9S6mP/ +DylQAogf+BYNIADj4lD/AgAAAN/ikPsWBSABUGZQmxX+FhEiAUtmkJsV/xYEIAsQSDApZDH5CgEq +BQFUMPhypCAAEGAwC5w4+xIPIgAAULALgACLFS2wAsCR/V1AAAAQYDANnDgsZDMtUAL/EgQiAABy +sP1YQAAAEGAw+Jw4AN8QQDD8ZDUsAEBHcP1UAiGdALcgiBiIgfxgNSACAkIwKGQ0YAGGKWA3Y/40 +wJEpZDUpYDfz/ilgARBgMClQASiwAfoSCCgBAMow+FQAIAAQYDAsZDWKoSlgN/xgNSACAlKwKmQ0 +Y/34KHKk+iwAAgAAW/D7FgQgABBgMAuAAMDQLWQ1LWQzKVAC/xIEICAQYDD7EgUoCQBmcClUAi1i +EPlgNyIAAHKw8/22YAAQYDAAAAAAAChypPosAAIAAFvw+xYEIAAQYDALgAD9EgggABBwMC5kNS5k +M43Rsd0tZDQpUAL/EgQgIBBgMPsSBSgJAGZwKVQCLGA1LWIQKWA38/1fYgAAcrAocqT6LAACAABb +8PsWBCABEGAwC4AAwNEtZDMpUAL/EgQg3xBgMPsSBSgAQGZwKVQCLGA1LWIQKWA38/0dYgAAcrAA +APP9HmACEEgwmxX/FgQgDBBwMC5kMShypPosAAIAAFvw+xYEIAAQYDALgAD/EgQgABBIMClkMylQ +AosV/QoBIAAQYDD5WEACAABysPjcOADfEFAw/GQ1KABAVnD5VAIg6QA3IC1iEClgN2P8qtog+woD +IAAQYDBb/jtj/MsAANog+woCIAAQYDBb/jbaIPsKAiABEGAwW/4zY/ysAAAAAADz/H5gBxBIMCpg +O2SgkSlQASiwASpQAAmINPihB3AFEEgwY/xcKLAAwJj6iAwABhBQMPP8TGgFAEawmxWKF58U/hYR +IAEQSDAKnThj/I0AAAAuFhGLHyhyqJ8UihQLgAAuEhH/EgQgCRBIMP0KCiIAAGJw+xIFLAUAU3D8 +ZDEgggRLMP8CAAgAQwcgwIt4wSn/AgAL/3CDICxgNWP/JAAA8/veYAQQSDCJGImR/GA1IAICSnAp +ZDRj/wgqsAJj/QsocqTaIPsSBCAAEGAwC4AAwMAsZDMpUAKPFPsSBSIAAHKw+VxAACAQUDD8ZDUq +CQBScPpUAiP/ZupQjRiN0fxgNSACAmtwLWQ0Y/62AIsVK7AC+HKkIAEQSDD7W0AAABBgMAucOPsS +BCIAAFCwC4AAixUtsALAkf1dQAAAEGAwDZw4LGQzLVAC/xIEIgAAcrD9WEAAABBgMPicOADfEEAw +/GQ1LABAR3D9VAIuVwC3IIgYiIH8YDUgAgJCMChkNGP+QAAAbBAK+6CBEdgQUDCqKi6gbC2yfiuy +gK7d8xYFLZAEP2D6FggqACBu8PsWCSAAEEAw+LRjIAAQMDD4tE8gARBgMPi0OyIAACjw/LQiIAAQ +GDD4pHIiAAA6MNoQ+1wAAAIQYDBYaK0qEQAKmUbwkAQAAEkGYGuVNfCRBAIAGSJgwMEAzBoAkATz +CxsCCQAfMPMDRwAuAH7wKCKL+IwBJgkAPzD4Josm4AE8MGAABygijLGIKCaMCglIppayZvYGTwAE +Akpw9GORdAAgTXCFFZMR+AqmIHACeLD/FgQgzAJwsP4WAyAAEGgw/RYHICACMLD2FgYoACBAsJgS +8ABUYAAQMDADCBvwkQQCAbd+EMCBAIgaCDMC8/+cYuABHDD/AgAAALiGYGiSWv8CAAIAUwZg/wIA +BAB4gmCmNvg8AiAEAjGw9gZPBAAgRXD/AgAKAMIhkNoQ+1wAAAIQYDBYaG8jEQADmUb0f7RjAAEc +MG+VrACQBAcIG3+Ho7I58//LZAAgTXCMGfoKFCABEFgw+8Q7K//TnpDAwG05FKLN/dA4LgAgKzAu +4AL96QpwAgJjMGP/hQAAAP7TBn//EGAwwMFkz3WKFPw8AAAEAllwWGhTY/9ljxn8CgAgARBwMP70 +Tyf/rBTgbTkUos390GYuACArMC7gAv3pDXACAmMwY/84AAAAAAAA/tMGf/8QYDDAwWTPJYoT/DwA +AAQCWXBYaD9j/xUAAAD/PPwgBhBAMAj/LPoSCSAIEEAw+BIILgMAR/D8CgAgARBIMPmkYyA0EHAw +/4SNK/9yH5BtORSizf3Qpi4AICswLuAC/ekJcAICYzBj/sQAAP7TBn//EGAwwMFkzrWKEvw8AAAE +AllwWGgjY/6lihYvUAIvJAz+UAMgCAJZcP4kDSAIEGAwWGgbiySKIogXjRn5CgEgABBgMPuqDAjg +AUAw/NQiKAUAUnCYF2P+ZY4XZOFKiBjA8f+EciABEHAwihkpoDXAMPqiCiEqADZgixkrsElksR2N +GS3QXcDBDcM5/aIBIgAAIPCPGSugACegAYX7LPESKfAhJlABKfQg//AiIFgAPmD/AgACAJqCYP8C +AAIApYZg/wIABACwgmD/AgAEAMiGYP8CAAYAu4JgfNkCZEFkZODZZPDuwKOLGfq0ISIAAFCwW/23 +iBkogDX+CgAgeAA2IIkZKZBJZJBrihkqoF1koGP+CgEgYwA04IsYK7Bz/wIAAABRBuCMEYIZwd7y +IhogeAhrMIggz4KJGSmSFYmQypmKGSqiEIqgyqCKGIsnKyYB+qBsIAEQYDBb/CaMGPomACABEFgw +K8Rv0Q8AjhjA0S3kb9EPZD+gjRj8oXwQBRBQMP3QbCAkEFgwWG8uihjAsfqgbCAAEGAwW/zLY/95 +jaHz/u5gABAgMIwYwLArxHLz/rZgABBwMAAAAADz/ydgARBQMI4YwNAt5HNj/1cAAAAAAAD3aDQA +BRB4MPi4DAAEEFAwCPo4Y/78iaGIGLGZ+aYBIAEQSDAphHNj/toqIoqxqiomitEPwJGZoYkZwICY +oiiVEiigAfikACABEEAwKJQjY/6yJ6ABJlABiRgHaDT4pAAgARBAMCiUc2P+mQAAAAAA8/6fYAIQ +UDCFUYgY9aYCIAEQSDAphHNj/nqIGZIa8lICIAEQSDAphCOJooVRIoUS8hIKIawIKnCIGcCg+oQj +L/8t41Bj/lAAbBAI/p9AEZgQMDD2JggAFRBgMPpgrCACEHgw+OJ+IeAQSDD7XAABwBA4MP7igCGg +ECgw9ycICAAgUjD5iBEEACAssPkpCA4AIEOw+eYaIAkQQDD15hAgYAJTsPfmFSCIAmuw9+xYIHIE +QvD4uUFgCxBAMP8CAAYAqMbQ+bopYBkQSDB0kyH+RB5h/gJRMMG6+rNicAMQYDAMqixgAFkAAPoW +ACYBDmUQ0Q8AAAAAAAD6FgAh6AhhMCQaI6Qk+zwAAgAAUTBYZ1ODEPoKASE4EEAw+jQNIQ4QSDD0 +VgEoACBMsPlWAigAIECwmFMZoP5gAFMAAAAAwKj1GmwiAABY8PpkzSQAICyw/EwAAgAAUXBYZ0AZ +oPX8CgIhhRBAMPx0DSAAEFgw+3QPIVMQUDD1ZhMqACBQsPpmFCgAIECw+GYVIgAAGfAsMAyZEicw +DyowDYU0KDAOmBSVFpoVlxMkUgD7UgIh0BB4MPdSASAGEGgw9VIDIAAQUDBt2huirg/uCC3ggi7g +fA8CAA8CAH3jF/7TBHACAlKw+goAIBQAtyBgAHoAAAAAAPoKASByADcgaMF0/xIGIgBcgyCU8Jfx +m/KV8yw0DNEP/wIAA/9uGSAZoMf7MAAhTxBQMPwwASoAIFCwLKQB+6QAIU0QQDD/5FEqBwFcMPvk +UygAIECw+iZxIVEQGDD4JnIiACAcsCMmc/P/MWIAABtwAAAAAADAwfw0DCABEGAw9UFucgAAEzAt +EgX0XAACAJCDYPsWASAAmIdgiBL6YKwiAABZMAuAAIk0+hIBIAEQWDArNAWVk5qSl5GUkCI0DNEP +AAAAAAAA8swABgBivRCMFfR8AAIAggMg+xYBIXoCPyCOFGTguPsWAS+wALXgYACtjxUPAgAPAgBo +8mJp8X+JFGSQemRwd/sWASIAACHw8/+HYAIQEDAkGiP0JAgCAABY8PcwACIAAFEwWGbQgxD4Gjgq +BwE4MPo0DyACEFgw+zQNIQ4QSDD0VgEoACBMsPlWAigAIECwmFMZoHhj/j2MFMnKjRP5CgAvngA3 +YI4T/wIAAABGB6D7FgEh/4+GYI8WlPCX8ZvylfMiNAzRDwAAiBVogllpgeaKFMihZX/f+xYBIgAA +IvDz/u9gARAQMIwU+xYBLuUANyCNE/kKAS+uALdgY/9AAI4U+xYBLs0AN6BlfzKbEWP+wI8UZP/A +iBNogSP7FgEuswC14GP/sACJFGSfqowTaMEVZH+iY/9/Za90Y/8BAABlr5Rj/9UAAGWvjGP/4wAA +bBAGiCokIAf5IDUgBBBQMPQEQQAYABIw8AAGagkAUnDakPygQxAwEFgw/yICIgAAaLD+IgAm4AFU +MPcWACAFEFAwWG3tHp6W+J7FFOABLDD6oDkSDAA5YIMz/OIXJ8AEOSD9IgAmACBBsCtiOvzMASoJ +AFNw/OYXIgBWwuAuYjn5njIQogA3oPAJBwIAAEuwAElhAElhGZ5AHKAnG56zHZ6wLeYA/yIAJYAE +OeD75gIgEBBAMPjmAywJAGKw/OYEJAkASTD05QogNAJTsPgxBiACECAw+OULL4AEP+D9MQcuCQAn +8P/mASBAAljw/eUMIAYQYDBYZlf0ZjkvgBBwMP40EiI6ADlgiif7CgEgABBgMPqsICABEGgwW089 +0qDRD8Ag0Q8AiyJlsFgrTBj6LAACAABgsFtW0WlS5IonwLD6rCAgARBgMFtSbh2e5p2gjCAbn/r7 +pgIgARBoMPjMEQAwEFgw86YDLAkAazD8pgEiAABo8Pyf8hAFEFAwWG2ewCDRD8Cl/J/vEDAQWDBY +bZrAINEPAAAAbBAGF53qJnKGimMoSgBtigeJoHORWiqsEIphK6ECZLFMW0rXjWP8qhECAABisKra +/KUCIToANqDzpgAiAABZMPqsCiAGEGAwWGYcG535KnKALHJ4K7DR9nKGLZAEOyD8qggAAIb+0Cei +J4d+h39gAQVloPlj/6EA2pD8n8cQMBBYMP8iAiIAAGiw/iIAJOABVDD1FgAgBRBQMFhtcRieSRye +Ghqfvv0iACXABDjg+8IXJAAgQTAoQjrTD/u8ASoJAFNw+8YXIgCZwiAuQjkPAgD5nbcRJQA3oPAJ +BwIAAEuwAElhAElhGZ3GHJ+tG544HZ42neD/IgAgEBBAMPjmAyOABDlg++YCLAkAYrD85gQiCQBI +sPLlCiIAAFnw+GEGIAIQEDD45QsvgAQ/4P1hBy4JABfw/+YBIDQCU7D95QwgBhBgMFhl3fJGOS+A +EHAwLmQS/mEGIgAAabD/YQcgBRBQMPyfkxAwEFgwWG090Q8noqeHfod/imIooQJkj+5bSoCIZAqm +CvhmCwoAIDqw+mUGIAAQSDD5ZgAvghA4MPlmAS/LADWgkmaTYiVlBy4gNS5kEy1AASxAACxkIC1k +IStAAypAAipkIitkIylABShABCdkEihkJClkJYoqIyAH+SA1IEACObDzA0EB/0YSkMCk8/6EagkA +UnCLIsmwwKX8n2sQMBBYMFhtFWP/RAAAKzwY+iwAAgAAYLBbVjKKJ8Cw+qwgIAEQYDBbUdAdnked +oIwgG59c+6YCIAEQaDD4zBEAMBBYMPamAywJAGsw/KYBIgAAabD8n1QQBRBQMFhtAGP+7QAAAGwQ +Btog8xYAIDoQWDD8nZUSAAAZsFr/DvasAAA0ADagZDANAzsC/AoGIFgCUrBYZYnIe9tw/AoGIGQC +UbBYZYWUaZVqiRCZaIgiyIbAINEPwCzRDysgB/sLQQIAAFCw+7wYIgAAYLBbVgXAINEPAABsEAQi +Ir/AQfMlDAAMADSgwCAFQjjRDwDAINEPbBAKLkAQL0AR+EAqIAAQUDD47hEAARAwMP/6/y4JAHuw +9OUIAgEjmiDAhG2KS6Or+7CMLAAgIrAswC77wTlwAgJSsPvDBnIAAFPw2mBlohuLICxALPu8NiAA +EFAwbckUpKz8wEYsACBesC3QAPqsAS4A/2NQYAAI0w9j/9IAAAAA/J8PEAUQUDD96uYgMBBYMP0i +AC4AIGuwWGy0+0w6IJgQUDD6OggABBBgMFhlRvsaGiA2EDAw+0QIAJQQSDD3CpAqANSpEPoKoCCk +EGAw+TkIAJwQaDD5FgYgIAJA8PgWBywAIGzw/RYDLAAgYPD8FgUhAhBYMPye8xoAIFzw+xYBKgAg +UPD6FggmACA88PwWAiBgAmMw/BYEIDMQGDArQAD/AgAMAEya0Hs6GvayKHA1EHAwe2Ijihb8CgQg +BAJZMFhlIWAAE9pw/AoEIAQCWTBYZR1gAAMAfrEML0ABsv+vRHVDuGABAowUjSCPFy5AAp4Z//Id +IAUQUDD90gAgMBBYMFhseYkZaJIZaZXMiBcogh3/AgACAGoeIIoXwJUpph1j/7WLFyuyHf8CAAIA +XprgjRfAxCzWHWP/ngAAarZx+rdcYBEQcDD/EgchHAhy8C/wBw8CANMP/wIAAf+/Y9CPFw8CACv0 +8C5AAS708SxAAS0aAA3MNvoSASzgAWAw/BYAIAQCWTBYZO/8EgIgBRBQMP0SACAwEFgwWGxTY/85 +ihj8CgQgBAJZMFhk5mP/KQAAarMc/wIABf+QiuCKFfwKBCAEAlkwWGTfY/8MAAAAAAD/AgAB/4Ie +4IoT/AoEIAQCWTBYZNhj/u/RDwB9wwHfYGX/9GP+BgAAbBAEijTynI0YcAFUMP2XB3/7EEAwCJkB +KCJvIiKAqYgJiBH4IggCAFCmkIQnhE4oQiX/AgAAAHUmIPyehBAFEFAw/UIlIDAQWDBYbCkoMEYp +MEfAsPqefhmABDog+YgCAPQQSDD+CrgsAFRKEMCUbZoWo7z9oIAsACBzMCzAfrG7/NkbcAICUrDa +QPtMECBAAmDwW/88wCDRDwAAAAAAAP3DBn//EFAwwKFkr9v9IgAgBRBQMPyeZxAwEFgwWGwMwCDR +DwAAAAD8nmQQBRBQMP0xCiAwEFgw/iIPIgAAeLBYbAOKL/gKASAAEHgw+QoAICcANqAuoRktMQoO +3QwNqTjAoAmKOAqPOPX/HmIFAEpwwCDRDwAAAPP/5WAAEEgw/SIAIAUQUDD8nk0QMBBYMFhr78Ag +0Q8AbBAEgi/IJyQhGXNJAtEPAMAg0Q9sEBoYnSEIORH5FgAgFRBIMPAIFwAQAkBwbZoCAAiK9J1s +EEICUHD0FgIgkAJYsP0iACALEHAw/zr/IAAQKDD/FQwgARAgMPUUGy2ABD9g9BQgLAkAd3D9FgMg +AxBgMFhkaCUUOSUUOiUUOygQAiwQAf0QACADEHAw/hQ4IEoCSHD9lAAgeAJQcPyUASCoAliw+JQC +IBAQYDBYZFkqHEz8CggggAJYsFhkViocVPwKCCBwAliwWGRSKhx8/AoIIMgCWLBYZE8bnSkZnGwe +nUolFFwlFGwlFIwYnHckFUT0nFsUEBBQMPoVQSAgEGAwLBQ8LBQ9KIJ8jyeNIPoVISAEEGAw8vIO +IgAAULD5Rp0sCQB3cP1GnCD/ECgw9RVCIAUQaDALgAAtQp0ZnQ0bnfoNjRT/nTEYACRpUBKdBChC +piIifwmIAfmdMBmQBDog+J0rEgAgQLD+IgwgARBQMPs7DAAAEBgwC6M48585DgBAQ7AP7gL+Jgwg +HwC0oNEPKiA6KyA7CKoRC6oCsaoqJDsKihQqJDrRDyosTvscAAADEGAwWGQX+xwIIgAAULD8Cgsg +AhBoMFgHIcPB/SAFIEEQWDD9JDAqBQAfMCskBdEPAGwQBvYsAAFRADUgKixI+hYBIIACYLD8FgIg +oAJYsPsWACBwAjiw8p3IH+8QcDD7nccQABAoMPAASm/9EGAwAGiVaWmaMS0wBC8wBfgwBi2ABD9g +D90C/zAHLYAEP2AI3QII3RH/3QID6BB4MA/dLP1kNiIAQFiwLzABpfXz8woKAFkhUCkwAP8CAAAA +TIZgaJJsaZSptDnzCRYCAABB8ABIivAASWIAQHCwAAAoMAIpMAP6+t8gCgJY8PoiAQmABDog+hIA +KAkASjD4ZRggAxBgMFhj140R+52dEBACePDxDxYP/RBgMPIdHg/vEHAwKjABpaXzowoL/8YlUGAA +MooS/AoGL/sQWDD7PAIiAEBYsFhjx/udjh/9EGAw8//Pb+8QcDAtMAMtZDTz/0liAEBgsMogGpxV +i2AuonT6oosgABBgMP67DAABEGgwW0w1wrQrZAXRD9EPEp18Y//VAABsEAgqICYXnGIKqAkMiBH0 +IAcmACBF8Ch9ASiA+fsgFiD/EEgw9ARBAAAQGDD3cn8iOQA2IHmxCADFjltT0mSilRib5QxFEahV +KFI6/wIABAEPxiAmUjn5m1sSFAA1oPAJBwIAAEmwAElhAElhAElhAElhAElhKiEHGJuMG5vY+ZwS +G0ABUDD0m9cbwAQ6oP+dWBoJAFqwmmCLIP3xAiAFEGAw//IAIDwQcDD+ZgMrgAQ+4PRmAioJAGbw +m2EkICYjZQqTaJNpk2rzZgsgLBBQMPNmDC5IATgw82YNL4AEO6DzZg4gBhBgMPNmDyoHATww82YQ +K1AEPuDzZhEqCQB28PlmBijAATww+5kCBQAEOSDzZhIkCQBJMPplCyQJAEEw9GYEICACcHD/5gAg +QAJRsP3lAiIAAFuwWGNlLCAmFJxCG5tADMwJDMwR/LsIAEwCUbD0uwgABhBgMFhjXRqcV/pkLSCJ +EEgw+WQsIAIQaDAtZDj9ZDkgBRBwMP5kNSABEEAw+GQzIAQQeDD/ZDEgEBBAMPhkLiAAEHgw/2Qw +IAAQcDAuZDQsICYbmyYMzAkMzBH8uwgAdAJRsPS7CAAGEGAwWGNDwOT+ZEAgAxBoMC1kQScgJhub +Gwd8CQzMEfy7CAAwAlBw9LsIAAYQYDBYYziIFgBEBIkX+EwUAAUQIDD8FgYgUBBYMPsUGCCIAlGw ++YgYAAgQYDD4Fgcu6AFEMPMUHy4JAD/w/xQeIDACWHBYYyePJ/76wCBAAnvw9FY5LgBAc/Dz9QQg +gAJzsJ7wnvErIBYtCv99sQ76ICYgLBBgMFtTMcAg0Q/AINEPAIgiZIBRH5wTiSf+IgAgBBBAMPgW +Ai/AEGgw/xYAIAEQeDD47hEAQAJScP2tAQ4JAHuw/hYBIIACa3Cdmf2WCCIAAFhw85UUIAEQYDBb +TzHAINEPAAAAACtMGPosAAIAAGCwW1OJY/+ciSJln5crICbaIPu8EiIAAGCwW1ODY/+EAGwQCPws +AAIAADFw+XwAAIoANSAbnLnynLkQABBQMPYWAi/vEDgw/BYBL/sQKDD5FgAv/RB4MG0IISkwACgw +AfiRSWoAIFIwaJI2aJQoaJUXaJoK84MKCgAgIpBj/9eTFPP/72oAQBbwJvrfBrsB8//hYgAAMPAH +uwHz/9ZiAABg8AW7AfP/y2IAAGjwD7sB8//AYgAAcPDIssAh0Q+IESiAJhKcmAiICQyIEagiIiJ/ +ZCG48+ADIAYQWDDwAAtgABBwMAAAgilkIaEvIgf3CgAgABAoMP/yDiAAECAw/xYDIAAQeDBtuhSi +6vqgQCoAIG+wK7AC/uwBLgCZ0tD+CgAgCBBYMG26FKLq+qA4KgAgZ7ArsAT+7AEuAJHS0P4KACAI +EFgwbboUour6oEgqACA3sCuwCP7sAS4AidLQ+goAIAMQWDBtuhSiq/uwUC4AIDKwLuAF+qwBLgCB +25AuIDQPAgAPAgBz4QIjJDT/CEcAABBwMPsKBi9NALYgBAlHZZ9CBQpHyKwqLEj8CgggEAJZsFhi +kwcLR8m1tWv8CgMgoAJQsFhijo0TLNEZscws1RmNFC3QA/8CAAIAYH9QixQqsAQtsAX8sAYrgAQ6 +oA2qAvuwByuABDqgDKoC/iA2K4AEOqD7qgID6BBYMAuqLHrhJYsS+iQ2IABUetCNEyzRGP4SACAC +AmMwLNUYjSD95gAgABAQMNEPjhCNIP3mACAAEBAw0Q8AAAAAAAD/+v8r/2bekPP+xWABEHgw9Pr/ +K/9u3pDz/tVgARAgMPX6/yv/dt6Q8/7lYAEQKDD3+v8r/3720PP+9WABEDgwghDH//8mACAAEBAw +0Q/aIFrxgsCQKSQ2iRMokDb+EgAgAgJCMCiUNo0g/eYAIAAQEDDRD9ogWvF5LiA2G5ogHJoeHZwW +/rsoAgAAULBa8ZPaIFrxdmP/N2wQCpYYKCAE+iBTICgQWDD8IAciAAAgsP2a8RIAAHFw+q8JAAAQ +KDD8DEEPwAQ/4P8gBSwAIH9w/dJ/IAFWBiD4CiUmAVdf0PYKACYBU0fQKyAWKQr//BYKICwESvCd +GQDOjltSW4wa/RIJIxEANqAYmm0MxxGodyhyOv8CAAQBT0YgI3I5GZniZDKQHppn8AkHAgAASPAA +SWEASWEASWEASWEASWEsIQcMDEoMzBH7IRksCQBzMJww+iIAIEAQSDD5NgMoSAFoMPmaWRAFEGAw ++TYCK4AEOqD73BQKCQBisPo2ASmABDog+poDHsABaDD5QCYuCQBDsPY1CiAwEEAwKDULljiWOZY6 +JjYLljwmNg32Ng4uBwFsMPY2Dy9QBD/g9jYQLUAEOyD2NhEsCQB7MP6a9BwJAHMwJjYS9jYTK0AE +PuDwmREKCQB28Ps2BigJAGZw+pkCAEACUPD5NgQhlwA1YPwKBiCAAllwWGHrLEAmFZrIG5nGDMwJ +DMwR/LsIAEwCUPD1uwgABhBgMFhh4x6a3RuZsvs0NyAAEFAw+jQ0IBAQQDD4NC4giRB4MC80LP40 +LSACEGgwLTQ5/TQ4IAEQSDApNDP5NDEggBBgMPw0NiAGEGAw/DQ1IAAQSDApNDAtQCYbmaoN3QkM +3RGtu/W7CAB0AlDwWGHIwOP+NEEgBBBoMC00QCRAJhuZoARMCQzMEfy7CAAwAlBw9bsIAAYQYDBY +Yb2IFgBEBIkX+EwUAAYQKDD8FgYgUBBYMPsUGCCIAlDw+YgYAAgQYDD4Fgcu6AFEMPYUHy4JACfw +/xQeIDACWHBYYaz1NEwgARBQMCo0TYgnG5t0iI77NE8gCBBIMCk0ToqAiYEvgQ0qrDT6hgAgAgJK +cPmGASACAnvwL4UNwOUudjkrIBYtCv99sQr6IFMgMBBgMFtRrownLfrA+8wgICgQcDD+JAUqAEBu +8PbFFCCAAlrwm8n7xgggABAQMNEPAIQo8/1SYgAAKLDAINEPAAAZm1X/kQIgIAJAcC+FAvmSACAG +EGAw+YYAIgAAWjBYYYFj/lMAiiJkoEmJGI0nGJp5jyD4FgAvwBBwMPkWAiABEEAw+P8RAEACU3D+ +rgEOCQBH8P8WASCAAnOwntn+1ggiAABYcPbVFCABEGAwW02ZwCDRDyvMGPosAAIAAGCwW1HzY/+k +iiJlr58rIFPaIPu8EiIAAGCwW1HtY/+MAAAAbBAa+JoCHgAQSDD5FgAgABAgMPQWASAVEEgw8AgX +ABACQHDTD22aAgAIii0QAi8QASUQAPiaSBAIAnBwKuACLOABmBKIICQUGyMUOCQUOSQUOiQUO/7g +ACP/EFgw+xUMIAQQSDD5FCAgQgJYcPq0AiALEEgw/LQBIHgCUHD+tAAgSgJwcPXkACAQEGAw/+QB +KYAEOiD95AIoCQBKMPgWAyCoAliwWGE3KhxM/AoIIIACWLBYYTQqHFT8CgggcAJYsFhhMCocfPwK +CCDIAliwWGEt+Zj9ECAQQDD4FDwgURB4MPgUPSBuBHjwKRUgJBRcJBRsJBSMLiII+xwIIgAAULD+ +4RkgCxBgMP4lKSACEGgwWAQrLworLyQFBgAAKBAgwJIJiAIoFCBj/8EAbBAEwHBtShSjdPRAACgA +IBHwKIAA9IkLcAICOfDAINEPAAAA9IMIf/8QEDDAIdEP0Q8AAGwQNCcyBBKZt/aYwhZwATwwB3cJ +DHcR/mJ4IgAgOLAtLQIt0AAqYoAnIn8O3Qj53REAARBgMP2qCAIAAFnwWEcUJCKD9awAAIAANSAr +MEwsME0IuxH8uwIAABAQMIxKyc+Ky8mhbQgJLaE2e9EHiqvIpGP/7wDSoMwtLMIJ0w9lz97MI4RJ +ZU/TGpjEiC0mooP+mLkZkAQ6IPuY4hYAIEGwhGiNZykwVIxHjd4tFluMzvwWWiAAEGgw/JqnEABv +hmBokg7RDwAA8/+9YAAQEDAAAADAxvpsbCDKEFgw+hZYKgAgXPBYYM/7PD0gkAJRsPoWWSADEGAw +WGDKLDEvbs8KHZqW/wIACgD0Y1DAlyoxLi8wmPrLQAABEHAw++k4CgUBUDD/eEAIBQBXsPjpOA4D +AXwwD+k4ZJHSi0p2uSguElst4DIv4DMI3REP3QKx3S3kMw2NFC3kMi0SWizQObHMLNQ5YAAnACgS +Wy+ANCmANQj/EQn/Ai/8AS+ENQ+PFC+ENC8SWi7wOi7sAS70OgZqAlgMH9ogW0au0Q+ISnaJHi8S +WynwNijwNwiZEQiZArGZKfQ3CYkUKfQ2YAAbAAAoElsvgDgpgDkI/xEJ/wKx/y+EOQ+PFC+EOC8w +Wf8CAAQA0QfgwIn/AgAGAIbH0COigxiYSP9QDCCgAkhwnZCdkZ2SnZOdlJ2VnZadlyiCeJ2YnZn9 +lgooACB6MP2WCymQBDog/ZYMIgAgRPAvMS6dnZ2e/ZYPJgBWX9ApUAXCo/8CAAYAT9ZQG5g1Gpg1 +iTAuFhoqFhT4mREABBBQMPsWFigJAFZwKRYVKDAHCAhBAIgRCPgCDogCKBYYD+owLxYZLRYbLlAm +/u8JDAkAY7AsFhz7QgAgAxBwMC4WHfsWHiD+AlBw+5g8EBYCUrD+mTsQBhBgMP0UfS3ABD/g/WIA +KgAgbvD9FiEqACB28FhgVfscUCIAAFDw/AoEIAIQaDBbRT3aIFtGWtEPAAAAAAAA8/4aYAAQSDAr +MFrCyf8CAAYBnWbQ2iBbRlLRDwAamS4ZmGQcmUEYmHAtYgcrYgAognwt0g4tFlb5pj8qCQBm8Pum +PiAEEGAw+5kWEAUQaDD7FlciAABRsAuAAByZHy/CP/+PFAD/EHAwf+BEKRJWKJA6KpA7CIgRCogC +sYgolDsIiBQolDraYFgLpdogW0Y00Q8A2iBbRjKJSv8CAA//rTJQ+mwAAAQQWDBb/sHRDwAAGpgz +H5j4GZf9K6KmKZKDD7sBCbsR+5kaGAAgXnCNnBiX8QvdAQjdAv2WDC+pADZgLBJYKRZdHpjNKFAm +HZfOLRZTCIgJ8A0HCcAEOiD9ElcuACBDsC7gfwBNYQBNYQBNYQBNYRqY5BmYKx2Y7x+Y5PgKBC9A +BDug+NY/KAkATfD5FlEuCQB7sP7VgCIAAFsw+dY+IAYQYDBYX/oYmCcnEl0ogl37ElciAABRcPwK +BCAFEGgwC4AAHJjcLsI/Do5HZOV7/wIACgK8A6AuFlQfmF4YmJwtZT+dGy0WUvpgfCAAEFgwmxib +GZsa+xYNIAEQSDCZFCkWDAqpCf1hKSnABD5g+hYFKAAgSjAogn/4FlUmAvh/UB+YTf0WUC4JAH9w +KRJVLxYH+QhGCkgBSDD5qhEIBwFMMPCZEQgJAFIw+xxAKAkASjD4FgYgIAJQcFtETGShb8Cl/Jma +EDIQWDBYZzIqElRkoaUsElsrwDwtwD0IuxENuwIrvAErxD0LixT7xDwiAABRsFgLORyXnB2XeS9Q +DP4KACCgAkBwLoYALoYBnoKeg56EnoWehp6HnoieiS3SeJ6KLMKD/oYLLAAgf3D+hgwtkAQ/YP2X +rhwAIGswL8Euno2ejv6GDyYAW2/QLVAFwuP/AgAGAFT3UBqXeh2XYytyAB6XYS4WFi0WFPi7EQAE +EGgw+hYaKgkAbvArFhUpwAcJCUEAmREJ+QIKmQIpFhgI6jAfmWT4FhkgABBwMC4WGyxQJvzNCQwJ +AHswLBYcK0IAKxYeG5dr+hx/LcAEP2D+FH0gAxBwMP2YZxoAIG7w/hYdIBYCUrD/YgAgBhBgMP8W +ISoAIG7wWF+B+xxQIgAAUfD8CgQgAhBoMFtEadogW0WG0Q8A2iBbRYSOSnbpEvpsAAAEEFgwW/4U +0Q8AAAAAAAD6bAAAURBYMFv+D9EPLRJQLhJVHJk+L2B8+BJSIAUQUDD4FgAgMhBYMFhm0RyZOf0S +ECAFEFAw/hIRIDIQWDBYZswqEhApElQrEhErZhP6ZFAuXgC2YByXOx2XGC9QDP4KACCgAkBwnoCe +gZ6CnoOehJ6Fnoaeh56Inokt0nieiizCg/6GCywAIH9w/oYMLZAEP2D9l04cACBrMC/BLp6NLoYO +/oYPJgBeb9AuUAUoCiP/AgAGAFdHkBqXGR2XAytyAB6XAC4WFi0WFPi7EQAEEGgw+hYaKgkAbvAr +FhUpwAcJCUEAmREJ+QIKmQIpFhgP6jAemQP/FhkgABBAMCgWGyxQJvzNCQwJAHMwLBYc/kIAIAEQ +WDArFH0blwn6HH8gAxB4MP4WHi3ABD9g/ZgFGgAgbvD/Fh0gFgJSsPliACAGEGAw+RYhKgAgbvBY +Xx/7HFAiAABR8PwKBCACEGgwW0QHLkA2ye/aQFruQi5ANhuW6RyW5x2Y3/67KAIAAFEwWu5c2kBa +7j8qfDT8Cggg4AJY8FhfDSp8PPwKCCDQAljwWF8KKnxc/AoIILgCWPBYXwb8Mhkg0AJR8Px2GSCY +EFgw0w/8ChAqACBc8Fhe/ys8QfwKAyCcAlHwWF78jUoucAX+dDAgKAgzcMCM+HRUIDYQeDAvdAVg +AA0qCg76dFQgNxBIMCl0BQd6AlgQTgIqAltE+RuX7RyWvv2X7RIAAFGwWu402mBa7haLSg8CAHa5 +FIJpZCAP+iwAAFEQWDBb/YGCKWUv7/uYphIAAFGwW/peHJeA+doAIP4CQHD5FiQgMgJCMPAMFwAV +EEgwbZoCAAiKKxJZ+ZfMEAMQYDD5FiYg/gJQcP1iACABEEAw+BSwI/8QeDD/FVQgCxBwMPjdEQAA +EHgw/xSrLAkAd3D9FicgZAJSsFhexR6XrfiW8BAAEGgwLRTL/RTKIP4CUHD9FMkgAxBgMPwUzyBi +EFgw+xTIICICYrArwAEpwAL4gnwgbAJSsCmkAiukARmXsSzAACykAI9gImIHKxJX+ZbOHgkAT/Dy +Ig4gBRBoMP/mPiIAAFGw+eY/IAQQYDALgAAfl5Av8j//jxQA/xBwMP8CAAgAh3uQGJa0GZd4EpZ+ +KIKmIiKDCYgBCYgR+pebEgAgQLCILBmXnAqIAQmIAvgmDCD+ALSg+5hnEgAAUbBb+hPCnClkBdEP +LcGA+ioALSABbDD/AgAL/T7qkCwSUS4SUykSVy0WXAAOiwBJYQBJYQBJYQBJYRqXbhmXZimmPyym +Pixgbi5gbC9gbyhgcClgbS1gcfiIEQ8ABD/g+JkRDwAEO6D57gIOCQBH8P/dAgwJAHMwDcwDDM0U +DcwDDG0U/cwDAAEQWDD8DEUAABBQMFhn6h6XVxiWmtmgKeZA+IJdIAQQYDD75kEgBRBoMPsSVyIA +AFFwC4AAHJdNLsI/LRJc8/nObugBcDAtFlBj+hgvIDooIDsI/xEI/wKx/y8kOw+PFC8kOmP/CwAA +AAAAAPosTiD+Alhw+7wRIAMQYDBYXlLaIPscfyALEGAw+7wZIAIQaDBYAVzDyCwkBWP+1QAAAABs +EAYYmBx4UQLRDwD6LAACAABY8PxMAAIAAGlw/mwAAgAAeHBb+0hlr96NEBqW1fcKJCABEGAw+dgR +AABcg2AjooaoM443ju6J5SsKI/riBCACAmpw/eYFKgADy1AqrAGa5CkgBSw0N/uRnXAmEGAwKjAF +fKECd6mPjjf14g4vwBB4MPc0BSBAAmuw/woALABAf3D/5RQggAJrcJ3p/eYIIgAAUPBa7UooURKE +OrGI+FUSIBEANSDCXSlABXWRJYRJZU/0+iwAAAAQWDD8CgAgABBoMFv6YIs3i74qsQ6xqiq1DtEP +2kBYA+KESWVPyWP/0QAA+iwAAAAQWDD8CgAgABBoMFv6VBqWniqiiyyhAmTO9VtCthuVwRyVv/qW +mRIAAHqwHpYULMJuKqKGje+vzPALBw2QBDsg/dwBKgAgYrD95g8gQAJKsABJYQBJYQBJYQBJYQBJ +YQBJYZoRKCAWGZaiLCEHLSANLiAM/qQMIAEQeDAvpAQuICYtpA0vIAcdl7UO6wn8pQcrwAQ+4P6k +UygAIF5wKZJ/KaYVL6QHLqRTkqj9pRYiAABhMPikFiIAAFjwW/nQHZa6LCAmG5W3gxEMzAn0lesd +wAQ7IPy7CACwAlDw/bsIAAYQYDBYXdKKSy2hAsjbW0KBjkwCrxGv7i42GCogJhmWfAqqCQyqEaqZ +KpKDZKBlianImfmSCSIAAFJwZZ/0k6klNRf3NAUgABBYMJs5+zYKLd8ANOCMN4zOjcX6wgQgAgJb +cPY1GSoADmrQLcEO+8YFIAICcrD+xgQgAgJrcC3FDtEPL8EOm8X6xgQgAgJ78C/FDtEPI5aDY/+k +bBAmGJeA+FEJcAAQUDDAIdEPANsw/EwAAgAAaXD6FgQiAABx8PosAAAgAnhwW/qpZa/aihT2lk4Q +JRBYMPmlEQGaADqgI2JopTONN43eLNEMscws1QwrNAUpYX/0CgAgBBAoMPIyCiAAlnZQZCEqGJYz +9BYXLgAQSDD5FhYgFRBIMPAIFwDAAkBwbZoCAAiK/JZ9ELgCUHApoAL/oAEgsAJAcC6AAiaAASwW +GI0gJRSQJBRzJBSRJBSSJBSTKIAA+qAAIPICGHD1FHgj/xBYMPsVOCAQEGAw/zQBIKgCWLD5NAIg ++gJ4cPo0ACD+AlBw9vQBLYAEP2D+9AIgCxAYMPj0ACwJAB9w/RYZICoCUrBYXWj7LEAg/gJQcPqs +JSAIEGAwWF1k+yw4IP4CUHD6rC0gCBBgMFhdX/ssZCD+AlBw+qxVIAgQYDBYXVokFOQkFMT0FLQg +IBBAMCgUlSgUlI4o/5UlEgAAULD/FUwgwAJYcP7hGSALEGAw/iUpIAIQaDABEQJYAFrCm/kkBSAA +EBAw0Q/AINEPAAAbliEalQLwCgcCAABK8ABJYQBJYQBJYQBJYR2XFYkwGJVrEpVRHpVcKIJ7/iad +IgAAUPD0Jp4iAABhcPQmnygJAG5w+SacIAUQaDALgAAqIp36ihQA/xBIMHqQFIw3jM4rwDexu/vE +NyAAEBAw0Q8AAJQclB2UHiQWERuVmRiV/yMinheV1SJiaPgzAQABEDAw9hYII5AEPOD2FhAiACAY +sCogfCYhKSkhPwqoCfoWCSnABDog+RYPJgAgRfAjcn8nfQL3cQQgFARZsBuVhQtrAiocIPMMRg5I +ARgw831AD5AEO6Dw3REMCQBzMPsWCywJAGsw/BYKIKACWHBbQYbJoMCl/JbUEDIQWDBYZGxj/cMA +AN1g/JbREgAAcPD/IHwgBRBQMPcWACAyEFgwWGRkHJbL/RIUIAUQUDD+EhUgMhBYMFhkXi8SFCgS +FSgmEy8kUGP9fwBsEBCTEpQUlROLMCwgBy0wE/0WDiADEDAwlhv2MBgsIAFgMPwWDyrgAVwwKxYQ +9LKWZgIBNDB9ZwcoCsCYEGAABygSECiMTJgQJYwfBUUUKCAEa4YH/wIABAJhiiArIBYmCv/TD3ax +H4YTBgZH/Gz+IAEQQDD6IEEsBQBiMFtM/v8CAAAE76qghB/5lRAQBxBAMJgc+JSJFcAEOSD0ckxk +ACBJMC1COv8CAAoCLK9QJ0I5ZHRO8AgHAgAAQfBtWQIASGEoIQcZlQIICEoMiBH8Eg4oCQBKMJhw +LyIALhIA+JT+EgAAULD+dgMvgAQ/4Ph2Ai4JAH1w/3YBIgAAWPBbHh4tISIrIEEclI2PLRaUaSzC +gykwGPZieC+QBD/g+7oJDgAgZ/CfGf/yCCgBAUwwmRoZlVQu8Az/8gcrwAQ6oPggBSgAIFZw+ZJ/ +IFAQUDD/8g4uACAzsP8WDS+QBDug/gpOLAAgczD8FgggGARSMH6BBMXyLyQF9NwRDsABSDD5f0AK +SAFIMP3YFAmABD6g+pSEGUAEOiD1/xEOCQBLsPuVgxkABD7g+AoALgkAR/D4dQouCQB7sPgKsCgJ +AHZw+HULKAkAVnD6fCAqCQBfMPt2BiAGEGAw+XYEIJACWLBYXHgsIEEdlVUblFMMzAkMzBH8uwgA +TAJR8P27CAAGEGAwWFxwGpVq/pRAEIkQSDD5dCwguAJYsP50NyCAEGgw/XQ2IBgQYDD6dC0gAhB4 +MP90MSABEEAw+HQzIAAQeDD/dDAgEBBAMPh0LiB4AlHwWFxcKnxU/BIQIGACWPBYXFnAkvl0NSAA +EEgwKXQ0KDAw/wIABAGlgiD4FhIkA6WGIMWh/wIABgGjVhCMHY7Bi8D+7AEgtBBoMP7GASoAIG7w +m8D1RjkkAXiGICsgFi8K/3+xMywSEPogQSB4AmMwW0xXwCDRDwAA8/2DYAgQKDCOEi7hCC86/3/h +DIsS/BIEIgAAULBYGOrAINEPL0I6/wIACgNer9AnQjlkdrLwCAcCAABB8G1ZAgBIYdog/BIOIgAA +WPBbHZgqIQcblG0KCkoMqhELqgKacI8gCP8R+CEiLgkAfXCfcf0gQSBAAnHwnhcflND92QkAkAJg +sP48MCnABD5g/xIQKAAgfnD4FgYguAJYsPggBSB4AlHw9PKhbQAEP2CGEB+UWJ9y9nYDIFAQeDD5 +kn8gJgR6MMRudoEJxfb/AgAOA3v6EIYWJBYUIxYT+YhCAsABTDD5EhAkBwFIMPVEEQmABDog9t8U +AgkARPD4lasfQAQ/4PRmEQQJAHkw/5WhEHgCSnD4EgcmCQBBsCl1C/SVmxIJACTw/3YHIAAQeDD/ +dQoiCQAfcPZ2BiIJACTwk3QIDIYASGn5ISogABBAMCh0MP90LyAAEBgw83QuIAAQIDAkdDUkdDb0 +dDcgABAwMCZ0MSZ0MiZ0Myl0LfmJFAAAEDAwJnQ0KXQsJCBXJHQ7BIQUJHQ6BIQUJHQ5BIQUJHQ4 +JBIUL7AAI7ABI6QBL6QAIxITKbACKLAD+KQDIMACQLD5pAIggAJJ8AIIiABJigAIiAAJiigiHCwS +ECh0UwiIFCh0UgiIFCh0UfiIFACoAlHw+HRQIgAAW7BYW8ArEhD6IHQqACBd8Cq0WIke9UY5IgJZ +BmAoMBLTD9MPZIUxG5OJHJP2HZSn+4soAgAAULBa6vzaIFrq32P9pwCMImTFI4sSjBT9EgMiAABQ +sFtJYNKg0Q+NEtog/hIDIAgCWHD90QgiAABjcFs06y0KiP8CAAf+y26QjBFkzaSKx4sS/BIEIEAC +UrBbR8mMEY7AjRQI7hEO3QKdoSsgBNag86wABAJsguD6LAACAABZsFs0HfwSASQsADag/RIDIgAA +WbD8EgQiAABTMFgXQcAg0Q8AFpVhjy7/AgAP/oUz0IgYiIL/AgAB/n9+EPoSCCABEFgwWuogY/zr +AIodKaEUsZkppRRgAAxohO+LHSqxFrGqKrUWihr+EgwgAhB4MP90yCAIEEgw/3TJICQQaDD9dDkg +JhBgMPx0NSAAEFgw+3Q0LgUAUnAudDhj/HgWlUOWcvaTSRBEEHgwn3OPLSZigwn/Ea9mhmcuFhEp +kn/2Yg4gUBB4MPYWBSAyBHowxP7+FhEgHgR6MP4WESBSEEAwKCQFhhYJj0L5CEYPgAQ/4PbeFAgH +AUww9ZkRD0AEO6D/iAIICQB2cPmU9RgJAEow/pT6GAkAQ3D5lPIYCQBKMJh0/zINIAAQQDD4dQot +QAQ9oPl2BywJAHdw/XYGIHgCe/AvdQuPFybAAS7AAC70ACb0AS3AAynAAin0Ai30AyjABSbABCb0 +BCj0BS7ABy3ABi30Bi70BynACSjACCj0CCn0CSbACy7ACi70Cib0Cy0hKi10LQ2NFC10LCwgVyYS +ESx0OwyMFCx0OgyMFCx0OQyMFPx0OCAYEGAwWFsk22D8ChAgsAJR8FhbIYgVHJNl/HYaIAgQaDAt +dhsrIHQrdHQblPElRjmNLipyF8CQ+qxAJgCMX1AekvQu4oMJ3xGv7o7nju4m4AIv4AEt4AAk4AQl +4AX74AYtgAQ/YPhEEQwJAH9w/+ADJAkAKTD14AclgAQ5IPjdEQQJAFkw9t0CBYAEOSD43REECQAp +MPSkCAwJAH9w+ksGfAAgbnCx3SXgCS/gDCTkBy3kAwSLFA2GFCbkAivkBi3gCCTgDQuLFAaGFCbk +ASvkBQaGFPuLFA+ABD/g++QELgkAJ/D04A8tgAQ/YPXgDiwJAC9wJuQA9uAKL4AEP+D43REOCQAv +8PXgCy+ABD/g9t0CDgkAJ/D0/AEtgAQ/YPXdAgoAA3kQsd0k5A8t5AsNjBQEjxQv5A4s5AoPjxQM +jBQs5Akv5A0MjBQPjxQv5Aws5AgsgAIrgAEmgAAtgAQugAX/gAYngAQ5oPjdEQYJAFmw+4ADLAkA +d3D+gActgAQ/YPhmEQwJAH9w/GYCDYAEP2D4ZhEMCQB3cP2tCAYJAFmw+tsGeAAgNnCxmS2EByaA +DiqACS+ADS6ADCmEAwmLFA2MFCyEBiuEAimACAuLFAyMFCyEBfuEAS+ABDug/4APLgkAe7ALixQM +jBT8hAQvgAQ7oPuEACmABD5g+4AKKAkAVnD6gAsuCQAzsPiZEQ+ABDug/+4CCAkAXnD4mREAAgJr +sPqZAgoAA3NQsZkthA8phAuOHgmPFA2KFCqEDi+ECgqKFA+PFC+ECSqEDQ+PFAqKFCqEDP+ECCP9 +qx+gKyAFxcb/AgAH/Kpm0NogW0CVwCDRDwAAAAAAAADz9rFiAAATMI0iZdtTix/aIPu8GCIAAGCw +W0sKY/tBAI0dLNETKnxm+xIJIAICYzD81RMgAhBIMPl0ZCAJEEAw+XRlIAsQeDD/dDkgDRBwMP50 +NSAAEGgw/XQ0INgCWvD4dDggBhBgMFhabCgSEmP4cY4eixvA0v7bOAIAAFCwWA/EY/h9ix/aIPu8 +GCIAAGCwW0rsY/rJAAAAKqwZ/AoDIKICWLBYWl0qbB38CgMgnAJYsFhaWowRY/sJaWIOiifbMPwS +BCBAAlKwW0aAiyJluG0rIEHaIPu8EiIAAGCwW0rZwCDRD8XyLyQFY/kEAABsEASKOowp+CIMIBII +ULCcOmAAGsmli6nTDw8CAHKxDPq8AAAJADbgi7lyufKcqfoiDSAAEGAwnCr8JgsgMBBIMPwmCSAL +ADYgKSQF0Q8AAGWv9RqSnfsiACArEGgwLSQFLqJ0KqKL/rsMAAEQaDBbQqzRD2wQBigKK/gkBSIA +AFCwWulUgywWklcUkxr3ClAgbwA04Pc0BSIAAFDwWulNiz0qYogJuxGrqoqqyaQrrGD8CgQiAABQ +cFhaHIoQYAAHAAAAGpKsmhAdkwksOugMrCwNzCj8FgAiAABQ8FrpPfsSACIAAGkw/JJREgAAUPBa +6VgDOgJa6TuDO2U/loMs+yINIBYANOBlsLyTLWAABQAAk7ubPMDgniyDKskzw74qMAX1MgggJARa +sPNcAA/xALVgwLCbKtEP2jBa6SaEOvsKPiB0ADUg90QFIgAAUTBa6SCLTSpiiAm7EauqiqpkoBIr +rGD6HAQgBBBgMFhZ74oRYAAEGpJ/mhEdkt0sOugMrCwNzCj8FgEiAABRMFrpEYsRHJIm/ZLXEgAA +UTBa6S3aQFrpEIRLDwIADwIA+wo+L5YAtSCEOvwyCyAqADUgz8aUO2AAGgCJu2SfRG0ICvmSCyIA +AFpwZJ82Y//ulMucTMDQnTqOOcDw/zYIICgAN6DEgig0BWP/MInLDwIADwIAZJ/YbQgK+ZILIgAA +YnBkn8pj/+6JO2Wf1vsyACA/EHgwLzQFLmJ0+mKLIAAQYDD+uwwAARBoMFtCORmRz4iesIiYnvP+ +4mA+EFgwAAAAbBAQKCAFhSjCrfRSCCYBi9YQiScqJAX8+sAgQAJacPy7AQAAEDAw9pUUIIACUvCa +mfqWCCIAAFCwWujSF5JX/AoEIPoANOAdkaUpQAwjcmj4cmAgIAJwcJbgluGW4pbjluSW5ZbmlueW +6Jbp9uYKKAAgSjD25gspkAQ6IPbmDCIAIETwKjEulu2W7vbmDyYAV26QK0AFwtP/AgAGAFDu0B2R +ZB+RTY4wGJFLmBYvFgT47hEABBB4MP0WCi4JAHuwLhYFLDAHDAxBAMwRDKwCDcwC/BYIIAMQeDAL +6jAak0wrFgkmFgspQCYdklobkVn5ngkICQBWcCkWDChSAP8WDSAGEGAw+BYOIJQCUHD2FD0vwAQ7 +oP4iACoAIHbw/hYRKgAgbvBYWW37HBAiAABQ8PwKBCACEGgwWz5VwMQTkkIYkSQtUhWEWPAIBwIA +AEjwAElhAElhAElhAElhHpJJGZGD/5M2EBQCUPD/5YAg2AJYsPzmPygJAE9w+eY+IAYQYDBYWVYY +kYIogl36TAACAABY8PwKBCAFEGgwC4AAgyrJPPAAD2A+ECAwAADaMFu1goM4yDkpMAV0mfCDOGU/ +9IMrZDEy/pHzEFYQMDD+FhUgThAoMIk3L5kUKjAF9JIJICcAN+B2oSf/AgAGAGoukPU0BSIAAFDw +WuhiKHF/focWzUZgALkAAPP/2WAAECAw2jBbPz1gAKdkQKQsEhWNQ4lAikEvMQiOQv8WFyAgEEAw +AIAE/g4bCuABUDD6FhQo+AFMMCkWFoow+hYAIDIQWDD5FgEgBRBQMFhgiStxfyoSF/w6/yCoAHbw +/RIWIMQEYrBo1ipkQEf8EhQiAABZMP8KhCIAAFDw/0UIIAEQcDD+NBUgABBoMFgUxWAAIQAALRIU +ijfAwPvcAABAAlKwW0H68/+/YgAAIrArOv97oQ+DO2U/D4Mr8AAtYAAQMDAAjTf++sAgQAJjcP4K +ACwAQHMw/tUUIIACYzCc2ZzYY//OAAAAAAAAAPsiDCApADTgyrQpsgsPAgAPAgDInm0ICfmSCyIA +AFpwyJFj/++Tu5s8livRD9EPAJMslivRDwAAbBAEiScr+sDzkg4gQAJScPsKJioAQFqw+yQFIIAC +UrCamfqWCCAAEEAw+JUUIgAAULBa6AgsMRGCKrHM/DURIC0ANKDwABhgLRAYMAAAAAD6LAAAARBY +MFv/HSIiCcgrLSAFc9npgillL/TRD9EPAGwQGhiRcCkKFfAIFwIAAEBwbZoCAAiKHZKiHJKiBNw5 +LBYAiyD5Ov8gARBQMPkVCCALEGAw+hQYK4AEPuD6HBkqCQBm8PsWASADEGAw/BQTIKICWPBYWLkr +PE78CgMgOgJQcFhYtioKACoUMSoUMvoUMyACEFgw+xQwIGYANSAfkYIoIg36FiogAxBgMP/yfyBw +AnBw+hQzIP4CSHD6FDIpkAQ6IPsUMC4AIEfw+hQxIHACW/DzCxYAgAJQcPJaHgCAAkPw8QgWAJAC +W/DyHh4AUgJScFhYmSgSKgiIFCgWEvosAAIAAFhw/AoLIAIQaDBb+6HRDwAAbBAaGJEyKQoV8AgX +AgAAQHBtmgIACIobkmb7FgAgARAoMPoiACADEGAw/BQTI/8QSDD5FQggCxBYMPUUGCuABDqg+6oC +AKICWPD6FgEgMgJQcFhYfCocHfwKAyCcAljwWFh4+woIIBAQeDD/FDEgABBwMP4UMiAUEGgw/RQz +IAIQYDD8FDAgGQA1IChAAClAAv8CAAgAYYIgKxQ2YAAOAIk8CQpQC6oRBaoCKhQ2FZEULVF/+xQ0 +IBIQeDD81AEAIhBwMPQKVi4FACPw/hYQLgA4Z1AoIAX/AgAGAI6mECQkBSowBcOZ+ak9cAcQWDAr +UX/+tzdwPRBoMCwgBXTJLIstKlJoCbsRq6qKqmSgq/usYCD+AlBw+qwpIAQQYDBYWEkqEipgAJgr +NFTRDyo0MP00BSAHEGAwLDRU0Q8AAAD6LAACAABYcPwKCyACEGgwW/tLY/+LAAD5ekAD/57iUPlt +QAP/muZQjkN75xP/AgAB/5RrkBiSDy8xGQj/AS81GRaRai41GYQ89pCWFABAMTAOqBAIRAL2kggU +AEAxMA/YEPlfQAQJAEEw8P8RCABANTAPmQKZPGP+5wAakLQqFioZkREoOugIqCwJiCj4FioiAABQ +sFrnRSsSKhyQWv2RCxIAAFCwWudh2iBa50TAlyk0VNEPAAAA+iwAAgAAWHD8CgsgTxBwMP4kBSAC +EGgwW/sbY/7LAABsEBoYkKwpChXwCBcCAABAcG2aAgAIihuQ+fsWACABEDAw+iIAIAMQYDD8FBMj +/xBIMPkVCCALEFgw9hQYK4AEOqD7qgIAogJY8PoWASAyAlBwWFf2Khwd/AoDIJwCWPBYV/LAUPUU +MSBoAlBw9RQyIAIQYDD8FDAgqAJZMPUUMyAQEGAwWFfpKhxE/AoIIIACWTBYV+YqHEz8CgggcAJZ +MFhX4itMZPwKCCDoAlBwWFffwoAoFDQoFDUvMhkvFhD2FUAiAABQsPUUVCIAAFhw9RRkIAsQYDD1 +FIQg/xBwMP4VPiACEGgwW/rfKjAF+jQwIDkQSDApNAXRDwBsEBoYkG3/kMEQCxBYMPwKAyAVEEgw +8AgXAgAAQHBtmgIACIqfEIogLTr//RUIIAEQcDD+FBgrgAQ6oPwUEyoJAFqwmhEpMAQnHB36HBkk +mgA+YCs8UVhXttpw/AoDIJwCWPBYV7P1FDUiAABQsPYUNiABEEgw+RQwIAAQQDD4FDEiAABYcPgU +MiALEGAw+BQzIAIQaDBb+rXRDwArPEhYV6TacPwKAyAKAlkwWFegY/+zAABsEDIckXwswn/6kG8c +ABBoMPtcAA/AEHAw9cxUIgAASzBtSQUAA4YASWEqon+JJ50QHZFo9iINILACOzD0Ig4gQAJCcPPM +PC4AQHYw//xAJ5AEOaD6ZggGAFRtEAlEEaSkjUeI3v+WCSA5EFAw/5YIIAAQaDD9lRQgnAA1ICnA +VMLQ/go/LABlImD7Cj0sAI/LUC6AVC+AVfWAVi+ABDugD+4C/4BXL4AEO6AF7gII7hEP7gKx7i6E +Vw6OFC6EVg6OFC6EVQ6OFC6EVChABfUKOiYDnlYQ/wIABgQZrhD/AgAGAoDeENog+0wAAgAAYPD9 +CgkgHhBwMFv/lNEPAAAA+goALgBAdjD6lRQggAJ78J+ZL5YIym8owFT/AgACAtUGIGiFb/sKYSwC +5gIg+4lkcCwQYDAoYAX9Ci8mANlmEP8CAAYA1W4Q0Q8AAAAAAAD/AgAEAIImYP8CAAYBCopgKYBY +KoBZCJkRCpkCsZkphFkJiRQphFgoQAX4jMogDhBwMP8CAAoCIvIQGpEbCooKiqAKoADaIPtsAAIA +AGDw/QoJIAAQcDBb/2nRDwDFcvUKOywAr7pQ/wIADAEXydAtgGAugGEPAgD/gGItgAQ/YA7dAv6A +Yy2ABD9gD90CCN0RDt0Csd0thGMNjRQthGINjRQthGENjRQthGAoQAXTD/8CAAwCAkFQ/wIADAH+ +UhAqwhv4CgAv/xAYMPiqEQAIEHAwbeoZrIn5kGQqACAmMCuwNNMPDwIA+bkMcAICQjDwAhJgABBA +MPmzBnIAAEDwwIFkj+pgA8z/AgACAH4eYCuAUCyAUQ8CAP2AUiuABD7gDLsC/IBTK4AEPuANuwII +uxEMuwIrvAErhFMLixQrhFILixQrhFELixQrhFAoQAUPAgD/AgAGA7jWEP8CAAYB7PYQ+kwAAgAA +WfBYArD4rAAE5gA2oAIqAvw8AAIAAFkw+A5HAAcQaDBb/xz7CooiAABRMFgCIQYAAAAAAAAjYgpk +MBYqPE77HAAAAxBgMFgDyWSjciMyCGU/6NogWzzm0Q/CwXyZQC2AWi6AWwjdEQ7dArHdLYRbDY0U +LYRaKEAF/wIABgJZrhD/AgAGAlXeENog+0wAAgAAYPD9CgkgABBwMFv+/tEP2iD7TAACAABg8P0K +CyAAEHAwW/740Q8AAMHifpnhKoBoK4Bp/YBqK4AEOqALqgL7gGsrgAQ6oA2qAgiqEf+OuRoJAFqw ++cEvIAICUrAqhGsKihQqhGoKihQqhGkKihT6hGgmA23+UIVLyF4oUTf/AgAGAS/OEIVbZV/v2iD7 +TAACAABg8P0KByAXEHAwW/7Z0Q8rCmH/AgAP/7PaUCyAZC2AZf6AZi2ABDsgDcwC/YBnLYAEOyAO +zAIIzBENzALzYgogAgJjMCyEZwyMFCyEZgyMFCyEZQyMFPyEZC0TADTgKjxO+xwAAAMQYDBYA3dk +piODOGU/6WP89QAAAAAtCght2hSsifmQXCoAICYwK7A8+IwBLgChytAqFiz4HH8gABBIMPiMMSAD +EFgwDwIADwIADwIAbboU+4AAKgAgInAqoE6xmfiMAS4Aj9LQGY8XKBx/KIw58AkXABUQSDBtmgIA +CIorTFH4kEgQAxBgMPgWLiD+AlBw/SIAIAEQcDD+FNAgAxB4MP8UyyALEHAw/zr/LYAEP2D/FWQs +CQB3cP0WLyCkAlKwWFZf+0xOIP4CUHD6rFYgAxBgMFhWWiodAfuPLBACEEgw+RToIAAQeDAvFOsv +FOovFOkrsn/+Ig0gAxBgMPkU6CD+Amhw/xZYIMACUrD/FOsvkAQ7oP8U6ioAIHbw/xTpIHACQvDz +CBYA8gJ7cPJfHgCAAnLw8Q4WAOICa3DyHR4AkAJa8FhWPS4SWAIqAvwKCyACEGgw/o4UAP4CWHD+ +FkAgcgJa8Fv5RNEPAAAAAAAA+bMGcgAAQPDAgWSOs2AAZHujAcAxZD7cYABZ2iD7TAACAABg8P0K +CSAeEHAwW/5b0Q8AAioC+0wAAgAAYfBb/ZIvcAL/AgAB/YHr0ARKAlgHfgYAAAAAAP8CAAf+Al4Q +2iD7TAACAABg8P0KCSAeEHAwW/5K0Q8AAGRdpv8CAA4A0EoQKVE2KMEu/wIADgDJShArzFn8CgMg +ugJRcFgC9WWhfCpQBSsKVnuhBQVaAls8EgIqAvtMAAAAEGAwW/000Q8AAAAAAAD7GnIiAABQ8FgE +x9EPAAAA+kwAAAMQYDD8RFQiAABZ8FgBuPisAANRADag2iD8PAACAABZMPgORwAHEGgwW/4l+kwA +AAAQWDBYASrRDwAAAPpsAAAEEFgwWAKv9KwAAgcAtqDaIPtsAAIAAGDw/QoJICkQcDBb/hfRDwAA +ANog+2wAAgAAYPD9CgkgHhBwMFv+EdEP/wIAAgGhhuDaIPtMAAIAAGDw/QoJIB4QcDBb/gnRDwIq +AvtMAAAAEGAwW/0CLUAFLwoE/0RUIEMQcDD9RDAgFARzcCgKPyhEBfsKhyIAAFEwWAGf0Q8A2iD7 +TAAAABBgMFv89PpsAAABEFgwW/wJ2mBb+5H7YggiAABRsFv7cdEPANog+0wAAAAQYDBb/OmKaFv8 +zNEPAAAAAAAA+kwAAAMQSDD5RFQiAABZcFgA2tog+0wAAgAAYbBb/aLaQFgHC9EPANog+0wAAgAA +YPD9CgcgFxBwMFv92tEPAPMKOSIAAFCw+0wAAAAQYDBb/NH6QAUgCBBYMCtEVCpEMCNEBdEP2iD7 +TAACAABh8Fv9ByxwAv8CAAIBIOsQjXPyChAh/GfvUB6ONbgY8A4XABUQSDBtmgIACIr6j2kQogJZ +MPoWAiADEGAw/0IAI/8QQDD4FQwgARBIMPkUICALEEAw+P8RAAAQSDD5FBsuCQBH8P8WAyBCAlBw +WFV+Khwl/AoDIJwCWTBYVXryFDkgABB4MP8UOiAIEHAw/hQ8ICAQaDD9FDgiAABRMP0UPiAiEFgw ++xYSIBQQYDD8FDsgEAJYcPwKCyACEGgwW/h4JUQF0Q8AANtwWAEm+KwAAEkANqDaIPw8AAIAAFkw ++A5HAAcQaDBb/ZP6TAAAABBYMFgAmNEP2iD7TAACAABh8Fv8yChwAv8CAAH77WoQ2kBYBrTRDwAA +AAD6TAACAABZcFgAeo1Hjd4p0FAq0FH70FIpgAQ+YAqZAvrQUymABD5gC5kCCJkRCpkCKZwBKdRT +CYkUKdRS+YkUAAMQYDD51FEgCgIY8PmJFAIAAFjw+dRQIJwCUTBYVTv6HQEiAABY8PqsZCADEGAw +WFU2KxJZHI8VGY4zC4sUKxZZiEz5iAEMAAhm0ByPEQyMApxMYAAJAB2M7w2NAi1GDAIqAvtMAAAD +EHAw/kRUIgAAYbBb/RoESgJYBoPRDwD6TAACAABZcFgASgIqAvtMAAIAAGGwW/0SBEoCWAZ6BgAA +AAAAAAAA+kwAAgAAWfBYANb4rAAAfgA2oNog/DwAAgAAWTD4DkcABxBoMFv9Q/pMAAAAEFgwWABI +0Q8AAAAAAADaIPtMAAAAEGAwW/w40Q8A2kBYBmRj/boAAADaIPtMAAAAEGAwW/wxL2B9/wIAA/tj +K+D7GnIiAABQ8FgDxNEPAAAA2iD7TAAAABBgMFv8J9EPKnwQ/AoIIIACWbBYAdz2oFZiAABCsGqh +LPpMAAIAAFlwWAAXAioC+0wAAgAAYbBb/N4oCgP4RFQiAABRMFgGRQYAAAAAANog/DwAAgAAWTD4 +DkcABxBoMFv9E/pMAAAAEFgwWAAY0Q/aIPtMAAIAAGDw/QoOIBkQcDBb/QvRD2wQBCosNPwKCCA4 +AljwWFTSKiw8/AoIICgCWPBYVM4qLFz8CgggEAJY8FhUyyosaPgyBCCIAljw+CYZIBAQYDBYVMXR +DwAAAGwQBBaM8SgiFiViiPmIEQIAAFCw+FUIAgAAWPBb4l3aIFrj5YopyK+Eq9swW75U+kwAD/UA +tSCKKcDQ+yILIBkANqBlsI+aK2AABACau5us/SYJIAAQUDCLWnK5DIopiSiZWmAAJwAAAADJuIy4 +csEUbQgM+8wAAA4ANyCMyHLBBGP/7AAAyLSKKYwonLidKCsgBfskMCA4ALagjSvO3sTjfrFNLmJ0 +iyD6YosgABBgMP67DAABEGgwWz0SGYyoiJ7D//8kBSH+AkIwmJ7RD8SSKSQF0Q+Juw8CAA8CAGSf +am0ICvmSCyIAAFpwZJ9cY//uw68qJAXRDwAAAGwQGviNJh4AEEgw+RYAIAAQIDD0FgEgFRBIMPAI +FwAQAkBw0w9tmgIACIoYjSuYEowg/jr/IAsQaDD+FQwgBBB4MP8UIC2ABDsg9BQbLAkAazCcEysg +BPocISQAQobg/AoDIKICWLBYVGsqHCX8CgMgnAJYsFhUZxONOigiFiMyf/mIEQA/EEgw+SQFIgAg +RPAkFDkkFDr0FDsggAJQcPgKBSCAAljw+BQ4IAgQYDBYVFkrPEj8CgMgCAJQcFhUVYkR+xwIIgAA +ULD5iRQACxBgMPkWDyACEGgwW/dd0Q8A/AoDIJACWLBYVEorEAAtEAH+EAIgSgJgcC7EAi3EAfvE +ACArEFAwKiQF8/+DYgAAGLAAAGwQBCIxAyoxAhSOC/4vL2ABEEAw8kMncAEQKDAnMQImMED3yEAA +ABAQMPdXQAIFAEFw9nZAAgUAOXAGUjjRDykwQPrLQAAHEBAw+lpAAgUAWjD6gjkIBwFMMAmCONEP +AGwQFigKhv8CAAYBvETQKQqH/wIABgG6zNAlIRkXjE8sIAwbjMEtcoD0IhYiAABAcPpyiCAQEEgw +8AsXDAAgazD5RBENkAQ7IPSkCAoAIGKw0w9tmgIACIoejBIqoS72CgAmARr2kBuLzPkiACDhEGAw +LBQY+xYCIAgQYDD7i8gZgAQ+YPsWACgJAGZwmREtIAf7i8QcIAFsMADdEQ2qAguqApoUCOowmBWZ +Gf+M8BBAEHAwLhUPnxgtIFQtFDErIAUrFDL6IDAgARB4MC8UMCoUMykiFvkWDSBAAmhwi9SI1YrT ++dICIIACcHCZ4prjmOWb5IjRmOEt0gAt5gArIgArFhYqIFQqFF0pIAUpFGAoIDAvFFz2FF4gaAJY +sPgUYSDQAlBwWFPeKhxw/AoIIHgCWLBYU9srTHL8CgYg9AJQcFhT1yocffwKAyCcAliwWFPUwEj7 +LFwg/gJQcPqsBSAIEGAwWFPOKxFCBRwU/RFDKAsBKDD1r0AJkAQ6IP0VMS+gBD/g/SIMLAkAYXD8 +DEAOBQFYMPnMEQ+wBDug/T1UDAkAczD4/wIMCQBrMPwUZCoNAVgw+SBpK6AEOqD9IGgqDgFcMPm7 +EQ4GASgw/u4RCgkAWrD9PUAKBgFMMPl8QAgFAUww/swRDdAEP2D/uxEKCQBqsPWdQAoJAGbw9YxA +DbAEP2D8zBEKCQBasPVbQAgJAFZw+gowK/AEPuD9zAIICQBWcPkUZSoEASgw/SIMJAcBLDD/zAIF +0AQ9YPuqAg4JACuw/swCChABbDD9GVAMEgFsMPqZEQ2QBD9g+7sRCAkAbnD8qgIICQBecPoUZygJ +ACZwKRRmhScoWRT0gRNgQAIhcI5ZZOEJ2kD7HAAACBBgMFs/rigiFiVyiPmIEQIAAFCw+FUIAgAA +WPBb4R3aIFripYopyK+Eq9swW70U+kwAD/UAtSCKKfsiCyAYADagZbCQmitgAAOau5us9iYJIAAQ +UDCLWnK5DoopiSiZWmAAKQAAAAAAAMm4jLhywRRtCAz7zAAADgA3IIzIcsEEY//sAADItIopjCic +uJYoKyAF+yQwIDgAtqCNK87exON+sXUucnSLIPpyiyAAEGAw/rsMAAEQaDBbO9IZi2iInsP//yQF +If4CQjCYntEPxJIpJAXRD4m7DwIADwIAZJ9obQgK+ZILIgAAWnBkn1pj/+7BpiokVGP8jsC0KyRU +Y/yGAAD6LAACAABYcPwKCCACEGgwWzgrY/7sw88sJAXRDwAAAGwQBBuMFRmLWB6MNfiLZRIAAFCw +jaCEpxKLSCiCfPRCDiwJAHdw/SacIAQQYDD5Jp0gBRBoMAuAACoinf6MKxD/EEgw+ooUDIABHDD9 +3RAOABFWUCtAOixAOwi7EQy7ArG7K0Q7C4sU+0Q6IAAQEDDRDygiphKL8BmL9SIifwmIAQmIEagi +jCwOzAENzAKcLNEPAABsEATAcG1KFKN09EAAKAAgEfAogAD0iQtwAgI58MAg0Q8AAAD0gwh//xAQ +MMAh0Q/RDwAAbBBGKTBUxHL1i7YQAhBQMPIKACAA+wZg/wIAAgCpGmAqMS8tMJgvMS70i6AeHgE+ +oBiMyv8CAAoBcFIQwJf/zkAAARBgMP9fQAgFAHcw/X1ACAUAfzD9yTgAFRBQMPSTBm4AEEAwkhUA +BI2YFPyLnhAwAkBwbaoCAAiKLBYG+mIAI/8QYDD8FRQgBBBYMCsUMPiqEQALEFgw8hQrKgkAWrAq +FgcpYAQPAgD6HDEkATkGYPwKAyCiAlmwWFLaKhw1/AoDIJwCWbBYUtYoYhYjUmj5iBEAPxBIMPlk +BSIAIETwIhRJIhRK8hRLIKACUHD5CgUggAJY8PkUSCAIEGAwWFLJKzxI/AoDICgCUHBYUsWOFfsc +GCIAAFGw/o4UAAsQYDD+FhMgAhBoMFv1zShiFiRSaNMP+YgRAgAAUbD4RAgAihBYMFvgWNpgWuHg +imnJoIOrKwqKW7xP+jwAD/QAtOCKaYtryqjMuZprYAAa0Q8AAAAAibvIm/mSCyIAAFpw0w9ln/Ka +u5us8mYJIAAQUDCLSna5CoppiWiZSmAAHQAAybCMuHbBDPvMAAAJADcgjMh2yfLItIppjGicuJJo +K2AF+2QwID0AtqCNa8/TxOP/AgAGAMD20C5SVItg+lJrIAAQYDD+uwwAARBoMFs7ChiKoI+Ow5/5 +ZAUh/gJ78J+O0Q8nZAXRDwAAIzBZwL7/AgAH/63c0ByMZS9gUC5gTy1gTipkVChgBfhkMCAyEFgw +8xYAIAUQUDBYWeMoYhYkUmj5iBECAABRsPhECACKEFgwW+AV2mBa4Z2Kacmgg6srCopbvAz6PAAP +9AC04Ipp+2ILIC0ANqDMuJprYAAZAAAAAACJu8ib+ZILIgAAWnDTD2Wf8pq7m6zyZgkgABBQMItK +drkKimmJaJlKYAAdAADJsIy4dsEM+8wAAAkANyCMyHbJ8si0immMaJy4kmgrYAX7ZDAgOgC2oI1r +z9DE436xeC5SVItg+lJrIAAQYDD+uwwAARBoMFs6xxiKXY+Ow5/5ZAUh/gJ78J+O0Q8AACdkBdEP +AAAA8/0iYgAASLD8CgMgkAJZsFhSPiscEC6wAv2wASBqAmBwLcQBLsQCK7AA+8QAICsQUDAqZAXz +/ZBiAAAZsMP/L2QF0Q/DjyhkBdEPAAAAAAD7PHAgaAJRsPoWfiAIEGAwWFIq+zxoIHgCUbD6Fn8g +CBBgMFhSJvs8XCC4AlGw+haAIAgQYDBYUiH8Mhkg0AJRsPxmGSCYEFgw/AoQKgAgXPBYUhotYAwe +idX/YAUgARA4MCdkVC9kMCdiFi7iePxSaCAQEEgw8AQXAP4CQHD+3QgHkAQ94PndEQYAID8w/WEZ +LAAgazD9FoEgggJCMG2aAgAIihiKBizBLvMKCCYBLUcQH4nA/mIAIOEQQDAoFNgvFjL/ib0fgAQ7 +oP8WMC4JABuwLhYxL2AH+Im5HiABfDAA/xEPzwII/wIvFjQN6jAtFjUuFjn8iuQQQBBYMCsVbywW +OCpgVCoU8SlgBSkU8vhgMCABEGAwLBTwKBTz/2IWIP4CcHD/Fj0gwgJzsIvkieKI4YrjLx0BjeWd +9ZrzmPGZ8iv2BCkdASsdAS7iAC72AC8dAS1iAC0WRipgVC0dASq0HSodASsdAShgBSiUIC5gMC70 +ISK0HvzUHCBQAlKw+xJ+IgAAYPBYUcwrEn8qHQH6rDAgCBBgMFhRyPodASDkAlnw+qw6IAYQYDBY +UcP6HQEgnAJZsPqsPSADEGAwWFG+KxKAKh0B+qxEIAgQYDBYUboqEaMqFZEqEoEKTkD6X0AKCwFU +MPpoQAgHAVQw/ZkRCeAEOiD5iAIICgFUMPm7EQmgBD5g+xGiKAkAXnD6HBQGCAFUMPx3EQwJAGKw +/AxADAUBXDD5zBENsAQ/YP1iDCwJAGsw//8RCgkBUDD/7gILsAQ6oPp3AgyTAWww/R0BLAkAazD8 +1CQmCQBN8P9gaCoNAVgw+WBpKg4BXDD6qhELkAQ+4AuqAvlrQA4DAXww+XxAD9AEP+D+zBEL8AQ+ +4Py7AgoJAHqw+VlACgkAWrD6CjAoCQBWcAqZAinUJfhiDCYJAEXwCA9Q+BxQCBIBQDD6zBEJkAQ6 +IPv/EQwJAEMw9+4CDAkAezD+1CcsCQAbMCzUJo1nK9kU9LDVYEACU3Ar0glksMorHH/7vEEgCBBg +MFs9mSxRf/8CAAP9e/sQAASNKB0B+IxQIBUQSDBtmgIACIoqHQEfiz//FlQgogJZsPliACP/EHAw +/hWwIAEQaDD9pGggAxBgMPiZEQALEGgw8qRjKAkAbnD5FlUg0gJSsFhRVfodASCcAlmw+qxtIAMQ +YDBYUVD7HQEiAABRsPK0giALEGAw87SEICAQSDD5tIAgAhBoMPm0hiAQEEAw+LSBIBQQeDD/tIMg +IhBwMP4WZCCgAlrwW/RPw6oqZAXRD9pg+xx/IAgQYDD7vEEgAhBoMFs2JmP/KgAAAGwQHBiJ2PeJ +5BwAEFAw+hYAIAAQWDCbESkiFiRyaAAIjfmZEQAQAkBw+QoVJAAgSTBtmgIACIr8CgMgQgJQcP0i +ACCiAiiw/goLIAEQMDD2FBsj/xB4MPYUIC2ABD9g/xUMLAkAd3D9FgMiAABZcFhRGyYUOCMVIC8Q +AikQAfsQACD8EGAw/BQ8IAIQUDD6FD0gSgJAcPuEACAIEGgw+YQBIXIQcDD/hAIgjARw8C4qE/8q +FyYASnTQ+CofJgBh/ND6Fi0gggRA8C0SLBmK5/scCCIAAFCw+dkCAAsQYDD5FgIgAhBoMFv0DNEP +AAAAAP0USyAyEFAwKiQFJkR98//KYBQQaDDbUPMKCCIAACKw+hwEIAMQYDBYUPCMES1xfyMUTwyM +FPwWEiwBAWww/BYBJAUAabD0FE4gNBBYMCskBfP/h2AYEGgw21D8CgMgCAJQcFhQ4o0R/Y0UAHAC +WTD9FgEgmAJQcP0WEiAIEGAwWFDaw+UuJAXz/1BgHBBoMNtQ/AoDIAgCUHBYUNSIESYUTgiIFJgR ++BYSIDMQeDAvJAXz/yZgNBBoMAAAbBAi+Il6EAAQSDCZEIktKIJoCZkRqYKJKIwqJJIZ9MAqYeAC +ITAqCkBtCAuLzAs7VGi0B4zIycJj/+0ALcAFLcUJKsQFY//rAAAAAP8CAAoApUUgjyopFiwaiVf7 +iZAQqAJgsPwWMSB4Amhw/RYwIEoCcHD+Fi8gQgJAcCgWLisWOPoWLSCYAlhw+xYyIIACULD6FjMg +qAJAcPgWNCBwAnCw/hY1IPgCaHD9FjYgyAJgsCwWN7g8/goAICACKPD9PAAACBBAMNMPbYoU9tAY +JgAgF7AncECx7vZ5F3ACAmtwjTRm0LUkTPDzPBArkAC9IGAAp/ZzBn//EGgwwNFk398mEizTDyZi +CmRgQP08AAAAEHAwpuoqoEAn0Bix7vepEnACAmtw/NnsegAgM7CNNGP/rwD3owZ//xBoMMDRZN/s +hmndMP4KAC/LALWg/PwAAOAAN+CLzN0w+ztUAAAQcDD4CggkAGOa4G2KZPbQGCYAIGewJ3A8se72 +cVJwAgJrcP8CAA//EGgw/wIACgF+NdBgAvIAAAAAAACPKvP8AAAJALfgYAAgyT0oMAXzMggiAABQ +8GmN74msCTlUaZTnKwqGW/wzZT/gwKAqJH3RD9MPjTQvCgAPAgD42BECAABwcPgWACADEFgwbboU +9uAAJAAgZ/AlUE6x//VpD3ACAnOwKMEJKMQFjypj/tb2UwZ//xBwMMDhZO/nKsxO+xwAAAMQYDBY +UEKNNGP/2ozIZc8jGYjuKZF/fpcEjTRj/qMrEjgeiE4ZiTcYiGeGJ48gKIJ89mIOIgAAULD5iFQe +CQBP8P/mnCAEEGAw+eadIAUQaDALgAAaiEEqop36ihQA/xBIMHqQHytgOixgOwi7EQy7ArG7K2Q7 +C4sUK2Q6jyqNNGP+PgAAGIg1GYj5FojQKIKmDwIAJmJoCYgBCYgR/YkbFgAgQbCMbA8CAA8CAP2H +2hwAQGswDwIADcwC/GYML70ANaCJNCtcCPpsPCmABD5g+RYAIAgQYDBYUA31bE4iAABYcPwKAyIA +AFFwWFAIKhItKBwI8AoXABUQSDBtmgIACIoqEi4YiPb4FgIgogJZsP1iACABEHAw/hQgIAAQeDD/ +FBsgCxBwMP86/y2ABD9g/xUMLAkAd3D9FgMgAxBgMFhP8ywSLy5QAC1QAS3EAS7EACtQAvvEAiAA +EEgwKRQ5KxIxKRQ6+RQ7IAMQUDAqFDj6EjAgEBBgMFhP5S8SMy4SMi3wACzwASzkAS3kACvwAirw +AyrkAyvkAinwBCjwBSjkBSnkBC3wBy/wBi/kBi3kBy4SNS0SNCzgACvgASvUASzUACrgAingAynU +AyrUAijgBC/gBS/UBSjUBCzgBy7gBi7UBizUBy0SNywSNivQACrQASrEASvEACnQAijQAyjEAynE +Ai/QBC7QBS7EBS/EBCvQBy3QBivEB/3EBiAAEHgw/xRcICAQUDD/FGwg/xBIMPkVQiABEEAw/xSM +IBACWHD6FDwgAhBoMPoUPSALEGAw+BVEIgAAUbBb8rvD6S5kBWP+FcDRZd2fY/1BAGwQLigwVGiC +AtEPAPs8cCBoAimw/AoIIgAAUXBYT6D7PGggeAIhsPwKCCIAAFEwWE+c+zxcILgCEbD8CggiAABQ +sFhPlys8ePkyGSDQAlGw+WYZIBAQYDBYT5ErYAUdiI+KbPiHbRABEBgw94gvEDEQYDD9qgEGAb9m +0B6Ihw6uAp5sKWIWKmAMI2RUK4J7L2EZKIKD/xZRKgAgWrDwBxcLkAQ6oPqKCAmQBD5g+QoQKAAg +SjD4FlAiAABAcG2aAgAIihmHdyqhLv8CAAYBG86QHIcx+2IAIOEQaDAtFBj8FgIgCBBgMP2HLRuA +BD7g/RYAKgkAZvCbES1gB/6HKhwgAWwwAN0RDa0CDt0CnRQJ6jCbGZkVGIhV+BYIIEAQeDAvFQ8u +YFQuFDEtYAUtFDIrYDArFDMjFDAqYhb6Fg0gQAJQcImljaGOoo+j+KIEIIACWHCYtJ+znrKdsZm1 +iqCasIlgKRYWKGBUKBRdL2AFLxRgLmAw/hRhIAAQaDDzFFwiAABZcP0UXiDQAlBwWE9E20D8Cggg +4AJQcFhPQSsSUCocetMP+7xyIAYQYDBYTzwqHH38CgMgnAJZsFhPOAIrAvocfyAIECAw+qwFIAgQ +YDBYTzMpEUIrEUMvElErFTGLbP+uQAILAXgw+VxACA0BSDD/GhQMBgF8MP7dEQoJAFPw+ogRCgAB +UDD7zBELkAQ6oPs7VAoJAGKw+elACgkAWrD6FGQjkAQ4oPVgaS+gBDug+2BoLgkAE7D5mREMCQF4 +MPmIAg2wBDsg+ztACAYBLDD1ekAEBQEsMP6qEQnwBD5g/bsRCAkAVnD/WkAICQBaMP+LQAgJAEow +/0lADgcBfDD4CjAkCQBFcP+qEQQJAEVw9RRlK8AEPuD8YgwqCQBm8PqZAg/QBD/g/90CCgkAdvD9 +uwIKEAFgMPwYUAwSAWAw+ogRDZAEOyD7qhEICQBiMPuZAggJAFIw+RRnKAkAIjAoFGaCZyUpFCos +IPwiCSESADVgZMEK+xwAAAgQYDBbOxMtYAX6CgAsABBIMPgcfyAxEHAw+IwZL/53c1AAB40qFiX5 +FiQgFRBIMG2aAgAIivJsUSADEGAw/WIAIAsQcDDzFKsg/gJQcPMUsCP/EHgw/xVULYAEP2D6rDIs +CQB3cP0WJyIAAFiwWE7NIxTI+hx/IhcQeDD/FWgg/BBIMPkUzCACEEAw+BTNICICcrAo4AL94AEg +bAJKsC2UAfiUAiIAAFiw/uAAIAMQYDD+lAAgKgJSsFhOuigSJR6InPMU3iIAAFGw+IgUAAsQYDD4 +FiUgAhBoMPgWNiAzEHgw/2QFIP4CWHD+FiYgMgJa8FvxutEPGYesCakCmWxj/IIAAAAA+mwAAgAA +WHD8CgggAhBoMFszj2P+6QAAbBAWE4Z+KiAMGIdAKzJ7JCIW8zKDIBAQSDDwCBcKACBasPmqEQIA +AEBw+joIBZAEOSD0IRkiACAk8G2aAgAIihiGkSqhLv8CAAYBLMaQH4ZL/iIAIOEQKDAlFBj/FgIg +CBAoMP+GRx+ABDug/xYALgkAK7CeES8gB/iGQx4gAXwwAP8RD68CCP8CnxQN6jCeGZ0VHIdv/BYI +IEAQWDArFQ8qIFQqFDEpIAUpFDIoIDD4FDMgARBQMCoUMC8iFv8WDSBAAnhwjvWJ8YvyjPP98gQg +gAJAcJ2EnIMrhgIphgEuhgUv8gAvhgAuIgAuFhYtIFQtFF0sIAUsFGD7IDAgABBIMCkUXisUYfoU +XCIAAGFw+hxoIGgCWLBYTloqHHD8CgggeAJYsFhOVys8cvwKBiD0AlBwWE5TKhx9/AoDIJwCWLBY +TlD7LFwg/gJQcPqsBSAIEGAwWE5L+xFCLgUBJDD9EUMiCAEkMPQcFAYJASAw9KdACAsBIDD5iBEH +oAQ94P0VMSwJAGEw+2YRA8AEPOD9IgwiCQA08PwMQA4FAVgw+cwRD7AEO6D9PVQMCQBzMPRmQAwJ +AGsw/BRkJgkARfD9IGgqDQFYMPkgaSoOAVww+qoRC5AEPuD0eEAKCQBasPlrQAwDAWww+XxADdAE +P2D+zBEL8AQ+4Py7AgoJAGqw+VlACgkAWrD6CjAoCQBWcP2IEQgJAFZw+RRlJ+AEOaD0IgwuBAEg +MPczAgYJAEGw//8RAgkANPD/7gIOEAEkMPQdUAQSASAw+t0RBZAEOSD7/xEMCQAncPPuAgwJAH9w +/hRnLAkAL3AtFGaFJyxZFCRcIP5SCSAYADcgyeDaQPscAAAIEGAwWzoq0Q8AAAD6LAACAABYcPwK +CCACEGgwWzLl0Q8AAABsEByJJycxCyiZFIaZ9ICvYYgCOfAqbBn8CgMgegJY8FhN7ipsHfwKAyCC +AljwWE3rLjA8ii4Yh7/9hcYQARBYMPmmEQG6AnOw/r45BgK7xpCILS3SgxyHxvmKEQYAIGmw/WAF +KgAgU3CLZ4+n+qIIIBEQQDD7sg4hngJrcP/yDioAGUNQGIe7CNgKiIAKgAAAKxYt+hYsIAMMB6Ap +8D4q8D8ImREKmQKxmSn0PwmJFCn0PtogWzPU0Q8AAAAAAADz/1FgABAwMAAAZeQjKTBU/wIAAAOY +BmBpktfBp/pkVCIAAFGwW/8cY//HZeQcKTBU/wIAAAJrBmBpkrZgBNNl5CIpMFT/AgAAA2OGYGmS +osDFLGRUKzBY+QoBKAQHAuD+CgEgABBoMAntOGTQYSsyGStlGRuG5CowWohsDwIACnpA/qoQCABA +WjAKiAIoZgwqMFobhgoKakD7iAEK8AQ6oPuHexgJAFIwKGYMKjBaL2AF+4gBCgUBUDDwqhEAPRBY +MPtkBSgJAFIwKGYML2Qw/QoBIAAQYDAJ3DhkzxQjYRklYhYrYAwchUkahWoYhi0swngqooPwCBcA +EBBIMPy7CAAgAkBw+VURC5AEPuD1pQgKACBasG2aAgAIih2FgCqhLv8CAAf/Zu6QHIU6+2IAIOEQ +aDAtFCj8FgYgCBAgMPyFNhuABD7g/BYEKgkAJvCbFSxgB/2FMhwgAWAwAMwRDKwCDcwCnBgJ6jCZ +GZsdGIZe+BYMIEAQUDAqFRcvYFQvFEEuYAUuFEL9YDAgARB4MC8UQC0UQyxiFvwWESBgAmBwi8WK +xInDiML+wgEgoAJocJ7RmNKZ05rUK9YFLMIALNYAK2IAKxYaKmBUKhRtKWAFKRRw+GAwIAAQcDD/ +FGwiAABhMP4UbiBoAlmw+BRxIPACUHBYTUn7bDwg/gJQcPqsASAIEGAwWE1E+1xyIP4CUHD6rAsg +BhBgMFhNQPtsTiD+AlBw+qwOIAMQYDBYTTv7bFwg/gJQcPqsFSAIEGAwWE02/RFKKAYBGDDzqUAK +CwEYMP8RSyYJARww8x4UB7AEPeD/FTkuCQBw8PmqEQmgBD5g/2IMKAkAVnD+DkAEBQFsMPnuEQWw +BD1g/z9UDgkAK7DzekAOCQB7sP4UdCwNAWgw+2BpLaAEOyD/YGgsDgFsMPndEQQFARww/1URDAkA +azD/P0AMBgFcMPt+QAoFAVww/u4RDfAEP2D9/xEMCQB3cP/MAg4EARww9f8CDAkAazD8CjAqCQBm +8POFQAoJAGbw+xR1JcAEPWD3YgwkCQA9cP6IEQvQBDqg+ogCBAkATXD4VQICEAE8MPceUAYSATww ++u4RB5AEPeD7MxEOCQA7sPX/Ag4JABuw/xR3LgkAI7AuFHaEZy1JFPTU0GBAAhkwKEIJZITFAzoC +/AoIICACWHBbORVj/Hdl4QEpMFT/AgAAAV+GYP8CAAP+MxpgYALG/wIAAACBH6AqMS7/AgAGAdbm +kBmGxP8CAA/+IsqQ+xpyIgAAUbBb+6Fj/DL/AgAAAHgfoCoxLv8CAAYBxmaQG4a5/wIAD/4M2pD7 +KhMiAABRsFv7lmP8Bv8CAAAAcB+gKjEu/wIABgG25pAchq7/AgAP/fbikPsqHyIAAFGwW/uLY/va +ZeDOKTBU/wIAAAEpBmD/AgAD/eSaYGACWS3wPi7wPwjdEQ7dArHdLfQ/DY0ULfQ+Y/unLvA+KPA/ +CO4RCO4Cse4u9D8OjhQu9D5j+40o8D4p8D8IiBEJiAKxiCj0PwiIFCj0PmP7cwAp8D4q8D8ImREK +mQKxmSn0PwmJFCn0PmP7WCrwPivwPwiqEQuqArGqKvQ/CooUKvQ+Y/s+K/A+LPA/CLsRDLsCsbsr +9D8LixQr9D5j+yQAACzwPi3wPwjMEQ3MArHMLPQ/DIwULPQ+Y/sILfA+LvA/CN0RDt0Csd0t9D8N +jRQt9D5j+u7aIFsykNEPLrBwse4utHAtMhvByPjdEQIBK5pgwKD++v8gCBB4MG36GqOv//BkJAAg +MrAkQDQPAgAPAgD/SQxwAgJSsPAAFGAAEFAw/0MGcgAAU7DAoWSv6mAAb8CIbYoUo6//8FwkACAy +sCRAPP9JQnACAlKw/RYAIgAAUHD4CgMgABBoMA8CAG2KFPOgAC4AIDdwL/BOsd3/OSdwAgJSsClg +BflkMCA9EEAwKGQFY/o8AAD/QwZyAABTsMChzKpj/7IAc/MBwOFk79QsZFT6CkAghhBYMPpkBSIA +AFGwW/gmY/oJAAAAAAAAAPs8RSD+AlBw+qwhIAMQYDBYTEYoEiwvEigughgPjxQvFigtghkchUP7 +Ci0gLhB4MP3qCAwAID9w/YYZIWEAN6AYhHt9i2wpEij/AgAN/N3mUGP5riqwXCywXQiqEQyqArGq +KrRdCooUKrRc2iD7PAACAABhMP1cAAIAAHGwW/kiY/l/ACywXC2wXQjMEQ3MArHMLLRdDIwULLRc +2iD7PAACAABhMP1cAAIAAHGwW/x3Y/lPLTA4KDA5DwIA+TA6LYAEP2AI3QL4MDstgAQ/YAndAgjd +EQjdAv8CAAYAvl9Q/wIABgC6f1AvEij+FisgqAJY8PoWKiwAK2fQ3HBYTAvaIPsSKyIAAGEw/VwA +AgAAcbBb+zopEizAgCiWGWP44iqwXiywXwiqEQyqArGqKrRfCooU+rReI/yUAmD7YDAgBhBgMCxk +VCtkBWP5oNxwWEv30Q8tsHGx3S20cWP4owAusHKx7i60cmP4ly+wcrH/L7RyY/iMAAAosHKxiCi0 +cmP4fyxkVPpsAABAEEgw+WQFIIYQWDBb971j+GYALRIo/wIADfwyZ1AtMDgoMDn5MDotgAQ/YAjd +AvgwOy2ABD9gCd0CCN0RCN0C/RYpIBgEW3D/AgAP/Bb7UBiFuykxLi4WK/oWKi//eMJQ2iD8TAAA +qAJY8P1cAAIAAHGwW/r/HITNLTA4KDA5KhIq+TA6LYAEP2D+EissCQBHcPgwOy2ABD9g+d0CAC0Q +WDD43REALhB4MPP+oGwJAEdwAAAAAPscECIAAFGw/AoIIAIQaDBbMKNj96wAAB+FmisxLn+xRhiF +mS4WK/oWKiC6BELwKhIswJApphlj94gqMFr/AgAD+/fikP8CAAP78+aQ/wIAAfvv6pAKDEP8zP8g +ABBYMAy5OGP3yQAAKBItL4ByLhIssf//hHIgABBoMC3mGWP3QQAAAAAAAAD8fAAAqAJY8FhLlhmE +mCgSKNMP/wIADfuUzhDaIPsSKyIAAGEw/VwAAgAAcbBb+sFj/3MAAAAAAGwQBiwgB4kn9BYCKCAB +YDD0kjxgQAIycCqZFGSiMSqSCf0KEiIrADagLqIAK6Aw+Tr/LvgBcDD+FgEmAT/u0C+hCPsKSyYB +SU/QKSAF9awAAE0QcDD5sgxwShBoMP8CAAgA9+5QjxH/AgAGAPL2UPoSAiAwEEgw9zELIEoES/Ap +YQUr+sALawH7mwgLwAQ6oPu8QCoAIFDw9awACgE2WpAbg6WEWvyKEQGIAjnw+6oIBAMAOTD9ojog +bgI5MAdHFLR+/hYAKgDHd1AmojkZgxRkYYDwCQcP/BBAMPmE9BAeBEHw2GBt6QIASGEsIAcMKEAK +iBAJiAKYYI0g+hIBIDAQWDD+g48QMAJ5MP9mAy2ABD9g/mYCLAkAbfD9ZgEgNARasIonjRLAwPqs +ICIAAFtwWzQtLCAH1aArIQj9hR8cIAFgMADMEfwKACoJAGbw/GYFKgkAbvCbZABFjQIGj51mlGcs +IAwqbCj0ZgctAAQ7IPxMAAoJAGbw+2YEIKgCWPBYSyoqXBn8CgMgegJY8FhLJys8QfwKAyA6AlFw +WEsjjVEkVQv8IQcs4AFsMJ1RLSAHGYLz+iEILUABYDD8zBEOAgFoMP0NQQ6gBDug/oS3HAkAczD8 +fxELAAQ/YPuqAg4AIH2w+4NWHAkAczCc8P4iACoJAEqwmvT79gIgBBBAMPn2BiAwEFgw+/YDIAAQ +SDD59gUvgAQ7oPn2By4JAEOw/vYBIEACY/ACBYYATGMABYYATGEYgz8M3xH+EgAuACBH8P72OSIA +AFCwWzED0Q/RDwAAiSJkkJ6KEcOwe6nviScVhNAsmRQlUn/0wIFgQAJScIiZhoH2BkcAABBYMPxc +AAIAAGmwWzPYiifbMPwSAiBAAlKwWzcRjSCMEosnCN0RDcwC/KYBIEACUvD7XAACAABhsFs3CdEP +E4OvKCIeIzJ/CYgR+DMIAgAAULBbMOLaMFsw4dEP+iwAAgAAWPD8EgIiAABpcFv82dEPAAAA8/+B +YAAQQDDaIPuMGCIAAGCwWztUY/9QCaUMY/2RAABsEAQagwscgponIAcuIQctIQgWhGL+DkoOAgE8 +MPr/EA/ABDug9wdBDgkAe7DwfxEOCQAzsP5GACwJAH9w9iIALAkAZ3CdRPxGBiAAEFgw+0YFIAQQ +QDD7RgcgMBBIMPpGAieABDmg+UYDJgkAQbD2RgEgQAIRMAIDhgBCYwADhgBCYRKCYAx/EaL/lfDR +DwBsEAYag3WLLSqifwm7EauqiqrJoiusYPwKBCIAAFBwWEqbihBgAAUAGoMrmhD8gmkT6BBYMAur +LAO7KAy7KPsWACIAAFCwWtm7ixAcgtD9g4ESAABQsFrZ19ogWtm60Q9sEBAagoosMScbg1uGLigg +B/SyfyIAAEkw+AhBB5AEOaD6wQ90ACAxMCchN/8CAA4B7eHQKyE2KjEm/wIADgHm2pCOJ2TkRizp +FCgWE/XiCSQ/ADcgKRYQ2iBa2Z4uEhMtIAWUHvUWDyBWEHgw+SEIJgIb/1D6gq8T/xBgMPg6/yAL +EDAw+JgMAAcQIDD0VA9kBQBBsChSAPiIVwYCEmZQDOkRqpkpFhEpkjoVg/4jFhXzEhEqAbgmUCMy +OWQzZf8CAAYCPYIgFoIW8AYHAgAAQPBtSQIASGEsIEEZg/kegwMMzwn3IQcvwAQ/4PiCkx4AIHuw +LuJ/9iEiJ0ABPDDwzBEHwAQ94P6PQgzAAXQw/n5AD4AEP+D23xQMCQB/cPXuEQ9ABD/g/woALgkA +e7D/FgQmCQBF8Pc2ACwJAHdw/YPfHAkAazAXhCEuIgD5NgcgWBBYMPs2AyBIEFAw+jULJ0AEOaD6 +PCAgkAJYsP81CiwJAGsw/DYEIAcQeDD3gnAWCQA5sPY2Bi+ABDug9zYCLgkAe7D+NgEgDBBgMFhK +I8CA/ILfEAAQSDD5NDogABAwMPY0OCAuEFAw+jQ7IIkQWDD7NCwgeAJQ8Pw0LSC4Aliw+DQ5IBgQ +YDBYShQdg/z+MEggABAwMCY0RPY1JSCKAlDw9jYUL4QQeDD/NDwgAgJzsP40SCAgAlhw/RYEIAMQ +YDBYSgb7ggUQABBIMCk0VCwgaCw0VS4hNi41LC8hNy81Lfk1LiBCEFAwKjRkKzUvJyAFxYb9ClAm +AYXF0C0kBSkhCC46//8CAAYBZHZQH4HILSAHKiEHG4OR/QxBDAIBbDD6CkoMoAQ/YPyqEQ8ABDsg +/p4CCgkAarD7IgAoCQBesPoSDyCQEEAw/QoEKAAgQPD/7gIHgAQ+4PWgc2wJAG3w9oPIEAIQUDD2 +FgYmCQBR8JYXhh4nYh+XGReCHSZiHioUK5YY+xYNIAAQMDCWHC02HS42IP82IiAAEFAwKjYh+jYj +IDAQMDAmNh8pNhz3Nh4gMAJIcAIJhgBIYwAJhgBIYRmCCAzIEamIJIY5YABwi6EWg2kLC0f3ggUa +CQA28JuhLTYd9zYeIDAQMDAmNh8uNiD/NiIgABBYMCs2ISk2HPs2IyIAAEqwBgmGAEhnBAmGAEhl +G4Hz+RIPK8AEOyCrqiSmOYmQ+YlXADIQaDD/AgAGALJuUMPF/wIABgCtZlAtOv8tJQguIAUr+sD5 +gnYQVhB4MPwKACYA5v+QjScq3CALqgH7Ig4ggAJSsJrYmtkpkn+KLIgr/NUUK5AEPuD1oApoACBe +cJiZYAACAJir/AoAIAYANiCajJwriJv8JgwgCAA2IJKMmCuSm/osAAADEFgwW/7m0Q/aQPs8AAIA +AGJw/gqFIgAAaXBYAUrRDwAAAI0iIxIV+BYUIWwAN2BohliOJy/pFCRSvfTxL2BAAlOwJeIJ91wA +ACQANWAlUgH1BUcAABBYMPxMAAIAAGlwWzJhiif6rCAiAAA5MPwSECIAAFjwWzWYjCArEhAIzBEM +uwL7pgEgogC14NEPKRYQ8/vBYAAQKDAAAAAAAPP7/GAAEEAwlB4vQAX/RDAgQxBoMC1EBWP7uQAA +AAAA/wIAB/3uGiCJJ/j6wCBAAjJw+AoAJgBAQbD4lRQggAIxsJaZlphj+7YpIRQjIRLAQPkWEi6e +ADZg+lJCIgAAWPD8CgAgARBoMFsxxSZSQyoSEvRMASACAhjwBjMueknYY/5vKBIRJIY5Y/5siifb +cPqsICIAAGFwWzVo0Q8AiictEhDAwPqsICIAAFtwWzImmh9j+3EcgyCNIPshCCAFEFAw+xYAIDIQ +WDBYUJlj/ODz/tRgABAoMByDGY0g/iE2IAUQUDD/ITcgMhBYMFhQkNogWy8x0Q8AAAAr7Bj6LAAC +AABgsFs5qygSFGP+gwAAbBAGF4HxjC0ncn/4gvIdkAQ7IPoiDiwAIGHw/MIHIEsQeDD2CkogSBBw +MPswPCCBEGgw/MIOIHIEQrAJqhGqeoen93IOIMwEavAtIAX/AgAGAIj3UH3yFXbSEi0KhP4KhSYA +7e7Q/wIABgCJ9tDRD/8CAAYAxG7QLSAF/wIABgFad1D/AgAMALnr0P8CAAwAtbNQLwqE/wIABgDR +/tAoCoX/AgAGAUHG0NEPACnAYCvAYf3AYimABD5gC5kC+8BjKYAEPmANmQIImRELmQKxmSnEYwmJ +FCnEYgmJFCnEYQmJFPnEYCA9ADagK3A8LHA9/XA+K4AEPuAMuwL8cD8rgAQ+4A27Agi7EQy7ArG7 +K3Q/C4sUK3Q+C4sUK3Q9C4sUK3Q8K6AFxMD7wg5wQhBwMMPe/wIACf+cbtD4ClAn/5h20C8gBf8C +AAYA48fQ+iwAAgAAWPD8TAACAABpcFv+PNEPKcBssZn5xGwvAwA2oCpwc7GqKnRz0Q8AAAAAK8Bt +sbv7xG0gPQA2oCxwdC1wdf5wdi2ABDsgDcwC/XB3LYAEOyAOzAIIzBENzAKxzCx0dwyMFCx0dgyM +FCx0dQyMFCx0dMRt9IByEgAAULBa19X2JAUiAABpcPhCTyIAAFCw+TEnIAAQWDD5JTcgABBgMAuA +ANogWy6s0Q/RDyrAYCvAYf3AYiuABDqgC6oC+8BjK4AEOqANqgIIqhELqgKxqirEYwqKFCrEYgqK +FCrEYQqKFCrEYPP+6mAAEFAwxE32gFQSAABQsFrXt/QkBSIAAGlw+GJPIgAAULD5MScgABBYMPkl +NyAAEGAwC4AAKjBU/wIADgBkgqAagVSLLIwuKqJ/+SILLZAEOyD1sApqACBisJmpYAACAJm7yJCb +nMCwmyuJq/smDCAIADZgkpyZK5KrGoFFiy0qon8JuxGrqoqqyaMrrGD8CgQiAABQcFhIa4oQYAAG +AAAagPuaEByAOSs66AurLAy7KPsWACIAAFCwWteMixAcgKH9gVISAABQsFrXqNogWteL0Q8AAAAA +APs8AAIAAGEw/gqEIgAAaXBYAB3RDwAAAC3AbbHdLcRtY/6PLsBsse4uxGzRDy8xLmX/NCgxL2WP +LiogaCkwVbGq/wIAD/+R0lDaIFsuU9EPbBAEwHBtShSjdPRAACgAIBHwKIAA9IkPcAICOfDAINEP +AAAAAAAAAPSDCH//EBAwwCHRD9EPAABsEAgpIAcagQouIFUvISKTE/OAdhCEEGAw/GwMAAEQWDD/ +FgIgABB4MP7uCQIAAGvw/L04AgAAQXD8IhYiAABZMPqifyggAUww/xYAL8AEPmD5zBEEACAf8PyA +0hQAIGKw+lI6L8AEO6D/CgcgBhAYMP7MCAIFAG/w/MJ/KgD+npAnUjlkcfIYf9TwCAcCAABB8G05 +AgBIYSshBx6AVQsLSv+AVRvABD7g/rsCAFgQSDD7dgAgUBBAMPsSAigFAGpw+iIALgcBYDD4dgMv +UAQ7oP92AihIAWAw/AxGCYAEOiD4CkgsCQBDMPvfFAuABDqg9P8RCgkAUPD6dgEuCQB7sPqBnBBA +EHgw/oGhHAkAczD9gZkeBQBuMClAfC91C/12BytABD7g/goAKgkAdvAudQr7dgYpAAQ+YPtMcigJ +AGZw+pkCAAYQYDD5dgQgQAJR8FhH5CtMbPwKBiBMAlHwWEfgJnQ8+ICcEAAQWDD7dDogLhBQMPp0 +OyAAEGgw/XQ4IAAQYDAsdDn8EgMgiRBIMCl0LCh0LS7BJi3BJyTAQC/ASS90SSR0QC11JxR/zizB +J/51JiAAEGgwLXRE/XRIJgBYpxAqfEH8CgMgogJYsFhHxCssTvwKAyB6AlHwWEfBiRMYgVApkEUu +EgAfgasAmTIJjjv6fEUuCQB7sPjuEQIAAFhw/hYAIAMQYDBYR7X6CoQgCRBYMPphJHAAEHAwK3RV +/nRXIEIQYDD8dFwgAxBoMC10ViNWOdEPAAAAAAD4EgMgABBIMPl0VC//EFgwK3RVKoEmKnUsKIEn +JHUvKXUu+HUtIEIQeDAvdGQjVjnRD8DALHUnY/9KjSKbEZgU9YwAAEwAN2CPE/yBhBAFEFAw/vEm +IDIQWDD/8SciAABpcFhO+QUIR2iCAdEPiieMESupFCmhFQzMEay7+qwgK//13lCLE4wRWzOy0Q8A +AAD6LAAAMAJacPwsAAIAACowWzgKY/+hAABsEAYbgUcCLAkMzBGsuyuyf2Sw9fAAC29gARgwAACL +uWSw5iixGQgIS3jp8Ya6ZG/s+goAIAYQSDBtmhSmrPzAbCwAICawLdAA/NkTcAICUrDAoPAAGmAG +EGgwAAAAAAD9wwZ//xBQMMChZaBvY//gAG3aFKas/MByLAAgJrAt0Ab82UtwAgJSsIJqZCBv80wh +IOQCcbD+FgAgDAJpMP0WASA6Ajkw2zD8CgMgnAJQsFv/C8yt23D8CgMgogJQsFv/CMqmgihlL9xg +ADEAAAAA/cMGf/8QUDDAoWSvq4ZpwKD5CgYvVAC1oGP/MYoQ+xIBIAYQYDBb/vplr8fWIMlmL2AE +aPQdwCDRD8Bg9lYAIAAQEDDRDwAA9lYAIAAQEDDRDwAAgmnKLvoKACADEEAw0w9tihSiq/uwXSwA +ICKwLMAh+8kacAICUrAtITYsQRZ9wRyCK2Uvz5ZQ0Q8AAAAA/LMGf/8QUDDAoWWv5WP/2ZJQ0Q9s +EA70ft0QABBQMJoQiTQoQn77gQwQXAIQ8PRCgChwAUww+JgIBAIoEmAJiBGoRIRHC5sIK7DoJEIO +/wIAAAIcetAlTQEoUYJkhCr7PCYiUhBQMPpKCAAGEGAwWEcLH4D6wNP+8AIgCAJYcP60AiGAEGAw +//EALAAgYTD/tQAiAABTMGTRUmbRT23aFw0BMA0AMS3cNS3dAQ0BMQACAA0CMC3cASiwACmg0rGq ++7wBJgCTzhDAkCpRoMG9+cTnJBIANqD8MQsgABBIMPYqaCAAEFAw/yp3Im8QaDD+KnkqAcvi0JUV +K0KE9kYIAocQYDD6FgkgABA4MPkWDy4AIHEw/hYKLAAgbTD9Fg0gABBAMPgWDi4AIH0w/xYHIoIQ +SDD3FhEilRBQMPYWDCAAEDgw+koIDAAgYTD8FgYoACBNMPkWECACAlrw+0aEIpEQWDD6FgsqACBd +MPsWCCAAEDAwuBr7LAAAAhBgMFhGxyURBA8CAA8CAAUNSPwxCyYAIDNw9mwCJMkBLDD2Bk8CAABz +cP9cAAoBceGQ8FAEBB4AuWAHCBv/AgACAbp+EP8CAAQAyifga/Ys/hYDLgFel2D6EhAgCRBgMPzc +NAAEAliwWEaujhNgAdzTD/P+2WABEEgwAAAA+goIKACEI+D4Cn8sABZ6kP8KpyoBQGqQ/hYDKgE8 +b9D6EgsgDBBgMPzcNAAEAliwWEacjhNgAZf/AgAOAMRD0P8CAAQBKENgKRr//hYDKgEi7lDaEPwK +BCAEAliwWEaRjRAagIGOEw2PFP0NRwDUBFPwGIB+/wIADgCrw9DAmP8CAAoApupQwKz/AgAKAKHu +kI4eGIB2/BIDIAwCWLCbGfhGgiACAnuw/Mz8LuABeDD+Fg4s4AFgMPwWBCIAAFEwW97zKUKJ/hID +IAICSnApRolgAPsAAAAA/wIAAgEOG2AsEhEfgGH/RoIgDAJQsPoWCSH4Aluw/cwBKuABXDD7FgQs +4AFoMCwWEWAAw2r3KP8CAAgAWIvg/hYDJAC8m2D6EgggBBBgMPzcNAAEAliwWEZdjhNgAJgA/wIA +BgBEG+D+FgMuAKgXYPoSBiAKEGAw/Nw0AAQCWLBYRlKOE2AAb/8CAAIAZiPga/MvZNEl/hYDLgCR +F2D6Eg0gCBBgMPzcNAAEAliwWEZHwIT+EgMmCQBF8PAAOWbgATwwavQia/Ui/hYDLgB3l2D6Egog +CRBgMPzcNAAEAliwWEY6jhNgAA5o8zstQocPAgAt3AEtRof6EhEgBAJ7sP8CAAIAIHiw/wIABABL +kWAAUAQHCBv/AgACAEd+EGAAmgAAAAAAAAD+FgMiAEgbYIoX/AoCIAQCWLD7Fg8sAQDjcFhGIsCI +/hIDJgkARfDz/6Vm4AE8MABq8TRr8o1k0Fr+FgMurgC/YPoSDCAHEGAw/Nw0AAQCWLBYRhTAgv4S +AyYJAEXw8/9uZuABPDAAAGX/WM7VwIEIdwLz/1pm4AE8MADAnnl5E/8CAAIAShKgZVzwjR/K22AA +FtEPLEKFK0KGscz8RoUgAgJa8CtGhtEP+ipcIgAAW3D6SggAAhBgMFhF+ose/BIRL9AAtuBpwciN +GWTfw44VLuGuZO+72kD8EgQiAABbcFvdKi9CibH/L0aJ0Q8oQoOxiChGg9EPACtChypChSlChrG7 ++0aHIAICUrD6RoUgAgJKcClGhtEPLkKNLUKFLEKGse7+Ro0gAgJrcP1GhSACAmMwLEaG0Q8pQogo +QoUvQoaxmflGiCACAkIw+EaFIAICe/AvRobRD2wQDPQyBCIAAHkw1iDyfn8UcAEgMARECQxEEaQi +JCJ//jELIMQANSD5fYURgBBAMP4WDCgAIECwKICALJJ4lhv6koAiAABZMPUWCigAIGIw/xYJKZAE +OiD4qggAARBgMFgr1S8xCiswMScwNykwMCUwNC4wNiYwNfowMyIAAGqw+O4RBYAEPWD2IoMkCQA1 +cPiZEQ4JADuw+5kCAHACWPD3vAAATAA1oIxnjM5okSj4kkVgDhBwMGiTfWmUKmmiJ8pkmxj9FgUg +dAJ48J8eYAD+AAAAAAAAAP8CAAAB2gag+xYIIgCzAqDRDwAAAAAAAPP/uGAAEGAwaKHsaaLpGH5C +KIF//wIAAADF9hAuMDjAmH6S02rn0P8CAAYCBoegKsEXsaoqxReKG4wZ/RIKIgAAWPBb5H3RD2ih +rGmiqWRfpvsWCCAUEBgw8ADbYAAQIDAAAChwAaSE94cKCgA1KRApcAB+mewvcAIocAMqYRkI/xEI +/wL6CksPYAF8MHr50ikagKkpKZB7A5kRCfkCKWUZiRQokQ/aYPwSCSIAAFjw/RIKIAICQjD4lQ8g +ABBwMFvjHypwAfSkCAAOEHAw96cKC//PLRCGaQ8CAA8CAMtmixUqEg77sBYgBhBgMPtkFiCAAlmw +W+RD/goOL9oAtqCJZ/cSCCAAECAw+ZIOL8gANWCZFGP/WADRDwAAAAAAAPx/Qh//alqQDDMBLXAB +pNT31woKAYepECpwAGiiO/mk3mALEFgwJiKDxu/0bqliAEB08LR/nxBgAjCINggoUWSCtfrcAAIA +AGFw/ewAAgAAc/Bb5vDRDwAAACYig8eb9G51YgBATPCyepodih38CgYggAJZsFvkG2Svj4ZpZW/q +Y/5UGHzqijMSfdwogmkiImiqiAmIEagiiicrqRRksm+LqS/QBxV9Zw8PQQz/EfeyAC4AIC/wKfI6 ++gowIgAAKvD3h1cKAON2UCbyOWRhuy4gBx9+ug4uQAruEA/uAp5giCD9FgUgChBIMPx9WRCMEFgw +/GYCKYAEOiD7ZgMoCQBKMPhmASAuBFHwiieNGcDA+qwgIgAAW3BbLffVoC4gBy0hCNMP+37oHiAB +cDAA7hH+3QIAABBgMPxmBSwJAF9wnWQARY3yBh8AUAJRsPtmBiB0EGAw/GYHIKgCWPBYRPcXfaaI +LSdyaPmIEQAGEGAw+HcIAMoQWDD3Fgcg2AI58Pp8AAoAIFzwWETsihf7PD0gAxBgMPsWBiCQAlKw +WETnihcbfLgcfLYdfeZa1C6KF1rUEIsW/AoDIDICUXBYRN8rPEH8CgMgOgJRcFhE3I5R8woAIgAA +WXD6LAAADhBoMPwKoC7gAXAw/lYBLAAgYbBb+gsffbEafawYfbkdfPSTr5Ouk62TrJOrk6qTqZOo +k6eTppOlk6QjpgMjpgLzpgEiAABZ8POmACAEEHAw/oY/LAkAbTD9hj4gBhBgMP+FgCAUAlKwWES9 +GHzqihUogl0bfZb8CgQgBRBoMAuAANogWyrB0Q8AhmlkbGyKEPwKBiCQAlmwW+ObZa/qY/2MAAAp +wDixmSnEONEPAIsiZLFi/wIAD/4iUdCJJxV+hiyZFCVSf/TBQWBAAlJwi5mGsfYGRwIAAGFw+woA +IgAAabBbLY6KJ9sw/BIJIEACUrBbMMeNIIwZiycI3RENzAL8pgEgQAJS8PtcAAIAAGGwWzC/0Q8A +AAAAAAD63AACAABhcP4SDCIAAGuwW+bf0Q8AAADz/Y5gABBYMC7BFbHuLsUVY/vzZTux9xIIIAAQ +IDDwABtgCxBQMIM5zzwocAH0hAgACxBQMPeHCgoARqkQKXAAepnmZGuBiWrznAAP3gA2YPkWASAS +AmHw/BYDIBgCWfD7FgIgBAIR8Nog/AoGINgCWPBb41hlr62KE/wKAyCQAljwW+NUZa+dihL8CgYg +gAJY8FvjUGWvjY0RDwIAc9FXLtAFwvx/6YH6PAAAARBYMFvqp9owW+ov+jwAAFEQWDBb4vlj/2OI +Z4iOL4EQsf8vhRDRDwAAAADz/sFgABBYMAAAANog+wocIgAAYLBbNNnz/oxgMBBQMNpgW+thY/8p +bBAGLyEIhScmIAcTfeb4WRQgNBBgMPQ6/yAAEDgw+zK9JiABMDD0ge5gQAJRcIVZ2LD7XAAGAdUn +0IlQ+BYAJPgBSDD5CEcGAThlEP98AAYBNGYQ+QoEIAAQUDAcfHYMaBGsiC2COrOc/xYCKgEJ51Av +gjkee+v9+v0iBQA34PAOBwAYBGpw2PBtyQIASGEmIQcYfGkGBkr+fhkXwAQ5oP2xCCgJAEGwmPAY +fhaJIJf2l/iX+Z73mPX+fhEQGBBAMJjzGHxf/p4CCYAEPmD+9gQgAxBwMPj2Ai4JAHJwnvGOsQjd +EfYWASAEEDAw9pYCDuABcDD4IQgsCQB3cP22ASwA6gUgJCAHHXve9A5BBAIBIDD6RBAJAAQ/oPmJ +AgCgAkPw9aBeaAkAbnCW/Sf2ESf2Ex18Q/n2ECAwEFAwmv+JERp9mp3+/XvOGAkAJnD99hIoCQBW +cPn2DCIAAErw8gkWADIQKDAASGMACYYASGEZfDEM6BGpiCyGOYSw8ABfZPgBIDAtUBT1CjIhbAA3 +YCf2Eyf2EZb9HXwq+fYQIDAQWDCb/4kRG32Bnf79e7UYCQAmcP32EigJAF5w+fYMIgAASrAGCYYA +SGcECYYASGUZfBkM6BGpiCyGOYSgBIRX9UFmcDUQUDB6QV6MJ/36wCBAAlswDbsB98UUIIACWvCb +yfvGCCIAAFCwWtLyLiAVZODZwCDRDwCbEPV8AAYA4SfQiHAIhFf4CUcGAEblEP8CAAYAQuZQwJT/ +CgAgABBQMPP+F2AAEFgwACYhFCQhEvUKAC+XADWg+jJCIgAAWTD8CgAgARBoMFssLSgyQ/VcASAC +AiEwCEQudlnbY/9rAP8SAiwYAD0gGXu1CUkCmbDI/YonixD6rCAgAhBgMFszQIsiZb9s2iD8LAAA +MAJZsFs0KMAg0Q8AwLD8EgAgAhBoMFssiYsQ+FAUIBUAtqBlj0BgAA2NsAjdEJ2wY/4lAGSBDMCU +8/1zYAEQeDDaIFspmsAg0Q8AACf2EZb9KfYQHn0rHXtf/fYSIDAQKDCV//R7zB4JAHEwnvyU/i6h +CIWhhKD47hEE4AEsMAXuAvSEVwAyECgw/qYBIBIEKTCEsASEVwoKhgBIawgKhgBIaSggBykhB/kJ +SgoCAUAw+qoQCcAEPmD6fREYCQBWcP4hCCggAUAw+nuyGAkAVnD59hwpAAQ+IP0iAC4JAEuw9/Yh +IDAQSDAp9h8Zezoq9h739iMgkBBQMPjdEQ4JAEuw/vYgIAQQcDD59iIsCQB3cP32HSoAIFPwDguG +AEpvDAuGAEptG3uYDIoRq6ospjlj/f/aIFspXcAg0Q8AAAAAAAAA8/7xYAgQSDBsEAwoMQgae+0p +Ov//AgAGAFTOEPAKFwIAAEhwAAmKAAmKAAmKAAmKAAmKAAmKAAmKAAmKG3r/HnsUiCAaevz6FgIg +BBBIMP4WBimABDog+xYAKAkASjCYES8gBy0xCA8PQQD/EQ/dAg7dAp0UDOow/BYFIAAQWDD7Fgcg +QAJIcAIDhgBJYwADhgBJYYsn/LkULYAEPWD+sgksCQBtMP+xFSBAAlLw/RYJICYANyD04B5ggAJD +MHj7BtEPAAAAAAD7HAAABBBgMFsvRtEPAAAA+iwAAgAAWHD8CgQgAhBoMFsoAdEPAAAAbBAGHH0J +hTX+MgQgBRBQMPh67hAwEFgw9YZLBOABLDD1FgAu+AF0MPjuAQIAAGmwWEpvGHrCKYJwKIKAppb8 +fPsXkAQ5oP8gBSYAIDIw/WAFIAUQUDD+YgogMBBYMFhKZMKT/wIAACUQWDD/AgAGAE5NUP8CAAAk +EGAw/wIABgBGXVD/AgAGAEJlUP4KcCwAPgFgLWAFftFxLyIZiGhk8G75IAQgcQA2IMF3/WIOIGwA +NmDI29pg+2IPIAEQYDAL0ACLJ2SwWfwKFiAlADVgfFEdaFMad1EX+iwAAgAAWPD8TAAAAhBoMFsd +kcAg0Q8A+mIIIAAQWDD+CnEgABBgMP5kBSACEGgwWx2JwCDRDwAmJhlj/4qSaGP/jSckBGP/kVsi +B48gn6CaJ2P/mQAAAGwQBPUkAyAAEDAw9EkQCYAEOOD5CgEoCQBKMPYkACgJAEow+CYBICACELDR +DwAAAGwQBBt6fBp8svl8shAAEGAw/igRAAUQaDD6iggAARBwMPs0AggAIEow9IYAIAAQeDBbLO7S +oNEPbBAEIyRy+iwAAAEQWDBbMCvaIFswuNKg0Q8AAGwQBIoqcqYO+HrWEAAGrqAIqAKYKtEP0Q8c +fJodfJsrIAX5CnIsAEBisP3MAQBwEGgw/CYKIcIESvB9sdn6IgggABBYMPwKACACEGgwWx1L0Q8A +AGwQCCQiGRx8jPMgByAFEFAw/0IIIAEQQDD9QAQk4AEsMP5CACH8AjFw//IAIiABHDDzFgAmBQAy +MPYWASAwEFgwWEnp+iwAABAQWDD9HBAiAABg8Fs1BmSgixx8eIsgwNH9pAkqCQBm8JugGnowDDkR ++BIEKAAgVnCYkPsgIiIAAFCwWyqkjkr7CnIgdBB4MPpABSAAEGAw/CQjIEgAC7B/oRxoUjuKJ8Cx ++qwgIAEQaDBbK1PAINEPAAAAAAAAAPwKcCA8BFqwfKEW+kIIIAAQWDD8CgAgAhBoMFsdE8Ag0Q/A +INEP2iD8fFYSAABZsFs0wsAg0Q8AbBAGHHxS/SIAIgAAeTD+IAQgBRBQMPUWACAwEFgwWEm0HHxL +LTIELjAXLzIG+DIHIAUQUDD4FgAgMBBYMFhJrCkgBMGn+yAiIK4EUnDIuNogWypywLArJCMqMAX7 +CnYgdBBgMP0KdyCABGKw+tIucAAQEDD+CnIsABNakP8KcCA8BHKwf6EW+jIIIAAQWDD8CgAgAhBo +MFsc5sAg0Q/RDyMiGWP/pgAAKzQF+yQFIAAQEDDRDwAAAGwQBCQiGR96Ao00HHwk+goFIDAQWDD+ +MBcsAEB/cFhJhigwF8KaeYEX+yAiIgAAULBbKkzAoPokIyIAAFEwW/9vwCDRDwAAAGwQBCQiGR95 +8I00HHwT+goFIDAQWDD+MBcsAEB/cFhJdCowFygKJf8CAAAkEEgw/wIABgBBxpD7ehEQ9gRKsClC +CiYKI/0KFCAfECgw+5wCAA4AhnAsRgr/QAUgdBBAMP2hZHAeEHAw/qFkcAMQYDB1oUz2oUl//xBg +MHjxEY1OyNz7Qg8iAABRMAvQACowF3WhInahHx176IlK+iwAAAAQWDD9mQEAABBgMPlGCiACEGgw +W/9VwCDRDwAAAAAAAPP/t2AEEGAw8/+vYAIQYDBj/6cAbBAGIiIZZCBwHHvfiCiNIC8gBY6A+IAF +IAUQUDD4FgAgMBBYMFhJPS4gBSkKc/oKdCCYBEuw+wp2INQEU7D8CnIgSghbsP0KcCA6BGOwfeEV ++iIIIAAQWDD8CgAgAhBoMFscfi4gBf0iACAFEFAw/HvHEDAQWDBYSSnAINEPjS6PKC4KdS4kBf70 +BSARADdg2iD7Ig8gARBgMAvQAC4gBWP/wwCJKCgKdygkBSiUBS4gBWP/sQAAAGwQBCggcsCUCYgC ++CRyIgAAULBbL7vSoNEPAABsEAodeWQsIA0be6wmIAcqIAz5slAm4AEsMPTAz2YgATAwHnp6rq4u +4OUq0nms7q6qCaoRqpoqrID6FgoiAGAB4Igi0w/TD2WA5ymgDfoKACBEADZgGnuZKqCAGHlc+3lw +FYAEPqD1Fgkk4AEsMAhVCihSmAuqAQuAAAoJQWiRB/8CAAIAfh5gKFKeihkLgADMoWAA1hh5xQxl +EahVKVI69BYIJABkQmAkUjlkQL3Iq4ow+gpDABACWPBayfnaIPtMAAIAAGDwWy0mwLT7VjkiMgA5 +4IonjRjAwPqsICIAAFtwWypf0qDRD8Ag0Q8r0niqugmqEfP/QGoAIFJwjCf++sAgQAJrMP7dAQAA +ECgw9cUUIIACa3Cdyf3GCCIAAFCwWx9XLyAE+hIKKf+LG+BgAFdocgPAINEPiifAsPqsICADEGAw +Wy2DHXn7naCMIBt7XPjMEQADEGgw+6YCLAkAazD8pgEgABAQMNEPK2wY+iwAAgAAYLBbMdVj/7QA +AADz/wxgABBQMAAAH3kD/CEJIgAASHDwDwcAAhBwMG3qAgBJYRl7SPscAAAGEEAwbYoRjbf+nQQh ++AJa8P3mACAIAkpwG3lL+XtAEAYQeDAPAgDTD9MPbfoP+LIHIAgCSnD4lgch+AJa8B17Nxl5Jvt5 +XxgJAE8w+db/I+gQYDCwzMjELtL/frj1JSQFY/4yAABsEAj7ejgQAhBoMJ0RmxCPMg8PXy8VBC4g +DCwgDQjuEQ7MAiwVBSkhCZsQ/RYBIgAAULD5FgMgIAJAcPADFgAAEGAw8AigAgAAWHBb/2nRD2wQ +BBh5PdMPCEgKKIKc+iwAAgAAWPALgADRDwBsEAb2eOYRGBA4MAcnKNMP93sQFgAgObAjZugPAgAn +cn/7ewwSAABR8FhKbPW8AAIAACKw+wpkIgAAUPBYSmf8CgAgZBBoMFhJpdpA/AoAIgAAGvD7XAAC +AABo8FhJn/+xMWIAAHLwGXmvAigL+nmAGbAEOiD8evgYACBKMCyGxfpm6iACEEgwKWbpK4bBK2br +0Q8AkxAcevGbEx944xt44v15cxADEFAw/RYCKdAEPeALmSz9mSgAIBBYMPkWASIAAGiwWEhBHHjY +HnmWAi0L/3loHbAEP2D4euAcACB3cCjWxf9m6iACEHAwLmbpLNbBLGbr0Q8AAGwQBvR4qBEYEEAw +CCgoqEQqQuf6RugiAABY8FhKMvwKACBkEGgwWElvFXrLJVJ/07D7esoSAABRcFhKKvwKACIAAGjw +WEln/7ExYgAAcvAZeXcCKAv6eUgZsAQ6IPx6wBgAIEowLIbF+kbqIAIQSDApRukrhsErRuvRDwCT +EBx6uZsTH3irG3iq/Xk7EAMQUDD9FgIp0AQ9YAuZLP2ZKAAgEFgw+RYBIgAAaLBYSAkceKAeeV4C +LQv/eTAdsAQ/YPh6qBwAIHdwKNbF/0bqIAIQcDAuRuks1sEsRuvRDwAAbBAGKTAIGnhU/PrqIgAA +IXD1eP4QRQA2YGiREvpMAAIAAFjwWEcfwCDRDwAAAACJMAqaAfwSACBcADagKjAJZKBh+KFWb+oQ +YDD4+uoqAEAqcPP/xmwFAFIwiTD6mgEAMAAqcCowCWSgWfihTm/qEGAwY/+mAAAAeZa4KzAJZb+a ++zwIIgAAULBbJNLz/4xiAABisGP/sgAAAAAA8/+qb9oQYDD7PAgiAABQsFskgYkw8/+VYgAAYrAA +AADz/1xv2hBgMPs8CCIAAFCwWyTI8/9JYgAAYrAAbBAEHnm+L+JaKeJvBVoC+zwAATEAN+AJyVNk +kSb/AgAAAIseYI0gKTIAI+Kg9QogIBAQMDD34qUgARAgMPPTDAAAWapQ+CEaKZAEP2D5elgWACBN +8C1yCiyyAyJyC/SAKmwAQE9wf8cFGHh1CN0Ce8cFKQqACd0CfMcExIAI3QJ9xwIF3QJ+xwIG3QL4 +Ov8pMAFkMPiRDXAAEGAwfzsSYAARAAAAGXhAwMH53QIKAAN80MBwGHjPw/ovhhAihhHDmymGEC2G +ERl5aoiAH3ka+YgBCYAEPOAJiAIFiAIPjwIM+DkZeMP4lgAgCAA14J16knuJsB933XmWPC/yey3i +paP/Cf8Rr92N2g0MWQDMEQTIAv2MOgAOAGNwBswCedcEwIgIzAJ61wTAlAnMAnvXBMDSDcwCnLPA +wFhGpMAg0Q8AAAAA8//xb7kQYDBsEASJMPpcAAIAAFjw/HoWEFAAqnB5lhePwIjBmLOfso3CjsOe +tZ20iMWJxJm2mLfAwFhGk8Ag0Q8Zegwpkq5xlgfz/+xvuRBgMIkyCclTb5It/xoMIEoAPmCJso2z +ncGZwI+0iLWYw5/CjbaOt57FncSJsGP/nQAAAACOM3/o2fP/rm/qEGAwbBAEGXi3GnkSGHhk93gY +FyABEDD6ZgIAABAQMPaW+yAKECgw0w9tWg0qkvsIqwH3sQhwAgIQsMcg0Q8KrUn9NgAtIAFQMPxG +ACAAEBAw0Q9sEAr9d5ASAAB4sCzwDfUWBSIAABDw+/AMIegCM3Dz0oAjdgA3IBp4paq6KqDlKdJ5 +rKqqmQmZEak5KZyALZETLpESLPEa+yEELgAga7D0wB5h/gJzsGSzucKA/wIACgHaXhApIQWrmf8C +AAoB088QiyD0eIcQAL0q0CohBZ4U/RYDJBgANqD4CgEgABBIMPyJOAAAEFgwCYs4+RYGI4QANuAq +IQUn8RkjIQT6dwgAIAIosPcXEgIBxX6Q9goUIAAQYDDAoP8WAiIBccDg8xgUAgAAePBtiV2JUABg +BAkDGfRg7mMgARwwJmz2AGAECQsZ9GDpayABXDD2bPYqAHXu0P8CAAoAcd+Q/wIACgBt7ND/AgAK +AGmfkKep9rgRCMAEPmAJiAL//P4oCQBA8PhG+yACAlKwmxGTEC4WBP0WAyABO4fgjRaPEvsKASAA +EFAwDbo48hYHIikANqCLIPIWByABD6bQJiEF+woAIrAANaAu8RryFgciCQA3oB13qB538xl4nyMh +BC/xGSghBfsmBCAgAjiw+yUELgAgN/D/FhIAAPd+EA8aSfmqAgAKEEAw+kb7IAAQeDBtig0sQvsO +yAH9gTJwAgJ78PAAPW/wEGAwtFWJUPP/EWAUEDAwtFX2ChQr/47q0JsRkxBgAiMA8/9qYAAQYDAM +qkn6FgApIAFkMPkWASAAEGAw+Xh9EAICMbDyFgchagC3IIgR/IgQAf4CGPD4dgAgChB4MJMZ+goA +IgD+wOCLEYMQhRmWGJIXYABbAqNJ8xYAKyABFDD7FgEgABBgMIgXZcEkKYEEspkphQSJcADxBAA4 +GgiZAvl2ACB1ADfgL/z28PEEAfwCKXDwuBoAAgJSsPl4XRgJAEJw+HYAIGoAN+Av/PZuUnQsEggM +rAgMDEn5zAIAChBAMPxG+yAAEGAwbYoVIkL7DiYB/wIAAAICYzD/AgAH/7ttkP8CAA/wEGAw/wIA +B/+zbZBj/3EAAAD/CgAgCAI58P92ACAAEEgw8/9+YBQQeDAZeED4CgAgCAI58Jhw8/+MYBQQeDBp +UWiCF4gYHHg5CKgICAhJ/IgCAAAQWDD4RvsgChBgMG3KDSxC+w7JAf2REHACAlrw8AAbb/AQYDAA +AAAADKtJ+xYAKyABYDD6FgEgABBgMPIWByAYALcgjhCNcADxBADuGvIWBywJAHdwnXCKFYsXWEWI +wCDRDwAAAADz/plgFBB4MCnSeKuZCZkR8/yZaAAgTPAAAAAAnxKeFP0WAyH+yJzg96cIAgAAWHD6 +fAAACAJgcFv++YNQAGAEAwMZ8wNJAgAAYrDzFgAhGQC2oCg6/3gxE4kT/wIACgCEzNCLFP8CAAoA +f57QjRH8fhANYAQ/YA7dAg09Ai1G+2P9MZIX8/9ob+oQYDCbJGP9Tp8S8/0dYAAQYDAAAAAA8hYH +If+mnOCWGJIXY/7YAACfEp4U/RYDIgAAUfD8HAQiAABYcFv+1o0Ti1COFI8S+0tZAgAAYrD7FgEg +dAC2oH2zbHvjaYYQ9rkRCMAEOeAJiAL4ZgIB/gIY8PZG+yACAjnw8/wsYAoQMDCK8Chifo4k/xYC +K5AEPqD/eLsaACBc8Iy6wND4qgwPNAFwMPDuEQwAQHsw+7ILLAkAczBYBwKPEo0TjhQs8Rpj+6kA +AADyFgcv6hBYMAq6OPP+kmIAAGKwAAAAAADyFgcv6hBoMAraOPP+emIAAGKwAGwQBIkiDwIA+cVQ +AgAAQLD51lAIPgFMMBR4nvSUCgYwBDmg8kKEIiAEPmD0VxACCQA08AczAvIPRAAASCCQAoVE/YIA +JYAEPWAF/wLz+vAuCQAf8PIuVAwAQB9w/4YCLAkAd3CdgCxCiPZ4ihWQBD5g/A1YAAAQEDD8DE0M +4AQ/YP3MAgAcEBgw/IYDIgAAIjBtOhT1IwoACAIhMPYzCAACAhCwIzKAk0PyCgAgHBAYMG06FfUj +CgAIAkIw9jMIAAICELAjMqAjhh/AINEPAABsEASFIowgHXhu8iIDIgAAQLD8DEMIPgEsMPXbUAoc +ASgw9YdEBbIBEDDyAk0EgAEsMCPSgPZ4YxAWAHjwxirRDwAAAP533ROABD3g/s8QAgkAHXAPMwL9 +nwoCCQB08CP2hPQKAC8ABDkg+ZcRDgkAcLD+9oggJAA24PKMAAAcEBgwbToUgyT3RQoACAIQsPZV +CAACAiEwI1aA8goAICgANqAkCgDzChwnkAQ+YG06FSOCIPdFCgAIAkIw9lUIAAICITAjVqDRD2wQ +BCkyAA8CAPqeGHAAEGAweZ4i+lwAAgAAWPBYRLnAINEPAADaMFv/xIkwDwIA+ZbhcgAAYrDaMFv/ +i/P/1GIAAGKwbBAEKyEE9HgrEAEQODD1CgAgABAwMPv5QAAEEBgw++pADA0BXDD7jEQKJgFcMG06 +FS5ChPjmDXAIAiEwAFEEAH8aD2YCsVUeeBtkkIIj4oB+P3dkYHT1eBcQLAA2oCcKAPh4FhAEEHgw +bfoZI1KIwU/zA00ACAIpcPdEDAoAA5oQdG1GsXcUeA4s5owVeA4jIQUFtQLwVREAABAQMPJGgiIJ +ACzwI0aDJeKA//r4KeAEO2D/lhEEAEB9cPhmAgQJAC6wBlUCJeaA0Q/GKtEPACjigMe9/5oRCABA +WjAKiAL45oAgABAQMNEPAABsEASIMPuOFnAAEGAw+lwAAgAAWPBYRG/AINEPAAAA2jBb/7zz/+Vi +AABisGwQCIkw9AoAIAAQQDD7MgMgAE0qUCogDPqs+SABEEgwCpQ4BJg4ZIBx/HfhEAAHsuAswX// +AgAAAHR3EI41jzT5MgIodAFYMPgWAyp4AVgw+hYCLB8BWDD8FgEiAABQsPx2lRb4AXQw9xYFJvAB +cDD2FgYm8AF8MPcWACfgAXgw9hYEL+ABcDD/j1cMAEBm8PycAQt0AUwwWESB/goBIAAQaDAE7Thk +0GKJMHmWXSkhEogrDJkQCYgCmDIuIGAvIGGNLvz/EA6ABDugD+4C/CEHLAkAd3CdMysgVPohLCxs +AWAw+MwQCwAEPuAMuwILqgKaNCggICkgIS8iEfiZEAkABDogCYgCCP8CnzXAwPpcAAIAAFjwWEQk +wCDRDwAAAPP/6m/qEGAwbBAG+XX5EgAAMPD3MgAgABBgMPUORwABEGgw+AoIK8AEOSD5dwEIADTW +EPUWACQAIBqw9BYBIAAQKDD+1TgAEAIg8ItiC4tXb7VUy7EYd48IuAqIgPosAAIAAGHw/VwAAgAA +WTALgAD8rAAAEAIxsPWgDGAQAiEwiREPAgB5Q8L6EgAiAABY8FhD/cAg0Q8AlRDz/+pgABBgMAAA +AAAAAPP/3G/qEGAwbBAEFHUcKEJ8JEKAooIJIhGiQqIyIiBE0Q8AAGwQDPMyACIAAFDwKyETLiAN +AwxPC80M/tw4AvABHDD4PAlqACBm8MYq0Q8AGHdX+XWAEFEANSAUd2UEtAL0hv8j6BAgMG0ICrBE +ZEC2JoL/dpACY//uEndM8woGIEACIHBtOhHzLQQh+AIhMPMyACAIAhCwk0iIH/imASAAEBAw0Q8A +AGRQd9QQ/KIBIgAAEjD8FgcgBhAYMG06EfMtBCH4AiEw9UIIIAgCELCVMBN1QRJ3Nhp3SR13Rx93 +RYY0jDWONoQ3lCie+BR3RB53RY8znNiNMpaon0id6BZ3QvI66CYJADLw9ob/If4CELDJJieC//eY +93H+AhCwwCDRD8cv0Q8AxyvRD8cr0Q9sEBQsMgAoIRMrIA33dxwZ4AFkMAiaDPupOALwAWAw9CAV +aAAgSjAWdy0adMn5dT0QAFQEoGgiB8Yq0Q8AAAAA8hwAD/QAtSAddyaEMQAKiwBCYQBCYRp3Hhx3 +HJ0UixT9EgUiAAAR8P8SBi7gBDkg/hYMIAYQGDD+dxQQQAIgcA8CANMPbToR8y0EIfgCITD1Qggg +CAIQsJUwEnb5FHcJhReVKJ9IhRMUdwuPEp3om8iVqJ9I8jroKgkAMjD6dv8h/gIQsGQgjyty//uY +9nH+AhCwwCDRDwAAZU9bhDEACov8CgIggAIQcG3KAgBCYRJ24/McYC+ABD0g/xYcIwAQcDD+FhQg +BhBoMG3aEYQ39S0EIfgCGPD0VgAgCAIQsBJ22PoKBiCAAhhwDwIAbaoP+zIHIAgCELD7Jgch+AIY +8AaMAvx2/yPoEBAwsCLIKy1y/32QCmP/8scr0Q/HK9EPwCDRDwAAAABsEAaKMAoGV/9jHWATEGgw +ZUFs2zD6LAACAABhMFv/ntOgZTFc0jDRD3bTc/oLTwrgAT2g/wIAABEQQDD/AgAKAEQFoP92zhYA +TcWQ+QoSKgCtN1D/AgAKAKlNkGVBSvjyayC1ADVgjC8uIA38ugwCAABK8A6pOKnMCMwKjMBkwSuK +Mf8CAAYATO2Q/wIAAABYgqAqxBbAoPP/hmIAABqw/wIADABuGaD7PAACAABQsPxMAAIAAGlwW/80 +8/9jYgAAGrAAAAAAAP4gDSB8ADUg+SEIIJoAN6ArIRMLmwybMWP/sokvLiANKvJrCbwMDss4q5kK +mQr5kgAgYQA1IPmRCCBxADegLSETDZ0MnTFj/4QAAAAAAAAA8/98b/8QUDBooFQuwAct8o/78pMu +IAFwMK7dCd0RrburqiqgRGP/UvP/T2D/EFAwLyETiDEPiQwOmDio/y8lCGP/OiohE4sxCrwMDss4 +q6oqlQhj/yeZMWP/IpkxY/8d8/8XYP8QUDDGOhx2fy4gDS0gDPQWACIAAHmw9RYBIAIQUDDzFgIg +EhBYMFhDvdIw0Q8uIA0cdnUtIAz0FgAgAhBQMPUWASIAAHmw+xYCL+oQQDD4FgMgEhBYMFhDsfP+ +vm/qEFAwAABsEAQWdCMiMgAXdmf0QChiAEAwsBR2Z3J7BRh2ZHKLH/QkCAC5EEgw9nZjGgAHSRAG +RgqGYApgAMlVxirRDwAAGHP2qCiIgPg2ASAAEBAw0Q/HL9EPAAAAbBAEHHZXizD9dAoQ/xBwMPl2 +VRAyEEAw+wpXAgAAMLD4qwxwABAQMAmpComQCpAAxirRDwAAAABkQzcrYCEqYCAIuxELqgL6NgEg +ABAQMNEPZEN/KmB2/wIABgIu9pDZoPk2ASAAEBAw0Q/7dUIQARBQMPlgDSMmADUgZJOlL8LEjmAP +7gwOVBQORBEE1AwkTQf0QgwogAF0MACRBPCoGgIAAFiw/HUxFABAQTD0pDkCAABrsPoKBSIAAHEw +WENo9DYBIAAQEDDRDwAAAAAAAABkT1soYA1kg3fyNgEgABAQMNEPZE9IKWANZJN68jYBIAAQEDDR +D2RPNSpgDWSi7/I2ASAAEBAw0Q8AAAAAAGRPHStgDWSy8fI2ASAAEBAw0Q9kTwosYA35Yg4jTAA3 +ILCd/TYBIAAQEDDRD2RO8C5gDWTjQvI2ASAAEBAw0Q9kTt0vYA35YRIjOwA34LCY+DYBIAAQEDDR +D2ROwylgDWSTMvI2ASAAEBAw0Q9kTrAr0qEq0qCrqrCqmjHRD2ROn4xnjM4swSKcMdEPZE6RLtKg +njHRD2RB3yhgYC9gYQiIEQj/Av82ASAAEBAw0Q9kTm4pYFQLi0f/AgAKAMLO0Mev+jYBIAAQEDDR +D2ROUYtni76LvZsx0Q9kTkQuwlQtwlOu3bDdnTHRD2ROMy/CU58x0Q9kTikpwlIowlGpiLCImDHR +D2ROGCrCUZox0Q9kTg6LZ4u+LLIQi7+su7C7mzHRD2RN+oxnjM6Mz5wx0Q9kTe2NZ43ejtyN267d +sN2dMdEPZE3ajmeO7o7rnjHRD2RNzY9nj/6I/o/9qP+w/58x0Q9kTbqIZ4iOiYqIiamIsIiYMdEP +ZE2niWeJnomZmTHRD2RNmopniq6LqIqnq6qwqpox0Q9kTYeLZ4u+i7ebMdEPZE16jGeMzo3GjMWt +zLDMnDHRD2RNZ41njd6N1Z0x0Q9kTVqOZ47uL+EpLuEor+6w7p4x0Q9kTUWPZ4/+L/EonzHRD2RN +N4hniI4pgScogSapiLCImDHRD2RNIolniZ4pkSaZMdEPZE0UimeKriuhJSqhJKuqsKqaMdEPZEz/ +i2eLviuxJJsx0Q9kTPGMZ4zOLcEjLMEircywzJwx0Q9kUMnaYFgXKi1gDAjdEf4KgCwJAG6wDt0C +/TYBIAAQEDDRD2RQpo4xLmQgDo4U/mQhIAAQEDDRD2RQkY8xL2RhD48U/2RgIAAQEDDRD2SRHy/C +xI5gD+4MDlkUDpkR+dkMBGQQWDCrmfiSsy6AAXAwAOEEAKsaC4gC+JazIAAQEDDRDwBkUEUpMgFo +kAIJngL+ZHYiAABRsFsfn8Ag0Q8AKMF8ZI0JKsF1KcF0qpmwmfk2ASAAEBAw0Q8rwXxkvQctwXT9 +NgEgABAQMNEPxy/RDwAAAC1gDC6wgADQBP4OGwAFEFAw/gJAAgAAWLD8dE4SAABwsFhChvI2ASAA +EBAw0Q+PZ4/+iPOP8qj/sP//NgEgABAQMNEPiGeIjoiC+DYBIAAQEDDRD4pvqaqwqvo2ASAAEBAw +0Q+Lb/s2ASAAEBAw0Q8sYROpzLDM/DYBIAAQEDDRDy1hE/02ASAAEBAw0Q8AAAAAAADz+6Vv/xBI +MChgDC6wgACBBACvGg/uAv60gCAAEBAw0Q8AAABsEAYlMAonMAscdSD2MAggBRBQMPQxAiAIEFgw +9BYAIgAAaLD+bAACAAAhsFhCVRtzGcCg+2sLACcAtWAsson9EgAqAA5l0P/bYW/1EBAwLjEC+jQJ +IAICc7AuNQLRDyiyiNogDwIAC4AAy6L0YRlwABBQMCQ0CPo0CyABEEgw+TQKL/UQEDDRDyswC8DA +/DQKIAICWvD7NAsv9RAQMNEPsWRpR8bAINEPAAAA/WwAAAEQUDD8dPcQCBBYMFhCMccr0Q8AbBAE +/3KCEDIANSCLMPl08RD/EGAw/nTuEAAQEDD7ClcAGBBAMPmpCgoABkKQiZAKkABkQdbGKtEPZV/O +xy/RD2RP8SriOZox0Q9kT+cbc2crsICbMdEPZE/akjHRD2RP05Ix0Q9kT8ws8hkLzBGcMdEPZE+/ +nDHRD2RPuC3iOp0x0Q9kT64LiUdkkY1pkaUp4o5mkdyZMdEPZE+Yx++eMdEPLRrg9f32L+cQUDD4 +ChQiAABhcG2KDynBdAqZAf2RC3AEAmMwsSIi+trRD2Yv9/RBXGjoAVwwEnMq9AoBINEAtmAFWwIs +CgD+IoQgFBB4MG36DyixdAqIAfu8AiYApm4QsczwAUJv+xBgMGRPJSvipCniPiriQwuZDPiqEQnw +AUwwCpkCmTHRD2RPByzil5wx0Q9kTv0t4padMdEPZE7zkjHRD2RO7JIx0Q9kTuWSMdEPZE7ekjHR +D2RO15Ix0Q9kTtCSMdEPZE7JkjHRD2ROwivyaSrixQm7EauqiqdkoKEqrCBbHuIKTBT8NgEgABAQ +MNEPAAAAAABkTpdYEkr6NgEgABAQMNEPAAAAAAAA/wIAAf9AnmDbUP0qQCAAEGAw8iKFIBQQQDBt +ihApsXQKmQF9kST8zAEgBAJa8CryfCnixQmqEaqZKZBkwKEJqTn5NgEgABAQMNEPAMAEAgsZf7fZ +8//pYAIQSDAcdFQswq5xxk8i+rnRDynijWaQTZkx0Q8q4lTz/1dh8AJSsABkkEL/AgAB/v8eYPoy +ASABEFgwWAes0qDRDwDABA4NGf0NQAACEFgwDUs5+zYBIAAQEDDRD4oxWHZIwCDRD9KQ0Q/SkNEP +ijFYAqbSoNEPAGwQBBN0VSUygBRy6fMyfyQAICCwJUaAI0aB0Q9sEAQWdE/1ceMQABAgMPgKACAB +EDgw9mF/IAoQGDBtOicAQAQGCRv/lxRwAgIhMCtQMACxBAB6GrCqmiBgAAGYIPVcASAIAhCwwCDR +DwAAAGwQBBZ0PNMPLmGELWF5FHID83Q5EAAQQDDycxIcACB3cPkKgCwBACdwbZoV8okRC5AEOiAJ +qQL5iQIAAgJCMCk2Ti8igfV0LRDmACfwKCKB/wIAAABFrhAqIor6ClUAEhBIMHqTWRp0JvwKACAA +EHgw/NsRAAEQcDD+uwIAEBBoMPs2TSACEFgwWyQp9qBsYgAAErDAgPRlhSCAEEgwDwIAbZoV8okR +C5AEOiAJqQL5iQIAAgJCMCk2TtEPwCDRD8Ck/HQQEAYQWDBYQUIsIoEFzAH8JoEgABAQMNEPAADA +pPx0CRAGEFgwWEE6LSKBBd0B/SaBIAAQEDDRD9EPAABsEAQUczIiRpYjRpfRDwAAbBAEFXMuAkkU +KVaRJFKSAghDD4gRAIEEADYa8IEEAAMQODDwdxoP/xBAMAh3AwdEAQZEAiRWktEPAAAAbBAG0jCJ +IBRxc/mWTnIAABlwGHPEKIKu/wIAAACaBhDAUChBqClCU5kjKCUIL0GpLyUJLkGqLiUKLUGrLSUM +LEGsLCUNK0GtKyUOKkGuKiUQKUGvKSURiSBgAAHAUHqWIYojK0JTerQJ8AAWb+oQKDAAACxBqCsh +CPpGUyQAC9sQwVbaMPssAAIAAGFwWEAqwCDRDy1BqStFqCohCdMP0w963NwuQaoqRakqIQp67NAv +QasqRaoqIQx6/MQoQawqRasqIQ16jLgpQa0qRawqIQ56nKwrQa4qRa0qIRB6vKAsQa8qRa4qIRF6 +zJQqRa9YenYcc7MoQa8uQasvQagqQa4pQawrQaotQanwmRELAAQ6oPC7EQ8ABD/g/0GtLAkAf3D7 +7gIICQBSMPoKBCAAEFgw+BYALgkAT/BYQNNYEWD2rz9iAAAqsGABmQAAAAAA9nOeEAEQODAnRan3 +c5oQAxBAMChFqihFq/Z25SAAEDAwJkWoWHt4KyIBDwIA/wIAAAB/ktD7ilIK8AFcMFh6XPahSWIA +ACqwK3KOKyYKKnKPKiYLKXKNKSYJWHpQKnIZ+woCIR8ANqAccSgswNF+x3kmRa0ocsQdc4IqQa4f +c38uQascc4ApQa//7gEKAEBqsP5FqyAAEGgw+kWuKABAZnD5Ra8gqwA2IPxzdxAEEHAwbQgzL0J4 +KkKAr98J/xGvqimhLwyZAfkITwACAmtw+aUvIA4AWjAupToocsQmpT72pTYqADNDUGP/xRlw4/8C +AAv+8FZQK3JMGnDf/wIAC/7pXpArQjL6CgAtxwA24C1CeCxCgG0IFK2uCe4R+qwBLgAgczD25TYr +/tTakGP/5PoKBSAAEFgwWHod968bYgAAKrBYpr1j/ekAKUGvKkGue6cQK3azK3a0+3ayIQAQeDAv +drV/lxX7drAgCBBIMPl2ryAgEEAwKHauY/1UJkWvY/1OLHJMZc7eY/7kAFimqmP9nwAAWHfC8/2X +YgAAKrBsEASIMBlxKIwx/SAMKPgBQDD5iAoCAABQsPiCSCIAAFjw+N0RAAUQcDD8DEcMCQB3cAuA +AIkxiiL7IA0o6AFMMPkJBgA7ADagHHCmy0ApwoD6IAwgLwA24B5xwK6uLuDlLcJ5q+6u3QndEa2d +LdyAjdeN3pTQ9dYBL40QEDDRD9KQ0Q8vwniq/wn/Ea+fj/eP/pTw9fYBL40QEDDRDwAAbBAMFHCR +KyAM+iANIgAAMLDwBAcCAABIcABJYQBJYQBJYQBJYRdw+Blw6B1w6fUKACmABDrg9RQRLcAEOOD8 +FBAoCQBCsP0WASgJAEowmBD9IAwo+AFAMPeICgIAAFhw+IJIIgAAULD43REABRAQMPLdAgAEEGAw +C4AAIxIBDwIAA4NHAwMGZjH1IhEE8gJLAgAAUbD8CgEiAABYsFgeyPAEBwIAAEhw8AmgAgAAKrAA +SWEASWEASWEYcModcuT/cYQSAABYcP8VBCGAEHAw/hUFIAEQSDD5FgEgABBgMP0WAygJAECw+BYA +IAAQaDBb/5z2oaNiAAAasPAEBwIAAEhw8AmgAAUQcDAASWEASWEASWEYcLf5cs4QARBQMJoR+RYC +KAkAQLCYEP1QDCj4AUAwB4gK+IJIIgAAWHD43REAARBgMP7dAgIAAFFwC4AAgxEDg0fzAwYCAABI +cPYxUmAFEHAwAASLAElhAElhAElhAElhGHCh+XChEAEQWDD7FQQgABBQMPoVBSAEEGAwnBH5FgQo +CQBAsJgQ/VAMKPgBQDAHiAoogkj43RECAABRcP7dAgIAAFhwC4AAgxEDg0cDAwb2MQRiAABIcAAE +iwBJYQBJYQBJYQBJYRhwiRlynfkWAyACEGAw/BYBKAkAQLCYEP1QDCj4AUAwB4gK+IJIIgAAUXD4 +3REABRBwMP7dAgIAAFhwC4AAgxEDg0cDAwb2MMBiAABIcAAEiwBJYQBJYQBJYQBJYRhweBlyh/kW +ASgJAECwmBD9UAwo+AFAMPeICgIAAFFw+IJIIgAAWHD43REABRBwMP7dAgABEGAwC4AAgxEDg0cD +AwZmMH/RD41g+goCIAAQWDD8cnQSAABw8Fg/mdIw0Q+NYPoKAiAAEFgw/HJvEgAAcPBYP5PSMNEP +AI1g+goCIAAQWDD8cmkSAABw8Fg/jNIw0Q+NYPoKAiAAEFgw/HJkEgAAcPBYP4bSMNEPjWD6CgIg +ABBYMPxyXxIAAHDwWD+A0jDRD41g+goCIAAQWDD8cloSAABw8Fg/edIw0Q8AbBAE9CBcY/ABFDD0 +CiAgIQA04AKIV8qBAslTypkC6lH0oC9h/gJZMAK0O9JA0Q8AACIR8//cYBAQIDAIIhHz/9Zh8AIh +MAAADCIR8//OYfgCITAOLRH8TP0h/AIRMA3CO9EPwCDRDwBsEAQScVsiItjRDwBsEAQScVgiItfR +DwBsEAQl+sAFJQEkURX1CsAkACApMPMmASQAICkwlCDRD2wQBBNyLvlv5RAAEGAwLDb2LDb0LDby +LDbvLDbkLDbiLDbeLDbdLDbYLDbWLDbRLDbMLDbLLDbKLDbQLDbcLDbu+TbSLAAQcDAuNukuNuv+ +NvEgPxB4MC826P826i//EBAwIjbN8jbTIAYQaDAtNt/9NvUgHhBYMPs2yCAaEFAw+jbOIAMQQDD4 +NtQgEBBIMPk27CP/EEAw+DbwIBEQUDAqNuYbcbL7NuUgGxBoMC024BJw9R9yAy822fI21yABEHAw +/jbaIA8QEDAiNvcccf0sNuPRDwAAAGwQBBdvjfZx+hXgBDygp1fzdgAkACA1cCRWf9EPAAAAbBAE +GHBGiIAZcfPzcEQYAEBKMPgiAgAQECAwBCIC8jYAIAAQEDDRD2wQBBhw/xlvWSaCWhpwOimSe/eC +pSoACTCQopkJmRHwAAdmACBN8ADAcMPKLKYQI6YRw7srphAkphEbcM6KoBxwfvgtEQoAQFqw/aoC +ACAQWDALqgIMrAIFyjkbcCbAIPq2ACAKADXglHqTe9EPwCDRDwAAbBAE+HAaEBMQWDD8ccwQARBQ +MPn6/y/nEDAw/QoUIeAQODD8zNggygI8oPLMAAAAECgw0w9t2g8uIXQG7gH34SpwBAIQsLFVx0si +gsAEtQwAUQQArxoJ8wMDIgEC/wIvhsBgAGwAAAAAAAAA/1vaYgAAIXAugoQAUQQArRoJ3wMP7gEO +3QIthoRgAEX1CgAiAJAYoMDQ8swAABQQGDBtOg8kIXQGRAHyLAImAEi9ELFVJPr7JYLABLIMACEE +AN4aACEEAK8aCf8DD1UBDlUCJYbA8swAAAAQKDDzChQiYBA4MG06DyQhdAZEAfdBfXAEAhCwsVXH +Wy6CwBdu/yxyfCdygAW9DPDRBA2QBDsg8K0aBgAgZfD2cDcuEQBPcA/uAfwKAiwJAHdw/YbAJgkA +YbD2dDcgABAQMNEPAP8CAAIAACFw/wIAC/+2FWAugoQAUQQA3xoAUQQAohoJIgMC7gEP7gIuhoRj +/2cAAG9bhyuChBRu4SZCfCRCgPBRBAeQBDmg8KcaBAAgMTDzQDcsEQBJ8Ay7AfYKAiYJAF3w94aE +IgkANPDzRDcgABAQMNEPxirRD2wQCPtv0x8AEHAw8ioLAP8QYDD/cV4RGBA4MPcnKAIAAEmw86oJ +B8AEOOD4/forwAQ6oPuqCAYAIEXw9JB0ZgAgObAfcVMCKAv9cVIZsAQ6IPtvABgAIFow/YbFIAIQ +SDApdukrduor8X8rhsErdusv8X4PRy4PTyz4b4gQAgJr8PdxRR4FAD9wrFn6FgQoAEB2cPWXOQoA +QP4QB4kUAJsRC/sCK6bJKWaoL2ap0Q8AAAAALfL0LnLrLHLqDd0RDt0sDcwomhT8FgUqAFKnECRm +p/py6iIAAFkwWEBL/RIFIAAQYDBYP4j0UKxg/xBIMPlVCA8AEEAw9LCkZABARXCNFAWKFACsEQy8 +AizWySpmqCtmqdEPAAAYcR0ccSAZb18ogvT0FgEiAABosPkWACIAAHDw9xYDKdAEOiALiCz5iCgA +AxBQMPgWAiAgEFgwWD4qGW9SjBQHihQAqxELmwIrxskqZqgpZqnRDwAAAAAA/0wAAAMQUDD8EgUg +IBBYMPwWACIAAGiw/HEGEgAAcPBYPhmEFWP/NvVxAB9kALbgGHD7+IL0IgAAaLD0FgEgARBIMPkW +ACIAAHDw+XLrIAMQUDD8cPgSAAB68PUWAynQBDogCYgs+BYCICAQWDBYPgbAkYwUBYoUAKsRC5sC +K8bJKmaoKWap0Q8AAABsEAb2bnIRGBA4MAcnKNMP93CcFgAgObAjZugjZucncn/7cJgSAABR8Fg/ ++PW8AAIAACKw+wpkIgAAUPBYP/P8CgAgZBBoMFg/MdpA/AoAIgAAGvD7XAACAABo8Fg/K/+xMWIA +AHLwGW87AigL+m8MGbAEOiD8cIQYACBKMCyGxfpm6iACEEgwKWbpK4bBK2br0Q8AkxAccH2bEx9u +bxtubv1u/xADEFAw/RYCKdAEPeALmSz9mSgAIBBYMPkWASIAAGiwWD3NHG5kHm8iAi0L/270HbAE +P2D4cGwcACB3cCjWxf9m6iACEHAwLmbpLNbBLGbr0Q8AAGwQBhNuEyYgBykyfiMygKaZCZkRqTOD +N4gigz7IhMAg0Q8AACc9AShxoGSBjilxgmSRiMDC+ypeIsMQUDD6OggKACBc8Fg2Rh1wOCwygv3J +J3ACEEgwKXGg+AokIgFL/lD4FgEiAXP6UPgWASIBn/ZQ8ACNYgAAUjAuKoAOPgj+FgIgABB4MC/k +R//kTSABEGgw/eROIAoQQDAo5Ez55EogCAJY8PnkSyAbEFAw+uRIIAgQYDD5CiEizxBQMPnkSSoA +IFDwWDYmKXGg+Ao2IgCI/lD4FgAiAKr6UPgWACIA0HZQGXB0L4zaDw9I+RICLgkAT/AvlEYPjxT/ +lEUiAABSMBluWfo8CAKAEGgw/cwIAAAQWDD7xCEpwAQ5oPvEIigAIEowmBMogjonrDEHRxT7EgMq +AXw+ECuyORxtxvi8AALqADbgAAyLbXkCAEhhHW5JGG6kmLCPIBht+P22AiAkAnKw/rYDL4AEP+D+ +bnseCQB98P+2ASkABD2g/zKAIAAQYDD8tQoioRBoMP62BiAEAmKw+rwgLgkAT/D8tQsuCQBH8P+2 +BCoAIGzwWDXsihMnpjkpMo6xmSk2jgULR/8CAAP/LYLgiif7TAAAABBgMPqsICIAAGkwWx7QwCDR +D44SwYH45FggARBIMPnkWiAAEGgw/eRZIAQQUDD65FcgUAJY8P8wJiANEGAw/+RbIt0QUDD95Fwq +ACBQ8Fg10ClxoPP+rWBJEEAwAAD4OggCgBBwMP6uCAAGEEgwKeQi+eQhIAEQWDD75CQgABBoMP3k +IyACEGAw+DBiIqcQeDD95CYqACB6sPjkJSDIAljwWDW8iBApcaDz/mBgEAJCMCoagKo6KqDkx5oK +mR2KEPhtrxAEEDgw+XcMAoAQcDD6OggAARBIMP6uCA8AATww+eQkLgkAR/D/5CIgABBoMC3kIw+P +FP/kISDsAljw/zB0IqcQYDD/5CUqACBisP3kJiH4AmHwWDWeiBCye/P99GgAIFowAMHF/iqAIBkQ +UDD+PggAABBIMPnkRy/CEHgw/+RJIAkQaDD95Eov/hBYMPvkRS+AEEAw+ORIIQ4QWDD65EYiyxBQ +MPo6CAoAIFzwWDWIKXGg8/0ZYD8QQDD/CgsgBhBYMPg6CA/+EGAw/vqAIoAQQDD4qAgAABBIMPmE +IyKnEGgw/oQkKgAgarD8hCEvwhBoMPuEIiACEGAw/YQlIU0QWDD/hCYqACBc8Fg1cIgRKXGg8/zB +YBACQjD7KqcvwhBwMPkqgCGAEDgw+DoIBgAgPPD3cOQoACBOsP6UJS+AEGgw/ZQkIAwQQDD9b7Ya +ACBasPd3CQAAEFgw+JQmIAoCYfD7lCMtAAFgMPsaUywJAGsw/JQiKgAgXPD8jBQAAgI58PyUISIA +AGHwWDVQiBG2efP8SmgAIEowACoyjytsGPqsASIAAGCw+jaPIgAAULBbH/MFC0f/AgAD/eka4Ion +wLD6rCAgARBgMFshbB1t5J2gjCAbb5T4zBEAARBoMPumAiwJAGsw/KYBIAAQEDDRDwBsEAT1CgEg +ABA4MPYgIiCOADTgIyAtFGzt9SRdICsANOAoQnwkQoCmiAmIEfhuuhQAIEEwIkEfCCIB+ArAI+AB +EDAIIgIiRR/++gAiAABg8Bpt2gJpEaqZL5KCwEHzAkcMBQAZMP7/AQQFAGSwD18CL5aCLZKEDt0B +DV0CLZaEKJKAGm0rG20N/Lc5CABAUjAHiAL4loAgABAQMNEPJyRd8/+kYAAQGDBsEAYkMAAVbmb2 +CgEgPAA1IP8CAAAA7YUg/wIAAgD2ASD/AgACAPwFIP1SgSTOADkg+goEIBgQWDD8b1USAABpMFg8 +ZcYq0Q8AiDGwKvgJQwAHEFgwbboP+EgUAf4CUrD5pE0oYAFEMCmkTCgwAf8CAAAAvWIQ+FJ9IPsA +NSD/AgAAAHmFIP8CAAIAdYEgwCDRDwAAJFJ/LyAipP8J/xH+MAMsACB/cI3XKTAFDuQJjd4pJF8o +MQMNTwkoJTApMAT5JF4j4AFEMCP1bywgXxpvMfsKACAbEEAw8xqALCABYDD6mQINgAQ7IPn1cSwJ +AEMw/PVwKgAgG3D7pAUgAgJLsCmk5CogXvz6AC/wEHgw/ukJAYUANqB6wA0KihT0oB1gEAJa8HrI +8XrwDApKFPAABmAIAlrwsbsKGhRlr/csIF/7D0IIACBPcPv/EQxAAWAw/8wCCAAgHnAslAYqITAK +ihQqlAcoITD4lAggABAQMNEPAAAAKiBchCDAMPhEDABYADag2kD7PAAAABBgMPI1CAAAEGgw9VBM +IAAQeDD/FgEgABBwMP8WAiBkEEgw+RYAIAAQeDBbGD5moBsGXDf6TAACAABY8FsYIvagCmACAhjw +KCBceDOrKSAty5r6LAAAARBYMFv/XNKg0Q/AINEPLDAH/CRcIBACWPDxCxYAmAJQsAAKimP+Ybg+ +8w4WAKgCaLAATYpj/lHSoNEPKDAB+FsSAAQQSDD4OhIACBBgMPgXEgwHAUQw/HcBCgBASrD5iQEM +AEBiMPoKAiYJAFXw/8wRCdAEPmD8mQIKAEBW8PqKAQgAAUAw+6oRCgkAbvD5iBEGCQBd8PqIAgYJ +AE3w+HcCAgAAULD3JC0gABBYMFv/MWP91AAAKCBfpN74CEIOACAbsCjkBi8hMA+PFC/kBywhMPzk +CCIAABLw0Q8AAGwQBBttt4wgI7J/A8wM+rKBLOABYDCjwwkzEaOjIzIHK7J9IzIOLgoC9RqAIAEQ +aDD0PQEqACBm8PhBgiuQBD7g+6oIAAAQYDD7QbEkACAs8PlBgyDoADYg/FTGIJAAPmBokm3/AgAC +AFoGYCoylihQxiqsASo2lvlFgyAXADYg+iwAAAAQWDD8CgAgAhBoMFv94BtsCvxukBIAAFCwWDkW +wCDRDy8yjioyif8CAAQASUPgLzKWC/gu+Nw4AKsANqApUMYtNpb+RYMvyAA2YGP/rS4gNWTgeS8g +SWTwcyggXWSAbS4ylgvuLg7cOCxUxitBrvSwZGH+AnrwDw9P/0WuIFkAN+AqMpYoUMaxqio2lvlF +gy9+ADYgY/9jLDKWL0GuLVTGK1DGscz8NpYoBQB/sPlFgy9dADbgY/9CwCDRD2WvfC0ylrHdLTaW +KUWDY/8tLVTGY/+XAAAAwLBb/s7z/6JgAxBIMC5QxrH4KDaW+UWDLwwAt6BlzwRj/xQAAGwQCBlr +uC4gIg8CACqSfimSgK6qCaoRqpkjkgcbblD4GuAhoBBgMPMyDiHAEGgw/5wwIgAAULD/FgEgQAIy +cP6UBywAIGzw/ZYVLAAgYPD8lhAoACBA8PiWGiCwAmJw/BYCIIgCInBb/tYbbj30FgQiAABQsFv+ +0vtuOxIAAFCwW/7P+245EgAAULBb/s37bjcSAABQsFv+yvtuNRIAAFCwW/7H+240EgAAULBb/sQn +PQEscbErcbAaa88MuxwLqjb6da8gARAoMPU0GSAAECAw9TYHIAwQYDD0NBggMAJY8PQ2CCIAAFDw +WDPClxMkZQIkZAAlZAHzZgIgGAJA8PhmAy/AEHAwLjRO9DRMIAAQSDD1NE0gABBQMPQ0TyCAEGgw +9BYAIAgQeDBt+kGimy+wRIwQ+vo3DmABfDD/zAgK4AFQMPwWACYSAL5gDMgRmBD/sEwsACBI8C/E +VP+wTCwAIGswKcTF/8S9IAICSnD8EgAmACBs8PoaOSACAlqw+zRcKgAgUPD8NhQqQAFcMP27AgAE +EGAw+3S4IgAAWHBYM5X7PEwgSAIw8PwKFCIAAFGwWDOQwcX7GjghDhBQMPo6CAoAIFzwWDOLjhEk +5Awk5A0l5A4k5A8k5AMk5AAl5AEk5Ask5AUtME715AkuBwFsMP/kCCwGAWww/eQKIKACYPD8Nmsg +cAJY8Ps2bSB4AlDwKjZvJDZoJDZpJDRs9TRtL8AQSDApNG70NG8gUAJA8Cg2big2aiY2bP8gLSAI +EDAw9jRxL4gQcDD/NHAg2AJY8P500SAGEGAw/SAtIMACMPD9dNIiAABRsFgzYoIU/AoCL8AQODD7 +GlEhTRBQMPo6CAoAIFzwWDNbJCQMJCQNJSQOJCQPJCQDJCQAJSQBJCQLJCQFKzBuDwIADwIA9SQJ +LAcBWDD8JAgqBgFcMCskCic03PQ02iDgAlDw+jZzIMwCSPD5NnUg1AJA8Cg2dyQ2cCQ2cfY2dCDI +AmDw/DZ2IYAQEDD8NnIiACAQ8Pwg5CAEEGgw9TTbINoQWDD0NN0qACBc8PzMCQDkAjDw/cwJAgAA +UbBYMzP3EgMgGRBgMPsahSFTEFAw+joICgAgXPBYMyyIEiSEBSSECyWEASSEACSEAySEDyWEDiSE +DSSEDCkw3PWECSoGAUgw+oQKKAcBTDD5hAgg7AJ48C82ev82fiDeEGAw9jZ8IKYQaDD0NnkgqhBw +MPQ2eC4AIHDw/jZ/LAAgbPD9Nn0sACBg8Cw2e/UkxSAHEFgwK3WgJDaJJDaEJDaO9XWDIAAQEDDR +DwBsEAT3+uchCQA04PhM+CIAhYEg9QoBIAAQSDD4WTgAABBYMPprmRATEHAw/2rbEAEQYDD9+v8g +ABAgMPgq4CAUECgw8/wACAkAQLDTD21aDyUxdAdVAfWBLnAEAhjwsUTT8PsqwCAAECAw+yICABQQ +QDBtig8vMXQH/wH/IU5wBAIY8LFE0Q8AZk/Ub0sdI6KEAEEEALUaAEEEAMYaDWYDBjMBBTMCI6aE +Y/+zKKLABOYMAGEEALMaAGEEAMUaDVUDBYgBA4gCKKbAY/+SZk+0b0scKKKEAEEEAJsaAEEEAM4a +De4DDogBC4gCKKaE0Q8vosAE5QwAUQQAkhoAUQQAwxoNMwMD/wEC/wIvpsDRD8CQ8/8NYAAQWDDA +kPP/A2ABEFgwbBAEKSIHKZIOKJIzIiAiKwoA+IwBIAAQYDD4ljMiAABQsFv/rhxrbQIqEaysK8KA +HWyvDbsBK8aAC+owGWqOKZI1CZkKC5kJC+owC5sMarEObQgIDeowDZ0MatECY//wHGpkHWwqra0r +0oAeal4OuwIr1oArwn7+bJER+AJTMCqigfzCfCoAIBbw+bsRDgAgcLD+4OgqACBesPuyBywAIBMw +CcwRrKr7sg4gEgD7sMAg0Q8A/70BIAAQcDAutoIu9aEu9aAu9a7+9YIiAABbsFv9VMAg0Q8AbBAE +F2pFGWzV/msgEAEQaDD2bOYf5xBYMPQwRWGwAkpwaDI92JD8KkAgABBQMP/ihSAUECAwbUoPJYF0 +C1UB+IwCJgByZVCxqipyfChipAmqEaqIKIBkZIHm/wIAAACIhKDAgPQKASIAAHjw8085AgCCAKDa +gPQKFCIgEGAwbUoPJZF0C1UB+ZwCJgBc5VCxqiX6+yniwMFDBUQMAEEEADoaAEEE8NsaD/8QYDAM +uwMLmQEKmQIp5sAqcnwpYqQJqhEKmQglkDf7CiAiAABSMA+6OQpVAiWUN2QwkhlstfNiWyAAkoSg +ZDCE8goAIAMQUDBtCC4rkHwkcnwAIAQLCxv/txp0ACAgsCNipAlEEaQzLDBkyMQoNGQqNGsjYlux +InMrSmP/ygCgBA8IGf8CAAH/jH4Q/wIAA/+UmKBgAC4AAAAA9awAC/+mFqAp4oQAoQQAOhoAUQTw +2xoP/xBgMAy7AwuZAQqZAinmhGP/ScAg0Q8A2oD0ChQiABBgMG1KDyWRdAtVAfxRUXAEAkpwsaol ++vsp4sDBQwVEDABBBAA6GgBBBPDbGg//EGAwDLsDC5kBCpkCKebAKnJ8KWKkCaoRqpklkDf7Cggi +AABSMA+6OQpVAiWUN2P+/QD/q7RiAAAqsCvihAChBAA8GgChBPDUGg//EEgwCUQDBLsBDLsCK+aE +Y/+xAGQ/Y8AgbQgtKpB8K2KkACAECgob/HJ8ICgAfrCsLAnMEay7LbRrLbRkI2JbsSL/AgAL/5qY +kGP/y2UuHWP/JwBsEAQabET4oKkgDhBoMPlqjR/nEGAw+yAjIBQQeDD6rNggdgDyMP4KFCYAT27Q +LSAi/Q1CAEAQeDD/3QIAABBYMG3qDy6hdAzuAf7RLHAEAlKwsbvwACJv+xBYMAB9sWctGofAsG36 +DyihdAyIAfjRCHAEAlKwsbvHu/+7JmABEGAwKpKFALEEAM0aDaoBCso5zqbB7P4kLCAAEBAw0Q8A +AAAAAP+SwSHgAlLwAKEEAMgaCP8BD885ZP/XKyAi8goAIBUANuDRDy0gIi4agPP/kWwJAHdwAMCk +/GwkEBgQWDBYOSjAINEPbBASKiIbwMAsJC4poQMooQL/AgAGAJJOEBtrZR5pdR1pdSUhHCghHiYh +HxdpiJcanRSeFikgItTA/2mAEgAAGzD9ae0YCQBecPkWDC4GAUAw+Ws5GAcBQDD4zAACBQBH8P7Y +OQoHATQw+2wHFAUAWnD4ahAUCQBBMPsWDSgGATQw/iArJqABMDD/ICQmgAQ5oP0gLCwFAEow+CAg +LhAEO6D7/xAOCQAzsPYgIy4JAH8w+4gRDgkAG7DzICEsCQBHcPUVHi4JACOw+GYRDgkAe7D/IR0j +AAQ84P8VHyIJADTw/CEZLgkAG7D8FSAsCQB3cJ0e+yA0IAAQSDApFhIrFhMoIDUoFEImIC/2FEMg +ABBYMFsaJhZpeBVqLioWGB1ppPUWFiEAAilw9RYXIgAAGrDwAEZgQAIrcNEPAAAAAC1ADP8CAAYA +TYNgyJb/AgAAAJeHYP8CAAQAk4dgZFG8FWki+iIbIAICWPBbGhAuEhgdaZD64cJyAAAasChSeCTS +iKOICYgRqEQrQS72sdBwBBBIMIhACIgRCYgCmBUvQAcuQgcPD0H86RQvAAQ/4PrsIC4JAH7w++IJ +LgkAP/D/FgggsgA3ICwKKFsX/PtpKBIGALagwFAusNH+CUAB/7F/kCwgKy8gIsCRDJw5//8JAFQA +NyD6aiQSWgC/IMrFDP8R/UAMKgAgerAqoIDTD32pKvpMAAIAAFiwW46YG2kUYAATAAAAaMMb/wIA +BACMgyBoxRBoxsctQAwusNHz/wpoAAF0MCkgIhhqDwmZCQyZEf1ADCgAIEowKICAfYna+kwAAgAA +WLBbjcwbaQBj/8YAAAAAAPP/TmAAEFgwAAAAHGjaLSAiG2lKLMJvLyArK7KI/cwIAAEQUDD/rzkN +kAQ7IP8WFCoAIGbwLrA1jbAosAcrFhWYECywFpwRLBIX+7EZIAUQUDD7FgIgMBBYMFg4cy0SFS3Q +NP4SFCf/QJtgZOC5/wIAAABrB6D/AgAD/zcboPwSFSAAEHAwKeABLeACLcUZKcQH/uAAIAIQWDD+ +xBYiAABTMFuL+2VeQvscECIAAFEw/AoEIAIQaDBbFd/9QgAgBBBQMPxrVRAYEFgwWDhXY/4ZLBIW +LUAiLiACLyAB+CAAIAQQUDD4FgAgMhBYMFg4TipAIhtpxwqsCQzMEfy7CAABEHAwLrR5LSAALbR6 +LCACLLR7KSABKbR4W5MTG2i3Y/6fAAAAAAAA+hIVIAAQWDBbi9f6EhUgABBYMFrSfWP9pgAAAAAA +AAD6EhUgARBYMFuLz/oSFSABEFgwWtJ1Y/2GANWgJRYZjlj6CgQgGBBYMPxrKhIAAGlw/yAiLmAB +cDBYOCmLWPuPVwAbEEAwePEuikctoRX5+sAgQAJSsAmpAanZ+1xAKACBTVDCyFsXZhtokvWsAA2p +ADagY/+oAAAsICILDUN9yceOHQ4OX2njvxpo7C0hHh5ofPghHyAAEFgw/X9AAgAAYvD9bUAMBQB7 +sP9qNBIAAHLw+HlADgUAarD6ICsiAABq8Pn7OQ6gAUQw/iAkKgkAdvD4/xAKEAQ6oP9pBxoJAHqw +/CAjKgkAYrD7ICEqCQBasPhoQA6wBDug+P05DYAEOyD+3QILAAQ+4P2qAgoJAGbw+yAgKgkAWrAp +ICwLuxH7IRwoCQBecCtVFvghHSgJAFZwmVooVRcvIRkvVRj+IDQgABBoMJ1enl8sIDUsVDIrIC8r +VDMbaFbz/L1gARAoMA27DGP++wBsEAgoIh3TDw8CAIiC8yArIgAAULALgAD3CgEgATOmoCogKxVp +x4sn9CAiJgC2HpDzaSASRwA2oIu+KrIytFn6rAEggBBwMPq2MiBAEHgwGGnkAkoRqKgsgoAdasUN +zAEshoAtgrcbasML3QIthrcsknwrUoGkzAnMEfhp5BoAIGbwLbEfLLEdCN0B/bUfIEIAZzAssR54 +xxajrC3CgP8CAAAAgA9QKrAtYAD3AAAAAPoKACwAIBqwL/oALcKEKLEdD90B+goALAkAbrD9xoQg +QABiMCixHnmHFSrCgCixH/6IAgAAZg6QKrAtYADDAAArwoIPuwELqwIrxoIowoAaaEEKiAIoxoAm +kn4qUoH7aiAWACAhsAlmEapm/WIHKgAgXTArsOiN3v0WASIARnrQLCEf2kD8DEUAARBYMFv9HCtS +fSkhH4ogCQlF+6oMAACShmD7Z/ISSAA6YP8CAAQAlIJg/wIACACUgmD/AgAKAJSGYP8CAAwAlIJg +HGfzLMI2LTroDb0sB8wRDcwsAq0Ro90s1oFbFOD3JC4gABAQMNEPwKEtsR8P3QIttR9j/wfAoSi1 +H2P/NxlnwymSfKSZCZkRqapb/AYrUn+PYA8CAAv/DPpSgS7gAXwwC/sICbsR+BIBKgAgXrArsgce +Z7YojQIrsg4u4nwnhQIsvQH9wYIuACB7sAnuEf7BsSoAIHKw+cGDLxsAN2AtGoD9vQgAABB4MP/U +xiAAQAZg/wIAAgBVgmD/AgACAIAGYC+yli7Qxi/8AS+2lvnFgyAXADeg+mwAAAAQWDD8CgAgAhBo +MFv5hBtnrvxqNBIAAFGwWDS6Y/67G2pBY/8AANogW/0VZ6680qDRDwAbaj1j/uwAABtoOmP+5AAA +G2o6Y/7cAAAbajlj/tQAACiyjvqyiSQAWMIgKLKWmBAOiC7A4fjvOADSADagKdDG97aWIAIQUDD6 +xYMvfAC2YGP/hyhgNWSAjyhgSWSAiShgXWSAgyiylvIWBiABEBAwDoguCC84L9TGghYuwa77FgQg +bgA3oLDv+xYEL+ABfDD/xa4gXAA34CqylijQxrGqKraW+cWDLyEAtiBj/ywAACrBri+ylifUxi7Q +xv/8ASACEEAw/7aWKAUAVjD5xYMu+AC3oGP/AwBlr2EospaxiCi2linFg2P+3ifUxmP/iwCdEvwW +AyAAEFgwW/pdjBONEosU8/+RYAMQSDCOECrQxrHuLraW+cWDLq8AtqBl/qdj/rcAAAAAAGwQBCkg +N/8CAAIAq25Q/mgeEBMQKDD6adAQARAgMPP6/yAAEHgw/frnIgAAY/D6rNggnAB2cCYqAPusAAAU +EEAwbYoPKbF0DZkB+7wCJgBRNlCxzMebK+LACVgMAIEEAPwaAIEEAEgaA4gDCLsBDLsCK+bAKSA3 +Kwr7C5kBKSQ3+woAIAB7flD4ChQiYBBgMNMPbYoPKaF0DZkB/JF5cAQCUrCxuyv6+yriwAtYDACB +BC0gNwD8GvCBBAD+EEgw8EgaDABAT3D9JDcoEQAaMP0dFAoAQEKw/SQ3KgkAYrD65sAgABAQMNEP +AAAAAAAAAPnMAAv/sRcgK+KEAMEEAPwaAJEEAEgaA4gDCLsBDLsCK+aEY/9dAABvu4ws4oQAsQQp +IDcA/RrwsQQA/hBQMPBIGggAQFZw+SQ3KBEAGjD5GRQMAEBDMPkkNywJAGsw/OaEIAAQEDDRDwAA +AAAAAAD6CgAgABBYMFv8pCkgNyoK7wqZASkkN2P+kwkbFPskNyAAEBAw0Q8AbBAEHGcDGGmSG2mS +GmmT8AAPYAAQMDAAsWb/AgAIAEOBoABgBAIEG39H7G8zC8g4wHLwABJgABAoMGg4Amk7ZPcKACAB +ECgwBhRA9g9ABeAEOSD2LhQOCQAn8PLuEQ+ABD/gr+4L7ggt4oAKXxH/fwIMAEBXcA/dAgjdAi3m +gAnqMCXCNQlVCQnqMAlZDGqRhm0IDQnqMAlZDP8CAAH/vSZgY//r0Q8AbBAEGmbZHmeU+woAL+cQ +aDD8KkAgARB4MP7ihSAUEEAwbYoPKKF0DYgB/IFMcAQCUrCxux5pUdMPK+JbZLBMHGeh/WaoEAAQ +UDBtCCkpwIAo0nwAoAQJCRv/lxV4ACBCsCvipAmIEai7L7RrL7RkK+Jbsap7qxRj/88AsAQOCRl/ +l7DAolv3WcAg0Q/AoVv3V8Ag0Q8AAABsEAQbZrPTDyiw0fyHEnABEBgwKSAiLCAs/wofIsMANmDA +MCogI8C5/AoOJgFT3pD/AgAGAU/mkC0gJS4gKMBA+SETIDUAN2D6CgEiTQA3oLGY+AtAAgAAeTAL +rzj4JRMgGAA34CkiHYuc/JINIAsANuDIw9ogC7AALSAi0w9k0wkuIGrTD/VpIxhkAXQw9gogIJcA +NmD/AgAAAJmGYP8CAAIAqQJg+mkfEm4APmD8aRsQAhBQMP0gIiAYEFgwWDYQxjr6CgIgGBBYMPxp +FRIAAGjwWDYL8ANRYAEQIDAAAAAuIGto4SsvIGTO9dogW/4m06BnMzLHhXg5x8Ck/GkKEBgQWDBY +Nf7wAx9gABAgMAAAACQkavsKGCIAAGKw/SAiIAQQUDBYNfYcaQATZ9z6CgQgGBBYMP0gIiBgAjsw +WDXw+QoAIAgQUDBtqkQrIGgAkAQLCxt/tzYJH0D5DkAP4AQ/4PktFA4JAHuw8t0RD4AEO6Cu3aXd +LtKDBu4CLtaDLN0EjMD93QQsAEAbMJzQsZkoIh2IgQIqAvsKASAAEGAwC4AAwbDzrAAPSAC2oPsk +aiIAAFCwW/30/HwAAAQQUDD9ICIgGBBYMFg1zSkgaxxo1/zMcCP/jh5gLSBkZd8R9iRqIAQQUDD9 +ICIgGBBYMFg1wxxoz/NmKhAwEDgw+goEIBgQWDD9ICIhoAJjMFg1vCv63/kKACAIEHAwbepELyBo +AJAEDw8bf/c2CR1A+QxADeAEP2D5KhQMCQBrMPKqEQ2ABDsgrKqlqiyigwvMASymgyitBIiA+q0E +KAkAGjCYoLGZKCIdiIECKgL7CgAgABBgMAuAAB1orvOsAA50ALagwKT7ChgiAABjcFg1nBpopSck +amP+R7CZCQlP+SUTI/7r/lBlnbv0JCUgBBBQMPxnkBAYEFgwWDWRKSIdipxkrbQrkg1kva4CKgIL +sABj/aUqICJYGMdj/VsAAAAA9Gd6F/6e/xApvQopknz0QoEv5xBoMPpmshGHEHAw+ZkRAAAQYDD5 +RAgAFBBAMG2KDyixdA2IAf6BTXAEAlrwsczHm/miwSHgAmJwAMEEADsa+woBKABAXnAJuTn1ZhsQ +VAA2YC1QISMK/3PRECoKBfxoeRAYEFgwWDVpI1QhwDBnPL/SMNEPAP/Lt2IAAEswKKKFAMEEADka ++YkBAAEQcDDz/7doBQBPsAAA2iBb/mpj/O0AKkAsf6GpKgr//AoDIKAQWDBYFrr2oFBiAAAasC1Q +IdMPfalXLVAgK1AifbFGKUAsaJRAaJU9Kgr//ApWIKAQWDBYMFX2oCNiAAAasBxoVv1QIiAFEFAw +/lAgIBgQWDBYNUMsUCAsVCJnP2DaQFv73mP/WADz/1RgABAYMPoKBSAYEFgw/GhJEgAAcPBYNTcj +VCFj/47AQS0gLsjT2iBb/AxkTyobaDL8aEESAABQsFgyp9Iw0Q8AAGwQBBxnE/gKCC/fECAw/2WR +ECAQaDD6LAAAABBIMPs8AAABEHAw8pwAAgUAH7D9aCYSBQAbcPkKAC4FAB5wbYpKKKBoAJAECAgb +f4c8CRhA+Q5ACeAEOiD5KBQOCQBDsPjuEQkgBDogroitiC6CgwTuAQ4uAi6Ggy6NBI7gDO4B+I0E +LgkAc/CegLGZKKIdiIHAwAuAANKg0Q8AAGwQBPNoFhoiALygAyMKgzD6MAAAEBAQMMYq0Q/RD8Ai +0Q/AKNEPAABsEARoMUH7ZWMSIAA44Gg0Pmg4Q2g7SGg8JxhlaSiCNik66Am5LAeIEQmILBpoAwIp +EQqZCPiWACIAAFCwWxJU0Q8bZ+5j/9EbZ+pj/8sAABtn6WP/wwAAG2XmY/+7AAAbZ+Zj/7MAAGwQ +BhhlVdMPI4DR+QoBIgBufNDVgPcKpyAAEBAw9vrnIBQQUDBtqhArUXQGuwF3sQvyLAEgBAIpcMcr +0Q9mID8VZgL6ChMgABBYMP8rNW//EDAwL1KEACEEAJ4aBu0DD98BD+4CLlaELFKEACEE8L0aDABA +azANzAIsVoRgADAA0Q8AAC5SwAKsDADBBACdGgbXAwfuAQ7dAi1WwCNSwADBBPC0GgIAQDzwBDMC +I1bAB+owD+owJII1p0QPTwxq8Q5tCAgL6jALSwxqsQJj//BvK1QtUoQAIQQAnBoGzgMO3QENzAIs +VoRgAAGCECaCNcBQ9mYKB9AQODDwAAln8AQ5oLFVd1EcBOowCOowpkQISAxqgextCAgI6jAISAxq +geBj//DRDwAALFLAAq4MAOEEAJsaBr0DDcwBDLsCK1bAY/+pAGwQBtcQ+QoAIA4QUDD1Z6AQDxBY +MP5k/xAfEGAw9AoEIgAAaLD1UgAgARAQMPUWACIAADOwbUoqKGDkCAhE/IEfcAICMbD/AgAGAJbW +EPCRBAYAkt4QAC8a/3QAIAICSnCxdyTg5PbihSIAIAtwIiAA9+DlIAIQYDD5CvAgWAB9sPJFFAJg +ARAw9AREA8AEOKD3B0QCCQAosPICRwYAf9UQ/wIABgB/1dD3ZoAQ3wA04P8CAAAAaZzgBkQU9kVA +BgBAYTAYZjL6ZMoQUQA1YAwvAfIVEgQDARAw+S4BBABAZXD07gIEAAEQMP//EQXQBDkg/0QCAgkA +cXAEIgLy1REC4AEQMPKwE3QAID1wZDC7K1KADwIACLsCK1aA9GBoamABFDDB4PIVEgAgEDAw8jwS +BABANXD+zAEGAEAwsP4kAQfwBDmg/UQRAgkAYvD2RAICCQARcAQiAvLVEQLgARAw8pAjdAAgPXBk +MFQpUoAImQIpVoDRDwCRBAC/Gi90APP+3WAIAkpw0Q8AAPYmFAQCATQw8/8sZgBAYbD/AgAH/4TV +0K7VJVDk/ygRBIABLDD6VQwI4AFAMPP+7GIFACowKVKACpkCKVaA0Q8rUoAKuwIrVoBj/0NsEAjy +ZG4SAABAsNkwDwIA8AIHAgAAEHAAQmEAQmH/AgAEAEESIBJmsPQcAAAGEBgwbToR8y0EIfgCITD1 +QgggCAIQsJUwFWSzEmaoG2a8HWa6H2a4FGa2jFSOVYNWileaKJNIilMUZraDUp74nNiauJNIF2ad +HGSMCIsQC5sC9mTEGgkAZvD7dv8j6BAQMG0ICbAiySAscv98YAJj/+/AINEPAMAg0Q/HK9EPbBAE +E2W8AyMKIzKZGGcBAiQRqETzRgAgABAQMNEPAABsEAQTZbT1CgAgCBAgMPMjCgIAADiw8zKZIAAQ +EDAPAgDTD9MPbUoX8CEEBGABGDDwRBoABAIQsPNDFAQAICVwGWU7AngR9SQUCAAgSjD0hgAgABAQ +MNEPbBAEFGU59iwAAAgQGDBtOgooQqUICFJkgFW4RCcKABllLxhlJfUKgC8AEFAw+2UsEAAQYDD4 +dAgAIBAQMG0qKwwCACKyQCKS0gojAQNjAiOW0iOS0ixGoKVzqDMjMoAiltLyktIgCAIhMLRV0Q8A +ACdCpAcHSfP/pWfgBD3gAABsEAQWZsb3CgAgABAYMNMP9AoXIgAAEbD2bUAgAgI58NMPbUoKIyaA +8yaBIBACELDBR/l04mIAABGwEma492a4EA0QIDDWINMPbUoKIyaw8yaxIBACELAjZsvybUAgDRAg +MPNmyiG+CDiwFmasJwoA9AobIgAAEbD2bUAgAgI58NMPbUoKIybQ8ybRIBACELDBS/l04mIAABGw +0Q9sEAQYZhAPAgCoKCiA6PwKASXgARww/4dycAAQWDAYZVAIKAoogpnAMPhIFAgiAUQw8JEEAAAQ +EDDwyhoABhBIMG2aEvhIFAgiAUQw8JEECgkAVvAAyhr5Ch8kCQBS8AOZDHlNDrEz+TT0YB8QSDDR +DwAAAPo8AAIAAFlwW6VY96/iYgAAErBj/+QAAPosAAIAAFlwW6VS0qDRDwBsEAT3ZRESAAAwsBVk +KgUlAiV2syJytBRlUhNmdPQKECIAQCCw8woAIgkAGLDydrQiAAAR8G1KB/MmtSAIAhCwJnaz0Q8A +AABsEAQWZK2mJiVigMd/BzcDB1UBBUUCJWaA0Q8AbBAEwMEYZc8ZZmH4KAgFIAQ4oPiA6CQAIEkw +hEArCgD0BE8A0AB+MBhlDggoCiiCmfhIFAgiAUQw8JEEAAAQEDDwyhoABhBIMG2aEvhIFAgiAUQw +8JEECgkAVvAAyhr5Ch8iCQBW8AKZDHk9DrEi+ST0YB8QSDDRDwAAAPtMAAIAAFCwW6UWZ6/i0Q/6 +LAACAABZMFulEtEPAAAAbBAEW/9xHGY7/QoAIAAQGDD6ChEiAABDMPzNBCACAmtwbaoKI4ZA84ZB +IBACQjDBofnY5GIAAEMwwCDaIFv/QrEiaS71+GW7EBAQUDBtqgojhhDzhhEgEAJCMBhltoiAGWW1 +KgrCCogCmJDRDwAAAGwQBBRmISNCgAIzDCNGf9EPAAAAbBAEFmRepiYlYoDHfwc3AwdVAQVFAiVm +gNEPAGwQBBJknxRmFSMigXs2ICkiigkJVfCRBAABEEAwAIgaIiL+AiIU8AAJYgAgEjAAACJBfSRB +f/NjgBALADUgAyI1pCLRD9EPAGwQBBVkT8CICCgCKFZSDzQRJFZT0Q8AAGwQBBdkOQImCwtmEadm +KWLCDz0RANEEAFoaANEE8EsaD/8QYDAMuwMLmQEKmQIpZsL3Y0sRGBBAMAgoKPZiwiYAIEXwJnbs +0Q8AAABsEAQVZCYCJAsLRBGlRCNCwBVjlQUzAiNGwNEPbBAEFWQfAiQLC0QRpUQjQsAWY6gVY2gG +MwEFMwIjRsDRDwAAbBAEG2VhDwIA+7J/IgAAUPBYNMD9CgggABBgMFgz7/0sAAAAEGAwWDP70rDR +DwAAbBAE82QZEAEQEDAiNoAiNoHRDwBsEAQYZcsqgn/BsAuqAiqGf1g1F9EPAABsEATzZcYTUAQ4 +oKMi0Q8AbBAEGGQLwJDTDymGaimGaymGbAwCACiCbAjqMBNjEyMyNQMzCggzCgLqMAIyDGohDm0I +CArqMAo6DGqhAmP/8NEPAABsEAT4ZbIQGAA04BVlsSiAfSVSf7A0CEQoolKkItEP0Q8AAABsEAQT +ZaskMoAjMn90OQUUZalySwPAItEPwCDRDwAAAGwQBPoKgCVAEEgw8pI6AT8QQDADozqjJPj6gCQA +IEEwCEIB0Q8AAABsEAQYYs3wCAcD4AQ84G05AgBCYdEPAABsEATzZZUTEAQ4oKMi0Q8AbBAEGGWS +AiUKCFUK8lK0IBAANOApUrOSMAkiDNEPAAAqUrMKIgzRD2wQBMCi/ApAK6AEPKBYk/j7ZYYQRwA2 +oBxlhSy2fvy2fyAQAmMw/LaAIAAQaDD8toEgcAJysG0pHZ2vna4psoCekZyvKbKA+aYOIIACUrD+ +toAggAJzsMAg0Q/HJNEPAGwQBBJioA8CACgifyIigAmIEQgiCAIqAlq6CBhimwAIi/giByBAEEgw +bZoCAEhhwJCZJ9EPAAAAbBAIF2KSFGQxKnJ6+XKAIAAQGDDyY4YQABBYMP9ijRuQBDqg/xYEKAAg +VnD5FgMggBBAMPAAGmFQAjHwAAAAAPpWgCAAEFgwsTP0TAEkAMAA4CpyfiVilqo6CaoR+WBUJAAg +VXCFVwAwBCxh1fVSDiFnADZgLCCA/AwbDAAgRTD90MwhiAB/MH7XvC9yfi5ilq8/Cf8Rr+6O5wM6 +Av7iDiAHEFgw/hYFIgAAYHBYMZGIFAAIi/gSBSAzEEgwbZoCAEhhihUpCnj9KoAhgBB4MPytAS4A +IH6w8/TEIHgQcDD+xa8gHhBYMPvFsSAEEHAw/sWwLAAgbrAp1EQu1DH+1DgvgBB4MP/UIiAOEFgw ++9QmL8IQYDD81CMgARBAMPjUISAHEGAw/NQwL4gQQDD81DkgAxBYMPvUOi/MEHgw/9QuIgAAWHD4 +1C0gAhB4MP/ULyKnEHAw/9RCIAYQQDD41EEqACBysPoWAiAAEHAw/tRDIAYQYDBYKnmKFfsqsiAG +EGAw+xwACgAgWrBYKnSKFfsSAiK7EGAw/AoGKgAgYrBYKm6KFfsqTCAGEGAw+xwACgAgWrBYKmn6 +EgMiAABY8FvxkSgKgPeudmIAAFqw0rDRDwAAAAAAAP/HFHwAIEUwLNDMwOHTDw7MAizUzCxh1fhJ +CAH/QPcQL5DMwKIK/wIvlMxj/m4AAGwQBhZiEQAGixZk4Rlk4thgbZoCAEhhE2TkH2TgG2TeHmTg +F2TjFWThGGTiFGTjEmTdLI3/IkZYJUZWJkZTJ0ZVKULAKkK6LkbJK0bHL0aZI0ZXLe0oLUbC80Fb +IKACevD/RpggYAJa8CtGyv7tCCuQBDqg/kbBKAAgVnD5kgcg/gI48Ad3FChGVImemRAjZQIjZQP8 +ZgAgABAoMPdlBCLAARgw9WUFIC0ANKDaIPtcAAABEGgwWw7SaK4V+iwAAAAQWDD8YgAgARBoMFsO +zGmu6ShCVCeFBCWFBSOFAiOFA/OMAAAgAmIw/IYAICoANKDaIPsKACABEGgwWw7BaK4V+iwAAAAQ +WDD8MgAgARBoMFsOu2mu6YcQI0JVDwIAJ3EnJTUFJzUC9zUDICACYPD8NgAg/gIx8PZ2FALAATgw +9jUEIWwANKDaIPsKACABEGgwWw6raK4V+iwAAAAQWDD8MgAgARBoMFsOpWmu6SNCVg8CAA8CACY1 +BPc1AiIAAFCw9zUDIAAQWDD1NQUgIAJg8Pw2ACABEGgwWw6ZaK4V+iwAAAAQWDD8MgAgARBoMFsO +k2mu6StCwilCdSNCx/W1BSAEEGAw/LUEIgAQUDD6tQIg+xBAMAmIDPq1AyD+Akow+XkUACACUvCa +sPU1BSAgAmDwLDYAKTUE+DUCIsABQDD4NQMgKwA0oAIqAvsKACABEGgwWw56aK4V+iwAAAAQWDD8 +MgAgARBoMFsOdWmu6SpCdg8CAGSglS2s//2oAQ4AD+6QbQgP/oz/IgAAUjD+iAEOAAT2kGP/6QAA +D6oRIkLKL6x/D38UJSUFLyUE+iUCIsABVDD6JQMgIAJgsPwmACArADTgAzoC+woAIAEQaDBbDlto +rhX6PAAAABBYMPwiACABEGgwWw5Vaa7p0Q8oQlYmhQQnhQInhQP1hQUgIAJKMJmAY/7sAAAAAAAA +APP/jGABEFAwbBAMFmQ4LCAMHWGvKmKn+2KvJl4AOyAYYXYogNEJqhH6uggAgBAYMP+HB3IAIB6w +YAACI60DiN3yCgAgFgA2INEPqsMJMxHz/+tiACAe8AAAACRiTRVkJPQWCSD+AiEwBDsU9bsBAAIQ +UDD7vBAgEBBgMFiSgYgZBHkU+aUEIgAAErD4pQIgIAJisPilAyAAEDgw96UFJMABQDD8pgAgKgA1 +INpA+3wAAAEQaDBbDh5orhX6TAAAABBYMPwiACABEGgwWw4Zaa7pJGJMIma09BYKIP4CITAEOxT1 +uwEAAhBQMPu8ECAQEGAwWJJjJ6UFBHgUhBr4pQQiAAASsPSlAiAgAmKw9KUDJMABIDD8pgAgKgA1 +INpA+woAIAEQaDBbDgJorhX6TAAAABBYMPwiACABEGgwWw38aa7pJGJLImaz9BYLIP4CITAEOxT1 +uwEAAhBQMPu8ECAQEGAwWJJGJ6UFBHgUhBv4pQQiAAASsPSlAiAgAmKw9KUDJMABIDD8pgAgKwA1 +IARKAvsKACABEGgwWw3laK4V+kwAAAAQWDD8IgAgARBoMFsN32mu6SJmshthI/oKAiAQEGAwWJIu +G2PLGWDr+GPKH/8QYDD6tvwgABBQMPAJBwAMEEgwbZoCAEhhGWHg/5xgIAMQcDAqlHwslH4slK4s +lN4ulH8ulK8ulN8s9K4u9K/+9KwgAhBAMPiU3CABEFgwK5SsJGJNwcAExDb0Fg4g/gIhMAQ7FAW7 +Afu8ECACEFAwWJIPJ6UFBHkUiB75pQQiAAASsPilAiAgAmKw+KUDJMABQDD8pgAgKgA1INpA+woA +IAEQaDBbDa5orhX6TAAAABBYMPwiACABEGgwWw2oaa7pGmEP8qYLIAgAtKDHJNEPix7AovK7EQAQ +EGAwWJH0HGEH+fr0IgAAEfAKkjj6xgwgBwA0oNEPAB1jjBtjjhJjjBhjjPgWDSAQAiLwmx8qYrMr +Jn+dHCmhAismgCQmgfQmgiEbADZgWw2TGGCeKIJtL2KvqogJiBH5EgwuACBH8CjwB/mQgCD8EFAw +CogBCAhH/mN6GAkASjAo9AeeFI3wKxwQ+vIHIAEQYDD43REAARBwMP8mgywJAHdw/RYFIEACUrBb +FPeJHYsfjRwiLDD0TDAgYAJa8P3cAS//uMrQhjcmYg4mYgQkbH8EOxT1uwEAAhBQMPu8ECAQEGAw +WJG8JqUCJqUD96UFIgAAErD0eBQAIAJisPilBCTAATAw/KYAICoANSDaQPsKACABEGgwWw1baK4V ++kwAAAAQWDD8IgAgARBoMFsNVWmu6Y03HmNFjd4cY0ry5oQgBRBQMP3SBCAyEFgwWDALH2M+L/KE +/vr0IgAAEfAP4jjIJdEPxyTRDwAeYgIi4tuNNyPi3B5jNY3eJ+bIL9IGLdIFLebELebGAtYM9mYU +DgAgb/D25sch/gJ78A39DP1tFAACEFAw/+bFIP4CM3D2OxQAEBBgMP0WCCoAQC7w/eaCICACWvBY +kYMnpQUGeBSFGPilBCIAACKw9aUCICACYrD1pQMkwAEsMPymACAqADVg2lD7CgAgARBoMFsNImiu +FfpcAAAAEFgw/EIAIAEQaDBbDRxprukZYwz0loEgEAC1IPAATG/0EBAwAAAAABxjDv6SxSIAAHiw +/ZLEIAUQUDDzFgAgYBBAMPgWASAyEFgwWC/KH2L9HGMFLfLH/vLGIAUQUDD/8oIgMhBYMFgvw8Ag +yCbRDwAAAAAAAP4KPywAEGAw/2DzEUEQIDD7CgYgABBQMC0aQC32EBhi6ynyESmG/ST2EC3yERNh +ERli8Zk4JPYQIxoAA90CLfYRE2BZJ4ayKoaLKoaKKoaMKoaRKoaQKoaWKoaYKoadKoacKoaeKoai +KoakKoavKoauKoa0+oa2IAEQeDAvhposhqkshqsshrEuhqguhqorhp/7hrUv/xBIMCmGjfmGkyAD +ECAw9IaUIBAQaDD9hqwgGhAgMPSGjiAbEGgw/YagIA8QIDAkhrefPftiGBAeEEgwKYaIHmJrLoaZ ++4alI/8QSDAphrAcYmcfYVgTYBwjhpITYOkvhpcshqPzMsIgERBQMCqGptEPAGwQBBJhISMigXs2 +GykiigkJVfCRBAABEEAwAIgaIiL+AiIUooLRDwASYrIiIX/RD2wQFBpisNMPKKLD+V/CEyEANiDy +CgAgABBYMP0KACAAEDAw9woAIAAQQDD4FhcgABB4MP8WCyAAEHAw/hYKIAAQKDD1FgkgABAgMPQW +DSAAEBgw8xYMIAAQIDD3FhMgABAYMPYWFCAAEDgw/RYVIAAQMDD7FhYgABBoMP0WDyAAEFgw+xYH +IAAQKDAfX6IeYo4v8ngu4p6vLwn/Ea/unh4u4RL+FgAiAABQcFhmAokeiBAqlGL4lRIgWAJScFhl +/foSDiIAAFqw0w/7pFYgcAJSsFhl+I0e/NESK+ABLDAr1RMq1Ff8VQgCAABQsFhl6ioSFiIWGC4S +FIIeLBIXiB+XLyMkVZYsKyBxKSE+LSBwLyBu+SByKAAgQnD9IgssACBjcP8gVC4AIHPw+xIHKgAg +UvArJhKfE5gfKhYWLBYXLhYUjBqOHIouKBIV/RILJgAgabD/ITMiACB88PkiESgAIEJw+iE0JgAg +VfAoFhUoITL/Eg0sACBv8PoSCS4AIHKw+CE2LAAgYjD5ITUqACBO8J0b+GJNGgAgUjD5EhMuACB+ +cCIgbyiAdZ4c/xYNKAAgTLDyEhggNAD+MCkWEyIWGIgeghOSFiKEfiISGGAACgCIHikWEyiAfpgW +GWI6mxeIFimSw5oZ/BYKIAICELD4RAgL/0vMkBhiMyiCxWSBvvkSDyAAEBAwbQgXAAEwAAAxIAyU +IA0CAAExAAIAAAIwIAwBJRYbFV87GGInJVJ6JBYZJIKe9xYcJAAgLLDyFholkAQ9YPISFCQAICkw +JBYRlkwrRhIlQG4jRFUnQG/1EhMiACARcCIWFCJAcPcSFyQAIC3wJRYTJUBx8hIWJgAgPLAnFhcn +QHL1EhUiACARcCIWFiJBPvdBMiQAIC3wJRYVJUEz8hIcKAAgTLD3QTQsACBh8JJP9UE1LAAgbXAi +QTb3QRIuACBx8PUSGy4AIH1w8kBUKgAgULAiFhD1RRMkACA9cCUWG4dLhU4kQhH3EhwmACA5sPiA +dSIAIBTw8hIaKgAgJvD0EhkmACAt8PUSGyIAQv4QmR8iFhgoEhEiEhAiFhIihH4iEhhgAHQAACuS +NGSyqfoKACAAEHgw/goAIAAQaDD8CgAgABBYMPUKACAAEDAw9woAIAAQQDD4FhUgABAgMPQWFCAA +EBgw8xYPIAAQIDD3FhYgABAYMPYWFyAAEDgw9RYTIAAQMDDz/m9gABAoMAAAKBIRmR8ogH4oFhIZ +YcgoEhIpksWxIvkrDnQAIEEwiR9j/k0AAAAAAPISFCGvADcgGWG/LJX5LZX7LpX9/5X/IDoANqCw +qAipAfkWBS4AtcaQihVtCBHYoPoWAiH+Akqw+aoBDgAEzhCaFWP/44kSD5kR+WGuEgAAUnAYYa0v +lf8ulf0tlfsslfkqhRwcYaktwegaYab5wekhJwA3YC7B6igSEy+gBdMP8qQELgUAdjD/pAUgFgA2 +YC8SFygSFiikBy+kBi8SFS+kCGTRKyjCUdMPDwIA88ZYIL8ANiD7FgcgABAQMBpepRlhkiqieSmS +nqoqCaoR+xYHKAAgVnCZGCmREvkWASAIAlBwWGUEjBiLESrEYvvFEiBYAlMwWGT/+hIIIgAAWrD7 +pFYgcAJSsFhk+okYHGF+ixeNno6bL5ESKJBUJZUTlpyXnyqUVyqSESOUVfuWEiACAhCw+sB1KgAg +VvD4FgQiACBE8P9VCAYAIHGw/68SdgAgbfAolH7wAApiAABSMAAAACqQfi3CUfpECAv/qOyQJcZM +JsZNJ8ZOK8ZPI8ZTJMZUjh/+xjggABAQMNEPAADz/rZiAABKsGWe2S/B62X+0y7B6i8SEyigBQ74 +OSikBWP+7mXeUWXuTmX+S2SupBhhUSyF+S2F+y6F/S+F/2P+SmWe0CnB62WeymXux/9efhAAEEgw +KaQBKaQA//DRIOAQcDD5xRUn4BBoMPnFGSAgEEAw+cUcLgABfDD4xRMsBQB/sC3FF2P+iwAAAAAA +AADyCgAgABBYMPUKACAAEDAw9woAIAAQIDD0FhMgABAYMPMWDyAAECAw9xYVIAAQGDD2FhYgABA4 +MPUWFyAAEDAw8/4AYAAQKDBsEAiSFFgqtFv+cxZhJith4P8CAAIBTf7QKmIzLmI1L2HhKGHiLWHj +wHD4SEEOIAF8MP0NQQ4FAHqw/mY1InsAN2Bkgn/7CgQgIAJQcPtmUiIAAFhwWHyN9qGNYgAAErCK +EFh8b1gnTVh7svahemIAABKwWHsoWHr8WHnz9qFpYgAAErBYeTQsYd1+xwpYeTD2oVViAAASsFh4 +wvahSmIAABKwWHiF+woDIgAAErD9YeAgAJuuoP8CAAIAx39QLmHhDwIA/wIACADIctAqYePB+P8C +AAgAydPQ/wIACADZ0tAoYeIPAgAPAgB7hxr6EgQiAABhMPs8AAIAAGlwWHe39qDlYgAAErBb++eN +bvsa9CPoEHAwDwIADt0s/wIACgEHbtAYXkkWXs4nhgkpYqr9HxQLABBQMPqZAQH+Anvw+EoALgkA +T/AI/wIvZqpb+1T2oJViAAASsFgqXxReBdMPKUDR+mDRECoA6nAponbHvQuZASmmdiemcSlA0Xmf +ECyidsfbDcwBLKZ2J6ZyKUDReJ8NLqJ2xv8P7gEupnYnpoKHFChwDYp3KXB3iq77nAABIwA2IB1g +ISnSrh5eHPwaByAAEFAw/pkCD+cQWDD51q4gFBBAMG2KDy9BdAv/AfzxGnAEAiEwsapYKjvaUPs8 +AAIAAGCwWCyWwCDRD2av6P+rIW//EGAwKWKE8KEEAAEQQDAAiBoMiwMLmQEJiAIoZoRj/8MrYsDB +0wrdDPDRBAABEEgwAJkaDJ0DDbsBC5kCKWbAY/+hAFh4DMCz965tYgAAErBj/5BYd/jAs/eua2IA +ABKwY/+A+hIEIgAAWPD8TAACAABpcFh31/avamIAABKwKmHjwLP/AgAP/yrW0PoSBCIAAFjw/EwA +AgAAaXBb/Df3rjpiAAASsGP/OgAAW/29KmYzY/1iJ2Y2J2Y3J2Y4Y/18J2Y8J2Y7J2Y6J2Y9Y/1w +wMgMmQL9rQUo4AFMMPl0dyBlEGAwLNXu/NXvIBwANuDApfxeURAAEFgw/gpkIAMQaDBYLSZj/qhk +n+TApfxeSxAAEFgwWC0hG15K/F5KEgAAUfBYKpZj/8bApfxgXxAIEFgwWC0a8/3lYfQQaDAAAGwQ +BMk3/wIAAABqBODJOP8CAAAAagTgwCDRDwAAACchE/U/6mYAICXwKCEuHl2jDwIAd4kCLiUufmE2 ++2wAAgAAULD8ChAgABBoMFgAMvaghGIAABqwHF6yLMF/AioC98wIAAIQWDBYK332oGhiAAAasB1d +kdMP0w99UTD7XAACAABQsPwKECAAEGgwWAAh9qBDYgAAGrACKgL7CgIiAABh8FgrbvagLWIAABqw +AioC+woBIgAAYfBYK2j2oBdiAAAasPoiCiIAAFkw/AoAIAEQaDBbDfbSMNEPAAAAhyzz/ypmACAl +8Nxw+iwAAAEQWDBYK1r2r95iAAAasPoiDSIAAFkw/AoAIAEQaDBbDefSMNEPAGwQBhRgFYYvJEJ/ +o2YEZAqEQPRAbWfgBD2g+F2kEGUANWAsQAcMDEEMxREIVQgoUjr/AgACAF3GICtSOWSwsMDA+iIA +IAAQQDD4FgAgBRBoMPgWASAAEHAw+BYCIAAQeDBbETrAwyxWOSsgBikiAtMP+7wBIAEQUDD7JAYo +CQBWcJki2iD7CgAiAABhsFgrLvagV2IAACqw+iIQIgAAWPD8CgAgARBoMFsNu/YKACA8ADUgikcm +RAUqqRRloEP7QgogABBgMPoiEyAgEHAw/kYCIAEQaDBbDbAfX98v8n+n//b2ACIAABFw0Q/SUNEP +ACvMGPosAAIAAGCwWw/WxyTRDxxf1i4gDS0gDPoWACIAAHjw+EICIBIQWDD4FgEgBBBQMFgsiYtH +/PrAIEACSvD6QgIoAEBmcPa1FCCAAkpwmbn5tgggQgA2oPz6ACAAEFgw+sASf/AQaDAKihT0oB1g +EAJa8HrI8XrQDApKFPAABmAIAlrwsbsKGhRlr/faQFsPjmP/NwAA8//yYAAQWDBsEAb8QCYggBBI +MPMHRggAQEjw+BYAIB4A4PADhULwAAZkACBNcNVwGV+qDwIAKpJ6K5J++EBbKgAgYrD5qhEAABAw +MPySdioAIFqw+hYBICgANiCPSAn/EQ+/CC3wcyvyAC3c//30cyzgAWww/LsMArgAN2AmRFv7PAAC +AABRMPwKACAAEGgwW6np+iwAAgAAWTD8XAAAABBoMFukx/tcAAIAABqw/AoAIgAAUTBbp1QqQCbb +UPqtAyAAEGAwW6aIG13rHl0GDl4CLraz/V4MEAAQQDD9trQgEBBIMG2aCvuJCgACAkIwJpa1Jbaz +LCANG193+SAMIDMANyAtsnf7sn4h/QA3IB5dna6eLuDlrO6u3gnuEa67K7yAj7AN/wx/eQfwABNg +ABBYMCsgVcDR+3sMDAUAY3CryyoiFIcQ/AoAIAEQaDBbDTBkcZwpQCYXXXb++v8gARB4MPKZEQ40 +ALlgGl3uBVwU+ckKCoABLDDwAA9oACBWcB1d6f2ZCApAASwwp5ooooAAsQQAbBoAsQQA/RoO3QMN +iAEMiAIopoAuQDZ85xGJESiRGLCICAhP+JUYIYkANiBuXgwaXfgGWRGqmYmQYAAfHF1YBVsUDLsK +KrKEK7KIBQxEAMEE8PkaCgkAWrAKmQHJlY4R2lD7QCYgABBgMP7hGCAAEGgwW55rK0BaGl8y/AoA +IAEQaDD6oogqwAFcMFsM+yZEWipAJiYkfyZFGSZFGiZENluu4yxAJhtd0gLMEfvMCAIAABKwp8ws +woD9EgEmAETmkC3QNGTQvipAJlv4jR5cSy7g0flAJiDeAPewf5cyACsRHV04CRwUDcwKKML0gk4t +IQMiIQLH8v0iDAngAUAw+LgCAgUAF/D4xvQiAAAQ8NEP2yAdXSwJHBQNzAoowvSCTh5dgi0hAyIh +Asfy/SIMCABAcjD4uAICBQAX8PjG9CIAABDw0Q+PTiLxAy/xAvL/DA/yEHAwD+M50jDRDygiFCmB +AyiBAv8CAAf/K04Q0jDRDwAaXAEqonipqgmqEfP+DGoAIFbwjBEtwCIC3RGr3afdKtaAKsUZY/8r +AIoR3GD6ohwgARBoMFsMtGP9OQAAAIoRKKIdiIH7CgEgABBgMAuAAPP+ZWABEHgwbBAE9SANIDIA +tOAXXArKVyNyfCYgDPJygyAxADVgFF0BpGQkQOWlRKQ0CUQRpCIiLICCIAMiDNEPIiBVwEHzIggE +BQAtMAUiDNEPJHJ7pkQJRBGkIoIgAyIM0Q9sEAQoIhAPAgAPAgApgQMogQL5gXx/9BAwMMBA+iwA +AAgQWDBYKPf2oXFiAAAasCoiENMPK6EDKaEC+5E+cAAQKDDbQFsMs8DA/QoAIgAAIrD6LAACAABZ +MFv+mPahNGIAABqwKiIQ0w/TDy2hAyyhAv3BB3ACAilwaVjFKaEDKKECwPH5iAwAABBwMAj+OGTv +idog/Ar9IAAQWDBYKh3ToGYw74oqDwIAK6EDKqECe6F3wDD6LAAACBBYMFgo0fag8WIAACKwiios +oQMroQL8sT1wABAoMNswWwyOHVvhHlvg+woAIgAAGrD6LAACAABg8Fv+Lfagn2IAACKwiiouoQMt +oQL+0QdwAgIpcGlUxiuhAymhAsCB+5kMAAAQeDAJjzhk/41gAAIAwDDaIPwK/SAAEFgwWCn39qBb +YgAAIrCKLS2hAyyhAn3BS9swWwxxHVvDHlvD+woBIgAAGrD6LAACAABg8Fv+EPmsAAIAACKw9qAi +YAEQeDCKLSuhAyihAvuIDAAAEHAwCP44ZO+70pDRD9Iw0Q/SQNEP/wIAD/+AspDaIPsKHCIAAGCw +Ww5YY/7sdqng2iD7ChwiAABgsFsOU9JA0Q9sEAoWW7gvIDUcW18tIAyFMSjCeC4gNPnCgCAAEFgw +/YgIBOgBLDD1BQYJkAQ6IPRQFGgAIEZw/uIjYAcQQDD4JDQgBxBwMPpbqxgsALugGF5CCOgKiICf +GZkYCoAAKyQ0HFumLSA1FlufLiEWE1ubL2IVIxYAKSIK+RYBIAUQUDD1FgIgMBBYMFgq7CpiFfs8 +AAIAAGFwWCoV0lDRDxxbmP1iFSAFEFAw/xIJIDAQWDBYKuIWW5UaWzUVW5LwCgcCAABJsPAJoAIA +ADqwAElhAElhAElhHFuHGFtMKyAMKSANGluK+IDRK4AEPuD/W4gYCQBecPqZAgIAAHFw+cYsKAAB +QDD5W4MeBQBD8C7FXCnGLS0gNfoSCCAAEFgw+8TBLcAEP2D9xMAiAABZsPxbehIAAGkwW+pbLPqN +9awAB/+tZpBlrxkcW2srwVwLC0srJRYswWQeW3H+FgotQAFgMCwlFyngASrgACokNikkNyoSCCjg +Ai/gAy8kOSgkOC3gBS7gBP4kOiBsAiiw/SQ7IAEQYDBYCVsuEggcW2EtIRYv4BQo4Qgp4Qkr4A0u +4AwvpBQopQgppQkrpA0upAwqJhEvIDYuIDcuFgCOGSsgOJsRKiA5mhIpIDqZE/ggOyAwEFgw+BYE +IAUQUDBYKpOPGBxbTCghFy3xCS7xCP/wFCAFEFAw+BYAIDAQWDBYKouIICo8GviIEQIAAFlw+DYD +IAYQYDBYIxwTWzMqPf4qohVYKdP9EgogAhBYMCskNGAAEh1bNvda0RIAABqw9Sw2IewCM3DwBwcC +AABJsABJYQBJYQBJYQBJYR9bLy4hFvtbLxABEGAwLDYt+zVcLgkAe7AuNiwqUAEpUAAp1AAq1AEo +UAMvUAIv1AIo1AMsUAQuUAUu1AUs1AT8WxsSAABZsPoiESIAAGkwW+n6KPqN9awAB/7rxpBlrZbA +kykkNGAAChdarvZbDBIAABqw/FsUEAUQUDD9IRggMBBYMP8SCSIAAHGwWCpRwOHwBwcCAABJsABJ +YQBJYQBJYQBJYRxbCRpbCSshFi42LSo2LvoiESIAAGkw/Fr8GgkAZvD7NiwiAABZsFvp2/76jSAE +EGgw9awAB/6rdpBlrRUtJDRgAA/3Wo4SAAAasPZa6xAEEGgw/FrtEAEQcDDwBwcCAABJsABJYQBJ +YQBJYQBJYRpa7x9a8CkhFv41XCAAEEAwKDVdLTYt/zYwIgAAWbD6IhEoCQBWcPk2LCIAAGkwW+m9 +K/qN9awAB/5yXpBlrKPAtSskNGAAChdacfZa0BIAABqwwLLwBwcCAABJsABJYQBJYQBJYQBJYRla +1yghFhpa1yo2LyUiESs2Lfla1RgJAEowKDYs/VAMKPgBQDD5iAoAAhBgMPiCSCAFEHAw+N0RAgAA +WbD+3QICAABRcAuAACwyLYtSDIxH/AwGAE4ANuAdWrZk0EMrUA0ZWnIqUAz5koMhzAA24B1av/xa +TBwAIG6wLd0BLdBNLMJ5q92tzAnMEayZKZyAjpeO7h9ap5/g9OYBL40QEDDRDy/6jfXMAAYA1f8Q +ZcvK+iwAAAMQWDBaxCnAhigkNGAACwAXWjj2WpYSAAAasPAHBwIAAEmwAElhAElhAElhAElh/Fqj +EAUQKDD9IRYgBRBQMP4iESAwEFgwWCnWGVqeKCEW/lqdGAkASjAoNiyPKhladPoiESAAEGAw/89Q +AgAAazD/nTkMBQB7sP0KASwJAGsw+VqMHAkAazAsNi39oAwo+AFAMAmICiiCSPjdEQIAAFmw/AxH +DAkAL3ALgAAlMi30SUEE6AEsMPUFBgsMADZg/wIAAf2ehmAtIAxgAAoXWgn2WmcSAAAasBxafC4g +DY8gKiA1mhApIRaZEfgiCiAwEFgw+BYCIAUQUDBYKakbWlvwBwcCAABJsABJYQBJYQBJYQBJYRha +biogDCkhFi8gDRxabPuZAguABDqg/DYtLgkAV/D5NVwuCQBH8C82LC4gNf0KACIAAFmw+hIIL8AE +O6D+NMAgABBgMFvpLPWsAAAXADag+goCIDAQWDD8WloSAABpcFgpi8Cg+iQ0IgAAEXDRDxtZ2iuy +eKq7CbsRq5mOl47uneD05gEvjRAQMNEP0sDRDwAAbBAEgieCLoIv0Q8AbBAEgieCLiMiEIIvoyKw +ItEPAABsEASCJ4IugiTRDwBsEA4WWcbzYoYiAABQ8CgyWpIU+hYFIAAQODD1bf8gjAA2ICxiImAA +BgAtMlpk0Hr0CgAv9gA3IPoyWCIAAFkwWwqnK2JyZqBWKVLAqrsJuxGrmSmSCmSQRiKSCPQgQGCM +EGgwLCBofcE1+1nLH4wQcDD+JGgiAABQsFsH2yekEo8i96UIIBoAt+ArIAf7C0ECAABQsPu8GCIA +AGCwWxJtLFJisUR8Q49j/34sUmP0wO5vwBAQMPAATmAAECAwjsct7CAC3QH35RQggAJrcJ3pneiX +yJfJl8qXy5fMl82XzpfPJ8YQJ8YRJ8YSJ8YTJ8YUJ8YVJ8YWJ8YXLFJjJEwB/wIACgBOYRAtYnMs +UsCtTQndEa3MLsIM/BYGIUQAf7ArwhL+MmsgkAJjMPwWCSqIAVgw+qoPAAEQaDD+qgoAABBgMPqi +ACvwAVwwWwo1jRaP14gZLvwg94YALgBAE7D39RQggAJzsJ75nviX2JfZl9qX25fcl92X3pffJ9YQ +J9YRJ9YSJ9YTJ9YUJ9YVJ9YWJ9YXLFJjsUT/AgAL/7ZlECkyWfkWCiD+AlMwCnoUKpUEJ5UF/JUC +JMABYDD8lQMgIAJicPyWACAsADUg2kD7CgAgARBoMFsGQGiuF4wa+kwAAAAQWDD8wgAgARBoMFsG +Ommu5yxSYMrGwEAsYnAqUsCsTAnMEfyqCAAAEFgw+qwgIEAQYDBYIZEsUmCxRHxD2S0yVv0WCyD+ +AnMwDn4ULtUEJ9UF/NUCJMABYDD81QMgIAJjcPzWACAsADUg2kD7CgAgARBoMFsGIGiuF4wb+kwA +AAAQWDD8wgAgARBoMFsGGmmu5y4yVSRSYC4WDCflBSTlAvTlAyAgAmOw/OYAIP4CaTD9fRQEwAEg +MP3lBCAtADUgBEoC+woAIAEQaDBbBgporheMHPpMAAAAEFgw/MIAIAEQaDBbBgRprucsUmJkwHDA +QG0IaC5ici1SwK5OCe4Rrt2P1y78IALuAff1FCCAAnOwnvme+JfYl9mX2pfbl9yX3Zfel98n1hAn +1hEn1hIn1hMn1hQn1hUn1hYn1hcn1hgn1hkn1hon1hsn1hwn1h0n1h4n1h8sUmKxRHxLAmP/kC8y +WP8WDSD+AiMwBHQUJ/UFLPUCLPUDJPUE/ARGACACY/D89gAgLgA1INpA+woAIAEQaDBbBddorhmM +HfpMAAAAEFgw0w/8wgAgARBoMFsF0Wmu5SxSYWTATsBAKGJxIlLAqEgJiBGoIo4n//rAIEACa7AP +3QH35RQggAJrcP3mCSIAAFkw/eYIIAAQYDD6MlcgARBoMFsJkZcrlyqXKZcoLFJhsUR8Q7IiMlcp +zH8JeRQpJQQnJQX8JQIkwAFgMPwlAyAgAmCw/CYAICoANSDaQPsKACABEGgwWwWuaK4V+kwAAAAQ +WDD8IgAgARBoMFsFqGmu6RpY2SlSwCtieCqg0Qm7Ef+nE3gAIF5wK5Ini74rshCwu5sXYAALLJKn +jM4swhCwzJwXLQqADT0ILRYPLdC0/wIAAAC3J2AcW50dW5stFg78FgggABBYMCsWEShibyQSESJS +wKhECUQR/BIOIgAgILAtIgAuIAwkIgcvIA0oIDX0Qg4gBRBQMPgWACAwEFgwWChBKSA0/wIABgDu +gmD6KiAgABBYMPpKCACQEGAwWCDdKkwQ/CoQIAAQWDBYINn6KvAgABBYMPpKCAAsEGAwWCDU+jog +IAAQWDD6SggAcBBgMFgg0CQiD2RAlSwSCC1CAC5ADClCBy9ADSggNSmSDvkWECAFEFAw+BYAIDAQ +WDBYKCEqEhD8CpAiIBBYMPsKACoAIFqwWCC/KhIQwLD8KhAgIAJSsFgguyoSEPsq8CAsEGAw+woA +KgAgWrBYILUqEhD8CnAjIBBYMPsKACoAIFqwWCCwl0iXSZdKl0uXTJdNl06XTydGECdGESdGEidG +EywSEScmEycmEicmEScmEJcvly6XLZcslyuXKo0flyknJggt0LQszAH8FhEt/1drEIUXihRbBjKK +M/xcEQAAEFgwWCCYijQFXAr9zBEAABBYMFgglPQyASPwBDlgKCx/CHgUKEUEJ0UF8kUCICACYTDy +RQMiwAEQMPxGACArADSgAioC+woAIAEQaDBbBSRorhX6LAAAABBYMPxCACABEGgwWwUfaa7pgjIp +XH8JeRQnJQUpJQT1JQIiwAEsMPUlAyAgAmCw/CYAICsANOADOgL7CgAgARBoMFsFEWiuFfo8AAAA +EFgw/CIAIAEQaDBbBQtprunRDx5YdI0qLBIR+xIFIgAAULD+CiAsAEB3cP0mCiwJAHMwW/ywY/4A +AABsEAoVWBEvIAwZWQIWWA4UWusYWSsoFgQrQrIsQrMuQrT6YnggABAYMP4WByAAEDgw/kKvIgAA +EnD8FgUuACBX8Pn/EQAEEGAw+xYGLgAge7AoIf8vYnz9Qq8gvQA2IK8/Cf8Rr90t0CL5EgQkAFWT +YAAFiyrgDJ4QH1jmDdgJ++ANKcAEOiD7FgEuACBH8J8SAElhAElhAElhAElhL/H/LBYJ+hYIIHEA +N+AaWF4pEgErEggcWtseWQP9WFsZwAQ7YC3GH/jEiC4JAHPw+FhOG4AEPuD7EgQoCQBecC7FQPiC +XCAFEGgw+hIAKAkAVnD5xh4gBBBgMAuAABpaySqiH4wZjhD6ihQA/xBIMPsSAigAA9JQJ7Z/8zwB +If4CYzD1zy1gYAIQsBtarPxYuhAQAkrwKcaGKcaHK8aE+8aFIGACUvAqxpD6xpEgcAJC8CjGkvjG +kyDQAmrw/caeIMACevAvxpwvxp39xp8gYAJ78C/GqP/GqSBgAmtwLcaqLcargueCLiPCNoIk9zUF +ICACYPCcMCI1AvI1AyD+Aliw+3sUAsABEDD7NQQgKwA0oAIqAvsKACABEGgwWwSRaK4V+iwAAAAQ +WDD8MgAgARBoMFsEi2mu6RJakw8CACMiQyIiRCc1BSI1AvI1AyAgAmDw/DYAIP4CQLD4eBQCwAEQ +MPg1BCAqADSg2iD7CgAgARBoMFsEe2iuFfosAAAAEFgw/DIAIAEQaDBbBHVprukpQk3BMAkzNsk+ +wCAaV9n7LAAAABBgMPqiCyABEGgwWwg+sSJzKeQpQk3yCgAgcQA2YChibiNCr6goCYgRqDPaMFqu +44s3+frAIEACUvAJqgH3tRQggAJSsJq4mrmXOfc2CiAkEFgwKzQF8AUHAEACYPAATGEATGEATGEA +TGEATGEATGH6EgciAABYsPwKACABEGgwWwghK0JNsSJ7I5IrQkwjCgAPAgD1FgMg9gA24BJaUSUW +AyhibSVCr/0imCgAIEDwCYgRqFX/AgAGAGWvUCkipP8CAAYAYC5QKiKw/wIABgBarpAsIrz/AgAG +AFUvENpQWq62jVf/+sAgQAJzcA/uAS7sQJ7YntmKW/fVFCAUADaggqtbBY76LAAP9wC0oBJaNYpc +DwIAZKAPgqtbBYj6LAAP9wC0oBJaL4pdDwIAZKAPgqtbBYL6LAAP9wC0oBJaKZdbJ1YKKBID91YJ +ICsQSDApVAXwCAcAQAJZcABLYQBLYQBLYQBLYQBLYQBLYfoSBSIAAFjw/AoAIAEQaDBbB+ErQkyx +M/8CAAv/jFzQKUJL9QoAIKwANmAoYmwjQq+oWAmIEagz2jBaroSJN/v6wCBAAlJwC6oBKqxAmpia +mYo595UUIBEANqCCq1sFXPosAA/3ALSgijrIq4KrWwVY+iwAD/cAtKCKO8irgqtbBVT6LAAP9wC0 +oJc5jBP3NgggPxBIMCk0BfAMBwBAAljwAEthAEthAEthAEthAEthAEth+hIGIgAAWXD8CgAgARBo +MFsHtS1CS7FV/wIAC/+ubVAeV0cZWPyX7yfmEJfuJ5Z/J5aLJ5aXJ5aj0Q8AAGwQBB9Z4f1ZOx// +EHAw9lkvEAEQUDAnICIoIgor0q4AcQQAqhr0gHJsAEBasAwMR2TApPC3F3IAAGLwC8hC+HkMcAAQ +SDD5ZIAsAEB68A6oAwjIAS9hTysKA9MP+NauLgALftApIAwaVvBolnIqoNF/pwJokWkrYU57twUs +IAxoxXX6LAACAABY8PxMAAIAAGlwWABlCqIC0Q8AwMDwtxdyAAB68AvIQnh5DB9Zt8CA+GSALgBA +fvD+qQMCAABY8Pn5AQIAAFFwKdauWCWPwCDRDwAAAAAAAPP/wW+5EGAw+iwAAgAAWPD8TAACAABp +cFv+m2P/fwAA+iwAAgAAWPD8TAACAABpcFv832P/cwAAbBAEjzLA0fpcAAIAAFjw81j1HlEBfDAi +ICIsMq4AIQTw3RoCAABzMPwIRw4ADm8Q/wIADgBmQ1CJsiz6/wzcA/zsAQAAXj5QDFhS+P8MDrAE +O+AP7Dn/WNkQdADDMImy+URSAGAAinAJeFD0LhEI0AQ6IPjuAgkABDkg/lmAGAkAcjAIzAIOzAIM +Dkf09IAgeAA3oAzcAv5W9RxVAWQw/MlCCB4BYDD8Nq4oIAQ6IP7OAQAOAEMwYAABwJ/48IAsCQBD +sA/dEA3MAvidEAjABDogDYgC/VaQGAkAYjCYsi7yIZ6zLdDS/AoAL/gQQDANjDhYJUHAINEPAAAA +AAAAAPP/7m+5EGAwf5aIGVih8/+CbABASzAAAGwQBIgiwnr2V0UQ0QC2IAIqAlgQymWgwxxZVP0g +DCADEFAw/iANIBAQWDBYJgGMJy3JFBdXfPkiAiBAAlsw+sIJIGoAN2BkkHz/CiogYQA2oC6gABhX +cvyiAiAUCHuweMFdd8FC2rD8CgIgABBYMFsOJBtXbZagjCCXopOl9KQcIAIQaDD1pgYgABBIMPum +BC2ABDsg+aQdLAkAazD8pgEiAABRcFglM8Ag0Q/Jltqw/AoCIAAQWDBbCqBj/7MAAHfJrmP/4dpQ ++zwAAAAQYDBYJQPaIFgdB9Kg0Q+MJw8CAC3JFPTQYGBAAlMwi8lksFYusAB36QgYV0kvsgJ48UD7 +CgAgAhBgMFsN/R1XRBtZF5agjCCTpSSkHJWmm6T9pgIv/xBIMPjMEQACEGgw+aQdLAkAazD8pgEi +AABRcFglDcAg0Q8AAAD7CgAgAhBgMFsKemP/tAAAbBAEHlhcKCAN/eKuIBsANiD6LAACAABY8PxM +AAIAAGlwW/+h0qDRD4kzZ5AbH1j62lD/3QICAABY8P3mriAAEGAwWCTRwCDRDyggIhlWNQiIEQjY +AgmIAooyKOauWq1KwCDRD2wQBIowCjpEbqkQ2lD7PAAP6hBgMFgkw8Ag0Q8YWOcIqAqIgPs8AAIA +AGEw/VwAAgAAULALgADSoNEPAGwQBIww/AlCAgAAWXD6PAAAYQA2YGiRWf5Y2hLCAjpgHVZP+sYi +cgAASzAP6jCIMokzDYwCLOZ8KeZ9KOZ8DOowiTAPzAxgAAHAwHmWGgjqMI+iDfkCKeZ8KeJ9maMv +5nwP6jAI/wyvzMDQWCTR0qDRDy362vP/8mAAEGAwxtrz/+hgABBgMABsEATSMIogCglC81wAADsA +NmBokUf4khdv6hBoMMDA+iwAAgAAWPBYJMDSoNEPAAAE6jB6rjZ5rk/A0MCADOowBMwMDYw6Y//V +CeoweaYTDOowCcwM8//Gb+oQaDAO6jAtIAjG2vP/tmAAEGAwKiAIKyAJLCAK/SALKiYBUDBYIFdm +oCOKIHmmryogCCsgCfwgCiomAVAwWAaqZqAKKiQLY/+VAAAAAADz/49v/xBoMGwQBooyiDAZVdD9 +VkMQtAAmMPhW3xoASVZQDqoR+fr/IBEQWDBtugf5htQgCAJCMBJW2A2rAismvRpYhComvFgFuPes +AAAsADag+jwAAgAAWXD9fAAAABBgMFgkh9Kg0Q8AAAAAAAAA8//eb+oQODAAABRWxxZYdiwi8Pw0 +ECAiAhDw2iD9Qu8iAABYcP0WACAEEGAwWB2xJEz89knkcAgCELBj/6MAAPP/nm/qEDgwbBAK1iAL +6jAYVljTDyiCf/8CAAoBOkbQHVWCGlZTF1hhLdI1K6Z/8nIBIAAQYDD6on4gEAI58FgmSh1VeS3Q +0fK1DAABEHAw/nQAIBQAc3AuMABo4ynH/v9vAQA4EEAwePEcwKX8WFAQCBBYMP8wACIAAGkw9RYA +IgAAcbBYJPTBg/8CAAoAtSoQF1bv0w/TDyZ2vRpYRhtVt/0KZCAAEGAw/goKIAMQSDD5dr4gABB4 +MFsHvh1WLPKsAAHcADag9RYGIAAQSDDzFgUhNQA1INWQ9hYELAABMDD8Fgch/gJZMPsWCCADEBgw +8AASYAEQMDAAAAAAAAD2CgEgUgA04I0YDwIA/hIHKgAD7VAmCgD04Hlj8AQ5oBtVl/J2viAAEGAw ++FgjEGQQaDD6WCAQChBwMPgWACAAEHgwWwK48qwAAJwANqBmIMaxVXRTqR1WBhRYFAvqMCnSf/8C +AAoAu07QHlUvLuI1K9Z/KtJ+/AoAIgAAa7BYJfqbQfpGACDsADTgGFgMwPAvhADRD4gVDwIApYgo +gAAodr0aWAT7VXUQABBgMP8KASBkEGgw+VgAHgkAfLD/dr4gChBwMPkWACAAEHgwWwKV8qwAD3oA +tqArcr7/AgAD/7eG0GAALooV+XK9KgAgKrAppABj/1cAAPtX8BAUEFAwBaoMWwK2Y/6IFFfo8/9M +YAMQGDAAIvq5HFfqjxWOFI0WL/AAlhL1FgEgBBBQMP0WACAIEFgw8hYDIgAAaTBYJIaIGHhTbLAz +CuowGVT3KZI1CZkKCpkKCuowCpoMaqEICuowCpoMa6H28/6TYAAQKDAAAMCh/FfTEAgQWDBYJHYc +V8/AsPvEAC/7EBAw0Q8AHlW4LeJ+sd0t5n5j/YEAAC5yvv8CAAP/EIeQ8/4Zb7kQEDDAkCl2vRpX +vxtVMP0KZCAAEGAw/goKIAEQQDD4dr4gABB4MFsHN2P/aSrSfrGqKtZ+Y/6CAGwQBv9UzxD/EEAw ++goOJgCTxJCvKSmQ5P4KASAAEFgw0w/5CUQP5xBoMPqZJHAUEEAwLBrA/CwCAgAAU/Btig8ooXQN +iAH4wX5wBAJSsLG7tCITVQss8OcAIQQqMPwA6Rr5BEMAABAQMPQUACCqBFJwLfDk+PDlIAAQSDD+ +8OYsgAFsMP3c9yABEFgw/bk4CIABQDD/nAEh7gJCMPj5OA6AAXAw/ZwBIe4Cc7D+2TgMgAFgMPuc +ASHuAmMwDLk4b5JY0Q8AAAAA+VVaEf/CLuDH3/+7ImAAEBgwKJKEALEEADoaALEEAOwaDcwDDIgB +CogCKJaEY/9XKJLAwcMLzAwAwQQAOhoAwQQA7BoNzAMMiAEKiAIolsBj/zQqCuD7HAAAARBgMFv+ +/vagDWIAABKwJDT80Q/AINEP0qDRDwAAbBAEGVbv+zAIL+cQYDD+Cg4gFBBAMPmQqSGwAlJw/7Qe +bAAgVvAt0OT9DUQAiADycH7ZDi0agPAAPGwJAG7wAHyfMMTg+woALEABXDD+ChQsCQB3cG3qDy+h +dAz/Af/RLHAEAlKwsbvwACJv+xBYMAB+0b8tGofAsG2KDymhdAyZAfnRCHAEAlKwsbvHuxlVGP+7 +a2ABEFAwLJKFALEEAK0aDcwBDKw5ZcBriTD6lnl/6hBoMCswCSwwCiowCC0wEFge5gr4UP8KASAA +EHAwCP44/awAAEMAN6CJMNMPDwIAeZY0KzAJLDAKKjAI/jALICACaPBYBYvwAB1iAABqsPySwSHg +AnLwAOEEAK0aDcwBDKw5ZM+Txt3aMPtcAAAAEGAwWCMh0qDRD3mW62P/s2wQBIowKAoHDwIA/TEE +KABM0hB5plb9+UALwAFoMAzqMBtVZXDfUCq2sygKAP6ytCIAAFDw/jYHIBAQSDBtmhL7iQoABAJS +sPmStSACAkIwKaUPD+ow/PwMAAAQaDD6PAACAABZcFgjBNKg0Q/A0PP/62AAEGAwAGmRNhlUagmp +Aim2xSiyxi8xBQj/Ai81BS6yyp4zLbLJnTQpssiZNSiyx5g2Y/+rAMba8/+wYAAQYDDG2vP/pmAA +EGAwbBAEFlWO9DA8a7AEOKADqAIoZsEkZsIbVFT9CjIgARBwMPpVhxAAEGAw/GbDIAAQeDBbBlv2 +oFNiAAASsMCTKWbDYAALAASsAixmwcC6K2bD+1RFEAAQYDD6VXkQMhBoMP4KASAAEHgwWwZN9qAM +YgAAErAtYsItVQDRD8Ck/FVxEBQQWDBYI2/RDwDApPxWyRAUEFgwWCNr0Q8AbBAEFlVn9DA+a7AE +OKADqAIoZsEkZsIbVC39CjIgARBwMPpVYBAAEGAw/GbDIAAQeDBbBjT2oFJiAAASsCVmwsCRKWbD +YAANBKwCLGbBJWbCwLkrZsP7VB0QABBgMPpVURAyEGgw/goBIAAQeDBbBiX2oAZiAAASsNEPwKH8 +VU4QFBBYMFgjSNEPAMCh/FVPEBQQWDBYI0TRDwAAbBAGKTIAJDEEKAoH/wIACAClShD7U5EWgAEk +MPRxL2SIASAwLbJ8K7KA+goAIIAQYDD53REAARBIMP27CAAEEEAwbYoOLbAh0rD8uwgGAHcnULGq +izD6tjJwABAwMJkSBuowZJEC/DEFIgAAUTD9MQciAABZ8Fv/u4kSizCaEA7qMAbmDGAAAwAAAAD/ +AgAAAGom0A/qMP8WASECADZg8lUZG7AEOSD8MQUgPQA14IQRB6gCKCbBLCbCG1Pd/QoyIAEQcDD6 +VRAQABBgMPwmwyAAEHgwWwXk9qEdYgAAOrDAkykmw2AADIQRDK0CLSbBwLorJsP7U84QABBgMPpV +AhAyEGgw/goBIAAQeDBbBdb2oNViAAA6sC4iwi41B91wD+owBP8Mr2baMPtcAAIAAGGwWCJU0qDR +DwAAAP8CAAX/igKgZX8M8/8JYAAQSDAoMQX/AgAN/2dCIMba8//IYAAQMDCNEGP/viogJPkWAiBe +ADagKCId2kD4ggciAABZ8PwxBSAcAmjw/jEGIAEQeDALgACJEoswmhBj/uEpICTLmyIiHYInyir6 +TAACAABZ8PwxBSAcAmjw/jEGIAAQeDALIACEEfP/VmIAAGqwx4+YEGP+qYQR8/9Fb+oQaDCEEfP/ +O2//EGgwwKT8VMgQFBBYMFgixmP/JMCk/FYgEBQQWDBYIsJj/xQAAABsEAQUVBukIiMmgCIigdEP +bBAEiTD7VBYYQAFMMPpWFhBfADZgaJFa+lYTEroCOmCJMPqWHnAAEGAwDeowiDKOM6uvKPaALvaB +DOowiTANzAxj//95lhYN6jCPMquuL+aALuKBnjMJ6jANmQypzMDQ+jwAAgAAWXBYIf/SoNEPAGP/ +rBpV/mP/psba8//hYAAQYDAAbBAEiicoqRQXVBb5IgIgQAJasPqiCSBnADYgZJB4/AoqIF4ANqAp +oAD9VAsQGAhicIyifcFZd8FA2rD8CgIgABBYMFsKvh5UBxhTw5igjyCXopOlJKQc9aYGIAIQQDD2 +pB0vgAQ/4P6mBC4JAEfw/6YBIgAAUXBYIc7AINEPyZXasPwKAiAAEFgwWwc7Y/+1d8myY//jANpQ ++zwAAgAAYbBYIZ7aIFgZotKg0Q8AAABsEAQWVQ0YVb0IIxD1UzUSCQBE8PNm/yPoEBAw0w9tCAmw +IsgrKWL/eVACY//twCDRD8cr0Q8AAGwQBogzJjIAF1Oa9DICIgAASTD2BkICANAGECgiAikWAP1U +ChHdALYgZGFL/wIAAACrBaD/AgACAK4BoPvQfSIqAj2gKtE/ALEEAKoa/wIACgEh0RD6LAAAAhBY +MFgfyfaiFmIAADqwiTD/AgACAFMqUP8CAAIAZaZQ22D6LAAAABBgMFghA/ZTvB+NEGAw+SICIA4E +YrAHpzgsIgctyRQrzCD6wgkgvgA3YGSRHv8KKiC2ADagLqAAGFOt/KICIB4Ie7D/AgAGAHJHEHbB +P9qw/AoCIAAQWDBbCl4ZU6iMEB1TY52giyCWopOllaYnpB0spBz4uxEAAhBgMPmmBCoJAGbw+6YB +IgAAUXBYIW7AINEPAA7qMNog+2wAAgAAYTD+UsIQIAJo8Fgfp/agtGIAADqwD+owiTD/AgAB/56m +UAjqMPxMAAIAAFCw/TwQIgAAWbBYH/H2oJliAAA6sAnqMGP/FGSQZNqw/AoCIAAQWDBbBsdj/2Mq +0iD/AgAL/1bVEGABDSvSIf8CAAv/U90QYAD/LtB9LNE/AOEEAMwa/wIAC/9MZRBgAOgA/wIAD/+W +MxBj/1faYFv/g9yg+zwAAgAAUXBYIRvAINEP2lD7PAACAABh8FghF9ogWBka0qDRDwAv+o3/AgAH +/6T+kGP+hwAAKPqN/wIAB/+yRpBj/neMJynJFPSQYWBAAlMwi8lksFcssADC2n3JBx9TVY6yf+Gk ++woAIAIQYDBbCgmMEBlVNB1TT5egiyCdopOllaaZpPykHC//EEAw+LsRAAIQYDD4pB0qCQBm8Pum +ASIAAFFwWCEZwCDRDwAA+woAIAIQYDBbBoZj/7TH5PdS/REECHKw2iD7ChwiAABgsFsK3mP/bfP9 +4m/qEDgwbBAEiTCEMvqePXAAEBAweZ4Y+jwAAgAAWXD8LAAAABBoMFghD9Kg0Q8AANpAWCQAWCQX +CeowikCaMwjqMAmIDPP/zmIAIECwCOowiTOZQALqMPgiDAIAAFEwWCP1WCQMiTBj/6kAAABsEASC +JyYpFPIiCSA0ADWg+AoqICwANKAnIAAaUxaJIv0iBSA4CEHwepkUnTCLJiwgHCxEAPtWACAAEBAw +0Q8AxyLRD2wQBvosAAIAAFhw/BwEIBACaHBb/+qMEGagOSk8EPIJFgAgAlMwAEpjAAmGAEphCeow +iMErOQEaUhgImTILmQwKmTb4CE8JAAQ+YPjGASgJAEowmMH6LAAAABBYMFqorNEPAABsEAQXVNYS +UuMmcp4kck4CMgH4crEqAAawkKZEcksDwCDRDwkiEaKC0Q8AAGwQBBdR/hJS2CZyniRyTgIyAfhy +sCoABzCQpkRySwTAINEPAAkiEaKC0Q8AbBAEFFLOElLIIiJ/BDQBCUQRpCLRDwAAbBAEFFKkJECA +AwJDACAEBAQb+FGoEBQA/TDAINEPAAAkgnwogoCkIgkiEaKC0Q8AbBAE84hCAIAQSDD5OgECAGjg +0KmJ9ZyALgBnkmDVkPSg9WhIARwwLSAMFlGWKiAN8wxGDgByS1AuIFUrIFQZUq//YoAh6AIZsPSg +o2oAIHbwsLf7YnkgoQA2oKnYKIDlqoiouAmIEaj/L/yAifALmQx5wQ//AgAKAFB3EP8CAAoATDsQ +ZEBI+zJ8IDAANqD/MoMgdQA2oBhSmajdLdDlqt2tvQndEa39LdyAidALmQz5yQdwABBYMGAAC8DR +/ssMCgUAU3CrqyoiFFsCT2SgRyhieyIyg6WICYgRqCLRDwDz/zlowAEcMGP/MwAAAAAA8/+AYgAA +OvApYnitmQmZEfP/aG4AIE/wKGJ4rY0J3RHz/5dsACBv8MAg0Q9sEATziEIAgBBIMPk6AQIAbuDQ +qYn0nIAuAG2SYNSQ9KEBaEgBHDAuIAwVUU8qIA3zDEYOAHhLkC8gVSsgVBlSaP1SgCHoAhlw9KCv +agAgfvCwt/tSeSC9ADagCeYIJmDlCmYIBrYICWYRBtYIJmyAKGIAC4gMeMEa/wIACgBT/xD/AgAK +AE+7EPsyfCA1ADagLTKD+FJTEGwANqCo6CiA5aqIqLgJiBGo3S3cgInQC5kM+ckMcAAQWDBgABAA +AAAAAMDR/8sMCgUAU3CrqyoiFFsCBvhSeyBMADagIjKDpIgJiBGoItEPAAAAAPP/LWjAARwwY/8n +AAAAAADz/3liAAA68ClSeK6ZCZkR8/+dbAAgT3AmUniuZglmEfP/UGYAIDNwwCDRD2wQBCQgDchC +0Q8AABZRDRhSKvOFQgLgARww8mKAIBoANOCoWCiA5SRieaOIqEQJRBGkIiIsgNEPKWJ4pZkJmRGp +ItEPbBAE0Q8AAABsEAQXUgWnJyN2gCZygSN2gMePCEgDCGYBBlYCJnaB0Q8AAABsEAbLTScgANMP +90EvcAAQQDAPAgDTD9MPbQgP9HAUYAICQjCiiSeQAHdBEmP/4gAAAAAA8AAJYAAQEDAA2SCxkmQh +9xZT8ipgAPQKACEEADagbQgMJWABsUT0UAdgAgIxsGP/7GRA6ScgAGRw4/8CAAAAmSUg+AoALgCV +UdAZU+MIRgxgABcAAAAAAPqQACoAIBYwK7AA+EYMAEgIWrD4jAEgAFeFoPti4WACAkpwGlPXoov7 +sAAqACBSMCqgAHqzD/ujDnABECAw8AAGYAAQIDDHT2RAehZTzipgAPQKACBxADagbQgMLGABsUT0 +wAdgAgIxsGP/7GRAVv8CAAAAoqUg+AoALgCeupAZU8EIRgxgABL6kAAqACAWMCuwAPhGDABICFqw ++GEnYAICQjD7YuFgAgJKcBpTtqKL+7AAKgAgUjAqoAB6sxP7oxJwARAgMMfP/DYAIAAQEDDRD8dP +ZE/uFlOs0w8sYADAoPSsAAB7ADcgbQgMLWABsUT00AdgAgIxsGP/7GRAYP8CAAAA6qUg+AoALgDm +uxAZU54IRgxgABzz/xdiAABZ8PyQACoAIBYwK7AA0w/4RgwASAhbMPhhJ2ACAkIw+2LfYAICSnAc +U5Cii/uwACwAIGIwLMAAfLMR+8MQcAEQIDD6NgAgABAQMNEPx09kT/AWU4cuYAD5CjkgLxBAMPQK +ACIPADegbQgMLGABsUT0wAdgAgIxsGP/7GRAmWpBV/fpVHAAEGAwHVN5DEYMYAAjAMYq0Q8AAAAA +8/7/YgAAWfD+0AAqACAXMCuwAPxGDABSCFuw+GFhYAICYzD7YuFgAgJrcB5TaqLL+7AALgAgczAu +4ABgAAHbcH6zD/vjDnABECAw8AAGYAAQIDDHT8pHmjAqIADAQPsKACoAnlIQ/wIACgCU1lDcoPAA +vGGgAiswAAAAAABk4Vf2U1UQABAgMNMPbQgMLGABsUT0wApgAgIxsGP/6gAAAPo2ACYAIBUwJnAA +0w/0CgAhIQA1oPoKYCIAABGw+wpGIGYQYDBtCFEMRBH0NgAqAAiSEHKTCfAAMWGgAhCwAADyqxRw +QBBoMHLDDPAAHGFSAhCwAAAAAAD/AgAL/34TUP8CAAv/ehbQIizJokSUMCJwAfQgvGACAjnwY/+n +AAAA8/55YgAAWfD1zNAqABJWUARECvVECQACAlrw9DYAJgAgFvAqcADTD/qD3HIAAGKwZKB+KApr ++QpLIE0QWDD6Cm0iAAASsG0IFnghFnkhOHohQnshTyJwAfQgVmACAjnwY//iKDroCEgo+DYAIAAQ +EDDRD8ypYAA5AAAAAAAAy6Dz/69iAAA4sAZJEfk2ACAAEBAw0Q8aUAsKSij6NgAgABAQMNEPDEsQ ++zYAIAAQEDDRD8AgkhDRD5owJiAA9AoAL/EANaDz/sxiAAA4sAAAAGwQBCYgAPYxKnAAEDgwDwIA +0w/TD20ID/RgD2ACAjnwongmgAB2MQdj/+LAINEPALGC0Q+xItEPbBAEFVDhpSUjVoAkVoHRD2wQ +BCMgAAIkAvIKACAXADTgbQgMKEABsSL0gAdgAgIhMGP/7NEPAABsEAQWT+sVURrwAAlgABAgMLFE +aEkpI1K8fDcfA+owImI1oyII6jAIKAxqgeNtCAgI6jAIKAxqgddj//DAINEPxy/RD2wQBPNSmBD+ +AhCwAjIUAyIBIiwQ0Q8AAGwQCB5SxhRSxhlR5CwyASgiACmSuxdQ//b6+C//EBAw+YgMCh8BYDD4 +FgMgAFADEP8CAAIAtYcQ/FHZEmsANqAswV8aUPT9ChEiggA3IAM8Am3aHfYxDHAAEHgwekIEj8Vj +//8vpsAszPzyptQgCAJSsB9SrCg8CA8CAAjvOS92vFv/yPSsAAHmADag+VJuEACWrSASUcKIEimR +WCIizwgoFAmIDAeIEagi+xIDIgAAULBbAGhkohvaUPs8AAIAAGEwWB5cwCDRDwAAAPtRtBAAZ4cQ +K7Ff3DD6FgUgERBoMPp8AADHADbgbdod9jEMcAAQaDB6QgSNxWP//y2mwCzM/PKm1CAIAlKwHlKG +H1KDKDwI0w8I/jkudrxb/6JkoWpmoIcaUZ6NEosTLqFeDS0UKqLPDt0M/RYELXAEP2D9qggAABBg +MPoWASABEGgwWwAhixEPAgAssQMrsQL+EgQgNghi8C9yvRhScI0SCP8BD90CLXa9HFJtLHa8/FJt +EAUQUDD9EgIgBhBYMFge/R5SY/oSBSAAEEgwmRBj/piaFfP/E2/qECAwAAAA/lJcH7kQUDCaEIoV +Y/58AAAbUXcrsV9ksUAYUJP5CgAgERBYMG26CimGwPKG1CAIAkIw2iAcUlAsdrxb/2/0rAAA/gA2 +oMCQZUBMmRIaUIaLNSumwPtSTBH4AkDwiIUotsD4UkoR8AJ48C/yBS+GwP9SQRHoAnDwLuIFLvbA +LXK9HlCXDt0BDZ0CLXa9HFJALHa8W/9Z1KBmTnASUVWOEi8hXg4uFCIizw/uDAfoEagiKCEDLyEC +ePFF8/5Ob7kQIDAqcuV/pw9+pwwKyE+YEmP+DAAAAAAA8/4Eb/QQIDAscuX/AgAB/4z/EP8CAAH/ +iPsQDMlPmRJj/nmEEGP+C/xSJRAFEFAw/RICIAYQWDBYHrHz/edgABAgMAAAAAAA8/28b+oQIDD7 +EgMiAABQsPwKASABEGgwWv+7Y/3NAAApcuV/lwp+lwfz/vtp7AFMMMdE8/7xYAAQSDDGSvP+52AA +EEgwAAAAbBAGJBQA9BQBIgAAULBb+jwWUXsnCg71CgEv5xAgMPZs2CAAXa6g+gr+IgAAWHD6OgEC +AABhcFv5emagoPU6AgACAlhw+gpHAAEQYDBb+XT2oIpqACA0sCuw5PwawCAUEGgw/CwCCoABXDDy +EAEgMgg68MCwbdoPLWF0BN0B/cEIcAQCMbCxu9EPZr/6b7sjH0+oIvKEALEE8F4aD/8QQDAI6AMI +IgHyEAEuCQATsC72hNEPGk+fLKLAweML7gwA4QTwWRoP/xBoMA2dAw3MAfIQASgJAGZwKabA0Q8A +pi8v8OQPD0R3+SP8GsAgABBYMPwsAgAUEEAwbYoQLWF0BN0BfcEL+7wBIAQCMbDSoNEPZr/4b7sj +H0+GIvKEALEE8F4aD/8QQDAI6AMIIgEC7gL+9oQiAAASsNEP0qAcT3wtwsDB8wv/DADxBPBZGg// +EHAwDp4DDt0BDZkCKcbA0Q8AAABsEAb0FAAgMBBAMPaDP3ABECAw2iBb+eFmoDT6Cv4iAABYcPo6 +AQABEGAwW/kkZqAe9DoCAgAAWXD6CkcCAABhsFv5HmagCMAg0Q8AAADGqhtOo6ssLMDk/AxEAA4Q +aDB9ySTAwP0awC/nEHAw/S0CABQQeDBt+g8vsXQO/wH/0QpwBAJa8LHM0qDRD2bP+BlPT//LIG// +EHAwKJKEAMEEAEIaDisDC4gBCCIC8paEIgAAErDRDy+SwMGDDIgMAIEEAE0aDtIDAv8BD90C/ZbA +IgAAErDRDwBsEAYjMAgkICL/ICMiAGkM4PpQ7BAAZSTg+KCpL+cQaDDyCg4gQBBYMPwKACAUEEgw ++qzYIG4A8jD4ChQmAFOX0PQOQgAAEGAw+6wADgkAW7Btig8osXQNiAH44S5wBAJa8LHM8AAkb/sQ +YDD+Gocg6AQT8NugbZoPKLF0DYgB+OEJcAQCWvCxzCz6+xlPGv/LMWABEGgwK5KFAMEEAN4aDrsB +C9s5z7EooNEPAgB8jwJy+Tr4Mnxv6hAQMNEPAAAAAAAA+5LBIeACQzAAgQQA3hoOuwEL2zlkv8zG +LdEPxirRDwAuGoDz/4luCQBxMNpA/ApcIKAQWDBb/zLy+sMgGADmsNEPAAAAAAAA+wqiIgAAUTD4 +PP8iAABocP8KZiBoEGAw+Pw4AAIQcDBb/37SoNEPAPoK/yCgEFgw/RwAACIQYDD8TAkAAhBwMFv/ +dtKg0Q8AbBAEF0+pJnKBGE4p+goLIAkQSDD3cn0gmAA1oKJ3CXcRp2cicCNrIjhmIDUicCxoJVBo +IU1oIkpoJkdoI0RpJDQicDZ5IS7/AgAIAEUEoHohAmkqIMAiAjIKCCIKIiJN0Q95IcZrKgJrKST4 +Kr1gDhBYMHshtcAgAjIKCCIKIiJN0Q/AIwIyCggiCiIiTdEPaEU0aEcj+EgKYAAQEDBoSRh6QRUC +MgoIIgoiIk3RDwAMIhGigiIiTdEPwCICMgoIIgoiIk3RDwDAIQIyCggiCiIiTdEPwCECMgoIIgoi +Ik3RDwAAbBAGGk9wKaKBHk3w/QoLIAkQYDD7on0hdwA2YKK7CbsRq5sqsCP/AgACAKEKoGahOiqw +LNMPaKIaaKUX/wIABADIAqD/AgAAAM4GoP8CAAQAzgKgwND8UNkQBBBQMPRFCQAAEFgw/RYAJAAg +L3D+VQoCAAB48PhSbSIAAGiw+BYBIgAAcTBYHV0lUm3aIPtMAAIAAGDwW/+h+VBdHgEBIDD0DUAP +4AQ7oPQrFAwJAHdw8rsRDYAEP2D9uwgAARAQMPm5CAIAa4DgBQxBZqDsGlC8qrqIqx5Qu/WtQg4t +ASww9P8RDYAEP2D/3QIIAEByMA2IApirLqIcGFCzBX9C9/8RDgBAQ7AP7gIuphwvoifG0PUoRA4A +QG/wCP8CL6YnLp0EjuAdUKkYTkz8zxEOAEBrsA/uAv+dBC4JAEOwnvAooh8dTxYNiAIoph+PogL/ +Av+mAiJwADjgjagC3QKdqIuox84MuwGbqNEPAP8CAAf/YOaQa6oCa6kq/woOK/9ZgqD/AgAP/2d6 +kGP+o9EPAiUJDlUKJVJtY/7wAPP/LGAAEGAwAGg1Y2g3WGg4BWg5Un0xT/P+nmAAEGgwKJ0EiIAb +TvX6nQQoAEBaMJig0Q8psDb/AgAP/zbiUGP+dQAAAAAAAPP+bmABEGgwKrA2aKnx/wIAD/8vapDz +/lhgAhBoMAAA8/5OYAIQaDDz/kZgARBoMGwQBNog/DwAAgAAWTBb/z77T/scAQEkMPQMQA3gBD9g +9CkUDAkAazDymRENgAQ7IPyZCAABEHAw9qCPaAAgXnAv+sAskoP6rVEP8xBAMP7dEQwAQEMwDcwC +LJaDKJKIxrD7iAEKlQFUMAuIAiiWiC2Sifr4RQwAQH9wCN0CLZaJLJKK+p1FDABAezANzAIslooo +ko3HuPuIAQpGAVQwC4gCKJaNLZKM+gxFDABAf3ANzAIslowrkoIOuwIrloIvkoLHjgj/AS+WgtEP +KpKAG06tC6oBKpaA0Q8AAABsEA4eTrQcT6X0LAAADhBQMP/ifS/nEGgw+MCpIAEQMDD+4oEgCBBY +MP8jCAGwAmMw+4UBA5AEPOD8j09yACB08C8wI/cwLCAAEHAw+AoUJgCMV9DbwPowNSAAEDAw9A9C +AEAQEDDyMDYuCQAX8G2KDyixdA2IAfjxCXAEAlrwse4u+vvwAGFiAAArsPQgIGmQBD/gqekqkDYr +kCwrNCwqNDYpkDX5NDUgABAQMNEPAC8ahycwLCIwNvowNSIAAFsw/goAIBQQQDBtig8psXQNmQH5 +8QhwBAJa8LHux+srCv/17AAEBQAq8BlP/R5NuP+SASBAAkBwn4H5kgAgARBYMPmGACo+AL1gKeKF +AFEEAL8aD5kB8AAfaAUATvAAAAAAAAAA+eLBIeACQXAAgQQAvxoPmQEJuTn8MCwgABB4MP0KHyAY +ADZgwV91ySn/NGMgABAQMNEPAAAAAAD/AgAGAIDvENLw0Q8vGoDz/0RuCQB8sAAAAADGd/oKBSAY +EFgw/E/YEgAAaTBYHGD1NCwgABB4MP80NSABEEAw+DQuL60ANaApMCMqCg7/AgAGAGfWUCwaR/pM +yRAAEFgw/fr/IBQQcDBt6hAooXQHiAF4wUr7vAEgBAJSsCn6+xtNfCqywMGDCYgMAIEEAPwa8IEE +AAEQcDAA7hoN7gMOqgEMqgIqtsAaTOz/NGMg/xBIMPmkISAAEBAw0Q8AAAD/u7xiAABK8BxNaivC +hBpM4gCRBAD+GvCRBAABEEAwAIga/zRjKBEAajD5Cv8qAEBG8PmkISoJAHbw+8aEIAAQEDDRDwAr +MGP6FgwhZgA24CkwYrG6+jRjKgAL3lDAINEPLBpA8/8xbAkAYTAAAAAA+goFIBgQWDD8T5USAABp +MFgcG8Dg/jRjIAEQeDD/NC4iAABRMP40NiCgEFgw/jQ1IB0QaDD9NCwgABBgMFv9dGijCcCN/wIA +DgF7wpAsHCAMbAr8Fg0iAABRMPzAACCgEFgwW/1rwd32osRiAABasP4KAiFEADWg/wIABAD4gqD/ +AgACAPoCoCwwLC8K/3+xFigwIykKDg8CAP8CAAYA484QKgoIKjUf/wIABgBWbxAvCv/6Cv8mAHv+ +0Job+xYKJgCO7xCMHQRKAg8CAPzAASCgEFgwW/1O+hYOIAFGLqD6NDUgDQA1oAqtCg/dES00NSww +LPsKACD/EGgwd8kSLjA2cukMiBwvMDX/AgAH/2/H0I8anBSbE4kb/RYCIgAAcXD6FgEiAABpMPkW +ACAEEFAw/E9LEBgQWDBYG9HAINEPAGRumvswIyIAAFEwWBffKzBjY/6JAAD7FgovVAC1oNpA/AoG +IKAQWDBb/SmLGv0KHSACEHAw/6wAAADShqD/AgACAM6CoP8CAAgAyoKgLDAsfcECLjUfKAr//wIA +D/+OQ9ApCv//AgAP/4jK0MDwLzUfY/8EAAD/AgAKAIQGoP8CAAwAi4Kg/wIADACOBqD/AgAOAJCC +oCwwLGP+rIwd2kAPAgD8wAIgoBBYMFv9CPoWDyAAwi6g/QoMIAsQYDD+CgUgBBB4MPoWECCeADWg +CksUb7luaLhrwOL+NCwgAhBgMMH9f8EvjB0ESgL8wAMgoBBYMFv89tag9qFHYgAAWrD6NDUgAF4G +oG+kS8DaLTQ2LDAsYAABwLAtEhDz/ptgABBQMMHwLzUfY/46LjQs8/4XYgAAY7DAgSg0LPP+CmAB +EGAwaLlHfLFEbroVLjQs8/+OYAUQYDBvphzAmyk0NmP/rSwwLGP/eA2pAWiUWWiYYSwwLGP/aW+o +lcCsKjQ2Y/+NLjQs8/3AYgAAY7AALzQs8/9MYAQQYDDAwSw0LPP9p2ABEGAwwPYvNCzz/ZpgBhBg +MMCDKDQs8/2NYAMQYDDAmSk0NmP/Ry80LPP/EmIAAGPwLjQs8/8HYgAAY7AuNCzz/mtgAhBgMAAA +AAAA+hYKIgAAUPBb4fCCGtEPAPoWESAAJi6gwKL8TsYQGBBYMP4SESIAAGkwWBtJwCDRDwAAAAAA +AADyrAACAABQ8Fvh4tEPAAAA8qwAAgAAUPBb4d7RD9owW+Hd0mDRDwAA8hIRIgAAUPBb4djRDwAA +AGwQBhxNURVMZv9OGRAOEGgw9CAiIAkQcDD6ICMgARA4MP/82C/nEFgw9kwAANsANOB+oTN9oTAC +SxGsuyqygB1Oov8hGCoAQGqwKraA3UD+PAAABBBQMPxOnRAYEFgwWBsgwCDRDwAALvDRGUvH8EEE +APYA87D9oXNwFBBAMPoKACAgEGgw/U0CD/sQSDBtig8u8XQL7gH+0S1wBAJ78LGqKFLAwbMJuwwA +sQTwfxoP/xBQMAr6AwqIAQj/Ai9WwGP/cwAAAAAA/6vVYgAASrAuUoQAoQTwfRoP/xB4MA/fAw/u +AQ7dAi1WhGP/SSqQIPB4Gg//EFgwC4sDC6oBCogCKJQgY/8vAP8CAAYAUHaQ/wIABgBMbpAXS8kC +ZRGsVS5SjRxOayhSgC8gLCohGCoWACkgQvkWASIAAGmw+SBDIBgQWDD5FgIoDgFAMPgWAyAFEFAw +WBriKiAs+QoeIB8QQDD/IRgmAITGkP8CAAf/b06QZP7WKiBC+yBDLtAAtqBkvsjdYPxOUxAFEFAw +/lKNIBgQWDBYGtIsUoD/IRgsCQA7MCxWgGP+ogAAKPDR/wIAAAAQcDD/AgACAEhyEP8CAAAUEEgw +/wIABgBAbpDC0P1NAgIAAFOwbZoPKPF0C4gB+NE6cAQCe/CxqsebKlLAwYMJiAwAgQQA6xoAgQTw +fRoP/xB4MA/dAw2qAQuqAipWwCYgImP+/gAAAAAAAAD/q8piAABKsCpShACRBADrGgCRBPB9Gg// +EHgwD90DDaoBC6oCKlaEY//HGUtPAEEEKJAg8HsaD/8QaDANuwPw6hoIAEBaMAqIAiiUIGP+py8h +GGP91gAAbBAGJiAjwL76CgAgCRBoMPcgIiYBBm2Q/wIABgECXZAqJCwlIGj0IGkiAAAasAAwBAUI +G3+HDNpw+2wAAgAAYPBb/Y+xM2k45MAwADAEBAkbf5cM2nD7bAACAABg8Fv9A7EzaTjkKgrIKiUd +2iD8CgAgABBYMPskICABECAw9CRDIAEQWDBb/0D2oR1iAAAasMDJ/GEMcA4QaDD/AgAOAIXpkAvq +MBRN7tMP0w8uQnH/AgAKAN/20BVK4CtGcSpCcP1SNSAAEGAwWBurL1DRmxD4Cg4iALJz0P8CAAYA +rkWQGk3gG01hWvtJG03fjRAqJGIpQh8aTdv9mQwAABBgMPuSBnoAIFJw3KArQIAvUNEAcAT7DhsP +/xBoMP/nfn/nEFAw/wIAABQQSDD/AgAAAEDz0MCA+ESAIYcQeDD7XAAAABBwMG2aDyixdAqIAfu8 +AiYAUkfQse7wAJpv+xBwMLrv8PEEAAEQWDAAuxr5uQEAARB4MAn5OSumh82eCeowCOowKlI1DKoo +qpkImAxqgQgL6jALmwxrsfYtJGPAwfwkLiIAAFHwW/1t0jDRDwAA8HEEAAEQeDAA/xoN/wP/vwEA +DhBwMP9EgCYAT3WQBVsC/goAIEAQeDD/fwIAFBBAMG2KDyixdAqIAfjxCHAEAlrwse7H6xpLTPmi +hyv/sY+g8OEEAAEQWDAAuxr5uQEAARB4MAn5OSumh2P/XQAAAPwKDiAfEGgw/SQsL/8dYZAuCtAu +JR1j/jIaS5MbTQta+vMYTYqJECokYi9CHxpLjvn/DAAAEGAw+voIDf9XQ9Dz/qZiAABisC8agPP+ +zm4JAH3wKEJwsYgoRnBj/jkAAGwQBCMgI8BO8grIIAwEIPDRDyIK0NEPAGwQBiogI/MgIiABEFgw +/SBDIAkQQDD/Cg8mAEwCoP8CAA4AQ0KQKSAsaZR7KSBpCZ8CG01Y+QpHAAAQcDD8CgggABBIMG3K +PQCQBAoIG3+HMgkYQPkMQAngBDog+SgUDAkAQzD4zBEJIAQ6IKyIq4gogifwkQQIBQFAMACIGgju +Ag4OR7GZ/iRDIBwEe7DAkPkkQyAAEHAw+kvoEBwAN2DK4MAg0Q8AAPskQyAAEBAw0Q8pIGlj/3lk +7+ZgADIAAAAAAAACPBGqzCvCgB1NOw27ASvGgC4gQ/08AAAEEFAw/E0+EBgQWDBYGbnAIdEPAAAl +ICIWSo4CVBGqRC5CjRxNMC8gLChCgCohGJoQKSBC+RYBIBgQWDD5IEMiAABpcPkWAigOAUAw+BYD +IAUQUDBYGacqICzBj3ihPMGeeaE3KiEYy6ErIEL+IEMvjAC24GTvhN1Q/E0bEAUQUDD+Qo0gGBBY +MFgZmixCgAbMAixGgC4gQ2P/YAAuIENj/1kAAGwQBhVLrSggI/QgIiABEDAw+QoOIgAAGLD/MEIg +ABAQMP1MAAYAVc4QGkn9K6DRxuf8CmAgFBBAMPxMAgDYAPLw/UqzEgAAWLBtig8ooXQOiAH4wTJw +BAJSsLG7x5v60sEh4AJicADBBABrGvsKASoAQFqwCro5ZKBl9jRCIMoAN+DAINEPAAD/u9JiAABK +8CrShQCxBABrGvuqAQABEHAw8//SagUAU7AZShMpkCEAQAQJCRsJDED8NEIghAA34P8CAAAAWn5Q +0Q8AAAAAAADyNEIvrgA34GAAnAAAAAAA+tKHKgAYjmAAkQQAbBr6ywEAARBwMAvrOfzWhyAzALbg +8jRCL30AN+AtMCJgAGgAAAAAAAC6ngDhBABrGvq4AQABEGAwCMg5+9aHL9UANiD2NEIvTgC34GAA +DAAAAAAA/wIAAf+fflACQhGlIi8igBhMugj/AS8mgP4wQiABEBAw/UwAAAQQUDD8TLwQGBBYMFgZ +N9EPAAD3Sg0SAAAzcALSEaUiLiKNHEyuLzAsKCKAKjEYKhYAKTBCKRYB+TBDIBgQWDD5FgIoDgFA +MPgWAyAFEFAwWBkmKjAswY94oTzBnnmhNyoxGP4wQiA0ADagzuwrMEPKt91g/EyaEAUQUDD+Io0g +GBBYMFgZGSwigAfMAiwmgC4wQmAABAAALjBC8/9dYAEQEDBsEAb/AgAKAUyFIPpLKRI+ADkg/wIA +CAFkgSD4SwlgAhBoMMYq0Q8AYAAEAAAAwND8CvAgDxBYMAIjEfMWAyIAIFTwLjKAH0yEGUyE0w/8 +2BEOAEB7sP4KACgJAHIw/hYBKAkASjD4NoAgARBAMJgS+OwABgEuZVD6CgEmASpdUP8CAAYBKmWQ ++QoBJgEmXZAnMoUdSfMMXwEPAgD/SxIeBQB7cPOqEQ1wBD5g+t0CCgBAYbD/CgEoBQBT8P6IAgH8 +AnEw/QoAKAkAajAO/TgeTGQPAgD43REGAEB18P9JThYJAG3wCHcCJzaFL/DR/wIAAgBef9D/AgAO +ANi20BpK7CuivPRpEA//EGAwDJwDDLsBC5kCKaa8+mwAAgAAWTBb4jkXTFAeS80dTE/5CgAgCBB4 +MNMPbfppAJAEBQgbf4deb0MS+goAIA8ANSDwABRgAhBYMAAAAPhIB2AAEFgwaUs/wKEJHED5CEAN +4AQ7IPkvFAgJAGIw8v8RCYAEOiCo/67/LP0EjMAKqBH4uAIMAEBrMAjMAv/9BCwJADswnPCxmRdM +MvABumAAECgwwNL+TDAQBBBgMB9KwYsTD7sILLYHGkwsKrYIKLICGUwrCYgCKLYCH0wpL7YFGkwp ++qIAIGMANKD8EgIgAKcEoAAhBADMGv7MEQ//EHgwD88DCvgBCMgCeKlU+frSIgBuASD/AgAAAGoF +IC2y1AndAS221C4ygR9MGA/uAf42gSoAbQUgIjKBKPq9CCIB8jaBIAAQEDDRD4kS+EzwL/oQeDD4 +nDgIAEB6sAjIAnihqintBImQCfkB+u0EKAkATzD5pgAjLgC4oB5MAorhZKCi+QoDIACehqD/AgAC +AKKCoP8CAAIApQag8ACZYAAQYDAAAAD/AgAD/rPAoGP9d2SuaRtL9iyyvAZKFPSqEA//EGgwDa0D +DcwBDKoCKra8Y/5JAAD6Cg8v/tphkPP9tGAPEEgw8/1MYAEQaDAtssAeSrUO3QEttsAsstT5zAEA +KRBoMA3MAiy21GP/GC8ygSLKBQL/Af82gSAAEBAw0Q8AAAAAAP8CAAoAYQUg3KD/AgAH/21mkJzh +Y/7QAChM8PwKCC/1EHgw+Nw4CABAfrAJyQL/AgAH/1tOkGP/AwCxVf8CAAn/JwFgAFAEBgkbf5fs ++xoAIQAQYDD1GEAAMhBoMPUPQAngBDog9SoUDgkAR/DyqhEPgAQ/4P+qCAAUEHAw96oIAgAAeHBa ++v9kr67AovxLtxAIEFgwWBgkxyvRDwAAyyFoITWMEbAtDZw4Y/9cAMsiaCE8jBECnDhj/05oSzmM +EgLcOGP/Q48SAv048/87YgAAY3BpS8lgAAJoS8bz/ypiAABisGhLyPP/H2IAAGKwAGlLv2P/8AAA +8/8OYgAAYrBsEAguIGoaSiL0ICIgHxBYMPUgIy5gAXQw/SAsIDsAN+DzCgAgAKKH4C0gK87RKCBC ++SAgIAEQUDD8CgYiTwA2ICuc+gujOfwkICIAABDw0Q/SMNEPAAAA/wIABgE6X1ApIR8JCUUbSgoC +ShGrqpoU+qKAKgEyBmD/AgAIATYCYGmSBQpLQWSwGCwhHysgI/0gaCIAAFEw/iBpLKABYDBb/tAn +IGgmIGktICP9FgUgABAYMAAwBAcOG3/nDNpA+xIFIgAAYPBb+t6xM2k45MAwADAEBg8bf/cM2kD7 +EgUiAABg8Fv6UrEzaTjkF0imJiAiGEnnAmMRqDMuMo0cS0coMoAvICwqIRiaECkgQvkWASAYEFgw ++SBDIgAAabD5FgIoDgFAMPgWAyAFEFAwWBe+LSAswZ950Q/BrnrRCishGMi0LCBCZMGvLiBqLArw +/O4BAAEQeDAP7gL+JGogARAYMPAAGGAfEFgwAAJPEf0gLC4AIFfw/xYEIAAQGDD4CgkmAJvfUPkK +DiYAncVQ/wIABgCZzVD1EgQiAABQsFv9rh5IFvxJyBAAEFgwLSBBKlKN0w8PAgD00H5uAQFUMC0g +K/8CAAf/M/9QZPCQ+yQgIAEQQDAoJCsm4oX2Y1AAEBBIMPaIUgwAQGWw/Zs5BlsBMDD/iBEHsAQ5 +oPgzAgYJADLw9SAiIgkANPAWSaECVRGmVSNWgvxLFhIAAGkw+hYAIBgQWDD+CgEgBBBQMFgXfvP9 +9WABEBgwLSAswZ950RTBjHjRD8GeedEKLSEYyNQoIEJkgMwpICtkndLA8CskKy3ihSgKdvUKZigA +QGdw/W1QBAUATjDzICIsCQAvcBVJhAIzEaUzLTaCY/+IKCAiGkr5AogRqogaR7yqiIiACDhA+J8M +AAEQcDAP4zn4JCAiAAAQ8NEPAAApCvAJ6QEpJGpj/sDaIFv9xGP+yAAAAADz/VVgABAYMApLQf8C +AAP+zJrgY/27AAAKTEH/AgAB/sifIGP9qwAALiBDZO5J3WD8SscQBRBQMP4yjSAYEFgwWBdFLzKA +B/8CLzaALSAsY/4lKCBDZI8sKSBkZZ8mY/6MAAAAbBAE8oQUAuABEDATSs4oCoDzMn8oACBBMAKE +OApCEaIy0Q8AbBAEGErHAgtH8okUAIAQUDD4gn8qACBScAupOAqZEfQwRWIAIEowiiGJIASqjvKZ +GgIAAECw+SYBIAcQSDBtmhOJgvqGACAQAkIwioEEmY6ZgQSqjvqGACIAAFCwWBlu2iBYGWrRDwCK +IYsgBKqOBLuO+yYBIAcQSDBtmhOJIvomACAQAhCwiiEEmY6ZIQSqjpog0Q8AAABsEAQTSqIMIhGj +IoIg0Q8AbBAEFUqfDCQRpUQjRsAkQsDRDwBsEAQXSpwChBQWSpkGRRH3VQgFoAQ5IPQwNmIAIDEw +DgKIAcWKDAKIAYWKCgKIAUWKCAKIAQWKBgKIAMWKBAKIAIWKAgKIAEWKAAKIAAWK0Q8OBYgBwooM +BYgBgooKBYgBQooIBYgBAooGBYgAwooEBYgAgooCBYgAQooABYgAAorRDwBsEAQCgxTyR4wToAQ8 +4KMiIixw0Q8AAABsEAQTR/QcR7MCFBQXR5DyfhQJVQEUMPhHQB4fARQw8ppWAAgQaDDyu1QABBAo +MPW7AQQAQCyw/aoBBgBAaLD3ZhAMAEBEsPfuAQYAQDyw+EQBB5AEPeD/3REAQBBAMPuqAgRQBD1g +8jYUBAkANXDy21IGAEBhsPwsAQQJADEw8yYBDdAEOyD9CgIsCQBrMPtmEQoAQG7w8l0UBgkAObD3 +GgAsAEAfcPLzFAoJAH7w9zMBABAQeDD3CoAsCQB3cPuqAgAgEHAw8ntYCABAdnDynhQKAEB+8PLf +FAgJAF5w8jtcCAkAVnD6KgAqAEBG8PgoAQ4AQFfw/YgQCgBAULDz/wID0QEUMPOqEQIAQDzw9ycB +AgkAXPD5RyoSCQBM8P93EAQAEFgw8rMUDgkAH/D7MwEOAEBLsPh3Ag4JABuw/+4CACAQQDD7KwEM +CQB3cPW7EQQJAGkw+SkBBAkAYTD2RAIBABAwMPeZEQYAQDCw+5kCBxAEOaD5RAIGCQBRsPYKECQJ +ADEw+CgBBgBAMLD7iBAGkAQ5oPdEAgYJAEGw9goCJAkAMTAGJgHxIxAGMAQ5oPVCAgIJADTwAyIC +0Q8AbBAI+0oGEgAAULD8CgcgARBoMFr3dftKAhIAAFCw/AoHIAEQaDD4HBAgChBwMPgWACABEHgw +WvdTyaPAovxJ+RAIEFgwWBZcxyvRDwAAAAD7SfYSAABQsP9OEA0ABDzg/t0CD4AEOWD8SfEcCQB3 +cFr3XftJ6hIAAFCw/AoHIAIQaDBa91n7SeYSAABQsPwKByADEGgw/xwQIAoQcDD/FgAgARB4MFr3 +N/IKACAVADagwKL8Sd8QCBBYMFgWP8cr0Q/RD2wQBMspwFD3+vAvABAwMNMPbQgNcmANAoIU9CAe +YBACKXBj/+lycA0CQhTwAAdgCAIpcACxVQISFGUv99JQ0Q/AINEPbBAEyiuwI/MlAQ4AEpyQDwIA +DwIAbQgP9Fz/IgAAEXD0VQEOAAOkkGP/4w8iEdEP0Q/AIdEPAABsEAQE6jAYRpAogjUCiCioQgPq +MAMjDGoxDm0ICAnqMAkpDGqRAmP/8NEPAGwQBKMisCIDIizRD2wQBBNJrxRJrf8oDGAAEEAwAyMK +gzAKMADSgNEPIkLR80LSIk8BEDDRDyJC5/NC6CJLARAw0Q8iQuTzQuUiRwEQMNEPIkLh80LiIkMB +EDDRDyNC3SJC3gH0BAMiGAICQtEPIkLa80LbIlsBEDDRDyJC1/NC2CJXARAw0Q8iQtTzQtUiUwEQ +MNEPAAAAbBAEE0mNFEmK/ygMYAAQQDADIwqDMAowANKA0Q8jQs4iQs8B5AQDIhgCAk/RDyNC5CJC +5QGkBAMiGAICT9EPI0LhIkLiAWQEAyIYAgJP0Q8jQt4iQt8BJAQDIhgCAk/RDyJC2/NC3CPuARAw +0Q8iQtjzQtkj6gEQMNEPIkLV80LWI+YBEDDRDyJC0vNC0yPiARAw0Q8AAABsEAQTSWgUSWT/KAxg +ABBAMAMjCoMwCjAA0oDRDyJCzvNCzyPuARAw0Q8iQuTzQuUj6gEQMNEPIkLh80LiI+YBEDDRDyJC +3vNC3yPiARAw0Q8jQtoiQtsB5AQDIhgCAk/RDyNC1yJC2AGkBAMiGAICT9EPI0LUIkLVAWQEAyIY +AgJP0Q8jQtEiQtIBJAQDIhgCAk/RDwAAAGwQBBNJQxRJPv8oDGAAEEAwAyMKgzAKMADSgNEPIkKr +80KsI1EBEDDRDyJCzfNCziNVARAw0Q8jQsgiQskBlAQDIhgCAkrRDyNCwyJCxAHUBAMiGAICStEP +IkK/80LAI0EBEDDRDyJCuvNCuyNFARAw0Q8iQrXzQrYjSQEQMNEPIkKw80KxI00BEDDRDwAAAGwQ +BBNJIBRJGv8oDGAAEEAwAyMKgzAKMADSgNEPIkKq80KrIvUBEDDRDyNCzCJCzQGUBAMiGAICR9EP +I0LHIkLIAdQEAyIYAgJH0Q8iQsPzQsQi4QEQMNEPIkK+80K/IuUBEDDRDyJCufNCuiLpARAw0Q8i +QrTzQrUi7QEQMNEPIkKv80KwIvEBEDDRDwAAAGwQBPMKEyAdADSgcjsDwCDRD7sj8DEEAAEQEDAA +IhqwItEPAMcv0Q9sEAQYR/X7RfAdQAQ9IPg/EA5IASgw9CwQD4AEO6D/zAIMCQB3cPUKRwwJAGsw +DKoCC6oCKoaYJoaZJ4KYGUfRCXcBJ4aY0Q9sEAQjIA0vIAz0MgdggBAwMPlI3RI3ADfgLgoA/xoU +ABgAf/D+kOUgAgJKcPSgKmH+AmKwLZDl+5DmIAQCQnDTD23JEf2A5S4AIHNwsoj7gOQuACBy8K7e +rr6wOKjuKSAFaJMv/wIABABhAmD/AgAEAMSGYP8CAAYA0gJg/wIABgDXBmBomAfAINEPAAAAAMCT +KSQF/e0RDh4Au6AUSLzwAA9kACAjcBRIug8CAA8CAKTUF0ZsG0e29Ui3EAEQUDCnSSmSgAkISgiM +EQXMAgwMT/y2uyksAUwwbZkN8IkRAAICQjAKmQIptrxv7gocSKfwAAxsACBncB5Ipg8CAK7dp9kp +koAJCEoIjBEFzAIMDE/8trspLAFMMG2ZDfCJEQACAkIwCpkCKba8F0VF/wIABgBhg+AZRmD7coAh +AAA04Kn8LMDlKHJ5DwIAA8MIA4MICTMRA7MIIzyACPURKjIULqEDLaEC/wIABgBFd1ArCgBa9iT5 +MA0gPAA2oCswVcDB+roICAUATzAJqgwFpAL2RAIAARBgMPo8AAIAAFkwW/OH3KD7TAACAABQ8Fvo +Y2P/qgAAG0VFZJ/BLDAMKrJ8+7KDICAANmAdRjytzS3Q5anZqakJmRGpuSmcgI6QCuoMY/+nKXJ4 +rJkJmRHz/+xoACBO8MClKiQF2iBb6T32oFJgCBBgMPwkBSIAABKw0Q8AAAAA8/5GbgAgM/D6CgAg +CBBgMPwkBSIAABKw0Q/A2P0kBSAAEBAw0Q8AACNyeK8zCTMR8/8SYgAgHvDz/gpgABBwMNKg0Q9s +EAYTSEUuMp/4MqAoHgC4oBpISwoqCoqgCqAAwND6CgAgDxBYMPDkBAAAEHgw/v4YAgAAYLDw3xEP +4AFwMP/uAgAAEGgwW/9GGUUKLzKf/jKgKB4AuKAYSDsIKAqIgAqAAMDQwKDx5AQADxBYMP/uGAIA +AGCw+N8RDuABcDD/7gIACBBoMFv/Nm8oCh9ILw8vCo/wCvAAwOD6CgAgDxBYMPwsAAAQEGgwW/8t +bygKGEgnCCgKiIAKgADAoFv/HsC//CwAAgAAcrD9ChAgARBQMFv/I28oChlIHgkpComQCpAAwKBb +/xTAv/wsAAIAAHKw/QoUIAEQUDBb/xlvKAoaSBUKKgqKoAqgAMDg+goAIA8QWDD8LAAAGBBoMFv/ +EG8oChtIDQsrCouwCrAAwKBb/wLAv/wsAAIAAHKw/QoYIAEQUDBb/wZvKAocSAQMLAqMwArAAMCg +W/74wL/8LAACAABysP0KHCABEFAwW/78bygMHUf7DS0KjdAK0AAAAMDg+goAIA8QWDD8LAAAIBBo +MFv+828oCh5H8w4uCo7gCuAAwKBb/uTAv/wsAAIAAHKw/QogIAEQUDBb/ulvKAofR+oPLwqP8Arw +AMCgW/7awL/8LAACAABysP0KJCABEFAwW/7fLjKg+DKhKB4AuKAZR98JKQqJkAqQAMDQ+goAIA8Q +WDDwZAQAABB4MP7+GAIAAGCw8N8RD+ABcDD/7gIALBBoMFv+zv8oD2ABEFAwGEfQCCgKiIAKgADA +4G8oJBlHzQkpComQCpAAACsyqvEUBAAAEEgwC5kYCQlD+zKrIgSCqmAdR8X6CgEgDxBYMPXfEQIA +AGCw/+4CADAQaDBb/rjAoPsKDyIAAGCw/QowIAAQcDBb/rLaIFv+g/sKAiIAAGCw/Qo8IgAAcrD4 +7hEAABBQMFv+qm8oCh9HsA8vCo/wCvAAwEBvKAoYR60IKAqIgAqAAMDwbygKGUeqCSkKiZAKkADA +4G8oChpHpwoqCoqgCqAAwNBvKAobR6QLKwqLsAqwAMDAwKD1RUgQDBBYMPb4EAhwBD+g+t4QDFAE +PSD9iAIOCQBLsPvPEA4JAEOw/+4CAgAAYLD17gIAQBBoMFv+h28oCh5Hkg4uCo7gCuAAwKDAsf2u +EQIAAGCw/QpEIAAQUDBb/n5vKAofR4oPLwqP8ArwAMDgKDKg+goAIAQQWDDxZAQAABB4MPj/GAIA +AGCw/w9AAFAQaDD/7hAOkAQ/4PgyoS4JAHuwW/5sbygKGUd5CSkKiZAKkADAoMC4964QAgAAYLD6 +CgAgcBBoMFv+YwAUBC8yoSsyovoyoCAAEHAwD+8YKTKhAeQE+DKgIgAAYLD0MqEgdBBoMPQyoCAD +EFgw+pkYDgABfDDxtAQPEAQ/4PjoGAhAAUww+jKhKXAEPmD5MqAuCQBP8PGkBAAAEFAw9OQYCEAB +QDDxdAQJoAQ6IPnuGAQAASAw+0QRDkABcDD4/wIOCQAjsPQyoS4JAHuwW/4+LzKh+goAIAIQWDDw +JAQAABBwMP/uGAIAAGCw/Qp4LkABcDD/MqIvQAQ7oFv+MgGkBCQyoS8yoigyoSYyogT/GCQyofGU +BAAAEHAwCOgYJTKiJjKh8YQEAAAQUDD05BgADxBYMPkyoiIAAGCw9TKhLoAEP+DxVAQIAAFAMPbm +GAigBDog+DKiLgkAR/D4MqEkAAEgMPEkBATgBDkg9eUYBkABMDDxBAQHEAQ5oPYyoiQJADEw9DKh +LgkAJ/D46BgAfBBoMPCkBARAASww+TKiJUAEPWD2MqEoIAFAMPTkGAlgBDog8GQEBAkARXD27hgE +oAEgMPxEEQ5gAXAw9f8CDgkAI7D/MqIuCQB7sFv9+i8yovoKACAIEFgw8CQEAAAQcDD/7hgCAABg +sP0KgC4AAXAw/zKjLkAEO6Bb/e8ANAQuMqIvMqMPAgAPAgD4MqIgABB4MP7+GAAAEFAw8HQEAAEQ +WDD4/xgCAABgsP0KlC4AAXww/g5DD8AEP+D4MqMuCQB7sFv93C8yovoKACABEFgw8IQEAAAQcDD/ +7hgCAABgsP0KnC5AAXAw/zKjL/AEO6Bb/dEpMqH4MqIiAABQsFv9e/sKDCIAAGCw/qwAALAQaDDw +7hEAABBQMFv9xm8oCh9G1A8vCo/wCvAAwOAUQ8b1GgAoTAC4oBhGzwgoCoiACoAAAAAAAAAAKjKr +KTKsAfQECpkYCQlDzZ/wACZgABBoMCoysPG0BAAAEEgwCpkY+zKxKGABTDBkn94AkQQAXRoE3Tb6 +CgAgDxBYMP3fEQIAAGCw/Qq0LgkAe7Bb/aZvKAoYRrYIKAqIgAqAAMDgbygnGUazCSkKiZAKkAAA +AAAAKjKs8GQEAAAQSDAKmRgJCUP6Mq0gJQC2YPAAJmAAEGgwKjKx8CQEAAAQSDAKmRj7MrIoYAFM +MGSf3gCRBABdGgTdNvoKACAPEFgw/d8RAgAAYLD9CrguCQB7sFv9hi8yoi4yo/oKACAPEFgw8MQE +AgAAYLD/7hgBdBBoMFv9fi8yoy4ypPoKACAPEFgw8MQEAgAAYLD/7hgBeBBoMFv9ddogW/0i+woM +IgAAYLD+rAACBBBoMPDuEQAAEFAwW/1tLzKk+goAIAEQWDDwxAQAABBwMP/uGAIAAGCw/RrELgAB +cDD/MqUv8AQ7oFv9YtogW/zp9KwAAgAAULBb/Ob7Cg8iAABgsP0azC8ABDqg/k4CAAEQUDBb/Vfa +IFv8uPSsAAIAAFCwW/y1+woPIgAAYLD9GswvAAQ6oP5OAgAAEFAwW/1MbygLH0ZeDy8Kj/AK8AAA +wKDAtPCuEQIAAGCw+goAIdAQaDBb/UMA1AQqMqQrMqUpMqT4MqUgABAgMApEGPHUBAIAAGCw+YgY +AdQQaDD0BE8JAAQ6IPhEAgAPEFgw+goBIgAAcTBb/TLeQPoKACAPEFgw/RrUIgAAYLBb/S1vKAoc +RkAMLAqMwArAAMCgwLzwrhECAABgsPoKACHYEGgwW/0kLzKmLjKn+goAIA8QWDDw1AQCAABgsP/u +GAHcEGgwW/0cbygKGEYvCCgKiIAKgADAQNpAW/0MwGT1+vAhsgA1IMC//CwAAAEQeDD1rgEEBQAj +8P0a5C4JAHEw9u4CAgAAU/Bb/QtvKAofRh8PLwqP8ArwAMCgW/z8wL/8LAACAABysPoKASHoEGgw +W/0BbygLGEYWCCgKiIAKgAAAwEDaQFv88WRBdMC//CwAAAEQeDD1rgEEBQAj8P0a7C4JAHEw9u4C +AgAAU/Bb/PFvKAofRggPLwqP8ArwAMCgW/ziwL/8LAACAABysPoKASHwEGgwW/znbygKGEX/CCgK +iIAKgADAQNpAW/zYZEE9wL/8LAAAARB4MPWuAQQFACPw/Rr0LgkAcTD27gICAABT8Fv82G8oCh9F +8Q8vCo/wCvAAwKBb/MnAv/wsAAIAAHKw+goBIfgQaDBb/M5vKAsYRegIKAqIgAqAAADAoMC88K4R +AgAAYLD6CgEgsBBoMFv8xNogW/xL+hYBIGQANqAXRLcWRKH1RdsZQAQ8oPkWACAAECAw2iBb+/ku +MqcpMqiPEABIEQj/AgX/Ai92mPDUBAAAEGgwDt0YDQ1A/6wQDJAEP2ANzAIsdpkrcpiKEfa7AQAC +AiEw+3aYIXQIUTDRDwDAofsKDyIAAGCw/goAIeQQaDBb/KPAoPsKDyIAAGCw/goAIeQQaDBb/J5j +/knAofsKDyIAAGCw/goAIewQaDBb/JjAoPsKDyIAAGCw/goAIewQaDBb/JNj/oIAwKH7Cg8iAABg +sP4KACH0EGgwW/yMwKD7Cg8iAABgsP4KACH0EGgwW/yHY/65KzKv8NQEAAAQSDALmRj7MrAoYAFM +MP8CAAH7gapgaJEbsJ8A8QQfRZkArRqw3fP27mwDAH9wAAAAAAAAAPP232AAEGgwLTKnLzKo8/SI +be4BbDAvMsktMsoBJAQP3Rjz9HRt4AFsMC8yxC0yxQFkBA/dGPP0YG3gAWwwLzK/LTLAAaQED90Y +8/RMbeABbDAvMrotMrsB5AQP3Rjz9Dht4AFsMC0yti8yt/P0Km3iAWwwLTKxLzKy8/QcbeYBbDAt +MqwvMq3z9A5t6gFsMCgypy0yqAHkBAjdGPP0QGwAQE9wKDLKACQE+jLLIAAQaDAI3Rjz9CdsAEBP +cCgyxQBkBPoyxiAAEGgwCN0Y8/QObABAT3AoMsAtMsEApAQI3Rjz8/psAEBPcCgyuy0yvADkBAjd +GPPz5mwAQE9wKDK2LTK3ASQECN0Y8/PSbABAT3AoMrEtMrIBZAQI3Rjz875sAEBPcCgyrC0yrQGk +BAjdGPPzqmwAQE9wLzKoAWQE+DKpIAAQcDAP7hjz88ZuYAFwMC8yygGkBPgyyyAAEHAwD+4Y8/Ot +bmABcDAvMsUuMsYB5AQP7hjz85luYAFwMC8ywQAkBPgywiAAEHAwD+4Y8/OAbmABcDAvMrwAZAT4 +Mr0gABBwMA/uGPPzZ25gAXAwLzK3AKQE+DK4IAAQcDAP7hjz805uYAFwMC8ysgDkBPgysyAAEHAw +D+4Y8/M1bmABcDAvMq0BJAT4Mq4gABBwMA/uGPPzHG5gAXAwKzKoAaQE/DKpIAAQUDALqhjz8yZq +gAFQMCsyyioyywHkBAuqGPPzEmqAAVAwKzLGACQE/DLHIAAQUDALqhjz8vlqgAFQMCsywQBkBPwy +wiAAEFAwC6oY8/LgaoABUDArMrwApAT8Mr0gABBQMAuqGPPyx2qAAVAwKzK3AOQE/DK4IAAQUDAL +qhjz8q5qgAFQMCsysgEkBPwysyAAEFAwC6oY8/KVaoABUDArMq0BZAT8Mq4gABBQMAuqGPPyfGqA +AVAwKzKoKjKpAfQEC6oY8/KQaoABUDArMssANAT8MswgABBQMAuqGPPyd2qAAVAwKzLGAHQE/DLH +IAAQUDALqhjz8l5qgAFQMCsywQC0BPwywiAAEFAwC6oY8/JFaoABUDArMrwA9AT8Mr0gABBQMAuq +GPPyLGqAAVAwKzK3ATQE/DK4IAAQUDALqhjz8hNqgAFQMCsysgF0BPwysyAAEFAwC6oY8/H6aoAB +UDArMq0BtAT8Mq4gABBQMAuqGPPx4WqAAVAwLzKpAEQE+DKqIAAQcDAP7hjz8fBuYAFwMC8yywCE +BPgyzCAAEHAwD+4Y8/HXbmABcDAvMsYAxAT4MscgABBwMA/uGPPxvm5gAXAwLzLBAQQE+DLCIAAQ +cDAP7hjz8aVuYAFwMC8yvAFEBPgyvSAAEHAwD+4Y8/GMbmABcDAvMrcBhAT4MrggABBwMA/uGPPx +c25gAXAwLzKyAcQE+DKzIAAQcDAP7hjz8VpuYAFwMC4yri8yr/PxTG5gAXAwKzKpAIQE/DKqIAAQ +UDALqhjz8VZqgAFQMCsyywDEBPwyzCAAEFAwC6oY8/E9aoABUDArMsYBBAT8MscgABBQMAuqGPPx +JGqAAVAwKzLBAUQE/DLCIAAQUDALqhjz8QtqgAFQMCsyvAGEBPwyvSAAEFAwC6oY8/DyaoABUDAr +MrcqMrgBxAQLqhjz8N5qgAFQMCoysysytPPw0GqAAVAwKzKuAEQE/DKvIAAQUDALqhjz8LdqgAFQ +MCsyqQDUBPwyqiAAEFAwC6oY8/DGaoABUDArMssBFAT8MswgABBQMAuqGPPwrWqAAVAwKzLGAVQE +/DLHIAAQUDALqhjz8JRqgAFQMCsywQGUBPwywiAAEFAwC6oY8/B7aoABUDArMrwqMr0B1AQLqhjz +8GdqgAFQMCsyuAAUBPwyuSAAEFAwC6oY8/BOaoABUDArMrMAVAT8MrQgABBQMAuqGPPwNWqAAVAw +KzKuAJQE/DKvIAAQUDALqhjz8BxqgAFQMC8yqQEkBPgyqiAAEHAwD+4Y8/AtbmABcDAvMssBZAT4 +MswgABBwMA/uGPPwFG5gAXAwLzLGAaQE+DLHIAAQcDAP7hjz7/tuYAFwMC8ywS4ywgHkBA/uGPPv +525gAXAwLzK9ACQE+DK+IAAQcDAP7hjz785uYAFwMC8yuABkBPgyuSAAEHAwD+4Y8++1bmABcDAv +MrMApAT4MrQgABBwMA/uGPPvnG5gAXAwLzKuAOQE+DKvIAAQcDAP7hjz74NuYAFwMCsyqQFkBPwy +qiAAEFAwC6oY8++NaoABUDArMssBpAT8MswgABBQMAuqGPPvdGqAAVAwKzLGKjLHAeQEC6oY8+9g +aoABUDArMsIAJAT8MsMgABBQMAuqGPPvR2qAAVAwKzK9AGQE/DK+IAAQUDALqhjz7y5qgAFQMCsy +uACkBPwyuSAAEFAwC6oY8+8VaoABUDArMrMA5AT8MrQgABBQMAuqGPPu/GqAAVAwKzKuASQE/DKv +IAAQUDALqhjz7uNqgAFQMCsyqQG0BPwyqiAAEFAwC6oY8+7yaoABUDArMssqMswB9AQLqhjz7t5q +gAFQMCsyxwA0BPwyyCAAEFAwC6oY8+7FaoABUDArMsIAdAT8MsMgABBQMAuqGPPurGqAAVAwKzK9 +ALQE/DK+IAAQUDALqhjz7pNqgAFQMCsyuAD0BPwyuSAAEFAwC6oY8+56aoABUDArMrMBNAT8MrQg +ABBQMAuqGPPuYWqAAVAwKzKuAXQE/DKvIAAQUDALqhjz7khqgAFQMC0yqi8yq/Puam3gAWwwLzLM +AEQE+DLNIAAQaDAP3Rjz7lFt4AFsMC8yxwCEBPgyyCAAEGgwD90Y8+44beABbDAvMsIAxAT4MsMg +ABBoMA/dGPPuH23gAWwwLzK9AQQE+DK+IAAQaDAP3Rjz7gZt4AFsMC8yuC0yuQFEBA/dGPPt8m3g +AWwwLzKzLTK0AYQED90Y8+3ebeABbDAvMq4tMq8BxAQP3Rjz7cpt4AFsMC8yqgEEBPgyqyAAEHAw +D+4Y8+3xbgABcDAvMswBRAT4Ms0gABBwMA/uGPPt2G4AAXAwLzLHAYQE+DLIIAAQcDAP7hjz7b9u +AAFwMC8ywgHEBPgywyAAEHAwD+4Y8+2mbgABcDAuMr4vMr/z7ZhuAAFwMC8yuQBEBPgyuiAAEHAw +D+4Y8+1/bgABcDAvMrQAhAT4MrUgABBwMA/uGPPtZm4AAXAwLzKvAMQE+DKwIAAQcDAP7hjz7U1u +AAFwMCsyzAFUBPwyzSAAEEgwC5kY8/ZVaGABTDArMscBlAT8MsggABBIMAuZGPP2PGhgAUwwKzLC +KTLDAdQEC5kY8/YoaGABTDArMr4AFAT8Mr8gABBIMAuZGPP2D2hgAUwwKzK5AFQE/DK6IAAQSDAL +mRjz9fZoYAFMMCsytACUBPwytSAAEEgwC5kY8/XdaGABTDAvMqwANAT4Mq0gABBwMA/uGPPxQG5A +AXAwLzLOAHQE+DLPIAAQcDAP7hjz8SduQAFwMC8yyQC0BPgyyiAAEHAwD+4Y8/EObkABcDAvMsQA +9AT4MsUgABBwMA/uGPPw9W5AAXAwLzK/ATQE+DLAIAAQcDAP7hjz8NxuQAFwMC8yugF0BPgyuyAA +EHAwD+4Y8/DDbkABcDAvMrUBtAT4MrYgABBwMA/uGPPwqm5AAXAwLzKwLjKxAfQED+4Y8/CWbkAB +cDAqMs4ApAT7Ms8gABBIMAqZGPPwxmhgAUwwKjLJAOQE+zLKIAAQSDAKmRjz8K1oYAFMMCoyxAEk +BPsyxSAAEEgwCpkY8/CUaGABTDAqMr8BZAT7MsAgABBIMAqZGPPwe2hgAUwwKjK6AaQE+zK7IAAQ +SDAKmRjz8GJoYAFMMCoytSkytgHkBAqZGPPwTmhgAUwwKzLPAOQE/DLQIAAQUDALqhjz8VNq4AFQ +MCsy5QCkBPwy5iAAEFAwC6oY8/E6auABUDArMuIAZAT8MuMgABBQMAuqGPPxIWrgAVAwKzLfACQE +/DLgIAAQUDALqhjz8Qhq4AFQMCsy2yoy3AHkBAuqGPPw9GrgAVAwKzLYKjLZAaQEC6oY8/DgauAB +UDArMtUBZAT8MtYgABBQMAuqGPPwx2rgAVAwKzLSASQE/DLTIAAQUDALqhjz8K5q4AFQMCsyzyoy +0AFkBAuqGPPxFmvgAVAwKzLlKjLmASQEC6oY8/ECa+ABUDArMuIA5AT8MuMgABBQMAuqGPPw6Wvg +AVAwKzLfAKQE/DLgIAAQUDALqhjz8NBr4AFQMCsy3ABkBPwy3SAAEFAwC6oY8/C3a+ABUDArMtkA +JAT8MtogABBQMAuqGPPwnmvgAVAwKzLVKjLWAeQEC6oY8/CKa+ABUDArMtIqMtMBpAQLqhjz8HZr +4AFQMCgy0ABkBPky0SAAECAwCEQY8/CjZIABIDAoMuYAJAT5MucgABAgMAhEGPPwimSAASAwKDLi +JDLjAeQECEQY8/B2ZIABIDAoMt8BpAT5MuAgABAgMAhEGPPwXWSAASAwKDLcAWQE+TLdIAAQIDAI +RBjz8ERkgAEgMCgy2QEkBPky2iAAECAwCEQY8/ArZIABIDAoMtYA5AT5MtcgABAgMAhEGPPwEmSA +ASAwKDLTAKQE+TLUIAAQIDAIRBjz7/lkgAEgMCsy0AC0BPwy0SAAEFAwC6oY8/AkaoABUDArMuYA +dAT8MucgABBQMAuqGPPwC2qAAVAwKzLjADQE/DLkIAAQUDALqhjz7/JqgAFQMCsy3yoy4AH0BAuq +GPPv3mqAAVAwKzLcAbQE/DLdIAAQUDALqhjz78VqgAFQMCsy2QF0BPwy2iAAEFAwC6oY8++saoAB +UDArMtYBNAT8MtcgABBQMAuqGPPvk2qAAVAwKzLTAPQE/DLUIAAQUDALqhjz73pqgAFQMCgy0AEE +BPky0SAAECAwCEQY8++KZIABIDAoMuYAxAT5MucgABAgMAhEGPPvcWSAASAwKDLjAIQE+TLkIAAQ +IDAIRBjz71hkgAEgMCgy4ABEBPky4SAAECAwCEQY8+8/ZIABIDAkMt0oMt7z7zFkgAEgMCgy2SQy +2gHEBAhEGPPvHWSAASAwKDLWAYQE+TLXIAAQIDAIRBjz7wRkgAEgMCgy0wFEBPky1CAAECAwCEQY +8+7rZIABIDArMtABVAT8MtEgABBQMAuqGPPvD2qAAVAwKzLmARQE/DLnIAAQUDALqhjz7vZqgAFQ +MCsy4wDUBPwy5CAAEFAwC6oY8+7daoABUDArMuAAlAT8MuEgABBQMAuqGPPuxGqAAVAwKzLdAFQE +/DLeIAAQUDALqhjz7qtqgAFQMCsy2gAUBPwy2yAAEFAwC6oY8+6SaoABUDArMtYqMtcB1AQLqhjz +7n5qgAFQMCsy0wGUBPwy1CAAEFAwC6oY8+5laoABUDAoMtABpAT5MtEgABAgMAhEGPPudGSAASAw +KDLmAWQE+TLnIAAQIDAIRBjz7ltkgAEgMCgy4wEkBPky5CAAECAwCEQY8+5CZIABIDAoMuAA5AT5 +MuEgABAgMAhEGPPuKWSAASAwKDLdAKQE+TLeIAAQIDAIRBjz7hBkgAEgMCgy2gBkBPky2yAAECAw +CEQY8+33ZIABIDAoMtcAJAT5MtggABAgMAhEGPPt3mSAASAwKDLTJDLUAeQECEQY8+3KZIABIDAr +MtAqMtEB9AQLqhjz7fNqgAFQMCsy5gG0BPwy5yAAEFAwC6oY8+3aaoABUDArMuMBdAT8MuQgABBQ +MAuqGPPtwWqAAVAwKzLgATQE/DLhIAAQUDALqhjz7ahqgAFQMCsy3QD0BPwy3iAAEFAwC6oY8+2P +aoABUDArMtoAtAT8MtsgABBQMAuqGPPtdmqAAVAwKzLXAHQE/DLYIAAQUDALqhjz7V1qgAFQMCsy +1AA0BPwy1SAAEFAwC6oY8+1EaoABUDArMtEARAT8MtIgABBQMAuqGPPtVGtAAVAwKjLnKzLo8+1G +a0ABUDArMuMqMuQBxAQLqhjz7TJrQAFQMCsy4Coy4QGEBAuqGPPtHmtAAVAwKzLdAUQE/DLeIAAQ +UDALqhjz7QVrQAFQMCsy2gEEBPwy2yAAEFAwC6oY8+zsa0ABUDArMtcAxAT8MtggABBQMAuqGPPs +02tAAVAwKzLUAIQE/DLVIAAQUDALqhjz7LprQAFQMCgyqwA0BPkyrCAAECAwCEQY8+UuZIABIDAo +Ms0AdAT5Ms4gABAgMAhEGPPlFWSAASAwKDLIALQE+TLJIAAQIDAIRBjz5PxkgAEgMCgywwD0BPky +xCAAECAwCEQY8+TjZIABIDAoMr4BNAT5Mr8gABAgMAhEGPPkymSAASAwKDK5AXQE+TK6IAAQIDAI +RBjz5LFkgAEgMCgytAG0BPkytSAAECAwCEQY8+SYZIABIDAoMq8kMrAB9AQIRBjz5IRkgAEgMCgy +qwAkBPkyrCAAEHgwCP8Y8+R7bgABfDAoMs0AZAT5Ms4gABB4MAj/GPPkYm4AAXwwKDLIAKQE+TLJ +IAAQeDAI/xjz5EluAAF8MCgywwDkBPkyxCAAEHgwCP8Y8+QwbgABfDAoMr4BJAT5Mr8gABB4MAj/ +GPPkF24AAXwwKDK5AWQE+TK6IAAQeDAI/xjz4/5uAAF8MCgytAGkBPkytSAAEHgwCP8Y8+PlbgAB +fDAoMq8B5AT5MrAgABB4MAj/GPPjzG4AAXwwKDKrABQE+TKsIAAQcDAI7hjz48NuAAFwMCgyzQBU +BPkyziAAEHAwCO4Y8+OqbgABcDAoMsgAlAT5MskgABBwMAjuGPPjkW4AAXAwKDLDANQE+TLEIAAQ +cDAI7hjz43huAAFwMCgyvgEUBPkyvyAAEHAwCO4Y8+NfbgABcDAoMrkBVAT5MrogABBwMAjuGPPj +Rm4AAXAwKDK0AZQE+TK1IAAQcDAI7hjz4y1uAAFwMCgyrwHUBPkysCAAEHAwCO4Y8+MUbgABcDAo +MqotMqsB5AQI3Rjz4xBsQAFsMCgyzQAkBPkyziAAEGgwCN0Y8+L3bEABbDAoMsgAZAT5MskgABBo +MAjdGPPi3mxAAWwwKDLDAKQE+TLEIAAQaDAI3Rjz4sVsQAFsMCgyvgDkBPkyvyAAEGgwCN0Y8+Ks +bEABbDAoMrkBJAT5MrogABBoMAjdGPPik2xAAWwwKDK0AWQE+TK1IAAQaDAI3Rjz4npsQAFsMCgy +rwGkBPkysCAAEGgwCN0Y8+JhbEABbDAoMqoB1AT5MqsgABBgMAjMGPPiWGwAAWAwKDLNABQE+TLO +IAAQYDAIzBjz4j9sAAFgMCgyyABUBPkyySAAEGAwCMwY8+ImbAABYDAoMsMAlAT5MsQgABBgMAjM +GPPiDWwAAWAwKDK+ANQE+TK/IAAQYDAIzBjz4fRsAAFgMCgyuQEUBPkyuiAAEGAwCMwY8+HbbAAB +YDAoMrQBVAT5MrUgABBgMAjMGPPhwmwAAWAwKDKvAZQE+TKwIAAQYDAIzBjz4alsAAFgMCsyqwCE +BPwyrCAAEFAwC6oY8+HdagABUDArMs0AxAT8Ms4gABBQMAuqGPPhxGoAAVAwKzLIAQQE/DLJIAAQ +UDALqhjz4atqAAFQMCsywwFEBPwyxCAAEFAwC6oY8+GSagABUDArMr4BhAT8Mr8gABBQMAuqGPPh +eWoAAVAwKzK5AcQE/DK6IAAQUDALqhjz4WBqAAFQMCoytSsytvPhUmoAAVAwKzKwAEQE/DKxIAAQ +UDALqhjz4TlqAAFQMC8yqwCUBPgyrCAAEHAwD+4Y8+FFbkABcDAvMs0A1AT4Ms4gABBwMA/uGPPh +LG5AAXAwLzLIARQE+DLJIAAQcDAP7hjz4RNuQAFwMC8ywwFUBPgyxCAAEHAwD+4Y8+D6bkABcDAv +Mr4BlAT4Mr8gABBwMA/uGPPg4W5AAXAwLzK5AdQE+DK6IAAQcDAP7hjz4MhuQAFwMC8ytQAUBPgy +tiAAEHAwD+4Y8+CvbkABcDAvMrAAVAT4MrEgABBwMA/uGPPglm5AAXAwKzKrAMQE/DKsIAAQUDAL +qhjz4MNqgAFQMCsyzQEEBPwyziAAEFAwC6oY8+CqaoABUDArMsgBRAT8MskgABBQMAuqGPPgkWqA +AVAwKzLDAYQE/DLEIAAQUDALqhjz4HhqgAFQMCsyvioyvwHEBAuqGPPgZGqAAVAwKjK6KzK78+BW +aoABUDArMrUARAT8MrYgABBQMAuqGPPgPWqAAVAwKzKwAIQE/DKxIAAQUDALqhjz4CRqgAFQMC8y +qwHEBPgyrCAAEHAwD+4Y8+KjbkABcDAuMs4vMs/z4pVuQAFwMC8yyQBEBPgyyiAAEHAwD+4Y8+J8 +bkABcDAvMsQAhAT4MsUgABBwMA/uGPPiY25AAXAwLzK/AMQE+DLAIAAQcDAP7hjz4kpuQAFwMC8y +ugEEBPgyuyAAEHAwD+4Y8+IxbkABcDAvMrUBRAT4MrYgABBwMA/uGPPiGG5AAXAwLzKwAYQE+DKx +IAAQcDAP7hjz4f9uQAFwMCoyzgA0BPsyzyAAEEgwCpkY8+IxaGABTDAqMskAdAT7MsogABBIMAqZ +GPPiGGhgAUwwKjLEALQE+zLFIAAQSDAKmRjz4f9oYAFMMCoyvwD0BPsywCAAEEgwCpkY8+HmaGAB +TDAqMroBNAT7MrsgABBIMAqZGPPhzWhgAUwwKjK1AXQE+zK2IAAQSDAKmRjz4bRoYAFMMAAAbBAE +iCLOh9ogW/YqzqBoUwPAINEPiif7TAAAABBgMPqsICIAAGkwWuzm0qDRDwAAaFMyiifAsPqsICAB +EGAwWvAdHTyUnaCMIBs/JvjMEQABEGgw+6YCLAkAazD8pgEgABAQMNEPwCDRDwAAbBAEiieFrvQ8 +txaAEEAw9z8bFAAgRXAoUGEvUGD9IAwgABAwMP4gDSAUAkIw+FRhIFQAN+D48X1gRRBIMGjyE9tg +/D8PEAEQUDBYCzzHItEPAAAA+XCAICcAtODIkWThDSZUYCZUYS5Cd4sg+kKHIAAQYDD+uwwAARBo +MFrsQ8Ag0Q8AAI8i8woBIPsAt+DaIFv17WWhGIsgI1RgKEJ3+kKHIAEQYDD4uwwAARBoMFrsN8Ag +0Q8qUGF6m8Jk4I76bAAAuQA3YCl8gP0bFAAYAH9w+nBlIQICSfDKvC2Q5S+Q5vicAiH+AmLwDwIA +0w/TD23JEf2A5SoAIFNwsoj/gOQqACBT8Kraqvqw66uq+DtgGdAEPqD+O9IeHgC6oBw+2fAACWgA +IGZwHT7XrZkqcIAKjjgfPF7Asv+ZCAAAEBAw/paAIAALr6ArVGDRDyoKgPP/uWoAIFNwAAAA9paA +IAIQWDD7VGAgABAQMNEPANrQW/ZLY/7pAAAAAADz/4piAABRsAAAKqwg+woAIAEQYDBa760ePCWe +oIsg/T63HYAEOuD9pgIsCQAbMJyhY/7oiidj/9AAAABsEAQVPEoqUocpoQMooQL/AgAGAGTOEMCw +Wuwe1KD3Pn4SAAAysB87Ki/yeC5Sf6T/Cf8Rr+4v4A0p4Axk8KT7fAAAwQA2YP+XDHAAEFAw+nDl +IAICWfAJGRTKnP2w5SAEAkLw+7DmIf4CYnAPAgDTD23JEf2A5SoAIFNwsoj7gOQqACBS8Kraqrqw +/Q2tCA1bFA67EQs7DPuyAyyAAWww8NEEAAEQYDAAzBr8CgEqAEBm8AvLOQ7qAlv/YypShw8CAA8C +AC+hAy6hAn/hDStMAVrr8PSsAA//p1GQwCDRDwAAAADwkQQAARBYMAC7GvsrAQABEEAw8/+7agUA +XjAAAAAAAPP/gmAAEFAwbBAGHj5xEz1DJuIRFT0t9D5vEAAQEDD3bP8gAG2loPAAD2HwAlmwALEi +/wIABgBkNJACegwEqREEmQIpNpgoMpkpMpj4CEEIAEAucPk2mCOwAj4geyHQHTrbLdJ4LOJfraoJ +qhGqyi0yriygIvDXF3IAAHtwDchCeMkMHT3LwID45LwsAEBv8PDBBAABEHgw8P8aD/8QQDAI/wP6 +FgAuAEB/cImimxH/Nq4gEwC2YIoQW/U0ixH+PkQfbgA2oIoQiqcrCgD6rCAgARBgMFrvLYsRjBAd +O6SdoIzAHj47Hz41+MwRAAEQaDD/pgIsCQBrMJyhY/8x0Q9sEA5b/8EYPjQogIz2CgEj4AA2IBc+ +MhM9AfIKACAAECgwGj4tKqBwACAECgobf6csJDLRe0YmACEE8GsaAgAAYfD7VQIABRBQMPsKECIA +AGlwWApLGT4iCUwBLDbRsSL5KL5gEAIY8NNQHj4ekxsADovwDoAAIAJYcPALgAIAAFDwW/9ejxv+ +EgQjTQA34CwSBysSBi8SBfwWASAFEFAw+xYAIgAAaPD8PhAQEBBYMFgKMxs+Dhw61f47mRAAEHgw +nxot4oMM3QIt5oMZPNQrslT5kq4gwgA24GQwuhU+BBg+Bxo+BR0+A50dmhj4FgkggBA4MPcWDCIA +QGZw8AB7YCACOHAaPfksopokoqKsKAmIEahEi0AqoqoMuwxa60xkotxvJAyPHS/wtfQKACF9ALfg +Gz3uK7JUjR2MGo4ciRuIGY8YCRkU+RYLIBACQjD4FgkgEAJ78P8WCCACAnOw/hYMIAICYzD8Fgog +AgJrcP0WDSoAElsQihvJqowb8hIKIW4AfzBlP3uNHP8CAA4BBJNgiRlgAgEcPdqPFo4VjRT4Egcg +BRBQMPgWACAQEFgwWAnzKBwQAgiLwDAGM2ISPcvyAYIObgA44BU6QChSeSQioqOICYgR/CKaJAAg +QTCLQCoiqgy7DFrrGcmpBEGLsTMGM2TyAYQPqAI44MAg0Q8AAAAAAAAA+kwAAAAQWDBb/oxj/9YA +AP1cAAFsADSgwMDyGhIAJAB8sCwKgAxcCPzAzSACAmlw9KBIYIAQcDCu2yuwzfjcAiACAktw/p0I +Af4CSrD90M0iAABS8G2aH/6JCAACAlow/rsIAAQCQjD6kM0oACBmsP2wzSwAIEtwrKys3KxMDF4U +Du4RDn4M/eIDKIABZDAAkQQAaBoI3QKd47FE/wIAC/9F+RDJMPwSDCH/sxkgY//MAAAAAAAAAPoS +DCAAQgEg/1wAAPwANKDAwPIdEgAkAHywLAqADFwI/MDNIAICeXD00EhggBBwMLL4+/wBKgAgc/D6 +oM0qACB28P2wzSH+AktwDwIAbZof/okIAAICWjD+uwgABAJCMPqQzSgAIGaw/bDNLAAgS3CsrKzc +rExvzhYZPWMJyQtgABMAAAAAAAD+ru1iAABisBk9XwnJCx09YBw53ho6Ui3QjA3KOBs64quZ+paA +IAARLqAePVku4IzI4WhAUo8dL/C1Y/8cAAAA8/74YAAQYDDAgCiWgGP/2YkYHT1PHDnNGjpBLdCM +Dco4GzrRq5n6loAgABsuoB49SC7gjGTtY9ogW/TIY/1bAPP/aGAAEGAw2iBb9MRj/6T/EgUgNAA3 +oIwXixZj/LAAwPAvloBj/8UYPUUjgjcjhjdj/G0AAAAA+kwAAAAQWDBb/g5j/RQAAPsSBiAMADfg +jBdj/HoAAAD8EgcsdAC24GXMbGP9zgAAbBAEiieJMCuhFf36wCBAAjKw9QxHDABAbbD9uwgIyAFI +MPu8QCKUAjsgZIB6iasIjBGsnPzNASH+AlEw/K4RCgBMWxCuzvg8ECoATHbQaEEKbakFAAiGAExh +iWOIkLGImJCPMP8CAAIAVsPQwCDRD4oxCgpHaaHz/iAULuABTDD//AEiAABRsP8fFAABEFgw/+4I +AAAQYDD+JBQgARBoMFrqsdKg0Q8AJTAXL6kU/j0KEAICKXD5oggtwAQ5YPmmCy4AIGfwL6UUnpCM +IAjMEQxVApWRY/9WKGEFCMwMY/9iAAy7DAtJFLieDq42bekFAAiGAExhA7gI+U8MAIACS3D//P8g +IAJCMG35BQIIhgBJY2P/RIphGDlqJJAQwHDzkBcgIAIqcPhECgDeCEqw+mwAAAEQWDD8fAAAARBo +MFrqio1jjdDaIPkgFCzgAWww+EIQIAICa3D9HRQCAABZcP2ZCAIAAGDw+SQUIAIQaDALgACOY9MP +DwIAZO7u+zwAAgAAUbD8CgAiAABo8FrqdvdmAyAAEBAw0Q+OINtQ+EIQIgAAULD47hEAARB4MP/u +AgIAAGDw/pYBIAIQaDALgACJY2SepS9pBPlmACACAhDw92YDI8AEOKAC/wz/ZQQgABAQMNEPAABs +EATRDwAAAGwQBATqMBU8uSJSgHJDBCRWgNEPKFJ/9FaAIAICQjAoVn/RD2wQBIknKJkU+pwgIAAQ +EDD7kgkgJQA2IPwKKiAdADbgKbAAHTpB+7ICIB4IYnD+OkAQFARq8H6xAtEPAMCy/AoAIAIQaDBa +6kPSoNEPAAAAbBAEiScomRT7kgkgEAA2IIkiyJ7AINEPAAAAAPP/8GAAEFgwLLAdiraLtQDMMlgH +29ogW//f0qDRDwAAbBAEizWINCwwHP0yBiIAAFCwC4AA0qDRDwAAAGwQBi8yABg5ZyQiAP9LUw74 +AXww+PgKDABsF+AogkgPAgBkgPAZO0IYPH8pkq4P9Qrxng90ACBFcCpQfP8CAAIAn36Q9lB9IMAA +ovALbAEMDEP9Cv8gpAhi8CdQfn1xDIsxCwtH/wIADgB6utAcOh4nUIAqQCCLMP9AISgABrqQI1B/ +fLhHc/BEGTxnBkhD0w8JiAoogn/aQAuAAPomACCRADagwCDRDxw8YS5ADf1ADCACEFAw+xYAKGAB +MDD4FgEgABBYMFgIc8Yq0Q8AHDxYLkANLUAMkxH6FgAgABBYMPcWAiACEFAwWAhqxy/RDxw8Uf1A +DCACEFAw/kANIEAQSDD5FgAgABBYMFgIYsYq0Q8AAAAALUAM/kANIAIQUDD8PEUQABBYMFgIWiL6 +2tEPHDxCL0AhLkANLUAMKkAgmhApUH+ZEfhQgCAAEFgw+BYCIAIQUDBYCE/GKtEPHDw4LkANLUAM ++xYAIAIQUDD3FgEgABBYMFgIR8Yq0Q8tQAz+QA0gAhBQMPw8LhAAEFgwWAhAIvq50Q8AAABsEAoW +OQEGKwsqsJQssJYusJXzCgEgABB4MPzMASH+AlKw/KoBAAICQ7D6XEIK4AFQMPq0liBfADYg/bIk +IAAQIDANyQqJkAoIRACABAkJGcmcbQgUf588sar5GRQK4AFQMPq0liAHADZgY//kLrCVscwOzgwO +TDgusJX7yhEAAgJ78NMP+OwBKuABUDD6tJYr/9jH0B04a/8KES2ABDqg+9KAJgCWfJAl0niqVQlV +EfW1CAIAABswFDhxAwJHBCIKKCKYA4oUC4AAKCKc+jwAAAAQWDALgAAoIp7aMAuAAIehBwdH9KwA +BAB+leCPoP9KUw74AXww9lwADACrl+AYOMII+AoogkhkgWcZOqIYO94pkq4P8grxng9yACBAsCsg +fP8CAAIA3n7Qmhj7IH0iAGKikAq8AQwMQ/oWCC4AW+KQKiB+LQr/faERjkH6Fgcu4AFwMP4WBC4A +slOQLSCALmAg+kIAKAARa5AvYCGeFhg5dy0WBSwgf/wWCSgAU8KQ/BYJLgBP59AZO8ALSEMJiAoo +gn/7rAACAABRsAuAAPWsAADtADagwMBmwDqIQBk4lgiIVwmICiiCSPpcAAIAAFkw/HwAAgAAaPAL +gADRDyXSeapV88MCBZAEPWDz/tdkACAu8ADGyvo8AAIAAFkwWAbt0Q8cO6aJGC5gDf1gDChgAVgw ++BYBIAIQUDD5FgAgABBYMFgHuPP/jm/qEGAwAAAAABw7nIgVihYuYA0tYAyJGZkR+hYAIAAQWDD4 +FgIgAhBQMFgHrPP/Xm//EGAwAAAcO5H9UAwgAhBQMP5QDSBAEFgw+xYAIAAQWDBYB6Jj/6QtUAz+ +UA0gAhBQMPw7hxAAEFgwWAec8/8db9oQYDAcO4MvYCEuYA0tYAwqYCCaECkgf5kR+CCAIAAQWDD4 +FgIgAhBQMFgHkGP/Whw7eYgXLmANLWAMiRT5FgAgAhBQMPgWASAAEFgwWAeHY/83AAAtUAz+UA0g +AhBQMPw7bhAAEFgwWAeA8/6ub7kQYDBsEASJMNpQ/TtpEgAAWPD8MAggHgAqcG7GLfAABm/qEGAw +wMD+N+EQMgAmcC/Qgi+0CCnSHq6ZCUkUmbQo0h+YtVgGmcAg0Q8s1ILz/9VgABBgMABsEAT2LAAC +AAAQ8PNMAAIAACGwDwIADwIAbTkP8yAAIAICELDzRAAgAgIhMNJg0Q9sEATWINMP0w9tSQfzJAAg +AgIQsNJg0Q9sEAQlCgMFIixkIGz6CmAgehBoMPkKLyA5EGAw9C4KAAAQEDDzJwgAABBAMP8KBCAI +Aliw0w9t+i8icAAMiBHymxFwAgI58HLDCfAAGWGgAhCwAAByqwxy0wnwAAlhUgIQsAAAIizJqCj4 +RgAgCAIhMP5Jr3IAABLwwCDRDwAAAGwQBCoKYPgKLyB6EGAw+wo5IAMQKDAFJSxtWY8iMAD3MAEq +AAiSEHKzCfAAHmGgAkiwAAD5LMkqAAoSkHLDDPAACWFSAkiwAAAAAADyMAIqAA66EHezFfd80CoA +FJYQcqsscsMp8AApYVICELB3qw13wwrwAAphUgI58AAAACd8yXKL2nKz1/AAB2GgAhCwIizJ/H0R +B4AEOmCtZvM8AyYAIDCw9kUAIAQCITDAINEPbBAEAh0UZNB6/ApgIAAQSDD7Ci8gehB4MP4KOSAA +EEAw9QoCIAAQEDD6LAImACAcsG1aLCJwAAyIEfK7D3ACAjnwcuMH8AAWYaACELByywty8wjwAAhh +UgIQsAAiLMmoKASSCPmcASACECgw+CQAIgAAErD6LAIgABBAMP2ZsXYAIBywwCDRD2wQBAIyFGQg +Z/oKYCB6EGAw+QovIDkQWDD0LgoAABAQMPMnCAAAEEAw9QoIIBACaLBtWiwicAAMiBHymw9wAgI5 +8HKzB/AAFmGgAhCwcqsLcsMI8AAIYVICELAAIizJqCj4RgAgCAIhMP5JtHIAABNwwCDRDwAAAGwQ +BPcsAABQADTg+go5IC8QQDD7CnogYBBIMPIKACAAEDAwbTkup2MjMAACIgrziw9wAgIxsHOjB/AA +FWGgAhjwc5sKc7MH8AAHYVICGPAjPMkDIgnRD8Ag0Q8AbBAE9woAIFIANKDDufwKeiAvEEgw+AoA +IGAQUDBtKS6jciIgAAiICvKbD3ACAjnwcrMH8AAVYaACELByqwpywwfwAAdhUgIQsCIsyQKICfhG +ACAAEBAw0Q/AkPlGACAAEBAw0Q8AAABsEAQjJQLzJQMgIAJgsPwmACAAEFgw+yUFIP4CQPD4eBQC +wAEcMPglBCAoADTg+jwAAAEQaDBa485orhX6PAAAABBYMPwiACABEGgwWuPIaa7pyEspIQQMmREp +nBCZQNEP0Q8AbBAEEjbTKCJ/IiKACYgRqCKIJ8uB/DppEAQQUDD9IgAgABBYMP8iByIAAHCwWAZ1 +GzeeHDbc/TpiEgAAULBajlLaIFqONdEPwKH7CkAgQBBgMFhoAvsiAC//EGAw+iYHIAAQaDBYTPpj +/6kAbBAEHjpXGDbYHzeMGTpXFDpTFTpWEzpQGzpTHTbILTaNKzaOJTZ/JDZ+KTZwKTZxLzaFLII1 +KI0OKDaIKDaJD88on+D+NoYgQAJScCo2ePo2eSABEDAw9jZ1IIACSnD5NoAgZBAQMCI2fSk2gQLC +KJJADcwonLASOj8UOj0kNociNo/RDwAAAGwQBBM6OxI6O/UKFiAAEDgw+AofIA0QIDDTD9MPbUoi +8jaAJgMAQXDyNn8gAgIpcPQ9AiAYAhCw90UCIBgCGPAmRQPRDwAAAGwQBBg2kgIERw8CAAhECihC +mAKKFAuAAPoJQQAsAjzgaJECaZMcKEKe2iALgADSoNEPKEKc+iwAAAAQWDALgABj/+LAINEPAGwQ +BBI6GSMioiIiXKMi0Q9sEAQaN4ECKQnTDwqZCiOWZCr6wApKAfpaAgAgEFgwC6oCKpZlJ5ZmDAIA +KZJmCeowGDaDKII1CIgKCYIKBuowBiYMamEObQgIC+owCysMarECY//w0Q8AbBAEEzgfIjKBFDn+ +BCIBIjaB0Q9sEAYSOBorIrwdOfocOfsNuwEMuwIrJrwK6jAI6jAcNm0pwjUKmQgImAxqgRBtCAgO +6jAOngxq4QRj//AAAC8igPg4ChABEBgw8/8CAAIQSDD/JoAv/hAYMG2aKSmCzQOZASmGzSmCziqN +QAOZASmGzimizQOZASmmzSmiziitQAOZASmmzi8ivxk53Bg53dMPCf8BCP8CLya/KyLAHjnZHTna +DrsBDbsCKybACuowCOowKcI1qpkImAxqgQ5tCAgK6jAKmgxqoQJj//AoIoH6Oc8QDxBYMP0a9CAP +EGAw84gBABQQcDD4JoEiAAB4cFronMivwKL8OcYQGBBYMFgFwccr0Q8pIoEaN6sKmQH5JoEgABAQ +MNEPbBAEEzYu9jfgEHYQKDDzMoUgZhAgMAY2AfNjUAQFADFwBDMCFTm2AiQRpUSTQNEPbBAEBOow +GDYhKII1AogoqEID6jADIwxqMQ5tCAgJ6jAJKQxqkQJj//DRDwBsEATzOagQzBBIMAkpKBg2FPkz +CACAECAw9DoIAAEQWDD7pNIgABBIMCmk0Cmk0yk1piiA0Q8CAH+HGdogWDmG8qwAAB4AtqD6Cgcq +ACAk8Cq00NEP2iBYORDyrAAP6gA2oNEPbBAEFzX+9DmPEMwQQDAIKCj1ckwggBAwMPlySiQAIEEw +9kYIAAEQQDAoZMwClTj4ZM4iQAEoMPJkzSQjASwwJWTPI3DRfj8gKXDQaCca9SsMAC4APmArvBwA +sQQAihr6RlYgABAQMNEPwCAiRlbRD2wQCBg14vlaByAAEDgw9frnIBQQUDDzChQiAAAyMG06DyRh +dAVEAflBCXAEAjGwsXcn+vv3FgAiAAAyMPcKACUnEEgw0w9tqg8rYXQFuwH5sQlwBAIxsLF3J/r7 ++VpHIgAAMjD3FgEgFBBwMPwKFCAAEDgw0w9tyg8tYXQF3QH50QlwBAIxsLF3J/r79xYCIgAAMjD3 +CgAlZxBIMNMPbeoPL2F0Bf8B+fEJcAQCMbCxdyf6+/lahyIAADIw9xYDIBQQUDDzChQgABA4MNMP +bToPJGF0BUQB+UEJcAQCMbCxdyf6+9aA9xYEJacQSDD8ChQgABA4MG2qDythdAW7AfmxCXAEAjGw +sXcn+vvAYPcWBSXHEEgw/goUIgAAOjBtyg8tcXQF3QH50QlwBAI58LFmJvr79hYGIAAQODD4Wuci +AAAyMNMPbeoPL2F0Bf8B+PEJcAQCMbCxdyf6+/QcAA//EFgw9xYHIAIQGDDTD206CYhA9oBBYAgC +ITDBw/c2PxABEFAw9BwAAAIQSDBtmlGFQPIGQApMAL1gLXKEAFEEAG4aAFEEAK8aC/8DD90BDt0C +LXaEYAAhxyvRDyNywAXNDADRBABoGgDRBACpGguZAwkzAQgzAiN2wPISFAAIAiEwwCDRDwAAbBAG +/ywAAA4QMDD3N9YQARBYMPUUASHAEGAw9BQAIP8QQDD3fNgv5xAgMPgpD3QAIDyw8AESYAAQUDAA +AAAoUOT8LQICAABx8PgIRAAAEFAw9okZcBQQSDBtmg8v4XQE/wH/0X5wBAJzsLGqtC8ZNZ0A8QT5 +kPwiAABp8PC4GgAJEHAw+ApDAAQQeDD6FAImAFvOEPoWASAAEEgw0w9t+hUq0OQKCkT+qgwAAgJC +cPqJOAACAmtw/wIAAgBGQmAqCuD8CgEgBAJYcFvfrsCx/BrAIAA7LqAeNYONES3k/GAAZgAA9q+E +YAAQcDBvqywYNekvgoQAoQQA6RoAoQTwuhoP/xBoMA2qAwr/AfoSAi4JAE/wL4aEY/9RAAAfNd4p +8sDB0wrdDADRBADoGgDRBPC+Gg//EGgwDe4DDp4BCO4CLvbAY/8kwKBmoBr6Cv4iAABYcPo6AQAC +EGAwW9+J/BrAIAEQWDAtUOQNDUT22R9wFBBwMPwKACwJAGSwbeoPL3F0BP8B/9EKcAQCOfCxzNKg +0Q9mz/hvyyMYNb4pgoQAwQTwshoP/xBoMA0tAw2ZAQkiAvKGhCIAABKw0Q8fNbUi8sDBkwyZDACR +BPC+Gg//EEAwCOgDCCIBAu4C/vbAIgAAErDRDwBsEAgYNO73CgAv5xAoMPoKFCQHEEgw8woUIgAA +MjBtOg8kYXQFRAH5QQlwBAIxsLF3J/r79xYAIgAAMjD3CgAkJxBIMNMPbaoPK2F0BbsB+bEJcAQC +MbCxdyf6+/lKRyIAADIw9xYBIBQQcDD8ChQgABA4MNMPbcoPLWF0Bd0B+dEJcAQCMbCxdyf6+/cW +AiIAADIw9woAJGcQSDDTD23qDy9hdAX/AfnxCXAEAjGwsXcn+vv5SociAAAyMPcWAyAUEFAw8woU +IAAQODDTD206DyRhdAVEAflBCXAEAjGwsXcn+vvWgPcWBCSnEEgw/AoUIAAQODBtqg8rYXQFuwH5 +sQlwBAIxsLF3J/r7wGD3FgUkxxBIMP4KFCIAADowbcoPLXF0Bd0B+dEJcAQCOfCxZib6+/YWBiAA +EDgw+ErnIgAAMjDTD23qDy9hdAX/AfjxCXAEAjGwsXcn+vv0HAAP/xBYMPcWByACEBgw0w9tOgmI +QPaAQWAIAiEwwcP3NUsQARBQMPQcAAACEEgwbZpRhUDyBkAKTAC9YC1yhABRBABuGgBRBACvGgv/ +Aw/dAQ7dAi12hGAAIccr0Q8jcsAFzQwA0QQAaBoA0QQAqRoLmQMJMwEIMwIjdsDyEhQACAIhMMAg +0Q8AAGwQBBU1MMCR/yshb/8QMDAkUoQAIQQANxoAIQQAmBoGiAMIRAEHRAIkVoTRDypSwMHTAt0M +ANEEADsaANEEAJwaBswDDKoBC6oCKlbA0Q8AbBAE9/rnL/8QUDD4NRoQARBIMPsKFCAOECAw9hpH +JgBApNDyNFgQABAYMNMPbboPLCF0B8wB/GE6cAQCELCxM8c7LoLA8jSFEBMQKDADVQwAUQQAnRr/ +Cv8kEQBTcP8kIS4AQCOw/yQiLAkAd3AthsDRDwBvO8ongoQAMQQcNHcAlhr7Cv8sEQBVsPvEISYA +QG3w+8QiJgkAObAmhoTRDyYaQPP/fGYJADCwAGwQBBQ08f8rFmABECgwI0KFACEEAFIaAjIBAlI5 +0Q8A8kLBIeACQLAAgQQAUxoDIgECUjnRDwAAbBAEFDTjwIH/Kx5v/xA4MCVChQAhBACDGgAzEQc2 +AwZVAQUzAiNGhdEPJkLBwacCqgwAoQQAhRoHWQMJZgEGVQIlRsHRDwAAbBAEFDeoBCUKI1bhDAIA +JELq0Q9sEAQTN6QOIhGjIoIg0Q8AbBAEEjc3LyKUwJDwkQQAARBwMPIilS5YAXww+vwBIAAQEDD6 +HRQAHgB+sADiGvICRwIAAEuwZNCJ8JEEAAQCGnDw6xoAAgJicPDBBAoJAFyw8OwaCuABXDD8uwIC +ADGjYAAxBPDsGgAGAlJwAKEEAOga/YwAAfwCU3D5zAAACAJCcA8CANMP0w9tqSfwgQQAAgJiMPiM +AirgAVgw8OkaCgkATrDwwQQM4AFYMPDtGgoJAG8wCwtHCbsCCwtHDbsCCwJH3fD6CgUgCBBYMPw3 +bhIAAHCwWANj0Q8AAGwQBBI3ACQi5yIi6AEkBBM0QQQiGBQzx/M3LBIAQBiw9CIMAAEQIDACQjki +NIDRD2wQBGRAVykgAGSQUSgwAPpBOGAAEDgweYkwbQgdB0YM+GE6YAICOfBqYhKiefmQACgAIBnw +KIAAeYkPY//bonn5kAAoACAZ8CiAAHiTC/mDEHABEBAwwCDRD8cv0Q/AINEP0Q9sEAQaNtv5LAQi +AABg8PoqCAH/EEAw+6KAKgADzhAqooFYBU8LQgHRDwAAAGwQBB03Oxg3O/ncAAC3EFAwbaoFAAiG +AElh+zc3EgAAU3BYBYXRDwBsEAYTNc75NrwQABBAMBo1tiQyrg8CAApEASQ2riiWqCiWqSiWqiiW +q1hs1hUzkSs66CtWNVhsxvagoGIAABKwWGygWGxf0qBb/+NmII1Yayj2oIdiAAASsBw2Yx40/Q8C +ACzCfv7NAQgAPnMQW//a9TWfEgBDiRBYahr2oI5iAAASsFhpq/agUmIAABKwWGlE9qBHYgAAErDA +QSIyrg8CAHQvcwUtAS02rlhpJVhpF/agKGIAABKwGzQD/DQCEAEQUDBYZI0ZNwP6ln0hCwA2oPSW +giAAEBAwZyAEwKFa5eLRDwAALlI1wKT8NvsQABBYMA7dLFgC6mP/cQVPAf82riADEFAwWoqSY/9r +AFv/smP/xWP//AAA+DNDFkgBEDAIZxEHBUcIVQooUpj4FgAiAABRsA8CAAuAAAoJQWiRB/8CAAIA +Wh5gKFKe2nALgADNqYgQ2mALgAAKCUFokQJpk20oUp7acAuAAGSv5JShHDV8nKAaNWgbNtn4EgAo +UAEUMPmkgCoAQFyw+zauIgAAUbALgAAoUpzToPsKASIAAFHwC4AA+FKaL/wQWDD7OwEAChBgMPy7 +AgIAAFGwC4AA/wIAA/+niJBj/t4AAAAAAPP/lmAAEFAw/DbCEAEQUDD7CgEv9BBoMFgCrfP+6m/0 +EBAwAAAAAADz/1RgABBQMGwQBB0zG/s8AAIAAFCw/dI1IAAQYDBYA+bzvAACAAASsNEPAGwQBAPq +MBYz4yRif3QzByNmfyJiftEPImJ+82Z/IAICELAiZn7RDwBsEAT3Igcv/xAoMIZzgyKJcplgiHL2 +hgEgABAwMPZ2AyQRAC0w9nYCIgBALPCTItEPAAAAbBAE+zwAAgAAaTD6LAAAABBgMFqKZNogWopG +0Q8AAABsEAQUNpAkQIDyM1YQBxBAMPg4KAAZADUgJSJK+FMScAAQSDAqIknHJAqSOdEPwCDRD8DA ++woAL/QQEDAMsjnRDwAAAGwQBNlA+DwAAJsANOD/AgAEAEeQ4GQwh9RQ8jUHEAYQGDAPAgDTD9MP +bToR8y0EIfgCITD1QgggCAIQsJUwFzMJEzT+BnY4EjUQj2QbNQ6HZR01C45njGaeOB41DJzYHDUM +jWOXuItinyid6JvIFDTyEjLhCI8QD58C8zMZHgkAF/D/Rv8j6BAQMG0ICrAiZCCuJ0L/dzADY//u +AMAg0Q/HItEPGjZXKqCAZK9qFDMcK0JK/QoHIAUQYDAG3Dn/AgAKAEVm0CNCScDi/jQAICACQPAC +BYYASGMABYYASGHLaSU8MAYGhgBFZwQGhgBFZfcKBSmABDpgCHgCmDEvIAYlCoD3RkkuCQAv8P8k +BiAAEBAw0Q8AAAAAAAAA/AoDLYAEPmANzQKdMSogBisKgPxGSSoJAFqw+iQGIAAQEDDRD8cr0Q8A +AAAAAAAA8/95YAAQGDBsEARkMFtvNFRkMFEZNLYINhD4Mt4WCQAxMPaW/yPoEBAwbQgKsCJkIKsn +kv93gAdj/+4AAAAAAPI0qxAGEBgwDwIA0w9tOhHzLQQh+AIpcPMyACAIAhCwk1jAINEPxyLRDxg2 +EiiAgGSPoBMy2CkySmSQayUySf0iACABEGAw/FQAL4AEOSD8VAguCQBjsP5WASAAECAwJFQJD+ow ++N0RAAMQcDD/VQUsCQB3cJ1TKiAGiyL8NkkgAgJSsPokBioJAGbw+yYCKsABUDD6JAYiAAARMNEP +xyvRDwAAAAAAAPP/k2AAECgwbBAMGDIz+UwAAgAAOPDTD/AIBwIAABhwAENhAENh8AgHAEACGHAA +Q2EAQ2FkcKD/AgAAAI6F4P8CAAIAkoHg/wIABABDkeBkcH8SNGz0HAAABhAYMG06EfMtBCH4AiEw +9UIIIAgCELCVMPI0ZRBAAhhwGjR3iDMcNHWLNB40c401FDRwhjePNpYoFjRyn0iEMp3om8iYqJRo +GDRYGzJICHoQCpoC9TJ/GgkAWrD6hv8j6BAQMG0ICrAiZCCyK4L/e1ACY//uwCDRD8ci0Q8AABw1 +vSzAgP0ysx8ABDlgnhL9FgovZgA3IBQyfy1CSv8CAAYAQ0dgI0JJ9RwAAAIQcDD+NAAgIAI48AIF +hgBHYwAFhgBHYfc8MCBAAihwBgWGAEdnBAWGAEdl+JgRAAUQMDAGiAKYMS8gBiUKgPZGSS4JAC/w +/yQGIAAQEDDRDwAA+jKjGzAEPWCbE5obY/7fAPwyrBxwBD1gnRWcHWP+zwDHK9EPAAAAAPP/fWAA +EBgwbBAI8zHTEgAAMPAESQLwAwcCAAAYcABDYQBDYWRgjP8CAAQAQpGgZGB9EjQU9BwAAAYQGDBt +OhHzLQQh+AIhMPVCCCAIAhCwlTATMhcSNAwaNCAcNB4eNBwUNBqIM4s0jTWFN482lSgVNBufSIQy +neibyJiolFgYNAEbMfAIahAKmgL3MigaCQBasPqG/yPoEBAwbQgKsCJkIGYrgv97cAJj/+7AINEP +xyLRDxw1ZizAgGTPdBMyKy0ySm7VSSQySfYcAAACEHAw/kQAICACOTACBoYAR2MABoYAR2H4mBEA +AxAwMAaIAphBLyAGJQqA9jZJLgkAL/D/JAYgABAQMNEPxyvRDwAA8/+1YAAQIDBsEATKOW80Ick+ +FDIC8zPXE+gQEDBtCAqwImQgniUy/3VAAmP/7sAg0Q/HItEPAAAYNUEogIBkj9AqIAb4p2pwARBI +MBMyBCsySmSwciYySYUgKWQAmWEpZAgkZAkI6jD4VREAAxA4MPhlBSQJAD1wlWMuIAaPIrHu/iQG +LgkAT/CfIo0iLiAG+TZJL40QYDD9DUAAABAYMP4ORgIFAG8w/iQGIgAAEPDRD4kiKPqN+QlAAAAQ +EDAJgjnRD8cr0Q/z/4xgABAwMGwQBJcj+DsRCKAEPSD6MeAaCQBdsPgx4B0ABDlg+CYCKAkAZnD7 +JgEoCQBWcPkmACAgAhCw0Q8AbBAEFjFOFDJr9WKAIBsANOCkJCRA5SJieaNEpCIJIhGiUiIsgNEP +ACRieKJCCSIRolLRD2wQBBYxTwIFRwZVCihSmAKGFAZqAguAAMecCakB+TkCAoYAPODAOPRAFWIJ +AB5wGDOKKIKu/IYHcAQQSDAJMwIoUpz6LAAAARBYMAuAAChSmvpsAAIAAFjwC4AA0Q8AAAAAAADz +/+ZiAAAacGwQBBk05Ygw9AsGCuABEDD7NAYoAEBKMPg2ACSMAD6gaKNuEzEsA6MKKDKYAoQUBEoC +C4AAKDKc1aD7CgEiAABQsAuAAPgymi/8EFgw+1sBAAoQYDD8uwICAABRMAuAANEPGjEOK6J4AowU +KqKArLsJuxGrqouni76NsMnT/LIBIAAQcDCesP62ASIAAFjwC9AA0Q9sEAQCCkdopSgTMQ3TDwOj +CigymAKCFNogC4AAKDKa/AoDIgAAWrD8uwICAABQsAuAANEPbBAEGTE4iCH5STYCAABQ8PgITwkA +BD5g+YgCAgAAYXD4JgEiAABYsFv/w8Ag0Q8AbBAEIyUSlCuVLiYmESggDY0ajBuLHI4YKSEHLiRU ++yUsK0AEOeD8JGEpYAFMMP0kYCgJAFZw+SUHIBAANiCMHo0dLSQhLCQg0Q/RD2wQBPgxzRBOADSg +GzD0+ICAIAAQODD6sjggABAwMG0pEQBgBAgJG/+XBnACAjGwuHfTD/uxbyoAIDqw+0UAKgAgUPD6 +RQIr8AFQMPpFASAAEBAw0Q8cMOErwjgswW/8RQAqACBc8PtFAivwAVww+0UBIAAQEDDRD2wQBBUw +2ClQ3ydQ3itQ4Bgyh/h3EQuABDpg+6oCBgkATfD5KgAmEQBV8PYK/iYJAE3w94IUBgBARfD3RAEi +AEAwsPJEACAAEBAwKlDhKkQCKVDiKUQDKFDjKEQEI0QF0Q8AAABsEAQoIA3JgishK9ow+wtGAgAA +YXBb/+HSoNEP2jD7TAACAABhcFv/v9Kg0Q8AAABsEAQoIASNIP4hCSg4ADog+goCIAAQWDD8NE0S +AAB48FgAN8Yq0Q8A/zwAAAUQUDD8NEgQABBYMFgAMcAg0Q8AAAAAAGwQBN4w/SIAIAIQUDD8NEAQ +ABBYMFgAKcYq0Q9sEAQC0kLRD2wQBBgyXC1gBy9hByxhCP0pQAwgAWww/w9KDQAEP2D6mRAPwAQ/ +4Pn/AgwJAGsw/TD2HgkAR/CfIB8ykY5glCOdIvjuEQwJAHsw/CYELgkAcPD+JgEgABBwMJ4lAEeN +AgKP/yYGILAQcDCeJy1gDCtiBwDdEfuyDiwJAGsw/CYEIGACYXD8JgcgUAJQsFv4mQw4Eagi0Q8A +bBAK8zPsEgAAQPAbMy2WGCkwgiuxnCoyHicWCfUWByuABD7g+6UICgB6llAL6jAvMqn4FgMqAHV+ +0Cs2qR0wZBY0BioyqP3SNSAAEGAwWAEwm1GOYPgSAyAgAklw8lQOIBgQaDD6VgAgABAQMPhUDyAM +EFAw/lYCIAoQQDD+HBAgAgJ7sP9mACBgAnhwbaoFAASGAElhIlTP/xYAIgAAUXD4VM4gJBAgMP4W +ASAMEEAw+BYCIAgQSDDTD9MPbZox+IwEIgAAW7D4FgIsAARDUGAADgDBnfmKBnIAAFvw2ECYEquM +LM3/LMI//KY0IAgCUrD7GgAiAABRcFgCJB0wEygxQI3dsYj9jRQJ4AFAMH2JBSI1QNEPACg1QNEP +0Q8ALjKose4uNqhj/w4AbBAIHDPLGTMDKCIZjyDzIAcgBRBQMP2ABCABEDAw94IKIHgQWDD+ggAk +4AEoMPuEBSH8Aikw+yQFJgkATfD3hgoiIAEcMPMWACQFAC2w9RYBIDAQWDBb/5/6LAAAEBBYMP0c +ECIAAGDwWuq8+TOyEEkANqCIIMCw+6QJKAkASjCYoI8pn6EeL+QMPRH8EgQsACB3cPzWACI6ADkg +iif7CgEgABBgMPqsICABEGgwWuEPwCDRD8Ag0Q/aIPwznxIAAFlwWuqJwCDRDwAAD0QRBBQUBUoC +ZKBIyUgKTwQqrPXwoQQAARBIMAqZDAVEGABVGmABBApfBCqs9fChBA/hEEgw+pkMAAAHrqAAVBrw +AOhgABAoMAUEGQBVGmAA2gAAAA8iEQISFPIzAgIfATgwASIQ9iICAAoAtOAUL9UEIgLAMNEPDyIR +AhIUAyoCZKBHySgKLwQqrPXwoQQAARBAMAqIDAMiGAAzGmAAjwo/BCqs9fChBA/hEEAw+ogMAAAH +rqAAMhrwAHNgABAYMAMCGQAzGmAAZQAAB/JQ8SIQAAAQGDDRDwT3UAF3EPciAwwABTUQFC+3BCIC +0Q8ABEgRBYgCZI/S8kwAAgAAGXDRDwB1M0lgAFEAAGwQAhYzWNMPDwIA9CcDBf/fMJB2RM3ySFoJ +VAEkMGSe0mSPRxoy7QH0BPYiAgQJADEw+iIBBABAUTD5iAwKAAkVEHJBsgMiGPAzGgH+AkIw9CIM +CgADKNCwIvUzDAA0EEgw+goAIAEQWDADIhgAMxrTD22YIwuqGPC7GgoAC6SQdCFEsbv0IgwKAAOo +0CIs/wUzDAMiGAAzGik6/vmdBCgAIEoweYtAdCMHdCEisbtksJ3zvAAIwAQ6IKiiB/dQAXcQByIC +0Q8AdTu3Y//EAAB1M951Odaxu2SwdAsbFPP/0GvwBD7gAABmgBD4nAEgABAYMPP/xWLABDogAAgI +BvCABAwkALogALYaC6sYCgoZYAAVAABvjT8LphgAuRoKCxn6CgAiCQBM8PgKACIJABiwyCPAkQlm +AmdvdrG7yL8PZhFlb2wLGxTz/2Zr8AQ+4PP/XmACAlKwB/JQ8SIQAAAQGDDRDwAAAGwQAhYy/nYk +MvJEWgU0ATQwBUQMa0wwZkA9sUTxVAQGCQA0sPN1GAxoADkgAEEEBQUZBQIGB1I70Q8AAAQkEQNE +AshCxy/RD/VkEQ//ECgwAlQ70kDRDwDAINEPZiAE0lDRDwAFYhHRDwAAAGwQCCMWASIWAPUWAyIA +AFDw9BYCIgAAWXBYAMcoEgKCEAODKAUiKKMi8qIIAgAAGvDRDwAAAAAAbBAI21D2PAAAIBBgMPos +AADfADUg908ECgAHoJDzCgAgABAQMNEPAPfIDAKIADXgAIAEAgMZAHEEBi8YBU0YAQQE/Q5PA/AB +aDACNC4CMyzz7CgJ4AF8MP9EGAIAAFjw/EsZcgAAUTCk2v2jD3H+AljwfKsH+toIAfwCWPAMrwwC ++C4C/yz/7CgPAAQ6IP6eAgIAAFPw/OsZcgAAE7Cu0v0jD3H+AlPwfCsH+vz+IgAgE3DwcQQDAAQ+ +4PwiDAIJAB6w8FsaAgAAUPBYAI16IxLwcQQOAFxQkABoGv8CAAoAVtoQ8goAIf4CGPDRDwAA+V8E +CgBPqJDImgCRBABbGgMiGAAzGgEEBPsMTw3wAVwwDSQuDSIs8sooCeABGDDzRBgCAAB4sPpLGXIA +AHEwq0774w9x/gJ4sHrrB/6+CAH8AniwCuoMDakuDa0s/c4oDQAEOmAMjAL+yyRyAABTcKvM+8Ma +cf4CU3B+yxLw8xEB/AJTcPOjAgAAEBAw0Q8AAPMR86MCAAAQEDDRD8Ag0Q8AAGRRSw+/BGTxTQDx +BA/JDAC7GgCQBAoEGQDxBPCoGg3wAVwwDUUuDUQsAJAEBgIZ8PEEDeABWDAEzigAYxrxBAQCCQBA +sPJVGAIAAHkw/lsZcgAAUXCrWvujD3H+AnkwfqsH+roIAfwCeTD+qAwF4AEUMA2ELA2ILvTCKAkA +BDog+FUCAgAAcTDyWxlyAABRcKta+6MPcf4CcTByqwf6uggB/AJxMAD/EfKiDA4JAH+wDSQsDSUu +AQQE9MooCeABGDDzVRgCAAARMPpbGXIAAHFwq1774w9x/gIRMHrrB/6+CAH8AhEwCuoMDakuDa0s +/c4oDQAEOmAMjAL+yzNyAABTcKvM+8Mpcf4CU3B+yyHz3P4pAAQ4oPgzAgIAABPw0Q9yQwJ1Mx3z +CgEgABAQMNEPACMR86MCAgAAE/DRDwAAAAAAAADzCgAgABAQMNEPwLEFuyxj/qsLogz7DV8AARB4 +MPP/Sm3gAVgwAAAAbBACAwVf9SYcBfABEDADSxyrZvkKACoAA1mQsZkBBAQDKxwGmRgAZhqrZntr +AbGZ9UIcAgAAGbCpItEPbBAC8EEEDAAGiSADIhgAMxrRDwDwMhoAABAYMNEPAABsEALwQAQMAAaJ +IAMjGAICGdEPAPIDGQAAEBAw0Q8AAGwQAsst8AAUYAAQODAAAABsEALKLfISBgYfARQw9C8EBhAE +PeAAQQQAJRr1shQCsAQ9YCVKHQRVDAxVEKUiByIC0Q8AwDDRD2wQAgLqMNEPbBACzCUD8DFgAA8A +byIFA/ExYAAFbyMFA/IxAAIA0Q9sEALMJQLwMNEPAABvIgQC8TDRD28jBALyMNEPwCDRD2wQAiIK +gCMKAG0oDig3QCg3RCg3SCg3TCM9AQMCANEPbBACJicAAwIA0Q8AbBACJScAAwIA0Q8AbBACAgRF +pDMjPD8DYxRtOQUmJwAiLEADAgDRD2wQAgIERaQzIzw/A2MUbTkFJCcAIixAAwIA0Q9sEAICBEWk +MyM8PwNjFG05BSUnACIsQAMCANEPbBACAwIA0Q9sEAIC5DHRDwAAAAAAAAAAAAAAACAFaYAgBXY4 +AAAAAAAAAAAAAAAAIAVueAAAAAAAAAAAIAVr+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAFXiwg +A9WoIAPUsCAD3xQgA95UIAPSuCAD05QgA92sIAPQ4CAD0/ggA9Z0AAAAAAAAAAAgA90wIAPckCAD +0gwgA9GUAAAAAAAAAQIAAQAAAAAAAAAAAAABAAECAwQFAjIyAAAAAAAAAgAAAAAAAAAAAAAAAAAA +AAMQAAAAAAAAAAAAAAAAAAAEAAAACACJBgAAAAAAAAAABAAAAQgAiRQAAAAAAAAAAAQAAAIgAAy8 +AAAAAAAAAAAAAAAB/wEAAAAAAAEAAAAAAAAAAAAAAAAf/OEwAAAAAOAAAOABAAAAAAAAACAFP+wA +AAAAIAU/iCAFPRggBTwIIAUewCAE0dggBMKQIATBaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAD +hLggA5OwIAOTsCADk7AgA6J4IAO7mCADyCggA864IAOBnCADfxAgAzxMIAPlPCADOdwgAzbQIATB +PCAEwAwgBLloIAOTsCAEuJAgBLdEIAS2bCAFuGggAs4EIAMYuCAFWNwAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAACADXkggA0mAIANYcCADVtwgA1VkAAAAACADUxAgA12IAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAACAHW+QAAAABIAdRwAAAAAIgB0ygAAAAASAHSRQAAAABIAdCgAAA +AAQgBy+0AAAAASAHLqgAAAABAAAAAAAAAAAAAQABAAAAAAAAAAAAAAAAIAVQJCADgvggAFk0AAAA +AAAA/wAAAA7/AAEAAAAAAAAKAQCBAAoBAAEACgEAAQAKAQABAA4DAQEAHv+BgQAeAoEBAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARsEAwMBGwIDAwEbAwMDARsCAQEBHwSBgQEr/4GBASoB +gYEBKQGBgQEfA4EBAR8DgQEBLP+BgQE9AoEFATz/hQABPP+FAAE5AQUFAT4PBQUBLgSBgQEbAgEB +AA4CgQEBLgKBgQAOAgABAA4CgQEADgIBAQEaAYGBAQ4CAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAABwDAQAADgMBAQBPBAEBAF8EAQEAPAQBAAAAAAAAAGz/AQEATAQB +AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAMbFCADG5AgAxswIAMbpAAAAHMA +AAB9AAAAhwAAAJEAAAAAHwAAAAAAAAEAAAAAAAAAAgEAAAAAAAAEAgAAAAAAAAYUAAAAAAAABxIA +AAAAAAAIAwAAAAAAAAoVAAAAAAAADxMAAAAAAAAQBAAAAAAAACAFAAAAAAAAQAYAAAAAAACABwAA +AAAAAMAWAAAAAAABAAgAAAAAAAIACQAAAAAAAwAXAAAAAAAEAAoAAAAAAAgACwAAAAAADAAYAAAA +AAAQAAwAAAAAABgAGgAAAAAAIAANAAAAAABAAA4AAAAAAIAADwAAAAAAwAAaAAAAAADgABsAAAAA +AQAAEAAAAAABgAAcAAAAAAHAAB0AAAAAAeAAHgAAAAACAAARAAAAAAYhegAAAAUAAAAEAAAAAQAA +AFIAAAATAAAAGwAAABYAAAAQAAAAAAAAAAAAAABSAAAAWwAIGzIAAAAGAAAADAAAAAIAAABnAAAA +AAAAAB0AAAAUAAAAEAAAAAAAAAAAAAAAVwAAAGMACYloAAAABwAAAAIAAAACAAAA/QAAAAMAAAAe +AAAAGgAAABAAAAADAAAAAAAAAFsAAABoAAoh/wAAAAcAAAACAAAAAgAAAGcAAAAcAAAAHgAAAB4A +AABQAAAAAAAAAAIAAABcAAAAbAAKupUAAAAIAAAACgAAAAMAAAD1AAAAAQAAAB4AAAAaAAAAEAAA +AAEAAAAAAAAAXQAAAG0ACyBPAAAACAAAAAoAAAADAAAAagAAAAIAAAAeAAAAGgAAABAAAAACAAAA +AAAAAF4AAABuAAun8QAAAAgAAAAKAAAAAwAAACkAAAACAAAAHwAAABwAAAAQAAAAAgAAAAIAAABf +AAAAcQAMNQAAAAAIAAAACgAAAAMAAABSAAAAEwAAABsAAAAbAAAAUAAAAAAAAAAAAAAAYQAAAHMA +DELzAAAACAAAAAoAAAADAAAA9QAAAAEAAAAbAAAAGwAAABAAAAABAAAAAgAAAGEAAABzAAy3NgAA +AAkAAAAGAAAAAwAAAP0AAAADAAAAHAAAABwAAAAQAAAAAwAAAAAAAABkAAAAcAANHO8AAAAJAAAA +BgAAAAMAAAApAAAAAQAAABwAAAAcAAAAUAAAAAEAAAACAAAAZAAAAHEADj3VAAAACQAAAAYAAAAD +AAAAKgAAAB8AAAAfAAAAHwAAABAAAAAAAAAAAgAAAGYAAAByAA7VvgAAAAoAAAAJAAAABAAAAGoA +AAACAAAAHAAAABwAAAAQAAAAAgAAAAAAAABmAAAAdwAPQkAAAAAKAAAACQAAAAQAAAD9AAAAAgAA +AB0AAAAdAAAAUAAAAAIAAAACAAAAZgAAAHcAD7xSAAAACgAAAAkAAAAEAAAAKQAAAAEAAAAdAAAA +HQAAAFAAAAABAAAAAgAAAGsAAAB4ABBGBAAAAAoAAAAJAAAABAAAAGcAAAAcAAAAHQAAAB0AAAAQ +AAAAAAAAAAAAAABrAAAAeQAAAAcAAAAAAAAAOwAAAAAAAAACAAAAAAAAADgAAAAAAAAABAAAAAMA +AAA7AAAAAQAAATYAAAFsAAABlgAAAPAAAAEgAAABUwAAAOEAAAExAAABYQAAALwAAADkAAABCwAA +APUAAAEiAAABSQAAAMYAAADrAAABDwAAAMIAAADqAAABEwAAAJ0AAAC/AAAA3gAAAMsAAADtAAAB +DQAAAKoAAADJAAAA5AAAAKMAAADEAAAA4AAAAIEAAACiAAAAvQAAAK8AAADMAAAA4wAAAJQAAACw +AAAAxgAAAIsAAACoAAAAvwAAAAAAAACBAAAAnQAAAJoAAACzAAAAxwAAAIEAAACbAAAArwAAAG4A +AACPAAAApQAAAAAAAAAAAAAAAAAAAIkAAACfAAAAsQAAAG0AAACIAAAAmwAAAAAAAABhAAAAcgAA +AAAAAAAAAAAAAAAAAHoAAACPAAAAnwAAAAAAAAByAAAAhwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAPsAAAEmAAABagAAANkAAAD/AAABNgAAAO4AAAEuAAABjAAAAKsAAADTAAABEwAAANYAAAD5 +AAABKgAAALkAAADaAAABCgAAALcAAADiAAABMAAAAIwAAACtAAAA4QAAALoAAADZAAABBgAAAKIA +AAC+AAAA5wAAAJYAAAC3AAAA6gAAAGUAAACMAAAAugAAAKQAAAC/AAAA5gAAAI4AAACoAAAAzQAA +AHoAAACYAAAAwwAAAAAAAAAAAAAAlAAAAJEAAACqAAAAzQAAAHsAAACVAAAAtwAAAAAAAAB6AAAA +owAAAAAAAAAAAAAAAAAAAIAAAACYAAAAuAAAAGQAAACBAAAAowAAAAAAAAAAAAAAfQAAAAAAAAAA +AAAAAAAAAG0AAACGAAAApQAAAAAAAABmAAAAjgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA +AAEpAAABVQAAAM4AAADzAAABFQAAAMcAAADuAAABFgAAAKEAAADDAAAA4AAAAM0AAADtAAABDAAA +AKsAAADKAAAA4wAAAKIAAADBAAAA3QAAAH0AAACeAAAAtwAAAK0AAADJAAAA3wAAAJMAAACtAAAA +wQAAAIYAAACiAAAAuQAAAAAAAAAAAAAAiwAAAJcAAACuAAAAwAAAAH0AAACWAAAAqQAAAEwAAACB +AAAAmQAAAAAAAAAAAAAAAAAAAIUAAACaAAAAqwAAAGIAAAB/AAAAkwAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAHYAAACJAAAAmQAAAAAAAABWAAAAeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AGYAAAB6AAAAiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN8AAAEDAAAB +MQAAAL8AAADfAAABEAAAALwAAADkAAABLAAAAI8AAACvAAAA4gAAAL0AAADcAAABBwAAAKQAAAC/ +AAAA5wAAAJYAAAC2AAAA5gAAAFcAAACGAAAAtAAAAKQAAAC/AAAA5AAAAI4AAACmAAAAygAAAHYA +AACTAAAAvAAAAAAAAAAAAAAAAAAAAI8AAACnAAAAyAAAAHgAAACRAAAAsgAAAAAAAABtAAAAmQAA +AAAAAAAAAAAAAAAAAHwAAACUAAAAsgAAAFoAAAB6AAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAGcAAACAAAAAngAAAAAAAAAAAAAAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABq +AAAAigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANsAAAEAAAABGwAAALcA +AADXAAAA8AAAALAAAADPAAAA6AAAAJAAAACuAAAAxgAAALMAAADOAAAA5AAAAJkAAACyAAAAxgAA +AI0AAACnAAAAvAAAAAAAAAAAAAAAjQAAAJkAAACvAAAAwAAAAIAAAACXAAAAqQAAAAAAAAB8AAAA +lAAAAAAAAAAAAAAAAAAAAIUAAACZAAAAqAAAAFoAAAB7AAAAjwAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAHQAAACHAAAAlQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEA +AAB1AAAAgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAcQAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMwAAADrAAABGAAAALIAAADPAAAA +9gAAAKkAAADMAAABAAAAAIIAAAChAAAAygAAAK0AAADIAAAA7QAAAJgAAACxAAAA1QAAAIMAAACg +AAAAxwAAAAAAAAAAAAAAlgAAAJUAAACtAAAAzgAAAIAAAACYAAAAuQAAAAAAAAB1AAAAnQAAAAAA +AAAAAAAAAAAAAH8AAACWAAAAtAAAAFUAAAB9AAAAnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AGYAAACAAAAAnQAAAAAAAAAAAAAAfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiAAAA +hgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXwAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAD/AAAADwAAAP8AAAAPAAAA/AAAAAAA +AAD/AAAADwAAAPgAAAAJAAAA2wAAAA8AAADwAAAADwAAAKUAAAAPAAAA4AAAAAkAAACZAAAADwAA +AMAAAAAAAAAAmQAAAA8AAACAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAADwAAAPwAAAAPAAAA +/AAAAA8AAAD4AAAABQAAAPwAAAAPAAAA8AAAAA8AAAC0AAAADwAAAOAAAAAFAAAAtAAAAA8AAADA +AAAAAAAAALQAAAAPAAAAgAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAA +AAAPAAAAwAAAAAAAAAAAAAAADgAAAMAAAAAAAAAAAAAAAA8AAACAAAAAAAAAAAAAAAAOAAAAgAAA +AAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAA +AQAAAAAAAAAAAAAAAAABOIAAAGgqAABOIAABhqAAAYagAAII1QACCNUAAAAoAAAAMgABBGoAAGgq +AABKZwABhqAAAYagAAII1QACCNUAAAAoAAAAMgABWwEAAGgqAABQIAACCNUAAYagAAII1QACtnEA +AAAmAAAAMgABKW4AAGgqAABNKQACCNUAAYagAAII1QACtnEAAAAmAAAAMgABBEEAAGgqAABKZwAC +CNUAAYagAAII1QACtnEAAAAmAAAAMgABdAYAAGyBAABUAQACiwoAAgjVAAKLCgACtnEAAAAeAAAA +LQABRYUAAGyBAABRYQACiwoAAgjVAAKLCgACtnEAAAAeAAAALQABIVoAAGyBAABO6gACiwoAAgjV +AAKLCgACtnEAAAAeAAAALQABBGoAAGyBAABMlwACiwoAAgjVAAKLCgACtnEAAAAeAAAALQABhqAA +AG+bAABWzgACiwoAAgjVAAKLCgADDUAAAAAeAAAAKAABWzgAAG+bAABUdQACiwoAAgjVAAKLCgAD +DUAAAAAeAAAAKAABOIAAAG+bAABSPAACiwoAAgjVAAKLCgADDUAAAAAeAAAAKAABHBgAAG+cAABQ +IQACiwoAAgjWAAKLCgADDUAAAAAeAAAAKAABbHQAAHLjAABXYwADDUAAAosKAAKLCgADDUAAAAAb +AAAAIwABS1IAAHLjAABVWAADDUAAAosKAAKLCgADDUAAAAAbAAAAIwABL7YAAHLjAABTZQADDUAA +AosKAAKLCgADDUAAAAAbAAAAIwABGFkAAHLjAABRiAADDUAAAosKAAKLCgADDUAAAAAbAAAAIwAB +eroAAHZfAABaPgADDUAAAosKAAKLCgADDUAAAAAZAAAAIwABWysAAHZfAABYVgADDUAAAosKAAKL +CgADDUAAAAAZAAAAIwABQV4AAHZfAABWgQADDUAAAosKAAKLCgADDUAAAAAZAAAAIwABKZMAAHZg +AABUwQADDUEAAosLAAKLCwADDUEAAAAZAAAAIwABESoAAG+bAABP3QACCNUAAgjVAAKLCgADDUAA +AAAeAAAAKAABFwQAAGyBAABOIAACiwoAAosKAAKLCgADDUAAAAAbAAAAIwAAAAAAACtoAAAjgwAA +GGoAAA0GAAALKgAAAAAAAAAAAAAAAAABABAAEQAeAA0AEgAHAB8ADgALABMAFQAbAAgAFwAgAA8A +HQAMAAYACgAUABoAFgAcAAUACQAZAAQAGAADAAIAAQB7AHUA+wD1AEUAbwB9AHcAXwBpAMUA7wCj +AD8A/QD3ALsAOQDfAOkAzwCdAEcAcQAPAFkAJQC/ABMAYwB/AHkAbQBdAD0AuQCbAA0AYQBrAAsA +CQBRAB8AMQBTAMcA8QAhALUAjwDZAK0AMwClAEEAVQCXAJMA4wApAMkA/wD5APMAwwDtAN0A5wAj +AL0AOwC3AE8AHQCNANcAkQDhAOsA2wAbAIsAiQCHAK8A0QCfADUALQCxANMAFwCnAEkAcwBDAGcA +oQA3AM0AVwARAFsAmQAHAC8AswCrAJUAJwDBAOUATQDVABkAhQArABUAZQDLAAUAqQBLAIMAAwCB +AAAA+gD0AHwAdgDEAO4A/AD2AN4A6ABGAHAAJAC+AH4AeAA8ALgAYABqAFAAHgDGAPAAjgDYAKQA +QACSAOIA/gD4AOwA3AC8ADoAHACMAOAA6gCKAIgA0ACeALAA0gBIAHIAoAA2ABAAWgAuALIAJgDA +ANQAGAAUAGQAqABKAIAAegB0AEQAbgBeAGgAogA+ALoAOADOAJwADgBYABIAYgBsAFwAmgAMAAoA +CAAwAFIAIAC0AKwAMgBUAJYAKADIAPIAwgDmACIAtgBOANYAkADaABoAhgCuADQALAAWAKYAQgBm +AMwAVgCYAAYAqgCUAOQATACEACoAygAEAIIAAgABAAMAAgAEAAAAAAAAAAAAAQACABwAGwAWABUA +HgAdABgAFwAMAAsAEAAPACAAHwAaABkAFAATAAoACQAOAA0AEgARAAgABwAGAAUABAADAAEAAAAC +AAQAAAAAAAAAACACkfAgByPYIAKR9CAHKwwgApIAIAcqICACkgwgBynQIAKSICAHKSQgApI4IAcn +sCACkkggByeIIAKSUCAHJ2AgApJkIAcnMCACknAgBycIIAKSeCAHJuAgApKMIAcmrCACkpggByvY +IAKSoCAHI1AgApK4IAcjDCACkswgByJ4IAKS4CAHIlAAAAAAAAAAACACkvQgByIEIAKS+CAHIYgg +ApMAIAchUCACkwggByEYIAKTFCAHIOAgApMYIAcgqCACkyQgByBwIAKTKCAHIcAgApMwIAcgOCAC +kzggByAAIAKTQCAHHhQgApNIIAcfyCACk1QgBx+QIAKTXCAHH1ggApNkIAcfICACk2wgBx7oIAKT +dCAHHrAgApHIIAccICACk3wgBxvoIAKThCAHG7AgApOMIAcbeCACk5wgBxtAIAKTpCAHGwggApOs +IAca0CACk7QgBxqoIAKTwCAHGoAgApPMIAcaUCACk+QgBxooIAKUACAHGgAgApQQIAcZ2CAClCAg +BxmwIAKUMCAHGYggApRAIAcZYCAClFAgBxk4IAKUYCAHGRAgApRsIAcY6CAClHggBxjAAAAAAAAA +AAAgApSEIAcXlCAClIggBxdgIAKUkCAHFywgApScIAcW+CAClKAgBxbEIAKUpCAHFpAgApSoIAcW +aCAClLAgBxZAIAKR1CAHLgAgApHcIActNCACkcAgByyEIAKR6CAHK+AAADAEAAAwEAAAWdwAAFqA +AABahAAAWogAAFqMAABakAABlDAAABAkAAAQMAAAEDwAABDcAAARDAAAeywAAHs0AAHijAAB5owA +AeqMAAHujAAB8owAAfaMAAH6jAAB/owAAI3MAACOgAAAfnQAAI/cAAGRWAABknAAAI/8AAQTHAAE +ExgABBMQAASTHAAEkxgABJMQAAB34AAAd+QAAHf0AAB4BAABnDwAARB0AAEQhAAAlAgAAJhcAACW +DAAAlhQAAJYgAACWLAAAlsQAANAoAACQCAADCNwAA0jcAAOI3AADyNwAAwjkAANI5AADiOQAA8jk +AAGQVAAAYBwAAaDYAAGQkAAAd+AAAHfkAAB39AAAeAQAAHjYAAB44AAAePQABQB4AAUIeAAFEwgA +AZQEAAHjwAAB58AAAevAAAHvwAAB88AAAffAAAH7wAAB/8AAAZQMAAAAAAAAAAAAAAAAAAAwAL// +/0AAADAIv///QAABlBCf////AAGUNAAAABAAAZQIn//j/wABlDgAAAAQAAAQKOH///8AABAs4f// +/wAAEDQB////AAAQOAH///8AABBAAAQAAAAAERAA////AAARFAD///8AAHsoAH3/4gAAezA//+7/ +AAB7OAAAAAEAAHtAP//u/wAAfCQAff/iAAHiiAAIAAAAAeaIAAgAAAAB6ogACAAAAAHuiAAIAAAA +AfKIAAgAAAAB9ogACAAAAAH6iAAIAAAAAf6IAAgAAAAAjcj////wAACN0P////AAAI58AAAA/wAA +joQAAAD/AAB+cH+//38AAH54f7//fwAAfgAAwAAAAAGRVAH///8AAZGcAf///wAAj9gDf///AACP ++P////8ABBMUAAAABwAEEwwAAAALAASTFAAAAAcABJMMAAAACwAAd9wAAAADAAB39P////8AAHgE +AAAAAwABnDgAAcBAAAGc+AABwEAAAJAEAAAAPgABEHgA////AAEQfAD///8AARCIAAAAAAAAlAQA +AP//AACUEAAA//8AAJhUAAAB/wAAmFgAAAH/AACWCAAAAAAAAJYcAP///wAAliQA////AACWKAD/ +//8AAJYwAP///wAA0CAAAAAHAADQJAAAAAcAAwjYAAAAAwADSNgAAAADAAOI2AAAAAMAA8jYAAAA +AwADCOQAAAADAANI5AAAAAMAA4jkAAAAAwADyOQAAAADAAGQUAAAAO8AAaDUAAABgwABkIwAOAAA +AAGQmAA4AAAABQB0AAAABwAFAHAAAAAFAAUIdAAAAAcABQhwAAAABQAFEwQAAAABIAjrcB//l7Af +/5fA4QBeAACAAAD/nwAAIAaBAAAQAABACAAAAgAAAPjAAAAAAGAs/3///yAJLgDhAHIAH/+XROEE +EgAAixRA4QP+AAAEAEjhBAIAAAQAIR//j7CGEAAAAAQAQIAAAACAFAADgBYAA4ASACOAEbIDgBAA +BQAq8S8AAYafAArxLyAJLkAABAAIIAjrkB//lnjhAHYAH/+XrCACkGAgApAA/wD//wAMAACAAAAf +gAAAPx//mEDhAZoAH/+XlAAAIAAAAAgA/8D//yAJLnAAJgwAH/+ZdD////8AAZ4M4QGeAAABnnQA +AZ6sAAGe2AABnvAAAZ8cIAjsoCAI7QAgCS7AIAkwACAJL7AgCS8QIAkvYB//kYDhAC4ABAAAAAKA +UADhAFYAgAAAgP/xAIAAAEAAjgHggB//lOQgBoAAIAaT1AAAFNDhAZIA4QAOAAABAAAAAA//AAIA +AAB/AEAAAwAAAIIAgADBAMD//yP/AADIABAgASDhAH4A4QB6AOEAjgA8AAAA//+//1Bo6Ef4//// +kgAAAPAA8ADfv/v7IAAEBH/3//+AAEIA//f/fwAGAAD/AAAAAEkkkgAAfhgQARABAAB+QCABIAEV +FRUVhCGEIRAQEBDhAY4AAAD+fwQEAYAf/5oMH/+RYMzMzMyIiIiIRERERB//lyzhAM4AAACAAAAA +j8Tg//4AIAaT9AAACMCAAcQRxBHEEQD/AP8AQABAAA9CQAAAHCD//wAAIAkwcCAJMOAf/5Zk///g +AcyIRABERAAAzMyIiP/w/wAAAgAzKioVFR//mgQf/5ikAAD//SAJMZAf/5kkIAAAACAI7XAgByvg +ADAAACAwAAAAYAAAIGAAAOMAAgDi//8A0AAAAM///gAgAoy8H/+ZGB//mbAf/4CgH/+ZOCAF5EAA +ABAA///wACAJMmAgCO+wIAjv8CAI8BAgCPAwIAjwkCAI8OAgCPFAAAAf/yAI8XAgCPGQIAjx0CAJ +MhAgCTHQIAkyMB//mLAgCPHwH/+b8OEAMgAf/4DQAAB7YB/84gAIAAAAH/+XhB//kUwf/5Ew/4AP +///+AB/hAN4A4QDuAAAA///hAv4A4QO+AOEDPgDhA34A4QHiAOEBDgDhAJIAAAEQAAAADwAf/5Zg +AAAJAB//mTT/8AAAAAKABv/7//8gCPbgIAj3QB//gQAf/5awIAXiACACjqAgCPewIAj38OAAAAAA +AH1sAA8AABAAAAAf/5Ww4QCKAAAEAAAgCPhQIAj4gB//mUAf/4EQH/+RsP//x/8f/6gQIAKQZAAC +/8AgCTTAH/+RAAAAQEAf/5hUH/+XfCAJNPAgCTUwIAj4sB//lWwgCPjwH/+aECAF4CAf/5lMH/+V +HB//lJAf/6CAH/+cBB//ngAgAIR0H//pTB//6Dwf/5msIACGKB//mTACAIIQAgACEAIAABABAAAA +ABoAAAD6xogAIAAA8AAAAB//mRwf/5BE4QMGACAF4GQgCPlwIAj5oB//luAf/5iIIAk0UOEAEgCI +AAIQH/+RZB//mXAAAPgAADw8PCAF4gQf/5ZoAAB+TCAGlVQgBeDAH/+W9CBf8AAAQAAAIAoAAAAK +AAAf/5eoH/+XpB//lsgf/5bEH/+BMB//mCQf/5goH/+YLB//mFwf/5hYH/+YUB//mEwf/5hEH/+Y +OB//mDwf/4FQH/+QmB//l2Af/4HQIAj8QB//geAf/5bwH/+VDB//luwf/5UIA+f8GCAI/IAf/4Hw +H/+Y4CACjXgf/5jcD////yACkHAf/5acIAj84CAGk8T//+tAIAaTlP//63AgBpJkIAaTjP//7KAf +/5h8IAaR1CAGklz//+0wH/+W3AP//+AABHIMAARyFAAEchwABHAUAARwKAAEcCAABHAsAACFgD// +/+Af/4I4AAQAgAAA/wAABEAkAARATAAESiQABADgAAQABCAI/6AgCP/QH/+WkAAEAsQABALAIAk4 +ICAJOFAABHBkAADwACAJOIAABEHAAARBxAAEQcgABEB4AARA3AAEQUAABEFEIAkAoCAJAOAgCQEQ +IAkAACAJAEAgCQBwAARwWAAAECgABEFgIAkBYAAAd3cAADMzIAkCoCAJAeAgCQGgIAkCICAJAmAg +CQEwAAAgKAAEdBgABErAAARAwAAEQMQABEHwAARB9AAEdBQAACAgIAk34CAJA8AgCQOAIAkDQCAJ +AwAgCQLAAAQCcAAACPAABAJ0AAQCfAAEApAgCQQAAAC/KAAEcFwABHQAAADwBgAES/AABHIoAAGb +LwABYx0ABAEwAAQA7AAEAQgABHYAAAD//gAEAQQABHYEAAD/+AAEAQAABADkAAR2CAAA/8EABHIA +AABVVQAEcgQABAD4AAQA3AAEANgABHJIAAQBOAAEARgABHJMAAQA9AAEclAABHQIAARyCAAEQEgA +BErcIAkEUCAJBJAgCQTQAARBLAAEQTwABEDgIAkFEAAEQQAgCQVAAARwSAAEcGAABHIgAAR2DAAE +eAQAAYaggBAAACAJOMAgApDwgBIAAwAEAOiAEAADAAQAwAAATiAABADMAAQAxAAEAMgABAE0IAaL +1CAGjxRBLoSAAAIAIQAP/ykABABEIAkFcAAEAkQABAJMAAQCSAYGAAAABAGAAAAeeAABMLAABADQ +AAQA1AAEAPAABAD8AAII1QABBGoABAEMAAQBEAAAosIABAEUAAAw1AAEARwABAEkAAQBKAAEASwA +BAFAAAQBRAAEAlAABAEgAAQCYAAEAmQABAJUAAEAIQAEQfwABEv8AACAIAAACAgABHAwAARgwAAE +YMQAAIgAAARB1AAES9QABEHYAARL2AAEQdwABEvcAARwOAAEcAAgCQWgAARwBAAAwAAgCQXgAARg +yAAAgCQABEAcAARKHAAAFywgCQYgIAkGUEHNzWUABGDkAARg0CAJBoAABEAAAARABAAEQAwABEAI +AARKBAAEcDQABHAIAARQAAAEVAAABGDMAAB/AAAEQdAABEvQAARwUAAEUGgABFBAAARUaCAGilgA +BFBQAARUUAAEUiQABFIoAARSLAAEQBAABEgQAADDAAAEQBQABEgUIAaK2AAEQeAABEvgIAaLWAAE +QegABEvoAARB5AAES+QABEHsAARL7AAEQBgABEoYAADu8AAEUGAABFRgAAARAAAAETAAABAwIAaD +kCAGgIwgBoYwIAaE5CAGiNAgBoeEAAP//wAEEwQABBMkAP///wCBAiDhAeJA/8AMAB//kEAgCQlA +H/+VaAAA4+8ABFCwAARUsAAEYOAAAMHzH/+aSB//gmD//H//AAB+6IAABwCAAAUAgAAGAIAABACA +AAEAgAACACAHflAgCQmQH/+QjCAHf9AgAoygIAkJwEAAAAAf/5m0VVVVX1VVVVUAD///IAXguB// +kJcAVgAA4QT+AOEFBgAAJgAA4QHeAOEAWgDf//4AAACAYAAAQAkAAAnEIAk74CAJPDAgCTxgIAk9 +ICAJPPAgCTuwH/+XiN6tvu8gBpB0IAaSxAAJiWggBpJ0IAaQNCACkSDiAAYA4gAGCOIAAgDiAAII +IAk9UCAJCfDi//4AH/+ZaCAIQAAgCQogH/+Z1B//lLAgB9AAAAAAAGwQBvoKBSAIEFgw/P1TEgAA +aLBbzHkb/VHTD9MPKbDkKLAYCYgCyojz/U4QzBAgMAQkKPT6+yIAICTw+iwAAgAAWPBbigx0oQJl +r+7SoNEPAAArvfgsskorskz+CgMgDBBAMPwJQgAAECAw+w1CAfICUnD6hDkGAIyHYP5EAgABEFAw +aZcCaNeeE/02Css4+3VTD/8QMDAvMrPDgAhIAgaIAwj/Af82syABEFAwW8ajKTKzwaAKmQL5NrMg +ARBQMFvGnioyshv9KAuqAio2sikKgCk2ri8yrxj9JQj/AS82r/39IxA0EHAwDl4o+P0iHAAgd3CJ +2YvaiteP1va7EQggBD5g+6oRCAkAXnAKmQIJ/wII/wIvNrAe/RguNrErMrKO1YjYH/0WjdTziBEP +gAQ7oPz9Eh4JAEOw/7sBDAkAd3ANuwIMuwL7NrIgARBQMFvGeigyshn9DPr9ChAQEFgw/Qp4IBAQ +YDD5iAEAFBBwMPg2siIAAHhwWq72yajAovz9AxAIEFgwW8wbY/6ZAADz/u9gABBQMMGkW8ZowrAq +MrMLTAIGzAMMqgEKSgILqgL6NrMgFBBQMFvGYGP+aABsEAQZ/PP5ksAgCAA0oMAg0Q8b/PArsH8c +/PHz/O8b8AQ+4Ay7AgnqUfs2SSPCAj6g9/zrEAEQKDD2CgIgEhBwMC52sCZ2sy0KyC12sSwa9Cx2 +sttQ/QpkIAEQYDD6/OEQChBwMPV2kSAAEHgwWq7J9qJfYgAAIrDA7/8KByAGEEAw+goFIAQQWDD5 +/NcQABBgMB381i12oMTRLXaAwNgtdqMrdrXE2i12tih2ty92uCx2uSh2uip2uy52vMHVLXa9KHa+ +K3a/KnbAwNotdsEqdsIvKgAvdsMrdsTBgCh2xS8KZC92xisqmyt2xyV2yCp2ySp2yigKAyh2yy8K +Ei92zC52zRv8uyuySioKTv46ACpUAVww/nbOK9AEPuALqgwqdrQslhQmlhUoChgolhka/LIb/LL/ +/K8QARBwMP92kCAAEHgwWq6T9qGHYgAAIrAa/Kob/Kr8CgAgChBoMP78qBAAEHgw/naQIAEQcDBa +ron2oV5iAAAisBr8nxv8oPwKACAKEGgw//yfEAEQcDAPAgAPAgD/dpAgABB4MFquffahL2IAACKw +GvyUG/yU/AoAIAoQaDD4/JQQARBwMPh2kCAAEHgwWq5z9qEGYgAAIrAa/Ikb/Ir8CgAgChBoMPn8 +ixABEHAw+XaQIAAQeDBarmn2oN1iAAAisPv8gBAAEGAw+vyDEAoQaDD6dpAgARBwMPr8eRAAEHgw +Wq5e9qCyYgAAIrAb/Hv7NkAgARBQMFvF0hb8eR78eBz8ePw2QCAAECAw1eAtMkD/AgACAFXrUMCq +W8XKsUT2Sehx/gJxcP4KAC/7EBgw+goFIAgQWDD8/GwSAABo8FvLb/YwVGIAACDw+vxoEAcQWDD9 +CmQgARBgMP8KACABEHAw/naBIAoQcDBarjz2oCliAAAisPr8XRAHEFgw/QpkIAMQYDD+CgogAhB4 +MP92gSAAEHgwWq4x1KDJR8Cl/PxUEAgQWDD9LAACAABxMFvLVNJA0Q/SQNEPAAAAAAAA8/9sYAAQ +GDBsEAQT/Er0CgAgABBQMPYKzCCAECgw9TgIAAEQODAogND5MlUgGAA2IPRMASIAIDTw+ULpaAAg +KPDSoNEPZJ/o8EEED+UANKAAexpkv9raQFvFlWav4mP/zwAAAGwQEhv8NRL8Mx/8NI24LLAXKrI7 +j/D/FgAiAABwcPuw4yAAECAwKSJx+Q9bCWABTDD00MRoACB+cPCTEQl0AWgwA4MCIyZyoc8v8AAv +JnQvInbANPP/AggAIE4w/yZ2IKwANqDwmBEPdAFUMAj/Ai8mgi8idK69LdAAKPqP+P8BDcAEP2AP +3QItJnQoInYsChAMiAIoJnYkJnMqCggqJnob/BD5Cg0gIAJQcPkmeyBgEGAwW8OhGvwH+QoYICAC +QHBtmg/5ggAgCAJSsPmmPyAIAkIwLSK7H/wDHvwDD90BDt0CLSa7HPwBLCaDG/wB+yaEIAAQEDDR +DyQmcigidsfLDIgB+CZ2L1wAtqAkJoJj/4QAAGwQDhz7+BT73h779/b79RAAEDgw+EDRJAAQUDDz ++/URABBoMPn78hABEHgw9WGVKgABRDD7+zkCAAAQ8PvSOQgFAF6w+eXiL+ABFDD/5eMgEgD+MIju +ZIPOLmGPK2GRKmGTrr2q3aXd/ghECgIObJDyCh8j5wC2IAsJRPWT3GiAAVAwZYPU/wIACAHoqJAo +YZ4O/gwN+QwpZZf+ZY4t4AF0MAvfDP9lkCNXADYgCvsMK2WSCbkM+WWWKeABTDAFmwwrZZQO2hEo +YZD6xoQp4AQ6ICjGhyJhlA6fEf/GhSPgBDigIsaGLmGU/8b9L+AEO6D+xvwgABAQMPRhmCABV6yg +y077TP8qAdDFIP8CAAgB2KLQ2kBbtG8d+7Mo0oob+7XwqREIAEBaMP9hjCgJAEowKNaKL9b+LNKB +HvuCDswCLNaBwKhbqzkrYsQuYsL1pRECAAASsPW0DA/wEFAwCkQB/wIACgEN9RAoYsFkghAa+4Qp +oNErCoD0ZsQoCQBecPmk0SIAAFkwHPucL2LD9RYBIAUQUDD7FgAgEBBoMP0WAiAAEFgw9BYDIAIQ +aDBbyoZkQfv0ZugiyAA1IPUKACAAECAwKmLowLjTD/SqCAAAEGAwW8PjsVXzWeh0ACAgsMAgZiHG +W4kD9qHAYgAAErAc+33TD9MPK8KBHfuA0w8PAgANuwL7xoEgQAJQcFuI5fahmGIAABKw+/t6EEAC +UHBap3/2oYViAAASsBj7di9iTidmTfz7bBAAEFAw+P8BD/8QGDD/Zk4gBRBwMNMPbeoY2zDAmXmj +Adtw/c0EIAgCUrD71gAgCAJjMBr7Z1uIxhz7Z/oKACAREHAwbeoU2zDC8X+jAgd7AivGFPqsBCAI +AmMwGvtfW4i8HPtc+goAIAUQQDDTD22KE9swwJl5owHbcCvGKPqsBCAIAmMwGvtVW4ixHPtS+goA +IAwQWDBtuhPbMMLRfaMB23Arxi36rAQgCAJjMBr7TFuIpxz7SPoKACAFEHAwbeoT2zDA+X+jAdtw +K8Y5+qwEIAgCYzAa+0NbiJ0c+z76CgAgDBBAMG2KE9swwpF5owHbcCvGPvqsBCAIAmMwGvs6W4iT +82GXIAA2rKAtYY0uYY8rYZEsYZ4qYZMlYZX0YZggLwA3IJMRlRKUExz7MPoWACIAAHrw+goEIAYQ +WDBbyhTRDwAAAAAA8/4EYAAQIDAc+yiUE5MSlRH6FgAiAAB68PhhmSAEEFAw+BYEIAYQWDBbygfR +DwAAK2K6L2K59LwPL/AQQDAIRAGkWnrzWSlit2SQU/pmuiIAAFqwHPsWLmK49RYBIAUQUDD7FgAg +EBBoMP0WAiAAEFgw9BYDIAAQaDBbyfNj/bML6AwKiAwoZZIFjwwJ/wz/ZZYp4AFEMAWYDChllGP8 +o/P/sGAAECAwKWIWZZwq92WYICAQcDD+ZY8gIBBYMPtlkSWgEFAw+mWTIgAQKDAlZZXz/Dln4BBo +MAAAlRD8+vQSAABrsP+sAAIAAHLw+goCIAYQWDBbydTz/H1v6hAQMPP9Xm/0EBAw/vwAAAIQUDD8 ++ukQBhBYMFvJy/P8Wm/0EBAwAAAAAAD9TAAAAhBQMPz64hAGEFgwW8nDY/yEAAD9TAAAAhBQMPz6 +3RAGEFgwW8m9Y/xsAABsEAjz+toQABBQMPb61xIAACKwKSpAKTaqJzKFIjKGGPrUwFP4eAEP/BBI +MPkiAQQFAEFwBCIC8jaGIFoAFfDAqPoWBCAIECgw9WR+IAgQIDD0FgAgCBAYMPMWASAIEEAwmBJg +ACMAAPoWBCACECgw9WR+IAMQIDD0FgAgABAYMPMWASABEEAwmBL0VQoMVAE4MPQKICxXATww9TUI +DEAEP2D4+rQUACAuMPNgfiQAICzw9UQMACgQODD0ZH8mAwA/MPT6rRbwBD3g+fqsFgkAP3D3MwIA +AxAQMPVC0CIJAETwDwIAbSod8mB+ICACITAJVQH3IgIECQAs8PVGzCIJAESwJULQEvqc+PqeECAQ +MDD5VwEGAwAzMP9mEAYJADzw90bQIAMQGDD3+pUSAAAgcG06GyMi4PVCACAgAhCwtEQHMwEGVQIF +MwIIMwIjJtz2+ooQIAIocPj6jBAgECAw9/qGEB8QcDAPAgDTD20IRfQSFAQDAHEwK2LsJmwQ+E8R +AgMAEzD5UgAqwAQ5IPraAgLwBDig+LsBDgkAF/D/qgIICQBecPqZAgAIAilw+WboIA4IObBj/67A +INEPAAAAbBAE9vpyFAAgJPAGJgrzZech/gIpcCVl6NEPAGwQBBX6bPYiACAgEBgwbToGh1B2ewW4 +VcIg0Q+XICJQBNEPAGwQCMBg8xYCIgAAWXD3+mESAABRMPIWBSIAACCw+xYEIAICELD6FgMgQAIp +8Cpyf1uprfssAAIAABqw+nJ/IgAAYPBbxdX0oBBgEAI58PV523AQAjGwwCDRD7E8rEwqwADF3f8K +ACYAhu6Q9fwAAgAAcHDzCgAgABAQMPQKIiAvEDgwbQgTyaPKJHehQmgiX7HK3KAqoAB9oWNj/+XI +MSc0AGRfsPRUACAAEBAw0Q8AdKnZ8iwBIAICUzD65gAgCAJzsPP/zWIAAGKwAAAAAAD/xAAgAgIQ +sPrMASIAABsw+uYAIAgCc7Dz/6hiAABisHSpnC/EAPP/lmIAACswySZoIUJoIjLIMSc0AGRfR/RU +ACAAEBAw0Q+NEvLWACAHADTgJzQAy18Y+hwS+c+oIvRUACIAIBGw0Q+LFPoSASAAEGAwW6hKixP6 +EgAgABBgMFuoRokS8pYAIAcANOAnNADIUSRUAGau7Rj6DBL5v6giomLRDxj6CRL5vPgSAiIAIECw +/4YAIgAgEbDRD2wQBIswJrAAJwoA/wIAAgAASvD/AgAIAEEFoGRgegu5AvgaACAAEFAw/AoJICMQ +aDBtCGFobBV8YRJ9YSH4jP8gAgJSsPYkACACAhCwsXereSaQAGhpWWSAbM9mYABRJJAA0w8PAgD4 +SUJgABAoMKt79rAAIgAAOvBtCBT0YDFgAgIpcCZwAbF3+GkiYgAASfBj/+TTD2P/l8CA+CQAIAIC +UnD6NgAgABAQMNEPq3urWcmCwLD7JAAgAgJicPw2ACIAABKw0Q/GKtEPAGwQCFv+6fanHmIAABKw +FfnOGfnP+vnMEAEQWDD8+cwQABAQMBj5zCimpSympCKmpx/5yi+mph75yS6mqR35yS2mqCymqxj5 +xyimqi1Sgh/5xh75xg/dAQ7dAi1Wghz5xCxWhitWhyhSqggYS/8CAAYDzE4QFPl3F/m/8/m/H/8Q +MDAd+b4c+b6c0CgywBn5vQmIASg2wC4y0C/qwP/uAQEVEHgwD+4CLjbQHfm3LTbRKDLYHPm2GfmY +DIgBCYgCKDbYLjLbH/myD+4CLjbbHfmxLXY1KTLdLPrfDJkBKTbdLjLSGPmtH/mtCO4BD+4CLjbS +LDLSKUDQx94NzAH8NtIiOAE6YC4y0xj5ph/5pgjuAQ/uAi420yY29CY29S4ywR/5otMP0w//7gEA +gBB4MA/uAi42wSwywh35nQ3MAiw2wilyLRv5mxr5m/z5nBgAQF5w+vmZGAkAVnD5di0gBRBYMFuo +xxr5lPz5lRAGEFgwW6jDGvmR/PmREAcQWDBbqMAa+Y38+Y4QCBBYMFuovBr5ivz5ihAJEFgwW6i5 +GvmG/PmHEAoQWDBbqLUa+YP8+YMQCxBYMFuoshr5gRz5gxj5gfh2DiAgEFgwDwIAW6is+vl8EUEQ +WDD9CgAg/xBgMFung/r5dxFBEFgw/QoAIP8QYDBbp38a+XL8+XQQ5BBIMPl2CiAjEFgwW6idGvlt +/PlvECQQWDBbqJoa+Wn8+WsQJRBYMFuolhv5apt8m3sU+Rf1CgAgABBQMPIKzCCAEDAw+3YNLAAg +MTAswNAPAgD9QlUk1gA3IPVcASQAIBEw+VLmbAAgMTD2pLxiAAASsBX5WQ8CAA8CAC1S1B/5Vx75 +Vw/dAf7dAgAuEFAw/VbUIAEQWDBbhs/6Ci4gBxBYMFuGyPoKLSABEFgwW4bK+gotICkQWDBbhsP6 +CisgARBYMFuGxPoKKyApEFgwW4a9+goyIAEQWDBbhr/6CjIgKRBYMFuGuPoKLyABEFgwW4a5+gov +ICwQWDBbhrL6CiYgARBYMFuGtPoKJiApEFgwW4at+go6IEcQWDBbhqr7CgEgqRBQMFuGq/sKLSCp +EFAwW4al+go2IAMQWDBbhqb6CjYgLhBYMFuGn/oKNyABEFgwW4ag+go3IDwQWDBbhpr6CiUgAhBY +MFuGm/oKJSADEFgwW4aU+go7IAIQWDBbhpX6CjsgBhBYMFuGj/sKASCzEFAwW4aQFPkSKEGBwSj/ +AgAIAhvAkPsKViCzEFAwW4aF+gpHIAEQWDBbhoYpQYH/AgAIAhNIkPoKRyA6EFgwW4Z9+gpGIAEQ +WDBbhn4qQYEPAgAPAgD/AgAIAgfQkPoKRiA5EFgwW4Zz+gpAIEwQWDBbhnD6CjMgTRBYMFuGbvoK +OSBOEFgwW4Zr+gqyIGIQWDBbhmj6CkkgTxBYMFuGZfoKTSABEFgwW4Zn+wphIE0QUDBbhmAtMv4e ++HMO3QItNv4rUpAsCi8MuwIrVpBb/Jz2osRiAAASsBz438Cg/MCAIAQQeDBt+gwAoAQMDRt/1wGx +qbGqG/jcFfjbF/jZEvjWLkF7/QoEIfoCenAP2Tj+LkACAABScP/40RoFAHNwKLKALkF7x8sMiAH4 +toAgAT1/kP8CAAABvgZg/wIAAgG+gmD/AgAEAcICYBr4lBv4pxz4x/gKACAQEEgw0w9tmg0LiQos +lp/6lq8gAgJCMFv8L/aiI2IAABKwGvi9+woRIBEQYDBblF0oUigW+LoX+E/4FgQgHwA2IMCgW5Tn ++goAKAAgNrAqloGLFCuWgiqWgyeWgCVSWw8CAMlXwKFblN79CgAsACAysC3GgSXGgi3GgyfGgBj4 +qfv6/yBUEFAw+YJ/IAgCQjAPAgAPAgBtqgz5gn8qACAycCumgLSIKkF+ppzTD/vGgCKQADagwNAa ++Ij8Cv8gJxBYMFumkRr4hRv4lxz4l1unsh74cR/4lS/mcBr4fxz4lR34ky3meP34kxJAEFgwW6aG +xJAqCgMKmSz5GBQP/BBgMPr4GhAGAkIwDIgB9/iLHSAEOiD6ojYpgAQ6IP6ZEQgJAGIw+fhPGAkA +SjD3pygAMhBYMAuqKCiWpVuHpRv4CyuyNiwKZPy6KAIAADKwW4egHPgGLMI2LTro/cooAgAAKrBb +h5uwaPitEQ8ABDog/t0CAf4CYXANzQItNuQAwAT3ChkAFBBYMAuqLCo27Ssy7CsWBSkKACk25QCA +BAcFGSUWBgUuFC425gpYESg25wVZCik26Cg26Rf4YQdXKCc26iYKSwZWKCY26xz4XQy7AQtbAis2 +7Pz4WxJYEFAw+lUoAAgQWDD1Nu4gABBoMPkWACIAAHow+BYBIAQQUDBbxuz1FgEiAABp8P8SBSIA +AHGw/PhOEAQQUDD4EgYgCBBYMPgWAC/wAXwwW8bhKUF+zJ4qQX/MqStBgMy0LEGBZMFT0Q9k2yra +UFvBNmarMmP7H8Dg/lYcIrQAOmD/AgAEAJUCYGmhUilQgBr4Obqs/qwFKAAgMrDygM0uACAzsP3g +zSwAIDMw/8DNIAAQWDD7hM0oACBMsPvkzSgAIE9w+8TNKAAgT/ApVIBj/UYAAAAAAP9WHSFiAD6g +/wIAA/6bGqAvUIooUIArUIX5UI8gABBgMCxUhfxUjygAIFow+FSALgAgT/AvVIpj/QcAAAAAAAD7 +CgIgsxBQMFuFfGP7vgAA+gpHIAIQWDBbhXhj+88AAPoKRiACEFgwW4V0Y/vmAAAuorwtUqof+AoO +Tksu7P7/7hEMAEB/cA7dAi1WqmP4Sy9Bf2X9bShBgGWNZylBgWWdYfP9YGAMEGgwG/f+K1YcY/yO +HPf+Hff8LVYcLFYdY/x/J1YdL1Ye8lYfIAAQcDAuVhxj/GsAACdWHS9WHiJWH2P+zSsy4B338hz3 +8tMPDbsBDLsCKzbgKTLAGvemCpkCKTbALzLYGPeIGvfH/PfqHgkAR/D/NtggIBBYMFum8h/3oyry +GMCUCaoCKvYYKPIZCYgCKPYZwOEu9iDRDwAAbBAEEvfeIiF/wDXzKBNwABAgMBP32yQ06CQ06SQ0 +6iQ069EPbBAEE/fVFPfWIjF/BCIBIjV/0Q9sECj3CgEiIQA0oP8CAAABngSg/wIAAgGkgKD/AgAE +AfIAoPb66iQBpgSg8AHpYAAQGDAlEkYmHIT2+uokACA1cP18AAACEFAw/PfBEAEQWDBbxk3AovsK +ASAAEEgw+VR9IAoQQDD4VHwiAABgcFvGRhv3uMCh+rSIIADLLaAf97Uv8h3+CgAiAABY8P8qFAAA +EGAw9KOYaGIBeDAKShRtiQuJsLHu+7wELAAgYnBkoRKJtIiwhLH9sgIgIAJzsPyyAygAIGIw+LIF +JAAgQTD0sgYsACAncP2yBywAIGsw/LIIKAAgZnD5sgkoACBKMPiyCiQAIEEw9LILLAAgJ3D9sgws +ACBrMPyyDSgAIGZw+YgIAf4CSrD4vEAkACBBMPSyDywAICdw/bIOLAAgazAPAgAPAgBtmYf5ggAg +IAJzsPyCASwAIGdw/YICKgAgaTD5ggMkACBScPyCBCQAICMw/YIFJAAgI3D5ggYkACAicPyCByQA +ICMw/YIIJAAgI3D5ggkkACAicPyCCiQAICMw/YILJAAgI3D5ggwkACAicPyCDSQAICMw/YIOJAAg +I3D0gg8oACAmcPnMCACAAkIwrNysTPv3ZB4gAXww+B0BID0AN+Dz6QoABBBQMP+qDAAgAkIw+ZIA +KAAgQ/DTD/kWRCAAEEgwDwIA0w/TD22pB/mEACACAkIwKhJErKwsth4d91HAwSzUiMg2/wIABADd +AKDSYNEPAAAe90wANRGuU/5cAAAEEFAw/PdJEAEQWDD9LAACAAB48FvFz8Cl+woBIgAAYPBbxcwt +MAAjFkD1CgAhCAJgcPTRLmD/EHgw/wIABgCbf1DA0P0WRSAAEFgwKxZH8AA+b+oQMDAAAC4SR9MP +ZO2dKxJBiOEsEkL9EkMiAABQcAuAAPahDGIAADKwLBJA0w8swADVcPTAf2D/EGgwfcF3+x0BIgAA +UHBb/NUsEAD6FkYgAgI5cA8CAP0KWy/OADcgfcmjKByEqKUuUHsvCl0PAgB/6ZItHQH73AQiAABQ +cPzcCCAYAmtwW/xi+hZHITwANqAvEkVl8SQZ9xCIoXmJiSsSQPz3ChABEFAwKhZFA7sMK8YdY/9y +ZmB3HfcFwMEs1Ihj/TIV9wYY9wYAMxGlNfP+1mIAIETwAAAV9wMY9wMAMxGlNfP+wWIAIETwGPZz +KIDRGvb++fb/EJAAfjAjkcQHMxHz/qJiACBU8AAAAAAAAPXMAAAAEDgw8/ydb+oQMDD1zAAAABA4 +MPP8jW/qEDAwJRJGKByE8/x/ZAAgRXAAACORwwczEfP+XmIAIFTwAAD79pkSAABQ8FvHvvoKBiAA +EFgw/AoAIAAQaDD+CgAgABB4MFu/R9Jg0Q8A3XD79t0QBhBQMP/2ixUABDzg/goBIgAAYXBbvz4Y +9tgogoBogA4T9tRj/gAA8/2QYAAQYDAT9tHz/dlv/hAwMMCi/PbPEAEQWDBbxU7z++1v6hAwMGwQ +BBb2yyliWShiWCRiWvn2yRgAIEow+AoAJAAgQTD0QNhh/gIRMCeSeCVipgl3EadVKFQhKFQgmFyY +WyhWDyhWDihWEShWEihUVShUVChUfihUfyhVLChVMihVMyhVNChVNShVNihUbihUbyhUcChUcShU +cvhUcy//EDgw91R2IAEQIDBtKWcikngjYqYoVRPyQggAAgIhMPhVOiOQBDig+FUSJAAgFPAoVHEo +VHIoVHMoVCEoVCCYXJhbmF+YXihWEShWEihUVShUVChUfihUfyhVLCdUdihVMihVMyhVNChVNShV +NihUbihUbyhUcChVEyhVEihVOtEP0Q8AAABsEBIY9o0jFhEkFheFiIuFh4eJhoyEjYOOgv+CASAg +AjBwn2GeYp1jnGSZZpdnm2UlZgj4ggAiAABQ8PhmACJtADSgKBIXKxIXFvZ89wqAL8AQYDD0slRv +BBAoMC1ihi5ihPqIEQAJEEgw+SYPIH4CQjDzJgUoAEBiMPP12xgAIEKw+CYGL/AQWDD5YoMkACAv +cAtVAf8CAAoBA/VQ+jDRIf8ANmD1ZoYqCQA6sPo00SIAAGlw9PXqEAUQUDD/YoUgABBYMPUWAyD8 +EEAw/RYAIBAQYDD8FgIgAhBoMPgWASIAAGEwW8TSGfXr+lwAAcYANWD6JhAhuQA2oIov9woAIAAQ +GDD0FhMgABBoMPShGGAgAiBwKRYSLRYWKxIXikALqijwcAQAZBBYMAuqLPsiECB+AlKwCmoUKhYU ++goZCgAgHvArFhgqFhVbpVItYoYoYoMuYoT61QwP+BBYMAtVAf+sAAoAZHVQ+vWfEMAANiApoNH1 +ZoYggBBYMP8WECgJAF5w+aTRIgAAaXAsEhMoEhAvYoX9FgAgBRBQMPUWAyAIEGgw/RYCIAAQWDD4 +FgEgAhBoMFvEnvpcAACAADVgKRIY+pYAIOEANqAlEhH7EhUgABBgMFu9/C8SFC0SFiwSGPBxBAAB +EHAwAO4alcGdxJ/D+v8RDAAgb/D+xgYkACB9cP0WFiH+Amtw/cYFIYACWXCbwoovtET3fAEgOAIY +8PUWESv/e1XQwCDRDy8WEPP/WGAAECgwAAAAAC1ifC9iey4SEPXcBy/4EEAwCFUBpe75YnkqACF3 +0Mua/mZ8IgAAa7AsEhIoEhAuYnr9FgAgBRBQMPUWAyAIEGgw/RYCIAAQWDD4FgEgABBoMFvEaPP/ +LGIAAFFw8//IYAAQKDDz/hFgABAoMMck0Q/BJtEPwCzRDwAtYnwvYnv13A8v8BBAMPsK/CQAQEVw ++1sIAgAAYnD5YnkqACTf0GSQQftmfCIAAGrw/mJ6IAUQUDD1FgMgABBYMP0WACD8EEAw+BYBIBAQ +aDD9FgIgABBoMFvESBn1YPP922IAAFFwAAAAAPP/wmAAECgwbBAQW4TmIy0BKiZgW4Tg/TIgIA0Q +WDD19cEQDBBgMPo2ISAEEEAw/a0MAAEQIDD69boQAgJrcP02IiEkEDAwF/VqGfW3KKRFKDSjKDSd +JTYbJDShLDYcLDSkK6REKTYd+zSlIBAQSDApNKf3ctogDhBYMPs0piACEGAw/DSiIAAQYDD8NKAn +8AE8MPc2HiYAIDCw9zYfIgAAWbDTD22KEi+wgADxBABOGvXhCHACAlrwsczAxAwOR/40nSQBHgOg +/PWZEAUQUDD99ZUQMBBYMFvEDS4yIC0yIQ7dDLHdDW0U+dwAAmMAN2AND19k8vDCoAmIV2SC8wnL +U2Sy+gnsUWTC/7CuCeo71aAqCgX89YYQMBBYMP5cAAAREHgwW8P6wYEIWDb4NJwh/gIyMABhBABF +GvCBBAH+AilwJTYj9TYkIKACSHDwRhoADAJCMPCBBAEgEFAw8E8aAf4CMbD2NiUh/gJ78P82JioA +IFCwK6CDLKCCLaCBLqCAnpCdkZySm5MU9TD89WkQBRBQMP1C2SAwEFgwW8PcLzIlCv8RL0bZ/PVj +EAUQUDD9QtkgMBBYMFvD1Rz1YC0yICsSFS8SFykSFvgSFCAFEFAw/jIhLoAEP+DwmRELgAQ+4PuI +AggJAH5w/zIiKAkASjD4RtogMBBYMFvDxfz1UBIAAHnw/TIeIAUQUDD+Mh8gMBBYMFvDvhT1QRz1 +Si8yJf4wnCAFEFAw+TImIDAQWDD5FgApoAQ5oPgWASIAAGlwW8OzHPVAHfVB/kBEIAUQUDD4QEUg +MBBYMPgWACAPEHgw0w9bw6r8PGwiAABocPkyGyAEEEAw0w8PAgD5FgAgCBBIMG2aJ/yJCAoAIGow ++ZIAIAgCWjD5pgAoACBm8PmSACoAIGrw+aYAIBACQjDApfz1JxAwEFgwW8OVwKX89SUQMBBYMP0a +8CHwEHAwW8OQ/PUhEAUQUDD7CjAgBRBoMFvDi/syICFsEFAw+ioIDaAEOWBb/nrAINEPAAAAAPz1 +FxAFEFAw/fUHEDAQWDBbw38sMKQtMhsAwQQAThoAwAQNCxlksO0sMhywy/CwBAH+Akuw+QkZD/8Q +UDBtCAoJGRT0kBFgAgJSsGP/7gAA8/2+YAAQKDAAwQQATRrwsAQB/gJbcPsLGQ//EEgwbQgKCxsU +9LAJYAICSnBj/+4AAAqZDClkfCwyHPxkgCACAmpwLWR9KjIcspv7ZH4gAgJSsCpkgS8yHLOY+GR/ +IAQCe/AvZIIuMhyz7i5kg/oKACAEEHAwbeoSKGCAAIEEAE8a9fEIcAICMbCxqsCkCg5HLjSdY/zh +AAAA2RHz/QpgEBBQMAiZEfP9BWHwAlKwAAAMmRHz/P5h+AJSsA6ZEfP8+WH8AlKwwKL89NIQABBY +MFvDO/z00BAFEFAw/fS+EDAQWDBbwzdj/KEAAABsEAoX9MoqcsAscrgrffcosNH0CoAtkAQ7IP+H +DnoAIGKwpKpbmbRgAAkAAC0qgK2qW5mxGfSsLZIS/nJjIC4AN2DAICxyYStyYC9yYi5yY5ISnBH7 +FgAgBRBQMPz0tRAwEFgwW8Mb0Q8AAAD69CQQNAA3oP9yYioAFnaQy/X7cmAqABn+kMu6/HJhKgAc +XpD4CkAgBwA3IHyLOPP/sW/qEBAwACxyYStyYC9yYvP/n2/qEBAwLHJhK3Jg8/+Rb+oQEDAALHJh +8/+Fb+oQEDAAAAAAAPv0JRFMEEgw8xYEKAAgTLD5FgUhRBBQMPkmUyoAIFCwKhYHKiZRKiZS+SZU +IkAQUDBbkG+aGPsqgCJAEFAwW5BsJRIII3JhJnKoDwIABTMoLnKm820MD4AQYDD6FgYsAEBncPXc +AAoA+PdQKHKlZIHmGvPRKaDR/XaoKAkAJnD5pNEiAAAzcBzz6i9yp/YWACAFEFAw8xYBIIAQaDD9 +FgIgABBYMPUWAyACEGgwW8LU/VwAAmkANWD8cmEhvAA3YGTAivbcICAAECAw89wIIGACK3Ab8/CV +3JXd/RYKL/8QQDD/CgAvwBBgMP/VFCJAEHAw/tUVLABAYbD41gAggAJjMCzWCfzWCCBwAlNwW4Nk ++/PhEkAQUDBbkDWMGisiUY4XmsGKGClyYZOxLsYD+8YCIAICITD8rQgEACAusPMmUSYAIDKw+UOJ +cgAgHrCNFityYCoKAv27KACAEGAwWCQ+3aD7cmAg+QA2oGSwjPasICBgAiqw9AoAIBACGrCV3JXd +/RYJIAAQQDD5+v8vwBBwMPnWACJAEHgw/9UVLgBAcbD41RQggAJzsP7WCSBwAlNw/tYIIoAQWDBb +gzn6KkAigBBYMFuQCo4ZLCJTjxWa4YoWK3Jgk8Ev5gP85gIgAgIhMP6tCAQAIC6w8yZTJgAgMrD7 +Q4dyACAesNqwW6MZ26D8ChAgAhBQMFgkEytyYPomViBMADagwMBbu98qcmJboxDBwPusAAACEFAw +WCQKL3Ji+iZYIFkAtqAscmEd8/QrcmAucmMt0hLz/S5v9BAQMAAAAAAAAPP+K2AAECgwLHJhHfPr +L3JiLnJjLdIS8/0Jb/QQEDAAK3JgHfPlL3JiLnJjLdIS8/zxb/QQEDAA+/wAAAAQYDBbu78qcmFb +ovHBwPusAAACEFAwWCPrLHJh+iZXL8MANqD7zAAAABBgMFu7tSpyYFui5ywKEPusAAACEFAwWCPg +K3Jg+iZVL4EANqDAwFu7rCpyY1ui3sHA+6wAAAIQUDBYI9cucmP6JlkgfgC2oCxyYR3zwStyYC9y +Yi3SEvP8Y2/0EBAwLXKeL3KdDwIA+PqAIP4CI3AIRAEDTAh880ApcpsPAgDLl/x2niIAAGswHPNH +LnKc8xYBIAUQUDD9FgAgABBYMPQWAyCAEGgw/RYCIAAQaDBbwiTz/URiAABpMPP/y2AAECAw++wA +AAAQYDBbu4P7EgQiAABQsFv92R7zni3iEsDxCv04LeYS8/vIYgAAErBsEAgW85UsYoAtYngrbfYp +sNHzFgUggBAgMPVt/y2QBD9g/5cofAAgazCkyluYjS9ieC5SwAn/Ea/u9OoIAgAAMrBbmIUKZwxg +ACMAAAAnKoCnyluYhClieChSwAmZEamI94oIAgAAMrBbmHsKZwwmUqj+UqYjwAQ94PNkDA/wEFgw +C0QB+FKlKgEZ9RBkgisa8t8poNErCoD0VqgoCQBecPmk0SIAADEwL1KnHPL2nBb2FgAgBRBQMPMW +ASAAEFgw9BYDIBAQQDD4FgIgAhBoMFvB4GRB/PQmAyHaADUgGvN1A0kU93MKD/AQQDDwCgcD0AQ8 +4G2ZAgBEYSZSqC5Spg8CAANkDAhEAf8CAAoA23UQKFKlZIGrGvK9KaDRKwqA9FaoKAkAXnD5pNEi +AAAxMIwWL1Kn9hYAIAUQUDDzFgEgEBBoMP0WAiAAEFgw9BYDIAIQaDBbwb9kQdf0JgQhVQA1INpA +/DwAAAAQWDBbulwPehGaFFuiUCZSqC5SpvpkDA/wEEAwCEQB86wACgCfdRApUqVkkTMb8p0qsNEs +CoD0VqgqCQBisPq00SIAADEwjBYvUqf2FgAgBRBQMPMWASAQEGgw/RYCIAAQWDD0FgMgAhBoMFvB +n2RBt/QmASDVADUg2kD7EgQgABBgMFu6/9pwW6IxJlKoLlKm+mQMD/AQQDAIRAHzrAAKAJD1EClS +pWSRFhvyfSqw0SwKgPRWqCoJAGKw+rTRIgAAMTCMFi9Sp/YWACAFEFAw8xYBIBAQaDD9FgIgABBY +MPQWAyACEGgwW8GAZEGS9CYCIFgANSDaQPt8AAAAEGAwW7rgHfK//vKwEAAQWDD4CgAgEBBIMG2a +Hg2JAinm+flSxiACAkIwKuL5+5kIAAQCWvAKCk0qlQqKFS8tAS5Sdy70NFqfo8Ag0Q/HJNEPAAAA +8/3pYAAQIDDz/mlgABAgMPP+4WAAECAwKFKeL1Kd9IwPL/AQSDAJRAGkO/8CAAoATN/QKlKbZKCO ++1aeIgAAQvAc8m4uUpzzFgEgBRBQMPQWAyAQEGgw/RYCIAAQWDD4FgAgABBoMFvBTGP9rQAAAPP+ +/mAAECAwKFKeL1Kd9IwPL/AQSDAJRAGkO3vzQSpSm8ur+1aeIgAAQvAc8lguUpzzFgEgBRBQMPQW +AyAQEGgw/RYCIAAQWDD4FgAgABBoMFvBNWP92ADz/3VgABAgMPP/x2AAECAwKFKeL1Kd9IwPL/AQ +SDAJRAGkPn7zOSpSm8uj/laeIgAAQ7Ac8kAuUpzzFgEgBRBQMPQWAyAQEGgw/RYCIAAQWDD4FgAg +ABBoMFvBHWP9+ADz/89gABAgMChSni9SnfSMDy/wEEgwCUQBpDt78zkqUpvLo/tWniIAAELwHPIq +LlKc8xYBIAUQUDD0FgMgEBBoMP0WAiAAEFgw+BYAIAAQaDBbwQdj/h0A8//PYAAQIDBsEAQY8pzA +kCmG+/goCgeQBD1g9koRCVAEPOD6mQIGCQA9sPiNBCYJAE3wl4DRDwBsEAoU8pGISYlIikeLRoxF +jUSFQYZAjkOPQp8SnhOWEPUWASAgAjBwnWCcYZtimmOZZJhlhUqVZvRCCyAEECgw9GYHICQANKBp +IRTybAAACBAoMG1ZCYgg84EIcAgCELDGKtEPwCDRD/P/52IAABBwbBAQEvIH0w8iIoMqCqTyCEMA +CBBYMPgWACAfEGAwW72X+woEIB8QYDD6FggoZAEQMPgWASC4EFAwW72Q+woAIB8QYDD6FgkoaAEU +MPkWAiDMEFAwW72J+hYKIBwQWDDyykMAHxBgMPoWAyDcEFAwW72D+hYLIB8QYDDyC1MA8BBQMPsW +BCAYEFgwW718+hYMIBQQWDDyTFMBBBBQMPwWBSAfEGAwW711+woQIB8QYDD6Fg0seAEUMP0WBiEY +EFAwW71u+woMIB8QYDD6Fg4ufAEQMP4WByEsEFAwW71o+hYPIAAQIDDzHCAggAIocPIcAAAAEEAw ++BYTIAAQeDD/FhQgARA4MIkwiCC7mQCRBPB2GgAUAkIwAIAEBgYby2sa8YIqopYGqixbqlQb8X8r +spcqFhAGuixbqlEuEhQsEhMvEhAAQQQArRrw/xoMCQBrMPwWEy4JAHuwLhYU9EwEIAgCGPD1OZ5w +CAIQsBnxrSsSFCuWhPYKACAQEFgw+BITIAAQUDD6FhUgHxBgMPiWvSFAEFAwW705+hYIIBQQWDD6 +GkwgHxBgMFu9NPoWCSAYEFgw+hpYIB8QYDBbvTD6FgogHBBYMPoaZCAfEGAwW70r+hYLIAAQWDD6 +GnQgHxBgMFu9JvoWDCAEEFgw+hqAIB8QYDBbvSH6Fg0gCBBYMPoajCAfEGAwW70d+hYOIAwQWDD6 +GpggHxBgMFu9GPoWDyAAECAw8hwAAEACGHCMMIsgLMwLAMEE8HoaABQCWvAAsAQKChvKry0aAAra +LCoWEVuqCioWEioSEVuqCCgSEi8SFQBBBACIGvCuGg4JAEfw/xYVJgkAcbD0TAQgCAIY8PU5qXAI +AhCwGfFmKhIVKpaF9pa+IAAQEDDRDwBsEAQU8Wz3CgAgBRAwMAcCR/sKACIAAFCwW41EKQoICXkC +CQlHKUZSKEJTJQoA9UZWI1AEPKADMxQlPQEa8cH7CgIgABBgMP84EAAFEGgw9ogCAAEQcDD4Rlgg +ABB4MFqi9PagcmACAhjwdTnOwLArRlixd/lCWCAAMC6gaXaOEvGtH/Gw/vGwEAAQaDD8CgAgEBAY +MAPbAgsLRytGUgyJFACZEQ6ZAilGU/3cASjgAWgw8AIHCcAEOiD5QlMoACB6MPiCOSCAEEgwbZoC +AEhh/M0IKYICO2DSoNEPbBAEGvGbDwIADwIAKqJ/+MrgI+gQWDALqiyoqG6IBSsal3q7XCoKZBTx +k9MP+kV+IAEQWDBbjS/z8YwQABAQMPpFfyAAECgw2iBbjSHaIFuNGfU2AiAAECAw+iwAAgAAWTD8 +CgMgARBoMFuM/7FEaUvnsSLzPBAloAI4oMAg0Q8AACzqcKysbsgFLQrPetsK8/+UYDIQUDAAAAAu ++jiurm7oBMX3evsH8/98YBkQUDDz/3RgChBQMGwQBBjxb/bxZxAAEGgw+QoAIAEQYDDwABZgAxBY +MAAA+UkIAAICa3D41FRgAgJCMCKAtfQKAC/pADSgB9UR9lUIC5AEO2BtCDMsZvupT/NdBCMABDvg +kjArZvu0VfeAtS8ABDkg9v8KAAICITD//QQuCQBysP72ACv/07kQY//F0Q8AAGwQBBLwnNMP0w8p +Iprz8NcfwBAoMA8CAPSQK2B+AlJwBaoBKiaaKjahKCKW9AoAIBcANiD6CgAiAABZMFuLhCsilrFE +e0PsKSKcDwIADwIA9JArYH4CanAF3QEtJpwtNqIsIpf0CgAgFwA3IPoKASIAAFkwW4t2LiKXsUR+ +Q+wpIp4PAgAPAgD0kC1gfgIicAVEASQmniQ2oy8imfQKACAZADfg+goCIgAAWTBbi2goIpmxRNMP +eEPqKSKY9AoAIBkANmD6CgMiAABZMFuLYCoimLFE0w96Q+opIqIqOgD0kFZgfgJicAXMASwmoisi +oioyzys2ziqtAxvwni4yvBjxELCvD38U9P8RDgBAQ7AP7gIuNrwtMqx/1wgoMssICEt7gTgsMszA +l3yQCC0yzA1dS3vRBsAg0Q9j/7wuMswS8QEvrf4PbxT7/xEOAEATsA/uAv42zCAAEBAw0Q8oMssc +8N0prMD5aRQIAEBiMAmIAig2y2P/rABsEBIa8KMpCgD6oIAgBBBAMG2KDACQBAoMG3/HAbGbsZn6 +8O0R+gJK8PXwfxAEEEAwCYs4GPDn+fDnH/8QcDD7HxQCABBoMP9WgCAAECgw0w9t2hklhoElhoAq +loMuloIqloH+loAgEAJCMCmcEBvw2xzw2x3w3B7w3PgKACBAEEgwbZokC4kKKZ0ElZANiQopnQSV +kA6JCimdBJWQ/IkKAAICQjApnQSVkFuMAvjwzxAIEFAwbaoFJYYwKI0EEvDH9PBPEAAQGDAlJsIl +JsMlJsQlJsX1JsYiAABQ8FuLzioiwA8CAASqAvomwCACAhjw8i1AJagCOOD48EsQCBBQMG2qB/WG +hCAIAkIwF/C5EvC5JXavKyKawsD8uwIAABBAMPsmmiMIEFgwbboWJXbGJXbHJXbIJXbJJXbK+HbF +IAICQjD4HAAAEBBQMA8CANMPbaoH9YYAIAgCQjD0CoggABAYMPo8AAIAAFhwW4uRsTN0Oe8T8CX0 +CgAgAhAwMBvwjvzwjRIAAFDwW4ucIz1A8k0KAAICITD21o0lxgI5IBrwPCqggPTwjRAAEBgwADAE +Cgsb/wIAAgB2ftCxM/RNQCXYAjjgG/CN+vCLHYAEOqBbi4ob78olJov98IkQgBAYMPuw0S/4EHgw +9ApkL/4QcDD68IQQBBBAMPsLQAABEGAw+WoAKgUAXzD8HFAqBQBacPkKACDAAlhwbYpZo9IoIMwi +IM0IqBwEiCzyRQwIAEByMAWFKAKIKARVLASILP6IAQAKAmtw/lUBCAEAQbD1ZTcCAEB6MPK2AChA +AUAw+7wEJAAgRXD1xgAiACAosPzMBCgAIBZw/hxQKgAwypDAwG0IHA7NCovQscwMDEH4vP4iGAA6 +4PjWACH8Akpweas6Y//c2jD8HEAgABBYMFu+Ii8RIC9Givrv9hCEAnBwLeEALuEBAN0R+qCALAkA +d3AtRolj/uUAAAAAAAD6my1wABBgMNMPbQgdDs0Ki9AszAEMDEH4sgxgBAJC8PjWACAEAkpwepsF +Y//ZAAAAKRxQiJD4doQgCAJ6cP/yACAIAkHw/4aEIBACcnD+4gAgEAJ58P72hCAYAmpw/dIAIBgC +cfAt5oQpHGCOkP52iCAIAmpw/dIAIAgCcfD95oggEAJicPzCACAQAmnw/NaIIBgCWnD7sgAgGAJh +8CvGiBrvuy8SGywSGC0SGi4SGQw8FA09FA4+FP8/FA+gBDug/v8QDUAEP2D/3QIMCQBzMP3MAgAp +EFgwW57dwCDaIFuKeQIqAluKcLEiaSTvwCD7Wu4iAABQsFuK0LEiaSTvwCDRD2wQCBTwCRfvYhPv +XShBJBzvb/5BFSAfEBAw+0EXIX4ANiAlQRkqQRv2QRMsACB28KXdqt3+D0QKAbJtkPXzNGiAAVgw +9YMsaIABLDBlkyT+aAwIAZDQkChFFAuPDA1iDCJFHQX/DP9FGCngAUAwC4kMKUUWAv8M/0UcL+AB +fDAK+Qz5RRop4AQ6ICJBFvg2hCPgBDigIjaHIkEaDv8R/zaFI+AEOKAiNoYsQRr/Nv0t4AQ7IPw2 +/CAAEBAwZiKsIkEeyyj4LP8qAXpEoP8CAAgBghIQ2iBbp+YtMorwrhEMAEA/cPxBEiwJAHdwLTaK +LDb+KTKBG+76C5kCKTaBKkES9u/KEAAQEDD178kQMQA2oC8yvdMP0w/8KBEOAEA38Aj/Ai82vSU2 +vFuelvSgCGACAhCwxy7RDypBEnoj0gqrCilB6vs2jSG9ADZgLDKBHe+5DcwBLDaBIkEeI0EdKkEb +JUEZL0EkK0EXJkET/kEVIasAN+CVEJMRkhP8768SAAB68PoWAiIAAGmw+goEIAYQWDBbvfTAINEP +AAAqMoQpQRIoQRMKmQwJKRQpRRUJiAwoRRQlMoQmMocvQRQGVQwFJRQlRRcF/wwvRRYtMocuMoUO +3QwNLRQtRRkqMoUrQRcuQRUsMoYlQRn2QRMugAF0MPyqDAwAIHbw9d0IDeIBUDD82AgL4gFQMPpF +GyoBAMWQZfHUCwhEZYHOBQlEZZHI/wIACADi0JAsQSQObgz+RRQoACBXcAlpDPlFHS3gAXQwC98M +/0UWIQMANyAF+wwrRRgJuQz5RRwp4AFMMAqbDCtFGg7YESJBFvg2hCPgBDigIjaHL0EaDp4R/jaF +L+AEP+AvNoYsQRr+Nv0t4AQ7IPw2/CAAEBAwZiDPKTKBe5ZaKDKKCAhV8IEEAAEQEDAAIhoCAk/y +RR4uRAA0oP8CAAoAtUSgsCn/AgAIALwSUNogW6dnLjKK8K8RDgBAO7D9QRIuCQB7sC42ii02/isy +gRzuewy7Ais2gWP+AMCAKEUeY/34KUHrZZ5AKkHsZa46K0HtZb40Y/49AAAc70iSE5MS9RYAIgAA +abD6FgEiAAB68PhBHyAEEFAw+BYEIAYQWDBbvYjAINEPAAAL6AwFiAwoRRgKjAwJzAz8RRwp4AFE +MAqfDC9FGmP+99EPAAAAAAAA/1wAAgAAa7D6FgAiAABy8PoKAiAGEFgwW7118/0pb+oQEDAAAAAA +AP5sAAACEFAw/MywIAYQWDBbvW3z/Qlv9BAQMAAAAAAA+goCIAYQWDD87oQSAABosFu9ZWP9KwAA ++goCIAYQWDD87n8SAABosFu9X2P9E99Q+goCIgAAa7D8FgAiAABy8PzudBAGEFgwW71X8/6Ob+oQ +EDDeYPzubxwAIFdw+woGIAIQUDBbvVDz/nFv9BAQMPoKAiAGEFgw/O5oEgAAaLBbvUlj/LsAAPoK +AiAGEFgw/O5jEgAAaLBbvUNj/KMAAGwQGBbuxBLuZR/u9ilhEShiNy3wBCrwDPzyAiBQAlhwnLD6 +tAQgQAJwcC3kBP/yACQAEGgw/+YAKAEASjD4FiQqA4/HUP0WICABEFAwF+5m0w/TDyp28Vu5+hTu +4ylCR/8CAAAEkipgGu7hGe7h+woAIAAQaDAooIEuoIAskIMvkIAikIIjkIH/oIIqAQB+8P6ggywB +AHdw+N03CgEAHvDyuzcMAQB/cPy7NwwBAHdwGu5psbv5CgAgARAYMPqggCAEEEAwbYoMAJAECgwb +f8cBsZuxmRzux/JAviH6Akrw9UC/IAQQQDD5izgABBBQMPsiNwACAkNw8kS+JAEARXD1RL8gBhBY +MPUNRw7gARAwW7z9HO65JRYfIhYlL0DALkC9LUC8KEDBKBYAK0DCKxYBKkDDKhYCKUDEKRYD+EDF +IAYQWDD4FgQgBBBQMFu87vscMCAAEFAwW4p7Fe3ZG+6nKhIML1Kh9PAPagAgWrAsUqD/AgAABNUr +IC1SnP8CAAAEi6tgLkJH/wIAAAQPK6AvYejy7lYQBCWr4CxCFitCFS1igilihP2ZDAoDAGbw8pkI +ABgQYDALmSwMmCwrnDAMuy4LmQypiAqIESiNDPoWHioAIEKw//qAIP4CcrAP7gEuFiIudsRbicws +EiQoQkcrEiIKzDcJzBH/AgAKACBm8P8CAAAEAaogLhIg0w/TDw7uDw3uES4WIxruPtMPDwIAL6Ec +9PAgb8AQMDAc7k0swWAd7bwrvD/2uwENwAQ7IPvWjCoAIGbw/u3pEH4CavAG3QEtFiGd4Vu2ixzu +Ih/t+S0SISsSJPnuKxwAIG6wLdw/Bt0B+JHoKgAgX3D99uUgfgJa8P/6wCoAQDbw+rwAB5wANiAt +QMEoQMAqQMUuQMMpQMImQMQrFhL+QkcoACB2cPpmCAgAIGow+YgIAgAAUvD7KQwGACBBsPYWHSSq +ADegDjgUL0C9/xYcIAIQUDD4FhogABBYMFuKFysSGlqdbykSGioWGwmqKFuJeywSGyoSHcC4DLsM ++6ooAGQQWDBanWYrEhv6FhUqACBW8PsWFiAIEFAwC6oMKxIcKhYX+6ooAGQQWDBanV0c7eovEiMr +EhouQhUqFhgLqigODQbyRiEoAEBXcPlGIiAiADfgr+iwiAjYAQiYDPhGIigAIBIwLkIVKHbGKUIi +Dg0GL1Ka0w9k96UoUpxkh7YvUp5k98cvUqHI9ChSoGSH0yhSoy/6wPgWFCAKADYgKFKiZIfTKBIS +DwIADwIADIg3rojyqggB/gJCMPpGHygAQENw+EYhKgBAS3AIqgz4UNEqACASsCpGIvoSFiAgEEgw ++YgCAIAQSDD5EhgoCQBKMChU0fqZCAAIEEAwCYgMKUIWKhIXCLgoCQkG+RIVKABASjALqigLmSj4 +RiAugBBAMPKqCAgAIEZwZGDoK0DAZLZoBp0s/b0oAH4CUrAPqgH6RiMsAEB/cP1GJCoAIGqwK0DB +ZLZUBp0s/b0oAH4CUrAPqgH6RiUsAEB/cP1GJioAIGqwK0DCZLZABp0s/b0oAH4CUrAPqgH6Rics +AEB/cP1GKCoAIGqwK0DDZLYsBp0s/b0oAH4CUrAPqgH6RiksAEB/cP1GKioAIGqwK0DEZLYYBp0s +/b0oAH4CUrAPqgH6RissAEB/cP1GLCoAIGqwK0DFZLYEBp0s/b0oAH4CUrAPqgH6Ri0sAEB/cP1G +LioAIGqwessKLlDRwvAP7gIuVNFbuMj7QhUgABBQMFv6//anYWIAABKw+0IWIAEQUDBb+vsKogL9 +QhYgA7AuoP7SFWAAEFAwbQgKsaoAoQQAOBp9iwJj/+4iEiUmHCD4QiAoACA0sCmQACpGGQ2ILAmJ +LgmIDPhGGCBQAhhwoy8v8AAuQhgC/xD9ds0sCQB/sCxCGRrtmPvtmRHqAmMw/XbOLQAEOyBbiNIu +QhYqQhUrQhgtEh8vQiICuyz87ZAYACAzcCiAAAr/LA7MLPxGGyH8AlrwK0YaHO1ACPguCP8ML0YX +H+2Ho9kpkAAoQhcBmRD6dssoCQBKMC5CGCtCF667+bwwIBgQcDAOmS4Juwz4dswgYAJa8ClCGCpC +Fw6ZLA6qLA2qLB3s7QKZLACqEfvWGygJAFZwKXbHKhIeKnbFKPJXCrkRDogs+ogRCgAgSrD61hgq +ACBCsC/yWA7/LAr/EfrWGSoAIHqwDrss+tYaK6AEPuD9Qh8qACBasCtCIS12yCt2yhntYC1CIytC +JChCI/vs6hgAIFow/bbbIf4CQjAuQiUottwvQiYtQiWv3f621yH+AmtwL0InLbbYKEIoLkInqO7/ +lvUh/gJzsChCJy6W9i1CKC9CJ63/+LbfIf4Ce/AtQikvtuAuQiooQimuiP2W9yH+AkIwLkIpKJb4 +L0IqLUIpr93+tuMh/gJrcChCKy225ClCLC9CK6n/+LbhIf4Ce/AtQi0vtuIuQi4pQi2umf226SH+ +Akpw+bbqKgAH0xAsUNHC0A3MAixU0Vu4OcAg0Q8a7O//AgAKAMDGkCoWIPP422ACEFAwAAAuQnr7 +FhIhfAA3oA44FC9Avf8WHCACEFAw+BYZIAAQWDBbiOsrEhlanEMpEhkqFhPTDwmqKFuITiwSEyoS +HcC4DLsM+6ooAGQQWDBanDorEhP6Fg0qACBW8PsWDiAIEFAwC6oMKxIcKhYP+6ooAGQQWDBanDAc +7L0qFhAiRiEpEhkuQhUvEiMJqSj+DQYACBBYMPkWESgAQE9w+UYiICIAN+Cv6rCqCtoBCpoM+kYi +KgAgErAuQhUqdsYpQiIODQYvUppk84MoUpxkg5QqUp5ko6UvUqHI9ChSoGSDwipSo9MP9KAKb8AQ +eDAoUqJkg8MoEhIMiDeuiLCICNgB+EYhKgBAS3AIqgz4UNEqACASsCpGIvoSDiAgEEgw+YgCAIAQ +SDD5EhAoCQBKMChU0SgSGfpCFigAIFZwCbkMCYkoCgoG+hIRKABAVnApRiD5Eg0qACASsCpGH4of +CJko+oooDoAQQDComfP7UWoAIBKwAP8CAAoBDkSQIhYg8/dWYAMQUDAtQLxk0qouQL3+FhwipAA3 +oCJCFShCFvYSHSIAAFOw8oIIDoAQcDDymQwCACBC8PgIBgH+AhCw/pkIDgAgarD5qigCAEASMP2e +KAYAIHGwIkYfBu4s/kIVKABAcjAGqiz4RiAiACBAsP4OBgIAIBOw+uoBAf4CELD6RiIuAEATsC5G +IfP6smoAIHKwAAAoQnr/AgAD+2yqICpCFSlCFgoqNvpGFSgDAEywKUYWY/a9K0J6/wIAA/vvquAs +UppkwpQtUp5k0p4pUqP/AgAB++QqYC5Sov8CAAP73qugKlai8/eyagAgSrAvYen/AgAD+9kr4Chh +6v8CAAP706ogKWHr/wIAA/vOKmBj988AACxCev8CAAP7/SsgLWHoZNImLhIgK3bGDu4PC+sLwPAv +FiNj9+soken1iGFvwBB4MC2R6mXYVi6R62XoUMePKHbGwNAtds0tds4tdsstdswZ6+Mtlhstdsco +dsUolhgolhkolhoodsgvUpr4dsoh+gA34C5SnmTh/ylSo2ScCS9SomX8AypWovP7/WoAIEqwAChS +nSpWnPP242oAIFIwx9/9RiMgABBYMCtGJGP5pMeP+EYlIAAQcDAuRiZj+bjH3/1GJyAAEFgwK0Yo +Y/nMx4/4RikgABBwMC5GKmP54Mff/UYrIAAQWDArRixj+fTH//9GLSAAEHAwLkYuY/oIAAAd663/ +AgAKAEZHUC0WIPP1M2AEEFAwAAAqVqDz9lNqACB6sChSmy9CIQiZDPlGIi4AIE/wL1aaY/hCKFKd +L0IhCJkM+UYiLgAgT/AvVpxj+DEoUp8vQiEImQz5RiIuACBP8C9WnmP4IChCIQ+ZDPlGIigAIEow +KFagY/gXKBIUCJkMKEIh+UYiKAAgSjAoVqJj+BQd7B5402YtFiDz9KVgBRBQMMff/UYfIAAQWDAr +RiAtRiErRiJj+HEoUpsvQiEImQz5RiIuACBP8C9WmmP8ZC9SnSpCIQ+ZDPlGIioAIEqwKlacY/xT +KlKfKEIhCpkM+UYiKAAgSjAoVp5j/EIAG+uiKxYg8/Q7YAAQUDAAAChCIQ+ZDPlGIigAIEowKFag +Y/woKEIhCpkM+UYiKAAgSjAoVqJj/CcpYellndIsYeplzcxj/dUALVKbKlaa8/1hagAgU3AAAC5S +nypWnvP9V2oAIFOwAAAqUpsrVprz/gBqACBasAAAK1KfKlae8/32agAgUvAAAP1CFSACEFAw/Ovg +EAgQWDBbuhnRD8Ci/OvdEAgQWDBbuhbRDwAAAABsEAwU69kT6z4e69gc65US69iF5o3niOWJ5Prg +AiAgAlhw+rQCIEACeHCZ8JjxnfOV8v7hAC//ECgw/rUAIAMQcDAf68aVwJXBlcIlxgMlxgT4MqQg +IAJQcPXGBSABEGgw9cYGIAAQSDD1xgcuAEB+MP/ZOAguAUAw+SRVKAAgUjD4gAAgQAJYcPgkVCAH +EFAw/EJKIAgQKDBtWg8vsQcrvP7/JSsqAARj0LCqx68oMqQb67D1qREIAEBaMAmIAig2pBfrAidy +hSYyggd3Uvd8Aix/EEAw+XcRBgBAQbAHZgImNoIY66Uf6wkmISstIFX8MoIgARAoMCUkkCpCTCtC +SitGSysmFysmGPomFiCAEEgw9UHlIEAQODDw0QQMAEB7MPBmGgYFAGZwJ4SA9iYZKABVq5D/65Ef +wBBwMPqqCQBgAmhw+7kJC6AEOqD6OhQJoAQ+YPk5FAB+AlKw/PACIH4CSnD81AIoAEB2cP/xACoA +QHKw/9UAIIACUrD6JhsggAJKcCkmHSgypB/qn/kcMCguAUAw//KZKAAgSjAogAAI/yjDjwj/Cw7/ +AfoiFiCAAnvwLyYfLTLJddcXHOtwKzLP/wIABgBc5tDasMTQDa0KLSYjW/jCwCDRDy5KAA6+N/4m +FyoBAHKwW6NtKiYWKUEYKiYX+kYiIgAAKrD6RiQgigA2YPrq6x3wBD5gDd0J+0EXIAYCY3AN3DsM +LBIMuwgLWwgLqjYqJhYqJhdbo1wuIhcc61T9IhYgBhBYMPXoDAIAAHqw+BYAIAQQUDBbuYAqIhZb +o1L6IhciAABKsCkmFlujT/oiFiIAAFqwKyYXBb0MLUYlBawMLEYjY/60Kqw/DqoBKjbPY/9AKkI1 +BaoJKiYWKiYXY/+SAGwQBCZaQPoKgCIAAEEw/frAIEACWLDzJgAgYAJgsPwmDCAAEEgw/CYNIh8B +JDD5JRQqAEBu8PWlOgCAAlrw+yYJIHACULD7JggoBQAZsPglFSIAAFlwW3n/A2Q5+1wAAgAAUTBb +hs+aIdEPAGwQBhPq0SgyWxXq0PIKACA1ADYgKFJ7JDKmDwIAqCgJiBGoRCpCBysqAPqiDiAAEGAw +W7KrKTJbsSIPAgD6Rg4r/+nMkBLrDvQKACAAEDAw+yDlIgAAUTBbhqb0TAEmAQBRsPlE6WACAhCw +LDJZKzJYKjJarLv7qggAABAgMPwWAiDWADagsW7+FgAgABBoMJ0TYABTLyBUKyRV+/sIAgAAUvCb +Ev0SACoAFVqQgiAKuAxtiR0oUnspMqb6iAgAAgJSsAmIEaiYJ4QMJoQNkogthDcqMlkpMlgoMlqq +mfRMASgAIEoweEtuIlJ4KjKmokIJIhGqIiYgDYsS9yAML5YANaCLEylSe6uZCZkR+CIAKAAgTrCZ +ESeUDPaUDSIAAFmw+JYIIgAAUfBbhnKNEYwTKSBUKtQ3/CRVIAICYzD8FgMjIAE6YIoSqp76JFUh +/gJbsJsSY/9M0Q8AAGwQEhTqe9MPKEGtJwqA+AhBAAAQKDAIdTn6+v8iAABZcFuGbvsKACIAADKw +9RYSL/8QUDBbhmkqFhb6KkAgABBYMFuGZioWFfr6/yEAEFgwW4ZiKhYU+vr/IQAQWDBbhl8qFhP6 ++v8hABBYMFuGWyoWEfsKAC//EFAwW4ZYmhz6+v8kABBYMFuGVSoWEPsaACJAEFAwW4ZRmh/7WoAi +QBBQMFuGTpoe+uqgE4AQWDBbhksqFg37CgAv/xBQMFuGR5ob+woAL/8QUDBbhkSaGvsKAC//EFAw +W4ZBKhYJ+vr/JwAQWDBbhj2aGPr6/ycAEFgwW4Y6mhf6+v8nABBYMFuGNyoWBvr6/yCAEFgwW4Yz +mhX6+v8hABBYMFuGMJoU+woAL/8QUDBbhi2aE/r6/yOAEFgwW4Yp1aD7CgAv/xBQMFuGJi1CLChC +N4cXI0IzixOPGS5CLSIWGClCOCJCMg/uKAuZKAczKIsUhxiPGguIKAciKA/dKIce/0IxIgAgGLAi +FhqCHP5CKywAIHdwI0IiAv8oghsHMyiHHQLuKPJCISgAIEowKBYZiB8HIignQiPzQh8iACAYsAh3 +KCgSECsSESlCHggzKCgSFPdCHCIAIDzwC5koKxITCHcoKEIdLEIa/xIWLgAge7ALiCiLFflCNSgA +IEowD8woL0I0C5koixYL/ygrQhv5EhUuACBP8Am7KClCGae7+WooAgAAOrCsrKvMqMyjzKLMrsz9 +EhosACBrMC5CO/1COSwAIGswBe4oB90o/hIZLAAgd3CVEv/MCAf/EEAw8hIYLAAgczD5gw18ACBr +MPAAB2IAABqwAMAwo8XaUFuF0dtQ9xYBIIAQYDBYGfD5rAAAgBBgMPesAABKADTgLUIZJxIS9QoA +IDcAN2D6FhciAAAasP18AAIAAFDw+/r/L/8QYDBb/t5aln0uQhmxVf5T4XIAIB2w+RIXIIAQYDAG +Vyinl2QmScAw9hYAIAAQKDAmQoClZiNmAC5CafhCGSoAB/TQDogI/wIACgBwxNAuQmr5QhoqAAd0 +0K6Z/wIACgCKTNAuQmv6QhsqAAd00K6q/wIACgCX1NAuQmz7QhwqAAf00A67CP8CAAoApNzQLkJt +/UIdKgAHdNCu3f8CAAoAsmzQLkJu/0IeKgAHdNCu//8CAAoAv/zQLkJv+EIfKgAH9NAOiAj/AgAK +AMzE0C5Cc/lCIyoAB3TQrpn/AgAKAN5M0C5CcvpCIioAB3TQrqr/AgAKAO/U0C5CcftCISoAB3TQ +rrv/AgAKAP1c0C5CcP1CICoBDnTQrt3+ChQqAQlo0C5kBGAANwAAAPp8AAIAAFjw/RISIAAQeDD/ +ZAQv/xBgMFv+jogQx7/7pgAgABBIMPlmByYAID4wWpYoLAqAsTP8VQgP/2UQ0GAFAgAAAAAAAPp8 +AAIAAFjw/QoAIAIQYDD8ZAQv/xBgMFv+fC0SFvpmByCAEGAw8//DZgAgP3AAAPp8AAIAAFjw/goD +IkAQYDD+ZAQgABBoMFv+cC8SFfpmByCAEGAw8/+TZgAgP/AAAPp8AAIAAFjw/Pr/IAQQQDD4ZAQh +ABBoMFv+ZCkSFPpmByCAEGAw8/9jZgAgPnAAAPs8AA//EGAw+goFIQAQaDD6ZAQiAABR8Fv+WCsS +E/pmByCAEGAw8/8zZgAgPvAAAPp8AAIAAFjw/AoBIQAQaDD8ZAQv/xBgMFv+TC0SEfpmByCAEGAw +8/8DZgAgP3AAAPp8AAIAAFjw/Pr/IBIQcDD+ZAQkABBoMFv+QJpniK4vEhD2hgAggBBgMPP+z2YA +ID/wAAAAAAAA/CpAIgAAWPD6ChghABBoMPpkBC+WEEgw+WQFIgAAUfBb/jCLH/pmByCAEGAw8/6U +ZgAgPvAAAAD6fAACAABY8PwKFiWAEGgw/GQEIkAQYDBb/iSNHvpmByCAEGAw8/5kZgAgP3AAAAD8 +6VsSAABR8Ps8AAAVEHAw/mQEI4AQaDBb/hiPHfpmByCAEGAw8/40ZgAgP/AuQnf4QjEqAAf00A6I +CP8CAAoAkMTQLkJ0+UIrKgAHdNCumf8CAAoAnkzQLkJ1+kIsKgAHdNCuqv8CAAoAq9TQLkJ2+0It +KgAH9NAOuwj/AgAKALjc0C5CeP1CMioAB3TQrt3/AgAKAMZs0C5Cef9CMyoAB3TQrv//AgAKANP8 +0C5CevhCNCoAB/TQDogI/wIACgDgxNAuQnv5QjUqAAd00K6Z/wIACgDuTNAuQnz6QjcqAAd00K6q +/wIACgD71NAuQn37QjgqAAf00A67CP8CAAoBCNzQLkJ+/UI7KgAHdNCu3f8CAAoBFmzQLkJ//0I5 +K/6fdNCu//8CAAv+mnjQ+nwAAgAAWPD8+v8gGhBAMPhkBCAAEGgwW/3NiRH6ZgcggBBgMPP9B2YA +ID5wAAAAAAAA+zwAD/8QYDD9CgAgCBBQMPpkBCIAAFHwW/3Aixz6ZgcggBBgMPP81GYAID7wAAAA ++nwAAgAAWPD9CgAgCRBgMPxkBC//EGAwW/20jRv6ZgcggBBgMPP8pGYAID9wAAAA+nwAAgAAWPD8 ++v8gChBwMP5kBCAAEGgwW/2ojxr6ZgcggBBgMPP8dGYAID/wAAAA+nwAAgAAWPD8+v8gCxBAMPhk +BCAAEGgwW/2ciRn6ZgcggBBgMPP8RGYAID5wAAAA+zwAD/8QYDD6CgwnABBoMPpkBCIAAFHwW/2Q +ixj6ZgcggBBgMPP8FGYAID7wAAAA+nwAAgAAWPD8Cg0nABBoMPxkBC//EGAwW/2EjRf6ZgcggBBg +MPP75GYAID9wAAAA+nwAAgAAWPD8+v8gDhBwMP5kBCcAEGgwW/14jxb6ZgcggBBgMPP7tGYAID/w +AAAA+nwAAgAAWPD8+v8gDxBAMPhkBCCAEGgwW/1siRX6ZgcggBBgMPP7hGYAID5wAAAA+zwAD/8Q +YDD6ChAhABBoMPpkBCIAAFHwW/1gixT6ZgcggBBgMPP7VGYAID7wAAAA+nwAAgAAWPD9CgAgERBg +MPxkBC//EGAwW/1UjRP6ZgcggBBgMPP7JGYAID9wAAAA+nwAAgAAWPD8+v8gGRBwMP5kBCOAEGgw +W/1IjxL6ZgcggBBgMPP69GYAID/wKEIy9yqQInAQGDD1CgAgeQA2ICZCeCJCgKZWCWYRpiKGJ4Zu +wMD7IRIgwAJRsFuwC4srmirzaggAABBgMFuwB4sumi33aggAABBgMFuwAyomEPsiESSgEFAw+moI +AAAQYDBbr/4qJhP7IFQmsBBQMPpqCAAAEGAwW6/4K0IysVX6JhQr/8fdUCxCM/UKACB5ADcgJkJ5 +IkKAplYJZhGmIoYnhm7AwPshEiDAAlGwW6/riyuaKvNqCAAAEGAwW6/niy6aLfdqCAAAEGAwW6/j +KiYQ+yIRJKAQUDD6aggAABBgMFuv3iomE/sgVCawEFAw+moIAAAQYDBbr9grQjOxVfomFCv/x91Q +LEI09QoAIHkANyAmQnoiQoCmVglmEaYihieGbsDA+yESIMACUbBbr8uLK5oq82oIAAAQYDBbr8eL +Lpot92oIAAAQYDBbr8MqJhD7IhEkoBBQMPpqCAAAEGAwW6++KiYT+yBUJrAQUDD6aggAABBgMFuv +uCtCNLFV+iYUK//H3VDAINEPAAAAbBAGGOgcFugcAiUK+FUKAIQANKD/AgAAAE4EoPpStSIoAjig +KVK0epkOW4OcIlKz0Q8AACJSs9EPLFKxBA4GA60MDN0MDt0B+Oe1HAAgazAsVrMrYkcvYhQZ5/P6 +CgIgARBwMPv/CAAAEGgw/P8MAgAAWzD5zAgOACBH8FuwER/nGy7w0SIKgALuAi700SJSs9EPAChS +taOIqEj0CQYB/gJCMPJSsygAQEowKFa00Q8AAAAA+iwAAAAQWDBbg634+sAgfgIisAhEAfpSsSIA +AFkwW7htwKFbg22UEBzn6PsKCCABEGgw/woAIgAAOrD6CgUiAABx8Fu2D8Cg0qAT52ijcyo2gSQ2 +gio2gwLkFgECANpw+TKDIAIQWDBaOuUkMojISfp8AAACEFgwWjrh3kAC5BbApfzn0hAIEFgw/zKI +IAEQaDBbtfsqYugpUrKqmSlm6ChStPhm6iAAEBAwIlaxIlayIlazIla0Ila10Q9sEAgc53QX5v3T +DyjCE/ZylSBFADYgwCDdYP5iUCAFEFAw/Oe8EDAQWDBbteYf57oc57st8msu8pj/8mchsBBIMPkW +ACAFEFAw8hYBIDAQWDBbtdzRDwAqcncocnT+cnUuUBAwMPamCA/wEFgwC2YB/wIACgBgdZD75sEQ +uAA2ICmw0SoKgPZ2dygJAFZw+bTRIgAAUbAvcnb2FgMhsBBgMPwWASACEGgw+hYAIBAQWDD7FgIg +BRBQMPzmzhAAEFgwW7XA/WwAAIEANaD23AAAbAA3YNrQ/BqwIAAQWDBbrlwa5wL2dpUhQBBYMFuS +9dsg8hYEIgAAYPD6ZlAiAABpMP5cAAIAAFGwW/OZ/QoAIAEQSDD6mjkCAAASsPesAACMADSgCp04 +Zd7tY/7/AAAAAAAAAPP/XmAAEDAw8/7tb/QQEDAAAAAAACpybS9ybPasDy/wEEAw+xqwJgBAQbCr +a3vzPylyasuZ+3ZtIgAAUvAc5q0ucmuWE/oWACGwEFgw+xYBIAAQaDD7CgAgEBBQMPoWAiAFEFAw +W7WK8/8sYgAAabDz/8lgABAwMNww/UwAAgAAcXD7EgQiAABRsFvyTB7nBMDx/eITIAAQYDDyrAAA +ARBQMPesOAIAAEiw8v04CAUAF/D95hMuQwA3IMCACag4ZY4hY/4zAAAAbBAEEub1KCIWyIPAINEP +APrmuBFBEFgwW5KrGOdCHedC+IF/IUEQWDD50j4gABB4MP4KECIAAGKw+uatGABAcjD+GgAoBQBH +8PnWPiwJAHMwW5XXW3YMwJH5JhYgABAQMNEPAGwQBPPnMRH8EFAwFOalCgw/KULfCVkUKTYcKELh +CGgUKDYdJELjBFQUJDYeEuaGIiLeAgJA8jSQIAAQEDDRDwBsEAQT5yL05yIQABAwMA8CAPIKBCIA +ACjwbSob8lJ/IAQCGPDyNeMgCAIhMCJSfwIyFCI15yZGmMAg0Q9sEAQX5xUc5t0U5xQV5xX95xUQ +ABAQMPsKECIAADEw81wIIgAASXD4TAACAABQ8NMPbbojLYaDKYZ/+YaAIFACSnAqhoH6hoIgUAJS +sPuNAiBQAkIwLLUMG+cEHOcE+W0EIAAQQDD4lh8gJAJQsFt2BBrmcCqggAAgBAoKG3+vQRzmvx3m ++PsqoCACAhCw+2YIBgAgXfD7RAgCACBc8Po8AAQAIF1w+VwAAgAAQTD/AgAAEBBYMP8CAAX/upig +wCDRDxvmihrm6iuyfSqigfzmXxoAIFyw/ebnG5AEPuD7CsgqACBasFo84WP/k2wQBBTm4ipCavLm +NBAAEEgw+EoAKnwBUDBtigoMmxD7JvsgAgJKcGSgUWmhTiNCaypCVluexluetPwKICAIEFgw9zc8 +cgAAKrAd5tEa5tL/5hAeBwEYMNMP/to5AA4AZPAPqgJ6NwUY5e4IqgJ7NxMZ5mjwAA1qCQBKsADA +INEPABrmxfw3DHAEEEgwHeYL0w8NqgL+5sIQMgB08P6qAgAiAHjwL0B90w/TD3//AgyqAn83Agmq +AguoAigm/CYKCwVmDARjECMm/RnmtQk5Aikm/iMm/ygtBCiCABvms/rmER8/EEgw/OavGABASjD5 +LQQoCQBaMPiWACA4EFgwW5U5GuYI/GwRCUAEOaD4bhEMgAQ9oPxpEA8ABD2g+f8CDAkAbPD47gIM +CQB/cPxsAgwJAHdw/cwCADkQWDBblSkqQlIY5Z/8VhAAMBAYMPUKACAhADagCGYC3GD65fISAABY +8FuVIClCUrFV+VPqcAICGPDAMPo8AAAAEFgw/AoAIAAQaDBbdZWxM2k+5yMKANowW3WIsTNpO/Uq +IsAb5oQLqgL6JsAgABAQMNEPbBAEwCDRDwBsEAYW5n7TDw8CAChiXBXmfPLmfBAAECAw++Z7EpEA +NiD7FgEgARBIMPkWAiAAEFAwmhAX5gYncnwjYqWnRwl3EQczCCcyBydyDitiWvwKACIAAFHwW63i ++2JaIAAQYDD6NhsgQAJR8Fut3fo2HCAAEFgwK3YyK3YzKWKhwaD6NAQoACBNMJkwKVCA/AofIAEQ +cDD5CEYAABA4MPkNRAwABqIgLDQhJzQkYAAKLjQk/TQhIAAQODAkNCIvUFAnNRwnNR0nNR4nNR8n +NConNCsnNGT3Nh0l7hBIMCk1GSc0NCc0LCc0Nfc0QSABEFgw9zUzIAUQQDD4NCkgARBQMPo0LS6A +AXww/zQjIgAAUTBbf737CgAiAABisPw0aSIAAFEwW3+4LjAj+jRoIBAQSDApNGr5NGsiAImDoPvn +B2AJEHgwa+Vt/+FqcA4QQDD44UhwHxBIMBrlKv8CAA4AtkuQKqDRDwIADwIAf6cLKyKALPrPDLsB +KyaA+kwAAAAQWDBbfzUtYlzyLUAgAgIhMPVcASv/UO0QYAEYGuYD+jYdIBAQeDD/NR8gwBBwMC41 +HmAAFgAa5f36Nh0gCBBIMPk1HyDAEEAwKDUeiKbaMAuAAPowIyIAAEqwKTUcW38VKzAj/TBpIgAA +YrD+MGgiAABRMFubA/oWACAAYa6gKDIdKIIJAzoCC4AA+hYAIABXrqD6PAAAARBYMFt+3voWACAA +Ti6g2jBbfcgpMRx7n2F8n27/AgAAAFp6UPpMAAACEFgwW38FY/87AACJEsidW38c+hYAIAAzrqDA +oJoSLlCIihH46B1gAhBYMPoKAiAYEFgw/OXmEgAAaTBbs/MqMh1j/0YqNh0rNR9j/z0AAAAAAPpM +AAAQEFgwW37vY/7kAAD6TAAACBBYMFt+62P+1MDAnBAd5NMt0NF73ySJENKQ0Q8AAAAAAAAA+goC +IBgQWDD85dASAABpMFuz24IQ0Q8AW31ziRDSkNEPxirRDwAAAGwQFBTlyBjlyCtC5ypC5idCGSlC +Fy5CHS9CGyyCtC1CHy0WEywWFy8WFS4WFJkVJxYWKULo+4FqKgAgWrCbE/qBbigAIFZwmhErgWz7 +FgIgABAQMPiBcCAAEDgw+BYAI70ANmD5FgQvwBAoMP/lsBAAEHAw/hYSL/8QEDD/FhggABBYMB7l +Nh/lqCjieCbyyqh4CYgRqGaDZxrkuYM+KBIXKWE+mTOYMi1CzaiYKBYX+RIFKgAFbpCdNGAABwCJ +FSxhNpw0KZw/BZkBKTYFLUCQ/RYcIGgAN2ArQhgqYG4qFg4rFg9btaD9EhwgABBgMFu03QKqAf0K +ASAAEGAw/Nw5CgUAU3D1vgEKCQBisPsKACAkADagLBIYjR/+Eg4gAhBQMP8SHCAAEFgwW7OL8AAG +b+oQWDCeNmay3Yk1KhIWiDYqrD8FqgH6NgcoACBKMP9AkSB+AkIwBYgBmBX/FhsgaQA34CtCGipg +b5ocmx1btX79EhsgABBgMFu0uwKsAf4KASAAEGgw/e05DAUAY7D1vwEMCQBrMPsKACAnADcgLBIY +jR3+EgwgAhBQMP8SGyAAEFgwW7No8AAJb+oQWDAAAACfOGayUIo3KRIVjDgpnD8FmQH5NgksACBT +MPhAkiB+AmMwBcwBLBYW+BYaIGYANiArQhwqYHCaGpsbW7Va/RIaIAAQYDBbtJcCqgH9CgEgABBg +MPzcOQoFAFNw9b0BCgkAYrD7CgAgJAA2oCwSGI0b/hIKIAIQUDD/EhogABBYMFuzRfAABm/qEFgw +nTpmscWJOS4SFIg6DwIALuw/Be4B/jYLKAAgSjD/QJMgfgJCMAWIASgWFf8WGSBoADfgK0IeKmBx +KhYIKxYJW7U2/RIZIAAQYDBbtHMCrwH5CgEgABBAMPiYOQ4FAH5w9bkBDgkAR/D7CgAgJAA34CwS +GI0Z/hIIIAIQUDD/EhkgABBYMFuzIfAABm/qEFgwmTxmsTWOOyoSE408/xICIH4CUrD5Mg4qAEAq +sPo2DSwAIHdw/ECTIH4Ca3D6Fh0sAEAvcC0WFP0SACCBADcgLECUK0IgKmBymhabFywWEFu1Dv0S +ECAAEGAwW7RL9bgBDABAFrD/CgEgABBwMP7+OQwFAG/w+hIdLAkAd3D7CgAgKwA3YCwSGI0X/hIG +IAIQUDD/EhAgABBYMFuy94o9jz4vFhHwAAlv6hBYMCgWEZg+jRCOEY8SjBNgAAaOEYwTKRYRKWE6 +LDUiKGEyLzUkKTYQKDUj+BISLAAgYjCYP5wT+WEzKAAgQnApNSUoFhIuNSYoYTQoNSctNSj5YTUu +ACB+cPgSES4AIHIw/xYCIAICOfD5NSksACBucPkSBCgAIEKw/hYBIH4CQjD9FgAoAEAqMPgWEy/+ +N8nQ0rDRD9EPAGwQBBrkTdMPJqJYFeTB9AoAIDIANaAY5L/35L8QABBIMG0IHCJwgABABAICG38n +CwVGCyhmQClmQSaiWLFEdksCY//cKKJZ9AoAIF4ANiAb5DttCFAvsnkuoqavTwn/Ea/uLOETL+Bi +hu8j4FYi4FeO7PszEQAQAmkw9mYRAlAEOKD2IgIOCQAf8PXdCw4JABfwL9ZAAO4RDswCLNZBKaJZ +sUR5SwJj/6jRDwBsEAYY5CMugjL0CgAgIgC3oGAAnQAAAB7kli7iQrFE/wIAAgAgH3D/AgAKAEPx +EBPkGBLkjyMyeCIikKNDCTMRoyIlIQcjIRMqIAz7IA0kbAEsMFt/+RrkhykhByghEgqZAfOZAgAA +EGgw+SUHL6kANiAFVRFtCDUsIA0vIAwY5BzAkCmG+/PeCAACAmtw+yESL5AEP+D47goOCQB9cP7t +BCwJAHsw/OYAK/+221Bj/8MAwNQN7Tb3CgAgxAA3YB7kEy4WAhnj8o8SGORpKZJ4KIKQ//C1KAAg +TfAJmRH5iAgAABAgMPgWASCDADfgihGxQvqgDCIAAFiwW7FokhAmoQfzoRMiAAAqsCtQDfqgDCZs +ATAwW3/IGuRXKVEHKFESCpkB85kCAAAQEDD5VQcgIQA2INtg8yoIAgAAcTD8CgEiAABp8FvxTStR +ErEieyPijRKMEC3QtaMj/cOQcgAAIzAd5EMt0kLA5A7dNo4S93wBIAICc7D+FgIr/6Vt0C96//3j +TBoAE5/QG+PZ89kMA4AQYDD7OAoAABBQMG2ZDCq2+/mNBCAIAkIwnJAZ5DApkc3Ag3mAZRjjthTk +LSmCeIiKI0KQ9UIYKAAgSjD0QhkpkAQ6IKgzIjEHpUT6MAwkAwBpMPswDSJsARAwW3+SHOPA9UgM +D1AEOKDTD/xZCgAAEFgwbYoVKDAMK8b7+p0EIAgCSnAJiBEI6AKYoNEPbBAGG+OzJAoC9Lb7IAgQ +SDD0CgAiAABC8G2aCfmNBCAIAkIwlJDAkRjjqvm2+yQAEEgwDwIADwIAbZoJ+Y0EIAgCQjCUkARK +AlvyChPjQBXi9fahpmIAABKwW/HP9qGbYgAAErArUjYsGvQMuygrNpAa4/kqNo8kNotbf0dmIXtb +9+b2oXViAAASsPrjQhAnEFgwW482HuPxCi9A/+R+LAMBVDD95H8kAQFQMPTkfSgAAVAw+OR8IAQQ +IDBb9Kn2oTliAAASsPrjMxFBEFgwW48nF+PjCotA0w8rdLgS4zUpMtP8IX0gAKQuYP8CAAIAl/cQ +LSF+9uN7EA8At2AuIX/M5C8hgGTx2hTjD/sKAiAAEGAw/goBIgAQaDD649IQAhBAMPhGEyAAEHgw +WpSm9qDJYgAAErDAkSlGEygywih2Ri8y2J9gLjLZLmYBLTLbLWYCLDLwLGYDKzLs+2YEIABOLKAp +Yv8a4xAImREropALC0cLmQIpppBb82P2oHxiAAASsFvyaPagcWIAABKwW/II9qBmYgAAErAb43Eq +chHTDwuqCBvi0Cq2q1vx4BPjS/gKgCAAEBAw/Pr0IAMQIDAtMjpu0zYrMjnLsPoKACABEGAw/QoA +IAAQSDD5FgEgABBwMPkWAiABEEAw+BYAIAAQeDBalh4kNjnLLtEPsIj6jAEgARBoMPraOQACAlow ++8I4D60AtqBj/94AAAAa4t37GkAjJxBgMFuSCmP+wy5Q0QTuAi5U0WP+rwAY4ugb4ub8+v8gVBBQ +MPmCfyAIAkIwDwIA0w/TD22qDPmCfyoAIFpwLKaAtIgqUNH7nQgCAABy8NMP/NaAIKQA/rAY43rT +Dw8CACmCf/qCgCBNEFgwbboS+YKBKgAgdnD6toAgEAJCMCqCgC9Q0K6Y+oaAIjgBO+Aa4qcsonYr +CgILzAIspnYpon4LmQIppn5bfrce4pMt4oLA8Q/dAi3mgtEPAAAAAADz/lRgABAQMGwQBB3i39MP +0w8s0lnTDw8CAGTAQfjM/yIAAFsw+MoBDgAPxxBtCA/5rP8iAABasPmqAQ4ABM7QY//pAAAPuxEe +41AvzB8PXxQr5Hz/5H0gABBQMCrkfvjSpiCAEFAwCAA/W5sKCgE/0Q8AAGwQDBbjRY8gFeLE8+K8 +EgAASPCZFS1SeShSgCxSei5SeCtSf/LwDCIAADiwkhcv8A2fGBLik/m7EQ+QBDug/o4IDZAEOyD+ +FgktkAQ/YP5iNiwAIG4w/RYKLAAgYjD8FgsoACBaMPgWDCBYADegKgoAW360AqkIKJKAZ4ALbQgF +KpKAZ6ACY//zG+KcL2I2HOKa+goCIAAQaDD//fAgARBwMFurACNWZC5iNhjjHCNWZint8PlWZSgA +IEOwKFZnKFZoK2JpyrP6CgEiACAfsFt+naKpLJKAZ8ALbQgFK5KAZ7ACY//zLmI2ZOO/W367LVIh +LlIiL1IgIlIjI1IfJFIeKFIdKVIcK1IaLFIZKlIbLFZq/FIrKgAgZvArVmv7UiwqACBasCpWbPpS +LSgAIFZwKVZt+VIxKAAgSjAoVm74UjIkACBBMCRWb/RSMyIAICTwI1Zz81I0IgAgGLAiVnDyUjUu +ACAX8C9Wcv9SNy4AIHuwLlZx/lI4LAAgd3AtVnT9UjssACBrMPxWdSoAIGbw+1Z2KgAgWrD6Vncg +ABBgMPxWaSgAIFZw+VZ4KAAgSjD4VnkkACBBMPRWeiIAICTw81Z7IgAgGLDyVnwuACAX8P9WfS4A +IHuw/lZ+LAAgd3AtVn9bqqvToFuqqtKgW6qpGeJX+/qAIAAQaDD/4bQQgBBAMPcWBCoABhJQ9xYE +IAIQaDD5pxEKAEiSUClSaC5SZtMPB5IMCyIB/wIACgEndJAqUmVkokMr8NHyVmgqCQBG8Pv00SIA +AEiwHOG+L1Jn+RYAIAUQUDD3FgEggBBoMP0WAiAAEFgw8hYDIAIQaDBbsKhlIIwf4nco8rUk+oD/ +8rQg/gISMAQiAaJ+/wIACgDt99AZ4m8pkrJkkc0Z4m3wADNgABBoMBriag3ZCgqZCiiStf+StCD+ +AhIwCyIBon7/AgAKANd30CuSsmSxo/8CAAIA4YNg/pa1IgAAQ7Ac4aYukrP3FgEggBAgMCQWAvIW +AyAFEFAw+BYAIAAQWDBbsITyVoAh5AA0oCdSfyRSeilSeChSeS1SMvmZEQWQBDkg+YgRB5AEPeD3 +JwgNkAQ/YP1KFAgAIECw+BYGJAAgILD4EgkoACBMsNMPbakFAAiGAElhihkNaxRbffQtUjOJFvgS +Ci2QBD9gDUoUbakFAAiGAElhihoNaxRbfestUjT4EgstkAQ/YA1KFG2pBQAIhgBEYSoSCw1rFFt9 +4y1SOfgSDC2QBD9gDUoUbakFAAiGAEdhKhIMDWsUW33bwKH7CgAgABBgMFv6BS9RrcDjf+APwpDw +ABJgAhBAMAAAAAAAAPkKACAGEEAwLWLIyNaomgraKFt94dowW/dLW/bzLmI2yOwOPBT74kUQAhBQ +MFv58yhiaciEK2I2ZLBmG+Fs/OFpEAAQUDBb+e36CgAgABBYMFt9xxviOxziO/0KACIAAHqw/goB +IAEQUDBbqhWKF4sYW68zjRSMFZrQ88YAIAAQEDDRDwAAAAD54foQABBoMPP+aGAAEBAw8/3LYAAQ +EDAAABviJvg8FAACEFAwW/nTY/+HGOENL4DRKgqACv8CL4TRL5K0Y/4rL2JpwKL84ZESAABY8P7/ +CAAAEGgw//3wIAEQcDBbqfYoYmkjVmQjVmYpjfD5VmUoACBA8CiN8ChWZyhWaGP7/8ck0Q8AAAAA +bBAG2iD7HAAAPRBgMFuPYxjiCokQIoJ/CpI78oZ/IgAAErDRDwAAAGwQBtog+xwAAD0QYDBbj1kY +4gGJECKCfwqSO/KGfyIAABKw0Q8AAABsEAbaIPscAAA9EGAwW49P+eH4EAAMrqAESAryEgAoACBK +MPKE6CIAABKw0Q/SoNEPAAAAbBAG2iD7HAAAPRBgMFuPQvnh6xAADK6gBEgK8hIAKAAgSjDyhOci +AAASsNEP0qDRDwAAAGwQBtog+xwAAD0QYDBbjzX54d4QAAyuoARICvISACgAIEow8oTmIgAAErDR +D9Kg0Q8AAABsEAbaIPscAAA9EGAwW48o+eHREAAMrqAESAryEgAoACBKMPKE5SIAABKw0Q/SoNEP +AAAAbBAG2iD7HAAAPRBgMFuPG/nhxRAADK6gBEgK8hIAKAAgSjDyhOgiAAASsNEP0qDRDwAAAGwQ +Ch/hvIv0iPby8gciAABQsIn1jPON8o7xnhGdEpwTmRWSF5gWKxYE//IAIgAAGTD/FgAgPRBYMFuQ +EPasAABGADagKKAAwJD74KYQrwA2IAmUAvMWCCBAAjhw0xCFMA8CAA8CAAVaAluQFvtcAAIAABKw ++mwAAgAAYLBbrD3Ip7gzdznXxirRD6YsK8AAwtz9sQpyAABTMGW/5GAAAbHK+TIBL+EANqAuoADW +oPXvqmQJACJwG+CLihgvCv//QVJ6ACBasPng8BCAEGAw/KwIAAEQWDD0xMwgGgB9MC2RfwvdAi2V +f35HIy6Rf8D0D+4C/pV/IAAQEDDRDykKgKm4+EgIAAAQEDAihMzRD8Ag0Q8AACwKgPysCAAAEFgw ++8TMIAAQEDDRDwAAAGwQBtog+xwAAD0QYDBbjsMY4W+JECKCfwqSO/KGfyIAABKw0Q8AAABsEAba +IPscAAA9EGAwW465GOFmiRAign8Kkjvyhn8iAAASsNEPAAAAbBAG2iD7HAAAPRBgMFuOrxjhXYkQ +IoJ/CpI78oZ/IgAAErDRDwAAAGwQBtog+xwAAD0QYDBbjqUY4VSJECKCfwqSO/KGfyIAABKw0Q8A +AABsEAbaIPscAAA9EGAwW46bGOFLiRAign8Kkjvyhn8iAAASsNEPAAAAbBAG2iD7HAAAPRBgMFuO +kRjhAokQIoJ/CpI78oZ/IgAAErDRDwAAAGwQBtog+xwAAD0QYDBbjocY4TiJECKCfwqSO/KGfyIA +ABKw0Q8AAABsEAbaIPscAAA9EGAwW459GOEviRAign8Kkjvyhn8iAAASsNEPAAAAbBAG2iD7HAAA +PRBgMFuOcxjhJokQIoJ/CpI78oZ/IgAAErDRDwAAAGwQBtog+xwAAD0QYDBbjmkY4R2JECKCfwqS +O/KGfyIAABKw0Q8AAABsEAbaIPscAAA9EGAwW45f+OETEAALLqCJECKCgAkiKPKGfiIAABKw0Q/S +oNEPAABsEAbaIPscAAA9EGAwW45TGOEIiRAign8Kkjvyhn8iAAASsNEPAAAAbBAG2iD7HAAAPRBg +MFuOSRjf8IkQIoJ/CpI78oZ/IgAAErDRDwAAAGwQBtog+xwAAD0QYDBbjj/2oB9iAAASsPo8AAIA +AFkw/QpyIgAAYXD/EgAgARBwMFgYmdEPAAAAbBAG2iD7HAAAPRBgMFuOMfagH2IAABKw+jwAAgAA +WTD9CnEiAABhcP8SACABEHAwWBiL0Q8AAABsEAbaIPscAAA9EGAwW44j9qAfYgAAErD6PAACAABZ +MP0KcCIAAGFw/xIAIAEQcDBYGH3RDwAAAGwQBtog+xwAAD0QYDBbjhX2oB9iAAASsPo8AAIAAFkw +/QpvIgAAYXD/EgAgARBwMFgYb9EPAAAAbBAG2iD7HAAAPRBgMFuOB/agH2IAABKw+jwAAgAAWTD9 +Cm4iAABhcP8SACABEHAwWBhh0Q8AAABsEAbaIPscAAA9EGAwW4359qAfYgAAErD6PAACAABZMP0K +dCIAAGFw/xIAIAIQcDBYGFPRDwAAAGwQFhvgpPwKgCIAAFBwW6cj+iwAAD0QWDBbjvXyrAAByQA2 +oCigACMWIiUWIfQWICCHADYg9QosIAAQSDD5FiMg/gIgcPAAW2ACAiEwuGb/AgAGAMslkCdiAAd6 +AluO9vt8AAIAABqw+iwAAgAAYPBbqx1lr9aiNy1wAPXRMXIAAHHwZd/G+WIBIV8AN6AqEiMo4AD6 +mgICAAATsPoWIyAdADYg8/+vYgAAMHAAAAAA8//SYAICcfDAsCsWIyoSIiwSIfsSICBeEGgw/xIj +IAIQcDBYGB0sEiP539oQAhBwMA8CAP/HDXABEGgwL5GrDv8CL5WrKBIj/YcNcAgQEDAqkasCqgIq +lasrEiP8tw1wEBBgMC+Rqwz/Ai+VqygSI9MP0w97hwgqkawNqgIqlawrEiP6tw1wIBAYMC+RrQ3/ +Ai+VrSgSI3mHCCqRrQ6qAiqVrSgSICsSI4+aKgpgCroBCo85/5YKIBoAYvArka4NuwIrla4tEiN3 +1wgvka4O/wIvla4oEiN2hwgqka4MqgIqla4rEiN1twgtka4D3QItla4uEiN05wovka/AhQj/Ai+V +ryoSI3OnCiuRr8DWDbsCK5WvLhIjcucIL5GvAv8CL5WvKBIjcYcTKpGvDKoC+pWvIAAQEDDRD8Yq +0Q/AINEPAAAAbBAI2iD7HAAAPRBgMFuNbvaghWIAABKwHN9gwND8wIAgIAJYcPoKASAEEEAwbYoP +fKAJsd36tgAgCAJa8A+qEfoKASBVADdgJhwQ/hIAIAAQeDD7CgAgBBBAMNMPbYojeuAYesAK8AAS +bgkAfrAAAAANuS4GmQqJkA+fAvu8ASvwBDqg2jD7TAACAABhcP4KASBhEGgwWBev0Q8AbBAG2iD7 +HAAAPRBgMFuNR/agH2IAABKw+jwAAgAAWTD9CmwiAABhcP8SACACEHAwWBeh0Q8AAABsEAbaIPsc +AAA9EGAwW4059qAfYgAAErD6PAACAABZMP0KaiIAAGFw/xIAIAIQcDBYF5PRDwAAAGwQBtog+xwA +AD0QYDBbjSv2oB9iAAASsPo8AAIAAFkw/QpoIgAAYXD/EgAgAhBwMFgXhdEPAAAAbBAG2iD7HAAA +PRBgMFuNHfagH2IAABKw+jwAAgAAWTD9CmYiAABhcP8SACACEHAwWBd30Q8AAABsEAbaIPscAAA9 +EGAwW40P9qAfYgAAErD6PAACAABZMP0KZCIAAGFw/xIAIAIQcDBYF2nRDwAAAGwQBtog+xwAAD0Q +YDBbjQH2oB9iAAASsPo8AAIAAFkw/Qp8IgAAYXD/EgAgAhBwMFgXW9EPAAAAbBAG2iD7HAAAPRBg +MFuM8/agH2IAABKw+jwAAgAAWTD9CmAiAABhcP8SACABEHAwWBdN0Q8AAABsEAbaIPscAAA9EGAw +W4zl9qAfYgAAErD6PAACAABZMPxcAABYEGgw/xIAIAIQcDBYFz/RDwAAAGwQBtog+xwAAD0QYDBb +jNf2oB9iAAASsPo8AAIAAFkw/FwAAFQQaDD/EgAgARBwMFgXMdEPAAAAbBAG2iD7HAAAPRBgMFuM +yfagH2IAABKw+jwAAgAAWTD8XAAARBBoMP8SACAEEHAwWBcj0Q8AAABsEAbaIPscAAA9EGAwW4y7 +9qAfYgAAErD6PAACAABZMPxcAAA4EGgw/xIAIAQQcDBYFxXRDwAAAGwQBtog+xwAAD0QYDBbjK32 +oB9iAAASsPo8AAIAAFkw/FwAACQQaDD/EgAgAhBwMFgXB9EPAAAAbBAG2iD7HAAAPRBgMFuMn/ag +H2IAABKw+jwAAgAAWTD8XAAAIRBoMP8SACABEHAwWBb50Q8AAABsEAbaIPscAAA9EGAwW4yR9qAf +YgAAErD6PAACAABZMPxcAAAgEGgw/xIAIAEQcDBYFuvRDwAAAGwQBtog+xwAAD0QYDBbjIP2oB9i +AAASsPo8AAIAAFkw/Qp+IgAAYXD/EgAgARBwMFgW3Rne/yiQfcChCogCKJR90Q8AbBAGaTEFbkQG +ZEADxirRD9og+xwAAD0QYDBbjG/43yUQABIuoPhICACAEFgw+RIAKAAgWjAigM0JIjbyhM0iAAAS +sNEP0qDRDwAAAGwQBtog+xwAAD0QYDBbjF8Y3xeJECKAfwqSO/KEfyIAABKw0Q8AAABsEAYCKgL7 +HAAAPRBgMFuMVWageR3d44sQL9DRLdI2+N53FAAQSDD/D0AAARBwMPvdKA4FAH+wD5g5+NMlcAAQ +WDD4CgogDBBgMA+MOW0ID7HMAMEEAOka+dMHcAICWvBj/+kd3g0v0qzAh/Ld4RgDAELwAIEEAOwa +8v8BDQAEOyAPzAL81qwiAAASsNEP0qDRDwAAbBAG2iD7HAAAPRBgMFuMMPndvxAAFS6gixApkjYY +3fgLmSgigrwb3i/5SRQCAEBYsAkiAvKGvCIAABKw0Q/SoNEPAABsEAYY3tvTDw8CACmAAikUAiiB +ACgVABPd6SMykAODQW8zRNog/Ao9IAgCWHBbjBf83doQACYuoCvC8Y0RoT7+4AAj6BB4MA/dKA7d +LPsLRw2ABD9gDbsC+8bxIgAAErDRDwAAAAAAAPoKAiABEFgw/N7BEgAAaPBbrKXHK9EPANKg0Q8A +AAAAbBAMHN67x98tFgQrwgEowgMpwgIpFgIoFgMrFgH8wgAiAABQsPwWACBbEFgwW40C8qwAAWYA +NqAqoAAuCmB662QvCnp6817TEPcKOiAgAihwhDDaQFuNCvtMAAIAADKw+iwAAgAAYbBbqTHKo7gz +dTne8goAIAAQGDD5CgEgABBQMPKaOAAAEEAwCpg4zYdgAQeibCvAAPrMAAYBAr7QZb/KYAH8AMAw +/AoAIF0QaDD0CgAiAABwsPscICIAAFCw/woLIgAAKvDTD236HSqgAH2hH/SgN2ACAmMw+rQAKgAg +EzD+rAAAAgJa8PwKCyAWAnCw+hwgIAICE7D1yAgAYAJYcPSEACAAEGAwW4u++iwAAD0QWDBbjMjy +rAAAfQA2oCugAP0KLyAiADbg3KBtCA19sQ0rwAH0sA9gAgJjMGP/65QUYABYAAAAiRRkkFDAwPoK +CyBAAkhwbaoVKiAA9KARYAICELAqlAD8zAEgAgJKcMDLpcv8CgAgQAJQcPS0ACBoAlhwW4ufCv5Q +/QoBIAAQYDAO3DhlwLXGKtEPAAD6HCAgABBgMP4sAAALEHgw0w9t+hgr4AB9sRr0sKFgAgJjMCuk +APLOCAACAlKw/AoLIBYCcLD6HCAgAgITsPXICABoAlhw9IQAIAAQYDBbi4X69lAAAGWuoMDA+goL +IEACSHDTD22qFSogAPSgEWACAhCwKpQA/MwBIAICSnDAy6XL/AoAIEACUHD0tAAgIAJYcFuLdPsK +ASAAEGAwBrw49M9WaB8BVDDA0Am9OGTfSck0aDtWweF+MTXAINEPAADz/41v6hBQMBjdY4IcqCIo +IoCJFP8SDS//EFAwCpkDCYgBCP8C/yaAIAAQEDDRDwAa3UaLHIwUjR1bi1HAINEPscqDMfP90mIA +ABKwGt1BixyMFI0dW4tKwCDRDwAAAAD6CgEgABBIMAapOGWfgWP+yAAAAGwQBtog+xwAAD0QYDBb +i0j2oBhiAAASsCgSABveAQgJR/i0fiQSAL5gaJMB0Q/GKtEPAABsEAbaIPscAAA9EGAwW4s7GN34 +iRAign8Kkjvyhn8iAAASsNEPAAAAbBAG2iD7HAAAPRBgMFuLMRjd74kQIoCACpI78oSAIgAAErDR +DwAAAGwQBtog+xwAAD0QYDBbiyf2oBRiAAASsIkQG93gCQhH+bR/IgwAviDRD8Yq0Q8AAGwQBtog ++xwAAD0QYDBbixsY3dqJECKCfwqSO/KGfyIAABKw0Q8AAABsEAbaIPscAAA9EGAwW4sRGN3NiRAi +gH0KkjvyhH0iAAASsNEPAAAAbBAI+iwAAD0QWDBbjBXzrAABPgA2oPfc0hAAECAw9t1JECwQKDD7 +CgAgABBgMPwWBSIAAFDw8ABCYAsQSDAAABndQQQfFAf/Ci3yrvo8AA//EHAw/pgDAAICITD4EgUs +AEBHcPsKACwJAG7w/fauJgBwESD5Cgsg2AC2IN4QbZodLaAA9dEfcgAAevD00LhgAgJa8C3kAPO6 +CAACAnOw/woLIBYCUPArHBDx/ggAABBgMPOsASAAEGgw/eQAIgAAUHBbitrSoPcgWGIAAFDw2RD/ +CgAgCxBAMG2KFC2gAMnW/ZQAIAICe/D6rAEgAgJKcP8KCyAWAlDwKxwQ8f0IAAAQYDDzrAEgABBI +MPnUACIAAFBwW4rF9qA1YgAAErDA4Z4VGt0BjhQqon8OqygsOugMuyx7Yxr53MIT/4L9EPP/AGsA +BD7gAPP/e2/qEBAw0Q8f3Xb83XYQARBYMAr/LP1MAAAEEFAwW6tRG9z2Y//FAAAAbBAOG91v+hwA +AEgQYDBbo+L6LAAAPRBYMFuLtPKsAAB8ADagKKAA0w9kgG/3CgAgkAIwcPAADWIAABhwAAAAALgz +djFWhDDaQFuLuvtMAAIAACqw+iwAAgAAYXBbp+Flr92iXCrAAMLc/aE3cgAAWzBlr8v5MgEgJAA2 +4C6wANKw9e+vZgkAPnAvGgx/cAwS3U33Jn8gABAQMNEPxirRDwAAAADz/8xgAgJbMGwQBPosAAA9 +EFgwW4uN8qwAABsANqAT3UHaMFuLm9yg+zwAAgAAULBbp8PIosYq0Q8Y3Tsa3Twign8Z3NUKIgEJ +IgLyhn8gABAQMNEPAAAAbBAWG901/Ap4IgAAUHBbo6P6LAAAPRBYMFuLdfSsAACAADagKKAADwIA +DwIAZICp+QoAIPACMHD5FiAgLBA4MPAADWIAABBwAAAAALgidiFOgyDaMFuLePs8AAIAACqw+kwA +AgAAYXBbp59lr92kXCrAAPehWXIAAFswZa/N+SIBIB4ANuAsEiAqsAD8nAICAAAi8PwWIC+oALag +YAA/AMYqZiAyGt0NLqF+fewJLaV/0Q8AAAAAAP6hfyABEFgw/N0IEAQQUDBbqt3GKtEPAPP/qmAC +Alsw0Q/A8C8WIC0SIPP/vGAAEBAwAABsEBYb3Pr8CngiAABQcFujaPosAAA9EFgwW4s69KwAAHwA +NqAooADTD2SAf/kKACDwAjBw+RYgICwQODDwAA1iAAAQcAAAAAC4InYhToMg2jBbiz77PAACAAAq +sPpMAAIAAGFwW6dlZa/dpF0q0AD3oTFyAABbcGWvzfkiASAeADbgLBIgKrAA/JwCAgAAIvD8FiAv +qAC2oGAAFQDGKtEPAAAAAPP/0mACAltwwNAtFiAe3M8a2/L8EiAgABAQMPzlfiFAEFgwW4sd0Q9s +EATAINEPAGwQBi0gAPs8AAIAAGEw+lwAAD0QeDD/0SlwABAwMMU7c9Ef3iBtCBX00EhgAgIxsC3g +Af/RDHACAnOwc9EEY//jAAAX3LibEvwWASAAEBgw+hYAICACIfAlcn/bIPxsAAIAAFFwW6cwyKy4 +d/R56HAQAhjwxirRD9pQW4r/dqnpGtteGNypqjp4oeiLEiitFCiCMYwR/RIAIgAAULALgADSoNEP +bBAG3ED6IAAiAABpcPIWAyAAEDAw/jwAAD0QeDD/oS5yAAAYsMUrcqEk2zAPAgDTD20IFfSgSGAC +AjGwKrAB/6EMcAICWvByoQRj/94AABfcjp4S/BYBIAAQEDD9FgAgYAIp8CRyf9sw/GwAAgAAUTBb +pwTIrLh39XnocBACELDGKtEP2kBbitN2qeka2zIY3H+qKnih6IsSKK0UKIIljBH9EgAiAABQ8AuA +ANKg0Q9sEAbcQPogACIAAGlw/wo9IgAAcPDyFgMiAAAYsP+hLHAAEBAwxUt0oSLbMA8CANMPbQgV +9KCNYAICELAqsAH/oQpwAgJa8HShAmP/3hXcZZ0SnBGeEBbcYvAAD2AAEDgwALhm9WFdcBACOfAk +Yn/bMPwsAAIAAFEwW6bWZa/i2kBbiqhyqdoa2wcY3FeqenihMosQabEUjBEtOv99yQwe3FMv4oAu +4n+v7p4RixAorRMoghmMEf0SAiIAAFDwC4AA0qDRD8Yq0Q8AAABsEAbcQPogACIAAGlw/wo9IgAA +cPDyFgMiAAAYsP+hKXAAEBAwxUt0oR8DOwJtCBX0oERgAgIQsCqwAf+hC3ACAlrwdKEDY//jABXc +N54SFtw1nBH9FgAgABA4MCRif9sw/CwAAgAAUTBbpqfIrLhm9WnocBACOfDGKtEP2kBbinZyqeka +2tUY3Cmqenih6IsSKK0SKII1jBH9EgAiAABQ8AuAANKg0Q9sEAQa2tsZ3CAsokr6okwgzBBoMA0t +KPTaxhA0EFgw8so4CAAgbnD5kOUodwFQMAuIHPPcHxQAIEEw9EIAIMoANmD/AgAAAGEGYP8CAAIA +XQJg/wIAAgBZBmD/AgAEAFUCYBPcCgrZQciZaJEKaZINYAAHAAADMxQDQxQDUxQDCklbku8KDF/7 +3AISAABQsFqMnBvbTgPaFNMPC6oCW5LoCgxf+9v8EgAAULBajJUDqkJbkuMKDF/72/gSAABQsFqM +kPvbAhvwBDkgW5Oo3KD72/MSAABQsFqMihvb8fosAAAKEGAwWoyGG9vv+iwAAAoQYDBajIMb2+z8 +2+wSAABQsFqMf8Ag0Q9j/1kAbBAIF9qYHtvoL3JKJ3JMLuIA8vc4ACACaHD3FgYmPQE8MP7WACwA +IG3wLdAAG9vfHNvg+N0RAgAAULBaiqgU290T2931294QABAwMPosAAIAAFkwWoqDCuhB+ilBAhoA +uiBvkgVvogJusgHAYfosAAIAAFjwWop7JE0C8z0CIZoIKTD6TkIMQAFQMPrPQgxIAVQw/903DAEA +czANzDf728gcACBhsPzMAyIAAFCwWoxR+9vEEgAAULD8CgcgARBoMFqKhvvadRIAAFCw/AoHIAEQ +aDD4HBQgChBwMPgWACABEHgwWopkyaHAovzbtxAIEFgwW6luxyvRDwAA+9uyEgAAULD8CgcgAhBo +MFqKc/vaYhIAAFCw/AoHIAMQaDD5HBQgChBwMPkWACABEHgwWopSyK/AovzbpRAIEFgwW6lbxyvR +D4sW+tuiEMwQYDD8LCgAABB4MP4KgC3ABD3g/KoIDOABbDD+qQgKOwFcMP2UziAZADbg+LEtYAEQ +YDBosi5oszYskM1gAAsAL5TO/JDNIgAAa/Cuq/uwzCIAAFCwW5LU0qDRDyyUzCyUzWP/5S+UzCyU +zWP/3AAAL5TML5TN8//RYgAAY/AAAGwQCPvbgRIAAFCw/AoBIAEQaDBaij/7230SAABQsPwKASAA +EGgw/gpkICACQHD4FgAgFBB4MFqKHcmjwKL823QQCBBYMFupJscr0Q8AAAAA+9tuEgAAULD8CgEg +ABBoMFqKK/vbahIAAFCw/AoBIAEQaDD+CmQgIAJIcPkWACAUEHgwWooKyabAovzbYhAIEFgwW6kT +xyvRDwAAAAAAAAD8218SAABQsP3aZxAgAlhw+xYAIMgQcDD721gQChB4MFqJ+sivwKL821YQCBBY +MFupBMcr0Q/AINEPAABsEFrTIPvbOxIAAFCw/QoAIgAQYDBaigce20wf2zwc20wd20oa203720sQ +BRBAMCgWkisWjSoWnS0WmywWnC8Wmf4WmiBAAnhw/xaeIIACcHD+Fp8gwAJgcPwWoCD+Akhw/R0B +IGICSnApFqEa2z0b2zsrFo8qFo79FqIgABBIMPkWmCCgAmtwLRaQYAEnAHiiAdLgwKX82zMQCBBY +MP1MAAIAAHCwW6jX3UD6CgUgCBBYMPzbLRAMAhCw/iwAAgAAeLBbqNAkEo36PAACAABZMFqJuvIF +RgAIEFgw+gJHBYAEPWD82yISCQAosPoKBSIAAGiwW6jD3CD6PAACAABZMFqLkiISmCUSjiYSj/cS +kCIAAFDw+xKdIAAQYDBai4sqEqIpEqEsEp4uEp8vEqAtEpwrEpsoEp0kTQImbQIlXQL1Fo4gAgIQ +sCIWmPYWjyAgAjnwJxaQJBaNKI0CK70C/d0CICACe/D/FqAgCAJzsC4Wn/0WnCAIAmMwLBaeKxab ++BadICACSnD5FqEgIAJSsCoWoikSmSoSmigSkimdAiqtAvoWmiH+AkIwKBaS+RaZIm4ANiD7Epki +AABQ8FqJfyQSjiUSjyYSkCcSoiwSnisdAS0SoC4SoS4WqP0WpyD+Alrw+sYAIEICYvD8FqUgYgJa +8PsWpiAAEBAw+jwAAgAAWXBaiW0qFqT7TAACAABQ8FqJai0SpCgSpy4SqA2fRv+GACzBAWww/eYA +KAEAa/D9+TYOyQFQMP52ACrBAVAw+us3DAMAU7D8EqYoAwBmcPsSpSgBAFowmmCYwJmwHNrEmROY +FC0WAP4WASAIEFgw+hYCIgAAcLD9EpggBRBQMFuoYPRMCCAQAilw+RKoIAgCMbD4EqcgCAI58P8S +piACAhCw/hKlIAgCSnD5FqggCAJCMPgWpyAIAnvw/xamIAgCc7D+FqUl/5oYoPsSmiIAAFDwWok5 +0qD7EpsiAABQ8FqJNvsSnCbIARAw9hZwJMABFDD1FnEkyAFQMPQWciLAAVAw8hZzIgAAUPBaiSv9 +bAACAABxcP9MAAAEEDgw8hYAIAgQWDD82pMSyAFQMPIWASAFEFAwW6gzKhKYIxaM0w/6rPwgAhBw +MArnOPYK/yAAYaXgIhaL9B0BIP8QMDDzHQEg/gIhMPM8fyBCAiEw9HQKAEICKPD0FqkgABA4MPQ8 +MSCCAhjwj0CNUI4w8hKLLAAgf3ANHRT+2AwABRBQMPgiCAIAAHiw/NpzEsABEDDyFgAgCBBYMFuo +EigSqfYmNAYAgDyw8zwEIAgCKXD4WbVwCAIhMCMSjPkSnyQAIDHw9BQUD/oQEDD0TPogGhBAMPSW +ACqAASAw/qzgK/5IlqDyCgUn/kcKoPP8hmIAABKwAADz/8JgABA4MAAAAADaMCoWjAERAlgBG2ak +FSoSjBvaUhzaU1qKxSoSjBvaO/wKASABEGgwWoj6KhKMG9o4+B0BIAEQYDD4jH8gABBoMP4KZCCi +AkIw+BYAIBQQeDBaiNdlo9AqEowb2iz8CgEgABBoMFqI6yoSjBvaKfkdASABEGAw+Zx/IAEQaDD+ +CmQgogJKcPkWACAUEHgwWojIZaPSG9oiHNoiHdkrKB0B+hKMIP4CQjD+CsggogJCMPgWACAKEHgw +Woi9ZaN5GtoLGdoLH9oo+NodEAAQaDD9FoogABBgMCwWhCgWlS8Wo/kWhSBAAlhw+xaUIP4CcHD6 +FoYggAJYcPsWkyDAAlBw+haXIGICc7AuFokpHQEe2gwpFoj+FpYgoAJKcCkWhyMShyQSiCUSiSYS +lycSliISlYxgLVIAKhKM/90RDXAEOyD9zAICAABYsFqKeIxAjTAqEoz/3RENcAQ7IP3MAgIAAFnw +Wopy/hKjIAgCGPD0TAQgCAIpcPZsBCAQAhCw/imvcBACOfAlEoYjEoQkEoX6EowiAABZcFqIgdag ++hKMIgAAWTBaiH382fASAABCsP4SlCpIAVQw+xZ9KCoBNDD5FoEmJgE0MPcWgiIuATAw8haAJkAB +VDD3Fn8iAAB5sP7iACIiATAw8haDJkwBUDD2FnwiRAFQMPIWfigqAXQw+RZ5Ki4BcDD6FngoIgF0 +MPkWeyomAXAw+hZ6IgAAaPD4FgAgBRBQMFunb/sSfSH4AkDw/woCIAQQUDD4+jgAABBwMP8dASAA +Jiag/R0CIP4Ce/D5/GEg4gJ78G2qKIuQ0w8PAgD0sRZgCAJKcP8CAAAArgbg/wIAAgC9BuCx7v/8 +BCAIAmtwJxJ/KxJ9IhJ+JhJ8HNm2+hKML4AEOuD8LREPQAQ9oP19Ag4JAHuw/t0CAgAAWTBaiFct +EpON0PzZrBAgAmtw/RaRLCUBbDD6EowvwAQ/YPTYEQ+ABDtg+O4CDAkAf3D+3QICAABZcFqISSYS +hycSiCISifzZnhAFEFAw/RKRIAgQWDBbpzYpEpQqEpMrEpcoEpYvEpUuEqMlXQIkTQIkFoX1FoYg +IAIxsPYWhyAgAjnw9xaIICACELDyFokgAgIY8CMWhC7tAi/9AviNAiAgAlrw+xaXIAgCUrD6FpMg +CAJKcCkWlCgWli8Wlf4WoyX+1RzgIhKK0Q+G0GhjIv8CAAP/cpmgi/DNufoKAiAIEFgw/Nl4EgAA +aPBbpxHHK9EPi/DIuLC8nPBj/soAAAD6CgIgCBBYMPzZcBIAAGjwW6cHxyvRDwCI0P8CAAP/UR4g +i/Blv876CgIgCBBYMPzZZxIAAGjwW6b+xyvRD4rQZa6Ei/D/sw9gAgJi8JzwY/51AAAAAAAA+goC +IAgQWDD82VwSAABo8Fum8ccr0Q8A0qDRD8Ci/Nk6EAgQWDBbpuxgAAzAovzZOhAIEFgwW6bo/NlQ +EAIQUDD7Cggv+xBoMP0WiiAFEGgwW6bhIhKK0Q8AAMCi/NkrEAgQWDBbptxj/80AbBAs+9k4EgAA +ULBah8b72TUSAAAasPzZPxIAAFCwWomlG9k9HNgrHdgq8xY+IgAAULBah9omCgD5HFAiAABQcPXZ +NxAAEFgwFNk2E9k2KxY9KhY8KRY72iD7TAACAABhsFqJlNog+zwAAgAAYbBaiZEkTQLzPQIhvggp +MAIqAlv9g9Og9hZOIAN2LqAjEjskEjwW2SQX2SInFksmFkwX2SIW2SL7EksiAABQsFqHnZpA+xJM +IgAAULBah5r6NgAiAABZ8PwKACIAAFCwWol52iD7bAAAABBgMFqJdiZtAikSTCgSSyd9AimdAviN +AiAgAhjw+BZLICACITD5FkwhSggqMCYSTvvZChIAAFCwWoeFKxI9KRI7KhI8HdkGtJn6rAQgAgJa +8P1mCAX/jprgIRZGHtj8H9j6GtkA+hZJIAAQSDApFkcvFkP+FkIggAJocP0WPyCgAmBw/BZFIHgQ +YDAjEkYrEkWEMYYwLrIA9odGBMgBJDD3FjAkwAEgMPQWKS7IAXQwLxYs9RYxLsABcDAuFjQlMgL+ +sgImwAEwMCYWKPMyAybIASgw9QVGDsgBdDD1FiouwAFwMP4WNiTIARgw/xYuIsABHDDzFisg/gJQ +cPOyASCCAlKw9hYyIAAQeDD7sgMgBBAwMPQWMyzIARww/RYtIsABHDDzFjUsyAFcMP0WLyrAAVww ++xY3IAAQIDBtag2OoG/oAbH/fssBsUS0qsn8yUoqHH/6rEEgBBBAMG2KDY6gb+gGKwqAq+uboLSq +9goAIAAQKDDzGgAgABAgMP9s/yAAEDgw+hx/IAAQcDD6rEEgBBBoMG3aHchhf+EQK6IADwIACzM0 ++1UIBACAWTD+7AEgCAJSsPNNDAAIEFgwfbp2sWb/AgAEAmCVoCUKAPQKACABEHAw/hY5IQAQGDAv +EjkPAgBl/5UpEkYoEj//AgAL/01KEBvYkxzXgPosAAAAEGgwWocw+9iVEgAAULBahw8b2H/8Ej4i +AABQsFqI8BvYexzXJvosAAAAEGgwWocmwCDRDwAAAAAnFjn6CgEiAABJsPapOQAEEEAwCYgMCFUs +9GAtZMABLDAuHf7+7H8h/gJ5sPwSSSCCAnOw/m4KAAUQUDD+4n8iAABpcFumBiwKeMDw+hx/IAAQ +IDD6rCEgBBBAMG2KDY6gb+gBsf9+ywGxRLSqyfzJSiocf/qsISAEEFgwbboNjqBv6AYrCoCr65ug +tKr2CgAgABAgMPMaAC2ABD1g/RZBIAAQKDD/bP8gABA4MPocfyAAEHAw+qwhIAQQQDBtih3IYX/h +ECuiAA8CAAszNPtVCAQAgFkw/uwBIAgCUrDzTQwACBBYMH26HLFm/wIABAGnlaDAkfUKACAAECAw +8AEDYQAQGDAA+AoBIgAAebD2jzkABBBwMA/uDA5eLPcWTS7AAXAw/hZEIC0ANaAuHf78Ekkg/gJz +sP0SRCBCAnOw/m4KAAUQUDD+4n8h/gJ5sFulwywKeC8SR2v0VMDg/xx/IAAQIDD//DEgBBBAMG2K +DYrwb6gBse56ywGxRLT/yezJSi8cf//8MSAEEEAwbYoNivBvqAYoCoCoqJjwtP/AYPUKACAAECAw +8ACAYQAQGDAtEkEsEkTaIPsSQywJAGswWoh5LhJH/Ap4JAEoI6ApEk0vEkYoEkUqEkMtEkIrEkcq +rQIt3QL9FkIgAgJa8CsWR/oWQyAgAkIw+BZFICACe/AvFkZlnp1j/ZuxZv8CAAQA/BWgwFD0CgAg +ARBwMP4WQCEAEBgwLxJAZP+D92z/IAAQUDD/HH8gABBwMP/8MSAEEEAwbYoeyGF34RGI8NMPDwIA +CDM0+FUIBACAQTD+7AEgCAJ78PNJDAAIEFgwebKYKhZA+QoBIgAAQbD2mDkABBAYMAgzDANTLPRg +KmLAARwwLh3+/ux/If4CebD8EkkgYgJzsP5uCgAFEFAw/uJ/IgAAaPBbpWr/CgAgeBBQMPwcfyAA +ECAw/MxRIAQQQDBtihaOwA8CAG/oAi/8Af6rBnAIAmMwsUTTD/MWOCAlADfgyU0sHH/8zFEgBBBo +MG3aEI7ALQqA/+gGbAAgb7CdwLTM/h3+IAAQKDD+7H8gABAgMPMaACCiAnOw/hZKIAAQMDDwAERh +/gJ5sAAAAPgKBCoFADMwCogMCFgsCAhG+BY6IBoANaAuEkr8EkkgBRBQMP7ifyIAAGowW6U8LxI6 +LxZI9H6vYf4CebD+CgAgABA4MPwcfyIAAFGw/MxRIAQQQDBtih/IYX/hEo3ADwIADwIADTM0/VUI +BACAaTD+7AEgCAJjMPNODAAIEFgw/wIAAAEQYDD/AgAJ/7p20C8SSvcKASAAECgw8xoAIAAQIDD2 +bAEgCAJ78P8WSiQSAL2gY/9+AAAc1479EkcgAhBQMFulF8cr0Q8c14r9EkcgAhBQMFulEscr0Q8t +EjgsEkgPAgD43RECAABQsPsSQiwJAGswWofc8/2UYHgQYDAc1379EkcgAhBQMFulBccr0Q8c13r9 +EkcgAhBQMFulAMcr0Q8AAAAA/Nd2EAIQUDD9Ej0gCBBYMFuk+dIw0Q8AbBAKE9Xl0w8oMkonMkwb +120W1dEChzj3d1MANBBAMAh4HBzWHf3XaBYAIEGw9mIAIgAAULBahfYb12Uc1hf6LAAAMhBoMFqF +8hvXYRzWE/3XCRIAAFCwWoXu+9deEgAAULD8CgIgAhBoMFqF6RvXKhzXK/osAAAAEGgw+RwQIAoQ +cDD5FgAgARB4MFqFyMmiwKL811EQCBBYMFuk0ccr0Q8AAAAb1y38100SAABQsFqHnhvXS/osAAAA +EGAwWoea+TKHI5QANKD5q1IKXQFIMAuqDLWqG9dDHNdE9K0RAAYQcDD+3QICAABQsFqFyRPXLBTX +KhXXPtog/AoAIgAAWTBah4naIPs8AAAAEGAwWoeGJE0C8z0CIb4IKTAb1zX81lUSAABQsFqHgG53 +EvvXMRIAAFGwW46X8AARYgAAGrD71y4SAABRsFuOktOg+9crEgAAULBahZDVoPvXKRIAAFCwWoWN +1KD71ycSAABQsFqFihvXJfzXJRAZEHAwBe4M/j43DAAgVTD93AYgHAJzsP/dEQ+ABDug/t0CAgAA +ULBahZv71xcSAABQsFqFe8CyW45406D71xYSAABQsFqFdsCyW450/tWrHAAgVPD71xEQBAJrcPzX +EB3QBD9g/t0CAgAAULBahYr71wcSAABQsFqFadSg+9cJEgAAULBahWbToPvXBxIAAFCwWoVj+j4I +ABACaTD+1cscAQB3cBvXAfzXAh2gBD9g/t0CAgAAULBahXcb1v781v4SAABQsFqHOhvW/PzW+xIA +AFCwWoc2+9brEgAAULBahVArCgJbjk1bjjNbjiLVoPvW9BIAAFCwWoVJwLJbjkdbji1bjhzUoPvW +7xIAAFCwWoVDwLJbjkFbjidbjhbToPvW6hIAAFCwWoU9wLJbjjtbjiFbjhD71uUdwAQ44PhOEQ1A +BD1g/t0CDAkAYrD9zAICAABQsFqHFvvW3RIAAFCwWoUvKwoCW44tW44TW44B1aD71tgSAABQsFqF +KcCyW44nW44NW4371KD7CgIgGRBQMFuOIluOCFuN9tOg+woCICgQUDBbjh1bjgNbjfL4TRENQAQ5 +YP3MAg3ABDzg+9bGHAkAazD6LAAMCQBisFqG+PvWrRIAAFCwWoUR06D71rISAABQsFqFDqo6+qz+ +IAIQWDBbjgpbjfBbjd7ToPvWtxIAAFCwWoUGwLJbjgRbjepbjdgb1rP0PRENgAQ6oP3MAgIAAFCw +Wobi+9auEgAAULD8CmAgYBBoMFqFFxvWqhzVL/3VLhIAAFCwWoUTFNZaE9amFdZaFtam2iD81YgS +AABZcFqG0tog+0wAAAAQYDBahs/aIPzVBhIAAFjwWobMIz0CJV0C9E0CIZ4IMXDaIFv9GmaiffvW +PhIAAFCw/AoBIAEQaDBahPz71joSAABQsPwKASAAEGgw/hwQIBQQeDD+FgAgZBBwMFqE2sqnwKL8 +1ogQCBBYMFuj48cr0Q/5S1IKVwFIMAuqDPP8bmAKAlKwAAAAAAD71iYSAABQsPwKASAAEGgwWoTj ++9YiEgAAULD+CmQgARBoMPwcECAUEHgw/BYAIAEQYDBahMLJpsCi/NZxEAgQWDBbo8vHK9EPAAAA +AAAAAPvWFhIAAFCw/NYVECACaHD9FgAgyBBwMP3VGxAKEHgwWoSyyaHAovzWYxAIEFgwW6O8xyvR +DwAAF9ZhH9Sn/NZeEAgQcDD+FgkgBxBoMP0WCiAAECAw/BYLIAAQGDD/LwoAGBAwMP8WByAFEHgw +/xYIIBUQKDCLF9MPK7KKAGAE+wsZD/8QYDD81k4aEQBm8AsLQvsWBSoAIFzw/LsKAgAAULBahI3c +oPsSCyIAAFCwWoZt/NZEEAUQUDD+EgkgCBBYMP8SBSIAAGkwW6OVixcrsooAUAT7CxkP/xBgMPzW +OhoRAGbwCwtC+xYGKgAgXPD8uwoCAABQsFqEd9yg+3wAAgAAULBahlj81jAQBRBQMP4SCiAIEFgw +/xIGIgAAaTBbo38nfQL8EgggAgIhMPgSCyH0Ailw/hIKIfQCMbD9EgkggBB4MPiNAiIAIHzw+BYL +IfwCc7D+Fgoh/AJrcP0WCSH+AmMw/BYILwsAtyAb1cr6LAAACBBgMFqGO/vWFBIAAFCwWoRUyKz7 +1hISAABQsFqEUWWqRPvWEBIAAFCwWoRN+9YOEgAAULBahEv71c0SAABQsFqESPvWCRIAAFCwWoRF +2iBb+lXSoNEP0qDRDwAAAGwQChfUQClySihyTBTULgKYOPh4UwA0EEgwCYgcqESEQPvV+xIAAFEw +W401/NX6EAUQMDD6ZjcAChBAMAhmNghjEPvUMhwJAGDw/BYEIgAAULBahhAb1C0c1C76LAAAABBo +MPgcECAKEHAw+BYAIAEQeDBahCn81egSQgC2oPvVuxIAAFCwWoQf/dQiEfYCKrAJXBEMPAL71B0c +CQBrMPwWBCIAAFCwWoX7G9QYHNQY+iwAAAAQaDD4HBAgChBwMPgWACABEHgwWoQTZaINHNQS+9QO +HAkAYPD8FgQiAABQsFqF7BvUChzUCvosAAAAEGgw+BwQIAoQcDD4FgAgARB4MFqEBWWh9GQhmCty +SypyTBzUZx3VwvkcICg+AVgwCYgKhdOO0Y/Sn5KekfWWAyoAQGaw/dIAIAAQUDD9lgAgABAoMPiC +ACABEEgw+5o4AAIQSDAKlTn91bIUCQBFcAxcEQw8AvvT6RwJAGsw/BYEIgAAULBahccb0+Uc0+X6 +LAAAABBoMPgcECAKEHAw+BYAIAEQeDBag+BloYL71aISAABQsFqD19Wg+9V0EgAAULBag9T/AgAK +AGORYCVc/PxVEQQAZ5agwIh6iwf/AgAKAG/GoMCgB6kR+BoAJAkATXD91ZEUCQBFcAxcEQw8AvvT +xxwJAGsw/BYEIgAAULBahaUb08Ic08L6LAAAABBoMPgcECAKEHAw+BYAIAEQeDBag71loRn7ahoi +AABRMFuMtPvVYBIAEGAw+iwADAEAUzBahZQb07Ic07f8FgQiAABQsFqFkPvTrRIAAFCw/NOsEAoQ +cDD9HBAgARB4MP0WACAAEGgwWoOoZaDowCDRDyVc9PxVEQAEEEAw+FUCBf+cxqDAiP8CAAv/mlYQ +8/82YfgCUrArckkqckpj/mMAAMCyW4yTY/8eAAAAAAD2FgAgAhBQMPsKCCAAEGgw/goAIAAQeDBb +op3HK9EPAJYQ/NVOH9AEOWD6CgIgCBBYMP0KAyACEHgwW6KVxyvRD5YQ/NVGEAIQUDD7CgggAxBo +MP4KACADEHgwW6KNxyvRDwCWEPzVPRIAAHFw+goCIAgQWDD9CgMgARB4MFuihMcr0Q+WEPzVNRIA +AHFw+goCIAgQWDD9CgMgABB4MFuifMcr0Q8AAAD81S0QAhBQMPsKCCAFEGgw/goAIAAQSDD5FgAg +ABB4MFuicccr0Q8AbBAKF9NdKnJKJXJMFtNLAqU49XhTADQQSDAJiByoZiNiACt60Po8AASFASgw +W4xR+9UcEgAAYrD2FgYiAABQsFqFMRzVGPvVGBIAAFCwDDwsWoUtG9UW/ArIIgAAULBahSob1RP8 +KgAiAABQsFqFJvvVDRIAAFDwW4w+G9UOCqwK/8wRAgAAULBahR8Y1QsERAvTDwhECvtCfyIAAFDw +W4w1HNUGBQtC/LsKAgAAMrD7sn8iAABQ8FuMLteg+0KFIgAAUPBbjCsrQoOaGfcWBSIAAFDwW4wn ++kKHIgAAOrBbpFr8rAACAABq8PrU9RAAEFgwW6L0W6NN+6wAAgAAUPBbjBwtCgQH1zcHewJbjBn1 +uFEEIAC+oPAAFWAAEFAwAAAAAMDh+goCIfYCerAP6jj+qhACAdGGIBvU4g8CAAuqAhvUX/zU4BAI +EGgw+iwADAkAbrBagyb71N0SAABQsPwKASABEGgwWoMh+9MAEgAAULD8CgEgARBoMP4cECAUEHgw +/hYAIDIQcDBagwDJo8Ci/NTPEAgQWDBbognHK9EPAAAAABvUy/osAAAIEGAwWoTVG9TJ+iwAAAEQ +YDBahNIb08L8OgAiAABQsFqEzvvURhIAAFCw/AoCIAIQaDBagwSMFizCAR3UviwWBwxsDPvUux2A +BDsg/cwCAgAAULBahMEb1Lj6LAAAABBgMFqEvh7UtfzUthxUASwwDt0cG9S0/cwMA+gQaDANzCz8 +FggiAABQsFqEtIUXG9Su+iwAAAQQYDBahLCNFfosAAAkEGAw+9RzHAEAazBahKvaIPvUbxIAAGGw +WoSoG9Qa+iwAAAIQYDBahKQb1GL6LAAAABBgMFqEodog+9SEEgAAYbBahJ3aIPvUUhIAAGFwWoSa ++0KAIgAAUPBbi7L71JMQDxBgMPosAAwBAFMwWoST+0KBIgAAUPBbi6v71FoQFBBgMPosAAwBAFMw +WoSL3GD71E4SAABQsFqEiNxw+9SEEgAAULBahIX71IISAABQ8FuLnfvUPhAEEDAw+iwADAEAUbBa +hH371HwSAABQ8FuLlfvUNBAGEGAw+iwADAEAUzBahHb71HMSAABQ8FuLjgpsN/vUKRIAAFCwWoRv +G9Rv/CoAIgAAULBahGz7QoQiAABQ8FuLhPvUahADEGAw+iwADAEAUzBahGT71GYSAABQ8FuLffvU +ZBAKEGAw+iwADAEAUzBahF371GASAABQ8FuLdYQY+9QiEEAQYDD6LAAMAQBTMFqEVfrS5BIAAFkw +W4ttG9RX/KwAAgAAULBahE/71C0SAABQ8FuLZ/vUURAFECAw+iwADAEAUTBahEf71CYSAABQ8FuL +XwpMN/vUShIAAFCwWoRBiBkkCgMPAgD4RDcCAABQsPvURBIAAGEwWoQ6+9Q5EgAAUPBbi1L70+wQ +DBBgMPosAAwBAFMwWoQzsUz71DsSAABQsFqELxvUOfosAAAAEGAwWoQs+9Q2EgAAULD8Ch8gABBo +MFqCYRvUM/osAAABEGAwWoQkGdI/+ZKHIGcANKD5qlIKXQFMMAq7DLW7BbsIC6oI+qz/IAIQWDBb +izTcoPvUJRIAAFCwWoQWG9Qk+iwAAAAQYDBahBPaIPvUIRH+Amlw/R0UAB8QYDBagkfAINEPAB7U +HPP8Y2oJAHKwAAAAAAD5SlIKVwFMMAq7DPP/m2AKAlrwAGwQBCs66As7KBrSkAsbFFuLGvKqKAPo +EFgwW4sXW4sL0Q8AAGwQEPrSFRIJADSgJqJMKKJLKBYVBnVTZFIF/wIAAAEFBWBuUg/AnXWTCvAA +CWABEDgwAAAAwHIT0/0U0/3aIPzT/RIAAFjwWoPoIz0CdDnsGdIe/dP5EgwBPWDdkBvT9/zT9hIA +AFCwWoIZE9HrDHoRqjonotApotEootIqotMb0/D8iBEJYAQ+YPN3EQvgBDqg+XcCCAkAUjD80qYW +CQBF8PosAAIAAGnwWoIJLhIV/9JVEAEQUDDTD/5uUQYMAL1gwKAb0+D80psQNBBAMAhVHCYWEfjT +3BQAIB1wJRYThVL47REOBQBWMP4WECwJAH9w/RYUL/AEOWD+CkAsCQB3cP7dAgIAAFCwWoHxKRIV +89PPGGMBTDD0WBEFgAQ+YPbTzBQJAEVw/VwAAgAAULD80x0SAABY8FqB5SM9AnY55hPTxBXTxdxw ++iwAAgAAWPBag6UjPQJ1OewnEhTz078QQBBAMPXTvhYJAEXw3HD6LAACAABY8FqDnCM9AnU57MCh +W5sYG9O3HNIf+iwAAAAQaDBagc/zCgAgMhAoMMGkW5sQsTN1OfUb07Ac00j90rYSAABQsP4KZCAg +Akhw+RYAIBQQeDBaganIr8Ci/NOnEAgQWDBboLLHK9EPG9OlHNOl/dIIEGQQcDD6HBAgFBB4MPoW +ACIAAFCwWoGcy6HAovzTnRAIEFgwW6ClxyvRDyaiSiuiSSsWFWP99wAAAADz/hNgABA4MPP+C2AA +EDgwAAAb05L805ISAABQsFqDahPTkRXTkdog/NOOEgAAWPBag2UjPQJ1OewnEhMPAgCHcPrTihIA +AFnwW/9cG9N+HNGx+iwAAAAQaDBagZUb03/8020SAABQsFqDVxPTfvzSKRIAAFCw/dNnEgAAWPBa +gYwjPQJ1Oeb6CiAiAABZ8Fv/SxPTXtog/AoAIgAAWPBag0ojPQJ0Oez6CiAiAABZ8Fv/QhnRYSUS +FQ8CACmShwV1Q/koUQgwAUww9FHHaAUAFjAqEhBkpgn/AgAAAyuGoP8CAAIDUAKgKxIVCwpC+hYO +LEsBXDAtFg/93QkMPgFYMP0SECgAIE9w+qoJCnIBXDD7Fg0qACBisPkWDCIDTIdg/NNTEAgQWDD9 +XP8h/gJysP88AAAFEFAwW6BRJBYW/RINIgAAeTD800sQBRBQMP4SDCAIEFgw8xYLIf4Ca3BboEgU +00X6EhYgABBwMP4WEiOQBD3gW6Jl/KwAAgAAavD7EhIiAABRMFug/luhWMGPCjks+hILKAEAyjAo +FBRbolv9vAACAABisPsSEiIAAFEwW6D0wU9boU0KOiwrHBb7FgoqAQDRMPoUFSAoAhhwHNGFJDAA +G9Mp/EwCAgAAULBagvn7fAAH0BBQMFv+9BzTGdog0w/70yEcCQBhMFqC8vvTIBIAAFCw/AowIDIQ +cDD9HBAgFBB4MP0WACAwEGgwWoEKyaPAovzTFxAIEFgwW6AUxyvRDwAAAAAb0xD6LAAAABBgMFqC +4PvTDhIAAFCwWoD5/hwUKmABUDD6FgQgEghw8JoYYAAdFNLxjRT8CvAiAABQsPzdEQIAAFkwWoEM +JE0CdknkjhqxM/8CAA//oPDQYAAQLxIVDwhC+BYOLksBfDAvFg8pEhEJOUFklSv/AgAAApgGYP8C +AAICmQJg/wIAAgKahmD1FgcgABAYMBrS7hbS7hXS7vTS7xAAEFgw8wxDAA8QaDArFhf6FgYmAcZv +ECsWF/oWBiIB1gcgJE0CJV0CJm0C+q0CIA8QaDDzQxQAAgJa8PMMQwWaAj7g+gogIgAAWfBb/qUT +0tgU0tr6LAACAABY8PwKgCCAEGgwWoDbIz0CdDnm+gogIgAAWfBb/poT0s78CoAiAABQsP0KACIA +AFjwWoDSIz0CdDnm+gogIgAAWfBb/pAd0K/TDy3ShxvSxv2uUgxUAWww/NH9HAUAF7D43RECAABQ +sFqAxBvSvxzSBv3ROxIAAFCwWoDAE9K8FNK82iD80VYSAABY8FqCgSM9AnQ57Pt8AAAgEFAwW/56 +LRITLdILG9K0HNK0+N0RAgAAULBagLElEhMPAgCFXBPSr/TSsBWABD1g/VwAAgAAULD80qoSAABY +8FqApyM9AnQ55vvSqBIAAFCw/AoQIBAQaDBagKEU0qUT0qUZ0qaMF4gf+woCIAEQaDD83DkAABBQ +MPbSnxoFAGLwCogKCYgKJYJ+iRiaGfiCfyXABD1g9JsRC4AEOmD8lxEKCQBasPiIEQYJAFXw+FUC +BgkATfDccPosAAIAAFkwWoJN2iD7PAACAABhcFqCSiRNAvM9AiG+CDEwE9KJFNKJ3FD6LAACAABY +8FqCQyM9AnQ57BvShfzRPRIAAFCwWoI+G9KC/NE5EgAAULBagjob0oD80TYSAABQsFqCNxPSfRTS +fdog/NJ9EgAAWPBagjIjPQJ0Oewb0nj80lISAABQsFqCLRPSdhTSd9og/NJzEgAAWPBagigjPQJ0 +OeyDGRvScfzSSBIAAFCwWoIjKBIOGdJtA4gKCYgKJYJ+KIJ/E9Jr/FURCYAEOiD00mkUCQBFcNog ++zwAAgAAYXBaghYjPQJ0OewpEhUY0mIJiVIMmRGpiCSCfiiCfxPSX/xEEQmABDog9tJdFAkAQTDa +IPs8AAIAAGEwWoIIIz0CdjnsE9JYFtJY3FD6LAACAABY8FqCASM9AnY57BPSUxXSVNxA+iwAAgAA +WPBagfsjPQJ1OewqChRbmXcqChRbmXYqCgJbmXQoEhUlEhET0kkPAgD1BVMIWwFAMPOJEQlwBDog +/FURCAkASjD00kMUCQBFcP1cAAIAAFCw/NJAEgAAWPBagB8jPQJ0OeYqEhXTD9MPCupD89I6GUAE +PqD4pREJwAQ6oPqIAgQJAE1w9NI1FAkARXDaIPxcAAIAAFjwWoHWIz0CdDnswCDRDwCLFvzQpRIA +AFCwWoHQ2iD80ioSAABZsFqBzdog/NIoEgAAWXBagcpgACcAixb80TcSAABQsFqBxdog/NB3EgAA +WbBagcLaIPzSHhIAAFlwWoG/2iD7TAAAABBgMFqBvIoWKxIXY/wbJBIV+NIXGkABIDCaHvqqCQo+ +ASQw+9ISGgAgWrAFUwkKMwoLMwrzMn8qSwEkMPsWDyRyASAwlB0Luwn0RAkKACBecJscC0QKCEQK +JELtY/ntJBIV+NIFGkABIDCaHvqqCQo+ASQw+9IAGgAgWrAFUwkKMwoLMwrzMn8qSwEkMPsWDyRy +ASAwlB0Luwn0RAkKACBecJscC0QKCEQKJEJ/Y/mcKxIV++xRCkABWDD6Fg4sSwFcMP0WDypyAVww +mx0N3Qn6qgkMACBPcJ0c8/lvagAgYrCZHJsdGNHmFNHkBVMJCjMKBDMKIzJ/C7QJCUQKCEQKJEJ/ +Y/lFE9HflRdj+uuVF/P65mP/EBgwlRfz+txgPxAYMACVF/P60WAPEBgwAABsEATIJ2ghBcYq0Q8A +ABbPiRvR0ShiSiViTPkKASAAEBgw8pM4AgAAULDzhTkABxBgMFqBZCliSihiTPTPbhgFABpw+HhT +ADQQSDAJiByoRIRB+kz8IAIQWDBbiHUpYkooYkz3z2QYBQAacPh4UwA0EEgwCYgcG9G5/tG6FgAg +RfD3cgEh/gJJMPU/QQgAAUww9a0RCPAEPmD1CEIGAAE8MPqIEQdgBD3g+d0CBgkARfD//xEMCQA/ +cPzRqRwJAH9w/t0CAgAAULBaf3jAINEPAAAAAGwQBhbQOfvPVhIAAGiw9CCmYIAQYDD0BQYAAE8E +oB3QOyrSgSjSfi7SfwOiDAJSAX4jfPmw0SB5ADYg8taBKAkAZnD5tNEiAABQsBzPYy/SgJMR9BYC +IAAQWDD6FgAgAhBoMPIWAyAFEFAwW55PzyYqYrX0oggAABBoMP9itCH+AhCw+GKyIgBAEXDzKwgC +AAAqsPvzcXIAAFGwZIBp2mDwAD9gABBoMNEPAAAAAAAA8/+XYAAQEDAN2goGqgolorX0AgYIACAh +cP+itCH+AkIwCCIBoyn+orIqABdP0MrmaNIsojUlprUcz0kuorOVEJMR9BYCIAAQWDDyFgMgBRBQ +MFueKdEPAPP/3GAAEBAwL7DRDP8CL7TRL6K0Y//DAGwQBBTPufPRWxAAEBAw2iBbmoAKCEFpgSH8 +rx5yAABI8AAEiwBJYQBJYQBJYQBJYfosAAAAEFgwW5pxsSLzPQQpmgI4oMAg0Q8AAABsEATyAkcA +DRAYMPMhHXAOECAwdCEV+AqBLiQAOKD5CocgFARAsHkhAtEPABvO8iqw0cDIDKoCKrTR0Q9sEAQW +zx4GJgslYuAY0TkENxH3RwIEAEBFcAdVAiVm4NEPAABsEAQWzxUGJgslYtAY0TAENxH3RwIEAEBF +cAdVAiVm0NEPAABsEApbmlQX0Bzzz7MQABBIMPIKASIAAHKw9tEkEAsQKDD6NDQgCBBAMG2KEgCQ +BA4KG/+nB3ACAlpwK3Z/sZn0CgAiAGj/kMAg/wIAAgDS+5D/AgACAVb3kP8CAAIBx/OQ/wIAAgI6 +75D/AgACAnLrkP8CAAICqueQeOdjKhok/M9zEBIQWDBbmo/6Zd4gFRBYMPx6/yE0EFAwW5qKCqsC +/CwAAAcQUDBb/8wqYd4KC0P+Cg0mAsOG4P8CAAYCv/bQW/+uK2HeCwtD/jA0IA4EKvBpugosYEHB +0A3MAixkQRzQ9C1yfyR2gCswNZsQKjA2mhEpMDf5FgIiAAB5MPgwOCAAEFgw+BYDIAQQUDBbnarR +DwAqCpz8z00QDhBYMFuaaRzPSvsKHiIAAGqw/WXXITgQUDBbmmMiND38ev8gERBYMPo0NSAAEHgw +/zQ5LuABUDD+FgQgrBBQMFuaWvwKACIAABKw+goAIgAAWLBb/5v6GkQgAgIQsPx6/yAEEFgwW5pQ +KDA11aD0CgAgJwA2ICowOdtQ+koIAgAAYLBb/4YrMDX0TAEgAgJhcPtD4XIAIGCwKmHX9BIEKmAB +VDD1CgsmAkqG4MDd/wIABgJF7tBb/2orYdcLC0P/AgAGAkUu0P8CAAoCQQLgLjA0Y/5YAAAqCrD8 +zxUQChBYMFuaMRzPE/sKAiIAAGqw/WXYIUgQUDBbmizAvfo0Nif/EGAw9DQ6LuABVDD/RAgAAhBw +MP40PSDAEFAwW5oi+hYFIgAAWrD8LAAAARBQMFv/ZCgSBfsKCCFQEFAw+IwBJ/8QYDD0FgQiACBA +sFuaFikwNtWg9AoAICcANmAqMDrbUPpKCAIAAGCwW/9MKzA29EwBIAICYXD7Q+FyACBgsCph2A8C +APQSBCpgAVQw9QoLJgHlBuAtCg3/AgAGAd/u0PoKRwANEHAwfqEULwoOf6EOaK4LKAqBeKEFKQqH +eakKKmBBwMgMqgIqZEH/AgAGAa8u0P8CAAoBqwLgLjA0Y/1SAAAAACoKxPzO0RAGEFgwW5ntHM7P ++woGIgAAarD9ZdkhVBBQMFuZ6MC5+jQ3J/8QYDD0NDsu4AFUMP9ECAADEHAw/jQ9INQQUDBbmd76 +FgYiAABasPwsAAACEFAwW/8giBb7CgwhXBBQMPiMASf/EGAw9BYEIgAgQLBbmdIpMDfVoPQKACAn +ADZgKjA721D6SggCAABgsFv/CCswN/RMASACAmFw+0PhcgAgYLAqYdn0EgQqYAFUMPUKCyYBZwbg +wN3/AgAGAWJu0Fv+7Cth2QsLQ/8CAAYBYa7Q/wIACgFdguAuMDT/AgAB/jzzkCoK2PzOlxACEFgw +W5mzHM6U+woKIgAAarD9ZdohYBBQMFuZrcC1+jQ4J/8QYDD0NDwgBBB4MP80PS7gAVAw+groJAAg +cTBbmaT6FgciAABasPwsAAADEFAwW/7liBf7ChAhaBBQMPiMASf/EGAw9BYEIgAgQLBbmZgpMDjV +oPQKACAnADZgKjA821D6SggCAABgsFv+ziswOPRMASACAmFw+0PhcgAgYLAqYdr0EgQqYAFUMPUK +CyYBAgbgwN3/AgAGAP1u0Fv+sith2tMP0w8LC0P/AgAGAPqu0P8CAAoA9oLgLjA0/wIAAf3J75Aq +Cuj8zlsQHhBYMFuZd/pl2yABEFgw/Hr/IPwQUDBbmXL6FggiAABasPwsAAAEEFAwW/60jBgqYdv8 +zAEqYAFUMPwiCAYA1IbgLQoN/wIABgDPbtBb/pMrYdsLC0P/AgAGAM6u0P8CAAoAyoLgLjA0/wIA +Af2R65AqCvz8zj0QGhBYMFuZWfpl3CAdEFgw/Hr/IQwQUDBbmVT6FgkiAABasPwsAAAFEFAwW/6W +jBkqYdz8zAEqYAFUMPwiCAYAqIbgLQoN/wIABgCjbtBb/nUrYdwLC0P/AgAGAKKu0P8CAAoAnoLg +LjA0/wIAAf1Z55AqGhD8zh8QFhBYMFuZO/pl3SAZEFgw/Hr/ISAQUDBbmTb6FgoiAABasPwsAAAG +EFAwW/54jBoqYd38zAEqYAFUMPwiCAYAfIbgwN3/AgAGAHfu0Fv+Vyth3QsLQ/8CAAYAdy7Q/wIA +CgBzAuAuMDRj+jwsYEHA0g3MAixkQWP6di5gQcHwD+4CLmRBY/yfKGBBwJIJiAIoZEFj+2oAACpg +QcGwC6oCKmRBY/tzAAAsYEHA0g3MAixkQWP8NgAALmBBwPIP7gIuZEFj/TEAAChgQcGQCYgCKGRB +Y/06AAArYEHAwgy7AitkQWP9+wAALWBBweAO3QItZEFj/ggAAC9gQcCCCP8CL2RBY/5XAAApYEHB +oAqZAilkQWP+YAAAK2BBwMIMuwIrZEFj/q8AAC1gQcHgDt0CLWRBY/64AAAvYEHAggj/Ai9kQWP/ +BgAAKWBBwaAKmQIpZEFj/w8AAGwQBhbPYvfNEBAAEBgw9c8EEfQQIDDaMFuWkv9w0SAAIK6g8s7+ +EIIA//BkMHYpckoockwDmDj6YpkgABSyIGSgCwM6AluWbmagFGAAAcCg+wrMIAICGPD5MrpmACBZ +sNKg0Q/AINEP2jD8z0kSAABYsFp+2SItAnUp7BLPRtow/AoAIgAAWLBaftMcz0MiLQJ8Kekbz0L8 +z0ISAABQ8Fp+zmP/iB/M4C/ywJ8QHszgwN795kAgARBQMFuWRhjM3CIKD/KGQCAAEBAwwaRblkGx +InQp9YkQCelR/wIAA/+oHmAbzNMazOMqtkBj/z8AAGwQBBnM1RzPKxbMwPiQ0SABEFAw8woAIBQQ +KDD0Chgv/xA4MPKcAAIA7v4QI8YfI8Ye88SAIDAQcDArIXQfzx4LXEb/zwoKACjzEI/wCvAAAABv +OxopYoQAMQQAqBoAiBEHjAMMmQEJiAIoZoRgACQsYsDB5wPuDADhBACpGgedAw3MAQyZAilmwGAA +BwDaMFuYD8ChKyF0B7wD9MsBDgAJJxBouFJouzf/AgAEAKojEPIsAiACAhjw/wIAADAQcDD/AgAP +/7qo0PcKhyAAEBgw8syhEA4QWDDwAFVgFBAgMC9ixwAxBACrGge5Aw+fAQ+/Ai9mx2AACAAxBACr +Gge5AyhixgmIAQi4AihmxmP/nwB7qQz6PAAAARBYMFuXn8C+8zwBIf4CITD0QLdgBAIQsCohdHeh +FwpaRmiiLGiqWf8CAAYARa6QaaHFYACAAC1ilh7O2v7MwRwAQHdwDt0CLWaWY/+6AAAAANowW5fK ++woOL64AtqAtIXQZzs74kIAsQAFsMPDRBAABEGAwAMwaDIgCKJSAY/+HANowW5e++woOL34AtqAq +IXQbzGsKCkKrqyuw5AsLRFuXjB3OvsDPLNSA8/9aYA4QWDAAAAAA+jwAAAEQWDBbl3Dz/0NgDhBY +MAAAW5jPW5jFH86yKvYeK/YfLmKH/maHIAAQEDDRD8Yq0Q/AINEPAAAAAAAAAGwQBhbM3w8CACZh +whjM3AdmEfPMlhYAIEGw+s6lEAEQWDD8CgEgChBoMPgqACAAEHAw+DY6IAAQeDBafiwZzEIokNLy +zpwSAAAhsPfOmxABEFgw+rg7AAAQKDD4lNIgAR8uoJYQi0KKQSs2O4lAKjY8KTY9Gs6P+woBIAEQ +YDD/VhEAChBoMPdoAgAAEHAw+DY6IAAQeDBafhVmof/6zoQQARBYMP0KCiAAEHAw8mwCAAAQeDD8 +NjogARBgMFp+C/ah2WACAilw+V6ZYBgCITAtEgAXznoSznr93QYgABAoMP0WACAA3C6gDdQCi0KK +QSs2OylCACo2PCk2PRrObfsKASABEGAw/1YRAAoQaDDyaAIAABBwMPg2OiAAEHgwWn3zZqF3+s5i +EAEQWDD9CgogABBwMPdsAgAAEHgw/DY6IAEQYDBafen2oVFgAgIpcPlemGAYAiEwLRIAFsv+/d0G +IAAQKDD9FgAgAJmuoA3UAo1EjEMtNjuLQiw2PIpBKzY9iUAqNj4pNj8azkn7CgEgARBgMP9YEQAK +EGgw9ogCAAAQcDD4NjogABB4MFp9z/ag5WACAilw9EwUL2oCOWCEEPbOQBAAECgwLU0KjdQsTQqM +wy02OytNCouyLDY8Kk0KiqErNj0pTQqJkCo2Pik2PxrOL/sKASABEGAw/1gRAAoQaDD2iAIAABBw +MPg2OiAAEHgwWn219qCFYAICKXD0TBQtTAI5YIQQ9s4nEAAQKDAtTQwt0iQsTQwswiMtNjsrTQwr +siIsNjwqTQwqoiErNj0pTQwpkiAqNj4pNj8azhT7CgEgARBgMP9YEQAKEGgw9ogCAAAQcDD4Njog +ABB4MFp9mvagDGACAilw9EwULUICOWDSoNEP0qDRD9Kg0Q/SoNEPAAAAbBAG2iBbaA6UEBzMifsK +CCIAAGiw/zwAAgAAMrD6CgUiAABxsFuasMBwFcwKpWUjVoEkVoInVoMH5BYBAgDaYPhSgyACEFgw +Wh+HI1KI0w8PAgDIOfpsAAACEFgwWh+C/SwAAgAAcPAH5Bb8zHIQBRBQMP9SiCAIEFgwW5qbwCDR +DwAAbBAEE83n/8vqEAEQcDD9Ch4gBBBIMPgKICIAAFDwbYoKK6AFeyACf7c1vKoay3z88IAgABBY +MA8CAP6k3CAAEBAwbZoYKKDk+NMQcAICUrAAsQQA6RoJzAIs9ICxu9EPjqAczdD94AAgCBBYMP7g +ASACEFAwW5p72TD/CiAg/hBQMG36DSiQBQqIAfiUBSAYAkpwxyvRDwBsEAYoIAD5CoIiAABQsPIt +BCAUBEowxy7RDwAAJ6wW/wIACgDzkdAUzbuaEBPNuZMRE8258AB2YEAQKDAAAAAAALwzdDFVKDAF +BYgB+TAELeICPiB2menacPsyACACEGAwW5cE/AoAL+oQWDAKyzhmv86NESwxA4gy2mD7fAMsACBr +MAuAAPahkmABEHgwLjAF0w8P7gIuNAUmcALzzZ8QBgJBsKh3/wIACgCwEdADOwL6fAAAAhBgMFuW +7vPNkxAKADagJnACY/97iRC0ev8CAAoAoVJQCXoMtKr6C0MAABBIMG25DosQLLAAsbv7FgAoACBP +MApLFGSxCIgQLYAELIAAKoABL4AC/oADKAAgTzD8gAUoACBOsPqABi4AIE/w+YAHLgAge7D/gAgs +ACB3cP6ACSwAIGsw/YAKKgAgYrD8gAsoACBWcPqADC4AIE/w+YANLgAge7D+gA8sACB3cP2ADiwA +IGsw/KoIACACQjD6mQgB/gJS8G2pgvmAACwAIEtw/IABKgAgY7AtgAL5gAMuACBScPyABC4AIHMw +/YAFLgAgc3D5gAYuACBycPyABy4AIHMw/YAILgAgc3D5gAkuACBycPyACi4AIHMw/YALLgAgc3D5 +gAwuACBycPyADS4AIHMw/YAOLgAgc3D+gA8oACB2cPnJCAAgAkIwCdkIqekayuAppN3EoFv/VtKg +0Q8A8//sYAAQSDCOMBzNP/3gACACEFAw/uABIAgQWDBbmeZj/mEAbBAEHMtlK8J/LMKA+csNH5AE +OuD+zAgAGhBoMC3EBJvAKJKDGs0xCogCKJaDW5NYwCDRD2wQBBjNLRnNLRrNLRvNLvIKACAGEGAw +DAk/Ago/Agc/Agg/Ags/CwQ/CgU/CQY/+IJ/IIAQUDAIAD9bg4wezSIKAT/y5H4gCBB4MP/kfCAB +EGgwLeR9W5N+W5Nb0Q8AAGwQBhrLP9MPIqJYwEj8y2EQABB4MP76/yFrADSg9vwAAAAQSDD4CgAg +ABAoMG0IWSeini2ipqdnCXIRot0l1RMr0RIu1HaZ35jcJtQiL9QNJtQM9NQFIAwQEDDy1AQgARAY +MCPUIJfQI9Qhh9uD3iKiWPZsASQAIF1w94gICAAgHnD81S4qAAORkGP/nyuiWWSwrBXM9v0SAC// +ECAw+woAIAAQMDDwAExggBA4MMDRme8m5CIt5A0k5Az45gwvgBAYMCPkISPkIPPiCy//EBAwIuR2 +gu7zolkoACAaMPu8/yACAmtw9mwBKAAgFnD85S4qACcZkCKiny6ipqJiCSMR8woNLgAgG7Aj5ATy +5gAgCBAQMPLkBS+YALbgsVWnWyuwzfW/h2ACAiEwbQgOsVWnWyuwzfW/dWACAiEwY//qLKJay8n0 +yscQABAwMPgKByAOEDgwbQgkIqKgLqKmomIJIxGj7pLgL+QNKOQMJ+QELaJasWb05S8qAAPpkGP/ +1MAg0Q/Z8PP/A2AAEEAwAABsEAb7y18QARBQMPzLXhAAEGgw/8yzEAEQcDBbkzkayssTyukby1cZ +ysosMl0tMlwuMlspNp0pNp8pNqEpNqMvMlorNpwrNp4qNpsqNqAoMlkoNqoqMl8rMl74MmAuACBH +8CkyYy82q/8yYi4AIHuwLjas/jJhLAAgd3AtNq39MmssACBrMCw2rvwybCoAIGbwKzav+zJtKgAg +WrAqNrP6MnEoACBWcCk2sPkycigAIEowKDay+DJzLgAgR/AvNrH/MnQuACB7sC42tP4ydSwAIHdw +LTa1/TJ3LAAgazAsNrb8MngqACBm8Cs2t/syeyoAIFqw+ja4KAAgVnApNrkaypD6NpooACBKMCg2 +uvnKkh4AIEfwLza7+TaiLgAge7D+NrwgABBAMPg2qSwAIHdw/Ta9LAAgazD8Nr4qACBm8Cs2v1uS +6ysyoy8yovj6gCD+AhLw+a0RAgBAQLCi2vkyoCoAI1fQy576NqMiAABasBzKGS4yofIWAyAFEFAw ++xYAIIAQQDD9FgEgABBYMPgWAiABEGgwW5j28jbAIBMANKDAINEPAAAA8//EYAAQEDDHJNEPbBAG +FMnc+snIEAAQKDD2yokQARAYMCWmgSWmgyWmgCWmgihA0SkKEPmmiiCAAP4wG8xBLWJ/GMw+/8pC +EGoQcDAO3SgeykIP3SwvgoDAzP3MNw4AQHfwD88CL4aALbKADt0BDcwCLLaAK7KAG8rZ/MwyEAAQ +UDBb/hfAofzKRxAAEFgwW/4TW/rfGcnr0w8okoX/QNAgIBBYMPv6/SgJAFow+JaFIAQQSDD4zCQS +PgC74G2aFymCkCqNBAuZASmGkCmikCiNCAuZASmmkB3MHMfPLNYgLNYhLNYiLNYjLNYkW5VUH8nh +wIgq8o/6CUMKYAFQMPpE0CgJAEZwKUTQLvKKG8qk+QqILgkAQ7D+9oogABBAMG2aDQuJCyWWQPWW +QSACAkIwG8ndEswGJbaQI7aRIyaAW/p/LCKAHcwD0w8NzAIsJoBb/TlmoUVb/LP+Yn8gAJ+uoPnJ +6BD/EDgw8hqQIAMQeDAC7iwP7iwqQob+lrwiQAFQMPQhomJKAVQw/wIAAADxhKD/AgAEAO2EoP8C +AAAA6YTg/wIABADlhOBuJAUKOEYoFgBuNAQK2UeZEhnJXfmSjyIA5hig/wIAAgCyAOBlMdT5a1MA +ABBQMPoWASvwBD7gKkKJALAECgoZCgpBW5P7yjL/AgACAKmA4P8CAAYA4Bjg/wIABAB1QKCMEosQ +/wIADgBvYtDAoGaggFv8RmagetpA/QoEIIAQYDBt2gysqyuwlPe5X3ACAlKwKQoALEDRf8dbHcvE +HsmuLebALebAwCDaIFuSobEiaST1L0DR/wIAAABef9AZykYokoEquv4KiAEoloFbkk3AoGagHRzJ +UCXGcivCdsfbDbsB+8Z2IAAQEDDRDwt5FGP/odKg0Q8fy64uYn8P7iwu7P4OHhT77hEACBB4MPpA +5C4JAHJw/8mQHgkAe7D+9sAkGAA6oP8CAAP/vp6gGcmKKJLAxqL6CgUoAEBSMAqIAiiWwGP/X40R +ghL8CgEg4BBQMP8iEQ3ABD9g+ywADOABbDBbkzn5rAAAQwA2oGee+5kTYAC7W5IoZ69QY/9SZD7q +YADP+EKIKnYBTDAPuxEAsAQICBkICEGYEWP+mQAAihFbkq9j/sQAAAAAAPoK4CIAAFiw/AoDIDAQ +aDBbkyLz/6piAABKsN0g/jwAAAIQUDD8y3gQCBBYMFuYEPP+jm/aEFAw/SwAAAIQUDD8y3MQCBBY +MFuYCWP/4QAA/TwAAAIQUDD8y24QCBBYMFuYA2P/yQAA/TwAAAIQUDD8y2kQCBBYMFuX/WP/sQAA +AAAAAAD9PAAAAhBQMPzLYhAIEFgw+Q4GAgAAEnBbl/Tz/h5iAABQsP08AAACEFAw/MtbEAgQWDBb +l+1j/gEAAGwQChPI2Sgw0RLLVfUyRCBqAH4wJSZ+HMkeGctSKiJ+KSaA/MKOI+gQWDALqiwqNjYL +zCgsJn8LzCz8NjUgABAQMNEPACoayPwK/yAPEFgwW5Sa+woXIgAAIrD6GsggAxBgMFuUlsG5/Aof +IgAAMrD0FgghyBBQMFuUkMG+/AofIgAAIrD2FgchyBBQMFuUi8C4/AoDIgAAMrD0FgYhzBBQMFuU +hvsKFSIAACKw+hrUIAEQYDBblIHBtvwKASIAADqw9BYFIdQQUDBblHwdyyccyyb0okdhgAIjcARu +CS7hftMPDl4s9TJEIbQQUDD+HxQAHhBYMP8mfiD/EGAwW5Rv+woGIgAAOrD6GrggAxBgMFuUasC4 +/AofIgAAMrD3FgQhuBBQMFuUZcC9/AofIgAAOrD2FgMhuBBQMFuUYMG3/AoDIgAAMrD3FgIhuBBQ +MFuUWvoWCSAEEFgw+hrEIAEQYDBblFb7CgUiAAA6sPoaxCABEGAwW5RRZKGBBGsJK7F+DwIAC1ss +FchlKyZ/LFKzLfrADcwB/FazIAEQUDBbkdUuUrPB8A/uAv5WsyABEFAwW5HQHshaGshcLVKyDt0C +LVayLAqALFauKVKvG8hVC5kBKVavHchVjqmIqo+njKb2iBEOIAQ7oPv/EQ4JAEOwD+4CDswCDcwC +LFawG8hMK1axKFKyi6WNqBzIS4qk890RC4AEPuD5yEcaCQBu8PyIAQoJAFqwCogCCYgC+FayIAEQ +UDBbka8oUrIZyEH6yD8QEBBYMP0KeCAQEGAw+YgBABQQcDD4VrIiAAB4cFp6K2Sg2cCi/Mg3EAgQ +WDBbl1Abyr8pUq8sUrD6UrIgfgCicP8CAAAAaz5QLSJ//yJ+KBYBVDD4MkQj6BBwMA7dLA7/LP82 +NioFAE4w/TY1LeAEOuD8JoAgABAQMNEPKTJE/iJ+KIABYDD0iAkMFgFUMPiBfioFAG5w+SJ/I+gQ +aDAN7iwIuCwNmSz+NjYp4AQ6ICgmgPk2NSAAEBAw0Q/AkQeXOWRxA/8CAAAAewXg/wIAA/81AeDz +/m5gABBYMMCxB7c5ZHFG/wIAAABnBeD/AgAD/tSB4PP9rGAAEHAwwaRbkWwsUrPC39MPDcwC/Faz +IBQQUDBbkWdj/xUAH8qDJTJE+odEDuABUDD/7gkGFgFQMPzvUQoFADVw/xYBJioBYDD64X4kgAFk +MFuZDR7KeY0RDt0J/dF+IAAQYDBbmDodynYNfQn90X4gABBgMFuYRB3Kbg1tCf3RfiAAEGAwW5hA +BF0J/dF+IAAQYDBbmDwuIn//In4p4AQ64PgmgCPoEBAwAu4sAv8sLzY2/jY1IAAQEDDRDwAA8/zq +YgAAcXDz/YRiAABZcAAAG8pXihQLqgn6oX4iAABZcFuY6R7KVY0T0w8O3Qn90X4gABBgMFuYFh7K +UY0SDt0J/dF+IAAQYDBbmB8eykmNGdMPDt0J/dF+IAAQYDBbmBoEbQn90X4gABBgMFuYFmP9HAAA +ihgMqgn6oX4iAABZcFuY0R7KPY0X0w8O3Qn90X4gABBgMFuX/h7KOY0WDt0J/dF+IAAQYDBbmAce +yjGNFdMPDt0J/dF+IAAQYDBbmAIEbQn90X4gABBgMFuX/vP8GmIAAHLwbBCGwKD7CgggDxBgMFuT +dxjKJwGiCouBjIAsFgArFgH4ggIiAABqsPgWAiIAW5agIiIA+EoAIABUrKAbyh1yikwssoAYyhwr +soHyzBoAIAJQcCymAPK7GgB/EEgwbZoa+YKAIBACQjD7pgEgEAJSsCuCfwSZjpmgBLuO+6YBICAC +UHBb/CT3oE5iAAASsBvKCiyygBjKCiuygfLMGgAgAlBwLKYA8rsaAH8QSDBtmhr5goAgEAJCMPum +ASAQAlKwK4J/BJmOmaAEu477pgEgIAJQcFv8ENKgx858IRbRDwDRDwDAovzJ9hAIEFgwW5Z8xyvR +D8Ci/MnzEAgQWDBblnjRDwBsEAQZyfAWyIMqkoEqZqb5koIgBBBQMCpmgipmgSpmgCpmkCpmifpm +jCAIEBgw82Z0IAAQQDAoZp8pZqf4x1YQARBIMClmjhLHbBvHbSOA0SIigf7HaxQAEGAw+TQCDAAB +HDD9yzkAGgC8sCtlftEPAAAAAPQCQAQAEHgw9ITRLgUAE/AuZX7RDwAAAGwQBBzJ0BjJzR7Hqv3J +zRAEEFAw+oSCIAAQWDArhUAthh7+hh8ggBB4MFuWScAg0Q8AAABsEAQcycUaycUYycIqxn/6rUAg +iBBYMPqGfyAAEGAwW4+l0Q9sEAYax777rPQgrAA8oGgibokQ9JB5YAICEnD+Ij9gARAgMGAADgAA +AAAAaWQDpaiXgHJLKPo8AAIAAFkwW5Uy+GESYAICITD5Yt9oACAusCeVAGP/26WrJ7QAY//T0Q8r +ongpooCjuwm7Efhha2gAIF5waGJqaWTkpZyXwNEPAPhANGACAhEwckOpY//PAAAsoniEESmyg6PM ++cwRAAICITD4YR1oACBmcGhiHWhkInJDgWP/pwAAGcfeqTkpkOVj/0+lmiekAGP/5KWbJ7UAY//c +pZyXwGP/1aWdJ9QA0Q+lniflANEPIAKRLAzAAAIgBbo0IAKRMAjAAAggBbo0IAKRNDzAAAwgBbmE +IAKROAbAADQgBbuQIAKRPAjAADggBbo0IAKRQALAADwgBbuQIAKRRAjAAEAgBbo0IAKRSAhAAEgg +Bbq8IAKRTAhAAEwgBbq8IAKRUAhAAFAgBbq8IAKRVAhAAFQgBbq8IAKRWCBAAFggBbq8IAKRXCBA +AGggBbq8IAKRYCBAAHggBbq8IAKRZCBAAIggBbq8IAKRaCBAAJggBbq8IAKRbCBAAKggBbq8IAKR +cCBAALggBbq8IAKRdCBAAMggBbq8IAKReAxAANggBbkEIAKRfAxAAOQgBbkEIAKRgAxAAPAgBbkE +IAKRhAxAAPwgBbkEIAKRiAxAAQggBbkEIAKRjAxAARQgBbkEIAKRkAxAASAgBbkEIAKRlAxAASwg +BbkEIAKRmAhAATggBbq8IAKRnAhAATwgBbq8IAKRoAhAAUAgBbq8IAKRpBBAAUQgBbq8IAKRqBBA +AUwgBbq8aW5vZGVfZmMtPmZsb3djX2ZsYWdzIFsweCV4XSwgaW5vZGVfZmMtPmZsb3djX2J1Zi0+ +Zmlmby5udW1fYnl0ZXMgWyV1XQoAAAAAAAAAAABhdXRoZW50aWNhdGVfdGFyZ2V0OiBLRVlfQ0hB +UF9SRVNQIC0gWzB4JXgleCV4JXgleCV4JXgleF0KAAAAAAAAYXV0aGVudGljYXRlX3RhcmdldDog +S0VZX0NIQVBfUkVTUCAtIFsweCV4JXgleCV4JXgleCV4JXhdCgAAAAAAAGF1dGhlbnRpY2F0ZV90 +YXJnZXQ6IEluY29ycmVjdCBwYXNzd29yZAoAAAAAAAAAAHZhbGlkYXRlX2tleXZhbDogS2V5IENI +QVBfQSwgdmFsIFslZF0KAAAAAAAAAAAAAHZhbGlkYXRlX2tleXZhbDogS2V5IENIQVBfSSwgdmFs +IFslZF0KAAAAAAAAAAAAAENIQVBfQzogZGlnZXN0IGV4cGFuc2lvbiBlcnJvcgoAdmFsaWRhdGVf +a2V5dmFsOiBLRVlfQ0hBUF9OQU1FLCBsZW4gWzB4JXhdCgAAAAAAQ0hBUF9OOiBUYXJnZXQgdXNl +cmlkIG1pc21hdGNoCgBDSEFQX1I6IGRpZ2VzdCBleHBhbnNpb24gZXJyb3IKAFJlY2lldmVkIEF1 +dGhNZXRob2QgdmFsdWUKAAAAAAAAdmFsaWRhdGVfa2V5dmFsOiBmbG93Y19mb2lzY3NpX2Nvbm5f +ZmxhZ3MgWzB4JXhdCgAAAAAAAAAAAAAAAAAAAHZhbGlkYXRlX2tleXZhbDogZmxvd2NfZm9pc2Nz +aV9jb25uX2ZsYWdzIFsweCV4XQoAAAAAAAAAAAAAAAAAAABOZWdvIEZCTCBbJXVdCgAAS0VZX01B +WFJDVkRTTCBbJXVdCgAAAAAAAAAAAAAAAABEdXBsaWNhdGUgaXNjc2kga2V5CgAAAAAAAAAAAAAA +AGZvaXNjc2lfcGFyc2VfcmN2ZF9wYXJhbXM6IGVycm9yCgAAAAAAAAAAAAAAAAAAAGZvaXNjc2lf +cGFyc2VfcmN2ZF9wYXJhbXM6IHJsZW4gJWQKAAAAAAAAAAAAAAAAAGFzeW5jX3BkdTogbG9nb3V0 +IHJlcXVlc3RlZCBibG9ja2luZyBzZXNzaW9uCgAAAGFzeW5jX3BkdTogc2Vzcy9jb25uIGRyb3Ag +cmVxdWVzdGVkIGJsb2NraW5nIHNlc3Npb24KAAAAAAAAAAAAAABsb2dpbl9yZXNwOiBmbG93Y19m +b2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhdCgAAAABsb2dpbl9yZXNwOiBmbG93Y19mb2lzY3NpX2Nv +bm5fZmxhZ3MgWzB4JXhdLCByYyBbMHgleF0KAAAAAAAAAAAAaVNDU0kgU2VjLXBhcmFtcyByZWNl +aXZlZGhhdmUgZXJyb3JzISEKAAAAAAAAAAAAVGFyZ2V0IG1vdmVkIHRlbXAuIGNvbm4gJXgsIHNl +c3MgJXgKAAAAAAAAAAAAAAAATG9naW4gRmFpbGVkISEuIGNvbm5fZmMgWzB4JXhdLCBzZXNzX2Zj +IFsweCV4XSwgc3RhdHVzX2NsYXNzIFsweCV4XQoAAAAAAAAAAAAAAABsb2dpbl9yZXNwOiBzZXNz +X2ZjLT5mbG93Y19pZCBbJXVdLCBjb25uX2ZjLT5mbG93Y19pZCBbJXVdIGxvZ2dlZCBpbgoAAAAA +AAAAAAAAAFByb3RvY29sIEVycm9yIGNiaXQgJWQgdGJpdCAlZCBjc2cgJWQgbnNnICVkCgAAAGNv +bm4gdGlkIFsweCV4XSwgcnhfZGF0YS0+c2VxIFsweCV4XSwgcnhfZGF0YS0+bGVuIFsweCV4XSwg +cnhfZGF0YS0+c3RhdHVzIFsweCV4XQoAAAAAAAAAAAAAAAAAAGNza19mYy0+Zmxvd2NfY3NvY2tf +b2Zmc2V0IFsweCV4XSwgZGxlbjE2IFsweCV4XQoAAAAAAAAAAAAAAAAAAABhY3RfZXN0OiBmbG93 +Y19mb2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhdCgAAAAAAAABhY3RfZXN0YWI6IHRjYl9mYy0+Zmxv +d2NfYnVmIFsweCV4XSwgdGNiX2ZjLT5mbG93Y190eXBlIFsweCV4XSB0Y2JfZmMtPmZsb3djX3N0 +YXRlIFsweCV4XSwgbnBhZ2VzIFsweCV4XSwgZmxvd2NfdHBfc25kX21heCBbMHgleF0KAAAAAAAA +AAAAAAAAAABhY3RfZXN0YWI6IGF0aWQgWzB4JXhdLCB0aWQgWzB4JXhdLCBvcCBbMHgleF0sIHJj +dl9pc24gWzB4JXhdLCBzbmRfaXNuIFsweCV4XSwgY3NvY2stPmZsb3djX3N0YXRlIFsweCV4XSwg +dGNwX29wdCBbMHgleF0sIHRjYl9mYy0+Zmxvd2NfaWQgWzB4JXhdIAoAAAAAAAAAAAAAAAAAY3Nr +X2ZjLT5mbG93Y19jc29ja19jb29raWUgWzB4JXhdIAoAAAAAAAAAAAAAAAAAbDNpbjRfZGV2X2Nv +bmZpZzogd3ItPnBhcmFtLnZsYW5pZCBbJXVdLCBsMmRldl9mYy0+Zmxvd2NfbmV0X2wyZGV2X3Zs +YW5kZXYgWzB4JXhdCgAAAAAAAAAAAAAAAAAAbmV0X2wzaW40X2Rldl9jb25maWc6IGwyZGV2X2Zj +LT5mbG93Y19pZCBbMHgleF0sIGFkZHJlc3MgYWxyZWFkeSB1c2VkIGJ5IHBvcnQgJWQKAAAAAAAA +AAAAAAAAAAAAbmV0X2wzaW40X2Rldl9jb25maWc6ICBhZGRyIFsweCV4XSwgbWFzayBbMHgleF0s +IGd3IFsweCV4XSwgcmVmX2NudCBbMHgleF0gaW4gdXNlCgAAAAAAAAAAAAAAAAAAd3JoX2NobmV0 +X2lmY29uZjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgbDJkZXZfZmMtPmZsb3djX3R5cGUg +WyUweF0sIGlmY29uZl93ci0+c3Vib3AgWzB4JXhdCgAAAAAAAAAAAAAAAAAAAHdyaF9jaG5ldF9p +ZmNvbmY6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIHVua25vd24gc3Vib3AgWzB4JXhdCgAA +AAAAAAAAAAAAAAAAd3JoX2NobmV0X2lmY29uZjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwg +cmMgJWQKAAAAAAAAAAAAAAAAAG5ldGlmX2lwX2NvbmZsaWN0X3RpbWVyX2NiOiBsMmRldl9mYy0+ +Zmxvd2NfaWQgWzB4JXhdLCBpbmRldmN0eHQtPnN0YXRlIFslZF0sIGluZGV2Y3R4dC0+cmV0cnlf +Y250IFslZF0KAAAAAAAAAABuZXRpZl9pcF9jb25mbGljdF90aW1lcl9jYjogbDJkZXZfZmMtPmZs +b3djX2lkIFsweCV4XSwgaW5kZXZjdHh0IFsweCV4XSwgaW4gZnJlZSBzdGF0ZQoAAAAAAAAAAABj +bWRoX2NobmV0X2lmYWNlOiBmYyBbMHgleF0sIGZjLT5mbG93Y19pZCBbMHgleF0sIGZjLT5mbG93 +Y190eXBlIFsweCV4XSwgcCBbMHgleF0sIGxlbjE2IFsldV0sIGxvYyBbMHgleF0KAAAAAAAAY21k +aF9jaG5ldF9pZmFjZTpsMmRldl9mYyBbMHgleF0sIGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0s +IGwyZGV2LT5mbG93Y190eXBlIFsldV0sIGwyZGV2X2ZjLT5mbG93Y19uZXRfbDJkZXZfZmxhZ3Mg +WyUweF0KAAAAAABjbWRoX2NobmV0X2lmYWNlOiByMlswXSAldSByMlsxXSAldQoAAAAAAAAAAAAA +AABjbWRoX2NobmV0X2lmYWNlOiBsMmRldl9mYy0+Zmxvd2NfbmV0X2wyZGV2X2ZsYWdzIGNoYW5n +ZWQgZnJvbSBbJTB4XSB0byBbJTB4XSwgcmMgWyVkXQoAAAAAAAAAAABjaG5ldF9sMmRldl91cF9t +Yl9jYjogcmMgWyVkXSwgcG9ydCBbJXVdLCBzdGF0ZSBbJXVdLCBjb29raWUgWzB4JXhdCgAAAAAA +AAAAAAAAAGNobmV0X3F1ZXVlX3htaXQ6IGZjLT5mbG93Y19pZCBbMHgleF0sIGJ1Zl9sZW4gWzB4 +JXhdLCBidWZmZXJlZCBbMHgleF0sIGZpZm8ubnVtX2J5dGVzIFslMHhdCgAAAGRoY3BfcHJvY2Vz +c19jYjogbDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgZGhjdHh0LT5zdGF0ZSBbJTB4XSwgZGhj +dHh0LT5ydHJ5X2NudCBbJXVdCgAAAAAAAAAAAGRoY3BfdGltZXJfY2I6IERIQ1BESVNDT1ZFUiBz +ZW50LCBidXQgbm8gcmVwbHkgZnJvbSBhbnkgcG9zc2libGUgc2VydmVyIG9uIHRoZSBuZXR3b3Jr +LiBSZXRyeWluZyBhZ2FpbgoAAAAAAAAAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2Nf +aWQgWzB4JXhdLCBzZW5kaW5nIERIQ1BESVNDT1ZFUiBmb3IgZGhjdHh0IFsweCV4XSBvbiBwaWQg +WyVkXQoAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBESENQT0ZG +RVIgcmVjZWl2ZWQgZm9yIGRoY3R4dCBbJXhdIHBpZCBbJWRdCgAAAAAAAAAAAABkaGNwX3RpbWVy +X2NiOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCAgREhDUEFDSyByZWNlaXZlZCBmb3IgZGhj +dHh0IFsleF0sIHBpZCBbJWRdCgAAAAAAAAAAAABkaGNwX3RpbWVyX2NiOiBsMmRldl9mYy0+Zmxv +d2NfaWQgWzB4JXhdLCBkaGN0eHQtPmlwYWRkciBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAGRoY3Bf +dGltZXJfY2I6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIG5vIHJlcGx5IGZyb20gZGhjcCBz +ZXJ2ZXIsIHRpbWluZyBvdXQKAAAAAAAAAAAAAAAAAAAAAGxvZ2luX3BhcmFtczogY29ubl9mYy0+ +Zmxvd2NfZm9pc2NzaV9jb25uX2ZsYWdzIFsweCV4XQoAAAAAAAAAAABsb2dpbl9wYXJhbXM6IGNv +bm5fZmMtPmZsb3djX2ZvaXNjc2lfY29ubl9mbGFncyBbMHgleF0KAAAAAAAAAAAAYXV0aF9uZWdv +X3NlY3VyaXR5OiBzZW5kX2ZsYWcgWzB4JXhdLCBhdXRoX3BvbGljeSBbMHgleF0KAAAAAAAAAGF1 +dGhfbmVnb19zZWN1cml0eTogS0VZX0NIQVBfUkVTUCAtIGhhc2hbMHgleCV4JXgleCV4JXgleCV4 +XQoAAABhdXRoX25lZ29fc2VjdXJpdHk6IEtFWV9DSEFQX1JFU1AgLSBoYXNoWzB4JXgleCV4JXgl +eCV4JXgleF0KAAAAYXV0aF9uZWdvX3NlY3VyaXR5OiBLRVlfQ0hBUF9SRVNQIC0gZXJyb3IgZW5j +b2RpbmcgdG8gaGV4CgAAAAAAAGF1dGhfbmVnb19zZWN1cml0eTogS0VZX0NIQVBfUkVTUCAtIGVs +ZW4gWzB4JXhdCgAAAAAAAAAAAAAAAAAAAABhdXRoX25lZ29fc2VjdXJpdHk6IEtFWV9DSEFQX0NI +QUwgLSBlcnJvciBlbmNvZGluZyB0byBoZXgKAAAAAAAAYXV0aF9uZWdvX3NlY3VyaXR5OiBLRVlf +Q0hBUF9DSEFMIC0gZWxlbiBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAHNlbmRfbG9naW5fcmVxdWVz +dDpjb25uX2ZjLT5mbG93Y19pZCBbMHgleF0sIHNlc3NfZmMtPmZsb3djX2lkIFsweCV4XSwgY3Ry +bF94bWl0IFsweCV4XSwgc2Vzc19mYy0+Zmxvd2NfZm9pc2NzaV9zZXNzX3R5cGUgWzB4JXhdCgAA +AAAAAAAAAAAAAAAAAHNlbmRfbG9naW5fcmVxdWVzdDogZmxhZyBbMHgleF0uCgAAAAAAAAAAAAAA +AAAAAHNlbmRfbG9naW5fcmVxdWVzdDogdHhfbGVuIFsldV0KAAAAAAAAAAAAAAAAAAAAAHhtaXRf +c2VuZHRhcmdldHM6IGNvbm4gdGlkIFsweCV4XSwgY3RybF94bWl0LT50dHQgWzB4JXhdLCBkYXRh +X2xlbiBbJXVdLCBwYWRfbGVuIFsldV0KAAAAAAAAAAAAAHBpbmdfdGFyZ2V0OiBwaW5nIHRpbWVv +dXQgYmxvY2tpbmcgc2Vzc2lvbgoAAAAAAHNlbmRfbm9wX291dDogY29ubiBmbG93X2lkIFsweCV4 +XSwgcmVxIFsldV0sIHR0dCBbMHgleF0KAAAAAAAAAABjc29ja19mYWlsZWQ6IGNza19mYy0+Zmxv +d2NfaWQgWzB4JXhdLCBjc2tfZmMtPmZsb3djX3N0YXRlIFsweCV4XSwgc2Vzc19mYy0+Zmxvd2Nf +aWQgWzB4JXhdLCBzZXNzX2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0sIGV2dCBbMHgleF0KAAAAAAAA +AAAAAABjb3NrY19mYWlsZWQ6IHNlc3Npb24gYmxvY2ssIGV2ZW50IFsweCV4XQoAAAAAAABjb3Nr +Y19mYWlsZWQ6IHNlc3Npb24gYmxvY2ssIGV2ZW50IFsweCV4XQoAAAAAAABjaG5ldF9maW5kX2wy +dF9lbnRyeTogZGFkZHIgWyUwOHhdLCBbMHglMDh4XSwgbG9jYWwgbmV0d29yayBbJWRdCgAAAAAA +AAAAAAAAAAAAAGwydGVudCBbJTB4XSwgbDJ0ZW50LT5pZHggWyVkXQoAcmMgWyVkXSwgY3NrX2Zj +IFsweCV4XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0KAAAAAAAAAAAAAAAAAAAAAGNzb2NrX2Zy +ZWU6IHNpemVvZihjc2tfZmMtPnUuY3NvY2spIFsldV0sIGJ5dGVzCgAAAAAAAAAAAAAAAAAAAABU +Q1AgY29ubiBlc3RhYmxpc2htZW50IGZhaWxlZCAlZAoAAAAAAAAAAAAAAAAAAABJbnZhbGlkIG9w +Y29kZSAweCV4IGluIGN0cmwgcGF0aAoAAAAAAAAAAAAAAAAAAABERFAgZXJyb3IgWzB4JXhdLCBh +Ym9ydGluZyBjb25ubiBbMHgleF0KAAAAAAAAAABpc2NzaV9oZHI6IGJhZCB0Y2Igc3RhdGUgdG8g +cnggZGF0YSwgdGNiX2ZjLT5mbG93Y19pZCBbMHgleF0sIHRjYl9mYy0+Zmxvd2Nfc3RhdGUgWzB4 +JXhdCgAAAAAAAABpc2NzaV9oZHJfcng6IEludmFsaWQgdGFzayBzdGF0ZSAweCV4IGZvciB0YXNr +IDB4JXgKAAAAAAAAAAAAAAAAaXNjc2lfZGF0YTogcmN2ZCBwYXlsb2FkCgAAAAAAAABkcm9wX2Fs +bF90YXNrOiByZXF1ZXN0ZWQgbGlkeCBbJXVdCgAAAAAAAAAAAAAAAABnZXRfcmVmX3Rhc2s6IGlz +dGFzay0+Zmxvd2NfaWQgWzB4JXhdLCBpc3Rhc2tfZmMtPmZsb3djX3N0YXRlIFsldV0sIGFicnRf +bGlkeCBbMHgleF0sIGxpZHggWzB4JXhdCgAAAAAAAAAAAAAAAAAAcHJvY2Vzc190bWZfcmVzcG9u +c2U6IGlzdGFza19mYy0+Zmxvd2NfYnVmLT5zY2hlZF9ub2RlLm5leHQgWzB4JXhdLCBpc3Rhc2tf +ZmMgWzB4JXhdLCBpc3Rhc2tfZmMtPmZsb3djX2lkIFsldV0KAHByb2Nlc3NfdG1mX3Jlc3BvbnNl +OiB1bHB0eHBsZW4xNiBbJXVdCgAAAAAAAAAAAHByb2Nlc3NfdG1mX3Jlc3BvbnNlOiBkZWxheV9w +cm9jZXNzaW5nLCBvcCBbJXhdCgAAAAAAAAAAAAAAAAAAAABwcm9jZXNzX3RtZl9yZXNwb25zZTo6 +IHdyIG9wY29kZSBbMHgleF0KAAAAAAAAAABwcm9jZXNzX3RtZl9yZXNwb25zZTo6IHRhc2sgZnVu +Y3Rpb24gWzB4JXhdCgAAAABjYWxsaW5nIGRyb3BfdGFzaywgbGlkeCBbMHgleF0KAHdyaF9mb2lz +Y3NpX25vZGU6IG5vZGVfd3ItPmZsb3dpZF9sZW4xNiAyIFsleF0KAHdyaF9mb2lzY3NpX2NoYXA6 +IGlkX2xlbiBbJXhdLCBzZWNfbGVuIFsleF0KAAAAAHdyaF9mb2lzY3NpX2NoYXA6IHRndF9pZF9s +ZW4gWyV4XSwgdGd0X3NlY19sZW4gWyV4XQoAAAAAAAAAAAAAAABwZWVyX2NvbjogY3NrX2ZjID0+ +IGZsb3dpZCBbMHgleF0sIGZsb3djX2J1ZiBbMHgleF0KAAAAAAAAAAAAAAAAZm9pc2NzaV9jdHJs +OiBzdWJvcCBbMHgleF0sIHNlc3NfdHlwZV90b19lcmwgWzB4JXhdLCBzZXNzX3R5cGUgWzB4JXhd +CgAAAAAAAAAAAAB3YXRjaGRvZyBjbWQgaGFuZGxlciAodGltZSAldSBhY3Rpb24gJXUpCgAAAAAA +AABXQVRDSERPRzogZGV2aWNlIHNodXRkb3duCgAAAAAAAFdBVENIRE9HOiBieXBhc3MgdGltZW91 +dAoAAAAAAAAAV0FUQ0hET0c6IEZMUiAtIG5vdCBpbXBsZW1lbnRlZCB5ZXQKAAAAAAAAAAAAAAAA +V0FUQ0hET0c6IHRlbXBlcmF0dXJlIG9mICVkQyBleGNlZWRzIHRocmVzaG9sZCBvZiAlZEMKAAAA +AAAAAAAAAGZpbHRlcjogcG9yZ3JhbW1pbmcgdGlkICV1IChsZSB0Y2FtIGluZGV4ICV1KS4uLgoA +AAAAAAAAAAAAAAAAAABmaWx0ZXI6IHJlcXVlc3RpbmcgY29tcGxldGlvbi4uLgoAAAAAAAAAAAAA +AAAAAABGQ09FIEZyZWU6IHN0aWxsIHlpZWxkZWQgd2hlbiBmcmVlaW5nLi4uZmxvd2NfaWQgJXgg +Zmxvd2NfZmxhZ3MgJXggCgAAAAAAAAAAAAAAAHBvcnQgJWQgcHJpb3IgJWQgc2VsZWN0ICVkIHBy +b3RvY29sSUQgMHglMDR4CgAAAHBvcnQgJWQgc2V0IHBmY19lbiA9IDB4JXgKAAAAAAAAcG9ydCAl +ZCBzZXQgcGdpZF8wXzcgPSAweCUwOHggcGdfcGVyY2VudGFnZSAweCUwOHhfJTA4eCBudW1fdGNz +X3N1cHBvcnRlZCAlZAoAAABwb3J0ICVkIHNldCBwZmNfZW4gPSAweCV4CgAAAAAAAEZDb0UgRERQ +IGZhaWxlZCA6IG94X2lkIDB4JXggcnhfaWQgMHgleAoAAAAAAAAAAEZDb0UgRERQIGZhaWxlZCA6 +IERkcFJlcG9ydCAweCV4IERkcFZhbGlkIDB4JXgKAFBSTEkgUnNwIHRpbWVkb3V0IDogZmxvd2Nf +aWQgMHgleCBveF9pZCAweCV4IHJ4X2lkIDB4JXggCgAAAAAAAABjYW5ub3QgYWxsb2NhdGUgb2Zm +bG9hZGVkIGZpbHRlciBjb25uZWN0aW9uCgAAAABjYW5ub3QgYWxsb2NhdGUgb2ZmbG9hZGVkIGZp +bHRlciBJUHY2IGNvbm5lY3Rpb24KAAAAAAAAAAAAAAAAAAAAdW9bJXVdOiB3ciAlcCB3ci0+bGVu +Z3RoICV1IG1zcyAldQoAAAAAAAAAAAAAAAAAdW9bJXVdOiBmIDB4JTA4eCBkc3RfY3BsIDB4JTA4 +eCBzcmNfY3BsIDB4JTA4eCBpbW1kbGVuMTYgJXUKAAAAAHVvWyV1XTogbGFzdCBtc3MgJXUKAAAA +AAAAAAAAAAAAdW9bJXVdOiAhbGFzdCB3ci0+c2NoZWRwa3RzaXplICV1CgAAAAAAAAAAAAAAAAAA +aW52YWxpZCBidWZmZXIgZ3JvdXBbJXVdIGNvbmZpZ3VyYXRpb246IG10dSAldSBsd20gJXUgaHdt +ICV1IGR3bSAldQoAAAAAAAAAAAAAAABmYyAldSB2ZiAldSBnb3QgaXZmPTB4JXgscmFuZ2U6ICUj +eC0lI3ggKCV1LyV1IHVzZWQpCgAAAAAAAAAAAAAAVkkgJXUgY2Fubm90IGdldCBSU1Mgc2xpY2U6 +IE5vIG1vcmUgc2xpY2VzIGF2YWlsYWJsZSAodXNlZCAldS8ldSkKAAAAAAAAAAAAAAAAAABwZm4g +JXUgdmZuICV1IHdpdGggcG9ydCBtYXNrIDB4JXggY2Fubm90IGFjY2VzcyBwb3J0ICV1LCByZXQg +JWQKAAAAAAAAAAAAAAAAAAAAAHBmbiAldSB2Zm4gJXUgY291bGQgbm90IGFsbG9jYXRlIHZpaWQs +IHJldCAlZAoAAHBmbiAldSB2Zm4gJXUgY291bGQgbWFwIHZpaWQgIDB4JXggdG8gZmxvd2MsIHJl +dCAlZAoAAAAAAAAAAAAAAABwZm4gJXUgdmZuICV1IGNvdWxkIG5vdCBhbGxvY2F0ZSB1d2lyZSBm +dW5jICVkIG1hYyBhZGRyLCByZXQgJWQKAAAAAAAAAAAAAAAAAAAAAG1paV9mb3JjZV9zcGVlZFsl +dV06IHJjYXBzIDB4JXgKAAAAAAAAAAAAAAAAAAAAAG1paV9saW5rX3N0YXR1c1sldV06IGJtc3Ig +MHglMDh4IHN0YXR1cyAldSBtYWNfbHMgMHglMDh4CgAAAAAAAABwb3J0X2NtZF9oYW5kbGVyOiB1 +bmtub3duIHUuZGNiLnR5cGUgMHgleAoAAAAAAABwb3J0WyV1OjB4JTAyeDoweCUwMnhdOiBwaHkg +cmVzZXQgbm90IGF2YWlsYWJsZQoAAAAAAAAAAAAAAAAAAAAAcG9ydFsldToweCUwMng6MHglMDJ4 +XTogdW5rbm93biBhY3Rpb24gMHgleAoAAAAAcG9ydFsldToweCUwMng6MHglMDJ4XTogdW5rbm93 +biByZWFkIGFjdGlvbiAweCV4CgAAAAAAAAAAAAAAAAAAAGNwbF9lcnJfbm90aWZ5OiB0aWQgJXUg +Y3BsIDB4JTA4eCUwOHgKAAAAAAAAAAAAAGNwbF9lcnJfbm90aWZ5OiB0aWQgJXUgY3BsIDB4JTA4 +eCUwOHggMHglMDh4JTA4eAoAAAAAAAAAAAAAAAAAAABjcGxfZXJyX25vdGlmeTogdGlkICV1IGxl +biAldQoAAEZDT0UgRnJlZTogc3RpbGwgeWllbGRlZCB3aGVuIGZyZWVpbmcuLi5mbG93Y19pZCAl +eCBmbG93Y19mbGFncyAleCAKAAAAAAAAAAAAAAAARkNPRSBCUCBXUiBFUlI6IFdSIHdpdGggY29v +a2llICV4JXggZXJyb3JlZCBiYWNrIAoAAAAAAAAAAAAAAAAAAHNjc2lfYWJvcnQ6IEVudGVyaW5n +IEFib3J0X3Rhc2ssIGJ1ZmZlcmVkIFsldV0KAHNjc2lfYWJvcnQ6OiB3ci0+aXFpZCBbMHgleF0s +IGlzdGFza19mYy0+Zmxvd2Nfc2dlX2lxaWQgWzB4JXhdCgBzY3NpX2Fib3J0OjogbHVuX2lkeCBb +MHgleF0KAAAAAHNjc2lfYWJvcnQ6IHJlZiB0YXNrIG5vdCBvdXRzdGFuZGluZwoAAAAAAAAAAAAA +AHNjc2lfYWJvcnQ6IHNyZXEtPm9wY29kZSBbMHgleF0gZmxhZ3MgWzB4JXhdCgAAAHNjc2lfYWJv +cnQ6IHRhc2tfaWR4IFsldV0sIGl0dCBbMHgleF0KAAAAAAAAAAAAAGFib3J0L2Nsb3NlIFdSIHdp +dGggY29va2llIDB4JWx4IHdhcyBpc3N1ZWQgb24gc3NuIDB4JXggaW4gd3Jvbmcgc3RhdGUgMHgl +eAoAAAAAYWJvcnQgV1Igb24gc3NuIDB4JXggZGlkIG5vdCBmaW5kIFdSIHdpdGggY29va2llIDB4 +JXgleAoAAAAAAAAAAGNsb3NlIFdSIHdpdGggY29va2llIDB4JWx4IG9uIHNzbiAweCV4O2RpZCBu +b3QgZmluZCBXUiB3aXRoIGNvb2tpZSAweCVseAoAAAAAAAAAYWJvcnQgV1Igb24gc3NuIDB4JXgg +d2FzIGlzc3VlZCBvbiB4Y2hnIDB4JXggd2l0aCByeF9pZCAweCV4IGluIHdyb25nIHN0YXRlIDB4 +JXgKAAAAAAAAAAAAAAAAAAAAcG9ydCAlZCBhcHBsSUQgMHglMDR4IG91aSAweCUwNnggdXNlcl9w +cmlvciAlZAoAc2VuZCBkY2J4IGluZm86Zmxvd2NpZCAldQoAAAAAAABzZW5kIGRjYnggY29tcGxl +dGUKAAAAAAAAAAAAAAAAAERDQlggcG9ydCAldSBhbGxfc3luY2QgPSAldQoAAAAAY2huZXRfbDJ0 +X3VwZGF0ZTogbDJ0X3VwZGF0ZSByZXF1ZXN0IHNlbnQgbDJ0ZW50IFslMDh4XSwgbDJ0ZW50LT5p +ZHggWyVkXSwgbDJ0ZW50LT52bGFuIFslZF0KAAAAbmV0aWZfcHJvY2Vzc19kaGNwOiBsMmRldl9m +Yy0+Zmxvd2NfaWQgWzB4JXhdLCBwcm9jZXNzaW5nLCBvcHRfbGVuICV1CgAAAAAAAAAAAABjaG5l +dF9kaGNwX3JlY3Y6IHZsYW5pZCBbJXVdLCBsMmRldl9waWRfZmMtPmZsb3djX25ldF9sMmRldl92 +bGFuZGV2IFsweCV4XSwgbDJkZXZfZmMgWzB4JXhdCgAAAABjaG5ldF9kaGNwX3JlY3Y6IGwyZGV2 +X2ZjLT5mbG93Y19pZCBbMHgleF0sIGRoY3R4dC0+c3RhdGUgWyVkXSwgbWFsYWNpb3VzIGRoY3Ag +cmVjdiBmb3Igbm8gcmVxdWVzdAoAAAAAAAAAAAAAAAAAZGhjdHh0LT5zdGF0ZSA6ICVkCgAAAAAA +AAAAAAAAAABsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBCYWQgREhDUCBjb29raWUgcmVjaWV2 +ZWQsIGFib3J0aW5nCgAATl9QT1JUIDB4JXgleCV4IHJlamVjdGVkIFBMT0dJIHdpdGggcmVhc29u +IGNvZGUgJXgKAAAAAAAAAAAAAAAAAEFCVFMgd2hpbGUgYXdhaXRpbmcgUFJMSSBSc3A6IGZsb3dj +X2lkIDB4JXggb3hfaWQgMHgleCByeF9pZCAweCV4IAoAAAAAAAAAAAAAAAAAQUJUUyBmYWtlIFJz +cDogbG9jIDB4JXggb3hfaWQgMHgleCByeF9pZCAweCV4CgAAcmVsZWFzZV90aWQ6IHNpemVvZih0 +Y2JfZmMtPmZsb3djX2ZvaXNjc2lfY29ubikgWyV1XSwgYnl0ZXMKAAAAAGFjdF9vcGVuX3JwbDog +YXRpZCBbMHgleF0sIHRpZCBbMHgleF0sIG9wIFsweCV4XSwgc3RhdHVzIFsweCV4XQoAAAAAAAAA +AAAAAAAAAAAAYWN0X29wZW5fcnBsOiBjc2tfZmMtPnRjYl9zdGF0ZSBbMHgleF0sIGNza19mYy0+ +ZmxhZ3MgWzB4JXhdLCB0Y2JfZmMtPmZsb3djX3N0YXRlIFsweCV4XQoAAAAAAAAAc2VuZF9hYm9y +dF9ycGw6IGNza19mYy0+Zmxvd2NfdHlwZSBbMHgleF0sIGNza19mYy0+Zmxvd2NfaWQgWzB4JXhd +LCB0aWQgWzB4JXhdLCB1bHB0eGNoIFsldV0sIGJ1ZmZlcmVkIFsldV0KAAAAAHdyaF9vZmxkX3Rj +cF9jbG9zZV9jb25fcmVwbHk6IHRjYl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCB0Y2JfZmMtPmZsb3dj +X3R5cGUgWzB4JXhdLCBsZW4xNiBbJXVdLCBsb2MgWyV1XQoAAAAAAAAAAAB3cmhfb2ZsZF90Y3Bf +Y2xvc2VfY29uX3JlcGx5OiBycGwtPm9wX1RpZCBbMHgleF0sIHJwbD5zdGF0dXMgWzB4JXhdLCBy +cGwtPnNuZF9ueHQgWzB4JXhdLCBycGwtPnJjdl9ueHQgWzB4JXhdCgAAdGNwX2Fib3J0X3JwbF9y +c3M6IHRpZCBbMHgleF0sIHN0YXR1cyBbMHgleF0KAAAAdGNwX2Fib3J0X3JlcV9yc3M6IHRpZCBb +MHgleF0sIHN0YXR1cyBbMHgleF0KAAAAcGt0c2NoZWRfY2xfcmxbJXU6JXVdOiBtb2RlIHwgdW5p +dCB8IHJhdGUgMHglMDZ4IG1pbiAldSBtYXggJXUgcGt0c2l6ZSAldQoAAAAAAABwYXJhbV9kbWFx +WzB4JXg6MHgleF06IGRtYXEgMHgleCByZWFkICV1IHBmICV1IHJldCAlZAoAAAAAAAAAAAAATUNb +JXVdIGluaXRfc3RhdGVfbWFjaGluZSAweCUwMngKAAAAAAAAAAAAAAAAAAAATUMgaW5pdGlhbGl6 +YXRpb24gbm90IGNvbXBsZXRpbmcsIE1DIGN1cnJlbnQgaW5pdCBzdGF0ZSBpcyAweCUwMngKAAAA +AAAAAAAAAAAAAABNQ1sldV0gX2h3X21jX2luaXRfbWMKAAAAAAAAAAAAAF9od19tY19pbml0X21j +X2ZwZ2FbJXVdOiBlcnJvciAlZAoAAAAAAAAAAAAAAAAAAGh3X2xlX2ZpbHRlcl9jdHVwbGU6IHR1 +cGxlICV1IG5vdCBzcGVjaWZpZWQgYnV0IHJlcXVpcmVkIGZvciBtYXNrIDB4JXgKAAAAAAAAAAAA +bGUgY29uZmlndXJhdGlvbjogaGFzaCByZWdpb24gdG9vIGxhcmdlIHRvIGVuYWJsZSBzZXJ2ZXIg +c3JhbQoAAGxlIGNvbmZpZ3VyYXRpb246IGNhbm5vdCBlbmFibGUgc2VydmVyIHNyYW0gd2hlbiBo +YXNoIHJlZ2lvbiBpcyBkaXNhYmxlZAoAAAAAAAAAbGUgY29uZmlndXJhdGlvbjogbmVudHJpZXMg +JXUgcm91dGUgJXUgY2xpcCAldSBmaWx0ZXIgJXUgYWN0aXZlICV1IHNlcnZlciAldSBoYXNoICV1 +CgAAAAAAAAAAAAAAbGUgY29uZmlndXJhdGlvbjogbmVudHJpZXMgJXUgcm91dGUgJXUgY2xpcCAl +dSBmaWx0ZXIgJXUgc2VydmVyICV1IGFjdGl2ZSAldSBoYXNoICV1IG5zZXJ2ZXJzcmFtICV1CgAA +AAAAAAAAAAAAAGNmX3BhcnNlOiBmaWxlIG1lbXR5cGUgMHgleCBtZW1hZGRyIDB4JXggbWFwcGVk +IEAgJXA6CgAAAAAAAAAAAABjb25maWd1cmVkIHdpdGggY2FwcyBuYm18bGluayAweCUwOHggc3dp +dGNofG5pYyAweCUwOHggdG9lfHJkbWEgMHglMDh4IGlzY3NpfGZjb2UgMHglMDh4CgAAAAAAAABu +ZXQgVkkgYWxsb2NhdGlvbiBmYWlsZWQgZm9yIGZjX2lkICV1IHdpdGggZXJyb3IgJWQKAAAAAAAA +AAAAAAAAbmV0IFZJIG1hYyBhZGRyZXNzIHByb2dyYW1taW5nIGZhaWxlZCBmb3IgZmNfaWQgJXUg +d2l0aCBlcnJvciAlZAoAAAAAAAAAAAAAAAAAAABuZXQgVkkgcnhtb2RlIHByb2dyYW1taW5nIGZh +aWxlZCBmb3IgZmNfaWQgJXUgd2l0aCBlcnJvciAlZAoAAAAAbmV0IFZJIHJzcyBpbmRpcmVjdGlv +biB0YWJsZSBwcm9ncmFtbWluZyBmb3IgZmNfaWQgJXUgZmFpbGVkIHdpdGggZXJyb3IgJWQKAAAA +AABuZXQgVkkgcnNzIGNvbmZpZyBjb21tYW5kIGZhaWxlZCBmb3IgZmNfaWQgJXUgd2l0aCBlcnJv +ciAlZAoAAAAAbmV0IFZJIGNvbW1hbmQgZmFpbGVkIGZvciBmY19pZCAldSB3aXRoIGVycm9yICVk +CgAAAAAAAAAAAAAAAAAAAHBwbWF4IFsldV0sIGJpdHMgWyV1XSwgRldfSVNDU0lfUEFHRVBPRF9U +QUdfSURYX01BWF9TSVpFIFsldV0KAABkZWZhdWx0IHRhZ21hc2sgWzB4JTB4XQoAAAAAAAAAAHBy +b2dyYW1tZWQgdGFnbWFzayBbMHglMHhdCgAAAAAAcHBtLT5kZHBfaW5mby5sbGltaXQgWzB4JTB4 +XSwgcHBtLT5kZHBfaW5mby51bGltaXQgWzB4JTB4XSwgcHBtLT5kZHBfaW5mby5zaXplIFsweCUw +eF0KAAAAAAAAAAAAcHBtLT5kZHBfaW5mby5tYXhfdHhzeiBbMHglMHhdIHBwbS0+ZGRwX2luZm8u +bWF4X3J4c3ogWzB4JTB4XSBpb3NpemUgWzB4JTB4XQoAAABwcG1heCBbJXVdLCBpZHhfYml0cyBb +JXVdLCBpZHhfbWFzayBbMHglMHhdLCByZXN2ZF90YWdfbWFzayBbMHglMHhdLCB0YWdtYXNrIFsw +eCUweF0KAAAAAAAAAAAAAAB0YWcgaXR0IDB4JTB4LCBiaXRzICV1LCBhZ2UgMHglMHgsIGJpdHMg +JXUKAAAAAABjeGNuaWMtPmlzY3NpX3BwbSBbMHglMHhdCgAAAAAAAHNjc2lfcGxkX3NpemUgWyV1 +XSwgQUxJR04oc2NzaV9wbGRfc2l6ZSwgMTYpIFsldV0KAAAAAAAAAAAAAAAAAABtYXhfcHBvZF96 +b25lcyBbJXVdCgAAAAAAAAAAAAAAAGZvaXNjc2lfaW5pdDogZm9pc2NzaV9pbml0X2RvbmUgWyV1 +XSwgZGV2LnJlcy5mb2lzY3NpX250YXNrcyBbJXVdLCBkZXYucmVzLmZvaXNjc2lfbnNlc3MgWyV1 +XSwgZGV2LnJlcy5uY3NvY2sgWyV1XSwgZGV2LnJlcy5mb2lzY3NpX25pbml0IFsldV0sIHJjIFsl +ZF0KAAAAAAAAAABjaF9jbF9yYXRlWyV1LyV1XTogY2FwcGVkIGNsYXNzIHJhdGUgZnJvbSByZXF1 +ZXN0ZWQgJXUgdG8gY29uZmlndXJlZCAoZWZmZWN0aXZlKSBjaGFubmVsIHJhdGUgJXUKAAAAAAAA +AAAAAAAAAAAAY2hfY2xfcmF0ZVsldS8ldV06IGluY3JlYXNlZCBkZWZpY2l0X2luY3IgZnJvbSBy +ZXF1ZXN0ZWQgJXUgdG8gcmVxdWlyZWQgbWluIG9mICV1OyByYXRlICV1IChlZmYgJXUpIGRlZmlj +aXRfbWF4ICV1CgAAAAAAAAAAAAAAAABwa3RzY2hlZCBjaGFubmVsICV1IHNldHMgc3BlZWQgKGZy +b20gJXUpIHRvICV1IGticHMKAAAAAAAAAAAAAAAAcG9ydF9jbWRfaGFuZGxlcjogdW5rbm93biB1 +LmRjYi50eXBlIDB4JXgKAAAAAAAAaTJjIGVycm9yIGNhdXNlZCBieSBtb2R1bGUgdW5wbHVnCgAA +AAAAAAAAAAAAAAAAc2VuZHRvIHBlbmRpbmc6IHdyX3BlbmQgJXAgZm9yIHBvcnQgJXUsICB3YW50 +IHRvIHNlbmQgdG8gcG9ydCAldQoAAAAAAAAAAAAAAAAAAABzZW5kdG86Zmxvd2NpZCAldQoAAAAA +AAAAAAAAAAAAAHBvcnRfbGlua19zdGF0ZV9oYW5kbGVyWyV1XSBsZWF2aW5nIFNUQVRFX1VQICg9 +PnBvd2VyZG93bikKAAAAAABwb3J0X2xpbmtfc3RhdGVfaGFuZGxlclsldV0gcG93ZXJpbmcgZG93 +bgoAAAAAAABwb3J0X2xpbmtfc3RhdGVfaGFuZGxlclsldV0gbGVhdmluZyBwb3dlcmRvd24gKD0+ +ZG93bikKAAAAAAAAAAAAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXJbJXVdIGxlYXZpbmcgU1RBVEVf +RE9XTiAoPT5wb3dlcnVwKQoAAAAAAHBvcnRfbGlua19zdGF0ZV9oYW5kbGVyWyV1XSBwb3dlcmlu +ZyB1cAoAAAAAAAAAAHBvcnRfbGlua19zdGF0ZV9oYW5kbGVyIGxlYXZpbmcgcG93ZXJ1cCAoPT51 +cCkKAHBvcnRfbGlua19zdGF0ZV9oYW5kbGVyWyV1XSBvaCBteSB3aGF0IGlzIGdvaW5nIG9uIChz +dGF0ZSA9ICUjeAoAAAAAAAAAAAAAAAAAAAAAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXIgZ290IHJl +c2NoZWR1bGVkCgAAAAAAAAAAcG9ydF9saW5rX3N0YXRlX2hhbmRsZXI6IFNvbWV0aGluZyB3ZW50 +IHRlcnJpYmx5IHdyb25nLiByZXQgPSAlZAoAAAAAAAAAAAAAAAAAAABod19zZ2VfbWFtZW1faW5p +dDogZW5jb3VudGVyZWQgZXJyb3IgJWQKAAAAAAAAAABsZSBpbml0aWFsaXphdGlvbjogbmVudHJp +ZXMgJXUgcm91dGUgJXUgY2xpcCAldSBmaWx0ZXIgJXUgYWN0aXZlICV1IHNlcnZlciAldSBoYXNo +ICV1CgAAAAAAAAAAAABsZSBpbml0aWFsaXphdGlvbjogbmVudHJpZXMgJXUgcm91dGUgJXUgY2xp +cCAldSBmaWx0ZXIgJXUgc2VydmVyICV1IGFjdGl2ZSAldSBoYXNoICV1IG5zZXJ2ZXJzcmFtICV1 +CgAAAAAAAAAAAAAAdHAgY2hhbm5lbCBjb25maWd1cmF0aW9uOiAldSByeCBhbmQgJXUgdHggY2hh +bm5lbHMKAAAAAAAAAAAAAAAAAHRwIG1lbSBkaXN0cmlidXRpb25bJSVdIHBtdHggJXUgcG1yeCAl +dSBkZHAgJXUgZGRwX2lzY3NpICV1IHN0YWcgJXUgcGJsICV1IHJxICV1IHJxdWRwICV1CgAAAAAA +AFRQX1BNTV9SWF9QQUdFX1NJWkUgJXUgaXMgbm90IHN1cHBvcnRlZAoAAAAAAAAAAFRQX1BNTV9U +WF9QQUdFX1NJWkUgJXUgaXMgbm90IHN1cHBvcnRlZAoAAAAAAAAAAGN4Y25pY19kZXZpY2VfaW5p +dDogY3hjbmljIFsweCUweF0sIGN4Y25pYy0+ZmlsdGVyIFslMHhdCgAAAAAAAABjeGNuaWNfZGV2 +aWNlX2luaXQ6IGRldi50cC5udW1fdHhfcGFnZXMgWyV1XSwgZGV2Lm1jWzBdLnNpemUgWyV1XSwg +ZGV2LnRwLnR4X3BhZ2Vfc3ogWyV1XSwgY3hjbmljIHNpemUgWyVkXSwgcmMgWyVkXQoAAAAAAAAA +AAAAAFBvcnRbJXVdOiBVbmtub3duIFNHTUlJIHN1Yi10eXBlICUjeAoAAAAAAAAAAAAAAHBvcnRf +aW5pdFsldV06IHBvcnQgdHlwZSAweCV4IGlzIG5vdCBzdXBwb3J0ZWQKAEVRIHBmbiAldSB2Zm4g +JXU6IGRlc3Ryb3lpbmcgZXFpZCAldSB3aXRoIHBlbmRpbmcgV1IocykgKG51bV9ieXRlcyAldSBh +bmQgZmxhZ3MgMHglMDh4CgAAAAAAAAAAAGwyZGV2X2ZjLT5mbG93Y19pZCBbJXVdLCBsMmRjLT5w +Zm4gWyV1XSwgbDJkYy0+dmZuIFsldV0sIGwyZGMtPmxwb3J0IFsldV0sIGwyZGV2X2ZjLT5mbG93 +aWQgWyV1XSBsMmRjLT50eF9jaCBbJXVdLCBkZXYudnBkLnBvcnR2ZWMgWyV4XQoAAAAAAAAAAHBv +cnR2ZWMgWyV1XQoAAABBaCBoYS4uLmRvdWJsZSBmcmVlIG94X2lkIDB4JXgsIHJ4X2lkIDB4JXgK +AAAAAABIb3N0IFBSTEkgUmVzcG9uc2UgdGltZWRvdXQ6IG94X2lkIDB4JXggcnhfaWQgMHgleAoA +AAAAAAAAAAAAAAAAcGZuICV1IHZmbiAldSB2aWEgY29tbWFuZAoAAAAAAABod19pMmNfdHJhbnNh +Y3Rpb246IG5kYXRhICV1IGFkZHJfb3AgMHgleCBkYXRhWzBdIDB4JXggZGlmZiAldQoAaHdfaTJj +X3RyYW5zYWN0aW9uOiBuZGF0YSAldSBhZGRyX29wIDB4JXggZGF0YVswXSAweCV4IGRpZmYgJXUg +ZHBvcyAldSBjb250ICV1IGZhaWxlZCB3aXRoIGVyciAlZAoAAAAAAAAAAAAAAAAAAGkyYyB0cmFu +c2FjdGlvbiBmYWlsZWQgdG8gY29tcGxldGUKAAAAAAAAAAAAAAAAAFBMX1BDSUVfTElOSy5zcGVl +ZCBvZiAldSBpcyBub3Qgc3VwcG9ydGVkCmZpbGUsIHJldCBGV19FSU8KAAAAAABjb25maWd1cmF0 +aW9uIGZpbGUgcGFyc2VyOiBzZ2UgdGltZXIgdmFsdWVbJWldIGlzIHRvbyBsYXJnZSwgY2hhbmdp +bmcgZnJvbSAldSB0byAldXVzZWNzCgAAAAAAAABmaWx0ZXJtYXNrIDB4JXggaXMgbm90IGVxdWFs +L3N1YnNldCB0by9vZiBmaWx0ZXJtb2RlCgAAAAAAAAAAAAAAaHdfbGVfY2xpcF9oYW5kbGVyOiBy +ZW1vdmVkIHBvcz0ldSAoPWlkeCAldSkKAAAAaHdfbGVfY2xpcF9oYW5kbGVyOiBhZGRpbmcgdG8g +cG9zPSV1ICg9aWR4ICV1KQoAbW9kdWxlWyV1XTogcG9ydCBtb2R1bGUgaW5zZXJ0ZWQgYW5kIHJl +YWR5CgAAAAAAbW9kdWxlWyV1XTogcG9ydCBtb2R1bGUgcmVtb3ZlZAoAAAAAAAAAAAAAAAAAAAAA +bW9kdWxlWyV1XTogdW5rbm93biBtb2R1bGUgaWRlbnRpZmllciAweCUwMngKAAAAbW9kdWxlWyV1 +XTogZ3BpbyAldSB0cmFucyAxMEcgMHglMDJ4IDFHIDB4JTAyeCAobGVuZ3RoICV1KSBjYWJsZSAw +eCUwMnggKGxlbmd0aCAldSkgbW9kdWxlX3R5cGUgMHglMDJ4CgAAAAAAAAAAAGN4NF9jcl9wZG93 +blsldV06IGVuICV1IHZpX2VuX2NudCAldQoAAAAAAAAAAAAAAGhzc19zaWdkZXRbJXVdOiBoc3Nf +c2lnZGV0IGNoYW5nZWQgdG8gMHgleAoAAAAAAGNyX21vZHVsZV9yeF9sb3NbJXVdOiByeF9sb3Mg +Y2hhbmdlZCB0byAldQoAAAAAAGN4NF9jclsldV06IHJldCAlZCBzdGF0dXMgJXUgeGdtX2xzIDB4 +JTA4eAoAAAAAAE1DOiBleHBlY3RlZCBzdGF0ZSB0byBzd2l0Y2ggdG8gQ0ZHLgAAAAAAAAAAAAAA +AE1DOiBleHBlY3RlZCBzdGF0ZSB0byBzd2l0Y2ggdG8gQWNjZXNzLgAAAAAAAAAAAE1DOiBleHBl +Y3RlZCBzdGF0ZSB0byBzd2l0Y2ggdG8gQ0ZHLgAAAAAAAAAAAAAAAE1DOiBleHBlY3RlZCBzdGF0 +ZSB0byBzd2l0Y2ggdG8gQWNjZXNzLgAAAAAAAAAAAElJLjEuYnggZHAxOFsldV0gcVsldV0gJSN4 +ICUjeCAlI3ggJSN4IG1pbiAlI3ggbWF4ICUjeAoAAAAAAAAAAABJSS4xLmMtZC4gJSN4ICUjeCAl +I3ggJSN4IGFsbCAgJSN4CgAAAAAAAAAAAAAAAABJSS4yLmIgKCUjeCAtICUjeCArICUjeCkgJSAx +MjggPSAlI3gKAAAAAAAAAAAAAABJSS4zIGluZXdfMWUgYWZ0ZXIgbGltaXQgY29tcHV0ZSBpdGVt +cF8xZSAleCwgaW5ld18xZSAleAoAAAAAAAAASUkuMy4gaXRlbXBfMWUgJSN4IGluZXdfMWUgJSN4 +IGluZXdfMWUgJWQKAAAAAAAASUkuNC4gc2V0XzFlICUjeAoAAAAAAAAAAAAAAAAAAABNQzogY2Fs +aWJyYXRpb24gZmFpbGVkIGZvciBlcnJhdGEyOSBkcDE4ICV1CgAAAABJVi4xLiBkcDE4WyV1XSBw +aGFzZV9zZWwgYmVmb3JlICUjeCBhZnRlciAlI3gsIGdhdGVfZGVsYXkgJSN4CgAATUMgZXJyYXRh +MjkgaXNzdWU6IGRwMTggJXUgcXVhZCAldSBjYW5ub3QgYmUgZGVjcmVhc2VkCgAAAAAAAAAAAE1D +IGVycmF0YTI5IGlzc3VlOiBkcDE4ICV1IHF1YWQgJXUgY2Fubm90IGJlIGRlY3JlYXNlZAoAAAAA +AAAAAABNQyBlcnJhdGEyOSBpc3N1ZTogZHAxOCAldSBxdWFkICV1IGNhbm5vdCBiZSBkZWNyZWFz +ZWQKAAAAAAAAAAAATUMgZXJyYXRhMjkgaXNzdWU6IGRwMTggJXUgcXVhZCAldSBjYW5ub3QgYmUg +ZGVjcmVhc2VkCgAAAAAAAAAAAHRlbXAyXzFlKzB4MTAgPSAlI3gKAAAAAAAAAAAAAAAATUM6IGNh +bGlicmF0aW9uIGZhaWxlZCBmb3IgZXJyYXRhMjEgaXRlcmF0aW9uICV1CgAAAAAAAAAAAAAAAAAA +AE1DIGVycmF0YSAyMTogZHAxOFsldV0gcHIwIG4wMiBmYWlsZWQgdG8gZ2V0IGF2ZXJhZ2UKAAAA +AAAAAAAAAABNQyBlcnJhdGEgMjE6IGRwMThbJXVdIHByMCBuMTMgZmFpbGVkIHRvIGdldCBhdmVy +YWdlCgAAAAAAAAAAAAAATUMgZXJyYXRhIDIxOiBkcDE4WyV1XSBwcjEgbjAyIGZhaWxlZCB0byBn +ZXQgYXZlcmFnZQoAAAAAAAAAAAAAAE1DIGVycmF0YSAyMTogZHAxOFsldV0gcHIxIG4xMyBmYWls +ZWQgdG8gZ2V0IGF2ZXJhZ2UKAAAAAAAAAAAAAABNQyBpbml0aWFsaXphdGlvbiBmYWlsZWQ6IENh +bGlicmF0aW9uIGNvbXBsZXRlIGJpdCBub3QgdG9nZ2xpbmcKAAAAAAAAAAAAAAAAAAAAAE1DIGlu +aXRpYWxpemF0aW9uIGZhaWxlZDogREZJIGluaXQgbm90IGdvaW5nIHRvIDAKAAAAAAAAAAAAAAAA +AABNQyBpbml0aWFsaXphdGlvbiBmYWlsZWQ6IERGSSBpbml0IG5vdCBjb21wbGV0aW5nCgAAAAAA +AAAAAAAAAAAATUMgaW5pdGlhbGl6YXRpb24gZmFpbGVkOiBDYWxpYnJhdGlvbiBkaWRuJ3QgY29t +cGxldGUuCgAAAAAAAAAAAERQMTggJXUsIGJ5dGVfbGFuZSAldSwgYml0X3NlbGVjdCAldQoAAAAA +AAAAAAAAAERQMTggJXUsIGJ5dGVfbGFuZSAldSwgYml0X3NlbGVjdCAldQoAAAAAAAAAAAAAAE1D +IGZhaWxlZCB0byBnZXQgVVBDVEwgcG93ZXIgdXAgZG9uZQoAAAAAAAAAAAAAAE1DIGluaXRpYWxp +emF0aW9uIGZhaWxlZDogRGlkbid0IGdldCBhbGwgRFAxOHMgbG9ja2VkCgAAAAAAAAAAAABNQyBp +bml0aWFsaXphdGlvbiBmYWlsZWQ6IERpZG4ndCBnZXQgYm90aCBBRFJzIGxvY2tlZAoAAAAAAAAA +AAAAQ3VycmVudCBTbGV3IHR4X3JvdyAlZDogdHhfY29sICVkLCB2YWwgJWQKAAAAAAAAQ3VycmVu +dCBTbGV3IGFkZHJfcm93ICVkOiBhZGRyX2NvbCAlZCwgdmFsICVkCgAATUMgaW5pdGlhbGl6YXRp +b24gZmFpbGVkOiBTTEVXX0RPTkVfU1RBVFVTIG5ldmVyIHRvZ2dsZWQAAAAAAAAAAGZscl9wZnZm +X2ZzbVsldToldV06IHVua25vd24gc3RhdGUgJXUKAAAAAAAAAAAAAGh3IHBmIGJpdG1hcCAweCUw +MnggdmZpZCBiaXRtYXAgMHglMDh4OjB4JTA4eDoweCUwOHg6MHglMDh4CgAAAABhZnRlciB2Zmlk +IGZpeHVwLCB2ZmlkIGJpdG1hcCAweCUwOHg6MHglMDh4OjB4JTA4eDoweCUwOHgKAAAAAAAATUNb +JXVdOiBmYWlsZWQgdG8gc3dpdGNoIGNvbnRyb2xsZXIgdG8gQ0ZHIHN0YXRlCgAAAAAAAAAAAAAA +AAAAAE1DWyV1XTogZmFpbGVkIHRvIHN3aXRjaCBjb250cm9sbGVyIHRvIElOSVRfTUVNIHN0YXRl +CgAAAAAAAAAAAABNQ1sldV06IGZhaWxlZCB0byBzd2l0Y2ggY29udHJvbGxlciB0byBDRkcgc3Rh +dGUKAAAAAAAAAAAAAAAAAAAATUNbJXVdOiBwZXJpb2RpYyBjYWxpYnJhdGlvbiBmYWlsZWQgd2l0 +aCBlcnJvciAldQoAAAAAAAAAAAAAAAAAAHRpbWVyIHF1ZXVlICV1IGxvc3QgYSB0aWNrISBuZXh0 +ICVwIGxhc3QgJXAgbnVtZSAldQoAAAAAAAAAAAAAAABmbHJfdGltZXJfc3RhcnQ6IGZsb3djX2lk +ICV1ICVwIGJ1ZiAlcAoAAAAAAAAAAABNQUM6IFBMTHMgZGlkbid0IGxvY2sKAAAAAAAAAAAAAHBj +aWU6IHJlYWQgZnJvbSBzZXJjZmcgcGNpZV9pcF91cl9tYXhmdW5jIDB4JXggcGZiaXRtYXAgMHgl +eAoAAABwY2llOiBucGYgJXUgKHBmYml0bWFwIDB4JTAyeCkgbnZmICV1IChwZiAwLi4zIDB4JTAy +eCAweCUwMnggMHglMDJ4IDB4JTAyeCkKAAAAAGZhaWxlZCB0byBmaW5kIHRoZSAlYyVjIFZQRCBw +YXJhbWV0ZXIKAAAAAAAAAAAAAGZhaWxlZCB0byBwYXJzZSB0aGUgJWMlYyBWUEQgcGFyYW1ldGVy +CgAAAAAAAAAAAGZhaWxlZCB0byBzdWNjZXNzZnVsbHkgZmluZCBDaGVsc2lvIFZQRAoAAAAAAAAA +AGxvZyBpbml0aWFsaXplZCBAIDB4JTA4eCBzaXplICV1ICgldSBlbnRyaWVzKQoAAGJvb3RzdHJh +cCBmaXJtd2FyZSB0b29rICV1IG1zZWNzIHRvIHJ1bgoAAAAAAAAAAGZsb3djICV1IChTR0UgZXFp +ZCAldSkgKEVUSENUUkwgcXVldWUpIGV4cGVyaWVuY2VkIGEgUENJIERNQSBSRUFEIHdvcmsgcmVx +dWVzdCBlcnJvciAoaW5ib3VuZCBxdWV1ZSAldSkKAAAAAAAAAABmbG93YyAldSAoU0dFIGVxaWQg +JXUpIGV4cGVyaWVuY2VkIGFuIHVuZXhwZWN0ZWQgUENJIERNQSBSRUFEIHdvcmsgcmVxdWVzdCBl +cnJvciAoaW5ib3VuZCBxdWV1ZSAldSkKAAAAAAAAAAAAAAAAZmxvd2MgJXUgZXhwZXJpZW5jZWQg +YW4gdW5leHBlY3RlZCBQQ0kgRE1BIFJFQUQgZXJyb3IgKGluYm91bmQgcXVldWUgJXUpCgAAAAAA +AAB3cmhfZm9pc2NzaV9zY3NpX2Vycjogd3IgWzB4JXhdLCBxdWV1ZWQgb24gZmxvd2MgWzB4JXhd +LCBmaWZvIFsweCV4XSBieXRlc19hdmFpbGFibGUKAAAAAAAAAAAAAABzZW5kX2Fib3J0X3JlcTog +Y3NrX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIHRpZCBb +MHgleF0sIHVscHR4Y2ggWyV1XSwgYnVmZmVyZWQgWyV1XQoAAAAAc2VuZF9jbG9zZV9yZXE6IGNz +a19mYy0+Zmxvd2NfdHlwZSBbMHgleF0sIGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2tfZmMt +PnRjYl9zdGF0ZSBbMHgleF0KAAAAc2VuZF9jbG9zZV9yZXE6IGNza19mYy0+Zmxvd2NfdHlwZSBb +MHgleF0sIGNza19mYy0+Zmxvd2NfaWQgWzB4JXhdLCB0aWQgWzB4JXhdLCB1bHB0eGNoIFsldV0s +YnVmZmVyZWQgWyV1XQoAAAAAAG9mbGRfdGNwX2RvX2FjdGl2ZV9jbG9zZTogY3NrX2ZjIFsweCV4 +XSwgY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+dGNiX3N0YXRlIFsweCV4XQoAAAAA +AG9mbGRfdGNwX2RvX2FjdGl2ZV9jbG9zZTogY3NrX2ZjIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19p +ZCBbMHgleF0sIGNza19mYy0+dGNiX3N0YXRlIFsweCV4XQoAAAAAAHNlc3Npb25fYmxvY2s6IHNl +c3NfZmMtPmZsb3djX2lkIFsweCV4XSwgc2Vzc19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBjb25u +X2ZjLT5mbG93Y19pZCBbMHgleF0sIGNvbm5fZmMtPmZsb3djX3N0YXRlIFsweCV4XSwgY3NrX2Zj +LT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdCgAAAAAAAAAAAAAA +AAAAAG9mbGRfdGNwX2Rpc2Nvbm5lY3Q6IHRjYl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2tfZmMt +PmZsb3djX2lkIFsweCV4XSwgY3NrLT50Y2Jfc3RhdGUgWzB4JXhdCgAAAGRlY29kZV9iYXNlNjRf +c3RyaW5nOiBkbGVuIFslZF0KAAAAAAAAAAAAAAAAAAAAAGRlY29kZV9oZXhfc3RyaW5nOiBkbGVu +IFslZF0KAAAAbG9nZ2VkX2luOiBmbG93Y19mb2lzY3NpX2Nvbm5fZmxhZ3MgWzB4JXhdCgAAAAAA +Zm9pc2NzaV92YWxpZGF0ZV9sb2dpbl9zdGFnZTogLSAxCgAAAAAAAAAAAAAAAAAAU2VxICMgbWlz +bWF0Y2ggc3RhdHNuID0gMHgleCBleHBzdGF0c24gPSAweCV4CgAAdGV4dF9yZXNwOiBjX2JpdCBb +MHgleF0sIGZfYml0IFsweCV4XQoAAAAAAAAAAAAAY3BsX3R4X3BrdDogaW50ZiBbMHgleF0KAAAA +AAAAAABuZXRfbDJkZXZfZmluZF9ieV9hZGRyOiBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBs +MmRjLT5scG9ydCBbJXVdLCBsMmRfZmMtPmZsb3djX2lkIFsweCV4XSwgbDJkYy0+aW40X2Rldi5p +bl9hZGRyLmFkZHIgWzB4JXhdLCBhZGRyIFsweCV4XQoAAABuZXRfbDJkZXZfbXR1X2NvbmZpZzog +bDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgbXR1ICV1CgAAAAAAAAAAbmV0aWZfZG9fZGhjcDog +d3ItPnBhcmFtLnZsYW5pZCBbJXVdLCBsMmRldl9mYy0+Zmxvd2NfbmV0X2wyZGV2X3ZsYW5kZXYg +WzB4JXhdCgBsMmRldl92aV9mc206IG1iIFsweCV4XSwgZGVmZXJyZWQsIHN0YXRlIFsweCV4XSwg +cG9ydCBbMHgleF0KAAAAbDJkZXZfdmlfZnNtOiB2aWlkIFsweCV4XSBwb3J0IFsweCV4XSwgbWFj +LWlkIFslMDJ4OiUwMng6JTAyeDolMDJ4OiUwMng6JTAyeF0uIAoAAAAAAAAAAAAAAAAAAAAAbDJk +ZXZfdmlfZnNtOiBzZ2VfZXFpZCBbMHgleF0sIHNnZV9pcWlkIFsweCV4XSwgc2dlX2VxY3IgWzB4 +JXhdLCByc3Nfc3ogWzB4JXhdCgBsMmRldl92aV9mc206IGwyZGV2X2ZjLT5mbG93Y19uZXRfbDJk +ZXZfbXR1IFsldV0sIG1iX3NjcmF0Y2ggWzB4JXhdLCBwb3J0IFsweCV4XQoAAAAAAAAAAAAAAAAA +AABsMmRldl92aV9mc206IHZpaWQgWyVkXSwgdmlfZmMtPmZsb3djX3ZpX2ZsYWdzIFsweCV4XQoA +AAAAAAAAAAAAbDJkZXZfdmlfZnNtOiBwZm4gWzB4JXhdLCB2Zm4gWzB4JXhdLCBsMmRldl9mYy0+ +Zmxvd2NfaWQgWzB4JXhdLCBscG9ydCBbMHgleF0sIHZpaWQgWzB4JXhdLCBmbGFncyBbMHgleF0K +AAAAAAAAAGwyZGV2X3ZpX2ZzbTogRXJyb3IgZnJlZWluZyBWSSwgcmMgWzB4JXhdCgAAAAAAAGwy +ZGV2X3ZpX2ZzbTogcGlkIFsweCV4XSwgdmlpZCBbMHgleF0sIG1iX2xvYyBbMHgleF0sIG1iX29y +aWdbMHgleF0sIGwyZGV2X2ZsYWdzIFsweCV4XSwgcmMgWzB4JXhdCgAAAAAAAAAAAAAAAABjcGxf +dHhfcGt0OiBpbnRmIFsweCV4XQoAAAAAAAAAAGVuY29kZSBoZXggc3RyaW5nOiBkbGVuIFslZF0K +AAAAdGNwX3NlbmRfYW9wZW5fcmVxOiBjc2tfZmMtPmZsb3djX2lkIFsweCV4XSwgY3NrX2ZjLT5m +bG93Y19zdGF0ZSBbMHgleF0sIGJ1ZmZlcmVkIFsldV0sIHJlc19jbnQgWzB4JXhdLCBpcV9pZHgg +WzB4JXhdCgAAAAAAAAAAAABhb3Blbl9yZXE6IGh3X2xlX2ZpbHRlcl9jdHVwbGUgZmFpbGVkCgAA +AAAAAAAAAABvZmxkX3RjcF9zZW5kX2FvcGVuX3JlcTogY3BsX3JlcS0+RmlsdGVyIFsweCUweF0s +IGN0dXBsZXNbMF0gWzB4JXhdLCBjdHVwbGVzWzFdIFsweCV4XQoAAAAAAAAAAABjc29ja19hbGxv +YzogdHhfY2ggWzB4JXhdLCBscG9ydCBbMHgleF0sIGNvb2tpZSBbJTA4eF0KAAAAAAAAAAAAY3Nv +Y2tfYWxsb2M6IGF2YWlsYWJsZSBbJXVdLCBuY3NvY2sgWyV1XSwgcG9zOmF0aWQgWzB4JXhdLCBj +c2tfZmMgWzB4JXhdLCBjc2tfZmMtPmZsb3djX2lkIFsweCV4XSwgc3BvcnQgWyV1XQoAAGZvaXNj +c2lfcGVlcl9pbml0OiBjb25uX2F0dHItPmhkaWdlc3RfdG9fZGRwX3Bnc3ogWzB4JXhdCgAAAAAA +AABmb2lzY3NpX3BlZXJfaW5pdDogY29ubl9mYy0+Zmxvd2NfZm9pc2NzaV9jb25uX2ZsYWdzIFsw +eCV4XQoAAAAAdGFza19mcmVlOiB0cnlpbmcgdG8gZnJlZSBxdWV1ZWQgdGFzayBbMHgleF0hISEK +AAAAAAAAAAAAAAAAAAAAAFdBVENIRE9HOiBObyB0ZW1wZXJhdHVyZSBzZW5zb3IgYXZhaWxhYmxl +LgoAAAAAAFdBVENIRE9HOiBBY3RpdmF0aW5nCgAAAAAAAAAAAAAAV0FUQ0hET0cgLSBFbmFibGUg +YWN0aW9uICV1IHRpbWUgJXUKAAAAAAAAAAAAAAAAV0FUQ0hET0cgLSBEaXNhYmxlIGFjdGlvbiAl +dQoAAABXQVRDSERPRzogRGUtYWN0aXZhdGluZwoAAAAAAAAAAHNlc3Npb25fdW5ibG9jazogc2Vz +c19mYy0+Zmxvd2NfaWQgWzB4JXhdLCBzZXNzX2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0sIGNvbm5f +ZmMtPmZsb3djX2lkIFsweCV4XSwgY29ubl9mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBjc2tfZmMt +PmZsb3djX2lkIFsweCV4XSwgY3NrX2ZjLT5mbG93Y19zdGF0ZSBbMHgleF0KAAAAAAAAAAAAAAAA +AHNlc3Npb25fbGlua19ub3RpZnk6IHBvcnQgWzB4JXhdIGxpbmsgZG93biBwaW5nIHJlY292ZXJ5 +IGRpc2FibGVkLCB0cnlpbmcgdG8gcmVjb3ZlciBzZXNzaW9uIFsweCV4XSBjb25uIFsweCV4XQoA +AAAAAAAAAAAAAAAAAAAAc2Vzc2lvbl9saW5rX25vdGlmeTogcG9ydCBbMHgleF0gbGluayB1cCBz +ZXNzaW9uIFsweCV4XSBjb25uIFsweCV4XQoAAAAAAAAAAAAAAABmb2lzY3NpIGNvbm5fZmMgWzB4 +JXhdLCBmbG93Y19zY2hlZGNsIFsweCV4XSwgaW5nX2NoIFsweCV4XSwgZWdyX2NoIFsweCV4XQoA +AAAAAGwyZGV2X25vdGlmeSB3aXRoIHVua25vd24gZmxhZyBbMHgleF0KAAAAAAAAAAAAAEZDb0Ug +RkNCIGxpbmtkb3duOiBpb19yZXEgMHgleCV4IGlxaWQgMHgleCBmbG93aWQgMHgleCBvcCAweCV4 +CgBmY29lIG5vdGlmeSA6IFVwZGF0ZSBuZXcgRENCWCB2YWx1ZXMgVkkgc3RhdGUgMHgleCBwcmkg +MHgleCBzY2hlZGNsIDB4JXggZGNieF9kb25lIDB4JXgKAAAAAAAAAABmY29lIG5vdGlmeSA6IEZD +RiBmbG93aWQgMHgleCwgdWxwY2ggMHgleCAKAAAAAABuZXRfbDJkZXZfbm90aWZ5OiBFdmVudCBv +biBsMmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhdLCBwb3J0IFslZF0sIGV2ZW50IFsweCV4XSwgdWxw +dHhjaCBbJXVdLCBjbGFzcyBbMHgleF0sIHByaW9yaXR5IFsweCV4XQoAAAAAAGZjb2Ugbm90aWZ5 +IDogRENCWCA6IHBvcnQgMHgleCwgcHJpb3JpdHkgMHgleCB1bHB0eGNoIDB4JXggY2xhc3MgMHgl +eAoAAAAAAAAAAAAAY2hfY2xfcmF0ZVsldS8ldV06IGNhcHBlZCBkZWZpY2l0X2luY3IgZnJvbSBy +ZXF1aXJlZCAldSB0byAldTsgcmF0ZSAldSAoZWZmICV1KSBkZWZpY2l0X21heCAldQoARkNvRSBG +Q0YgdGltZXI6IGZsb3djIHN0YXRlIDB4JXgsIHBvcnQgMHgleCAsZmNmIDB4JXgsIGZsb3djX2lk +IDB4JXgKAAAAAAAAAAAAAABjb3JlX3Byb2dyYW1fdGNiOiB0aWQgJSN4IHRfc3RhdGUgJSN4IHJj +dl9hZHYgMHglMDh4IHJjdl9zY2FsZSAlI3ggdHhfbWF4ICUjeCByY3Zfbnh0ICUjeCBhdGlkICUj +eAoAAAAAAAAAAAAAAAAACW9wdDAgJSN4JXggb3B0MiAlI3ggaXB2NiAlI3ggZmxhZ3NfdGltZXIg +MHglMDh4CgAAAAAAAAAAAAAAAAAAAG9mbGRfY29ubmVjdGlvbl93cjogY29ubmVjdGlvbiB3aXRo +IDUtdHVwbGUgbHAgMHglMDR4IGZwIDB4JTA0eCBsaXAgMHglMDh4JTA4eCBwaXAgMHglMDh4JTA4 +eCBmaWx0ZXIgMHglMDh4IGV4aXN0cyBAIExFIGluZGV4ICV1CgAAAAAAAAAAAAAAAAAAAG9mbGRf +Y29ubmVjdGlvbl93cjogY29ubmVjdGlvbiB3aXRoIDUtdHVwbGUgbHAgMHglMDR4IGZwIDB4JTA0 +eCBsaXAgMHglMDh4IHBpcCAweCUwOHggZmlsdGVyIDB4JTA4eCBleGlzdHMgQCBMRSBpbmRleCAl +dQoAAAAAAAAAb2ZsZF9jb25uZWN0aW9uX3dyOiBjb25uZWN0aW9uIHdpdGggNS10dXBsZSBscCAw +eCUwNHggZnAgMHglMDR4IGxpcCAweCUwOHglMDh4IHBpcCAweCUwOHglMDh4IGZpbHRlciAweCUw +OHgKAAAAAG9mbGRfY29ubmVjdGlvbl93cjogY29ubmVjdGlvbiB3aXRoIDUtdHVwbGUgbHAgMHgl +MDR4IGZwIDB4JTA0eCBsaXAgMHglMDh4IHBpcCAweCUwOHggZmlsdGVyIDB4JTA4eAoAAAAAAAAA +AAAAAABJUUZMSU5UIHBmbiAldSB2Zm4gJXU6IGlxZXNpemUgJXUgdG9vIHNtYWxsCgAAAABJUUZM +SU5UIHBmbiAldSB2Zm4gJXU6IGlxaWQgJXUgdG9vIGxhcmdlIChtYXggJXUpCgAAAAAAAAAAAAAA +AAAASVFGTElOVCBwZm4gJXUgdmZuICV1OiBpcWlkICV1IG5vdCBhbGxvY2F0ZWQKAAAASVFGTElO +VCBwZm4gJXUgdmZuICV1OiBmbDBpZCAldSB0b28gbGFyZ2UgKG1heCAldSkKAAAAAAAAAAAAAAAA +AElRRkxJTlQgcGZuICV1IHZmbiAldTogZmwwaWQgJXUgbm90IGFsbG9jYXRlZAoAAElRRkxJTlQg +cGZuICV1IHZmbiAldTogZmwxaWQgJXUgdG9vIGxhcmdlIChtYXggJXUpCgAAAAAAAAAAAAAAAABJ +UUZMSU5UIHBmbiAldSB2Zm4gJXU6IGZsMWlkICV1IG5vdCBhbGxvY2F0ZWQKAABJUUZMSU5UIHBm +biAldSB2Zm4gJXU6IGZsMWlkICV1IGlzIHZhbGlkIGJ1dCBub3QgZmwwaWQgJXUKAAAAAAAASVFG +TElOVCBwZm4gJXUgdmZuICV1OiBmbDFpZCAldSBpcyB2YWxpZCBidXQgaGVhZGVyIHNwbGl0IGZl +YXR1cmUgaXMgbm90IGVuYWJsZWQKAAAAAAAAAAAAAAAAAAAASVEgcGZuICV1IHZmbiAldTogaXFp +ZCAldSB0b28gbGFyZ2UgKG1heCAldSkKAAAASVEgcGZuICV1IHZmbiAldTogaXFpZCAldSBub3Qg +YWxsb2NhdGVkCgAAAAAAAAAASVEgcGZuICV1IHZmbiAldTogZmwwaWQgJXUgZmwxaWQgJXUgYnV0 +IG5vdCBzdXBwb3J0ZWQKAAAAAAAAAAAAAGh3X3VscHR4X3dvcmthcm91bmRfcHIxNjk0OV9lbmFi +bGVkX3BmOiBwZiAldSBlbmFibGVkICV1CgAAAAAAAABod191bHB0eF93b3JrYXJvdW5kX3ByMTY5 +NDlfZW5hYmxlZF92ZmlkOiB2ZmlkICV1IGVuYWJsZWQgJXUKAAAARVEgcGZuICV1IHZmbiAldTog +Y3JlYXRpbmcgRVRIIGVxaWQgJXUgd2l0aCBwZW5kaW5nIFdSKHMpIChudW1fYnl0ZXMgJXUgYW5k +IGZsYWdzIDB4JTA4eAoAAAAAAAAARVEgcGZuICV1IHZmbiAldTogY3JlYXRpbmcgQ1RSTCBlcWlk +ICV1IHdpdGggcGVuZGluZyBXUihzKSAobnVtX2J5dGVzICV1IGFuZCBmbGFncyAweCUwOHgKAAAA +AAAARVEgcGZuICV1IHZmbiAldTogZXFpZCAldSB0b28gbGFyZ2UgKG1heCAldSkKAAAARVEgcGZu +ICV1IHZmbiAldTogZXFpZCAldSBub3QgYWxsb2NhdGVkCgAAAAAAAAAAcG9ydF9ibGlua19sZWRf +cmVzdG9yZQoAAAAAAAAAAABwb3J0X2JsaW5rOiBibGlua2R1cj0weCV4IGJsaW5rX3JlZmNudAoA +AAAAAAAAAABwb3J0X2JsaW5rOiAJYmxpbmtfcmVmY250PTB4JXgKAHBvcnRfYmxpbms6IAlibGlu +a19yZWZjbnQ9MHgleAoAaHcgcmVnaXN0ZXIgb3BlcmF0aW9uIG5vdCBjb21wbGV0aW5nLCByZWcg +MHglMDh4IG1hc2sgMHglMDh4IHZhbHVlIDB4JTA4eCAocmVnIDB4JTA4eCkKAAAAAAAAAAAATURJ +TyBDTDQ1OiBmYWlsZWQgdG8gc2V0IHVwIE1NRCBhZGRyCgAAAAAAAAAAAAAATURJTzogZmFpbGVk +IHRvIHJlYWQKAAAAAAAAAAAAAABNRElPIENMNDU6IGZhaWxlZCB0byBzZXQgdXAgTU1EIGFkZHIK +AAAAAAAAAAAAAABNRElPOiBmYWlsZWQgdG8gd3JpdGUKAAAAAAAAAAAAAG1paV9hZHZfZmNbJXVd +OiByY2FwcyAweCV4CgAAAAAAbWlpX2Fkdl9zcGVlZFsldV06IHJjYXBzIDB4JXgKAABtaWlfYW5y +ZXN0YXJ0WyV1XTogYWNhcHMgMHgleAoAAG1paV9pbml0WyV1XTogYWNhcHMgMHgleAoAAAAAAAAA +bWlpX3Bkb3duWyV1XTogcG93ZXJkb3duIGVuICV1CgBwb3J0WyV1OjB4JTAyeDoweCUwMnhdOiBs +MWNmZywgcGNhcHMgMHgleCBhY2FwcyAweCV4IHJjYXBzIDB4JXgKAAAAAAAAAAAAAAAAAAAAAHBv +cnRbJXU6MHglMDJ4OjB4JTAyeF06IGwxY2ZnLCBpbnZhbGlkIHJlcXVlc3QsIHBjYXBzIDB4JXgg +YWNhcHMgMHgleCByY2FwcyAweCV4CgAAAAAAAAAAAAAAAAAAAHBvcnRbJXU6MHglMDJ4OjB4JTAy +eF06IGwxY2ZnLCBtZGkgbi9hIHBjYXBzIDB4JXggYWNhcHMgMHgleCByY2FwcyAweCV4CgAAAAAA +AAAAcG9ydFsldToweCUwMng6MHglMDJ4XTogbDFjZmcsIGNhbm5vdCBmb3JjZSBuby9tdWx0aXBs +ZSBzcGVlZChzKSwgcGNhcHMgMHgleCBhY2FwcyAweCV4IHJjYXBzIDB4JXgKAAAAAAAAAAAAAAAA +AGdldF9yZWZfdGFzazogcmVxdWVzdGVkIGNvb2tpZTogaGlnaCBbMHglMDh4XSwgbG93IFsweCUw +OHhdCgAAAABnZXRfcmVmX3Rhc2s6IHRhc2sgY29va2llOiBoaWdoIFsweCUwOHhdLCBsb3cgWzB4 +JTA4eF0KAAAAAAAAAAAAZ2V0X3JlZl90YXNrOiBpc3Rhc2stPmZsb3djX2lkIFsweCV4XSwgaXN0 +YXNrX2ZjLT5mbG93Y19zdGF0ZSBbJXVdCgAAAAAAAAAAAAAAAABnZXRfcmVmX3Rhc2s6IHRhc2sg +bm90IGZvciBjb29raWUgJWx4CgAAAAAAAAAAAABjaG5ldF9sMnRfdXBkYXRlOiBsMmRldl9mYyBb +MHgleF0sIGwyZGV2X2ZjLT5mbG93Y19pZCBbJXVdIGwyZGV2X2ZjLT5mbG93Y19mbGFncyBbMHgl +eF0sIGludGYgWzB4JXhdCgAAAAAAAAAAAAAAY2huZXRfbDJ0X3VwZGF0ZTogbDJkZXZfZmMtPmZs +b3djX2lkIFsldV0gYWxyZWFkeSBzY2hlZHVsZWQKAAAAAGNobmV0X2wydF91cGRhdGU6IGluIGRl +bGF5ZWRfcHJvY2Vzc2luZywgbDJ0ZW50IFslMDh4XQoAAAAAAAAAAABwcm9jZXNzX2RoY3Bfb3B0 +czogcm9vdCBwYXRoIGxlbiBbJWRdIGJ5dGVzCgAAAABuZXRpZl9wcm9jZXNzX2RoY3Bfb3B0czog +bDJkZXZfZmMtPmZsb3djX2lkIFsweCV4XSwgTVNHX1RZUEUgWyVkXSwgZGhjdHh0LT5zdGF0ZSBb +JWRdCgAAAAAAAAAAAABpY21wX3JlY3Y6IGwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIHBpZCBb +MHgleF0sIGljbXAgdHlwZSBbMHgleF0KAAAAAAAAAAAAAAAAAGZjX3NlbmRfYWxsb2NfY3BsOiBm +YWlsZWQgdG8gc2V0dXAgZmlsdGVyIGN0dXBsZQoAAAAAAAAAAAAAAAAAAABmY29lX2NvbXB1dGVf +Y3R1cGxlIHZsYW4gJXggdmlpZCAleCBwb3J0ICV4IG1wc19pZHggJXgKAAAAAAAAAAAAZmNvZV9j +b21wdXRlX2N0dXBsZSAweCV4OiV4CgAAAABBQlRTIEFDQyBhd2FpdGluZyBQUkxJIFJzcDogZmxv +d2NfaWQgMHgleCBveF9pZCAweCV4IHJ4X2lkIDB4JXggaXFpZCAweCV4CgAAAAAAAGFycF9yZWN2 +OiBpcGlkIFsweCV4XSwgaW5fYWRkci5hZGRyIFsweCV4XSwgc2lwIFsweCV4XSwgcmlwIFsweCV4 +XSwgYXJwX29wIFsweCV4XQoAAAAAAAAAAAAAAAAAAGNobmV0X2FycF9yZWN2OiBpcCBjb25mbGlj +dCBkZXRlY3RlZAoAAAAAAAAAAAAAAGNobmV0X2FycF9yZWN2OiBwaWQgWyV1XSwgdmxhbiBbMHgl +eF0sIGFycCBvcCBbMHgleF0sIHNpcCBbMHgleF0sIHJpcCBbMHgleF0KAAAAY3NvY2tfcGVlcl9j +bG9zZTogY3NrX2ZjLT5mbG93Y19pZCBbMHgleF0sIGNza19mYy0+dGNiX2ZjLT5mbG93Y19pZCBb +MHgleF0sIGNza19mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdLCBjc2tfZmMtPmZsb3djX2Nzb2NrX3Rj +Yl9mYy0+Zmxvd2Nfc3RhdGUgWzB4JXhdCgAAAAAAAAAAAGNzb2NrX3BlZXJfY2xvc2U6IGNza19m +Yy0+Zmxvd2NfaWQgWzB4JXhdLCBjc2tfZmMtPmZsb3djX3N0YXRlICBbMHgleF0KAAAAAAAAAAAA +dGNiX2ZjLT5mbG93Y19pZCBbMHglMDZ4XSwgdGNiX2ZjLT5mbG93Y190eXBlIFsweCV4XSwgY3Bs +b3AgWzB4JXhdIAoAAAAAAAAAAAAAAABjaF9yYXRlWyV1XTogY2FwcGVkIHRpY2sgZnJvbSByZXF1 +aXJlZCAldSB0byBzdXBwb3J0ZWQgJXU7IHJhdGUgJXUgKGVmZiAldSkgZGVmaWNpdF9pbmNyICV1 +IHRpY2sgJXUKAAAAAAAAAAAAAAAAcGt0c2NoZWRfY2hfcmxbJXVdOiBjaGFubmVsIHJsIG5vdCBh +dmFpbGFibGUgaW4gY29uanVuY3Rpb24gd2l0aCBmbG93IHNoYXBpbmcKAABwa3RzY2hlZF9jaF9y +bFsldV06IHJhdGUgJXUgbWF4ICV1CgAAAAAAAAAAAAAAAABwa3RzY2hlZF9jbF93cnJbJXU6JXVd +OiB3ZWlnaHQgJXUgd2VpZ2h0ZWRfbWFzayAweCV4CgAAAAAAAAAAAAAAZXFfcGFyYW1zWzB4JXg6 +MHgleF06IGRtYXEgMHgleCByZWFkICV1IHBmICV1IGVxaWRfYXBpICV1IHJldCAlZAoAAAAAAAAA +AAAAAAAAAABNQyBDTEsgc2V0dGluZyBmYWlsZWQ6IFBMTF9NX0xPQ0sgbmV2ZXIgdG9nZ2xlZAoA +AAAAAAAAAAAAAAAAAAAAd2FpdF9mb3JfY2FsaWJfZG9uZTogcmV0ICVkIGluICV1IGF0dGVtcHRz +CgAAAAAAbWFsbG9jX2RlY1sldV06IHN0YXJ0ICVwIGVuZCAlcCBuZXh0ICVwIHNpemUgMHgleCBh +bGlnbWVudCAweCV4IHAgJXAKAAAAAAAAAAAAAABtYWxsb2NfaW5jWyV1XTogc3RhcnQgJXAgZW5k +ICVwIG5leHQgJXAgc2l6ZSAweCV4IGFsaWdtZW50IDB4JXggcCAlcAoAAAAAAAAAAAAAAGxlIGNv +bmZpZ3VyYXRpb246IGhhc2ggbW9kZSByZXF1aXJlcyBhdCBsZWFzdCAxNiBlbnRyaWVzLCBuaGFz +aCAldQoAAAAAAAAAAAAAAAAAbGUgY29uZmlndXJhdGlvbjogaGFzaCBtb2RlIHJlcXVpcmVzIGF0 +IGVudHJpZXMgdG8gYmUgYSBwb3dlciBvZiAyLCBuaGFzaCAldQoAAABsZSBjb25maWd1cmF0aW9u +OiByZXF1ZXN0ZWQgJXUgdGNhbSBlbnRyaWVzIGJ1dCBvbmx5ICV1IGF2YWlsYWJsZQoAAAAAAAAA +AAAAAAAAAGxlIGNvbmZpZ3VyYXRpb246IHRjYW0gcmVnaW9ucyBtdXN0IGhhdmUgbXVsdGlwbGUg +b2YgMzIgZW50cmllcywgbnJvdXRlICV1IG5jbGlwICV1IG5maWx0ZXIgJXUgbnNlcnZlciAldQoA +AAAAAABvZmxkIHRwIHRpbWVyIHNldHRpbmdzIFRQX01TTCAweCUwOHggVFBfUlhUX01JTiAweCUw +OHggVFBfUlhUX01BWCAweCUwOHggVFBfUEVSU19NSU4gMHglMDh4IFRQX1BFUlNfTUFYIDB4JTA4 +eAoAICAgICAgICAgICAgICAgICAgICAgICBUUF9LRUVQX0lETEUgMHglMDh4IFRQX0tFRVBfSU5U +VkwgMHglMDh4IFRQX0lOSVRfU1JUVC5pbml0X3NydHRfbWF4cnR0IDB4JTA0eCBUUF9JTklUX1NS +VFQuaW5pdF9zcnR0X2luaXRzcnR0IDB4JTA0eCBUUF9GSU5XQUlUMl9USU1FUiAweCUwOHgKAAAA +AAAAAAAAAABjb25maWd1cmF0aW9uIGZpbGUgcGFyc2VyIGVuY291bnRlcmVkIGVycm9yIEAgbGlu +ZSAldToKAAAAAAAAAAAASE9TVCBQQUdFX1NJWkUgWzB4JTBseF0gdG9vIHNtYWxsLCBtaW4gWzB4 +JTBseF0gcmVxdWlyZWQKAAAAAAAAAHBhZ2Ugc2l6ZSBbJWx1XSBtaXNtYXRjaAoAAAAAAAAAUEFH +RSBzaXplICVsdSB1bnN1cHBvcnRlZCwgZGRwIGRpc2FibGVkCgAAAAAAAAAASG9zdCBwYWdlX3Np +emUgJWx1LCBkZHBfaWR4ICV1CgBGQ29FIEREUCBpbml0OiBmY29lIGxsaW1pdCAweCV4LCBmY29l +IHVsaW1pdCAweCV4IGdibCBsbGltaXQgMHgleCBnYmwgdWxpbWl0IDB4JXggcGNic3ogJXgKAAAA +AABGQ29FIEREUCBpbml0OiBmY29lIHBwb2Qgb2ZmIDB4JXgsIGZjb2Ugc3QgcHBvZCBhZGRyIDB4 +JXggZmNvZSBudW0gcHBvZHMgMHgleAoAAGZjb2UgeGNoZyBtZ3IgaW5pdDogTnVtYmVyIG9mIGV4 +Y2hhbmdlcyBmb3IgRkNvRSBpcyAleAoAAAAAAAAAAABRU0ZQIG1vZHVsZSB1bnBsdWcgLSByZWlu +aXRpYWxpemluZyByeF9sb3MgIHRvIDB4ZmYKAAAAAAAAAAAAAAAAZ3Bpb19xc2ZwX21vZHVsZV91 +cGRhdGU6IGNoYW5nZWQgcnhfbG9zIGZyb20gMHgleCB0byAweCV4CgAAAAAAAGdwaW9fcXNmcF9t +b2R1bGVfdXBkYXRlOiBjaGFuZ2VkIHR4X2RpcyBmcm9tIDB4JXggdG8gMHgleAoAAAAAAABNQUMg +ZmFpbGVkIHRvIHJlc3luYyB0eAoAAAAAAAAAAENhbGN1bGF0aW9uIG91dCBvZiBib3VuZHMgZnVy +aW5nIGluaXQ6ICUjeCAlI3ggJSN4CgAAAAAAAAAAAAAAAABod19zZ2VfbWFtZW1fY2FsYzogZW5j +b3VudGVyZWQgZXJyb3IgJWQKAAAAAAAAAABzZ2UgcmVxdWlyZSBuZXEgJXUgbmlxICV1IHJvdW5k +aW5nIHRvICV1ICV1CgAAAABod19lZGNfYmlzdFsldV06IGJpc3RfY21kWzB4JTA4eF0gYWRkciAw +eCV4IGxlbiAweCV4CgAAAAAAAAAAAAAAaHdfZWRjX2Jpc3RbJXVdOiBkb25lLCBlbmNvdW50ZXJl +ZCAldSBlcnJvcnMgb24gZmlyc3QgYW5kICV1IGVycm9ycyBvbiBzZWNvbmQgYXR0ZW1wdAoAAAAA +AAAAAAAAVGVtcGVyYXR1cmUvVm9sdGFnZSBTZW5zb3I6IENvcmUgY2xvY2sgJWQgPiA1MDA7IHVz +aW5nIDUwMCB0byBzdGF5IGluIGNvbXBsaWFuY2Ugd2l0aCBoYXJkd2FyZS4KAAAAAAAAAAAAAAAA +AAAAAGZvaXNjc2lfYnllOmwyZGV2X2ZjLT5mbG93Y19pZCBbMHgleF0sIGwyZGV2X2ZjLT5mbG93 +Y19wY2llX3BmbiBbMHgleF0sIGwyZGV2X2ZjLT5mbG93Y19wY2llX3ZmbiBbMHgleF0sIHBvcnQg +WzB4JXhdCgAAAAAAAAAAAAAAZm9pc2NzaV9ieWU6dmxhbmRldl9mYy0+Zmxvd2NfaWQgWzB4JXhd +LCB2bGFuZGV2X2ZjLT5mbG93Y19wY2llX3BmbiBbMHgleF0sIHZsYW5kZXZfZmMtPmZsb3djX3Bj +aWVfdmZuIFsweCV4XSwgcG9ydCBbMHgleF0KAAAAAABpbml0X3BvcnRbJXVdOiAgbGluayBzdGF0 +dXMgMHgleCBtb2RfdHlwZSAweCV4IHZpX2VuX2NudCAldSByeF9sb3MgJXUgaHNzX3NpZ2RldCAl +dSBwb3J0X2NmZy5zaWdkZXQgJXUKAAAAAAAAAAAAaW5pdF9wb3J0WyV1XTogIGxpbmsgc3RhdHVz +IDB4JXgKAAAAAAAAAAAAAAAAAAAAcnhjZmdfdnBkIHBvcnQgJXUgbGFuZSAldSBwdHlwZSAldSA9 +PiBpZHg9ICV1ID0+IHJ4Y2ZnID0gJSN4CgAAAFJhbmdlIGNhbGM6IEF2ZXJhZ2VkICUjeCBidXQg +aWdub3JlZCB2YWx1ZSAlI3ggKGl0ZXJhdGlvbiAldSkKAABNQyBjYWxpYnJhdGlvbiBmYWlsZWQ6 +IERGSSBpbml0IG5vdCBnb2luZyB0byAwCgBNQyBjYWxpYnJhdGlvbiBmYWlsZWQ6IERGSSBpbml0 +IG5vdCBjb21wbGV0aW5nCgBNQyBjYWxpYnJhdGlvbiBmYWlsZWQ6IENhbGlicmF0aW9uIGRpZG4n +dCBjb21wbGV0ZS4KAAAAAAAAAAAAAAAATUMgY29tbWFuZCBmYWlsZWQgdG8gY29tcGxldGUob3Bj +b2RlICUjeCBjYWRkciAlI3ggYmFkZHIgJSN4IGRlbGF5ICVkKQoAAAAAAAAAAABwZm5fYml0bWFw +IDB4JXgKAAAAAAAAAAAAAAAAAAAAAGJhZCBtYWlsYm94IGNtZDogcGZuIDB4JXggdmZuIDB4JXg7 +IG9wY29kZSAweCV4ID4gTEFTVEMyRSAweCV4CgBtYWlsYm94IGNtZCBub3QgeWV0IHN1cHBvcnRl +ZDogcGZuIDB4JXggdmZuIDB4JXg7IG9wY29kZSAweCV4CgAAYmFkIG1haWxib3ggY21kOiBwZm4g +MHgleCB2Zm4gMHgleDsgb3Bjb2RlIDB4JXggaXMgdmFsaWQgcG9zdCBkZXZpY2UgaW5pdCBvbmx5 +CgBiYWQgbWFpbGJveCBjbWQ6IHBmbiAweCV4IHZmbiAweCV4OyBvcGNvZGUgMHglMDJ4IHJhbWFz +ayAweCV4IGNtZCByYW1hc2sgMHgleAoAAGJhZCBtYWlsYm94IGNtZDogcGZuIDB4JXggdmZuIDB4 +JXg7IG9wY29kZSAweCUwMnggbGVuMTYgMHgleCB2ZXJzdXMgZXhwZWN0ZWQgbGVuMTYgMHgleAoA +AAAAAAAAAGluc3VmZmljaWVudCBjYXBzIHRvIHByb2Nlc3MgbWFpbGJveCBjbWQ6IHBmbiAweCV4 +IHZmbiAweCV4OyByX2NhcHMgMHgleCB3eF9jYXBzIDB4JXggcmVxdWlyZWQgcl9jYXBzIDB4JXgg +d19jYXBzIDB4JXgKAAAAAAAAAAAAaW5zdWZmaWNpZW50IGNhcHMgdG8gcHJvY2VzcyBtYWlsYm94 +IGNtZDogcGZuIDB4JXggdmZuIDB4JXg7IHJfY2FwcyAweCV4IHd4X2NhcHMgMHgleCByZXF1aXJl +ZCByX2NhcHMgMHgleCB3X2NhcHMgMHgleAoAAAAAAAAAAABod19wb3dlcl9wcmVwOiBWREQ9Tk9O +RSBidXQgVkNTPSVkCgAAAAAAAAAAAAAAAABod19wb3dlcl9wcmVwOiB1bnN1cHBvcnRlZCBleHRl +cm5hbCBhZGp1c3RhYmxlIHBvd2VyIHJlZ3VsYXRvcnMgVkREPSVkLCBWQ1M9JWQKAGh3X3Bvd2Vy +X3ByZXA6IHVuc3VwcG9ydGVkIFZERD0lZAoAAAAAAAAAAAAAAAAAAGh3X3Bvd2VyX3ByZXA6IHVu +c3VwcG9ydGVkIFZDUz0lZAoAAAAAAAAAAAAAAAAAAGh3X3Bvd2VyX3ByZXA6IGkyYyB3cml0ZSBl +cnJvciwgVkREPSVkLHJldD0lZAoAAGh3X3Bvd2VyX3ByZXA6IHVuc3VwcG9ydGVkIFZERD0lZAoA +AAAAAAAAAAAAAAAAAGh3X3Bvd2VyX3ByZXA6IGkyYyB3cml0ZSBlcnJvciwgVkNTPSVkLHJldD0l +ZAoAAGh3X3Bvd2VyX3ByZXA6IHVuc3VwcG9ydGVkIFZDUz0lZAoAAAAAAAAAAAAAAAAAAFZQRCBy +ZWdpb24gaXMgdG9vIHNtYWxsIChTRVJDRkdfU1JfUEZOVlBEU0laRSAweCV4KQoAAAAAAAAAAAAA +AABjZjogZmFpbGVkIHRvIGFsbG9jYXRlZCBtZW1vcnkgZm9yIGNvbmZpZ3VyYXRpb24gZmlsZSwg +cmV0ICVkCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAggAAASAAAAAAAAAAggAA +AQAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoCAAAAAAAAAAAAAAAAA +gAAAAAAAAAAAAQAAAAAQAAAAAAAAAAMAAAAAAAAAAAAAAAMAAAAAAAAAAAAAEAAAAAAAAAAIAAAA +AAIAAAAAAAAAAAAgAAAAAAAAAAAAAAABAAOAAAAAAAAAAAAAAAIAAAAAAAAAAAAgA4AAAAAAAAAA +AAAQAoAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAgAAAAAAAA +AAAAAACAAAKAAAAAAAAAAAAAAAKAAAAAAAAAAACAAAIAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAKA +AAAAAAAAAAABAAMAAAAAAAAAAAAAAoMAAAAAAAAAAAAQAoAAAAAAAAAAAAAwAAMAAAAAAAAIAAAw +AAMAAAAAAAAAAAAwBYMAAAAAAAAIAAAwBYMAAAAAAAAAAAAwBIMAAAAAAAAIAAAwBIMAAAAAAAAA +AAAwAwMAAAAAAAAIAAAwAwMAAAAAAAAAAAA4AwMAAAAAAAAAAAA4BYMAAAAAAAAAAAA4BIMAAAAA +AAAAAAA4AAMAAAAAAAAAAAA0BoIAAAAAAAAAAAA8A4IAAAAAAAAAAAA8AAMAAAAAAAAIAAA8AAMA +AAAAAAAAAAA8BIMAAAAAAAAAAAA8BQMAAAAAAAAAAAA9BAMAAAAAAAAAAAA8A4MAAAAAAAAAAAAs +AAIAAAAAAAAAAAAsBYIAAAAAAAAAAAAsBQIAAAAAAAAAAAAQBoAAAAAAAAAAAAAQBoKAAAAAAAAA +AAAADoIAAAAAAAAAAAAQB4KAAAAAIAAAAAAAB4IAAAAAIAAAAAAQBwKAAAAAAAAAAAAQBwKAAAAA +AAAAAAAQBwKAAAAAAAAAAAAABwIAAAAAIAAAAAAQF4MAAAAAAAAIAAAQF4MAAAAAAAAIAAAQAAAA +AAAAAAAAAAAQBgOAAAAAAAAAAAAADgMAAAAAAAAAAAAQBgNAAAAAAAAAAAAQBgMAAAAAAAAAAAAQ +BgAAAAAAAAAAAAAABgOAAAAAAAAAAAAABgMAAAAAAAAAAAAADgIAAAAAAAAAAAAADgIAAAAAAAAA +AAAQBgIAAAAAAAAAAAAQBgIAAAAAAAAAAAAQBgKAAAAAAAAAAAAQBgKAAAAAAAAAAAAAAAIAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAEAMAAAAAAAAIAAAAAAAAAAAAAAAAAAD///// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////8AAAAgAAAAAMAAAAAAAAAgAAAAAOAA +AAAAAAAAAgAAAAAAAABAAAAAAAAAAAAAAAAAAAEhAAAAAAAAAAAAAQEgAAAAAAAAAAAAAAIAAAAE +AAQAAAAABoAAAAQAAAAAAAAAgABAAAAAAAACAAAAgAAgAAAAAAACAAAIgAAAAAAAQAAAAAABAEAA +AAAAAAAAAAABAEIAAAAAAAAAAAAAACAAAAAAAAAAAAACECAAAAAAAAAAAAACDAIAAAAAAAAAAAAA +hQIAAAAEAAAAAAAAgEIAAAAAAAAAAACAgEIAQAAAAAAAAACAgEIAAAAAAAAAAAACACIAAAAAAAAA +AAAAgEEAAAAAAAAAAACAgEEAAAAAAAAAAAAAgEGAAAAAAAAAAACAgEGAAAAAAAAAAAACACEAAAAA +AAAAAAAAECCAAAAAAAAAAAACJQCAAAAAAAAAAAAABQAAAAAAAAAAAAAIiASAAAAAAAAAAAAIiASA +AAAAAAAAAAAIogCAAAAAAAAAAAAIogCAAAAAAAAAAAAIowCAAAAAAAAAAAAIowCAAAAAAAAAAAAI +pICAAAAAAAAAAAAIpICAAAAAAAAAAAAEpIDAAAAAAAAAAAAEogDAAAAAAAAAAAAEowDAAAAAAAAA +AAAEiATAAAAAAAAAAAAACQGAAAAAAAAAAAACDACAAAAAAAAAAAAAiATAAAAAAAAAAAAAiASAAAAA +AAAAAAACCwCAAAAAAAAAAAAAioCAAAAAAAAAAAAAC4CAAAAAAAAAAAAAjACAAAAAAAAAAAACIBCA +AAAAAAAAAAACCgCAAAAAAAAAAAACCoCAAAAAAAAAAAAACQKAAAAAAAAAAAAAAQEAAAAAAAAAAAAA +AQCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAIEQAAAAAAAAAAAAAIEIAAAAAAAA +AAAAAIEEAAAAAAAAAAAAAIGAAAAAAAAAAAAAgADAAAAAAAAAAAAAgACgAAAAAAAAAAAAAAgAAAAA +AAAAAAAAgYAAAAAAAAAAAAAAgYCAAAAAAAAAAAAAiYCAAAAAAAAAAAAAiYDAAAAAAAAAAAAAAYIA +AAAAAAAAAAACAYAAAAAAAAAAAAACAYCAAAAAAAAAAAAAQYGAAAAAAAAAAAACAYGAAAAAAAAAAAAA +SYGAAAAAAAAAAAACCYGAAAAAAAAAAAACAYEAAAAAAAAAAAAAQYEAAAAAAAAAAAAgAAAAAAAAAAAA +AAAQAAACAAAAAAAAAAAQAAAAAAAAAAAAAAAAgADAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgA +kgAAAAAAAAADZgAgAEAAAAAACACSAAAAAAAAAANyASUEQAAAAAAAAAAAAAAAAAAAA5YAIABAAAAA +AAgAAAACAIgDhwAAVgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAAAAAAAAAAA5YAIABA +AAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAAAAAAAAAAA5YA +IABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAIAAAAAgCIA4UA +AJYBIABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAIAAAAAgCI +A4UAAJYBIABAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAACAAOWACYEQAAAAAAIRyAB +BAAAArAAAtIFQCREAAAAAAhHIAEEAAACsgAC0gVGJEAAAAAACAAAAAIAiAOHAACWASYEQAAAAAAA +AAAAAAAAAAAAA5YAIABAAAAAAABHIAEGDKGCskABkgRAJEQAAAAACAAAAAIAiAOHAACWASYEQAAA +AAAARyABBAygQrGAAhIFQCREAAAAAAgAAAACAIgDhwAAlgEmBEAAAAAACAAAAAIAiAOFAACWASAA +QAAAAAAIAAAAAgCIA4UAAJYBIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAAAAAAAAAAAAAAAAOW +ACAAQAAAAAANxRK6ArCA0xRUi+JKRiRAAAAAAAXFEroCt4DTFFSLYkmmJEAAAAAABcUSogawgNMU +VIviSkYkQAAAAAANxRKiBreA0xRUi2JJpiRAAAAAAAXFEqIGsIDTFFSL4kpGJEAAAAAADcUSoga3 +gNMUVItiSaYkQAAAAAAFxRKiBrCA0xRUi+JKRiRAAAAAAA3FEqIGt4DTFFSLYkmmJEAAAAAACcQQ +oAIAgJAAAItiacYkQAAAAAABxBCgBrCAkwZUi2JpxiRAAAAAAAHEEKAGsICTBlSLYmnGJEAAAAAA +AcUQuAawgJMWVItiSMYkQAAAAAAIoRCIAgCBWBIAC1IApiRAAAAAAAnAEJACsIADFlSKkgHGJEAA +AAAACcAQuAawgAMQlIviAkYkQAAAAAAJwBC4ArSAAxCUi2IBpiRAAAAAAAnAELgCtIADEJSLYgGm +JEAAAAAACcAQuAK0gAMQlItiAaYkQAAAAAAJwBC4ArSAAxCUi2IBpiRAAAAAAAGgEJAGtIADEJSL +YgGmJEAAAAAAAcAQgAKwgAMUVIpSAMYkQAAAAAABwBCAArCAAxRUilIAxiRAAAAAAAHAEIACsIAD +FFSKUgDGJEAAAAAACEcgAQQAAAKwAALSBEAkQAAAAAAAgQAAAgCFWAdAC1IApiRAAAAAAAAAAAAE +AKBAAYAB1gAgAEAAAAAAAAAAAAYAoYAAQAFWACAAQAAAAAAAAAAABACgQAGAAdYAIABAAAAAAAiB +AAACAIVZgAQLUgCmJEAAAAAACgFAAAAAABgCAANCASakQgAAAAAAAAAAAAAAAAAAA5YAIABAAAAA +AAAAAAAEAKBAAYAB1gAgAEAAAAAACAAAAAIAiAOFAAPWACAAQAAAAAAIAAAAAgCIA4UAA9YAIABA +AAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAOWACAAQAAAAAAAAAAABACgQAGAAdYA +IABAAAAAAAnAELgCtIADEJSLYgGmJEAAAAAAAAAAAAAAAAACAAOWACYEQAAAAAAAAAAAAAAAAAAA +A5YAIABAAAAAAAgAAAACAIgDhQAAlgEgAEAAAAAAAAAAAAQAoEABgAHWACAAQAAAAAAAAAAABACg +QAGAAdYAIABAAAAAAAAAAAAEAKBAAYAB1gAgAEAAAAAACKEQiAIAgVgQAAkSAaYkQAAAAAAAAAAA +BACgQAGAAdYAIABAAAAAAAAAAAAGAKGAAEABVgAgAEAAAAAACAAAAAIAiAOHQAjSAkYkQgAAAAAJ +xRKiApSI0hKAiyJJxiRAAAAAAAnAEIACpIgAhVSLUgDGJEAAAAAACcAQgAa0iAMBFItSAaYkQAAA +AAANwAAAArCAwxZUi+IDRiRAAAAAAAAAAAAAAAAAAAADlgAgAEAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIADAABAAA +AAIAAAIAJiRAAAAAAABHMAAGAyACtwAIAgHAJEAAAAAACAMAAAIGoAq3AAgCAcYkRgAAAAAAAAAA +AAAAAAIAAAIAJiRAAAAAAAAgUAAEAAAAAAAAAgEmJEYAAAAACGAgAIQAAAAAAAAGACAAQAAAAAAI +YCAAhAAAAAIBMAIAJiVAAAAAAAhgAAAEAIQBggQEAgHGJMIAAAAAAcAAAAJDgAMCDIgCAaYkQAAA +AAAIAGAABAAAAAIAAAIAJiRAAAAAAAgAYAAEAAAAAAAABAEgAEAAAAAAAAAAAAAAAAAAAAAEASAA +QAAAAAAECBSABgoAAAcBTAIgpiZAAAAAAAiAAAAGAIQBgAQIAgGmJMAAAAAAAEAAAAIAoAAAQAgC +AKYkRgAAAAAAAAAAAAAAAAIAAAIAJiRAAAAAAAQAAAAChAADAooIAgTAJEAAAAAAAAAAAAAAAAAC +AAAGASBIQAAAAAAAIFAABAAAAAIAAAIAJiRAAAAAAAhgIACEAAAAAgAABgAmBEAAAAAACGAgAIQA +AAACAAACASYlQAAAAAAIYAAABACEAYAEBAIBxiTAAAAAAAgAYAAEAAAAAAAABAEgAEAAAAAAAACA +ACAAAAAAAAACACZMcAAAAAAAAIAAIAAAAAAAAAYBIAAAAAAAAAAAgAAgAAAAAAAAAgAmTHAAAAAA +AACAACAAAAAAAAAGASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAACcAAAAi0jAQJFgQCBMYkQAAAAAAJwAAADDSABAkWBAIExiRAAAAAAAQIdIBMCQAAUABc +AmHmJEAAAAAADAh0gEQAAABSAEACYSYkQAAAAAAIAhCgBAAAAAABAAIAJiRAAAAAAAgCEKAEAAAA +AAEAAgAmJEAAAAAABAh0AEIBAAAHAIgCYMYkQAAAAAANyBQAAgkAAARAnAJg5iRAAAAAAAnIEIAC +tIAEApSIAmXGJEAAAAAADch0AEy0gAMAlIgCYKYkwAAAAAAFyHQASDSQAwCUiAJgpiTAAAAAAAhH +AAAEAAAAAAAAAgEgJEAAAAAACEcAAAQAAAAAAAACBEAkQAAAAAAARyABDAchwrcACAIAwCREAAAA +AABHIAEMByHCtwAIAgDAJEQAAAAAAEcgAQwHIcK3AAgCAMAkRAAAAAAAACABCACEAAVAiAIBxiTA +AAAAAAAAIAEIAIQABUCIAgHGJMAAAAAAAAAgAQgAhAAFQIgCAcYkwAAAAAAAACABhoIAAQLAiAID +xiTAAAAAAAAAIAGCggAAAsCIAgPGJMAAAAAACcAgAYKkgAEFQIgCAcYkwAAAAAAIAAAADACEAAVA +iAIBxiTAAAAAAAAAIAGGggABAsCIAgPGJMAAAAAAAAAgAYKCAAAAwIgCAqYkwAAAAAAJwCABgqSA +AQVAiAIBxiTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBAUAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbZ2xvYmFsXQpyc3NfZ2xiX2NvbmZpZ19tb2RlPWJhc2lj +dmlydHVhbApyc3NfZ2xiX2NvbmZpZ19vcHRpb25zPXRubG1hcGVuLGhhc2h0b2VwbGl0eix0bmxh +bGxsa3AKcGxfdGltZW91dF92YWx1ZT0yMDAKcmVnWzB4MTAwOF09MHg0MDgxMC8weDIxYzcwCnJl +Z1sweDEwMGNdPTB4MjIyMjIyMjIKcmVnWzB4MTBhMF09MHgwMTA0MDgxMApyZWdbMHgxMDQ0XT00 +MDk2CnJlZ1sweDEwNDhdPTY1NTM2CnJlZ1sweDEwNGNdPTE1MzYKcmVnWzB4MTA1MF09OTAyNApy +ZWdbMHgxMDU0XT05MjE2CnJlZ1sweDEwNThdPTIwNDgKcmVnWzB4MTA1Y109MTI4CnJlZ1sweDEw +NjBdPTgxOTIKcmVnWzB4MTA2NF09MTYzODQKcmVnWzB4MTBhNF09MHhhMDAwYTAwMC8weGYwMDBm +MDAwCnJlZ1sweDEwYThdPTB4NDAyMDAwLzB4NDAyMDAwCmJhcjJ0aHJvdHRsZWNvdW50PTUwMApz +Z2VfdGltZXJfdmFsdWU9NSwxMCwyMCw1MCwxMDAsMjAwCnJlZ1sweDExMjRdPTB4MDAwMDA0MDAv +MHgwMDAwMDQwMApyZWdbMHgxMTMwXT0weDAwZDVmZmViCnJlZ1sweDExM2NdPTB4MDAwMmZmYzAK +cmVnWzB4N2RjMF09MHgwNjJmODg0OQpmaWx0ZXJNb2RlPXNydnJzcmFtLGZyYWdtZW50YXRpb24s +bXBzaGl0dHlwZSxwcm90b2NvbCx2bGFuLHBvcnQsZmNvZQpmaWx0ZXJNYXNrPXByb3RvY29sLGZj +b2UKdHBfcG1yeD0zMAp0cF9wbXJ4X3BhZ2VzaXplPTY0Swp0cF9ucnhjaD0wCnRwX3BtdHg9NTAK +dHBfcG10eF9wYWdlc2l6ZT02NEsKdHBfbnR4Y2g9MApyZWdbMHg3ZDA4XT0weDAwMDAwODAwLzB4 +MDAwMDA4MDAKcmVnWzB4MTljMDRdPTB4MDA0MDAwMDAvMHgwMDQwMDAwMApbZnVuY3Rpb24iMCJd +Cm52Zj0xNgp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT0xCm5pcWZsaW50PTgKbmV0aGN0cmw9 +OApuZXE9MTYKbmV4YWN0Zj04CmNtYXNrPWFsbApwbWFzaz0weDEKW2Z1bmN0aW9uIjEiXQpudmY9 +MTYKd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9MQpuaXFmbGludD04Cm5ldGhjdHJsPTgKbmVx +PTE2Cm5leGFjdGY9OApjbWFzaz1hbGwKcG1hc2s9MHgyCltmdW5jdGlvbiIyIl0KbnZmPTE2Cnd4 +X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTEKbmlxZmxpbnQ9OApuZXRoY3RybD04Cm5lcT0xNgpu +ZXhhY3RmPTgKY21hc2s9YWxsCnBtYXNrPTB4NApbZnVuY3Rpb24iMyJdCm52Zj0xNgp3eF9jYXBz +PWFsbApyX2NhcHM9YWxsCm52aT0xCm5pcWZsaW50PTgKbmV0aGN0cmw9OApuZXE9MTYKbmV4YWN0 +Zj04CmNtYXNrPWFsbApwbWFzaz0weDgKW2Z1bmN0aW9uIjQiXQp3eF9jYXBzPWFsbApyX2NhcHM9 +YWxsCm52aT0yOApuaXFmbGludD0xNzAKbmV0aGN0cmw9MTAwCm5lcT0yNTYKbmV4YWN0Zj00MApj +bWFzaz1hbGwKcG1hc2s9YWxsCm5ldGhvZmxkPTEwMjQKbnJvdXRlPTMyCm5jbGlwPTMyCm5maWx0 +ZXI9NDk2Cm5zZXJ2ZXI9NDk2Cm5oYXNoPTEyMjg4CnByb3RvY29sPW5pY192bSxvZmxkLHJkZHAs +cmRtYWMsaXNjc2lfaW5pdGlhdG9yX3BkdSxpc2NzaV90YXJnZXRfcGR1CnRwX2wydD0zMDcyCnRw +X2RkcD0yCnRwX2RkcF9pc2NzaT0yCnRwX3N0YWc9Mgp0cF9wYmw9NQp0cF9ycT03CltmdW5jdGlv +biI1Il0Kd3hfY2Fwcz1hbGwKcl9jYXBzPWFsbApudmk9NApuaXFmbGludD0zNApuZXRoY3RybD0z +MgpuZXE9NjQKbmV4YWN0Zj00CmNtYXNrPWFsbApwbWFzaz1hbGwKbnNlcnZlcj0xNgpuaGFzaD0y +MDQ4CnRwX2wydD0xMDI0CnByb3RvY29sPWlzY3NpX2luaXRpYXRvcl9mb2ZsZAp0cF9kZHBfaXNj +c2k9Mgppc2NzaV9udGFzaz0yMDQ4CmlzY3NpX25zZXNzPTIwNDgKaXNjc2lfbmNvbm5fcGVyX3Nl +c3Npb249MQppc2NzaV9uaW5pdGlhdG9yX2luc3RhbmNlPTY0CltmdW5jdGlvbiI2Il0Kd3hfY2Fw +cz1hbGwKcl9jYXBzPWFsbApudmk9NApuaXFmbGludD0zNApuZXRoY3RybD0zMgpuZXE9NjYKbmV4 +YWN0Zj0zMgpjbWFzaz1hbGwKcG1hc2s9YWxsCm5oYXNoPTIwNDgKcHJvdG9jb2w9ZmNvZV9pbml0 +aWF0b3IKdHBfZGRwPTIKZmNvZV9uZmNmPTE2CmZjb2VfbnZucD0zMgpmY29lX25zc249MTAyNApb +ZnVuY3Rpb24iMTAyMyJdCnd4X2NhcHM9YWxsCnJfY2Fwcz1hbGwKbnZpPTQKY21hc2s9YWxsCnBt +YXNrPWFsbApuZXhhY3RmPTgKbmZpbHRlcj0xNgpbZnVuY3Rpb24iMC8qIl0Kd3hfY2Fwcz0weDgy +CnJfY2Fwcz0weDg2Cm52aT0xCm5pcWZsaW50PTQKbmV0aGN0cmw9MgpuZXE9NApuZXhhY3RmPTQK +Y21hc2s9YWxsCnBtYXNrPTB4MQpbZnVuY3Rpb24iMS8qIl0Kd3hfY2Fwcz0weDgyCnJfY2Fwcz0w +eDg2Cm52aT0xCm5pcWZsaW50PTQKbmV0aGN0cmw9MgpuZXE9NApuZXhhY3RmPTQKY21hc2s9YWxs +CnBtYXNrPTB4MgpbZnVuY3Rpb24iMi8qIl0Kd3hfY2Fwcz0weDgyCnJfY2Fwcz0weDg2Cm52aT0x +Cm5pcWZsaW50PTQKbmV0aGN0cmw9MgpuZXE9NApuZXhhY3RmPTQKY21hc2s9YWxsCnBtYXNrPTB4 +NApbZnVuY3Rpb24iMy8qIl0Kd3hfY2Fwcz0weDgyCnJfY2Fwcz0weDg2Cm52aT0xCm5pcWZsaW50 +PTQKbmV0aGN0cmw9MgpuZXE9NApuZXhhY3RmPTQKY21hc2s9YWxsCnBtYXNrPTB4OApbcG9ydCIw +Il0KZGNiPXBwcCxkY2J4CmJnX21lbT0yNQpscGJrX21lbT0yNQpod209MzAKbHdtPTE1CmR3bT0z +MApbcG9ydCIxIl0KZGNiPXBwcCxkY2J4CmJnX21lbT0yNQpscGJrX21lbT0yNQpod209MzAKbHdt +PTE1CmR3bT0zMApbcG9ydCIyIl0KZGNiPXBwcCxkY2J4CmJnX21lbT0yNQpscGJrX21lbT0yNQpo +d209MzAKbHdtPTE1CmR3bT0zMApbcG9ydCIzIl0KZGNiPXBwcCxkY2J4CmJnX21lbT0yNQpscGJr +X21lbT0yNQpod209MzAKbHdtPTE1CmR3bT0zMApbZmluaV0KdmVyc2lvbj0weDE0MjUwMDBmCmNo +ZWNrc3VtPTB4MjNhMmQ4NTAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAFtnbG9iYWxdCnJzc19nbGJfY29uZmlnX21vZGU9YmFzaWN2aXJ0dWFs +CnJzc19nbGJfY29uZmlnX29wdGlvbnM9dG5sbWFwZW4saGFzaHRvZXBsaXR6LHRubGFsbGxrcApw +Y2llX21hX3JzcF90aW1lcnZhbHVlPTUwMApyZWdbMHg1OWM0XT0weDMvMHgzCnBsX3RpbWVvdXRf +dmFsdWU9MjAwCnJlZ1sweDEwMDhdPTB4NDA4MTAvMHgyMWM3MApyZWdbMHgxMDBjXT0weDIyMjIy +MjIyCnJlZ1sweDEwYTBdPTB4MDEwNDA4MTAKcmVnWzB4MTA0NF09NDA5NgpyZWdbMHgxMDQ4XT02 +NTUzNgpyZWdbMHgxMDRjXT0xNTM2CnJlZ1sweDEwNTBdPTkwMjQKcmVnWzB4MTA1NF09OTIxNgpy +ZWdbMHgxMDU4XT0yMDQ4CnJlZ1sweDEwNWNdPTEyOApyZWdbMHgxMDYwXT04MTkyCnJlZ1sweDEw +NjRdPTE2Mzg0CnJlZ1sweDEwYTRdPTB4YTAwMGEwMDAvMHhmMDAwZjAwMApyZWdbMHgxMGE4XT0w +eDQwMjAwMC8weDQwMjAwMApiYXIydGhyb3R0bGVjb3VudD01MDAKc2dlX3RpbWVyX3ZhbHVlPTUs +MTAsMjAsNTAsMTAwLDIwMApyZWdbMHgxMTI0XT0weDAwMDAwNDAwLzB4MDAwMDA0MDAKcmVnWzB4 +MTEzMF09MHgwMGQ1ZmZlYgpyZWdbMHgxMTNjXT0weDAwMDJmZmMwCnJlZ1sweDdkYzBdPTB4MDYy +Zjg4NDkKZmlsdGVyTW9kZT1mcmFnbWVudGF0aW9uLG1wc2hpdHR5cGUscHJvdG9jb2wsdmxhbixw +b3J0LGZjb2Usc3J2cnNyYW0KdHBfcG1yeD0zMAp0cF9wbXJ4X3BhZ2VzaXplPTY0Swp0cF9ucnhj +aD0wCnRwX3BtdHg9NTAKdHBfcG10eF9wYWdlc2l6ZT02NEsKdHBfbnR4Y2g9MApyZWdbMHgxOWMw +NF09MHgwMDQwMDAwMC8weDAwNDAwMDAwCltmdW5jdGlvbiIwIl0Kd3hfY2Fwcz1hbGwKcl9jYXBz +PWFsbApudmk9MjgKbmlxZmxpbnQ9MTcwCm5ldGhjdHJsPTk2Cm5lcT0yNTIKbmV4YWN0Zj00MApj +bWFzaz1hbGwKcG1hc2s9YWxsCm5yb3V0ZT0zMgpuY2xpcD0zMgpuZmlsdGVyPTQ4Cm5zZXJ2ZXI9 +MzIKbmhhc2g9MjA0OApwcm90b2NvbD1uaWNfdm0sb2ZsZCxyZGRwLHJkbWFjLGlzY3NpX2luaXRp +YXRvcl9wZHUsaXNjc2lfdGFyZ2V0X3BkdQp0cF9sMnQ9MzA3Mgp0cF9kZHA9Mgp0cF9kZHBfaXNj +c2k9Mgp0cF9zdGFnPTIKdHBfcGJsPTUKdHBfcnE9NwpbZnVuY3Rpb24iMSJdCnd4X2NhcHM9YWxs +CnJfY2Fwcz1hbGwKbnZpPTQKbmlxZmxpbnQ9MzQKbmV0aGN0cmw9MzIKbmVxPTY2Cm5leGFjdGY9 +MzIKY21hc2s9YWxsCnBtYXNrPWFsbApuaGFzaD0yMDQ4CnByb3RvY29sPWZjb2VfaW5pdGlhdG9y +CnRwX2RkcD0yCmZjb2VfbmZjZj0xNgpmY29lX252bnA9MzIKZmNvZV9uc3NuPTEwMjQKW2Z1bmN0 +aW9uIjEwMjMiXQp3eF9jYXBzPWFsbApyX2NhcHM9YWxsCm52aT00CmNtYXNrPWFsbApwbWFzaz1h +bGwKbmV4YWN0Zj04Cm5maWx0ZXI9MTYKW2Z1bmN0aW9uIjAvKiJdCnd4X2NhcHM9MHg4MgpyX2Nh +cHM9MHg4Ngpudmk9MQpuaXFmbGludD00Cm5ldGhjdHJsPTIKbmVxPTQKbmV4YWN0Zj00CmNtYXNr +PWFsbApwbWFzaz0weDEKW2Z1bmN0aW9uIjEvKiJdCnd4X2NhcHM9MHg4MgpyX2NhcHM9MHg4Ngpu +dmk9MQpuaXFmbGludD00Cm5ldGhjdHJsPTIKbmVxPTQKbmV4YWN0Zj00CmNtYXNrPWFsbApwbWFz +az0weDIKW3BvcnQiMCJdCmRjYj1wcHAsZGNieApiZ19tZW09MjUKbHBia19tZW09MjUKaHdtPTMw +Cmx3bT0xNQpkd209MzAKW3BvcnQiMSJdCmRjYj1wcHAsZGNieApiZ19tZW09MjUKbHBia19tZW09 +MjUKaHdtPTMwCmx3bT0xNQpkd209MzAKW3BvcnQiMiJdCmRjYj1wcHAsZGNieApiZ19tZW09MjUK +bHBia19tZW09MjUKaHdtPTMwCmx3bT0xNQpkd209MzAKW3BvcnQiMyJdCmRjYj1wcHAsZGNieApi +Z19tZW09MjUKbHBia19tZW09MjUKaHdtPTMwCmx3bT0xNQpkd209MzAKW2ZpbmldCnZlcnNpb249 +MHgxNDI1MDAwZApjaGVja3N1bT0weGU1NmNiOTk5CgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAA +==== diff --git a/sys/dev/cxgbe/firmware/t5fw_cfg.txt b/sys/dev/cxgbe/firmware/t5fw_cfg.txt new file mode 100644 index 0000000..95eebfa --- /dev/null +++ b/sys/dev/cxgbe/firmware/t5fw_cfg.txt @@ -0,0 +1,151 @@ +# Firmware configuration file. +# +# Global limits (some are hardware limits, others are due to the firmware). +# nvi = 128 virtual interfaces +# niqflint = 1023 ingress queues with freelists and/or interrupts +# nethctrl = 64K Ethernet or ctrl egress queues +# neq = 64K egress queues of all kinds, including freelists +# nexactf = 336 MPS TCAM entries, can oversubscribe. +# + +[global] + rss_glb_config_mode = basicvirtual + rss_glb_config_options = tnlmapen, hashtoeplitz, tnlalllkp + + sge_timer_value = 1, 5, 10, 50, 100, 200 # usecs + + # TP_SHIFT_CNT + reg[0x7dc0] = 0x62f8849 + + # TP_GLOBAL_CONFIG + reg[0x7d08] = 0x00000800/0x00000800 # set IssFromCplEnable + + filterMode = fragmentation, mpshittype, protocol, vlan, port, fcoe + filterMask = protocol, fcoe + + # TP rx and tx channels (0 = auto). + tp_nrxch = 0 + tp_ntxch = 0 + + # TP rx and tx payload memory (% of the total EDRAM + DDR3). + tp_pmrx = 38 + tp_pmtx = 60 + tp_pmrx_pagesize = 64K + tp_pmtx_pagesize = 64K + +# PFs 0-3. These get 8 MSI/8 MSI-X vectors each. VFs are supported by +# these 4 PFs only. Not used here at all. +[function "0"] + nvf = 16 + nvi = 1 +[function "0/*"] + nvi = 1 + +[function "1"] + nvf = 16 + nvi = 1 +[function "1/*"] + nvi = 1 + +[function "2"] + nvf = 16 + nvi = 1 +[function "2/*"] + nvi = 1 + +[function "3"] + nvf = 16 + nvi = 1 +[function "3/*"] + nvi = 1 + +# PF4 is the resource-rich PF that the bus/nexus driver attaches to. +# It gets 32 MSI/128 MSI-X vectors. +[function "4"] + wx_caps = all + r_caps = all + nvi = 32 + niqflint = 256 + nethctrl = 128 + neq = 256 + nexactf = 328 + cmask = all + pmask = all + + # driver will mask off features it won't use + protocol = ofld + + tp_l2t = 4096 + tp_ddp = 2 + + # TCAM has 8K cells; each region must start at a multiple of 128 cell. + # Each entry in these categories takes 4 cells each. nhash will use the + # TCAM iff there is room left (that is, the rest don't add up to 2048). + nroute = 32 + nclip = 32 + nfilter = 1008 + nserver = 512 + nhash = 16384 + +# PF5 is the SCSI Controller PF. It gets 32 MSI/40 MSI-X vectors. +# Not used right now. +[function "5"] + nvi = 1 + +# PF6 is the FCoE Controller PF. It gets 32 MSI/40 MSI-X vectors. +# Not used right now. +[function "6"] + nvi = 1 + +# The following function, 1023, is not an actual PCIE function but is used to +# configure and reserve firmware internal resources that come from the global +# resource pool. +[function "1023"] + wx_caps = all + r_caps = all + nvi = 4 + cmask = all + pmask = all + nexactf = 8 + nfilter = 16 + +# MPS has 192K buffer space for ingress packets from the wire as well as +# loopback path of the L2 switch. +[port "0"] + dcb = none + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "1"] + dcb = none + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "2"] + dcb = none + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "3"] + dcb = none + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[fini] + version = 0x1 + checksum = 0xb2417251 +# +# $FreeBSD$ +# diff --git a/sys/dev/cxgbe/firmware/t5fw_cfg_fpga.txt b/sys/dev/cxgbe/firmware/t5fw_cfg_fpga.txt new file mode 100644 index 0000000..eb4ed4b --- /dev/null +++ b/sys/dev/cxgbe/firmware/t5fw_cfg_fpga.txt @@ -0,0 +1,477 @@ +# Chelsio T5 Factory Default configuration file. +# +# Copyright (C) 2010-2013 Chelsio Communications. All rights reserved. +# +# DO NOT MODIFY THIS FILE UNDER ANY CIRCUMSTANCES. MODIFICATION OF +# THIS FILE WILL RESULT IN A NON-FUNCTIONAL T4 ADAPTER AND MAY RESULT +# IN PHYSICAL DAMAGE TO T4 ADAPTERS. + +# This file provides the default, power-on configuration for 4-port T4-based +# adapters shipped from the factory. These defaults are designed to address +# the needs of the vast majority of T4 customers. The basic idea is to have +# a default configuration which allows a customer to plug a T4 adapter in and +# have it work regardless of OS, driver or application except in the most +# unusual and/or demanding customer applications. +# +# Many of the T4 resources which are described by this configuration are +# finite. This requires balancing the configuration/operation needs of +# device drivers across OSes and a large number of customer application. +# +# Some of the more important resources to allocate and their constaints are: +# 1. Virtual Interfaces: 128. +# 2. Ingress Queues with Free Lists: 1024. PCI-E SR-IOV Virtual Functions +# must use a power of 2 Ingress Queues. +# 3. Egress Queues: 128K. PCI-E SR-IOV Virtual Functions must use a +# power of 2 Egress Queues. +# 4. MSI-X Vectors: 1088. A complication here is that the PCI-E SR-IOV +# Virtual Functions based off of a Physical Function all get the +# same umber of MSI-X Vectors as the base Physical Function. +# Additionally, regardless of whether Virtual Functions are enabled or +# not, their MSI-X "needs" are counted by the PCI-E implementation. +# And finally, all Physical Funcations capable of supporting Virtual +# Functions (PF0-3) must have the same number of configured TotalVFs in +# their SR-IOV Capabilities. +# 5. Multi-Port Support (MPS) TCAM: 336 entries to support MAC destination +# address matching on Ingress Packets. +# +# Some of the important OS/Driver resource needs are: +# 6. Some OS Drivers will manage all resources through a single Physical +# Function (currently PF0 but it could be any Physical Function). Thus, +# this "Unified PF" will need to have enough resources allocated to it +# to allow for this. And because of the MSI-X resource allocation +# constraints mentioned above, this probably means we'll either have to +# severely limit the TotalVFs if we continue to use PF0 as the Unified PF +# or we'll need to move the Unified PF into the PF4-7 range since those +# Physical Functions don't have any Virtual Functions associated with +# them. +# 7. Some OS Drivers will manage different ports and functions (NIC, +# storage, etc.) on different Physical Functions. For example, NIC +# functions for ports 0-3 on PF0-3, FCoE on PF4, iSCSI on PF5, etc. +# +# Some of the customer application needs which need to be accommodated: +# 8. Some customers will want to support large CPU count systems with +# good scaling. Thus, we'll need to accommodate a number of +# Ingress Queues and MSI-X Vectors to allow up to some number of CPUs +# to be involved per port and per application function. For example, +# in the case where all ports and application functions will be +# managed via a single Unified PF and we want to accommodate scaling up +# to 8 CPUs, we would want: +# +# 4 ports * +# 3 application functions (NIC, FCoE, iSCSI) per port * +# 8 Ingress Queue/MSI-X Vectors per application function +# +# for a total of 96 Ingress Queues and MSI-X Vectors on the Unified PF. +# (Plus a few for Firmware Event Queues, etc.) +# +# 9. Some customers will want to use T4's PCI-E SR-IOV Capability to allow +# Virtual Machines to directly access T4 functionality via SR-IOV +# Virtual Functions and "PCI Device Passthrough" -- this is especially +# true for the NIC application functionality. (Note that there is +# currently no ability to use the TOE, FCoE, iSCSI, etc. via Virtual +# Functions so this is in fact solely limited to NIC.) +# + + +# Global configuration settings. +# +[global] + rss_glb_config_mode = basicvirtual + rss_glb_config_options = tnlmapen,hashtoeplitz,tnlalllkp + + # PCIE_MA_RSP register + pcie_ma_rsp_timervalue = 500 # the timer value in units of us + reg[0x59c4] = 0x3/0x3 # enable the timers + + # PL_TIMEOUT register + pl_timeout_value = 200 # the timeout value in units of us + + # The following Scatter Gather Engine (SGE) settings assume a 4KB Host + # Page Size and a 64B L1 Cache Line Size. It programs the + # EgrStatusPageSize and IngPadBoundary to 64B and the PktShift to 2. + # If a Master PF Driver finds itself on a machine with different + # parameters, then the Master PF Driver is responsible for initializing + # these parameters to appropriate values. + # + # Notes: + # 1. The Free List Buffer Sizes below are raw and the firmware will + # round them up to the Ingress Padding Boundary. + # 2. The SGE Timer Values below are expressed below in microseconds. + # The firmware will convert these values to Core Clock Ticks when + # it processes the configuration parameters. + # + reg[0x1008] = 0x40810/0x21c70 # SGE_CONTROL + reg[0x100c] = 0x22222222 # SGE_HOST_PAGE_SIZE + reg[0x10a0] = 0x01040810 # SGE_INGRESS_RX_THRESHOLD + reg[0x1044] = 4096 # SGE_FL_BUFFER_SIZE0 + reg[0x1048] = 65536 # SGE_FL_BUFFER_SIZE1 + reg[0x104c] = 1536 # SGE_FL_BUFFER_SIZE2 + reg[0x1050] = 9024 # SGE_FL_BUFFER_SIZE3 + reg[0x1054] = 9216 # SGE_FL_BUFFER_SIZE4 + reg[0x1058] = 2048 # SGE_FL_BUFFER_SIZE5 + reg[0x105c] = 128 # SGE_FL_BUFFER_SIZE6 + reg[0x1060] = 8192 # SGE_FL_BUFFER_SIZE7 + reg[0x1064] = 16384 # SGE_FL_BUFFER_SIZE8 + reg[0x10a4] = 0xa000a000/0xf000f000 # SGE_DBFIFO_STATUS + reg[0x10a8] = 0x402000/0x402000 # SGE_DOORBELL_CONTROL + + # SGE_THROTTLE_CONTROL + bar2throttlecount = 500 # bar2throttlecount in us + + sge_timer_value = 5, 10, 20, 50, 100, 200 # SGE_TIMER_VALUE* in usecs + + + reg[0x1124] = 0x00000400/0x00000400 # SGE_CONTROL2, enable VFIFO; if + # SGE_VFIFO_SIZE is not set, then + # firmware will set it up in function + # of number of egress queues used + + reg[0x1130] = 0x00d5ffeb # SGE_DBP_FETCH_THRESHOLD, fetch + # threshold set to queue depth + # minus 128-entries for FL and HP + # queues, and 0xfff for LP which + # prompts the firmware to set it up + # in function of egress queues + # used + + reg[0x113c] = 0x0002ffc0 # SGE_VFIFO_SIZE, set to 0x2ffc0 which + # prompts the firmware to set it up in + # function of number of egress queues + # used + + reg[0x7dc0] = 0x062f8849 # TP_SHIFT_CNT + + # Selection of tuples for LE filter lookup, fields (and widths which + # must sum to <= 36): { IP Fragment (1), MPS Match Type (3), + # IP Protocol (8), [Inner] VLAN (17), Port (3), FCoE (1) } + # + filterMode = fragmentation, mpshittype, protocol, vlan, port, fcoe, srvrsram + + # Percentage of dynamic memory (in either the EDRAM or external MEM) + # to use for TP RX payload + tp_pmrx = 30 + + # TP RX payload page size + tp_pmrx_pagesize = 64K + + # TP number of RX channels + tp_nrxch = 0 # 0 (auto) = 1 + + # Percentage of dynamic memory (in either the EDRAM or external MEM) + # to use for TP TX payload + tp_pmtx = 50 + + # TP TX payload page size + tp_pmtx_pagesize = 64K + + # TP number of TX channels + tp_ntxch = 0 # 0 (auto) = equal number of ports + + reg[0x19c04] = 0x00400000/0x00400000 # LE Server SRAM Enable + +# Some "definitions" to make the rest of this a bit more readable. We support +# 4 ports, 3 functions (NIC, FCoE and iSCSI), scaling up to 8 "CPU Queue Sets" +# per function per port ... +# +# NMSIX = 1088 # available MSI-X Vectors +# NVI = 128 # available Virtual Interfaces +# NMPSTCAM = 336 # MPS TCAM entries +# +# NPORTS = 4 # ports +# NCPUS = 8 # CPUs we want to support scalably +# NFUNCS = 3 # functions per port (NIC, FCoE, iSCSI) + +# Breakdown of Virtual Interface/Queue/Interrupt resources for the "Unified +# PF" which many OS Drivers will use to manage most or all functions. +# +# Each Ingress Queue can use one MSI-X interrupt but some Ingress Queues can +# use Forwarded Interrupt Ingress Queues. For these latter, an Ingress Queue +# would be created and the Queue ID of a Forwarded Interrupt Ingress Queue +# will be specified as the "Ingress Queue Asynchronous Destination Index." +# Thus, the number of MSI-X Vectors assigned to the Unified PF will be less +# than or equal to the number of Ingress Queues ... +# +# NVI_NIC = 4 # NIC access to NPORTS +# NFLIQ_NIC = 32 # NIC Ingress Queues with Free Lists +# NETHCTRL_NIC = 32 # NIC Ethernet Control/TX Queues +# NEQ_NIC = 64 # NIC Egress Queues (FL, ETHCTRL/TX) +# NMPSTCAM_NIC = 16 # NIC MPS TCAM Entries (NPORTS*4) +# NMSIX_NIC = 32 # NIC MSI-X Interrupt Vectors (FLIQ) +# +# NVI_OFLD = 0 # Offload uses NIC function to access ports +# NFLIQ_OFLD = 16 # Offload Ingress Queues with Free Lists +# NETHCTRL_OFLD = 0 # Offload Ethernet Control/TX Queues +# NEQ_OFLD = 16 # Offload Egress Queues (FL) +# NMPSTCAM_OFLD = 0 # Offload MPS TCAM Entries (uses NIC's) +# NMSIX_OFLD = 16 # Offload MSI-X Interrupt Vectors (FLIQ) +# +# NVI_RDMA = 0 # RDMA uses NIC function to access ports +# NFLIQ_RDMA = 4 # RDMA Ingress Queues with Free Lists +# NETHCTRL_RDMA = 0 # RDMA Ethernet Control/TX Queues +# NEQ_RDMA = 4 # RDMA Egress Queues (FL) +# NMPSTCAM_RDMA = 0 # RDMA MPS TCAM Entries (uses NIC's) +# NMSIX_RDMA = 4 # RDMA MSI-X Interrupt Vectors (FLIQ) +# +# NEQ_WD = 128 # Wire Direct TX Queues and FLs +# NETHCTRL_WD = 64 # Wire Direct TX Queues +# NFLIQ_WD = 64 ` # Wire Direct Ingress Queues with Free Lists +# +# NVI_ISCSI = 4 # ISCSI access to NPORTS +# NFLIQ_ISCSI = 4 # ISCSI Ingress Queues with Free Lists +# NETHCTRL_ISCSI = 0 # ISCSI Ethernet Control/TX Queues +# NEQ_ISCSI = 4 # ISCSI Egress Queues (FL) +# NMPSTCAM_ISCSI = 4 # ISCSI MPS TCAM Entries (NPORTS) +# NMSIX_ISCSI = 4 # ISCSI MSI-X Interrupt Vectors (FLIQ) +# +# NVI_FCOE = 4 # FCOE access to NPORTS +# NFLIQ_FCOE = 34 # FCOE Ingress Queues with Free Lists +# NETHCTRL_FCOE = 32 # FCOE Ethernet Control/TX Queues +# NEQ_FCOE = 66 # FCOE Egress Queues (FL) +# NMPSTCAM_FCOE = 32 # FCOE MPS TCAM Entries (NPORTS) +# NMSIX_FCOE = 34 # FCOE MSI-X Interrupt Vectors (FLIQ) + +# Two extra Ingress Queues per function for Firmware Events and Forwarded +# Interrupts, and two extra interrupts per function for Firmware Events (or a +# Forwarded Interrupt Queue) and General Interrupts per function. +# +# NFLIQ_EXTRA = 6 # "extra" Ingress Queues 2*NFUNCS (Firmware and +# # Forwarded Interrupts +# NMSIX_EXTRA = 6 # extra interrupts 2*NFUNCS (Firmware and +# # General Interrupts + +# Microsoft HyperV resources. The HyperV Virtual Ingress Queues will have +# their interrupts forwarded to another set of Forwarded Interrupt Queues. +# +# NVI_HYPERV = 16 # VMs we want to support +# NVIIQ_HYPERV = 2 # Virtual Ingress Queues with Free Lists per VM +# NFLIQ_HYPERV = 40 # VIQs + NCPUS Forwarded Interrupt Queues +# NEQ_HYPERV = 32 # VIQs Free Lists +# NMPSTCAM_HYPERV = 16 # MPS TCAM Entries (NVI_HYPERV) +# NMSIX_HYPERV = 8 # NCPUS Forwarded Interrupt Queues + +# Adding all of the above Unified PF resource needs together: (NIC + OFLD + +# RDMA + ISCSI + FCOE + EXTRA + HYPERV) +# +# NVI_UNIFIED = 28 +# NFLIQ_UNIFIED = 106 +# NETHCTRL_UNIFIED = 32 +# NEQ_UNIFIED = 124 +# NMPSTCAM_UNIFIED = 40 +# +# The sum of all the MSI-X resources above is 74 MSI-X Vectors but we'll round +# that up to 128 to make sure the Unified PF doesn't run out of resources. +# +# NMSIX_UNIFIED = 128 +# +# The Storage PFs could need up to NPORTS*NCPUS + NMSIX_EXTRA MSI-X Vectors +# which is 34 but they're probably safe with 32. +# +# NMSIX_STORAGE = 32 + +# Note: The UnifiedPF is PF4 which doesn't have any Virtual Functions +# associated with it. Thus, the MSI-X Vector allocations we give to the +# UnifiedPF aren't inherited by any Virtual Functions. As a result we can +# provision many more Virtual Functions than we can if the UnifiedPF were +# one of PF0-3. +# + +# All of the below PCI-E parameters are actually stored in various *_init.txt +# files. We include them below essentially as comments. +# +# For PF0-3 we assign 8 vectors each for NIC Ingress Queues of the associated +# ports 0-3. +# +# For PF4, the Unified PF, we give it an MSI-X Table Size as outlined above. +# +# For PF5-6 we assign enough MSI-X Vectors to support FCoE and iSCSI +# storage applications across all four possible ports. +# +# Additionally, since the UnifiedPF isn't one of the per-port Physical +# Functions, we give the UnifiedPF and the PF0-3 Physical Functions +# different PCI Device IDs which will allow Unified and Per-Port Drivers +# to directly select the type of Physical Function to which they wish to be +# attached. +# +# Note that the actual values used for the PCI-E Intelectual Property will be +# 1 less than those below since that's the way it "counts" things. For +# readability, we use the number we actually mean ... +# +# PF0_INT = 8 # NCPUS +# PF1_INT = 8 # NCPUS +# PF2_INT = 8 # NCPUS +# PF3_INT = 8 # NCPUS +# PF0_3_INT = 32 # PF0_INT + PF1_INT + PF2_INT + PF3_INT +# +# PF4_INT = 128 # NMSIX_UNIFIED +# PF5_INT = 32 # NMSIX_STORAGE +# PF6_INT = 32 # NMSIX_STORAGE +# PF7_INT = 0 # Nothing Assigned +# PF4_7_INT = 192 # PF4_INT + PF5_INT + PF6_INT + PF7_INT +# +# PF0_7_INT = 224 # PF0_3_INT + PF4_7_INT +# +# With the above we can get 17 VFs/PF0-3 (limited by 336 MPS TCAM entries) +# but we'll lower that to 16 to make our total 64 and a nice power of 2 ... +# +# NVF = 16 + +# For those OSes which manage different ports on different PFs, we need +# only enough resources to support a single port's NIC application functions +# on PF0-3. The below assumes that we're only doing NIC with NCPUS "Queue +# Sets" for ports 0-3. The FCoE and iSCSI functions for such OSes will be +# managed on the "storage PFs" (see below). +# + +# Some OS Drivers manage all application functions for all ports via PF4. +# Thus we need to provide a large number of resources here. For Egress +# Queues we need to account for both TX Queues as well as Free List Queues +# (because the host is responsible for producing Free List Buffers for the +# hardware to consume). +# +[function "0"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 28 # NVI_UNIFIED + niqflint = 170 # NFLIQ_UNIFIED + NLFIQ_WD + nethctrl = 96 # NETHCTRL_UNIFIED + NETHCTRL_WD + neq = 252 # NEQ_UNIFIED + NEQ_WD + nexactf = 40 # NMPSTCAM_UNIFIED + cmask = all # access to all channels + pmask = all # access to all four ports ... + nroute = 32 # number of routing region entries + nclip = 32 # number of clip region entries + nfilter = 48 # number of filter region entries + nserver = 32 # number of server region entries + nhash = 2048 # number of hash region entries + protocol = nic_vm, ofld, rddp, rdmac, iscsi_initiator_pdu, iscsi_target_pdu + tp_l2t = 3072 + tp_ddp = 2 + tp_ddp_iscsi = 2 + tp_stag = 2 + tp_pbl = 5 + tp_rq = 7 + +# We have FCoE and iSCSI storage functions on PF5 and PF6 each of which may +# need to have Virtual Interfaces on each of the four ports with up to NCPUS +# "Queue Sets" each. +# +[function "1"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 4 # NPORTS + niqflint = 34 # NPORTS*NCPUS + NMSIX_EXTRA + nethctrl = 32 # NPORTS*NCPUS + neq = 66 # NPORTS*NCPUS * 2 (FL, ETHCTRL/TX) + 2 (EXTRA) + nexactf = 32 # NPORTS + adding 28 exact entries for FCoE + # which is OK since < MIN(SUM PF0..3, PF4) + # and we never load PF0..3 and PF4 concurrently + cmask = all # access to all channels + pmask = all # access to all four ports ... + nhash = 2048 + protocol = fcoe_initiator + tp_ddp = 2 + fcoe_nfcf = 16 + fcoe_nvnp = 32 + fcoe_nssn = 1024 + +# The following function, 1023, is not an actual PCIE function but is used to +# configure and reserve firmware internal resources that come from the global +# resource pool. +# +[function "1023"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 4 # NVI_UNIFIED + cmask = all # access to all channels + pmask = all # access to all four ports ... + nexactf = 8 # NPORTS + DCBX + + nfilter = 16 # number of filter region entries + +# For Virtual functions, we only allow NIC functionality and we only allow +# access to one port (1 << PF). Note that because of limitations in the +# Scatter Gather Engine (SGE) hardware which checks writes to VF KDOORBELL +# and GTS registers, the number of Ingress and Egress Queues must be a power +# of 2. +# +[function "0/*"] # NVF + wx_caps = 0x82 # DMAQ | VF + r_caps = 0x86 # DMAQ | VF | PORT + nvi = 1 # 1 port + niqflint = 4 # 2 "Queue Sets" + NXIQ + nethctrl = 2 # 2 "Queue Sets" + neq = 4 # 2 "Queue Sets" * 2 + nexactf = 4 + cmask = all # access to all channels + pmask = 0x1 # access to only one port ... + +[function "1/*"] # NVF + wx_caps = 0x82 # DMAQ | VF + r_caps = 0x86 # DMAQ | VF | PORT + nvi = 1 # 1 port + niqflint = 4 # 2 "Queue Sets" + NXIQ + nethctrl = 2 # 2 "Queue Sets" + neq = 4 # 2 "Queue Sets" * 2 + nexactf = 4 + cmask = all # access to all channels + pmask = 0x2 # access to only one port ... + +# MPS features a 196608 bytes ingress buffer that is used for ingress buffering +# for packets from the wire as well as the loopback path of the L2 switch. The +# folling params control how the buffer memory is distributed and the L2 flow +# control settings: +# +# bg_mem: %-age of mem to use for port/buffer group +# lpbk_mem: %-age of port/bg mem to use for loopback +# hwm: high watermark; bytes available when starting to send pause +# frames (in units of 0.1 MTU) +# lwm: low watermark; bytes remaining when sending 'unpause' frame +# (in inuits of 0.1 MTU) +# dwm: minimum delta between high and low watermark (in units of 100 +# Bytes) +# +[port "0"] + dcb = ppp, dcbx # configure for DCB PPP and enable DCBX offload + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "1"] + dcb = ppp, dcbx + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "2"] + dcb = ppp, dcbx + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "3"] + dcb = ppp, dcbx + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[fini] + version = 0x1425000d + checksum = 0xe56cb999 + +# Total resources used by above allocations: +# Virtual Interfaces: 104 +# Ingress Queues/w Free Lists and Interrupts: 526 +# Egress Queues: 702 +# MPS TCAM Entries: 336 +# MSI-X Vectors: 736 +# Virtual Functions: 64 +# +# $FreeBSD$ +# diff --git a/sys/dev/cxgbe/firmware/t5fw_cfg_uwire.txt b/sys/dev/cxgbe/firmware/t5fw_cfg_uwire.txt new file mode 100644 index 0000000..fd68b72 --- /dev/null +++ b/sys/dev/cxgbe/firmware/t5fw_cfg_uwire.txt @@ -0,0 +1,568 @@ +# Chelsio T5 Factory Default configuration file. +# +# Copyright (C) 2010-2013 Chelsio Communications. All rights reserved. +# +# DO NOT MODIFY THIS FILE UNDER ANY CIRCUMSTANCES. MODIFICATION OF +# THIS FILE WILL RESULT IN A NON-FUNCTIONAL T4 ADAPTER AND MAY RESULT +# IN PHYSICAL DAMAGE TO T4 ADAPTERS. + +# This file provides the default, power-on configuration for 4-port T4-based +# adapters shipped from the factory. These defaults are designed to address +# the needs of the vast majority of T4 customers. The basic idea is to have +# a default configuration which allows a customer to plug a T4 adapter in and +# have it work regardless of OS, driver or application except in the most +# unusual and/or demanding customer applications. +# +# Many of the T4 resources which are described by this configuration are +# finite. This requires balancing the configuration/operation needs of +# device drivers across OSes and a large number of customer application. +# +# Some of the more important resources to allocate and their constaints are: +# 1. Virtual Interfaces: 128. +# 2. Ingress Queues with Free Lists: 1024. PCI-E SR-IOV Virtual Functions +# must use a power of 2 Ingress Queues. +# 3. Egress Queues: 128K. PCI-E SR-IOV Virtual Functions must use a +# power of 2 Egress Queues. +# 4. MSI-X Vectors: 1088. A complication here is that the PCI-E SR-IOV +# Virtual Functions based off of a Physical Function all get the +# same umber of MSI-X Vectors as the base Physical Function. +# Additionally, regardless of whether Virtual Functions are enabled or +# not, their MSI-X "needs" are counted by the PCI-E implementation. +# And finally, all Physical Funcations capable of supporting Virtual +# Functions (PF0-3) must have the same number of configured TotalVFs in +# their SR-IOV Capabilities. +# 5. Multi-Port Support (MPS) TCAM: 336 entries to support MAC destination +# address matching on Ingress Packets. +# +# Some of the important OS/Driver resource needs are: +# 6. Some OS Drivers will manage all resources through a single Physical +# Function (currently PF0 but it could be any Physical Function). Thus, +# this "Unified PF" will need to have enough resources allocated to it +# to allow for this. And because of the MSI-X resource allocation +# constraints mentioned above, this probably means we'll either have to +# severely limit the TotalVFs if we continue to use PF0 as the Unified PF +# or we'll need to move the Unified PF into the PF4-7 range since those +# Physical Functions don't have any Virtual Functions associated with +# them. +# 7. Some OS Drivers will manage different ports and functions (NIC, +# storage, etc.) on different Physical Functions. For example, NIC +# functions for ports 0-3 on PF0-3, FCoE on PF4, iSCSI on PF5, etc. +# +# Some of the customer application needs which need to be accommodated: +# 8. Some customers will want to support large CPU count systems with +# good scaling. Thus, we'll need to accommodate a number of +# Ingress Queues and MSI-X Vectors to allow up to some number of CPUs +# to be involved per port and per application function. For example, +# in the case where all ports and application functions will be +# managed via a single Unified PF and we want to accommodate scaling up +# to 8 CPUs, we would want: +# +# 4 ports * +# 3 application functions (NIC, FCoE, iSCSI) per port * +# 8 Ingress Queue/MSI-X Vectors per application function +# +# for a total of 96 Ingress Queues and MSI-X Vectors on the Unified PF. +# (Plus a few for Firmware Event Queues, etc.) +# +# 9. Some customers will want to use T4's PCI-E SR-IOV Capability to allow +# Virtual Machines to directly access T4 functionality via SR-IOV +# Virtual Functions and "PCI Device Passthrough" -- this is especially +# true for the NIC application functionality. (Note that there is +# currently no ability to use the TOE, FCoE, iSCSI, etc. via Virtual +# Functions so this is in fact solely limited to NIC.) +# + + +# Global configuration settings. +# +[global] + rss_glb_config_mode = basicvirtual + rss_glb_config_options = tnlmapen,hashtoeplitz,tnlalllkp + + # PL_TIMEOUT register + pl_timeout_value = 200 # the timeout value in units of us + + # The following Scatter Gather Engine (SGE) settings assume a 4KB Host + # Page Size and a 64B L1 Cache Line Size. It programs the + # EgrStatusPageSize and IngPadBoundary to 64B and the PktShift to 2. + # If a Master PF Driver finds itself on a machine with different + # parameters, then the Master PF Driver is responsible for initializing + # these parameters to appropriate values. + # + # Notes: + # 1. The Free List Buffer Sizes below are raw and the firmware will + # round them up to the Ingress Padding Boundary. + # 2. The SGE Timer Values below are expressed below in microseconds. + # The firmware will convert these values to Core Clock Ticks when + # it processes the configuration parameters. + # + reg[0x1008] = 0x40810/0x21c70 # SGE_CONTROL + reg[0x100c] = 0x22222222 # SGE_HOST_PAGE_SIZE + reg[0x10a0] = 0x01040810 # SGE_INGRESS_RX_THRESHOLD + reg[0x1044] = 4096 # SGE_FL_BUFFER_SIZE0 + reg[0x1048] = 65536 # SGE_FL_BUFFER_SIZE1 + reg[0x104c] = 1536 # SGE_FL_BUFFER_SIZE2 + reg[0x1050] = 9024 # SGE_FL_BUFFER_SIZE3 + reg[0x1054] = 9216 # SGE_FL_BUFFER_SIZE4 + reg[0x1058] = 2048 # SGE_FL_BUFFER_SIZE5 + reg[0x105c] = 128 # SGE_FL_BUFFER_SIZE6 + reg[0x1060] = 8192 # SGE_FL_BUFFER_SIZE7 + reg[0x1064] = 16384 # SGE_FL_BUFFER_SIZE8 + reg[0x10a4] = 0xa000a000/0xf000f000 # SGE_DBFIFO_STATUS + reg[0x10a8] = 0x402000/0x402000 # SGE_DOORBELL_CONTROL + + # SGE_THROTTLE_CONTROL + bar2throttlecount = 500 # bar2throttlecount in us + + sge_timer_value = 5, 10, 20, 50, 100, 200 # SGE_TIMER_VALUE* in usecs + + + reg[0x1124] = 0x00000400/0x00000400 # SGE_CONTROL2, enable VFIFO; if + # SGE_VFIFO_SIZE is not set, then + # firmware will set it up in function + # of number of egress queues used + + reg[0x1130] = 0x00d5ffeb # SGE_DBP_FETCH_THRESHOLD, fetch + # threshold set to queue depth + # minus 128-entries for FL and HP + # queues, and 0xfff for LP which + # prompts the firmware to set it up + # in function of egress queues + # used + + reg[0x113c] = 0x0002ffc0 # SGE_VFIFO_SIZE, set to 0x2ffc0 which + # prompts the firmware to set it up in + # function of number of egress queues + # used + + reg[0x7dc0] = 0x062f8849 # TP_SHIFT_CNT + + # Selection of tuples for LE filter lookup, fields (and widths which + # must sum to <= 36): { IP Fragment (1), MPS Match Type (3), + # IP Protocol (8), [Inner] VLAN (17), Port (3), FCoE (1) } + # + filterMode = srvrsram, fragmentation, mpshittype, protocol, vlan, port, fcoe + filterMask = protocol, fcoe + + # Percentage of dynamic memory (in either the EDRAM or external MEM) + # to use for TP RX payload + tp_pmrx = 30 + + # TP RX payload page size + tp_pmrx_pagesize = 64K + + # TP number of RX channels + tp_nrxch = 0 # 0 (auto) = 1 + + # Percentage of dynamic memory (in either the EDRAM or external MEM) + # to use for TP TX payload + tp_pmtx = 50 + + # TP TX payload page size + tp_pmtx_pagesize = 64K + + # TP number of TX channels + tp_ntxch = 0 # 0 (auto) = equal number of ports + + # TP_GLOBAL_CONFIG + reg[0x7d08] = 0x00000800/0x00000800 # set IssFromCplEnable + + # LE_DB_CONFIG + reg[0x19c04] = 0x00400000/0x00400000 # LE Server SRAM Enable + +# Some "definitions" to make the rest of this a bit more readable. We support +# 4 ports, 3 functions (NIC, FCoE and iSCSI), scaling up to 8 "CPU Queue Sets" +# per function per port ... +# +# NMSIX = 1088 # available MSI-X Vectors +# NVI = 128 # available Virtual Interfaces +# NMPSTCAM = 336 # MPS TCAM entries +# +# NPORTS = 4 # ports +# NCPUS = 8 # CPUs we want to support scalably +# NFUNCS = 3 # functions per port (NIC, FCoE, iSCSI) + +# Breakdown of Virtual Interface/Queue/Interrupt resources for the "Unified +# PF" which many OS Drivers will use to manage most or all functions. +# +# Each Ingress Queue can use one MSI-X interrupt but some Ingress Queues can +# use Forwarded Interrupt Ingress Queues. For these latter, an Ingress Queue +# would be created and the Queue ID of a Forwarded Interrupt Ingress Queue +# will be specified as the "Ingress Queue Asynchronous Destination Index." +# Thus, the number of MSI-X Vectors assigned to the Unified PF will be less +# than or equal to the number of Ingress Queues ... +# +# NVI_NIC = 4 # NIC access to NPORTS +# NFLIQ_NIC = 32 # NIC Ingress Queues with Free Lists +# NETHCTRL_NIC = 32 # NIC Ethernet Control/TX Queues +# NEQ_NIC = 64 # NIC Egress Queues (FL, ETHCTRL/TX) +# NMPSTCAM_NIC = 16 # NIC MPS TCAM Entries (NPORTS*4) +# NMSIX_NIC = 32 # NIC MSI-X Interrupt Vectors (FLIQ) +# +# NVI_OFLD = 0 # Offload uses NIC function to access ports +# NFLIQ_OFLD = 16 # Offload Ingress Queues with Free Lists +# NETHCTRL_OFLD = 0 # Offload Ethernet Control/TX Queues +# NEQ_OFLD = 16 # Offload Egress Queues (FL) +# NMPSTCAM_OFLD = 0 # Offload MPS TCAM Entries (uses NIC's) +# NMSIX_OFLD = 16 # Offload MSI-X Interrupt Vectors (FLIQ) +# +# NVI_RDMA = 0 # RDMA uses NIC function to access ports +# NFLIQ_RDMA = 4 # RDMA Ingress Queues with Free Lists +# NETHCTRL_RDMA = 0 # RDMA Ethernet Control/TX Queues +# NEQ_RDMA = 4 # RDMA Egress Queues (FL) +# NMPSTCAM_RDMA = 0 # RDMA MPS TCAM Entries (uses NIC's) +# NMSIX_RDMA = 4 # RDMA MSI-X Interrupt Vectors (FLIQ) +# +# NEQ_WD = 128 # Wire Direct TX Queues and FLs +# NETHCTRL_WD = 64 # Wire Direct TX Queues +# NFLIQ_WD = 64 ` # Wire Direct Ingress Queues with Free Lists +# +# NVI_ISCSI = 4 # ISCSI access to NPORTS +# NFLIQ_ISCSI = 4 # ISCSI Ingress Queues with Free Lists +# NETHCTRL_ISCSI = 0 # ISCSI Ethernet Control/TX Queues +# NEQ_ISCSI = 4 # ISCSI Egress Queues (FL) +# NMPSTCAM_ISCSI = 4 # ISCSI MPS TCAM Entries (NPORTS) +# NMSIX_ISCSI = 4 # ISCSI MSI-X Interrupt Vectors (FLIQ) +# +# NVI_FCOE = 4 # FCOE access to NPORTS +# NFLIQ_FCOE = 34 # FCOE Ingress Queues with Free Lists +# NETHCTRL_FCOE = 32 # FCOE Ethernet Control/TX Queues +# NEQ_FCOE = 66 # FCOE Egress Queues (FL) +# NMPSTCAM_FCOE = 32 # FCOE MPS TCAM Entries (NPORTS) +# NMSIX_FCOE = 34 # FCOE MSI-X Interrupt Vectors (FLIQ) + +# Two extra Ingress Queues per function for Firmware Events and Forwarded +# Interrupts, and two extra interrupts per function for Firmware Events (or a +# Forwarded Interrupt Queue) and General Interrupts per function. +# +# NFLIQ_EXTRA = 6 # "extra" Ingress Queues 2*NFUNCS (Firmware and +# # Forwarded Interrupts +# NMSIX_EXTRA = 6 # extra interrupts 2*NFUNCS (Firmware and +# # General Interrupts + +# Microsoft HyperV resources. The HyperV Virtual Ingress Queues will have +# their interrupts forwarded to another set of Forwarded Interrupt Queues. +# +# NVI_HYPERV = 16 # VMs we want to support +# NVIIQ_HYPERV = 2 # Virtual Ingress Queues with Free Lists per VM +# NFLIQ_HYPERV = 40 # VIQs + NCPUS Forwarded Interrupt Queues +# NEQ_HYPERV = 32 # VIQs Free Lists +# NMPSTCAM_HYPERV = 16 # MPS TCAM Entries (NVI_HYPERV) +# NMSIX_HYPERV = 8 # NCPUS Forwarded Interrupt Queues + +# Adding all of the above Unified PF resource needs together: (NIC + OFLD + +# RDMA + ISCSI + FCOE + EXTRA + HYPERV) +# +# NVI_UNIFIED = 28 +# NFLIQ_UNIFIED = 106 +# NETHCTRL_UNIFIED = 32 +# NEQ_UNIFIED = 124 +# NMPSTCAM_UNIFIED = 40 +# +# The sum of all the MSI-X resources above is 74 MSI-X Vectors but we'll round +# that up to 128 to make sure the Unified PF doesn't run out of resources. +# +# NMSIX_UNIFIED = 128 +# +# The Storage PFs could need up to NPORTS*NCPUS + NMSIX_EXTRA MSI-X Vectors +# which is 34 but they're probably safe with 32. +# +# NMSIX_STORAGE = 32 + +# Note: The UnifiedPF is PF4 which doesn't have any Virtual Functions +# associated with it. Thus, the MSI-X Vector allocations we give to the +# UnifiedPF aren't inherited by any Virtual Functions. As a result we can +# provision many more Virtual Functions than we can if the UnifiedPF were +# one of PF0-3. +# + +# All of the below PCI-E parameters are actually stored in various *_init.txt +# files. We include them below essentially as comments. +# +# For PF0-3 we assign 8 vectors each for NIC Ingress Queues of the associated +# ports 0-3. +# +# For PF4, the Unified PF, we give it an MSI-X Table Size as outlined above. +# +# For PF5-6 we assign enough MSI-X Vectors to support FCoE and iSCSI +# storage applications across all four possible ports. +# +# Additionally, since the UnifiedPF isn't one of the per-port Physical +# Functions, we give the UnifiedPF and the PF0-3 Physical Functions +# different PCI Device IDs which will allow Unified and Per-Port Drivers +# to directly select the type of Physical Function to which they wish to be +# attached. +# +# Note that the actual values used for the PCI-E Intelectual Property will be +# 1 less than those below since that's the way it "counts" things. For +# readability, we use the number we actually mean ... +# +# PF0_INT = 8 # NCPUS +# PF1_INT = 8 # NCPUS +# PF2_INT = 8 # NCPUS +# PF3_INT = 8 # NCPUS +# PF0_3_INT = 32 # PF0_INT + PF1_INT + PF2_INT + PF3_INT +# +# PF4_INT = 128 # NMSIX_UNIFIED +# PF5_INT = 32 # NMSIX_STORAGE +# PF6_INT = 32 # NMSIX_STORAGE +# PF7_INT = 0 # Nothing Assigned +# PF4_7_INT = 192 # PF4_INT + PF5_INT + PF6_INT + PF7_INT +# +# PF0_7_INT = 224 # PF0_3_INT + PF4_7_INT +# +# With the above we can get 17 VFs/PF0-3 (limited by 336 MPS TCAM entries) +# but we'll lower that to 16 to make our total 64 and a nice power of 2 ... +# +# NVF = 16 + +# For those OSes which manage different ports on different PFs, we need +# only enough resources to support a single port's NIC application functions +# on PF0-3. The below assumes that we're only doing NIC with NCPUS "Queue +# Sets" for ports 0-3. The FCoE and iSCSI functions for such OSes will be +# managed on the "storage PFs" (see below). +# +[function "0"] + nvf = 16 # NVF on this function + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 1 # 1 port + niqflint = 8 # NCPUS "Queue Sets" + nethctrl = 8 # NCPUS "Queue Sets" + neq = 16 # niqflint + nethctrl Egress Queues + nexactf = 8 # number of exact MPSTCAM MAC filters + cmask = all # access to all channels + pmask = 0x1 # access to only one port + +[function "1"] + nvf = 16 # NVF on this function + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 1 # 1 port + niqflint = 8 # NCPUS "Queue Sets" + nethctrl = 8 # NCPUS "Queue Sets" + neq = 16 # niqflint + nethctrl Egress Queues + nexactf = 8 # number of exact MPSTCAM MAC filters + cmask = all # access to all channels + pmask = 0x2 # access to only one port + +[function "2"] + nvf = 16 # NVF on this function + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 1 # 1 port + niqflint = 8 # NCPUS "Queue Sets" + nethctrl = 8 # NCPUS "Queue Sets" + neq = 16 # niqflint + nethctrl Egress Queues + nexactf = 8 # number of exact MPSTCAM MAC filters + cmask = all # access to all channels + pmask = 0x4 # access to only one port + +[function "3"] + nvf = 16 # NVF on this function + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 1 # 1 port + niqflint = 8 # NCPUS "Queue Sets" + nethctrl = 8 # NCPUS "Queue Sets" + neq = 16 # niqflint + nethctrl Egress Queues + nexactf = 8 # number of exact MPSTCAM MAC filters + cmask = all # access to all channels + pmask = 0x8 # access to only one port + +# Some OS Drivers manage all application functions for all ports via PF4. +# Thus we need to provide a large number of resources here. For Egress +# Queues we need to account for both TX Queues as well as Free List Queues +# (because the host is responsible for producing Free List Buffers for the +# hardware to consume). +# +[function "4"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 28 # NVI_UNIFIED + niqflint = 170 # NFLIQ_UNIFIED + NLFIQ_WD + nethctrl = 100 # NETHCTRL_UNIFIED + NETHCTRL_WD + neq = 256 # NEQ_UNIFIED + NEQ_WD + nexactf = 40 # NMPSTCAM_UNIFIED + cmask = all # access to all channels + pmask = all # access to all four ports ... + nethofld = 1024 # number of user mode ethernet flow contexts + nroute = 32 # number of routing region entries + nclip = 32 # number of clip region entries + nfilter = 496 # number of filter region entries + nserver = 496 # number of server region entries + nhash = 12288 # number of hash region entries + protocol = nic_vm, ofld, rddp, rdmac, iscsi_initiator_pdu, iscsi_target_pdu + tp_l2t = 3072 + tp_ddp = 2 + tp_ddp_iscsi = 2 + tp_stag = 2 + tp_pbl = 5 + tp_rq = 7 + +# We have FCoE and iSCSI storage functions on PF5 and PF6 each of which may +# need to have Virtual Interfaces on each of the four ports with up to NCPUS +# "Queue Sets" each. +# +[function "5"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 4 # NPORTS + niqflint = 34 # NPORTS*NCPUS + NMSIX_EXTRA + nethctrl = 32 # NPORTS*NCPUS + neq = 64 # NPORTS*NCPUS * 2 (FL, ETHCTRL/TX) + nexactf = 4 # NPORTS + cmask = all # access to all channels + pmask = all # access to all four ports ... + nserver = 16 + nhash = 2048 + tp_l2t = 1024 + protocol = iscsi_initiator_fofld + tp_ddp_iscsi = 2 + iscsi_ntask = 2048 + iscsi_nsess = 2048 + iscsi_nconn_per_session = 1 + iscsi_ninitiator_instance = 64 + +[function "6"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 4 # NPORTS + niqflint = 34 # NPORTS*NCPUS + NMSIX_EXTRA + nethctrl = 32 # NPORTS*NCPUS + neq = 66 # NPORTS*NCPUS * 2 (FL, ETHCTRL/TX) + 2 (EXTRA) + nexactf = 32 # NPORTS + adding 28 exact entries for FCoE + # which is OK since < MIN(SUM PF0..3, PF4) + # and we never load PF0..3 and PF4 concurrently + cmask = all # access to all channels + pmask = all # access to all four ports ... + nhash = 2048 + protocol = fcoe_initiator + tp_ddp = 2 + fcoe_nfcf = 16 + fcoe_nvnp = 32 + fcoe_nssn = 1024 + +# The following function, 1023, is not an actual PCIE function but is used to +# configure and reserve firmware internal resources that come from the global +# resource pool. +# +[function "1023"] + wx_caps = all # write/execute permissions for all commands + r_caps = all # read permissions for all commands + nvi = 4 # NVI_UNIFIED + cmask = all # access to all channels + pmask = all # access to all four ports ... + nexactf = 8 # NPORTS + DCBX + + nfilter = 16 # number of filter region entries + +# For Virtual functions, we only allow NIC functionality and we only allow +# access to one port (1 << PF). Note that because of limitations in the +# Scatter Gather Engine (SGE) hardware which checks writes to VF KDOORBELL +# and GTS registers, the number of Ingress and Egress Queues must be a power +# of 2. +# +[function "0/*"] # NVF + wx_caps = 0x82 # DMAQ | VF + r_caps = 0x86 # DMAQ | VF | PORT + nvi = 1 # 1 port + niqflint = 4 # 2 "Queue Sets" + NXIQ + nethctrl = 2 # 2 "Queue Sets" + neq = 4 # 2 "Queue Sets" * 2 + nexactf = 4 + cmask = all # access to all channels + pmask = 0x1 # access to only one port ... + +[function "1/*"] # NVF + wx_caps = 0x82 # DMAQ | VF + r_caps = 0x86 # DMAQ | VF | PORT + nvi = 1 # 1 port + niqflint = 4 # 2 "Queue Sets" + NXIQ + nethctrl = 2 # 2 "Queue Sets" + neq = 4 # 2 "Queue Sets" * 2 + nexactf = 4 + cmask = all # access to all channels + pmask = 0x2 # access to only one port ... + +[function "2/*"] # NVF + wx_caps = 0x82 # DMAQ | VF + r_caps = 0x86 # DMAQ | VF | PORT + nvi = 1 # 1 port + niqflint = 4 # 2 "Queue Sets" + NXIQ + nethctrl = 2 # 2 "Queue Sets" + neq = 4 # 2 "Queue Sets" * 2 + nexactf = 4 + cmask = all # access to all channels + pmask = 0x4 # access to only one port ... + +[function "3/*"] # NVF + wx_caps = 0x82 # DMAQ | VF + r_caps = 0x86 # DMAQ | VF | PORT + nvi = 1 # 1 port + niqflint = 4 # 2 "Queue Sets" + NXIQ + nethctrl = 2 # 2 "Queue Sets" + neq = 4 # 2 "Queue Sets" * 2 + nexactf = 4 + cmask = all # access to all channels + pmask = 0x8 # access to only one port ... + +# MPS features a 196608 bytes ingress buffer that is used for ingress buffering +# for packets from the wire as well as the loopback path of the L2 switch. The +# folling params control how the buffer memory is distributed and the L2 flow +# control settings: +# +# bg_mem: %-age of mem to use for port/buffer group +# lpbk_mem: %-age of port/bg mem to use for loopback +# hwm: high watermark; bytes available when starting to send pause +# frames (in units of 0.1 MTU) +# lwm: low watermark; bytes remaining when sending 'unpause' frame +# (in inuits of 0.1 MTU) +# dwm: minimum delta between high and low watermark (in units of 100 +# Bytes) +# +[port "0"] + dcb = ppp, dcbx # configure for DCB PPP and enable DCBX offload + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "1"] + dcb = ppp, dcbx + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "2"] + dcb = ppp, dcbx + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[port "3"] + dcb = ppp, dcbx + bg_mem = 25 + lpbk_mem = 25 + hwm = 30 + lwm = 15 + dwm = 30 + +[fini] + version = 0x1425000f + checksum = 0x23a2d850 + +# Total resources used by above allocations: +# Virtual Interfaces: 104 +# Ingress Queues/w Free Lists and Interrupts: 526 +# Egress Queues: 702 +# MPS TCAM Entries: 336 +# MSI-X Vectors: 736 +# Virtual Functions: 64 +# +# $FreeBSD$ +# diff --git a/sys/dev/cxgbe/offload.h b/sys/dev/cxgbe/offload.h index 6090775..7f4b38e 100644 --- a/sys/dev/cxgbe/offload.h +++ b/sys/dev/cxgbe/offload.h @@ -140,6 +140,7 @@ struct tom_tunables { int ddp; int indsz; int ddp_thres; + int rx_coalesce; }; int t4_register_uld(struct uld_info *); diff --git a/sys/dev/cxgbe/t4_main.c b/sys/dev/cxgbe/t4_main.c index e3836ce..762540e 100644 --- a/sys/dev/cxgbe/t4_main.c +++ b/sys/dev/cxgbe/t4_main.c @@ -373,6 +373,7 @@ static int t4_sysctls(struct adapter *); static int cxgbe_sysctls(struct port_info *); static int sysctl_int_array(SYSCTL_HANDLER_ARGS); static int sysctl_bitfield(SYSCTL_HANDLER_ARGS); +static int sysctl_btphy(SYSCTL_HANDLER_ARGS); static int sysctl_holdoff_tmr_idx(SYSCTL_HANDLER_ARGS); static int sysctl_holdoff_pktc_idx(SYSCTL_HANDLER_ARGS); static int sysctl_qsize_rxq(SYSCTL_HANDLER_ARGS); @@ -633,9 +634,6 @@ t4_attach(device_t dev) if (rc != 0) goto done; /* error message displayed already */ - for (i = 0; i < NCHAN; i++) - sc->params.tp.tx_modq[i] = i; - rc = t4_create_dma_tag(sc); if (rc != 0) goto done; /* error message displayed already */ @@ -682,6 +680,7 @@ t4_attach(device_t dev) } pi->xact_addr_filt = -1; + pi->linkdnrc = -1; pi->qsize_rxq = t4_qsize_rxq; pi->qsize_txq = t4_qsize_txq; @@ -1075,9 +1074,10 @@ cxgbe_ioctl(struct ifnet *ifp, unsigned long cmd, caddr_t data) if (rc) return (rc); ifp->if_mtu = mtu; - if (ifp->if_drv_flags & IFF_DRV_RUNNING) { + if (pi->flags & PORT_INIT_DONE) { t4_update_fl_bufsize(ifp); - rc = update_mac_settings(pi, XGMAC_MTU); + if (ifp->if_drv_flags & IFF_DRV_RUNNING) + rc = update_mac_settings(pi, XGMAC_MTU); } end_synchronized_op(sc, 0); break; @@ -1826,11 +1826,11 @@ allocate: } #define FW_VERSION(chip) ( \ - V_FW_HDR_FW_VER_MAJOR(FW_VERSION_MAJOR_##chip) | \ - V_FW_HDR_FW_VER_MINOR(FW_VERSION_MINOR_##chip) | \ - V_FW_HDR_FW_VER_MICRO(FW_VERSION_MICRO_##chip) | \ - V_FW_HDR_FW_VER_BUILD(FW_VERSION_BUILD_##chip)) -#define FW_INTFVER(chip, intf) (FW_HDR_INTFVER_##intf) + V_FW_HDR_FW_VER_MAJOR(chip##FW_VERSION_MAJOR) | \ + V_FW_HDR_FW_VER_MINOR(chip##FW_VERSION_MINOR) | \ + V_FW_HDR_FW_VER_MICRO(chip##FW_VERSION_MICRO) | \ + V_FW_HDR_FW_VER_BUILD(chip##FW_VERSION_BUILD)) +#define FW_INTFVER(chip, intf) (chip##FW_HDR_INTFVER_##intf) struct fw_info { uint8_t chip; @@ -2089,6 +2089,7 @@ prep_firmware(struct adapter *sc) G_FW_HDR_FW_VER_MINOR(sc->params.fw_vers), G_FW_HDR_FW_VER_MICRO(sc->params.fw_vers), G_FW_HDR_FW_VER_BUILD(sc->params.fw_vers)); + t4_get_tp_version(sc, &sc->params.tp_vers); /* Reset device */ if (need_fw_reset && @@ -2932,7 +2933,8 @@ cxgbe_uninit_synchronized(struct port_info *pi) pi->link_cfg.link_ok = 0; pi->link_cfg.speed = 0; - t4_os_link_changed(sc, pi->port_id, 0); + pi->linkdnrc = -1; + t4_os_link_changed(sc, pi->port_id, 0, -1); return (0); } @@ -3634,7 +3636,7 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x1fee0, 0x1fee0, 0x1ff00, 0x1ff84, 0x1ffc0, 0x1ffc8, - 0x30000, 0x30040, + 0x30000, 0x30030, 0x30100, 0x30144, 0x30190, 0x301d0, 0x30200, 0x30318, @@ -3643,29 +3645,29 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x30800, 0x30834, 0x308c0, 0x30908, 0x30910, 0x309ac, - 0x30a00, 0x30a04, - 0x30a0c, 0x30a2c, + 0x30a00, 0x30a2c, 0x30a44, 0x30a50, 0x30a74, 0x30c24, + 0x30d00, 0x30d00, 0x30d08, 0x30d14, 0x30d1c, 0x30d20, 0x30d3c, 0x30d50, 0x31200, 0x3120c, 0x31220, 0x31220, 0x31240, 0x31240, - 0x31600, 0x31600, - 0x31608, 0x3160c, + 0x31600, 0x3160c, 0x31a00, 0x31a1c, - 0x31e04, 0x31e20, + 0x31e00, 0x31e20, 0x31e38, 0x31e3c, 0x31e80, 0x31e80, 0x31e88, 0x31ea8, 0x31eb0, 0x31eb4, 0x31ec8, 0x31ed4, 0x31fb8, 0x32004, - 0x32208, 0x3223c, - 0x32248, 0x3227c, - 0x32288, 0x322bc, + 0x32200, 0x32200, + 0x32208, 0x32240, + 0x32248, 0x32280, + 0x32288, 0x322c0, 0x322c8, 0x322fc, 0x32600, 0x32630, 0x32a00, 0x32abc, @@ -3697,7 +3699,7 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x33c28, 0x33c28, 0x33c3c, 0x33c50, 0x33cf0, 0x33cfc, - 0x34000, 0x34040, + 0x34000, 0x34030, 0x34100, 0x34144, 0x34190, 0x341d0, 0x34200, 0x34318, @@ -3706,29 +3708,29 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x34800, 0x34834, 0x348c0, 0x34908, 0x34910, 0x349ac, - 0x34a00, 0x34a04, - 0x34a0c, 0x34a2c, + 0x34a00, 0x34a2c, 0x34a44, 0x34a50, 0x34a74, 0x34c24, + 0x34d00, 0x34d00, 0x34d08, 0x34d14, 0x34d1c, 0x34d20, 0x34d3c, 0x34d50, 0x35200, 0x3520c, 0x35220, 0x35220, 0x35240, 0x35240, - 0x35600, 0x35600, - 0x35608, 0x3560c, + 0x35600, 0x3560c, 0x35a00, 0x35a1c, - 0x35e04, 0x35e20, + 0x35e00, 0x35e20, 0x35e38, 0x35e3c, 0x35e80, 0x35e80, 0x35e88, 0x35ea8, 0x35eb0, 0x35eb4, 0x35ec8, 0x35ed4, 0x35fb8, 0x36004, - 0x36208, 0x3623c, - 0x36248, 0x3627c, - 0x36288, 0x362bc, + 0x36200, 0x36200, + 0x36208, 0x36240, + 0x36248, 0x36280, + 0x36288, 0x362c0, 0x362c8, 0x362fc, 0x36600, 0x36630, 0x36a00, 0x36abc, @@ -3760,7 +3762,7 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x37c28, 0x37c28, 0x37c3c, 0x37c50, 0x37cf0, 0x37cfc, - 0x38000, 0x38040, + 0x38000, 0x38030, 0x38100, 0x38144, 0x38190, 0x381d0, 0x38200, 0x38318, @@ -3769,29 +3771,29 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x38800, 0x38834, 0x388c0, 0x38908, 0x38910, 0x389ac, - 0x38a00, 0x38a04, - 0x38a0c, 0x38a2c, + 0x38a00, 0x38a2c, 0x38a44, 0x38a50, 0x38a74, 0x38c24, + 0x38d00, 0x38d00, 0x38d08, 0x38d14, 0x38d1c, 0x38d20, 0x38d3c, 0x38d50, 0x39200, 0x3920c, 0x39220, 0x39220, 0x39240, 0x39240, - 0x39600, 0x39600, - 0x39608, 0x3960c, + 0x39600, 0x3960c, 0x39a00, 0x39a1c, - 0x39e04, 0x39e20, + 0x39e00, 0x39e20, 0x39e38, 0x39e3c, 0x39e80, 0x39e80, 0x39e88, 0x39ea8, 0x39eb0, 0x39eb4, 0x39ec8, 0x39ed4, 0x39fb8, 0x3a004, - 0x3a208, 0x3a23c, - 0x3a248, 0x3a27c, - 0x3a288, 0x3a2bc, + 0x3a200, 0x3a200, + 0x3a208, 0x3a240, + 0x3a248, 0x3a280, + 0x3a288, 0x3a2c0, 0x3a2c8, 0x3a2fc, 0x3a600, 0x3a630, 0x3aa00, 0x3aabc, @@ -3823,7 +3825,7 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x3bc28, 0x3bc28, 0x3bc3c, 0x3bc50, 0x3bcf0, 0x3bcfc, - 0x3c000, 0x3c040, + 0x3c000, 0x3c030, 0x3c100, 0x3c144, 0x3c190, 0x3c1d0, 0x3c200, 0x3c318, @@ -3832,29 +3834,29 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x3c800, 0x3c834, 0x3c8c0, 0x3c908, 0x3c910, 0x3c9ac, - 0x3ca00, 0x3ca04, - 0x3ca0c, 0x3ca2c, + 0x3ca00, 0x3ca2c, 0x3ca44, 0x3ca50, 0x3ca74, 0x3cc24, + 0x3cd00, 0x3cd00, 0x3cd08, 0x3cd14, 0x3cd1c, 0x3cd20, 0x3cd3c, 0x3cd50, 0x3d200, 0x3d20c, 0x3d220, 0x3d220, 0x3d240, 0x3d240, - 0x3d600, 0x3d600, - 0x3d608, 0x3d60c, + 0x3d600, 0x3d60c, 0x3da00, 0x3da1c, - 0x3de04, 0x3de20, + 0x3de00, 0x3de20, 0x3de38, 0x3de3c, 0x3de80, 0x3de80, 0x3de88, 0x3dea8, 0x3deb0, 0x3deb4, 0x3dec8, 0x3ded4, 0x3dfb8, 0x3e004, - 0x3e208, 0x3e23c, - 0x3e248, 0x3e27c, - 0x3e288, 0x3e2bc, + 0x3e200, 0x3e200, + 0x3e208, 0x3e240, + 0x3e248, 0x3e280, + 0x3e288, 0x3e2c0, 0x3e2c8, 0x3e2fc, 0x3e600, 0x3e630, 0x3ea00, 0x3eabc, @@ -3893,7 +3895,7 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x40200, 0x40298, 0x402ac, 0x4033c, 0x403f8, 0x403fc, - 0x41300, 0x413c4, + 0x41304, 0x413c4, 0x41400, 0x4141c, 0x41480, 0x414d0, 0x44000, 0x44078, @@ -3921,7 +3923,7 @@ t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 0x48200, 0x48298, 0x482ac, 0x4833c, 0x483f8, 0x483fc, - 0x49300, 0x493c4, + 0x49304, 0x493c4, 0x49400, 0x4941c, 0x49480, 0x494d0, 0x4c000, 0x4c078, @@ -4189,6 +4191,9 @@ t4_sysctls(struct adapter *sc) sizeof(sc->sge.counter_val), sysctl_int_array, "A", "interrupt holdoff packet counter values"); + SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nfilters", CTLFLAG_RD, + NULL, sc->tids.nftids, "number of filters"); + #ifdef SBUF_DRAIN /* * dev.t4nex.X.misc. Marked CTLFLAG_SKIP to avoid information overload. @@ -4380,6 +4385,10 @@ t4_sysctls(struct adapter *sc) G_RXCOALESCESIZE(t4_read_reg(sc, A_TP_PARA_REG2)); SYSCTL_ADD_INT(ctx, children, OID_AUTO, "ddp_thres", CTLFLAG_RW, &sc->tt.ddp_thres, 0, "DDP threshold"); + + sc->tt.rx_coalesce = 1; + SYSCTL_ADD_INT(ctx, children, OID_AUTO, "rx_coalesce", + CTLFLAG_RW, &sc->tt.rx_coalesce, 0, "receive coalescing"); } #endif @@ -4402,6 +4411,16 @@ cxgbe_sysctls(struct port_info *pi) oid = device_get_sysctl_tree(pi->dev); children = SYSCTL_CHILDREN(oid); + SYSCTL_ADD_INT(ctx, children, OID_AUTO, "linkdnrc", CTLFLAG_RD, + &pi->linkdnrc, 0, "reason why link is down"); + if (pi->port_type == FW_PORT_TYPE_BT_XAUI) { + SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", + CTLTYPE_INT | CTLFLAG_RD, pi, 0, sysctl_btphy, "I", + "PHY temperature (in Celsius)"); + SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fw_version", + CTLTYPE_INT | CTLFLAG_RD, pi, 1, sysctl_btphy, "I", + "PHY firmware version"); + } SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nrxq", CTLFLAG_RD, &pi->nrxq, 0, "# of rx queues"); SYSCTL_ADD_INT(ctx, children, OID_AUTO, "ntxq", CTLFLAG_RD, @@ -4639,12 +4658,40 @@ sysctl_bitfield(SYSCTL_HANDLER_ARGS) } static int +sysctl_btphy(SYSCTL_HANDLER_ARGS) +{ + struct port_info *pi = arg1; + int op = arg2; + struct adapter *sc = pi->adapter; + u_int v; + int rc; + + rc = begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4btt"); + if (rc) + return (rc); + /* XXX: magic numbers */ + rc = -t4_mdio_rd(sc, sc->mbox, pi->mdio_addr, 0x1e, op ? 0x20 : 0xc820, + &v); + end_synchronized_op(sc, 0); + if (rc) + return (rc); + if (op == 0) + v /= 256; + + rc = sysctl_handle_int(oidp, &v, 0, req); + return (rc); +} + +static int sysctl_holdoff_tmr_idx(SYSCTL_HANDLER_ARGS) { struct port_info *pi = arg1; struct adapter *sc = pi->adapter; int idx, rc, i; struct sge_rxq *rxq; +#ifdef TCP_OFFLOAD + struct sge_ofld_rxq *ofld_rxq; +#endif uint8_t v; idx = pi->tmr_idx; @@ -4669,6 +4716,15 @@ sysctl_holdoff_tmr_idx(SYSCTL_HANDLER_ARGS) rxq->iq.intr_params = v; #endif } +#ifdef TCP_OFFLOAD + for_each_ofld_rxq(pi, i, ofld_rxq) { +#ifdef atomic_store_rel_8 + atomic_store_rel_8(&ofld_rxq->iq.intr_params, v); +#else + ofld_rxq->iq.intr_params = v; +#endif + } +#endif pi->tmr_idx = idx; end_synchronized_op(sc, LOCK_HELD); @@ -6519,13 +6575,14 @@ get_filter_mode(struct adapter *sc, uint32_t *mode) t4_read_indirect(sc, A_TP_PIO_ADDR, A_TP_PIO_DATA, &fconf, 1, A_TP_VLAN_PRI_MAP); - if (sc->filter_mode != fconf) { + if (sc->params.tp.vlan_pri_map != fconf) { log(LOG_WARNING, "%s: cached filter mode out of sync %x %x.\n", - device_get_nameunit(sc->dev), sc->filter_mode, fconf); - sc->filter_mode = fconf; + device_get_nameunit(sc->dev), sc->params.tp.vlan_pri_map, + fconf); + sc->params.tp.vlan_pri_map = fconf; } - *mode = fconf_to_mode(sc->filter_mode); + *mode = fconf_to_mode(sc->params.tp.vlan_pri_map); end_synchronized_op(sc, LOCK_HELD); return (0); @@ -6658,7 +6715,8 @@ set_filter(struct adapter *sc, struct t4_filter *t) } /* Validate against the global filter mode */ - if ((sc->filter_mode | fspec_to_fconf(&t->fs)) != sc->filter_mode) { + if ((sc->params.tp.vlan_pri_map | fspec_to_fconf(&t->fs)) != + sc->params.tp.vlan_pri_map) { rc = E2BIG; goto done; } @@ -7171,16 +7229,20 @@ t4_os_portmod_changed(const struct adapter *sc, int idx) } void -t4_os_link_changed(struct adapter *sc, int idx, int link_stat) +t4_os_link_changed(struct adapter *sc, int idx, int link_stat, int reason) { struct port_info *pi = sc->port[idx]; struct ifnet *ifp = pi->ifp; if (link_stat) { + pi->linkdnrc = -1; ifp->if_baudrate = IF_Mbps(pi->link_cfg.speed); if_link_state_change(ifp, LINK_STATE_UP); - } else + } else { + if (reason >= 0) + pi->linkdnrc = reason; if_link_state_change(ifp, LINK_STATE_DOWN); + } } void diff --git a/sys/dev/cxgbe/t4_sge.c b/sys/dev/cxgbe/t4_sge.c index 84fb44e..586137a 100644 --- a/sys/dev/cxgbe/t4_sge.c +++ b/sys/dev/cxgbe/t4_sge.c @@ -474,16 +474,11 @@ t4_read_chip_settings(struct adapter *sc) s->s_qpp = r & M_QUEUESPERPAGEPF0; } - r = t4_read_reg(sc, A_TP_TIMER_RESOLUTION); - sc->params.tp.tre = G_TIMERRESOLUTION(r); - sc->params.tp.dack_re = G_DELAYEDACKRESOLUTION(r); + t4_init_tp_params(sc); t4_read_mtu_tbl(sc, sc->params.mtus, NULL); t4_load_mtus(sc, sc->params.mtus, sc->params.a_wnd, sc->params.b_wnd); - t4_read_indirect(sc, A_TP_PIO_ADDR, A_TP_PIO_DATA, &sc->filter_mode, 1, - A_TP_VLAN_PRI_MAP); - return (rc); } @@ -664,6 +659,18 @@ mtu_to_bufsize(int mtu) return (bufsize); } +#ifdef TCP_OFFLOAD +static inline int +mtu_to_bufsize_toe(struct adapter *sc, int mtu) +{ + + if (sc->tt.rx_coalesce) + return (G_RXCOALESCESIZE(t4_read_reg(sc, A_TP_PARA_REG2))); + + return (mtu); +} +#endif + int t4_setup_port_queues(struct port_info *pi) { @@ -678,9 +685,10 @@ t4_setup_port_queues(struct port_info *pi) #endif char name[16]; struct adapter *sc = pi->adapter; + struct ifnet *ifp = pi->ifp; struct sysctl_oid *oid = device_get_sysctl_tree(pi->dev); struct sysctl_oid_list *children = SYSCTL_CHILDREN(oid); - int bufsize = mtu_to_bufsize(pi->ifp->if_mtu); + int bufsize; oid = SYSCTL_ADD_NODE(&pi->ctx, children, OID_AUTO, "rxq", CTLFLAG_RD, NULL, "rx queues"); @@ -701,6 +709,7 @@ t4_setup_port_queues(struct port_info *pi) * a) initialize iq and fl * b) allocate queue iff it will take direct interrupts. */ + bufsize = mtu_to_bufsize(ifp->if_mtu); for_each_rxq(pi, i, rxq) { init_iq(&rxq->iq, sc, pi->tmr_idx, pi->pktc_idx, pi->qsize_rxq, @@ -724,6 +733,7 @@ t4_setup_port_queues(struct port_info *pi) } #ifdef TCP_OFFLOAD + bufsize = mtu_to_bufsize_toe(sc, ifp->if_mtu); for_each_ofld_rxq(pi, i, ofld_rxq) { init_iq(&ofld_rxq->iq, sc, pi->tmr_idx, pi->pktc_idx, @@ -731,7 +741,7 @@ t4_setup_port_queues(struct port_info *pi) snprintf(name, sizeof(name), "%s ofld_rxq%d-fl", device_get_nameunit(pi->dev), i); - init_fl(&ofld_rxq->fl, pi->qsize_rxq / 8, OFLD_BUF_SIZE, name); + init_fl(&ofld_rxq->fl, pi->qsize_rxq / 8, bufsize, name); if (sc->flags & INTR_DIRECT || (sc->intr_count > 1 && pi->nofldrxq > pi->nrxq)) { @@ -1342,7 +1352,7 @@ t4_wrq_tx_locked(struct adapter *sc, struct sge_wrq *wrq, struct wrqe *wr) eq->pidx -= eq->cap; eq->pending += ndesc; - if (eq->pending > 16) + if (eq->pending >= 8) ring_eq_db(sc, eq); wrq->tx_wrs++; @@ -1513,8 +1523,8 @@ t4_eth_tx(struct ifnet *ifp, struct sge_txq *txq, struct mbuf *m) if (sgl.nsegs == 0) m_freem(m); doorbell: - if (eq->pending >= 64) - ring_eq_db(sc, eq); + if (eq->pending >= 8) + ring_eq_db(sc, eq); can_reclaim = reclaimable(eq); if (can_reclaim >= 32) @@ -1562,9 +1572,13 @@ t4_update_fl_bufsize(struct ifnet *ifp) { struct port_info *pi = ifp->if_softc; struct sge_rxq *rxq; +#ifdef TCP_OFFLOAD + struct sge_ofld_rxq *ofld_rxq; +#endif struct sge_fl *fl; - int i, bufsize = mtu_to_bufsize(ifp->if_mtu); + int i, bufsize; + bufsize = mtu_to_bufsize(ifp->if_mtu); for_each_rxq(pi, i, rxq) { fl = &rxq->fl; @@ -1572,6 +1586,16 @@ t4_update_fl_bufsize(struct ifnet *ifp) set_fl_tag_idx(fl, bufsize); FL_UNLOCK(fl); } +#ifdef TCP_OFFLOAD + bufsize = mtu_to_bufsize_toe(pi->adapter, ifp->if_mtu); + for_each_ofld_rxq(pi, i, ofld_rxq) { + fl = &ofld_rxq->fl; + + FL_LOCK(fl); + set_fl_tag_idx(fl, bufsize); + FL_UNLOCK(fl); + } +#endif } int diff --git a/sys/dev/cxgbe/tom/t4_connect.c b/sys/dev/cxgbe/tom/t4_connect.c index ac48d31..08267cd 100644 --- a/sys/dev/cxgbe/tom/t4_connect.c +++ b/sys/dev/cxgbe/tom/t4_connect.c @@ -57,6 +57,7 @@ __FBSDID("$FreeBSD$"); #include "common/common.h" #include "common/t4_msg.h" #include "common/t4_regs.h" +#include "common/t4_regs_values.h" #include "tom/t4_tom_l2t.h" #include "tom/t4_tom.h" @@ -246,9 +247,12 @@ calc_opt2a(struct socket *so, struct toepcb *toep) /* RX_COALESCE is always a valid value (M_RX_COALESCE). */ if (is_t4(sc)) opt2 |= F_RX_COALESCE_VALID; - else + else { opt2 |= F_T5_OPT_2_VALID; - opt2 |= V_RX_COALESCE(M_RX_COALESCE); + opt2 |= F_CONG_CNTRL_VALID; /* OPT_2_ISS really, for T5 */ + } + if (sc->tt.rx_coalesce) + opt2 |= V_RX_COALESCE(M_RX_COALESCE); #ifdef USE_DDP_RX_FLOW_CONTROL if (toep->ulp_mode == ULP_MODE_TCPDDP) @@ -384,10 +388,18 @@ t4_connect(struct toedev *tod, struct socket *so, struct rtentry *rt, if (toep->ce == NULL) DONT_OFFLOAD_ACTIVE_OPEN(ENOENT); - INIT_TP_WR(cpl, 0); + if (is_t4(sc)) { + INIT_TP_WR(cpl, 0); + cpl->params = select_ntuple(pi, toep->l2te); + } else { + struct cpl_t5_act_open_req6 *c5 = (void *)cpl; + + INIT_TP_WR(c5, 0); + c5->iss = htobe32(tp->iss); + c5->params = select_ntuple(pi, toep->l2te); + } OPCODE_TID(cpl) = htobe32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6, qid_atid)); - cpl->local_port = inp->inp_lport; cpl->local_ip_hi = *(uint64_t *)&inp->in6p_laddr.s6_addr[0]; cpl->local_ip_lo = *(uint64_t *)&inp->in6p_laddr.s6_addr[8]; @@ -397,20 +409,19 @@ t4_connect(struct toedev *tod, struct socket *so, struct rtentry *rt, cpl->opt0 = calc_opt0(so, pi, toep->l2te, mtu_idx, rscale, toep->rx_credits, toep->ulp_mode); cpl->opt2 = calc_opt2a(so, toep); + } else { + struct cpl_act_open_req *cpl = wrtod(wr); + if (is_t4(sc)) { - cpl->params = select_ntuple(pi, toep->l2te, - sc->filter_mode); + INIT_TP_WR(cpl, 0); + cpl->params = select_ntuple(pi, toep->l2te); } else { - struct cpl_t5_act_open_req6 *c5 = (void *)cpl; + struct cpl_t5_act_open_req *c5 = (void *)cpl; - c5->rsvd = 0; - c5->params = select_ntuple(pi, toep->l2te, - sc->filter_mode); + INIT_TP_WR(c5, 0); + c5->iss = htobe32(tp->iss); + c5->params = select_ntuple(pi, toep->l2te); } - } else { - struct cpl_act_open_req *cpl = wrtod(wr); - - INIT_TP_WR(cpl, 0); OPCODE_TID(cpl) = htobe32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ, qid_atid)); inp_4tuple_get(inp, &cpl->local_ip, &cpl->local_port, @@ -418,16 +429,6 @@ t4_connect(struct toedev *tod, struct socket *so, struct rtentry *rt, cpl->opt0 = calc_opt0(so, pi, toep->l2te, mtu_idx, rscale, toep->rx_credits, toep->ulp_mode); cpl->opt2 = calc_opt2a(so, toep); - if (is_t4(sc)) { - cpl->params = select_ntuple(pi, toep->l2te, - sc->filter_mode); - } else { - struct cpl_t5_act_open_req6 *c5 = (void *)cpl; - - c5->rsvd = 0; - c5->params = select_ntuple(pi, toep->l2te, - sc->filter_mode); - } } CTR5(KTR_CXGBE, "%s: atid %u (%s), toep %p, inp %p", __func__, diff --git a/sys/dev/cxgbe/tom/t4_listen.c b/sys/dev/cxgbe/tom/t4_listen.c index 7db4126..9e1dc80 100644 --- a/sys/dev/cxgbe/tom/t4_listen.c +++ b/sys/dev/cxgbe/tom/t4_listen.c @@ -674,6 +674,12 @@ t4_syncache_respond(struct toedev *tod, void *arg, struct mbuf *m) synqe->iss = be32toh(th->th_seq); synqe->ts = to.to_tsval; + if (is_t5(sc)) { + struct cpl_t5_pass_accept_rpl *rpl5 = wrtod(wr); + + rpl5->iss = th->th_seq; + } + e = &sc->l2t->l2tab[synqe->l2e_idx]; t4_l2t_send(sc, wr, e); @@ -1011,9 +1017,12 @@ calc_opt2p(struct adapter *sc, struct port_info *pi, int rxqid, /* RX_COALESCE is always a valid value (0 or M_RX_COALESCE). */ if (is_t4(sc)) opt2 |= F_RX_COALESCE_VALID; - else + else { opt2 |= F_T5_OPT_2_VALID; - opt2 |= V_RX_COALESCE(M_RX_COALESCE); + opt2 |= F_CONG_CNTRL_VALID; /* OPT_2_ISS really, for T5 */ + } + if (sc->tt.rx_coalesce) + opt2 |= V_RX_COALESCE(M_RX_COALESCE); #ifdef USE_DDP_RX_FLOW_CONTROL if (ulp_mode == ULP_MODE_TCPDDP) @@ -1287,7 +1296,8 @@ do_pass_accept_req(struct sge_iq *iq, const struct rss_header *rss, if (synqe == NULL) REJECT_PASS_ACCEPT(); - wr = alloc_wrqe(sizeof(*rpl), &sc->sge.ctrlq[pi->port_id]); + wr = alloc_wrqe(is_t4(sc) ? sizeof(struct cpl_pass_accept_rpl) : + sizeof(struct cpl_t5_pass_accept_rpl), &sc->sge.ctrlq[pi->port_id]); if (wr == NULL) REJECT_PASS_ACCEPT(); rpl = wrtod(wr); @@ -1328,7 +1338,13 @@ do_pass_accept_req(struct sge_iq *iq, const struct rss_header *rss, save_qids_in_mbuf(m, pi); get_qids_from_mbuf(m, NULL, &rxqid); - INIT_TP_WR_MIT_CPL(rpl, CPL_PASS_ACCEPT_RPL, tid); + if (is_t4(sc)) + INIT_TP_WR_MIT_CPL(rpl, CPL_PASS_ACCEPT_RPL, tid); + else { + struct cpl_t5_pass_accept_rpl *rpl5 = (void *)rpl; + + INIT_TP_WR_MIT_CPL(rpl5, CPL_PASS_ACCEPT_RPL, tid); + } if (sc->tt.ddp && (so->so_options & SO_NO_DDP) == 0) { ulp_mode = ULP_MODE_TCPDDP; synqe->flags |= TPF_SYNQE_TCPDDP; diff --git a/sys/dev/cxgbe/tom/t4_tom.c b/sys/dev/cxgbe/tom/t4_tom.c index a254253..671174d 100644 --- a/sys/dev/cxgbe/tom/t4_tom.c +++ b/sys/dev/cxgbe/tom/t4_tom.c @@ -58,6 +58,8 @@ __FBSDID("$FreeBSD$"); #include "common/common.h" #include "common/t4_msg.h" #include "common/t4_regs.h" +#include "common/t4_regs_values.h" +#include "common/t4_tcb.h" #include "tom/t4_tom_l2t.h" #include "tom/t4_tom.h" @@ -330,6 +332,30 @@ t4_pcb_detach(struct toedev *tod __unused, struct tcpcb *tp) } /* + * setsockopt handler. + */ +static void +t4_ctloutput(struct toedev *tod, struct tcpcb *tp, int dir, int name) +{ + struct adapter *sc = tod->tod_softc; + struct toepcb *toep = tp->t_toe; + + if (dir == SOPT_GET) + return; + + CTR4(KTR_CXGBE, "%s: tp %p, dir %u, name %u", __func__, tp, dir, name); + + switch (name) { + case TCP_NODELAY: + t4_set_tcb_field(sc, toep, 1, W_TCB_T_FLAGS, V_TF_NAGLE(1), + V_TF_NAGLE(tp->t_flags & TF_NODELAY ? 0 : 1)); + break; + default: + break; + } +} + +/* * The TOE driver will not receive any more CPLs for the tid associated with the * toepcb; release the hold on the inpcb. */ @@ -513,38 +539,38 @@ calc_opt0(struct socket *so, struct port_info *pi, struct l2t_entry *e, return htobe64(opt0); } -#define FILTER_SEL_WIDTH_P_FC (3 + 1) -#define FILTER_SEL_WIDTH_VIN_P_FC (6 + 7 + FILTER_SEL_WIDTH_P_FC) -#define FILTER_SEL_WIDTH_TAG_P_FC (3 + FILTER_SEL_WIDTH_VIN_P_FC) -#define FILTER_SEL_WIDTH_VLD_TAG_P_FC (1 + FILTER_SEL_WIDTH_TAG_P_FC) -#define VLAN_NONE 0xfff -#define FILTER_SEL_VLAN_NONE 0xffff - uint64_t -select_ntuple(struct port_info *pi, struct l2t_entry *e, uint32_t filter_mode) +select_ntuple(struct port_info *pi, struct l2t_entry *e) { + struct adapter *sc = pi->adapter; + struct tp_params *tp = &sc->params.tp; uint16_t viid = pi->viid; - uint32_t ntuple = 0; - - if (filter_mode == HW_TPL_FR_MT_PR_IV_P_FC) { - if (e->vlan == VLAN_NONE) - ntuple |= FILTER_SEL_VLAN_NONE << FILTER_SEL_WIDTH_P_FC; - else { - ntuple |= e->vlan << FILTER_SEL_WIDTH_P_FC; - ntuple |= 1 << FILTER_SEL_WIDTH_VLD_TAG_P_FC; - } - ntuple |= e->lport << S_PORT; - ntuple |= IPPROTO_TCP << FILTER_SEL_WIDTH_VLD_TAG_P_FC; - } else if (filter_mode == HW_TPL_FR_MT_PR_OV_P_FC) { - ntuple |= G_FW_VIID_VIN(viid) << FILTER_SEL_WIDTH_P_FC; - ntuple |= G_FW_VIID_PFN(viid) << FILTER_SEL_WIDTH_VIN_P_FC; - ntuple |= G_FW_VIID_VIVLD(viid) << FILTER_SEL_WIDTH_TAG_P_FC; - ntuple |= e->lport << S_PORT; - ntuple |= IPPROTO_TCP << FILTER_SEL_WIDTH_VLD_TAG_P_FC; - } - - if (is_t4(pi->adapter)) - return (htobe32(ntuple)); + uint64_t ntuple = 0; + + /* + * Initialize each of the fields which we care about which are present + * in the Compressed Filter Tuple. + */ + if (tp->vlan_shift >= 0 && e->vlan != CPL_L2T_VLAN_NONE) + ntuple |= (uint64_t)(F_FT_VLAN_VLD | e->vlan) << tp->vlan_shift; + + if (tp->port_shift >= 0) + ntuple |= (uint64_t)e->lport << tp->port_shift; + + if (tp->protocol_shift >= 0) + ntuple |= (uint64_t)IPPROTO_TCP << tp->protocol_shift; + + if (tp->vnic_shift >= 0) { + uint32_t vf = G_FW_VIID_VIN(viid); + uint32_t pf = G_FW_VIID_PFN(viid); + uint32_t vld = G_FW_VIID_VIVLD(viid); + + ntuple |= (uint64_t)(V_FT_VNID_ID_VF(vf) | V_FT_VNID_ID_PF(pf) | + V_FT_VNID_ID_VLD(vld)) << tp->vnic_shift; + } + + if (is_t4(sc)) + return (htobe32((uint32_t)ntuple)); else return (htobe64(V_FILTER_TUPLE(ntuple))); } @@ -945,6 +971,7 @@ t4_tom_activate(struct adapter *sc) tod->tod_syncache_removed = t4_syncache_removed; tod->tod_syncache_respond = t4_syncache_respond; tod->tod_offload_socket = t4_offload_socket; + tod->tod_ctloutput = t4_ctloutput; for_each_port(sc, i) TOEDEV(sc->port[i]->ifp) = &td->tod; diff --git a/sys/dev/cxgbe/tom/t4_tom.h b/sys/dev/cxgbe/tom/t4_tom.h index 4411a06..b86a76c 100644 --- a/sys/dev/cxgbe/tom/t4_tom.h +++ b/sys/dev/cxgbe/tom/t4_tom.h @@ -234,7 +234,7 @@ u_long select_rcv_wnd(struct socket *); int select_rcv_wscale(void); uint64_t calc_opt0(struct socket *, struct port_info *, struct l2t_entry *, int, int, int, int); -uint64_t select_ntuple(struct port_info *, struct l2t_entry *, uint32_t); +uint64_t select_ntuple(struct port_info *, struct l2t_entry *); void set_tcpddp_ulp_mode(struct toepcb *); int negative_advice(int); struct clip_entry *hold_lip(struct tom_data *, struct in6_addr *); diff --git a/sys/dev/iwn/if_iwn.c b/sys/dev/iwn/if_iwn.c index b6b523a..6e0cc1b 100644 --- a/sys/dev/iwn/if_iwn.c +++ b/sys/dev/iwn/if_iwn.c @@ -94,7 +94,7 @@ static const struct iwn_ident iwn_ident_table[] = { { 0x8086, 0x0885, "Intel Centrino Wireless-N + WiMAX 6150" }, { 0x8086, 0x0886, "Intel Centrino Wireless-N + WiMAX 6150" }, { 0x8086, 0x0896, "Intel Centrino Wireless-N 130" }, - { 0x8086, 0x0887, "Intel Centrino Wireless-N 130" }, + { 0x8086, 0x0897, "Intel Centrino Wireless-N 130" }, { 0x8086, 0x08ae, "Intel Centrino Wireless-N 100" }, { 0x8086, 0x08af, "Intel Centrino Wireless-N 100" }, { 0x8086, 0x4229, "Intel Wireless WiFi Link 4965" }, @@ -335,6 +335,8 @@ enum { IWN_DEBUG_NODE = 0x00000400, /* node management */ IWN_DEBUG_LED = 0x00000800, /* led management */ IWN_DEBUG_CMD = 0x00001000, /* cmd submission */ + IWN_DEBUG_TXRATE = 0x00002000, /* TX rate debugging */ + IWN_DEBUG_PWRSAVE = 0x00004000, /* Power save operations */ IWN_DEBUG_FATAL = 0x80000000, /* fatal errors */ IWN_DEBUG_ANY = 0xffffffff }; @@ -585,6 +587,7 @@ iwn_attach(device_t dev) | IEEE80211_C_IBSS /* ibss/adhoc mode */ #endif | IEEE80211_C_WME /* WME */ + | IEEE80211_C_PMGT /* Station-side power mgmt */ ; /* Read MAC address, channels, etc from EEPROM. */ @@ -2097,56 +2100,106 @@ rate2plcp(int rate) return 0; } -static void -iwn_newassoc(struct ieee80211_node *ni, int isnew) +/* + * Calculate the required PLCP value from the given rate, + * to the given node. + * + * This will take the node configuration (eg 11n, rate table + * setup, etc) into consideration. + */ +static uint32_t +iwn_rate_to_plcp(struct iwn_softc *sc, struct ieee80211_node *ni, + uint8_t rate) { #define RV(v) ((v) & IEEE80211_RATE_VAL) struct ieee80211com *ic = ni->ni_ic; - struct iwn_softc *sc = ic->ic_ifp->if_softc; - struct iwn_node *wn = (void *)ni; uint8_t txant1, txant2; - int i, plcp, rate, ridx; + uint32_t plcp = 0; + int ridx; /* Use the first valid TX antenna. */ txant1 = IWN_LSB(sc->txchainmask); txant2 = IWN_LSB(sc->txchainmask & ~txant1); + /* + * If it's an MCS rate, let's set the plcp correctly + * and set the relevant flags based on the node config. + */ if (IEEE80211_IS_CHAN_HT(ni->ni_chan)) { - ridx = ni->ni_rates.rs_nrates - 1; - for (i = ni->ni_htrates.rs_nrates - 1; i >= 0; i--) { - plcp = RV(ni->ni_htrates.rs_rates[i]) | IWN_RFLAG_MCS; - if (IEEE80211_IS_CHAN_HT40(ni->ni_chan)) { - plcp |= IWN_RFLAG_HT40; - if (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40) - plcp |= IWN_RFLAG_SGI; - } else if (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20) + /* + * Set the initial PLCP value to be between 0->31 for + * MCS 0 -> MCS 31, then set the "I'm an MCS rate!" + * flag. + */ + plcp = RV(rate) | IWN_RFLAG_MCS; + + /* + * XXX the following should only occur if both + * the local configuration _and_ the remote node + * advertise these capabilities. Thus this code + * may need fixing! + */ + + /* + * Set the channel width and guard interval. + */ + if (IEEE80211_IS_CHAN_HT40(ni->ni_chan)) { + plcp |= IWN_RFLAG_HT40; + if (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40) plcp |= IWN_RFLAG_SGI; - if (RV(ni->ni_htrates.rs_rates[i]) > 7) - plcp |= IWN_RFLAG_ANT(txant1 | txant2); - else - plcp |= IWN_RFLAG_ANT(txant1); - if (ridx >= 0) { - rate = RV(ni->ni_rates.rs_rates[ridx]); - wn->ridx[rate] = plcp; - } - wn->ridx[IEEE80211_RATE_MCS | i] = plcp; - ridx--; + } else if (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20) { + plcp |= IWN_RFLAG_SGI; } - } else { - for (i = 0; i < ni->ni_rates.rs_nrates; i++) { - rate = RV(ni->ni_rates.rs_rates[i]); - plcp = rate2plcp(rate); - ridx = ic->ic_rt->rateCodeToIndex[rate]; - if (ridx < IWN_RIDX_OFDM6 && - IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) - plcp |= IWN_RFLAG_CCK; + + /* + * If it's a two stream rate, enable TX on both + * antennas. + * + * XXX three stream rates? + */ + if (rate > 0x87) + plcp |= IWN_RFLAG_ANT(txant1 | txant2); + else plcp |= IWN_RFLAG_ANT(txant1); - wn->ridx[rate] = htole32(plcp); - } + } else { + /* + * Set the initial PLCP - fine for both + * OFDM and CCK rates. + */ + plcp = rate2plcp(rate); + + /* Set CCK flag if it's CCK */ + + /* XXX It would be nice to have a method + * to map the ridx -> phy table entry + * so we could just query that, rather than + * this hack to check against IWN_RIDX_OFDM6. + */ + ridx = ieee80211_legacy_rate_lookup(ic->ic_rt, + rate & IEEE80211_RATE_VAL); + if (ridx < IWN_RIDX_OFDM6 && + IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) + plcp |= IWN_RFLAG_CCK; + + /* Set antenna configuration */ + plcp |= IWN_RFLAG_ANT(txant1); } + + DPRINTF(sc, IWN_DEBUG_TXRATE, "%s: rate=0x%02x, plcp=0x%08x\n", + __func__, + rate, + plcp); + + return (htole32(plcp)); #undef RV } +static void +iwn_newassoc(struct ieee80211_node *ni, int isnew) +{ + /* Doesn't do anything at the moment */ +} + static int iwn_media_change(struct ifnet *ifp) { @@ -3400,7 +3453,8 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) (void) ieee80211_ratectl_rate(ni, NULL, 0); rate = ni->ni_txrate; } - ridx = ic->ic_rt->rateCodeToIndex[rate]; + ridx = ieee80211_legacy_rate_lookup(ic->ic_rt, + rate & IEEE80211_RATE_VAL); /* Encrypt the frame if need be. */ if (wh->i_fc[1] & IEEE80211_FC1_WEP) { @@ -3506,7 +3560,7 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) tx->rts_ntries = 60; tx->data_ntries = 15; tx->lifetime = htole32(IWN_LIFETIME_INFINITE); - tx->rate = wn->ridx[rate]; + tx->rate = iwn_rate_to_plcp(sc, ni, rate); if (tx->id == sc->broadcast_id) { /* Group or management frame. */ tx->linkq = 0; @@ -3637,7 +3691,8 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m, /* Choose a TX rate index. */ rate = params->ibp_rate0; - ridx = ic->ic_rt->rateCodeToIndex[rate]; + ridx = ieee80211_legacy_rate_lookup(ic->ic_rt, + rate & IEEE80211_RATE_VAL); if (ridx == (uint8_t)-1) { /* XXX fall back to mcast/mgmt rate? */ m_freem(m); @@ -3713,14 +3768,18 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m, tx->rts_ntries = params->ibp_try1; tx->data_ntries = params->ibp_try0; tx->lifetime = htole32(IWN_LIFETIME_INFINITE); + + /* XXX should just use iwn_rate_to_plcp() */ tx->rate = htole32(rate2plcp(rate)); if (ridx < IWN_RIDX_OFDM6 && IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) tx->rate |= htole32(IWN_RFLAG_CCK); + /* Group or management frame. */ tx->linkq = 0; txant = IWN_LSB(sc->txchainmask); tx->rate |= htole32(IWN_RFLAG_ANT(txant)); + /* Set physical address of "scratch area". */ tx->loaddr = htole32(IWN_LOADDR(data->scratch_paddr)); tx->hiaddr = IWN_HIADDR(data->scratch_paddr); @@ -4076,14 +4135,20 @@ iwn_set_link_quality(struct iwn_softc *sc, struct ieee80211_node *ni) else txrate = rs->rs_nrates - 1; for (i = 0; i < IWN_MAX_TX_RETRIES; i++) { + uint32_t plcp; + if (IEEE80211_IS_CHAN_HT(ni->ni_chan)) rate = IEEE80211_RATE_MCS | txrate; else rate = RV(rs->rs_rates[txrate]); - linkq.retry[i] = wn->ridx[rate]; - if ((le32toh(wn->ridx[rate]) & IWN_RFLAG_MCS) && - RV(le32toh(wn->ridx[rate])) > 7) + /* Do rate -> PLCP config mapping */ + plcp = iwn_rate_to_plcp(sc, ni, rate); + linkq.retry[i] = plcp; + + /* Special case for dual-stream rates? */ + if ((le32toh(plcp) & IWN_RFLAG_MCS) && + RV(le32toh(plcp)) > 7) linkq.mimo = i + 1; /* Next retry at immediate lower bit-rate. */ @@ -4585,6 +4650,8 @@ iwn_collect_noise(struct iwn_softc *sc, { struct iwn_ops *ops = &sc->ops; struct iwn_calib_state *calib = &sc->calib; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; uint32_t val; int i; @@ -4623,12 +4690,9 @@ iwn_collect_noise(struct iwn_softc *sc, (void)iwn_cmd(sc, IWN_CMD_RXON, &sc->rxon, sc->rxonsz, 1); #endif -#if 0 - /* XXX: not yet */ /* Enable power-saving mode if requested by user. */ - if (sc->sc_ic.ic_flags & IEEE80211_F_PMGTON) + if (ic->ic_flags & IEEE80211_F_PMGTON) (void)iwn_set_pslevel(sc, 0, 3, 1); -#endif } static int @@ -4940,6 +5004,13 @@ iwn_set_pslevel(struct iwn_softc *sc, int dtim, int level, int async) uint32_t reg; int i; + DPRINTF(sc, IWN_DEBUG_PWRSAVE, + "%s: dtim=%d, level=%d, async=%d\n", + __func__, + dtim, + level, + async); + /* Select which PS parameters to use. */ if (dtim <= 2) pmgt = &iwn_pmgt[0][level]; diff --git a/sys/dev/iwn/if_iwnvar.h b/sys/dev/iwn/if_iwnvar.h index 7326260..0bcc19b 100644 --- a/sys/dev/iwn/if_iwnvar.h +++ b/sys/dev/iwn/if_iwnvar.h @@ -102,7 +102,6 @@ struct iwn_node { struct ieee80211_node ni; /* must be the first */ uint16_t disable_tid; uint8_t id; - uint32_t ridx[256]; struct { uint64_t bitmap; int startidx; diff --git a/sys/dev/mfi/mfi.c b/sys/dev/mfi/mfi.c index cf2d505..b20ddc5 100644 --- a/sys/dev/mfi/mfi.c +++ b/sys/dev/mfi/mfi.c @@ -3773,12 +3773,15 @@ mfi_timeout(void *data) MFI_PRINT_CMD(cm); MFI_VALIDATE_CMD(sc, cm); /* - * Fail the command instead of leaving it on - * the queue where it could remain stuck forever + * While commands can get stuck forever we do + * not fail them as there is no way to tell if + * the controller has actually processed them + * or not. + * + * In addition its very likely that force + * failing a command here would cause a panic + * e.g. in UFS. */ - mfi_remove_busy(cm); - cm->cm_error = ETIMEDOUT; - mfi_complete(sc, cm); timedout++; } } diff --git a/sys/dev/pci/pci.c b/sys/dev/pci/pci.c index bea162b..091d02c 100644 --- a/sys/dev/pci/pci.c +++ b/sys/dev/pci/pci.c @@ -152,6 +152,7 @@ static device_method_t pci_methods[] = { DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource), DEVMETHOD(bus_activate_resource, pci_activate_resource), DEVMETHOD(bus_deactivate_resource, pci_deactivate_resource), + DEVMETHOD(bus_child_detached, pci_child_detached), DEVMETHOD(bus_child_pnpinfo_str, pci_child_pnpinfo_str_method), DEVMETHOD(bus_child_location_str, pci_child_location_str_method), DEVMETHOD(bus_remap_intr, pci_remap_intr_method), @@ -3489,7 +3490,7 @@ pci_driver_added(device_t dev, driver_t *driver) pci_printf(&dinfo->cfg, "reprobing on driver added\n"); pci_cfg_restore(child, dinfo); if (device_probe_and_attach(child) != 0) - pci_cfg_save(child, dinfo, 1); + pci_child_detached(dev, child); } free(devlist, M_TEMP); } @@ -3804,6 +3805,34 @@ pci_probe_nomatch(device_t dev, device_t child) pci_cfg_save(child, device_get_ivars(child), 1); } +void +pci_child_detached(device_t dev, device_t child) +{ + struct pci_devinfo *dinfo; + struct resource_list *rl; + + dinfo = device_get_ivars(child); + rl = &dinfo->resources; + + /* + * Have to deallocate IRQs before releasing any MSI messages and + * have to release MSI messages before deallocating any memory + * BARs. + */ + if (resource_list_release_active(rl, dev, child, SYS_RES_IRQ) != 0) + pci_printf(&dinfo->cfg, "Device leaked IRQ resources\n"); + if (dinfo->cfg.msi.msi_alloc != 0 || dinfo->cfg.msix.msix_alloc != 0) { + pci_printf(&dinfo->cfg, "Device leaked MSI vectors\n"); + (void)pci_release_msi(child); + } + if (resource_list_release_active(rl, dev, child, SYS_RES_MEMORY) != 0) + pci_printf(&dinfo->cfg, "Device leaked memory resources\n"); + if (resource_list_release_active(rl, dev, child, SYS_RES_IOPORT) != 0) + pci_printf(&dinfo->cfg, "Device leaked I/O resources\n"); + + pci_cfg_save(child, dinfo, 1); +} + /* * Parse the PCI device database, if loaded, and return a pointer to a * description of the device. diff --git a/sys/dev/pci/pci_private.h b/sys/dev/pci/pci_private.h index b4c0c9e..9eb0df0 100644 --- a/sys/dev/pci/pci_private.h +++ b/sys/dev/pci/pci_private.h @@ -106,6 +106,7 @@ struct pci_devinfo *pci_read_device(device_t pcib, int d, int b, int s, int f, size_t size); void pci_print_verbose(struct pci_devinfo *dinfo); int pci_freecfg(struct pci_devinfo *dinfo); +void pci_child_detached(device_t dev, device_t child); int pci_child_location_str_method(device_t cbdev, device_t child, char *buf, size_t buflen); int pci_child_pnpinfo_str_method(device_t cbdev, device_t child, diff --git a/sys/dev/qlxgbe/ql_os.c b/sys/dev/qlxgbe/ql_os.c index 757d612..c6fcae3 100644 --- a/sys/dev/qlxgbe/ql_os.c +++ b/sys/dev/qlxgbe/ql_os.c @@ -1646,11 +1646,13 @@ qla_error_recovery(void *context, int pending) if ((ha->pci_func & 0x1) == 0) { - if (!ha->msg_from_peer) + if (!ha->msg_from_peer) { qla_send_msg_to_peer(ha, QL_PEER_MSG_RESET); - while ((ha->msg_from_peer != QL_PEER_MSG_ACK) && msecs_100--) - qla_mdelay(__func__, 100); + while ((ha->msg_from_peer != QL_PEER_MSG_ACK) && + msecs_100--) + qla_mdelay(__func__, 100); + } ha->msg_from_peer = 0; diff --git a/sys/dev/ral/rt2560.c b/sys/dev/ral/rt2560.c index c67f1f7..7c1b9de 100644 --- a/sys/dev/ral/rt2560.c +++ b/sys/dev/ral/rt2560.c @@ -2370,7 +2370,7 @@ rt2560_set_basicrates(struct rt2560_softc *sc, if (!(rate & IEEE80211_RATE_BASIC)) continue; - mask |= 1 << ic->ic_rt->rateCodeToIndex[RV(rate)]; + mask |= 1 << ieee80211_legacy_rate_lookup(ic->ic_rt, RV(rate)); } RAL_WRITE(sc, RT2560_ARSP_PLCP_1, mask); diff --git a/sys/dev/ral/rt2661.c b/sys/dev/ral/rt2661.c index 8ae2515..70c30f1 100644 --- a/sys/dev/ral/rt2661.c +++ b/sys/dev/ral/rt2661.c @@ -1923,7 +1923,7 @@ rt2661_set_basicrates(struct rt2661_softc *sc, if (!(rate & IEEE80211_RATE_BASIC)) continue; - mask |= 1 << ic->ic_rt->rateCodeToIndex[RV(rate)]; + mask |= 1 << ieee80211_legacy_rate_lookup(ic->ic_rt, RV(rate)); } RAL_WRITE(sc, RT2661_TXRX_CSR5, mask); diff --git a/sys/dev/ral/rt2860.c b/sys/dev/ral/rt2860.c index 4207d75..3bdd01d 100644 --- a/sys/dev/ral/rt2860.c +++ b/sys/dev/ral/rt2860.c @@ -1528,7 +1528,7 @@ rt2860_tx(struct rt2860_softc *sc, struct mbuf *m, struct ieee80211_node *ni) tid = 0; } ring = &sc->txq[qid]; - ridx = ic->ic_rt->rateCodeToIndex[rate]; + ridx = ieee80211_legacy_rate_lookup(ic->ic_rt, rate); /* get MCS code from rate index */ mcs = rt2860_rates[ridx].mcs; @@ -1779,7 +1779,8 @@ rt2860_tx_raw(struct rt2860_softc *sc, struct mbuf *m, /* Choose a TX rate index. */ rate = params->ibp_rate0; - ridx = ic->ic_rt->rateCodeToIndex[rate]; + ridx = ieee80211_legacy_rate_lookup(ic->ic_rt, + rate & IEEE80211_RATE_VAL); if (ridx == (uint8_t)-1) { /* XXX fall back to mcast/mgmt rate? */ m_freem(m); @@ -2311,7 +2312,7 @@ rt2860_set_basicrates(struct rt2860_softc *sc, if (!(rate & IEEE80211_RATE_BASIC)) continue; - mask |= 1 << ic->ic_rt->rateCodeToIndex[RV(rate)]; + mask |= 1 << ieee80211_legacy_rate_lookup(ic->ic_rt, RV(rate)); } RAL_WRITE(sc, RT2860_LEGACY_BASIC_RATE, mask); diff --git a/sys/dev/re/if_re.c b/sys/dev/re/if_re.c index 44b4d28..1e906a7 100644 --- a/sys/dev/re/if_re.c +++ b/sys/dev/re/if_re.c @@ -1321,7 +1321,7 @@ re_attach(device_t dev) SYS_RES_IRQ, &rid, RF_ACTIVE); if (sc->rl_irq[i] == NULL) { device_printf(dev, - "couldn't llocate IRQ resources for " + "couldn't allocate IRQ resources for " "message %d\n", rid); error = ENXIO; goto fail; @@ -1632,7 +1632,7 @@ re_attach(device_t dev) /* * Don't enable TSO by default. It is known to generate * corrupted TCP segments(bad TCP options) under certain - * circumtances. + * circumstances. */ ifp->if_hwassist &= ~CSUM_TSO; ifp->if_capenable &= ~(IFCAP_TSO4 | IFCAP_VLAN_HWTSO); @@ -2784,7 +2784,7 @@ re_encap(struct rl_softc *sc, struct mbuf **m_head) /* * Unconditionally enable IP checksum if TCP or UDP * checksum is required. Otherwise, TCP/UDP checksum - * does't make effects. + * doesn't make effects. */ if (((*m_head)->m_pkthdr.csum_flags & RE_CSUM_FEATURES) != 0) { if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) { @@ -3247,7 +3247,7 @@ re_init_locked(struct rl_softc *sc) if ((sc->rl_flags & RL_FLAG_JUMBOV2) != 0) { /* * For controllers that use new jumbo frame scheme, - * set maximum size of jumbo frame depedning on + * set maximum size of jumbo frame depending on * controller revisions. */ if (ifp->if_mtu > RL_MTU) @@ -3948,7 +3948,7 @@ re_sysctl_stats(SYSCTL_HANDLER_ARGS) RL_UNLOCK(sc); if (i == 0) { device_printf(sc->rl_dev, - "DUMP statistics request timedout\n"); + "DUMP statistics request timed out\n"); return (ETIMEDOUT); } done: diff --git a/sys/dev/uart/uart.h b/sys/dev/uart/uart.h index 772793f..fb0f699 100644 --- a/sys/dev/uart/uart.h +++ b/sys/dev/uart/uart.h @@ -67,6 +67,7 @@ struct uart_class; extern struct uart_class uart_imx_class __attribute__((weak)); extern struct uart_class uart_ns8250_class __attribute__((weak)); extern struct uart_class uart_quicc_class __attribute__((weak)); +extern struct uart_class uart_s3c2410_class __attribute__((weak)); extern struct uart_class uart_sab82532_class __attribute__((weak)); extern struct uart_class uart_sbbc_class __attribute__((weak)); extern struct uart_class uart_z8530_class __attribute__((weak)); diff --git a/sys/dev/uart/uart_bus_fdt.c b/sys/dev/uart/uart_bus_fdt.c index d7b6017..4f6ac9b 100644 --- a/sys/dev/uart/uart_bus_fdt.c +++ b/sys/dev/uart/uart_bus_fdt.c @@ -109,6 +109,8 @@ uart_fdt_probe(device_t dev) sc->sc_class = &uart_imx_class; else if (ofw_bus_is_compatible(dev, "arm,pl011")) sc->sc_class = &uart_pl011_class; + else if (ofw_bus_is_compatible(dev, "exynos")) + sc->sc_class = &uart_s3c2410_class; else if (ofw_bus_is_compatible(dev, "cadence,uart")) sc->sc_class = &uart_cdnc_class; else diff --git a/sys/dev/uart/uart_cpu_fdt.c b/sys/dev/uart/uart_cpu_fdt.c index 52d5f00..0052388 100644 --- a/sys/dev/uart/uart_cpu_fdt.c +++ b/sys/dev/uart/uart_cpu_fdt.c @@ -149,6 +149,8 @@ uart_cpu_getdev(int devtype, struct uart_devinfo *di) class = &uart_ns8250_class; if (fdt_is_compatible(node, "arm,pl011")) class = &uart_pl011_class; + if (fdt_is_compatible(node, "exynos")) + class = &uart_s3c2410_class; if (fdt_is_compatible(node, "cadence,uart")) class = &uart_cdnc_class; diff --git a/sys/dev/uart/uart_subr.c b/sys/dev/uart/uart_subr.c index acbf3b4..0277b21 100644 --- a/sys/dev/uart/uart_subr.c +++ b/sys/dev/uart/uart_subr.c @@ -54,6 +54,7 @@ static struct uart_class *uart_classes[] = { &uart_z8530_class, #if defined(__arm__) &uart_lpc_class, + &uart_s3c2410_class, #endif }; static size_t uart_nclasses = sizeof(uart_classes) / sizeof(uart_classes[0]); diff --git a/sys/dev/usb/quirk/usb_quirk.c b/sys/dev/usb/quirk/usb_quirk.c index 98e7c42..e46f269 100644 --- a/sys/dev/usb/quirk/usb_quirk.c +++ b/sys/dev/usb/quirk/usb_quirk.c @@ -94,6 +94,7 @@ static struct usb_quirk_entry usb_quirks[USB_DEV_QUIRKS_MAX] = { USB_QUIRK(SILICONPORTALS, YAPPHONE, 0x100, 0x100, UQ_AU_INP_ASYNC), USB_QUIRK(LOGITECH, UN53B, 0x0000, 0xffff, UQ_NO_STRINGS), USB_QUIRK(ELSA, MODEM1, 0x0000, 0xffff, UQ_CFG_INDEX_1), + USB_QUIRK(PLANEX2, MZKUE150N, 0x0000, 0xffff, UQ_CFG_INDEX_1), /* Quirks for printer devices */ USB_QUIRK(HP, 895C, 0x0000, 0xffff, UQ_BROKEN_BIDIR), USB_QUIRK(HP, 880C, 0x0000, 0xffff, UQ_BROKEN_BIDIR), diff --git a/sys/dev/usb/usbdevs b/sys/dev/usb/usbdevs index 21a8901..8dee4f0 100644 --- a/sys/dev/usb/usbdevs +++ b/sys/dev/usb/usbdevs @@ -849,6 +849,7 @@ product ACCTON RT3070_2 0xa702 RT3070 product ACCTON RT2870_1 0xb522 RT2870 product ACCTON RT3070_3 0xc522 RT3070 product ACCTON RT3070_5 0xd522 RT3070 +product ACCTON RTL8192SU 0xc512 RTL8192SU product ACCTON ZD1211B 0xe501 ZD1211B /* Aceeca products */ @@ -1134,7 +1135,9 @@ product ASUS RT2870_4 0x1760 RT2870 product ASUS RT2870_5 0x1761 RT2870 product ASUS USBN13 0x1784 USB-N13 product ASUS RT3070_1 0x1790 RT3070 +product ASUS USBN10 0x1786 USB-N10 product ASUS RTL8192CU 0x17ab RTL8192CU +product ASUS RTL8192SU 0x1791 RTL8192SU product ASUS A730W 0x4202 ASUS MyPal A730W product ASUS P535 0x420f ASUS P535 PDA product ASUS GMSC 0x422f ASUS Generic Mass Storage @@ -1185,7 +1188,11 @@ product AZUREWAVE RT3070_3 0x3305 RT3070 product AZUREWAVE RTL8188CU 0x3357 RTL8188CU product AZUREWAVE RTL8188CE_1 0x3358 RTL8188CE product AZUREWAVE RTL8188CE_2 0x3359 RTL8188CE - +product AZUREWAVE RTL8192SU_1 0x3306 RTL8192SU +product AZUREWAVE RTL8192SU_2 0x3309 RTL8192SU +product AZUREWAVE RTL8192SU_3 0x3310 RTL8192SU +product AZUREWAVE RTL8192SU_4 0x3311 RTL8192SU +product AZUREWAVE RTL8192SU_5 0x3325 RTL8192SU /* Baltech products */ product BALTECH CARDREADER 0x9999 Card reader @@ -1242,6 +1249,9 @@ product BELKIN F5D7050E 0x705e F5D7050E Wireless Adapter product BELKIN RT2870_1 0x8053 RT2870 product BELKIN RT2870_2 0x805c RT2870 product BELKIN F5D8053V3 0x815c F5D8053 v3 +product BELKIN RTL8192SU_1 0x815f RTL8192SU +product BELKIN RTL8192SU_2 0x845a RTL8192SU +product BELKIN RTL8192SU_3 0x945a RTL8192SU product BELKIN F5D8055 0x825a F5D8055 product BELKIN F5D8055V2 0x825b F5D8055 v2 product BELKIN F5D9050V3 0x905b F5D9050 ver 3 Wireless Adapter @@ -1368,6 +1378,9 @@ product CONCEPTRONIC AR5523_1 0x7801 AR5523 product CONCEPTRONIC AR5523_1_NF 0x7802 AR5523 (no firmware) product CONCEPTRONIC AR5523_2 0x7811 AR5523 product CONCEPTRONIC AR5523_2_NF 0x7812 AR5523 (no firmware) +product CONCEPTRONIC2 RTL8192SU_1 0x3300 RTL8192SU +product CONCEPTRONIC2 RTL8192SU_2 0x3301 RTL8192SU +product CONCEPTRONIC2 RTL8192SU_3 0x3302 RTL8192SU product CONCEPTRONIC2 C54RU 0x3c02 C54RU WLAN product CONCEPTRONIC2 C54RU2 0x3c22 C54RU product CONCEPTRONIC2 RT3070_1 0x3c08 RT3070 @@ -1404,6 +1417,7 @@ product COREGA RT2870_2 0x003c RT2870 product COREGA RT2870_3 0x003f RT2870 product COREGA RT3070 0x0041 RT3070 product COREGA CGWLUSB300GNM 0x0042 CG-WLUSB300GNM +product COREGA RTL8192SU 0x0047 RTL8192SU product COREGA RTL8192CU 0x0056 RTL8192CU product COREGA WLUSB_11_STICK 0x7613 WLAN USB Stick 11 @@ -1546,6 +1560,9 @@ product DLINK RTL8192CU_1 0x3307 RTL8192CU product DLINK RTL8192CU_2 0x3309 RTL8192CU product DLINK RTL8192CU_3 0x330a RTL8192CU product DLINK DWA131B 0x330d DWA-131 rev B +product DLINK2 RTL8192SU_1 0x3300 RTL8192SU +product DLINK2 RTL8192SU_2 0x3302 RTL8192SU +product DLINK2 DWA131A1 0x3303 DWA-131 A1 product DLINK2 DWA120 0x3a0c DWA-120 product DLINK2 DWA120_NF 0x3a0d DWA-120 (no firmware) product DLINK2 DWLG122C1 0x3c03 DWL-G122 c1 @@ -1582,6 +1599,9 @@ product DYNASTREAM ANTDEVBOARD2 0x1006 ANT dev board /* Edimax products */ product EDIMAX EW7318USG 0x7318 USB Wireless dongle +product EDIMAX RTL8192SU_1 0x7611 RTL8192SU +product EDIMAX RTL8192SU_2 0x7612 RTL8192SU +product EDIMAX RTL8192SU_3 0x7622 RTL8192SU product EDIMAX RT2870_1 0x7711 RT2870 product EDIMAX EW7717 0x7717 EW-7717 product EDIMAX EW7718 0x7718 EW-7718 @@ -2075,6 +2095,8 @@ product GUILLEMOT HWGUSB254 0xe000 HWGUSB2-54 WLAN product GUILLEMOT HWGUSB254LB 0xe010 HWGUSB2-54-LB product GUILLEMOT HWGUSB254V2AP 0xe020 HWGUSB2-54V2-AP product GUILLEMOT HWNU300 0xe030 HWNU-300 +product GUILLEMOT HWNUM300 0xe031 HWNUm-300 +product GUILLEMOT HWGUN54 0xe032 HWGUn-54 product GUILLEMOT HWNUP150 0xe033 HWNUP-150 /* Hagiwara products */ @@ -2101,6 +2123,8 @@ product HAWKING HWUN2 0x0009 HWUN2 product HAWKING RT3070 0x000b RT3070 product HAWKING RTL8192CU 0x0019 RTL8192CU product HAWKING UF100 0x400c 10/100 USB Ethernet +product HAWKING RTL8192SU_1 0x0015 RTL8192SU +product HAWKING RTL8192SU_2 0x0016 RTL8192SU /* HID Global GmbH products */ product HIDGLOBAL CM2020 0x0596 Omnikey Cardman 2020 @@ -3327,6 +3351,7 @@ product PLANEX2 RTL8192CU 0xab2b RTL8192CU product PLANEX2 GWUS54HP 0xab01 GW-US54HP product PLANEX2 GWUS300MINIS 0xab24 GW-US300MiniS product PLANEX2 RT3070 0xab25 RT3070 +product PLANEX2 MZKUE150N 0xab2f MZK-UE150N product PLANEX2 GWUS54MINI2 0xab50 GW-US54Mini2 product PLANEX2 GWUS54SG 0xc002 GW-US54SG product PLANEX2 GWUS54GZL 0xc007 GW-US54GZL @@ -3338,6 +3363,7 @@ product PLANEX2 GWUSVALUEEZ 0xed17 GW-USValue-EZ product PLANEX3 GWUS54GZ 0xab10 GW-US54GZ product PLANEX3 GU1000T 0xab11 GU-1000T product PLANEX3 GWUS54MINI 0xab13 GW-US54Mini +product PLANEX2 GWUSNANO 0xab28 GW-USNano /* Plextor Corp. */ product PLEXTOR 40_12_40U 0x0011 PlexWriter 40/12/40U @@ -3555,6 +3581,10 @@ product REALTEK USB20CRW 0x0158 USB20CRW Card Reader product REALTEK RTL8188CTV 0x018a RTL8188CTV product REALTEK USBKR100 0x8150 USBKR100 USB Ethernet product REALTEK RTL8188CE_0 0x8170 RTL8188CE +product REALTEK RTL8171 0x8171 RTL8171 +product REALTEK RTL8172 0x8172 RTL8172 +product REALTEK RTL8173 0x8173 RTL8173 +product REALTEK RTL8174 0x8174 RTL8174 product REALTEK RTL8188CE_1 0x817e RTL8188CE product REALTEK RTL8188CU_0 0x8176 RTL8188CU product REALTEK RTL8188CU_1 0x817a RTL8188CU @@ -3569,7 +3599,10 @@ product REALTEK RTL8191CU 0x8177 RTL8191CU product REALTEK RTL8192CU 0x8178 RTL8192CU product REALTEK RTL8192CE 0x817c RTL8192CE product REALTEK RTL8188RU_1 0x817d RTL8188RU +product REALTEK RTL8712 0x8712 RTL8712 +product REALTEK RTL8713 0x8712 RTL8713 product REALTEK RTL8188RU_2 0x317f RTL8188RU +product REALTEK RTL8192SU 0xc512 RTL8192SU /* RedOctane products */ product REDOCTANE DUMMY 0x0000 Dummy product @@ -3720,6 +3753,8 @@ product SENAO RT3072_2 0x9707 RT3072 product SENAO RT3072_3 0x9708 RT3072 product SENAO RT3072_4 0x9709 RT3072 product SENAO RT3072_5 0x9801 RT3072 +product SENAO RTL8192SU_1 0x9603 RTL8192SU +product SENAO RTL8192SU_2 0x9605 RTL8192SU /* ShanTou products */ product SHANTOU ST268 0x0268 ST268 @@ -3940,9 +3975,11 @@ product SITECOMEU WL608 0x003f WL-608 product SITECOMEU RT3071 0x0040 RT3071 product SITECOMEU RT3072_1 0x0041 RT3072 product SITECOMEU RT3072_2 0x0042 RT3072 +product SITECOMEU WL353 0x0045 WL-353 product SITECOMEU RT3072_3 0x0047 RT3072 product SITECOMEU RT3072_4 0x0048 RT3072 product SITECOMEU RT3072_5 0x004a RT3072 +product SITECOMEU WL349V1 0x004b WL-349 v1 product SITECOMEU RT3072_6 0x004d RT3072 product SITECOMEU RTL8188CU_1 0x0052 RTL8188CU product SITECOMEU RTL8188CU_2 0x005c RTL8188CU @@ -4110,6 +4147,7 @@ product SURECOM RT2573 0x31f3 RT2573 /* Sweex products */ product SWEEX ZD1211 0x1809 ZD1211 product SWEEX2 LW153 0x0153 LW153 +product SWEEX2 LW154 0x0154 LW154 product SWEEX2 LW303 0x0302 LW303 product SWEEX2 LW313 0x0313 LW313 diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c index fa4e9f1..1d17ceb 100644 --- a/sys/dev/usb/wlan/if_rum.c +++ b/sys/dev/usb/wlan/if_rum.c @@ -502,6 +502,12 @@ rum_attach(device_t self) | IEEE80211_C_WPA /* 802.11i */ ; + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + bands = 0; setbit(&bands, IEEE80211_MODE_11B); setbit(&bands, IEEE80211_MODE_11G); diff --git a/sys/dev/usb/wlan/if_uath.c b/sys/dev/usb/wlan/if_uath.c index f238d0d..76bd02b 100644 --- a/sys/dev/usb/wlan/if_uath.c +++ b/sys/dev/usb/wlan/if_uath.c @@ -457,6 +457,12 @@ uath_attach(device_t dev) IEEE80211_C_BGSCAN | /* capable of bg scanning */ IEEE80211_C_TXFRAG; /* handle tx frags */ + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + /* put a regulatory domain to reveal informations. */ uath_regdomain = sc->sc_devcap.regDomain; diff --git a/sys/dev/usb/wlan/if_upgt.c b/sys/dev/usb/wlan/if_upgt.c index eff7922..fb4d619 100644 --- a/sys/dev/usb/wlan/if_upgt.c +++ b/sys/dev/usb/wlan/if_upgt.c @@ -353,6 +353,12 @@ upgt_attach(device_t dev) | IEEE80211_C_WPA /* 802.11i */ ; + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + bands = 0; setbit(&bands, IEEE80211_MODE_11B); setbit(&bands, IEEE80211_MODE_11G); diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c index f3fa1ca..0815452 100644 --- a/sys/dev/usb/wlan/if_ural.c +++ b/sys/dev/usb/wlan/if_ural.c @@ -487,6 +487,12 @@ ural_attach(device_t self) | IEEE80211_C_WPA /* 802.11i */ ; + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + bands = 0; setbit(&bands, IEEE80211_MODE_11B); setbit(&bands, IEEE80211_MODE_11G); diff --git a/sys/dev/usb/wlan/if_urtw.c b/sys/dev/usb/wlan/if_urtw.c index 184317b..10fd7db 100644 --- a/sys/dev/usb/wlan/if_urtw.c +++ b/sys/dev/usb/wlan/if_urtw.c @@ -893,6 +893,12 @@ urtw_attach(device_t dev) IEEE80211_C_BGSCAN | /* capable of bg scanning */ IEEE80211_C_WPA; /* 802.11i */ + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + bands = 0; setbit(&bands, IEEE80211_MODE_11B); setbit(&bands, IEEE80211_MODE_11G); diff --git a/sys/dev/usb/wlan/if_urtwn.c b/sys/dev/usb/wlan/if_urtwn.c index 180dbe2..48ac4cb 100644 --- a/sys/dev/usb/wlan/if_urtwn.c +++ b/sys/dev/usb/wlan/if_urtwn.c @@ -80,6 +80,7 @@ SYSCTL_INT(_hw_usb_urtwn, OID_AUTO, debug, CTLFLAG_RW, &urtwn_debug, 0, "Debug level"); #endif +#define URTWN_RSSI(r) (r) - 110 #define IEEE80211_HAS_ADDR4(wh) \ (((wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) @@ -418,6 +419,12 @@ urtwn_attach(device_t self) | IEEE80211_C_WPA /* 802.11i */ ; + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + bands = 0; setbit(&bands, IEEE80211_MODE_11B); setbit(&bands, IEEE80211_MODE_11G); @@ -610,6 +617,11 @@ urtwn_rx_frame(struct urtwn_softc *sc, uint8_t *buf, int pktlen, int *rssi_p) rssi = urtwn_get_rssi(sc, rate, &stat[1]); /* Update our average RSSI. */ urtwn_update_avgrssi(sc, rate, rssi); + /* + * Convert the RSSI to a range that will be accepted + * by net80211. + */ + rssi = URTWN_RSSI(rssi); } m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); @@ -1253,6 +1265,7 @@ urtwn_ra_init(struct urtwn_softc *sc) cmd.mask = htole32(mode << 28 | basicrates); error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd)); if (error != 0) { + ieee80211_free_node(ni); device_printf(sc->sc_dev, "could not add broadcast station\n"); return (error); @@ -1267,6 +1280,7 @@ urtwn_ra_init(struct urtwn_softc *sc) cmd.mask = htole32(mode << 28 | rates); error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd)); if (error != 0) { + ieee80211_free_node(ni); device_printf(sc->sc_dev, "could not add BSS station\n"); return (error); } @@ -1276,7 +1290,9 @@ urtwn_ra_init(struct urtwn_softc *sc) maxrate); /* Indicate highest supported rate. */ - ni->ni_txrate = rs->rs_nrates - 1; + ni->ni_txrate = rs->rs_rates[rs->rs_nrates - 1]; + ieee80211_free_node(ni); + return (0); } diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c index 3d3f269..d245d99 100644 --- a/sys/dev/usb/wlan/if_zyd.c +++ b/sys/dev/usb/wlan/if_zyd.c @@ -400,6 +400,12 @@ zyd_attach(device_t dev) | IEEE80211_C_WPA /* 802.11i */ ; + ic->ic_cryptocaps = + IEEE80211_CRYPTO_WEP | + IEEE80211_CRYPTO_AES_CCM | + IEEE80211_CRYPTO_TKIPMIC | + IEEE80211_CRYPTO_TKIP; + bands = 0; setbit(&bands, IEEE80211_MODE_11B); setbit(&bands, IEEE80211_MODE_11G); diff --git a/sys/dev/virtio/balloon/virtio_balloon.c b/sys/dev/virtio/balloon/virtio_balloon.c index 9b45459..9a87cf2 100644 --- a/sys/dev/virtio/balloon/virtio_balloon.c +++ b/sys/dev/virtio/balloon/virtio_balloon.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -70,7 +70,7 @@ struct vtballoon_softc { uint32_t vtballoon_current_npages; TAILQ_HEAD(,vm_page) vtballoon_pages; - struct proc *vtballoon_kproc; + struct thread *vtballoon_td; uint32_t *vtballoon_page_frames; int vtballoon_timeout; }; @@ -90,7 +90,7 @@ static int vtballoon_config_change(device_t); static void vtballoon_negotiate_features(struct vtballoon_softc *); static int vtballoon_alloc_virtqueues(struct vtballoon_softc *); -static int vtballoon_vq_intr(void *); +static void vtballoon_vq_intr(void *); static void vtballoon_inflate(struct vtballoon_softc *, int); static void vtballoon_deflate(struct vtballoon_softc *, int); @@ -127,9 +127,9 @@ CTASSERT(VTBALLOON_PAGES_PER_REQUEST * sizeof(uint32_t) <= PAGE_SIZE); #define VTBALLOON_MTX(_sc) &(_sc)->vtballoon_mtx #define VTBALLOON_LOCK_INIT(_sc, _name) mtx_init(VTBALLOON_MTX((_sc)), _name, \ - "VirtIO Balloon Lock", MTX_SPIN) -#define VTBALLOON_LOCK(_sc) mtx_lock_spin(VTBALLOON_MTX((_sc))) -#define VTBALLOON_UNLOCK(_sc) mtx_unlock_spin(VTBALLOON_MTX((_sc))) + "VirtIO Balloon Lock", MTX_DEF) +#define VTBALLOON_LOCK(_sc) mtx_lock(VTBALLOON_MTX((_sc))) +#define VTBALLOON_UNLOCK(_sc) mtx_unlock(VTBALLOON_MTX((_sc))) #define VTBALLOON_LOCK_DESTROY(_sc) mtx_destroy(VTBALLOON_MTX((_sc))) static device_method_t vtballoon_methods[] = { @@ -206,10 +206,10 @@ vtballoon_attach(device_t dev) goto fail; } - error = kproc_create(vtballoon_thread, sc, &sc->vtballoon_kproc, + error = kthread_add(vtballoon_thread, sc, NULL, &sc->vtballoon_td, 0, 0, "virtio_balloon"); if (error) { - device_printf(dev, "cannot create balloon kproc\n"); + device_printf(dev, "cannot create balloon kthread\n"); goto fail; } @@ -230,15 +230,14 @@ vtballoon_detach(device_t dev) sc = device_get_softc(dev); - if (sc->vtballoon_kproc != NULL) { + if (sc->vtballoon_td != NULL) { VTBALLOON_LOCK(sc); sc->vtballoon_flags |= VTBALLOON_FLAG_DETACH; wakeup_one(sc); - msleep_spin(sc->vtballoon_kproc, VTBALLOON_MTX(sc), - "vtbdth", 0); + msleep(sc->vtballoon_td, VTBALLOON_MTX(sc), 0, "vtbdth", 0); VTBALLOON_UNLOCK(sc); - sc->vtballoon_kproc = NULL; + sc->vtballoon_td = NULL; } if (device_is_attached(dev)) { @@ -300,7 +299,7 @@ vtballoon_alloc_virtqueues(struct vtballoon_softc *sc) return (virtio_alloc_virtqueues(dev, 0, nvqs, vq_info)); } -static int +static void vtballoon_vq_intr(void *xsc) { struct vtballoon_softc *sc; @@ -310,8 +309,6 @@ vtballoon_vq_intr(void *xsc) VTBALLOON_LOCK(sc); wakeup_one(sc); VTBALLOON_UNLOCK(sc); - - return (1); } static void @@ -322,28 +319,26 @@ vtballoon_inflate(struct vtballoon_softc *sc, int npages) int i; vq = sc->vtballoon_inflate_vq; - m = NULL; if (npages > VTBALLOON_PAGES_PER_REQUEST) npages = VTBALLOON_PAGES_PER_REQUEST; - KASSERT(npages > 0, ("balloon doesn't need inflating?")); for (i = 0; i < npages; i++) { - if ((m = vtballoon_alloc_page(sc)) == NULL) + if ((m = vtballoon_alloc_page(sc)) == NULL) { + sc->vtballoon_timeout = VTBALLOON_LOWMEM_TIMEOUT; break; + } sc->vtballoon_page_frames[i] = VM_PAGE_TO_PHYS(m) >> VIRTIO_BALLOON_PFN_SHIFT; - KASSERT(m->queue == PQ_NONE, ("allocated page on queue")); + KASSERT(m->queue == PQ_NONE, + ("%s: allocated page %p on queue", __func__, m)); TAILQ_INSERT_TAIL(&sc->vtballoon_pages, m, pageq); } if (i > 0) vtballoon_send_page_frames(sc, vq, i); - - if (m == NULL) - sc->vtballoon_timeout = VTBALLOON_LOWMEM_TIMEOUT; } static void @@ -359,11 +354,10 @@ vtballoon_deflate(struct vtballoon_softc *sc, int npages) if (npages > VTBALLOON_PAGES_PER_REQUEST) npages = VTBALLOON_PAGES_PER_REQUEST; - KASSERT(npages > 0, ("balloon doesn't need deflating?")); for (i = 0; i < npages; i++) { m = TAILQ_FIRST(&sc->vtballoon_pages); - KASSERT(m != NULL, ("no more pages to deflate")); + KASSERT(m != NULL, ("%s: no more pages to deflate", __func__)); sc->vtballoon_page_frames[i] = VM_PAGE_TO_PHYS(m) >> VIRTIO_BALLOON_PFN_SHIFT; @@ -385,7 +379,9 @@ vtballoon_deflate(struct vtballoon_softc *sc, int npages) KASSERT((TAILQ_EMPTY(&sc->vtballoon_pages) && sc->vtballoon_current_npages == 0) || (!TAILQ_EMPTY(&sc->vtballoon_pages) && - sc->vtballoon_current_npages != 0), ("balloon empty?")); + sc->vtballoon_current_npages != 0), + ("%s: bogus page count %d", __func__, + sc->vtballoon_current_npages)); } static void @@ -413,7 +409,7 @@ vtballoon_send_page_frames(struct vtballoon_softc *sc, struct virtqueue *vq, */ VTBALLOON_LOCK(sc); while ((c = virtqueue_dequeue(vq, NULL)) == NULL) - msleep_spin(sc, VTBALLOON_MTX(sc), "vtbspf", 0); + msleep(sc, VTBALLOON_MTX(sc), 0, "vtbspf", 0); VTBALLOON_UNLOCK(sc); KASSERT(c == vq, ("unexpected balloon operation response")); @@ -512,7 +508,7 @@ vtballoon_sleep(struct vtballoon_softc *sc) if (current < desired && timeout == 0) break; - msleep_spin(sc, VTBALLOON_MTX(sc), "vtbslp", timeout); + msleep(sc, VTBALLOON_MTX(sc), 0, "vtbslp", timeout); } VTBALLOON_UNLOCK(sc); @@ -544,7 +540,7 @@ vtballoon_thread(void *xsc) } } - kproc_exit(0); + kthread_exit(); } static void diff --git a/sys/dev/virtio/block/virtio_blk.c b/sys/dev/virtio/block/virtio_blk.c index 21d7703..5219a38 100644 --- a/sys/dev/virtio/block/virtio_blk.c +++ b/sys/dev/virtio/block/virtio_blk.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -36,10 +36,10 @@ __FBSDID("$FreeBSD$"); #include <sys/malloc.h> #include <sys/module.h> #include <sys/sglist.h> +#include <sys/sysctl.h> #include <sys/lock.h> #include <sys/mutex.h> #include <sys/queue.h> -#include <sys/taskqueue.h> #include <geom/geom_disk.h> @@ -62,6 +62,12 @@ struct vtblk_request { TAILQ_ENTRY(vtblk_request) vbr_link; }; +enum vtblk_cache_mode { + VTBLK_CACHE_WRITETHROUGH, + VTBLK_CACHE_WRITEBACK, + VTBLK_CACHE_MAX +}; + struct vtblk_softc { device_t vtblk_dev; struct mtx vtblk_mtx; @@ -73,6 +79,7 @@ struct vtblk_softc { #define VTBLK_FLAG_SUSPEND 0x0008 #define VTBLK_FLAG_DUMPING 0x0010 #define VTBLK_FLAG_BARRIER 0x0020 +#define VTBLK_FLAG_WC_CONFIG 0x0040 struct virtqueue *vtblk_vq; struct sglist *vtblk_sglist; @@ -85,11 +92,9 @@ struct vtblk_softc { vtblk_req_ready; struct vtblk_request *vtblk_req_ordered; - struct taskqueue *vtblk_tq; - struct task vtblk_intr_task; - int vtblk_max_nsegs; int vtblk_request_count; + enum vtblk_cache_mode vtblk_write_cache; struct vtblk_request vtblk_dump_request; }; @@ -102,8 +107,9 @@ static struct virtio_feature_desc vtblk_feature_desc[] = { { VIRTIO_BLK_F_RO, "ReadOnly" }, { VIRTIO_BLK_F_BLK_SIZE, "BlockSize" }, { VIRTIO_BLK_F_SCSI, "SCSICmds" }, - { VIRTIO_BLK_F_FLUSH, "FlushCmd" }, + { VIRTIO_BLK_F_WCE, "WriteCache" }, { VIRTIO_BLK_F_TOPOLOGY, "Topology" }, + { VIRTIO_BLK_F_CONFIG_WCE, "ConfigWCE" }, { 0, NULL } }; @@ -116,6 +122,7 @@ static int vtblk_detach(device_t); static int vtblk_suspend(device_t); static int vtblk_resume(device_t); static int vtblk_shutdown(device_t); +static int vtblk_config_change(device_t); static int vtblk_open(struct disk *); static int vtblk_close(struct disk *); @@ -128,6 +135,11 @@ static void vtblk_negotiate_features(struct vtblk_softc *); static int vtblk_maximum_segments(struct vtblk_softc *, struct virtio_blk_config *); static int vtblk_alloc_virtqueue(struct vtblk_softc *); +static void vtblk_resize_disk(struct vtblk_softc *, uint64_t); +static void vtblk_set_write_cache(struct vtblk_softc *, int); +static int vtblk_write_cache_enabled(struct vtblk_softc *sc, + struct virtio_blk_config *); +static int vtblk_write_cache_sysctl(SYSCTL_HANDLER_ARGS); static void vtblk_alloc_disk(struct vtblk_softc *, struct virtio_blk_config *); static void vtblk_create_disk(struct vtblk_softc *); @@ -138,11 +150,12 @@ static struct vtblk_request * vtblk_bio_request(struct vtblk_softc *); static int vtblk_execute_request(struct vtblk_softc *, struct vtblk_request *); -static int vtblk_vq_intr(void *); -static void vtblk_intr_task(void *, int); +static void vtblk_vq_intr(void *); static void vtblk_stop(struct vtblk_softc *); +static void vtblk_read_config(struct vtblk_softc *, + struct virtio_blk_config *); static void vtblk_get_ident(struct vtblk_softc *); static void vtblk_prepare_dump(struct vtblk_softc *); static int vtblk_write_dump(struct vtblk_softc *, void *, off_t, size_t); @@ -167,9 +180,14 @@ static void vtblk_enqueue_ready(struct vtblk_softc *, static int vtblk_request_error(struct vtblk_request *); static void vtblk_finish_bio(struct bio *, int); +static void vtblk_setup_sysctl(struct vtblk_softc *); +static int vtblk_tunable_int(struct vtblk_softc *, const char *, int); + /* Tunables. */ static int vtblk_no_ident = 0; TUNABLE_INT("hw.vtblk.no_ident", &vtblk_no_ident); +static int vtblk_writecache_mode = -1; +TUNABLE_INT("hw.vtblk.writecache_mode", &vtblk_writecache_mode); /* Features desired/implemented by this driver. */ #define VTBLK_FEATURES \ @@ -179,13 +197,14 @@ TUNABLE_INT("hw.vtblk.no_ident", &vtblk_no_ident); VIRTIO_BLK_F_GEOMETRY | \ VIRTIO_BLK_F_RO | \ VIRTIO_BLK_F_BLK_SIZE | \ - VIRTIO_BLK_F_FLUSH | \ + VIRTIO_BLK_F_WCE | \ + VIRTIO_BLK_F_CONFIG_WCE | \ VIRTIO_RING_F_INDIRECT_DESC) #define VTBLK_MTX(_sc) &(_sc)->vtblk_mtx #define VTBLK_LOCK_INIT(_sc, _name) \ mtx_init(VTBLK_MTX((_sc)), (_name), \ - "VTBLK Lock", MTX_DEF) + "VirtIO Block Lock", MTX_DEF) #define VTBLK_LOCK(_sc) mtx_lock(VTBLK_MTX((_sc))) #define VTBLK_UNLOCK(_sc) mtx_unlock(VTBLK_MTX((_sc))) #define VTBLK_LOCK_DESTROY(_sc) mtx_destroy(VTBLK_MTX((_sc))) @@ -211,6 +230,9 @@ static device_method_t vtblk_methods[] = { DEVMETHOD(device_resume, vtblk_resume), DEVMETHOD(device_shutdown, vtblk_shutdown), + /* VirtIO methods. */ + DEVMETHOD(virtio_config_change, vtblk_config_change), + DEVMETHOD_END }; @@ -284,10 +306,13 @@ vtblk_attach(device_t dev) sc->vtblk_flags |= VTBLK_FLAG_READONLY; if (virtio_with_feature(dev, VIRTIO_BLK_F_BARRIER)) sc->vtblk_flags |= VTBLK_FLAG_BARRIER; + if (virtio_with_feature(dev, VIRTIO_BLK_F_CONFIG_WCE)) + sc->vtblk_flags |= VTBLK_FLAG_WC_CONFIG; + + vtblk_setup_sysctl(sc); /* Get local copy of config. */ - virtio_read_device_config(dev, 0, &blkcfg, - sizeof(struct virtio_blk_config)); + vtblk_read_config(sc, &blkcfg); /* * With the current sglist(9) implementation, it is not easy @@ -333,24 +358,12 @@ vtblk_attach(device_t dev) vtblk_alloc_disk(sc, &blkcfg); - TASK_INIT(&sc->vtblk_intr_task, 0, vtblk_intr_task, sc); - sc->vtblk_tq = taskqueue_create_fast("vtblk_taskq", M_NOWAIT, - taskqueue_thread_enqueue, &sc->vtblk_tq); - if (sc->vtblk_tq == NULL) { - error = ENOMEM; - device_printf(dev, "cannot allocate taskqueue\n"); - goto fail; - } - error = virtio_setup_intr(dev, INTR_TYPE_BIO | INTR_ENTROPY); if (error) { device_printf(dev, "cannot setup virtqueue interrupt\n"); goto fail; } - taskqueue_start_threads(&sc->vtblk_tq, 1, PI_DISK, "%s taskq", - device_get_nameunit(dev)); - vtblk_create_disk(sc); virtqueue_enable_intr(sc->vtblk_vq); @@ -375,12 +388,6 @@ vtblk_detach(device_t dev) vtblk_stop(sc); VTBLK_UNLOCK(sc); - if (sc->vtblk_tq != NULL) { - taskqueue_drain(sc->vtblk_tq, &sc->vtblk_intr_task); - taskqueue_free(sc->vtblk_tq); - sc->vtblk_tq = NULL; - } - vtblk_drain(sc); if (sc->vtblk_disk != NULL) { @@ -441,6 +448,26 @@ vtblk_shutdown(device_t dev) } static int +vtblk_config_change(device_t dev) +{ + struct vtblk_softc *sc; + struct virtio_blk_config blkcfg; + uint64_t capacity; + + sc = device_get_softc(dev); + + vtblk_read_config(sc, &blkcfg); + + /* Capacity is always in 512-byte units. */ + capacity = blkcfg.capacity * 512; + + if (sc->vtblk_disk->d_mediasize != capacity) + vtblk_resize_disk(sc, capacity); + + return (0); +} + +static int vtblk_open(struct disk *dp) { struct vtblk_softc *sc; @@ -541,8 +568,8 @@ vtblk_strategy(struct bio *bp) max_nsegs = sc->vtblk_max_nsegs - VTBLK_MIN_SEGMENTS; KASSERT(nsegs <= max_nsegs, - ("bio %p spanned too many segments: %d, max: %d", - bp, nsegs, max_nsegs)); + ("%s: bio %p spanned too many segments: %d, max: %d", + __func__, bp, nsegs, max_nsegs)); } #endif @@ -606,6 +633,84 @@ vtblk_alloc_virtqueue(struct vtblk_softc *sc) } static void +vtblk_resize_disk(struct vtblk_softc *sc, uint64_t new_capacity) +{ + device_t dev; + struct disk *dp; + int error; + + dev = sc->vtblk_dev; + dp = sc->vtblk_disk; + + dp->d_mediasize = new_capacity; + if (bootverbose) { + device_printf(dev, "resized to %juMB (%ju %u byte sectors)\n", + (uintmax_t) dp->d_mediasize >> 20, + (uintmax_t) dp->d_mediasize / dp->d_sectorsize, + dp->d_sectorsize); + } + + error = disk_resize(dp, M_NOWAIT); + if (error) { + device_printf(dev, + "disk_resize(9) failed, error: %d\n", error); + } +} + +static void +vtblk_set_write_cache(struct vtblk_softc *sc, int wc) +{ + + /* Set either writeback (1) or writethrough (0) mode. */ + virtio_write_dev_config_1(sc->vtblk_dev, + offsetof(struct virtio_blk_config, writeback), wc); +} + +static int +vtblk_write_cache_enabled(struct vtblk_softc *sc, + struct virtio_blk_config *blkcfg) +{ + int wc; + + if (sc->vtblk_flags & VTBLK_FLAG_WC_CONFIG) { + wc = vtblk_tunable_int(sc, "writecache_mode", + vtblk_writecache_mode); + if (wc >= 0 && wc < VTBLK_CACHE_MAX) + vtblk_set_write_cache(sc, wc); + else + wc = blkcfg->writeback; + } else + wc = virtio_with_feature(sc->vtblk_dev, VIRTIO_BLK_F_WCE); + + return (wc); +} + +static int +vtblk_write_cache_sysctl(SYSCTL_HANDLER_ARGS) +{ + struct vtblk_softc *sc; + int wc, error; + + sc = oidp->oid_arg1; + wc = sc->vtblk_write_cache; + + error = sysctl_handle_int(oidp, &wc, 0, req); + if (error || req->newptr == NULL) + return (error); + if ((sc->vtblk_flags & VTBLK_FLAG_WC_CONFIG) == 0) + return (EPERM); + if (wc < 0 || wc >= VTBLK_CACHE_MAX) + return (EINVAL); + + VTBLK_LOCK(sc); + sc->vtblk_write_cache = wc; + vtblk_set_write_cache(sc, sc->vtblk_write_cache); + VTBLK_UNLOCK(sc); + + return (0); +} + +static void vtblk_alloc_disk(struct vtblk_softc *sc, struct virtio_blk_config *blkcfg) { device_t dev; @@ -621,6 +726,11 @@ vtblk_alloc_disk(struct vtblk_softc *sc, struct virtio_blk_config *blkcfg) dp->d_name = VTBLK_DISK_NAME; dp->d_unit = device_get_unit(dev); dp->d_drv1 = sc; + dp->d_flags = DISKFLAG_CANFLUSHCACHE; + dp->d_hba_vendor = virtio_get_vendor(dev); + dp->d_hba_device = virtio_get_device(dev); + dp->d_hba_subvendor = virtio_get_subvendor(dev); + dp->d_hba_subdevice = virtio_get_subdevice(dev); if ((sc->vtblk_flags & VTBLK_FLAG_READONLY) == 0) dp->d_dump = vtblk_dump; @@ -656,8 +766,18 @@ vtblk_alloc_disk(struct vtblk_softc *sc, struct virtio_blk_config *blkcfg) dp->d_fwheads = blkcfg->geometry.heads; } - if (virtio_with_feature(dev, VIRTIO_BLK_F_FLUSH)) - dp->d_flags |= DISKFLAG_CANFLUSHCACHE; + if (virtio_with_feature(dev, VIRTIO_BLK_F_TOPOLOGY)) { + dp->d_stripesize = dp->d_sectorsize * + (1 << blkcfg->topology.physical_block_exp); + dp->d_stripeoffset = (dp->d_stripesize - + blkcfg->topology.alignment_offset * dp->d_sectorsize) % + dp->d_stripesize; + } + + if (vtblk_write_cache_enabled(sc, blkcfg) != 0) + sc->vtblk_write_cache = VTBLK_CACHE_WRITEBACK; + else + sc->vtblk_write_cache = VTBLK_CACHE_WRITETHROUGH; } static void @@ -765,8 +885,7 @@ vtblk_bio_request(struct vtblk_softc *sc) req->vbr_hdr.sector = bp->bio_offset / 512; break; default: - panic("%s: bio with unhandled cmd: %d", __FUNCTION__, - bp->bio_cmd); + panic("%s: bio with unhandled cmd: %d", __func__, bp->bio_cmd); } return (req); @@ -809,14 +928,13 @@ vtblk_execute_request(struct vtblk_softc *sc, struct vtblk_request *req) } sglist_reset(sg); - sglist_append(sg, &req->vbr_hdr, sizeof(struct virtio_blk_outhdr)); if (bp->bio_cmd == BIO_READ || bp->bio_cmd == BIO_WRITE) { error = sglist_append(sg, bp->bio_data, bp->bio_bcount); if (error || sg->sg_nseg == sg->sg_maxseg) panic("%s: data buffer too big bio:%p error:%d", - __FUNCTION__, bp, error); + __func__, bp, error); /* BIO_READ means the host writes into our buffer. */ if (bp->bio_cmd == BIO_READ) @@ -834,28 +952,16 @@ vtblk_execute_request(struct vtblk_softc *sc, struct vtblk_request *req) return (error); } -static int -vtblk_vq_intr(void *xsc) -{ - struct vtblk_softc *sc; - - sc = xsc; - - virtqueue_disable_intr(sc->vtblk_vq); - taskqueue_enqueue_fast(sc->vtblk_tq, &sc->vtblk_intr_task); - - return (1); -} - static void -vtblk_intr_task(void *arg, int pending) +vtblk_vq_intr(void *xsc) { struct vtblk_softc *sc; struct virtqueue *vq; - sc = arg; + sc = xsc; vq = sc->vtblk_vq; +again: VTBLK_LOCK(sc); if (sc->vtblk_flags & VTBLK_FLAG_DETACH) { VTBLK_UNLOCK(sc); @@ -872,9 +978,7 @@ vtblk_intr_task(void *arg, int pending) if (virtqueue_enable_intr(vq) != 0) { virtqueue_disable_intr(vq); VTBLK_UNLOCK(sc); - taskqueue_enqueue_fast(sc->vtblk_tq, - &sc->vtblk_intr_task); - return; + goto again; } VTBLK_UNLOCK(sc); @@ -888,6 +992,37 @@ vtblk_stop(struct vtblk_softc *sc) virtio_stop(sc->vtblk_dev); } +#define VTBLK_GET_CONFIG(_dev, _feature, _field, _cfg) \ + if (virtio_with_feature(_dev, _feature)) { \ + virtio_read_device_config(_dev, \ + offsetof(struct virtio_blk_config, _field), \ + &(_cfg)->_field, sizeof((_cfg)->_field)); \ + } + +static void +vtblk_read_config(struct vtblk_softc *sc, struct virtio_blk_config *blkcfg) +{ + device_t dev; + + dev = sc->vtblk_dev; + + bzero(blkcfg, sizeof(struct virtio_blk_config)); + + /* The capacity is always available. */ + virtio_read_device_config(dev, offsetof(struct virtio_blk_config, + capacity), &blkcfg->capacity, sizeof(blkcfg->capacity)); + + /* Read the configuration if the feature was negotiated. */ + VTBLK_GET_CONFIG(dev, VIRTIO_BLK_F_SIZE_MAX, size_max, blkcfg); + VTBLK_GET_CONFIG(dev, VIRTIO_BLK_F_SEG_MAX, seg_max, blkcfg); + VTBLK_GET_CONFIG(dev, VIRTIO_BLK_F_GEOMETRY, geometry, blkcfg); + VTBLK_GET_CONFIG(dev, VIRTIO_BLK_F_BLK_SIZE, blk_size, blkcfg); + VTBLK_GET_CONFIG(dev, VIRTIO_BLK_F_TOPOLOGY, topology, blkcfg); + VTBLK_GET_CONFIG(dev, VIRTIO_BLK_F_CONFIG_WCE, writeback, blkcfg); +} + +#undef VTBLK_GET_CONFIG + static void vtblk_get_ident(struct vtblk_softc *sc) { @@ -899,7 +1034,7 @@ vtblk_get_ident(struct vtblk_softc *sc) dp = sc->vtblk_disk; len = MIN(VIRTIO_BLK_ID_BYTES, DISK_IDENT_SIZE); - if (vtblk_no_ident != 0) + if (vtblk_tunable_int(sc, "no_ident", vtblk_no_ident) != 0) return; req = vtblk_dequeue_request(sc); @@ -949,8 +1084,10 @@ vtblk_prepare_dump(struct vtblk_softc *sc) */ vtblk_drain_vq(sc, 1); - if (virtio_reinit(dev, sc->vtblk_features) != 0) - panic("cannot reinit VirtIO block device during dump"); + if (virtio_reinit(dev, sc->vtblk_features) != 0) { + panic("%s: cannot reinit VirtIO block device during dump", + device_get_nameunit(dev)); + } virtqueue_disable_intr(vq); virtio_reinit_complete(dev); @@ -1003,7 +1140,6 @@ static int vtblk_poll_request(struct vtblk_softc *sc, struct vtblk_request *req) { struct virtqueue *vq; - struct vtblk_request *r; int error; vq = sc->vtblk_vq; @@ -1016,14 +1152,12 @@ vtblk_poll_request(struct vtblk_softc *sc, struct vtblk_request *req) return (error); virtqueue_notify(vq); - - r = virtqueue_poll(vq, NULL); - KASSERT(r == req, ("unexpected request response: %p/%p", r, req)); + virtqueue_poll(vq, NULL); error = vtblk_request_error(req); if (error && bootverbose) { device_printf(sc->vtblk_dev, - "%s: IO error: %d\n", __FUNCTION__, error); + "%s: IO error: %d\n", __func__, error); } return (error); @@ -1154,7 +1288,7 @@ vtblk_free_requests(struct vtblk_softc *sc) struct vtblk_request *req; KASSERT(TAILQ_EMPTY(&sc->vtblk_req_ready), - ("ready requests left on queue")); + ("%s: ready requests left on queue", __func__)); while ((req = vtblk_dequeue_request(sc)) != NULL) { sc->vtblk_request_count--; @@ -1162,7 +1296,7 @@ vtblk_free_requests(struct vtblk_softc *sc) } KASSERT(sc->vtblk_request_count == 0, - ("leaked requests: %d", sc->vtblk_request_count)); + ("%s: leaked %d requests", __func__, sc->vtblk_request_count)); } static struct vtblk_request * @@ -1236,3 +1370,33 @@ vtblk_finish_bio(struct bio *bp, int error) biodone(bp); } + +static void +vtblk_setup_sysctl(struct vtblk_softc *sc) +{ + device_t dev; + struct sysctl_ctx_list *ctx; + struct sysctl_oid *tree; + struct sysctl_oid_list *child; + + dev = sc->vtblk_dev; + ctx = device_get_sysctl_ctx(dev); + tree = device_get_sysctl_tree(dev); + child = SYSCTL_CHILDREN(tree); + + SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "writecache_mode", + CTLTYPE_INT | CTLFLAG_RW, sc, 0, vtblk_write_cache_sysctl, + "I", "Write cache mode (writethrough (0) or writeback (1))"); +} + +static int +vtblk_tunable_int(struct vtblk_softc *sc, const char *knob, int def) +{ + char path[64]; + + snprintf(path, sizeof(path), + "hw.vtblk.%d.%s", device_get_unit(sc->vtblk_dev), knob); + TUNABLE_INT_FETCH(path, &def); + + return (def); +} diff --git a/sys/dev/virtio/block/virtio_blk.h b/sys/dev/virtio/block/virtio_blk.h index fdac9e5..cdb8d3f 100644 --- a/sys/dev/virtio/block/virtio_blk.h +++ b/sys/dev/virtio/block/virtio_blk.h @@ -39,8 +39,9 @@ #define VIRTIO_BLK_F_RO 0x0020 /* Disk is read-only */ #define VIRTIO_BLK_F_BLK_SIZE 0x0040 /* Block size of disk is available*/ #define VIRTIO_BLK_F_SCSI 0x0080 /* Supports scsi command passthru */ -#define VIRTIO_BLK_F_FLUSH 0x0200 /* Cache flush command support */ +#define VIRTIO_BLK_F_WCE 0x0200 /* Writeback mode enabled after reset */ #define VIRTIO_BLK_F_TOPOLOGY 0x0400 /* Topology information is available */ +#define VIRTIO_BLK_F_CONFIG_WCE 0x0800 /* Writeback mode available in config */ #define VIRTIO_BLK_ID_BYTES 20 /* ID string length */ @@ -51,15 +52,27 @@ struct virtio_blk_config { uint32_t size_max; /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */ uint32_t seg_max; - /* geometry the device (if VIRTIO_BLK_F_GEOMETRY) */ + /* Geometry of the device (if VIRTIO_BLK_F_GEOMETRY) */ struct virtio_blk_geometry { uint16_t cylinders; uint8_t heads; uint8_t sectors; } geometry; - /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */ + /* Block size of device (if VIRTIO_BLK_F_BLK_SIZE) */ uint32_t blk_size; + + /* Topology of the device (if VIRTIO_BLK_F_TOPOLOGY) */ + struct virtio_blk_topology { + uint8_t physical_block_exp; + uint8_t alignment_offset; + uint16_t min_io_size; + uint16_t opt_io_size; + } topology; + + /* Writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */ + uint8_t writeback; + } __packed; /* diff --git a/sys/dev/virtio/network/if_vtnet.c b/sys/dev/virtio/network/if_vtnet.c index 8e2de46..89604d1 100644 --- a/sys/dev/virtio/network/if_vtnet.c +++ b/sys/dev/virtio/network/if_vtnet.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -42,7 +42,6 @@ __FBSDID("$FreeBSD$"); #include <sys/module.h> #include <sys/socket.h> #include <sys/sysctl.h> -#include <sys/taskqueue.h> #include <sys/random.h> #include <sys/sglist.h> #include <sys/lock.h> @@ -97,7 +96,6 @@ static void vtnet_set_hwaddr(struct vtnet_softc *); static int vtnet_is_link_up(struct vtnet_softc *); static void vtnet_update_link_status(struct vtnet_softc *); static void vtnet_watchdog(struct vtnet_softc *); -static void vtnet_config_change_task(void *, int); static int vtnet_change_mtu(struct vtnet_softc *, int); static int vtnet_ioctl(struct ifnet *, u_long, caddr_t); @@ -123,8 +121,7 @@ static int vtnet_rx_csum(struct vtnet_softc *, struct mbuf *, struct virtio_net_hdr *); static int vtnet_rxeof_merged(struct vtnet_softc *, struct mbuf *, int); static int vtnet_rxeof(struct vtnet_softc *, int, int *); -static void vtnet_rx_intr_task(void *, int); -static int vtnet_rx_vq_intr(void *); +static void vtnet_rx_vq_intr(void *); static void vtnet_txeof(struct vtnet_softc *); static struct mbuf * vtnet_tx_offload(struct vtnet_softc *, struct mbuf *, @@ -135,8 +132,7 @@ static int vtnet_encap(struct vtnet_softc *, struct mbuf **); static void vtnet_start_locked(struct ifnet *); static void vtnet_start(struct ifnet *); static void vtnet_tick(void *); -static void vtnet_tx_intr_task(void *, int); -static int vtnet_tx_vq_intr(void *); +static void vtnet_tx_vq_intr(void *); static void vtnet_stop(struct vtnet_softc *); static int vtnet_reinit(struct vtnet_softc *); @@ -427,19 +423,6 @@ vtnet_attach(device_t dev) ifp->if_capabilities |= IFCAP_POLLING; #endif - TASK_INIT(&sc->vtnet_rx_intr_task, 0, vtnet_rx_intr_task, sc); - TASK_INIT(&sc->vtnet_tx_intr_task, 0, vtnet_tx_intr_task, sc); - TASK_INIT(&sc->vtnet_cfgchg_task, 0, vtnet_config_change_task, sc); - - sc->vtnet_tq = taskqueue_create_fast("vtnet_taskq", M_NOWAIT, - taskqueue_thread_enqueue, &sc->vtnet_tq); - if (sc->vtnet_tq == NULL) { - error = ENOMEM; - device_printf(dev, "cannot allocate taskqueue\n"); - ether_ifdetach(ifp); - goto fail; - } - error = virtio_setup_intr(dev, INTR_TYPE_NET); if (error) { device_printf(dev, "cannot setup virtqueue interrupts\n"); @@ -447,9 +430,6 @@ vtnet_attach(device_t dev) goto fail; } - taskqueue_start_threads(&sc->vtnet_tq, 1, PI_NET, "%s taskq", - device_get_nameunit(dev)); - /* * Device defaults to promiscuous mode for backwards * compatibility. Turn it off if possible. @@ -495,18 +475,10 @@ vtnet_detach(device_t dev) VTNET_UNLOCK(sc); callout_drain(&sc->vtnet_tick_ch); - taskqueue_drain(taskqueue_fast, &sc->vtnet_cfgchg_task); ether_ifdetach(ifp); } - if (sc->vtnet_tq != NULL) { - taskqueue_drain(sc->vtnet_tq, &sc->vtnet_rx_intr_task); - taskqueue_drain(sc->vtnet_tq, &sc->vtnet_tx_intr_task); - taskqueue_free(sc->vtnet_tq); - sc->vtnet_tq = NULL; - } - if (sc->vtnet_vlan_attach != NULL) { EVENTHANDLER_DEREGISTER(vlan_config, sc->vtnet_vlan_attach); sc->vtnet_vlan_attach = NULL; @@ -590,9 +562,11 @@ vtnet_config_change(device_t dev) sc = device_get_softc(dev); - taskqueue_enqueue_fast(taskqueue_fast, &sc->vtnet_cfgchg_task); + VTNET_LOCK(sc); + vtnet_update_link_status(sc); + VTNET_UNLOCK(sc); - return (1); + return (0); } static void @@ -788,18 +762,6 @@ vtnet_watchdog(struct vtnet_softc *sc) vtnet_init_locked(sc); } -static void -vtnet_config_change_task(void *arg, int pending) -{ - struct vtnet_softc *sc; - - sc = arg; - - VTNET_LOCK(sc); - vtnet_update_link_status(sc); - VTNET_UNLOCK(sc); -} - static int vtnet_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) { @@ -1705,15 +1667,16 @@ vtnet_rxeof(struct vtnet_softc *sc, int count, int *rx_npktsp) } static void -vtnet_rx_intr_task(void *arg, int pending) +vtnet_rx_vq_intr(void *xsc) { struct vtnet_softc *sc; struct ifnet *ifp; int more; - sc = arg; + sc = xsc; ifp = sc->vtnet_ifp; +again: VTNET_LOCK(sc); #ifdef DEVICE_POLLING @@ -1730,31 +1693,15 @@ vtnet_rx_intr_task(void *arg, int pending) } more = vtnet_rxeof(sc, sc->vtnet_rx_process_limit, NULL); - if (!more && vtnet_enable_rx_intr(sc) != 0) { - vtnet_disable_rx_intr(sc); - more = 1; - } - - VTNET_UNLOCK(sc); - - if (more) { + if (more || vtnet_enable_rx_intr(sc) != 0) { + if (!more) + vtnet_disable_rx_intr(sc); sc->vtnet_stats.rx_task_rescheduled++; - taskqueue_enqueue_fast(sc->vtnet_tq, - &sc->vtnet_rx_intr_task); + VTNET_UNLOCK(sc); + goto again; } -} - -static int -vtnet_rx_vq_intr(void *xsc) -{ - struct vtnet_softc *sc; - - sc = xsc; - - vtnet_disable_rx_intr(sc); - taskqueue_enqueue_fast(sc->vtnet_tq, &sc->vtnet_rx_intr_task); - return (1); + VTNET_UNLOCK(sc); } static void @@ -1800,7 +1747,6 @@ vtnet_tx_offload(struct vtnet_softc *sc, struct mbuf *m, uint8_t ip_proto, gso_type; ifp = sc->vtnet_ifp; - M_ASSERTPKTHDR(m); ip_offset = sizeof(struct ether_header); if (m->m_len < ip_offset) { @@ -1918,7 +1864,7 @@ vtnet_enqueue_txbuf(struct vtnet_softc *sc, struct mbuf **m_head, sglist_init(&sg, VTNET_MAX_TX_SEGS, segs); error = sglist_append(&sg, &txhdr->vth_uhdr, sc->vtnet_hdr_size); KASSERT(error == 0 && sg.sg_nseg == 1, - ("cannot add header to sglist")); + ("%s: cannot add header to sglist error %d", __func__, error)); again: error = sglist_append_mbuf(&sg, m); @@ -1955,6 +1901,7 @@ vtnet_encap(struct vtnet_softc *sc, struct mbuf **m_head) int error; m = *m_head; + M_ASSERTPKTHDR(m); txhdr = uma_zalloc(vtnet_tx_header_zone, M_NOWAIT | M_ZERO); if (txhdr == NULL) { @@ -2077,14 +2024,15 @@ vtnet_tick(void *xsc) } static void -vtnet_tx_intr_task(void *arg, int pending) +vtnet_tx_vq_intr(void *xsc) { struct vtnet_softc *sc; struct ifnet *ifp; - sc = arg; + sc = xsc; ifp = sc->vtnet_ifp; +again: VTNET_LOCK(sc); #ifdef DEVICE_POLLING @@ -2109,26 +2057,12 @@ vtnet_tx_intr_task(void *arg, int pending) vtnet_disable_tx_intr(sc); sc->vtnet_stats.tx_task_rescheduled++; VTNET_UNLOCK(sc); - taskqueue_enqueue_fast(sc->vtnet_tq, &sc->vtnet_tx_intr_task); - return; + goto again; } VTNET_UNLOCK(sc); } -static int -vtnet_tx_vq_intr(void *xsc) -{ - struct vtnet_softc *sc; - - sc = xsc; - - vtnet_disable_tx_intr(sc); - taskqueue_enqueue_fast(sc->vtnet_tq, &sc->vtnet_tx_intr_task); - - return (1); -} - static void vtnet_stop(struct vtnet_softc *sc) { diff --git a/sys/dev/virtio/network/if_vtnetvar.h b/sys/dev/virtio/network/if_vtnetvar.h index 184870e..d870436 100644 --- a/sys/dev/virtio/network/if_vtnetvar.h +++ b/sys/dev/virtio/network/if_vtnetvar.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -79,11 +79,6 @@ struct vtnet_softc { int vtnet_watchdog_timer; uint64_t vtnet_features; - struct taskqueue *vtnet_tq; - struct task vtnet_rx_intr_task; - struct task vtnet_tx_intr_task; - struct task vtnet_cfgchg_task; - struct vtnet_statistics vtnet_stats; struct callout vtnet_tick_ch; diff --git a/sys/dev/virtio/pci/virtio_pci.c b/sys/dev/virtio/pci/virtio_pci.c index 917ca84..b3df3d9 100644 --- a/sys/dev/virtio/pci/virtio_pci.c +++ b/sys/dev/virtio/pci/virtio_pci.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -51,6 +51,17 @@ __FBSDID("$FreeBSD$"); #include "virtio_bus_if.h" #include "virtio_if.h" +struct vtpci_interrupt { + struct resource *vti_irq; + int vti_rid; + void *vti_handler; +}; + +struct vtpci_virtqueue { + struct virtqueue *vtv_vq; + int vtv_no_intr; +}; + struct vtpci_softc { device_t vtpci_dev; struct resource *vtpci_res; @@ -69,40 +80,22 @@ struct vtpci_softc { device_t vtpci_child_dev; struct virtio_feature_desc *vtpci_child_feat_desc; - /* - * Ideally, each virtqueue that the driver provides a callback for - * will receive its own MSIX vector. If there are not sufficient - * vectors available, we will then attempt to have all the VQs - * share one vector. Note that when using MSIX, the configuration - * changed notifications must be on their own vector. - * - * If MSIX is not available, we will attempt to have the whole - * device share one MSI vector, and then, finally, one legacy - * interrupt. - */ int vtpci_nvqs; - struct vtpci_virtqueue { - struct virtqueue *vq; - /* Device did not provide a callback for this virtqueue. */ - int no_intr; - /* Index into vtpci_intr_res[] below. Unused, then -1. */ - int ires_idx; - } vtpci_vqx[VIRTIO_MAX_VIRTQUEUES]; + struct vtpci_virtqueue *vtpci_vqs; /* - * When using MSIX interrupts, the first element of vtpci_intr_res[] - * is always the configuration changed notifications. The remaining - * element(s) are used for the virtqueues. + * Ideally, each virtqueue that the driver provides a callback for will + * receive its own MSIX vector. If there are not sufficient vectors + * available, then attempt to have all the VQs share one vector. For + * MSIX, the configuration changed notifications must be on their own + * vector. * - * With MSI and legacy interrupts, only the first element of - * vtpci_intr_res[] is used. + * If MSIX is not available, we will attempt to have the whole device + * share one MSI vector, and then, finally, one legacy interrupt. */ - int vtpci_nintr_res; - struct vtpci_intr_resource { - struct resource *irq; - int rid; - void *intrhand; - } vtpci_intr_res[1 + VIRTIO_MAX_VIRTQUEUES]; + struct vtpci_interrupt vtpci_device_interrupt; + struct vtpci_interrupt *vtpci_msix_vq_interrupts; + int vtpci_nmsix_resources; }; static int vtpci_probe(device_t); @@ -134,36 +127,45 @@ static void vtpci_describe_features(struct vtpci_softc *, const char *, uint64_t); static void vtpci_probe_and_attach_child(struct vtpci_softc *); -static int vtpci_alloc_msix(struct vtpci_softc *, int); -static int vtpci_alloc_msi(struct vtpci_softc *); -static int vtpci_alloc_intr_msix_pervq(struct vtpci_softc *); -static int vtpci_alloc_intr_msix_shared(struct vtpci_softc *); -static int vtpci_alloc_intr_msi(struct vtpci_softc *); -static int vtpci_alloc_intr_legacy(struct vtpci_softc *); +static int vtpci_alloc_msix(struct vtpci_softc *, int); +static int vtpci_alloc_msi(struct vtpci_softc *); +static int vtpci_alloc_intr_msix_pervq(struct vtpci_softc *); +static int vtpci_alloc_intr_msix_shared(struct vtpci_softc *); +static int vtpci_alloc_intr_msi(struct vtpci_softc *); +static int vtpci_alloc_intr_legacy(struct vtpci_softc *); +static int vtpci_alloc_interrupt(struct vtpci_softc *, int, int, + struct vtpci_interrupt *); static int vtpci_alloc_intr_resources(struct vtpci_softc *); -static int vtpci_setup_legacy_interrupt(struct vtpci_softc *, +static int vtpci_setup_legacy_interrupt(struct vtpci_softc *, + enum intr_type); +static int vtpci_setup_pervq_msix_interrupts(struct vtpci_softc *, enum intr_type); -static int vtpci_setup_msix_interrupts(struct vtpci_softc *, +static int vtpci_setup_msix_interrupts(struct vtpci_softc *, enum intr_type); -static int vtpci_setup_interrupts(struct vtpci_softc *, enum intr_type); +static int vtpci_setup_interrupts(struct vtpci_softc *, enum intr_type); -static int vtpci_register_msix_vector(struct vtpci_softc *, int, int); -static int vtpci_set_host_msix_vectors(struct vtpci_softc *); -static int vtpci_reinit_virtqueue(struct vtpci_softc *, int); +static int vtpci_register_msix_vector(struct vtpci_softc *, int, + struct vtpci_interrupt *); +static int vtpci_set_host_msix_vectors(struct vtpci_softc *); +static int vtpci_reinit_virtqueue(struct vtpci_softc *, int); +static void vtpci_free_interrupt(struct vtpci_softc *, + struct vtpci_interrupt *); static void vtpci_free_interrupts(struct vtpci_softc *); static void vtpci_free_virtqueues(struct vtpci_softc *); -static void vtpci_cleanup_setup_intr_attempt(struct vtpci_softc *); static void vtpci_release_child_resources(struct vtpci_softc *); +static void vtpci_cleanup_setup_intr_attempt(struct vtpci_softc *); static void vtpci_reset(struct vtpci_softc *); static void vtpci_select_virtqueue(struct vtpci_softc *, int); -static int vtpci_legacy_intr(void *); -static int vtpci_vq_shared_intr(void *); -static int vtpci_vq_intr(void *); -static int vtpci_config_intr(void *); +static void vtpci_legacy_intr(void *); +static int vtpci_vq_shared_intr_filter(void *); +static void vtpci_vq_shared_intr(void *); +static int vtpci_vq_intr_filter(void *); +static void vtpci_vq_intr(void *); +static void vtpci_config_intr(void *); #define vtpci_setup_msi_interrupt vtpci_setup_legacy_interrupt @@ -478,18 +480,19 @@ vtpci_alloc_virtqueues(device_t dev, int flags, int nvqs, uint16_t size; sc = device_get_softc(dev); - error = 0; if (sc->vtpci_nvqs != 0) return (EALREADY); - if (nvqs <= 0 || nvqs > VIRTIO_MAX_VIRTQUEUES) + if (nvqs <= 0) return (EINVAL); - if (flags & VIRTIO_ALLOC_VQS_DISABLE_MSIX) - sc->vtpci_flags |= VTPCI_FLAG_NO_MSIX; + sc->vtpci_vqs = malloc(nvqs * sizeof(struct vtpci_virtqueue), + M_DEVBUF, M_NOWAIT | M_ZERO); + if (sc->vtpci_vqs == NULL) + return (ENOMEM); for (idx = 0; idx < nvqs; idx++) { - vqx = &sc->vtpci_vqx[idx]; + vqx = &sc->vtpci_vqs[idx]; info = &vq_info[idx]; vtpci_select_virtqueue(sc, idx); @@ -506,12 +509,15 @@ vtpci_alloc_virtqueues(device_t dev, int flags, int nvqs, vtpci_write_config_4(sc, VIRTIO_PCI_QUEUE_PFN, virtqueue_paddr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT); - vqx->vq = *info->vqai_vq = vq; - vqx->no_intr = info->vqai_intr == NULL; + vqx->vtv_vq = *info->vqai_vq = vq; + vqx->vtv_no_intr = info->vqai_intr == NULL; sc->vtpci_nvqs++; } + if (error) + vtpci_free_virtqueues(sc); + return (error); } @@ -772,7 +778,7 @@ vtpci_alloc_msix(struct vtpci_softc *sc, int nvectors) cnt = required; if (pci_alloc_msix(dev, &cnt) == 0 && cnt >= required) { - sc->vtpci_nintr_res = required; + sc->vtpci_nmsix_resources = required; return (0); } @@ -795,10 +801,8 @@ vtpci_alloc_msi(struct vtpci_softc *sc) return (1); cnt = required; - if (pci_alloc_msi(dev, &cnt) == 0 && cnt >= required) { - sc->vtpci_nintr_res = required; + if (pci_alloc_msi(dev, &cnt) == 0 && cnt >= required) return (0); - } pci_release_msi(dev); @@ -815,7 +819,7 @@ vtpci_alloc_intr_msix_pervq(struct vtpci_softc *sc) return (ENOTSUP); for (nvectors = 0, i = 0; i < sc->vtpci_nvqs; i++) { - if (sc->vtpci_vqx[i].no_intr == 0) + if (sc->vtpci_vqs[i].vtv_no_intr == 0) nvectors++; } @@ -869,54 +873,62 @@ vtpci_alloc_intr_legacy(struct vtpci_softc *sc) { sc->vtpci_flags |= VTPCI_FLAG_LEGACY; - sc->vtpci_nintr_res = 1; return (0); } static int -vtpci_alloc_intr_resources(struct vtpci_softc *sc) +vtpci_alloc_interrupt(struct vtpci_softc *sc, int rid, int flags, + struct vtpci_interrupt *intr) { - device_t dev; struct resource *irq; - struct vtpci_virtqueue *vqx; - int i, rid, flags, res_idx; - dev = sc->vtpci_dev; + irq = bus_alloc_resource_any(sc->vtpci_dev, SYS_RES_IRQ, &rid, flags); + if (irq == NULL) + return (ENXIO); - if (sc->vtpci_flags & VTPCI_FLAG_LEGACY) { - rid = 0; - flags = RF_ACTIVE | RF_SHAREABLE; - } else { - rid = 1; - flags = RF_ACTIVE; - } + intr->vti_irq = irq; + intr->vti_rid = rid; - for (i = 0; i < sc->vtpci_nintr_res; i++) { - irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, flags); - if (irq == NULL) - return (ENXIO); + return (0); +} - sc->vtpci_intr_res[i].irq = irq; - sc->vtpci_intr_res[i].rid = rid++; - } +static int +vtpci_alloc_intr_resources(struct vtpci_softc *sc) +{ + struct vtpci_interrupt *intr; + int i, rid, flags, nvq_intrs, error; + + rid = 0; + flags = RF_ACTIVE; + + if (sc->vtpci_flags & VTPCI_FLAG_LEGACY) + flags |= RF_SHAREABLE; + else + rid = 1; /* - * Map the virtqueue into the correct index in vq_intr_res[]. The - * first index is reserved for configuration changed notifications. + * For legacy and MSI interrupts, this single resource handles all + * interrupts. For MSIX, this resource is used for the configuration + * changed interrupt. */ - for (i = 0, res_idx = 1; i < sc->vtpci_nvqs; i++) { - vqx = &sc->vtpci_vqx[i]; - - if (sc->vtpci_flags & VTPCI_FLAG_MSIX) { - if (vqx->no_intr != 0) - vqx->ires_idx = -1; - else if (sc->vtpci_flags & VTPCI_FLAG_SHARED_MSIX) - vqx->ires_idx = res_idx; - else - vqx->ires_idx = res_idx++; - } else - vqx->ires_idx = -1; + intr = &sc->vtpci_device_interrupt; + error = vtpci_alloc_interrupt(sc, rid, flags, intr); + if (error || sc->vtpci_flags & (VTPCI_FLAG_LEGACY | VTPCI_FLAG_MSI)) + return (error); + + /* Subtract one for the configuration changed interrupt. */ + nvq_intrs = sc->vtpci_nmsix_resources - 1; + + intr = sc->vtpci_msix_vq_interrupts = malloc(nvq_intrs * + sizeof(struct vtpci_interrupt), M_DEVBUF, M_NOWAIT | M_ZERO); + if (sc->vtpci_msix_vq_interrupts == NULL) + return (ENOMEM); + + for (i = 0, rid++; i < nvq_intrs; i++, rid++, intr++) { + error = vtpci_alloc_interrupt(sc, rid, flags, intr); + if (error) + return (error); } return (0); @@ -925,67 +937,67 @@ vtpci_alloc_intr_resources(struct vtpci_softc *sc) static int vtpci_setup_legacy_interrupt(struct vtpci_softc *sc, enum intr_type type) { - device_t dev; - struct vtpci_intr_resource *ires; + struct vtpci_interrupt *intr; int error; - dev = sc->vtpci_dev; - - ires = &sc->vtpci_intr_res[0]; - error = bus_setup_intr(dev, ires->irq, type, vtpci_legacy_intr, NULL, - sc, &ires->intrhand); + intr = &sc->vtpci_device_interrupt; + error = bus_setup_intr(sc->vtpci_dev, intr->vti_irq, type, NULL, + vtpci_legacy_intr, sc, &intr->vti_handler); return (error); } static int -vtpci_setup_msix_interrupts(struct vtpci_softc *sc, enum intr_type type) +vtpci_setup_pervq_msix_interrupts(struct vtpci_softc *sc, enum intr_type type) { - device_t dev; - struct vtpci_intr_resource *ires; struct vtpci_virtqueue *vqx; + struct vtpci_interrupt *intr; int i, error; - dev = sc->vtpci_dev; + intr = sc->vtpci_msix_vq_interrupts; - /* - * The first resource is used for configuration changed interrupts. - */ - ires = &sc->vtpci_intr_res[0]; - error = bus_setup_intr(dev, ires->irq, type, vtpci_config_intr, - NULL, sc, &ires->intrhand); - if (error) - return (error); + for (i = 0; i < sc->vtpci_nvqs; i++) { + vqx = &sc->vtpci_vqs[i]; - if (sc->vtpci_flags & VTPCI_FLAG_SHARED_MSIX) { - ires = &sc->vtpci_intr_res[1]; + if (vqx->vtv_no_intr) + continue; - error = bus_setup_intr(dev, ires->irq, type, - vtpci_vq_shared_intr, NULL, sc, &ires->intrhand); + error = bus_setup_intr(sc->vtpci_dev, intr->vti_irq, type, + vtpci_vq_intr_filter, vtpci_vq_intr, vqx->vtv_vq, + &intr->vti_handler); if (error) return (error); - } else { - /* - * Each remaining resource is assigned to a specific virtqueue. - */ - for (i = 0; i < sc->vtpci_nvqs; i++) { - vqx = &sc->vtpci_vqx[i]; - if (vqx->ires_idx < 1) - continue; - - ires = &sc->vtpci_intr_res[vqx->ires_idx]; - error = bus_setup_intr(dev, ires->irq, type, - vtpci_vq_intr, NULL, vqx->vq, &ires->intrhand); - if (error) - return (error); - } + + intr++; } - error = vtpci_set_host_msix_vectors(sc); + return (0); +} + +static int +vtpci_setup_msix_interrupts(struct vtpci_softc *sc, enum intr_type type) +{ + device_t dev; + struct vtpci_interrupt *intr; + int error; + + dev = sc->vtpci_dev; + intr = &sc->vtpci_device_interrupt; + + error = bus_setup_intr(dev, intr->vti_irq, type, NULL, + vtpci_config_intr, sc, &intr->vti_handler); if (error) return (error); - return (0); + if (sc->vtpci_flags & VTPCI_FLAG_SHARED_MSIX) { + intr = sc->vtpci_msix_vq_interrupts; + error = bus_setup_intr(dev, intr->vti_irq, type, + vtpci_vq_shared_intr_filter, vtpci_vq_shared_intr, sc, + &intr->vti_handler); + } else + error = vtpci_setup_pervq_msix_interrupts(sc, type); + + return (error ? error : vtpci_set_host_msix_vectors(sc)); } static int @@ -995,7 +1007,7 @@ vtpci_setup_interrupts(struct vtpci_softc *sc, enum intr_type type) type |= INTR_MPSAFE; KASSERT(sc->vtpci_flags & VTPCI_FLAG_ITYPE_MASK, - ("no interrupt type selected: %#x", sc->vtpci_flags)); + ("%s: no interrupt type selected %#x", __func__, sc->vtpci_flags)); error = vtpci_alloc_intr_resources(sc); if (error) @@ -1012,34 +1024,24 @@ vtpci_setup_interrupts(struct vtpci_softc *sc, enum intr_type type) } static int -vtpci_register_msix_vector(struct vtpci_softc *sc, int offset, int res_idx) +vtpci_register_msix_vector(struct vtpci_softc *sc, int offset, + struct vtpci_interrupt *intr) { device_t dev; - uint16_t vector, rdvector; + uint16_t vector; dev = sc->vtpci_dev; - if (res_idx != -1) { + if (intr != NULL) { /* Map from guest rid to host vector. */ - vector = sc->vtpci_intr_res[res_idx].rid - 1; + vector = intr->vti_rid - 1; } else vector = VIRTIO_MSI_NO_VECTOR; - /* - * Assert the first resource is always used for the configuration - * changed interrupts. - */ - if (res_idx == 0) { - KASSERT(vector == 0 && offset == VIRTIO_MSI_CONFIG_VECTOR, - ("bad first res use vector:%d offset:%d", vector, offset)); - } else - KASSERT(offset == VIRTIO_MSI_QUEUE_VECTOR, ("bad offset")); - vtpci_write_config_2(sc, offset, vector); /* Read vector to determine if the host had sufficient resources. */ - rdvector = vtpci_read_config_2(sc, offset); - if (rdvector != vector) { + if (vtpci_read_config_2(sc, offset) != vector) { device_printf(dev, "insufficient host resources for MSIX interrupts\n"); return (ENODEV); @@ -1051,24 +1053,40 @@ vtpci_register_msix_vector(struct vtpci_softc *sc, int offset, int res_idx) static int vtpci_set_host_msix_vectors(struct vtpci_softc *sc) { - struct vtpci_virtqueue *vqx; - int idx, error; + struct vtpci_interrupt *intr, *tintr; + int idx, offset, error; + + intr = &sc->vtpci_device_interrupt; + offset = VIRTIO_MSI_CONFIG_VECTOR; - error = vtpci_register_msix_vector(sc, VIRTIO_MSI_CONFIG_VECTOR, 0); + error = vtpci_register_msix_vector(sc, offset, intr); if (error) return (error); - for (idx = 0; idx < sc->vtpci_nvqs; idx++) { - vqx = &sc->vtpci_vqx[idx]; + intr = sc->vtpci_msix_vq_interrupts; + offset = VIRTIO_MSI_QUEUE_VECTOR; + for (idx = 0; idx < sc->vtpci_nvqs; idx++) { vtpci_select_virtqueue(sc, idx); - error = vtpci_register_msix_vector(sc, VIRTIO_MSI_QUEUE_VECTOR, - vqx->ires_idx); + + if (sc->vtpci_vqs[idx].vtv_no_intr) + tintr = NULL; + else + tintr = intr; + + error = vtpci_register_msix_vector(sc, offset, tintr); if (error) - return (error); + break; + + /* + * For shared MSIX, all the virtqueues share the first + * interrupt. + */ + if ((sc->vtpci_flags & VTPCI_FLAG_SHARED_MSIX) == 0) + intr++; } - return (0); + return (error); } static int @@ -1079,10 +1097,10 @@ vtpci_reinit_virtqueue(struct vtpci_softc *sc, int idx) int error; uint16_t size; - vqx = &sc->vtpci_vqx[idx]; - vq = vqx->vq; + vqx = &sc->vtpci_vqs[idx]; + vq = vqx->vtv_vq; - KASSERT(vq != NULL, ("vq %d not allocated", idx)); + KASSERT(vq != NULL, ("%s: vq %d not allocated", __func__, idx)); vtpci_select_virtqueue(sc, idx); size = vtpci_read_config_2(sc, VIRTIO_PCI_QUEUE_NUM); @@ -1098,35 +1116,50 @@ vtpci_reinit_virtqueue(struct vtpci_softc *sc, int idx) } static void -vtpci_free_interrupts(struct vtpci_softc *sc) +vtpci_free_interrupt(struct vtpci_softc *sc, struct vtpci_interrupt *intr) { device_t dev; - struct vtpci_intr_resource *ires; - int i; dev = sc->vtpci_dev; - for (i = 0; i < sc->vtpci_nintr_res; i++) { - ires = &sc->vtpci_intr_res[i]; + if (intr->vti_handler != NULL) { + bus_teardown_intr(dev, intr->vti_irq, intr->vti_handler); + intr->vti_handler = NULL; + } - if (ires->intrhand != NULL) { - bus_teardown_intr(dev, ires->irq, ires->intrhand); - ires->intrhand = NULL; - } + if (intr->vti_irq != NULL) { + bus_release_resource(dev, SYS_RES_IRQ, intr->vti_rid, + intr->vti_irq); + intr->vti_irq = NULL; + intr->vti_rid = -1; + } +} - if (ires->irq != NULL) { - bus_release_resource(dev, SYS_RES_IRQ, ires->rid, - ires->irq); - ires->irq = NULL; - } +static void +vtpci_free_interrupts(struct vtpci_softc *sc) +{ + struct vtpci_interrupt *intr; + int i, nvq_intrs; - ires->rid = -1; + vtpci_free_interrupt(sc, &sc->vtpci_device_interrupt); + + if (sc->vtpci_nmsix_resources != 0) { + nvq_intrs = sc->vtpci_nmsix_resources - 1; + sc->vtpci_nmsix_resources = 0; + + intr = sc->vtpci_msix_vq_interrupts; + if (intr != NULL) { + for (i = 0; i < nvq_intrs; i++, intr++) + vtpci_free_interrupt(sc, intr); + + free(sc->vtpci_msix_vq_interrupts, M_DEVBUF); + sc->vtpci_msix_vq_interrupts = NULL; + } } if (sc->vtpci_flags & (VTPCI_FLAG_MSI | VTPCI_FLAG_MSIX)) - pci_release_msi(dev); + pci_release_msi(sc->vtpci_dev); - sc->vtpci_nintr_res = 0; sc->vtpci_flags &= ~VTPCI_FLAG_ITYPE_MASK; } @@ -1134,19 +1167,32 @@ static void vtpci_free_virtqueues(struct vtpci_softc *sc) { struct vtpci_virtqueue *vqx; - int i; + int idx; - for (i = 0; i < sc->vtpci_nvqs; i++) { - vqx = &sc->vtpci_vqx[i]; + for (idx = 0; idx < sc->vtpci_nvqs; idx++) { + vqx = &sc->vtpci_vqs[idx]; + + vtpci_select_virtqueue(sc, idx); + vtpci_write_config_4(sc, VIRTIO_PCI_QUEUE_PFN, 0); - virtqueue_free(vqx->vq); - vqx->vq = NULL; + virtqueue_free(vqx->vtv_vq); + vqx->vtv_vq = NULL; } + free(sc->vtpci_vqs, M_DEVBUF); + sc->vtpci_vqs = NULL; sc->vtpci_nvqs = 0; } static void +vtpci_release_child_resources(struct vtpci_softc *sc) +{ + + vtpci_free_interrupts(sc); + vtpci_free_virtqueues(sc); +} + +static void vtpci_cleanup_setup_intr_attempt(struct vtpci_softc *sc) { int idx; @@ -1166,14 +1212,6 @@ vtpci_cleanup_setup_intr_attempt(struct vtpci_softc *sc) } static void -vtpci_release_child_resources(struct vtpci_softc *sc) -{ - - vtpci_free_interrupts(sc); - vtpci_free_virtqueues(sc); -} - -static void vtpci_reset(struct vtpci_softc *sc) { @@ -1191,7 +1229,7 @@ vtpci_select_virtqueue(struct vtpci_softc *sc, int idx) vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, idx); } -static int +static void vtpci_legacy_intr(void *xsc) { struct vtpci_softc *sc; @@ -1200,7 +1238,7 @@ vtpci_legacy_intr(void *xsc) uint8_t isr; sc = xsc; - vqx = &sc->vtpci_vqx[0]; + vqx = &sc->vtpci_vqs[0]; /* Reading the ISR also clears it. */ isr = vtpci_read_config_1(sc, VIRTIO_PCI_ISR); @@ -1208,15 +1246,16 @@ vtpci_legacy_intr(void *xsc) if (isr & VIRTIO_PCI_ISR_CONFIG) vtpci_config_intr(sc); - if (isr & VIRTIO_PCI_ISR_INTR) - for (i = 0; i < sc->vtpci_nvqs; i++, vqx++) - virtqueue_intr(vqx->vq); - - return (isr ? FILTER_HANDLED : FILTER_STRAY); + if (isr & VIRTIO_PCI_ISR_INTR) { + for (i = 0; i < sc->vtpci_nvqs; i++, vqx++) { + if (vqx->vtv_no_intr == 0) + virtqueue_intr(vqx->vtv_vq); + } + } } static int -vtpci_vq_shared_intr(void *xsc) +vtpci_vq_shared_intr_filter(void *xsc) { struct vtpci_softc *sc; struct vtpci_virtqueue *vqx; @@ -1224,39 +1263,62 @@ vtpci_vq_shared_intr(void *xsc) rc = 0; sc = xsc; - vqx = &sc->vtpci_vqx[0]; + vqx = &sc->vtpci_vqs[0]; - for (i = 0; i < sc->vtpci_nvqs; i++, vqx++) - rc |= virtqueue_intr(vqx->vq); + for (i = 0; i < sc->vtpci_nvqs; i++, vqx++) { + if (vqx->vtv_no_intr == 0) + rc |= virtqueue_intr_filter(vqx->vtv_vq); + } - return (rc ? FILTER_HANDLED : FILTER_STRAY); + return (rc ? FILTER_SCHEDULE_THREAD : FILTER_STRAY); +} + +static void +vtpci_vq_shared_intr(void *xsc) +{ + struct vtpci_softc *sc; + struct vtpci_virtqueue *vqx; + int i; + + sc = xsc; + vqx = &sc->vtpci_vqs[0]; + + for (i = 0; i < sc->vtpci_nvqs; i++, vqx++) { + if (vqx->vtv_no_intr == 0) + virtqueue_intr(vqx->vtv_vq); + } } static int -vtpci_vq_intr(void *xvq) +vtpci_vq_intr_filter(void *xvq) { struct virtqueue *vq; int rc; vq = xvq; - rc = virtqueue_intr(vq); + rc = virtqueue_intr_filter(vq); - return (rc ? FILTER_HANDLED : FILTER_STRAY); + return (rc ? FILTER_SCHEDULE_THREAD : FILTER_STRAY); } -static int +static void +vtpci_vq_intr(void *xvq) +{ + struct virtqueue *vq; + + vq = xvq; + virtqueue_intr(vq); +} + +static void vtpci_config_intr(void *xsc) { struct vtpci_softc *sc; device_t child; - int rc; - rc = 0; sc = xsc; child = sc->vtpci_child_dev; if (child != NULL) - rc = VIRTIO_CONFIG_CHANGE(child); - - return (rc ? FILTER_HANDLED : FILTER_STRAY); + VIRTIO_CONFIG_CHANGE(child); } diff --git a/sys/dev/virtio/scsi/virtio_scsi.c b/sys/dev/virtio/scsi/virtio_scsi.c index 52f1581..e5f922b 100644 --- a/sys/dev/virtio/scsi/virtio_scsi.c +++ b/sys/dev/virtio/scsi/virtio_scsi.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2012, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2012, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -40,7 +40,6 @@ __FBSDID("$FreeBSD$"); #include <sys/lock.h> #include <sys/mutex.h> #include <sys/callout.h> -#include <sys/taskqueue.h> #include <sys/queue.h> #include <sys/sbuf.h> @@ -172,13 +171,10 @@ static struct vtscsi_request * vtscsi_dequeue_request(struct vtscsi_softc *); static void vtscsi_complete_request(struct vtscsi_request *); static void vtscsi_complete_vq(struct vtscsi_softc *, struct virtqueue *); -static void vtscsi_control_vq_task(void *, int); -static void vtscsi_event_vq_task(void *, int); -static void vtscsi_request_vq_task(void *, int); -static int vtscsi_control_vq_intr(void *); -static int vtscsi_event_vq_intr(void *); -static int vtscsi_request_vq_intr(void *); +static void vtscsi_control_vq_intr(void *); +static void vtscsi_event_vq_intr(void *); +static void vtscsi_request_vq_intr(void *); static void vtscsi_disable_vqs_intr(struct vtscsi_softc *); static void vtscsi_enable_vqs_intr(struct vtscsi_softc *); @@ -333,30 +329,12 @@ vtscsi_attach(device_t dev) goto fail; } - TASK_INIT(&sc->vtscsi_control_intr_task, 0, - vtscsi_control_vq_task, sc); - TASK_INIT(&sc->vtscsi_event_intr_task, 0, - vtscsi_event_vq_task, sc); - TASK_INIT(&sc->vtscsi_request_intr_task, 0, - vtscsi_request_vq_task, sc); - - sc->vtscsi_tq = taskqueue_create_fast("vtscsi_taskq", M_NOWAIT, - taskqueue_thread_enqueue, &sc->vtscsi_tq); - if (sc->vtscsi_tq == NULL) { - error = ENOMEM; - device_printf(dev, "cannot allocate taskqueue\n"); - goto fail; - } - error = virtio_setup_intr(dev, INTR_TYPE_CAM); if (error) { device_printf(dev, "cannot setup virtqueue interrupts\n"); goto fail; } - taskqueue_start_threads(&sc->vtscsi_tq, 1, PI_DISK, "%s taskq", - device_get_nameunit(dev)); - vtscsi_enable_vqs_intr(sc); /* @@ -389,14 +367,6 @@ vtscsi_detach(device_t dev) vtscsi_stop(sc); VTSCSI_UNLOCK(sc); - if (sc->vtscsi_tq != NULL) { - taskqueue_drain(sc->vtscsi_tq, &sc->vtscsi_control_intr_task); - taskqueue_drain(sc->vtscsi_tq, &sc->vtscsi_event_intr_task); - taskqueue_drain(sc->vtscsi_tq, &sc->vtscsi_request_intr_task); - taskqueue_free(sc->vtscsi_tq); - sc->vtscsi_tq = NULL; - } - vtscsi_complete_vqs(sc); vtscsi_drain_vqs(sc); @@ -572,19 +542,14 @@ vtscsi_register_cam(struct vtscsi_softc *sc) goto fail; } - VTSCSI_UNLOCK(sc); - - /* - * The async register apparently needs to be done without - * the lock held, otherwise it can recurse on the lock. - */ if (vtscsi_register_async(sc) != CAM_REQ_CMP) { error = EIO; device_printf(dev, "cannot register async callback\n"); - VTSCSI_LOCK(sc); goto fail; } + VTSCSI_UNLOCK(sc); + return (0); fail: @@ -652,8 +617,6 @@ vtscsi_register_async(struct vtscsi_softc *sc) { struct ccb_setasync csa; - VTSCSI_LOCK_NOTOWNED(sc); - xpt_setup_ccb(&csa.ccb_h, sc->vtscsi_path, 5); csa.ccb_h.func_code = XPT_SASYNC_CB; csa.event_enable = AC_LOST_DEVICE | AC_FOUND_DEVICE; @@ -1268,7 +1231,7 @@ vtscsi_scsi_cmd_cam_status(struct virtio_scsi_cmd_resp *cmd_resp) status = CAM_REQ_ABORTED; break; case VIRTIO_SCSI_S_BAD_TARGET: - status = CAM_TID_INVALID; + status = CAM_SEL_TIMEOUT; break; case VIRTIO_SCSI_S_RESET: status = CAM_SCSI_BUS_RESET; @@ -2152,14 +2115,15 @@ vtscsi_complete_vq(struct vtscsi_softc *sc, struct virtqueue *vq) } static void -vtscsi_control_vq_task(void *arg, int pending) +vtscsi_control_vq_intr(void *xsc) { struct vtscsi_softc *sc; struct virtqueue *vq; - sc = arg; + sc = xsc; vq = sc->vtscsi_control_vq; +again: VTSCSI_LOCK(sc); vtscsi_complete_vq(sc, sc->vtscsi_control_vq); @@ -2167,24 +2131,23 @@ vtscsi_control_vq_task(void *arg, int pending) if (virtqueue_enable_intr(vq) != 0) { virtqueue_disable_intr(vq); VTSCSI_UNLOCK(sc); - taskqueue_enqueue_fast(sc->vtscsi_tq, - &sc->vtscsi_control_intr_task); - return; + goto again; } VTSCSI_UNLOCK(sc); } static void -vtscsi_event_vq_task(void *arg, int pending) +vtscsi_event_vq_intr(void *xsc) { struct vtscsi_softc *sc; struct virtqueue *vq; struct virtio_scsi_event *event; - sc = arg; + sc = xsc; vq = sc->vtscsi_event_vq; +again: VTSCSI_LOCK(sc); while ((event = virtqueue_dequeue(vq, NULL)) != NULL) @@ -2193,23 +2156,22 @@ vtscsi_event_vq_task(void *arg, int pending) if (virtqueue_enable_intr(vq) != 0) { virtqueue_disable_intr(vq); VTSCSI_UNLOCK(sc); - taskqueue_enqueue_fast(sc->vtscsi_tq, - &sc->vtscsi_control_intr_task); - return; + goto again; } VTSCSI_UNLOCK(sc); } static void -vtscsi_request_vq_task(void *arg, int pending) +vtscsi_request_vq_intr(void *xsc) { struct vtscsi_softc *sc; struct virtqueue *vq; - sc = arg; + sc = xsc; vq = sc->vtscsi_request_vq; +again: VTSCSI_LOCK(sc); vtscsi_complete_vq(sc, sc->vtscsi_request_vq); @@ -2217,56 +2179,12 @@ vtscsi_request_vq_task(void *arg, int pending) if (virtqueue_enable_intr(vq) != 0) { virtqueue_disable_intr(vq); VTSCSI_UNLOCK(sc); - taskqueue_enqueue_fast(sc->vtscsi_tq, - &sc->vtscsi_request_intr_task); - return; + goto again; } VTSCSI_UNLOCK(sc); } -static int -vtscsi_control_vq_intr(void *xsc) -{ - struct vtscsi_softc *sc; - - sc = xsc; - - virtqueue_disable_intr(sc->vtscsi_control_vq); - taskqueue_enqueue_fast(sc->vtscsi_tq, - &sc->vtscsi_control_intr_task); - - return (1); -} - -static int -vtscsi_event_vq_intr(void *xsc) -{ - struct vtscsi_softc *sc; - - sc = xsc; - - virtqueue_disable_intr(sc->vtscsi_event_vq); - taskqueue_enqueue_fast(sc->vtscsi_tq, - &sc->vtscsi_event_intr_task); - - return (1); -} - -static int -vtscsi_request_vq_intr(void *xsc) -{ - struct vtscsi_softc *sc; - - sc = xsc; - - virtqueue_disable_intr(sc->vtscsi_request_vq); - taskqueue_enqueue_fast(sc->vtscsi_tq, - &sc->vtscsi_request_intr_task); - - return (1); -} - static void vtscsi_disable_vqs_intr(struct vtscsi_softc *sc) { diff --git a/sys/dev/virtio/scsi/virtio_scsivar.h b/sys/dev/virtio/scsi/virtio_scsivar.h index 7afe32f..f30f667 100644 --- a/sys/dev/virtio/scsi/virtio_scsivar.h +++ b/sys/dev/virtio/scsi/virtio_scsivar.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2012, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2012, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -62,11 +62,6 @@ struct vtscsi_softc { struct virtqueue *vtscsi_event_vq; struct virtqueue *vtscsi_request_vq; - struct taskqueue *vtscsi_tq; - struct task vtscsi_control_intr_task; - struct task vtscsi_event_intr_task; - struct task vtscsi_request_intr_task; - struct cam_sim *vtscsi_sim; struct cam_path *vtscsi_path; diff --git a/sys/dev/virtio/virtio.c b/sys/dev/virtio/virtio.c index 6c6b0bc..ea2b91a 100644 --- a/sys/dev/virtio/virtio.c +++ b/sys/dev/virtio/virtio.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -36,7 +36,6 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <machine/resource.h> -#include <machine/_inttypes.h> #include <sys/bus.h> #include <sys/rman.h> @@ -49,8 +48,8 @@ static int virtio_modevent(module_t, int, void *); static const char *virtio_feature_name(uint64_t, struct virtio_feature_desc *); static struct virtio_ident { - uint16_t devid; - char *name; + uint16_t devid; + const char *name; } virtio_ident_table[] = { { VIRTIO_ID_NETWORK, "Network" }, { VIRTIO_ID_BLOCK, "Block" }, @@ -87,9 +86,29 @@ virtio_device_name(uint16_t devid) return (NULL); } +static const char * +virtio_feature_name(uint64_t val, struct virtio_feature_desc *desc) +{ + int i, j; + struct virtio_feature_desc *descs[2] = { desc, + virtio_common_feature_desc }; + + for (i = 0; i < 2; i++) { + if (descs[i] == NULL) + continue; + + for (j = 0; descs[i][j].vfd_val != 0; j++) { + if (val == descs[i][j].vfd_val) + return (descs[i][j].vfd_str); + } + } + + return (NULL); +} + void virtio_describe(device_t dev, const char *msg, - uint64_t features, struct virtio_feature_desc *feature_desc) + uint64_t features, struct virtio_feature_desc *desc) { struct sbuf sb; uint64_t val; @@ -98,13 +117,12 @@ virtio_describe(device_t dev, const char *msg, int n; if ((buf = malloc(512, M_TEMP, M_NOWAIT)) == NULL) { - device_printf(dev, "%s features: 0x%"PRIx64"\n", msg, - features); + device_printf(dev, "%s features: %#jx\n", msg, (uintmax_t) features); return; } sbuf_new(&sb, buf, 512, SBUF_FIXEDLEN); - sbuf_printf(&sb, "%s features: 0x%"PRIx64, msg, features); + sbuf_printf(&sb, "%s features: %#jx", msg, (uintmax_t) features); for (n = 0, val = 1ULL << 63; val != 0; val >>= 1) { /* @@ -119,15 +137,9 @@ virtio_describe(device_t dev, const char *msg, else sbuf_cat(&sb, ","); - name = NULL; - if (feature_desc != NULL) - name = virtio_feature_name(val, feature_desc); + name = virtio_feature_name(val, desc); if (name == NULL) - name = virtio_feature_name(val, - virtio_common_feature_desc); - - if (name == NULL) - sbuf_printf(&sb, "0x%"PRIx64, val); + sbuf_printf(&sb, "%#jx", (uintmax_t) val); else sbuf_cat(&sb, name); } @@ -147,18 +159,6 @@ virtio_describe(device_t dev, const char *msg, free(buf, M_TEMP); } -static const char * -virtio_feature_name(uint64_t val, struct virtio_feature_desc *feature_desc) -{ - int i; - - for (i = 0; feature_desc[i].vfd_val != 0; i++) - if (val == feature_desc[i].vfd_val) - return (feature_desc[i].vfd_str); - - return (NULL); -} - /* * VirtIO bus method wrappers. */ @@ -251,13 +251,12 @@ virtio_modevent(module_t mod, int type, void *unused) { int error; - error = 0; - switch (type) { case MOD_LOAD: case MOD_QUIESCE: case MOD_UNLOAD: case MOD_SHUTDOWN: + error = 0; break; default: error = EOPNOTSUPP; diff --git a/sys/dev/virtio/virtio.h b/sys/dev/virtio/virtio.h index 4d069dd..b1334f8 100644 --- a/sys/dev/virtio/virtio.h +++ b/sys/dev/virtio/virtio.h @@ -71,11 +71,6 @@ struct vq_alloc_info; #define VIRTIO_TRANSPORT_F_END 32 /* - * Maximum number of virtqueues per device. - */ -#define VIRTIO_MAX_VIRTQUEUES 8 - -/* * Each virtqueue indirect descriptor list must be physically contiguous. * To allow us to malloc(9) each list individually, limit the number * supported to what will fit in one page. With 4KB pages, this is a limit @@ -99,7 +94,7 @@ struct vq_alloc_info; struct virtio_feature_desc { uint64_t vfd_val; - char *vfd_str; + const char *vfd_str; }; const char *virtio_device_name(uint16_t devid); diff --git a/sys/dev/virtio/virtio_bus_if.m b/sys/dev/virtio/virtio_bus_if.m index ec2029d..74341ff 100644 --- a/sys/dev/virtio/virtio_bus_if.m +++ b/sys/dev/virtio/virtio_bus_if.m @@ -1,5 +1,5 @@ #- -# Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> +# Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> # All rights reserved. # # Redistribution and use in source and binary forms, with or without @@ -50,9 +50,6 @@ METHOD int alloc_virtqueues { int nvqs; struct vq_alloc_info *info; }; -HEADER { -#define VIRTIO_ALLOC_VQS_DISABLE_MSIX 0x1 -}; METHOD int setup_intr { device_t dev; diff --git a/sys/dev/virtio/virtio_if.m b/sys/dev/virtio/virtio_if.m index 701678c..9a99d37 100644 --- a/sys/dev/virtio/virtio_if.m +++ b/sys/dev/virtio/virtio_if.m @@ -1,5 +1,5 @@ #- -# Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> +# Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> # All rights reserved. # # Redistribution and use in source and binary forms, with or without @@ -33,8 +33,7 @@ CODE { static int virtio_default_config_change(device_t dev) { - /* Return that we've handled the change. */ - return (1); + return (0); } }; diff --git a/sys/dev/virtio/virtqueue.c b/sys/dev/virtio/virtqueue.c index 1553afa..a82426e 100644 --- a/sys/dev/virtio/virtqueue.c +++ b/sys/dev/virtio/virtqueue.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -414,18 +414,24 @@ virtqueue_nused(struct virtqueue *vq) } int -virtqueue_intr(struct virtqueue *vq) +virtqueue_intr_filter(struct virtqueue *vq) { - if (vq->vq_intrhand == NULL || - vq->vq_used_cons_idx == vq->vq_ring.used->idx) + if (vq->vq_used_cons_idx == vq->vq_ring.used->idx) return (0); - vq->vq_intrhand(vq->vq_intrhand_arg); + virtqueue_disable_intr(vq); return (1); } +void +virtqueue_intr(struct virtqueue *vq) +{ + + vq->vq_intrhand(vq->vq_intrhand_arg); +} + int virtqueue_enable_intr(struct virtqueue *vq) { diff --git a/sys/dev/virtio/virtqueue.h b/sys/dev/virtio/virtqueue.h index 0296b8c..128a10a 100644 --- a/sys/dev/virtio/virtqueue.h +++ b/sys/dev/virtio/virtqueue.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org> + * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -39,7 +39,7 @@ struct sglist; #define VIRTIO_RING_F_EVENT_IDX (1 << 29) /* Device callback for a virtqueue interrupt. */ -typedef int virtqueue_intr_t(void *); +typedef void virtqueue_intr_t(void *); #define VIRTQUEUE_MAX_NAME_SZ 32 @@ -70,7 +70,8 @@ void *virtqueue_drain(struct virtqueue *vq, int *last); void virtqueue_free(struct virtqueue *vq); int virtqueue_reinit(struct virtqueue *vq, uint16_t size); -int virtqueue_intr(struct virtqueue *vq); +int virtqueue_intr_filter(struct virtqueue *vq); +void virtqueue_intr(struct virtqueue *vq); int virtqueue_enable_intr(struct virtqueue *vq); int virtqueue_postpone_intr(struct virtqueue *vq); void virtqueue_disable_intr(struct virtqueue *vq); diff --git a/sys/fs/ext2fs/ext2_lookup.c b/sys/fs/ext2fs/ext2_lookup.c index 75b11a8..623260d 100644 --- a/sys/fs/ext2fs/ext2_lookup.c +++ b/sys/fs/ext2fs/ext2_lookup.c @@ -289,9 +289,9 @@ ext2_lookup_ino(struct vnode *vdp, struct vnode **vpp, struct componentname *cnp int entryoffsetinblock; /* offset of ep in bp's buffer */ enum {NONE, COMPACT, FOUND} slotstatus; doff_t slotoffset; /* offset of area with free space */ - int slotsize; /* size of area at slotoffset */ doff_t i_diroff; /* cached i_diroff value */ doff_t i_offset; /* cached i_offset value */ + int slotsize; /* size of area at slotoffset */ int slotfreespace; /* amount of space free in slot */ int slotneeded; /* size of the entry we're seeking */ int numdirpasses; /* strategy for directory search */ @@ -476,7 +476,6 @@ searchloop: endsearch = i_diroff; goto searchloop; } - dp->i_offset = i_offset; if (bp != NULL) brelse(bp); /* @@ -512,7 +511,6 @@ searchloop: enduseful = slotoffset + slotsize; } dp->i_endoff = roundup2(enduseful, DIRBLKSIZ); - dp->i_flag |= IN_CHANGE | IN_UPDATE; /* * We return with the directory locked, so that * the parameters we set up above will still be @@ -560,12 +558,13 @@ found: */ if ((flags & ISLASTCN) && nameiop == LOOKUP) dp->i_diroff = i_offset &~ (DIRBLKSIZ - 1); - dp->i_offset = i_offset; /* * If deleting, and at end of pathname, return * parameters which can be used to remove file. */ if (nameiop == DELETE && (flags & ISLASTCN)) { + if (flags & LOCKPARENT) + ASSERT_VOP_ELOCKED(vdp, __FUNCTION__); /* * Write access to directory required to delete files. */ @@ -576,7 +575,13 @@ found: * and distance past previous entry (if there * is a previous entry in this block) in dp->i_count. * Save directory inode pointer in ndp->ni_dvp for dirremove(). + * + * Technically we shouldn't be setting these in the + * WANTPARENT case (first lookup in rename()), but any + * lookups that will result in directory changes will + * overwrite these. */ + dp->i_offset = i_offset; if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0) dp->i_count = 0; else @@ -621,6 +626,7 @@ found: * Careful about locking second inode. * This can only occur if the target is ".". */ + dp->i_offset = i_offset; if (dp->i_number == ino) return (EISDIR); if (dd_ino != NULL) @@ -656,10 +662,7 @@ found: */ pdp = vdp; if (flags & ISDOTDOT) { - ltype = VOP_ISLOCKED(pdp); - VOP_UNLOCK(pdp, 0); /* race to get the inode */ - error = VFS_VGET(vdp->v_mount, ino, cnp->cn_lkflags, &tdp); - vn_lock(pdp, ltype | LK_RETRY); + error = vn_vget_ino(pdp, ino, cnp->cn_lkflags, &tdp); if (pdp->v_iflag & VI_DOOMED) { if (error == 0) vput(tdp); diff --git a/sys/fs/ext2fs/ext2_vfsops.c b/sys/fs/ext2fs/ext2_vfsops.c index 54d1e89..9e6ce1a 100644 --- a/sys/fs/ext2fs/ext2_vfsops.c +++ b/sys/fs/ext2fs/ext2_vfsops.c @@ -979,7 +979,7 @@ ext2_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp) * already have one. This should only happen on old filesystems. */ if (ip->i_gen == 0) { - ip->i_gen = random() / 2 + 1; + ip->i_gen = random() + 1; if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) ip->i_flag |= IN_MODIFIED; } diff --git a/sys/fs/nfsclient/nfs_clport.c b/sys/fs/nfsclient/nfs_clport.c index b2ed50a..d7b082b 100644 --- a/sys/fs/nfsclient/nfs_clport.c +++ b/sys/fs/nfsclient/nfs_clport.c @@ -433,6 +433,7 @@ nfscl_loadattrcache(struct vnode **vpp, struct nfsvattr *nap, void *nvaper, vap->va_size = np->n_size; np->n_attrstamp = 0; KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp); + vnode_pager_setsize(vp, np->n_size); } else if (np->n_flag & NMODIFIED) { /* * We've modified the file: Use the larger @@ -444,12 +445,22 @@ nfscl_loadattrcache(struct vnode **vpp, struct nfsvattr *nap, void *nvaper, np->n_size = vap->va_size; np->n_flag |= NSIZECHANGED; } + vnode_pager_setsize(vp, np->n_size); + } else if (vap->va_size < np->n_size) { + /* + * When shrinking the size, the call to + * vnode_pager_setsize() cannot be done + * with the mutex held, so delay it until + * after the mtx_unlock call. + */ + nsize = np->n_size = vap->va_size; + np->n_flag |= NSIZECHANGED; + setnsize = 1; } else { np->n_size = vap->va_size; np->n_flag |= NSIZECHANGED; + vnode_pager_setsize(vp, np->n_size); } - setnsize = 1; - nsize = vap->va_size; } else { np->n_size = vap->va_size; } diff --git a/sys/fs/nullfs/null_vnops.c b/sys/fs/nullfs/null_vnops.c index 6ff15ee..70402e3 100644 --- a/sys/fs/nullfs/null_vnops.c +++ b/sys/fs/nullfs/null_vnops.c @@ -554,6 +554,7 @@ null_rename(struct vop_rename_args *ap) struct vnode *fvp = ap->a_fvp; struct vnode *fdvp = ap->a_fdvp; struct vnode *tvp = ap->a_tvp; + struct null_node *tnn; /* Check for cross-device rename. */ if ((fvp->v_mount != tdvp->v_mount) || @@ -568,7 +569,11 @@ null_rename(struct vop_rename_args *ap) vrele(fvp); return (EXDEV); } - + + if (tvp != NULL) { + tnn = VTONULL(tvp); + tnn->null_flags |= NULLV_DROP; + } return (null_bypass((struct vop_generic_args *)ap)); } diff --git a/sys/fs/smbfs/smbfs_node.c b/sys/fs/smbfs/smbfs_node.c index 481fa1d..1b55ff3 100644 --- a/sys/fs/smbfs/smbfs_node.c +++ b/sys/fs/smbfs/smbfs_node.c @@ -89,7 +89,7 @@ smbfs_vnode_cmp(struct vnode *vp, void *_sc) struct smbnode *np; struct smbcmp *sc; - np = (struct smbnode *) vp; + np = (struct smbnode *) vp->v_data; sc = (struct smbcmp *) _sc; if (np->n_parent != sc->n_parent || np->n_nmlen != sc->n_nmlen || bcmp(sc->n_name, np->n_name, sc->n_nmlen) != 0) diff --git a/sys/fs/smbfs/smbfs_smb.c b/sys/fs/smbfs/smbfs_smb.c index ec4a49d..0e10e5e 100644 --- a/sys/fs/smbfs/smbfs_smb.c +++ b/sys/fs/smbfs/smbfs_smb.c @@ -94,12 +94,10 @@ smbfs_smb_lockandx(struct smbnode *np, int op, u_int32_t pid, off_t start, off_t if (op == SMB_LOCK_SHARED) ltype |= SMB_LOCKING_ANDX_SHARED_LOCK; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_LOCKING_ANDX, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_LOCKING_ANDX, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_uint8(mbp, 0xff); /* secondary command */ @@ -119,7 +117,6 @@ smbfs_smb_lockandx(struct smbnode *np, int op, u_int32_t pid, off_t start, off_t smb_rq_bend(rqp); error = smb_rq_simple(rqp); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -188,19 +185,16 @@ smbfs_smb_statfs(struct smb_share *ssp, struct statfs *sbp, u_int16_t units, bpu, bsize, funits; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION_DISK, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_QUERY_INFORMATION_DISK, + scred, &rqp); + if (error) + return (error); smb_rq_wstart(rqp); smb_rq_wend(rqp); smb_rq_bstart(rqp); smb_rq_bend(rqp); error = smb_rq_simple(rqp); if (error) { - free(rqp, M_SMBFSDATA); smb_rq_done(rqp); return error; } @@ -216,7 +210,6 @@ smbfs_smb_statfs(struct smb_share *ssp, struct statfs *sbp, sbp->f_files = 0xffff; /* total file nodes in filesystem */ sbp->f_ffree = 0xffff; /* free file nodes in fs */ smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return 0; } @@ -260,12 +253,9 @@ smb_smb_flush(struct smbnode *np, struct smb_cred *scred) if ((np->n_flag & NOPEN) == 0 || !SMBTOV(np) || SMBTOV(np)->v_type != VREG) return 0; /* not a regular open file */ - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_FLUSH, scred); - if (error) { - free(rqp, M_SMBFSDATA); + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_FLUSH, scred, &rqp); + if (error) return (error); - } smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM); @@ -274,7 +264,6 @@ smb_smb_flush(struct smbnode *np, struct smb_cred *scred) smb_rq_bend(rqp); error = smb_rq_simple(rqp); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); if (!error) np->n_flag &= ~NFLUSHWIRE; return (error); @@ -301,12 +290,9 @@ smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred) return (0); } - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_WRITE, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM); @@ -320,7 +306,6 @@ smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred) smb_rq_bend(rqp); error = smb_rq_simple(rqp); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -337,12 +322,10 @@ smbfs_smb_query_info(struct smbnode *np, const char *name, int len, u_int16_t wattr; u_int32_t lint; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_QUERY_INFORMATION, scred, + &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); smb_rq_wend(rqp); @@ -377,7 +360,6 @@ smbfs_smb_query_info(struct smbnode *np, const char *name, int len, fap->fa_size = lint; } while(0); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -394,12 +376,10 @@ smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime, u_long time; int error, svtz; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred, + &rqp); + if (error) + return (error); svtz = SSTOVC(ssp)->vc_sopt.sv_tz; smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); @@ -431,7 +411,6 @@ smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime, } } while(0); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -554,12 +533,10 @@ smbfs_smb_setftime(struct smbnode *np, struct timespec *mtime, u_int16_t date, time; int error, tzoff; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION2, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_SET_INFORMATION2, scred, + &rqp); + if (error) + return (error); tzoff = SSTOVC(ssp)->vc_sopt.sv_tz; smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); @@ -584,7 +561,6 @@ smbfs_smb_setftime(struct smbnode *np, struct timespec *mtime, error = smb_rq_simple(rqp); SMBSDEBUG("%d\n", error); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -648,12 +624,9 @@ smbfs_smb_open(struct smbnode *np, int accmode, struct smb_cred *scred) u_int16_t fid, wattr, grantedmode; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_OPEN, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_OPEN, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_uint16le(mbp, accmode); @@ -684,7 +657,6 @@ smbfs_smb_open(struct smbnode *np, int accmode, struct smb_cred *scred) */ } while(0); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); if (error) return error; np->n_fid = fid; @@ -702,12 +674,9 @@ smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime, u_long time; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CLOSE, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CLOSE, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM); @@ -721,7 +690,6 @@ smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime, smb_rq_bend(rqp); error = smb_rq_simple(rqp); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -739,12 +707,9 @@ smbfs_smb_create(struct smbnode *dnp, const char *name, int nmlen, u_long tm; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CREATE, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_uint16le(mbp, SMB_FA_ARCHIVE); /* attributes */ @@ -771,7 +736,6 @@ smbfs_smb_create(struct smbnode *dnp, const char *name, int nmlen, if (error) return error; smbfs_smb_close(ssp, fid, &ctime, scred); - free(rqp, M_SMBFSDATA); return error; } @@ -783,12 +747,9 @@ smbfs_smb_delete(struct smbnode *np, struct smb_cred *scred) struct mbchain *mbp; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_DELETE, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN); @@ -801,7 +762,6 @@ smbfs_smb_delete(struct smbnode *np, struct smb_cred *scred) error = smb_rq_simple(rqp); } smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -814,12 +774,9 @@ smbfs_smb_rename(struct smbnode *src, struct smbnode *tdnp, struct mbchain *mbp; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_RENAME, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_RENAME, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN); @@ -838,7 +795,6 @@ smbfs_smb_rename(struct smbnode *src, struct smbnode *tdnp, error = smb_rq_simple(rqp); } while(0); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -851,12 +807,9 @@ smbfs_smb_move(struct smbnode *src, struct smbnode *tdnp, struct mbchain *mbp; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_MOVE, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_MOVE, scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_uint16le(mbp, SMB_TID_UNKNOWN); @@ -877,7 +830,6 @@ smbfs_smb_move(struct smbnode *src, struct smbnode *tdnp, error = smb_rq_simple(rqp); } while(0); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -890,12 +842,10 @@ smbfs_smb_mkdir(struct smbnode *dnp, const char *name, int len, struct mbchain *mbp; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE_DIRECTORY, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CREATE_DIRECTORY, scred, + &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); smb_rq_wend(rqp); @@ -907,7 +857,6 @@ smbfs_smb_mkdir(struct smbnode *dnp, const char *name, int len, error = smb_rq_simple(rqp); } smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -919,12 +868,10 @@ smbfs_smb_rmdir(struct smbnode *np, struct smb_cred *scred) struct mbchain *mbp; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE_DIRECTORY, scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_DELETE_DIRECTORY, scred, + &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); smb_rq_wend(rqp); @@ -936,7 +883,6 @@ smbfs_smb_rmdir(struct smbnode *np, struct smb_cred *scred) error = smb_rq_simple(rqp); } smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } @@ -958,7 +904,7 @@ smbfs_smb_search(struct smbfs_fctx *ctx) } error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_SEARCH, ctx->f_scred, &rqp); if (error) - return error; + return (error); ctx->f_rq = rqp; smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); @@ -1204,12 +1150,10 @@ smbfs_smb_findclose2(struct smbfs_fctx *ctx) struct mbchain *mbp; int error; - rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK); - error = smb_rq_init(rqp, SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2, ctx->f_scred); - if (error) { - free(rqp, M_SMBFSDATA); - return error; - } + error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2, + ctx->f_scred, &rqp); + if (error) + return (error); smb_rq_getrequest(rqp, &mbp); smb_rq_wstart(rqp); mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM); @@ -1218,7 +1162,6 @@ smbfs_smb_findclose2(struct smbfs_fctx *ctx) smb_rq_bend(rqp); error = smb_rq_simple(rqp); smb_rq_done(rqp); - free(rqp, M_SMBFSDATA); return error; } diff --git a/sys/fs/smbfs/smbfs_vfsops.c b/sys/fs/smbfs/smbfs_vfsops.c index 66512e9..2d33df3 100644 --- a/sys/fs/smbfs/smbfs_vfsops.c +++ b/sys/fs/smbfs/smbfs_vfsops.c @@ -324,11 +324,6 @@ smbfs_root(struct mount *mp, int flags, struct vnode **vpp) td = curthread; cred = td->td_ucred; - if (smp == NULL) { - SMBERROR("smp == NULL (bug in umount)\n"); - vfs_mount_error(mp, "smp == NULL (bug in umount)"); - return EINVAL; - } if (smp->sm_root) { *vpp = SMBTOV(smp->sm_root); return vget(*vpp, LK_EXCLUSIVE | LK_RETRY, td); diff --git a/sys/fs/smbfs/smbfs_vnops.c b/sys/fs/smbfs/smbfs_vnops.c index 6ceed9c..ef1dc65 100644 --- a/sys/fs/smbfs/smbfs_vnops.c +++ b/sys/fs/smbfs/smbfs_vnops.c @@ -1282,11 +1282,14 @@ smbfs_lookup(ap) error = vfs_busy(mp, 0); vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); vfs_rel(mp); - if (error) - return (ENOENT); + if (error) { + error = ENOENT; + goto out; + } if ((dvp->v_iflag & VI_DOOMED) != 0) { vfs_unbusy(mp); - return (ENOENT); + error = ENOENT; + goto out; } } VOP_UNLOCK(dvp, 0); diff --git a/sys/geom/geom_disk.c b/sys/geom/geom_disk.c index a9f7048..60cff73 100644 --- a/sys/geom/geom_disk.c +++ b/sys/geom/geom_disk.c @@ -148,14 +148,12 @@ g_disk_access(struct g_provider *pp, int r, int w, int e) dp->d_name, dp->d_unit); dp->d_maxsize = DFLTPHYS; } - if (dp->d_flags & DISKFLAG_CANDELETE) { - if (bootverbose && dp->d_delmaxsize == 0) { - printf("WARNING: Disk drive %s%d has no d_delmaxsize\n", - dp->d_name, dp->d_unit); - dp->d_delmaxsize = dp->d_maxsize; + if (dp->d_delmaxsize == 0) { + if (bootverbose && dp->d_flags & DISKFLAG_CANDELETE) { + printf("WARNING: Disk drive %s%d has no " + "d_delmaxsize\n", dp->d_name, dp->d_unit); } - } else { - dp->d_delmaxsize = 0; + dp->d_delmaxsize = dp->d_maxsize; } pp->stripeoffset = dp->d_stripeoffset; pp->stripesize = dp->d_stripesize; @@ -629,7 +627,7 @@ void disk_create(struct disk *dp, int version) { - if (version != DISK_VERSION_02) { + if (version != DISK_VERSION) { printf("WARNING: Attempt to add disk %s%d %s", dp->d_name, dp->d_unit, " using incompatible ABI version of disk(9)\n"); diff --git a/sys/geom/geom_disk.h b/sys/geom/geom_disk.h index 05c5de3..852047b 100644 --- a/sys/geom/geom_disk.h +++ b/sys/geom/geom_disk.h @@ -120,7 +120,8 @@ int disk_resize(struct disk *dp, int flag); #define DISK_VERSION_00 0x58561059 #define DISK_VERSION_01 0x5856105a #define DISK_VERSION_02 0x5856105b -#define DISK_VERSION DISK_VERSION_02 +#define DISK_VERSION_03 0x5856105c +#define DISK_VERSION DISK_VERSION_03 #endif /* _KERNEL */ #endif /* _GEOM_GEOM_DISK_H_ */ diff --git a/sys/geom/geom_io.c b/sys/geom/geom_io.c index 25a90de..0e79920 100644 --- a/sys/geom/geom_io.c +++ b/sys/geom/geom_io.c @@ -49,6 +49,7 @@ __FBSDID("$FreeBSD$"); #include <sys/proc.h> #include <sys/stack.h> #include <sys/sysctl.h> +#include <sys/vmem.h> #include <sys/errno.h> #include <geom/geom.h> @@ -626,7 +627,6 @@ g_io_transient_map_bio(struct bio *bp) vm_offset_t addr; long size; u_int retried; - int rv; KASSERT(unmapped_buf_allowed, ("unmapped disabled")); @@ -636,10 +636,7 @@ g_io_transient_map_bio(struct bio *bp) retried = 0; atomic_add_long(&transient_maps, 1); retry: - vm_map_lock(bio_transient_map); - if (vm_map_findspace(bio_transient_map, vm_map_min(bio_transient_map), - size, &addr)) { - vm_map_unlock(bio_transient_map); + if (vmem_alloc(transient_arena, size, M_BESTFIT | M_NOWAIT, &addr)) { if (transient_map_retries != 0 && retried >= transient_map_retries) { g_io_deliver(bp, EDEADLK/* XXXKIB */); @@ -651,7 +648,7 @@ retry: /* * Naive attempt to quisce the I/O to get more * in-flight requests completed and defragment - * the bio_transient_map. + * the transient_arena. */ CTR3(KTR_GEOM, "g_down retrymap bp %p provider %s r %d", bp, bp->bio_to->name, retried); @@ -661,12 +658,6 @@ retry: goto retry; } } - rv = vm_map_insert(bio_transient_map, NULL, 0, addr, addr + size, - VM_PROT_RW, VM_PROT_RW, MAP_NOFAULT); - KASSERT(rv == KERN_SUCCESS, - ("vm_map_insert(bio_transient_map) rv %d %jx %lx", - rv, (uintmax_t)addr, size)); - vm_map_unlock(bio_transient_map); atomic_add_int(&inflight_transient_maps, 1); pmap_qenter((vm_offset_t)addr, bp->bio_ma, OFF_TO_IDX(size)); bp->bio_data = (caddr_t)addr + bp->bio_ma_offset; diff --git a/sys/i386/include/counter.h b/sys/i386/include/counter.h index 3e93b36..01b09bb 100644 --- a/sys/i386/include/counter.h +++ b/sys/i386/include/counter.h @@ -67,6 +67,93 @@ counter_64_inc_8b(uint64_t *p, int64_t inc) : "memory", "cc", "eax", "edx", "ebx", "ecx"); } +#ifdef IN_SUBR_COUNTER_C +static inline uint64_t +counter_u64_read_one_8b(uint64_t *p) +{ + uint32_t res_lo, res_high; + + __asm __volatile( + "movl %%eax,%%ebx\n\t" + "movl %%edx,%%ecx\n\t" + "cmpxchg8b (%2)" + : "=a" (res_lo), "=d"(res_high) + : "SD" (p) + : "cc", "ebx", "ecx"); + return (res_lo + ((uint64_t)res_high << 32)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t res; + int i; + + res = 0; + if ((cpu_feature & CPUID_CX8) == 0) { + /* + * The machines without cmpxchg8b are not SMP. + * Disabling the preemption provides atomicity of the + * counter reading, since update is done in the + * critical section as well. + */ + critical_enter(); + for (i = 0; i < mp_ncpus; i++) { + res += *(uint64_t *)((char *)p + + sizeof(struct pcpu) * i); + } + critical_exit(); + } else { + for (i = 0; i < mp_ncpus; i++) + res += counter_u64_read_one_8b((uint64_t *)((char *)p + + sizeof(struct pcpu) * i)); + } + return (res); +} + +static inline void +counter_u64_zero_one_8b(uint64_t *p) +{ + + __asm __volatile( + "movl (%0),%%eax\n\t" + "movl 4(%0),%%edx\n" + "xorl %%ebx,%%ebx\n\t" + "xorl %%ecx,%%ecx\n\t" +"1:\n\t" + "cmpxchg8b (%0)\n\t" + "jnz 1b" + : + : "SD" (p) + : "memory", "cc", "eax", "edx", "ebx", "ecx"); +} + +static void +counter_u64_zero_one_cpu(void *arg) +{ + uint64_t *p; + + p = (uint64_t *)((char *)arg + sizeof(struct pcpu) * PCPU_GET(cpuid)); + counter_u64_zero_one_8b(p); +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + int i; + + if ((cpu_feature & CPUID_CX8) == 0) { + critical_enter(); + for (i = 0; i < mp_ncpus; i++) + *(uint64_t *)((char *)c + sizeof(struct pcpu) * i) = 0; + critical_exit(); + } else { + smp_rendezvous(smp_no_rendevous_barrier, + counter_u64_zero_one_cpu, smp_no_rendevous_barrier, c); + } +} +#endif + #define counter_u64_add_protected(c, inc) do { \ if ((cpu_feature & CPUID_CX8) == 0) { \ CRITICAL_ASSERT(curthread); \ diff --git a/sys/ia64/include/counter.h b/sys/ia64/include/counter.h index 68f89e2..a3fe871 100644 --- a/sys/ia64/include/counter.h +++ b/sys/ia64/include/counter.h @@ -37,6 +37,45 @@ #define counter_enter() critical_enter() #define counter_exit() critical_exit() +#ifdef IN_SUBR_COUNTER_C +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +/* XXXKIB might interrupt increment */ +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, inc) do { \ CRITICAL_ASSERT(curthread); \ *(uint64_t *)zpcpu_get(c) += (inc); \ diff --git a/sys/kern/Make.tags.inc b/sys/kern/Make.tags.inc index 81205a6..cb8a3ff 100644 --- a/sys/kern/Make.tags.inc +++ b/sys/kern/Make.tags.inc @@ -30,6 +30,7 @@ COMM= ${SYS}/dev/advansys/*.[ch] \ ${SYS}/fs/msdosfs/*.[ch] \ ${SYS}/fs/nullfs/*.[ch] \ ${SYS}/fs/procfs/*.[ch] \ + ${SYS}/fs/smbfs/*.[ch] \ ${SYS}/fs/udf/*.[ch] \ ${SYS}/fs/unionfs/*.[ch] \ ${SYS}/geom/*.[ch] \ diff --git a/sys/kern/kern_acct.c b/sys/kern/kern_acct.c index 3362112..ef3fd2e 100644 --- a/sys/kern/kern_acct.c +++ b/sys/kern/kern_acct.c @@ -133,6 +133,7 @@ static int acct_configured; static int acct_suspended; static struct vnode *acct_vp; static struct ucred *acct_cred; +static struct plimit *acct_limit; static int acct_flags; static struct sx acct_sx; @@ -196,7 +197,7 @@ int sys_acct(struct thread *td, struct acct_args *uap) { struct nameidata nd; - int error, flags, replacing; + int error, flags, i, replacing; error = priv_check(td, PRIV_ACCT); if (error) @@ -267,6 +268,15 @@ sys_acct(struct thread *td, struct acct_args *uap) } /* + * Create our own plimit object without limits. It will be assigned + * to exiting processes. + */ + acct_limit = lim_alloc(); + for (i = 0; i < RLIM_NLIMITS; i++) + acct_limit->pl_rlimit[i].rlim_cur = + acct_limit->pl_rlimit[i].rlim_max = RLIM_INFINITY; + + /* * Save the new accounting file vnode, and schedule the new * free space watcher. */ @@ -284,12 +294,7 @@ sys_acct(struct thread *td, struct acct_args *uap) error = kproc_create(acct_thread, NULL, NULL, 0, 0, "accounting"); if (error) { - (void) vn_close(acct_vp, acct_flags, acct_cred, td); - crfree(acct_cred); - acct_configured = 0; - acct_vp = NULL; - acct_cred = NULL; - acct_flags = 0; + (void) acct_disable(td, 0); sx_xunlock(&acct_sx); log(LOG_NOTICE, "Unable to start accounting thread\n"); return (error); @@ -314,6 +319,7 @@ acct_disable(struct thread *td, int logging) sx_assert(&acct_sx, SX_XLOCKED); error = vn_close(acct_vp, acct_flags, acct_cred, td); crfree(acct_cred); + lim_free(acct_limit); acct_configured = 0; acct_vp = NULL; acct_cred = NULL; @@ -334,7 +340,7 @@ acct_process(struct thread *td) { struct acctv2 acct; struct timeval ut, st, tmp; - struct plimit *newlim, *oldlim; + struct plimit *oldlim; struct proc *p; struct rusage ru; int t, ret; @@ -410,7 +416,6 @@ acct_process(struct thread *td) /* (8) The boolean flags that tell how the process terminated, etc. */ acct.ac_flagx = p->p_acflag; - PROC_UNLOCK(p); /* Setup ancillary structure fields. */ acct.ac_flagx |= ANVER; @@ -419,14 +424,10 @@ acct_process(struct thread *td) acct.ac_len = acct.ac_len2 = sizeof(acct); /* - * Eliminate any file size rlimit. + * Eliminate rlimits (file size limit in particular). */ - newlim = lim_alloc(); - PROC_LOCK(p); oldlim = p->p_limit; - lim_copy(newlim, oldlim); - newlim->pl_rlimit[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY; - p->p_limit = newlim; + p->p_limit = lim_hold(acct_limit); PROC_UNLOCK(p); lim_free(oldlim); diff --git a/sys/kern/kern_clock.c b/sys/kern/kern_clock.c index 2841f8c..4cfd219 100644 --- a/sys/kern/kern_clock.c +++ b/sys/kern/kern_clock.c @@ -216,13 +216,8 @@ deadlkres(void) } FOREACH_THREAD_IN_PROC(p, td) { - /* - * Once a thread is found in "interesting" - * state a possible ticks wrap-up needs to be - * checked. - */ thread_lock(td); - if (TD_ON_LOCK(td) && ticks < td->td_blktick) { + if (TD_ON_LOCK(td)) { /* * The thread should be blocked on a @@ -247,8 +242,7 @@ deadlkres(void) __func__, td, tticks); } } else if (TD_IS_SLEEPING(td) && - TD_ON_SLEEPQ(td) && - ticks < td->td_blktick) { + TD_ON_SLEEPQ(td)) { /* * Check if the thread is sleeping on a diff --git a/sys/kern/kern_descrip.c b/sys/kern/kern_descrip.c index c0ecf15..fb264ba 100644 --- a/sys/kern/kern_descrip.c +++ b/sys/kern/kern_descrip.c @@ -3176,10 +3176,16 @@ static SYSCTL_NODE(_kern_proc, KERN_PROC_OFILEDESC, ofiledesc, CTLFLAG_RD, CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE); #endif +struct export_fd_buf { + struct filedesc *fdp; + struct sbuf *sb; + ssize_t remainder; + struct kinfo_file kif; +}; + static int export_fd_to_sb(void *data, int type, int fd, int fflags, int refcnt, - int64_t offset, cap_rights_t fd_cap_rights, struct kinfo_file *kif, - struct sbuf *sb, ssize_t *remainder) + int64_t offset, cap_rights_t fd_cap_rights, struct export_fd_buf *efbuf) { struct { int fflag; @@ -3202,16 +3208,23 @@ export_fd_to_sb(void *data, int type, int fd, int fflags, int refcnt, { O_TRUNC, KF_FLAG_TRUNC } }; #define NFFLAGS (sizeof(fflags_table) / sizeof(*fflags_table)) + struct kinfo_file *kif; struct vnode *vp; - int error; + int error, locked; unsigned int i; - if (*remainder == 0) + if (efbuf->remainder == 0) return (0); + kif = &efbuf->kif; bzero(kif, sizeof(*kif)); + locked = efbuf->fdp != NULL; switch (type) { case KF_TYPE_FIFO: case KF_TYPE_VNODE: + if (locked) { + FILEDESC_SUNLOCK(efbuf->fdp); + locked = 0; + } vp = (struct vnode *)data; error = fill_vnode_info(vp, kif); vrele(vp); @@ -3255,15 +3268,21 @@ export_fd_to_sb(void *data, int type, int fd, int fflags, int refcnt, kif->kf_structsize = offsetof(struct kinfo_file, kf_path) + strlen(kif->kf_path) + 1; kif->kf_structsize = roundup(kif->kf_structsize, sizeof(uint64_t)); - if (*remainder != -1) { - if (*remainder < kif->kf_structsize) { + if (efbuf->remainder != -1) { + if (efbuf->remainder < kif->kf_structsize) { /* Terminate export. */ - *remainder = 0; + efbuf->remainder = 0; + if (efbuf->fdp != NULL && !locked) + FILEDESC_SLOCK(efbuf->fdp); return (0); } - *remainder -= kif->kf_structsize; + efbuf->remainder -= kif->kf_structsize; } - error = sbuf_bcat(sb, kif, kif->kf_structsize); + if (locked) + FILEDESC_SUNLOCK(efbuf->fdp); + error = sbuf_bcat(efbuf->sb, kif, kif->kf_structsize); + if (efbuf->fdp != NULL) + FILEDESC_SLOCK(efbuf->fdp); return (error); } @@ -3277,18 +3296,16 @@ kern_proc_filedesc_out(struct proc *p, struct sbuf *sb, ssize_t maxlen) { struct file *fp; struct filedesc *fdp; - struct kinfo_file *kif; + struct export_fd_buf *efbuf; struct vnode *cttyvp, *textvp, *tracevp; int64_t offset; void *data; - ssize_t remainder; int error, i; int type, refcnt, fflags; cap_rights_t fd_cap_rights; PROC_LOCK_ASSERT(p, MA_OWNED); - remainder = maxlen; /* ktrace vnode */ tracevp = p->p_tracevp; if (tracevp != NULL) @@ -3306,46 +3323,44 @@ kern_proc_filedesc_out(struct proc *p, struct sbuf *sb, ssize_t maxlen) } fdp = fdhold(p); PROC_UNLOCK(p); - kif = malloc(sizeof(*kif), M_TEMP, M_WAITOK); + efbuf = malloc(sizeof(*efbuf), M_TEMP, M_WAITOK); + efbuf->fdp = NULL; + efbuf->sb = sb; + efbuf->remainder = maxlen; if (tracevp != NULL) export_fd_to_sb(tracevp, KF_TYPE_VNODE, KF_FD_TYPE_TRACE, - FREAD | FWRITE, -1, -1, 0, kif, sb, &remainder); + FREAD | FWRITE, -1, -1, 0, efbuf); if (textvp != NULL) export_fd_to_sb(textvp, KF_TYPE_VNODE, KF_FD_TYPE_TEXT, - FREAD, -1, -1, 0, kif, sb, &remainder); + FREAD, -1, -1, 0, efbuf); if (cttyvp != NULL) export_fd_to_sb(cttyvp, KF_TYPE_VNODE, KF_FD_TYPE_CTTY, - FREAD | FWRITE, -1, -1, 0, kif, sb, &remainder); + FREAD | FWRITE, -1, -1, 0, efbuf); error = 0; if (fdp == NULL) goto fail; + efbuf->fdp = fdp; FILEDESC_SLOCK(fdp); /* working directory */ if (fdp->fd_cdir != NULL) { vref(fdp->fd_cdir); data = fdp->fd_cdir; - FILEDESC_SUNLOCK(fdp); export_fd_to_sb(data, KF_TYPE_VNODE, KF_FD_TYPE_CWD, - FREAD, -1, -1, 0, kif, sb, &remainder); - FILEDESC_SLOCK(fdp); + FREAD, -1, -1, 0, efbuf); } /* root directory */ if (fdp->fd_rdir != NULL) { vref(fdp->fd_rdir); data = fdp->fd_rdir; - FILEDESC_SUNLOCK(fdp); export_fd_to_sb(data, KF_TYPE_VNODE, KF_FD_TYPE_ROOT, - FREAD, -1, -1, 0, kif, sb, &remainder); - FILEDESC_SLOCK(fdp); + FREAD, -1, -1, 0, efbuf); } /* jail directory */ if (fdp->fd_jdir != NULL) { vref(fdp->fd_jdir); data = fdp->fd_jdir; - FILEDESC_SUNLOCK(fdp); export_fd_to_sb(data, KF_TYPE_VNODE, KF_FD_TYPE_JAIL, - FREAD, -1, -1, 0, kif, sb, &remainder); - FILEDESC_SLOCK(fdp); + FREAD, -1, -1, 0, efbuf); } for (i = 0; i < fdp->fd_nfiles; i++) { if ((fp = fdp->fd_ofiles[i].fde_file) == NULL) @@ -3427,20 +3442,15 @@ kern_proc_filedesc_out(struct proc *p, struct sbuf *sb, ssize_t maxlen) * re-validate and re-evaluate its properties when * the loop continues. */ - if (type == KF_TYPE_VNODE || type == KF_TYPE_FIFO) - FILEDESC_SUNLOCK(fdp); error = export_fd_to_sb(data, type, i, fflags, refcnt, - offset, fd_cap_rights, kif, sb, &remainder); - if (type == KF_TYPE_VNODE || type == KF_TYPE_FIFO) - FILEDESC_SLOCK(fdp); + offset, fd_cap_rights, efbuf); if (error) break; } FILEDESC_SUNLOCK(fdp); + fddrop(fdp); fail: - if (fdp != NULL) - fddrop(fdp); - free(kif, M_TEMP); + free(efbuf, M_TEMP); return (error); } diff --git a/sys/kern/kern_intr.c b/sys/kern/kern_intr.c index 8d63c9b..63d8469 100644 --- a/sys/kern/kern_intr.c +++ b/sys/kern/kern_intr.c @@ -841,7 +841,7 @@ ok: * again and remove this handler if it has already passed * it on the list. */ - ie->ie_thread->it_need = 1; + atomic_store_rel_int(&ie->ie_thread->it_need, 1); } else TAILQ_REMOVE(&ie->ie_handlers, handler, ih_next); thread_unlock(ie->ie_thread->it_thread); @@ -912,7 +912,7 @@ intr_event_schedule_thread(struct intr_event *ie) * running. Then, lock the thread and see if we actually need to * put it on the runqueue. */ - it->it_need = 1; + atomic_store_rel_int(&it->it_need, 1); thread_lock(td); if (TD_AWAITING_INTR(td)) { CTR3(KTR_INTR, "%s: schedule pid %d (%s)", __func__, p->p_pid, @@ -990,7 +990,7 @@ ok: * again and remove this handler if it has already passed * it on the list. */ - it->it_need = 1; + atomic_store_rel_int(&it->it_need, 1); } else TAILQ_REMOVE(&ie->ie_handlers, handler, ih_next); thread_unlock(it->it_thread); @@ -1066,7 +1066,7 @@ intr_event_schedule_thread(struct intr_event *ie, struct intr_thread *it) * running. Then, lock the thread and see if we actually need to * put it on the runqueue. */ - it->it_need = 1; + atomic_store_rel_int(&it->it_need, 1); thread_lock(td); if (TD_AWAITING_INTR(td)) { CTR3(KTR_INTR, "%s: schedule pid %d (%s)", __func__, p->p_pid, @@ -1247,7 +1247,7 @@ intr_event_execute_handlers(struct proc *p, struct intr_event *ie) * interrupt threads always invoke all of their handlers. */ if (ie->ie_flags & IE_SOFT) { - if (!ih->ih_need) + if (atomic_load_acq_int(&ih->ih_need) == 0) continue; else atomic_store_rel_int(&ih->ih_need, 0); @@ -1349,7 +1349,7 @@ ithread_loop(void *arg) * we are running, it will set it_need to note that we * should make another pass. */ - while (ithd->it_need) { + while (atomic_load_acq_int(&ithd->it_need) != 0) { /* * This might need a full read and write barrier * to make sure that this write posts before any @@ -1368,7 +1368,8 @@ ithread_loop(void *arg) * set again, so we have to check it again. */ thread_lock(td); - if (!ithd->it_need && !(ithd->it_flags & (IT_DEAD | IT_WAIT))) { + if ((atomic_load_acq_int(&ithd->it_need) == 0) && + !(ithd->it_flags & (IT_DEAD | IT_WAIT))) { TD_SET_IWAIT(td); ie->ie_count = 0; mi_switch(SW_VOL | SWT_IWAIT, NULL); @@ -1529,7 +1530,7 @@ ithread_loop(void *arg) * we are running, it will set it_need to note that we * should make another pass. */ - while (ithd->it_need) { + while (atomic_load_acq_int(&ithd->it_need) != 0) { /* * This might need a full read and write barrier * to make sure that this write posts before any @@ -1551,7 +1552,8 @@ ithread_loop(void *arg) * set again, so we have to check it again. */ thread_lock(td); - if (!ithd->it_need && !(ithd->it_flags & (IT_DEAD | IT_WAIT))) { + if ((atomic_load_acq_int(&ithd->it_need) == 0) && + !(ithd->it_flags & (IT_DEAD | IT_WAIT))) { TD_SET_IWAIT(td); ie->ie_count = 0; mi_switch(SW_VOL | SWT_IWAIT, NULL); diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c index 33d2db5..84b1c61 100644 --- a/sys/kern/kern_synch.c +++ b/sys/kern/kern_synch.c @@ -132,7 +132,7 @@ sleepinit(void) /* * General sleep call. Suspends the current thread until a wakeup is * performed on the specified identifier. The thread will then be made - * runnable with the specified priority. Sleeps at most timo/hz seconds + * runnable with the specified priority. Sleeps at most sbt units of time * (0 means no timeout). If pri includes the PCATCH flag, let signals * interrupt the sleep, otherwise ignore them while sleeping. Returns 0 if * awakened, EWOULDBLOCK if the timeout expires. If PCATCH is set and a diff --git a/sys/kern/subr_bus.c b/sys/kern/subr_bus.c index 1d45f28..f196c8b 100644 --- a/sys/kern/subr_bus.c +++ b/sys/kern/subr_bus.c @@ -3316,6 +3316,48 @@ resource_list_release(struct resource_list *rl, device_t bus, device_t child, } /** + * @brief Release all active resources of a given type + * + * Release all active resources of a specified type. This is intended + * to be used to cleanup resources leaked by a driver after detach or + * a failed attach. + * + * @param rl the resource list which was allocated from + * @param bus the parent device of @p child + * @param child the device whose active resources are being released + * @param type the type of resources to release + * + * @retval 0 success + * @retval EBUSY at least one resource was active + */ +int +resource_list_release_active(struct resource_list *rl, device_t bus, + device_t child, int type) +{ + struct resource_list_entry *rle; + int error, retval; + + retval = 0; + STAILQ_FOREACH(rle, rl, link) { + if (rle->type != type) + continue; + if (rle->res == NULL) + continue; + if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == + RLE_RESERVED) + continue; + retval = EBUSY; + error = resource_list_release(rl, bus, child, type, + rman_get_rid(rle->res), rle->res); + if (error != 0) + device_printf(bus, + "Failed to release active resource: %d\n", error); + } + return (retval); +} + + +/** * @brief Fully release a reserved resource * * Fully releases a resource reserved via resource_list_reserve(). diff --git a/sys/kern/subr_counter.c b/sys/kern/subr_counter.c index a98ed40..2656ed7 100644 --- a/sys/kern/subr_counter.c +++ b/sys/kern/subr_counter.c @@ -29,34 +29,32 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/systm.h> -#include <sys/counter.h> #include <sys/kernel.h> +#include <sys/lock.h> +#include <sys/mutex.h> +#include <sys/proc.h> +#include <sys/sched.h> #include <sys/smp.h> #include <sys/sysctl.h> #include <vm/uma.h> + +#define IN_SUBR_COUNTER_C +#include <sys/counter.h> static uma_zone_t uint64_pcpu_zone; void counter_u64_zero(counter_u64_t c) { - int i; - for (i = 0; i < mp_ncpus; i++) - *(uint64_t *)((char *)c + sizeof(struct pcpu) * i) = 0; + counter_u64_zero_inline(c); } uint64_t counter_u64_fetch(counter_u64_t c) { - uint64_t r; - int i; - r = 0; - for (i = 0; i < mp_ncpus; i++) - r += *(uint64_t *)((char *)c + sizeof(struct pcpu) * i); - - return (r); + return (counter_u64_fetch_inline(c)); } counter_u64_t diff --git a/sys/kern/subr_vmem.c b/sys/kern/subr_vmem.c new file mode 100644 index 0000000..b48dbca --- /dev/null +++ b/sys/kern/subr_vmem.c @@ -0,0 +1,1372 @@ +/*- + * Copyright (c)2006,2007,2008,2009 YAMAMOTO Takashi, + * Copyright (c) 2013 EMC Corp. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * From: + * $NetBSD: vmem_impl.h,v 1.2 2013/01/29 21:26:24 para Exp $ + * $NetBSD: subr_vmem.c,v 1.83 2013/03/06 11:20:10 yamt Exp $ + */ + +/* + * reference: + * - Magazines and Vmem: Extending the Slab Allocator + * to Many CPUs and Arbitrary Resources + * http://www.usenix.org/event/usenix01/bonwick.html + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include "opt_ddb.h" + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/queue.h> +#include <sys/callout.h> +#include <sys/hash.h> +#include <sys/lock.h> +#include <sys/malloc.h> +#include <sys/mutex.h> +#include <sys/smp.h> +#include <sys/condvar.h> +#include <sys/taskqueue.h> +#include <sys/vmem.h> + +#include <vm/uma.h> +#include <vm/vm.h> +#include <vm/pmap.h> +#include <vm/vm_map.h> +#include <vm/vm_kern.h> +#include <vm/vm_extern.h> +#include <vm/vm_param.h> +#include <vm/vm_pageout.h> + +#define VMEM_MAXORDER (sizeof(vmem_size_t) * NBBY) + +#define VMEM_HASHSIZE_MIN 16 +#define VMEM_HASHSIZE_MAX 131072 + +#define VMEM_QCACHE_IDX_MAX 16 + +#define VMEM_FITMASK (M_BESTFIT | M_FIRSTFIT) + +#define VMEM_FLAGS \ + (M_NOWAIT | M_WAITOK | M_USE_RESERVE | M_NOVM | M_BESTFIT | M_FIRSTFIT) + +#define BT_FLAGS (M_NOWAIT | M_WAITOK | M_USE_RESERVE | M_NOVM) + +#define QC_NAME_MAX 16 + +/* + * Data structures private to vmem. + */ +MALLOC_DEFINE(M_VMEM, "vmem", "vmem internal structures"); + +typedef struct vmem_btag bt_t; + +TAILQ_HEAD(vmem_seglist, vmem_btag); +LIST_HEAD(vmem_freelist, vmem_btag); +LIST_HEAD(vmem_hashlist, vmem_btag); + +struct qcache { + uma_zone_t qc_cache; + vmem_t *qc_vmem; + vmem_size_t qc_size; + char qc_name[QC_NAME_MAX]; +}; +typedef struct qcache qcache_t; +#define QC_POOL_TO_QCACHE(pool) ((qcache_t *)(pool->pr_qcache)) + +#define VMEM_NAME_MAX 16 + +/* vmem arena */ +struct vmem { + struct mtx_padalign vm_lock; + struct cv vm_cv; + char vm_name[VMEM_NAME_MAX+1]; + LIST_ENTRY(vmem) vm_alllist; + struct vmem_hashlist vm_hash0[VMEM_HASHSIZE_MIN]; + struct vmem_freelist vm_freelist[VMEM_MAXORDER]; + struct vmem_seglist vm_seglist; + struct vmem_hashlist *vm_hashlist; + vmem_size_t vm_hashsize; + + /* Constant after init */ + vmem_size_t vm_qcache_max; + vmem_size_t vm_quantum_mask; + vmem_size_t vm_import_quantum; + int vm_quantum_shift; + + /* Written on alloc/free */ + LIST_HEAD(, vmem_btag) vm_freetags; + int vm_nfreetags; + int vm_nbusytag; + vmem_size_t vm_inuse; + vmem_size_t vm_size; + + /* Used on import. */ + vmem_import_t *vm_importfn; + vmem_release_t *vm_releasefn; + void *vm_arg; + + /* Space exhaustion callback. */ + vmem_reclaim_t *vm_reclaimfn; + + /* quantum cache */ + qcache_t vm_qcache[VMEM_QCACHE_IDX_MAX]; +}; + +/* boundary tag */ +struct vmem_btag { + TAILQ_ENTRY(vmem_btag) bt_seglist; + union { + LIST_ENTRY(vmem_btag) u_freelist; /* BT_TYPE_FREE */ + LIST_ENTRY(vmem_btag) u_hashlist; /* BT_TYPE_BUSY */ + } bt_u; +#define bt_hashlist bt_u.u_hashlist +#define bt_freelist bt_u.u_freelist + vmem_addr_t bt_start; + vmem_size_t bt_size; + int bt_type; +}; + +#define BT_TYPE_SPAN 1 /* Allocated from importfn */ +#define BT_TYPE_SPAN_STATIC 2 /* vmem_add() or create. */ +#define BT_TYPE_FREE 3 /* Available space. */ +#define BT_TYPE_BUSY 4 /* Used space. */ +#define BT_ISSPAN_P(bt) ((bt)->bt_type <= BT_TYPE_SPAN_STATIC) + +#define BT_END(bt) ((bt)->bt_start + (bt)->bt_size - 1) + +#if defined(DIAGNOSTIC) +static void vmem_check(vmem_t *); +#endif + +static struct callout vmem_periodic_ch; +static int vmem_periodic_interval; +static struct task vmem_periodic_wk; + +static struct mtx_padalign vmem_list_lock; +static LIST_HEAD(, vmem) vmem_list = LIST_HEAD_INITIALIZER(vmem_list); + +/* ---- misc */ +#define VMEM_CONDVAR_INIT(vm, wchan) cv_init(&vm->vm_cv, wchan) +#define VMEM_CONDVAR_DESTROY(vm) cv_destroy(&vm->vm_cv) +#define VMEM_CONDVAR_WAIT(vm) cv_wait(&vm->vm_cv, &vm->vm_lock) +#define VMEM_CONDVAR_BROADCAST(vm) cv_broadcast(&vm->vm_cv) + + +#define VMEM_LOCK(vm) mtx_lock(&vm->vm_lock) +#define VMEM_TRYLOCK(vm) mtx_trylock(&vm->vm_lock) +#define VMEM_UNLOCK(vm) mtx_unlock(&vm->vm_lock) +#define VMEM_LOCK_INIT(vm, name) mtx_init(&vm->vm_lock, (name), NULL, MTX_DEF) +#define VMEM_LOCK_DESTROY(vm) mtx_destroy(&vm->vm_lock) +#define VMEM_ASSERT_LOCKED(vm) mtx_assert(&vm->vm_lock, MA_OWNED); + +#define VMEM_ALIGNUP(addr, align) (-(-(addr) & -(align))) + +#define VMEM_CROSS_P(addr1, addr2, boundary) \ + ((((addr1) ^ (addr2)) & -(boundary)) != 0) + +#define ORDER2SIZE(order) ((vmem_size_t)1 << (order)) +#define SIZE2ORDER(size) ((int)flsl(size) - 1) + +/* + * Maximum number of boundary tags that may be required to satisfy an + * allocation. Two may be required to import. Another two may be + * required to clip edges. + */ +#define BT_MAXALLOC 4 + +/* + * Max free limits the number of locally cached boundary tags. We + * just want to avoid hitting the zone allocator for every call. + */ +#define BT_MAXFREE (BT_MAXALLOC * 8) + +/* Allocator for boundary tags. */ +static uma_zone_t vmem_bt_zone; + +/* boot time arena storage. */ +static struct vmem buffer_arena_storage; +static struct vmem transient_arena_storage; +vmem_t *buffer_arena = &buffer_arena_storage; +vmem_t *transient_arena = &transient_arena_storage; + +/* + * Fill the vmem's boundary tag cache. We guarantee that boundary tag + * allocation will not fail once bt_fill() passes. To do so we cache + * at least the maximum possible tag allocations in the arena. + */ +static int +bt_fill(vmem_t *vm, int flags) +{ + bt_t *bt; + + VMEM_ASSERT_LOCKED(vm); + + /* + * Loop until we meet the reserve. To minimize the lock shuffle + * and prevent simultaneous fills we first try a NOWAIT regardless + * of the caller's flags. Specify M_NOVM so we don't recurse while + * holding a vmem lock. + */ + while (vm->vm_nfreetags < BT_MAXALLOC) { + bt = uma_zalloc(vmem_bt_zone, + (flags & M_USE_RESERVE) | M_NOWAIT | M_NOVM); + if (bt == NULL) { + VMEM_UNLOCK(vm); + bt = uma_zalloc(vmem_bt_zone, flags); + VMEM_LOCK(vm); + if (bt == NULL && (flags & M_NOWAIT) != 0) + break; + } + LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist); + vm->vm_nfreetags++; + } + + if (vm->vm_nfreetags < BT_MAXALLOC) + return ENOMEM; + + return 0; +} + +/* + * Pop a tag off of the freetag stack. + */ +static bt_t * +bt_alloc(vmem_t *vm) +{ + bt_t *bt; + + VMEM_ASSERT_LOCKED(vm); + bt = LIST_FIRST(&vm->vm_freetags); + MPASS(bt != NULL); + LIST_REMOVE(bt, bt_freelist); + vm->vm_nfreetags--; + + return bt; +} + +/* + * Trim the per-vmem free list. Returns with the lock released to + * avoid allocator recursions. + */ +static void +bt_freetrim(vmem_t *vm, int freelimit) +{ + LIST_HEAD(, vmem_btag) freetags; + bt_t *bt; + + LIST_INIT(&freetags); + VMEM_ASSERT_LOCKED(vm); + while (vm->vm_nfreetags > freelimit) { + bt = LIST_FIRST(&vm->vm_freetags); + LIST_REMOVE(bt, bt_freelist); + vm->vm_nfreetags--; + LIST_INSERT_HEAD(&freetags, bt, bt_freelist); + } + VMEM_UNLOCK(vm); + while ((bt = LIST_FIRST(&freetags)) != NULL) { + LIST_REMOVE(bt, bt_freelist); + uma_zfree(vmem_bt_zone, bt); + } +} + +static inline void +bt_free(vmem_t *vm, bt_t *bt) +{ + + VMEM_ASSERT_LOCKED(vm); + MPASS(LIST_FIRST(&vm->vm_freetags) != bt); + LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist); + vm->vm_nfreetags++; +} + +/* + * freelist[0] ... [1, 1] + * freelist[1] ... [2, 3] + * freelist[2] ... [4, 7] + * freelist[3] ... [8, 15] + * : + * freelist[n] ... [(1 << n), (1 << (n + 1)) - 1] + * : + */ + +static struct vmem_freelist * +bt_freehead_tofree(vmem_t *vm, vmem_size_t size) +{ + const vmem_size_t qsize = size >> vm->vm_quantum_shift; + const int idx = SIZE2ORDER(qsize); + + MPASS(size != 0 && qsize != 0); + MPASS((size & vm->vm_quantum_mask) == 0); + MPASS(idx >= 0); + MPASS(idx < VMEM_MAXORDER); + + return &vm->vm_freelist[idx]; +} + +/* + * bt_freehead_toalloc: return the freelist for the given size and allocation + * strategy. + * + * For M_FIRSTFIT, return the list in which any blocks are large enough + * for the requested size. otherwise, return the list which can have blocks + * large enough for the requested size. + */ +static struct vmem_freelist * +bt_freehead_toalloc(vmem_t *vm, vmem_size_t size, int strat) +{ + const vmem_size_t qsize = size >> vm->vm_quantum_shift; + int idx = SIZE2ORDER(qsize); + + MPASS(size != 0 && qsize != 0); + MPASS((size & vm->vm_quantum_mask) == 0); + + if (strat == M_FIRSTFIT && ORDER2SIZE(idx) != qsize) { + idx++; + /* check too large request? */ + } + MPASS(idx >= 0); + MPASS(idx < VMEM_MAXORDER); + + return &vm->vm_freelist[idx]; +} + +/* ---- boundary tag hash */ + +static struct vmem_hashlist * +bt_hashhead(vmem_t *vm, vmem_addr_t addr) +{ + struct vmem_hashlist *list; + unsigned int hash; + + hash = hash32_buf(&addr, sizeof(addr), 0); + list = &vm->vm_hashlist[hash % vm->vm_hashsize]; + + return list; +} + +static bt_t * +bt_lookupbusy(vmem_t *vm, vmem_addr_t addr) +{ + struct vmem_hashlist *list; + bt_t *bt; + + VMEM_ASSERT_LOCKED(vm); + list = bt_hashhead(vm, addr); + LIST_FOREACH(bt, list, bt_hashlist) { + if (bt->bt_start == addr) { + break; + } + } + + return bt; +} + +static void +bt_rembusy(vmem_t *vm, bt_t *bt) +{ + + VMEM_ASSERT_LOCKED(vm); + MPASS(vm->vm_nbusytag > 0); + vm->vm_inuse -= bt->bt_size; + vm->vm_nbusytag--; + LIST_REMOVE(bt, bt_hashlist); +} + +static void +bt_insbusy(vmem_t *vm, bt_t *bt) +{ + struct vmem_hashlist *list; + + VMEM_ASSERT_LOCKED(vm); + MPASS(bt->bt_type == BT_TYPE_BUSY); + + list = bt_hashhead(vm, bt->bt_start); + LIST_INSERT_HEAD(list, bt, bt_hashlist); + vm->vm_nbusytag++; + vm->vm_inuse += bt->bt_size; +} + +/* ---- boundary tag list */ + +static void +bt_remseg(vmem_t *vm, bt_t *bt) +{ + + TAILQ_REMOVE(&vm->vm_seglist, bt, bt_seglist); + bt_free(vm, bt); +} + +static void +bt_insseg(vmem_t *vm, bt_t *bt, bt_t *prev) +{ + + TAILQ_INSERT_AFTER(&vm->vm_seglist, prev, bt, bt_seglist); +} + +static void +bt_insseg_tail(vmem_t *vm, bt_t *bt) +{ + + TAILQ_INSERT_TAIL(&vm->vm_seglist, bt, bt_seglist); +} + +static void +bt_remfree(vmem_t *vm, bt_t *bt) +{ + + MPASS(bt->bt_type == BT_TYPE_FREE); + + LIST_REMOVE(bt, bt_freelist); +} + +static void +bt_insfree(vmem_t *vm, bt_t *bt) +{ + struct vmem_freelist *list; + + list = bt_freehead_tofree(vm, bt->bt_size); + LIST_INSERT_HEAD(list, bt, bt_freelist); +} + +/* ---- vmem internal functions */ + +/* + * Import from the arena into the quantum cache in UMA. + */ +static int +qc_import(void *arg, void **store, int cnt, int flags) +{ + qcache_t *qc; + vmem_addr_t addr; + int i; + + qc = arg; + flags |= M_BESTFIT; + for (i = 0; i < cnt; i++) { + if (vmem_xalloc(qc->qc_vmem, qc->qc_size, 0, 0, 0, + VMEM_ADDR_MIN, VMEM_ADDR_MAX, flags, &addr) != 0) + break; + store[i] = (void *)addr; + /* Only guarantee one allocation. */ + flags &= ~M_WAITOK; + flags |= M_NOWAIT; + } + return i; +} + +/* + * Release memory from the UMA cache to the arena. + */ +static void +qc_release(void *arg, void **store, int cnt) +{ + qcache_t *qc; + int i; + + qc = arg; + for (i = 0; i < cnt; i++) + vmem_xfree(qc->qc_vmem, (vmem_addr_t)store[i], qc->qc_size); +} + +static void +qc_init(vmem_t *vm, vmem_size_t qcache_max) +{ + qcache_t *qc; + vmem_size_t size; + int qcache_idx_max; + int i; + + MPASS((qcache_max & vm->vm_quantum_mask) == 0); + qcache_idx_max = MIN(qcache_max >> vm->vm_quantum_shift, + VMEM_QCACHE_IDX_MAX); + vm->vm_qcache_max = qcache_idx_max << vm->vm_quantum_shift; + for (i = 0; i < qcache_idx_max; i++) { + qc = &vm->vm_qcache[i]; + size = (i + 1) << vm->vm_quantum_shift; + snprintf(qc->qc_name, sizeof(qc->qc_name), "%s-%zu", + vm->vm_name, size); + qc->qc_vmem = vm; + qc->qc_size = size; + qc->qc_cache = uma_zcache_create(qc->qc_name, size, + NULL, NULL, NULL, NULL, qc_import, qc_release, qc, + UMA_ZONE_VM); + MPASS(qc->qc_cache); + } +} + +static void +qc_destroy(vmem_t *vm) +{ + int qcache_idx_max; + int i; + + qcache_idx_max = vm->vm_qcache_max >> vm->vm_quantum_shift; + for (i = 0; i < qcache_idx_max; i++) + uma_zdestroy(vm->vm_qcache[i].qc_cache); +} + +static void +qc_drain(vmem_t *vm) +{ + int qcache_idx_max; + int i; + + qcache_idx_max = vm->vm_qcache_max >> vm->vm_quantum_shift; + for (i = 0; i < qcache_idx_max; i++) + zone_drain(vm->vm_qcache[i].qc_cache); +} + +void +vmem_startup(void) +{ + + mtx_init(&vmem_list_lock, "vmem list lock", NULL, MTX_DEF); + vmem_bt_zone = uma_zcreate("vmem btag", + sizeof(struct vmem_btag), NULL, NULL, NULL, NULL, + UMA_ALIGN_PTR, UMA_ZONE_VM); +} + +/* ---- rehash */ + +static int +vmem_rehash(vmem_t *vm, vmem_size_t newhashsize) +{ + bt_t *bt; + int i; + struct vmem_hashlist *newhashlist; + struct vmem_hashlist *oldhashlist; + vmem_size_t oldhashsize; + + MPASS(newhashsize > 0); + + newhashlist = malloc(sizeof(struct vmem_hashlist) * newhashsize, + M_VMEM, M_NOWAIT); + if (newhashlist == NULL) + return ENOMEM; + for (i = 0; i < newhashsize; i++) { + LIST_INIT(&newhashlist[i]); + } + + VMEM_LOCK(vm); + oldhashlist = vm->vm_hashlist; + oldhashsize = vm->vm_hashsize; + vm->vm_hashlist = newhashlist; + vm->vm_hashsize = newhashsize; + if (oldhashlist == NULL) { + VMEM_UNLOCK(vm); + return 0; + } + for (i = 0; i < oldhashsize; i++) { + while ((bt = LIST_FIRST(&oldhashlist[i])) != NULL) { + bt_rembusy(vm, bt); + bt_insbusy(vm, bt); + } + } + VMEM_UNLOCK(vm); + + if (oldhashlist != vm->vm_hash0) { + free(oldhashlist, M_VMEM); + } + + return 0; +} + +static void +vmem_periodic_kick(void *dummy) +{ + + taskqueue_enqueue(taskqueue_thread, &vmem_periodic_wk); +} + +static void +vmem_periodic(void *unused, int pending) +{ + vmem_t *vm; + vmem_size_t desired; + vmem_size_t current; + + mtx_lock(&vmem_list_lock); + LIST_FOREACH(vm, &vmem_list, vm_alllist) { +#ifdef DIAGNOSTIC + /* Convenient time to verify vmem state. */ + VMEM_LOCK(vm); + vmem_check(vm); + VMEM_UNLOCK(vm); +#endif + desired = 1 << flsl(vm->vm_nbusytag); + desired = MIN(MAX(desired, VMEM_HASHSIZE_MIN), + VMEM_HASHSIZE_MAX); + current = vm->vm_hashsize; + + /* Grow in powers of two. Shrink less aggressively. */ + if (desired >= current * 2 || desired * 4 <= current) + vmem_rehash(vm, desired); + } + mtx_unlock(&vmem_list_lock); + + callout_reset(&vmem_periodic_ch, vmem_periodic_interval, + vmem_periodic_kick, NULL); +} + +static void +vmem_start_callout(void *unused) +{ + + TASK_INIT(&vmem_periodic_wk, 0, vmem_periodic, NULL); + vmem_periodic_interval = hz * 10; + callout_init(&vmem_periodic_ch, CALLOUT_MPSAFE); + callout_reset(&vmem_periodic_ch, vmem_periodic_interval, + vmem_periodic_kick, NULL); +} +SYSINIT(vfs, SI_SUB_CONFIGURE, SI_ORDER_ANY, vmem_start_callout, NULL); + +static void +vmem_add1(vmem_t *vm, vmem_addr_t addr, vmem_size_t size, int flags, int type) +{ + bt_t *btspan; + bt_t *btfree; + + MPASS(type == BT_TYPE_SPAN || type == BT_TYPE_SPAN_STATIC); + + btspan = bt_alloc(vm); + btspan->bt_type = type; + btspan->bt_start = addr; + btspan->bt_size = size; + + btfree = bt_alloc(vm); + btfree->bt_type = BT_TYPE_FREE; + btfree->bt_start = addr; + btfree->bt_size = size; + + bt_insseg_tail(vm, btspan); + bt_insseg(vm, btfree, btspan); + bt_insfree(vm, btfree); + vm->vm_size += size; +} + +static void +vmem_destroy1(vmem_t *vm) +{ + bt_t *bt; + + /* + * Drain per-cpu quantum caches. + */ + qc_destroy(vm); + + /* + * The vmem should now only contain empty segments. + */ + VMEM_LOCK(vm); + MPASS(vm->vm_nbusytag == 0); + + while ((bt = TAILQ_FIRST(&vm->vm_seglist)) != NULL) + bt_remseg(vm, bt); + + if (vm->vm_hashlist != NULL && vm->vm_hashlist != vm->vm_hash0) + free(vm->vm_hashlist, M_VMEM); + + bt_freetrim(vm, 0); + + VMEM_CONDVAR_DESTROY(vm); + VMEM_LOCK_DESTROY(vm); + free(vm, M_VMEM); +} + +static int +vmem_import(vmem_t *vm, vmem_size_t size, int flags) +{ + vmem_addr_t addr; + int error; + + if (vm->vm_importfn == NULL) + return EINVAL; + + size = roundup(size, vm->vm_import_quantum); + + /* + * Hide MAXALLOC tags so we're guaranteed to be able to add this + * span and the tag we want to allocate from it. + */ + MPASS(vm->vm_nfreetags >= BT_MAXALLOC); + vm->vm_nfreetags -= BT_MAXALLOC; + VMEM_UNLOCK(vm); + error = (vm->vm_importfn)(vm->vm_arg, size, flags, &addr); + VMEM_LOCK(vm); + vm->vm_nfreetags += BT_MAXALLOC; + if (error) + return ENOMEM; + + vmem_add1(vm, addr, size, flags, BT_TYPE_SPAN); + + return 0; +} + +/* + * vmem_fit: check if a bt can satisfy the given restrictions. + * + * it's a caller's responsibility to ensure the region is big enough + * before calling us. + */ +static int +vmem_fit(const bt_t *bt, vmem_size_t size, vmem_size_t align, + vmem_size_t phase, vmem_size_t nocross, vmem_addr_t minaddr, + vmem_addr_t maxaddr, vmem_addr_t *addrp) +{ + vmem_addr_t start; + vmem_addr_t end; + + MPASS(size > 0); + MPASS(bt->bt_size >= size); /* caller's responsibility */ + + /* + * XXX assumption: vmem_addr_t and vmem_size_t are + * unsigned integer of the same size. + */ + + start = bt->bt_start; + if (start < minaddr) { + start = minaddr; + } + end = BT_END(bt); + if (end > maxaddr) + end = maxaddr; + if (start > end) + return (ENOMEM); + + start = VMEM_ALIGNUP(start - phase, align) + phase; + if (start < bt->bt_start) + start += align; + if (VMEM_CROSS_P(start, start + size - 1, nocross)) { + MPASS(align < nocross); + start = VMEM_ALIGNUP(start - phase, nocross) + phase; + } + if (start <= end && end - start >= size - 1) { + MPASS((start & (align - 1)) == phase); + MPASS(!VMEM_CROSS_P(start, start + size - 1, nocross)); + MPASS(minaddr <= start); + MPASS(maxaddr == 0 || start + size - 1 <= maxaddr); + MPASS(bt->bt_start <= start); + MPASS(BT_END(bt) - start >= size - 1); + *addrp = start; + + return (0); + } + return (ENOMEM); +} + +/* + * vmem_clip: Trim the boundary tag edges to the requested start and size. + */ +static void +vmem_clip(vmem_t *vm, bt_t *bt, vmem_addr_t start, vmem_size_t size) +{ + bt_t *btnew; + bt_t *btprev; + + VMEM_ASSERT_LOCKED(vm); + MPASS(bt->bt_type == BT_TYPE_FREE); + MPASS(bt->bt_size >= size); + bt_remfree(vm, bt); + if (bt->bt_start != start) { + btprev = bt_alloc(vm); + btprev->bt_type = BT_TYPE_FREE; + btprev->bt_start = bt->bt_start; + btprev->bt_size = start - bt->bt_start; + bt->bt_start = start; + bt->bt_size -= btprev->bt_size; + bt_insfree(vm, btprev); + bt_insseg(vm, btprev, + TAILQ_PREV(bt, vmem_seglist, bt_seglist)); + } + MPASS(bt->bt_start == start); + if (bt->bt_size != size && bt->bt_size - size > vm->vm_quantum_mask) { + /* split */ + btnew = bt_alloc(vm); + btnew->bt_type = BT_TYPE_BUSY; + btnew->bt_start = bt->bt_start; + btnew->bt_size = size; + bt->bt_start = bt->bt_start + size; + bt->bt_size -= size; + bt_insfree(vm, bt); + bt_insseg(vm, btnew, + TAILQ_PREV(bt, vmem_seglist, bt_seglist)); + bt_insbusy(vm, btnew); + bt = btnew; + } else { + bt->bt_type = BT_TYPE_BUSY; + bt_insbusy(vm, bt); + } + MPASS(bt->bt_size >= size); + bt->bt_type = BT_TYPE_BUSY; +} + +/* ---- vmem API */ + +void +vmem_set_import(vmem_t *vm, vmem_import_t *importfn, + vmem_release_t *releasefn, void *arg, vmem_size_t import_quantum) +{ + + VMEM_LOCK(vm); + vm->vm_importfn = importfn; + vm->vm_releasefn = releasefn; + vm->vm_arg = arg; + vm->vm_import_quantum = import_quantum; + VMEM_UNLOCK(vm); +} + +void +vmem_set_reclaim(vmem_t *vm, vmem_reclaim_t *reclaimfn) +{ + + VMEM_LOCK(vm); + vm->vm_reclaimfn = reclaimfn; + VMEM_UNLOCK(vm); +} + +/* + * vmem_init: Initializes vmem arena. + */ +vmem_t * +vmem_init(vmem_t *vm, const char *name, vmem_addr_t base, vmem_size_t size, + vmem_size_t quantum, vmem_size_t qcache_max, int flags) +{ + int i; + + MPASS(quantum > 0); + + bzero(vm, sizeof(*vm)); + + VMEM_CONDVAR_INIT(vm, name); + VMEM_LOCK_INIT(vm, name); + vm->vm_nfreetags = 0; + LIST_INIT(&vm->vm_freetags); + strlcpy(vm->vm_name, name, sizeof(vm->vm_name)); + vm->vm_quantum_mask = quantum - 1; + vm->vm_quantum_shift = SIZE2ORDER(quantum); + MPASS(ORDER2SIZE(vm->vm_quantum_shift) == quantum); + vm->vm_nbusytag = 0; + vm->vm_size = 0; + vm->vm_inuse = 0; + qc_init(vm, qcache_max); + + TAILQ_INIT(&vm->vm_seglist); + for (i = 0; i < VMEM_MAXORDER; i++) { + LIST_INIT(&vm->vm_freelist[i]); + } + memset(&vm->vm_hash0, 0, sizeof(vm->vm_hash0)); + vm->vm_hashsize = VMEM_HASHSIZE_MIN; + vm->vm_hashlist = vm->vm_hash0; + + if (size != 0) { + if (vmem_add(vm, base, size, flags) != 0) { + vmem_destroy1(vm); + return NULL; + } + } + + mtx_lock(&vmem_list_lock); + LIST_INSERT_HEAD(&vmem_list, vm, vm_alllist); + mtx_unlock(&vmem_list_lock); + + return vm; +} + +/* + * vmem_create: create an arena. + */ +vmem_t * +vmem_create(const char *name, vmem_addr_t base, vmem_size_t size, + vmem_size_t quantum, vmem_size_t qcache_max, int flags) +{ + + vmem_t *vm; + + vm = malloc(sizeof(*vm), M_VMEM, flags & (M_WAITOK|M_NOWAIT)); + if (vm == NULL) + return (NULL); + if (vmem_init(vm, name, base, size, quantum, qcache_max, + flags) == NULL) { + free(vm, M_VMEM); + return (NULL); + } + return (vm); +} + +void +vmem_destroy(vmem_t *vm) +{ + + mtx_lock(&vmem_list_lock); + LIST_REMOVE(vm, vm_alllist); + mtx_unlock(&vmem_list_lock); + + vmem_destroy1(vm); +} + +vmem_size_t +vmem_roundup_size(vmem_t *vm, vmem_size_t size) +{ + + return (size + vm->vm_quantum_mask) & ~vm->vm_quantum_mask; +} + +/* + * vmem_alloc: allocate resource from the arena. + */ +int +vmem_alloc(vmem_t *vm, vmem_size_t size, int flags, vmem_addr_t *addrp) +{ + const int strat __unused = flags & VMEM_FITMASK; + qcache_t *qc; + + flags &= VMEM_FLAGS; + MPASS(size > 0); + MPASS(strat == M_BESTFIT || strat == M_FIRSTFIT); + if ((flags & M_NOWAIT) == 0) + WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "vmem_alloc"); + + if (size <= vm->vm_qcache_max) { + qc = &vm->vm_qcache[(size - 1) >> vm->vm_quantum_shift]; + *addrp = (vmem_addr_t)uma_zalloc(qc->qc_cache, flags); + if (*addrp == 0) + return (ENOMEM); + return (0); + } + + return vmem_xalloc(vm, size, 0, 0, 0, VMEM_ADDR_MIN, VMEM_ADDR_MAX, + flags, addrp); +} + +int +vmem_xalloc(vmem_t *vm, const vmem_size_t size0, vmem_size_t align, + const vmem_size_t phase, const vmem_size_t nocross, + const vmem_addr_t minaddr, const vmem_addr_t maxaddr, int flags, + vmem_addr_t *addrp) +{ + const vmem_size_t size = vmem_roundup_size(vm, size0); + struct vmem_freelist *list; + struct vmem_freelist *first; + struct vmem_freelist *end; + vmem_size_t avail; + bt_t *bt; + int error; + int strat; + + flags &= VMEM_FLAGS; + strat = flags & VMEM_FITMASK; + MPASS(size0 > 0); + MPASS(size > 0); + MPASS(strat == M_BESTFIT || strat == M_FIRSTFIT); + MPASS((flags & (M_NOWAIT|M_WAITOK)) != (M_NOWAIT|M_WAITOK)); + if ((flags & M_NOWAIT) == 0) + WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "vmem_xalloc"); + MPASS((align & vm->vm_quantum_mask) == 0); + MPASS((align & (align - 1)) == 0); + MPASS((phase & vm->vm_quantum_mask) == 0); + MPASS((nocross & vm->vm_quantum_mask) == 0); + MPASS((nocross & (nocross - 1)) == 0); + MPASS((align == 0 && phase == 0) || phase < align); + MPASS(nocross == 0 || nocross >= size); + MPASS(minaddr <= maxaddr); + MPASS(!VMEM_CROSS_P(phase, phase + size - 1, nocross)); + + if (align == 0) + align = vm->vm_quantum_mask + 1; + + *addrp = 0; + end = &vm->vm_freelist[VMEM_MAXORDER]; + /* + * choose a free block from which we allocate. + */ + first = bt_freehead_toalloc(vm, size, strat); + VMEM_LOCK(vm); + for (;;) { + /* + * Make sure we have enough tags to complete the + * operation. + */ + if (vm->vm_nfreetags < BT_MAXALLOC && + bt_fill(vm, flags) != 0) { + error = ENOMEM; + break; + } + /* + * Scan freelists looking for a tag that satisfies the + * allocation. If we're doing BESTFIT we may encounter + * sizes below the request. If we're doing FIRSTFIT we + * inspect only the first element from each list. + */ + for (list = first; list < end; list++) { + LIST_FOREACH(bt, list, bt_freelist) { + if (bt->bt_size >= size) { + error = vmem_fit(bt, size, align, phase, + nocross, minaddr, maxaddr, addrp); + if (error == 0) { + vmem_clip(vm, bt, *addrp, size); + goto out; + } + } + /* FIRST skips to the next list. */ + if (strat == M_FIRSTFIT) + break; + } + } + /* + * Retry if the fast algorithm failed. + */ + if (strat == M_FIRSTFIT) { + strat = M_BESTFIT; + first = bt_freehead_toalloc(vm, size, strat); + continue; + } + /* + * XXX it is possible to fail to meet restrictions with the + * imported region. It is up to the user to specify the + * import quantum such that it can satisfy any allocation. + */ + if (vmem_import(vm, size, flags) == 0) + continue; + + /* + * Try to free some space from the quantum cache or reclaim + * functions if available. + */ + if (vm->vm_qcache_max != 0 || vm->vm_reclaimfn != NULL) { + avail = vm->vm_size - vm->vm_inuse; + VMEM_UNLOCK(vm); + if (vm->vm_qcache_max != 0) + qc_drain(vm); + if (vm->vm_reclaimfn != NULL) + vm->vm_reclaimfn(vm, flags); + VMEM_LOCK(vm); + /* If we were successful retry even NOWAIT. */ + if (vm->vm_size - vm->vm_inuse > avail) + continue; + } + if ((flags & M_NOWAIT) != 0) { + error = ENOMEM; + break; + } + VMEM_CONDVAR_WAIT(vm); + } +out: + VMEM_UNLOCK(vm); + if (error != 0 && (flags & M_NOWAIT) == 0) + panic("failed to allocate waiting allocation\n"); + + return (error); +} + +/* + * vmem_free: free the resource to the arena. + */ +void +vmem_free(vmem_t *vm, vmem_addr_t addr, vmem_size_t size) +{ + qcache_t *qc; + MPASS(size > 0); + + if (size <= vm->vm_qcache_max) { + qc = &vm->vm_qcache[(size - 1) >> vm->vm_quantum_shift]; + uma_zfree(qc->qc_cache, (void *)addr); + } else + vmem_xfree(vm, addr, size); +} + +void +vmem_xfree(vmem_t *vm, vmem_addr_t addr, vmem_size_t size) +{ + bt_t *bt; + bt_t *t; + + MPASS(size > 0); + + VMEM_LOCK(vm); + bt = bt_lookupbusy(vm, addr); + MPASS(bt != NULL); + MPASS(bt->bt_start == addr); + MPASS(bt->bt_size == vmem_roundup_size(vm, size) || + bt->bt_size - vmem_roundup_size(vm, size) <= vm->vm_quantum_mask); + MPASS(bt->bt_type == BT_TYPE_BUSY); + bt_rembusy(vm, bt); + bt->bt_type = BT_TYPE_FREE; + + /* coalesce */ + t = TAILQ_NEXT(bt, bt_seglist); + if (t != NULL && t->bt_type == BT_TYPE_FREE) { + MPASS(BT_END(bt) < t->bt_start); /* YYY */ + bt->bt_size += t->bt_size; + bt_remfree(vm, t); + bt_remseg(vm, t); + } + t = TAILQ_PREV(bt, vmem_seglist, bt_seglist); + if (t != NULL && t->bt_type == BT_TYPE_FREE) { + MPASS(BT_END(t) < bt->bt_start); /* YYY */ + bt->bt_size += t->bt_size; + bt->bt_start = t->bt_start; + bt_remfree(vm, t); + bt_remseg(vm, t); + } + + t = TAILQ_PREV(bt, vmem_seglist, bt_seglist); + MPASS(t != NULL); + MPASS(BT_ISSPAN_P(t) || t->bt_type == BT_TYPE_BUSY); + if (vm->vm_releasefn != NULL && t->bt_type == BT_TYPE_SPAN && + t->bt_size == bt->bt_size) { + vmem_addr_t spanaddr; + vmem_size_t spansize; + + MPASS(t->bt_start == bt->bt_start); + spanaddr = bt->bt_start; + spansize = bt->bt_size; + bt_remseg(vm, bt); + bt_remseg(vm, t); + vm->vm_size -= spansize; + VMEM_CONDVAR_BROADCAST(vm); + bt_freetrim(vm, BT_MAXFREE); + (*vm->vm_releasefn)(vm->vm_arg, spanaddr, spansize); + } else { + bt_insfree(vm, bt); + VMEM_CONDVAR_BROADCAST(vm); + bt_freetrim(vm, BT_MAXFREE); + } +} + +/* + * vmem_add: + * + */ +int +vmem_add(vmem_t *vm, vmem_addr_t addr, vmem_size_t size, int flags) +{ + int error; + + error = 0; + flags &= VMEM_FLAGS; + VMEM_LOCK(vm); + if (vm->vm_nfreetags >= BT_MAXALLOC || bt_fill(vm, flags) == 0) + vmem_add1(vm, addr, size, flags, BT_TYPE_SPAN_STATIC); + else + error = ENOMEM; + VMEM_UNLOCK(vm); + + return (error); +} + +/* + * vmem_size: information about arenas size + */ +vmem_size_t +vmem_size(vmem_t *vm, int typemask) +{ + + switch (typemask) { + case VMEM_ALLOC: + return vm->vm_inuse; + case VMEM_FREE: + return vm->vm_size - vm->vm_inuse; + case VMEM_FREE|VMEM_ALLOC: + return vm->vm_size; + default: + panic("vmem_size"); + } +} + +/* ---- debug */ + +#if defined(DDB) || defined(DIAGNOSTIC) + +static void bt_dump(const bt_t *, int (*)(const char *, ...) + __printflike(1, 2)); + +static const char * +bt_type_string(int type) +{ + + switch (type) { + case BT_TYPE_BUSY: + return "busy"; + case BT_TYPE_FREE: + return "free"; + case BT_TYPE_SPAN: + return "span"; + case BT_TYPE_SPAN_STATIC: + return "static span"; + default: + break; + } + return "BOGUS"; +} + +static void +bt_dump(const bt_t *bt, int (*pr)(const char *, ...)) +{ + + (*pr)("\t%p: %jx %jx, %d(%s)\n", + bt, (intmax_t)bt->bt_start, (intmax_t)bt->bt_size, + bt->bt_type, bt_type_string(bt->bt_type)); +} + +static void +vmem_dump(const vmem_t *vm , int (*pr)(const char *, ...) __printflike(1, 2)) +{ + const bt_t *bt; + int i; + + (*pr)("vmem %p '%s'\n", vm, vm->vm_name); + TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) { + bt_dump(bt, pr); + } + + for (i = 0; i < VMEM_MAXORDER; i++) { + const struct vmem_freelist *fl = &vm->vm_freelist[i]; + + if (LIST_EMPTY(fl)) { + continue; + } + + (*pr)("freelist[%d]\n", i); + LIST_FOREACH(bt, fl, bt_freelist) { + bt_dump(bt, pr); + } + } +} + +#endif /* defined(DDB) || defined(DIAGNOSTIC) */ + +#if defined(DDB) +static bt_t * +vmem_whatis_lookup(vmem_t *vm, vmem_addr_t addr) +{ + bt_t *bt; + + TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) { + if (BT_ISSPAN_P(bt)) { + continue; + } + if (bt->bt_start <= addr && addr <= BT_END(bt)) { + return bt; + } + } + + return NULL; +} + +void +vmem_whatis(vmem_addr_t addr, int (*pr)(const char *, ...)) +{ + vmem_t *vm; + + LIST_FOREACH(vm, &vmem_list, vm_alllist) { + bt_t *bt; + + bt = vmem_whatis_lookup(vm, addr); + if (bt == NULL) { + continue; + } + (*pr)("%p is %p+%zu in VMEM '%s' (%s)\n", + (void *)addr, (void *)bt->bt_start, + (vmem_size_t)(addr - bt->bt_start), vm->vm_name, + (bt->bt_type == BT_TYPE_BUSY) ? "allocated" : "free"); + } +} + +void +vmem_printall(const char *modif, int (*pr)(const char *, ...)) +{ + const vmem_t *vm; + + LIST_FOREACH(vm, &vmem_list, vm_alllist) { + vmem_dump(vm, pr); + } +} + +void +vmem_print(vmem_addr_t addr, const char *modif, int (*pr)(const char *, ...)) +{ + const vmem_t *vm = (const void *)addr; + + vmem_dump(vm, pr); +} +#endif /* defined(DDB) */ + +#define vmem_printf printf + +#if defined(DIAGNOSTIC) + +static bool +vmem_check_sanity(vmem_t *vm) +{ + const bt_t *bt, *bt2; + + MPASS(vm != NULL); + + TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) { + if (bt->bt_start > BT_END(bt)) { + printf("corrupted tag\n"); + bt_dump(bt, vmem_printf); + return false; + } + } + TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) { + TAILQ_FOREACH(bt2, &vm->vm_seglist, bt_seglist) { + if (bt == bt2) { + continue; + } + if (BT_ISSPAN_P(bt) != BT_ISSPAN_P(bt2)) { + continue; + } + if (bt->bt_start <= BT_END(bt2) && + bt2->bt_start <= BT_END(bt)) { + printf("overwrapped tags\n"); + bt_dump(bt, vmem_printf); + bt_dump(bt2, vmem_printf); + return false; + } + } + } + + return true; +} + +static void +vmem_check(vmem_t *vm) +{ + + if (!vmem_check_sanity(vm)) { + panic("insanity vmem %p", vm); + } +} + +#endif /* defined(DIAGNOSTIC) */ diff --git a/sys/kern/sys_generic.c b/sys/kern/sys_generic.c index 45b9327..44d1a89 100644 --- a/sys/kern/sys_generic.c +++ b/sys/kern/sys_generic.c @@ -1498,6 +1498,62 @@ sys_openbsd_poll(td, uap) } /* + * XXX This was created specifically to support netncp and netsmb. This + * allows the caller to specify a socket to wait for events on. It returns + * 0 if any events matched and an error otherwise. There is no way to + * determine which events fired. + */ +int +selsocket(struct socket *so, int events, struct timeval *tvp, struct thread *td) +{ + struct timeval rtv; + sbintime_t asbt, precision, rsbt; + int error; + + precision = 0; /* stupid gcc! */ + if (tvp != NULL) { + rtv = *tvp; + if (rtv.tv_sec < 0 || rtv.tv_usec < 0 || + rtv.tv_usec >= 1000000) + return (EINVAL); + if (!timevalisset(&rtv)) + asbt = 0; + else if (rtv.tv_sec <= INT32_MAX) { + rsbt = tvtosbt(rtv); + precision = rsbt; + precision >>= tc_precexp; + if (TIMESEL(&asbt, rsbt)) + asbt += tc_tick_sbt; + if (asbt <= INT64_MAX - rsbt) + asbt += rsbt; + else + asbt = -1; + } else + asbt = -1; + } else + asbt = -1; + seltdinit(td); + /* + * Iterate until the timeout expires or the socket becomes ready. + */ + for (;;) { + selfdalloc(td, NULL); + error = sopoll(so, events, NULL, td); + /* error here is actually the ready events. */ + if (error) + return (0); + error = seltdwait(td, asbt, precision); + if (error) + break; + } + seltdclear(td); + /* XXX Duplicates ncp/smb behavior. */ + if (error == ERESTART) + error = 0; + return (error); +} + +/* * Preallocate two selfds associated with 'cookie'. Some fo_poll routines * have two select sets, one for read and another for write. */ diff --git a/sys/kern/uipc_usrreq.c b/sys/kern/uipc_usrreq.c index 5d8e814..7a4db04 100644 --- a/sys/kern/uipc_usrreq.c +++ b/sys/kern/uipc_usrreq.c @@ -1764,8 +1764,8 @@ unp_externalize(struct mbuf *control, struct mbuf **controlp, int flags) } for (i = 0; i < newfds; i++, fdp++) { fde = &fdesc->fd_ofiles[*fdp]; - fde->fde_file = fdep[0]->fde_file; - filecaps_move(&fdep[0]->fde_caps, + fde->fde_file = fdep[i]->fde_file; + filecaps_move(&fdep[i]->fde_caps, &fde->fde_caps); if ((flags & MSG_CMSG_CLOEXEC) != 0) fde->fde_flags |= UF_EXCLOSE; diff --git a/sys/kern/vfs_bio.c b/sys/kern/vfs_bio.c index 767ed30..f6d5a85 100644 --- a/sys/kern/vfs_bio.c +++ b/sys/kern/vfs_bio.c @@ -64,6 +64,7 @@ __FBSDID("$FreeBSD$"); #include <sys/resourcevar.h> #include <sys/rwlock.h> #include <sys/sysctl.h> +#include <sys/vmem.h> #include <sys/vmmeter.h> #include <sys/vnode.h> #include <geom/geom.h> @@ -920,13 +921,13 @@ bfreekva(struct buf *bp) atomic_subtract_long(&bufspace, bp->b_kvasize); if ((bp->b_flags & B_UNMAPPED) == 0) { BUF_CHECK_MAPPED(bp); - vm_map_remove(buffer_map, (vm_offset_t)bp->b_kvabase, - (vm_offset_t)bp->b_kvabase + bp->b_kvasize); + vmem_free(buffer_arena, (vm_offset_t)bp->b_kvabase, + bp->b_kvasize); } else { BUF_CHECK_UNMAPPED(bp); if ((bp->b_flags & B_KVAALLOC) != 0) { - vm_map_remove(buffer_map, (vm_offset_t)bp->b_kvaalloc, - (vm_offset_t)bp->b_kvaalloc + bp->b_kvasize); + vmem_free(buffer_arena, (vm_offset_t)bp->b_kvaalloc, + bp->b_kvasize); } atomic_subtract_long(&unmapped_bufspace, bp->b_kvasize); bp->b_flags &= ~(B_UNMAPPED | B_KVAALLOC); @@ -2019,15 +2020,11 @@ static int allocbufkva(struct buf *bp, int maxsize, int gbflags) { vm_offset_t addr; - int rv; bfreekva(bp); addr = 0; - vm_map_lock(buffer_map); - if (vm_map_findspace(buffer_map, vm_map_min(buffer_map), maxsize, - &addr)) { - vm_map_unlock(buffer_map); + if (vmem_alloc(buffer_arena, maxsize, M_BESTFIT | M_NOWAIT, &addr)) { /* * Buffer map is too fragmented. Request the caller * to defragment the map. @@ -2035,10 +2032,6 @@ allocbufkva(struct buf *bp, int maxsize, int gbflags) atomic_add_int(&bufdefragcnt, 1); return (1); } - rv = vm_map_insert(buffer_map, NULL, 0, addr, addr + maxsize, - VM_PROT_RW, VM_PROT_RW, MAP_NOFAULT); - KASSERT(rv == KERN_SUCCESS, ("vm_map_insert(buffer_map) rv %d", rv)); - vm_map_unlock(buffer_map); setbufkva(bp, addr, maxsize, gbflags); atomic_add_long(&bufspace, bp->b_kvasize); return (0); @@ -2389,7 +2382,7 @@ restart: * We block if: * We have insufficient buffer headers * We have insufficient buffer space - * buffer_map is too fragmented ( space reservation fails ) + * buffer_arena is too fragmented ( space reservation fails ) * If we have to flush dirty buffers ( but we try to avoid this ) */ static struct buf * @@ -3593,7 +3586,7 @@ biodone(struct bio *bp) done(bp); if (transient) { pmap_qremove(start, OFF_TO_IDX(end - start)); - vm_map_remove(bio_transient_map, start, end); + vmem_free(transient_arena, start, end - start); atomic_add_int(&inflight_transient_maps, -1); } } diff --git a/sys/mips/conf/AP93.hints b/sys/mips/conf/AP93.hints index 22be50f..da4c320 100644 --- a/sys/mips/conf/AP93.hints +++ b/sys/mips/conf/AP93.hints @@ -36,6 +36,9 @@ hint.arswitch.0.is_gmii=0 # No, not GMII hint.pcib.0.bus.0.0.0.ath_fixup_addr=0x1fff1000 hint.pcib.0.bus.0.0.0.ath_fixup_size=4096 +# ath0 - eeprom comes from here +hint.ath.0.eeprom_firmware="pcib.0.bus.0.0.0.eeprom_firmware" + # Signal leds hint.gpioled.0.at="gpiobus0" hint.gpioled.0.name="sig1" diff --git a/sys/mips/conf/ENH200 b/sys/mips/conf/ENH200 new file mode 100644 index 0000000..886397f --- /dev/null +++ b/sys/mips/conf/ENH200 @@ -0,0 +1,44 @@ +# +# Specific board setup for the Engenius ENH-200 802.11bgn mesh node. +# +# The Engenius ENH-200 has the following hardware: +# +# + AR7240 CPU SoC +# + AR9285 Wifi +# + Integrated switch +# + 8MB flash +# + 32MB RAM +# + uboot environment + +# $FreeBSD$ + +include "AR724X_BASE" +ident "ENH200" +hints "ENH200.hints" + +options AR71XX_REALMEM=32*1024*1024 + +options AR71XX_ENV_UBOOT + +# For DOS - enable if required +options MSDOSFS + +# uncompress - to boot read-only lzma natively from flash +device geom_uncompress +options GEOM_UNCOMPRESS +options ROOTDEVNAME=\"ufs:/dev/map/rootfs.uncompress\" + +# Used for the static uboot partition map +device geom_map + +# Options needed for the EEPROM based calibration/PCI configuration data. +options AR71XX_ATH_EEPROM # Fetch EEPROM/PCI config from flash +options ATH_EEPROM_FIRMWARE # Use EEPROM from flash +device firmware # Used by the above + +# Options required for miiproxy and mdiobus +options ARGE_MDIO # Export an MDIO bus separate from arge +device miiproxy # MDIO bus <-> MII PHY rendezvous + +device etherswitch +device arswitch diff --git a/sys/mips/conf/ENH200.hints b/sys/mips/conf/ENH200.hints new file mode 100644 index 0000000..347c04e --- /dev/null +++ b/sys/mips/conf/ENH200.hints @@ -0,0 +1,124 @@ +# $FreeBSD$ + +# arge0 MDIO bus +hint.argemdio.0.at="nexus0" +hint.argemdio.0.maddr=0x19000000 +hint.argemdio.0.msize=0x1000 +hint.argemdio.0.order=0 + +# arge1 MDIO bus doesn't exist on the AR7240 + +# arge0: MII; dedicated PHY 4 on switch, connected via internal switch +# MDIO bus. + +# hint.arge.0.eeprommac=0x83fe9ff0 +hint.arge.0.phymask=0x10 # PHY 4 +# hint.arge.0.miimode=2 # MII +hint.arge.0.mdio=mdioproxy1 # Hanging off the arswitch MDIO bus + +# arge1: connected to the LAN switch MAC, at 1000BaseTX / GMII. +hint.arge.1.phymask=0x0 +# hint.arge.1.miimode=1 # GMII +hint.arge.1.media=1000 # Force to 1000BaseTX/full +hint.arge.1.fduplex=1 + +# +# AR7240 switch config +# +hint.arswitch.0.at="mdio0" +hint.arswitch.0.is_7240=1 # We need to be explicitly told this +hint.arswitch.0.numphys=4 # 4 active switch PHYs (PHY 0 -> 3) +hint.arswitch.0.phy4cpu=1 # Yes, PHY 4 == dedicated PHY +hint.arswitch.0.is_rgmii=0 # No, not RGMII +hint.arswitch.0.is_gmii=0 # No, not GMII + +# ath0 hint - pcie slot 0 +hint.pcib.0.bus.0.0.0.ath_fixup_addr=0x1fff1000 +hint.pcib.0.bus.0.0.0.ath_fixup_size=4096 + +# ath0 - eeprom comes from here +hint.ath.0.eeprom_firmware="pcib.0.bus.0.0.0.eeprom_firmware" + +# Signal leds +hint.gpioled.0.at="gpiobus0" +hint.gpioled.0.name="sig1" +hint.gpioled.0.pins=0x0001 # pin 0 +hint.gpioled.1.at="gpiobus0" +hint.gpioled.1.name="sig2" +hint.gpioled.1.pins=0x0002 # pin 1 +hint.gpioled.2.at="gpiobus0" +hint.gpioled.2.name="sig3" +hint.gpioled.2.pins=0x0800 # pin 11 +hint.gpioled.3.at="gpiobus0" +hint.gpioled.3.name="sig4" +hint.gpioled.3.pins=0x0080 # pin 7 + +# nvram mapping - XXX ? +#hint.nvram.0.base=0x1f030000 +#hint.nvram.0.maxsize=0x2000 +#hint.nvram.0.flags=3 # 1 = No check, 2 = Format Generic +#hint.nvram.1.base=0x1f032000 +#hint.nvram.1.maxsize=0x4000 +#hint.nvram.1.flags=3 # 1 = No check, 2 = Format Generic + +# GEOM_MAP +# +# The default bootargs: +# +# bootargs=console=ttyS0,115200 root=31:04 rootfstype=squashfs init=/etc/preinit mtdparts=ar7240-nor0:256k(u-boot),64k(u-boot-env),320k(custom),1024k(kernel),4928k(rootfs),1536k(failsafe),64k(ART) board=ENH200 +# +# However there's not a lot of space in this image layout. +# +# Thus, an alternate layout will be used, complete with reconfiguring +# uboot to use the new base address. +# +# 256k - uboot (0x000000 -> 0x040000) +# 64k - uboot-env (0x040000 -> 0x050000) +# 1728k - kernel (0x050000 -> 0x200000) +# 6016k - rootfs (0x200000 -> 0x7e0000) +# 64k - config (0x7e0000 -> 0x7f0000) +# 64k - ART (0x7f0000 -> 0x800000) +# +# For this, the 'bootcmd' environment variable needs to be +# changed to point to the new location: +# +# ar7240> setenv bootcmd 'bootm 0x9f050000' + +# uboot (256k) +hint.map.0.at="flash/spi0" +hint.map.0.start=0x00000000 +hint.map.0.end=0x00040000 +hint.map.0.name="uboot" +hint.map.0.readonly=1 + +# uboot-env (64k) +hint.map.1.at="flash/spi0" +hint.map.1.start=0x00040000 +hint.map.1.end=0x00050000 +hint.map.1.name="uboot-env" +hint.map.1.readonly=1 + +# kernel (1728k) +hint.map.2.at="flash/spi0" +hint.map.2.start=0x00050000 +hint.map.2.end=0x00200000 +hint.map.2.name="kernel" + +# rootfs (6016k) +hint.map.3.at="flash/spi0" +hint.map.3.start=0x00200000 +hint.map.3.end=0x007e0000 +hint.map.3.name="rootfs" + +# config (64k) +hint.map.4.at="flash/spi0" +hint.map.4.start=0x007e0000 +hint.map.4.end=0x007f0000 +hint.map.4.name="cfg" + +# ART (64k) +hint.map.5.at="flash/spi0" +hint.map.5.start=0x007f0000 +hint.map.5.end=0x00800000 +hint.map.5.name="ART" +hint.map.5.readonly=1 diff --git a/sys/mips/include/counter.h b/sys/mips/include/counter.h index 68f89e2..193c98e 100644 --- a/sys/mips/include/counter.h +++ b/sys/mips/include/counter.h @@ -37,6 +37,46 @@ #define counter_enter() critical_enter() #define counter_exit() critical_exit() +#ifdef IN_SUBR_COUNTER_C +/* XXXKIB non-atomic 64bit read on 32bit */ +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +/* XXXKIB non-atomic 64bit store on 32bit, might interrupt increment */ +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, inc) do { \ CRITICAL_ASSERT(curthread); \ *(uint64_t *)zpcpu_get(c) += (inc); \ diff --git a/sys/modules/Makefile b/sys/modules/Makefile index ac620d3..8f58ed0 100644 --- a/sys/modules/Makefile +++ b/sys/modules/Makefile @@ -81,7 +81,7 @@ SUBDIR= \ ${_ctau} \ ctl \ ${_cxgb} \ - cxgbe \ + ${_cxgbe} \ ${_cyclic} \ dc \ dcons \ @@ -302,6 +302,7 @@ SUBDIR= \ siis \ sis \ sk \ + ${_smbfs} \ ${_sn} \ ${_snc} \ snp \ @@ -386,6 +387,10 @@ _cxgb= cxgb .endif .endif +.if ${MK_SOURCELESS_UCODE} != "no" +_cxgbe= cxgbe +.endif + .if ${MK_CRYPT} != "no" || defined(ALL_MODULES) .if exists(${.CURDIR}/../opencrypto) _crypto= crypto @@ -521,6 +526,7 @@ _rdma= rdma _safe= safe _sbni= sbni _scsi_low= scsi_low +_smbfs= smbfs _sound= sound _speaker= speaker _splash= splash @@ -724,6 +730,7 @@ _s3= s3 _safe= safe _scsi_low= scsi_low _sfxge= sfxge +_smbfs= smbfs _sound= sound _speaker= speaker _splash= splash @@ -781,6 +788,7 @@ _ips= ips _mly= mly _pccard= pccard _scsi_low= scsi_low +_smbfs= smbfs _sound= sound _splash= splash _sppp= sppp @@ -803,6 +811,7 @@ _drm= drm _exca= exca _nvram= powermac_nvram _pccard= pccard +_smbfs= smbfs _sound= sound _cyclic= cyclic _dtrace= dtrace @@ -829,6 +838,7 @@ _igb= igb .if ${MK_CDDL} != "no" || defined(ALL_MODULES) _opensolaris= opensolaris .endif +_smbfs= smbfs _sound= sound .if ${MK_ZFS} != "no" || defined(ALL_MODULES) _zfs= zfs diff --git a/sys/modules/cc/Makefile b/sys/modules/cc/Makefile index e3e8336..7b851f5 100644 --- a/sys/modules/cc/Makefile +++ b/sys/modules/cc/Makefile @@ -1,6 +1,7 @@ # $FreeBSD$ -SUBDIR= cc_chd \ +SUBDIR= cc_cdg \ + cc_chd \ cc_cubic \ cc_hd \ cc_htcp \ diff --git a/sys/modules/cc/cc_cdg/Makefile b/sys/modules/cc/cc_cdg/Makefile new file mode 100644 index 0000000..bc6f62d --- /dev/null +++ b/sys/modules/cc/cc_cdg/Makefile @@ -0,0 +1,9 @@ +# $FreeBSD$ + +.include <bsd.own.mk> + +.PATH: ${.CURDIR}/../../../netinet/cc +KMOD= cc_cdg +SRCS= cc_cdg.c + +.include <bsd.kmod.mk> diff --git a/sys/modules/cxgbe/Makefile b/sys/modules/cxgbe/Makefile index 2f848b6..fb75485 100644 --- a/sys/modules/cxgbe/Makefile +++ b/sys/modules/cxgbe/Makefile @@ -4,7 +4,7 @@ SUBDIR = if_cxgbe SUBDIR+= t4_firmware -#SUBDIR+= t5_firmware +SUBDIR+= t5_firmware SUBDIR+= ${_tom} .if ${MACHINE_CPUARCH} == "amd64" || ${MACHINE_CPUARCH} == "i386" diff --git a/sys/modules/cxgbe/t4_firmware/Makefile b/sys/modules/cxgbe/t4_firmware/Makefile index fea29a5..d5b86d1 100644 --- a/sys/modules/cxgbe/t4_firmware/Makefile +++ b/sys/modules/cxgbe/t4_firmware/Makefile @@ -17,7 +17,7 @@ FIRMWS += ${F}:${F:C/.txt//}:1.0.0.0 .endif .endfor -T4FW_VER = 1.8.4.0 +T4FW_VER = 1.8.11.0 FIRMWS += t4fw.fw:t4fw:${T4FW_VER} CLEANFILES += t4fw.fw diff --git a/sys/modules/cxgbe/t5_firmware/Makefile b/sys/modules/cxgbe/t5_firmware/Makefile new file mode 100644 index 0000000..6637b22 --- /dev/null +++ b/sys/modules/cxgbe/t5_firmware/Makefile @@ -0,0 +1,27 @@ +# +# $FreeBSD$ +# + +T5FW = ${.CURDIR}/../../../dev/cxgbe/firmware +.PATH: ${T5FW} + +KMOD = t5fw_cfg +FIRMWS = ${KMOD}.txt:${KMOD}:1.0.0.0 + +# You can have additional configuration files in the ${T5FW} directory. +# t5fw_cfg_<name>.txt +CFG_FILES != cd ${T5FW} && echo ${KMOD}_*.txt +.for F in ${CFG_FILES} +.if exists(${F}) +FIRMWS += ${F}:${F:C/.txt//}:1.0.0.0 +.endif +.endfor + +T5FW_VER = 1.8.22.0 +FIRMWS += t5fw.fw:t5fw:${T5FW_VER} +CLEANFILES += t5fw.fw + +t5fw.fw: t5fw-${T5FW_VER}.bin.uu + uudecode -o ${.TARGET} ${.ALLSRC} + +.include <bsd.kmod.mk> diff --git a/sys/net/if_bridge.c b/sys/net/if_bridge.c index bc9bda09..b33696f 100644 --- a/sys/net/if_bridge.c +++ b/sys/net/if_bridge.c @@ -118,6 +118,7 @@ __FBSDID("$FreeBSD$"); #ifdef INET6 #include <netinet/ip6.h> #include <netinet6/ip6_var.h> +#include <netinet6/in6_ifattach.h> #endif #if defined(INET) || defined(INET6) #include <netinet/ip_carp.h> @@ -1041,14 +1042,6 @@ bridge_ioctl_add(struct bridge_softc *sc, void *arg) if (ifs->if_bridge != NULL) return (EBUSY); - bif = malloc(sizeof(*bif), M_DEVBUF, M_NOWAIT|M_ZERO); - if (bif == NULL) - return (ENOMEM); - - bif->bif_ifp = ifs; - bif->bif_flags = IFBIF_LEARNING | IFBIF_DISCOVER; - bif->bif_savedcaps = ifs->if_capenable; - switch (ifs->if_type) { case IFT_ETHER: case IFT_L2VLAN: @@ -1056,20 +1049,95 @@ bridge_ioctl_add(struct bridge_softc *sc, void *arg) /* permitted interface types */ break; default: - error = EINVAL; - goto out; + return (EINVAL); } +#ifdef INET6 + /* + * Two valid inet6 addresses with link-local scope must not be + * on the parent interface and the member interfaces at the + * same time. This restriction is needed to prevent violation + * of link-local scope zone. Attempts to add a member + * interface which has inet6 addresses when the parent has + * inet6 triggers removal of all inet6 addresses on the member + * interface. + */ + + /* Check if the parent interface has a link-local scope addr. */ + if (in6ifa_llaonifp(sc->sc_ifp) != NULL) { + /* + * If any, remove all inet6 addresses from the member + * interfaces. + */ + BRIDGE_XLOCK(sc); + LIST_FOREACH(bif, &sc->sc_iflist, bif_next) { + if (in6ifa_llaonifp(bif->bif_ifp)) { + BRIDGE_UNLOCK(sc); + in6_ifdetach(bif->bif_ifp); + BRIDGE_LOCK(sc); + if_printf(sc->sc_ifp, + "IPv6 addresses on %s have been removed " + "before adding it as a member to prevent " + "IPv6 address scope violation.\n", + bif->bif_ifp->if_xname); + } + } + BRIDGE_XDROP(sc); + if (in6ifa_llaonifp(ifs)) { + BRIDGE_UNLOCK(sc); + in6_ifdetach(ifs); + BRIDGE_LOCK(sc); + if_printf(sc->sc_ifp, + "IPv6 addresses on %s have been removed " + "before adding it as a member to prevent " + "IPv6 address scope violation.\n", + ifs->if_xname); + } + } else { + struct in6_ifaddr *ia6_m, *ia6_s; + /* + * If not, check whether one of the existing member + * interfaces have inet6 address. If any, remove + * inet6 addresses on the interface to be added. + */ + ia6_m = NULL; + BRIDGE_XLOCK(sc); + LIST_FOREACH(bif, &sc->sc_iflist, bif_next) { + ia6_m = in6ifa_llaonifp(bif->bif_ifp); + if (ia6_m != NULL) + break; + } + BRIDGE_XDROP(sc); + ia6_s = in6ifa_llaonifp(ifs); + + if (ia6_m != NULL && ia6_s != NULL) { + BRIDGE_UNLOCK(sc); + in6_ifdetach(ifs); + BRIDGE_LOCK(sc); + if_printf(sc->sc_ifp, "IPv6 addresses on %s have " + "been removed before adding it as a member " + "to prevent IPv6 address scope violation.\n", + ifs->if_xname); + } + } +#endif /* Allow the first Ethernet member to define the MTU */ if (LIST_EMPTY(&sc->sc_iflist)) sc->sc_ifp->if_mtu = ifs->if_mtu; else if (sc->sc_ifp->if_mtu != ifs->if_mtu) { if_printf(sc->sc_ifp, "invalid MTU: %lu(%s) != %lu\n", ifs->if_mtu, ifs->if_xname, sc->sc_ifp->if_mtu); - error = EINVAL; - goto out; + return (EINVAL); } + bif = malloc(sizeof(*bif), M_DEVBUF, M_NOWAIT|M_ZERO); + if (bif == NULL) + return (ENOMEM); + + bif->bif_ifp = ifs; + bif->bif_flags = IFBIF_LEARNING | IFBIF_DISCOVER; + bif->bif_savedcaps = ifs->if_capenable; + /* * Assign the interface's MAC address to the bridge if it's the first * member and the MAC address of the bridge has not been changed from @@ -1104,12 +1172,10 @@ bridge_ioctl_add(struct bridge_softc *sc, void *arg) BRIDGE_LOCK(sc); break; } - if (error) - bridge_delete_member(sc, bif, 0); -out: + if (error) { - if (bif != NULL) - free(bif, M_DEVBUF); + bridge_delete_member(sc, bif, 0); + free(bif, M_DEVBUF); } return (error); } @@ -3408,7 +3474,7 @@ bridge_fragment(struct ifnet *ifp, struct mbuf *m, struct ether_header *eh, continue; } bcopy(eh, mtod(m0, caddr_t), ETHER_HDR_LEN); - } else + } else m_freem(m); } diff --git a/sys/net/if_lagg.c b/sys/net/if_lagg.c index 11273b2..9867c97 100644 --- a/sys/net/if_lagg.c +++ b/sys/net/if_lagg.c @@ -63,6 +63,8 @@ __FBSDID("$FreeBSD$"); #ifdef INET6 #include <netinet/ip6.h> +#include <netinet6/in6_var.h> +#include <netinet6/in6_ifattach.h> #endif #include <net/if_vlan_var.h> @@ -543,6 +545,34 @@ lagg_port_create(struct lagg_softc *sc, struct ifnet *ifp) if (ifp->if_type != IFT_ETHER) return (EPROTONOSUPPORT); +#ifdef INET6 + /* + * The member interface should not have inet6 address because + * two interfaces with a valid link-local scope zone must not be + * merged in any form. This restriction is needed to + * prevent violation of link-local scope zone. Attempts to + * add a member interface which has inet6 addresses triggers + * removal of all inet6 addresses on the member interface. + */ + SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { + if (in6ifa_llaonifp(lp->lp_ifp)) { + in6_ifdetach(lp->lp_ifp); + if_printf(sc->sc_ifp, + "IPv6 addresses on %s have been removed " + "before adding it as a member to prevent " + "IPv6 address scope violation.\n", + lp->lp_ifp->if_xname); + } + } + if (in6ifa_llaonifp(ifp)) { + in6_ifdetach(ifp); + if_printf(sc->sc_ifp, + "IPv6 addresses on %s have been removed " + "before adding it as a member to prevent " + "IPv6 address scope violation.\n", + ifp->if_xname); + } +#endif /* Allow the first Ethernet member to define the MTU */ if (SLIST_EMPTY(&sc->sc_ports)) sc->sc_ifp->if_mtu = ifp->if_mtu; diff --git a/sys/net80211/ieee80211_amrr.c b/sys/net80211/ieee80211_amrr.c index 73dd901..003b4bc 100644 --- a/sys/net80211/ieee80211_amrr.c +++ b/sys/net80211/ieee80211_amrr.c @@ -46,6 +46,7 @@ __FBSDID("$FreeBSD$"); #endif #include <net80211/ieee80211_var.h> +#include <net80211/ieee80211_ht.h> #include <net80211/ieee80211_amrr.h> #include <net80211/ieee80211_ratectl.h> @@ -128,13 +129,25 @@ amrr_deinit(struct ieee80211vap *vap) free(vap->iv_rs, M_80211_RATECTL); } +static int +amrr_node_is_11n(struct ieee80211_node *ni) +{ + + if (ni->ni_chan == NULL) + return (0); + if (ni->ni_chan == IEEE80211_CHAN_ANYC) + return (0); + return (IEEE80211_IS_CHAN_HT(ni->ni_chan)); +} + static void amrr_node_init(struct ieee80211_node *ni) { - const struct ieee80211_rateset *rs = &ni->ni_rates; + const struct ieee80211_rateset *rs = NULL; struct ieee80211vap *vap = ni->ni_vap; struct ieee80211_amrr *amrr = vap->iv_rs; struct ieee80211_amrr_node *amn; + uint8_t rate; if (ni->ni_rctls == NULL) { ni->ni_rctls = amn = malloc(sizeof(struct ieee80211_amrr_node), @@ -152,16 +165,50 @@ amrr_node_init(struct ieee80211_node *ni) amn->amn_txcnt = amn->amn_retrycnt = 0; amn->amn_success_threshold = amrr->amrr_min_success_threshold; - /* pick initial rate */ - for (amn->amn_rix = rs->rs_nrates - 1; - amn->amn_rix > 0 && (rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL) > 72; - amn->amn_rix--) - ; - ni->ni_txrate = rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL; + /* 11n or not? Pick the right rateset */ + if (amrr_node_is_11n(ni)) { + /* XXX ew */ + IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, + "%s: 11n node", __func__); + rs = (struct ieee80211_rateset *) &ni->ni_htrates; + } else { + IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, + "%s: non-11n node", __func__); + rs = &ni->ni_rates; + } + + /* Initial rate - lowest */ + rate = rs->rs_rates[0]; + + /* XXX clear the basic rate flag if it's not 11n */ + if (! amrr_node_is_11n(ni)) + rate &= IEEE80211_RATE_VAL; + + /* pick initial rate from the rateset - HT or otherwise */ + for (amn->amn_rix = rs->rs_nrates - 1; amn->amn_rix > 0; + amn->amn_rix--) { + /* legacy - anything < 36mbit, stop searching */ + /* 11n - stop at MCS4 / MCS12 / MCS28 */ + if (amrr_node_is_11n(ni) && + (rs->rs_rates[amn->amn_rix] & 0x7) < 4) + break; + else if ((rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL) <= 72) + break; + rate = rs->rs_rates[amn->amn_rix] & IEEE80211_RATE_VAL; + } + + /* if the rate is an 11n rate, ensure the MCS bit is set */ + if (amrr_node_is_11n(ni)) + rate |= IEEE80211_RATE_MCS; + + /* Assign initial rate from the rateset */ + ni->ni_txrate = rate; amn->amn_ticks = ticks; IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, - "AMRR initial rate %d", ni->ni_txrate); + "AMRR: nrates=%d, initial rate %d", + rs->rs_nrates, + rate); } static void @@ -175,19 +222,42 @@ amrr_update(struct ieee80211_amrr *amrr, struct ieee80211_amrr_node *amn, struct ieee80211_node *ni) { int rix = amn->amn_rix; + const struct ieee80211_rateset *rs = NULL; KASSERT(is_enough(amn), ("txcnt %d", amn->amn_txcnt)); + /* 11n or not? Pick the right rateset */ + if (amrr_node_is_11n(ni)) { + /* XXX ew */ + rs = (struct ieee80211_rateset *) &ni->ni_htrates; + } else { + rs = &ni->ni_rates; + } + + IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, + "AMRR: current rate %d, txcnt=%d, retrycnt=%d", + rs->rs_rates[rix] & IEEE80211_RATE_VAL, + amn->amn_txcnt, + amn->amn_retrycnt); + + /* + * XXX This is totally bogus for 11n, as although high MCS + * rates for each stream may be failing, the next stream + * should be checked. + * + * Eg, if MCS5 is ok but MCS6/7 isn't, and we can go up to + * MCS23, we should skip 6/7 and try 8 onwards. + */ if (is_success(amn)) { amn->amn_success++; if (amn->amn_success >= amn->amn_success_threshold && - rix + 1 < ni->ni_rates.rs_nrates) { + rix + 1 < rs->rs_nrates) { amn->amn_recovery = 1; amn->amn_success = 0; rix++; IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, "AMRR increasing rate %d (txcnt=%d retrycnt=%d)", - ni->ni_rates.rs_rates[rix] & IEEE80211_RATE_VAL, + rs->rs_rates[rix] & IEEE80211_RATE_VAL, amn->amn_txcnt, amn->amn_retrycnt); } else { amn->amn_recovery = 0; @@ -208,7 +278,7 @@ amrr_update(struct ieee80211_amrr *amrr, struct ieee80211_amrr_node *amn, rix--; IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, "AMRR decreasing rate %d (txcnt=%d retrycnt=%d)", - ni->ni_rates.rs_rates[rix] & IEEE80211_RATE_VAL, + rs->rs_rates[rix] & IEEE80211_RATE_VAL, amn->amn_txcnt, amn->amn_retrycnt); } amn->amn_recovery = 0; @@ -231,14 +301,27 @@ amrr_rate(struct ieee80211_node *ni, void *arg __unused, uint32_t iarg __unused) { struct ieee80211_amrr_node *amn = ni->ni_rctls; struct ieee80211_amrr *amrr = amn->amn_amrr; + const struct ieee80211_rateset *rs = NULL; int rix; + /* 11n or not? Pick the right rateset */ + if (amrr_node_is_11n(ni)) { + /* XXX ew */ + rs = (struct ieee80211_rateset *) &ni->ni_htrates; + } else { + rs = &ni->ni_rates; + } + if (is_enough(amn) && (ticks - amn->amn_ticks) > amrr->amrr_interval) { rix = amrr_update(amrr, amn, ni); if (rix != amn->amn_rix) { /* update public rate */ - ni->ni_txrate = - ni->ni_rates.rs_rates[rix] & IEEE80211_RATE_VAL; + ni->ni_txrate = rs->rs_rates[rix]; + /* XXX strip basic rate flag from txrate, if non-11n */ + if (amrr_node_is_11n(ni)) + ni->ni_txrate |= IEEE80211_RATE_MCS; + else + ni->ni_txrate &= IEEE80211_RATE_VAL; amn->amn_rix = rix; } amn->amn_ticks = ticks; diff --git a/sys/net80211/ieee80211_ioctl.c b/sys/net80211/ieee80211_ioctl.c index 9f58754..6b668cb 100644 --- a/sys/net80211/ieee80211_ioctl.c +++ b/sys/net80211/ieee80211_ioctl.c @@ -1589,7 +1589,9 @@ ieee80211_ioctl_setmlme(struct ieee80211vap *vap, struct ieee80211req *ireq) mlme.im_op == IEEE80211_MLME_ASSOC) return setmlme_assoc_sta(vap, mlme.im_macaddr, vap->iv_des_ssid[0].len, vap->iv_des_ssid[0].ssid); - else if (mlme.im_op == IEEE80211_MLME_ASSOC) + else if ((vap->iv_opmode == IEEE80211_M_IBSS || + vap->iv_opmode == IEEE80211_M_AHDEMO) && + mlme.im_op == IEEE80211_MLME_ASSOC) return setmlme_assoc_adhoc(vap, mlme.im_macaddr, mlme.im_ssid_len, mlme.im_ssid); else diff --git a/sys/net80211/ieee80211_phy.c b/sys/net80211/ieee80211_phy.c index d2ad60d..d1924d8 100644 --- a/sys/net80211/ieee80211_phy.c +++ b/sys/net80211/ieee80211_phy.c @@ -60,8 +60,11 @@ struct ieee80211_ds_plcp_hdr { #define TURBO IEEE80211_T_TURBO #define HALF IEEE80211_T_OFDM_HALF #define QUART IEEE80211_T_OFDM_QUARTER +#define HT IEEE80211_T_HT +/* XXX the 11n and the basic rate flag are unfortunately overlapping. Grr. */ +#define N(r) (IEEE80211_RATE_MCS | r) #define PBCC (IEEE80211_T_OFDM_QUARTER+1) /* XXX */ -#define B(r) (0x80 | r) +#define B(r) (IEEE80211_RATE_BASIC | r) #define Mb(x) (x*1000) static struct ieee80211_rate_table ieee80211_11b_table = { @@ -176,6 +179,98 @@ static struct ieee80211_rate_table ieee80211_turboa_table = { }, }; +static struct ieee80211_rate_table ieee80211_11ng_table = { + .rateCount = 36, + .info = { +/* short ctrl */ +/* Preamble dot11Rate Rate */ + [0] = { .phy = CCK, 1000, 0x00, B(2), 0 }, + [1] = { .phy = CCK, 2000, 0x04, B(4), 1 }, + [2] = { .phy = CCK, 5500, 0x04, B(11), 2 }, + [3] = { .phy = CCK, 11000, 0x04, B(22), 3 }, + [4] = { .phy = OFDM, 6000, 0x00, 12, 4 }, + [5] = { .phy = OFDM, 9000, 0x00, 18, 4 }, + [6] = { .phy = OFDM, 12000, 0x00, 24, 6 }, + [7] = { .phy = OFDM, 18000, 0x00, 36, 6 }, + [8] = { .phy = OFDM, 24000, 0x00, 48, 8 }, + [9] = { .phy = OFDM, 36000, 0x00, 72, 8 }, + [10] = { .phy = OFDM, 48000, 0x00, 96, 8 }, + [11] = { .phy = OFDM, 54000, 0x00, 108, 8 }, + + [12] = { .phy = HT, 6500, 0x00, N(0), 4 }, + [13] = { .phy = HT, 13000, 0x00, N(1), 6 }, + [14] = { .phy = HT, 19500, 0x00, N(2), 6 }, + [15] = { .phy = HT, 26000, 0x00, N(3), 8 }, + [16] = { .phy = HT, 39000, 0x00, N(4), 8 }, + [17] = { .phy = HT, 52000, 0x00, N(5), 8 }, + [18] = { .phy = HT, 58500, 0x00, N(6), 8 }, + [19] = { .phy = HT, 65000, 0x00, N(7), 8 }, + + [20] = { .phy = HT, 13000, 0x00, N(8), 4 }, + [21] = { .phy = HT, 26000, 0x00, N(9), 6 }, + [22] = { .phy = HT, 39000, 0x00, N(10), 6 }, + [23] = { .phy = HT, 52000, 0x00, N(11), 8 }, + [24] = { .phy = HT, 78000, 0x00, N(12), 8 }, + [25] = { .phy = HT, 104000, 0x00, N(13), 8 }, + [26] = { .phy = HT, 117000, 0x00, N(14), 8 }, + [27] = { .phy = HT, 130000, 0x00, N(15), 8 }, + + [28] = { .phy = HT, 19500, 0x00, N(16), 4 }, + [29] = { .phy = HT, 39000, 0x00, N(17), 6 }, + [30] = { .phy = HT, 58500, 0x00, N(18), 6 }, + [31] = { .phy = HT, 78000, 0x00, N(19), 8 }, + [32] = { .phy = HT, 117000, 0x00, N(20), 8 }, + [33] = { .phy = HT, 156000, 0x00, N(21), 8 }, + [34] = { .phy = HT, 175500, 0x00, N(22), 8 }, + [35] = { .phy = HT, 195000, 0x00, N(23), 8 }, + + }, +}; + +static struct ieee80211_rate_table ieee80211_11na_table = { + .rateCount = 32, + .info = { +/* short ctrl */ +/* Preamble dot11Rate Rate */ + [0] = { .phy = OFDM, 6000, 0x00, B(12), 0 }, + [1] = { .phy = OFDM, 9000, 0x00, 18, 0 }, + [2] = { .phy = OFDM, 12000, 0x00, B(24), 2 }, + [3] = { .phy = OFDM, 18000, 0x00, 36, 2 }, + [4] = { .phy = OFDM, 24000, 0x00, B(48), 4 }, + [5] = { .phy = OFDM, 36000, 0x00, 72, 4 }, + [6] = { .phy = OFDM, 48000, 0x00, 96, 4 }, + [7] = { .phy = OFDM, 54000, 0x00, 108, 4 }, + + [8] = { .phy = HT, 6500, 0x00, N(0), 0 }, + [9] = { .phy = HT, 13000, 0x00, N(1), 2 }, + [10] = { .phy = HT, 19500, 0x00, N(2), 2 }, + [11] = { .phy = HT, 26000, 0x00, N(3), 4 }, + [12] = { .phy = HT, 39000, 0x00, N(4), 4 }, + [13] = { .phy = HT, 52000, 0x00, N(5), 4 }, + [14] = { .phy = HT, 58500, 0x00, N(6), 4 }, + [15] = { .phy = HT, 65000, 0x00, N(7), 4 }, + + [16] = { .phy = HT, 13000, 0x00, N(8), 0 }, + [17] = { .phy = HT, 26000, 0x00, N(9), 2 }, + [18] = { .phy = HT, 39000, 0x00, N(10), 2 }, + [19] = { .phy = HT, 52000, 0x00, N(11), 4 }, + [20] = { .phy = HT, 78000, 0x00, N(12), 4 }, + [21] = { .phy = HT, 104000, 0x00, N(13), 4 }, + [22] = { .phy = HT, 117000, 0x00, N(14), 4 }, + [23] = { .phy = HT, 130000, 0x00, N(15), 4 }, + + [24] = { .phy = HT, 19500, 0x00, N(16), 0 }, + [25] = { .phy = HT, 39000, 0x00, N(17), 2 }, + [26] = { .phy = HT, 58500, 0x00, N(18), 2 }, + [27] = { .phy = HT, 78000, 0x00, N(19), 4 }, + [28] = { .phy = HT, 117000, 0x00, N(20), 4 }, + [29] = { .phy = HT, 156000, 0x00, N(21), 4 }, + [30] = { .phy = HT, 175500, 0x00, N(22), 4 }, + [31] = { .phy = HT, 195000, 0x00, N(23), 4 }, + + }, +}; + #undef Mb #undef B #undef OFDM @@ -184,6 +279,8 @@ static struct ieee80211_rate_table ieee80211_turboa_table = { #undef CCK #undef TURBO #undef XR +#undef HT +#undef N /* * Setup a rate table's reverse lookup table and fill in @@ -210,15 +307,23 @@ ieee80211_setup_ratetable(struct ieee80211_rate_table *rt) uint8_t cix = rt->info[i].ctlRateIndex; uint8_t ctl_rate = rt->info[cix].dot11Rate; - rt->rateCodeToIndex[code] = i; - if (code & IEEE80211_RATE_BASIC) { - /* - * Map w/o basic rate bit too. - */ - code &= IEEE80211_RATE_VAL; - rt->rateCodeToIndex[code] = i; + /* + * Map without the basic rate bit. + * + * It's up to the caller to ensure that the basic + * rate bit is stripped here. + * + * For HT, use the MCS rate bit. + */ + code &= IEEE80211_RATE_VAL; + if (rt->info[i].phy == IEEE80211_T_HT) { + code |= IEEE80211_RATE_MCS; } + /* XXX assume the control rate is non-MCS? */ + ctl_rate &= IEEE80211_RATE_VAL; + rt->rateCodeToIndex[code] = i; + /* * XXX for 11g the control rate to use for 5.5 and 11 Mb/s * depends on whether they are marked as basic rates; @@ -247,11 +352,10 @@ ieee80211_phy_init(void) static struct ieee80211_rate_table * const ratetables[] = { &ieee80211_half_table, &ieee80211_quarter_table, - &ieee80211_11a_table, - &ieee80211_11g_table, + &ieee80211_11na_table, + &ieee80211_11ng_table, &ieee80211_turbog_table, &ieee80211_turboa_table, - &ieee80211_turboa_table, &ieee80211_11a_table, &ieee80211_11g_table, &ieee80211_11b_table @@ -276,9 +380,9 @@ ieee80211_get_ratetable(struct ieee80211_channel *c) else if (IEEE80211_IS_CHAN_QUARTER(c)) rt = &ieee80211_quarter_table; else if (IEEE80211_IS_CHAN_HTA(c)) - rt = &ieee80211_11a_table; /* XXX */ + rt = &ieee80211_11na_table; else if (IEEE80211_IS_CHAN_HTG(c)) - rt = &ieee80211_11g_table; /* XXX */ + rt = &ieee80211_11ng_table; else if (IEEE80211_IS_CHAN_108G(c)) rt = &ieee80211_turbog_table; else if (IEEE80211_IS_CHAN_ST(c)) @@ -463,3 +567,66 @@ ieee80211_compute_duration(const struct ieee80211_rate_table *rt, } return txTime; } + +static const uint16_t ht20_bps[32] = { + 26, 52, 78, 104, 156, 208, 234, 260, + 52, 104, 156, 208, 312, 416, 468, 520, + 78, 156, 234, 312, 468, 624, 702, 780, + 104, 208, 312, 416, 624, 832, 936, 1040 +}; +static const uint16_t ht40_bps[32] = { + 54, 108, 162, 216, 324, 432, 486, 540, + 108, 216, 324, 432, 648, 864, 972, 1080, + 162, 324, 486, 648, 972, 1296, 1458, 1620, + 216, 432, 648, 864, 1296, 1728, 1944, 2160 +}; + + +#define OFDM_PLCP_BITS 22 +#define HT_L_STF 8 +#define HT_L_LTF 8 +#define HT_L_SIG 4 +#define HT_SIG 8 +#define HT_STF 4 +#define HT_LTF(n) ((n) * 4) + +#define HT_RC_2_MCS(_rc) ((_rc) & 0xf) +#define HT_RC_2_STREAMS(_rc) ((((_rc) & 0x78) >> 3) + 1) +#define IS_HT_RATE(_rc) ( (_rc) & IEEE80211_RATE_MCS) + +/* + * Calculate the transmit duration of an 11n frame. + */ +uint32_t +ieee80211_compute_duration_ht(uint32_t frameLen, uint16_t rate, + int streams, int isht40, int isShortGI) +{ + uint32_t bitsPerSymbol, numBits, numSymbols, txTime; + + KASSERT(rate & IEEE80211_RATE_MCS, ("not mcs %d", rate)); + KASSERT((rate &~ IEEE80211_RATE_MCS) < 31, ("bad mcs 0x%x", rate)); + + if (isht40) + bitsPerSymbol = ht40_bps[rate & 0x1f]; + else + bitsPerSymbol = ht20_bps[rate & 0x1f]; + numBits = OFDM_PLCP_BITS + (frameLen << 3); + numSymbols = howmany(numBits, bitsPerSymbol); + if (isShortGI) + txTime = ((numSymbols * 18) + 4) / 5; /* 3.6us */ + else + txTime = numSymbols * 4; /* 4us */ + return txTime + HT_L_STF + HT_L_LTF + + HT_L_SIG + HT_SIG + HT_STF + HT_LTF(streams); +} + +#undef IS_HT_RATE +#undef HT_RC_2_STREAMS +#undef HT_RC_2_MCS +#undef HT_LTF +#undef HT_STF +#undef HT_SIG +#undef HT_L_SIG +#undef HT_L_LTF +#undef HT_L_STF +#undef OFDM_PLCP_BITS diff --git a/sys/net80211/ieee80211_phy.h b/sys/net80211/ieee80211_phy.h index 56b404f7..bf39cdd 100644 --- a/sys/net80211/ieee80211_phy.h +++ b/sys/net80211/ieee80211_phy.h @@ -60,6 +60,8 @@ struct ieee80211_channel; +#define IEEE80211_RATE_TABLE_SIZE 128 + struct ieee80211_rate_table { int rateCount; /* NB: for proper padding */ uint8_t rateCodeToIndex[256]; /* back mapping */ @@ -74,7 +76,7 @@ struct ieee80211_rate_table { * rate; used for dur. calcs */ uint16_t lpAckDuration; /* long preamble ACK dur. */ uint16_t spAckDuration; /* short preamble ACK dur. */ - } info[32]; + } info[IEEE80211_RATE_TABLE_SIZE]; }; const struct ieee80211_rate_table *ieee80211_get_ratetable( @@ -83,7 +85,14 @@ const struct ieee80211_rate_table *ieee80211_get_ratetable( static __inline__ uint8_t ieee80211_ack_rate(const struct ieee80211_rate_table *rt, uint8_t rate) { - uint8_t cix = rt->info[rt->rateCodeToIndex[rate]].ctlRateIndex; + /* + * XXX Assert this is for a legacy rate; not for an MCS rate. + * If the caller wishes to use it for a basic rate, they should + * clear the high bit first. + */ + KASSERT(! (rate & 0x80), ("rate %d is basic/mcs?", rate)); + + uint8_t cix = rt->info[rt->rateCodeToIndex[rate & IEEE80211_RATE_VAL]].ctlRateIndex; KASSERT(cix != (uint8_t)-1, ("rate %d has no info", rate)); return rt->info[cix].dot11Rate; } @@ -91,7 +100,14 @@ ieee80211_ack_rate(const struct ieee80211_rate_table *rt, uint8_t rate) static __inline__ uint8_t ieee80211_ctl_rate(const struct ieee80211_rate_table *rt, uint8_t rate) { - uint8_t cix = rt->info[rt->rateCodeToIndex[rate]].ctlRateIndex; + /* + * XXX Assert this is for a legacy rate; not for an MCS rate. + * If the caller wishes to use it for a basic rate, they should + * clear the high bit first. + */ + KASSERT(! (rate & 0x80), ("rate %d is basic/mcs?", rate)); + + uint8_t cix = rt->info[rt->rateCodeToIndex[rate & IEEE80211_RATE_VAL]].ctlRateIndex; KASSERT(cix != (uint8_t)-1, ("rate %d has no info", rate)); return rt->info[cix].dot11Rate; } @@ -99,7 +115,14 @@ ieee80211_ctl_rate(const struct ieee80211_rate_table *rt, uint8_t rate) static __inline__ enum ieee80211_phytype ieee80211_rate2phytype(const struct ieee80211_rate_table *rt, uint8_t rate) { - uint8_t rix = rt->rateCodeToIndex[rate]; + /* + * XXX Assert this is for a legacy rate; not for an MCS rate. + * If the caller wishes to use it for a basic rate, they should + * clear the high bit first. + */ + KASSERT(! (rate & 0x80), ("rate %d is basic/mcs?", rate)); + + uint8_t rix = rt->rateCodeToIndex[rate & IEEE80211_RATE_VAL]; KASSERT(rix != (uint8_t)-1, ("rate %d has no info", rate)); return rt->info[rix].phy; } @@ -107,6 +130,13 @@ ieee80211_rate2phytype(const struct ieee80211_rate_table *rt, uint8_t rate) static __inline__ int ieee80211_isratevalid(const struct ieee80211_rate_table *rt, uint8_t rate) { + /* + * XXX Assert this is for a legacy rate; not for an MCS rate. + * If the caller wishes to use it for a basic rate, they should + * clear the high bit first. + */ + KASSERT(! (rate & 0x80), ("rate %d is basic/mcs?", rate)); + return rt->rateCodeToIndex[rate] != (uint8_t)-1; } @@ -134,6 +164,14 @@ ieee80211_ack_duration(const struct ieee80211_rate_table *rt, } } +static __inline__ uint8_t +ieee80211_legacy_rate_lookup(const struct ieee80211_rate_table *rt, + uint8_t rate) +{ + + return (rt->rateCodeToIndex[rate & IEEE80211_RATE_VAL]); +} + /* * Compute the time to transmit a frame of length frameLen bytes * using the specified 802.11 rate code, phy, and short preamble @@ -151,5 +189,10 @@ uint8_t ieee80211_plcp2rate(uint8_t, enum ieee80211_phytype); * Convert 802.11 rate code to PLCP signal. */ uint8_t ieee80211_rate2plcp(int, enum ieee80211_phytype); + +uint32_t ieee80211_compute_duration_ht(uint32_t frameLen, + uint16_t rate, int streams, int isht40, + int isShortGI); + #endif /* _KERNEL */ #endif /* !_NET80211_IEEE80211_PHY_H_ */ diff --git a/sys/netinet/cc/cc_cdg.c b/sys/netinet/cc/cc_cdg.c new file mode 100644 index 0000000..69335db --- /dev/null +++ b/sys/netinet/cc/cc_cdg.c @@ -0,0 +1,695 @@ +/*- + * Copyright (c) 2009-2013 + * Swinburne University of Technology, Melbourne, Australia + * All rights reserved. + * + * This software was developed at the Centre for Advanced Internet + * Architectures, Swinburne University of Technology, by David Hayes, made + * possible in part by a gift from The Cisco University Research Program Fund, + * a corporate advised fund of Silicon Valley Community Foundation. Development + * and testing were further assisted by a grant from the FreeBSD Foundation. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * CAIA Delay-Gradient (CDG) congestion control algorithm + * + * An implemention of the delay-gradient congestion control algorithm proposed + * in the following paper: + * + * D. A. Hayes and G. Armitage, "Revisiting TCP Congestion Control using Delay + * Gradients", in IFIP Networking, Valencia, Spain, 9-13 May 2011. + * + * Developed as part of the NewTCP research project at Swinburne University of + * Technology's Centre for Advanced Internet Architectures, Melbourne, + * Australia. More details are available at: + * http://caia.swin.edu.au/urp/newtcp/ + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/hhook.h> +#include <sys/kernel.h> +#include <sys/khelp.h> +#include <sys/limits.h> +#include <sys/lock.h> +#include <sys/malloc.h> +#include <sys/module.h> +#include <sys/queue.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/sysctl.h> +#include <sys/systm.h> + +#include <net/if.h> +#include <net/vnet.h> + +#include <netinet/cc.h> +#include <netinet/tcp_seq.h> +#include <netinet/tcp_timer.h> +#include <netinet/tcp_var.h> + +#include <netinet/cc/cc_module.h> + +#include <netinet/khelp/h_ertt.h> + +#include <vm/uma.h> + +#define CDG_VERSION "0.1" + +#define CAST_PTR_INT(X) (*((int*)(X))) + +#ifndef VIMAGE +#define vnet_sysctl_handle_uint(oidp, arg1, arg2, req) \ + sysctl_handle_int(oidp, arg1, arg2, req) +#endif + +/* Private delay-gradient induced congestion control signal. */ +#define CC_CDG_DELAY 0x01000000 + +/* NewReno window deflation factor on loss (as a percentage). */ +#define RENO_BETA 50 + +/* Queue states. */ +#define CDG_Q_EMPTY 1 +#define CDG_Q_RISING 2 +#define CDG_Q_FALLING 3 +#define CDG_Q_FULL 4 +#define CDG_Q_UNKNOWN 9999 + +/* Number of bit shifts used in probexp lookup table. */ +#define EXP_PREC 15 + +/* Largest gradient represented in probexp lookup table. */ +#define MAXGRAD 5 + +/* + * Delay Precision Enhance - number of bit shifts used for qtrend related + * integer arithmetic precision. + */ +#define D_P_E 7 + +struct qdiff_sample { + long qdiff; + STAILQ_ENTRY(qdiff_sample) qdiff_lnk; +}; + +struct cdg { + long max_qtrend; + long min_qtrend; + STAILQ_HEAD(minrtts_head, qdiff_sample) qdiffmin_q; + STAILQ_HEAD(maxrtts_head, qdiff_sample) qdiffmax_q; + long window_incr; + /* rttcount for window increase when in congestion avoidance */ + long rtt_count; + /* maximum measured rtt within an rtt period */ + int maxrtt_in_rtt; + /* maximum measured rtt within prev rtt period */ + int maxrtt_in_prevrtt; + /* minimum measured rtt within an rtt period */ + int minrtt_in_rtt; + /* minimum measured rtt within prev rtt period */ + int minrtt_in_prevrtt; + /* consecutive congestion episode counter */ + uint32_t consec_cong_cnt; + /* when tracking a new reno type loss window */ + uint32_t shadow_w; + /* maximum number of samples in the moving average queue */ + int sample_q_size; + /* number of samples in the moving average queue */ + int num_samples; + /* estimate of the queue state of the path */ + int queue_state; +}; + +/* + * Lookup table for: + * (1 - exp(-x)) << EXP_PREC, where x = [0,MAXGRAD] in 2^-7 increments + * + * Note: probexp[0] is set to 10 (not 0) as a safety for very low increase + * gradients. + */ +static const int probexp[641] = { + 10,255,508,759,1008,1255,1501,1744,1985,2225,2463,2698,2932,3165,3395,3624, + 3850,4075,4299,4520,4740,4958,5175,5389,5602,5814,6024,6232,6438,6643,6846, + 7048,7248,7447,7644,7839,8033,8226,8417,8606,8794,8981,9166,9350,9532,9713, + 9892,10070,10247,10422,10596,10769,10940,11110,11278,11445,11611,11776,11939, + 12101,12262,12422,12580,12737,12893,13048,13201,13354,13505,13655,13803,13951, + 14097,14243,14387,14530,14672,14813,14952,15091,15229,15365,15500,15635,15768, + 15900,16032,16162,16291,16419,16547,16673,16798,16922,17046,17168,17289,17410, + 17529,17648,17766,17882,17998,18113,18227,18340,18453,18564,18675,18784,18893, + 19001,19108,19215,19320,19425,19529,19632,19734,19835,19936,20036,20135,20233, + 20331,20427,20523,20619,20713,20807,20900,20993,21084,21175,21265,21355,21444, + 21532,21619,21706,21792,21878,21962,22046,22130,22213,22295,22376,22457,22537, + 22617,22696,22774,22852,22929,23006,23082,23157,23232,23306,23380,23453,23525, + 23597,23669,23739,23810,23879,23949,24017,24085,24153,24220,24286,24352,24418, + 24483,24547,24611,24675,24738,24800,24862,24924,24985,25045,25106,25165,25224, + 25283,25341,25399,25456,25513,25570,25626,25681,25737,25791,25846,25899,25953, + 26006,26059,26111,26163,26214,26265,26316,26366,26416,26465,26514,26563,26611, + 26659,26707,26754,26801,26847,26893,26939,26984,27029,27074,27118,27162,27206, + 27249,27292,27335,27377,27419,27460,27502,27543,27583,27624,27664,27703,27743, + 27782,27821,27859,27897,27935,27973,28010,28047,28084,28121,28157,28193,28228, + 28263,28299,28333,28368,28402,28436,28470,28503,28536,28569,28602,28634,28667, + 28699,28730,28762,28793,28824,28854,28885,28915,28945,28975,29004,29034,29063, + 29092,29120,29149,29177,29205,29232,29260,29287,29314,29341,29368,29394,29421, + 29447,29472,29498,29524,29549,29574,29599,29623,29648,29672,29696,29720,29744, + 29767,29791,29814,29837,29860,29882,29905,29927,29949,29971,29993,30014,30036, + 30057,30078,30099,30120,30141,30161,30181,30201,30221,30241,30261,30280,30300, + 30319,30338,30357,30376,30394,30413,30431,30449,30467,30485,30503,30521,30538, + 30555,30573,30590,30607,30624,30640,30657,30673,30690,30706,30722,30738,30753, + 30769,30785,30800,30815,30831,30846,30861,30876,30890,30905,30919,30934,30948, + 30962,30976,30990,31004,31018,31031,31045,31058,31072,31085,31098,31111,31124, + 31137,31149,31162,31174,31187,31199,31211,31223,31235,31247,31259,31271,31283, + 31294,31306,31317,31328,31339,31351,31362,31373,31383,31394,31405,31416,31426, + 31436,31447,31457,31467,31477,31487,31497,31507,31517,31527,31537,31546,31556, + 31565,31574,31584,31593,31602,31611,31620,31629,31638,31647,31655,31664,31673, + 31681,31690,31698,31706,31715,31723,31731,31739,31747,31755,31763,31771,31778, + 31786,31794,31801,31809,31816,31824,31831,31838,31846,31853,31860,31867,31874, + 31881,31888,31895,31902,31908,31915,31922,31928,31935,31941,31948,31954,31960, + 31967,31973,31979,31985,31991,31997,32003,32009,32015,32021,32027,32033,32038, + 32044,32050,32055,32061,32066,32072,32077,32083,32088,32093,32098,32104,32109, + 32114,32119,32124,32129,32134,32139,32144,32149,32154,32158,32163,32168,32173, + 32177,32182,32186,32191,32195,32200,32204,32209,32213,32217,32222,32226,32230, + 32234,32238,32242,32247,32251,32255,32259,32263,32267,32270,32274,32278,32282, + 32286,32290,32293,32297,32301,32304,32308,32311,32315,32318,32322,32325,32329, + 32332,32336,32339,32342,32346,32349,32352,32356,32359,32362,32365,32368,32371, + 32374,32377,32381,32384,32387,32389,32392,32395,32398,32401,32404,32407,32410, + 32412,32415,32418,32421,32423,32426,32429,32431,32434,32437,32439,32442,32444, + 32447,32449,32452,32454,32457,32459,32461,32464,32466,32469,32471,32473,32476, + 32478,32480,32482,32485,32487,32489,32491,32493,32495,32497,32500,32502,32504, + 32506,32508,32510,32512,32514,32516,32518,32520,32522,32524,32526,32527,32529, + 32531,32533,32535,32537,32538,32540,32542,32544,32545,32547}; + +static uma_zone_t qdiffsample_zone; + +static MALLOC_DEFINE(M_CDG, "cdg data", + "Per connection data required for the CDG congestion control algorithm"); + +static int ertt_id; + +static VNET_DEFINE(uint32_t, cdg_alpha_inc); +static VNET_DEFINE(uint32_t, cdg_beta_delay); +static VNET_DEFINE(uint32_t, cdg_beta_loss); +static VNET_DEFINE(uint32_t, cdg_smoothing_factor); +static VNET_DEFINE(uint32_t, cdg_exp_backoff_scale); +static VNET_DEFINE(uint32_t, cdg_consec_cong); +static VNET_DEFINE(uint32_t, cdg_hold_backoff); +#define V_cdg_alpha_inc VNET(cdg_alpha_inc) +#define V_cdg_beta_delay VNET(cdg_beta_delay) +#define V_cdg_beta_loss VNET(cdg_beta_loss) +#define V_cdg_smoothing_factor VNET(cdg_smoothing_factor) +#define V_cdg_exp_backoff_scale VNET(cdg_exp_backoff_scale) +#define V_cdg_consec_cong VNET(cdg_consec_cong) +#define V_cdg_hold_backoff VNET(cdg_hold_backoff) + +/* Function prototypes. */ +static int cdg_mod_init(void); +static void cdg_conn_init(struct cc_var *ccv); +static int cdg_cb_init(struct cc_var *ccv); +static void cdg_cb_destroy(struct cc_var *ccv); +static void cdg_cong_signal(struct cc_var *ccv, uint32_t signal_type); +static void cdg_ack_received(struct cc_var *ccv, uint16_t ack_type); + +struct cc_algo cdg_cc_algo = { + .name = "cdg", + .mod_init = cdg_mod_init, + .ack_received = cdg_ack_received, + .cb_destroy = cdg_cb_destroy, + .cb_init = cdg_cb_init, + .conn_init = cdg_conn_init, + .cong_signal = cdg_cong_signal +}; + +/* Vnet created and being initialised. */ +static void +cdg_init_vnet(const void *unused __unused) +{ + + V_cdg_alpha_inc = 0; + V_cdg_beta_delay = 70; + V_cdg_beta_loss = 50; + V_cdg_smoothing_factor = 8; + V_cdg_exp_backoff_scale = 3; + V_cdg_consec_cong = 5; + V_cdg_hold_backoff = 5; +} + +static int +cdg_mod_init(void) +{ + VNET_ITERATOR_DECL(v); + + ertt_id = khelp_get_id("ertt"); + if (ertt_id <= 0) + return (EINVAL); + + qdiffsample_zone = uma_zcreate("cdg_qdiffsample", + sizeof(struct qdiff_sample), NULL, NULL, NULL, NULL, 0, 0); + + VNET_LIST_RLOCK(); + VNET_FOREACH(v) { + CURVNET_SET(v); + cdg_init_vnet(NULL); + CURVNET_RESTORE(); + } + VNET_LIST_RUNLOCK(); + + cdg_cc_algo.post_recovery = newreno_cc_algo.post_recovery; + cdg_cc_algo.after_idle = newreno_cc_algo.after_idle; + + return (0); +} + +static int +cdg_cb_init(struct cc_var *ccv) +{ + struct cdg *cdg_data; + + cdg_data = malloc(sizeof(struct cdg), M_CDG, M_NOWAIT); + if (cdg_data == NULL) + return (ENOMEM); + + cdg_data->shadow_w = 0; + cdg_data->max_qtrend = 0; + cdg_data->min_qtrend = 0; + cdg_data->queue_state = CDG_Q_UNKNOWN; + cdg_data->maxrtt_in_rtt = 0; + cdg_data->maxrtt_in_prevrtt = 0; + cdg_data->minrtt_in_rtt = INT_MAX; + cdg_data->minrtt_in_prevrtt = 0; + cdg_data->window_incr = 0; + cdg_data->rtt_count = 0; + cdg_data->consec_cong_cnt = 0; + cdg_data->sample_q_size = V_cdg_smoothing_factor; + cdg_data->num_samples = 0; + STAILQ_INIT(&cdg_data->qdiffmin_q); + STAILQ_INIT(&cdg_data->qdiffmax_q); + + ccv->cc_data = cdg_data; + + return (0); +} + +static void +cdg_conn_init(struct cc_var *ccv) +{ + struct cdg *cdg_data = ccv->cc_data; + + /* + * Initialise the shadow_cwnd in case we are competing with loss based + * flows from the start + */ + cdg_data->shadow_w = CCV(ccv, snd_cwnd); +} + +static void +cdg_cb_destroy(struct cc_var *ccv) +{ + struct cdg *cdg_data; + struct qdiff_sample *qds, *qds_n; + + cdg_data = ccv->cc_data; + + qds = STAILQ_FIRST(&cdg_data->qdiffmin_q); + while (qds != NULL) { + qds_n = STAILQ_NEXT(qds, qdiff_lnk); + uma_zfree(qdiffsample_zone,qds); + qds = qds_n; + } + + qds = STAILQ_FIRST(&cdg_data->qdiffmax_q); + while (qds != NULL) { + qds_n = STAILQ_NEXT(qds, qdiff_lnk); + uma_zfree(qdiffsample_zone,qds); + qds = qds_n; + } + + free(ccv->cc_data, M_CDG); +} + +static int +cdg_beta_handler(SYSCTL_HANDLER_ARGS) +{ + + if (req->newptr != NULL && + (CAST_PTR_INT(req->newptr) == 0 || CAST_PTR_INT(req->newptr) > 100)) + return (EINVAL); + + return (vnet_sysctl_handle_uint(oidp, arg1, arg2, req)); +} + +static int +cdg_exp_backoff_scale_handler(SYSCTL_HANDLER_ARGS) +{ + + if (req->newptr != NULL && CAST_PTR_INT(req->newptr) < 1) + return (EINVAL); + + return (vnet_sysctl_handle_uint(oidp, arg1, arg2, req)); +} + +static inline unsigned long +cdg_window_decrease(struct cc_var *ccv, unsigned long owin, unsigned int beta) +{ + + return ((ulmin(CCV(ccv, snd_wnd), owin) * beta) / 100); +} + +/* + * Window increase function + * This window increase function is independent of the initial window size + * to ensure small window flows are not discriminated against (i.e. fairness). + * It increases at 1pkt/rtt like Reno for alpha_inc rtts, and then 2pkts/rtt for + * the next alpha_inc rtts, etc. + */ +static void +cdg_window_increase(struct cc_var *ccv, int new_measurement) +{ + struct cdg *cdg_data; + int incr, s_w_incr; + + cdg_data = ccv->cc_data; + incr = s_w_incr = 0; + + if (CCV(ccv, snd_cwnd) <= CCV(ccv, snd_ssthresh)) { + /* Slow start. */ + incr = CCV(ccv, t_maxseg); + s_w_incr = incr; + cdg_data->window_incr = cdg_data->rtt_count = 0; + } else { + /* Congestion avoidance. */ + if (new_measurement) { + s_w_incr = CCV(ccv, t_maxseg); + if (V_cdg_alpha_inc == 0) { + incr = CCV(ccv, t_maxseg); + } else { + if (++cdg_data->rtt_count >= V_cdg_alpha_inc) { + cdg_data->window_incr++; + cdg_data->rtt_count = 0; + } + incr = CCV(ccv, t_maxseg) * + cdg_data->window_incr; + } + } + } + + if (cdg_data->shadow_w > 0) + cdg_data->shadow_w = ulmin(cdg_data->shadow_w + s_w_incr, + TCP_MAXWIN << CCV(ccv, snd_scale)); + + CCV(ccv, snd_cwnd) = ulmin(CCV(ccv, snd_cwnd) + incr, + TCP_MAXWIN << CCV(ccv, snd_scale)); +} + +static void +cdg_cong_signal(struct cc_var *ccv, uint32_t signal_type) +{ + struct cdg *cdg_data = ccv->cc_data; + + switch(signal_type) { + case CC_CDG_DELAY: + CCV(ccv, snd_ssthresh) = cdg_window_decrease(ccv, + CCV(ccv, snd_cwnd), V_cdg_beta_delay); + CCV(ccv, snd_cwnd) = CCV(ccv, snd_ssthresh); + CCV(ccv, snd_recover) = CCV(ccv, snd_max); + cdg_data->window_incr = cdg_data->rtt_count = 0; + ENTER_CONGRECOVERY(CCV(ccv, t_flags)); + break; + case CC_NDUPACK: + /* + * If already responding to congestion OR we have guessed no + * queue in the path is full. + */ + if (IN_CONGRECOVERY(CCV(ccv, t_flags)) || + cdg_data->queue_state < CDG_Q_FULL) { + CCV(ccv, snd_ssthresh) = CCV(ccv, snd_cwnd); + CCV(ccv, snd_recover) = CCV(ccv, snd_max); + } else { + /* + * Loss is likely to be congestion related. We have + * inferred a queue full state, so have shadow window + * react to loss as NewReno would. + */ + if (cdg_data->shadow_w > 0) + cdg_data->shadow_w = cdg_window_decrease(ccv, + cdg_data->shadow_w, RENO_BETA); + + CCV(ccv, snd_ssthresh) = ulmax(cdg_data->shadow_w, + cdg_window_decrease(ccv, CCV(ccv, snd_cwnd), + V_cdg_beta_loss)); + + cdg_data->window_incr = cdg_data->rtt_count = 0; + } + ENTER_RECOVERY(CCV(ccv, t_flags)); + break; + default: + newreno_cc_algo.cong_signal(ccv, signal_type); + break; + } +} + +/* + * Using a negative exponential probabilistic backoff so that sources with + * varying RTTs which share the same link will, on average, have the same + * probability of backoff over time. + * + * Prob_backoff = 1 - exp(-qtrend / V_cdg_exp_backoff_scale), where + * V_cdg_exp_backoff_scale is the average qtrend for the exponential backoff. + */ +static inline int +prob_backoff(long qtrend) +{ + int backoff, idx, p; + + backoff = (qtrend > ((MAXGRAD * V_cdg_exp_backoff_scale) << D_P_E)); + + if (!backoff) { + if (V_cdg_exp_backoff_scale > 1) + idx = (qtrend + V_cdg_exp_backoff_scale / 2) / + V_cdg_exp_backoff_scale; + else + idx = qtrend; + + /* Backoff probability proportional to rate of queue growth. */ + p = (INT_MAX / (1 << EXP_PREC)) * probexp[idx]; + backoff = (random() < p); + } + + return (backoff); +} + +static inline void +calc_moving_average(struct cdg *cdg_data, long qdiff_max, long qdiff_min) +{ + struct qdiff_sample *qds; + + ++cdg_data->num_samples; + if (cdg_data->num_samples > cdg_data->sample_q_size) { + /* Minimum RTT. */ + qds = STAILQ_FIRST(&cdg_data->qdiffmin_q); + cdg_data->min_qtrend = cdg_data->min_qtrend + + (qdiff_min - qds->qdiff) / cdg_data->sample_q_size; + STAILQ_REMOVE_HEAD(&cdg_data->qdiffmin_q, qdiff_lnk); + qds->qdiff = qdiff_min; + STAILQ_INSERT_TAIL(&cdg_data->qdiffmin_q, qds, qdiff_lnk); + + /* Maximum RTT. */ + qds = STAILQ_FIRST(&cdg_data->qdiffmax_q); + cdg_data->max_qtrend = cdg_data->max_qtrend + + (qdiff_max - qds->qdiff) / cdg_data->sample_q_size; + STAILQ_REMOVE_HEAD(&cdg_data->qdiffmax_q, qdiff_lnk); + qds->qdiff = qdiff_max; + STAILQ_INSERT_TAIL(&cdg_data->qdiffmax_q, qds, qdiff_lnk); + --cdg_data->num_samples; + } else { + qds = uma_zalloc(qdiffsample_zone, M_NOWAIT); + if (qds != NULL) { + cdg_data->min_qtrend = cdg_data->min_qtrend + + qdiff_min / cdg_data->sample_q_size; + qds->qdiff = qdiff_min; + STAILQ_INSERT_TAIL(&cdg_data->qdiffmin_q, qds, + qdiff_lnk); + } + + qds = uma_zalloc(qdiffsample_zone, M_NOWAIT); + if (qds) { + cdg_data->max_qtrend = cdg_data->max_qtrend + + qdiff_max / cdg_data->sample_q_size; + qds->qdiff = qdiff_max; + STAILQ_INSERT_TAIL(&cdg_data->qdiffmax_q, qds, + qdiff_lnk); + } + } +} + +static void +cdg_ack_received(struct cc_var *ccv, uint16_t ack_type) +{ + struct cdg *cdg_data; + struct ertt *e_t; + long qdiff_max, qdiff_min; + int congestion, new_measurement, slowstart; + + cdg_data = ccv->cc_data; + e_t = (struct ertt *)khelp_get_osd(CCV(ccv, osd), ertt_id); + new_measurement = e_t->flags & ERTT_NEW_MEASUREMENT; + congestion = 0; + cdg_data->maxrtt_in_rtt = imax(e_t->rtt, cdg_data->maxrtt_in_rtt); + cdg_data->minrtt_in_rtt = imin(e_t->rtt, cdg_data->minrtt_in_rtt); + + if (new_measurement) { + slowstart = (CCV(ccv, snd_cwnd) <= CCV(ccv, snd_ssthresh)); + /* + * Update smoothed gradient measurements. Since we are only + * using one measurement per RTT, use max or min rtt_in_rtt. + * This is also less noisy than a sample RTT measurement. Max + * RTT measurements can have trouble due to OS issues. + */ + if (cdg_data->maxrtt_in_prevrtt) { + qdiff_max = ((long)(cdg_data->maxrtt_in_rtt - + cdg_data->maxrtt_in_prevrtt) << D_P_E ); + qdiff_min = ((long)(cdg_data->minrtt_in_rtt - + cdg_data->minrtt_in_prevrtt) << D_P_E ); + + calc_moving_average(cdg_data, qdiff_max, qdiff_min); + + /* Probabilistic backoff with respect to gradient. */ + if (slowstart && qdiff_min > 0) + congestion = prob_backoff(qdiff_min); + else if (cdg_data->min_qtrend > 0) + congestion = prob_backoff(cdg_data->min_qtrend); + else if (slowstart && qdiff_max > 0) + congestion = prob_backoff(qdiff_max); + else if (cdg_data->max_qtrend > 0) + congestion = prob_backoff(cdg_data->max_qtrend); + + /* Update estimate of queue state. */ + if (cdg_data->min_qtrend > 0 && + cdg_data->max_qtrend <= 0) { + cdg_data->queue_state = CDG_Q_FULL; + } else if (cdg_data->min_qtrend >= 0 && + cdg_data->max_qtrend < 0) { + cdg_data->queue_state = CDG_Q_EMPTY; + cdg_data->shadow_w = 0; + } else if (cdg_data->min_qtrend > 0 && + cdg_data->max_qtrend > 0) { + cdg_data->queue_state = CDG_Q_RISING; + } else if (cdg_data->min_qtrend < 0 && + cdg_data->max_qtrend < 0) { + cdg_data->queue_state = CDG_Q_FALLING; + } + + if (cdg_data->min_qtrend < 0 || + cdg_data->max_qtrend < 0) + cdg_data->consec_cong_cnt = 0; + } + + cdg_data->minrtt_in_prevrtt = cdg_data->minrtt_in_rtt; + cdg_data->minrtt_in_rtt = INT_MAX; + cdg_data->maxrtt_in_prevrtt = cdg_data->maxrtt_in_rtt; + cdg_data->maxrtt_in_rtt = 0; + e_t->flags &= ~ERTT_NEW_MEASUREMENT; + } + + if (congestion) { + cdg_data->consec_cong_cnt++; + if (!IN_RECOVERY(CCV(ccv, t_flags))) { + if (cdg_data->consec_cong_cnt <= V_cdg_consec_cong) + cdg_cong_signal(ccv, CC_CDG_DELAY); + else + /* + * We have been backing off but the queue is not + * falling. Assume we are competing with + * loss-based flows and don't back off for the + * next V_cdg_hold_backoff RTT periods. + */ + if (cdg_data->consec_cong_cnt >= + V_cdg_consec_cong + V_cdg_hold_backoff) + cdg_data->consec_cong_cnt = 0; + + /* Won't see effect until 2nd RTT. */ + cdg_data->maxrtt_in_prevrtt = 0; + /* + * Resync shadow window in case we are competing with a + * loss based flow + */ + cdg_data->shadow_w = ulmax(CCV(ccv, snd_cwnd), + cdg_data->shadow_w); + } + } else if (ack_type == CC_ACK) + cdg_window_increase(ccv, new_measurement); +} + +/* When a vnet is created and being initialised, init the per-stack CDG vars. */ +VNET_SYSINIT(cdg_init_vnet, SI_SUB_PROTO_BEGIN, SI_ORDER_FIRST, + cdg_init_vnet, NULL); + +SYSCTL_DECL(_net_inet_tcp_cc_cdg); +SYSCTL_NODE(_net_inet_tcp_cc, OID_AUTO, cdg, CTLFLAG_RW, NULL, + "CAIA delay-gradient congestion control related settings"); + +SYSCTL_STRING(_net_inet_tcp_cc_cdg, OID_AUTO, version, + CTLFLAG_RD, CDG_VERSION, sizeof(CDG_VERSION) - 1, + "Current algorithm/implementation version number"); + +SYSCTL_VNET_UINT(_net_inet_tcp_cc_cdg, OID_AUTO, alpha_inc, + CTLFLAG_RW, &VNET_NAME(cdg_alpha_inc), 0, + "Increment the window increase factor alpha by 1 MSS segment every " + "alpha_inc RTTs during congestion avoidance mode."); + +SYSCTL_VNET_PROC(_net_inet_tcp_cc_cdg, OID_AUTO, beta_delay, + CTLTYPE_UINT|CTLFLAG_RW, &VNET_NAME(cdg_beta_delay), 70, + &cdg_beta_handler, "IU", + "Delay-based window decrease factor as a percentage " + "(on delay-based backoff, w = w * beta_delay / 100)"); + +SYSCTL_VNET_PROC(_net_inet_tcp_cc_cdg, OID_AUTO, beta_loss, + CTLTYPE_UINT|CTLFLAG_RW, &VNET_NAME(cdg_beta_loss), 50, + &cdg_beta_handler, "IU", + "Loss-based window decrease factor as a percentage " + "(on loss-based backoff, w = w * beta_loss / 100)"); + +SYSCTL_VNET_PROC(_net_inet_tcp_cc_cdg, OID_AUTO, exp_backoff_scale, + CTLTYPE_UINT|CTLFLAG_RW, &VNET_NAME(cdg_exp_backoff_scale), 2, + &cdg_exp_backoff_scale_handler, "IU", + "Scaling parameter for the probabilistic exponential backoff"); + +SYSCTL_VNET_UINT(_net_inet_tcp_cc_cdg, OID_AUTO, smoothing_factor, + CTLFLAG_RW, &VNET_NAME(cdg_smoothing_factor), 8, + "Number of samples used for moving average smoothing (0 = no smoothing)"); + +SYSCTL_VNET_UINT(_net_inet_tcp_cc_cdg, OID_AUTO, loss_compete_consec_cong, + CTLFLAG_RW, &VNET_NAME(cdg_consec_cong), 5, + "Number of consecutive delay-gradient based congestion episodes which will " + "trigger loss based CC compatibility"); + +SYSCTL_VNET_UINT(_net_inet_tcp_cc_cdg, OID_AUTO, loss_compete_hold_backoff, + CTLFLAG_RW, &VNET_NAME(cdg_hold_backoff), 5, + "Number of consecutive delay-gradient based congestion episodes to hold " + "the window backoff for loss based CC compatibility"); + +DECLARE_CC_MODULE(cdg, &cdg_cc_algo); + +MODULE_DEPEND(cdg, ertt, 1, 1, 1); diff --git a/sys/netinet/if_ether.c b/sys/netinet/if_ether.c index 37249e5..ad31557 100644 --- a/sys/netinet/if_ether.c +++ b/sys/netinet/if_ether.c @@ -174,7 +174,7 @@ arptimer(void *arg) ifp = lle->lle_tbl->llt_ifp; CURVNET_SET(ifp->if_vnet); - if (lle->la_flags != LLE_DELETED) { + if ((lle->la_flags & LLE_DELETED) == 0) { int evt; if (lle->la_flags & LLE_VALID) diff --git a/sys/netinet/in_mcast.c b/sys/netinet/in_mcast.c index b0d53b0..31f2fe1 100644 --- a/sys/netinet/in_mcast.c +++ b/sys/netinet/in_mcast.c @@ -1236,7 +1236,9 @@ in_leavegroup_locked(struct in_multi *inm, /*const*/ struct in_mfilter *imf) KASSERT(error == 0, ("%s: failed to merge inm state", __func__)); CTR1(KTR_IGMPV3, "%s: doing igmp downcall", __func__); + CURVNET_SET(inm->inm_ifp->if_vnet); error = igmp_change_state(inm); + CURVNET_RESTORE(); if (error) CTR1(KTR_IGMPV3, "%s: failed igmp downcall", __func__); diff --git a/sys/netinet/in_pcb.c b/sys/netinet/in_pcb.c index f5e2ef2..3506b74 100644 --- a/sys/netinet/in_pcb.c +++ b/sys/netinet/in_pcb.c @@ -467,6 +467,23 @@ in_pcb_lport(struct inpcb *inp, struct in_addr *laddrp, u_short *lportp, return (0); } + +/* + * Return cached socket options. + */ +short +inp_so_options(const struct inpcb *inp) +{ + short so_options; + + so_options = 0; + + if ((inp->inp_flags2 & INP_REUSEPORT) != 0) + so_options |= SO_REUSEPORT; + if ((inp->inp_flags2 & INP_REUSEADDR) != 0) + so_options |= SO_REUSEADDR; + return (so_options); +} #endif /* INET || INET6 */ #ifdef INET @@ -595,8 +612,7 @@ in_pcbbind_setup(struct inpcb *inp, struct sockaddr *nam, in_addr_t *laddrp, if (tw == NULL || (reuseport & tw->tw_so_options) == 0) return (EADDRINUSE); - } else if (t && (reuseport == 0 || - (t->inp_flags2 & INP_REUSEPORT) == 0)) { + } else if (t && (reuseport & inp_so_options(t)) == 0) { #ifdef INET6 if (ntohl(sin->sin_addr.s_addr) != INADDR_ANY || diff --git a/sys/netinet/in_pcb.h b/sys/netinet/in_pcb.h index 2df90b0..1760bca 100644 --- a/sys/netinet/in_pcb.h +++ b/sys/netinet/in_pcb.h @@ -442,6 +442,7 @@ struct tcpcb * inp_inpcbtotcpcb(struct inpcb *inp); void inp_4tuple_get(struct inpcb *inp, uint32_t *laddr, uint16_t *lp, uint32_t *faddr, uint16_t *fp); +short inp_so_options(const struct inpcb *inp); #endif /* _KERNEL */ @@ -543,6 +544,7 @@ void inp_4tuple_get(struct inpcb *inp, uint32_t *laddr, uint16_t *lp, #define INP_PCBGROUPWILD 0x00000004 /* in pcbgroup wildcard list */ #define INP_REUSEPORT 0x00000008 /* SO_REUSEPORT option is set */ #define INP_FREED 0x00000010 /* inp itself is not valid */ +#define INP_REUSEADDR 0x00000020 /* SO_REUSEADDR option is set */ /* * Flags passed to in_pcblookup*() functions. diff --git a/sys/netinet/ip_output.c b/sys/netinet/ip_output.c index 21d47f7..d835bd2 100644 --- a/sys/netinet/ip_output.c +++ b/sys/netinet/ip_output.c @@ -900,13 +900,10 @@ ip_ctloutput(struct socket *so, struct sockopt *sopt) switch (sopt->sopt_name) { case SO_REUSEADDR: INP_WLOCK(inp); - if (IN_MULTICAST(ntohl(inp->inp_laddr.s_addr))) { - if ((so->so_options & - (SO_REUSEADDR | SO_REUSEPORT)) != 0) - inp->inp_flags2 |= INP_REUSEPORT; - else - inp->inp_flags2 &= ~INP_REUSEPORT; - } + if ((so->so_options & SO_REUSEADDR) != 0) + inp->inp_flags2 |= INP_REUSEADDR; + else + inp->inp_flags2 &= ~INP_REUSEADDR; INP_WUNLOCK(inp); error = 0; break; diff --git a/sys/netinet/sctp_indata.c b/sys/netinet/sctp_indata.c index b4a0d08..7bad54c 100644 --- a/sys/netinet/sctp_indata.c +++ b/sys/netinet/sctp_indata.c @@ -1729,7 +1729,6 @@ sctp_process_a_data_chunk(struct sctp_tcb *stcb, struct sctp_association *asoc, sctp_alloc_a_readq(stcb, control); sctp_build_readq_entry_mac(control, stcb, asoc->context, net, tsn, protocol_id, - stcb->asoc.context, strmno, strmseq, chunk_flags, dmbuf); @@ -1857,7 +1856,6 @@ failed_pdapi_express_del: sctp_alloc_a_readq(stcb, control); sctp_build_readq_entry_mac(control, stcb, asoc->context, net, tsn, protocol_id, - stcb->asoc.context, strmno, strmseq, chunk_flags, dmbuf); diff --git a/sys/netinet/sctp_indata.h b/sys/netinet/sctp_indata.h index 5eaa1f4..79a86e2 100644 --- a/sys/netinet/sctp_indata.h +++ b/sys/netinet/sctp_indata.h @@ -47,14 +47,14 @@ sctp_build_readq_entry(struct sctp_tcb *stcb, struct mbuf *dm); -#define sctp_build_readq_entry_mac(_ctl, in_it, a, net, tsn, ppid, context, stream_no, stream_seq, flags, dm) do { \ +#define sctp_build_readq_entry_mac(_ctl, in_it, context, net, tsn, ppid, stream_no, stream_seq, flags, dm) do { \ if (_ctl) { \ atomic_add_int(&((net)->ref_count), 1); \ (_ctl)->sinfo_stream = stream_no; \ (_ctl)->sinfo_ssn = stream_seq; \ (_ctl)->sinfo_flags = (flags << 8); \ (_ctl)->sinfo_ppid = ppid; \ - (_ctl)->sinfo_context = a; \ + (_ctl)->sinfo_context = context; \ (_ctl)->sinfo_timetolive = 0; \ (_ctl)->sinfo_tsn = tsn; \ (_ctl)->sinfo_cumtsn = tsn; \ diff --git a/sys/netinet/sctp_input.c b/sys/netinet/sctp_input.c index 0528d3d..c19464f 100644 --- a/sys/netinet/sctp_input.c +++ b/sys/netinet/sctp_input.c @@ -1028,12 +1028,13 @@ sctp_handle_shutdown_ack(struct sctp_shutdown_ack_chunk *cp SCTP_UNUSED, SCTP_SOCKET_UNLOCK(so, 1); #endif } - /* are the queues empty? */ +#ifdef INVARIANTS if (!TAILQ_EMPTY(&asoc->send_queue) || !TAILQ_EMPTY(&asoc->sent_queue) || !stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { - sctp_report_all_outbound(stcb, 0, 0, SCTP_SO_NOT_LOCKED); + panic("Queues are not empty when handling SHUTDOWN-ACK"); } +#endif /* stop the timer */ sctp_timer_stop(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb, net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_9); /* send SHUTDOWN-COMPLETE */ @@ -1875,9 +1876,14 @@ sctp_process_cookie_existing(struct mbuf *m, int iphlen, int offset, cookie->tie_tag_peer_vtag != 0) { struct sctpasochead *head; +#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) + struct socket *so; + +#endif + if (asoc->peer_supports_nat) { /* - * This is a gross gross hack. just call the + * This is a gross gross hack. Just call the * cookie_new code since we are allowing a duplicate * association. I hope this works... */ @@ -1939,6 +1945,10 @@ sctp_process_cookie_existing(struct mbuf *m, int iphlen, int offset, asoc->mapping_array_size); } SCTP_TCB_UNLOCK(stcb); +#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) + so = SCTP_INP_SO(stcb->sctp_ep); + SCTP_SOCKET_LOCK(so, 1); +#endif SCTP_INP_INFO_WLOCK(); SCTP_INP_WLOCK(stcb->sctp_ep); SCTP_TCB_LOCK(stcb); @@ -1946,7 +1956,7 @@ sctp_process_cookie_existing(struct mbuf *m, int iphlen, int offset, /* send up all the data */ SCTP_TCB_SEND_LOCK(stcb); - sctp_report_all_outbound(stcb, 0, 1, SCTP_SO_NOT_LOCKED); + sctp_report_all_outbound(stcb, 0, 1, SCTP_SO_LOCKED); for (i = 0; i < stcb->asoc.streamoutcnt; i++) { stcb->asoc.strmout[i].chunks_on_queues = 0; stcb->asoc.strmout[i].stream_no = i; @@ -1968,11 +1978,15 @@ sctp_process_cookie_existing(struct mbuf *m, int iphlen, int offset, */ LIST_INSERT_HEAD(head, stcb, sctp_asocs); - /* process the INIT info (peer's info) */ SCTP_TCB_SEND_UNLOCK(stcb); SCTP_INP_WUNLOCK(stcb->sctp_ep); SCTP_INP_INFO_WUNLOCK(); - +#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) + SCTP_SOCKET_UNLOCK(so, 1); +#endif + asoc->total_flight = 0; + asoc->total_flight_count = 0; + /* process the INIT info (peer's info) */ retval = sctp_process_init(init_cp, stcb); if (retval < 0) { if (how_indx < sizeof(asoc->cookie_how)) @@ -3196,13 +3210,14 @@ sctp_handle_shutdown_complete(struct sctp_shutdown_complete_chunk *cp SCTP_UNUSE /* notify upper layer protocol */ if (stcb->sctp_socket) { sctp_ulp_notify(SCTP_NOTIFY_ASSOC_DOWN, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); - /* are the queues empty? they should be */ - if (!TAILQ_EMPTY(&asoc->send_queue) || - !TAILQ_EMPTY(&asoc->sent_queue) || - !stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { - sctp_report_all_outbound(stcb, 0, 0, SCTP_SO_NOT_LOCKED); - } } +#ifdef INVARIANTS + if (!TAILQ_EMPTY(&asoc->send_queue) || + !TAILQ_EMPTY(&asoc->sent_queue) || + !stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { + panic("Queues are not empty when handling SHUTDOWN-COMPLETE"); + } +#endif /* stop the timer */ sctp_timer_stop(SCTP_TIMER_TYPE_SHUTDOWNACK, stcb->sctp_ep, stcb, net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_22); SCTP_STAT_INCR_COUNTER32(sctps_shutdown); @@ -3491,18 +3506,13 @@ sctp_reset_in_stream(struct sctp_tcb *stcb, uint32_t number_entries, uint16_t * } static void -sctp_reset_out_streams(struct sctp_tcb *stcb, int number_entries, uint16_t * list) +sctp_reset_out_streams(struct sctp_tcb *stcb, uint32_t number_entries, uint16_t * list) { - int i; + uint32_t i; + uint16_t temp; - if (number_entries == 0) { - for (i = 0; i < stcb->asoc.streamoutcnt; i++) { - stcb->asoc.strmout[i].next_sequence_send = 0; - } - } else if (number_entries) { + if (number_entries > 0) { for (i = 0; i < number_entries; i++) { - uint16_t temp; - temp = ntohs(list[i]); if (temp >= stcb->asoc.streamoutcnt) { /* no such stream */ @@ -3510,6 +3520,10 @@ sctp_reset_out_streams(struct sctp_tcb *stcb, int number_entries, uint16_t * lis } stcb->asoc.strmout[temp].next_sequence_send = 0; } + } else { + for (i = 0; i < stcb->asoc.streamoutcnt; i++) { + stcb->asoc.strmout[i].next_sequence_send = 0; + } } sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_SEND, stcb, number_entries, (void *)list, SCTP_SO_NOT_LOCKED); } @@ -3596,7 +3610,7 @@ sctp_handle_stream_reset_response(struct sctp_tcb *stcb, struct sctp_association *asoc = &stcb->asoc; struct sctp_tmit_chunk *chk; struct sctp_stream_reset_out_request *srparam; - int number_entries; + uint32_t number_entries; if (asoc->stream_reset_outstanding == 0) { /* duplicate */ @@ -4554,8 +4568,10 @@ __attribute__((noinline)) if ((ch->chunk_type == SCTP_ABORT_ASSOCIATION) || (ch->chunk_type == SCTP_SHUTDOWN_COMPLETE) || (ch->chunk_type == SCTP_PACKET_DROPPED)) { - if ((vtag_in == asoc->my_vtag) || - ((ch->chunk_flags & SCTP_HAD_NO_TCB) && + /* Take the T-bit always into account. */ + if ((((ch->chunk_flags & SCTP_HAD_NO_TCB) == 0) && + (vtag_in == asoc->my_vtag)) || + (((ch->chunk_flags & SCTP_HAD_NO_TCB) == SCTP_HAD_NO_TCB) && (vtag_in == asoc->peer_vtag))) { /* this is valid */ } else { diff --git a/sys/netinet/sctp_pcb.c b/sys/netinet/sctp_pcb.c index e98ca0c..00f685f 100644 --- a/sys/netinet/sctp_pcb.c +++ b/sys/netinet/sctp_pcb.c @@ -4451,23 +4451,21 @@ sctp_delete_from_timewait(uint32_t tag, uint16_t lport, uint16_t rport) int i; chain = &SCTP_BASE_INFO(vtag_timewait)[(tag % SCTP_STACK_VTAG_HASH_SIZE)]; - if (!LIST_EMPTY(chain)) { - LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { - for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { - if ((twait_block->vtag_block[i].v_tag == tag) && - (twait_block->vtag_block[i].lport == lport) && - (twait_block->vtag_block[i].rport == rport)) { - twait_block->vtag_block[i].tv_sec_at_expire = 0; - twait_block->vtag_block[i].v_tag = 0; - twait_block->vtag_block[i].lport = 0; - twait_block->vtag_block[i].rport = 0; - found = 1; - break; - } - } - if (found) + LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { + for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { + if ((twait_block->vtag_block[i].v_tag == tag) && + (twait_block->vtag_block[i].lport == lport) && + (twait_block->vtag_block[i].rport == rport)) { + twait_block->vtag_block[i].tv_sec_at_expire = 0; + twait_block->vtag_block[i].v_tag = 0; + twait_block->vtag_block[i].lport = 0; + twait_block->vtag_block[i].rport = 0; + found = 1; break; + } } + if (found) + break; } } @@ -4481,19 +4479,17 @@ sctp_is_in_timewait(uint32_t tag, uint16_t lport, uint16_t rport) SCTP_INP_INFO_WLOCK(); chain = &SCTP_BASE_INFO(vtag_timewait)[(tag % SCTP_STACK_VTAG_HASH_SIZE)]; - if (!LIST_EMPTY(chain)) { - LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { - for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { - if ((twait_block->vtag_block[i].v_tag == tag) && - (twait_block->vtag_block[i].lport == lport) && - (twait_block->vtag_block[i].rport == rport)) { - found = 1; - break; - } - } - if (found) + LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { + for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { + if ((twait_block->vtag_block[i].v_tag == tag) && + (twait_block->vtag_block[i].lport == lport) && + (twait_block->vtag_block[i].rport == rport)) { + found = 1; break; + } } + if (found) + break; } SCTP_INP_INFO_WUNLOCK(); return (found); @@ -4515,42 +4511,40 @@ sctp_add_vtag_to_timewait(uint32_t tag, uint32_t time, uint16_t lport, uint16_t (void)SCTP_GETTIME_TIMEVAL(&now); chain = &SCTP_BASE_INFO(vtag_timewait)[(tag % SCTP_STACK_VTAG_HASH_SIZE)]; set = 0; - if (!LIST_EMPTY(chain)) { + LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { /* Block(s) present, lets find space, and expire on the fly */ - LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { - for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { - if ((twait_block->vtag_block[i].v_tag == 0) && - !set) { - twait_block->vtag_block[i].tv_sec_at_expire = - now.tv_sec + time; + for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { + if ((twait_block->vtag_block[i].v_tag == 0) && + !set) { + twait_block->vtag_block[i].tv_sec_at_expire = + now.tv_sec + time; + twait_block->vtag_block[i].v_tag = tag; + twait_block->vtag_block[i].lport = lport; + twait_block->vtag_block[i].rport = rport; + set = 1; + } else if ((twait_block->vtag_block[i].v_tag) && + ((long)twait_block->vtag_block[i].tv_sec_at_expire < now.tv_sec)) { + /* Audit expires this guy */ + twait_block->vtag_block[i].tv_sec_at_expire = 0; + twait_block->vtag_block[i].v_tag = 0; + twait_block->vtag_block[i].lport = 0; + twait_block->vtag_block[i].rport = 0; + if (set == 0) { + /* Reuse it for my new tag */ + twait_block->vtag_block[i].tv_sec_at_expire = now.tv_sec + time; twait_block->vtag_block[i].v_tag = tag; twait_block->vtag_block[i].lport = lport; twait_block->vtag_block[i].rport = rport; set = 1; - } else if ((twait_block->vtag_block[i].v_tag) && - ((long)twait_block->vtag_block[i].tv_sec_at_expire < now.tv_sec)) { - /* Audit expires this guy */ - twait_block->vtag_block[i].tv_sec_at_expire = 0; - twait_block->vtag_block[i].v_tag = 0; - twait_block->vtag_block[i].lport = 0; - twait_block->vtag_block[i].rport = 0; - if (set == 0) { - /* Reuse it for my new tag */ - twait_block->vtag_block[i].tv_sec_at_expire = now.tv_sec + time; - twait_block->vtag_block[i].v_tag = tag; - twait_block->vtag_block[i].lport = lport; - twait_block->vtag_block[i].rport = rport; - set = 1; - } } } - if (set) { - /* - * We only do up to the block where we can - * place our tag for audits - */ - break; - } + } + if (set) { + /* + * We only do up to the block where we can place our + * tag for audits + */ + break; } } /* Need to add a new block to chain */ @@ -6700,30 +6694,28 @@ skip_vtag_check: chain = &SCTP_BASE_INFO(vtag_timewait)[(tag % SCTP_STACK_VTAG_HASH_SIZE)]; /* Now what about timed wait ? */ - if (!LIST_EMPTY(chain)) { + LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { /* * Block(s) are present, lets see if we have this tag in the * list */ - LIST_FOREACH(twait_block, chain, sctp_nxt_tagblock) { - for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { - if (twait_block->vtag_block[i].v_tag == 0) { - /* not used */ - continue; - } else if ((long)twait_block->vtag_block[i].tv_sec_at_expire < - now->tv_sec) { - /* Audit expires this guy */ - twait_block->vtag_block[i].tv_sec_at_expire = 0; - twait_block->vtag_block[i].v_tag = 0; - twait_block->vtag_block[i].lport = 0; - twait_block->vtag_block[i].rport = 0; - } else if ((twait_block->vtag_block[i].v_tag == tag) && - (twait_block->vtag_block[i].lport == lport) && - (twait_block->vtag_block[i].rport == rport)) { - /* Bad tag, sorry :< */ - SCTP_INP_INFO_RUNLOCK(); - return (0); - } + for (i = 0; i < SCTP_NUMBER_IN_VTAG_BLOCK; i++) { + if (twait_block->vtag_block[i].v_tag == 0) { + /* not used */ + continue; + } else if ((long)twait_block->vtag_block[i].tv_sec_at_expire < + now->tv_sec) { + /* Audit expires this guy */ + twait_block->vtag_block[i].tv_sec_at_expire = 0; + twait_block->vtag_block[i].v_tag = 0; + twait_block->vtag_block[i].lport = 0; + twait_block->vtag_block[i].rport = 0; + } else if ((twait_block->vtag_block[i].v_tag == tag) && + (twait_block->vtag_block[i].lport == lport) && + (twait_block->vtag_block[i].rport == rport)) { + /* Bad tag, sorry :< */ + SCTP_INP_INFO_RUNLOCK(); + return (0); } } } diff --git a/sys/netinet6/in6.c b/sys/netinet6/in6.c index 80359c1..9e005c5 100644 --- a/sys/netinet6/in6.c +++ b/sys/netinet6/in6.c @@ -1987,6 +1987,32 @@ in6ifa_ifpwithaddr(struct ifnet *ifp, struct in6_addr *addr) } /* + * Find a link-local scoped address on ifp and return it if any. + */ +struct in6_ifaddr * +in6ifa_llaonifp(struct ifnet *ifp) +{ + struct sockaddr_in6 *sin6; + struct ifaddr *ifa; + + if (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) + return (NULL); + if_addr_rlock(ifp); + TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { + if (ifa->ifa_addr->sa_family != AF_INET6) + continue; + sin6 = (struct sockaddr_in6 *)ifa->ifa_addr; + if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) || + IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr) || + IN6_IS_ADDR_MC_NODELOCAL(&sin6->sin6_addr)) + break; + } + if_addr_runlock(ifp); + + return ((struct in6_ifaddr *)ifa); +} + +/* * Convert IP6 address to printable (loggable) representation. Caller * has to make sure that ip6buf is at least INET6_ADDRSTRLEN long. */ diff --git a/sys/netinet6/in6_ifattach.c b/sys/netinet6/in6_ifattach.c index 85890ab..674356a 100644 --- a/sys/netinet6/in6_ifattach.c +++ b/sys/netinet6/in6_ifattach.c @@ -266,6 +266,7 @@ found: /* get EUI64 */ switch (ifp->if_type) { + case IFT_BRIDGE: case IFT_ETHER: case IFT_L2VLAN: case IFT_FDDI: @@ -727,6 +728,8 @@ in6_ifattach(struct ifnet *ifp, struct ifnet *altifp) switch (ifp->if_type) { case IFT_PFLOG: case IFT_PFSYNC: + ND_IFINFO(ifp)->flags &= ~ND6_IFF_AUTO_LINKLOCAL; + ND_IFINFO(ifp)->flags |= ND6_IFF_IFDISABLED; return; } @@ -734,7 +737,6 @@ in6_ifattach(struct ifnet *ifp, struct ifnet *altifp) * quirks based on interface type */ switch (ifp->if_type) { -#ifdef IFT_STF case IFT_STF: /* * 6to4 interface is a very special kind of beast. @@ -742,8 +744,8 @@ in6_ifattach(struct ifnet *ifp, struct ifnet *altifp) * linklocals for 6to4 interface, but there's no use and * it is rather harmful to have one. */ - goto statinit; -#endif + ND_IFINFO(ifp)->flags &= ~ND6_IFF_AUTO_LINKLOCAL; + break; default: break; } @@ -777,8 +779,7 @@ in6_ifattach(struct ifnet *ifp, struct ifnet *altifp) /* * assign a link-local address, if there's none. */ - if (ifp->if_type != IFT_BRIDGE && - !(ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) && + if (!(ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) && ND_IFINFO(ifp)->flags & ND6_IFF_AUTO_LINKLOCAL) { int error; @@ -795,10 +796,6 @@ in6_ifattach(struct ifnet *ifp, struct ifnet *altifp) ifa_free(&ia->ia_ifa); } -#ifdef IFT_STF /* XXX */ -statinit: -#endif - /* update dynamically. */ if (V_in6_maxmtu < ifp->if_mtu) V_in6_maxmtu = ifp->if_mtu; diff --git a/sys/netinet6/in6_pcb.c b/sys/netinet6/in6_pcb.c index d5db387..a0a6874 100644 --- a/sys/netinet6/in6_pcb.c +++ b/sys/netinet6/in6_pcb.c @@ -243,8 +243,7 @@ in6_pcbbind(register struct inpcb *inp, struct sockaddr *nam, if (tw == NULL || (reuseport & tw->tw_so_options) == 0) return (EADDRINUSE); - } else if (t && (reuseport == 0 || - (t->inp_flags2 & INP_REUSEPORT) == 0)) { + } else if (t && (reuseport & inp_so_options(t)) == 0) { return (EADDRINUSE); } #ifdef INET @@ -265,8 +264,8 @@ in6_pcbbind(register struct inpcb *inp, struct sockaddr *nam, INP_IPV6PROTO) == (t->inp_vflag & INP_IPV6PROTO)))) return (EADDRINUSE); - } else if (t && (reuseport == 0 || - (t->inp_flags2 & INP_REUSEPORT) == 0) && + } else if (t && + (reuseport & inp_so_options(t)) == 0 && (ntohl(t->inp_laddr.s_addr) != INADDR_ANY || (t->inp_vflag & INP_IPV6PROTO) != 0)) return (EADDRINUSE); diff --git a/sys/netinet6/in6_var.h b/sys/netinet6/in6_var.h index 3b4e89e..b3f7218 100644 --- a/sys/netinet6/in6_var.h +++ b/sys/netinet6/in6_var.h @@ -800,6 +800,7 @@ void in6_setmaxmtu(void); int in6_if2idlen(struct ifnet *); struct in6_ifaddr *in6ifa_ifpforlinklocal(struct ifnet *, int); struct in6_ifaddr *in6ifa_ifpwithaddr(struct ifnet *, struct in6_addr *); +struct in6_ifaddr *in6ifa_llaonifp(struct ifnet *); char *ip6_sprintf(char *, const struct in6_addr *); int in6_addr2zoneid(struct ifnet *, struct in6_addr *, u_int32_t *); int in6_matchlen(struct in6_addr *, struct in6_addr *); diff --git a/sys/netinet6/ip6_output.c b/sys/netinet6/ip6_output.c index 2736566..5df3572 100644 --- a/sys/netinet6/ip6_output.c +++ b/sys/netinet6/ip6_output.c @@ -1477,13 +1477,10 @@ ip6_ctloutput(struct socket *so, struct sockopt *sopt) switch (sopt->sopt_name) { case SO_REUSEADDR: INP_WLOCK(in6p); - if (IN_MULTICAST(ntohl(in6p->inp_laddr.s_addr))) { - if ((so->so_options & - (SO_REUSEADDR | SO_REUSEPORT)) != 0) - in6p->inp_flags2 |= INP_REUSEPORT; - else - in6p->inp_flags2 &= ~INP_REUSEPORT; - } + if ((so->so_options & SO_REUSEADDR) != 0) + in6p->inp_flags2 |= INP_REUSEADDR; + else + in6p->inp_flags2 &= ~INP_REUSEADDR; INP_WUNLOCK(in6p); error = 0; break; diff --git a/sys/netinet6/nd6.c b/sys/netinet6/nd6.c index 0e30825..0a67a8a 100644 --- a/sys/netinet6/nd6.c +++ b/sys/netinet6/nd6.c @@ -176,13 +176,25 @@ nd6_ifattach(struct ifnet *ifp) nd->flags = ND6_IFF_PERFORMNUD; - /* A loopback interface always has ND6_IFF_AUTO_LINKLOCAL. */ - if (V_ip6_auto_linklocal || (ifp->if_flags & IFF_LOOPBACK)) + /* A loopback interface always has ND6_IFF_AUTO_LINKLOCAL. + * XXXHRS: Clear ND6_IFF_AUTO_LINKLOCAL on an IFT_BRIDGE interface by + * default regardless of the V_ip6_auto_linklocal configuration to + * give a reasonable default behavior. + */ + if ((V_ip6_auto_linklocal && ifp->if_type != IFT_BRIDGE) || + (ifp->if_flags & IFF_LOOPBACK)) nd->flags |= ND6_IFF_AUTO_LINKLOCAL; - - /* A loopback interface does not need to accept RTADV. */ - if (V_ip6_accept_rtadv && !(ifp->if_flags & IFF_LOOPBACK)) - nd->flags |= ND6_IFF_ACCEPT_RTADV; + /* + * A loopback interface does not need to accept RTADV. + * XXXHRS: Clear ND6_IFF_ACCEPT_RTADV on an IFT_BRIDGE interface by + * default regardless of the V_ip6_accept_rtadv configuration to + * prevent the interface from accepting RA messages arrived + * on one of the member interfaces with ND6_IFF_ACCEPT_RTADV. + */ + if (V_ip6_accept_rtadv && + !(ifp->if_flags & IFF_LOOPBACK) && + (ifp->if_type != IFT_BRIDGE)) + nd->flags |= ND6_IFF_ACCEPT_RTADV; if (V_ip6_no_radr && !(ifp->if_flags & IFF_LOOPBACK)) nd->flags |= ND6_IFF_NO_RADR; diff --git a/sys/netsmb/smb_conn.c b/sys/netsmb/smb_conn.c index 190d127..d58bc72 100644 --- a/sys/netsmb/smb_conn.c +++ b/sys/netsmb/smb_conn.c @@ -530,7 +530,6 @@ smb_vc_free(struct smb_connobj *cp) /* * Called when use count of VC dropped to zero. - * VC should be locked on enter with LK_DRAIN. */ static void smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred) diff --git a/sys/nfsclient/nfs_subs.c b/sys/nfsclient/nfs_subs.c index c41bc61..5dfab1c 100644 --- a/sys/nfsclient/nfs_subs.c +++ b/sys/nfsclient/nfs_subs.c @@ -581,6 +581,7 @@ nfs_loadattrcache(struct vnode **vpp, struct mbuf **mdp, caddr_t *dposp, vap->va_size = np->n_size; np->n_attrstamp = 0; KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp); + vnode_pager_setsize(vp, np->n_size); } else if (np->n_flag & NMODIFIED) { /* * We've modified the file: Use the larger @@ -592,12 +593,22 @@ nfs_loadattrcache(struct vnode **vpp, struct mbuf **mdp, caddr_t *dposp, np->n_size = vap->va_size; np->n_flag |= NSIZECHANGED; } + vnode_pager_setsize(vp, np->n_size); + } else if (vap->va_size < np->n_size) { + /* + * When shrinking the size, the call to + * vnode_pager_setsize() cannot be done + * with the mutex held, so delay it until + * after the mtx_unlock call. + */ + nsize = np->n_size = vap->va_size; + np->n_flag |= NSIZECHANGED; + setnsize = 1; } else { np->n_size = vap->va_size; np->n_flag |= NSIZECHANGED; + vnode_pager_setsize(vp, np->n_size); } - setnsize = 1; - nsize = vap->va_size; } else { np->n_size = vap->va_size; } diff --git a/sys/nfsclient/nfs_vnops.c b/sys/nfsclient/nfs_vnops.c index d834b89..69ff21d 100644 --- a/sys/nfsclient/nfs_vnops.c +++ b/sys/nfsclient/nfs_vnops.c @@ -1379,8 +1379,8 @@ nfs_writerpc(struct vnode *vp, struct uio *uiop, struct ucred *cred, while (tsiz > 0) { nfsstats.rpccnt[NFSPROC_WRITE]++; len = (tsiz > wsize) ? wsize : tsiz; - mreq = m_get2(NFSX_FH(v3) + 5 * NFSX_UNSIGNED + nfsm_rndup(len), - M_WAITOK, MT_DATA, 0); + mreq = m_get2(NFSX_FH(v3) + 5 * NFSX_UNSIGNED, M_WAITOK, + MT_DATA, 0); mb = mreq; bpos = mtod(mb, caddr_t); nfsm_fhtom(vp, v3); diff --git a/sys/powerpc/include/counter.h b/sys/powerpc/include/counter.h index 81b6bbc..e876f62 100644 --- a/sys/powerpc/include/counter.h +++ b/sys/powerpc/include/counter.h @@ -39,6 +39,44 @@ #define counter_enter() do {} while (0) #define counter_exit() do {} while (0) +#ifdef IN_SUBR_COUNTER_C +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, i) counter_u64_add(c, i) extern struct pcpu __pcpu[MAXCPU]; @@ -65,6 +103,46 @@ counter_u64_add(counter_u64_t c, int64_t inc) #define counter_enter() critical_enter() #define counter_exit() critical_exit() +#ifdef IN_SUBR_COUNTER_C +/* XXXKIB non-atomic 64bit read */ +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +/* XXXKIB non-atomic 64bit store, might interrupt increment */ +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, inc) do { \ CRITICAL_ASSERT(curthread); \ *(uint64_t *)zpcpu_get(c) += (inc); \ diff --git a/sys/powerpc/wii/wii_ipcreg.h b/sys/powerpc/wii/wii_ipcreg.h index 197a4e0..86b3e1f 100644 --- a/sys/powerpc/wii/wii_ipcreg.h +++ b/sys/powerpc/wii/wii_ipcreg.h @@ -34,4 +34,69 @@ #define WIIIPC_IOH_ADDR 0x133e0000 #define WIIIPC_IOH_LEN 0xc20000 +#define WIIIPC_TXBUF 0x00 +#define WIIIPC_CSR 0x04 +#define WIIIPC_CSR_TXSTART 0x01 +#define WIIIPC_CSR_TBEI 0x02 +#define WIIIPC_CSR_RBFI 0x04 +#define WIIIPC_CSR_RXREADY 0x08 +#define WIIIPC_CSR_RBFIMASK 0x10 +#define WIIIPC_CSR_TBEIMASK 0x20 +#define WIIIPC_RXBUF 0x08 +#define WIIIPC_ISR 0x30 +#define WIIIPC_ISR_MAGIC 0x40000000 + +enum wiiipc_cmd { + WIIIPC_CMD_OPEN = 1, + WIIIPC_CMD_CLOSE = 2, + WIIIPC_CMD_READ = 3, + WIIIPC_CMD_WRITE = 4, + WIIIPC_CMD_SEEK = 5, + WIIIPC_CMD_IOCTL = 6, + WIIIPC_CMD_IOCTLV = 7, + WIIIPC_CMD_ASYNCRESP = 8 +}; + +struct wiiipc_ipc_msg { + uint32_t ipc_cmd; + int32_t ipc_result; + int32_t ipc_fd; /* WIIIPC_CMD_ASYNCRESP - the original cmd */ + union { + struct { + intptr_t pathname; + uint32_t mode; + } _ipc_open; + struct { + intptr_t data; + uint32_t len; + } _ipc_read, _ipc_write; + struct { + int32_t offset; + int32_t whence; + } _ipc_seek; + struct { + uint32_t request; + intptr_t ibuf; + uint32_t ilen; + intptr_t obuf; + uint32_t olen; + } _ipc_ioctl; + struct { + uint32_t request; + uint32_t argin; + uint32_t argout; + intptr_t iovec; + } _ipc_ioctlv; + uint32_t _ipc_argv[5]; + } args; +} __attribute__((packed)); + +CTASSERT(sizeof(struct wiiipc_ipc_msg) == 32); + +#define ipc_open args._ipc_open +#define ipc_read args._ipc_read +#define ipc_write args._ipc_write +#define ipc_ioctl args._ipc_ioctl +#define ipc_ioctlv args._ipc_ioctlv + #endif /* _POWERPC_WII_WII_IPCREG_H */ diff --git a/sys/sparc64/include/counter.h b/sys/sparc64/include/counter.h index 68f89e2..a3fe871 100644 --- a/sys/sparc64/include/counter.h +++ b/sys/sparc64/include/counter.h @@ -37,6 +37,45 @@ #define counter_enter() critical_enter() #define counter_exit() critical_exit() +#ifdef IN_SUBR_COUNTER_C +static inline uint64_t +counter_u64_read_one(uint64_t *p, int cpu) +{ + + return (*(uint64_t *)((char *)p + sizeof(struct pcpu) * cpu)); +} + +static inline uint64_t +counter_u64_fetch_inline(uint64_t *p) +{ + uint64_t r; + int i; + + r = 0; + for (i = 0; i < mp_ncpus; i++) + r += counter_u64_read_one((uint64_t *)p, i); + + return (r); +} + +/* XXXKIB might interrupt increment */ +static void +counter_u64_zero_one_cpu(void *arg) +{ + + *((uint64_t *)((char *)arg + sizeof(struct pcpu) * + PCPU_GET(cpuid))) = 0; +} + +static inline void +counter_u64_zero_inline(counter_u64_t c) +{ + + smp_rendezvous(smp_no_rendevous_barrier, counter_u64_zero_one_cpu, + smp_no_rendevous_barrier, c); +} +#endif + #define counter_u64_add_protected(c, inc) do { \ CRITICAL_ASSERT(curthread); \ *(uint64_t *)zpcpu_get(c) += (inc); \ diff --git a/sys/sys/bus.h b/sys/sys/bus.h index 152b067..06e0f6c 100644 --- a/sys/sys/bus.h +++ b/sys/sys/bus.h @@ -273,6 +273,9 @@ struct resource * int resource_list_release(struct resource_list *rl, device_t bus, device_t child, int type, int rid, struct resource *res); +int resource_list_release_active(struct resource_list *rl, + device_t bus, device_t child, + int type); struct resource * resource_list_reserve(struct resource_list *rl, device_t bus, device_t child, diff --git a/sys/sys/malloc.h b/sys/sys/malloc.h index b0e1805..8f51606 100644 --- a/sys/sys/malloc.h +++ b/sys/sys/malloc.h @@ -51,6 +51,8 @@ #define M_NOVM 0x0200 /* don't ask VM for pages */ #define M_USE_RESERVE 0x0400 /* can alloc out of reserve memory */ #define M_NODUMP 0x0800 /* don't dump pages in this allocation */ +#define M_FIRSTFIT 0x1000 /* Only for vmem, fast fit. */ +#define M_BESTFIT 0x2000 /* Only for vmem, low fragmentation. */ #define M_MAGIC 877983977 /* time when first defined :-) */ diff --git a/sys/sys/socketvar.h b/sys/sys/socketvar.h index 77f31df..89dec18 100644 --- a/sys/sys/socketvar.h +++ b/sys/sys/socketvar.h @@ -371,6 +371,8 @@ void soupcall_clear(struct socket *so, int which); void soupcall_set(struct socket *so, int which, int (*func)(struct socket *, void *, int), void *arg); void sowakeup(struct socket *so, struct sockbuf *sb); +int selsocket(struct socket *so, int events, struct timeval *tv, + struct thread *td); /* * Accept filter functions (duh). diff --git a/sys/sys/stdatomic.h b/sys/sys/stdatomic.h index 8d7a20b..054ded6 100644 --- a/sys/sys/stdatomic.h +++ b/sys/sys/stdatomic.h @@ -122,33 +122,44 @@ * atomic operations. */ -enum memory_order { +typedef enum { memory_order_relaxed = __ATOMIC_RELAXED, memory_order_consume = __ATOMIC_CONSUME, memory_order_acquire = __ATOMIC_ACQUIRE, memory_order_release = __ATOMIC_RELEASE, memory_order_acq_rel = __ATOMIC_ACQ_REL, memory_order_seq_cst = __ATOMIC_SEQ_CST -}; +} memory_order; /* * 7.17.4 Fences. */ +static __inline void +atomic_thread_fence(memory_order __order __unused) +{ + #ifdef __CLANG_ATOMICS -#define atomic_thread_fence(order) __c11_atomic_thread_fence(order) -#define atomic_signal_fence(order) __c11_atomic_signal_fence(order) + __c11_atomic_thread_fence(__order); #elif defined(__GNUC_ATOMICS) -#define atomic_thread_fence(order) __atomic_thread_fence(order) -#define atomic_signal_fence(order) __atomic_signal_fence(order) + __atomic_thread_fence(__order); #else -#define atomic_thread_fence(order) ((void)(order), __sync_synchronize()) -#define atomic_signal_fence(order) __extension__ ({ \ - (void)(order); \ - __asm volatile ("" ::: "memory"); \ - (void)0; \ -}) + __sync_synchronize(); +#endif +} + +static __inline void +atomic_signal_fence(memory_order __order __unused) +{ + +#ifdef __CLANG_ATOMICS + __c11_atomic_signal_fence(__order); +#elif defined(__GNUC_ATOMICS) + __atomic_signal_fence(__order); +#else + __asm volatile ("" ::: "memory"); #endif +} /* * 7.17.5 Lock-free property. @@ -270,6 +281,8 @@ typedef _Atomic(__uintmax_t) atomic_uintmax_t; #define atomic_store_explicit(object, desired, order) \ __atomic_store_n(&(object)->__val, desired, order) #else +#define __atomic_apply_stride(object, operand) \ + (((__typeof__((object)->__val))0) + (operand)) #define atomic_compare_exchange_strong_explicit(object, expected, \ desired, success, failure) __extension__ ({ \ __typeof__(expected) __ep = (expected); \ @@ -302,13 +315,15 @@ __extension__ ({ \ }) #endif #define atomic_fetch_add_explicit(object, operand, order) \ - ((void)(order), __sync_fetch_and_add(&(object)->__val, operand)) + ((void)(order), __sync_fetch_and_add(&(object)->__val, \ + __atomic_apply_stride(object, operand))) #define atomic_fetch_and_explicit(object, operand, order) \ ((void)(order), __sync_fetch_and_and(&(object)->__val, operand)) #define atomic_fetch_or_explicit(object, operand, order) \ ((void)(order), __sync_fetch_and_or(&(object)->__val, operand)) #define atomic_fetch_sub_explicit(object, operand, order) \ - ((void)(order), __sync_fetch_and_sub(&(object)->__val, operand)) + ((void)(order), __sync_fetch_and_sub(&(object)->__val, \ + __atomic_apply_stride(object, operand))) #define atomic_fetch_xor_explicit(object, operand, order) \ ((void)(order), __sync_fetch_and_xor(&(object)->__val, operand)) #define atomic_load_explicit(object, order) \ @@ -319,8 +334,12 @@ __extension__ ({ \ /* * Convenience functions. + * + * Don't provide these in kernel space. In kernel space, we should be + * disciplined enough to always provide explicit barriers. */ +#ifndef _KERNEL #define atomic_compare_exchange_strong(object, expected, desired) \ atomic_compare_exchange_strong_explicit(object, expected, \ desired, memory_order_seq_cst, memory_order_seq_cst) @@ -343,23 +362,54 @@ __extension__ ({ \ atomic_load_explicit(object, memory_order_seq_cst) #define atomic_store(object, desired) \ atomic_store_explicit(object, desired, memory_order_seq_cst) +#endif /* !_KERNEL */ /* * 7.17.8 Atomic flag type and operations. + * + * XXX: Assume atomic_bool can be used as an atomic_flag. Is there some + * kind of compiler built-in type we could use? */ -typedef atomic_bool atomic_flag; +typedef struct { + atomic_bool __flag; +} atomic_flag; + +#define ATOMIC_FLAG_INIT { ATOMIC_VAR_INIT(0) } + +static __inline _Bool +atomic_flag_test_and_set_explicit(volatile atomic_flag *__object, + memory_order __order) +{ + _Bool __expected; + + __expected = 0; + return (atomic_compare_exchange_strong_explicit(&__object->__flag, + &__expected, 1, __order, __order)); +} + +static __inline void +atomic_flag_clear_explicit(volatile atomic_flag *__object, memory_order __order) +{ + + atomic_store_explicit(&__object->__flag, 0, __order); +} + +#ifndef _KERNEL +static __inline _Bool +atomic_flag_test_and_set(volatile atomic_flag *__object) +{ -#define ATOMIC_FLAG_INIT ATOMIC_VAR_INIT(0) + return (atomic_flag_test_and_set_explicit(__object, + memory_order_seq_cst)); +} -#define atomic_flag_clear_explicit(object, order) \ - atomic_store_explicit(object, 0, order) -#define atomic_flag_test_and_set_explicit(object, order) \ - atomic_compare_exchange_strong_explicit(object, 0, 1, order, order) +static __inline void +atomic_flag_clear(volatile atomic_flag *__object) +{ -#define atomic_flag_clear(object) \ - atomic_flag_clear_explicit(object, memory_order_seq_cst) -#define atomic_flag_test_and_set(object) \ - atomic_flag_test_and_set_explicit(object, memory_order_seq_cst) + atomic_flag_clear_explicit(__object, memory_order_seq_cst); +} +#endif /* !_KERNEL */ #endif /* !_STDATOMIC_H_ */ diff --git a/sys/sys/vmem.h b/sys/sys/vmem.h new file mode 100644 index 0000000..47f55fb --- /dev/null +++ b/sys/sys/vmem.h @@ -0,0 +1,135 @@ +/*- + * Copyright (c)2006 YAMAMOTO Takashi, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* From $NetBSD: vmem.h,v 1.20 2013/01/29 21:26:24 para Exp $ */ + +/* $FreeBSD$ */ + +#ifndef _SYS_VMEM_H_ +#define _SYS_VMEM_H_ + +#include <sys/types.h> + +#ifdef _KERNEL + +typedef struct vmem vmem_t; + +typedef uintptr_t vmem_addr_t; +typedef size_t vmem_size_t; + +#define VMEM_ADDR_MIN 0 +#define VMEM_ADDR_MAX (~(vmem_addr_t)0) + +typedef int (vmem_import_t)(void *, vmem_size_t, int, vmem_addr_t *); +typedef void (vmem_release_t)(void *, vmem_addr_t, vmem_size_t); +typedef void (vmem_reclaim_t)(vmem_t *, int); + +/* + * Create a vmem: + * name - Name of the region + * base - Initial span start (optional) + * size - Initial span size + * quantum - Natural unit of allocation (ie PAGE_SIZE, 1, etc) + * qcache_max - Maximum size to quantum cache. This creates a UMA + * cache for each multiple of quantum up to qcache_max. + * flags - M_* flags + */ +vmem_t *vmem_create(const char *name, vmem_addr_t base, + vmem_size_t size, vmem_size_t quantum, vmem_size_t qcache_max, int flags); +vmem_t *vmem_init(vmem_t *vm, const char *name, vmem_addr_t base, + vmem_size_t size, vmem_size_t quantum, vmem_size_t qcache_max, int flags); +void vmem_destroy(vmem_t *); + +/* + * Set callbacks for bringing in dynamic regions: + * importfn - Backing store import routine. + * releasefn - Backing store release routine. + * arg - Backing store argument + * import_quantum - Size to import from backing store + */ + +void vmem_set_import(vmem_t *vm, vmem_import_t *importfn, + vmem_release_t *releasefn, void *arg, vmem_size_t import_quantum); + +/* + * Set a callback for reclaiming memory when space is exhausted: + */ +void vmem_set_reclaim(vmem_t *vm, vmem_reclaim_t *reclaimfn); + +/* + * Allocate and free linear regions from a vmem. Must specify + * BESTFIT or FIRSTFIT. Free is non-blocking. These routines + * respect the quantum caches. + */ +int vmem_alloc(vmem_t *vm, vmem_size_t size, int flags, vmem_addr_t *addrp); +void vmem_free(vmem_t *vm, vmem_addr_t addr, vmem_size_t size); + +/* + * Constrained allocate and free routines. These bypass the quantum cache. + * size - Size in units of 1, not quantum. + * align - Required alignment of the start of region + * phase - Offset from alignment + * nocross - Illegal boundary + * minaddr - Minimum allowed address for last byte + * maxaddr - Maximum allowed address for first byte + * flags - M_* flags + * addrp - result + */ +int vmem_xalloc(vmem_t *vm, vmem_size_t size, vmem_size_t align, + vmem_size_t phase, vmem_size_t nocross, vmem_addr_t minaddr, + vmem_addr_t maxaddr, int flags, vmem_addr_t *addrp); +void vmem_xfree(vmem_t *vm, vmem_addr_t addr, vmem_size_t size); + +/* + * Add a static region to a vmem after create. This won't be freed + * until the vmem is destroyed. + */ +int vmem_add(vmem_t *vm, vmem_addr_t addr, vmem_size_t size, int flags); + +/* + * Given roundup size to the vmem's native quantum size. + */ +vmem_size_t vmem_roundup_size(vmem_t *vm, vmem_size_t size); + +/* + * Report vmem utilization according to the requested type. + */ +vmem_size_t vmem_size(vmem_t *vm, int typemask); + +void vmem_whatis(vmem_addr_t addr, int (*fn)(const char *, ...) + __printflike(1, 2)); +void vmem_print(vmem_addr_t addr, const char *, int (*fn)(const char *, ...) + __printflike(1, 2)); +void vmem_printall(const char *, int (*fn)(const char *, ...) + __printflike(1, 2)); +void vmem_startup(void); + +/* vmem_size typemask */ +#define VMEM_ALLOC 0x01 +#define VMEM_FREE 0x02 + +#endif /* _KERNEL */ + +#endif /* !_SYS_VMEM_H_ */ diff --git a/sys/ufs/ffs/ffs_alloc.c b/sys/ufs/ffs/ffs_alloc.c index d7db636..287ccbb 100644 --- a/sys/ufs/ffs/ffs_alloc.c +++ b/sys/ufs/ffs/ffs_alloc.c @@ -1710,7 +1710,7 @@ ffs_alloccgblk(ip, bp, bpref, size) cgp = (struct cg *)bp->b_data; blksfree = cg_blksfree(cgp); if (bpref == 0) { - bpref = cgp->cg_rotor; + bpref = cgbase(fs, cgp->cg_cgx) + cgp->cg_rotor + fs->fs_frag; } else if ((cgbpref = dtog(fs, bpref)) != cgp->cg_cgx) { /* map bpref to correct zone in this cg */ if (bpref < cgdata(fs, cgbpref)) diff --git a/sys/ufs/ffs/ffs_balloc.c b/sys/ufs/ffs/ffs_balloc.c index 1e809bb..1b830ae 100644 --- a/sys/ufs/ffs/ffs_balloc.c +++ b/sys/ufs/ffs/ffs_balloc.c @@ -299,6 +299,10 @@ retry: continue; } UFS_LOCK(ump); + /* + * If parent indirect has just been allocated, try to cluster + * immediately following it. + */ if (pref == 0) pref = ffs_blkpref_ufs1(ip, lbn, i - num - 1, (ufs1_daddr_t *)0); @@ -368,7 +372,14 @@ retry: */ if (nb == 0) { UFS_LOCK(ump); - if (pref == 0) + /* + * If allocating metadata at the front of the cylinder + * group and parent indirect block has just been allocated, + * then cluster next to it if it is the first indirect in + * the file. Otherwise it has been allocated in the metadata + * area, so we want to find our own place out in the data area. + */ + if (pref == 0 || (lbn > NDADDR && fs->fs_metaspace != 0)) pref = ffs_blkpref_ufs1(ip, lbn, indirs[i].in_off, &bap[0]); error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, @@ -850,6 +861,10 @@ retry: continue; } UFS_LOCK(ump); + /* + * If parent indirect has just been allocated, try to cluster + * immediately following it. + */ if (pref == 0) pref = ffs_blkpref_ufs2(ip, lbn, i - num - 1, (ufs2_daddr_t *)0); @@ -920,7 +935,14 @@ retry: */ if (nb == 0) { UFS_LOCK(ump); - if (pref == 0) + /* + * If allocating metadata at the front of the cylinder + * group and parent indirect block has just been allocated, + * then cluster next to it if it is the first indirect in + * the file. Otherwise it has been allocated in the metadata + * area, so we want to find our own place out in the data area. + */ + if (pref == 0 || (lbn > NDADDR && fs->fs_metaspace != 0)) pref = ffs_blkpref_ufs2(ip, lbn, indirs[i].in_off, &bap[0]); error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, diff --git a/sys/ufs/ufs/dinode.h b/sys/ufs/ufs/dinode.h index 8aa1fe0..6d06bde 100644 --- a/sys/ufs/ufs/dinode.h +++ b/sys/ufs/ufs/dinode.h @@ -138,7 +138,7 @@ struct ufs2_dinode { int32_t di_atimensec; /* 68: Last access time. */ int32_t di_ctimensec; /* 72: Last inode change time. */ int32_t di_birthnsec; /* 76: Inode creation time. */ - int32_t di_gen; /* 80: Generation number. */ + u_int32_t di_gen; /* 80: Generation number. */ u_int32_t di_kernflags; /* 84: Kernel flags. */ u_int32_t di_flags; /* 88: Status flags (chflags). */ int32_t di_extsize; /* 92: External attributes block. */ @@ -180,7 +180,7 @@ struct ufs1_dinode { ufs1_daddr_t di_ib[NIADDR]; /* 88: Indirect disk blocks. */ u_int32_t di_flags; /* 100: Status flags (chflags). */ int32_t di_blocks; /* 104: Blocks actually held. */ - int32_t di_gen; /* 108: Generation number. */ + u_int32_t di_gen; /* 108: Generation number. */ u_int32_t di_uid; /* 112: File owner. */ u_int32_t di_gid; /* 116: File group. */ u_int64_t di_modrev; /* 120: i_modrev for NFSv4 */ diff --git a/sys/ufs/ufs/inode.h b/sys/ufs/ufs/inode.h index 6416632..97ec63f 100644 --- a/sys/ufs/ufs/inode.h +++ b/sys/ufs/ufs/inode.h @@ -102,7 +102,7 @@ struct inode { int16_t i_nlink; /* File link count. */ u_int64_t i_size; /* File byte count. */ u_int32_t i_flags; /* Status flags (chflags). */ - int64_t i_gen; /* Generation number. */ + u_int64_t i_gen; /* Generation number. */ u_int32_t i_uid; /* File owner. */ u_int32_t i_gid; /* File group. */ /* diff --git a/sys/ufs/ufs/ufs_extattr.c b/sys/ufs/ufs/ufs_extattr.c index d52f650..209d93e 100644 --- a/sys/ufs/ufs/ufs_extattr.c +++ b/sys/ufs/ufs/ufs_extattr.c @@ -399,20 +399,8 @@ ufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp, return (error); } - /* - * XXXRW: While in UFS, we always get DIRBLKSIZ returns from - * the directory code on success, on other file systems this - * may not be the case. For portability, we should check the - * read length on return from ufs_readdir(). - */ - edp = (struct dirent *)&dirbuf[DIRBLKSIZ]; + edp = (struct dirent *)&dirbuf[DIRBLKSIZ - auio.uio_resid]; for (dp = (struct dirent *)dirbuf; dp < edp; ) { -#if (BYTE_ORDER == LITTLE_ENDIAN) - dp->d_type = dp->d_namlen; - dp->d_namlen = 0; -#else - dp->d_type = 0; -#endif if (dp->d_reclen == 0) break; error = ufs_extattr_lookup(dvp, UE_GETDIR_LOCKPARENT, @@ -934,8 +922,8 @@ ufs_extattr_get(struct vnode *vp, int attrnamespace, const char *name, * is to coerce this to undefined, and let it get cleaned * up by the next write or extattrctl clean. */ - printf("ufs_extattr_get (%s): inode number inconsistency (%d, %jd)\n", - mp->mnt_stat.f_mntonname, ueh.ueh_i_gen, (intmax_t)ip->i_gen); + printf("ufs_extattr_get (%s): inode number inconsistency (%d, %ju)\n", + mp->mnt_stat.f_mntonname, ueh.ueh_i_gen, (uintmax_t)ip->i_gen); error = ENOATTR; goto vopunlock_exit; } diff --git a/sys/ufs/ufs/ufs_vnops.c b/sys/ufs/ufs/ufs_vnops.c index 574c59c..14df1f3 100644 --- a/sys/ufs/ufs/ufs_vnops.c +++ b/sys/ufs/ufs/ufs_vnops.c @@ -2161,12 +2161,6 @@ ufs_symlink(ap) /* * Vnode op for reading directories. - * - * The routine below assumes that the on-disk format of a directory - * is the same as that defined by <sys/dirent.h>. If the on-disk - * format changes, then it will be necessary to do a conversion - * from the on-disk format that read returns to the format defined - * by <sys/dirent.h>. */ int ufs_readdir(ap) @@ -2179,103 +2173,123 @@ ufs_readdir(ap) u_long **a_cookies; } */ *ap; { + struct vnode *vp = ap->a_vp; struct uio *uio = ap->a_uio; + struct buf *bp; struct inode *ip; + struct direct *dp, *edp; + u_long *cookies; + struct dirent dstdp; + off_t offset, startoffset; + size_t readcnt, skipcnt; + ssize_t startresid; + int ncookies; int error; - size_t count, lost; - off_t off; - if (ap->a_ncookies != NULL) - /* - * Ensure that the block is aligned. The caller can use - * the cookies to determine where in the block to start. - */ - uio->uio_offset &= ~(DIRBLKSIZ - 1); - ip = VTOI(ap->a_vp); + if (uio->uio_offset < 0) + return (EINVAL); + ip = VTOI(vp); if (ip->i_effnlink == 0) return (0); - off = uio->uio_offset; - count = uio->uio_resid; - /* Make sure we don't return partial entries. */ - if (count <= ((uio->uio_offset + count) & (DIRBLKSIZ -1))) - return (EINVAL); - count -= (uio->uio_offset + count) & (DIRBLKSIZ -1); - lost = uio->uio_resid - count; - uio->uio_resid = count; - uio->uio_iov->iov_len = count; -# if (BYTE_ORDER == LITTLE_ENDIAN) - if (ap->a_vp->v_mount->mnt_maxsymlinklen > 0) { - error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); - } else { - struct dirent *dp, *edp; - struct uio auio; - struct iovec aiov; - caddr_t dirbuf; - int readcnt; - u_char tmp; - - auio = *uio; - auio.uio_iov = &aiov; - auio.uio_iovcnt = 1; - auio.uio_segflg = UIO_SYSSPACE; - aiov.iov_len = count; - dirbuf = malloc(count, M_TEMP, M_WAITOK); - aiov.iov_base = dirbuf; - error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred); - if (error == 0) { - readcnt = count - auio.uio_resid; - edp = (struct dirent *)&dirbuf[readcnt]; - for (dp = (struct dirent *)dirbuf; dp < edp; ) { - tmp = dp->d_namlen; - dp->d_namlen = dp->d_type; - dp->d_type = tmp; - if (dp->d_reclen > 0) { - dp = (struct dirent *) - ((char *)dp + dp->d_reclen); - } else { - error = EIO; - break; - } - } - if (dp >= edp) - error = uiomove(dirbuf, readcnt, uio); + if (ap->a_ncookies != NULL) { + ncookies = uio->uio_resid; + if (uio->uio_offset >= ip->i_size) + ncookies = 0; + else if (ip->i_size - uio->uio_offset < ncookies) + ncookies = ip->i_size - uio->uio_offset; + ncookies = ncookies / (offsetof(struct direct, d_name) + 4) + 1; + cookies = malloc(ncookies * sizeof(*cookies), M_TEMP, M_WAITOK); + *ap->a_ncookies = ncookies; + *ap->a_cookies = cookies; + } else { + ncookies = 0; + cookies = NULL; + } + offset = startoffset = uio->uio_offset; + startresid = uio->uio_resid; + error = 0; + while (error == 0 && uio->uio_resid > 0 && + uio->uio_offset < ip->i_size) { + error = ffs_blkatoff(vp, uio->uio_offset, NULL, &bp); + if (error) + break; + if (bp->b_offset + bp->b_bcount > ip->i_size) + readcnt = ip->i_size - bp->b_offset; + else + readcnt = bp->b_bcount; + skipcnt = (size_t)(uio->uio_offset - bp->b_offset) & + ~(size_t)(DIRBLKSIZ - 1); + offset = bp->b_offset + skipcnt; + dp = (struct direct *)&bp->b_data[skipcnt]; + edp = (struct direct *)&bp->b_data[readcnt]; + while (error == 0 && uio->uio_resid > 0 && dp < edp) { + if (dp->d_reclen <= offsetof(struct direct, d_name) || + (caddr_t)dp + dp->d_reclen > (caddr_t)edp) { + error = EIO; + break; + } +#if BYTE_ORDER == LITTLE_ENDIAN + /* Old filesystem format. */ + if (vp->v_mount->mnt_maxsymlinklen <= 0) { + dstdp.d_namlen = dp->d_type; + dstdp.d_type = dp->d_namlen; + } else +#endif + { + dstdp.d_namlen = dp->d_namlen; + dstdp.d_type = dp->d_type; + } + if (offsetof(struct direct, d_name) + dstdp.d_namlen > + dp->d_reclen) { + error = EIO; + break; + } + if (offset < startoffset || dp->d_ino == 0) + goto nextentry; + dstdp.d_fileno = dp->d_ino; + dstdp.d_reclen = GENERIC_DIRSIZ(&dstdp); + bcopy(dp->d_name, dstdp.d_name, dstdp.d_namlen); + dstdp.d_name[dstdp.d_namlen] = '\0'; + if (dstdp.d_reclen > uio->uio_resid) { + if (uio->uio_resid == startresid) + error = EINVAL; + else + error = EJUSTRETURN; + break; } - free(dirbuf, M_TEMP); + /* Advance dp. */ + error = uiomove((caddr_t)&dstdp, dstdp.d_reclen, uio); + if (error) + break; + if (cookies != NULL) { + KASSERT(ncookies > 0, + ("ufs_readdir: cookies buffer too small")); + *cookies = offset + dp->d_reclen; + cookies++; + ncookies--; + } +nextentry: + offset += dp->d_reclen; + dp = (struct direct *)((caddr_t)dp + dp->d_reclen); } -# else - error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); -# endif - if (!error && ap->a_ncookies != NULL) { - struct dirent* dpStart; - struct dirent* dpEnd; - struct dirent* dp; - int ncookies; - u_long *cookies; - u_long *cookiep; - - if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) - panic("ufs_readdir: unexpected uio from NFS server"); - dpStart = (struct dirent *) - ((char *)uio->uio_iov->iov_base - (uio->uio_offset - off)); - dpEnd = (struct dirent *) uio->uio_iov->iov_base; - for (dp = dpStart, ncookies = 0; - dp < dpEnd; - dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) - ncookies++; - cookies = malloc(ncookies * sizeof(u_long), M_TEMP, - M_WAITOK); - for (dp = dpStart, cookiep = cookies; - dp < dpEnd; - dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) { - off += dp->d_reclen; - *cookiep++ = (u_long) off; + bqrelse(bp); + uio->uio_offset = offset; + } + /* We need to correct uio_offset. */ + uio->uio_offset = offset; + if (error == EJUSTRETURN) + error = 0; + if (ap->a_ncookies != NULL) { + if (error == 0) { + ap->a_ncookies -= ncookies; + } else { + free(*ap->a_cookies, M_TEMP); + *ap->a_ncookies = 0; + *ap->a_cookies = NULL; } - *ap->a_ncookies = ncookies; - *ap->a_cookies = cookies; } - uio->uio_resid += lost; - if (ap->a_eofflag) - *ap->a_eofflag = VTOI(ap->a_vp)->i_size <= uio->uio_offset; + if (error == 0 && ap->a_eofflag) + *ap->a_eofflag = ip->i_size <= uio->uio_offset; return (error); } diff --git a/sys/vm/uma_core.c b/sys/vm/uma_core.c index 27abc3e..3a9492a 100644 --- a/sys/vm/uma_core.c +++ b/sys/vm/uma_core.c @@ -493,7 +493,7 @@ keg_timeout(uma_keg_t keg) KEG_UNLOCK(keg); hash_free(&oldhash); - KEG_LOCK(keg); + return; } } KEG_UNLOCK(keg); diff --git a/sys/vm/vm.h b/sys/vm/vm.h index 106c510..bfb4a60 100644 --- a/sys/vm/vm.h +++ b/sys/vm/vm.h @@ -134,10 +134,6 @@ struct kva_md_info { vm_offset_t buffer_eva; vm_offset_t clean_sva; vm_offset_t clean_eva; - vm_offset_t pager_sva; - vm_offset_t pager_eva; - vm_offset_t bio_transient_sva; - vm_offset_t bio_transient_eva; }; extern struct kva_md_info kmi; diff --git a/sys/vm/vm_init.c b/sys/vm/vm_init.c index 62e9891..2c4bcb6 100644 --- a/sys/vm/vm_init.c +++ b/sys/vm/vm_init.c @@ -76,6 +76,7 @@ __FBSDID("$FreeBSD$"); #include <sys/pipe.h> #include <sys/bio.h> #include <sys/buf.h> +#include <sys/vmem.h> #include <vm/vm.h> #include <vm/vm_param.h> @@ -120,6 +121,7 @@ vm_mem_init(dummy) /* * Initialize other VM packages */ + vmem_startup(); vm_object_init(); vm_map_startup(); kmem_init(virtual_avail, virtual_end); @@ -183,29 +185,31 @@ again: if ((vm_size_t)((char *)v - firstaddr) != size) panic("startup: table size inconsistency"); + size = (long)nbuf * BKVASIZE + (long)nswbuf * MAXPHYS + + (long)bio_transient_maxcnt * MAXPHYS; clean_map = kmem_suballoc(kernel_map, &kmi->clean_sva, &kmi->clean_eva, - (long)nbuf * BKVASIZE + (long)nswbuf * MAXPHYS + - (long)bio_transient_maxcnt * MAXPHYS, TRUE); - buffer_map = kmem_suballoc(clean_map, &kmi->buffer_sva, - &kmi->buffer_eva, (long)nbuf * BKVASIZE, FALSE); - buffer_map->system_map = 1; + size, TRUE); + + size = (long)nbuf * BKVASIZE; + kmi->buffer_sva = kmem_alloc_nofault(clean_map, size); + kmi->buffer_eva = kmi->buffer_sva + size; + vmem_init(buffer_arena, "buffer arena", kmi->buffer_sva, size, + PAGE_SIZE, 0, 0); + + size = (long)nswbuf * MAXPHYS; + swapbkva = kmem_alloc_nofault(clean_map, size); + if (!swapbkva) + panic("Not enough clean_map VM space for pager buffers"); + if (bio_transient_maxcnt != 0) { - bio_transient_map = kmem_suballoc(clean_map, - &kmi->bio_transient_sva, &kmi->bio_transient_eva, - (long)bio_transient_maxcnt * MAXPHYS, FALSE); - bio_transient_map->system_map = 1; + size = (long)bio_transient_maxcnt * MAXPHYS; + vmem_init(transient_arena, "transient arena", + kmem_alloc_nofault(clean_map, size), + size, PAGE_SIZE, 0, 0); } - pager_map = kmem_suballoc(clean_map, &kmi->pager_sva, &kmi->pager_eva, - (long)nswbuf * MAXPHYS, FALSE); - pager_map->system_map = 1; exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr, exec_map_entries * round_page(PATH_MAX + ARG_MAX), FALSE); pipe_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr, maxpipekva, FALSE); - - /* - * XXX: Mbuf system machine-specific initializations should - * go here, if anywhere. - */ } diff --git a/sys/vm/vm_kern.c b/sys/vm/vm_kern.c index 7c7ccc1..42cd699 100644 --- a/sys/vm/vm_kern.c +++ b/sys/vm/vm_kern.c @@ -89,8 +89,6 @@ vm_map_t kernel_map; vm_map_t kmem_map; vm_map_t exec_map; vm_map_t pipe_map; -vm_map_t buffer_map; -vm_map_t bio_transient_map; const void *zero_region; CTASSERT((ZERO_REGION_SIZE & PAGE_MASK) == 0); diff --git a/sys/vm/vm_kern.h b/sys/vm/vm_kern.h index 5730cef..1479e5f 100644 --- a/sys/vm/vm_kern.h +++ b/sys/vm/vm_kern.h @@ -64,11 +64,13 @@ #define _VM_VM_KERN_H_ 1 /* Kernel memory management definitions. */ -extern vm_map_t buffer_map; extern vm_map_t kernel_map; extern vm_map_t kmem_map; extern vm_map_t exec_map; extern vm_map_t pipe_map; +extern struct vmem *buffer_arena; +extern struct vmem *transient_arena; +extern vm_offset_t swapbkva; extern u_long vm_kmem_size; #endif /* _VM_VM_KERN_H_ */ diff --git a/sys/vm/vm_object.c b/sys/vm/vm_object.c index 97d8557..1c20ca6 100644 --- a/sys/vm/vm_object.c +++ b/sys/vm/vm_object.c @@ -2231,12 +2231,6 @@ vm_object_in_map(vm_object_t object) /* sx_sunlock(&allproc_lock); */ if (_vm_object_in_map(kernel_map, object, 0)) return 1; - if (_vm_object_in_map(kmem_map, object, 0)) - return 1; - if (_vm_object_in_map(pager_map, object, 0)) - return 1; - if (_vm_object_in_map(buffer_map, object, 0)) - return 1; return 0; } diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c index 65ca2e3..a47209f 100644 --- a/sys/vm/vm_page.c +++ b/sys/vm/vm_page.c @@ -645,6 +645,7 @@ vm_page_initfake(vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr) /* Fictitious pages don't use "order" or "pool". */ m->oflags = VPO_BUSY | VPO_UNMANAGED; m->wire_count = 1; + pmap_page_init(m); memattr: pmap_page_set_memattr(m, memattr); } diff --git a/sys/vm/vm_pager.c b/sys/vm/vm_pager.c index 989c318..c7d038b 100644 --- a/sys/vm/vm_pager.c +++ b/sys/vm/vm_pager.c @@ -78,6 +78,7 @@ __FBSDID("$FreeBSD$"); #include <vm/vm.h> #include <vm/vm_param.h> +#include <vm/vm_kern.h> #include <vm/vm_object.h> #include <vm/vm_page.h> #include <vm/vm_pager.h> @@ -174,11 +175,10 @@ static const int npagers = sizeof(pagertab) / sizeof(pagertab[0]); * cleaning requests (NPENDINGIO == 64) * the maximum swap cluster size * (MAXPHYS == 64k) if you want to get the most efficiency. */ -vm_map_t pager_map; -static int bswneeded; -static vm_offset_t swapbkva; /* swap buffers kva */ -struct mtx pbuf_mtx; +struct mtx_padalign pbuf_mtx; static TAILQ_HEAD(swqueue, buf) bswlist; +static int bswneeded; +vm_offset_t swapbkva; /* swap buffers kva */ void vm_pager_init() @@ -215,10 +215,6 @@ vm_pager_bufferinit() cluster_pbuf_freecnt = nswbuf / 2; vnode_pbuf_freecnt = nswbuf / 2 + 1; - - swapbkva = kmem_alloc_nofault(pager_map, nswbuf * MAXPHYS); - if (!swapbkva) - panic("Not enough pager_map VM space for physical buffers"); } /* diff --git a/sys/vm/vm_pager.h b/sys/vm/vm_pager.h index b5d923c..aa1b7f0 100644 --- a/sys/vm/vm_pager.h +++ b/sys/vm/vm_pager.h @@ -95,9 +95,8 @@ extern struct pagerops mgtdevicepagerops; #ifdef _KERNEL -extern vm_map_t pager_map; extern struct pagerops *pagertab[]; -extern struct mtx pbuf_mtx; +extern struct mtx_padalign pbuf_mtx; vm_object_t vm_pager_allocate(objtype_t, void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t, struct ucred *); diff --git a/sys/vm/vm_phys.c b/sys/vm/vm_phys.c index b871d79..66f3b0c 100644 --- a/sys/vm/vm_phys.c +++ b/sys/vm/vm_phys.c @@ -559,7 +559,6 @@ vm_phys_fictitious_reg_range(vm_paddr_t start, vm_paddr_t end, } for (i = 0; i < page_count; i++) { vm_page_initfake(&fp[i], start + PAGE_SIZE * i, memattr); - pmap_page_init(&fp[i]); fp[i].oflags &= ~(VPO_BUSY | VPO_UNMANAGED); } mtx_lock(&vm_phys_fictitious_reg_mtx); |
