diff options
Diffstat (limited to 'sys')
331 files changed, 55588 insertions, 8992 deletions
diff --git a/sys/amd64/conf/pfSense b/sys/amd64/conf/pfSense new file mode 100644 index 0000000..a200451 --- /dev/null +++ b/sys/amd64/conf/pfSense @@ -0,0 +1,195 @@ +include GENERIC + +nooptions KDB_TRACE +options DDB # Support DDB. + +ident pfSense + +nooptions MAC # TrustedBSD MAC Framework +nooptions COMPAT_FREEBSD4 # Compatible with FreeBSD4 +nooptions COMPAT_FREEBSD5 # Compatible with FreeBSD5 +nooptions COMPAT_FREEBSD6 # Compatible with FreeBSD6 +nooptions COMPAT_FREEBSD7 # Compatible with FreeBSD7 + +options GEOM_MIRROR +options GEOM_UZIP +options GEOM_PART_MBR +options GEOM_PART_BSD +options GEOM_ELI +options GEOM_BDE + +options TMPFS +options UNIONFS +options NULLFS +options PPS_SYNC + +# Bus support. Do not remove isa, even if you have no isa slots +device isa + +# Wireless +nooptions IEEE80211_DEBUG # enable debug msgs +device wlan_rssadapt +device wlan_xauth +device wlan_acl +device iwifw +device ipwfw # Firmware for Intel PRO/Wireless 2100 IEEE 802.11 driver +device wpifw # Firmware for Intel 3945ABG Wireless LAN IEEE 802.11 driver +device iwnfw # Firmware for Intel Wireless WiFi Link 4965AGN IEEE 802.11n driver +device uath # Atheros USB IEEE 802.11a/b/g wireless network device +device ralfw # Firmware for Ralink Technology RT2500 wireless NICs. +device ural # Ralink Technology RT2500USB IEEE 802.11 driver +device urtw # Realtek RTL8187B/L USB IEEE 802.11b/g wireless network device +device rum # Ralink Technology USB IEEE 802.11a/b/g wireless network device +device mwlfw # Firmware for Marvell 88W8363 IEEE 802.11n wireless network driver +device zyd # ZyDAS ZD1211/ZD1211B USB IEEE 802.11b/g wireless network device +device upgt # Conexant/Intersil PrismGT SoftMAC USB IEEE 802.11b/g wireless +device udav # Davicom DM9601 USB Ethernet driver +device axe +device axge +device aue +device cue +device kue +device mos +device rsu +device rsufw +device run # Ralink RT2700U/RT2800U/RT3000U USB 802.11agn +device runfw +device rue +device urtwn +device urtwnfw + +# Only for 8.1+ +device siba_bwn # Broadcom BCM43xx IEEE 802.11b/g wireless network driver +device bwn # Broadcom BCM43xx IEEE 802.11b/g wireless network driver +device bwi # Broadcom BCM43xx IEEE 802.11b/g wireless network driver + +# Pseudo devices. +device pty # Pseudo-ttys (telnet etc) + +# USB support +nooptions USB_DEBUG # enable debug msgs + +# 3G devices +device ufoma +device ucom +device uslcom +device uplcom +device umct +device uvisor +device uark +device uftdi +device uvscom +device umodem +device u3g +device cdce + +device uhid # "Human Interface Devices" + +# FireWire support +device firewire # FireWire bus code +device sbp # SCSI over FireWire (Requires scbus and da) + +# pfsense addons + +device tap +device gre +device if_bridge +device lagg +device vte +device netmap + +options IPFIREWALL_DEFAULT_TO_ACCEPT +options IPFIREWALL_VERBOSE + +options IPSTEALTH + +options NETGRAPH #netgraph(4) system +options NETGRAPH_VLAN +options NETGRAPH_L2TP +options NETGRAPH_BPF +options NETGRAPH_ETHER +options NETGRAPH_IFACE +options NETGRAPH_EIFACE +options NETGRAPH_PPP +options NETGRAPH_PPPOE +options NETGRAPH_PPTPGRE +options NETGRAPH_RFC1490 +options NETGRAPH_SOCKET +options NETGRAPH_TTY +options NETGRAPH_MPPC_ENCRYPTION +options NETGRAPH_UI +options NETGRAPH_VJC +options NETGRAPH_KSOCKET +options NETGRAPH_LMI +options NETGRAPH_ONE2MANY +options NETGRAPH_BRIDGE +options NETGRAPH_CISCO +options NETGRAPH_ECHO +options NETGRAPH_ASYNC +options NETGRAPH_FRAME_RELAY +options NETGRAPH_HOLE +options NETGRAPH_TEE +options NETGRAPH_TCPMSS +options NETGRAPH_PIPE +options NETGRAPH_CAR +options NETGRAPH_DEFLATE +options NETGRAPH_PRED1 + +options IPSEC +options IPSEC_NAT_T +options TCP_SIGNATURE + +# IPSEC filtering interface +device enc + +options ALTQ +options ALTQ_CBQ +options ALTQ_RED +options ALTQ_RIO +options ALTQ_HFSC +options ALTQ_PRIQ +options ALTQ_FAIRQ +options ALTQ_NOPCC +options ALTQ_CODEL + +# Squid related settings +options MSGMNB=8192 # max # of bytes in a queue +options MSGMNI=40 # number of message queue identifiers +options MSGSEG=512 # number of message segments per queue +options MSGSSZ=32 # size of a message segment +options MSGTQL=2048 # max messages in system + +device pf +device pflog +device carp +device pfsync + +device crypto # core crypto support +device cryptodev # /dev/crypto for access to h/w +device rndtest # FIPS 140-2 entropy tester +device hifn # Hifn 7951, 7781, etc. +options HIFN_DEBUG # enable debugging support: hw.hifn.debug +options HIFN_RNDTEST # enable rndtest support +device ubsec # Broadcom 5501, 5601, 58xx +device safe # safe -- SafeNet crypto accelerator +device padlock + +device speaker + +options DEVICE_POLLING + +options MROUTING + +# Additional cards +device mxge # mxge - Myricom Myri10GE 10 Gigabit Ethernet adapter driver +device cxgb # cxgb -- Chelsio T3 10 Gigabit Ethernet adapter driver +device cxgbe # cxgbe -- Chelsio T5 10 Gigabit Ethernet adapter driver +device ixgbe # http://www.nabble.com/kern-130476:-Error-in-compiling-kernel-with-device-ixgbe-td21424560.html +device nve # nVidia nForce MCP on-board Ethernet Networking +device oce + +# Default serial speed +options CONSPEED=115200 + +# Enable gpioapu +device gpioapu diff --git a/sys/boot/forth/Makefile.inc b/sys/boot/forth/Makefile.inc index 97ab433..7c82ac4 100644 --- a/sys/boot/forth/Makefile.inc +++ b/sys/boot/forth/Makefile.inc @@ -23,3 +23,7 @@ FILES+= shortcuts.4th FILES+= support.4th FILES+= version.4th FILESDIR_loader.conf= /boot/defaults + +# pfSense +FILES+= logo-pfSensebw.4th +FILES+= brand-pfSense.4th diff --git a/sys/boot/forth/brand-pfSense.4th b/sys/boot/forth/brand-pfSense.4th new file mode 100644 index 0000000..d56ecc2 --- /dev/null +++ b/sys/boot/forth/brand-pfSense.4th @@ -0,0 +1,46 @@ +\ Copyright (c) 2004-2015 Electric Sheep Fencing LLC +\ 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$ + +2 brandX ! 1 brandY ! \ Initialize brand placement defaults + +: brand+ ( x y c-addr/u -- x y' ) + 2swap 2dup at-xy 2swap \ position the cursor + type \ print to the screen + 1+ \ increase y for next time we're called +; + +: brand ( x y -- ) \ "pfSense" [wide] logo in B/W (7 rows x 42 columns) + + s" __ ____ " brand+ + s" _ __ / _/ ___| ___ _ __ ___ ___ " brand+ + s" | '_ \| |_\___ \ / _ \ '_ \/ __|/ _ \ " brand+ + s" | |_) | _|___) | __/ | | \__ \ __/ " brand+ + s" | .__/|_| |____/ \___|_| |_|___/\___| " brand+ + s" |_| " brand+ + s" " brand+ + + 2drop +; diff --git a/sys/boot/forth/loader.conf b/sys/boot/forth/loader.conf index a76f6ca..141b862 100644 --- a/sys/boot/forth/loader.conf +++ b/sys/boot/forth/loader.conf @@ -553,3 +553,10 @@ mac_seeotheruids_load="NO" # UID visbility MAC policy #module_before="cmd" # executes "cmd" before loading the module #module_after="cmd" # executes "cmd" after loading the module #module_error="cmd" # executes "cmd" if load fails + +# pfSense specific default values +loader_color="NO" +loader_logo="pfSensebw" +loader_brand="pfSense" +hw.usb.no_pf="1" +net.isr.maxthreads="-1" diff --git a/sys/boot/forth/logo-pfSensebw.4th b/sys/boot/forth/logo-pfSensebw.4th new file mode 100644 index 0000000..6da2413 --- /dev/null +++ b/sys/boot/forth/logo-pfSensebw.4th @@ -0,0 +1,54 @@ +\ Copyright (c) 2004-2015 Electric Sheep Fencing LLC +\ 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$ + +46 logoX ! 7 logoY ! \ Initialize logo placement defaults + +: logo+ ( x y c-addr/u -- x y' ) + 2swap 2dup at-xy 2swap \ position the cursor + type \ print to the screen + 1+ \ increase y for next time we're called +; + +: logo ( x y -- ) \ B/W pfSense logo (15 rows x 32 columns) + + s" " logo+ + s" " logo+ + s" " logo+ + s" ______ " logo+ + s" / \ " logo+ + s" _____/ f \ " logo+ + s" / \ / " logo+ + s" / p \______/ Sense" logo+ + s" \ / \ " logo+ + s" \_____/ \ " logo+ + s" \ / " logo+ + s" \______/ " logo+ + s" " logo+ + s" " logo+ + s" " logo+ + + 2drop +; diff --git a/sys/boot/forth/menu-commands.4th b/sys/boot/forth/menu-commands.4th index 9adf30a..5c6350a 100644 --- a/sys/boot/forth/menu-commands.4th +++ b/sys/boot/forth/menu-commands.4th @@ -253,7 +253,7 @@ also menu-namespace also menu-command-helpers cr ." To get back to the menu, type `menu' and press ENTER" cr - ." or type `boot' and press ENTER to start FreeBSD." cr + ." or type `boot' and press ENTER to start pfSense." cr cr FALSE \ exit the menu diff --git a/sys/boot/forth/menu.4th b/sys/boot/forth/menu.4th index 9127565..1f95b66 100644 --- a/sys/boot/forth/menu.4th +++ b/sys/boot/forth/menu.4th @@ -470,7 +470,7 @@ also menu-infrastructure definitions \ Print the frame caption at (x,y) s" loader_menu_title" getenv dup -1 = if - drop s" Welcome to FreeBSD" + drop s" Welcome to pfSense" then TRUE ( use default alignment ) s" loader_menu_title_align" getenv dup -1 <> if diff --git a/sys/boot/i386/boot0/boot0.S b/sys/boot/i386/boot0/boot0.S index 798ee97..ab17088 100644 --- a/sys/boot/i386/boot0/boot0.S +++ b/sys/boot/i386/boot0/boot0.S @@ -647,8 +647,8 @@ os_dos: #endif os_win: .ascii "Wi"; .byte 'n'|0x80 os_linux: .ascii "Linu"; .byte 'x'|0x80 -os_freebsd: .ascii "Free" -os_bsd: .ascii "BS"; .byte 'D'|0x80 +os_freebsd: .ascii "pfSe" +os_bsd: .ascii "ns"; .byte 'e'|0x80 #ifndef SAVE_MORE_MEMORY os_ext: .ascii "EX"; .byte 'T'|0x80 #endif diff --git a/sys/conf/NOTES b/sys/conf/NOTES index a977898..78fb6ee 100644 --- a/sys/conf/NOTES +++ b/sys/conf/NOTES @@ -700,6 +700,7 @@ options ALTQ_CBQ # Class Based Queueing options ALTQ_RED # Random Early Detection options ALTQ_RIO # RED In/Out options ALTQ_HFSC # Hierarchical Packet Scheduler +options ALTQ_FAIRQ # Fair Packet Scheduler options ALTQ_CDNR # Traffic conditioner options ALTQ_PRIQ # Priority Queueing options ALTQ_NOPCC # Required if the TSC is unusable diff --git a/sys/conf/files b/sys/conf/files index 9d8a183..5ff5e3c 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -252,7 +252,9 @@ compat/freebsd32/freebsd32_syscalls.c optional compat_freebsd32 compat/freebsd32/freebsd32_sysent.c optional compat_freebsd32 contrib/altq/altq/altq_cbq.c optional altq contrib/altq/altq/altq_cdnr.c optional altq +contrib/altq/altq/altq_codel.c optional altq contrib/altq/altq/altq_hfsc.c optional altq +contrib/altq/altq/altq_fairq.c optional altq contrib/altq/altq/altq_priq.c optional altq contrib/altq/altq/altq_red.c optional altq contrib/altq/altq/altq_rio.c optional altq @@ -535,6 +537,8 @@ crypto/sha1.c optional carp | crypto | ipsec | \ netgraph_mppc_encryption | sctp crypto/sha2/sha2.c optional crypto | geom_bde | ipsec | random | \ sctp | zfs +crypto/sha2/sha256c.c optional crypto | geom_bde | ipsec | random | \ + sctp | zfs crypto/siphash/siphash.c optional inet | inet6 crypto/siphash/siphash_test.c optional inet | inet6 ddb/db_access.c optional ddb @@ -1410,6 +1414,7 @@ dev/fxp/inphy.c optional fxp dev/gem/if_gem.c optional gem dev/gem/if_gem_pci.c optional gem pci dev/gem/if_gem_sbus.c optional gem sbus +/dev/gpioapu/gpioapu.c optional gpioapu pci dev/gpio/gpiobus.c optional gpio \ dependency "gpiobus_if.h" dev/gpio/gpioc.c optional gpio \ @@ -1589,6 +1594,48 @@ iwn1000.fw optional iwn1000fw | iwnfw \ compile-with "${NORMAL_FW}" \ no-obj no-implicit-rule \ clean "iwn1000.fw" +iwn100fw.c optional iwn100fw | iwnfw \ + compile-with "${AWK} -f $S/tools/fw_stub.awk iwn100.fw:iwn100fw -miwn100fw -c${.TARGET}" \ + no-implicit-rule before-depend local \ + clean "iwn100fw.c" +iwn100fw.fwo optional iwn100fw | iwnfw \ + dependency "iwn100.fw" \ + compile-with "${NORMAL_FWO}" \ + no-implicit-rule \ + clean "iwn100fw.fwo" +iwn100.fw optional iwn100fw | iwnfw \ + dependency "$S/contrib/dev/iwn/iwlwifi-100-39.31.5.1.fw.uu" \ + compile-with "${NORMAL_FW}" \ + no-obj no-implicit-rule \ + clean "iwn100.fw" +iwn105fw.c optional iwn105fw | iwnfw \ + compile-with "${AWK} -f $S/tools/fw_stub.awk iwn105.fw:iwn105fw -miwn105fw -c${.TARGET}" \ + no-implicit-rule before-depend local \ + clean "iwn105fw.c" +iwn105fw.fwo optional iwn105fw | iwnfw \ + dependency "iwn105.fw" \ + compile-with "${NORMAL_FWO}" \ + no-implicit-rule \ + clean "iwn105fw.fwo" +iwn105.fw optional iwn105fw | iwnfw \ + dependency "$S/contrib/dev/iwn/iwlwifi-105-6-18.168.6.1.fw.uu" \ + compile-with "${NORMAL_FW}" \ + no-obj no-implicit-rule \ + clean "iwn105.fw" +iwn135fw.c optional iwn135fw | iwnfw \ + compile-with "${AWK} -f $S/tools/fw_stub.awk iwn135.fw:iwn135fw -miwn135fw -c${.TARGET}" \ + no-implicit-rule before-depend local \ + clean "iwn135fw.c" +iwn135fw.fwo optional iwn135fw | iwnfw \ + dependency "iwn135.fw" \ + compile-with "${NORMAL_FWO}" \ + no-implicit-rule \ + clean "iwn135fw.fwo" +iwn135.fw optional iwn135fw | iwnfw \ + dependency "$S/contrib/dev/iwn/iwlwifi-135-6-18.168.6.1.fw.uu" \ + compile-with "${NORMAL_FW}" \ + no-obj no-implicit-rule \ + clean "iwn135.fw" iwn2000fw.c optional iwn2000fw | iwnfw \ compile-with "${AWK} -f $S/tools/fw_stub.awk iwn2000.fw:iwn2000fw -miwn2000fw -c${.TARGET}" \ no-implicit-rule before-depend local \ @@ -1683,7 +1730,7 @@ iwn6000g2afw.fwo optional iwn6000g2afw | iwnfw \ no-implicit-rule \ clean "iwn6000g2afw.fwo" iwn6000g2a.fw optional iwn6000g2afw | iwnfw \ - dependency "$S/contrib/dev/iwn/iwlwifi-6000g2a-17.168.5.2.fw.uu" \ + dependency "$S/contrib/dev/iwn/iwlwifi-6000g2b-18.168.6.1.fw.uu" \ compile-with "${NORMAL_FW}" \ no-obj no-implicit-rule \ clean "iwn6000g2a.fw" @@ -1697,7 +1744,7 @@ iwn6000g2bfw.fwo optional iwn6000g2bfw | iwnfw \ no-implicit-rule \ clean "iwn6000g2bfw.fwo" iwn6000g2b.fw optional iwn6000g2bfw | iwnfw \ - dependency "$S/contrib/dev/iwn/iwlwifi-6000g2b-17.168.5.2.fw.uu" \ + dependency "$S/contrib/dev/iwn/iwlwifi-6000g2b-18.168.6.1.fw.uu" \ compile-with "${NORMAL_FW}" \ no-obj no-implicit-rule \ clean "iwn6000g2b.fw" @@ -3224,6 +3271,7 @@ libkern/asprintf.c standard libkern/bcd.c standard libkern/bsearch.c standard libkern/crc32.c standard +libkern/explicit_bzero.c standard libkern/fnmatch.c standard libkern/iconv.c optional libiconv libkern/iconv_converter_if.m optional libiconv @@ -3267,6 +3315,7 @@ libkern/strtoq.c standard libkern/strtoul.c standard libkern/strtouq.c standard libkern/strvalid.c standard +libkern/timingsafe_bcmp.c standard net/bpf.c standard net/bpf_buffer.c optional bpf net/bpf_jitter.c optional bpf_jitter @@ -3365,6 +3414,7 @@ net80211/ieee80211_scan_sta.c optional wlan net80211/ieee80211_sta.c optional wlan \ compile-with "${NORMAL_C} -Wno-unused-function" net80211/ieee80211_superg.c optional wlan ieee80211_support_superg +net80211/ieee80211_scan_sw.c optional wlan net80211/ieee80211_tdma.c optional wlan ieee80211_support_tdma net80211/ieee80211_wds.c optional wlan net80211/ieee80211_xauth.c optional wlan wlan_xauth @@ -3566,7 +3616,6 @@ netipsec/keysock.c optional ipsec inet | ipsec inet6 netipsec/xform_ah.c optional ipsec inet | ipsec inet6 netipsec/xform_esp.c optional ipsec inet | ipsec inet6 netipsec/xform_ipcomp.c optional ipsec inet | ipsec inet6 -netipsec/xform_ipip.c optional ipsec inet | ipsec inet6 netipsec/xform_tcp.c optional ipsec inet tcp_signature | \ ipsec inet6 tcp_signature netipx/ipx.c optional ipx @@ -3995,6 +4044,8 @@ opencrypto/cryptodev.c optional cryptodev opencrypto/cryptodev_if.m optional crypto opencrypto/cryptosoft.c optional crypto opencrypto/cryptodeflate.c optional crypto +opencrypto/gmac.c optional crypto +opencrypto/gfmult.c optional crypto opencrypto/rmd160.c optional crypto | ipsec opencrypto/skipjack.c optional crypto opencrypto/xform.c optional crypto diff --git a/sys/conf/files.amd64 b/sys/conf/files.amd64 index b5fb621..445912a 100644 --- a/sys/conf/files.amd64 +++ b/sys/conf/files.amd64 @@ -151,9 +151,14 @@ amd64/pci/pci_cfgreg.c optional pci cddl/contrib/opensolaris/common/atomic/amd64/opensolaris_atomic.S optional zfs compile-with "${ZFS_S}" crypto/aesni/aeskeys_amd64.S optional aesni crypto/aesni/aesni.c optional aesni +aesni_ghash.o optional aesni \ + dependency "$S/crypto/aesni/aesni_ghash.c" \ + compile-with "${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} -mmmx -msse -msse4 -maes -mpclmul ${.IMPSRC}" \ + no-implicit-rule \ + clean "aesni_ghash.o" aesni_wrap.o optional aesni \ dependency "$S/crypto/aesni/aesni_wrap.c" \ - compile-with "${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} -mmmx -msse -maes ${.IMPSRC}" \ + compile-with "${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} -mmmx -msse -msse4 -maes ${.IMPSRC}" \ no-implicit-rule \ clean "aesni_wrap.o" crypto/blowfish/bf_enc.c optional crypto | ipsec diff --git a/sys/conf/files.i386 b/sys/conf/files.i386 index af25ccf..fb6e4b2 100644 --- a/sys/conf/files.i386 +++ b/sys/conf/files.i386 @@ -142,9 +142,14 @@ bf_enc.o optional crypto | ipsec \ no-implicit-rule crypto/aesni/aeskeys_i386.S optional aesni crypto/aesni/aesni.c optional aesni +aesni_ghash.o optional aesni \ + dependency "$S/crypto/aesni/aesni_ghash.c" \ + compile-with "${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} -mmmx -msse -msse4 -maes -mpclmul ${.IMPSRC}" \ + no-implicit-rule \ + clean "aesni_ghash.o" aesni_wrap.o optional aesni \ dependency "$S/crypto/aesni/aesni_wrap.c" \ - compile-with "${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} -mmmx -msse -maes ${.IMPSRC}" \ + compile-with "${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} -mmmx -msse -msse4 -maes ${.IMPSRC}" \ no-implicit-rule \ clean "aesni_wrap.o" crypto/des/arch/i386/des_enc.S optional crypto | ipsec | netsmb diff --git a/sys/conf/options b/sys/conf/options index 0699c2c..d8dffe9 100644 --- a/sys/conf/options +++ b/sys/conf/options @@ -384,8 +384,10 @@ ACCEPT_FILTER_HTTP ALTQ opt_global.h ALTQ_CBQ opt_altq.h ALTQ_CDNR opt_altq.h +ALTQ_CODEL opt_altq.h ALTQ_DEBUG opt_altq.h ALTQ_HFSC opt_altq.h +ALTQ_FAIRQ opt_altq.h ALTQ_NOPCC opt_altq.h ALTQ_PRIQ opt_altq.h ALTQ_RED opt_altq.h @@ -853,6 +855,7 @@ MWL_TX_NODROP opt_mwl.h # Options for the Intel 802.11n wireless driver IWN_DEBUG opt_iwn.h +WPI_DEBUG opt_wpi.h # dcons options DCONS_BUF_SIZE opt_dcons.h diff --git a/sys/contrib/altq/altq/altq.h b/sys/contrib/altq/altq/altq.h index c740ed3..4ef6cd2 100644 --- a/sys/contrib/altq/altq/altq.h +++ b/sys/contrib/altq/altq/altq.h @@ -63,7 +63,9 @@ #define ALTQT_BLUE 10 /* blue */ #define ALTQT_PRIQ 11 /* priority queue */ #define ALTQT_JOBS 12 /* JoBS */ -#define ALTQT_MAX 13 /* should be max discipline type + 1 */ +#define ALTQT_FAIRQ 13 /* fairq */ +#define ALTQT_CODEL 14 /* CoDel */ +#define ALTQT_MAX 15 /* should be max discipline type + 1 */ #ifdef ALTQ3_COMPAT struct altqreq { diff --git a/sys/contrib/altq/altq/altq_cbq.c b/sys/contrib/altq/altq/altq_cbq.c index 3991d1d..13f9721 100644 --- a/sys/contrib/altq/altq/altq_cbq.c +++ b/sys/contrib/altq/altq/altq_cbq.c @@ -241,6 +241,10 @@ get_class_stats(class_stats_t *statsp, struct rm_class *cl) if (q_is_rio(cl->q_)) rio_getstats((rio_t *)cl->red_, &statsp->red[0]); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->q_)) + codel_getstats(cl->codel_, &statsp->codel); +#endif } int diff --git a/sys/contrib/altq/altq/altq_cbq.h b/sys/contrib/altq/altq/altq_cbq.h index 30a15c7..38ee9e5 100644 --- a/sys/contrib/altq/altq/altq_cbq.h +++ b/sys/contrib/altq/altq/altq_cbq.h @@ -35,6 +35,7 @@ #include <altq/altq.h> #include <altq/altq_rmclass.h> +#include <altq/altq_codel.h> #include <altq/altq_red.h> #include <altq/altq_rio.h> @@ -51,6 +52,7 @@ extern "C" { #define CBQCLF_FLOWVALVE 0x0008 /* use flowvalve (aka penalty-box) */ #define CBQCLF_CLEARDSCP 0x0010 /* clear diffserv codepoint */ #define CBQCLF_BORROW 0x0020 /* borrow from parent */ +#define CBQCLF_CODEL 0x0040 /* use CoDel */ /* class flags only for root class */ #define CBQCLF_WRR 0x0100 /* weighted-round robin */ @@ -90,9 +92,10 @@ typedef struct _cbq_class_stats_ { int qcnt; /* # packets in queue */ int avgidle; - /* red and rio related info */ + /* codel, red and rio related info */ int qtype; struct redstats red[3]; + struct codel_stats codel; } class_stats_t; #ifdef ALTQ3_COMPAT @@ -186,7 +189,7 @@ struct cbq_getstats { #define CBQ_TIMEOUT 10 #define CBQ_LS_TIMEOUT (20 * hz / 1000) -#define CBQ_MAX_CLASSES 256 +#define CBQ_MAX_CLASSES 2048 #ifdef ALTQ3_COMPAT #define CBQ_MAX_FILTERS 256 diff --git a/sys/contrib/altq/altq/altq_classq.h b/sys/contrib/altq/altq/altq_classq.h index dc5c646..daec994 100644 --- a/sys/contrib/altq/altq/altq_classq.h +++ b/sys/contrib/altq/altq/altq_classq.h @@ -49,6 +49,7 @@ extern "C" { #define Q_RED 0x01 #define Q_RIO 0x02 #define Q_DROPTAIL 0x03 +#define Q_CODEL 0x04 #ifdef _KERNEL @@ -59,6 +60,7 @@ struct _class_queue_ { struct mbuf *tail_; /* Tail of packet queue */ int qlen_; /* Queue length (in number of packets) */ int qlim_; /* Queue limit (in number of packets*) */ + int qsize_; /* Queue size (in number of bytes*) */ int qtype_; /* Queue type */ }; @@ -67,10 +69,12 @@ typedef struct _class_queue_ class_queue_t; #define qtype(q) (q)->qtype_ /* Get queue type */ #define qlimit(q) (q)->qlim_ /* Max packets to be queued */ #define qlen(q) (q)->qlen_ /* Current queue length. */ +#define qsize(q) (q)->qsize_ /* Current queue size. */ #define qtail(q) (q)->tail_ /* Tail of the queue */ #define qhead(q) ((q)->tail_ ? (q)->tail_->m_nextpkt : NULL) #define qempty(q) ((q)->qlen_ == 0) /* Is the queue empty?? */ +#define q_is_codel(q) ((q)->qtype_ == Q_CODEL) /* Is the queue a codel queue */ #define q_is_red(q) ((q)->qtype_ == Q_RED) /* Is the queue a red queue */ #define q_is_rio(q) ((q)->qtype_ == Q_RIO) /* Is the queue a rio queue */ #define q_is_red_or_rio(q) ((q)->qtype_ == Q_RED || (q)->qtype_ == Q_RIO) @@ -100,6 +104,7 @@ _addq(class_queue_t *q, struct mbuf *m) m0->m_nextpkt = m; qtail(q) = m; qlen(q)++; + qsize(q) += m_pktlen(m); } static __inline struct mbuf * @@ -114,6 +119,7 @@ _getq(class_queue_t *q) else qtail(q) = NULL; qlen(q)--; + qsize(q) -= m_pktlen(m0); m0->m_nextpkt = NULL; return (m0); } diff --git a/sys/contrib/altq/altq/altq_codel.c b/sys/contrib/altq/altq/altq_codel.c new file mode 100644 index 0000000..45c5ca6 --- /dev/null +++ b/sys/contrib/altq/altq/altq_codel.c @@ -0,0 +1,477 @@ +/* + * CoDel - The Controlled-Delay Active Queue Management algorithm + * + * Copyright (C) 2013 Ermal Luçi <eri@FreeBSD.org> + * Copyright (C) 2011-2012 Kathleen Nichols <nichols@pollere.com> + * Copyright (C) 2011-2012 Van Jacobson <van@pollere.net> + * Copyright (C) 2012 Michael D. Taht <dave.taht@bufferbloat.net> + * Copyright (C) 2012 Eric Dumazet <edumazet@google.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, + * without modification. + * 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 names of the authors may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, provided that this notice is retained in full, this + * software may be distributed under the terms of the GNU General + * Public License ("GPL") version 2, in which case the provisions of the + * GPL apply INSTEAD OF those given above. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * $FreeBSD$ + */ +#include "opt_altq.h" +#include "opt_inet.h" +#include "opt_inet6.h" + +#ifdef ALTQ_CODEL /* CoDel is enabled by ALTQ_CODEL option in opt_altq.h */ + +#include <sys/param.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/socket.h> +#include <sys/systm.h> + +#include <net/if.h> +#include <net/if_var.h> +#include <netinet/in.h> + +#include <netpfil/pf/pf.h> +#include <netpfil/pf/pf_altq.h> +#include <altq/if_altq.h> +#include <altq/altq.h> +#include <altq/altq_codel.h> + +static int codel_should_drop(struct codel *, class_queue_t *, + struct mbuf *, u_int64_t); +static void codel_Newton_step(struct codel_vars *); +static u_int64_t codel_control_law(u_int64_t t, u_int64_t, u_int32_t); + +#define codel_time_after(a, b) ((int64_t)(a) - (int64_t)(b) > 0) +#define codel_time_after_eq(a, b) ((int64_t)(a) - (int64_t)(b) >= 0) +#define codel_time_before(a, b) ((int64_t)(a) - (int64_t)(b) < 0) +#define codel_time_before_eq(a, b) ((int64_t)(a) - (int64_t)(b) <= 0) + +static int codel_request(struct ifaltq *, int, void *); + +static int codel_enqueue(struct ifaltq *, struct mbuf *, struct altq_pktattr *); +static struct mbuf *codel_dequeue(struct ifaltq *, int); + +int +codel_pfattach(struct pf_altq *a) +{ + struct ifnet *ifp; + + if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL) + return (EINVAL); + + return (altq_attach(&ifp->if_snd, ALTQT_CODEL, a->altq_disc, + codel_enqueue, codel_dequeue, codel_request, NULL, NULL)); +} + +int +codel_add_altq(struct pf_altq *a) +{ + struct codel_if *cif; + struct ifnet *ifp; + struct codel_opts *opts; + + if ((ifp = ifunit(a->ifname)) == NULL) + return (EINVAL); + if (!ALTQ_IS_READY(&ifp->if_snd)) + return (ENODEV); + + opts = &a->pq_u.codel_opts; + + cif = malloc(sizeof(struct codel_if), M_DEVBUF, M_NOWAIT | M_ZERO); + if (cif == NULL) + return (ENOMEM); + cif->cif_bandwidth = a->ifbandwidth; + cif->cif_ifq = &ifp->if_snd; + + cif->cl_q = malloc(sizeof(class_queue_t), M_DEVBUF, M_NOWAIT | M_ZERO); + if (cif->cl_q == NULL) { + free(cif, M_DEVBUF); + return (ENOMEM); + } + + if (a->qlimit == 0) + a->qlimit = 50; /* use default. */ + qlimit(cif->cl_q) = a->qlimit; + qtype(cif->cl_q) = Q_CODEL; + qlen(cif->cl_q) = 0; + qsize(cif->cl_q) = 0; + + if (opts->target == 0) + opts->target = 5; + if (opts->interval == 0) + opts->interval = 100; + cif->codel.params.target = machclk_freq * opts->target / 1000; + cif->codel.params.interval = machclk_freq * opts->interval / 1000; + cif->codel.params.ecn = opts->ecn; + cif->codel.stats.maxpacket = 256; + + cif->cl_stats.qlength = qlen(cif->cl_q); + cif->cl_stats.qlimit = qlimit(cif->cl_q); + + /* keep the state in pf_altq */ + a->altq_disc = cif; + + return (0); +} + +int +codel_remove_altq(struct pf_altq *a) +{ + struct codel_if *cif; + + if ((cif = a->altq_disc) == NULL) + return (EINVAL); + a->altq_disc = NULL; + + if (cif->cl_q) + free(cif->cl_q, M_DEVBUF); + free(cif, M_DEVBUF); + + return (0); +} + +int +codel_getqstats(struct pf_altq *a, void *ubuf, int *nbytes) +{ + struct codel_if *cif; + struct codel_ifstats stats; + int error = 0; + + if ((cif = altq_lookup(a->ifname, ALTQT_CODEL)) == NULL) + return (EBADF); + + if (*nbytes < sizeof(stats)) + return (EINVAL); + + stats = cif->cl_stats; + stats.stats = cif->codel.stats; + + if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0) + return (error); + *nbytes = sizeof(stats); + + return (0); +} + +static int +codel_request(struct ifaltq *ifq, int req, void *arg) +{ + struct codel_if *cif = (struct codel_if *)ifq->altq_disc; + struct mbuf *m; + + IFQ_LOCK_ASSERT(ifq); + + switch (req) { + case ALTRQ_PURGE: + if (!ALTQ_IS_ENABLED(cif->cif_ifq)) + break; + + if (qempty(cif->cl_q)) + break; + + while ((m = _getq(cif->cl_q)) != NULL) { + PKTCNTR_ADD(&cif->cl_stats.cl_dropcnt, m_pktlen(m)); + m_freem(m); + IFQ_DEC_LEN(cif->cif_ifq); + } + cif->cif_ifq->ifq_len = 0; + break; + } + + return (0); +} + +static int +codel_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr) +{ + + struct codel_if *cif = (struct codel_if *) ifq->altq_disc; + + IFQ_LOCK_ASSERT(ifq); + + /* grab class set by classifier */ + if ((m->m_flags & M_PKTHDR) == 0) { + /* should not happen */ + printf("altq: packet for %s does not have pkthdr\n", + ifq->altq_ifp->if_xname); + m_freem(m); + PKTCNTR_ADD(&cif->cl_stats.cl_dropcnt, m_pktlen(m)); + return (ENOBUFS); + } + + if (codel_addq(&cif->codel, cif->cl_q, m)) { + PKTCNTR_ADD(&cif->cl_stats.cl_dropcnt, m_pktlen(m)); + return (ENOBUFS); + } + IFQ_INC_LEN(ifq); + + return (0); +} + +static struct mbuf * +codel_dequeue(struct ifaltq *ifq, int op) +{ + struct codel_if *cif = (struct codel_if *)ifq->altq_disc; + struct mbuf *m; + + IFQ_LOCK_ASSERT(ifq); + + if (IFQ_IS_EMPTY(ifq)) + return (NULL); + + if (op == ALTDQ_POLL) + return (qhead(cif->cl_q)); + + + m = codel_getq(&cif->codel, cif->cl_q); + if (m != NULL) { + IFQ_DEC_LEN(ifq); + PKTCNTR_ADD(&cif->cl_stats.cl_xmitcnt, m_pktlen(m)); + return (m); + } + + return (NULL); +} + +struct codel * +codel_alloc(int target, int interval, int ecn) +{ + struct codel *c; + + c = malloc(sizeof(*c), M_DEVBUF, M_NOWAIT | M_ZERO); + if (c != NULL) { + c->params.target = machclk_freq * target / 1000; + c->params.interval = machclk_freq * interval / 1000; + c->params.ecn = ecn; + c->stats.maxpacket = 256; + } + + return (c); +} + +void +codel_destroy(struct codel *c) +{ + + free(c, M_DEVBUF); +} + +#define MTAG_CODEL 1438031249 +int +codel_addq(struct codel *c, class_queue_t *q, struct mbuf *m) +{ + struct m_tag *mtag; + uint64_t *enqueue_time; + + if (qlen(q) < qlimit(q)) { + mtag = m_tag_locate(m, MTAG_CODEL, 0, NULL); + if (mtag == NULL) + mtag = m_tag_alloc(MTAG_CODEL, 0, sizeof(uint64_t), + M_NOWAIT); + if (mtag == NULL) { + m_freem(m); + return (-1); + } + enqueue_time = (uint64_t *)(mtag + 1); + *enqueue_time = read_machclk(); + m_tag_prepend(m, mtag); + _addq(q, m); + return (0); + } + c->drop_overlimit++; + m_freem(m); + + return (-1); +} + +static int +codel_should_drop(struct codel *c, class_queue_t *q, struct mbuf *m, + u_int64_t now) +{ + struct m_tag *mtag; + uint64_t *enqueue_time; + + if (m == NULL) { + c->vars.first_above_time = 0; + return (0); + } + + mtag = m_tag_locate(m, MTAG_CODEL, 0, NULL); + if (mtag == NULL) { + /* Only one warning per second. */ + if (ppsratecheck(&c->last_log, &c->last_pps, 1)) + printf("%s: could not found the packet mtag!\n", + __func__); + c->vars.first_above_time = 0; + return (0); + } + enqueue_time = (uint64_t *)(mtag + 1); + c->vars.ldelay = now - *enqueue_time; + c->stats.maxpacket = MAX(c->stats.maxpacket, m_pktlen(m)); + + if (codel_time_before(c->vars.ldelay, c->params.target) || + qsize(q) <= c->stats.maxpacket) { + /* went below - stay below for at least interval */ + c->vars.first_above_time = 0; + return (0); + } + if (c->vars.first_above_time == 0) { + /* just went above from below. If we stay above + * for at least interval we'll say it's ok to drop + */ + c->vars.first_above_time = now + c->params.interval; + return (0); + } + if (codel_time_after(now, c->vars.first_above_time)) + return (1); + + return (0); +} + +/* + * Run a Newton method step: + * new_invsqrt = (invsqrt / 2) * (3 - count * invsqrt^2) + * + * Here, invsqrt is a fixed point number (< 1.0), 32bit mantissa, aka Q0.32 + */ +static void +codel_Newton_step(struct codel_vars *vars) +{ + uint32_t invsqrt, invsqrt2; + uint64_t val; + +/* sizeof_in_bits(rec_inv_sqrt) */ +#define REC_INV_SQRT_BITS (8 * sizeof(u_int16_t)) +/* needed shift to get a Q0.32 number from rec_inv_sqrt */ +#define REC_INV_SQRT_SHIFT (32 - REC_INV_SQRT_BITS) + + invsqrt = ((u_int32_t)vars->rec_inv_sqrt) << REC_INV_SQRT_SHIFT; + invsqrt2 = ((u_int64_t)invsqrt * invsqrt) >> 32; + val = (3LL << 32) - ((u_int64_t)vars->count * invsqrt2); + val >>= 2; /* avoid overflow in following multiply */ + val = (val * invsqrt) >> (32 - 2 + 1); + + vars->rec_inv_sqrt = val >> REC_INV_SQRT_SHIFT; +} + +static u_int64_t +codel_control_law(u_int64_t t, u_int64_t interval, u_int32_t rec_inv_sqrt) +{ + + return (t + (u_int32_t)(((u_int64_t)interval * + (rec_inv_sqrt << REC_INV_SQRT_SHIFT)) >> 32)); +} + +struct mbuf * +codel_getq(struct codel *c, class_queue_t *q) +{ + struct mbuf *m; + u_int64_t now; + int drop; + + if ((m = _getq(q)) == NULL) { + c->vars.dropping = 0; + return (m); + } + + now = read_machclk(); + drop = codel_should_drop(c, q, m, now); + if (c->vars.dropping) { + if (!drop) { + /* sojourn time below target - leave dropping state */ + c->vars.dropping = 0; + } else if (codel_time_after_eq(now, c->vars.drop_next)) { + /* It's time for the next drop. Drop the current + * packet and dequeue the next. The dequeue might + * take us out of dropping state. + * If not, schedule the next drop. + * A large backlog might result in drop rates so high + * that the next drop should happen now, + * hence the while loop. + */ + while (c->vars.dropping && + codel_time_after_eq(now, c->vars.drop_next)) { + c->vars.count++; /* don't care of possible wrap + * since there is no more + * divide */ + codel_Newton_step(&c->vars); + /* TODO ECN */ + PKTCNTR_ADD(&c->stats.drop_cnt, m_pktlen(m)); + m_freem(m); + m = _getq(q); + if (!codel_should_drop(c, q, m, now)) + /* leave dropping state */ + c->vars.dropping = 0; + else + /* and schedule the next drop */ + c->vars.drop_next = + codel_control_law(c->vars.drop_next, + c->params.interval, + c->vars.rec_inv_sqrt); + } + } + } else if (drop) { + /* TODO ECN */ + PKTCNTR_ADD(&c->stats.drop_cnt, m_pktlen(m)); + m_freem(m); + + m = _getq(q); + drop = codel_should_drop(c, q, m, now); + + c->vars.dropping = 1; + /* if min went above target close to when we last went below it + * assume that the drop rate that controlled the queue on the + * last cycle is a good starting point to control it now. + */ + if (codel_time_before(now - c->vars.drop_next, + 16 * c->params.interval)) { + c->vars.count = (c->vars.count - c->vars.lastcount) | 1; + /* we dont care if rec_inv_sqrt approximation + * is not very precise : + * Next Newton steps will correct it quadratically. + */ + codel_Newton_step(&c->vars); + } else { + c->vars.count = 1; + c->vars.rec_inv_sqrt = ~0U >> REC_INV_SQRT_SHIFT; + } + c->vars.lastcount = c->vars.count; + c->vars.drop_next = codel_control_law(now, c->params.interval, + c->vars.rec_inv_sqrt); + } + + return (m); +} + +void +codel_getstats(struct codel *c, struct codel_stats *s) +{ + *s = c->stats; +} + +#endif /* ALTQ_CODEL */ diff --git a/sys/contrib/altq/altq/altq_codel.h b/sys/contrib/altq/altq/altq_codel.h new file mode 100644 index 0000000..991af42 --- /dev/null +++ b/sys/contrib/altq/altq/altq_codel.h @@ -0,0 +1,129 @@ +/* + * CoDel - The Controlled-Delay Active Queue Management algorithm + * + * Copyright (C) 2013 Ermal Luçi <eri@FreeBSD.org> + * Copyright (C) 2011-2012 Kathleen Nichols <nichols@pollere.com> + * Copyright (C) 2011-2012 Van Jacobson <van@pollere.net> + * Copyright (C) 2012 Michael D. Taht <dave.taht@bufferbloat.net> + * Copyright (C) 2012 Eric Dumazet <edumazet@google.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, + * without modification. + * 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 names of the authors may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, provided that this notice is retained in full, this + * software may be distributed under the terms of the GNU General + * Public License ("GPL") version 2, in which case the provisions of the + * GPL apply INSTEAD OF those given above. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _ALTQ_ALTQ_CODEL_H_ +#define _ALTQ_ALTQ_CODEL_H_ + +struct codel_stats { + u_int32_t maxpacket; + struct pktcntr drop_cnt; + u_int marked_packets; +}; + +struct codel_ifstats { + u_int qlength; + u_int qlimit; + struct codel_stats stats; + struct pktcntr cl_xmitcnt; /* transmitted packet counter */ + struct pktcntr cl_dropcnt; /* dropped packet counter */ +}; + +#ifdef _KERNEL +#include <altq/altq_classq.h> + +/** + * struct codel_params - contains codel parameters + * <at> target: target queue size (in time units) + * <at> interval: width of moving time window + * <at> ecn: is Explicit Congestion Notification enabled + */ +struct codel_params { + u_int64_t target; + u_int64_t interval; + int ecn; +}; + +/** + * struct codel_vars - contains codel variables + * <at> count: how many drops we've done since the last time we + * entered dropping state + * <at> lastcount: count at entry to dropping state + * <at> dropping: set to true if in dropping state + * <at> rec_inv_sqrt: reciprocal value of sqrt(count) >> 1 + * <at> first_above_time: when we went (or will go) continuously above + * target for interval + * <at> drop_next: time to drop next packet, or when we dropped last + * <at> ldelay: sojourn time of last dequeued packet + */ +struct codel_vars { + u_int32_t count; + u_int32_t lastcount; + int dropping; + u_int16_t rec_inv_sqrt; + u_int64_t first_above_time; + u_int64_t drop_next; + u_int64_t ldelay; +}; + +struct codel { + int last_pps; + struct codel_params params; + struct codel_vars vars; + struct codel_stats stats; + struct timeval last_log; + u_int32_t drop_overlimit; +}; + +/* + * codel interface state + */ +struct codel_if { + struct codel_if *cif_next; /* interface state list */ + struct ifaltq *cif_ifq; /* backpointer to ifaltq */ + u_int cif_bandwidth; /* link bandwidth in bps */ + + class_queue_t *cl_q; /* class queue structure */ + struct codel codel; + + /* statistics */ + struct codel_ifstats cl_stats; +}; + +struct codel *codel_alloc(int, int, int); +void codel_destroy(struct codel *); +int codel_addq(struct codel *, class_queue_t *, struct mbuf *); +struct mbuf *codel_getq(struct codel *, class_queue_t *); +void codel_getstats(struct codel *, struct codel_stats *); + +#endif /* _KERNEL */ + +#endif /* _ALTQ_ALTQ_CODEL_H_ */ diff --git a/sys/contrib/altq/altq/altq_fairq.c b/sys/contrib/altq/altq/altq_fairq.c new file mode 100644 index 0000000..2189996 --- /dev/null +++ b/sys/contrib/altq/altq/altq_fairq.c @@ -0,0 +1,909 @@ +/* + * Copyright (c) 2008 The DragonFly Project. All rights reserved. + * + * This code is derived from software contributed to The DragonFly Project + * by Matthew Dillon <dillon@backplane.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. Neither the name of The DragonFly Project nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific, prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDERS 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. + * + * $DragonFly: src/sys/net/altq/altq_fairq.c,v 1.1 2008/04/06 18:58:15 dillon Exp $ + * $FreeBSD$ + */ +/* + * Matt: I gutted altq_priq.c and used it as a skeleton on which to build + * fairq. The fairq algorithm is completely different then priq, of course, + * but because I used priq's skeleton I believe I should include priq's + * copyright. + * + * Copyright (C) 2000-2003 + * Sony Computer Science Laboratories 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 SONY CSL 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 SONY CSL 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. + */ + +/* + * FAIRQ - take traffic classified by keep state (hashed into + * mbuf->m_pkthdr.altq_state_hash) and bucketize it. Fairly extract + * the first packet from each bucket in a round-robin fashion. + * + * TODO - better overall qlimit support (right now it is per-bucket). + * - NOTE: red etc is per bucket, not overall. + * - better service curve support. + * + * EXAMPLE: + * + * altq on em0 fairq bandwidth 650Kb queue { std, bulk } + * queue std priority 3 bandwidth 400Kb \ + * fairq (buckets 64, default, hogs 1Kb) qlimit 50 + * queue bulk priority 2 bandwidth 100Kb \ + * fairq (buckets 64, hogs 1Kb) qlimit 50 + * + * pass out on em0 from any to any keep state queue std + * pass out on em0 inet proto tcp ..... port ... keep state queue bulk + */ +#include "opt_altq.h" +#include "opt_inet.h" +#include "opt_inet6.h" + +#ifdef ALTQ_FAIRQ /* fairq is enabled in the kernel conf */ + +#include <sys/param.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/errno.h> +#include <sys/kernel.h> +#include <sys/queue.h> + +#include <net/if.h> +#include <net/if_var.h> +#include <netinet/in.h> + +#include <netpfil/pf/pf.h> +#include <netpfil/pf/pf_altq.h> +#include <netpfil/pf/pf_mtag.h> +#include <altq/altq.h> +#include <altq/altq_fairq.h> + +/* + * function prototypes + */ +static int fairq_clear_interface(struct fairq_if *); +static int fairq_request(struct ifaltq *, int, void *); +static void fairq_purge(struct fairq_if *); +static struct fairq_class *fairq_class_create(struct fairq_if *, int, int, u_int, struct fairq_opts *, int); +static int fairq_class_destroy(struct fairq_class *); +static int fairq_enqueue(struct ifaltq *, struct mbuf *, struct altq_pktattr *); +static struct mbuf *fairq_dequeue(struct ifaltq *, int); + +static int fairq_addq(struct fairq_class *, struct mbuf *, u_int32_t); +static struct mbuf *fairq_getq(struct fairq_class *, uint64_t); +static struct mbuf *fairq_pollq(struct fairq_class *, uint64_t, int *); +static fairq_bucket_t *fairq_selectq(struct fairq_class *, int); +static void fairq_purgeq(struct fairq_class *); + +static void get_class_stats(struct fairq_classstats *, struct fairq_class *); +static struct fairq_class *clh_to_clp(struct fairq_if *, uint32_t); + +int +fairq_pfattach(struct pf_altq *a) +{ + struct ifnet *ifp; + int error; + + if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL) + return (EINVAL); + + error = altq_attach(&ifp->if_snd, ALTQT_FAIRQ, a->altq_disc, + fairq_enqueue, fairq_dequeue, fairq_request, NULL, NULL); + + return (error); +} + +int +fairq_add_altq(struct pf_altq *a) +{ + struct fairq_if *pif; + struct ifnet *ifp; + + if ((ifp = ifunit(a->ifname)) == NULL) + return (EINVAL); + if (!ALTQ_IS_READY(&ifp->if_snd)) + return (ENODEV); + + + pif = malloc(sizeof(struct fairq_if), + M_DEVBUF, M_WAITOK | M_ZERO); + pif->pif_bandwidth = a->ifbandwidth; + pif->pif_maxpri = -1; + pif->pif_ifq = &ifp->if_snd; + + /* keep the state in pf_altq */ + a->altq_disc = pif; + + return (0); +} + +int +fairq_remove_altq(struct pf_altq *a) +{ + struct fairq_if *pif; + + if ((pif = a->altq_disc) == NULL) + return (EINVAL); + a->altq_disc = NULL; + + fairq_clear_interface(pif); + + free(pif, M_DEVBUF); + return (0); +} + +int +fairq_add_queue(struct pf_altq *a) +{ + struct fairq_if *pif; + struct fairq_class *cl; + + if ((pif = a->altq_disc) == NULL) + return (EINVAL); + + /* check parameters */ + if (a->priority >= FAIRQ_MAXPRI) + return (EINVAL); + if (a->qid == 0) + return (EINVAL); + if (pif->pif_classes[a->priority] != NULL) + return (EBUSY); + if (clh_to_clp(pif, a->qid) != NULL) + return (EBUSY); + + cl = fairq_class_create(pif, a->priority, a->qlimit, a->bandwidth, + &a->pq_u.fairq_opts, a->qid); + if (cl == NULL) + return (ENOMEM); + + return (0); +} + +int +fairq_remove_queue(struct pf_altq *a) +{ + struct fairq_if *pif; + struct fairq_class *cl; + + if ((pif = a->altq_disc) == NULL) + return (EINVAL); + + if ((cl = clh_to_clp(pif, a->qid)) == NULL) + return (EINVAL); + + return (fairq_class_destroy(cl)); +} + +int +fairq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes) +{ + struct fairq_if *pif; + struct fairq_class *cl; + struct fairq_classstats stats; + int error = 0; + + if ((pif = altq_lookup(a->ifname, ALTQT_FAIRQ)) == NULL) + return (EBADF); + + if ((cl = clh_to_clp(pif, a->qid)) == NULL) + return (EINVAL); + + if (*nbytes < sizeof(stats)) + return (EINVAL); + + get_class_stats(&stats, cl); + + if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0) + return (error); + *nbytes = sizeof(stats); + return (0); +} + +/* + * bring the interface back to the initial state by discarding + * all the filters and classes. + */ +static int +fairq_clear_interface(struct fairq_if *pif) +{ + struct fairq_class *cl; + int pri; + + /* clear out the classes */ + for (pri = 0; pri <= pif->pif_maxpri; pri++) { + if ((cl = pif->pif_classes[pri]) != NULL) + fairq_class_destroy(cl); + } + + return (0); +} + +static int +fairq_request(struct ifaltq *ifq, int req, void *arg) +{ + struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc; + + IFQ_LOCK_ASSERT(ifq); + + switch (req) { + case ALTRQ_PURGE: + fairq_purge(pif); + break; + } + return (0); +} + +/* discard all the queued packets on the interface */ +static void +fairq_purge(struct fairq_if *pif) +{ + struct fairq_class *cl; + int pri; + + for (pri = 0; pri <= pif->pif_maxpri; pri++) { + if ((cl = pif->pif_classes[pri]) != NULL && cl->cl_head) + fairq_purgeq(cl); + } + if (ALTQ_IS_ENABLED(pif->pif_ifq)) + pif->pif_ifq->ifq_len = 0; +} + +static struct fairq_class * +fairq_class_create(struct fairq_if *pif, int pri, int qlimit, + u_int bandwidth, struct fairq_opts *opts, int qid) +{ + struct fairq_class *cl; + int flags = opts->flags; + u_int nbuckets = opts->nbuckets; + int i; + +#ifndef ALTQ_RED + if (flags & FARF_RED) { +#ifdef ALTQ_DEBUG + printf("fairq_class_create: RED not configured for FAIRQ!\n"); +#endif + return (NULL); + } +#endif +#ifndef ALTQ_CODEL + if (flags & FARF_CODEL) { +#ifdef ALTQ_DEBUG + printf("fairq_class_create: CODEL not configured for FAIRQ!\n"); +#endif + return (NULL); + } +#endif + if (nbuckets == 0) + nbuckets = 256; + if (nbuckets > FAIRQ_MAX_BUCKETS) + nbuckets = FAIRQ_MAX_BUCKETS; + /* enforce power-of-2 size */ + while ((nbuckets ^ (nbuckets - 1)) != ((nbuckets << 1) - 1)) + ++nbuckets; + + if ((cl = pif->pif_classes[pri]) != NULL) { + /* modify the class instead of creating a new one */ + IFQ_LOCK(cl->cl_pif->pif_ifq); + if (cl->cl_head) + fairq_purgeq(cl); + IFQ_UNLOCK(cl->cl_pif->pif_ifq); +#ifdef ALTQ_RIO + if (cl->cl_qtype == Q_RIO) + rio_destroy((rio_t *)cl->cl_red); +#endif +#ifdef ALTQ_RED + if (cl->cl_qtype == Q_RED) + red_destroy(cl->cl_red); +#endif +#ifdef ALTQ_CODEL + if (cl->cl_qtype == Q_CODEL) + codel_destroy(cl->cl_codel); +#endif + } else { + cl = malloc(sizeof(struct fairq_class), + M_DEVBUF, M_WAITOK | M_ZERO); + cl->cl_nbuckets = nbuckets; + cl->cl_nbucket_mask = nbuckets - 1; + + cl->cl_buckets = malloc( + sizeof(struct fairq_bucket) * cl->cl_nbuckets, + M_DEVBUF, M_WAITOK | M_ZERO); + cl->cl_head = NULL; + } + + pif->pif_classes[pri] = cl; + if (flags & FARF_DEFAULTCLASS) + pif->pif_default = cl; + if (qlimit == 0) + qlimit = 50; /* use default */ + cl->cl_qlimit = qlimit; + for (i = 0; i < cl->cl_nbuckets; ++i) { + qlimit(&cl->cl_buckets[i].queue) = qlimit; + } + cl->cl_bandwidth = bandwidth / 8; + cl->cl_qtype = Q_DROPTAIL; + cl->cl_flags = flags & FARF_USERFLAGS; + cl->cl_pri = pri; + if (pri > pif->pif_maxpri) + pif->pif_maxpri = pri; + cl->cl_pif = pif; + cl->cl_handle = qid; + cl->cl_hogs_m1 = opts->hogs_m1 / 8; + cl->cl_lssc_m1 = opts->lssc_m1 / 8; /* NOT YET USED */ + +#ifdef ALTQ_RED + if (flags & (FARF_RED|FARF_RIO)) { + int red_flags, red_pkttime; + + red_flags = 0; + if (flags & FARF_ECN) + red_flags |= REDF_ECN; +#ifdef ALTQ_RIO + if (flags & FARF_CLEARDSCP) + red_flags |= RIOF_CLEARDSCP; +#endif + if (pif->pif_bandwidth < 8) + red_pkttime = 1000 * 1000 * 1000; /* 1 sec */ + else + red_pkttime = (int64_t)pif->pif_ifq->altq_ifp->if_mtu + * 1000 * 1000 * 1000 / (pif->pif_bandwidth / 8); +#ifdef ALTQ_RIO + if (flags & FARF_RIO) { + cl->cl_red = (red_t *)rio_alloc(0, NULL, + red_flags, red_pkttime); + if (cl->cl_red != NULL) + cl->cl_qtype = Q_RIO; + } else +#endif + if (flags & FARF_RED) { + cl->cl_red = red_alloc(0, 0, + cl->cl_qlimit * 10/100, + cl->cl_qlimit * 30/100, + red_flags, red_pkttime); + if (cl->cl_red != NULL) + cl->cl_qtype = Q_RED; + } + } +#endif /* ALTQ_RED */ +#ifdef ALTQ_CODEL + if (flags & FARF_CODEL) { + cl->cl_codel = codel_alloc(5, 100, 0); + if (cl->cl_codel != NULL) + cl->cl_qtype = Q_CODEL; + } +#endif + + return (cl); +} + +static int +fairq_class_destroy(struct fairq_class *cl) +{ + struct fairq_if *pif; + int pri; + + IFQ_LOCK(cl->cl_pif->pif_ifq); + + if (cl->cl_head) + fairq_purgeq(cl); + + pif = cl->cl_pif; + pif->pif_classes[cl->cl_pri] = NULL; + if (pif->pif_poll_cache == cl) + pif->pif_poll_cache = NULL; + if (pif->pif_maxpri == cl->cl_pri) { + for (pri = cl->cl_pri; pri >= 0; pri--) + if (pif->pif_classes[pri] != NULL) { + pif->pif_maxpri = pri; + break; + } + if (pri < 0) + pif->pif_maxpri = -1; + } + IFQ_UNLOCK(cl->cl_pif->pif_ifq); + + if (cl->cl_red != NULL) { +#ifdef ALTQ_RIO + if (cl->cl_qtype == Q_RIO) + rio_destroy((rio_t *)cl->cl_red); +#endif +#ifdef ALTQ_RED + if (cl->cl_qtype == Q_RED) + red_destroy(cl->cl_red); +#endif +#ifdef ALTQ_CODEL + if (cl->cl_qtype == Q_CODEL) + codel_destroy(cl->cl_codel); +#endif + } + free(cl->cl_buckets, M_DEVBUF); + free(cl, M_DEVBUF); + + return (0); +} + +/* + * fairq_enqueue is an enqueue function to be registered to + * (*altq_enqueue) in struct ifaltq. + */ +static int +fairq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr) +{ + struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc; + struct fairq_class *cl = NULL; /* Make compiler happy */ + struct pf_mtag *t; + u_int32_t qid_hash = 0; + int len; + + IFQ_LOCK_ASSERT(ifq); + + /* grab class set by classifier */ + if ((m->m_flags & M_PKTHDR) == 0) { + /* should not happen */ + printf("altq: packet for %s does not have pkthdr\n", + ifq->altq_ifp->if_xname); + m_freem(m); + return (ENOBUFS); + } + + if ((t = pf_find_mtag(m)) != NULL) { + cl = clh_to_clp(pif, t->qid); + qid_hash = t->qid_hash; + } + if (cl == NULL) { + cl = pif->pif_default; + if (cl == NULL) { + m_freem(m); + return (ENOBUFS); + } + } + cl->cl_flags |= FARF_HAS_PACKETS; + cl->cl_pktattr = NULL; + len = m_pktlen(m); + if (fairq_addq(cl, m, qid_hash) != 0) { + /* drop occurred. mbuf was freed in fairq_addq. */ + PKTCNTR_ADD(&cl->cl_dropcnt, len); + return (ENOBUFS); + } + IFQ_INC_LEN(ifq); + + return (0); +} + +/* + * fairq_dequeue is a dequeue function to be registered to + * (*altq_dequeue) in struct ifaltq. + * + * note: ALTDQ_POLL returns the next packet without removing the packet + * from the queue. ALTDQ_REMOVE is a normal dequeue operation. + * ALTDQ_REMOVE must return the same packet if called immediately + * after ALTDQ_POLL. + */ +static struct mbuf * +fairq_dequeue(struct ifaltq *ifq, int op) +{ + struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc; + struct fairq_class *cl; + struct fairq_class *best_cl; + struct mbuf *best_m; + struct mbuf *m = NULL; + uint64_t cur_time = read_machclk(); + int pri; + int hit_limit; + + IFQ_LOCK_ASSERT(ifq); + + if (IFQ_IS_EMPTY(ifq)) { + return (NULL); + } + + if (pif->pif_poll_cache && op == ALTDQ_REMOVE) { + best_cl = pif->pif_poll_cache; + m = fairq_getq(best_cl, cur_time); + pif->pif_poll_cache = NULL; + if (m) { + IFQ_DEC_LEN(ifq); + PKTCNTR_ADD(&best_cl->cl_xmitcnt, m_pktlen(m)); + return (m); + } + } else { + best_cl = NULL; + best_m = NULL; + + for (pri = pif->pif_maxpri; pri >= 0; pri--) { + if ((cl = pif->pif_classes[pri]) == NULL) + continue; + if ((cl->cl_flags & FARF_HAS_PACKETS) == 0) + continue; + m = fairq_pollq(cl, cur_time, &hit_limit); + if (m == NULL) { + cl->cl_flags &= ~FARF_HAS_PACKETS; + continue; + } + + /* + * Only override the best choice if we are under + * the BW limit. + */ + if (hit_limit == 0 || best_cl == NULL) { + best_cl = cl; + best_m = m; + } + + /* + * Remember the highest priority mbuf in case we + * do not find any lower priority mbufs. + */ + if (hit_limit) + continue; + break; + } + if (op == ALTDQ_POLL) { + pif->pif_poll_cache = best_cl; + m = best_m; + } else if (best_cl) { + m = fairq_getq(best_cl, cur_time); + if (m != NULL) { + IFQ_DEC_LEN(ifq); + PKTCNTR_ADD(&best_cl->cl_xmitcnt, m_pktlen(m)); + } + } + return (m); + } + return (NULL); +} + +static int +fairq_addq(struct fairq_class *cl, struct mbuf *m, u_int32_t bucketid) +{ + fairq_bucket_t *b; + u_int hindex; + uint64_t bw; + + /* + * If the packet doesn't have any keep state put it on the end of + * our queue. XXX this can result in out of order delivery. + */ + if (bucketid == 0) { + if (cl->cl_head) + b = cl->cl_head->prev; + else + b = &cl->cl_buckets[0]; + } else { + hindex = bucketid & cl->cl_nbucket_mask; + b = &cl->cl_buckets[hindex]; + } + + /* + * Add the bucket to the end of the circular list of active buckets. + * + * As a special case we add the bucket to the beginning of the list + * instead of the end if it was not previously on the list and if + * its traffic is less then the hog level. + */ + if (b->in_use == 0) { + b->in_use = 1; + if (cl->cl_head == NULL) { + cl->cl_head = b; + b->next = b; + b->prev = b; + } else { + b->next = cl->cl_head; + b->prev = cl->cl_head->prev; + b->prev->next = b; + b->next->prev = b; + + if (b->bw_delta && cl->cl_hogs_m1) { + bw = b->bw_bytes * machclk_freq / b->bw_delta; + if (bw < cl->cl_hogs_m1) + cl->cl_head = b; + } + } + } + +#ifdef ALTQ_RIO + if (cl->cl_qtype == Q_RIO) + return rio_addq((rio_t *)cl->cl_red, &b->queue, m, cl->cl_pktattr); +#endif +#ifdef ALTQ_RED + if (cl->cl_qtype == Q_RED) + return red_addq(cl->cl_red, &b->queue, m, cl->cl_pktattr); +#endif +#ifdef ALTQ_CODEL + if (cl->cl_qtype == Q_CODEL) + return codel_addq(cl->cl_codel, &b->queue, m); +#endif + if (qlen(&b->queue) >= qlimit(&b->queue)) { + m_freem(m); + return (-1); + } + + if (cl->cl_flags & FARF_CLEARDSCP) + write_dsfield(m, cl->cl_pktattr, 0); + + _addq(&b->queue, m); + + return (0); +} + +static struct mbuf * +fairq_getq(struct fairq_class *cl, uint64_t cur_time) +{ + fairq_bucket_t *b; + struct mbuf *m; + + b = fairq_selectq(cl, 0); + if (b == NULL) + m = NULL; +#ifdef ALTQ_RIO + else if (cl->cl_qtype == Q_RIO) + m = rio_getq((rio_t *)cl->cl_red, &b->queue); +#endif +#ifdef ALTQ_RED + else if (cl->cl_qtype == Q_RED) + m = red_getq(cl->cl_red, &b->queue); +#endif +#ifdef ALTQ_CODEL + else if (cl->cl_qtype == Q_CODEL) + m = codel_getq(cl->cl_codel, &b->queue); +#endif + else + m = _getq(&b->queue); + + /* + * Calculate the BW change + */ + if (m != NULL) { + uint64_t delta; + + /* + * Per-class bandwidth calculation + */ + delta = (cur_time - cl->cl_last_time); + if (delta > machclk_freq * 8) + delta = machclk_freq * 8; + cl->cl_bw_delta += delta; + cl->cl_bw_bytes += m->m_pkthdr.len; + cl->cl_last_time = cur_time; + cl->cl_bw_delta -= cl->cl_bw_delta >> 3; + cl->cl_bw_bytes -= cl->cl_bw_bytes >> 3; + + /* + * Per-bucket bandwidth calculation + */ + delta = (cur_time - b->last_time); + if (delta > machclk_freq * 8) + delta = machclk_freq * 8; + b->bw_delta += delta; + b->bw_bytes += m->m_pkthdr.len; + b->last_time = cur_time; + b->bw_delta -= b->bw_delta >> 3; + b->bw_bytes -= b->bw_bytes >> 3; + } + return(m); +} + +/* + * Figure out what the next packet would be if there were no limits. If + * this class hits its bandwidth limit *hit_limit is set to no-zero, otherwise + * it is set to 0. A non-NULL mbuf is returned either way. + */ +static struct mbuf * +fairq_pollq(struct fairq_class *cl, uint64_t cur_time, int *hit_limit) +{ + fairq_bucket_t *b; + struct mbuf *m; + uint64_t delta; + uint64_t bw; + + *hit_limit = 0; + b = fairq_selectq(cl, 1); + if (b == NULL) + return(NULL); + m = qhead(&b->queue); + + /* + * Did this packet exceed the class bandwidth? Calculate the + * bandwidth component of the packet. + * + * - Calculate bytes per second + */ + delta = cur_time - cl->cl_last_time; + if (delta > machclk_freq * 8) + delta = machclk_freq * 8; + cl->cl_bw_delta += delta; + cl->cl_last_time = cur_time; + if (cl->cl_bw_delta) { + bw = cl->cl_bw_bytes * machclk_freq / cl->cl_bw_delta; + + if (bw > cl->cl_bandwidth) + *hit_limit = 1; +#ifdef ALTQ_DEBUG + printf("BW %6ju relative to %6u %d queue %p\n", + (uintmax_t)bw, cl->cl_bandwidth, *hit_limit, b); +#endif + } + return(m); +} + +/* + * Locate the next queue we want to pull a packet out of. This code + * is also responsible for removing empty buckets from the circular list. + */ +static +fairq_bucket_t * +fairq_selectq(struct fairq_class *cl, int ispoll) +{ + fairq_bucket_t *b; + uint64_t bw; + + if (ispoll == 0 && cl->cl_polled) { + b = cl->cl_polled; + cl->cl_polled = NULL; + return(b); + } + + while ((b = cl->cl_head) != NULL) { + /* + * Remove empty queues from consideration + */ + if (qempty(&b->queue)) { + b->in_use = 0; + cl->cl_head = b->next; + if (cl->cl_head == b) { + cl->cl_head = NULL; + } else { + b->next->prev = b->prev; + b->prev->next = b->next; + } + continue; + } + + /* + * Advance the round robin. Queues with bandwidths less + * then the hog bandwidth are allowed to burst. + */ + if (cl->cl_hogs_m1 == 0) { + cl->cl_head = b->next; + } else if (b->bw_delta) { + bw = b->bw_bytes * machclk_freq / b->bw_delta; + if (bw >= cl->cl_hogs_m1) { + cl->cl_head = b->next; + } + /* + * XXX TODO - + */ + } + + /* + * Return bucket b. + */ + break; + } + if (ispoll) + cl->cl_polled = b; + return(b); +} + +static void +fairq_purgeq(struct fairq_class *cl) +{ + fairq_bucket_t *b; + struct mbuf *m; + + while ((b = fairq_selectq(cl, 0)) != NULL) { + while ((m = _getq(&b->queue)) != NULL) { + PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m)); + m_freem(m); + } + ASSERT(qlen(&b->queue) == 0); + } +} + +static void +get_class_stats(struct fairq_classstats *sp, struct fairq_class *cl) +{ + fairq_bucket_t *b; + + sp->class_handle = cl->cl_handle; + sp->qlimit = cl->cl_qlimit; + sp->xmit_cnt = cl->cl_xmitcnt; + sp->drop_cnt = cl->cl_dropcnt; + sp->qtype = cl->cl_qtype; + sp->qlength = 0; + + if (cl->cl_head) { + b = cl->cl_head; + do { + sp->qlength += qlen(&b->queue); + b = b->next; + } while (b != cl->cl_head); + } + +#ifdef ALTQ_RED + if (cl->cl_qtype == Q_RED) + red_getstats(cl->cl_red, &sp->red[0]); +#endif +#ifdef ALTQ_RIO + if (cl->cl_qtype == Q_RIO) + rio_getstats((rio_t *)cl->cl_red, &sp->red[0]); +#endif +#ifdef ALTQ_CODEL + if (cl->cl_qtype == Q_CODEL) + codel_getstats(cl->cl_codel, &sp->codel); +#endif +} + +/* convert a class handle to the corresponding class pointer */ +static struct fairq_class * +clh_to_clp(struct fairq_if *pif, uint32_t chandle) +{ + struct fairq_class *cl; + int idx; + + if (chandle == 0) + return (NULL); + + for (idx = pif->pif_maxpri; idx >= 0; idx--) + if ((cl = pif->pif_classes[idx]) != NULL && + cl->cl_handle == chandle) + return (cl); + + return (NULL); +} + +#endif /* ALTQ_FAIRQ */ diff --git a/sys/contrib/altq/altq/altq_fairq.h b/sys/contrib/altq/altq/altq_fairq.h new file mode 100644 index 0000000..8fede5b --- /dev/null +++ b/sys/contrib/altq/altq/altq_fairq.h @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2008 The DragonFly Project. All rights reserved. + * + * This code is derived from software contributed to The DragonFly Project + * by Matthew Dillon <dillon@backplane.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. Neither the name of The DragonFly Project nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific, prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDERS 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. + * + * $DragonFly: src/sys/net/altq/altq_fairq.h,v 1.1 2008/04/06 18:58:15 dillon Exp $ + * $FreeBSD$ + */ + +#ifndef _ALTQ_ALTQ_FAIRQ_H_ +#define _ALTQ_ALTQ_FAIRQ_H_ + +#include <altq/altq.h> +#include <altq/altq_classq.h> +#include <altq/altq_codel.h> +#include <altq/altq_red.h> +#include <altq/altq_rio.h> +#include <altq/altq_rmclass.h> + +#define FAIRQ_MAX_BUCKETS 2048 /* maximum number of sorting buckets */ +#define FAIRQ_MAXPRI RM_MAXPRIO +#define FAIRQ_BITMAP_WIDTH (sizeof(fairq_bitmap_t)*8) +#define FAIRQ_BITMAP_MASK (FAIRQ_BITMAP_WIDTH - 1) + +/* fairq class flags */ +#define FARF_RED 0x0001 /* use RED */ +#define FARF_ECN 0x0002 /* use RED/ECN */ +#define FARF_RIO 0x0004 /* use RIO */ +#define FARF_CODEL 0x0008 /* use CoDel */ +#define FARF_CLEARDSCP 0x0010 /* clear diffserv codepoint */ +#define FARF_DEFAULTCLASS 0x1000 /* default class */ + +#define FARF_HAS_PACKETS 0x2000 /* might have queued packets */ + +#define FARF_USERFLAGS (FARF_RED|FARF_ECN|FARF_RIO|FARF_CLEARDSCP| \ + FARF_DEFAULTCLASS) + +/* special class handles */ +#define FAIRQ_NULLCLASS_HANDLE 0 + +typedef u_int fairq_bitmap_t; + +struct fairq_classstats { + uint32_t class_handle; + + u_int qlength; + u_int qlimit; + struct pktcntr xmit_cnt; /* transmitted packet counter */ + struct pktcntr drop_cnt; /* dropped packet counter */ + + /* codel, red and rio related info */ + int qtype; + struct redstats red[3]; /* rio has 3 red stats */ + struct codel_stats codel; +}; + +#ifdef _KERNEL + +typedef struct fairq_bucket { + struct fairq_bucket *next; /* circular list */ + struct fairq_bucket *prev; /* circular list */ + class_queue_t queue; /* the actual queue */ + uint64_t bw_bytes; /* statistics used to calculate bw */ + uint64_t bw_delta; /* statistics used to calculate bw */ + uint64_t last_time; + int in_use; +} fairq_bucket_t; + +struct fairq_class { + uint32_t cl_handle; /* class handle */ + u_int cl_nbuckets; /* (power of 2) */ + u_int cl_nbucket_mask; /* bucket mask */ + fairq_bucket_t *cl_buckets; + fairq_bucket_t *cl_head; /* head of circular bucket list */ + fairq_bucket_t *cl_polled; + union { + struct red *cl_red; /* RED state */ + struct codel *cl_codel; /* CoDel state */ + } cl_aqm; +#define cl_red cl_aqm.cl_red +#define cl_codel cl_aqm.cl_codel + u_int cl_hogs_m1; + u_int cl_lssc_m1; + u_int cl_bandwidth; + uint64_t cl_bw_bytes; + uint64_t cl_bw_delta; + uint64_t cl_last_time; + int cl_qtype; /* rollup */ + int cl_qlimit; + int cl_pri; /* priority */ + int cl_flags; /* class flags */ + struct fairq_if *cl_pif; /* back pointer to pif */ + struct altq_pktattr *cl_pktattr; /* saved header used by ECN */ + + /* round robin index */ + + /* statistics */ + struct pktcntr cl_xmitcnt; /* transmitted packet counter */ + struct pktcntr cl_dropcnt; /* dropped packet counter */ +}; + +/* + * fairq interface state + */ +struct fairq_if { + struct fairq_if *pif_next; /* interface state list */ + struct ifaltq *pif_ifq; /* backpointer to ifaltq */ + u_int pif_bandwidth; /* link bandwidth in bps */ + int pif_maxpri; /* max priority in use */ + struct fairq_class *pif_poll_cache;/* cached poll */ + struct fairq_class *pif_default; /* default class */ + struct fairq_class *pif_classes[FAIRQ_MAXPRI]; /* classes */ +}; + +#endif /* _KERNEL */ + +#endif /* _ALTQ_ALTQ_FAIRQ_H_ */ diff --git a/sys/contrib/altq/altq/altq_hfsc.c b/sys/contrib/altq/altq/altq_hfsc.c index 0363016..d4f7ab9 100644 --- a/sys/contrib/altq/altq/altq_hfsc.c +++ b/sys/contrib/altq/altq/altq_hfsc.c @@ -391,6 +391,14 @@ hfsc_class_create(struct hfsc_if *hif, struct service_curve *rsc, return (NULL); } #endif +#ifndef ALTQ_CODEL + if (flags & HFCF_CODEL) { +#ifdef ALTQ_DEBUG + printf("hfsc_class_create: CODEL not configured for HFSC!\n"); +#endif + return (NULL); + } +#endif cl = malloc(sizeof(struct hfsc_class), M_DEVBUF, M_NOWAIT | M_ZERO); if (cl == NULL) @@ -407,6 +415,7 @@ hfsc_class_create(struct hfsc_if *hif, struct service_curve *rsc, qlimit(cl->cl_q) = qlimit; qtype(cl->cl_q) = Q_DROPTAIL; qlen(cl->cl_q) = 0; + qsize(cl->cl_q) = 0; cl->cl_flags = flags; #ifdef ALTQ_RED if (flags & (HFCF_RED|HFCF_RIO)) { @@ -451,6 +460,13 @@ hfsc_class_create(struct hfsc_if *hif, struct service_curve *rsc, #endif } #endif /* ALTQ_RED */ +#ifdef ALTQ_CODEL + if (flags & HFCF_CODEL) { + cl->cl_codel = codel_alloc(5, 100, 0); + if (cl->cl_codel != NULL) + qtype(cl->cl_q) = Q_CODEL; + } +#endif if (rsc != NULL && (rsc->m1 != 0 || rsc->m2 != 0)) { cl->cl_rsc = malloc(sizeof(struct internal_sc), @@ -543,6 +559,10 @@ hfsc_class_create(struct hfsc_if *hif, struct service_curve *rsc, if (q_is_red(cl->cl_q)) red_destroy(cl->cl_red); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_destroy(cl->cl_codel); +#endif } if (cl->cl_fsc != NULL) free(cl->cl_fsc, M_DEVBUF); @@ -617,6 +637,10 @@ hfsc_class_destroy(struct hfsc_class *cl) if (q_is_red(cl->cl_q)) red_destroy(cl->cl_red); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_destroy(cl->cl_codel); +#endif } IFQ_LOCK(cl->cl_hif->hif_ifq); @@ -844,6 +868,10 @@ hfsc_addq(struct hfsc_class *cl, struct mbuf *m) if (q_is_red(cl->cl_q)) return red_addq(cl->cl_red, cl->cl_q, m, cl->cl_pktattr); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + return codel_addq(cl->cl_codel, cl->cl_q, m); +#endif if (qlen(cl->cl_q) >= qlimit(cl->cl_q)) { m_freem(m); return (-1); @@ -868,6 +896,10 @@ hfsc_getq(struct hfsc_class *cl) if (q_is_red(cl->cl_q)) return red_getq(cl->cl_red, cl->cl_q); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + return codel_getq(cl->cl_codel, cl->cl_q); +#endif return _getq(cl->cl_q); } @@ -1652,6 +1684,10 @@ get_class_stats(struct hfsc_classstats *sp, struct hfsc_class *cl) if (q_is_rio(cl->cl_q)) rio_getstats((rio_t *)cl->cl_red, &sp->red[0]); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_getstats(cl->cl_codel, &sp->codel); +#endif } /* convert a class handle to the corresponding class pointer */ diff --git a/sys/contrib/altq/altq/altq_hfsc.h b/sys/contrib/altq/altq/altq_hfsc.h index d04b378..b0228c5 100644 --- a/sys/contrib/altq/altq/altq_hfsc.h +++ b/sys/contrib/altq/altq/altq_hfsc.h @@ -34,6 +34,7 @@ #include <altq/altq.h> #include <altq/altq_classq.h> +#include <altq/altq_codel.h> #include <altq/altq_red.h> #include <altq/altq_rio.h> @@ -49,12 +50,13 @@ struct service_curve { /* special class handles */ #define HFSC_NULLCLASS_HANDLE 0 -#define HFSC_MAX_CLASSES 64 +#define HFSC_MAX_CLASSES 2048 /* hfsc class flags */ #define HFCF_RED 0x0001 /* use RED */ #define HFCF_ECN 0x0002 /* use RED/ECN */ #define HFCF_RIO 0x0004 /* use RIO */ +#define HFCF_CODEL 0x0008 /* use CoDel */ #define HFCF_CLEARDSCP 0x0010 /* clear diffserv codepoint */ #define HFCF_DEFAULTCLASS 0x1000 /* default class */ @@ -101,9 +103,10 @@ struct hfsc_classstats { u_int parentperiod; /* parent's vt period seqno */ int nactive; /* number of active children */ - /* red and rio related info */ + /* codel, red and rio related info */ int qtype; struct redstats red[3]; + struct codel_stats codel; }; #ifdef ALTQ3_COMPAT @@ -229,7 +232,12 @@ struct hfsc_class { struct hfsc_class *cl_children; /* child classes */ class_queue_t *cl_q; /* class queue structure */ - struct red *cl_red; /* RED state */ + union { + struct red *cl_red; /* RED state */ + struct codel *cl_codel; /* CoDel state */ + } cl_aqm; +#define cl_red cl_aqm.cl_red +#define cl_codel cl_aqm.cl_codel struct altq_pktattr *cl_pktattr; /* saved header used by ECN */ u_int64_t cl_total; /* total work in bytes */ diff --git a/sys/contrib/altq/altq/altq_priq.c b/sys/contrib/altq/altq/altq_priq.c index 3ce65dc..c77ba40 100644 --- a/sys/contrib/altq/altq/altq_priq.c +++ b/sys/contrib/altq/altq/altq_priq.c @@ -297,6 +297,14 @@ priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid) return (NULL); } #endif +#ifndef ALTQ_CODEL + if (flags & PRCF_CODEL) { +#ifdef ALTQ_DEBUG + printf("priq_class_create: CODEL not configured for PRIQ!\n"); +#endif + return (NULL); + } +#endif if ((cl = pif->pif_classes[pri]) != NULL) { /* modify the class instead of creating a new one */ @@ -318,6 +326,10 @@ priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid) if (q_is_red(cl->cl_q)) red_destroy(cl->cl_red); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_destroy(cl->cl_codel); +#endif } else { cl = malloc(sizeof(struct priq_class), M_DEVBUF, M_NOWAIT | M_ZERO); @@ -338,6 +350,7 @@ priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid) qlimit(cl->cl_q) = qlimit; qtype(cl->cl_q) = Q_DROPTAIL; qlen(cl->cl_q) = 0; + qsize(cl->cl_q) = 0; cl->cl_flags = flags; cl->cl_pri = pri; if (pri > pif->pif_maxpri) @@ -381,6 +394,13 @@ priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid) } } #endif /* ALTQ_RED */ +#ifdef ALTQ_CODEL + if (flags & PRCF_CODEL) { + cl->cl_codel = codel_alloc(5, 100, 0); + if (cl->cl_codel != NULL) + qtype(cl->cl_q) = Q_CODEL; + } +#endif return (cl); @@ -394,6 +414,10 @@ priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid) if (q_is_red(cl->cl_q)) red_destroy(cl->cl_red); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_destroy(cl->cl_codel); +#endif } if (cl->cl_q != NULL) free(cl->cl_q, M_DEVBUF); @@ -445,6 +469,10 @@ priq_class_destroy(struct priq_class *cl) if (q_is_red(cl->cl_q)) red_destroy(cl->cl_red); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_destroy(cl->cl_codel); +#endif } free(cl->cl_q, M_DEVBUF); free(cl, M_DEVBUF); @@ -560,6 +588,10 @@ priq_addq(struct priq_class *cl, struct mbuf *m) if (q_is_red(cl->cl_q)) return red_addq(cl->cl_red, cl->cl_q, m, cl->cl_pktattr); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + return codel_addq(cl->cl_codel, cl->cl_q, m); +#endif if (qlen(cl->cl_q) >= qlimit(cl->cl_q)) { m_freem(m); return (-1); @@ -584,6 +616,10 @@ priq_getq(struct priq_class *cl) if (q_is_red(cl->cl_q)) return red_getq(cl->cl_red, cl->cl_q); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + return codel_getq(cl->cl_codel, cl->cl_q); +#endif return _getq(cl->cl_q); } @@ -628,7 +664,10 @@ get_class_stats(struct priq_classstats *sp, struct priq_class *cl) if (q_is_rio(cl->cl_q)) rio_getstats((rio_t *)cl->cl_red, &sp->red[0]); #endif - +#ifdef ALTQ_CODEL + if (q_is_codel(cl->cl_q)) + codel_getstats(cl->cl_codel, &sp->codel); +#endif } /* convert a class handle to the corresponding class pointer */ diff --git a/sys/contrib/altq/altq/altq_priq.h b/sys/contrib/altq/altq/altq_priq.h index 481d31b..110847d 100644 --- a/sys/contrib/altq/altq/altq_priq.h +++ b/sys/contrib/altq/altq/altq_priq.h @@ -30,6 +30,7 @@ #include <altq/altq.h> #include <altq/altq_classq.h> +#include <altq/altq_codel.h> #include <altq/altq_red.h> #include <altq/altq_rio.h> @@ -59,6 +60,7 @@ struct priq_add_class { #define PRCF_RED 0x0001 /* use RED */ #define PRCF_ECN 0x0002 /* use RED/ECN */ #define PRCF_RIO 0x0004 /* use RIO */ +#define PRCF_CODEL 0x0008 /* use CoDel */ #define PRCF_CLEARDSCP 0x0010 /* clear diffserv codepoint */ #define PRCF_DEFAULTCLASS 0x1000 /* default class */ @@ -102,9 +104,10 @@ struct priq_classstats { struct pktcntr xmitcnt; /* transmitted packet counter */ struct pktcntr dropcnt; /* dropped packet counter */ - /* red and rio related info */ + /* codel, red and rio related info */ int qtype; struct redstats red[3]; /* rio has 3 red stats */ + struct codel_stats codel; }; #ifdef ALTQ3_COMPAT @@ -134,7 +137,12 @@ struct priq_class_stats { struct priq_class { u_int32_t cl_handle; /* class handle */ class_queue_t *cl_q; /* class queue structure */ - struct red *cl_red; /* RED state */ + union { + struct red *cl_red; /* RED state */ + struct codel *cl_codel; /* CoDel state */ + } cl_aqm; +#define cl_red cl_aqm.cl_red +#define cl_codel cl_aqm.cl_codel int cl_pri; /* priority */ int cl_flags; /* class flags */ struct priq_if *cl_pif; /* back pointer to pif */ diff --git a/sys/contrib/altq/altq/altq_rmclass.c b/sys/contrib/altq/altq/altq_rmclass.c index c433024..656d0ee 100644 --- a/sys/contrib/altq/altq/altq_rmclass.c +++ b/sys/contrib/altq/altq/altq_rmclass.c @@ -68,6 +68,7 @@ #include <altq/if_altq.h> #include <altq/altq.h> +#include <altq/altq_codel.h> #include <altq/altq_rmclass.h> #include <altq/altq_rmclass_debug.h> #include <altq/altq_red.h> @@ -218,6 +219,14 @@ rmc_newclass(int pri, struct rm_ifdat *ifd, u_int nsecPerByte, return (NULL); } #endif +#ifndef ALTQ_CODEL + if (flags & RMCF_CODEL) { +#ifdef ALTQ_DEBUG + printf("rmc_newclass: CODEL not configured for CBQ!\n"); +#endif + return (NULL); + } +#endif cl = malloc(sizeof(struct rm_class), M_DEVBUF, M_NOWAIT | M_ZERO); if (cl == NULL) @@ -302,6 +311,13 @@ rmc_newclass(int pri, struct rm_ifdat *ifd, u_int nsecPerByte, #endif } #endif /* ALTQ_RED */ +#ifdef ALTQ_CODEL + if (flags & RMCF_CODEL) { + cl->codel_ = codel_alloc(5, 100, 0); + if (cl->codel_ != NULL) + qtype(cl->q_) = Q_CODEL; + } +#endif /* * put the class into the class tree @@ -652,6 +668,10 @@ rmc_delete_class(struct rm_ifdat *ifd, struct rm_class *cl) if (q_is_red(cl->q_)) red_destroy(cl->red_); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->q_)) + codel_destroy(cl->codel_); +#endif } free(cl->q_, M_DEVBUF); free(cl, M_DEVBUF); @@ -1618,6 +1638,10 @@ _rmc_addq(rm_class_t *cl, mbuf_t *m) if (q_is_red(cl->q_)) return red_addq(cl->red_, cl->q_, m, cl->pktattr_); #endif /* ALTQ_RED */ +#ifdef ALTQ_CODEL + if (q_is_codel(cl->q_)) + return codel_addq(cl->codel_, cl->q_, m); +#endif if (cl->flags_ & RMCF_CLEARDSCP) write_dsfield(m, cl->pktattr_, 0); @@ -1647,6 +1671,10 @@ _rmc_getq(rm_class_t *cl) if (q_is_red(cl->q_)) return red_getq(cl->red_, cl->q_); #endif +#ifdef ALTQ_CODEL + if (q_is_codel(cl->q_)) + return codel_getq(cl->codel_, cl->q_); +#endif return _getq(cl->q_); } @@ -1717,7 +1745,8 @@ void cbqtrace_dump(int counter) #endif /* CBQ_TRACE */ #endif /* ALTQ_CBQ */ -#if defined(ALTQ_CBQ) || defined(ALTQ_RED) || defined(ALTQ_RIO) || defined(ALTQ_HFSC) || defined(ALTQ_PRIQ) +#if defined(ALTQ_CBQ) || defined(ALTQ_RED) || defined(ALTQ_RIO) || \ + defined(ALTQ_HFSC) || defined(ALTQ_PRIQ) || defined(ALTQ_CODEL) #if !defined(__GNUC__) || defined(ALTQ_DEBUG) void diff --git a/sys/contrib/altq/altq/altq_rmclass.h b/sys/contrib/altq/altq/altq_rmclass.h index cf0ddf4..782bc13 100644 --- a/sys/contrib/altq/altq/altq_rmclass.h +++ b/sys/contrib/altq/altq/altq_rmclass.h @@ -164,7 +164,12 @@ struct rm_class { void (*overlimit)(struct rm_class *, struct rm_class *); void (*drop)(struct rm_class *); /* Class drop action. */ - struct red *red_; /* RED state pointer */ + union { + struct red *red_; /* RED state pointer */ + struct codel *codel_; /* codel state pointer */ + } cl_aqm_; +#define red_ cl_aqm_.red_ +#define codel_ cl_aqm_.codel_ struct altq_pktattr *pktattr_; /* saved hdr used by RED/ECN */ int flags_; @@ -233,6 +238,7 @@ struct rm_ifdat { #define RMCF_RIO 0x0004 #define RMCF_FLOWVALVE 0x0008 /* use flowvalve (aka penalty-box) */ #define RMCF_CLEARDSCP 0x0010 /* clear diffserv codepoint */ +#define RMCF_CODEL 0x0020 /* flags for rmc_init */ #define RMCF_WRR 0x0100 diff --git a/sys/contrib/altq/altq/altq_subr.c b/sys/contrib/altq/altq/altq_subr.c index 16b796a..bddf73f 100644 --- a/sys/contrib/altq/altq/altq_subr.c +++ b/sys/contrib/altq/altq/altq_subr.c @@ -537,6 +537,16 @@ altq_pfattach(struct pf_altq *a) error = hfsc_pfattach(a); break; #endif +#ifdef ALTQ_FAIRQ + case ALTQT_FAIRQ: + error = fairq_pfattach(a); + break; +#endif +#ifdef ALTQ_CODEL + case ALTQT_CODEL: + error = codel_pfattach(a); + break; +#endif default: error = ENXIO; } @@ -612,6 +622,16 @@ altq_add(struct pf_altq *a) error = hfsc_add_altq(a); break; #endif +#ifdef ALTQ_FAIRQ + case ALTQT_FAIRQ: + error = fairq_add_altq(a); + break; +#endif +#ifdef ALTQ_CODEL + case ALTQT_CODEL: + error = codel_add_altq(a); + break; +#endif default: error = ENXIO; } @@ -648,6 +668,16 @@ altq_remove(struct pf_altq *a) error = hfsc_remove_altq(a); break; #endif +#ifdef ALTQ_FAIRQ + case ALTQT_FAIRQ: + error = fairq_remove_altq(a); + break; +#endif +#ifdef ALTQ_CODEL + case ALTQT_CODEL: + error = codel_remove_altq(a); + break; +#endif default: error = ENXIO; } @@ -681,6 +711,11 @@ altq_add_queue(struct pf_altq *a) error = hfsc_add_queue(a); break; #endif +#ifdef ALTQ_FAIRQ + case ALTQT_FAIRQ: + error = fairq_add_queue(a); + break; +#endif default: error = ENXIO; } @@ -714,6 +749,11 @@ altq_remove_queue(struct pf_altq *a) error = hfsc_remove_queue(a); break; #endif +#ifdef ALTQ_FAIRQ + case ALTQT_FAIRQ: + error = fairq_remove_queue(a); + break; +#endif default: error = ENXIO; } @@ -747,6 +787,16 @@ altq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes) error = hfsc_getqstats(a, ubuf, nbytes); break; #endif +#ifdef ALTQ_FAIRQ + case ALTQT_FAIRQ: + error = fairq_getqstats(a, ubuf, nbytes); + break; +#endif +#ifdef ALTQ_CODEL + case ALTQT_CODEL: + error = codel_getqstats(a, ubuf, nbytes); + break; +#endif default: error = ENXIO; } diff --git a/sys/contrib/altq/altq/altq_var.h b/sys/contrib/altq/altq/altq_var.h index 956ee16..355c94c 100644 --- a/sys/contrib/altq/altq/altq_var.h +++ b/sys/contrib/altq/altq/altq_var.h @@ -243,6 +243,11 @@ int cbq_add_queue(struct pf_altq *); int cbq_remove_queue(struct pf_altq *); int cbq_getqstats(struct pf_altq *, void *, int *); +int codel_pfattach(struct pf_altq *); +int codel_add_altq(struct pf_altq *); +int codel_remove_altq(struct pf_altq *); +int codel_getqstats(struct pf_altq *, void *, int *); + int priq_pfattach(struct pf_altq *); int priq_add_altq(struct pf_altq *); int priq_remove_altq(struct pf_altq *); @@ -257,5 +262,12 @@ int hfsc_add_queue(struct pf_altq *); int hfsc_remove_queue(struct pf_altq *); int hfsc_getqstats(struct pf_altq *, void *, int *); +int fairq_pfattach(struct pf_altq *); +int fairq_add_altq(struct pf_altq *); +int fairq_remove_altq(struct pf_altq *); +int fairq_add_queue(struct pf_altq *); +int fairq_remove_queue(struct pf_altq *); +int fairq_getqstats(struct pf_altq *, void *, int *); + #endif /* _KERNEL */ #endif /* _ALTQ_ALTQ_VAR_H_ */ diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300.h b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300.h index 00f3384..e63b517 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300.h +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300.h @@ -185,6 +185,8 @@ struct ar9300_ani_state { int32_t rssi; /* The current RSSI */ u_int32_t tx_frame_count; /* Last tx_frame_count */ u_int32_t rx_frame_count; /* Last rx Frame count */ + u_int32_t rx_busy_count; /* Last rx busy count */ + u_int32_t rx_ext_busy_count; /* Last rx busy count; extension channel */ u_int32_t cycle_count; /* Last cycle_count (can detect wrap-around) */ u_int32_t ofdm_phy_err_count;/* OFDM err count since last reset */ u_int32_t cck_phy_err_count; /* CCK err count since last reset */ @@ -204,6 +206,7 @@ struct ar9300_ani_state { #define DO_ANI(ah) \ ((AH9300(ah)->ah_proc_phy_err & HAL_PROCESS_ANI)) +#if 0 struct ar9300_stats { u_int32_t ast_ani_niup; /* ANI increased noise immunity */ u_int32_t ast_ani_nidown; /* ANI decreased noise immunity */ @@ -223,6 +226,7 @@ struct ar9300_stats { HAL_MIB_STATS ast_mibstats; /* MIB counter stats */ HAL_NODE_STATS ast_nodestats; /* Latest rssi stats from driver */ }; +#endif struct ar9300_rad_reader { u_int16_t rd_index; @@ -429,7 +433,7 @@ struct ath_hal_9300 { u_int32_t ah_mask2Reg; /* copy of AR_IMR_S2 */ u_int32_t ah_msi_reg; /* copy of AR_PCIE_MSI */ os_atomic_t ah_ier_ref_count; /* reference count for enabling interrupts */ - struct ar9300_stats ah_stats; /* various statistics */ + HAL_ANI_STATS ah_stats; /* various statistics */ RF_HAL_FUNCS ah_rf_hal; u_int32_t ah_tx_desc_mask; /* mask for TXDESC */ u_int32_t ah_tx_ok_interrupt_mask; @@ -576,6 +580,9 @@ struct ath_hal_9300 { u_int8_t ah_tx_chainmask; /* tx chain mask */ u_int8_t ah_rx_chainmask; /* rx chain mask */ + /* optional tx chainmask */ + u_int8_t ah_tx_chainmaskopt; + u_int8_t ah_tx_cal_chainmask; /* tx cal chain mask */ u_int8_t ah_rx_cal_chainmask; /* rx cal chain mask */ @@ -845,6 +852,7 @@ struct ath_hal_9300 { HAL_BOOL ah_aic_enabled; u_int32_t ah_aic_sram[ATH_AIC_MAX_BT_CHANNEL]; #endif + #endif /* ATH_SUPPORT_MCI */ u_int8_t ah_cac_quiet_enabled; #if ATH_WOW_OFFLOAD @@ -852,6 +860,14 @@ struct ath_hal_9300 { u_int32_t ah_mcast_filter_u32_set; #endif HAL_BOOL ah_reduced_self_gen_mask; + HAL_BOOL ah_chip_reset_done; + HAL_BOOL ah_abort_txdma_norx; + /* store previous passive RX Cal info */ + HAL_BOOL ah_skip_rx_iq_cal; + HAL_BOOL ah_rx_cal_complete; /* previous rx cal completed or not */ + u_int32_t ah_rx_cal_chan; /* chan on which rx cal is done */ + u_int32_t ah_rx_cal_chan_flag; + u_int32_t ah_rx_cal_corr[AR9300_MAX_CHAINS]; /* Local additions for FreeBSD */ /* @@ -873,11 +889,11 @@ struct ath_hal_9300 { int ah_fccaifs; int ah_reset_reason; int ah_dcs_enable; + HAL_ANI_STATE ext_ani_state; /* FreeBSD; external facing ANI state */ struct ar9300NfLimits nf_2GHz; struct ar9300NfLimits nf_5GHz; struct ar9300NfLimits *nfp; - }; #define AH9300(_ah) ((struct ath_hal_9300 *)(_ah)) @@ -1181,10 +1197,11 @@ struct ath_hal; extern struct ath_hal_9300 * ar9300_new_state(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status); extern struct ath_hal * ar9300_attach(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, - HAL_STATUS *status); + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status); extern void ar9300_detach(struct ath_hal *ah); extern void ar9300_read_revisions(struct ath_hal *ah); extern HAL_BOOL ar9300_chip_test(struct ath_hal *ah); @@ -1193,7 +1210,8 @@ extern HAL_BOOL ar9300_get_channel_edges(struct ath_hal *ah, extern HAL_BOOL ar9300_fill_capability_info(struct ath_hal *ah); extern void ar9300_beacon_init(struct ath_hal *ah, - u_int32_t next_beacon, u_int32_t beacon_period, HAL_OPMODE opmode); + u_int32_t next_beacon, u_int32_t beacon_period, + u_int32_t beacon_period_fraction, HAL_OPMODE opmode); extern void ar9300_set_sta_beacon_timers(struct ath_hal *ah, const HAL_BEACON_STATE *); @@ -1216,12 +1234,21 @@ extern HAL_BOOL ar9300_set_key_cache_entry_mac(struct ath_hal *, extern HAL_BOOL ar9300_set_key_cache_entry(struct ath_hal *ah, u_int16_t entry, const HAL_KEYVAL *k, const u_int8_t *mac, int xor_key); extern HAL_BOOL ar9300_print_keycache(struct ath_hal *ah); +#if ATH_SUPPORT_KEYPLUMB_WAR +extern HAL_BOOL ar9300_check_key_cache_entry(struct ath_hal *ah, u_int16_t entry, + const HAL_KEYVAL *k, int xorKey); +#endif extern void ar9300_get_mac_address(struct ath_hal *ah, u_int8_t *mac); extern HAL_BOOL ar9300_set_mac_address(struct ath_hal *ah, const u_int8_t *); extern void ar9300_get_bss_id_mask(struct ath_hal *ah, u_int8_t *mac); extern HAL_BOOL ar9300_set_bss_id_mask(struct ath_hal *, const u_int8_t *); extern HAL_STATUS ar9300_select_ant_config(struct ath_hal *ah, u_int32_t cfg); +#if 0 +extern u_int32_t ar9300_ant_ctrl_common_get(struct ath_hal *ah, HAL_BOOL is_2ghz); +#endif +extern HAL_BOOL ar9300_ant_swcom_sel(struct ath_hal *ah, u_int8_t ops, + u_int32_t *common_tbl1, u_int32_t *common_tbl2); extern HAL_BOOL ar9300_set_regulatory_domain(struct ath_hal *ah, u_int16_t reg_domain, HAL_STATUS *stats); extern u_int ar9300_get_wireless_modes(struct ath_hal *ah); @@ -1396,6 +1423,8 @@ extern HAL_BOOL ar9300_set_tx_power_limit(struct ath_hal *ah, u_int32_t limit, u_int16_t extra_txpow, u_int16_t tpc_in_db); extern void ar9300_chain_noise_floor(struct ath_hal *ah, int16_t *nf_buf, struct ieee80211_channel *chan, int is_scan); +extern int16_t ar9300_get_nf_from_reg(struct ath_hal *ah, struct ieee80211_channel *chan, int wait_time); +extern int ar9300_get_rx_nf_offset(struct ath_hal *ah, struct ieee80211_channel *chan, int8_t *nf_pwr, int8_t *nf_cal); extern HAL_BOOL ar9300_load_nf(struct ath_hal *ah, int16_t nf[]); extern HAL_RFGAIN ar9300_get_rfgain(struct ath_hal *ah); @@ -1417,7 +1446,7 @@ extern void ar9300_disable_mib_counters(struct ath_hal *); extern void ar9300_ani_attach(struct ath_hal *); extern void ar9300_ani_detach(struct ath_hal *); extern struct ar9300_ani_state *ar9300_ani_get_current_state(struct ath_hal *); -extern struct ar9300_stats *ar9300_ani_get_current_stats(struct ath_hal *); +extern HAL_ANI_STATS *ar9300_ani_get_current_stats(struct ath_hal *); extern HAL_BOOL ar9300_ani_control(struct ath_hal *, HAL_ANI_CMD cmd, int param); struct ath_rx_status; @@ -1680,6 +1709,8 @@ extern void ar9300_tx99_start(struct ath_hal *ah, u_int8_t *data); extern void ar9300_tx99_stop(struct ath_hal *ah); #endif /* ATH_SUPPORT_HTC */ #endif /* ATH_TX99_DIAG */ +extern HAL_BOOL ar9300_set_ctl_pwr(struct ath_hal *ah, u_int8_t *ctl_array); +extern void ar9300_set_txchainmaskopt(struct ath_hal *ah, u_int8_t mask); enum { AR9300_COEFF_TX_TYPE = 0, diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_ani.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_ani.c index b07ca71..9c2c3ed 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_ani.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_ani.c @@ -210,7 +210,7 @@ ar9300_ani_get_current_state(struct ath_hal *ah) /* * Return the current statistics. */ -struct ar9300_stats * +HAL_ANI_STATS * ar9300_ani_get_current_stats(struct ath_hal *ah) { return &AH9300(ah)->ah_stats; @@ -484,6 +484,9 @@ ar9300_ani_control(struct ath_hal *ah, HAL_ANI_CMD cmd, int param) */ is_on = param ? 1 : 0; + if (AR_SREV_JUPITER(ah) || AR_SREV_APHRODITE(ah)) + goto skip_ws_det; + /* * make register setting for default (weak sig detect ON) * come from INI file @@ -528,6 +531,7 @@ ar9300_ani_control(struct ath_hal *ah, HAL_ANI_CMD cmd, int param) m1_thresh_ext); OS_REG_RMW_FIELD(ah, AR_PHY_SFCORR_EXT, AR_PHY_SFCORR_EXT_M2_THRESH, m2_thresh_ext); +skip_ws_det: if (is_on) { OS_REG_SET_BIT(ah, AR_PHY_SFCORR_LOW, AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); @@ -1057,10 +1061,13 @@ ar9300_ani_get_listen_time(struct ath_hal *ah, HAL_ANISTATS *ani_stats) struct ath_hal_9300 *ahp = AH9300(ah); struct ar9300_ani_state *ani_state; u_int32_t tx_frame_count, rx_frame_count, cycle_count; + u_int32_t rx_busy_count, rx_ext_busy_count; int32_t listen_time; tx_frame_count = OS_REG_READ(ah, AR_TFCNT); rx_frame_count = OS_REG_READ(ah, AR_RFCNT); + rx_busy_count = OS_REG_READ(ah, AR_RCCNT); + rx_ext_busy_count = OS_REG_READ(ah, AR_EXTRCCNT); cycle_count = OS_REG_READ(ah, AR_CCCNT); ani_state = ahp->ah_curani; @@ -1081,17 +1088,30 @@ ar9300_ani_get_listen_time(struct ath_hal *ah, HAL_ANISTATS *ani_stats) int32_t ccdelta = cycle_count - ani_state->cycle_count; int32_t rfdelta = rx_frame_count - ani_state->rx_frame_count; int32_t tfdelta = tx_frame_count - ani_state->tx_frame_count; + int32_t rcdelta = rx_busy_count - ani_state->rx_busy_count; + int32_t extrcdelta = rx_ext_busy_count - ani_state->rx_ext_busy_count; listen_time = (ccdelta - rfdelta - tfdelta) / CLOCK_RATE(ah); -#if HAL_ANI_DEBUG +//#if HAL_ANI_DEBUG HALDEBUG(ah, HAL_DEBUG_ANI, - "%s: cyclecount=%d, rfcount=%d, tfcount=%d, listen_time=%d " + "%s: cyclecount=%d, rfcount=%d, tfcount=%d, rcdelta=%d, extrcdelta=%d, listen_time=%d " "CLOCK_RATE=%d\n", - __func__, ccdelta, rfdelta, tfdelta, listen_time, CLOCK_RATE(ah)); -#endif + __func__, ccdelta, rfdelta, tfdelta, rcdelta, extrcdelta, + listen_time, CLOCK_RATE(ah)); +//#endif + /* Populate as appropriate */ + ani_stats->cyclecnt_diff = ccdelta; + ani_stats->rxclr_cnt = rcdelta; + ani_stats->txframecnt_diff = tfdelta; + ani_stats->rxframecnt_diff = rfdelta; + ani_stats->extrxclr_cnt = extrcdelta; + ani_stats->listen_time = listen_time; + ani_stats->valid = AH_TRUE; } ani_state->cycle_count = cycle_count; ani_state->tx_frame_count = tx_frame_count; ani_state->rx_frame_count = rx_frame_count; + ani_state->rx_busy_count = rx_busy_count; + ani_state->rx_ext_busy_count = rx_ext_busy_count; return listen_time; } @@ -1151,7 +1171,13 @@ ar9300_ani_ar_poll(struct ath_hal *ah, const HAL_NODE_STATS *stats, ofdm_phy_err_cnt = OS_REG_READ(ah, AR_PHY_ERR_1); cck_phy_err_cnt = OS_REG_READ(ah, AR_PHY_ERR_2); - + /* Populate HAL_ANISTATS */ + if (ani_stats) { + ani_stats->cckphyerr_cnt = + cck_phy_err_cnt - ani_state->cck_phy_err_count; + ani_stats->ofdmphyerrcnt_diff = + ofdm_phy_err_cnt - ani_state->ofdm_phy_err_count; + } /* NB: only use ast_ani_*errs with AH_PRIVATE_DIAG */ ahp->ah_stats.ast_ani_ofdmerrs += 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 335414e..a446f96 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_attach.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_attach.c @@ -302,6 +302,7 @@ static const struct ath_hal_private ar9300hal = { ar9300_get_desc_info, /* ah_get_desc_info */ ar9300_select_ant_config, /* ah_select_ant_config */ ar9300_ant_ctrl_common_get, /* ah_ant_ctrl_common_get */ + ar9300_ant_swcom_sel, /* ah_ant_swcom_sel */ ar9300_enable_tpc, /* ah_enable_tpc */ AH_NULL, /* ah_olpc_temp_compensation */ #if ATH_SUPPORT_CRDC @@ -319,7 +320,9 @@ static const struct ath_hal_private ar9300hal = { ar9300_set_key_cache_entry, /* ah_set_key_cache_entry */ ar9300_set_key_cache_entry_mac, /* ah_set_key_cache_entry_mac */ ar9300_print_keycache, /* ah_print_key_cache */ - +#if ATH_SUPPORT_KEYPLUMB_WAR + ar9300_check_key_cache_entry, /* ah_check_key_cache_entry */ +#endif /* Power Management Functions */ ar9300_set_power_mode, /* ah_set_power_mode */ ar9300_set_sm_power_mode, /* ah_set_sm_ps_mode */ @@ -342,6 +345,8 @@ static const struct ath_hal_private ar9300hal = { /* Get Channel Noise */ ath_hal_get_chan_noise, /* ah_get_chan_noise */ ar9300_chain_noise_floor, /* ah_get_chain_noise_floor */ + ar9300_get_nf_from_reg, /* ah_get_nf_from_reg */ + ar9300_get_rx_nf_offset, /* ah_get_rx_nf_offset */ /* Beacon Functions */ ar9300_beacon_init, /* ah_beacon_init */ @@ -499,11 +504,11 @@ static const struct ath_hal_private ar9300hal = { #else AH_NULL, AH_NULL, - ar9300TX99TgtChannelPwrUpdate, /* ah_tx99channelpwrupdate */ - ar9300TX99TgtStart, /* ah_tx99start */ - ar9300TX99TgtStop, /* ah_tx99stop */ - ar9300TX99TgtChainmskSetup, /* ah_tx99_chainmsk_setup */ - ar9300TX99SetSingleCarrier, /* ah_tx99_set_single_carrier */ + ar9300_tx99_channel_pwr_update, /* ah_tx99channelpwrupdate */ + ar9300_tx99_start, /* ah_tx99start */ + ar9300_tx99_stop, /* ah_tx99stop */ + ar9300_tx99_chainmsk_setup, /* ah_tx99_chainmsk_setup */ + ar9300_tx99_set_single_carrier, /* ah_tx99_set_single_carrier */ #endif #endif ar9300_chk_rssi_update_tx_pwr, @@ -525,6 +530,8 @@ static const struct ath_hal_private ar9300hal = { ar9300_dump_keycache, /* ah_dump_keycache */ ar9300_is_ani_noise_spur, /* ah_is_ani_noise_spur */ ar9300_set_hw_beacon_proc, /* ah_set_hw_beacon_proc */ + ar9300_set_ctl_pwr, /* ah_set_ctl_pwr */ + ar9300_set_txchainmaskopt, /* ah_set_txchainmaskopt */ }, ar9300_get_channel_edges, /* ah_get_channel_edges */ @@ -618,7 +625,8 @@ ar9300_read_revisions(struct ath_hal *ah) */ struct ath_hal * ar9300_attach(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, - HAL_BUS_HANDLE sh, uint16_t *eepromdata, HAL_STATUS *status) + HAL_BUS_HANDLE sh, uint16_t *eepromdata, HAL_OPS_CONFIG *ah_config, + HAL_STATUS *status) { struct ath_hal_9300 *ahp; struct ath_hal *ah; @@ -628,7 +636,7 @@ ar9300_attach(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_NO_INTERSPERSED_READS; /* NB: memory is returned zero'd */ - ahp = ar9300_new_state(devid, sc, st, sh, eepromdata, status); + ahp = ar9300_new_state(devid, sc, st, sh, eepromdata, ah_config, status); if (ahp == AH_NULL) { return AH_NULL; } @@ -654,12 +662,6 @@ ar9300_attach(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, /* XXX FreeBSD: enable RX mitigation */ ah->ah_config.ath_hal_intr_mitigation_rx = 1; - /* - * XXX what's this do? Check in the qcamain driver code - * as to what it does. - */ - ah->ah_config.ath_hal_ext_atten_margin_cfg = 0; - /* interrupt mitigation */ #ifdef AR5416_INT_MITIGATION if (ah->ah_config.ath_hal_intr_mitigation_rx != 0) { @@ -843,6 +845,18 @@ ar9300_attach(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, /* Enable RIFS */ ahp->ah_rifs_enabled = AH_TRUE; + /* by default, stop RX also in abort txdma, due to + "Unable to stop TxDMA" msg observed */ + ahp->ah_abort_txdma_norx = AH_TRUE; + + /* do not use optional tx chainmask by default */ + ahp->ah_tx_chainmaskopt = 0; + + ahp->ah_skip_rx_iq_cal = AH_FALSE; + ahp->ah_rx_cal_complete = AH_FALSE; + ahp->ah_rx_cal_chan = 0; + ahp->ah_rx_cal_chan_flag = 0; + HALDEBUG(ah, HAL_DEBUG_RESET, "%s: This Mac Chip Rev 0x%02x.%x is \n", __func__, ahpriv->ah_macVersion, @@ -2378,7 +2392,9 @@ ar9300_detach(struct ath_hal *ah) struct ath_hal_9300 * ar9300_new_state(u_int16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, - uint16_t *eepromdata, HAL_STATUS *status) + uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, + HAL_STATUS *status) { static const u_int8_t defbssidmask[IEEE80211_ADDR_LEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; @@ -2430,7 +2446,7 @@ ar9300_new_state(u_int16_t devid, HAL_SOFTC sc, ** Initialize factory defaults in the private space */ // ath_hal_factory_defaults(AH_PRIVATE(ah), hal_conf_parm); - ar9300_config_defaults_freebsd(ah); + ar9300_config_defaults_freebsd(ah, ah_config); /* XXX FreeBSD: cal is always in EEPROM */ #if 0 @@ -2456,6 +2472,7 @@ ar9300_new_state(u_int16_t devid, HAL_SOFTC sc, AH_PRIVATE(ah)->ah_tpScale = HAL_TP_SCALE_MAX; /* no scaling */ ahp->ah_atim_window = 0; /* [0..1000] */ + ahp->ah_diversity_control = ah->ah_config.ath_hal_diversity_control; ahp->ah_antenna_switch_swap = @@ -2934,6 +2951,10 @@ ar9300_fill_capability_info(struct ath_hal *ah) p_cap->halRxUsingLnaMixing = AH_TRUE; } + /* + * AR5416 and later NICs support MYBEACON filtering. + */ + p_cap->halRxDoMyBeacon = AH_TRUE; #if ATH_WOW_OFFLOAD if (AR_SREV_JUPITER_20_OR_LATER(ah) || AR_SREV_APHRODITE(ah)) { @@ -3831,6 +3852,11 @@ ar9300_ant_div_comb_get_config(struct ath_hal *ah, } else { div_comb_conf->antdiv_configgroup = DEFAULT_ANTDIV_CONFIG_GROUP; } + + /* + * XXX TODO: allow the HAL to override the rssithres and fast_div_bias + * values (eg CUS198.) + */ } void @@ -4109,6 +4135,8 @@ ar9300_probe(uint16_t vendorid, uint16_t devid) return "Qualcomm Atheros QCA955x"; case AR9300_DEVID_QCA9565: /* Aphrodite */ return "Qualcomm Atheros AR9565"; + case AR9300_DEVID_AR1111_PCIE: + return "Atheros AR1111"; default: return AH_NULL; } diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_beacon.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_beacon.c index 17943a9..f4da88c 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_beacon.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_beacon.c @@ -34,7 +34,8 @@ extern u_int32_t ar9300_num_tx_pending(struct ath_hal *ah, u_int q); */ void ar9300_beacon_init(struct ath_hal *ah, - u_int32_t next_beacon, u_int32_t beacon_period, HAL_OPMODE opmode) + u_int32_t next_beacon, u_int32_t beacon_period, + u_int32_t beacon_period_fraction, HAL_OPMODE opmode) { u_int32_t beacon_period_usec; @@ -52,6 +53,14 @@ ar9300_beacon_init(struct ath_hal *ah, beacon_period_usec = ONE_EIGHTH_TU_TO_USEC(beacon_period & HAL_BEACON_PERIOD_TU8); + + /* Add the fraction adjustment lost due to unit conversions. */ + beacon_period_usec += beacon_period_fraction; + + HALDEBUG(ah, HAL_DEBUG_BEACON, + "%s: next_beacon=0x%08x, beacon_period=%d, opmode=%d, beacon_period_usec=%d\n", + __func__, next_beacon, beacon_period, opmode, beacon_period_usec); + OS_REG_WRITE(ah, AR_BEACON_PERIOD, beacon_period_usec); OS_REG_WRITE(ah, AR_DMA_BEACON_PERIOD, beacon_period_usec); OS_REG_WRITE(ah, AR_SWBA_PERIOD, beacon_period_usec); diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_eeprom.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_eeprom.c index ba7777e..9028ab7 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_eeprom.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_eeprom.c @@ -1200,6 +1200,44 @@ ar9300_noise_floor_cal_or_power_get(struct ath_hal *ah, int32_t frequency, return nf_use; } +/* + * Return the Rx NF offset for specific channel. + * The values saved in EEPROM/OTP/Flash is converted through the following way: + * ((_p) - NOISE_PWR_DATA_OFFSET) << 2 + * So we need to convert back to the original values. + */ +int ar9300_get_rx_nf_offset(struct ath_hal *ah, struct ieee80211_channel *chan, int8_t *nf_pwr, int8_t *nf_cal) { + HAL_CHANNEL_INTERNAL *ichan = ath_hal_checkchannel(ah, chan); + int8_t rx_nf_pwr, rx_nf_cal; + int i; + //HALASSERT(ichan); + + /* Fill 0 if valid internal channel is not found */ + if (ichan == AH_NULL) { + OS_MEMZERO(nf_pwr, sizeof(nf_pwr[0])*OSPREY_MAX_CHAINS); + OS_MEMZERO(nf_cal, sizeof(nf_cal[0])*OSPREY_MAX_CHAINS); + return -1; + } + + for (i = 0; i < OSPREY_MAX_CHAINS; i++) { + if ((rx_nf_pwr = ar9300_noise_floor_cal_or_power_get(ah, ichan->channel, i, 0)) == 1) { + nf_pwr[i] = 0; + } else { + //printk("%s: raw nf_pwr[%d] = %d\n", __func__, i, rx_nf_pwr); + nf_pwr[i] = NOISE_PWR_DBM_2_INT(rx_nf_pwr); + } + + if ((rx_nf_cal = ar9300_noise_floor_cal_or_power_get(ah, ichan->channel, i, 1)) == 1) { + nf_cal[i] = 0; + } else { + //printk("%s: raw nf_cal[%d] = %d\n", __func__, i, rx_nf_cal); + nf_cal[i] = NOISE_PWR_DBM_2_INT(rx_nf_cal); + } + } + + return 0; +} + int32_t ar9300_rx_gain_index_get(struct ath_hal *ah) { ar9300_eeprom_t *eep = &AH9300(ah)->ah_eeprom; @@ -1530,6 +1568,61 @@ u_int16_t ar9300_ant_ctrl_chain_get(struct ath_hal *ah, int chain, return 0; } +/* + * Select the usage of antenna via the RF switch. + * Default values are loaded from eeprom. + */ +HAL_BOOL ar9300_ant_swcom_sel(struct ath_hal *ah, u_int8_t ops, + u_int32_t *common_tbl1, u_int32_t *common_tbl2) +{ + ar9300_eeprom_t *eep = &AH9300(ah)->ah_eeprom; + struct ath_hal_private *ap = AH_PRIVATE(ah); + const struct ieee80211_channel *curchan = ap->ah_curchan; + enum { + ANT_SELECT_OPS_GET, + ANT_SELECT_OPS_SET, + }; + + if (AR_SREV_JUPITER(ah) || AR_SREV_SCORPION(ah)) + return AH_FALSE; + + if (!curchan) + return AH_FALSE; + +#define AR_SWITCH_TABLE_COM_ALL (0xffff) +#define AR_SWITCH_TABLE_COM_ALL_S (0) +#define AR_SWITCH_TABLE_COM2_ALL (0xffffff) +#define AR_SWITCH_TABLE_COM2_ALL_S (0) + switch (ops) { + case ANT_SELECT_OPS_GET: + *common_tbl1 = OS_REG_READ_FIELD(ah, AR_PHY_SWITCH_COM, + AR_SWITCH_TABLE_COM_ALL); + *common_tbl2 = OS_REG_READ_FIELD(ah, AR_PHY_SWITCH_COM_2, + AR_SWITCH_TABLE_COM2_ALL); + break; + case ANT_SELECT_OPS_SET: + OS_REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM, + AR_SWITCH_TABLE_COM_ALL, *common_tbl1); + OS_REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM_2, + AR_SWITCH_TABLE_COM2_ALL, *common_tbl2); + + /* write back to eeprom */ + if (IEEE80211_IS_CHAN_2GHZ(curchan)) { + eep->modal_header_2g.ant_ctrl_common = *common_tbl1; + eep->modal_header_2g.ant_ctrl_common2 = *common_tbl2; + } else { + eep->modal_header_5g.ant_ctrl_common = *common_tbl1; + eep->modal_header_5g.ant_ctrl_common2 = *common_tbl2; + } + + break; + default: + break; + } + + return AH_TRUE; +} + HAL_BOOL ar9300_ant_ctrl_apply(struct ath_hal *ah, HAL_BOOL is_2ghz) { u_int32_t value; @@ -1606,6 +1699,7 @@ HAL_BOOL ar9300_ant_ctrl_apply(struct ath_hal *ah, HAL_BOOL is_2ghz) if ( AR_SREV_POSEIDON(ah) && (ahp->ah_lna_div_use_bt_ant_enable == TRUE) ) { value &= ~AR_SWITCH_TABLE_COM2_ALL; value |= ah->ah_config.ath_hal_ant_ctrl_comm2g_switch_enable; + HALDEBUG(ah, HAL_DEBUG_RESET, "%s: com2=0x%08x\n", __func__, value) } #endif /* ATH_ANT_DIV_COMB */ OS_REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM_2, AR_SWITCH_TABLE_COM2_ALL, value); @@ -1711,6 +1805,8 @@ HAL_BOOL ar9300_ant_ctrl_apply(struct ath_hal *ah, HAL_BOOL is_2ghz) /* For WB225, need to swith ANT2 from BT to Wifi * This will not affect HB125 LNA diversity feature. */ + HALDEBUG(ah, HAL_DEBUG_RESET, "%s: com2=0x%08x\n", __func__, + ah->ah_config.ath_hal_ant_ctrl_comm2g_switch_enable) OS_REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM_2, AR_SWITCH_TABLE_COM2_ALL, ah->ah_config.ath_hal_ant_ctrl_comm2g_switch_enable); break; @@ -1776,6 +1872,7 @@ ar9300_attenuation_margin_chain_get(struct ath_hal *ah, int chain, return 0; } +#if 0 HAL_BOOL ar9300_attenuation_apply(struct ath_hal *ah, u_int16_t channel) { u_int32_t value; @@ -1814,6 +1911,75 @@ HAL_BOOL ar9300_attenuation_apply(struct ath_hal *ah, u_int16_t channel) } return 0; } +#endif +HAL_BOOL +ar9300_attenuation_apply(struct ath_hal *ah, u_int16_t channel) +{ + int i; + uint32_t value; + uint32_t ext_atten_reg[3] = { + AR_PHY_EXT_ATTEN_CTL_0, + AR_PHY_EXT_ATTEN_CTL_1, + AR_PHY_EXT_ATTEN_CTL_2 + }; + + /* + * If it's an AR9462 and we're receiving on the second + * chain only, set the chain 0 details from chain 1 + * calibration. + * + * This is from ath9k. + */ + if (AR_SREV_JUPITER(ah) && (AH9300(ah)->ah_rx_chainmask == 0x2)) { + value = ar9300_attenuation_chain_get(ah, 1, channel); + OS_REG_RMW_FIELD(ah, ext_atten_reg[0], + AR_PHY_EXT_ATTEN_CTL_XATTEN1_DB, value); + value = ar9300_attenuation_margin_chain_get(ah, 1, channel); + OS_REG_RMW_FIELD(ah, ext_atten_reg[0], + AR_PHY_EXT_ATTEN_CTL_XATTEN1_MARGIN, value); + } + + /* + * Now, loop over the configured transmit chains and + * load in the attenuation/margin settings as appropriate. + */ + for (i = 0; i < 3; i++) { + if ((AH9300(ah)->ah_tx_chainmask & (1 << i)) == 0) + continue; + + value = ar9300_attenuation_chain_get(ah, i, channel); + OS_REG_RMW_FIELD(ah, ext_atten_reg[i], + AR_PHY_EXT_ATTEN_CTL_XATTEN1_DB, + value); + + if (AR_SREV_POSEIDON(ah) && + (ar9300_rx_gain_index_get(ah) == 0) && + ah->ah_config.ath_hal_ext_atten_margin_cfg) { + value = 5; + } else { + value = ar9300_attenuation_margin_chain_get(ah, 0, + channel); + } + + /* + * I'm not sure why it's loading in this setting into + * the chain 0 margin regardless of the current chain. + */ + if (ah->ah_config.ath_hal_min_gainidx) + OS_REG_RMW_FIELD(ah, + AR_PHY_EXT_ATTEN_CTL_0, + AR_PHY_EXT_ATTEN_CTL_XATTEN1_MARGIN, + value); + + OS_REG_RMW_FIELD(ah, + ext_atten_reg[i], + AR_PHY_EXT_ATTEN_CTL_XATTEN1_MARGIN, + value); + } + + return (0); +} + static u_int16_t ar9300_quick_drop_get(struct ath_hal *ah, int chain, u_int16_t channel) @@ -2339,16 +2505,31 @@ ar9300_eeprom_set_power_per_rate_table( HAL_CHANNEL_INTERNAL *ichan = ath_hal_checkchannel(ah, chan); #endif - tx_chainmask = chainmask ? chainmask : ahp->ah_tx_chainmask; + if (chainmask) + tx_chainmask = chainmask; + else + tx_chainmask = ahp->ah_tx_chainmaskopt ? + ahp->ah_tx_chainmaskopt :ahp->ah_tx_chainmask; ar9300_get_channel_centers(ah, chan, ¢ers); +#if 1 if (IEEE80211_IS_CHAN_2GHZ(chan)) { ahp->twice_antenna_gain = p_eep_data->modal_header_2g.antenna_gain; } else { ahp->twice_antenna_gain = p_eep_data->modal_header_5g.antenna_gain; } +#else + if (IEEE80211_IS_CHAN_2GHZ(chan)) { + ahp->twice_antenna_gain = AH_MAX(p_eep_data->modal_header_2g.antenna_gain, + AH_PRIVATE(ah)->ah_antenna_gain_2g); + } else { + ahp->twice_antenna_gain = AH_MAX(p_eep_data->modal_header_5g.antenna_gain, + AH_PRIVATE(ah)->ah_antenna_gain_5g); + } +#endif + /* Save max allowed antenna gain to ease future lookups */ ahp->twice_antenna_reduction = twice_antenna_reduction; @@ -2885,7 +3066,8 @@ ar9300_eeprom_set_transmit_power(struct ath_hal *ah, } max_power_level = target_power_val_t2[i]; /* Adjusting the ah_max_power_level based on chains and antennaGain*/ - switch (ar9300_get_ntxchains(ahp->ah_tx_chainmask)) + switch (ar9300_get_ntxchains(((ahp->ah_tx_chainmaskopt > 0) ? + ahp->ah_tx_chainmaskopt : ahp->ah_tx_chainmask))) { case 1: break; diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.c index 251957e..5bdd74f 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.c @@ -36,6 +36,9 @@ static HAL_BOOL ar9300ClrMulticastFilterIndex(struct ath_hal *ah, uint32_t ix); static HAL_BOOL ar9300SetMulticastFilterIndex(struct ath_hal *ah, uint32_t ix); +static void ar9300_beacon_set_beacon_timers(struct ath_hal *ah, + const HAL_BEACON_TIMERS *bt); + static void ar9300SetChainMasks(struct ath_hal *ah, uint32_t tx_chainmask, uint32_t rx_chainmask) @@ -60,14 +63,44 @@ ar9300_freebsd_set_tx_power_limit(struct ath_hal *ah, uint32_t limit) return (ar9300_set_tx_power_limit(ah, limit, 0, 0)); } +static uint64_t +ar9300_get_next_tbtt(struct ath_hal *ah) +{ + return (OS_REG_READ(ah, AR_NEXT_TBTT_TIMER)); +} + + +/* + * TODO: implement the antenna diversity control for AR9485 and + * other LNA mixing based NICs. + * + * For now we'll just go with the HAL default and make these no-ops. + */ +static HAL_ANT_SETTING +ar9300_freebsd_get_antenna_switch(struct ath_hal *ah) +{ + + return (HAL_ANT_VARIABLE); +} + +static HAL_BOOL +ar9300_freebsd_set_antenna_switch(struct ath_hal *ah, HAL_ANT_SETTING setting) +{ + + return (AH_TRUE); +} + +static u_int +ar9300_freebsd_get_cts_timeout(struct ath_hal *ah) +{ + u_int clks = MS(OS_REG_READ(ah, AR_TIME_OUT), AR_TIME_OUT_CTS); + return ath_hal_mac_usec(ah, clks); /* convert from system clocks */ +} void ar9300_attach_freebsd_ops(struct ath_hal *ah) { - /* stub everything first */ - ar9300_set_stub_functions(ah); - /* Global functions */ ah->ah_detach = ar9300_detach; ah->ah_getRateTable = ar9300_get_rate_table; @@ -154,8 +187,8 @@ ar9300_attach_freebsd_ops(struct ath_hal *ah) ah->ah_getRfGain = ar9300_get_rfgain; ah->ah_getDefAntenna = ar9300_get_def_antenna; ah->ah_setDefAntenna = ar9300_set_def_antenna; - // ah->ah_getAntennaSwitch = ar9300_get_antenna_switch; - // ah->ah_setAntennaSwitch = ar9300_set_antenna_switch; + ah->ah_getAntennaSwitch = ar9300_freebsd_get_antenna_switch; + ah->ah_setAntennaSwitch = ar9300_freebsd_set_antenna_switch; // ah->ah_setSifsTime = ar9300_set_sifs_time; // ah->ah_getSifsTime = ar9300_get_sifs_time; ah->ah_setSlotTime = ar9300_set_slot_time; @@ -164,6 +197,7 @@ ar9300_attach_freebsd_ops(struct ath_hal *ah) ah->ah_setAckTimeout = ar9300_set_ack_timeout; // XXX ack/ctsrate // XXX CTS timeout + ah->ah_getCTSTimeout = ar9300_freebsd_get_cts_timeout; // XXX decompmask // coverageclass ah->ah_setQuiet = ar9300_set_quiet; @@ -191,10 +225,10 @@ ar9300_attach_freebsd_ops(struct ath_hal *ah) /* Beacon functions */ /* ah_setBeaconTimers */ ah->ah_beaconInit = ar9300_freebsd_beacon_init; - /* ah_setBeaconTimers */ + ah->ah_setBeaconTimers = ar9300_beacon_set_beacon_timers; ah->ah_setStationBeaconTimers = ar9300_set_sta_beacon_timers; /* ah_resetStationBeaconTimers */ - /* ah_getNextTBTT */ + ah->ah_getNextTBTT = ar9300_get_next_tbtt; /* Interrupt functions */ ah->ah_isInterruptPending = ar9300_is_interrupt_pending; @@ -246,12 +280,21 @@ ar9300_attach_freebsd_ops(struct ath_hal *ah) ah->ah_btCoexDisable = ar9300_bt_coex_disable; ah->ah_btCoexEnable = ar9300_bt_coex_enable; + /* MCI bluetooth functions */ + if (AR_SREV_JUPITER(ah) || AR_SREV_APHRODITE(ah)) { + ah->ah_btCoexSetWeights = ar9300_mci_bt_coex_set_weights; + ah->ah_btCoexDisable = ar9300_mci_bt_coex_disable; + ah->ah_btCoexEnable = ar9300_mci_bt_coex_enable; + } + ah->ah_btMciSetup = ar9300_mci_setup; + ah->ah_btMciSendMessage = ar9300_mci_send_message; + ah->ah_btMciGetInterrupt = ar9300_mci_get_interrupt; + ah->ah_btMciGetState = ar9300_mci_state; + ah->ah_btMciDetach = ar9300_mci_detach; + /* LNA diversity functions */ ah->ah_divLnaConfGet = ar9300_ant_div_comb_get_config; ah->ah_divLnaConfSet = ar9300_ant_div_comb_set_config; - - /* Setup HAL configuration defaults */ - ah->ah_config.ath_hal_ant_ctrl_comm2g_switch_enable = 0x000bbb88; } HAL_BOOL @@ -323,11 +366,26 @@ ar9300_ani_poll_freebsd(struct ath_hal *ah, HAL_NODE_STATS stats; HAL_ANISTATS anistats; + HAL_SURVEY_SAMPLE survey; OS_MEMZERO(&stats, sizeof(stats)); OS_MEMZERO(&anistats, sizeof(anistats)); + OS_MEMZERO(&survey, sizeof(survey)); ar9300_ani_ar_poll(ah, &stats, chan, &anistats); + + /* + * If ANI stats are valid, use them to update the + * channel survey. + */ + if (anistats.valid) { + survey.cycle_count = anistats.cyclecnt_diff; + survey.chan_busy = anistats.rxclr_cnt; + survey.ext_chan_busy = anistats.extrxclr_cnt; + survey.tx_busy = anistats.txframecnt_diff; + survey.rx_busy = anistats.rxframecnt_diff; + ath_hal_survey_add_sample(ah, &survey); + } } /* @@ -335,9 +393,11 @@ ar9300_ani_poll_freebsd(struct ath_hal *ah, * wants. */ void -ar9300_config_defaults_freebsd(struct ath_hal *ah) +ar9300_config_defaults_freebsd(struct ath_hal *ah, HAL_OPS_CONFIG *ah_config) { + /* Until FreeBSD's HAL does this by default - just copy */ + OS_MEMCPY(&ah->ah_config, ah_config, sizeof(HAL_OPS_CONFIG)); ah->ah_config.ath_hal_enable_ani = AH_TRUE; } @@ -465,11 +525,13 @@ ar9300_freebsd_setup_x_tx_desc(struct ath_hal *ah, struct ath_desc *ds, u_int txRate3, u_int txTries3) { +#if 0 ath_hal_printf(ah, "%s: called, 0x%x/%d, 0x%x/%d, 0x%x/%d\n", __func__, txRate1, txTries1, txRate2, txTries2, txRate3, txTries3); +#endif /* XXX should only be called during probe */ return (AH_TRUE); @@ -590,8 +652,8 @@ ar9300_freebsd_beacon_init(struct ath_hal *ah, uint32_t next_beacon, uint32_t beacon_period) { - ar9300_beacon_init(ah, AH_PRIVATE(ah)->ah_opmode, - next_beacon, beacon_period); + ar9300_beacon_init(ah, next_beacon, beacon_period, 0, + AH_PRIVATE(ah)->ah_opmode); } HAL_BOOL @@ -653,6 +715,55 @@ ar9300SetMulticastFilterIndex(struct ath_hal *ah, uint32_t ix) return (AH_TRUE); } +#define TU_TO_USEC(_tu) ((_tu) << 10) +#define ONE_EIGHTH_TU_TO_USEC(_tu8) ((_tu8) << 7) + +/* + * Initializes all of the hardware registers used to + * send beacons. Note that for station operation the + * driver calls ar9300_set_sta_beacon_timers instead. + */ +static void +ar9300_beacon_set_beacon_timers(struct ath_hal *ah, + const HAL_BEACON_TIMERS *bt) +{ + uint32_t bperiod; + +#if 0 + HALASSERT(opmode == HAL_M_IBSS || opmode == HAL_M_HOSTAP); + if (opmode == HAL_M_IBSS) { + OS_REG_SET_BIT(ah, AR_TXCFG, AR_TXCFG_ADHOC_BEACON_ATIM_TX_POLICY); + } +#endif + + /* XXX TODO: should migrate the HAL code to always use ONE_EIGHTH_TU */ + OS_REG_WRITE(ah, AR_NEXT_TBTT_TIMER, TU_TO_USEC(bt->bt_nexttbtt)); + OS_REG_WRITE(ah, AR_NEXT_DMA_BEACON_ALERT, ONE_EIGHTH_TU_TO_USEC(bt->bt_nextdba)); + OS_REG_WRITE(ah, AR_NEXT_SWBA, ONE_EIGHTH_TU_TO_USEC(bt->bt_nextswba)); + OS_REG_WRITE(ah, AR_NEXT_NDP_TIMER, TU_TO_USEC(bt->bt_nextatim)); + + bperiod = TU_TO_USEC(bt->bt_intval & HAL_BEACON_PERIOD); + /* XXX TODO! */ +// ahp->ah_beaconInterval = bt->bt_intval & HAL_BEACON_PERIOD; + OS_REG_WRITE(ah, AR_BEACON_PERIOD, bperiod); + OS_REG_WRITE(ah, AR_DMA_BEACON_PERIOD, bperiod); + OS_REG_WRITE(ah, AR_SWBA_PERIOD, bperiod); + OS_REG_WRITE(ah, AR_NDP_PERIOD, bperiod); + + /* + * Reset TSF if required. + */ + if (bt->bt_intval & HAL_BEACON_RESET_TSF) + ar9300_reset_tsf(ah); + + /* enable timers */ + /* NB: flags == 0 handled specially for backwards compatibility */ + OS_REG_SET_BIT(ah, AR_TIMER_MODE, + bt->bt_flags != 0 ? bt->bt_flags : + AR_TBTT_TIMER_EN | AR_DBA_TIMER_EN | AR_SWBA_TIMER_EN); +} + + /* * RF attach stubs */ diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.h b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.h index c07c32f..524c3f3 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.h +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd.h @@ -11,7 +11,8 @@ extern HAL_STATUS ar9300_eeprom_get_freebsd(struct ath_hal *, int param, extern HAL_BOOL ar9300_stop_tx_dma_freebsd(struct ath_hal *ah, u_int q); extern void ar9300_ani_poll_freebsd(struct ath_hal *ah, const struct ieee80211_channel *chan); -extern void ar9300_config_defaults_freebsd(struct ath_hal *ah); +extern void ar9300_config_defaults_freebsd(struct ath_hal *ah, + HAL_OPS_CONFIG *ah_config); extern HAL_BOOL ar9300_stop_dma_receive_freebsd(struct ath_hal *ah); extern HAL_BOOL ar9300_get_pending_interrupts_freebsd(struct ath_hal *ah, HAL_INT *masked); diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd_inc.h b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd_inc.h index a159c2c..1af621b 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd_inc.h +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_freebsd_inc.h @@ -35,6 +35,7 @@ #define ATH_SUPPORT_PAPRD 1 #define ATH_SUPPORT_TxBF 0 #define AH_PRIVATE_DIAG 1 +#define ATH_SUPPORT_KEYPLUMB_WAR 0 /* XXX need to reverify these; they came in with qcamain */ #define ATH_SUPPORT_FAST_CC 0 @@ -57,7 +58,9 @@ #ifdef AH_SUPPORT_AR9340 #define AH_SUPPORT_WASP 1 #endif /* AH_SUPPORT_AR9340 */ -//#define AH_SUPPORT_SCORPION 1 +#ifdef AH_SUPPORT_QCA9550 +#define AH_SUPPORT_SCORPION 1 +#endif /* AH_SUPPORT_QCA9550 */ #define FIX_NOISE_FLOOR 1 /* XXX this needs to be removed! No atomics in the HAL! */ diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_gpio.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_gpio.c index 5660c1f..1dcdafe 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_gpio.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_gpio.c @@ -162,7 +162,6 @@ ar9300_gpio_cfg_output( HALASSERT(gpio < AH_PRIVATE(ah)->ah_caps.halNumGpioPins); if ((gpio == AR9382_GPIO_PIN_8_RESERVED) || - (gpio == AR9382_GPIO_PIN_11_RESERVED) || (gpio == AR9382_GPIO_9_INPUT_ONLY)) { return AH_FALSE; @@ -348,7 +347,6 @@ ar9300_gpio_cfg_input(struct ath_hal *ah, u_int32_t gpio) HALASSERT(gpio < AH_PRIVATE(ah)->ah_caps.halNumGpioPins); if ((gpio == AR9382_GPIO_PIN_8_RESERVED) || - (gpio == AR9382_GPIO_PIN_11_RESERVED) || (gpio > AR9382_MAX_GPIO_INPUT_PIN_NUM)) { return AH_FALSE; @@ -378,7 +376,6 @@ ar9300_gpio_set(struct ath_hal *ah, u_int32_t gpio, u_int32_t val) { HALASSERT(gpio < AH_PRIVATE(ah)->ah_caps.halNumGpioPins); if ((gpio == AR9382_GPIO_PIN_8_RESERVED) || - (gpio == AR9382_GPIO_PIN_11_RESERVED) || (gpio == AR9382_GPIO_9_INPUT_ONLY)) { return AH_FALSE; @@ -397,8 +394,7 @@ ar9300_gpio_get(struct ath_hal *ah, u_int32_t gpio) { u_int32_t gpio_in; HALASSERT(gpio < AH_PRIVATE(ah)->ah_caps.halNumGpioPins); - if ((gpio == AR9382_GPIO_PIN_8_RESERVED) || - (gpio == AR9382_GPIO_PIN_11_RESERVED)) + if (gpio == AR9382_GPIO_PIN_8_RESERVED) { return 0xffffffff; } @@ -453,7 +449,6 @@ ar9300_gpio_set_intr(struct ath_hal *ah, u_int gpio, u_int32_t ilevel) HALASSERT(gpio < AH_PRIVATE(ah)->ah_caps.halNumGpioPins); if ((gpio == AR9382_GPIO_PIN_8_RESERVED) || - (gpio == AR9382_GPIO_PIN_11_RESERVED) || (gpio > AR9382_MAX_GPIO_INPUT_PIN_NUM)) { return; @@ -549,8 +544,7 @@ ar9300_gpio_get_mask(struct ath_hal *ah) if (AH_PRIVATE(ah)->ah_devid == AR9300_DEVID_AR9380_PCIE) { mask = (1 << AR9382_MAX_GPIO_PIN_NUM) - 1; - mask &= ~(1 << AR9382_GPIO_PIN_8_RESERVED | - 1 << AR9382_GPIO_PIN_11_RESERVED); + mask &= ~(1 << AR9382_GPIO_PIN_8_RESERVED); } return mask; } @@ -562,8 +556,7 @@ ar9300_gpio_set_mask(struct ath_hal *ah, u_int32_t mask, u_int32_t pol_map) if (AH_PRIVATE(ah)->ah_devid == AR9300_DEVID_AR9380_PCIE) { invalid = ~((1 << AR9382_MAX_GPIO_PIN_NUM) - 1); - invalid |= 1 << AR9382_GPIO_PIN_8_RESERVED | - 1 << AR9382_GPIO_PIN_11_RESERVED; + invalid |= 1 << AR9382_GPIO_PIN_8_RESERVED; } if (mask & invalid) { ath_hal_printf(ah, "%s: invalid GPIO mask 0x%x\n", __func__, mask); diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_interrupts.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_interrupts.c index 51ee3cd..acc14b3 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_interrupts.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_interrupts.c @@ -142,6 +142,21 @@ ar9300_get_pending_interrupts( sync_en_def = AR9340_INTR_SYNC_DEFAULT; } + /* Store away the async and sync cause registers */ + /* XXX Do this before the filtering done below */ +#ifdef AH_INTERRUPT_DEBUGGING + ah->ah_intrstate[0] = OS_REG_READ(ah, AR_ISR); + ah->ah_intrstate[1] = OS_REG_READ(ah, AR_ISR_S0); + ah->ah_intrstate[2] = OS_REG_READ(ah, AR_ISR_S1); + ah->ah_intrstate[3] = OS_REG_READ(ah, AR_ISR_S2); + ah->ah_intrstate[4] = OS_REG_READ(ah, AR_ISR_S3); + ah->ah_intrstate[5] = OS_REG_READ(ah, AR_ISR_S4); + ah->ah_intrstate[6] = OS_REG_READ(ah, AR_ISR_S5); + + /* XXX double reading? */ + ah->ah_syncstate = OS_REG_READ(ah, AR_HOSTIF_REG(ah, AR_INTR_SYNC_CAUSE)); +#endif + sync_cause = OS_REG_READ(ah, AR_HOSTIF_REG(ah, AR_INTR_SYNC_CAUSE)) & (sync_en_def | AR_INTR_SYNC_MASK_GPIO); diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_keycache.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_keycache.c index 8b9a143..0f4fab9 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_keycache.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_keycache.c @@ -436,3 +436,156 @@ void ar9300_dump_keycache(struct ath_hal *ah, int n, u_int32_t *entry) } #undef AH_KEY_REG_SIZE } + +#if ATH_SUPPORT_KEYPLUMB_WAR +/* + * Check the contents of the specified key cache entry + * and any associated MIC entry. + */ + HAL_BOOL +ar9300_check_key_cache_entry(struct ath_hal *ah, u_int16_t entry, + const HAL_KEYVAL *k, int xorKey) +{ + const HAL_CAPABILITIES *pCap = &AH_PRIVATE(ah)->ah_caps; + u_int32_t key0, key1, key2, key3, key4; + u_int32_t keyType; + u_int32_t xorMask = xorKey ? + (KEY_XOR << 24 | KEY_XOR << 16 | KEY_XOR << 8 | KEY_XOR) : 0; + struct ath_hal_9300 *ahp = AH9300(ah); + + + if (entry >= pCap->hal_key_cache_size) { + HALDEBUG(ah, HAL_DEBUG_KEYCACHE, + "%s: entry %u out of range\n", __func__, entry); + return AH_FALSE; + } + switch (k->kv_type) { + case HAL_CIPHER_AES_OCB: + keyType = AR_KEYTABLE_TYPE_AES; + break; + case HAL_CIPHER_AES_CCM: + if (!pCap->hal_cipher_aes_ccm_support) { + HALDEBUG(ah, HAL_DEBUG_KEYCACHE, "%s: AES-CCM not supported by " + "mac rev 0x%x\n", + __func__, AH_PRIVATE(ah)->ah_macRev); + return AH_FALSE; + } + keyType = AR_KEYTABLE_TYPE_CCM; + break; + case HAL_CIPHER_TKIP: + keyType = AR_KEYTABLE_TYPE_TKIP; + if (IS_MIC_ENABLED(ah) && entry + 64 >= pCap->hal_key_cache_size) { + HALDEBUG(ah, HAL_DEBUG_KEYCACHE, + "%s: entry %u inappropriate for TKIP\n", + __func__, entry); + return AH_FALSE; + } + break; + case HAL_CIPHER_WEP: + if (k->kv_len < 40 / NBBY) { + HALDEBUG(ah, HAL_DEBUG_KEYCACHE, "%s: WEP key length %u too small\n", + __func__, k->kv_len); + return AH_FALSE; + } + if (k->kv_len <= 40 / NBBY) { + keyType = AR_KEYTABLE_TYPE_40; + } else if (k->kv_len <= 104 / NBBY) { + keyType = AR_KEYTABLE_TYPE_104; + } else { + keyType = AR_KEYTABLE_TYPE_128; + } + break; + case HAL_CIPHER_CLR: + keyType = AR_KEYTABLE_TYPE_CLR; + return AH_TRUE; + default: + HALDEBUG(ah, HAL_DEBUG_KEYCACHE, "%s: cipher %u not supported\n", + __func__, k->kv_type); + return AH_TRUE; + } + + key0 = LE_READ_4(k->kv_val + 0) ^ xorMask; + key1 = (LE_READ_2(k->kv_val + 4) ^ xorMask) & 0xffff; + key2 = LE_READ_4(k->kv_val + 6) ^ xorMask; + key3 = (LE_READ_2(k->kv_val + 10) ^ xorMask) & 0xffff; + key4 = LE_READ_4(k->kv_val + 12) ^ xorMask; + if (k->kv_len <= 104 / NBBY) { + key4 &= 0xff; + } + + /* + * Note: key cache hardware requires that each double-word + * pair be written in even/odd order (since the destination is + * a 64-bit register). Don't reorder these writes w/o + * considering this! + */ + if (keyType == AR_KEYTABLE_TYPE_TKIP && IS_MIC_ENABLED(ah)) { + u_int16_t micentry = entry + 64; /* MIC goes at slot+64 */ + + + /* + * Invalidate the encrypt/decrypt key until the MIC + * key is installed so pending rx frames will fail + * with decrypt errors rather than a MIC error. + */ + if ((OS_REG_READ(ah, AR_KEYTABLE_KEY0(entry)) == key0) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY1(entry)) == key1) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY2(entry)) == key2) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY3(entry)) == key3) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY4(entry)) == key4) && + ((OS_REG_READ(ah, AR_KEYTABLE_TYPE(entry)) & AR_KEY_TYPE) == (keyType & AR_KEY_TYPE))) + { + + /* + * since the AR_MISC_MODE register was written with the contents of + * ah_miscMode (if any) in ar9300Attach, just check ah_miscMode and + * save a pci read per key set. + */ + if (ahp->ah_misc_mode & AR_PCU_MIC_NEW_LOC_ENA) { + u_int32_t mic0,mic1,mic2,mic3,mic4; + /* + * both RX and TX mic values can be combined into + * one cache slot entry. + * 8*N + 800 31:0 RX Michael key 0 + * 8*N + 804 15:0 TX Michael key 0 [31:16] + * 8*N + 808 31:0 RX Michael key 1 + * 8*N + 80C 15:0 TX Michael key 0 [15:0] + * 8*N + 810 31:0 TX Michael key 1 + * 8*N + 814 15:0 reserved + * 8*N + 818 31:0 reserved + * 8*N + 81C 14:0 reserved + * 15 key valid == 0 + */ + /* RX mic */ + mic0 = LE_READ_4(k->kv_mic + 0); + mic2 = LE_READ_4(k->kv_mic + 4); + /* TX mic */ + mic1 = LE_READ_2(k->kv_txmic + 2) & 0xffff; + mic3 = LE_READ_2(k->kv_txmic + 0) & 0xffff; + mic4 = LE_READ_4(k->kv_txmic + 4); + if ((OS_REG_READ(ah, AR_KEYTABLE_KEY0(micentry)) == mic0) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY1(micentry)) == mic1) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY2(micentry)) == mic2) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY3(micentry)) == mic3) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY4(micentry)) == mic4) && + ((OS_REG_READ(ah, AR_KEYTABLE_TYPE(micentry)) & AR_KEY_TYPE) == (AR_KEYTABLE_TYPE_CLR & AR_KEY_TYPE))) { + return AH_TRUE; + } + + } else { + return AH_TRUE; + } + } + } else { + if ((OS_REG_READ(ah, AR_KEYTABLE_KEY0(entry)) == key0) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY1(entry)) == key1) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY2(entry)) == key2) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY3(entry)) == key3) && + (OS_REG_READ(ah, AR_KEYTABLE_KEY4(entry)) == key4) && + ((OS_REG_READ(ah, AR_KEYTABLE_TYPE(entry)) & AR_KEY_TYPE) == (keyType & AR_KEY_TYPE))) { + return AH_TRUE; + } + } + return AH_FALSE; +} +#endif diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_misc.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_misc.c index a0722b7..e9caa43 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_misc.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_misc.c @@ -683,6 +683,7 @@ ar9300_get_capability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, { struct ath_hal_9300 *ahp = AH9300(ah); const HAL_CAPABILITIES *p_cap = &AH_PRIVATE(ah)->ah_caps; + struct ar9300_ani_state *ani; switch (type) { case HAL_CAP_CIPHER: /* cipher handled in hardware */ @@ -911,6 +912,34 @@ ar9300_get_capability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, return HAL_ENOTSUPP; } #endif + + /* FreeBSD ANI */ + case HAL_CAP_INTMIT: /* interference mitigation */ + switch (capability) { + case HAL_CAP_INTMIT_PRESENT: /* hardware capability */ + return HAL_OK; + case HAL_CAP_INTMIT_ENABLE: + return (ahp->ah_proc_phy_err & HAL_PROCESS_ANI) ? + HAL_OK : HAL_ENXIO; + case HAL_CAP_INTMIT_NOISE_IMMUNITY_LEVEL: + case HAL_CAP_INTMIT_OFDM_WEAK_SIGNAL_LEVEL: +// case HAL_CAP_INTMIT_CCK_WEAK_SIGNAL_THR: + case HAL_CAP_INTMIT_FIRSTEP_LEVEL: + case HAL_CAP_INTMIT_SPUR_IMMUNITY_LEVEL: + ani = ar9300_ani_get_current_state(ah); + if (ani == AH_NULL) + return HAL_ENXIO; + switch (capability) { + /* XXX AR9300 HAL has OFDM/CCK noise immunity level params? */ + case 2: *result = ani->ofdm_noise_immunity_level; break; + case 3: *result = !ani->ofdm_weak_sig_detect_off; break; + // case 4: *result = ani->cck_weak_sig_threshold; break; + case 5: *result = ani->firstep_level; break; + case 6: *result = ani->spur_immunity_level; break; + } + return HAL_OK; + } + return HAL_EINVAL; default: return ath_hal_getcapability(ah, type, capability, result); } @@ -986,6 +1015,27 @@ ar9300_set_capability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, return AH_TRUE; } return AH_FALSE; + + /* FreeBSD interrupt mitigation / ANI */ + case HAL_CAP_INTMIT: { /* interference mitigation */ + /* This maps the public ANI commands to the internal ANI commands */ + /* Private: HAL_ANI_CMD; Public: HAL_CAP_INTMIT_CMD */ + static const HAL_ANI_CMD cmds[] = { + HAL_ANI_PRESENT, + HAL_ANI_MODE, + HAL_ANI_NOISE_IMMUNITY_LEVEL, + HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION, + HAL_ANI_CCK_WEAK_SIGNAL_THR, + HAL_ANI_FIRSTEP_LEVEL, + HAL_ANI_SPUR_IMMUNITY_LEVEL, + }; +#define N(a) (sizeof(a) / sizeof(a[0])) + return capability < N(cmds) ? + ar9300_ani_control(ah, cmds[capability], setting) : + AH_FALSE; +#undef N + } + case HAL_CAP_RXBUFSIZE: /* set MAC receive buffer size */ ahp->rx_buf_size = setting & AR_DATABUF_MASK; OS_REG_WRITE(ah, AR_DATABUF, ahp->rx_buf_size); @@ -1129,6 +1179,7 @@ ar9300_get_diag_state(struct ath_hal *ah, int request, void **result, u_int32_t *resultsize) { struct ath_hal_9300 *ahp = AH9300(ah); + struct ar9300_ani_state *ani; (void) ahp; if (ath_hal_getdiagstate(ah, request, args, argsize, result, resultsize)) { @@ -1169,14 +1220,35 @@ ar9300_get_diag_state(struct ath_hal *ah, int request, return AH_TRUE; #endif case HAL_DIAG_ANI_CURRENT: + + ani = ar9300_ani_get_current_state(ah); + if (ani == AH_NULL) + return AH_FALSE; + /* Convert ar9300 HAL to FreeBSD HAL ANI state */ + /* XXX TODO: add all of these to the HAL ANI state structure */ + bzero(&ahp->ext_ani_state, sizeof(ahp->ext_ani_state)); + /* XXX should this be OFDM or CCK noise immunity level? */ + ahp->ext_ani_state.noiseImmunityLevel = ani->ofdm_noise_immunity_level; + ahp->ext_ani_state.spurImmunityLevel = ani->spur_immunity_level; + ahp->ext_ani_state.firstepLevel = ani->firstep_level; + ahp->ext_ani_state.ofdmWeakSigDetectOff = ani->ofdm_weak_sig_detect_off; + /* mrc_cck_off */ + /* cck_noise_immunity_level */ + + ahp->ext_ani_state.listenTime = ani->listen_time; + + *result = &ahp->ext_ani_state; + *resultsize = sizeof(ahp->ext_ani_state); +#if 0 *result = ar9300_ani_get_current_state(ah); *resultsize = (*result == AH_NULL) ? 0 : sizeof(struct ar9300_ani_state); +#endif return AH_TRUE; case HAL_DIAG_ANI_STATS: *result = ar9300_ani_get_current_stats(ah); *resultsize = (*result == AH_NULL) ? - 0 : sizeof(struct ar9300_stats); + 0 : sizeof(HAL_ANI_STATS); return AH_TRUE; case HAL_DIAG_ANI_CMD: if (argsize != 2*sizeof(u_int32_t)) { @@ -1697,10 +1769,10 @@ ar9300_get_bb_panic_info(struct ath_hal *ah, struct hal_bb_panic_info *bb_panic) /* Suppress BB Status mesg following signature */ switch (bb_panic->status) { - case 0x04000539: - case 0x04008009: - case 0x04000b09: - case 0x1300000a: + case 0x04000539: + case 0x04008009: + case 0x04000b09: + case 0x1300000a: return -1; } @@ -3718,8 +3790,6 @@ ar9300_tx99_start(struct ath_hal *ah, u_int8_t *data) /* Disable AGC to A2 */ OS_REG_WRITE(ah, AR_PHY_TEST, (OS_REG_READ(ah, AR_PHY_TEST) | PHY_AGC_CLR)); - OS_REG_WRITE(ah, 0x9864, OS_REG_READ(ah, 0x9864) | 0x7f000); - OS_REG_WRITE(ah, 0x9924, OS_REG_READ(ah, 0x9924) | 0x7f00fe); OS_REG_WRITE(ah, AR_DIAG_SW, OS_REG_READ(ah, AR_DIAG_SW) &~ AR_DIAG_RX_DIS); OS_REG_WRITE(ah, AR_CR, AR_CR_RXD); /* set receive disable */ @@ -3763,3 +3833,47 @@ ar9300SetDfs3StreamFix(struct ath_hal *ah, u_int32_t val) { return AH_FALSE; } + +HAL_BOOL +ar9300_set_ctl_pwr(struct ath_hal *ah, u_int8_t *ctl_array) +{ + struct ath_hal_9300 *ahp = AH9300(ah); + ar9300_eeprom_t *p_eep_data = &ahp->ah_eeprom; + u_int8_t *ctl_index; + u_int32_t offset = 0; + + if (!ctl_array) + return AH_FALSE; + + /* copy 2G ctl freqbin and power data */ + ctl_index = p_eep_data->ctl_index_2g; + OS_MEMCPY(ctl_index + OSPREY_NUM_CTLS_2G, ctl_array, + OSPREY_NUM_CTLS_2G * OSPREY_NUM_BAND_EDGES_2G + /* ctl_freqbin_2G */ + OSPREY_NUM_CTLS_2G * sizeof(OSP_CAL_CTL_DATA_2G)); /* ctl_power_data_2g */ + offset = (OSPREY_NUM_CTLS_2G * OSPREY_NUM_BAND_EDGES_2G) + + ( OSPREY_NUM_CTLS_2G * sizeof(OSP_CAL_CTL_DATA_2G)); + + + /* copy 2G ctl freqbin and power data */ + ctl_index = p_eep_data->ctl_index_5g; + OS_MEMCPY(ctl_index + OSPREY_NUM_CTLS_5G, ctl_array + offset, + OSPREY_NUM_CTLS_5G * OSPREY_NUM_BAND_EDGES_5G + /* ctl_freqbin_5G */ + OSPREY_NUM_CTLS_5G * sizeof(OSP_CAL_CTL_DATA_5G)); /* ctl_power_data_5g */ + + return AH_FALSE; +} + +void +ar9300_set_txchainmaskopt(struct ath_hal *ah, u_int8_t mask) +{ + struct ath_hal_9300 *ahp = AH9300(ah); + + /* optional txchainmask should be subset of primary txchainmask */ + if ((mask & ahp->ah_tx_chainmask) != mask) { + ahp->ah_tx_chainmaskopt = 0; + ath_hal_printf(ah, "Error: ah_tx_chainmask=%d, mask=%d\n", ahp->ah_tx_chainmask, mask); + return; + } + + ahp->ah_tx_chainmaskopt = mask; +} diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_osprey22.ini b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_osprey22.ini index 9814dab..fffaf7a 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_osprey22.ini +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_osprey22.ini @@ -881,7 +881,7 @@ static const u_int32_t ar9300_osprey_2p2_mac_core[][2] = { { 0x00008258 , 0x00000000 }, { 0x0000825c , 0x40000000 }, { 0x00008260 , 0x00080922 }, - { 0x00008264 , 0x9bc00010 }, + { 0x00008264 , 0x9d400010 }, { 0x00008268 , 0xffffffff }, { 0x0000826c , 0x0000ffff }, { 0x00008270 , 0x00000000 }, @@ -1171,7 +1171,7 @@ static const u_int32_t ar9300_osprey_2p2_mac_postamble[][5] = { { 0x000010b0 , 0x00000e60 , 0x00001cc0 , 0x00007c70 , 0x00003e38 }, { 0x00008014 , 0x03e803e8 , 0x07d007d0 , 0x10801600 , 0x08400b00 }, { 0x0000801c , 0x128d8027 , 0x128d804f , 0x12e00057 , 0x12e0002b }, - { 0x00008120 , 0x08f04800 , 0x08f04800 , 0x08f04810 , 0x08f04810 }, + { 0x00008120 , 0x18f04800 , 0x18f04800 , 0x18f04810 , 0x18f04810 }, { 0x000081d0 , 0x00003210 , 0x00003210 , 0x0000320a , 0x0000320a }, { 0x00008318 , 0x00003e80 , 0x00007d00 , 0x00006880 , 0x00003440 }, }; diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_power.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_power.c index 44bebe4..2a8f7f8 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_power.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_power.c @@ -469,7 +469,7 @@ u_int32_t ar9300_wow_offload_handshake(struct ath_hal *ah, u_int32_t pattern_ena OS_REG_SET_BIT(ah, AR_MBOX_CTRL_STATUS, AR_MBOX_WOW_REQ); OS_REG_SET_BIT(ah, AR_MBOX_CTRL_STATUS, AR_MBOX_INT_EMB_CPU); - if (!ath_hal_wait(ah, AR_MBOX_CTRL_STATUS, AR_MBOX_WOW_CONF, AR_MBOX_WOW_CONF, bt_handshake_timeout_us)) { + if (!ath_hal_waitfor(ah, AR_MBOX_CTRL_STATUS, AR_MBOX_WOW_CONF, AR_MBOX_WOW_CONF, bt_handshake_timeout_us)) { HALDEBUG(ah, HAL_DEBUG_UNMASKABLE, "%s: WoW offload handshake failed", __func__); return 0; } @@ -666,15 +666,19 @@ ar9300_set_power_mode(struct ath_hal *ah, HAL_POWER_MODE mode, int set_chip) HALDEBUG(ah, HAL_DEBUG_POWER_MGMT, "%s: %s -> %s (%s)\n", __func__, modes[ar9300_get_power_mode(ah)], modes[mode], set_chip ? "set chip " : ""); + OS_MARK(ah, AH_MARK_CHIP_POWER, mode); switch (mode) { case HAL_PM_AWAKE: + if (set_chip) + ah->ah_powerMode = mode; status = ar9300_set_power_mode_awake(ah, set_chip); #if ATH_SUPPORT_MCI if (AH_PRIVATE(ah)->ah_caps.halMciSupport) { OS_REG_WRITE(ah, AR_RTC_KEEP_AWAKE, 0x2); } #endif + ahp->ah_chip_full_sleep = AH_FALSE; break; case HAL_PM_FULL_SLEEP: #if ATH_SUPPORT_MCI @@ -698,7 +702,10 @@ ar9300_set_power_mode(struct ath_hal *ah, HAL_POWER_MODE mode, int set_chip) } #endif ar9300_set_power_mode_sleep(ah, set_chip); - ahp->ah_chip_full_sleep = AH_TRUE; + if (set_chip) { + ahp->ah_chip_full_sleep = AH_TRUE; + ah->ah_powerMode = mode; + } break; case HAL_PM_NETWORK_SLEEP: #if ATH_SUPPORT_MCI @@ -707,12 +714,17 @@ ar9300_set_power_mode(struct ath_hal *ah, HAL_POWER_MODE mode, int set_chip) } #endif ar9300_set_power_mode_network_sleep(ah, set_chip); + if (set_chip) { + ah->ah_powerMode = mode; + } break; default: HALDEBUG(ah, HAL_DEBUG_POWER_MGMT, "%s: unknown power mode %u\n", __func__, mode); + OS_MARK(ah, AH_MARK_CHIP_POWER_DONE, -1); return AH_FALSE; } + OS_MARK(ah, AH_MARK_CHIP_POWER_DONE, status); return status; } @@ -976,7 +988,7 @@ ar9300_set_power_mode_wow_sleep(struct ath_hal *ah) OS_REG_SET_BIT(ah, AR_STA_ID1, AR_STA_ID1_PWR_SAV); OS_REG_WRITE(ah, AR_CR, AR_CR_RXD); /* Set receive disable bit */ - if (!ath_hal_wait(ah, AR_CR, AR_CR_RXE, 0, AH_WAIT_TIMEOUT)) { + if (!ath_hal_waitfor(ah, AR_CR, AR_CR_RXE, 0, AH_WAIT_TIMEOUT)) { HALDEBUG(ah, HAL_DEBUG_POWER_MGMT, "%s: dma failed to stop in 10ms\n" "AR_CR=0x%08x\nAR_DIAG_SW=0x%08x\n", __func__, OS_REG_READ(ah, AR_CR), OS_REG_READ(ah, AR_DIAG_SW)); diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv.c index e13c00b..c919d3c 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv.c @@ -113,6 +113,8 @@ ar9300_stop_dma_receive(struct ath_hal *ah, u_int timeout) #define AH_RX_STOP_DMA_TIMEOUT 10000 /* usec */ #define AH_TIME_QUANTUM 100 /* usec */ + OS_MARK(ah, AH_MARK_RX_CTL, AH_MARK_RX_CTL_DMA_STOP); + if (timeout == 0) { timeout = AH_RX_STOP_DMA_TIMEOUT; } @@ -157,6 +159,9 @@ ar9300_stop_dma_receive(struct ath_hal *ah, u_int timeout) OS_REG_WRITE(ah, AR_MACMISC, org_value); + OS_MARK(ah, AH_MARK_RX_CTL, + status ? AH_MARK_RX_CTL_DMA_STOP_OK : AH_MARK_RX_CTL_DMA_STOP_ERR); + return status; #undef AH_RX_STOP_DMA_TIMEOUT #undef AH_TIME_QUANTUM diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv_ds.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv_ds.c index a83099e..d4065d8 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv_ds.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_recv_ds.c @@ -68,6 +68,7 @@ ar9300_proc_rx_desc_fast(struct ath_hal *ah, struct ath_desc *ds, rxs->rs_status = 0; rxs->rs_flags = 0; + rxs->rs_phyerr = 0; rxs->rs_datalen = rxsp->status2 & AR_data_len; rxs->rs_tstamp = rxsp->status3; @@ -129,17 +130,16 @@ ar9300_proc_rx_desc_fast(struct ath_hal *ah, struct ath_desc *ds, * Consequently we filter them out here so we don't * confuse and/or complicate drivers. */ + if (rxsp->status11 & AR_crc_err) { rxs->rs_status |= HAL_RXERR_CRC; /* - * ignore CRC flag for spectral phy reports + * ignore CRC flag for phy reports */ if (rxsp->status11 & AR_phyerr) { u_int phyerr = MS(rxsp->status11, AR_phy_err_code); - if (phyerr == HAL_PHYERR_SPECTRAL) { - rxs->rs_status |= HAL_RXERR_PHY; - rxs->rs_phyerr = phyerr; - } + rxs->rs_status |= HAL_RXERR_PHY; + rxs->rs_phyerr = phyerr; } } else if (rxsp->status11 & AR_phyerr) { u_int phyerr; @@ -165,7 +165,9 @@ ar9300_proc_rx_desc_fast(struct ath_hal *ah, struct ath_desc *ds, rxs->rs_status |= HAL_RXERR_MIC; } } - +#if 0 + rxs->rs_channel = AH_PRIVATE(ah)->ah_curchan->channel; +#endif return HAL_OK; } diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_reset.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_reset.c index 642aba1..01845b9 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_reset.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_reset.c @@ -31,7 +31,6 @@ #define FIX_NOISE_FLOOR 1 - /* Additional Time delay to wait after activiting the Base band */ #define BASE_ACTIVATE_DELAY 100 /* usec */ #define RTC_PLL_SETTLE_DELAY 100 /* usec */ @@ -325,6 +324,7 @@ int16_t ar9300_get_min_cca_pwr(struct ath_hal *ah) int16_t nf; // struct ath_hal_private *ahpriv = AH_PRIVATE(ah); + if ((OS_REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) == 0) { nf = MS(OS_REG_READ(ah, AR_PHY_CCA_0), AR9280_PHY_MINCCA_PWR); if (nf & 0x100) { @@ -402,6 +402,33 @@ void ar9300_chain_noise_floor(struct ath_hal *ah, int16_t *nf_buf, } } +/* + * Return the current NF value in register. + * If the current NF cal is not completed, return 0. + */ +int16_t ar9300_get_nf_from_reg(struct ath_hal *ah, struct ieee80211_channel *chan, int wait_time) +{ + int16_t nfarray[HAL_NUM_NF_READINGS] = {0}; + int is_2g = 0; + HAL_CHANNEL_INTERNAL *ichan = NULL; + + ichan = ath_hal_checkchannel(ah, chan); + if (ichan == NULL) + return (0); + + if (wait_time <= 0) { + return 0; + } + + if (!ath_hal_waitfor(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF, 0, wait_time)) { + ath_hal_printf(ah, "%s: NF cal is not complete in %dus", __func__, wait_time); + return 0; + } + is_2g = !! (IS_CHAN_2GHZ(ichan)); + ar9300_upload_noise_floor(ah, is_2g, nfarray); + + return nfarray[0]; +} /* * Pick up the medium one in the noise floor buffer and update the @@ -415,6 +442,7 @@ ar9300_get_nf_hist_mid(struct ath_hal *ah, HAL_NFCAL_HIST_FULL *h, int reading, int16_t sort[HAL_NF_CAL_HIST_LEN_FULL]; /* upper bound for hist_len */ int i, j; + for (i = 0; i < hist_len; i++) { sort[i] = h->nf_cal_buffer[i][reading]; HALDEBUG(ah, HAL_DEBUG_NFCAL, @@ -451,7 +479,7 @@ ar9300_reset_nf_hist_buff(struct ath_hal *ah, HAL_CHANNEL_INTERNAL *ichan) HAL_CHAN_NFCAL_HIST *h = &ichan->nf_cal_hist; HAL_NFCAL_HIST_FULL *home = &AH_PRIVATE(ah)->nf_cal_hist; int i; - + /* * Copy the value for the channel in question into the home-channel * NF history buffer. The channel NF is probably a value filled in by @@ -538,6 +566,7 @@ get_noise_floor_thresh(struct ath_hal *ah, const HAL_CHANNEL_INTERNAL *chan, { struct ath_hal_9300 *ahp = AH9300(ah); + switch (chan->channel_flags & CHANNEL_ALL_NOTURBO) { case CHANNEL_A: case CHANNEL_A_HT20: @@ -1332,7 +1361,7 @@ ar9300_set_operating_mode(struct ath_hal *ah, int opmode) } /* XXX need the logic for Osprey */ -inline void +void ar9300_init_pll(struct ath_hal *ah, struct ieee80211_channel *chan) { u_int32_t pll; @@ -1609,6 +1638,7 @@ ar9300_set_reset(struct ath_hal *ah, int type) { u_int32_t rst_flags; u_int32_t tmp_reg; + struct ath_hal_9300 *ahp = AH9300(ah); HALASSERT(type == HAL_RESET_WARM || type == HAL_RESET_COLD); @@ -1802,6 +1832,7 @@ ar9300_set_reset(struct ath_hal *ah, int type) ar9300_attach_hw_platform(ah); + ahp->ah_chip_reset_done = 1; return AH_TRUE; } @@ -1987,13 +2018,25 @@ HAL_BOOL ar9300_chip_reset(struct ath_hal *ah, struct ieee80211_channel *chan) { struct ath_hal_9300 *ahp = AH9300(ah); + int type = HAL_RESET_WARM; OS_MARK(ah, AH_MARK_CHIPRESET, chan ? chan->ic_freq : 0); /* * Warm reset is optimistic. + * + * If the TX/RX DMA engines aren't shut down (eg, they're + * wedged) then we're better off doing a full cold reset + * to try and shake that condition. */ - if (!ar9300_set_reset_reg(ah, HAL_RESET_WARM)) { + if (ahp->ah_chip_full_sleep || + (ah->ah_config.ah_force_full_reset == 1) || + OS_REG_READ(ah, AR_Q_TXE) || + (OS_REG_READ(ah, AR_CR) & AR_CR_RXE)) { + type = HAL_RESET_COLD; + } + + if (!ar9300_set_reset_reg(ah, type)) { return AH_FALSE; } @@ -2300,10 +2343,22 @@ ar9300_per_calibration(struct ath_hal *ah, HAL_CHANNEL_INTERNAL *ichan, static void ar9300_start_nf_cal(struct ath_hal *ah) { + struct ath_hal_9300 *ahp = AH9300(ah); OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_ENABLE_NF); OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NO_UPDATE_NF); OS_REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); AH9300(ah)->nf_tsf32 = ar9300_get_tsf32(ah); + +/* + * We are reading the NF values before we start the NF operation, because + * of that we are getting very high values like -45. + * This triggers the CW_INT detected and EACS module triggers the channel change + * chip_reset_done value is used to fix this issue. + * chip_reset_flag is set during the RTC reset. + * chip_reset_flag is cleared during the starting NF operation. + * if flag is set we will clear the flag and will not read the NF values. + */ + ahp->ah_chip_reset_done = 0; } /* ar9300_calibration @@ -2397,7 +2452,7 @@ ar9300_calibration(struct ath_hal *ah, struct ieee80211_channel *chan, u_int8_t ar9300_load_nf(ah, nf_buf); /* start NF calibration, without updating BB NF register*/ - ar9300_start_nf_cal(ah); + ar9300_start_nf_cal(ah); } } return AH_TRUE; @@ -2447,12 +2502,15 @@ ar9300_iq_calibration(struct ath_hal *ah, u_int8_t num_chains) u_int32_t q_coff_denom, i_coff_denom; int32_t q_coff, i_coff; int iq_corr_neg, i; + HAL_CHANNEL_INTERNAL *ichan; static const u_int32_t offset_array[3] = { AR_PHY_RX_IQCAL_CORR_B0, AR_PHY_RX_IQCAL_CORR_B1, AR_PHY_RX_IQCAL_CORR_B2, }; + ichan = ath_hal_checkchannel(ah, AH_PRIVATE(ah)->ah_curchan); + for (i = 0; i < num_chains; i++) { power_meas_i = ahp->ah_total_power_meas_i[i]; power_meas_q = ahp->ah_total_power_meas_q[i]; @@ -2525,6 +2583,19 @@ ar9300_iq_calibration(struct ath_hal *ah, u_int8_t num_chains) OS_REG_RMW_FIELD(ah, offset_array[i], AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF, q_coff); + /* store the RX cal results */ + if (ichan != NULL) { + ahp->ah_rx_cal_corr[i] = OS_REG_READ(ah, offset_array[i]) & 0x7fff; + ahp->ah_rx_cal_complete = AH_TRUE; + ahp->ah_rx_cal_chan = ichan->channel; +// ahp->ah_rx_cal_chan_flag = ichan->channel_flags &~ CHANNEL_PASSIVE; + ahp->ah_rx_cal_chan_flag = 0; /* XXX */ + } else { + /* XXX? Is this what I should do? */ + ahp->ah_rx_cal_complete = AH_FALSE; + + } + HALDEBUG(ah, HAL_DEBUG_CALIBRATE, "Register offset (0x%04x) QI COFF (bitfields 0x%08x) " "after update = 0x%x\n", @@ -2551,6 +2622,55 @@ ar9300_iq_calibration(struct ath_hal *ah, u_int8_t num_chains) } /* + * When coming back from offchan, we do not perform RX IQ Cal. + * But the chip reset will clear all previous results + * We store the previous results and restore here. + */ +static void +ar9300_rx_iq_cal_restore(struct ath_hal *ah) +{ + struct ath_hal_9300 *ahp = AH9300(ah); + u_int32_t i_coff, q_coff; + HAL_BOOL is_restore = AH_FALSE; + int i; + static const u_int32_t offset_array[3] = { + AR_PHY_RX_IQCAL_CORR_B0, + AR_PHY_RX_IQCAL_CORR_B1, + AR_PHY_RX_IQCAL_CORR_B2, + }; + + for (i=0; i<AR9300_MAX_CHAINS; i++) { + if (ahp->ah_rx_cal_corr[i]) { + i_coff = (ahp->ah_rx_cal_corr[i] & + AR_PHY_RX_IQCAL_CORR_IQCORR_Q_I_COFF) >> + AR_PHY_RX_IQCAL_CORR_IQCORR_Q_I_COFF_S; + q_coff = (ahp->ah_rx_cal_corr[i] & + AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF) >> + AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF_S; + + OS_REG_RMW_FIELD(ah, offset_array[i], + AR_PHY_RX_IQCAL_CORR_IQCORR_Q_I_COFF, i_coff); + OS_REG_RMW_FIELD(ah, offset_array[i], + AR_PHY_RX_IQCAL_CORR_IQCORR_Q_Q_COFF, q_coff); + + is_restore = AH_TRUE; + } + } + + if (is_restore) + OS_REG_SET_BIT(ah, + AR_PHY_RX_IQCAL_CORR_B0, AR_PHY_RX_IQCAL_CORR_IQCORR_ENABLE); + + HALDEBUG(ah, HAL_DEBUG_CALIBRATE, + "%s: IQ Cal and Correction (offset 0x%04x) enabled " + "(bit position 0x%08x). New Value 0x%08x\n", + __func__, + (unsigned) (AR_PHY_RX_IQCAL_CORR_B0), + AR_PHY_RX_IQCAL_CORR_IQCORR_ENABLE, + OS_REG_READ(ah, AR_PHY_RX_IQCAL_CORR_B0)); +} + +/* * Set a limit on the overall output power. Used for dynamic * transmit power control and the like. * @@ -3727,6 +3847,13 @@ ar9300_init_cal_internal(struct ath_hal *ah, struct ieee80211_channel *chan, #endif /* end - Init time calibrations */ + /* Do not do RX cal in case of offchan, or cal data already exists on same channel*/ + if (ahp->ah_skip_rx_iq_cal) { + HALDEBUG(ah, HAL_DEBUG_CALIBRATE, + "Skip RX IQ Cal\n"); + return AH_TRUE; + } + /* If Cals are supported, add them to list via INIT/INSERT_CAL */ if (AH_TRUE == ar9300_is_cal_supp(ah, chan, IQ_MISMATCH_CAL)) { INIT_CAL(&ahp->ah_iq_cal_data); @@ -3827,6 +3954,8 @@ ar9300_set_dma(struct ath_hal *ah) { u_int32_t regval; struct ath_hal_9300 *ahp = AH9300(ah); + struct ath_hal_private *ahpriv = AH_PRIVATE(ah); + HAL_CAPABILITIES *pCap = &ahpriv->ah_caps; #if 0 /* @@ -3886,9 +4015,14 @@ ar9300_set_dma(struct ath_hal *ah) /* * Enable HPQ for UAPSD */ - if (AH_PRIVATE(ah)->ah_opmode == HAL_M_HOSTAP) { - OS_REG_WRITE(ah, AR_HP_Q_CONTROL, - AR_HPQ_ENABLE | AR_HPQ_UAPSD | AR_HPQ_UAPSD_TRIGGER_EN); + if (pCap->halHwUapsdTrig == AH_TRUE) { + /* Only enable this if HAL capabilities says it is OK */ + if (AH_PRIVATE(ah)->ah_opmode == HAL_M_HOSTAP) { + OS_REG_WRITE(ah, AR_HP_Q_CONTROL, + AR_HPQ_ENABLE | AR_HPQ_UAPSD | AR_HPQ_UAPSD_TRIGGER_EN); + } + } else { + /* use default value from ini file - which disable HPQ queue usage */ } /* @@ -4307,6 +4441,7 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch HAL_BOOL stopped, cal_ret; HAL_BOOL apply_last_iqcorr = AH_FALSE; + if (OS_REG_READ(ah, AR_IER) == AR_IER_ENABLE) { HALDEBUG(AH_NULL, HAL_DEBUG_UNMASKABLE, "** Reset called with WLAN " "interrupt enabled %08x **\n", ar9300_get_interrupts(ah)); @@ -4335,6 +4470,11 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch ahp->ah_rx_chainmask = rxchainmask & ap->ah_caps.halRxChainMask; ahp->ah_tx_cal_chainmask = ap->ah_caps.halTxChainMask; ahp->ah_rx_cal_chainmask = ap->ah_caps.halRxChainMask; + + /* + * Keep the previous optinal txchainmask value + */ + HALASSERT(ar9300_check_op_mode(opmode)); OS_MARK(ah, AH_MARK_RESET, b_channel_change); @@ -4441,7 +4581,21 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch #if 0 /* Get the value from the previous NF cal and update history buffer */ if (curchan && (ahp->ah_chip_full_sleep != AH_TRUE)) { - ar9300_store_new_nf(ah, curchan, is_scan); + + if(ahp->ah_chip_reset_done){ + ahp->ah_chip_reset_done = 0; + } else { + /* + * is_scan controls updating NF for home channel or off channel. + * Home -> Off, update home channel + * Off -> Home, update off channel + * Home -> Home, uppdate home channel + */ + if (ap->ah_curchan->channel != chan->channel) + ar9300_store_new_nf(ah, curchan, !is_scan); + else + ar9300_store_new_nf(ah, curchan, is_scan); + } } #endif @@ -4452,7 +4606,7 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch AH9300(ah)->nfp = IS_CHAN_2GHZ(ichan) ? &ahp->nf_2GHz : &ahp->nf_5GHz; /* - * XXX For now, don't apply the last IQ correction. + * XXX FreeBSD For now, don't apply the last IQ correction. * * This should be done when scorpion is enabled on FreeBSD; just be * sure to fix this channel match code so it uses net80211 flags @@ -4489,6 +4643,34 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch } #endif /* + * In case of + * - offchan scan, or + * - same channel and RX IQ Cal already available + * disable RX IQ Cal. + */ + if (is_scan) { + ahp->ah_skip_rx_iq_cal = AH_TRUE; + HALDEBUG(ah, HAL_DEBUG_CALIBRATE, + "Skip RX IQ Cal due to scanning\n"); + } else { +#if 0 + /* XXX FreeBSD: always just do the RX IQ cal */ + /* XXX I think it's just going to speed things up; I don't think it's to avoid chan bugs */ + if (ahp->ah_rx_cal_complete && + ahp->ah_rx_cal_chan == ichan->channel && + ahp->ah_rx_cal_chan_flag == chan->channel_flags) { + ahp->ah_skip_rx_iq_cal = AH_TRUE; + HALDEBUG(ah, HAL_DEBUG_CALIBRATE, + "Skip RX IQ Cal due to same channel with completed RX IQ Cal\n"); + } else +#endif + ahp->ah_skip_rx_iq_cal = AH_FALSE; + } + + /* FreeBSD: clear the channel survey data */ + ath_hal_survey_clear(ah); + + /* * Fast channel change (Change synthesizer based on channel freq * without resetting chip) * Don't do it when @@ -4854,6 +5036,23 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch ar9300_init_bb(ah, chan); /* BB Step 7: Calibration */ + /* + * Only kick off calibration not on offchan. + * If coming back from offchan, restore prevous Cal results + * since chip reset will clear existings. + */ + if (!ahp->ah_skip_rx_iq_cal) { + int i; + /* clear existing RX cal data */ + for (i=0; i<AR9300_MAX_CHAINS; i++) + ahp->ah_rx_cal_corr[i] = 0; + + ahp->ah_rx_cal_complete = AH_FALSE; +// ahp->ah_rx_cal_chan = chan->channel; +// ahp->ah_rx_cal_chan_flag = ichan->channel_flags; + ahp->ah_rx_cal_chan = 0; + ahp->ah_rx_cal_chan_flag = 0; /* XXX FreeBSD */ + } ar9300_invalidate_saved_cals(ah, ichan); cal_ret = ar9300_init_cal(ah, chan, AH_FALSE, apply_last_iqcorr); @@ -5009,6 +5208,11 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch nf_hist_buff_reset = 0; #ifndef ATH_NF_PER_CHAN if (First_NFCal(ah, ichan, is_scan, chan)){ + if (ahp->ah_skip_rx_iq_cal && !is_scan) { + /* restore RX Cal result if existing */ + ar9300_rx_iq_cal_restore(ah); + ahp->ah_skip_rx_iq_cal = AH_FALSE; + } } #endif /* ATH_NF_PER_CHAN */ } @@ -5082,12 +5286,24 @@ ar9300_reset(struct ath_hal *ah, HAL_OPMODE opmode, struct ieee80211_channel *ch ar9300_set_smart_antenna(ah, ahp->ah_smartantenna_enable); + if (ahp->ah_skip_rx_iq_cal && !is_scan) { + /* restore RX Cal result if existing */ + ar9300_rx_iq_cal_restore(ah); + ahp->ah_skip_rx_iq_cal = AH_FALSE; + } + return AH_TRUE; bad: OS_MARK(ah, AH_MARK_RESET_DONE, ecode); *status = ecode; + if (ahp->ah_skip_rx_iq_cal && !is_scan) { + /* restore RX Cal result if existing */ + ar9300_rx_iq_cal_restore(ah); + ahp->ah_skip_rx_iq_cal = AH_FALSE; + } + return AH_FALSE; #undef FAIL } @@ -6139,6 +6355,7 @@ ar9300_ant_ctrl_set_lna_div_use_bt_ant(struct ath_hal *ah, HAL_BOOL enable, cons value &= ~AR_SWITCH_TABLE_COM2_ALL; value |= ah->ah_config.ath_hal_ant_ctrl_comm2g_switch_enable; } + HALDEBUG(ah, HAL_DEBUG_RESET, "%s: com2=0x%08x\n", __func__, value); OS_REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM_2, AR_SWITCH_TABLE_COM2_ALL, value); value = ar9300_eeprom_get(ahp, EEP_ANTDIV_control); @@ -6186,5 +6403,7 @@ ar9300_ant_ctrl_set_lna_div_use_bt_ant(struct ath_hal *ah, HAL_BOOL enable, cons } else { return AH_TRUE; } + + /* XXX TODO: Add AR9565 support? */ } #endif /* ATH_ANT_DIV_COMB */ diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_stub.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_stub.c index 2dd9472..211e201 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_stub.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_stub.c @@ -33,7 +33,7 @@ void ar9300_set_stub_functions(struct ath_hal *ah) { - ath_hal_printf(ah, "%s: setting stub functions\n", __func__); +// ath_hal_printf(ah, "%s: setting stub functions\n", __func__); ah->ah_getRateTable = ar9300_Stub_GetRateTable; // ah->ah_detach = ar9300_Stub_detach; diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit.c index ab39284..530b29a 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit.c @@ -583,6 +583,14 @@ ar9300_num_tx_pending(struct ath_hal *ah, u_int q) HAL_BOOL ar9300_stop_tx_dma(struct ath_hal *ah, u_int q, u_int timeout) { + struct ath_hal_9300 *ahp = AH9300(ah); + + /* + * If we call abort txdma instead, no need to stop RX. + * Otherwise, the RX logic might not be restarted properly. + */ + ahp->ah_abort_txdma_norx = AH_FALSE; + /* * Directly call abort. It is better, hardware-wise, to stop all * queues at once than individual ones. @@ -798,10 +806,40 @@ ar9300_stop_tx_dma_indv_que(struct ath_hal *ah, u_int q, u_int timeout) */ #define AR9300_ABORT_LOOPS 1000 #define AR9300_ABORT_WAIT 5 +#define NEXT_TBTT_NOW 10 HAL_BOOL ar9300_abort_tx_dma(struct ath_hal *ah) { + struct ath_hal_9300 *ahp = AH9300(ah); int i, q; + u_int32_t nexttbtt, nextdba, tsf_tbtt, tbtt, dba; + HAL_BOOL stopped; + HAL_BOOL status = AH_TRUE; + + if (ahp->ah_abort_txdma_norx) { + /* + * First of all, make sure RX has been stopped + */ + if (ar9300_get_power_mode(ah) != HAL_PM_FULL_SLEEP) { + /* Need to stop RX DMA before reset otherwise chip might hang */ + stopped = ar9300_set_rx_abort(ah, AH_TRUE); /* abort and disable PCU */ + ar9300_set_rx_filter(ah, 0); + stopped &= ar9300_stop_dma_receive(ah, 0); /* stop and disable RX DMA */ + if (!stopped) { + /* + * During the transition from full sleep to reset, + * recv DMA regs are not available to be read + */ + HALDEBUG(ah, HAL_DEBUG_UNMASKABLE, + "%s[%d]: ar9300_stop_dma_receive failed\n", __func__, __LINE__); + //We still continue to stop TX dma + //return AH_FALSE; + } + } else { + HALDEBUG(ah, HAL_DEBUG_UNMASKABLE, + "%s[%d]: Chip is already in full sleep\n", __func__, __LINE__); + } + } /* * set txd on all queues @@ -812,13 +850,27 @@ ar9300_abort_tx_dma(struct ath_hal *ah) * set tx abort bits (also disable rx) */ OS_REG_SET_BIT(ah, AR_PCU_MISC, AR_PCU_FORCE_QUIET_COLL | AR_PCU_CLEAR_VMF); - OS_REG_SET_BIT(ah, AR_DIAG_SW, (AR_DIAG_FORCE_CH_IDLE_HIGH | AR_DIAG_RX_DIS | - AR_DIAG_RX_ABORT | AR_DIAG_FORCE_RX_CLEAR)); + /* Add a new receipe from K31 code */ + OS_REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH | AR_DIAG_RX_DIS | + AR_DIAG_RX_ABORT | AR_DIAG_FORCE_RX_CLEAR); + /* beacon Q flush */ + nexttbtt = OS_REG_READ(ah, AR_NEXT_TBTT_TIMER); + nextdba = OS_REG_READ(ah, AR_NEXT_DMA_BEACON_ALERT); + //printk("%s[%d]:dba: %d, nt: %d \n", __func__, __LINE__, nextdba, nexttbtt); + tsf_tbtt = OS_REG_READ(ah, AR_TSF_L32); + tbtt = tsf_tbtt + NEXT_TBTT_NOW; + dba = tsf_tbtt; + OS_REG_WRITE(ah, AR_NEXT_DMA_BEACON_ALERT, dba); + OS_REG_WRITE(ah, AR_NEXT_TBTT_TIMER, tbtt); OS_REG_SET_BIT(ah, AR_D_GBL_IFS_MISC, AR_D_GBL_IFS_MISC_IGNORE_BACKOFF); - /* Let TXE (all queues) clear before waiting on any pending frames */ - for (i = 0; i < AR9300_ABORT_LOOPS; i++) { - if (OS_REG_READ(ah, AR_Q_TXE) == 0) { + /* + * Let TXE (all queues) clear before waiting for any pending frames + * This is needed before starting the RF_BUS GRANT sequence other wise causes kernel + * panic + */ + for(i = 0; i < AR9300_ABORT_LOOPS; i++) { + if(OS_REG_READ(ah, AR_Q_TXE) == 0) { break; } OS_DELAY(AR9300_ABORT_WAIT); @@ -830,28 +882,38 @@ ar9300_abort_tx_dma(struct ath_hal *ah) /* * wait on all tx queues + * This need to be checked in the last to gain extra 50 usec. on avg. + * Currently checked first since we dont have a previous channel information currently. + * Which is needed to revert the rf changes. */ - for (q = 0; q < AR_NUM_QCU; q++) { + for (q = AR_NUM_QCU - 1; q >= 0; q--) { for (i = 0; i < AR9300_ABORT_LOOPS; i++) { - if (!ar9300_num_tx_pending(ah, q)) { + if (!(ar9300_num_tx_pending(ah, q))) { break; } OS_DELAY(AR9300_ABORT_WAIT); } if (i == AR9300_ABORT_LOOPS) { - HALDEBUG(ah, HAL_DEBUG_TX, - "%s[%d] reached max wait on pending tx, q %d\n", - __func__, __LINE__, q); - return AH_FALSE; + status = AH_FALSE; + HALDEBUG(ah, HAL_DEBUG_UNMASKABLE, + "ABORT LOOP finsihsed for Q: %d, num_pending: %d \n", + q, ar9300_num_tx_pending(ah, q)); + goto exit; } } + /* Updating the beacon alert register with correct value */ + OS_REG_WRITE(ah, AR_NEXT_DMA_BEACON_ALERT, nextdba); + OS_REG_WRITE(ah, AR_NEXT_TBTT_TIMER, nexttbtt); + +exit: /* * clear tx abort bits */ OS_REG_CLR_BIT(ah, AR_PCU_MISC, AR_PCU_FORCE_QUIET_COLL | AR_PCU_CLEAR_VMF); - OS_REG_CLR_BIT(ah, AR_DIAG_SW, (AR_DIAG_FORCE_CH_IDLE_HIGH | AR_DIAG_RX_DIS | - AR_DIAG_RX_ABORT | AR_DIAG_FORCE_RX_CLEAR)); + /* Added a new receipe from K31 code */ + OS_REG_CLR_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH | AR_DIAG_RX_DIS | + AR_DIAG_RX_ABORT | AR_DIAG_FORCE_RX_CLEAR); OS_REG_CLR_BIT(ah, AR_D_GBL_IFS_MISC, AR_D_GBL_IFS_MISC_IGNORE_BACKOFF); /* @@ -859,7 +921,9 @@ ar9300_abort_tx_dma(struct ath_hal *ah) */ OS_REG_WRITE(ah, AR_Q_TXD, 0); - return AH_TRUE; + ahp->ah_abort_txdma_norx = AH_TRUE; + + return status; } /* diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit_ds.c b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit_ds.c index 596f6dc..72ed110 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit_ds.c +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300_xmit_ds.c @@ -68,9 +68,11 @@ ar9300_fill_tx_desc( const void *ds0) { struct ar9300_txc *ads = AR9300TXC(ds); + short desclen; /* Fill TXC info field */ - ads->ds_info = TXC_INFO(qcu); + desclen = (AR_SREV_JUPITER(ah) || AR_SREV_APHRODITE(ah)) ? 0x18 : 0x17; + ads->ds_info = TXC_INFO(qcu, desclen); /* Set the buffer addresses */ ads->ds_data0 = buf_addr[0]; @@ -124,6 +126,9 @@ ar9300_fill_tx_desc( ads->ds_ctl17 = SM(key_type, AR_encr_type); } + /* Only relevant for Jupiter/Aphrodite */ + ads->ds_ctl23 = 0; + return AH_TRUE; } diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300desc.h b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300desc.h index 9054db0..5dbf927 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9300desc.h +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9300desc.h @@ -78,7 +78,8 @@ struct ar9300_txc { u_int32_t ds_ctl20; /* DMA control 20 */ u_int32_t ds_ctl21; /* DMA control 21 */ u_int32_t ds_ctl22; /* DMA control 22 */ - u_int32_t ds_pad[9]; /* pad to cache line (128 bytes/32 dwords) */ + u_int32_t ds_ctl23; /* DMA control 23 */ + u_int32_t ds_pad[8]; /* pad to cache line (128 bytes/32 dwords) */ }; @@ -347,6 +348,7 @@ struct ar9300_txc { /* ds_status2 */ #define AR_data_len 0x00000fff +#define AR_data_len_S 0 #define AR_rx_more 0x00001000 #define AR_num_delim 0x003fc000 #define AR_num_delim_S 14 @@ -428,11 +430,11 @@ struct ar9300_txc { #define RXSTATUS_NUMWORDS(ah) 11 -#define TXC_INFO(_qcu) (ATHEROS_VENDOR_ID << AR_desc_id_S) \ +#define TXC_INFO(_qcu, _desclen) (ATHEROS_VENDOR_ID << AR_desc_id_S) \ | (1 << AR_tx_rx_desc_S) \ | (1 << AR_ctrl_stat_S) \ | (_qcu << AR_tx_qcu_num_S) \ - | (0x17) + | (_desclen) #define VALID_KEY_TYPES \ ((1 << HAL_KEY_TYPE_CLEAR) | (1 << HAL_KEY_TYPE_WEP)|\ diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9340.ini b/sys/contrib/dev/ath/ath_hal/ar9300/ar9340.ini index 81894de..ef7dbca 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9340.ini +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9340.ini @@ -1078,7 +1078,7 @@ static const u_int32_t ar9340_wasp_1p0_mac_postamble[][5] = { { 0x0000801c , 0x128d8027 , 0x128d804f , 0x12e00057 , 0x12e0002b }, - { 0x00008120 , 0x08f04800 , 0x08f04800 , 0x08f04810 , 0x08f04810 }, + { 0x00008120 , 0x18f04800 , 0x18f04800 , 0x18f04810 , 0x18f04810 }, { 0x000081d0 , 0x00003210 , 0x00003210 , 0x0000320a , 0x0000320a }, @@ -1212,7 +1212,7 @@ static const u_int32_t ar9340_wasp_1p0_baseband_postamble[][5] = { { 0x00009e18 , 0x00000000 , 0x00000000 , 0x00000000 , 0x00000000 }, - { 0x00009e1c , 0x0001cf9c , 0x0001cf9c , 0x00021f9c , 0x00021f9c }, + { 0x00009e1c , 0x0001c59c , 0x0001c59c , 0x0002159c , 0x0002159c }, { 0x00009e20 , 0x000003b5 , 0x000003b5 , 0x000003ce , 0x000003ce }, @@ -1586,10 +1586,14 @@ static const u_int32_t ar9340_wasp_1p0_baseband_postamble_dfs_channel[][3] = { { 0x00009824 , 0x5ac668d0 , 0x5ac668d0 }, + { 0x00009828 , 0x06903080 , 0x06903080 }, + { 0x00009e0c , 0x6d4000e2 , 0x6d4000e2 }, { 0x00009e14 , 0x37b9625e , 0x37b9625e }, + { 0x00009814 , 0x3400c00f , 0x3400c00f }, + }; diff --git a/sys/contrib/dev/ath/ath_hal/ar9300/ar9580.ini b/sys/contrib/dev/ath/ath_hal/ar9300/ar9580.ini index 32124db..52b92ff 100644 --- a/sys/contrib/dev/ath/ath_hal/ar9300/ar9580.ini +++ b/sys/contrib/dev/ath/ath_hal/ar9300/ar9580.ini @@ -34,8 +34,10 @@ static const u_int32_t ar9300_ar9580_1p0_baseband_postamble_dfs_channel[][3] = { /* Addr 5G_HT20 5G_HT40 */ { 0x00009824 , 0x5ac668d0 , 0x5ac668d0 }, + { 0x00009828 , 0x06903080 , 0x06903080 }, { 0x00009e0c , 0x6d4000e2 , 0x6d4000e2 }, { 0x00009e14 , 0x37b9625e , 0x37b9625e }, + { 0x00009814 , 0x3400c00f , 0x3400c00f }, }; static const u_int32_t ar9300Modes_fast_clock_ar9580_1p0[][3] = { @@ -257,7 +259,7 @@ static const u_int32_t ar9300_ar9580_1p0_mac_postamble[][5] = { { 0x000010b0 , 0x00000e60 , 0x00001cc0 , 0x00007c70 , 0x00003e38 }, { 0x00008014 , 0x03e803e8 , 0x07d007d0 , 0x10801600 , 0x08400b00 }, { 0x0000801c , 0x128d8027 , 0x128d804f , 0x12e00057 , 0x12e0002b }, - { 0x00008120 , 0x08f04800 , 0x08f04800 , 0x08f04810 , 0x08f04810 }, + { 0x00008120 , 0x18f04800 , 0x18f04800 , 0x18f04810 , 0x18f04810 }, { 0x000081d0 , 0x00003210 , 0x00003210 , 0x0000320a , 0x0000320a }, { 0x00008318 , 0x00003e80 , 0x00007d00 , 0x00006880 , 0x00003440 }, }; @@ -1091,7 +1093,7 @@ static const u_int32_t ar9300_ar9580_1p0_mac_core[][2] = { { 0x00008258 , 0x00000000 }, { 0x0000825c , 0x40000000 }, { 0x00008260 , 0x00080922 }, - { 0x00008264 , 0x9bc00010 }, + { 0x00008264 , 0x9d400010 }, { 0x00008268 , 0xffffffff }, { 0x0000826c , 0x0000ffff }, { 0x00008270 , 0x00000000 }, @@ -2155,7 +2157,7 @@ static const u_int32_t ar9300_ar9580_1p0_baseband_postamble[][5] = { { 0x00009e10 , 0x7ec88d2e , 0x7ec88d2e , 0x7ec84d2e , 0x7ec84d2e }, { 0x00009e14 , 0x37b95d5e , 0x37b9605e , 0x3379605e , 0x33795d5e }, { 0x00009e18 , 0x00000000 , 0x00000000 , 0x00000000 , 0x00000000 }, - { 0x00009e1c , 0x0001cf9c , 0x0001cf9c , 0x00021f9c , 0x00021f9c }, + { 0x00009e1c , 0x0001c59c , 0x0001c59c , 0x0002159c , 0x0002159c }, { 0x00009e20 , 0x000003b5 , 0x000003b5 , 0x000003ce , 0x000003ce }, { 0x00009e2c , 0x0000001c , 0x0000001c , 0x00000021 , 0x00000021 }, { 0x00009e3c , 0xcf946220 , 0xcf946220 , 0xcf946222 , 0xcf946222 }, diff --git a/sys/contrib/dev/iwn/iwlwifi-100-39.31.5.1.fw.uu b/sys/contrib/dev/iwn/iwlwifi-100-39.31.5.1.fw.uu new file mode 100644 index 0000000..aeaf67c --- /dev/null +++ b/sys/contrib/dev/iwn/iwlwifi-100-39.31.5.1.fw.uu @@ -0,0 +1,5925 @@ +begin-base64 644 iwlwifi-100-39.31.5.1 +AAAAAElXTAoxMDAgZncgdjM5LjMxLjUuMSBidWlsZCAzMjg5NQoAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAQUfJ3+AAAABAAAAAAAAAAEAAAAw7AEAICCADwAAQABpIAAAaSBAAGkg +AABpIEAAICCADwAA6ABpIAAAaSBAAGkgAABpIEAAICCADwAAMAVpIAAAaSBAAGkgAABKIAAASiEA +AEoiAABKIwAASiQAAEolAABKJgAASicAAEogABBKIQAQSiIAEEojABBKJAAQSiUAEEomABBKJwAQ +SiAAIEohACBKIgAgSiMAIEokACBKJQAgSiYAIEonACBKIAAwSiEAMAokgD+AAADAQSycMEAsnDBC +JBw0CiKAP4AA1FkKIwA3jg4AAEomAHBpIEAASiYAcEomAHBKJgBwSiYAcAAWAHCAAHAEQHggIECH +AAAAAAAAAAAAAArIz3GgAMgfDhkYgAvIDxkYgAzIEBkYgA0SAjYAyER4ERkYgA7ILRkYgOB+4cT8 +HMi+/BxIvuHA4cHhwuHD/BwIsfwcSLH8HIix/BzIsfwcCLL8HEiy/ByIsvwcyLL8HAi/aiSAEOHE +aiTAEOHE8cDPcKAA0BsUgM9xgABsBAQggI/PUQThAKEK8i8pAQDPcIAAYAnwIEAAQHja/9HAwcRr +JMAQwcRrJIAQwcSfdAQUCzQEFAo0BBQJNAQUCDQEFAc0BBQGNAQUBTQEFAQ0wcPBwsHBwcDBxEUs +fhAKJkB+wcRrJIAUwcQgIECHCsiHuAoaGDALyJu4CxoYMAzIDBoYMA3Ih7gNGhgwDsiFIMMPDhoY +MOB+4HjxwArIlbgKGhgwC8ibuAsaGDANyIq4jbiQuA0aGDDPcIAAiAoYiIHgC/QNyM9xAAAQCqy4 +DRoYMEINIAAP2GfY6g3gAIohRwHRwOB+8cDPcQMAQA3PcKAAqCAtoM9ygAC4BCCCAWkAoqINIAFI +2M9wgADECCWAI4EggcdxAACIE44OgAfi8eB4z3CAAMQIHQaAB+B48cBmC0ABgODPdoAAbAQG8oHg +BvQB2APwANgLroDhBvKB4Qb0AdgD8ADYCq6A4gbygeIG9AHYA/AA2AyuANjPdaAAyB8YHRiQC46A +4IohEAAO8giOgOAM8s9wAwBADUUdGBAwpQLYGB0YkAPwMaUKjoDgGvIJjoDgFvLPcAEAMOwgHRiQ +z3CAACgAIR0YkM9wgABoBCIdGJAYFQCWRSAAAxgdGJAMjoDgB/IYFQCWhSABBBgdGJCA4xjyANiU +uM92gACoBACmcdgGuAYIIAH82SCGz3AAAEwc9g/gAJ+5GBUAloW4GB0YkOkCQAFpIEAA/vHgePHA +pcFBwELBDBwAMRAcQDHPcYAA/Fo0GcAPMBkADywZwA4oGYAOJBlADs9wgAD8WiAYQAvPcIAA/Foc +GAALz3CAAPxaGBjACs9wgAD8WhQYgArPcIAA/FoQGMAIz3CAAPxaDBiACM9wgAD8WggYQAjPcYAA +gFqAGQAIfBnAB3gZgAd0GUAHcBkAB2wZAAdoGYAGZBlABmAZAAZcGcAFWBmABVQZQAVQGQAFTBnA +BEgZgAREGUAEQBkABO+hzqGtoYyhLBnAAigZgAIkGUACIBkAAhwZwAEYGYABFBlAARAZAAFjoWog +AAPYGQAAaiDAAtQZAABqIIAC0BkAAGogQAHIGQAAaiAAAcQZAABqIMAAwBkAAGoggAC8GQAAaiBA +ALgZAABqIAAAtBkAAGoggAHMGQAAz3GfALj/GIFTJ841UyXENVMmxTWUuBihQMMBwALB17oMFAYw +yXMA3ZYL4AAQFAcwz3CgALQPvKDPcaAAyDsugS4L4AB92LYJQAGSDuAAqXAI2ADZUg7gAJm5NvHx +wLYIYAF72AoL4ADX2c9xgAD8WjQZwA8wGQAPLBnADigZgA4kGUAOz3CAAPxaIBhAC89wgAD8WhwY +AAvPcIAA/FoYGMAKz3CAAPxaFBiACs9wgAD8WhAYwAjPcIAA/FoMGIAIz3CAAPxaCBhACM9xgACA +WoAZAAh8GcAHeBmAB3QZQAdwGQAHbBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAE +SBmABEQZQARAGQAE76HOoa2hjKEsGcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAA +A9gZAABqIMAC1BkAAGoggALQGQAAaiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAA +uBkAAGogAAC0GQAAaiCAAcwZAADrds91oADQG1wVEBDPcAAARBziCSABCifAHzpwz3CAAHAWA4CA +4AbyF4VRIMCAlAcCAQfYwgkgAQq4UyBBBwfY2gzgAAq4z3CgANQLGIBCIAAISCAAAM9zgADMFc9x +gACoBCCBnBsAAAshQITKICIDOPRMIICgDvRRIYClCvKg4Ej3USFApRzYyiDhBirwBNgo8IwgAaAh +8kIgQSCP4T4ADQAzJkFwgAAAQEAnAHI0eAB4SiBAIA3YFPBKIIAg6PFKIAAhE9gM8EogACIU2Ajw +SiAAJBXYBPAW2ALwD9hxg+lxyXIKJAAEWQTv/wolQATgeBEDz//xwCYJwAB12OII4ACKIQoDVgsA +AJ4PgAGf/qIIAAAKIcAP63IG2IojSgdKJAAAHQTv/wolAAHgeIDh8cAD8qDgi/YKIcAP63IF2Onb +SiRAAPkD7/+4c89ygABgCRV6IKLRwOB+ANmeuRl5z3KAAFgJAYIleOB/AaIA2Z65GXnPcoAAWAkB +giZ44H8BogDZnrkZec9wgABYCQGAJHhCIACA4H/KIGIA4HjPcIAAWAkBgOB/LygBAOB48cDyCM// +4HjgeOB44HhpIIABbyE/AGkgAAD38fHAatgSCOAAiiFEAwDYjbjuC6ADCBoYMBDMhiD/ignyz3CA +AAUFAIiA4CwIwgOw8fHAUgjAA89xgADMEfAhAABAeIDZz3CgANAbMKCg8eB48cCSDQABz3CAAGwE +oIDPcIAAiAoIgAQljR8PAADg67gF9FILgAmA4A70z3GgALRHANhLGRiAAdh3GRiAANieuFQZGIAE +JYIfAQAAABJqz3OAAHwEIIOkeOGDBCWOHwAAAEAHeSCjBHkGJUAQA74EJYEfAAAAgKR+XXpFecd/ +5H7GeAK5BCWNHwIAAACkeSZ4LygBAE4gQQTPcIAAiApVEIAA4aOA4M92oADIHxkaWDAP8s9woAAU +BCqgCYC44En3z3KgAIggAdg1egCiM/DPcYAADAUA2AChAN+RvxMe2JPPcIAA3AIQeM91oAC0R0kd +GJDPcYAAdHrPcIAAEAUgoG8gQwBUHRiQAdimCqADCBoYMGIKgAmA4A30Ex7Yk89wgAAMBBB4SR0Y +kG8gQwBUHRiQyQQAAeB48cDhxc9xgADcCIARAADPdaAAyB8vKgEAz3ADAEANRR0YEPAhgABAeIDY +FR0YkKUEAAHgePHAz3GAAGwEfNhSDqAAIIEKIcAP63IF2IojxABKJAAAmQHv/wolAAHxwOHFz3CA +AGwEoIBr2AQljR8PAADgHg6gAIohSAMvKEEDqg6gDU4gQAQKJQCAyiHCD8oiwgfKIGIByiOCDwAA +EwJQAeL/yiRiAH/YCrjPcaAA0BsToX/YEKEdBAAB4HjxwGvYzg2gAIohCAheDqANBNgKJQCAyiHC +D8oiwgfKIGIByiOCDwAAIgIIAeL/yiRiABkFz//gePHAVguADYDZz3CgANAbMKABBc//SiRAdQDZ +qCDAA89wgADgCTZ4YYBAgM9wgADcCAHhVXhgoOB+4H7geFEhQMfxwB3yz3CAAMwFAICD4Mohwg/K +IsIHyiBiAcojgg8AAEwCyiTCAJQA4v/KJSIAWg0ACAvIvbgLGhgwANmduc9woADQGzGgjQTP/+B4 +8cCB4MwgooAF9M9ygACICgTwz3KAAPCez3GAAFxbgeDMIOKAKfRogmChaYJhoXyKaKl9immpKhKD +AGqpKxKDAGupLBKDAGypdJJ2qW2SZ7F3kmixaILAu3SpaIIEI4MPAAYAAIDjAdvAe3KphBICAFQZ +mAAc8GCBaKJhgWmiaIl8qmmJfapqiSoawgBriSsawgBsiSwawgB2iXSyZ5FtsmiRd7JUEQMGhBrA +AILgBvSeDuAAQCEABtHA4H7xwB4KAAHPdYAA8J4Ahc92oACAJQamApUHpgKFCqYGlQumVgggDgDf +gOAG8uim6abxpvKmAIUVpgKVFqZJAgAB8cDeCQABAN7PcIAAKIUmCCAO1KiA4BTyCN/JdYDlzCWi +kMwlIpHMJWKR+AkiBMogQgNhv4DnAeUy9x3wSiSAfc9xgAAIcKgggAEEGZAD4HgA2UokAHLPcoAA +iFyoIMACFiJAAHaQz3CAAHhwNHgB4WCwz3WAAPCez3eAABR/QCUAEiRv0gngAAbaqXBAJ4ESxgng +AAbaQCUAEkAnARS6CeAABtoYjYTgDvSKIA8KZgugAIohGQ8oFYAQEgngDiiF1g6ADQmFUSBAgQry +iiCHDkILoACKIZoEHgrAB1oPwA2A4OgKQgLPcQAA///PcIAAsHssoCugBBqYM7L/SQEAAfHA3ggg +AQDahCgLCgAhg3+AAFyhWaPPdoAAEEC0aLpmUoIChgAhgX+AAOygz3eAAKxcXqNhhtgZwABlhtwZ +AAAGhuAZwADkGQAAFieAEBYmgRAI4AThrg4gBAja3WUUhRZ+Fn9AJwASJG6aDiAECNrVAAAB8cAA +2OL/dghgBADYz3CAADQF9g1gBATZ0gmABI4OwAIB2ADZ9gygDIDaCglACR4NgA3+CMAH4gyACEYL +AAgA2D4IIA4Icd4IAA5GDYAKBg2ACPkFz//gePHA4cUA3c9wgABIBaCgz3CAAACFrLAiDOAHqXBO +DI//9g8gCqlwDgrABAINAASaD2AKqXBmD0AKUQAAAfHA2g/AAILgo8EG9M91gACICgjwhCgLCgAh +jX+AAPCeguAG9M92gADMiwnwz3GAALShhCgLCgAhTg4tlTx6KHCGIfEPR7nCuoYg/gMkekS4UHHK +IcIPyiLCB8ogYgHKI4IPAABlBMokIgAABaL/yiUCAUiFO7pTIgKAQK5NlcC6Qa4M8neVhiP/CUO7 +Z653lYYj/gdFu2iugOIS8s9ygAAsJBUiAwAAizV6Aq4BiwOuAosErgOLBa4DigvwAdkprgLYAq4j +rgDYBK4D2AWuBq6LcMlxJg0gBAzaAMABwU4I4AoCwotwyXESDSAEDNoAwAHBugjgCgLCz3GAAMQG +AKENlUS44LgA2S+lBfKKIQgAL6XhuAPyi7kvpVEggIAE8o25L6UhB+AAo8DgePHAqg7gAJhwhCgL +CgAhgH+AAPCeViAGBSiAViDFBVEhwICKIQgAyiEhANQYRABKJAByANmoIIAPz3WAABRB/IguZeR+ +LyqBA04igwfPcoAAOEFvYgAmQwDgq1QQjwDkfi8ugRNOJo8X7mLIq8iAUSbAkA/yXYiG4dMipgAv +KoEATiKNB89ygABAQapiEPDPdoAAKEEuZs5lvIjEfWwQjgDEfS8tQRNOJY4XymJQqwHhSiQAcgDa +qCCBANyIz3OAACBBT2PPdYAAOEHkfi8pgQNOIY8H72UAJoEA/KlUEI8A5H4vLoETTiaPF+5lJBmC +A8iAUSbAkA/yfYiA4tMjoQAvK8EATiONB89zgABAQatjEfCA4gPyyWoC8Eh2zmN8iMR7bBCOAMR7 +LyvBAE4jjgfLZSwZwgAB4kokAHEA2qggQAXPcYAAHEF9iElhACWMAAHiZHkvKUEATiGDB89xgABA +QWlhIKzGCKAGiHClBcAA8cA6DcAAguAF9M9xgACICgfwhCgLCgAhgX+AAPCeqYF4iUEtwhDAuhe6 +ACKODwAAgBzkvc8mIhbgvU7azyaiEMoigg8AAE4BhuPPImEC5b0V9M9zgADwns93gAD8oeKXKBME +AZB3DPTDEw8GUSdAkQX0aYNRI0CBAvKBvs9zgADkoWyLh+PMI2KCzCMiggP0g75RJQCSzyaiFYLg +iBmAA4wZgAAF9M9wgACICgfwhCgLCgAhgH+AAPCeaRCCAE4QDQEOIoEPAAA6AQm5Qn0lfTqQQnkS +uSV9O5BCeRe5JX0EJb6fAPAAAMohwg/KIsIHyiBiAcojgg8AAKgAzyPiAsokwgDIAaL/yiVCA5UE +4ACQGEAD8cAmDMAAguAIdQb0z3aAAIgKCPCELQsaACGOf4AA8J4B2WgeQhAA34AewBNM2E4eBBAF +2BCmCtgbthDYGrYU2EweBBAt2FAeBBAm2FIeBBBKJABy6XKoIIANz3CAAGRB9CCDAM9wgADEfFR4 +YLDPcIAAdEH0IIMAz3CAANR8VHhgsM9wgACEQfQggwDPcIAA5HxUeGCwz3CAAJRB9CCDAM9wgAD0 +fFR4YLDPcIAApEH0IIMAz3CAAAR9VHgB4mCwCIbluAXyBNpiHoIQA/BiHsIT5LgK8gnZah5EEC7a +XbYC2mkeghAK8BTaah6EEDLaXbZpHkIQFNlZjlEgAIBZYTB5ah5EEBrhPLYK8grYZB4EEAbYZh4E +EAfYCPAQ2GQeBBBmHsQTBdgQpqlwyf5cjlQeghBsHoIQ5rrKIIEAyiGBAAryUCLDAW94CHFUHsIQ +bB7CEOW6CPIoc4YjAwBveVQewhDkugXypbhsHgIQUSLAgAXypLlUHkIQguUX8qlw//7PcIAAwKGE +LQsaMCBADlEgQIDx2MAoIgHKIIEPAACTAMAoIQGcHgAQGNiNuBemCIbPcYAA8J7juAbyuhGBAIm5 +BPChEYEANqbPcaAArC85gTC5UyEBgM9ygACEBFUeQhAT8s9xAADECSKySiQAcgDZqCCAAoDbz3KA +AGx+NHpgsgHhFPCA2SKyk9kEuc9ygABsfiCyIbIisoojFwdjsiSyZbJmsoohBAAnsgQgvo8ABgAA +C/I2uMC4G3gB4G4eBBAC2IAeABAD8G4exBMA2BymHaapcCb/KIYB2kEpAAU1uVIgAABSIQEAwLjA +uVoOb/9IcxkCwADPcIAAiAoIgM9xpAAcQMC4E3jBuBKh4H7xwOHFz3GAAIgKd5HPcoAAyAbgu1fY +AKID8l/YAKLiuwPyhbgAolEjQIAE8oe4AKLPcoAAzIugigDagOXKIIEAz3OlAOgPBqPPc6AApDAB +g4DlzyDiANAg4QABo89woADsJ0ugUIHPcKAAyBxIoBIJIAsPgZkBwADxwB4J4AAH2c91oADIH0gd +WJDPcIAAiAqAEAAAAN5MHRiQz3CrAKD/2aA6oNigiiAEAA+lz3CAAIgKahABAc93gABoM7AdQBC0 +HUAQH9kIuS6lCIBRIACAANiLuCXyEKUgj+C5ZNjKIIEDUSFAgAanCfIM2H4dGJABhwOnAocEpwXw +fh2Yk8OnxKfPcIAAiAoJgFEgQIEkCcINz3GgAKQwAYGEuBDwEaV+HZiTyXCGCOANyXHDp8SnxqfP +caAApDABgaS4AaGr/44PgAqv/89wAABVVVodGJAB2FkdGJDPdYAAiApuFQERz3CmAOgHJqDSDEAD +jg5gCg2Vz3CAALBlB4iA4GQNggHPcIAAiAqIEAIAz3GgAMQnDxmYgIwQAgDPcKAAMBBEoM9wgADI +dRB4jxkYgM9wgAB0dhB6liACABC4RXiQGRiAiiAEAJIZGIDPcoAAiAqQEgAAQBkAgM9wgADUGFMZ +GIAPEQCGn7gPGRiAD9gQGQCAVRKAAIDgyiCCDwAAvA/KIIEPAAC8HxwZGIDPcKYA9M/DoO0HgADg +ePHAdg+gACjaOnAacYQoCwovds91gACICgAmgB+AAPCeig9gAKlxz3GAAMyLACaAH4AAtKHCD2AA +DNoA3892oAC0D/ymSIVTIgAAZgkgCjSVhP9MIQCgaArhCsogYQADyFEggIAE8vIOwAEJ8ADZnrnP +cKAA/EQhoPymTCAAoMogYgAQD6INyiECAE0HgADgePHA4g6AAAolAJChwQHYEvIDyFEggIAN9Aoh +wA/rcgXYiiNHC0okAABZBG//uHMA2IQtCxrPdoAA8J46cAAmTx4Jh0AmARmEKQsqJbhTIBIAMCFA +DiW4UyAQAOlwEg5gAA3Z/g9gDqlw6YeA5SW/wL8F9APY6Pwn/QPwAg2ADYDnIPJMIgCgyiHCD8oi +wgfKI4IPAAAPAsogYgHG9UYLQAYSD6AAAdhMIACgPfSKIIkGcghgAIohyAbSD6AHANgz8PIOoAAA +2IDlA/Rv/SDwqgyADXIMgA2A4ATyrgyADRjwZgyADYDgFPLPcIAA5KEMiIngzCDigQz0z3CAABBA +GYAE2UDAi3AyC2AAvdpMIACgCfRMIUCgBvQuDIANgOAD8m/9qXBp/o4NIAGpcATYGgygDQMaGDCA +4BL0z3CAAPyhApA0lhBxDPIGDIANgOAv8oDlLfRWDIANgOAp8qlw6XGE/3/ZEbnPcKAAsB80oIoN +AAbWC4ANgOAI9M9wgAD8oQKQNJYQcQj0DcgFIIAPAQAA/AvwDcgFIIAPAAAAPA0aGDANyJC4DRoY +MJoLgA2A4A/yz3CAAPyhApA0lhBxCfQYjs9xgACIChipCYYJoQHeIg3gCclwz3CAAKkGrgvgCcCo +geUT9M9wgADkoQyIieDMIOKBA/SA5wf0iOAH9EoLgA2A4APybguADVIKQAYmDEAAYghgAQDYJQWg +AKHA4HjxwADYd//WCE//+goADqECj//gePHAtgyAAAh1z3aAAPCehCgLCgAmUB4kEAAgUSBAgcoh +wQ/KIsEHyiBhAcojgQ8AALkCyiQhABgCYf/KJQEBz3CAANwKAYiA5QAWAUAx9M9ygABcWyCiABYD +QIDgYaIAFoNAaKoAFoNAaaoAFgBBA/IPtgAWgEAKqgAWgEALqgAWgEAMqgAWgEAAFgBBB7IAFgBB +CLIAFgBABCGADwAGAACA4AHYwHgSqgTYTvw38MIeWBAAFgFAz3KAAOiiwx5YEAAWgUCA4AwaQoAA +FoFADRpCgMxwB/IgkM9wgADAoTuwAvAAkAAWgEDPcYAA7KIaGgKAABaAQBsaAoAAFoBAHBoCgAAW +gEAAFgBBBhkEgAAWAEEaGQSAABYAQK943v1iCyABqXDuCYANgODPd4AA/KEP9AKXNJYQcQvy4gmA +DYDgJvKA5ST0MgqADYDgIPIkEAEgqXAlucC5+f66CYANgOAF9AKXNJYQcQf0DcgFIIAPAQAA/Arw +DcgFIIAPAAAAPA0aGDANyJC4DRoYMHIKQACJA4AA8cAA2Jr/VgkADv0Aj//gePHAANnPcKAAtA88 +oM9woADsJyugz3CAAPSLIaAioOIK4AoocM9xgACwZSCR/9iC4cogog//2s9xqwCg/1mhGKEC2BoK +YAADGhgwrQCP/+B4hCgLCgAhgH+AAOyg3BACAM9xgABYXdgQAwBgGYCA4BACAOQQAABcGcCAbBmA +gOB/cBkAgPHAigqgABLZqcEIduYLYACLcEokAHEA2qgggAIWJIAwKIiB4cP2YbkoqAHiAcICwYQu +CxoAIYB/gADsoNgYgAAFwtwYQAAGwbRu4BiAAMd1gAAQQEgVERDkGEAAz3CAAKxcCiBALhYgQAQI +4IPBSgjgAwja9IXPcIAArFyHwfZ4COA2COADCNoAwAAgjS+AAPCeUSAAgLQdGBAF8rkd2BMD8Lkd +WBRGCIANgOAF9EYIgA2A4APyANgC8AHYEHYQD+H/yiCBA7QVABZRIECA8djAKCIByiCBDwAAkwDA +KCEB9ghgAJwdABABAqAAqcDgeADYiPHxwKXBi3AaCWAABdkAwuC6E/LPcIAAiAoYiIHgDfQA2Jq4 +z3GgAMgfD6EBwKQZAADD2Bq4DqFRIoCAFvIFEgI2ANlKJABy4HioIIADuHGDcSiJESJAgAAiQDFc +GEIACfJAJUEAfghAAKXA0cDgfgohwA/rcgXYiiOPDbkGL/9KJEAA4HjxwOHFz3WAAPCeCYVRIECB +yiHCD8oiwgfKIGIByiOCDwAA2gbKJGIAhAYi/8olwgAODgAKCg1gBwHYz3CAAOShDIiH4B/0wxUA +FlEgQIEb8moPQA3PcYAAeIUEkCWBCrgwcMohwg/KIsIHyiBiAcojgg8AAOQGyiQiADQGIv/KJcIA +8gwP/5oI4AkA2AYNgAnODwAA/QCAAPHAAtgW/dj9WQZP//HAdgiAAADez3WgALQP3KWWCuAJaHf4 +/54LoArpcAPIUSCAgATyKgjAAQnwANmeuc9woAD8RCGg3KWlAIAA4HiEKAsKz3GAANShMCFCDs9w +gACIXFZ4dpDPcYAAXFvEGdwAF5DPc4AAWF3FGRwAz3CAAKxcVngMiJAbAoAA2OB/xxkcAPHAig9P +/3YOQA3aD0//xQVP/+B48cDiD2AARNrPdYAAEEDEbc9xgACwXEIIYACpcEokgHAA2aggAAgUadhg +cYCEKQsKACGCf4AAXKEAIYB/gADsoH6iANt5omGFQoUB4dgYwABlhdwYgABGheAYwADkGIAA7QdA +AM9wgABcW40DIACKIQUF4HjxwGYPQAChwQDdQMUAFo5AABaCQAAWg0AAFpBAgOId8kh3z3GAANiL +I4mGJ/wXRb/DuuZ54LnKJYIQYMXhucolghDKJSEQARxCM1EhgIDKIiEAAhyCMIDgJPTPcIAAXFu2 +iPSIsXPMJsGTEfIKIcAP63JAKwQEEL4F2IojHA0FJEQDfQQv/wUmxRMAxUAgDgbPd4AA8J5UGFgD +hB9AEyHwz3CAAPyhApAQcwr0z3eAAPCewhcAFsC4EHYN8gohwA/rcgXYiiNcD5hzNQQv/0olAAAA +xc92gADApNsfWBNAIEEgSSEBBjR5Ag4gAMlwQiDAJUggAACA4ADby/cA2gAWAUAB4oPivfcB4xBz +uPdWJgAZ2g0gAAbZqgxADYDgCfTPcIAA/KECkDSXMHAO9LIKYADJcM9wgAAEC6KgTyXBF14IIACK +IBINZg0AAH0GYAChwOB4ANhW8fHAocGLcI4NIAAB2QAUBTBMJQCAyiHBD8oiwQfKIGEByiOBDwAA +ggd8AyH/yiRhAM9wgADYiyINIAADGEIBocDRwOB+8cDODUAAz3OAALwLQ4MA3891oAAsILCF0mrU +fn5mpaYEpgHijCICgCamQ6OF9wKD46MB4AKjAQZAAOB4ANjPcaAAyB8YoRmhAdgOoeB+4HjxwFYN +QAAId5pxunLacwoiACEKI0AhCiGAIc9wAADIG6YPIAAKIMAh+nDPcAAAzBuWDwAAG3DPcAAABByK +DwAAz3agAMgfO3AB2BOmBdjPdYAAKAsApeGlDsAgHQAUCaUVhhwdQBQKpRiGGB3AFAulGYYUHYAU +DKWgFgAQEB2AFQ2lpBYAEAwdQBUOpagWABAIHQAVD6XPcAEAHycQpSoPIAAo2BGlIg8gAADYEqVT +J8B1E6UByFQdABcWpRIWAJZQHQAXF6UTFgCWz3GgAMgcGKUUFgCWUyECMxmlFRYAlhC6GqUkFgCW +G6UWFgCWHKXPcIAAzBURgB2lz3CAACgLeBiACs9wgAAoC3wYwArPcIAApAsEGAALz3CAAKQLCBhA +CyiBI6DPcYAAbAUggSSgLyHHBQi5JXovIQcGRXlZBGAAJaDhxeHGQCkNAiV9QC0DFIjipXsIdZD3 +UyV+kAbyAR1SEGG6+/FBKo4AwbpCJk6QBB3QEP31gOIK8i8kiXDgeKgggAEBHVIQ4HjBxuB/wcXg +eChyANnW8eB48cDmC0AACHbPcKAALCCwgAvwKggP/89wDwBAQuIMYAapcYHgDfLPcKAA1AsYgEIg +AAhIIAAAEHYt9xkEQAAKIcAP63IF2Ioj0gmKJMMPKQEv/7hz8cCKC0AAocEacM92oACsLxmGBCCA +D3AAAADXcCAAAAAB2MB4LyYH8Ch1AN8T9IogSQaSDe//iiEMBjmGhg3v/4ogCQaKIAkGeg3v/6lx +6XAr8A/MABxEM08gwQMB4BB4j7gCHEQwDxocMM9woADUCziAQiEBCIDhyiHMA0AgACIQcSwPxf9A +IMAhBCCADwAA/P8FIIAPgK4AAOxxAKEAwexwIKAB2EkDYAChwCK5BvDscmCiBOBhuYHhYIA69wDZ +z3CgANQLbaDPcKAARB01oOB+4HjxwL4KQAAIdih1KHBIccj/geDKIIEDxA/h/8ohQQMNA0AA4HjP +c9C6/srPcp8AuP9+ohqiO6LPcKAAOC4FgAQggA/AAAAA13DAAAAA9fNp2Bi4GaLgfuB48cBiCkAA +CHfPcYAAxAQIiQDegOCpwUDGQfQB3aipz3GAAABoz3CgAMwrLaAA2I+4DxocMB0agjMeCqAKi3De +D8AFz3ABAB8nQcCKIFQAQsDPcIAAQE8AiGTFAt0RHAIwAMASHEIzExwCMM9wgAC8C0XAz3CAACgL +RsDPcIAAbAUAgEPGINlIx0fAgcAB2sf/CNgB2c7/AxpYMzECYACpwAPaz3GgABQERaHPcaAA1AsN +oeB+8cDhxQPdANvPcqAA1AuxonCiz3WArhgA7HKgogLaHBqCMAcSDTbscqCiDxICNwHiDxqcMOxy +AKIBEgI27HBAoOxwIKAB2M91oADIHxOlOIXscCCgGYXm/3Qd2JDPcaAAyDsOgYi4DqG9AUAA8cAA +2AQSgTDj/wQShTAKIcAP63IH2IojkQG9Bu/+SiQAAOB4ANoD8AHiQSiBADByvPfgfs9xgADMFUQZ +wAeduJ64z3GgAMgcDaHgeOB44HjgeOB44HjgeOB44H4D2s9xoAAUBEWhz3GgAPwLDKngfgPaz3Gg +ABQERaHPcaAACAwAseB+A8zXcAAAAEDKIYsPgK4EAMohig8ArgQA7HAgoM9woAAUBAPZJaAByM9x +oADUCwDaDaHPcKAARB1VoOB+gOFU8kAhwgPDuY/hnAAtACS6MyZBcIAAfEBAJ4NyNHsAewAWAUAE +GFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQY +UAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQ +AAAWAUBCIkKABBhQAL/14H7geIDi4cUi8mNqwbqD4jwALQAiuzMmgnCAAIxAQCeNclR9AH0EEAIE +BBmQAAQQAgQEGZAABBACBAQZkABCI0OABBACBAQZkADv9eB/wcWA4uHFU/JAIsMDw7qP4p4ALQAk +uzMmgnCAAJBAQCcNclR9AH0BEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIA +ARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgAB +EIIEARmSAAEQggQBGZIAARCCBAEZkgBCI0OAARCCBAEZkgC+9arx8cDiDgAAKHZGIc0AHWUiuZP/ +wb6B5g7yguYI8oPmDfQAFoBAAR0SEAAWgEABHRIQABaAQACtGQcAAOB4gOHKJE1w4HjoIK0BABYB +QQIYVADgfuB48cCODiAAUyFCAE4iDQEgEgI2z3agABQEyYYA28J6UHHKIcYPyiLGB8ogZgHKI4YP +AAAZAsokZgDkA+b+yiXGAIDhyiRNcMoizQDoIG0CTmDPcaAAOAQB4sipgeUN8oLlB/KD5Q30z3Cg +ADgEaKjPcKAAOARoqM9woAA4BGiofQYAAOB4z3OfALj/GqM+o8K6BSKCDwBsAABZo+B+z3KgADgu +RYIEIoIPwAAAANdywAAAAADbC/LPcp8AuP8aojuiadgYuBmiAdgC8Ghw4H7geM9y0Lr+ys9xnwC4 +/16hGqHPcKAAOC4FgAQggA/AAAAA13DAAAAA9vNq2Bi4GaEcgeB+4HjxwIYNAADPcIAAsGUAkIbg +AN4a9AXYCbgaGhgwGxoYMBwaGDAdGhgwCdgIuB4aGDAfGhgwiiAQACAaGDCKIAgAIRoYMADdCNjP +dwAABB2YcBUiQDMaEAEGANjPcqAAFASqosiiJ6IEoj5miOFoucohDgDpcJ/+QiRAAIDgIOcB5Sf3 +bQUAAOB4QSmBgAryLyRJcOB4qCCAAQQQAgTscUCh4H7gePHA5gwgAADaCHUods9woADUCziAQiEB +CIDhyiGMAEAmABIQcdwIxf8HbgQggA8AAPz/BSCAD4CuAADscQChAcjscQChIr4G8OxxAKEE5WG+ +geYAhTr3s/75BAAAB9nPcqAA1AcaGliAgOAO8hkSAYYJIEMADxIBhgIgwIB5YQ8aWID29eB+4Hih +wfHAz3OADggA7HJgouxyAKIocKH+0cDgf6HA8cA6DEAKXgxACtHA4H7gePHA4cXPcIAAsGUmiIDh +RPIniIDhQPKgkEptiOIJ9zMmgnCAAKBAQCeBclR5AHkA2SXwJJCA4Qf0JZCB4cwhooAD8gDZAvAB +2QLdGfAkkAXdgeEB2cB5E/AkkATdg+EB2cB5DfAkkAbdguEB2cB5B/AkkArdhOEB2cB5geEM8ggQ +BQEKIcAP63IQ2IojDg81Ae/+mHURBAAAocHgf6HA4HjgfuB48cCOCyAAuHHPcoAAqF0FuTAiRABR +JECDosEG8s9zgAB4ogXwz3OAAJCfQCMCBkAjAQdRJECCyiHCD8oiwgfKI4IPAAAoBNgA4v7KIGIB +z3aAALBhQC2NAaZm6L5AxiDFBPLCvaphD/BRJkCSB/JEJQEcRLkqYom6BfBTJcEQPHkqY89xgACw +YBYhQQEiiQ65RXkgoGUDIACiwOB48cDmCgAAOnAacUh1aHBGDCAGCtlhaCpwR/+keAQlARQwcBXy +INrPdqAAyB9QpgrYQx4YEADYjbhq/lGmYbuMI/+PAN8p9ulwAvAB2PkCAADxwJoKAAAacADdNNg2 +/1AgQQQ02P39NNgz/08gAQWVuTTY+v2pdwTwqXcIdQPYCrgQdX4ABgAybQQhgQ8AAPz/LNjy/SzY +AdnPcwAAiBMoctj/gOAt8izYI/9BKA4ENNgh//W4GvT0uAvyNNge/08gAQU02OX9R9haDK//AdmA +5hHyqXCAIBAA13AAAAAMwiBhABB2yvMN8EfYOgyv/wLZB/CA5Qf0RtgqDK//ANkA2ATwABjEIwHY +RQIAAPHA2gkAAAh3CHYodRpyMNgG/whxhiEGADDYzf002AP/UCBBBDTYyv002AD/TyABBZW5NNjG +/RHw9LgM8jTY+/5PIAEFNNjC/UfYzguv/wHZAh1UFAHmACDAIxB2QAAGADJuBCGBDwAA/P8s2Lj9 +LNgB2c9zAACIEyhyn/+A4A7yLNjq/kEoEQQ02Oj+9bjW80fYhguv/wLZANgD8AHYnQEAAOB48cA+ +CQAACHXPcIAAxAQBgCh2geChwUh3F/SA4wzyi3Cg/4DgANgl8gAUADEB4LhgEHgH8AAlgB8AAAAM +EHjJcelyx/8V8IDjDvSWJQIQsH0K8M9woABgHbKwFJAB5bB9Ah4UEGG/jCf/n/X1Adg5ASAAocDx +wAHbMNjD/lMgggCE4ghxC/czJoJwgACsQEAngHJUeAB4aHAF8NoKr/9I2ADYgODKIcEPyiLBB8og +YQHKI4EPAADMBcokIQAUBqH+yiUBAc9zgADEBDTYrv7wuAHYyiAhADcE7/8Bo/HA4cUIdc9wgADc +CgGIgOAQ8gTwpgyP/s9woADUCxiAANlCIAAIgODKIEwAEHU096kAAAD8HIi2/BxItvwcCLb8HMi1 +/ByItfwcSLX8HAi1/BzItPwciLT8HEi0/BwItPwcyLP8HIiz/BxIs+B+4HgE3DjdNfDgeATcNN0z +8OB4BNww3THw4HgE3CzdL/DgeATcKN0t8OB4BNwk3Svw4HgE3CDdKfDgeATcHN0n8OB4BNwY3SXw +4HgE3BTdI/DgeATcEN0h8OB4BNwM3R/w4HgE3AjdHPDgeATcBN0Z8DQUGjAwFBkwLBQYMCgUFzAk +FBYwIBQVMBwUFDAYFBMwFBQSMBAUETAMFBAwAscBxrAkTTOwJB8z4H7gfuB44H7geOB+4HjgfuB4 +ANmWuc9woACsLzyg4H7gePHAocGLcKYOr/8B2UDYmgrv/0DAWg6P/6HA0cDgfuB48cAKIcAP63IF +2DDbiiTDD40Er/64c+B44H7geOB+4HjgfuB44H7geOB/AdjgfuB44H7geOB/AdjxwM4Oz/8Ids9w +oABkLvAgjwMZEhA2GRqYM/XYBbgiDK//yXEZyM91oAAUBAqlCYWA4NQOQgXPcKAAwC9REACGCyDA +g/X1z3AAAGQezgjP/xEggIPt8wmFgODr9RkaGDT12AW42guv/wpxGcgKpcUGz//gePHAog2P/+UD +j/7geJUFj//xwFIO7/8A2UokAHLgeKgggAIAFgJAFSJAMBoYmAAB4QAWDUAAFg5AogjP/89woAAU +BKygz3CgANQL3KBWDY//fQbP/+HF4cYkiM9ygAC0QKaIwrkuYgDZDyGBA4Dlz3OAAPxwdhMCBgX0 +Jnp2G5gAHPBFeXYbWAAliBUjjQN5HVgQJohFiFlhfB1YECCAjCEQgEX3iiEQACCgI7l3G1gAAIAq +uHgbGAAA2c9woADwNiygeRMBBiWgfBMBBiagehMBBiegfRMBBiigexMBBimgfhMBBiqgdxMBBiug +eBMBBi2gdhMBBiSgwcbgf8HF4HjxwOHFosGLdalw1gyv/wLZqXDR/44Mj/+9Be//osDgeIDg8cAH +9M9wgADUckoJr/8k2dHA4H7gePHAJg3v/5hwkODKIcYPyiLGB8ogZgHKI4YPAABUA5wCpv7KJSYE +ANpKJAB0z3aAANAEqCCAD0AsgwFVe8dzgACwYSCDz3WAAKhdQCxAAd25AGUgo/G40SEiggnyoIvP +d4AAvECtZ4HlCvbPdYAAsGAWJQ0RoI1RJQCQBPKeuRbwLbjAuBUmDxDjh1IhTQILJ0CTDfLPdYAA +EJ+EKAsKMCVAHv647POfuSCjAeLhBM//8cBmDM//osEAFhFBABYAQUApTSHHdYAAqF0AhUwhAKQt +uFMgEgCO9wohwA/rcgXYiiPVB0okQADRAa/+CiVABM9wgACwYBYgQAQacKoLr/8C2c9wgAAwYRYg +QASaC6//AtlAKZMhACOAL4AAsGGKC6//ENmLcIILr/8B2QCFUSBAggfyNguP/zUE7/+iwAAjgC+A +ALBhrgrgCRDZARCAIJDgyiHKD8oiygfKI4oPAACMBYQH6v/KIGoBSiQAdADZqCBBCxUjQCDPcoAA +sGEwIgUABCWOjwAAAAEEHEAxS/Ihw89wgAC8QAQljQ8GAAAAQS1CFG9goOP4YtEl4YIP8oDmBPKB +5w32BCWEDwAAACQMJICPAAAAJAP0ANsp8ILiPfeC4gX0gOb584Ln9/WA5gPyzOMz9oDmBfKB58P2 +gOXt9c9ygACwZUaSUHcn9lElwIIO8s9zgAAQn4QqCyowI0IOBCK+jwAGAADZ8wHbb3sD8AHYCHME +JYIPAQAAwC66z3WAAABESmVQcAHYwiANAIDjzCAigBLyAeECEIAgz3GAAAxBCGGB4B3yCiHAD+ty +BdiKI9YIEfDPc4AAEJ+EKgsqMCNEDgohwA/rcgXYPQCv/oojFghKJEAAMQCv/kolAAADEIAgCGGC +4Mohwg/KIsIHyiOCDwAApQUF2O31KnBU/89wgAAwYRYgQARAkM9xAAAYFQkiQQAgsDbx8cDPcIAA +0ASyC6//AtmSCY//HwXP/+B44cU1aM9ygACoXSFiz3KAABCfLbnAuYQpCwowIkEOUSEAgM9xgADY +i0GBxSKCDwAACgLFImEDSiQAdADbqCCAAjZodXkAIY0PgACwYUClAeMO2c91gACwYBYlAhAgqgDb +YaoB2SKqA9kjqkokAHFocagggAG6YRZ6ZKoB4eB/wcVlA8//YQPP//HAABYAQIHgz3GAAHAWAKEN +9AAWAEAMuAQggA8BAADwAaEAFgBAAqER8ILgABYAQAv0RiDCAEOhABYAQM9woADQG16gA/AAFgBA +A8zXcAAAAEDKIYsPgK4IAMohig8ArggA7HAgoAHI7HEAoY4Pb/8B2ADZz3CgAEQdNaATBM//8cDh +xQAWAUChwUDBARSAMFEgAIAF8s9ygABYfATwz3KAAHB8IKJgigHZCPAAFgBAFSJMAACkAeF9eBBx ++PdRIwCACPIAFgBBFSJMAACkAeGF4QDdB/cVIkwAAeGF4aCk+/fPcYCuCADscCCgAcjscQCh5g9v +/wKKz3CgAEQdtaAxAe//ocDgePHAABYAQAAWAEAAFgBAABYAQM9xgK4IAOxwIKAByOxxAKHSDm// +AtgA2c9woABEHTWgVwPP/+B48cDhxc91gADQBARtkgmv/wjZAYXPcaAAuB4CoQKFA6GeD0//zQDP +//HA4cWhwQDdQMUAFgFAABYAQIHhDfLPcYCuDADscCCgAcjscQCh7HCgoKlwE/AaCCAKi3AB2s9x +gK4QAOxwIKAByOxxAKHscECgAMHscCCgSHBCDk//z3CgAEQdtaCe8fHA5g+P/wogAKBacQDdFvIK +cS8oQQBOIIIHz3CgAAwtT3rwIIAAwrgPJQ0QANgPIIAABiEBgO/1gOXPd6AAFAQl8i8oQQNOII4H +GRqYM/XYBbgODW//yXEZyM9xoABkLgqn8CERACmHvglv/9rYSnBGCWAFBCEBJL4PoALJcADYDyCA +AwYlDZDd9QfYCgkgBBkaGDAZyAqnqQeP//HAUg+v/wjZosEBEg42z3WgADguHBUQEGIIr/+LcAAU +BDAA3wQkvo/w/wAAyiHCD8oiwgfKIGIByiOCDwAASgaoBGL+yiXCAFEkQILKIcIPyiLCB8ogYgHK +I4IPAABMBogEYv7KJcIA56V+DaAMP9gAwAQUATEHpYK5u/8cHQAUGg5v/wEamDMtB6//osDgeOHF +4cYA3s9zoADAL6UbmIMP3Qi9oxMChqR6jCIQgPzzFBuYgxQbmIOjEwKGCyJAg/z1FLgFeaQbWICk +EwCG/7j98yEBz//gePHAbg6P/wfdz3CgAFQuK4DPd6AAwC+lFxKWFBcRli8oQQBOIJMHz3agABQE +qqaA2OL/89gFuIDZsgtv/5+5GRIQNvXYBbimC2//qXGqphkaWDME8APYBaaphoDlG/KA5frzQS2A +kAryLyQJcOB4qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKggQAEAFoBA4Hiphufx89gyCK//Bbj/uOH1 +9dgFuEoLb/8KcRkaGDQoHgAUz3CgABgs8CDBBM9woABoLBUgwAQgoEArACHHcIAATG41gFaAJXo3 +gBiARXkFIESAyiHCD8oiwgfKIGIByiOCDwAA1AYcA2L+yiUiAIDZz3CgANAbMKClH5iUFB9YlLkF +j//gePHAXg2v/xfZt8FKIUAgAN7aDG//i3AMFJAwz3WAADQFTCAApMohxg/KIsYHyiBmAcojhg8A +ALADyiRGBMACZv7KJQYEIMBRIACAb/QSwO24yiGBIwTyz3WAADgFz3eAAKhdQChOIcBn/mZRIECC +yiHBD8oiwQfKIGEByiOBDwAAvgPKJGEAeAJh/solAQQBwALBCnK+DeACZm6A4EHy/9pHrkokAHEA +2aggQAMoZQAhgw+AAChdFiMDBASrKGUB4QCrDRSAMEUgwAANHAIwiiD/D1PAAIapuACmEsCGIPsP +KLgMrkokAHQA2KgggAL7YEAoQSEQ4ztjQKsB4AEUgDAIrgIUgDAJrs9wgACwBBUgQAQggA8hAQQg +oAHfAvAC3wpwgv4N8EAoTiHHdoAAqF0AhlEgQILKJ0EUyiciEoHn2gICACCGz3CAAIgKGIhacYHg +hiL7LxLyZgqADIDgIIYZ8s9wgADkoQyIh+AT9EEpQANRIACAD/ITwOi4EsIL8oYi+w9BKgQCTI6Q +cgPyqLhTwBAUADGGIPMPQigRAhPAEsIGeUR4JXgApkwiAKAIcYYh+w8J8oDhB/QKcADZYgqgDA/a +AIYA2c9ygADIXxYiAgT1uCCiIaIE9ADZi7khova4BvIBgoUgAQ4BohAUADHruIoiwy8E9B4UkjAN +FIAwUSBAgQ3yWBQAMQW2gODKIAIEyiEiAAgKogzKIuIDDRSAMFEgAICx8gCG7bgK8s91gAA4BYog +VQJmDS//iiGQDxAUADHjuD30IIbruRTy/9gHrkokAHEA2aggQAMoZQAhgg+AAChdFiICBASqKGUB +4QCqW/BMIQChjfYKIcAP63IF2IojUQRKJEAAdQBv/golQATuuAeOMiVBFAAhgi+AAChdFiICBAny +JKoE2QApQQQleAeuPPAgqg8gQARh8EwiAKSR9owiw68b8gohwA/rcgXYiiPRCUokQAAlAG/+CiWA +BKYJIAOLcBAUADHuuAbyAhSBMCmuBfABFIEwKK4ghuu5GvIA2EokAHEHrqggQAMAIIEPgAAoXRYh +AQQEGYIEABmCBAHgARSAMAiuAhSAMAmuK/BMIQChyiHKD8oiygfKI4oPAACHBD4H6v/KIGoB7rgH +jgAhgS+AAChdFiEBBAnyBBmCBATZAClBBCZ4B67e8QAZggQA2Q8hQQQmeAeuARSAMAiuDRSAMFEg +QIAa8lAUADGA4AK2FPIA3RDYOnAClhEgQIPKIAIEyiFCA3AIogzKIkIDQiFAIIDgAeUx9w0UgDBR +IACBBvIjwGoLIANVFIEwDRSAMFEgwIAd8jXBVhQCMQpwxgsgAxLDuHCMIAKAyiHBD8oiwQfKIGEB +yiOBDwAA3wT4BiH+yiRhAFElwIHKJyIRCnAL/c9xgK4IAOxwIKAByOxxAKGCDy//6XAA2c9woABE +HTWggQGv/7fA8cAiCa//AdmkwUohQCCeCG//gcAA3lLwgsCSCG//AtkCwItyWgjgAgPBBCBABC8h +B6BD8gDAANnPcoAAqF0PIQEABbgAYs9ygABIBWCCMn8tuFMgEAAEJ8CQAKIG9IDjqA5iB8ogIggg +wI4KIAMQ2QDAAN01aAAhgg+AAKhdiiEIAKKyIKKpcVYPYAwP2s9wgACwBBUgAAQggOR5IKAAwc9w +gADIXzZ4oKChoM9wgACoXzR4oLAB5iHAEHZcB8X/z3GArggA7HAgoAHI7HEAoXYPL/8qcK0Ar/+k +wPHAIg+AAo4PD/8bA4//4HjxwDoIj/+EKAsKz3GAALAE8CEOAAAhj3+AAPCeSIcEIoEPgAAAAEQi +AwIvuQa7JXsEIoEPAAEAAEEpTQMsuWV9JX3PcYAA0AQVIRAADBAAIBB1M/IEIr6PgAEAACDyz3CA +AOShDIiH4Br0Kg5ADIDgFvIIh764RCABAgQggg+AAAAACKcEIIAPAAEAAAa5L7pBKE0DRXklfSy4 +BX2A5gwYQCML8i8pgQNOIYAHECYOEJr8gOb49ekHT//gePHAosGLcKIIb/8I2QDAgODPcYAAnAQA +oQfyBhQAMQOxBBQAMQKxog4P/6LA0cDgfvHApMGLcHIIb/8Q2c9xgK4IAOxwIKAByOxxAKEAwFEg +AIADwAb0AsH2C2ADANoF8EoNIAQBwV4ND/8A2c9woABEHTWgpMDRwOB+4HjxwAYPT/86Dm//AN5/ +2M93oADIHxkfGJAB2AhxCHKKCy/+CHPPcIAAFADXcIAAFAAL8gohwA/rcgXYX9uKJIMPWQQv/rhz +z3WgANAP1aUaCoAGegpP/0DZz3CfALj/MqAiCU//gNnPcKAAFAQsoB0dWJCaC0AGAgjABbIKYAbJ +cKoLIAkD3s91oACsLxiFmrgYpRLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhvowm +/5/u9RiFs7i6uBilB9hIHxiQxg7P/i4MwAiyC8AITgnACRqFwLiB4AHYwHgvJgfwBfKOCWAJAd4F +8APeGIWauBilMg7P/t4MgAKKDgADz3CAADQFrgvgAgTZdg/AAhIIQAOWDoAHlgoAB+4NwAt2DEAM +AgxP/oogxg3PcYAAiAoNsQPYbRkCABvZz3CAAHAj/gtgATCopgsABXIOT/+yDIAIsgzADB4LQA1y +CQAKQgsv/8lwAQZP/+B+4HjgfuB44H7geOB+4HjgfuB44H7gePHACiHAD+tyBdha24okgw8BAy/+ +uHPgePHAYg1P/xpwKHfPdoAAiAoUls91gADAZRC4VgngBwClgODKJyIQz3GAruQB7HAgoOxxABkA +BAiGUSAAgATyAIWBuAClz3CAAMAGAIiA4AX0AIWDuAClz3CgACwgEIAA3kokwHBtHRgQyXCoIAAE +z3GAACisRCi+AzMhQQ4AIIIPgABAZwHgIKqA5x7yAIViFQ8WqXJjFQQWgLgApQDZB/DscwCjBBqQ +AwHh9+EAgrr3z3GgANQLDaHAomId2BNjHRgREPAA2alzBfDscgCiBOMB4ffhAIO7989xoADUCw2h +5QRv/9QdgBPxwOHFocEIdToOL/4T2M9wgADkBACAgOAj9M9woADUCxiAANlCIAAIgODKIEwAjCAH +ikn3z3GAAEgWCYEB4AmhD/Cd2AAcBDAPzAIcBDAB4BB4j7gPGhwwAMCpca//FgkABZUEb/+hwADY +zPHxwOHFABYNQAHIUyUBEKj/USVAkM9xgADkBAHYyiAhAGkEb/8AoeB48cDhxc9zpwAUSADZKKMH +g89ygAD4ch+iEIPPdacANESAGgAAz3DzD//8J6MQo6DYmrg2o/UdGBDPcKUACAwIEAUATCUAgMoh +wg/KIsIHyiBiAcojgg8AACQDJAEi/sokIgDPc6QAuD2bEw0Gu6KmEw0GvKKSEw0GvaKjEw0GvqJQ +3aKgmxtYAP/YphsYAJIbGACjGxgAz3OkAOz/z3AAAP//J6MGowHYz3WgAMgcEaWKIMQAz3OgAOwn +BqMKg2QaBACKIM0ABqMKg2YaBADPcCgAAgEGo4ogjQAGozGlhQNP/+B48cDhxQhyAd2A4cohwQ/K +IsEHyiBhAcojgQ8AAMQAyiQhAHgAIf7KJQEBgOJE9lN6iiX/H4DhRPYzebN9FCGAAEoMYAU7eax4 +NQNv/y9w4HjxwJ4KT/96cJpxGnI6cwolACEA2s9xqwCg/1mhB9gaoVihIN/PdaAAyB/wpQHeQx2Y +EwDYdgkv/4248aXPcKcAmEfaoN4OYAke2M9xpwAUSB2B3oH7gXAREgAAGAAgABmAI/e4xSCCDwD/ +AADTIOEF977FJoIfAP8AANMm4RWKIRAAzP8IdclwiiEQAMn/CHZALwASiiEIAMb/CHdAKgAiiiEI +AMP/sXkZ4Sx5L3HRehniTHovcjB3ABtAIwAcgCOD9gDYBPBQcH32AdghAm//AB0CIPHA4glv/wDZ +z3OgALQPvIM8o89wgAD4cmQQAgEQuk8iTgCIvs9yoADsJ8aiZhAOARC+hSaNEMai34DPd6cAFEjH +p4AQDgDQp892pQAIDCKm+4DPdqQAuD2bHtgT/ICmHtgT/YCSHtgTHoCjHhgQz3CkAOz/JqCKIIoA +BqK8o84M4AEB2MUBT//xwDIJT//PcIAAsGUHiIDgfAQhAKvBz3CrAKD/ZBAXAM9wqwCg/2gQGADP +cKsAoP9gEBkAB95P/wDZz3CrAKD/OaDaoDigVg+gCAHYANjPcacAFEgMoQ2hDqEPoc9wAAABKs91 +oADsJwalz3ClAOgPx6DPd6AAyB8g2BCnBdhDHxgQANjKD+/+jbgg2BGnAdnPcKAAtA88oM9wAAAC +Lwalz3AAAMIwBqXPcAAAQkgGpc9wAAACSgalz3AAAAJiBqXPcAAAwmMGpUojACDPcIAAsGUkkAWQ +RCm+BxhgFXgVI8EkJ3AZYcdxgACAFgMRkgAEEZQAARGQAAIRlgAAiRC4BSCADwAAQi0GpQCJELgF +IIAPAACCRgalAIkQuAUggA8AAEJgBqUg2BCnBdhDHxgQANgeD+/+jbgg2BGnANgQ8M9wgAB4cRYg +QAREGIABIYZIGEABN6BYoEAhQCA6cM9wgACwZQaQMnCOAg4Az3GnABRIXBlABEAoACRPIEEAh7mJ +uSalCHGFIYsAJqWFIIwABqVMIQCgQCQVOhTyTCFAoBzyTCGAoCb0QCoAJAUggQ8AAIJgJqUFIIAP +AABCYhnwQCoAJAUggQ8AAIItJqUFIIAPAABCLw3wQCoAJAUggQ8AAMJGJqUFIIAPAACCSAalINgQ +pwXYQx8YEADYUg7v/o24INgRp4twgcGIwonDCiRABSX/CMFAKUAhACCOD4AA/HAJwCCmAaYAwBim +AcAZpkAuACSFIIoABqUg2BCnBdhDHxgQANgKDu/+jbgg2BGngsCDwYjCicMKJEAFEv8IwEwhAKAC +pgnAA6YCwBqmA8AbphTyTCFAoBzyTCGAoCb0QCwAJAUggQ8AAIJgJqUFIIAPAABCYhnwQCwAJAUg +gQ8AAIItJqUFIIAPAABCLw3wQCwAJAUggQ8AAMJGJqUFIIAPAACCSAalINgQpwXYQx8YEADYeg3v +/o24INgRp4TAhcGIwonDCiRABe/+CMAGpgnAB6YEwB6mBcAfpiDYEKcF2EMfGBAA2EYN7/6NuCDY +EadAKAAkhSCKAAalhsCHwYjCicMKJEAF3/4IwAbDBKYJwHymBaYHwADBHaYCwAIgQgAEwVtjAiNF +gDryInhMeC9wqHHA/gLBQCuOINR+FSZOFAJ5x3aAAPhyAcADwiGmB8MCIgEABcA7YwIjBYAq8gJ6 +LHovcKhxs/4DwQTDAiECAALAR6YCIwaANB6AESHyBcACIEWAnAXi/0weQBEKIcAP63IF2IojRQ0I +8AohwA/rcgXYiiOFCiUD7/2KJIMPCiHAD+tyBdiKI4UL9vEKIcAP63IF2IojhQyKJIMPAQPv/Qol +gAFAI1MgTCOAoNAExf8A2M9xoAC0Dxyh2/7qcM9xqwCg/xmhaBkABmAZQAZKJABxANioIAANCHGA +IYINMHkGuYG5l7kmpQhxgCFCDzB5BrmBuZe5JqUIcYAhxAYweQa5gbmXuSalCHGAIYQIMHkGuYG5 +l7kmpQhxgCGGADB5BrmBuZe5JqUIcYAhRgIweQa5gbmXuSalAeDlBC//q8DgePHAtgwv/5hwocHP +coAA6AQgis9zgAD4cgGChBMDAJBxzCDBgOrycHAG8s9wgAAQdCGIIKpKJMBwSiAAEKggwALPcIAA +EHQyIAACkHAD8kAgSBBMIMCQpAEGAM9wgAAQdAGIkHAG9AQhAQEvJUcABvAHIAABLyUHAGGiANvP +cKAAtA9wEBIAfKAAGgIBFPBAIIAhEHgGuIG4QCkBJCV4BqZAI4ERMHkGuYG5QCoAFCV4BqYB489w +gACwZQaQEHMyAQYAANkPIcEACyFAgQHYyicCAA30CyEAge3zz3CAABB0AYiQcOfzCicAAoDjEfKB +42fyguMG9IoghiCKIUYCDPAKIcAP63IF2IojjwNk8Lbavdkacnlxz3agAOwnSiEAIEokAHEKIkAU +KnWoIIECACBBI1RrQC8AARR4GmK1esdygABwcwiSMHlAKYkBTyFBEBx/EL/leSamwLi4eAUgQAQv +IQggACNPEwmS8H8Gv08nRhAceUApEwQFI4EhJqbAuLh4BSCBAi8iSBBFIcAQBqYKhotxALEIki8m +AQAAFAAx0HAU9EUnzxDmpgqGALEJkgAUATEceDBwFPQB5WnxiiLEBoohhAin8QohwA/rcgXYiiOP +CEokAACBAO/9CiUAAQohwA/rcgXYiiMPCfTxz3GgALQPcBmABBUDL/+hwOB4ANnPcIAAEHQgqCGo +4H8iqPHAjgoP/67Bz3CAAIgKCIDPdYAAgBbAuEDAz3CAALBlJJAFkEQpvgcAwRhgFXgncDV5OGAZ +ZSOJQcEZZSSJuGACiELBQ8DPcIAA+HJqEAEBz3CAALwGQJBQcUokACAo9M9xgABwIw2JhiD/AXto +z3CAABB0wIgCI4ODzokvicojYgCGJv8R+27BiAKIhiH/AUO5DibOk8omYhAOIECA237KIGIAxXsC +uGV4A/AH2IDgpAMhAETAz3CgALRHRxAAhoDglAMBAM9xgABwIw2Jz3OAABB0hiD/AUO4AKsOiYYg +/wFDuAGrD4kA2Z65hiD/AUO4AqvPcIAA+HJqGIQAz3CgALRHUxhYgHH9z3CAALBlJJAFkM93oADs +J0QpvgcAwRhgFXgncDV5OGAJZRC5BSGBDwAAQi0mpwllELkFIYEPAACCRianCGUQuAUggA8AAEJg +BqfPcKcAFEgMgM9xDwAA/M92gAD4ckXAAMACuBR4ACYEEB1mG2YaZgAmBRAeZgmGBBQEAKeFBcZI +goDmYoMMFQUAH/JALI4CJH7JvaV+z3WnABRIzaUKu2R5ybpFec9ypwAUSC6iQC2BAgQhgQ8PAAD8 +ybgFec9wpwAUSC+gHvAKvSR9iHbJvsV9z3anABRIraYKukR5ybtlec9ypwAUSC6iCrgEIIEPDwAA +/KhwybgleM9xpwAUSA+hSiAAIAPYRsAKIgAlBMARIACECgIBAM9xgAAQdDIhAAQCcUfBz3GgALRH +YBkYgBC4m7jPcYAAzIsgiZ+4gOEB2cB5D7kleM9xoAC0R18ZGIDPcKAAtEdxEACGBCCADw4AAAAx +uIHg9vMA3QPwAeXPcIAAsGUGkBB1ogEGAAfAAIgRIECD9PMBwQLAgOUCIFkAAMACuBR4SMDPcKcA +FEi3oArygeUN8oLlEfSKIIYAiiFGAgvwiiSCLYoiQi8H8IogxAaKIYQImnBacUojACFqdkAtWBFh +vgPBFW4leBB4ELiFIIoABqcAJgAVEHgGuIG4l7gGpwAmgBQQeAa4gbiXuAanQCSAIRB4BriBuAan +QCKAIRB4BriBuAanQCQEPYnAisGLwozDNP0twIDgDfTPcIAA+HJoEAABz3GAAPhyAeAQeGgZBAAF +wIDgEvKJwCCAisBAgInAQKCKwCCgjMFAgYvAAICLwUChjMEAoRYggDMJwQAglg+AAPxwCsDwHkAg +9B4AIAghgA///wH/LyVAJgQtPiAIwBUgUQMAIYAvgAD4ci2AL3AA/Q4glw8AAAABCsCIIHwABCh+ +BQAhgC+AAPhyM4AvcPj8DiCCDwAAAAEJJ4EvAAD/AQkigA8AAP8BSCEBAEggAAAtwlQeWCCB4lUe +GCAM9FRtQCgDIXR7emLVesdygABwcyiyCbJCI1MgTCMAoMAGzf8q8QbAYbiA4EAgUCDoBe3/RsAK +DIAEJ/3PcKAAtEdxEACGBCCADw4AAAAxuIHg9vN5Bu/+rsDgePHAocGLcHoPr/4E2QDAUSAAgPAM +gv8AwFEgQICIC8L/AMBRIICA1AqCCQDAUSDAgDgNggkAwFEgAIHAC4IEhgmgAQHYz3GAruAB7HAg +oAHI7HEAoc9ygAD8cIokgX0A2aggwAHwIkMA7HBgoAHhLgyv/gDYocDRwOB+4HjxwN4Nz/7PcKUA +6A8HgM9ypAAMQlMgBIBEII0ARCADAQKCz3YPAAD8CHHJucR444IquNh3xH9BL4US5IJTJkYC6XLJ +uuR+Kr4G8p7hhPeMIU+IxPcA2QPwAdlMJACABPKe4ET3ANgG8IwgT4g89wHYgOUbeCV4BfJMJoCH +Q/cA2QXwjCZPiD33AdmA5QK5BXkE8kwlgIdE9wDYBvCMJU+IPPcB2IDjA7gFeQTynuJE9wDYBvCM +Ik+IPPcB2IDjBLgFeQTynuZE9wDYBvCMJk+YPPcB2AW4JXhCIACAaQXv/sogYgDxwP4Mz/7G/4Dg +CfTPcIAAkAUAgIXgpAAFAM9yoACsLxqCwLiB4AHYwHgvJgfwAN1E8s9wgADwcymAz3aAAPSLAeFg +himggOMjhjV4BfIqgAHhKqAE8DiAAeE4oBiCmrgYonX+GIKzuLq4GKL+D4AIoaYuCaABoqbPcKAA +eEUAgAQggA8OAAAAMbiB4Pbzz3GAAIgKSIE0kVMiAADqC2/+AdteDgAIgOAI8p3/gOAG8voNr/0O +2AXwBg6v/Q7YrQTP/uB48cChwQHYQMDPcIAA3BYKgFEgAIDKIAIHyiKCDwAAZwBcCaL+yiEiAaHA +0cDgfuB4ocHxwAIMz/6jwQh2R8DPdYAA3BYahfuFPIUEfyR/x39BxxoOb/6KINgEiiDYBA4Ob/7J +cYDnWfIEFAExgOEa8hwUADELIECADPLPcIAAdAVggM9xAACwVQzYYHsD2grwgOAI9M9wgAB4BSCA +YHkM2AYUATGA4RryHhQAMQsgQIAM8s9wgAB0BWCAz3EAALBVDdhgewTaCvCA4Aj0z3CAAHgFIIBg +eQ3YCyeAkwvyCg2v/QXYiiDYBIINb/6KIYgEEvCA5hD0iiDYBHINb/6KIYgF+gyv/QXYiiAYBF4N +b/7pcbz/3KUI3IcD7/6jwOB48cAOC8/+CHcFgUCBAN0g3si4ELjIugUgkAABgSaByLjIuRC5BSER +AADYDyBAAwsgAIQN8vAnQROA4QnyBCBABEIgAIBgecogYgBhvoDmAeUs9x0Dz/7gePHAvgrP/s91 +gADcFiWFQIXIuci6QCkDBAUjg4BGhSGFyLoQusi5BSJGAEeFIoXIuhC6yLkFIkUASIUjhci6yLkQ +ugUiRAAj8i8pwQDggE4hjgcA2g8iggNSfgQigQHEfyV/4KD6hcR/5Xk6pTmFBCIPAQQiQgHEeeV5 +OaU4hcR5BCODg0V5OKXg9Z0Cz/7gePHAJgrP/qLBz3WAANwWOoUbhSR4PIVVJU4XBCEQAEYMb/6K +IJgDTCAAoEohACAq8kwhAKhG9xEgQKTAIWEg+vPwJkAUXB1AFIDgyiHBD8oiwQfKIGEByiOBDwAA +RQLKJAEEYAdh/colQQRAeIogmAPyC2/+KnEA2A8gQAQGIBAgCnBq/4ogmAPaC2/+PIX5Ae/+osDx +wJIJz/6nwTpxGnJAwADYYcAB2AUcAjAGHAIwi3CGDiAJgsEFwQpwIyBABAbCBMCA4A30CiHAD+ty +BdiKI4QGiiTDD+kGb/24c0B4pQHv/qfA4HjxwEIJz/4acCh1SHdodjhjqg1v/mbZgeAJ9ApwLgyv +/qlx6XBCDm/+yXF9Ac/+4HjxwOHFo8EB2EDAz3WAANwWqXAqCq/+XNk6hRuFJHg8hQR5gcBBwY3/ +AcA7hQR5QcEaC2/+iiBYBFUlQB+pcXH/z3CAAFQYQCUBG27/i3DqC6/+BNkBwC//AIWA4AX0BYWA +4IAMwf8pAe/+o8DxwKoIz/4IdgDdiiDYA9IKb/7Jcc9wgADcFlqAO4BEeQDaDyKCAwQiQwBCIwOA +yiNiAC8mx/AB38ogQQMG8hyAJHhFeBj/6XDJAM/+4H8A2M9ygADcClSKWWEweUFpUHDE9iJ4EHgD +8ALYz3GgAMgfHqEQ2A6hAdgVGRiA4H7gePHAKgjP/gDfz3WgANAP9aUD3hLw4HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44Hhhvowm/5/u9QPYGqXPcIAA3ArvqAHYFaVFAM/+8cDaD6/+BdgA +3Qu4qXHd/89xgADIdR6B67hg8h2BUSAAgFzyDgxP/QDZnLnPcKAA0BswoAHZz3CkAJhAPKAEIL7P +MAAAAAHlyiUiEFEjAMAn9FEgQMUF8lEhgMMo8lEgwMUO8lEhgMMK8s9wqgAABAGAhiA/C4PgGvLO +/yDfz3agAMgf8KYB2EMeGBAA2EIOb/6NuPGmhOWmB8X/CPDF/89xgAA0ZwmBAeAJoVEgAMcA2Q/y +ANrPcKAA0BuculCgz3CAALwEQIAQggHgEKLPcKQAmEA8oD3wWgtP/VEgQMU39FEgAMUB5colIhBR +IwDAz3agAMgfIN8O9PCmAdhDHhgQANjKDW/+jbjxpoTlQgAGAObxz3WgANAPANgVpfCmAdhDHhgQ +ANimDW/+jbgD2PGmGqUA2M9xgADcCg+pz3GAADRnCYEB4AmhAdgVpfUGj/7gePHAhg6P/s9xoAD8 +RAWBAN/PdaAA0A+8uAWh9aUD3hLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhvowm +/5/u9QPZOqXPcIAA3ArvqDqlAdgVpc9xgADIdR2BgLgdoZL/TgiAAoEGj/7xwOHFz3KgANAPsILP +cIAA3AoviDB1ANsF9APZOqJvqALw3P9pBo/+ANvPcqAAxCeKIBgIPBrAgM9xoADIHw6hgBEAAFEg +QIDPcIAAfH4N8kISAoYEIr6PAMAAAAXyQYCA4gPyQqCAGcAA4H9hoOB4EMwEIL6PAAAoQEXy47gh +8hESAjeA2M9xgAC4Zuu6EBocMAbyGIEB4BihBfAQgQHgEKFRIsCAB/QA2c9woAAsIC+gEcxGIIAC +4H8RGhwwUSBAgRfyiiAEABAaHDDPcYAAuGYPgQHgD6ERzADZRiCAAhEaHDDPcKAALCAvoOB+BNgQ +Ghwwz3GAAMwVHoEB4OB/HqHgfvHADg2P/gDdINjPdoAA9HveD2AFAKbPcKAAyB8B2TOgWIB5gDWA ++BAAAEAmEBXPd4AAyHVMH0QTAnkCIgKAI6bPcYAAiAoDI0MDQaZiphSRUB9EEyiBCba9tlMhAAAI +ts9ypQAIDECCTh9EE1MiRQFTIkMASB9CEYPjyiHBD8oiwQfKI4EPAABJDcokgQ8AAP4AFAJh/cog +YQEEIoMPAAAA4EWmXoctu+u6lh/CEAzyBLuBu2V4CLYH2AfwFSAMIKCkA/AE2AHgiOC69+u5RAyC +BB6HqXcruFMgEABRIIDFsfKA56/0QSmAQ8C4EnAB38onIhDKJWIQz3GAANwKD4kB4A94D6nPcaAA +tA83gTBwAN4J9M9woACoIAaAjCCDjsv3AN9a/89wgAC8BCCAAd0IgQHgCKGA54Xyz3GAAPR7BYHP +cqQAkEEEIIAPAAAA4EEoRAMVgnaCUSQAgLhzaKHPc4AAyHUHoQTyTBsEAAnwTBuEAwQggA///wAA +B6FRJECABvIwuE4bBAAG8E4bhAMQeAehUSSAgATyUBtEAQnwUBuEAwQlgA///wAACKENggahBCCA +DwAAAP4puFIbBAAeg+u4IvLPcKoAAAQEgAmhz3CAAFh8QIiA4kAgBAEz8oDiXAAuAAIQhQD0JIMD +FdgTuPAgwwDPcIAAMHzVeAHmUHZgoLP3HPDPcIAAcHxAiIDiQCAEARfygOICEIUA0Pf0JIMDKdgS +uPAgwwDPcIAAMHzVeAHmUHZgoLT3QakCGUIBgOcX9AQgvs9gAAAAE/TPcIAAvAQggAHdAYFhuAGh +B4EB4AehiiCFB94ML/4QEgE3USMAwBTyAN8F/4ogxQfGDC/+6XHPcIAAvAQggAHdAYFhuAGhB4EB +4AehBCC+z4ABAADMJyKQzCUhkBjzz3CgADAQA4CA4ADZC/LPcIAAvARAgAHdKHcMggHgDKKA5RTy +AtnPcKAAyBwqoCT/z3CAAMh1QNk9oBDMhiD5jwb0ANiPuBAaHDB5Aq/+6XDgeOHFMNsA3c9woADI +HGmgA9rPcaAAzBchGZiATqGnoGqg4H/BxfHA4cXPcYAAzBUOgQHgDqHPcaAAxCcZEQCGgOAA2gXy +AtgQGRiAz3WgANQLV6UH/89xgADIdR2Bh7gdoej/EIWA4A3yA9gRpeB44HjgeOB44HgRpcX+EQKP +/gohwA/rcgXYz3MAAL4JSiQAABUHL/0KJQABUSEAxvHATfTPcKAADCQHgIDgR/LPcIAARHYLgM9x +oADIH2TgHqEQ2A6hAdgVGRiAPghv/gvYUSEAxjP0USBAxwDaJPLPcaAA1AsWgTiBJOAwcE/3USEA +xgT0USMAwPzzUSMAwBL0USCAxBD0GfAA2c9woAD8RJ65IaBFoM9xgADMFQ+BAeAPoc9wnwC4/1wY +wAjPcJ8AuP9cGAAIvP/RwOB+4HjxwNYIj/4Idc92gADIdR2GLyYI8Dz04L0Q9IK4z3GAALwEQIEd +pgOCAeADoiCBiiBFCdoKL/4jgVElQJAdhhH0hLjPcoAAvAQggh2mBIEB4AShIIKKIIUJsgov/iSB +z3CgAAwkA4BRIMCAHYYQ8oS4z3KAALwEIIIdpgWBAeAFoSCCiiCFCYYKL/4lgT2GLyZI8ADfDvQK +IcAP63IF2M9zAAATCYokgw/BBS/9SiUAAM91oADQDxEVAJaA4GfyRCF+ghPyUSEAgBfyz3KAALwE +IIICgQHgAqEggoogRQguCi/+IoEJ8FEhAIEV8pz/HYZRIMCBSfTPcKAAxCcZEACGgOAH8gLZz3Cg +AJAjPaBR/hvwk/8dhlEgwIE39DmF6XIF8AARAFAB4k96QSmAABByufcA2gXwABGAUAHiT3pTIUAA +EHK59wPYEh0YkOB44HjgeOB44HgSHRiQdv4ehvO4CfLPcIAAbIXrqM9wgAAAheywz3AAAP8/z3Gg +AAwkAaEb2AShUP+5B0/+CiHAD+tyz3MAAFoJBdiG8eB48cDhxVDdANrPc6AAyB+vo16jAiBCAF6j +AdoVG5iAQNpOowQgvs8AAgAQuA6B/4UHT/7gePHABg9P/s9wgADIdTGAUSFAghHyz3GAANwKLolE +EIIARHlRIYCASNrKIoEPAACQAALwDtoA289xoACoICeBqBANAFlhsXHCJUUQyiXmErB4CtmX/UP+ +z3CAANQbAJDPdqAAxCdRIACBBPKMJQOSBPcA3xXwz3CgALQPfKDPcKsAoP96oGoOoAgA2BkWAJaA +4ATyAtgQHhiQAd8ZFgCWgOAr9FEhAMYp9M9wgADIdRGAUSAAggXyD8xhuA8aHDAD2c9woADUCzGg +4HjgeOB44HjgeDGgz3GAAMwVFIFqvQHgFKEVgbhgFaESDS/+AdiCCSABAdjj/XkGb/7pcOHF4cbA +2M9xgAD0e0GJHBoCMBJqR+AEIIAPAAD8/5e47HMAowfI7HMAow/MAN1KJMBzAeAQeI+4EHsPGhww +z3CgAIgkfqCpcKggwAHwIQ4A7HPAowHggOIA2cz3z3CAADB88CBDAOxwYKAB4VBxuPfPcKAA1Aut +oAHYwcbgf8HFwdgcGgIwz3GAAMh1FoHPcoAAiAp4igzghuMB28IjwQAYIMAAA+AEIIAPAAD8/5e4 +nbifuOxzAKMHyOxzAKMYijaBhuAB2MIgAQAYIQEA7HAgoOB/AdjgePHA4cXPcoAAyHUWgpjgz3GA +AJx+BfJUEoAAgOAE8hmCuoIE8BuCvIJRgs9z/v//P2R4pHsEIoIPAAAAEEV4AKEA2AGhZXpKoQ7a +S6HPcYAA8J66CUABMgtAC4DgB/LPcYAA2KGmCWABAdhBBU/+4HjxwMYMb/4b2M92oADEJxUWDZYW +HhiQA9nPcKAA1AsxoOB44HjgeOB44HgxoIogBAzGDu/9ANm6/eS9E/LPcIAAvAQggBGBAeARoX39 +GRYAloDgBfIC2BAeGJCW/ijwUhYAllMgQQCD4dEl4ZAD8uD+HvDPcIAAqQgB2SCoz3CAALwEQIAG +ggHgBqLPcIAAyHUegO64BvLPcIAAfAUgoAjw77gG8s9wgACABSCghQRP/vHAFgxv/gDaz3AAAP8/ +z3WgAMQnEx0YkBvYFh0YkAHYEB0YkM92gADIdRGGsghgAjaGqB4AEJn+HYbnuAPyANgf8C0VAZZW +hjByB/KAuB2mANi7/vXxBCWBXwAAcMcehiV4HqYRFQCW4LgG8s9wAAA0eAfw6bgH8s9wAACIdgUE +T/5RIMCAG/II2BMdGJAg/4Dg1/UC2DwdAJAhFQGWz3CAAHx+IaARFQCWUSCAgAf0ev4dhlEgwIHD +9REVBZZRJYCADPQKIcAP63IF2IojBgDVAC/9iiSDDwTYEx0YkJ3/r/HgePHAIgtv/gDZz3KAAMh1 +PaI+olQaQgA/ooDYlBoCAIAaQACoGkAAz3CAAKyDOaDPcIAAiH4goM9woAAEJTSgMNnPcKAAUAwi +oFEgQMYE9Bf9oQBAADv9gNnPcKAAsB83oDagUSGAw892gADIdc9xgADAZc91gACIChzyANiLuB6m +z3CAALwEVOEgoBuVHLYdlZIeBBCKIIQOHraKIEQLxgzv/QDZBtnPcKAAyBwpoBTwz3CAALwEBOEg +oBqVHLYclZIeBBBOFQARHraKIIQLlgzv/QDZz3GAALwEQIEAggHgAKIggQGBAeABofrYANl6/Ev9 +gOD8BwEAz3CgAAwkz3EAAP8/IaDPcKAA0A8REACGgOAN8gohwA/rcgXYiiPOA4okgw+dB+/8uHMB +2c9woADQDxEYWIBoFYEQHJYCIFAAHobruAQCIQAvIAgkANhAHgQQz3KqAAAEAoLPcaUACAxggQQg +gQ8AAAD/KLkEI4MPAAAA4Ht7iblleWiFBCO+jwAGAAAxpgTyjLkxps9zgAD0ewyjLaMggkQWjxCU +5yqjGfIG9ornGfQjuQ7wt+cO8u7nE/RFKf4CQSnBcFEgwIHCIWIAANgL8EUp/gJBKQFx+vEiufjx +ANkB2DamQYI8s0uj5LrKIGIA4brKIGEAhiL+DyS66JNJHoIQHablekizVSFDBeC4z3IAAGQPCSOC +AAPyANg38I7hjPecFQMQcHEI989zoADQD4ATAwBwcQnygLgdpi4L7/2KIAUI6/HPcKAA0A8ZEACG +QiAACEggAAAQctj3z3GfALj/GIGQuBihGIGwuBihHYaDuB2mz3CAALwEIICKIMUI6grv/SWBy/EB +2IDgCPTPdaAA1AsA2PP9XQYAAApwANlX/mIVgBBEFoIQz3OAAKifBCCEAIYi/wNEJAEBRLpZYcG5 +K2OJu3umbBaNEEkWgxAEJQ8QhiX/E2R/RL2/Z891gAC0QfQlzxNeHsQTz3eAAJCiKWeJuTymcBaB +ECR4hiH/A2R4RLk4YPQlABAEIwMBYB4EEBGGemLPcYAA1EH0IYMAGabPcYAA5EH0IYEAih7EEBqm +jB7EEI4eRBCQHkQQANjPdaAA1AsHBSAASh4CEM9wpgAIBAGABCCADzAAAAA0uFEgQMZAHgQQQBYB +EQz0z3CgAKggCIAZYTB5Yg9v/wpwBPAKcB7+BCCAT4ABAADXcAABAAAA2RX0z3KAAPR7QB5EEEke +QhA2pimilhaBEAHYSh4CEAiSBLmJuSV4CLLa8EkeQhDPcKYAjANdgFEgwMfPdYAAyHUEIoEPOAAA +AEEpwASWHgIQBCKADwAAAPAsuCW5JXgRpgTyEYWMuBGlUyLBAkQVhBA2pVEkAIDRIuKHANgC9AHY +z3OAAPR7SaOWFYIQyJMEusV6SLPRhTyzUyTCAFx6z3eAAJifT2cdpfulbBWPEMO/LyXBA893gADE +fPQnTxHNo14dxBPPd4AAgKJPZ9ml/KVwFY8Qw78vJcEDz3eAAMR89CdPEdqlYB3EE893gADkfPQn +hRDPd4AA9Hz0J4IQih1EEYwdRBGOHYQQkB2EEM9ypgCMA12CBCKPDwEAAAAwv0odwhNJo0oVghCA +4gDeFfJMJECDCfKAuB2liiBFCJYI7/2KIdAHHYVRIACAmPRRIADG//NE8FUhQwXPcgAAZA8JI4IA +4LjPc6AA0A8D8gDYNPCO4Yv3z3eAAAQL6IfxcQX3gBMPAPFxCPKAuB2lRgjv/YogBQjt8RkTAIZC +IAAIgODKIIwDEHLX989xnwC4/xiBkLgYoRiBsLgYoR2Fg7gdpc9wgAC8BCCAiiDFCAYI7/0lgc3x +AdiA4FLyz3aAAMh1ShaAEM91oADUC4DgygIBAIogxQDeD6/9iiGRAc9xpgDUBCwRAIA0ERGAOBEP +gMsREgYqcca56XKGIv0PBrpFeSpyhiL9DwS6RXkEIIIPAgAAACe6RXlEJwIcDbpFeelyhiLzDwQg +gA84AAAADrpFeSW4JXhEJ4EQFLkleEQnARKIuFIgQAVBKcGAEaZUHkIQDfLPcQAA//8M8ADYE/3P +daAA1AvZAgAAz3EAABAfGnE2hj+2BCGBL/8DAP8ouTamygkgAgDa8r+YcKgeABA68kQWgxARhqDj +0SDhgjTyBCCCjwAAAAEH8s9xgAC8QGlhgeEJ9gQggQ8AAAAk13EAAAAkIPIEIIUPBgAAAEEtQQSC +4TAADQCC4Qr0gOIU8s9xgAC8QGlhguEO9IDiBPLM4wr2NoYScQb3z3EBAIgNkHFP9wwkgI8BAIgN +x/fPcYAAzBUWgQHgFqEB2iDwgOLPcYAAvEBpYQbygeHE9kwlAIAV9M9ygACwZUaSUHEP9uu4C/LP +cIAAiAoIgAQgvo8ABgAAA/IA2gLwAtrPc4AA9HsoG0AE66NUFo8QMBuABBdvKJOIuCV4NoYIsxGG +PLOA4Q2jXabc8s9ygACcBECCgOLMJyKQHfIA2Y25rgggAiDaz3GAAJwEI5ECIE8AEYY2hpoIIAIg +2hB3CHFI9xC/z3AAAHgeJgnv/eV5NobPcKAA0A+AEAAAEHEL8h2Gz3KAALhmgLgdpgCCAeAAolQW +gBCA4FThDPKJIZkEWCFCBM9woADQDyIYmIAH8M9wAABkDwkhAQDPcKAA0A8ZEACGQiAACEggAAAQ +cd33z3GfALj/GIGQuBihGIGwuBihHYaDuB2mz3CAALwEIICKIMUIYg2v/SWBz3GAALhmAoEB4AKh +HYZEIP6CFPKGIL+NCvKKIMULPg2v/YohkgFhAs//z3GAALhmCYEB4Amh+/xY8M4PwANU8ELZz3Cg +AHgmMqA2ho7hDPQRzFMgQIAI8s9wgACICgmAUSBAgDLyVOEYhUIgAAhIIAAAEHE+AA4Az3GfALj/ +GIHPdYAAvASQuBihGIGwuBihHYYghYO4HaaKIMUIwgyv/SWBIIUFgQHgBaEA2Gr8HvAc/Tv9EMyG +IP+FBfICyAGA/bgC8k39lP0KJgCQC/QD2BGl4HjgeOB44HjgeBGlBPDiCsAHQH4A2BCljQIP/s9x +gABEdiuBz3KgAMgfZOE+ohDZLqIB2RUaWIAhgIDhBPRRIwDA/PMhgMG5g+EQ9M9wgACpCAHZIKjP +cIAAvAQggAaBAeAGoQDYF/AhgFEhAIAI9M9ygADIdT2Cgrk9ogGAUSBAgAj0z3GAAMh1HYGEuB2h +AdjgfvHAz3CAAHB80g2v/RjZz3CAAFh8xg2v/RjZzwCP/+B4AdoA2c9woAC0D1ygz3CAADRnKaBR +A+/8FNjgeKHB8cBqCQ/+ocEIdlpyz3CAAJiFBoAA2oHgAdjAeIDmQMFAKBQDQfLPcIAAyHWUEIEA +57kI9M9ygACoXQW5ImItusC6yXGGIfwAjCEChVR4EPTPcYAARAUggVEhgIAG8iDdjhAPAQnwmN2K +EA8BBfBeEA8BDt2KIIUAQguv/alxiiCFADYLr/3pcc9wgACIfgCAUSAAgMAlIhGwei8gyCNKJUAg +B/DPcIAAiH5AoLpyGnICEgEhQCAAJTBwSPYCIQEESCEBAC8jSCAE8EojACAAwQDdqXAKcx4JYAKY +dQohAKAc9FEgAMMK9M9woAD8RB2ABCC+jyAGAAD281EgAMMA2Ar0z3GAAMwVCYEB4AmhANiYuDpw +AN1MIQCgAN+V9EwlAKDPd4AAiH6ip4jyAIdRIACAOvLPcYAAAHZMic9xgAC8QDIhhQCwdUAAJgAf +2Klyz3MDABQAVnvPcaMAsP9Q4zAjRADPcwMAGABWe1DjIWMB4i8rQQAvKQEBInsQc8ogxQCwcqf3 +TyTUI0AtQQFCIQEIGWHPcIAAMEQoYCGHCbgleKV4AqcFJIAjDXEAsQ1wABjEBAwSASANcCCgEBIB +IQ1wILCKIIUA8gmv/clxjCYClRPyjCYDkRzyjCYDlSDyCiHAD+tyBdjPcwAA/guKJIMPJQWv/Lhz +z3CAALwEIIAPgQHgD6GiDqABSnAR8M9wgAC8BCCADoEB4A6hCfDPcIAAvAQggA2BAeANoQCHgOAG +8iKHDXAgoKCnz3CgAPQHpKAB389xoADIH/gRAgAAIMAkQniA4MogTANfgRB4UHBGAAUADBICIM9w +gAB8fkKgoNgPob+hz3KAANwKz3CAAMh1VYockEwhAKBCeGJwH6EC2BUZGIAF8lEgQMYg2ALygNgO +oYwmA5UH9M9wgADIdRyQCPCMJgORCfTPcIAAQHYNkIoPb/+pcRoJT/8QzIYg+Y8K9IwmA5EA2M8g +oQPKICIBEBocMM9wgACIfqCg6XAI3MsG7/2hwOB48cCGDu/9ANkIdQGAwbiD4MogQSDKIEEABfKp +cA3/SiBAIIHgEPIQhVEggIFL8hCFz3aAAMh17rgb8s9wgADcCgKII/AB2wDfP/AA31UmQBrpcc9z +gAB0M6IJ4ACQ2kAlABKcHgAQANgFtQTbLfAQhe+4B/LPcIAA3AoDiAXwBYUmhdoPAAFRIMCBlB4C +EAjyHYaVuB2mHoaXuB6mH4YEIL6PEHAAAMonIhDh9Zy4MgzgCh+mgODL8xCF7bjH8wHfxvEA3+lz +z3KAAMh1VBKOAM9xoAD0JoDmz3CAAHx+EfTPdoAAJnb0Js4TXJLaYs92gADcCtWOwnoQuoC6AvAC +2kOhJYVMIACgIaAO9M9wgACpCAHZIKjPcIAAvAQggAaBAeAGocIPD//BBe/9aHDgePHAVg3v/QDZ +CHYBgMG4g+DKIEEgyiBBAAXyyXDB/kogQCDPcaAALCAmgYHgMHkb8hCGUSCAgTfyz3WAAMh1HJUQ +ccn2JYbPcIAAfH4CgBBxWfQQhu64CvLPcIAA3AoCiBDwAdgA3zTwEIbvuAbyz3CAANwKA4gG8AWG +JoauDgABlB0CEB+FBCC+jxBwAAAL9B4LwAqA4DXyEIbtuDHyAd8D8ADfEfBVJUAa6XHPc4AAeDMa +COAAkNofhZ64H6VAJgASnB0AEPIOD/8A2M91gADIdVQVghCA4s9xoAD0JiH0z3KAACZ29CLDA1yV +emLPc4AA3Ap1i2J6ELqAuhLwAN/T8c9xgAC8BECBC4IB4AuiIIGKIEULeg5v/SuBw/EC2kOhRYZM +IACgz3GAAHx+QaEN9M9xgACpCAHaQKnPcYAAvARAgSaCAeEmonEEz/3gePHACgzP/Qh2EcxTIECA +CvIGEgE2ANiYEQEAwgygAAhyAYbBuIPgyichEMolwRMG8slwaP4IdQHfgeXKI2EAOPIQhlEggIEF +9ADbaHEx8BDMUSDAgCHyEcxTIECAEvQZyAHaACCBD4AAiHDPcIAAcCMSiECpUSAAgPgOYgDKIIIA +ENgQGhwwz3GAALhmEoEB4BKhCN3a8c9wgAA8ZiuAAeEroJ4Nb/2KIMUJANsB2QLYz3KgAPQmA6JD +hoDnz3CAAHx+QaAN9M9wgACpCAHaQKjPcIAAvARAgAaCAeAGooDhCfIA2J64z3GgAPxEAaEA2AWh +dg0P/30D7/0FI0AD4HjxwA4Lz/0IdgGAwbiD4ADdyiBBAwTyyXAu/gHdgeAA2SzyEIZRIICBKPIQ +zM9ygADAZVEgQIEZ8kDYEBocMFASAAYB4FAaGAAZyM9ygAAIcBR6IKoCEgE2ANiYEQEAfgugAAhy +CvCkEgEAAeGkGkAAzgxv/YogBQoC2c9woAD0JiOgI4aA5c9wgAB8fiGgDvTPcIAAqQgB2SCoz3CA +ALwEIIAGgQHgBqG+DA//zQLv/QDY4HjxwM9ygADIdVQSgQCA4RT0PJLPcoAA3ApUikJ5ELlFIUMB +z3GgAPQmY6EA2s9xgAB8fkGh+v2B4MogYQAE8nYMD/8A2DcBT//xwAoKz/0IdRpxQSkAAc9xgADo +Q8O4CGEklQQhgQ8AAACA13EAAACAAdnAeTV4IZUE4TBwDfKMIAKkCfTPcIAAyHUWgIwgAoYD8hDY +N/AklfILb/2KIMQLjCACrCLyDvaMIAKgJPKMIAKkJvKMIAKoJ/SpcMT+I/CMIAOkFfII9owgA6Ad +9Klwn/8Z8IwgA6jMIIKvAADwABP0qXDH/w/wqXAF/wvwqXBX/wnwVgxgAalwBfA2DmABqXC1Ac/9 +TXGCC2/9iiCFCMHx4HjxwEYJz/3PdYAAyHUfhQQgvo8AcAAASvIvKQEAz3CAAPAE9CBAAKQVARAA +3pwVAhCCuMlz4v2A4DjyH4X+uDDyz3WAAHAjEI0ujRBxLPISjVEgwIAo9DCtUgxgAAPYUSAAwxr0 +ANmeuc9woAD8RCGgMI2GIf8BQ7kQuU8hwgbPcYAAzIsgiZ+6gOEB2cB5D7lFeS2gEo2EuBKtBvDP +cIAA9ITAqE4LgAEJAc/98cDhxRoPL/8A3c9ygADIdR2CUSDAgVr0z3CgAAQlIoAEIYEP/wBfb1Mh +gACH4ED0USKA0zzyHoL6uDr0BCC+jwAeAAAI8lEigMD/9VEiAMDPIWIBz3KAAMh1HoL5uM8hIgLP +ISIDzyHiAs8hogMg9Pu4EfIdgoi5ibmNuQQggA8CAAAAi7mOuVIgQAQquAV5DvD8uMUhgg8AAAAF +zyHiAs8hogPFIYEPAAAAB89wgABUdgiIxLgYuFEggMQFIE0AyA5i/cogIghFAO/9qXDgePHADxIB +NwHhMHmPuQ8aXDDPcaAA1AsNoc9xgACICiiB67kO8lEgAIEK9MoIgAPPcIAA6HSg2doMb/3E2q8G +D//xwIIPr/2KIAgAz3agAMQnEx4YkM91gAB0duSV6XDiCeADhiD8AxpwqXDpcYYh/ANS/wh3hP9E +J36UD/JRJwCRB/LPcYAAyHUdgYC4HaEBhWIOD/9e8EwgAKAM8qX/z3GAAMh1PYFRIcCBVPTV/w3w +A9nPcKAA1AsxoOB44HjgeOB44HgxoM91gADIdR6F7rgH8gHZz3CAAHwFIKAI8O+4BvIB2c9wgACA +BSCgUSfAkAbyz3CAAIh8igtAAhEWAJZRIICAFvRKDQ//HYVRIMCBIPQRFgWWUSWAgAz0CiHAD+ty +BdiKI8kDMQRv/Iokgw8E2BMeGJAb2BYeGJDPdYAArIMZhYDgBvISCIABANgZpdUGj/3PcqAAxCct +EgCGTdjPcYAAHHYJuBoaGIAAiYDgBvIB289woADUC3KgBNgQGhiATXCGIPMPjCAMgAHYwHgYYBR4 +IIke4IDhwCAiA1EggMQF9FEhAMb7889xoADQDxAZGIAlEQCGJREAhs9xoADEJxoRAIYEIIAP//// +ABoZGIAREQCG67gI8gDYi7gTGRiAGtgZGRiA4H8A2PHA1g2P/c92gADIdc9woAAMJDyAVoahwQIi +QABkuBB4hh4EEBByyiHOD8oizgfKIG4ByiOODwAALAXKJC4AMANu/MolDgECyAGA/bgJ8i8ghwqM +IAKGBfQehp64HqbPdaAAxCchFRCWUgjAA4Dg5AEhAJgeABBRJYDTz3aAAMh1z3WAAIgKBfJWFYAQ +C/BRJcDTBfJXFYAQBfADhg4P4AAkhpQeAhAehkQgAQyg4Qj0USXA0gT0gNmUHkIQlBaBEFEhwIEE +8rO4l7geplEggIEm8hSWUSBAgSL0Ig7ABoDgHvTPcKAALCAPgIDgBfICyAGA/bgU8h6GkLg2C6AK +HqaA4AbyUSVA0wHZA/QA2Ytwz3OAAHQzNgigAJDaz3CAAMh1lBCBAEApAgaGIf0PUiHBAUW5RXnP +cqAAiCQwoimF47legAPy6boD8gDYAvAB2FEhAIHRImKCANnKIWIA97oleA94FfRRIoDTE/KA4BH0 +RCI+0wv0z3CAAMh1AYBRIACABfK+CMADA/C+CcADz3WAAMh1HoXzuB3yBNnPcKAAkCM9oE1xag4v +/YogRA5RIIDEBfRRIQDG+/PPdYAAyHWGFQARz3GAAIgK1g0gBC+RFfAAlQQggA8AAMyA13AAAMiA +CPQLhVEgAIAE8l//B/AE2c9woACQIz2gAtjPd6AAxCc8HwCQlBWAEM9xgAB8flEgwIEEGQAECfId +hZW4HaWKIAUJ6g0v/QDZx/4Idh2FUSDAgcX0UyZAEIPgBvQVFwCWUSDAgD7yvgov/8lwufDPcYAA +PGYNgQHgDaED2c9woADUCzGg4HjgeOB44HjgeDGgENgQHRiQAtg8HQCQz3GAAHx+3gkv/wQZAAQd +hlEgwIGX9BEVBZZRJYCAC/QKIcAP63IF2IojFwvFAG/8iiSDDwTYEx0YkBvYFh0YkIHwEMxRIMCA +PoUL8gQhgA8AQEAA13AAQEAAA/SYuT6l8LkJ8gDB1NipcgHbW/yA4JwNQgHPcIAAqQgB3+Coz3CA +ALwEIIAGgQHgBqEehfO48AlCBB6F8LggDcH+HoXuuAjyAdnPcIAAfAUgoAnw77gH8gHZz3CAAIAF +IKDPcaAAyBwA2AehMNgKoclws/6KIIQNvgwv/clxAsgBgP24FfIehfi4E/IQ2BAaHDDPcIAAiHwm +DwACGcgAIIEPgACIcB6F4Km4uB6lAJWGIPwAjCACgBD00g8ABIDgDPQD2c9woADUCzGg4HjgeOB4 +4HjgeDGgHoXzuAX0AJWuDWAFNJV9Aq/9ocDPcoAA3ApUillhMHlBaVBwxPYieBB4A/AC2M9xoADI +Hx+hiiAYCA6hAtgVGRiA4H7xwOIJj/3PdoAA7AUAhoDg4A/CBRDM4LgA3zzyz3GgAMgfsBECAM9z +gACICmoTAAFjuAgiAAAeoRDYDqEB2BUZGIDPcYAAdHoCGlgwz3GAADR7BhpYMCiDz3WgALRH67kF +8ksd2JN3HRiQxgjAAlcVAJa8uFcdGJDPcIAABAUAiIDgOAxCBwQgkE8wAAAAKvDtuCfyJg4P/891 +oAD8RAWFvLgFpc9wgAA0ZwmAjCACjYj35gpv/BTYz3CgALQP/KDPcIAAiAoIgOu4BfIA2J64AqUQ +zO+4z3CgAMgfFvQadwDZz3CAAMwVI6AloM9xoAAsICOBJ6Ba8J4Kb/wU2M9woAC0D9ygUvAE2Qga +WDA/gIDhiiEMAMohgg8AAAACLqAD2RW5EhhYgACGgODgDsIFIwMAAFEgQMUt8s91gADMFQOFAeAD +pXYNL/8B389woAD8RCWAvLkloM9xgAA0ZymBjCECjZQH5v8A3s9xgACICiiB67kE8gDZnrkioM9w +gADIdR2AhiC+jwTyBYUB4AWlAd8QzOS4dPTmuH30hiD/hb/yUSMAwIf0CMgEIL6PA4DoQ8L1USBA +xb71z3WgAMgfP4WgFQAQCSEAAOTgAN7T9s9wgACwXACAUSBAgAvy3qUQ3z4MIAPpcIDgBfQB2B6l +7qWKIAgAoB2AEw6lH4Wo4Ej3gOAE9IogBAAOpUoIQAcv2JW4Eh0YkM9wAQDA/BUdGJCqCIAAZgng +AQfYz3CAAOwFAICA4NgNwgXPcoAAzBUDgiSCCCEAAASiJoIFggghAAAGojyFZ4IIgmJ5CCBAAAii +z3GAAPYEAImI4Nj0wKkD2c9woABALTCg1PARzFMgQICU8wbIAhIBNgIaGDAGGlgwng6AAs9woAD8 +RCWAvLkloM9wgAAEBQCIgOAMCkIHfPFRIEDFevUQzM91gAC4ZlEgwIAg8oDYEBocMBHM67gG8hiF +AeAYpQDfBfAQhQHgEKXPcIAAcCMSiFEgAIBgCiIAyiBiAEwgAKAT8heFAeAXpQ/wiiAEABAaHDAP +hUwgAKAB4A+lBfIWhQHgFqUQzOe4PvIRzAQggA8AAAAY13AAAAAIGvJaCYAAEcxRIMCAI/LPcKAA +LCAlgAaACuEQcRf3AhIBNgLYEBocMFDYdgwgAJgRAQCX8R4PIAHpcFEgAIAH8gjYm7gIGhgwFvEE +2AgaGDAS8QLIoBAAAPC4ANg98uIOQAAA2Ja4OfDouCb06bg49O64DvJRIwDACvKKIQQAz3CgALAf +NKAE2AgaGDARzO+45AXB/89xoACoIEiBz3GAAEB2LZEwctAFxf+vuMkF7/8RGhwwig9gAIogBACe +CKAAAN0CyKAQAADwuKlwBfJyDkAAANiVuN4IgAC58WIOYAAB2ADYkLj58QHgAKnPcIAAiAoIgOu4 +FfLPcIAA6AMQeM9xoAC0R0kZGIDPcABEFABLGRiATBmYgwPYdxkYgPUFT/3geM9wgAAFBUCI4LoI +8s9xoACsLxmBirgZoVEiQIAH8s9xoACsLxmBjrgZoeB+8cAH2M9xoADUBxoZGIAOEQKGGRoYMM9w +oABILF6gHxEAhgkamDABGhgwBMqc4Mwggo8AAJEABvIAFgBAABYAQAPMz3GfALj/GKGKIEYESg/v +/AESATYEytHA4H7xwOHFz3GAAIgKSIFRIgCALPLPcqAAyBxIgoYg/wFDuM9ygAAMQQpiANuA4soh +wQ/KIsEHyiBhAcojgQ8AAFoAyiTBAFQCIfzKJSEAgeLPcKoADFC+gcf3gL2+oQHZJaAE8KC9vqFl +oBUFT/3xwJIMT/0acM93gABwIxCPz3agALRHRCABDkIp0QAqdXEWAZYEIYEPDgAAADG5geH480MW +AZZGIQENQx5YkFcWAZa8ub+5Vx5YkF8WAZa/uV8eWJAA2Z65Ux5YkGAeGJDN/89wgACwZQeIgOAU +8hCPhiD/AWIPL/5DuM93gAAIBRSPEHUI8s9wgABsJxaAQHgUH0IUQxYAlkwgwKBFIAANQx4YkIAA +DQAKcDMmAHCAAJBEQCeBchR5AHkQvZu9z3CAAMyLAIifvYDgAdjAeA+4pXhfHhiQIPDPcIAAzIsA +iBC9gOAB2MB4D7iYuJ+4pXhFIMABXx4YkA7wEL3PcIAAzIsAiJ+9gOAB2MB4D7ileF8eGJAIyITg +MA0h/MogoQPRA0/9CiHAD+tyBdiKIw8ISiQAAPkAL/wKJQAB8cBeC2/9AdnPcIAAiAoIgMC4G3gA +3s91oAC0R0sdmJN3HViQz3GgAIRE2KEC2XcdWJAA2Z65Ux1YkFQdWJDPcYAANAFHHViQjrjPcYAA +KABFIAYNSB1YkM9wgACICkkdmJMakAK4bLhEHRiQHNhFHRiQz3CAAGgzAYhGHRiQz3CAAHAjEIh1 +/0okwHDPcYAAnH7JcqgggAPPcIAA2ItWeGGA82r1fz9nAoBipwHiA6fPd4AACAUAh4DgBPJkHRiQ +Qx2YkQHYgP/PcIAAiAoogOu5EfLPcIAA6AMQeEkdGJDPcABEFABLHRiQTB2YkwPYBPBLHZiTAdh3 +HRiQUSEAgECHDvJTIkEAErlEIgADDrgleIYi/wMKukV4EvBIcIYg8w8KuAQigQ8AAAAMBrkleAQi +gQ8AAAAwArkleM9xgABYM4UCb/0CoaHB8cACCk/9OnDPcIAA2ItAgKTBSHCGIP4DJLgOuAZ5wrpA +KoADJXhMwAQggw8BAADALrtAKw0GnL3PcYAAiAoogZ+9z3KAAAgFUSEAgM9xgACUGXZ5BvLQgcSi +MYEF8MCBIYHEoiOiAhICNieKUSHAgAv0z3GAANAEIIGGIX8PPXkPuSV9USGAocoiISIK8gvZBCC+ +jwAAABjKIeIDWnFRIQChzyXiFgX0USEAos8lYhfpuDDyBCCBDwEAAMAuuc92gAAMQSlmSSGBAGG5 +0mnUfsd2gAAMfigWEBAsFhMQz3aAAIgKYhaOECzHCLsY4QQggA8AAAAQ5H6GJv8eCb7Fe2V/BX+e +vS95uRpCAIoh/w9f8Oi4JvJDwCPBoOHKI0IAyiMhAM92gAC8QClmBCCPDwYAAAAxvwQghA8BAADA +ACdFEM9xgAAMQUEshAMyIQEBAiFBARYjRQAswStmFvBTIMEAz3OAAPhDPXkpYwQggw8BAADALrvP +doAADEFrZmG7FiHFAAHbTCUAhov3CiHAD+tyBdiKI8YJEQbv+4okgw9ALYEANHnHcYAAFH0AERAA +BBETAAQggA/vAADdIoFhuya4ZXhSIM8DuRpCATAUBDAA2M92oAC0R3EWApYEIoIPDgAAADG6geL5 +84wh/4/PcqcAiEkL8s9zgADcFnqDUSMAggPyL6IB2A6iCnBSDKAHiHGKIP8Pbx4YkGseGJAD2Q+5 +z3CgAMgfExhYgFke2JRaHhiUWx7Yk1gemJRRIYCiSiAAIAfyz3CAAIgKahAQAfu9yiAhAA/ymgoA +BM9woADIHx6AAnACuG64SCAAAAhxybklfYYn4x+MJxyQ0CXhE88l4hNXHliTz3GAALBlJJGB4Q30 +hBYCllAiAQMEIoIPAAAADK25ArpFeQPwhBYBlhYeWJCMIM+PyiHGD8oixgfKIGYByiOGDwAAFwHK +JMYA2ATm+8olJgAI3IMHL/2kwOB4ocHxwB4PD/0acM9wgADYi2CApMFocIYg/gMkuA64BnnCuw67 +ZXlMwQQhgw8BAADALruB4gHawHoGulYiQghAKw0GnL3PcIAAiAoIgJ+9z3aAAAgFUSAAgM9wgACU +GXZ4BfLwgOSmEYAE8OCAAYDkpum5A6Yx8gQhgA8BAADALrjPdoAADEEIZkkggABhuAK4LMcUeAAg +jg+AAAx+KBYRECwWEhDPdoAAiApiFo4QCLuKIP8Pnr3kfoYm/x4JvsV7ZX8EIYMPAAAAEGV/TyIT +AU8j0yFf8FEgQKLPImIBzyIhAei5enIi8kPBI8Kg4somghDKJiEQz3OAALxASmMEIY8PBgAAADG/ +BCGADwEAAMD6Yi64z3eAAAxBCGdCeBYmBRAswApjFvBTIcAAz3KAAPhDHXgIYgQhgg8BAADALrrP +c4AADEFKY2G6FiCFAAHaTCUAhov3CiHAD+tyBdiKI0oEZQPv+4okgw9ALYAAFHjHcIAAFH0AEBEA +BBASAAQhjw/vAADdAoBhuia/RX9SJ88Tz3agALRHcRYClgQigg8OAAAAMbqB4vjzjCD/j89ypwCI +SQvyz3OAANwWeoNRIwCCBfIPogHYAvAA2A6irgmgBypwiiD/D28eGJBrHhiQA9kPuc9woADIHxMY +WIBZHpiUWh5YlFse2JNYHtiUUSCAogDYBvLPcIAAiApqEAAB+70acMogIQAP8vYPwAPPcKAAyB8e +gAJwArhuuEggAAAIccm5JX2GJ+MfjCcckNAl4RPPJeITVx5Yk89xgACwZSSRgeEN9IQWApZQIgED +BCKCDwAAAAytuQK6RXkD8IQWAZYWHliQjCDPj8ohxg/KIsYHyiBmAcojhg8AABcByiTGADQC5vvK +JSYAXwXP/+B48cB2DC/9A7k6cM9wgACICh+ANXkAIY0PgACcfoDgWnOf8gmFRXi6cAmlEBUUEBQV +EBBGhRwVFhAgFRMQIIXPdqAAtEdxFgCWBCCADw4AAAAxuIHg+POMIv+Pz3OnAIhJC/LPcIAA3BYa +gFEgAIIF8k+jAdgC8ADYDqNiCKAHCnCKIP8Pbx4YkGseGJAD2A+4z3egAMgfEx8YkFkeGJVaHhiU +Wx6YlVgeWJVRI8CmyiEhAA7yug7AAx6HArhCIIEDSCEBAChyyboFI5MgynCGIOMPjCAcgAX0UCPA +IwPwTyPAI1ceGJDPcIAAsGUEkIHgDfSEFgKWUCIAAwQigg8AAAAMrbgCukV4A/CEFgCWFh4YkIwh +z4/KIcYPyiLGB8ogZgHKI4YPAAAXAcokxgD4AOb7yiUmAAASASB+FwCW4LnPIOIA0CDhAH4fGJAv +IUMAABpAIADZz3CAAIgKP6AghWEDL/0AGUAg8cAqCy/9ANuA4aXBCvJIgQQigg8AAAAwQiIDgMoj +YgADuBV4ACCCD4AAnH7Agui+QMYS8iDAz3WAALxAMiUEEACKDWUEJoAfBgAAADG4ACBFAwXwAdiY +cLhwrr6vvrC+QMaA48whIoCM9M9wgADYi89zgADIdZYTgQADiAshAIA38kgTgwAA2QDfUyNNAA8h +QQNEIw0DQr2GI/8DDydPE7xrBCcPkADbBHkPI0MDZHjKJwEQgOHKIcEDTCVAgBTyTCWAgBPyTCXA +gEPyCiHAD+tyBdiKIwwGSiQAAOEHr/sKJQABDrklfjbw5Xn88SGCz3WAAKhddWljZVEjQIIL8i8o +AQBOIIEHANiOuDh4BX4i8EwlQIAP8kwlgIAR8kwlwIAX8gohwA/rcgXYiiPMC9Txz3CAALBgNngC +iAbwz3CAALBgNngDiA64BX4E8I6+j76QvgQmgB8BAADALrjPcYAAAEQIYbBwVAAmAEDGCiHAD+ty +BdiKI8wNRQev+5h2DZEogYYgfwwEIYEPAAAAMCy5qWkceEAlgRMRIECDDyZOEEDGDPQKIcAP63IF +2IojDQCKJMMPCQev+7h1z3GAANiLAIGLc6CDhiD+AyS4DrgGfaCjAIHCuA64BX2gowDAz3aAAAgF +BCCBDwEAAMAuuUApAwZPIwUHz3OAAIgKqINPJcUHUSUAkM91gACUGTZ9BfLwheSmsYUE8OCFoYXk +pum4o6Yu8qeCCLklfaeiBCCADwEAAMAuuM91gAAMQQhlSSCAAGG4ArgUeMdwgAAMfsqAq4BiE4AA +IMcEIMQDz3CAAAB2ERCGAE8lhQcEJgABCbgFeSV/iiAGBooh/w9T8Oi4HvJEwCTGoObKJYITyiUh +EM93gAC8QM5nBCCPDwYAAAAxvwQggQ8BAADA/mYuuc93gAAMQSlnwnkT8FMgwQA9ec91gAD4Qy1l +BCCBDwEAAMAuuc92gAAMQSlmYbk2fZjljfcKIcAP63IF2IojjQ6KJIMPyQWv+7h1Mm00ecdxgAAU +fcCBoYEEIIAP7wAA3SKBQiRPACa4BX9SJ88TiiAEAqSixaImoiAaQAEJoueiAdgfo10AL/2lwOB4 +ANiQuM9xoADIHxUZGIDPcIAAsFxGkFt6TyIDAFoRAoY4EIAAZHpYYNgZAADgfuB44cUA289ygAAI +cBQiDQBgtWi1GmIgGsIAuB3EEM9xgACwXBZ5IpEoGsIAyB3EEHAdRBAB2YAaQgDPcYAAoHAVeWCh +4H/BxeB48cDhxQh1GRIBNs9wgAAIcDR4EYiA4BLyAsgBgO24DvLPcIAAEFrwIEAAz3GAAIQEFHkA +kRDgALFKC4ACGcjf/wLIAdmgGEAAz3EPAP//7gigAqlwmQfP/PHAHg/v/EokAHLPcqAAiCAA3qgg +QQGH5kDyAILPcYAAsFzPc4AAeIXWeaiJZ4O7Y4Dgz3WAAAhw1H0j9AAmgB+AAHhw8IiC5wr0cBUP +Eft/I5GAvyR/cB3EEwfwgecF9CKRcB1EEADZMKjPcKAAyBz6gHAVARHkeYgdRBAF8IgVAREwcMP3 +eGEE8IgdBBB4YIkgzw8EGhAAAeYA2c9wgAB4heUG7/wnoPHAdg7P/FEgwIEZEg42z3CAAAhwAhIB +Ns9zgACsfM9ygADMFdR48YgQEIYAEfIB55h3MhGFAAeTAhuCAQazGoIB4Bqiz3BBAIMA46sR8EAm +RAAxEYUAAhsCAbgQAAHjqwazG4IB4Buiz3AhAIIADCRAgcX3aQbv/ASjz3CAAChwyGAB4ASrAYEA +2lEgAIGwiTjyLyXIA89+SSbEENVtz3eAAKhdxmf2vhKJCPLPdoAAsGC2fsGOA/BIdgAkjw+AALBg +tn/kjwggwAMIIIADoHBJIM4DFm3VeM92gACwYQBmz3aAAMhftn6hhs92gACICt2GxX0EJY0fAAAA +CKZ4A/ADgQKjmBGAAKiLEHUF8kSrYNgYuLDxANiduK7x4cXhxs9woAAUBAPZI6AZyM9ygACsfGGS +z3GAAAhwxIoUIQ0AaLUAIIMPgAAocDDhwKtighV5BpJgoQISAza4HQQQBIKgEwEAhiHDDyV4oBsA +AMHG4H/BxRkSAjYEIL6PYAAAAM9zgAAIcFR7x3KAAHhwCHEG8gLIHJBRIICCCvIEIYEPYQAAANdx +AQAAAAb0ANgAswHYHvAQzFEgwIECEgE2DfIyEYEAAYswcAT0ANgBq/LxAeABqwvwMRGBAACLMHAF +9ADYAKvm8QHgAKsC2OB/EKrxwIYM7/wE2Qh1GRIONgbYGRoYMM93oAAUBAqnz3CAAJRE3g2P/ACF +1g2v/ATZAYXODa/8ONkihYDhBvIBhQCQEHHM9wohwA/rcgXYddtKJEAAyQGv+7hzpg2v/AOFAYVC +hSCQBYWaDa/8QnnKp4EE7/wZGpgz4HjPcYAAIAXgfwOh4HjxwAIMz/wKJQCQyiHBD8oiwQfKI4EP +AACtAMogYQEi8iGFgOHKIcEPyiLBB8ojgQ8AAK4ABdgW8hCJz3KAAKhdBbgHYsKBLb8BhoDgwL8F +8gCGgOAL9AohwA/rcgXYtdtKJEAAMQGv+7hzUSCAwQb0sgwABoDgDfKKIM4Cug1v/LzZAIaA2Sig +AYZAeCnwAYUgkCDIEHHKIc0PyiLNB8ojjQ8AAMIAvAft/wXYqXC0/wGG0f/PcIAA1KGELwsaiiEQ +ADAgQA4YeQDIJngAGhgwz3CAABBa5qD2Cm/86XCNA8/84HjPcYAAIAUjgeB/IKDxwOHFAhIBNqKB +iiH/DwAaWDAghXYLr/wk2gGFgODiIAIAaQPP/OB48cDqCu/8BtgZEg82GRoYMM92oAAUBAqmCYaA +4ADdE/K6C0ACCYaA4A3yJBYFEAohwA/rcgXYiiNEA0UAr/tKJEAAiiD/D+qmABoYMM9xoADQGxCB +z3KAAAhwhrgQoROBkLgToR2KgOAZGtgzDPLPcIAAEFoGgM9xgACEBBR5AJEQ4ACxprKusiYaQgPE +GkQDiiBPC4oMb/yKIQQItQLP/PHA4cUIdc9wgAAQWkaAz3CAAJCfhCoLCgAgQg7PcIAAXFsAgFEg +wIChwRTyFmnPc4AAsGEAY1EgQIIM9M9wgACwYDZ4W4oCiIm6DrhFeAbwcg6v/ItwAMAApWkC7/yh +wOB44HjgeOB44HjgeAokgPAFIEQA4CDBB0Qk/oBBKsQAhAACAC8kAvFCIQEBQiADAeggogQEEQQC +BBEFAgQRBgIEEQcCBBsIAQQbSAEEG4gBBBvIASwAJQBEIj6BPAAiAEQi/IBAIcEA4CDBB0AjwwCo +IIABARGEAgEbCgEgIMAHBBEEAgQRBQIEGwgB1Afh/wQbSAFEIvyABBEEAskH7/8EGwgBQiFBAEIg +QwCoIIABARGEAgEbCgEgIMAH8cAyCe/8ANjPdoAAsH9KJAB0gN2oIEAFCHEB4E8gwgEWJkMQR6uK +IggAQClEAQAkgQ+AAKhdQKEA2kKxpqnA2H8eAhDPdoAAMAWgrs9wgAAwgIDZogxv/Chyoa7PcoAA +3Aqiqs9xgAAcorKpz3CAAESfoqijqrOpJQHv/KOo4HiiwfHAqgjv/JhyRcFBKAECQSgDBAd5J3vG +u8dzgAAwgCCL57kS9BQUDjHPcoAAsH8WIk0A4IXxcAT04pXRdwjyJ43nuWdt8/MA2Dbw5o2A5wb0 +gN7PcIAAMAXBqM9wgADcCsKI0XcN9IDewqjPcIAAHKLSqM9wgABEn8KoDvDDiNF3DPSA3sOoz3CA +AByi06jPcIAARJ/DqMaNNnoAHIADB42HuQCrz3CAADAFYIggqAHYZ6oM3GMAz/zgePHA5g+P/M9x +gACYRCGBo8FCwc9xgACwBBUhEAAAEA4ggOYvKIEDTiCNB1TyFW0AIJEPgACoXQYRgCDPcYAAsH8W +eQCBIpGO5QgcRDDKIGEABPKLcgLBvP+A4DXyANjPcYAASAVAgQ8gQAMvIgogBCKAoAChBvSA4lgN +ogTKICIIr3g+CWAAENkA3wQZxCOKIQgAABlAIKlw6XEODqAJD9rPcIAAyF8AEAEgtnjgoOGgz3CA +AKhfBCGBBAAYQCC0eOCwECZOky8ogQNOII0HsPVxB6/8o8DgeKLB8cAWD4/8RcHPcYAA8J6igbFw +EPSmkRQUDjGxdgz0z3WAANwKQq3PdYAAHKJSrVYZggC8EQ0GsXAU9M91gADAobKVFBQOMbF2DPTP +dYAA3ApDrc91gAAcolOtVxmCAIDiDPTPdYAAMAXBjYDmANnKIEEAI/IhrY7iBPQB2B/wQSgNAgd9 +QSgBBKd5z3eAADAFoI9TJUURTCUAhMa5i/YKIcAP63IF2LvbBQRv+4okgw9RJYCRBPIA2DTxz3WA +ALB/FiVNEceNAKUUFAAxwK9GrQK1x3GAADCAAIkHrQAZQgEAG0IBzPGiwUHBQSgCAgd6QSgBBEd5 +z3KAADCAxrkqYue6EPQEFAMxz3GAALB/VnlAgVBwBfRCkXByBvJHiee69fOA2APwBongf6LA4Hjx +wO4Nr/y4cEokQACQ4Mohyg/KIsoHyiOKDwAAEwFgA2r7yiBqAUAtQwHHc4AAqF3Gi4wmApAA2A3y +z3CAALB/FiCNA6CFoKEmizZ4ApAAsohwCQaP/OB48cB+Da/8AdmlwRpwCiKAL4AANAX+DG/8i3BM +IECgABSFMAEUkTAG9AoigC+AADgFTCUAgMT2TCUAgcv2CiHAD+tyBdic2+ECb/tKJEAATCUAgCYB +DgCocAAWjkAAFpRATCQApHpwhfaMJMOvKPQAFgBBABaPQAAWgEAAFgBBTCQApH4ACgCA5yXyz3CA +ADQFAoBALM0gtX0Q4Lhgdgxv/ATZz3CAADQFAoBMIUCgHWXMJ2GTFfQA2Iy4FPAKIcAP63IF2Kfb +SiRAAF0Cb/sKJQAFCiHAD+tyBdiw2/XxANgAtc9wgAA0BSKAQCzAIBV4EmEZYQUiQAQAsQTdBvCB +wATdEgxv/KlxACKMIwAcAhXPcIAAsATwIAIEHt+A4i8pgQACJ0AQJPLPc4AAr101aCtjESOAgwny +ACaBH4AAKF0WeQAZAgUALYETCyHAgAnyACaBH4AAKF0WeQQZAgUQIgKALymBAAInQBDg9UIjQCCA +4OgGzf9iC0/8WQSv/KXAANhA8fHA4cWtwYt1qXCGC2/8DdkAwB14UyABAEQpPg2pcAAhgX+AAEhg +Fgxv/A3aJgtP/FUEr/ytwOB48cDhxSDbz3GgAMgcaaEAFgBAz3KgABAUDKIAFgVAAd1MJQCAyiHB +D8oiwQfKIGEByiOBDwAACQEwAWH7yiRBAxgaQAFoGUABA9gPormhaqHKCk/8+QOP/PHAfguP/KQQ +AQD5uaLBcPQg2c9zoADIHCmjpBABAFEhwIEu8jGIz3WgABAUI7nAuQO5BeED2k+lRoVBwo3hEN7K +JuIRBhQPMYwnw58I9AQUDzHxdswn6pAB3kP2AN6A5ur1xYBFfselsYiGJfwfGL2les91oADMF1qg +F/BFgM9xoAAQFEehpBABAFEhgIIJ8jGI17qGIfwPGLlFeTqgz3WgAMwXDdkB2gPhDR2YkA4dWJAm +gBkdWJAngBodWJAogBsdWJAD2RQdWJBwEAEBEB1YkHAQAQHPdaAA9AcE4SelR6OkEAEAmbmkGEAA ++QKv/KLA4HjxwC4O4AUQ2G/ZB7nPcqAA8Bcxos9xAADw/ziirg/ABdHA4H4A2oDhyiRNcOB46CDt +Af/ZXGAgrAHi4H7xwPr/8P/w8Q97SLgPeM9ygAAARvQiAABAKAECSLgFefQiwAAweeB/J3jgePHA +IgqP/KXBCHYCiyh1mHBkwACLABIGAREcAjB5cAISBwEEEggBEBQAMeSSBhIFAQAgyQMAkS8hSBIH +IEACEHjn/wAgigEBlS8iiBIHIIACEHjj/wAgxgEClS8miAEHIIABEHje/wAgBwIDlS8nyAEHIMAB +EHja/wAlBQAElS8lSAEHIEABEHjV/x9nBZXwf+d4EHjS/yaVIXAQeAd5PHoPuSV6UHoAIoECMHkA +HEQwR5Unelx5D7pFeTB5ACGCAVB6XHkCHIQwD7pFeTB5ACHCAVB6XHkEHIQwD7pFeTB5ACFCAVB6 +XHkGHIQwD7pFeTB5P2fwf/x5CBzEMw+/5XkweThgaXHGuYW5CLkFIcECILYQeCCVChwEMCd4HHgI +uAUgAAEBtgDAAaYBwAKmAsADplkBr/ylwOB+4HjxwOHFCHU+iM9wgAA0BUKAQCUAFAO5NXlZYfoI +b/wK2qlw9/85AY/88cC+CK/8mHClwSh3uHMA3gQjgA//AAAAGLoFem95CLn/2Ai4ZHgouAV5RXkI +3fQkgAMneETAEBQAMZD/EhQCMWG9QCgBBAV5R3lEwRAUAjEUJIAzgOVAsAHmK/dTJcIFQKcAFA0B +B9kG8BB9FCdMEAC0YbkUJEAwu3tPvQCQpXuB4XB7eGAz9wQggA8AAAD/ELgFekCnnfHxwCYIr/wg +2QDaz3WgAMgcKaXPcaAAlBNboc9zgAA0BWKD82jPdoAAyHUMhvV/UyDEBfBj+2NTII8Ag+ekwYtx +GvQehpu4HqY0FoAQ4ovxcAr0KHBAIwEERGtAJgMcav8N2irwHYaRuJK4HabPcKAAzBcr8IXnDvRB +KgJSQCMABMG6iHO5/x6GnLgepg3aFPAsuFMgAgAehgO6mbgepuSDBeIFJwARAKEFgwGhBoMCoQeD +A6ED4s9woADMF89xoACUE1yhAdqA4gf0HoaXuB6mINgKpRjwAMED2hgYWIABwRkYWIACwRoYWIAD +wRsYWIAUGJiAhhYBERAYWIAE2SelFhiYgIkHb/ykwOB48cDhxc91gAAwg89xgACICgCBdBUCFhBy +IfQCkeoVAhcQch30dhUAFsII7/93FQEWjCACgBPyz3KAAEQFIYIA2w8jAwAFuGZ5IaIAIIEPgACo +XQCBqriIuAChANg1B2/89B0cEM9wgABUdiiIz3KAABCFjCECgAKSQSgDAwvy67gJ9AW5x3GAAKhd +ApEPIMAAArEA2OB/BLIA2kokAHRIcagggAPPcIAAFITPc4AAlIQ0e0CzNnhAoEGgAeFKJMBzANmo +IEACz3CAAKhfNHhAsAHhz3CAAEQFQaDPcIAAEIXgf0Sw8cA2Dm/8VGiGIvgDibpTIcMARXvPcoAA +qF8Ueo/hiiUPHMogKQAJ9gCSAN4PJk4QiiXPH8Z4ALJKJAB0ANqoIEAGz3eAAIyEVH/El6R+0XPP +cIAAFIQM9ADexLdWeMCgwaDPcIAAtIRVeMCgAeIxBk/84HjxwMINb/yYcgh1z3aAAJSE9CZAEM93 +gAAUhFEgQILKIEEAyiQidMogIgDoIGIC9CYCEFEiQIID8gHgkOBGAAYALbvAu89ygACoX7R6QCuF +AmCSBL2GJfgTib0PI0MAYLIA2hZ/QKdBp8O5pXkFIUMBFH5gts9xgAC0hBV5ABkAAQLwgNilBU/8 +CHHDuM9zgACUhPQjAgDJulBxyiQidMogIgDoIGIC9CMCAMm6UHED8gHg4H7xwA4Nb/wA2Qh1AYDB +uIPgyiBBAMAKYv7KIEIDgeAR8hCFUSCAgQ/yEIXPdoAAyHXuuBnyz3CAANwKAogf8AHeAvAA3gLZ +z3CgAPQmI6Alhc9wgAB8fhYPr/0hoBkFb/zJcBCF77gH8s9wgADcCgOIBfAFhSaFag6P/5QeAhAf +hgQgvo8QcAAAEvTaCkAJgOAF8lElQNMB2QL0ANlVJkAaz3OAAHQz2g8v/5DaEYXPcYAARAUAoUEo +DwPDv5QWgRBBKAUFUSHAgRRpBSDEAwbyHYaVuB2mf/BPJEACvv+Q4PIABgDPcYAAtITwIQMAlBaB +EEApAgaGIf0PUiHBAUW5JXrPcaAAxCdBGZiAAiXCgMAihA8AAAAQDL/XcgAAAAiQv1L2BSdPEWIZ +2IOMIgKAx/bPcYAAzBUMgQHgDKEA2Z25S/Dle2IZ2IDXcgAAwA9SAAwADiKBDwAAABDPc4AAFIQW +e6DhQIMBg1H3ANsPI0MAQiNFAE4hDwgBKsMDOHoFIkIBOHgFexbwQiEBCADYDyBAAGG4OHoFIgMA +iiL/Dwrwz3GAAMwVDYGKIv8PSHMB4A2hAdnPcIAA8IQkqM9xgAAwg+MZHAFyGZgAcxnYALfxANmc +uR+GJXgfpkAlABKcHgAQL/HgePHAGgtP/Ah1VSBPBBHMosHtuNEgYoAK8gYSATYA2JgRAQDWCy// +CHLPcIAARHYLgM9xoADIH2TgHqEQ2A6hAdgVGRiAAYWA4AT0USMAwPzzAYXBuIPgdPQAh0HABBQA +MUEoEAMQhVEggIEGFBExRfIRzOu4RPIQhc92gADIde64BvLPcIAA3AoCiA7wEIXvuAbyz3CAANwK +A4gG8AWFJoVWDI//USDAgZQeAhDKImEgC/IdhpW4HaaKIAUJngzv+wDZSiIAIJQWgBDPcYAAXH4E +uEaRBSAABFBwCvLPcoAAzBUAgkoiACAB4ACiBJHXcAAA//8Q9EoiACAO8M9wgAA8ZiuAAN4B4Sug +Ugzv+4ogBQxadgGVnOAU9MGH4ofPcKAA9CYC2SOgI4XPcIAAfH4hoL4PL/6pcIHgBvQB2IPwENiB +8EwiAKAi8s9woADELMegz3GAAFR26KAoiUAoAiMQuZ+5RXlBKQIhRXkmoBHM67gO8hDZq7gQGlww +ERocMM9xgAA0ZwKBAeACofYLj/0REgE37LkH8gjYrLkRGlwwAvAA2EwiAKBN8s9zgAAwg+ATBAAU +FQUQRCw+BwAjQQ4AGUABTJVCsc9ygABUdkiKz3WAAFx+SKkJGQIEChlEBMOhxJXkoUAkTQDgG0AD +ELpAKAMjZXpBKQMhZXrKsc91oADAL0cdmJDPcqAAaCzwIoIDS7GPFQOWCPCjFQKWjxUDllEiAIEF +9Oe7+fME8Oe7yiMhAEDDARSCMMa7xrpYqXmpNQFv/KLA8cDaCE/8z3GAAPCEJImA4Rbyz3GAADCD +chEOBnMRDQbPcoAAzBXjERAHz3GAAEQF4IEigjS/AeEiojLwz3KgAMQnERIBhlEhgIEA3/jzZBID +hmQa2IMC2RMaWICA4y8pwQBOIYIHE/LPcYAAFIRWecCBoYHPcYAAlIT0IZAAz3GAALSE8CGPAArw +z3KAAMwVIYLpdel2GncB4SGiQYANcUChJJANcCCwz3GAAIh+AIGA4AfyQoENcECgANgAoc9wgACI +CgiA67jKIIIDyiFCA8oiwgPwDyICyiMCBFMgwCDPcYAARAUggRS/USGAgAy45XgK8oK4DXEAoQ1w +wKANcKCgIPANcQChSiQAdOB4qCAAA0QmgRAPuVMmABAleA1xAKEivkokAHTgeKggAANEJYEQD7lT +JQAQJXgNcQChIr39Bw/8z3KAABSEz3GgAAQlT6FWIgAEEaFWIgAFEKHgfkokAHQA2agggAIA2s9w +gACUhDR4QLAB4ebx4HjxwFYPD/zPdYAAXH5Elc9xoABoLPAhkQCA4M93oADAL1PyL43PcIAAsGDP +cqAALCDPdoAAiAo2eCKIPBISAA6NOBYQEYDghAApAMogqQCMIgGkeAAlAATYANgFolDYRSFBAhja +YgzgACDb+LgI2C70A9jPcaAA9AcFoYTaDXBAsEIiACgNcgCyQIUNcECgQpUNcECwQIYNcECgQpYN +cECwBpVAKQIlw7gMuIK4BXoNcECgANgEoQ6NAeAOrVoI4AAKcAHYFfAA2ADZSB9YkEkfWJBmlQy7 +n7sFI0IERx+YkC6tz3KAALhmOYIB4TmixQYP/OB48cDhxQDdCvBELT4XJ3Ac2aYL7/vF2gHlz3CA +ADCD4BABADB1svfBBg/84HjhxeHGgODPcYAAeIVFgSbyz3OgAMgfQBMOBkAogQLPdYAAyHVAFQAR +0H7YYNyVPmbPcYAAiAppEY0Aon4IJg0QAn0JIkIDAtgVGxiAX6Migc9wgAB8fiKgwcbgf8HF4HgA +2c9wgAB8fiCgIaDgfyKgANnPcIAAfH4hoM9wgADIdTyQz3CAANwKFYjPcqAAyB8CeR+CMHkQeAgh +AQAweQLYFRoYgD+i4H7xwOHFCHXPcIAAsGUAkIbgDvSKIBQNug+v+6lxANjPcacAiEmB5cogYQAO +oeUFD/zPcIAAsGUAkIbgB/QG2c9wpwCISTCg4H5RIADD8cAv8s9woAD0ByeAGYAweThgA7iWIEIF +z3GgAMgfHqEQ2A6hAdgVGRiAGgzv+4HYUSAAwxXyz3CAAEwFAdkhoALIpBABAJq5pBhAAGoI7/4B +2M9xgABIFgSBAeAEodHA4H7gePHA6gwv/JhwQYHkunCJOfKyic93gACoXdVrxmdkyva+CBGFAEkg +wAAH8s92gACwYHZ+wY4C8ADex3CAALBgdngEiAglDRAIJY0TACVAEUkgzQMWa7V4z3WAALBhBWXP +cIAAyF92eM9zgACICn2DAYBleAQggA8AAAAIBn0C8KOB6L2YGUADANsJ8qQRAAAA25e7kbiUuKQZ +AABRJACAJPIZyM92gAAQWsC68CYOEM9wgAAQn4QuCxowIEAOBCCADwBAAAA+uB7gGHpFff69mBlA +Aw3ypBEAAIUjAQSMuJG4pBkAAJwZwAAd8P+9z3KAAIgKEoIQ8qQRDQCFIwEElruYu429kb2kGUAD +nBnAAJ64EqIJ8JS7lrucGcAAnrifuBKiMQQP/OB44cXhxpgQDgAZEgI2BCaBHwAAAAg7eQQmjR8A +AAAQJX3PcYAAEFrwIYIAz3GAAJCfhCoLCgAhQg7pvkAiAQaYEIMACfJEIwIMRLpOYYm+yXIW8FEm +AJI6kgvyHOLCu35iyI56YlCKpX7QfiV6CPDDu3x7fmJ6YlCKyI4leogYgAOleowYgADBxuB/wcWh +wfHAJgsP/Ah1R8DovShw3gAhAEh2A7hAIJEFJ8HPcIAAvEAEJZIfBgAAAEEqQiQrYAQlgB/AAAAA +Nripd3piz3OAAABIxr8IY0pjGmJBLYASUiAAAMC4A7gY4IXiyiCNDwEAiQ3VII4ALyAIIAQlgh8A +AAAYz3CAAPhB13IAAAAIHgAiAPAgwAOg4RIAAQDPcUJ70F4FKH4ACiDADipxBSk+AAogwA5MIgCg +JLgB4ATyUyABADhg7b0CKIEjz3KAAMQKVZIR8s9zgAD0QWCTBSs+AAAhgH8AAP8/Lrg4YI8AIABY +YBV5hwAgAFhhUSVAklAAIQAnxbflIgALADNoUyUCEM9wgAAwQfAggAAFKT4ACiDADgHgBvCK5cAo +4QDAKKIAz3GAANwKLonA2qR5hiH/DiK5OnraejcAIABYYDNoUyXAEBx4z3KAAERB8CIAABbhBSk+ +AAogwA7PcoAAxAo1kgHgFXkIktp4OGAQeAjcFwIP/OB48cCyCQ/8ocEacCh1ANikGQAAz3eAAIgK +EqcJyAQggA8AwAAA13AAwAAA0IkW9BnIz3GAAAhwFHkRiYDgDvTPcIAAMGHWeCKICI0Qccb2CnCG +DO//qXHT8FEgAKB/8gQVBBBRJACBO/IZyM9ygAAIcBR6ERKFAM9zgACoXVVuQmMPePa6Mo1JIMAA +CPLPcoAAsGDWekGKA/AA2sdwgACwYNZ4BIgIIQEACCGBAAAhQAFJIMEDFm41eM9xgACwYQFhz3CA +AMhf1nhdhwGARXgEIIAPAAAACAZ5AvAjhZgdQBAZyM9ygAAQWvAiAgDPcIAAEJ+EKgsKMCBADlMk +AgAEIIAPAEAAAD64HuAYekV5/rmYHUAQCfIA2Iy4pB0AEFDYnB0AEGvw/7kO8gDYjbikHQAQz3BA +AVAAnB0AEADYnrgSp13wANikHQAQBdgUuJwdABDA2Bi4EqdR8FEgQKdC8gGFUSAAgTPyMo1kEoIw +SSLCABVuz3OAAKhdAGP2uAjyz3CAALBg1ngBiAPwANjHcoAAsGDWekSKCCGBAAghAABJIMEDFm41 +eM9xgACwYQFhz3CAAMhf1nhBgB2HRXgEIIAPAAAACAZ5AvAjhZgdQBAZyM9ygAA4cBV6IKIA2ATw +BdgUuJwdABBRIAClANjPIGIEyiAhAKQdABACyAGAz3GgAMAd7LgAgdAg4gDPIOEAAKERjc9xgAAI +RMK4CWF0HUQQz3GAABBE8CEBAKQVABAleJgVARBRIUCCpB0AEAvyO5eAuHYdRBB4HUQQpB0AEBHw +KIdal1EhwIB2HYQQCfI7l4O4eB1EEKQdABAD8HgdhBCOC+//qXCkFQAQRCB+gowVghAV8mIXgRBE +eYYi/wNEuoYh/w5ZYc9ygADEQfQiUgDPcoAAtEH0IlEADfDDus9xgADUfFx69CGSAM9xgADEfPQh +kQCYFQUQ4LjKIUIEFfSIFYEQUSUAgsO5PHnRICKFCPLPcoAA9Hz0IkEAB/DPcoAAxHz0IkEAQYVR +IsCAyiEhAFElAIKEHUQQI/KYFYIQz3GAALxAz3OAAKhdSWEEJYIPBgAAADG6WWFVbkJj+7oS8pe4 +pB0AEATYuB0CEADYj7i6HQQQz3AMQKj+GaUC8AHZBCW+jwEAAMAL9AohwA/rcgXYiiOXDOkDr/qK +JIMPgeEa8oLhzCHigMohwg/KIsIHyiBiAcojgg8AAP4FyiQiALwDovrKJQIBz3CAALBg1ngDiAfw +z3CAALBg1ngCiIwVARAOuCV4jB0AEP/YQMC2CaAJi3AIcoQXABAglXQVDhGYFQMQgODZYcwiIYA4 +8hnIhuA28rXhaAAMAM92gAAIcBR+EY6A4Cz0AsikEAAAUSAAgCb0USAAoCLynhUAEa67r7uKuJ4d +BBCA4rC7mB3AEAn0hBcCEC8qgQBOIoAHI7hAwADADuAPIwIAmB2AEFEiAIIA2MogYQOYHQIQmBUA +EDYK7/8A2qQVARAEIb6PAAAAMIIdBBBQ8owVAxCcFQIRlB3AEJIdhBDsuYAdRBQCEg42D/IU2pAd +hBB+HYQUeBYCEQIijiDQfrIdhBMQ8A7akB2EEADafh2EEHgWAhFKIgAgAiGOINB+sh2EE89ygACw +XECChiJ/jwr0mBUOEFEmQJIG9JG5krmkHUAQELpFeaQdQBAyhwQjgw8AAAAQUiMDA2V5BCGCDwAA +ABBdekV5Mqcd8JgVARBglZQdQBCeFQERdBUCEbIdBBCSHUQQuBWBEHpiWWEweZAdRBAA2TpxWnGA +HUQQfh1EEAAiQSQ4YIQVAREZYTB5sB1EEL0E7/uhwOB48cBmDM/7ug+ACYDgggIBAAjIUSCAgXoC +AgACEgM2z3WgAMgfKoOkFQAQjCH/jw3yInjXcACAAABH94fYkLhTAiAAoBsAADCLFWnHcIAAqF1A +gAQivo8AAAATV/Lpugjyi9iQuCsCIACgGwAA7Loz9EWQgOIa9AnIBCCADwDAAADXcADAAAAK9BHY +FLigGwAACg5v++bYI/CI2JC4oBsAAPoNb/vn2Bvw6NjyDW/7SHECyKQQAQC0uaQYQACSEAEBp7mS +GEQAnhABAae5nhhEAAXwhdiQuKAbAADPcIAAiAoYiITg1fQCyM9xgACgMVCIDIEPIIAADKHPcYAA +PAgAgQHgAKHF8CKQMxOAABEhAIAm8gnIBCCADwDAAADXcADAAAAV9AiLgOAV9qQTAAC0uKQbAACS +EwABp7iSGwQAnhMAAae4nhsEAArwAYNRIICBBvKN2JC4oBsAAJvwCMgEIL6PAAABEHTyog+AAgIS +AzYIcrATDgGoGwAAFYVVJkEW1bgwcM91gAB4hUT3BdknpSWFAnnk4cogJQAJIIAArBsAAKQTAADy +uFbymBOBAMO5Ccg8eQQghg8BAADwGcjPdYAAsFwWfeWVrBMNAEEuBgMJJcQTz3WAABBa8CUFEIAT +DwF+Ew0B/WXPd4AAxAr3lxS4/WUIJE8Don8D5891gADIQ/AlTRAivwUt/hNTIQ9wACdNHi8kQgNA +LU0BNX3HdYAAiHXglc9xoADELO+hoZWuoUAuDQaevQV9BSRAAwqhz3GAAEwFAdgAoQbwoBUCELAT +DgHRckb3BdgYuKAbAADPcIAAiAQAkCCTCSEBAM9woAAUBAmAEHHL9wPYGLigGwAAz3GAALhmDoEB +4A6hQQLP++B4BCiADwAAL7pCKcJ0UHpEKv4CAiBADhB4gOAE8gHiUHqD4ECxA/aA4AP0ANgC8IDY +4H7geKHB4cXhxkLBz3WlAKz/WKXPcoAAxArVkkiS2mJCewPjIrt6Y3piSCJCAAW6RSJCAye4VqVT +IAIAIsAEIYEPAAAAIAe6JblFeCV4ibiOuBmlwcbBxeB/ocDpuQf0BCC+jwAGAAAL8lEhgIIJ9M9w +oAD8RBmAUSCAgvrz4H7xwCIJ7/tKJEAAz3WgALRHVxUAls92oADIHwDfBCC+jwAoAADCJAIBbxUA +lkwkAIAEIIUPgAAAAAQggw8gAAAABCCCDwAGAAAF8kAWARaD4YP3ANkC8AHZ+HETFgGWBCC+jwA4 +AAAEIYYPAAAAgMwnIYDAJ2EQBSNBAQUhgQEFIb6ABfSJ56QHzv9MJgCABvKA48wiIYBg8msVAZbj +uQnyz3GAALhmDIEB4AyhTPBTIb6ACfLPcYAAuGYLgQHgC6FC8Oe5QPSA4wjyz3GAAMwVCYEB4Amh +OPCA4iLy+rgJ8s9zgABIFkaDAeJGownw+bgJ8s9zgABIFkeDAeJHo7j/IvBxFQSWbxUFlgohwA/r +cs9zAADhDqEFb/oF2FEhgIHPcYAAzBUG8hyBAeAcoQzwANieuFMdGJAA2FcdGJAKgQHgCqHd2ADd +mL0OCm/7qXGpcB7wExYAlvC4yiAhALgOYfvPIKEDaxUBllgVAJYLIECADfIWC2/+AdgD2c9woAD0 +ByqgBdiYuALwANj9B4/7ocHxwIYPj/uhwUfBCHZIdWh36bkEIZEPAQAAwAogACEv8gLZz3CgAMgc +KaAnwVNt7uFQeAT0i3Fi/xnwt+EH9Bt4EHiLcV//EPCU4QP0HHgJ8IrhBPQAHIQwB/DPcAAA//8A +HAQw4HgA2M9yqQCk/7miABQBMYK4N6Iaoijw6LkO8kwgAKDRJuKRyiCBA8oiQQNkDeH/yiPBAxrw +J8CA4MohwQ/KIsEHyiBhAcojgQ8AAD4OyiQhAGwEYfrKJcEABb2leM9xpQCs/xahaf8KJQCQE/Tn +vgzyTCAAoA30AdnPcKAA9AcsoAPZBvAD2c9woAD0ByWgz3CAAPAFAICA4Afyz3GAADQdBYEfZ+Wh +z3GAALhmCoFRJoCSAeAKoQbyTgugBUEpgCOpcAjcvwav+6HA4HjxwGIOj/sIdc92gABMBQeGEHUK +8vXYBbhaCK/7qXGB4AL0p6apBo/78cA2Do/7pBEAACh18rgA2DHyz3KAAEwFIIKA4THyAKJ+FQER +gBUAEThgz3GAAMQK95EfZ1EhgMX+889woADELMuA5NgmCG/7yXFTJoEU/r7MISKADfKYFQAQqgqv +/wDaz3GAAMQKKJEiePhgCfAA2AfwGcjPcYAAsFwWeQWRgOCsFQEQB/SkFQIQsbqkHYAQA/AJIQEA +A9oYus9zoADIH0+j+BMNAEFtCCGBAKJ5oBtAAADZmLkuo+UFj/vhxeHGpBACAPi6CfK2EAEBz3Cg +AJgDPqB+8AAWAUE8sAAWA0FEIQ0DfbAAFgNAhOVvoAAWA0FAGMQAABYDQHGgABYDQUgYxAAZ8hjb +chjEAAAWA0CI5XOgABYDQVAYxAAAFgNBVBjEAAf0KHOGI/MPjCMMgAzyGN4U8BDechiEAwDdz3OA +AKx8p7MM8B7echiEAwAWA0B2oAAWA0FcGMQAKHOGI/0MjCMCggn0AubQfnIYhAMAFgNBAvAA2+G+ +YBjEAATyABYDQbgQgwCgkNtjcHtyGMQAwn2wfboQAwFwGEQDSHSEJAyQZXk8sAvyABYBQGi9OqAA +FgFAsH07oHAYRAOYus9xoACYA6QYgAA+gbYYRAArAY//PJAIckQhAAOE4CbyGcjPc4AAwHD0IwAA +JXgcsgGC7bgJ8lQSAQG8EgABw7kleFQaBAAJyM9xgACsfAQggA8AwAAA13AAwAAAANjKICIAzyDi +Agex4H7gePHABgyP+89wgACICmoQEAEZyM9xgAAQWvAhAgDPcYAAkJ+EKgsKACFGDhESDTdAJggG +RiXBEREaXDACEgI2AN6kEgEAhLmkGkAAIYJAJgcC7rmiwYYahAMD9KC9sH1TJX6QogIBAM9xgAA0 +ZyeBz3OAADRnAeEnowYSATbPd6AAvC2kGYADDqdvh/e7/vNvh/a7UyPPAiHyjudK989ygABIFuOC +trsB5+OiF/Bkv/B/kBnEAwQjjw8AAADwLL/wqXQZhAPAseGCyKmGJ/8dhL/hoVKKUqn2uyoCAQAA +2vW7lrqkGYAAEfI6Dm//ANgGEgE2pBEAAAQggg8CAAAALbqlelB9PfBBgVEiAIFP8nCJD3hJIMQA +z3eAAKhdFWsAZ/a4UokH8s9wgACwYHZ4AYgC8ADYACSPD4AAsGB2f+SPCCLCAwgiAABJIMIDFmtV +eM9ygACwYQBiz3KAAMhfdnrPc4AAiAp9g0GCZXoEIoIPAAAACEZ4mBkAAADYlrj0uEGBhiL/DSDy +gOJT8pgRggBAJgAJSGDPc4AA9HxAwCDCw7pcevQjggBV8AohwA/rcgXYz3MAAIIKiiSDD+EHL/pK +JQAAmBEDAOm7nBmAAyTygOKAuKQZAAAr8pgRgADPcoAAiApiEoIAhiD/A0S4MiAAEIm4QMAgw2R6 +hiP/A4Yi/w5Eu3piT3rPc4AAtEH0I4IAIfBRIwCCCfKA4gnymBGCAEAmAAlIYAzwgOIE9ADaSHAR +8JgRgADDuBx4MicAAEDAIMLPc4AAxHzDulx69COCAIgZAACYEQAAhBmEAJARAQF2Dm//ANoGEgI2 +AhIBNs93oADIH4QSDgGCGgQAHmbQfrAahAP4FwAQsBEDAQJ7ACMABM9zgACICmQTAwF4YNhgoBcP +EBB48XBaAA0Az3CAAIgKEoCYEQ8ACyDAgyP0UIoQiRBy0ScikhHymBGPAM9ygAC8QOpigeLJ9gW4 +z3KAAKhdAGLxuA3022Nwe4YZxADPcYAANGcIgREaXDMB4AihaQGv+6LA8cACCY/7z3agAMgfoBYE +EPgWAxCE4CX0AhICNqQSAAD0uHYSAQEH8s9wgABMfqGAA/CCEg0BEcxRIACBhBIAAQjyAiXCEAIk +gwAIIwMABfCGEgMBG2PPd4AAiAps8IHgR/QREgI3AsjkungQAQEh8lEiQIDPd4AAiApkFwIRCfJ+ +EA0BQn1ifQIkQwMq8IAQAwHPdYAAMGEAI4QAcIh2fWCVACMNAYQQAwG7YxrwpBACAPS6CPJwiM9y +gAAwYXZ6YJIE8IIQAwGAEA0Bz3eAAIgKZBcCEV1lu2OEEA0Bu2OAEA0BumJ+EA0BIn0l8ILgz3eA +AIgKHfQCEg02EcxRIACBeBUBEWQXAhEJ8oAVABFCeGJ4AiQDAAfwghUDEYQVABFbYxtjgBUNESJ9 +BfAA22hxaHVochHMUSBAgGkXhBAI8gLIdhABAQIhAQFZYQnwgOMCIQEBxfZqFwARGWH4FgAQPWUC +fR+GEHWM96DYD6YA2B+mP6YC2BUeGJCA2A6m6Qdv+3B44HjPcYAAuGYNgQHgDaEZyMdwgAAkcCyI +AeEveSyoz3CAAGgzAogQccr2iiAIAAgaGDDPcAEIAAAN8APZz3CgABQEI6CKIBAACBoYMAnYGLjg +fvHALg9v+wDZz3CgAPxEvYDZgAQmgp8AAAACDPQEJb6fAAYAAAb0AsikEAAA+rhU8s9wgADECheQ +z3GgAMgf+r0foSDYDqES8gLIz3EDAIQAoBhAAIogCAAIGhgwiiAEAP4IL/sA2Sjw+b0M8tH/AhIC +NghxoBoAAOYIL/v82BzwAhIBNqQRAAD6uMogYgHAKCIEDPSA4hDyz3KAAMwVCYIB4AmiCNiQuKAZ +AACKIAgACBoYMKlwyXFL/QPez3WgANQH0qVWDM/8Ex2YkwLIoBAAAAPwKHDFBk/74HjxwFIOT/v6 +CG//CHbG/89xoADIHwh1QNgPoUARAQYwedYNr/zJcJkGb/upcPHAAsikEAAAUSAAgM9wgACICgTy +HZAD8ByQ7/+A4D30z3CgABQEA9kjoCDYEBocMM9xgAC4ZhGBAeARoQLIANqYEAEAdBADAZQYQACe +EAEBkhhEACCQO2O4EIEAeWEweZAYRACkEAEArLmtuaQYQACAEAEBfhADAYAYhAA7Y7AQAQFieTB5 +sBhEAIIQAQF+GIQAshhEAJ8AT//geM9wgACYhQaAA9vPcaAA9AdloYHgAdjAeAy4hSADAQ1zALMC +yADafZANcGCwAshxgA1wYKACyEgQAwENcGCwRKHgfuB48cBCDW/7CHMQiTMRjQAB2kCrGRIPNs92 +gAAwcO5mz3KAAFhwQNzBqxkSDzYCIg4D9CbOE8GzGRIONvAiggNBo0GBUSIAgRDy0onPcoAAsGAW +etyrQIqGIn8MXHoEukV+3KsE8IDaXKsEuAV9vasckc9ygACgcA+zGcjwIgAABLMJyAWjVBEAAQyz +AJENs6ARggBIowjIBCCADwIAQQDXcAIAAAAD9Ii6SKMIyAQgvo8AAEEQA/KJukijnBEAAc9zgABM +BSa4wLhAKAIDD4HAuA24RXjVBG/7BaPgePHAagxP+wh1AsgHiFEgwIAL8gDYRgsv+5C4ANmSuc9w +oADQGzGgz3CgANQLGIBCIAAISCAAALDgTAgl+8ogJQzPcYAMLADscCCgAcjscQChIIXscCCgIYXs +cCCgIoXscCCgI4XscCCgJIXscCCgJYXscCCgJoXscCCgJ4XscCCgKIXscCCgz3CgAMAvoxAAhlEg +AIH58wnIz3GgAGgsBCCADwEAAPAsuPAhDQDPcIAATAXFgNnY5g3v+gUmQRPqCS/7BSZAExEET/vg +ePHAmgtP+wh1z3GgAMAvoxEAhlEgAIEA3/jzCchAGRiAGRIBNobhqXAE9GIIj/4R8MH/z3aAAIh8 +0XUL9CqOgOEH8oogUg2KDe/6h7nqrrUDT/vgePHARgtP+xkSAzbPcYAACHAA3XR5AhIONqCxQYbu +ug/0qLHIGUQDUI4FusdygACoXeWSgOfD9mG/5bIAI4IPgAAkcKSqrKrPcoAAsFx2ekKSuBlEA3AZ +hADPcYAAoHB1eaChIYYEIYEPAAAAYNdxAAAAIA70z3GAABBa8CHCAM9xgACEBFR5QJEQ4kCxA9rP +caAAFARQocb/2djiDO/6ARIBNg0DT/vgeKHB8cCWCk/7ocEodQh2GnIEIb6PAQAAwGh3LPTovUDF +DfIgwc9wgAC8QClgBCWAHwYAAAAxuDhgAvAB2AQlgR8CAAAB13ECAAAByiChAIHgDfKC4Ajyg+AA +2Mog4QHAKKEDB/AD2A64A/AA2I64BX3JcBoIL/6pcclwqXEKculzSiRAAKL8gOAZ9FEgAMML9M9w +oAD8RB2ABCC+jyAGAAD181EgAMMA2An0z3GAAMwVCYEB4AmhANiYuAjcQwJv+6HA4HihwfHA4cVR +IACCCHWYACEAQsAiw89wgAC8QAQlgh8GAAAAMbprYAQlgB/AAAAANrh6Ys9zgAAASEpjCGNYYEEt +ghJSIgIAwLoDuhjiheDKIo0PAQCJDdUiDgBQcUIAJQAA2O29GAAhAAIhgADPcRxHx3EFKH4ACiDA +DgPwIripcsa6673PcYAALEP0IYIABfI8alR5MHoFKj4AQSmAcAjcswFP+wohwA/rcgXYd9uMu0ok +AAC5Bu/5CiUAAfHAGglP+wh2MIjPcoAAMGERzDZ6USBAgGCSDPLPcKAALCAPgIQWDREIIEADongD +8GhwsBYNEWTlsXAyAQ4Az3WAAKhdBbkhZQDfBCGND4ADAAA3vWW9SCUNEAQhgQ8YAAAAM7kN4Q8n +TxAJIMEAAxKQANYO7/+YFgAQmBYDEAkgwQNocsa667vPcIAALEP0IIIABfIcalR4EHoiurh6A2oE +IIAPAAD8/89ygABMfgOiz3KgAMQsDaIwGgAECcgEIIAPAQAA8Cy4GLhPIEMHGcgUuGV4BXkqos9y +gADMFR2CAeAdom4K7/rj2FEhgMX/889woADELKuA5NhaCu/6qXEEJY8f8AcAAP69NL9TJYEULfKB +51YADgAAlhDgEHFOAA4AEI7PcoAAqF0FuABi+7jVIcIDz3WAAEx+IKXipZgWABCqDC//ANoBpc9x +gAC4ZhyBAeAcoRqBH2cRzPqhRiCAAhEaHDAB2Ajwz3GAALhmG4EB4BuhANgFAE/7pBABALe5pBhA +AADZOaC4GEIA4H+6GEQA8cDPcIAATH4BgM9xoADIH5YgQQ8eoRDYDqEB2BUZGIAT8M9xoAD8RB2B +OYEEIYKPAAAAAhH0BCC+jwAGAAAN9FEjAMAm9M9woAD0BweA/7gA2+nzLvAA2/q4yiOCDwAAAQL5 +uMojgg8AAAIC/LjKI4IPAAABAoDiCfLPc4AAzBVJgwHiSaOKIwgCvg1P/xLwAdnPcIAATAUhoFoK +7/0ocM9xgABIFgSBiiMIAgHgBKHrAS//aHDgeFEgQMPxwCjyz3CAAEx+AYDPcaAAyB+WIEEPHqEQ +2A6hAdgVGRiAog3v+kHYUSBAwxLyAdnPcIAATAUhoP4J7/0B2M9xgABIFgSBAeAEoYojCAIv8M9x +oAD8RB2BOYEEIYKPAAAAAgDbBvQEIL6PAAYAABryANv6uMojgg8AAAEC+bjKI4IPAAACAoDiCfLP +c4AAzBVJgwHiSaOKIwgC8gxP/wfwA9nPcKAAFAQloDcBL/9ocOHFAhICNiCSQYJA4fS6wCGiAAPh +z3OgANQHDxMNhgQhgQ8AAPz/sXAaYcj3GcgVIgEwGhEABh1lAiJBAxkTAIYQcT73DxuYgOB/wcXx +wKoND/uowQDdz3eAAEx+EcwAFxEQz3agAMgfYYdRIECAAsgO8qAWAhD4FgEQInsCItYAdhADAS8m +iCVbYwXwhBAWAcJzOhiEBR+GEHPJ93B4z3GAANwKZguv/TWJAdnPcKAA1Ac0oDOgA9ktoBEQF4bP +caAA1AdWJwAiDxkYgBQZWIMCyKQQAABRIACCBfJGDEABA/BHHliTz3CgANQHDRABhkAuACQweQUg +UAACyCGAABATAUDBuBCCAHIQAQECIZQAuhABAULCQ8FZgM9xoADUB4gZgABW/wnIz3GAAFx+BCCA +DwEAAPAsuAISAzYEsQ+DrqkAoUATAAECsRCLYBMDAVRow7tleg+pRrEZEgI2z3CAAIRwIYdAIAQH +VXhHgDpiR6CkFgAQGWH4FgAQAnlEwc9xoADUCwHYEKEih89wAAD8/wK5K+EkeJe4mribuOxxAKEB +EgE27HAgoCKH7HAgqBkSATbPcIAACHA0eDCI7HAgqOxwoLAZEgE2z3CAAFhw8CBBAOxwIKAZyPAk +AQDscCCw7HCgsOxwoKDscKCgCRIBNuxwIKACyCCQVBAAARC5JXjscQChAhICNgGCUSAAgQ7yMopQ +is9wgACwYFZ4AIiGIH8MHHgEuCV4A/CA2OxxAKkCyM9ygABMBTCIMxCAAAS5BXnscCCo7HCgsAIS +AzbPdqAA1AecEwABJrjAuEAoAQMPg8C4DbgleAWiGRICNs9xgAAIcAAigA+AADBwoKjPcIAAsFxW +eFR5oLECkLgZRAMVJIIAoKJwGQQAz3CAAIgKHJDIGUQDRcAA2EHAWnAIdwh1K/BMIgCgBvQQzFEg +AIAT8s9woADQGxGA8bjKICEAQArh+s8g4QMA2ZG5z3CgANAbMaAA2BQeGJACyEAiUiDPdqAA1Aco +iAHhKKgJEgE2z3CgAEgsPaDPcIAATH4CgFJwmAIOAEwiAKCE8t7+BSUNkEYCAgAPhhB4GRYBlljg +MHDU9w+GEHgZFgGWWOAwcMb3hBYAELLgN/cPhhB4GRYBlljgMHCmAA0AHh7Ykx0WAJYGEgE2CRoY +MB0WAJZAJwMSR8AdFgCWALEdFgCWAaFWJwASHh4YkB0WApZALgAkUHoFIhAAANrPcKAA0BuRulGg +z3CAAFQDEHjPcqAAtEdJGhiAz3CAAAwFYKDPcIAAEAUgoG8gQwBUGhiAz3CgANAbEYDxuAf0ANg2 +Ce/6j7gGEgE2AYFAwApwhiDzD4wgDIAAERMBD/Ia2A7wz3KAALhmHoLPd6AA0A+KIBAhAeAeotHw +INgCwppwWGAQeHIZBAAAwPa4B/LPcaAASAhAIwAjBvBAIwAhz3GgAEwIG3ECwUwiAKAAIRkAA8AF +IBAgQCHAMQQggA8AAPz/RsDPcIAATH4jgAbACCBVABTyDCVApN4ADQC1/gUlDZB39AHYFB4YkFUn +QBQPHhiQUSIAwv/1z3agANQHVB5AFgAYADQCIwAlD6YGwQIhUSVMIgCgAiVAIBumA9gQpgISATYZ +8iiJqXDIuAy5JXjscQCxA8zscQCxAcAB4EHAB8AGEgE2+ncBGhgwAsgCGlgwBhoYMAGBIJFWJw8i +NLjAuBR5z3AAAPz/A+EkeB9nGRIBNgbwFSJAMBoQAAYCfxUiQDAaEAAGEHd39wPMz3GfALj/GKHP +cKAA/EQ9gAQhvo8ABgAAdgXB/0wiAKAV8oolEBAY8M9ygAC4Zj2Cz3egANAPiiASIAHhPaIn8M93 +oADQDxzwCcjPcqAASCyKJQgQHaL6uc9xgAA0ZwbyAIGAvQHgAKEG8AGBgb0B4AGhz3egANAPz3ag +ANQHGnUH8M93oADQD0ogACBTIH6gBPRk/gV9gOUY8uG9DfICyCmIAeEpqM9xgAA0ZwGBAeABoQnw +4L0H8s9xgAA0ZwCBAeAAoRp1Asipcci5CIgMuCV4AxIBNxC5JXjscQChCnSEJAKRAcBAIFIAE/KA +HkAUA8wKcci5ELgleOxxAKEA2AymAdgUHhiQngrv/kAiUiACyJIQAAFRIICCKfJCDcAEENgQHxiQ +JBcAls9xgACIfCWREHgCuSV4DB8YkBTYEB8YkM9wgACIfEeQJpAY2BC6RXkMH1iQEB8YkM9wgACI +fEmQKJAQukV5DB9YkADYER8YkEwgAKBo8s9wgABMfgKAUnDH9wjZ7HAgoEAiUiD18c9wgABcfiSQ +z3CgAGgs8CBAAM9xgABMBSWBJXgOHxiQA9gSpjINT/zpvQTy6nBG/gjwA9gTHhiQANgUHhiQ573K +IIIPAAAGARX04L3KIIIPAAADAQ/04b3KIIIPAAAEAQn04r2KIEQByiCBDwAABwEqCa/6qXHPcqAA +LCAwggTAMHAB2cohJgBEIINAD4Lk4AHYyiAmAIDhzCMhgMwgIYDs889wACgIAAgaGDAFwF4OL/wA +2avwz3CAAHAjEohRIACAF/JRIADDFfLPcIAAcCMPiM9xgADMixC4IImfuIDhAdnAeQ+5JXjPcaAA +/EQNoUwhAKAN8s9xoADUB4AZQATPcYAAuGYdgQHgHaHPcIAAXH4kkM9woABoLPAgQADPcYAATAUl +gSV4z3GgANQLDaHPcKAA1AcA2SygiiAEAloIr/qpcdYPb/8FwM9woADUBxkQAIbA4KgADgARzFEg +QIBQ8s9woADUBwPdIBhYgwHZFBhYgADYz3GAAAwFAKEA2JG4z3agAMgfEx4YkM9wgADcAhB4z3Kg +ALRHSRoYgAbIz3GAABAFAKFvIEMAVBoYgBMWAJbxuMogIQCcDKH6zyDhA89woADUBw8QAoYGEgE2 +tBmEABMYWIPPcBIgAADKC+/+GRICNgbIsBAAAaAWARBk4DBwyiCFDxIoCACF989wACgIAAgaGDAR +zAQggA8AAAIIguAK9AYSATaKIAQAMguv/ZgRAQAZEgE2z3KAABhwANg0egCyAsgaCOACGpA9Be/6 +qMDgePHA4cUCyKQQAQCYEAIAUSEAgHIQAQFIcAby0gnv/gDaCHUH8AHhxgnv/gDarGjOD4ABz3Kg +AMgf+BIBAALIz3OAAKhdEIgFuABj7bgG9AHYE6J4glmCBvAC2BOieoJbggIlQBB4YBBzwCJtAA1x +AKENcECgABYAQAAWAEACyM9yoAD0B3AQAQFouSeicBABAWi5MHkBBe/6cBhEAPHAz3CAAJiFBoAB +2c9zoAD0B4HgGYPAeYDgDLkO8mQTBAAKIcAP63IF2M9zAABRCeUBr/lKJQAAAsgckCV4DXEAsQLI +PZANcCCwAsgvgA1wIKACyEAQAQENcCCwAsgxgA1wIKACyEgQAQENcCCwAhIBNhyRhiD/DITgH/Iz +gQ1wIKACyFAQAQENcCCwAshUEAEBDXAgsAISATYckYYg8w+MIAyACfQ2gQ1wIKACyFwQAQENcCCw +AhIBNhyRhiD9DIwgAoIQ9GARAQENcCCwAhIBNqQRAAD3uAbyOYENcCCgAsgA/QISATakEQAAUSCA +gQfyAYHwuBTym/+bBo/+OoENcCCgAhIBNqQRAACGIPOPBvI7gQ1wIKB7Bo/+dwaP/vHAAdjPcaAA +9AcLoQPYCKHPcKAA/EQ9gBmAUSBAgjX0BCG+jwAGAAAv9OB44HjgeFEgQMMp8gLIz3GgAMgfsBAA +AZYgQQ8eoRDYDqEB2BUZGIAGCq/6QdhRIEDDFfLPcIAATAUB2SGgAsikEAEAmrmkGEAAVg5v/QHY +z3GAAEgWBIEB4AShtgtP/+sFj/7gePHAwgrP+qQRAAChwVEgAIDPcIAAiAoodgPyG5AC8BqQmBYB +EAQhvo8BAADAdh4EEC306LlAwQ7yIMLPcIAAvEBKYAQhgA8GAAAAMbhYYAPwAdgEIYIPAgAAAddy +AgAAAcogoQCB4A7yguAJ8oPgANjKIOEBwCihAwbwA9gOuATwANiOuAV5mB5AEJ4WABGUHkAQkh4E +EIIWABGQFhMRz3WgANQHsh4EEADYgB4EEH4eBBAZFQCWuOAQFpIQTfcRzM9xgAC4ZoYgiAIRGhww +FYEB4BWhnvAPFRGWARIQNgHZz3CAAAwFIKAA2JG4z3GgANAbEaHPcIAA3AIQeM9yoAC0R0kaGIDP +cIAAEAXAoG8gQwBUGhiAEYEJEg828bjKICEApAih+s8g4QOkFgAQ9rgi9AkSAjYCIsEDgeEA2Afy +AieBEIwhw48C9AHYgOAU9BHMz3GAALhmhiCIAhEaHDAUgQHgFKEPHViUCRrYMwEaGDRQ8AEaGDQR +js9xgAAIRMK4MiEFAAka2DPPcYAAEER0HkQR8CEBAKQWABAleKQeABAAlqBwEHiQHgQQcnDKIcIP +yiLCB8ogYgHKI4IPAAD4BqQGYvnKJMIEEBaEEAwiAKHKIcIPyiLCB8ogYgHKI4IPAAD5BoAGYvnK +JYIEDxUAlrQeBBBmCy//yXCkFgAQhiDlj1ANIv7KIIIDDx1YlAkB7/qhwOB48cC2CM/6EMxRIACA +AN1Y8s9woADQGxGA8bjKICEAkA9h+s8g4QMCyM9ygACoXTCIBbkhYs9ygABMBS25wLmEKQsKACGB +f4AA8J4morQRAgbPcYAAsFxAoc9xgAAAXUiRGRIBNs92oADUBxEiQICQEAABEfIZFgGWOOAwcMv3 +z3CAAJgEIIDPcAAAmB6aDW/6h7kPFgCWAhIBNrQZBAAIyF4Or/4ZEgI2AhIBNpIRAAH2DW/9lBEB +AAHeHfAD2M9xoADUByAZGIAB3hQZmIMAFgBACRoYMAAWAEABGhgwAsi0EAABDxkYgMvYBgpv+hkS +ATYZEgI2z3eAAAhwFCeAECiQgOECEgM2FfSYEwEAVX8spzSnz3GAABBa8CGCAM9xgACEBPQhgQC8 +G0QAyBhEAAXwyBAAAbwbBAAeC+/+oBuAAwISAzagEwAABCC+jwEBAAAY8gDZz3CgAPxEnrkhoM9w +oADQGxGA77gk8rYKb/0B2M9xgADMFR+BAeAfoRrwkhMAAZQTAQCQEwIBshMDAZoP7/5KJEAAAhIC +NqASAQAleKAaAADO2EYJb/oBEgE2AhIONqAWABAEIL6PAQEAAGjyz3CgABQEA9kjoAjIBCC+jwAA +ARAj8qQWABDyuB/yz3GAAEwFAIGA4BnyoKFRIYDF//PPcKAAxCyrgOTY8ghv+qlxUyWBFP69zCEi +gAfymBYAEHILr/4A2gISATagEQAA8LgK8oogCAAQGhwwoBEBAIcGIAD62PS4IvIJyNCJANozEY8A +BCCADwEAAPBBKA0Dz3GgADguB4EPIkIDAdxGeAehGcjmDKAHACwAEMd3gACoXQW+EOffZ6CviiAQ +AAgaGDACyKAQAQAvBiAA+9gDzM9xnwC4/xihxg/v/hnICMgEIL6PAAABEBvy2g/v/gISATaA4AIS +ATYM8qQRAADxuBHMxSCiBM8gYQARGhwwAYHuuAXyEcyAuBEaHDDM2A4Ib/oIEgE2Wggv/wLIbgkv +/wLIAhIBNhyRhiD9DIwgAoIP9BCJz3KAALJdBbgQYoHgB/RgEQABhLhgGQQAUSAAwwv0z3CgAPxE +HYAEIL6PIAYAAPXzUSAAwwDYCfTPcYAAzBUJgQHgCaEA2Ji4gOAM8gPZz3CgABQEI6CKIBAAWwUg +AAgaGDACyKQQAAAEIL6PAAAAMNjy9LgJ9DYJD//W2G4PL/oIEgE2AsikEAEA7LlW8loPL/rN2CIM +L/8B2AISATYD2h2xz3CAAJiFBoDPc6AA9AdFo4HgAdjAeAy4hSACDQ1yALICyF2QDXBAsALIT4Dg +ugDZC/LPcoAATAUGgqKADXCgoAaCRpAG8A1wQKACyEAQAgENcECwAshRgA1wQKACyEgQAgENcECw +JKMCyBkSAzZ+EAEBgBAAAc9ygACEcHV6GWEHgjhgbg4v/weiCBIBNoMEIADQ2LIOL/rR2AISATYB +gfi4D/LPcIAAUAgAkB2xz3CAAFQIQIABgFGhEqEH8FYLL/8C2AISATYdscYOD/8CyPYNL/94EAAB +gOA6BAIAAsgZEgI2gBABAc9wgACEcFV4R4BZYSeg0thODi/6ANkCEgM2AYOYEwEA+LiUG0AAFfLP +dYAAiHypcLoOL/9ocRDYEBocMBHMo7gRGhwwoghv/6lw4wMAAJ4TAAFAk3QTDQGSGwQAumJQepAb +hAAqCW//ghMDAQh1z9juDS/6qXH4vQ7yA9nPcKAAFAQjoIogEAAIGhgw/dibAyAAqXECyKQQAQD0 +uVUgwgdz8m4KT/8CEgM2gOCSEwIBlBMBAEjySHDPdoAATH5Ahs4J7/5ils93gAAAXSiXgOHKIIIP +AACEHrwIQvrPdYAAnAQAhYDgIvIZyAISAjYVIgEwmBIAABoRAQb+D2/+INojlQIgTQACyCCGmBAA +AOoPb/4g2hB1CHFI9xC9z3AAAHQedghv+qV5Mg1P/wiXgODKIIIPAACEHlwIYvrKISIA6wIAAKQT +AACnupIbhACQEwIBtLikGwAAkhMAATIJ7/6wEwMBA9nPcKAA9AcloALIGRIDNpgQAQBVIMIHz3CA +ADhwdXggoAqCUSAAgQj0lg7P/tvYygwv+ggSATYCyKQQAQAodIQkGpAJ8gYPz/0D2c9woAAQFCWg +FPBRIQCCB/JuCcAA6gnAAAzwcBACAc9woAD0BwDZR6DPcKAAyBwnoAISATbT2HoML/qkEQEAAsgB +gPm4B/Q2CS//BNgCEgE2HbFq/bH9GnDU2FYML/oKcQISAzYZyIQTAgGCEwEBBCC+rwYIAABZYc9y +gACEcBV6B4I4YPYBIgAHos9woAAUBAPZJaABg1EgwIAl8qQTAABRIACAz3CAAIgKBPLdkAPw3JDP +cYAAcCMSiVEgAIAV8g+Jz3GAAMyLELggiZ+4gOEB2cB5D7kleM9xoAD8RA2hA/B2Ew4BEcxTIECA +DPLV2L4LL/oIEgE2CMgGEgE2GRICNqr9z3WAAIh8qXAuDC//AhIBNhoLL//JcIDgr/QCyJIQAAFR +IICCuA5CBALIAYBRIMCAXPLX2HYLL/oA2coKr/2A2AgSATYEIYEPAgABANdxAgAAABESAjcJ9P24 +B/JPIsAAERocMAXwo7pQeBEanDACEgI2IYJRIYCBLvKLuIy4ERocMDCKMxKAAAS5JXjPcYAAXH7P +cqAAOC6kggaxEPAvKkEDTiKDBwDaDyLCAEZ9z3KAAOBv9CLCAFBwCfKA5fH1z3AAAP//BLEG8GSx +z3CfALj/dqAI2BAaHDDPcYAAuGYRgQHgEaEo8BDYEBocMBHMo7gRGhwwPg0v/6lw2NiuCi/6ARIB +NgLIAYDuuAj0GcgB2gAggQ+AAIhwQKkRzFMgQIAK8gYSATaKIAQANg4v/ZgRAQACyBqQKgtgAhkS +ATYRzFEgwIAIEgE2EvJeCi/619jPcIAArHwCEgE2AoCYGQAACMhWDm/+GRICNggSATbc2DoKD/ph +AI/64HjxwOHFb9iVuM91oADIHxIdGJDPcAEAQDwVHRiQwgiP/YogBAAOpU0Aj/rgePHAyg9P+q7B +z3agANQHA90THliTDxYQlhkWAJbA4L73ABYAQAAWD0DveJzgyiHCD8oiwgfKIGIByiOCDwAAKgvK +JMIAHAUi+colIgCLcAIPL/oO2QYUATEAFAAxUSEAgcAgogAD4AvDBCCADwAA/P+A41YgAQIO8s9y +nwC4/3qiLMN7ogLDfqLPcwBsBAB5ohkWApZQcD73ACEABA8eGJAgHliT5dheCS/66XEBwAQggA8A +AABAeQdv+q7A8cAOD2/6A9vPcqAA1AcTGtiADxINhgAWAEAAFgFAL3ic4Mohwg/KIsIHyiBiAcoj +gg8AAJULyiTCAGwEIvnKJSIAABYOQNB+ABYQQFYmABJRIAClwCCiAAPgBCCADwAA/P8ZEg6GQiAP +BNF3O/cdZQ8aWIMgGtiAzggv+trYBCCALwAAAEDtBk/64HiA4OHFAdod8i8pAQBOIYMHz3GgAGgs +8CHNAK99z3GgABgs8CHBAC95MHXKIiIAgOIJ8gDZDyHBAAYgQIDm9QHYAvAA2G0AT//xwDYOb/rA +2oIkAzAIdRpxz3GAAAhITgyv/YtwAdnPcKAAFAQkoM9xgAC4ZhOBAeDivROhyiciEAP0vf8IdxnI +z3GgAGQuz3KgADgu8CEBAAeCBCBRAJzwtf/PdoAAiHwId8lwmggv/4txPgov/8lwjvAA2M9xgAAM +BQChANnPcKAAyB+RuRMYWIDPcIAA3AIQeM9xoAC0R0kZGICLcM9ygAAQBQCibyBDAFQZGIDPcKAA +yB8TEACG8bjKICEAdAwh+s8g4QPhvkQmjRQN8o7YUSYAkZC4oBwAMFHyhtiQuKAcADBL8IDnBvKM +2JC4oBwAMEXwJMAFuMdwgACoXSCAKHSEJAyQEPJRIUCCAd0H8ovYkLigHAAwMfCI2JC4oBwAMC3w +IpAzFIAwESEAgBTyCcgEIIAPAMAAANdwAMAAAAr0IsCA4MogiQ8AAI0AzyApBBL2CsGMIf+PEfLP +cKAAyB+kEAAAInjXcACAAABH94fYkLigHAAwAd2A58wlIZBs9QPZz3CgABQEI6CA56l2cfVTJn6Q +CPLPcKAAFAQJgIDgafXhvgfyBCEAJIP/gOBh8+UEb/qAJAMw4HjhxeHGocFKJAByANmoIMAOACGC +D4AAmJ+EKAsKMiJCDs9zgADEfM91gACICkDCIMLDulx69CODAEwVAhF6YnqVYrpbYwPiz3WAAMhD +8CVNECK6BS2+EFMhDnAAJkIeXXrVaDV+x3aAAIh1QLYD4yK7BS3+EFMhA3AAI0IOXXpBtgHhocDB +xuB/wcXgePHA4cWpwYt1qXDPcYAAyEgKCq/9JNqpcJ4O7/4CEgE2Pggv/6lwSQRv+qnA8cDKC0/6 +ocHPcYAA8Hokgc9ygACICtqSz3OAANR8BCGBDwAAABBFIUEDQMEgws91oADIH8O6XHr0I4MAoBUC +EMJ7UHNwAC0AAN9+FQKWo7p+HZiQEHhwe9YIL/8U2vi4KvQD2M9xoAD0BwWh5NoNcECwDXDgsIoi +/w8NcECgz3IAAP//DXBAsM9ygABMBQaCYIANcGCgBoJCkA1wQLDkodoND/5AFQEWMHkOCe/8yXAB +2APwANh9A2/6ocDxwM9wgACIChiIheAO9M9wAQCghpILQACeDQABCHHPcIAAHBoCDoAA0cDgfpEE +L/kT2OB48cDeCk/6z3WAADQaBYUDgM92gAB0c0CAAobPcS0AwMY4YAJ6gOLG9u4PD/v6Dw/7IobH +cS0AwMa6DaAAqXANA0/64HjPcIAANBoFgAOAIIDPcIAAdHMioNkBr/sR2OB4z3CAADQaBYADgCCA +z3CAAHRz4H8ioOB4z3GAAPhyAIGAuOB/AKHgeKkBr/sR2OB48cDhxWYKoAAw2LRoXgqgADnYBX0Y +vZC9z3CAAOxIegqgAJS9KLileM9xgABsBZUCb/oAocHZz3CgAAQlIKDgfuB+4HjxwOHFz3WAAByF +qXB6CS/6A9kBhc9xoACAJQyhAoUNoQCNUSAAgADYjrgE8g+hA/AQoRoJD/pJAk/64HjxwMYJT/rP +dYAAcAUAhc92gADIdeSQ6XGmD2/8hiH8A1EgwIAacAXyH4aAuB+mIIUAkThgAKVUFoAQgOAV9Olw +AgxgAIYg/AOA4AzyUSAAoAvyz3CAAIgKCYBRIECABfQfhoK4H6bFAU/64HjxwGIJT/rPcIAAyHU+ +gAQhgQ///484BCWAXwAAcMcleM91gADIdRoMYAAepYDg+gEhAJgdABBRJYDTB/LPcIAA3AoCiA3w +USXA0wfyz3CAANwKA4gF8AOF1gqv/SSFlB0CEB6FhiD/A6DgCPRRJcDSBPSA2JQdAhCUFYAQUSDA +gUAoAQYV9FEigNOCuRryRCI+0wz0z3CAAMh1AYBRIACABPImDUAAHvAiDkAAGvAehVEigNOzuB6l +xSGCDwAAAAdFIQAGz3GAAFR2KImGIf0PUiHBAUW5JXjPcaAAiCQQoYoh1gDPcKAAgCUvoM9xoADE +J0ERAIZRIsDTzyDiAtAg4QJBGRiAz3WAAMh1AJUEIIAPAADMgNdwAADIgAj0C4VRIACABPLKCY/8 +UvAehfO4VBWCEELyTdgJuBoZGICA4gbyAdrPcKAA1AtSoATYEBkYgE1xPgrv+YogRA5RIIDEBPRR +IQDG/PPPdYAAyHXPdqAAxCcuFgGWFoUieGS4EHiGHQQQz3GAAIgKmgngAC+RGhYAlgQggA////8A +Gh4YkBEWAJbruBTyANiLuBMeGJAa2BkeGJAM8IDiB/IB2s9woADUC1KgBNgQGRiAHoVRIICBNvIU +lVEgQIEy9M9woAAsIA+AgOAs9MoNAAeA4AbyUSVA0wHZA/QA2VQVgBCA4MwhooAw2gP0kNrPc4AA +dDO+Ci/9VSVAGh+FlLgfpR6FkLgepQzwz3GAADxmDYEB4A2hENnPcKAAkCM9oJEHD/rPcKQAkEFN +gM9xgADodEKxGoBRIEDGA7EEIIAP/wAAADC4BLHPcIAA6HQA2gjyz3GAAMh1MYFRIYCCBfJCsEOw +RLDgf1mw4HjxwNYOD/rPcIAAyHUOkM9ygADodACyz3CmAOj/C4DPdaQAtEUDogwVA5YNFQGWz3CA +AMh1RBCOAC8mxwD/2BC4yXSEJAOcBCMHAAT04L4t9DIVAJZTII8A/2cBsv/Y9H8IuO9/ZHhALwQS +ACQFAAAmxgMFJYUBQC8AFgQjgw8A/wAAQC8GFBtjACeHAf/YBSXFAQi4BSNDAQQhBQD5YQAlAAEF +eeWyb3gEI4MP/wAAACi7ZXgveQOyJLIEFQCWArLPcIAAyHURgFEgAIIM8s9wgAC8QMhggeDG9s9w +pgDo/w2ABPAA2AaiBaIA2EokgHAG2Y25qCAAAynbErvwI00AQCIDDxV7AeGgowHgMQYP+vHAug0v ++hvYz3GgAMQnUhEShhURD4YA3c92gADIdRYZGIDjv8ogQSMQ8h2GAd2DuB2mz3CAALhmIoAB4SKg +vg+v+YogxQgadVEgwMZKIQAgEvIdhs9xgADAZQHdOnWEuB2mBYEB4AWhiiCFCY4Pr/n8EQEAUScA +kQXyVBaAEIDgA/IA3wvwHYbPcYAAuGYB34W4HaYFgQHgBaHPcKAAxCdMIACgzCEhoMwnIZA/8gDY +nrjPcaAA/EQBoQDYBaEehrC4HqaoFgAQz3agAMgfZOAephDYDqYB2BUeGJDeC+/5CdgD2B6mENgO +pgHYFR4YkM9xoADEJxkRAIaA4ATyUSMAwPjzTxEAhtIKj/uA5wb0z3aAAMh1OvDPcYAAuGYFgQHg +Ag9v+wWhu/BPEAGGQhAAhgQgvo8AwAAAKPIBth6G87gg8ooghA6yDq/5iiHODpoLwAAAloYg/ACM +IAKAFvTuCcAAgOAS9APZz3CgANQLMaDgeOB44HjgeOB4MaAG8ACW0g/gATSWVBaAEIDgIvLPc6AA +/CVUg89xgAC4ZgaBgOJYYAahB/IB389ygACpCOCqU4NngYDgemJHoT6GOvLuuRjyAdnPcIAAfAUg +oDLwUSIAoBbyAdnPcIAAqQggqM9xgAC4ZgOBAeADoT6G6vHvuSDyAdnPcIAAgAUgoBrwA9nPcKAA +1AsxoOB44HjgeOB44HgxoEwhAKAL9B2Gz3GAALhmgrgdpgSBAeAEoQHdHobwuArylRaAEKQWARDJ +cgIKL/wB2wTwPgpP/B+GUSAAgAfyz3CAAIh8KgjP/s93gACsgxmHgOAF8vIMz/0A2Bmnsg1P+89w +gACICgiA67gL8oDlCfQb/89wgADodKDZfgjv+cTaHobwuNwNwv15Aw/64HjxwBILD/rPcYAAdHbP +cIAAcAUgoADZz3CAAER2KaDPcAAA/z/PcaAADCQBoRvYBKFRIADEz3aAAMh1FfIdhoS4HabPcIAA +vAQggAWBAeAFoYoghQkCDa/5JIFGDE/7pwIAAEQWgBDxhsK4BCePHwAAAAhUFoIQ+3+A4s91oADE +JwDZFfLg2r8dmJCU2pUeghAE289ygABEBWCiAto8HYCQz3KAAHx+IaIH8EDZvx1YkNTZlR5CEAAg +kQ+AAPCevBGBIAAgkg+AAIyiCBKAIAUh0wNKDK/7BSDQAwHYEB0YkMQRgCDPcYAAxHzleBumbBaA +EMO4HHj0IQAAZB7AFF4eBBAQEoAg5XgcpnAWgBDDuBx49CEAAGgeABTPcYAA5HxgHgQQZBaAEMO4 +HHj0IQIAih6EEM9ygAD0fPQiAACOHgQQaBaAEMO4HHj0IQEA9CIAAIweRBCQHgQQEMyGIP+FkAyB ++89wgACICgiA67iYCsL/HPDPcYAAiH4AgWOBQ6FmeAChBIEMFQGQEngleAwdAJAA2I+4Ex0YkIog +vw8IHQCQGtgZHRiQAgiP+892gADIdR2GUSDAgaX0z3WgAMQnERUQllEgwKMA2tb1USBAohr0USCA +oy/0USAAoFj0USDAoGbyCNgTHRiQNgqP+4DgW/QC2DwdAJAjhs9wgAB8fiGg1PHV/aAWABCRFQGW +AeDDuTBwoB4AEMj1iiIIABMdmJCRFQCWw7gQccDzEh2YkLzxOhUAllEggIAd8s9xgACIfgCB4LgX +9IC4AKGKIP8AAdoEoUOhOhUAloYg/wEDuAGhDBUAkEYgAA8MHQCQCB2AkADYjrgTHRiQUSUA0Jbz +BNnPcKAAkCM9oJDxzv0C2DwdAJAjhs9wgAB8fiGgHobzuITzLPATHRiULfBUFoEQgOEJ9EIVAJYE +IL6PAMAAAAT0USAAog3yvxUAloDhpbi/HRiQiiAEABMdGJBm9VEggKAO9AohwA/rcgXYiiMMA4ok +gw/BBa/4CiUABBMdGJSX/mkAD/rgeOHFz3WAAOh0CaUqpXi1S6UB2Bm14H/BxUokAHoA2agggAIA +2s9wgADodDV4QKAB4eB+4HhGgYDiCPIjgWCBIoJieTBwANgD9gHY4H7xwM9xgADgGphw+P+A4Any +z3GAAAAbiHD0/4DgA/QA2Anwz3GAACAbiHDw/4Dg+fMB2NHA4H7geAhzOGDVu9W5MHM2uMT3AiNC +AArwz3KAAHiFRYIB4Mm4Inp6Yha44H9FeOB48cBuD8/5CHXXdSUAAIAA2Er3z3GAAHiFJYEwddD3 +In0B4Pnxz3CAAHiFxYCpcKIIIADJcQUuPhACJU0ejCAQgMohxg/KIsYHyiBmAcojZgnKJCYAqASm ++MolBgEWuH0H7/mleAHaz3OgALAfWaN+g4DgBfIie3Bwg/cA2ALwSHDgfuB4z3KgACwgcIKA4Ary +AiNCANdyAIAAAAb3UHCG9wDYBfBwcH73AdjgfoDgDfLPcqAAsB8B23miXoIielBwwiCNAAL3ANjg +fuB4CiJAgADZ7gABAC8mAPBKJkAATgAGAE8AIACKJf8P4HgKIkCAANnOAAEAbAAkAC8mAPBcAAUA +Kwg1CEomQAAIcQDYAiG+gOAgxQdCeQHgAiG+gOAgxQdCeesH7/8B4C8tAQBAJUUAAiZ88QAAIAAA +KEAB6CBiAy8gAIAvIUsAAiG+gMAghgHCIYYA4H4RACAASiAAEEogQBAOIkIALyALEs4gRYCKJf8P +CAAFAC8tAQBAJUUAAiZ88QAAIAAAKEABSiZAAOggIgMvIACALyFLAAIhvoDAIIYBwiGGAEomAABC +IP6QziCCAUQgfpDOIYIB4H45BgAA4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfwHY8cDhxc9x +gACICimBUSFAgMogogAo9ES4z3GAANAaw7gJYeC5BPJRJYDRG/RRIUCAGfLPdYAAiAoYjYHgDvKi +C8AGgOAH8s9wgADkoQyIh+AE8hiNguAH9FElgNED8gHYAvAA2J0Fz/nxwCINz/lEIg5TTXWGJfwT +TXBNcAQlgF8AAAAgQSh+gwXyVgvABoDgA/QA3wLwAd+I5hP0z3CAAIgKGIiB4AbyUSVA0QfyBfCG +JfbXA/IB3pjwAN6W8IDm/fXPdoAAyHVUFoAQgOD39Q4LwAaA4B3yz3CAAOShDIiH4MwgYoIV9AGG +jCD/jxH0JJbPcAAA//8QcQv0BYaMIP+PB/QMltdwAAD//9XzhC8LGgAhgH+AAPCeKYDPcoAA+EhR +IUCBBfJAIgEHA/BAIgEEGIgJYUEtABEIYhZ5z3CAABRJfLg4YCgQgADguAbyPoaGIfaPGPLhuAby +PoZRIYCCEvLiuAXyUSUA0gPyAd4L8OO4CPLPcaAADCQxgYwh/4/38wDeUSCAgcomIhBSCsAGgOAH +8gQlvt8AAAAiyiZiEIDmFfLPcYAAyHUegei4HPKMJQKQzCWCnwAAUADMJYKfAADQABL0k7geoQ7w +z3CAAIgKCYDhuAf0jCUCkAb0USCAgQLyAt4JBO/5yXDgePHAmgvP+c9woAAMJBiAQSiEB0EtAFTB +uIPgCvczJgBwgACQSUAnAXIUeQB5ANgY8M91gADIdZQVgBBAKAEGhiD9D1IgwAFFuCV4z3GgAIgk +EKE+hbO5PqVT8AHYRCg+DQAhgH+AAEhgIYjPdYAAyHWUFYIQz3agAIgkUyFFAD6FQCoPBoYi/Q8M +JECBUiLCAUW6BfLlelCm3vHPc4AAeElig5q55XtlelCmPqXPcaAAyBwQ2kmhJIDPcqAA8BcmoiOA +JqIigCaiIYAmooYVARFouTB5hh1EEFMhwYDAICEIwCAiDCCAM6IsaCCBM6L4EAGCM6L8EACAE6IA +2AqiBQPP+eB48cCCCs/5z3CgAAwkYBATAM91gADIda1wQSuQJ4Yg9w+UFYEQQShRAgDYNngCcMdw +gAAoXRUgQATgiM9wgAA8BSCAE28VeBBhRCCUgFMgjgAEI4AvACAAAMwgIoAH9EwkAKDMICGAANgC +9AHYWnCKIJUBWgxv+QpxiiDVAU4Mb/kqcYogFQJGDG/56XGKIFUCOgxv+clxkOfaAAoAgObMIiKg +afJMJEChzPcKIcAP63IF2JbbiiSDD3EHb/gKJQAFz3CAAHhJ8CCAA0AogiOUFYEQBXqC5kApAAZF +eIYh/Q9SIcEBRbkleM9xoADEJ0EZGIAo9B6FENkDv/V/mrgepc9woADIHCmgz3CAADwFQIDPcKAA +8Bf5YieBJqD5YiaBJqD5YiWB+mImoCSCJqAA2SqghhUAEWi4EHiGHQQQLPBKFYAQgOAo9IYVABEw +HcAUZLiD5hB4hh0EEAn0KxEBhmS4EHiGHQQQLaUKCW/96XAS8JQVgRBAKQAGhiH9D1IhwQFFuSV4 +z3GgAIgkEKEehbO4HqVBAc/5z3CgAMgcENkpoAHYz3GgAPAXCqECEgM2HJOGIP+MKPQPg1EgAIAk +8s9ygABIYASCBqEDggahAoIGoQGCBqFwEwABHuBTIMCABPRAIgAIBPBAIgAMQIBToUxoQIJTofgQ +AoJTofwQAIAToQrwCIMGoQeDBqEGgwahBYMGoeB+4HjhxQISDTbPc6AA8BcPhc9yoAD8FwijQBUA +EQqyEYUIo0gVABEKshOFCKNQFQARCrIclYYg8w+MIAyAB/QWhQijXBUAEQqycBUBERyVCOEIsh2V +CLJUFQARCLJgFQARCLIZhQejGoUHoxuFB6NyFQAROGAQeAiyz3CgAPQHJ6AC2c9woADIHCeg4H/B +xQhyA/AB4CCIgOH+9eB/QnjxwLDg4cUIdYP2ueXK9gohwA/rcgXYEtuYdV0Fb/i4c0IlABw1AO/5 +D3jgePHAtg+v+dhwAN3v/8logOaU9vhwqXcyJoADsOCI9rngBvbt/zJvOHgFfQHnQidHAEwnAIBh +vjH35Qev+alw4HgKJgDwiiC/D8ogZADgfy8gAwDgf4og/w/xwGIPj/mOCiAACHWA4M9xoADIH0WF +DfL0EQ4AAoBkhcR6RXv0GcAAIoUAoQrw9BEAAER49BkAABzYGLgVGRiAjQeP+Q/ZmrnPcKAAsB81 +oOB+4HjxwA4Pj/kIdc92oADIH6QWABC4YKQeABAB2BOmWIY5hgDYACJCgwEhAQBYpjmmAtkzpjqG +W4YAIUGDASCAADqmG6YVhlYNoACpcRWmF4ZODaAAqXEXpg/YmrgOps9wgAAgG9P/z3CAAOAa0f/P +cIAAABvP/wUHj/nPcaAAyB/0EQAAANpGIMAP9BkAAA3ImribuJy4DRoYMBzYGLgVGRiAWKFZoVqh +W6GkGYAAz3AADA8ADqHgfuB48cBWDo/5z3WgANAb04X6vgbyz3CAAOAaegkAAPu+B/LPcIAAABtu +CQAA/L4G8s9wgAAgG14JAAAc2Bi4E6WFBo/54HjxwOHFJYBAgEIiAoDKImIAgOLKIcIPyiLCB8og +YgHKI4IPAABeAMokIgB4A2L4yiUCAWCBMHMK8kKAooNCfYDlBPZggzBz+vVBgwGjYKBBoACiRICl +gFEiQIBAJQMWC/JGhYDiBvKigkKAQn2A5cP2AKNEgKWAUSLAgEAlAxcL8keFgOIG8qKCQoBCfYDl +w/YAo0GAUHEF9BoO7/8FgOkFj/ngeECAEHII8mSCCyNAgAX0QIIQcvv1ANrgf0hw4HjxwE4Nj/kI +dgCAQiABgMohYgCA4QDYJvIlhkGGAd8wciCGQYZBoSCiAKbPcK3eAgABpqWGwH8GhRB2BvSpcALZ +6f8GpaWGB4UQdgb0qXAI2eX/B6WA5wXymg3v/wWGAdhVBY/58cDqDI/5CHUoduX/CHfCpalws/89 +Ba/56XDgeCCAEHHKISEA4H8ocPHAwgyP+Qh3HvAAhiGGIaAAoQDYAKbPcK3eAgABpqWGBoUQdgX0 +qXAC2cz/BqWlhgeFEHYF9KlwCNnI/welI4Zgeclw6XDs/womAJAI8gOHIIAChiJ4gOCyB8z/Cg3v +/+lwyQSP+eB48cDhxQh1A/DB/6lw4P+A4Pz1wQSP+eB44H7geIDhyiRNcOB46CAtAs9xoABQDCWB +ARhSAOB+4HjxwCIMr/m4cJhxz3OAAHwFAoMjg892gADIdc91gACUSQJ5HoY5uMG4FH0BFYcQz3Cg +ANQLPBAGALBxz3WgANAPANpE9wDYRvCoFgAQz3GgAMgfZOAeoRDYDqEB2BUZGIAZcwbwz3WgANAP +CXMXFQCWI4MCIMABAnlIIQEAAoMCeUghAQBMJECAE/RQcdH3z3OAAEwbAoslFQ+WwbjTaAHgAqsD +g9h/53gDowHi7/FRIwDAEvSwcc9zoADUC6gHxf8IEAEQAdigcQgYQBA8G4ABuQOP+WIJD/u28eB4 +8cBGC4/5z3CAAFR2CIiMIAKAK/I1aMdxgACoXcCBz3KAAMhfz3eAACiFTBcPERZ6YYJQJo0Vhie7 +H6ChjCdEkIYjAQ5hogX0kb2goQvwsb6B57a+wKEH9Ja+wKGFIwEOYaLCDY/5ANnPcIAAKIVBA6/5 +TxhCAOB44cXhxs9wgABUdgiIjCACgM9ygABghRfy1orPcYAAyF+1aMd1gACoXRZ5gOYAhWGBBfKV +uAClq7sE8LW4AKWLu2GhANgXqsHG4H/BxfHAggqP+c9wgABUdgiIjCACgC/yz3WAACiFMoXPcoAA +yF/VaMd2gACoXWCGRCEEgxZ64YIT8lAjgQUgpkwkAIGGJwEe4aIF9JG5IKYE8LG7trtgpgoNj/kG +8Ja7YKaFJwEe4aJPFYAQorhPHQIQfQKP+eB48cASCo/5z3aAAFR2CI6MIAKAMvLPcIAA8J5IgM91 +gAAohTGFt7q4ugQhgQ8DAAAAB7lFeSigngkv+gDYEYVIjs9xgADIX1EggIIVasdwgACoXWCAVnlB +gQXylbtgoKu6BPC1u2Cgi7pPFYAQQaGjuE8dAhAJAo/58cB6CY/5ocEIdUDBz3aAAMh1AJZKJkAg +hiD8AIwgAoDCJoIlAtjKcVP/gOAO9B6Gs7gepgDYz3GAAGCFF6nPcYAAAIUMsWnwQiWSEEx0hCQD +kP7z4HjPdaAA0A8lFQ6WJRUPlkokQCAQFRWWAm8MIgCgwiQOJS8jACVaCKAAyXBMJgCgGnAUJxEV +EfKF5gfyi+YA2MogYQAC8ALYz3GAAEwbJIELIQCAA/IA2QLwAdkqcDH/gOAU8kwgwKEj8s9wgAB4 +GxYgAARAgAaIEHYP9IDiDfLpcGB6AMEW8M9xgADIdR6Bs7geoabxCiHAD+tyBdiKIxcESiQAADEG +L/gKJQABAdiidxAd2JMCIlIkgODMIyKgnPWxAK/5ocDhxc9wgABMGyCIAduA4WGoIPLPcqAAsB95 +on6CQoCjgFB1ANkY9M9ygACYBUSKgOID9AHaCvBBgAIjjQDXdUwAQEt59yGoKHKB4gP0YaAiqOB/ +wcWioO/x8cAaCI/5GnA6cYogRw1KCi/5iiHVDs92gADIdUwgAKTPdYAAKIUA34b3DNjpcfX+gOAM +9B6GTx3CE7O4HqbPcIAAAIXssCDwqXAM2eb+z3KAAEwbAIqA4PzZC/IAliR4jCACgAX0JZUElSd4 +A6JCIAAjKnGG/wCWhiD8AIwgAoAoD8H/9QdP+fHAng9P+aHBCHaKIEQPwgkv+clxguYA2RD3z3KA +AMh1HoKzuB6iz3CAAGCFN6jPcIAAAIUssJHwAtjQ/oDgjfLPcaAAUAwFgc91gAAohRKtBYETrQmV +jCCIgGK+TfIT9ofgH/KMIMSBcvSC5jD0yXAA2cL+gOAs8lUlwBTJcbj+IPCMIMiAU/KMIBCAYPQF +gQluheBwDeH/yiEhAFjwgeZW9MlwANm1/oDgUvJUJcAZyXGr/k8VgBCBuE8dAhBI8E8VgBCAuE8d +AhBC8IHmQPTJcADZqf6A4Dryi3DJcaD+IMBTIAEAhiB/D0wdQhAceE0dAhDm8Y7mKvTPcIAAiAoY +iIHgJPLJcADZnP6A4CDyz3KAAACFSHAG2ZH+QCIAAgbZj/4MkoG4EfCE5hD0yXAA2ZL+gOAM8s9y +gAAAhUAiAAUE2Yb+DJKAuAyyiiBED34IL/kplbUGb/mhwPHAOg5P+Qh1GnHPcIAAKIVGCi/5RNnP +cIAAyHUegM9ygAD0ezm4UyBBAM9wgACUSTR4QYogiADbVXnPcqAA1Asvos9ygAB8BSGIYqICJUAQ +gODKIMwAA6JNcYYh/APQ4cwhgo8AAIAAD/KMIQOEEPIKIcAP63IF2IojmQ5KJAAAUQMv+LhzCnFl +/wPwhv8RBk/54HjxwJ4NT/nPcoAAyHU+ghpw67mqwQDYEPLPcYAAiApiEYEARBKDAMDdZHmGIf8O +Irk6fQjwz3CAAIgKTBANAQLYhhIBAQJ5EYIE4S4Kb/0A2jYIYAACIE4DA9jPdaAAyB8TpRiFANlC +wBmFQ8AahUTAG4VFwPWFXBUREEAVABYeZs9wgAAohUCAAYAAIoKDASBAAEDCTCBAoEHAi3AK9ITB +BgtgAIbCpgtgBgh2JJAL8ILB9gpgAIbCCHbPcIAAeIUkkM9ygAB4hWWCBsIEu1BzQCmAAof3UHBK +9wJ6UHC/9wXwugtgAIbACHJGwoLmFvTpcEoLYABIcQh3KnA+C2AABsEGwzpwBMIHwQXAACLCgAEg +QABEwhfwgOYW9OlwSgtgAEhxCHcqcD4LYAAGwQTBOnAGwwXAB8ICIcGARMEDIIAARcCB5gvyz3CA +AIgKGIiE4MwmIZAA2AL0AdgvIgegOvTpcNYKYAAD2Qh2KnDOCmAAA9kAwQh3AcBAIcGAQSAAAEHA +BMBAwQXBQCDAgEEhAQBEwPIOIABFwUwgAKAH9NWlAMAYpQHAGaVMIICgDPTVpQDAGKUBwBml96UE +wBqlBcAbpUwgQKAG9PelAMAapQHAG6WKIAcOBg7v+EpxTCIAoAHZwHnPcIAAoDE0qA0Eb/mqwM9x +gABAGyCBANiD4cwhIoAC9AHY4H8PeAoiAIDxwBTy+P+A4MohwQ/KIsEHyiBhAcojgQ8AAKAGyiQh +AAwBIfjKJQEBz3CAAEAbQKDRwOB+8cDPcoAAQBsggoDhyiHBD8oiwQfKIGEByiOBDwAAqQbKJCEA +1AAh+MolAQEBogHaz3GgAMgfUKFKGZgASBkYAN7x4HjxwCILT/nPcaQAtEUpEQCGz3aAADxmEaYr +EQCGAN0Sps9wpQAIDAOAGKYOEQCGEHowuFOmFKYPEQCGFabPcIAABHZQiHKIWaY0iHqmC5A7pizg +AiCPAAIgwgAieM9zgABAGyCDXaaD4fymOAAtAB6mMyZBcIAAnElAJwByNHgAeAPYwf9A2M7/t6YM +8M9yoACoIDGCAoOiozhgF6YB2BKiAdjpAm/5FqbPcIAAmAUEiIDgB/LPcIAATBsBiALwAdjgfuB4 +8cBiCk/5z3aAAPCewxYAFlEgQIEH8s9wgADkoQyIiOAF8gmGUSBAgYvyz3GAAMh1A4H+C6/8JIGB +4Ah1EPR2CEAGgOAM8s9wgADkoQyIiOAG9AHYGP/SCEAGEfCA5Q/0UghABoDgCfLPcIAA5KEMiIfg +AtgC8gDYD/+yCYACz3GAAHiFBoFFIEABBqHPcIAAiAoYiITgz3WAACiFJfLPcIAAXFtWiHeNUHPP +cYAAPGYF8gCAUSAAgA/0z3KAAHwFB4IB4AeiANgFogaiAKIPgQHgD6EE8A6BAeAOoQmGUSBAgaQN +ggDPcYAAfAUEgYDgC/IA2AShz3GAALgGAIGiuO4KoAIAoU8VgBBRIMCARA+C/08VgBBRIICAxA6C +/4j/sf+A4OgKIvjKIOIEz3CAAHAjEYiA4NgKIvjKIGIEkQFP+eB48cDPcIAAAIUMkOC4BPJaCs/8 +BvBRIECA6AnC/M9wgABghReIgeAH8oLgCPSI/YUFz/9p/X0Fz/95Bc//8cDiCE/5z3CgAMQnUhAB +hkEQAIaGIOOPAN0G8uu50SGigUjyz3CAAIgKCYDPdoAAKIVRIECBGPJaDAAHgOAK9BSOgeDKICEB +bAmhAsohYQDPcIAAfH4AgFEggIAE8kIKL/0QlrSuz3CAAHx+oKBNcIYg/AOMIAKAGPTPcYAAfAUJ +gQHgCaHPcIAAiAoYiITgdA3BBYogRw16Cu/4iiFLAIILAAd3/wbwjCADhBgPwf+dAE/5z3GAAHwF +C4GB4Af0z3CgALAfG4ANoeB+Nrg2uTBw1iCFDwAAgADgfyJ44HjxwM9ygAB8BQuCgeAO9M9woACw +HxuADqItgvX/ShIBAThgEHhKGgQAbQTP//HA4cXPdYAAfAURhYDgEPQLhYHgDPSyCQ/4luAI8s9w +oACwHxuAD6UB2BGlHQBP+fHA4cXPdYAAfAURhYDgGPILhYHgFPSCCQ/4luAQ8s9woACwHxuAANoQ +pS+F2f9IFQERUaU4YBB4SB0EEN0HD/kA2c9wgAB8BS2gLqAvoDCgJ6AmoCWgShhEAEgYRAAsoOB/ +MaDxwADZz3CAAHwFK6D0/89wgABgG94Jj/+9A8//CHHPcIAAYBtFgEOCYblggs9ygAB8BUqC1bp6 +Ys9zgAB4hWWDBSt+AAAhgXDHcQAAABAJAo//4HjxwM9xgAB8BQuBgOAV9AHYC6EA2Aqh3f+KIIcO +Agnv+IohDwTPcIAA8J4YiIPgnA/h/8ogYQFNA8//4HjxwK4OL/mKIMcPpMHWCO/4iiERDi4LwASA +4PQOwv/PdoAAfAUKhiyGnf9IFgERShYCEVlhMHAA3cP3AiBNAAeGgOAQ9IDlDvIFhs9xgAA8Zrhg +BaYGhrhgBqYQgbhgEKEAhoDgAN8D8uamiiAIAHYI7/glhgaGQsVAwAWGENlBwAeGQ8CLcHIL7/ii +2gqG56ZKHsQTSB7EEwym4KbWD+/3D9gFhoXgjfcB2Ln/CglP+s9xgAA0ZxiBAeAYoQPwBdiz/1UG +L/mkwIDgAdjCIAwAz3KAAEwbAKoB2AGqANgCqgGiAqIDouB/JKLgeAAWAEABBc/4z3CAAEAb4H8A +gOB48cBeD+/3D9jPcKAAsB87gM9wgAB8BTEC7/8qoM9xoACwHzuBQSiCBdW4QSmDBdW5AnnPcIAA +eIViegWAyboFKL4AJ3HPcIAA4BoDgACA4H84YOB4z3GgALAfO4FBKIMF1bhBKYIF1bkQcVtjSffP +coAAeIVFgllhAnkB4wLwAnlAK4AFJXjM8QDZlrnPcKAA0BszoOB4USOAxf/z4H7gePHABg0P+Rpw +iiAIAM92oADIHxCmAdhBHhgQ9P/PdYAAeIUDhSWF1bgwcMohzQ/KIs0HyiBtAcojjQ8AAI8AyiQt +AGAC7ffKJQ0BZgsABmoLIAYIdzpwTCAAoMwgYqA+9ACFGKYBhRmmBYUUpgOFFabyCgAGgOBb8s9w +gADkoQyIh+BV9BeGt4YEIJAPwP8AABWG1b02CyAAKnHVuAIgQ4MFIAEEN6YC2TOmWoY7hhQABABC +K8AHAiLCgAMhAQAL8GSXCruie3hgAiICgADbAyHBAFqmO6Yr8EwggKAn9ASXCrgWps9wgADwngmA +USBAgRfyz3CAAOShDIiH4BH0AdgTpjiGGYYA2wIhQYQDIMAAOqYbphWGtgogACpxBvAAhxqmAYcb +pgOFF6Y9BA/54HjxwOILD/kKJgCQz3WAAHiFEfTPcIAAoEmpcT4M7/gU2s9wgADgGmIPT//PcIAA +ABsU8ILmC/RKCgAGqXEaDO/4FNrPcIAAABsN8KlwEgvv+AXZz3CAAOAaLg9P/89wgAAgGyYPT/8E +lQq4BaUGhYYgww8Gpclwl/++D4/30QMP+c9wgADgGieAgOEH8gOAQIACgUJ4BPDPcP8P///gfuB4 +z3GAAOAaRoGA4ooh/w8goAXyIoIgoAHYAvAC2OB+4HjxwKHBCHOLcPb/guAA2AfyAMAQcwHYwiAO +AKHA0cDgfuDYANrPcaAAyB8QoQnYsBkAALQZAABq2EIZGAAA2Jq4D6GkGYAAz3AADAAZDqHgfuHF +UyBCBQQgjQ/A/wAAz3CAAHiFBYACIIMABCGCD8D/AADVuSJ4pXtFeBBzyiCtAAX3EHMA2MogZgDg +f8HF4HjxwOHF2HC4cZhy7v8IdchwiHHs/xB1yiCtAAr3EHUA2MogRgGcD+b/yiEGAdkCD/kIcyhy +z3CgALAfG4ACIIAPAAIAAGhx3vGKIf8PIKDPc4AA4BpGg4DiEvIkglEhQIAL8s9xgABoHDByB/LP +cYAAgBwwcgb0QIJQc/H1AtgF8CKCIKAB2OB+8cAGCi/5SiRAAMCBoIAB39F1wiQCAdF1oYFhgMIn +zhMB3rFzwH6xcwHbwiPOAEwkAIDMJiKQyiNiAAv0gOMG9IDmzCcikATyAtsD8ADbgOMU8oHjDvKC +4xr0oIDAgQGAIYECJY2ToKIDIEAAAaIQ8ADYAKIBogzwoIHAgCGBAYACJY2ToKIDIQEAIaLhAS/5 +aHDgeAXwQnnHcEAAAADPcoAAeIVFglBxN/dTIEMFcHHAII0PQAAAAMAgjQDgfyJ4BvBieQIggA9A +AAAAz3KAAHiFZYJwcTf3UyBCBTpiUHOD9zhgB/ACIIAPQAAAAGJ4OGDgfvHAFgkP+Qh1KHZuCi// +AYCghRC5QS0AFDhgXgov/8lxELmweDhgUgov/0AugRJVAS/5KHDVuNW5MHDH989ygAB4hUWCWWHg +fw4gQACl4BzyCfaD4BDyhOAU8oXgFvTgfwHYreAK8r3gCvKMIEOHDvTgfwbY4H8A2OB/AtjgfwPY +4H8E2OB/BdgH2OB+8cCB4OHFANgJ9M9wgAA/hQHdOgxv/6lxqXDlAA/54HjxwGIID/kId89wgACI +ChiIhOAacUjyhOcA3Y4AJQDKIEUDz3aAACiFQCYAE/4Lb/8E2S6OsK5TIQAAEa5BKMAgoLkwcGAA +JQACIEIAY7/xclQABgCA4g/yz3GgANAPEBEAhmG6WGAQGRiAJREAhg94AvAPjgDZUyCCIA8hgQAk +eC8mB/DPcZ8AuP8QrhiBzyDiB9Ag4QcYoRiBnrgYoRiBvrgYoQHYIQAP+eB4g+DxwADYCfTPcIAA +PIVyC2//A9kB2NHA4H7geIbg8cAA2A/0z3CAAESFVgtv/wbZz3GAAHx+AIGCuAChAdjt8fHAmuDh +xQDYjPfPdYAAbIUEbS4Lb/8E2QuNgrgLrQHY0QfP+PHAluDhxQDYjPfPdYAAbIWpcAoLb/8E2QuN +g7gLrQHYrQfP+PHALg/P+BpwTCAAoaHBugAlAADYi3AE3d4Kb/+pcQDAz3agANAP13CaCVBvRfQX +8CUWA5YlFgKWLyTHACUWAJZPfw99TCQAgwi9pX8L8hAWAJb9YfhgEB4YkCNtEnHq9yjwgufMJ+KT +zCcil8olQhAg9M91gABEhUetJRYClgitSa0lFgKWZq2P50qtomkJ9M9wgABPhWIKb/8N2Q3lnOcI +9M9wgABchU4Kb/8N2Q3lAiBBIwPwQiABIRAWAJY4YBAeGJAB2M0G7/ihwPHAZg7P+M92gAD8G/Am +ARDPd4AAzAWD4QCnVPKC4M91gACYhQv0JoWB4Qn0iiAJCGoIr/gA2QjYAKeC4Br0AtgGpQDZz3Cg +APxEnrkhoM9woAC0DwDaXKANyAQggA/+//8DDRoYMA3Ih7gNGhgwKvDwJgEQgeEM9M9wgADIHACA +USAAgAT0ANgGpQPwJqUDyFEggIAE8qoND/oN8ADanroA2c9woAD8REGgz3CgALQPPKDPcIAAiAoY +iITgOA8CAg0Gz/jxwADZm7nPcKAA0BsxoM9wgADMBSCAieHKIcYPyiLGB8ogZgHKI4YPAADXAMok +JgAEA6b3yiXGAM9wgACwG/AgQABAeNHA4H7xwOHFz3GgAKwvHIG9gQR9z3CAAMAEAIiB4An0z3DA +3wEAHKEo2Ri5G/CKIEkGYg9v+IohzgmKIAkGVg9v+Klx/L0K8oogCgVGD2/4iiHODSINQAX2vcwN +wvgA2Zu5z3CgANAbMaBtBc/44HjxwOHFz3WAAJiFz3CAALRJqXFWDa/4SNrPcIAAZErPcYAA0AVC +Da/4CNoA2c9wgADUGymgz3CAAMwFIKDPcKAALCAQgCEF7/gSpeB48cDt/wDYz3GgAMAvgBkAAM9w +yAA8AMAZAAATgYu4E6GS8eB48cCCDO/4iiBJDKoOb/iKIQoIAN3PcIAA9IuhoM9xgADwnkiBoqA0 +kVMiAADeC2/4AdvPdoAAmIUKhoDgrqYI8s9wgACIChiIhOAE9ATYBPBqCoAARgygAADZgOAV9AeG +USDAgAnyiiCJBkoOb/iKIUsBANgI8IogSQc6Dm/4iiGLAgLYZf9pBM/44HjxwADZz3CgANAbm7kx +oAPIhOAL8oogiQYODm/4iiFKAgDYW/8K8IogCQn+DW/4iiEKBATYVv/Q/y7x4HjxwLoLr//hxc91 +oACsLxiF+rgN8hqFwLiB4AHYwHgvJgfwBfQchfy4CPKKIEkGvg1v+C9oigsAARyFUSAAgBryz3CA +ACAcAIBCIACAyiBiAIDgEPTPcoAA1BsJgoTgSvfPcYAAmIUqgYHhBPQB4AmiPIV6DW/4iiCJDZYP +T/dSC0AFgOAI9M9wgADMBQCAg+A0D8H/mQPP+PHAEgvP+Ah3OnGKIMkJRg1v+IohhwnPcIAA0AUg +gAGAViFBCxTgOGAycMohxg/KIsYHyiBmAcojhg8AAOcByiQmAHAApvfKJQYBz3CAAJiFCoCA4Bzy +z3CAAIgKGIiE4Bbyz3CAAJiFBYCC4Mohwg/KIsIHyiBiAcojgg8AAOgByiQiACwAovfKJcIAwg3A +AFjY+g9v+AHZz3agAMgfINgQpjLYQx4YEADYagmv+I24INgRps9wgACYhaQWEBA6Cq//56A1ho4M +b/iKIMkJz3WgAKwvPIV+DG/4iiDJCYogyQlyDG/4KnFRJ8CQPvLPcIAAFAgAgFEgQIA48hgWAJah +uBgeGJCKIBAAEaYZhfC4GYUM8gQggA8IAAAA13AIAAAAAdjAeAfwhiB/D4LgAdjAeIDg7POg3xHw +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhv4wn/5/t9RmFiLgZpfIOj/nPcIAAmIUH +gMC4geAB2MB4Bgzv/lpwvg3gACpwAdjyDOAACnEchfm4IPTPcIAA3AUAgIDgGvQYhYi4GKWg3xLw +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhv4wn/5/u9a4PwACkFg8Qqgvv/kpwYv9c +2KYOb/gB2SDYEKYy2EMeGBAA2BoIr/iNuCDYEaYchfm4yiAiAoAOYvjKIaIAz3AAggEAHKUA2F4M +4ADpcU0Bz/jgePHAsgnAAIDgANnKIEEAIPKqC+/4KHCKIIkHEgtv+Iohxg4D2Jv+AtjPcYAAmIUF +oc9wgADwngmAJbjAuBoL7/4KoQjYiiH/D2T/AdhNA8//8cDPcIAAzAUAgIPgBPSiCAABKf81A8// +8cDhxQh1z3CAAPCeCYDPcYAAmIUluMC4KgjgAAqhgOAG8ioJ4ACpcIDgBPQA2APwAdjVAM/44Hjx +wOHFz3WAAJiFTBWBEIDhDfYKIcAP63IF2IojxAJKJAAAyQVv9wolAAEDyIHgyiHBD8oiwQfKI4EP +AAAMAcogYQHv84LhCfQA2EwdAhDOCa/3FthM8Iogxwvc/4DgSPIKhQDZgOAupQfyz3CAAIgKGIiE +4BL0z3KAAMgcMKIxohDYCaInoiWliiBJB/4Jb/iKIYQJAtgr8EYLwADPcYAA0AVAgSGBliKBARTh +WWEwcDwABQAB2AWlz3CgACwgcIAKJYAPAQAMKwHYBtkIcsdzBwAgof4LoAVKJAAAiiDJBqoJb/iK +IYQNAdhC/uEHj/jxwGoPj/jPcIAAiAoYiITgyiHBD8oiwQfKIGEByiOBDwAARAHKJCEA0ARh98ol +wQByDUAAugrgAAh2gOYIdRL0iiDHC6X/gOAM8s9wgADQBSCAAYCWIYEBFOA4YBB1DPceDM/7iiCJ +BjIJb/iKIUUHANgk/mEHj/jxwOoOr/iKIP8PocFAwM91gACYhQSFgOAA2Qjyz3CgACwgEIAkpQOl +Ag1AAHINYAAacAhx1g5gAApwgOBe9M9wgADIHAmAUSAAgcohwQ/KIsEHyiBhAcojgQ8AAH4ByiQh +ACAEYffKJcEAiiDQB7YIb/iKIUYAig5AAs9xAIIBAM9woACsLzygiiDPC3X/gOA08gKFgODKIcIP +yiLCB8ogYgHKI4IPAACPAcokIgDUA2L3yiUCAfYMoACLcAolAJAc8oogSQZeCG/4iiHGBYogCQZS +CG/4AMGKIAkGRghv+KlxiiCJBz4Ib/iKIcYGA9jm/alwAMG3/lUGr/ihwOB48cDyDY/4JgxAAJYM +YAAIdQhx+g1gAKlwhOAJ9IogCQYCCG/4iiHLBy3wz3CgAMgfpBABABWAz3aAAJiFQYZCeddxAACg +DwDdy/fPcYAAeIUlgdW4QSmCAEJ5MHCE9wKGgOAR9IogCQa6Dy/4iiGLCqKmiiBJB64PL/iKIUsL +AtjC/d0Fj/jgePHA4cXPcIAAiAoYEIQATCQAgcohwQ/KIsEHyiBhAcojgQ8AAP4C1AJh98olIQB2 +C0AA5gtgAAh1CHFKDWAAqXCdBY/48cDPcIAAiAoYiITgyiHBD8oiwQfKIGEByiOBDwAAEAPKJCEA +kAJh98olwQAyC0AAgOAO8gYKz/uKIEkIGg8v+IohTAcH2J79kgmAAHkHj//xwOHFz3CAAIgKGIiE +4MohwQ/KIsEHyiBhAcojgQ8AAFMDyiQhAEACYffKJcEA4gpAAFILYAAIdQhxtgxgAKlwhiC/jhL0 +ig1AAIHgDvQC3c9wgACYhaagiiBJB6oOL/iKIQ0JqXCC/eEEj/jxwGoMj/iiwc9wgAC0STaAz3WA +AJiFF4BAwSWFQcCD4cwhIoAw8s9wgACIChiIhOAq8oHhAN4L9EYJz/vPcIAACHAdiIDgxaUe8oog +SQZODi/4iiGMDwPYBaUNhc6lCiWADwEAxCoM2RUkAjDPcKAALCBwgECCANjHcwcAIKFmCKAFmHBR +BK/4osDgePHA2guP+M9wgACIChiIhODKIcEPyiLBB8ogYQHKI4EPAABFAMokIQBEAWH3yiXBAIog +Bw7aDS/4ANnPdoAAKIUtjoDhBPIMjhBxDPbCDS/4iiCHDYoghw22DS/4LI5j8M9woACwHxuAz3eA +APCFAqeKIEkGmg0v+FfZiiAJBpINL/gih0yODY7PcYAAeIVokUCncHDPdYAAmIUBp4v2CLEA2U0d +QhAB2SylNYUwcMP3FaUQjgSlEY6A4ATygOIE8gDYCvDPcIAAiAoJgFEggID48wHYAqWKIEkGNg0v ++HfZiiAJBioNL/gihwKFIIeA4MogYgAYuAV5BIUKIgCAiiAJBsoiYgAQugYNL/hFeQyOgOAG9AKF +gOCUCYEFbgxv9wLYIQOP+OB48cC2Cq/4iiBJBt4ML/iKIYQAUglAAM91gACYhQhxhODMISKCEfTP +cKAALCAQgADaQqUDpc9wgADwhQKA1bjHcAAAiBMJpQ2FgODKISIBAN5+CmAAyXCE4AP0zaUV8AKF +gOAK8oogiQl+DC/4iiGECQXYCfCKIEkHbgwv+IohxAoC2M4Lj/+dAo/44HjxwCYKj/iA4MohwQ/K +IsEHyiBhAcojgQ8AAFMByiQhAJgHIffKJQEBz3eAAGgcRYdDgkCCz3OgALAf24PPc4AAeIVTJk0V +Nr4eZl1lZYNhuAUrPgAndQIlgBCMIBeHSvfPcIAA8IUBgAUo/gAndR5mgOEI8s9wgADIHBOAgeAn +9PoPQAWA4BLyz3CAAPCeNJDPcIAA/KECkBBxCPICJYEfAAAADOlwBfDpcFglQRaSDM/+z3CAAIAc +ACWBHwAAiBN+DM/+iiDJDhnwz3CAAFAcbgzv/lglQRbPcIAAmBwAJYEfAACIE1oMz/7Jccm5z3CA +APCFI6CKIIkPYgsv+Mlxz3GAAHiFBoGBuIUBr/gGofHAz3CAADgcwgvv/uHFz3CAANCFNYjPcIAA +aByA4c91gADwhQv0IIBCIQGAyiFiAIDhBfIghYDhSfSSC8/+z3CAAIAchgvP/kKFz3CgALAfG4A2 +uja4EHLF9whxgCEQAALwCHFghXpiYYV5YTByzfcKIcAP63IF2K7bSiQAAC0GL/e4c3piMHL+9yJ6 +T3pwcsohzQ/KIs0HyiONDwAAtQDKIG0BK/fPcYAAUBwggUIhAYDKIWIAgOEG8lhgI4XJuDBwBfJI +cADZiv/FAI/44HjxwOHFiiBJBnIKL/jM2c9wgACIChiIhODKIcEPyiLBB8ogYQHKI4EPAADPAMok +IQCoBSH3yiXBANIJb/cC2M91gACYhQKFgOAL8s9wgADUGwGACaXPcKAALCAQgAGlz3CAAHiFBoBR +IACAI/LPcIAAzAUAgIbgzCBigcwgIoIE9EX/FfAEhYDgANkR8s9woAAsIBCAIqUDpc9wgADwhQKA +1bjHcAAAiBMJpQDYBKWh/w0Aj/jxwOHFCHHPcIAAiAoYiITgyiHBD8oiwQfKIGEByiOBDwAAOQHK +JCEA/AQh98olwQDPcIAAmIUKgIDgO/LPcIAAIBxAgEIiAoDKImIAgOIx9IDhyiHBD8oiwQfKIGEB +yiOBDwAAPwHKJCEAvAQh98olAQFFgEOCYbmggs9yoACwH1uC1bpdZc9ygAB4hUWCBSp+ACd1Fgrv +/lclwRjPcIAAOBwAJYEfAACIEwIKz/5dB0/44HjxwIogSQ4OCS/4iiEGBM9woACwHzuAiiBJDvoI +L/g2uc9wgACIChiIhODKIcEPyiLBB8ogYQHKI4EPAACTAcokIQAwBCH3yiXBAM9xgADUGwmBhOBD +9wHgCaHPcYAAeIUGgUYgQAEGoc9wgADMBQCAguAL9IogyQeaCC/4iiGGCPoPb/8G2NHA4H7gePHA +iiBJBoIIL/iKIcYLz3CgALAfO4CKIEkPbggv+Da5z3GAAHiFBoGCuAah1g8v9wLY5fHxwIogSQZO +CC/4iiFIAM9woACwHzuAiiDJDzoIL/g2uc9wgACIChiIhODKIcEPyiLBB8ogYQHKI4EPAAAEAsok +IQBwAyH3yiXBAIogyQcGCC/4iiHIA2YPb/8G2AHZz3CAAJiFLaDPcYAAeIUGgUYgQAEGoanx4Hjx +wM9wgACIChgQhABMJACByiHBD8oiwQfKIGEByiOBDwAAwgEUAyH3yiUhAIogSQaqD+/3iiEHAc9w +oACwHzuAiiAJD5YP7/c2uc9xgACYhQyBgOAJ8gWBgODMIGKABfIA2Mr/GfDPcYAAeIUGgUYgQAEG +oc9wgADMBQCAguAL9IogyQdWD+/3iiFHBbYOb/8G2OILQAVd8fHAEg1v+IogSQY6D+/3iiFICM9w +oACwHzuAiiAKACYP7/c2uc9wgACIChiIAN2E4MohwQ/KIsEHyiBhAcojgQ8AACYCyiRBA1gCIffK +JcEAz3aAAHiFpqaKIEkI5g7v94ohCAtGDm//B9gGhoK4Pgjv/wamz3CAAJiFraBCDi/3Atj9BE/4 +4HjxwIogSQa2Du/3iiHHCc9woACwHzuAiiBJD6IO7/c2uc9xgAB4hQaBgrgGoQoOL/cC2M9xgACY +hQyBgOAM8g2BgOAK8gWBgODMIGKALA/i/8ogIgDbBc//8cAyDE/4z3CAAPCeCYDPcYAAmIUluFMg +AIAKoQDYBaENoVnyz3CAAIgKGIiE4FPyiiBJBi4O7/eKIckCz3CgALAfO4CKIAkGGg7v9za5z3WA +AFAcAIVCIACAyiBiAIHgGPSCDq/+qXDPdoAAaBwAhkIgAIDKIGIAgOAM9IogSgDiDe/3iiGJBclw +vg6v/iKFz3WAAJgcAIVCIACAyiBiAIHgGfQ+Dq/+qXDPdoAAgBwAhkIgAIDKIGIAgOAL9IogSgCi +De/3iiHJCMlweg6v/iKFzQNP+OB48cDhxc9wAAD//891gADwhQOlz3CAACAc8g2P/s9wgAA4HOoN +j/4A2SClBdgBpSKl6gwv9wLYmQNP+OB4z3GAAMgcz3CAABRKOQMv+BTa4HjxwOHFz3WAALAcsg2v +/qlwz3CAAMgcIIDhuR7yFBAEABgQBQBRIQCAzCQigMwlIoAI9AohwA/rcgXYYQAv97TbXgtv/gAl +AAFmDQ//CHHSDa/+qXApA0/48cDhxc91gADIHKlwIgov+AfZCBUEEADYRiT+g8ohwg/KIsIHyiBi +Acojgg8AAGcAEAAi98olIgBAheG6E/LgugfyJYWA4QXyJoWA4Qv0CiHAD+tyBdhv20okAADlB+/2 +uHPPcQEARMkypVEiAIETpSOFDvIOpQGFj+AvpQvyz3ABACDLEqUB2BOlBfAupf/YD6XG/14JD/iN +Ak/4z3GAAMgcAIEigX/bz3KAAJiFUyAAgCZ7BPQugoDhFfSA4AbyDoILIMCAD/QwgoDhBPQFgoLg +B/KA4QfyEYKC4AP0AdgC8ADY4H7geOHF4cbPcIAAyBxAgAKAP9sGewxwz3aAAMgcoobPcYAAmIUL +IECDAdgugcIgAQALIUCDwLoG8imGUSEAgc8gYQALIMDACfTPcYAAmIUugQshwIAA2QLyBNmA4gb0 +hOEI8oDgBvSA4gXyhOED9ATYwcbgf8HF8cBSCW/4ANnPc4AAmIUEg4DgCPTPcIAAyBwHgIDgA/IB +2c91gADIHMCFz3CAAIgKGIhTJgIQhOAA3wnyz3CAAPCeCYBRIECBA/QA3jfwB4WA4AP08aWA4swh +IoAL8gmFUSAAgQfyUSYAkQryAYWP4AT0ANgIdhXwANgS8BGFAeCE4BGlCN5G9wGFj+AA2Anyz3ag +ACwg0IYB2MOjCN6whYDlDPSA4gT0gOEI9IDgBvRME4AAguAD9ATeAQFv+Mlw8cCOCE/4ocEacCh3 +SHad/4DgS/LPdYAAmIUAhYDgRfTPcIAAzAUAgILgC/SKIAkIlgrv94ohSAL2CW//CNjPcYAAyBwA +gVEgAIFLgQT0AYGP4Aryg+Ip8gDYB6EMoQPaS6EJ8IPiIfIA2AmhB6ED2kihBKWKIIoITgrv9yqB +z3CgACwgsIBAxgHYHtkKcghzSiQAAAolAAEAJYcfBwAgoWB/CiYAAU0Ab/ihwPHAhODhxQh1DvSy +C+//BN2KIIkGBgrv94ohBglmCW//ANhd8IThOPTPcIAA8J4YEIQATCQAgcohwQ/KIsEHyiBhAcoj +gQ8AAKwBMAXh9solIQAkEAQAUSRAgcohwQ/KIsEHyiBhAcojgQ8AAK4BDAXh9solIQCKIEkIognv +94ohBgwCCW//B9j6Cq//BN0uC8//JfBTJX6QE/LPcIAAzAUAgILgzCAigRn0iiAJCG4J7/eKIYcA +zghv/wjYD/CI4Qz0z3GAAMgcz3IBAOgnAd2pcDKBoP8D8ADdhQcv+Klw8cAKDw/4z3WAAMgcCIWD +4DPyC4WD4DHyCYXPcaAALCBRIACBC/IMhYHgCfQwgQ4J7/eKIEoIAdgg8NCBCoUCJgEQBdgMuBBx +1/eKIMoH7gjv98lxENgJpQ2FAiYBENdxAAAAUMn3iiDKB9II7/fJcQHYDKUC8ADY/QYP+PHAig4P ++M9woAAsIPCAz3aAAMgcCoalhgInARCxcQb3BoYdZSJ9CfDPcgEA6CcB2DKGcv/qpgCGz3aAALAc +USBAgAzy3g4v/qlw6ggP/whxUgmv/slwBfDmCK/+yXCVBg/44HjPcYAAyBwAgVEgAIHPcIAAjH9I +gFMiAwAE9AGBj+AS8oDjDfJRIsCBCfTPcKAALCAQgA2hAdjgfwuhAtjgfwuhgOMM8lEiwIEI9M9w +oAAsIBCACqEB2APwAtgIoeB+4HjxwMoNL/gJ2c92gADUGzoN7/fJcACWz3WAAJiFUSAAgAjyAdhM +HQIQTg/v9hbYCfBMFYAQgeAF9ALYTB0CEACWIoYiuMC4TR0CEM9wgAAYHSCgz3GgACwgUIFyhQIi +wAD/uAP0UqUQgQOlz3CAALAcAIBCIACAyiBiAIDgCPTPcIAAyBwAgIDgJArC/wiGgOAF9M9wgAB4 +hQiQFaUAliW4wLhCD+/+A9liDM/3iQUP+PHAGg0P+Ch1z3GgACwgMIHPc4AAsGVGi4DiAN4E8keL +gOID9AbYh+DKIcoPyiLKB8ogagHKI4oPAACBAsokKgBoAur2yiXKAIblz3OAAJiFAvI0o06DDyJC +A06jz3KAABgd8CIAAFKDOGACII0A/70C9BKjz3WAAMgcAoVBhQR6GcgRIgCADPIqpcIOr/eKIMoI +AYWP4MmlAvTHpekED/jxwHYMD/gIdc9wgADUG0GAz3CAAJiFz3aAAMh1SaBehgQlhB8AAAAg5rom +ulMiAwBBLUITwLoWIM8AQqcn8s9ygADIHGmCJXtposO5ANsPI0MAL4ILIcCAAd8F8uyiHBoAAea9 +JPQugmR5cIIFIcGAMKIe8gDaz3GAANQbSaHPcaAALCAwgSOgEvDPcaAALCAwgSGgRCUBE4jhCvQC +gIDgBPKmCgAFBPCiCgAFz3CAAIgKGIiB4Ab0z3GAAKhdFfAKCgAFgOAx8s9wgADkoQyIh+Ar9JQW +gBDPcYAAqF0FuABh7bgh8pQWgBDsvUAhDwMFuDhgD/IggIi5IKCuDa/3iiAJBpQWgBAB2QW4H2cg +rwPwANksqM9xgACsBIogCQaKDa/3IIG5Aw/44HjxwOHFz3CAAMwFABAEAM9wgACYhUwkwIHMJCKA +CvIUEAUACiHAD+tyBdi1AO/28NsA3aWgiiCJBkYNr/f12aoML/+pcH0DD/jxwAILD/jPcIAAjH8I +gM93gACYhVEgwIEA3RX0iiBJBxYNr/fc2QLedgwv/8lwxafPcYAAyBywobGhENgJoaehCvClp4og +iQbuDK/35dlSDC//qXAVAw/48cCuCg/4z3WAAJiFIIUleAClEIWA4KHBBfQB2BClBYURpW4PL/uL +cADBz3ABAAwrMHAM8s9wAQDEKhBxBvLPcAEA6CcQcQT0eg8P+wDeMg6v/8Klz3CAACAcBg1P/s9w +gAA4HPoMT/7PcIAAsBzyDE/+iiCJBmoMr/d62coLL//JcJkCL/ihwPHA4cUIdYogCQZODK/3qXHP +cYAAmIUAgaZ4AKEA2BChBYH+Dq//EaFxAg/48cDyCS/4AdvPcIAAyBwAgM9ygADwhcG4g+DBgsB7 +geYF9M9wgADUG8eAz3CAAFAcAIBCIACAyiBiAIDgN/TPcYAAmIUMgYDgzCMhgC/0AoLPc6AAsB/7 +gza4Nr/xcNYnjR8AAIAAQIK1gQAiEAD9ZRJ1T/cKIcAP63IF2IojBAcKJAAEBQev9rh1ACCQIxJ1 +fff+ZoogSQaSC6/3iiGECQIggCMuD2//AdmtAQ/44HjxwD4JD/gIdoog/w8Aps9wgACYhQqAgODK +JSERavLPcIAAiAoYiITgFfQCDQAAz3GAANAFAKZAgSGBViJCCxThWWEwcAHYwiAOABN4UyBNAFDw +wP/PcIAAIBwAgM93gADUG0IgEYBqDCAAyiFiIACmz3GgALAfu4Eph0AnEBPPcoAAeIXwIEEgRYJh +uQUqfgDVvSd1giWBEUglDRAQdcolBhBP989wgAAgHFILb/5KIUAgz3CAADgcQgtP/qCmz3GAANAF +AIEhgVYgQAsU4ThgEHUB3cIlThOzfVMlTZAK8kwhQKAG9AmHzgiv//AgACCtAC/4qXDgePHATggP ++M9wgACIChiIhODPdoAAmIUV9AqGAdqA4ACGwHoB2YDgz3CAAHiFBoDAeYDgzCIhgMwhIoBd8mPw +z3CgACwgsIAShgDaAiUBkOOGyiJvALF3CYYQAC8A+2ACJc8QgOcA38P2Ad/XcQBAAADI94DiBvIC +JYEfTgABIDKmAiXBENdxAEAAAMn3gOcH8gIlgR9OAAEgI6YihoDhE/IhhjhgEHHH9xB1y/cwdYf3 +B/AwdYP3EHXD9wDZAvAB2SKmAIbPdYAAeIWmhYDgAdjAeIDhAdnAeYYlfx6G5QDbBPKqhoDlA/QB +24DnzCIigAP0ANgI8IDjzCEigMwgIoD58wHYsQfP9/HANg/P9wh1z3agAMAvGoY5uFIgAABTIBAA +FIZRIMCAAN8J9GoJ7/ck2PK4yiLBIwPySiJAIFEWAJaA4Ar0oxYAlgQggA8AAAAPjCAQgAT0ANgD +8AHY6b16cMomIRAI8qUWAJZeCK/907gIdgQhkU8ABAAAz3AAAAgcFgnP9z+4UiACAAQggE8CAAAA +13ACAAAAAdnAeQxwhiA9AIDgSiRAAMIkAgFRIIDBCfLPcIAAzAUAgIHgANsC9AHbz3CAAEwaAoBR +IICACPLPd6AArC/8h/a/ANgD9AHY5b3KIGEgTCAAoBLy5r3KImEgTCIAoAzy6b3KJmEQgOYI8uO9 +yiFhIEwhAKAE9ADYJPDkvcoiYQCA4vrz4r3KI2EgTCMAoPTz4b3KIWEAgOHw8+C9yiRhAEwkAIDq +8+e9yiNhAIDj5PNRJQCSyiBhAIDg3vMB2D0G7/cPeOB44cXhxgh1z3GAALBlIJH/2ILhyiCiD//a +z3GrAKD/WaEYoQTZz3CgAMgcKKAW3hLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhh +vowm/5/u9YDlz3GgAMAvCfLPcMgAPADAGQAAE4GLuAjwz3DIALIMwBkAABOBq7gTocHG4H/BxfHA +CglgAUfYANrPcasAoP9ZoQfYGqFYodHA4H7xwM9xAwBADc9woACoIC2gz3GgAMAvFIHwuBSBC/IE +IIAPCAAAANdwCAAAAAHYwHgG8IYgfw+C4AHYwHiA4B30FREAhqC4FRkYgAzwz3CgAKwvHID5uAv0 +DHSEJMKfB/Ra2Gn/gOD08wfwz3GgAMwrEoGAuBKhxPHxwM9wAAAIHBIPr/ehwf+4C/LPcKAALCAQ +gATZQMCLcPoJr/d82qHA0cDgfs9yoAAsIFCCInrPcYAA0AUVeQCBEHLK989wgADwngmAUSBAgQLy +QKHgfuB48cChwQDYz3KAAJiFTRKBAEDAgeGLcA/0z3GgACwgMIFUgkJ513FOAAAgxfcKCs/+A/AO +Cc/+guAG9Iog/w+hwNHA4H7PcIAA4BoDgCCAAMAieIDgyiAsAPPx4HjhxYoh/w/PcKAAsB8bgM91 +gADgGmOFYIOmhdW4gOUA2gbyIoVieYDhyiGMAAkhAACCIIEBSCAAAOB/wcXxwNYLz/cacM9wgACY +hQeASiJAIMC4geDPcIAATBotiMIigiSB4Q30z3GAAFwaIIGA4QfyCBAEAFEkwIAE8kohACAc8FEk +QIDKIcIPyiLCB8ogYgHKI4IPAAC2ABgBovbKJcIATCJAoAHYwiABABW4ACCRD0AAAACKIEkGRN2a +DW/3qXGKIMkJjg1v9wpxDgzgBADez3CgALQP3KANyM93oADIHwQggA/+//8DDRoYMA3Ih7gNGhgw +z3CgAOwny6BJH1iTHN0S8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Yb2MJf+f7vXP +daAAwC8Thfq4C/SKIEkGFg1v91vZAdiSCCACSnHqDO//SnDPcZ8AuP9dgc9wgADYBd2hdg3v/0Cg +z3CAANgFwaDPcIAAmIUHgIjgEvJiC+//iiDPC4DgDPQB2c9wgADYBSGgiiAJCr4Mb/cBEgE2TCJA +oCj0iiBJBq4Mb/eA2RCFUSAAgAz0QBUEEAohwA/rcgXYg9vxB2/2uHPPcIAAsGUgkIXhCfQBkIDg +BfSKIBAAEaUI8IogEAERpRCFUSAAgP71FIWruBSlTyFAJpy4GaUYFwCWobgYHxiQiiAQABGnCdgI +uA+nDh+Ykw8fmJMQH5iTER+Yky0fmJMTham4E6XPcIAAmIUHgIPgGfTPcIAA0AUAgFYgQAsCIAGg +GgAPAAohwA/rcgXYs9tKJAAAVQdv9rhzEmmfuIgdABCeCg/+gB2AE89wgADYBfUB7/fCoOB48cCO +Cc/3z3WgAMAvgBUPEFwVEBBoFREQiBUSEM9wgACYhQeASiNAIMC4geDPdoAA2AUChsIjwiTguLP0 +gLgCpoogCQ2OC2/33dmKIAkNhgtv90EvgRCKIAkNegtv9wpxiiAJDW4Lb/cqcYogCQ1mC2/3SnHP +cYAAsGUAkYXgBfQBkYDgD/IQhVEgAIAL8kAVBBAKIcAP63IF2OzblQZv9rhzTCMAoC3yiiAJDSYL +b/fy2TCFHgtv94ogCQ0QhVEggIIF2Qz0QBUEEEwVBRAKIcAP63IF2F0Gb/b124ogEAASpc93oADI +HyDYEKdDH1gQANiiD2/3jbgg2BGnEPAQhVEggIIM8kAVBBBMFQUQCiHAD+tyBdgdBm/2/9tMIwCg +E4UP8vq4GPIKIcAP63IF2HDbSiQAAP0Fb/YKJQAB+rjKIcEPyiLBB8ojgQ8AAHQABdjx8wfYz3eg +AMgfGR8YkAHYCHEIctoMb/YIcyCGz3CfALj/PaCAFQ4QIr4aCS/+yXDPcYAANGcNgdhgDaEA2IAd +ABCIHQAQCdgIuA6nSQDP9+B48cD6D4/3z3CAAJiF54DAv4HnAd/PcYAA2AUCgcB/4bgy9IG4gOfP +dqAAwC8CoQX0E4a6uBOmAtgRps91oADIHwbwRRUAFuTgQAAFABCGUSAAgPnzQgrP/wHYdgzgAelx +FRYAloC4FR4YkIog0AfCCW/3iiFFBZYPQAEmDE/6CdgIuA6l3QeP91wWBBBAFgUQCiHAD+tyBdj1 +BG/2iiOFAfHA7gzAAE4KwACuDQAA0cDgfuB4OdnPcKUACAw+oOB+8cDhxQDdogggAKlw6gvgAKlw +Ig8AADoKwADPcIAAjAWRB6/3oKDgePHAz3GAAOQFAIHXcACAAAAE9EYNwADZ8QCB13AAQAAADPTP +caAAsB87gR4Jb/eKIEwM8gzAAMnxx/HgePHA2g6P94Dhz3WAAOQFD/IApQGFgOAU9G4Ir/YL2BIM +r/8I2AHYAaUK8ADewKVuCK/2C9iCDK//CNjBpQkHj/eA4PHADNgJ8j4Ij/biC6//gNjRwOB+RgiP +9l4Mr/+A2L4Ij/6C4Ab00gpv/gDY8/Hx8eB48cBKDq/3iiDMDqLBighv94ohRQKLcM4Nb/cC2QMU +jzCC58ohyg/KIsoHyiBqAcojig8AAFoByiQqALwDavbKJcoAAhSAMM92gADsBYQvCBgAFBAxJB4C +EM9wgAAUiAAgQQ4oiQolQC6A4UAgEgIAIFQOHPKKIEwNHghv94ohxQmKIEwNEghv9+lxVgmv90Ig +gCEB2BO2/9glHgIQQCYAGeIIr/cE2WjwSiMAICYexBQlHsITz3WAAACGQCUREqJ1i3CpccoNb/cC +2kAlABK6Dm/3QiCBIQAlgS+AAACGAoHPcYAAeIUlgdW4MHDKIcYPyiLGB8ogZgHKI4YPAAB4Acok +xgTwAmb2yiXGBC4OYAXpcEokgHBqcaggwAOEKQgIL3AyIgIggOIG8jAhAiAChRByJfIB4UAmABlK +CK/3BNkB2QgcQiCGFQAWgLiGHRgQKHCf/4ogTA0+Dy/3iiEGBIogTA0yDy/3IoWKIEwNKg8v9+lx +JQWv96LACiHAD+tyBdiKIwYBSiQAAG0Cb/YKJQAB4HjxwM9xgADsBQOhdg5v9g3YFgqv/4ogBAAZ +8eB48cCuDI/3ABYOQKHBgubKIcYPyiLGB8ogZgHKI4YPAABrBcokxgAgAmb2yiUmAEDGi3fpcJ4P +b/cE2YogzAqqDi/3yXGELggYCiBALgAhjX+AAPyHEg/v/QRtz3CAAOCJGIAQdg7yIBWAEIDgIvLp +cATZiglv95naANggHQIQGvAAIIEvgADwhwqBgbgKoc9wgADsBTOAgOEB2gXyRKAE2AfwANkvoCqg +S6AkoAXYzv9hBK/3ocDgeNEFb/YN2OB48cDhxc91gADsBRSFgOAh9CoOT/6C4EAIYf7KICEAAdgU +pZYNb/YN2KINb/YM2IDgFaUI8oINb/YM2JoJr/+A2M9xAQBwTQHYWghgA4DaHQSP9+B48cCaC4/3 +z3WAAOwFMBUQEIwgw68I8oogDA26DS/3iiHGDSDwgODKIcEPyiLBB8ogYQHKI4EPAAC8AcokIQD0 +AGH2yiUBBAhxgiEIAM9wgAAAhg4gQADODK/9iiEICBpwz3CAAPyNERAChowiw4//2QXyGhgYhCyl +B/ARGBiEANgEpSylyv95A4/34HjxwOHFCHWEKAgIACGBf4AAAIaGEQAGz3KAAOwFoLiGGRgAAoIE +iIDgE/IDgYDgyiHBD8oiwQfKIGEByiOBDwAAMQfKJCEAYABh9solwQACgYDgFvTPc4AA/I0REwCG +jCDDjwryz3CgALAfG4ACoRobWIMR8KyiANi//w3wBg1P/oQtCBgIcQAhgH+AAACIng3P/fkCj/fg +ePHAfgqv9wLYAN0Ids9wgAAYiIQtCBgwIEAOUSAAgEwP4v/KIEIDCW6A4AHlL/cA2O3+uQKP9+B4 +8cDhxc91gADsBSOFz3CAAJQh8CBAAEB4gOD5850Cj/fPcKAABEQHgIDgAdjgf8B4z3OgAKggMYPP +coAANB0DgjhgA6IB2BKj4H7geM9yoAAsIGaCz3GAAOwFEoFieBKhEIIRoebx4Hjhxc9yoADIH6QS +AwDPcYAA7AURgRBzwiMGAET3YngTe7+CEoG7Y3hgEqEB2EoaGADgf8HF8cCmCa/3ANvPcIAA7AVj +oP/az3CAAPyNERiYgEokgHBodaggAAeELQgYACGBf4AA/IfPd4AA4BphoQbexaHPdgEAcDrEoeah +IBnCAAAhgX+AABiIYKEB5c9wgAD8jRoYmIDPcYAAsCEAgRzaQKAY2PIJ7/8CoZkBj/fgeAHaz3GA +ADQdQ6kYoShwZNlhBi/3ddrgePHADgmP989ygABciqKCjCXDnzTy/9kiooQtCBigoAAhj3+AAACG +BI+A4AogQC4S9AKHz3GAAHgGRgmv/SCBCHHPdqAAyB8Vhm4OT/6A4AT0AdgV8M9xgAA0HQKPoKkB +qQHYE6YchgGhAdjg/wDYACCBL4AAHIgAqQDY+QCP9+B48cCWCK/3AdqhwYHgz3GAALQGQKEn9M91 +gADgiRiFjCDDjwryANqEKAgIACGBf4AAHIhAqc92gADsBQ+GgOAG8g6Gyv8A2A+m/9gYpYtwzf+A +4AnyzgnAAADADKYA2Cb/EfD2CW/2Ddi6CcAABg5v/4ogBABmCk/+guB8DCH+yiAhAIEAr/ehwPHA +Bgiv9//az3CAAPyNERiYgBoYmIAA3s9xgADsBcOhTKEB2s9wgAC0BkCgz6HUodWh06HAocGhAt3J +cIQoCAgacAAhgX+AAPCHCoEAIY9/gAD8h0YgwAAKoWYK7/0Eb2G9gOUgH4ITQCBAICj3AdjC//kH +T/fgeADYz3GAADQdA6nPcIAA7AVIgAKAQqkc4FZ4RIhJqQWI4H8KqfHAbg9v94ogDAnPdYAA7AUk +hZIJD/cEhYDgRfTPdoAA/I0RFgKWAN+EKggIACGAf4AAAIYCpSSIAduA4e6lb6Uh8hse2JMMEAUA +z3GAAHiFBCWED8D/AAAUEQYAQSwEBgUuPgEAIYR/PwD//wQkQQEcHliQIJCMIYKGAdnCIU4ALaXo +pSSAz3aAADiKwLkmts92gAA0HSiuQK4CiGSlAa4e8ASFgeAc9M3/ANgEpQKFJIiA4RL0KIUc4DZ4 +JIjPcIAAXFsWiBBxAdnAec9wgAC0BiCgAtgD8AHYA6X5Bm/3AdjgePHAz3KAAOwFAoIliIDhAdgF +8gjZLqJ5/wfwz3GAALQGtg+gAACh4weP/+B48cBeDm/3iiBMCc92gADsBSSGgggP9wSGgOCb9AKG +SIYkgFZ4z3KAAFxbBCGBDwAGAACA4QHZdoogEI0AwHlwdQj0z3eAADiK5pe0ivF1BPIA3Qbwsoqx +cfz1Ad2A5c9xgAC0BqChFvTPcYAAvAYgkTBzEPTPcYAAvgYgkXSKMHMI9M9xgADABiCJUoowcgTy +ANkD8AHZgOFV8ieAz3CAAFyKIaDPcIAA8IVBgM9wgAB4hQWABSi+AEApgHIQccohxg/KIsYHyiBm +Acojhg8AAOoCyiQmABwDJvbKJQYBz3CAAIAGAICuDW/9OGCA4AT0uf9D8A3IBCCAD////wMNGhgw +ZBaAEADdgOClpgn0z3CgACwgEIDHcAcAIKEYpniGAd8KJYAPAQDsTOlwBtkE2qoJYARKJAAAZB5C +E+Sm6XAc8ADYAtkjpmQeAhAW8ASGgeAB3RH0BYaA4Bn0z3CAAFyKIYDPcIAAgAYAgCYNb/04YIDg +BPIB2E0FT/f6Ca/6ZB5CEwDYBKa08QXYDqapcA//ANhkHgIQ7/HgePHAxgxP9891gADsBQSFgOAM +9CSF4g7v9oogjAgChQSIgOAV9ALYBKUEhYHgPvQFhYDgMPTPcKAAsB8bgCoKb/46hYDgIvQA2CXw +ANgFpc92oADIHxWGz3GAAIAG0gxv/SCBGqWkFgMQCiWADwEASE0A2AbZBNrHcwcAIKHCCGAEmHAB +2ASlL/BSCY/6BNgD8AXYgOAB2gT0Adgl8CuFgeEP8k+lDqUN8ASFguAa9CSFRg7v9oogjAgLhYHg +A/QB2A7wgODq9QKFog4v/gOACHHPcIAAyCEGD4/9ANjV/t7xANhRBE/34HjPcoAA7AUigiWJgOES +8s9xgADgiXiBz3GAABiIhCsICDAhQQ5RIUCABPQI2A6iAdgLogDYCqIEogXYA6LgfuB48cCeC2/3 +iiCMCc91gADsBSSFvg3P9gSFgOA/9CKFSIVAIQAHVnhEiM9wgAC8BgCQEHIB3g70z3CAAL4GQJDP +cIAAOIoGkBByBPTEpQDYQPAEiYDgHvLPcIAAtAYAgIDgGPTPcIAAXIohgM9wgACABgCAXgtv/Thg +gOAM9IogTA1ODe/2iiHNAQDYzv8B2CDwxKUB2BzwBIWB4ADeGvQihc9zgACICkSBBYEc4UijCaNo +hc9wgAA4igaQdnkkiWoK7/bJc8SlA9gDpQHYPQNP9wohwA/rcgXYiiNNCph2UQAv9rhzz3CAALAh +IIAc2s9zgADsBUChQoNVIsEJIaCgEgEAjbmgGkAAViPBAqQaQACcEgEBaIMkoFUiQQ0joEAiAQd2 +eSWJoOEL9M9xgAC8BiCRSHSAJEQTIKwe2wLwGNtioFUiQQ15YVEGb/oloOB4z3GAADQdQCEAA1Uh +wgVQcEb3ANkEGFAAUHC99+B+4HjxwCYKT/fPcIAA4IlYgEogACCC4sohxg/KIsYHyiBmAcojhg8A +ANAHyiQGBJAH5vXKJcYAz3CAAOwFaICEKggIACGAf4AAAIaA4XZ4p4BH9M9wgACYHe4N7/aKIQ8P +z3CAAFAd3g3v9iDZz3ClAAgMAIBTIECAEvKB4BLyguAT8gohwA/rcgXYiiOfCwokAAQtB+/1CiUA +BP/ZB/D/2Qi5A/D/2RC5z3KgALRHHhpYgB0aGIAbGliDANmRuc9woADQGzGgz3CAAAwEEHhJGhiA +byBDAFQaGIAz8M9zoAC0RxsTAIaA4A7yGxMFhgohwA/rcgXYiiNfD8UG7/UKJAAESxsYhAHYdxsY +gADYnrhUGxiAiiTDf89zgABsSgpwqCBABApjz3WAADQdz3GAAJgdVX1HhfAhAQAB4FlhJ6VNAU/3 +4HjxwOYIb/eKIAwKosHPdYAA7AUkhQYL7/YA3gSFgOAn9BIKgAAB2ASlAoUEiIDgSAIBAM9wgAC0 +BgCAgOA4AgIAz3CgACwgA4DPcoAAXIohghlhz3CAAHwGAIA4YG4NL/4AooDgEAIBAHTwBIWC4Dv0 +DYWA4MohwQ/KIsEHyiBhAcojgQ8AAJMDyiSBA+wF4fXKJcEAQoUohUAiAAc2eCaIYMEmiAEcQjAm +iAIcQjAniGHBJ4gFHEIwB4iLcQYcAjCSDC/3qBIAAM9woAAsICOAz3CAADQdIaDFpVb/A9gEpcrw +BIWD4Dn0QoUohUAiAAc2eAWIUSBAgRHyA5LPcaAALCAjgc9zgAA0HWGDCrhieTBwBfcJ2A6liPAF +hYDgDfQEioDgqPLPcIAAXIqeDC/+AICA4KDyBYWA4AbyBdgOpQHYCfDPcIAAtAYAgIDglPQA2O/+ +kPAEhYHga/RQ/yKFSIVAIQAHVnhFiOC6F/KDukWoz3KAAMBlx4LPc4AA4Inao/eCw4L+Ztuj9oLC +gv5m3KPBglWCXmbdowWIUSBAgCvykgvP/YDgyiHBD8oiwQfKIGEByiOBDwAA5QPKJCEAuATh9col +AQGCC+/9Ati2C+/9CNgihQSJguAK9AHYAKUA2BKlngvv/VrYIoUEiYHgA/QB2AGlCIUc4RZ5BYmG +IP+MyiCCDwAAMEO0DOL/yiEiAAKFKIUc4DZ4BYiGIP6HBPIC2ASlKPAE2ASlJPAkhYThAdgg9BOl +z3egAMgfPIfPcIAANB0hoNII7/aKIAwKz3CAADQdDNnWC+/2ddoVh89xgACEBu4OL/0ggQelxKUE +2AOlAdjZBi/3osDxwGYOD/fPdYAA7AUEhYDgavQChQSIgOAT8s9wgAC0BgCAgOAN9M9wgABciiIL +L/4AgIDgBfIA2Jb+LwMAAM92oADIHzyGz3CAADQdAYBIhQJ5AoVWeAeAEHGG9wHYBKUHAwAAAIWA +4AryUSNAwAjyAtgVHhiQkgrv/R7YFYbPdYAA7AWKCy/+J4WA4NoCAQAVhs9xgACEBj4OL/0ggQel +AoUohRzgNngFiIYg/4wJ8s9wAAAwQ89xgABQHeH+AoUohRzgNngFiFEgQICaAgEAAIWA4AXyH4aA +4I4CAgDf/IcCAAAEhYHgjfQkhbIPr/aKIEwKz3GgACwgI4GiD6/2iiBMCgKFKIUc4DZ4BRCGAADe +USYAgNOlPfLPcoAANB3PcIAAwGV2gCKAeWHPc4AA4In8g9iqVBAEAAQQBQAAJQUBdBMEAOJ5AiUF +AfqDHBAEAAIkxIN7gwOAYnjKJ4ETA/IB3/iqgOEO8kAsgwBwcYT3TyeAEAbwgOAG8k8nQBAPfxiq +QSnAADhgsHBD94K/+KpRJkCAKfIAhYDgDfLPcaAALCAmgRKFInjPcYAANB0FocClBfABhYDgA/LB +paf88g7P/YLgDvIKIcAP63IF2IojEwVKJAAAJQLv9QolAAHuCO/9ANgChSiFHOA2eAWIhiD/jATy +AtgEpbfwBNgEpbPwBIWC4Av0z3AAADBDz3GAAFAdi/4E2ASlBIWE4Kj0JIV+Dq/2iiBMCs9woAAs +ICOAz3CAADQdQCAQBzegYg6v9oogjA0ihSAVBBBAIQAHFiAAAQWIUSAAgADeHfJKJMBwyXLJc6gg +wAHwIMAgAeMaYgPfSiRAcQDbqCDAAfAgwCMB5xtjUHPH989ygAA0HRiKgrgYqs9wgABcisOgTJFA +JEAAUHAIpUb3hhEABlEgQIAG8gHYD6X2/VfwDoWh/A3IBCCAD////wMNGhgwzqUC/YogTA3KDa/2 +iiFUBgiFIoUWeYogTA22Da/2J4EC2AOlAoXPcoAAtAYkiIDhD/QohRzgNngkiM9wgABcWxaIEHEB +2MB4AKIm8CCCgOEF8gHYA6Ug8CiFNngngM9wgABciiGgz3CAAPCFQYDPcIAAeIUFgAUovgBAKYBy +EHHKIcYPyiLGB8ojhg8AAC8FeAbm/wXYxKVlAy/3AdgKIcAP63IF2IojlA5KJIAAgQDv9bhz4Hjx +wOYKD/fPdYAA7AUEhYDgocFB9CSFBg2v9oogjAoB3s9wgAC0BsCgANgTpSqFAaWA4QClAtoe9M9w +gABcW893gAC8BuCXdojxcxL0z3eAAL4G4Jd0iPFzCvRyiM9wgADABgCIEHME9ESlBPDKpclxgeEQ +9JoP7/UC2M9ygABcWxSKNopAgu4Jr/YB28SlmPBEpQSFgeAJ9CSFggyv9oogjAoC2ASlBIWC4DP0 +JIVuDK/2iiCMCs9xgAC8BoogjAxaDK/2IJHPcYAAvgaKIMwMSgyv9iCRAoUEiIDgF/ILhYDgFfTP +coAAXIokggOCDiGDDwcAIKEQc0f3B9gOpQHYD6ULpQPwOGADogPYV/AEhYPgEPQkhQYMr/aKIIwK +DcgEIIAP////Aw0aGDAE2EfwBIWE4Bz0JIXiC6/2iiCMClMgwEDuCmAAG6XPcIAA4Ik4gM9wgAAY +iIQpCAgwIEAOUSBAgAXYyiChASnwBIWF4Bv0z3aAAOCJGIYE2UDAi3CuDq/2mdoYhoQoCAgAIYB/ +gADwhyqAobkqoAHYC6UG2ASlANgN8ASFhuAK9AbYA6UbhYDgyiBiABt4BKUB2JEBL/ehwM9wgACM +fyiAz3KAAOwFL3iB4Av0ANvPcKAAtA98oALYA6JkogPwAdgFoi0Dr/aKIMwI4HjPcIAAXIotgM9y +gADsBS94geAF9ATYBKID8AHYBaIFA6/2iiDMCOB4z3CAAIx/KIDPcoAA7AUveIHgBfQC2ASiA/AB +2AWi3QKv9oogzAjgePHAoggv94ogTA3KCq/2iiHXDA3IAN4EIIAP////Aw0aGDCyC2//yXDPdYAA +7AUVhYDg2Ali/8ogYgDVAC/31KUB2c9wgADsBSSgZQRP/+B48cDhxYDhz3WAAFwGEvImhYDhDfQA +peoJ7/UK2IoN7/6KIAgAAdgGpQ7wIIUleAvw4gnv9QrY+g3v/oogCAAA2AalAKWBAA/38cACCA/3 +CHYA3+lw6XHr/wPY6XWA5hpwCPITbRR4x3CAAOAhlgpP/YDmCfITbRR4x3CAACgihgpP/UIgQCCA +4AHlKvfPcIAAlIrpdJ2wMLyesM9wgABcBj4JYADgoAkAD/fgePHAkg/P9s9xgAC4BgCBoLgAoQHY +4v/PcIAAlIoAgIPgy/cKIcAP63IF2N3bmHMJBa/1SiUAAIDg4AAuAADez3eAAFwGz3CAAGxL1Xgg +gLNuA4AipwOnFG4AIIEPgACUikeRBpEQukV4RZEacASRELpFeEORWnACkRC6RXg6cJIP7/wKcSKH +enC0fQAlgB+AAOwhIKB+Ce/9KnAIcQAlgB+AAOAhFgpP/QwggKSE90wiAKAm9COHs260fQAlgB+A +ADQiIKBOCe/9anAIcQAlgB+AACgi5glP/YogTA36CK/2/dmKIEwN8giv9mpxg+aO9wohwA/rcgXY +/9ua8YogTA3WCK/2iiHEAM9wgACUigCAAeYQdjAHxf/RBs/28cDPcIAAlIr+Da/2Ddm+DY/2tf/R +wOB+8cBqDs/2CHaKIEwLlgiv9slxg+bKIcYPyiLGB8ogZgHKI4YPAACQAcokxgDUA6b1yiUmABRu +z3eAAJSK+GBFkCSQELpFeYDhGnBD8s9wgABsS9V4IIDPcoAAXAYDgCSis24ForR9ACWAH4AAfCIG +EAIhIKAEEAAhELpmCO/9RXgIcQAlgB+AAHAi/ghP/c9wgABcBiWAACWAH4AAxCIGEAIhDhADISCg +BBAAIQwQASEQuhC7RXgmDu/8ZXkiCM/9CHEAJYAfgAC4Ir4IT/1elx2XANkPIYEDELpFeAYgQIAB +3R23MLgetxX0z3GAALgGAIGguAoPIAAAoc9woACwHxuAsqcM2RGnVicAEqoKr/aW2hDaz3GAAFwG +AIHYekZ4rQXv9gCh4HjxwEoNz/bPdoAAXAYA3QvwENi4eAshAIDADuL/yiBCAwHlg+Ughrb3gOHK +ICEAzAzh/8ohAQCBBc/24HjxwADZz3KAAJSKIKLPcIAAuAYgoD2yMLk+skDx8cDhxQDdz3CAAFwG +oKDPcIAAuAagoM9wgACUiql0nbAwvJ6wqXAx/6lwqXEd/zkFz/bgePHAugzP9gDfz3WAAJSKPpUP +Jw8QHZUQuSV4BiD+gz30z3GAALgGAIGAuAChz3CAALwGz3GAAFxbAJBWiRByG/TPcIAAvgYAkFSJ +EHIT9M9wgADABgCIMokQcQ30DcgEIIAP/v//Aw0aGDANyIe4DRoYMM9woACwHxuAAN4M2dKlEKVW +JQASfgmv9pbaAdjJcdoIoAKA2j6VHZUQuSV45XgdtTC4fQTv9h614Hiq8eB4CHEA2Pzx4HgIcQHY ++PHgeAhxAtj08eB48cDhxc9xgACUin6RXZEQu2V6ESIAgAHdCvQDuBR4x3CAAOAhgg4P/alwA/AA +2D0Ez/bgePHA4cUodfL/gODKIEEDZAvh/8ohYQAhBM/24HgIcgDYENnw8QhyAdgg2ezxCHIC2EDZ +6PHxwM9wAAAgThoM7/zhxc91gAB4BgClz3AAALgLAaXPcAAAiBP+C8/8AqXPcA8AQELyC8/8A6UF +2OoL7/wLuMUD7/YEpfHASgvP9s92gADgiugWgRCMIcOPC/KA4Abyz3CAAAAj2g0P/f/Y6B4CEM9w +gACMBQDdoKDPcYAAuAYAgeQeQBOiuJYMIAAAoalwKgwv/6lxZQPP9vHA9grv9oogzA3PcaAAsB87 +gRYNT/bPcIAA5AUAgAQgvo8AwAAACfTPcIAAwIsIiIwgw48D8gHY3f/PdYAA4IqpcDIKr/Y42TIL +gATDhYogTA7WDG/2yXHeCY/2iiCMDsYMb/Zf2f4Mr/3JcAhxz3CAAAAjlg0P/f7Y6QLv9ugdAhDg +eP/Yz3GAAOCK6BkCAADY4H/kGQAAz3KAAFxbdorPcYAAjAZUimGxAaFAsShwCNmJB2/2c9rxwOHF +z3GAAOCKQYnPdYAAjAWA4s9zgAC4BiCDBvIB2AClgrkgownwANpApaK5gOAgo5gLAgAA2C4LL/8I +cQDY6P9xAs/24HjxwM9wgACICgmAUSBAgcogYgD0CeIDyiEiAM9xgAC8BoogjAwCDG/2IJEB2OP/ +0cDgfuB48cAKIcAP63IF2I/bSiQAAEEHb/UKJQAB8cDhxQh1/9nPcIAAwIsoqG8gQwC+Ci//AdnP +caAAsB87gboLb/aKIMwNBYUDgEKFIICKIIgApgtv9kJ54QHP9vHAz3CAAJQGBICA4Bv0Mguv9RLY +gOAX9M9wgACwZQeIgOAR8s9wgAB0BWCAz3EBAMhWC9hgewTa3gqv9RLY0cDgfs9xgADwngmBUSBA +gQf0wxEABlEgQIEF8mYIL/gT2O/x7/HxwP4I7/YH2J4MAADPdaAAtA/8hRpwANgcpc9xoAAsIDCB +Fgtv9oogkQXqD0ABz3aAAJQGAKYB2AYNYAEErkCGz3GAADRnAqZFoUIKoAQGofyl8g0gAApwFY6B +4B70QIaKIEQEz3GAABgjIoEaYjhgEHIB2MIgDgCA4AvyiiARC7YKb/YA2aoPIAME2ATwsg8gAwTY +ng4AA8kAz/bxwOHFz3WAAJQGFI2MIMOPDvTPcIAAJCMlgCOBIIHHcZwAAEBaCw/9/tgUrbEAz/bx +wOHFz3WAAJQGB4UbeEYJ7/wjhYDgBfIB2BWtrf+RAM/24HjxwP/Zz3CAAJQGNKjo//T/bfHgePHA +/g+P9gh3z3CcAABAz3GAAHiFxYFOCe/8yXGMIAKAz3GAAJQGAN2G9x14jCACgAHlffcAKEIDBSq+ +AxwZQA6A5xa4BqEE9P/YFKkUiYwgw49ID8H/EQDP9uB48cDPcIAAGCMaD2/2A9naDk/2NfHxwFIJ +r/US2KH/z3GAAPCeCYFRIECBB/TDEQAGUSBAgQTyxg7v9xPYz3CgACwgMIDPcIAAlAYjoM9wgAB4 +BSCAYHkL2BHx4HjxwAoJr/US2ADYC/GA4AHZwHnPcIAAlAbgfySgz3KAALQGYYKA4WV4AaIR8s9x +gABcWwSSdokQcxT0BZJ0iRBzEPQMijKJEHEM9A3IBCCAD/7//wMNGhgwDciHuA0aGDDgfuB4z3KA +AFxbz3GAALQGBJF2ihBzDPQFkXSKEHMI9AyJUooQcgT0AYED8ADY4H7xwM9xgAC0BgCBgOAT8gGB +gOAV9PoMgAOA4A3IxSCCDwEAAPwJ9AUggA8AAAA8DRoYMA3IkLgNGhgwhg4P/NHA4H7gePHASgiv +9Q3YgOAt9M9ygABcW89xgAC0BgSRdooQcxz0BZF0ihBzGPQMiVKKEHIU9AGBgOAU9JYMgAOA4A3I +xSCCDwEAAPwK9AUggA8AAAA8DRoYMA3IkLgNGhgwHg4P/ALw1//L8eB4DciQuA0aGDAJBg/88cCS +CkACgOAH8s9wgAC4BwCAhuAH9M9wgAC0BgCAgOAD9ADYAvAB2K/x4HjxwMYNj/YacAQikg8ABgAA +TCIAoAHdwH0EIoIPQAAAANdyQAAAAAHfz3aAAPSLGI7AfxB1OnEJ9IDlBfQZjhB3A/QA2ALwAdhA +hg95EnIA2Ab0QYYycswhIYAD8gHYLyYH8BquOvIA2c9woAC0Dzyg/g+P/gpwKnGpcp4MoAHpc5IL +IACpcNT/gOAH9GoKQAByDU/9A/CeDU/9zg5ABAGGz3WAALQGBLUAhgW1GI4MrfIOYATpcASVz3KA +AIgKJZUUsgiCgOHQICEAzyAiALm4urgFIIAECKJJBY/28cDyDI/2z3CAAIgKCYCiwVEgQIEA3gzy +CiHAD+tyBdiS24okww9lAm/1uHaLd+lwRgxv9gLZz3WgALQPcBUQENylz3GrAKD/2aEH2Bqh2KEA +FAAxAhQBMUQgAgJCIgKCQSjDAMoiYgDAuNILoAHAuwAUADGGIP8NQiAAgroKIADKIGIAcB0AFEHG +6XCKD2/2CNnFBK/2osDhxeHGz3GgAMgcyIEIoQbdEfDgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeGG9jCX/n+31yXDBxuB/wcXgePHAGgyv9gHZz3CAALBlAJCG4M9yrADUAQDdBfStGliA +A/CtGliDN9uoGtiAhuAM9EXb6BrAgOwaQICBGtgAghpYAA/woN/oGsCDBd7sGoCDWtuBGtgAghrY +A4MamAMH3r4amIMIGoCDhuAM28ojgg8AAHcAGBrAgL8amIMMGoCDhuA428ojgg8AAH8AHBrAgLwa +WIMAGkCDEBpAg70aWIMEGkCDFBpAg4bgCPQE26oa2ICrGtiACfBI26oa2ICrGtiArBrYgJMaWICG +4GrYyiCiCpgaGIB62JkaGIAQ2JoaGIB+GlgAfxpYAIAaWACVA4/24HjPcAAAAT3PcaoA8EMFoc9y +AAA8PEahz3AAADw+B6GKIFQACKHPcAAACxIJoc9wAAAYHAqhz3AAAB8fC6HPcAAAHBgMoc9wAAAS +Cw2hiiBEAQ6hz3AAAD48D6FQoYogRA8RoeB+4cXPcaAAyBwIoQbdEfDgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeGG9jCX/n+314H/BxeB48cCCCq/2B9gA34j/GnCY/891pAC4PawVABbP +dqUA2MuiuKwdGBAB2Oym9h0YEA4KIADpcIogxACfHRgQOdnPcKUACAw+oMf/CnDf/xjYlR0YEMjZ +z3CAABgjIKDhoCKgz3EBANRWz3CAAFgX1BhAAPjYC6ZxAo/28cASCq/2iiEEDs9wgAAUfRYOL/ZA +IA0Cz3CAAFxbQCAOCAYOL/aKIQUFSiQAdgDZqCDAAooi/w8SaRR4HGVApNhgQKAB4TkCj/bgeM9y +gACwZSeKgOEF9CaKgOEM8oDgz3GsAJABANoD8kWh4H4C2AWh4H7gfuB48cDhxQh1IJAClUGVELgF +einYErgVIEEAQKEglfAgQQAwcg7ypgsv9oog0QMClSGVELgFeZYLL/aKINED0QGP9vHA4cUIdSCQ +ApVBlRC4BXoV2BO4FSBBAEChIJXwIEEAMHIO8mYLL/aKINEDApUhlRC4BXlWCy/2iiDRA5EBj/bx +wBoJj/YodoDgzCYikA30CiHAD+tyBdiKI4UOiiTDD4kGL/W4c1MmfpDKIcIPyiLCB8ojgg8AAHwB +yiBiAfD1QYAghqKAWHlAgCR9KdkSuRUhggCgogCA8CEBADB1C/LqCi/2iiDRA4og0QPeCi/2qXEV +Aa/2BG7xwKIIj/aA4Eh1y/cIdkCFYb5gegRtgOYIcRDlOffxAI/24HjxwOHFiiBSDqYKL/Z02c91 +gAA8I6lwQCWBFdoIb/YW2gHY0QCv9jEdAhDgePHASgiP9gh2guDKIcYPyiLGB8ogZgHKI4YPAABP +AMokJgDABSb1yiXGAM91gAA8IwuFACaPH4AAWCMQdgT0FI+A4Dnyrgvv/wXYGnCKIBIOMgov9slx +RC6+FQAlQB5AkCGQCLpFec9ypAC4PZsaWAAikMoaWAAjkMsaWAAkkMQaWAAlkMYaWAAmkMcaWAAn +kMIaWAAokMMaWAApkMUaWAAKkKMaGADqDO//CnDLpQDYFK/9B0/24HjxwOHFpsGKIJINwgkv9oXZ +i3AGDy/2BtkAFAAxgOAU9EAkgDDPdYAAPCOpceIPL/YW2gHYMB0CEAuFgOAMD+H/yiAhAAAUADGB +4Bj0iiDSDXoJL/aW2UAkgDDPdYAAPCNAJYEVqg8v9hbaAdgrhTEdAhCB4dQOwf9iDg/2kQdv9qbA +4HjxwBIPT/bPcoAAcCMBghYShAAJJAQATCQAgAXyTCQAgsv3CiHAD+tyBdiKI8gAeQQv9UolAAIA +22qiTCQAgGuibKLX92h3aHVocRJpFHgeYtOGAeHfZx5i1IZYYBWA22MveZBxHWWsorH3a6Lqog0H +T/bgePHAng5v9phwz3GAAHAjbIkA3UAhAgpKJMBw4HioIEADESNAgwf0z3D/AP//FSJMAwCkAeWv +fWuBqoFwdQyB1fYQdc/2EHMC28ogKQDKJWkQyiNsAMogLADKJawQFPAB2wLYAN0Q8BBzy/YQdQDd +yiOpAMogaQAI9gHYAt0D8ALYAd0A2/AizwDwIkUD8CIAAAIlzgPNoQIgQAEOoQDYDyDAADwZAgAP +IEADPRkCAFkGb/YAHMIA4HjxwOYNb/aKIBANocHPcaAAsB87gQDeBggv9mDGrv+LcMr/z3WAAHAj +sBWCEIDiQCUBGgT0FI0Q8CDAeo3wIQ8AAYUFKP4AN3c29gHYFK2wHYITyXKA4swgYYAQ9CDC8CGD +ACGFWo0FKb4AN3PG9gLYFK0B2bAdQhCB4BvyguAP8oPgIvIKIcAP63IF2IojCwSKJMMP5QIv9bhz +AYU5jQUpPgANhTdwBfc9FYAQB/CxFYAQgOD69TwVgBAzaCV4D3kNrRDwAYU5jQUpPgAthS8gQA4Q +cS33LoUwcKj3P9ktrRWNgeAM8oLgGvKD4AvyCiHAD+tyBdiKI0sNzPE8FYAQEPABhVmNBSo+AE2F +LyBADhByBvdOhVBwP9hG9z0VgBBTaEV4Dq32Du/1iiAQDS6NDRWFEA+NBSFBASV4hiD/AQwVhBBD +uAskAIDKIcEPyiLBB8ojgQ8AAAMDIAIh9cogYQEGID6ByiHCD8oiwgfKI4IPAAAEAwQCIvXKIGIB +0QRv9qHA8cBeDG/2SiRAABpwwLiB4MIkAgEKc4Yj/gNEuwpwhiDxD0e4RCCCI1x6SHHPdYAAcCNM +rQQgji8AAAAMSr64dtStBCCOLwAAADBMvtWtBCCPLwAAAEBOv7EdwhNTIr6AyiHBD8oiwQfKI4EP +AAAyAcogYQEc8kwkAIAp8gQhAgBQcMohwg/KIsIHyiOCDwAAPAHKIGIBDPQEIMIAUHMO8gohwA/r +cgXYiiNED4okww9FAS/1SiUAAIDjQfQKIcAP63IF2IojhA/y8YPmA/aA5gj2CiHAD+tyBdiKIwUB +6PGwdoX2TCUAgAj2CiHAD+tyBdiKI8UB3PFTIgQARCKPAC8mwQMAJIQBhiL/DkK6gHJPerByQ/ZU +rbhy0XJD9lWtSHaC4kT2ANqxHYIQsHZRjQX0gOID8gTaUa3RjYHmzCYikMwmIpEG9FNpJXpOrU2t +gOPMJiKRBfJTa2V6Ta2A4MwmIpEE8lNoRXgOrRNpJXgPrQ2NEK1WDu/4ANhFA2/2Ph0EFPHA4gpP +9s91gABwIxGNgOAU8pIML/UR2ADe0a3Src9wgACICg2Qlv/PcIAAsGUHiIDg+A8C99+1iiCQDNYM +7/WKIYwJCQNP9vHAAtjPcYAAcCMRqRKJRSBAAhKpD4lQiRByBvIQqeIN7/gB2NHA4H7xwALYz3GA +AHAjEakSiYC4o7gPeKG4EqkNiVCJEHIG8hCptg3v+AHY6vHgePHAPgpP9s92oACwHxuGAN/PdYAA +cCNTIFAFAtgRrTuGVgzv9YogEAoPjeCl4aXipYYg/wFbaA6NrB3AEwHZhiD/AUO4EHIyrQP0Bdky +rQeFEnDP94G5Mq3V/89xgAA0ZxSBAeAUoTuGiiDQCgXw2v87hoogUAwCDM/1KQJP9uB48cAD2c9w +gABwIzGoANkyqC2IUIgwcgbyMKgSDe/4AdiY8eB48cCaCU/2CHfPcIAAiAoJgM91gABwIyW4UyAQ +AB+VEHdT8oogkAmuC+/16XERjQHe0a0TrelwQv9RJwCQBPQRjYTgC/TPcQICAgKKC+/1iiCQDJz/ +UvATjYDgANky9NGtrB1AEDKt1q3XrQrYGK0F2lmtUNgarQDYjrgIpQmlB6UD2EAdAhAE2EEdAhBC +HQIQQx2CEEQdghBFHYIQBthGHQIQRx0CEEgdAhBJHQIQCNhKHQIQDNhLHQIQMti4HQAQsB1CEKb/ +EY2A4BjyBMqQ4BT0TCAAoBLyDI0zaCV4Dq0Nrc9woACwHzuAuBUAEDa5OGC0HQAQuv8FAU/28cCi +CE/2z3WAAHAjFo0hhRBxR/cXjSKFEHFQAAUALYXPcIAAsCMvYKX+z3CAALBlB4iA4LgNAvcA2A2l +DqUApQGlAqWsHQAQz3agALAfO4aGCu/1iiBQCqL/G4Y2uB9nyb+0HcATI/ASjaG4OI1AhTByz3ag +ALAfEq2H92T/O4aKIJAKEfA7hkeF1blQcUn3gbgSrV7/O4aKINAKBfBm/zuGiiBQDDIKz/VhAE/2 +4HjxwLYJL/UR2Iog0AcaCu/1OtnPcoAAcCMxioDhIPLPcIAAmIUCgEIgAIDKIGIALyYH8Bb0g+ER +9M9woACwHzuAtBIAADa5InjJuIwgx4/I91j/MQXP/7//KQXP/yUFz//xwOHFz3WAAHAjEo1RIACB +CfINjRCt5grv+AHYEo2kuBKt6QcP9uB48cBqDw/2z3aAAHAjEo5RIACAU/LPcoAAyHU+gua5C/QA +koYg/ACMIAKAR/RRIQCCQ/IAhgHgAKYPjoYg/wGWEo0AQ7ixcDn0ANmsFgUQSiTAcFISBAGoIMAF +z3CAABR2NHhgiBElQJBAJA8LQC2AABR4NXjYYAXy4OPCJ8UQ86AB4UAlQADCuKweABABhgHgAaYA +koYg/ACMIAKABPQChgHgAqaKINAH9gjv9YohEg1qCC/1EdgdBw/24HijweHFQsEJFIEwQ8KD4UHA +ANgK9oDhyPYKFIEwgOHE9oPhw/YB2AcUgjAGFIMwUHMG8iLBMHPMIkKAA/QB2CHFgeUQ9AoUgTAj +w3BxSvYLFIIwUHHMI6qAhPaA4sogaQCB4A30iiHJD89wgADEBiCggeX/2cohIgAhoMHF4H+jwKPB +QMBBwQUUgTAA2IHhQsIN8oLhB/KD4Q30IcEA2A8gQAADFIEwDyBAAAIUgTAPIEAABhSBMIHhDvKC +4Qfyg+EP9CHBA+EPIEAAAxSBMAPhDyBAAAIUgTAD4Q8gQAAJFIEwgeEO9AIUgTAKuU8hAgQDFIEw +DLkleiHBDrlFeSV4IMGB4Qj0BxSBMCLCBrkIukV5JXjgf6PAANjPcawA1AH4GQCA/BkAgAChpRkY +gKYZGICnGRiAohkYgKMZGICkGRiAnxkYgKAZGIChGRiAz3KAAMwGAIKLGRiAAYKMGRiAsREAhoO4 +sRkYgLIRAIaDuLIZGICzEQCGg7izGRiA4H7xwOHFAN3PcIAABAWgqM9wpwCYR7qgogtAAIDgA/Tf +/w3w6gtAAM9wgADMBkCAz3GrAKD/WKEBgBmhz3CnABRIqKBlBQ/24HjxwOoMD/bPdYAAzAYChYHg +Adgg8nYIr/8H2D4NYAAIdmIPQACWCA/2EgiAAIoOQAAKDkAAgOAN8v4JgABKCcAA1gmAAOIJr//J +cAHYAqUA2AUFD/bxwJYML/YB2M91oADIHBGlAN7n/4Hg0A1BANGl5QQP9s9xrACYAACBo7gAoQGB +o7gBoQKBo7gCoeB+4HjPcKsAoP84gM9ygADMBiCiOYAA2yGieKB5oD/ZOqDgfgLYz3GsANQBnxkY +gKAZGIChGRiAAdiiGRiAoxkYgKQZGIClGRiAphkYgKcZGIAF2PgZAID8GQCAAKHgfvHA+gsv9phw +Ad3Pd6cAFEiop97/5P+IcOv//9ibuM92pwCYRxymiiASDQYOr/WIcc9xgAAEBQCJgODKIcIPyiLC +B8ogYgHKI4IPAAC5AsokIgA8AeL0yiUCAQDYFqcb2BqmAQQv9qCp8cCOCw/2Ad7PdacAFEjIpUYK +YAAacMr/JgtgAApw/9ibuM93pwCYRxyniiASDZoNr/UKcc9xgAAEBQCJgODKIcIPyiLCB8ogYgHK +I4IPAACKAsokIgDQAOL0yiUCAQDYFqXap40DL/bAqeB48cDhxaoJYAAIdYDgqXAE9Mf/A/Dg/4kD +D/bgePHAocG4cADYQMBTJYAAgeAP8oLgFPKE4BnyCiHAD+tyBdiKI8kGeQDv9Iokgw/PcAAAItLP +cYAAk3wP8M9wAAAj0s9xgACWfAfwz3AAACTSz3GAAJl8KdoSuvAiAABAwItwIgvv9QPaocDRwOB+ +4HjxwJoKD/bPcKYAnD8ZgFEgAIChwaTyAMAA3Q8lDRA2DqADi3CA4CP0z3eAAIgKhBcBEC8pQQBO +IYAHQSjFAEwlgIAAHEAxCffPcIAADAsyIEABgOAT9AohwA/rcgXYiiOMAs0Hr/SKJIMPABQFMEwl +gIAU9893gACICs92gACIfEAmwBIuDq/1CdmaCEAAgOCpcAv0v/8L8AohwA/rcgXYiiOMA9/xcglA +AFMlgBCB4A7yguAe8oTgLfTPcKcAkEgggM9wgAAEqCKgJfDPcIAAsGVAkM9wpwAUSIbiz3GAAASo +BfQegAChFfAdgAChE/DPcIAAsGVEkM9wpwAUSIHiz3GAAASoBfQdgAGhA/AegAGhAsi5EIAAAg2g +A6lxAMHHcYAA+AoUiYDgBfJhuA94FKkCyLkQgAAbeIC4Cq6KIFINjguv9alxhBcBEM9wgABUXDag +z3CAAGyfIqAE/6UBL/ahwIDg8cC4cQv0CiHAD+tyBdh727kGr/SKJIMPz3GAANiLIIFMJQCABCGB +DwAHAABBKQMGANnKJE1x4HjoIK0D8CBFAAQlgg8BAADALrplelBzBPQB4dHA4H4KIcAP63IF2ITb +aQav9EokQADgeM9wgACICgiAz3GAANiLUSAAgATyAYkD8AKJ4H8AqeB4CHFYiQGAgOICoQn0WYmA +4sIgogDAIKEAAqHgfvHAhggP9ih1YoUgkM92gADMBnh5Y4UkeyOGZXkjpiaFAZA4eCeFosEkeCSG +QCUQFIDiJXgEpify+gtv/wfYOnABhSOGABwEMAIcRDAwuQQcRDAghYt3YHnpcAQQACAkhgIcRDAw +uQQcRDAAEAEgABwEMGB56XAA2AOmBKZSDW//KnBlAC/2osDxwPoPz/WhwQAWjkAAFo1AABYAQZYL +b/8H2BpwguYG2AP0u3gH4APgBCCADwAA/P8FIIAPgK4AAOxxAKEByOxxAKHscMCoAdnPcKAAyB9R +GFiAh+aiAQ0AMiaOc4AAhEtAJwBy1HgAeAAWAUAAFgBAgLnPcKAA7CcmoKrwgOVQAQ4AABYAQQAW +AUEAHEQwABYBQOIPIABhvQAUATEGuIG4ELkleM9xoADsJwahgOUr947w7HCgqIDlFAEOAAAWAEAA +FgFArg8gABB4BrhFIMIAz3CgAOwnRqAKgItxALEAFAEx7HAgsGG9gOUq93DwABYAQLIKQADPcaAA +7CcLoQAWAEBm8IDlyAAOAAAWD0AAFhJAQS8RFPB/Wg8gAOlwBrhFIMAAz3agAOwnBqYKhotxALEA +FAAxBiBABAUggAQAHAQwMg8gAOlwABQBMQa4gbgQuSV4BqZhvYDlsgfN/zjwgOVsAA4AABYAQQAW +AUEAHEQwABYBQP4OIABhvQAUATEGuEUggAEQuSV4z3GgAOwnBqGA5Sn3HPCA5dr3ABYAQQAWAUEA +HEQwABYBQMYOIABhvQAUATEGuEUgwAEQuSV4z3GgAOwnBqGA5Sr3ANnPcKAAyB9RGFiAbgtv/wpw +Rg2v9QHYANjPcaAAyB90GRiAZQbv9aHACiHAD+tyBdiKIwQLSiQAAJUDr/QKJQAB4HjxwPYNz/UA +Fo5AABaNQAAWAEGKCW//B9iYcILmBtgD9AdtA+AEIIAPAAD8/wUggA+ArgAA7HEAoQHI7HEAoexw +wKgB2M9xoADIHBGhhebKAC0AANozJo5zgACMS0AnAHLUeAB4ABYDQM9woADsJ2agSvCA5ZAADgCf +deB4qCAAAgAWA0DPcKAA7CdmoDzw7HCgqIDlcAAOAJ914HioIMACABYDQM9woADsJ2agaoDscGCo +KvAAFgNAz3CgAOwna6Ai8IDlyiRNc+B46CCtBwAWDkAEJoMfAAAA/yi7tmtFJc8Qz3OgAOwnBCaA +H/8AAADmo+qDMLg4voG9Bn/lfhC+xX2mo1GhMgpv/4hwBgyv9QHYTQXP9QohwA/rcgXYiiMGDUok +AABlAq/0CiUAAeB46QWP9fHAvgzP9Rpwz3CAAHAjEIjPdoAA9IuGIP8BO2gFhg4gQIDPcYAAsGUn +icogYgCA4SLyOo6A4cwgIYAe8gDdDN8SbRV4x3CAAGwnIICA4QbyAoCA4BXyQHhhv4DnAeUy9wDY +Gq7PcIAAcCMQiIYg/wFDuAWmAgxv/wpwqQTP9QohwA/rcgXYLdtKJEAAyQGv9Lhz4HjxwAAWhUCn +wUwlAIUAHEAxRPdMJQCCS/cKIcAP63IF2HrboQGv9EokQAAAFoBAYcAAFoBABRwCMAAWgEAGHAIw +i3D2CGAAgsEDwoDiC/QKIcAP63IF2ITbiiTDD2UBr/S4cwXAYHoGwQTBgOHKIcEPyiLBB8ojgQ8A +AIgABdju8wLAgODiIEIA6gqP9afA0cDgfuB44H7gePHAmgvP9Rt9AvAIdc9wpgCcPxmAUSAAgCb0 +A94R8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Yb6MJv+f7fWA5cIH6f8JbQohwA/r +chLYTNtKJAAAzQCv9AolAAGhA8/18cAmC8/1OnAKIECgz3agAMgfAdhRHhiQz3ABAALDz3WgAOwn +BqXPcAEAQsUGpc9wAQACyAalz3ABAILKBqUO9M9wAQBCxAalz3ABAELJBqXPcAEAwssGpSDf8KYy +2EMeGBAA2L4Jr/WNuPGmANhRHhiQz3CgAKwvGoDAuIHgAdjAeC8mB/Au8kwgAKAi8gHYUR4YkEwh +AKAO8s9wAwDGAAal8KYy2EMeGBAA2HYJr/WNuPGmz3CAALBlAJCG4Abyz3AGAAJ1BqUA2FEeGJAE +8M4Nj//PcIAAiAoPgIC4BqWlAs/18cDhxQHbz3KgAOwnZqKA4c9zoACsLwb0GIOauBijV/C1g1El +AJAM9FQTBAAKIcAP63IF2EjbqQdv9Lhzz3PAAEdoZqKA4Abyz3ADAMcABqLPcBAABmkGos9wAADC +Ggaiz3AAAAI0BqLPcAAAgk0GosfYlbgGos9wAABCLQaiz3AAAIJGBqLPcAAAQmAGos9wAwACwwai +z3ADAELFBqLPcAMAAsgGos9wAwCCygaigOEN9M9wAwBCxAaiz3ADAELJBqLPcAMAwssGovkBz/Xg +ePHAz3CAALBlCBAFAUwlAIDMJWKADvJMJYCADvIKIcAP63IF2IojBwDlBm/0iiSDDwDYA/AB2NHA +4H7geM9wAwAGIc9xoADsJwahz3AEAEZLBqHgfgHYANvPcaAAyBwRoc9wgADHIM9yoADsJwaiz3CA +AAc6BqLPcIAAh1MGos9wgACHJAaiz3CAAMc9BqLPcIAAR1cGooogigAGooogiwAGooogjAAGooog +hQAGos9wAwAHIQaiz3AEAEdLBqLPcAMARzoGos9wBADHZAaiz3ADAMdTBqLPcAQAxzEGos9wgADg +BgCQELiFIIQABqJxoeB+4HjxwKHBLygBAE4ggQfPcKcAPEgUgM9ygACTfDR5WWFAwItw3giv9QPa +ocDRwOB+4HjPcCwABgHPcaAA7CcGoc9wgADGIAahz3CAAIYkBqHPcAMAwgIGoc9wSABCAQahAdnP +cKcAFEg3oOB+4HiAuM9xoADsJwah4H4J2eB/IKDgePHATgqv9SjYCHGGIfwDJLnPcoAAsGUgskQg +AQMiuSGywbgCsk/x4HjxwCYKr/UA2EEoAQLAuc9ygACwZSaqKbjAuAeqP/HgeM9wIAAGAc9xoADs +Jwahz3BwAIICBqHgfs9xIAAHAc9woADsJyag4H7gfuB4AdnPcKAAyBwwoEvZz3CkABxAJKDgfuB4 +4cXhxgHaYJAf8MlzHfAVII0AwJWhlQHi13YAAPv/UHp19tdzAAD//xvyguHMI4GPAAD+/xXygeHM +I4GPAAD9/w/ygOEJ8s91AAD7/7Fz4fXBxuB/wcXXcwAA/P/19Qa+gb4QvcV9z3agAOwnpqbt8c9y +AAA+Ps9xqgDwQ0WhRqGKIMgPB6HPcAAABQoIoc9wAAAPFQmhz3AAABkdCqHPcAAAHx8Loc9wAAAd +GQyhz3AAABUPDaGKIJQCDqHPcAAAAj8PoVChUaHgfuB48cCyDo/1z3CAALBlJ4iA4QHYMvIA3s91 +oADIH1EdGJDPcIAATCQC2cP/z3AHAMYAz3GgAOwnBqHPcGAAxiAGoc9wDwCCIwahz3CqAAIkBqHP +cKcAFEjLoMyg0/9RHZiTIN7QpTLYQx0YEADYNg1v9Y240aWpBq/1AdjgePHA4cXPcoAAsGUEks9x +gADYi4DgANtgoRHygeAm8oLgN/IKIcAP63IF2IojSgZKJEAAlQNv9EolAAAH2Bi4AKFhqUokwHBi +qaggwAIA2I64FiHNAAGlA9gOuAKlAeMD2AayB7IA2DDwANiZuAChUtgBqUokwHACqaggQAIA3Y+9 +FiHAAKGgoqAB41LYGPAA2Ji4SiTAcAChqCBAAgDdjr0WIcAAoaCioAHjYdhgkgGphuPKIIIPAABS +AAKpAttmsgHbZ7LlBa/1AKngePHA4cXPcYAAsGUHiaHBgOAA2jPyAByEMAPbz3CgAOwnZqAKgIt1 +ALUAFA0xqXCGIPwHjCACiAX0AByEMEh1qXSEJAOQyiHCD8oiwgfKIGIByiOCDwAAtQLKJGIAnAJi +9MolQgNEJQAcRLgEsUQlABNCuAWxAvBEsWUFr/WhwOB4z3CAALBlB4iA4Bbyz3IBAECAz3CAAFAY +RKDPcAAANOOA4M9xgADcFgbyuBkAABuBkbgboeB+4HjxwM9wgACwZQSQgOAR8oHgzCCigBHyCiHA +D+tyBdiKIwwHSiRAAB0Cb/RKJQAAz3EqFRUqBPDPcSoqFRXPcIAACAUgoNHA4H7xwM9xgACwZSSR +gOFD8oHhD/KC4S/yCiHAD+tyBdiKIw0ESiRAANUBb/RKJQAABCCBD/P//88EIYAPAwAAAAK4BSEC +AAQhgQ8AAAAMBCCADwAAAAwleM9xgACICiiBArhRIQCARXgX9AcggA8PAAAAxvHPcYAAiAoogVEh +AIAL9AQgvo8MAAAA0iCiBNIg4gS29bbxIJABkAa5gbkQuCV4z3GgAOwnBqHgfuB4ocHxwLYLr/WY +cM9wgAD0ixAQBQDPcIAAbCcFgKHBgOCGIfcPSvLPdYAA5AYGhbBwB/QHhZBwBfQIhRBxPvIAHAAx +IMKA4VMiwACGIv8DRLpaYgO4VHoUeFhgx3CAAFCR4IjpcoYi/Q9begGIRX8IcoYi/Q9bekV4AN4T +8s9yqgDgB3OCUSMAgAjyCKLposqiy6LMos2iDfDoogmi+fEJuOV4z3KnABRIA6LEosWiGB1AERwd +ABEopQjcawOv9aHAAIAB22ChaLgCuBV4x3CAAGwnQ4BDoUGAQaFCgEKhRIBEoeB/YKDgeM9wgACw +ZQSQz3GAAOgnhCgFBAAhgH+AAFwo4H8CoeB4WQFP9s9zgAD4J89xgADkBgyJQ4MAqg2JAaoB2OB/ +AKPxwJYKr/VKJAAAz3KlAAgMCBIFAEwlAIDKIcIPyiLCB8ojgg8AAKED/Aci9MogYgFA2AKiz3OA +ALBlz3GAAPSLz3CAAFwopJMggRPwhCkCCi9zhC0FFCdzG2P0IwMBz3amAACAFSYOEUAkRABgpowk +gYSu94QtBRQAIYB/gADUKIQpAgoncHaQz3GkAKA/faEXkB6hCBpAAWkCj/XxwPIJj/WlwQh3KHaO +De/+B9gacAGGDN0EHAQwBBcBFAYcRDAwuQgcRDAQFgEUYHmBwAGGYb0MHAQwAReBFA4cRDAwuRAc +RDAQFgEUYHmDwIDlMffiDu/+CnD9Aa/1pcDxwJYJj/XPcIAAbCcAgIDghvIB2M91oADIHBGlz3DB +AEItz3GgAOwnBqHPcMEAgkYGoc9wwQBCYAahz3CAAHAjEIiGIP8BQ7gpaIbhzAANAM92gAD0iwSG +MyZBcIAAlEtAJ4J0BrgUeDR6x3CAABCMAHrPcYAATCxP8M9xgAAcLRDgS/DPcYAA7C0g4EXwz3GA +AEwsMODD/wSGz3KAAFCMz3GAABwtBrgUeDbwz3eAAJCMz3GAAEwscOC6/wSGz3GAAOwtBrgUePhg +J/DPcYAAHC1Q4LP/z3KAAHCMBIYX8M93gACwjM9xgABMLIAgAgSs/wSGz3GAABwtBrgUePhgqP8E +hs9ygADAjAa4FHjPcYAA7C1YYKP/ANgRpeEAj/XhxQHYANnPcqAAyBwRos91gADkBgCNz3OgAOwn +ELgFIIAPAADCaQajAY0QuAUggA8AAAJqBqMxouB/wcXhxQHYANrPcaAAyBwRoc9wgADkBmKQhrsQ +uwUjjQ8AAMISz3OgAOwnpqMDkBC4BSCADwAAAhMGo1Gh4vHxwAIIj/XPdYAA5AbIjQmNwr7CuBZ+ +z35SCO//DdgGuIG4EL7FeM9xoADsJwahBIXPcaUA6A8GoQWFB6ExAI/18cC+D0/1z3alAOgPJoan +hs9wgADkBgDfJKCloA4I7/8N2Aa4gbjPcaAA7CcGoeamRSXNH6em8QdP9eB48cBuD0/1osE6cBpx +AN0aC+/+B9iacALZqXBacHpxANs0aAJxKHUUIQAgaHLChQQQDwXYf8OFAeLEf4Pi5Xsg5bb3AYEC +HMQwMLsAHAQwIIEEHMQwYHmLcEIjQSCA4b4H7f9AIkAgXgzv/opwVQdv9aLA4HjxwM9wgABsJw+A +gOAP8s9wgAD0iwSAz3GAAEwvz3KAAHCSArgUeFhg2f/RwOB+4HjxwNIOT/XPcIAAbCcUgIDgfvLP +cIAAcCMQiIYg/wFDuClohuHoAA0Az3WAAPSLRIXPcIAA8JIzJkFwgACcS0AgEAsEulR6QCARCkAg +EgZAIA8IQCAOBFhgQCcCcjR6AHrPcYAArC9R8M9xgADMLwTgS/DPcYAA7C8I4Efwz3GAAKwvDODO +DW//ANoEhc9xgADMLwS4FHjYYDfwz3GAAKwvHOCyDW//ANoEhc9xgADsLwS4FHj4YCnwz3GAAMwv +FOCSDW//ANoEhc9xgADsLwS4FHhCcBnwz3GAAKwvJOB2DW//ANoEhc9xgADMLwS4FHgicGINb/8A +2gSFz3GAAOwvBLgUeAJwTg1v/wHaIQZP9fHACiUAgM9xgADkBiQRBAAj8kwkAIDPcqQAuD0A2w70 +mxIABgqhphIABguhkhIABgyhoxIABg2hmxrYAP/YphoYAJIaGACjGhgAAdrPcKAAtA9coCbwTCQA +gMohwQ/KIsEHyiOBDwAA1AX4AiH0yiBhAQqBz3KkALg9mxoYAAuBphoYAAyBkhoYAA2BoxoYAAPI +z3KgALQPhiD/DiK4HKIkGUABI/HgePHA4cVGDi/1CHVGDWAAqXCNBU/18cDhxTIOL/UIdQoNYACp +cHkFT/XxwCIOD/WT/gnx4HjxwOoMb/UA2QfYGnE6cADeQCgAIRR4x3CAAPCSFSCNAwCVjCACjQDf +hPaMIIWCyfb/2AC1iiARA+4O7/QA2QGdvOAF9owgP4FH9uG1iiARA9YO7/QA2QHmz36M5rQHy/9C +IUAggOBAIEEgogft/y952QRP9fHA4cXPcYAA8JKKIAgPqNoB3TILb/Wpc4DgyiHBD8oiwQfKIGEB +yiOBDwAAgAXKJCEA4AEh9MolAQHV/89wgABsJ7UEb/W0oPHAOgxv9YogmAehwYt2yXEB2uoKb/VI +c4DgDvQKIcAP63IF2Ioj2ANKJAAAnQEv9AolAAEAFAAxz3WAAOQGyXEB2gytiiAYCLIKb/VIc4Dg +yiHBD8oiwQfKI4EPAAAWBgXY5PMAFAAxDa09BG/1ocDPcIAADDDgfxSA4HjxwLYLT/UIdxpxAdnP +cKcAmEc6oCDez3WgAMgf0KUK2EMdGBAA2IoKL/WNuNGlz3GnABRIDIGA4APyPoEC8D2BABhAIPe5 +xSGCDwD/AADTIeEFyQNv9SCn8cBiC0/1z3CAALBlB4iA4FgCIQCiwQHZz3CgAMgcMaDmDq/+BdjP +doAADDAPpsPYz3WgAOwnBqUKhc93pwAUSAC2iiDEAAalCoXPcacAmEcBtoogxQAGpQqFAraKIMsA +BqUKhQO2iiDPAAalCoUEts9wAACDDQalCoUFts9wAADDDQalCoUGts9wAAADDgalCoUHtgiHBKYc +gQWmF4cGphaHB6bPcKUACAwCgAimDYcJpg6HCqYPhwumz3CrAKD/GIAMps9wqwCg/xmADabPcKsA +oP8agA6mz3AFAMYDBqXG2JC4BqXPcCwAAgEGpc9wWgBCAQaliiCLAAalz3BAAIcNBqXPcNEAwg0G +pc9wwAAHDgalAdgIp89wUAD/AByhAdgXpwDYFqfPcKUACAxQ2SKgANgNpw6nD6f82c9wqwCg/zig +c9k5oBqAz3GrAKD/gbgaoc9wKgACDgali3CBwZL/AMHPcIAAcHI1pjKgAcEvoM9wGgACDgali3CB +wYv/AMHPcIAAcHI2pjOgAcEwoM9wJgACDgali3CBwYP/AMHPcIAAcHI3pjSgAcEgFgUQMaABlhC4 +hSCEAAalApYQuIUghQAGpQOWELiFIIsABqUElhC4hSCPAAalBZYQuAUggA8AAIINBqUGlhC4BSCA +DwAAwg0GpQeWELgFIIAPAAACDgalBIZMJQCACKcGhhenB4YWp89wpQAIDAgYQAHKIcIPyiLCB8og +YgHKI4IPAAD5AMQG4vPKJCIACYbPcasAoP8NpwqGDqcLhg+nDIYYoQ2GGaEOhhqhSg6v/g+GANjP +caAAyBwRoWEBb/WiwOB48cDqCE/1z3CAALBlJoiA4c91gAAMMKLBBPIHiIDgBvQThSkBb/WiwADZ +A9g6cRpwiiCRBfIK7/QA2V4Mr/4F2A+lw9jPdqAA7CcGpgqGz3enABRIALWKIMQABqYKhs9xpwCY +RwG1iiDFAAamCobG2gK1iiDLAAamCoaQugO1iiDPAAamCoYEtc9wAACDDQamCoYFtc9wAADDDQam +CoYGtc9wAAADDgamCoYHtQiHBKUcgQWlF4cGpRaHB6XPcKUACAwCgAilDYcJpQ6HCqUPhwulz3Cr +AKD/GIAMpc9wqwCg/xmADaXPcKsAoP8agA6lz3AFAMYDBqYB2Eamz3IsAAIBRqbPcloAQgFGpooi +iwBGps9yQACHDUamz3LRAMINRqbPcsAABw5Gpginz3JQAP8AXKEXpwDYFqfPcKUACAxQ2SKgANgN +pw6nD6f82c9wqwCg/zigc9k5oBqAz3GrAKD/gbgaoc9wEQAGDgami3CBwfL+NoUAwCJ4hCiEAxWF +N4UCefIIb/svcAHCgiDEAs9xgABwchOlVaEWoc9wQACGDQamz3AQAAIOBqaLcIHB4v42hQDAIngE +KIAPAAB0CRWFN4UCebIIb/svcE/gFKXPcYAAcHIYoQGVELiFIIQABqYClRC4hSCFAAamA5UQuIUg +iwAGpgSVELiFII8ABqYFlRC4BSCADwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqYE +hQHCCKcGhSAVBRAXpweFTCUAgBanz3ClAAgMCBhAAVehQfQJhc9xqwCg/w2nCoUOpwuFD6cMhRih +DYUZoQ6FGqHGC6/+D4UThYwgA4JoAAkAjCA/i2AACwCMIIKARfaMIL+IWAAJACDfz3agAMgf8KYA +IUAkFXhDHhgQANg+De/0jbjxprj+iiDRBXII7/QzhUIgQCCA4EAhQSBoBe3/L3kM8AohwA/rcgXY ++dutA+/zSiQAAB7YE6VMFQQQjCSCgET2jCS/iAv2CiHAD+tyBdiKIwQOhQPv87hziiDRBR4I7/SI +cREFz//xwOHFz3WAAPSLLg0v/6lwuHAAhYDgEvLPcoAApEtKJIBzANioIEACRCh+AzIiQQ6wcSHy +AeAW8ADYSiSAec9ygAC8TKgggANZIsEIRCh+AydxMiGBDwAAKAGwcQvyAeAKIcAP63IF2KjbCQPv +80okgALlBQ/14HjPcIAA9ItAgIDiI4AJ8s9wgACwS0QpfgMyIEAODfDPcIAA2ExZIEAJRCl+Aydw +MiCADwAAKAHgfvHAKg0P9aHBGnAodkh1iiARBVIPr/SKIUcCiiARBUYPr/QKcYogEQU6D6/0yXGK +IBEFMg+v9Klxz3GgACwgEIHPc4AAHAcEoxCBRINCeBB1A6PV90AogiFFIs8Az3KgAOwn5qJKgotw +QLAAFAAxxHgQduz1GQUv9aHAopPPcIAA9IsMEAQAABQPMRC9CiHAD+tyBdiKI0cEBSREAxC/JQLv +8wUnhRPgePHAggwv9QDYz3GAALBlJJGiwYLhzCFigMogYQAvIAcgz3aAABwHApYB2QHgArbPcKAA +yB9RGFiAz3DAAEdoz3WgAOwnBqXD2AalCoVAJIEwALECFAAxwbiD4Bbyz3ADAMYABqUg389woADI +H/CgMtlDGFgAANgGC+/0jbjPcKAAyB/xoM9xgADoJwSBgeAU9AaBz3eAAPSLQHgYF4QQTCQAgBX0 +z3ABAAYBBqXPcBIABgQU8AohwA/rcgXY69tKJAAAWQHv8wolAAHPcAEABwEGpc9wEgAHBAaliiDE +AAalCoXPcYAA4AYAsSCHgOHPcAAAwhpDhyXyRCp+AwAhg3+AAKRLxtqSukalBqXPcAAAAjQGpc9w +AACCTQalx9iVuAalz3CAALBlAJDPcqcAFEiG4AHYwiABABN4wrgd8EQqfgMAIYN/gADMTMfYkrgG +pc9wGQDCGgalz3AZAAI0BqXPcBkAgk0GpcbYlbgGpc9ypwAUSADYC6IMos9wgACwZQCQhuAG8s9y +qgDgBwHYE6KA4Qn0TCAAoMoggg8CAIJyBPTPcBAAh3IGpQGLELgFIIAPAABCcgalBYsQuAUggA8A +AEJwBqUEixC4BSCADwAAgnAGpQOLELgFIIAPAADCcAalAosQuAUggA8AAAJxBqUJixC4BSCADwAA +QnEGpQiLELgFIIAPAACCcQalB4sQuAUggA8AAMJxBqUGixC4BSCADwAAAnIGpQuLELgFIIAPAACC +cwalCosQuAUggA8AAMZzBqVC2Iy4BqXPcAEARmoGpc9woADIH6QQEADPcIAAxnMGpc9wQABCdAal +z3CAAMdzBqXPcAIARmoGpc9wEADGagalL3gkj0wkAIAB2sB6wg4gAnmPJNgY2TPaL//PcBAAx2oG +pc9wEACGcgaltghAApIOQAIk2AHZM9on/89woADIH6QQAAACIAAEAKbPcAIAR2oGpc9wwABGaAal +z3AAAMMJBqUKhYtxALEAFAExgOHMIeKHKfTCC6/0iiCRBAOWAeADtgSWgeAO9AQWBBEAFAUxCiHA +D+tyBdj9Bq/ziiNGBYLgEfQEFgQRTCRAgMv2ABQFMQohwA/rcgXY3Qav84ojRgYYF4UQgcLPcQAA +QyHPcxEAQiHPcIAAIExYIMQHz3ASAEIhz3YTAEIhJqUqhUwlAIAgsmalI4cG9BUkQQDwEQEBBvAV +JEEAuBEBARC5BSGBDwAAwiImpQalJqXGpSalBBQAMRC4BSCADwAAQiEGpQDZz3CgAMgfURhYgCUB +L/WiwOB48cDhxc91gAD0iwClIaVYrXmttP4DpdH+BKXPcIAAsGUHiIDgFAzC/w0BD/XxwJIIL/VK +JEAAz3CAAPSLRIDPcYAAlAbPd4AAQJRVfyCBAIdKJUAAAiEDAM9wgABsJ6+AtBAOAM9wgACYBoHl +wiQCAYHmAIjCJUIBgOC0wR3yTCQAgMwlIoDKIcEPyiLBB8ogYQHABaHzyiOhDHF7lOPN989wgABI +FmWAIKdAwgHjZaDGDyAAi3BxAC/1tMDPcQEAfI2A4Qnyz3KAANwWwBpAADuCk7k7os9xgADolFkA +7/RU2uB48cDPcYAAPJVKCO/0LNoA2UokwHHPcoAAQJSoIIACz3AAAP//FSJMAACkAeHRwOB+z3GA +ALBlJJGB4QHZwHngfyCg4HjxwH4P7/QB2qPBCHW2D6/0i3HPcYAAvE4AgUHAApEIHAQwz3CAALBl +AJCG4ADCBPLDukDCz3GAADAHgcOpcPoIYAAwgSHALgtgAAfZWnAFFIAwIgtgAAfZOnBKcADZCNoq +c0okQALiC2AASiVABLpwBhSAMP4KYAAH2RpwBxSAMPIKYAAH2Qh3CnAA2Qja6XNKJEACsgtgAEol +QASacCLA0gpgAAfZCHUJFIAwxgpgAAfZCHapcADZCNrJc0okQAKGC2AASiVABHpwz3AAAAjSqnHa +C2AAANpB2Am4SnHOC2AAAdrPcAAAAYIqcb4LYAAB2s9wAAAJ0opxsgtgAADaz3AAAAKCCnGiC2AA +AdrPcAAAA4LpcZYLYAAB2s9wAAAK0mpxhgtgAADaz3AAAASCqXF6C2AAAdrPcAAABYLJcWoLYAAB +2gDYhQbv9KPA4HjxwKTBi3FuDq/0A9qSDu//g8ADwIDgNPQAwc9wAAAb0oDhEPQB2TYLYAAA2s9w +AAAc0gHZJgtgAADaAtgK2TDwgeEQ9ALZFgtgAADaz3AAABzSAtkGC2AAANoC2BTZIPAE2foKYAAA +2s9wAAAc0gDZ6gpgAADaAtgh2RLwz3AAABvSAtnWCmAAANrPcAAAHNIA2coKYAAA2gLYEdm+CmAA +AtoCwc9wAAAF0rIKYAAA2gHB0tgIuDt5AeGiCmAAANoA2KTA0cDgfvHAfg3P9KnBQMBBwQDYSMCC +xV4JYACpcITGVglgAMlwhsdOCWAA6XAAwIty6ghgABfZAcCBwuIIYAAX2QDAOglgAKlxAcAyCWAA +yXGpcKlxMglgAKlyyXDJcSoJYADJcqlwyXE+CWAA6XIGwAfBiMNyDyAAAdoIwG0F7/SpwOB48cD2 +DO/0BNqkwRpwHg2v9ItxAMHPdoAAMAdxhs9wgADsMAQUETAA3fAgwgDPcIAA+DDwIM8Az3AAAAbS +WHnWCWAAqXLPcAAAB9IAKcEjxglgAKlyCnDPcq3e7742DGAANIYKcEH/g+Am8jGGAsIKcAokgA+t +3u++GgxgAAPDCnCO/4PgGPLPcAAAINJWJgEU2glgAATaz3AAACHSVSZBGMoJYAAE2oAWABCEFgEQ +tf8bpqlwoQTv9KTA4HjxwD4M7/QB26HBGnDPdYAAMAdZhTiFCiWAD63e775ZYVqFtgtgAEokAAAK +cMb/g+Bd8huFOYUC21iFHKUKcAolgA+t3u++WWFahY4LYABKJAAACnC8/4PgSfIbhTmFAdtYhR2l +CnAKJYAPrd7vvkJ5WoVmC2AASiQAAApwsv+D4DXyG4U5hQLbWIUepQpwCiWAD63e775CeVqFPgtg +AEokAAAKcKj/g+Ah8huFH6VkFRAQWIU8hd6FfYU/ZhlhYnlifwIhgYMCfwDYQMAO8kx/i3YvcNIO +IADJcp4OIADJcADBAiBAIBmlANi5A+/0ocDxwOHFocEIdYtxdguv9AHaAMDPcYAAMAcQoc9xrd7v +vsYKYACpcKlwuv+D4MogIgCZA+/0ocDgePHA4cUA2AhxJghgAALaAdgA2R4IYAAC2gLYCtkSCGAA +AtrPcAAABNIA2QYIYAAA2s9wAAAN0gHZ9g8gAADaz3WAADAHE4UVJQAQJIDPcAAAEdLeDyAAANrP +cIAAsGUgkIbhE4UVfQT0JoUD8CSFz3AAABDSug8gAADaz3AAAALSz3HQB/8Aqg8gAADaz3AAAAHS +A9maDyAAANrPcAAAA9IC2Y4PIAAA2s9wAAAb0gPZfg8gAADaANiPuAPZcg8gAADaz3AAAAXSANlm +DyAAANoJ2Iy4ANlaDyAAANrPcAAAC9LPcUsAS0tGDyAAANrPcAAAEtIA2ToPIAAA2s9wAAAT0gDZ +Kg8gAADaz3AAABTSANkeDyAAANrPcAAABEOKIc8PDg8gAADaz3AAAHDSANn+DiAAANpdAu/0ANjx +wOIJ7/S12KHBrg8gAADZiiCEBqIPIAAA2YogRgCaDyAAANkE2JIPIAAs2Q/Yig8gAAHZBtiCDyAA +FdkI2HoPIAAV2QnYcg8gABXZCthqDyAAAdkL2GIPIAAB2QzYWg8gAAHZz3WAADAHUYUF2EjZRg8g +AA8hgQAzhYt2geEVJUwQFJQH8s9xgACwZSCRhuEp9GIPIADJcROFAMEVJQAQFJAWDyAAxrkThRUl +ABAYkEIPIADJcROFAMEVJQAQGJD2DiAAxrkThRUlABAckCYPIADJcROFAMEVJQAQHJDGuSjwEg8g +AMlxE4UAwRUlABAUkMYOIACHuROFFSUAEBiQ8g4gAMlxE4UAwRUlABAYkKYOIACHuROFFSUAEByQ +1g4gAMlxE4UAwRUlABAckIe5hg4AAADYGQHv9KHA8cDhxaHBi3HGCK/0AdoAFAQwz3WAAFyUz3CA +AGwwqXEU2jYPIAAA2wAUBDDPcIAAMAdWJYESA9oeDyAAAtvPcIAAlDBVJcEVEtp6DyAAAMMxBe// +ANjgePHAQgjv9AHapMEacGoIr/SLcQpwz3Kt3u++xg8gAAjZCnDi/4Pgz3eAAFyU3PIAwc9wgAC4 +MM92gAAwB/AgQAAwpo7gAdjCIA4AE6YK2BimANgRpk4I7/+BwM9wgACwZQCQhuAB2MIgAQAbeEAg +UQAI8AjgGaYZhgC1EYYB4BGmUYYycjIBBgABwIDgBfKA4swiooDz8xCGVSfDGDJoNHkYYBR4PWNU +eFYnARcIYVV9z3Gt3u++FKYmDyAACnAKcBz/g+CQ8s9xrd7vvhIPIAAKcApwZv+D4Ibyog4gAADY +z3Gt3u+++g4gAApwEIYYYFGGFHjpcYAhQwhUeAlhA7rPcAAAC9JYeVYMIAAA2hGGFCYAEASQDg0g +ADSGEYaA4Aj0Btj+DCAANIYC2ArZEPCB4Az0bg+v/4LAAsEC2IDhFNnKIWIEBPAC2CHZEgwgAALa +IJU5pgGVGqYmCW/0iiCYDwpwz3Kt3u++dg4gAADBCnDi/oPgOPKKINgPAglv9DmGIJUKcM9zrd7v +vlIOIABZhoLBCnDiDm/0AtoCwAPCAiIBADF5iOHOBs7/EHLGBsr/aLhg8Qpwz3Kt3u++Ig4gABDZ +CnB5/4PgDvLPca3e774ODiAACnBCCCAACnCD4MogIgAdAs//8cDhxc9wgABsJ6iAUyLAAIYi/wNE +ulpiVHoDuBR4WGC4YGhxtg5v9AbasQav9ADY8cAyDq/0ANnPdoAA3BYXhs91gABclA8hAQAZhiR4 +QiAAgMogYgCB4KHBAd8J9M9xAACEJgvYZgzv9VUlwhg3hgDYDyBAADiGJHhCIACAyiBiAIHgANkb +9AvYYMABHEIwAhzCMwMcwjOLdslwBNlVJcIYfgzv9VTbEdhgwMlwBNlWJQIXagzv9SzbANgNBq/0 +ocDgePHAdg2P9FpwGnHacPpxOnJ6cwDYmnBvJUMQCHZKIMA3O3AId7pw6XCqcVoNIAAB2gAgQIMB +IYEDSg0gAAtyQiBYsMpzQyEZMPJxzCDBgAr3ACdPkwEllSMCJhagAydXIKlwyXFKDSAAAdoFIH6A +CHUodtv16XCqcelyYg0gAKpzAiISoOlwAyBQIKpx9gwgAAHaBSI+pAh1KHYQ8gUlvpMM8ipwANlK +cjINIAAKc6lySg0gAMlzmnAqcADZ6XIeDSAAqnMAJAIg7QSv9AAbgCAggADagOFF9gHaM3kgoIAh +AYB/3MAhBAOA4ke5IKAE8jN5IKDgfuB4IIAHueB/IKChwfHA4cVCwJhxSHWA4ADaRPYB2hN4QsCC +wPj/gOICwALyE3j+Da/6iHEApQjc6wSP9OB44cWf4eHGAN0Y8p7hA/aA4UP2ANgU8J/hH95K9k4h +/AfgeKgggAEPJY0TYb4RIECAA/KleALwpngAogHYwcbgf8HF4HjxwKHBANpAwoty7f8AwKHA0cDg +fgDZIKDgfyGgCHJfuECh4H8BoeB48cACDI/0SHVAgGGAwYEAgSoMIADJcQClVQSv9CGl4HjhxeHG +wIBhgKCBAYEAJY2TASDAAKCiAaLM8eB48cDGC4/0SHXBgACAKHKKDSAAyXEApR0Er/QhpWCAQIEB +gCGBUHPMIEGA4SDBB8ogIQAwcIb2BPZQc8T34H8B2Iog/w/gfuB4n+HMIO6HzCBOgAb3AnlBaaDi +BfSKIf8PBvAA2Q8hgQBhuRh54H8ocPHAUguv9NhwKHZIcYh1yXDy/wh3qXCocfD/CHEALoADBH8m +fwArQAMkeJEDr/TlePHAJguP9Eh2gOAB3UT2iiX/HxN4gOFE9rN9M3kUIQAAhgyv+jt5rHgAHkAe +ZQOv9AHY4HjxwOYKj/Q6cCh1GnKGDu/9B9hMIACgE/JMIECgEvJMIICgE/IKIcAP63IF2DXbCiRA +BFEAb/MKJQAEKdkSuQfwFdkTuQPwK9kSuRUhQQSgod4Pz/3xAo/08cCKCo/0OnAodRpyLg7v/QfY +USCAoFpwBvLqDq/+ZNhQIJAgTCAAoBLyTCBAoBryTCCAoBnyCiHAD+tyBdhg2wokQATlBy/zCiUA +BCnYErjwIEAEAKWCD+/9SnCJAo/0FdgTuPbxK9gSuPTx8cAmCo/0GnAodwHYAN3PdqAAyBwRproN +7/0H2PB/QCiBIYG5EL/lec9yoADsJyaisaY6D8/9VQKP9OB48cDqCY/0ocEacCh2AdjPdaAAyBwR +pX4N7/0H2EAokCFFIMMgz3KgAOwnZqJKgotxQLEAFAExAN8gpvGl8g7P/Q0Cr/ShwOB48cCeCY/0 +CHc6cYDiGnMA3sz3SHX0J4ATFSGBIwpyvf9hvYDlAeY499UBj/TxwHIJj/QIdzpxgOIacwDezPdI +dfQngBPwIYEjCnKc/2G9gOUB5jj3qQGP9FEkwIDxwATy6P8D8PL/0cDgfuB48cA2CY/0ocEId4Di +GnEA3s73SHX0J4ATi3HN/wDAFCCMI2G9gOUAtAHmNvew8eB48cAGCY/0CHeA4hpxAN7M90h19CeA +E/QggSOy/2G9gOUB5jn3RQGP9FEjwIDxwATy6P8D8PP/y/HxwNIIj/QIdwHYAN3PdqAAyBwRpmIM +7/0H2IC/z3GgAOwn5qGxpu4Nz/0RAY/04HjxwOHFCHGO4AHYwiANAADdz3OrAKD/uaMH2lqjuKMB +2sYPb/9Ic74O7/0B2O0Aj/SJBA/08cBuCgAAZgiv9FDZRcBKIAAghsX6/0wgAKUEFQEUT/cFwNdx +rd7vvhUgAAQgoEAgUCDz9STcmwCP9AohwA/rcgXYiiMFCJhzuQUv8wolAARTIkKB4HxOIgOIFgAM +AAEozAAAKYEAACiAAOB/hXlOIwMAACjBAOB/AnjgeFMiQoHgfE4iA4gWAAwAACnMAAEpgQABKIAA +4H+FeE4jAwABKcAA4H8ieeB4CHQA2AUqfgAvcQUqPgMAIECOASHBDgUrPgPgfydx4HgzACAASiQA +AAchxAAvJkDwSiUAABAAJgAvJAQBDiBAgQMlQQCA4w4AAwAOIkKBAyXDAAUjhYAwAQEAeXNIdAhy +KHMKJcCCSiIAEBoABADAIiEYyiUBgy8vQQHAImMQwCLDEUonAAAKJcCAwCchCBYABADKJYGALyhB +AcAnYwDAJwMADieHgsonJABAJ0cACiXAAUwnAIgA2RAAJAAA2EhxaHIA20InB4gKJEBxKAABAE4n +Coh+AAEAACmAAgEpwQEAKoUCoHEBKsIBACuFAgErwwGgckwiAJhqAAkAqCCABQAgAIABIUGAASKC +gAEjwwACIgKDAyPDggwABgAAIgKDASPDgsAgZgBCJD6ASiUAACAAAQAMAAoADiJCgQMlwwAvJACB +DAADAA4gQIEDJUEA4H4ocEhxaHIA2yAggA8BADyfqCCAAwAgAIABIUGAASKCgJFywiIGA8UgZgAg +IIAPAQBwnwDaCWoA2y8hAgAgIIAPAQCYn+B4UyJCgeB8TiIDiBYADAAAKcwAAimBAAEogADgf4V4 +TiMDAAIpwADgf0IpwQf8HIix/BxIsfwcCLHhw+HC4cHhwAfAHBzAMeHA4H8BwPHA4g1P9M91gAC4 +BwAVBRBMJUCCWvfPd4AAxE4AhcGFCLgihQV+MHYI8hC5iiBLBeYP7/PFecKlAIXwJwAQQHiA4O7z +BQZP9AohwA/rcgXYVNslAy/zSiSAAOB48cDhxaPBCHWKIIsDrg/v86lxz3CAANQHIIgBHEIzz3CA +AAac9CBAAGDBz3GgAMgfAxwCMADYAhwCMAHYE6EZgULAGIEM2UHAi3CGCi/0hNr6C0ABqQVv9KPA +4HjxwCoNb/SKIIsAz3aAALgHQIbPd4AAvAcghxi6ELlCD+/zRXkA3aCmz3aAANAHAIaMIMOPoKcH +8s9wgABYMaIPj/rPcIAA1AegqM9wgADYB6Cgz3CAAPgHoKD/2DUFb/QApuB48cDhxQh1hg4v8xDY +z3CAAPCeCYAluMC4wgxgAQhxigpv/ATYqXDH/93/Lg6P/YogCwDKDu/zqXEFBU/08cCGDG/0gdih +wWDAAN8DzAEcwjMCHAQwiiCLB6IO7/NI2c92gAC4B4ogiweSDu/zIIaKIIsHz3WAALwHgg7v8yCF +AIaA4BDyz3GAANgHAIGBuAChz3GAABwxA4EB4AOhAdgD8ALYGnAAwMoPL/QKcUwggKA68s9wgADQ +BwCAjCDDjxzyiiALADYO7/Nn2c9wgABYMaoOj/r/2c9wgADQByCgIIVAhoogiwAQuRi6Eg7v80V5 +4KbgpQCGgOAE9ACFgOAG8s4Pj/yA4BDyiiALAO4N7/Nw2c9wgADYBwCALygBAE4gwAe4/wEEb/Sh +wOB48cDPcIAAaJVBiM9xgADEmAIML/QC4s9wgADMByCQz3CAAIyVLrDRwOB+4HjPcIAAuAcAgIDg +zCBigAT0ANgF8Ijg/vMB2OB+8cBOC0/0GnDPdYAAuAcAhSh2gOBIdwb0gObiIIIDOvCKIAsAYg3v +84ohhwuKIAsAVg3v8+lxz3CAANAHAICMIMOPB/LPcIAAWDG+DY/6z3CAAPQHz3GAANgHwKAAgQV/ +4KHPcYAAHDECgQHgAqHPcYAA8AcAGQAEA/D6DM//AIWA4P31z3CAALwHAICA4Pf1IQNP9PHAz3CA +ALgHAICA4Anyz3GAABwxC4EB4AuhAth3/5fx8cDPcYAAuAeKIAsGxgzv8yCBPgwv8xDY3g8v/ATY +/9nPcIAA0AcgoIHx4HjxwG4Kb/Qc2hpwz3aAAAQxAIbPcYAAiJjPdYAAjJVAoEAlABcBpgiFI6bP +cYAA3AeNuAilz3CAAMQHCaUY2AKmz3CAAPwHAIBuC2/6IIHPcaAALCAwgThgIYYKoQKNUSBAgADb +T/RMIACgCvTPcIAAxJjPcYAA6AcAoUDwz3CAAOgHAIABiEQovihAIIUAz3CAAL+VMiBCDi8lRwHP +cIAA7AcC4k96gOIAEIQAAiSBANb2ACOAD4AAqJVEKL4oFuAyIEAOeWEAIY8PgACImAHjb3tQcwCv +AiSBAK32ACGAD4AAiJjPcYAA6AcAoS6VAiFBATB5WWEutQWmDpXVAW/0BKbPcIAAoJj48eB48cBq +CU/0pcHPdYAA1AcAjc92gAAInPQmARCCC+/ziiALA89wgACMlQWAwLgNHAIwAI30JgAQAdvPcaAA +yB9jwHOhGYEA2kHAGIEOHIIwQMAVgQ8cgjBEwxTZQsCLcFIO7/OC2nEBb/SlwOB48cD6CG/0ENqk +wYt3z3GAAOhODg9v9+lwz3WAANQHAI3PdoAACJz0JgEQBgvv84ogSwPPcIAAjJUFgMC4ARwCMACN +9CYAEM9xgAAcMWDACYEA2gIcAjAIgUmhSKHPcaAAyB8DHAIwAdgToRmBQsAYgUHAz3CAAMBlO4AH +gDhgQ8DpcBDZvg3v84Pa2QBv9KTA8cBqCE/0z3aAALwHIIaB4QvyCiHAD+tyBdjb20okAADdBe/y +uHPPdYAAuAcAhYLgzCDigcohwg/KIsIHyiOCDwAA3ADKIGIB6vXPcoAAjH8gEoIAgeIJ8s9ygACM +lUKKUSIAgDP0guAA3w/0GLgQuQV5hSEMACoK7/OKIIsAA9gApeCmRfB2CY/9z3CAANgHAIAghlEg +AIAAhRC5GLgFeQf0z3CAAIyVBICA4Aj0iLnuCe/ziiCLAAHY5PGLueIJ7/OKIIsACNjc8foNAAGA +4A3IxSCCDwEAAPwK9AUggA8AAAA8DRoYMA3IkLgNGhgwAIUghkAoAgYQuQi4RXkFeYogiwCaCe/z +gbkC2ACmxQcP9OB48cBWDy/0AdnPcIAA7QcgqM9wgAC4ByCAhOEI9M92gAC8BwCGgeAN8gohwA/r +cgXYiiNEBkokAACxBO/yuHPPdYAA5AdAhQDbDyODAM9ygADgB+CCZn/gos9ygADMnCASjwCB5w/0 +QCkCBhC4RXgIuQV5iiCLABYJ7/NFIYEBBtgh8MLnz3KAABwxaYIM8ownwpEH8owngpIG8oC7BvBF +I8MABPBFI0MBaaJAKQIGELgFegi5RXmKIIsA0gjv84G5AtgApoogSwTCCO/zIIWKIEsEz3GAAMyc +sgjv8yiB4QYP9OB48cB2Dg/0z3GAANgHAIHPdYAAuAfPdoAAvAeAuAChz3GAABwxBYEB4AWhIIUA +hhi5ELgFeYUhGABuCO/ziiCLAAbYAKUA2J0GL/QApvHAz3CAAIyVRJCA4iHyz3CAAO0HAIiA4Bv0 +z3CAANQHIIjPcIAAiJvwIEAAUSAAgA/0z3GAAMBlG4EngRlhMHIH9xoI7/OKIMsHAdgC8ADYYwLP +//HA0g0v9IDYocFgwAPMAhwEMADYARwCMM9wgAC4BwCAgODsAQIAzg5P/YDg8PTPcIAAyBwAgFEg +AIHq9IogCg/GD6/zARIBNmIIz//Pd4AAjJXpcKIO7/OKIQsPBZeGIH8MHHhTIICAB/TPcYAAzAcD +gYa4A6ECj1EgQIBY9M92gACEmfzcAiYAE24O7/MY2a6XQiUEFowkB4HL9wohwA/rcgXYp9vBAu/y +iiUHAcDcAiYAE0IO7/OIccDcQBaFkM9wgADMB0wlAIACJgETJ6AK8gohwA/rcgXYrNuJAu/yiiSD +D0EWjZBAJYUQQCWBH0wlgIgveSAYQgDL9wohwA/rcgXYstthAu/yiiSDD8DcAiYAE89xgABolTIN +7/Ooci6Xz3CAAMwHILAW8BwXBBGMJAiAyvcKIcAP63IF2LvbJQLv8oolCADPcIAAiJiqDe/ziHHP +dYAAiJ0A2SjwABYCQM9wgACImzV4QKAAFgJBz3CAAAicNHhAsAAWgEDPcoAAeJo2ehCqEaoSqgAW +gEAUqhWqFqoAFgBBz3KAABycNXoWsgAWAEEB4ReyA48Qca4Hxf96DuAB6XDKDe/yENhqCS/8BNgB +yEAdAJDPcIAAuAcggM91gAC8BwCFGLkQuAV5iLkiDq/ziiCLAAHZz3CAALgHIKAA2AClgg/v8wDA +JgoAAYDgjAoCARrwz3GAABwxBIEB4AShz3CgANQDHJAuD8/zAMBWD+/zAtkiDq//AtiKIEoP0g2v +8wDZ/QMv9KHA4HjxwIYLD/TPdYAAzAcDhc92gAC8By8oASCKIAsBpg2v8yCGI4VQIQwAp7xQJAyS +AN8G8poOr/9OIMAnHPAodIQkBpAb8gmFgeAG9IIOr/9OIMAn6aUDhYYgBgADpYogSwBiDa/zANkK +hYDgBPJAeOqldQMv9AHYAIaA4Kn0USEAgM93gADwnon0CI3PcYAAiJvwIQIAAdkCuEZ5NHjPcYAA +SJwQYQq4DKXHcAAAABgWCy/6SiFAILkXARYacM9wgAAIcDR4EYiA4GIJIAHCIUIkTCAAoMwhIqDM +ICKATvLPcIAAhJ1CEAGHz3CAALwGAJAQcR30z3KAAIyVBYLPcYAAiAoogVMgBABTIQMAkHMP9EOK +geLEIIEPAAYAAMQhgQ8ABgAAzCBBgAPyANgC8AHYKYcPpc91gAC4B0CGUSFAgSCFELoYuUV5EPKA +4A70GI+D4Az0ibluDK/ziiCLAALYAKUA2ACmhvGFIQwAVgyv84ogiwAD2PbxTCAAoAb0iiALCIoh +xQwg8M9xgADMFRiBAeAYoW7xdgyv/wHYCYcluMC4AgogAQhxqgvv8hDYwg/v+wTYsgyP/89wgABU +nD2AiiDKD/4Lj/NU8QohwA/rcgXYiiOGBUokgABJB6/yuHPxwK4JL/SKIEsBz3aAALwH0guv8yCG +z3WAAMwHA4UIdIQkhpAghhrygOGcDgL3AN9EHcITz3WAALgHAIUghhi4QCkCBAV6iLqKIIsAlguv +80V5AdgApY3wgOE89A3IBCCAD////wMNGhgwiiDLAHYLr/MA2SCGz3eAALgHAIcQuRi4BXmFIUgA +Wguv84ogiwAC2ACnAdgApkQVgBCA4Ar0z3CgACwgEIDHcAcAIKEQpXCFCiWADwEApKUB2AbZBNpq +DeAASiQAAADYRB0CEDPwgeEz9APYDgkv+gu4gOAr9AHY5g0v90QdAhAeD8AAgOANyMUggg8BAAD8 +CvQFIIAPAAAAPA0aGDANyJC4DRoYMCCGz3WAALgHAIUQuRi4BXmIucIKr/OKIIsAAdgApQDYAKYB +3x3wguEe9IK4A6XPcoAAHDEGggDfRB3CE891gAC4BwHgBqIAhRC5GLgFeYi5ggqv84ogiwAB2ACl +4KapAC/06XAKIcAP63IF2IojhwxKJIAAvQWv8rhz4HjxwB4IL/SKIIsBz3WAALwHRgqv8yCFANjP +cYAAHDHPdoAAzAcIoQmhA4aGIHmPFfLPdoAAuAcAhiCFGLgQuQV5hSEYABIKr/OKIIsABtgApgDY +AKXe8APY/g/v+Qu4gOAghQj0z3aAALgHAIYYuOjxgOHS9CiOz3CAABycQCAQC893gACMlTV4V5B2 +kIDiBBcEEQOHG/JwcsohxQ/KIsUHyiOFDwAAKALKIGUBl/eA4A3yEHLKIcYPyiLGB8ojhg8AACoC +yiBmAUn3kHNM9wohwA/rcgXYiiOIC0okQADZBK/yuHOA4A3yEHPKIcYPyiLGB8ojhg8AADACBdhv +9w+GgOAc9AuGgOAY9AHYz3KgALAfGaIegg2mz3CAAAic9CBBADYJr/OKIEsGiiBLBioJr/MthgHY +C6Zojs9xgAAInEWHz3CAAIgK9CHBAEigZoc0sGmgZZdtsFMiAABSDm/zANsIjs9xgACImhZ5Igvv +8wqHiiBLB893gAC4B9oIr/MghyYKr/QB2DYNj/8Ijs9xgACIm/AhAQBTIQGACPIB2s9zoACwH1mj +XoNEplIhAQA7eRV5NCBAICCFCrgMpgCHELkYuAV5irmOCK/ziiCLAATYAKcojgDYAKXPcIAACJz0 +IEEAcgiv84ogCwTPcaAALCAjgWIIr/OKIAsED4aA4Af0ANgyDuAACHESCE/9AdhxBs/zCiHAD+ty +BdiKIwkNSiSAAJEDr/K4c+B48cD2Dc/zz3CAAIyVA4DPdoAAzAfeDu/5LYYIdwOGz3WAALwHhiB5 +jwz0ANj+De/5jLiA4AbyD4aA4MwnYZAk9ACFgeDICgH3D4aA4MwnYZAH9M9xgAAcMQCBAeAAoSCF +z3aAALgHAIYQuRi4BXmFIRgAug9v84ogiwAG2ACmAN/gpdLwCI7Pd4AAiJvwJwAQUSAAgDfyDIai +Du/5JIaMIBCAYgAtACCFgeFkCgH3JYbPc4AAHDGA4QDYCKMQ8kaGAN8PJ48QBiHBgy8vQRAlpk4n +ghcB4Pb1RqYIowCFz3aAALgHIIYQuBi5BXmFIVQBOg9v84ogiwAF2ACmAKUA35LwIIWG4VQBDQAy +JkFwgAD4TkAngHI0eAB4z3CAAIyVAohRIECAANkE9DYJj/8ghQiO8CcAEM9ygAC4B+C4QIIA3xC5 +QCoDBmV5EPKAuAWm5qYIukV5iiCLANIOb/NFIYEBBtgApWDwz3KgALAfAdgZoh6ChSEUAASmHoIO +pq4Ob/OKIIsABdnPcIAAuAcgoOClAd9I8AWGgOAg9M93gAC4ByCHGLmRuZK5hSEUAH4Ob/OKIIsA +BdgApwDYAKXPcKAAsB8B3/mgHoAOpoogSwRaDm/zANko8OC4B/QvKAEATiCBByamogmv/waGz3CA +ALgHQIAghUAqAAYQuQV5CLpFeYogiwAmDm/zgLkB389wgAAEMeIP7/bgpYogSwQODm/zJoY5BO/z +6XDPcYAAHDEHgQHgB6HPcIAAuAcggEApAAaRuAi5BXmKIIsA3g1v80UhgQEG2FTxCiHAD+tyBdiK +I4sPSiSAACEBr/K4c+B48cCCC8/zHgrAAIDgCPLPdoAAzAcDhoYgeY8X8s92gAC4BwCGz3WAALwH +IIUYuBC5BXmFIRgAhg1v84ogiwAG2ACmAN5V8ADYcgvv+Yy4gODm8893gACMlQOHKgzv+S2GgOB9 +8g+GgOB59CyGz3AAAAEUCCEAAJkgCgAKDO/5JIZIjs9xgAAInIDgz3WAABwx9CGBADDyJg1v84og +SwaKIMsEGg1v8yyGz3GgACwgI4EKDW/ziiDLBIogywT+DG/zJIaKIMsE9gxv8y2GwgmP/y6FANgh +HgIQCI4B4S6lAeAjjw94MHBMACsACK7R8O0CIADApQCFAeAApcIMb/OKIMsFiiDLBbYMb/Mshs9x +oAAsICOBpgxv84ogywWKIMsFmgxv8ySGiiDLBZIMb/Mths93gAC4ByCHz3WAALwHAIUYuRC4BXmF +IRgAAN5uDG/ziiCLAAbYAKfL8QoMj/+A4M91gAC8ByCFLfJIjs9wgAAcnAHfVXgWkAq4DKbPcKAA +sB/5oB6AANtmphC5BKbPcIAAiJvwIIAAgLgFps92gAC4BwCGGLgFeYUhkAEODG/ziiCLAATYAKYG +2AClHQIgAADegOGf9AyGugrv+SSGgOAS8iCFz3aAALgHAIYQuRi4BXmFIVQB1gtv84ogiwAF2ACm +5fEojs9wgACImxpw8CBAAAHZBnkDl4Dga/KA4Wn0ApcKuG4K7/kuhoDg3fLPcoAAwGU3ghaCIngi +gkOCQnkZYQOXMHCqAAUAggtv84ogiwTPcaAALCAjgXILb/OKIIsEz3GAABwxAYEB4DIIr/8BoSiO +AdoB4S958CBAIAZ6EmlUeM9ygABInBBiANohHoIQQ48KuFBxKK4MpoX2igqv/wDeovDHcAAAABge +Cc/5IIXPdoAAuAdAhkApAwSA4Bi6ZXoM8oUiDACKIIsA/gpv80V5A9gApgDeiPCFIhgAiiCLAOYK +b/NFeQbY9fEghc92gAC4BwCGELkYuAV5hSFUAcoKb/OKIIsABdgApgCla/CF4W30DIZ6Ce/5JIaA +4GPyiiDLBKYKb/Mshs9xoAAsICOBlgpv84ogywRiD0//ANghHgIQCI4ghQHgCK7PcIAAuAcAgBC5 +GLgFeYUhFABqCm/ziiCLAAXZz3CAALgHIKAA2AClI48IjjBwIgfK/89xgACIm/AhAQAB2gK4JnpU +eM9xgABInBBhCrgMpsdwAAAAGCYIz/nPcYAAuAcggUCFGLmA4BC6RXkQ8oUhDAAKCm/ziiCLAAPZ +z3CAALgHIKAvBe//AN7Pd4AAuAd/Be//hSEYAAHeDQDv88lwCiHAD+tyBdiKI88JSiSAAC0Fb/K4 +c/HAkg+v84ogSwLPdoAAvAe2CW/zIIYAhoDguPQA389woAC0D/ygz3WAALgHiiALB5YJb/MghXYM +z/bPcIAAXFtAgM9xgABcW1MiAAB2CS/9NonPcIAA8J4JgCW4wLhKD6AA6XGKIMsDz3GAAFxbWglv +8zaJz3GgALAfAdgZoT6Bz3CAAMwHBgkv/SSgLgyv8gLYgg4P8z4K7/0B2M9wgAB0W2YLj/NyCm/0 +AdgDyFEggIAF8rYOz/QL8ADZnrnPcKAA/EQhoM9woAC0D/ygiiBLB/YIb/Mghc9xgACICoogCwTm +CG/zNJEghQCGQCkCBgi5ELgFeoogiwDOCG/zRXnPcIAA8J4JgCCFUSBAgeCmFvLPcIAAzAcPgIDg +EPTPcIAA8J4YiIPgCvQYuYUhHACWCG/ziiCLAAfYI/DmD8/8z3CAAIyVBIAghUCGGLmA4BC6RXkI +8s9wgADMBwOAhiA5jwnyiLliCG/ziiCLAAHYB/CLuVIIb/OKIIsACNgApeCmeQav8wDYCiHAD+ty +BdiKI9ECSiSAAI0Db/K4c+B48cDyDa/ziiCLAs92gAC8BxYIb/MghgCGgOBZ9M9zgADMB+ODz3WA +ALgH6XSEJIaQIIUQuEApAgYFein0D4OA4CL0CLlFeYogiwDeDy/zgLkB3aCmz3CgACwgcIAKJYAP +AQCkpQDYBtkE2sdzBwAgof4JoACYcIogCwWuDy/zANmpcC/wUScAkAnyTyIBApoPL/OKIIsAAdgO +8M9wgACMlQSAgOAM8k8iwQJ+Dy/ziiCLAAjYAKUA2ACmE/AIuYogiwBmDy/zRXn38YHgHfTPcIAA +zAcDgIYgeY8F9AHYfQWP8yoKz/Yghs91gAC4BwCFELkYuAV5iLkuDy/ziiCLAAHYAKXZ8YLgFfTP +coAAzAcjgs91gAC4BxC4hbkjos9ygAAcMSqCAeEqoiCFGLkFeePxCiHAD+tyBdiKIxIFSiSAAEUC +b/K4c/HArgyv84ogywLPdYAAvAfODi/zIIWKIMsCz3aAAIyVvg4v8ySGIIWA4TP0/tnPcIAAzAch +oB4Pb/oEhghxz3CAAFgxfg/P+c9xgAAcMQyBAeAMoRoOb/IQ2DIKr/sE2NoNz/zPcIAAuAcAgCCF +QCgCBhC5CLhFeQV5iiCLAGIOL/NFIcEAA9gApQHYHfCD4R30z3KAABwxDYLPdoAAuAcQuQHgDaIA +hhi4BXmIuTIOL/OKIIsAAdgApgDYAKXPcYAAzAcLoVUEj/MKIcAP63IF2IojUwFKJIAAZQFv8rhz +8cCmD0/yANjRwOB+8cDCC6/ziiD/D891oAA4LseFB6XPcKAAVC4LgAYmAHAPAP//qgvv8xbZGg3P +88el/QOP8/HAiiDKBboNL/OKIQQNQg6v8wHYA8iE4HwPAfLPcQAAXAjuDG/yBtgNyAUggA8BAAD8 +DRoYMAPIUSCAgATyJgvP9A3wANqeugDZz3CgAPxEQaDPcKAAtA88oN3/igrP+i4L7/wB2OoMb/IB +2NHA4H7xwOHF63WKIIoFRg0v8+/ZiiCKBToNL/Opcc91gAAUCACFUSBAgBb0A4VSIIAAA6UI8M9w +oACoIA2A5OD0AAUAIg1v81TYRCABAQOFMHDz9YogigX6DC/ziiEEAAPIhOAc9M9xgABcWwGBpbgB +oc9xgADwnsMRAAaluMMZGAAJgaW4CaEluMC4z3GAAJiF0g8v/wqhlgoP84ogigWyDC/ziiGEAwDa +z3CgAPxEnrpBoM9woAC0DwDZPKANyAQggA/+//8DDRoYMA3Ih7gNGhgwf9gKuM9xoADQGxOhf9gQ +oQDYlbgQoc9xAACoCrILb/IG2M9xoADwNgSBRiDAAQShlNiGDy/zGNmKIIoFQgwv8yCFAIVRIECA +DAni+sogIgCKIIoFKgwv84ohhAplAo/zCiHAD+tyBdj720okAABxBy/yCiUAAeB48cDhxaHBz3WA +ABQIRJUilYogSgUQuvILL/NFeUKFIYVQcSTyA8iE4EDBBfRPIQABQMCA4Qz0gOIK8s9wgADYBSCA +z3CfALj/PaCA/4twBNnKDi/zodohhYDhB/IChYDgA/SW/yGFIqWA4SbyANnPcKAA/ESeuSGgz3Cg +ALQPANpcoA3IBCCAD/7//wMNGhgwDciHuA0aGDB/2Aq4z3GgANAbE6F/2BChANiVuBCh1gpv8gHY +lQGv86HA4HjxwOHFABYAQM91gAAUCE4Ib/MApQCFgOAH8oHgD/KC4NwNwf8L8DoLb/NU2FEgQIAF +8gGFgbgBpcP/VQGP8+B4z3KAABQIIYIleOB/AaLgeM9ygAAUCCGCBnngfyGi4HjxwM9zoACsLxmD +8LgZgwzyBCCADwgAAADXcAgAAAAB2MB4B/CGIH8PguAB2MB4gOAX8hmDBCCADw4AAABCIACAyiBi +AIHgDfIKIcAP63JkEwQABdhp2/UFL/JKJQAAogpv81TYRCADAs9ygAAUCFEgQIABgs8gYgDQIGEA +4rgBog/yJIIwcw3yZKKiuAGilv8B2c9wgACpBroOr/wgqP0Ez//gePHAiiBKBkIKL/MA2RL/1P+M +/+UEz//geADZnLnPcKAArC89oOB+4HjxwOHFANicuM9xoACsLxyhGoFRIICCGoEN8qq4GqEagVEg +AIDw8891gAAUCAGFoLgM8Iq4GqEagVEgAIDk9c91gAAUCAGFgLgBpQDZm7nPcKAA0BsxoLj/cP8B +hUIgAIABAK/zyiBiAPHAhg9P889xAIIBAM9woACsLzygz3CAABQIAYCA4AT03v8W8Oj+ag6v+m/Y +gOAQ9CDez3WgAMgf0KUK2EMdGBAA2DYOL/ONuNGl3/6lB0/z8cA2D2/zD9nPdYAA8JwAFgBAABYA +QFUlThQApZYOL/MEbclwMghv8yKVHpXPcYAANAjaYNhgARCFAEwlAIBAoRH0AoXwuMohwQ/KIsEH +yiBhAcojgQ8AANcAbAQh8sokYQBBB0/z4HgIcs9wgABwMSWAI4Fggc9xoACwHzuB1bl5YRDhxQHv ++UJ54HjxwN3/5g0P889wgACIChiIgeAq9M9xgADwnM9ygACIMQCCYIFgoACCHNtgqARpAaICgY24 +AqHPcIAAKAgDoVUhQAQDohjYAqJVIcAFBaIBgZIMYAAEooDgBvQA2OD/egxgAAbY0cDgfvHA4cXP +daAAyB8Vhc9xnwC4/9W4FqEqCgAAFRUAlpC4Hh0YkEoMYAAA2I0GT/PgePHA4cUB2M9xoADIHxOh +GIGswUnAGYHPdYAAjH9KwAiF4LgK8lEgwIEG9MYKD/qSDy/yE9iLcalwTg4v8yTaz3CAADQIIIAC +iYDgE/QEiVEgAIAP8g3IBCCAD/7//wMNGhgwDciGuIy4j7iQuArwDcgFIIAPAQAA/A0aGDANyKy4 +DRoYMH4ID/KLcDDZygov85Daz3CfALj/Atk2oCjAgeDKIcIPyiLCB8ogYgHKI4IPAAAfAcokIgDo +AiLyyiUiAIoLQACA4Af0ANif/3ILYAAG2LUFb/OswPHANg1v8zDaz3GfALj/VqEZGhgwz3WgANQH +Gh0YkB8VAJYA3wHeARoYMAQShTBMJQCHyiHCD8oiwgfKIGIByiOCDwAAiwGEAiLyyiSCAxkVApYD +2CAdGJAUHZiTDxUDlgAWAEAAFgBAABYBQQAWAEEAFgBADx3YkPS4QOEweQTyAuEweQNpBCCADwAA +/P8Qcs/3+gpAAIDgKfLPcKAAsB8dgNW413AAAAAUQgANAA8VAJZA4B4dGJAdFQGWHh0YkK25HR1Y +kMYKQACA4ATyIgtAAA3wDcgFIIAPAQAA/A0aGDANyKy4DRoYMM9wgAAMBeCgANmRuc9woADQGzGg +z3CAANwCEHjPcaAAtEdJGRiAz3KAAHR6z3CAABAFQKBvIEMAVBkYgC4K7/UIGpgzcQRv8wDYz3CA +AIgx/QdP9uB48cDqDgABz3CAAPCeGBCEAEwkAIEI9AmAUSBAgQTysgkAABHwTCRAgAvyz3CAAOSh +DBCFAEwlwIHMJWKCBfQWDc//0cDgfgohwA/rcgXYPQEv8m7b8cDPcIAAoDEgEAUATCWAgMohxg/K +IsYHyiBmAcojhg8AAEcAEAEm8sokpgDPcIAAAE/wIEABQHjRwOB+8cBqC0/zCHXPdoAAoDGKIE8K +ig3v8iiGCIYQdUX3gOXKJQIQAvSopoogjwpuDe/yqXGlA0/z4HjPcIAAoDHgfwiA4HjxwIogTwtS +De/y2tnaDC/yBtgA2Or/0vHxwM9xoADQGxOB8LgJ8gDYkLgToYogDwwmDe/yxdmKIA8MHg3v8sjZ ++g9P9rrx4HjxwAHYz3GAAKAxA6HPcKAALCADgAShAoGB4LgPwf+q8fHAiiBPDOoM7/KA2XIML/IG +2KDx8cCqCk/z3f+B4AzyCiHAD+tyBdiS24okww8hAC/yuHPPdYAAoDEjhYHhAoUP9IHgANkF8hSN +gOAF8iYJIAAmpQzwI6UB2AalCPCA4Ab0Ad5WDu//xqXCpb0CT/PxwM9xgACgMc9wgAAIT7YKL/M4 +2mYIYAAA2NHA4H7gePHAKgpP8wAWAEDPcIAAXFsBgFEgQIEM9AohwA/rcgXYhduKJMMPmQfv8bhz +ABYAQM91gADwnAClxG3JcG4JL/MP2VUlTxTpcAYLL/MilSIJD/MIFQUQUSUAhMohwQ/KIsEHyiBh +AcojgQ8AAI0AUAfh8cokYQDPcYAAiDEAgUCFQKAAgRzaQKgChcGh46GNuAKlz3CAAEAIA6UY2AKh +VSXAFQWhAYXCDyAABKGA4Bj0z3CAAHiFJZCA4YogjwvI9p4L7/Ke2fYJAAAH8JIL7/Kj2YIJAACG +DyAADdi1AU/z8cBKCU/zz3aAAIx/CIbguKzBCvJRIMCBBvQSDs/53gov8hPYi3HJcJoJL/Mk2gHY +z3GgAMgfE6EYgQDdScAZgc93gACgMUrABocw2UvAi3BCDu/ykNqhtqimoaa8rqOnhg3v/6lwz3CA +AHiFBZCA4MT2qqetpwXwLgogAKlwZocB2c9ygABICACCgePAeYDjOGAAogHYIYLAeDhgAaIVAW/z +rMDxwKYIT/PPcIAAoDHAgADflr/+ZgILL/rJcAhxz3CAANgxnguv+f5mz3WAAHiFBZUlhQq42WHi +Ci/6DiBAAJhwz3CAAPAxeguv+Yhxygov+slwmHDPcIAACDJmC6/5iHHPcIAAoDHAoAWF/mYeZgWV +CrimCi/6DiCAAwhxz3CAACAyPguP+YkAT/PgePHAGghP8892gACgMaCGAN+Wv/1ldgov+qlwCHHP +cIAAyDISC6/5/WViCi/6qXAIcc9wgADgMv4Kj/lJAG/zoKbxwNoPD/PPcKAAsB+7gADelr4EJY0f +wP8AAN1lFOUAJY8fgAAAACYKL/qpcAhxz3CAAPgyvgqP+RIKL/rYZQhxz3CAABAzrgqP+QIKL/rp +cAhxz3CAACgzmgqP+c9wgACgMeEHL/PgoPHAbg8P889woACwH/uAAN2WvQQnjx/A/wAAv2cQ5wAn +kB+AAAAAvgkv+ulwCHHPcIAAODJWCq/5v2fPdoAAeIUFliWGCrj5YZoJL/oOIEAACHHPcIAAUDIy +Co/5hgkv+ulwCHHPcIAAaDIiCq/5v2cFhh9nBZYKuGoJL/oOIMADCHHPcIAAgDICCq/5AnVWCS/6 +CnAIcc9wgACYMu4Jj/nPcYAAoDEAGQAEBZYlhgq4uWEyCS/6DiBAAAhxz3CAALAyygmP+Q0HD/Pg +ePHApg4P86LBgODKIYEPrd6t3gfyJYAjgSCBAoACeb4I7/KKIE8Nz3aAAKAxAYaB4ADdEPSKIE8N +ogjv8oohBgShpioIL/IG2PoK7/+pcE/wKgvP/4HgAdjAeC8nB5AR8oogDw12CO/yiiHGBzILz/8B +2O4M7/8GpsoK7/+pcA3IBSCADwEAAPwNGhgwDgnP8bIK7/8A2NYP7/EG2M9wgAB4hQWQgOBGAAwA +CoYI2UHAC4ZAwItwOgvv8pTaiiCPDhoI7/KKIcYPiiCPDg4I7/Irhoogjw4GCO/yKoaA5wb0vgrP +/wHYB6arpiUGL/OiwPHAug0v84ogDwriD6/yiiFFAqoPb/wA3oDgz3WAAKAxDPSKIM8Oxg+v8ooh +xQMB2AGlyXC3/z/wDcgEIIAP/v//Aw0aGDANyIe4DRoYMA3IkLgNGhgwVgjP8XIND/YKD+/xBtgk +hc9woAAsIAOAx3EAAAAUInjXcACAAABI94ogDwpqD6/yiiGFCMOl/gnv/8KlgOC8CeH/yiBhAM9w +gAB4hQWQgODKIIkPAABAAGAKCft1BQ/z4HjxwOHFCHUFgAOAQoUggIogDwsiD6/yQnnPcIAAeIUF +kIDgxPYN/wPwL/+pcMf/SQUP8+B48cCyDA/zOnAKIECQGnMKJQAhCiRAIQojgCEeAC8A6HMKIcAP +63IF2ErbSiRAADEC7/EKJQACz3WAAEAzAIUc2SCgAYUY2SCwanGEKQsKACGSf4AA8J5cEgEgAN5q +oM93gABQCCGgCiHAhEAnAxPKIWIAMKgzGIID0ahioDEYAgIyGAIC27BasLoIL/MM4CGFDNgSqQOB +USBAgg70DInPcoAAKEHDuBx4CGLPcoAAkJ8IYgypTCMAoAX0z3CAABR/BPDPcIAANH8Dpc9yAABI +EUCwTCFAoBjaQqUF8ooiBQJAsArCgOIF9M9yAQAIzESntBICJlEiAIAQ8hraQLFCpUCQTCAAoIe6 +QLAI8s9wgADIHASAMxkCAEwlAKAP8gGBmLgBoQOBn7gDoQASASAEEgAgAB8EFSGnAqeSDy/2qXDB +Aw/z8cB6Cw/zocEIdlpxOnIac4h3Zgnv+qh1gODMJiKQCvLPcIAAmIWvoA4N7/ED2A3wQMXJcEpx +KnIA25hzuHPYdwonAASe/5EDL/OhwPHAPgsP8891gACYhS+FAN6A4cohwQ/KIsEHyiBhAcojgQ8A +AKYAyiSBA6QA4fHKJcEAAdrPcIAAjH9geUigz6W+DO/xA9hlAw/z4HjxwO4KL/PocwolQIAaAC8A +yHEKIcAP63IF2IojhAFlAO/xSiRAAATFgOXKIcEPyiLBB8ogYQHKI4EPAAAIAcokIQBAAOHxyiXB +AFEggMEQ8oogzgLODK/yiiGEA89wgACMf4DZKKAEwEB4PfDPdYAAQDPhhRDewLfCpaTfgeDDheC2 +BfSk2Iy4ALbPcIAAiAoPkI64j7gBtgCFHN6EKQsKwKDPcIAATJ8wIE4OAYWZvsGggOHKIWIAMKgA +3jMYggPRqGqgMRhCATIYQgHbsFqwlg7v8gzgAYUI2TKoEg4v9qlwdQIP8+B4z3CAAIx/KIDPcJ8A +uP8A2jagCNnscCCgA9nPcKAAFAQloAHI7HEAoc9woADUC02g4H7geM9xgABkCOB/AKHgeM9wgABk +COB/AIDgeHkAz/J1AM/y4H7geOB/ANjgfwHY4H8A2OB/AdjgfuB44H7geOB+4HjgfuB44H7geOB+ +4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB/AdjPcIAAAKfgfs9wgADwpuB/D4Dg +eOB+4HjgfuB44H8A2OB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjxwOHFz3WAAGgzqXCaCO/y +A9kAFYUQRCVAAYXgyiHBD8oiwQfKIGEByiOBDwAATwCIBqHxyiRhAAGNg+DD9mO4Aa0qCM/yWQEP +8+B48cDWCA/zGnHPdoAAaDMgjlEhAIBI8s9xgABoCCCJgOHMICGgQPKB4Ab0z3CAAPSLoYAD8ADd +juUD94DlAvQA3c9xgAD0ixiJgOAE9IDlBPQA3wTwooEE34ogEwGyCq/yqXGKIFMBqgqv8ulxz3CA +AIgKGIiD4MwgIoHMIOKBzCAigswgYoII8oogEwGCCq/yjNkK8AqWEHUI9AuWEHfMICGgBPQA2CHw +AdjPcaAAyB8Noc9wgABoCAGI67aqtgS/ELjlfQV9iiATAUYKr/Kj2YogEwE6Cq/yqXHPcKAAyB9/ +GFiDAdhVAA/z4HjxwO4Pz/LE/4DgPfIg3c92oADIH7CmMthDHhgQANjGDq/yjbixprCmHthDHhgQ +ANiyDq/yjbixpn8WD5aKIBMBQS8NFMS93gmv8s3ZiiATAdIJr/LpcYogEwHKCa/yqXHPcYAAaAgB +iQHaEHXCIooAgOVAqcf2ANgNpoHiA/QE2AGp1QfP8uB4z3CAAGgzAIhRIICAB/LPcaAAwB0AgYC4 +AKHgfs9wgABoMwCIUSCAgAfyz3GgAMAdAIGguACh4H7xwOHFocHPcIAAvAgAkM91gABsqKlxiiIE +CtoN7/IB24DgD/QKIcAP63IF2M9zAACPC0okAACNBK/xCiUAAQCNhODKIcsPyiLLB8ogawHKI4sP +AACTC8okKwBoBKvxyiXLAM9wgAC+CACQz3GAALyqDtpU4BB4fg3v8gHbgODKIcEPyiLBB8ojgQ8A +AJwLBdjR84txiiDIDgHaWg3v8gHbgODKIcEPyiLBB8ojgQ8AAKcLBdi/8wAUADHPcYAAiAhIuASp +4Qbv8qHA4HgOeCx4KWoA2A8gQAAncFp44H8OIMAA4HjxwEoOz/LPcIAAsGUAkIbgAtjKIOIBeXDP +cIAAbAgQiATwQCdAAA94+HDPcIAAbAgRiPBwkAALAGlwgOAA2fP2RCk+B5hwL3AZcYQvAwEncM9x +gABsqAAhBQAfFcUAGWEeEcYAOXAA3gAhjR+AAGyo1X3njahxBdrpcAUVwxDb/0AogRA0eYQvAQUn +cdR5x3GAANiqWXEAqelwyHEH2gYVwxDS/wHmz36G5sAH6/8BGgIQQiRAAIDgQCBBEIQH7f8vebHx +7QXP8oDgGPJKJIBwANioIMAEz3OAAImoRCg+BzIjQw5wcVAADACA4yHygeAi8gHgD3gb8Iwhwo04 +ACoAAdhKJIBx4HioIEAEz3OAAE2pRCg+BzIjQw5wccz2gOMH8obgCPIB4A944H8A2GG44H8PeOB+ +4HjxwAoNz/IacIDhSHeOACwAAN06cRUgQCOA50CIAogM8s92gACEMxV+ArgUeMdwgADAOgvwz3aA +ALwzFX4CuBR4x3CAAGg7IYhRIQCAIfIFEMEAIq4GEMAAA67pcEhxzf+A4ACuE/JEKD4HACGAf4AA +bKhhiD2IcHEJ8gIiwAAQeAe4Fg7v+GJ5AvAA2AGuQiFBIIDhfgft/wHl0QTP8uB48cByDM/yz3aA +ALBlAJaG4M91gABsCAf0AdgPrQDYEK0O8ASWguDMIGKABfQB2A+t9/ED2A+tANgQrQLYEa2KIAcI +AN9iDm/y6XE//89wgACkqhmIgOAG8gHYIR0CEATwIR3CE4ogBwg+Dm/yAdlv/4ogBwgyDm/yAtnP +cYAAxFkggc9wgABgPgHatv+KIAcIFg5v8gPZAJaG4Avyz3GAAMhZIIHPcIAAtD4A2q3/iiAHCPYN +b/IE2SEEz/KB4PHAuHEY9EwlAIDE9kwlgIPL9gohwA/rcgXYiiMQBSkBr/GYc0AtgABkuMdwgACE +Mxvwz3CAAGA9MiBBAYwhw4/KIcEPyiLBB8ogYQHKI4EPAAAZBPQAofHKJMEAz3CAALwzNXjRwOB+ +4HgCeS15THlWIQFyR7k4YOB/D3jgePHAMgvP8gh2KHVIdxpzT3kQuQ94CLgFeYogRwhODW/ypXmA +58wgIqAI8ixtL3nPcIAAbAgyqAfwz3CAAGwIsqipcc9ygABsCLOq1Kr1qhYaAgTJcMv/ABCHAOGI +z3CAAGwI0IgRiBB2mgEJAOhwRCg+By9whC4DEQokQA4AIE0Oz3GAAHCoPWVAL4IAVHqELgEVACJB +DgAhiA+AANiqACaDH4AAiAhMJwCACiVADib0GhXAEEokgHEIqxsVwBAA2QyrGI0Qq6ggQAYUIEAQ +QYhzbnR7NXvHc4AAvKsAEMAAWKsVJUIQGasBEsAAAeEaqwCKL3kbq37wARXBEIDhGPQA2kirTKtQ +q0okgHEA2aggwAMTbhR4NXjHcIAAvKtYqFmoWqhbqAHhL3lk8Hy4ACQEAGy6ACJAAQAghQ+AANiq +ACSAD4AAcKgaiDqN6XKo/wirACSAD4AAcKgbiDuN6XKj/wyrz3KAAHCoACSAABiIOI0AJIYA6XKd +/xCrANtKIYARFCXLABQgxBABE4AQARSBAOlylv8zbjR5dXkAIYoPgAC8qxgaAhAAE4AQABSBAOly +j/8ZGgIQFSbLABUlxBABE4AQARSBAOlyif8aGgIQABOAEAAUgQDpcoX/GxoCEEIhSRBMIQCQAeOa +B+3/b3sB5s9wgABsCBGIz34QdnAGzP8A2c9wgABsCI0B7/IgqPHAJgnv8ooghwjPdYAAbAhKC2/y +Mo0UjTKNVv8VFYQQTCQAgAwVwRAG8gMQwAAwcEf2BvACEMAAMHBD9ghxz3KAAFxbE412ihBzLXkK +9BSNVIpQcAb0DRXAEAkgQAANeRGNUI0QcqAACQASFYcQFBWGECEVhRAA20okgHPgeKgggA/PcIAA +iAjPdoAAoDRvZny4AiHOA81+SCZOEM1+TCUAgMwmIoAR8kwkAIAN9IzjS/bPd4AApKoUJ88R94/7 +fwknjhPNflhgLBCPAM9wgACQNGhgRCq+AwJ/CSeOEwAjQA7Pd4AAEKyCJxATH2eWJ8IQwK8B4297 +AeIRjU96EHJyB8z/iQDP8qDgANpAoYr2wODKICkBwiAsCMIo7AAAoeB+4HjhxeHGABHNAIDlRPYA +3aCpgOAo8s9wgACwZQCQhuAS9NTlhPdT3aCpz3CAAAA2FCBOA6COoKoAEcEANHgBiCHw1OWE91Pd +oKnPcIAAWDUUIE4DoI6gqgARwQA0eAGIEfDU5YT3U92gqc9wgACwNBQgTgOgjqCqABHBADR4AYgA +q8HG4H/BxeB4ocHxwHYPj/KhwWXCCHUods9wgAC+BoXBi3JAJEMwAIjW/0QtvhYAJkAeFBTBMM9y +gAAEqJjmWGBqACoAOKhTJoAQheBGAAoARibAEQ9+wriF4G4ACgAgwwEUhDAAJY8fgAAUfRJuFHgf +Z0QtvhYAJkAeWGA4qAHmz35TJoAQheAAHwIRZK+s9hvwARSAMMd1gAAUfQK+1H6+ZgCuIMAErg/w +QiYAFg94ARSBMMd1gAAsfgK4FHgdZSDAKK0MrQjcIwev8qHA4HjxwKoOr/JIcKHBCiEAIQogQCEA +3gAdgAOGIPwDRLhk34QoAQkvdYAlDxrDulpiVXpdZUQrvgwCJU0ee3gNeItxlf8AwBV4FXgCfalw +6g+v+Olx7HgCJUIeieDKIGoCyiEKAEn2gODKIIsDyiGLA4P2IWjPc4AAcFmYI8oCFSMAADAgjw8A +AFAKNXswI4APAABQCuJ4THgvcJ4Pr/hk2bhgjCFCoPhgYAAqAMogqgDPcYAARE8WIUEEoIHhgXoP +r/gK2SjgSCAAAIwgQ4LKIIoPAADIAM9ygAA8UxZ6JYIEgqlyDg4v/ulzKLkA2oDizCGBjwAA/wEK +cMT3wKAE2ATwIKBIcAUGr/KhwOB48cCeDY/yosEIdTpxGnJod4h2z3CAAKg2gcEGDm/yBNoGFIIw +CiUABypwCnHpc5h2sf9TJYAQheBW9kYlwBEPe8K4heBY9gDCEmsUeAAggQ+AABx9AeNve1MjgACF +4EChtPYK8ADBAr20fQAlgB+AABx9IKCJBa/yosDgePHADg2P8qHBOnDPcIAAbKgCEBQBiiAHCUYP +L/Iqcc9wgABkNDIgVgTPcIAAbAjQiBGIEHaqASkASiMAIAogwCQKIsAkAvB6dUQuvhMAJkAuz3GA +ABCsG2EME8MAACEVAM9wgADcFhqAe3tRIACCbXsM8kwhAKZK9otxaHAk/wDAAiMBgALyLXvPcIAA +iAh8uNhgKBDBAM9ygACUBgCKBdqK/UwkAKAIdxbyz3CAAJwGAICMIB+E0PbXcAAAoA9M9gIgAAVE +KH4DL3DmDa/4iiEPCgJ/SiSAcQDdqCCABTNuNHm1ec9wgAC8qzpgWYqA4jhgC/LxchDy8XIT9oXl +V/YB5a99CvBCJZIQLyKHJGG9r30R8BsQ0AAA2Gp1DPCA5UoiACDKJWEQBfJCJVIQLyKHJAHYgOAu +8nNudHsVI0ADz3KAALyrGWIAIgQAFSODBFhjemJZijmJUHEbiNj2GxSDAAS4LyAIIEJ5BLsweQIg +wCBCfwx/Og2v+C8gRg4OeAIgASBAIQACDnhEuC8gBSBMIQCmhfZAINAiLyAFJMlwKnEKcgP/TCEA +plL2ACaBH4AAFH1AKYAgFHgE4TIhBAAqcADZKHIMFcMgb/8B5s9wgABsCBGIz34Qdm4GzP99A6/y +ocDxwEILj/LPcKAAtA9wEBAAiiDHCM9xgACUBmINL/IggYogxwjPcYAAnAZSDS/yIIHPcIAAlAYA +gIDgAN0G9CjZz3CAAJQGIKDPcIAAnAYAgIDgCfTPcQAA5AzPcIAAnAYgoM9woAC0D7ygz3aAAGwI +UY5wjlBzEfbPcIAABKh/2RQjzwAfZyyvra8B4297UHMF2S6v9fYA3w7dz3CAAIA06GBf/2G9gOUB +5+9/N/cwjs9wgAAQrIIgEANEKb4DJ3AzIIAPAAAYBJTgRgALAA6OgOAf8s9ygABcWxOOdooQcxf0 +FI50ihBzE/QVjgHbgOASisB7EHMN9FGOUHEJ9gCODyBAAAHhL3lQcQCu+fbPcIAAlAYAgM9xoAC0 +Dwamz3CAAJwGAIAHpnAZAAR5Ao/y8cDhxc91gACUBoogxwk+DC/yIIUAhc9xgABsCEaBbWhQc8Ag +bAHMIgyADfbPcIAAnAYAgEIggQwwcoX2MuAQcsL2pP9JAo/y8cDCCa/yAdmhwc93gACoNs9woADI +HCAQEgDPcKAAyBwpoJIIb/IU2It2BG/Jcc4Jb/IB2gDBz3CnALBLNKDPcQAAAdMA3Q3wBG+1eMlx +rglv8gHaAMEB5VAYQCAqcUAhUQAvIUgkjCXDn89wowCw/xUgUACq9wRvyXGCCW/yAdoAwf/dKnBQ +GEAgANkacDpxBG81eMlxZglv8gHaAMEp2BK4FSAABCCgQCBAIGG9gOUQeEAhQSAs9/oPL/IU2M9x +oADIHCAZgARVAa/yocDgePHA4cXPcIAAbAgOgIHgMPTPdYAAqDYA2KlxiiIIAKYPb/IIc4DgDvQK +IcAP63IF2IojzAJKJAAAWQYv8QolAAEghYDhzCGCj/////8E8gGN2uAO9IDhyiHBD8oiwQfKI4EP +AAAUA8ogYQHm8wkBj/LPcoAABKgVeiCCgOEp8ve5BvIFIYEPAP8AACCiz3CAALBlAJCG4Ey5E/TP +cIAAbKgAiIbgifbPcIAAiAgEiIAgAgAieAjw8NwOIQADBPAocIAgww+A4IX2jCDDj8P2iiAHDeB/ +DnjgePHAKgiP8s92gABsCCiOA44RIQCAAN0L9IoghwmKIf8POgoP8qauAdgw8BQgAQDHcYAABKhO +iYDiyiCBDwAA5gHKIYEP/v7+/uzzYbpOqdP/jCAHjcoggQ8AAOYByiGBD7q7rdve82OOz3GAAIgI +fLnPcoAAlAZ5YQ17JBHBAACKB9pR/AWuqXANAI/y8cCaD2/yANhKJIABz3KAAGwIz3WAALyrw4oK +JABxZYqoIIAE8270fxV/+WU4iYDhv2cL8nBxDfJwcY/2heAT8gHgD3gH8CpoKaphuA3wGo8LqgDY +C/CA4AX0ANgJqgHYA/ApaCmqCqoB2JkHT/LgePHALg9P8s92gABsCGOOA7sKjnR7FSMBAM9wgAC8 +qz1gSY64jVV7emBYihtjUHU4YBqIVvYCIkEDuosEuDB5EHgEvWWOonhiegx6Zgiv+C8gRg4OeLhg +COAOeES4PQdv8guu4HjxwMYOT/LPcoAAbAgiis9wgABkNGOKKWDPcIAAEKxEK74DgiAQAydxOGAz +IIAPAAAYBBt4q4oNeAIlARAB4Tx5LyFFgBQjwADHcIAABKge8gwQzwDxf+9/gecxfs9+x/Zhvwkn +jhPPfgLwAd6A4cT2zXkE8NN5LXksqK2oB4oPIMAAB6oA2AXwANtuqAHYoQZv8iaq8cAuDm/yFdju +Dy/xSiAAIM92gABsCA6OgOCZ8iGOheH4AA0AMyZBcIAAvFlAJwByNHgAeBCOBh4CFAQeAhQDrnP/ +Atkhrk7wlP+A4ATyA9gBrkXwBNgBrkHwrP/88cT/Bdkhrj7wJI7PcIAAgDQtYAOORCi+BgAlQR4A +IYIPgAAEqDiKBhbCEDpiTXqpcYv9mOU+ACoABI4jjs9ygAAQrIIiEANEKb4DJ3AaYgAhgA+AABR9 +Mm00eQTgMiBEADMigw8AABgEqXAKcQpy8P0EjgHgD3iO4ASuQ/YA2ALwAdiA4DLyA44ojgDaAd8P +IgIARnkorgDdAeBRjg94UHCkrjoALAADroDhFPQgjgeOp64leACuoa4b8AohwA/rcgXYiiOcAAok +AASdAi/xCiUABLIOL/EV2KGuCfCqDi/xFdjhrgXwng4v8RXYSQVP8uB48cAAFoBAz3GAAGwIDKkA +FoRAABaAQFAkvoENqQAWgEDKIcIPyiLCB8ogYgHKI4IPAAA/CkACIvHKJcIAUSSAgQDYyiBhAA6p +z3CAALwGAJCA4ATy2vxS/s4LD/I3AY//8cDhxc91gABsCAKtCI1AjSV4CK0OjSZ6gOBArQvyPg4v +8RXYgOAH9ADYAa0GDi/xFdjJBE/y4Hjhxc9xgABsCFGJcIlQcwr3oIkRJcCQAdkG9AHjUHP79wDY +BPBgoChw4H/BxYHg8cC4cRj0TCUAgMT2TCWAg8r2CiHAD+tyBdiT25UBL/GYc0AtgAAUeGy4x3CA +AMA6HPDPcIAAYD0yIEABjCDDj8ohwQ/KIsEHyiBhAcojgQ8AAJkAXAEh8cokwQACuBR4x3CAAGg7 +0cDgfvHAsgtP8s92gAC+BgCOz3eAALwGII/g/0GIz3WAAKgI47oglwbyAdgArYogxwNI8AKAgOAF +8gDYAK2QuT7wUSIAgTHyz3KAAFxbFooQcSv0AJZ0inBwJ/TPcIAAwAYAiFKKEHIf9M9wgACICgmA +USBAgRnyQYWA4gDbDvLPcKAALCAQgEJ413AxAQAtRPcB2kCtBPBgrQDaELqKIEcDRXkO8AGNgOAH +8gHYAK2KIAcDBvAA2ACtkbmKIAcEKg3P8VkDb/IAjeB4gODxwA70sv/PcaAALCAwgcdxSWsA0iKg +Bg3v8YoghwWK8eB4gODxwNhxCvSo/wDZIqCKIMcF6gzv8chxfPHgePHA4cXPdYAAqAiKIEcG0gzv +8SmNBNhuC6/7AdkIjSmN6P8BA0/y4HjxwM9xgACoCIogxwaqDO/xKYnPcIAAqDoeDY/4WPHgeOHF +UyANAKCpBCCBDwAGAABCIQGABCCAD0AAAADKIWIAIKrXcEAAAAAB2MB4AKvgf8HF4HjxwDIKb/LY +cQomgJCIdcwjIoAG8kImBgEvJocByHF9/4Dmz3GAAKgIA6Eh8iSIArk0eUOIA+FRIgCAYogM9Aoh +wA/rcgXYiiNIA5hzdQfv8AolgAEIYVEgQIAK9AohwA/rcgXYiiNIBPHxYYjgu8ohwQ/KIsEHyiOB +DwAAHwLKIGEB5fPhvdEjIoHKIcIPyiLCB8ojgg8AACYCyiBiAdf1USUAkA7yUSPAgMohwQ/KIsEH +yiOBDwAALQLKIGEBx/PdAU/y8cBiCU/yocEIdih3GnIA3c9woAC0D3AQEQCKIMcAggvv8clxz3Cg +ALQPvKCLcUAkQjBAJIMw6XC0/0wgAKAF9EokAAAJ8M9wgADgigGIgOD49UokgAAgwAEUgjDJcQIU +gzC3/89wgACoCCmIgOHMJkKQBfIjgKqooqHlvxbyz3GAAFxbVolQdhD0VIlTJwMQUHMM9AQnjx8A +BgAAgOcB2jKJwHowcgXyoqihoKCoiiDHAO4K7/HJcc9xoAC0D3AZQAQBAW/yocDxwKYIb/KKIAcG +z3aAAKgIxgrv8SSGFd0EhjJoAeA0ecdxgABoOwSmAoGA4BHyz3OgACwgcINieNdwSWsA0gDax/dC +oYogxwWOCu/xIIkEhqrghPcA2ASmYb2A5bwHzf+xAE/y8cDPcYAAlAaKIIcBZgrv8SCB4//PcIAA +vAYAkIDgcAzC/2kEz//gePHAEghv8thxocEacItxQCRCMEAkgzDIcGf/ARSAMIDgCfICFIAwgOAF +8kIgECEvIAckIMAKcfH+ARSBMIDhBPKiiAPwoYiKIMcBAgrv8chxQCgAJkAtAhQFegEUgDACFIEw +CLgFeoogxwHiCe/xRXnhvdEl4pAF8lElAJEM8gohwA/rcgXYiiMNAZhzHQXv8AolAAThBy/yocDg +ePHA4cU9/89wgACIChiIhODPdYAA4IoL9IogDwqSCe/xiiEKAgKNIYXP/wKNIYUB2nj/wQcP8uB4 +6LgI8gQgvo8AAAAYAdgD9ADY4H8AqeB48cAiDw/yocEacADez3CgALQPcBARAM9woAC0D9ygiiBH +AT4J7/EKcYQoCCgAIY1/gAAAhiHwQCUAFxYghAMFFIAAhiD+hxjyBIWLcUAkgzBAJE8w6XId/6gV +ABDpceP/IMAEFIEAARSCMAIUgzBKJMAAI/8B5gyVEHa+B8X/iiBHAd4I7/EKcc9xoAC0D3AZQATz +Bc//4HiEKAsKACGBf4AA8J4oEYAAKIEZBe//ANrxwI//YgyP/70Cz//PcYAAXFvPcIAAvAYAkFaJ +EHIV9M9wgAC+BgCQVIkQcg30z3CAAMAGAIgyiRBxB/TPcYAAqAgBiQKp4H7xwC4OD/IacM9xgABc +W892gAC8BgCWVokQcs91gACoCBH0z3CAAL4GAJBUiRByC/TPcIAAwAYAiDKJEHED9AKNAvAA2AGt +j/7PcIAAwAZAiM9xgAC+BgCJII6A4gHawHoKcwDfmHfo/gOFAYhRIACBIJYH8gHYA62KIEcDBPDj +rYoghwPiD4/xCQYP8vHAog0P8qHBCHUA3s9woAC0D3AQEADPcKAAtA/coOONiiAHAbYPr/HpcQSV +i3FAJIMwgOAB2MB4LycAAAWFQCRCMMH+CoVAJEEwh/+A54AlEx/Y91YlABjwIIADViUBHNR5IInA +uAUgwAEvJAcAIMABFIIwAhSDMMD+Aebxdqz3iiAHAVYPr/Hpcc9xoAC0D3AZAASRBc//8cAKDQ/y +z3CAAIgKKBCQAKiAiiAHAi4Pr/EKcVMlABAKcTT+AYhRIACByiHCD8oiwgfKIGIByiOCDwAAWgPK +JMIAYALi8MolAgQlBQ/y4HjPcKAALCAwgM9wgACoCOB/IaDgePHA4cXPdYAAqAgAjYDgEfQ6/oDg +DfSKIEcEAN3CDq/xqXGQ2ZC5AsigGEAAFPADjYDgEfLPcKAAAAQsiIwhAoAA3Qn0mg6v8YoghwSR +2ZC56/EB3c0EL/KpcOB48cBODA/yz3aAACiFFI6B4BH0BNgSDW/7AdnPcIAAvgYAiM9xgAC8BiCJ +T/4A2BSuLvD2joDnLPLPdYAAqAgKjWG4EHcX8mL+z3CAAKg6z3GAAHiFJYFBbwUpvgAKD2/4L3GK +IIcGz3GAALwGFg6v8SCRz3CAAL4GAJDqrQitz3CAALwGAJAJrQDYFq41joDhCPLPcIAAvgYAiDz+ +ANgVrhUEL/IB2OB48cCSCw/yocE6cBpygOFodrYALAAA2HpxWnAVIQAgz3GAALwIABCUAKKI44gh +kQGIAdo4YBB4i3EyCi/ySHOA4BLyABQCMUwgAKASbQQihA8AAAD/QizDARR4EfLHcIAAwDoQ8Aoh +wA/rcgXYs9tKJAAAyQDv8AolAAHHcIAAaDuA5gAYAgUE8kKoA/BBqFEiAIAU8oDmDfIjiIC5I6gy +bzR5OmBDihlhgbpDqeSogOYD8maoAvBlqEIjQSCA4VoH7f9AIkAgIQMv8qHA8cDPcIAAYD4O2QHa +ANvK/89wgACYPgfZAdpIc8b/z3CAALBlAJCG4A/yz3CAALQ+KtkA2gDbwP/PcIAAXD8L2QDaAdu8 +/9HA4H7gePHA4cXPdYAAvAhm2CJtAdpCCS/ySHOA4MohwQ/KIsEHyiOBDwAA/QAF2CPyZ9ipcQHa +Igkv8khzgODKIcEPyiLBB8ojgQ8AAAEBBdgR8gGVJG0B2gHgEHj6CC/ySHOA4A30CiHAD+tyBdiK +I0QBSiQAALEHr/AKJQABAZUmbQHaAuAQeM4IL/JIc4DgyiHBD8oiwQfKI4EPAAAJAcogYQHn88X/ +eg0P/2oNj/xZAg/yAgAAAADAAAAAAAAAAAAAAAAAAAACAAAAAAAAACgLgAC8C4AAgFqAABAAgAC4 +BIAABAjAEAoAE2RQBYCBAADAFgQBE2IPXAAiCgAAQAAGAHAcAABhAAATJAAAEyUAAMAXyCDAEHBF +wBAQCMAQ//9cMwAAEyQAABMlBAjAEQ8UFSIEABUm+/8wMgACWDADABMkGAjAERwIwBEPFBUiAQAV +JgQAMDAAAkVwAgAAYQEAEyQsEMARAAATJBBFwBEYCMARAARYMA98EyIIAMwRAAATJQAAEyQ0SMcR +D3sTIgEAEzAEKMARDxQVIgQAFSbGIBMkQAATJQQowBEPehMiGCjAEQ9NEyIEEMURAgATJPAcwBEB +ABMk7BzAEQAAEyRwABMlEBzAEQAAEyUAABMk4BzAEQEAEyQkEMARAAAAIQAAEyUAABMkD0UAIgBc +ADkDAABiAmAAYgAAWDhWAABhJBDAEQCAEyQ4HMARD3MTIoIBEzAEKMARD3QTIgICEzAEKMARD3UT +IkICEzAEKMARDxQVIgEAFSYPcBMiAQATMAQowBEPchMiCADMEQ9EACIKAABAAEAAcA4AAGEAABMl +AgATJOwcwBEPdhMiGAjKEQkAE0AcCMoRCQATQCAIyhEPeBMiBADKEQAAASQAAAElBgAAYQ92EyIs +SMcRD3gTIgAAxhEDAAEkAAABJQ8UFSICABUmD0UAIgBcADkiAABkAAATJAEAEyU4HMARD3cTIuAc +wBEPARMiBAjAEQ8UFSIBABUmDwMTIv/wEzIYKMARAAMTOP/zEzIYKMARAAMTOBgowBEDABMkAAAT +JQQIwBEAABMkOEXAEQ8DEyL/PxMy8P8TMw8TAiJgM4CBAADAFgACEzgYKMARxyATJEAAEyUEKMAR +BAAAYQAAWDgAABMkAQATJTgcwBFYM4CBAADAFggAE2IAABMlAwATJFQExRF/AhMkBADFEVwzgIEA +AMAWCADFEQAAACE4WoCBAADAFjwEwBEMBYCBAADAFgQBG2IQBMAQAwAbJFQEwBEkBMARCATAEPhZ +gIEAAMAXCATAENhZgIEAAMAXAAAbJQMcG2JAABskMBzAEQUAAGEQBYCBAADAFg8bGSIIBKCBOPDE +gAAAGyQCABslOBzAEQAAACEMBYCBAADAFkwEwBEQBYCBAADAFg8bGSJIBKCBOPDEgAAAGyQCABsl +OBzAEQAAACEAAACFDAWAgQAAwBYPGwQiEAQbZg8BG2gUHMAQCgAbQAQAG24DAABhDxwdIgEAHSb5 +DwBhZAwAEADABhEBAAQn/AAEZAAAGyQCABslOBzAEQAAACEAABslQAAbJDAcwBEAAAAhDxwdIhgB +HSYYAMcQ+HSAgQAAwBcgAMcQAHWAgQAAwBcAAAAhmB2AgQIAXG4RAABh+EHEEA8bCSIACwk5AgAK +YgMBCmIEAgpiAAAJQAQAAGEJAAlAAgAAYQoACUAAAABhAgAJQQAJGigAAMAWAQAbJgAAwBcEAB0m +AQAIJ+kACGQAAAAhAAAAACwBAAABAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAAAAAAwACQANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCAgAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAgPAAAHzwAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCKgAAgTQEAAAAAAAAAAAAAAAAAAAAAAAAAAACU +ioAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAD/AQAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAIAAAAGAAgACQAAAAcAAAAA +AAAAAAAAAAAAAAACAAAAAgAAAIMAAACSAAAA6AAAAPcAAABOAQAAXQEAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAA//8AAMycgAC4pgEAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACM +f4AAAMABAAAAAAAAAAAAAAAAAAAAAACMf4AAxMQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAjH+AAAAA +AAAAAAAAAAcAAAAAAAAAAAAAAAAAAH9/AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAECBAgACBAgAQAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUBwAA +FQAAACAbgADoCQAA6AkAAOgJAADoCQAA6AkAAOgJAADoCQAA6AkAAOgJAADoCQAA6AkAAOgJAADo +CQAA6AkAAOgJAADoCQAA6AkAAOgJAADoCQAA6AkAAOgJAADoCQAA6AkAAOgJAADoCQAA6AkAAOgJ +AADoCQAA6AkAAOgJAADoCQAA4AoAAAAAAAC0EAEA6AkAACwIAADoCQAA6AkAAOgJAABcCAAAvPcA +AJBAAADoCQAA6AkAAHwIAAB8CAAAfAgAAHwIAAB8CAAAfAgAAHwIAADoCQAA6AkAAOgJAADoCQAA +tAkAAOgJAADoCQAA6AkAAOgJAADoCQAA5AoAAOgJAADoCQAAEAgAAAMAAADUygEAAgAAAMgdAQAE +AAAAxC4AABAAAAAsoAEABgAAAGzCAQAHAAAAXMwBAAsAAAD8NgEADAAAAJQ7AQANAAAAzDsBABYA +AABsEAEACgAAAMhQAQATAAAA+EEAAA4AAAAUUQAADwAAAGAHAQABAAAAjL4BABEAAAAcZgEAEgAA +AIBWAQAFAAAA4FMAABQAAABsbAAAFQAAANzfAQAXAAAA4AoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAgAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAMwkAADMJAAAzCQAALwvAADMJAAAzCQAALAvAADMJAAAzCQAAMwkAADM +JAAAzCQAAMwkAADMJAAAzCQAAMwkAABAGQAA6BoAAPgaAABsHAAA9BwAAHAcAADMJAAAzCQAAKQ4 +AADkPAAAwD0AAMwkAADMJAAAzCQAALg2AAAAmgAA/JkAADiaAADMJAAAzCQAAMwkAADALwAAzCQA +AMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAA +zCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADM +JAAAzCQAAMwkAADMJAAAzCQAALAwAADMJAAAzCQAAMwkAADMJAAAzCQAAJgxAADMJAAAzCQAAMwk +AADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAOQuAADMJAAABC8AAMwkAADMJAAAzCQA +AMwkAADMJAAAzCQAAMwkAADMJAAA+FQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAA +zCQAAMwkAADMJAAAiE8BABxTAQDMJAAArDcBAMwkAABcOQEASCgBAMwkAADMJAAAjD4AAMwkAADM +JAAAzCQAAMwkAADMJAAAPKgBAIShAQDMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAVMwBAFjM +AQDMJAAAzCQAAMwkAADMJAAAzCQAAMwkAAAYwgEAzCQAAMwkAADMJAAALOEBAMwkAAD4HwAA/B8A +AMwkAADMJAAA6MwBAPxBAADMJAAAzCQAAMwkAAD4vAEAzCQAAMwkAABMCAEAbFYBAMwkAADMJAAA +zCQAAHheAQBgIwEAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAA4HEBAMwkAABwzAEAdMwBAIDMAQCE +zAEAeMwBAHzMAQCIzAEAjMwBAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAACOQAAMwk +AADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAAC0MwAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQA +AMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAA +zCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADMJAAAzCQAAMwkAADM +JAAAzCQAAFQ0AADUNAAAXDUAALw1AAC0TwAAlDUAAMwkAADMJAAAzCQAAMwkAADMJAAATDQAAFA0 +AADMJAAAzCQAALw+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4QMOHuHhAw4e4cECCh7hgQUMHuEAAAAA +AAAAAAAA4QMOHuHhAw4e4cECBh7hgQUMHuHBAgYe4YEFDB7hwQIGHuGBBQwe4cECBh7hgQUMHuEA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//////////wAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEB +AQEBAQEBAQENDQ0NDQ0NDQ0NDQ0NDQ0NAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAAAAAAAAAAAAAAB +AQEBAQEBAQEBAQEBAQEBDQ0NDQ0NDQ0NDQ0NDQ0NDQMDAwMDAwMDAwMDAwMDAwMAAAAAAAAAAAAA +AAAAAAAAAQEBAQEBAQEBAQEBAQEBAQ0NDQ0NDQ0NDQ0NDQ0NDQ0DAwMDAwMDAwMDAwMDAwMDAAAA +AAAAAAAAAAAAAAAAAJECAAAxyi8AkQIAADHKLwCRAgAAMcovAJECAAAxyi8AkQIAADHKLwCRAgAA +McovAJECAAAxyi8AkQIAADHKLwBDAQAAMcovAEMBAAAxyi8AQwEAADHKLwBDAQAAMcovAEMBAAAx +yi8AQwEAADHKLwBDAQAAMcovAEMBAAAxyi8AQA0AAN4DCQAAAAAAAAAAAAAAAAAs4wAAAQAAAOAa +gAAAAAAAAAAAAAAAAAC84wAAFQAAACAbgAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgICAgICAgAGAAoCA +gICA4BqAAOAagACkIKAAOCCgAAEAAAD8////AAAAAAAAAAAAG4AAABuAAKggoAA8IKAACAAAAPP/ +//8AAAAAAAAAACAbgAAgG4AArCCgAGwgoAAwAAAAz////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA +AAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAABgCAEABQAAACAbgACIDQEAAP8DAKgNAQAA/wUA +lA4BAAD/LQC4DgEAAP89AHAOAQAA/wQAVA4BAAD/JQDcDgEAAP/dALgVAQCoFgEAIBcBAFgSAQCQ +EQEAIBgBAKgYAQDsGAEAPBkBAAAAAAAsAQAAXgEAAAEAAAABAAAAAQAAAAEAAAADAAAAAAAAAAAA +AAAAAAAAAwAAAAIAAAADAAAAAwAAAAMAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAwHwEACgAA +AOAagAAAAAAAAAAAAAAAAAC8HwEACgAAAOAagAAAAAAAAAAAAAAAAADwHwEACgAAAOAagAAAAAAA +AAAAAAAAAABoIAEACgAAAOAagAAAAAAAAAAAAAAAAACIIQEACgAAAOAagAAAAAAAAAAAAAAAAAAA +IQEACgAAAOAagAAAAAAAAAAAAAAAAACEJwEABgAAAOAagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAQAAAAAIAAAAAAoAAQJwAA6AMAAOgDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAoD4BALA/AQB0QgEAKEUBAKRHAQAoSwEATEEBACAFgABUf4AAGAAAABR/gAAAAAAA +AAAAAAAAAAAAAAAAAAAAALBNAQAGAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAA +AAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5 +AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqA +AAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAA +AAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAK +AAAA4BqAAAAAAAAAAAAAAAAAAMz5AAAKAAAA4BqAAAAAAAAAAAAAAAAAAGhUAQAKAAAA4BqAAP// +//8AAAAA/////wAAAAAAAAAAAAAAAPxVAQAFAAAAIBuAAGQAZABpANwAyABaAKoAvgCGAX0APgBk +AGQAaQDcAMgAWgCqAL4AhgF9AD4AAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIBAQAC +AQABAgICAAEBAAIBAgECAAIAAQID//8AABgBAgCzAAIAhQAQAIYADgCHAAoAiAALAIkADwCKAAAA +iwAHAIwADwCFABEAhgAMAIcACgCIAAsAiQAPAIoAAACLAAcAjAAPAIUAEgCGAAgAhwAKAIgACwCJ +AA8AigAAAIsABwCMAA8AhQATAIYAAACHAAoAiAALAIkADwCKAAAAiwAHAIwADwCFAAAApgA3AKcA +AQALATcADAEBAJwB/wDVAf8A1gH/AKgAIgANASIApwGDAKgBWQC4AQYAwQEBAAIAWABLAEwATAAH +AGQABwApAxgAbACUAHYAAAAkAxAAJAMfALMBAgC1AQsADAMBABEDAQAVAwEAIAMBACUDAQAqAwEA +LwMBAPv/AAD9/wAAuQHPALgBBgD8/wAAuQHfAP//AAByAAMAdAADAG4AAwBwAAMA1wADANkAAwDT +AAMA1QADAD0BAwA/AQMAOQEDADsBAwDUAQYA0AFQAH4AaQDjAGkASQFpAJQAAACVAAAAlAABAJUA +AQCUAAIAlQADAJQAAwCVAAcA+gAAAPkAAAD6AAEA+QABAPoAAgD5AAMA+gADAPkABwBfAQAAYQEA +AF8BAQBhAQEAXwECAGEBAwBfAQMAYQEHAHgAGwDdABsAQwEbAIUAAACGAAAAhwAGAIUAAQCGAAEA +hwAGAIUAAgCGAAMAhwAGAIUAAwCGAAcAhwAGAOsAAADqAAAA7AAGAOsAAQDqAAEA7AAGAOsAAgDq +AAMA7AAGAOsAAwDqAAcA7AAGAFEBAABQAQAAUgEGAFEBAQBQAQEAUgEGAFEBAgBQAQMAUgEGAFEB +AwBQAQcAUgEGAH8AeQDkAHkASgF5AKkAEACqADMAqwABAA4BEAAPATMAEAEBAHQBEAB1ATMAdgEB +AP3/AAB5AC0A3gAtAEQBLQD8/wAAeQBqAN4AagBEAWoA//8AAKYAPwCnAAEACwE/AAwBAQBxAT8A +cgEBAAQACAD9/wAAqAAAAKwAAgANAQAAEQECAP//AACcAf8AnQH/AJ4B/wCfAf8A1QH/ANYB/wDX +Af8AdgD/ANsA/wBBAf8AMACAAPv/AAAAAAAASHEBAHh8AQAQjIAAQAUAAAAAAABIcQEAdHIBAFCR +gAAgAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/IABAAB/AQBwkoAAVAAAAAAAAABIcQEAMH8B +APCSgABQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAASHEBAHx7AQBcKIAAUAEAAAAAAAAQgQEA +mH0BAOQGgAACAAAAAAAAAEhxAQDUfQEA6AaAAAQAAAAAAAAA6IABAHRyAQDEkoAALAAAAAAAAABI +cQEAUH4BAAAAAAAAAAAAAAAAAEhxAQAQfgEA7AaAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAABAAIAAgADAAQABAAFAAYABgAHACAAIAAhACIAIgAjACQAJAAlACYAJgBDAEQARABF +AEYARgBHAEgASABJAEoASgBLAEwATABNAE4ATgBPAFAAUABRAG4AbgBvAHAAcABxAHIAcgBzAHQA +dAB1AHYAdgB3AHgAeAB4AHgAeAB4AHgAeAB4AA8APwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAABAAEAAgADAAMABAAFAAUABgAHAAcACAAJAAkACgAjACMAJAAlACUAJgAnACcAKAApACkA +RgBHAEcASABJAEkAZgBnAGcAaABpAGkAagBrAGsAbABtAG0AbgBvAG8AcABxAHEAcgBzAHMAdAB1 +AHUAdgB3AHcAeAB4AHgAeAB4AHgAeAB4AA4APwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAABAAIAAgADAAQABAAFAAYABgAHACAAIAAhACIAIgAjACQAJAAlACYAJgBDAEQARABFAEYARgBH +AEgASABJAEoASgBLAEwATABNAE4ATgBPAFAAUABRAG4AbgBvAHAAcABxAHIAcgBzAHQAdAB1AHYA +dgB3AHgAeAB4AHgAeAB4AHgAeAB4AA8AQwAAAAAAAAAAAAAAAAAAAAAAAAABAAEAAgADAAMABAAF +AAUABgAHAAcACAAJAAkACgAjACMAJAAlACUAJgAnACcAKAApACkARgBHAEcASABJAEkAZgBnAGcA +aABpAGkAagBrAGsAbABtAG0AbgBvAG8AcABxAHEAcgBzAHMAdAB1AHUAdgB3AHcAeAB4AHgAeAB4 +AHgAeAB4AHgAeAB4AHgAeAB4AAgAQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAIA +AgADAAQABAAFAAYABgAHACAAIAAhACIAIgAjACQAJAAlACYAJgBDAEQARABFAEYARgBHAEgASABJ +AEoASgBLAEwATABNAE4ATgBPAFAAUABRAG4AbgBvAHAAcABxAHIAcgBzAHQAdAB1AHYAdgB3AHgA +eAB4AHgAeAB4AHgAeAB4AA8AQwAAAAAAAAAAAAAAAQABAAIAAwADAAQABQAFAAYABwAHAAgACQAJ +AAoAIwAjACQAJQAlACYAJwAnACgAKQApAEYARwBHAEgASQBJAGYAZwBnAGgAaQBpAGoAawBrAGwA +bQBtAG4AbwBvAHAAcQBxAHIAcwBzAHQAdQB1AHYAdwB3AHgAeAB4AHgAeAB4AHgAeAB4AHgAeAB4 +AHgAeAB4AHgAeAB4AAQAPwB4XAEAEtIAAAAAAAD//w8APHoBALYAAAAAAAAA/wAAADx6AQC3AAAA +AAAAAP8AAAA8egEAuAAAAAAAAAD/AAAAPHoBALkAAAAAAAAA/wAAADx6AQC6AAAAAAAAAP8AAAA8 +egEAuwAAAAAAAAD/AAAAPHoBAL0AAAAAAAAA/wAAADx6AQC+AAAAAAAAAP8AAAA8egEAvwAAAAAA +AAD/AAAAPHoBAMAAAAAAAAAA/wAAADx6AQDBAAAAAAAAAP8AAAA8egEAwgAAAAAAAAD/AAAAeFwB +ABPSAAAAAAAA//8PADx6AQAbAQAAAAAAAP8AAAA8egEAHAEAAAAAAAD/AAAAPHoBAB0BAAAAAAAA +/wAAADx6AQAeAQAAAAAAAP8AAAA8egEAHwEAAAAAAAD/AAAAPHoBACABAAAAAAAA/wAAADx6AQAi +AQAAAAAAAP8AAAA8egEAIwEAAAAAAAD/AAAAPHoBACQBAAAAAAAA/wAAADx6AQAlAQAAAAAAAP8A +AAA8egEAJgEAAAAAAAD/AAAAPHoBACcBAAAAAAAA/wAAAHhcAQAU0gAAAAAAAP//DwA8egEAggEA +AAAAAAD/AAAAPHoBAIMBAAAAAAAA/wAAADx6AQCEAQAAAAAAAP8AAAA8egEAhQEAAAAAAAD/AAAA +PHoBAIYBAAAAAAAA/wAAADx6AQCHAQAAAAAAAP8AAAA8egEAiQEAAAAAAAD/AAAAPHoBAIoBAAAA +AAAA/wAAADx6AQCLAQAAAAAAAP8AAAA8egEAjAEAAAAAAAD/AAAAPHoBAI0BAAAAAAAA/wAAADx6 +AQCOAQAAAAAAAP8AAAB4XAEACNIAAAAAAAD//wMAuFwBAACCAAAAAAAA/wEAALhcAQABggAAAAAA +AP8BAAB4XAEACdIAAAAAAAD//wMAuFwBAAKCAAAAAAAA/wEAALhcAQADggAAAAAAAP8BAAB4XAEA +CtIAAAAAAAD//wMAuFwBAASCAAAAAAAA/wEAALhcAQAFggAAAAAAAP8BAAB4XAEABtIAAAAAAAD/ +AQAAeFwBAAfSAAAAAAAA/wMAAHhcAQAG0gAACQAAAAD+AwB4XAEAB9IAAAoAAAAA/A8AeFwBAAbS +AAASAAAAAAD8B3hcAQAH0gAAFAAAAAAA8D94XAEAFdIAAAAAAAD/AwAAeFwBAAzSAAAAAAAA/wEA +AHhcAQAV0gAACgAAAAD8DwB4XAEADNIAAAkAAAAA/gMAeFwBABXSAAAUAAAAAADwP3hcAQAM0gAA +EgAAAAAA/AcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc0g3SEdIQ0gLS +AdID0hvSC9IAgAXSEtIT0hTSBEMG0gfSBNIJEHDStQAaAYEBBQAEAAYACAAJAAoACwAMAIMAkgDo +APcATgFdAQ8ALgAAAGwAAAB0AAAAgAAAAIwAAACdAAAABwAAAAQAAAAIAAAAEAAAAEAAAACAAAAA +IAAAAAAAAAAJAAAAEgAAAAAAAAAKAAAAFAAAACAFgABUf4AAGAAAABR/gAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAHCjAQAGAAAA4BqAAAAAAAAAAAAAAAAAANC/AQAGAAAA4BqAACAFgABUf4AAGAAA +ABR/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMgBAAQAAADgGoAAAAAAAAAAAAAAAAAAaMcBAAQAAADg +GoAAAAAAAAAAAAAAAAAAEMkBAAYAAADgGoAAAAAAAAAAAAAAAAAAaMcBAAQAAADgGoAAAAAAAAAA +AAAAAAAAWMgBAAQAAADgGoAAAAAAAAAAAAAAAAAAaMcBAAQAAADgGoAAAAAAAAAAAAAAAAAAWMgB +AAQAAADgGoAAAAAAAAAAAAAAAAAAaMcBAAQAAADgGoAAAAAAAAAAAAAAAAAAEMkBAAYAAADgGoAA +AAAAAAAAAAAAAAAAaMcBAAQAAADgGoAAAAAAAAAAAAAAAAAAWMgBAAQAAADgGoAAAAAAAAAAAAAA +AAAAEMkBAAYAAADgGoAAAAAAAAAAAAAAAAAAWMgBAAQAAADgGoAAAAAAAAAAAAAAAAAAWMgBAAQA +AADgGoAAAAAAAAAAAAAAAAAAEMkBAAYAAADgGoAAIAWAAFR/gAAYAAAAFH+AAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAUBQAAAAAAAAAAAAAAAAAAAAAA/wD/AAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIDBAQEBAQFBgcICAgI +CAkKCwwNAAAABQYHCA0ODxAVFhcYGQAACg0RFAoNERQKDREUCgoAAAAAAAAGBgYGCQkJCQAGAABu +O2g7YjtcO246aDpiOlw6bjloOWI5XDluOGg4YjhcOG43aDdiN1w3biloKWIpXCluKGgoYihcKG4n +aCdiJ1wnbhloGWIZXBluGGgYYhhcGG4XaBdiF1wXbgloCWIJXAluCGgIYghcCG4HaAdiB1wHbgZo +BmIGXAZuBWgFYgVcBW4EaARiBFwEbgNoA2IDXANuAmgCYgJcAm4BaAFiAVwBbgBoAGIAXABuO2g7 +YjtcO246aDpiOlw6bjloOWI5XDluOGg4YjhcOG43aDdiN1w3biloKWIpXCluKGgoYihcKG4naCdi +J1wnbhloGWIZXBluGGgYYhhcGG4XaBdiF1wXbgloCWIJXAluCGgIYghcCG4HaAdiB1wHbgZoBmIG +XAZuBWgFYgVcBW4EaARiBFwEbgNoA2IDXANuAmgCYgJcAm4BaAFiAVwBbgBoAGIAXABuO2g7Yjtc +O246aDpiOlw6bjloOWI5XDluOGg4YjhcOG43aDdiN1w3bjZoNmI2XDZuNWg1YjVcNW40aDRiNFw0 +bjNoM2IzXDNuMmgyYjJcMm4xaDFiMVwxbjBoMG4iaCJiIlwibiFoIWIhbhNoE2ITXBNuEmgSYhJc +Em4RaBFiEVwRbgNoA2IDXANuAmgCYgJcAm4BaAFiAVwBbgBoAGIAXABcAFwAXAAAG0EAAEAAQABA +AEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAA +QABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQABA +AEAAQABAAEAAQABAAEAAQAFBAEABQAFBAEABQAFAAUEBQQFBAUEBQQFBAUEBQQFBAUEBQQFBAUEB +QQFBAUEBQQFBAUEBQQFBAUIBQQBCAEIAQgBCAEIAQgBCAEIAQgBCAEIAQgBCAEIAQwBDAEIAQgBC +AEIAQwBDAEMAQwBDAEMARABDAEQAQwBEAEQARABEAUQBRAFEAUQBRQFEAUUBRQFEAUUBRQFEAUUB +RQFFAUUBRQFFAUUBRQFFAUUBRgFGAUYBRgFHAUYBRwFHAkcBRwJHAkcCSAJHAkgCSAJIAkgCSAJI +AkgCSAJJAkgCSQJJAkkCSQJJAkkCSgJKAkoCSgJKAkoCSwJKAksCSwJLAksCTAJMAkwCTAJNAk0C +TQJNAk4CTgJOAk4CTwJOAk8CTwJPAk8CUAJQAlACUANRAlECUgNRA1ICUgNSA1ICUwJTAlQCUwJV +AlQCVQJVAlYCVgJWAlYCVwJXAlgCVwFZAlgBWgFZAVoBWgFbAVsAWwBbAFwAXABdAFz/XQBd/17/ +Xv9e/17/X/9f/2D/YP5g/2D+Yf5h/mL+Yf1j/mP9ZP1k/Gb9Zfto+2f6afpo+Wr5avhr+Wr4a/hr +92z4bPZt9231bfZt9W31bfVt9W31bPVt9Wv1bPVr9Wv1avVq9Wn1avVp9Wn1aPVo9Wf1aPVn9Wf1 +ZvVm9WX1ZvZl9mX2ZPZk9mT2ZPZj9mP2YvZj9mL2YvZh9mH2YfZh9mD2YPZf9mD2X/Zf9l72X/Ze +9l72XfZe9l32XfZc9l33XPZc91v3W/db91v3Wvda91r3WvdZ91n3WfdZ91j3WPdY91j3V/dY91f3 +V/dW91f3VvdW91X3VvdV91X3VfdV91T3VPdU91T3U/dT91P3U/dS91P4UvdS+FL4UvhR+FH4UfhR ++FD4UfhQ+FD4UPhQ+E/4T/hP+E/4TvhP+E74TvhO+E74TfhO+E34TfhN+E34TPhM+Ez4TPhM+Ez4 +S/hL+Ev4S/hL+Ev4SvhK+Er4SvhK+Er4SfhJ+En4SfhJ+En5SPlI+Uj5SPlI+Uj5R/lH+Uf5R/lH ++Uf5RvlG+Ub5RvlG+Ub5RflG+UX5RflF+UX5RflF+UT5RPlE+UT5RPlE+UP5RPlD+UP5Q/lD+UP5 +Q/lC+UL5QvlC+UL5QvlC+UL5QflB+UH5QflB+UH5QPlB+UD5QPlA+UD5QPlAAAAAAAAAAAAAAAAA +ZOMBAAgAAAAgG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +/////////wAB//8CA////wT//////////////////////wX/Bv8H/wj/Cf8K/wv/DP///w3///8O +////D////xD//////////////////////////////////////////////xH///8S////E////xT/ +//8V////Fv///xf///8Y////Gf///xr///8b/////xz///8d////Hv///x////8g////If////// +////////////////IiMk/yUmJ///KP///yn///////////////////////////////////////// +/////////////////////////////////////wEEAAACBQEAAwYCAAQHAwAFCAQABgkFAAcKBgAI +CwcACQwIAAoNCQALDgoADA8LAA0QDAAOEQ0AAUEABAJCAQQDQwIEBEQDBAVFBAQGRgUEB0cGBLcT +IgC4FCMAuRUkALsWJQC8FyYAvRgnAMAZKADEGikABxsAAAgcAQALHQIADB4DABAfBAAiIQUAJCIG +ACYjBwAoJAgAKiUJACwmCgAuJwsAMCgMADQpDQA4Kg4APCsPAEAsEABkLhEAaC8SAGwwEwBwMRQA +dDIVAHgzFgB8NBcAgDUYAIQ2GQCINxoAjDgbAJE6HACVOx0AmTweAJ09HwChPiAApT8hACRJBgIs +SgoCNEsNATxMDwFkTREBbE4TAXRPFQF8UBcBhFEZAZVSHQGdUx8BAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQVBxUVFQsVFRUV +FRUVDwAAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAP +AD8AAgAAAA8APwABAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAEAAAAAgAAAAUAAAAAAAAAHycBpQA8 +ODQwLCgkIBwYFBAMCAQADAgEADw4NDAsKCQgHBgUEAwIBAIAFQ8bAAAAIQAAAAIAAAIAAAAAAQEA +AQIBAQEBAQEBAQEBAQICAgICAgICAwMDAwMDAwMEBAQEBAQEBAECAgICAgIDAwMDAwMDAwMDAwMD +AwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAABAQIBAgIDf/8HDx8/AQMBAw8HAQcPHz9///8F +AAcCAwQGBnTRRRfooosuDQ8FBwkLAQMKFDduVVVVAUtoLwFVVVUF4ziOA6qqqgJxHMcBqqqqCsdx +HAcoACgAMAAsACwAKAA8ADQAKAAoADQAMAAsACwARAA8AEAAPACMAGwAWABIAPQAsAAsACwAPAA0 +ADAALABUAEQAVABUAGwAYABcAFQAjAB4ADoBAgHVAN8A2gCiAHUAfwBqARoB2QDoAAoBugB5AIgA +igUqAzkBqAGKBcoC2QBIAcoBSgHiAPkAygHqAIIAmQBm5gAAndiJnU7sxE40SIM0J3ZiJxqkQRoT +O7ETERiBEQ/8wA9O7MROJ3ZiJxqkQRoTO7ETDdIgDYmd2AkIjMAIB37gBzRIgzQapEEaERiBEQ3S +IA0IjMAIBmmQBrCy1QUFVEAFJ3ZiJxM7sRMN0iANiZ3YCQZpkAbETuwEBEZgBAM/8AOqqqqqGqRB +GhM7sRMP/MAPERiBEQ3SIA0KqIAKEzuxEw/8wA8P/MAPDdIgDQu0QAsLtEALiZ3YCQ3SIA0KqIAK +CqiACgiMwAgHeIAHB3iABwZpkAYP/MAPDdIgDQu0QAsN0iANC7RAC4md2AkIjMAIiZ3YCQiMwAgH +fuAHB37gB8EsKQcKqIAKCIzACAd4gAcIjMAIB3iABwZpkAawstUFBmmQBrCy1QUFVEAFBVRABdYd +xgQNABoAJwA0AE4AaAB1AIIAGgA0AE4AaACcANAA6gAEAScATgB1AJwA6gA4AV8BhgE0AGgAnADQ +ADgBoAHUAQgCDABOAGgAggB1AJwAwwBoAIIAggCcALYAtgDQAJwAwwDDAOoAEQERATgBggCcALYA +nAC2ANAA6gDQAOoABAEEAR4BwwDqABEB6gARATgBXwE4AV8BhgGGAa0BAAAwAAAANgAAAAwAAAAS +AAAAGAAAACQAAAAGAAAACQAAAAAAAAAAAAAAGCAUFA4OFBQFBgECAwQAAAABAQIBAgIDBAwMCAQM +BARAAAAAgAAAAAABAAAAAgAAQAAAAAAEAABAAAAAQAAAABAREhMUFRYXGBkaGxwdHh8gISIjJCUm +JygpKissLS4vQEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5v +cHFyc3R1dnd4eXp7fH1+fy0ADyAA8GEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApcaE+JnujfYN/73Wsd5U +kVBgAwKpzn1WGediteZNmuxFj50fQImH+hXv67LJjgv77EFns/1f6kW/I/dTluRbm8J1HOGuPWpM +WmxBfgL1T4NcaPRRNNEI+ZPic6tTYj8qDAhSlWVGXp0oMKE3Dwq1LwkONiSbGz3fJs1pTs1/n+ob +Ep4ddFguNC02stzutPtb9qRNdmG3zn17Uj7dcV6XE/WmaLkAACzBYEAf48h57ba+1EaN2WdLct6U +1JjosEqFa7sqxeVPFu3FhteaVWaUEc+KEOkGBIH+8KBEeLol40vzov5dwICKBa0/vCFIcATx32PB +d3WvY0IwIBrlDv1tv0yBFBg1Ji/D4b6iNcyIOS5Xk/JVgvxHeqzI57orMpXmoMCYGdGef6NmRH5U +qzuDC8qMKcfTazwoeafivB0Wdq0721ZkTnQeFNuSCgxsSOS4XZ9uve9DpsSoOaQxN9OL8jLVQ4tZ +brfajAFksdKc4Em02PqsB/Mlz6/KjvTpRxgQ1W+I8G9KclwkOPFXx3NRlyPLfKGc6CE+3ZbcYYYN +hQ+Q4EJ8xHGqzNiQBQYB9xIco8Jfavmu0GmRF1iZJzq5JzjZE+uzKzMiu9JwqYkHpzO2LSI8khUg +yUmH/6p4UHqljwP4WYAJFxraZTHXxoS40MOCsCl3WhEey3v8qNZtOiwAAQIEBAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADE2OjM4OjIz +AAAAAAECAQIDBAAABQYHCAkKAAAABQYAAgQABQAFAAAABQcBAwQABQEFAABAI0AlISEhIUBAQEBA +BQQEAQFAQEBABQVAQAwMQA0MDAEBAQVAQAUFAAQABEBAAARAQEAFQEBAQEAFQEBABQUFAQEBAUAF +BQUBBQEBQAUFBUAFQAUFBQUFBAAAABwRAAAcMgAAHDMAAAQAAAAcFQAAAgAXAGwAcAR0CHQMAAQE +BgAAAAAAAAAAZAAAAACQAQAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAF +AAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAABAAAAEAAAAAAAAAABAAAAAQAAAAAA +AAD/AAAA/wAAAAAAAAAAAAAARMkBAAAAAAAABAAAZAAAAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH +BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgIC +AgIBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAEUgEADFIBABRSAQBsUgEAdFIBAHxSAQAACiVDx058mAAHFShZLwAAAAQOCR0tNwAABA4J +HSw7AAEQAAEAAAACgAABQgYCEAACIAAAA8AAAUMGAxAAAsAAAAPAAAFDBgQQAAJAAAACgAABRAYF +EQAAQAAAA8AAAUUGBhEAAOAAAAPAAAFFBgcRAAEAAAACgAABRgYIEQACIAAAA8AAAUcGCREAAsAA +AAPAAAFHBgoRAAJAAAACgAABSAYLEgAAQAAAA8AAAUkGDBIAAOAAAAPAAAFJBg0SAAEAAAACgAAB +SgYOEgACAAAAAoAAAUwGAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAA +BwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAAwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAAwAAAAcAAAAH +AAAABwAAAAcAAAAHAAAAIhYAAIAAAAMAAAFZACQWAAEAAAADAAABWgAmFgACAAAABAAAAVoAKBYA +AgAAAAMAAAFbACoWAAKAAAADAAABXAAsFwAAAAAABAAAAVwALhcAAIAAAAMAAAFdADAXAAEAAAAD +AAABXgA0FwACAAAAAwAAAV8ANhcAAoAAAAMAAAFgADgYAAAAAAAEAAABYAA8GAABAAAAAwAAAWIA +PhgAAgAAAAQAAAFiAEAYAAIAAAADAAABYwBkGwACAAAAAwAAAW8BZhsAAoAAAAMAAAFwAWgcAAAA +AAAEAAABcAFsHAABAAAAAwAAAXIBbhwAAgAAAAQAAAFyAXAcAAIAAAADAAABcwJ0HQAAAAAABAAA +AXQCdh0AAIAAAAMAAAF1AngdAAEAAAADAAABdgJ8HQACAAAAAwAAAXcDfh0AAoAAAAMAAAF4A4Ae +AAAAAAAEAAABeAOEHgABAAAAAwAAAXoDhh4AAgAAAAQAAAF6BIgeAAIAAAADAAABewSMHwAAAAAA +BAAAAXwEkR8AAUAAAAMAAAF+BJUfAAMAAAAEAAABfwWXHwACwAAAAwAAAYAFmSAAAEAAAAMAAAGB +BZ0gAAFAAAADAAABggWfIAABwAAAAwAAAYMFoSAAAwAAAAQAAAGDBaUhAABAAAADAAABhQUAAAAA +AAAAAAAARLoBAICqAQBgrAEA7K0BABiwAQCIsgEAfLYBABy4AQBkuQEAAAAAAAAAAAAAAAAAAAAA +AAA8iJ+fnz4AVMMBAGjDAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAErxApkEAAAApXiBTAIAAABuUFaIAQAAAFK8QCYB +AAAAD/1m6wAAAAA3KCvEAAAAAOb9JKgAAAAAKV4gkwAAAAAlcMeCAAAAAId+s3UAAAAAe0QAawAA +AAAblBViAAAAAJASiloAAAAA834SVAAAAACwqXdOAAAAABUvkEkAAAAAjGg8RQAAAAASuGNBAAAA +AGKu8j0AAAAARL/ZOgAAAACiVAw4AAAAAD4igDUAAAAAUaYsMwAAAAAOygoxAAAAAAOZFC8AAAAA +SAlFLQAAAAAM0JcrAAAAAHk/CSoAAAAAoSuWKAAAAADY1DsnAAAAADzW9yUAAAAAihfIJAAAAAB+ +waojAAAAAEY0niIAAAAAlP+gIQAAAAAJ3LEgAAAAAKilzx8AAAAAMVf5HgAAAAAwBi4eAAAAAKLf +bB0AAAAAGyW1HAAAAABRKgYcAAAAAAJTXxsAAAAAHxHAGgAAAAA74ycaAAAAAClTlhkAAAAAy/QK +GQAAAAAHZYUYAAAAANhIBRgAAAAAgUyKFwAAAADZIhQXAAAAAKSEohYAAAAABjA1FgAAAAAG6MsV +AAAAABl0ZhUAAAAAvZ8EFQAAAAAhOqYUAAAAANEVSxQAAAAAbgjzEwAAAABs6p0TAAAAANeWSxMA +AAAAHuv7EgAAAADhxq4SAAAAAMULZBIAAAAAUJ0bEgAAAAC/YNURAAAAAOo8kREAAAAAIxpPEQAA +AAAb4g4RAAAAAMp/0BAAAAAAWN+TEAAAAAAF7lgQAAAAABqaHxAAAAAA1NLnDwAAAABWiLEPAAAA +AJmrfA8AAAAAWy5JDwAAAAAYAxcPAAAAAPoc5g4AAAAA0W+2DgAAAAAE8IcOAAAAAI2SWg4AAAAA +7kwuDgAAAAAoFQMOAAAAALbh2A0AAAAAgamvDQAAAADgY4cNAAAAAI8IYA0AAAAAqI85DQAAAACd +8RMNAAAAADkn7wwAAAAAlCnLDAAAAAAU8qcMAAAAAGZ6hQwAAAAAerxjDAAAAACDskIMAAAAAPFW +IgwAAAAAbKQCDAAAAADVleMLAAAAAEEmxQsAAAAA91CnCwAAAABtEYoLAAAAAEZjbQsAAAAAUkJR +CwAAAACHqjULAAAAAAOYGgsAAAAACgcACwAAAAAD9OUKAAAAAHZbzAoAAAAADDqzCgAAAACNjJoK +AAAAAN5PggoAAAAAAYFqCgAAAAAQHVMKAAAAAEMhPAoAAAAA6IolCgAAAABlVw8KAAAAADeE+QkA +AAAA7w7kCQAAAAA29c4JAAAAAMU0ugkAAAAAbMulCQAAAAAJt5EJAAAAAI/1fQkAAAAAAYVqCQAA +AABwY1cJAAAAAAGPRAkAAAAA4wUyCQAAAAC5WxkAAAAAAGoRGQAAAAAA9McYAAAAAABWfxgAAAAA +AIw3GAAAAAAAlfAXAAAAAABuqhcAAAAAABRlFwAAAAAAhSAXAAAAAADA3BYAAAAAAMGZFgAAAAAA +hlcWAAAAAAAOFhYAAAAAAFXVFQAAAAAAWpUVAAAAAAAbVhUAAAAAAJQXFQAAAAAAxdkUAAAAAACs +nBQAAAAAAEVgFAAAAAAAjyQUAAAAAACI6RMAAAAAAC6vEwAAAAAAf3UTAAAAAAB6PBMAAAAAABsE +EwAAAAAAYcwSAAAAAABLlRIAAAAAANZeEgAAAAAAASkSAAAAAADK8xEAAAAAAC6/EQAAAAAALYsR +AAAAAADEVxEAAAAAAPEkEQAAAAAAtPIQAAAAAAAKwRAAAAAAAPGPEAAAAAAAaF8QAAAAAABuLxAA +AAAAAAAAEAAAAAAAHdEPAAAAAADDog8AAAAAAPJ0DwAAAAAApkcPAAAAAADgGg8AAAAAAJzuDgAA +AAAA2sIOAAAAAACZlw4AAAAAANZsDgAAAAAAkEIOAAAAAADHGA4AAAAAAHjvDQAAAAAAocYNAAAA +AABDng0AAAAAAFt2DQAAAAAA6E4NAAAAAADoJw0AAAAAAFsBDQAAAAAAPtsMAAAAAACStQwAAAAA +AFOQDAAAAAAAgmsMAAAAAAAdRwwAAAAAACIjDAAAAAAAkf8LAAAAAABo3AsAAAAAAKa5CwAAAAAA +SpcLAAAAAABTdQsAAAAAAL9TCwAAAAAAjjILAAAAAAC9EQsAAAAAAE3xCgAAAAAAPNEKAAAAAACJ +sQoAAAAAADOSCgAAAAAAOXMKAAAAAACaVAoAAAAAAFQ2CgAAAAAAZxgKAAAAAADR+gkAAAAAAJPd +CQAAAAAAqsAJAAAAAAAWpAkAAAAAANWHCQAAAAAA52sJAAAAAABLUAkAAAAAAAE1CQAAAAAABhoJ +AAAAAABa/wgAAAAAAPzkCAAAAAAA68oIAAAAAAAnsQgAAAAAAK+XCAAAAAAAgX4IAAAAAACdZQgA +AAAAAAFNCAAAAAAArjQIAAAAAACiHAgAAAAAAN0ECAAAAAAAXe0HAAAAAAAi1gcAAAAAACy/BwAA +AAAAeKgHAAAAAAAHkgcAAAAAANh7BwAAAAAA6mUHAAAAAAA8UAcAAAAAAM06BwAAAAAAniUHAAAA +AACsEAcAAAAAAPj7BgAAAAAAgecGAAAAAABF0wYAAAAAAEW/BgAAAAAAf6sGAAAAAAD0lwYAAAAA +AKGEBgAAAAAAh3EGAAAAAACmXgYAAAAAAPtLBgAAAAAAhzkGAAAAAABKJwYAAAAAAEEVBgAAAAAA +bgMGAAAAAADP8QUAAAAAAGPgBQAAAAAAK88FAAAAAAAlvgUAAAAAAFGtBQAAAAAArpwFAAAAAAA8 +jAUAAAAAAPp7BQAAAAAA6GsFAAAAAAAFXAUAAAAAAFBMBQAAAAAAyjwFAAAAAABxLQUAAAAAAEQe +BQAAAAAARQ8FAAAAAABxAAUAAAAAAMnxBAAAAAAATOMEAAAAAAD51AQAAAAAANDGBAAAAAAA0bgE +AAAAAAD6qgQAAAAAAE2dBAAAAAAAx48EAAAAAABpggQAAAAAADJ1BAAAAAAAImgEAAAAAAA4WwQA +AAAAAHROBAAAAAAA1UEEAAAAAABcNQQAAAAAAAYpBAAAAAAA1hwEAAAAAADIEAQAAAAAAN4EBAAA +AAAAF/kDAAAAAABz7QMAAAAAAPHhAwAAAAAAkNYDAAAAAABRywMAAAAAADLAAwAAAAAANLUDAAAA +AABXqgMAAAAAAJmfAwAAAAAA+5QDAAAAAAB8igMAAAAAABuAAwAAAAAA2XUDAAAAAAC2awMAAAAA +AK9hAwAAAAAAx1cDAAAAAAD7TQMAAAAAAExEAwAAAAAAuToDAAAAAABCMQMAAAAAAOgnAwAAAAAA +qB4DAAAAAACEFQMAAAAAAHoMAwAAAAAAiwMDAAAAAAC2+gIAAAAAAPvxAgAAAAAAWekCAAAAAADR +4AIAAAAAAGLYAgAAAAAADNACAAAAAADOxwIAAAAAAKi/AgAAAAAAmrcCAAAAAACjrwIAAAAAAMSn +AgAAAAAA/J8CAAAAAABLmAIAAAAAALCQAgAAAAAALIkCAAAAAAD6AAAA4QAAAK8AAACvAAAArwAA +AMgAAADIAAAArwAAAK8AAACvAAAAAAYKExUZAAAOAAAAKgAAAAcAAAALAAAA/////wAAAAAAAAAA +AQAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAEAAAABAAAAAAAAAAAAAAAFBQUFBQUFBQAAAACADQAAACAAAIANAACADQAAACAAAIAN +AAAABgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAlLkBACAggA8AAEAAaSAA +AGkgQABpIAAAaSBAACAggA8AAOgAaSAAAGkgQABpIAAAaSBAACAggA8AACAFaSAAAGkgQABpIAAA +SiAAAEohAABKIgAASiMAAEokAABKJQAASiYAAEonAABKIAAQSiEAEEoiABBKIwAQSiQAEEolABBK +JgAQSicAEEogACBKIQAgSiIAIEojACBKJAAgSiUAIEomACBKJwAgSiAAMEohADAKJIA/gAAAwEEs +nDBALJwwQiQcNAoigD+AAKxCCiMAN3YOAABKJgBwaSBAAEomAHBKJgBwSiYAcEomAHAAFgBwgABw +BEB4ICBAhwAAAAAAAAAAAAAKyM9xoADIHw4ZGIALyA8ZGIAMyBAZGIANEgI2AMhEeBEZGIAOyC0Z +GIDgfuHE/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwcyLH8HAiy/BxIsvwciLL8HMiy/BwI +v2okgBDhxGokwBDhxPHAz3CgANAbFIDPcYAAbAQEIICPz1EE4QChCvIvKQEAz3CAAIgJ8CBAAEB4 +2v/RwMHEayTAEMHEaySAEMHEn3QEFAs0BBQKNAQUCTQEFAg0BBQHNAQUBjQEFAU0BBQENMHDwcLB +wcHAwcRFLH4QCiZAfsHEaySAFMHEICBAhwrIh7gKGhgwC8ibuAsaGDAMyAwaGDANyIe4DRoYMA7I +hSDDDw4aGDDgfuB48cAKyJW4ChoYMAvIm7gLGhgwDciKuI24kLgNGhgwz3CAAKgKGIgbCFEADcjP +cQAA8AmsuA0aGDAqDSAAD9hn2DYN4ACKIUcB0cDgfvHAz3EDAEANz3CgAKggLaDPcoAAuAQgggFp +AKLiDCABSNjPcIAA7AglgCOBIIHHcQAAiBPODEAH4vHgeM9wgADsCGEEQAfgePHA+gtAAc92gABs +BAXoDwhRAAHYAvAA2AuuBukNCVEAAdgD8ADYCq4F6g8KUQAB2ALwANgMrgDYz3WgAMgfGB0YkAuO +iiEQAA3oCI4L6M9wAwBADUUdGBAwpQLYGB0YkALwMaUKjhnoCY4X6M9wAQCSuSAdGJDPcIAAKAAh +HRiQz3CAAGgEIh0YkBgVAJZFIAADGB0YkAyOB+gYFQCWhSABBBgdGJAZ6wDYlLjPdoAAqAQApnHY +BrheD+AA/Nkghs9wAABMHFIP4ACfuRgVAJaFuBgdGJCRA0AB4HhpIEAA/vHgePHApcFBwELBDBwA +MRAcQDHPcYAA/EM0GcAPMBkADywZwA4oGYAOJBlADs9wgAD8QyAYQAvPcIAA/EMcGAALz3CAAPxD +GBjACs9wgAD8QxQYgArPcIAA/EMQGMAIz3CAAPxDDBiACM9wgAD8QwgYQAjPcYAAgEOAGQAIfBnA +B3gZgAd0GUAHcBkAB2wZAAdoGYAGZBlABmAZAAZcGcAFWBmABVQZQAVQGQAFTBnABEgZgAREGUAE +QBkABO+hzqGtoYyhLBnAAigZgAIkGUACIBkAAhwZwAEYGYABFBlAARAZAAFjoWogAAPYGQAAaiDA +AtQZAABqIIAC0BkAAGogQAHIGQAAaiAAAcQZAABqIMAAwBkAAGoggAC8GQAAaiBAALgZAABqIAAA +tBkAAGoggAHMGQAAz3GfALj/GIFTJ841UyXENVMmxTWUuBihQMMBwALB17oMFAYwyXMA3fIK4AAQ +FAcwz3CgALQPvKDPcaAAyDsugYoK4AB92FoKQAHqDeAAqXAI2ADZqg3gAJm5NvHxwFoJYAF72GYK +4ADX2c9xgAD8QzQZwA8wGQAPLBnADigZgA4kGUAOz3CAAPxDIBhAC89wgAD8QxwYAAvPcIAA/EMY +GMAKz3CAAPxDFBiACs9wgAD8QxAYwAjPcIAA/EMMGIAIz3CAAPxDCBhACM9xgACAQ4AZAAh8GcAH +eBmAB3QZQAdwGQAHbBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAESBmABEQZQARA +GQAE76HOoa2hjKEsGcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAAA9gZAABqIMAC +1BkAAGoggALQGQAAaiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAAuBkAAGogAAC0 +GQAAaiCAAcwZAADrds91oADQG1wVEBDPcAAARBwyCSABCifAHzpwz3CAAJAWA4AH6BeFUSDAgDwA +QgEH2BIJIAEKuFMgQQcH2DIM4AAKuM9woADUCxiAQiAACEggAADPc4AA7BXPcYAAqAQggZwbAAAL +IUCEyiAiAzT0HwiRIBcJniUTCBUIUSFApRzYyiDhBijwBNgm8IwgAaAh8kIgQSA/CRUEMyZBcIAA +/DZAJwByNHgAeEogQCAN2BTwSiCAIOnxSiAAIRPYDPBKIAAiFNgI8EogACQV2ATwFtgC8A/YcYPp +cclyCiQABGEE7/8KJUAE4HgpA8//8cCKCMAAddhGCOAAiiEKA04LAAA2DMABpf6iCAAACiHAD+ty +BtiKI0oHSiQAACUE7/8KJQAB4HjxwATpGQgSCAohwA/rcgXY6dtKJEAABQTv/7hzz3KAAIgJFXog +otHA4H7geADZnrkZec9ygACACQGCJXjgfwGiANmeuRl5z3KAAIAJAYImeOB/AaIA2Z65GXnPcIAA +gAkBgCR4QiAAgOB/yiBiAOB4z3CAAIAJAYDgfy8oAQDgePHACgnP/+B44HjgeOB4aSCAAW8hPwBp +IAAA9/HxwGrYdg+gAIohRAMA2I24pg6gAwgaGDAQzIYg/4oJ8s9wgAAFBQCIgODMCsIDr/HxwPIK +wAPPcYAA7BHwIQAAQHiA2c9woADQGzCgn/HgePHAPg4AAc9wgABsBKCAz3CAAKgKCIAEJY0fDwAA +4A0I3wIiCEAJj+jPcaAAtEcA2EsZGIAB2HcZGIAA2J64VBkYgAQlgh8BAAAAEmrPc4AAfAQgg6R4 +4YMEJY4fAAAAQAd5IKMEeQYlQBADvgQlgR8AAACApH5dekV5x3/kfsZ4ArkEJY0fAgAAAKR5Jngv +KAEATiBBBM9wgACoClUQgADho892oADIHxkaWDAP6M9woAAUBCqgCYATCBUOz3KgAIggAdg1egCi +MvDPcYAADAUA2AChAN+RvxMe2JPPcIAA3AIQeM91oAC0R0kdGJDPcYAAdGPPcIAAEAUgoG8gQwBU +HRiQAdhiDaADCBoYMDYPAAmO6BMe2JPPcIAADAQQeEkdGJBvIEMAVB0YkHkFAAHxwOHFz3GAAAQJ +gBEAAM91oADIHy8qAQDPcAMAQA1FHRgQ8CGAAEB4gNgVHRiQWQUAAeB48cDPcYAAbAR82L4NoAAg +gQohwA/rcgXYiiPEAEokAACpAe//CiUAAfHA4cXPcIAAbASggGvYBCWNHw8AAOCKDaAAiiFIAy8o +QQOmCOAMTiBABAolAIDKIcIPyiLCB8ogYgHKI4IPAAATAmAB4v/KJGIAf9gKuM9xoADQGxOhf9gQ +odEEAAHgePHAa9g6DaAAiiEICFoI4AwE2AolAIDKIcIPyiLCB8ogYgHKI4IPAAAiAhgB4v/KJGIA +HwXP/+B48cBmDYAMgNnPcKAA0BswoAcFz/9KJAB1ANmoIMADz3CAAAgKNnhhgECAz3CAAAQJAeFV +eGCg4H7gfuB48cA9CV5Hz3CAAMAFAICD4Mohwg/KIsIHyiBiAcojgg8AAEwCyiTCAKQA4v/KJSIA +NgvABwvIvbgLGhgwANmduc9woADQGzGgkwTP//HAgeDMIKKABfTPcoAAqAoE8M9ygADogM9xgABc +RIHgzCDigCn0aIJgoWmCYaF8imipfYppqSoSgwBqqSsSgwBrqSwSgwBsqXSSdqltkmexd5JosWiC +wLt0qWiCBCODDwAGAACA4wHbwHtyqYQSAgBUGZgAHPBggWiiYYFpomiJfKppiX2qaokqGsIAa4kr +GsIAbIksGsIAdol0smeRbbJokXeyVBEDBoQawAANCJEAHg/gAEAhAAbRwOB+8cDWCgABz3WAAOiA +AIXPdqAAgCUGpgKVB6YChQqmBpULpjoLYA0A3wXo6KbppvGm8qYAhRWmApUWpgUDAAHgePHAlgoA +AQDdz3CAAKhrCgtgDbSoE+gI36l2gObMJqKQzCYikcwmYpF8DCIEyiCCA2G/6w91kAHmHPBKJIB9 +z3GAAAhZqCBAAQQZUAPgeADZSiQAcs9ygACIRaggAAMWIkAAdpDPcIAAeFk0eAHhYLDPdoAA6IDP +d4AAFGhAJgASJG86CeAABtrJcEAngRIuCeAABtpAJgASQCcBFB4J4AAG2hiOFQgRAYogDwrWCqAA +iiEZD9IIwAwJhhcIXgGKIIcOwgqgAIohmgQ+CIAHTgpADYDg9A5CAs9xAAD//89wgACwZCygK6AE +Glgztf8RAgAB4HjxwKIJIAEA2oQoCwoAIYN/gABUg1mjz3aAAAw3tGi6ZlKCAoYAIYF/gADkgs93 +gACsRV6jYYbYGcAAZYbcGQAABobgGcAA5BkAABYngBAWJoEQCOAE4R4JYAQI2t1lFIUWfhZ/QCcA +EiRuCglgBAjamQEAAfHAANji/+IKYAQA2M9wgAA0BY4NYAQE2TIOQAQGCgADAdgA2QYOYAyA2g4O +wAgeD4AMGg9AB3YKQAgyCcAHANgmC2ANCHHCC0ANFg4ACpoKQAgFBs//4HjxwOHFAN3PcIAAPAWg +oM9wgACAa6ywLgqgB6lwfgyP/1IM4AmpcEIOgAR+DwAE6gsgCqlwtgsAChUBAAHxwJ4IAAGjwQ0I +kQDPdYAAqAoI8IQoCwoAIY1/gADogA0IkQDPdoAACHMJ8M9xgACsg4QoCwoAIU4OLZU8eihwhiHx +D0e5wrqGIP4DJHpEuFBxyiHCD8oiwgfKIGIByiOCDwAAZQTKJCIAIAWi/8olAgFIhTu6UyICgECu +TZXAukGuDPJ3lYYj/wlDu2eud5WGI/4HRbtorhHqz3KAAHgjFSIDAACLNXoCrgGLA64CiwSuA4sF +rgOKCvAB2SmuAtgCriOuANgErgPYBa4GrotwyXGaDyAEDNoAwAHB/gwgCgLCi3DJcYYPIAQM2gDA +AcFqDSAKAsLPcYAAwAYAoQ2VRLgA2S+lDQgeAIohCAAvpQkIXgCLuS+lCQieAI25L6XpB+AAo8Dg +ePHAcg/gAJhwhCgLCgAhgH+AAOiAViAGBSiAViDFBVEhwICKIQgAyiEhANQYRABKJAByANmoIEAP +z3WAABA4/IguZeR+LyqBA04igwfPcoAANDhvYgAmQwDgq1QQjwDkfi8ugRNOJo8X7mLIq8iAIQ7e +EF2IhuHTIqYALyqBAE4ijQfPcoAAPDiqYhHwz3aAACQ4LmbOZbyIxH1sEI4AxH0vLUETTiWOF8pi +UKsB4UokAHIA2qggwA/ciM9zgAAcOE9jz3WAADQ45H4vKYEDTiGPB+9lACaBAPypVBCPAOR+Ly6B +E04mjxfuZSQZggPIgB8O3hB9iIDi0yOhAC8rwQBOI40Hz3OAADw4q2MQ8ATqyWoD8Eh2zmN8iMR7 +bBCOAMR7LyvBAE4jjgfLZSwZwgAB4kokAHEA2qggAAXPcYAAGDh9iElhACWMAAHiZHkvKUEATiGD +B89xgAA8OGlhIKwGDGAGiHB1BsAA4HjxwAYOwAAPCJEAz3GAAKgKB/CEKAsKACGBf4AA6ICpgXiJ +QS3CEMC6F7oAIo4PAACAHOS9zyYiFuC9TtrPJqIQyiKCDwAATgGG488iYQIrDV8Rz3OAAOiAz3eA +APSD4pcoEwQBFQ8BEcMTDwYLD18RaYMJC14Bgb7Pc4AA3INsi4fjzCNigswjIoID9IO+USUAks8m +ohWIGYADjBmAAA8IkQDPcIAAqAoH8IQoCwoAIYB/gADogGkQggBOEA0BDiKBDwAAOgEJuUJ9JX06 +kEJ5ErklfTuQQnkXuSV9BCW+nwDwAADKIcIPyiLCB8ogYgHKI4IPAACoAM8j4gLKJMIA9AGi/8ol +QgNlBeAAkBhAA/HA9gzAAAh1DQiRAM92gACoCgjwhC0LGgAhjn+AAOiAAdloHkIQAN+AHsATTNhO +HgQQBdgQpgrYG7YQ2Bq2FNhMHgQQLdhQHgQQJthSHgQQSiQAculyqCCADc9wgABgOPQggwDPcIAA +xGVUeGCwz3CAAHA49CCDAM9wgADUZVR4YLDPcIAAgDj0IIMAz3CAAORlVHhgsM9wgACQOPQggwDP +cIAA9GVUeGCwz3CAAKA49CCDAM9wgAAEZlR4AeJgsAiGDwheAQTaYh6CEAPwYh7CExkIHgEJ2Woe +RBAu2l22AtppHoIQCvAU2moehBAy2l22aR5CEBTZWY5ZYTB5ah5EEBrhPLYXCB4ACthkHgQQBthm +HgQQB9gH8BDYZB4EEGYexBMF2BCmqXDN/lyOVB6CEGweghDmusoggQDKIYEACfJQIsMBb3gIcVQe +whBsHsIQEwpeAShzhiMDAG95VB7CEA0KHgGluGweAhALCt4ApLlUHkIQMw2QEKlwAv/PcIAAuIOE +LQsaMCBADlEgQIDx2MAoIgHKIIEPAACTAMAoIQGcHgAQGNiNuBemCIbPcYAA6IANCN4AuhGBAIm5 +BPChEYEANqbPcaAArC85gTC5UyEBgM9ygACEBFUeQhAT8s9xAADECSKySiQAcgDZqCCAAoDbz3KA +AGxnNHpgsgHhFPCA2SKyk9kEuc9ygABsZyCyIbIisoojFwdjsiSyZbJmsoohBAAnsgQgvo8ABgAA +C/I2uMC4G3gB4G4eBBAC2IAeABAD8G4exBMA2BymHaapcCj/KIYB2kEpAAU1uVIgAABSIQEAwLjA +uZoOb/9Ic+0CwADPcIAAqAoIgM9xpAAcQMC4E3jBuBKh4H7xwOHFz3GAAKgKd5HPcoAAxAZX2ACi +CwseAF/YAKILC54AhbgAogsLXgCHuACiz3KAAAhzoIoA2oDlyiCBAM9zpQDoDwajz3OgAKQwAYOA +5c8g4gDQIOEAAaPPcKAA7CdLoFCBz3CgAMgcSKDeDGAKD4FxAsAA4HjxwPIJ4AAH2c91oADIH0gd +WJDPcIAAqAqAEAAAAN5MHRiQz3CrAKD/2aA6oNigiiAEAA+lz3CAAKgKahABAc93gADgNrAdQBC0 +HUAQH9kIuS6lCIBRIACAANiLuCTyEKUgj+C5ZNjKIIEDBqcVCV4ADNh+HRiQAYcDpwKHBKcG8H4d +mJPDp8Snz3CAAKgKCYBRIECBGAwCDc9xoACkMAGBhLgR8BGlfh2Yk8lwfgsgDclxw6fEp8anz3Gg +AKQwAYGkuAGhq/+aCwAKsP/PcAAAVVVaHRiQAdhZHRiQz3WAAKgKbhUBEc9wpgDoByagmg9AAy4O +4AkNlc9wgACwTgeIgODoCcIBz3CAAKgKiBACAM9xoADEJw8ZmICMEAIAz3CgADAQRKDPcIAAyF4Q +eI8ZGIDPcIAAdF8QepYgAgAQuEV4kBkYgIogBACSGRiAz3KAAKgKkBIAAEAZAIDPcIAA9BhTGRiA +DxEAhp+4DxkYgA/YEBkAgFUSgACA4Moggg8AALwPyiCBDwAAvB8cGRiAz3CmAPTPw6DBAMAA8cBO +COAAKNo6cBpxhCgLCi92z3WAAKgKACaAH4AA6IASD2AAqXHPcYAACHMAJoAfgACsg0YPYAAM2gDf +z3agALQP/KZIhVMiAAC+DaAJNJWF/0whAKBcDiEKyiBhAAPICwieACoLAAII8ADZnrnPcKAA/EQh +oPymTCAAoMogYgAMCiINyiECACUAwADxwL4PgAAKJQCQocEB2BHyA8gdCJ8ACiHAD+tyBdiKI0cL +SiQAAJUEb/+4cwDYhC0LGs92gADogDpwACZPHgmHQCYBGYQpCyoluFMgEgAwIUAOJbhTIBAA6XCm +DWAADdnphyW/wL+G7QPY9Pwy/QTwEggADR/vTCIAoMohwg/KIsIHyiOCDwAADwLKIGIBy/WiDgAG ++g+gAAHYcQgRIIogiQYWCGAAiiHIBuoNYAcA2Czw3g+gAADYg+15/R7wwg/ADIoPwAwF6MYPwAwW +8IIPwAwU6M9wgADcgwyIieDMIOKBDPTPcIAADDcZgATZQMCLcNYKYAC92hEIESALCVEgTg/ADALo +fP2pcHP+dgpgAalwBNg6D+AMAxoYMI/oz3CAAPSDApA0lhMJAAAqD8AMK+ir7X4PwAwn6Klw6XGO +/3/ZEbnPcKAAsB80oAYJAAb+DsAMiOjPcIAA9IMCkDSWEQkBAA3IBSCADwEAAPwL8A3IBSCADwAA +ADwNGhgwDciQuA0aGDDGDsAMEOjPcIAA9IMCkDSWFQkBABiOz3GAAKgKGKkJhgmhAd6+CaAJyXDP +cIAAnQZaCKAJwKglDVEQz3CAANyDDIiJ4Mwg4oED9IbvEQgRAnoOwAwE6J4OwAziC0AAJg1gAQDY +MQagAKHA8cAA2IP/TglP//kCj//gePHAxg2AAAh1z3aAAOiAhCgLCgAmUB4kEAAgUSBAgcohwQ/K +IsEHyiBhAcojgQ8AALkCyiQhAIQCYf/KJQEBz3CAAPwKAYgAFgFAsu3PcoAAXEQgogAWA0CA4GGi +ABaDQGiqABaDQGmqABYAQQLyD7YAFoBACqoAFoBAC6oAFoBADKoAFoBAABYAQQeyABYAQQiyABYA +QAQhgA8ABgAAgOAB2MB4EqoE2GT8OPDCHlgQABYBQM9ygADghMMeWBAAFoFAgOAMGkKAABaBQA0a +QoDMcAjyIJDPcIAAuIM7sAPwAJAAFoBAz3GAAOSEGhoCgAAWgEAbGgKAABaAQBwaAoAAFoBAABYA +QQYZBIAAFgBBGhkEgAAWAECveO/9ZghgAalwLg3ADM93gAD0g4zoApc0lhUJAAAiDcAMJOii7XYN +wAwg6CQQASCpcCW5wLkK//4MwAyF6AKXNJYTCQEADcgFIIAPAQAA/ArwDcgFIIAPAAAAPA0aGDAN +yJC4DRoYMEIKQAClBIAAANg88fHAANnPcKAAtA88oM9woADsJyugz3CAADBzIaAioAIPIAoocM9x +gACwTiCR/9iC4cogog//2s9xqwCg/1mhGKEC2PYJYAADGhgwHQGP/+B4hCgLCgAhgH+AAOSC3BAC +AM9xgABYRtgQAwBgGYCA4BACAOQQAABcGcCAbBmAgOB/cBkAgPHAsgugABLZqcEIdroLYACLcEok +AHEA2qgggAIWJIAwKIgLCZIAYbkoqAHiAcICwYQuCxoAIYB/gADkgtgYgAAFwtwYQAAGwbRu4BiA +AMd1gAAMN0gVERDkGEAAz3CAAKxFCiBALhYgQAQI4IPBHgvgAwja9IXPcIAArEWHwfZ4COAKC+AD +CNoAwAAgjS+AAOiAtB0YEA0IHgC5HdgTBPC5HVgUmgvADITongvADAToANgD8AHYEHYUD+H/yiCB +A7QVABZRIECA8djAKCIByiCBDwAAkwDAKCEB2ghgAJwdABAxA6AAqcAA2Izx8cClwYtw/ghgAAXZ +AMIrCh4Az3CAAKgKGIgfCFEAANiauM9xoADIHw+hAcCkGQAAw9gauA6hKwqeAAUSAjYA2UokAHKo +IEADuHGDcSiJACJAMVwYQgAVCk4AQCVBAGoIQAClwNHA4H4KIcAP63IF2Iojjw1JBy//SiRAAPHA +4cXPdYAA6IAJhVEgQIHKIcIPyiLCB8ogYgHKI4IPAADaBsokYgAYByL/yiXCAFIPgAmKCyAHAdjP +cIAA3IMMiEEI0QHDFQAWOQheAdIKwAzPcYAA+GsEkCWBCrgwcMohwg/KIsIHyiBiAcojgg8AAOQG +yiQiAMgGIv/KJcIAlg0P/2oNYAkA2PIJQAm+DwAAOQKAAOB48cAC2DD98f3ZBk//8cCuCYAAAN7P +daAAtA/cpU4PYAlod/j/8g/gCelwA8gLCJ4AwgzAAQjwANmeuc9woAD8RCGg3KXdAYAAhCgLCs9x +gADMgzAhQg7PcIAAiEVWeHaQz3GAAFxExBncABeQz3OAAFhGxRkcAM9wgACsRVZ4DIiQGwKAANjg +f8cZHADxwAIIj//eCcAMFPxJBk//8cAiCaAARNrPdYAADDfEbc9xgACwRS4IYACpcEokgHAA2agg +AAgUadhgcYCEKQsKACGCf4AAVIMAIYB/gADkgn6iANt5omGFQoUB4dgYwABlhdwYgABGheAYwADk +GIAALQGAAM9wgABcRIEDIACKIQUF4HjxwKYIgAChwQDdQMUAFo5AABaCQAAWg0AAFpBAHOpId89x +gAAUcyOJhif8F0W/w7rmeeC5yiWCEGDF4bnKJYIQyiUhEAEcQjNRIYCAyiIhAAIcgjCk6M9wgABc +RLaI9Iixc8wmwZMR8gohwA/rckArBAQQvgXYiiMcDQUkRAMdBS//BSbFEwDFQCAOBs93gADogFQY +WAOEH0ATIfDPcIAA9IMCkBULAQDPd4AA6IDCFwAWwLgbDgAQCiHAD+tyBdiKI1wPmHPVBC//SiUA +AADFz3aAALiG2x9YE0AgQSBJIQEGNHn6DSAAyXBCIMAlSCAAABsIdAAA2wDaABYBQAHi+wrUgAHj +9QsEgFYmABnSDSAABtkaCMAMiOjPcIAA9IMCkDSXHwhBAL4LYADJcM9wgAAkC6KgTyXBF14IIACK +IBINYg0AAMUHYAChwADYWvHxwKHBi3CKDSAAAdkAFAUwTCUAgMohwQ/KIsEHyiBhAcojgQ8AAIIH +IAQh/8okYQDPcIAAFHMeDSAAAxhCAaHA0cDgfvHAFg9AAM9zgADcC0ODAN/PdaAALCCwhdJq1H5+ +ZqWmBKYB4owiAoAmpkOjhfcCg+OjAeACo0kHQADgeADYz3GgAMgfGKEZoQHYDqHgfuB48cCeDkAA +CHeacbpy2nMKIgAhCiNAIQohgCHPcAAAyBuaDyAACiDAIfpwz3AAAMwbig8AABtwz3AAAAQcfg8A +AM92oADIHztwAdgTpgXYz3WAAEgLAKXhpQ7AIB0AFAmlFYYcHUAUCqUYhhgdwBQLpRmGFB2AFAyl +oBYAEBAdgBUNpaQWABAMHUAVDqWoFgAQCB0AFQ+lz3ABAB8nEKUeDyAAKNgRpRYPIAAA2BKlUyfA +dROlAchUHQAXFqUSFgCWUB0AFxelExYAls9xoADIHBilFBYAllMhAjMZpRUWAJYQuhqlJBYAlhul +FhYAlhylz3CAAOwVEYAdpc9wgABIC3gYgArPcIAASAt8GMAKz3CAAMQLBBgAC89wgADECwgYQAso +gSOgz3GAAGAFIIEkoC8hxwUIuSV6LyEHBkV5oQVgACWg4cXhxkApDQIlfUAtAxSleyUKNAIIdVMl +fpAG8gEdUhBhuvvxQSqOAMG6QiZOkAQd0BD99QnqLySJcOB4qCBAAQEdUhDgeMHG4H/BxShyANnY +8eB48cAyDUAACHbPcKAALCCwgAvw4ggP/89wDwBAQqYPIAapcR8IUADPcKAA1AsYgEIgAAhIIAAA +3wiEg2UFQAAKIcAP63IF2Ioj0gmKJMMP0QEv/7hz8cDWDEAAocEacM92oACsLxmGBCCAD3AAAADX +cCAAAAAB2MB4LyYH8Ch1AN8T9IogSQaWDe//iiEMBjmGig3v/4ogCQaKIAkGfg3v/6lx6XAr8A/M +ABxEM08gwQMB4BB4j7gCHEQwDxocMM9woADUCziAQiEBCIDhyiHMA0AgACIQcSwPxf9AIMAhBCCA +DwAA/P8FIIAPgK4AAOxxAKEAwexwIKAB2JUEYAChwCK5BvDscmCiBOBhufkJtYBggADZz3CgANQL +baDPcKAARB01oOB+4HjxwAoMQAAIdih1KHBIccj/geDKIIEDxA/h/8ohQQNZBEAA4HjPc9C6/srP +cp8AuP9+ohqiO6LPcKAAOC4FgAQggA/AAAAA8wiAj8AAAABp2Bi4GaLgfuB48cCuC0AACHfPcYAA +xAQIiQDeqcFAxocIEQAB3aipz3GAAABRz3CgAMwrLaAA2I+4DxocMB0agjNiDuAJi3AOC8AFz3AB +AB8nQcCKIFQAQsDPcIAAqEIAiGTFAt0RHAIwAMASHEIzExwCMM9wgADcC0XAz3CAAEgLRsDPcIAA +YAUAgEPGINlIx0fAgcAB2sf/CNgB2c7/AxpYM30DYACpwAPaz3GgABQERaHPcaAA1AsNoeB+8cDh +xQPdANvPcqAA1AuxonCiz3WArhgA7HKgogLaHBqCMAcSDTbscqCiDxICNwHiDxqcMOxyAKIBEgI2 +7HBAoOxwIKAB2M91oADIHxOlOIXscCCgGYXm/3Qd2JDPcaAAyDsOgYi4DqEJA0AA8cAA2AQSgTDj +/wQShTAKIcAP63IH2IojkQFlB+/+SiQAAOB4ANoD8AHiQSiBAP0KRIDgfs9xgADsFUQZwAeduJ64 +z3GgAMgcDaHgeOB44HjgeOB44HjgeOB44H4D2s9xoAAUBEWhz3GgAPwLDKngfgPaz3GgABQERaHP +caAACAwAseB+A8zXcAAAAEDKIYsPgK4EAMohig8ArgQA7HAgoM9woAAUBAPZJaAByM9xoADUCwDa +DaHPcKAARB1VoOB+pwkQAEAhwgPDuZ8JNQQkujMmQXCAAHg3QCcDcjR7AHsAFgFABBhQAAAWAUAE +GFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQY +UAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFAQiJC +gAQYUAC+9eB+4cUi6mNqwbo9CjUBIrszJoJwgACIN0AnjXJUfQB9BBACBAQZkAAEEAIEBBmQAAQQ +AgQEGZAAQiNDgAQQAgQEGZAA7/Xgf8HF4cWpChAAQCLDA8O6nQo1BCS7MyaCcIAAjDdAJ41yVH0A +fQEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIA +ARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgAB +EIIEARmSAEIjQ4ABEIIEARmSAL/1qvHgePHANghAACh2RiHNAB1lIrmV/8G+HQ5QEBEOkBAbDtEQ +ABaAQAEdEhAAFoBAAR0SEAAWgEAArW0AQADgeIDhyiRNcOB46CCtAQAWAUECGFQA4H7gePHA4g8g +AFMhQgBOIg0BIBICNs92oAAUBMmGANvCelBxyiHGD8oixgfKIGYByiOGDwAAGQLKJGYAlATm/sol +xgCA4cokTXDKIs0A6CBtAk5gz3GgADgEAeLIqR8NUBATDZAQHw3REM9woAA4BGioz3CgADgEaKjP +cKAAOARoqNEHAADgeM9znwC4/xqjPqPCugUigg8AbAAAWaPgfs9yoAA4LkWCBCKCD8AAAAAA2x8K +gA/AAAAAz3KfALj/GqI7omnYGLgZogHYAvBocOB+4HjPctC6/srPcZ8AuP9eoRqhz3CgADguBYAE +IIAPwAAAAPEIgI/AAAAAatgYuBmhHIHgfuB48cDaDgAAz3CAALBOAJAA3jUIkQEF2Am4GhoYMBsa +GDAcGhgwHRoYMAnYCLgeGhgwHxoYMIogEAAgGhgwiiAIACEaGDAA3QjYz3cAAAQdmHAVIkAzGhAB +BgDYz3KgABQEqqLIoieiBKI+ZojhaLnKIQ4A6XCh/kIkQAAg59MIdYAB5cEGAADgeEEpgYAJ8i8k +SXCoIMABBBACBOxxQKHgfvHAPg4gAADaCHUods9woADUCziAQiEBCIDhyiGMAEAmABIQcegIxf8H +bgQggA8AAPz/BSCAD4CuAADscQChAcjscQChIr4G8OxxAKEE5WG++Q61kACFtv5RBgAAB9nPcqAA +1AcaGliADegZEgGGCSBDAA8SAYYCIMCAeWEPGliA9fXgfqHB8cDPc4AOCADscmCi7HIAoihwpf7R +wOB/ocDxwI4IwAmyCMAJ0cDgfuB48cDhxc9wgACwTiaIhwkQACeIgwkQAKCQSm0XClUCMyaCcIAA +nDdAJ4FyVHkAeQDZJPAkkIbpJZCB4cwhooAE8gDZA/AB2QLdGPAkkAXdgeEB2cB5EvAkkATdg+EB +2cB5DPAkkAbdguEB2cB5BvAkkArdhOEB2cB5GwlQAAgQBQEKIcAP63IQ2IojDg/tAe/+mHVxBQAA +4HihwfHA7gwAAETAjekKIcAP63IF2IojDwNKJEAAxQHv/rhzYIED60GBiOrPcoAAVEVwgmChUYJB +oSTGgObKIcEPyiLBB8ojgQ8AANYDyiBhAeTzgOLKIcEPyiLBB8ojgQ8AANcDyiBhAdjzMQheAgQg +gA8BAADALrjPcoAACDgIYkkggABhuAK4FHjHcIAADGdqoCGBK6BI8DkIHgKg5solghPKJSEQBCCC +DwEAAMDPd4AAuDfOZwQggA8GAAAAMbguuh5mz3CAAAg4SGDCeBPwUyDCAF16z3WAAPQ6TWUEIIAP +AQAAwC64z3KAAAg4CGJhuBZ9Em0UeMdwgAAUZmCgIYEhoIoh/w8dDTQWIqAKIcAP63IF2Iojzw6K +JIMPxQDv/rh1CNw3BAAA4HjhxeHGANtKJAB2z3KAABRmqCCAAzJrNHklYD5ioKY9YKGFGWGhpiKB +AeMipkgQAQZIGlgASRABBkkaWABLEAEGSxpYAEwQAAZDBq//TBoYAPHAegsgALhxz3KAAKhGBbkw +IkQAosEPDF4Dz3OAAHCEBPDPc4AAiIFAIwIGQCMBB1EkQILKIcIPyiLCB8ojgg8AACgEIADi/sog +YgHPdoAAsEpALY0BpmZAxiDFCw4eEsK9qmEN8BMOXhJEJQEcRLkqYom6BfBTJcEQPHkqY89xgACw +SRYhQQEiiQ65RXkgoFUDIACiwOB48cDWCgAAOnAacUh1aHCqDeAFCtlhaCpw7v6keAQlARQrCEAA +INrPdqAAyB9QpgrYQx4YEADYjbgT/lGmYbuMI/+PAN8p9ulwAvAB2OkCAADxwIoKAAAacADdNNjd +/lAgQQQ02Kb9NNja/k8gAQWVuTTYo/2pdwTwqXcIdQPYCrh3DQUQMm0EIYEPAAD8/yzYm/0s2AHZ +z3MAAIgTKHLZ/yvoLNjL/kEoDgQ02Mn+NwhfBRsIHgU02Mb+TyABBTTYj/1H2AYLr/8B2RLuqXCA +IBAA13AAAAAMwiBhAJ0OAJAL8EfY5gqv/wLZB/CH7UbY2gqv/wDZANgE8AAYxCMB2D0CAADxwNIJ +AAAIdwh2KHUacjDYr/4IcYYhBgAw2Hj9NNis/lAgQQQ02HX9NNip/k8gAQWVuTTYcf0R8BkIHgU0 +2KT+TyABBTTYbf1H2H4Kr/8B2QIdVBQB5gAgwCNBDgUQMm4EIYEPAAD8/yzYZP0s2AHZz3MAAIgT +KHKh/w7oLNiU/kEoEQQ02JL+sQhehUfYOgqv/wLZANgD8AHYmQEAAOB48cA6CQAACHXPcIAAxAQB +gCh2ocFIdzEIUQAN64twpP+A4ADYI/IAFAAxAeC4YBB4BvAAJYAfAAAADBB4yXHpcsj/FfCO65Yl +AhCwfQrwz3CgAGAdsrAUkAHlsH0CHhQQYb+MJ/+f9fUB2DkBIAChwPHAAdsw2G7+UyCCABsKdQEI +cTMmgnCAAKg3QCeAclR4AHhocAXwkgmv/0jYANiA4MohwQ/KIsEHyiBhAcojgQ8AAMwFyiQhAHAF +of7KJQEBz3OAAMQENNhZ/vC4AdjKICEA2wLv/wGj8cDhxQh1z3CAAPwKAYgR6APwFgyP/s9woADU +CxiAANlCIAAIgODKIEwA6whEg60AAADgePwciLb8HEi2/BwItvwcyLX8HIi1/BxItfwcCLX8HMi0 +/ByItPwcSLT8HAi0/BzIs/wciLP8HEiz4H7geATcON018OB4BNw03TPw4HgE3DDdMfDgeATcLN0v +8OB4BNwo3S3w4HgE3CTdK/DgeATcIN0p8OB4BNwc3Sfw4HgE3BjdJfDgeATcFN0j8OB4BNwQ3SHw +4HgE3AzdH/DgeATcCN0c8OB4BNwE3RnwNBQaMDAUGTAsFBgwKBQXMCQUFjAgFBUwHBQUMBgUEzAU +FBIwEBQRMAwUEDACxwHGsCRNM7AkHzPgfuB+4HjgfuB44H7geOB+4HgA2Za5z3CgAKwvPKDgfuB4 +8cChwYtwWg2v/wHZQNhCCe//QMAODY//ocDRwOB+4HjxwAohwA/rcgXYMNuKJMMP6QOv/rhz4Hjg +fuB44H7geOB+4HjgfuB44H8B2OB+4HjgfuB44H8B2PHAzg7P/wh2z3CgAGQu8CCPAxkSEDYZGpgz +9dgFuNYKr//JcRnIz3WgABQECqUJhYDgVAlCBc9woADAL1EQAIYLIMCD9fXPcAAAZB56D4//3wiO +gwmF7egZGhg09dgFuJIKr/8KcRnICqXJBs//4HjxwFoMj/9FA4/+4HgAFgFBILAAFoJAUyJBACGg +QSrBAFIhAQDAuSioQSqBAMC5KahBKgEBwLkwqAAWgUDPcaAAyBwogeB/I6DxwAGAEeg1CFAANQiQ +AAohwA/rcgXYiiMEAEokAADtAq/+CiUAAQHZz3CgAMgcKaCCC6//FNgJ8ALZ+PEB2c9woADIHCmg +0cDgfuB48cAS6CcIUAApCJAACiHAD+tyBdiKI8UFSiQAAKECr/4KJQABKdgSuAfwFdgTuAXwT3or +2BK4NXhAoOHx8cDhxQh1Jguv/xTYI4XPcKAAyBwooPUFz//gePHAdg3P/6XBi3fpcMX/6XDT/yLA +FugAFg5BJMAD6AAWAEEA3QnwAcAAFgJAyXHf/wHm0H4B5QAUATHvDUSQE/AA3QzwABYBQQPqABYA +QQHAABYCQAHl1f8AFAEx6Q1kkCTCJMCF6AsJHgAAFgBBz3GArggA7HAgoAHI7HEAoelw2f/qCa// +AdgA2c9woABEHTWgTQXv/6XA8cABgBPoIwhQACMIkAAKIcAP63IF2IojRAlKJAAAsQGv/golAAEC +2ALwAdjPcaAAyBwJoUIKr/8U2Gnx8cAS6C0IUAAvCJAACiHAD+tyBdiKI8YASiQAAHUBr/4KJQAB +KdgSuPAgQAAAolHxFdgTuPrxK9gSuPjx8cBmDM//pcGLd+lwgf/pcN7/ABQAMQK4C+AEIIAPAAD8 +/wUggA+ArgAA7HEAoQHI7HEAoQAUATHscCCwCRSAMAfoz3CmAJw/GYD7CFGAIsAV6AAWDUEkwAPo +ABYAQQDeCPDscgHAqXHX/wHlsH0B5gAUATHvDkSQEfAA3QrwABYBQQTqABYAQexyAcDO/wHlABQB +MesNZJAkwiTAhegLCR4AABYAQelwi/+iCa//AdgA2c9woABEHTWgZfHxwKoL7/8B2AAWgUAAFopA +ABaHQAAWhkBEJr6DRCKCE8B4CiPAgcojYgAB44DiyiJBAMoiIgCA4MogwgHKICEAQNwEIguTGmJP +ehn0EmoM4AQggA8AAPz/BSCAD4CuAADsdQClAcjsdQCl7HUAHYIS7HBAqADa7HBAsOcLdAAA2Blw +OXOB4MojgQHKIcEByiOCAkQjggOC4kolQADCJUIBUiMAAMC4RCMNDJDlAdvAe6DlAd3AfQUlxBAA +Fg1AYbkveZfqIQl0AADfwIWA4ATlA/QAFg1ACwsREOxywKIB5+sPRJDAhQsLERDscsCiBiU+gRPy +HQl0AADaABYOQIDgwKUE5QP0ABYNQAHi7wpEgAAWAkBApQskQIEd8icJdAAA2gAWDkDghQPr534C +8OV+wKWA4ATlBPQAFg1AAeLnCkSAABYAQECFA+tHeALwRXgApUIhQxAtC3WAQCBAEA8LERAaCK// +AdgG8APZz3CgABQEJaAA2c9woABEHTWglQLP/+B4HQCP//HAJgrv/wDZSiQAcqggQAIAFgJAFSJA +MBoYmAAB4QAWDUAAFg5AJguP/89woAAUBKygz3CgANQL3KDiD0//VQLP/+B44cXhxiSIz3KAALA3 +pojCuS5iANkPIYEDz3OAAPxZdhMCBobtJnp2G5gAHfBFeXYbWAAliBUjjQN5HVgQJohFiFlhfB1Y +ECCAjCEQgET3iiEQACCgI7l3G1gAAIAquHgbGAAA2c9woADwNiygeRMBBiWgfBMBBiagehMBBieg +fRMBBiigexMBBimgfhMBBiqgdxMBBiugeBMBBi2gdhMBBiSgwcbgf8HF8cDhxaLBi3WpcGIPb/8C +2alw0v8aD0//lQHv/6LA4HjxwIjoz3CAANRb2gtv/yTZMwPP//HAAgnv/5hwkODKIcYPyiLGB8og +ZgHKI4YPAABUA9QFZv7KJSYEANpKJAB0z3aAANAEqCBAD0AsgwFVe8dzgACwSiCDz3WAAKhGQCxA +Ad25AGUgo/G40SEiggnyoIvPd4AAuDetZxcNkxDPdYAAsEkWJQ0RoI0LDR4QnrkV8C24wLgVJg8Q +44dSIU0CCydAkwzyz3WAAAiBhCgLCjAlQB7bCJ6Hn7kgowHiwQDP/+B48cBCCM//osEAFhFBABYA +QUApTSHHdYAAqEYAhS24Iwk0JFMgEgAKIcAP63IF2Ioj1QdKJEAADQVv/golQATPcIAAsEkWIEAE +GnA+Dm//AtnPcIAAMEoWIEAELg5v/wLZQCmTIQAjgC+AALBKGg5v/xDZi3ASDm//AdkAhQ8IXgLK +DU//FQDv/6LAACOAL4AAsErGCSAJENkBEIAgkODKIcoPyiLKB8ojig8AAIwFhgfq/8ogagFKJAB0 +ANmoIIEJFSNAIM9ygACwSjAiBQAEJY6PAAAAAQQcQDFE8iHDz3CAALg3BCWNDwYAAABBLUIUb2Cg +4/hi0SXhgg3yA+4bD5MQBCWEDwAAACQPDIEPAAAAJADbJPD/CtWADQqRAHvu8w+RkAPuzOM19gXu +Bw+SEPHtz3KAALBORpLbCsKDHw3eAs9zgAAIgYQqCyowI0IOBCK+jwAGAADd8wHbb3sE8AHYCHME +JYIPAQAAwC66z3WAAPw6SmVQcAHYwiANAIDjzCAigBHyAeECEIAgz3GAAAg4CGE9CFAACiHAD+ty +BdiKI9YIEPDPc4AACIGEKgsqMCNEDgohwA/rcgXYhQNv/oojFghKJEAAeQNv/kolAAADEIAgCGGC +4Mohwg/KIsIHyiOCDwAApQUF2O71KnBZ/89wgAAwShYgQARAkM9xAAAYFQkiQQAgsDzx4HjxwM9w +gADQBEoOb/8C2TIMT/9jAM//4HjhxTVoz3KAAKhGIWLPcoAACIEtucC5hCkLCjAiQQ5RIQCAz3GA +ABRzQYHFIoIPAAAKAsUiYQNKJAB0ANuoIIACNmh1eQAhjQ+AALBKQKUB4w7Zz3WAALBJFiUCECCq +ANthqgHZIqoD2SOqSiQAcWhxqCCAAbphFnpkqgHh4H/BxU0Hj/9JB4//8cAAFgBAz3GAAJAWAKEf +CFEAABYAQAy4BCCADwEAAPABoQAWAEACoRHwguAAFgBAC/RGIMIAQ6EAFgBAz3CgANAbXqAD8AAW +AEADzNdwAAAAQMohiw+ArggAyiGKDwCuCADscCCgAcjscQChLgpv/wHYANnPcKAARB01oFcHj//x +wOHFABYBQKHBQMEBFIAwDQgeAM9ygABYZQXwz3KAAHBlIKJgigHZB/AAFgBAFSJMAACkAeF9ePMI +RYARCx4AABYAQRUiTAAApAHhEwm1AQDdFSJMAAHh+wm0gaCkz3GArggA7HAgoAHI7HEAoYoKb/8C +is9woABEHbWgIQWv/6HA4HjxwAAWAEAAFgBAABYAQAAWAEDPcYCuCADscCCgAcjscQChdglv/wLY +ANnPcKAARB01oJ8Gj//gePHA4cXPdYAA0AQEbS4Mb/8I2QGFz3GgALgeAqEChQOhQgpP/70Ej//x +wOHFocEA3UDFABYBQAAWAEAfCVAAz3GArgwA7HAgoAHI7HEAoexwoKCpcBPwAg8gCYtwAdrPcYCu +EADscCCgAcjscQCh7HBAoADB7HAgoEhw5ghP/89woABEHbWgnvHxwNYLj/8KIACgWnEA3RbyCnEv +KEEATiCCB89woAAMLU968CCAAMK4DyUNEADYDyCAAAYhAYDv9c93oAAUBCbtLyhBA04gjgcZGpgz +9dgFuLIPL//JcRnIz3GgAGQuCqfwIREAKYdqDC//2thKcLYP4AQEIQEkfg2gAslwANgPIIADBiUN +kN71B9gSCOADGRoYMBnICqedA4//4HjxwEILr/8I2aLBARIONs91oAA4LhwVEBD+Cm//i3AAFAQw +AN8EJL6P8P8AAMohwg/KIsIHyiBiAcojgg8AAEoG9Aci/solwgBRJECCyiHCD8oiwgfKIGIByiOC +DwAATAbUByL+yiXCAOelmgvgCz/YAMAEFAExB6WCubv/HB0AFL4Ib/8BGpgzHQOv/6LA4HjhxeHG +AN7Pc6AAwC+lG5iDD90IvaMTAoakeowiEID88xQbmIMUG5iDoxMChgsiQIP89RS4BXmkG1iApBMA +hv8I3oc7Ac//4HjxwF4Kj/8H3c9woABULiuAz3egAMAvpRcSlhQXEZYvKEEATiCTB892oAAUBKqm +gNji//PYBbiA2VYOL/+fuRkSEDb12AW4Sg4v/6lxqqYZGlgzBPAD2AWmqYYb7XztQS2AkAryLyQJ +cOB4qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKggQAEAFoBA4Hiphujx89jSCm//BbjJCN+H9dgFuPIN +L/8KcRkaGDQoHgAUz3CgABgs8CDBBM9woABoLBUgwAQgoEArACHHcIAATFc1gFaAJXo3gBiARXkF +IESAyiHCD8oiwgfKIGIByiOCDwAA1AZsBiL+yiUiAIDZz3CgANAbMKClH5iUFB9YlK0Bj//gePHA +Ugmv/xfZt8FKIUAgAN6CDy//i3AMFJAwz3WAADQFTCAApMohxg/KIsYHyiBmAcojhg8AALADyiRG +BBAGJv7KJQYEIMDhCB8AEsDtuMohgSMF8s91gADkCM93gACoRkAoTiHAZ/5mUSBAgsohwQ/KIsEH +yiBhAcojgQ8AAL4DyiRhAMgFIf7KJQEEAcACwQpyWgvgAmZuhQgQAP/aR65KJABxANmoIIADKGUA +IYMPgAAoRhYjAwQEqyhlAeEAqw0UgDBFIMAADRwCMIog/w9TwACGqbgAphLAhiD7Dyi4DK5KJAB0 +ANioIEAC+2BAKEEhEOM7Y0CrAeABFIAwCK4CFIAwCa7PcIAAsAQVIEAEIIAPIQEEIKAB3wPwAt8K +cIT+DvBAKE4hx3aAAKhGAIZRIECCyidBFMonIhKB58YCAgAghs9wgACoChiIWnGGIvsvIwhQAIoI +wAsghhjoz3CAANyDDIgpCNEBQSlAAyEIHgATwBLCGQgeAoYi+w9BKgQCTI4JCgABqLhTwBAUADGG +IPMPQigRAhPAEsIGeUR4JXgApghxhiH7DxUKECCI6QpwANmKCOALD9oAhgDZz3KAAMhIFiICBCCi +IaILCF8FANmLuSGiDwieBQGChSABDgGiEBQAMeu4iiLDLwP0HhSSMA0UgDAfCF4BWBQAMQW2gODK +IAIEyiEiADQI4gvKIuIDDRSAMFEgAICv8gCGGQheA891gADkCIogVQIeCC//iiGQDxAUADF5CN8A +IIYtCd4C/9gHrkokAHEA2aggQAMoZQAhgg+AAChGFiICBASqKGUB4QCqWfAdCRIhCiHAD+tyBdiK +I1EESiRAANEDL/4KJUAE7rgHjjIlQRQAIYIvgAAoRhYiAgQI8iSqBNkAKUEEJXgHrjzwIKoPIEAE +YfAjChIkjCLDrxvyCiHAD+tyBdiKI9EJSiRAAIUDL/4KJYAEBgvgAotwEBQAMQ0IngMCFIEwKa4F +8AEUgTAoriCGNQneAgDYSiQAcQeuqCBAAwAggQ+AAChGFiEBBAQZggQAGYIEAeABFIAwCK4CFIAw +Ca4r8EwhAKHKIcoPyiLKB8ojig8AAIcEQAfq/8ogagHuuAeOACGBL4AAKEYWIQEECfIEGYIEBNkA +KUEEJngHrt7xABmCBADZDyFBBCZ4B64BFIAwCK4NFIAwNQheAFAUADECthToAN0Q2DpwApYRIECD +yiACBMohQgOkDqILyiJCA0IhQCDnCHWAAeUNFIAwDwgeASPAEgvgAlUUgTANFIAwPwjeADXBVhQC +MQpwbgvgAhLDuHCMIAKAyiHBD8oiwQfKIGEByiOBDwAA3wRgAiH+yiRhAFElwIHKJyIRCnAX/c9x +gK4IAOxwIKAByOxxAKFCCi//6XAA2c9woABEHTWgjQVv/7fA8cAuDW//AdmkwUohQCBeCy//gcAA +3lLwgsBSCy//AtkCwItyEg6gAgPBBCBABC8hB6BD8gDAANnPcoAAqEYPIQEABbgAYs9ygAA8BWCC +Mn8tuFMgEAAEJ8CQAKIG9IDjSA/iBsogIgggwDYK4AIQ2QDAAN01aAAhgg+AAKhGiiEIAKKyIKKp +cY4NoAsP2s9wgACwBBUgAAQggOR5IKAAwc9wgADISDZ4oKChoM9wgACoSDR4oLAB5iHAYQ4EkM9x +gK4IAOxwIKAByOxxAKE6Ci//KnC5BG//pMDgePHA2gyAAk4KD/9/Bk//4HjxwEYMT/+EKAsKz3GA +ALAE8CEOAAAhj3+AAOiASIcEIoEPgAAAAEQiAwIvuQa7JXsEIoEPAAEAAEEpTQMsuWV9JX3PcYAA +0AQVIRAADBAAIGENABAEIr6PgAEAAB/yz3CAANyDDIg3CNEBYgyACxfoCIe+uEQgAQIEIIIPgAAA +AAinBCCADwABAAAGuS+6QShNA0V5JX0suAV9DBhAIwruLymBA04hgAcQJg4Qp/z67vkDT//xwKLB +i3BiCy//CNkAwM9xgACcBAChCOgGFAAxA7EEFAAxArFqCQ//osDRwOB+4HjxwKTBi3AyCy//ENnP +cYCuCADscCCgAcjscQChAMBRIACAA8AG9ALBcgsgAwDaBfBGDOADAcEmCA//ANnPcKAARB01oKTA +0cDgfuB48cAaC0//Tgpv/wDef9jPd6AAyB8ZHxiQAdgIcQhyCg/v/Qhzz3CAABQAHwiAD4AAFAAK +IcAP63IF2F/biiSDD8kH7/24c891oADQD9WlVgsABjIND/9A2c9wnwC4/zKg4gsP/4DZz3CgABQE +LKAdHViQ7gzABc4JQAUODOAFyXDKD2AIA97PdaAArC8YhZq4GKUS8OB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB4Yb6MJv+f7vUYhbO4urgYpQfYSB8YkJoJz/62C0AIOgtACE4IAAkahcC4 +geAB2MB4LyYH8AXyigmgCAHeBfAD3hiFmrgYpQYJz/6eCoACEg7AAs9wgAA0BXoOoAIE2SYPgAKW +D8AC6g4AB3oLgAZeC8AKtgqAC14PD/6KIMYNz3GAAKgKDbED2G0ZAgAb2c9wgABMcsYKYAEwqLYJ +wASGCk//ZgwACF4IQAkSDu/+yXAdAk//4H7geOB+4HjgfuB44H7geOB+4HjgfuB48cAKIcAP63IF +2FrbiiSDD3kG7/24c+B48cB+CU//GnAod891gACoChSVz3aAAMBOELieCWAHAKaA4MonIhDPcYCu +5AHscCCg7HEAGQAECIULCB4AAIaBuACmz3CAALQGAIiF6ACGg7gAps9woAAsIBCAANptHhgQHe8A +hmIWDxbJc2MWBBaAuACmSHEG8Ox1AKUEG5AAAeH34QCDuffPcaAA1AsNoUCjYh7YE2MeGBEP8Mlz +SHUG8OxxAKEE4wHl9+UAg7r3z3GgANQLDaEtAW//1B6AEOB48cDhxaHBCHXSCS/+E9jPcIAA5AQA +gKToz3CgANQLGIAA2UIgAAiA4MogTACMIAeKSPfPcYAAaBYJgQHgCaEQ8J3YABwEMA/MAhwEMAHg +EHiPuA8aHDAAwKlxuv/OD4AE2QBv/6HA4HgA2Mzx8cDhxQAWDUAByFMlARCy/1ElQJDPcYAA5AQB +2MogIQCtAG//AKHgePHA4cXPc6cAFEgA2SijB4PPcoAA+FsfohCDz3WnADREgBoAAM9w8w///Cej +EKOg2Jq4NqP1HRgQz3ClAAgMCBAFAEwlAIDKIcIPyiLCB8ogYgHKI4IPAAAkA8QE4v3KJCIAz3Ok +ALg9mxMNBruiphMNBryikhMNBr2ioxMNBr6iUN2ioJsbWAD/2KYbGACSGxgAoxsYAM9zpADs/89w +AAD//yejBqMB2M91oADIHBGliiDEAM9zoADsJwajCoNkGgQAiiDNAAajCoNmGgQAz3AoAAIBBqOK +II0ABqMxpckHD//gePHA4cUIcgHdgOHKIcEPyiLBB8ogYQHKI4EPAADEAMokIQAYBOH9yiUBAYDi +RPZTeool/x8JCRMAM3mzfRQhgAACCiAFO3mseHkHL/8vcOB48cDiDg//enCacRpyOnMKJQAhANrP +casAoP9ZoQfYGqFYoSDfz3WgAMgf8KUB3kMdmBMA2G4M7/6NuPGlz3CnAJhH2qAuDqAIHtjPcacA +FEgdgd6B+4FwERIAABgAIAAZgCP3uMUggg8A/wAA0yDhBfe+xSaCHwD/AADTJuEViiEQAMz/CHXJ +cIohEADJ/wh2QC8AEoohCADG/wh3QCoAIoohCADD/7F5GeEseS9x0XoZ4kx6L3IAG0AjDw9iEAAc +gCMA2ATw/wiDgAHYZQYv/wAdAiDxwCYOL/8A2c9zoAC0D7yDPKPPcIAA+FtkEAIBELpPIk4AiL7P +cqAA7CfGomYQDgEQvoUmjRDGot+Az3enABRIx6eAEA4A0KfPdqUACAwipvuAz3akALg9mx7YE/yA +ph7YE/2Akh7YEx6Aox4YEM9wpADs/yagiiCKAAaivKMGC+ABAdgJBg//8cB2DQ//z3CAALBOB4iA +4HAEIQCrwc9wqwCg/2QQFwDPcKsAoP9oEBgAz3CrAKD/YBAZAAfeT/8A2c9wqwCg/zmg2qA4oC4P +IAgB2ADYz3GnABRIDKENoQ6hD6HPcAAAASrPdaAA7CcGpc9wpQDoD8egz3egAMgfINgQpwXYQx8Y +EADYwgrv/o24INgRpwHZz3CgALQPPKDPcAAAAi8Gpc9wAADCMAalz3AAAEJIBqXPcAAAAkoGpc9w +AAACYgalz3AAAMJjBqVKIwAgz3CAALBOJJAFkEQpvgcYYBV4FSPBJCdwGWHHcYAAoBYDEZIABBGU +AAERkAACEZYAAIkQuAUggA8AAEItBqUAiRC4BSCADwAAgkYGpQCJELgFIIAPAABCYAalINgQpwXY +Qx8YEADYFgrv/o24INgRpwDYEPDPcIAAeFoWIEAERBiAASGGSBhAATegWKBAIUAgOnDPcIAAsE4G +kDJwggIOAM9xpwAUSFwZQARAKAAkTyBBAIe5ibkmpQhxhSGLACalhSCMAAalQCQVOicJECA7CVAg +TwmRIEAqACQFIIEPAACCYCalBSCADwAAQmIY8EAqACQFIIEPAACCLSalBSCADwAAQi8M8EAqACQF +IIEPAADCRialBSCADwAAgkgGpSDYEKcF2EMfGBAA2FIJ7/6NuCDYEaeLcIHBiMKJwwokQAUm/wjB +QClAIQAgjg+AAPxZCcAgpgGmAMAYpgHAGaZALgAkhSCKAAalINgQpwXYQx8YEADYBgnv/o24INgR +p4LAg8GIwonDCiRABRT/CMACpgnAA6YCwBqmA8AbpiUJECA5CVAgTQmRIEAsACQFIIEPAACCYCal +BSCADwAAQmIZ8EAsACQFIIEPAACCLSalBSCADwAAQi8N8EAsACQFIIEPAADCRialBSCADwAAgkgG +pSDYEKcF2EMfGBAA2H4I7/6NuCDYEaeEwIXBiMKJwwokQAXy/gjABqYJwAemBMAepgXAH6Yg2BCn +BdhDHxgQANhKCO/+jbgg2BGnQCgAJIUgigAGpYbAh8GIwonDCiRABeL+CMAGwwSmCcB8pgWmB8AA +wR2mAsACIEIABMFbYwIjRYA68iJ4THgvcKhxw/4CwUArjiDUfhUmThQCecd2gAD4WwHAA8IhpgfD +AiIBAAXAO2MCIwWAKvICeix6L3Cocbb+A8EEwwIhAgACwEemAiMGgDQegBEh8gXAAiBFgKgF4v9M +HkARCiHAD+tyBdiKI0UNCPAKIcAP63IF2IojhQrRBq/9iiSDDwohwA/rcgXYiiOFC/bxCiHAD+ty +BdiKI4UMiiSDD60Gr/0KJYABQCNTIEwjgKDcBMX/ANjPcaAAtA8cod7+6nDPcasAoP8ZoWgZAAZg +GUAGSiQAcQDYqCAADQhxgCGCDTB5BrmBuZe5JqUIcYAhQg8weQa5gbmXuSalCHGAIcQGMHkGuYG5 +l7kmpQhxgCGECDB5BrmBuZe5JqUIcYAhhgAweQa5gbmXuSalCHGAIUYCMHkGuYG5l7kmpQHgNQEv +/6vA4HjxwAYJL/+YcKHBz3KAAOgEIIrPc4AA+FsBgoQTAwCQccwgwYDp8hEIwADPcIAAEF0hiCCq +SiTAcEogABCoIMACz3CAABBdMiAAAgsIAAFAIEgQTCDAkKIBBgDPcIAAEF0BiBEIAQEEIQEBLyVH +AAbwByAAAS8lBwBhogDbz3CgALQPcBASAHygABoCARTwQCCAIRB4BriBuEApASQleAamQCOBETB5 +BrmBuUAqABQleAamAePPcIAAsE4GkBBzMAEGAADZDyHBAAshQIEB2MonAgAN9AshAIHt889wgAAQ +XQGI0wgAgQonAAIS69ELUAAPC5EAiiCGIIohRgIL8AohwA/rcgXYiiOPA2Xwttq92RpyeXHPdqAA +7CdKIQAgSiQAcQoiQBQqdaggQQIAIEEjVGtALwABFHgaYrV6x3KAAHBcCJIweUApiQFPIUEQHH8Q +v+V5JqbAuLh4BSBABC8hCCAAI08TCZLwfwa/TydGEBx5QCkTBAUjgSEmpsC4uHgFIIECLyJIEEUh +wBAGpgqGi3EAsQiSLyYBAAAUADErCIEBRSfPEOamCoYAsQmSABQBMRx4KwhBAAHla/GKIsQGiiGE +CKbxCiHAD+tyBdiKI48ISiQAADEEr/0KJQABCiHAD+tyBdiKIw8J9fHPcaAAtA9wGYAEaQfv/qHA +ANnPcIAAEF0gqCGo4H8iqPHA4g7P/q7Bz3CAAKgKCIDPdYAAoBbAuEDAz3CAALBOJJAFkEQpvgcA +wRhgFXgncDV5OGAZZSOJQcEZZSSJuGACiELBQ8DPcIAA+FtqEAEBz3CAALAGQJBKJAAgUQmBAM9x +gABMcg2JhiD/AXtoz3CAABBdwIgCI4ODzokvicojYgCGJv8R+27BiAKIhiH/AUO5DibOk8omYhAO +IECA237KIGIAxXsCuGV4A/AH2IDglgMhAETAz3CgALRHRxAAhoDghgMBAM9xgABMcg2Jz3OAABBd +hiD/AUO4AKsOiYYg/wFDuAGrD4kA2Z65hiD/AUO4AqvPcIAA+FtqGIQAz3CgALRHUxhYgHX9z3CA +ALBOJJAFkM93oADsJ0QpvgcAwRhgFXgncDV5OGAJZRC5BSGBDwAAQi0mpwllELkFIYEPAACCRian +CGUQuAUggA8AAEJgBqfPcKcAFEgMgM9xDwAA/M92gAD4W0XAAMACuBR4ACYEEB1mG2YaZgAmBRAe +ZgmGBBQEAKeFBcZIgmKDDBUFACDuQCyOAiR+yb2lfs91pwAUSM2lCrtkecm6RXnPcqcAFEguokAt +gQIEIYEPDwAA/Mm4BXnPcKcAFEgvoB/wCr0kfYh2yb7Ffc92pwAUSK2mCrpEecm7ZXnPcqcAFEgu +ogq4BCCBDw8AAPyocMm4JXjPcacAFEgPoUogACAD2EbACiIAJQTAESAAhAACAQDPcYAAEF0yIQAE +AnFHwc9xoAC0R2AZGIAQuJu4z3GAAAhzIImfuIDhAdnAeQ+5JXjPcaAAtEdfGRiAz3CgALRHcRAA +hgQggA8OAAAAMbjvCFCAAN0C8AHlz3CAALBOBpAQdZwBBgAHwACI7whOgwHBAsACIFkAAMACuBR4 +SMDPcKcAFEi3oAvtHQ1QECUNkRCKIIYAiiFGAgrwiiSCLYoiQi8I8IogxAaKIYQImnBacUojACFq +dkAtWBFhvgPBFW4leBB4ELiFIIoABqcAJgAVEHgGuIG4l7gGpwAmgBQQeAa4gbiXuAanQCSAIRB4 +BriBuAanQCKAIRB4BriBuAanQCQEPYnAisGLwozDOf0twI3oz3CAAPhbaBAAAc9xgAD4WwHgEHho +GQQABcAR6InAIICKwECAicBAoIrAIKCMwUCBi8AAgIvBQKGMwQChFiCAMwnBACCWD4AA/FkKwPAe +QCD0HgAgCCGAD///Af8vJUAmBC0+IAjAFSBRAwAhgC+AAPhbLYAvcAb9DiCXDwAAAAEKwIggfAAE +KH4FACGAL4AA+FszgC9w/vwOIIIPAAAAAQkngS8AAP8BCSKADwAA/wFIIQEASCAAAC3CVB5YIFUe +GCAbClEAVG1AKAMhdHt6YtV6x3KAAHBcKLIJskIjUyBMIwCgxgbN/y/xBsBhuIDgQCBQIPIF7f9G +wC79z3CgALRHcRAAhgQggA8OAAAAMbjvCFCA3QLv/q7A8cChwYtwigqv/gTZAMBRIACAEA2C/wDA +USBAgJgLwv8AwFEggIAICsIIAMBRIMCAbAzCCOYPYAEB2M9xgK7gAexwIKAByOxxAKHPcoAA/FmK +JIF9ANmoIAAC8CJDAOxwYKAB4U4Pb/4A2KHA0cDgfvHATgrP/s9wpQDoDweAz3KkAAxCUyAEgEQg +jQBEIAMBAoLPdg8AAPwIccm5xHjjgiq42HfEf0EvhRLkglMmRgLpcsm65H4qvgbyDQmUB4whT4jE +9wDZA/AB2QsMEAALCJUHANgF8IwgT4g99wHYG3gleATtCQ6VBwDZBvCMJk+IPPcB2QK5BXkD7QsN +lQcA2AXwjCVPiD33AdgDuAV5BOsJCpUHANgG8IwiT4g89wHYBLgFeQPrCw6VFwDYBfCMJk+YPfcB +2AW4JXhCIACA6QHv/sogYgDgePHAegnP/sn/h+jPcIAAhAUAgJ8IVAHPcqAArC8agsC4geAB2MB4 +LyYH8ADdQfLPcIAA8FwpgM92gAAwcwHhYIYpoCOGNXgG6yqAAeEqoAXwOIAB4TigGIKauBiigP4Y +grO4urgYomoIAAihpp4PYAGips9woAB4RQCABCCADw4AAAAxuO8IUIDPcYAAqApIgTSRUyIAADYP +L/4B22IOgAcH6KL/BejWCa/9DtgE8OIJr/0O2DEBz/7xwKHBAdhAwM9wgAD8FgqAUSAAgMogAgfK +IoIPAABnAJgMYv7KISIBocDRwOB+4HihwfHAigjP/qPBCHZHwM91gAD8FhqF+4U8hQR/JH/Hf0HH +Wglv/oog2ASKINgETglv/slxqQ8QEAQUATEY6RwUADELIECADfLPcIAAaAVggM9xAACkWQzYYHsD +2gjwiOjPcIAAbAUggGB5DNgGFAExGOkeFAAxCyBAgA3yz3CAAGgFYIDPcQAApFkN2GB7BNoI8Ijo +z3CAAGwFIIBgeQ3YCyeAkwvy7giv/QXYiiDYBMoIb/6KIYgEEfCR7oog2AS6CG/+iiGIBd4Ir/0F +2IogGASqCG/+6XG+/9ylCNwbAO/+o8DxwKIPj/4IdwWBQIEA3SDeyLgQuMi6BSCQAAGBJoHIuMi5 +ELkFIREAANgPIEADCyAAhAzy8CdBEwjpBCBABEIgAIBgecogYgBhvuEOdZAB5bEHj/7xwFYPj/7P +dYAA/BYlhUCFyLnIukApAwQFI4OARoUhhci6ELrIuQUiRgBHhSKFyLoQusi5BSJFAEiFI4XIusi5 +ELoFIkQAI/IvKcEA4IBOIY4HANoPIoIDUn4EIoEBxH8lf+Cg+oXEf+V5OqU5hQQiDwEEIkIBxHnl +eTmlOIXEeQQjg4NFeTil4PU1B4/+4HjxwL4Oj/6iwc91gAD8FjqFG4UkeDyFVSVOFwQhEACWDy/+ +iiCYA0ohACBVCBAgEQkVKBEgQKTAIWEg+/PwJkAUXB1AFIDgyiHBD8oiwQfKIGEByiOBDwAARQLK +JAEEWANh/colQQRAeIogmANGDy/+KnEA2A8gQAQGIBAgCnBv/4ogmAMuDy/+PIWVBq/+osDxwC4O +j/6nwTpxGnJAwADYYcAB2AUcAjAGHAIwi3AiDmAIgsEFwQpwIyBABAbCBMCM6AohwA/rcgXYiiOE +Bookww/lAm/9uHNAeEUGr/6nwPHA4g2P/hpwKHVId2h2OGP+CG/+ZtkXCFEACnB6D2/+qXHpcJYJ +b/7JcR0Gj/7gePHA4cWjwQHYQMDPdYAA/BapcHYNb/5c2TqFG4UkeDyFBHmBwEHBj/8BwDuFBHlB +wXIOL/6KIFgEVSVAH6lxdP/PcIAAdBhAJQEbcf+LcDIPb/4E2QHANf8AhYboBYWA4JgMwf/JBa/+ +o8DgePHASg2P/gh2AN2KINgDKg4v/slxz3CAAPwWWoA7gER5ANoPIoIDBCJDAEIjA4DKI2IALybH +8AHfyiBBAwbyHIAkeEV4Hv/pcGkFj/7gfwDYz3KAAPwKVIpZYTB5QWkNCgMAIngQeAPwAtjPcaAA +yB8eoRDYDqEB2BUZGIDgfuB48cDKDI/+AN/PdaAA0A/1pQPeEvDgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeGG+jCb/n+71A9gapc9wgAD8Cu+oAdgVpeUEj/7xwHoMr/4F2ADdC7ipcd3/ +z3GAAMheHoGxCN4CHYGtCB4AHghP/QDZnLnPcKAA0BswoAHZz3CkAJhAPKAEIL7PMAAAAAHlyiUi +EEkLH0ALCF5FTwmeQx0I3kUZCZ5Dz3CqAAAEAYCGID8LNwjQANH/IN/PdqAAyB/wpgHYQx4YEADY +oglv/o248aa1DRSRCfDI/89xgAA0UAmBAeAJoQDZHwgeRwDaz3CgANAbnLpQoM9wgAC8BECAEIIB +4BCiz3CkAJhAPKA68HYPD/1tCF9FUSAAxQHlyiUiEM92oADIHyDfHwsfQPCmAdhDHhgQANgyCW/+ +jbjxpkENFRHo8c91oADQDwDYFaXwpgHYQx4YEADYEglv/o24A9jxphqlANjPcYAA/AoPqc9xgAA0 +UAmBAeAJoQHYFaWpA4/+8cA+C4/+z3GgAPxEBYEA3891oADQD7y4BaH1pQPeEvDgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeGG+jCb/n+71A9k6pc9wgAD8Cu+oOqUB2BWlz3GAAMheHYGA +uB2hmP92CEACOQOP/vHA4cXPcqAA0A+wgs9wgAD8Ci+IANsPDUEQA9k6om+oAvDc/yEDj/4A289y +oADEJ4ogGAg8GsCAz3GgAMgfDqGAEQAAUSBAgM9wgAB8ZwzyQhIChgQivo8AwAAABPJBgALqQqCA +GcAA4H9hoBDMBCC+jwAAKEBD8kEI3gAREgI3gNjPcYAAuE8QGhwwDQreAhiBAeAYoQXwEIEB4BCh +EQrfAADZz3CgACwgL6ARzEYggALgfxEaHDAvCF4BiiAEABAaHDDPcYAAuE8PgQHgD6ERzADZRiCA +AhEaHDDPcKAALCAvoOB+BNgQGhwwz3GAAOwVHoEB4OB/HqHgfvHAzgmP/gDdINjPdoAA9GTuCSAF +AKbPcKAAyB8B2TOgWIB5gDWA+BAAAEAmEBXPd4AAyF5MH0QTAnkCIgKAI6bPcYAAqAoDI0MDQaZi +phSRUB9EEyiBCba9tlMhAAAIts9ypQAIDECCTh9EE1MiRQFTIkMASB9CEYPjyiHBD8oiwQfKI4EP +AABJDcokgQ8AAP4AMAYh/cogYQEEIoMPAAAA4EWmXoctu5YfwhAZCt4CBLuBu2V4CLYH2AfwFSAM +IKCkA/AE2AHg9QgUguu5iApCBB6HqXcruFMgEABRIIDFq/KA56n0QSmAQ8C4EnAB38onIhDKJWIQ +z3GAAPwKD4kB4A94D6nPcaAAtA83gQDeEwhBAM9woACoIAaAjCCDjsv3AN9c/89wgAC8BCCAAd0I +gQHgCKGA53/yz3GAAPRkBYHPcqQAkEEEIIAPAAAA4EEoRAMVgnaCuHNooc9zgADIXgehCwweAEwb +BAAI8EwbhAMEIIAP//8AAAehDQxeADC4ThsEAAbwThuEAxB4B6ELDJ4AUBtEAQjwUBuEAwQlgA// +/wAACKENggahBCCADwAAAP4puFIbBAAeg0MI3gLPcKoAAAQEgAmhz3CAAFhlQIhAIAQBMepZCnQA +AhCFAPQkgwMV2BO48CDDAM9wgAAwZdV4AebtDqSQYKAa8M9wgABwZUCIQCAEARfqJQp0AAIQhQD0 +JIMDKdgSuPAgwwDPcIAAMGXVeAHm7Q6kkGCgQakCGUIBmO8EIL7PYAAAABL0z3CAALwEIIAB3QGB +YbgBoQeBAeAHoYoghQdiCC/+EBIBNykLHkAA3wv/iiDFB04IL/7pcc9wgAC8BCCAAd0BgWG4AaEH +gQHgB6EEIL7PgAEAAMwnIpDMJSGQIPPPcKAAMBADgADZCujPcIAAvARAgAHdKHcMggHgDKIU7QLZ +z3CgAMgcKqAq/89wgADIXkDZPaAQzIYg+Y8G9ADYj7gQGhwwTQdv/ulw4HjhxTDbAN3PcKAAyBxp +oAPaz3GgAMwXIRmYgE6hp6BqoOB/wcXxwOHFz3GAAOwVDoEB4A6hz3GgAMQnGREAhgDaBOgC2BAZ +GIDPdaAA1AtXpQ3/z3GAAMheHYGHuB2h6f8QhQ3oA9gRpeB44HjgeOB44HgRpc3+6QZP/gohwA/r +cgXYz3MAAL4JSiQAAEkDL/0KJQAB8cCRCR9Gz3CgAAwkB4CFCBAAz3CAAERfC4DPcaAAyB9k4B6h +ENgOoQHYFRkYgM4LL/4L2F0JH0YA2kMIXkfPcaAA1AsWgTiBJOAZCEUACwkfRv8LHsAnCx9AIwif +RBrwANnPcKAA/ESeuSGgRaDPcYAA7BUPgQHgD6HPcJ8AuP9cGMAIz3CfALj/XBgACMH/0cDgfvHA +vg1P/gh1z3aAAMheHYYvJgjwO/QlDR8QgrjPcYAAvARAgR2mA4IB4AOiIIGKIEUJeg7v/SOBHYYl +DV8QhLjPcoAAvAQggh2mBIEB4AShIIKKIIUJVg7v/SSBz3CgAAwkA4BRIMCAHYYR8oS4z3KAALwE +IIIdpgWBAeAFoSCCiiCFCSYO7/0lgT2GLyZI8ADfD/QKIcAP63IF2M9zAAATCYokgw8JAi/9SiUA +AM91oADQDxEVAJbHCBAARCF+ghHyLwkeAM9ygAC8BCCCAoEB4AKhIIKKIEUI0g3v/SKBB/ApCR4B +ov8dhpMI3wHPcKAAxCcZEACGBugC2c9woACQIz2gX/4b8Jn/HYZvCN8BOYXpcgXwABEAUAHiT3pB +KYAA9woEgADaBfAAEYBQAeJPelMhQAD3CgSAA9gSHRiQ4HjgeOB44HjgeBIdGJCE/h6GFwjeBM9w +gADsa+uoz3CAAIBr7LDPcAAA/z/PcaAADCQBoRvYBKFY/60ET/4KIcAP63LPcwAAWgkF2Ivx4Hjx +wOHFUN0A2s9zoADIH6+jXqMCIEIAXqMB2hUbmIBA2k6jBCC+zwACABAMD4H/eQRP/uB48cD6C0/+ +z3CAAMheMYAlCV4Cz3GAAPwKLolEEIIARHlRIYCASNrKIoEPAACQAAPwDtoA289xoACoICeBqBAN +AFlhsXHCJUUQyiXmErB4Ctms/VL+z3CAANwbAJDPdqAAxCcNCB4BjCUDkgT3AN8U8M9woAC0D3yg +z3CrAKD/eqBaDuAHANgZFgCWBegC2BAeGJAB3xkWAJap6FMJH0bPcIAAyF4RgA8IHgIPzGG4Dxoc +MAPZz3CgANQLMaDgeOB44HjgeOB4MaDPcYAA7BUUgWq9AeAUoRWBuGAVocYIL/4B2HYIIAEB2PX9 +eQNv/ulw4cXhxsDYz3GAAPRkQYkcGgIwEmpH4AQggA8AAPz/l7jscwCjB8jscwCjD8wA3UokwHMB +4BB4j7gQew8aHDDPcKAAiCR+oKlwqCDAAfAhDgDsc8CjAeAdCnQAANnPcIAAMGXwIEMA7HBgoAHh +8QmEgM9woADUC62gAdjBxuB/wcXB2BwaAjDPcYAAyF4Wgc9ygACoCniKDOCG4wHbwiPBABggwAAD +4AQggA8AAPz/l7iduJ+47HMAowfI7HMAoxiKNoGG4AHYwiABABghAQDscCCg4H8B2OB48cDhxc9y +gADIXhaCz3GAAJxnDQgQBlQSgAAF6BmCuoID8BuCvIJRgs9z/v//P2R4pHsEIoIPAAAAEEV4AKEA +2AGhZXpKoQ7aS6HPcYAA6ICaCEABXgqACgfoz3GAANCDighgAQHYRQJP/uB48cDKCW/+G9jPdqAA +xCcVFg2WFh4YkAPZz3CgANQLMaDgeOB44HjgeOB4MaCKIAQMggrv/QDZzP0lDR4Rz3CAALwEIIAR +gQHgEaGQ/RkWAJYE6ALYEB4YkKL+JvBSFgCWUyBBAIPh0SXhkATy5/4c8M9wgAC8BCCABoEB4Aah +z3CAAMheHoATCJ4DAdnPcIAAcAUgoAjwEQjeAwHZz3CAAHQFIKCRAU/+8cAiCW/+ANrPcAAA/z/P +daAAxCcTHRiQG9gWHRiQAdgQHRiQz3aAAMheEYYmCSACNoaoHgAQpv4dhgsI3gEA2B/wLRUBllaG +DwpAAIC4HaYA2MT+9fEEJYFfAABwxx6GJXgephEVAJYNCB4Az3AAAAR7B/APCF4Cz3AAAGx5EQFP +/jMI3gAI2BMdGJAm/9noAtg8HQCQIRUBls9wgAB8ZyGgERUAlg8InwCJ/h2GkwjfgREVBZYbDZ8A +CiHAD+tyBdiKIwYASQXv/Iokgw8E2BMdGJCh/7Xx8cA6CG/+ANnPcoAAyF49oj6iVBpCAD+igNiU +GgIAgBpAAKgaQADPcIAALGo5oM9wgACIZyCgz3CgAAQlNKAw2c9woABQDCKgCwhfRi/9gQBAAFT9 +gNnPcKAAsB83oDagz3aAAMhez3GAAMBOz3WAAKgKPQmeQwDYi7geps9wgAC8BFThIKAblRy2HZWS +HgQQiiCEDh62iiBEC5oI7/0A2QbZz3CgAMgcKaAU8M9wgAC8BAThIKAalRy2HJWSHgQQThUAER62 +iiCEC2oI7/0A2c9xgAC8BECBAIIB4ACiIIEBgQHgAaH62ADZmfxi/YDg3AcBAM9woAAMJM9xAAD/ +PyGgz3CgANAPERAAhgzoCiHAD+tyBdiKI84DiiSDDxkE7/y4cwHZz3CgANAPERhYgGgVgRAclgIg +UAAehuu4BAIhAC8gCCQA2EAeBBDPcqoAAAQCgs9xpQAIDGCBBCCBDwAAAP8ouQQjgw8AAADge3uJ +uWV5aIUEI76PAAYAADGmA/KMuTGmz3OAAPRkDKMtoyCCRBaPEJTnKqMa8gX2NQ+REiO5DfAfD9Ad +7ucS9EUp/gJBKcFwUSDAgcIhYgAA2ArwRSn+AkEpAXH78SK5+fEA2QHYNqZBgjyzS6PkusogYgDh +usogYQCGIv4PJLrok0keghAdpuV6SLNVIUMFz3IAAGQPCSOCAAkIHgAA2DjwGwmUA5wVAxATC0QA +z3OgANAPgBMDABUJwACAuB2mBg+v/YogBQjs8c9woADQDxkQAIZCIAAISCAAADMIhQDPcZ8AuP8Y +gZC4GKEYgbC4GKEdhoO4HabPcIAAvAQggIogxQjCDq/9JYHK8QHYiOjPdaAA1AsA2AH+QQYAAApw +ANli/mIVgBBEFoIQz3OAAKCBBCCEAIYi/wNEJAEBRLpZYcG5K2OJu3umbBaNEEkWgxAEJQ8QhiX/ +E2R/RL2/Z891gACwOPQlzxNeHsQTz3eAAIiEKWeJuTymcBaBECR4hiH/A2R4RLk4YPQlABAEIwMB +YB4EEBGGemLPcYAA0Dj0IYMAGabPcYAA4Dj0IYEAih7EEBqmjB7EEI4eRBCQHkQQANjPdaAA1Avv +BCAASh4CEM9wpgAIBAGABCCADzAAAAA0uEAeBBBAFgERGwhfRs9woACoIAiAGWEweeYPb/8KcAPw +CnAp/gQggE+AAQAAANkxCIEPAAEAAM9ygAD0ZEAeRBBJHkIQNqYpopYWgRAB2EoeAhAIkgS5ibkl +eAiy1/BJHkIQz3CmAIwDXYDPdYAAyF4EIoEPOAAAAEEpwASWHgIQBCKADwAAAPAsuCW5JXgRpg0I +3kcRhYy4EaVTIsECRBWEEDalUSQAgNEi4ocA2AL0AdjPc4AA9GRJo5YVghDIkwS6xXpIs9GFPLNT +JMIAXHrPd4AAkIFPZx2l+6VsFY8Qw78vJcEDz3eAAMRl9CdPEc2jXh3EE893gAB4hE9n2aX8pXAV +jxDDvy8lwQPPd4AAxGX0J08R2qVgHcQTz3eAAORl9CeFEM93gAD0ZfQnghCKHUQRjB1EEY4dhBCQ +HYQQz3KmAIwDXYIEIo8PAQAAADC/Sh3CE0mjShWCEADeEuoXDFADgLgdpYogRQh2DK/9iiHQBx2F +USAAgJf0AwgeRkXwVSFDBc9yAABkDwkjggDPc6AA0A8JCB4AANg18BkJlAPPd4AAJAvohw0PRBCA +Ew8AEwnAA4C4HaUmDK/9iiAFCOzxGRMAhkIgAAiA4MogjAMxCIUAz3GfALj/GIGQuBihGIGwuBih +HYWDuB2lz3CAALwEIICKIMUI5guv/SWBzvEB2KcIEADPdoAAyF5KFoAQz3WgANQLgOC6AgEAiiDF +AL4Lr/2KIZEBz3GmANQELBEAgDQREYA4EQ+AyxESBipxxrnpcoYi/Q8GukV5KnKGIv0PBLpFeQQg +gg8CAAAAJ7pFeUQnAhwNukV56XKGIvMPBCCADzgAAAAOukV5JbgleEQngRAUuSV4RCcBEoi4UiBA +BUEpwYARplQeQhAM8s9xAAD//wvwANgj/c91oADUC8UCAADPcQAAEB8acTaGP7YEIYEv/wMA/yi5 +NqZaCuABANqYcKgeABBxD54URBaDEBGGoOPRIOGCMPIEIIKPAAAAAQjyz3GAALg3aWEVCZMABCCB +DwAAACRBCYAPAAAAJAQghQ8GAAAAQS1BBC0J1QATCZEAEurPcYAAuDdpYR0JkQAE6szjCvY2hhEI +RCDPcQEAiA0dCQUBFQ4FcQEAiA3PcYAA7BUWgQHgFqEB2h/wz3GAALg3aWEF6gsJkgAtDREAz3KA +ALBORpIhCkIAGQjeAs9wgACoCgiABCC+jwAGAAAE8gDaA/AC2s9zgAD0ZCgbQATro1QWjxAwG4AE +F28ok4i4JXg2hgizEYY8s4DhDaNdptjyz3KAAJwEQIKA4swnIpAc8gDZjblOCeABINrPcYAAnAQj +kQIgTwARhjaGNgngASDaFw8lEAhxEL/PcAAAeB4ODa/95Xk2hs9woADQD4AQAAAZCQAAHYbPcoAA +uE+AuB2mAIIB4ACiVBaAEFThDOiJIZkEWCFCBM9woADQDyIYmIAH8M9wAABkDwkhAQDPcKAA0A8Z +EACGQiAACEggAAA7CEUAz3GfALj/GIGQuBihGIGwuBihHYaDuB2mz3CAALwEIICKIMUIUgmv/SWB +z3GAALhPAoEB4AKhHYZEIP6CFPKGIL+NCvKKIMULLgmv/YohkgF5As//z3GAALhPCYEB4AmhDP1W +8KIOgANS8ELZz3CgAHgmMqA2hhsJkQMRzFMgQIAH8s9wgACoCgmAZQheAFThGIVCIAAISCAAAD8I +RQDPcZ8AuP8Ygc91gAC8BJC4GKEYgbC4GKEdhiCFg7gdpoogxQi2CK/9JYEghQWBAeAFoQDYf/we +8Cv9Sv0QzIYg/4UF8gLIAYAJCF4HXP2g/QomAJAL9APYEaXgeOB44HjgeOB4EaUE8MIMAAdAfgDY +EKXJB8/9z3GAAERfK4HPcqAAyB9k4T6iENkuogHZFRpYgCGAhOn9Cx7AIYDBuRcJ0QDPcIAAvAQg +gAaBAeAGoQDYFPAhgBEJHwDPcoAAyF49goK5PaIBgBMIXwDPcYAAyF4dgYS4HaEB2OB+4HjxwM9w +gABwZdIJr/0Y2c9wgABYZcYJr/0Y2TUBj//geAHaANnPcKAAtA9coM9wgAA0UCmg8Qev/BTY4Hih +wfHAtg7P/aHBCHZacs9wgAAYbAaAANqB4AHYwHhAwUAoFAOBDhAQz3CAAMhelBCBABUJ3wHPcoAA +qEYFuSJiLbrAuslxhiH8AIwhAoVUeA/0z3GAADgFIIEPCZ4AIN2OEA8BCPCY3YoQDwEE8F4QDwEO +3YoghQBGD2/9qXGKIIUAPg9v/elxz3CAAIhnAIBRIACAwCUiEbB6LyDII0olQCAI8M9wgACIZ0Cg +unIacgISASFAIAAlEwhDAAIhAQRIIQEALyNIIAPwSiMAIADBAN2pcApzigkgAph1CiEAoBr0GQgf +Q89woAD8RB2ABCC+jyAGAAD381EgAMMA2Ar0z3GAAOwVCYEB4AmhANiYuDpwAN1MIQCgAN+S9Ewl +AKDPd4AAiGeip4XyAId1CB4Az3GAAABfTInPcYAAuDcyIYUAQQ1lER/YqXLPcwMAFABWe89xowCw +/1DjMCNEAM9zAwAYAFZ7UOMhYwHiLytBAC8pAQEiexBzyiDFAM8KRIFPJNQjQC1BAUIhAQgZYc9w +gAAsOyhgIYcJuCV4pXgCpwUkgCMNcQCxDXAAGMQEDBIBIA1wIKAQEgEhDXAgsIoghQD+DW/9yXGM +JgKVE/KMJgORHPKMJgOVIPIKIcAP63IF2M9zAAD+C4okgw/VAa/8uHPPcIAAvAQggA+BAeAPoXYP +YAFKcBHwz3CAALwEIIAOgQHgDqEJ8M9wgAC8BCCADYEB4A2hAIcF6CKHDXAgoKCnz3CgAPQHpKAB +389xoADIH/gRAgAAIMAkQniA4MogTANfgRB4RQiEAAwSAiDPcIAAfGdCoKDYD6G/oc9ygAD8Cs9w +gADIXlWKHJBCeGJwH6EC2BUZGIANCRAgUSBAxiDYA/KA2A6hjCYDlQb0z3CAAMheHJAJ8IwmA5EI +9M9wgABAXw2Q8g9v/6lxtglP/xDMhiD5jwv0jCYDkQDYzyChA8ogIgEQGhwwz3CAAIhnoKDpcAjc +JwTv/aHA8cDiC+/9ANkIdQGAwbiD4MogQSDKIEEABfKpcBX/SiBAICMIUAAQhZUIngEQhc92gADI +XjkIngPPcIAA/AoCiCLwAdsA3z7wAN9VJkAa6XHPc4AA7DbiCOAAkNpAJQASnB4AEADYBbUE2yzw +EIURCN4Dz3CAAPwKA4gG8AWFJoXWDgABlB4CEBEI3gEdhpW4HaYehpe4HqYfhgQgvo8QcAAAyici +EOL1nLi+CyAKH6ZM6BCFlQhegwHfyfEA3+lzz3KAAMheVBKOAM9xoAD0Js9wgAB8Z5Huz3aAACZf +9CbOE1yS2mLPdoAA/ArVjsJ6ELqAugLwAtpDoSWFIaAVCBEgz3CAALwEIIAGgQHgBqF2CE//MQPv +/Whw4HjxwMYK7/0A2Qh1AYDBuIPgyiBBIMogQQAF8qlwzv5KIEAgz3GgACwgJoEweTUIUAAQhW8I +ngHPdoAAyF4clhUIQwAlhc9wgAB8ZwKAsQkBABCFFwieA89wgAD8CgKIEfAB2ADfMvAQhQ8I3gPP +cIAA/AoDiAXwBYUmhcINAAGUHgIQH4YEIL6PEHAAAAn0vgoACjToEIVlCF4DAd8D8ADfEfBVJkAa +6XHPc4AA8DZuD6AAkNofhp64H6ZAJQASnB4AEKoPD/8A2M92gADIXlQWghDPcaAA9Cag6s9ygAAm +X/QiwwNclnpiz3OAAPwKdYtiehC6gLoT8ADf1fHPcYAAvARAgQuCAeALoiCBiiBFC6YKb/0rgcXx +AtpDoUWFz3GAAHxnQaEVCBEgz3GAALwEQIEmggHhJqLxAc/98cCOCc/9CHYRzFMgQIAK8gYSATYA +2JgRAQAqDKAACHIBhsG4g+DKJyEQyiXBEwbyyXB6/gh1Ad+B5cojYQA28hCGDQifAQDbaHEx8BDM +RwjeABHMUyBAgBL0GcgB2gAggQ+AAIhZz3CAAExyEohAqVEgAIB0DmIAyiCCABDYEBocMM9xgAC4 +TxKBAeASoQjd2/HPcIAAPE8rgAHhK6DeCW/9iiDFCQDbAdkC2M9yoAD0JgOiQ4bPcIAAfGdBoInv +z3CAALwEQIAGggHgBqIK6QDYnrjPcaAA/EQBoQDYBaFODg//EQHv/QUjQAPxwKYIz/0IdgGAwbiD +4ADdyiBBAwTyyXBF/gHdANlZCFAAEIZRCJ4BEMzPcoAAwE4zCF4BQNgQGhwwUBIABgHgUBoYABnI +z3KAAAhZFHogqgISATYA2JgRAQD+CqAACHIK8KQSAQAB4aQaQAAiCW/9iiAFCgLZz3CgAPQmI6Aj +hs9wgAB8ZyGgiO3PcIAAvAQggAaBAeAGoaoND/91AO/9ANjgePHAz3KAAMheVBKBAJPpPJLPcoAA +/ApUikJ5ELlFIUMBz3GgAPQmY6EA2s9xgAB8Z0GhFv6B4MogYQAF8mIND/8A2P0BT//gePHAsg+P +/Qh1GnFBKQABz3GAAOQ6w7gIYSSVBCGBDwAAAIDXcQAAAIAB2cB5NXghlQThHwhAAIwgAqQJ9M9w +gADIXhaAjCAChgPyENg38CSVUghv/YogxAuMIAKsIvIO9owgAqAk8owgAqQm8owgAqgn9Klw1/4j +8IwgA6QV8gj2jCADoB30qXCj/xnwjCADqMwggq8AAPAAE/SpcMf/D/CpcBP/C/CpcGD/CfCWDSAB +qXAF8GoPIAGpcF0Hj/1NceIPL/2KIIUIwfHgePHA7g6P/c91gADIXh+FBCC+jwBwAABH8i8pAQDP +cIAA8AT0IEAApBUBEADenBUCEIK4yXP5/TfoH4VfCJ4Hz3WAAExyEI0ujVcJAAASjVMI3wAwrfIL +YAAD2DcIH0MA2Z65z3CgAPxEIaAwjYYh/wFDuRC5TyHCBs9xgAAIcyCJn7qA4QHZwHkPuUV5LaAS +jYS4Eq0F8M9wgAB0a8CobgxAAbkGj/3gePHA4cXuDy//AN3PcoAAyF4dglEgwIFY9M9woAAEJSKA +BCGBD/8AX29TIYAAfQjRAXkKnlMegnUInwYEIL6PAB4AAAjyAQqfQFEiAMDPIWIBz3KAAMheHoL5 +uM8hIgLPISIDzyHiAs8hogMg9CMI3gYdgoi5ibmNuQQggA8CAAAAi7mOuVIgQAQquAV5DvD8uMUh +gg8AAAAFzyHiAs8hogPFIYEPAAAAB89wgABUXwiIxLgYuFEggMQFIE0ALAti/cogIgj1Ba/9qXDg +ePHADxIBNwHhMHmPuQ8aXDDPcaAA1AsNoc9xgACoCiiBGwneAhcIHwFGCEADz3CAAOhdoNk+CW/9 +xNp9Bw//4HjxwDINr/2KIAgAz3agAMQnEx4YkM91gAB0X+SV6XAGCaADhiD8AxpwqXDpcYYh/ANU +/wh3hv9EJ36UDvIRDx4Rz3GAAMheHYGAuB2hAYUuDw//WPAXCBAgp//PcYAAyF49gaEJ3wHX/wzw +A9nPcKAA1AsxoOB44HjgeOB44HgxoM91gADIXh6FEQieAwHZz3CAAHAFIKAJ8A8I3gMB2c9wgAB0 +BSCgEQ/eEM9wgACIZS4MAAIRFgCWKwifACoOD/8dhUEI3wERFgWWGw2fAAohwA/rcgXYiiPJA00B +b/yKJIMPBNgTHhiQG9gWHhiQz3WAACxqGYUG6EYJQAEA2BmllQSP/c9yoADEJy0SAIZN2M9xgAAc +Xwm4GhoYgACJB+gB289woADUC3KgBNgQGhiATXCGIPMPjCAMgAHYwHgYYBR4IIke4IDhwCAiAwkI +n0T9CR7Gz3GgANAPEBkYgCURAIYlEQCGz3GgAMQnGhEAhgQggA////8AGhkYgBERAIYTCN4CANiL +uBMZGIAa2BkZGIDgfwDY4HjxwJoLj/3PdoAAyF7PcKAADCQ8gFaGocECIkAAZLgQeIYeBBAQcsoh +zg/KIs4HyiBuAcojjg8AACwFyiQuAFAAbvzKJQ4BAsgBgBcIXgcvIIcKjCAChgX0HoaeuB6mz3Wg +AMQnIRUQloIPQAOA4JgeABDe8s92gADIXs91gACoCgsNnlNWFYAQCvANDd5TVxWAEAbwA4Z6DuAA +JIaUHgIQHoZEIAEMEQkRCA0N31KA2ZQeQhCUFoEQCwneAbO4l7gepkkIngEUlkEIXwF+D0AGnOjP +cKAALCAPgAboAsgBgCkIXgcehpC4NgvgCR6mBuhRJUDTAdkD9ADZi3DPc4AA7DbuD2AAkNrPcIAA +yF6UEIEAQCkCBoYh/Q9SIcEBRblFec9yoACIJDCiKYVegAsJ3gALCl4CANgC8AHYUSEAgdEiYoIA +2cohYgAleA94KQrfBSUKnlOQ6EQiPtMK9M9wgADIXgGADQgeAPIPQAME8O4PQAPPdYAAyF4ehTkI +3gQE2c9woACQIz2gTXH+Ci/9iiBEDgkIn0T9CR7Gz3WAAMhehhUAEc9xgACoCjYJ4AMvkRXwAJUE +IIAPAADMgBUIgQ8AAMiAC4UJCB4AaP8H8ATZz3CgAJAjPaAC2M93oADEJzwfAJCUFYAQz3GAAHxn +BBkABBUI3gEdhZW4HaWKIAUJigov/QDZ1f4Idh2FUSDAgb70UyZAEA0I0QAVFwCWewjeAL4LL//J +cLLwz3GAADxPDYEB4A2hA9nPcKAA1AsxoOB44HjgeOB44HgxoBDYEB0YkALYPB0AkM9xgAB8Z+4K +L/8EGQAEHYZRIMCBkPQRFQWWGQ2fAAohwA/rcgXYiiMXCwkGL/yKJIMPBNgTHRiQG9gWHRiQevAQ +zD6FGwjeAAQhgA8AQEAADwiBDwBAQACYuT6lFwkeBADB1NipcgHbg/yA4PgOAgHPcIAAvAQggAaB +AeAGoR6F87hMDcIDHoXwuFgOwf4ehRMIngMB2c9wgABwBSCgCPARCN4DAdnPcIAAdAUgoM9xoADI +HADYB6Ew2AqhyXDE/ooghA1uCS/9yXECyAGALwheBx6FKwgeBhDYEBocMM9wgACIZQoIAAIZyAHa +ACCBD4AAiFkehUCpuLgepQCVhiD8AIwgAoAP9D4LwAON6APZz3CgANQLMaDgeOB44HjgeOB4MaAe +hQ0I3wQAlT4IIAU0lXEAr/2hwOB4z3KAAPwKVIpZYTB5QWkNCgMAIngQeAPwAtjPcaAAyB8foYog +GAgOoQLYFRkYgOB+8cDWD0/9z3aAAOAFAIaA4PgJggUQzADfeQgeAM9xoADIH7ARAgDPc4AAqApq +EwABY7gIIgAAHqEQ2A6hAdgVGRiAz3GAAHRjAhpYMM9xgAA0ZAYaWDAog891oAC0Rw8J3gJLHdiT +dx0YkF4JgAJXFQCWvLhXHRiQz3CAAAQFAIiA4BgOggYEIJBPMAAAACrwTwheAwIPD//PdaAA/EQF +hby4BaXPcIAANFAJgIwgAo2I9y4Ib/wU2M9woAC0D/ygz3CAAKgKCIALCN4CANieuAKlEMzvuM9w +oADIHxb0GncA2c9wgADsFSOgJaDPcaAALCAjgSegWfDmDy/8FNjPcKAAtA/coFHwBNkIGlgwP4CA +4YohDADKIYIPAAAAAi6gA9kVuRIYWIAAhoDg+AiCBQ0DAABdCF5Fz3WAAOwVA4UB4AOlUg4v/wHf +z3CgAPxEJYC8uSWgz3GAADRQKYGMIQKNmAfm/wDez3GAAKgKKIELCd4CANmeuSKgz3CAAMheHYCG +IL6PBfIFhQHgBaUB3xDM4wgfAea4ePSGIP+FufJRIwDAgvQIyAQgvo8DgOhDwvWFCF/Fz3WgAMgf +P4WgFQAQCSEAAOTgAN7R9s9wgACwRQCAFwheAN6lEN+qDOAC6XCF6AHYHqXupYogCACgHYATDqUf +hRMIFQqF6IogBAAOpRILgAYv2JW4Eh0YkM9wAQDA/BUdGJByCIAAdgqgAQfYz3CAAOAFAICA4PgP +QgXPcoAA7BUDgiSCCCEAAASiJoIFggghAAAGojyFZ4IIgmJ5CCBAAAiiz3GAAPYEAImI4NP0wKkD +2c9woABALTCgzfARzFMgQICX8wbIAhIBNgIaGDAGGlgwPg9AAs9woAD8RCWAvLkloM9wgAAEBQCI +gOD4C4IGgfFRIEDFffUQzM91gAC4T0MI3gCA2BAaHDARzBEI3gIYhQHgGKUA3wXwEIUB4BClz3CA +AExyEohRIACAVAoiAMogYgAnCBAgF4UB4BelDfCKIAQAEBocMA+FAeAPpQsIECAWhQHgFqUQzHkI +3gERzAQggA8AAAAYOwiADwAAAAgmCYAAEcxHCN4Az3CgACwgJYAGgArhLwhEAAISATYC2BAaHDBQ +2GYMIACYEQEAmvGaCCAB6XAPCB4ACNibuAgaGDAf8QTYCBoYMBvxAsigEAAA8LgA2Dzytg5AAADY +lrg48EsIHwJvCF8CGwieAxcLHkCKIQQAz3CgALAfNKAE2AgaGDARzO+4+gXB/89xoACoIEiBz3GA +AEBfLZEwcuIFxf+vuN8F7/8RGhwwYg9gAIogBAByCKAAAN0CyKAQAADwuKlwBvJGDkAAANiVuK4I +gAC58ToOYAAB2ADYkLj48QHgAKnPcIAAqAoIgC0I3gLPcIAA6AMQeM9xoAC0R0kZGIDPcABEFABL +GRiATBmYgwPYdxkYgP0DT/3PcIAABQVAiBEKHgDPcaAArC8ZgYq4GaERCl4Az3GgAKwvGYGOuBmh +4H7gePHAB9jPcaAA1AcaGRiADhEChhkaGDDPcKAASCxeoB8RAIYJGpgwARoYMATKnODMIIKPAACR +AAbyABYAQAAWAEADzM9xnwC4/xihiiBGBA4M7/wBEgE2BMrRwOB+8cDhxc9xgACoCkiBWwoeAM9y +oADIHEiChiD/AUO4z3KAAAg4CmIA24DiyiHBD8oiwQfKIGEByiOBDwAAWgDKJMEAwAfh+8olIQDP +cKoADFARCrQAvoGAvb6hAdkloAXwoL2+oWWgJQNP/eB48cCeCk/9GnDPd4AATHIQj892oAC0R0Qg +AQ5CKdEAKnVxFgGWBCGBDw4AAAAxufUJUIBDFgGWRiEBDUMeWJBXFgGWvLm/uVceWJBfFgGWv7lf +HliQANmeuVMeWJBgHhiQzf/PcIAAsE4HiBXoEI+GIP8BIglv/kO4z3eAAAgFFI8TDQAQz3CAALgm +FoBAeBQfQhRDFgCWRSAADUMeGJCDCBUhCnAzJgBwgACMO0AnAXIUeQB5EL2bvc9wgAAIcwCIn72A +4AHYwHgPuKV4Xx4YkB/wz3CAAAhzAIgQvYDgAdjAeA+4mLifuKV4RSDAAV8eGJAP8BC9z3CAAAhz +AIifvYDgAdjAeA+4pXhfHhiQCMiE4JgKIfzKIKED5QFP/QohwA/rcgXYiiMPCEokAABpBu/7CiUA +AeB48cBuCW/9AdnPcIAAqAoIgMC4G3gA3s91oAC0R0sdmJN3HViQz3GgAIRE2KEC2XcdWJAA2Z65 +Ux1YkFQdWJDPcYAANAFHHViQjrjPcYAAKABFIAYNSB1YkM9wgACoCkkdmJMakAK4bLhEHRiQHNhF +HRiQz3CAAOA2AYhGHRiQz3CAAExyEIh2/0okwHDPcYAAnGfJcqgggAPPcIAAFHNWeGGA82r1fz9n +AoBipwHiA6fPd4AACAUAhwPoZB0YkEMdmJEB2IH/z3CAAKgKKIAlCd4Cz3CAAOgDEHhJHRiQz3AA +RBQASx0YkEwdmJMD2AXwSx2YkwHYdx0YkECHHQkeAFMiQQASuUQiAAMOuCV4hiL/Awq6RXgS8Ehw +hiDzDwq4BCKBDwAAAAwGuSV4BCKBDwAAADACuSV4z3GAANA2mQBv/QKhocHxwBYIT/06cM9wgAAU +c0CApMFIcIYg/gMkuA64BnnCukAqgAMleEzABCCDDwEAAMAuu0ArDQacvc9xgACoCiiBn73PcoAA +CAVRIQCAz3GAALQZdnkG8tCBxKIxgQXwwIEhgcSiI6ICEgI2J4oZCd8Az3GAANAEIIGGIX8PPXkP +uSV9USGAocoiISIJ8gvZBCC+jwAAABjKIeIDWnFRIQChzyXiFgb0USEAos8lYhdjCF4CBCCBDwEA +AMAuuc92gAAIOClmSSGBAGG50mnUfsd2gAAMZygWEBAsFhMQz3aAAKgKYhaOECzHCLsY4QQggA8A +AAAQ5H6GJv8eCb7Fe2V/BX+evS95uRpCAIoh/w9d8E8IHgJDwCPBoOHKI0IAyiMhAM92gAC4Nylm +BCCPDwYAAAAxvwQghA8BAADAACdFEM9xgAAIOEEshAMyIQEBAiFBARYjRQAswStmFfBTIMEAz3OA +APQ6PXkpYwQggw8BAADALrvPdoAACDhrZmG7FiHFAAHbGw0UBgohwA/rcgXYiiPGCYUD7/uKJIMP +QC2BADR5x3GAABRmABEQAAQREwAEIIAP7wAA3SKBYbsmuGV4UiDPA7kaQgEwFAQwANjPdqAAtEdx +FgKWBCKCDw4AAAAxuvMKUICMIf+Pz3KnAIhJCvLPc4AA/BZ6gwkLHgIvogHYDqIKcG4N4AaIcYog +/w9vHhiQax4YkAPZD7nPcKAAyB8TGFiAWR7YlFoeGJRbHtiTWB6YlFEhgKJKIAAgBvLPcIAAqApq +EBAB+73KICEAEPICDoADz3CgAMgfHoACcAK4brhIIAAACHHJuSV9hifjH4wnHJDQJeETzyXiE1ce +WJPPcYAAsE4kkR0JUQCEFgKWUCIBAwQigg8AAAAMrbkCukV5BPCEFgGWFh5YkIwgz4/KIcYPyiLG +B8ogZgHKI4YPAAAXAcokxgBMAub7yiUmAAjcnwUv/aTAocHxwDoND/0acM9wgAAUc2CApMFocIYg +/gMkuA64BnnCuw67ZXlMwQQhgw8BAADALruB4gHawHoGulYiQghAKw0GnL3PcIAAqAoIgJ+9z3aA +AAgFUSAAgM9wgAC0GXZ4BfLwgOSmEYAE8OCAAYDkpgOmZwleAgQhgA8BAADALrjPdoAACDgIZkkg +gABhuAK4LMcUeAAgjg+AAAxnKBYRECwWEhDPdoAAqApiFo4QCLuKIP8Pnr3kfoYm/x4JvsV7ZX8E +IYMPAAAAEGV/TyITAU8j0yFe8FEgQKLPImIBzyIhAXpyRQkeAkPBI8Kg4somghDKJiEQz3OAALg3 +SmMEIY8PBgAAADG/BCGADwEAAMD6Yi64z3eAAAg4CGdCeBYmBRAswApjFvBTIcAAz3KAAPQ6HXgI +YgQhgg8BAADALrrPc4AACDhKY2G6FiCFAAHaGQ0UBgohwA/rcgXYiiNKBN0A7/uKJIMPQC2AABR4 +x3CAABRmABARAAQQEgAEIY8P7wAA3QKAYbomv0V/UifPE892oAC0R3EWApYEIoIPDgAAADG68wpQ +gIwg/4/PcqcAiEkL8s9zgAD8FnqDCwseAg+iAdgC8ADYDqLSCuAGKnCKIP8Pbx4YkGseGJAD2Q+5 +z3CgAMgfExhYgFkemJRaHliUWx7Yk1ge2JRRIICiANgG8s9wgACoCmoQAAH7vRpwyiAhAA/yZguA +A89woADIHx6AAnACuG64SCAAAAhxybklfYYn4x+MJxyQ0CXhE88l4hNXHliTz3GAALBOJJEfCVEA +hBYCllAiAQMEIoIPAAAADK25ArpFeQPwhBYBlhYeWJCMIM+PyiHGD8oixgfKIGYByiOGDwAAFwHK +JMYAsAem+8olJgBlBc//4HjxwJYKL/0DuTpwz3CAAKgKH4A1eQAhjQ+AAJxngOBac57yCYVFeLpw +CaUQFRQQFBUQEEaFHBUWECAVExAghc92oAC0R3EWAJYEIIAPDgAAADG49QhQgIwi/4/Pc6cAiEkK +8s9wgAD8FhqADQgeAk+jAdgD8ADYDqOGCeAGCnCKIP8Pbx4YkGseGJAD2A+4z3egAMgfEx8YkFke +GJVaHhiUWx6YlVgeWJVRI8CmyiEhAA3yLgqAAx6HArhCIIEDSCEBAChyyboFI5MgynCGIOMPjCAc +gAT0UCPAIwTwTyPAI1ceGJDPcIAAsE4EkB0IUQCEFgKWUCIAAwQigg8AAAAMrbgCukV4BPCEFgCW +Fh4YkIwhz4/KIcYPyiLGB8ogZgHKI4YPAAAXAcokxgB0Bqb7yiUmAAASASB+FwCW4LnPIOIA0CDh +AH4fGJAvIUMAABpAIADZz3CAAKgKP6AghYUBL/0AGUAg4HjxwEoJL/0A26XBC+lIgQQigg8AAAAw +QiIDgMojYgADuBV4ACCCD4AAnGfAgkDGJw4eEiDAz3WAALg3MiUEEACKDWUEJoAfBgAAADG4ACBF +AwTwAdiYcLhwrr6vvrC+QMaA48whIoCF9M9wgAAUc89zgADIXpYTgQADiAshAIA18kgTgwAA2QDf +UyNNAA8hQQNEIw0DQr2GI/8DDydPE7xrBCcPkADbBHkPI0MDZHjKJwEQgOHKIcEDJQ1QACcNkAB/ +DdAACiHAD+tyBdiKIwwGSiQAAGUFr/sKJQABDrklfjLw5Xn88SGCz3WAAKhGdWljZRkLXgIvKAEA +TiCBBwDYjrg4eAV+IPAbDVAAIw2QAC8N0AAKIcAP63IF2IojzAvY8c9wgACwSTZ4AogG8M9wgACw +STZ4A4gOuAV+BPCOvo++kL4EJoAfAQAAwC64z3GAAPw6CGFVCGUBQMYKIcAP63IF2IojzA3RBK/7 +mHYNkSiBhiB/DAQhgQ8AAAAwLLmpaRx4QCWBEw8mThBAxh0ITwMKIcAP63IF2IojDQCKJMMPmQSv ++7h1z3GAABRzAIGLc6CDhiD+AyS4DrgGfaCjAIHCuA64BX2gowDAz3aAAAgFBCCBDwEAAMAuuUAp +AwZPIwUHz3OAAKgKqINPJcUHUSUAkM91gAC0GTZ9BfLwheSmsYUE8OCFoYXkpqOmYQheAqeCCLkl +faeiBCCADwEAAMAuuM91gAAIOAhlSSCAAGG4ArgUeMdwgAAMZ8qAq4BiE4AAIMcEIMQDz3CAAABf +ERCGAE8lhQcEJgABCbgFeSV/iiAGBooh/w9T8D0IHgJEwCTGoObKJYITyiUhEM93gAC4N85nBCCP +DwYAAAAxvwQggQ8BAADA/mYuuc93gAAIOClnwnkT8FMgwQA9ec91gAD0Oi1lBCCBDwEAAMAuuc92 +gAAIOClmYbk2fRsNFBYKIcAP63IF2IojjQ6KJIMPWQOv+7h1Mm00ecdxgAAUZsCBoYEEIIAP7wAA +3SKBQiRPACa4BX9SJ88TiiAEAqSixaImoiAaQAEJoueiAdgfo5EG7/ylwOB4ANiQuM9xoADIHxUZ +GIDPcIAAsEVGkFt6TyIDAFoRAoY4EIAAZHpYYNgZAADgfuB44cUA289ygAAIWRQiDQBgtWi1GmIg +GsIAuB3EEM9xgACwRRZ5IpEoGsIAyB3EEHAdRBAB2YAaQgDPcYAAoFkVeWCh4H/BxeB48cDhxQh1 +GRIBNs9wgAAIWTR4EYgR6ALIAYAfCF4Dz3CAAOhC8CBAAM9xgACEBBR5AJEQ4ACx9gtAAhnI3/8C +yAHZoBhAAM9xDwD//54JYAKpcNEFz/zgePHAUg3v/EokAHLPcqAAiCAA3qggAQGDDtARAILPcYAA +sEXPc4AA+GvWeaiJZ4O7Y891gAAIWdR9ougAJoAfgAB4WfCIFw+REHAVDxH7fyORgL8kf3AdxBMG +8A0PURAikXAdRBAA2TCoz3CgAMgc+oBwFQER5HmIHUQQBvCIFQERCQkFAHhhBfCIHQQQeGCJIM8P +BBoQAAHmANnPcIAA+GsZBe/8J6DgePHAqgzP/FEgwIEZEg42z3CAAAhZAhIBNs9zgACsZc9ygADs +FdR48YgQEIYAEfIB55h3MhGFAAeTAhuCAQazGoIB4Bqiz3BBAIMA46sR8EAmRAAxEYUAAhsCAbgQ +AAHjqwazG4IB4Buiz3AhAIIADQ0FAaEE7/wEo89wgAAoWchgAeAEqwGBANqwiXUIHgEvJcgDz35J +JsQQ1W3Pd4AAqEbGZxKJEQ6eFc92gACwSbZ+wY4D8Eh2ACSPD4AAsEm2f+SPCCDAAwgggAOgcEkg +zgMWbdV4z3aAALBKAGbPdoAAyEi2fqGGz3aAAKgK3YbFfQQljR8AAAAIpngD8AOBAqOYEYAAqIsP +DQAQRKtg2Bi4sfEA2J24r/HhxeHGz3CgABQEA9kjoBnIz3KAAKxlYZLPcYAACFnEihQhDQBotQAg +gw+AAChZMOHAq2KCFXkGkmChAhIDNrgdBBAEgqATAQCGIcMPJXigGwAAwcbgf8HFGRICNgQgvo9g +AAAAz3OAAAhZVHvHcoAAeFkIcQXyAsgckBcIngIEIYEPYQAAABMJgQ8BAAAAANgAswHYHPAQzAIS +ATYbCN4BMhGBAAGLDQhBAADYAavz8QHgAasL8DERgQAAiwsIQQAA2ACr5/EB4ACrAtjgfxCq8cDC +Cu/8BNkIdRkSDjYG2BkaGDDPd6AAFAQKp89wgACQO8YKj/wAhb4Kr/wE2QGFtgqv/DjZIoUF6QGF +AJAbCEUACiHAD+tyBdh120okQABhB2/7uHOSCq/8A4UBhUKFIJAFhYIKr/xCecqnvQLv/BkamDPP +cYAAIAXgfwOh4HjxwEIKz/wKJQCQyiHBD8oiwQfKI4EPAACtAMogYQEg8iGFgOHKIcEPyiLBB8oj +gQ8AAK4ABdgU8hCJz3KAAKhGBbgHYsKBLb8BhsC/A+gAhovoCiHAD+tyBdi120okQADRBm/7uHMN +CJ9Bhg6ABQ3oiiDOAroKb/y82QCGgNkooAGGQHgp8AGFIJAgyBBxyiHND8oizQfKI40PAADCAMAH +7f8F2Klwt/8BhtP/z3CAAMyDhC8LGoohEAAwIEAOGHkAyCZ4ABoYMM9wgADoQuagAghv/Olw1QHP +/OB4z3GAACAFI4HgfyCg8cDhxQISATaigYoh/w8AGlgwIIVqCK/8JNoBhYDg4iACALEBz/zgePHA +Mgnv/AbYGRIPNhkaGDDPdqAAFAQKpgmGAN0R6IYMAAIJhg3oJBYFEAohwA/rcgXYiiNEA+0Fb/tK +JEAAiiD/D+qmABoYMM9xoADQGxCBz3KAAAhZhrgQoROBkLgToR2KGRrYMw3oz3CAAOhCBoDPcYAA +hAQUeQCREOAAsaayrrImGkIDxBpEA4ogTwuSCW/8iiEECAUBz/zgePHA4cUIdc9wgADoQkaAz3CA +AIiBhCoLCgAgQg7PcIAAXEQAgKHBKQjeABZpz3OAALBKAGMZCF8Cz3CAALBJNnhbigKIiboOuEV4 +BvDWDK/8i3AAwACluQDv/KHA4HjgeOB44HgKJIDwBSBEAOAgwQdEJP6AQSrEAIQAAgAvJALxQiEB +AUIgAwHoIKIEBBEEAgQRBQIEEQYCBBEHAgQbCAEEG0gBBBuIAQQbyAEsACUARCI+gTwAIgBEIvyA +QCHBAOAgwQdAI8MAqCCAAQERhAIBGwoBICDABwQRBAIEEQUCBBsIAdQH4f8EG0gBRCL8gAQRBALJ +B+//BBsIAUIhQQBCIEMAqCCAAQERhAIBGwoBICDAB/HAhg+v/ADYz3aAALBoSiQAdIDdqCBABQhx +AeBPIMIBFiZDEEeriiIIAEApRAEAJIEPgACoRkChANpCsaapwNh/HgIQz3aAADAFoK7PcIAAMGmA +2a4Jb/wocqGuz3KAAPwKoqrPcYAAFISyqc9wgAA8gaKoo6qzqXkHr/yjqOB4osHxwP4Or/yYckXB +QSgBAkEoAwQHeSd7xrvHc4AAMGkgiykJ3wEUFA4xz3KAALBoFiJNAOCFDQjBA+KVEQ+AEyeNZ23n +Cd6BANg18OaNh++A3s9wgAAwBcGoz3CAAPwKwogdD4ETgN7CqM9wgAAUhNKoz3CAADyBwqgP8MOI +Gw+BE4Dew6jPcIAAFITTqM9wgAA8gcOoxo02egAcgAMHjYe5AKvPcIAAMAVgiCCoAdhnqgzctwaP +/PHAPg6P/M9xgACUOyGBo8FCwc9xgACwBBUhEAAAEA4gLyiBA04gjQenDhAQFW0AIJEPgACoRgYR +gCDPcYAAsGgWeQCBIpGO5QgcRDDKIGEABPKLcgLBvf806ADYz3GAADwFQIEPIEADLyIKIAQigKAA +oQf0gOJICGIEyiAiCK94MgsgABDZAN8EGcQjiiEIAAAZQCCpcOlxkg7gCA/az3CAAMhIABABILZ4 +4KDhoM9wgACoSAQhgQQAGEAgtHjgsBAmTpMvKIEDTiCNB7D1zQWv/KPAosHxwHINj/xFwc9xgADo +gKKBJQhBA6aRFBQOMRkOQRPPdYAA/ApCrc91gAAUhFKtVhmCALwRDQYpCEEDz3WAALiDspUUFA4x +GQ5BE891gAD8CkOtz3WAABSEU61XGYIAi+rPdYAAMAXBjYDmANnKIEEAIvIhrQsKkQMB2BzwQSgN +Agd9QSgBBKd5z3eAADAFoI9TJUURGw0yBMa5CiHAD+tyBdi728EBb/uKJIMPCw2eEQDYOfHPdYAA +sGgWJU0Rx40ApRQUADHAr0atArXHcYAAMGkAiQetABlCAQAbQgHN8eB4osFBwUEoAgIHekEoAQRH +ec9ygAAwaca5KmIlCt8BBBQDMc9xgACwaFZ5QIELCIEAQpERCsAAR4nrCt6BgNgD8AaJ4H+iwOB4 +8cBODK/8uHBKJEAAkODKIcoPyiLKB8ojig8AABMBHAFq+8ogagFALUMBx3OAAKhGxouMJgKQANgN +8s9wgACwaBYgjQOghaChJos2eAKQALKIcGkEj/zgePHAABYFQEwlAIHKIc0PyiLNB8ogbQHKI+0J +yABt+8okbQAbDVQAqHAA2gAWAUAB4vsKlIFhuPUIVYCyCU/80cDgfuB4ANje8eB+4HgAFgBAABYA +QJUBT/zgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfwDY8cDhxc91gACwac9xgACoCgCBdBUCFkcK +AQACkeoVAhc7CgEAdhUAFsYO7/93FQEWjCACgBPyz3KAADgFIYIA2w8jAwAFuGZ5IaIAIIEPgACo +RgCBqriIuAChANiZA6/89B0cEM9wgABUXyiIz3KAAJBrjCECgAKSQSgDAwvyFwjfAgW5x3GAAKhG +ApEPIMAAArEA2OB/BLIA2kokAHRIcagggAPPcIAAlGrPc4AAFGs0e0CzNnhAoEGgAeFKJMBzANmo +IEACz3CAAKhINHhAsAHhz3CAADgFQaDPcIAAkGvgf0Sw8cCaCq/8VGiGIvgDibpTIcMARXvPcoAA +qEgUeo/hiiUPHMogKQAJ9gCSAN4PJk4QiiXPH8Z4ALJKJAB0ANqoIEAGz3eAAAxrVH/El6R+z3CA +AJRqGQuBAwDexLdWeMCgwaDPcIAANGtVeMCgAeKVAo/84HjxwCYKr/yYcgh1z3aAABRr9CZAEM93 +gACUalEgQILKIEEAyiQidMogIgDoICIC9CYCEAkKXgIB4EcIFQQtu8C7z3KAAKhItHpAK4UCYJIE +vYYl+BOJvQ8jQwBgsgDaFn9Ap0Gnw7mleQUhQwEUfmC2z3GAADRrFXkAGQABAvCA2A0Cj/wIccO4 +z3OAABRr9CMCAMm6UHHKJCJ0yiAiAOggYgL0IwIAyboHCYAAAeDgfvHAdgmv/ADZCHUBgMG4g+DK +IEEA7Ami/sogQgMhCFAAEIUhCJ4BEIXPdoAAyF41CJ4Dz3CAAPwKAogg8AHeA/AA3gLZz3CgAPQm +I6Alhc9wgAB8Z8IO7/0hoIUBr/zJcBCFEQjeA89wgAD8CgOIBvAFhSaFcgzP/5QeAhAfhgQgvo8Q +cAAAEvRuCcAIBehRJUDTAdkC9ADZVSZAGs9zgADsNiYOb/+Q2hGFz3GAADgFAKFBKA8Dw7+UFoEQ +QSgFBRRpBSDEAw8J3gEdhpW4HaZ88E8kQALA//EIFQTPcYAANGvwIQMAlBaBEEApAgaGIf0PUiHB +AUW5JXrPcaAAxCdBGZiAAiXCgMAihA8AAAAQDL/XcgAAAAiQv1L2BSdPEWIZ2IOMIgKAx/bPcYAA +7BUMgQHgDKEA2Z25SvDle2IZ2IBZDoNwAADADw4igQ8AAAAQz3OAAJRqFntAgyUJNQgBgwDbDyND +AEIjRQBOIQ8IASrDAzh6BSJCATh4BXsX8EIhAQgA2A8gQABhuDh6BSIDAIoi/w8L8M9xgADsFQ2B +iiL/D0hzAeANoQHZz3CAAHBrJKjPcYAAsGnjGRwBchmYAHMZ2AC58QDZnLkfhiV4H6ZAJQASnB4A +EDTx8cCOD0/8CHVVIE8EEcyiwe240SBigAryBhIBNgDYmBEBAC4Kb/8Ics9wgABEXwuAz3GgAMgf +ZOAeoRDYDqEB2BUZGIABhYTo/QsewAGFwbjnCNEAAIdBwAQUADFBKBADEIUGFBExjQieARHMiwje +AhCFz3aAAMheDwieA89wgAD8CgKIDfAQhQ8I3gPPcIAA/AoDiAXwBYUmhXIKz/9RIMCBlB4CEMoi +YSAM8h2GlbgdpoogBQnSD+/7ANlKIgAglBaAEM9xgABcZwS4RpEFIAAEFwiAAM9ygADsFQCCSiIA +IAHgAKIEkScIgQ8AAP//SiIAIA3wz3CAADxPK4AA3gHhK6CCD+/7iiAFDFp2AZUrCBEHwYfih89w +oAD0JgLZI6Ajhc9wgAB8ZyGg+g5v/qlwDwhRAAHYf/AQ2H3wSQoQIM9woADELMegz3GAAFRf6KAo +iUAoAiMQuZ+5RXlBKQIhRXkmoBHMHQjeAhDZq7gQGlwwERocMM9xgAA0UAKBAeACobYLz/0REgE3 +DwkeAwjYrLkRGlwwAvAA2JsKECDPc4AAsGngEwQAFBUFEEQsPgcAI0EOABlAAUyVQrHPcoAAVF9I +is91gABcZ0ipCRkCBAoZRATDocSV5KFAJE0A4BtAAxC6QCgDI2V6QSkDIWV6yrHPdaAAwC9HHZiQ +z3KgAGgs8CKCA0uxjxUDlgjwoxUClo8VA5YLCh8B9QvegQTw57vKIyEAQMMBFIIwxrvGulipeam1 +BW/8osDxwFoNT/zPcYAAcGskiRfpz3GAALBpchEOBnMRDQbPcoAA7BXjERAHz3GAADgF4IEigjS/ +AeEioi/wz3KgAMQnERIBhgDf9wmegWQSA4ZkGtiDAtkTGliALynBAE4hggcS689xgACUalZ5wIGh +gc9xgAAUa/QhkADPcYAANGvwIY8AC/DPcoAA7BUhgul16XYadwHhIaJBgA1xQKEkkA1wILDPcYAA +iGcAgQfoQoENcECgANgAoc9wgACoCgiA67jKIIIDyiFCA8oiwgP8DSICyiMCBFMgwCDPcYAAOAUg +gRS/DLjleBcJngCCuA1xAKENcMCgDXCgoB3wDXEAoUokAHSoIAADRCaBEA+5UyYAECV4DXEAoSK+ +SiQAdKggwAJEJYEQD7lTJQAQJXgNcQChIr2NBE/84HjPcoAAlGrPcaAABCVPoVYiAAQRoVYiAAUQ +oeB+SiQAdADZqCCAAgDaz3CAABRrNHhAsAHh5vHgePHA4gtP/M91gABcZ0SVz3GgAGgs8CGRAM93 +oADAL6sIEAAvjc9wgACwSc9yoAAsIM92gACoCjZ4Iog8EhIADo04FhARgOCEACkAyiCpAIwiAaR4 +ACUABNgA2AWiUNhFIUECGNraC+AAINv4uAjYLvQD2M9xoAD0BwWhhNoNcECwQiIAKA1yALJAhQ1w +QKBClQ1wQLBAhg1wQKBClg1wQLAGlUApAiXDuAy4grgFeg1wQKAA2AShDo0B4A6t4g+gAApwAdgV +8ADYANlIH1iQSR9YkGaVDLufuwUjQgRHH5iQLq3PcoAAuE85ggHhOaJRA0/84HjxwOHFAN0K8EQt +PhcncBzZ5g7v+8XaAeXPcIAAsGngEAEA6Q1EkE0DT/zgeOHF4cbPcYAA+GtFgSXoz3OgAMgfQBMO +BkAogQLPdYAAyF5AFQAR0H7YYNyVPmbPcYAAqAppEY0Aon4IJg0QAn0JIkIDAtgVGxiAX6Migc9w +gAB8ZyKgwcbgf8HFANnPcIAAfGcgoCGg4H8ioADZz3CAAHxnIaDPcIAAyF48kM9wgAD8ChWIz3Kg +AMgfAnkfgjB5EHgIIQEAMHkC2BUaGIA/ouB+8cDhxQh1z3CAALBOAJAhCJEBiiAUDQIL7/upcQDY +z3GnAIhJgeXKIGEADqF1Ak/8z3CAALBOAJAPCJEBBtnPcKcAiEkwoOB+8cBfCB5Dz3CgAPQHJ4AZ +gDB5OGADuJYgQgXPcaAAyB8eoRDYDqEB2BUZGIBeD+/7gdgvCB5Dz3CAAEAFAdkhoALIpBABAJq5 +pBhAAPIO7/4B2M9xgABoFgSBAeAEodHA4H7gePHAfglv/JhwQYFwiXMKHgGyic93gACoRtVrxmdk +yggRhQBJIMAAEw6eFc92gACwSXZ+wY4C8ADex3CAALBJdngEiAglDRAIJY0TACVAEUkgzQMWa7V4 +z3WAALBKBWXPcIAAyEh2eM9zgACoCn2DAYBleAQggA8AAAAIBn0C8KOB6L2YGUADANsJ8qQRAAAA +25e7kbiUuKQZAABLDB4AGcjPdoAA6ELAuvAmDhDPcIAACIGELgsaMCBADgQggA8AQAAAPrge4Bh6 +RX2YGUADHQ2eF6QRAACFIwEEjLiRuKQZAACcGcAAHvDPcoAAqAoSgiMN3hekEQ0AhSMBBJa7mLuN +vZG9pBlAA5wZwACeuBKiCPCUu5a7nBnAAJ64n7gSosUAT/zhxeHGmBAOABkSAjYEJoEfAAAACDt5 +BCaNHwAAABAlfc9xgADoQvAhggDPcYAAiIGEKgsKACFCDkAiAQaYEIMAEw5eEkQjAgxEuk5hib7J +chXwOpIZDh4SHOLCu35iyI56YlCKpX7QfiV6CfDDu3x7fmJ6YlCKyI4leogYgAOleowYgADBxuB/ +wcXgeKHB8cC+Dw/8CHVHwOi9KHDcACEASHYDuEAgkQUnwc9wgAC4NwQlkh8GAAAAQSpCJCtgBCWA +H8AAAAA2uKl3emLPc4AAnDvGvwhjSmMaYkEtgBJSIAAAwLgDuBjgheLKII0PAQCJDdUgjgAvIAgg +BCWCHwAAABjPcIAA9DjXcgAAAAgeACIA8CDAA6DhEgABAM9xQnvQXgUofgAKIMAOKnEFKT4ACiDA +DiS4AeALChAgUyABADhgAiiBI89ygADkClWSJQ1eE89zgADwOGCTBSs+AAAhgH8AAP8/Lrg4YJEA +IABYYBV5iQAgAFhhUSVAkk4AIQAnxbflIAALADNoUyUCEM9wgAAsOPAggAAFKT4ACiDADgHgB/CK +5cAo4QDAKKIAz3GAAPwKLonA2qR5hiH/DiK5OnraejUAIABYYDNoUyXAEBx4z3KAAEA48CIAABbh +BSk+AAogwA7PcoAA5Ao1kgHgFXkIktp4OGAQeAjcrwYP/PHAUg4v/NhwKHUA2KQZAADPd4AAqAoS +pwnIBCCADwDAAADQiTEIgQ8AwAAAGcjPcYAACFkUeRGJjujPcIAAMErWeCKICI0RCEMAyHCSDO// +qXHQ8FEmAIB+8gQVBBB5DB4BGcjPcoAACFkUehEShQDPc4AAqEZVbkJjD3gyjUkgwAATCp4Fz3KA +ALBJ1npBigLwANrHcIAAsEnWeASICCEBAAghgQAAIUABSSDBAxZuNXjPcYAAsEoBYc9wgADISNZ4 +XYcBgEV4BCCADwAAAAgGeQPwI4WYHUAQGcjPcoAA6ELwIgIAz3CAAAiBhCoLCjAgQA5TJAIABCCA +DwBAAAA+uB7gGHpFeZgdQBAVCZ4HANiMuKQdABBQ2JwdABBq8B8J3gcA2I24pB0AEM9wQAFQAJwd +ABAA2J64Eqda8ADYpB0AEAXYFLicHQAQwNgYuBKnUPCDDl4HAYVpCB4BMo1kEoIwSSLCABVuz3OA +AKhGAGMTCJ4Fz3CAALBJ1ngBiALwANjHcoAAsEnWekSKCCGBAAghAABJIMEDFm41eM9xgACwSgFh +z3CAAMhI1nhBgB2HRXgEIIAPAAAACAZ5A/AjhZgdQBAZyM9ygAA4WRV6IKIA2APwBdgUuJwdABBR +JgCFANjPIGIEyiAhAKQdABACyAGAz3GgAMAd7LgAgdAg4gDPIOEAAKERjc9xgAAEO8K4CWF0HUQQ +z3GAAAw78CEBAKQVABAleJgVARCkHQAQFwleAjuXgLh2HUQQeB1EEKQdABAQ8CiHWpd2HYQQFQne +ADuXg7h4HUQQpB0AEATweB2EEJ4L7/+pcKQVABBEIH6CjBWCEBbyYheBEER5hiL/A0S6hiH/Dllh +z3KAAMA49CJQAM9ygACwOPQiUQAO8MO6z3GAANRlXHr0IZAAz3GAAMRl9CGRAJgVBRDguMohQgQW +9IgVgRBRJQCCw7k8edEgIoUH8s9ygAD0ZfQiQQAG8M9ygADEZfQiQQBBhVEiwIDKISEAhB1EEEsN +HgKYFYIQz3GAALg3z3OAAKhGSWEEJYIPBgAAADG6WWFVbkJjJQreBpe4pB0AEATYuB0CEADYj7i6 +HQQQz3AMQKj+GaUC8AHZBCW+jwEAAMAL9AohwA/rcgXYiiOXDPEHr/qKJIMPOQlQAILhzCHigMoh +wg/KIsIHyiBiAcojgg8AAP4FyiQiAMQHovrKJQIBz3CAALBJ1ngDiAfwz3CAALBJ1ngCiIwVARAO +uCV4jB0AEIQXAhAglXQVABEZYTrqGRICNm0KkAFpCZINz3CAAAhZVHgRiK7oAsikEAAAVQgfAFEO +HgCeFQARirieHQQQUCWAA6+4sLiYHQAQhBcCEC8qgQBOIoMHI7sA2g7jDyLCAAUggwCGIPsPhiL7 +DwUgvoCYHcAQANjKIGEDmB0CEJgVABBeCu//ANqkFQEQBCG+jwAAADCCHQQQT/KMFQIQnBUDEZQd +gBCSHcQQgB1EFAISDjYfCR4DFNuQHcQQfh0EFHgWAxECIM4g0H6yHYQTEPAO25AdxBAA234dxBB4 +FgMRSiAAIAIhziDQfrIdhBPPc4AAsEVgg4Yjf48J9JgVDhAPDl8SkbmSuaQdQBAQu2V5pB1AEDKH +BCKCDwAAABBSIgIDRXkEIYIPAAAAEF16RXkypxzwmBUBEGCVlB1AEJ4VARF0FQIRsh0EEJIdRBC4 +FYEQemJZYTB5kB1EEADZOnEacYAdRBB+HUQQACBBJDhghBUBERlhMHmNAS/8sB1EEOB48cAqCQ/8 +CMhRIICBcgICAAISAzbPdaAAyB8qg6QVABCMIf+PDPIieBUIhQ8AgAAAh9iQuEsCIACgGwAAMIsV +acdwgACoRkCABCK+jwAAABNV8hMKXgKL2JC4JwIgAKAbAABnCh8DRZCa6gnIBCCADwDAAAAZCIEP +AMAAABHYFLigGwAAkgmv++bYI/CI2JC4oBsAAIIJr/vn2Bvw6Nh6Ca/7SHECyKQQAQC0uaQYQACS +EAEBp7mSGEQAnhABAae5nhhEAAXwhdiQuKAbAADPcIAAqAoYiITg0/QCyM9xgAAYNVCIDIEPIIAA +DKHPcYAAjAgAgQHgAKHD8CKQMxOAAE0JDgAJyAQggA8AwAAAMQiBDwDAAAAIiysIUwCkEwAAtLik +GwAAkhMAAae4khsEAJ4TAAGnuJ4bBAAK8AGDEQieAY3YkLigGwAAm/AIyAQgvo8AAAEQdPK+CYAC +AhIDNghysBMOAagbAAAVhVUmQRbVuM91gAD4awkIRQAF2SelJYUCeeThyiAlAAkggACsGwAApBMA +ALEIngSYE4EAw7kJyDx5BCCGDwEAAPAZyM91gACwRRZ95ZWsEw0AQS4GAwklxBPPdYAA6ELwJQUQ +gBMPAX4TDQH9Zc93gADkCveXFLj9ZQgkTwOifwPnz3WAAMQ68CVNECK/BS3+E1MhD3AAJ00eLyRC +A0AtTQE1fcd1gACIXuCVz3GgAMQs76Ghla6hQC4NBp69BX0FJEADCqHPcYAAQAUB2AChBvCgFQIQ +sBMOAQ0KhQMF2Bi4oBsAAM9wgACIBACQIJMJIQEAz3CgABQECYAbCEUAA9gYuKAbAADPcYAAuE8O +gQHgDqEVB8/74HgEKIAPAAAvukIpwnRQekQq/gICIEAOEHgD6AHiUHoLCDMBQLGD6ADYAvCA2OB+ +4HihweHF4cZCwc91pQCs/1ilz3KAAOQK1ZJIktpiQnsD4yK7emN6YkgiQgAFukUiQgMnuFalUyAC +ACLABCGBDwAAACAHuiW5RXgleIm4jrgZpcHGwcXgf6HADwlfAgQgvo8ABgAACfITCZ8Cz3CgAPxE +GYD7CJ6C4H7xwP4N7/tKJEAAz3WgALRHVxUAls92oADIHwDfBCC+jwAoAADCJAIBbxUAlgQghQ+A +AAAABCCDDyAAAAAEIIIPAAYAAA0MEABAFgEWCQnUAADZA/AB2fhxExYBlgQgvo8AOAAABCGGDwAA +AIDMJyGAwCdhEAUjQQEFIYEBBSG+gAP0qQ+Ukg8OEACA48wiIYBd8msVAZYVCd4Az3GAALhPDIEB +4AyhS/BTIb6ACPLPcYAAuE8LgQHgC6FB8H8J3wEI689xgADsFQmBAeAJoTfwIeoVCJ4Gz3OAAGgW +RoMB4kajCvAVCF4Gz3OAAGgWR4MB4keju/8j8HEVBJZvFQWWCiHAD+tyz3MAAOEO4QGv+gXYUSGA +gc9xgADsFQXyHIEB4ByhC/AA2J64Ux0YkADYVx0YkAqBAeAKod3YAN2YvaoNb/upcalwHfATFgCW +8LjKICEAUAqh+88goQNrFQGWWBUAlgsgQIAM8vIJr/4B2APZz3CgAPQHKqAF2Ji4A/AA2OUEz/vg +eKHB8cBqDM/7ocFHwQh2SHVodwQhkQ8BAADACiAAIWMJXgIC2c9woADIHCmgJ8FTbe7hUHgE9Itx +Zv8Z8A8J0Q0beBB4i3Fj/xDwCwkRBRx4CfANCZECAByEMAfwz3AAAP//ABwEMOB4ANjPcqkApP+5 +ogAUATGCuDeiGqIo8CEJHgJMIACg0SbikcoggQPKIkEDcA3h/8ojwQMa8CfAgODKIcEPyiLBB8og +YQHKI4EPAAA+DsokIQCsAKH6yiXBAAW9pXjPcaUArP8WoWv/CiUAkBL0Fw7eER0IESAB2c9woAD0 +ByygA9kF8APZz3CgAPQHJaDPcIAA5AUAgAfoz3GAADwdBYEfZ+Whz3GAALhPCoEB4AqhDw6eEiIM +IAVBKYAjqXAI3KsD7/uhwPHATgvP+wh1z3aAAEAFB4YVDQAQ9dgFuPILr/upcQkIUQCnppUDz/vx +wCILz/ukEQAAKHXyuADYMPLPcoAAQAUggoDhMPIAon4VARGAFQAROGDPcYAA5Ar3kR9nAQmeRc9w +oADELMuA5NjOC2/7yXFTJoEU/r7MISKADvKYFQAQ/gqv/wDaz3GAAOQKKJEiePhgCvAA2AjwGcjP +cYAAsEUWeQWRrBUBEIfopBUCELG6pB2AEAPwCSEBAAPaGLrPc6AAyB9Po/gTDQBBbQghgQCieaAb +QAAA2Zi5LqPVAs/74cXhxqQQAgATCh4GthABAc9woACYAz6gfvAAFgFBPLAAFgNBRCENA32wABYD +QG+gABYDQUAYxAAAFgNAcaAAFgNBSBjEADcNEBEY23IYxAAAFgNAc6AAFgNBUBjEAAAWA0FUGMQA +Ew0REihzhiPzD4wjDIAM8hjeFPAQ3nIYhAMA3c9zgACsZaezDPAe3nIYhAMAFgNAdqAAFgNBXBjE +AChzhiP9DIwjAoIJ9ALm0H5yGIQDABYDQQLwANtgGMQACQ5eEAAWA0G4EIMAoJDbY3B7chjEAMJ9 +sH26EAMBcBhEA0h0hCQMkGV5PLAL8gAWAUBovTqgABYBQLB9O6BwGEQDmLrPcaAAmAOkGIAAPoG2 +GEQAgQGP/zyQCHJEIQADTQgQARnIz3OAAMBZ9CMAACV4HLIBghcIXgNUEgEBvBIAAcO5JXhUGgQA +CcjPcYAArGUEIIAPAMAAANdwAMAAAADYyiAiAM8g4gIHseB+4HjxwPYIz/vPcIAAqApqEBABGcjP +cYAA6ELwIQIAz3GAAIiBhCoLCgAhRg4REg03QCYIBkYlwRERGlwwAhICNgDepBIBAIS5pBpAACGC +QCYHAqLBhhqEAwsJnwOgvbB9UyV+kJYCAQDPcYAANFAngc9zgAA0UAHhJ6MGEgE2z3egALwtpBmA +Aw6nb4cBC94Fb4dTI88CQwueBRUPlRPPcoAAaBbjgra7AefjohfwZL/wf5AZxAMEI48PAAAA8Cy/ +8Kl0GYQDwLHhgsiphif/HYS/4aFSilKp9rseAgEAANqWuqQZgAAjC14Flg5v/wDYBhIBNqQRAAAE +IIIPAgAAAC26pXpQfTzwQYGhCh4BcIkPeEkgxADPd4AAqEYVawBnUokRCJ4Fz3CAALBJdngBiAPw +ANgAJI8PgACwSXZ/5I8IIsIDCCIAAEkgwgMWa1V4z3KAALBKAGLPcoAAyEh2es9zgACoCn2DQYJl +egQigg8AAAAIRniYGQAAANiWuEGBhiL/DUMIHgWhChAAmBGCAEAmAAlIYM9zgAD0ZUDAIMLDulx6 +9COCAFLwCiHAD+tyBdjPcwAAggqKJIMPMQRv+kolAACYEQMAnBmAA0kLXgKAuKQZAAAo6pgRgADP +coAAqApiEoIAhiD/A0S4MiAAEIm4QMAgw2R6hiP/A4Yi/w5Eu3piT3rPc4AAsDj0I4IAHvATCx4C +COqYEYIAQCYACUhgC/CF6gDaSHAQ8JgRgADDuBx4MicAAEDAIMLPc4AAxGXDulx69COCAIgZAACY +EQAAhBmEAJARAQHWDm//ANoGEgI2AhIBNs93oADIH4QSDgGCGgQAHmbQfrAahAP4FwAQsBEDAQJ7 +ACMABM9zgACoCmQTAwF4YNhgoBcPEBB4Ww8EEM9wgACoChKAmBEPAAsgwIMj9FCKEIkQctEnIpIR +8pgRjwDPcoAAuDfqYhMKkgAFuM9ygACoRgBiHwhfBNtjcHuGGcQAz3GAADRQCIERGlwzAeAIoWUG +r/uiwPHA/g2P+892oADIH6AWBBD4FgMQSwgRAQISAjakEgAAdhIBAQ8IHgXPcIAATGehgAPwghIN +ARHMUSAAgYQSAAEI8gIlwhACJIMACCMDAAXwhhIDARtjz3eAAKgKa/CTCFEAERICNwLIeBABAUMK +HgFRIkCAz3eAAKgKZBcCEQnyfhANAUJ9Yn0CJEMDKvCAEAMBz3WAADBKACOEAHCIdn1glQAjDQGE +EAMBu2Ma8KQQAgAVCh4FcIjPcoAAMEp2emCSBPCCEAMBgBANAc93gACoCmQXAhFdZbtjhBANAbtj +gBANAbpifhANASJ9JPDPd4AAqAo5CJEAAhINNhHMeBUBEWQXAhEVCB4BgBUAEUJ4YngCJAMACPCC +FQMRhBUAEVtjG2OAFQ0RIn0G8ADbaHFodWhyEcxpF4QQFQheAALIdhABAQIhAQFZYQnwDwtyAAIh +AQFqFwARGWH4FgAQPWUCfR+GGQ0EEKDYD6YA2B+mP6YC2BUeGJCA2A6m6QSv+3B44HjPcYAAuE8N +gQHgDaEZyMdwgAAkWSyIAeEveSyoz3CAAOA2AogVCEMAiiAIAAgaGDDPcAEIAAAN8APZz3CgABQE +I6CKIBAACBoYMAnYGLjgfvHALgyv+wDZz3CgAPxEvYDZgAQmgp8AAAACDPQEJb6fAAYAAAb0Asik +EAAApwieBs9wgADkCheQz3GgAMgfH6Eg2A6hJQ2eFgLIz3EDAIQAoBhAAIogCAAIGhgwiiAEALYM +L/sA2SfwGQ1eFtH/AhICNghxoBoAAJ4ML/v82BvwAhIBNqQRAAD6uMogYgHAKCIEC/QP6s9ygADs +FQmCAeAJogjYkLigGQAAiiAIAAgaGDCpcMlxVv0D3s91oADUB9KlhgwP/RMdmJMCyKAQAAAC8Chw +xQOP+/HAVguP+24Jb/8Idsf/z3GgAMgfCHVA2A+hQBEBBjB5Og7v/MlwnQOv+6lw8cACyKQQAABR +IACAz3CAAKgKBPIdkAPwHJDv/7zoz3CgABQEA9kjoCDYEBocMM9xgAC4TxGBAeARoQLIANqYEAEA +dBADAZQYQACeEAEBkhhEACCQO2O4EIEAeWEweZAYRACkEAEArLmtuaQYQACAEAEBfhADAYAYhAA7 +Y7AQAQFieTB5sBhEAIIQAQF+GIQAshhEAA8BT//PcIAAGGwGgAPbz3GgAPQHZaGB4AHYwHgMuIUg +AwENcwCzAsgA2n2QDXBgsALIcYANcGCgAshIEAMBDXBgsESh4H7gePHASgqv+whzEIkzEY0AAdpA +qxkSDzbPdoAAMFnuZs9ygABYWUDcwasZEg82AiIOA/QmzhPBsxkSDjbwIoIDQaNBgSMKHgHSic9y +gACwSRZ63KtAioYifwxcegS6RX7cqwPwgNpcqwS4BX29qxyRz3KAAKBZD7MZyPAiAAAEswnIBaNU +EQABDLMAkQ2zoBGCAEijCMgEIIAPAgBBAA0IgQ8CAAAAiLpIowjIBCC+jwAAQRAE8om6SKOcEQAB +z3OAAEAFJrjAuEAoAgMPgcC4DbhFeOEBr/sFo/HAdgmP+wh1AsgHiBkI3gAA2AoPL/uQuADZkrnP +cKAA0BsxoM9woADUCxiAQiAACEggAACw4BAMJfvKICUMz3GADCwA7HAgoAHI7HEAoSCF7HAgoCGF +7HAgoCKF7HAgoCOF7HAgoCSF7HAgoCWF7HAgoCaF7HAgoCeF7HAgoCiF7HAgoM9woADAL6MQAIb5 +CB6BCcjPcaAAaCwEIIAPAQAA8Cy48CENAM9wgABABcWA2diuCS/7BSZBE64NL/sFJkATIQGP++B4 +8cCqCI/7CHXPcaAAwC+jEQCGAN/1CB6BCchAGRiAGRIBNqlwCwmRASoPj/4P8MP/z3aAAIhlFw2B +EyqOB+mKIFINVgkv+4e56q7JAI/74HjxwFoIj/sZEgM2z3GAAAhZAN10eQISDjagsUGGHwqfA6ix +yBlEA1COBbrHcoAAqEblkgsPUhBhv+WyACOCD4AAJFmkqqyqz3KAALBFdnpCkrgZRANwGYQAz3GA +AKBZdXmgoSGGBCGBDwAAAGAhCYEPAAAAIM9xgADoQvAhwgDPcYAAhARUeUCREOJAsQPaz3GgABQE +UKHH/9nYrggv+wESATYhAI/74HihwfHAqg9P+6HBKHUIdhpyBCG+jwEAAMBodyz0QMUfDR4SIMHP +cIAAuDcpYAQlgB8GAAAAMbg4YALwAdgEJYEfAgAAAddxAgAAAcogoQAfCFAAFQiQAIPgANjKIOEB +wCihAwfwA9gOuAPwANiOuAV9yXAaDy/+qXHJcKlxCnLpc0okQACu/JnoFwgfQ89woAD8RB2ABCC+ +jyAGAAD281EgAMMA2An0z3GAAOwVCYEB4AmhANiYuAjcWwdv+6HA4HihwfHA4cVRIACCCHWYACEA +QsAiw89wgAC4NwQlgh8GAAAAMbprYAQlgB/AAAAANrh6Ys9zgACcO0pjCGNYYEEtghJSIgIAwLoD +uhjiheDKIo0PAQCJDdUiDgBQcUIAJQAA2O29GAAhAAIhgADPcRxHx3EFKH4ACiDADgPwIripcsa6 +z3GAACg69CGCAAsN3hI8alR5MHoFKj4AQSmAcAjcywZP+wohwA/rcgXYd9uMu0okAAAtAy/6CiUA +AfHAMg5P+wh2MIjPcoAAMEoRzDZ6YJIbCF4Az3CgACwgD4CEFg0RCCBAA6J4AvBocLAWDRFk5bFw +KgEOAM91gACoRgW5IWUA3wQhjQ+AAwAAN71lvUglDRAEIYEPGAAAADO5DeEPJ08QCSDBAAMSkADW +Du//mBYAEJgWAxAJIMEDaHLGus9wgAAoOvQgggANC94CHGpUeBB6Irq4egNqBCCADwAA/P/PcoAA +TGcDos9yoADELA2iMBoABAnIBCCADwEAAPAsuBi4TyBDBxnIFLhleAV5KqLPcoAA7BUdggHgHaJC +Du/649gBCZ5Fz3CgAMQsq4Dk2C4O7/qpcQQljx/wBwAANL9TJYEUWw2eF1cPlBAAlhDgTwhFABCO +z3KAAKhGBbgAYvu41SHCA891gABMZyCl4qWYFgAQMg0v/wDaAaXPcYAAuE8cgQHgHKEagR9nEcz6 +oUYggAIRGhwwAdgI8M9xgAC4TxuBAeAboQDYJQVP+6QQAQC3uaQYQAAA2TmguBhCAOB/uhhEAPHA +z3CAAExnAYDPcaAAyB+WIEEPHqEQ2A6hAdgVGRiAEvDPcaAA/EQdgTmBBCGCjwAAAAIQ9AQgvo8A +BgAADPRNCx9Az3CgAPQHB4AA29cI3ocu8ADb+rjKI4IPAAABAvm4yiOCDwAAAgL8uMojgg8AAAEC +CerPc4AA7BVJgwHiSaOKIwgCCg5P/xLwAdnPcIAAQAUhoHIJL/4ocM9xgABoFgSBiiMIAgHgBKF7 +Ai//aHDgePHAUQheQ89wgABMZwGAz3GgAMgfliBBDx6hENgOoQHYFRkYgHoJL/tB2CkIXkMB2c9w +gABABSGgGgkv/gHYz3GAAGgWBIEB4AShiiMIAi7wz3GgAPxEHYE5gQQhgo8AAAACANsG9AQgvo8A +BgAAGfIA2/q4yiOCDwAAAQL5uMojgg8AAAICCurPc4AA7BVJgwHiSaOKIwgCQg1P/wbwA9nPcKAA +FAQloMsBL/9ocOB44cUCEgI2IJJBgkDh9LrAIaIAA+HPc6AA1AcPEw2GBCGBDwAA/P8VDSUQGmEZ +yBUiATAaEQAGHWUCIkEDGRMAhv0IRIAPG5iA4H/BxfHA0gpP+6jBAN3Pd4AATGcRzAAXERDPdqAA +yB9hh1EgQIACyA7yoBYCEPgWARAiewIi1gB2EAMBLyaIJVtjBfCEEBYBwnM6GIQFH4YTCMUAcHjP +cYAA/AqaCu/9NYkB2c9woADUBzSgM6AD2S2gERAXhs9xoADUB1YnACIPGRiAFBlYgwLIpBAAAA0I +HgIyCEABBPBHHliTz3CgANQHDRABhkAuACQweQUgUAACyCGAABATAUDBuBCCAHIQAQECIZQAuhAB +AULCQ8FZgM9xoADUB4gZgABZ/wnIz3GAAFxnBCCADwEAAPAsuAISAzYEsQ+DrqkAoUATAAECsRCL +YBMDAVRow7tleg+pRrEZEgI2z3CAAIRZIYdAIAQHVXhHgDpiR6CkFgAQGWH4FgAQAnlEwc9xoADU +CwHYEKEih89wAAD8/wK5K+EkeJe4mribuOxxAKEBEgE27HAgoCKH7HAgqBkSATbPcIAACFk0eDCI +7HAgqOxwoLAZEgE2z3CAAFhZ8CBBAOxwIKAZyPAkAQDscCCw7HCgsOxwoKDscKCgCRIBNuxwIKAC +yCCQVBAAARC5JXjscQChAhICNgGCIQgeATKKUIrPcIAAsElWeACIhiB/DBx4BLgleAPwgNjscQCp +AsjPcoAAQAUwiDMQgAAEuQV57HAgqOxwoLACEgM2z3agANQHnBMAASa4wLhAKAEDD4PAuA24JXgF +ohkSAjbPcYAACFkAIoAPgAAwWaCoz3CAALBFVnhUeaCxApC4GUQDFSSCAKCicBkEAM9wgACoChyQ +yBlEA0XAANhBwFpwCHcIdSnwDQoRIBDMJwgeAM9woADQGxGA8bjKICEAJA7h+s8g4QMA2ZG5z3Cg +ANAbMaAA2BQeGJACyEAiUiDPdqAA1AcoiAHhKKgJEgE2z3CgAEgsPaDPcIAATGcCgFJwigIOAEwi +AKCD8uL+BSUNkDgCAgAPhhB4GRYBlljgKwkFAA+GEHgZFgGWWOANCQUAhBYAEO8I1YwPhhB4GRYB +lljgqQkEAB4e2JMdFgCWBhIBNgkaGDAdFgCWQCcDEkfAHRYAlgCxHRYAlgGhVicAEh4eGJAdFgKW +QC4AJFB6BSIQAADaz3CgANAbkbpRoM9wgABUAxB4z3KgALRHSRoYgM9wgAAMBWCgz3CAABAFIKBv +IEMAVBoYgM9woADQGxGAEQhfBADYHg3v+o+4BhIBNgGBQMAKcIYg8w+MIAyAABETARDyGtgP8M9y +gAC4Tx6Cz3egANAPiiAQIQHgHqLM8CDYAsKacFhgEHhyGQQAAMARCJ4Fz3GgAEgIQCMAIwfwQCMA +Ic9xoABMCBtxAsEAIRkAA8AFIBAgQCHAMQQggA8AAPz/RsDPcIAATGcjgAbACCBVACMKECDZCUQl +uv4FJQ2QdPQB2BQeGJBVJ0AUDx4YkAMKH0LPdqAA1AdUHkAWABgANAIjACUPpgbBAiFRJQIlQCAb +pgPYEKYCEgE2NwoQICiJqXDIuAy5JXjscQCxA8zscQCxAcAB4EHAB8AGEgE2+ncBGhgwAsgCGlgw +BhoYMAGBIJFWJw8iNLjAuBR5z3AAAPz/A+EkeB9nGRIBNgbwFSJAMBoQAAYCfxUiQDAaEAAG7w8F +kAPMz3GfALj/GKHPcKAA/EQ9gAQhvo8ABgAAhgXB/y0KECCKJRAQGfDPcoAAuE89gs93oADQD4og +EiAB4T2iKPDPd6AA0A8d8AnIz3KgAEgsiiUIEB2i+rnPcYAANFAH8gCBgL0B4AChBfABgYG9AeAB +oc93oADQD892oADUBxp1BvDPd6AA0A9KIAAgUyB+oAP0a/4FfRjtGw1eEALIKYgB4Smoz3GAADRQ +AYEB4AGhCfATDR4Qz3GAADRQAIEB4AChGnUCyKlxyLkIiAy4JXgDEgE3ELkleOxxAKEKdIQkApEB +wEAgUgAT8oAeQBQDzApxyLkQuCV47HEAoQDYDKYB2BQeGJBOC+/+QCJSIALIkhAAAVUIngJqDkAE +ENgQHxiQJBcAls9xgACIZSWREHgCuSV4DB8YkBTYEB8YkM9wgACIZUeQJpAY2BC6RXkMH1iQEB8Y +kM9wgACIZUmQKJAQukV5DB9YkADYER8YkNUIECDPcIAATGcCgBMKBSAI2exwIKBAIlIg9fHPcIAA +XGckkM9woABoLPAgQADPcYAAQAUlgSV4Dh8YkAPYEqaiDY/8DQ1eEupwTf4I8APYEx4YkADYFB4Y +kOe9yiCCDwAABgEV9OC9yiCCDwAAAwEP9OG9yiCCDwAABAEJ9OK9iiBEAcoggQ8AAAcBJg2v+qlx +z3KgACwgMIIEwDBwAdnKISYARCCDQA+C5OAB2MogJgCA4cwjIYDMICGA7PPPcAAoCAAIGhgwBcAC +D2/8ANmn8M9wgABMchKILwgeACsIHkPPcIAATHIPiM9xgAAIcxC4IImfuIDhAdnAeQ+5JXjPcaAA +/EQNoR0JECDPcaAA1AeAGUAEz3GAALhPHYEB4B2hz3CAAFxnJJDPcKAAaCzwIEAAz3GAAEAFJYEl +eM9xoADUCw2hz3CgANQHANksoIogBAJeDK/6qXEaCK//BcDPcKAA1AcZEACGwOCoAA4AEcyhCF4A +z3CgANQHA90gGFiDAdkUGFiAANjPcYAADAUAoQDYkbjPdqAAyB8THhiQz3CAANwCEHjPcqAAtEdJ +GhiABsjPcYAAEAUAoW8gQwBUGhiAExYAlvG4yiAhAJwI4frPIOEDz3CgANQHDxAChgYSATa0GYQA +ExhYg89wEiAAAHoM7/4ZEgI2BsiwEAABoBYBEGTgMHDKIIUPEigIAIX3z3AAKAgACBoYMBHMBCCA +DwAAAggVCJEABhIBNoogBABqCu/9mBEBABkSATbPcoAAGFkA2DR6ALICyAIKoAIakIkCL/uowOB4 +8cDhxQLIpBABAJgQAgBRIQCAchABAUhwBvKGCu/+ANoIdQfwAeF6Cu/+ANqsaGoKgAHPcqAAyB/4 +EgEAAsjPc4AAqEYQiAW4AGMRCF8DAdgToniCWYIG8ALYE6J6gluCAiVAEHhgEHPAIm0ADXEAoQ1w +QKAAFgBAABYAQALIz3KgAPQHcBABAWi5J6JwEAEBaLkweU0CL/twGEQA8cDPcIAAGGwGgAHZz3Og +APQHgeAZg8B5DLkP6GQTBAAKIcAP63IF2M9zAABRCZEGr/lKJQAAAsgckCV4DXEAsQLIPZANcCCw +AsgvgA1wIKACyEAQAQENcCCwAsgxgA1wIKACyEgQAQENcCCwAhIBNhyRhiD/DEEIEAEzgQ1wIKAC +yFAQAQENcCCwAshUEAEBDXAgsAISATYckYYg8w+MIAyACvQ2gQ1wIKACyFwQAQENcCCwAhIBNhyR +hiD9DIwgAoIR9GARAQENcCCwAhIBNqQRAAAPCN4FOYENcCCgAsgL/QISATakEQAAEwieAQGBKQge +BJz/VweP/jqBDXAgoAISATakEQAAhiDzjwbyO4ENcCCgNweP/jMHj/7xwAHYz3GgAPQHC6ED2Aih +z3CgAPxEPYAZgGkIXwIEIb6PAAYAAC704HjgeOB4VQheQwLIz3GgAMgfsBAAAZYgQQ8eoRDYDqEB +2BUZGIAODq/6QdgtCF5Dz3CAAEAFAdkhoALIpBABAJq5pBhAAKINr/0B2M9xgABoFgSBAeAEoQoM +T/+rBo/+8cAaCA/7pBEAAKHBUSAAgM9wgACoCih2A/IbkALwGpCYFgEQBCG+jwEAAMB2HgQQLfRA +wR0JHgIgws9wgAC4N0pgBCGADwYAAAAxuFhgA/AB2AQhgg8CAAAB13ICAAAByiChAB0IUAATCJAA +g+AA2Mog4QHAKKEDBvAD2A64BPAA2I64BXmYHkAQnhYAEZQeQBCSHgQQghYAEZAWExHPdaAA1Aey +HgQQANiAHgQQfh4EEBkVAJYjCDUOEBaSEBHMz3GAALhPhiCIAhEaHDAVgQHgFaGd8A8VEZYBEhA2 +AdnPcIAADAUgoADYkbjPcaAA0BsRoc9wgADcAhB4z3KgALRHSRoYgM9wgAAQBcCgbyBDAFQaGIAR +gQkSDzbxuMogIQCwDKH6zyDhA6QWABBHCJ8FCRICNgIiwQMA2A8JUAACJ4EQjCHDjwL0AdiT6BHM +z3GAALhPhiCIAhEaHDAUgQHgFKEPHViUCRrYMwEaGDRP8AEaGDQRjs9xgAAEO8K4MiEFAAka2DPP +cYAADDt0HkQR8CEBAKQWABAleKQeABAAlqBwEHiQHgQQcnDKIcIPyiLCB8ogYgHKI4IPAAD4BlgD +ovnKJMIEEBaEEAwiAKHKIcIPyiLCB8ogYgHKI4IPAAD5BjQDovnKJYIEDxUAlrQeBBDOCy//yXCk +FgAQhiDlj5AKYv7KIIIDDx1YlGUG7/qhwPHAEg7P+hDMAN2xCB4Az3CgANAbEYDxuMogIQCgC6H6 +zyDhAwLIz3KAAKhGMIgFuSFiz3KAAEAFLbnAuYQpCwoAIYF/gADogCaitBECBs9xgACwRUChz3GA +AABGSJEZEgE2z3agANQHkBAAASMKTgAZFgGWOOAbCQUAz3CAAJgEIIDPcAAAmB6uCa/6h7kPFgCW +AhIBNrQZBAAIyCIPr/4ZEgI2AhIBNpIRAAFCDa/9lBEBAAHeHfAD2M9xoADUByAZGIAB3hQZmIMA +FgBACRoYMAAWAEABGhgwAsi0EAABDxkYgMvYHg5v+hkSATYZEgI2z3eAAAhZFCeAECiQAhIDNpbp +mBMBAFV/LKc0p89xgADoQvAhggDPcYAAhAT0IYEAvBtEAMgYRAAG8MgQAAG8GwQAugvv/qAbgAMC +EgM2oBMAAAQgvo8BAQAAF/IA2c9woAD8RJ65IaDPcKAA0BsRgEsI3gMOCq/9AdjPcYAA7BUfgQHg +H6EZ8JITAAGUEwEAkBMCAbITAwEaCC//SiRAAAISAjagEgEAJXigGgAAzthiDW/6ARIBNgISDjag +FgAQBCC+jwEBAABn8s9woAAUBAPZI6AIyAQgvo8AAAEQIPKkFgAQPQieBM9xgABABQCBGOigoQMJ +nkXPcKAAxCyrgOTYDg1v+qlxUyWBFP69zCEigAbymBYAEEIMr/4A2gISATagEQAAFwgeBIogCAAQ +GhwwoBEBAG0GIAD62EcIHgUJyNCJANozEY8ABCCADwEAAPBBKA0Dz3GgADguB4EPIkIDAdxGeAeh +Gch2DCAHACwAEMd3gACoRgW+EOffZ6CviiAQAAgaGDACyKAQAQAVBiAA+9gDzM9xnwC4/xihPggv +/xnICMgEIL6PAAABEBnyVggv/wISATYCEgE2DOikEQAA8bgRzMUgogTPIGEAERocMAGBDwieAxHM +gLgRGhwwzNguDG/6CBIBNtIIL/8CyOYJL/8CyAISATYckYYg/QyMIAKCD/QQic9ygACyRgW4EGIP +CFEAYBEAAYS4YBkEABkIH0PPcKAA/EQdgAQgvo8gBgAA9/NRIADDANgK9M9xgADsFQmBAeAJoQDY +mLgM6APZz3CgABQEI6CKIBAASQUgAAgaGDACyKQQAAAEIL6PAAAAMNjyEwgfBbIJD//W2JILb/oI +EgE2AsikEAEArQkeA34Lb/rN2JIML/8B2AISATYD2h2xz3CAABhsBoDPc6AA9AdFo4HgAdjAeAy4 +hSACDQ1yALICyF2QDXBAsALIT4AA2RsKHgDPcoAAQAUGgqKADXCgoAaCRpAG8A1wQKACyEAQAgEN +cECwAshRgA1wQKACyEgQAgENcECwJKMCyBkSAzZ+EAEBgBAAAc9ygACEWXV6GWEHgjhg1g4v/wei +CBIBNnEEIADQ2NYKb/rR2AISATYBgR8IHgbPcIAAoAgAkB2xz3CAAKQIQIABgFGhEqEH8MYLL/8C +2AISATYdsSoPD/8CyF4OL/94EAABgOAoBAIAAsgZEgI2gBABAc9wgACEWVV4R4BZYSeg0thyCm/6 +ANkCEgM2AYOYEwEAlBtAACsIHgbPdYAAiGWpcB4PL/9ocRDYEBocMBHMo7gRGhww+ghv/6lw0QMA +AJ4TAAFAk3QTDQGSGwQAumJQepAbhACCCW//ghMDAQh1z9gSCm/6qXEhDR4WA9nPcKAAFAQjoIog +EAAIGhgw/diJAyAAqXECyKQQAQBVIMIH6QkeBcIKT/8CEgM2khMCAZQTAQCTCBAASHDPdoAATGdA +hmIK7/5ils93gAAARiiXgOHKIIIPAACEHtwMQvrPdYAAnAQAhSHoGcgCEgI2FSIBMJgSAAAaEQEG +0giv/iDaI5UCIE0AAsgghpgQAAC+CK/+INoXDSUQCHEQvc9wAAB0HpYMb/qleXoNT/8Il4DgyiCC +DwAAhB6ADGL6yiEiAN0CAACkEwAAp7qSG4QAkBMCAbS4pBsAAJITAAHKCe/+sBMDAQPZz3CgAPQH +JaACyBkSAzaYEAEAVSDCB89wgAA4WXV4IKAKghUIHwEWD8/+29jyCG/6CBIBNgLIpBABACh0hCQa +kAnyWgwP/gPZz3CgABAUJaAT8BEJHgKiDYAAog2AAA3wcBACAc9woAD0BwDZR6DPcKAAyBwnoAIS +ATbT2KIIb/qkEQEAAsgBgBEIXwaqCS//BNgCEgE2HbFz/br9GnDU2H4Ib/oKcQISAzYZyIQTAgGC +EwEBBCC+rwYIAABZYc9ygACEWRV6B4I4YOwBIgAHos9woAAUBAPZJaABg0kI3gCkEwAAUSAAgM9w +gACoCgTy3ZAD8NyQz3GAAExyEoktCB4AD4nPcYAACHMQuCCJn7iA4QHZwHkPuSV4z3GgAPxEDaEE +8HYTDgERzFMgQIAN8tXY7g8v+ggSATYIyAYSATYZEgI2sf3PdYAAiGWpcJ4ML/8CEgE2jgsv/8lw +gOCs9ALIkhAAAVEggIIYCAIEAsgBgLkI3gDX2KYPL/oA2Q4K7/2A2AgSATYEIYEPAgABABESAjcX +CYEPAgAAAA8IXgdPIsAAERocMAXwo7pQeBEanDACEgI2IYJdCZ4Bi7iMuBEaHDAwijMSgAAEuSV4 +z3GAAFxnz3KgADgupIIGsRHwLypBA04igwcA2g8iwgBGfc9ygADgWPQiwgATCIAA8u3PcAAA//8E +sQbwZLHPcJ8AuP92oAjYEBocMM9xgAC4TxGBAeARoSjwENgQGhwwEcyjuBEaHDCmDS//qXDY2OIO +L/oBEgE2AsgBgBUInwMZyAHaACCBD4AAiFlAqRHMUyBAgAryBhIBNoogBACeDW/9mBEBAALIGpBC +DSACGRIBNhHMCBIBNicI3gCWDi/619jPcIAArGUCEgE2AoCYGQAACMg6D2/+GRICNggSATbc2G4O +D/rdBY/68cDhxW/YlbjPdaAAyB8SHRiQz3ABAEA8FR0YkA4Iz/2KIAQADqXNBY/64HjxwEoNj/qu +wc92oADUBwPdEx5Ykw8WEJYZFgCWwOC+9wAWAEAAFg9A73ic4Mohwg/KIsIHyiBiAcojgg8AACoL +yiTCAPgBYvnKJSIAi3A2C2/6DtkGFAExABQAMVEhAIHAIKIAA+ALwwQggA8AAPz/ViABAg3rz3Kf +ALj/eqIsw3uiAsN+os9zAGwEAHmiGRYClv8KBIAAIQAEDx4YkCAeWJPl2JYNL/rpcQHABCCADwAA +AED5BK/6rsDgePHAjgyv+gPbz3KgANQHExrYgA8SDYYAFgBAABYBQC94nODKIcIPyiLCB8ogYgHK +I4IPAACVC8okwgBIAWL5yiUiAAAWDkDQfgAWEEBWJgASUSAApcAgogAD4AQggA8AAPz/GRIOhkIg +DwT7DsSTHWUPGliDIBrYgAYNL/ra2AQggC8AAABAbQSP+uB44cUB2hvoLykBAE4hgwfPcaAAaCzw +Ic0Ar33PcaAAGCzwIcEAL3kwdcoiIgAJ6gDZDyHBAAYgQIDn9QHYAvAA2MkAT//xwLoLr/rA2oIk +AzAIdRpxz3GAAKQ7fgvv/YtwAdnPcKAAFAQkoM9xgAC4TxOBAeDivROhyiciEAP0vv8IdxnIz3Gg +AGQuz3KgADgu8CEBAAeCBCBRAJjwtv/PdoAAiGUId8lwFgkv/4txsgov/8lwivAA2M9xgAAMBQCh +ANnPcKAAyB+RuRMYWIDPcIAA3AIQeM9xoAC0R0kZGICLcM9ygAAQBQCibyBDAFQZGIDPcKAAyB8T +EACG8bjKICEArAhh+s8g4QNEJo0UHQ5eEI7YkLigHAAwnw4eEYbYkLigHAAwSfAG74zYkLigHAAw +Q/AkwAW4x3CAAKhGIIAodIQkDJAP8gHdEQleAovYkLigHAAwMfCI2JC4oBwAMCvwIpAzFIAwKQkO +AAnIBCCADwDAAAAdCIEPAMAAACLAgODKIIkPAACNAM8gKQQS9grBjCH/jxHyz3CgAMgfpBAAACJ4 +EwiFDwCAAACH2JC4oBwAMAHdgOfMJSGQcPUD2c9woAAUBCOggOepdnX1UyZ+kAjyz3CgABQECYCA +4G31Dw5eEAQhACSG/4DgZfNxAq/6gCQDMOB44cXhxqHBSiQAcgDZqCDADgAhgg+AAJCBhCgLCjIi +Qg7Pc4AAxGXPdYAAqApAwiDCw7pcevQjgwBMFQIRemJ6lWK6W2MD4s91gADEOvAlTRAiugUtvhBT +IQ5wACZCHl161Wg1fsd2gACIXkC2A+MiuwUt/hBTIQNwACNCDl16QbYB4aHAwcbgf8HF4HjxwOHF +qcGLdalwz3GAAGQ8Qgnv/STaqXAiD+/+AhIBNroIL/+pcNUBr/qpwPHAVgmP+qHBz3GAAPBjJIHP +coAAqAraks9zgADUZQQhgQ8AAAAQRSFBA0DBIMLPdaAAyB/Dulx69CODAKAVAhDCe3MK5AAA334V +Apajun4dmJAQeHB7Ugkv/xTaVwgfBgPYz3GgAPQHBaHk2g1wQLANcOCwiiL/Dw1wQKDPcgAA//8N +cECwz3KAAEAFBoJggA1wYKAGgkKQDXBAsOSh2g4P/kAVARYweaYIL/3JcAHYAvAA2AkBr/qhwOB4 +8cDPcIAAqAoYiCEIUQHPcAEAoIaaCkAAeggAAQhxz3CAADwaOgmAANHA4H5xAW/5E9jgePHA4cU+ +DmAAMNi0aDYOYAA52AV9GL2Qvc9wgACIPFIOYACUvSi4pXjPcYAAYAWxAK/6AKHxwAohwA/rcgXY +BttKJAAAEQUv+QolAAHB2c9woAAEJSCg4H7gfuB48cDhxc91gACca6lwMg4v+gPZAYXPcaAAgCUM +oQKFDaEAjVEgAIAA2I64BPIPoQPwEKHSDQ/6TQCP+uB48cDKD0/6z3WAAGQFAIXPdoAAyF7kkOlx +Agjv/IYh/AMacA0I3gAfhoC4H6YghQCROGAApVQWgBCS6OlwfgtgAIYg/AMJ6BkIHiDPcIAAqAoJ +gA0IXwAfhoK4H6bRB0/68cByD0/6z3CAAMhePoAEIYEP//+POAQlgF8AAHDHJXjPdYAAyF6WC2AA +HqWA4JgdABDr8g8NnlPPcIAA/AoCiAzwEQ3eU89wgAD8CgOIBvADhY4K7/0khZQdAhAehYYg/wMR +CBEIDQ3fUoDYlB0CEJQVgBBAKAEGKQjfAYK5NwqeU0QiPtML9M9wgADIXgGACwgeAJYMQAAd8JYM +QAAb8B6FUSKA07O4HqXFIYIPAAAAB0UhAAbPcYAAVF8oiYYh/Q9SIcEBRbkleM9xoACIJBChiiHW +AM9woACAJS+gz3GgAMQnQREAhlEiwNPPIOIC0CDhAkEZGIDPdYAAyF4AlQQggA8AAMyAFQiBDwAA +yIALhQ0IHgAqCs/8TvAehVQVghCDCN4ETdgJuBoZGIAH6gHaz3CgANQLUqAE2BAZGIBNcRoP7/mK +IEQOCwifRP8JHsbPdYAAyF7PdqAAxCcuFgGWFoUieGS4EHiGHQQQz3GAAKgKPg2gAC+RGhYAlgQg +gA////8AGh4YkBEWAJYpCN4CANiLuBMeGJAa2BkeGJAK8AfqAdrPcKAA1AtSoATYEBkYgB6FaQie +ARSVYQhfAc9woAAsIA+AqugmDoAGBuhRJUDTAdkD9ADZVBWAEIDgzCGigDDaA/SQ2s9zgADsNs4K +b/1VJUAaH4WUuB+lHoWQuB6lDPDPcYAAPE8NgQHgDaEQ2c9woACQIz2gwQVP+s9wpACQQU2Az3GA +AOhdQrEagAOxBCCAD/8AAAAwuASxz3CAAOhdANoRCF5Gz3GAAMheMYELCZ4CQrBDsESw4H9ZsOB4 +8cAKDU/6z3CAAMheDpDPcoAA6F0Ass9wpgDo/wuAz3WkALRFA6IMFQOWDRUBls9wgADIXkQQjgAv +JscA/9gQuMl0hCQDnAQjBwAE9FsOHxAyFQCWUyCPAP9nAbL/2PR/CLjvf2R4QC8EEgAkBQAAJsYD +BSWFAUAvABYEI4MPAP8AAEAvBhQbYwAnhwH/2AUlxQEIuAUjQwEEIQUA+WEAJQABBXnlsm94BCOD +D/8AAAAou2V4L3kDsiSyBBUAlgKyz3CAAMheEYAbCB4Cz3CAALg3yGAPCJIAz3CmAOj/DYAD8ADY +BqIFogDYSiSAcAbZjbmoIEADKdsSu/AjTQBAIgMPFXsB4aCjAeBpBE/64HjxwO4Lb/ob2M9xoADE +J1IREoYVEQ+GAN3PdoAAyF4WGRiA47/KIEEjEPIdhgHdg7gdps9wgAC4TyKAAeEioKoM7/mKIMUI +GnVRIMDGSiEAIBLyHYbPcYAAwE4B3Tp1hLgdpgWBAeAFoYoghQl6DO/5/BEBAAsPHhFUFoAQA+gA +3wvwHYbPcYAAuE8B34W4HaYFgQHgBaHPcKAAxCdMIACgzCEhoMwnIZA88gDYnrjPcaAA/EQBoQDY +BaEehrC4HqaoFgAQz3agAMgfZOAephDYDqYB2BUeGJDKCC/6CdgD2B6mENgOpgHYFR4YkM9xoADE +JxkRAIYE6PULHsBPEQCGOgzP+4Xvz3aAAMheOPDPcYAAuE8FgQHgggjv+wWhqfBPEAGGQhAAhgQg +vo8AwAAAJvIBth6GQQjeBIoghA6qC+/5iiHODkIPgAAAloYg/ACMIAKAFPSmDYAAkugD2c9woADU +CzGg4HjgeOB44HjgeDGgBvAAlqoK4AE0llQWgBAa6M9zoAD8JRSDz3KAALhPJoIAIECABqITgyeC +OGAHoh6GM/IlCJ4DAdnPcIAAcAUgoCvwJQoeIM9xgAC4TwOBAeADoR6G8PE/CN4DAdnPcIAAdAUg +oBnwA9nPcKAA1AsxoOB44HjgeOB44HgxoBkJESAdhs9xgAC4T4K4HaYEgQHgBKEB3R6GFwgeBJUW +gBCkFgEQyXIWC2/8AdsD8PYKj/wfhg8IHgDPcIAAiGV2Cc/+z3eAACxqGYcG6MYOz/0A2BmnVg+P ++89wgACoCgiAFwjeAontJ//PcIAA6F2g2ZYN7/nE2h6G8LiwD8L93QFP+uB48cB2CU/6z3GAAHRf +z3CAAGQFIKAA2c9wgABEXymgz3AAAP8/z3GgAAwkAaEb2AShz3aAAMheLQgeRB2GhLgdps9wgAC8 +BCCABYEB4AWhiiCFCSIK7/kkgfINj/uPAgAARBaAEPGGwrgEJ48fAAAACFQWghD7f891oADEJwDZ +Ferg2r8dmJCU2pUeghAE289ygAA4BWCiAto8HYCQz3KAAHxnIaIH8EDZvx1YkNTZlR5CEAAgkQ+A +AOiAvBGBIAAgkg+AAISECBKAIAUh0wOyDe/7BSDQAwHYEB0YkMQRgCDPcYAAxGXleBumbBaAEMO4 +HHj0IQAAZB7AFF4eBBAQEoAg5XgcpnAWgBDDuBx49CEAAGgeABTPcYAA5GVgHgQQZBaAEMO4HHj0 +IQIAih6EEM9ygAD0ZfQiAACOHgQQaBaAEMO4HHj0IQEA9CIAAIweRBCQHgQQEMyGIP+F+A3B+89w +gACoCgiA67jQCsL/HPDPcYAAiGcAgWOBQ6FmeAChBIEMFQGQEngleAwdAJAA2I+4Ex0YkIogvw8I +HQCQGtgZHRiQkgnP+892gADIXh2GUSDAgZv0z3WgAMQnERUQlgDasQjfozMIXyJdCJ8jrwgfIMsI +3iAI2BMdGJCyC8/7tQgRAALYPB0AkCOGz3CAAHxnIaDY8fH9oBYAEJEVAZYB4MO5oB4AEJ0IQYCK +IggAEx2YkJEVAJbDuI0JAIASHZiQwvE6FQCWOwieAM9xgACIZwCBLwgfAIC4AKGKIP8AAdoEoUOh +OhUAloYg/wEDuAGhDBUAkEYgAA8MHQCQCB2AkADYjrgTHRiQPQ0e0ATZz3CgAJAjPaCW8ej9Atg8 +HQCQI4bPcIAAfGchoB6GGQjehCrwEx0YlCnwVBaBEInpQhUAlgQgvo8AwAAAA/QdCB4ivxUAloDh +pbi/HRiQiiAEABMdGJBw9R0InyAKIcAP63IF2IojDAOKJIMPmQPv+AolAAQTHRiUqf7lBg/64Hjh +xc91gADoXQmlKqV4tUulAdgZteB/wcVKJAB6ANmoIIACANrPcIAA6F01eECgAeHgfuB4RoEJ6iOB +YIEigmJ5MHAA2AL2AdjgfuB48cDPcYAA6BqYcPj/B+jPcYAACBuIcPX/g+gA2Ajwz3GAACgbiHDx +/3noAdjRwOB+CHM4YNW71bkNCeUANrgCI0IACvDPcoAA+GtFggHgybgienpiFrjgf0V44HjxwPIN +D/oIddd1JQAAgADYSvfPcYAA+GslgSUJRQMifQHg+fHPcIAA+GvFgKlwmgggAMlxBS4+EAIlTR6M +IBCAyiHGD8oixgfKIGYByiNmCcokJgCIAub4yiUGARa4AQYv+qV4AdrPc6AAsB9Zo36DBOgiewkI +xAAA2APwSHDgfs9yoAAsIHCCCegCI0IAEw6EcACAAAAPCIQAANgE8P8IxYAB2OB+4HgM6M9yoACw +HwHbeaJegiJ6UHDCII0AA/cA2OB+CiJAgADZ7gABAC8mAPBKJkAATgAGAE8AIACKJf8P4HgKIkCA +ANnOAAEAbAAkAC8mAPBcAAUAKwg1CEomQAAIcQDYAiG+gOAgxQdCeQHgAiG+gOAgxQdCeesH7/8B +4C8tAQBAJUUAAiZ88QAAIAAAKEAB6CBiAy8gAIAvIUsAAiG+gMAghgHCIYYA4H4RACAASiAAEEog +QBAOIkIALyALEs4gRYCKJf8PCAAFAC8tAQBAJUUAAiZ88QAAIAAAKEABSiZAAOggIgMvIACALyFL +AAIhvoDAIIYBwiGGAEomAABCIP6QziCCAUQgfpDOIYIB4H59AgAA4HjgfuB44H7geOB+4HjgfuB4 +4H7geOB+4HjgfwHY8cDhxc9xgACoCimBUSFAgMogogAk9ES4z3GAANgaw7gJYQsJHgAzDZ9RMwle +AM91gACoChiNHwhQAF4MQAYI6M9wgADcgwyICwjQARiNDwiRAAsNnlEB2ALwANgxBA/68cC2Cw/6 +RCIOU011hiX8E01wTXAEJYBfAAAAIEEofoME8hYMQAaE6ADfA/AB3ycOERLPcIAAqAoYiA0IUAAT +DV5RBfCGJfbXA/IB3o/wAN6N8P/uz3aAAMheVBaAEPno1gtABhzoz3CAANyDDIiH4MwgYoIU9AGG +jCD/jxD0JJbPcAAA//8ZCQEABYaMIP+PBvQMlrcIgI8AAP//hC8LGgAhgH+AAOiAKYDPcoAAlDwL +CV4BQCIBBwPwQCIBBBiICWFBLQARCGIWec9wgACwPHy4OGAoEIAADQgeAD6GhiH2jxbyCwheAD6G +JQmeAgsIngALDR5SAd4L8BUI3gDPcaAADCQxgYwh/4/38wDeUSCAgcomIhAiC0AGCOgEJb7fAAAA +IsomYhAV7s9xgADIXh6BOwgeAowlApDMJYKfAABQAMwlgp8AANAAEfSTuB6hDfDPcIAAqAoJgBEI +XwCMJQKQBfQHCJ4BAt61Ai/6yXDgfuB44H7geOB+4HjgfuB4CHID8AHgIIj+6eB/QnjgePHA4cUL +CDIMCHUZDZIeCiHAD+tyBdgS25h1/Qav+LhzQiUAHHkCL/oPeOB48cD6CS/62HAA3e//yWgrDhIQ ++HCpdzImgAMVCBIMEQiTDu3/Mm84eAV9AedCJ0cA5w91gGG+LQIv+qlwCiYA8Iogvw/KIGQA4H8v +IAMA4H+KIP8P8cCqCQ/6ggogAAh1z3GgAMgfRYUM6PQRDgACgGSFxHpFe/QZwAAihQChC/D0EQAA +RHj0GQAAHNgYuBUZGIDZAQ/64HgP2Zq5z3CgALAfNaDgfuB48cBWCQ/6CHXPdqAAyB+kFgAQuGCk +HgAQAdgTpliGOYYA2AAiQoMBIQEAWKY5pgLZM6Y6hluGACFBgwEggAA6phumFYbWDKAAqXEVpheG +zgygAKlxF6YP2Jq4DqbPcIAAKBvT/89wgADoGtH/z3CAAAgbz/9NAQ/6z3GgAMgf9BEAAADaRiDA +D/QZAAANyJq4m7icuA0aGDAc2Bi4FRkYgFihWaFaoVuhpBmAAM9wAAwPAA6h4H7gePHAnggP+s91 +oADQG9OFEQ6eFs9wgADoGm4JAAAPDt4Wz3CAAAgbYgkAABEOHhfPcIAAKBtSCQAAHNgYuBOlzQAP ++uB48cDhxSWAQIBCIgKAyiJiAIDiyiHCD8oiwgfKIGIByiOCDwAAXgDKJCIAHAWi+MolAgFggRUL +QABCgKKDQn0NDVMQYIP1C0GAQYMBo2CgQaAAokSApYBAJQMWFwpeAEaFBuqigkKAQn0HDVIQAKNE +gKWAQCUDFxcK3gBHhQbqooJCgEJ9Bw1SEACjQYALCYEAIg7v/wWAOQAP+uB4QIAVCgAAZIILI0CA +BfRAgvcKAYAA2uB/SHDgePHAng/P+Qh2AIBCIAGAyiFiAADYJOklhkGGAd8wciCGQYZBoSCiAKbP +cK3eAgABpqWGwH8GhQ8OARCpcALZ6v8GpaWGB4UPDgEQqXAI2eb/B6UF76YN7/8FhgHYqQfP+fHA +Pg/P+Qh1KHbm/wh3wqWpcLb/kQfv+elw4HgggBBxyiEhAOB/KHDxwBYPz/kIdx7wAIYhhiGgAKEA +2ACmz3Ct3gIAAaalhgaFDw4BEKlwAtnN/walpYYHhQ8OARCpcAjZyf8HpSOGYHnJcOlw7P8KJgCQ +B/IDhyCAAoYieLcIUoAaDe//6XAdB8/58cDhxQh1A/DD/6lw4f/+6BkHz/ngfuB4gOHKJE1w6CBt +As9xoABQDCWBARhSAOB+8cCCDu/5uHCYcc9zgABwBQKDI4PPdoAAyF7PdYAAFD0CeR6GObjBuBR9 +ARWHEM9woADUCzwQBgDPdaAA0A8NCWUBANoA2EPwqBYAEM9xoADIH2TgHqEQ2A6hAdgVGRiAGXMG +8M91oADQDwlzFxUAliODAiDAAQJ5SCEBAAKDAnlIIQEAKQxRACUKRQDPc4AAVBsCiyUVD5bBuNNo +AeACqwOD2H/neAOjAeLw8SMLH0DPc6AA1AuxCUSBCBABEAHYoHEIGEAQPBuAASEGz/n2Dk/7uvHx +wK4Nz/nPcIAAVF8IiIwgAoAr8jVox3GAAKhGwIHPcoAAyEjPd4AAqGtMFw8RFnphglAmjRWGJ7sf +oKGMJ0SQhiMBDmGiBfSRvaChC/Cxvra+wKEPD1EQlr7AoYUjAQ5hok4MD/oA2c9wgACoa6kF7/lP +GEIA4HjhxeHGz3CAAFRfCIiMIAKAz3KAAOBrFvLWis9xgADISLVox3WAAKhGFnkAhWGBBu6VuACl +q7sF8LW4AKWLu2GhANgXqsHG4H/BxeB48cDqDM/5z3CAAFRfCIiMIAKALvLPdYAAqGsyhc9ygADI +SNVox3aAAKhGYIZEIQSDFnrhghLyUCOBBSCmhicBHuGiDQwRAZG5IKYF8LG7trtgppoLD/oH8Ja7 +YKaFJwEe4aJPFYAQorhPHQIQ5QTP+fHAfgzP+c92gABUXwiOjCACgDLyz3CAAOiASIDPdYAAqGsx +hbe6uLoEIYEPAwAAAAe5RXkooP4Pb/oA2BGFSI7PcYAAyEhRIICCFWrHcIAAqEZggFZ5QYEF8pW7 +YKCrugTwtbtgoIu6TxWAEEGho7hPHQIQdQTP+fHA5gvP+aHBCHVAwc92gADIXgCWSiZAIIYg/ACM +IAKAwiaCJQLYynFW/4/oHoazuB6mANjPcYAA4GsXqc9xgACAawyxZPBCJZIQTHSEJAOQ/fPgeM91 +oADQDyUVDpYlFQ+WSiRAIBAVFZYCbwwiAKDCJA4lLyMAJf4PYADJcBpwFCcRFSMOECAPDlARi+YA +2MogYQAC8ALYz3GAAFQbJIELIQCAA/IA2QLwAdkqcDX/EehJCNAhz3CAAIAbFiAABECABogdDgEQ +DOrpcGB6AMEV8M9xgADIXh6Bs7geoavxCiHAD+tyBdiKIxcESiQAAAEAr/gKJQABAdiidxAd2JMC +IlIkgODMIyKgofUlA+/5ocDgeOHFz3CAAFQbIIgB22GoIOnPcqAAsB95on6CQoCjgADZMQ2BEM9y +gACMBUSKg+oB2grwQYACI40A9w2Fn0wAQEshqChyBwpRAGGgIqjgf8HFoqDv8fHAkgrP+RpwOnGK +IEcNegtv+Yoh1Q7PdoAAyF7PdYAAqGsRCDQkAN8M2Olx+/6M6B6GTx3CE7O4HqbPcIAAgGvssB/w +qXAM2e7+z3KAAFQbAIr82QroAJYkeIwgAoAG9CWVBJUneAOiQiAAIypxi/8AloYg/ACMIAKANA/B +/3UCz/ngePHAGgrP+aHBCHaKIEQP9gpv+clxJQ71EADZz3KAAMheHoKzuB6iz3CAAOBrN6jPcIAA +gGsssI7wAtjX/oDgivLPcaAAUAwFgc91gACoaxKtBYETrQmVjCCIgGK+TPIS9j0I0AGMIMSBb/Rj +DpEQyXAA2cn+K+hVJcAUyXHA/iHwjCDIgFHyjCAQgF/0BYEJboXghA3h/8ohIQBX8KsOURDJcADZ +vP6jCBAAVCXAGclxs/5PFYAQgbhPHQIQRfBPFYAQgLhPHQIQP/B/DlEQyXAA2bH+cwgQAItwyXGo +/iDAUyABAIYgfw9MHUIQHHhNHQIQ5/FTDpETz3CAAKgKGIhHCFAAyXAA2aP+H+jPcoAAgGtIcAbZ +mv5AIgACBtmY/gySgbgQ8CMOERHJcADZmv4L6M9ygACAa0AiAAUE2ZD+DJKAuAyyiiBED7oJb/kp +lTUB7/mhwOB48cC6CM/5CHUacc9wgACoa3oLb/lE2c9wgADIXh6Az3KAAPRkObhTIEEAz3CAABQ9 +NHhBiiCIANtVec9yoADUCy+iz3KAAHAFIYhiogIlQBCA4MogzAADok1xhiH8A9DhzCGCjwAAgAAP +8owhA4QQ8gohwA/rcgXYiiOZDkokAAAtBW/4uHMKcWf/A/CH/5EAz/ngePHAHgjP+c9ygADIXj6C +GnCqwQDYIQneAs9xgACoCmIRgQBEEoMAwN1keYYh/w4iuTp9CPDPcIAAqApMEA0BAtiGEgEBAnkR +ggThFgiv/QDaBghgAAIgTgMD2M91oADIHxOlGIUA2ULAGYVDwBqFRMAbhUXA9YVcFREQQBUAFh5m +z3CAAKhrQIABgAAigoMBIEAAQMJBwItwFwhRIITBxgpgAIbCUgggBgh2JJAK8ILBsgpgAIbCCHbP +cIAA+GskkM9ygAD4a2WCBsIEuxULpABAKYACFwiFAAJ6AQiEAAbwcgtgAIbACHJGwi8OkRDpcAIL +YABIcQh3KnD6CmAABsEGwzpwBMIHwQXAACLCgAEgQABEwhXwlu7pcAYLYABIcQh3KnD6CmAABsEE +wTpwBsMFwAfCAiHBgETBAyCAAEXAFw5QEM9wgACoChiIhODMJiGQANgC9AHYLyIHoDf06XCSCmAA +A9kIdipwigpgAAPZAMEIdwHAQCHBgEEgAABBwATAQMEFwUAgwIBBIQEARMDGDiAARcERCBEg1aUA +wBilAcAZpRkIkSDVpQDAGKUBwBml96UEwBqlBcAbpQ8IUSD3pQDAGqUBwBuliiAHDkoPL/lKcUwi +AKAB2cB5z3CAABg1NKiVBq/5qsDgeM9xgABIGyCBANiD4cwhIoAC9AHY4H8PeAoiAIDxwBTy+P+A +4MohwQ/KIsEHyiBhAcojgQ8AAKAGyiQhAPACYfjKJQEBz3CAAEgbQKDRwOB+8cDPcoAASBsggoDh +yiHBD8oiwQfKIGEByiOBDwAAqQbKJCEAuAJh+MolAQEBogHaz3GgAMgfUKFKGZgASBkYAN7x4Hjx +wKoNj/nPcaQAtEUpEQCGz3aAADxPEaYrEQCGAN0Sps9wpQAIDAOAGKYOEQCGEHowuFOmFKYPEQCG +FabPcIAABF9QiHKIWaY0iHqmC5A7pizgAiCPAAIgwgAieM9zgABIGyCDXab8pjcJNQEepjMmQXCA +ABw9QCeAcjR4AHgD2MH/QNjO/7emC/DPcqAAqCAxggKDoqM4YBemAdgSogHYcQWv+Ram4HjPcIAA +jAUEiAboz3CAAFQbAYgD8AHY4H7xwO4Mj/nPdoAA6IDDFgAWEQheAc9wgADcgwyIDQgQAgmGUSBA +gYfyz3GAAMheA4EqCC/9JIEIdSEIUQAuDcAFDOjPcIAA3IMMiBEIEQIB2Bz/jg3ABQ/wje0SDcAF +CejPcIAA3IMMiIfgAtgC8gDYFP/iD0ACz3GAAPhrBoFFIEABBqHPcIAAqAoYiM91gACoa00IEAHP +cIAAXERWiHeNz3GAADxPDQuAAACAIQgfAM9ygABwBQeCAeAHogDYBaIGogCiD4EB4A+hBfAOgQHg +DqEJhlEgQIE0DYIAz3GAAHAFBIEL6ADYBKHPcYAArAYAgaK4DgmgAgChTxWAEFEgwIBwD4L/TxWA +EFEggID0DoL/jP+1/4Dg1Axi+Mog4gTPcIAATHIRiIDgxAxi+MogYgQpBI/54HjxwM9wgACAawyQ +DQgeAI4ID/0G8FEgQIAcCAL9z3CAAOBrF4gPCFAAEQiRAJT9lQXP/3X9jQXP/4kFz//xwHoLj/nP +cKAAxCdSEAGGQRAAhoYg448A3Qby67nRIaKBQPLPcIAAqAoJgM92gACoaykIXgEUjoHgyiAhAaAP +YQLKIWEAz3CAAHxnAIANCJ4AWghv/RCWtK7PcIAAfGegoE1whiD8A4wgAoAW9M9xgABwBQmBAeAJ +oc9wgACoChiIhOBUCUEFiiBHDdYLL/mKIUsAfv8G8IwgA4QoD8H/RQOP+c9xgABwBQuBDwhRAM9w +oACwHxuADaHgfja4NrkwcNYghQ8AAIAA4H8ieOB48cDPcoAAcAULgiEIUQDPcKAAsB8bgA6iLYL1 +/0oSAQE4YBB4ShoEAI0Ez//xwOHFz3WAAHAFEYWP6AuFGwhRAK4LT/gTCJAFz3CgALAfG4APpQHY +EaXJAo/54HjxwOHFz3WAAHAFEYUX6AuFKwhRAH4LT/gjCJAFz3CgALAfG4AA2hClL4Xa/0gVARFR +pThgEHhIHQQQiQKP+eB4ANnPcIAAcAUtoC6gL6AwoCegJqAloEoYRABIGEQALKDgfzGg8cAA2c9w +gABwBSug9P/PcIAAaBs2Co//3QPP/whxz3CAAGgbRYBDgmG5YILPcoAAcAVKgtW6emLPc4AA+Gtl +gwUrfgAAIYFwx3EAAAAQXQKP/+B48cDPcYAAcAULgZboAdgLoQDYCqHd/4oghw5mCi/5iiEPBM9w +gADogBiIg+CcD+H/yiBhAW0Dz//xwFoJr/mKIMcPpME6Ci/5iiERDj4OwASA4PgOwv/PdoAAcAUK +hiyGnv9IFgERShYCEVlhMHAA3cP3AiBNAAeGjugO7QWGz3GAADxPuGAFpgaGuGAGphCBuGAQoQCG +AN8C6OamiiAIAN4JL/klhgaGQsVAwAWGENlBwAeGQ8CLcNYML/mi2gqG56ZKHsQTSB7EEwym4Kbe +CW/4D9gFhh0IVAEB2Lv/Qg+P+s9xgAA0UBiBAeAYoQTwBdi2/wUBr/mkwOB4gOAB2MIgDADPcoAA +VBsAqgHYAaoA2AKqAaICogOi4H8kouB4ABYAQGUGD/nPcIAASBvgfwCA4HjxwGIJb/gP2M9woACw +HzuAz3CAAHAFWQLv/yqgz3GgALAfO4FBKIIF1bhBKYMF1bkCec9wgAD4a2J6BYDJugUovgAncc9w +gADoGgOAAIDgfzhg4HjPcaAAsB87gUEogwXVuEEpggXVuRcJJQBbY89ygAD4a0WCWWECeQHjAvAC +eUArgAUleMzxANmWuc9woADQGzOg4HgDC55F4H7xwLoPT/kacIogCADPdqAAyB8QpgHYQR4YEPX/ +z3WAAPhrA4UlhdW4MHDKIc0PyiLNB8ogbQHKI40PAACPAMokLQBwBC34yiUNAUYIwAVKCOAFCHc6 +cEwgAKDMIGKgPvQAhRimAYUZpgWFFKYDhRWm0g+ABbMIEADPcIAA3IMMiKcI0QEXhreGBCCQD8D/ +AAAVhtW9IgsgACpx1bgCIEODBSABBDemAtkzplqGO4YUAAQAQivABwIiwoADIQEAC/Bklwq7ont4 +YAIiAoAA2wMhwQBapjumKfBPCJEgBJcKuBamz3CAAOiACYAzCF4Bz3CAANyDDIgnCNEBAdgTpjiG +GYYA2wIhQYQDIMAAOqYbphWGpgogACpxBvAAhxqmAYcbpgOFF6b1Bk/54HjxwJoOT/kKJgCQz3WA +APhrEfTPcIAAID2pcaINL/kU2s9wgADoGsIPT//PcIAACBsU8BsOkRAuD4AFqXF+DS/5FNrPcIAA +CBsN8Klwfgwv+QXZz3CAAOgajg9P/89wgAAoG4YPT/8ElQq4BaUGhYYgww8GpclwmP/iCQ/4iQZP ++c9wgADoGieABukDgECAAoFCeAXwz3D/D///4H7PcYAA6BpGgYoh/w8goAbqIoIgoAHYA/AC2OB+ +8cChwQhzi3D3/4LgANgH8gDAEHMB2MIgDgChwNHA4H7g2ADaz3GgAMgfEKEJ2LAZAAC0GQAAathC +GRgAANiauA+hpBmAAM9wAAwAGQ6h4H7hxVMgQgUEII0PwP8AAM9wgAD4awWAAiCDAAQhgg/A/wAA +1bkieKV7RXgQc8ogrQAF9xBzANjKIGYA4H/BxeB48cDhxdhwuHGYcu7/CHXIcIhx7P8QdcogrQAK +9xB1ANjKIEYBnA/m/8ohBgGZBU/5CHMocs9woACwHxuAAiCADwACAABocd7xiiH/DyCgz3OAAOga +RoMS6iSCGwleAM9xgABwHA8KQADPcYAAiBwRCkEAQILlC4GAAtgF8CKCIKAB2OB+8cDKDG/5SiRA +AMCBoIAB39F1wiQCAdF1oYFhgMInzhMB3rFzwH6xcwHbwiPOAEwkAIDMJiKQyiNiAAr0heuA5swn +IpAD8gLbAvAA2xTrIQtQADkLkQCggMCBAYAhgQIljZOgogMgQAABohDwANgAogGiDPCggcCAIYEB +gAIljZOgogMhAQAhoqkEb/locOB4BfBCecdwQAAAAM9ygAD4a0WC8wpEgFMgQwVwccAgjQ9AAAAA +wCCNAOB/IngG8GJ5AiCAD0AAAADPcoAA+Gtlgu8LRIBTIEIFOmILC4QAOGAH8AIggA9AAAAAYng4 +YOB+8cDeC0/5CHUodqoOL/8BgKCFELlBLQAUOGCaDi//yXEQubB4OGCODi//QC6BEh0Eb/kocNW4 +1bkPCQUAz3KAAPhrRYJZYeB/DiBAAKXgHPIJ9iUI0AAtCBABMQhRAeB/AdgZCFALGQhQD4wgQ4cO +9OB/BtjgfwDY4H8C2OB/A9jgfwTY4H8F2AfY4H7xwIHg4cUA2An0z3CAAL9rAd2mDG//qXGpcK0D +T/ngePHAKgtP+Qh3z3CAAKgKGIgacY8IEAGE5wDdiAAlAMogRQPPdoAAqGtAJgATagxv/wTZLo6w +rlMhAAARrkEowCCguV8IZAACIEIAY79TCsUDDurPcaAA0A8QEQCGYbpYYBAZGIAlEQCGD3gD8A+O +ANlTIIIgDyGBACR4LyYH8M9xnwC4/xCuGIHPIOIH0CDhBxihGIGeuBihGIG+uBihAdjtAk/5g+Dx +wADYCfTPcIAAvGvmC2//A9kB2NHA4H7geIbg8cAA2A/0z3CAAMRrygtv/wbZz3GAAHxnAIGCuACh +Adjt8fHAmuDhxQDYjPfPdYAA7GsEbaILb/8E2QuNgrgLrQHYoQJP+fHAluDhxQDYjPfPdYAA7Gup +cH4Lb/8E2QuNg7gLrQHYfQJP+fHA/glP+RpwocG5CDQhANiLcATdVgtv/6lxAMDPdqAA0A+RCIEP +mglQbxbwJRYDliUWApYvJMcAJRYAlk9/D30IvaV/GQwQAxAWAJb9YfhgEB4YkCNt2QhFoCnwgufM +J+KTzCcil8olQhAh9M91gADEa0etJRYClgitSa0lFgKWZq1KraJpFQ/RE89wgADPa9oKb/8N2Q3l +Ew8RF89wgADca8oKb/8N2Q3lAiBBIwTwQiABIRAWAJY4YBAeGJAB2KEBb/mhwOB48cA6CU/5z3aA +AAQc8CYBEM93gADABQCnpQnQAM91gAAYbBsIkQAmhRMJUQCKIAkI9gnv+ADZCNgApzkIkQAC2Aal +ANnPcKAA/ESeuSGgz3CgALQPANpcoA3IBCCAD/7//wMNGhgwDciHuA0aGDAo8PAmARAXCVEAz3CA +ANAcAIALCB8AANgGpQLwJqUDyA0IngDiC4/6DfAA2p66ANnPcKAA/ERBoM9woAC0Dzygz3CAAKgK +GIiE4JgNAgLlAE/58cAA2Zu5z3CgANAbMaDPcIAAwAUggInhyiHGD8oixgfKIGYByiOGDwAA1wDK +JCYAOAXm98olxgDPcIAAuBvwIEAAQHjRwOB+8cDhxc9xoACsLxyBvYEEfc9wgADABACIEwhRAM9w +wN8BAByhKNkYuRvwiiBJBvII7/iKIc4JiiAJBuYI7/ipcRUNHheKIAoF1gjv+Iohzg1WCcAE9r2k +CEL5ANmbuc9woADQGzGgRQBP+eB48cDhxc91gAAYbM9wgAA0Palx2g7v+Ejaz3CAAOQ9z3GAAMQF +xg7v+AjaANnPcIAA3BspoM9wgADABSCgz3CgACwgEID5By/5EqXgePHA7f8A2M9xoADAL4AZAADP +cMgAPADAGQAAE4GLuBOhkvHgePHAWg8v+YogSQw6CO/4iiEKCADdz3CAADBzoaDPcYAA6IBIgaKg +NJFTIgAAfg2v+AHbz3aAABhsCoaupgfoz3CAAKgKGIgLCBEBBNgD8AoKgADOC6AAANmU6AeGFQje +AIogiQbeD6/4iiFLAQDYCfCKIEkHzg+v+IohiwIC2Gj/RQcP+fHAANnPcKAA0BubuTGgA8gXCBAB +iiCJBqYPr/iKIUoCANhe/wrwiiAJCZYPr/iKIQoEBNhZ/9L/MvHgePHA8guv/+HFz3WgAKwvGIUb +CJ4GGoXAuIHgAdjAeC8mB/AF9ByFFQgeB4ogSQZWD6/4L2iuCgABHIU1CB4Az3CAACgcAIBCIACA +yiBiAJDoz3KAANwbCYIVCBUBz3GAABhsKoEJCVEAAeAJojyFFg+v+IogiQ3mCc/3kg+ABInoz3CA +AMAFAICD4DwPwf+BBg/54HjxwPYND/kIdzpxiiDJCeIOr/iKIYcJz3CAAMQFIIABgFYhQQsU4Dhg +MnDKIcYPyiLGB8ogZgHKI4YPAADnAcokJgCwAub3yiUGAc9wgAAYbAqAHejPcIAAqAoYiC8IEAHP +cIAAGGwFgILgyiHCD8oiwgfKIGIByiOCDwAA6AHKJCIAcALi98olwgAODcAAWNiSCe/4AdnPdqAA +yB8g2BCmMthDHhgQANgCC+/4jbgg2BGmz3CAABhspBYQEHYKr//noDWGKg6v+IogyQnPdaAArC88 +hRoOr/iKIMkJiiDJCQ4Or/gqcX0P3hDPcIAAZAgAgHEIXgAYFgCWobgYHhiQiiAQABGmGYXwuBmF +C/IEIIAPCAAAANdwCAAAAAHYwHgG8IYgfw+C4AHYwHht6KDfEfDgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeGG/jCf/n+31GYWIuBmlig0P+s9wgAAYbAeAwLiB4AHYwHhmCC//WnAKDeAA +KnAB2EIM4AAKcRyFRQhfBs9wgADQBQCAOQgRABiFiLgYpaDfEvDgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeGG/jCf/n+716g7AAKQWDxAKCC//SnBl/1zYRgjv+AHZINgQpjLYQx4YEADY +ugnv+I24INgRphyF+bjKICICIAji+MohogDPcACCAQAcpQDYrgvgAOlxOQQP+eB48cAiCcAAgOAA +2cogQQAg8r4Kb/kocIogiQe2DK/4iiHGDgPYof4C2M9xgAAYbAWhz3CAAOiACYAluMC4eg/v/gqh +CNiKIf8PZv8B2GEDz//xwM9wgADABQCADQjRANIPwAAs/0kDz//xwOHFCHXPcIAA6IAJgM9xgAAY +bCW4wLiiD6AACqEG6JoI4ACpcIToANgD8AHYxQMP+eB48cDhxc91gAAYbEwVgRAfCVMACiHAD+ty +BdiKI8QCSiQAABUA7/cKJQABA8iB4MohwQ/KIsEHyiOBDwAADAHKIGEB7/MTCZEAANhMHQIQEgzv +9xbYSvCKIMcL3f+NCBAACoUA2S6lCOjPcIAAqAoYiCcIEQHPcoAA0BwwojGiENgJoieiJaWKIEkH +qguv+IohhAkC2CnwmgrAAM9xgADEBUCBIYGWIoEBFOFZYT0IRAAB2AWlz3CgACwgcIAKJYAPAQA0 +IAHYBtkIcsdzBwAgoRIIIAVKJAAAiiDJBlYLr/iKIYQNAdhK/tUCD/nxwF4KD/nPcIAAqAoYiITg +yiHBD8oiwQfKIGEByiOBDwAARAHKJCEAIAeh98olwQAqDUAADgrgAAh2CHWQ7oogxwuo/wzoz3CA +AMQFIIABgJYhgQEU4DhgGQhEA84IT/yKIIkG4gqv+IohRQcA2C3+WQIP+fHA4gkv+Yog/w+hwUDA +z3WAABhsBIUA2Qfoz3CgACwgEIAkpQOlwgxAAC4NYAAacAhxfg5gAApwvQgRAM9wgADQHAmAUSAA +gcohwQ/KIsEHyiBhAcojgQ8AAH4ByiQhAHQGoffKJcEAiiDQB2YKr/iKIUYApg4AAs9xAIIBAM9w +oACsLzygiiDPC3n/NOgChYDgyiHCD8oiwgfKIGIByiOCDwAAjwHKJCIALAai98olAgGCDKAAi3AK +JQCQHPKKIEkGEgqv+IohxgWKIAkGBgqv+ADBiiAJBvoJr/ipcYogiQfyCa/4iiHGBgPY8P2pcADB +vf5RAS/5ocDgePHA7ggP+eYLQABSDGAACHUIcaINYACpcBMIEQGKIAkGtgmv+Iohywcs8M9woADI +H6QQAQAVgM92gAAYbEGGQnnXcQAAoA8A3cv3z3GAAPhrJYHVuEEpggBCeQsIRAAChpDoiiAJBnIJ +r/iKIYsKoqaKIEkHYgmv+IohSwsC2M392QAP+fHA4cXPcIAAqAoYEIQATCQAgcohwQ/KIsEHyiBh +AcojgQ8AAP4CMAWh98olIQA6C0AApgtgAAh1CHH2DGAAqXCdAA/58cDPcIAAqAoYiITgyiHBD8oi +wQfKIGEByiOBDwAAEAPKJCEA7ASh98olwQD2CkAADejCDg/8iiBJCNYIr/iKIUwHB9ip/SoJgACl +B4//4HjxwOHFz3CAAKgKGIiE4MohwQ/KIsEHyiBhAcojgQ8AAFMDyiQhAJwEoffKJcEApgpAABIL +YAAIdQhxYgxgAKlwhiC/jhL0Ng1AACEIUQAC3c9wgAAYbKagiiBJB2IIr/iKIQ0JqXCN/eEHz/jx +wGoPz/iiwc9wgAA0PTaAz3WAABhsF4BAwSWFQcCD4cwhIoAv8s9wgACoChiIVwgQAQDeFQlRAP4N +D/zPcIAACFkdiMWlH+iKIEkGBgiv+IohjA8D2AWlDYXOpQolgA8BAOwfDNkVJAIwz3CgACwgcIBA +ggDYx3MHACChhgzgBJhwVQfv+KLA8cDeDs/4z3CAAKgKGIiE4MohwQ/KIsEHyiBhAcojgQ8AAEUA +yiQhAKQDoffKJcEAiiAHDpYPb/gA2c92gACoay2OBekMjhsIQgCCD2/4iiCHDYoghw12D2/4LI5e +8M9woACwHxuAz3eAAHBsAqeKIEkGWg9v+FfZiiAJBk4Pb/gih0yODY7PcYAA+GtokUCnz3WAABhs +HQjiAAGnCLEA2U0dQhAB2SylNYUJCQUAFaUQjgSlEY4D6APqANgI8M9wgACoCgmA9wiegAHYAqWK +IEkG+g5v+HfZiiAJBu4Ob/gihwKFIIeA4MogYgAYuAV5BIUKIgCAiiAJBsoiYgAQusoOb/hFeQyO +hegChYDg0A4BBdIOr/cC2C0Gz/jxwMYN7/iKIEkGpg5v+IohhAAiCUAAz3WAABhsCHGE4MwhIoIR +9M9woAAsIBCAANpCpQOlz3CAAHBsAoDVuMdwAACIEwmlDYWA4MohIgEA3joKYADJcAsIEQHNpRTw +AoUJ6IogiQlKDm/4iiGECQXYCPCKIEkHOg5v+IohxAoC2AoMj/+tBc/48cA6Dc/4gODKIcEPyiLB +B8ogYQHKI4EPAABTAcokIQAIAqH3yiUBAc93gABwHEWHQ4JAgs9zoACwH9uDz3OAAPhrUyZNFTa+ +HmZdZWWDYbgFKz4AJ3UCJYAQjCAXh0r3z3CAAHBsAYAFKP4AJ3UeZgfpz3CAANAcE4BPCFEAPg0A +BRLoz3CAAOiANJDPcIAA9IMCkBEJAAACJYEfAAAADOlwBfDpcFglQRZWDc/+z3CAAIgcACWBHwAA +iBNCDc/+iiDJDhnwz3CAAFgcMg3v/lglQRbPcIAAoBwAJYEfAACIEx4Nz/7Jccm5z3CAAHBsI6CK +IIkPMg1v+Mlxz3GAAPhrBoGBuJ0E7/gGofHAz3CAAEAcigzv/uHFz3CAAFBsNYjPcIAAcBzPdYAA +cGyL6SCAQiEBgMohYgAF6SCFlQkRAF4Mz/7PcIAAiBxSDM/+QoXPcKAAsB8bgDa6NrgPCIUACHGA +IRAAAvAIcWCFemJhhXlhGwmFAAohwA/rcgXYrttKJAAApQCv97hzemIBCYUAInpPenByyiHND8oi +zQfKI40PAAC1AMogbQEr989xgABYHCCBQiEBgMohYgAH6VhgI4XJuA0IQABIcADZjf/hA8/48cDh +xYogSQZKDG/4zNnPcIAAqAoYiITgyiHBD8oiwQfKIGEByiOBDwAAzwDKJCEAJACh98olwQBGDK/3 +AtjPdYAAGGwChQzoz3CAANwbAYAJpc9woAAsIBCAAaXPcIAA+GsGgEUIHgDPcIAAwAUAgIbgzCBi +gcwgIoIE9Er/FPAEhQDZEOjPcKAALCAQgCKlA6XPcIAAcGwCgNW4x3AAAIgTCaUA2ASlpP81A8/4 +4HjxwOHFCHHPcIAAqAoYiITgyiHBD8oiwQfKIGEByiOBDwAAOQHKJCEAfAdh98olwQDPcIAAGGwK +gDnoz3CAACgcQIBCIgKAyiJiALHqgOHKIcEPyiLBB8ogYQHKI4EPAAA/AcokIQBAB2H3yiUBAUWA +Q4JhuaCCz3KgALAfW4LVul1lz3KAAPhrRYIFKn4AJ3XqCu/+VyXBGM9wgABAHAAlgR8AAIgT1grP +/oUCz/jgePHAiiBJDu4Kb/iKIQYEz3CgALAfO4CKIEkO2gpv+Da5z3CAAKgKGIiE4MohwQ/KIsEH +yiBhAcojgQ8AAJMByiQhALQGYffKJcEAz3GAANwbCYELCBUBAeAJoc9xgAD4awaBRiBAAQahz3CA +AMAFAIAXCJEAiiDJB3oKb/iKIYYITgiv/wbY0cDgfuB48cCKIEkGYgpv+IohxgvPcKAAsB87gIog +SQ9OCm/4NrnPcYAA+GsGgYK4BqFSCq/3Atjl8fHAiiBJBi4Kb/iKIUgAz3CgALAfO4CKIMkPGgpv ++Da5z3CAAKgKGIiE4MohwQ/KIsEHyiBhAcojgQ8AAAQCyiQhAPQFYffKJcEAiiDJB+YJb/iKIcgD +ug9v/wbYAdnPcIAAGGwtoM9xgAD4awaBRiBAAQahqfHgePHAz3CAAKgKGBCEAEwkAIHKIcEPyiLB +B8ogYQHKI4EPAADCAZgFYffKJSEAiiBJBooJb/iKIQcBz3CgALAfO4CKIAkPdglv+Da5z3GAABhs +DIEK6AWBgODMIGKABPIA2Mr/GvDPcYAA+GsGgUYgQAEGoc9wgADABQCAGQiRAIogyQc6CW/4iiFH +BQ4Pb/8G2DYJAAVd8eB48cA6CO/4iiBJBhoJb/iKIUgIz3CgALAfO4CKIAoABglv+Da5z3CAAKgK +GIgA3YTgyiHBD8oiwQfKIGEByiOBDwAAJgLKJEED3ARh98olwQDPdoAA+GumpoogSQjGCG/4iiEI +C5oOb/8H2AaGgrhmCO//BqbPcIAAGGytoL4Ir/cC2CUAz/jgePHAiiBJBpYIb/iKIccJz3CgALAf +O4CKIEkPgghv+Da5z3GAAPhrBoGCuAahhgiv9wLYz3GAABhsDIEM6A2BCugFgYDgzCBigDAP4v/K +ICIA3wXP//HAXg+P+M9wgADogAmAz3GAABhsJbhTIACACqEA2AWhDaFX8s9wgACoChiIowgQAYog +SQYSCG/4iiHJAs9woACwHzuAiiAJBv4PL/g2uc91gABYHACFQiAAgMogYgAzCFEAXg+v/qlwz3aA +AHAcAIZCIACAyiBiAIvoiiBKAMoPL/iKIYkFyXCWD6/+IoXPdYAAoBwAhUIgAIDKIGIAMwhRAB4P +r/6pcM92gACIHACGQiAAgMogYgCL6IogSgCKDy/4iiHJCMlwVg+v/iKF/QaP+OB48cDhxc9wAAD/ +/891gABwbAOlz3CAACgc0g6P/s9wgABAHMoOj/4A2SClBdgBpSKlbg9v9wLYyQaP+OB4z3GAANAc +z3CAAJQ9GQVv+BTa4HjxwOHFz3WAALgckg6v/qlwz3CAANAcIIA9CV4AFBAEABgQBQBRIQCAzCQi +gMwlIoAI9AohwA/rcgXY7QJv97TbCgiv/gAlAAHmDQ//CHGuDq/+qXBZBo/48cDhxc91gADQHKlw +Bgxv+AfZCBUEEADYRiT+g8ohwg/KIsIHyiBiAcojgg8AAGcAnAJi98olIgBAhScKXgAPCh4AJYUD +6SaFi+kKIcAP63IF2G/bSiQAAHUCb/e4c89xAQAEqzKlE6UjhR8KHgEOpQGFL6UZCNADz3ABANSs +EqUB2BOlBPAupf/YD6XH/0oLT/jFBY/44HjPcYAA0BwAgSKBf9vPcoAAGGxTIACAJnsD9C6CkekG +6A6CCyDAgA30MIKF6QWCDwiQAAfpEYILCJEAAdgC8ADY4H7geOHF4cbPcIAA0BxAgAKAP9sGewxw +z3aAANAcoobPcYAAGGwLIECDAdgugcIgAQALIUCDwLoG8imGUSEAgc8gYQALIMDACfTPcYAAGGwu +gQshwIAA2QLyBNmE6g8JEAGF6ATqCQkRAQTYwcbgf8HF4HjxwJIMr/gA2c9zgAAYbASDhujPcIAA +0BwHgAPoAdnPdYAA0BzAhc9wgACoChiIUyYCEADfEQgQAc9wgADogAmACQhfAQDeMfAHhYPo8aWA +4swhIoAJ8gmFDwgeARUOHhEBhQ0I0QMA2Ah2FfAA2BLwEYUB4BGlEQg1AQjeAYWP4ADYCfLPdqAA +LCDQhgHYw6MI3rCFiO2D6obphuhME4AABwiRAATeVQSv+Mlw8cDiC4/4ocEacCh3SHal/5UIEADP +dYAAGGwAhYkIEQDPcIAAwAUAgBcIkQCKIAkIogwv+IohSAJ2Cm//CNjPcYAA0BwAgUuBCwgfAQGB +FwjQA1UK0AAA2AehDKED2kuhCPBFCtAAANgJoQehA9pIoQSliiCKCF4ML/gqgc9woAAsILCAQMYB +2B7ZCnIIc0okAAAKJQABACWHHwcAIKFgfwomAAGhA6/4ocDgePHA4cUIdSEIEQHaC+//BN2KIIkG +Egwv+IohBgnmCW//ANhd8HEJEQHPcIAA6IAYEIQATCQAgcohwQ/KIsEHyiBhAcojgQ8AAKwB4Ach +98olIQAkEAQAUSRAgcohwQ/KIsEHyiBhAcojgQ8AAK4BvAch98olIQCKIEkIrgsv+IohBgyCCW// +B9hOC6//BN1WC8//JfBTJX6QE/LPcIAAwAUAgILgzCAigRn0iiAJCHoLL/iKIYcATglv/wjYD/Ad +CRECz3GAANAcz3IBACQdAd2pcDKBoP8D8ADd2QKv+Klw8cBeCo/4z3WAANAcCIVpCNAAC4VhCNAA +CYXPcaAALCAZCB4BDIUVCFEAMIEaCy/4iiBKCAHYIfDQgQqFAiYBEAXYDLgxCEUAiiDKB/oKL/jJ +cRDYCaUNhQImARAZDkVwAAAAUIogygfeCi/4yXEB2AylA/AA2FUCj/jgePHA3gmP+M9woAAsIPCA +z3aAANAcCoalhgInARANDUQQBoYdZSJ9CfDPcgEAJB0B2DKGcv/qpgCGz3aAALgcGwheALILb/6p +cI4JD/8IcVYKr/7JcATw7gmv/slw6QGP+M9xgADQHACBUSAAgc9wgACMaEiAUyIDAAT0AYEhCNAD +C+sXCt8Bz3CgACwgEIANoQHY4H8LoQLY4H8LoQrrFQrfAc9woAAsIBCACqEB2APwAtgIoeB+4Hjx +wCoJr/gJ2c92gADcG04PL/jJcACWz3WAABhsEwgeAAHYTB0CEAYKb/cW2AjwTBWAEA0IUQAC2Ewd +AhAAliKGIrjAuE0dAhDPcIAAIB0goM9xoAAsIFCBcoUCIsAACQjfB1KlEIEDpc9wgAC4HACAQiAA +gMogYgCI6M9wgADQHACAgOBYCsL/CIaG6M9wgAD4awiQFaUAliW4wLj2D+/+A9l+Dg/48QCP+OB4 +8cB+CI/4KHXPcaAALCAwgc9zgACwTkaLAN4E6keLg+oG2IfgyiHKD8oiygfKIGoByiOKDwAAgQLK +JCoALAUq98olygDPc4AAGGwJDZARNKNOgw8iQgNOo89ygAAgHfAiAABSgzhgAiCNAAkN3xcSo891 +gADQHAKFQYUEehnIGwoOACql4ggv+IogyggBhcmlBwjRA8elVQCP+OB48cDeD0/4CHXPcIAA3BtB +gM9wgAAYbM92gADIXkmgXoYEJYQfAAAAIOa6JrpTIgMAQS1CE8C6FiDPAEKnJ/LPcoAA0BxpgiV7 +aaLDuQDbDyNDAC+CCyHAgAHfBfLsohwaAAFLDZ8RLoJkeXCCBSHBgDCiHfIA2s9xgADcG0mhz3Gg +ACwgMIEjoBHwz3GgACwgMIEhoEQlARMTCRECAoAF6DoIwAQD8DoIwATPcIAAqAoYiA8IUQDPcYAA +qEYT8KIPgAQx6M9wgADcgwyIVwjRAZQWgBDPcYAAqEYFuABhRwheA5QWgBBAIQ8DBbg4YCMNHhMg +gIi5IKDSD+/3iiAJBpQWgBAB2QW4H2cgrwPwANksqM9xgACsBIogCQauD+/3IIElB0/44HjxwOHF +z3CAAMAFABAEAM9wgAAYbEwkwIHMJCKACvIUEAUACiHAD+tyBdh9Ay/38NsA3aWgiiCJBmoP7/f1 +2UINL/+pcOkGT/jxwG4OT/jPcIAAjGgIgM93gAAYbADdLQjfAYogSQc+D+/33NkC3hINL//JcMWn +z3GAANAcsKGxoRDYCaGnoQvwpaeKIIkGFg/v9+XZ6gwv/6lwhQZP+OB48cAaDk/4z3WAABhsIIUl +eAClEIWhwYboAdgQpQWFEaWSDK/7i3AAwc9wAQA0IBsIQADPcAEA7B8PCQAAz3ABACQdCwkBAKIM +j/sA3nIOr//Cpc9wgAAoHCIOT/7PcIAAQBwaDk/+z3CAALgcDg5P/oogiQaODu/3etlmDC//yXAF +Bm/4ocDgePHA4cUIdYogCQZyDu/3qXHPcYAAGGwAgaZ4AKEA2BChBYE6D6//EaHdBU/48cBeDW/4 +AdvPcIAA0BwAgM9ygABwbMG4g+DBgsB7Dw5REM9wgADcG8eAz3CAAFgcAIBCIACAyiBiALjoz3GA +ABhsDIGA4MwjIYAw9AKCz3OgALAf+4M2uDa/8XDWJ40fAACAAECCtYEAIhAA/WUhDQUUCiHAD+ty +BdiKIwQHCiQABNEBL/e4dQAgkCP9DQWU/maKIEkGug3v94ohhAkCIIAjig9v/wHZGQVP+PHArgxP ++Ah2iiD/DwCmz3CAABhsCoCA4MolIRFp8s9wgACoChiILwgRAdIMAADPcYAAxAUApkCBIYFWIkIL +FOFZYTBwAdjCIA4AE3hTIE0AT/DB/89wgAAoHACAz3eAANwbQiARgDoMIADKIWIgAKbPcaAAsB+7 +gSmHQCcQE89ygAD4a/AgQSBFgmG5BSp+ANW9J3WCJYERSCUNEBB1yiUGEE/3z3CAACgccgxv/koh +QCDPcIAAQBxiDE/+oKbPcYAAxAUAgSGBViBACxThOGAQdQHdwiVOE7N9UyVNkAnyDwlRIAmHHgmv +//AgACAhBG/4qXDxwMILT/jPcIAAqAoYiM92gAAYbCsIEQEKhgHagOAAhsB6AdmA4M9wgAD4awaA +wHmA4MwiIYDMISKAWfJf8M9woAAsILCAEoYA2gIlAZDjhsoibwCxdwmGEAAvAPtgAiXPEIDnAN/D +9gHfFw5FcABAAAAH6gIlgR9OAAEgMqYCJcEQFw5FcABAAAAH7wIlgR9OAAEgI6YihhLpIYY4YBEI +RQAZCEUDEQ1EEAjwCQ1EEAkIRQMA2QPwAdkipgCGz3WAAPhrpoWA4AHYwHiA4QHZwHmGJX8eANsJ +DZARqoaD7QHbgOfMIiKAA/QA2AjwgOPMISKAzCAigPnzAdgtA0/48cCyCk/4CHXPdqAAwC8ahjm4 +UiAAAFMgEAAUhgDfFQjfAJYLL/gk2PK4yiLBIwTySiJAIFEWAJaK6KMWAJYEIIAPAAAAD4wgEIAE +9ADYA/AB2Om9enDKJiEQCPKlFgCWXg6v/dO4CHYEIZFPAAQAAM9wAAAIHEILD/g/uFIgAgAEIIBP +AgAAANdwAgAAAAHZwHkMcIYgPQCA4EokQADCJAIBFQieQc9wgADABQCAgeAA2wP0AdvPcIAAVBoC +gBUIngDPd6AArC/8hwDYBw+fFQHY5b3KIGEgIQgQIOa9yiJhIBkKECDpvcomYRAG7uO9yiFhIAkJ +ESAA2B7w5L3KImEAfOrivcojYSDxCxCg4b3KIWEAcungvcokYQDdDBCA573KI2EAautRJQCSyiBh +AGToAdjVAW/4D3jgeOHF4cYIdc9xgACwTiCR/9iC4cogog//2s9xqwCg/1mhGKEE2c9woADIHCig +Ft4S8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Yb6MJv+f7vXPcaAAwC8K7c9wyAA8 +AMAZAAATgYu4CfDPcMgAsgzAGQAAE4GruBOhwcbgf8HF4HjxwBYIYAFH2ADaz3GrAKD/WaEH2Bqh +WKHRwOB+8cDPcQMAQA3PcKAAqCAtoM9xoADALxSB8LgUgQvyBCCADwgAAADXcAgAAAAB2MB4BvCG +IH8PguAB2MB4m+gVEQCGoLgVGRiAC/DPcKAArC8cgBcIXwYMdIQkwp8F9FrYcP916Afwz3GgAMwr +EoGAuBKhxvHxwM9wAAAIHFoJL/ihwRsI3gfPcKAALCAQgATZQMCLcEoM7/d82qHA0cDgfs9yoAAs +IFCCInrPcYAAxAUVeQCBEwiFAM9wgADogAmABwheAUCh4H7xwKHBANjPcoAAGGxNEoEAQMCLcB8J +UQDPcaAALCAwgVSCQnkPDkVwTgAAIOoKz/4D8PIJz/4RCJEAiiD/D6HA0cDgfs9wgADoGgOAIIAA +wCJ4gODKICwA8/HgeOHFiiH/D89woACwHxuAz3WAAOgaY4Vgg6aF1biA5QDaBvIihWJ5gOHKIYwA +CSEAAIIggQFIIAAA4H/BxfHAdg8P+Bpwz3CAABhsB4BKIkAgwLiB4M9wgABUGi2IwiKCJBcJUQDP +cYAAZBoggQXpCBAEAA0M3gBKIQAgHPBRJECAyiHCD8oiwgfKIGIByiOCDwAAtgAYBOL2yiXCAEwi +QKAB2MIgAQAVuAAgkQ9AAAAAiiBJBkTd9g+v96lxiiDJCeoPr/cKcdIJoAQA3s9woAC0D9ygDcjP +d6AAyB8EIIAP/v//Aw0aGDANyIe4DRoYMM9woADsJ8ugSR9YkxzdEvDgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeGG9jCX/n+71z3WgAMAvE4UXCJ8GiiBJBnIPr/db2QHYOg+gAUpx9gzv +/0pwz3GfALj/XYHPcIAAzAXdoYIN7/9AoM9wgADMBcGgz3CAABhsB4AnCBACigvv/4ogzwuN6AHZ +z3CAAMwFIaCKIAkKHg+v9wESATZPClEgiiBJBg4Pr/eA2RCFGwgfAEAVBBAKIcAP63IF2IPb9QLv +9rhzz3CAALBOIJATCVEBAZCF6IogEAARpQfwiiAQARGlEIUBCB8AFIWruBSlTyFAJpy4GaUYFwCW +obgYHxiQiiAQABGnCdgIuA+nDh+Ykw8fmJMQH5iTER+Yky0fmJMTham4E6XPcIAAGGwHgDUI0QDP +cIAAxAUAgFYgQAsCIAGgGAAPAAohwA/rcgXYs9tKJAAAYQLv9rhzEmmfuIgdABACDA/+gB2AE89w +gADMBaUFL/jCoPHAPg0P+M91oADAL4AVDxBcFRAQaBUREIgVEhDPcIAAGGwHgEojQCDAuIHgz3aA +AMwFAobCI8Ik4Lit9IC4AqaKIAkN9g2v993ZiiAJDe4Nr/dBL4EQiiAJDeINr/cKcYogCQ3WDa/3 +KnGKIAkNzg2v90pxz3GAALBOAJEJCFEBAZEP6BCFGwgeAEAVBBAKIcAP63IF2OzbpQHv9rhzWwsQ +IIogCQ2WDa/38tkwhY4Nr/eKIAkNEIUF2R0InwJAFQQQTBUFEAohwA/rcgXYcQHv9vXbiiAQABKl +z3egAMgfINgQp0MfWBAA2A4K7/eNuCDYEacP8BCFGwieAkAVBBBMFQUQCiHAD+tyBdgxAe/2/9sT +hR8LECAxCJ4GCiHAD+tyBdhw20okAAAVAe/2CiUAAfq4yiHBD8oiwQfKI4EPAAB0AAXY8fMH2M93 +oADIHxkfGJAB2AhxCHICCO/2CHMghs9wnwC4/z2ggBUOECK+jgov/slwz3GAADRQDYHYYA2hANiA +HQAQiB0AEAnYCLgOpwUED/jgePHAtgsP+M9wgAAYbOeAwL+B5wHfz3GAAMwFAoHAf2UIXwCBuM92 +oADALwKhhO8Thrq4E6YC2BGmz3WgAMgfB/BFFQAW5OBAAAUAEIb1CB6AagrP/wHYPgugAelxFRYA +loC4FR4YkIog0Ac6DK/3iiFFBXoIQAHWCc/6CdgIuA6lnQMP+FwWBBBAFgUQCiHAD+tyBdgRAO/2 +iiOFAfHAWgzAAMIJwACSDQAA0cDgfuB4OdnPcKUACAw+oOB+8cDhxQDdngggAKlwWgvgAKlw/g4A +AK4JwADPcIAAgAVRAy/4oKDgePHAz3GAANgFAIERCIEPAIAAAK4MwADZ8QCBIQiBDwBAAADPcaAA +sB87gZYLr/eKIEwMWgzAAMnxx/HgePHAmgoP+M91gADYBQ3pAKUBhZTohgvv9gvYagyv/wjYAdgB +pQrwAN7ApYYL7/YL2NoMr/8I2MGlzQIP+IDg8cAM2AnyVgvP9joMr/+A2NHA4H5eC8/2tgyv/4DY +0gmP/g0IkQAODG/+ANjz8fHx4HjxwA4KL/iKIMwOosEGC6/3iiFFAotwRgjv9wLZAxSPMILnyiHK +D8oiygfKIGoByiOKDwAAWgHKJCoA3Aaq9solygACFIAwz3aAAOAFhC8IGAAUEDEkHgIQz3CAAJRu +ACBBDiiJCiVALkAgEgIAIFQOG+mKIEwNngqv94ohxQmKIEwNkgqv9+lxwgvv90IggCEB2BO2/9gl +HgIQQCYAGVIL7/cE2WPwSiMAICYexBQlHsITz3WAAIBsQCUREqJ1i3CpcUII7/cC2kAlABIqCe/3 +QiCBIQAlgS+AAIBsAoHPcYAA+GslgdW4MHDKIcYPyiLGB8ogZgHKI4YPAAB4AcokxgQUBqb2yiXG +BEokgHBqcagggAOEKQgIL3AyIgIgB+owIQIgAoVNCgAAAeFAJgAZvgrv9wTZAdkIHEIghhUAFoC4 +hh0YEChwof+KIEwNxgmv94ohBgSKIEwNugmv9yKFiiBMDa4Jr/fpcfUAL/iiwAohwA/rcgXYiiMG +AUokAACVBa/2CiUAAfHAz3GAAOAFA6GaCe/2Ddh6Cq//iiAEAB/x4HjxwH4ID/gAFg5AocGC5soh +xg/KIsYHyiBmAcojhg8AAGsFyiTGAEwFpvbKJSYAQMaLd+lwFgrv9wTZiiDMCjIJr/fJcYQuCBgK +IEAuACGNf4AAfG6SCC/+BG3PcIAAYHAYgB8OABAgFYAQIujpcATZDgyv95naANggHQIQGPAAIIEv +gABwbgqBgbgKoc9wgADgBTOAAdoF6USgBNgH8ADZL6AqoEugJKAF2M//NQAv+KHA4Hj5AO/2Ddjg +ePHA4cXPdYAA4AUUhZ/oUg9P/oLgjAlh/sogIQAB2BSlvgjv9g3Yzgjv9gzYFaUI6K4I7/YM2AYK +r/+A2M9xAQDIQQHYfgxgA4Da9QfP9+B48cByD8/3z3WAAOAFMBUQEIwgw68I8oogDA1KCK/3iiHG +DSDwgODKIcEPyiLBB8ogYQHKI4EPAAC8AcokIQAoBKH2yiUBBAhxgiEIAM9wgACAbA4gQAAaCu/9 +iiEICBpwz3CAAHx0ERAChowiw4//2QXyGhgYhCylB/ARGBiEANgEpSyly/9RB8/34HjxwOHFCHWE +KAgIACGBf4AAgGyGEQAGz3KAAOAFoLiGGRgAAoIEiBToA4GA4MohwQ/KIsEHyiBhAcojgQ8AADEH +yiQhAJQDofbKJcEAAoGW6M9zgAB8dBETAIaMIMOPCvLPcKAAsB8bgAKhGhtYgxHwrKIA2MD/DfAy +Dk/+hC0IGAhxACGAf4AAgG4mD8/91QbP9+B48cBaDu/3AtgA3Qh2z3CAAJhuhC0IGDAgQA5RIACA +UA/i/8ogQgMJbuMIdYAB5QDY8/6VBs/34HjxwOHFz3WAAOAFI4XPcIAAnCHwIEAAQHh56H0Gz/fg +eM9woAAERAeAgOAB2OB/wHjPc6AAqCAxg89ygAA8HQOCOGADogHYEqPgfuB4z3KgACwgZoLPcYAA +4AUSgWJ4EqEQghGh5vHgeOHFz3KgAMgfpBIDAM9xgADgBRGBEHPCIwYARPdieBN7v4ISgbtjeGAS +oQHYShoYAOB/wcXxwIIN7/cA289wgADgBWOg/9rPcIAAfHQRGJiASiSAcGh1qCAAB4QtCBgAIYF/ +gAB8bs93gADoGmGhBt7Foc92AQAsL8Sh5qEgGcIAACGBf4AAmG5goQHlz3CAAHx0GhiYgM9xgAC4 +IQCBHNpAoBjYDgrv/wKhdQXP9+B4AdrPcYAAPB1DqRihKHBk2fEAr/d12uB48cDqDM/3z3KAANxw +ooKMJcOfMvL/2SKihC0IGKCgACGPf4AAgGwEjwogQC6Q6AKHz3GAAGwGog6v/SCBCHHPdqAAyB8V +ho4PT/6E6AHYFfDPcYAAPB0Cj6CpAakB2BOmHIYBoQHY4f8A2AAggS+AAJxuAKkA2NkEz/fgePHA +dgzv9wHaocHPcYAAqAZAoU8IUQDPdYAAYHAYhYwgw48K8gDahCgICAAhgX+AAJxuQKnPdoAA4AUP +hgXoDobL/wDYD6b/2Bili3DO/wnoOgnAAADADKYA2Cn/EfAuDa/2DdgmCcAAfg5v/4ogBACaC0/+ +guDYDSH+yiAhAGUE7/ehwPHA6gvv9//az3CAAHx0ERiYgBoYmIAA3s9xgADgBcOhTKEB2s9wgACo +BkCgz6HUodWh06HAocGhAt3JcIQoCAgacAAhgX+AAHBuCoEAIY9/gAB8bkYgwAAKofoL7/0Eb2G9 +IB+CE9kNdZBAIEAgAdjD/90Dz/fgeADYz3GAADwdA6nPcIAA4AVIgAKAQqkc4FZ4RIhJqQWI4H8K +qfHAUgvv94ogDAnPdYAA4AUkhS4MT/cEhYkIEQDPdoAAfHQRFgKWAN+EKggIACGAf4AAgGwCpSSI +AdvupW+lIukbHtiTDBAFAM9xgAD4awQlhA/A/wAAFBEGAEEsBAYFLj4BACGEfz8A//8EJEEBHB5Y +kCCQjCGChgHZwiFOAC2l6KUkgM92gAC4cMC5JrbPdoAAPB0orkCuAohkpQGuHvAEhTkIUQDO/wDY +BKUChSSIkukohRzgNngkiM9wgABcRBaIEHEB2cB5z3CAAKgGIKAC2APwAdgDpeEC7/cB2OB48cDP +coAA4AUCgiWIAdgG6QjZLqJ7/wjwz3GAAKgGLg+gAAChBwDP//HASgrv94ogTAnPdoAA4AUkhiYL +T/cEhoDgmPQChkiGJIBWeM9ygABcRAQhgQ8ABgAAgOEB2XaKIBCNAMB5FQ3BEM93gAC4cOaXtIoJ +DcATAN0G8LKK/QlBgwHdz3GAAKgGoKGV7c9xgACwBiCRIwtBAM9xgACyBiCRdIoTC0EAz3GAALQG +IIlSigsKQAAA2QLwAdmpCRAAJ4DPcIAA3HAhoM9wgABwbEGAz3CAAPhrBYAFKL4AQCmAchBxyiHG +D8oixgfKIGYByiOGDwAA6gLKJCYAZAZm9solBgHPcIAAdAYAgB4Lr/04YITou/9A8A3IBCCAD/// +/wMNGhgwZBaAEADdpaaK6M9woAAsIBCAx3AHACChGKZ4hgHfCiWADwEAREHpcAbZBNq+DqADSiQA +AGQeQhPkpulwG/AA2ALZI6ZkHgIQFfAEhgHdIQhRAAWGmOjPcIAA3HAhgM9wgAB0BgCAngqv/Thg +BegB2EUBz/eqD+/6ZB5CEwDYBKa48QXYDqapcBX/ANhkHgIQ8PHxwL4Iz/fPdYAA4AUEhYzoJIWW +CW/3iiCMCAKFBIiT6ALYBKUEhXsIUQAFha7oz3CgALAfG4BqC2/+OoWi6ADYJfAA2AWlz3agAMgf +FYbPcYAAdAZOCq/9IIEapaQWAxAKJYAPAQCgQQDYBtkE2sdzBwAgoeINoAOYcAHYBKUt8AoPz/oE +2APwBdgB2oPoAdgj8CuFIQlQAE+lDqUM8ASFNQiRACSFAglv94ogjAgLhQkIUQAB2A7w6+gChfYP +L/4DgAhxz3CAANAhtgjP/QDY3v7f8QDYVQDP9+B4z3KAAOAFIoIliRLpz3GAAGBweIHPcYAAmG6E +KwgIMCFBDg0JXwAI2A6iAdgLogDYCqIEogXYA6LgfuB48cCmD6/3iiCMCc91gADgBSSFfghP9wSF +eQgRACKFSIVAIQAHVnhEiM9wgACwBgCQAd4hCgEAz3CAALIGQJDPcIAAuHAGkA0KAQDEpQDYPfAE +iR3oz3CAAKgGAICX6M9wgADccCGAz3CAAHQGAIDuCK/9OGCL6IogTA0WCG/3iiHNAQDY0P8B2B/w +xKUB2B3wBIUA3jcIUQAihc9zgACoCkSBBYEc4UijCaNohc9wgAC4cAaQdnkkiT4NL/fJc8SlA9gD +pQHYTQeP9wohwA/rcgXYiiNNCph2uQNv9rhz4HjPcIAAuCEggBzaz3OAAOAFQKFCg1UiwQkhoKAS +AQCNuaAaQABWI8ECpBpAAJwSAQFogySgVSJBDSOgQCIBB3Z5JYkbCREIz3GAALAGIJFIdIAkRBMg +rB7bAvAY22KgVSJBDXlhHQTv+iWg4HjPcYAAPB1AIQADVSHCBREIhQAA2QQYUAD7CISA4H7gePHA +Mg6P989wgABgcFiASiAAIILiyiHGD8oixgfKIGYByiOGDwAA0AfKJAYE+AJm9solxgDPcIAA4AVo +gIQqCAgAIYB/gACAbHZ4p4CPCREAz3CAAKAdrghv94ohDw/PcIAAWB2eCG/3INnPcKUACAwAgFMg +QIAS8iUIUAAnCJAACiHAD+tyBdiKI58LCiQABJUCb/YKJQAE/9kH8P/ZCLkD8P/ZELnPcqAAtEce +GliAHRoYgBsaWIMA2ZG5z3CgANAbMaDPcIAADAQQeEkaGIBvIEMAVBoYgDLwz3OgALRHGxMAhg3o +GxMFhgohwA/rcgXYiiNfDzECb/YKJAAESxsYhAHYdxsYgADYnrhUGxiAiiTDf89zgADsPQpwqCAA +BApjz3WAADwdz3GAAKAdVX1HhfAhAQAB4FlhJ6VZBY/38cD2DK/3iiAMCqLBz3WAAOAFJIXODS/3 +AN4EhabosgmAAAHYBKUChQSIgOA+AgEAz3CAAKgGAICA4DICAgDPcKAALCADgM9ygADccCGCGWHP +cIAAcAYAgDhgwg4v/gCigOAKAgEAcvAEhXkIkQANhYDgyiHBD8oiwQfKIGEByiOBDwAAkwPKJIED +XAFh9solwQBChSiFQCIABzZ4JohgwSaIARxCMCaIAhxCMCeIYcEniAUcQjAHiItxBhwCMEoPb/eo +EgAAz3CgACwgI4DPcIAAPB0hoMWlV/8D2ASlx/AEhW8I0QBChSiFQCIABzZ4BYgnCF4BA5LPcaAA +LCAjgc9zgAA8HWGDCrhieQsJBAAJ2A6lhfAFhYzoBIqA4Kfyz3CAANxw9g0v/gCAgOCf8gWFBugF +2A6lAdgJ8M9wgACoBgCAgOCT9ADY9P6P8ASF1QhRAFP/IoVIhUAhAAdWeEWIMwoeAIO6RajPcoAA +wE7Hgs9zgABgcNqj94LDgv5m26P2gsKC/mbco8GCVYJeZt2jBYhZCF4AIg3P/YDgyiHBD8oiwQfK +IGEByiOBDwAA5QPKJCEAMABh9solAQEWDe/9AthGDe/9CNgihQSJFwiRAAHYAKUA2BKlMg3v/VrY +IoUEiQkIUQAB2AGlCIUc4RZ5BYmGIP+MyiCCDwAAMEPADOL/yiEiAAKFKIUc4DZ4BYiGIP6HBfIC +2ASlJ/AE2ASlJfAkhQHYQwkRAROlz3egAMgfPIfPcIAAPB0hoKYLL/eKIAwKz3CAADwdDNmmDi/3 +ddoVh89xgAB4BoIMb/0ggQelxKUE2AOlAdjxAq/3osDgePHAfgqP9891gADgBQSFzQgRAAKFBIgS +6M9wgACoBgCAjOjPcIAA3HB+DC/+AIAG6ADYnf4TAwAAz3agAMgfPIbPcIAAPB0BgEiFAnkChVZ4 +B4APCQQAAdgEpe8CAAAAhQnoEwteQALYFR4YkCoM7/0e2BWGz3WAAOAF7gwv/ieFgODGAgEAFYbP +cYAAeAbeC2/9IIEHpQKFKIUc4DZ4BYiGIP+MCPLPcAAAMEPPcYAAWB3n/gKFKIUc4DZ4BYhRIECA +hgIBAACFBegfhoDgegICAPH8cwIAAASFgeCH9CSFjgov94ogTArPcaAALCAjgX4KL/eKIEwKAoUo +hRzgNngFEIYAAN7TpXkOHgDPcoAAPB3PcIAAwE52gCKAeWHPc4AAYHD8g9iqVBAEAAQQBQAAJQUB +dBMEAOJ5AiUFAfqDHBAEAAIkxIN7gwOAYnjKJ4ETBPIB3/iqDelALIMADQnEAE8ngBAF8AXoTydA +EA9/GKpBKcAAOGAJCEUBgr/4qk8OXgAAhQ7oz3GgACwgJoEShSJ4z3GAADwdBaHApQXwAYUD6MGl +vPxyCA/+HQiQAAohwA/rcgXYiiMTBUokAACxBS/2CiUAAZYK7/0A2AKFKIUc4DZ4BYiGIP+MBPIC +2ASls/AE2ASlr/AEhRcIkQDPcAAAMEPPcYAAWB2U/gTYBKUEhYTgpPQkhWYJL/eKIEwKz3CgACwg +I4DPcIAAPB1AIBAHN6BKCS/3iiCMDSKFIBUEEEAhAAcWIAABBYgA3j0IHgBKJMBwyXLJc6gggAHw +IMAgAeMaYgPfSiRAcQDbqCCAAfAgwCMB5xtjEQrFAM9ygAA8HRiKgrgYqs9wgADccMOgTJFAJEAA +EQilAAilhhEABg0IXgAB2A+lAv5V8A6Ft/wNyAQggA////8DDRoYMM6lFv2KIEwNtggv94ohVAYI +hSKFFnmKIEwNoggv9yeBAtgDpQKFz3KAAKgGJIiO6SiFHOA2eCSIz3CAAFxEFogQcQHYwHgAoibw +IIIF6QHYA6Ug8CiFNngngM9wgADccCGgz3CAAHBsQYDPcIAA+GsFgAUovgBAKYByEHHKIcYPyiLG +B8ojhg8AAC8FgAbm/wXYxKWdB2/3AdgKIcAP63IF2IojlA5KJIAAFQQv9rhz4HjxwB4PT/fPdYAA +4AUEhaHBgQgRACSF9g/v9oogjAoB3s9wgACoBsCgANgTpSqFAaUApQLanenPcIAAXETPd4AAsAbg +l3aIJwvBA893gACyBuCXdIgXC8EDcojPcIAAtAYAiAsLAQBEpQPwyqXJcSMJUQAeC2/2AtjPcoAA +XEQUijaKQILuDO/2AdvEpZXwRKUEhRUIUQAkhXIP7/aKIIwKAtgEpQSFZQiRACSFXg/v9oogjArP +cYAAsAaKIIwMTg/v9iCRz3GAALIGiiDMDD4P7/YgkQKFBIgW6AuFlOjPcoAA3HAkggOCDiGDDwcA +IKERCwUAB9gOpQHYD6ULpQTwOGADogPYWPAEhSMI0QAkhfoO7/aKIIwKDcgEIIAP////Aw0aGDAE +2EbwBIU7CBEBJIXaDu/2iiCMClMgwEC6CmAAG6XPcIAAYHA4gM9wgACYboQpCAgwIEAOUSBAgAXY +yiChASjwBIU5CFEBz3aAAGBwGIYE2UDAi3CiCS/3mdoYhoQoCAgAIYB/gABwbiqAobkqoAHYC6UG +2ASlANgO8ASFFwiRAQbYA6UbhYDgyiBiABt4BKUB2M0Fb/ehwOB4z3CAAIxoKIDPcoAA4AUveBcI +UQAA289woAC0D3ygAtgDomSiA/AB2AWiIQbv9oogzAjgeM9wgADccC2Az3KAAOAFL3gLCFEABNgE +ogPwAdgFovkF7/aKIMwI4HjPcIAAjGgogM9ygADgBS94CwhRAALYBKID8AHYBaLRBe/2iiDMCOB4 +8cDeDG/3iiBMDb4N7/aKIdcMDcgA3gQggA////8DDRoYMB4Mb//JcM91gADgBRWFgOBQCmL/yiBi +ABEFb/fUpQHZz3CAAOAFJKDNBE//4HjxwOHFz3WAAFAGEukmhY3pAKV+DS/2CtheDu/+iiAIAAHY +BqUO8CCFJXgL8HYNL/YK2M4O7/6KIAgAANgGpQClwQRP9/HAQgxP9wh2AN/pcOlx7P8D2Ol1GnAJ +7hNtFHjHcIAA6CGKDE/9Ce4TbRR4x3CAADAiegxP/UIgQCDdCHWAAeXPcIAAFHHpdJ2wMLyesM9w +gABQBgoJYADgoE0ET/fgePHA1gtP989xgACsBgCBoLgAoQHY4//PcIAAFHEAgBsIFAEKIcAP63IF +2N3bmHOpAC/2SiUAAN0IdAAA3s93gABQBs9wgADsPtV4IICzbgOAIqcDpxRuACCBD4AAFHFHkQaR +ELpFeEWRGnAEkRC6RXhDkVpwApEQukV4OnBSDS/9CnEih3pwtH0AJYAfgAD0ISCgFgvv/SpwCHEA +JYAfgADoIQoMT/0LCIQkTwoRICOHs260fQAlgB+AADwiIKDqCu/9anAIcQAlgB+AADAi3gtP/Yog +TA3+C+/2/dmKIEwN8gvv9mpxHw7UEAohwA/rcgXY/9uc8YogTA3aC+/2iiHEAM9wgAAUcQCAAeY3 +DgSQHQNP9/HAz3CAABRx/ggv9w3ZvggP97f/0cDgfvHAtgpP9wh2iiBMC5oL7/bJcYPmyiHGD8oi +xgfKIGYByiOGDwAAkAHKJMYAfAfm9colJgAUbs93gAAUcfhgRZAkkBC6RXkacIcJEADPcIAA7D7V +eCCAz3KAAFAGA4AkorNuBaK0fQAlgB+AAIQiBhACISCgBBAAIRC6Agrv/UV4CHEAJYAfgAB4IvYK +T/3PcIAAUAYlgAAlgB+AAMwiBhACIQ4QAyEgoAQQACEMEAEhELoQu0V47gsv/WV5vgnP/QhxACWA +H4AAwCK2Ck/9XpcdlwDZDyGBAxC6RXgGIECAAd0dtzC4HrcV9M9xgACsBgCBoLjeDiAAAKHPcKAA +sB8bgLKnDNkRp1YnABKqDe/2ltoQ2s9xgABQBgCB2HpGePkBb/cAoeB48cCWCU/3z3aAAFAGAN0L +8BDYuHgLIQCAwA7i/8ogQgMB5fEN9JAghoDhyiAhANwM4f/KIQEAzQFP9+B48cAA2c9ygAAUcSCi +z3CAAKwGIKA9sjC5PrJA8fHA4cUA3c9wgABQBqCgz3CAAKwGoKDPcIAAFHGpdJ2wMLyesKlwNP+p +cKlxIf+FAU/34HjxwAYJT/cA3891gAAUcT6VDycPEB2VELkleAYg/oM99M9xgACsBgCBgLgAoc9w +gACwBs9xgABcRACQVok3CgEAz3CAALIGAJBUiSsKAQDPcIAAtAYAiDKJGwkBAA3IBCCAD/7//wMN +GhgwDciHuA0aGDDPcKAAsB8bgADeDNnSpRClViUAEn4M7/aW2gHYyXFyDaACgNo+lR2VELkleOV4 +HbUwuMkAb/ceteB4qvHgeAhxANj88eB4CHEB2Pjx4HgIcQLY9PHgePHA4cXPcYAAFHF+kV2RELtl +egHdFwoPAAO4FHjHcIAA6CGCCE/9qXAC8ADYiQBP9/HA4cUodfP/gODKIEEDeAvh/8ohYQBxAE/3 +4HgIcgDYENnw8QhyAdgg2ezxCHIC2EDZ6PHxwM9wAAAgTuYJL/3hxc91gABsBgClz3AAALgLAaXP +cAAAiBPKCQ/9AqXPcA8AQEK+CQ/9A6UF2LYJL/0LuBUAb/cEpfHAmg8P9892gABgcegWgRCMIcOP +CvIH6M9wgAAII94PD/3/2OgeAhDPcIAAgAUA3aCgz3GAAKwGAIHkHkATorhuDCAAAKGpcLoML/+p +cbkHD/fgePHARg8v94ogzA3PcaAAsB87gR4Iz/bPcIAA2AUAgAQgvo8AwAAACfTPcIAAQHIIiIwg +w48D8gHY3f/PdYAAYHGpcDYN7/Y42cOFiiBMDuIPr/bJceYMz/aKIIwO0g+v9l/Zog6v/clwCHHP +cIAACCOWDw/9/tg9By/36B0CEOB4/9jPcYAAYHHoGQIAANjgf+QZAADPcoAAXER2is9xgACABlSK +YbEBoUCxKHAI2ZEC7/Zz2vHA4cXPcYAAYHFBic91gACABc9zgACsBiCDB+oB2AClgrkgowjwANpA +paK5gOAgo3QLAgAA2MYLL/8IcQDY6f/FBg/38cDPcIAAqAoJgFEgQIHKIGIAcAiiA8ohIgDPcYAA +sAaKIIwMEg+v9iCRAdjk/9HA4H7gePHACiHAD+tyBdiP20okAAD1Au/1CiUAAfHA4cUIdf/Zz3CA +AEByKKhvIEMAVgsv/wHZz3GgALAfO4HKDq/2iiDMDQWFA4BChSCAiiCIALYOr/ZCeTkGD/fxwM9w +gACIBgSAmujeDu/1EtiW6M9wgACwTgeIEOjPcIAAaAVggM9xAQDsSgvYYHsE2pIO7/US2NHA4H7P +cYAA6IAJgQ0IXwHDEQAGDQheASYIr/gT2PLx8PHgePHAXg0v9wfYcgwAAM91oAC0D/yFGnAA2Byl +z3GgACwgMIEuDq/2iiCRBRoPAAHPdoAAiAYApgHYNgwgAQSuQIbPcYAANFACpgahRaH8pcoNIAAK +cBWOPwhRAECGiiBEBM9xgAAgIyKBGmI4YBByAdjCIA4ACuiKIBEL1g2v9gDZbg2gAgTYBfB2DaAC +BNh2DIACMQUP9+B48cDhxc91gACIBhSNjCDDjw70z3CAACwjJYAjgSCBx3GcAABAag0P/f7YFK0V +BQ/38cDhxc91gACIBgeFG3giD+/8I4UE6AHYFa2x//UED/fxwP/Zz3CAAIgGNKjp//X/cvHgePHA +ZgwP9wh3z3CcAABAz3GAAPhrxYEqD+/8yXGMIAKAz3GAAIgGAN2G9x14jCACgAHlffcAKEIDBSq+ +AxwZQA4WuAahg+//2BSpFImMIMOPTA/B/3kED/fxwM9wgAAgIzoK7/YD2foJz/Y88fHAEg3v9RLY +pP/PcYAA6IAJgQ8IXwHDEQAGDQheAZYOb/gT2M9woAAsIDCAz3CAAIgGI6DPcIAAbAUggGB5C9ga +8eB48cDODO/1EtgA2BTxgOAB2cB5z3CAAIgG4H8koM9ygACoBmGCZXgBohDpz3GAAFxEBJJ2iSsL +AQAFknSJIwsBAAyKMokbCQEADcgEIIAP/v//Aw0aGDANyIe4DRoYMOB+z3KAAFxEz3GAAKgGBJF2 +ihkLAQAFkXSKEQsBAAyJUooJCgEAAYED8ADY4H7xwM9xgACoBgCBE+gBgZXongtAA4DgDcjFIIIP +AQAA/An0BSCADwAAADwNGhgwDciQuA0aGDB+DU/80cDgfuB48cAWDO/1Ddir6M9ygABcRM9xgACo +BgSRdoo5CwEABZF0ijELAQAMiVKKKQoBAAGBlOg+C0ADgOANyMUggg8BAAD8CvQFIIAPAAAAPA0a +GDANyJC4DRoYMBoNT/wC8Nn/zfHgeA3IkLgNGhgwBQVP/PHAcg9AAgjoz3CAAFwIAIAPCJEBz3CA +AKgGAICD6ADYAvAB2LPx4HjxwEYKD/cIdwQikg8ABgAATCIAoAHdwH0EIoIPQAAAANdyQAAAAEoh +QCDPdoAAMHMYjsIhQiQacRENARCE7RmOCQhBBADYA/AB2ECGD3kA2A8PgRBBhhJyzCEhgALyAdgv +JgfwGq408gDZz3CgALQPPKDmCM/+6XAKcalyugtgASpzpgsgAKlw1P+H6PYOAABKD0/9A/B2D0/9 +YYbPcYAAqAYAhmSxLyYI8AWxGI7PcoAAqAp0sgypCILQICEAzyAiALm4urgFIIAECKLVAQ/38cB+ +CQ/3z3CAAKgKCYCiwQDeGwheAQohwA/rcgXYktuKJMMPTQav9bh2i3fpcIoPr/YC2c91oAC0D3AV +EBDcpc9xqwCg/9mhB9gaodihABQAMQIUATFEIAICQiICgkEowwDKImIAwLj+CmABwLsAFAAxhiD/ +DUIgAILeCiAAyiBiAHAdABRBxulwwgrv9gjZUQEv96LA4HjhxeHGz3GgAMgcyIEIoQbdEfDgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+31yXDBxuB/wcXgePHApggv9wHZz3CA +ALBOAJDPcqwA1AEA3QsIkQGtGliAA/CtGliDN9uoGtiAGQiRAUXb6BrAgOwaQICBGtgAghpYAA/w +oN/oGsCDBd7sGoCDWtuBGtgAghrYA4MamAMH3r4amIMIGoCDhuAM28ojgg8AAHcAGBrAgL8amIMM +GoCDhuA428ojgg8AAH8AHBrAgLwaWIMAGkCDEBpAg70aWIMEGkCDFBpAgxEIkQEE26oa2ICrGtiA +CfBI26oa2ICrGtiArBrYgJMaWICG4GrYyiCiCpgaGIB62JkaGIAQ2JoaGIB+GlgAfxpYAIAaWAAh +AA/34HjPcAAAAT3PcaoA8EMFoc9yAAA8PEahz3AAADw+B6GKIFQACKHPcAAACxIJoc9wAAAYHAqh +z3AAAB8fC6HPcAAAHBgMoc9wAAASCw2hiiBEAQ6hz3AAAD48D6FQoYogRA8RoeB+4cXPcaAAyBwI +oQbdEfDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+314H/BxeB48cAOD+/2 +B9gA34j/GnCY/891pAC4PawVABbPdqUA2MuiuKwdGBAB2Oym9h0YECYKIADpcIogxACfHRgQOdnP +cKUACAw+oMf/CnDf/xjYlR0YEMjZz3CAACAjIKDhoCKgz3EBAPhKz3CAAHgX1BhAAPjYC6b9Bs/2 +8cCaDu/2SiQAds9yNAA0NM9xagBqagDez3WAABRmz3OAAFxEqCBABJh2Em4UeB5lQKZ4YEagIaYn +oIon/x/ipuigQCROAEgdmBBOG5gASR1YEE8bWABLHZgQURuYAEwdWBChBu/2UhtYAOB4z3KAALBO +J4qD6SaKC+nPcawAkAEA2gToRaHgfgLYBaHgfuB+8cDhxQh1IJAClUGVELgFeinYErgVIEEAQKEg +lfAgQQAdCkAA0g5v9oog0QMClSGVELgFecIOb/aKINEDRQbP9vHA4cUIdSCQApVBlRC4BXoV2BO4 +FSBBAEChIJXwIEEAHQpAAJIOb/aKINEDApUhlRC4BXmCDm/2iiDRAwUGz/bxwI4Nz/YodoDgzCYi +kA30CiHAD+tyBdiKI4UOiiTDD1kCr/W4c1MmfpDKIcIPyiLCB8ojgg8AAHwByiBiAfD1QYAghqKA +WHlAgCR9KdkSuRUhggCgogCA8CEBABcNQBAWDm/2iiDRA4og0QMKDm/2qXGJBe/2BG7xwBYNz/Yb +CHQASHUIdkCFYb5gegRtCHH3DnWQEOVlBc/24HjxwOHFiiBSDtINb/Z02c91gABEI6lwQCWBFfoL +r/YW2gHYRQXv9jEdAhDgePHAvgzP9gh2guDKIcYPyiLGB8ogZgHKI4YPAABPAMokJgCQAab1yiXG +AM91gABEIwuFACaPH4AAYCMLDgEQFI846JoL7/8F2BpwiiASDmINb/bJcUQuvhUAJUAeQJAhkAi6 +RXnPcqQAuD2bGlgAIpDKGlgAI5DLGlgAJJDEGlgAJZDGGlgAJpDHGlgAJ5DCGlgAKJDDGlgAKZDF +GlgACpCjGhgA0gzv/wpwy6UA2BSvcQTP9vHA4cWmwYogkg3yDG/2hdmLcDIKr/YG2QAUADGT6EAk +gDDPdYAARCOpcQoLr/YW2gHYMB0CEAuFgOAUD+H/yiAhAAAUADEzCFEAiiDSDa4Mb/aW2UAkgDDP +dYAARCNAJYEV0gqv9hbaAdgrhTEdAhCB4dwOwf+SCY/2DQTv9qbA8cCOC+/2CHMIdoYj/gNEuwh3 +hifxH0e/RCCBAzx5z3WAAExyLK0EIIQPAAAADEIsgAIUrQQmhB8AAAAwQiwAAxWtBCaEHwAAAEBT +Ib6AQiyAA7EdAhAN9AohwA/rcgXYTNuKJMMPGQCv9UolAAARjYHgzCAigMwgIoEG9FNpJXpOrU2t +gOPMICKBBfJTa2V6Ta2A58wgIoEE8hNv5XgOrRNpJXgPrQ2NEK1CCK/5ANhFA+/237XgeKTx4Hjg +fuB44H7geOB+4HjgfuB4o8HhxULBCRSBMEPCQcAZCTMBANgRCVIAChSBMAkJUgAHCRIBAdgHFIIw +BhSDMBELgAAiwTBzzCJCgAP0AdghxSENURAKFIEwI8MZCcMACxSCMFBxzCOqgIT2gOLKIGkAGwhR +AIohyQ/PcIAAuAYioIHl/9nKISIAI6DBxeB/o8CjwUDAQcEFFIEwANiB4ULCDfKC4Qfyg+EN9CHB +ANgPIEAAAxSBMA8gQAACFIEwDyBAAAYUgTAhCVAAEwmQACMJ0QAhwQPhDyBAAAMUgTAD4Q8gQAAC +FIEwA+EPIEAACRSBMCEJUQACFIEwCrlPIQIEAxSBMAy5JXohwQ65RXkleCDBFQlRAAcUgTAiwga5 +CLpFeSV44H+jwADYz3GsANQB+BkAgPwZAIAAoaUZGICmGRiApxkYgKIZGICjGRiApBkYgJ8ZGICg +GRiAoRkYgM9ygADIBgCCixkYgAGCjBkYgLERAIaDuLEZGICyEQCGg7iyGRiAsxEAhoO4sxkYgOB+ +8cDhxQDdz3CAAAQFoKjPcKcAmEe6oLIKQACE6N//DvD2CkAAz3CAAMgGQIDPcasAoP9YoQGAGaHP +cKcAFEiooHkBz/bxwAIJz/bPdYAAyAYChYHgAdgf8gII7/8H2E4MYAAIdmoOQABSC4/2Mg9AAJYN +QAAaDUAADOgaCYAANgjAAPIIgAByCe//yXAB2AKlANghAc/24HjxwK4I7/YB2M91oADIHBGlAN7n +/4Hg4AxBANGl/QDP9s9xrACYAACBo7gAoQGBo7gBoQKBo7gCoeB+4HjPcKsAoP84gM9ygADIBiCi +OYAA2yGieKB5oD/ZOqDgfgLYz3GsANQBnxkYgKAZGIChGRiAAdiiGRiAoxkYgKQZGIClGRiAphkY +gKcZGIAF2PgZAID8GQCAAKHgfvHAEgjv9phwAd3Pd6cAFEiop97/5P+IcOv//9ibuM92pwCYRxym +iiASDdYIb/aIcc9xgAAEBQCJgODKIcIPyiLCB8ogYgHKI4IPAAC5AsokIgCwBGL1yiUCAQDYFqcb +2BqmGQDv9qCp8cCmD4/2Ad7PdacAFEjIpVYJYAAacMr/NgpgAApw/9ibuM93pwCYRxyniiASDWoI +b/YKcc9xgAAEBQCJgODKIcIPyiLCB8ogYgHKI4IPAACKAsokIgBEBGL1yiUCAQDYFqXap6UHr/bA +qeB48cDhxb4IYAAIdYDgqXAE9Mf/A/Dg/6EHj/bgePHAocG4cADYQMBTJYAAIwhQAC0IkAA3CBAB +CiHAD+tyBdiKI8kG7QNv9Yokgw/PcAAAItLPcYAAk2UP8M9wAAAj0s9xgACWZQfwz3AAACTSz3GA +AJllKdoSuvAiAABAwItw5g1v9gPaocDRwOB+4HjxwK4Oj/bPcKYAnD8ZgKEIHgDPdoAAqAqEFgAQ +LygBAE4gkAdBKNAgEQjVIAAgjS+AABgLFI2O6AohwA/rcgXYiiMMBYokgw9ZA2/1CiUABM93gACI +ZUAnwBImCW/2CdnWDwAAgOAA2A8gAAQD9Mn/A/C2CEAAFI0A2WG4D3gUrQLIuRCAABt4gLgKr4og +Ug0ODy/2DyEBBIQWARDPcIAAVEU2oM9wgABkgSKgMf9lBo/24HjxwLhxiugKIcAP63IF2Hvb3QJv +9Yokgw/PcYAAFHMggUwlAIAEIYEPAAcAAEEpAwYA2cokTXHoIK0D8CBFAAQlgg8BAADALrpleg0L +gQAB4dHA4H4KIcAP63IF2ITbkQJv9UokQADgeM9wgACoCgiAz3GAABRzCwgeAAGJAvACieB/AKkI +cViJAYACoYjqWYmA4sIgogDAIKEAAqHgfuB48cBWDY/2KHVihSCQz3aAAMgGeHljhSR7I4ZleSOm +JoUBkDh4J4WiwSR4JIZAJRAUJXgEpibqQgyv/wfYOnABhSOGABwEMAIcRDAwuQQcRDAghYt3YHnp +cAQQACAkhgIcRDAwuQQcRDAAEAEgABwEMGB56XAA2AOmBKaaDa//KnA1Ba/2osDgePHAygyP9qHB +ABaOQAAWjUAAFgBB2guv/wfYGnCC5gbYA/S7eAfgA+AEIIAPAAD8/wUggA+ArgAA7HEAoQHI7HEA +oexwwKgB2c9woADIH1EYWICH5pwBDQAyJo5zgAAEP0AnAHLUeAB4ABYBQAAWAECAuc9woADsJyag +p/CA5UoBDgAAFgBBABYBQQAcRDAAFgFAqg8gAGG9ABQBMQa4gbgQuSV4z3GgAOwnBqHXDVWQi/Ds +cKCogOUOAQ4AABYAQAAWAUB2DyAAEHgGuEUgwgDPcKAA7CdGoAqAi3EAsQAUATHscCCwYb3VDVWQ +bfAAFgBAigpAAM9xoADsJwuhABYAQGPwww1UEAAWD0AAFhJAQS8RFPB/Jg8gAOlwBrhFIMAAz3ag +AOwnBqYKhotxALEAFAAxBiBABAUggAQAHAQw+g4gAOlwABQBMQa4gbgQuSV4BqZhvbUNVZA38GsN +VBAAFgBBABYBQQAcRDAAFgFAyg4gAGG9ABQBMQa4RSCAARC5JXjPcaAA7CcGodUNVZAb8DcNVBAA +FgBBABYBQQAcRDAAFgFAlg4gAGG9ABQBMQa4RSDAARC5JXjPcaAA7CcGodcNVZAA2c9woADIH1EY +WIC6C6//CnDOCG/2AdgA2M9xoADIH3QZGIA9A6/2ocAKIcAP63IF2IojBAtKJAAAxQcv9QolAAHx +wM4Kj/YAFo5AABaNQAAWAEHWCa//B9iYcILmBtgD9AdtA+AEIIAPAAD8/wUggA+ArgAA7HEAoQHI +7HEAoexwwKgB2M9xoADIHBGhvw61EQDaMyaOc4AADD9AJ4By1HgAeAAWA0DPcKAA7CdmoEbwiQ1U +EJ91qCBAAgAWA0DPcKAA7CdmoDrw7HCgqG0NVBCfdaggAAMAFgNAz3CgAOwnZqBqgOxwYKgo8AAW +A0DPcKAA7CdroCLwgOXKJE1z6CCtBwAWDkAEJoMfAAAA/yi7tmtFJc8Qz3OgAOwnBCaAH/8AAADm +o+qDMLg4voG9Bn/lfhC+xX2mo1Ghigqv/4hwng8v9gHYMQKP9gohwA/rcgXYiiMGDUokAAClBi/1 +CiUAAeB4eQFP9vHAogmP9hpwz3CAAExyEIjPdoAAMHOGIP8BO2gFhg4gQIDPcYAAsE4nicogYgAh +6TqOgOHMICGAG/IA3QzfEm0VeMdwgAC4JiCABekCgBboQHhhv+sPdZAB5QDYGq7PcIAATHIQiIYg +/wFDuAWmegyv/wpwkQGP9gohwA/rcgXYLdtKJEAAEQYv9bhz8cAAFoVAp8ENDTUFABxAMRcNFQIK +IcAP63IF2Hrb7QUv9UokQAAAFoBAYcAAFoBABRwCMAAWgEAGHAIwi3DmCGAAgsEDwozqCiHAD+ty +BdiE24okww+1BS/1uHMFwGB6BsEEwYDhyiHBD8oiwQfKI4EPAACIAAXY7fMCwIDg4iBCAJIOD/an +wNHA4H7gfuB48cCOCI/2G30C8Ah1z3CmAJw/GYBNCB8AA94S8OB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB4Yb6MJv+f7vXHDXOQCW0KIcAP63IS2EzbSiQAACEFL/UKJQABmQCP9vHAHgiP +9jpwCiBAoM92oADIHwHYUR4YkM9wAQACw891oADsJwalz3ABAELFBqXPcAEAAsgGpc9wAQCCygal +DvTPcAEAQsQGpc9wAQBCyQalz3ABAMLLBqUg3/CmMthDHhgQANhqDS/2jbjxpgDYUR4YkM9woACs +LxqAwLiB4AHYwHgvJgfwLPJFCBAgAdhRHhiQIQkQIM9wAwDGAAal8KYy2EMeGBAA2CYNL/aNuPGm +z3CAALBOAJANCJABz3AGAAJ1BqUA2FEeGJAE8LIOj//PcIAAqAoPgIC4BqWhB0/28cDhxQHbz3Kg +AOwnZqLPc6AArC+F6RiDmrgYo1PwtYMZDR8QVBMEAAohwA/rcgXYSNsFBC/1uHPPc8AAR2hmogXo +z3ADAMcABqLPcBAABmkGos9wAADCGgaiz3AAAAI0BqLPcAAAgk0GosfYlbgGos9wAABCLQaiz3AA +AIJGBqLPcAAAQmAGos9wAwACwwaiz3ADAELFBqLPcAMAAsgGos9wAwCCygaijenPcAMAQsQGos9w +AwBCyQaiz3ADAMLLBqL9Bk/24HjxwM9wgACwTggQBQFMJQCAzCVigA3yHw2QAAohwA/rcgXYiiMH +AEkDL/WKJIMPANgC8AHY0cDgfs9wAwAGIc9xoADsJwahz3AEAEZLBqHgfgHYANvPcaAAyBwRoc9w +gADHIM9yoADsJwaiz3CAAAc6BqLPcIAAh1MGos9wgACHJAaiz3CAAMc9BqLPcIAAR1cGooogigAG +ooogiwAGooogjAAGoooghQAGos9wAwAHIQaiz3AEAEdLBqLPcAMARzoGos9wBADHZAaiz3ADAMdT +BqLPcAQAxzEGos9wgADcBgCQELiFIIQABqJxoeB+4HjxwKHBLygBAE4ggQfPcKcAPEgUgM9ygACT +ZTR5WWFAwItwkgwv9gPaocDRwOB+4HjPcCwABgHPcaAA7CcGoc9wgADGIAahz3CAAIYkBqHPcAMA +wgIGoc9wSABCAQahAdnPcKcAFEg3oOB+4HiAuM9xoADsJwah4H4J2eB/IKDgePHAAg4v9ijYCHGG +IfwDJLnPcoAAsE4gskQgAQMiuSGywbgCslDx4HjxwNoNL/YA2EEoAQLAuc9ygACwTiaqKbjAuAeq +QPHgeM9wIAAGAc9xoADsJwahz3BwAIICBqHgfs9xIAAHAc9woADsJyag4H7gfuB4AdnPcKAAyBww +oEvZz3CkABxAJKDgfuB44cXhxgHaYJAe8MlzHPAVII0AwJWhlQHi13YAAPv/UHp19j0LgA8AAP// +guHMI4GPAAD+/xTygeHMI4GPAAD9/w7yCunPdQAA+//HC0GDwcbgf8HF8QuBjwAA/P8GvoG+EL3F +fc92oADsJ6am7PHgeM9yAAA+Ps9xqgDwQ0WhRqGKIMgPB6HPcAAABQoIoc9wAAAPFQmhz3AAABkd +CqHPcAAAHx8Loc9wAAAdGQyhz3AAABUPDaGKIJQCDqHPcAAAAj8PoVChUaHgfuB48cC6C0/2z3CA +ALBOJ4gB2DHpAN7PdaAAyB9RHRiQz3CAAJgjAtnE/89wBwDGAM9xoADsJwahz3BgAMYgBqHPcA8A +giMGoc9wqgACJAahz3CnABRIy6DMoNP/UR2YkyDe0KUy2EMdGBAA2PYIL/aNuNGltQNv9gHY8cDh +xc9ygACwTgSSz3GAABRzANtgoRLoTwhQAHEIkAAKIcAP63IF2IojSgZKJEAA/Qfv9EolAAAH2Bi4 +AKFhqUokwHBiqaggAAMA2I64FiHNAAGlA9gOuAKlAeMD2AayB7IA2C/wANiZuAChUtgBqUokwHAC +qagggAIA3Y+9FiHAAKGgoqAB41LYGfAA2Ji4SiTAcAChqCCAAgDdjr0WIcAAoaCioAHjYdhgkgGp +huPKIIIPAABSAAKpAttmsgHbZ7L1Am/2AKnxwOHFz3GAALBOB4mhwQDaMugAHIQwA9vPcKAA7Cdm +oAqAi3UAtQAUDTGpcIYg/AeMIAKIBPQAHIQwSHWpdIQkA5DKIcIPyiLCB8ogYgHKI4IPAAC1Asok +YgAMB+L0yiVCA0QlABxEuASxRCUAE0K4BbED8ESxeQJv9qHAz3CAALBOB4gl6M9wAQDMa89xgAD8 +FmEZGADPcAEAxHhVIUIHQCEDAwXoHaMbgYO4G6HPcAEAyHkF6AKiG4GCuBuhz3ABAMR6BegAohuB +gLgboeB+8cDPcIAAsE4EkBLogeDMIKKAEvIKIcAP63IF2IojDAdKJEAAcQbv9EolAADPcSoVFSoF +8M9xKioVFc9wgAAIBSCg0cDgfuB48cDPcYAAsE4kkYcJEAAjCVAAYQmQAAohwA/rcgXYiiMNBEok +QAApBu/0SiUAAAQggQ/z///PBCGADwMAAAACuAUhAgAEIYEPAAAADAQggA8AAAAMJXjPcYAAqAoo +gQK4RXgvCR8AByCADw8AAADH8c9xgACoCiiBFwkfAAQgvo8MAAAA0iCiBNIg4gS39bfxIJABkAa5 +gbkQuCV4z3GgAOwnBqHgfuB4ocHxwLIIb/aYcM9wgAAwcxAQBQDPcIAAuCYFgKHBhiH3D5UIEADP +dYAA4AYGhRMIQQEHhQsIAQEIhX0JAAAAHAAxIMJTIsAAhiL/A0S6WmIDuFR6FHhYYMdwgACMeOCI +6XKGIv0PW3oBiEV/CHKGIv0PW3pFeADeEenPcqoA4AdzghULHgAIoumiyqLLosyizaIN8OiiCaL5 +8Qm45XjPcqcAFEgDosSixaIYHUARHB0AESilCNxrAG/2ocAAgAHbYKFouAK4FXjHcIAAuCZDgEOh +QYBBoUKAQqFEgESh4H9goOB4z3CAALBOBJDPcYAANCeEKAUEACGAf4AAqCfgfwKh4HgVAg/3z3OA +AEQnz3GAAOAGDIlDgwCqDYkBqgHY4H8Ao/HAlg8v9kokAADPcqUACAwIEgUATCUAgMohwg/KIsIH +yiOCDwAAoQNYBOL0yiBiAUDYAqLPc4AAsE7PcYAAMHPPcIAAqCekkyCBE/CEKQIKL3OELQUUJ3Mb +Y/QjAwHPdqYAAIAVJg4RQCREAGCmjCSBhK73hC0FFAAhgH+AACAohCkCCidwdpDPcaQAoD99oReQ +HqEIGkABaQcP9vHA8g4P9qXBCHcodgIOL/8H2BpwAYYM3QQcBDAEFwEUBhxEMDC5CBxEMBAWARRg +eYHAAYZhvQwcBDABF4EUDhxEMDC5EBxEMBAWARRgeYPA4w1VkFYPL/8KcP0GL/alwPHAlg4P9s9w +gAC4JgCAgOCF8gHYz3WgAMgcEaXPcMEAQi3PcaAA7CcGoc9wwQCCRgahz3DBAEJgBqHPcIAATHIQ +iIYg/wFDuClozwnVAc92gAAwcwSGMyZBcIAAFD9AJwJ1BrgUeDR6x3CAAExzAHrPcYAAmCtQ8M9x +gABoLBDgSvDPcYAAOC0g4Ebwz3GAAJgrMODD/wSGz3KAAIxzz3GAAGgsBrgUeDXwz3eAAMxzz3GA +AJgrcOC6/wSGz3GAADgtBrgUePhgJvDPcYAAaCxQ4LT/z3KAAKxzBIYW8M93gADsc89xgACYK4Ag +AgSt/wSGz3GAAGgsBrgUePhgqf8Ehs9ygAD8cwa4FHjPcYAAOC1YYKP/ANgRpeUFD/bgeOHFAdgA +2c9yoADIHBGiz3WAAOAGAI3Pc6AA7CcQuAUggA8AAMJpBqMBjRC4BSCADwAAAmoGozGi4H/BxeHF +AdgA2s9xoADIHBGhz3CAAOAGYpCGuxC7BSONDwAAwhLPc6AA7CemowOQELgFIIAPAAACEwajUaHi +8fHAAg0P9s91gADgBsiNCY3CvsK4Fn7PfkoI7/8N2Aa4gbgQvsV4z3GgAOwnBqEEhc9xpQDoDwah +BYUHoTEFD/bxwL4MD/bPdqUA6A8mhqeGz3CAAOAGAN8koKWgBgjv/w3YBriBuM9xoADsJwah5qZF +Jc0fp6bxBA/24HjxwG4MD/aiwTpwGnEA3Y4LL/8H2JpwAtmpcFpwenEA2zRoAnEodRQhACBocsKF +BBAPBdh/w4UB4sR/5XvxCvSAIOUBgQIcxDAwuwAcBDAggQQcxDBgeYtwQiNBIL8JdYBAIkAg0gwv +/4pwWQQv9qLA8cDPcIAAuCYPgBDoz3CAADBzBIDPcYAAmC7PcoAArHkCuBR4WGDb/9HA4H7xwNoL +D/bPcIAAuCYUgIDgfvLPcIAATHIQiIYg/wFDuClohuHoAA0Az3WAADBzRIXPcIAALHozJkFwgAAc +P0AgEAsEulR6QCARCkAgEgZAIA8IQCAOBFhgQCcCcjR6AHrPcYAA+C5R8M9xgAAYLwTgS/DPcYAA +OC8I4Efwz3GAAPguDOAGDm//ANoEhc9xgAAYLwS4FHjYYDfwz3GAAPguHODqDW//ANoEhc9xgAA4 +LwS4FHj4YCnwz3GAABgvFODKDW//ANoEhc9xgAA4LwS4FHhCcBnwz3GAAPguJOCuDW//ANoEhc9x +gAAYLwS4FHgicJoNb/8A2gSFz3GAADgvBLgUeAJwhg1v/wHaKQMP9vHACiUAgM9xgADgBiQRBAAi +8s9ypAC4PQDbHwwRAJsSAAYKoaYSAAYLoZISAAYMoaMSAAYNoZsa2AD/2KYaGACSGhgAoxoYAAHa +z3CgALQPXKAn8EwkAIDKIcEPyiLBB8ojgQ8AANQFXAeh9MogYQEKgc9ypAC4PZsaGAALgaYaGAAM +gZIaGAANgaMaGAADyM9yoAC0D4Yg/w4iuByiJBlAASbxAQLP9f0Bz/XxwPoJz/We/hzx4HjxwBYK +L/YA2QfYGnE6cADeQCgAIRR4x3CAACx6FSCNAwCVjCACjQDfhPaMIIWCyfb/2AC1iiARA9IKr/UA +2QGdCwhTD4wgP4FH9uG1iiARA7oKr/UA2QHmz365DhKTQiFAIEAgQSCnCHWAL3kJAg/28cDhxc9x +gAAseoogCA+o2gHdZggv9qlzgODKIcEPyiLBB8ogYQHKI4EPAACABcokIQBsBqH0yiUBAdb/z3CA +ALgm5QEv9rSg8cBqCS/2iiCYB6HBi3bJcQHaHggv9khzjegKIcAP63IF2Ioj2ANKJAAALQav9Aol +AAEAFAAxz3WAAOAGyXEB2gytiiAYCOoP7/VIc4DgyiHBD8oiwQfKI4EPAAAWBgXY4/MAFAAxDa1t +AS/2ocDgeM9wgABYL+B/FIDgePHA5ggP9gh3GnEB2c9wpwCYRzqgIN7PdaAAyB/QpQrYQx0YEADY +bg6v9Y240aXPcacAFEgMgQToPoED8D2BABhAIPe5xSGCDwD/AADTIeEF+QAv9iCn4HjxwJIID/bP +cIAAsE4HiIDgWAIhAKLBAdnPcKAAyBwxoIoP7/4F2M92gABYLw+mw9jPdaAA7CcGpQqFz3enABRI +ALaKIMQABqUKhc9xpwCYRwG2iiDFAAalCoUCtoogywAGpQqFA7aKIM8ABqUKhQS2z3AAAIMNBqUK +hQW2z3AAAMMNBqUKhQa2z3AAAAMOBqUKhQe2CIcEphyBBaYXhwamFocHps9wpQAIDAKACKYNhwmm +DocKpg+HC6bPcKsAoP8YgAymz3CrAKD/GYANps9wqwCg/xqADqbPcAUAxgMGpcbYkLgGpc9wLAAC +AQalz3BaAEIBBqWKIIsABqXPcEAAhw0Gpc9w0QDCDQalz3DAAAcOBqUB2Ainz3BQAP8AHKEB2Ben +ANgWp89wpQAIDFDZIqAA2A2nDqcPp/zZz3CrAKD/OKBz2TmgGoDPcasAoP+BuBqhz3AqAAIOBqWL +cIHBkv8Awc9wgABwWzWmMqABwS+gz3AaAAIOBqWLcIHBi/8Awc9wgABwWzamM6ABwTCgz3AmAAIO +BqWLcIHBg/8Awc9wgABwWzemNKABwSAWBRAxoAGWELiFIIQABqUClhC4hSCFAAalA5YQuIUgiwAG +pQSWELiFII8ABqUFlhC4BSCADwAAgg0GpQaWELgFIIAPAADCDQalB5YQuAUggA8AAAIOBqUEhkwl +AIAIpwaGF6cHhhanz3ClAAgMCBhAAcohwg/KIsIHyiBiAcojgg8AAPkAUAOi9MokIgAJhs9xqwCg +/w2nCoYOpwuGD6cMhhihDYYZoQ6GGqHuDu/+D4YA2M9xoADIHBGhkQbv9aLA4HjxwBoOz/XPcIAA +sE4miM91gABYL6LBBOkHiIboE4VdBu/1osAA2QPYOnEacIogkQXeDm/1ANkGDe/+BdgPpcPYz3ag +AOwnBqYKhs93pwAUSAC1iiDEAAamCobPcacAmEcBtYogxQAGpgqGxtoCtYogywAGpgqGkLoDtYog +zwAGpgqGBLXPcAAAgw0GpgqGBbXPcAAAww0GpgqGBrXPcAAAAw4GpgqGB7UIhwSlHIEFpReHBqUW +hwelz3ClAAgMAoAIpQ2HCaUOhwqlD4cLpc9wqwCg/xiADKXPcKsAoP8ZgA2lz3CrAKD/GoAOpc9w +BQDGAwamAdhGps9yLAACAUamz3JaAEIBRqaKIosARqbPckAAhw1Gps9y0QDCDUamz3LAAAcORqYI +p89yUAD/AFyhF6cA2Banz3ClAAgMUNkioADYDacOpw+n/NnPcKsAoP84oHPZOaAagM9xqwCg/4G4 +GqHPcBEABg4GpotwgcHz/jaFAMAieIQohAMVhTeFAnmaD6/7L3ABwoIgxALPcYAAcFsTpVWhFqHP +cEAAhg0Gps9wEAACDgami3CBweP+NoUAwCJ4BCiADwAAdAkVhTeFAnlaD6/7L3BP4BSlz3GAAHBb +GKEBlRC4hSCEAAamApUQuIUghQAGpgOVELiFIIsABqYElRC4hSCPAAamBZUQuAUggA8AAIINBqYG +lRC4BSCADwAAwg0GpgeVELgFIIAPAAACDgamBIUBwginBoUgFQUQF6cHhRanz3ClAAgMCBhAAVeh +hQ0RAAmFz3GrAKD/DacKhQ6nC4UPpwyFGKENhRmhDoUaoXIM7/4PhROFbw4CcAAAyABnCIIP///s +/4wggoBG9lsOAnD//+L/IN/PdqAAyB/wpgAhQCQVeEMeGBAA2CoJr/WNuPGmuv6KINEFXgxv9TOF +QiBAIIDgQCFBIGgF7f8veQ3wCiHAD+tyBdj520EAr/RKJAAAHtgTpUwVBBCMJIKARfaMJL+ICvYK +IcAP63IF2IojBA4ZAK/0uHOKINEFCgxv9YhxFQXP/+B48cDhxc91gAAwc5INL/+pcLhwAIUR6M9y +gAAkP0okgHMA2KgggAJEKH4DMiJBDkUJQAEB4BXwANhKJIB5z3KAADxAqCDAA1kiwQhEKH4DJ3Ey +IYEPAAAoARkJQAEB4AohwA/rcgXYqNuZB2/0SiSAAhkDz/XPcIAAMHNAgCOACurPcIAAMD9EKX4D +MiBADg7wz3CAAFhAWSBACUQpfgMncDIggA8AACgB4H7gePHAYgrP9aHBGnAodkh1iiARBUILb/WK +IUcCiiARBTYLb/UKcYogEQUqC2/1yXGKIBEFIgtv9alxz3GgACwgEIHPc4AAGAcEoxCBRINCeC8I +ZQMDo0AogiFFIs8Az3KgAOwn5qJKgotwQLAAFAAxxHjZDgGQUQLv9aHAopPPcIAAMHMMEAQAABQP +MRC9CiHAD+tyBdiKI0cEBSREAxC/uQZv9AUnhRPgePHAugnv9QDYz3GAALBOJJGiwYLhzCFigMog +YQAvIAcgz3aAABgHApbPd6AAyB8B4AK2AdhRHxiQz3DAAEdoz3WgAOwnBqXD2AalCoVAJIEwALEC +FAAxwbgjCNAAz3ADAMYABqUg2BCnMthDHxgQANj2Dm/1jbgg2BGnz3GAADQnBIElCFEABoFAeM9w +gAAwcxiIlejPcAEABgEGpc9wEgAGBBTwCiHAD+tyBdjr20okAAD9BW/0CiUAAc9wAQAHAQalz3AS +AAcEBqWKIMQABqUKhc9xgADcBgCxz3CAADBzABAEAM9wgAAwc89yAADCGs9xAAACNAOARQwQAEQo +fgMAIYN/gAAkP8bYkrgGpUalJqXPcAAAgk0GpcfYlbgGpc9wgACwTgCQz3GnABRIhuAB2MIgAQAT +eMK4HvBEKH4DACGDf4AATEDH2JK4BqXPcBkAwhoGpc9wGQACNAalz3AZAIJNBqXG2JW4BqXPcacA +FEgA2AuhDKHPcIAAsE4AkA8IkAHPcaoA4AcB2BOhFQwRAEwgAKDKIIIPAgCCcgX0z3AQAIdyBqUB +ixC4BSCADwAAQnIGpQWLELgFIIAPAABCcAalBIsQuAUggA8AAIJwBqUDixC4BSCADwAAwnAGpQKL +ELgFIIAPAAACcQalCYsQuAUggA8AAEJxBqUIixC4BSCADwAAgnEGpQeLELgFIIAPAADCcQalBosQ +uAUggA8AAAJyBqULixC4BSCADwAAgnMGpQqLELgFIIAPAADGcwalQtiMuAalz3ABAEZqBqWkFxAQ +z3CAAMZzBqXPcEAAQnQGpc9wgADHcwalz3ACAEZqBqXPcBAAxmoGpSTYGNkz2jb/z3AQAMdqBqXP +cBAAhnIGpSTYAdkz2jD/pBcAEAIgAAQAps9wAgBHagalz3DAAEZoBqXPcAAAwwkGpQqFi3EAsQAU +ATGA4cwh4oco9NoPL/WKIJEEA5YB4AO2BJYdCFEABBYEEQAUBTEKIcAP63IF2LkDb/SKI0YFIQiR +AAQWBBEZDJIAABQFMQohwA/rcgXYmQNv9IojRgbPcIAAMHMYEIQAgcDPdgAAQyHPcxEAQiHPcYAA +oD9YIcUHz3ESAEIhz3ITAEIhxqXKhcCwZqXPcIAAMHMDgBEMEQAVJQAA8BAAAQbwFSUAALgQAAEQ +uAUggA8AAMIiBqUmpQalRqUGpQQUADEQuAUggA8AAEIhBqUA2FEfGJCFBq/1osDxwOHFz3WAADBz +AKUhpVitea2//gOl2/4Epc9wgACwTgeIgOA8DML/bQaP9c9xgACwTiSRgeEB2cB54H8goOB48cC0 +wYogmAPCDi/1A9kWDWAAi3CKIJgDsg4v9QvZiiCYA6oOL/UR2bTA0cDgfuB48cDhxaHBi3GCDG/1 +AdoAwc9wgADIgIDhyiGBDwAARAAF8oHhiNnKISIMgLkgqADdqKjJ2SWwAtkhqP/ZIbClqCDZJKgD +2X4N4AEpqKlw2QWv9aHA8cBaDa/1ANnPdoAA/BYXhs91gACIfA8hAQAZhiR4QiAAgMogYgChwQHf +FwhRAM9xAADEJQnY8g7v9lYlghQ3hgDYDyBAADiGJHhCIACAyiBiAADZJQhRAAnYYMABHEIwAhzC +MwMcwjOLcATZViWCFAYP7/aKIwQIANhJBa/1ocDxwLTBiiCYA74NL/UC2WIMoACLcIogmAOuDS/1 +Cdm0wNHA4H7xwLYMr/UA2c91gAD8FheFz3aAADh+DyEBABmFJHhCIACAyiBiAKHBAd8XCFEAz3EA +AMQlENhODu/2VSbCGDeFANgPIEAAOIUkeEIgAIDKIGIAANkjCFEAENhgwAEcQjACHMIzAxzCM4tw +BNlVJsIYYg7v9ihzANilBK/1ocDgePHAOgyv9ahwiHWA4c92gADIgMohIQEG8oHhCNnKISIEgOLP +IWEBB/KB4s8hoQHPIeIBL3mAuSCuANpIrmW2vH2hrv/ZIbZFrgSuQ7YD2P4L4AEJrlEEj/XxwLTB +iiCYA8IML/UA2a4PoACLcIogmAOyDC/1ENm0wNHA4H7xwOHFocGLcY4Kb/UB2gAUBDDPdYAAfHvP +cIAAuC+pcRTaigngAADbABQEMM9wgAAsB1YlgRID2nIJ4AAC289wgADgL1UlwRUS2soJ4AAAwwDY +4QOv9aHA8cDhxQDYCHG2D6AAAtoB2ADZrg+gAALaAtgK2aIPoAAC2s9wAAAE0gDZlg+gAADaz3AA +AA3SAdmGD6AAANrPdYAALAcThRUlABAkgM9wAAAR0m4PoAAA2s9wgACwTiCQE4UVfQkJkQEmhQPw +JIXPcAAAENJKD6AAANrPcAAAAtLPcdAH/wA6D6AAANrPcAAAAdID2SoPoAAA2s9wAAAD0gLZHg+g +AADaz3AAABvSA9kOD6AAANoA2I+4A9kCD6AAANrPcAAABdIA2fYOoAAA2s9wAAAL0s9xSwBLS+IO +oAAA2s9wAAAS0gDZ1g6gAADaz3AAABPSANnGDqAAANrPcAAAFNIA2boOoAAA2s9wAAAEQ4ohzw+q +DqAAANrPcAAAcNIA2ZoOoAAA2rECr/UA2PHANgqv9bXYocE+D6AAANmKIIQGMg+gAADZiiBGACoP +oAAA2QTYIg+gACzZD9gaD6AAAdkG2BIPoAAV2QjYCg+gABXZCdgCD6AAFdkK2PoOoAAB2QvY8g6g +AAHZDNjqDqAAAdnPdYAALAdRhQXYSNnWDqAADyGBADOFi3YVJUwQFJQTCVAAz3GAALBOIJFXCZEB +8g6gAMlxE4UAwRUlABAUkKYOoADGuROFFSUAEBiQ0g6gAMlxE4UAwRUlABAYkIYOoADGuROFFSUA +EByQtg6gAMlxE4UAwRUlABAckMa5KPCiDqAAyXEThQDBFSUAEBSQVg6gAIe5E4UVJQAQGJCCDqAA +yXEThQDBFSUAEBiQNg6gAIe5E4UVJQAQHJBmDqAAyXEThQDBFSUAEByQh7kWDoAAANhtAa/1ocDx +wOIIr/UB2hpwz3GAADxCAIGkwUHAApGDwQgcBDC2Dy/1CnDPcIAAsE4AkAPCCwiQAcO6Q8LPcYAA +LAeBwwpw0g+gADCBIcD6CeAAB9kacAUUgDDuCeAAB9k6cApwANkI2ipzSiRAAq4K4ABKJUAEWnAG +FIAwzgngAAfZCHYHFIAwwgngAAfZCHXJcADZCNqpc0okQAKCCuAASiVABEDAIsCiCeAAB9l6cAkU +gDCWCeAAB9macGpwANkI2opzSiRAAlYK4ABKJUAECHfPcAAACNJKcX4MoAAA2kHYCbgKcXIMoAAB +2s9wAAABgipxZgygAAHaAMHPcAAACdJWDKAAANrPcAAAAoLJcUoMoAAB2s9wAAADgqlxOgygAAHa +z3AAAArS6XEuDKAAANrPcAAABIJqcR4MoAAB2s9wAAAFgopxEgygAAHaANjtB2/1pMDxwKTBi3F+ +Di/1A9qqCe//g8ADwLLoAMHPcAAAG9KQ6QHZ4gugAADaz3AAABzSAdnSC6AAANoC2ArZMPAhCVEA +AtnCC6AAANrPcAAAHNIC2bILoAAA2gLYFNkg8ATZpgugAADaz3AAABzSANmWC6AAANoC2CHZEvDP +cAAAG9IC2YILoAAA2s9wAAAc0gDZdgugAADaAtgR2WoLoAAC2gLBz3AAAAXSXgugAADaAcHS2Ai4 +O3kB4U4LoAAA2gDYpMDRwOB+8cDiDk/1qcFAwEHBANhIwILFMgjgAKlwhMYqCOAAyXCGxyII4ADp +cADAi3LCD6AAF9kBwIHCug+gABfZAMAOCOAAqXEBwAYI4ADJcalwqXEGCOAAqXLJcMlx/g+gAMly +qXDJcRII4ADpcgbAB8GIw1IOoAAB2gjA0QZv9anA4HjxwFYOT/UacM9wgACwTgCQocHPdoAALAcy +hh8IkQEA2I7hAdnCIU4AgOHKIgIgAt0L9AHdCPAC3Y7hAdjCIA4AG3gB4FpwEYaA4EAqDyGM9AbY +JgugALlnCnDPcq3e777ODKAAuWcKcEH/g+AUAgEAz3AAAAfSz3EDD/DAAN9CCqAA6XLPcAAABtLp +cTIKoADpcjGGCnAE2gokgA+t3u++jgygAP/bCnCF/4Pg6vLPcAAAINJVJkEYWgqgAATaz3AAACHS +ViZBFEoKoAAE2oQWABCIFgEQq/86cM9wAAAH0s9x5BAOOdoJoADpcs9wAAAG0ulxygmgAOlyMYYK +cATaCiSAD63e774mDKAA/9sKcGv/g+C28s9wAAAg0lUmQRjyCaAABNrPcAAAIdJWJkEU4gmgAATa +hBYAEIgWARCR/wIgUIQ4AAMAEoYB2o7gwiKOAM9wgACwTiCQi+padx8JkQEL8IHgCNjKIGICc/FK +IoAgCwmRAQXdAvAD3XMIUiBvCIMvAAB8ks9wAABQw84PL/sKcYDgyiBsAMj2jCACiMoghg8AAJ8A +z3GAAFAw8CEAABV4pg8v+4ohDwodZUPYFabPcAAAC9LPcUMAQ0PyCKAAANrPcIAAsE4AkA0IkQGL +5col7RIF8IrlyiVtEUcOA3QAACT0z3EAAFDDXg8v+wpwgODKIGwAx/aMIAKIyiCGDwAAnwDPcYAA +UDDwIQAAFXg6Dy/7iiEPCgJ9gOXKJWsQQCoAIR1lEYaJ6AbYOgmgAKlxAtgK2RfwIwhRAAjYJgmg +AKlxHg6v/4twAMEC2IDhFNnKIWIEB/AJ2AoJoACpcQLYIdlKCKAAAtq0pgDYMQRv9aHA4HjxwNIL +b/UE2qTBGnCqCi/1i3EAwc92gAAsB3GGz3CAADgwBBQRMADd8CDCAM9wgABEMPAgzwDPcAAABtJY +efoPYACpcs9wAAAH0gApwSPqD2AAqXIKcM9yrd7vvkoKoAA0hgpwoP5RCNAAMYYCwgpwCiSAD63e +774uCqAAA8MKcO3+NQjQAM9wAAAg0lUmQRj6D2AABNrPcAAAIdJWJkEU6g9gAATahBYAEIgWARAT +/xymqXB9A2/1pMDgePHAHgtP9aHBCHUAJI4AYn4CJk4RoHJiegIiAoEA2EDADfIsfot2L3BIcdIL +oADJcp4LoADJcADAAn2pcEkDb/WhwOB48cDeCm/1iiTDDwh2z3WAACwHe4VZhQolgA+t3u++OoV6 +YoYJoAAD28lwtv+XCNAAHIVbhQolgA+t3u++eYU6hR2lyXB6YgTbXgmgAIokww/JcKz/bwjQAByF +W4UKJYAPrd7vvnmFOoUepclwYnoD2zYJoACKJMMPyXCi/0cI0AAchVuFCiWAD63e7755hTqFH6XJ +cGJ6BNsOCaAAiiTDD8lwmP8fCNAAcBUFEHwVBBAbhTmFgB1AEV2FfoXA/xulANiJAk/14HjxwBIK +b/UB2wh3z3WAACwHWoU5hQolgA+t3u++AN5ZYVuFvgigAJh26XCE/5EI0AAchTqFAttZhR2l6XAK +JYAPrd7vvllhW4WWCKAAmHbpcHr/bQjQAByFOoUB21mFHqXpcAolgA+t3u++QnlbhXIIoACYdulw +cf9FCNAAHIU6hQLbWYUfpelwCiWAD63e775CeVuFSgigAJh26XBn/yEI0ABwFQUQfBUEEBqFOYWA +HUARXYV+hZD/GqXJcL0BT/XxwE4Jb/UB2qHBGnAiCC/1i3HPdoAALAcQhs9xgAB8e1UhzwgCuBR4 +H2cAwFYhDQfPca3e774QpuYPYAAKcApwjv9NCNAAANgD8BiGAeA3hh0IZQAYps9xrd7vvsIPYAAK +cApwt//nCNGAEvARhjqGFX8gtzuGIbcwhjlhNHkUeRSGPWUArRWGAa0A2CUBb/WhwOB48cC6CG/1 +CNmhwRpwAtjPdoAALAcXpgrYGabPcq3e775qD2AACnAKcDf9g+B78gDd9g5gAKlwmgqv/4twz3CA +ALBOAJAVCJEBBtgQpgHfCfAQhgHgEKYF8LCmA9+pcJkI1QHPcYAABDDwIQAAAdmO4BKmwiFOAOIO +YAAzptUPdJCxpgDYAMEG6YDgzCCigC7yz3Gt3u++9g5gAApwCnAw/YMI0ADPca3e777iDmAACnAK +cHf9bwjQALqm/9gbps9xrd7vvsYOYAAKcApwZP5XCNAACnDPcq3e776yDmAAMIYKcKP/PwjQABGG +AeCZCOSDEaaw8c9xrd7vvpIOYAAKcAoPYAAKcB8I0AAKcM9yrd7vvnoOYAAQ2Qpw+/yD4MogIgBs +8fHAkg8v9QfYKHcacjpzAN7PdYAACDMBpcKlz3BoH/8AA6VIcMlxCNoKc0okQAKOCaAASiVABA6l +CnDJcQjaCnNKJEACdgmgAEolQAQPpQpwyXEI2gpzSiRAAmIJoABKJUAEEKWE7wHYEaUK8AsPURAC +2BGlBPAJD5EQ0aXSpf/YANkJ2ghzSiSAAjIJoABKJcAEANkT2v/bSiQABR4JoABKJUAHE6XPcIAA +uAcUIEAECpBBBy/1B6WA4ADZyiBBAAXygeAB2MogogBI2Q8hAQDPcIAAgDPgfzGw4HjxwOHFocGL +cZIN7/QB2gAUBDDPdYAAiHzPcIAA3DKpcRXajgxgAADbABQEMM9wgAC8B1UlQRUD2nYMYAAC289w +gABcM1YlARMS2s4MYAAAwwDY5QYv9aHA8cBiDi/1BNqkwRpwNg3v9ItxAsADwwDdqXEI2kokQAJm +CKAASiVABAhxAcCWCmAAqXIKcM9yrd7vvvoMYAAAwXoIr/8KcG0I0ADPdoAAuAfPcAAAINJVJsEV +vgpgAATaz3AAACHSViYBE64KYAAE2jeG+IZBKcAFwLgYuBN4JXhBL8EVwLkYuTN5JX8Xps9xAABo +H/imyggv+wi4GabPcQAAaB+6CC/7QC8AEhqmqXAVBi/1pMDgePHAhg0v9QratMEacH4M7/SKwQbY +rgpgAAvBCNimCmAAC8EJ2J4KYAALwTgUBDAKcArBDMIKJYAPrd7vvj4MYAANwwpwwf+D4Mnyz3aA +ALgHGYZAFAQwD6YahgrBCiWAD63e774MwhKmCnASDGAAD8MKcLb/g+Cz8hmGSBQEMBCmGoYKwQol +gA+t3u++DMITpgpw6gtgABHDCnCs/4Pgn/IZhjqGEaZPhjSmsIZCKtUHmnBCKNYHqXcShl+9GnBC +KNkHE4Y6ckIp0gcbcXpwQijXBwIgQIBAwAMngCRBwAIiwIMAwkLAAyVAI0PAAsADwUIPYAABwwIn +D5VEwAMljRUCIMCkRcFIwAMhwDVJwAjACcHpckbHR8UaD2AAqXMEwwXCAiMDgADdAyJBAGhwiiIP +CioPYACpcwUgfoB6cCh3SvIAIBCmBsIBIlImCnBKceIOYAAHwwAhEaUAwhtw+nEBJZUlKnCqccoO +YAABwwIgArATwAMnQyDacLoOYACpcU4gA4AA3AMkQRBocGpyzg5gAOlzAsKacApwSnGWDmAAA8MI +wlpwGnEqcKpxhg5gAAnDAiIDoMpyAyBBIGhwdg5gAKlzanKWDmAA6XNUHgAVFqYE8LWmtqYA2O0D +L/W0wPHAugsv9QzYmnFachpzAN/PdoAAuAd6cM9wgACkM/Ag0QMehqIO7/oqcTyGOGATeJYO7/qK +IQ8KCHUfhooO7/oqcT2GOGATeH4O7/qKIQ8KM280eUAsQiFWejpiACABJDR5WWHHcYAAFH0NChEg +pKkFqQnwCwpRIKapB6kD8KipCalCI0Agkwh1gAHngQMv9QDY4HjxwB4LD/WlwbpwANhEwM92gAC4 +Bwh1geUB2MB4ACCRDwAACNKC5cohgS8AAArSSiIAIADf8CaAFEojQCAUJtATjuDCI84kjglgAAwQ +ECHPcYAA0DIEbgPapghgAALbanCpcQra6XPP/s9wgADcMs9xgAAIMxXaighgAADbqXD3/s9wgABc +M89xgACAM94IYAAS2ocLESCD2PIPIABAJgEYKIaD2KoPIADGuejY3g8gAEAmARgohujYlg8gAMa5 +iiCFA8oPIABAJgEYKIaKIIUDfg8gAMa5ktiyDyAAQCYBGCiGkthqDyAAxrn32J4PIABAJgEYKIb3 +2FYPIADGuYogRQeKDyAAQCYBGCiGiiBFBz4PIADGuYogvw1AwEHACthCwM9wrd7vvkPAqnCpcQpy +KnNKJIACCiUAAQomAAHKCGAATiQHAKpwEf+D4LzyFYapcQmmFoZAIMIgSiSAAipzCqaKIL8NQMBB +wArYQsDPcK3e775DwKpwCiUAAQomAAGGCGAATiQHAKpwAf+D4JzyNYZWhgqGK6ZMphN4VHhJhhym +E3hTejR6XaaKIQ8K3gtgAITCHYYQFBMwiiEPChN4ygtgAITCHIYQFBQwiiEPChN4ugtgAITCBMCK +IQ8KQiCWAh2GE3imC2AAhMIEwAAcgDWpcQpyQiCHAgQcwDEK2ELAz3Ct3u++Q8CqcCpzQCOEIkAk +hSLyDyAACiYAAapw2/6lCNAAFYYNphaGDqaH7QbYWg4gAFUmwRYRDVEQCNhKDiAAVSbBFg8NkRAJ +2D4OIABVJsEWG4bDuA0IdAMbpgvYG6bPcYAApDPwIQAALoZNhgx5eB5AHgx6CYZ8HkAeg+gKhgno +C4aD6AyGBeiA4swhIYAG9ADYHKYdph6mH6aqcEpxqXLpczH/AeeE54gFxf9AIlKgfgXB/0AlTZBa +BcH/ANilAC/1pcDgePHAcggv9QjZz3Kt3u++Lg8gAAh2yXBn/k8I0AAA3boOIACpcM9xrd7vvhIP +IADJcMlwQf8zCNAAz3Gt3u++/g4gAMlw0gpv/8lwHwjQAMlwz3Kt3u++5g4gABDZyXBV/oPgyiBC +A3kAD/XgePHA4cWhwYtx1g6v9AHaABQEMM91gAA4fs9wgADgM6lxF9rSDSAAANsAFAQwz3CAADwI +VSXBFQPaug0gAALbz3CAAHg0ViVBEwvaEg4gAADDANgpAC/1ocDxwK4P7/QX2qbBz3ZAH/8Az3U+ +AD4+z3CAAOAzz3GAABA0Tg0gAADbz3AAAAvSABwEMM9wAAAC0gIcBDDPcAAAG9IEHAQwz3AAABzS +QsUGHAQwz3WAADwIAoUA2UPGDyEBAAOFRMGCwQTaRcCLcAINIAAA289xgABsNKlwA9ryDCAAAtsA +2JUH7/SmwPHA4cWhwc9wgAA8CCKAUNgPIE0Az3CAAHg0z3GAAJA0Lg0gAAvaBdgAHAQwAhxEM4tw +QCSBMBoNIAAB2gDYmfHxwOIO7/QB2qHBCHauDa/0i3HPdYAAPAgAFAQxIoXJcEOFyNuGCm//SiUA +AM9wAAAg0kAlARRaCyAABNrPcAAAIdJAJQEVSgsgAATaANgBB+/0ocDxwI4O7/QC2qLBCHZaDa/0 +i3EAwADdqXEE2gLbSiSAAYoIYABKJcABCHF2CyAAS9jJcM9yrd7vvh4NIAABwclw2/+D4MogQgOx +Bu/0osDgePHAKg7P9K7BenBacTpyGnOCxYoPIACpcITGgg8gAMlweg8gAIbAdg8gAIjAbg8gAIrA +jMdmDyAA6XBqcBfZCg8gAItySnAX2f4OIACBwgDAUg8gAKlxAcBKDyAAyXGpcKlxTg8gAKlyyXDJ +cUIPIADJcqlwyXFaDyAAhsIqcBfZxg4gAItyCnAX2b4OIACBwgDAEg8gAKlxAcAKDyAAyXGpcKlx +Cg8gAKlyyXDJcQIPIADJcqlwyXEWDyAAiMLPcAAAKhLeDiAAisGIwIrB4g4gAOly6XAL2RIPIADp +cobAJg8gAOlxgOAB2Br2z3AAAPYPsg4gAIrBiMCKwbIOIADpculwC9nmDiAA6XKGwPoOIADpcYDg +AtjKICoAZQXv9K7A4HjxwAIN7/QB2qHBmnDmC6/0i3EAwc9wgADUM892gAA8CPAgQAAips9xrd7v +vgOmtgsgAIpwinBO/0oiACCjCNAAz3Gt3u++ngsgAIpwinBr/48I0ACKcA/Zz3Ot3u++hgsgAALa +inCK/x/fdwjQABAWEBAUFhEQCiOAJAPwWnVKdR7wqXcc8AAnjRS9fbB9inCpcc9zrd7vvkoLIAAK +2opwe/8/CNAARIYKcCpxZYaM/9MIUIDJCJCASiNAIAIngBQJCJQAwwsQoIHgyiXOE89wgACoNPQg +QAOmpgemANh5BO/0ocDPcIAAtH4osOB/SbDxwCoM7/QI2c9yrd7vvuYKIAAIdslwBP9jCNAAANnP +dYAAPAgipc9yrd7vvsYKIADJcMlwt/9HCNAAIoVAIUGAIqXz8yyVyXBOlev/z3Gt3u++ogogAMlw +Gg8v/8lwHwjQAMlwz3Kt3u++igogABDZyXDt/oPgyiAiAB0Ez/TgePHAngvP9DpwKHUacrIK7/0H +2CUIECAnCFAgKQiQIAohwA/rcgXYNdsKJEAEaQCv8wolAAQp2RK5BvAV2RO5BPAr2RK5FSFBBKCh +EgzP/bEDz/TgePHARgvP9DpwKHUacl4K7/0H2FpwDwieILIKb/5k2FAgkCAlCBAgNQhQIDcIkCAK +IcAP63IF2GDbCiRABAUAr/MKJQAEKdgSuPAgQAQApboL7/1KcE0Dz/QV2BO49vEr2BK49PHxwOoK +z/QacCh3AdgA3c92oADIHBGm8gnv/QfY8H9AKIEhgbkQv+V5z3KgAOwnJqKxpnILz/0ZA8/04Hjx +wK4Kz/ShwRpwKHYB2M91oADIHBGltgnv/QfYQCiQIUUgwyDPcqAA7CdmokqCi3FAsQAUATEA3yCm +8aUqC8/90QLv9KHA4HjxwGIKz/QIdzpxGnMdCnQAAN5IdfQngBMVIYEjCnK//2G99Q11kAHmmQLP +9PHANgrP9Ah3OnEacx0KdAAA3kh19CeAE/AhgSMKcp//Yb31DXWQAeZtAs/08cALDN4A6f8C8PP/ +0cDgfvHA/gnP9KHBCHcacSEKdAAA3kh19CeAE4txzv8AwBQgjCNhvQC08Q11kAHmsvHgePHAzgnP +9Ah3GnEdCnQAAN5IdfQngBP0IIEjs/9hvfcNdZAB5g0Cz/TxwAsL3gDp/wLw9P/M8eB48cCaCc/0 +CHcB2ADdz3agAMgcEaaeCO/9B9iAv89xoADsJ+ahsaYqCs/92QHP9OB48cDhxQhxjuAB2MIgDQAA +3c9zqwCg/7mjB9pao7ijAdouCy//SHMaC+/9Adi1Ac/0BQRP9PHAUg0AAC4J7/RQ2UXASiAAIIbF ++v8lCDUlBBUBFAXAFSAABCCgQCBQIO8JgY+t3u++JNxjAc/0CiHAD+tyBdiKIwUImHPhBW/zCiUA +BOB48cDhxc9wgAC4JqiAUyLAAIYi/wNEulpiVHoDuBR4WGC4YGhx5g9v9AbaNQHv9ADY8cC2CO/0 +ANnPdoAA/BYXhs91gAB8ew8hAQAZhiR4QiAAgMogYgChwQHfFwhRAM9xAADEJQvYTgov9lUlwhg3 +hgDYDyBAADiGJHhCIACAyiBiAADZNwhRAAvYYMABHEIwAhzCMwMcwjOLdslwBNlVJcIYYgov9lTb +EdhgwMlwBNlWJQIXTgov9izbANiRAO/0ocDgePHA+g+P9FpwGnHacPpxOnJ6cwDYmnBvJUMQCHZK +IMA3O3AId7pw6XCqcTYMIAAB2gAgQIMBIYEDJgwgAAtyQiBYsMpzQyEZMPJxzCDBgAr3ACdPkwEl +lSMCJhagAydXIKlwyXEmDCAAAdoFIH6ACHUodtv16XCqcelyLgogAKpzAiISoOlwAyBQIKpx0gsg +AAHaBSI+pAh1KHYQ8gUlvpMM8ipwANlKcv4JIAAKc6lyFgogAMlzmnAqcADZ6XLqCSAAqnMAJAIg +cQev9AAbgCAggADagOFF9gHaM3kgoIAhAYB/3MAhBANHuSCgA+ozeSCg4H4ggAe54H8goKHB8cDh +xULAmHFIdYDgANpE9gHaE3hCwILA+P8CwAPqE3j+Ca/6iHEApQjccweP9OHF4cYA3TMJ0AcLCdMH +CwkTAADYE/AZCfMHH95OIfwH4HioIIABDyWNE2G+CQhOAKV4A/CmeACiAdjBxuB/wcXxwKHBANpA +woty7v8AwKHA0cDgfgDZIKDgfyGgCHJfuECh4H8BoeB48cCSDo/0SHVAgGGAwYEAgQIJIADJcQCl +5Qav9CGl4HjhxeHGwIBhgKCBAYEAJY2TASDAAKCiAaLN8eB48cBWDo/0SHXBgACAKHLaCiAAyXEA +pa0Gr/QhpWCAQIEBgCGBUHPMIEGA4SDBB8ogIQAwcIb2BPYJCsUA4H8B2Iog/w/gfuB4n+HMIO6H +zCBOgAb3AnlBaQsKEQiKIf8PBvAA2Q8hgQBhuRh54H8ocPHA4g2v9NhwKHZIcYh1yXDy/wh3qXCo +cfD/CHEALoADBH8mfwArQAMkeCEGr/TlePHAtg2P9Eh2gOAB3UT2iiX/HxN4CQkTALN9M3kUIQAA +igiv+jt5rHgAHkAe9QWv9AHY4HgIdADYBSp+AC9xBSo+AwAgQI4BIcEOBSs+A+B/J3HgeDMAIABK +JAAAByHEAC8mQPBKJQAAEAAmAC8kBAEOIECBAyVBAIDjDgADAA4iQoEDJcMABSOFgDABAQB5c0h0 +CHIocwolwIJKIgAQGgAEAMAiIRjKJQGDLy9BAcAiYxDAIsMRSicAAAolwIDAJyEIFgAEAMolgYAv +KEEBwCdjAMAnAwAOJ4eCyickAEAnRwAKJcABTCcAiADZEAAkAADYSHFocgDbQicHiAokQHEoAAEA +TicKiH4AAQAAKYACASnBAQAqhQKgcQEqwgEAK4UCASvDAaByTCIAmGoACQCoIIAFACAAgAEhQYAB +IoKAASPDAAIiAoMDI8OCDAAGAAAiAoMBI8OCwCBmAEIkPoBKJQAAIAABAAwACgAOIkKBAyXDAC8k +AIEMAAMADiBAgQMlQQDgfihwSHFocgDbICCADwEAGJqoIIADACAAgAEhQYABIoKAkXLCIgYDxSBm +ACAggA8BAEyaANoJagDbLyECACAggA8BAHSa4Hj8HIix/BxIsfwcCLHhw+HC4cHhwAfAHBzAMeHA +4H8BwFMiQoHgfE4iA4gWAAwAASjMAAApgQAAKIAA4H+FeU4jAwAAKMEA4H8CeOB4UyJCgeB8TiID +iBYADAAAKcwAASmBAAEogADgf4V4TiMDAAEpwADgfyJ54HhTIkKB4HxOIgOIFgAMAAApzAACKYEA +ASiAAOB/hXhOIwMAAinAAOB/QinBB/HACiHAD+tyBdgO24okww8hAG/zuHPgePHAocGB2GDAA8wC +HAQwAMBmDW/0AtmhwNHA4H7gfuB44H8A2OB+4HjgfuB44H7geOB+4HjgfuB44H7gePHAo8EA2WDB +ARwCMAMcQjACHEIwAdjPcaAAyB8ToRmBQsAYgQzZQcCLcMIOL/SE2qPA0cDgfuB44H7geOB+4Hjg +fuB44H7geOB+4HjgfwDY8cChwYDYYMADzAIcBDDPcKAA1AMckK4MT/QAwM4Mb/QC2ZIP7/8C2KHA +0cDgfuB44H8A2OB/ANjgfwDY4H8A2OB/ANjgfwDY4H8A2OB/ANjgfwDY8cBOCq/0iiD/D891oAA4 +LseFB6XPcKAAVC4LgAYmAHAPAP//Rg7v9BbZtg/P9MeliQKP9PHAiiDKBf4KL/SKIQQN9gjv9AHY +A8iE4HQNAfPPcQAARAjOCm/zBtgNyAUggA8BAAD8DRoYMAPICwieABINz/UM8ADanroA2c9woAD8 +REGgz3CgALQPPKDd/y4OT/tWDW/9AdjKCm/zAdjRwOB+4HjxwOHF63WKIIoFigov9O/ZiiCKBX4K +L/Spcc91gABkCACFLwhfAAOFUiCAAAOlCfDPcKAAqCANgOTg9gAFAF4Kb/RU2EQgAQEDhekIQYCK +IIoFQgov9IohBAADyDsIEQHPcYAAXEQBgaW4AaHPcYAA6IDDEQAGpbjDGRgACYGluAmhJbjAuM9x +gAAYbBoO7/8KoeoPz/OKIIoF+gkv9IohhAMA2s9woAD8RJ66QaDPcKAAtA8A2TygDcgEIIAP/v// +Aw0aGDANyIe4DRoYMH/YCrjPcaAA0BsToX/YEKEA2JW4EKHPcQAAiAqWCW/zBtjPcaAA8DYEgUYg +wAEEoZTYxgwv9BjZiiCKBYoJL/QghQCFUSBAgLAMYvvKICIAiiCKBXIJL/SKIYQK9QCP9AohwA/r +cgXY+9tKJAAAWQUv8wolAAHxwOHFocHPdYAAZAhElSKViiBKBRC6Ogkv9EV5QoUhhUEJgAADyEDB +CwgRAU8hAAFAwIzpCurPcIAAzAUggM9wnwC4/z2ggv+LcATZEgwv9KHaIYUF6QKFg+iZ/yGFIqUl +6QDZz3CgAPxEnrkhoM9woAC0DwDaXKANyAQggA/+//8DDRoYMA3Ih7gNGhgwf9gKuM9xoADQGxOh +f9gQoQDYlbgQocIIb/MB2DEAr/ShwPHA4cUAFgBAz3WAAGQIng0v9AClAIUI6B8IUACC4PANwf8L +8IIIb/RU2A8IXgABhYG4AaXH//UHT/TgeM9ygABkCCGCJXjgfwGi4HjPcoAAZAghggZ54H8houB4 +8cDPc6AArC8Zg/C4GYMM8gQggA8IAAAA13AIAAAAAdjAeAfwhiB/D4LgAdjAeBjoGYMEIIAPDgAA +AEIgAIDKIGIAHQhQAAohwA/rcmQTBAAF2Gnb8QMv80olAADuDy/0VNhEIAMCz3KAAGQIUSBAgAGC +zyBiANAgYQABoiEIngAkgh0LQABkoqK4AaKa/wHZz3CAAJ0GBglv/SCoDwXP//HAiiBKBp4P7/MA +2Rj/1f+R//sEz//geADZnLnPcKAArC89oOB+4HjxwOHFANicuM9xoACsLxyhGoFRIICCGoEM8qq4 +GqEageUIHoDPdYAAZAgBhaC4DPCKuBqhGoHRCB+Az3WAAGQIAYWAuAGlANmbuc9woADQGzGguv92 +/wGFQiAAgKkGb/TKIGIA8cAuDk/0z3EAggEAz3CgAKwvPKDPcIAAZAgBgIPo4P8U8PD+Jgpv+2/Y +kOgg3s91oADIH9ClCthDHRgQANiWCy/0jbjRpef+UQZP9PHA4g1v9A/Zz3WAAMh+ABYAQAAWAEBV +JU4UAKX2Cy/0BG3JcIoNL/QilR6Vz3GAAIQI2mDYYAEQhQBAoSUNEQAChfC4yiHBD8oiwQfKIGEB +yiOBDwAA1wB0AiHzyiRhAO0FT/QIcs9wgADoNCWAI4Fggc9xoACwHzuB1bl5YRDhIQZv+kJ54Hjx +wN7/SgsP9M9wgACoChiIUwhRAM9xgADIfs9ygAAANQCCYIFgoACCHNtgqARpAaICgY24AqHPcIAA +eAgDoVUhQAQDohjYAqJVIcAFBaIBgV4MYAAEoofoANjh/0YMYAAG2NHA4H7gePHA4cXPdaAAyB8V +hc9xnwC4/9W4FqEeCgAAFRUAlpC4Hh0YkBYMYAAA2D0FT/TgePHA4cUB2M9xoADIHxOhGIGswUnA +GYHPdYAAjGhKwAiFEwgeAA8I3wHuDo/6lg0v8xPYi3GpcK4LL/Qk2s9wgACECCCAAomS6ASJIQge +AA3IBCCAD/7//wMNGhgwDciGuIy4j7iQuAvwDcgFIIAPAQAA/A0aGDANyKy4DRoYMKIOz/KLcDDZ +Nggv9JDaz3CfALj/Atk2oCjAgeDKIcIPyiLCB8ogYgHKI4IPAAAfAcokIgD8ACLzyiUiAF4LQACH +6ADYof9GC2AABthtBG/0rMDxwO4Lb/Qw2s9xnwC4/1ahGRoYMM91oADUBxodGJAfFQCWAN8B3gEa +GDAEEoUwTCUAh8ohwg/KIsIHyiBiAcojgg8AAIsBmAAi88okggMZFQKWA9ggHRiQFB2Ykw8VA5YA +FgBAABYAQAAWAUEAFgBBABYAQA8d2JBA4TB5CQgeBQLhMHkDaQQggA8AAPz/HwiFAN4LgAAo6M9w +oACwHx2A1bhFDgRwAAAAFA8VAJZA4B4dGJAdFQGWHh0YkK25HR1YkK4LgAAF6AoMgAAM8A3IBSCA +DwEAAPwNGhgwDcisuA0aGDDPcIAADAXgoADZkbnPcKAA0BsxoM9wgADcAhB4z3GgALRHSRkYgM9y +gAB0Y89wgAAQBUCgbyBDAFQZGID2Cu/2CBqYMy0Db/QA2OB4z3CAAAA1eQCP9+B48cDPcIAA6IAY +EIQAEQwRAQmADQheAa4JAAAQ8BkMUADPcIAA3IMMEIUATCXAgcwlYoIG9CoNz//RwOB+CiHAD+ty +BdhdB+/ybtvgePHAz3CAABg1IBAFAEwlgIDKIcYPyiLGB8ogZgHKI4YPAABHADAH5vLKJKYAz3CA +AERC8CBAAUB40cDgfvHALgpP9Ah1z3aAABg1iiBPCgYL7/MohgiGDw0FEIDlyiUCEAL0qKaKII8K +6grv86lxaQJP9OB4z3CAABg14H8IgOB48cCKIE8Lzgrv89rZ8gov8wbYANjq/9Lx8cDPcaAA0BsT +gRcIHgQA2JC4E6GKIA8Mogrv88XZiiAPDJoK7/PI2XYIj/e68eB48cAB2M9xgAAYNQOhz3CgACwg +A4AEoQKBgeC4D8H/qvHxwIogTwxmCu/zgNmKCi/zBtig8fHAbglP9N3/GQhQAAohwA/rcgXYktuK +JMMPQQbv8rhzz3WAABg1I4UChSEJUQAA2QkIUAAUjQboHgkgACalDPAjpQHYBqUI8IboAd5iDu// +xqXCpYUBT/TxwM9xgAAYNc9wgABMQioIL/Q42koIYAAA2NHA4H7gePHA8ghP9AAWAEDPcIAAXEQB +gBsIXwEKIcAP63IF2IXbiiTDD70F7/K4cwAWAEDPdYAAyH4ApcRtyXDuDu/zD9lVJU8U6XB+CC/0 +IpWeDs/zCBUFEFElAITKIcEPyiLBB8ogYQHKI4EPAACNAHQF4fLKJGEAz3GAAAA1AIFAhUCgAIEc +2kCoAoXBoeOhjbgCpc9wgACQCAOlGNgCoVUlwBUFoQGFpg8gAAShmOjPcIAA+GslkBUJcgCKII8L +Ignv857Z9gkAAAfwFgnv86PZggkAAG4PIAAN2IEAT/TxwBYIT/TPdoAAjGgIhqzBEwgeAA8I3wFW +Co/6/ggv8xPYi3HJcBYP7/Mk2gHYz3GgAMgfE6EYgQDdScAZgc93gAAYNUrABocw2UvAi3DGC+/z +kNqhtqimoaa8rqOnkg3v/6lwz3CAAPhrBZALCFIAqqetpwTwMgogAKlwZocB2c9ygACYCACCgePA +eYDjOGAAogHYIYLAeDhgAaLhBy/0rMDgePHAcg8P9M9wgAAYNcCAAN+Wv/5mHg+v+slwCHHPcIAA +UDUWCG/6/mbPdYAA+GsFlSWFCrjZYf4Or/oOIEAAmHDPcIAAaDXyDy/6iHHmDq/6yXCYcM9wgACA +Nd4PL/qIcc9wgAAYNcCgBYX+Zh5mBZUKuMIOr/oOIIADCHHPcIAAmDW2Dw/6VQcP9OB48cDmDg/0 +z3aAABg1oIYA35a//WWSDq/6qXAIcc9wgABANooPL/r9ZX4Or/qpcAhxz3CAAFg2dg8P+hUHL/Sg +pvHApg4P9M9woACwH7uAAN6WvgQljR/A/wAA3WUU5QAljx+AAAAAQg6v+qlwCHHPcIAAcDY2Dw/6 +Lg6v+thlCHHPcIAAiDYmDw/6Hg6v+ulwCHHPcIAAoDYSDw/6z3CAABg1rQYv9OCg8cA6Dg/0z3Cg +ALAf+4AA3Za9BCePH8D/AAC/ZxDnACeQH4AAAADaDa/66XAIcc9wgACwNc4OL/q/Z892gAD4awWW +JYYKuPlhtg2v+g4gQAAIcc9wgADINaoOD/qiDa/66XAIcc9wgADgNZoOL/q/ZwWGH2cFlgq4hg2v ++g4gwAMIcc9wgAD4NXoOL/oCdXINr/oKcAhxz3CAABA2Zg4P+s9xgAAYNQAZAAQFliWGCri5YU4N +r/oOIEAACHHPcIAAKDZCDg/62QUP9OB48cByDQ/0osGA4MohgQ+t3q3eB/IlgCOBIIECgAJ5Qg6v +84ogTw3PdoAAGDUBhgDdIQhRAIogTw0mDq/ziiEGBKGmSg7v8gbYAgvv/6lwTfAyC8//geAB2MB4 +LycHkBHyiiAPDfoNr/OKIcYHOgvP/wHY7gzv/wam0grv/6lwDcgFIIAPAQAA/A0aGDBGD4/yugrv +/wDY9g3v8gbYz3CAAPhrBZBDCFIACoYI2UHAC4ZAwItwugjv85TaiiCPDqINr/OKIcYPiiCPDpYN +r/Mrhoogjw6KDa/zKoaG78oKz/8B2Aemq6b1BC/0osDxwIoML/SKIA8Kag2v84ohRQL+CS/9AN7P +dYAAGDWN6Iogzw5ODa/ziiHFAwHYAaXJcLn/PvANyAQggA/+//8DDRoYMA3Ih7gNGhgwDciQuA0a +GDCSDo/yDg4P9y4N7/IG2CSFz3CgACwgA4DHcQAAABQieBcIhQ8AgAAAiiAPCvIMr/OKIYUIw6UO +Cu//wqWA4MwJ4f/KIGEAz3CAAPhrBZCA4MogiQ8AAEAAxA2J+0UED/TxwOHFCHUFgAOAQoUggIog +DwuuDK/zQnnPcIAA+GsFkAkIUgAP/wPwMf+pcMj/HQQP9OB48cCGCw/0OnAKIECQGnMKJQAhCiRA +IQojgCEeAC8A6HMKIcAP63IF2ErbSiRAAGEA7/IKJQACz3WAALg2AIUc2SCgAYUY2SCwanGEKQsK +ACGSf4AA6IBcEgEgAN5qoM93gACgCCGgCiHAhEAnAxPKIWIAMKgzGIID0ahioDEYAgIyGAIC27Ba +sKIP7/MM4CGFDNgSqQOBHwhfAgyJz3KAACQ4w7gceAhiz3KAAIiBCGIMqQ8LESDPcIAAFGgE8M9w +gAA0aAOlz3IAAEgRQLAY2kKlDQlQIIoiBQJAsArCherPcgEAuK1Ep7QSAiYhCh4AGtpAsUKlQJCH +ukCwEQgQIM9wgADQHASAMxkCACENECABgZi4AaEDgZ+4A6EAEgEgBBIAIAAfBBUhpwKnMghv96lw +pQIP9OB48cBaCg/0ocEIdlpxOnIac4h3Eg1v+6h1gODMJiKQCvLPcIAAGGyvoEIL7/ID2A3wQMXJ +cEpxKnIA25hzuHPYdwonAASh/3ECL/ShwPHAHgoP9M91gAAYbC+FAN6A4cohwQ/KIsEHyiBhAcoj +gQ8AAKYAyiSBA+AGofLKJcEAAdrPcIAAjGhgeUigz6XyCu/yA9hFAg/04HjxwM4JL/TocwolQIAa +AC8AyHEKIcAP63IF2IojhAGhBq/ySiRAAATFgOXKIcEPyiLBB8ogYQHKI4EPAAAIAcokIQB8BqHy +yiXBACMInkGKIM4Cagqv84ohhAPPcIAAjGiA2SigBMBAeDzwz3WAALg24YUQ3sC3wqWk38OF4LYN +CFEApNiMuAC2z3CAAKgKD5COuI+4AbYAhRzehCkLCsCgz3CAAESBMCBODgGFmb7BoIDhyiFiADCo +AN4zGIID0ahqoDEYQgEyGEIB27BasI4N7/MM4AGFCNkyqLYOL/epcFUBD/TPcIAAjGgogM9wnwC4 +/wDaNqAI2exwIKAD2c9woAAUBCWgAcjscQChz3CgANQLTaDgfuB4z3GAALQI4H8AoeB4z3CAALQI +4H8AgOB48cCeCC/0iiBPDwDdz3aAALgIegmv84ohyAWKIE8Pbgmv8yOGz3GArgwA7HAgoAHI7HEA +oUAmDxIF8CCJ7HAgqAHl+w3ykblnz3CgABQEA9pFoCCJz3CgAPwLLKipAA/08cDhxc91gAC4CKlw +Zg6v8wLZiiDPDxYJr/Nz2eH/iiDPDwoJr/MgjYogzw/+CK/zIZUAjTkIXgAZCJAACiHAD+tyBdh6 +20okQADlBK/yuHPPcaAAyB+wEQAAHqEQ2A6hJoXPcIAAJAsioFLwNQieAITgyiHCD8oiwgfKI4IP +AACGAAXY4fUA2c9wgACYBiCgAdnPcIAAnQbqCe/8IKg48CcI3gAB2YjgyiHCD8oiwgfKI4IPAACQ +AAXYx/XPcIAAmAYgoCTwNQgeAAIVBRENDdIDjCXDj8v2CiHAD+tyBdia200Er/JKJEAAz3GAACQL +AoEGpQDYAqHPcaAAyB+wEQAAHqEQ2A6hAdgEpakHz/OKIgQAz3GgAMgfT6GwGQAATqEQ2A6h3QKP +8uB48cDPcIAA5AoXkPf/H9jPcaAAyB8IuA6hf9iVuBIZGIDPcAEAwPwVGRiA0cDgfuB4iiAQAMkH +b/PU2eB48cDWDu/zA9jPdaAA1AcgHRiQAdgUHRiQGRUPlg8VAZbPdoAAuAgnpgAWAEAAFgBA8H8I +pgAWAEEStg8dWJBA4AqmBfAZFQ+W8H+KIFAAdg9v8+lxCobxDwSQ5QbP8+B48cB6Du/ziiBQAIom +/x9WD2/z6tkmCo/yDHHPdYAAbAQgpREOQBA+D2/ziiBQAMCFMwjfQc9wgABsBACAUyCAgerzLygB +AE4gggfPcYAAuAgC2AShz3CgABQESqBFodH/HPCqCo/2jCBCgcohwg/KIsIHyiBiAcojgg8AAPgA +yiRiAOQCovLKJcIAbP+2/wDZz3CAALgIJKBNBs/zA9jPcqAA1AcgGhiAAdgUGhiADxIBhgAWAEAA +FgBAABYAQAAWAEAPGliADxIAhgzgHhoYgB0SAYYeGhiAg7kdGliA4H7xwM9wgAC4CAWAz3GgANQH +GRoYMBoZGIAOEQCGHxEFhgkaGDABGlgxBMqc4Mohwg/KIsIHyiBiAcojgg8AALkBRAKi8sokYgDd +/y/YlbjPcaAA0BsQoc9wAQDA/BOhKfHxwDYNz/PPd4AAdGMCGtgzz3CAADRkBhoYMAHeCBqYM8lw +ev8A3c9wgAAMBaCgANmRuc9woADQGzGgz3CAANwCEHjPcaAAtEdJGRiAz3CAABAF4KBvIEMAVBkY +gMYOz/jPcIAABAUAiIDgjAsC/QjILwjeABnIz3GAAAhZCBqYMxR5samwqQPZz3CgABQEI6DPcYAA +uAgDgQHgA6EO8B0InwIKIcAP63IF2Iojhw6KJMMPdQGv8rhzyNhqDW/ziiGHD90Ez/PgePHA4cWp +wYt1qXDPcYAAhEIuDC/3JNoB2GDAAhwEMBnIDLiFIEgASMCeC2/4qXC5BO/zqcDxwDoM7/OKIJAA +Hg1v84ohBAvPdYAAuAgUFQUQAd5MJYCByiHBD8oiwQfKIGEByiOBDwAALQH0AKHyyiSBA5r/sf/j +/89woADUC9CgENjPcqAAyB/PcaAAsB8PogrwENjPcqAAyB/PcaAAsB8PogHeFRqYg0ASAwbhlWJ/ +/qIUoX4PT/Kg/89woADUC9Gg0wjewc9woAAUBAmAgOAMDwL5LgiP9owgQoHMIIKPAAD8AAzyCiHA +D+tyBdiKIwUESiRAAGkAr/K4c89yoADUCwDZMKKMIEKBEPTJ/s9wgAC4CACIGQgeAAohwA/rcgXY +iiNFBefxng0P9Az/z3GAALgIANihA+/zBKHxwIogEAEaDG/ziiGFDiz/z3CAALgIBIAa6ILgzCDi +gAzyCiHAD+tyBdiKIwYCiiTDD/EHb/K4c7D/iiAQAeILb/OKIcYCdg0P+QPwAf//A8//4HjxwKj+ +z3CgANAbgNkwoM9wgAC4CACIhiB/jJQPwf/bA8//4HjxwOHFz3WAAMiAAI0xCF8AIgpv/QbYz3Gn +ADBMFBEAhgOlFREAhgSlFhEAhgWlFxEAhgalGBEAhgelCfABjQfoANnPcKcAmEc6oAmNDwjQAEAl +ABMuDK/zFNnZAs/z4HjxwE4Kz/PPdoAAyIAAjqHBRCANByK9OnCGIfwnVgnv/AfYQSlPIRpwjO0K +IcAP63IF2IojzAOKJIMPEQdv8rhzCydAk8ohwg/KIsIHyiOCDwAAEgMF2PH1Dr2IvZW9QMXPcYAA +FHMAgYtyhiD+AyS4QCiDAwCCZngAoiCBwrkOuSV4AKIAwQDdQSmAA0EpwgPAuMC6BCGEDwEAAMAI +uAq6MLlFeMC5QCkCAwV6AI5BLIQDQSiDAUEoQQHAu8C5C7sJuWV5QSjDAQ27ZXlFeYC5z3KgAOwn +JqJALMEA5XnPcqsAoP86os9xoAC0D7yhIY7PcqcANET2GlgAJZZhlvNp9X8QvwUj0gP1GpgEZI7l +jlEgQID3GtgA+BrYA89zpwAUSEEpgiFYGwABV6PPcqAAgERwgs93pQCs/0YjAwVwogDCBCKCDyEA +AMEmulWnyiCCDwEA//8G9ADAEgpv+BThGKcgwIm4jrgZpwCOEwheAEAmABOuCq/zFNkD8ADdz3ag +APQHpKaaDE/yz3GAAMiAAYmF6ACJEwhfAAHZkLnPcKcAmEc8oAPYBKYDCB5Dz3GAAMiAAYmF6ACJ +FwhfAM9ypwCYR3AagAQIiYC4GqIAiXUIXgCpCB7D/QjewRINT/aMIAKDzCCCjwAA/AAM8gohwA/r +cgXYiiPOBEokQABNBW/yuHOMIAKDGPTPdYAAyICpcH4Ob/MD2QCNUSAAgMohwg/KIsIHyiOCDwAA +mAPKIGIB5fVb/wTwegoP9MYNb/OA2Abwvg1v84DYVv8A2s9xoAD0B0ShA9gKoQmhSaGyCO/8CnBF +AO/zocDgePHAz3KAALBOJJIA2ILhzCFigMogYQAvJgfwz3GAAMiAAIkP8kCSEQqRAYYgPg6FIAEB +BvCGID8FRSAACgCpCwgeAFX/AvA8/78Az//xwM9wgADIgM4Nb/MD2er/qwDP/wEFT/P9BE/z4H7g +eOB/ANjgfwHY4H8A2OB/AdjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4 +4H7geOB+4HjgfuB44H7geOB/AdjPcIAA+Ijgfs9wgADoiOB/D4DgeOB+4HjgfuB44H8A2OB+4Hjg +fuB44H7geOB+4HjgfuB44H7geOB+4HjxwOHFz3WAAOA2qXAiDW/zA9kAFYUQRCVAAYXgyiHBD8oi +wQfKIGEByiOBDwAATwC4A2HyyiRhAAGNCwgSAWO4Aa2yDE/zLQeP8+B48cCqDo/zGnHPdoAA4DYg +jo0JHgDPcYAA6AggiYDhzCAhoD7yDwhRAM9wgAAwc6GAAvAA3QcN1ROC7QDdz3GAADBzGImC6ITt +AN8E8KKBBN+KIBMBRg8v86lxiiBTAT4PL/Ppcc9wgACoChiIg+DMICKBzCDigcwgIoLMIGKCCPKK +IBMBFg8v84zZCvAKlhUNARALlhB3zCAhoAT0ANgh8AHYz3GgAMgfDaHPcIAA6AgBiOu2qrYEvxC4 +5X0FfYogEwHaDi/zo9mKIBMBzg4v86lxz3CgAMgffxhYgwHYMQaP8+B48cDKDY/zxv886CDdz3ag +AMgfsKYy2EMeGBAA2FYLb/ONuLGmsKYe2EMeGBAA2EYLb/ONuLGmfxYPloogEwFBLw0UxL1yDi/z +zdmKIBMBag4v8+lxiiATAV4OL/Opcc9xgADoCAGJAdoQdcIiigAVDXIQQKkA2A2mCQpRAATYAamx +BY/zz3CAAOA2AIgRCJ4Az3GgAMAdAIGAuACh4H7geM9wgADgNgCIEQieAM9xoADAHQCBoLgAoeB+ +AAAEAAAAAMAAAAAAAAAAAAAAAAAAAAIAAAAAAAAASAuAANwLgACAQ4AAEACAALgEgAAECMAQCgAT +ZEQFgIEAAMAWBAETYg9cACIKAABAAAYAcBwAAGEAABMkAAATJQAAwBfIIMAQcEXAEBAIwBD//1wz +AAATJAAAEyUECMARDxQVIgQAFSb7/zAyAAJYMAMAEyQYCMARHAjAEQ8UFSIBABUmBAAwMAACRXAC +AABhAQATJCwQwBEAABMkEEXAERgIwBEABFgwD3wTIggAzBEAABMlAAATJDRIxxEPexMiAQATMAQo +wBEPFBUiBAAVJsYgEyRAABMlBCjAEQ96EyIYKMARD00TIgQQxRECABMk8BzAEQEAEyTsHMARAAAT +JHAAEyUQHMARAAATJQAAEyTgHMARAQATJCQQwBEAAAAhAAATJQAAEyQPRQAiAFwAOQMAAGICYABi +AABYOFYAAGEkEMARAIATJDgcwBEPcxMiggETMAQowBEPdBMiAgITMAQowBEPdRMiQgITMAQowBEP +FBUiAQAVJg9wEyIBABMwBCjAEQ9yEyIIAMwRD0QAIgoAAEAAQABwDgAAYQAAEyUCABMk7BzAEQ92 +EyIYCMoRCQATQBwIyhEJABNAIAjKEQ94EyIEAMoRAAABJAAAASUGAABhD3YTIixIxxEPeBMiAADG +EQMAASQAAAElDxQVIgIAFSYPRQAiAFwAOSIAAGQAABMkAQATJTgcwBEPdxMi4BzAEQ8BEyIECMAR +DxQVIgEAFSYPAxMi//ATMhgowBEAAxM4//MTMhgowBEAAxM4GCjAEQMAEyQAABMlBAjAEQAAEyQ4 +RcARDwMTIv8/EzLw/xMzDxMCItg2gIEAAMAWAAITOBgowBHHIBMkQAATJQQowBEEAABhAABYOAAA +EyQBABMlOBzAEdA2gIEAAMAWCAATYgAAEyUDABMkVATFEX8CEyQEAMUR1DaAgQAAwBYIAMURAAAA +IRBDgIEAAMAWPATAEQwFgIEAAMAWBAEbYhAEwBADABskVATAESQEwBEIBMAQ0EKAgQAAwBcIBMAQ +sEKAgQAAwBcAABslAxwbYkAAGyQwHMARBQAAYRAFgIEAAMAWDxsZIggEoIE48MSAAAAbJAIAGyU4 +HMARAAAAIQwFgIEAAMAWTATAERAFgIEAAMAWDxsZIkgEoIE48MSAAAAbJAIAGyU4HMARAAAAIQAA +AIUMBYCBAADAFg8bBCIQBBtmDwEbaBQcwBAKABtABAAbbgMAAGEPHB0iAQAdJvkPAGFkDAAQAMAG +EQEABCf8AARkAAAbJAIAGyU4HMARAAAAIQAAGyVAABskMBzAEQAAACEPHB0iGAEdJhgAxxD4XYCB +AADAFyAAxxAAXoCBAADAFwAAACGgHYCBAgBcbhEAAGH4QcQQDxsJIgALCTkCAApiAwEKYgQCCmIA +AAlABAAAYQkACUACAABhCgAJQAAAAGECAAlBAAkaKAAAwBYBABsmAADAFwQAHSYBAAgn6QAIZAAA +ACEAAAAALAEAAAEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAABAAAABwAAAAAAAADAAJAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAACI6gAAhOoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAA8HCAAHhBAQAAAAAAAAAAAAAAAAAAAAAAAAAAABRxgAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAAAAAAAA +AAAAAAEAAAAAAAAAAAAAAAAAAAABAQECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAAAABgAIAAkAAAAHAAAAAAAAAAAAAAAAAAAAAgAA +AAIAAACDAAAAkgAAAOgAAAD3AAAATgEAAF0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAQAC +AAAAAwATACMAMgB/ACAAEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAABAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAjGiAAOShAQAAAAAAAAAAAAAAAAAAAAAAjGiAAIymAQAAAAAAAAAAAAAAAAAA +AAAAAAAAAIxogAAAAAAAAAAAAAEADwBkAAEAxAiAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAA8BwAAFQAAACgbgADICQAAyAkAAMgJAADICQAAyAkA +AMgJAADICQAAyAkAAMgJAADICQAAyAkAAMgJAADICQAAyAkAAMgJAADICQAAyAkAAMgJAADICQAA +yAkAAMgJAADICQAAyAkAAMgJAADICQAAyAkAAMgJAADICQAAyAkAAMgJAADICQAAwAoAAAAAAABw +BgEAyAkAABQIAADICQAAyAkAAMgJAABECAAACO4AAAhFAADICQAAyAkAAGQIAABkCAAAZAgAAGQI +AABkCAAAZAgAAGQIAADICQAAyAkAAMgJAADICQAAlAkAAMgJAADICQAAyAkAAMgJAADICQAAxAoA +AMgJAADICQAA+AcAAAMAAACIrAEAAgAAADwTAQAEAAAAWC8AABAAAABgmwEABgAAADykAQAHAAAA +HLcBAAsAAADQKwEADAAAAEwwAQANAAAAhDABABYAAAAoBgEACgAAABBFAQATAAAASEYAAA4AAAAs +VQAADwAAAEj9AAABAAAAeKABABEAAADUUwEAEgAAAKhKAQAFAAAA3FcAABQAAAC0bwAAFwAAAMAK +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJAAAFCQAABQkAAB8NAAAFCQA +ABQkAABAMAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAyBgAAGAaAABkGgAA +0BsAAFAcAADUGwAAFCQAABQkAABEPQAAbEEAAEhCAAAUJAAAFCQAABQkAABcOwAA+JoAAPSaAAD8 +mgAALDEAADwyAADMWQEAgDQAAPgyAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQk +AAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQA +ABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAABsNQAAFCQAABQkAAAUJAAA +FCQAABQkAABQNgAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAB4 +LwAAFCQAAJgvAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAAOxYAAAUJAAAFCQAABQk +AAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAANBDAQBgRwEAFCQAAHwsAQAUJAAAIC4B +AHwdAQAUJAAAFCQAAAxDAAAUJAAAFCQAABQkAAAUJAAAFCQAAAScAQB4mwEAFCQAABQkAAAUJAAA +xLMBABQkAAAUJAAAcN4AABS3AQAYtwEAFCQAAAC3AQAUJAAAFCQAABQkAAAUJAAA8KMBABQkAAAU +JAAAFCQAABQkAAAUJAAARB8AAEgfAAAUJAAAIE0BAKi3AQBMRgAAFCQAABQkAAAUJAAA8J4BABQk +AAAUJAAAMP4AAJRKAQAUJAAAFCQAABQkAACUUgEAxBgBABQkAAAUJAAAFCQAABQkAAAUJAAAFCQA +AIhdAQAUJAAAMLcBADS3AQBAtwEARLcBADi3AQA8twEASLcBAEy3AQAUJAAAFCQAABQkAAAUJAAA +FCQAABQkAAAUJAAAFCQAAJjeAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAXDgAABQkAAAU +JAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQk +AAAUJAAAFCQAANRbAQAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAAUJAAAFCQA +ABQkAAAUJAAAFCQAABQkAAAUJAAAFCQAABQkAAD8OAAAfDkAAAA6AABgOgAA5FMAADg6AAAUJAAA +FCQAABQkAAAUJAAAFCQAAPQ4AAD4OAAAFCQAABQkAAA8QwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOED +Dh7h4QMOHuHBAgoe4YEFDB7hAAAAAAAAAAAAAOEDDh7h4QMOHuHBAgYe4YEFDB7hwQIGHuGBBQwe +4cECBh7hgQUMHuHBAgYe4YEFDB7hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAA//////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBDQ0NDQ0NDQ0NDQ0NDQ0NDQMDAwMDAwMDAwMD +AwMDAwMAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQ0NDQ0NDQ0NDQ0NDQ0NDQ0DAwMD +AwMDAwMDAwMDAwMDAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEBAQENDQ0NDQ0NDQ0NDQ0N +DQ0NAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAAAAAAAAAAAAACRAgAAMcovAJECAAAxyi8AkQIAADHK +LwCRAgAAMcovAJECAAAxyi8AkQIAADHKLwCRAgAAMcovAJECAAAxyi8AQwEAADHKLwBDAQAAMcov +AEMBAAAxyi8AQwEAADHKLwBDAQAAMcovAEMBAAAxyi8AQwEAADHKLwBDAQAAMcovAEANAADeAwkA +AAAAAAAAAAAAAAAANN4AAAEAAADoGoAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgICAgICAgIABgAKAgICA +gOgagADoGoAApCCgADggoAABAAAA/P///wAAAAAAAAAACBuAAAgbgACoIKAAPCCgAAgAAADz//// +AAAAAAAAAAAoG4AAKBuAAKwgoABsIKAAMAAAAM////8AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAA +AAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAARP4AAAUAAAAoG4AAVAMBAAD/AwB0AwEAAP8FAFgE +AQAA/y0AfAQBAAD/PQA0BAEAAP8EABgEAQAA/yUAoAQBAAD/3QBcCwEASAwBALwMAQAMCAEATAcB +ALgNAQA8DgEAgA4BANAOAQAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAAAAAA +AAAAAAMAAAACAAAAAwAAAAMAAAADAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAnBQBAAoAAADo +GoAAAAAAAAAAAAAAAAAAKBUBAAoAAADoGoAAAAAAAAAAAAAAAAAAXBUBAAoAAADoGoAAAAAAAAAA +AAAAAAAA1BUBAAoAAADoGoAAAAAAAAAAAAAAAAAA9BYBAAoAAADoGoAAAAAAAAAAAAAAAAAAbBYB +AAoAAADoGoAAAAAAAAAAAAAAAAAAxBwBAAYAAADoGoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAEAAAAACAAAAAAKAAECcAAOgDAADoAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAFAzAQBYNAEAADcBAKw5AQAgPAEAhD8BAOg1AQAgBYAAVGiAABgAAAAUaIAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAIQgEABgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAA +AAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAAAE8AAA +CgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAA +AAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAA +AAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAAAE8AAACgAA +AOgagAAAAAAAAAAAAAAAAAAE8AAACgAAAOgagAAAAAAAAAAAAAAAAACkSAEACgAAAOgagAD///// +AAAAAP////8AAAAAAAAAAAAAAAAoSgEABQAAACgbgABkAGQAaQDcAMgAWgCqAL4AhgF9AD4AZABk +AGkA3ADIAFoAqgC+AIYBfQA+AAAAAAABAQAAAAAAAAABAgEBAAIBAAECAgIAAQEAAgECAQIAAgAB +AgP//wAAGAECALMAAgCFABAAhgAOAIcACgCIAAsAiQAPAIoAAACLAAcAjAAPAIUAEQCGAAwAhwAK +AIgACwCJAA8AigAAAIsABwCMAA8AhQASAIYACACHAAoAiAALAIkADwCKAAAAiwAHAIwADwCFABMA +hgAAAIcACgCIAAsAiQAPAIoAAACLAAcAjAAPAIUAAACmADcApwABAAsBNwAMAQEAnAH/ANUB/wDW +Af8AqAAiAA0BIgCnAYMAqAFZALgBBgDBAQEAAgBYAEsATABMAAcAZAAHACkDGABsAJQAdgAAACQD +EAAkAx8AswECALUBCwAMAwEAEQMBABUDAQAgAwEAJQMBACoDAQAvAwEA+/8AAP3/AAC5Ac8AuAEG +APz/AAC5Ad8A//8AAHIAAwB0AAMAbgADAHAAAwDXAAMA2QADANMAAwDVAAMAPQEDAD8BAwA5AQMA +OwEDANQBBgDQAVAAfgBpAOMAaQBJAWkAlAAAAJUAAACUAAEAlQABAJQAAgCVAAMAlAADAJUABwD6 +AAAA+QAAAPoAAQD5AAEA+gACAPkAAwD6AAMA+QAHAF8BAABhAQAAXwEBAGEBAQBfAQIAYQEDAF8B +AwBhAQcAeAAbAN0AGwBDARsAhQAAAIYAAACHAAYAhQABAIYAAQCHAAYAhQACAIYAAwCHAAYAhQAD +AIYABwCHAAYA6wAAAOoAAADsAAYA6wABAOoAAQDsAAYA6wACAOoAAwDsAAYA6wADAOoABwDsAAYA +UQEAAFABAABSAQYAUQEBAFABAQBSAQYAUQECAFABAwBSAQYAUQEDAFABBwBSAQYAfwB5AOQAeQBK +AXkAqQAQAKoAMwCrAAEADgEQAA8BMwAQAQEAdAEQAHUBMwB2AQEA/f8AAHkALQDeAC0ARAEtAPz/ +AAB5AGoA3gBqAEQBagD//wAApgA/AKcAAQALAT8ADAEBAHEBPwByAQEABAAIAP3/AACoAAAArAAC +AA0BAAARAQIA//8AAJwB/wCdAf8AngH/AJ8B/wDVAf8A1gH/ANcB/wB2AP8A2wD/AEEB/wAwAIAA ++/8AAAAAAAD4XAEADGgBAExzgABABQAAAAAAAPhcAQAUXgEAjHiAACABAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAB0bAEAkGoBAKx5gABUAAAAAAAAAPhcAQC8agEALHqAAFABAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAEAAAD4XAEAEGcBAKgngABQAQAAAAAAAHhsAQAsaQEA4AaAAAIAAAAAAAAA+FwB +AGhpAQDkBoAABAAAAAAAAABwbAEAFF4BAAB6gAAsAAAAAAAAAPhcAQDkaQEAAAAAAAAAAAAAAAAA ++FwBAKRpAQDoBoAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgACAAMABAAE +AAUABgAGAAcAIAAgACEAIgAiACMAJAAkACUAJgAmAEMARABEAEUARgBGAEcASABIAEkASgBKAEsA +TABMAE0ATgBOAE8AUABQAFEAbgBuAG8AcABwAHEAcgByAHMAdAB0AHUAdgB2AHcAeAB4AHgAeAB4 +AHgAeAB4AHgADwA/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQACAAMAAwAEAAUA +BQAGAAcABwAIAAkACQAKACMAIwAkACUAJQAmACcAJwAoACkAKQBGAEcARwBIAEkASQBmAGcAZwBo +AGkAaQBqAGsAawBsAG0AbQBuAG8AbwBwAHEAcQByAHMAcwB0AHUAdQB2AHcAdwB4AHgAeAB4AHgA +eAB4AHgADgA/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgACAAMABAAEAAUABgAG +AAcAIAAgACEAIgAiACMAJAAkACUAJgAmAEMARABEAEUARgBGAEcASABIAEkASgBKAEsATABMAE0A +TgBOAE8AUABQAFEAbgBuAG8AcABwAHEAcgByAHMAdAB0AHUAdgB2AHcAeAB4AHgAeAB4AHgAeAB4 +AHgADwBDAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQACAAMAAwAEAAUABQAGAAcABwAIAAkACQAKACMA +IwAkACUAJQAmACcAJwAoACkAKQBGAEcARwBIAEkASQBmAGcAZwBoAGkAaQBqAGsAawBsAG0AbQBu +AG8AbwBwAHEAcQByAHMAcwB0AHUAdQB2AHcAdwB4AHgAeAB4AHgAeAB4AHgAeAB4AHgAeAB4AHgA +CABDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgACAAMABAAEAAUABgAGAAcAIAAg +ACEAIgAiACMAJAAkACUAJgAmAEMARABEAEUARgBGAEcASABIAEkASgBKAEsATABMAE0ATgBOAE8A +UABQAFEAbgBuAG8AcABwAHEAcgByAHMAdAB0AHUAdgB2AHcAeAB4AHgAeAB4AHgAeAB4AHgADwBD +AAAAAAAAAAAAAAABAAEAAgADAAMABAAFAAUABgAHAAcACAAJAAkACgAjACMAJAAlACUAJgAnACcA +KAApACkARgBHAEcASABJAEkAZgBnAGcAaABpAGkAagBrAGsAbABtAG0AbgBvAG8AcABxAHEAcgBz +AHMAdAB1AHUAdgB3AHcAeAB4AHgAeAB4AHgAeAB4AHgAeAB4AHgAeAB4AHgAeAB4AHgABAA/AJhQ +AQAS0gAAAAAAAP//DwDUZQEAtgAAAAAAAAD/AAAA1GUBALcAAAAAAAAA/wAAANRlAQC4AAAAAAAA +AP8AAADUZQEAuQAAAAAAAAD/AAAA1GUBALoAAAAAAAAA/wAAANRlAQC7AAAAAAAAAP8AAADUZQEA +vQAAAAAAAAD/AAAA1GUBAL4AAAAAAAAA/wAAANRlAQC/AAAAAAAAAP8AAADUZQEAwAAAAAAAAAD/ +AAAA1GUBAMEAAAAAAAAA/wAAANRlAQDCAAAAAAAAAP8AAACYUAEAE9IAAAAAAAD//w8A1GUBABsB +AAAAAAAA/wAAANRlAQAcAQAAAAAAAP8AAADUZQEAHQEAAAAAAAD/AAAA1GUBAB4BAAAAAAAA/wAA +ANRlAQAfAQAAAAAAAP8AAADUZQEAIAEAAAAAAAD/AAAA1GUBACIBAAAAAAAA/wAAANRlAQAjAQAA +AAAAAP8AAADUZQEAJAEAAAAAAAD/AAAA1GUBACUBAAAAAAAA/wAAANRlAQAmAQAAAAAAAP8AAADU +ZQEAJwEAAAAAAAD/AAAAmFABABTSAAAAAAAA//8PANRlAQCCAQAAAAAAAP8AAADUZQEAgwEAAAAA +AAD/AAAA1GUBAIQBAAAAAAAA/wAAANRlAQCFAQAAAAAAAP8AAADUZQEAhgEAAAAAAAD/AAAA1GUB +AIcBAAAAAAAA/wAAANRlAQCJAQAAAAAAAP8AAADUZQEAigEAAAAAAAD/AAAA1GUBAIsBAAAAAAAA +/wAAANRlAQCMAQAAAAAAAP8AAADUZQEAjQEAAAAAAAD/AAAA1GUBAI4BAAAAAAAA/wAAAJhQAQAI +0gAAAAAAAP//AwDYUAEAAIIAAAAAAAD/AQAA2FABAAGCAAAAAAAA/wEAAJhQAQAJ0gAAAAAAAP// +AwDYUAEAAoIAAAAAAAD/AQAA2FABAAOCAAAAAAAA/wEAAJhQAQAK0gAAAAAAAP//AwDYUAEABIIA +AAAAAAD/AQAA2FABAAWCAAAAAAAA/wEAAJhQAQAG0gAAAAAAAP8BAACYUAEAB9IAAAAAAAD/AwAA +mFABAAbSAAAJAAAAAP4DAJhQAQAH0gAACgAAAAD8DwCYUAEABtIAABIAAAAAAPwHmFABAAfSAAAU +AAAAAADwP5hQAQAV0gAAAAAAAP8DAACYUAEADNIAAAAAAAD/AQAAmFABABXSAAAKAAAAAPwPAJhQ +AQAM0gAACQAAAAD+AwCYUAEAFdIAABQAAAAAAPA/mFABAAzSAAASAAAAAAD8BwAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzSDdIR0hDSAtIB0gPSG9IL0gCABdIS0hPSFNIE +QwbSB9IE0gkQcNK1ABoBgQEFAAQABgAIAAkACgALAAwAgwCSAOgA9wBOAV0BDwAuAAAAbAAAAHQA +AACAAAAAjAAAAJ0AAAAHAAAABAAAAAgAAAAQAAAAQAAAAIAAAAAgAAAAAAAAAAkAAAASAAAAAAAA +AAoAAAAUAAAA/////wAAAAAtAQAA3QEAAFoCAAC6AgAACgMAAE0DAACHAwAAugMAAOgDAAARBAAA +NwQAAFkEAAB6BAAAmAQAALQEAADOBAAA5wQAAP4EAAAVBQAAKgUAAD4FAABRBQAAZAUAAHUFAACG +BQAAlwUAAKcFAAC2BQAAxQUAANMFAADhBQAA7gUAAPsFAAAIBgAAFAYAACAGAAArBgAANwYAAEIG +AABMBgAAVwYAAGEGAABrBgAAdQYAAH4GAACIBgAAkQYAAJoGAACiBgAAqwYAALQGAAC8BgAAxAYA +AMwGAADUBgAA2wYAAOMGAADqBgAA8gYAAPkGAAAABwAABwcAAA4HAAAUBwAAGwcAACIHAAAoBwAA +LgcAADUHAAA7BwAAQQcAAEcHAABNBwAAUwcAAFgHAABeBwAAZAcAAGkHAABvBwAAdAcAAHkHAAB/ +BwAAhAcAAIkHAACOBwAAkwcAAJgHAACdBwAAogcAAKcHAACrBwAAsAcAALUHAAC5BwAAvgcAAMIH +AADHBwAAywcAANAHAADUBwAA2AcAANwHAADhBwAA5QcAAOkHAADtBwAA8QcAAPUHAAD5BwAA/QcA +AAEIAAAFCAAACAgAAAwIAAAQCAAAFAgAABcIAAAbCAAAHwgAACIIAAAmCAAAKQgAAC0IAAAwCAAA +NAgAADcIAAA7CAAAPggAAEEIAABFCAAASAgAAEsIAABPCAAAUggAAFUIAABYCAAAWwgAAF8IAABi +CAAAZQgAAGgIAABrCAAAbggAAHEIAAB0CAAAdwgAAHoIAAB9CAAAgAgAAIIIAACFCAAAiAgAAIsI +AACOCAAAkQgAAJMIAACWCAAAmQgAAAAAAAAAAAAACgAAAA3SEdIQ0gLSAdID0hvSC9IAgAXSEtIT +0hTSBEMI0gnSCtIc0gbSB9Jw0gAAAQAAAAAAAAAAAAAAAAAAAAMAAAAEAAAAAwAAAAAAAAADAAAA +AAAAAAAAAAAAAAAAAAAAAP8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtQAaAYEBBAAP +AIMA6ABOAZIA9wBdAQYACAAJAAoACwAMAAUAAAAAAAAALAABAAAAAAAAAAAAAAAAAAAAAAAAAAIA +AgACAAAA3wAAABkBAABiAQAAvgEAADICAADDAgAAewMAAGIEAACEBQAA8gYAAL4IAAACCwAAAQAA +AAIAAAAAAAAAC9IO0g3SCNIJ0grSEtIT0hTSEdIQ0gLSAdID0gCABdIEQxvSHNIE0gBFMNIx0gAA +AAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAcAAAAAAAAAAwAAAAQAAAAD +AAAAAAAAAP8DAAADAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAC1ABoBgQEFAAQA +DwAQAAoACwAMAE4AAAAAAAAAAAAAACwAAQAAAAIAAgACAAAAAAAAAAAAAQABAAIAAgACAAMAAwAE +AAQABQAFAAYABgAHAAcACAAIAAkACQAKAAoACwALAAwADAANAA0ADgAOAA8AAAAAAAAAAAAAAAAA +tKEBAAYAAADoGoAAIAWAAFRogAAYAAAAFGiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcqgEABAAAAOga +gAAAAAAAAAAAAAAAAAAwqQEABAAAAOgagAAAAAAAAAAAAAAAAADQqgEABgAAAOgagAAAAAAAAAAA +AAAAAAAwqQEABAAAAOgagAAAAAAAAAAAAAAAAAAcqgEABAAAAOgagAAAAAAAAAAAAAAAAAAwqQEA +BAAAAOgagAAAAAAAAAAAAAAAAAAcqgEABAAAAOgagAAAAAAAAAAAAAAAAAAwqQEABAAAAOgagAAA +AAAAAAAAAAAAAADQqgEABgAAAOgagAAAAAAAAAAAAAAAAAAwqQEABAAAAOgagAAAAAAAAAAAAAAA +AAAcqgEABAAAAOgagAAAAAAAAAAAAAAAAADQqgEABgAAAOgagAAAAAAAAAAAAAAAAAAcqgEABAAA +AOgagAAAAAAAAAAAAAAAAAAcqgEABAAAAOgagAAAAAAAAAAAAAAAAADQqgEABgAAAOgagAAgBYAA +VGiAABgAAAAUaIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQFAAAAAAAAAAAAAAAAAAAAAAD/ +AP8AAAAAAAAEFQcVFRULFRUVFRUVFQ8AAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAEA +AAAPAD8AAQAAAA8APwABAAAADwA/AAIAAAAPAD8AAQAAAAAAAAABAAAAAgAAAAMAAAAAAAAABAAA +AAIAAAAFAAAAAAAAAB8nAaUAPDg0MCwoJCAcGBQQDAgEAAwIBAA8ODQwLCgkIBwYFBAMCAQCABQO +GgAAACAAAAACAAACAAAAAAEBAAECAQEBAQEBAQEBAQECAgICAgICAgMDAwMDAwMDBAQEBAQEBAQB +AgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAQECAQICA3// +Bw8fPwEDAQMPBwEHDx8/f///BQAHAgMEBgZ00UUX6KKLLg0PBQcJCwEDChQ3blVVVQFLaC8BVVVV +BeM4jgOqqqoCcRzHAaqqqgrHcRwHKAAoADAALAAsACgAPAA0ACgAKAA0ADAALAAsAEQAPABAADwA +jABsAFgASAD0ALAALAAsADwANAAwACwAVABEAFQAVABsAGAAXABUAIwAeAA6AQIB1QDfANoAogB1 +AH8AagEaAdkA6AAKAboAeQCIAIoFKgM5AagBigXKAtkASAHKAUoB4gD5AMoB6gCCAJkAZuYAAJ3Y +iZ1O7MRONEiDNCd2YicapEEaEzuxExEYgREP/MAPTuzETid2YicapEEaEzuxEw3SIA2JndgJCIzA +CAd+4Ac0SIM0GqRBGhEYgREN0iANCIzACAZpkAawstUFBVRABSd2YicTO7ETDdIgDYmd2AkGaZAG +xE7sBARGYAQDP/ADqqqqqhqkQRoTO7ETD/zADxEYgREN0iANCqiAChM7sRMP/MAPD/zADw3SIA0L +tEALC7RAC4md2AkN0iANCqiACgqogAoIjMAIB3iABwd4gAcGaZAGD/zADw3SIA0LtEALDdIgDQu0 +QAuJndgJCIzACImd2AkIjMAIB37gBwd+4AfBLCkHCqiACgiMwAgHeIAHCIzACAd4gAcGaZAGsLLV +BQZpkAawstUFBVRABQVUQAXWHcYEDQAaACcANABOAGgAdQCCABoANABOAGgAnADQAOoABAEnAE4A +dQCcAOoAOAFfAYYBNABoAJwA0AA4AaAB1AEIAgwATgBoAIIAdQCcAMMAaACCAIIAnAC2ALYA0ACc +AMMAwwDqABEBEQE4AYIAnAC2AJwAtgDQAOoA0ADqAAQBBAEeAcMA6gARAeoAEQE4AV8BOAFfAYYB +hgGtAQAAMAAAADYAAAAMAAAAEgAAABgAAAAkAAAABgAAAAkAAAAAAAAAAAAAABggFBQODhQUBQYB +AgMEAAAAAQECAQICAwQMDAgEDAQEQAAAAIAAAAAAAQAAAAIAAEAAAAAABAAAQAAAAEAAAAAQERIT +FBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uL0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltc +XV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8tAA8gAPBhAAAAAAAAAAAAAAECBAQA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAxNjozNjo1NwAAAAABAgECAwQAAAUGBwgJCgAAAAUGAAIEAAUABQAAAAUHAQMEAAUBBQAAQCNA +JSEhISFAQEBAQAUEBAEBQEBAQAUFQEAMDEANDAwBAQEFQEAFBQAEAARAQAAEQEBABUBAQEBABUBA +QAUFBQEBAQFABQUFAQUBAUAFBQVABUAFBQUFBWwAcAR0CHQMAAQEBgAAAAAAAAAAZAAAAACQAQAK +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAAAAAAAAAAAAAAAAA/wAA +AAAAAAAAAAAAAAAAAAAAAAABAAAAEAAAAAAAAAABAAAAAQAAAAAAAAD/AAAA/wAAAAAAAAAAAAAA +BKsBAAAAAAAABAAAZAAAAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH +BwcHBwcHBwcHBwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgICAgIBAQEBAQAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMRgEAVEYBAFxGAQCw +RgEAuEYBAMBGAQAACiVDxE56lQAHEyRUKwAAAAQOCR0tNwAABA4JHSw7AAEQAAEAAAACgAABQgYC +EAACIAAAA8AAAUMGAxAAAsAAAAPAAAFDBgQQAAJAAAACgAABRAYFEQAAQAAAA8AAAUUGBhEAAOAA +AAPAAAFFBgcRAAEAAAACgAABRgYIEQACIAAAA8AAAUcGCREAAsAAAAPAAAFHBgoRAAJAAAACgAAB +SAYLEgAAQAAAA8AAAUkGDBIAAOAAAAPAAAFJBg0SAAEAAAACgAABSgYOEgACAAAAAoAAAUwGAAAH +AAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcA +AAAHAAAAAwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAAwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAIhYA +AIAAAAMAAAFZACQWAAEAAAADAAABWgAmFgACAAAABAAAAVoAKBYAAgAAAAMAAAFbACoWAAKAAAAD +AAABXAAsFwAAAAAABAAAAVwALhcAAIAAAAMAAAFdADAXAAEAAAADAAABXgA0FwACAAAAAwAAAV8A +NhcAAoAAAAMAAAFgADgYAAAAAAAEAAABYAA8GAABAAAAAwAAAWIAPhgAAgAAAAQAAAFiAEAYAAIA +AAADAAABYwBkGwACAAAAAwAAAW8BZhsAAoAAAAMAAAFwAWgcAAAAAAAEAAABcAFsHAABAAAAAwAA +AXIBbhwAAgAAAAQAAAFyAXAcAAIAAAADAAABcwJ0HQAAAAAABAAAAXQCdh0AAIAAAAMAAAF1Angd +AAEAAAADAAABdgJ8HQACAAAAAwAAAXcDfh0AAoAAAAMAAAF4A4AeAAAAAAAEAAABeAOEHgABAAAA +AwAAAXoDhh4AAgAAAAQAAAF6BIgeAAIAAAADAAABewSMHwAAAAAABAAAAXwEkR8AAUAAAAMAAAF+ +BJUfAAMAAAAEAAABfwWXHwACwAAAAwAAAYAFmSAAAEAAAAMAAAGBBZ0gAAFAAAADAAABggWfIAAB +wAAAAwAAAYMFoSAAAwAAAAQAAAGDBaUhAABAAAADAAABhQUAAAAAAAAAAAAAJKUBADilAQAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAD/////AAAAAAAAAAABAAAAAAAAAGAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA +AAEAAAAAAAAAAAAAAAUFBQUFBQUFAAAAAIANAAAAIAAAgA0AAIANAAAAIAAAgA0AAAAGAAAABAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAEAAAALAEAAAcAAAAAAAAACAAAAAQAAAC8 +C4AACQAAAAQAAAAQBgAACgAAAAQAAAAoC4AACwAAAAQAAADcC4AADAAAAAQAAAAQBgAADQAAAAQA +AABIC4AADwAAAAQAAAASAAAA +==== diff --git a/sys/contrib/dev/iwn/iwlwifi-105-6-18.168.6.1.fw.uu b/sys/contrib/dev/iwn/iwlwifi-105-6-18.168.6.1.fw.uu new file mode 100644 index 0000000..c623f8c --- /dev/null +++ b/sys/contrib/dev/iwn/iwlwifi-105-6-18.168.6.1.fw.uu @@ -0,0 +1,12141 @@ +Copyright (c) 2006-2012, Intel Corporation. +All rights reserved. + +Redistribution. Redistribution and use in binary form, without +modification, are permitted provided that the following conditions are +met: + +* Redistributions must reproduce the above copyright notice and the + following disclaimer in the documentation and/or other materials + provided with the distribution. +* Neither the name of Intel Corporation nor the names of its suppliers + may be used to endorse or promote products derived from this software + without specific prior written permission. +* No reverse engineering, decompilation, or disassembly of this software + is permitted. + +Limited patent license. Intel Corporation grants a world-wide, +royalty-free, non-exclusive license under patents it now or hereafter +owns or controls to make, have made, use, import, offer to sell and +sell ("Utilize") this software, but solely to the extent that any +such patent is necessary to Utilize the software alone, or in +combination with an operating system licensed under an approved Open +Source license as listed by the Open Source Initiative at +http://opensource.org/licenses. The patent license shall not apply to +any other combinations which include this software. No hardware per +se is licensed hereunder. + +DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. +begin-base64 644 iwlwifi-105-6-18.168.6.1.fw +AAAAAElXTAoxMDUgZncgdjE4LjE2OC42LjEgYnVpbGQgMAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAQaoEgAAAAABAAAAAAAAAAEAAABweQIAICCADwAAQABpIAAAaSBAAGkg +AABpIEAAICCADwAA6ABpIAAAaSBAAGkgAABpIEAAICCADwEAiAppIAAAaSBAAGkgAABKIAAASiEA +AEoiAABKIwAASiQAAEolAABKJgAASicAAEogABBKIQAQSiIAEEojABBKJAAQSiUAEEomABBKJwAQ +SiAAIEohACBKIgAgSiMAIEokACBKJQAgSiYAIEonACBKIAAwSiEAMAokgD+BAABAQSycMEAsnDBC +JBw0CiKAP4AACHMKIwA3BgvAB0omAHBpIEAASiYAcEomAHBKJgBwSiYAcAAWAHCAAGgcQHggIECH +AAAAAAAAAAAAAPwciLb8HEi2/BwItvwcyLX8HIi1/BxItfwcCLX8HMi0/ByItPwcSLT8HAi0/BzI +s/wciLP8HEiz4H7geATcON018OB4BNw03TPw4HgE3DDdMfDgeATcLN0v8OB4BNwo3S3w4HgE3CTd +K/DgeATcIN0p8OB4BNwc3Sfw4HgE3BjdJfDgeATcFN0j8OB4BNwQ3SHw4HgE3AzdH/DgeATcCN0c +8OB4BNwE3RnwNBQaMDAUGTAsFBgwKBQXMCQUFjAgFBUwHBQUMBgUEzAUFBIwEBQRMAwUEDACxwHG +sCRNM7AkHzPgfuB44HjgeOB44HjgeAokgPAFIEQA4CDBB0Qk/oBBKsQAhAACAC8kAvFCIQEBQiAD +AeggogQEEQQCBBEFAgQRBgIEEQcCBBsIAQQbSAEEG4gBBBvIASwAJQBEIj6BPAAiAEQi/IBAIcEA +4CDBB0AjwwCoIIABARGEAgEbCgEgIMAHBBEEAgQRBQIEGwgB1Afh/wQbSAFEIvyABBEEAskH7/8E +GwgBQiFBAEIgQwCoIIABARGEAgEbCgEgIMAHz3GgAKwvGIGauBihmQUgEwXY4HjPcaAArC8YgbO4 +urgYoYUFIBNk2AoiQIAA2e4AAQAvJgDwSiZAAE4ABgBPACAAiiX/D+B4CiJAgADZzgABAGwAJAAv +JgDwXAAFACsINQhKJkAACHEA2AIhvoDgIMUHQnkB4AIhvoDgIMUHQnnrB+//AeAvLQEAQCVFAAIm +fPEAACAAAChAAeggYgMvIACALyFLAAIhvoDAIIYBwiGGAOB+EQAgAEogABBKIEAQDiJCAC8gCxLO +IEWAiiX/DwgABQAvLQEAQCVFAAImfPEAACAAAChAAUomQADoICIDLyAAgC8hSwACIb6AwCCGAcIh +hgBKJgAAQiD+kM4gggFEIH6QziGCAeB+KQAAAOB4/ByIsfwcSLH8HAix4cPhwuHB4cAHwBwcwDHh +wOB/AcAKJgDwiiC/D8ogZADgfy8gAwDgf4og/w/hxQh1EfDgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeGG9jCX/n+314H/BxeB48cDhxc9wgABEHk2Az3WAALidIIW3uri6BCGBDwMAAAAH +uUV5LaBWD+ASANgAhc9xgADgw1EggIJMic9wgABQ2jJqNnnHcYAAENdggVZ4QYAF8pW7YKGrugTw +tbtgoYu6QaALjaO4FQXv/wutosHxwJIMz/9Fwc91gABEHieFMHAI9DCVFBQOMTB2BPRZHYIQ0BUB +FjBwDvTPcYAAUCE8kRQUDTEwdQb0z3GAAKghWamA4gz0z3WAAOAHwY2A5gDZyiBBACXyIa2O4gT0 +Adgh8EEoDQIHfUEoAQSnec93gADgB6CPUyVFEUwlAITGuY32CiHAD+tyz3AAAM0bn9t1AiABiiSD +D1ElgJEG8gDYDNxbBM//z3aAANDZFiZNEaeNoK/JdRYlTREApRQUADFGrcdxgACQ1gK1AIkHrQAZ +QgEAG0IBxPHgePHAtgvP/wjIz3KgAMgfDhoYgAnIDxoYgArIEBoYgAsSATYCyCR4ERoYgAzIz3GA +AKg6LRoYgACBAeAAocO4jeAp9AvIf9kKuSR4LygBAE4gggcA2A8ggAAEIQGAQiKNAhnyCyNAwBf0 +z3CgAIgg8CBQA892gAAoNgCGEHXPd4AALDYG9ACHEnBwCUEHoKYAHwAUiQPP/+B48cDhxQHZz3Cg +ALAfOaDPcYAApBwIgQCArMFJwAyBAIDPcYAALCHPdYAAEKlKwAqBobgKoQiF4LgJ8lEgwIEH9FYJ +QAZiCqACGNiLcalwkg/gDyTaz3CAANwHIIACiYDgEvQEiVEgAIAO8gvIBCCAD/7//wMLGhgwC8iG +uIy4j7iQuAvwC8gFIIAPAQAA/AsaGDALyKy4CxoYMNIOz/+LcDDZkNoe21oKYA8Yu89wnwC4/wLZ +NqAowIHgyiHCD8oiwgfKIIIPAADqHMojgg8AAPwAyiQiALwAIgHKJSIAygpABoDgB/T+DOAAANjK +D2APBtipAu//rMDPcYAAnHLgfwhh4HjxwD4JQAbPcYAA9BfwIQAAQHjPcKAA0BuA2lCgz3CAAHwc +AIBRIACCANkG8s9wnwC4/z2g0cDgfvHA6gnv/w/Zz3WAAAjgABYAQAAWAEBVJU4UAKUyDWASBG3J +cO4MYBIilR6Vz3GAANwH2mDYYAEQhQBMJQCAQKET9AKF8LjKIcEPyiLBB8oggQ8AAOkcyiOBDwAA +wQD4B+EAyiRhAPEBz//geIDhyiRNcOB46CAtAs9xoABQDCWBARhSAOB+4HjxwFoJz//PcIAARB4D +gBiIpcGE4EogACAM9AohwA/rcoogjA1k2wokAASlB+AAuHPPd4AApBwkhyCBZgigB4ogBw6KIJkF +WgigB2fZz3WAADSpiiDZBkoIoAcsjYog2QY+CKAHLY2KINkGNgigBy+NiiDZBioIoAcujYog2QYi +CKAHMI2KINkGFgigBzGNz3aAADg0z3CAAOhaOgkgESQeABTPcIAABFsqCQARz3CAAKxbIgkAEc9w +gADIWxYJABEtjYDhBPJsjTBzjPbSD2AHiiCHDYoghw3GD2AHLI3I8ASHQIDPcIAACJtgoCGgQqDP +cIAAeN8IkBBxlPbPcIAAeN8B2iiwz3eAAFjBz3CAAEDBTKdDgFBxARgCBML3I6AQjYDgyiBiAAOm +EY2A4BbygOMU9M9wgABEHgOACYBRIICADPKeD2ACB9gB2AGmz3CgACwgEIAApoogyQNCD2AHo9mK +IIkDz3GAAAibMg9gByKBAYbPcYAACJsggYDgyiBiABi4BXkDhgoiAICKIIkDyiJiABC6Cg9gB0V5 +z3CAALAwAICB4A30z3CAAHjfz3EAABAnRgnv/wWAEHgC8ADYz3GAAOjAB7EDhoHgDBkEBDr0AIGC +4Mwg4oAE9AHYAKFMFoAQgeAw9M9woAAsIPCAz3ABACRCQMAB2EHACBwANBHYQ8AA2Iy4RMAA2BDZ +BNoIc5hwuHAAJ4cfAAAAfTYOYAXYcIogygR2DmAHANmKIMoDbg5gBwDZSxaAEAHgD3hLHgIQDI2A +4AX0AYaA4AgIwQXPcIAAWFt6D8AQAdnPcIAA3BQgoH4OYAIG2FEHr/+lwOB4osHxwOYOr/+YckXB +QSgBAgd5QSgCBCd6xrrPdYAAkNZJZee5XWUT9BQUDjHPc4AA0NlocjZ64ILxcAX04pLRdwfyJ4rn +uadq9fMA2CjwxoqA5gf0gN/PcIAA4AfhqM93gACYHgWPEHYE9IDYBa8K8M93gACoIRmPEHYE9IDY +Ga/GijZ7AByAAweKh7kArc9wgADgB0CIIKgB2EerDNy3Bo//4HihwfHAAxICN9dyAAAAQAHawiKK +ABe6x3IADgAAg7rsc0Cj7HIAogIM4AQocNHA4H+hwOB4peAf8gn2g+AV8oTgF/KF4Bv04H8B2L3g +D/IG9q3gFfTgfwLYzOAP8owgQ4cN9OB/BtjgfwDY4H8D2OB/BNjgfwXY4H8H2AjY4H7gePHA4cWK +IFIO/gxgB7TZz3WAANAuqXBAJYEbagrgDy7aAdgdBq//YR0CEOB48cCSDY//guAIdY33CiHAD+ty +/diLuHPbSiQAAO0D4AC4c893gADQLjeHACWQH4AAJC8wdQX0DBCAIIDgkvLSD6AIBdg6cIogEg6S +DGAHqXFELb4bACdAHkCQIZAA3gi6RXnPcqQAuD2bGlgAIpAMGIIjyhpYACOQt6fLGlgAJJDEGlgA +JZDGGlgAJpDHGlgAJ5DCGlgAKJDDGlgAKZDFGlgACpCjGhgAz3CAAAQqIIBgeclwjOAa8s9wgAAE +KiCAYHnJcJDgEvLPcIAABCoggGB5yXCR4Aryz3CAAAQqIIBgeclwkuAD9ADdz3CAAEQeA4AIgM9x +pAC0RVEgAIAQ8kQtvhsAJ0AebJBLkHt7ZXpTGZiADZBUGRiABvBTGZiDVBmYg0Qtvhsndw6XVhkY +gA+XWBkYgBCXVRkYgBGXVxkYgBKXWhkYgBOXXBkYgBSXWRkYgBWXWxkYgLYLoAgqcJEEj//xwFIK +7//hxcoJwATPcIAARB4DgBiIgeAu9M9xgAAI4M9ygADYXQCCYIFgoACCHNtgqARpAaLPcIAAYAgD +oVUhQAQDohjYAqJVIcAFBaIBgQDdWhlEAwSiAoGtuF4MIAYCoYDgEPSSDqAAqXBeCWAPBtgK8GYJ +ABOA4AbyPgoAEwYPwBIpBI//huDxwADYD/TPcIAAUKkqCu//BtnPcYAA8KkAgYK4AKEB2NHA4H7g +eIPg8cAA2An0z3CAAEipAgrv/wPZAdjRwOB+4HjxwIHg4cUA2An0z3CAAEupAd3iCe//qXGpcMkD +j//gePHAluDhxQDYjPfPdYAAuJ2pcMIJ7/8E2QuNg7gLrQHYoQOP//HAmuDhxQDYjPfPdYAAuJ0E +bZ4J7/8E2QuNgrgLrQHYfQOP//HApMGQ4ADZyiBCABP0i3B6Ce//ENkAFAAxhODMIGKBCPTPcIAA +VMMfgPW4AvJMcAHYpMDRwOB+8cDGCo//CHfPcIAARB4DgBiIhOAacUnyhOcA3YwAJQDKIEUDz3aA +ADSpQCYAEyYJ7/8E2S6OsK5TIQAAEa5BKMAgoLkwcGIAJQACIEIAY7/xclYABgCA4g7yz3GgANAP +EBEAhmG6WGAQGRiAJREAhg94A/APjgDZUyCCIA8hgQAkeC8mB/DPcZ8AuP8QrhiBzyDiB9Ag4QcY +oRiBnrgYoRiBvrgYoQHYgQKP/+HE/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwcyLH8HAiy +/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDhxPHAz3CgANAbFIDPcYAAhAYEIICPz1EE4QChEfL2 +uC8pAQAF8i8pgQ9AAAAAz3CAAGgp8CBAAEB47g2P/9HAwcRrJMAQwcRrJIAQwcSfdAQUCzQEFAo0 +BBQJNAQUCDQEFAc0BBQGNAQUBTQEFAQ0wcPBwsHBwcDBxEUsfhAKJkB+wcRrJIAUwcQgIECH4HiM +IFyCAdjgf8IgCwDxwEYJr/9KJEAAz3WAAEQeFSUDEACDQCUOFdFwwiQCAfAlDRHIFQUWRCW+gQny +CiHAD+tyjtiNuHkHoAB028gQDQalecgYWACggwbZRnnIFQAWJHjIHRgQAIPIEAAGhiB/jpgOwRJN +AY//4HjxwNYIr/+KIAwJz3WAAOAGJIUGCEAHBIWA4EX0z3aAAEisExYClgDfhCoICQAhgH+AAEyk +AqUkiAHbgOHrpWylIfIdHtiTDBAFAAQlgQ/A/wAAQSkEBs9xgAB43xQRBgAFLj4BACGEfz8A//8E +JEEBHh5YkCCQjCGChgHZwiFOACql56UkgM92gACEqMC5KrbPdoAAwCQorkCuAohkpQGuH/AEhYHg +HfSuD4AJANgEpQKFJIiA4RP0J4Uc4DZ4JIjPcIAAcCEHiBBxAdnAec9wgAC8JCCgAtgC8AHYA6Vh +AK//AdjxwPIPb/+KIAwKo8HPdYAA4AYkhR4PIAcA3gSFgOAo9OoLQAAB2ASlAoUEiIDgcAIBAM9w +gAC8JACAgOBgAgIAz3CAAKQcEIDPcoAAqKgAgCOCGWHPcIAArCQAgDhgbgggEQKigOA4AgEAfvAE +hYLgQvQKhYDgEPQMFQQQEBUFEAohwA/rcs9wAACKDNUFoACKI44LIoVHhUAhAAdWeEaIYMJGiAEc +gjBGiAIcgjBHiGHCR4gFHIIwB4gGHAIwiiBTAXIOIAeoEQEAAoWLcZIOIA+oEAAAz3CAAKQcEIAg +gM9wgADAJCGgcg+gAMWlA9gEpdbwBIWD4Dr0QoUnhUAiAAc2eAWIUSBAgRPyz3GAAKQcA5Iwgc9z +gADAJCCBYYMKuGJ5MHAF9wnYC6WO8AWFgOAN9ASKgOCy8s9wgACoqIoP4BACgIDgqvIFhYDgBvIF +2AulAdgJ8M9wgAC8JACAgOCe9ADYfgrAB5rwBIWB4G/0yg5AAyKFR4VAIQAHVnhFiOC6G/KDukWo +z3KAAGQ7yYLPc4AASKwVG5iD+YLFgv5mFhuYg/iCxIL+ZhcbmIPDgleCXmYYG5iDBYhRIECAK/J6 +DcAQgOAQ9AohwA8ChetyHBUFEAQQhADPcAAAiwyBBKAAiiMQAGoN4BAC2PoM4BAI2CKFBImC4Ar0 +AdgApQDYDqXiDOAQWtgihQSJgeAD9AHYAaUHhRzhFnkFiYYg/4zKIIIPAAAwQywMogTKISIAAoUn +hRzgNngFiIYg/ocE8gLYBKUs8ATYBKUo8CSFhOEB2CT0D6XPd4AApBwQhyCAz3CAAMAkIaDKDCAH +iiAMCs9wgADAJAzZddoe21IN4A4YuwSHz3GAALQkAIDmCGABIIEGpcSlBNgDpQHYvQVv/6PA8cBS +DW//iiCMCc91gADgBiSFfgwABwSFgOBA9CKFR4VAIQAHVnhEiM9wgADYBgCQEHIB3g70z3CAANoG +QJDPcIAAhKgKkBByBPTEpQDYUfAEiYDgH/LPcIAAvCQAgIDgGfTPcIAAqKgjgM9wgACwJACAzg2g +BjhggOAN9IogTA0ODCAHiiFNB7YI4AcA2AHYL/DEpQHYLfAEhYHgK/QChc9ygABEHiOCZIBooSOC +ZYAc4GmhJ4U2eCSIA4IA3jSwAtgE2UoL7//Jcs9zgACEqEKFB4VAIgEHFnkKkySJRIJ2DGANyXPE +pQPYA6UB2NEET/8MFQQQEBUFEAohwA/rcs9wAACJDLkCoACKIw4B4HjxwD4MT//PdoAA4AYEhoDg +ocE79CSGagsgB4ogjAoB389wgAC8JOCgANgPpgCmAaaKIJMBSgsgB4ohWQUC3alwFgvgBOlxz3CA +AKwGAIAmgJ4RAAamuJ4ZGACpcADZogrv/wTaUg5gEqlwz3CAAEQeI4BIgTSRUyIAAM4LYA3pc6Sm +6XCL8ASGguAz9CSG8gogB4ogjArPcYAA2AaKIIwM3gogByCRz3GAANoGiiDMDM4KIAcgkQKGBIiA +4BfyCYaA4BX0z3KAAKioBoIlgg4ggw8HACChMHNH9wfYC6YB2AymCaYD8DhgBaID2DLwBIaD4BD0 +JIaKCiAHiiCMCgvIBCCAD////wMLGhgwBNgi8ASGhOAg9CSGZgogB4ogjApTIMBAz3GAAEReLg8g +AAChz3CAACyoOoDPcIAAaKaEKQgJMCBADlEgQIAF2MogoQEEpiTwBIaF4AHfHfTPdYAALKgahQTZ +mdoe20DAi3CuCuAOGLsahemmhCgICQAhgH+AADymK4ChuSugBtgEpgDYBfAEhobgBvIB2A0Db/+h +wAbYA6YA2Nbx8cCWCk//z3WAAOAGBIWA4KXBDfQkhcIJIAeKIIwIAoUEiIDgGPQC2ASlBIWB4FX0 +BYWA4EX0z3CAAKQcBIDPcYAA/F8AgPIJ4BAggYDgNPQA2Djwz3CAAKQcBIAA3sWlz3GAALAkAICu +DSABIIHPcYAA/F8B3wTaAKHPcKAALCBAEAcAz3AAADh9QMAF2EHAQsdDxkTGyXAG2clzmHa4dgAn +hw8AAAB94gggBdh25KXpcDHwZg/gBAXYBNgC8AXYgOAB2gP0Adgl8CmFgeEQ8kylC6UM8ASFguAc +9CSF+gggB4ogjAgJhYHgBPQB2A/wgODr9QKFKgjgBAOACHHPcIAAsFp6CoAQANiuDwAH3fEA2O0B +b/+lwPHAfglv/4ogTAnPdYAA4AYkha4IIAelwQSFgOCq9AKFR4UkgFZ4z3KAAHAhBCGBDwAGAACA +4QHZZ4ogEI4AwHlwdgn0z3eAAISo6pfBivF2A/IA3gXwxorRcf31Ad6A5s9xgAC8JMChFfTPcYAA +2AYgkTBzD/TPcYAA2gYgkWGKMHMJ9M9xgADcBiCJRoowcgPyANkC8AHZgOFk8hwQBADPcIAAqKgM +GAABz3CAAAibBBAFAM9wgAB43wWABSh+AUApgHKQcMoizgfKII4PAACIDMojjg8AAAEDFAduAMoh +zg/PcIAAsCQAgIYJoAaAcIDgBfSKDIAPUPALyAQggA////8DCxoYMM9wgADkXwCIAN6A4MWlCvTP +cKAALCAQgMdwAAAAfRKlSBUHEM9wAAD8fEDABdhBwAHfQsdDxkTG6XAG2QTaANuYc7hzJg/gBNhz +z3CAAORfwKjkpelwH/AA2M9xgADkXwCpAtkjpRfwBIWB4AHeEvQFhYDgHPTPcIAAqKgjgM9wgACw +JACA4gigBjhggOAG8gHYTQBv/6XAz3CAAORfwKhaDeAEBdgA2ASlovEF2Aul5g0gB8lwANnPcIAA +5F8gqOjx4HjxwLIPD//PdoAA4AYEhoDgePQChgSIgOAU8s9wgAC8JACAgOAO9M9wgACoqF4I4BAC +gIDgBvJuC6AHANhpAwAAz3CAAKQcEIBHhiCAz3CAAMAkAYACeQKGVngHgBBxhvcB2ASmQQMAAACG +gOAM8lEjQMAK8gLZz3CgANAbM6AqDqAQHtjPdoAApBwEhs91gADgBgCAvg6gECaFgOAIAwEABIbP +cYAAtCQAgIoKIAEggQalAoUnhRzgNngFiIYg/4wJ8s9wAAAwQ89xgADcJEoNQAQChSeFHOA2eAWI +USBAgMQCAQAAhYDgCPLPcKAALCAGgIDgsAICAAINQASpAgAABIaB4Jb0JIbqDeAGiiBMCs9wgACk +HDCAIIHaDeAGiiBMCgKGJ4Yc4DZ4BRCGAADaUSYAgE+mQfLPc4AAwCTPd4AAZDsYhySHz3WAAEis +GWEXFQCWWKtcFwQQDBcFEAAlBQEYFQSWAnkCJQUBFRUAliQXBBACJASAFhUNlgWHonjKJYEQA/IB +3birgOEO8kAsjwDxcYT3TyWAEAbwgOAG8k8lQBAPfRirQSnAADhgsHBD94K9uKtRJkCALvIAhoDg +DfLPcaAALCAmgQ6GInjPcYAAwCQFoUCmBfABhoDgA/JBphoMQAQKDYAQguAR8ut1/gyAEAwWBBC4 +cM9wAACMDAohwA+pch0EYACKIxMLBg2gEADYAoYnhhzgNngFiIYg/4wF8gLYBKa+8ATYBKa88ASG +guAL9M9wAAAwQ89xgADcJNYLQAQE2ASmBIaE4K/0JIaiDOAGiiBMCs9wgACkHBCAIIDPcIAAwCRA +IA0HN6CCDOAGiiCMDSKGHBYEEEAhAAcWIAABBYhRIACAHfIA2kokwHBIc6ggwAHwJcAQAeMaYgPf +SiRAcQDbqCDAAfAlwBMB5xtjUHPH989ygADAJBiKgrgYqgDdz3eAAKiopacMkUAkQgAQckemR/eH +EQAGUSBAgAbyAdi6CKAHDKZc8KoKIAcLhgvIBCCAD////wMLGhgwLgxgCaumiiBMDeYL4AaKIZQN +B4YihhZ5iiBMDdIL4AYngQLYA6YChs9ygAC8JCSIgOEP9CeGHOA2eM9xgABwISeJBIgwcAHYwHgA +oinwIIKA4QXyAdgDpiPwJ4Y2eBwQBADPcIAACJsEEAUAz3CAAHjfBYAMHwARBSh+AUApgHKQcMoi +zgfKII4PAACNDMojjg8AAE4FiAJuAMohzg+kpnUEL/8B2AwWBBAQFgUQCiHAD+tyz3AAAI4MZQJg +AIoj1QXgePHAz3CAALwkAICA4B3yz3CAAOgpAICA4Bv0MgzADoDgCPQLyAUggA8AAAA8CxoYMGYM +wA6A4An0C8gFIIAPAAAA1AsaGDALyJC4CxoYMN4JgAbRwOB+4HjxwJILD/8Idc92oAA4LgeGz3EA +AAQqqLgHprYKYAcN2IDlAN/kCqISyiAiBM91gAAkKkUVARYHhiV4B6aKIBUMkgrgBoohzQ2KIBUM +hgrgBkUVARbPcIAAjCEskM9wgABEHh6QEHELyEUd2BMK8gUggA8AAADUCxoYMAvIkLgG8AUggA8B +AAD8CxoYME4PD/8AhbC4WgigEgClgODgD0ISWQMP//HAz3CAAJASD4CA4A/yz3KfALj/HaLPcYAA +fBwEgQHgs7i1uLi4BKEWonoOgACD4BH0z3GAABCpiiCVB/IJ4AYogc9wgACoXBoLQBDGCOAABdjP +cIAAfBwAgO+4BvIA2c9wnwC4/z2g0cDgfvHAz3CAAJASD4CA4A/yz3KfALj/HaLPcYAAfBwEgQHg +s7i1uLi4BKEWog4OgACH4BH0z3GAABCpiiCVB4YJ4AYogc9wgACoXK4KQBBaCOAABtjPcIAAfBwA +gO+4BvIA2c9wnwC4/z2g0cDgfvHAz3CAAJASD4CA4A/yz3KfALj/HaLPcYAAfBwEgQHgs7i1uLi4 +BKEWoqINgACE4BH0z3GAABCpiiDVBxoJ4AYogc9wgACoXEIKQBDuD6AAAtjPcIAAfBwAgO+4BvIA +2c9wnwC4/z2g0cDgfvHAz3CAAJASD4CA4A/yz3KfALj/HaLPcYAAfBwEgQHgs7i1uLi4BKEWojYN +gACI4BH0z3GAABCpiiDVB64I4AYogc9wgACoXNYJQBCCD6AAAdjPcIAAfBwAgO+4BvIA2c9wnwC4 +/z2g0cDgfvHAz3CAAJASD4CA4A/yz3KfALj/HaLPcYAAfBwEgQHgs7i1uLi4BKEWonXYUgjgBooh +hQ0+C2AABNgKJQCAyiHCD8oiwgfKIIIPAADfDsojgg8AAHkBWAciAMokYgDPcIAAfBwAgO+4BvIA +2c9wnwC4/z2g0cDgfuHFAdvPcoAAAAZ+suB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgGuEUgzQDPcKAA7CemoAqAANsAsX6y4H/B +xeB48cCKIMoGmg+gBgDZRgkAA2YMABIOCgASgNnPcKAA0BswoNHA4H7gePHAKggP/xpwAd8AEBIB +FPBadRLwFSDAI6CQAhARAQHn13UAAPv/8H909gwigK8AAP//CfLPcAAA+/9ScOz1SQAP/892gACU +HACGAeCB4ACmCfQB2c9woADIHDGg8g4gEihwBr2BvUApACSleM9xoADsJwahAIZCIECAAKbc9c9x +oADIHADYEaHW8eB48cDPcIAAjC0AgIHgyiHCD8oiwgfKIIIPAACvE8ojgg8AAPMByiQiAPAFIgDK +JQIBGggAANHA4H7xwJ4KgBG6DIAO0cDgfuB48cBCD8/+z3CAAEQeA4AogM9wgAC8qsC5NngkgACA +CrkEIYEPDwAA/Mm4JXjPcacAFEgNoXIL4Aehwfpwz3GAAJQcAIEB4IHgAKEJ9AHYz3GgAMgcEaEm +DgASi3FCDu//QtjPcAgAhxDPd6AA7CcGpwLZANg6cAogQKTaccogYiAPeS8lACRKIwAgFWkQuIG4 +h7iMuAanSiQAIYp1CiLAJGG9QChAIUAvgiFYYBUgTgOYdYAkgg3HdoAA+KoCli8kCAFALIEBgbkc +eBC4JXgGpyKWwLm4eQUhwAQvIwggA5aYdYAkQg8vJAgBHHhALIEBgbkQuCV4BqcDlsC4uHgFIIAE +LyIIIIog2AeaDaAGqXGKINgHjg2gBqpxIpaKINgHgg2gBjx5I5aKINgHdg2gBjx5QiRUIEwkAKBo +B83/QCsAJAUggA8AAAIvBqdAKgAkBSCADwAAwjAGp0ImQSCA4RQH7f9AIUAgABQAMRC4gbiHuIy4 +BqfPcIAAlBwAgM9xgACUHEIgQIAAoQf0z3GgAMgcANgRofUF7/6hwPHAANiNuPoOIA0GGhgwDMyG +IP+KCPLPcIAAIDYAiIDggA6CBNHA4H7PcQMAQA3PcKAAqCAtoM9xgABcCECBAWoAoc9woAA4LgWA +BCCAD8AAAADXcMAAAAAK8kjYz3GfALj/GqFboWnYGLgZoc9ygAAwVwaCA4AggMdxAACIEzEGIBBI +cAhyz3OAAExXBoMDgCCAz3CAAKQcBIAAgNW4GWEQ4WhwCQYgEEJ54HjxwAhxz3CAACArSIjPcIAA +sipEKj4LMiBCDue6CfLGugq6z3CAAIxc2g0gEFlh0cDgfuB48cDhxc91gADgXAaFA4AggM9wgAAg +K2iISohEKz4LACGAf4AAnCpVeEyQqXAKuqINIBBZYYoglQruC6AGIoUhBc/+4HjPcIAA2CpckM9z +gADEXCKDaHAKunUFIBBZYeB48cDhxc9wgAAgK0iIKojPdYAA4FxEKj4LACGAf4AAnCo1eEyQIoWp +cAq6Rg0gEFlhiiCVCpILoAYihcUEz/7gePHAOgzP/s9xgAA0ZCGBo8FCwc9xgABEHhUhEAAAEAAg +wBAOBoDmLyiBA04gjQdY8hJtFngAIJIPgAAQ1wYSgCDPcYAA0NkWeQCBIpGO5QgcRDDKIGEABvKL +cgYNL/8CwYDgN/IA2M9xgAB8B0CBDyBAAy8hCiAEIYCgAKEG9IDicAxiCMogIgiveEINoAQQ2QDf +BBrEI4ohCAAAGkAgqXDpcSoIYAcP2gAQAiDAEgAGBCBABMAaGADPcIAAUNq2eOCg4aDPcIAAcNa0 +eOCwECZOky8ogQNOII0HrPW5A+/+o8DgePHA4cUIdQTwzgsAEDIMIBCpcIDg+vXFA8/+4HijwULC +CRSAMIHgAdjAeBC4AeDgf6PA4HijweB/o8DgePHAJgvP/s92gAAwCAAWBRBMJUCCyiHGD8oixgfK +IIYPAACGJ8ojhg8AAGMAaAEmAMokpgDPcIAAkBIKgIDgEPLPcZ8AuP8doc9wgAB8HESAAeKzurW6 +uLpEoFahz3eAAExeAIahhgi4IIcFfTB1CfIQuYogSwXyCaAGpXmgpyCGz3CAAGxv8CBAAEB4gODr +889wgAB8HACAUSCAggbyANnPcJ8AuP89oOUCz/6iweHFQsFBKAICB3pBKAEER3nPcoAAkNbGuSpi +57oS9AgUAzHPdYAA0NmpcVZ5QIFQcAX0QpFwcgbyR4nnuvfzgNgD8AaJwcXgf6LA8cDPcoAAGtcy +aDZ5MWKiwUDBQcCLcAjZntoe2+4JYA4Yu6LA0cDgfuB+4HjxwAjIlbgIGhgwCcibuAkaGDALyIq4 +jbiQuAsaGDDPcIAARB4DgBiIgeAM9AvIz3EAAFAsrLgLGhgwBgkgBw/Y0cDgfvHA4cUIdT6Iz3CA +ALATQIBAJQAUA7k1eVlhNg/gDgramg/v/6lwEQLP/uB48cClwUHAQsEMHAAxEBxAMc9xgAB8ljQZ +wA8wGQAPLBnADigZgA4kGUAOz3CAAHyWIBhAC89wgAB8lhwYAAvPcIAAfJYYGMAKz3CAAHyWFBiA +Cs9wgAB8lhAYwAjPcIAAfJYMGIAIz3CAAHyWCBhACM9xgAAAloAZAAh8GcAHeBmAB3QZQAdwGQAH +bBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAESBmABEQZQARAGQAE76HOoa2hjKEs +GcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAAA9gZAABqIMAC1BkAAGoggALQGQAA +aiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAAuBkAAGogAAC0GQAAaiCAAcwZAABA +2J+4z3GfALj/HaHPcKD+AAAWoVMjwAQFIIAPsP4AABahGIFTJ801UyXENVMmxTWUuBihQMMBwALB +17oMFAYwqXMCDmAGEBQHMLYNYA4A2M9xoADIOy6BRg9gBn3YQg7AA89wAACt3u4IAAEI2ADZzgjg +Bpm5kQQAD+B48cDmD4/+z3KAAEQlgOHPdYAA2F8O8gCiAIWA4BP0Sg9gAQ/YpghgCAjYAdgApQvw +AN7AovoNYAEP2FYIYAgI2MClEQDP/uB4z3GAAEgpAIEc2s9zgADgBkCgQoNVIsAJAaGgEgAAjbig +GgAAz3CAAIAIpBoAAJwSAAFngwShVSJADQOhQCIAB3Z4BYig4Az0z3CAANgGAJBIdIAkRBMArB7b +A/AY22KhVSJADXhgBaHBAGAOKHDgePHAKg+P/s9wgACQEgOAgOAP8s9ynwC4/x2iz3GAAHwcBIEB +4LO4tbi4uAShFqLPcIAAhAZAgM92gAAID6CGBCKDDw8AAOAEI4EPAQAAABJpZHgHfaCmmHUEIo4P +AAAAQM91gAAED+CFA75kfj15x3/gpQQkDQAEIoIPAAAAgAYjQANFeQK55H4EI4MPAgAAAMZ4ZHkm +eC8oAQBOIEEEhuENGlgwB/LPcIAABMIOkIDgKPLPcIAAQAcAiM9ygABEHvAiAgC/EgIGUyJCgBr0 +z3KAALRohuEEuABiEvTPcoAAFML0IgIAgOIM8s9ygADQPSOCDRoYMAHhI6IF8BBxG/IocM9zoAAU +BAqjz3KAAFwHQIqB4gDZBfRJg7jigvcB2YDhAd0J9M9xoACIIBV5oKEU8AbY2/EuD+AMBhpYMzYI +AAaA4Ar0ANmRuc9woADQGzGg1g5gEKlwOQaP/vHAzg2v/jDaz3GfALj/VqENGhgwz3GgANQHGhkY +gB8RAIYB3QEaGDAEEoUwTCUAh8ohwg/KIsIHyiCCDwAA6xzKI4IPAABpAfQD4v/KJEIDGREChgPY +IBkYgBQZWIMPEQ6GABYAQAAWAEAAFgNBABYAQQAWD0APGZiD9L9WIwACEHgE8gLgEHgD4AQggA8A +APz/EHIPEQCGQOAeGRiAHREChhv3rboeGRiAHRmYgCYJAAaA4AXyigmv/wDYEvALyAUggA8BAAD8 +CxoYMAvIrLgLGhgwBvCNuh4ZGIAdGZiAJg7gDAYaWDNNBa/+ANjgePHA4cXPcIAAhAaggHXYBCWN +Hw8AAOAKDGAGiiGFCS8tQRPyDu//TiVAFAolAIAO8gohwA/rcs9wAADeDoojxQoNA+//TiVEFH/Y +CrjPcaAA0BsToX/YEKH9BI/+8cB6DI/+CHbsiCiWz3CAAKQGsm8oc4Yj8w+2fUIrEQLHdYAAENdg +he27CHIC8kRo67mKIMMvBPQeFpAQDY5RIACApPLjuT3067sV8v/YB61KJABxANmoIIADKGIAIYMP +gAD43vZ7BKsoYgHhL3kAq13wTCEAoZD2CiHAD+tyz3AAAC0liiMLBEokQABlAu//CiVABO65B40y +IkIEACGBL4AA+N72eQnyRKkE2QApQQQleAetPfBAqQ8gQARj8EwgAKSW9owgw6/KIcIPyiLCB8og +gg8AAC4lyiOCDwAA5ALKJGIADALi/8olAgTaCe//yXAIlu64BfICjgmtA/ABjgitAIXruBjyANpH +rUokAHHPcYAA+N6oIMACOGL2eAQYAgQAGAIEAeJPegGOCK0CjgmtLPBMIQChyiHKD8ogig8AAC8l +yiOKDwAAAQM8B+r/yiLKBwiWACGBL4AA+N7uuAeN9nkJ8gQZAgQE2QApQQQmeAet3fEAGQIEANkP +IUEEJngHrQGOCK1RA4/+8cD2Co/+z3OAALQHYIMA3s91nwC4//2FeWHPc4AAiAbgo92lz3OgAFAM +YIPHcwAAAEAie827cHDE91EjAMD0889xgACIBmCBz3GfALj/faFRIwDAyiAiAB70geIb9M9yoADQ +DxASAYaA4NP3z3WAAMgUn3BjhaggAAMCjSUSD4bBuNNo2H8B4AKt53tjpRAaWIAB2MkCj/7xwF4K +j/7PcIAAkBIPgKzBgOAA3w/yz3KfALj/HaLPcYAAfBwEgQHgs7i1uLi4BKEWos9xgAAUJBmBz3WA +ABCpobgZoQKVIZUQuAV5AhxEMDC5BBxEMCiFAtrPcKAAsB9IwVmgz3KAAKQcCYIAgEnADYIAgErA +KglgBoog1QPPcIAA3AcggIog1QMWCWAGIokIheC4HPJRIMCBGvTPdYAARB4AhcQQAAbPdoAAZDtR +IECBB/QeCAAFAdjcHgAQAYUYiEEeGBAeCWABGNjPcIAAICsoiM9wgACwKkQpPgs0IEAOUSAAgcog +AQfKISEMyiKBDwAAkADKI6EHQAkhDsArIQbPcIAAfBwAgO+4BfLPcJ8AuP/9oLEBr/6swPHA9gkg +AAHYz3CAACQqIIDruQ/yz3CAAEQeAIDEEAAGUSBAgQXyUSGAggTYAvIC2DYPAADRwOB+8cAKCY/+ +USCAwaXBgA4iBMogogALyJC4CxoYMDYNr/4A3c9wgACoXCaAI4EggYy9wgngD7lhANnPdoAAJCr8 +HkAQz3CgACwg8IDPcAAAQB5AwALYQcAB2ELAQ8FEwQXZBNoA25hzuHPYc5YPIAQAJ0cTAIaLuACm ++QCv/qXA4HjxwIoIj/5RIIDBpcEADiIEyiCiAAvIkLgLGhgwtgyv/gDdz3CAAKhcJoAjgSCBjL1C +CeAPuWEB2s92gAAkKvwegBAA2c9woAAsIPCAz3AAABgfQMAC2EHAQsJDwUTBKHAF2QTaCHOYcLhw +2HASDyAEACdHEwCGq7gApnkAr/6lwPHADgiP/s91gAAkKgCF67gF8g4MwAWA4AryC8gFIIAPAAAA +PAsaGDAqDI/+z3OgADguB4PDuI/gD/IcEwQACiHAD+tyz3AAAMEbiiMEAC0Gr/9KJQAAz3aAAIwh +CI6J4AfyiOAR9ACFUSAAgg30ogvABYDgCfLPcIAA4FwGgAOAAIBKCsAAmgvABYDgCvLPcIAAqFzq +D4APlg0gAADYCfAIjongCfQAhVEggIAF9ADYBgggCIy4xQdP/uB48cA+D0/+enCB4AHdwiVBE4Hg +AdjPd4AARB4gh8B4yBEOBiGHRCa+kcgRAwYE9EQjvoES8gohwA/rckArDQTPcAAAyxuKI0cMCiTA +BHEFr/8FJYUTz3GAAIwhXpcskVBxB/TPcoAAzLNBglBxGvIiCgAA6gkgAKlwqgkAAPAnQBPEEAEG +qXAlucC5igjgAADajghAEAvIkLgLGhgw+gqP/m4KoBEB2CIJ4AoA2BoJ4AoC2M92oADAL6kWAJar +FgGWqhYClgV5rBYAlgDdrRYDlgV6rhYAlgV7z3APAAD4BCEBgAQiEAAEIxEAWnUX8i8qQQBOIoAH +z3KgAAwt8CICAFEiAIIA2g8iAgAE9EV9BPAFIpIgBiGBgOv1z3CAAIwhLJAelxBxD/TPcIAAJCoA +gAQgvo8AADgQBfRGD4AFgOAo9EwjQKAL9KUWAZZPIgAhhrgGeaUeWJAP8M9wgACMISyQHpcQcQny +pRYAlkUlQREmeKUeGJBMI0CgCfLPcIAAjCEskB6XEHEE8j4N4BEF2EwjQKAL9KUWAJZFJUERBSEB +BCV4pR4YkDrwTyIAIYa4z3GAABwrSIEFIEAEBXoA2AihAYfAEAMGgOMvKMEATiCNByHyjuXKJCJ0 +yiAiAOggIgXybQAggQ+AABDX9n8S4e9hjCfDn8ohIgDPIcIDxiJCAAHgECNDgy8owQBOII0H4vWl +FgCWBXqlHpiQeQVP/vHALg1P/s9xoAAsIOaBsIHPdoAAHCsFhgIlAhAEhhByRPdCeAahBvAK2Aah +6g2ABuSmZQVv/qWm8cDhxc91gABEHhV9AIXPcYAA8KmAIAMAbgqgDgPaAIXPcYAAbDuAIAMDXgqg +DoPaPQVP/vHA4cXPdYAARB4VfSCFz3KAAPCpSHCAIQMAOgqgDgPaIIXPcIAAbDuAIQMDJgqgDoPa +CQVP/uB48cChwc9wgAAMZACAtgzgBkDAi3AE2b3aHttODOANGLuhwNHA4H7geM9wgAAcK+B/BoDg +eM9wgAAIK+B+z3CAAJwH4H8AgOB48cBCDG/+ANlKJIBw4HioIAAKz3WAACAscNwCJQITRCk+Bydy +z3eAAExdAN7AogXbZKLPcwIAjCBjogHbZaLmokIlAh4AIkAOwKAG2kSgz3ICACAhQ6BloOagAeFN +BE/+8cDiC0/+z3CAAJwH4IDPcIAAkBIPgIDg730Q8s9xnwC4/x2hz3CAAHwcRIAB4rO6tbq4ukSg +VqHPdoAASV4AjhB1CPKKIBUD2gogBqlx4K7PcIAAzGfwIEADQHjPcIAAfBwAgO+4B/IA2c9wnwC4 +/z2g2QNP/uB48cAeDO//ANjPcIAAJCoAgOC4BvLuuAf0CNgD8AHYcgkAANHA4H7gePHAQgtP/qXB +USCAwQLduAgiBMogQgMLyJC4CxoYMG4Pb/4A389wgACoXCaAI4EggYy/+gugD/lhz3aAACQq/B5A +EwDZz3CgACwgQBAHAM9wAACsHkDAQcVCwUPBRMEB2AXZBNoA25hzuHPYcMoJIAQAJ8cDAIaAuACm +MQNv/qXA8cDCCk/+USCAwaXBOAgiBMogogALyJC4CxoYMO4Ob/4A3c9wgACoXCaAI4EggYy9egug +D7lhA9jPdoAAJCr8HgAQANnPcKAALCDwgM9wAACEH0DAAthBwELBQ8FEwShwBdkE2ghzmHC4cEom +QABKCSAEACdHEwCGoLgApq0Cb/6lwOB48cBuC6AF4cWA4AvyC8gFIIAPAAAA1AsaGDBuDk/+z3WA +ACQqAIXnuAbyp7gApYYMYA8A2M9wgACMIQiIieAI8ojgDvQAhVEgAIIK9M9wgADgXAaAA4AAgKYM +gABZAk/+8cDiCU/+CHbPdYAAnAeKIJUCDgkgBiCFiiDVAsClAgkgBslx2g3P/yUCT/7xwAHZz3CA +ABwrIKDPc4AAxFwGgwOAIIDPcIAApBwFgECAaHDVunYKoA9ZYc9wgADcByCABImguASp0cDgfuB4 +z3OAAMRcBoMDgCCAz3CAAKQcBYBAgGhw1bpBAqAPWWEocgkAIAAA2eHF4cZAKQ0CJX1ALQMUiOKl +ewh1kPdTJX6QBvIBHVIQYbr78UEqjgDBukImTpAEHdAQ/fWA4gryLySJcOB4qCCAAQEdUhDgeMHG +4H/BxeB48cDhxc91gAAkpCCNjCHDjwrygOAG8s9wgABEWVIJgA//2ACtz3CAAMyjANk1oM9wgADE +FCCgz3GAAOgpAIGiuIoLoAoAoQDY0giv/whxJQFP/uB48cDhxQDdz3CAADgIoKDPcIAA6CmgoM9w +gADEqKl0nbAwvJ6wEglgBKlwqXAGCmAJqXHtAE/+4HjxwGoIT/7PcIAAkBICgAcSDzaA4A0SDjYB +EhA2D/LPcp8AuP8dos9xgAB8HASBAeCzuLW4uLgEoRaiBtgNGhgwz3WgABQECqUJhYDgJ/ID2BCl +BKXPcIAACOKCCiAQAxoYMJLZA8iQuaAYQADuCyAEANgJhYDgD/IoFQQQJBUFEB7YCiHAD+tyjLhV +Bm//iiMEBgca2DMBGhg0z3CAAHwcyqUAgFEggIANGpgzBvLPcZ8AuP8A2B2hFQBP/vHA4cUIdfoN +4AAU2M9wgABEHgCAxBAABiW4LgggAcC4PgjgBwTYNgrgDalwqghADd4NAA2KIAsAug7gBalx7QcP +/uB48cByDw/+ocEIdSh2iiBED54O4AWpcYLlA/cT3ZrwqXDJcVoMr/8A2s9yoP4UBoDgz3GfALj/ +BvRIcBahtqHv8UAiAA4Wobahz3KgAFAMBYLPdoAANKkSrgWCE64JlowgiIAqbUbyE/aH4CLyjCDE +gWr0guFaAAUAz3KAALideg1v/kAiAAJIcR/wjCDIgEzyjCAQgFj0BYIJaYXgQ/cA3VPwHgggBwDZ +CHVP8IHhSvTPcoAAuJ1CDW/+QCKAAguKgbgLqu3xC4mAuAup6fGB4Tj0Jg1v/otwIMDPcYAAuJ1T +IAIAhiB/D0ipHHgJqe3xjuFQAAUAz3CAAEQeA4AYiIHgIPLPcoAA7JpIcOoMb/4G2UAiAALiDG/+ +BtkMkoG4DLK/8YThjvfPcoAA7JpAIgAFxgxv/gTZDJKAuAyysfET3QPwHN2KIEQPZg3gBSmWqXCN +Bi/+ocDxwM9wgADsmgyQ4LgE8lYPwAMG8FEgQIC8CAIEz3CAALidC4iB4AjyguAJ9JINwATRwOB+ +pg7ABPzx/PHxwN4ND/5+CoAFgODPdYAAJCoP9AQVBBAKIcAP63LPcAAAvRvD2yUEb/9KJQAAz3aA +AIwhCI4AFQQQh+DRJCGCyiHBD8oiwQfKIIEPAADDG8ojgQ8AAMoA8ANh/8olIQBRJECCNfQA2c9z +gAAgKyirAdpJq0qrjB1EEArbjh3CEIfgAtuPHcIQBvKI4A70USQAggzy7BUAEWq4EHiQHQQQCtiU +HQQQB/Bk2JAdBBCUHUQQkh1CEJYdghBVJcAYViXBFaoKYA4L2gCFibgApQHYAaXPcYAARB4AgcgQ +AAaGIH+OCfQBgcgQAAaGIH+OFA1BAwiOh+AI8s9xoAA4LgeBqLgHoUUFD/7xwNIML/5KJEBxz3aA +AOjAJIYA3aggQAIA3w8nTxMLIcCDBPQB5Q3wiiBKDuYL4AWpcQSG5ngEpkoJoACpcASGgODcCuEA +yiBhAvEED/7geAhzOGDVu9W5MHM2uMT3AiNCAArwz3KAAHjfRYIB4Mm4Inp6Yha44H9FeOB48cBW +DC/+mHIIdc92gABEnvQmQBDPd4AAxJ1RIECCyiBBAMokInTKICIA6CBiAvQmAhBRIkCCA/IB4JDg +RgAGAC27wLvPcoAAcNa0ekArhQJgkgS9hiX4E4m9DyNDAGCyANoWf0CnQafDuaV5BSFDARR+YLbP +cYAAZJ4VeQAZAAEC8IDYOQQP/uB+4HjxwOHFz3GAANSiQYnPdYAAxBSA4s9zgADoKSCDBvIB2ACl +grkgownwANpApaK5gOAgo2gOQgoA2LILb/8IcfIK4AEA2P0DD/7xwIYLL/6YcAMSATYAkSGBQOD0 +ucAgogAD4AQggA8AAPz/z3GgANQHDxENhgAgBQGQdQDaR/cNyBUiAzAOEwAGHWUZEQCGAiVDAxBz +fAAOAAXdDL3PcKAAyB++oBDdrqAB3RUYWIPPdp8AuP+9hs9wgACIBqCgXaYZEQCGEHPF91EjAMD6 +889wgACIBkCAz3CfALj/XaBRIwDAGPINyBUiAjAOEgIGz3CfALj/VqB2oBkRAIYKIcAP63JD2M9z +AABEFjEBb/+MuA8ZWIElAw/+8cCKCg/+q8HPcIAA+N8AEBMAB8gEIIAP8QAA8EDADcwA3s91oADI +H1EgQIDPcIAA+N8hgAPID/KgFQIQ+BUDEGJ5AiJXAHYQAQEvJ8glWWEE8IQQFwHicToYxAUfhRBx +xfcweA4LYAYC2QHZz3CgANQHNKAzoAPf7aAREACGz3GgANQHQcBA4A8ZGIAUGZiDA8ikEAEAUSEA +ggXyEgtADQPwRx2Yk89woADUBw0QAIZALwEkEHgFIRUAA8ghgAAQEgFDwbgQmAByEAEBuhAAAQIh +FAaGCGAHRMCB4Av0z3CAAFAcAJCB4AHYwHgMuELAAvBCxgPIz3GgANQHWYCIGYAApBABANmguBiC +A7oYhAO3uaQYQAADwPa4CPLPcqAASAhAIgEjB/BAIgEhz3KgAEwIBMACwwNxZXgFJRUgB2nPcwAA +/P9keM9zgAD432ODCCDFAM9zoADUBzWjABpABQIiASUvowIlAQA7o/Cjz3KAADA2DRIBNgCCMHAd +8s9woAA4LgWABCCAD8AAAADXcMAAAAAN8vXYBbjPc58AuP8aozujadgYuBmjAdgC8MlwgeAD9CCi +z3CAAPjfBBAEAAIjUyHPcoAArKqIcIAgDwoepRDYDqUB2BUdGJAHyAQggA8BAADwLLgDEgM2BLIP +g86qAKJAEwABArIQi2ATAwFAKAUBw7sFI0MBZrIPqi8jCAHPcIAAgMJAIAUJNXgpgM9ygAAEwjtj +aaCkFQAQ+BUBEIBwInhFwAHYz3GgANQLEKEDwDW4wLgXuAAggQ8ADgAAz3CAAPjfAoACuCvgBCCA +DwAA/P8leOxxAKEBEgE27HAgoM9wgAD43yKA7HAgqA3IFCIBADCJ7HAgqOxwwLADyJQQAQDscCCg +DcjwJQEA7HAgsOxwwLDscMCg7HDAoAcSATbscCCgA8ggkFQQAAEQuSV47HEAoQMSAzYBg1EgAIEP +8jKLcIvPcIAAUNl2eACIhiB/DBx4BLgleALwgNjscQCpA8g7djCIMxCAAAS5JXjscQCpA8gadjyQ +7HAgsAMSAzbPcIAACF6cEwEBb4MmucC5wLsMuQ27ZXkgoA0SATYAIYAPgAAswsCoz3CAALDBNng0 +esCyApDAGoQDFSVBAHgaBADPcIAARB4EgBqQ0BqEA0bAz3CAAPjfAoDAoYDgyiWOEx4DLgDKIY4j +yXfJdTp2TCAAoLzyFPDPcaAA/EQdgTmBBCGCjwAAAAgS9AQgvo8ABgAADPRRIwDAJ/TPcKAA9AcH +gP+4AN7o8y/wAN76uMomgh8AAAEC+bjKJoIfAAACAvy4yiaCHwAAAQKA4gryz3OAAFQ9UIOKJggS +AeJQo3oOABER8AHZz3CAANRdIKByDaAPKHDPcYAA0D0NgYomCBIB4A2hBSWNkxHycQIgAADehBIA +ALLglPdRIwDATvTPcAAAkBOiD0AFz3KgANQHD4IQeBkSAYZY4DBwK/cK8M9zgADYPCSDiiEQIQHh +JKNRIYCgQ/QeGtiDHRIAhgcaGDAdEgCGSsAdEgGGBMggoB0SAYYhoB0SAYYioB0SAYYjoB0SAYYk +oFYnABIeGhiAHRIChkAvACRQeQUhFQAEEgE2hiLzDwAREgGMIgyAAYFDwBfyGtgW8M9wgAD43wgQ +BAAAEAUACiHAD+tyV9jPcwAAjBM5BC//jLgA3tHwINiacANwEHhyGQQAAN5MIACgA/QDyHLwA8D2 +uAjyz3GgAEgIQCIAIwfwQCIAIc9xoABMCEfBA3BIwATBAsAleAUlFSAIwAfgz3GAAPjfI4EEIIAP +AAD8/wggVgAMJsCkLgEtAEnAmg0AAAUlDZCY9AHZz3CgANQHFBhYgFUnQRQPGFiAUSIAwv/1CMDP +caAA1AcVoQfCAiIAJQAaQAUPoQnCAiaAIBuhA9gQoSrAnOAA3o70B8gAwQQggA/xAADwEHGU9API +qXHIuQIjkyUIiAy4JXgDEgE3ELkleOxxAKEKwEAhWTABGhgwBMgDEgE2QccDGhgwBBpYMCGAAJAB +xzS5wLk0eAPgQOcEIIAPAAD8/x9nDRIBNgfwFSJAMA4QAAYCfxUiQDAOEAAGEHd29wPMz3GfALj/ +GKHPcKAA/ERdgAQivo8ABgAAYfRMIACgDPIEyFCIUyLBAIYi/gNEusQYggAwqM9woAAUBMSgB8jP +caAASCwdoc9wgAD43wKAQCBQIBJwDAXN/wvwz3KAANg8I4KKIRIgAeEjogPwOnV2CEAGUyF+oAX0 +VgwAAAV9gOVR8uG9RvIDyCmIAeEpqM9xgADYPAaBAeAGoUTwCiHAD+tyKBQFMDzYjLjPcwAAGxRN +Ai//SiRAAPoN4AUocAohwA/rcgcSBTZH2Iy4z3MAACMULQIv/wAUBDBMIACgz3GAANg8iiUQEAj0 +B8jPc6AASCyKJQgQHaP6ugfyBYGAvQHgBaG08QaBgb0B4AahsPHgvQjyz3GAANg8BYEB4AWhOnUD +yKlxyLkIiAy4JXgDEgE3ELkleOxxKnSEJAKRAKFAIU8wG/LPcaAA1AeAGcAEA8wqcsi6ELhFeOxy +AKLMoQHYFBkYgFYLIBEB589xoP6EAM9wnwC4/zagAxICNpISAAHquAQSATYG9JIRAwFRI4CCNvKq +uJIaBACSEQABqrh2C6AJkhkEABDZz3CgANAPEBhYgCQQAYbPcoAACOZFkjB5ArpFeQwYWIAU2RAY +WIDPcYAACOZnkUaRGNkQu2V6DBiYgBAYWIDPcYAACOZpkUiRELtlegwYmIAG8M9wgAAI5sqoz3Kg +ANQL0KJMIQCgZPLPcaD+uADPcJ8AuP82oAXwCNnscCCgAefPcIAA+N8CgBB3t/fPcIAArKokkJTh +wCGGDwAAkwDPcKAAaCzwIEAAz3GAAAheIIHPd6AA1AcleA2iA9gSp7YJAA1RJUCSBfKeDq//AcAG +8APYEx8YkBQfmJNMIACgF/LPcKAALCAwgAXAMHAB3colhhMEII9PIAAAAM9wAAA1FQ4LQAWA5cwn +IZDr889wACgIAAYaGDAGwP4JIAbJcVEhQKCy8s9woAAsIM+grvDPcIAArDoRiFEgAIAb8lEgAMMZ +8s9xgABEHiOBz3CAAKw6EIgQuDIhgQ8AANgCn7iA4QHZwHkPuSV4z3GgAPxEDaFMIwCgDfLPcKAA +9AdgGMAEz3GAANg8A4EB4AOhz3CAAKyqJJCU4cAhhg8AAJMAz3CgAGgs8CBAAM9xgAAIXiCBANrP +dqAA1AcleM9xoADUCw2hTKaKIAQCXgigBalxtgqgDwbAGRYAlsDgoAAOAA3MUSBAgEzyA90gHliT +AdgUHhiQBBIBNgAWBEAHGhgxABYFQAEaWDEEypzgyiLCB8oggg8AANwOyiOCDwAA9Ao0B+L+yiHC +DyhwJgxgEA7ZDxYAlgQSATa0GQQAEx5YkxCJUyDCAIYg/gNEuMQZAgBQqc9wEiAAAA4JIAQNEgI2 +BMjPcaAALCCwEAABL4Fk4DBwyiCFDxIoCACF989wACgIAAYaGDAA3g3MBCCADwAAAgiC4An0BBIB +NoogBADSDCAKmBEBAA3Iz3GAABTCz3KAAOjAFHnAsSaSz3CAAPjfAoAZYTB5JrKt2M9yALsAu8IN +oAcFuAPIGpDGDeAHDRIBNs92gACsqgSWz3WAAGDV9CUBEAaWMHAT8hIK4AUHyAohwA/rcgSWDBYE +Ec9zAACpFfQlBRAx2D0G7/6MuOEHr/2rwFEgQMPxwOHFJ/LPcIAA+N8BgM9xoADIH5YgQQ8eoRDY +DqEB2BUZGIB+DuAQQdhRIEDDE/IB2c9wgADUXSCgSg5gDwHYz3GAANA9DYEB4A2hiiUIEi7wz3Gg +APxEHYE5gQQhgo8AAAAIAN0H9AQgvo8ABgAAGfIA3fq4yiWCHwAAAQL5uMolgh8AAAICgOIK8s9z +gABUPVCDiiUIEgHiUKPeDsAQBvAD2c9woAAUBCWgiQev/alw4HjxwAoPj/0Idc92gADMDACOgOCo +wVj0i3fpcM9xgABYZK4Pr/0g2gHYAK4A2I+4CxocMADYFRoCMM92gAAAANd1AAD+yqC2BfQHwIC4 +R8DPcKAArC8agFIgAABRIACACPIBloC4AbYHwIG4R8DPcIAArGigiAoPoASqrs9xQ3WoEkDBiiEa +CkHBK44EpkbA6XBjwQ0cQjPPcYAAHD9Ewc9xgACIPkXBINkB2j3bOg4gDRe7CNg2D6AFAdkC2c9w +gACQJCSgrQav/ajA4HjxwDoOj/0odoDgz3GAAEQeLyAHIAP0YYEC8GCBxBMDBiW78CENAMC7gOai +oaOhzCMhgAHdyiUhEM9zgACMIeiLiecX9OGBxBcPFlEnQJER8uyTfpFwdw3ygeAK8oDgCfQAgcQQ +AAZRIECBA/QA3YHiyiUhEADfagtgDelwCnBiDKAGqXHPcIAAkCQEgFEggIAR8s9wgABkOACAgOAL +9M9wAAAWCZIIAAWB4AX0BguACwzwANmeuc9woAD8RCGg4HjhoB4LYA0A2IDmCA5iAMogYgDGD8AE +gOAE9IoIQA8E8LoIQA/PdYAAoA0AjYDgBvRyCwAOAdgAraUFj/3xwDoNj/3PdoAAICspjmiOMHPP +dYAAJCoacAX0AIXsuKPySo7PcIAAsCpAIJEBRCs+CydwVXgGiIHgKK5z9ACFz3eAAJwqRCk+C0An +ARU0IUEO7LjAuRHygOGsuAClFPIyCAAGCI5EKD4LACdAHiqQoLkqsAjwgOEG8hoIAAYAhYy4AKUI +jkQoPgsyIUAugeAB2MIgAQD2CeAQCq4IjiqORCg+Cyd3NX9Ml5hwgOLPd4AA4FzpcBjyz3GAAIwh +KImJ4QjyiOEr9CCFUSEAgif0RCw+CzIhQS6B4Qb0QCqBAgJxA/AKcUYNwA6KIJUKlgtgBSKHiiCV +CooLYAUihwiORCg+C89wgACwKjQgQA5RIECBAIUn8oW4JvAtagq5AnHj8UQpPgsyIUAuz3eAAOBc +gODKIGIAVgngEAquCI5KjkQoPgsvcQAhgA+AAJwqVXhMkIDi6XDI8zIhQSCB4cD1wvGluAClz3GA +AIwhKImH4QzyiOEQ9M9xgABEHiGBxBEBBlEhQIEI8uK4zyDiANAg4QAApT4PQAABBI/98cCmC4/9 +z3WAAOjAxJWA5h/yz3CgACwgMIAA3waFJ6UOIEAAHg2v/clxCKWKIIoLtgpgBclxiiDKC64KYAUo +heS1z3CgACwgEIDltQalwQOv/QiF8cBKC4/9OnDPdYAA6MAAhc9xgABgMAK4FXgVIEAEMCEQAIog +Sg1uCmAFKnGKIIoNYgpgBQpxTCAAoQ/0ABUEEAohwA/rcoogzAyKI8UCdQHv/golQARMIACgN/JM +IECgFPJMIICgHvJMIMCgEfIAFQQQCiHAD+tyiiAMDYojRQtBAe/+CiUABOYKAAAd8IogCgsCCmAF +iiHFBn4JAAAV8ACFgeAD3gnyiiAKDeYJYAWKIQUJwKUA2AWlBIWguASlFgpgAAPY5QKP/eB48cDP +coAA6MAmkgHhB5IweRBxJrLX9gSKgeAG9AWKgeAB2APyANiA4A3ynglgBYogig6KIMoBkglgBYoh +hgyqCAAA0cDgfuB48cDhxc9wgABUw0CQRCIAA4jgQ/QA3c9xgADowKWhBIFRIoCBoLgEoSb0BJHP +coAAQMEB4ESCEHhQcASx1PcEiYHgBvQFiYHgAdgD8gDYgOAK8oogygEqCWAFiiGGAUIIAAAb8M9w +gAA4NAOAgOAS8gPYEfDPcQAA//8GCWAFiiAKDs9xgAA4NAOBgOAC8qOhBNiiCQAAIQKP/eB48cDh +xc9zgADowAQThABMJECABvQFi4HgAdgD8gDYgOAL9AUThQAKIcAP63KKII0O4Qev/s7bAtgAowDd +BJOpo6WjprMKowSDpLOguASjiiDKAZIIYAXV2Z4J4AapcL0Bj/3gePHA4cWKIAoNdghgBcDZz3WA +AOjAiiDKC2YIYAUohQDZA9gApSWlJIWguZ4IoA0kpYUBj/0A2c9wgADowCqg4H8poOB48cD+CI/9 +7g/P/89wgAAUwWCAz3KAAOjAqIBgos92gACwMASCqKIA2cCGoLiB5iWiBKIY9ILjzCPigBn0gOXP +cIAAODQjoAvyiiAKC+4PIAWKIQQLag/P/wnw6goAAAfwAdtgoiiioLgEogEBj/3gePHAjgiv/QDY +z3GgACwgUIHPdoAA6MAkjs91gAAUwYHhCKUF9CWOgeEC8gHYgOAl9CqGgOEc8gaG7gmv/Q4ggADP +cQAAECcwcND3z3GAAHjfJYGZIc0KMHBK9wXwz3AAABAnCKUC2AjwANgI8AmGgOD29QHYAKUB2IEA +j/3xwOHFCHWKIAoORg8gBalxz3GAAOjABIEPIEADBKF2DyAACdhhAI/98cDmD0/9z3agACwgEIbP +dYAA6MAHpc9wgAAgWz4I4A4A34ogigsCDyAFJJUAFQUQTCVAgBHyTCWAgMwl4oBR8gohwA/rcoog +TA2KIwgHCQav/ookgw8ElYDgnfLmC8//z3CAAHjfBYAohZkgzQowcAHYwiAOAIDgjfLPcIAAyDPp +oNdxAAAQJ28gCwCA4CDyBI2B4AX0BY2B4AHZAvIA2YDhiiAKCwnyfg4gBYohxwSWDc//b/ByDiAF +iiEHBs9wAACIE+YN7/8IpWXwiiAKC1YOIAWKIQcI0g3P/1vwBJWA4CL0JZUIhYHhwCCBDwAAiBMD +8ht4CKWKIAoLKg4gBYohRw3PcIAAeN8FgCiFmSDNCjBwAdjCIA4AgOA39BIJAAA38IHgB/SKIAoL +iiGHDivwCIUdeNdwAAAQJwilbyALAIDgHfIEjYHgBvQFjYHgAdkD8gDZgOGKIAoLCPLKDSAFiiGI +AeIMz/8T8LoNIAWKIcgCz3AAAIgTCKUH8IogCguKIcgEog0ABSINz/8ElQW1iiCKC5INIAUkleS1 +EIatBm/9BqXgePHAz3GAAAibQYHPcYAAeN8lgQUpvgAwcMogTgAMIQDwz3EAABAntg9v/cogRQ7P +cYAAQMEEodHA4H7gePHA4cUA2M9zgADowACjz3WgACwgEIUB2c9ygAAUwQajEIUgogaiz3CAAMgz +A4gkq4wgg4YkqgTyJaolqxIMIAAD2DkGT/3gePHA4cXPdYAA6MCKIIoM7gwgBSCFAdgdBm/9AKXP +cIAARB4DgM9xpAAcQAiAwLgTeMG4EqHgfuB44cUA2kokAHTPdYAAxJ3Pc4AAPJ5IcKggAANAIwEC +FHlAsRYlARBAoUGhAeBKJMBzANmoIEACz3CAAHDWNHhAsAHhz3CAAHgHQaDPcIAA7JpMsOB/wcXg +eAXwQnnHcEAAAADPcoAAeN9FglBxN/dTIEMFcHHAII0PQAAAAMAgjQDgfyJ4BvBieQIggA9AAAAA +z3KAAHjfZYJwcTf3UyBCBTpiUHOD9zhgB/ACIIAPQAAAAGJ4OGDgfvHAygxP/c9wgADgwwyI57gK +9AK4z3GAABDXFngFYS29wL0D8P/dqgjABIDgCPLPcIAAjCEIiIfgAtgD8gDYz3GAADSpd4nPcoAA +zLMhgjBzBPIggoDhBPQB3wPwAN/PdoAARB4ghsQRAQZRIUCBK/KA5Sn0I4Y4iYThJfK2D4AOgOfP +cYAA4DsY8s9ygAC0BwKCAeACogDYz3KAAKxdAKLPcoAACF0Aos9ygACMBgCiEYEB4BGhBfAQgQHg +EKGyCo/9DgjABIDgDvLPcIAAjCEIiIjgzCVhkAb0Wg+gDgHYSgzABYwlw59P8oDnEfLPcYAAxBQA +gYDgC/IA2AChz3GAAOgpAIGiuJIOoAkAoUoOwA3PcYAAeN8GgUUgQAEGoc93gAC4nQuPUSDAgJwO +Qv0Lj1EggIDQCgIEBgrAA34IwASA4AgLIgDKICIGgOUI8gCGxBAABlEgQIEX9M9xgABsOASJgOAR +8gOJgOAK9Iog0A6aCiAFiiFFAzYOYAwD2M4KIAAV2K0DT/3geOHFz3GAAMgUAIkB24DgYakk8s9w +oACwH3mgz3CAAKQcCICjgWCAAoEQdQDaGPTPcIAA4BQAiIDgA/QB2ArwAYECIw0A13VMAEBLefdB +qUhwgeAD9GGhQqngf8HFoqHv8YDgAdjCIAwAz3KAAMgUAKoB2AGqANgCqgGiAqIDouB/JKLgePHA +ugpP/Qh1KHdIdoogRw3qCSAFiiFWA5DlifcO2Olxpg+v/gDagOAD9BPdLfDPcoAANKlIcA4Jr/0M +2c9xgADIFACJgOAP8s9wgABUwwCQhiD8AIwgAoAF9AWSZJJneAOhQiUAE6YLIAbJcQolAJAL9M9w +gABUwwCQhiD8AIwgAoD8DsH/nQJv/alw8cAmCk/9OnAacWYJIAVn2GjYXgkgBSpxTCEAp473CiHA +D+tyz3AAAOMOg9sKJEAEbQCv/golAARMIIChyiHGD8oghg8AAOQOyiOGDwAAhADKIsYHbPcA2s9x +gADAl566FSEBBACBASpCBEZ4sgzgBwChFQJP/eB4iQfv/wXZ4HjxwOHFAN3PcIAAwJdSCC//HNkb +2KYIIAAF2UokAHfPcYAA6BSoIMACFiFAAwQQBQCwdZh1BfRAJE0A7QFP/QohwA/rcnfYBbjVB2/+ +U9vgePHAz3CAAMCXGBAFAC8sQQFMJACHyiLGB8oghg8AAOIOyiOGDwAAqwCkB2b+yiHGD89wgADo +FBYgAAEAgEB40cDgfuB48cDhxc9wAwBADc91oADIH0UdGBCqD8//gNgVHRiQdQFP/eB48cDuCE/9 +OnAacS4IIAVl2GbYJgggBSpxTCEAp473CiHAD+tyz3AAAOMOY9sKJEAENQdv/golAARMIIChyiHG +D8oghg8AAOQOyiOGDwAAZADKIsYHbPcA2s9wgADAl566FSAABCCAASpCBEV5egvgByCg3QBP/eB4 +iQfv/wXZ4HjxwHIIb/3/2s9wgABIrBMYmIAcGJiAAN7PcYAA4AbDoc9wgAC4JECgAdrPcIAAvCRA +oMyh0KHRoc+hwKHBoQLdyXfPcIAAPKaELwgZACBCDkuCJ3AAIZB/gABIpkYiwgBLoIoIoA5AIAAh +Yb2A5SQYgiMB5yf3AtgA2b4Or/0E2hYOIAUB2FEAT/3geOHFz3KAAMgVIIoA3eC5ZNjKIEED4bnP +c6AAwB0GognyDNgAowGCA6ICggSiBPCgo6OipKLPcIAARB4DgAmAUSBAgdEhooAF8gCDgLgAo+B/ +wcXgePHA4cUA3c9woADAHaCgqXCKCCAAqXHPcIAAyBWjoKSg7Qcv/aag4HjxwG4PL/0IcWoIAACA +4DDydg5gEDLYcg5gEB7Yz3egAMgffxcOloogEwZBLg0UxL1+DuAE8tmKIBMGdg7gBMlxiiATBmoO +4ASpcc9xgADkFQGJAdoQdcIiigCA5UCpyPYA2A2ngeIE9ATYAalpBw/98cD6Dg/9GnHPd4AAyBUg +j1EhAIBJ8s9xgADkFSCJgOHMICGgQfKB4Ab0z3CAAMyzoYAD8ADdjuUD94DlAvQA3c9xgADMsxiJ +gOAE9IDlBPQA3gTwooEE3oogEwbiDeAEqXGKIFMG2g3gBMlxz3CAAEQeA4AYiIPgzCAigcwg4oHM +ICKCzCBiggfyiiATBrIN4ASx2QnwCpcQdQn0C5cQdswgIaAD9ADYIPAB2M9xoADIHw2hz3CAAOQV +AYjLt6q3BL4QuMV9BX2KIBMGcg3gBMjZiiATBmoN4ASpcc9woADIH38YWIMB2HUGD/2A4M9xgADI +FQT0QCEAAwTwQCEABACAz3GgAMAdUSAAgACBzyDiANAg4QAAoeB+4HjgfuB44H8A2OB+4HjgfuB4 +4H7geOB+4HjgfuB4z3GAAFw8EoEB4BKhDcjHcIAAIMIsiAHhL3ksqM9wgADIFQKIEHHJ9oogCAAG +GhgwitiQuAfwiiAQAAYaGDBC2Ji44H7gfuB48cB+DS/9JNqpwYt1z3GAABBkMg4v/alwz3eAACAs +CBeBkM9wgACyKkQpPgsyIEAOz3aAACQqUSDAgVEWABYf8oHgLvJiCCAAANiiCAAAggiAEAHYQMCB +wdrcAicAE94JYA0g2qlwJNm82h7b7gygDBi7AdhRHhgQEvCA4BDyng1gCVQWABYA30DHqXAk2bza +HtvKDKAMGLtRHtgTSQUv/anA4HgM2s9xgAAgLALgD3gnGQKAANgoGQKACxGAgCYZgoAIEYKAKRkC +gAHgD3gLGQKAz3CAALIqRCo+CzIgQA7gfyoZAoDgeN3Yz3GAADwrBKkLiQfgD3gFqVDYBqlv2Aep +mtgIqQnY4H8JqfHAbgwv/STarcHPcYAASGUmDS/9hMDPcoAAjCEIiofgfAICAM93gAAgLAgXgZAK +F4OQz3WAALAqQCWQEQNtRCk+Cyd1dX1mjc92gAAkKoHjTAICAGySz3KAAEQeXpJQcwj0QIYEIr6P +AAA4ECwCAQAA3alyC/BEKT4LACGDf4AAnCpVe2yTAeJ9ZUQpPgsyIEQOkHKx90wkgIDKIcIPyiLC +B8oggg8AANobyiOCDwAAxAAwAmL+yiUiAEINgAMGDaADmHACIAABIIZKuOO50SEhg1HygODEAQwA +EHUA2QMcQjAJ96J4EHUB4S95/PcDHEIwgODE9gHhAxxCMAgXgJAKvUQoPgsyIEEuL3DHcIAAnCqA +4cohYgA1eAyQCrhBwM9wgADgXAKAQsXpcYIhQwVDwEAkwDD6DyANDdpeDu//DdieDs//fg5AEAHY +RMCFwdrcAicAE9oPIA0g2oTAJNm82h7b6gqgDBi7AthRHhgQlvAC2c9woACwHzmgURYBFoPhCBeA +kLhwJ/REKD4LL3AyIAEgx3CAAJwqCiJAgMoiYgAVIIMApBYCF2yTUHMV9IHhAdnCIUEANXilFgEX +TJAwcs9wgACkHAf0DYAAgFMWARYQcWTy/9gDHAIwRC0+CzIgQS4vcMdwgACcKgq9gOHKIWIANXgM +kAq4QcDPcIAApBwJgELFIIAAIQABQ8DpcUAkwDCCIUMFFg8gDQ3afg3v/w3Yug3P/5oNQBAB2ETA +hcHa3AInABP2DiANINqEwCTZvNoe2woKoAwYuwPYUR4YEAgXgJBEKD4LMiBCLi9wx3CAAJwqCiOA +gMojYgAVIMEALJGB4qQeXBAB2cIhQQA1eAyQpR4cEM9wgACkHA2AAIBTHhgQBPBeDM//NQIv/a3A +4HjxwM4JD/2YEAIABCKBDwAAAAg7eQQigw8AAAAQJXvPcYAARB6kgem6ViVOFFYlDxWYEIEACPKG +If8DRLkvZ4m/6XEZ8FEiAIK8FQIRDPLCuYAlAhk/ZeiPPWUwjWV/8H9FeQnww7k8eT9mPmYwjuiP +RXmIGMADZXm9AS/9jBhAAPHA4cUDyKQQAQCYEAIAUSEAgHIQAQFIcAbyJg5gAgDaCHUH8AHhGg5g +AgDarGh+DoAOz3KgAMgf+BIBAAPIz3OAABDXEIgCuBZ4AGPtuM9wgACkHAj0AdtzokiAQIIMgGCA +CPAC23OiSYBAgg2AYIACJUAQWGAQcsAjbQANcQChDXBgoAAWAEAAFgBAA8jPcqAA9AdwEAEBaLkn +onAQAQFouTB5IQEv/XAYRADxwKIID/3PdqAAyB+gFgQQ+BYDEITgAN8i9AMSATakEQAA9Lh2EQIB +BvLPcIAA+N+hgATwghENAQ3MUSAAgYQRAAEJ8gIlwRACJEMACCMDAATwhhEDARtjaHFx8IHgSvQN +EgE3A8jkuXgQAgEh8lEhQIDPcYAARB4kgVQRAQEJ8n4QDQEifWJ9AiRDAyvwgBADAc91gADw1QAj +RABwiHZ9YJUAIw0BhBADAbtjG/CkEAEA9LkI8nCIz3GAAPDVdnlgkQTwghADAc9xgABEHiSBgBAN +AVQRAQE9ZbtjhBANAbtjgBANAblhfhANAUJ9J/CC4CH0AxINNg3MeBUCEVEgAIHPcIAARB4EgFQQ +AQEJ8oAVABEieGJ4AiQDAAfwghUDEYQVABE7YxtjgBUNEUJ9BfDpc+ly6XXpcQ3MUSBAgAfyA8h2 +EAIBYro6YgvwgONiusn2z3CAAEQeBIBGEAABGmL4FgAQXWUCfR+GEHWL96DYD6b/pl+mAtgVHhiQ +gNgOpokH7/xwePHAGg/P/M9xgABEHvAhAgBWIkUECIJWIgQFUSDAgIogCADKICEAvBoEAEokAHIA +2agggA/PdYAA8Gn8ii5l5H4vKIEDTiCDB89wgADYa29gACVDAOCrRBKPAOR+Ly6BE04mjxfuYMir +yIJRJsCQD/Idiobh0yCmAC8oAQBOII0Hz3CAABRoqGAQ8M92gAAYai5mzmW8isR9WBKOAMR9Ly1B +E04ljhfIYBCrAeFKJAByANuoIIEA3IrPcYAAtGtvYc91gADYa+R+LyiBA04gjwfvZQAlwAD8qEQS +jwDkfi8ugRNOJo8X7mUkGIIDyIJRJsCQD/I9ioDj0yGhAC8pQQBOIY0Hz3GAABRoqWER8IDjA/LJ +awLwaHbOYTyKxHlYEo4AxHkvKUEATiGOB8llLBhCAAHjSiQAcQDYqCBABc9xgAAQaH2KCWEAJAwA +AeBkeS8pQQBOIYMHz3GAABRoaWEgrCEGz/zgeOHF4cbPc6QAtEUpEwCGz3GAAGQ7yBkAACsTAIbM +GQAAz3ClAAgMA4DkGQAADhMAhhB6MLjUGQAA0BmAAA8TAIbYGQAAz3CAAJDD1Ii2iOgZgAN4iOwZ +QAMNkPAZwAAs4AIgggP0GYAAAiBCA2J4+BmAAPwZAADBxuB/wcXPcIAAsF0GgAOAIIDPcIAA3Jfg +fymg4HjhxeHGmHDPcoAA6BUFgiCCZoLKuBC4yrkFIQGAAYLKuxC7yrgFIwUAZ4ICgsq7ELvKuAUj +BwBoggOCyrvKuBC7BSMGACTyABQOAC8oQQBOIIMHANgPIMAAEn0EIEMBpH5lfgAcgAPagqR+xXt6 +onmCBCCOAQQgwAGke8V7eaJ4gqR7BCFBg2V4GKLf9cHG4H/BxeB48cCCDM/8OnAFgaCByrgQuMq9 +BSUNkAGBJoHKuMq5ELkFIRAAAd4b8gQlgJMU8i8oAQBOIIIH8CGBIIDhAN8PJ48QCfIEJwAUQiAA +gGB5yiBiAOZ9gOXbfuj1iQTP/OB44H8A2KHB8cAeDM/8o8EIdUjAz3aAAOgVGob7hjyGBH8kf6d/ +QcdGC6AEiiDYBIog2AQ6C6AEqXGA5xf0gOVs9IILIAUK2IDgZvIKIcAP63LPcAAAjROKI0cASiQA +AD0CL/4KJQABBBQBMYDhGfIgFAAxCyBAgA3yz3CAAPApYIDPcQAABGUM2GB7A9oJ8IDgB/TPcIAA +7CkggGB5DNgGFAExgOEZ8iIUADELIECADfLPcIAA8ClggM9xAAAEZQ3YYHsE2gnwgOAH9M9wgADs +KSCAYHkN2AQnUJML8tIKr/8K2IogGAiGCqAECnET8IDlEfSKINgEdgqgBIohRwt6Ca//CtiKIBgE +YgqgBOlxYggAALymCNx3A+/8o8DxwA4Lz/wIdgDdiiDYA0IKoATJcc9wgADoFVqAO4BEeQDaDyKC +AwQiQwBCIwOAyiNiAC8mx/AB38ogQQMH8hyAJHiqDu//RXjpcC0Dz/zgePHA4cWhwQHYQMDPdYAA +6BUKhVEgAIAM8otwBNln2j3begpgDBe7CoWguAqlCQPv/KHA4HjxwIYKz/wacCh1SHdodjhjZtk9 +2r4KYAwXuoHgCfQKcJYKYAypcelwZgpgDMlxvQLP/OB48cBSCs/8psEodRpyYMAA2AEcAjAB2AIc +AjADHAIwi3DCDuAHgcGA5QXyBMEKcGB9BcIDwYDhDvQKIcAP63LPcAAAjBPu24okww99AC/+uHNg +eQDYYQLv/KbA4HjxwPIJz/yiwQHez3WAAOgVOoUbhSR4PIUEIRAAHgmgBIogmANMIACgMvID8Nt+ +BCCAo/7zLygBAE4gkQcVJU4UHYZcHUAUgODKIcEPyiLBB8oggQ8AAI8TyiOBDwAAHALKJAEEBAAh +/solQQQODI//HYZAeL4Lj/+KIJgDvgigBCpxANgPIEAEBiAQIEoN7/8KcIogmAOmCKAEPIW1Ae/8 +osDgeOB+4HgA2c9wgAAILuB/OKDgfuB48cByDwAEz3ABAOBlgOAK8s9xgADoFbgZAAAbgZG4G6HP +cAEARGWA4Ajyz3GAAOgVHqEbgYG4G6HPcAAA2GeA4Anyz3GAAOgVlBkAABuBiLgboc9wAADcZ4Dg +CvLPcYAA6BWYGQAAG4GJuBuhz3AAAOhngOAJ8s9xgADoFZwZAAAbgYq4G6HPcAEACG2A4Aryz3GA +AOgV2BkAABuBmbgbodHA4H7xwOHFocHPcoAAvKrPdYAA6BUXhQDZDyEBABiFJHhCIACAyiBiAIHg +AdsA2Q/0CNhgwAEcQjACHMIwAxzCMItwBNnWDe//iiMIAAjYANn+De//KHIA2MEA7/yhwPHAOgjv +/AjZz3Kt3u++9g4gAjpwxg8gACpwg+BI8s9wgADclwOQTiDPAYfnUAAGAM9wgACIDeINYAD0IMAD +AN4A3QTYGnAqcOlxyXIKJIAPrd7vvq4OIAKpc9oPIAAqcIPgJvJCIEAggOAB5Sz3AeaC5qj3AeeH +57gHxf8qcM9yrd7vvn4OIAIQ2VIPIAAqcIPgDvLPca3e775qDiACKnAGD+//KnCD4MogIgDtB4/8 +8cCOD6/8A9qmwRpwFg3gDIPBA8HPcIAA1A4UFAcwAN7wIEUAz3CAANwO8CBGAM91gAA8CA7YxKVA +wATYQcDPcK3e775CwATCCnCA2wYOIAKYc9IJIAAKcIPgQPIDw89wgAD0DkKF8CDBAMClgOEMFRAQ +waUI8s93gAD8DvAnwBCA4Ab0wKXBpQDZGfCEKgwDrghgAC9wDiCBDwAAAAEgpQPAhCgMI/AnARCW +CGAAL3AOIIEPAAAAASGlBIWB4A30AIUReIwgB43C98ClMXmMIQeNw/fBpQDYGQev/KbA4HjxwLIO +r/wE2qbBOgzgDItxz3AAABvSAN2pcaIMYACpcgDBz3AAABzSkgxgAKlyAMHPcIAANA0BwhUgQQAA +kQLBBbpmDWAARXkDwIDg3AAFAM92gAA8CNLYCLgZ2V4MYAAA2s9wAAAi0kAmARKGCmAABNrPcAAA +I9JAJgETdgpgAADaz3AAACDShMFqCmAAANqFx89wAAAh0ulxWgpgAADaAoYX2cIPYAxAJgISA4YX +2bYPYAxAJgITBMAX2aoPYAyEwgXAF9miD2AM6XIChgDZjg8gAIu5AqYDhgDZgg8gAIu5A6YEwADZ +CLh2DyAAi7kIdwXAANkIuGYPIACLuSKGMXkZ4QUpfgAjhi9yUHcxeRnhBSl+AC9xzCBFgIb3A8AB +5RB1MgfO/wPAEHXG9wHZz3CAADwIJKAA2OEFr/ymwPHAdg2v/AnaqcEIdvYK4AyLcToL7/whwAhx +QthKDGAABbkMFAQwAMHJcAbCCiWAD63e777+CyACAsOmDiAAyXCD4CryAMEFws9wgAB8DQDd8CBA +AATBCroEIoIPDwAA/Mm5RXkWC2AAqXIiDOAPBdggFAQwAMHJcAbCCiWAD63e776yCyACB8M6Du// +yXCD4MogQgNNBa/8qcDgePHAtgyv/ALap8GacFoK4AyDwc9wgABsZQCAANlFwM9wAAAR0roKYAAo +cs9wAAAS0gDZrgpgAChyz3AAABPSANmeCmAAKHLPcAAAFNIA2ZIKYAAocs9wAAABRAfZggpgAADa +z3CgALQPcBAXAAoKYAwB2H4L4A8F2LzYUgtgAADZw9hKC2AAANmKIEQIPgtgAADZiiAECjYLYAAA +2SXFtdgqC2AAqXGKIIQGIgtgAKlxA9hAwATeQcbPd63e775Cx4pwBMEDwh7bmHNKJQAASiYAAMYK +IAJKJwAAjg7v/4pwg+Da8s91gAA8CAgVFhAMFRIQDthAwEHGQseKcATBA8Ie25hzSiUAAEomAACK +CiACSicAAFIO7/+KcIPgvPIIFRUQDBUQEA7YQMBBxkLHinAEwQPC4duYc0olAABKJgAAVgogAkon +AAAeDu//inCD4KLyCBUREAwVExAD2EDAQcZCx4pwBMEDwuHbmHNKJQAASiYAACIKIAJKJwAA6g3v +/4pwg+CI8sKFo4XuCGAMLyDHBQTBz3KAAPQOAiFApc9zgADkDjV6AKICIwAkz3KAAPwONXoAosPa +NXtAo89zgADsDjV7QKMi9CYLwAMKIcAPgODrcg/yz3CgAPxEdBAEAGQQBQDPcAAAsRNdAe/9iiNJ +Cs9wAACtE4ojiQpKJAAARQHv/QolAAGA4B304grAAwohwA+A4OtyD/LPcKAA/ER0EAQAZBAFAM9w +AACxExkB7/2KI4kMz3AAAK4TiiPJDN7xAiWAJdlgAiFBhA/yAiVCJAx6LgwgAC9wBMICJQEgz3CA +ANQOVXggoAIggCS5YAIhwYQP8gIgwiQMegYMIAAvcATCAiABIM9wgADcDlV4IKAA2GkCr/ynwOB4 +8cAaDiAAANjPcAAADdIA2TIIYAAA2s9wAAAM0gDZJghgAADaz3AAABXSz3HzD//8EghgAADaz3AA +ABvSANkGCGAAANrPcAAAAtKg2Zq59g8gAADaCdiMuADZ6g8gAADaFNiMuP/Z3g8gAADaANiMuP/Z +0g8gAADaEdiMuP/Zxg8gAADaAtiOuADZug8gAADaAdiOuM9xAAD//6oPIAAA2s9wAAAL0gDZmg8g +AADaz3AAAA3SAdmODyAAANrPcAAAEtIA2X4PIAAA2s9wAAAT0gDZcg8gAADaz3AAABTSANliDyAA +ANoA2NHA4H7xwFIJj/ykwYtxAd3SDqAMqXLPcIAATGQAgEHABNgmCGAALNkO2B4IYAAA2SHGtdgS +CGAAyXGKIIQGCghgAMlxiiBGAP4PIADJcQDAgODMIKKAzCDigMwgYoHMIKKBzCAigswgYoLMIOKC +yiFCAwP0A9mB4MwgooDMIOKAzCCigcwg4oHMICKCzCCigswg4oIA3QX0gbkveYDdhODMIGKBzCCi +gcwg4oHMICKCzCBigswgooLMIOKCA/SDuS95hg8gAA/Yg8HCDSAAEdgDwYO9pXlDwW4PIAAR2ADY +4QCv/KTA4HjxwOHFocGLcfINoAwB2s91gADsmQAUBDDPcIAA1AxWJQESEtrqDSAAANsAFAQwz3CA +ANAMqXEB2tYNIAAC289wgAD4DCRtHdreDSAAAMMA2JEAr/yhwOB48cD6D2/8A9qjwbpwlg2gDItx +AcHPcIAAhA0A3/QgTgACwc9wgACYDYDm9CBUAM9wgAA8COCg4aDMJqKQzCZikcwmopHKJcITAvQA +3YHmzCbikMwm4pHMJiKSA/QB3YTmzCZikswmopLMJuKSAvQC3WoNz/+qcM9yrd7vvlYO4AHJcUYO +7/+qcIPgdvIAwIDgzCCigVD0gObMJmKQzCYikUr0AsCA4Ej0z3CAANQOtXhacOCgz3CAANwOtXh6 +cOCgz3CAAPQOtXgacOCgz3CAAPwOtXg6cOCgz3CAAOQOtXjgoM9wgADsDrV44KCqcMlxz3Ot3u++ +3g3gAalyQgrv/6pwg+A48gDBABIAIIbhAdnAeQO5tXnHcYAAvKoAoQATACAEoQAQACAbeAihABEA +IBt4DKGqcKlxyXIKJIAPrd7vvpIN4AGKczoPr/+qcIPgEvIAwM9xgAA8CECBBL4GuNhgFSAABcdw +gAD4qiGBQrAjsADY1QZv/KPA4HjxwKTBi3EiDKAMBNoAwAHBBLg1eM9xgAA8DRBhbg0gAALBAMAB +wQS4NXjPcYAAXA0QYVoNIAADwQDYpMDRwOB+8cChwYoIYAKLcgDAocDRwOB+4HihweHF4ca4cM9w +gADMsxAQBgDPcIAAjC0FgJhxgOChwYYk9w9z8s9wgABYXgCA0HAN9M9wgABgXgCAsHAH9M9wgABc +XgCAkHBh8gAcQDEgwgEUgTDw3lMiwADEelMhxwAkflR6QC6NAbR9umIVes9xgAC8rEhh1H4Ic4Yj +/Q97ezpiQYpleEhzhiP9D3t73WUVJc0RvmHCjmV6yXOGI/0Pe3u5YSOJZX4oc4Yj/Q9MJACAe3tl +eRPyz3WqAOAHc4VRIwCABvJIpQmlKqXLpRDwCKVJpcqlK6UK8Am6RXjPcqcAFEgDogm5JX7Eos9x +gABYXgAZgAHPcIAAYF4AGEABz3CAAFxeABgAAaHAwcbBxeB/ocDxwC4NT/xaDoADgOBoD8ECAN4X +8HDcAiUAE0QuPhcvd4INoA0ncEIlAB56DaAN+GAA2QAmgB+AAI4rIKgB5s91gAAgLGsVgJAQdqb3 +z3CAAIxcUg2ADc9xgAAkKgCBobiuuDUFb/wAofHAz3EAggEAz3CgAKwvPKDPcIAAZDgAgIDgDPTP +cIAA6BcAgILgBvLWDIAD0cDgfooNQABSCeAFb9iA4Af0ogugDwrYdg1AAPLx8vHPcoAAZDggggZ5 +4H8gouB4z3KAAGQ4IIIleOB/AKLgeAQogA8AAC+6QinCdFB6RCr+AgIgQA4QeIDgBPIB4lB6g+BA +sQP2gOAD9ADYAvCA2OB+4HjVAg/+8cAaDE/8OnDPdYAAlBwAhQHggeAApQr0AdnPcKAAyBwxoBoL +oA8ocG4OYAUH2Bpwz3agAOwn64buDmAHKnALpgCFQiBAgAClBvTPcaAAyBwA2BGhQgtgBQpwIQRv +/Olw8cC2C0/8OnAodRpyKg5gBQfYUSCAoFpwBvIaDSAIyNhQIJAgTCCAoBzyC/ZMIACgEvJMIECg +I/QV2BO4DvBMIACkE/JMIACoGfRuC2AEKnAApRDwKdgSuPAgQAQApQrwK9gSuPrxz3CgAOwnGYAA +pcYKYAVKcJ0DT/wKIcAP63LPcAAAihN72wokQASlAa/9CiUABPHAJgtP/Ah3OnGA4hpzAN7N90h1 +9CeAExUhgSNSD+//CnJhvYDlAeY2910DT/zgePHA+gpP/KHBCHeA4hpxAN7P90h19CeAEx4IIACL +cQDAFCCMI2G9gOUAtAHmNPcxA2/8ocDxwMYKT/yhwRpwz3aAAJQcAIYB4IHgKHUApgr0AdnPcKAA +yBwxoL4JoA8ocBINYAUH2Ah3jg2gA7PYgOAV8otxxglv/QpwABQAMQClAIZCIECAAKYG9ADZz3Cg +AMgcMaDeCWAF6XDFAm/8ocBRJMCA8cAF8ioPz/8D8OoIAADRwOB+4HhRI8CA8cAF8kIPz/8D8AIJ +AADRwOB+4HjxwC4KT/wIdY7gAd7CJo0Tz3CgALQP/IC2D+ALANjJcKlxAdqaDGAFSHOmD+AL73hl +Ak/88cDuCU/8OnAodRpyYgxgBQfYTCCAoFpwH/IO9kwgAKAV8kwgQKAo9BXYE7gVIEAEoKAd8Ewg +AKQV8kwgAKgc9CpwHgpgBKlxEfAp2BK4FSBABKCgC/Ar2BK4FSBABKCgBfDPcKAA7Ce5oAYJYAVK +cNkBT/wKIcAP63LPcAAAiRNK2wokQATlB2/9CiUABOB48cBiCU/8CHc6cYDiGnMA3s33SHX0J4AT +8CGBI1YP7/8KcmG9gOUB5jb3mQFP/OB48cA2CU/8CHeA4hpxAN7N90h19CeAExoIIAD0IIEjYb2A +5QHmN/d1AU/84HjxwAYJT/wacM92gACUHACGAeCB4Ch1AKYJ9AHZz3CgAMgcMaACCKAPKHBaC2AF +B9g6cNYLoAOT2IDgGfKwfUAojyGBvxC9pX/PcKAA7CfmoACGQiBAgADZAKYG9M9woADIHDGgHghg +BSpw/QBP/OB4z3GAAEQeI4HPcoAA8AcyIYMPAAAfAwGiMiGBDwAAGQNhskhwILII2XPaHttNAOAL +GLvgePHAz3CAAEQeA4AJgFEgQIHKIGIAWAki/8ohIgDPcYAA2AaKIIwMhg/gAyCRdgwv/gHY0cDg +fuB48cAuCE/8z3WAAMyzIoWN4c92rACQAQX0GI2A4Ab0i+E89BiNgOA69OuGMBYQEM9wgAAMKiCA +YHkC2IDgIoUe9I3hp78G9EYgwCNFIAADE/DPcIAABCoggGB5ANiR4Af0RiDAI0UggAMF8EYgwCNF +IIAC66YMphbwjeHQJ+ER5fPPcIAABCoggGB5ANiR4NAn4RHo84e/2fEF2AymoNgLpvEHD/zxwJIP +D/wIdSh2IIVCIQGAyiFiAIDhANgF8uoPYA2pcAHYJIWA5tAhYgDPISIA0CEhAM8hYQCA4CSlIA9i +DcogQgO9Bw/84HjxwEoPL/yKIgQOz3CAAKwGAIDPdoAA1KImgEAmABTmC2AMBOEBhs91gABEHiKG +yB0YEM9ygABwIckdWBAhlieqII4EIIAPAAYAAIDgAdjAeCGqBqoA3koM4AnJcM9wgACjHHIO7/7A +qB4KgAOA4AryogqAA4DgBvQGCy/+yXAq8M9wgACkHCSAIIH+DeADiiBMDIogkwHyDeADqdkC2MIN +oAEB2RoJYA8C2COFSIE0kVMiAACaDiAKAduKIIwOyg3gA7PZANmeuc9wgABEJSCg5QYP/PHAsODh +xQh1g/a55cz2CiHAD+tyz3AAAJohItuYdcUEb/24c0IlABzBBi/8D3jgePHAQg4v/JhwQYHkurCJ +O/Jyic92gAAQ1/Jt9n/mZjTK9r4IEYUASSDAAAjyz3aAAFDZtn7BjgPwAN7HcIAAUNm2eASICCMD +AAgjgwMAI0ABSSDDAxZtdXjPc4AA0NoDY89wgABQ2rZ4z3WAAEQepIW4hQGApXgEIIAPAAAACAZ7 +AvBjgei7mBnAAADdCfKkEQAAAN2XvZG4lLikGQAAUSQAgBzyz3CAAEQexIDAusiGBCaOHwBAAAA+ +vh7m2HpFe/67mBnAAA3ypBEAAIUlARSMuJG4pBkAAJwZQAMd8P+7EvKkEQIAhSUBFJa9mL2NupG6 +pBmAAJwZQAMkgBCBnrgQoQvwlL2WvZwZQAMkgBCBnrifuBChlQUP/OB48cAiDS/8A9jPdoAABCog +hkB5gOBt8iCGYHkE2IDgafIghmB5ANhnuIvgCvczJgBwgAAwYkAnAXIUeQB5ANhC8M9wgAAMKiCA +YHkB2IDgAdjAeDjwz3WAAAwqIIVgeQHYgeAR8iCFYHkB2IPgC/IghWB5AdiC4AfyIIVgeQHYgeDe +9QHYHvDPcIAADCoggGB5AdiF4AHYwHgU8M9wgAAMKiCAYHkB2IHgAdjAeArwz3CAAAwqIIBgeQHY +g+AB2MB4geAX8iCG63VgeQDYGnDPcIAADCoggGB5Adi4cDfYCiHAD6lylNuxAm/9CiQABJkED/zg +ePHAMgwP/M91gAAQqSAVgBCB4M92gADgBgn0AN+2CeAL6XAC2AOm5KYD8AHYBaaKIMwIQgvgAyiF +YQQP/M9wgAAQqSiAz3KAAOAGL3iB4AX0AtgEogPwAdgFohkD4AOKIMwI4HjxwM4LD/zPdYAANAgA +hYHgDvIKIcAP63LPcAAAhyeKI0QGSiQAABkCb/24c892gAAwCECGguLMIuKByiHCD8oggg8AAIgn +yiOCDwAAGgHKIsIH6fWC4jj0z3GAAPoHYInPcYAAUsWEKx8AMiFBDlEhAIAJ8s9xgAAQqSARgQCB +4Q/0GLoQuAUggQCFIQwAggrgA4ogiwAD2ACmAN9D8HIK4AOKIMsIIIYAhRi5ELgFeYUhiABaCuAD +iiCLAALYAKYApTLwz3GAABCpIBGBAIHhAN8s9M9xgAD6B2CJz3GAAGDFGLqEKx8AMCFBDoDhELgF +egnyz3CAAPwHAICGIDmPCfJPIgECCgrgA4ogiwAB2MTxTyLBAvoJ4AOKIIsACNgApuClEQMP/Iog +SwriCeADSHHPcYAA/AeKIEsJ0gngAyCBAIZAhRi4ELoFetvx4HjPcIAAKKQogM9ygADgBi94geAF +9ATYBKID8AHYBaKhAeADiiDMCOB48cBWCg/8z3CAAJASCoCA4A/yz3KfALj/HaLPcYAAfBwEgQHg +s7i1uLi4BKEWos9wgAAwCAAQBADPdoAANAgAFgUQTCQAgcwlYYDKIsIHyiCCDwAAiSfKI4IPAABT +AWgAYv3KIcIPz3WAAAgIAIUA2c93gAAsxQ8hAQDPcIAABAhAgCZ6IBeBEIHhQKAR9EAsAQZALQAE +JXhALAECBXmKIIsA9gjgA0UhQQEF2CPwwuHPcoAAuDgJggzyjCHCgQfyjCGCggbygLgG8EUgwAAE +8EUgQAEJokAsAAZALQEEBXlALAACBXmKIIsArgjgA4G5AtgApoogSwSeCOADIIWKIEsElgjgAyiH +z3CAAHwcAIBRIICCBvIA2c9wnwC4/z2gnQEP/IDgANrKIIEAEfLPcqAAsB8B23miz3KAAKQcSIJg +ggIjQgBwccIibQBCeOB+DcjHcIAAIMI0iAHhL3mE4TSoAxICNoz2z3ADAIQAoBoAAIogCAAGGhgw +C/CKIBAABhoYMM9wAgGEAKAaAACKIAQABQDgAwDZz3OgALAfAdpZo89zgACkHGiDgOBggwXyIntw +cIP3ANgC8Ehw4H7geM9yoAAsIHCCgOAK8gIjQgDXcgCAAAAG91BwhvcA2AXwcHB+9wHY4H7xwG4I +L/yYcKXBKHe4cwDeBCOAD/8AAAAYugV6b3kIuf/YCLhkeCi4BXlFeQjd9CSAAyd4RMAKD2ANEBQA +MRIUAjFhvUAoAQQFeUd5RMEQFAIxFCSAM4DlQLAB5in3UyXCBUCnABQNAQfZB/AQfRQnTBAAtGG5 +FCRAMLt7T70AkKV7geFwe3hgMvcEIIAPAAAA/xC4BXpApz0AL/ylwOB48cA2CAAA9ggAAAoJAADR +wOB+4HjPcYAAwCRAIQADVSHCBVBwRvcA2QQYUABQcL334H7gePHAmg/gBgDYTgsv/QDYz3CAACxd +JgwP/c9wgAAMXR4MD/36CY/+ug/ACADYCg8gA4DZFg4ADZ4IwAJeCIANvgrAAfILAAMA2FYI7/4I +cc9wgADIFQCIUSCAgAjyz3GgAMAdAIGguAChZgrAC0YMAAOuDKAB/9g2CYABiiCFDwhxxgzgBQhy +0cDgfuB48cASD+/7iiD/D891oAA4LseFB6XPcKAAVC4LgNO4BiYAcA8A///uCKAOFtmmCgACx6VN +B8/74HjxwNYO4AYB2IoKL/0B2G4NQA/RwOB+4HjxwOHFAN3PcIAAfAegoM9wgADsmqywBg9gDalw +BgkP/VoJoAypcIIPAAQqDo/9ogiAAYogBgoIcTIM4AUIcuoIb/ypcLYIT/ztBs/7ANnPcKAA7Ccr +oOB+8cBqDu/7A9nPdoAAyBXCCaAOyXCgjkQlQBGF4A30CiHAD+tyiiBHDXTbSiRAAKkEL/1ALQUS +AY6D4MT2Y7gBrsILAAGRBs/78cDhxaTBi3B+CaAOBNnPdYAAlBwAhQHggeAApQn0AdnPcKAAyBwx +oA4NIA8ocACFQiBAgAClB/QA2c9woADIHDGgegsAAVEG7/ukwPHAocGLcDYJoA4B2WILAAGhwNHA +4H7gePHAocGLcOIIoA4E2QDAUSBAgBgLIgfKIKIAAMBRIICAvAtCDADAUSDAgGwLQgcAwFEgAIF4 +CEIHRgygDQHYz3GAruAB7HAgoAHI7HEAoc9ygAAUmIokgX0A2aggAALwIkMA7HBgoAHhMgsgAQDY +ocDRwOB+8cDhxaPBAdhAwM91gADoFalwYgigDlzZrg+P/jqFG4UkeDyFBHmBwAIIL/9BwQHAO4UE +eUHBUgygA4ogWARVJUAffggv/6lxz3CAAGAXcggv/0AlARuLcIIJIAEE2cYIL/8BwACFgOAF9AWF +gOAcCgH/Dg+P/kkF7/ujwPHA4cXPcIAAlGMAgKLBQcCBwAHdHgigDqlxiiAXCu4LoAMBEgE2IcKK +IBcKBRSBMBC62gugA0V5QMWLcCIJIAEE2QEF7/uiwPHAocGLcOYPYA4B2QDAUSDAgS8kBwAAHAAx +DPIHEgU2CiHAD+tyiiDFAMkCL/0n24ogFwqOC6ADARIBNgYI4AFA2N4JAAEWD4AHocDRwOB+8cA2 +DM/7z3WAAFQcAoUjhQHeEHHAfqlwgg9gDgPZsgkAAYDmA/IChQLwAIV1BO/7A6XgeOB+4HjxwOHF +z3WAAGwcqXAaD2AOENkAFQQQTCRAgBHyTCTAgB/yTCQAgRPyCiHAD+tyj9iNuJjbNQIv/bhzAYUM +uAQggA8BAADwAaUL8CGFz3CAACg4IKAjhc9wgAC+FCCoA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4 +nbifuOxxAKEBEgE27HAgoFYJIAEB2OUDz/vxwOHFANnPcoAAfBwgoiGiIqLPcND+AAAEogAWDUCg +ogAWA0D/vWGiABYAQAAWAEAQ8v+7QNjPIOIHyiCBDwAA0ADPIOEHz3GfALj/HaEG8M9wnwC4/z2g +A8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoMoIIAEB2A4MwAJZA8/74Hjx +wAAWAkChwUDCARSAMFEgAIAG8s9xgAB0mgXwz3GAADyqQKFgiQHaB/AAFgBAFSGMAACkAeJ9eBBy ++fdRIwCACfIAFgBBA/AA2BUhjAAApAHiheK69wPM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7js +cgCiARICNuxwQKBuCCABAomhwNHA4H7gePHA4cXPdYAAUAipcG4NYA4I2QCFz3GgALgeAqEBhQOh +yg/AAKECz/vBB8AA8cCkwYtwSg1gDhDZA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEB +EgE27HAgoADAUSAAgAPABvQCwdIOIAEA2gXw0gmgAgHBtg/AAKTA0cDgfgkAAAAFAAAA8cBeD8AA +ZQYADOB48cDhxbTBi3WpcBYNYA4U2QDAhuDMIOKBBvTiC2ADqXAIcSTwguAH9LoMYAOpcAhxHPCB +4Ab0Pg5gA6lwCHEW8IPgzCAiggf01gpgA6lwCHEM8ITgBvRWDGADqXAIcQbwieAe9IohhAADzNdw +AAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HIAogESAjbscECgBg/gAChwmQHv+7TACiHAD+tyfNiN +uHfbi7tKJAAAeQfv/AolAAHgePHA4cWiwYt1qXBeDGAOAtlGDmADqXCGDsAAXQHv+6LA8cDaCM/7 +ABYQQKHBTCCAoMohxg/KIsYHyiCGDwAAjwzKI4YPAACMBcokBgQgB+b8yiUmAAAcADSLdalwNg3g +AATZiiDMCtoPYAMKcYQoCCkvdwAnjh+AAEim+gggDQRuz3CAACyoGoAScBHyJBaAEIDgJPKpcATZ +mdoe2z4IYAsYuwDYJB4CEBjwx3eAADymC4eBuAunz3CAAOAGL4CA4QHaBfJEoATYBvAA2SygSaAk +oAXYLg6AA4UA7/uhwOB48cDhxc9wgACkHCSAIIFSD2ADiiDMDc9wgABEJQCABCC+jwDAAAAJ9M9w +gAAkpACIjCDDjwTy8g5v/QHYz3WAANSiqXBCC2AOUtkODsAHo4WKIEwOCg9gA6lxYg3AAIogjA7+ +DmADatkGDiABqXAIcc9wgABEWZIIAA3+2c9wgAAkpBUA7/sgqPHAz3CAAMSo9gpgDg3ZJg3AAGIJ +wAbRwOB+4HjxwGYPr/uKIMwOosGuDmADiiEFBotwzgpgDgLZAxSRMEwhgKCP9gQUhTAKIcAP63LP +cAAAhAyKI4UJsQXv/AokQAQCFIAwz3aAAOAGhCkIKS93IB4CEM9wgABgpvlgLIlAIBIDgOEAFBQx +ACDTAxzyiiBMDUYOYAOKIQUMiiBMDToOYAMqcbYKoAFCJIAhAdgRtv/YIR4CEEAmABhyC+AABNlr +8ADYEbYhHkIUz3WAAEykQCUQEv1li3CpcU4M4AsC2kAlABLiCWAOQiSBIQAngB+AAEykCBAFAM9w +gAB43wWAUyVBBRBxyiHGD8oixgfKIIYPAACFDMojhg8AAIQB6ATm/MokRgTeDeAHKnBKJIBwANmo +IEAEhCkICS9wMiICIIDiCPIIFQUQMCAEIAwkQIEm8gHhQCYAGNYK4AAE2QHZDBtCIIcVABaAuIcd +GBDmCqADKHCKIEwNYg1gA4ohxgiKIEwNVg1gAyKFiiBMDUoNYAMqcUUGr/uiwAohwA/rcs9wAACG +DGEE7/yKI8YFABYAQIEDwADxwOHFz3WAACDEqXA+CWAOA9kBhc9xoACAJQyhAoUNoQCNUSAAgADY +jrgE8g+hA/AQoU4LwAAlBo/74HjgfuB44H7geOB+4HjgfuB44H7gePHAjg2v+wTZo8EA30LHnglg +DotwPti+DGADARIBNj7YsgxgAwQUATE+2KoMYAMGFAExA8zXcAAAAEAB2MIgCgAXuAAggQ8ADgAA +BhQAMRt4E+AEIIAPAAD8/yV4nbifuOxxAKEBEgE27HAgoADB7HAgoAQUATHscCCwBhQBMexwILAG +FAQxUSQAgA3yARIFNgohwA/rcs9wAABPJmUD7/xp2wHdz3EAACIiKgxgAz7YPgogBKlwAsEleELA +AMBRIACAyiWiEMohgg8AADMzBAxiA8ogog/PcKAALCBAEBAAAvAB5wYUADEQd4AACgCC5QQUADGC +xhb0G3gQeMlxBgsgBKly7HEAqQQUADHJcRt4AeAQeO4KIASpcuxxAKkI8Mlx4gogBKly7HEAsQQU +ADFAIEUAz3CgACwgEIAvJUgBAiAABNdwAQCghpoH5f8EHEQxCBQEMAohwA/rcs9wAABQJqEC7/yM +23YJAATPcKAALCAwgD7YXgtgAwIhAQQ/2FILYAMCwe4J4AACwGUEr/ujwOB48cAAFoVApsFMJQCG +ABxCMUT2TCUAgk32CiHAD+tyz3AAAGYZldtJAu/8SiRAAAAWgEABHAIwABaAQAIcAjAAFoBAAxwC +MItwQgjgBoHBAsKA4g/0ABSFMAohwA/rcs9wAABnGZ/bCQLv/Iokww8EwGB6BcEDwYDhC/QKIcAP +63IAFIUwz3AAAGgZo9vt8QHAgODjIEIAyiAiAAIJwACmwNHA4H7xwM9wgADIM7oOIA4J2QINgAUi +CYAFigmABd4IwADRwOB+4HjxwM9wgADMNZYOIA4H2cYIwADRwOB+4HjxwKXBi3CCDiAOBdkAwFEg +AIAV8s9wgABEHgOAGIiB4A30ANiauM9xoADIHw+hAcCkGQAAw9gauA6hggjAAKXA0cDgfl0DoAYA +2OB48cDPcIAAMDj2DSAOKNliCMAA0cDgfuB48cDhxQAWAECC4M91gADoFwClH/QA2c9wnwC4/z2g +HNkV8M9woADIOzaARCECBzaAhiH/CCV6NoCGIf8IRXnPcqAAqCBNguTikfeA4ev1CgjAACCFhOFe +AA0AMyZBcIAAYGJAJ4ByNHgAeDgQBABYEAUACiHAD+tyz3AAAJkhrQDv/C/b0gqgA1TYUSBAgBPy +z3GAAGQ4AIGBuOYLoA4AoQnwnglv/gHY8g2AAwPwug3ABIECj/vgePHALg8ACZoPgADRwOB+4Hjx +wJINoAkA2M9wgABEHsgQAQbAuYHhAdnAecoPYA48EIAA0cDgfuB48cDhxc91gABEHgCFxBAABlEg +QIEN8gohwA/rcoXYjbiKI5wPSiRAABEA7/y4c9IMQAv2CSANAdjPcIAAjCEIiIfgHvQBhcQQAAZR +IECBGPImDQ/9z3GAAHjfBJAlgQq4MHAO8gohwA/rcobYjbiKI10CSiQAAMUHr/y4c7ILj/wGDCAM +ANj6D0AD3g6AALUBj/vgePHAMg6gCQDYLg+P/M9xgADoswKJEg9gDiCJ0cDgfuB48cCiwYtwPgwg +DgjZAMCA4M9xgACsOAChB/IGFAAxA7EEFAAxArGODoAAosDRwOB+8cDeCK/7gdihwWDAANgBHAIw +A8zPdoAAMAgCHAQwiiCLBwYIYANk2Yogiwf6DyADIIaKIIsHz3WAADQI6g8gAyCFz3CgACwgQBAR +AACGgOAP8s9xgAD8BwCBgbgAoc9xgAC4OAOBAeADoQHYAvAC2BpwAMAuCu/7CnHPd4AAuDgDEgE3 +XpeB2GCGog2gDgokAATPcKAALCAQgEAfQBRMIICgEadIHwAUUvIAhojgGfTPcIAAAFymCMAMeg4v +/hTY0gggBQTYIIZAhYogiwAYuRC6Vg8gA0V5ANgApgClheAD8gDYBfAAhYTg/fUB2C8mB/AP8ooP +oAMU2IDgCfTPcIAA5FsmgCOBIIHGCMAMAIaA4ATyANgG8ACFgOD89QHYLyYH8AX0sgrAAoDgEPKK +IAsA9g4gA5/Zz3CAAPwHAIAvKAEA8g8v/U4gwAfxB2/7ocDgePHAig9v+4DYocEDEgE3YMDPc4AA +MAhgg891gAC4OAIcRDAvpShySiAAIAEcAjSqDKAOCiQABM9wgACQJBAQBQBRJYCADPQAFAQwCiHA +D+tyz3AAAHYnrQWv/Gfbz3CAADAIAICA4JQCAgCeCEALgOCIAgIAz3CAAMw1AIBRIACBeAICAIog +Cg9KDiADARIBNiYIgArPd4AA+gcAj4QoHwAAIYB/gABQxRYKIA6KIQsPYI8KIYAvgABsxYQrHwAA +IYJ/gABQxQWShiB/DBx4UyCAgAj0z3GAAPwHAIGGuAChAopRIECAaPSEKx8AACGAf4AATMjKCSAO +GNkAj4QoHwAvcDQhDSBCJQQWjCQHgc33CiHAD+tyz3AAAIEnkNvlBK/8iiUHAc92gACIyNhgkgkg +DohxAI/PcYAADAiEKB8AMiZFHgAmQB5MJQCAAKEN8gohwA/rcs9wAAB3J5XbpQSv/Iokgw+hiM9x +gAAQCEAlhRBMJYCIQCWCH0CpzPcKIcAP63LPcAAAeCeb23UEr/yKJIMPz3GAAAjFtgqgC6hyAI+E +KB8ANCFBLs9wgAD4ByCwIPAcEgQBjCQIgMz3CiHAD+tyz3AAAIsnpNs1BK/8iiUIAIQrHwAAIYB/ +gABMyN4IIA6Icc9wgAAsxSAYAAQA2TPwABYCQIQrHwAAIYB/gACcyzDgNXhAoAAWAkEAIYB/gAAc +zDDgNHhAsAAWgEAAIY1/gAA8ylJpVHq6YhCqEaoSqgAWgEAUqhWqFqoAFgBBACGCf4AAWMw1ehqy +ABYAQQHhG7Jgj4QrHwAAIYB/gABQxUOIUHGMB+X/L3UAJYEfgADMywAlgh+AAEzMHg2AB5YML/4U +2PIN4AQE2ECPAcjPdYAANAiEKh8AACGBf4AADM0Aoc9wgAAwCCCFAIAQuRi4BXmIuRoMIAOKIIsA +AdnPcIAAMAggoAAdABSCDq/7AMDCCMACgOBIC8IOAxIBN89zgAAwCGCDgNgocuoJoA5KJEAAI/AE +hQHgBKXPcKAA1AMckE4IQAEAwEIOr/sC2QMSATfPc4AAMAhgg4DYKHK2CaAOSiSAABIP4AoC2Iog +Sg+eCyADANmxBG/7ocDxwAohwA/rcs9wAAAwJYojjAeKJIMPrQKv/EolAADgePHA4cUg289xoADI +HGmhABYAQM9yoAAQFAyiABYFQAHdTCUAgMohwQ/KIsEHyiCBDwAALCXKI4EPAAAJAWQCofzKJEED +GBpAAWgZQAED2A+iuaFqoXoJgABRBE/78cDhxa3Bi3WpcDYP4A0N2QDAHXhTIAEARCk+DalwACGB +f4AAiNVCCaALDdpGCYAAHQRv+63A4HhZBaAOANjgePHAlgtv+4ogkg2swcoKIAPF2Ytw6g7gDQzZ +ABQAMYDgL/TPdYAABCoghc92gADQLmB5ANiM4EAkjzAR8iCFYHkA2JDgC/IghWB5ANiR4AfyIIVg +eQDYkuAF9OlwyXEY2gTw6XDJcS7a6g9ACwHYYB4CEBeGgOCIDaH7yiAhAAAUADGB4Bf0iiDSDU4K +IAPe2UAkgDDPdYAA0C5AJYEbtg9gCy7aAdg3hWEdAhCB4VANgfuCCIAASQNv+6zA8cDOCm/7F9m3 +wToO4A2LcCPASiJAIFMg0ACGIP4DTCAApEIoEQEMHAI0j/YKIcAP63Jy2I24iiMPAwokgAQNAa/8 +CiUABEgUBTAgwEAojiDPdYAAENfWflEgAIDAZUEtTwPAv75mhiD3D170gOAN9AohwA/rcnPYjbiK +I88EzQCv/AokAASKIE8FCnH6DyAFqHIBwALBCnKuDW/7Zm6A4D3y6XCyC2AOCnENFIAwhSDBAA0c +AjCKIP8PU8AAhqm4AKYSwIYg+w8ouA+uSiQAdADZqCAAA//auGFAKIMgdnsS4HhgQKgB4Qpwygpg +Dotxz3CAAEQe8CDBA8ARAAYPIAAEwBkYAA+OgeAH9IDnzCCio1wOgg4B3wLwAt9eCmACCnAH8IDg +yieBFMonIhKB51ACAgAghs9wgABEHgOAGIgodYHghiX7HxHylg2AAoDgIIYa8s9wgACMIQiIh+AU +9EEpQANRIACADvITwOi4EsIK8oYi+w9BKgQCT46QcgTyqLhTwBPAEsIGeUR4JXiA5QCmhiD7Dwvy +gODKIAEEyiEhALwNoQPKIuEDDh5CFADYz3GAAFDaFiEBBECGAKH1ugGhBfQA2Iu4AaH2ugXyAYFF +IAAGAaGGDK/8i3ANFIAwUSBAgSHyWBQAMQW2WhQAMQa2BZaA4BnyIg2AAoDgEPIGllEgQIAJ8qYO +b/wKcPYNgA4F2BKuANgFtgfwCnAA2T4NoAMP2g0UgDBRIECAfvJQFAUxApYe2i8hSgEweSR4LykB +AAIiQAAQeEAoASEleM9xoADAL6IRAYYQeBDwLy1BEAIiQwMA3Q8lzRCmec91gABg1fQlzRCxcAjy +gOHx9c9wAAD//wfwcHjPcYAArKpksddwAAD//zDyz3KAACDUtGi7YgQTBAAjgwUhPoEm8s9xoP4Q +B892nwC4/zamz3GgAMAvFXkqEQCGFhEAhqBiCiHADxamAYPrchamAoMWpgODFqYEEwQADBMFAJHY +jbhZBm/8iiOSB0wlAIAEHkQRFPIA3RDYOnAClhEgQIPKIAIEyiFCA0gMogPKIkIDQiFAIIDgAeUx +9w0UgDBRIACBBvIKcCoJIAFVFIEwDRSAMFEgwIAb8jXBVhQCMQpwOgsv/RLDjCACgLhwDfQKIcAP +63J02I24iiOSD+EFb/xKJEAAUSXAgconIhF+CmAOCnADzNdwAAAAQAHYwiAKABe4x3AADgAAg7id +uJ+47HEAoQESATbscCCgEg1gAOlwfQcv+7fA8cAODy/7iiBTCaTBAN2pccIMIAWpcs92gADQ3gCO +SiRAIKGuAh4CFQHgAK6jrqGmoqakpqWmuK65rgHAuq4CwQemA8AopgmmAdgeDuACqXGBwD4K4A0B +2QHAB6ZadbjwgsAuCuANAtkBjgLBAd/jrgHgAa4DwCimCabpcOoN4ALpcQLAi3K6D2/7A8EEIAAF +LyQHIALZAq4AwCOuAabKDeAC6XBMJACgkPIAwc9ygAAQ10ojACASaRZ4AGIPI1MgLbhTIBAAiiBU +BQoMIAUKcs9wgAB8BwAQEQAvJcokz3GAAHwH+K4EJUAkAKED2SOuEB7AFBQeABQIHkAUA6ZqDeAC +6XDPcIAAfAcAgIDgDvRMIQCgCvK+DqAEINgE2SOu+a5GDeAC6XAF2SOuOg3gAgHYIMB2D+AAENkA +wAK4FngAIIEPgAAQ16KxiiAIAAChBtkjrhIN4AIB2ADAANlOCqADD9oAwIDZArgWeMdwgAAQ1yio +KagH2SOu7gzgAgHYz3CAAEQe8CACBM9zgABQ2sASAQYEIUAFwBoYAADCANnPcIAAcNZWeyCjIaNU +eNYKoA6gsIDgCvJaCoAOCNkjrvqupgzgAgHYQCJSICHAUnCQBs3/Cdkjro4M4AIB2APM13AAAABA +AdjCIAoAF7jHcAAOAACDuJ24n7jscQChARIBNuxwIKAyC2AAinAK2SOuVgzgAgHYSQUv+6TA8cCK +IFULANmuCiAFKHKqDkALlgpAANHA4H7gePHA4cUAFg1AA8wB2tdwAAAAQAHIwiKKABe6x3IADgAA +rg9gC1MlARBRJUCQz3GAAGQ7AdjKICEALQUv+wCh4HjxwKHBi3ASCOANAdkAFAUwTCUAgAv0CiHA +D+tyidiNuEXb/QJv/EokQADPcYAA9MEDGUIBQC2AAwKhSiTAcADaqCBAAgDYDyCAAAsgQIEE9AHi +BPAOuAGh8glAAKHA0cDgfuB48cC+CkAHz3CAAEQeLBCEAEwkAIEJ9MkQAAZRIECBBfK+DsABEPBM +JECADPLPcIAAjCEIEIUATCXAgcwlYoIG9NYPT/vRwOB+CiHAD+tyz3AAAOwcZQJv/F/b4HjxwNYL +D/sAFhJBABYAQc9xgAAQ10AqgCAWeDAhBQCiwUwiAKRBLUADUyATAI73CiHAD+tyddiNuIojGAJK +JEAAHQJv/EolAABRJUCCDPIKIcAP63J22I24iiNYAgECb/wKJIAEz3CAAFDZFiCABBpw5g6gDQLZ +z3CAAPDVFiCABNYOoA0C2UAqlSEAJYAvgADQ2sYOoA0Q2Ytwvg6gDQHZACWAL4AA0NrSD6AGENkB +EIAgkOCO9gohwA/rcnfYjbiKI5gKSiRAAJUBb/wKJYAEAN0Q2DpwFSVAI89xgADQ2jAhFAAEJIKv +AAAAAQQcADVN8kQkDiYjvgHmBCSALwYAAAAxuCHB32Cg4dEk4aI68oDiBPKB5gv3BCSELwAAACQM +JICPAAAAJCzyguBUAA0AguAG9IDiJvKC5iT0gOIF8szhQAAJAM9wgAAMKiCAYHkG2BB2FvfPcIAA +RB7wIMAEwxAABgHZBCC+jwAGAAAEJIAvAAAACMIhQQAruBBxRPcA2APwAdgPeAPwAd/pcAQkgS8B +AADALrnPcoAANHIpYjB3AdnCIU0AgODMISKAGPJCIUAggOAgB+3/AeUCEIAgz3GAAHRnCGGB4Bzy +CiHAD+tyediNuIojGQAy8QohwA/PcIAARB7wIMAE63KKI1gPwxAEBnjYjbhlAG/8CiUABQMQgCAI +YYLgCfIKIcAP63J62I24iiOZAhLx8gwgDkpwz3CAAPDVFiCABCCQz3IAABgVCSGBAFYPIAAgsOkB +L/uiwOB48cAAFoFAz3CAACheIKgAFoRAABaBQM9wgAAxXiCoABaAQFAkvoHKIcIPyiLCB8oggg8A +ANoUyiOCDwAAgQfcByL8yiUiAM9wgADYBgCQgOAF8uoNwA3uDMAN7g4AANHA4H7gePUHYA0A2OB4 +8cBCCS/7ANlKJABy4HioIIACABYCQBUiQDAOGJgAAeEAFg1AABYOQEYNgA3PcKAAFASsoM9woADU +C9ygng4AAG0BD/vxwPYIL/sI2aLBARIONs91oAA4LhwVEBAODKANi3AAFAQwAN8EJL6P8P8AAMoh +wg/KIsIHyiCCDwAApijKI4IPAADhBiQHIvzKJcIAUSRAgsohwg/KIsIHyiCCDwAApyjKI4IPAADk +BgAHIvzKJcIA56UCCKAOP9gAwAQUATEHpX4KoA2CuRwdABQODiAAARqYM8kAL/uiwPHAANhqDSAA +BBKBMAQShTAKIcAP63I42IojDwG1Bi/8SiQAAPHA4cXPdYAAJCqpcIAgBw9aC6ANBNkuDEACgOAH +8s9wgACMIQiIieAO8gohwA/rcs9wAADUG37bSiQAAHEGL/wKJQABz3CAAEQeIYDEEQAGUSBAgcoh +wQ/KIIEPAADWG8ojgQ8AAH8AyiLBB+bz/hUAF4Dgw/aO4Mn2CiHAD+tyz3AAANcbgNvY8cgRAAaG +IH+OBfRSCEAAD/AAhZK4AKULyK64r7gLGhgwC8iHuAsaGDDWCw/7Jg0AAP0Hz/rgePHAfg/P+s92 +gAAkKgCGz3WAACArUSBAggXyDgxAAoDgI/IA2AitAdgJrVUmwBi6CqANC9lVJsAYVibBFdIMIAsL +2giNz3eAALAqRCg+CwZvMiBADoHgAdjCIAEACq0Ahom4AKYU8AiNKY0wcAX0TiBBAC95Ka3Pd4AA +sCpVJsAYRCk+CydwYgqgDQvZaY0Db0QrPgsyIEAOiuDKIckPyiCJDwAA0RvKI4kPAABqAaoAKQDK +IskHguDKIcsPyiCLDwAA0hvKI4sPAABsAYoAKwDKIssHgeAB2dP2QiBEAAokAHEocKggQANEKz4L +ACdBHhV5RokiiTByJ/IB4A94hgpAAoDgHfLPcIAAjCEIiIngB/KI4BX0AIZRIACCEfQWCo/8guAF +8g4Kj/yB4An0z3CAAOBcBoADgACABglP/d4LAAClBs/6CiHAD+tyz3AAANMbiiNFDEokAACVBC/8 +CiUAAeB4nQbgBQHY4HixASAJAdjgePHAsgpgAuHFgODPdYAAJCoO9AQVBBAKIcAP63LPcAAAvhuK +IwYEVQQv/LhzAIWIuAClVSVAHj4JoA0F2fcVgRDPcKAAyBwagAq5yrgVeDhgmSAKAEQdGBDPcIAA +jCEIiIfgJfTPcIAARB4AgMQQAAZRIECBG/LsFQARz3GAAHjfJYEKuDBwyiHCD8oiwgfKIIIPAADE +G8ojgg8AAJ4ByiQiANgDIvzKJcIAlgjACroNYAwC2LoPz/sOCKALANgCDMAC5goAAL0Fz/rgeDkC +IAkB2OB45QNgDQHY4HjpBiAOAdjgePHAocEA2UDBABYCQAAWAECB4hryA8zXcAAAAEAB2MIgCgAX +uMdwAA4AAEUgAAOduJ+47HIAogESAjbscECg7HAgoB/wUghgBotwA8wB2ddwAAAAQAHYwiAKABe4 +x3AADgAAhLiduJ+47HIAogESAjbscECg7HAgoADC7HBAoIoKIAAocKHA0cDgfuB48cCaDO/6AtnP +d4AAQF6mCKAN6XBAh892oADsJ891gAAMKuC6S/IrhkQigACGIv8OIrqhuRS6tLkFIIMAZXkrpgQg +gA8QAAIABCKCDxAAAgDPcYAAAAZFeAuhIIUE3mB5yXCH4AvyIIVgeclwhuAH8iCFYHkB2IHgEfQA +h89xoADIHFEgQIAH8gHYHqEqD0AGBfAA2B6hjg4ABiCFYHkB2IXgNfQAh1EgwIAx8s9woABEHcWg +w6DEoCnwz3CgAMgcAdk+oAuGgbgLpu4OQAYghWB5AdiF4BP0z3CAAEQeA4AIgFEgAIAL8gDZlLnP +cIAAAAYroAuGlLgI8M9wgAAABgDZK6ALhrS4C6YuCQAA9QPP+uB48cDPcIAAuBOWD2ANAtkWCQAA +0cDgfuB48cByC+/6ANoIdSh2z3CgANQLOIBCIQEIgOHKIYwAQCYAEhBxkAwFDgPM13AAAABAAdjC +IAoAF7gAIIEPAA4AAAduBCCADwAA/P8leJ24n7jscQChARIBNuxwIKAivgbw7HEAoQTlYb6B5gCF +OvfiCAAAbQPP+uB48cDhxc9yoADUCwPdsaIA23CiAxICN9dyAAAAQAHawiKKABe6x3IADgAARSIC +Bp26n7rsc0CjAtoUGoIwBRIDNuxyYKILEgI3AeILGpww7HIAogESAjbscECg7HAgoM9woACwHwHZ +OaDPcYAApBwIgUCA7HBAoAyBAIBeCAAAz3GgAMg7DoGIuA6h5QLP+uB4A8zXcAAAAEAB2MIgCgAX +uMdwAA4AAE8ggQCduZ+57HAgoM9woAAUBAPZJaABEgI2z3CgANQLTaDPcKAARB01oOB+4HgD2s9x +oAAUBEWhz3GgANQLDaHPcKAARB1VoOB+A9rPcaAAFARFoc9xoADUCw2h4H4D2s9xoAAUBEWhz3Gg +APwLDKnPcKAARB1VoOB+4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geM9zoACoIDGDz3KAAMAk +A4I4YAOiAdgSo+B+4HjxwJoJ7/q4cc9wgAAsqGgQBABKIAAgTCSAgMoixgfKIIYPAACRDMojhg8A +ALcH4Afm+8ohxg/PcIAA4AYHgIQsCAkAIYF/gABMpEwlAIAWeceBPvTPcIAASCX2D2/8iiEPD89w +gADcJOYPb/wg2c9wpQAIDKCAUyVNkBPygeUT8oLlFPIKIcAP63LPcAAAkgyKI58HmHV5B+/7CiUA +BP/YBvD/2Ai4BPD/2BC4z3GAAAAGDKGtoc6hANmRuc9woADQGzGg1gmgDAHYH/DPc4AAAAYOg4Dg +G/TPcYAA0GjPcoAASCXPdYAAwCSKJMN/CnCoIMACD2EVJcMT54PwIg4AAeD+Zsej+QDP+jgTBAAK +IcAP63LPcAAAkwyKIx8M8Qbv+wolAATgeOHF4cbPcKAAFAQD2SOgDcjPcoAAFMNhks9xgAAEwsSK +FCENAGi1ACCDD4AAJMI44cCrYoIVeQaSYKEDEgM2wB0EEASCoBMBAIYhww8leKAbAADBxuB/wcXx +wCIIz/oIdhoMIAIodYDg0SVikwHYA/QA2AS4z3WAAJjfFHgJZYHhHWUK9MINYAypcN4Jr/0BjQDY +AK0BhVEA7/oApvHASggACa4NoAsA2M9wgACMIQgQhABMJMCBE/JMJACCFfJMJECCGvIKIcAP63LP +cAAAyhu72xUG7/tKJQAA7g1P/IYMAA7RwOB+z3CAACQqAIBRIACCBfSeCs/79fE+C0/8Cg5P/AvI +rrivuAsaGDALyIe4CxoYMKoLz/rl8eB48cBeD4/6z3GAAIwhDJHPdYAARB7elQ4mDpDPcIAABCwO +kMomYhAMsQHYSg4gAADZggxgCAHY2gpP/IHgGPQAhcQQAAZRIECBA/KA5hDyAdgIcc4IL/0IcgvI +kLgLGhgwC8gFIIAPAAAA1AnwC8iuuK+4CxoYMAvIh7gLGhgwJgvP+kkHj/rgePHAvg6P+g0SATbP +d6AAvC3PcIAARB4upwSAAN1GEBEBViBSBFYgkwQNEhA3ViAUBUYgwCADEgI2DRocMKQSAACEuKQa +AAABkqLBgOCGGkQDCPLPcIAABMP0IEAAgOAJ8gGC7rgF9FAgACAvIAggUyB+oEoDAQDPdoAAZDtp +FgAWAeAEEgM2aR4YEKQbQAMBkoDgSvLPcIAABMI0eIAQAQeA4UL00BABAVMhwYAU9HISAQHgkiJ/ +uBKBACJ/8H/gGMQDpBIBAIYh848G8mi/8H/gGMQDcBIPAeAQAAEhkuJ48XDCJw4QwiHOA3QSAAE4 +YLgSgQB0G0QDoLM4YBB4kBsEAL4bBAAQihCrAYIBowiKCKsSigDaEquWujLw3g4gAoogBQEPh/e4 ++vNPh/a6UyLAAibyjuBJ96cWABa2ugHgpx4YEBzwZLgEEgE2EHiQGQQABCKADwAAAPAsuHQZRAOg +sRCpobEDyL4ZRANhgKiphiP/DYS7YaESiBKp9ro+AgEAANiWuPW6BBIBNqQZAAAS8gIPb/4A2AQS +ATakEQAABCCCDwIAAAAtugUiAgQvIIggQPABgVEgAIFS8jTKUIlJIMQA8mrPcIAAENf2f+Bg9rhy +iQfyz3CAAFDZVngBiALwANgAJI8PgABQ2VZ/5I8II8MDCCMAAEkgwwMWanV4z3OAANDaAGPPc4AA +UNpWe0GDz3OAAEQeZIN4g2V6BCKCDwAAAAhGeJgZAAAA2Ja49LhBgYYi/w0f8oDiUvKYEYIAQCIA +KUhgz3OAAFSqQMAgwsO6XHr0I4IAVvAKIcAP63I02Iy4X9sFu4okgw/VAu/7SiUAAJgRAwDpu5wZ +QAMj8oDigLikGQAALPKYEYAAz3KAAEQeQ4KGIP8DRLgyJAAgibhAwCDDVIJkeoYj/wOGIv8ORLt6 +Yk96z3OAAPBn9COCACDwUSMAggrygOIK8pgRggBAIgApSGAN8IDiBfQA2khwEPCYEYAAw7gceDIj +ACBAwCDCz3OAAPypw7pcevQjggCIGQAAmBEAAIQZhACQEQEBrgggAADaBBIBNgMSDTaEEQIBghkE +AM9zoADIH1hgEHiwGQQA+BMCALAVDxFCf89ygABEHkSCACHRI1QSBAEAJE8EH2egEwMA8H9wdzgA +DQBQgpgVAxALIsCAFvQwiVCNMHLRIyKCFvKGI/8JI7sB44Hj0PcCus9xgAAQ11Z6QWHxuQjyuBYA +FgHguB4YEA3wgHAQeIYdBBBqFgAWDRocNAHgah4YEFkDr/qiwKHB8cAGC4/6CHVGwOi9KHDQACEA +SHYDuEAgkAVEJQIWI7oEJY8fBgAAAAHiQS9AFAQlgR/AAAAAWGA2uc9ygAAAcqlzxrspYghiOGBB +LYESUiEBAMC5A7kY4YXgyiGNDwEAiQ3VIQ4ALyFIIAQlgR8AAAAYz3CAAIBq13EAAAAIHgAiAPAg +wAAmwaDhEgABAM9xQnvQXgUofgAKIMAOCnEFKT4ACiDADoDnJLgB4AXyUyABADhg7b0CKYEjD/LP +coAAvGtAkgUqPgAAIYB/AAD/Py64XQAgABlhWQAgABV5USVAklQAIQAmxbflIAALADNoUyUCEM9w +gAA4aPAggAAFKT4ACiDADgHgB/CK5cAo4QDAKKIAz3GAAEQeI4HA2jSBpHmGIf8OIrk6etp6GWIw +eAjcNwKP+jNoUyXAEBx4z3KAAABs8CIAABbhBSk+AAogwA4B4BTZgwfv/9p54HjPcYAApBwkgUEo +ggXVuCCBQSmDBdW5AnnPcIAAeN9iegWAyboFKL4AJ3HPcIAALF0DgACA4H84YM9xgACkHCSBIIFB +KIMF1bhBKYIF1bkQcVtjSvfPcoAAeN9FgllhAnkB4wPwAnlAK4AFmQfv/yV48cDWC4/6Ogmv+lDZ +RcBKIAAgDg0v/obFTCAApQQVARRO9wXA13Gt3u++FSAABCCgQCBQIPL1JNxrAY/6CiHAD+tyz3AA +AIsTiiMHC5hzZQev+wolAATgePHA4cWC4JhwuHHK9wohwA/rcn3YjbhFB6/78NvPcIAARB7wIAEB +iiMLDUwlAIBAIQIGeGIm9KiBemKgokmBQaBciUioXYlJqCoRggBKqCsRggBLqCwRggBMqE2RR7BX +kUiwSIEEIoIPAAYAAIDiAdrAelKoVJFTqCiBwLktqBzwTCVAgBr0YmJIoUGASaFIiFypSYhdqUqI +KhmCAEuIKxmCAEyILBmCAFOIVLFHkE2xCJAXsa0Aj/oKIcAP63KQ2I24mQav+4ojhAfgePHAHgiP ++s92gAAkKlUWARZWFgIWMHKkwUj3iBYAEAIhgwB4YIgeABCA4Q7ygOIM9FcWABY4YFceGBBYFgAW +OGBYHhgQz3eAAJAGAIeA4ADdA/JYHlgTWBYAFkPCQMBXFgAWQsEQ2b7aQcCLcB7bjg/gCRi7Vh5Y +E1UeWBOgpwkAr/qkwPHAmg9P+s92gACMmgQWBRBCJUEAheFMAS0AosEyJkFwgAAYYkAnAHI0eAB4 +AtgApgHZz3CAAFAcILCiDKAJKHAChs91gAAUHCiFR4UIFQQQDyBAAAKmz3CAAPQbNXhAoBgVBREM +FQYQz3CAAHA0ANk0qM9wAADktkDABYUQFQcQQcAajTuNQIV+DaAKYYWKIBkBSg4gAjqNYfDPcIAA +UhwB2SCoz3CAABQcJ4DPcIAAWMEvoGoOL/0C2FHwBNgApgDYz3eAAFAcEgygCQC3z3WAABQcAoZI +hWeFDyCBAM9wgAD0G1V4YKAipuzYWgxgBECXCBUEEM9wAADkthgVBREMFQYQQMAFhRAVBxBBwBqN +O41AhfIMoAphhSQVgBBIhQDZUSAAgQSGDyGBAAnyAdvPcoAAcDR0qgV5JKYD8CZ4BKZ2CWAEANij +8eYND/wH8IogGQGGDSACIoapBm/6osAIFgQQCiHAD+tyz3AAAEIfmQSv+4ojRAfxwOHFiiAZAFoN +IAKt2QHdz3CAAIyaoKAA2M9xgABQHEILoAkAsbYMIACpcG0GT/rxwOHFANjPdYAAjJpaCCAAAKUu +DC/9Atgihc9ygABQHHfYfgtgBECSQQZP+vHAxg1P+gDez3eAAFAcwLf2CqAJyXDPdYAAjJrCpcOl +xKWKIMkAyXFKC2AEQJcB2P0Fb/oApeB48cDPcYAAjJoAEQUATCVAgYz3CiHAD+tyz3AAAEEfmdvd +A6/7iiSDDwGhz3CAADwc8CBAAUB40cDgfuB48cBSDU/6z3WAAIyaBBUFEEwlQICiwSXyTCWAgBDy +TCVAgWzyCBUEEAohwA/rcs9wAABEH40Dr/uKI0cGz3CAAFIcAdkgqM9wgAAUHCeAz3CAAFjBL6CC +DC/9AthQ8ATYAKUA2c9wgABQHCCwJgqgCShwz3aAABQcAoVIhmeGDyCBAM9wgAD0G1V4IqVgoHIK +YASKIIYLCBYEEBgWBRHPcAAA5LYMFgYQQMAFhhAWBxBBwBqOO45AhgYLoAphhiQWgBAB30iGANlR +IACBBIUPIYEACfLPcoAAcDT0qgV5JKUD8CZ4BKWKDyAEANiKIBkBogsgAjqOBPDuCw/8vQRv+qLA +4HjxwE4MT/rPdoAAjJoEFgUQQiVBAITh5gANADMmQXCAACBiQCeAcjR4AHgChs9xgAAUHEiBJ4EP +IIAAAqbPcIAA9BtVeCCgWfDPcIAAUhyA2SCoz3CAABQcJ4DPcIAAWMEvoHILL/0C2EfwCpaMIAKA +EfQA2M91gABQHBYJoAkAtSKGiiAFBHYJYARAlQHYAKYz8APYAKYx8AOGjCDDjwHfEvQA2M91gABQ +HOYIoAkAtSKGiiBFCuCmQglgBECVJgsP/BvwANkPIQEAAoYGIECAEvQA2M91gABQHLYIoAkAtSKG +iiCFDBYJYARAlfYKL/zgpgPwAqbBA0/6CBYEEAohwA/rcs9wAABDH7UBr/uKI0YA4HjxwOHFz3WA +AIyaBBUFEEIlQQCF4ZAADQAzJkFwgAAoYkAnAHI0eAB4z3CAAFIcgNkgqM9wgAAUHCeAz3CAAFjB +L6B+Ci/9Atgs8AKFz3GAABQcSIEngQ8ggAACpc9wgAD0G1V4IKAe8AOFjCDDjwHaCPIA2Q8hAQAC +hQYgQIAO9M9wgABQHECw8g9gCQHYA9g+Ci/8AKUG8AKlBPAB2AClEQNP+ggVBBAKIcAP63LPcAAA +RR/1AK/7iiNIC/HAggpP+gh2iiBZAbIJIALJcc91gACMmsOl2gzv/wXYI4XPcoAAUByg2AIIYARA +kr0CT/rxwEIKb/qKIJkBz3WAAIyaegkgAiKFz3CAABCpCIAA3ye4wLgTeMa4AeAKtQjYOnAA3gKF +DybOEwsmAJA38gSFCyCAgx7yxngEpc9wgAAQqSAQgACB4Bbyz3GAAHA0EIkB4A94EKmKIAoFIgkg +Aslxz3GAABCpCIGGIMMPgLgIoYogmQEGCSAC6XHPcIAA9BsVINADABAAIIDg4iACAAKFANkAGEAg +xngCpUIhQCCA4AHnfgft/+9/KpWB4c92gABQHACWC/SA4BD0ANnPcIAAcDQ0qIogCgQF8IDgBvSK +IEoEqgggAgDZAYWF4AjyAJaB4APYyiAiAcYLz/+lAU/6z3KAAIyaIoIA2w8jAwBmeSKiz3GAAPQb +ANoVeeB/QKHPc4AAjJpCgw8iQgBCo89ygAD0GzV64H8AouB48cASCW/6GXEIdoh1z3GAABQcGqkb +GQICQKEQGcABDBmAAaKhA8AYGUQBBMUHoSbAqKEkGQIAB8BhoQWhiiAZAg4IIAKpcVPYyXFyDiAE +qXImwFEgAIAJ8lfYyXFeDiAEqXIG2AXwgeYC2MogYgAWC8//DQFP+uB48cCOCE/6OnDPdoAAlBwA +hgHggeDPdaAAyB8Apgb0AdhRHRiQig9ADaQVEBDPcIAACC4mgM93gADMs2B5ANgBh4DgKvIk2BjZ +hg9gDTPageAO8gQXBRAKIcAP63LPcAAAdBmN26EGb/sKJEAEJNgB2V4PYA0z2oHgDvIEFwUQCiHA +D+tyz3AAAKsoktt5Bm/7CiRABKQVARCKIBgPOg/gAQIhAQQAhkIgQIAApgT0ANhRHRiQOQBP+vHA +4g8v+oogGA7PdoAAyDcOD+ABMobPcIAACC4EgIDgCfTPcQAArQv2DuABiiAYDj3wMobk4df2z3WA +AFReAIXa4FH2iiBYDtYO4AEI2UCFMoaKIJgOELrGDuABRXkI2Brw2uFGAAoAz3WAAFReAIXk4N32 +iiBYDqYO4AGKIT8OQIUyhoogmA4QupYO4AFFeYogPw7uDwANIIVIFgARELmqDu//JXgShgClpQcP ++uB44H7geOB+4HjPcIAAIDZAiOC6CPLPcaAArC8ZgYq4GaFRIkCAB/LPcaAArC8ZgY64GaHgfs9x +oADIOx2BgOAI8oLYFKHPcACAERQOoeB+4HjxwOHFtMGLdalwz3GAALRjkg8v+lDa1gvAAQoJ4AGp +cDUHL/q0wOB4z3CAAODDbIjPcYAA7JqMIwKACpFBKAIDDPLruAr0Art2e8dzgAAQ1wKTDyCAAAKz +ANjgfwyx4HjxwH4OL/pUaIYi+ANPIkMCUyHCAAUixADPcoAAcNYUeo/hiiMPDMogKQAJ9gCSAN0P +JU0QiiPPD6Z4ALIA2UokAHTPdoAAxJ3PcoAAPJ7PdYAAQJ6oIMAEFCJAAOSQZH+Qdwz0AN/ksBYm +QBDgoOGgQCUAGTV44KAB4W0GD/rgePHAANqeugDZz3CgAPxEQaDgeCGgigvgCShwC8gEIIAP/v// +AwsaGDALyIe4CxoYMNHA4H7xwM4ND/pIdoDgAd1E9ool/x8TeIDhRPazfTN5FCEAAGYPL/o7eax4 +AB5AHg0GL/oB2OB48cDhxQhyAd2A4cohwQ/KIsEHyiCBDwAAmxPKI4EPAABcAMokIQDgA2H7yiUB +AYDiRPZTeool/x+A4UT2M3mzfRQhgAAODy/6O3mseMEFL/ovcOB48cDhxc91gADsms9wgABEHiOA +QIUAgRByH/QCkUKVEHIb9AKFpgpv+yOFjCACgBXyz3KAAHgHIYIA2w8jAwACuGZ5FnghogAggQ+A +ABDXAIGquIi4AKEA2GEFL/oMteB4z3CfALj/z3Gg/kgHNqDPcKAAyB88gEAQAAbPcJ8AuP9YGAAI +SiTAcc9xAAAIgaggAAIp2BK48CBAAAHh4H7gePHA4cXPcAAA///PdYAACJsDpc9wgADoWv4MQAvP +cIAABFv2DEALz3CAAKxb6gxAC89wgADIW+IMQAsA2SClBdgBpSKliiDJA5oL4AGKIcwEngrv/AbY +mgrv/AnYvQQP+gfZz3KgANQHGhpYgIDgDvIZEgGGCSBDAA8SAYYCIMCAeWEPGliA9vXgfuB48cAW +DA/6AxIDNgh3DRIONs9xgAAEwhCLz3KAABDX1HkCuBZ4BWIxiS29gOFYYMC9C/Ihg+25CfLPcYAA +fB20eaCREOWgsSWQgOHR9mG5JbAQizJoNnk7YmWTgOM6Ygf0JpJRIUCAhAlC+/YJgAwiDmAGDcgD +yAHZoBhAAM9xDwD//+4IIADpcPUDD/rxwIILL/oD2M92oADUBxMeGJAPFhGWABYBQAAWDUCiwc9w +sP4AANO5BXlAxc9ynwC4/zaiUyXBFCV4FqIgwJzgDvIKIcAP63I12Iy4z3MAAPQMmHOlAW/7SiUA +AAAWD0DwfwAWEEBA51EgAKXAJ6IQA+cEJ48fAAD8/wfwz3AAAAUNMgyAARkWAJZCJwEUEHE29wAh +wCMPHhiQA9ggHhiQGRYAlojgk/cfFgCWQcAhwJzgyiHCD8oiwgc22Mojgg8AABENzyAiA8X12tj+ +CeABqXEEIIAvAAAAQAkDL/qiwPHAogov+sjagiQDMgh1KHbPcYAAeGRaCy/6i3DPcIAAkBINgIDg +z3GfALj/DPIdoc9ygAB8HASCAeCzuLW4uLgEohahz3CgABQEAdpEoM9ygABcPBiC4r0B4Biiz3Cg +/hABFqFALgAUpXgWocogIgCwDsH/GnANyM9xoABkLs9yoAA4LvAhAQDTuQeCJHgEIJEDrPCODs// +z3aAAAjmGnDJcLYMYASLcXYKoA3JcJ7wA9/PcKAAFATwoOSgABYEQAcaGDEAFgVAARpYMQTKnOAe +9ItwPg2gDA7ZJMDhvlMgwQCGIP4DRLjEHAIwZMFEJo0UGfKO2FEmAJGQuKAcADBr8obYkLigHAAw +Z/Drcs9wAADcDs9zAAD0CgEAb/sKIcAPTCAAoAfyjNiQuKAcADBT8AK5NnnHcYAAENdAgUh0hCQM +kA3yUSJAggjyi9iQuKAcADAB3UHwiNiQuPrxTolQcJHYzyAiBPT1AcD6uAjyAd2Q2JC4oBwAMC/w +MxSAMCKRESEAgBXyB8gEIIAPAMAAANdwAMAAAAv0IsCA4MogiQ8AAI0ArAfp/88gKQQKwYwh/48R +8s9woAAsIBCAInjXcACAAADKIIUPAACHAIQH5f/PICUETCAAoMwlIZBc9c9woAAUBOOgTCAAoKl2 +YvVTJn6QB/LPcKAAFAQJgIDgWPXhvjPyTCEAoAHaKvIqcS8oQQBOIIMHlOPKJcUQhfdodYAlwhTP +cKAAaCzwIEADlOMPeMonxRCE92h3gCfCEc91oAAYLPAlzROxcMoiIgCA4gryANgPIMAABiEBgNr1 +AdgD8ADYgOAk85kAL/qAJAMy4HjxwDIID/oacMoIIAIw2JhwKbhRIACAyiHCD8oiwgfKIIIPAADp +FMojgg8AAMcAeAYi+8olIgAs2N4IIAJAKIEgAd6KJQ8ajgggAjDYmHApuFEgAIAL8owmD5on8vIO +IA0B2GG9gOUB5i/3agggAjTYTyABBZW5ogggAjTYVgggAizYCHVOCCACNNj1uLhwGPIKIcAP63LP +cAAA6xTj2wkGL/tKJAAACiHAD+tyz3AAAOoU1NvxBS/7SiUAANkH7/lBLQAU8cBuD8/5CHcA3slw +8gggBclxA9jJdYDnGnAK8kQtPhcAIYB/gAC0Wb4PAAuA5wryRC0+FwAhgH+AAFxaqg8AC0IgQCCA +4AHlJ/fPcIAAxKjJdJ2wMLyesM9wgAA4COYJYAbAoG0Hz/nxwA4LQAGA4BDyz3CAACQqAIBRIICC +CvLPcIAAcFxiDwAL8g3gCgDY0cDgfvHALgkv/eHFz3OAAGQ7z3GAANBdQIH0Ew0AUHUA2Ir3+BMB +ADByBvf8EwEAMHLD9wHYJQfP+eB48cDPdYAAhAZ82N4NoAEghQAVBBAKIcAPARIFNutyz3AAANsO +8QQv+4/b4HjxwH4KQAGA4DDyz3CAACQqAIBRIICCKvLPcIAAICtoiEqIRCs+CwAhgH+AALAqVXgG +iIHgANka9M9ygABwXAaCA4BggAKCYniA4MogSwAF2Qq5MHBK9gaCA4AggMdxAAAAFAIPIAtIcNHA +4H7xwAIO7/kD2K7Bz3agANQHEx4YkA8WEJYZFgCWwOC+9wAWAUAAFg9A07nPcLD+AAAFec91nwC4 +/zalUyfBFCV4FqXveJzgyiHCD8oiwgfKIIIPAABAAM8gIgPKI4IPAACYDMokwgAYBCL7yiUiAItw +BgmgDA7ZBhQBMQAUADFRIQCBwCCiAAPgBCCSDwAA/P8LwIDgViIRIhDyGqUswBulAsAepc9wAGwE +ABmlBvDPcAAAtQyCDkABGRYAllJwufcAIQAkDx4YkAPYIB4YkODYfgygAelxAcAEIIAPAAAAQH0F +7/muwOB48cAaDc/5CHbPcKAAZC7wII0D070NEhA2DRqYM/XYBbjmDeAByXENyM9xoAAUBADfCqGu +CyAJyXBacAHYz3EAABAnz3KgAMgfPqIQ2S6iFRoYgEwiAKBKIQAgDyGRI9D3CyBAxAT0USMAwPzz +CyBAxAbyqg7v/wHnUne09wsgQMQX9FEjAMAk8hPwLyhBA04ggQcA2A8gQABALj6VBn0A2AT0QCk+ +gwPyAdiiDsABgOXt9QohwA/rclfYjLiKI58BSiQAANECL/sKJQABDRoYNPXYBbgyDeABCnENyM9x +oAAUBAqhkQTP+fHAMgzP+c9woABULiuAB93TuS8oQQBOII8Hz3CgAMAvpRAShhQQEYbPdqAAFASq +poILIAmA2PPYBbiA2eIM4AGfuQ0SEDb12AW41gzgAalxqqYNGlgzBPAD2AWmqYaA5RvygOX680Et +gJAK8i8kCXDgeKgggAEAFgBA4HhTJU2QCfIvJElz4HioIEABABaAQOB4qYbn8fPYQgzgAQW4/7jh +9fXYBbh6DOABCnEoHgAUlOcNGhg0yiHFA4X36XGAIcIBz3CgABgs8CBCAJTnyiHFA4X36XGAIcIE +z3CgAGgsNXgEv0Cgx3eAAMzTFYc2hwV5F4e4hyV4BSUNkMohwg/KIsIHyiCCDwAAwiHKI4IPAACN +B8okQgOUASL7yiUiAIDZz3CgANAbMKDPcKAAwC+lGJiEFBhYhFUDz/nxwO4Kz/mkEQAAKHVRIACA +CtjKICEEmBUBEAQhvo8BAADAdh0EEDD06LkW8kQhAAYjuEFoBCGADwYAAAAxuFhgBCGCDwYAAAHX +cgIAAAHKIKEAA/AB2IHgD/KC4Ajyg+AA2Mog4QHAKKEDC/DPcIAA9MECgAXwz3CAAPTBAYAFeZgd +QBCeFQARlB1AEJIdBBCCFQARkBUREbIdBBAA2IAdBBB+HQQQA8jPdqAA1AdBkIDiEBWSEAryDcjP +cYAABMP0IQAAgOAT8hkWAJa44E/3DczPcYAAXDxGIIACDRocMBqBAeCXAiAAGqEPFhSWgOIJ8g3I +z3GAAATD9CEAAIDgA/IB2AXwA9gTHhiQANgHEg82ARIQNgAWBEB6cAcaGDEAFgVAARpYMQTKnODK +IsIHyiCCDwAA3A7KI4IPAAD0CjAAIvvKIcIPqXAiDWAMDtlMI0CgD/QEyAGQgOAh8s9xgADQPRqB +AeAaoRyBAeAcoRfwA8gBkIDgE/INyM9xgADUwvQhAABTIMCAC/TPcYAA0D0agQHgGqEbgQHgG6ED +EgE2AYHuuA3yVBEAAVMgwIAH9M9xgADQPRmBAeAZoQIVBRFMJQCAFPIBhe64yiHCD8oiwgfKIKIL +zyAiA8ojgg8AALUHjAfi+sokYgAAlbBwyiHMD8oizAfKIOwLzyAsA8ojjA8AALgHaAfs+sokbAAQ +jVMgwQCGIP4DRLjEHQIQpBUAEPa4MK0i9AcSAjYCIsEDgeEA2AfyAieBEIwhw48C9AHYgOAU9A3M +z3GAAFw8RiCAAg0aHDAZgQHgGaEPHhiVBxrYMwEaGDSJ8Aca2DMBGhg0ANh0HQQQNgpgAKlwz3GA +AAhyC2F0FQIRz3GAABBy8CEAAHpiUHqkFQEQdB2EECV4pB0AEATIAZCA4BTyTCNAoA30AZW4FY8Q +WGAglfhgEHi+HQQQWWE/Zw3wvhUAEQrwIJW4FYAQWWE4YBB4vh0EEAh3kB0EEA8WAJa0HQQQ3gug +BalwEI0yd8wggYQS8gohwA/rckApDSRAKA4EMNiMuADbi7sFJcQTVQbv+gUmhRSkFQAQCHSEJBqQ +JfJRIECCHvIDyAGQgOAa8g3Iz3GAAATCFHmAEQAHgOAS9NARAAFqFY8QAeDDuPhgD3hqHQIQyg3g +AKlwah3CEwXwvg3gAKlwDx4YlckHj/ngePHAdg+P+RpwAN+kGcADz3CAAEQeBIDQifCgB8gEIIAP +AMAAANdwAMAAACh1FvQNyM9xgAAEwhR5EYmA4A70z3CAAPDV1ngiiAiNEHHG9gpw8giv/alx4fBR +IACghvIEFQQQUSQAgUDyDcjPcoAABMIUehEShQAPeEkgwgBybs9wgAAQ13Z7YGD2uDKNB/LPcIAA +UNnWeAGIAvAA2MdygABQ2dZ6RIoIIYEACCEBAAAhQAFJIMEDFm41eM9xgADQ2gBhz3KAAEQeRILP +cYAAUNrWeViCIYFFeQQhgQ8AAAAIJngD8AOFz3GAAEQemB0AECSBKIEEIYEPAEAAAD65UyQCAB7h +OHpFeP64mB0AEAvypBUAEIy4pB0AEFDYnB0AEHvw/7gT8qQVABCNuKQdABDPcEABUACcHQAQz3CA +AEQeJIAQgZ64EKFn8AXYFLicHQAQz3CAAEQepB3AEySAEIGeuJ+4EKFZ8FEgQKdH8gGFUSAAgTfy +Mo00EoIwSSLCAHJuz3CAABDXdntgYPa4CPLPcIAAUNnWeAGIA/AA2MdygABQ2dZ6RIoIIYEACCEA +AEkgwQMWbjV4z3KAAEQeRILPcYAA0NoBYc9wgABQ2tZ4WIIBgEV4BCCADwAAAAgGeQLwI4WYHUAQ +DcjPcoAAPMIVeiCinB3AEwXwBdgUuJwdABBRIAClB/IA2JG4pB0AEAPwpB3AEwPIAYDPcaAAwB3s +uACB0CDiAM8g4QAAoXQdxBP+DiAAqXDPcYAACHJ0FQIRCWFZYTB5dB1EEM9xgAAQcvAhAACkFQEQ +JXiYFQEQUSFAgqQdABAK8grZdh1EEHgdRBCAuKQdABAW8BDZz3KAAEQedh1EEEOCSIJRIsCACPIK +2XgdRBCDuKQdABAE8HgdRBASC6/8qXCkFQAQRCB+gowVgRAZ8s9ygABEHkOCVIIkeoYh/wNEuYYi +/w46Ys9xgAAYaPQhkQDPcYAA8Gf0IZIADfDDuc9ygAAsqjx59CJRAM9ygAD8qfQiUgCYFQUQUyAE +gMogggQW9IgVgRBRJQCCw7k8edEgIoUH8s9wgABUqvQgQAAG8M9wgAD8qfQgQAAhhVEhwIAF8oQd +BBAD8IQdxBNRJQCCDfJEJQEGI7kB4QQlgA8GAAAAMbgZYQLwAdkDyAGQgOAk8g3Iz3KAAATD9CIC +AIDiA/RBlbgVgxB0FQARBCW+jwEAAMB4YBpiUHq+HYQQDvQKIcAP63Is2Iy4iiMaCUkC7/qKJIMP +QJXn8YHhHfKC4cwh4oDKIcIPyiLCB8ogYgvPICIDyiOCDwAAtQbKJCIAGALi+solAgHPcIAAUNnW +eAOIBvDPcIAAUNnWeAKIjBUBEA64JXiMHQAQz3CAAKwGIIAGgaAQAAaA4Af0z3CAADBeAIiA4F3y +DRIDNobjWfIAla/gz3KAANA9ogAMAM9wgAAEwnR4EYiA4Ef0TCQAgEP0USAAoD3ynhUAEc9zgAC8 +PYq4nh0EEBaTAeAQeBazAcjnogWimBUAEK64r7iwuJgdABAmgaARAQYvKUEATiGCB0EqwQAO4Q8g +QACkFQEQmB0AELS5pB1AEJ4VARGnuZ4dRBDPcYAAJF4AoQQggA///9P2mB0AEA3YmB0CEAnwENgG +8AjYBPAC2ALwAdgHopgVABC+FQERkg/v/gDapBUCEAQivo8AAAAwgh0EEFLyjBUAEJwVARGUHQAQ +kh1EEOy6gB2EFAMSAzYK8hTZkB1EECpxfh1EEHgTDgEK8A7ZkB1EEH4dxBN4Ew4BSnHCeTB5sh1E +EM9xgACwwSCBhiF/jw30mBUOEFEmQJIJ9GGTgOMF9JG6krqkHYAQELkleqQdgBAEIIAPAAAAEM9y +gABEHmSCUiAAAzCDJXgQo0SCEIIEIIEPAAAAED15JXgQohTwmBUBEIAdxBOUHUAQnhUBEX4dxBOS +HUQQvhUBEbIdBBCQHUQQgBUAEX4VAhGCFQERGmKEFQARWWE4YBB4sB0EEKQVABDPcZ8AuP8WoZwV +ABAWoeUBj/ngePHAkgmP+doLj/zPcIAA4MMMiM9xgAAQ1wK4FngAYS24UyAAgAX0z3WAAGQ7DfDP +cYAARB4ggcQRAQbPdYAAZDtRIUCBBPQB2dwdQBDPcYAARB7wIQAAz3KAAPxcIIIYiIPhRgAtAEEd +GBAzJkFwgABYYkAngHI0eAB4dgggCwPYAgggC0DYANjgHQAQDfDPc6AAqCAxgwKCAN7Cojhg4B0A +EAHYEqNZAY/54HjxwOHFB9gNGhgwz3GgANQHGhkYgA4RDYbPcIAAkBJIgIDiBxpYMxDyz3CfALj/ +XaDPc4AAfBxEgwHis7q1uri6RKNWoM9woABILL6gHxEAhgEaGDAEypzgzCCCjwAAkQAF8gAWAEAA +FgBAA8zPcZ8AuP8YoYogRgSqDyABARIBNgESATZ92AoOYAMHEgI2zQCv+QTK8cC4cQK5z3KAABDX +NnkwIkQAUSRAgsoiwgfKIIIPAADLIsojgg8AAJMDlAai+sohwg9ALYEBz3KAANDaIWJRIUCCiiII +BcoiYQPPcYAAUNkWIUEBIokOuUV5IKDRwOB+8cDyD0/5z3KAAKQcRILPdYAACJtihUCCNrs2ulBz +1iKNDwAAgADAhT1ifmaxds73CiHAD+tyiiCNAoojEASYdh0Gr/q4dR5msXb/91hgEQCv+Q4ggAPg +eM9wgACcByCAz3CAAMBy4H/wIEAA4H8B2M9wgAAsV+B/AIDgeM9xgACMOuB/8CEAAPHAmHAKIcAP +63IKJcAHz3AAAJ8ZwQWv+jvb4HjPcYAAaDrgf/AhAADxwJhwCiHAD+tyCiXAB83YBbidBa/6RNvP +cYAAoDrgf/AhAADxwJhwCiHAD+tyCiXAB89wAAChGXUFr/pN2+B44cXPdYAAfD4ChUKdgeDPc4AA +yDc0gw70InpOeuTiAJ0E9jODxuFS9gDYAqUBnQ7wQnkueYwhA4IBnYj2M4PQ4cT2AdgCpQCd4H/B +xc9xgADEXAaBA4DPc4AAJCpAgAKBQnhIIAIA+BMBAPYTgAAieOwTAQFhuAUpPgBAKYBy4H9YYOB4 +z3GAAOBcBoEDgECAAoFCeOB/SCAAAOB4z3GAADQHJIHgfyCgEYjgf8K44HjPcYAADF1GgYDiiiH/ +DyCgBfIigiCgAdgC8ALY4H7geM9xgAAsXUaBgOKKIf8PIKAF8iKCIKAB2ALwAtjgfuB4iiH/DyCg +z3OAACxdRoOA4hLyJIJRIUCAC/LPcYAAPFswcgfyz3GAAFhbMHIG9ECCUHPx9QLYBfAigiCgAdjg +fvHAogrAAIDg8A1iCsogIgDRwOB+8cDPcIAAICtIiCqIRCo+CwAhgH+AALAqNXgGiIHgGPRSCsAA +gOAU8s9xgABEHgCByBAABoYgf44K9AGByBAABoYgf45MC2EKyiAhANHA4H7xwF4NT/mA4GXyz3aA +AKyqL47PcIAAUNnPdYAARB42eCKIA4UA389yoAAsIDQQEQE8EhIADo6A4JwAKQDKJakQjCIBpJAA +JQDKJSURZJaU48Ajhg8AAJMAz3CgAGgs8CDQAOWiUNhFIUECGNq+CiANINv4uMolIhIu9APYz3Gg +APQHBaGE2g1wQLBCIgAoDXIAskCGDXBAoEKWDXBAsAOFQIANcECgA4VCkA1wQLAGlkAoAiXDuAy4 +grgFeg1wQKDkoQ6OAeAOrkIOIAsqcAHdEPAA3c92gACsqtYLoAgElgDYz3GAAFw8Dq4egQHgHqHJ +BG/5qXDgePHAbgxP+RpwhCgICQAhgX+AAEykhxENBs9wgADgBgKAoL2HGVgDBIiA4BHyA4GA4A30 +CiHAD+tyydgEuIojnA4KJAAEnQKv+rh1AoGA4Bz0z3KAAEisExIAhowgw48L8s9wgACkHASAAIAC +oRwaGIQV8M9wgAC4JAAYAAQmCWAKANgN8D4Kz/6EKAgpCHEAIYB/gABMpsYMgAo5BE/54HjxwM4L +T/kacIogTAsGCyABCnFMIMCgz3aAAMSok/celjoWBREKIcAP63IQuAUlBQDPcAAAgwyKI4UPCQKv ++gokAARAKA0h3WUllQSVELkleIDgOfLPcIAArHLwIAEERCg+JwAhgH+AABRaL3cgoCOVApUQua4J +7/4leAhxACeAH4AACFo2DIAKz3CAAKBy8CABBAAngB+AAGxZR5UgoCOVApUQuhC5JXgmlaoOL/tF +eXIJz/4IcQAngB+AAGBZ/guACl6WHZYA2Q8hAQQQukV4BiBAgAHdHbYwuB62GfTPcYAA6CkAgaC4 +ug2gBQChz3CAAKQcBICW2h7bIIDPcIAABKmioCGgDNmmCuAIGLsQ2s9xgAA4CACBACoCBEZ4FQNv ++QCh8cCyCk/5AN3PdoAAxKg+lg8lDRAdlhC5JXgGIH6DQfTPcYAA6CkAgYC4AKHPcIAA2AbPcYAA +cCEAkEeJEHIb9M9wgADaBgCQQYkQchP0z3CAANwGAIgmiRBxDfQLyAQggA/+//8DCxoYMAvIh7gL +Ghgwz3CAAKQcBIDPcYAABKmW2h7bAIAAoQDYAqEocAzZ+gngCBi7ANiyCaAAgNk+lh2WELkleKV4 +HbYwuHECb/ketuB48cDhxZYKoAAodYDgyiBBA3QLYQTKIWEAWQJP+TEHz//xwNoJT/lWDqAJAN3P +cKAA0BsRgO+4C/KGCCALAdjPcYAA0D0JgQHgCaEGyFEgAIADEg42IvKkFgAQ8rge8s9xgACYOQCB +gOAY8qChUSGAxf7zz3CgAMQsq4Df2L4IIAGpcVMlgRT+vcwhIoAG8pgWABBaDq/+ANoDEgE2oBEA +APC4D/KKIAgADBocMPrYjgggAaARAQASDSAFA8g18PS4IvIHyNCJANozEY8ABCCADwEAAPBBKA0D +z3GgADguB4EPIkIDAdxGeAehDciGCOAMACwAEMd3gAAQ1wK+1n4S599noK8DEgE2iiAQAAYaGDD7 +2CoIIAGgEQEAA8igEIAAxOAYDkEMA9nPcKAAFAQjoDEBT/nxwMYIT/nPdYAAuJ0Bhc9zgABQ2kQg +BIPPcIAA4MMMiNJo1n7HdoAAENdAhhZ7IYMT8lAijwXgpkwkAIFGIQEGIaMF9JG/4KYE8LG6trpA +ppILQAwG8Ja6QKZFIQEGIaMLjaK4yQBv+Qut4HjhxeHGz3CAAODDTIiMIgKAz3OAALidGPLKi89w +gABQ2jJqNnnHcYAAENdWeIDmQIGhgAbylbpAoau9BfC1ukChi72hoADYC6vBxuB/wcXgeKHB8cBR +IACC4cWoACEACHVEJQMWBCWCHwYAAAAjuzG6AeN6YgQlgB/AAAAANrjPc4AAAHJKYwhjWGBBLYIS +UiICAMC6A7oY4oXgyiKNDwEAiQ3VIg4AUHFSACUAANjtvRgAIQACIYAAz3EcR8dxBSh+AAogwA4D +8CK4QS1BE8C5BLk0ealyxrpJIsIFVHnrvc9ygAAgajJiBfJBKgEBFCGCAAUqPgBBKQByCNzXBw/5 +CiHAD+tyO9iMuM9zAABXEkokAAC1BW/6CiUAAfHAPg8P+c9wgADgwwyIjCACgCvyMmg2ecdxgAAQ +16CBz3OAAFDaz3eAALid5JcWe0GDUCWOFYYnux/AoYwnRJBGIgIGQaMF9JG+wKEL8LG9gee2vaCh +B/SWvaChRSICBkGj+glADADZz3CAALidOQcv+Suo8cCKIE8LBg7gAPnZ/ggAANHA4H7PcYAA9BwJ +gYDgC/IHgYHgCfQWiQHgD3iQ4BapA/QA2Bap4H7xwJIOD/nPdYAAEKkIheC4rMFa8lEgwIFW9O4M +r/8A3vYN7/sY2ItxqXAmC2AJJNoB2c9woACwHzmgz3GAAKQcCIEAgM93gAD0HEnADIEAgDDZSsAG +h5DaHttLwItwEg6gCBi7wbXIpcGl3K3DpyoMIAAC2M9wgAB43woQBAFMJACAC/IKIcAP63KKIF8G +adtxBG/6uHYSDuAJyXBGhwHZz3OAADQdAIOB4sB5gOI4YACjAdjPcoAALB0ggsB4OGAAogTwDggA +ADEGL/mswOB48cALyAUggA8BAAD8CxoYMPoJT/n6C+/7C9iuCyAAANjRwOB+z3CAAPQc4H8IgOB4 +8cAB2M9xgAD0HAOhz3CAAKQcEIAAgAShAoGB4AgNwfrRwOB+8cBuDQ/5ABYAQM9wgAAsIQ+AUSBA +gQ30CiHAD+tyiiBfBJDbiiTDD7UDb/q4cwAWAEDPdYAACOAApeRt6XCaCOALD9lVJU4UyXBSCOAL +IpW6Ck/+CBUFEFElAIQL9AohwA/rcoognwSY23UDb/pKJEAAz3CAANhdIIBAhUChIIAc2kCpz3GA +AGgII6UY2SKgVSXBFSWg4aAhhcOgJKAA2FodBBACha24Sg2v/wKlgOAX9M9wgAB43yWQgOGKII8L +x/buC+AAq9kSCQAABvDiC+AAsNmaCAAAKgrgCA3Y+QQP+eB48cCKIE8MxgvgAI/Zvg7P/9HA4H7x +wM9wgABoaM9xgAD0HCYJYAk42vYJ4AgA2NHA4H7gePHAug7P/wDZguDMIGKAyiBCAAP0AdgPeNHA +4H7xwM9wgAD0HCAQBQBMJcCAi/cKIcAP63KKIF8FVtuNAm/6SiSAAM9wgACgaPAgQAFAeNHA4H7g +ePHAAgwP+c9wgACkHASAAN6WvqCABCWNH8D/AADdZRTlACWPH4AAAAAqCq/+qXAIcc9wgABIWLYM +QAoaCq/+2GUIcc9wgABkWKIMQAoGCq/+6XAIcc9wgAAsWJIMQArPcIAA9BwFBC/54KDgePHAkgsP ++c9wgACkHASAAN2WveCABCePH8D/AAC/ZxDnACeQH4AAAAC+Ca/+6XAIcc9wgACAWEoMYAq/Z892 +gAB43wWWJYYKuPlhngmv/g4gQAAIcc9wgADYVyYMQAqKCa/+6XAIcc9wgACcWBIMYAq/ZwWGH2cF +lgq4bgmv/g4gwAMIcc9wgAD0V/YLYAoCdVYJr/4KcAhxz3CAAPBY4gtACs9xgAD0HAAZAAQFliWG +Cri5YTIJr/4OIEAACHHPcIAAEFi6C0AKLQMP+fHAygoP+c92gAD0HKCGAN+Wv/1lBgmv/qlwCHHP +cIAADFmSC2AK/WXyCK/+qXAIcc9wgAC4WH4LQAr5Ai/5oKbxwIoKD/nPcIAA9BzAgADflr/+ZsYI +r/7JcAhxz3CAAChZUgtgCv5mz3WAAHjfBZUlhQq42WGmCK/+DiBAAJhwz3CAAKBXLgtgCohxjgiv +/slwmHDPcIAA1FgaC2AKiHHPcIAA9BzAoAWF/mYeZgWVCrhqCK/+DiCAAwhxz3CAALxX8gpACm0C +D/ngePHAAgoP+Qh1z3aAAPQciiBPCi4J4AAohgiGEHVF94DlyiUCEAL0qKaKII8KEgngAKlxPQIP ++eB48cDKCQ/5JgzP/4HgDPIKIcAP63KKIJ8FoduKJMMPGQBv+rhzz3WAAPQcI4WB4QKFD/SB4ADZ +BfIUjYDgBfL6Cu//JqUM8COlAdgGpQjwgOAG9AHeDgygCMalwqXPcIAAeN8KEAQBTCQAgAzyCiHA +D+tyiiAfBsDbvQcv+kolAAC1AQ/58cCKDQ/54HjgeOB44HhpIIABbyE/AGkgAAD38fHAIgkP+Rpw +z3agANAPAN0H8BAWAJb9YfhgEB4YkCNtEnFyAA0AJRYDliUWApYvJMcAJRYAlk9/D31MJACDCL2l +f+n1gufMJ+KTzCcil8olQhAh9M91gABQqUmtJRYClgqtS60lFgKWaK2P50ytomkI9M9wgABdqTYP +L/kN2Q3lnOcJ9M9wgABqqSYPL/kN2Q3lEBYAlgIgQSM4YBAeGJDlAC/5AdjgePHAgggP+aHBCHUo +doTlANiY94tw8g4v+QTZAMDXcJoJUG8L8s9xoADUCw+BZL24YA+hAdgG8KlwIg/v/8lxD3itAC/5 +ocDgeM9zgADoKUCDgOFFeACjGvLPcYAAcCHPcIAA2AYAkEeJEHIb9M9wgADaBgCQQYkQchP0z3CA +ANwGAIgmiRBxDfQLyAQggA/+//8DCxoYMAvIh7gLGhgw4H7xwM9wgAAwCACAgOAK8s9xgAC4OAuB +AeALoRYI7/oC2NHA4H7xwM9zgACkBmhwMgwgAATZBGsqDCAABNnRwOB+ANjPcYAAXAcBqREAIAwA +qfHA4cUaCe/8Mdi0aBIJ7/wz2AV9GL3PcIAAnGKeC2AJkL0ouOEH7/ileOB44cUyaDZ5z3KAABDX +IWLPcoAARB4tucC58CJDACiDUSEAgM9xgAD0wUGBCfI8i4DhxSKBDwAACgID8kUiQgNKJAB0ANuo +IIACNmh1eQAhjQ+AANDaQKUB4wDdz3OAAFDZFiMCAKCqoaoB2SKqA9kjqkokAHGpcqggwAF5YhZ5 +pKkB4uB/wcXgeOHFSiQAeADYqCAACADbz3WAAHwcQIUPIwMACyLAgA/yQYULIsCAQNrPIuIHyiKB +DwAA0ADPIuEHAvAA2s9zgACQEhV7QKMB4OB/wcXPcIAAsF0GgAOAIIDPcIAA3JcpoG0DL/wR2OB4 +8cByDu/4AdnPcIAAkCSKD6/+JKCKIMUPz3agAMgfGR4YkAHYAdkocihzQgwgAZhxlgyv+wDfagjP ++891oADQD/Wlz3CgAMAvehABhom5i7l6GFiAz3GAAIDNEBhYgAXZ9BhAgM4OAAIaCI/+/g+ACEDZ +z3CfALj/MqAqCoALgNnPcKAAFAQsoB0dWJCeCIAKBg8ACjoOYArpcAfYSB4YkEYNwAZmC8ABLgtA +AKoIQATSCMAIjg3AA2YPAAlSDEAAtg8ACC4Ij/uSDgABegwACgIJz/76CEAF0g1AAQoMwAbWDcAF +Dg9ABL4LD/5iCQAFWgkABU4LwAjPcAAA/spuDg/72QXP+OB48cBmDc/4z3eAAEQeA4cIgMC4wg2g +Ci8gACAA3c92oAC0R89woACMRLigANiTuHceGJAI2HceGJAA2J64Ux4YkOB4z3CAANwAEHhTHliT +Rx4YkM9wgACMAxB4SB4YkE8ggCNFIAANTyDGBzTYRB4YkBzYRR4YkM9wgADIFQGIRh4YkM9wgACs +Ou4MoAUMiEokgHDPcYAAmN+oIEADz3CAAPTBQYB0bXR7O2MCgEOjAeUEo891gADMXQCFgOAD8mQe +GJBDHpiRagugCgHYA4cIgFEgAIBAhQ7yUyJBABK5RCIAAw64JXiGIv8DCrpFeBLwSHCGIPMPCrgE +IoEPAAAADAa5JXgEIoEPAAAAMAK5JXjPcYAAJCy1BO/4AqHxwOHFEN2+DuABqXAH2Qu5z3KgAPAX +MaLPcQAA8P84orKiogvAAaEEz/jgePHAIgzv+ADaz3CAAOAGQ6D/289wgABIrBMY2IBKJIBwSHGo +IEAHhCkICQAhjn+AAEimz3eAACxdQaYG3aWmz3UCAFwepKZGpuemJB6CEAAhjX+AAGimQKUB4c9w +gABIrBwY2IDPcYAASCkAgRzaQKAY2A4IIAACoREEz/g52c9wpQAIDD6g4H7/2c9wgAAkpCCoANnP +cIAAzKPgfzWg4HgA2oDhyiRNcOB46CDtAf/ZXGAgrAHi4H7xwOHFz3GAAFjBz3CAADxyFgggCUja +z3CAACBsz3GAAOgHBgggCQjaAN3PcYAAsDChoaKhz3CAAMgzqaBqCuACA4HPcKAALCDPcYAAODRQ +gBCARaEGoRIKYAKpoYUDz/jxwADZz3KAAMSoIKLPcIAA6CkgoD2yMLk+stHA4H7geOB+4HjxwOYK +7/gg2QDaz3WgAMgcKaXPcaAAlBNboc9zgACwE2CD82jPdoAAVMMMhvV/UyDEBfBj+2NTII8Ag+ek +wYtxG/Qfhpu4H6Y0FoAQ4ovxcAv0KHBAIwEERGsaCGAKQCYDHA3aKvAehpG4krgeps9woADMFyvw +hecO9EEqAlJAIwAEwbr2Ce/8iHMfhpy4H6YN2hTwLLhTIAIAH4YDupm4H6bkgwXiBScAEQChBYMB +oQaDAqEHgwOhA+LPcKAAzBfPcaAAlBNcoQHagOIH9B+Gl7gfpiDYCqUY8ADBA9oYGFiAAcEZGFiA +AsEaGFiAA8EbGFiAFBiYgIoWAREQGFiABNknpRYYmIBFAu/4pMDgePHA1gnP+KQQAQD5uaLBcPQg +2c9zoADIHCmjpBABAFEhwIEu8jGIz3WgABAUI7nAuQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwn +w58I9AQUDzHxdswn6pAB3kP2AN6A5ur1xYBFfselsYiGJfwfGL2les91oADMF1qgF/BFgM9xoAAQ +FEehpBABAFEhgIIJ8jGI17qGIfwPGLlFeTqgz3WgAMwXDdkB2gPhDR2YkA4dWJAmgBkdWJAngBod +WJAogBsdWJAD2RQdWJBwEAEBEB1YkHAQAQHPdaAA9AcE4SelR6OkEAEAmbmkGEAAUQHv+KLA4Hjx +wOII7/gE2Qh1DRIONgbYDRoYMM93oAAUBAqnz3CAADBypg7ACACFng7gCATZAYWWDuAIONkIFQQQ +TCQAgAGFABAFAQTyDCRAgcr3CiHAD+tyGdiMuP0G7/lv2wOFag7gCIhxAYVChSCQBYVaDuAIQnnK +p9UA7/gNGpgz8cBmCM/4CHbPdYAAMAgAhYDgKHcF9IDm4iCCAy3wiiALAIYPYACKIUkDiiALAHoP +YADpcc9wgAAAXKIIAArPcIAAACrPcYAA/AfAoACBBX/goc9xgAC4OAKBAeACoQTw4gzP+QCFgOD8 +9c9wgAA0CACAgOD29VkAz/jgeM9yoAD8RDmCBCG+jwAACCAA2AX0PYL5uQLyAdjgfw948cAA2Jy4 +z3GgAKwvHKEagVEggIIagQzyqrgaoRqBUSAAgPHzLgtv/AHYC/CKuBqhGoFRIACA5/UqC2/8AdgA +2Zu5z3CgANAbMaCaC8ALQgnAC89wgABkOACAQiAAgMogYgDRwOB+4HjxwOHFz3GAAMSofpFdkRC7 +ZXoRIgCAAd0M9M9xgAC0WUQoPgeyD+AJACFADqlwA/AA2KkHj/jgeEaBgOII8iOBYIEigmJ5MHAA +2AP2AdjgfvHAFg+P+Ah1z3aAACxd3g/v/8lxgOAJ8qlw0g/v/0AmARiA4AP0ANgK8M9xgAAMXboP +7/+pcIDg9/MB2EUHj/jxwOHFz3CAAIwhCIiI4KHBB/TPcIAAJCoAgO24H/LPcoAAICxoEoCAz3OA +AI4rgOAT8msSgICA4BP0ahKAgFEgwIEL8s9wgAAkKgCA4bgF9FEgAIAD9AHYXPAA2FrwgeAT9G4S +gICA4AHYwHhgwMILYAiLcHMSgICB4Ev0bhKAgIDgR/Is8HMSgYCB4QX0gxKAgIHgCfKB4UoADACD +EoCAgeBCAAwAbhKAgIDgBfRvEoCAgOAD8gDYAvAB2GDAcgtgCItwcxKAgIHgI/RuEoCAgOAG9G8S +gICA4BvyANhgwBfwgeEB3W4SgIDCJUETgOAF9G8SgICA4APyANgC8AHYYMAuC2AIi3CoY4Dg6PUg +wDkGr/ihwOB4z3CAAAAGDoCA4AHY4H/AePHA6ggAAIDgBfJeCQAAgeAH9M9wgAC8JACAgOAD9ADY +FPAyCgAAgOAP9KYJAACA4Av0z3CAAIwhLJDPcIAARB4ekBBx7fUB2NHA4H7xwAYKAACA4CD0CglP ++oLgBPIA2NHA4H7PcIAAjCEIiIfgDfKI4BL0z3CAAEQeAYDEEAAGUSBAgQjyz3CAACQqAIAjuMC4 +6PEB2ObxqQTgABHY4HjxwLhwz3GgAKwvGIH6uAzyCiHAD+tyiiCMCWfbXQPv+UokAAAVgVEgAIAM +9AohwA/rcoogzAlo20ED7/lKJAAAAdjRwOB+4HjPcIAAMAgAgIDgzCBigAT0ANgF8Ijg/vMB2OB+ +8cDPcYAA+gdgic9wgAD7B0CIhCsfAAAhgH+AAJzLMODwIIAAUSAAgAX0KggAAIDgA/QA2AzwIInP +cIAAWMWEKR8ANCBADoDg9fMB2NHA4H7PcIAAMAgAgIXgAdjgf8B4z3CAADAIAICG4AHY4H/AeM9w +gAAwCACAh+AB2OB/wHjPcKAAxCwagOe4BvRRIACBAdgD9ADY4H7PcIAAJCoBgIHgAdjgf8B4z3CA +ACQqAYCC4AHY4H/AeM9wgAAkKgGAg+AB2OB/wHjPcIAAnAcggM9wgADAcvAgQACA4AHY4H/AeOB4 +8cDGD+//4cWA4Bzyz3WAAIwhCI2H4Bb0zg/P/4DgEvLPcIAARB4ekCyVEHEM9M9wgAAkKgCABCC+ +jwAAOBAE9ADYA/AB2PUDr/gPeM9wgACcByCAz3CAAMBy8CBAAIHgAdjgf8B44HjPcIAAJCoBgIDg +Adjgf8B4z3CAAJwHIIDPcIAA5HLwIEAAgOAB2OB/wHjgeM9wgACcByCAz3CAAORy8CBAAIHgAdjg +f8B44HjPcIAA4BQAiIDgB/LPcIAAyBQBiALwAdjgfuB4USFAxwXyCci9uAkaGDAA2Z25z3CgANAb +MaDgfvHA3gqP+M91oADIHyQVDpbovgryhRUAluoMT/uKIAQAJB0YkOK+CfKKINcK7glgAMlx9g3A +CxUDj/jgePHAngqv+DTYMguAAPC4z3eAAACOFfK+DSADANiSDSADAdiKJhAQAN1CCq/+qXAUJ0wT +Yb6A5gC0AeU49w7wANuKIhAAggmgBHB4FCfMEGG6gOIAtAHjOPetAo/48cBCCq/4NNihwQDd0gqg +AEDF8LjPd4AAAHYZ8oIP4AAB2APeCr4A2Iy4uGAQeItxggggAQHaFCdME2G+gOYAtAHlM/dKD8AA +EPAF2wq7A9oKunhlFgmgBBB4FCdME2G6gOIAtAHlN/dBAq/4ocDgeM9xAQB8Ws9wgABcF+B/JKDx +wOHFb9iVuM91oADIHxIdGJDPcAEAQDwVHRiQdgtACoogBAAOpRUCj/jgeADYkLjPcaAAyB8VGRiA +z3CAALDBRpBbek8iAwBaEQKGOBCAAGR6WGDYGQAA4H7geOHFANvPcoAAxJ1KJAB0z3WAADyeaHCo +IAACQCUBEhR5YLEB4Ehwz3GgAAQlD6FWIgAEEaFWIgAFEKHgf8HF4HjxwCYJj/jPdYAARB4Fhc92 +oADEJ3UeGJAMlXYeGJAHhXkeGJAQlXoeGJCmDe//AN+A4Bzydx7Yk3ge2JOAHtiTgR7YkweFhh4Y +kBCVhx4YkAeFih4YkBCVix4YkAWFiB4YkAyViR4YkAWFhB4YkAyVhR4YkMHYUB4YkBUBj/jgeOHF +CHHDuM9ygABEnvQiAwDJu3BxyiQidMogIgDoICIC9CINAMm9sXEC8gHg4H/BxfHA4cUIdc9xoADE +JxkRAIYB2oDgEREAhsB6gOIApdEg4YcA2Db0z3CAANDDDIDPcaAAyB9k4B6hENgOoQHYFRkYgBoP +oAsL2FEhAMbKICIAG/RRIEDHE/LPcaAA1AsWgTiBJOAwcEv38g6gCwPYUSMAwAX0USCAxAPyGNgC +8ADYgODKIOIEz3GgAJAjPoEgpV0Aj/jxwOIPT/jPdoAARB4VJgEQQIFpgriKQSvAAMC4F7jHcAAA +gBzku88gIgbgu07fzyCiAMongh8AAE4BhuXPJ2ES5bsW9M91gACMIRgVBBG+lpB1D/ShhsQVDRZR +JUCRCPSghsQVDRZRJUCRA/KBuFEjAILPIKIFG6L8okCBz3A6BEpwHaKggQfY9g9gAAq4BCCADwcA +AAAwuIfgVgANADMmAHCAAHBiQCeBchR5AHmKIAQAHqUY8IogEAAepRTwANiLuB6lEPAA2Iy4HqUM +8ADYjbgepQjwA9gMuB6lBPAA2I64HqWCIAEBYQdv+B6lCiHAD+tyjNiNuL7bi7tKJAAAUQWv+Qol +AAHxwM9xgABUPReh4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg +eOB40cDgfuB4IYAA2lMhfoAL8gDambpRIUCAyiKCDwAAgwDAKmIGz3GgALRHTBmAgGaQSCMDA0eQ +ELsEI4MPDwAAAMi6RXtIkAy6BCKCDwAAAPBlelAZgIBAgIPiKvRigM9ynwC4/32iRYBcGYCARoBg +GYCAR4B8GYCASIBkGYCASYBoGYCASoCAGYCAS4BsGYCATIBwGYCATYCEGYCAToB0GYCAT4B4GYCA +UICIGYCAQICI4hP0RYCcGYCARoCgGYCAR4C8GYCASICkGYCASYCoGYCACoDAGQCAz3AAAFVV4H7g +ePHAvg1P+Ah2AYDPdYAAfBwApQKGz3efALj/AaUA2AKlz3DQ/gAAwg5v/wSlANgdpwCGh+DPdqAA +tEcX9I4KAADPcAM/Aj+bHhiQz3AJPws/nB4YkADYl7hMHgCQbyBDAJMeGJAF8G8gQwBMHgCQWg4P +/gCF/7gX8s9woADIOx2AgOAR8s9wgACQEh+AgOAN8h2nBIUB4LO4tbi4uBanBKUD8ADYHafPcAAA +VVV5BU/4IpBIIUEBQCkCAyOQYoDLuY+5RXnPcp8AuP99os9yoADsRieiI4A1oiSANqIFgBeiz3AA +AFVV4H7xwNIMb/gA26bBz3GAAHwcYKFhoWKhz3agALRHLBYBkAokgA8AAFVVSiQAeGhxqCBAAs9y +gACQEjV6YKIB4QDZmLmVHliQSiSAcc9ygAB8HAgSBQALEJAAAN05ddh1qXKpcxl1qCBBBL9g5I+/ +5wAgSgMG8hUkQTNgoQHjSicAAA8nRwMLIMChCfIVJEEzIIFKIwAQDyNLEAPwSiMAECqICyHAgQUh +yRIJ8hUkQTMggUonAAAPJ0cAA/BKJwAAgOcFIsIBD/QVJEEzIIEMEAUAP98KJIAPAACt3g8gSBAE +GsITiecH9BUkQTMggQDaDyJCAIjnCPQVJEEzIIFKJgAADyZGAAHlz3WAAHwcCB1AEYDjyiSBDwAA +rd438iWIZIgGIoIBxboQuQUjgw8AAAA/ZXkFIYEPAD8AAJseWJBniCaICLtleWiIELtleWmIGLtl +eZweWJAGIQESxbmfuZkeWJAA2ZUemJCZuUweQJAkgFgeQJAKkJQeGJBvIEMAkx4YkF4MD/6IcK0D +b/imwOB44cXhxs9yoADARs9zoADgRkokAHIA3aggAAMWIE4DIYYB5QQaUAAihgQbUAAxgM9yoAC0 +R5gaWIAygLMaWIATgLQaGIDPcAAAVVXBxuB/wcXxwLTBBdgVuEHAz3AfAP//QsAA2UPBRMFFwUbB +R8E/2EjAScFKwUvBTMFNwU7BT8FQwVHBz3AAAP//UsBTwHYP7/+LcLTA0cDgfuB44cXhxiSIz3KA +ALhypojCuS5iANkPIYEDgOXPc4AApKJAgwX0JnpAoxfwRXkgoyWIFSONAyOlJohFiFlhJqUggIwh +EIBE94ohEAAgoCO5IaMAgCq4AqMA2c9woADwNiygI4MloCaDJqAkgyegJ4MooCWDKaAogyqgIYMr +oCKDLaAggySgwcbgf8HF4HjxwPYJT/gId5pxunLacwoiACEKI0AhCiGAIc9wAADIG5oKYAAKIMAh ++nDPcAAAzBuKCkAAG3DPcAAABBx+CkAAz3agAMgfO3AB2BOmBtjPdYAAiD4ApeGlCB0AFQwdQBUQ +HYAVFB2AFBgdwBQcHUAUDsAgHQAUz3GAAKQcCaUEgQCACqUIgQCAC6UMgQCADKWgFgAQDaWkFgAQ +DqWoFgAQD6XPcEN1qBIQpRIKYAAo2BGlCgpgAADYEqVTJ8B1E6UByFQdABcWpRIWAJZQHQAXF6UT +FgCWz3GgAMgcGKUUFgCWUyECMxmlFRYAlhC6GqUkFgCWG6UWFgCWHKXPcIAAVD0XgB2lz3CAAIg+ +eBiACs9wgACIPnwYwArPcIAABD8EGAALz3CAAIg+hBhACyiBiBhAAM9xgAAAACSBjBhAAC8hxwUI +uSV6LyEHBkV5kBhAAL4LYAAl2d0AT/jxwMIIT/jPc4AAHD9DgwDdz3agACwg0IbyavR/f2fFpwSn +AeKMIgiAJqdDo4X3AoOjowHgAqP1AE/44HjPcYAApBwIgQDaQKAMgQHZQKDPcKAAsB80oOB+8cBu +CG/4iiBMDaIP7/+KIZgEC8gA3gQggA////8DCxoYME4OIADJcM91gADgBhGFgOD0DCIAyiBiAKEA +b/jQpfHA4cWOCSAACHWMIP+PCPSKIAcKVg/v/6lxANiFAE/48cAOCG/4atiiwYtxAdoqDKAASHOA +4BD0CiHAD+tyz3AAANIUiiPFBIokgQpNBm/5SiUAAEAkgTFE2AHa+gugAEhzgOAP9AohwA/rcs9w +AADTFIojxQWKJAEBIQZv+UolAABeDq/4BhQAMYDgSPKBwWvYAdrCC6AASHOA4A/0CiHAD+tyz3AA +ANQUiiOFB4okwQrpBW/5SiUAAAQUADFAJIEwAdqSC6AASHOA4A/0BBQFMQohwA/rcs9wAADUFIoj +RQi5BW/5iiTBCgIUADHPdoAA4F8beEEoxQBMJYCMAB5AEdT2CiHAD+tyz3AAANUUiiOFCYUFb/mK +JMEKHdjPdoAA4F8AprhwABQAMc91gABU50AtggCpcR4LoAAB24DgD/QAFAQxABYFEAohwA/rcs9w +AADWFEUFb/mKIwUMQIaA4gDY0fYWJQEQYImGI/8NI7uB4wb0YYmA4wTyYrthqQHgUHCx9gDYEQcv ++KLA4HjxwIoOD/inwTpwenEaclpzi3DPcYAAmGNGDy/4GtrPcYAA4F8ggQDYgOG4ccQALgCKJf8f +z3GAALwUABGEAIom/x/JdQLw6XZMIYCjAdrPcYAAVOcWeWCJwiKMAEQjjwD9f/FyPfThiUQjAgQk +ukQjBgJBLsYADCCAoUQjAQEiuS/0TCRAgA70gOHMIiGAB/KB4cwiYYAA2gL0AdpPegXwgOIB2sB6 +geIb9EwiAKYB2sIiigBQcYYj/Q8nuwXygOLMIGGgDfQyd8wjIYAL8oDnA/KA4wXyMncD9vF2hfbJ +dwTwAdkJ8Ah1AeCwcFoHxf8A2Yog/w+A4QT0gOXKIEoDjCD/j8oggQ//////FfIyJII0geLPcYAA +VOcH9GJxFnkCEcAACfCC4hZ5BfQGEcAAA/AHEcAArQUv+KfA8cDaDM//dNiWDO//iiFLCt4OD/9u +CsAHBgwP/wohwA/rcj3YiiMLDkokAAChA2/5CiUAAfHAz3CAAEQeAoDCEAAGUSBAgNQOggbRwOB+ +4HjxwAYND/gacCh1OnLPcIAANKmuC+/5RNnPcqAA1At+ggAlgR8AAABAz3CAALQHYnlgoM25z3CA +ANDDL6IMgM9yoADIH2TgHqIQ2A6iAdgVGhiATXCGIPwD0ODMIIKPAACAABLyjCADhBPyCiHAD+ty +CiSACs9wAAAyEYojGg0BA2/5uHMKcNIJ7/oqcgTwFg3v+QpwgOAc8s9xnwC4/89zoP6UBnahFqHP +c4AAVMM/gwDanOCzuT+jz3GAALidS6nPcYAA7JpMscoggQCZBA/48cBCDA/4z3CgAMQnUhABhkEQ +AIaGIOOPAN0G8uu50SGigUvyz3CAAEQeA4AJgM92gAA0qVEgQIEX8nIJQASA4An0FI6B4MogIQHA +CyH/yiFhAM9wgADwqQCAUSCAgAXy1gxgABCWtK7PcIAA8KmgoE1whiD8A4wgAoAb9M9xgADkFACB +AeAAoc9wgABEHgOAGIiE4BgOwf6KIEcN4grv/4ohywO+CUAEzg6P+gXwjCADhHgNwfn5Aw/44Hjx +wIILD/gA3gLdz3eAADymQCcAG4QuCBkwIEAOUSAAgPAOov7KIIIDYb2A5QHmMvcOCCAAANi1Aw/4 +4HiA4PHAENgK8sIKz/oiDKABiiAEANHA4H56Cc/61gugAYogBABeCoAJguAG9HoKoAkA2PLx8PHg +ePHAEgsP+M92gAA4CADdC/AQ2Lh4CyEAgCQPov7KIEIDAeWD5SCGtveA4cogIQBsDCEDyiEBAEkD +D/jgePHA4cXPdYAA4AYQhYDgIfT+CYAJguAcCqEJyiAhAAHYEKX+CO/6EdhCCmAAENiA4BGlCfLq +CO/6ENhGC6ABiiAEAM9wAADE+CYKb/+A2f0CD/jgePHAggoP+M92gADgBs91gAAkJQOG8CUAEEB4 +gOD789ECD/jgePHAz3GAAEQlAIHXcACAAAAF9AYLz/vRwOB+AIHXcABAAAAO9M9wgACkHCSAIIFu +Ce//iiBMDL4Jz/vv8e3x4HgB2s9xgADAJEOpGKEocGTZddoe2+EBoAcYu+B48cDPcYAA4AYDoXoJ +7/oR2NYKoAGKIAgA0cDgfvHA5gkv+AHaocGB4M9xgAC8JEChLfTPdYAALKgahYwgw48K8gDahCgI +CQAhgX+AAGymQKnPdoAA4AYMhoDgB/KKD+//C4YA2Aym/9gape4NoAiLcIDgDfJaDEAEAMHPcIAA +uCQgoK4O4AgA2BHwwg+v+hHYPgxABBYKoAGKIAgAngiACYLgvAihCcogIQDFAS/4ocDxwM9wAAAg +TloJAAvPcYAAQCUAoc9xAAC4C89wgACsJCCgz3AAAIgTOgkAC89xgACwJAChz3APAEBCKgkAC89x +gAC0JAChBdgaCSALC7jPcYAARCkAodHA4H7geOHF4cZBLQBUwbiD4An3MyYAcIAATGJAJ4FyFHkA +eQDYF/DPcYAAVMOYEYAAQCgCBoYg/Q9SIMABRbhFeM9yoACIJBCiH4GzuB+hSvAB2BDbz3GgAMgc +aaHPc4AAVMOYE40AANrPdoAAkG/GhkAtARaGJf0fUiXNEcV5Rb2lec91oACIJDClP4MC3UQoPg0A +IYB/gACI1ZW5P6PPcaAA8Be9oaSAihMDAaaho4AU46ahooBTI8OApqGhgKahwCAhCMAgIgxggHOh +bGhgg3Oh+BADgnOh/BAAgBOhSqHBxuB/wcXgePHA4cWhwQh1z3DUuv7KQMAE8BYPIAsB2M9xnwC4 +/7qhBNgboYtwHqEA2p26z3CgANAbUaDPcABtABAZoQTw+giv/zDYUSFAx/vziiCbBQIPr/+pcYog +mwX2Dq//AMEAwNdw1Lr+ytfzHQAv+KHA4HgA289ynwC4/xqie6I+os9wAGwEABmi4H7xwIoP7/eY +cCh2GgggAEh1BiCBA4hwUgggAKV52QfP989xgABgKWCJgOPPcp8AuP8F8s9x0Lr+yj6iGqKA4w7y +z3CgADguBYAEIIAPwAAAANdwwAAAAPbzatgYuBmiHILgfuB44cXPcoAAYCmgioDlz3KfALj/BvLP +c9C6/sp+ohqiO6KA5Q7yz3CgADguBYAEIIAPwAAAANdwwAAAAPbzadgYuBmi4H/BxeB48cDSDs/3 +GnEEII4P8AAAAAQggA8BAADwQSgRA891oADALxUlTRRTFQCWz3CgAIQtNL7wIIADXg0gB8lwCiQA +gM93oP6QBBDy6XHPcJ8AuP82oBZuliACAMdwgACAzW4JIAAQ2VUnwRTPcJ8AuP82oEApACEAII4P +gAAg1MlwTgkgAATZTCAAoDfyFhUClioVAZYAhqGGB31jhgKGZ3gFJQ2QL3kc9FYiAAgieA94wOBW +98W6YbnFuTByEvJEIgAIJLjwJgAQUyIPAQDbDyPDAwHixbowcmR4BX3y9QUkfoML8gohwA/rcljY +jLiKI08IWQQv+bh1PQbP9+B48cDWDc/3BCCBD/AAAAAEIIAPAQAA8EEoEAPPdaD+pAOpcM92nwC4 +/xamz3egAMAvehcAlhUXAJZBKREFohcAlmoIL/gB2BUnABRTEAGGFhABhioQAIZWCC/4AdgVJ08U +mBcAlpAXAJZxFwCWQCUAGxamQCnAIcdwgACAzVIIIAAg2VYlQBIWpkApgCGWIAIAx3CAAIDNOggg +ABDZVSVAGRamz3GAACDUQCgAIThgIgggAATZViWAFhamz3CAAGDVDgggAArZcQXP9+B44cXPdaD+ +nAIA2s9znwC4/7ajgOHKJE1w4HjoIG0D8CCBADaj4HjgeOB44HjgeOB4AeLgf8HF4HjxwNoMz/cI +d89yoP5sA89wnwC4/1aggOEA3dH3KHZaDe//FSdAE+B44HjgeOB44HjgeGG+gOYB5TP3CQXP9+B4 +8cCaDM/3CHfPcqD+NAPPcJ8AuP9WoIDhAN3R9yh2Gg3v//AnQBPgeOB44HjgeOB44HhhvoDmAeUz +98kEz/fgeOHFz3Wg/tQCANrPc58AuP+2o4DhyiRNcOB46CBtA/AggQAggeB44HjgeOB44HjgeAHi +4H/BxeB48cAiDO/3iiAKBut1Vguv/4ohRA+KIAoGSguv/6lxz3aAAOgXAIZRIECAGvTPdYAAkBwA +hVIggAAApQnwz3CgAKggDYDk4BwBBQB2DO//VNgAFQQQhiD/DpBw8vWKIAoGAguv/4ohRQPPd4AA +QCaYFwCWUSCAgD7yzgvP/s91gABEHskVABaluMkdGBCTFwCWpbiTHxiQ1xUAFqW41x0YEA6FpbgO +pQCFyBAABoYgf47KICIAyiECACgKYvjKIqIBAYXIEAAGhiB/jsogYgDKISIAEApi+MoiogEAhc9x +gABYwcQQAAYluMC4bgvv+wqhiiAKBm4Kr/+KIUUJKg2P/X/YCrjPcaAA0BsToX/YEKEA2JW4EKHP +cQAA0CBCCiAABtjPcaAA8DYEgUYgwAEEoZTY0gvv/xjZiiAKBiYKr/8ghgCGUSBAgJgPIgHKICIA +iiAKBg4Kr/+KIQYALQPP9wohwA/rctvYBLiKIwUCJQEv+UolAADgePHArgrv94ogSgbiCa//iiGG +AiIMoAkB2M9wpQAIDADdz3aAAJAkoqAEhlEggIB8CAL5z3EAABAHrgkgAAbYC8gFIIAPAQAA/Asa +GDAEhlEggIAR8s9wgABkOACAgOAL9EINL/+KIMYIgeAF9LIPgAUM8ADZnrnPcKAA/EQhoOB4oaDK +D2AHANgWC8/7kg8AAdYMYAgB2GIIr/oB2H0Cz/fxwAoKz/eA4Ih1AN8J8oHgC/QB3s9wgADAFMCo +BfDPcIAAwBTgqIDhCfKB4Qv0AdnPcIAAvRQgqAXwz3CAAL0U4KiA4gnygeIL9AHZz3CAAL8UIKgF +8M9wgAC/FOCoz3agAMgfz3CAAMAUGB7YkwCIgOCKIRAAEvLPcIAAgR0AiIDgDPLPcAMAQA1FHhgQ +MKYC2BgeGJAD8DGmz3CAAL0UAIiA4Bzyz3CAAIIdAIiA4Bbyz3ACAG55IB4YkM9wgAAoACEeGJDP +cIAA/AUiHhiQGBYAlkUgAAMYHhiQz3CAAL8UAIiA4AjyGBYAloUgAQQYHhiQgeMH9BgWAJaIuBge +GJAYFgCWgLgYHhiQgOUZ8gDYlLjPdYAAWAgApXHYBrjKCe///Nkghc9wAABMHL4J7/+fuRgWAJaF +uBgeGJA1Ac/34HiA4fHAmHAF8kwkAIiP9s9wgACEBgAQBQAKIcAP63LPcAAA2g4RB+/4edvPcIAA +aCkVIAABIKDRwOB+4HgA2UokgHHPc4AAwJcocqggwAHwI4AAAeIFeeB/LyhBAOHFANpKJIBxz3WA +AMCXSHOoIIAB8CXBEAHjJXoA2Z65GXkEIYAAQiAAgMogYgDgf8HF4HjxwIogyQNyD2//iiHMB89x +oADIH6QRAgDPcIAAODQAgDWBz3OAAAibliBBDxByANrKIm8AAYPVuYHgAdgC8gCDgeAG9NdxAACI +E4T3ANgD8AHYgeLMIGKAKA5h+sog4QHRwOB+AuEweUFpUHDE9iJ4EHgD8ALYz3GgAMgfHqEQ2A6h +AdgVGRiA4H7gePHA4cVQ3QDaz3OgAMgfr6NeowIgQgBeowHaFRuYgEDaTqMEIL7PAAIAELAPwf/1 +B4/34HgA2c9wgADwqSGgz3CAAFTDHJBiuEggQAAQec9yoADIHx+CEHgIIQEAMHkC2BUaGIA/ouB+ +AuEweUFpUHDE9iJ4EHgD8ALYz3GgAMgfH6GKIBgIDqEC2BUZGIDgfgDZz3CAAPCpIKAhoOB/IqDh +xeHGgODPcYAAeN9FgSXyz3GgAMgfQBEOBs9zgABUw0AojQJCEwABfJPQfthgu2NiuwgjAwACewki +wgAC2BUZGIDPcIAARB5foQOAIoDPcIAA8KkioMHG4H/BxeB+4HjgfwDY4cT8HMi+/BxIvuHA4cHh +wuHD/BwIsfwcSLH8HIix/BzIsfwcCLL8HEiy/ByIsvwcyLLhxeHG4cf8HAi0/BxItPwciLT8HMi0 +/BwIv2okgBDhxGokwBDhxPHAz3WgAMgfGRUSlnvYgg1v/4ohBAPPdp8AuP/9hgohwCdA2Z+5PabP +caD+HAA2plMmwDQFIIAPsP4AABamz3AAAEQcpg6v/wogwC96cBkVAJZRIACCEPJYHoAXIRUAliIV +AJbPcYAAUAgAgRamAYEWpv2mB9h2Dq//CrhTIEEHB9iuDq//CrjPcKAA1AsYgEIgAAhIIAAAz3WA +AGQ7vB0YEM9wgABYCACACyDAhMomIhPKIGIAZvRMIoCgQfRv2CoOr/8GuM9wAADQGx4Oj//PcAAA +1BsWDo//z3AAANgbCg6P/wfYBg6v/wq4z3AAAAQc+g2P/89wAAAIHO4Nj//PcAAADBzmDY//z3AA +ABAc2g2P/89wAABEHNINj/9RI4ClDfK8FQAWgOAJ9EErTiXAvgO+XOYB2CTwNN4h8IwiBKAc8kwi +AKIU8gr2TCJAoA7yTCIAoRT0ht4T8EwiAKQK8owiAaAM9EzeC/Bm3gnwPN4H8EbeBfBU3gPwhN4A +2IHg+ApBBZMVAxbJcApxKnIKJIAEKQPv+AolwATxwLIMr/cB2qLBz3aAACArCI7PdYAAoCpEKD4L +QCUAFSdwIgrgB4txCI6Bx+lxRCg+C0AlABYncAoK4AcB2giORCg+CwAlQR5AIQANFOH2CeAHAdoI +jkQoPgsAJUEeQCEADhjh3gngBwHaCI5AJQEdRCg+C4twJ3HKCeAHAdoIjjjlRCg+C+lwACVBHrYJ +4AcB2okEr/eiwOB+4HjgfwHYz3KAAOAGIoIliYDhEvLPcYAALKh6gc9xgABopoQrCAkwIUEOUSFA +gAT0CNgLogHYCaIA2ASiBdgDouB+8cDhxYDjCHUocAbyz3GAAACOBfDPcYAAAHZben4Mr/e0eS0E +r/cB2M9wgADaBgCQgOAH8gDZz3CkABxAMqDgfs9wgADaBgCQgOAH8gPZz3CkABxAMqDgfvHAcguP +9zByugAlAFpwInoB4ih3QCqAIM9xgAAQ1xpyO2cWeBpjUoqMIsOPACMRAEPyz3aAACQqYIYA3fC7 +DyWNEA7yz3KgAEguS4LTugslgJAG8gBhUSBAgifyrg/P/oDgFvTPcIAAjCEskM9wgABEHh6QEHET +9ACGBCC+jwAAOBAN9CoMz/6A4Anyz3GgADguB4GleAehDPBGFgAWpXhGHhgQBvBFFgAWpXhFHhgQ +/9kSGUIgQiBCIIDiVgft/yFvDQOP9+B4z3EBAMcDz3CgAOwnJqDgfvHAogqP9xpwOguv/yTYmHBR +IACAyiHBD8oiwQfKIIEPAABRJsojgQ8AACkB6ADh+MolAQTPcaAArC9MIACgGIFI9Pq4BvLPcIAA +9CkAgEB49NgA2c4Kr/8B2jTYANmRucIKr/8A2jDYiiEGALYKr/8A2jTYANkD2qoKr/8UusYKr/8w +2MK4geAD9ADYB/AE3T/YVglv/6lxqXDPcgEAxgPPcaAA7CdGoc9zoAC0DzyDgOEl8gESBDZwEwUA +CiHAD+tyz3AAAFImTQDv+IojRQaauBih6gjgCoogDwrPcIAA9CkAgEB42gjgCgHYsgzv/oogBQOA +4AX0BNgNAo/3RNnPcKAAyBwpoLYI4AoB2BYJwAG98fHAjgmP96LBKHYKJICAAN/PdaAALCBAFRAQ +ABzEMxTyTCRAgEHyTCSAgJLyCiHAD+tyz3AAAFQmiiNEBcUHr/gKJQAEMmgEIYEPAAD8/yYKr/8s +2BCFAiAABIwgD4oK984Jr/8s2FEgAIAId/TzCPAghoC5IKZeCG//P9iyCa//NNj1uA3yIIaBuSCm +Rghv/z/YNNgA2QDadgmv/5W6ML8CHMQziPAPeRC5BSGCDwAAgv3PcaAA7CdGoQQggA8AAAAfSLiG +uBC4BSCADwAAQv0GoRCFAiAABIwgD4oM94tx7g9v+IogDw0AFAAxUSAAgPHzCPAghoC5IKbaDy// +P9iBwc4Pb/iKIE8MBBQAMVEggIAI8iCGgbkgproPL/8/2It1iiCPD6oPb/ipcSDACLgCHAQwiiDP +D5YPb/ipcSDBAhQAMSV4AhwEMDbwz3EDAEL+z3egAOwnJqfPcQQAAv4mp4a4EHgQuAUggA8AAEL9 +BqcQhQIgAASMIA+KDPeLcU4Pb/iKIE8PABQAMVEgAIHx8wjwIIaAuSCmOg8v/z/Yz3AGAAL/BqdA +JIEwIg9v+Iogzw5A2B4PL/8CFAExAhQAMTEAr/eiwM9xgABEHgCBAqEDoc9woAA4Looh/w8noM9w +gAAkKl0GL/mKIQgA4HjxwKYL7/7hxYDgWvLPdYAAJCoAFQQQANlRJACCyiHBD8oiwQfKIIEPAADJ +G8ojgQ8AAEcF3AWh+MolIQCEFQAQVx1YEFgdWBAB4IQdABDPcIAAkAYgoFYVABYB4FYdGBDPcIAA +NKktiIDhyfZMiFBxxfb2HUIQ+B2AEHYM4AEk4ACF7bgQ9I24xg8gBwClgOAK9AvIBSCADwAAANQL +GhgwSguP9wCF7rgK8q64qgov+QClheAQDSH5yiAhAl0HT/fxwOHFCHWKIBQNGg4v/6lxANjPcacA +iEmB5cog4QAOoTkHT/fxwMIOT/fPdYAANCygjQDegOXAoxr0geDMISGAFvKg4kT2wKMA2ArwwOIG +2AX2QiIACEO4AuAAo1B5ELkQfYoglA2+DS//pXnlBk/3uHBA3AAhAIPxwA4AJACYcYwgAoCL9goh +wA/rcs9wAADJFMEEr/iKI8gPz3CAAPRl9CAAAc9xgAD0ZgQofgEvcPUhAQFCKAMEwbtSuAQpfgEv +cUIpAgTBulK5gePAIGkAgeLAIWkAiCA+AIkgwQ+IIT4AiSHBD4Dg1iArCIDh1iErCL4JAADRwOB+ +4HjxwNYNT/ehwTpxAN+A4MohwQ/KIsEHyiCBDwAAyhTKI4EPAADTAsokwQAsBKH4yiXBA89xgAA4 +LECxz3GAADos4LFMIQCgyiXOE2gALgDKJs4TGndadwXwyXcadWpwQCBTAItxAdquCe//ANsAFA0x +LyPIJKl2Kb3Ivr/l2SUpFEwiAKDKIMIDyiGCA8oiAgT4DSIAyiNCA8lw3g7v/6lxQiFRIEwhAKCw +B+3/QCJSIMlwZgkgAKlxdQVv96HA4HjxwBYNT/d6cM9wgAA0LACIgOAacWz0z3GAAKgHpYkEiR1l +cnXKIcwPyiLMB8ogjA8AAMsUyiOMDwAAOAPKJMwEVAOs+MolTAMA3QDeKPAA2c9wgAA1LCCoSnCK +2eYO7/8qcs9wgAA1LACIUyXBEBi5w7gcuAV5z3gQuAV5iiBUDeYLL//leS8hiAQQuYogVA3WCy// +BSFBBAHmz34AIIEvgACoByaJAWkQdjoACgBAK4IgVHq1etR6z3OAAHyqV2OA5xJt6vNAJ5IQLyKI +JNR4gOHPcoAAcKo0IhEAufUB2bjxAeWvfYPlYgfL/4EET/fxwDYMT/fPc4AAOixAk1MiTYAh8oLl +JPTPdYAAqAcJrSitIoXPdoAAOCwAlindEr3Pd4AANSwVJQwQIKTgj4DnBvJWIA8I8H/1fSClAeAA +tgbwz3WAAKgHC60qrQHiQQRv90Cz8cDOC0/3CHYacc91gAA6LOCVC/DMf3oNb/dAKUBxRbhCDe// +CnEglYwhEIC09gUET/fgePHAjgtP9wh2z3CAADQsAIh6cYDgocEacob0z3GAAKgHpYkEiR1lcnXK +IcwPyiLMB8ogjA8AAMwUyiOMDwAAhQPKJMwEyAGs+MolTAMA3wDdIPABFIAwAR4SEAYRgSCA4QEU +gDAD9AEeEhAgwAMUgjABFIEwGLgUugV6AhSAMBC4BXqKIJQNWgov/0V5AeWvfc9xgACoBwAhAAQG +iAHgEHV6ACoAACERBEArgCAUePV4tHjPcYAAfKo0IRIAUyfAEBi4r3kQuQV5iiCUDRIKL/8FIYEE +TCIAoADZGPKLcUpwAtrqDq//ANuA4LX1CiHAD+tyz3AAAM0UiiOOBgokgAQNAa/4SiWAAAEeUhAG +EYAggOC+9QEeUhC68QHn73+D5y4Hy//BAm/3ocDgeADbgOBgqWCqxvaO4AT2YKngf2CqouCH9sDg +BfYB2ACpEfDk4Ib2jCACg8ogrADJ9owgQoSJ9owgQokH9gPYAKkB2OB/AKrgfvHAHgpP96PBSiEA +IItxKnBKIAAhCnJCDq//KnOA4A/0CiHAD+tyU9gGuIojBQEKJEAEaQCv+AolAAQgwoDiivYAwEEo +AQJTIcQATCTAgMn2AdnPcIAANCxvAiAAIKjPcYAAqAdAqQIZAgFBKA4DUybFEAMZQgFMJcCAyiLJ +B8ogiQ8AAMIUyiOJDwAAWAEMAKn4yiHJD0EoAgRTIsYABBmCAUEoAgVTIsUABRlCAUwmQIDMJeyA +yiHJD8oiyQfKIIkPAADDFMojiQ8AAF4BzAdp+MokiQFBKAIGUyLEAAYZAgFBKAUHBxlCAUwkQIDM +JWyAyiLJB8ogiQ8AAMQUyiOJDwAAZAGUB2n4yiHJDwQUhTCMJQGEvgAsAAEZQgEKIcAP63LPcAAA +xRSKI0UKbQdv+Jhzz3WAAHyqAN8D8AHn739BKAECw7kwd3QACgAA3hLwQCmBIDR5ChSAMBUhQQEB +5s9+FHm5YQAZBASAIAIjLyAIJADAQSgBBsO5AeEwdr4Hyv+CwQpwAtrODK//ANsLFIQwLygBAU4g +hQcvJUcBTCXAgK4Hy/8KIcAP63LPcAAAxhTlBm/4iiNGAkAhUSAvIUckQSgBBMO5MnFuB8n/BfBM +JgCAYAfJ/0EoAQXDuYDhCnWyACwASiAAIEoiACAF8EAiUiAvIockQSgBA8O5UnGCAAwASiEAIBXw +Ar7UfgoUgDAVJk4RQCFRIC8hRyQUfgAmgB+AAHyqoLCAJQITsH0AwEEoAQcB4TJxtgfM/zC4w7gA +IA4EgsGpcALaCgyv/wDbCxSEMC8oAQFOIIUHLyVHAUwlwICkB+v/z34KIcAP63LPcAAAxxQhBm/4 +iiOGCEAgUCAvIAckQSgBBcO5EnFcB8n/09kIuQDYA97PcoAAcKoA27JodH1dZSC1AeNve4LjViEB +CDB5t/ZhvoDmAeAPeDD3tQcv96PA8cA+Dw/3osFAwEHCQCgUBUApFwUA3UAqEwVAKxIFAd5KJYAh +qXcE8Ap1yncAwBW4E3gUIMAF5ghv9wfZAiBQAwIgQCPWCG/3DtnMfgohQC4EKT5wL3CsfgAhDXUd +ZQHAFbgTeBQggASyCG/3B9kCINYDAibAI6YIb/cO2QQofgQvcex+ACHAdBlhQi0AFWII7/9UuUIl +VSBMJQCgAeaMB+3/z37hBi/3osDgePHAlg4P9wh2unHPcIAAVMMAkADZSiNAIEoiQCCGIPwAjCAC +gMIjwiRKIIAgz3CAALidK6iacc9woADQDyUQD4YlEA2GYr4QEBGGsXZAJFQgkveifhJ2yiAuIEoI +r/fpcEwjAKCYcADYE/KF5wnyi+cF8gjwSiYAIDPwAdgC8ALYz3GAAMgUJIELIQCAA/IA2gLwAdoA +IEAjJguv+CpxCiYAoB/yTCQAghLyz3CAADgdFiAAAUCABogQdyD0gOIe8qlwYHqqcQoiAKAL8iJ1 +z3CgANAPEBhYg0wgAKCt9c9xoP6IBc9ynwC4/0wmAKDMIiKgEvIA2BPwCiHAD+tyz3AAADERiiMX +C0okAAAVBG/4CiUAAShwFqIT2DjhNqIQvgUmARU2or0FD/fgePHA4cXPcIAACC4IEAQATCQAgMoh +wQ/KIsEHyiCBDwAAaRnKI4EPAADQAcwDYfjKJQEBz3KlAAgMCBIFAADZTCUAgMwlIoTKIcIPyiLC +B8oggg8AAH0ZyiOCDwAA1wGYA2L4yiQiAEDYAqLPcIAAzLNggArw9CBNAM9wpgAAgDV4AeGgoNLh +hCsCCgAkQA6096QQAwHPcaQAoD99oaYQAAEeoQgaQAFZBQ/34HjxwIIkAzKLcM9xgADMYpINL/fI +2kokQHYA2aggQAMWJEAwYYBAkCvYErgB4VV4YKAweYAkAzLRwOB+4HjxwBIPIABH2ADaz3GrAKD/ +WaEH2BqhWKHRwOB+4H7geOB+4HjxwM9xgAAILjiBgOF0DgIA0cDgfvHAz3GAAAguPYGA4RAIQgDR +wOB+fQeACXkHgAl1B4AJANnPcIAAzLMhoKUGYAIioPHA4cXPdYAAzLPuD2ACqXC4cACFgOAT8kok +gHPPc4AAHCoA2agggAJAg0QpvgMyIkIOsHIe8gHhEPAA2UokgHnPcoAAbGyoIIACRCm+AzIiQw6w +cw7yAeEKIcAP63LPcAAAhhmKI0QBPQJv+EokAAA9BC/3KHDgeM9wgADMs0CAgOIjgAvyz3CAABwq +AIBEKb4DDeAyIEAOCPDPcIAAeWxEKb4DMiBADuB+4HjPcAAAAT/PcaoA8EMFoc9wAAA+PQahz3IA +AD09R6GKIMwPCKEJ2Iy4CaHPcAAAFhwKoc9wAAAfHwuhz3AAABwWDKGR2AS4DaHPcAAAAz8OoU+h +z3AAAD0+EKGKIMQPEaHgfuB48cAiCw/3ugygAgDdjg0gAAfYPg7v/xpwz3akALg9rBYAFs93pQDY +yznZorisHhgQrKfPcBUAKyv2HlgTmh4YEIogxACfHhgQGtjzHhgQ9B4YEGTYyB4YEKrYyR4YEGnY +zB4YEMDYzR4YEM9wpQAIDD6gLg/P/yYKIAAKcBjYlR4YEM9xgABUHKGhyNgCoQChA6HPcQIAQA/P +cIAAZBbUGEAAlNgLp0HZz3ClAMx/LaDPcKQADICioM0CD/fxwBoIAABCD8//Rg4AAB4JT/rRwOB+ +4HjxwEYKD/fPcIAAeMBAIBIGCHHPcIAArAYgoADexKgE30QuPhcKIUAuACGAf4AAeMDSCO/4HNmE +LgoSACGNf4AA6LOpcL4I7/iKIQoChC4CFwAhgH+AAAi+GnCqCO/4nNkAIZEkABlAI2G/gOehHRgU +sAft/wHmLQIP9+B48cDGCQ/3CHdacTpyGnMKIwAhiiYbGMlw/gjv/ulxRC8+FwAhjX+AAHjAyXDq +CO/+IY3JcOII7/4gjclw2gjv/iKNyXDSCO/+I43wrQHYEa0BHYIUAB1CFAIdAhQDHcIUEh0CFBMd +whRmCSAA6XCxAQ/34HjxwFoJL/dEKD4HGnA6cc9xgAB4wC9wGmFRioHiG2EP8gohwA/rcs9wAACy +KF7biiTDD6EHL/gKJQAETCDAoAnyz3KAAKwGBBoCBDhgAKIBiyCLUosODCAAc4sOCIABCnCGDSAA +KnFVAQ/34HjxwOHFCHWSDqAGANh6Cg/7RNnPcKAAyBwpoKoLL/cc2M9woACsLxiA+rgK9IogEQMG +CO/+S9laDWACqXD/2c9wqwCg/zmgOKAeDyABqXAhAQ/34HjxwOHFAgzv/wh1UgrgAqlwCQEP989x +oADIHAihUQMv9wbY4HjxwH4ID/eiwaKBYJDPdoAASAe4e6OBZH1ghqV7poEBkLh4p4FgpqR4oYZA +IQ8EgOKleAGmHPIBgQIcxDAwuwQcxDAAHAQwIIGLdWB5qXABhyGGAhxEMDC5BBxEMCCHABwEMGB5 +qXAA2ACmAaZ5AC/3osDgePHACggv95zZCHbPdYAACL6EKAIHL3emDq/4ACVAHlYOoAH4ZQYJIADJ +cEkAD/fgePHA3g/v9gHahCgCBwAhjX+AAAi+z3CAAKwGAIAodiCIAIaZHYIQTIUwuIHiD3hG9BBx +A9qZHYIQQPQE2JkdAhAQhYDgDPQF2JkdAhAIhhKlA4YRpRyGFKUXhhOlqXDaCqAByXEQhQHgkOBQ +ACUAEKUG2JkdAhCpcMoMoAHJcalw6g2gAclxqXBKDKAByXGpcDYOoAHJcalwQg6gAalxmBWAEIHg +CvQH2JkdAhByCCAAAm0A2JgdAhCRB8/28cDhxQh1hCgCBwAhgH+AAAi+z3KAAFQ6SJJRIkCADvIg +gYXhivcA2S2gLqBaDaABL6D2CCAAqXBdB8/2hCgCBwAhgH+AAAi+z3GAAFQ6KJFRIUCAA/IB2Syg +ANngfzCg8cDCDs/2CHUqCSAABdhAlSGVCLpFec9ypAC4PZsaWAAilc9zpAC0RcoaWAAjlcsaWAAk +lcQaWAAllcYaWAAmlccaWAAnlcIaWAAolcMaWAAplcUaWAAqlaMaWADPcYAARB4jgSiBUSEAgADe +C/JMlSuVW3pFeVMbWIAtlVQbWIAF8FMbmINUG5iDLpVWG1iAL5VYG1iAMJVVG1iAMZVXG1iAMpVa +G1iAM5VcG1iANJVZG1iANZVbG1iAeg3P/3EGz/bgePHAhCgCB89xgABUOiiRUyFBgM9ygAAKvi9w +BfIiD+//WGDRwOB+4HjxwOHFz3CAABQqIIAB3WB5qXDnuCe4UiAAAMolIhDKIUIDyiHhAcC4E3jC +uM9ypwAUSAuiLKLPcKoA4AezoA0Gz/bgePHA4cXPcaAAyByogQihTggv9wbY8QXv9qlw4HjxwHYN +z/YIds91gADMswClIaVYrSoJ7/95rZ4J7/8DpQSlBvB2Dm/+iiCJDM9woAB4RQCABCCAD3AAAABB +KD6FAN3y9c4KoAapcM9xqwCg/7mhB9gaobihWgmAAoDmAdjAeAzgLg+v+QHZeQXP9uB48cD2DM/2 +CHfPdYAAzLMYjUh2EHIacTpzCPSA5gT0GY0ycAT0ANgD8AHYLyIHIOlwhg5gAslxIIUwdwDYBvQh +hRJxzCIhoAPyAdgvJgfwGq0q8oogWwjuC6/+6XGKIFsI4guv/gpxiiBbCNoLr/7JcYogWwjOC6/+ +KnHpcApxyXISD+//KnOmCQADAYXPcYAA2AYAsQCFAbEYjQSp6gggAypwCfCA5wHYwHgM4HYOr/kB +2aEEz/bgePHACHMA2QLahCsKAgAhgH+AAOizhCkEDwTgugugBidwYbqA4gHhMvfRwOB+8cDPcIAA +mOPGCq/4iiEJDM9wgABkIboKr/gU2c9wgACIJK4Kr/gU2dHA4H7xwN4Lz/aiwTpwGnEA3VoO7/8H +2JpwAtmpcFpwenEA2zRoAnEodRQhACBocsKFBBAPBdh/w4UB4sR/g+LleyDltvcBgQIcxDAwuwAc +BDAggQQcxDBgeYtwQiNBIIDhvgft/0AiQCACC+//inDFA+/2osDgePHAcgvP9jpwWnHPd4AArDoM +j892gADMs6WGhiD/AUO4DiUNkM9wgAAEKiCAyiViEGB5BNiA4CPyGo6A4MwlIZAd8gDYEN0acAK4 +FXjHcIAAjC0ggIDhB/IigIDhFPJgeSpwYb2A5UAgQCAv9wDYGq4Mj4Yg/wFDuAWmbg0v90pwTQPP +9gohwA/rcs9wAABlGTfbCiQABFkBL/i4c/HA4cUIdSCQApVBlRC4BXop2BK4FSBBAEChIJXwIEEA +MHIO8v4Jr/6KINEDApUhlRC4BXnuCa/+iiDRAx0Dz/bxwOHFz3WAAOjAIIWA4R3y0gmv/oogSgwA +hYDgB/LPcYAAFMEAoQiFCKEA2AClBKW+CK/5Cdi6CK/5A9jPcIAAIFvWCgAIz3CAALAwkgngAAOA +iiAKA44Jr/6KIQ8CANnPcIAAcDS1Au/2L6g1BE/58cDhxYogyQNqCa/+iiEOB7ILIAMA3c9wgADo +WooKAAjPcIAABFuCCgAIz3CAACBbdgoACIogygE6Ca/+iiHOCM9wgACwMKKgNgiv+QPYz3CAADg0 +o6BVAu/2oaDxwOHFz3GgAKwvHIG9gQR9z3CAAIAdAIiB4An0z3DA3wEAHKEo2Ri5G/CKIMkD6giv +/oohTwmKIIkD3giv/qlx/L0K8oogigXOCK/+iiEPC/IMAAP2vbALgvkA2Zu5z3CgANAbMaDpAc/2 +4HjxwCIIAADeCUAA0cDgfuB4z3CAALAwAICB4AHY4H/AePHATgnP9s9wgABYwceAwL6B5gHez3GA +ABw2AIHAfuG4LPSBuAChz3WgAMAvE4X6uATyE4W6uBOlAtgRpc9wgAAEKiCAYHkA2IjgDPQWCCAK +CtgM8M9woACoIA2A5OCQ9xCFUSAAgPjzQgjv/8lwFRUAloC4FR0YkEEBz/ZcFQQQQBUFEAohwA/r +coogTAktB+/3iiOGDeB48cCmCM/2CHXPdqAAwC8ahjm4UiAAAFMgEQAUhlEgwIAH9C4J7/4k2PK4 +AN8C8gHfURYAloDgC/SjFgCWBCCADwAAAA+MIBCAA/QA2ALwAdgacAQhkk8ABAAAz3AAAAgc7gjP +/j+4UiADAAQggE8CAAAA13ACAAAAAdrAegxwhiA9AIDgAdnAeVEggMEI8s9wgADkBwCAgeAA2AP0 +AdgB3uW9yiGBI0whAKAo8ua9yidhEIDnIvLjvcoiYSBMIgCgHPLkvcojYQCA4xjy4r3KIGEgTCAA +oBLy4b3KImEAgOIM8uC9yiFhAIDhCPJRJcCRyiBhAIDgBPQA2APwAdgFAO/2D3jxwLIPj/anwQh2 +z3CAADxkIIABgEXBRsCKIMoB0g5v/i1oz3CAALAwAoBExgzZFSQCMM9woAAsILCAz3ABACRCQMAB +2EHAQsAQ2EPARYIA2AhzmHC4cAAlhx8AAAB9Rg5v/NhwuQev9qfA4HjxwNoLz/3PcqAAwC8A2Yga +QAATgou4E6LPcIAAuBMBkBC4RSAAD8AaAADPcIAAxDMSCW/5IKDRwOB+4HjxwAoPr/YA2Zu5z3Cg +ANAbMaCuCOAAAN6A4Cfyz3CAAJASMYCA4c91gAB8HAzyz3CfALj/PaAkhQHhs7m1ubi5JKU2oM9w +gADkByCAz3CAAPAz8CBAAEB4AIXxuAXyz3CfALj/3aARB4/24HjxwJYOr/ZU2Rpwz3aAAFjBp4bA +vYHlAd3AfcINb/6KIMkDiiBJB7YNb/4Kcc9wgABEHgCAxBAABlEgQIEb8s9wgAC4EwGQz3GAAOgH +4IE84BlnZOEScY/3CiHAD+tyH2eKIMwIWtsKJAAEoQTv91UnRRYHhoPgAN8O9M9wgAC4EyGQz3CA +AOgHAIA84ThgZOACIBAgz3CAAMgVAIhRIICAB/LPcaAAwB0AgaC4AKELyAQggA/+//8DCxoYMAvI +h7gLGhgw4gyv/6lwz3GfALj/XYHPcIAAiAZAoP2hHNkX8M9woADIOzaAVoCGIf8IhiL/CEV5VoCG +Iv8IRXnPcqAAqCBNguTiUAAFAIDh6vVOD4AAz3agAMAvURYAloDgBvQMdIQkwp8l8heG+bgh9M9w +gADoFwCAUSBAgBv0CiHAD+tyCiQACFEWBZaKIEwIvQPv93/bOBAEAFgQBQAKIcAP63LPcAAAmSGh +A+/3L9uB5Sn0iiDJA2YMb/6H2RCGUSAAgBr0z3WAAAwqIIVgeQHYheAH9CCFYHkC2ILgDPJAFgQQ +CiHAD+tyiiCMCI3bXQPv97hziiAQARGmEIZRIACA/fUUhqu4FKbPcIAA6BcAgILgEtjAKCIGyiAh +AM8gYQYZps9xoADIHxgRAIahuBgZGICKIBAAEaEJ2Ai4D6EThqm4E6bPcIAAWMEHgIPgzCDigQf0 +QCiAIJ+4iB4AENIPwAfPcIAAHDbRBK/24KDgeIHh8cAE9E4NAAAE8AoNAADRwOB+8cASDqAA4cXS +C2/5GtjPcIAAyDMAkM9ygABAwVIgAQDAuQHh4bggqgDZC/TPdYAAODRqhYHjBfJrhYHjAvQB2SOq +QSiBAsC5NKopuMC4z3GAALAweQSv9gCh4HjxwPYLr/aKIIkKz3agAMAvt4b6hogWEBAiC2/+6NmK +IIkKGgtv/qlxiiCJCg4Lb/7pcYogiQoGC2/+CnEwhv4Kb/6KIIkKM4byCm/+iiCJCgfYz3egAMgf +GR8YkAHYCHEIcghzjgnv/phwLgyv/lTYUSAAgQn0z3CAAIgGIIDPcJ8AuP89oIAWDRAivVYN4Aep +cIogiQqmCm/+qXHPcYAA2DwSgbhgEqEA2IgeABAJ2Ai4DqelA4/28cBGC6/2ANnPdZ8AuP9dhc92 +gACIBkCmPaUc2RXwz3OgAMg7NoNEIQIHNoOGIf8IJXo2g4Yh/whFec9yoACoIE2C5OKJ94Dh6/VK +Cs//gOAQ9ADYLfA4EwQAWBMFAAohwA/rcs9wAACZIUkB7/cv2wCGHaVWDGAIANiKIAkFBgpv/ooh +TAbPcYAA5AcggYogTAZeCKAAA9rmCaAAA9jWCM/7CNheDSAAiiH/DwHYBQOP9uB48cDPcIAA5AcA +gIPgB/SSDA/8FgnP//4IQADRwOB+4HjxwGYKr/aW2Rpwpglv/oogCgMA3QohgC+AAGg0Bd/PdoAA +yDO1fgOGTCBAoBUhTCMApAn0iiAKA3YJb/6c2QHYA6Zhv4DnAeWvfSv3AdnPcIAAODRxAq/2RBhC +AM9wgADowAHZJKglqM9xgADIMwCRhiAYAKi4ALHa2AOpz3AAAFDDAaHPcAEAoIYpAKAAAqHxwOHF +z3WAAHA0Do2B4KHBPfSKIAoDCglv/snZL42E4YogCgNU9voIb/7N2Q+NgOAJ9IogCgPqCG/+0dk2 +D+//AdgPjQHgD3gPrSHw0ghv/trZANgNrQ6tOgggAA+tcg/P/wDYzgnv/4y4z3CtC766QMCLcATZ +fdo920IJIAYXu4ogCgOaCG/+8dnNAa/2ocDxwOHFiiAKA4YIb/6v2c9ygAA4NEQSgACB4EAiAwwT +9EokQHEA2aggAAPwI00Az3CAANQzNXgB4aCgL3kA2EQaAgCFAY/24HgA2s9xgABwNE+pAdgNqU6p +TKlQqVGpUqlTqVSpiiAKAyUAb/6H2eB48cDeCK/2AdrPcYAARB5jgXiLhOMa9ACBz3GAALAwxBAA +BiW4UiAAACGBwLgB2oDhz3GAAHjfJoHAeoDhzCAhgMwiIoCA8oXwUSAAgAfyz3CAAEDBAIiB4AP0 +mHID8EokAADPcKAALCBwgM92gAA4NEWGpoYCI4CAANrKIm8AAiNPgwDdyiVvENdwAEAAAMn3gOIH +8gIjgA9OAAEgBabXdwBAAADI94DlBvICI4APTgABIAamAYaA4Bbyz3eAAMgzAIbhhx9n8XDG9/Fz +yvcQc4b3CPAQc4T38XPE9wDYA/AB2AGmIIHEEQMGQStBAVEhAIDKJmEQBvIphoPhbyYLEM9xgACw +MCGBz3eAAHjf5oeA4QHZwHmA4AHYwHiGJ38ehufRI2KBANsC9AHbgOXMIiKAzCMigMwgIoDMISKA +zCYikAT0ANgG8EwkAID88wHY9QdP9vHAiiDQB8YOL/6KIUYA7grAAs9wgACQJASAUSCAgAQKgv0J +2Qi5z3CgALAfNKDRwOB+4HjxwOHFCHWKIMkDjg4v/oohxQWKIIkDgg4v/qlxz3GAALAwAYGmeAGh +ANnPcIAAWMEwoCWAmQdv9jGg4HjxwB4PT/ahwQh2iiCJB04OL/7Jcc9xgADkB4ogiQc+Di/+IIHP +dYAAsDABhc9xgABYwQV+EIGA4MGlBvQB2BChBYERoXYIL/2LcADBz3ABAGgzMHAL8s9wAQAkQhBx +B/LPcAEAhFgQcQT0Ngwv/AHYAN7PcIAAODTBoO4ML/kH2OYML/kI2CYIwALPcIAA6Fr+DoAHz3CA +AARb9g6AB89wgABEHgCAxBAABlEgQIEL8oogSgKmDS/+HHnCDyAAyXAE8JYNYAADhcEGb/ahwOB4 +8cBODm/2uHBmDe//KHCA4ADZyiBBACjyz3afALj/HYbPdYAAiAYApT2mHNkV8M9woADIOzaAVoCG +If8IhiL/CEV5VoCGIv8IRXnPcqAAqCBNguTiiveA4ev1Qg2v/6hwIIU9plUGT/Y4EAQAWBAFAAoh +wA/rcs9wAACZIT0Er/cv2+B48cDPcIAAEKkIgFEgwIEz9M9xgADIM0KBIYHPcIAAHDRAoM9wgAA4 +NCegiiDJA9oML/6KIcUPiiDJBM4ML/6KIUYAz3GAAOQHIIGKIEYAJgtgAALargxgAALYiiDJA6oM +L/6KIcYA6gxgBgLYYgzP+Afwz3CAALAwigxgAAOA0cDgfuB48cA+DU/2CHUodoogSQd2DC/+iiEG +B4PlHfTPcIAAuBMBkM9ygADoByCCPOAZYQGCZOE4YBB2D/cKIcAP63KKII0BiiPGB0okAABpA6/3 +CiUAAYogWQUuDC/+iiFGCM9wgABYwc93oAAsIEAXEBBaDmAAp6BuCAAIz3CAAKQcJIAggQIML/6K +IEkHz3WgAKwvPIXyCy/+iiBJB4ogSQfmCy/+yXHWCq/7AdgCDq//yXAB2E4LoAAKcRyF+bgI9BiF +iLgYpUoPb/ag2Ajwz3GAABw2AIGCuAChiiBJB6YLL/6KIccAZgjP/54MQADQh5IKr/sB2HIOAACK +IEkHhgsv/oohRwZWC6AJMtjPcACCAQAcpfYN7/gCJgAUANjiCqAAyXGKIBkFXgsv/oohhwp1BE/2 +4HjxwOHFz3GAAEDBABGEAEwkAIClwQ72AxGFAEwlQIAK8gohwA/rcoogDQFVAq/38dtMJICAJfQD +iYDgI/QA2ACpiiDJCAoLL/742YogCQYCCy/++dnPcYAA5AcggfnYB91aCWAAqXLmCmAAqXDPcIAA +sDBuCa//o6BiCY//cvDPcYAA6MAEiYHgDPQFiYHgCvTPcAAA//8yDe//ANmA4GLyz3GAAEQeAIHE +EAAGUSBAgQXyA4EYiITgGPSKIMkIkgov/oohhASKIMkEhgov/oohxATPcYAA5AcggYogxATeCGAA +AtoC2Dzw6g1AAIwgEIVwAAUAz3CAALAwAICB4Ab0hgrP+IDgLvIA2c9woAAsILCAz3ABAGgzQMAB +2EHAQsBDwUTBBtkIcgDbmHO4cwAlhx8AAAB9zgkv/NhziiCJBA4KL/6KIQQKz3GAAOQHIIGKIAQK +ZghgAAHaAdjuCUAAJQNv9qXA4HjgfuB48cCiCk/2z3egACwg0IfPcIAAODQIgKXBAiYCEM9wgABA +wc9zgAB432WDI4AFK34AN3IB2UCIwiFOAIHiAN0F8gOIgeAZ9M9wgACwMKOgiiDJA5IJL/7O2Yog +SQSGCS/+z9nPcYAA5Acggc/Y4g8gAADaANhT8M9ygABEHgCCxBAABlEgQIFN8oHhS/QDghiIg+BH +9M9wgACwMAGAgOBB9M9wgABQHACQgeAB2MB4DLjXcAAAABA18oogyQMmCS/+1dnwh89wAQAkQkDA +AdhBwELFEdhDwADYjLhEwKlwDNkB2qlzmHW4dQAnhx8AAAB9pggv/Nh1z3CAADg0yKCKIEkG4ggv +/tjZz3GAAOQHIIHY2D4PIAAI2gjYxghAAO0Bb/alwPHA4cUA2Zu5z3CgANAbMaCKIEoBqggv/ooh +CA3PcIAAkCQEgFEggICKIEoBDPSKIUgOjggP/s9wgACwMH4IYAADgFLweggv/oohiA/uDA//iiBK +AWoIL/6KIYkAz3WAAEQeTYU+lVMiAAAeCWAEAduKIEoBSggv/oohSQMAhcQQAAZRIECBDfIDhRiI +hOAJ8s9wgABYwQeAUSDAgAbyiiBKAYohSQXH8YogSgESCC/+iiHJBoogyQQGCC/+iiFJB89xgADk +ByCBiiBJB14OIAAC2uoPIAAC2IogSgHiD+/9iiGJBxEBT/bxwJYIT/bPcqAALCAwgs9wgACkHASA +z3aAADg0AICghgIhQwPXcwAAoA8A38v3z3OAAHjfpYPVuEEtgxBifbFwhPcBhoDgDfRjhoHj4aYN +9IogCgKCD+/9iiEKCT/wvg/v+AfYO/DPdYAA6MAAhYDgGfIFhYDgF/IwggJ513EAAFDDAdjCIA4A +gOAp8i4Oj/8EheWl46aguASl8g+v+ADYHfCA4wXyBoYCeYDh1/ZTIIDBBKYT9IogyQQeD+/9iiFL +As9xgADkByCBiiBLAnYNIAAC2v4OIAAC2CUAT/bgePHAug8v9oog/w+hwSINIABAwIHgPPTPcIAA +RB4AgMQQAAZRIECBEfLPcIAAUBwAkM91gADkB4HgAdjAeAy413AAAAAQFPKKIEkErg7v/YohRQfP +cYAA5AcggYogRQcGDSAAANqODiAAANhS8IogiQWGDu/9iiFFCCCFiiBFCOYMIAAF2m4OIAAF2ELw +z3WAAMQzAIWB4ADeCfSKIMoKWg7v/YohRQrApTLwz3HA3wEAz3CgAKwvPKDPcACA//+yCO//AdmA +4CTytg4gBotwCiUAkB7yiiDJAx4O7/2KIcYAiiAJBRIO7/2KIcYBz3GAAOQHIIGKIMYBagwgAAPa +9g0gAAPYqXByCe//AMEZBy/2ocDgePHAuHDPcIAA5AcAEAQAz3GAAPQvQCyAABR4FSBAAQBhiuAK +9AohwA/rcoogzQDlBG/3oNuqDQAA0cDgfuB+4HjxwOHFz3CAAEQeA4AYiITgDfQKIcAP63KKIE0B +iiOEDUokAACtBG/3uHP+CEAACHXPcAAAv9/mD6//ANmB4AX0jCUQlRz3iiAKC1oN7/2KIQUBlgvv ++wHYiiBJBEYN7/2KIUUCz3GAAOQHIIGKIEUCngsgAADaKg0gAADYXQYP9uB+4HjxwOIND/aaCcAH +iiBKARIN7/2KIYcNz3WAAOgXAIWC4M92oACsLxbyGIb6uAryGoZSIAAAUSAAgATyHIb8uAryiiBK +AdoM7/2KIQgAKgxP/xyGUSAAgB3yz3CAAOhaAIBCIACAyiBiAIDgE/TPcoAAyDMJgoTgTffPcYAA +RB4ggcQRAQZRIUCBA/IB4AmiPIaODO/9iiAJC6oPD/d6DU/9geAM8gCFguAI8s9wgADkBwCAg+Cs +C8H/lQUP9vHAJg0P9s9wgACwMACAgeAU8s91gADkByCFgOHMIeKBzCEiggjyiiDRAADeogogAMly +wKXODo/7WQUP9gokAIDxwAzyCiHAD+tyiiBNAoojjg1BA2/3uHOaCk//Jg7v/wLYz3ABACRCkgvv ++wHZ0cDgfuB48cCyDC/2BtjyCs/4z3CAANwUSiQAAAAYAAHPcIAARB4DgBiIhOAL9AohwA/rcoog +zA3q2+kCb/e4c89wgACEV+IMQAfPcKAALCDQgM91gAA4NCCFAiZAENdwAAAgTgb20gvv+AfYwKXP +cIAAeN8GgFEgAIC8C+L4yiAiAroLIAYA2J0ED/bgePHAJgwv9oogyQNeC+/9iiHEA2IK7/gI2M92 +gADkBwCGh+DMICKCVfLPdYAAODQhhYDhB/LPcaAALCAwgSClz3GAAHjfJoFRIQCAQ/KE4MwgYoEl +9M9xgACwMAKBgOAI9ACBgeA18gOFgOAz8oogSgL2Cu/9iiHECYogygHqCu/9iiEECgDZz3CAAOjA +KaAqoADY6gtv/4y4G/CA4MwgooEX9AOFgOAA3wzyz3CgACwgEIACpYogyQOuCu/9iiHEDIogyQOi +Cu/9iiGEDeOlIIaH4cwhIoJi8s91gAA4NAGFgOAF9AOFgOAp8s9wgABQHACQgeAB2MB4DLjXcAAA +ABAd9IogSgJiCu/9iiGFAHoM7/8B2M9wgACwMACAgeA+9AOFgeD0CqH4yiBhAAOFgODoCqH4yiCh +ADDwgOEN9M9xgADowAqBCaEA2Aqhz3CgACwgEIAGoc9wgABQHACQgeAB2MB4DLjXcAAAABAW9M9w +gACwMAGAgOAQ9IogyQTqCe/9iiGFBiCGiiCFBkYIIAAC2tIJIAAC2PUCD/bPcoAAODQBgoDgANkE +9AOCgOAD8gHZUyCAwQSiAdrCIoEAANiA4cwiIYAD8gHY4H8PeOB44cXhxs91gADAMMAVAxa/40f3 +0mvUfr5mAKYhpkKmAWvFuMAdGBDBxuB/wcXxwOHFiiAKA2IJ7/2N2c91gABwNA2NgeAo9IogCgNO +Ce/9kNnPcIAAyDMAkOm40SCigg70iiAKAzIJ7/2V2QDYDq0NrZoIr/8PrRDwiiAKAxoJ7/2d2QHY +Dq0PjUIgAIBeD2//yiBiADkCD/bxwL4JD/ZmDU//z3OAAMgzAJPPcoAAQMFBKIEAwLkhqs9xgABQ +HCCRgeEB2cB5DLnXcQAAABAN9KKDz3GAABw0oKGhg89xgAA4NKehNvDPcYAAsDCggYHlEvTPdoAA +6MAkjoHhBfQljoHhAdkC8gDZgOHKIYIPAAAQJwP0IoOB5c92gAAcNCCmEvTPdYAA6MAkjYHhBfQl +jYHhAdkC8gDZgOHKIYIPAAAQJwP0IYPPdYAAODQnpalxz3WgACwg0IXlgQImzRP/vQL0xaHmgQIm +zRP/vQL0xqEog4DhBfTPcYAAeN8okSOiJbjAuPYNr/gD2TUBD/bgePHA4cXPcYAA5AcAEQQAuHDP +coAAiDRALIAAFngVIEABAGKF4An0CiHAD+tyiiCNAAUHL/d224LgABlAAWTyhOAj9M91gADowCCF +gOFc8roPr/2KIEoMAIWA4Ajyz3GAABTBAKEIhQihANgApQSlpg6v+AnYng6v+APYz3CAACBbughA +B0DwgeAQ9N4NoAUA2AvIBCCAD/7//wMLGhgwC8iHuAsaGDAw8M9wgACQJASAUSCAgA/yz3CAAGQ4 +AICA4An0/gpv/ZDYgeAF9G4NwAMN8ADanroA2c9woAD8REGg4HghoIINoAUocM9wgABEHgOAGIiE +4Ab0egvP/IDgBPSWCkACOQAP9vHAvg/P9c92oADALzqGz3KAABw2AILguEz0gLgAos9wgABYwQeA +Ad3AuIHgwH38uQXyEIZRIACAA/QA3wLwAd+A5e9/MPKKIIkKtg6v/YohxQUwhqoOr/2KIIkKEIZR +IICCD/RAFgQQTBYFEAohwA/rcoogTAm5BS/3iiOFBoHnDPSKIBABEaZODiAJCtgwhm4Or/2KIIkK +iiAQABKmOg4gCQXYz3CAAPwpIIBgealwdQfP9fHAiiDJA0YOr/2KIQYFz3GAALAwQIGB4hL0z3OA +AOjABIuB4AX0BYuB4AHYAvIA2IDgyiCCDwAAECcG9M9wgADIMwKAgeLPc4AAHDQAoxP0z3KAAOjA +BIqB4Ab0BYqB4AHYA/IA2IDgyiCCDwAAECcF9M9wgADIMwGAz3KAADg0B6LGDe//A4HRwOB+8cDP +cAAACBwSD+/9ocH/uA3yz3CgACwgEIAE2XzaPdtAwItwNg5gBRe7ocDRwOB+4H7geOB/AdjgfuB4 +8cDhxc9xAwBADc9woACoIC2gz3GgAMAvFIHwuBSBDPIEIIAPCAAAANdwCAAAAAHYwHgH8IYgfw+C +4AHYwHiA4F/0FREAhqC4FRkYgBHwz3CgAKggDYDk4M91oACsL4/3HIX5uEf0DHSEJMKfQ/QmDS// +WtiA4O3zQ/CKIIkDBg2v/YohyQnPcaAA1As7gfYMr/2KIIkDLHHqDK/9iiCJAzmF4gyv/YogiQM2 +Du/9JNgIcdIMr/2KIIkDJg7v/YogCQMIcb4Mr/2KIIkD63USDu/9JNi4cM9woADUC2wQBACKII0K +CiHAD6lyyQMv94ojiQvPcaAAzCsSgYC4EqG9Bc/14HjxwFoIIADhxR4IIAAIdeYIIAAIc3B1yiNF +AxBzmQXv9cogxQDxwOHFocEA3UDFxg5v/ItwguCKIP8PDPLPcIAADF0DgCCAAMAieIDgyiBMA2UF +7/WhwOB48cChwQDYQMDPcIAAQMEhiIHhi3AR9M9xoAAsIDCBz3KAADg0SIJCeddxTgAAIMX3qg5P +/APwhg5P/ILgBvSKIP8PocDRwOB+z3CAACxdA4AggADAIniA4MogLADz8eB44cXPcYAApBwkgSCB +z3OAACxdQ4PVuaCCRoOKIP8PgOIF8gKConhIIAAACSBAAGq4SCAAAOB/wcXPcYAALF0LgUCADoGA +4MoggQ//////CvICgEJ4SCAAAJkgBgBIIAAA4H7gePHABgzP9aHBGnDPcKAALCBAEBQAz3eAAFTD +P4cA3kQgFSPPdYAAODRBKYAB2nGGJv4vTCUAokojQCDCI8IkUyARAEEoQSPAuRYlUhQEGkAgiiDZ +BQ4Lr/2KIcoCTCUAoswhIaAJ9AGFgOAF8j4Nz/sD8KoMz/vPcIAARB4DgBiIgeAG9M9xgAAQ1xbw +mg8P/YDgPfLPcIAAjCEIiIfgN/SYF4AQz3GAABDXArgWeABh7bgt8pgXgBBRIACjQCHVAwK4Fng4 +YB3yIICIuSCglgqv/YogiQOYF4EQAdoSaRZ4onBAqM9wgABEHgGAwBAABhEgQIDMIaKDvA8CCQfw +gghgCc+ogOAICEIJz3eAAOQHAIeH4F/yBBIAIIHgyiCBDwAAXAY8CqH9yiFBBEwjAKBR8kwmAKBH +8gCHgOAgHQAVDvSKIMkDHgqv/YohCwPPcYAA6MAKgQHgCqEh8EYVgBCB4Bv0z3Dt/r66QMCLcATZ +fdo924oKYAUXu4ogCgPmCa/9iiELCEYdghNFHYITSglv/0cdghNSCE/4B4UmhYJwAiBCAP+6A/QG +pUwVgBCB4BH0TB2CE4ogigSqCa/9ANkJ8IogGQaeCa/9iiELDwAdABWBAu/1ocDxwEoKz/UIdc9w +oAAsIPCAh+UA3oz2CiHAD+tyiiANAoojCQOYdpUAL/e4c4bhIvL6DI//z3CAADg06KDPcIAA5AcA +gIDgzCDigRDyz3CAALAwAYCA4Ar0iiAKCy4Jr/2KIYkFYg8P+M9wgADIM8mgz3GAAFAciiBZBxIJ +r/0gkc9xgACwMM9wgAAcNCCB8CBAA4Hh+GAG9M9xgADIM8mhz3OAADg0JYMCIEIA/7oD9AWjAQLP +9eB48cDhxQh1BNnPcKAAyBwooE4M7/UW2M9xoADALxOBgOXPIOIC0CDhAhOhgOU82gb0z3CAALgT +QJDPcIAAuBMBkBC4RXjAGQAAwQHP9c9yoAAsIFCCInrPcYAA6AcVeQCBEHLM989wgABEHgCAxBAA +BlEgQIEC8kCh4H7gePHAGgnP9QDez3CgALQPvICmDmAFyXDPcoAA3JcEks9xoADsJxC4hSCEAAah +BZIQuIUgjQAGoQeCz3OnABRIB6MIghCjA4LPc6QAuD2bGxgABIKmGxgABYKSGxgABoKjGxgAz3Ck +AOz/xqCKIIoABqFGDmAFr3jPcIAAkCQEgFEggIBYD2IHyiBiAP0Az/XgeOB+4HgA2M9xgADAJAOp +z3CAAOAGR4ACgEKpHOBWeESISakFiOB/CqnxwGIMD/2A4DPyz3CAAIwhLJDPcIAARB4ekBBxKfLP +cIAAICtoiEqIRCs+CwAhgH+AALAqVXgGiM9xgAAkKoHgF/QAgYq47gwv/QChgOA8COIGyiAiAM9y +gABwXAaCA4AggMdxAAAAKN4IIAdIcNHA4H7gePHA6g+P9c9xpwAUSADdqKEHgc92gADclwemEIHP +cqcANEQIpqehz3DzD//8EKGg2Lahmrj1GhgAz3GkALg9mxEABs93gACUHAOmphEABgSmkhEABgWm +oxEABgam/9ibGVgDphkYAJIZGACjGRgAz3GkAOz/z3AAAP//p6EGoQCHAeCB4ACnCvQB2c9woADI +HDGgcg7gCChwBNiODq/2QCYBEg3Ygg6v9kAmgRLPcCgAAgHPcaAA7CcGoYogjQAGoQCHQiBAgACn +BfTPcKAAyByxoIEHj/XgePHAEg+P9VEgwIENEg82z3OAAATCAxINNs9xgAAUw/R7EYsQE4QAEvIB +4AhyMhWFEGeRAhkCAc92QQCDAGaxz3OAANQ9A6kR8EAkQgAxFYUQQqnAEwMBA6nPdiEAggBmsc9z +gADYPbByx/fEoQCDAeAAowSBVPDPc4AAJMLrYwHjwYVkqVEmAJEA2nCNOvIvJQgA739JJ8QQ8mvP +cIAAENf2f+Bg9rjSjQfyz3CAAFDZdngBiALwSHAAJI8PgABQ2XZ/5I8IJs4TCCYAEKBwSSDOAxZr +1XjPdoAA0NoAZs92gABQ2nZ+YYbPdoAARB7EhtiGxXsEI4MPAAAACGZ4A/ADhQKhmBWAEGiJEHMF +8kSpYNgYuAPwANiduAShXQaP9fHA4cUDyKQQAABRIACAz3CAAEQeBIAE8huQA/AakHYPQAeA4Dr0 +z3CgABQEA9kjoCDYDBocMM9xgABcPBaBAeAWoQPIANqYEAEApBADAJQYQACeEAEBrLuSGEQAvhAB +Aa27gBANAaQYwACQGEQAfhABAYAYhAA9ZbAQAQGieTB5sBhEAIIQAQF+GIQAhiPlj7IYRACIC8L8 +0QWP9fHAVg2v9QhzEIkzEY0AAdpAqw0SDzbPdoAALMLuZs9ygABcwkjcwasNEg82AiIOA/QmzhPB +sw0SDjbwIoIDQaNBgVEiAIEQ8tKJz3KAAFDZFnrcq0CKhiJ/DFx6BLpFftyrBPCA2lyrBLgFfb2r +HJHPcoAApMIPsw3I8CIAAASzB8gFo1QRAAEMswCRDbOgEYIASKMGyAQggA8CAEEA13ACAAAAA/SI +ukijBsiGIL6PA/KJukijnBEAAc9zgAAIXia4wLhAKAIDD4HAuA24RXjtBK/1AKPgeOHFz3AAANAu +z3OAACwHAaPPcIAAEKkAo89xgAAI4M9ygADYXQCCoIGgoACCHN2gqARpAaJVIUAEA6IY2AKiVSHA +BQWiAYEEomhwA6ECgY24AqHgf8HF4HjxwB4Mr/Uc2hpwz3CAAPoHAIjPdoAA8F0KIYAvgABMyIQo +HwAghgAhRC7PdYAAUMVAoQAlQR4AJUIeKIFAIgMHACVAHk8hTwPoogKIUSBAgGGmBfKDuY25KKLP +cIAAmAgCoxjYAqbPcIAAGAgAgAweABHPcYAAAAh+Cq/5IIEA2c9yoAAsIFCCgOBhhkqjxPZYYAqj +z3CAAPoHABCHAIQvHwAndUKNUSJAgC9wWPRMIACgC/TPcYAAiMgbYc9wgAAMCGCgSvDPcoAADAhA +gkGKRCi+KMdwgABsxRfgQCKEADIgQg4vJAcBz3CAABAIAuJPeoDiABCFAEAALAACJYMAhC8fAC9w +ACFPDgAnhh+AAGzFRCi+KEAmjwUyJ08eO2PHc4AARMgI4xtjAeEveVBx4KsCJYMApvaELx8AACFA +Lhtjz3CAAAwIYKAOlQIgAAEOtQ6VWGAOtWWmB/DPcYAAZMg4YAWmDpUVA6/1BKbgePHAogqP9Qh1 +AIiM4M92gAAgLGgWgZDI9IDhB/IDjWkWgpAQcsfygOFgDQL5AdhoHgKQIY2C4cogIQDMIeKDe/Rr +HgKQI42A4GkeQpAkjWoeQpDN9gVtyXGCIUIDFg+gBQ3acxaAkGweApBrFoCQguAN9EAlgBTJcYIh +QQ/2DqAFDdqDFoCQbR4CkGsWgJCA4CIBLgBKJAAgz3CAAOBcBoADgEAsECGggAAgki+AAJAriiBV +DEIJb/0DEoEgiiBVDAAgjy+AACQqLglv/VwXARaKIFUMIglv/V0XARaKIFUMFglv/V4XARaKIJUM +Cglv/alxXhcTFnJ1VAAOAAIl0BRdFxEWCnBOC6/1KnEFKT4gXBcCFgIgQS5QccAgZgADEoEgjCHD +jxH0BSk+IAAhz3QI8JzhAtiG8wDYaB4CkDvwon8A2BjwjCDDj8T3anf68TBwUPcFKT4gACHPdKJ/ +AnkveQAkgC+AAIwrIKgA2ATwAdgA34DgEPSKINUMeghv/elxcNwCJgATRCw+JydwEgrgBrlnaxaA +kEAkVCCScPwGzf8J8IDhB/IA2OILL/loHgKQRQGP9eB48cASCCAAAtgCCgAA0cDgfvHA6giP9c93 +gABEHhUnEBAAEA4gCHUUloXghfaI4ALYwvYA2BqmSiQAcgDZqCBADc9wgADQafQgQgDPcIAA/Kk0 +eECwz3CAAOBr9CBCAM9wgAAsqjR4QLDPcIAA4Gn0IEIAz3CAAAyqNHhAsM9wgADwa/QgQgDPcIAA +VKo0eECwz3CAAMhr9CBCAM9wgAAcqjR4AeFAsAiG5bgE2cohIQDkuDSmBvIJ2UYeRBAu2gbwFNlG +HkQQMtpbtlmOUSAAgFlhMHlGHkQQGuE6tgnyCthUHgQQBthWHgQQB9gI8BDYVB4EEADYVh4EEAXY +D6bOCKADqXA8jihwRB5CEIYgAwDmuVgeAhDKIkEADPJQIcMBb3pEHsIQUCDDAW94WB7CEOW5CPJI +c4YjAwBvekQewhDkuQXypbhYHgIQUSHAgAXypLpEHoIQguUV8o4Ir/ipcAAQACC5EAAGUSBAgPHY +wCgiAcoggQ8AAJMAwCghAYQeABAY2I24E6YIhlEgwIAG8rYXgBCJuATwnReAEBKmz3CgAKwvGYDP +cYAAkCQwuMC4yg9gCAWhCIYEIL6PAAYAAADfC/I2uMC4G3gB4FoeBBAC2BqmA/BaHsQTANgXphim +Pg/v/KlwKIYB2khzQSkABTW5UiAAAFIhAQDAuMC5+gyv/ZhyWQdP9fHA9g5v9QfYz3WgAMgfSB0Y +kM9wgABEHiOAz3asANQBGoFMHRiQguAC2MogIgDQHgCQiiAEAA+lRhEAAc93oACkMLAdABBGEQAB +tB0AEB/YCLgOpQiBUSAAgADYi7gI8hClrg4P+AGHhLgH8BGl9g4P+AGHpLgBp89wgABAXgCA4LgK +8oYg/w4iuBS4z3GAAAAGC6HGCC/4Ad/KCgABEgiAA5YIgAPPcAAAVVVaHRiQz3CmACgAWR3Yk++g +z3CAAEQeA4BaEAEBz3CmAOgHJqC+CI/8z3CAAEQeA4BWCWAFDZAA2IweGJAH2I0eGJAA2IseGJDP +cIAABCoggGB5BNiA4BPyz3GAAOgVGoE7gSR48bgL8oog2AkeDS/96XFKC6AAAtgE8JYMIAcB2M9y +oADEJw8SAIZEIAMCz3CAAEQeI4AbgQ8aGIAPEgCGo7gPGhiADxIAhgV7DxrYgHyBz3CgADAQZKDP +cIAAVMMQeI8aGIDPcIAApJ7Pc4AApK4QeBC7ZXiQGhiAiiAEAJIaGIAdgUAaAIDPcIAAhB1TGhiA +DxIAhp+4DxoYgADYEBoAgB6BHBoYgKkFT/XgeOB+4HjxwM9wgADAlxgQBAAKIcAP63LPcAAA5Q7e +240Dr/ZKJQAA4HjxwOHFz3WAAMCXathGDC/9JoUlhSalPgwv/WvYbQVP9YDg8cA02Af0hg1P/VAg +QQQF8H4NT/1PIEEEug1v/TTY0cDgfoDg8cD02Aj0Yg1P/VAgAQD02AfwVg1P/Qhx9NiAuZINT/3R +wOB+4HjxwKYMT/XPcoAAnDliks91gAAEZECFpMFAwkKV2BEEAM91gABAZQQchDBAhULCQpUMHIQw +tIBcgbFy2HKD9wIiRgNTgLeBUHXCJYYQz3KAAFQ6BhIFAcgRDgD/2gi6RH4ovgAchDPMEQ4ARH4o +vgIchDPQEQ4ASiTAcMR6KLoEHIQw7BECAAgchDDwEQIA9BEBAAochDAMHEQwANpIdqggAAQD2REh +gIMJ8hQkgTPgkQgiwgMkkQkjQwAB5gAlgREFKYEPAwAAIC9xBS0+ATdxRfeMEAEAAeEC8ADZsICM +GEAAVSDOBVMlwRAUJkEQQLFcEAIBSiQAdADfqCBAAvQmwRMwcsoiSwAB51UgwQeQGIQAwr0UIU0D +YLV8EAMBSiQAcgDaqCDAAfQhjQAII0MDAeIG43B7khjEANUDb/WkwPHAZgtv9Zhwb38Dv6Rvz3CA +AJw5tmCib7VgieMG5/BgBvTqkYwnApjKIGsAgeIK9HR5QZEdZbFyj/YCekGxCvCC4gv0dHlBkVhg +EHaF9gGxAdmYHEIAeQNP9eB48cAKC0/1dIBcgdgRDQBwcsIixgD3gTOAMHfCJ0YQAtvPcYAAVDr0 +IcQABhEFAQDZLqD6YgUqgg8DAAAgL3EFLH4DN3GMEA4AwvduoAUtfgM3cU33kBABAZQQAgEC4VBx +g/bk5sP3AdkuoAkDT/XgeOHF4cZ0gFyB2BEOAAIixABTgDeBPBAHAIwQCAACIYUAz3GAAFQ6Atr0 +IYoABhEJAc91gACcOUKVYZUKEQYBkhABAaOVCCNDAAAlAQEFKYEPAwAAIAokQA4FKr4TDCRAjtb3 +KpCMIQKI0vYC2S+gkBABAX5llBhEACGQMHZsAAoAonkhsAHZmBhCADDwBSm+EwwkQI5W90wngIAU +8pAQAQGUEA4BAuEwdgT2jCABmcr3wZAB2d1lsXIvoJj2obDl8UwngIAM9KGQACbBADB1yPYCJY0R +obAB2ZgYQgCQEAEBlBhEAADZL6AJIsIAIZAwcoX2QbAB2ZgYQgDBxuB/wcUiaADaQLBKJMB1z3CA +AJw5qCCAAhYggwBgkxQhjAAB4k96YLTgfuB48cByCU/1coDIgdgRAgBwdsImxhBxgCOBcHHCIcYA +AN/Pc4AAVDr0I8QDAd3ZYQUpgQ8DAAAgL3EFLL4AN3H0I0MD7aDE9wLZLaAH8AUrvgA3cUP3raCF +AU/14HhIgVKgQ4FRoFyBVKA3geB/M6DgePHABglv9QLbCHUodgHYALGpcI4N7/9NhU2FqXDJcYIN +7/8D202FqXDJcXYN7/8F202FqXDJcWoN7/8G206FqXDJcV4N7/8J206FqXDJcVIN7/8E2x0BT/Xx +wOHFiiAKC+IP7/xz2c91gADowIogCgvSD+/8IIXPcaAALCAwgSWlz3GAABCpKIFRIcCBANgL8iSN +geEE9CWNgeED8gHYgOAK8gCFgeDMICKAJPKKIMoMfNkc8Iogyg2KD+/8gtkghYDhGPIEjYHgBfQF +jYHgAdgC8gDYgOAF8ooOj/cK8IHhCPKKIMoMjdlaD8/8AtgApYkAT/XxwBIIT/XPdoAAlBwAhgHg +geAApgDdCvQB2c9woADIHDGgBg9gCChwz3CAAIAHIJCGuRC5BSGCDwAAwhLPcaAA7CdGoQGQELgF +IIAPAAACEwahAIZCIECAAKYG9M9woADIHLGgGQBP9fHAqg8P9c9wgACMLRmAAN2B4Mohwg/KIsIH +yiCCDwAAqBPKI4IPAACQAcokQgPoBWL2yiVCA892gACUHACGAeCB4ACmCfQB2c9woADIHDGgbg5g +CChwz3CAAIAHI5AEkMK5wrgDuCV4ELiFII0Az3GgAOwnBqEAhkIgQIAApgb0z3CgAMgcsaCNBw/1 +8cAeDw/1z3aAAJQcAIYB4IHgAKYA3Qr0AdnPcKAAyBwxoBIOYAgocM9ygADMLgCKz3GgAOwnELgF +IIAPAADCaQahAYoQuAUggA8AAAJqBqEAhkIgQIAApgX0z3CgAMgcsaApBw/14HjxwK4OD/UKIACg +z3WAAPBfABUEECvyTCQAgM9wpAC4PQDaGvSbEAMGz3GAAPRfYKGmEAMGz3GAAPhfYKGSEAMGz3GA +AOhfYKGjEAMGz3GAAOxfYKGbGJgA/9mmGFgAkhhYAKMYWAAB2DTwTCQAgMohwQ/KIsEHyiCBDwAA +fhnKI4EPAAD8ApwEYfbKJQEEz3CAAPRfIIDPcKQAuD2bGFgAz3GAAPhfIIGmGFgAz3GAAOhfIIGS +GFgAz3GAAOxfIIGjGFgAz3CAAJAkBIAiuMC4ggvABD0GL/UAHQAU8cDODS/1ANjPdYAABCoghUB5 +jOAU9M92gAAMKiCGYHkC2IDgDPQghmB5A9iA4Aj0Qg4v/VDYUSCAgQTyANgD8AHYLyEHIM9wgAD8 +Ns93gAAcKlYN7/gAp89xgADQPRSBAeAUoc9xgACUHACBAeCB4AChCfQB2M9xoADIHBGhcgxACM9x +gAAILgSBgeAV9CaBz3agAOwnYHkA2M9wgADMsxiIgOAX9M9wAQAGAQamz3ASAAYEFvAKIcAP63LP +cAAAhxmKI8UJSiQAAH0Db/YKJQABz3ABAAcBBqbPcBIABwQGps9wgADMsyCAgOEDgCzy4IdEKL4D +xtiSuAamIIUnd2B5ANiM4DjyIIVgeQDYkOAy8iCFYHkA2JHgLvIghWB5ANiS4Cjyz3A5AAIzBqbP +cDkAgkwGps9wOQACZgamx9iVuBnwRCi+AwAhj3+AAGxsx9iSuAamz3AAAAIzBqbPcAAAgkwGps9w +AAACZgamxtiVuAamkg4P/s9wgADMsxiIz3GAAMyzjgvgBCCBTCEAoBXyz3AAAAJuBqbPcMEAQm4G +ps9wAwDCbgamz3A2AEKXBqbPcAIAQmsGps9wEACHcgamBY8QuAUggA8AAEJwBqYEjxC4BSCADwAA +gnAGpgOPELgFIIAPAADCcAamAo8QuAUggA8AAAJxBqYJjxC4BSCADwAAQnEGpgiPELgFIIAPAACC +cQamB48QuAUggA8AAMJxBqYGjxC4BSCADwAAAnIGpgGPELgFIIAPAABCcgamC48QuAUggA8AAIJz +BqYKjxC4BSCADwAAwnMGpiCFYHkA2IzgEPIghWB5ANiQ4AzyIIVgeQDYkeAG8iCFYHkA2JLgCfQM +jxC4BSCADwAAwn8Gps9wAQBGagamz3egAMgfpBcQEEwhAKAJ8s9wUADGcwamz3AgAMdzHPAghWB5 +ANiM4BnyIIVgeQDYkOAT8iCFYHkA2JHgD/IghWB5ANiS4Anyz3CAAAZ0BqbPcIAAB3QGps9wgADG +cwamz3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqbPcIAAzLNYiM9xgADMswCIJImA4gHa +wHrPc4AAzLO2COAHeYsk2BjZzglgCDPageAW8s9wgADQPVAQBADPcIAAzLMMEAUACiHAD+tyz3AA +AIoZ2QBv9oojBwdMIQCgBfLPcAYAQmsGps9wEADHagamz3AQAIZyBqZMIQCgBvLPcAIARmoGpsYO +wAfKDcAHJNgB2WIJYAgz2oHgFfLPcIAA0D1QEAQAz3CAAMyzDBAFAAohwA/rcs9wAACqKHEAb/aK +I8cMpBcAEM9xgADQPQIgAAQToc9wAgBHagamIIVgeQDYjOAV8iCFYHkA2JDgD/IghWB5ANiR4Avy +IIVgeQDYkuAF8s9wZQDCbgamz3CAAJQcAIDPcYAAlBxCIECAAKEF9ADYUR8YkO0BD/XgePHAfgkP +9c9wgACMLRSAgOCL8vILL/4H2Hpwz3CAAKw6DIiGIP8BQ7hhuIbg9AANAM92gADMsySGz3KAAPyx +MyYAcIAAUGJAIhELBLk0eUAiEApAIhIGQCIPCEAiDQQ6YkAnAXIUeQB5z3GAADQvSHBV8M9xgABU +LwRqUfDPcYAAdC9AIgACS/BAIgADz3GAADQvgggv/gDaBIbPcYAAVC8EuBR4uGA78EAiAAfPcYAA +NC9iCC/+ANoEhs9xgAB0LwS4FHj4YCvwQCIABc9xgABUL0IIL/4A2gSGz3GAAHQvBLgUeEJwG/BA +IgAJz3GAADQvIggv/gDaBIbPcYAAVC8EuBR4AnAOCC/+ANoEhs9xgAB0LwS4FHgicPoP7/0B2uIP +7/1qcLEAD/XgePHAz3CAAIwtD4CA4BDyz3CAAMyzBIDPcYAATLMCuBR4OGDPcYAAlC9KDA/+0cDg +fvHANggv9UTaz3CAAChsz3GAALDB2gwgBQDeAt0WCCAAyXBhvYDlAeY693kAD/XgePHA/g/v9ADa +z3GAAEQeFXlggQS4ACCQD4AAsGi5G5gAAIEEEA8gz3aAAChsvhjYA6CBQoaKIAcPYYYdZfAdgBDs +HcAQIIFGhs91gACwwWWGOGD4GIAAFibBE/QYwAAWJcATBOAE4WIIL/UI2gwQACAWfhZ9BG0kbk4I +L/UI2uUHz/TgePHAeg/v9BLZqcEIdooLoAeLcEokAHEA2qgggAIWJIAwKIiB4cP2YbkoqAHiAsIB +w891gABEHtV9AIWKIQcP9G7Hd4AAsGg4YOwYwADwGIAAAIUGwgXDOGD4GIAAg8H0GMAABBcQEM9w +gACwwRYgAAQE4NIP7/QI2uOHz3CAALDBh8H2eATgvg/v9AjaAMAghbkZGAAghbkRAAZRIACACfK+ +GdgDIIW/EQAGgLgH8L4ZGAQghb8RAAaguG4Lb/y/GRgAgOAF9N4KT/yA4APyANgC8AHYEHZoCiEI +yiCBAwCFuRABBlEhQIDx2cApIgHKIYEPAACTAMApIQEiDC/6hBhAAN0G7/SpwPHAeg7P9M92gADc +X4Dhz3WAADgIEvIghoDhDfQApd4Nr/cO2DoPb/6KIBAAAdgApg7wIIUleAvwigyv9w7Y5g5v/oog +EAAA2ACmAKWZBs/08cAaDs/0z3GAAOgpAIGguAChpg7v+gHYz3CAAMSoABAEAEwkwIDKIc0PyiLN +B8ogjQ8AAIEMyiONDwAA2gBYBC32yiXtAEwkAIDIAC4AAN0UbQAggQ+AAMSoB5HmkcSRELgFfwWR +Q5EQuAV+ApEQukV4GnAyCe/26XFacM9wgACscvAgQQNELT4XCiFALgAhgH+AAMBZIKDeC2/6CnAI +cQAhgC+AALRZZg4ABoogzA62DK/86dmKIAwIrgyv/EpxiiAMCKIMr/zJcdF3g/eA5hj0z3CAAKBy +8CBBA0QtPhcvdgAhgH+AAGhaIKCKC2/6SnAIcQAmgB+AAFxaEg4ABs9wgADEqACAAeUQdUQHxf9l +Bc/04H7geM9xgAA8LM9wgAAILuB/IqDgfuB48cD+DM/0AN7PdYAA9MHPcIAADCoggMClYHkB2IPg +yiHCD8oiwgfKIIIPAACYGcojgg8AAOsAyiRiADADIvbKJYIDAIWYuAClANjBrcKtjrgBpQKlz3aA +ABAqQIYG2GB6AdlAhgfYYHoB2QGN/QTv9ACt4HjgfuB44H7gePHAz3CAAKxdAICF4HwABQDPcKAA +rC8agFIgAABRIACANPTPcYAA3JcLgQHgC6HPcIAA+CkAgEB4rg4AAM9wgAD0KQCAQHh+D4AA8g+P +/coOz/sG8FINb/yKIIkMz3CgAHhFAIAEIIAPcAAAAEEoPoXy9c9wgABEHiOASIE0kVMiAAAGDOAC +AdtCCq/3EtjRwOB+4HjxwOHFtMGKIJgJIguv/FrZBfACDW/8iiCJDM91oAC0R3EVAJYEIIAPcAAA +AEEoPoXx9Yog/w9vHRiQax0YkG4LL/iLcL4LD/yA4A/ybxUElmsVBZYKIcAP63LPcAAAsRP5AS/2 +NNtSDs/3zgiABPUD7/S0wECIAdgAoWi6ArpVesdygACMLWOCY6FhgmGhYoJioWSCZKHgfwCi4Hjx +wE4Lz/TPd4AAsF0GhwOAz3WAANyXIIBJhQAigA8tAMDGAnmA4YIALAChwc92gACUHACGAeCB4ACm +CvQB2c9woADIHDGgIgogCChwi3E+Cu/1QtgAhkIgQIAApgb0ANnPcKAAyBwxoAAUBDEEJL6PAAAX +/8ohwg/KIsIHyiCCDwAAphPKIyIMNAEi9solIgAAhYK4Ig0gAAClJgggAAHYAIWiuAClKYXHcS0A +wMaKCyAG6XABA+/0ocDgePHAagrP9K/Bz3GAAERkAIFKJAAgTcAEic93gABEHm7AA4cIgFMgFwA3 +FIAwQMAuwEHANhSAMELAz3CAAOgVOoAbgCR4z3GgALRHRxEBhjG4gOHAuAb0iiCYDJUEIABM2YDg +hAQBAM9wgADclwAQBABRJECAyiHBD8oiwQfKIIEPAACqE8ojgQ8AAFoAdAAh9solAQXPdYAA2AaK +IBgHNgmv/CCVIJXPcIAA3JcisADZnrnPcKAAtEdTGFiA4HhTGBiF6gkP/891gACUHACFAeCB4ACl +CPTPcaAAyBwB2BGhyggACC3Az3agAOwnELgFIIAPAABCLQamQCSBPNII7/VC2M9wCACHEAamAIVC +IECAAKUH9M9woADIHEQYAAXPcIAAvKoWIMAFJIAAgAq5ybgEIYEPDwAA/AV5z3CnABRILaCWDY/9 +TCcAoEPACvKKIf8Pz3CgALRHbxhYgGsYWIAB2M9xoAC0R2AZGIADhzIggA8AANgCgOAB2MB4D7iQ +uJu4n7hfGRiAAIUB4IHgAKUI9M9xoADIHAHYEaEOCAAIQCSBPioI7/UR2ACFQiBAgAClB/TPcaAA +yBxEGQAFz3GAAGw4J4lKIQAggeEB2cIhQQCA4UTBegIlAAolQCQAwQHAInhHwAbw0glv/IogiQzP +cKAAtEdxEACGBCCAD3AAAABBKD6F8vXPcKcAFEhcGAAFTCEAoC8nRxQJ9M9wgABHBAamSiAAIAfw +SiCAIM9xgABGBCamiiBYCJoPb/wqcYogWAeOD2/8CnEAhQHggeAApQn0z3GgAMgcAdgRoU4PwAcF +v/B/EL+Bv4e/jL/mpgCFQiBAgAf0z3GgAMgcRBkABUoiACFKdwHggeBhvwClCPTPcaAAyBwB2BGh +Dg/ABwLBFW8leBB4ELiFIIoABqbpcIAggg0QeEXABriBuJe4BqbpcIAgQg8QeEbABriBuJe4BqbP +cAAAAi8Gps9wAADCMAamAIVCIECAAKUG9M9woADIHEQYAAWIwInBisKLw7IKYAVAJAQ8LMCA4Aj0 +z3GAACA+EIkB4A94EKlMIUCgDvRMJwCgDPKCD8/7geAI9DAcAjVPJQAgLyUHIM9xgAC8qhYhwQUw +ERkACMLPcIAAFJgWINYDCcDwHoAg9B4AIAfAiCJ8AC8jACAEK74gL3COCa/6KIEOIJgPAAAAAQnA +iCB8AAQo/gQvcHYJr/orcQ4ggQ8AAAABCSCDPwAA/wEJIYIPAAD/AUgjAwBIIgIALMBUHtgggeBV +HpggDvQMFAQwQCgAIUAsgQE4YPV4x3CAAPiqYrBDsACFAeCB4AClCPTPcaAAyBwB2BGhvg3ABwPB +QCgAIQa5OGD1eMdwgAD4qiKQPHoFwRC6BrmBuUV5JqYDkAbBHHgGuRC4gbkleAamAIVCIECAAKUH +9M9xoADIHEQZAAVCIlIgTCIAoEwGzf8EwUAhUSAycZYFxv86FAExUSHAgcohgg+AAEYEyiGBD4AA +RwQmpgHggeAApQn0z3GgAMgcAdgRoTINwAcyFAAxELiBuIe4jLgGpgCFQiBAgAClBvTPcKAAyBxE +GAAF3gzP/gXwFg8v/IogiQzPcKAAtEdxEACGBCCAD3AAAABBKD6F8fWaCM/3z3CAANyXDIDPcYAA +3JeicAyhDYEB4A2hCPCKIJgMiiEEA+YMT/y5Ba/0r8DgeADZz3CAAPiXLKgtqOB/LqjgfuB4gLjP +caAA7CcGoeB+z3CAAAchz3GgAOwnBqHPcIAARzoGoc9wgADHUwahz3CAAMckBqHPcIAABz4Goc9w +gACHVwahSdnPcKcAiEkwoOB+4HgB2c9woADIHDCgS9nPcKQAHEAkoOB+4HjPcQEAHGTPcIAA/Cng +fyCgz3GAANyXAIGAuOB/AKHgePHAAg2v9LhwUyCBAM9wgAA0cihggeDKIcIPyiLCB8oggg8AAJUZ +yiSCDwAA/gBAA+L1yiPiB892gAAMKiCGYHkB2IPgEfIghut1YHkB2Lhwz3AAAJYZCiHAD6lyItsR +A+/1iiSDDwkFr/QB2AnZ4H8goOB48cDhxc91gAAMKiCFYHkC2IDgIIUI2Aj0QHkQec9wgACgCgfw +QHkQec9wgACICyoMj/XiCWAEAdiCDo/9ag8AACoIAAC9BI/0CHFYiQGAgOICoQn0WYmA4sIgogDA +IKEAAqHgfuB+4HjxwCIMj/TPdoAAlBwAhgHggeAApgDfCvQB2c9woADIHDGgGgvgByhwx9iUuM91 +oADsJwalz3ADAIJsBqXPcAMAwnQGpc9wAwBClgalxtiQuAal6grgBwrYz3AAAIJsBqXaCuAHCtjP +cAAAwnQGpc4K4AcK2M9wBQBClgalvgrgB4ogBw3PcAAAQpYGpa4K4AcK2M9wEwDGAAalogrgBzLY +AIZCIECAAKYF9M9woADIHPGg2QOP9OB48cBqC4/0z3KgAKwvNYJRIQCAAN8G8gHbz3GgAOwnZqGA +4Aj0z3CAAPgpAIBAeErwFYJRIACAyiHBD8oiwQfKIIEPAAB/GcojgQ8AAKoAyiTBAIgB4fXKJcEA +z3ATAMcAz3WgAOwnBqXPcBAABmkGpcfYlbgGpc92gACUHACGAeCB4ACmCfQB2c9woADIHDGg8gng +Byhwz3AAAEItBqXPcAAAgkYGpc9wAABCYAalAIZCIECAAKYG9M9woADIHPGgEQOP9PHAqgqP9M9w +gAAEKiCAocFgeQTYgOAz8s92gACUHACGAN0B4IHgABxEMwCmCfQB2c9woADIHDGghgngByhwi3Gi +Ca/1ANgAhkIgQIAApgb0z3CgAMgcsaAAFAExz3WAABAqhiH/DECFQrlgegLYABQBMUCFA9hgesG5 +nQKv9KHA8cAiCq/0A9jPdoAABCoghs91gADIN2B5osGA4AbyIIZgeQTYgOAG9GcDIABIFQQQA9ga +cM93pwAUSM92oADsJ1oMr/0F2A6lz3CAAJQcAIAB4IHgz3GAAJQcAKEJ9AHZz3CgAMgcMaDWCOAH +KHAD2PIIr/WpcQTY6giv9SJtBdjiCK/1JG0K2NoIr/UmbQ/Y0giv9UAlARI22MoIr/VAJYESN9i+ +CK/1QCUBEzjYtgiv9UAlgRMIhwSlDYcFpQ6HBqXPcKcAmEccgAelF4cIpRaHCaXPcKsAoP8YgAul +z3CrAKD/GYAMpc9wqwCg/xqADaXPcAMAxgMGpsbYkLgGps9wLAACAQamz3BZAEIBBqaKIIoABqbP +cEAAhw0Gps9w0QDCDQamz3DAAAcOBqbPcIAAlBwggIHhBvTPcqAAyBwA2BGiAdgIpwDYDacOp89w +pwCYR89yUAD/AFygANgXpxan/NrPcKsAoP9YoHzaWaAagM9yqwCg/4C4GqKB4c9wgACUHCCgCfTP +caAAyBwB2BGhrg+AB89wQACGDQamz3AQAAIOBqaLcGYMIAWBwTaFAMAieAQogA8AAHQJFYU3hQJ5 +Igqv9C9wAcJP4M9xgACImRSlV6EYoc9wQACHDQamz3ARAAYOBqbPcIAAlBwAgM9xgACUHEIgQIAA +oQb0z3GgAMgcANgRoYtwBgwgBYHBNoUAwCJ4Fgkv+xKlMoVVhSx4N4UvIEAOQnk5YbYJr/Q1eeC4 +HHjAIGIAgiDEAs9xgACImRKlE6UWoc9wgACUHACAAcIB4FWhgeDPcYAAlBwAoQn0z3GgAMgcAdgR +odIOgAcBlRC4hSCEAAamApUQuIUghQAGpgOVELiFIIsABqYElRC4hSCPAAamBZUQuAUggA8AAIIN +BqYGlRC4BSCADwAAwg0GpgeVELgFIIAPAAACDgamz3CAAJQcAIDPcYAAlBxCIECAAKEG9M9xoADI +HADYEaEEhSuFCKcFhQ2nBoUOpwiFF6cJhRanz3CrAKD/OKAshTmgLYU6oJIOb/0OhTKFjCGCgEX2 +jCE/gQz2Ig6gBwrYJg3ABEIgQCCA4AYFzf8G8DIOL/yKINEFMoWMIYKARfaMIT+BBfYeDi/8iiAR +C0gVBBCMJIKARfaMJD+BDPYKIcAP63LPcAAAtBmKI0UMJQWv9bhzz3CAAL4UAIiA4Afyz3CAACg4 +ABAEAIhw9QZv9KLA4HjPcIAAyDfgfxSA4HjPcQEABHzPcgEAwHKhBK/5ANjgeOB+4HjxwM9wgAD4 +KQCAQHjPcIAA9CkAgEB40cDgfuB4ANnPcIAAmAfgfyCg8cBCDk/0z3CAAAQqIIChwWB5BNiB4JH0 +Ignv+/fYgeCL9ADYABwEMM93gACUHACHAeCB4ACnCvQB2c9woADIHDGgGg2gByhwi3UA2DINb/Wp +cQAUBTGocIYg/AOMIAOMDfIKIcAP63LPcAAAvhmKIwQBQQSv9Yokgw/PdoAAECpAhoYl/A8A2GB6 +Qi2BAUCGAdhgegPZAdjmDG/1qXFAhgjYYHoAFAExABQFMUwlAIDKIcIPyiLCB8oggg8AAJoZyiOC +DwAAEgHoA6L1yiRiAALYrgxv9alxQIYE2GB6ABQBMRLYmgxv9alxQIYF2GB6ABQBMQAUBTFMJcCA +zCUigcohwg/KIsIHyiCCDwAAnBnKI4IPAAAZAZgDovXKJGIAAIdCIECAAKcW9M9xoADIHADYEaEQ +8M91gAAQKkCFAdhgegPZQIUE2GB6CHFAhQXYYHoE2VUFb/ShwOB48cDqDE/0z3WAAJQcAIUB4IHg +AKUA3gr0AdnPcKAAyBwxoN4LoAcocM9wgAAGIc9xoADsJwahz3CAAEY6BqHPcIAAxlMGoc9wgADG +JAahz3CAAAY+BqHPcIAAhlcGoQCFQiBAgAClBvTPcKAAyBzRoM9wpwCISdCg3QRP9AjZz3CAAPTB +4H8joPHAYgxP9M92gACUHACGAeCB4ACmAN0K9AHZz3CgAMgcMaBWC6AHKHDPcAAAwizPcaAA7CcG +oc9wAAACRgahz3AAAMJfBqEAhkIgQIAApgb0z3CgAMgcsaB1BE/08cBOCi/3FtjiDMAEz3GAAEQe +AIHEEAAGUSBAgQf0AYHEEAAGUSBAgQTyzgiv9xPYz3CAAOwpIIBgeQvY0cDgfvHAug6v+4ogiAWA +4A3y1gzv/ADYz3CAAAQqIIBgeQTYgODMDQL/0cDgfuB4z3CAAEQeA4AIgM9xgAD0wVEgAIAD8gGJ +AvACieB/AKmA4PHAuHEO9AohwA/rcs9wAACnGYojxAvNAa/1iiSDD89xgAD0wSCBTCUAgAQhgQ8A +BwAAQSkDBgDZyiRNceB46CBtA/AgRQAEJYIPAQAAwC66ZXpQcwX0AeHRwOB+CiHAD+tyz3AAAKgZ +iiMEDnkBr/VKJEAA4HjxwOHFAN3PcIAAoAamCCAAoKDPcKcAFEiooF0DT/TgePHAocG4cADYQMBT +JYAAgeAR8oLgIPKE4CXyCiHAD+tyz3AAAKsZiiOKCiUBr/WKJIMPz3CAAAwqIIBgeQHYhOAB2cB5 +z3AAACLSNHjPcYAAE+YP8M9wAAAj0s9xgAAW5gfwz3AAACTSz3GAABnmKdoSuvAiAAAOIIIPAAEA +AEDCi3AaD2AEA9qhwNHA4H7gePHASgpP9APIlBAAAM92gACUHAQgkA8BAADAAIZBKJAjAeCB4ACm +AN0J9AHZz3CgAMgcMaAyCaAHKHDPcSQABwHPcKAA7CcmoIohhQAmoFMggSCB4RPyguEw8oThPvIK +IcAP63LPcAAAiBmKIwYDiiSDD00Ar/UKJQAEz3GAAEQeI4EogVEhAIDKIYIPgADHIMohgQ+AAIck +JqDPcQQAxzEmoACGQiBAgACmBvTPcKAAyByxoPkBT/TPcYAARB4jgSiBUSEAgMohgg+AAAc6yiGB +D4AAxz3i8c9xgABEHiOBKIFRIQCAyiGCD4AAh1PKIYEPgABHV9Lx8cDPcYAARB4jgS8oAQAogcC5 +ACGDDwAAItJOIIEHKdgSuPAgwADPc4AAzLN4i89ygAAT5oDjocFAwAf0AiCADwAAAMBAwItwNHlZ +YcYNYAQD2qHA0cDgfvHAAglv9Lhwz3AsAAYBz3OgAOwnBqPPcqsAoP8aglMljQCB5QDZEvKC5TTy +hOVU8gohwA/rcs9wAACBGYojhQMtB2/1iiSDD891gABEHqOFqIXPdgIAggJRJQCQyiWCH4AAxiDK +JYEfgACGJKajxqPPdQQAxjGmo891SABCAaajz3OnABRIN6OAuBqi4QBP9M9xgABEHiOBKIHPdQIA +ggJRIQCAyiGCD4AABjrKIYEPgADGPSajpqPPcQQAxjEmo89xSgBCASajAdvPcacAFEh3odzxz3WA +AEQeo4Wohc92AgCCAlElAJDKJYIfgACGU8olgR+AAEZXpqPGo891BADGMaajz3VMAEIBu/HxwO4P +D/QDyJQQAAAB3s91pwAUSMilBCCQDwEAAMDaDu//QSiAI//Ym7jPd6cAmEccp4ogEg3+Du/7QSiB +I89xgACgBgCBgODKIcIPyiLCB8oggg8AAKwZyiOCDwAAsgDKJCIA/AVi9colAgEA2Bal2qfhBy/0 +wKHxwHYPD/TPcKYAnD8ZgFEgAIBf8s91gACsBgCFRoCgEgAGLygBAE4ggQdBKdAATCCAoAn3SHCA +IAoAMiAABIDgD/QKIcAP63LPcAAArRmKI0sCiiSDD5UFb/UKJQAEz3aAAAjmQCbAEsIN7/UJ2QDY +Dgqv/w8gAASA4ADYDyAABAT0HgzP/wTwng3P/wPIuRCAABt4gLgKrgCFJoCWIUEDACEABBiIjCDD +jwJxBPJhuA94GKmKIFINANkCDu/7DyEBBACFJoCgEQAGnxkYALILz/8JBw/04HjPcSoAFQDPcIAA +zF3gfyCg8cCKDg/0OnAbfc9wpgCcP2QQEABRIACgFfRGCW/0A9hhvYwl/5/z9QohwA/rcs9wAACk +KFHbCiRABMkEb/UKJQAEqQYP9OB48cBKDg/0z3GgAKwvOoFSIQEAUSEAgKHBAN2A9IDgz3aAAJQc +WPIGCo//z3eAAAQqIIdgealwjOAH8iCHYHmpcJDgIIYr9ACGAeCB4ACmCvQB2c9woADIHDGgCg1g +Byhwi3EmDS/1iiAHBQCGQiBAgACmBvTPcKAAyByxoAAUBTFMJcCAKvIKIcAP63LPcAAAiRnq2yUE +b/WYcwHhgeEgpgn0AdnPcKAAyBwxoLYMYAcocM9xBgACdc9woADsJyagAIZCIECAAKYI9M9woADI +HLGgBPC6CAAAAIYB4IHgAKYJ9AHZz3CgAMgcMaB2DGAHKHDPcIAARB4DgM9xoADsJw6AgLgGoQCG +QiBAgACmBvTPcKAAyByxoJkFL/ShwOB48cBuCAAAz3CAAAQqIIBgeQPYgOBEDoIEz3CAAJAkBIBR +IICAC/LPcYAARB5NgT6RUyIAAP4MIAIB29HA4H7gePHA4cXPdYAAwDcAhVEgAIAM9FoPwAM6DQ/7 +rg/P9y4Oz/8AhYC4AKU5BQ/08cC2D2/7iiAEAoDgEfJKDo//xg/P/89wgAAEKiCAYHkE2IDgBfIS +CI//DggAANHA4H7gePHAjgwP9M91gADANwCFUSBAgB30z3CAAAQqIIBgeQTYgOAV8l4Pb/vi2IDg +D/LSDi/9B9h6CqAECHZGDw//wgsv/clwAIWBuAClsQQP9OB44H7gePHANgwP9KQQAQD4uQjythAB +Ac9woACYAz6gn/AAFg1BvLAAFgJBXbAAFg5Az6AAFgJBQBiEAAAWAkBRoAAWAkFIGIQARCUCE4Ti +GvIY23IYxAAAFgNAiOJzoAAWA0FQGMQAABYDQVQYxAAI9KlzhiPzD4wjDIAO8hjbFvAQ23IYxAAA +389zgAAUw+ezENsM8B7bchjEAAAWD0D2oAAWD0FcGMQDqXeGJ/0cjCcCkgn0AuNwe3IYxAAAFg9B +AvAA3+G7YBjEAwTyABYPQSh0hCQMkAT0ANoj8IDiGvRRJgCQ0SEighTy0Iiouc9ygAAQ16QYQAAC +vtZ+wmL+ugTyi7mkGEAAANpaoFug5vEAFgJAWqAAFgJAW6AI2nQQDgG+EA8Bwn9if0J/uBCCAJi5 +pBhAAM9xoACYA0J/emJQenIYhAC6EAIB8H9wGMQDpXpcsD6BthhEAEkDD/TgePHA2gov9IogBwbP +doAA8BcKCu/7IIYV3c93gADsDwCG6XFSaAHgAKZUelhhAoCA4FlhEvLPcqAALCBQgkJ413BJawDS +ANvI92KhiiDHBc4J7/sgiQCGquCD9wDYAKZhvYDlvgfN/90CD/TgePHAz3CAAHgODtkB2v4KIAAA +289wgACwDgnZAdruCiAASHPPcIAApA0q2QDa3gogAADbz3CAAEwOC9kA2s4KIAAB29HA4H7gePHA +4cXPdYAAWjiKIEcGWgnv+yCNBNjeCS/7AdnPcIAAWTgAiLILIAAgjXUCD/TgePHAz3GAAFo4iiDH +BioJ7/sgic9wgAAAYFIKQAXRwOB+gODxwNhxC/QCCQAAANkioIogxwUCCe/7yHHRwOB+4HjxwLoJ +D/RyD0/7z3aAAKAHZtgibgHazg1v/EhzgOAM9AohwA/rcs9wAAC2FNnbiiSBCTzwAhYFEUwlAIDM +JYKPAAD//wz0CiHAD+tyz3AAALcU3NvRBy/1iiSBCWfYyXEB2oINb/xIc4DgDPQKIcAP63LPcAAA +uBTf24okwQkW8AGWJG4B2gHgEHhaDW/8SHOA4KGWDvQKIcAP63LPcAAAuRTi20AlRBB9By/1SiUA +AAJtEHgmbgHaKg1v/EhzgOAM9AohwA/rcqGWz3AAALoU5dtAJYQQ6vFNAQ/0z3GgAGAdErEUkeB+ +geDxwLhxHPRMJQCAxPZMJYCDzPYKIcAP63Kn2AW4nNsdBy/1SiQAAEAtgAAUeEIgAQPPcIAADA8Z +YR/wz3CAALwTMiBAAYwgw4/KIcEPyiLBB8oggQ8AAOEUyiOBDwAAogDcBiH1yiQhAAK4FHgAIIEP +gADsDyhw0cDgfui4CPIEIL6PAAAAGAHYA/QA2OB/AKngePHAOggP9M91gADaBgCNz3eAANgGWg/v +/yCPQYjPdoAAYDjjuiCXB/IB2ACuiiDHA03wAoCA4AbyANgArpC5RfBRIgCBM/LPcoAAcCEHihBx +LfQAlWGKcHAp9M9wgADcBgCIRooQciP0z3CAAEQeDoBRIECBG/LPcIAAXDhAgIDiANsO8s9woAAs +IBCAQnjXcDEBAC1E9wHaQK4E8GCuANoQuoogRwNFeRHwz3CAAKIcAIiA4AbyAdgAroogBwMH8ADY +AK6RuYogBwSyDo/71Qfv8wCO8cBOD8/zocEacDpygOFodsgALAAA2JpxFSANIM9xgACgBwAVkxAC +FZIQunDjjSGRAY0B2jhgEHiLcVoLb/xIc4DgE/IAFAAxTCEAoEAqgiAEIIEPAAAA/0e5VHoY8sdy +gAAMDxfwz3CAAKAHwZChjQohwA/rcs9wAAC7FIojhAAAJkQTUQUv9QolQAXHcoAA7A+A5gAawgQD +8gKqAvABqlEgAIAT8oDmDPIDioC4A6oSbxR4G2Jji1hggbtjqOSqgOYE8iaqA/AlqkIkQSCA4UYH +7f9AJUAgxQbv86HA4HjhxVMgDQCgqQQggQ8ABgAAQiEBgAQggA9AAAAAyiFiACCq13BAAAAAAdjA +eACr4H/BxeB4gODxwA/0gg3P/89xoAAsIDCBx3FJawDSIqB6Da/7iiCHBdHA4H7gePHALg7v89hx +CiaAkIh1zCMigAbyQiYGAS8mhwFCDe//yHGA5s9xgABYBwChJvIkiAK5NHlDiAPhUSIAgAIQhQAP +9AohwA/rcs9wAADiFIojiAVKJAAARQQv9QolgAEIYVEgQIAM9AohwA/rcs9wAADjFIojiAbv8QEQ +hQBRJQCAyiHBD8oggQ8AAOQUyiOBDwAAKALKIsEH3fPhvdElIoHKIcIPyiLCB8oggg8AAOUUyiOC +DwAALwLgAyL1yiSCAVElAJAT8lElwIDKIcEPyiLBB8oggQ8AAOYUyiOBDwAANgK4AyH1yiSBAbEF +z/PgePHAMg3P86HBCHUodxpyAN7PcKAAtA9wEBEAiiDHAF4Mr/upcbYKoAPJcItxQCRCMEAkgzCC +Du//6XBMIACgBfRKJAAACfDPcIAA1KIBiIDg+PVKJIAAIMABFIIwqXG2Du//AhSDMM9wgABaOACI +gODMJQKQCvLPcIAAWAcAgMKgz3CAAFg4wKjlvxfyz3GAAHAhB4kQdRH0AYlTJwIQEHIL9AQnjx8A +BgAAgOcB2gaJwHoQcg3yz3CAAKMcwKjPcIAAXDjAoM9wgABgOMCoiiDHAKoLr/upcQIKoAMvIEcE +sQTv86HA4HjxwM9xgAB4PooghwGGC6/7IIFqCc//z3CAANgGAJCA4PgLwv/RwOB+4H7gePHAcgrP +/7YJz/8SDYAG8gmP/OoIgAHRwOB+4HjPcQAArd5FA6/7iiCHCeB48cDhxc9wgABgOACIgOAS9LIL +z/+A4A70iiBHBADdHguv+6lxkNmQuQPIoBhAABjwz3CAAOwXAIiA4BHyz3CgAAAELIiMIQKAAN0J +9O4Kr/uKIIcEkdmQuejxAd0VBO/zqXDgeM9xgABEHvAhAQAoEYAAKIFNBu//ANrgePHAfgvP8wh3 +z3KAAHAhz3aAANgGAJZnihBzz3GAAKIcFPTPcIAA2gYAkGGKEHMO9M9wgADcBgCIRooQcgb0z3CA +AKMcAIgD8ADY/grv/wCpz3CAANwGQIjPcYAA2gYAiSCOgOIB2sB66XMA3eoM7/+Ydc9wgABYBwCA +AYjPcoAA7BdRIACBIJYG8gHYAKqKIEcDBfCgqooghwMmCo/7SQPP8+B4z3GAAHAhz3CAANgGAJBH +iRByGPTPcIAA2gYAkEGJEHIQ9M9wgADcBgCIJokQcQr0z3CAAKIcIIjPcIAAoxwgqOB+4HjxwJYK +z/PPdoAANKkUjoHgEvQE2E4K7/oB2c9wgADaBgCIz3GAANgGHgzv/yCJANgUrjbwto6A5TLyz3eA +AFg4AI9huBB1GfJaCM//z3CAAHjfBYAhbQUofgDPcIAAAGAeCyAFL3GKIIcGz3GAANgGZgmv+yCR +z3CAANoGIJDPcIAAWTigryCoz3CAANgGIJDPcIAAWjggqADYFq41joDhCfLPcIAA2gYaCO//AIgA +2BWuTQLv8wHYz3CgACwgMIDPcIAAXDjgfyCg4HjxwNYPr//hxc9wgABgHhCIhODPdYAA1KIL9Iog +DwruCK/7iiFKBAKNagggACGFAo0hhWIM7/8B2gkCz/PxwIoJz/PPcIAARB48EJAArYCKIAcCugiv ++wpxUyUAEKII7/8KcQGIUSAAgcohwg/KIsIHyiCCDwAA6BTKI4IPAABiA8okIgC0B+L0yiUCBJ0B +z/PxwDYJ7/PYcaHBGnCLcUAkQjBAJIMwogrv/8hwARSAMIDgCvICFIAwgOAG8kIgECEvIAckIMA6 +CO//CnEBFIEwgOEE8qKIA/ChiIogxwEuCK/7yHFAKAAmQC0CFAV6ARSAMAIUgTAIuAV6iiDHAQ4I +r/tFeeG90SXikAXyUSUAkQ/yCiHAD+tyz3AAAOcUiiNNA0okAAAVB+/0CiUABP0A7/OhwPHAjgjP +86HBGnAA3s9woAC0D3AQEQAiDmADyXCKIEcBtg9v+wpxhCgIKQAhjX+AAEykJfBAJQAXFiCEAwUU +gACGIP6HGvIEhYtxQCSDMEAkTzDCCe//6XKoFQAQ6g+v/+lxIMAEFIEAARSCMAIUgzD+Ce//SiTA +AAHmDJUQdrgHxf+KIEcBUg9v+wpxqg1gAy8gRwRZAO/zocDgePHA7g+P86HBCHcacTpyAN7PcKAA +tA9wEBIAgg1gA8lwo4+KIAcBFg9v+6lxBYeLcUAkgzBCCe//QCRCMAqHbg+v/0AkQTCA5dL3FCGM +IyCMIMABFIIwAhSDMPAgjyN2Ce//UycEEAHmsXax94ogBwHKDm/7qXEmDWADLyCHBM0Hr/OhwPHA +JgvP/6YPQAbRwOB+4HjxwGIPj/MKJACAz3CAAAjgpGhVIEEEBBAGAQXyDCSAgYz3CiHAD+tyz3AA +ANsbqtulBe/0CiWAATIhAAEAIQMBACEOAQAhBQFii8OOACECAQQVhQCMIEOHzCOBjwAAUADMJoGf +AABvAMwlgY8AAJoAB/TlionnBfTmioznEvIKIcAP63IYuBC7BSMNAAi+xX3PcAAA3hu12z0F7/QF +JUUDAYoCJgIBQCCQAAIiAoTKIcQPyiLEB8oghA8AAN8byiOEDwAAvAAQBeT0yiUEBIDixvaAcU4L +4AMAIQAEAJUA2QIgAAQAtc9wgAAcK9kGr/M2oOB48cB2Dq/ziiGLBgDdz3CAAFjBpaCeDW/7iiDK +Ac9wgACwMKKgz3GAAEQeAIHEEAAGUSBAgVfyA4EYiITgU/KKIMkDcg1v+4ohiwjPcIAApBwEgM91 +gAB0WyCAiiCJA1YNb/s2uQCFQiAAgMogYgCB4Bj0dg7gBKlwz3aAADxbAIZCIACAyiBiAIDgDPSK +IIkOIg1v+4ohSwvJcMIO4AQihc91gACQWwCFQiAAgMogYgCB4Bn0Mg7gBKlwz3aAAFhbAIZCIACA +yiBiAIDgC/SKIIkO4gxv+4ohiw7JcH4O4AQihQEGj/PgeOHFANvPcoAABMIUIg0AYLVotRpiIBrC +AMAdxBAoGsIAz3GAALDBFnkikTAawgDQHcQQgB3cEHgdRBAB2YgaQgDPcYAApMIVeWCh4B3EEPAd +xBDgf8HF4HjxwMoM7/sR2IDgPfTPcYAAcCHPcIAA2AYAkEeJEHIs9M9wgADaBgCQQYkQciT0z3CA +ANwGAIgmiRBxHvTPcIAA6CkAgIDgHPRKDUADgOAJ9AvIBSCADwAAADwLGhgwgg1AA4DgCPQLyAUg +gA8AAADUCxoYMAvIkLgLGhgw9goP+wPwygiP9NHA4H7geADZnLnPcKAArC89oOB+4HjNBM/68cDe +Cm/2FdiKINAHxgtv+6/Z0cDgfuB48cDPcYAAbDgIiYHgFPQDiYDgxvZhuAOp0cDgfoDgDPSKIFAO +lgtv+4ohhwAyD6ACAdj08fLx4HihwfHA4cWswQDZSsGQ2Ri5SMHPc4AA9MEggwQgjQ8BAADAhiH+ +AyS5DrkLJUCQTsCOwhby13UAAABAzCWCnwAAAIDMJYKfAQAAAAT0IYMD8CKDrrivuLC4BXkgog7D +CMCLdQQjgQ8BAADALrlAKQIGRXhIwIogBgZJwEHDqXAA2lIJIAAB289xgADoFRqBO4EkeFEgAIIS +8grAC8GEKAQOACGAf4AAmOMCuQjgNHkhYM9wpwCISS+gWglgBalwCNz7A6/zrMDgeKHB8cB6C6/z +CHKtwQjYSsCQ2Bi4ScDPcIAA9MGggAQhjg8BAADAhiX+EyS9Dr0LJkCTUMGQwxby13YAAABAzCaC +nwAAAIDMJoKfAQAAAAT0AYAD8AKArrmvubC5JXgAoxDDCcUEI4EPAQAAwC65QCkABua6BX1JxQ3y +CsAEI76PAAAAGEUgwABKwAXyhSAQAUrA5LoQ8pu9z3CgACwgBYAA2wK4briA4MogzADJuKV4ScAG +8Oi6BPKdvUnFEMCBxULAqXBGCCAAAtsDyAzCz3GAAOgVuRiCABqBO4EkeFEgAIIM8gK6z3CAAKDj +VHpBYM9wpwCISS+gUghgBalwCNzrAq/zrcDgePHAcgqP86PBYYAIdUDD6bsA2AqlNPIEI4APAQAA +wC64z3KAAHRnCmJJIoIAYbpLpRJqFHjHcIAAkOTKgM93gACMw8alC4DPdoAARB4FpcOGIMDUhvWP +BH7kfgm+QCkPAuV+xXgEI4MPAAAAEGV4B6UIhRjinrgIpUulkPBRIoCCGvLPcIAAJF4AgEHA6LhC +wA/yhiD/CSO4AeCB4Mn3guAE9AbYYcAl8AfYYcAh8CLAYcAf8EHDz3KAAKwGQIJGgp4SAgaG4hT0 +BCO+jwAAABgO9M9ygABEHkSCSIIEIr6PAAYAAATyAdgKpQTwCqUA2AHG6L4f8kLGIsKg4soiIQAE +Jo8fAQAAwEEvhBNEJg8WI78B5wQmjh8GAAAAMb4AJsUTz3aAAHRnMiYOEQImThES8FMmwhDPd4AA +wGtdekpnBCaOHwEAAMAuvs93gAB0Z85nYb7ou9Z6S6UI8iDHz3aAAHxn7mYD8AHehCgEDgAhgH+A +AJjjArpUekdgYb5YYOalAYAEI4MPLwAA3Sa7xXtSI8MDBaVnpc9wgAD0wQOAESBAgADfDvLPcIAA +QF4AgOC4CvKGIH8PHXhAKM8DBPAA34+/gOcc9M92gAAEKiCGYHkA2IzgEfIghmB5ANiQ4AvyIIZg +eQDYkeAH8iCGYHkA2JLgBPSeCS/8ANgIhQV/6KXZAK/zo8DxwG4Ij/PPdYAAICoAhcSQyXA2C6AA +hiD8AwCFyXG2CmAAhiH8A5rgz3OAANDDBfQhg4C5IaNKgwHiSqPPc6AAxCeREwGGw7lQcQ30iiUI +EBMbWIOREwGGw7lQcQPyEhtYg3kAj/PgePHA/g9v8wDYz3GgAKggKIHPcaAA1As4gc9xoADEJ1IR +AoYVEQKGQhEDhv67BvIB2M9xgABUw2GxUSLAgBpwyiViFBL0USDAxsolohQM9M9woADQDyAQAYYf +EACGEHEA3colYhWA5Xf0z3aAAFTDH4bwuGjyqBYBEJTYJgvgAslyTCAAoM93oADQDyjyz3CAAOQH +IIDPcKAA/CWA4c9ygADowAz0M4AKghlhKqLPcgD/AKqKIIgFDPATgCSSGWEweSSyiiCIBc9yAP8A +/+IMT/0AlhILr/00lpQXABCA4M9ygABcPAHZGvJtggHjbaJrgnhgC6LPcIAAohwgqB+G7rgG8s9w +gACMBiCgCPDvuAbyz3CAAJAGIKDPcKAA/CUTgGyCeGAMos9yAKAIAOxwQKBvIkMA7HBAoA4fWJDy +DoAGz3AAAP9/z3GgAAwkAaEb2AShEQdv86lw4H8B2PHA4cWhwS4O7/qLcIDgN/QAFAUwUSUAgAzy +hggAAM9xgABUw0OBz3GAAPCpQaEn8FElgIAE8nIOz/8h8FElQIIE8v4Nz/8b8FElwIAc8gjYz3Wg +AMQnEx0YkLIIAAGU4A3yAtg8HQCQz3CAAFTDI4DPcIAA8KkhoBnYmeDF86EGb/OhwAohwA/rchfY +jLiKI8cAhQSv9Iokgw/gePHA4cXPcIAAVMM/gAQhgQ///484BCWAXwAAcMcleM9xgABUwx+hRCIA +U4jgz3WAAFTDJPRRJUDRIPIqD8//USWA05wdABAJ8s9wgACYHgWImB0CEBXwUSXA0wnyz3CAAKgh +GYiYHQIQC/ADhSYLr/QkhZgdAhAF8ADYnB0AEJwVABCA4Mwg4oB48s9wgACQEguAgOAP8s9ynwC4 +/x2iz3GAAHwcBIEB4LO4tbi4uAShFqLPcKAAqCAIgB+FUSAAgQf0USXA0gX0gNiYHQIQmBWAEFEg +wIFAKAEGCfRRIoDTgrkO8toMgAIa8B+FUSKA07O4H6XFIYIPAAAAB0UhAAbPcYAA4MMsiYYh/Q9S +IcEBRbkleM9xoACIJBChiiDWAM9xoADEJ34ZGIDPcKAA1AsB2lKgBNgQGRiAz3WAAFTDH4VRIICB +JfIUlVEgQIEh9M9woAAsIA+AgOAb9K1xkgyv+FYlQBWAFQAQlLiAHQAQH4WQuB+lDfDPcYAA4DsP +gQHgD6EQ2c9woACQIz2g9QRv8xnY8cByDG/zANkIdgGAwbiD4MogQSAF8gYPIADJcBpwTCAAoMf0 +EIZRIICBw/IQhs91gABUw+64B/LPcIAAmB4FiA3wEIbvuAfyz3CAAKghGYgF8AWGJoaqCY/0mB0C +EIAVABAEIL6PEHAAAAf0rXHuC6/4ViVAFRGGz3GAAHgHAKFBKAEDUyHFAJgVgRBBKAYFUSHAgRRp +BSBEAQbyHoWVuB6lfPAuC+/6TyRAApDg7AAGAM9xgABknpgVgxDwIQEAQCsCBoYj/Q9SI8MBRbtl +es9zoADEJ0EbmIAA2oy6AiZPAPpiy7rXcgAAAAhALQ8DkL9S9wUnjxFiG9iDjCICgMf3z3GAAFQ9 +EoEB4BKhANmduUbw5XliG1iA13IAAMAPUgAOAA4igw8AAAAQz3KAAMSdFnqg4yCCBBIFAE/3ANgP +IMAAYbhOIw8IASnCA3h5BXkALcAABXoW8EIjAwgA2A8gwABhuHh5BSECAIoh/w8K8M9zgABUPROD +iiH/DyhyAeATowHYz3OAAGSqAKsCGwQBIaNCo73xANmcuYAVABAleIAdABBAJgASoB0AEALZz3Cg +APQmI6Alhs9wgADwqSGgFQNv8wpw8cCaCk/zCHVVIFEEDcyiwe240SBigAfyBMhWDq//mBAAAM9w +gADQwwyAz3GgAMgfZOAeoRDYDqEB2BUZGIABhYDgBfRRIwDA+/MBhcG4g+BEAgIAABEAIEHABBQA +MUEoEgMQhVEggIEGFBAxRPINzOu4RfIQhc92gABUw+64B/LPcIAAmB4FiA3wEIXvuAfyz3CAAKgh +GYgF8AWFJoWaD0/0USDAgZgeAhDKI2EgDPIehgDflbgepoogBQkyCS/76XF6d5gWgBDPcYAArKoE +uEaRBSCABFBwCfLPcoAAVD0JgkojACAB4AmiBJHXcAAA//8R9EojACAN8M9wgADgOy2AAN8B4S2g +5ggv+4ogBQx6dwGVnODA9AQRFCAIEREgz3CgAPQmAtkjoCOFz3CAAPCpIaAeDCAAqXAKJACAufTP +cIAArKpkkM9xgAAg1EwjAKBAKwUBACFCAT/yz3afALj/z3Cg/hgFFqbPcKAAwC8VIMYAKhYHhhYW +BobPd4AAINQwJ0ERNqYhgjamIoI2piOCNqZIGBiFz3GAAODDSRhYhCyJQCoOIxC5n7nFeUEoDiHF +eUcYWIANzOu4DfIQ2au4DBpcMA0aHDDPcYAA2DwHgQHgB6ENEgE37LkG8kokgAasuQ0aXDBMIwCg +YfLPdoAA3JbgFgEQ5YVEKT4HACZAHuCgrJUB4aKwz3WAAODDrI3gHkAQQCoBI6ioCRiCBBC9ChgE +BKV5DBgABUEoDSEQGEAEpXlqsM91oADAL0cdWJCU48Ajhg8AAJMAz3GgAGgs8CHBACuwjxUBlue5 +IvTPc6D+UAWjFQGWUSEAgY8VAZYV9Gh3z3afALj/9qbggue59qbhgvam4oL2puOC9qbr8wjwSiQA +Agvw57nKISEAQMEBFIIwxrnGulioOaiIcD0Ab/OiwOB48cDhxc9xgABEHiOBSIFRIgCAK/KGIP8B +z3KAAHRnQ7gKYgDbgOLKIcEPyiLBB8og4QfPICEDyiOBDwAAbwDKJMEAJAZh9MolIQCB4s9wqgAM +ULmBxveAvbmhAdkloAXwoL25oWWgCQBP8+B48cCODw/zCHUNzFMgQIAH8gTIOguv/5gQAAABhcG4 +g+DKJiEQBfIKCiAAqXAIdoDmY/QQhVEggIED9ADZUPAMzFEgwIBB8g3MUyBAgA0SAjYk9AAigA+A +AIzCAdnPdoAArDogqBGOUSAAgOQN4gTKIEIAEY5RIECBEPLPcIAAbDgDiIDgCvSKIBAPE9k+Du/6 +i7neCWACBNgQ2AwaHDDPcYAAXDwXgQHgF6EDyA0SATaEEAIBz3CAAIDCNXgpgFlhKaAa3rvxz3CA +AOA7LYAB4S2g+g3v+oogxQkB2c9wgACiHAHaQKjPcIAA0MNOgAaCAeAGogLwAdkC2s9woAD0JkOg +Q4XPcIAA8KmA4UGg/AqCA+kGL/PJcM9zgABUw1gTgQCA4QDaD/Q8k2K5ELlFIUMBz3GgAPQmY6HP +cYAA8KlBoe0AAADgePHARg4P8wh2AYDBuIPgAN0F8tYIIADJcAh1gOU29BCGUSCAgSbyDMzPcoAA +ZDtRIECBF/JA2AwaHDBVEgAGz3GAAATCAeBVGhgADcgA2hR5A8hAqa4Jr/+YEAAACvCsEgEAAeGs +GkAAGg3v+oogBQrPcIAAohwB2SCoz3CAANDDLoAGgQHgBqEC2c9woAD0JiOgI4bPcIAA8KkhoBUG +L/OpcOB44H8I2PHAmg0P8wh1KHcklc4M7/qKIMQLQS8OEcO+iObPcYAAgG7WeQfyAZVBgQTgUHAI +2AT0IIFgealwyQUP889xgADQwyyBz3KgAMgfZOE+ohDZLqIB2RUaWIAhgIDhBPRRIwDA/PMhgMG5 +g+EQ9M9wgACiHAHZIKjPcIAA0MMugAaBAeAGoQDZDfAhgFEhAIAA2coh4QUBgFEgQIDKIaEE4H8o +cOB48cD6DA/zz3aAANDDAYYEIL6PAHAAADryLykBAM9wgACkOPQgTQArhk8lgBBmCKACSYaA4BP0 +jCUDkM9xgABkOwf0uhEABgHguhkYAB7wuREABgHguRkYABjwAYb+uA/yz3GAAKw6DIlPiRByDPIR +iVEgwIC4D8ECBvAA2c9wgABkqiCongxABt0ED/PxwGoMD/MIdgGAwbiD4ADfEvSA5891gABUw0n0 +EIZRIICBO/IQhu64C/LPcIAAmB4FiBPw2g7v/8lwCHfr8RCG77gH8s9wgACoIRmIBfAFhiaGoglP +9FEgwIGYHQIQCPIehZW4HqUfhZe4H6WAFQAQBCC+jxBwAAAP9Jy4gB0AEDCGzgtv+FYlQBVAJgAS +oB0AEADYBbYB2c9wgACiHCCotBUBEAaBAeAGoVgVgBCA4Bn0vg9P+oDgBfIQhu24AdgC9ADYz3GA +ALbD9CEAADyVOGBiuBC4gLjPcaAA9CYDoQbwAtnPcKAA9CYjoCWGz3CAAPCpIaDdAy/z6XDxwGoL +L/MA2Qh1AYDBuIPgyiBBIAXy/g3v/6lwGnDPcKAALCAGgBB4TCAAoM92gABUw8onIhBZ9DCFUSGA +gTLyPJYwcMj2JYXPcIAA8KkCgBBxXfQQhe64BvLPcIAAmB4FiA7wEIXvuAbyz3CAAKghGYgG8AWF +JoV+CE/0mB4CEIAWABAEIL6PEHAAAAr05g5P+oDgC/IQhe24CfIB3wjwAN8Z8B4PT/sV8ADfMIWm +Cm/4ViZAFYAWABCoFgEQnriAHgAQUSFAgkAlABKgHgAQ6vMB2c9wgACiHCCotBYBEAaBAeAGoVgW +gRCA4c9woAD0Jhr0z3GAALbDXJb0IcEDWWFiuRC5gLkP8LQWARALgQHgC6G0FgEQiiBFC5IJ7/or +gcDxAtkjoCWFz3CAAPCpIaCdAi/zCnDxwDoKD/PPcIAAkBILgIDgD/LPcp8AuP8dos9xgAB8HASB +AeCzuLW4uLgEoRaiz3CgAKggCIBRJYDTz3aAAFTDBvLPcIAAmB4FiA7wUSXA0wbyz3CAAKghGYgG +8AOGYg8v9CSGmB4CEB+GUSAAgQv0USVA0wf0USVA0gX0gNiYHgIQmBaAEOe4C/Jfhj6Gs7qVuZe6 +PqZfpgDZAd0W8JwWARCB4RD0P4ZRIUCCz3GAAEQeI4EpgQXyRCENBAXwRCENAgPwAd0E2Ri4JXjP +caAAiCQQoR+GUSCAgRzyFJZRIECBGPTGCsACgOAU9M9woAAsIA+AgOAG8g3MUSDAgQryH4aQuB+m +rXESCW/4ViZAFYDlHfRRIoDTBPLSCEACF/BEIj7Tz3GAAFTDEfQBgVEgAIAN8pgRgADPcYAAENcC +uBZ4AGH+uAAIAvvPcKAAUAwAgM92gAC4BwTZz3WAAFTDAKbPcKAAkCM9oB+F87gG9A+FgOAA2DHy +TXH+D6/6iiBEDjeFihUCEQCGBOIZYVEggMQF9FEhAMb78891gABUw5gVgBDnuADbCfQCuM9zgAAQ +1xZ4A2Mtu8C7ihUAEU8VjRDPdoAARB7wJsMQQnmieFoL7/pPk9EAD/PgePHA4cWhwQDYQMDPcYAA +4DsPgQHgD6ED2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoM91oADE +JxUVAJbPcZ8AuP8WoTEVAJYWoRDYEB0YkIYPb/qLcIDgF/QAFAUwUSWAgA30CiHAD+tyDdiMuIoj +XwdJBi/0iiSDDwTZEx1YkBvZFh1YkD0AL/OhwPHAz3CAADyqZg6v9BjZz3CAAHSaWg6v9BjZ0cDg +fuB48cCaD8/yGnDPdaAA1AsQhQDfgeChwUDHDvIKIcAP63IP2Iy4iiOWCIokgw/hBS/0CiUABM9w +oP54As92nwC4/xamWB4AFM9xoAD8RBmBBCC+jwAACCAD9B2BTCDApAjyyg5v+otwgODKIAIgQiDB +IJThbgENADImQXCAAABiQCeAcjR4AHjPcYAA0MNOgQiCAeAIog6BCIAWppYMwAAA2ShwSvDPcoAA +0MMuggeBAeAHoQ6CB4AWpvPxz3KAANDDLoIMgQHgDKEOggyAFqbp8c9ygADQwy6CAoEB4AKhDoIC +gCfwz3GAAFw8BYEB4AWhH/DPcoAA0MMuggOBAeADoQ6CA4AWpgHZANgW8M9xgABUPRqBAeAaoRam +Sg2gBAHYvfHPcYAAVD0UgQHgFKEWpgHYCHGA4QwMggDPcIAAVMMfgPO4CfLPcIAAuJ3rqM9wgADs +muywA9gRpeB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4EaWBBu/yocAYhs9ygADQw5C4 +GKYYhrC4GKYuggWBAeAFoQ6CBYAWplIIAADG8c9ygADQwy6CBIEB4AShDoIEgPTxz3KAANDDLoIR +gQHgEaEOghGAsfHPcYAAXDwOgQHgDqGU8QohwA/rckHYjLiKI9gHHvHgePHArg3P8s9wgADQwwyA +z3agAMgfEN0B32TgHqauphUe2JPPcaD+IALPcJ8AuP82oGIMIAYJ2APYHqauphUe2JMF8JYOb/qK +IFUOz3CgAAwkB4CA4ATyUSMAwPXzuQXP8vHAz3CAABATrggv+wHZb9gGuGYIL/sI2QfYCrhaCC/7 +BdnRwOB+4HjxwOHFz3GAAEQeI4EpgVEhQIDKIKIAK/REuM9xgACUOMO4CWHguQXyUSWA0Rz0USFA +gBzyz3WAAEQeA4UYiIHgD/LqCE/6gOAH8s9wgACMIQiIh+AF8gOFGIiC4Ab0USWA0QTyAdgD8ADY +NQXP8uB48cCyDM/yRCIQU012hib8E01wTXAEJYBfAAAAIEEofoMF8poIT/qA4AP0AN8C8AHfz3WA +AFTDH4XxuATyAN2k8EwgAKD89XYIT/qA4B7yz3CAAIwhCIiH4MwgYoIW9AGFjCD/jxL0JJXPcAAA +//8QcQz0BYWMIP+PCPQMlddwAAD//8olYRCA8s9wgABEHvAgwQMJgVEgQIEF8s9wgABAaATwz3CA +AExoOIkqYEEuABHPcYAAWGgIYRZ6z3CAAABvSGDguAXyP4WGIfaPF/LhuAXyP4VRIYCCEfLiuATy +USUA0gTyAd0M8OO4CfLPcaAADCQxgYwh/4/28wDdUSCAgcolIhC2Dw/6gOAI8gQlvt8AAAAiyiVi +EIDlKPLPcYAAVMMfgei4D/KMJgKQzCaCnwAAUADMJoKfAADQAAP0k7gfoc9wgABEHgKAwhAABoDg +GvKMJgKQzCaCnwAAUAAU9E+BRXgPoQ/wz3CAAEQeA4AJgOG4B/SMJgKQBvRRIICBAvIC3ZED7/Kp +cOB48cAeC8/yz3CAAJASAICiwYDgAN4P8s9ynwC4/x2iz3GAAHwcBIEB4LO4tbi4uAShFqLPcYAA +VMPeod+hwLHPoU8ZggOAGYADjBmEA4DbmBnCAIQZgAPPcqAAyB+kEgAA+BINAKwZgANCGYQDoniw +GQAAz3CAAFiX2aDPcIAADMTAoATdz3CAAHgHoKCZEYAAoLiZGQIAz3CgAMQnZBiYg891AAD/fxMY +WIMb3RYYWIMaGJiDiif/H891oAD8RP2l+aWKJ5gdz3WgAFAM4qVxonCiPBiAg4ojGAhuooASAwCk +GYADUSNAgM9zgADwqVgZggMN8kIQAIYEIL6PAMAAAAXyAYOA4APyAqPBo4AagANRIYDDz3OAAGQ7 +z3CAAEQeQ4AZ8h+Bi7gfoVUjwAW0GQAACtgcsRuSlhkEAIogRAsqCa/6ANkG2c9woADIHCmgD/BA +IwADtBkAABDYHLEakpYZBACKIIQLAgmv+gDZz3GgANQLEIGB4A30CiHAD+tyC9iMuIoj1QCKJIMP +DQAv9LhzAd2woVEgQMYK9M9woACoICaAB4DFAiAAA93PcIAAVMO0EAEAAIEB4ACh+tieCS/7ANkg +2M93gAAsxLoOYAQApwHYz3GgAMgfE6HPc4AApBwIg0AnEBVAgAyDABAEAASDz3OfALj/ABAFAPgR +AADPcaAAMBAhgTajz3GgAAwkJ4ECIgKANqMA2QMkQwACJQEAz3CAAFTDUBiEA1IYhANUGIQDI6fP +cIAARB5BpyOAYqcUkc9ypQAIDAm3CIHAuAi3ABIEAM9ygABUw1MkRQFMGkIBUyRCAIPiyiHBD8oi +wQfKIGEFyiOBDwAAnAscB+HzzyAhAwQkgw8AAADgz3KAAFTDLbuaGsIAX4LruhQfABEM8gS7gbtl +eAi3B9gH8BUgDCDApAPwBNgB4IjguvcIgeu4jAiCBs9wgABUwx+AK7hTIBAAUSCAxa7yz3GAAJAk +BoEB4A94BqFBKYBDz3GAAJAkRoHPcaAAtA83gcC4MHIA3Qj0z3GgAKggJoGMIYOOxPcD3aXwEnAE +8gTdofDPc4AALMQFg89ypACQQfWCNoIEIIAPAAAA4C244Ljno892gABUwyijBPJQHsQTCfBQHkQT +BCePH///AADno+G4BfIwv1IexBMF8FIeRBPwf+ejUSCAgAXyVB5EEAjwVB5EEwQhgQ///wAAKKMN +ggajBCCADwAAAP4puFYeBBAfhuu4JPLPcKoAAAQEgAmjz3CAAHSaIIiA4URoN/KA4WQALgACEIQA +n3EA2KggwAP0Ig8AFd0TvfAlzxPPdYAALMMVfQHg4KUe8M9wgAA8qiCIgOFEaBnyAhCEAIDhyiRN +cMogLQDoIK0D9CIPACndEr3wJc8Tz3WAACzDFX0B4OClIasCGwIBtBYBEALdAYEB4AGhF/AEIL7P +YAAAAAj0iiCFByoOb/oMEgE3avFRIwDAB/KKIMUHFg5v+gDZXPH2Dy/68diB5TnzguUX9ALdBCC+ +z4ABAADKJaIRBvRRIwDAyiXiEILl9fPPcKAAMBADgIDgyiViEYblQAQCAM92gABUwxyWQiCEAB+G +67gvJAgBe/LPcKoAAASigM9xpQAIDCCBBCWCHwAAAP8ougQhgQ8AAADgibo7e0V7z3KAACzEcqas +om2iIIBIFo8QlOcqohnyBvaK5xn0I7kO8LfnDvLu5xP0RSn+AkEpwXBRJcCRwiFiAAfdC/BFKf4C +QSkBcfrxIrn48QDZCN0BgDemlOELojyyDfTPd4AARB7jh+iHBCe+nwAGAAAD8oy7cqbkuMolIhLh +uMolIRKGIP4PQSgDAU0ewhAIkoflZXgIshT0juEH3Y/3z3CAAEQeA4CEEAAAEHEH989woAAwEAiA +EHEC8gjdh+XKIAEB6A3h+sohIQA5AwAAz3CmAAgEAYAEIIAPMAAAADS4USBAxkIeBBBCFgERC/TP +cKAAqCAIgBlhMHmKDe/6iHAE8KoN7/qIcAQggE+AAQAA13AAAQAAANkV9AHYTh4CEM9ygAAsxJoW +gBBCHkQQTR5CEDemKaIEuCiSibgleAiydfBNHkIQz3CmAIwDPYBRIMDHBCGADzgAAABBKMIEmh6C +EAQhgg8AAADwLLoluEV4z3KAAFTDEqYE8hKCjLgSolMhzgJIEoMA16Lgu9Eh4ocH3QP0CN3PcIAA +LMQpoJoSgQDokAS55XkosNywh+Uygi2gQPTPcaYAjAO9gQQlgR8BAAAAMLlOGkIAqaBOEoAAgOAd +8o3jLfRRIADGJ/QU2M9xoADIHx6hENgOoQHYFRkYgArdUSAAxsol4hFRIwDAyiUiEorl+PMU8I7m +kffPcIAARB4DgIQQAAAQdgn3z3CgADAQCIAQdgP0B90C8Ajdh+Xo9M92gABUw04WgBCA4ODyz3Km +ANQELBIBgDQSEoA4Eg+AyxIQBkpwxrjpcoYi/Q8GukV4SnKGIv0PBLpFeAQhgg8CAAAAJ7pFeEQn +AhwNukV46XKGIvMPBCGBDzgAAAAOuiW5RXgleEQngRAUuSV4iLhEJwESQSnBgFIgQAUSplgeQhDK +IYIPAAD//8ohgQ8AABAfOnE3hkAeRBAEIoEv/wMA/yi5N6ZqCC/4ANryv6weABA78kgWgxAyhqDj +0SHhgjPyBCGCjwAAAAEI8kQhDQYjvQHlgeUK9wQhjQ8AAAAk13UAAAAkIfIEIY0PBgAAADG9guUy +AA0AguUK9IDiFfJEIQ0GI70B5YLlD/SA4gTyzOML9leGMnLKIo4PAQCIDcwgjoDN99dwAQCIDcf3 +z3GAAFQ9HIEB4ByhCN0y8IYh/wlBKc0Az3CAAAwqIIAB5WB5BtgQdRb3z3CAAEQeA4AIgAQgvo8A +BgAAANnKIWIAEoYEIIAPAAAACCu4EHFJ9wINAAAIdZTgyiXiEwrwz3CgADAQCIA3hhBxB93KJWIS +WBaCEM9xgAAsxAiRB7qIukV4CLEXhjAZAAQcsRKG66ENoawWABAoGYAEHbGH5QX0aggAAAh1gOXK +JSEQgOWkCqL/yiBCAwDYz3GgANQLEKHPcIAA4MMNiFEgAIAH8s9woACIJB6ACxocMOoOQAAMzIYg ++Y8J9ITlzCXikAX0ANiPuAwaHDAy2c9woADIHCqgPQKv8qLA4HjxwOYJj/LPcKAA1AsYgEIgAAhI +IAAAz3GAAJAkJYGB4YohmQ4I9M9xgABEHiOBPoGAIZkOEHEA3colbRSA5Tv0z3aAAFTDWBaAEIDg +yiAiACL0DBIBN+O5EPINzFMgfoAM8uu4F4YG8qDgAdjAeArwjuAB2MB4BvBRIUCBEvQA2M9xgABE +HiOBKYE9eVIhAQDAuSR4gOAI8h+GkbgfpgvwF4bo8WoMAABYFoAQgOA8CwEAgOV4AgIAz3WAAFTD +WBWAEIDgE/IC2c9woAD0JiOgz3GAAPCpANgBocDZmRWAEIC4mR0CEChwAvBC2M9xoADEJ78ZGIAA +2AwZAIAB2BAZGIAfhfG4FAICABKFN4XKDe/3ANqsHQAQH4XruFnyz3CAAEQeQ4BIFYEQFIIkeEQg +AwFEIQAMQigEAYBzz3CAAPgewbtoYIm4HKVwFY4Q9IJNFYAQxH+GJv8TBH9Evt9nz3aAAPBn9CbP +E2IdxBPPd4AAHCJrZ4m7faV0gnQVjxDke4Yn/xMEe0S/+2P0JsMQZB3EEHKFeqVUgnulRHkkeM9x +gAAAaIBw9CECAM9xgAAoaPQhAACOHYQQkB2EEJIdBBCUHQQQANhOHQIQmPBOFYEQz3CAACw4gOEA +gMC4U/KA4ADbyiAiAAr0coVIFYAQBCODDwAAAAh7e8K4ACCOD4AA7B4wjtiOx3CAABgiz3eAAPyp +SIhlftylcBWOEGV5w77cfvQnjhNlehCIYh2EEwV7faV0FYAQw7gcePQnABA6pc9xgAAMqmQdBBBo +FYAQw7gcePQhAwBbpY4dxBDPc4AAVKr0IwAAkh0EEGwVgBDDuBx49CEBAJAdRBD0IwAAPPCA4ADY +BvRIFYAQw7gceM9xgADoHglhz3KAAPypPKVwFYEQw7k8efQiQQBiHUQQz3GAAAwiCGEdpXQVgBDD +uBx49CIAAM9xgAAMqlKFZB0EEEgVgBDDuBx49CEDAFqlz3GAAFSq9CEAAI4dxBBbpZAdxBCSHQQQ +lB0EEO4JwAHPcIAARB4DgAiA67gG8k4VgBCA4CgNAgZYFYAQgOAF8iIID/8D8DYNAAAIdSEHb/Kp +cOB48cDhxc9xoADEJxURA4YE2BMZGIAb2BYZGIAD2s9woADUC1Gg4HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HhRoOS7yiWiFSv0UhEAhuC4yiXhFSXyUSBAgAXyUSPAgAPyEt0d8AHZz3CA +AKIcz3KAAFTDtBIDACCoBoMB4AajH4LuuAbyz3CAAIwGIKAI8O+4BvLPcIAAkAYgoBXdiiAEDE4N +L/oA2X0Gb/KpcOB4wdgUGgIwz3GAAEQeA4EYiAHbz3KAAFTDhuAXgsIjwQAM4BggwABmGgQAZhIA +AQPgBCCADwAA/P+duJ+47HMAowXI7HMAowOBGIg3gobgAdjCIAEAGCEBAOxwIKDgfuB48cCeDU/y +z3CAAFTDMoBRIUCCEvLPcYAARB4jgUgQggA0gUR5USGAgEjayiKBDwAAkAAD8A7aAN/PcaAAqCAn +gawQDQBZYbFxwiVFEMol5hKweH4Nr/oK2c9wgADIMwCQz3agAMQnUSAAgQXyjCUDkgP3AN0a8MoK +IAIA2M9wqwCg//qglg+v/QDYGRYAloDgBPIC2BAeGJDPcYAAVD0bgWq9uGAU3RuhGRYAloDgCPRR +IQDGzAuhBcogYQBJBW/yqXDgeOHFz3GAACzEQYnA2xQawjDPc4AARB5jgxJqR+AEIIAPAAD8/2mD +KrvAuxe7x3MADgAAZXjscwCjBcjscwCjSiTAcwDbqCDAAfAhzQDscKCgAeOA4gDZzPfPcIAALMPw +IEMA7HBgoAHhUHG49wDZz3CgANQLLaALzAHgEHgEIIAPAAD/v4+4CxocMM9xoACIJB6h4H/BxeB4 +8cBCDE/yz3eAAFTDQJcIdkhxhiH8A0IpBQFEIggDjBcBEUIoiBBA2M91oADQDwojQIAQHRiQyiNi +AKwXABBAK4YFz3OAACzELyQIAB2zOBMHAUAsBAQFJwABDB0YkGGLArtI4xAd2JBmFwMRUSKAgnlh +MHlmH0QQBfQOl1MgwIAQ8s9wgABEHgOACYBRIACAPdjAKOIFyiChB8AoIQYK8EAoABGgcM9ygACE +HQhiF7gD4QQhgQ8AAPz/BSCAASV4nbifuAwdGJALzAHgEHgEIIAPAAD/v4+4CxocMA4dmJMgFQCW +z3CAAEQeA4AIgOu4D/Lkvg307gkgBslwz3CAAGjEoNnE2j3bFgvgARe7nQNP8uB48cDhxc9wgACg +BwCQz3GAAPyxqNoB3YAgRAsQeD4Pr/qpc4DgyiHBD8oiwQfKIIEPAAC1FMojgQ8AAMwAyiQhAFwB +ofPKJQEB5ghAAM9wgACMLVUDb/K0oPHAdgggAgDYXgxP9m4Oz/2CDg/7Pg2v/QDY/9nPcKsAoP85 +oDig0cDgfuB48cDhxc9xgABEHvAhAgBKJEAAwxIBBg94MiKCDwAAHwMEIYMPAAYAAIDjAdvAewQh +jQ9AAAAA13VAAAAAwiQCAZYIb/vAud0CT/LgePHAYgpP8toOoAIIdc9xgABUwx+BsLgfoc9wnwC4 +/1gYwAjPc58AuP9YGwAIz3KgANAPEILPdqAAxCcWo89wgACQJAaAFqMZFgCWgOAA2QXyAtgQHhiQ +GBpYgJYJgAHGCCAEAdiA5QXyhg8AAAXwZg8AAHoKj/oZFgCWgOAE8gLYEB4YkEkCT/LxwM9wnwC4 +/1gYAAjPcJ8AuP9YGEAIz3CAACQTYg1v+iPZagxP/9HA4H7gePHASg/gAQHYANnPcIAA2DwuoOYP +7/QZ2NHA4H7xwIYJT/KiwYt2Egnv+clwCiUAkBn0z3CAAFTDz3GgAAwkO4FXgDByyiUiEiCG8LkE +8gLZjBhEAAQlgl8AAHDHP4BFeT+ggOXaAwIAAMDpuNryz3WAACAqAIWKIQgA5JDPdqAAxCcTHliQ +z3GAAFTDP4E6d/G5hiH8I0PyQSkBIcO5z3KAAIBuNnoggkB5CHUZFgCWgOAF8gLYEB4YkM9wAAD/ +fxMeGJAb2BYeGJAD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoM9w +gABYlxmAgOD4CcIBmuU6AwIAz3CAAAjmRgsgBADdKwMAAG4Lb/8qcBpwAIXuCi//KnGOCy//CHeI +58wn4pXKJcETLfJMIACgC/IKCyAAgcAKJQCQHPQeDO//AcAY8APZz3CgANQLMaDgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeDGgAN2a5wf0z3CAAAjmygoABIDlqgICAKIMAALPcIAAVMMf +gO64CPIB2c9wgACMBiCgCfDvuAfyAdnPcIAAkAYgoBEWAJYA3VEggIBBwBj0Zg+v+YHACiUAkBL0 +BBQFMFElgIAM9AohwA/rcgrYjLiKI8cKJQZv84okgw+A5UICAgAE2BMeGJAb2BYeGJDPcIAAWJcZ +gIDg4AjCASMCAADguMvyz3aAAFTDEoaGIDoAjCAEggQMBQLPcaAADCQ8gReGInhkuBB4ih4EEEQi +AFOI4Av0H4bxuAX0USVA0QHYBfQA2APwkgpP/4DgnB4AEDDyBg0P/wolAJDj9A3MUSDAgRHyH4ZR +IICBDfIvIIcKjCAChgf0z3GAAFTDH4GYuB+hqgkgAIHACiUAkMn0z3aAAFTDH4bwuBXyqBYBENTY +hgqgAclygOAH8g4PQAUL8IIOD/+08M9xgADQPR6BAeAeoQHfz3CAAKIctBYBEOCoBoEB4AahH4bz +uHQKAvoPhoDggAkC+h+G7rgI8gHZz3CAAIwGIKAJ8O+4B/IB2c9wgACQBiCgANjPcaAAyBwHoTDY +CqE2Cu//AcCKIIQNrg3v+QHBH4b4uBLyENgMGhwwz3CAAAjmAgkABA3IACCBD4AAjMIfhuCpuLgf +pgCWhiD8AIwgAoAc9CILj/mA4Bj0A9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB4MaAAlt4Jb/w0lkXwUSDAgEHAFd8E9Ol1IfAI2M92oADEJxMeGJA+CM//lOAIdRXyAtg8 +HgCQIRYBls9wgADwqSGgERYAllEggIDm9UINr/mBwAolAJDg85XlHfTPcKAAkCMegAQUBDBRIICA +yiHBD8oiwQfKIGECzyAhA8ojgQ8AAOQE7ANh88olIQDGDq//iHAIdalwwQUv8qLA4HjxwGYND/Kh +wQh2ANhAwACm3gyv+YtwCiUAkIr0z3CgAAQlIoAAhgQhgQ//AF//BSECAECmUyGCAFMggwBleofi +VfRRIoDTz3CAAFTDH4A98vq4XvQEIL6PAB4AAAP0AIYK8FEigMD/9VEiAMAAhgTyhbgAps9ygABU +wz+C+bkH8oi4i7iOuACmQvD7uRPyTyABAom5jbmLuY65IKYeggQggA8CAAAAUiBABCq4JXgApi7w +/LnFIIIPAAAABeP1hSAcAACmJPD1uACGIvKGIBwAhSAYAACmUSIAwf/1USLAwACGFvKGuACmEvBT +IQMAUyACAAUjvoDKJeEVCvKGIX8PhiB/DwUhPoDKJaEUz3CAAODDDIjEuEAoAQYAhiV4USCAxACm +IAtiBcogIgipcKUEL/KhwPHA4cUA3QXYC7hWDG/6qXGCDg/zz3CAAFTDH4DruA30hOXaAAYAUSBA +xWn0USAAxVX0AeVU8ADZnLnPcKAA0BswoAHZz3CkAJhAPKAF2AjwUgkAAPIKYAUF2AHY6gpABYTl +bgAGAAQgvs8wAAAAAeXKJSIQUSMAwBr0USBAxQXyUSGAwyXyUSAAxxv0USDAxeXzUSGAw+Pzz3Cq +AAAEAYCGID8Lg+AA3dT1E/D2CAAAz3GAANg8DoEB4A6hCfAA2Zy5z3CgANAbMKDaCAAAANnPcKQA +mEA8oBHwAN1RIwDABfRmCmAFAdic8boIAADPcYAA2DwOgQHgDqGtAw/y4HjhxQzMRCA+ikry47gq +8oDYDBocMA3Mz3GAAFw8z3Kg/pQBz3OfALj/67gA3QbyHYEB4B2hSHAH8BWBAeAVoUAiAA0Wow3M +USDAgAb0z3CgACwgr6ANzIYgggINGhwwIPBRIECBHPKKIAQADBocMM9xgABcPBSBAeAUoQ3MANlG +IIACDRocMM9woAAsIC+gz3Gg/vQBz3CfALj/NqDgf8HF8cAuCOABAdhSDS/yA9gmCAAAHgjgAQHY +0cDgfvHA5g/P/0IOz//2Ck/60cDgfuB48cBiCg/yz3GgAPxEBYEA3ry4BaHqD6AByXAD3Q4NL/Kp +cM9xoAAwEKKhz3CAAJAkoqGdAi/yxqDxwM9woAC0DzeAz3CAAJAkBoAQcQT0tg/P/wTwmg/P/9HA +4H7xwPoJL/IA2QfYGnE6cADeQCgAIRR4x3CAAPyxFSCNAwCVjCACjQDfhPaMIIWCyfb/2AC1iiAR +AwoJ7/n/2QGdvOAF9owgP4FH9uG1iiARA/II7/kA2QHmz36M5rQHy/9CIUAggOBAIEEgogft/y95 +6QEP8vHAkgkP8gDdz3CAADSphg1v+bSogOAT8gjegOXMJaKQzCUikcwlYpHcC2L+yiBCA2G+gOYB +5TP3HPCKJAFxz3GAAATCqCBAAQQZUAPgeADZSiQAcs9ygACwwaggAAMWIkAAYpDPcIAAfMI0eAHh +YLDPdYAARB7PdoAAeKlAJQAXJG7KDSACBtpAJQAVQCaBEroNIAIG2kAlABdAJgEUrg0gAgbaLBWA +EITgD/SKIA8KHgjv+YohWwU8FYAQmg8v/i2FWgzP+A6FUSBAgQnyiiCHDv4Pr/mKIdsIBgqAA1oN +T/mA4IQOwv/PcQAA///PcIAATOMsoHYPb/kroAEBD/LxwJIIL/IU2c91gAA8ItjcLg+v8wIlABPP +cIAAiCQiD6/zFNnPdoAARB5AJgAVAKbA3AIlABMBpgDdqXCpcRIPb/IG2gHYqXEGD2/yBtoAhkok +gHCpcQKmA6aoIMAFFSZCEGCCiiDGDQ2zAIIB4amgAIKpoACCwBhYAwCCwRhYAwCCwhhYAxvZz3CA +AKw6cQAv8iyo8cDmD8/xGnA6cUh2Rgpv+ZpzCHUEJoAfAAYAAIDgSiJAIMIigiQEJo4fQAAAANd2 +QAAAAEojQCDCI8Ikz3CAAKwGxIgA31YNoAHpcIDlDfQD3i8hBwQvIkcEyXBKc8oN7/oKJMAEyXAy +Du/6inGA5QT0rgqAAwTw3gqAA89wgACQJASAUSCAgBDyz3CAAGQ4AICA4Ar0OdhaCm/5i7iB4AT0 +zgzP/w3wANmeuc9woAD8RCGg4HjhoOIMoAEA2H0Hz/HgePHANg/P8aPBCHbPcIAARB7wIIMDiicL +Fi2T/WM8eihwhiHxD8K6R7kkelBxhiD+A0S4D/IKIcAP63KD2I24iiPSDUokAABhBS/zCiUAAUiD +f2c7ulMiAoBAr02TwLpBrQvy95OGJ/8ZQ7/nrXeThiP+B0W7aK2A4hvyz3KAAHg4FSIDAACLNXoC +rQGLz3GqqqqqA60CiwStA4sFrQOKBq3WDa/5iiDQD6IIYAECjYtwqXFKD+/xDNoAwAHBTgsv8wLC +i3CpcTYP7/EM2gDAAcEiCy/zAsLPcYAAUAcAoUYP4ATJcLkG7/GjwOB48cBODu/xV9jPdYAARB4j +hc9ygABUB3eR4LsAogPyX9gAouK7A/KFuACiUSNAgATyh7gAooomCxbLYdlhANqA48oggQDPcqUA +6A8GogCJz3GgAKQwgOABgc8g4gDQIOEAAaF6D8/1A4XPcaAAyBxPgALgSKFqCuAByGADhUoIb/0O +gDkGz/HgeOHFz3CAAEQeA4ApgEQhg4AA2iX0kOKMAAYAACKND4AAhB0AjaC4AK2AFYAQoLiAHQIQ +QBWAEKC4QB0CEBCNoLgQrZAVgBCguJAdAhBQFYAQoLhQHQIQAeLe8ZDiRAAGAAAijQ+AAIQdAI2A +uACtgBWAEIC4gB0CEEAVgBCAuEAdAhAQjYC4EK2QFYAQgLiQHQIQUBWAEIC4UB0CEAHi3/HmuRHy +z3KAAIQdCIqAuAiqiBKAAIC4iBoCAEgSgACAuBHwgOMR9M9ygACEHQiKoLgIqogSgACguIgaAgBI +EoAAoLhIGgIAUSEAgADYHfJKJAB04HioIAAG4rgV8gAggw+AAIQdIBOBAIC5IBtCAKATgQCAuaAb +QgBgE4EAgLlgG0IAAeAc8EokAHTgeKggAAbiuBXyACCDD4AAhB0gE4IAoLogG4IAoBOCAKC6oBuC +AGATggCgumAbggAB4OB/wcXxwF4Mz/GB4M92gABEHhpwA/QAhgLwAYbEEAAGFSYNFEwgAKAB3yW4 +UyAFACCFwH9AIQAGxBEBBlEhQIEM9AohwA/rcoHYjbiKI40PhQIv8wokAASKIgsNWWAAFgNAWGBg +oAAWAEABoQAWgEAIqQAWgEAJqc9wgACQJAWAgeAH9ECFABYAQQ+yA/AAFgBBABaAQAqpABaAQAup +ABaAQAypABaAQAAWAEEHsQAWAEEIsQAWAEAmDg/9AIXIEAAGhiB/jkr08CbAE8gQAAaGIH+OQvSK +INMBzgqv+YohDgcKcJoKb/cB2ZIKb/wvIAcE7g3gBApwz3CAAIwhLJAelhBxBfLOC0/4EnAm9ACF +xBABBgpwJbnAuRINL/QA2qYLgAGA4An0C8gFIIAPAAAAPAsaGDDeC4ABgOAI9AvIBSCADwAAANQL +GhgwC8iQuAsaGDBaD8/xqggP92kDz/HxwOIK7/EA2QokAKChwcohYQAV8s9wgACQJBAQBQBRJYCA +DfQKIcAP63J+2I24iiMIDUUBL/MKJAAFz3WAAEQeFSUOFQCGFSVSECQQFQAAEgEgIBAWACgQFwFB +LU8hKYEaEBgBwL8luVMhEwACDmAEDdmKIIkAinE6CO/76XL2Du/9inAAhgmAJbhTIBAAinCOCW/3 +ANlMJACg4AjB/0wgAKBT8oDnDvIKIcAP63J/2I24iiOJB0okAAC9AC/zuHOKIFAPggmv+TeV7gwA +An4IL/cB2ACGCIBRIACABvIsFYAQhOAD2AP0BdhMIwCgOnAa9OYPz/pyD8/6iiCQBUoJr/mKIckO +z3CAAGw4A4iA4Ar0iiAQDjIJr/mKIQkPzgzgAADYLBWAEITgDPSKII8OFgmv+YohCgCA2GYNL/sB +2UojACBQ8BoPb/+KcP4P7/YA2CwVgBCE4Av0iiCPDuoIr/mKIcoDgNg2DS/7ANlMJACgD/RiD8/6 +Wg/P+vIJz/UuDg/5gODECsL1ANgf8KYKz/UeDg/5gOAE9HYIQAUW8M9wgACMIQiIieDMIOKB7/XP +cIAAVGQAgATZvdoe20DAi3AiCWABGLsB2HpwAIYIgFEgAIAG8iwVgBCE4ATYA/QG2DpwAIYogBSQ +BCGPjwAGAAAFfwby9rnCJ6IQwCehECpwinEmC6/06XKA4MogQgQUC6L0yiHCA0wjAKAE8oYOz/am +8OYMD/kE2c9wgACQJE4LL/0koCCGyBEABoYgf45D9NoPL/yKcDYL4ASKcAASACDIEAAGhiB/jkL0 +z3CAAIwhLJAelRBxBfIKCU/4knA29IpwCnFWCi/0Adp/2RG5z3CgALAfNKC+Dg/52giAAYDgCfQL +yAUggA8AAAA8CxoYMBIJgAGA4Aj0C8gFIIAPAAAA1AsaGDALyJC4CxoYMI4Mz/EM8CQZQAUghiAZ +gAUghigZxAUghhoZBAYuDA/5gOAL8kwkAKAA2AX0Yg4ABQPwPgwABQHdygpgAqlwz3CAAGQcGgpg +AqCoTCRAoBX0z3CAAIwhCIiJ4Mwg4oEF9EwgAKAH9IjgB/SGDA/5gOAD8v4Jj/NGCc/4ag3P9gTK +kODMIIKPAACzAA/yCiHAD+tyARIENpLYjbiKI40GGQbv8golAAW+CSACANi5B6/xocDgePHAkg+P +8QDdz3aAAEQeCN8AhsQQAQZBKUABUSAAgA7ygOXMJaKQzCUikcwlYpEG9IDlzCWikA30USFAgQz0 +gOXMJaKQzCUikcwlYpEE9L4JL/6pcGG/gOe4B+3/AeXPd4AAcCHPdYAAmKlAJwAVJG3eC+ABBtpA +JwATQCWBEtIL4AEG2kAnABVAJQEUwgvgAQbazhYAFs9xoADEJ89ygABQIXcZGIAYkngZGIDQFgAW +gBkYgBySgRkYgA8RAIaDuA8ZGIA1B4/x8cDCDo/xz3aAAOAGAIZKIAAggODQDcICz3CAAJASA4CA +4ADfD/LPcp8AuP8dos9xgAB8HASBAeCzuLW4uLgEoRaiDMzguD/yz3OgAMgfsBMAAM9ygABEHkOC +AuBGEgEBYbkIIEEAPqMQ2A6jAdgVGxiAz3CAAAjiAxoYMM9wgADQ4n4KoAMEGhgwz3GgAPxEBYFK +IUAgvLgFoQzMhiD/gc9wgACgBgCAwiFBJIDgIAtC/QQgjk8wAAAAz3WgAMgfCfDtuBf0z3WgAMgf +CnYKIQAkz3CAAKQcEIDPcYAAVD3soQCADqHX8M91oADIHwDf0fCyCs/+z3GgAPxEBYG8uAWhz3CA +ANg8DoCMIAKNiPc+DW/0GdhWC2ABANgMzM91oADIH++41PME2AYaGDAfhYDgiiAMAMoggg8AAAAC +DqUD2BW4Eh0YkACGgOBkDMICz3CAAHwcAIAEIL6PAAAPOADZBvLPcJ8AuP89oLUFj/EehVEgQMUM +EgE3MfIGyIYg8Y8t9M91gABkO4gVABYEIb6PAAAAUAHgiB0YEATyBNgMGhww/gnv/gDfz3CgAPxE +JYC8uSWgaxUAFowgAo1iAAYAz3CAAHwcAIDruAXyz3CfALj//aBKIEAgDMzkuCv05rhH9IYg/4XL +8lEjAMC18lEgQMWx9AzMz3WAAFw8USDAgOQBAQCA2AwaHDANzOu4pfIdhQHgHaVKIAAgovAyDG/0 +GdhGCmAB6XCNAiAASiBAIA3MUyBAgFjzBMgDEgE2AxoYMLoIoAMEGlgwz3CgAPxEJYDPdaAAyB8A +37y5JaDPcIAAoAYAgIDgFfJy8JIIoAMA389woAD8RCWAvLkloM9wgACgBgCAgODPdaAAyB9g9AbI +BCC+jwOA6FNq9VEgQMVo9ZIID/pMIQCgG/LfhaAVABAJJgAQ5ODN9s9wgACwwQCAUSBAgAXy/qWi +CSABENjk5sf3QBUBFjB5rgzv+RDYiiAIAKAdwBMOpR+FgOAE9IogBAAOpV4IgAEv2JW4Eh0YkM9w +AQDA/BUdGJCODUADz3GAADA2AIGH4Nbyz3CgADguBYAEIIAPwAAAANdwwAAAAMXy9dgFuM9ynwC4 +/xqiB9gbomnYGLgZogHYuvB+CE/9n/EA367wFYUB4BWlz3CAAKw6EYhRIACAIApiA8ogYgCA5gXy +HIUB4BylDMznuADfWvINzAQghA8AAAAYDCSAjwAAAAgz8r4Kz/YNzFEgwIA/8s9xoAAsIAWBJoEK +4DBwYAANAAMSATYC2AwaHDBQ2I4P7/2YEQEAMg9AA89woAD8RCWAz3WgAMgfvLkloEDxiiAEAAwa +HDAUhYDmAeAUpcXzG4UB4BulwfFmDS/4CnBRIACABvII2Ju4BhoYMFLwz3WgAMgfBNgGGhgwOfED +yKAQAADwuOlwGfKKDk/3ANiWuBXw6LgX8n4L7/uKIAQAEgrv9ul1A8igEAAA8LipcAXyYg5P9wDY +lbhuC4AEBNjV8em4z3GgAMgfCPJGDm/3AdgA2JC48/EEIL6PAAAAUAryUSMAwAjyiiAEAA6hBNgG +GhgwDczvuAzyQBECBs9xgADMwy+RMHKE96+4DRocMM91oADIH9sFz/8A2IHgBPQH2AChz3CAAOAG +AICA4OAIwgLPcYAAVD0MgU2BCCIAAA2hz3CAAKQcEIBPgWCADoECewDKCCLCAIjgT6EK9APZz3Cg +AEAtMKBFBO//ABrCMwHgPQTv/wAaAjDgePHAngmv8YogiwHPd4AANAjaCG/5IIcA2M92gAD4B89x +gAC4OAihC6YBhoYgeY8W8s91gAAwCACFIIcYuBC5BXmFIRgApghv+YogiwAG2AClANjrAiAAAKcD +2EIK7/gLuIDgIIcH9M91gAAwCACFGLjm8YDhygICAAIWhBADFoUQz3WAAFDFQCWREIQsHwAvcAAg +gQ+AAFjMFSFBAVuROpFAJRIaQCUQFQAlBhAEFgYBgOK4YAOAIfIwcsohxQ/KIIUPAAB7J8ojhQ8A +AIcBPgAlAMoixQeA4A/yEHLKIcYPyiCGDwAAfCfKI4YPAACJAcoixgdL99BxTvcKIcAP63LPcAAA +fSeKI0YDSiRAAA0Hr/K4c4DgEPIQccohxg/KIIYPAAB+J8ojhg8AAI8ByiLGB233DIaA4CP0B4aA +4CH0AdjPcaAAsB8Zoc9wgACkHAiAAICELB8ACaYAIYB/gAAczDDg9CBBAYIPL/mKIEsGiiBLBnYP +L/kphgHYB6YCjs9xgABEHoQoHwAAJUIeI4FFgkihQ44AIYF/gAAczDDh9CGCAM9xgABEHiOBz3CA +AEQeVLHPcYAARB4AJUIeI4FGgid1SaEDgCWVLbAC2Ahxmg7v8QDa2g1AAAKOI46EKB8AACGAf4AA +HMww4DAgQi70IEEAUyIAALoPb/8A2wKOz3WAADAIhCgfADAiQS7eDi/5iiATAQKOhCgfAC9xMCJA +IAAhgg+AAEzKI44CuTR55g4gAVlhiiBLB7IOL/kghYYJ4AEB2OYLAAEijkOOhCkfAAAhgH+AAJzL +FSCEADAUAABRIACADfIB2M9zoACwHxmjz3CAAKQcCIAAgAKmz3CAAEQeAoCEKR8AwhADBoG7whjY +ADAUAADAuFIgAAAbeFV4ACCCD4AAWMw04jQiQQ4KuTIhQC4opiCFUSBAgACHGLkQuAV5EfLPcIAA +LMUgEIAAgeAJ9IUhFAASDi/5iiCLAAXYB/CKuQIOL/mKIIsABNgApQDYAKcCjiOOhCgfAAAhgH+A +ABzMMOD0IEEA3g0v+YogCwTPcIAApBwwgCCByg0v+YogCwQMhoDgyiAhAHwPIfTKIQEAAdjBBk/x +CiHAD+tyz3AAAH8niiMHCEokgADJBK/yuHPxwK4PT/cA2NHA4H7xwKIJ7/jhxYDgNPLPcYAANKkU +iYHgLvI3iYDhCfLPcIAAzLMBgBBxAdjAeBTwz3KAALidC4qGIP+MHvLPcYAAzLNhgaSKsXMA2AXy +IIowcwL0AdiB4M9xgAAkCAChCvTPcIAA5FsmgCOBIIHCDoACTQZP8fYOT/fu8eB48cDODU/xz3GA +APwHAIHPdYAAMAjPdoAANAiAuAChz3GAALg4BYEB4AWhIIUAhhi5ELgFeYUhGADSDC/5iiCLAAbY +AKUA2PUFb/EApvHAfg1P8c9wgAD6BwCIz3OAAPsHQIsB3phwhCgfAC9wACCND4AAnMsw5fAlgRDA +uYHhACCBD4AAHMww4fQhhQDHcIAAUMXAfgHi44hPevFyPgAqAECr9CGPALB3GfSA5hfy8CWPEFEn +AJAT9AHi44hPevFyTPb0IY8AsHcI9IDmBvLwJY8QUScAkPLzQKsDiBByegAKAPAlgBCELB8AwLhS +IAAAG3hVeAAggQ+AAFjMNOE0IUAOz3GAABgICrgAocdwAAAAGKoNj/jPdYAAMAgghc92gAA0CECG +GLmA4BC6RXkN8oUhDADWCy/5iiCLAAPYAKUA2ACmC/CFIRgAwgsv+YogiwAG2PXxrg7P/9kEb/EA +2PHAagxv8YogSwGlwc92gAA0CJoLL/kghs93gAD4BwQXBRAB3ah0hCSGkAAWBBAg8kwkAIC4CSL3 +yiAiAc91gAAwCACFIIYYuEApAgQFeoi6iiCLAFYLL/lFeQHYAKUA3c9wgADlX6CoqXeM8EwkAIBD +9IogywA2Cy/5ANnPcIAAMAgghgCAELkYuAV5hSFIABoLL/mKIIsAz3CAADAIAtmgpiCgz3WAAOVf +AI2A4Ar0z3CgACwgEIDHcAAAAH0NpzQXBxDPcAAAYH1AwATYQcAB3kLGANhDwETAyXAQ2QTaANuY +c7hzegov99hzANgArcl3yXVG8EwkQIAi9APYXgyv+Au4gOAa9M9wgADlX6Co3ggv9wTYAIbPd4AA +MAgghxC4GLkFeYi5ggov+YogiwCgpwDYAKYIdQHfJPBMJICAJ/QA2M9xgADlXwCpTyWAAAGnz3GA +ALg4BoHPd4AAMAgB4AahAIdALAEEGLgFeYi5Ogov+YogiwCgpwDdoKapd4DlRAlBAOlwSQNv8aXA +CiHAD+tyz3AAAHonQQGv8oojhQLgePHAxgpv8YogiwKlwc92gAA0CPYJL/kghs93gAD4BwGHCHSE +JAaQABYFECTyTCVAgAT0KgoP8wrwhbgBp89xgAC4OAqBAeAKoc91gAAwCACFABYFEBi4QC0BBAV5 +iLmqCS/5iiCLAAHYAKUA2ACmRPBMJQCAPPTPcIAAMAgAgEAtAgRAKAEGCLhFeQV5iiCLAHYJL/mA +uQGHAdpAps91oAAsILCFhiA5jwDZz3MAAGB9BNhAw0HAQsIE8hDYQ8AD8EPBRMEA2AbZBNoIc5hw +uHAAJYcfAAAAfeIIL/fYcIogCwUmCS/5iiHOAwXwTCVAgAX0Adg5Am/xpcBMJYCAz3WAADAIABUE +EAz0hbgBp89xgAC4OAqBAeAKoUAsAAad8QohwA/rcs9wAACEJwkAr/KKI04I8cCKCU/xz3WAAPgH +AYXPdoAANAgvLwEQiiALAbYIL/kghiGFUCEMAKe8UCQMkgfysgkv804nwBcb8Ch0hCQGkBryogkv +804nwBcBhYYgBgABpYogSwB+CC/5ANnPdYAAACoAhYDgBfJAeADYAKV9AW/xAdgAhoDgvPRRIQCA +z3eAAEQelfQCjSONhCgfAC9wACCCD4AAnMsw4vAiQwAB2gK5ZnpUecdxgABYzDThEGEKuAilx3AA +AAAYygmv+EohQCDDFwEWGnDPcIAABMI0eBGIgOBiC6/4wiFCJEwgAKDMISKgzCAigFPyIo3PcIAA +TMyEKR8AL3JTYM9wgADYBgCQEHMjhxr0x3KAAFDFZYIIgVMjBABTIA8AkHcO9EOKgeLEI4EPAAYA +AMQggQ8ABgAAzCMBgATyANgD8AHYSYEMpc91gAAwCGCFUSJAgUCGGLsQumV6D/KA4A30GImD4An0 +TyJBAm4P7/iKIIsAAtgJ8E8iAQKJuVoP7/iKIIsAA9gApQDYIg4gAACmcfFMIACgCPSKIAsIOg/v ++NnZafHPcYAAVD0egQHgHqFh8Y4K4AAB2ACHxBAABiW4aggv9MC4Hg7v8xTYdgjv+gTY6ghAACKN +z3CAAAzNhCkfADAgQQ7yDu/4iiDKD/4Ij/lB8QohwA/rcs9wAAB5J/3bSiSAAAEGb/K4c/HAig8v +8YogSwLPcYAANAi6Du/4IIHPcIAANAgAgIDgtvT+Du/yAd6KIBMCng7v+IohjAQC2G4Or/bJcc9w +gACsBgCAz3WAAEQeJoDPd4AA+AeeEQAGprieGRgAI4VIgTSRUyIAAC4PL//Jc3oNAAAC2ADZ1g2v +8QLaIoXCEQAGobjCGRgAAIXEEAAGJbjAuP4P7/MA2SOFiiDLAy4O7/g0kc9woACwH9mgz3CAAKQc +CIAAgAKnTglgBALY6gigAclwz3CAAJAkBIBRIICAEfLPcIAAZDgAgIDgC/SmCa/4iiDMDoHgBfQW +DA//DPAA2J64z3GgAPxEAaHgeADYAaEqDMAAVgmP/QOFKYDPdYAAMAhAhVEhQIHPcYAANAgggRi6 +ELlFeRDyTIeA4gz0GIiD4Ar0hSEcAJIN7/iKIIsAB9gd8EKPz3CAAGDFhCofADAgQA6A4AbyAYeG +IDmPCfKIuWoN7/iKIIsAwKUI8Iu5Wg3v+IogiwAI2AClANnPcIAANAggoG0GL/EocAohwA/rcs9w +AACDJ4ojTQZKJIAAWQRv8rhz4HjxwOINL/GKIMsCz3WAADQIEg3v+CCFz3aAAPgHAo7Pd4AAUMWE +KB8AQCcAFDAgQQ7yDO/4iiDLAgQWBBCIdIQkBpAAhRLyz3aAADAIIIYQuBi5BXmIuc4M7/iKIIsA +AdgApgDYAKVb8IDgQPSIdAKOhCSGkIQoHwAndw7yEBcFEAohwA/rcs9wAACNJ8UDb/KKIw8A1guv +9gSHCHHPcIAAAFwqDkACz3GAALg4DIEB4Ayhfgvv8xTY1g2v+gTYz3CAADAIAIBAhUAoAQYQugi4 +RXkFeYogiwBKDO/4RSHBAAPYAKUB2Bvwg+Ab9M9ygAC4OC2Cz3eAADAIELgB4S2iIIcYuQV5iLka +DO/4iiCLAAHYAKcA2AClB6YxBQ/xCiHAD+tyz3AAAIUniiPPBkokgAAhA2/yuHPxwKYMD/HPdYAA ++Acijc9wgABcxUIgkAKEKR8AMCBADs4LL/UphQh3AYXPdoAANAiGIHmPDPQA2GINb/iMuIDgBvIM +hYDgzCdhkCX0AIaB4OwLwfIMhYDgzCdhkAf0z3GAALg4AIEB4AChIIbPdYAAMAgAhRC5GLgFeYUh +GABuC+/4iiCLAAbYAKUA39UBIADgpgKNI42EKB8AACGAf4AAnMsw4PAgQABRIACAOfIIhcoKL/Ui +hYwgEIBmACkAIIaB4XwLwfIA2M9zgAC4OAijA4WA4BHyJIUA2gDfDydPEAYgwIMvLwEQA6VOJ4EX +AeL19SSlSKMAhs91gAAwCCCFELgYuQV5hSEUAeIK7/iKIIsABdgApQTYAKYA36LwIIaF4XQBDQAy +JkFwgABoYkAngHI0eAB4Ao0A34QoHwAyIEAuUSBAgMojwgMF9EYOgANghgKNI42EKB8AACGAf4AA +nMsw4PAgQAAQu89xgAAwCCCB4LhAKQIGZXoM8oC4A6XkpQi5JXqKIIsARSJBAYDwAdjPcaAAsB8Z +oc9wgACkHCiAAIECpQCBTyIBAoq5CqU6Cu/4iiCLAAXYz3GAADAIAKHgpgHfTvADhYDgJPTPd4AA +MAgAhxi4kLiSuE8gAQKKuQoK7/iKIIsABdgApwDYAKbPcKAAsB8B3/mgz3CAAKQcCIAAgAqliiBL +BN4J7/gA2Sjw4LgH9C8oAQBOIIEHJKVmDm/7BIXPcIAAMAgAgECGQCgBBhC6CLhFeQV5iiCLAKoJ +7/iAuQHfz3CAAPBd6gugAOCmiiBLBJIJ7/gkhakCL/HpcM9xgAC4OAeBAeAHoc9wgAAwCCCAQCkA +BpG4CLkFeYogiwBFIUEBXgnP+AXYRPEKIcAP63JP2Ae4iiNJCkokgAB1AG/yuHPPcKAATC4LgNO4 ++QOgAwbZ8cDhxc91oAA4LkeFz3CAALQ4ANlAoCelTgmgBCDYB4WKuAelC8gEIIAP////AwsaGDAL +yI+4CxoYMAvIkLgLGhgwJQIP8eB48cCqD8//z3CAALQ4IIDPcKAAOC4noGIMT/3RwOB+4HjxwIIJ +D/EmDG/4Ad2A4M92gAD4BwGGwH2GIHkPQiAAgMogYgAIuAV9ANhOCm/4jLiA4AHYwHgQuAUgfoMu +8guGgeAV9AKOI46EKB8AACGAf4AAnMs1eCyAgLksoM9wgAC4OIDZKaAA2Aumz3aAADAIAIbPdYAA +NAgghRi4ELkFeYUhGABCCO/4iiCLAAbYAKYA2BUCIAAApUKOY46EKh8AL3AAII0PgACcy3V9LIVT +IQSAMvTrhoHnLvRPJAIAUiICAFt6dXqAucdygABYzCylNOIQYs9xgAC4OIDdqaEKuADZCKbPcKAA +LCADgCumz3WAADQIAqYAhc92gAAwCCCGELgYuQV5irm+D6/4iiCLAATYv/HPd4AAUMWEKh8AQCcA +EzAgQA6mD+/0KYaA4EAnkBEe8gyGgOAa9CiGz3AAAAEUCCEAAJkgCgCCD+/0IoaA4Afy9guAALIK +j/+H8c9xgAC4OACBAeAAoYHxz3WAADQIAIWA4BHyhOB78gohwA/rcs9wAACCJ4ojSw5KJIAAZQYv +8rhzCIYyD+/0IoaA4BXyIIXPdoAAMAgAhhC5GLgFeYUhFAESD6/4iiCLAAXYAKYE2AClANhu8AKO +hCgfAC9wGWcjkYDhH2c48iOOx3CAAJzLMODwIEAAUSAAgC7yApcKuNYO7/QqhoDgU/LPcoAAZDs5 +ghiCIngkgkWCQnkZYQKOhCgfADQgQC4QcRb3pg6v+IogiwTPcIAApBwwgCCBlg6v+IogiwTPcYAA +uDgBgQHgAaEd8CCFz3aAADAIAIYQuRi4BXmFIRQBag6v+IogiwAF2ACmBNgApRvwCIbmDe/0IoYK +IgCAEAAPAM4KgACKCY//EPDPc4AA5FsGgwOAIIBocNoPIAJZYTYNr/MU2AHYQQfP8PHA3g7v8Iog +iwnPd4AA/AcODq/4IIfPdYAANAgAhYHgUA6B8s9wgAAwCECAIIWKIIsAGLoQueoNr/hFeQDez3CA +ADAIwKDPcIAAAFwGDyACwKXPcIAA5Fv6DgACz3CAAPsHwKjAp89wgAAUCMCgz3CAALg4yaAC2Mlx +Jg1v8QhyxQbP8PHA4cWC4M91gABsOJhwEfJMJACBIPIAFYUQCiHAD+tyz3AAAKsapQQv8oojxgmK +IJAMag2v+IohxgGuCgAAAY0gjRBxBPQCjQCtHPAiCGAAAK0S8IogEA1CDa/4iiHGBiYIAACKIJAK +Mg2v+IohRggB2AStz3GAAKw6EYmluBGpUQbP8PHA1g3v8ADYz3KAAKw6rBIEAM9zgABsOEAsgQA0 +eT1iWWE0gbOFMHUB3wf2AaviqwIhTgMG8OGrAqsCJU4Q6XCK5gCrRvbPcIAAmBzIYAPwCNileddx +AAD//wOrBvJAJEAAwrisGgAA3gkAAH4PIAAAi80Fz/DgeAokAIDxwBDyz3CAAGw4BRCFAAohwA/r +cs9wAACjGrEDL/Li24ogEAx2DK/449nPcIAARB4DgNYJ4AANkNHA4H7xwCINz/DPdYAAbDgEFYYQ +TCaAgY72CiHAD+tyz3AAAKEavduKJIMPZQMv8golgAEvJQcABa1ALoAAFXgVIEABz3GAAAg5BmGH +5sohwQ/KIsEHyiCBDwAAohrKI4EPAADEACwDIfLKJIEBhuYW8kwlwIAM9M9wgAAcXBoNAALPcIAA +OFwODQACJI3PcIAAgDnwIEEAYHnJcPUEz/DxwIYMz/DPcIAA5AcAgIfgyiWBHwAAECfKJYIfAACI +E89xgAAcXAaBA4DAgM9wgACkHASAAIDVuB5mKHAuDSACQiaBEs9wgAA4XCINIAK5ZqEEz/DxwOHF +guDPdYAAbDiYcA3yBRWFEAohwA/rcs9wAACkGn0CL/Lz24ogkAxGC6/49NkBjRIOIAAArYog0Aoy +C6/4+tkC2GEE7/AEreB48cDhxYLgz3WAAGw4mHAO8gUVhRAKIcAP63LPcAAApRoxAi/yiiOEDYog +kAz2Cq/4iiHEDQKNwg0gAACtiiBQC+IKr/iKIUQPBNgRBO/wBK3PcIAArDqsEAEAz3IAAP//Ark0 +eThgU6Dgf1Sg8cBuC8/wz3eAAJDDz3WAAGw4ABWFEM92gABkO0wlQIAUF5EQ0BaQEM32BBWEEAoh +wA/rcs9wAACoGq0BL/KKIwsEiiAVDnIKr/iocYwhAaheAAYADZcs4AIgQARAjQ97gOJ3FgEWCvQE +IYEP/wAA/yV7dx7YEBHwgeIK9AQhjQ//AP8AQCsBAqV5BfAweRC7ZXl3HlgQz3GAAKw6rBEDAEzh +AnACu3R7VXt5YQChIQPP8OB48cDPcoAAbDgoioHhGfQpijBwF/KB4AmqDfTPcIAAHFwWCwACz3CA +ADhcDgsAAtHA4H4EioPgBfQKDs//+fH58fHA4cWB4M91gABsOJhwJvJMJMCADfIFFYUQCiHAD+ty +z3AAAKYazQAv8oojhAmKINAMkgmv+IohBATPcYAArDoRiYW4EamKIJALegmv+IohBAUF2AStFvCK +IFAMZgmv+IohRAaqDs//iiAQC1YJr/iKIUQHA9gErQmNgOCEDcH/eQLP8PHA4cUKJACAz3WAAGw4 +EfJMJACBKvIFFYUQCiHAD+tyz3AAAKcaSQAv8oojBQuKIBAMDgmv+IohxQTPcYAArDoRiaW4EamK +IJAK9giv+IohxQUB2AStA9gDrQGNtgsgAACtDg7P/xTwiiAQDdIIr/iKIcUIFg7P/7ILz/+KIJAK +vgiv+IohBQoB2ASt6QHP8PHA4cUUuCV4z3WgADguBqUF8IYKb/iKIFwIBoX/uPvzxQHP8M9xoAC8 +LRV5WYExgc9zoADALzByCvSgEwGGESEAgAHYwiABAAS4BvBAIgAEInjDuOB+4HjxwBYJz/DPcaD+ +xAYA389wnwC4/zagz3agAMAvpR7Ykw/dCL0F8BoKb/iKIJwCoxYAlqR4jCAQgPfzFB7Ykwbw/glv ++Iog3ASjFgCWCyBAg/j1LQHP8OB4lODKIgUAhfcIcoAiwgTPcaAAaCzwIYEAANvPcqAAxCxnomii +DLiduJ+4JXgGouB+8cCSCM/wCHZyD+//KHXJcBIP7/+pcekAz/DgeOHFMNsA3c9woADIHGmgA9rP +caAAzBchGZiATqGnoGqg4H/BxfHATgjv8ADZz3CgAAwkWIDPdYAAVMOtcEEqhgeGIPcPmBWDECm4 +dnnAccdxgAD43hV5ABGEAM9wgACwEyCAQCzOANV+0GHZYUQgj4BTII4ABCKADwAgAADMICKABvSA +58wgIYAA2AP0AdjPd6AAxCdAKwUGhiP9D0wkAIRSI8MBtAAqAEW7gObMICKAVPLPcIAAkG/wIIcD +QC6GA4LmBSbGAQUlgAEFe0Ef2JAm9B+FENqauB+lCNhPHQIQz3CgAMgcSaAHgc9yoADwFwaiBoEG +ogWBBqIEgQaiANgKoooVABFouBB4ih0EEACVhiD/jCn0AdgdoifwThWAEIDgI/SKFQARTKVkuBB4 +ih0EEIPmBNlPHUIQDPQrFwGWZLgQeIodBBAM2C2lTx0CED4M7/eIcAnwBSNDAUEf2JAfhbO4H6V1 +B4/w4HgQ2s9xoADIHEmhAdvPcaAA8BdqoaQQAgDruibyAtpdoc9zgACI1USDRqFDg0ahQoNGoUGD +RqFwEAABHOBTIMCABPRAIwAIBPBAIwAMQIBToUxoQIJTofgQAoJTofwQAIAToQ/wXJCGIv+MA/R9 +oUiARqFHgEahRoBGoQWABqHgfuHFL4DPc6AA8BfPcqAA/Bcoo0AQAQEqsjGAKKNIEAEBKrIzgCij +UBABASqyPJCGIfMPjCEMgAf0NoAoo1wQAQEqsnAQAQG8kAjhqLK9kKiyVBANAaiyYBANAaiyuYCn +o7qAp6O7gKejchAAAThgEHgIss9woAD0ByegAtnPcKAAyBwnoOB/wcXxwEYOj/euCc/30cDgfuB4 +8cDqDY/wAN5RIACAz3KAAAAGz3WAAJQcAIUB4CTyANmXuTGigeAApQn0AdnPcKAAyBwxoNIM4AMo +cM9xgABGBM9woADsJyagAIVCIECAAKUF9M9woADIHNGgiiARAAvZAdoi8NGigeAApQr0AdnPcKAA +yBwxoJIM4AMocM9xgABHBM9woADsJyagAIVCIECAAKUG9M9woADIHNGgiiARAArZANqKDG/4GnIA +hQHggeDPd6AA7CcApQn0AdnPcKAAyBwxoEIM4AMocEAoQCEQeBC4gbiHuIy4BqcAhUIgQIAApQb0 +z3CgAMgc0aBhBY/w8cD+DI/wz3WAAFTDF4WY4M92gACY3wbyWBWAEIDgBfIahVuFA/AchV2Fz3GA +ACw4IIFRIQCACfQyhQQhgQ8AAAAQJXgles9x/v//PyR4AaYA3+KmRHktpg7Yqggv+A6mgOAI8s9x +gAB8IWoKoAAB2M9xgABYHl4KoAAA2BeFlOAG9AHYAa4xHgIQBfDhrjEewhPVBI/w4HihwfHAVgyP +8DpxCHZIdwIL7/kA3YHgyiBCIwv0z3CAAFAcAJCB4AHYwHhAKBADyXCGIPwAjCAChSP0z3CAAFTD +mBCAAOe4yiAiAAr0ArgWeM9xgAAQ1wBhLbjAuM9xgAB4ByCBUSGAgM9xgADMwxR5BPIg2q2RCvCY +2quRBvDPcIAAkMOzkA7aAZdAJQEVEHFG9qJ4SCAAABB4A/AA2FpwANgqcalzbg0gBJhwCiEAoAT0 +UgzAAzpwTCEAoADYTfQFIIAjDXEAsQ1xABmEBCOHDXAgoCiXDXAgsIoghQDKCm/4yXGMJgKVFPKM +JgORHvKMJgOVI/IKIcAP63IT2Iy4z3MAAJQKiiSDD80B7/G4c89wgABUw7QQAQAPgQHgD6HWCSAA +6XAT8M9wgABUw7QQAQAOgQHgDqEJ8M9wgABUw7QQAQANgQHgDaHPcaAA9AcA2AShAdgacM9xoADI +H/gRAgBCdQIlgBBIIAAAX4EQeFBwPgAFAEOHz3CAAPCpTCEAoEKgoNgPoQDYH6HPcIAAVMMckGK4 +QnAfoQLYFRkYgAXyUSBAxiDYAvKA2A6hjCYDlQf0z3CAAFTDHJAI8IwmA5EJ9M9wgADMww+Q8grv ++ADZag9P/gzMhiD5jxH0jCYDkcogIQDPIKEDCfJMIgCgANjPICIDyiAhAQwaHDAKcAjctwKP8OB4 +8cBeCo/wocEId/4I7/kA3YHgCvTPcIAAUBwAkAHdgeDAfQy9z3CAAITiBIDPcoAALKoEIIAPAAAA +EEUgQQNAwSDAw7gcePQiAwDPcKAAyB+gEAIAcLtQcwDeDvd+EAKGo7p+GJiA8Hhwe7YPIAQU2vi4 +BPLJcDjwA9jPcaAA9AcFoYUlAxkNcKCwDXDAsIoi/w8NcECgz3IAAP//DXBAsAPIz3OAABDXz3KA +AEQeEIgCuBZ4AGMtuMC48CIAAKCADXCgoAPIEIgCuBZ4AGMtuMC48CIAAEKQDXBAsMShrgnAAwHY +4QGv8KHA4HjxwGoJj/AacM9xgABkqgCJgOAW8sGBooHPcIAAeAcCEREB4IDPcYAAVD0LgTS/AeAL +oTbwZgov+IogCwjPcaAAxCcREQCGUSCAgQDf9PNkEQKGZBnYgwLYExkYgIDiLyiBAE4ggQcT8s9w +gADEnTZ4wIChgM9wgABEnvQgUQDPcIAAZJ7wIE8ACvDPcYAAVD0Kgel16XY6dwHgCqEEEAEgDXAg +oAgQASENcCCwz3GAAAzEAIGA4AfyQoENcECgANgAoc9wgABEHgOACIDruMogggPKIUIDyiLCA6gI +YgTKI0IEUyHAIM9xgAB4ByCBFL9RIYCADLjleAnygrgNcQChDXDAoA1woKAf8A1xAKFKJAB04Hio +IMACRCaBEA+5UyYAECV4DXEAoSK+SiQAdOB4qCDAAkQlgRAPuVMlABAleA1xAKEivYUAj/DgePHA +KgiP8Ah2KHUocEhxYgggAGhygeDKIIEDEAghAMohQQN1AI/w4HgiuQbw7HJgogTgYbmB4WCAOvfP +cKAA1AttoAPZz3CgAEQdNaDgfuB4QSmBgAryLyRJcOB4qCCAAQQQAgTscUCh4H7gePHAtg9P8KHB +CHfPdqAArC8ZhgQggA9wAAAA13AgAAAAAdjAeC8mB/AodRpyE/SKIMkDyg4v+IohzAU5hr4OL/iK +IIkDiiCJA7IOL/ipcQDYLfALzAAcRDNPIMEDAhxEMAHgEHgEIIAPAAD/v4+4CxocMM9woADUCziA +QiEBCEghAQBAJwASEHF4CMUDB+cEJ48fAAD8/wUnABSduJ+47HEAoQDB7HAgoAHYcQdv8KHA8cDh +xa4Nr/kA3YHgyiBCAwn0z3CAAFAcAJCB4AHYwHgMuIUgAwED2s9xoAD0B0WhDXIAsgPIANtdkA1w +QLADyFGADXBAoAPISBACAQ1wQLBkoTEHT/DgePHAtg5P8M91gADcluAVABAA3oDg0PdELj4XACFA +cxzZxdoe22oO7/8Yu+AVABAB5hB2s/cA2O0Gb/DgHQAQ4HjxwHYOT/AhgAomAJAQicO4yiHBD8oi +wQfKIKEGyiOBDwAAqgDPICEDPPKA4cohwQ/KIsEHyiDhBsojgQ8AAKsAzyAhAy7yArjPcYAAENcW +eABhz3GAADQHLbjAuAypI4YgkYYh/ACMIQKADPTPcYAARB7wIQEAvxEABoG4vxkYAAGGooCA5Qjy +AYWA4ATyAIWA4A30CiHAD+tyHNiMuLnbSiRAAD0Er/G4c1EggMEG9DYPAACA4A3yiiDOAvYML/jA +2QCFgNkooAGFQHge8AGGIJAUyBBxyiHND8oizQcd2MojjQ8AAMYAuAft/88gLQOiDK/3yXAKDSAA +AYXPcIAANAdeCaADDIjZBU/wz3CAANhd8QbP/+B48cBaDU/wo8EId4ogiwOODC/46XHPcIAA+wcg +iAEcwjPPcIAA+gcAiGDBhCgfAAAhgH+AABzMLuD0IEAAANoDHAIwAdgCHIIwz3agAMgfE6bPcYAA +pBwMgQCAhNpCwAiBAIAM2R7bQcCLcM4M7/8Yu89zgAAwCM91gAC4OAsSATdelYTYYIMaCqADmHdS +CcADpBYAEBOlLQVv8KPAz3CAABCpKIDPcJ8AuP8A2jagCNnscCCgA9nPcKAAFAQloAHI7HEAoc9w +oADUC02g4H7gePHAigxP8KXBCHcodoogmQa6Cy/4WtkA2c9woAAsILCAQMYG2EHAQsFDwUTBAdge +2elyANuYc7hzACWHHwAAAH1aDKAA2HOtBG/wpcDxwEIMT/Ckwc91gAD6B0CNz3CAAPsHIIiEKh8A +ACGAf4AAHMww4PQgQAAA3g95YMBOCy/4iiBLAyCNz3CAAGTFz3WAALg4hCkfADAgQA7AuAEcAjAJ +hcmlAhwCMAiFyKUB2QMcAjDPcKAAsB85oM9xgACkHAyBAICD2kLACIEAgB7bQcDPcIAAZDs9gAmA +OGBDwItwENmGC+//GLsAFIQwCxIBN89zgAAwCF6Vg9jWCKADYIP5A2/wpMDgePHA4cWlwc9wgAD6 +ByCIz3CAAPsHQIiEKR8AACGBf4AAHMww4fQhggAA3U95Y8LPcoAAZMUwIkAOwLgNHAIwhgov+Iog +CwPPcaAAsB8B2Bmhz3KAAKQcLIIggR7bQcEogiCBQMEkgiCBDhxCM0TAi3BCwQ8cQjMU2YLa5grv +/xi7z3KAALg4DBSEMAsSATfPc4AAMAhekoLYLgigA2CDXQNv8KXACMiHuAgaGDAJyJu4CRoYMArI +ChoYMAvIh7gLGhgwDMgMGhgw4H7geM9xgADclwCBgbjgfwCh4HjPcYAAdCs2iVEhwIEO8s9xgAAk +KiCB4bnKIWIABfRRIQCABPIA2SCo4H7geM9xgADcl+B/A7HgeM9xgAAsV+B/AKHgeOHFgODPcqAA +rC8A2Sv0z3CgALQPPKAYgvq4ZPQVglEgAIBg8hqCUSAAgFzyz3OAAJQcQIMBaoHgBvQB3c9woADI +HLGgz3WAAEdoz3CgAOwnpqCA4kCjRvTPcKAAyBwxoEDwGIL6uDn0FYJRIACANfIaglEgAIAx8s9z +gACUHECDAWqB4Ab0Ad3PcKAAyByxoM91gABGaM9woADsJ6agQKPgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB44HiA4gX0z3CgAMgcMaAB2c9woAC0Dzyg4H/Bxc9ygACMOhV6 +IKK1AC/4iiCSDuB48cCYcAohwA/rcgolwAfPcAAAohnFB2/xVtvgeM9ygABoOhV6IKKFAC/4iiDS +DuB48cCYcAohwA/rcgolwAfPcAAAoxmVB2/xXtvgeM9ygACgOhV6IKJVAC/4iiASD+B48cCYcAoh +wA/rcgolwAfPcAAApBllB2/xZtvgePHApBABAPm5BPQSD0/3B/Ag2c9woADIHCmgA9nPcKAAEBQl +oNHA4H7hxQO4NXjPcYAAHGACYUokAHQA2aggwAIWIkAAoYBggCnYErgB4XV4oKDgf8HF4HjPcIAA +rAYAgKHBJoCeEQAGhrieGRgA4H+hwOB44H7geM9xgAA0B+B/BKHgePHAaghP8M9ygABEHiOCOImE +4Q70CiHAD+tyiiCMDoojBgJKJAAAtQZv8bhzIILEEQEGUSFAgUfyz3aAAOhaIIZCIQGAyiFiAIDh +PfSA4A/0CiHAD+tyiiDMDoojhgNKJAAAeQZv8QolAAEmhiOBz3eAAKQcoIEkhyCB1bk9Zc9xgAB4 +3yWBYbgFKT4AJ3WKIIkLGg/v96lxBIcggIogiQsKD+/3NrnJcKoIoAFCJYESz3CAAARbACWBHwAA +iBOWCIABEQBP8OB48cBKDI/3gOAf9CYMj/eA4Avyz3CAAIwhLJDPcIAARB4ekBBxD/SiC4/3gOAN +8s9wgAAkKgCA67gH8n4Lj/eA4AP0AdgC8ADY0cDgfvHAWguP94DgHPJyC4/3gOAU8s9wgACMISyQ +z3CAAEQeHpAQcQ70z3CAACQqAIAEIL6PAAA4EAb0TgiP94DgBPQB2APwANjRwOB+4HjxwA4PD/DP +dYAAgAfMjQ2Nwr7CuBZ+z366Ci/8DdgGuIG4EL7FeM9xoADsJwahBIXPcaUA6A8GoQWFB6E9Bw/w +8cDKDg/wz3alAOgPJoanhs9wgACABwDfJKCloHYKL/wN2Aa4gbjPcaAA7CcGoeamRSXNH6em/QYP +8OB4z3GAAHAhz3CAANgGAJBHiRByFfTPcIAA2gYAkEGJEHIN9M9wgADcBgCIJokQcQf0z3CAAOgp +AIAC8ADY4H7geOHFn+HhxgDdGPKe4QP2gOFD9gDYFPCf4R/eSvZOIfwH4HioIIABDyWNE2G+ESBA +gAPypXgC8KZ4AKIB2MHG4H/BxeB48cAKDi/wKNieDg/4z3WAAAgqQIUIdgQghA8AAPD/ANhgekEs +AQFAhQHYRCYEE2B6QSyBAECFAthgelMmQRBqDi/4ANhAhQh3QSgBAgPYYHrAuUCFQS9BEgTYYHrA +uc9xAAC80c9wgAAEKiCgz3ABAMT3AKXPcf7KAgDSDO/3iiCSD/EFD/DgePHAQg+P+9oKj/vPcQAA +5NHPcIAADCp2CG/7IKDPcQEA9PfPcIAAECogoM9x/soBAJIM7/eKIJIP0cDgfvHASg0v8FDY2g0P ++M91gAAYKkCFCHYA2GB6UyZBEECFAdjJcWB6hiH9D89xAAAI0s9wgAAUKiCgz3ABACT4AKXPcf7K +AwBCDO/3iiCSD2kFD/DgePHA4cViDy/5B9i2D2/7CHWeD8//dgjP+04ML/mpcE0FD/DgeOB+4Hjg +fuB48cDGDC/wUyABAIHhSidAAMInwgEId4Yn/hNEvwhzhiPxD0e7CdnPcoAArDosqjCqLqovqkQg +gQM8eRlxLaoEIIQPAAAADEIsjQK4dbOqBCCEDwAAADBCLA4D2HbUqgDYsRoCAFMhfoDKIcEPyiCB +DwAAkRrKI4EPAABOAsoiwQcf8kwnAIAu8gQgwBAQc8ohwg/KIIIPAACSGsojgg8AAFgCyiLCBw30 +5Htwdw/yCiHAD+tyz3AAAJMaiiNJBookww91Am/xSiUAAIDnPfQKIcAP63LPcAAAlBqKI4kG8fFM +JsCABPZMJgCAEPYKIcAP63LPcAAAlRqKIwkIiiTDDzUCb/EKJYABDCWAgQT2TCUAgA72CiHAD+ty +z3AAAJYaiiPJCBECb/GKJMMPUyEAAIYhfw88eThgD3iwcEL2E6rQcEP2FKpGCuABANjhAw/w4H7g +eOB+4HgA2Q8hAQAveRNpJXjPcYAArDrgfwyp4HjxwFILD/BRIACAGnAH8oogUQCGCu/3CnGD8EQg +gCMceJhwz3WAAKw6Da0EIIEvAAAADEq5M61TIECAyiHBD8oiwQfKIIEPAACpGsojgQ8AAPoBdAFh +8colAQTPdoAAbDgHjoDgzCGhgAPyANgK8M9wgABEHgOACYBRIECB9/MB2A95CK4SCu/3iiCQDweO +geANFYQQUyQBABj0gOHKIcEPyiLBB8oggQ8AAKoayiOBDwAABAIQAWHxyiUBBADYAa4A3QHf4q4R +8IDhAN0B2Afyoa4A3QHfqXD28VEkQID68wGuoq4Id4YMb/8AriiOgeEEjg70gOAV9IogkAqaCe/3 +iiHIB+SuA9gDrgvwgOAJ8oogUAqCCe/3iiHICaSumQIP8OB44H7gePHALgov8ADbocEEuM9ygACY +3xR4HWKQ3hpiAYIYvsiliiYEEs9y/v//P8mlBHqA4UDCyiXBAAvyCIEEIIAPAAAAMEIgBYDKJWIA +TCUAgCbyz3CAAPTBABAEAMiBBCSGDwAHAAAEJo4fAAAAMCy+Yb5BLgYGQCaAExEmgIMPIgIAQMJC +9AohwA/rcj7YjLiKI4oODQBv8bh2z3CAAGw4B4iB4M8ioQMv8s9zgAD0wc92gABUw5oWgRADiwsh +AIAh8kwWgRAA21MhTgBEIQ8DDyODA0K/AN4PJs4ThiH/AwQmDpAA30S5BHsPJ08Q5HjKJgEQgOPK +I4EDDrtlegPwAYMFekDCz3CAAPTBIICLcoYh/gMkuUApgwMgggQhjg8BAADACybAkBby13YAAABA +zCaCnwAAAIDMJoKfAQAAAAT0AYAD8AKArrmvubC5JXgAogAUBDAEJIGPAQAAwAr0CiHAD+tyRtiM +uDUHL/GKI4sJCIUuuUApAgYEHQARRXgIpYogBQYJpc9wgACowwSIgOCKIAUOyiCBDwAA2AEJpalw +ANoB3hoOb/zJc8Ct6QAv8KHA4HgKJQCA8cAT8kwlgIAT8kwlwIAU8gohwA/rcoogzQ6KIwQFyQYv +8Yokgw9WDAAA0cDgfuYLAAD98X4LAAD58eB48cA2CA/wCHXPcIAAODQJgIDgCvTPcIAAyDMpgAzg +8CBOAAPwAd6KIP8PAKXPcYAARB4AgcQQAAZRIECBM/SyCw/6AKVOCW/4qXCA4Mol4hGk9JIMT/eA +4AX0AIWMIP+PDPTPcIAADCoggGB5AdiB4AXdyiUiEZLwz3GAALgTIZHPc4AA6AdAgzzhOmIhg2Ti +FOFZYTBwAd3CJU4Ts33BvXzwA4EYiITgE/QOCw/6AKXPcYAAuBMhkc9zgADoB0CDPOE6YiGDZOIU +4Vlh5PHPcIAA6FoAgM93gAAIm0IgEIAeCi/6yiBiIAClAYcQdsb3Xg9v9slxCHbPcIAApBwEgM9x +gAB43wCAJYFJbtW4BSm+ACdwargghUggAAAwcMogRgBF9wClSiBAIM9xgAC4E2GRz3GAAOgHQIEh +gTzjAd16YmTiFOE6YlBwwiVOE7N9UyVNkCLyTCBAoCD0z3CAAOhaTg8AAc9wgAAEW0IPAAHPcIAA +rFs6DwABz3CAAMhbLg8AASGHMHbJcMb3FgggAAHZBPA+Do//AQfv76lw4HjxwJoO7++4cQonAJDK +IcEPyiLBB8oggQ8AAEsDyiPhDsokIQDkBCHxyiUBAc9wgAA8WwaAA4AAgM9xgACkHCSBSW/Agc9x +gAB431MmTRUlgR1lBSm+ACd1AiUCEIwiF4c2vv5mSffPcIAACJsBgAUofgAndR5mTCUAgBLyTCVA +gD7yTCWAgGvyCiHAD+tyiiCNDpDbdQQv8Yokgw8CCk/3gOAU8s9wgACMISyQz3CAAEQeHpAQcQry +z3CAADxbAiWBHwAAAAwH8M9wgAA8W0IlARWyDgABz3CAAFhbACWBHwAAiBOeDgABiiBJDO4Mr/dC +JQEViiBJDMlxZPCiCU/3gODPcYAArFsR8s9wgACMIUyQz3CAAEQeHpAQcgfyKHACJYEfAAAADATw +KHBCJYEXUg4AAc9wgADIWwAlgR8AAIgTQg4AAYogCQ2SDK/3QiWBF4ogCQ3JcTTwRglP94Dgz3GA +AHRbEvLPcIAAjCFMkM9wgABEHh6QEHII8ihwAiWBHwAAAAwF8ChwQiUBFfYNIAHJvs9wgACQWwAl +gR8AAIgT4g0AAc9wgAAIm8OgiiDJDSoMr/dCJQEViiDJDelxGgyP989xgAB43waBgbg1Be/vBqHx +wMYMz+/Pd4AAIFsuDSAB6XDPcIAAFDQggM9wgAAYNACAz3agACwgCSEBAM9wgADowAiACSENADCG +6XByDSABuWEwhoogCgC+C6/3uWEwhoogCgyyC6/3uWHVBM/v4HjxwOHFz3CAAAibAYCB4Ab0z3CA +AMgzB4DPcYAAdFsggUIhAYDKIWIAgOEd9M9xgABYwSyBgOEX9M9xgABAwT4Mb/YjgQh1iiDJA14L +r/ex2YogyQNSC6/3qXGpcHIN7/8C2X0Ez+/gePHAAgzP789wgACkHASAoIDPcIAA6FoAgEIgAIDK +IGIAgOA2vQb0z3CAAARbRgwAAc9wgABAwSGIz3CAADxbgOHPdoAACJsM9CCAQiEBgMohYgCA4QTy +IIaA4S70FgwAAc9wgABYWw4MAAEBhqYLb/YIcSGGD3gwcMz3CiHAD+tyiiANA9fbSiQAAOUBL/G4 +c89xgAB0WyCBQiEBgMohYgCA4QfyHWUjhsm9MHUE8roM7/8A2bkDz++A4uHF4cZW8kAiwwMku8O6 +AvAA2o/ilgANADMmgnCAAIxiQCcNc1R9IH3AiAEZkgMB4AEQggQBGZIAARCCBAEZkgABEIIEARmS +AAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIA +ARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAEIjQ4Cz9cHG4H/BxeB4gOJY +YFlhC/IvJIlw4HioIMAB/xCCgv8ZioDgfoDi4cXhxiTyY2oiu8G6A/AA2oPiGfczJoJwgACIYkAn +DXNUfSB9wIAEGZADBOAEEAIEBBmQAAQQAgQEGZAABBACBAQZkABCI0OA5PXBxuB/wcXgePHAIgrv +71MhQgBOIg0Bz3KgABQEyYIA2w4mgh8AAAAGUHHKIcYPyiLGB8oghg8AAMYiyiOGDwAAmwLKJGYA +UAAm8colxgCA4cokTXDKIs0A6CAtAk5gz3GgADgEAeLIqYHlDvKC5Qjyg+UO9M9woAA4BGioz3Cg +ADgEaKjPcKAAOARoqAkCz+/xwHYJz+8acHpx+nK6cwoiACEKJEAhyHUKIcAhCiFAg89ygAAe18oh +YgASaRZ4CGJMIwCgBLgId4Yn/hMlf8ohzA/KIswHyiCMDwAAwSHKI4wPAADuAMokbACsB+zwyiXM +BFEggMEP8s9wgAAQqYDZKKAMwIDgBPJAeJPwXgxP/4/wTCBAoIogSgPKIIIPAACOAkYIr/cA2c92 +gAAMXgGGANmuD2/xONoAhhzZIKABhhjZILDPcYAARB4VIVYDABYBIFOBDcHwqM93gACICCgYQARF +eaS5IaAA2TMYQgDpcSKgCiFAgzEYwgQyGMIENBjEBcohYgBWCG/2DOCA5Qb0z3GAAHipBfDPcYAA +mKkjps9wAABIEQCxTCBAoBjYAqYE8oogBQIAsQzAgOAE9M9wAQBw9AGnABYAILkQAAZRIACAF/JB +hhrYALICpgCRh7gAsQDYC7EBgkwlAKCtuAGiB/LPcIAAzDUEgDMaAgBMIgCgFPIhhgGBmLgBoQOB +n7gDoc9xgABkBwAWACAAGQQFQIABgEGhAqGOCW//yXAhAM/v4HjxwNIPj++6cHpx+nIKIgAhCiFA +Ich1CiTAIQogQIPPcoAAHtfKIGIACHECuBZ4CGJMIwCgBLiGIP4DBSBQAMohzA/KIswHyiCMDwAA +vyHKI4wPAACWAMokbAAIBuzwyiXMBAzAgOAN9AohwA/rcofYBriX20okAADpBe/wuHNRIIDBCvLP +cIAAEKmA2SigDMBAeGrwz3aAAAxeAYYA3+lxCg5v8TjaAIYc2SCgAYYQ2SCwz3GAAEQeFSFWAwAW +ASAzgTMYwgPPd4AAkAgQGAIEpLmNuZm5IaDpcSKgCiFAgygYAAUxGMIEMhjCBDQYxAXKIWIAsg4v +9gzggOUF9M9xgAB4qQTwz3GAAJipI6ak2ACxTCVAoBDYAqYF9KTYjLgAsc9wgABEHhmQjriPuAGx +TCIAoAzAAacT8iGGAYGYuAGhA4GfuAOhz3GAAGQHABYAIAAZRARAgAGAQaECoSYIb//JcLUGj+/x +wOHFz3WAAHQ+AI2MIMOPD/TPcoAAzFoGggOAIIDHcQ8AAKBOD+AASHD+2ACt1QaP7+B48cBaDq/v +ANjPdYAA0NlKJAB0gN6oIAAFCHEB4E8gwgEWJUMQR6uKIggAArk2ecdxgAAQ10ChANpCscapwNh/ +HQIQz3WAAOAHwK3PcIAAkNaA2b4Mb/EocsGtz3CAAKgh2ajPcIAAmB5dBq/vxajgePHA5g2P76HB +CHcqDG/yGNjPdoAAZDsghgGGgOHMICGAK/TPcKAA1AsYgADdQiAACIDgyiBMA4wgCIVI98EWABYB +4MEeGBAd8J3YABwEMAvM6XECHAQwAeAQeAQggA8AAP+/j7gLGhwwAMAe2loIIAAYuqGmBfCA4APy +YbgBphoIAAAA2IoNr/hAJgESwQWv76HA4HjxwM9wgABEHgOAGIiF4A/0z3ABAKCGUg2AAsILD/UI +cc9wgABUXBYOwADRwOB+4HjxwBoNj+8IdxpxOnLPdoAARB4Dhs91gABkOxSQELj2D+/2AqWA4Mog +IiDPcIAAdAcAgIDgCvSFIQgkTyFAJ5+47HEAoexw4KADhgiAUSAAgATyAoWBuAKlz3CAANwGAIiA +4AX0AoWDuAKlz3CgACwgEIDPc4AA7DxyHRgQSiTAcADYqCAABs9xgAC0BiCJgOEM2soiIQBEKL4D +z3GAACjnJ3IzIYIAQCMBAxlhAeBAqUAlDhKiDm/yyXBMIACgB/IihQDYgLkipQPwiiD/D89xgAB0 +ByCBZxUPFoDhaBUEFhP0ANsH8OxyIKIEeQQeUBAB44wjgoAghrf3z3KgANQLLaIkeACmZx3YE2gd +GBEA2GkEr+/cHQAQJQbv/wDY4HjxwM9ygADgBgKCJYiA4QHYBvII2Q4Kr/crogjwz3GAALwk+g9v +8ACh0cDgfvHA1guv79hwPgggAADdyWiA5pb2+HCpdzImgAOw4Ir2ueAI9kINT/Mybzh4BX0B50In +RwBMJwCAYb4w9wEEr++pcOB4CHID8AHgIIiA4f714H9CePHAhguP7891oAD8RB2FOYUuC+ACAN4A +2J64AaXgeMGlxaXRA4/v4HjPcaqqu7vPcJ8AuP82oDagNqA2oM9xoADIOw6BiLgOoWkgQAD+8eB4 +8cDPcIAARB4DgBiIhOAO9AohwA/rcoogDA6KI4UKSiQAAIEB7/C4c4ogCgtGCm/3iiFFC0oJb/ID +2M9wgADowAAQBABMJACAC/QKIcAP63KKIEwOiiMFDEkB7/C4c89wgABQHACQgeAB2MB4DLjXcAAA +ABAS9M9woAAsIBCAz3GAADg0AqEC2AOhz3EBAIRYGg4v/wHYCPCKIAoL1glv94ohhQ7RwOB+8cCG +Co/vz3WAAFjBL4VKIAAggOHKIcEPyiLBB8oggQ8AAL4hyiOBDwAASADKJAEEyADh8MolwQDPcIAA +UhxAiM9wgAAQqWB5SKA8HQAUighv8gLYlQKP7/HANgqP7woL4AAIdYDgz3GgAMgfRYUN8m4RDgYC +gGSFxHpFe24Z2AAihQChCvBuEQAGRHhuGRgAHNgYuBUZGIBhAo/vgOAB2cB5z3CAAHA+4H8goPHA +3gmP789wgAAEKiCAosFgeQTYgOCoAgEAz3GAAJQcAIEB4IHgAKEJ9AHZz3CgAMgcMaDCCOACKHAa +DK/4BdjPdYAAyDcOpc9xgACUHACBAeCB4AChCvQB2c9woADIHDGglgjgAihwA9iyCK/wqXEE2KoI +r/AibQXYogiv8CRtCtiaCK/wJm0P2JIIr/BAJQESNtiGCK/wQCWBEjfYfgiv8EAlARM42HIIr/BA +JYETz3enABRICIfPcacAmEcEpQ2Hz3KrAKD/BaUOh892oADsJwalHIEHpReHCKUWhwmlGIILpRmC +DKUagg2lz3ADAMYDBqbG2JC4BqbPcCwAAgEGps9wWQBCAQamiiCKAAamz3BAAIcNBqbPcNEAwg0G +ps9wwAAHDgamz3CAAJQcAIDPcoAAlBxCIECAAKIG9M9yoADIHADYEaIB2AinANgNpw6nz3BQAP8A +HKEA2BenFqf82c9wqwCg/zigfNk5oBqAz3GrAKD/gLgaoc9wKgACDgami3BCDCAAgcEAwc9wgACI +mTWlMqABwS+gz3AaAAIOBqaLcCIMIACBwQDBz3CAAIiZNqUzoAHBMKDPcCYAAg4GpotwAgwgAIHB +AMHPcIAAiJk0oDelAcExoM9wgACUHACAAeCB4M9xgACUHAChCfTPcaAAyBwB2BGh/g6AAgGVELiF +IIQABqYClRC4hSCFAAamA5UQuIUgiwAGpgSVELiFII8ABqYFlRC4BSCADwAAgg0GpgaVELgFIIAP +AADCDQamB5UQuAUggA8AAAIOBqbPcIAAlBwAgM9xgACUHEIgQIAAoQb0z3GgAMgcANgRoQSFK4UI +pwWFDacGhQ6nCIUXpwmFFqfPcKsAoP84oCyFOaAthTqgvg5v+A6Fz3CAAJQcz3GAAJQcAIBCIECA +AKEG9M9xoADIHADYEaGJB2/vosDgePHAHg9P734IAADPdoAAUF6KD+/1AIYIdQCGEHUK8n4Kr/qp +cG4J7/qgpuYLr/IR2A4PD/XPcKAALCAwgM9wgABwB0kHb+8goPHAug/v/6HBz3CAAHg+AIAE2WLa +HttAwItwlg7v/hi7ocDRwOB+4HjxwPYML/IW2ADY0cDgfuB48cCaDm/vB9gGCY/4CHfPcKAAtA/c +gCYML/8A2M9xoAAsIDCBtg0v94ogkQVKDM/6z3WAAHg+2g/v+gClQIXPcYAAPF4Aoc9xgADYPEqh +2g6v+wuh5gsv/894tg1v+Olwz3CAAGQcAIiB4CL0QIWKIEQEz3WAAFQcI4UaYjhgEHIB2MIgBQCA +4AvyiiARC04NL/cA2Z4JL/ME2ACFBfCGCS/zBNgChboPYAIDpVUGT+/xwM9wgABwPgCAgOAd9HYN +r/cW2IDgGfTPcIAABCoggGB5BNiA4BHyz3CAAPApYIDPcQIAhBIL2GB7BNoyDS/yFtjRwOB+z3GA +AEQeAIHEEAAGUSBAgQj0AYHEEAAGUSBAgQnyegqv8hPYdgqv8hHY6fHp8fHAz3CAAOAXAIDPcYAA +cAcbeNIMb/MggYDgCfIB2c9wgABkHGoP7/8gqNHA4H7gePHARg1P7wh3fdgNuM9xgAB438WBzg5v +78lxjCACgM9xgADkFwDdh/cdeIwgAoAB5Xz3AChCAwUqvgPPcoAA4BcWuAChgOfPcYAAdD4AGkAO +A/T/2ACpAImMIMOPYA6B/00FT+/xwM4MT+86cHpxSHdodgokACEA2s9xqwCg/1mhB9gaoVih2gug +AgHYGdnPcKcAmEc6oCIOL/se2M9ypwAUSB2CvoJsEhAAcBISAACnoKb3uMUggg8A/wAA0yDhBfe9 +xSWCHwD/AADTJeEV5g4v9YohEAAIdqlw2g4v9YohEAAIdUAoACLKDi/1iiEIAAh3QCoAIr4OL/WK +IQgA0XkZ4Sx5L3GxehniTHovcjB3ABmAIwAbQCOD9gDYBPBQcH32AdhhBG/vABwCIPHAHgxP7wh1 +KHYqC6ACCtgB2M9xpwCYRxqhGgugAgrYz3CmAJw/ZBAEAFEkAIDKIcEPyiLBB8oggQ8AAL8ZyiOB +DwAAuABEAqHwyiUhAM9wpwAUSCyAHYAApve4xSCCDwD/AADTIOEFIQRv7wCl4HjxwKYLT+/PcoAA +qKjEgowmw5898v/ZJKLAoIQuCBkAIY1/gABMpASNCiBALoDgAd8S9AKFz3GAAEAl8g4v8SCBCHHP +cIAApBwEgACA/grAAIDgBPQB2Bzwz3CAAMAkIo3AqCGoz3GgALAf+aHPcYAApBwwgSCBAN0hoBoJ +b/fpcAAggC+AAGymoKgA2H0DT+/xwM9wgACkHASAz3GfALj/AIDVuBahog3P/s9xoADQGxOBkLgc +oYoIL/8A2NHA4H7xwOHFCHXPcIAApBwEgCCAiiDJCxYKL/c2uYogyQsOCi/3IoUSCS/yBthKDo/7 +z3CAAEQeA4AYiITgDvQKIcAP63KKIAwPiiMGC0okAAANAa/wuHPPcYAAyDMJgYTgRPcB4Amhz3GA +AHjfBoFGIEABBqHPdYAA5AcAhYLgEPSKIEkFqgkv94ohRg8ghYogRg8GCG/5BNqSCW/5BNjFAk/v +8cDhxQh1z3CAAKQcBIAggIogCQx2CS/3NrmKIAkMbgkv9yKFz3GAADg0CYEB4Amhz3GAAHjfBoGC +uAahz3CAAGw4A4iA4Av0iiCQDj4JL/eKIccF2gxv/gLYiiDJAy4JL/eKIYcGagkv8gbYVQJP7/HA +4cUIdf/Zz3CAACSkIKhvIEMA5gmv8AHZz3CAAKQcJIAggfYIL/eKIMwNBoUDgEKFIICKIIgA4ggv +90J5FQJP7+B4iQZv8hHY4HjxwOHFCHXPcIAApBwEgCCAiiCJDLoIL/c2uYogiQyyCC/3IoXPcIAA +RB4DgBgQhABMJACBDPQKIcAP63KKIEwPiiNHCrkHb/BKJQAAz3CgACwgMIDPcIAAhFceCqAAliFB +D89wgABYwQyAgOAX8s9wgABQHACQgeAB2MB4DLjXcAAAABAL9IogyQNGCC/3iiEHDvYKIAAA2Cfw +fgyP+89wgADcFACAgOAd9M9xgAB43waBRiBAAQahz3WAAOQHAIWC4BH0iiBJBQYIL/eKIYgEIIWK +IIgEZg4v+QTa7g8v+QTYUgiP+SEBT+/gePHA4cUIdc9wgACkHASAIICKIMkMzg/v9ja5iiDJDMYP +7/Yihc9wgACsWwCAQiAAgMogYgCA4Aj0z3GAADg0CYEB4Amhz3GAAHjfBoGCuAah1g/v8QbYz3CA +AFjBDICA4Bfyz3CAALAwAoCA4BHyz3CAAFAcAJCB4AHYwHgMuNdwAAAAEAX00gogAADYEPDPcIAA +bDgDiIDgCvSKIJAORg/v9oohSA/iCm/+AthtAE/v4H7gePHA8g8P76LBgODKIYEPrd6t3gfyJoAj +gSCBAoACeRIP7/aKIE8Nz3WAAPQcAYWB4Az0iiBPDfoO7/aKIYYKANjuCS/2AaVT8AoKD/aB4AHY +wHgvJgeQD/KKIA8N0g7v9oohxg0B2B4P7/AGpYYNL/YC2OIJD/aC4A3yCiHAD+tyiiDfBYojBwCK +JMMP0QVv8LhzngkP9s9wgAB43wWQgOBKAAwACoUI2UHAC4WU2h7bQMCLcBYPr/4Yu4ogjw5yDu/2 +iiEHBIogjw5mDu/2K4WKII8OWg7v9iqFgOYF9KYOz/AB2AelANgLpXUHL++iwPHA4cUIdQaAA4BC +hSCAiiAPCy4O7/ZCec9wgAB43wWQgODF9lIMD/YD8A4MD/YOCCAAqXBBBw/v8cDKDi/viiAPCv4N +7/aKIYUIDgmv9gDegODPdYAA9BwN9Iogzw7iDe/2iiHFCQHYAaWqDu//yXA/8AvIBCCAD/7//wML +GhgwC8iHuAsaGDALyJC4CxoYMLYKT+/WDI/26g3v8QvYz3CAAKQcEIAkhQCAx3EAAAAUInjXcACA +AABI94ogDwqCDe/2iiEFD8Olmggv9sKlgOAwDCH2yiBhAM9wgAB43wWQgODKIIkPAABAAPwOifiB +Bg/v4HjxwOHFCHXPcIAApBwEgCCAiiAJDjYN7/Y2uYogCQ4uDe/2IoXPcIAARB4DgBiIhOAN9Aoh +wA/rcoogzA+KI8oFSiQAADUEb/C4c89woAAsIDCAz3CAAIRXmg5gAJYhQQ/PdYAA5AcAhYLgEfSK +IEkF2gzv9oohCggghYogCgg6Cy/5BNrCDC/5BNiKIMoBvgzv9oohyggB2c9wgACwMCKgz3GAAHjf +BoFGIEAB5giv+wah/gxP+c0FD+/gePHA4cUIdc9wgACkHASAIICKIEkOegzv9ja5iiBJDnIM7/Yi +hc9wgABEHgOAGIiE4A30CiHAD+tyiiAND4ojig9KJAAAeQNv8Lhzz3GAAHjfBNgGoYogygE2DO/2 +iiHLAc9wgACwMAHZIqDPcIAAbDgDiIDgCvSKIJAOFgzv9oohiwKyDy/+AthKDO/xBthGDO/xCNgx +BQ/vz3CAAIRXJQVAAOB48cAuDO/xE9jPcIAApBwEgCCAz3CAAIwSIKDRwOB+4HgIcgDYjQLv9RDZ +4HgIcgHYgQLv9SDZ4HgIcgLYdQLv9UDZ4HgIcYkC7/UA2AhxgQLv9QHYCHF5Au/1AtixBg/w8cDh +xQh1z3CAAKQcBIAggIogSQ12C+/2NrmKIEkNbgvv9iKFz3CAAEQeA4AYEIQATCQAgQz0CiHAD+ty +iiCMD4ojCQN1Am/wSiUAAM9woAAsIDCAz3CAAIRX2gxgAJYhQQ/PcYAAeN8GgUYgQAEGoc91gADk +BwCFguAR9IogSQUKC+/2iiGJByCFiiCJB2oJL/kE2vIKL/kE2FYLT/klBA/v4HjxwOHFCHXPcIAA +pBwEgCCAiiCJDdIK7/Y2uYogiQ3KCu/2IoXPcYAAeN8GgYK4BqHPcIAAbDgDiIDgC/SKIJAOpgrv +9oohCQ1CDi/+AtjeCu/xBtjJAw/v8cDSCu/xFNgiCE/w0cDgfvHAz3GAADAIiiALBnIK7/YggbIK +7/EU2A4Mr/gE2NHA4H7geKEGT/vxwM9wgABsOAOIgOAK9IogkA5GCu/2iiHNAeINL/4C2NHA4H51 +Au/xGNjgePHA/9nPcIAAdD5aDG//IKhmDY//0cDgfvHAzgoP7891gAC4JAAVEBCMIMOvCPKKIAwN ++gnv9oohhwIi8IDgE/TPcIAALKhoEAQACiHAD+tyz3AAAIcMiiPHAwEBb/AKJQAECHGCIQgAz3CA +AEykDiBAADYML++KIQgJGnDPcIAASKwTEAKGjCLDj//ZBfIcGBiEIKUL8BMYGIQgpQDZz3CAAOAG +JKB2D8/2oQIP7+B4AdnPcIAA4AYkoGEHz/bgePHALgoP789wgADgXAaAz3WAACQqI4AggVIJ7/aK +IJULAti+Da/wAaWC4BTysg2P8IDgEPKqDY/wCHEyCe/2iiAVCp4Nj/AVJQEQFIEB4BShz3CAAIwh +LJDPdoAARB4elhBxGfILyAQggA/////DCxoYMAvIh7gLGhgw+g0P7wCGxBAABlEgQIEF8gCF67gD +2ALyBdi6D4/wANh6Cq/4jLj5AQ/v8cDhxc9wgACMIQiIh+At9M9wgABEHgGAHtnAEAMGgOMvKMEA +AiECABLyjuIJ8hJqFnjPdYAAH9cIZYDgCvIQI4OALyjBAAIhAgDx9QHYA/AA2IDgGfIGDk/2gOBU +CSIAyiAiABHwUgpP9s9ygAAkKiCCobmA4K65IKIH8joKT/aA4DgLgfV5AQ/v4HjxwOHFz3CAACAr +SIgqiEQqPgsAIYB/gACwKjV4BojPdYAAJCqB4BT0z3GAAEQeAIHIEAAGhiB/jgr0AYHIEAAGhiB/ +jowO4f/KICEAAIWquCEBL+8ApeB48cCaCA/vCHXPd4AAICxw3AInARMieEoKL+8c2Qh2QicAHjRu +ACGRD4AAJCpcEQEmQoVELj4XJ3BSCWAAWWEAJoAfgAB0KziIgOEacNX2jCHDj0X2YbkveTiogOHN +9nDcAicAE10RASZChUQuPhcncBoJYABZYV4JT/aA4AHaGhiCIAfyTglP9oDgTAqB9W0AD+/gePHA +4cXPcYAA6CsieL4JL+8c2S4Jb/YIdQAlgR+AAI4rgOAA2kCpB/QWCU/2gOAoCoL1VQAP7+B48cDS +D8/uz3CAAOBcBoAjgCCBBg+v9oog1QtyC4/wgeAV8moLj/CA4BHyYguP8Ahx5g6v9oog1QhSC4/w +z3GAACQqFXkLgQHgC6HPcIAAJCoggM9wgACMIUyQz3CAAEQe8LkekA/yEHIK9AQhvo8AADgQBvR2 +C0/2gOC78soL7+8B2M9wgACMISyQz3CAAEQeHpAQcQr0z3CAACQqAIAEIL6PAAA4EATyAd8D8ADf +z3CAAMRclg+v8ulxz3CAAIwhCIiI4BD0AN0C3kQtPhcAIYB/gADoK3YPr/LpcWG+gOYB5TX3IghP +9hpwz3CAAIwhLJDPcIAARB4ekBBxDfTPcIAAJCoAgAQgvo8AADgQBfRMIACgPvQLyAQggA////8r +CxoYMAvIh7gLGhgw8goP789wgACMIQiIh+As9M9wgABEHgGAwBAPBoDnLyjBA04gjgcg8o7mF/Ky +brZ9x3WAABDXBZWA4M/2BpVRIECACfI6DC/wz3iKC0ACBdgSrQDYBbUQJ4+TLyjBA04gjgfk9c9w +gACMIQiIiOAo9M9wgACMISyQz3CAAEQeHpAQcQv0z3CAACQqAIAEIL6PAAA4EBTyz3CAAEQeAYDE +EAAGUSBAgcwgIqAK8s9wgAAkKgCAUSAAgAfYA/IG2BIMj/BJBs/u4HjxwM9xgAAkKvwRAgCD4kQA +DQAzJoJwgABcYkAngHJUeAB4HYEB4B2hBdgS8B6BAeAeoQLYDPAfgQHgH6EG2AjwgBEAAAHggBkA +AAHYuguP8NHA4H7xwIoNz+4Ids9wgACQEg+AgOAQ8s9ynwC4/x2iz3GAAHwcBIEB4LO4tbi4uASh +FqLPcIAAxFwGgM91gAAkKiOAIIGODK/2iiAVC89wgACMIQiIh+DuAQIAgOZR8vgVABCA4OKGE/T2 +FYAQgOAP9gohwA/rcs9wAAC/G4ojCAZKJAAAfQMv8AolAAFhuGIIL/D4HQAQ4g/v7+lwz3CAANwH +AID4FQEQIqj4FQAQgOAn9LoIT/aA4BHyaglAAoogFQQODK/2iiFIDM9wgADcByCABImAuASpz3CA +ACArSIgqiEQqPgsAIYB/gACwKjV4BoiB4FwPIfHKIMEDAIXwuAAJ4u/KIGIAPgiP8IHgFPI2CI/w +CHG6C6/2iiAVCSYIj/AVJQEQAoEB4AKhAIWHuO8BIAAApYDmBfIAhae4AKULyJC4CxoYMJIIL+9K +IAAgz3OgAJAjHINRIMCAEPRwEwQACiHAD+tyz3AAAOUbiiNJCY0CL/AKJQAEmg8P+a4OT/7PcaAA +0BsTgZC4HKHPcIAAfBwAgO+4B/LPcJ8AuP90GAAEz3CAANwHIIACiYDgt/QEiVEgAIA/8ooglQQS +C6/2iiHJDc9woABILuuAz3agADgu078HhuR4RR0YEIogFQzuCq/26XGKIBUM5gqv9kUVARYHhuZ4 +B6YOC2ACENgAhc9xAADwH5C4AKUHhoi4B6a6Ci/3DdgLyAQggA/+//8DCxoYMAvIjriQuAsaGDCq +D8/uz3CAANwHIIAEiaC4BKlt8PgVABCA4OKGDvT2FYAQgOAK9gohwA/rcm/YBriKI4oID/FhuIoO +7+/4HQAQz3CAAEQeAYDEEAAGUSBAgQny+BUAEIDg7Aph9MogwQPPdoAAICxoFoCQgOAj8moWgJBR +IMCBHfIaDA/2ahaBkBpwAIXGuQq5gbgApc9wgACMXLYLIAD5YUwgAKAL9PILD/aA4AfyAIWOuP4M +b/UApeILD/aA4AbyVRUAFgHgVR0YEPgVABCA4BP0CBaAkAoWgZBEKD4LACGAf4AAsCo1eAaIgeA8 +DSHxyiDBA9UCz+7gePHAbgrP7gh3z3CAAOBcBoAjgCCBmgmv9oog1QrPcIAAkBIPgIDgAN0P8s9y +nwC4/x2iz3GAAHwcBIEB4LO4tbi4uAShFqIih89wgAAkKs92gAAgK0AYWAAIjs9xgACzKkQoPgsy +IUQOSo5CJEEAUHHI9kAiRQAvJUcBCh5CEQXwqq5KJQAARCg+CwAhgH+AAJwqFSBCAUySgOIO9LBx +yfZAJUUALyVHAQoeQhEE8KquSiUAABUgQAEMkIDgyiLMB8ogjA8AAOYbyiOMDwAA5QMMACzwyiHM +DxINz+8IjiqORCg+CwAhgH+AALAqNXgmiIDh6XAE9MIPAAIE8JoNAALPcIAAfBwAgO+4BvLPcJ8A +uP+9oMEBz+7xwOHFAN0ODq/2qXBSCK/wqXDSCI/xngiP8M9wgADEFK0B7+6goOB48cCWDc/1Ig7P +9QYNz/XRwOB+4Hjhxc9yoADIH6QSAwDPcYAA4AYNgRBzwiMGAET3YngTe7+CDoG7Y3hgDqEB2Eoa +GADgf8HFz3KgACwgZoLPcYAA4AYOgWJ4DqEQghkH7/MNofHAygjv7kokQADAgaCAAd/RdcIkAgHR +daGBYYDCJ84TAd6xc8B+sXMB28IjzgBMJACAzCYikMojYgAL9IDjBvSA5swnIpAE8gLbA/AA24Dj +FPKB4w7yguMa9KCAwIEBgCGBAiWNk6CiAyBAAAGiEPAA2ACiAaIM8KCBwIAhgQGAAiWNk6CiAyEB +ACGipQDv7mhw4HjxwOHFJoBAgEIiAoDKImIAgOLKIcIPyiLCB8oggg8AADYRyiOCDwAAdwDKJCIA +eAbi78olAgFggTBzCvJCgKKDQn2A5QT2YIMwc/r1QYMBo2CgQaAAokSApoBRIkCAQCUDFgvyRoWA +4gbyooJCgEJ9gOXD9gCjRICmgFEiwIBAJQMXC/JHhYDiBvKigkKAQn2A5cP2AKNBgFBxBfRqDS// +BoANAM/u4HjxwI4Pj+4IdgCAQiABgMohYgCA4QDYKPImhkGGAd8wciCGQYZBoSCiAKbPcK3eAgAB +pqaGwH8GhRB2B/SpcFoIIAAC2QalpoYHhRB2BvSpcEYIIAAI2QelgOcF8gINL/8GhgHYkQeP7iCA +EHHKISEA4H8ocPHAGg+P7gh1hg/v/yh2CHfCpdYO7/+pcGkHr+7pcOB4QIAQcgjyZIILI0CABfRA +ghBy+/UA2uB/SHDgeM9yoADIH/QSAAC82xi7BCCAD///APD0GgAAC8hleAsaGDAVGtiAz3OAAKQc +CIMA2SCgDIMgoAmDIKANgyCgCoMgoA6DIKALgyCgD4MgoM9wAAwPAKQaQAAOog/YDLgQouB+4Hjx +wH4Oj+7PdaAA0BvThfq+BvLPcIAALF1KCQAA+74H8s9wgABMXT4JAAD8vgbyz3CAAGxdLgkAAP2+ +B/LPcIAAjF0iCQAA/74G8s9wgAAMXRIJAAC82Bi4E6WRBo/u4HjxwBoOr+4A2wh3z3agAMgfpBYA +EM91gACkHPhgpB4AEAHYE6YohQyFQIEAgAAiwoNAoSyFASDAAAChAtgTpimFTYUAgUCCACDAgwCh +DYUBIsIAQKAE2BOmKoUOhUCBAIAAIsKDQKEuhQEgwAAAoQjYE6YrhQ+FQIEAgAAiwoNAoS+FASDA +AAChBIUAgGYIb/HpcSSFAKEFhQCAWghv8elxJYUAoQaFAIBKCG/x6XEmhQChB4UAgD4Ib/HpcSeF +AKEP2Jq4DqYP2Ay4EKbPcIAADF0aCw//z3WAACxdDgsv/6lwCgsv/0AlABgCCy//ViUAEvoKL/9W +JQATiQWP7uB48cAaDY/uCHcg8ACGIYYhoAChANgAps9wrd4CAAGmpoYGhRB2BvSpcPoN7/8C2Qal +poYHhRB2B/SpcOoN7/8I2QelI4Zgeclwrg3v/+lwCiYAkAnyA4cggAKGIniA4K4HzP+KCi//6XAZ +BY/uD9iauM9xoACwHxWhD9gMuBeh4H7xwI4Mj+7PcoAAVMM/gjpw67mqwQDYEPLPc4AARB5jg3SD +SBKBAMDdZHmGIf8OIrk6fQTwFN0C2IoSAQECeRKCBOFKCS/0ANquCWAAAiBOAwPYz3GgAMgfE6HP +dYAApBwIhQCAQsAMhQCAQ8AJhQCARMANhQCARcAEheCABYUAEBIAQBEABh5m/BEAAM9wgAA0qQDZ +QIABgAAigoMBIEAAQMJMIUCgQcCLdg70mg8P8ITBGnDJcB4L7/+Gwgh2CBABIQzwgsHJcAoL7/+G +wgh2z3CAAHjfJJDPcoAAeN9lggbCBLtQc0ApgAKI91BwS/cCelBwvvcG8NYLYACGwAhyRsKC5hX0 +6XBqDi/xSHEId0pwYg4v8QbBBsJacATDB8EFwAAiwoABIEAARMIW8IDmFfTpcGoOL/FIcQh3SnBi +Di/xBsEEw1pwBsEFwAfCAiNDgETDAyCAAEXAgeYL8s9wgABEHgOAGIiE4MwmIZAA2AL0AdgvIAeg +RvTpcPYNL/ED2Qh2SnDuDS/xA9kAwQh3AcBAIcGAQSAAAEHABMBAwQXBQCDAgEEhAQBEwEoIYABF +wUwhAKAK9ASFwKAIhQDBIKAMhQHBIKBMIYCgEfQEhcCgCIUAwSCgDIUBwSCgBYXgoAmFBMEgoA2F +BcEgoEwhQKAK9AWF4KAJhQDBIKANhQHBIKCKIAcO0glv9gpxTCAAoAHZwHnPcIAA9Bw0qM0Cr+6q +wPHAdgqP7qXBCHYCiyh1mHBkwACLABIGAREcAjB5cAISBwEEEggBEBQAMeSSBhIFAQAgyQMAkS8h +SBIHIEACCgkgABB4ACCKAQGVLyKIEgcggAL2CCAAEHgAIMYBApUvJogBByCAAeIIIAAQeAAgBwID +lS8nyAEHIMABzgggABB4ACUFAASVLyVIAQcgQAG6CCAAEHgfZwWV8H/neKoIIAAQeCaVIXAQeAd5 +PHoPuSV6UHoAIoECMHkAHEQwR5Unelx5D7pFeTB5ACGCAVB6XHkCHIQwD7pFeTB5ACHCAVB6XHkE +HIQwD7pFeTB5ACFCAVB6XHkGHIQwD7pFeTB5P2fwf/x5CBzEMw+/5XkweThgaXHGuYW5CLkFIcEC +ILYQeCCVChwEMCd4HHgIuAUgAAEBtgDAAaYBwAKmAsADpqEBr+6lwA97SLgPeM9ygAAAcPQiAABA +KAECSLgFefQiwAAweeB/J3jgePHAz3KAAPxcIIKA4cohwQ/KIsEHyiCBDwAANBHKI4EPAADjBsok +IQBUB6HvyiUBAQGiAdrPcaAAyB9QoUoZmABIGRgA0cDgfs9wgAD8XOB/AIDgeM9xgAD8XCCBANiD +4cwhIoAC9AHY4H8PeAoiAIDxwBfy4g/P/4DgyiHBD8oiwQfKIIEPAAAzEcojgQ8AANwGyiQhAOgG +oe/KJQEBz3CAAPxcQKDRwOB+4HgIcyhyz3CAAKQcBIAAgAIggA8AAgAASQAgAGhx4cVTIEIFBCCN +D8D/AADPcIAAeN8FgAIggwAEIYIPwP8AANW5Inile0V4EHPKIK0ABfcQcwDYyiBmAOB/wcXgePHA +4cXYcLhxug/v/5hyCHXIcLIP7/+IcRB1yiCtAAr3EHUA2MogRgGYD+b/yiEGAU0Aj+4A2M9xgADo +wAWhBIGguAShRQcv8QPY4Hg2uDa5MHDWIIUPAACAAOB/InjgePHApg9P7gonAJDPdoAAeN/PdYAA +LF0P9M9wgABYb8lxQgyv/hTaIgyv76lwQCUAGBHwgucK9B4LD/DJcSYMr/4U2kAlABgM8Mlwxgog +AQXZqXD2C4/vz3CAAAxd6guP7wSWCrgFpgaGhiDDDwamKgsgAOlwlgmP75UHT+7xwKHBCHP6CC/1 +i3CC4ADYBvIAwBBzAdjCIA4AocDRwOB+4HjxwADZz3CAAGQpGgggACCgz3CAAGhXZg+P/9HA4H7g +eADZz3KAALQHI6IkoiWiJqInoiKiz3CAAAhdIKDPcIAArF0goDGyMLLPcIAAJDbgfyCg4HjxwM9x +gABkKQCBgOAZ9AHYAKEA2c9wgACMErYP7/8goIoghw7ODS/2iiGPB89wgABgHhCIg+BsCSEAyiBh +AdHA4H7gePHAbg5v7oogxw+kwaINL/aKIdICmgnP9YDgsAkCAM9wgACMEgCAz3GAACQ2ig7v/yCB +z3aAALQHMJZRlllhMHAA3cT3AiBNAAKGgOAV9IDlE/LPcYAArF0AgbhgAKHPcYAACF0AgbhgAKHP +cYAA4DsSgbhgEqHPcIAAjAYAgIHgAN8G9M9wgAAIXeCgiiAIAM9xgACsXRoNL/Yggc9wgAAIXQCA +QsVAwM9wgACsXQCAi3VBwAKGENmi2h7bQ8CpcIoN7/0YuwDYig5v96lxz3CAAIwSIIDPcIAAJDbi +pvG2IKDwts9wgACMBuCgzgsv8RPYz3CAAKxdAICF4I33YgggAAHY7giP+c9xgADYPB2BAeAdoQTw +SgggAAXYuQVv7qTA4HgV2ADaz3GgAMgfbxkYAODYkLgQoQnYsBkAALQZAAB42EIZGAAA2Jq4D6Gk +GYAAz3AADAAZDqHgfs9ygABoVyaCI4FhuGCBz3GAAIwSIIHVuXlhz3OAAHjfZYMFKz4AJ3HHcQAA +ABDNBa//SHDxwOHFz3WAALQHB4WA4BT0z3CAAGQpAICB4A70OgyP9prgCvLPcIAApBwEgACABaUB +2AelIQVP7vHA4cXPdYAAtAcHhYDgGvLPcIAAZCkAgIHgFPQCDI/2muAQ8s9wgACkHASAAIAGpb4M +7/8lhTCVOGAQtQDYB6XdBE/uz3CAAGQpAICB4Av0z3CAAKQcBIAggM9wgAC0ByOg4H7xwM9wgABk +KQCAgeAQ9M9wgACkHASAz3KAALQHAIAEomoM7/8jgjGSOGARstHA4H7xwAoMb+6KIQgACHXPcKAA +yB8woAHZQRhYAFYJAADPdoAAeN8DhiWG1bgwcMohzQ/KIs0HyiCNDwAANRHKI40PAACbAMokLQA4 +Aq3vyiUNAW4Pz+9eD+/vCHcacIDlzCVikEr0z3WAAKQcCIUghiCgDIUhhiCgAIUlhiCgBIUjhiCg +lg+P9YDgcPLPcIAAjCEIiIfgavQFhcCAAIAEJo4fwP8AAFMgUQUEhQCAag7v8Apx1bhFhQV+AtvA +os9yoADIH3OiyYUCIEGEYIZNhUCCCgAEAEIpwAcH8CSXCrkCIUEEGWEA2AIjQ4ADIgEAYKYNhTvw +guU69ASXz3WAAKQcIYUKuAChz3CAAEQeAIDEEAAGUSBAgQmFIPLPcYAAjCEoiYfhGvTPcaAAyB8B +2lOhKIUA2yCBTIUCIQGEQIIgoA2FAyLCAECgBIUAgMoN7/AKcSWFAKEK8CCHIKANhSGHIKAjhgWF +IKABA0/uANmWuc9woADQGzOg4HhRI4DF//PgfuB4z3CAACxdJ4CA4QfyA4BAgAKBQngE8M9w/w// +/+B+4HjPcYAARB4kgSiBBCG+jwAGAAChwQX0USEAgAj0CPAEIL6PAAAAGATyANgD8AHYz3GmAKQA +F6Hgf6HA4HjxwDYKT+7PdaAAtEcIdgbwSgvv9YogiQxxFQCWBCCAD3AAAABBKD6F9PWKIP8Pbx0Y +kGsdGJAD2A+4z3GgAMgfExkYgAWGWR0YkAaGWh0YkAeGWx0YkAmGWB0YkAiGVx0YkEARAQbPcYAA +QF4ggQQggA8AAACAUSEAgAf0gOAG2Mog4QEC8ADYz3GAAEQeI4Eogc9ygAAABlEhAIAQ8k8gAQKN +uZe5JqIFIIEPgABAOieiBSCAD4AAwFMQ8AUggQ+AAMAkJqIFIIEPgAAAPieiBSCAD4AAgFcIooQV +AJYJogaGEgvv8SGG3g7v/wGGtQFP7uB48cA2CU/uOnDPd4AArDoMj4Yg/wFCKNAAz3agALRHCnUF +8EYK7/WKIIkMcRYAlgQggA9wAAAAQSg+hfX1QxYAlkYgAA1DHhiQVxYAlry4v7hXHhiQXxYAlr+4 +Xx4YkADYnrhTHhiQ4HgA2FMeGJAMj2AeGJDWCA/7z3CAAAQqIIBgeQTYgOAW8kwhQKAsDGH5yiBB +A893gABIXgCPEHUK8s9wgACMLTaAYHkA2AAfAhTCDA/wQxYAlkwhAKBFIAANn7hDHhiQTfJMIUCg +EfJMIYCgNvIKIcAP63KKIFoKiiONAkokAADJBm/vCiVABM9wgABEHgOAEL2bvTIggA8AANgCn72A +4AHYwHgPuKV4Xx4YkAbwUgnv9YogiQxxFgCWBCCAD3AAAABBKD6F9PWKIP8Pbx4YkGseGJAT8M9w +gABEHgOAEL0yIIAPAADYAp+9gOAB2MB4D7ileF8eGJAGyITgYA/h8MogoQQtAE/u4HjxwNIPD+4I +dSh2Yglv7gGAoIUQuUEtABQ4YFIJb+7JcRC5sHg4YEYJb+5ALoESEQBv7ihw8cCeDy/uBNkA2M91 +oAC0R0sdGJAA2pC6dx2YkAHadx2YkM9yoACERBiiANqRuncdmJAC2ncdmJDPcqAAiEQYogDYkrh3 +HRiQdx1YkIDYdx0YkADYnrhUHRiQANicuFQdGJDPdoAAVAbJcOIN7+8c2c9wgABIBtYN7+8K2clw +IR0YkM9wgADUBBB4SR0YkH0HD+7gePwcCLSF4PHAGnCN9wohwA/rcoog2gt32wokAARZBW/vuHOK +IBkKIg7v9Qpxz3OAAFQGJINocDR4IJBRIQCCDvIQEwQAABAFAQohwA/rcoog2golBW/vftskgwHh +iOEkowDaA/REoy8hBwSFIQwAILCQ2c9woAD8RBi5IqALkwHgEHgLs9HA4H8EFBA0gODxwAf0z3CA +AKSiHg3v7yTZ0cDgfuB48cBmDg/uig5gAQh2zg6AAM9xoADIHwh1QNgPoUARAQYweXIOb/bJcKkG +L+6pcOB48cAyDi/uSiQAcs9woACIIADeqCCAD4fmOfKggM9xgACwwc9ygAB439Z5aIlHgnpigOXP +c4AAfMLUex70ACaNH4AAdML4jYLnCPTgk/t/I5GAvyR/4LMG8IHnBPQikSCzANk4rc91oADIHPqF +IJPkeSyzBfAskzB1w/dZYQPwrLO5Yokhzw8EGFAAAeYA2c9wgAB43wUGL+4noOB48cAAFgRABxoY +MQAWBUABGlgxBBKBMJzhyiLCB8oggg8AANwOyiOCDwAA9ArYA2LvyiHCD8oI4AAO2dHA4H7gePHA +Ug0P7hpwDcjPd4AApMLwJwEQz3WAAATCAxICNggYRCABkoDgDRIBNgDeDvIUJUMQgBMOB4DmafIA +3oAbnAPwG4QD4BuEAxQlQxDAswGC7rgf9Miz0BuEAxCKz3GAABDXArgWeBthZZOA4zhg0fZhu2Ww +EIpyaHZ7emFFkoDieWEH9CaRUSFAgKAKQu8NyAAggQ+AACDCxKnMqdSpz3GAALDBFnkUfSKRwB2E +ExV/eB1EEAMSATbApwGBBCCADwAAAGDXcAAAACAT9BCJz3GAABDXArgWeABh7bjKJmIQz3CAAHwd +1HggkBDhILAD2c9woAAUBDCg0gygAQpw2diWC+/1ARIBNj3wcBINAeATAQECIU4DsXYG98J9ongQ +eIAbHADPcKAA1AcPEA6GAN3wG4QDcBICAcAbRANCeTB54BtEANATAQEB4TB58BMFAdAbRABTJX6A +yiHCD8oiwgfKIOINyiOCDwAA5w3KJIIPAAD+AFACYu/PICIDA9kTGFiANQQP7uB48cDCCy/uANjP +cYAA1F0Aoc9wgACQEgGAgOCjwQ/yz3KfALj/HaLPcYAAfBwEgQHgs7i1uLi4BKEWogzMz3WgANQH +USAAgAPYIB0YkFLyFB0YkAMSATYAFgRABxoYMQAWBUABGlgxBMqc4MoiwgfKIIIPAADcDsojgg8A +APQKwAFi78ohwg8ocK4OoAAO2QMSATZQiVMiwACGIv4DEKlEugK4xBmCABZ4z3KAABDXAGLPcoAA +RB4tuMC48CIAAASiuRACBs9wgACwwUCgDxUAlrQZBAAGyHoLb/QNEgI2AxIBNpIRAAFyD2/6lBEB +ADHwSiRAABQdGJEAFgBABxoYMAAWBUABGlgxBMqc4Mohwg/KIsIHyiDiCcojgg8AAGYCHAFi788g +IgMDyLQQAAEPHRiQy9jaCe/1DRIBNgMSDjaUFgAQUSBAggXy8g5P9gMSDjYNEgM2z3eAAATCFCfB +EAiRgOAh9FCOz3CAABDXdX8CulZ6QGCYFgIQLbhOp1anwLjPcoAAfB30IgIAvB6EENARAAEEIoIP +AADw/8O4RXjQGQQABfDQEQABvB4EEAHYoB4AECIOL/rQjoDg8AMhAAMSAzYGyFEggIHkAwIAIYP6 +uQjykNiQuNUDIACgGwAAAr7PcIAAENdAIIID1n7OYsQTggDRcgjykdiQuLEDIACgGwAAyoPPcqAA +LCDwgowm/58N8sJ/13cAgAAAR/eH2JC4jQMgAKAbAAAQE4QAQCyPAPZ/5mAEJr6fAAAAE/hgWfLp +vgfyi9iQuGUDIACgGwAA7L4z9CWQgOEc9AfIBCCADwDAAADXcADAAAAM9BHYFLigGwAA4diWCO/1 +iHEDEgM2IfCI2JC4oBsAAOLY9vF+CO/149gDEgM2pBMAALS4pBsAAJITAAGnuJIbBACeEwABp7ie +GwQABfCF2JC4oBsAAM9wgABEHgOAGIiE4OACAgDPcYAA9BwMgVCLDyCAAAyhz3GAADAdAIEB4MEC +IAAAocKQMxOAABEmAJAm8gfIBCCADwDAAADXcADAAAAV9AiLgOAU9qQTAAC0uKQbAACSEwABp7iS +GwQAnhMAAae4nhsEAArwUSGAgQjyjdiQuG0CIACgGwAABshRIACAFgIBAPINj/8DEgM2CHKoGwAA +z3CAAKQcBICwEwcBIIBVJ0AG1bkQcc92gAB430P3BdgHpgWGIniMIAmGyiElAKQTAAAJIYEA8ris +G0AA5vKYE4EAw7kHyDx5BCCIDwEAAPANEgY2z3CAALDBFiCAAcWQrBMAAAkggAOAEw4BfhMPAd9n +z3aAAEQexIZGFg4R/mYIIIADwniYEw4AQSgIE+i+AN+G8kQmDxYEJoEfBgAAACO/MbkB5/lhz3eA +AAByMidEEEEugRIEJoUfwAAAAFIhAQBBLYUFMidPEcC5A7kY4YB3hefKIY0PAQCJDdUhzgOkEw8A +9L8j8iJ4hBMBASJ4SCAAAEK4QS5PE8C/BL/0f8lxxrlJIcEFNH/rvs9xgAAgavFhBfJBKQ4BFCZB +EAUpPgBBKQByAN9Y8EEohABBLkATwLj0aPR/yXDGuEkgwAUUf+u+z3CAACBq8GAF8kEoDwEUJwAQ +BSg+AUEpAHKEEw8B6775YRDhQSmEAEEuQRPAuQS5NHnJd8a/SSfPFfR5z3eAACBqMWcF8kEpDgEU +JkEQBSk+AUEpD3Ig8FEmQJLKIMIDGvQD4M92gAD4afAmQRAiuAUpPgAvcFMgDgDYYIQTDgEdeCfm +Ir4FKb4DL3dTJwEQP2f9f89xoADELO+h7qFAKA4Wnr5ALg8F5X7FeMAbAAAKoc9xgACYOQHYAKEE +8E+CsBMHAfByRvcF2Bi4oBsAAM9wgABcB0GAIJMJIYEAAIiB4Af0GRUAlhBxANgC9wHYgOAM9APY +GLigGwAAz3GAAFw8E4EB4BOhoBMAAAQgvo8BAQAAGfSSEwABlBMBAJATAgGyEwMBsg9gAUokQAAD +EgI2oBIBACV4oBoAAM7YLg2v9QESATYDEg02oBUAEAQgvo8BAQAABvL6C4/0DQRAAAPMz3GfALj/ +GKEGyFEgAIDKICEge/KkFQAQ8rgz8s9xgACYOQCBgOAA2DPyANgAoYAVABF+FQ8RH2fPcIAARB4E +gEYQAAEfZ1EhgMX+889woADELMuA39iyDK/1yXFTJoEU/r7MISKACfKYFQAQTgpv8wDadLj4YALw +ANgDEgE2CPANyM9xgACwwRZ5BZGpcUogACCA4M9yoADIH6wVDhAH9KQVAxCxu6QdwBAD8AkmDhAD +2xi7b6L4EgMAgOChawgmThNifqAagAMA25i7bqIL8qQRAADxuA3MxSCiBM8gYQANGhwwAZGA4Ary +DcjPcoAABMP0IgAAgOAF8gGB7rgF8g3MgLgNGhwwzNj+C6/1BhIBNoII7/kDyAMSATZ8kUQjAAOE +4G3yDcjPcoAABMIUesASAAFleGGB7bscsQryVBEDAbwRDQHDu6V7VBnEAIYg/QyMIAKCGfQQiQK4 +FnjHcIAAENdlkIDj0fYGkFEgQIAN8oHjCPRgEQABhLhgGQQABfAckY24HLEBkYDgJ/LQEgABVBED +AcO4BXtUGcQAgBIAB4DgBfQckYq4HLGkEQ0A6L0J8mgRAgFTI8AAWGAQeGgZBABRJUCSCfJqEYAA +w7t4YA94ahkCAAfIz3KAABTDBCCADwDAAADXcADAAAAE9A4aBAQF8ADYi7gHsgGRgOAU8g3Iz3KA +AATCFHrQEgABUyDAgAry8BICAc9woACYA16gthmEAKQRAAAEIL6PAAAAMAf0hiDlj1gNYgDKIEIA +JgwAAYDgDvISCw/9A9nPcKAAFAQjoIogEACtAWAABhoYMAPIpBAAAAQgvo8AAAAwzvL0uAn0ggwP +89bYjgqv9QYSATYDyKQQAQDsuVTyegqv9c3Ylgrv8AHYAxIBNh2xz3CAAEQexIDKCS/3AN2B4Az0 +z3CAAFAcAJCB4ADdzyUhE8olAhQD2M9xoAD0BwWhhSUCHQ1woLADyF2QDXBAsAPIT4DgugbyQoYN +cECgRpYH8A1wQKADyEAQAgENcECwA8hRgA1wQKADyEgQAgENcECwEBkABAPIlBAAAFEgQIL8DgH2 +tgwP+AYSATbZAGAA0NjWCa/10dgDEgE2AYH4uA/yz3CAAGQHAJAdsc9wgABoB0CAAYBRoRKhB/DO +Ce/wAtgDEgE2HbFaC0/9A8j6C6//eBAAAYDgkABCANLYigmv9QpxAxIDNgGDmBMBAPi4lBtAABXy +z3WAAAjmqXDWDC/4aHEQ2AwaHDANzKO4DRocMMIMr/+pcFEAQACeEwABvhMCAZIbBACQG4QAvg9g +AYITAwEIdc/YMgmv9alx+L0P8gPZz3CgABQEI6CKIBAABhoYMP3YDQBgAKlxA8ikEAEAhiHlj4gL +QgADEg02pBUAEPS4lAIBAHCNz3KAAPDVdnrPcKAALCAPgIQVDhEgkggggAPCeLAVDhFk5tFwBgEu +AAkgQQACu89wgAAQ13Z7YGAEII4PgAMAADe+Zb6A5somDBQEIIAPGAAAADO4DeAB30oiACAPIhIg +AxKRAEIJr/SYFQAQCSCBBJgVABDtuMogwiNAKAMhdHsIcsa6SSLCBVR767jPcoAAIGpyYgXyQSoA +ARQgggAouth6A2oEIIAPAAD8/89ygAD43wOiz3KgAMQsDaIwGkAEB8gNEgM2BCCADwEAAPAsuBi4 +nbgUu2V4BXkqos9ygADQPQiCAeAIogYIr/Xe2FEhgMX/889woADELMuA39jyD2/1yXEEJo8f8AcA +AP6+NL9TJoEUB/KB58X3AJUQ4BBxDfcDEg02SiAAIM9xgADYPAGBAeABoQDZLPCkFQAQ97jVIcID +z3aAAPjfIKbippgVABBODS/zANoBps9xgADYPAKBAeACoQCB+GAAoc9wgABEHgOACYBRIECAB/IN +zEYggAINGhwwAxINNgHZSiAAIIDhkhUAETrylBUBEM9ygAD436KSwIJAwc9zpQCs/89ygABEHtij +RIJWEgIBFOJCfQPlIr26ZbpiSCJCAAW6RSJCA1ajUSDAgcoggi8AAIAAIMAEIYEPAAAAICW5BSAA +BCV4ibiOuBmjz3CgAKggCID+DI/v6QUAAKQVARCnuJIdBBC0uaQdQBCUFQAQkBUDEc9xpQCs/0DA +sBUCEXihz3OAAEQeZINWEwMBFONiegPiIrpbYnpiSCJCAAW6RSJCA1ahIMIEIIAPAAAAICW4BSIC +BEV4ibiOuBmhz3CgAKggCIAD2c9woAD0ByWgDciYFQIQz3GAADzCFXlAoaQVABAIdIQkGpAZ9AQg +vo8AAAAJCPIKCC/9qXCCCC/9A8gN8HAVARHPcKAA9AcnoM9woADIHBwYAAQDEgE209giDm/1pBEB +AAPIpBAAAFEgAIEJ9P4Pz/Lb2AoOb/UGEgE2A8gBgPm4B/QaDq/wBNgDEgE2HbFWDe/2AN6B4Az0 +z3CAAFAcAJCB4ADezyYhE8omAhTPdaAA9AcZhYDgEPIKIcAP63Iz2Iy4z3MAAG4KCiQABN0E7+4K +JQAEA8gckMV4DXEAsQPIPZANcCCwA8gvgA1wIKADyEAQAQENcCCwA8gxgA1wIKADyEgQAQENcCCw +AxIBNhyRhiD/DITgH/IzgQ1wIKADyFAQAQENcCCwA8hUEAEBDXAgsAMSATYckYYg8w+MIAyACfQ2 +gQ1wIKADyFwQAQENcCCwAxIBNhyRhiD9DIwgAoIb9GARAQENcCCwAxIBNqQRAAD3uBHyOYENcCCg +AxIBNqQRAABkGQAEuBkCBLoZBAS3uKQZAACkEQAABCC+jwAAQAgH8gGB8LhEDILwDvA6gQ1wIKAD +EgE2pBEAAIYg848E8juBDXAgoAHZK6UD2kilz3OAADA2DRINNkCDUHUA2Bvyz3KgADguRYIEIoIP +wAAAANdywAAAAAzy9dgFuM9ynwC4/xqiu6Jp2Bi4GaIocIHgA/Sgo89woAD8RD2AGYDruDX0BCG+ +jwAGAAAv9OB44HjgeFEgQMMp8gPIz3GgAMgfsBAAAZYgQQ8eoRDYDqEB2BUZGIDKC+AAQdhRIEDD +FfLPcIAA1F0B2SCgA8ikEAEAmrmkGEAAhgtv/wHYz3GAANA9DYEB4A2hKg0AABpw1NjqC2/1CnEE +IL6vBgDKACHyz3CAAGwcA4CA4Mohwg/KIsIHK9jKI4IPAAA/BM8gIgME9c9xgADQPRCBAeAQoc9x +oP7oAM9wnwC4/zagnQIAAAPZz3CgABQEJaADEgE2AYFRIMCAKfKkEQAAz3KAAEQeUSAAgASCA/K7 +kATwgggv9rqQz3GAAKw6EYlRIACAFfIDgjCJELkyIIAPAADYAp+5gOAB2MB4D7gleM9xoAD8RA2h +A/B2EQ0BDcxTIECADfLV2CYLb/UGEgE2BsgEEgE22gjv8w0SAjbPdoAACObJcHYO7/cDEgE2A8gG +EhA2z3eAAHgdoBARAAHYAKdODW//qXCA4ADZIKcK8oYgfo/s8gPIoBhABAYaGDQDEgE2khEAAeq4 +B/KquAoMb/mSGQQAAxICNn4SAQGCEgABgBIDAThgG2MNyM9xgACAwhV5CYFwextjaaEBglEgwIBz +8tfYigpv9QDZMgzv94DYBhIBNgQhgQ8CAAEA13ECAAAADRICNwj0/bgG8k8iwQANGlwwBvCjulB5 +DRqcMAMSAjYBglEggIEt8k8hwAKMuBB5DRocMBCKMxKCAAS4RXjPdYAArKrPcqAAOC5Egga1EfAv +LoEQTiaDFwDeDybOEMZ6z3aAAGDV9CbOENFwCPKA4vD1z3AAAP//BLUD8GS1CNgMGhwwz3CAAKw6 +EYhRIECBCfLPcIAAbDimDO/8AIgNEgE3A8gBgP24zyHiAdAh4QENGlwwz3GAAFw8FoEB4BahM/AQ +2AwaHDANzKO4DRocMAYNb//JcNjYkglv9QESATYDEgI2AZKA4AnyDcjPcYAABMP0IQAAgOAL8gGC +7rgJ9A3IAdoAIIEPgACMwkCpDcxTIECACfIEEgE2iiAEAJYO7/mYEQEAA8gakLoPr/cNEgE2DcxR +IMCABhIBNhHyLglv9dfYz3CAABTDAxIBNgKAmBkAAAbIVgrv8w0SAjYGEgE23NgGCU/1EQKv7aPA +4HjxwOHFqcGLdalwz3GAAKhibgqv7STaqXBODO/3AxIBNg4KIAGpcA0Cr+2pwPHA4cUDEgE2ooEg +hT4Or/0k2oDlDfQKIcAP63JZ2Iy47ttKJAAA2Qev7golAAEBhYDg4iACANEBj+3gePHAOgmP7Zgk +wTM6cADYThwYMAAWk0AAFpBAABaUQAAWkkBMIgChxPYvIkckTCIAocohyg/KIsoHyiCKDwAAtSjK +I4oPAABQAMokKgB0B6ruyiWKBEEoDiHAvkApASSKIJMCMghv9cV5gOYs9EwgAKAr8s9wgAD0wQOI +CnGGIfwHRbkmeFMgzSDguMohQgPKISEAViTMOSCs4bjKIUIDyiEhAIt0gCREHiCsUSCAgMogQgPK +ICEAi3SAJIQeAKwG8FMg/qAr9ADdhCoKIi9wunDHcIAA6LOELgQfBOAAIFAORCo+JwAhgH+AAHjA +4IgBiJJ3uHDMIMGEIPIKIcAP63JALA0kQCsOJIfYjbiI2wUlxBOxBq/uBSWFAwohwA/rckArDiTP +cAAAryhu2wUmBBWRBq/uCiUABApwggsgAEjZViAAKXYLIAAG2QAlgC+AAFS2gOYjgAn0gbkjoE4U +ATYkoCWgA/CCuSOgA4CGIH8OhuCKIBMDyiCCDwAAywQWDy/1KnGA5c9xgACsBgryz3CAAHjAQIgc +iBByBPQEGUIEAIEQiFJwDPQKcDIPL/3JcYogEg3eDi/1ThQBNjINj/LJB2/tlSTBM/HAhg9v7QDZ +z3CgAPxEdBAQANmABCaCnwAAAAgL9AQgvq8ABgAAB/QDyKQQAAD6uIzyz3CAAEQeBIDPcaAAyB9R +IICmRhAAAR+hINgOoQvyNg5P8YogBAByDi/1ANkA3T/wUSBAphLyXglv8AHdAxICNghxoBoAAIYg +fo/CJUETSg4v9fzYLfBRIMCkAxIBNgzybyBDAKAZAACKIAgABhoYMIogRALa8VEggKQM8gDYl7ig +GQAAiiAIAAYaGDCKIIQCzPGkEQAA+rgp8gXYELigGQAAiiAIAAYaGDAA3c9wnwC4/1gYAAgKcF4O +oADJcQPez3egANQH0qciDo/8z3CAAHgdAICA4MwlIpAD9BMfmJMDyKAQAAAZ8IDiCPLPcoAAVD0Q +ggHgEKLS8QohwA/rcgolAAgy2Iy4z3MAACUJuQSv7gokAAQocKEGT+3gePHApBABAOm5BfJGDQ/9 +0cDgfih0hCQSkBHy+bkE9EoMj/QH8CDZz3CgAMgcKaAD2c9woAAQFCWg6/Hr8fHA9g1P7QonAJA6 +cQDdFvLpcS8oQQBOIIIHz3CgAAwtT3rwIIAAwrgPJQ0QANgPIIAABiEBgO/1gOUr8i8oQQNOII4H +DRqYM/XYBbiSDm/1yXENyM9yoAAUBAqiz3GgAGQu8CEAAFMg0AQpgtIML/Xa2Cpw4gpv8wQgwSP6 +D6/5yXAA2A8ggAMGJQ2Q2PXPcoAAMDYAggfZh+ANGlgwHvLPcKAAOC4FgAQggA/AAAAA13DAAAAA +DvL12AW4z3OfALj/GqM7o2nYGLgZowHYA/AA2IHgAvQgos9woAAUBCqgdQVP7fHA4cXPcIAACMXP +dYAA+gdgjUGIhCsfAAAhgX+AAIjItgmv/QLiII3PcIAA+AdAkIQpHwAAIYB/gABsxVUFb+1AsOB4 +8cDaDE/tKHZGIc0AHWUyCCAAIrnBvoHmDfKC5gfyg+YM9AAWgEABHRIQABaAQAEdEhAAFoBAAK0N +BU/tgOFW8kAhwgMkusO5AvAA2Y/hlgANADMmQXCAAHhiQCeDcjR7AHsAFgFABBhQAAAWAUAEGFAA +ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAA +FgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAEIi +QoCz9eB+4HiA4cokTXDgeOggrQEAFgFBAhhUAOB+4HjxwM4LT+0A3c93AAAEHUogACKpdhUigDMO +EAEGANjPcqAAFATKoqiiJ6IEoj1liOFoucohDgB+DG/16XBCIFAgTCAAoCDnAeYm9+kDT+3geOB/ +ANjxwG4LT+2hwRpwSiMAIAAcwDSKIAcJqgov9Qpxz3CAAGReMiASBM9wgAC0BtGIEogQdlwBCQBq +dwohwCQC8Hp1RC6+EwAiQC7PcYAAKOczIQ0ATCAAprt9rX1X9s9xgADoFRqBO4EkeFEgAIIN8s9w +gAC0BguIi3PJcUoM7/WpcgDAAn2tfQAmgB+AALQGHBDBAM9ygAB4PgCKBdpaDyAAqXPPcYAANF4g +gQDdSiSAcSJ4qCCABXNudHu1e89ygACkmnliIYmA4XpiC/IQcRDyEHET9oXlV/YB5a99CvBCJZEQ +LyFHJGG9r30R8AMSzwAA2Wp1DPCA5UohACDKJWEQBfJCJVEQLyFHJAHZgOEt8vNu9H8VJ0ETz3OA +AKSaOmMAI0UAFSdPFPljIYlBijBy+2Pji9j2AiJEAAMVggAEv/B/IngEui8kCAECJ4MQbHgvIEYO +5gtv7YhxDngCfwjn7n9Ev+1/TCAApoT2Cuftf8lwCnHGDCAA6XIB5s9wgAC0BhKIz34QdrYGzP85 +Am/tocDgePHA5glP7Qh2KHVIdxpzT3kQuQ94CLgFeYogRwgOCS/1pXmA58wgIqAI8ixtL3nPcIAA +tAYzqAfwz3CAALQGs6ipcc9ygAC0BrSqwKr1qhYaAgQWCiAAyXAAEIcA4YjPcIAAtAbRiBKIEHak +AQkARC8+By9xhC4DEQokQA4AIUMOCiGAH4AAHJshc0AvggBUeoQuARUKJUAOACJNDgomgA+AACzm +ACZIAwAmjR+AALQGTCcAgMwnYoAm9BoTwAAA2RitGxPAAEokgHEcrRiLIB0CEKggQAYUIEAQQYiz +brR9NX3HdYAApJoAEMAAQK0VI0IAAa0BEsAAAeECrQCKL3kDrX3wARPAAIDgGfQA2litXK0gHYIQ +SiSAcQDZqCCAAxNuFHg1eMdwgACkmkCoQahCqEOoAeEveWHwfLkAJEQAbLoAIkEBACGFAQAkQAIa +iDqLAgkgAOlyGK0AJEACG4g7i/IIIADpchytACRAAhiIOIsAJEQC3gggAOlyIB0CEADdSiKAERQl +SwMUIEkTAROAEAERgRC+CCAA6XIzbjR5tXnHcYAApJoAqdhxABOAEAARgRCeCCAA6XIBHgIAFSRL +AxUjSQMBE4AQARGBEIYIIADpcgIeAgAAE4AQABGBEHIIIADpcgMeAgBCIkoQTCIAkAHlkgft/699 +AebPcIAAtAYSiM9+EHZmBsz/ANnPcIAAMF41AG/tIKjgePHA4cXPdYAAeD6KIMcJAg/v9CCFAIXP +cYAALF4ggU1oMHLAIGwBzCEMgDwLCQAZAE/t4HgCeS15THlWIQFyR7k4YOB/D3jgeIHg8cC4cRz0 +TCUAgMT2TCWAg872CiHAD+tyz3AAANcUiiOIAtEFb+5KJAAAQC2BAGS5ACGAD4AAtA8d8M9wgAC8 +EzIgQQGMIcOPyiHBD8oiwQfKIIEPAADYFMojgQ8AABAClAVh7sokIQDPcIAA5BE1eNHA4H7gePHA +z3KAAMYGCmqyCSAAKWomDgAA1ggAAM9xgACYciCBz3CAAHgOIgggAAHaz3GAAJRyIIHPcIAApA0O +CCAAANrRwOB+8cDCDg/tGnCA4Uh3lAAsAADdOnEVIEAjgOdAiAKIDPLPdoAAtA8VfgK4FHjHcIAA +DA8L8M92gADkERV+ArgUeMdwgADsDyGIUSEAgCTyBRDBACKuBhDAAAOu6XDSDCAASHEAroDgzCBi +gMogIQAT8kQoPgcAIYB/gAAYm8UQgwDhEIEAAiLAABB4B7j6Dy/tYnkBrkIhQSCA4XoH7f8B5YEG +D+3xwCYOD+3PcIAAtAYREIgAz3CAALQGEogRcLQACwBKJgAASiHAEUQuPgcvcIQoAxEncAAggQ+A +ABibHxHLAAAggQ+AABibHhHKAPhwAN4G3wAnjQ+AABib1X0HjWlxBdqYcD4KIAAFFcMQQC6CAFR6 +hCgBFQAiQQ7UecdxgAAs5rhxAKmIcElxB9oWCiAABhXDEAEdAgBhv4DnAea0B+3/z35CIUkQTCEA +kEAmRgB6B+3/LyaHAUAgSBDPcIAAtAYSiC8gBxIRcFYHyv/BBQ/tAttgqADYAKkB2OB/AKrgeKHB +8cBCDQ/tocFlwgh2KHXPcIAA2gaFwYtyQCRDMNILIAAAiEQuvhYAJUAeFBTBMM93gABonZjl+GB6 +ACoAIKhTJYAQheBMAAoARiXNEa99G/ABFIAwACaBH4AAmONSbVR6WWEgwgCpRC6+FgAlQB5EqRQU +wTD4YCCoyXBeCCAAqXEB5a99UyWAEIXgo/Yh8AEUgjASbRR4ACaBH4AAmOM4YECoIMJEqMlwMggg +AKlxD/BCJQAWD3gBFIEwx3aAALDkArgUeB5mIMAorgyuCNzfBC/tocDgeOB+4HjxwGYMD+0A3s9w +oAC0D3AQEACKIMcIz3GAAHg+jgvv9CCB6gnv/Mlwz3GAALQGsokRibFwEPbPcoAAyKJ/2xQgDwBf +Z2Cvwa8B4A94sXAF22Kv9vbPcIAAGJtBkM91gAA0XoDiwKUJ8s9wgAA8XgCAjCAfhAP2ANkU8Ndw +AACgD3v2QnhAiYDiiiEPCsAo4gAE9EQovgMvcI4ND+0IcQClCgvv9IogxwgA3Q7ez3eAAExgPgjv +/6hnYb6A5gHlr305989wgAB4PiCAz3CAACxeIKA6Ce/8LyAHBPEDD+3geA54LHgpagDYDyBAACdw +Wnjgfw4gwADgePHAYgsv7YoghwjPd4AAtAaiCu/0M48Aj9YL7/8zj89wgAAoXgAQ0ADPcYAAcCEU +j0eJEHIO9ACPIYkwcAr0z3CAADFeABDAAAkgAAQvIAUgsY8E8AHlr30SjxB1AAEJAADeSiKAI89w +gAApXgCIgOAQ8kQtvhMAJkAez3GAACheABHCAAAggQ+AACjnQKlf8M9wgAAEKiCAYHkA2IzgDPTP +cIAAPGDJYAIgQCANeEggQAAE8EggQCAvIQUgz3CAAExgy2ATj6lxggrv9FWPCSBABC8hBSDPcIAA +BCoggGB5ANgAJZMfgADQBpDgC/LPcIAABCoggGB5ANiM4AQTgSAL9M9xgABwCMlhBBOAICJ4CSBB +BAjwz3CAACxgyGACeQkhQQRELb4TACZAHsdwgAAo5yCoOnATj6lxug6v/8lyABHBIAJ5ABlCIEIi +UiBMIgCgAeYSB+3/z35+8V0CD+3xwBIKD+0Idc9wgAA3LACIEHUodwf0z3CAADYsAIgQdyfyz3aA +ALQGqXBAJoESdg+v9UAmwhIKjq96K44Yugi4BXqKIFQNDgnv9EV5Ko4EbiYOr/VLjgqOlgyv9SuO +z3CAADcsoKjPcIAANizgqA0CD+3geIDg4cUa9Iwhwo04ACoAAdhKJIBxz3OAAPibqCAABKFrRCg+ +BzIlTR6xccz2gOUI8obgCPIB4A94ANgE8GG4D3jgf8HF4cXhxgARzQCA5UT2AN2gqYDgHPKA5UX2 +ANgAqQDdz3CAAChfAJAQdYT2qWitfaCpz3CAAIBeFCBOA6COoKoAEcEANHgBiBrwgOVE9gDdoKnP +cIAA1F8AkBB1hfapaK19oKnPcIAALF8UIE4DoI6gqgARwQA0eAGIAKvBxuB/wcXxwN4IL+0A2KHB +ABwEMM91gACgBwCVz3aAABibyXGKIgQK5gxv9QHbgOAQ9AohwA/rcgAVBBHPcAAA2xSH24u7CQcv +7oolBAoAFoQQTCQAgcohyw/KIssHyiCLDwAA3BTKI4sPAACMAM8j6wLcBivuyiUrAF4Iz/SA4Moh +wg/KIsIHyiCCDwAA3RTKI4IPAACSAM8j4gLKJCIAsAYi7solIgCLcUXYAdpeDG/1AduA4A/0CiHA +D+tyz3AAAN4UlduLu4okQQGFBi/uSiUAAAAUADEB2YYg/g/A4MB5z3CAALwUIKhlAC/tocDgePHA +8g/P7Ah113UlAACAANhK989xgAB43yWBMHXQ9yJ9AeD58c9wgAB438WAqXBeCS/tyXEFLj4QAiVN +HowgEIDKIcYPyiLGB8oghg8AAM0iyiPmDMokJgAEBibuyiUGARa4/Qfv7KV4geDPcYAAXAcE9AHY +AKkBqQCJgeDKIIEPAADECcoggg8AAIAA4H8BofHAYg/P7Ah1z3aAAMwuiiDYDo4Or/Qgjoog2A6C +Dq/0IY4AjrhgAK4Bjh1loQfv7KGu4HhBiQK4FnjHcIAAENdIqCKJ4H8pqM9xgABEHvAhAQCKIAgA +4H8OoeB4DRICNgQgvo9gAAAAz3OAAATCVHvHcoAAdMIIcQbyA8gckFEggIIK8gQhgQ9hAAAA13EB +AAAABvQA2ACzAdge8AzMUSDAgQMSATYN8jIRgQABizBwBPQA2AGr8vEB4AGrC/AxEYEAAIswcAX0 +ANgAq+bxAeAAqwLY4H8YquHF4cbPcoAApAaA4MAiIgH/3RJpFngAIIMPgAAX16CrAN1KJABxz3OA +APjeqCCAAq5ieGU2eMSormIB5a99wKjBxuB/wcXgePHAQg7v7IogygWhwc91gABoOECVz3aAAGQ4 +IJYQumINr/RFec9wgADoFwCAguBA8gCFIIYQcSryz3CAAJAkBIBRIICAQMEF8k8hAAFAwIDhCPTG +Dq/yANi6Do/yOgsP9YtwBNmh2j3bsg1v/Be7IIaA4QvyAIWA4Af0ng6v8gHYngkP9SCGIKWA4RLy +tg+P8n/YCrjPcaAA0BsToX/YEKEA2JW4EKEeDa/vAdgBBu/socDgePHAig3P7M9xgABEHhV5QIEI +ggQggw+AAAAARCAPAi+7Br9lfwQggw8AAQAAQStOA+V+LLvFe8ESDgbRc8ASDQYw8gQgvo+AAQAA +HvLPdoAAjCHIjofmGPS+uAiiQIEIggQggw+AAAAARCABAi+7BrlleQQggA8AAQAAQShDAyV7LLgF +e4DlwRrYAAzyLylBA04hgAcSCCAAECUNEIDl+PVRBc/s8cDmDO/smHCQ4I33CiHAD+tycdiNuIoj +jQs9Ay/uSiUABEokAHQA26ggwA5ALI0BdX1ALIIAx3WAANDaAIXPcYAAENdWet24QWEApfG50SAi +ggjyRCACBiO6AeKB4gv3z3KAAFDZFiICAUCKUSIAgAPynrgT8C25wLnPd4AARB7wJ08QUiBOAsEX +ARYLIYCDBvIoh/657/OfuAClAeOxBM/s4HjPcYAARB7wIQAAz3GAALDBuxACBroQAwZCoWGhvBAC +Br0QAAZFoeB/BqHgeM9xgABEHvAhAADPcYAAsMG+EAAGFiECAAKSGrEDkhuxCIo4GQIAANjgfx2x +8cDhxc9zoACsLxmD8LgZgwDdDPIEIIAPCAAAANdwCAAAAAHYwHgH8IYgfw+C4AHYwHiA4BnyGYME +IIAPDgAAAEIgAIDKIGIAgeAP8gohwA/rcmQTBADPcAAArg2Z2/0BL+5KJQAAIgzv9FTY5LhEIAEC +I/LPcp8AuP+9ohzaFvDPc6AAyDtWg7aDhiL/CIYl/xileraDhiX/GKV6z3WgAKggrYXk5ZL3gOLs +9QLbz3KAAOgXYKJRIECAz3KAAGQ4AIIR8oG4EPA4EwQAWBMFAAohwA/rcs9wAACZIX0BL+4v26G4 +USCAgACiHvLPcoAAOF4AghBxGPLPcIAAvhQAiIHgIKIJ9M9xgAAoOACBgODD9mq4AKEB2c9wgABk +HDYMb/0gqD0Dz+zgfuB44H7gePHAsgrP7EogACDPcYAAICvPcIAAJCrPc4AAsCpIiQp1DPBEKj4L +ACGBf4AAnCq1eSyRAeUAIFAgRCo+Cy9xP2Pjj/F1PmOv989ygACMIUiKh+JG9EaOx3GAAJwqgeIB +2sIigQBVeRgRBAFMJICCTvYKIcAP63LPcAAAxRuKI0QGqQAv7kolgALsEAEB9hCAACx4L3USdZX3 +qXC+C+/sCnGA4XvyCiHAD+tyz3AAAMYbiiNECAokAARxAC/uuHUKcJYL7+ypcYDhZ/IKIcAP63LP +cAAAxxuKI4QJ7vGI4kn0QIBRIgCCRfJGjsdxgACcKoHiAdrCIoEAVXkYEQQBTCSAgsohyw/KIIsP +AADMG8ojiw8AAC4BbAfr/8oiywfsEBEBDCBApBb3KnAuC+/sCnGA4TPyCiHAD+tyz3AAAM8biiNE +DQokAAThB+/tCiVABApwBgvv7CpxgOEf8gohwA/rcs9wAADQG4ojhA7s8UwgAKDKIcEPyiLBB8og +gQ8AAMgbyiOBDwAAQAHKJAEEnAfh7colIQB9Ac/s4HjPcYAAVD1cGcAHz3GAAKQcUIGduJ64IILP +caAAyBwNoeB44HjgeOB44HjgeOB44HgAguB+8cDhxSDdz3OgAMgfsKNDGxgAANi6D+//jbixo0UB +z+zxwMYIz+yhwRpwKHZId4ogEQX6D2/0etmKIBEF7g9v9ApxiiARBeYPb/TJcYogEQXaD2/06XHP +cKAALCAwgM9wgADENyCgz3CgACwgEIDPcYAAxDcggc91gAA0NiJ4AKWLcaYPr+0KcACFEHfI9wAU +ADHEeBB26fUB2APwANitAO/socDxwEIIz+zPdaAALCBAFRAQQBUFEOu5B/QEIL6PAAYAACby7Lkk +9M92AAAQJwfwYtg+CW/0jLhAFQUQz3CgAPxEGYDsuAIlAAQD9NFwsfbXcAAAECeM9gohwA/rcoog +mgpp24y7UQbv7QokAAQ5AM/sUSAAw89woAD0B/HAK/IngBmAMHk4YAO4liBCBc9xoADIHx6hENgO +oQHYFRkYgI4O7/+B2FEgAMMV8s9wgADUXQHZIKADyKQQAQCauaQYQABKDm/+AdjPcYAA0D0NgQHg +DaED2c9woAD0Byqg0cDgfvHAANkK2M9yoADIHx6iENgOogHYFRoYgChwB/AB2QQggA8gAAAAUSAA +w8whIYDMICGAGPRRIwDAFPTPcAAAnxdOCE/0z3KgAPxEHYJZguu6ANnm9QQgvo8ABgAA4PXh8VEj +AMAV8s9wgADUXQHZIKADyKQQAQCauaQYQACuDW/+AdjPcYAA0D0NgQHgDaFRIADDANgJ9M9xgABU +PRCBAeAQoQDYmLjRwOB+4HjxwLYOr+wA2Qh3z3CgACwgQBAQAM91nwC4/x2Fz3aAAIgGPaUApgzw +9gjP7c9wDwBAQvYNr/AKcYHgEPLPcKAA1AsYgEIgAAhIIAAAEHcu9wCGHaXFBo/sAIYKIcAP63Je +2x2lz3AAAM4iiiTDD70E7+24c/HAMg6v7AHZpcEacM91gACkBlp1mglv/4twTCBAoAAUhTABFJEw +BPRAJRIRTCUAgMT2TCUAgc32CiHAD+tyz3AAACklrNtxBO/tSiRAAEwlAIA0AQ4AqHAAFo5AABaU +QEwkAKR6cIX2jCTDryj0ABYAQQAWj0AAFoBAABYAQUwkAKSGAAoAgOcn8s9wgACwEwCAQCzNILV9 +EOC4YBIJb/8E2c9wgACwEwCATCFAoB1lzCdhkxn0ANiMuBjwCiHAD+tyz3AAAColt9tKJEAA6QPv +7QolAAUKIcAP63LPcAAAKyXA2/PxANgAtc9wgACwEwCAQCzBIDV5MmA4YAUiQgRAsATdBvCBwATd +pghv/6lxACKMIwAcAhXPcIAARB7wIAAEHt/AEAIGgOIvKYEAAidAECXyMmjPc4AAF9c2eStjESOA +gwjyACaBH4AA+N4WeQAZAgUALYETCyHAgAjyACaBH4AA+N4WeQQZAgUQIgKALymBAAInQBDe9UIj +QCCA4NgGzf9eCs/x/QSv7KXA4HjgfuB48cCqDI/sz3GAAAjgQCERAVUhTgTPcIAAHCsWgADfgOBW +IU0DKA3C+AARBCEAJIEDMHU4AAYAQI2MIkOHAY0S9EKN0OIO9EON7+IM9ESNjCKChgj0RY2J4gT0 +v2AC58J/AuAdZTB1qfeA58onARHPc4AAPCsFi0AgkABVJEAEAnCMIAiAyiHND8oizQfKII0PAADC +G8ojjQ8AAJAAhALt7colDQSQd9hnR/cAIAEEegnv/AIkwgMEa9lntgjv/ApyABEBIc9wgAAcKwJx +ABlEIDkEr+z2oOB48cDhxQh1z3CAAIwhCIiH4MwgYoIF8vYMz/OA4B7yz3CAACQqAIBRIICCGPRm +CA/0gOAU8s9xgABEHgCByBAABoYgf44K9AGByBAABoYgf45gCaH9yiBBA/kDj+zPcYAAJCoAgaK4 +4H8AoeB48cBuC4/sbg/P84DgJPLPcIAAjCEIiIfgHvTPdoAAJCoAhvG4GPLPcKAASC4LgM91oAA4 +LtO454UEfweF5ngHpaYKIAAQ2AeFqL/leAelAIaxuACmgQOP7PHAGg/P84DgF/LPcIAAjCEIiIfg +EfTPc4AAJCoAg/C40SBhhAn0z3KgADguJ4KRuIi5J6IAo9HA4H7gePHA3gqP7M9woABILguAz3Wg +ADgu07jHhQR+B4XGeAelMgogABDYB4WlvsV4B6UdA4/s4Hjhxc9wgABEHgGAHtnAEAMGgOMvKMEA +AiECABPyjuIK8hJqFnjPdYAAH9cIZYHgC/IQI4OALyjBAAIhAgDw9QHYAvAA2OB/wcXPcIAAHCsW +gEIgAIDgf8ogYgDgePHA4cXPdYAAJCoAhe+4B/KvuEIJIAAApTnwJg7P84DgBPJSCs/xM/AAhfK4 +BfKyuMIK7/EApRoOz/OA4Cfyz3CAACArSIgqiEQqPgsAIYB/gACwKjV4BoiB4Bn0pg7P84DgFfLP +cIAAjCEIiIfgzCBiggbyBgvP84DgCfIAhVEggIKgD2H9yiAhADkCj+zgePHAvgmP7IoO7/MIdoDg +BvLWCa/9yXAS8M91gAAkKgCFUSCAggryz3CAAHBcAgrP/QCFqrgApe7x8QGP7ADZz3CAABwr4H82 +oM9xgAAkKgCBgrgAoQDYTQIv9oy48cBaCY/sz3CAAMRcxgnv/QDfz3CAAOBcugnv/QLdz3CAAIxc +rgnP/c9wgABwXKYJz/3PdoAAICxw3AImARNELz4XCiBALo4J7/0AIUAOQiYAHoIJ7/0CcGG9gOUB +5yv3XQGP7PHAz3KAAEQeAILPcYAAJCrIEAAGhiB/jif0AYLIEAAGhiB/jiH0A9imDe/zAaGA4AXy +9giv/QDYBfB2DA/u4g4P7gDYz3GgAMQndxkYgHgZGICAGRiAgRkYgA8RAIajuA8ZGIAE8ACBj7gA +odHA4H7xwHYIj+wIds9woADAL6UQFIYUEBOGohAShoogFQyuDy/0yXHPcaD+WAHPcJ8AuP82oEYP +r/tKIAAggOYp8sl3LynBA04hkQcA2C8hRyQPIEAEBn/PcKAAZC7wIE0EUyXNlAUgUCMQ8i8pQQNO +IYAHANkPIQEACyJAoCZ9UA+C+4Dl9PXiCq/yKnCA59r1yXCODq/7CnEk8C8ogQNOII8H738A2A8g +wAMGfs9woABkLvAgzQNTJc2UEvIvKUEDTiGABwDZDyEBACZ9QC8BFQy4JXjiCK/0AdmA5fH1gObe +9c9woADAL6UYGIUUGNiE3QdP7OB44H7geOB+4HjxwI4PT+wIdQbwz3AAAGsOpggP9M92oADAL6MW +AJZRIACB9fMHyEAeGJANyIbgBvTSDe/+qXCA8M93gAAI5gqPgOAJ8kAngBJAJYES/guv/Araz3Cg +ANQLGIBCIAAISCAAALDgcAjl/8ogJQwDyAOQJbjAuBe4x3AADgAARSABC+xwIKABEgE27HAgoCCF +7HAgoCGF7HAgoCKF7HAgoCOF7HAgoCSF7HAgoCWF7HAgoCaF7HAgoCeF7HAgoCiF7HAgoAfwz3AA +AE4O7g/P86MWAJZRIACB+PMHyAQggA8BAADwLLiU4MAghg8AAJMAz3GgAGgs8CENAM9wgAAIXsCA +2djODS/0BSZBE4IMr/EFJkATKo+A4Q7yiiBSDbINL/SHuc9xgAC8PReRAeAQeBexANgKr8EGT+yh +wfHAPg5P7KPBTMEacEh16bk6cwoiACEy8gLZz3CgAMgfSRhYgCzBU23u4VB4BvTOCS/wgcEa8Lfh +CPQbeBB4vgkv8IHBEfCU4QT0HHgK8IrhBfQEHIQwBvDPcAAA//8EHAQw4HgA2M9yqQCk/7miBBQB +MYK4N6Iaognw6Lk38kwiAKDRIOKhBfLPdaAAyB9M8M9ypQCs/89wgABEHriiBIBWEAABFOACIQMg +A+Miu3hjeGBIIEAABbhFIEADFqJBKMAhwLh3aCzABCGBDwAAACAluc91oADIH2V4JXiJuI64GaJA +FQAWIPAswIDgyiHBD8oiwQfKICEOzyAhA8ojIQXPIyEDyiQhALwDoe3KJcEABb2leM9xpQCs/xah +z3WgAMgfQBUAFs92oAC0R1cWAZZKIwAgSiRAIAQhvo8AKAAAz3GAAKQcMIEggcIkAiUF8LLYKg7v +84y4bxYAlkwkAKAEIIQPgAAAAAQggg8gAAAABCCDDwAGAAAG8kAVARaD4YT3ANkD8AHZExUPlgQg +vo8AOAAABCePHwAAAIDMISGAwCNhIAUiAQHleQUh/oAF9EwjQKKeB87/gOcF8oDizCMhgJPyaxYT +lkwjAKBP8mp0hCTQkQvyz3GAAFw8EIEA3QHgEKGcvWPwUSPAoAryz3GAAFw8EYEB4BGhQt1Z8Gp0 +hCQCmAnyz3GAANA9EYEB4BGhDvBRI4ChCfLPcYAA0D0EgQHgBKEE8FMjPqME8gDdP/BRI0CjCvKe +CM/8z3GAAEw+BYEB4AWh9PEqDw/yCiHAD+tybxYFlkTYjLjp24y7ZQKv7QokwASA4gjyz3GAAFQ9 +EIEB4BCh3PGA4y7y+rgL8s9ygADQPS+CAN0B4S+ikb0K8Pm4EvLPcoAA0D0ygkLdAeEyomoLr/9q +cd3YANnmCi/0mLmYvUnwcRYElm8WBZYKIcAP63I52M9zAAACEfUBr+2MuP4Pj/zPcYAAVD0RgQHg +EaGk8RMVAJbwuMogIQBECqH/zyChA2sWAZZYFgCWCyBAgCDybxYAls91oAD0B1MgQIAB2BDyCaXg +eADYCaXPcYAATD4IgQHgCKHPcZ8AuP8WoeIJL/4B2APYCqUF3Zi9A/AA3YDlGPRRIMChDPJMIgCg +DfQB2c9woAD0ByygA9kG8APZz3CgAPQHJaBRIICi8AoC+B/wAxIBNs9wgAAI4hBxBvLPcIAA0OIQ +cQz0khEAAaq4khkEAJ4RAAGquJ4ZBADPcaD+ZADPcJ8AuP82oM9wgADkBgCAgOAH8s9xgADAJAWB +InAFoc9xgABcPA+BAeAPoc9wgADMsyGAz3CAAEQeA4AUkBBxDvTPcYAA6BUagTuBJHhRIACCdAvi +9MogYgCpcAjciwJv7KPA4HihwfHAOgpP7Ch1CHYacgQhvo8BAADAaHct9Oi9FfJEJQAWI7ghaAQl +gB8GAAAAMbg4YAQlgR8GAAAB13ECAAAByiChAALwAdiB4BDyguAJ8oPgANjKIOEBwCihAwrwz3CA +APTBAoAG8M9wgAD0wQGABX3JcFYOr/ipcclwqXEKculzbgvv/0okQACA4FAKgf8I3BMCT+zgeM9w +pACQQU2Az3GAAGjEQrEagFEgQMYDsQQggA//AAAAMLgEsc9wgABoxADaCPLPcYAAVMMygVEhgIIF +8kKwQ7BEsOB/WbDgePHAYglv7Jhwz3CAAFTDDpDPdoAAaMQAts9wgABUw0gQBQAEJY+PAAAAAgDb +BPJRJQCCCvLPcaYA6P8LgQOmDIEEpgTwZKZjps91pAC0RQwVApYNFQCW/9kvIIcQgOcQuQQiSQAs +8jIVAZZTIY8A/2chtv/Z9H8Iue9/RHlALwYSACZHAAAgyBMFJwcCQC8BFgQigg8A/wAAQC8IFDpi +ACBIEv/ZBScHAgi5BSLCAQQgRwD4YAAngQEleOW2T3kEIoIP/wAAACi6RXkjtg94BLYEFQCWUSUA +ggK2EPJEJQAGI7gB4IHgyvfPcaYA6P8NgQWmDoEGpgTwZqZlpgDaSiSAcAbZjbmoIEADKdgSuPAg +QwBAJgAfVXgB4WCgAeLPcIAAVMMAkDgeABFVJkEUGrbPcIAAQMS+DW/8CNobFQCWz3GlANjLGaYc +FQCWGqYdFQCWG6YOgRymD4EdpiYVAJYeps9wpACQfxyAYQBv7B+m4cXPdYAAaMQJpSqleLVLpQHY +GbXgf8HFSiQAegDZqCCAAgDaz3CAAGjENXhAoAHh4H4AAAIAAAAAQAEAAAAAAKgSQ3UBBgABAAAA +AAAAAACIPoAAHD+AAACWgAB8HIAAXAiAAIwFgIEPGhsiAAAbJQIAG0AAABtxMAaAgQAAwBYPGwsi +NAaAgQAAwBYPGwoiOAaAgQAAwBYPGwgiSCWAgQIAXG4RAABh+EHEEA8bCSIACwk5AgAKYgMBCmIE +AgpiAAAJQAQAAGEJAAlAAgAAYQoACUAAAABhAgAJQQAJGigAAMAWAQAbJgAAwBcEAB0mAQAIJ+kA +CGQPIBsiOAaAgQAAwBeMBYCBDxobIgAAGyUCABtAAAAbcQ9FACIAXAA5BwAAYgZgAGIAAFg4YEXA +EHBFwBB4RcAQkEXAEGwAAGEIAFhu+A8AYQAAEyUAABMkJBDAEYAAEyVHaBMkBCjAEQCAEyQ4HMAR +DwATIgEAEzAEKMARD3MTIoIBEzAEKMARD3QTIgICEzAEKMARD3UTIkICEzAEKMARDxQVIgEAFSYP +chMiCADMEQ9EACIKAABAAEAAcA4AAGEAABMlAgATJOwcwBEPdhMiGAjKEQkAE0AcCMoRCQATQCAI +yhEPeBMiBADKEQAAASQAAAElBgAAYQ92EyIsSMcRD3gTIgAAxhEDAAEkAAABJQAAEyXCLBMkBCjA +EQJGEyQEKMARwl8TJAQowBEPRQAiAFwAOSwAAGQAABMkAQATJTgcwBEPdxMi4BzAEQIAAWIPARMi +BAjAERgGwBIEKMARDxMCIhwGwBIEKMARDxMHIiAGwBIEKMARDxMEIgIAcXAHAABh/wATJQIQEyQE +KMARAAATJQAAEyTISccRBgAAYQAAEyUCEBMkBCjAEQAAEyVJABMkyEnHEQ9wEyIBABMwBCjAEQMA +EyQAABMlBAjAEQAAEyQ4RcARJAbAEhgowBEPEwMiBAAAYQAAWDgAABMkAQATJTgcwBEAABUkAAAA +IQQGgIEAAMAWDxtQIggGgIEAAMAWDxsaIgwGgIEAAMAWDxsZIhAGgIEAAMAWAAAAhQAGgIEAAMAW +DxsEIhwEG2YbARtoFBzAEAoAG0AEABtuCwAAYQ8cHSIBAB0m+Q8AYRQGgIEAAMAWBQAbYowFgIEP +GhsiAAAbJQIAG0AAABtxZAwAEADABhEBAAQn/AAEZAAAGyQCABslOBzAEYwFgIEPGhsiAAAbJQIA +G0AAABtxAAAbJUAAGyQwHMARjAWAgQ8aGyIAABslAgAbQAAAG3GgBoCBAADAFgIBE2RCARMkBCjA +EdRdgIEAAMAWBgETYgQIwBAEABNkD1wAIgoAAEAABgBwGQAAYQAAEyQAABMlAADAFwAIWDDIIMAQ +cEXAEBAIwBAAABMlAwATJBwIwBEcCMARAAATJAQIwBEPFBUiBAAVJvv/MDIDABMkGAjAEQ8UFSIC +ABUmBAAwMAAAEyQQRcARGAjAEQAQWDAPfBMiCADMEQAAEyUAABMkNEjHEQ97EyIBABMwBCjAEQ8U +FSICABUm/wATJQIQEyQEKMARDxQVIgIAFSaYB4CBAADAFsIsEyQEKMARAkYTJAQowBHCXxMkBCjA +EQ9NEyIEEMURAgATJPAcwBEBABMk7BzAEQAAEyRwABMlEBzAEQAAEyUAABMk4BzAEYAAEyVGaBMk +BCjAEQAAEyUBABMkJBDAEQAAFSQAAAAhDw4aIgAAQBYAARtwDQAAYYAAYyT//hsyAABAFwAAGyUP +Gw8icAaAgf8AGzICABtBABsaKAAAwBYAABslAgAbQAAAG3EBAGRwBwAAYQEAYyQAABskUgaAgQAA +QBdIBoCBAABAFu0PAGECAGRwEAAAYQIAYyQBABskUgaAgQAAQBdKBoCBAABAFuQPAGEEAGRwBwAA +YQIAYyQCABskUgaAgQAAQBdMBoCBAABAFtsPAGEAAB0kAAAAIQACD24JAABhUgaAgQAAQBYAABsl +TgaAgQAbGigAAAAWAQAbJgAAABcNAABhaAaAgQAAQBYCABsmARAbaAAAGyQAAEAXVAaAgQAaGygP +Gw4ibAaAgQAAQBYBABsmAABAF9QEgIEPGhsiAAAbJQIAG0AAABtxAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALwCgAA8AIAAAAAAAAAAAAAoAIAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAQqYAADAYAABCpgACc2gAACQ0RFAoNExcZGRkZCQkAACikgACw +fgAAEKmAAAAAAAAQqYAAAAAAACzFgADYfgAAMIAAAAAAAAAxgAAAiIgzMzKAAAAAqqqKM4AAAAAA +AAA0gAAAAAAAADWAAAAAAAAANoAAAAAAAAA3gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6gAAAAAAA +ADuAAAAAAAAAPIAAAAAAAAA9gAAAqqoKAD6AAABThYiIP4AAAAAAADAwgAAAAAAAADGAAACamVhV +MoAAAACqqqozgAAAAAAAADSAAAAAAAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5 +gAAAAAAAADqAAAAAAAAAO4AAAAAAAAA8gAAAAAAAAD2AAACqqgoAPoAAAFWYmao/gAAAAAAAUDCA +AAAAAAAAMYAAAAAAAAAygAAAAAAAADOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaAAAAAAAAAN4AA +AAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAAAAAAAAA+gAAA +AAAAAD+AAAAAAAAAMIAAAAAAAAAxgAAAAAAAADKAAAAAAAAAM4AAAAAAAAA0gAAAmnkAADWAAACq +qqqqNoAAAAAAAAA3gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6gAAAqqqqCjuAAAAAcJmqPIAAAAAA +AAA9gAAAAAAAAD6AAAAAAAAAP4AAAAAAAAD//wAAtAAgABkBIAC1ACEAGgEhAAQACADUAQMAswEE +AHgAPADdADwAeQBqAN4AagCoAAEADQEBAJwBzACdAcwA1QHMANYBzACkAYAAXQI2AEoCDQBMAg8A +TQIBAK0BBgC4AQAAuwFWAI8AiAD0AIgAkAAAAPUAAACRAAYA9gAGAIUABADrAAQAUAILAFECAwBS +AgEAUwIAAFQCCwBVAgMAVgIBAFcCAAC5AcEA0AEAAGYCBgBoAgcAagIGAGwCBwBuAgUAcAIMAH0C +BgB/AgcAgQIGAIMCBwCFAgUAhwIMAKEBQAD7/wAA//8AALQAIAAZASAAtQAhABoBIQAEAAgA1AED +ALMBBAB4ADwA3QA8AHkAagDeAGoAqAABAA0BAQCcAcwAnQHMANUBzADWAcwApAGAAF0CMwBKAg4A +TAIOAE0CAQCtAQcAuAEAALsBVgCPAIgA9ACIAJAAAAD1AAAAkQAGAPYABgCFAAQA6wAEAFACCwBR +AgMAUgIBAFMCAACUAgsAlQIDAJYCAQCXAgAAVAILAFUCAwBWAgEAVwIAAJgCCwCZAgMAmgIBAJsC +AAC5AcEA0AEEAGYCBgBoAgcAagIGAGwCBwBuAgUAcAIMAH0CBgB/AgcAgQIGAIMCBwCFAgUAhwIM +AEsCAQChAUAAsgAwABcBMACzAAAAGAEAAJwCDwChAg8AoAKIAJ8CiACeAogAnQKIAKUCiACkAogA +owKIAKICiAD7/wAAAAAAAAIAAAAN0hLSE9IU0gzSFdIL0gLSEdIEQwAQFBAJEBEQAUAb0hzSANIK +AAsABAAOALUAGgEPAEIAvADDACEBKAG2ALcAuAC5AL0AvgC/AMAAGwEcAR0BHgEiASMBJAElAREA +AAAKAAAACgAAALYAAAC3AAAAuAAAALkAAAC2AAAAtwAAALgAAAC5AAAAvQAAAL4AAAC/AAAAwAAA +AL0AAAC+AAAAvwAAAMAAAAAS0gAAEtIAAAAAAgAsAGQAdACAAIwAoQAHAAAAAAABAAIAAwAAAAAA +txMiALgUIwC5FSQAuxYlALwXJgC9GCcAwBkoAMQaKQAHGwAACBwBAAsdAgAMHgMAEB8EACIhBQAk +IgYAJiMHACgkCAAqJQkALCYKAC4nCwAwKAwANCkNADgqDgA8Kw8AQCwQAGQuEQBoLxIAbDATAHAx +FAB0MhUAeDMWAHw0FwCANRgAhDYZAIg3GgCMOBsAkTocAJU7HQCZPB4AnT0fAKE+IAClPyEAJEkG +AixKCgI0Sw0BPEwPAWRNEQFsThMBdE8VAXxQFwGEURkBlVIdAZ1THwEBBAAAAgUBAAMGAgAEBwMA +BQgEAAYJBQAHCgYACAsHAAkMCAAKDQkACw4KAAwPCwANEAwADhENAAFAAAQCQQEEA0ICBARDAwQF +RAQEBkUFBAdGBgQIRwcECUgIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAABAHAAARBwAAEwcAADIGwAAzBsAADQMoABADKAAHBygAEAgoAAo +JKAAbBCgABgkoAB4JKAAfCSgAIAkoACEJKAAUBCgAFQQoABIJqAAYBCgAEwmoABkEKAAaBCgAFwQ +oABYEKAAMBCgADwQoAA0EKAALAygAACBpAABgaQAA4GkAIgkoACMJKAAkCSgAJQkoACYJKAAnCSg +AKAkoACkJKAAgHOAAAAAAACyDCwB/////////wAB//8CA////wT//////////////////////wX/ +Bv8H/wj/Cf8K/wv/DP///w3///8O////D////xD///////////////////////////////////// +/////////xH///8S////E////xT///8V////Fv///xf///8Y////Gf///xr///8b/////xz///8d +////Hv///x////8g////If//////////////////////IiMk/yUmJ///KP///yn///////////// +/////////////////////////////////////////////////////////////////wABAAEBAAAA +AAAAAAABAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAA+FMBAAAAAABodAAAAQAAAKQOAgAC +AAAA/A0CAAMAAACYcQIABAAAAPhTAQAFAAAAgDwBAAYAAAD4CAEABwAAAAg9AQAIAAAAXDwAAAkA +AAA0ZwAACgAAAPTcAAALAAAATDUAAAwAAACccQIADQAAACD+AAAOAAAA1P4AAA8AAACs/QAAEAAA +ALD+AAARAAAAsGQBABIAAADAMgIAEwAAAAgmAAAUAAAAnIwBABUAAAAsdQEAFgAAACSFAQAXAAAA +JA0CABgAAACEtwEAGQAAACgqAQAaAAAA9FMBABsAAAAAFAUAAAAAAAAAAAAAAAAAAAAAAP8A/wAA +AAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////// +/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAzKAAAMygAADMoAAACIcAAMygAADMoAAAbIcAAMygAADMoAAAzKAA +AMygAADMoAAAzKAAAMygAADMoAAAzKAAAPiPAAA8jwAALI8AAFSOAABkjwAAEI4AAMygAADMoAAA +VJYAAAiaAAAknAAAzKAAAMygAADMoAAANKAAAFiVAACQlQAA/JQAAMygAADMoAAAzKAAAPCfAADM +oAAA3JQAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMyg +AADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAA +AMygAADMoAAAzKAAAMygAADMoAAAMIgAAMygAADMoAAAzKAAAMygAADMoAAAQJ0AAMygAADMoAAA +zKAAAMygAADMoAAAiIsAAMygAACYiwAAlIsAAIyLAACQiwAArIQAAMygAABkhAAAzKAAAMygAADM +oAAAzKAAAMygAADMoAAAzKAAAMygAADogwAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMyg +AADMoAAAzKAAAMygAACYiQAAEIkAAMygAAC0iQAAzKAAAFCIAADUjQAAzKAAAMygAAAYkAAAzKAA +AMygAADMoAAAzKAAAMygAACckQAASJAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAA +zKAAAMygAADMoAAAnIsAAMygAADMoAAAzKAAAOScAADMoAAAzKAAAMygAACEnwAAzKAAAOifAACA +nAAAzKAAAMygAADIggAAQJwAAMygAADMoAAAXI4AAHSOAADMoAAAzKAAAESLAAD8hAAAzKAAAMyg +AADMoAAAmJUAAPiNAADMoAAAzKAAAMygAADMoAAAzKAAAMygAAAwjQAAzKAAALChAADwowAAJKMA +APijAAAcowAAFKMAAACkAADwoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAABMiwAA +zKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAJSkAACopQAAEIMAAFyDAADMoAAAzKAAAMygAADM +oAAAzKAAADCFAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMyg +AADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAAAMygAADMoAAAzKAA +AMygAADMoAAANIUAAFSGAADEhQAACKQAAHSDAADghgAAeIcAAMygAADMoAAAzKAAAMygAABkhwAA +aIcAAMygAADMoAAADIcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGizAACUsQAA4LQAANyzAAD0tQAAAAABAP// +//8AAAAA//////////8BAAAAEA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAADQ +/gAAAAAAAAAAAwMDAwQEBAUFBgAAGCCgACAgoABAIaAASCGgABwgoAAkIKAARCGgAEwhoAAoIKAA +MCCgAGghoABwIaAALCCgADQgoABsIaAAdCGgADggoAA8IKAAeCGgAHwhoAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMQN +AAAA/wMAZA4AAAD/BQAIDgAAAP8tAOQNAAAA/z0AgA0AAAD/BACoDQAAAP8lALDgAAAA/90ALA4A +ABAQTAAAAAAAAAAAAAABAQA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8 +FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAAPDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwV +FRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8 +PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAABAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFgQAACwFwAA4BMAADwRAAB8GQAA8BQAAJgW +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAA0B4AAuKmAABgAAAB4qYAAAAAAAAAAAAAAAAAAAAAAAFgnAQCIwgAAaCMAAIjCAACI +wgAAiMIAABAHAAC0KgIAVO4AAIjCAACIwgAABCoAAAQqAAAEKgAABCoAAAQqAAAEKgAABCoAAIjC +AACIwgAAiMIAAIjCAAAUWAAAiMIAAIjCAACIwgAAiMIAAIjCAAA47gAAiMIAAIjCAADs3wAAAAAA +ABQNAQAYDQEAtAIAAKACAAAcZAEAAAAAAMjRAACw9wEA8NEAAOD3AQAU0gAAEPgBADg2gACknoAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAFAAYA +BwAIAAgACQAKAAoACwAMAAwADQAOAA4ADwAmACcAKAApACoARgBGAEcASABIAEkASgBKAEsATABo +AGkAagBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0AHQA +dAB0AHQAdAB0AHQAdAB0AAoAPwAAAIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAFAAYABwAI +AAgACQAKAAoACwAMAAwADQAOAA4ADwAmACcAKAApACoARgBGAEcASABIAEkASgBKAEsATABoAGkA +agBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0 +AHQAdAB0AHQAdAB0AAoAPwAAAAAAvCEAAIQhAAC8qoAAAAIAAAAAAADcHAEArBwBALysgABABQAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BwBAMxgAQBMs4AAVAAAAAAAAADcHAEAoF8BAPyxgABQ +AQAAAAAAANwcAQCIWQEAhAeAAAgAAAABAAAA3BwBAKgbAQAAAAAAUAEAAAAAAADcHAEAFFoBAMwu +gAACAAAAAAAAANwcAQAgWQEAgAeAAAQAAAAAAAAA5BwBAKwcAQCgs4AAKgAAAAAAAADcHAEArBwB +AHw+gAAIAAAAAAAAAAAAAAC0HAEAAAAAAAAAAAABAAAAAAAAAMgcAQAAAAAAAAAAAAAAAAAAAAAA +sBwBAAAAAAAAAAAAAAAAANwcAQBk+gEAAAAAAAAAAAAAAAAA3BwBACT6AQCMB4AABAAAAAAAAABu +AG4AaQDAAKAAUACAAL4AUAF9AD4AAQABAAEAWAIoAOYBLQBVAzwA3AFjAAAAbgBuAGkAwACgAFAA +gAC+AFABfQA+AAEAAQABAFgCKADmAS0AVQM8ANwBYwAAAAAAAAABAQAATCYBABXSAAAAAAAA/wMA +AEwmAQAM0gAAAAAAAP8BAABMJgEAFdIAAAoAAAAA/A8ATCYBAAzSAAAJAAAAAP4DAEwmAQAV0gAA +FAAAAAAA8D9MJgEADNIAABIAAAAAAPwHTCYBAAbSAAAAAAAA/wEAAEwmAQAH0gAAAAAAAP8DAABM +JgEABtIAAAkAAAAA/gMATCYBAAfSAAAKAAAAAPwPAEwmAQAG0gAAEgAAAAAA/AdMJgEAB9IAABQA +AAAAAPA/AAAAAAAAAAAAAAAAAQAAAAEAAAAKAAAABQAAAAUAAAAGAAAACgAAAAoAAAAGAAAABAAA +AAUAAAAGAAAABQAAAAUAAAAGAAAABgAAAAYAAAAGAAAABwAAAAcAAAAHAAAACAAAAAgAAAAIAAAA +BAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAEAAAACAAAAAQAAAAEAAAADAAAAAwAAAAIAAAAB +AAAABAAAAAAAAAAAAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAEAAAAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAAAAAA +IDUBAMw6AQB4OQEAUDsBAMg6AQCYOAEATDsBAIw2AQCINgEAYOMWACDWEwAAAAAAEAAAAACAAAAA +AKAAECcAAOgDAADoAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgAAAAEAAAABAAAAAgAA +AAUAAAACAAAAAgAAAAUAAAACAAAAAgAAAAEAAAABAAAABQAAAAUAAAACAAAABQAAAAUAAAAAAAAA +BQAAAAIAAAACAAAAAAAAAAAAAAAAAAAABQAAAAUAAAAAAAAABQAAAAIAAAACAAAABQAAAAUAAAAF +AAAAAAAAAAUAAAACAAAABQAAAAEAAAABAAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAABQAAAAEA +AAABAAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAAAgAAAAUAAAABAAAAAgAAAAUAAAACAAAABQAA +AAUAAAAEAAAABQAAAAUAAAABAAAABQAAAAUAAAAFAAAAAgAAAAIAAAAFAAAABQAAAAUAAAABAAAA +BQAAAAUAAAAFAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAA +AAAAAAAACAAAAAAAAAABEAABAAAAAoAAAUIABgIQAAIgAAADwAABQwAGAxAAAsAAAAPAAAFDAAYE +EAACQAAAAoAAAUQABgURAABAAAADwAABRQAGBhEAAOAAAAPAAAFFAAYHEQABAAAAAoAAAUYABggR +AAIgAAADwAABRwAGCREAAsAAAAPAAAFHAAYKEQACQAAAAoAAAUgABgsSAABAAAADwAABSQAGDBIA +AOAAAAPAAAFJAAYNEgABAAAAAoAAAUoABg4SAAIAAAACgAABTAAGAXgAMAAAAFAAAAS2PAYCeABE +AAAAUAAABLk8BgN5AAgAAABQAAAEuzwGBHkAHAAAAFAAAAS+PAYFeQAwAAAAUAAABMA8BgZ5AEQA +AABQAAAEwzwGB3oACAAAAFAAAATFPAYIegAcAAAAUAAABMg8Bgl6ADAAAABQAAAEyjwGCnoARAAA +AFAAAATNPAYLewAIAAAAUAAABM88Bgx7ABwAAABQAAAE0jwGDXsAMAAAAFAAAATUPAYOfAAQAAAA +UAAABNo+BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQEAAAEAAQACAQAAAgABAAIBAAACgICAgICAgIAB +gAKAgICAgMAAkADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAA +AAYAAAAGAAAABgAAAAYAAAACAAAABgAAAAYAAAAHAAAABgAAAAYAAAADAAAAAQAAAAcAAAAGAAAA +AgAAAAYAAAAGAAAABwAAAAYAAAAGAAAAAAAAAAQAAAAHAAAABgAAAAQAAAAGAAAABgAAAAIAAADQ +4wEAAOUBAKzmAQBM5QEAMOcBANTiAQAAAAAAbgAAAG4AAgBuAG4AbgACAGkAaQBuAAEAwADAAOgA +AQCgAKAANgEDAFAAUAD1AAEAgACAAOgAAQC+AL4AvgABAFABUAFQAQEAfQB9AK8AAwA+AD4APgAB +AAEAAQABAAEAAQABAAEAAQABAAEAAQABAFgCWAJYAgEAKAAoACgAAQDmAeYB5gEBAC0ALQAtAAEA +VQNVA1UDAQA8ADwAPAABANwB3AHcAQEAYwBjAGMAAQAAAAAAAAAAADIABQAyAAUAAgAIAGQAoAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAP8AAAAAAAAAjAqMCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAACAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BwCABUAAAADAAAADF2AAAAAAAAAAAAAAAAA +ABQWAgAGAAAAAAAAACxdgAAAAAAAAAAAAAAAAACEHAIABQAAAAMAAAAMXYAAAAAAAAAAAAAAAAAA +eBwCAAoAAAADAAAADF2AAAAAAAAAAAAAAAAAAEAZAgAEAAAAAAAAACxdgAAAAAAAAAAAAAAAAABA +GQIABAAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAQBkCAAQAAAAAAAAALF2AAAAAAAAAAAAAAAAAAEAZ +AgAEAAAAAAAAACxdgAAAAAAAAAAAAAAAAABAGQIABAAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAMBoC +AAYAAAAAAAAALF2AAAAAAAAAAAAAAAAAAGgaAgAEAAAAAAAAACxdgAAAAAAAAAAAAAAAAABoGgIA +BAAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAaBoCAAQAAAAAAAAALF2AAAAAAAAAAAAAAAAAAGgaAgAE +AAAAAAAAACxdgAAAAAAAAAAAAAAAAAAwGgIABgAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAMBoCAAYA +AAAAAAAALF2AAAAAAAAAAAAAAAAAADAaAgAGAAAAAAAAACxdgAAAAAAAAAAAAAAAAABoGgIABAAA +AAAAAAAsXYAAAAAAAAAAAAAAAAAAaBoCAAQAAAAAAAAALF2AAAAAAAAAAAAAAAAAAFQXAgAKAAAA +AAAAACxdgAAAAAAAAAAAAAAAAAA8GQIACgAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAPBkCAAoAAAAA +AAAALF2AAAAAAAAAAAAAAAAAADwZAgAKAAAAAAAAACxdgAAAAAAAAAAAAAAAAAA8GQIACgAAAAAA +AAAsXYAAAAAAAAAAAAAAAAAAPBkCAAoAAAAAAAAALF2AAAAAAAAAAAAAAAAAADwZAgAKAAAAAAAA +ACxdgAAAAAAAAAAAAAAAAAA8GQIACgAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAPBkCAAoAAAAAAAAA +LF2AAAAAAAAAAAAAAAAAADwZAgAKAAAAAAAAACxdgAAAAAAAAAAAAAAAAAA8GQIACgAAAAAAAAAs +XYAAAAAAAAAAAAAAAAAAPBkCAAoAAAAAAAAALF2AAAAAAAAAAAAAAAAAADwZAgAKAAAAAAAAACxd +gAAAAAAAAAAAAAAAAAD0HgIABgAAAAAAAAAsXYAAAAAAAAAAAAAAAAAARB4CAAUAAAADAAAADF2A +AAAAAAAAAAAAAAAAAEQWAgAKAAAAAAAAACxdgAAAAAAAAAAAAAAAAADkFgIACgAAAAAAAAAsXYAA +AAAAAAAAAAAAAAAAXDECAAoAAAADAAAADF2AAAAAAAAAAAAAAAAAAKAXAgAKAAAAAAAAACxdgAAA +AAAAAAAAAAAAAACMGAIACgAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAJBsCAAoAAAAAAAAALF2AAAAA +AAAAAAAAAAAAAOAbAgAKAAAAAAAAACxdgAAAAAAAAAAAAAAAAADkHAIACgAAAAAAAAAsXYAAAAAA +AAAAAAAAAAAAiB0CAAoAAAAAAAAALF2AAAAAAAAAAAAAAAAAAOAdAgAGAAAAAAAAACxdgAAAAAAA +AAAAAAAAAADwHQIABgAAAAAAAAAsXYAAAAAAAAAAAAAAAAAAFB4CAAoAAAAAAAAALF2AAAAAAAAA +AAAAAAAAABgeAgAKAAAAAAAAACxdgAAAAAAAAAAAAAAAAAA8HgIAAQAAAAAAAAAsXYAAAAAAAAAA +AAAAAAAANCACAAoAAAABAAAATF2AAAAAAAAAAAAAAAAAAKgfAgAFAAAAAQAAAExdgAAAAAAAAAAA +AAAAAABMIwIABgAAAAEAAABMXYAAAAAAAAAAAAAAAAAAoCMCAAYAAAABAAAATF2AAAAAAAAAAAAA +AAAAAMAmAgAKAAAAAQAAAExdgAAAAAAAAAAAAAAAAAAAAAAADF2AAAxdgAC4IKAAbCCgAACAAQD/ +f/z/AAAAAAAAAAAsXYAALF2AAKQgoAA4IKAAAQAAAPz///8AAAAAAAAAAExdgABMXYAAqCCgADwg +oAAQAAAAx////wAAAAAAAAAAbF2AAGxdgACsIKAAeCGgAEABAAA//v//AAAAAAAAAACMXYAAjF2A +ALAgoAB8IaAAAAwAAP/x//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYFwIAFQAAAAMAAAAMXYAA +AAAAAFAAAAAAAAAANAeAALipgAAYAAAAeKmAAAAAAAAAAAAANAeAALipgAAYAAAAeKmAAAAAAAAA +AAAAAAAAADQHgAC4qYAAGAAAAHipgAAAAAAAAAAAAAAAAAB/AAAAAAAAAAB/AAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAD/AAD//wAAAQAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAECAwQEBAQEBQYHCAgI +CAgJCgsMDQAAbjtoO2I7XDtuOmg6YjpcOm45aDliOVw5bitoK2IrXCtuKmgqYipcKm4paCliKVwp +bihoKGIoXChuJ2gnYidcJ24maCZiJlwmbiVoJWIlXCVuJGgkYiRcJG4jaCNiI1wjbiJoImIiXCJu +IWghYiFcIW4gaCBiIFwgYhNcE24SaBJiElwSbhFoEWIRXBFuEGgQYhBcEG4CaAJiAlwCbgFoAWIB +XAFuAGgAVAAAAG47aDtiO1w7bjpoOmI6XDpuOWg5YjlcOW4raCtiK1wrbipoKmIqXCpuKWgpYilc +KW4oaChiKFwobidoJ2InXCduJmgmYiZcJm4laCViJVwlbiRoJGIkXCRuI2gjYiNcI24iaCJiIlwi +biFoIWIhXCFuIGggYiBcIG4SaBJiElwSbhFoEWIRXBFuEGgQYhBcEFcQUhBNEEkQbgFoAWIBXAFu +AGgAYgBcAFQAAAAAAAAAAAAAAB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAACH8BAAgAAAADAAAADF2AAKAIgAAgCYAAoAmAACAKgAAKDREUCg0RFBkZGRkKCgAAAAAA +AAYGBgYJCQkJAAYAAAAFBgcIDQ4PEBUWFxgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADxqsrCUv +rKysrKylrH6RTkMMmzYAAAA3AJqSj0gAAA8AIGg3AAAAEQA+OiARAAACJQAADC8AAAIvOTkACiU8 +ukdxjQAHFy1pNAAAAgAXAAAFEAogMEAAAAYGCgAFCg8NJBwkIgAAAABHmK+vSQAADBAUGCAIBAAA +PDg0MCwoJCAcGBQQDAgEAAsHAwA7NzMvKycjHxsXEw8LBwMxNjozMTo1MAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiAAAAEAAAAB0AAAA3AAAAbwAAAKAAAABwAAAABQAA +APYAAABaAAAAHwAAAEgAAAAgAAAASAAAAAgAAAABAAAAMwAAAH8AAAA0AAAAfwAAADcAAAABAAAA +OAAAAE8AAAA7AAAAfwAAADwAAAB/AAAAMQAAAAAAAAAyAAAAAAAAADUAAAAAAAAANgAAAAAAAAA5 +AAAAAAAAADoAAAAAAAAADQAAACoAAAAOAAAAegAAAA8AAAAQAAAA8wAAAEgAAAD0AAAASAAAAAAA +AAABAQEBAQEBAQICAgICAgICAwMDAwMDAwMBAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAF +AAAAoQMOHuEAAAChAw4e4QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAChAw4e4QAAABX2Y/aw9vz2RveQ99j3H/hl+Kn47fgv+XD5sPnu+Sv6Z/qi ++tz6FPtL+4H7tvvq+xz8Tfx9/Kv82fwF/TD9Wf2C/an9z/30/Rf+Of5a/nr+mP62/tL+7f4G/x7/ +Nf9L/2D/c/+F/5b/pv+0/8H/zf/Y/+H/6f/w//b/+v/9//////////3/+v/2//D/6f/h/9j/zf/B +/7T/pv+W/4X/c/9g/0v/Nf8e/wb/7f7S/rb+mP56/lr+Of4X/vT9z/2p/YL9Wf0w/QX92fyr/H38 +Tfwc/Or7tvuB+0v7FPvc+qL6Z/or+u75sPlw+S/57fip+GX4H/jY95D3Rvf89rD2Y/ZwuYO6lruq +vL690r7nv/zAEcInwz3EU8VqxoDHl8ivycbK3sv2zA/OJ89A0FnRctKM06bUv9Xa1vTXDtkp2kTb +X9x63Zbesd/N4OnhBeMh5D7lWuZ355PosOnN6urrB+0k7kLvX/B98ZryuPPV9PP1Efcv+Ez5avqI ++6b8xP3i/gAAHgE8AloDeASWBbQG0QfvCA0KKwtIDGYNgw6hD74Q3BH5EhYUMxVQFm0XiRimGcIa +3xv7HBceMx9PIGohhiKhI7wk1yXyJgwoJilBKlordCyOLacuwC/ZMPExCjMiNDo1UTZpN4A4ljmt +OsM72TzvPQQ/GUAuQUJCVkNqRH1FAAEBAgECAgMBAQEBAQEBAQICAgICAgICAwMDAwMDAwMEBAQE +BAQEBAECAgICAgIDAwMDAwMDAwMDAwMDAwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAKQ0AADw +NgAAJDEAACQwAACkMAAAxDUAAOwvAADsNQAAbDYAADoBAgHVAN8A2gCiAHUAfwCKBSoDOQGoAYoF +ygLZAEgBAQMPBwoUN25qARoB2QDoAAoBugB5AIgAygFKAeIA+QDKAeoAggCZAHTRRRfooosuAAUH +AQMEAAUBBQAAAAUGAAIEAAUABQAAAQIBAgMEAAAFBgcICQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApNwAAGjfAAB42gAAAQAAAAAAAAAB +AAAAAgAAAAMAAAAAAAAABAAAAAIAAAAFAAAABwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH +BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBgYGBgYFBQUFBQQEBAQEAwMDAwMCAgICAgEBAQEB +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgA +KAAwACwALAAoADwANABAADwAjABsAFgASAD0ALAAf/8HDx8/AQMwAAAANgAAAAwAAAASAAAAGAAA +ACQAAAAGAAAACQAAAAUABwIDBAYGQAOABsAJAA2AEwAaQB2AIIAGAA2AEwAaACcANIA6AEHACYAT +QB0AJ4A6AE7AV4BhmQMzB9kKcw6mFeYcgCAZJDMHcw6mFeYcWSvMOQBBM0jZCqYVgCBZKwBBplaA +YVlsndiJnU7sxE40SIM0J3ZiJxqkQRoTO7ETERiBEQ/8wA9O7MROJ3ZiJxqkQRoTO7ETDdIgDYmd +2AkIjMAIB37gBzRIgzQapEEaERiBEQ3SIA0IjMAIBmmQBrCy1QUFVEAFJ3ZiJxM7sRMN0iANiZ3Y +CQZpkAbETuwEBEZgBAM/8AOqqqqqGqRBGhM7sRMP/MAPERiBEQ3SIA0KqIAKEzuxEw/8wA8P/MAP +DdIgDQu0QAsLtEALiZ3YCQ3SIA0KqIAKCqiACgiMwAgHeIAHB3iABwZpkAYP/MAPDdIgDQu0QAsN +0iANC7RAC4md2AkIjMAIiZ3YCQiMwAgHfuAHB37gB8EsKQcKqIAKCIzACAd4gAcIjMAIB3iABwZp +kAawstUFBmmQBrCy1QUFVEAFBVRABdYdxgQBBw8fP3///2bmAAAFBgECAwQAAFQAVABsAGAAXABU +AIwAeAANDwUHCQsBAygAKAA0ADAALAAsAEQAPAAsACwAPAA0ADAALABUAEQAVVVVAUtoLwFVVVUF +4ziOA6qqqgJxHMcBqqqqCsdxHAcABAAAZAAAAAAAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAP +AD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAgAAAA8APwABAAAAIhYAAIAAAAMAAAFZAAAkFgAB +AAAAAwAAAVoAACYWAAIAAAAEAAABWgAAKBYAAgAAAAMAAAFbAAAqFgACgAAAAwAAAVwAACwXAAAA +AAAEAAABXAAALhcAAIAAAAMAAAFdAAAwFwABAAAAAwAAAV4AADQXAAIAAAADAAABXwAANhcAAoAA +AAMAAAFgAAA4GAAAAAAABAAAAWAAADwYAAEAAAADAAABYgAAPhgAAgAAAAQAAAFiAABAGAACAAAA +AwAAAWMAAGQbAAIAAAADAAABbwABZhsAAoAAAAMAAAFwAAFoHAAAAAAABAAAAXAAAWwcAAEAAAAD +AAABcgABbhwAAgAAAAQAAAFyAAFwHAACAAAAAwAAAXMAAnQdAAAAAAAEAAABdAACdh0AAIAAAAMA +AAF1AAJ4HQABAAAAAwAAAXYAAnwdAAIAAAADAAABdwADfh0AAoAAAAMAAAF4AAOAHgAAAAAABAAA +AXgAA4QeAAEAAAADAAABegADhh4AAgAAAAQAAAF6AASIHgACAAAAAwAAAXsABIwfAAAAAAAEAAAB +fAAEkR8AAUAAAAMAAAF+AASVHwADAAAABAAAAX8ABZcfAALAAAADAAABgAAFmSAAAEAAAAMAAAGB +AAWdIAABQAAAAwAAAYIABZ8gAAHAAAADAAABgwAFoSAAAwAAAAQAAAGDAAWlIQAAQAAAAwAAAYUA +BZCbAQAAAAAAkJsBAAAAAACQmwEAAAAAAJCbAQAAAAAAkJsBAAAAAACQmwEAAAAAAJCbAQAAAAAA +kJsBAAAAAAC4lAEAGAAAAICWAQAgAAAAxJwBABQAAADAnQEAFAAAAOyaAQAOAAAApJkBAA4AAAC8 +mgEAFAAAALyaAQAUAAAAQCNAJSEhISFAQEBAQAUEBAEBQEBAQAUFQEAMDEANDAwBAQEFQEAFBQAE +AARAQAAEQEBABUBAQEBABUBAQAUFBQEBAQFABQUFAQUBAUAFBQVABUAFBQUFBQAAAAAAAAAAZAAA +AACQAQAKAAAA3NIBAJzXAQDE1AEAhM8BAITcAQCo3wEApNkBAGjWAQBM2wEABAAAABwRAAAcMgAA +HDMAAAQAAAAcFQAAHAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXGhPiZ7o32Df+91rHe +VJFQYAMCqc59VhnnYrXmTZrsRY+dH0CJh/oV7+uyyY4L++xBZ7P9X+pFvyP3U5bkW5vCdRzhrj1q +TFpsQX4C9U+DXGj0UTTRCPmT4nOrU2I/KgwIUpVlRl6dKDChNw8KtS8JDjYkmxs93ybNaU7Nf5/q +GxKeHXRYLjQtNrLc7rT7W/akTXZht859e1I+3XFelxP1pmi5AAAswWBAH+PIee22vtRGjdlnS3Le +lNSY6LBKhWu7KsXlTxbtxYbXmlVmlBHPihDpBgSB/vCgRHi6JeNL86L+XcCAigWtP7whSHAE8d9j +wXd1r2NCMCAa5Q79bb9MgRQYNSYvw+G+ojXMiDkuV5PyVYL8R3qsyOe6KzKV5qDAmBnRnn+jZkR+ +VKs7gwvKjCnH02s8KHmn4rwdFnatO9tWZE50HhTbkgoMbEjkuF2fbr3vQ6bEqDmkMTfTi/Iy1UOL +WW632owBZLHSnOBJtNj6rAfzJc+vyo706UcYENVviPBvSnJcJDjxV8dzUZcjy3yhnOghPt2W3GGG +DYUPkOBCfMRxqszYkAUGAfcSHKPCX2r5rtBpkRdYmSc6uSc42RPrsyszIrvScKmJB6czti0iPJIV +IMlJh/+qeFB6pY8D+FmACRca2mUx18aEuNDDgrApd1oRHst7/KjWbTosAAECBAQAAAAEDAwIBAwE +BEAAAACAAAAAAAEAAAACAABAAAAAAAQAAEAAAABAAAAAAPBhAAABAQIBAgIDAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAZAAAACoAAAAOAAAAAAABAaQcAgCwHAIAvBwCAMgcAgDQHAIA2BwCAAEB +AAECAQEBAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAABAAAAAAAAAAEAAAAAAAAAAQAA +AAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAAAAAAD/////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAACADQAAACAAAIANAACADQAAACAAAIANAAAABgAAAAQAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAA +rC0CACAggA8AAEAAaSAAAGkgQABpIAAAaSBAACAggA8AAOgAaSAAAGkgQABpIAAAaSBAACAggA8A +APznaSAAAGkgQABpIAAASiAAAEohAABKIgAASiMAAEokAABKJQAASiYAAEonAABKIAAQSiEAEEoi +ABBKIwAQSiQAEEolABBKJgAQSicAEEogACBKIQAgSiIAIEojACBKJAAgSiUAIEomACBKJwAgSiAA +MEohADAKJIA/gQAAQEEsnDBALJwwQiQcNAoigD+AAAhXCiMANzoLwAZKJgBwaSBAAEomAHBKJgBw +SiYAcEomAHAAFgBwgADYGkB4ICBAhwAAAAAAAAAAAAD8HIi2/BxItvwcCLb8HMi1/ByItfwcSLX8 +HAi1/BzItPwciLT8HEi0/BwItPwcyLP8HIiz/BxIs+B+4HgE3DjdNfDgeATcNN0z8OB4BNww3THw +4HgE3CzdL/DgeATcKN0t8OB4BNwk3Svw4HgE3CDdKfDgeATcHN0n8OB4BNwY3SXw4HgE3BTdI/Dg +eATcEN0h8OB4BNwM3R/w4HgE3AjdHPDgeATcBN0Z8DQUGjAwFBkwLBQYMCgUFzAkFBYwIBQVMBwU +FDAYFBMwFBQSMBAUETAMFBAwAscBxrAkTTOwJB8z4H7geOB44HjgeOB44HgKJIDwBSBEAOAgwQdE +JP6AQSrEAIQAAgAvJALxQiEBAUIgAwHoIKIEBBEEAgQRBQIEEQYCBBEHAgQbCAEEG0gBBBuIAQQb +yAEsACUARCI+gTwAIgBEIvyAQCHBAOAgwQdAI8MAqCCAAQERhAIBGwoBICDABwQRBAIEEQUCBBsI +AdQH4f8EG0gBRCL8gAQRBALJB+//BBsIAUIhQQBCIEMAqCCAAQERhAIBGwoBICDAB89xoACsLxiB +mrgYoRUDoBAF2OB4z3GgAKwvGIGzuLq4GKEBA6AQZNgKIkCAANnuAAEALyYA8EomQABOAAYATwAg +AIol/w/geAoiQIAA2c4AAQBsACQALyYA8FwABQArCDUISiZAAAhxANgCIb6A4CDFB0J5AeACIb6A +4CDFB0J56wfv/wHgLy0BAEAlRQACJnzxAAAgAAAoQAHoIGIDLyAAgC8hSwACIb6AwCCGAcIhhgDg +fhEAIABKIAAQSiBAEA4iQgAvIAsSziBFgIol/w8IAAUALy0BAEAlRQACJnzxAAAgAAAoQAFKJkAA +6CAiAy8gAIAvIUsAAiG+gMAghgHCIYYASiYAAEIg/pDOIIIBRCB+kM4hggHgfgkAAADgeAomAPCK +IL8PyiBkAOB/LyADAOB/iiD/D/wciLH8HEix/BwIseHD4cLhweHAB8AcHMAx4cDgfwHA8cAWDc// +CHZacgGJQIkQuBi6B3oCiQi4R3hDiQd6AIbihgcghwBFiQSJELoYuEd4RokIukd4R4kHegGGo4YH +IIgACIlJiRi4ELoHegqJCLgHeguJR3hNiQd/DIkQuhi4R3hOiQi6L4lHeCd4B31KI0AhXvCSCqAF +ANkId+pwigqgBQHZB3/ocH4KoAUC2Qd/CXB2CqAFA9kghud4ByEHAEErAAZiCqAFANkIcylwWgqg +BQHZB3tJcE4KoAUC2Qd7aXBGCqAFA9khhmd4ByEIAEEuACYyCqAFANkIcwpwKgqgBQHZB3sqcB4K +oAUC2Qd7iHAWCqAFA9nihmd4B39BLQAWBgqgBQDZCHOKcPoJoAUB2Qd7yHDyCaAFAtkHe6pw5gmg +BQPZo4ZneAd9QS8ABtYJoAUA2QhzQS0AFA94ygmgBQHZB3tBLwASD3i6CaAFAtkHey8gBwKuCaAF +A9kkhmd4ByEFAEEoABaeCaAFANkIc0EvAAQPeI4JoAUB2Qd7QS0AEg94ggmgBQLZB3vveHYJoAUD +2Wd4ZYYHe0EvABZmCaAFANmYcEEoABQPeFoJoAUB2QckBABBLwACD3hKCaAFAtkHJAQAr3g+CaAF +A9kmhgcgAAEHIRYAQS0AFioJoAUA2Qh1QS8AFA94GgmgBQHZB31BKAASD3gOCaAFAtkHfS8gxwEC +CaAFA9mneKeGQiNToEEtCQRBKxAEB30g5kEtFxRBLgAiLyDHEEEtChIvI4cVQS0BAi8kRwNBLhQk +QSsCAi8lRyEvJ8clLycHAC8hRxIvIocSLyAHJC8hRyAvJAclLyaHAEEtAAYE9ZoIoAUE2QQgjw8A +/wAA6nCKCKAFBNn/2RC5JHgHf+hwegigBQTZ/9kIuSR4B38JcGoIoAUE2Q94IIbneCd4QSgBBgAa +QiBBKAEEARpCIEEoAQIDGgIgAhpCIEErAAY6CKAFBNkEIIMPAP8AAClwKgigBQTZ/9kQuSR4B3tJ +cBoIoAUE2f/ZCLkkeAd7aXAKCKAFBNkPeCGGZ3gneEEoAQYEGkIgQSgBBAUaQiBBKAECBxoCIAYa +QiBBLgAm3g9gBQTZBCCDDwD/AAAKcM4PYAUE2f/ZELkkeAd7KnC+D2AFBNn/2Qi5JHgHe4hwrg9g +BQTZD3gihmd4J3hBKAEGCBpCIEEoAQQJGkIgQSgBAgsaAiAKGkIgQS0AFn4PYAUE2QQggw8A/wAA +inBuD2AFBNn/2RC5JHgHe8hwXg9gBQTZ/9kIuSR4B3uqcE4PYAUE2Q94I4ZneCd4QSgBBgwaQiBB +KAEEDRpCIEEoAQIOGkIggQHv/w8aAiDgePHATgnP/54JIAAIdQDZKNgVJUIQFSUDEMCD4ILAouCj +wYPhgsGi4aPCg+KCwqLio8OD44IE4WS4w6LZCSKA46MJ2wSFEOU4uBIPYAUE2Q94zg5gBQDZCHYA +hTC4D3j+DmAFBNkPeLoOYAUB2Qd+AIUouA945g5gBQTZD3iiDmAFAtkHfgCN1g5gBQTZD3iSDmAF +A9nHeAClAYU4uL4OYAUE2Q94eg5gBQDZCHYBhTC4D3iqDmAFBNkPeGYOYAUB2Qd+AYUouA94kg5g +BQTZD3hODmAFAtkHfgSNgg5gBQTZD3g+DmAFA9nHeAGlAoU4uGoOYAUE2Q94Jg5gBQDZCHYChTC4 +D3hWDmAFBNkPeBIOYAUB2Qd+AoUouA94Pg5gBQTZD3j6DWAFAtkHfgiNLg5gBQTZD3jqDWAFA9nH +eAKlA4U4uBYOYAUE2Q940g1gBQDZCHYDhTC4D3gCDmAFBNkPeL4NYAUB2Qd+A4UouA946g1gBQTZ +D3imDWAFAtkHfgyN2g1gBQTZD3iWDWAFA9lhu4Djx3iuBu3/A6UZAM//8cCuD4//YYlAiRC7GLpn +emKJCLtnemOJAN9nekCgRIlliRi6ELtHe0aJCLpHe0eJZ3pBoEiJaYkYuhC7R3tKiQi6R3tLiWd6 +QqBtiUyJELsYumd6bokIuy+JZ3oK3Sd6Q6DDgAhzQS4AFA94Tg1gBQTZIIMEIIAPAP8AAAchBABB +LgASD3g2DWAFBNkEIIAP/wAAAAckBADPeCINYAUE2QQggA8AAAD/ByQEAEEuABYKDWAFBNkPeM9x +gADAVvAhwQMHIAABJ3ghgwSjJ3gigwWjJ3gjgwajYb0neAejQCMABIMNdZAB5y0Hj//hxQh1EfDg +eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+314H/BxeB48cDhxc9wgACUHE2A +z3WAAPiQIIW3uri6BCGBDwMAAAAHuUV5LaCuCGAQANgAhc9xgADIy1EggIJMic9wgQBQDzJqNnnH +cYEAEAxggVZ4QYAF8pW7YKGrugTwtbtgoYu6QaALjaO4oQav/wutosHxwB4Oj/9Fwc91gACUHCeF +FQhBADCVFBQOMQkOQRBZHYIQ0BUBFh0IQQDPcYAAoB88kRQUDTENDUEQz3GAAPgfWamL6s91gAD0 +BsGNgOYA2cogQQAk8iGtCwqRAwHYHvBBKA0CB31BKAEEp3nPd4AA9Aagj1MlRREfDTIExrkKIcAP +63LPcAAAzRuf2xEFIAGKJIMPDw2eEQDYDNzvBY//z3aBANAOFiZNEaeNoK/JdRYlTREApRQUADFG +rcdxgQCQCwK1AIkHrQAZQgEAG0IBx/HxwEoNj/8IyM9yoADIHw4aGIAJyA8aGIAKyBAaGIALEgE2 +AsgkeBEaGIAMyM9xgADIMS0aGIAAgQHgAKHDuFcIUQMLyH/ZCrkkeC8oAQBOIIIHANgPIIAABCEB +gEIijQIZ8gsjQMAX9M9woACIIPAgUAPPdoAA1C0Ahs93gADYLQ0NARAAhxJwHAwBBqCmAB8AFB0F +j//geM9xgACcVuB/CGHgePHAcghABc9xgABkFvAhAABAeIDZz3CgANAbMKDRwOB+gOHKJE1w6CBt +As9xoABQDCWBARhSAOB+8cBuDI//z3CAAJQcA4AYiKXBSiAAIB0IEQEKIcAP63KKIIwNZNsKJAAE +xQMgAbhzz3WAAOQrz3CAAFQ4lg9gDiQdABTPcIAAcDiKD0AOz3CAABg5fg9ADs9wgAA0OXYPQA7P +d4AAKJhtj4DjnvJMj1BzOAEMAM9wgAAIGwSAIIDPcIAASI5AoGGgIqDPcIEAeBQIkCkLAgDPcIEA +eBTPcYAAQMlosAHez3CAACjJzKEjgA0J5QABGAIEY6AQj4DgyiBiAAOlEY8T6JPqz3CAAJQcA4AJ +gBsIngDqDiACB9gB2AGlz3CgACwgEIAApc9wgABcKACAHQhRAM9wgQB4FM9xAAAQJwoNr/8FgBB4 +A/AA2M9xgADQyAexA4UMGQQEYwhRAACBguDMIOKAA/QB2AChTBWAEE8IUQDPcKAALCDQgM9wAQAI +FkDAAdhBwAgcADQR2EPAANiMuETAANgQ2QTaCHOYcLhwACaHHwAAAH3SCaAE2HBLFYAQAeAPeEsd +AhAMj4XoAYWA4KQKwQTPcIAAxDg+DkAOAdnPcIAAbBMgoCIOIAIG2CkDr/+lwOB4osHxwL4Kr/+Y +ckXBQSgBAgd5QSgCBCd6xrrPdYEAkAtJZV1lJwnfARQUDjHPc4EA0A5ocjZ64IILCMED4pITD4AT +J4qnau8J3oEA2CfwxoqG7oDfz3CAAPQG4ajPd4AA6BwFjwsOARCA2AWvCfDPd4AA+B8ZjwsOARCA +2Bmvxoo2ewAcgAMHioe5AK3PcIAA9AZAiCCoAdhHqwzcjwKP/6HB8cADEgI313IAAABAAdrCIooA +F7rHcgAOAACDuuxzQKPscgCiIgsgBChw0cDgf6HA4Hil4C3yEfZjCJAIhOAl8gf2L+hnCNEA4H8A +2DcIUAFbCBEI4H8L2IwgQ4cb8szgG/Kt4BHyB/Y3CJAJPwgRCuB/CtgzCBAMMwhRD+B/A9jgfwHY +4H8C2OB/BNjgfwXY4H8G2OB/B9jgfwjY4H8J2OB/DNjgfw3YDtjgfuB48cDhxc91gAB8JqlwQCWB +G74PoA0u2gHY0QGv/2EdAhDxwEoJj/8fCLQACHUKIcAP63L92Iu4c9tKJAAAsQAgAbhzz3eAAHwm +N4cAJZAfgADQJg8NQRAMEIAggOCM8goPYAcF2DpwRC2+GwAnQB5AkCGQAN4IukV5z3KkALg9mxpY +ACKQDBiCI8oaWAAjkLenyxpYACSQxBpYACWQxhpYACaQxxpYACeQwhpYACiQwxpYACmQxRpYAAqQ +oxoYAM9wgACoIyCAYHnJcDcIEAPPcIAAqCMggGB5yXAnCBAEz3CAAKgjIIBgeclwFwhQBM9wgACo +IyCAYHnJcAkIkQQA3c9wgACUHAOACIDPcaQAtEUhCB4ARC2+GwAnQB5skEuQe3tlelMZmIANkFQZ +GIAG8FMZmINUGZiDRC2+Gyd3DpdWGRiAD5dYGRiAEJdVGRiAEZdXGRiAEpdaGRiAE5dcGRiAFJdZ +GRiAFZdbGRiABgtgBypwVQCP/4bg8cAA2A/0z3CAAESYZgvv/wbZz3GAALibAIGCuAChAdjRwOB+ +4HjxwIPg4cUA2Bj0z3WAACiYQCUAFTYL7/8D2c9wgACUHAOAFJA1jRMJAADPcYAAPMsfgY24H6EB +2BEAj//xwIHg4cUA2An0z3CAAD+YAd3+Cu//qXGpcPUHT//gePHAluDhxQDYjPfPdYAA+JCpcN4K +7/8E2QuNg7gLrQHYzQdP//HAmuDhxQDYjPfPdYAA+JAEbboK7/8E2QuNgrgLrQHYqQdP//HAMg9P +/6PBz3aAAGCvJo5AJg0SArk0eY7gPWUA2CX0i3CGCu//DNkCFIAwnOgQ2c9wgAAwByCwBI4kbQCt +IMABrQMUgDACrYHA9g2gDQLaRo4B4k96J45GIsAAwbpGriV4B64B2DkHb/+jwPHApMGQ4ADZyiBC +ABP0i3AqCu//ENkAFAAxhODMIGKBCPTPcIAAPMsfgAkIXgVMcAHYpMDRwOB+geAA2cogQgAU9M9w +oABQDCWAz3OAAKB7AZMveRMJAADPcoAAMAcAkiGzgbgAsgHY4H7gePHATg5P/4bgANgp9M9wgAAI +GwSAz3eAAGCvVicREgCAUhcNEQ+ng+XKJSYQvmXUfgAhkCMKcJoJ7/8G2SJ2AZYK6AAQgCAI6M9x +gAAwBwCRhrgAsVIfRBMB2FUGT//geIDgANgI9M9xgAAwBwCRgrgAsQHY4H7gePHA2g1P/wh3z3CA +AJQcA4AYiBpxjQgQAYTnAN2GACUAyiBFA892gAAomEAmABMqCe//BNkujrCuUyEAABGuQSjAIKC5 +XQhkAAIgQgBjv1UKxQMP6s9xoADQDxARAIZhulhgEBkYgCURAIYPeALwD44A2VMggiAPIYEAJHgv +Jgfwz3GfALj/EK4Ygc8g4gfQIOEHGKEYgZ64GKEYgb64GKEB2J0FT//geOHE/BzIvvwcSL7hwOHB +4cLhw/wcCLH8HEix/ByIsfwcyLH8HAiy/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDhxPHAz3Cg +ANAbFIDPcYAA5AUEIICPz1EE4QChEfIvKQEADwieBS8pgQ9AAAAAz3CAAAwj8CBAAEB4cg+P/9HA +wcRrJMAQwcRrJIAQwcSfdAQUCzQEFAo0BBQJNAQUCDQEFAc0BBQGNAQUBTQEFAQ0wcPBwsHBwcDB +xEUsfhAKJkB+wcRrJIAUwcQgIECH4HiMIFyCAdjgf8IgCwDxwF4Mb/9KJEAAz3WAAJQcFSUDEACD +QCUOFdFwwiQCAfAlDRHIFQUWRCW+gQnyCiHAD+tyjtiNuJ0D4AB028gQDQalecgYWACggwbZRnnI +FQAWJHjIHRgQAIPIEAAGhiB/jlwMARBlBE//4HjxwO4Lb/+A2gh3KHYEgUAmDRYjuFMgQQE4ZQEY +kgBOIcIPHQo1AgDZygsAAclwagggAKlxqXAA2TjaA/BourYLAAEEhhSmBYYVpslwSgggAKlxyXDp +cfYJoA0Q2slwANmSCyABBNrxA0//4HjPcUVnASMgoM9xze+JqyGgz3G6mP7cIqDPcTIQdlQjoADZ +JKDgfyWg8cBaC2//mHBggAwQBgBCgKGA4oEHJoAApHgHII4BAIHHdyAk23ACIIAPlSiIW9hgG2MX +azm7ZXgHIkMDuGAEewcjjgBhgQIjgw84F6pIfmbAdkAuAxM0vsV7ByUOEBtjZH6nfv5m2mJAKk4E +44EvusV6ByMOAHpiRH4HfgInjx9CPhIx/mbdZUAtjhUqveSBxX0HI44AXWWkfmd+AiePH4MKUfD+ +Zthg12jlgTm4xXgHIk4DuGAEfkd+x3eHRyrG/mbbY0ArDgPmgTS7xXsHJQ4QG2Nkfqd+AiePH89X +7bn+ZtpiQCpOBOeBL7rFegcjDgB6YkR+B34CJ48fuQL/av5m3WVALY4VKr3ogcV9ByOOAF1lpH5n +fsd3gGnYmP5m2GDXaOmBObjFeAciTgO4YAR+R34CJ48fu3RRCP5m22NAKw4DNLvqgcV7ByUOEBtj +ZH6nfgInjx8AAE+k/mbaYkAqTgQvuuuBxXoHIw4AemJEfgd+AiePH6N2Qij+Zt1lQC2OFSq97IGl +fgcjjQBeZsR9Z33Hd5BrIhH9Zbhgt2g5uO2BpXgHIo0D2GAEfUd9AiePH2cCbY79ZbtjQCsNAzS7 +7oGlewcmDRAbY2R9x30CJ48fhllyvP1lumJAKk0EL7pFfX1lByMCAKR6PBEFAAciDwAAJYIPtEkh +CPpi2mJAKo4FKrrFeuGBumIHJY4QZH6nfgInjx/hCZ7a/mbYYNVoO7gFfuaBXmYHIoADpHhHeAIn +jx+/P8BM+GB4YEAoQwI3uAV764HbYwcjgANEeMd4x3deJlFa+GC4YEAojQMyuAV94IF9ZQcjQAPE +eGd4AiePH0kWVjj4YFhgQCgCBSy4RXjlgbhgByUCEGR6p3oCJ48f0Cmj7/pi2mLVaju6xXrqgRpi +ByCOAKR+B37Hd0QCUxT+ZttjQCtOAje7ZX5eZgcmgxAEewcjjwACJYMPXid/GftjfWVALYMTMr1l +feSB3WUHJkMTRHvHewInjx8sGDgE+2N4YEAoAwUsuAV76YG7YwclwBDEeKd4x3fhIebN+GBYYFVo +O7gFenpiByOAAKR4OBEHAAcgzwACJ4APyDwq+Phg2GBAKE4CN7jFeOOBWGAHII4AZH5HfgInjx8q +C3ny/mbdZUAtjhPogTK9pX4eZgcgjQNEfQd9x3daRe0U/WW7Y0ArDQUsu2V97YHdZQcmQxMEe8d7 +AiePHxxW+xb7Y3pidWrigTu6ZXq6YgclgxDEe6d7AiePHxADCFz7Y3hgQChDAje4BXvngVtjByOA +AKR4R3jHd29n2QL4YNhgQCiOAzK4BX7sgX5mByOAA0R4Z3gCJ48f1XJ2s/hguGBAKA0FLLjlgaV4 +2GAHJg0QZ30CJ48fBQC+xv1lumK0auiBPLqlehpiByCNAMd9AiePH454fwn9ZbtjQCvNAuuBNbtl +fV1lByWDEAd7x3edbSJh+2PbY0ArDgQwu8V7u2MHJc8QR38CJ44PGgL0x/5m2GBAKM4FKbjhgcV4 +eGAHIw4Ap34CJ48fQVu8Fd9n+mLUauSBPLpFfh5mByCCA2d6x3feS6nP+mK6YkAqzQLngTW6RX3d +ZQclghMHegInjx9ECaC0X2f7Y0ArAgTqgTC7RXu7YwclwhDHegInjx9AQZBDX2f4YEAowgUpuO2B +BXp6YgcjgACneMd3myjGfvhg2GDUaDy44IEFfl5mByKAA2d4AiePH14VBtj4YLhgQCjNAjW444EF +fd1lByWAE0d4AiePHxAre8/4YHhgQCgDBOaBMLhleLhgByUDEMd7x3eIBAUd+2N6YkAqwwXpgSm6 +RXsbYwcgwgCnegInjx8rJscv+mLaYtRq7IE8usV6emIHI44AB34CJ48fJBkbZv5m3WVALc4SNb3F +fV1lByWPEGd/ACWOD6If+Hz+ZthgQCgOBDC44oEFfr5mByWAE0d4AiePH1M7m6n4YHhgQCjDBeCB +KbhleLJ72GAFe8d7AiePH9YLvN37Y3pidmrngTq6RXsbY9J6ZXoHesd3KkOX//piumJAKo0C7oE2 +ukV9Enp9ZaV6Z3oCJ48fa1RZ3Ppi2mJAKs4D5YExusV6cn66YkV+p34CJ48fbAPHX/5m2GBAKE4F +K7jsgcV4WGCyfgV+R37Hd1tlw1n+Zttj1ms6u+OBZX5Sex5mxXsHewInjx/zcG4z+2O7Y0ArjQLq +gTa7ZX0Se91lpXvHewInjx8QAIML+2N6YkAqwwPhgTG6ZXrSe7piRXunewInjx97ei+if2f4YEAo +QwUruOiBBXuyeFtjZXhHeMd3qG9Pfvhg2GDWaDq4BX5SeH5mxXhneAIljw/TASAZH2f9ZUAtgBLm +gTa9pXjYYHJ9BX3HfQInjx/+XOy8v2f6YkAqzQPtgTG6pXrSfRpiRX0Hfcd3CE6hEb9n+2PkgUAr +TQUru2V9EntdZaV7R3sCJ48frAh+gftjfmbrgXZuOr7Fe1J+u2Nlfqd+AiePH8VCyw3fZ/hgQCiO +Aja44oEFfrJ4KYF+ZsV4Z3jHd9cqu9IfZ/piQCrAAzG6BXpyeNpiRXgCIYEPeRRvLMd4GWG5YUAp +QAUruQV5ABQNAFlhu2MAHMAABBQDAHlhBBxAAAgUAQBZYQgcQAAAJoEDDQQv/wwcQADgePHAkgsP +/wh2SHVEgCh3FiJBAySgCwmlAAWAAeAFpkEtQRc4YEEqwQBTIUGBBaZAJhAWH/JA3A4hEQPpcD0N +ZBQCcbYJYA0qcslw+g+v/wpxIncCJU0UDfCeCWANQNrJcOIPr/9AJgEWQOeCJQEQwOXpcEAmARZy +934JYA2pcnUDD//gePHAz3CAAPwiAIAb6M9wgACMIwCAmeimD8AMiegLyAUggA8AAAA8CxoYMJYP +wAyJ6AvIBSCADwAAANQLGhgwC8iQuAsaGDAqCoAF0cDgfuB48cDGCi//Z3rPdYAANAeghRUlTRHA +hUR5Z3lDKMAGQy4PEgQnjx8A/wD/Qy4OFgQmjh//AP8A5X7Apdlhx3GCWpl57QIv/zhg8cB+Ci// +mHBAJU0Dz3aAADQHwIbDvfAmTxNAJQ0Cw73wJk0T531AJY8Aw7/wJs8TUyXAABV+AIbnfWd6RHmn +eEMowAcApmd5GWHHcYJamXlDLMAGkQIv/zhg4HjxwCIKL/+YcEAlTQPPdoAANAfAhsO9QCUPAsO/ +8CbPE/AmTRPnfUAljwDDv/AmzxNTJcAAFX4Ahud9R3lneQd9Qy3AFwCmGWHHcdluoetDLMAGOQIv +/zhg8cDKCS//mHBAJU0Dz3aAADQHwIbDvUAlDwLDv/AmTRPwJs8TUyXAAKd/QCWNAMO98CZNExV+ +AIbnfad4BSJNAER5pHtDKMAHZXkZYQCmAiGBD+RwJENDLMAG2QEv/zhg8cBqCS//mHBAJU0Dz3aA +ADQHwIbDvUAlDwLDv/AmzxPwJk0T531AJY8Aw7/wJs8TUyXAABV+AIbnfUd5Z3kHfUMtwBcAphlh +AiGBD501Kj5DLMAGfQEv/zhg4HjhxQHbz3KAAGAFfrLgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4BrhFIM0Az3CgAOwnpqAKgADb +ALF+suB/wcXgePHAdgqAAn4MgA8yCoAPgNnPcKAA0BswoNHA4H7xwH4ID/8acAHfABASARPwWnUR +8BUgwCOgkAIQEQEB59d1AAD7//B/dPYZCoAvAAD//89wAAD7/90IgYSdAA//z3aAAAAbAIYB4ACm +FQhRAAHZz3CgAMgcMaDGDKAPKHAGvYG9QCkAJKV4z3GgAOwnBqEAhkIgQIAApt31z3GgAMgcANgR +odfx8cDPcIAAOCUAgIHgyiHCD8oiwgfKIIIPAACvE8ojgg8AAPMByiQiAFQHYgDKJQIBGggAANHA +4H7xwHoLAA9KCcAM0cDgfuB48cC2D8/+z3CAAJQcA4AogM9wgACkssC5NngkgACACrkEIYEPDwAA +/Mm4JXjPcacAFEgNoZoPoAahwRpwz3GAAAAbAIEB4AChFQhRAAHZz3CgAMgcMaD6C6APKHCLcVIO +7/9C2M9wCACHEM9zoADsJwajAtkA2JhwCiYAgfhxD3jKJmIAAN4FuBC4gbiHuIy4BqME2J9wyXeo +IAAMYbhAKIEhQC5CATpiuHAVeoAlgg3HcoAA4LIiki8lSAFALY0Bgb08eRC5pXkmoyKSwLkYecV5 +MH6jkrhwgCVCDy8lSAFALYEBvH2BuRC9pXkmoyOSwLkYeeV5MH8QvgUmjh8AAAIvxqMQvwUnjx8A +AMIw5qNCJ0EAYwl1gEAkQAAAFAAxELiBuIe4jLgGo89wgAAAGwCAz3GAAAAbQiBAgAChB/TPcaAA +yBwA2BGh0Qbv/qHA8cAA2I24og+gCwYaGDAMzIYg/4oI8s9wgADMLQCIgODsDsID0cDgfvHAz3ED +AEANz3CgAKggLaDPcaAArC8ZgfC4GYEL8gQggA8IAAAA13AIAAAAAdjAeAbwhiB/D4LgAdjAeM9y +gACgByCCYWmM6M9wgADoBQGIhuhgoroN4AVI2APwYKLPcoAAXDYGggOAIIDHcQAAiBOiCeANSHDR +wOB+4HjxwLoNz/7PcYAA7D8hgaPBQsHPcYAAlBwVIRAAABAAIMAQDgYvKIEDTiCNB68OEBASbRZ4 +ACCSD4EAEAwGEoAgz3GBANAOFnkAgSKRjuUIHEQwyiBhAAbyi3KuCm//AsE26ADYz3GAAMAGQIEP +IEADLyEKIAQhgKAAoQf0gOJ0DSIHyiAiCK94Xg7gAxDZAN8EGsQjiiEIAAAaQCCpcOlxXghgBg/a +ABACIMASAAYEIEAEwBoYAM9wgQBQD7Z44KDhoM9wgQBwC7R44LAQJk6TLyiBA04gjQes9T0F7/6j +wPHA4cUIdQTwPgjADZ4I4A2pcPzoSQXP/qPBQsIJFIAwgeAB2MB4ELgB4OB/o8DgeKPB4H+jwOB4 +8cCiDM/+vsE6cVpyiHYKIEAh6HWXx+lwXgmgANDZA9hhwAUcgjQLChEgCd0+8CUKUCBTCpAgCiHA +D+tyz3AAALENy9sKJIAE4QNgAEolAACUFAAxBhyCM0AogSELHEIzBxwCMEi4YsBAKYAggbgleBB5 +CRwCMEi5ChxCMEi9Y8XV8ZwUgDBAKQEjC7gFeTB4SLgHHAIwmBQAMQYcQjAG3WLASLgJHAIwdhSB +MIjGyXC5YTB5ZgmgAADaRMdFxoHARsAcHEQzXgugAITAMQTv/r7A4HjxwOHFo8EA3UDFQcJCwwLa +qXOYdbh12HUWD+//+HU1BO/+o8DxwLYL7/5AIQMFosEIdyh1SiQAcgDZqCCABIThbyALAPAjAgBT +IU4ATibAEAO4GXoAJEAwQKgB4c92gAB8PqlwyXEE8KlwIm5uCWAAAdoFhYYg+AGMIAeA9vWLdqlw +yXFWCWAACNpKJAB1ANioIMADQSiBAPAlQRBTIEMATiPCAAO6WXkcZyCsAeCpcADZLgugAATayXAA +2SILoAAI2oED7/6iwM9xRWcBIyCgz3HN74mrIaDPcbqY/twioM9xMhB2VCOgz3HSw/DhJKAA2Sag +4H8loPHA4grv/hlwz3CAADQHIKAAEA4QBBAPEAgQBxAMEAYQyXAQEAQQ6XHocshz8g+v/0olAAAA +IA0BQy+JEKlwyXEpcuhzCiSAAdYPr/9KJUAAwHDYcEMuihCpcUlyKXMKJMABvg+v/0olgAAAIM4B +Qy2HEMlwyHHocklzCiRAAqIPr/9KJcAAACBPAkMuiQDpcMlxKXLocwokgAKGD6//SiUAAUFw2HBD +LooQ6XFJcilzCiTAAWoPr/9KJUABACDNAUMvhxCpcMhx6HJJcwokQAJOD6//SiWAAQAgTgJDLokA +yXCpcSly6HMKJIACMg+v/0olwAFBcNhwQy2KEMlxSXIpcwokwAEaD6//SiUAAgAgzwFDLocQ6XDI +cehySXMKJEAC/g6v/0olQAIAIE0CQy6JAKlw6XEpcuhzCiSAAuIOr/9KJYACQXDYcEMvihCpcUly +KXMKJMABxg6v/0olwAIAIM4BQy2HEMlwyHHocklzCiRAAqoOr/9KJQADACBNAkMuiQCpcMlxKXLo +cwokgAKODq//SiVAA0Fw2HBDLooQqXFJcilzCiTAAXYOr/9KJYADACDPAUMthxDpcMhx6HJJcwok +QAJaDq//SiXAAwAgTQJDLokAqXDpcSly6HMKJIAChg6v/0olAARBcNhwQy+KEKlxSXIpcwokwAFq +Dq//SiVABAAgzgFDLYcQyXDIcehySXMKJEACTg6v/0olgAQAIE0CQy6JAKlwyXEpcuhzCiSAAjIO +r/9KJcAEQXDYcEMuihCpcUlyKXMKJMABdg6v/0olAAUAIM8BQy2HEOlwyHHocklzCiRAAloOr/9K +JUAFACBNAkMuiQCpcOlxKXLocwokgAI+Dq//SiWABUFw2HBDL4oQqXFJcilzCiTAASIOr/9KJcAF +ACDOAUMthxDJcMhx6HJJcwokQAIGDq//SiUABgAgTQJDLokAqXDJcSly6HMKJIAC6g2v/0olQAZB +cNhwQy6KEKlxSXIpcwokwAHSDa//SiWABgAgzwFDLYcQ6XDIcehySXMKJEACtg2v/0olwAYAIE0C +Qy6JAKlw6XEpcuhzCiSAApoNr/9KJQAHQXDYcEMvihCpcUlyKXMKJMABfg2v/0olQAcAIM4BQy2H +EMlwyHHocklzCiRAAmINr/9KJYAHACBNAkMuiQCpcMlxKXLocwokgAJGDa//SiXAB0Fw2HBDLooQ +qXFJcilzCiTAAS4Nr/9KJQAIACDPAUMthxDpcMhx6HJJcwokQAISDa//SiVACAAgTQJDLokAqXDp +cSly6HMKJIAC9gyv/0olgAhBcNhwQy+KEKlxSXIpcwokwAHaDK//SiXACAAgzgFDLYcQyXDIcehy +SXMKJEACvgyv/0olAAkAIE0CQy6JAKlwyXEpcuhzCiSAAqIMr/9KJUAJQXDYcEMuihCpcUlyKXMK +JMABigyv/0olgAkAIM8BQy2HEOlwyHHocklzCiRAAm4Mr/9KJcAJACBNAkMuiQCpcOlxKXLocwok +gAKqDK//SiUACkFw2HBDL4oQqXFJcilzCiTAAY4Mr/9KJUAKACDOAUMthxDJcMhx6HJJcwokQAJy +DK//SiWACgAgTQJDLokAqXDJcSly6HMKJIACVgyv/0olwApBcNhwQy6KEKlxSXIpcwokwAE+DK// +SiUACwAgzwFDLYcQ6XDIcehySXMKJEACIgyv/0olQAsAIE0CQy6JAKlw6XEpcuhzCiSAAgYMr/9K +JYALQXDYcEMvihCpcUlyKXMKJMAB6guv/0olwAsAIM4BQy2HEMlwyHHocklzCiRAAs4Lr/9KJQAM +ACBNAkMuiQCpcMlxKXLocwokgAKyC6//SiVADEFw2HBDLooQqXFJcilzCiTAAZoLr/9KJYAMACDP +AUMthxDpcMhx6HJJcwokQAJ+C6//SiXADAAgTQJDLokAqXDpcSly6HMKJIACYguv/0olAA1BcNhw +Qy+KEKlxSXIpcwokwAFGC6//SiVADQAgzgFDLYcQyXDIcehySXMKJEACKguv/0olgA0AIE0CQy6J +AKlwyXEpcuhzCiSAAg4Lr/9KJcANQXDYcEMuihCpcUlyKXMKJMAB9gqv/0olAA4AIM8BQy2HEOlw +yHHocklzCiRAAtoKr/9KJUAOACBNAkMuiQCpcOlxKXLocwokgAK+Cq//SiWADkFw2HBDL4oQqXFJ +cilzCiTAAaIKr/9KJcAOACDOAUMthxDJcMhx6HJJcwokQALmCq//SiUADwAgTQJDLokAqXDJcSly +6HMKJIACygqv/0olQA9BcNhwQy6KEKlxSXIpcwokwAGyCq//SiWADwAgzwFDLYcQ6XDIcehySXMK +JEAClgqv/0olwA8AIE0CQy6JAKlw6XEpcuhzCiSAAnoKr/+KJQEAQXDYcEMvihCpcUlyKXMKJMAB +Xgqv/4olQQAAIM4BQy2HEMlwyHHocklzCiRAAkIKr/+KJYEAACBNAkMuiQCpcMlxKXLocwokgAIm +Cq//iiXBAEFw2HBDLooQqXFJcilzCiTAAQ4Kr/+KJQEBACDPAUMthxDpcMhx6HJJcwokQALyCa// +iiVBAQAgTQJDLokAqXDpcSly6HMKJIAC1gmv/4olgQFBcNhwQy+KEKlxSXIpcwokwAG6Ca//iiXB +AQAgzgFDLYcQyXDIcehySXMKJEACngmv/4olAQIAIE0CQy6JAKlwyXEpcuhzCiSAAoIJr/+KJUEC +QXDYcEMuihCpcUlyKXMKJMABagmv/4olgQIAIM8BQy2LEOlwyHFpcklzCiRAAk4Jr/+KJcECACBN +AkMuhgCpcOlxyHJpcwokgAIyCa//iiUBA0Fw+HBDL4kQqXEpcshzCiTAAhYJr/+KJUEDACDOAkMt +jRDJcOhxqXIpcwokgAH6CK//iiWBAwAmBgBDL48AyHDJcelyqXMKJEAC3giv/4olwQMAEAEQIXBD +LoIQGWEEEAAQwHAEGAAQCBAAEFhgCBgAEAwQABAAGEAQH2cQEAAQDBjAEx1lcQKv/hAYQBPxwPoJ +j/4IdjpxJYBId3NvQSnCAPZ5xboloA0J5QAGgAHgBqZBL0EXOGAGpvhiv+A8AA4AQCYQF0DcDiIN +AypwACCBIBoI4Aypcslw1g6v/wpxCPDJcM4Or/8AJUEUQOVAJcAf8QjEgwDaA/AA3UAmARcAJUAU +WWHmD6AMAidCE9kBj/7xwH4Jj/7PdYAAeAcAFQUQMw1VAs92gADAOs93gABwUgPwABUFEAGFQC0B +AiV4IIYHCEAAAKbwJ0ARQHhz6KkBj/4KIcAP63LPcAAAhidj26kAIABKJIAAosHhxULBQSgCAgd6 +QSgBBEd5z3KBAJALxrkqYiUK3wEIFAMxz3WBANAOqXFWeUCBCwiBAEKREQrAAEeJ7wregYDYA/AG +icHF4H+iwOB+4HjgfuB4CMiVuAgaGDAJyJu4CRoYMAvIiriNuJC4CxoYMOB+4HjxwOHFCHU+iM9w +gABAEkCAQCUAFAO5NXlZYaoPoAwK2r4P7/+pcAUBj/7gePHApcFBwELBDBwAMRAcQDHPcYAAsIk0 +GcAPMBkADywZwA4oGYAOJBlADs9wgACwiSAYQAvPcIAAsIkcGAALz3CAALCJGBjACs9wgACwiRQY +gArPcIAAsIkQGMAIz3CAALCJDBiACM9wgACwiQgYQAjPcYAANImAGQAIfBnAB3gZgAd0GUAHcBkA +B2wZAAdoGYAGZBlABmAZAAZcGcAFWBmABVQZQAVQGQAFTBnABEgZgAREGUAEQBkABO+hzqGtoYyh +LBnAAigZgAIkGUACIBkAAhwZwAEYGYABFBlAARAZAAFjoWogAAPYGQAAaiDAAtQZAABqIIAC0BkA +AGogQAHIGQAAaiAAAcQZAABqIMAAwBkAAGoggAC8GQAAaiBAALgZAABqIAAAtBkAAGoggAHMGQAA +QMMBwALBUyfNNQwUBjBTJcQ1UybFNde6qXOeDSAFEBQHMNIIYAwA2JoIAAPPcAAArd4yD4AAqgvg +DQDYz3WgAKwvGYWJuBmlz3CAAPAFAICA4MogIQLKISEAxA5hBc8hYQbPcIAA9AUBgCkIXgBA2c9w +gABwfCawMLknsBmF8LgZhQXyjrgZpQfwirgZpQXw2gugBgDY9QTADOB4ANtgqCGoQqjgfwPg8cCu +Dk/+z3OAAAAjz3WAAEw8QIUM6QCjlOriCSABD9jSDqAGCNgB2AClDPAA3sCjCOqmCCABD9ieDqAG +CNjApdkGT/7xwGYOT/7PcIAA5AUAgM92gAA4DqCGz3eAADQOBCCCDw8AAOAEIoEPAQAAAHJpRHtn +faCmBCCODwAAAECYdaCHA75EfgQggA8AAACAx32gpwQjAwEGIs8AxH2mfz15JXgCuAQigg8CAAAA +BHoGJ4AQLygBAE4gQgQNGpgwDwqQAc9wgADsyQ6QJ+jPcIAAYAYAiM9xgACUHPAhAQC/EQEGUyFB +gBn0z3GAAPBMBLgBYSMKkQHPcIAA/Mn0IEAADejPcoAA9DQDgg0aWDAB4AOiBPA3CkAASHHPc6AA +FAQqo89ygAB8BkCKANgNClEASYMHChQOAdgB2onoz3CgAIggNXhAoAfwBtnc8ZoOIAsGGpgwvQVP +/uB48cBGDU/+CHbsiCiWz3CAABgGsm8oc4Yj8w+2fUIrEQLHdYEAEAxghQhyCQteA0Ro67mKIMMv +BPQeFpAQDY5RIACAovJ5Cd8AKwveAv/YB61KJABxANmoIIADKGIAIYMPgQD4E/Z7BKsoYgHhL3kA +q1vwIwkSIQohwA/rcs9wAAAtJYojCwRKJEAAQQTv/wolQATuuQeNMiJCBAAhgS+BAPgT9nkI8kSp +BNkAKUEEJXgHrT3wQKkPIEAEY/AtCBIkjCDDr8ohwg/KIsIHyiCCDwAALiXKI4IPAADkAsokYgDo +A+L/yiUCBLYL7//JcAiWCwieAwKOCa0D8AGOCK0AhTEI3gIA2ketSiQAcc9xgQD4E6ggwAI4YvZ4 +BBgCBAAYAgQB4k96AY4IrQKOCa0s8EwhAKHKIcoPyiCKDwAALyXKI4oPAAABAz4H6v/KIsoHCJYA +IYEvgQD4E+64B432eQnyBBkCBATZAClBBCZ4B63d8QAZAgQA2Q8hQQQmeAetAY4IrSEET/7xwMYL +T/7Pc4AA+AZgg3lhz3OgAFAMYIPHcwAAAEAie827CwsFAO0LHsBRIwDAyiAiAB/0OQpRAM91oADQ +DxAVA5YpCFQAz3KAAFgTn3AjgqggwAICiiUVD5bBuNNo2H8B4AKq53kjohAd2JAB2MEDT/7geM9w +gAAIseB/BoDgeM9wgAD0sOB+4H7gePHAOgtv/gbaCHUodyCwz3aAAJQcA4YI4H4JoAwkbQOGQCWB +EnIJoAwG2gOGQCUBFAjgZgmgDAbaANgBtQy1RCcBks9wgQBUGtEn4pEQ8s9ygACYyUCChiL/C0Ui +wgFMtRraWq1LkBDiS7AH8BjaWq1CkBDiQrDPcIEA+BNLtQCIz3KAAEASQIIDuBV4EGJTIICAzCEi +gAXyAJWOuAC1BQNP/uB48cCKCk/+CHY6cRpy5GjPcIEA+BMAiM9xgABAEiCBAN0DuBV4NCESAKGu +HNgArqG26XCpcWYKIAA42gQeRBQI2AKmQCYAFH4N4AOpcc9wgQAQDA6INx5CEzUeQhO8tgS4hiD+ +AxSuiiD/DwumD9g2HgIQUyKAoL22zCAioBDyGQjRAAvYFa4KcEAnARVmCKAMENoH8AsIkQAK2Pbx +sa9JAk/+4HjxwOoJb/4G2oIkAz06cBpxz3aBAPgTAI7Pd4AAQBIghwO4FXgVYc9wgAAAQyIIoAyY +wc9wAACIjmYcBDCawSpwDgigDGTaUyWNkGzYZPJbDdEQQI4gh5bAn8UDulV6EOFZYVoPYA9WJUIT +CiAAhFYlThPKIGIAE33PcIAAlBxDgFUkxjxWJIc2z3CAAFR7QCIBApjDiiQBC+oPIAVTJYUQfN2W +xzvwWQ2RECCOAIfPc4AANHsDuTV5EOA+YCyTAeEweUAjAgYss4npDZMB4BB4DbOF6A6TAeAOs1gc +RDAA2FocAjAg2FscAjABknTdXBwEMAKSXhwEMJbHEfAKIcAP63LPcAAAvCHu25hzYQDv/0olAAAI +dQDemMePwEwgAKCKIQYCyiGBDwAACAGODc//VhSBMItwuWEweSYO7//Jco/A1BwAMItw2BwAMNwc +wDPgHEQzEgggAFUkQD3tAG/+gCQDPfHAkghP/gh1AIAAkCe4wLgTeFMgTgAC2O4IIAfJcQ0amDPP +caAAFATKoc9ygAA4BwCCFL4B4A94AKLFeAuhAYViCKAMPNkAhVoIoAw6iAKFUgigDCaVkg+ABKUA +T/7geChyMQAgAADZ4cXhxgDdgOLKJIlw6CApAq5hqmDCek96g+oB5QDaSHDBxuB/wcXgeOHF4cZA +KQ0CJX1ALQMUpXslCjQCCHVTJX6QBvIBHVIQYbr78UEqjgDBukImTpAEHdAQ/fUJ6i8kiXDgeKgg +QAEBHVIQ4HjBxuB/wcXxwK4PL/4G2A0SDjYBEhA2DRoYMM91oAAUBAqlCYUHEg82J+gD2BClBKXP +cIEACBXqDKANAxoYMJLZA8iQuaAYQACqCmADANgJhQ/oKBUEECQVBRAe2AohwA/rcoy40Qav/4oj +BAYHGtgzARoYNMqloQcv/g0amDPxwOHFCHViCeAAFNjPcIAAlBwAgMQQAAYluIIK4ADAuEYPYAYE +2PYN4AupcAYLgAvGCIALfQcP/vHA4cWhwbkI9AAIdTIL7/8A2q0IEADPc6AAUAwFg89ygAAomBKq +BYMTqgmSjCDEgSptJ/IS9tsI0ACH4Hj0gQlRAM9ygAD4kDIKr/5AIoACC4qBuAuqD/CMIIiAMvKM +IMiASfKMIBCAYvQFgwlpCwhVAQDYXfDeC+AFANlZ8B8JlADPcoAA+JDyCa/+QCIAAkhxC4mAuAup +7fElCVEA3gmv/otwIMDPcYAA+JBTIAIAhiB/D0ipHHgJqe3xE9g58P0JlIPPcIAAlBwDgBiI8QhQ +gM9ygAAsjkhwogmv/gbZQCIAApYJr/4G2QySgbgMssHxzQkUgc9ygAAsjkAiAAV6Ca/+BNkMkoC4 +DLKz8bEJ0YHPcIAAKAdiCa/+B9nPcIAAzCM+DyAPAICl8RzYTQYv/qHA8cDhxc9wgAAsjgyQCwge +AKYOAAMF8FEgQIAQCEIDz3CAAPiQC4gPCFAAguD0CgEEA/AKDAAEz3WAADAHAJUxCJ4Az3KAADzL +TBKAAM9xgACMy8G49CEAAM9xgACYrwGpSBKAAAKpdg5gBQHYAJVRIACBPA8CDwDYzQUv/gC14Hjg +fuB48cDhxQDYz3WAANDISiRAcSSFqCCAAgDbDyMDAAshwIAD9AHgBfBmeToPYAAkpQSFgOBED6EA +yiBhAokFD/7geAhzOGDVu9W5DQnlADa4AiNCAArwz3KBAHgURYIB4Mm4Inp6Yha44H9FeOB48cDe +DC/+mHIIdc92gADEkfQmQBDPd4AARJFRIECCyiBBAMokInTKICIA6CAiAvQmAhAJCl4CAeBHCBUE +LbvAu89ygQBwC7R6QCuFAmCSBL2GJfgTib0PI0MAYLIA2hZ/QKdBp8O5pXkFIUMBFH5gts9xgADk +kRV5ABkAAQLwgNjFBA/+4H7gePHAPgwP/oIkAzIIdlpxSHU6c0hwi3GeCmAMCNpAKtAgQCUAEipx +jgpgDApyhsDeCm/+yXEF2AbZmnB6cUIgDSJfCnIgInVKdwolgCSCxotwyXFiCmAMCNoELL4kDxSB +MAAhQHUneA8cAjCpcITBRgpgDAjahsDJcaoOL/7Jcslwi3EyCmAMCNqEwKlxJgpgDAjaYb9ovbkP +dZBCJVUgQiNBIJkJdYBCJEAgSiQAcgDZqCAAAjIkQDCMIIKJBPQB4QDYBPCKIP8PxQMv/oAkAzLx +wOHFmHADyKCQAYBA5fS4wCWiEAPlz3KgANQHDxIDhgQljR8AAPz/EwslAYB1DcgVIgEwDhEABhtj +GRIAhgIlwRBHCEUABdgMuM9zoADIHx6jENgOowHYFRsYgBkSAIYJCEUA+QsewB8LHkAZEgCGCiHA +D+tyQ9iMuM9zAABEFoECr/+4dQ8aWIN1Aw/+4HjxwM4KD/6rwc9wgQD4FAAQEwAHyAQggA/xAADw +QMANzADez3WgAMgfUSBAgM9wgQD4FCGAA8gP8qAVAhD4FQMQYnkCIlcAdhABAS8nyCVZYQTwhBAX +AeJxOhjEBR+FDwhFADB4yg4gBQLZAdnPcKAA1Ac0oDOgA9/toBEQAIbPcaAA1AdBwEDgDxkYgBQZ +mIMDyKQQAQANCR4CxgiACwTwRx2Yk89woADUBw0QAIZALwEkEHgFIRUAA8ghgAAQEgFDwbgQmABy +EAEBuhAAAQIhFAaWCyAGRMAZCFEAz3CAAMAaAJCB4AHYwHgMuELAA/BCxgPIz3GgANQHWYCIGYAA +pBABANmguBiCA7oYhAO3uaQYQAADwBMIngXPcqAASAhAIgEjBvBAIgEhz3KgAEwIBMACwwNxZXgF +JRUgB2nPcwAA/P9keM9zgQD4FGODCCDEAM9zoADUBzWjABpABQIiASUvowIkAQA7o/Cjz3GAANwt +DRICNgCBPQiAAM9woAA4LgWABCCAD8AAAAAhCIAPwAAAAPXYBbjPc58AuP8ao1ujadgYuBmjAdgD +8MlwCQhRAEChz3CBAPgUBBAFAAIjEyHPcYAATLKocIAgDwoepRDYDqUB2BUdGJAHyAQggA8BAADw +LLgDEgM2BLEPg86pAKFAEwABArEQi2ATAwFAKAQBw7sFIwMBZrEPqS8jSAHPcIAAaMpAIAQJVXhJ +gM9xgADsyVtjaaCkFQAQ+BUCEKBwQnhFwAHYz3KgANQLEKIDwDW4wLgXuAAggg8ADgAAz3CBAPgU +AoACuCvgBCCADwAA/P9FeOxyAKIBEgI27HBAoM9wgQD4FEKA7HBAqA3IFCECAFCK7HBAqOxwwLAD +yJQQAgDscECgDcjwJAIA7HBAsOxwwLDscMCg7HDAoAcSAjbscECgA8hAkFQQAAEQukV47HIAogMS +AzYBgx8IHgFSi3CLz3CBAFAOdngAiIYgfwwceAS4RXgC8IDY7HIAqgPIO3ZQiDMQgAAEugV67HBA +qAPIGnZckOxwQLADEgM2z3CAAHw6nBMCAW+DJrrAusC7DLoNu2V6QKANEgI2ACKAD4AAFMrAqM9w +gACYyVZ4VHnAsQKQwBmEAxUkggB4GQQAz3CAAJQcBIAakNAZhANGwM9wgQD4FAKAwKKA4MonjhMK +Ay4AyiGOI8l1yXc6dkwgAKCz8hPwz3GgAPxEHYE5gQQhgo8AAAAIEfQEIL6PAAYAAAv0TwsfQM9w +oAD0BweAAN7VCN6HLfAA3vq4yiaCHwAAAQL5uMomgh8AAAIC/LjKJoIfAAABAgrqz3OAAHg0UIOK +JggSAeJQoxYMgA4R8AHZz3CAAGA6IKBuCWANKHDPcYAA9DQNgYomCBIB4A2hBSePkwvyYQIgAADe +hBIAACEIlAyTCx9Az3KgANQHD4IQeBkSAYZY4OcJBIAK8M9zgAD8MySDiiEQIQHhJKOJCZ8gHhpY +gx0SAIYHGhgwHRIAhkrAHRIBhgTIIKAdEgGGIaAdEgGGIqAdEgGGI6AdEgGGJKBWJQASHhoYgB0S +AYZALwIkMHgFIJUABBICNoYh8w8AEhIBjCEMgAGCQ8AW8hrYFfDPcIEA+BQIEAQAABAFAAohwA/r +clfYz3MAAIwToQVv/4y4AN7R8CDYmnADcBB4choEAADeCwgRIAPIc/ADwBEIngXPcaAASAhAIgAj +B/BAIgAhz3GgAEwIR8EDcEjABMECwCV4BSUVIAjAB+DPcYEA+BQjgQQggA8AAPz/CCBWAAwmwKQu +AS0AScAWDQAABScPkJj0AdnPcKAA1AcUGFiAVSVBFA8YWIADCh9CCMDPcqAA1AcVogfDAiIAJQAb +QAUPognDAibAIBuiA9gQoirAnOAA2ZD0BxIONgDABCaCH/EAAPBQcJT0A8jpcsi6AiOTJQiIDLhF +eAMSAjcQukV47HIAogrAQCFZMAEaGDAEyAMSAjYodkHFAxoYMAQamDAhgACQAcU0ucC5NHgD4EDl +BCCADwAA/P8dZQ0SATYG8BUiQDAOEAAGAn0VIkAwDhAABu8NBZADzM9xnwC4/xihz3CgAPxEXYAE +Ir6PAAYAAF30GQgQIATIUIhTIsEAhiL+A0S6xBiCADCoz3CgABQExKAHyM9xoABILB2hz3CBAPgU +AoBAIFAgEnAgBc3/C/DPcoAA/DMjgoohEiAB4SOiA/A6d64MAAVTIX6gBfTSCwAABX+fDxAQiQ9e +EAPIKYgB4Smoz3GAAPwzBoEB4AahQPAKIcAP63IoFAUwPNiMuM9zAAAbFLUDb/9KJEAAABQEMEfY +CiHAD+tyjLjPcwAAIxSZA2//uHZMIACgz3GAAPwziicQEAj0B8jPc6AASCyKJwgQHaMPCp4GBYGA +vwHgBaG48QaBgb8B4AahtPERDx4Qz3GAAPwzBYEB4AWhOncDyOlxyLkIiAy4JXgDEgE3ELkleOxx +KnSEJAKRAKFAIU0wFPLPcaAA1AeAGcAEA8wqcsi6ELhFeOxyAKLMoQHYFBkYgPoIoA4B5QMSAjaS +EgABBBIBNg0InwKSEQMBbQueAqq4khoEAJIRAAGquC4NYAiSGQQAENnPcKAA0A8QGFiAJBABhs9y +gQAIGUWSMHkCukV5DBhYgBTZEBhYgM9xgQAIGWeRRpEY2RC7ZXoMGJiAEBhYgM9xgQAIGWmRSJEQ +u2V6DBiYgAbwz3CBAAgZyqjPcqAA1AvQoq8JECAF8AjZ7HAgoAHlz3CBAPgUAoDzDQSQz3CAAEyy +JJCU4cAhhg8AAJMAz3CgAGgs8CBAAM9xgAB8OiCBz3WgANQHJXgNogPYEqWaDwALDQ9eEh4Pr/8B +wAfwA9gTHRiQFB2YkykIECDPcKAALCAwgAXAMHAB2cohhgMEIIBPIAAAAIDhzCAhgPHzz3AAKAgA +BhoYMAbABg7gBMlxUSFAoKryz3CgACwgz6Ck8M9wgADMMRGIOQgeADUIHkPPcYAAlBwjgc9wgADM +MRCIELgyIYEPAADYAp+4gOEB2cB5D7kleM9xoAD8RA2hGwsQIM9woAD0B2AYwATPcYAA/DMDgQHg +A6HPcIAATLIkkJThwCGGDwAAkwDPcKAAaCzwIEAAz3GAAHw6IIEA2s92oADUByV4z3GgANQLDaFM +ploOIA0GwBkWAJbA4KAADgANzJkIXgAD3SAeWJMB2BQeGJAEEgE2ABYEQAcaGDEAFgVAARpYMQTK +nODKIsIHyiCCDwAA3A7KI4IPAAD0CuQAYv/KIcIPKHBmDeANDtkPFgCWBBIBNrQZBAATHliTEIlT +IMIAhiD+A0S4xBkCAFCpz3ASIAAA/g0gAw0SAjYEyM9xoAAsILAQAAEvgWTgMHDKIIUPEigIAIX3 +z3AAKAgABhoYMADeDcwEIIAPAAACCBcIkQAEEgE2iiAEAMoK4AiYEQEADcjPcYAA/MnPcoAA0MgU +ec9wgQD4FMCxIoAGkhlhMHkmsq3Yz3IAuwC7tgpgBgW4A8gakCoJoAYNEgE2wQDv/avA8cDhxU8I +XkPPcIEA+BQBgM9xoADIH5YgQQ8eoRDYDqEB2BUZGIDqDGAOQdgnCF5DAdnPcIAAYDogoN4KIA0B +2M9xgAD0NA2BAeANoYolCBIt8M9xoAD8RB2BOYEEIYKPAAAACADdB/QEIL6PAAYAABjyAN36uMol +gh8AAAEC+bjKJYIfAAACAgnqz3OAAHg0UIOKJQgSAeJQoxYNQA4H8APZz3CgABQEJaBxAO/9qXDx +wPIPj/0Idc92gAD4CwCOqMHPCBEAi3fpcM9xgAAIQJYI7/0g2gHYAK4A2I+4CxocMADYFRoCMM92 +gAAAAKC2Dw2BHwAA/soHwIC4R8DPcKAArC8agFIgAAATCB4AAZaAuAG2B8CBuEfAz3CAAOhMoIgO +CuADqq7PcUN1qBJAwYohGgpBwSuOBKYNHEIzRsBjwc9xgABANkTBz3GAAKw1z3WAAPAFAIVFwYDg +yiDBA8ohIQjKImEAyiNhD4wLYQvAK+EFAIWA4MogIQLwDqEEyiFhAALZz3CAAOAiJKB9B6/9qMDx +wAoPj/0ods9xgACUHC8gByCE6GGBA/BggcQTAwYlu/AhDQDAu4DmoqGjocwjIYAB3colIRDPc4AA +3B/oiysPURLhgcQXDxYfD14R7JN+kRcPwBARCFAAh+gAgcQQAAYHCF8BAN2B4solIRAA30IIoAvp +cApw1gigBalxz3CAAOAiBIAjCJ4Az3CAABQwAICL6M9wAAAWCbILAAQLCFEAig0ACgzwANmeuc9w +oAD8RCGg4HjhoPoPYAsA2IDmsAliAMogYgA6CwAEheg6DcAMA/BuDcAMz3WAAMwMAI2G6LINAAwB +2ACthQaP/fHAIg6P/c91gADQyCSVEunPd6AALCBQhwDeBoVHpaIPr/0OIIAACKXEtRCHxbUGpVkG +r/0IheB48cDPcYAA0MgAEQQAuHDPcoAADChALIAAFXgVIEABMCIGABkOEQEKIcAP63KKIMwMNQUv +/4ojxQJPDhAAIw5QAC0OkAAjDtAACiHAD+tyiiAMDYojRQsRBS//CiWAATIKAADRwOB+FgkAAP3x +A9gJDFAAAKEA2AWhBIGguAShvghgAAPY7/Hv8fHAz3KAANDIBpIB4CeSEHgdCSMABrIEig0IUQAF +ioHgAdgD8gDYgOB4CAIA0cDgfs9wgAA8yyCQRCEAA2MIEQIA289ygADQyGWiBIKguASiPQmfAQSS +z3GAACjJAeAkgRB4HwklAASyBIoPCFEABYqB4AHYAvIA2IDgKAACAM9wgADkKwOACugD2Anwz3GA +AOQrA4EC6GOhBNhZAQAA4H7xwM9zgADQyAQThAANDFEABYuB4AHYA/IA2IzoBROFAAohwA/rcoog +jQ4VBC//ztsC2ACjANgkkwmjBaMGsyqjJIOguSSjtg6gBQSz0cDgfs9ygADQyADZJaIkggPYAKKg +uTUGoAskogDZz3CAANDIKqDgfymg4HjxwE4Mj/3uD8//z3CAAPzIYIDPcoAA0MiogGCiz3aAAFwo +BIKoogDZwIaguCWiBKIjDlEQguPMI+KAEvTPcIAA5CsjoATtlg/P/wrwSgoAAAbwAdtgoiiioLgE +ol0Ej/3xwO4Lr/0A2M9xoAAsIFCBz3aAANDIJI7PdYAA/MgIpQsJUQAljgkJUAAB2KLoKoYc6QaG +Ug2v/Q4ggADPcQAAECclCQUAz3GBAHgUJYGZIc0KGQhFAAXwz3AAABAnCKUC2AfwANgH8AmG+OgB +2AClAdjpA4/94HjPcoAA0Mgkgg8hAQAkorUGIAAJ2PHAXguP/c92oAAsIBCGz3WAANDIB6XPcIAA +jDiiDmAMAN8AFQUQJw1QAEwlgIDMJeKAPPIKIcAP63KKIEwNiiMIB5kCL/+KJIMPBJXPCBAA7gzP +/89wgQB4FAWAKIWZIM0KMHAB2MIgDgCzCBAAz3CAAHQr6aDXcQAAECdvIAsAEegEjQ0IUQAFjYHg +AdgD8gDYBegKDs//QfDPcAAAiBMIpU4Oz/878ASVmugllQiFgeHAIIEPAACIEwPyG3jPcYEAeBQl +gQilmSHNChBxAdjCIA4An+jWCAAAH/A3CFAACIUdeNdwAAAQJwilbyALABHoBI0NCFEABY2B4AHY +A/IA2AXomg3P/wfwz3AAAIgTCKXeDc//BJUFteS1EIapAq/9BqXxwM9xgABIjkGBz3GBAHgUJYEF +Kb4AMHDKIE4ADCEA8M9xAAAQJ7ILr/3KIEUOz3GAACjJBKHRwOB+4HjxwOHFANjPc4AA0MgAo891 +oAAsIBCFAdnPcoAA/MgGoxCFIKIGos9wgAB0KwOIJKuMIIOGJKoE8iWqJavuCyAAA9g1Ao/94HgB +2c9wgADQyOB/IKDPcIAAlBwDgM9xpAAcQAiAwLgTeMG4EqHgfuB44cUA2kokAHTPdYAARJHPc4AA +vJFIcKggAANAIwECFHlAsRYlARBAoUGhAeBKJMBzANmoIEACz3CBAHALNHhAsAHhz3CAALwGQaDP +cIAALI5MsOB/wcXgeAXwQnnHcEAAAADPcoEAeBRFgvMKRIBTIEMFcHHAII0PQAAAAMAgjQDgfyJ4 +BvBieQIggA9AAAAAz3KBAHgUZYLvC0SAUyBCBTpiCwuEADhgB/ACIIAPQAAAAGJ4OGDgfvHA0giP +/c9wgADIywyIGQjfAQK4z3GBABAMFngFYS29wL0D8P/dug7AAwnoz3CAANwfCIiH4ALYAvIA2M9x +gAAomHeJz3KAALS7IYIJC0AAIIKE6QHZA/AA2Rpxz3eAAJQcIIfEEQEGiwleAYcNERAjhziJfwkQ +Aa4OQAzPcYAABDM1CBAgz3KAAPgGAoIB4AKiz3CAADg6ANpAoM9wgACUOUCgz3CAAAAGQKARgQHg +EaEF8BCBAeAQoa4Lz/3PdoAAMAcglhMJXgAmCoAOAJahuBB5ALYfCZ4BOgqADs9xgACcrwuRAeAQ +eAuxAJamuAC27g3AAw/oz3CAANwfCIiI4MwlYZAH9B4OYAwB2LoNwASMJcOfRvIjCBAgz3GAAFQT +AIEL6ADYAKHPcYAAjCMAgaK4FgigCAChZgsADM9xgQB4FAaBRSBAAQahz3aAAPiQC45RIMCA8AjC +/QuOUSCAgGAMQgP2CQADhg3AA4DgtAoiAMogIgYG7QCHxBAABiEIXwHPcYAAHDAEiQroA4mA4KAL +4QrKIOEAjgogABXYlQdP/eHFz3GAAFgTAIkB22GpJOjPcKAAsB95oM9wgAAIGwiAo4FggAKBANox +DQEQz3CAAHATAIiD6AHYCvABgQIjDQD3DYWfTABAS0GpSHAHCFEAYaFCqeB/wcWioe/xgOAB2MIg +DADPcoAAWBMAqgHYAaoA2AKqAaICogOi4H8kouB48cDhxQh1Ewg0BJhyDtjiCi//ANqD6BPdLPDP +coAAKJhIcAoK7/0M2c9xgABYEwCJDujPcIAAPMsAkIYg/ACMIAKABvQFkmSSZ3gDoUIlABOyCyAF +iHEKJQCQDPTPcIAAPMsAkIYg/ACMIAKAFA/B/7kGb/2pcOB48cCYcLhxnODKIsYHyiCGDwAA4w7K +I4YPAACDAJgF5v7KIcYPTCWAgcoixgfKIIYPAADkDsojhg8AAIQAeAXm/sohxg8A2s9xgAD0ip66 +FSFBAQCBASoCAUZ4Wg+gBgCh0cDgfp0H7/8F2eB48cDhxQDdz3CAAPSKlg0v/xzZG9imCCAABdlK +JAB3z3GAAHgTqCDAAhYhQAMEEAUAmHUPDUERQCRNAA0GT/0KIcAP63J32AW4AQXv/lPb4HjxwM9w +gAD0ihgQBQAvLEEBTCQAh8oixgfKIIYPAADiDsojhg8AAKsA0ATm/sohxg/PcIAAeBMWIAABAIBA +eNHA4H7gePHA4cXPcAMAQA3PdaAAyB9FHRgQqg/P/4DYFR0YkJUFT/3gePHAmHC4cZzgyiLGB8og +hg8AAOMOyiOGDwAAYwB0BOb+yiHGD0wlgIHKIsYHyiCGDwAA5A7KI4YPAABkAFQE5v7KIcYPANrP +cIAA9IqeuhUgQAEggAEqAgFFeTYOoAYgoNHA4H6dB+//BdngeOB+4HjgfuB44H7geOB/AdjgfuB4 +4H7geOB/ANjgfuB44H7geOB+4HjgfuB44H7geM9xgACAMxKBAeASoQ3Ix3CAAAjKLIgB4S95Fwly +ACyoiiAIAAYaGDCK2JC4B/CKIBAABhoYMELYmLjgfuB+4HjxwDoMT/2YEAIABCKBDwAAAAg7eQQi +gw8AAAAQJXvPcYAAlBykgVYlThRWJQ8VmBCBABUKXgKGIf8DRLkvZ4m/6XEZ8FEiAIK8FQIRDPLC +uYAlAhk/ZeiPPWUwjWV/8H9FeQnww7k8eT9mPmYwjuiPRXmIGMADZXkpBG/9jBhAAPHA4cUDyKQQ +AQCYEAIAUSEAgHIQAQFIcAbycgkgAgDaCHUH8AHhZgkgAgDarGi+DIAMz3KgAMgf+BIBAAPIz3OB +ABAMEIgCuBZ4AGPtuM9wgAAIGwj0AdtzokiAQIIMgGCACPAC23OiSYBAgg2AYIACJUAQWGAQcsAj +bQANcQChDXBgoAAWAEAAFgBAA8jPcqAA9AdwEAEBaLknonAQAQFouTB5jQNv/XAYRADxwA4LT/3P +dqAAyB+gFgQQ+BYDEADfSQgRAQMSATakEQAAdhECAREIHgXPcIEA+BShgATwghENAQ3MUSAAgYQR +AAEJ8gIlwRACJEMACCMDAATwhhEDARtjaHFx8JUIUQANEgE3A8h4EAIBRwkeAVEhQIDPcYAAlBwk +gVQRAQEJ8n4QDQEifWJ9AiRDAyvwgBADAc91gQDwCgAjRABwiHZ9YJUAIw0BhBADAbtjG/CkEAEA +FQkeBXCIz3GBAPAKdnlgkQTwghADAc9xgACUHCSBgBANAVQRAQE9ZbtjhBANAbtjgBANAblhfhAN +AUJ9J/BDCJEAAxINNg3MeBUCEVEgAIHPcIAAlBwEgFQQAQEJ8oAVABEieGJ4AiQDAAfwghUDEYQV +ABE7YxtjgBUNEUJ9BfDpc+ly6XXpcQ3MEQheAAPIdhACAWK6OmIM8BULcgBius9wgACUHASARhAA +ARpi+BYAEF1lAn0fhhkNBBCg2A+m/6ZfpgLYFR4YkIDYDqb1AW/9cHjgePHAhglP/c9xgACUHPAh +AgBWIkUECIJWIgQFUSDAgIogCADKICEAvBoEAEokAHIA2aggQA/PdYAANE38ii5l5H4vKIEDTiCD +B89wgAAcT29gACVDAOCrRBKPAOR+Ly6BE04mjxfuYMiryIIhDt4QHYqG4dMgpgAvKAEATiCNB89w +gACUTKhgEfDPdoAAXE0uZs5lvIrEfVgSjgDEfS8tQRNOJY4XyGAQqwHhSiQAcgDbqCDAD9yKz3GA +APhOb2HPdYAAHE/kfi8ogQNOII8H72UAJcAA/KhEEo8A5H4vLoETTiaPF+5lJBiCA8iCHw7eED2K +gOPTIaEALylBAE4hjQfPcYAAlEypYRDwBOvJawPwaHbOYTyKxHlYEo4AxHkvKUEATiGOB8llLBhC +AAHjSiQAcQDYqCAABc9xgACQTH2KCWEAJAwAAeBkeS8pQQBOIYMHz3GAAJRMaWEgrJEAT/3hxeHG +z3OkALRFKRMAhs9xgACIMsgZAAArEwCGzBkAAM9wpQAIDAOA5BkAAA4TAIYQejC41BkAANAZgAAP +EwCG2BkAAM9wgAB4y9SItojoGYADeIjsGUADDZDwGcAALOACIIID9BmAAAIgQgNiePgZgAD8GQAA +wcbgf8HFz3CAADw6BoADgCCAz3CAAByL4H8poOB44cXhxphwz3KAAFgUBYIggmaCyrgQuMq5BSEB +gAGCyrsQu8q4BSMFAGeCAoLKuxC7yrgFIwcAaIIDgsq7yrgQuwUjBgAk8gAUDgAvKEEATiCDBwDY +DyDAABJ9BCBDAaR+ZX4AHIAD2oKkfsV7eqJ5ggQgjgEEIMABpHvFe3mieIKkewQhQYNleBii3/XB +xuB/wcXgePHA9g4P/TpwBYGggcq4ELjKvQUlDZABgSaByrjKuRC5BSEQAAHeGfIEJYCTE/IvKAEA +TiCCB/AhgSAA3w8njxAI6QQnABRCIACAYHnKIGIA5n3bfurtAQcP/eB44H8A2KHB8cCaDg/9o8EI +dkfAz3WAAFgUG4U6hfyFJHgEfwcnj5NBxxb0sQ4REJIJYAQK2KUIEAAKIcAP63LPcAAAjROKI0cA +SiQAANEFr/4KJQABBBQBMRjpHBQAMQsgQIAN8s9wgACUI2CAz3EAAIxaDNhgewPaCPCI6M9wgACQ +IyCAYHkM2AYUATEY6R4UADELIECADfLPcIAAlCNggM9xAACMWg3YYHsE2gjwiOjPcIAAkCMggGB5 +DdgLJ4CTBfIyCe//CtgH8IfuAgjv/wrYVggAANylCNwzBi/9o8DxwMYNL/0A2s9zgABYFDuDuoMA +3g8mDhCkeQQmQBBCIACAyiBiAC8mB/AB3coggQAH8hyDJHjyDu//xXipcPUFD/3gePHA4cWhwQHY +QMDPdYAAWBQKhRsIHgCLcATZZ9o927oJ4AoXuwqFoLgKpc0FL/2hwPHASg0P/RpwKHVId2h2OGNm +2T3a+gngChe6FwhRAApw1gngCqlx6XCmCeAKyXGBBQ/94HjxwBYND/2mwSh1GnJgwADYARwCMAHY +AhwCMAMcAjCLcGoLIAeBwQbtBMEKcGB9BcIDwY7pCiHAD+tyz3AAAIwT7tuKJMMPUQSv/rhzYHkA +2CkFL/2mwOB48cC6DC/9Admiwc91gABYFBqFW4UEehyFBCCQgC3yA/A7eQQgQKD+8y8oAQBOIJEH +XB1AFBUlTRQdhYDgyiHBD8oiwQfKIIEPAACPE8ojgQ8AABwCyiQBBOQDof7KJUEEJgjP/x2FQHje +D4//ANgPIEAEBiAQILIN7/8KcJ0EL/2iwOB44H7geAHZz3CAALQl4H84oOB+4HjxwHILgAPPcAEA +xD8J6M9xgABYFLgZAAAbgZG4G6HPcAEAPD8I6M9xgABYFB6hG4GBuBuhz3AAAPBcCujPcYAAWBSU +GQAAG4GIuBuhz3AAAPRcCujPcYAAWBSYGQAAG4GJuBuhz3AAAABdCujPcYAAWBScGQAAG4GKuBuh +z3ABAIxGCujPcYAAWBTYGQAAG4GZuBuh0cDgfvHA4cWhwc9ygACkss91gABYFBeFANkPIQEAGIUk +eEIgAIDKIGIAAdsA2SMIUQAI2GDAARxCMAIcwjADHMIwi3AE2QYO7/+KIwgACNgA2S4O7/8ocgDY +tQMv/aHA8cAuCy/9CNnPcq3e777GCuABOnC2DyAAKnCRCNAAz3CAAByLA5BOIM8BUQ/VEc9wgAC0 +DE4NYAD0IMADAN4A3QTYGnAqcOlxyXIKJIAPrd7vvoIK4AGpc8oPIAAqcE0I0ABCIEAg3wh1gAHl +AebTDpSQAee7D9SRKnDPcq3e775SCuABENlGDyAAKnAdCNAAz3Gt3u++PgrgASpwCg/v/ypwg+DK +ICIA5QIP/fHAhgov/QPapsEacI4JYAuDwQPBz3CAAAQOFBQHMADe8CBFAM9wgAAMDvAgRgDPdYAA +gAcO2MSlQMAE2EHAz3Ct3u++QsAEwgpwgNvaCeABmHPOCSAACnB9CNAAA8PPcIAAJA5ChfAgwQDA +pQwVEBDBpQjpz3eAACwO8CfAEIbowKXBpQDZGfCEKgwDpghgAC9wDiCBDwAAAAEgpQPAhCgMI/An +ARCOCGAAL3AOIIEPAAAAASGlBIUbCFEAAIUReIwgB43C98ClMXmMIQeNw/fBpQDYFQIv/abA4Hjx +wK4JL/0E2qbBtghgC4txz3AAABvSAN2pcRYMYACpcgDBz3AAABzSBgxgAKlyAMHPcIAAYAwBwhUg +QQAAkQLBBbrSDGAARXkDwIDg2gAFAM92gACAB9LYCLgZ2dILYAAA2s9wAAAi0kAmARIKCmAABNrP +cAAAI9JAJgET+glgAADaz3AAACDShMHuCWAAANqFx89wAAAh0ulx3glgAADaAoYX2XIO4ApAJgIS +A4YX2WYO4ApAJgITBMAX2VoO4AqEwgXAF9lSDuAK6XIChgDZhg8gAIu5AqYDhgDZeg8gAIu5A6YE +wADZCLhuDyAAi7kIdwXAANkIuF4PIACLuSKGMXkZ4QUpfgAjhi9yUHcxeRnhBSl+AC9xzCBFgIX3 +A8AB5TcIRYMDwA8IRQMB2c9wgACABySgANjdAC/9psDgePHAcggv/QnaqcEIdnIPIAuLcaoLb/0h +wAhxQti2C2AABbkMFAQwAMHJcAbCCiWAD63e777WD6ABAsOeDiAAyXBVCNAAAMEFws9wgACoDADd +8CBAAATBCroEIoIPDwAA/Mm5RXmKCmAAqXKaDKANBdggFAQwAMHJcAbCCiWAD63e776KD6ABB8M6 +Du//yXCD4MogQgNJAC/9qcDgePHAsg/v/ALap8GacNYOIAuDwc9wgAD4QACAANlFwM9wAAAR0i4K +YAAocs9wAAAS0gDZIgpgAChyz3AAABPSANkSCmAAKHLPcAAAFNIA2QYKYAAocs9wAAABRAfZ9glg +AADaz3CgALQPcBAXAAYJ4AoB2PYLoA0F2LzYvgpgAADZw9i2CmAAANmKIEQIqgpgAADZiiAECqIK +YAAA2SXFtdiWCmAAqXGKIIQGjgpgAKlxA9hAwATeQcbPd63e775Cx4pwBMEDwh7bmHNKJQAASiYA +AJ4OoAFKJwAAjg7v/4pwg+DX8s91gACABwgVFhAMFRIQDthAwEHGQseKcATBA8Ie25hzSiUAAEom +AABiDqABSicAAFIO7/+KcIPgufIIFRUQDBUQEA7YQMBBxkLHinAEwQPC4duYc0olAABKJgAALg6g +AUonAAAeDu//inCD4J/yCBUREAwVExAD2EDAQcZCx4pwBMEDwuHbmHNKJQAASiYAAPoNoAFKJwAA +6g3v/4pwg+CF8sKFo4XqD6AKLyDHBQTBz3KAACQOAiFApc9zgAAUDjV6AKICIwAkz3KAACwONXoA +osPaNXtAo89zgAAcDjV7QKMh9O4JQAMKIcAP63IQ6M9woAD8RHQQBABkEAUAz3AAALETZQVv/ooj +SQrPcAAArROKI4kKSiQAAFEFb/4KJQABnOiuCUADCiHAD+tyEOjPcKAA/ER0EAQAZBAFAM9wAACx +EyUFb/6KI4kMz3AAAK4TiiPJDOHxAiWAJdlgAiFBhBDyAiVCJAx6LgwgAC9wBMICJQEgz3CAAAQO +VXggoAIggCS5YAIhwYQQ8gIgwiQMegYMIAAvcATCAiABIM9wgAAMDlV4IKAA2G0F7/ynwPHApg0g +AADYz3AAAA3SANmuDyAAANrPcAAADNIA2aIPIAAA2s9wAAAV0s9x8w///I4PIAAA2s9wAAAb0gDZ +gg8gAADaz3AAAALSoNmauXIPIAAA2gnYjLgA2WYPIAAA2hTYjLj/2VoPIAAA2gDYjLj/2U4PIAAA +2hHYjLj/2UIPIAAA2gLYjrgA2TYPIAAA2gHYjrjPcQAA//8mDyAAANrPcAAAC9IA2RYPIAAA2s9w +AAAN0gHZCg8gAADaz3AAABLSANn6DiAAANrPcAAAE9IA2e4OIAAA2s9wAAAU0gDZ3g4gAADaANjR +wOB+8cBWDM/8pMGLcQHdVgsgC6lyz3CAAPw/AIBBwATYmg8gACzZDtiSDyAAANkhxrXYhg8gAMlx +iiCEBn4PIADJcYogRgByDyAAyXEAwIDgzCCigMwg4oDMIGKBzCCigcwgIoLMIGKCzCDigsohQgMD +9APZgeDMIKKAzCDigMwgooHMIOKBzCAigswgooLMIOKCAN0F9IG5L3mA3YTgzCBigcwgooHMIOKB +zCAigswgYoLMIKKCzCDiggP0g7kvefoOIAAP2IPBRg0gABHYA8GDvaV5Q8HiDiAAEdgA2OUD7/yk +wOB48cDhxaHBi3F2CiALAdrPdYAALI0AFAQwz3CAAAAMViUBEhLabg0gAADbABQEMM9wgAD8C6lx +AdpaDSAAAtvPcIAAJAwkbR3aXg0gAADDANiVA+/8ocDgePHA/grv/APao8G6cBoKIAuLcQHBz3CA +ALAMAN/0IE4AAsHPcIAAxAyA5vQgVADPcIAAgAfgoOGgzCaikMwmYpHMJqKRyiXCEwL0AN2B5swm +4pDMJuKRzCYikgP0Ad2E5swmYpLMJqKSzCbikgL0At1qDc//qnDPcq3e7742CqAByXFGDu//qnDt +CNAAAMCA4MwgooFQ9IDmzCZikMwmIpFK9ALAkQgRAM9wgAAEDrV4WnDgoM9wgAAMDrV4enDgoM9w +gAAkDrV4GnDgoM9wgAAsDrV4OnDgoM9wgAAUDrV44KDPcIAAHA61eOCgqnDJcc9zrd7vvr4JoAGp +ckoK7/+qcHUI0AAAwQASACCG4QHZwHkDubV5x3GAAKSyAKEAEwAgBKEAEAAgG3gIoQARACAbeAyh +qnCpcclyCiSAD63e775yCaABinNGD6//qnApCNAAAMDPcYAAgAdAgQS+BrjYYBUgAAXHcIAA4LIh +gUKwI7AA2NkB7/yjwOB48cCkwYtxpgggCwTaAMABwQS4NXjPcYAAaAwQYeIMIAACwQDAAcEEuDV4 +z3GAAIgMEGHODCAAA8EA2KTA0cDgfvHAocEqC+ABi3IAwKHA0cDgfuB4ocHhxeHGuHDPcIAAtLsQ +EAYAz3CAADglBYCYcaHBhiT3D+cIEADPcIAAzDoAgB8IgQHPcIAA1DoAgBMIQQHPcIAA0DoAgMMI +AAEAHEAxIMIBFIEw8N5TIsAAxHpTIccAJH5UekAujQG0fbpiFXrPcYAApLRIYdR+CHOGI/0Pe3s6 +YkGKZXhIc4Yj/Q97e91lFSXNEb5hwo5leslzhiP9D3t7uWEjiWV+KHOGI/0Pe3tleScMEADPdaoA +4AdzhRELHgBIpQmlKqXLpRDwCKVJpcqlK6UK8Am6RXjPcqcAFEgDogm5JX7Eos9xgADMOgAZgAHP +cIAA1DoAGEABz3CAANA6ABgAAaHAwcbBxeB/ocDxwM9xAIIBAM9woACsLzygz3CAABQwAICL6M9w +gABYFgCADwiQABYMAAPRwOB+2glAAB4N4ARv2IfokgxgDQrYxglAAPPx8/HPcoAAFDAgggZ54H8g +ouB4z3KAABQwIIIleOB/AKLgeAQogA8AAC+6QinCdFB6RCr+AgIgQA4QeAPoAeJQegsIMwFAsYPo +ANgC8IDY4H7geHEHT/7xwJIPj/w6cM91gAAAGwCFAeAApRUIUQAB2c9woADIHDGgDgxgDShwZg2g +BAfYGnDPdqAA7Cfrhm4MoAYqcAumAIVCIECAAKUG9M9xoADIHADYEaFGCqAECnCZB6/86XDxwC4P +j/w6cCh1GnIiDaAEB9hacA8IniC+CWAHyNhQIJAgTCCAoBnyCPYjCBAgRQhRIBXYE7gN8CUIECQ1 +CBEo/g2gAypwAKUP8CnYErjwIEAEAKUJ8CvYErj78c9woADsJxmAAKXWCaAESnAdB4/8CiHAD+ty +z3AAAIoTe9sKJEAENQYv/golAATgePHApg6P/Ah3OnEacx8KdAAA3kh19CeAExUhgSNaD+//CnJh +vfENdZAB5t0Gj/zgePHAeg6P/KHBCHcacSMKdAAA3kh19CeAEx4IIACLcQDAFCCMI2G9ALTtDXWQ +AeaxBq/8ocDxwEYOj/yhwRpwz3aAAAAbAIYB4Ch1AKYVCFEAAdnPcKAAyBwxoLoKYA0ocBIMoAQH +2Ah3UgsgA7PYFuiLcQINr/0KcAAUADEApQCGQiBAgACmB/QA2c9woADIHDGg7gigBOlwRQav/KHA +4HjxwA0M3gAuD8//BPDaCAAA0cDgfvHADQveAEoPz/8E8PYIAADRwOB+8cC2DY/8CHWO4AHewiaN +E89woAC0D/yAPg9gCgDYyXCpcQHaogugBEhzLg9gCu947QWP/PHAdg2P/DpwKHUacmoLoAQH2Ewg +gKBacBvyDPYnCBAgTQhRIBXYE7gVIEAEoKAb8CsIECQ5CBEoKnCeDKADqXER8CnYErgVIEAEoKAL +8CvYErgVIEAEoKAF8M9woADsJ7mgIgigBEpwaQWP/AohwA/rcs9wAACJE0rbCiRABIEEL/4KJQAE +4HjxwPIMj/wIdzpxGnMfCnQAAN5IdfQngBPwIYEjXg/v/wpyYb3xDXWQAeYpBY/84HjxwMYMj/wI +dxpxHwp0AADeSHX0J4ATGgggAPQggSNhvfMNdZAB5gUFj/zgePHAlgyP/Bpwz3aAAAAbAIYB4Ch1 +AKYXCFEAAdnPcKAAyBwxoA4JYA0ocGoKoAQH2DpwqgkgA5PYGOiwfUAojyGBvxC9pX/PcKAA7Cfm +oACGQiBAgADZAKYF9M9woADIHDGgPg9gBCpwjQSP/PHALgyP/M91gAC0uyKFz3asAJABCQlRAxiN +h+h5CdECGI11CBEA64YwFhAQz3CAALAjIIBgeQLYIoWe6Ke/EQlRA0YgwCNFIAADE/DPcIAAqCMg +gGB5ANgPCFEERiDAI0UggAMF8EYgwCNFIIAC66YMphbwjeHQJ+ER5fPPcIAAqCMggGB5ANiR4NAn +4RHo84e/2fEF2AymoNgLpvUDj/zxwOHFCwgyDAh1HQ2SHgohwA/rcs9wAACaISLbmHXxAi/+uHNC +JQAc4QOv/A944HjxwGILr/yYcEGBsIl3Ch4BconPdoEAEAzybfZ/5mY0yggRhQBJIMAAEQ6eFc92 +gQBQDrZ+wY4D8ADex3CBAFAOtngEiAgjAwAII4MDACNAAUkgwwMWbXV4z3OBANAPA2PPcIEAUA+2 +eM91gACUHKSFuIUBgKV4BCCADwAAAAgGewLwY4Hou5gZwAAA3QnypBEAAADdl72RuJS4pBkAADsM +HgDPcIAAlBzEgMC6yIYEJo4fAEAAAD6+HubYekV7mBnAAB0LngekEQAAhSUBFIy4kbikGQAAnBlA +Ax7wJwveB6QRAgCFJQEUlr2YvY26kbqkGYAAnBlAAySAEIGeuBChCvCUvZa9nBlAAySAEIGeuJ+4 +EKG1Ao/88cBGCq/8A9jPdoAAqCMghkB5gOBt8iCGYHkE2NMIEAAghmB5ANhnuBUIFQMzJgBwgAA0 +PkAnAXIUeQB5ANhC8M9wgACwIyCAYHkB2IDgAdjAeDjwz3WAALAjIIVgeQHYIwhQACCFYHkB2BsI +0AAghWB5AdgPCJAAIIVgeQHYwQhRgAHYHvDPcIAAsCMggGB5AdiF4AHYwHgU8M9wgACwIyCAYHkB +2IHgAdjAeArwz3CAALAjIIBgeQHYg+AB2MB4LwhQACCG63VgeQDYGnDPcIAAsCMggGB5Adi4cDfY +CiHAD6lylNvhAC/+CiQABL0Bj/zgePHAz3GAAHwHAIEhCFAACiHAD+tyz3AAAIcniiNEBkokAACx +AC/+uHPPcoAAeAcAgoLgzCDigcohwg/KIIIPAACIJ8ojgg8AABoByiLCB+n1NwiRAM9wgABCB2CI +z3CAADrNhCsfADIgQA4VCB4Az3CAAASYIBCAAAkIUQAD2CHwAtgAoh/wz3CAAASYIBCAAC0IUQDP +cIAAQgdgiM9wgABIzYQrHwAwIEAOCujPcIAARAcAgIYgOY8I2APyAdgAogDYAKHRwOB+8cDPcIAA +eAcAEAQAz3GAAHwHABEFAEwkAIHMJWGAyiLCB8oggg8AAIknyiOCDwAAUwHYB+L9yiHCD89wgABQ +BwCAANvPcoAATAcPIwMAAIJmeACiz3CAABTNIBCDAIHjBdgX8sLjz3KAAGgwCYIN8owjwoEG8owj +goIH8oC4B/BFIMAAA/BFIEABCaIC2ACh0cDgfoDgANrKIIEAEfLPcqAAsB8B23miz3KAAAgbSIJg +ggIjQgBwccIibQBCeOB+DcjHcIAACMo0iAHhL3k0qB0JMgEDEgI2z3ADAIQAoBoAAIogCAAGGhgw +C/CKIBAABhoYMM9wAgGEAKAaAADgfs9zoACwHwHaWaPPc4AACBtog2CDBOgiewkIxAAA2APwSHDg +fs9yoAAsIHCCCegCI0IAEw6EcACAAAAPCIQAANgE8P8IxYAB2OB+4HjxwEIPb/yYcKXBKHe4cwDe +BCOAD/8AAAAYugV6b3kIuf/YCLhkeCi4BXlFeQjd9CSAAyd4RMB6CqALEBQAMRIUAjFhvUAoAQQF +eUd5RMEQFAIxFCSAM0Cw1w11kAHmUyXCBUCnABQNAQfZB/AQfRQnTBAAtGG5FCRAMLt7T70AkKV7 +cHvpCbWAeGAEIIAPAAAA/xC4BXpApxEHb/ylwOB48cDWCGAGANjWCK/9ANjPcIAAuDmqCY/9z3CA +AJg5ogmP/fYMz/5GCgAIANj6CeACgNl6CEALTg1AAkILgAsiCYABvgyAAgDYvgkv/whxDg1ACi4N +gALyC2AB/9iKCEABiiCFDwhxOgggBQhy0cDgfvHANg5v/Iog/w/PdaAAOC7HhQelz3CgAFQuC4DT +uAYmAHAPAP//ogigDBbZJg6AAcelcQZP/OB44H7gePHA4cUA3c9wgADABqCgz3CAACyOrLA+CqAL +qXCaD0/9ygkgC6lwMgqAAx4OD/4OCEABiiAGCghxug/gBAhyagzv/KlwQgzP/CUGT/wA2c9woADs +Jyug4H7xwJ4Nb/wD2c9wgAAQi5YJoAwA3c92oADIH4IeWJNKJMByqXGoIAACz3CgAIAfNXigoAHh +AtiLHhiQTNiLuIMeWJODHhiQD9iIHhiQz3eAAAAbAIcB4ACnDwhRAAHYUR4YkNIJAA0B2c9woADs +JyagAIdCIECAAKcD9FEeWJMCDsAAhQVP/OB48cDhxaTBi3ASCaAMBNnPdYAAABsAhQHgAKUXCFEA +AdnPcKAAyBwxoIIJIA0ocACFQiBAgAClB/QA2c9woADIHDGgtg3AAEkFb/ykwPHAocGLcMoIoAwB +2Z4NwAChwNHA4H7gePHAocGLcF4IoAwE2QDAUSBAgPALYgbKIKIAAMBRIICAFAzCCgDAUSDAgOQL +ggYAwFEgAIH0CIIG7g6gCwHYz3GAruAB7HAgoAHI7HEAoc9ygABUi4okgX0A2aggAALwIkMA7HBg +oAHhbg3gAADYocDRwOB+8cDhxaPBAdhAwM91gABYFKlw3g9gDFzZ6g/P/jqFG4UkeDyFBHmBwIYM +L/9BwQHBG4UkeEHAVSVAHwoNL/+pcc9wgADQFf4ML/9AJQEbi3DGC+AABNlODS//AcAAhYboBYWA +4FwOAf9aD8/+SQRv/KPA4HjxwOHFz3CAALw/AICiwUHAgcAB3boPYAypcUDFi3CGC+AABNkdBG/8 +osDgePHAocGLcJ4PYAwB2QDALyQHAAAcADEbCN4BBxIFNgohwA/rcoogxQDxAu/9J9uCDmABQNhK +DMAAYg/ABqHA0cDgfuB48cBeC0/8z3WAAMQaAoUjhQHeEHHAfqlwRg9gDAPZHgzAAATuAoUD8ACF +oQNv/AOl8cDhxc91gAD0BalwIg9gDALZ+gvAACCFC+nPcKAALCBQgM9wgACwNtIOIAtZYXUDT/zg +ePHA4cXPdYAA3BqpcJoOYAwQ2QAVBBAhDFAAQQzQACkMEAEKIcAP63KP2I24mNtFAu/9uHMBhQy4 +BCCADwEAAPABpQzwIYXPcIAA1C8goCOFz3CAAE8TIKgDzNdwAAAAQAHYwiAKABe4x3AADgAAg7id +uJ+47HEAoQESATbscCCgmgvgAAHY6QJP/OB48cAA2M9xgADsGgChAaECoc9w0P4AAAShABYAQAAW +AEAAFgBAABYAQAPM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChARIBNuxwIKA+C+AAAthW +DUAC0cDgfuB48cAAFgJAocFAwgEUgDAPCB4Az3GAALSNBPDPcYAAOK9AoWCJAdoI8AAWAEAVIYwA +AKQB4n149QiFgBcLHgAAFgBBA/AA2BUhjAAApAHi+QpUgQPM13AAAABAAdjCIAoAF7jHcAAOAACD +uJ24n7jscgCiARICNuxwQKDSCuAAAomhwNHA4H7gePHA4cXPdYAAlAepcCYNYAwI2QCFz3GgALge +AqEBhQOhQgrAANUBT/w5AsAA8cCkwYtwAg1gDBDZA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbif +uOxxAKEBEgE27HAgoADAUSAAgAPABvQCweYO4AAA2gXwrg4gAgHBLgrAAKTA0cDgfgkAAAAFAAAA +8cDWCcAAKQeACuB48cDhxbTBi3WpcOYMYAwU2QDAhuDMIOKBBvSyC+ACqXAIcSPwDwiRAHYM4AKp +cAhxG/ARCFEA9g3gAqlwCHEV8IPgzCAiggf0pgrgAqlwCHEL8BEIEQESDOACqXAIcQXwOwhRAgLZ +A8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxyAKIBEgI27HBAoIIJ4AAocM0Ab/y0wAohwA/r +cnzYjbh324u7SiQAALkHr/0KJQAB8cDhxaLBi3WpcDIMYAwC2QIO4AKpcAIJwACVAG/8osAAFgBA +8QDAAPHA4cXPdYAACMypcAYMYAwD2QGFz3GgAIAlDKEChQ2hAI1RIACAANiOuATyD6ED8BChvgjA +AFEAT/zgePHA1g8v/BXZz3aAAMSbygtgDMlwngjAAAGGz3WBAKwbWgtgAgClBBYFECsNEAAAFgQQ +TCSAgsoixQfKIIUPAAD7KsojhQ8AAHUABAel/cohxQ8IFgQQTCSAgsohxQ/KIsUHyiCFDwAA/CrK +I4UPAAB4ANwGpf3KJSUAA4YZCN4A1gmABQhxz3CAABw4FgsACwLYA/AB2K0HL/wEpfHANg8P/AAW +BEDPdYAAOJ10HQARjCQBicohzQ/KIs0HyiCNDwAA/irKI40PAADFAIAGrf3KJS0AIQx0AADez3eA +AKCdQCcAE/IKYAwK2QHmHYXPfvEOBJC+D4AAQQcP/M9wgABQrakGoACKIR8E4HjxwMoOD/wAFgRA +z3WAAMSbVB0AEUwkgILKIc0PyiLNB8ogjQ8AAP0qyiONDwAAqgAQBq39yiUtAADeDPBWJcESE24V +eDhghgpgDArZAebPfhWF7Q4EkFIPgADdBg/84HjPcIEArBshgM9wgABQrcwYQAAtBqAA1NnxwEoO +L/wE2aPBAN5CxvIKYAyLcAPM13AAAABAAdjCIAoAF7gAIIEPAA4AAAYUADEbeBPgBCCADwAA/P8l +eJ24n7jscQChARIBNuxwIKAAwexwIKAEFAEx7HAgsAYUATHscCCwBhQEMRsMHgABEgU2CiHAD+ty +z3AAAE8mTQWv/WnbGgmgAwHYAsEAxSV4QsDPcKAALCBAEBAAwL0B5QPwAeYGFAAxgQ4DEAQUADGC +xy0NkRAbeBB46XHqCaADqXLscQCpBBQAMelxG3gB4BB40gmgA6ly7HEAqQjw6XHGCaADqXLscQCx +BBQAMUAgRQDPcKAALCAQgC8lSAECIAAE13ABAKCGnAfl/wQcRDEIFAQwCiHAD+tyz3AAAFAmrQSv +/YzbZgiAA0oOoAACwIEFL/yjwPHAABaFQKbBDQ0zBgAcQjEbDRMCCiHAD+tyz3AAAGYZldt1BK/9 +SiRAAAAWgEABHAIwABaAQAIcAjAAFoBAAxwCMItwRgsgBoHBAsKO6gAUhTAKIcAP63LPcAAAZxmf +2zUEr/2KJMMPBMBgegXBA8GL6QohwA/rcgAUhTDPcAAAaBmj2+7xAcCA4OMgQgDKICIAag2AAKbA +0cDgfvHAz3CAAHQreghgDAnZzgnABJYOgATODoAERg2AANHA4H7gePHAz3CAAHgtVghgDAfZLg2A +ANHA4H7gePHApcGLcEIIYAwF2RYNgAClwNHA4H7geOEG4AUA2OB48cDPcIAA4C/KDyAMKNn2DIAA +0cDgfuB48cDhxQAWAEDPdYAAWBYApQ8IkQAA2c9wnwC4/z2gzgyAACCFQQlVATMmQXCAAFQ+QCcA +cjR4AHheCyADVNgpCF4Az3GAABQwAIGBuFINoAwAoQrwBg+v/gHYxgsAAwTwDghABB0ED/zxwEYJ +QAh+DIAA0cDgfuB48cBeCOAIANjPcIAAlBzIEAEGwLmB4QHZwHlqCaAMPBCAANHA4H7gePHA4cXP +dYAAlBwAhcQQAAYdCF4BCiHAD+tyhdiNuIojnA9KJEAAwQKv/bhz9gkACpYPIAsB2M9wgADcHwiI +PQjRAQGFxBAABjEIXgHaD4/9z3GBAHgUBJAlgQq4HQhAAAohwA/rcobYjbiKI10CSiQAAHUCr/24 +c7IMD/3iDqAKANi2D8ACxguAAFkDD/zgePHA8gjgCADYAgqP/c9xgADQuwKJtgigDCCJ0cDgfuB4 +8cCiwYtwZg4gDAjZAMDPcYAAXDAAoQjoBhQAMQOxBBQAMQKxdguAAKLA0cDgfuB48cCCCi/8gdih +wWDAA8wA3892gAB4BwIcBDDPcKAALCBAEBEAAIYBHMIzEOjPcYAARAcAgYG4AKHPcYAAaDADgQHg +A6EB2APwAtgacADAHgiv/Apxz3WAAGgwAxIBN16Vgdhgho4OoAwKJAAEz3CgACwgEIBAHUAUEaVI +HQAUlwiQIACGJwgRAs9wgABsOV4NwAomDK/+FNgeCmAEBNjgps9wgAB8B+CgANgLCFABANgI8M9w +gAB8BwCA9wgRgQHYLyYH8A3y4gwgAxTYiejPcIAAUDkmgCOBIIGCDcAKAIYD6ADYB/DPcIAAfAcA +gPvoAdgvJgfwBfTKDkACC+jPcIAARAcAgC8oAQBKCu/9TiDAB9EBL/yhwPHAagkv/IDYocEDEgE3 +YMDPc4AAeAdgg891gABoMAIcRDAvpShySiAAIAEcAjSuDaAMCiQABM9wgADgIhAQBQAbDZ8AABQE +MAohwA/rcs9wAAB2J5kAr/1m289wgAB4BwCAgOB0AgIAMg7ACYDgbAICAM9wgAB4LQCAUSAAgVwC +AgDPdYAAuNypcJoMIAyKIQsPAhWEEEQkPoMN9AMSBTcKIcAP63LPcAAAjidBAK/9d9tBLMEAwLnP +d4AAQgcgr6lwhCkfAAAhgX+AADjNtg8gCr/aYI8KIYAvgABUzYQrHwAAIYJ/gAA4zQWShiB/DBx4 +UyCAgAj0z3GAAEQHAIGGuAChAorPCF8AhCsfAAAhgH+AADTQDgwgDBjZAI+EKB8AL3A0IQ0gQiUE +FowkB4HM9wohwA/rcs9wAACBJ5jbrQdv/YolBwHPdoAAcNDYYNILIAyIcQCPz3GAAFQHhCgfADIm +RR4AJkAeAKEbDRAACiHAD+tyz3AAAHcnndtxB2/9iiSDD6GIz3GAAFgHQCWFEEAlgh8fDfQIQKkK +IcAP63LPcAAAeCej20UHb/2KJIMPz3GAAPDMFg4gCqhyAI+EKB8ANCFBLs9wgABAByCwH/AcEgQB +jCQIgM33CiHAD+tyz3AAAIsnrNsFB2/9iiUIAIQrHwAAIYB/gAA00CYLIAyIcc9wgAAUzSAYAAQA +2TLwABYCQIQrHwAAIYB/gACE0zDgNXhAoAAWAkEAIYB/gAAE1DDgNHhAsAAWgEAAIY1/gAAk0lJp +VHq6YhCqEaoSqgAWgEAUqhWqFqoAFgBBACGCf4AAQNQ1ehqyABYAQQHhG7Jgj4QrHwAAIYB/gAA4 +zUOIjwmkgC91ACWBH4AAtNMAJYIfgAA01NoNwAZAjwHIhCofAAAhgX+AAPTUAKEAwKIMb/wB2cIM +QAKA4CAPggwDEgE3z3CAAHgHYICA2ChySiRAABnwBIUB4ASlz3CgANQDHJCeCQABAMBmDG/8AtkD +EgE3z3CAAHgHYICA2ChySiSAANYKgAzBBu/7ocDxwAohwA/rcs9wAAAwJYojjAeKJIMPyQVv/Uol +AADgePHA4cUg289xoADIHGmhABYAQM9yoAAQFAyiABYFQAHdTCUAgMohwQ/KIsEHyiCBDwAALCXK +I4EPAAAJAYAFYf3KJEEDGBpAAWgZQAED2A+iuaFqoc4OQABhBs/78cDhxa3Bi3WpcOIJIAwN2QDA +HXhTIAEARCk+DalwACGBf4AACOjSDCAKDdqaDkAALQbv+63A4Hh5BKAMANjgePHApg3v+wzZrMGi +CSAMi3AAFAAxr+jPdYAAqCMghc92gAB8JmB5ANhAJI8wIwgQAyCFYHkA2BsIEAQghWB5ANgPCFAE +IIVgeQDYDwiRBOlwyXEY2gTw6XDJcS7apgsACgHYYB4CEBeGgODsC2H8yiAhAAAUADEpCFEAQCSA +MM91gAB8JkAlgRt6CyAKLtoB2DeFYR0CEIHhvAtB/OoNQABtBe/7rMDgePHA8gzv+xfZt8H6CCAM +i3AjwEoiQCBTINAAhiD+A0IoEQElCDIkDBwCNAohwA/rcnLYjbiKIw8DCiSABD0Eb/0KJQAESBQF +MCDAQCiOIM91gQAQDNZ+USAAgMBlQS1PA8C/vmaGIPcPXPSN6AohwA/rcnPYjbiKI88EAQRv/Qok +AASKIE8FCnFyDmAEqHIBwALBCnJKDi/8Zm5/CBAA6XCqDWAMCnENFIAwhSDBAA0cAjCKIP8PU8AA +hqm4AKYSwIYg+w8ouA+uSiQAdADYqCAAA//au2BAKIEgNnkS4ztjQKsB4ApwsgxgDItxz3CAAJQc +8CDBA8ARAAYPIAAEwBkYAA+ODwhRAIDnzCCio0QMggwB3wLwAt+eDuABCnAH8IDgyieBFMonIhKB +57j0IIbPcIAAlBwDgBiIKHWGJfsfIQhQAMIJQAIghhnoz3CAANwfCIgnCNEBQSlAAx8IHgATwBLC +FwgeAoYi+w9BKgQCT44LCgABqLhTwBPAEsIGeUR4JXgApoYg+w8L7YDgyiABBMohIQCgDiEDyiLh +Aw4eQhQA2M9xgQBQDxYhAQRAhgChAaELCl8FANiLuAGhDwqeBQGBRSAABgGh6g1v/YtwDRSAMD8I +XgFYFAAxBbZaFAAxBrYFlhfoJglAAg7oBpYTCF4AMgpv/QpwYguADAXYEq4A2AW2B/AKcADZKg4g +Aw/aDRSAMDUIXgBQFAAxArYU6ADdENg6cAKWESBAg8ogAgTKIUIDAA4iA8oiQgNCIUAg5wh1gAHl +DRSAMA8IHgEKcM4L4ABVFIEwDRSAMDsI3gA1wVYUAjEKcLoNr/0Sw4wgAoC4cA30CiHAD+tydNiN +uIojkg/1AW/9SiRAAFElwIHKJyIRTg1gDApwA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxx +AKEBEgE27HAgoF4LYADpcIUC7/u3wPHAGgrv+4ogUwmkwQDdqXEaDGAEqXLPdoEA0BMAjkokQCCh +rgIeAhUB4ACuo66hpqKmpKalpriuua4BwLquAsEHpgPAKKYJpoHA6g3gCwHZAcAHpnp1ifCCwNoN +4AsC2QGOA8EB3+OuAeABrgLAKaYIpv4OL/yLcgQgAAUvJAegAtkjrgKuAMEhpm3yEmkWeM9ygQAQ +DABiSiEAIA8hUSAtuFMgEACKIFQFggtgBApyz3GAAMAGQIEvIkok+K4QHkAUBCKAoBQeABQAoQPZ +I65CpgOmBvQG6oIJIAQg2PmuBdgDriDAagrgABDZAMAyaDZ5ACGCD4EAEAyKIQgAorIgogbZI64A +2V4MIAMP2gDCgNkSahZ4x3CBABAMKKgpqAfYA67PcIAAlBzwIAAEz3OBAFAPVnvAEAEGBCGBBMAY +WAAA2SCjz3CBAHALIaNUeD4JoAygsAfoLgmADAjYA676rkAjUyAhwHJw8AbN/wnYA64DzNdwAAAA +QAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQESATbscCCg1glgAIpwCtgDrskA7/ukwOB48cCKIFUL +ANl2CmAEKHIiDAAKUglAANHA4H7gePHA4cUAFg1AA8wB2tdwAAAAQAHIwiKKABe6x3IADgAA7gwg +ClMlARBRJUCQz3GAAIgyAdjKICEApQDv+wCh4HjxwKHBi3AmDOALAdkAFAUwGQ0RAAohwA/rconY +jbhF24EHL/1KJEAAz3GAANzJAxlCAUAtgAMCoUokwHAA2qgggAIA2A8ggAALIECBA/QB4gPwDrgB +obIIQAChwNHA4H7xwK4Pj/sAFhJBABYAQc9xgQAQDEAqgCAWeDAhBQCiwUEtQAMjCjQkUyATAAoh +wA/rcnXYjbiKIxgCSiRAAAUHL/1KJQAAHQ1eAgohwA/rcnbYjbiKI1gC6QYv/QokgATPcIEAUA4W +IIAEGnBeC+ALAtnPcIEA8AoWIIAETgvgCwLZQCqVIQAlgC+BANAPPgvgCxDZi3A2C+ALAdkAJYAv +gQDQDwINIAYQ2QEQgCAhCBIECiHAD+tyd9iNuIojmApKJEAAfQYv/QolgAQA3RDYOnAVJUAjz3GB +ANAPMCEUAAQkgq8AAAABBBwANUjyRCQOJiO+AeYEJIAvBgAAADG4IcHfYKDh0SThojXyA+oXDpUQ +BCSELwAAACRbDIAPAAAAJFMI1QANCJEAJepHDpEQBOrM4T4ACQDPcIAAsCMggGB5BtgvCIQDz3CA +AJQc8CDABMMQAAYB2QQgvo8ABgAABCSALwAAAAjCIUEAK7gLCQUAANgC8AHYD3gE8AHf6XAEJIEv +AQAAwC65z3KAADRWKWIwdwHZwiFNAIDgzCEigBbyQiFAIC0IdYAB5QIQgCDPcYAAGEwIYTkIUAAK +IcAP63J52I24iiMZADnxCiHAD89wgACUHPAgwATrcoojWA/DEAQGeNiNuFkFL/0KJQAFAxCAIAhh +FwiQAAohwA/rcnrYjbiKI5kCGfGiCGAMSnDPcIEA8AoWIIAEIJDPcgAAGBUJIYEAgg4gACCw0QWv ++6LA4HjxwAAWgUDPcIAAnDogqAAWhEAAFoFAz3CAAKU6IKgAFoBAUCS+gcohwg/KIsIHyiCCDwAA +2hTKI4IPAACBB9AEIv3KJSIAz3CAAEwGAJAG6OIJAAwGCQAMGg4AANHA4H41BaALANjgePHALg2v ++wDZSiQAcqggQAIAFgJAFSJAMA4YmAAB4QAWDUAAFg5AzgnAC89woAAUBKygz3CgANQL3KDSDQAA +XQWP++B48cDiDK/7CNmiwQESDjbPdaAAOC4cFRAQfgjgC4twABQEMADfBCS+j/D/AADKIcIPyiLC +B8oggg8AAKYoyiOCDwAA4QYcBCL9yiXCAFEkQILKIcIPyiLCB8oggg8AAKcoyiOCDwAA5Ab4AyL9 +yiXCAOel6gxgDD/YAMAEFAExB6X6DqALgrkcHQAUPg0gAAEamDO1BK/7osDxwADYmgwgAAQSgTAE +EoUwCiHAD+tyONiKIw8BrQMv/UokAADgfuB48cDhxaHBH92LcCII4AsE2WG9+Q1VkPIMAACFBK/7 +ocDxwKnBi3CyCOALEtnaDAAAqcDRwOB+4HgAFgBAABYAQAAWgEAAFoBAABYAQQAWgEAAFoBAABaA +QAAWgEAAFgBBABYAQQAWAECdBAAA8cDhxaHBC92LcLYPoAsE2WG9+Q1VkIYMAAAZBK/7ocDxwK3B +i3CaD6ALDdluDAAArcDRwOB+4HiFA6ALAdjgeOB+4HjxwM9wgQBUGnIPoAsG2UoMAADRwOB+4Hjx +wF4Lr/tC2s92gABwfM9wgABMeloK4AlAJoEZz3eBAFQaQCcAEkAmgRRGCuAJBNoCl8l1EbYDzIok +wXLXcAAAAEAB2MIgCgAXuMdwAA4AAIUgBA2duJ+47HEAoQESATbscCCgANmoIAAC8CVCEOxwQKAB +4VEDj/vxwOHFz3WAAAB6qXDeDqALE9m2CwAA7g5gCalwAdnPcIAA/AU5A6/7IajgePHAvgqv+wHZ +ocG2DqALi3AAwM91gACgfQAVBRCgcBB4lODKIckPyiLJB8ogiQ8AALghyiOJDwAAkAD8ASn9yiRp +AADeDPAghQRt2WGEKQIFJ3BuDqALJdkB5tB+AMDrDgSQOgsAANoOIAEAFAAxAIUAwThgAKW1Aq/7 +ocDxwM9wgAD8BSIOoAsB2RILAADRwOB+4HjxwM9wgABUewoOoAtK2foKAABiCoAK0cDgfuB48cDP +cIAATHoGDqALQtneCgAA0cDgfuB48cDPcIAAoHvWDaAL0NnGCgAA0cDgfuB48cChwQDZQMEAFgJA +ABYAQDUKUAADzNdwAAAAQAHYwiAKABe4x3AADgAARSAAA524n7jscgCiARICNuxwQKDscCCgH/CK +DqAFi3ADzAHZ13AAAABAAdjCIAoAF7jHcAAOAACEuJ24n7jscgCiARICNuxwQKDscCCgAMLscECg +ggogAChwocDRwOB+4HjxwE4Jr/sC2c93gAC4OvINoAvpcECHz3agAOwnz3WAALAjlwoeACuGRCKA +AIYi/w4iuqG5FLq0uQUggwBleSumBCCADxAAAgAEIoIPEAACAM9xgABgBUV4C6EghQTeYHnJcBsI +0AEghWB5yXAPCJABIIVgeQHYJQhRAACHz3GgAMgcEQheAAHYHqE+DcAFBvAA2B6hxgyABSCFYHkB +2GkIUQEAh2EI3gDPcKAARB3FoMOgxKAo8M9woADIHAHZPqALhoG4C6YCDcAFIIVgeQHYJQhRAc9w +gACUHAOACIAZCB4AANmUuc9wgABgBSugC4aUuAnwz3CAAGAFANkroAuGtLgLpioJAACtAI/78cDP +cIAASBLqDKALAtkWCQAA0cDgfuB48cAuCK/7ANoIdSh2z3CgANQLOIBCIQEIgOHKIYwAQCYAEhBx +eA4FDAPM13AAAABAAdjCIAoAF7gAIIEPAA4AAAduBCCADwAA/P8leJ24n7jscQChARIBNuxwIKAi +vgbw7HEAoQTlYb75DrWQAIXiCAAAKQCP++B48cDhxc9yoADUCwPdsaIA23CiAxICN9dyAAAAQAHa +wiKKABe6x3IADgAARSICBp26n7rsc0CjAtoUGoIwBRIDNuxyYKILEgI3AeILGpww7HIAogESAjbs +cECg7HAgoM9woACwHwHZOaDPcYAACBsIgUCA7HBAoAyBAIBeCAAAz3GgAMg7DoGIuA6hoQdP++B4 +A8zXcAAAAEAB2MIgCgAXuMdwAA4AAE8ggQCduZ+57HAgoM9woAAUBAPZJaABEgI2z3CgANQLTaDP +cKAARB01oOB+4HgD2s9xoAAUBEWhz3GgANQLDaHPcKAARB1VoOB+A9rPcaAAFARFoc9xoAD8Cwyp +z3CgAEQdVaDgfuB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjhxeHGz3CgABQEA9kjoA3Iz3KA +APzKYZLPcYAA7MnEihQhDQBotQAggw+AAAzKOOHAq2KCFXkGkmChAxIDNsAdBBAEgqATAQCGIcMP +JXigGwAAwcbgf8HF8cA2Dk/7CHYyDOABKHWA4NElYpMB2AP0ANgEuM91gQCYFBR4CWUdZRUJUQCe +D6AKqXBqCS/+AY0A2ACtAYVlBm/7AKbxwOYNT/uiwQ0SAjbPc6AAvC3PcIAAlBxOoySAAN1GEREB +DRIQN1YhBgVGIMAgAxIONg0aHDCkFgAQhLikHgAQAZZWIYgEViFHBIYeRBMI6M9wgADsyvQggAAJ +6AGGDwifA1AgACAvIAggUyB+oEgDAQDPcIAAiDJpEAAGz3GAAIgyAeBpGRgABBIBNqQZQAMBlo8I +EADPcIAA7MlUeIAQDwd/DxEQ0BADAVMjw4AV9HIWAxHglmJ/uBaDEGJ/8H/gGMQDpBYDEIYj848F +8mi/8H/gGMQDcBYPEeAQAAFhluJ48XDCJw4QwiPOA3QWABEbY7gWgBB0GUQDoLF4YBB4kBkEAL4Z +BAAQjgDbEKkBhgGhCI4IqRKOEqmWuzDwD4P/CN6Fb4NTI8ACVQueBSEIlQPPcIAAiDKnEAAGtrvP +doAAiDIB4KceGBAa8GS4EHiQGQQABCOADwAAAPAsuBCpdBlEA6CxobG+GUQDAYaoqYYg/w2EuAGh +Eo4Sqfa7OAIBAADYlrikGQAAKQteBQIJ7/4A2AQSATakEQAABCCDDwIAAAAtuwUjAgQvIIggPvAB +gaUIHgFwiU96SSLAAM9ygQAQDPJr9n/iYtKJEQqeBc9ygQBQDnZ6QYoD8ADax3CBAFAOdngEiAgm +DhAIJoIQSSLCAxZrVXjPcoEA0A8AYs9ygQBQD3Z6z3OAAJQcZIN4g0GCZXoEIoIPAAAACEZ4mBkA +AADYlrhBgYYi/w1DCB4FoQoQAJgRggBAJwAJSGDPc4AAUK9AwCDCw7pcevQjggBS8AohwA/rcjTY +jLhf2wW7iiSDDwUD7/xKJQAAmBEDAJwZQANJC14CgLikGQAAKOqYEYAAz3KAAJQcQ4KGIP8DRLgy +JgAAibhAwCDDVIJkeoYj/wOGIv8ORLt6Yk96z3OAAHBM9COCAB7wEwseAgjqmBGCAEAnAAlIYAvw +heoA2khwEPCYEYAAw7gceDIgABBAwCDCz3OAAPiuw7pcevQjggCIGQAAmBEAAIQZhACQEQEBuggg +AADaBBIDNgMSDTbPdqAAyB+EEwIBghsEABpiUHqwG4QA+BYBELAVABEieAAgTwTPcIAAlBwEgFQQ +AQE/Z19noBYOEPB/Ow7EExCAmBUOEAsggIMX9HCLEI1wcNEmIpIa8oYm/xlBLsMQAeMpC5QAArgW +eM9zgQAQDABjGQheBM9xgACIMrgRAAYB4LgZGAAQ8FlhMHmGHUQQz3GAAIgyahEABg0aHDQB4GoZ +GACRAm/7osDgeKHB8cAmCk/7CHVGwOi9KHDOACEASHYDuEAgkAVEJQIWI7oEJY8fBgAAAAHiQS9A +FAQlgR/AAAAAWGA2uc9ygAAAVqlzxrspYghiOGBBLYESUiEBAMC5A7kY4YXgyiGNDwEAiQ3VIQ4A +LyFIIAQlgR8AAAAYz3CAAMRN13EAAAAIHgAiAPAgwAAmwaDhEgABAM9xQnvQXgUofgAKIMAOCnEF +KT4ACiDADiS4AeAE71MgAQA4YAIpgSMhDV4Tz3KAAABPQJIFKj4AACGAfwAA/z8uuF8AIAAZYVcA +IAAVeVElQJJWACEAJsW35SIACwAzaFMlAhDPcIAAuEzwIIAABSk+AAogwA4B4AbwiuXAKOEAwCii +AM9xgACUHCOBwNo0gaR5hiH/DiK5OnraehliMHgI3FsBT/szaFMlwBAceM9ygABET/AiAAAW4QUp +PgAKIMAOAeAU2YUH7//aec9xgAAIGySBQSiCBdW4IIFBKYMF1bkCec9wgQB4FGJ6BYDJugUovgAn +cc9wgAC4OQOAAIDgfzhgz3GAAAgbJIEggUEogwXVuEEpggXVuRkJJQBbY89ygQB4FEWCWWECeQHj +A/ACeUArgAWZB+//JXjxwBILT/teCG/7UNlFwEogACC6CK/+hsUjCDUlBBUBFAXAFSAABCCgQCBQ +IO0JgY+t3u++JNyTAE/7CiHAD+tyz3AAAIsTiiMHC5hzlQev/AolAATxwOHFmHAZCPQAuHEKIcAP +63J92I24eQev/PDbz3CAAJQc8CABAYojCw1AIQIGeGJPDREAqIF6YqCiSYFBoFyJSKhdiUmoKhGC +AEqoKxGCAEuoLBGCAEyoTZFHsFeRSLBIgQQigg8ABgAAgOIB2sB6UqhUkVOoKIHAuS2oGvA5DVEA +YmJIoUGASaFIiFypSYhdqUqIKhmCAEuIKxmCAEyILBmCAFOIVLFHkE2xCJAXsdkHD/sKIcAP63KQ +2I240Qav/IojhAfgePHASg8P+891gADMjQQVBRBCJUEAheE2AS0AosH1JkFwgAAYPkAnAHI0eAB4 +AtgApQHZz3CAAMAaILByC6AIKHAChc9zgACEGiiDR4MIEwQADyBAAAKlz3CAAGQaNXhAoBgTBQEM +EwYAz3CAABwsANk0qM9wAAD4nkDABYMQEwcAQcAaizuLQINeD2AJYYNc8M9wgADCGgHZIKjPcIAA +hBongM9wgABAyS+g8gnv/QLYSvAE2AClANjPd4AAwBruCqAIALfPdoAAhBoChUiGZ4YPIIEAz3CA +AGQaVXhgoCKl7NhmCOADQJcIFgQQz3AAAPieGBYFEQwWBhBAwAWGEBYHEEHAGo47jkCG3g5gCWGG +JBaAEEiGANlRIACBBIUPIYEACvIB289ygAAcLHSqBXkkpQTwJngEpeoNoAMA2ATwWg7P/G0GL/ui +wAgVBBAKIcAP63LPcAAAQh9tBa/8iiNEB+B48cDhxQHdz3CAAMyNoKAA2M9xgADAGjIKoAgAsV4M +IACpcD0GD/vgePHA4cUA2M91gADMjVoIIAAApdoPr/0C2CKFz3KAAMAad9iaD6ADQJINBg/78cCS +DQ/7AN7Pd4AAwBrAt+IJoAjJcM91gADMjcKlw6XEpYogyQDJcWYPoANAlwHYyQUv+wCl4HjxwM9x +gADMjQARBQAbDVQBCiHAD+tyz3AAAEEfmdu5BK/8iiSDDwGhz3CAAKwa8CBAAUB40cDgfvHAIg0P ++891gADMjQQVBRCiwUkNUAAjDZAA0Q1QAQgVBBAKIcAP63LPcAAARB9xBK/8iiNHBs9wgADCGgHZ +IKjPcIAAhBongM9wgABAyS+gIgjv/QLYTPAE2AClANnPcIAAwBogsB4JoAgocM92gACEGgKFSIZn +hg8ggQDPcIAAZBpVeCKlYKCWDqADiiCGCwgWBBAYFgURz3AAAPieDBYGEEDABYYQFgcQQcAajjuO +QIYODWAJYYYkFoAQAd9IhgDZUSAAgQSFDyGBAAjyz3KAABws9KoFeSSlBPAmeASlGgygAwDYBPCK +DM/8nQQv+6LA4HjxwC4MD/vPdoAAzI0EFgUQQiVBAITh5gANADMmQXCAACQ+QCeAcjR4AHgChs9x +gACEGkiBJ4EPIIAAAqbPcIAAZBpVeCCgWfDPcIAAwhqA2SCoz3CAAIQaJ4DPcIAAQMkvoB4Pr/0C +2EfwCpaMIAKAEfQA2M91gADAGhYIoAgAtSKGiiAFBKYNoANAlQHYAKYz8APYAKYx8AOGjCDDjwHf +EvQA2M91gADAGuYPYAgAtSKGiiBFCuCmcg2gA0CVwgvP/BvwANkPIQEAAoYGIECAEvQA2M91gADA +GrYPYAgAtSKGiiCFDEYNoANAlZIL7/zgpgPwAqahAw/7CBYEEAohwA/rcs9wAABDH6ECr/yKI0YA +4HjxwOHFz3WAAMyNBBUFEEIlQQCTCZUBMyZBcIAALD5AJ4ByNHgAeM9wgADCGoDZIKjPcIAAhBon +gM9wgABAyS+gKg6v/QLYLfAChc9xgACEGkiBJ4EPIIAAAqXPcIAAZBpVeCCgHfADhYwgw48B2gny +ANkPIQEAAoUGIECADfTPcIAAwBpAsPYOYAgB2APY3grv/AClBfACpQPwAdgApfUCD/sIFQQQCiHA +D+tyz3AAAEUf5QGv/IojSAvgePHA4cXPdYAAzI0DpfoM7/8F2COFz3KAAMAaoNg+DKADQJK1Ag/7 +4HjxwC4KD/vPcIAABJgIgM91gADMjQDfJ7jAuBN4xrgB4Aq1CNg6cADeAoUPJs4TCyCAgy3yBIUL +IICDGfLGeASlz3CAAASYCIAPeSMJUADPcoAAHCwwioYgww+AuAHhL3kwqs9xgAAEmAihz3CAAGQa +FSDQAwAQACCA4OIgAgAChQDZABhAIMZ4AqVCIUAgAeeVCHWA739Klc9wgADAGiCQgeLMISGAB/QA +2s9wgAAcLFSoAYURCFABgeED2MogIgEeDM//yQEP+89ygADMjSKCANsPIwMAZnkios9xgABkGgDa +FXngf0Chz3OAAMyNQoMPIkIAQqPPcoAAZBo1euB/AKLgePHANgkv+xlxCHWIds9xgACEGhqpGxkC +AkChEBnAAQwZgAHCoQPAGBlEAQTGB6EmwMihJBkCAAfAYaEFoVPYqXHuCqADyXImwBMIHgBX2Klx +3gqgA8lyBtgF8IHlAtjKIGIAegvP/z0BD/vgePHAwggP+xpwz3aAAAAbAIYB4M93oADIHwCmEQhR +AAHYUR8YkDYNgAukFwAQz3CAALQlJoDPdYAAtLtgeQDYAYUp6CTYGNk2DaALM9ofCFAABBUFEAoh +wA/rcs9wAAB0GY3b4Qdv/AokAAQk2AHZDg2gCzPaHwhQAAQVBRAKIcAP63LPcAAAqyiS27kHb/wK +JAAEAIZCIECAAKYF9ADYUR8YkIUAD/vgePHAIggP+89wgAC0JQSAJejPdYAAdC8yheThyvbPdoAA +yDoAhtrgyiArAoz22uFV9s92gADIOgCG5ODP9oogPw5iCIALIIZIFQARELkOD+//JXgShQCmOQAP +++B48cDPcIAA9AUBgFEgAIAgCAIA0cDgfuB4geCH2MogIgDPcYAArDXgfwGh4HjPcIAAsDYAgEIg +AIDKIGIAB+gB2c9wgABNEyCoDPDPcaAArC8ZgfC4GYHPIKIDzyChAhmh4H7geM9wgADMLUCIEQoe +AM9xoACsLxmBirgZoREKXgDPcaAArC8ZgY64GaHgfuB4z3GgAMg7HYEH6ILYFKHPcACAERQOoeB+ +z3CAAMjLbIjPcYAALI6MIwKACpFBKAIDDPIZCN8CArt2e8dzgQAQDAKTDyCAAAKzANjgfwyx4Hjx +wOIO7/pUaIYi+ANPIkMCUyHCAAUixADPcoEAcAsUeo/hiiMPDMogKQAJ9gCSAN0PJU0QiiPPD6Z4 +ALIA2UokAHTPdoAARJHPcoAAvJHPdYAAwJGoIMAEFCJAAOSQZH8ZDwERAN/ksBYmQBDgoOGgQCUA +GTV44KAB4dEGz/rgePHAANqeugDZz3CgAPxEQaDgeCGg7g+gCChwC8gEIIAP/v//AwsaGDALyIe4 +CxoYMNHA4H7xwDIOz/pIdoDgAd1E9ool/x8TeAkJEwCzfTN5FCEAAMoP7/o7eax4AB5AHnEG7/oB +2OB48cDhxQhyAd2A4cohwQ/KIsEHyiCBDwAAmxPKI4EPAABcAMokIQBQBWH8yiUBAYDiRPZTeool +/x8JCRMAM3mzfRQhgAByD+/6O3mseCUG7/ovcOB48cDhxc91gAAsjs9wgACUHCOAQIUAgUMKAQAC +kUKVOwoBAAKFXgxv/COFjCACgBXyz3KAALwGIYIA2w8jAwACuGZ5FnghogAggQ+BABAMAIGquIi4 +AKEA2MUF7/oMteB48cDhxc9wAAD//891gABIjgOlz3CAAFQ4jgjACc9wgABwOIYIwAnPcIAAGDl6 +CMAJz3CAADQ5cgjACQDZIKUF2AGlIqUuD2/9BtgqD2/9CdhtBc/6B9nPcqAA1AcaGliADegZEgGG +CSBDAA8SAYYCIMCAeWEPGliA9fXgfvHAygzP+gMSAzYIdw0SDjbPcYAA7MkQi89ygQAQDNR5ArgW +eAViMYktvVhgwL0M6SGDFQleA89xgADMG7R5oJEQ5aCxJZAjCVIAYbklsBCLMmg2eTtiZZM6Yofr +JpJRIUCAkAtC/AYMwAp+DOAFDcgDyAHZoBhAAM9xDwD//74IIADpcK0Ez/rxwEIM7/oD2c9yoADU +BxMaWIAPEgOGABYAQAAWAECiwUDAIMAfCBAHCiHAD+tyNdiMuM9zAAD0DJhzhQNv/EolAAAAFg1A +sH0AFgBAQOX0uMAlohAD5QQljR8AAPz/GRIOhkIlDxT7DsSTu2MPGtiAIBpYgBkSAYYpCRQCHxIB +hkHBIcGc4cohwg/KIsIHyiCiDcojgg8AABENzyAiA871BCCADwAAAEABBO/6osDgePHAigvv+sja +giQDMgh1KHbPcYAAKEBCDO/6i3AB2s9woAAUBESgz3KAAIAzGIIA2QHg4r0YosogQiAF9BYPz/8a +cA3Iz3GgAGQuz3KgADgu8CEAACeC07gkeAQgkQOh8PIOz/8acJ3wA9/PcKAAFATwoOSgABYEQAca +GDEAFgVAARpYMQTKPwgRB4twCg/gCg7ZJMFTIcAAhiH+A0S5xBxCMGTARCaNFDEOXhCO2JC4oBwA +MNkOHhGG2JC4oBwAMGbw63LPcAAA3A7PcwAA9Ao9Am/8CiHADw8IECCM2JC4oBwAMFTwArgWeMdw +gQAQDECASHSEJAyQDPITCl4Ci9iQuKAcADAB3ULwiNiQuPvxTohQccoggg8AAJEAzyAiBPH1AcER +CZ4GAd2Q2JC4oBwAMC7wIpAzFIAwLQkOAAfIBCCADwDAAAAdCIEPAMAAACLAgODKIIkPAACNAKYH +6f/PICkECsGMIf+PEvLPcKAALCAQgCJ413AAgAAAyiCFDwAAhwB+B+X/zyAlBEwgAKDMJSGQZvXP +cKAAFATjoEwgAKCpdmL1UyZ+kAjyz3CgABQECYCA4Fr1ZQ5eEAHaVwkQICpxLyhBAE4ggweU48ol +xRCF92h1gCXCFM9woABoLPAgQAOU4w94yifFEIT3aHeAJ8IRz3WgABgs8CXNE7FwyiIiAAnqANgP +IMAABiEBgNr1AdgC8ADYgOAo880B7/qAJAMy8cBqCc/6GnDyCOABMNiYcCm4USAAgMohwg/KIsIH +yiCCDwAA6RTKI4IPAADHALwAYvzKJSIALNgCCeABQCiBIAHeiiUPGrYI4AEw2JhwKbgZCB4AjCYP +mibyqg1gCwHYYb3nDXWQAeaSCOABNNhPIAEFlbnGCOABNNiCCOABLNgIdXoI4AE02LhwMwheBQoh +wA/rcs9wAADrFOPbTQBv/EokAAAKIcAP63LPcAAA6hTU2zkAb/xKJQAAFQHv+kEtABTgePHApgjP ++gh3AN7JcFoMoATJcQPYyXUacAnvRC0+FwAhgH+AACA35guACQrvRC0+FwAhgH+AAMg30guACUIg +QCDXCHWAAeXPcIAAuJfJdJ2wMLyesM9wgAA8B8YI4AXAoKkAz/rgfuB48cAeCK/94cXPc4AAiDLP +cYAAXDpAgfQTDQAZDaQQANj4EwEADQmEAPwTAQAwcsP3AdiJAM/64HjxwM9wgADkBQAQBAABEgU2 +CiHAD+tyz3AAANsOaQcv/I/b4HjgfuB48cDWD4/6z3CgAFQuK4AH3dO5LyhBAE4gjwfPcKAAwC+l +EBKGFBARhs92oAAUBKqmhgwgCIDY89gFuIDZcg+gAZ+5DRIQNvXYBbhmD6ABqXGqpg0aWDME8APY +BaaphhvtfO1BLYCQCvIvJAlw4HioIIABABYAQOB4UyVNkAnyLyRJc+B4qCBAAQAWgEDgeKmG6PHz +2NoOoAEFuMkI34f12AW4Dg+gAQpxKB4AFJTnDRoYNMohxQOF9+lxgCHCAc9woAAYLPAgQgCU58oh +xQOF9+lxgCHCBM9woABoLDV4BL9AoMd3gABM5hWHNocFeReHuIcleAUlDZDKIcIPyiLCB8oggg8A +AMIhyiOCDwAAjQfKJEIDSAYi/MolIgCA2c9woADQGzCgz3CgAMAvpRiYhBQYWIT9Bo/6AtnPcIAA +WBa1BqABIKDgePHAhg6P+qQRAAAodVEgAIAK2MogIQSYFQEQBCG+jwEAAMB2HQQQMPQtCR4CRCEA +BiO4QWgEIYAPBgAAADG4WGAEIYIPBgAAAddyAgAAAcogoQAD8AHYIwhQABUIkACD4ADYyiDhAcAo +oQML8M9wgADcyQKABfDPcIAA3MkBgAV5mB1AEJ4VABGUHUAQkh0EEIIVABGQFRERsh0EEADYgB0E +EH4dBBADyM92oADUB0GQEBWSEAjqDcjPcYAA7Mr0IQAAE+gZFgCWHwgVDg3Mz3GAAIAzRiCAAg0a +HDAagQHgfwIgABqhDxYUlgnqDcjPcYAA7Mr0IQAAA+gB2AXwA9gTHhiQANgHEg82ARIQNgAWBEB6 +cAcaGDEAFgVAARpYMQTKnODKIsIHyiCCDwAA3A7KI4IPAAD0CtwEIvzKIcIPqXBeCeAKDtkfC1Eg +BMgBkCDoz3GAAPQ0GoEB4BqhHIEB4ByhFvADyAGQFOgNyM9xgAC8yvQhAABTIMCACvTPcYAA9DQa +gQHgGqEbgQHgG6EDEgE2AYEdCJ4DVBEAAVMgwIAI9M9xgAD0NBmBAeAZoQIVBREpDRAAAYXuuMoh +wg/KIsIHyiCiC88gIgPKI4IPAAC1B0AEIvzKJGIAAJWwcMohzA/KIswHyiDsC88gLAPKI4wPAAC4 +BxwELPzKJGwAEI1TIMEAhiD+A0S4xB0CEKQVABAwrUcInwUHEgI2AiLBAwDYDwlQAAIngRCMIcOP +AvQB2JPoDczPcYAAgDNGIIACDRocMBmBAeAZoQ8eGJUHGtgzARoYNIPwBxrYMwEaGDQA2HQdBBDW +CmAAqXDPcYAACFYLYXQVAhHPcYAAEFbwIQAAemJQeqQVARB0HYQQJXikHQAQBMgBkBPoHQtRIAGV +uBWPEFhgIJX4YBB4vh0EEFlhP2cO8L4VABEJ8CCVuBWAEFlhOGAQeL4dBBAId5AdBBAPFgCWtB0E +EIIJYAWpcBCNMnfMIIGEE/IKIcAP63JAKQ0kQCgOBDDYjLgA24u7BSXEExEDL/wFJoUUpBUAEAh0 +hCQakCHyPQheAgPIAZAa6A3Iz3GAAOzJFHmAEQAHkujQEQABahWPEAHgw7j4YA94ah0CEFIL4ACp +cGodwhMF8EYL4ACpcA8eGJV9A4/64HjxwCoLj/oacADfpBnAA89wgACUHASA0InwoAfIBCCADwDA +AAAodTMIgQ8AwAAADcjPcYAA7MkUeRGJj+jPcIEA8ArWeCKICI0PCEMACnCKD+/9qXHc8FEgAKCG +8gQVBBCBDB4BDcjPcoAA7MkUehEShQAPeEkgwgBybs9wgQAQDHZ7YGAyjRMIngXPcIEAUA7WeAGI +AvAA2MdygQBQDtZ6RIoIIYEACCEBAAAhQAFJIMEDFm41eM9xgQDQDwBhz3KAAJQcRILPcYEAUA/W +eViCIYFFeQQhgQ8AAAAIJngD8AOFz3GAAJQcmB0AECSBKIEEIYEPAEAAAD65UyQCAB7hOHpFeJgd +ABAXCJ4HpBUAEIy4pB0AEFDYnB0AEHjwKwjeB6QVABCNuKQdABDPcEABUACcHQAQz3CAAJQcJIAQ +gZ64EKFk8AXYFLicHQAQz3CAAJQcpB3AEySAEIGeuJ+4EKFW8I8IXicBhXMIHgESjTQSgTBJIcEA +cm7PcoEAEAx2e2JiEQqeBc9ygQBQDtZ6QYoD8ADax3GBAFAO1nkkiQggQAAIIIAASSDBAxZuNXjP +coAAlBxEgs9xgQDQDwFhz3CBAFAP1nhYggGARXgEIIAPAAAACAZ5AvAjhZgdQBANyM9ygAAkyhV6 +IKKcHcATBfAF2BS4nB0AEBEIHiUA2JG4pB0AEATwpB3AE3QdxBPKDyAAqXDPcYAACFZ0FQIRCWFZ +YTB5dB1EEM9xgAAQVvAhAACkFQEQJXiYFQEQpB0AEBkJXgIK2XYdRBB4HUQQgLikHQAQFfAQ2c9y +gACUHHYdRBBDgkiCEwreAArZeB1EEIO4pB0AEAPweB1EEIIML/2pcKQVABBEIH6CjBWBEBjyz3KA +AJQcQ4JUgiR6hiH/A0S5hiL/Djpiz3GAAJhM9CGRAM9xgABwTPQhkgAO8MO5z3KAACivPHn0IlEA +z3KAAPiu9CJSAJgVBRBTIASAyiCCBBX0iBWBEFElAILDuTx50SAihQjyz3CAAFCv9CBAAAfwz3CA +APiu9CBAACGFCwneAIQdBBAD8IQdxBMdDR4CRCUCBiO6AeIEJYAPBgAAADG4GmID8AHaA8gBkCzo +DcjPcYAA7Mr0IQAAgugBlbgVgxB0FQERBCW+jwEAAMB5YThgEHi+HQQQBvRPJYUDmB1AEQQlvo8B +AADADvQKIcAP63Is2Iy4iiMaCSUH7/uKJIMPAJXe8TsKUACC4swi4oDKIcIPyiLCB8ogYgvPICID +yiOCDwAAtQbKJCIA9Abi+8olAgHPcIEAUA7WeAOIBvDPcIEAUA7WeAKIjBUBEA64JXiMHQAQz3CA +ACAGQIAGgqAQAAaI6M9wgACkOgCItQgQAA0SAzatC5ABAJXPcYAA9DSdCBIMz3CAAOzJdHgRiI0I +EQCFDBEAfQgeIJ4VABHPc4AA4DSKuJ4dBBAWkwHgEHgWswHI56EFoZgVARCuua+5sLmYHUAQBoKg +EAAGLygBAE4gggcjug7iDyGAAKQVARCYHQAQtLmkHUAQnhUBEae5nh1EEM9xgACYOgChBCCAD/// +0/aYHQAQDdiYHQIQCvAQ2AfwCNgF8ALYA/AB2AehmBUAEL4VARFKDC//ANqkFQEQBCG+jwAAADCC +HQQQUfKMFQIQnBUAEZQdgBCSHQQQgB2EFAMSAzYXCR4DFNiQHQQQKnB+HQQQeBMOAQnwDtiQHQQQ +fh3EE3gTDgFKcMJ4EHiyHQQQz3CAAJjJAICGIH+PDPSYFQ4QEQ5fEmGThuuRuZK5pB1AEBC4JXik +HQAQBCKCDwAAABDPcYAAlBxkgVIiAgMQgwV6UKNEgRCCBCCBDwAAABA9eSV4EKIT8JgVARCAHcQT +lB1AEJ4VARF+HcQTkh1EEL4VARGyHQQQkB1EEIAVABF+FQIRghUBERpihBUAEVlhOGAQeNkFb/qw +HQQQ4HjxwIINT/pWDQ/9z3CAAMjLDIjPcYEAEAwCuBZ4AGEtuFMgAIAF9M91gACIMg3wz3GAAJQc +IIHEEQEGz3WAAIgyUSFAgQT0AdncHUAQz3GAAJQc8CEAAM9ygACIOSCCGIhFCTUBQR0YEDMmQXCA +AGg+QCcAcjR4AHj2CKAJA9iSCKAJQNgA2OAdABAO8M9zoACoIDGDAoIA3sKiOGDgHQAQAdgSo0kF +T/rxwNoMb/q4cQK5z3KBABAMNnkwIkQAosENDF4Dz3KAAFQgBfDPcoAAMB1AIgMGQCIBB1EkQILK +IsIHyiCCDwAAyyLKI4IPAACsAwgE4vvKIcIPz3aBANAPQC2NAaZmQMYgxQ0OHhLCvaphDvARDl4S +RCUBHES5KmOJugbwUyXBEDx5KmLPcYEAUA4WIUEBIokOuUV5IKCxBG/6osDxwAfYz3GgANQHGhkY +gA4RAoYNGhgwz3CgAEgsXqAfEQCGBxqYMAEaGDAEypzgzCCCjwAAkQAG8gAWAEAAFgBAA8zPcZ8A +uP8YoX3Y6g3gAgESATYEytHA4H7gePHAuHECuc9ygQAQDDZ5MCJEAFEkQILKIsIHyiCCDwAAyyLK +I4IPAACTAzAD4vvKIcIPQC2BAc9ygQDQDyFiUSFAgooiCAXKImEDz3GBAFAOFiFBASKJDrlFeSCg +0cDgfvHAfgtP+s9ygACgffhyQCIGAWMIdAAA2s9xgQBsGphyABcCALhwAN2AcoQqAgUUagAmQw4f +YdRqPma1fgHlANj3DTSRAKZKJAByqCDAA0CLGnrAulN9GmegqqGLGn3AvbN9qKoB4EIlQAC3CHWA +QCRCAHUDT/rgePHACgtP+s9ygAAIG0SCz3WAAEiOYoVAgja7NrpQc9YijQ8AAIAAwIU9Yn5mHQ2F +EwohwA/rcoogjQKKIxAEmHZBAu/7uHUeZv8NhZNYYCkDb/oOIIAD4HjgfwDY4H8B2M9xgACsMeB/ +8CEAAPHAmHAKIcAP63IKJcAHz3AAAJ8ZAQLv+zvb4HjPcYAAiDHgf/AhAADxwJhwCiHAD+tyCiXA +B83YBbjdAe/7RNvPcYAAwDHgf/AhAADxwJhwCiHAD+tyCiXAB89wAAChGbUB7/tN2+B4HwkRAc9x +gAAYRwhhQCgCAgV6QCgBBEV5GLgleA7wz3KAABhD8CIAAAPwQygAAmG5L3mMIcOP+/XgfuB4z3KA +ABhI8CIAABcJEAFhuS95jCHDjxTyQygAAvnxBCCADwAAAP9BKAEChiDDDwUgQgBAKQAERXgYuSV4 +4H7geOHFz3WAAKA1AoVCnc9zgAB0LzSDHQhRACJ6Tnrk4gCdBPYzg8bhUvYA2AKlAZ0O8EJ5LnmM +IQOCAZ2I9jOD0OHE9gHYAqUAneB/wcXPcYAAVAYkgeB/IKARiOB/wrjgeM9xgACYOUaBiiH/DyCg +BuoigiCgAdgD8ALY4H7PcYAAuDlGgYoh/w8goAbqIoIgoAHYA/AC2OB+iiH/DyCgz3OAALg5RoMS +6iSCGwleAM9xgACoOA8KQADPcYAAxDgRCkEAQILlC4GAAtgF8CKCIKAB2OB+8cDWCE/6zwgQAM92 +gABMsi+Oz3CBAFAOz3WAAJQcNngiiAOFAN/PcqAALCA0EBEBPBISAA6OgOCcACkAyiWpEIwiAaSQ +ACUAyiUlEWSWlOPAI4YPAACTAM9woABoLPAg0ADlolDYRSFBAhja5gugCyDb+LjKJSISLvQD2M9x +oAD0BwWhhNoNcECwQiIAKA1yALJAhg1wQKBClg1wQLADhUCADXBAoAOFQpANcECwBpZAKAIlw7gM +uIK4BXoNcECg5KEOjgHgDq66DKAJKnAB3RDwAN3PdoAATLKuDKAHBJYA2M9xgACAMw6uHoEB4B6h +QQBv+qlw4HjxwOYPD/rPdoAAuJcrCPQAGnAeljoWBREKIcAP63IQuAUlBQDPcAAAgwyKI4UPOQev ++wokAARAKA0h3WUllQSVELkleDjoz3CAALRW8CABBEQoPicAIYB/gACANy93IKAjlQKVELmyDu/+ +JXgIcQAngB+AAHQ3RgsACc9wgACoVvAgAQQAJ4AfgADYNkeVIKAjlQKVELoQuSV4JpVGCi/8RXl2 +Ds/+CHEAJ4AfgADMNgoLAAlelh2WANkPIQEEELpFeAYgQIAB3R22MLgethT0z3GAAIwjAIGguIYP +IAUAoc9wgAAIGwSAIIDPcIAA+JeioCGgENrPcYAAPAcAgQAqAgRGeEUHL/oAoeB48cDiDi/6ANoP +IgIAz3OAALiXHpM9kxC4BXkGIb6ANvTPdYAAjCMAhYC4AKXPcIAATAbPdYAAwB8AkMeNNw4BEM9w +gABOBgCQwY0rDgEQz3CAAFAGAIimjRsNARALyAQggA/+//8DCxoYMAvIh7gLGhgwz3CAAAgbBIDP +dYAA+JcAgAClANgCpUV5PbMwucEGL/o+s/HA4cWuCqAAKHWA4MogQQP0CSEEyiFhAKkGD/pRB8// +8cAqDg/6NgygCADdz3CgANAbEYAXCN4DhgigCQHYz3GAAPQ0CYEB4AmhBsgDEgI2OwgeAKQSAAAz +CJ4Ez3GAALgwAIET6KChAQmeRc9woADELAuAUyCBBP64zCEigAfymBIAAJYL7/4A2gMSATagEQAA +FwgeBIogCAAMGhwwcgvgBChwLvBJCB4FB8jQiQDaMxGPAAQggA8BAADwQSgNA89xoAA4LgeBDyJC +AwHcRngHoQ3I6g3gCgAsABDHd4EAEAwCvtZ+EuffZ6CviiAQAAYaGDADyKAQgADE4LAJwQoD2c9w +oAAUBCOgqQUP+uB4osHxwEHCYsMKJQABgcNAJAQyEgggAAHa0cDgf6LA4HjxwAYND/qCJAM8CHco +dRpyOnMKJAAhCiJAIcDhVSTTN4t20vZ2Ce/6yXDJcOlxVgkv+6lyVSNAJvYI7/rJcVUjTyYQ3ZbA +ANnWDO/7QdpAIwAoANnKDO/7QdrpcJbBGgtgCKly6XBAIwEoDgtgCKlyiiQBcADZqCCABQAkQjBY +EoIAACRAMEcigg1YGIIAACRCMJwSggAB4YciAQecGIIA+gjv+slwyXCWwdoIL/tA2h8IciAA3Qp3 +8CFBIzIkQiPCCC/7yXBhv/EPdZAB5UpwXgjv+slxxgjv+slwyXBAIwEooggv+0DayXBKcZYIL/sQ +2kpwOgjv+slxYQQv+oAkAzzgeKLB8cBBwkLDCiUAAYHDQCQEMhIIIAAB2tHA4H+iwOB48cDeCw/6 +giQDObpwmnFIdxpzCiMAIQohQCGXxalwAN7JcdoL7/tB2lUk0jdAIgApyXHKC+/7QdqqcKlxFgpg +CIpyqnBAIgEpCgpgCIpyiiQBcKgggAUAJIEzXBGBAAAkgDNHIYENXBhCAAAkgTOgEYEAAeaHIQEH +oBhCAIt2aghv+8lwyXCpcW4Jr/tA2h8PdBAA3fAgQSPwI0IjWgmv+8lwYb/xD3WQAeUqcJYPL/vJ +cTYIb/vJcMlwQCIBKToJr/tA2slwKnEuCa/7FNoqcHIPL/vJcVkDL/qAJAM54HjxwBYLD/rPdYAA ++JABhc9zgQBQD0QgBIPPcIAAyMsMiNJo1n7HdoEAEAxAhhZ7IYMS8lAijwXgpkYhAQYhow0MEQGR +v+CmBfCxura6QKauDYAKB/CWukCmRSEBBiGjC42iuB0DL/oLreHF4cbPcIAAyMtMiIwiAoDPc4AA ++JAX8sqLz3CBAFAPMmo2ecdxgQAQDFZ4QIGhgAXulbpAoau9BPC1ukChi72hoADYC6vBxuB/wcWh +wfHAUSAAguHFqAAhAAh1RCUDFgQlgh8GAAAAI7sxugHjemIEJYAfwAAAADa4z3OAAABWSmMIY1hg +QS2CElIiAgDAugO6GOKF4MoijQ8BAIkN1SIOAFBxUgAlAADY7b0YACEAAiGAAM9xHEfHcQUofgAK +IMAOA/AiuEEtQRPAuQS5NHmpcsa6SSLCBVR5z3KAAGRNMmIPDd4SQSoBARQhggAFKj4AQSkAcgjc +LwIP+gohwA/rcjvYjLjPcwAAVxJKJAAAGQGv+wolAAHxwJYJD/rPcIAAyMsMiIwgAoAr8jJoNnnH +cYEAEAyggc9zgQBQD893gAD4kOSXFntBg1AljhWGJ7sfwKGMJ0SQRiICBkGjBfSRvsChC/Cxvba9 +oKEPD1EQlr2goUUiAgZBoxoMgAoA2c9wgAD4kJEBL/orqOB+4HjgfwDY4H7gePHAygtP+uB44Hjg +eOB4aSCAAW8hPwBpIAAA9/HxwPYID/oacM92oADQDwDdB/AQFgCW/WH4YBAeGJAjbW8IRCAlFgOW +JRYCli8kxwAlFgCWT38PfQi9pX/XDBGDgufMJ+KTzCcil8olQhAh9M91gABEmEmtJRYClgqtS60l +FgKWaK1MraJpFQ/RE89wgABRmP4Lb/oN2Q3lEw8RF89wgABemO4Lb/oN2Q3lEBYAlgIgQSM4YBAe +GJC9AC/6AdjgePHAVggP+owgBICAACYACHd5DxQVz3aAACiYViZAE7ILb/oC2WgWABFhCFEAViaA +E54Lb/oE2VQmQB2WC2/6AtlqFgARRQhzAWi/Arg9DwQQAN0L8FUmQBe1eHYLb/oE2WS/AeWvfWoW +ABHtDQKQVSbAFl4Lb/oC2WwWABENCHMBYr8CuAkPBRAA2BjwAN0L8FUmQBi1eDoLb/oE2WS/AeWv +fWwWABHtDQKQz3GgANQLD4EfZwHY76EFAA/68cCg4AhxANgJ989wgAAomDGgAgtv+kjgAdjRwOB+ +4HjxwGYP7/kA2jpwjCAEgEogQCDCIA0kz3CgANAPJRAAhs91gAAomM93gAC0mEAnUhOUHQIQz3Cg +ANAPJRAAhkAnExMC3pUdAhCWFYEQlRWAEDhgkODKIIkgfwhRIADYE/CSCm/6EOCWFYEQAeEveRNp +FXgyIgAglh1CEB5mQCRAIA94mnCVFYAQTwwDIBNpFXhicGIKb/oB2ZYVgBDPcYAA5JgDuBV4OGBK +Cm/6BNmWFYAQA7gVeEJwOgpv+gHZlhWAEAO4FXgZZy2JBuaVCXKI+GBKIAAgz3KgANAPEBIAhgIh +gSM4YBAaGIDRBu/5CnDxwI4Oz/mhwQh1KHZZDTQRANiLcO4Jb/oE2QDANQiAD/IBAFA3CIAP8gUA +UBsIgA+aCVBvz3GgANQLD4FkvbhgD6EB2BDwqXBKDe//yXEL8Klw5g3v/8lxBfAMbbYO7//JcQ94 +lQbv+aHA4HjPc4AAjCNAg0V4AKMZ6c9xgADAH89wgABMBgCQR4k5CgEAz3CAAE4GAJBBiSkKAQDP +cIAAUAYAiCaJHQkBAAvIBCCAD/7//wMLGhgwC8iHuAsaGDDgfuB48cDPcIAAeAcAgAvoz3GAAGgw +C4EB4Auhdg6v+wLY0cDgfuB48cDPc4AAGAZocN4LIAAE2QRr1gsgAATZ0cDgfgDYz3GAAHwGAanZ +BWAKAKnxwOHF4glv/THYtGjaCW/9M9gFfRi9z3CAAMQ+GgtgCJC9KLjJBe/5pXjgeOHFMmg2ec9y +gQAQDCFiz3KAAJQcLbnAufAiQwAog1EhAIDPcYAA3MlBgQnyPIuA4cUigQ8AAAoCA/JFIkIDSiQA +dADbqCCAAjZodXkAIY0PgQDQD0ClAeMA3c9zgQBQDhYjAgCgqqGqAdkiqgPZI6pKJABxqXKoIMAB +eWIWeaSpAeLgf8HF4HjhxUokAHgA2KggAAgA2891gADsGkCFDyMDAAsiwIAP8kGFCyLAgEDazyLi +B8oigQ8AANAAzyLhBwLwANrPc4AAwBEVe0CjAeDgf8HFz3CAADw6BoADgCCAz3CAAByLKaChBq/8 +EdjgePHAXgzP+c9wgAA4zcKIEw6eEADZz3CAAEIHIKgd8M9wgADg1LqI473KIWIA9PXPcIAAxJsM +EAQAHwxfAAohwA/rcgi+z3AAAPoqiiONB4kDb/sAJkUTdQTP+eB48cD+C+/5AdnPcIAA4CIkoIog +xQ/PdqAAyB8ZHhiQKHAocihzbg3gAJhxCg5v/ADfRg9P/M91oADQD/Wlz3CgAMAvehABhom5i7l6 +GFiAz3GAAADgEBhYgAXZ9BhAgDYOwAHiDY/+QgnAB0DZz3CfALj/MqBSCAAKgNnPcKAAFAQsoB0d +WJAGCgAJgg+ACM4P4AjpcAfYSB4YkC4MQAbeDIAB2glAAMIPwAPqCcAHVg2AA/oOAAjOCkAAtgpA +B7YJT/yeD8AAZg2ACPINz/4qDMAEGglAASILQAbuDkAFnguACvoNAAR+DE/+AgjABPoPgAQuC8AH +z3AAAP7KEgsP/GUDz/nxwPYKz/nPd4AAlBwDhwiAwLjiDiAJLyAAIADdz3agALRHz3CgAIxEuKAA +2JO4dx4YkAjYdx4YkADYnrhTHhiQ4HhTHliTz3CAADwAEHhHHhiQz3CAAOwCEHhIHhiQTyCAI0Ug +AA1PIMYHNNhEHhiQHNhFHhiQRh5Yk89wgADMMdIOIAUMiEokgHDPcYEAmBSoIEADz3CAANzJQYB0 +bXR7O2MCgEOjAeUEo891gABYOgCFBOhkHhiQQx6YkbIMIAkB2AOHCIBAhR0IHgBTIkEAErlEIgAD +DrgleIYi/wMKukV4EvBIcIYg8w8KuAQigQ8AAAAMBrkleAQigQ8AAAAwArkleM9xgADQI1EC7/kC +ofHA4cUQ3doPoAGpcAfZC7nPcqAA8Bcxos9xAADw/ziisqLKDIABPQLP+eB4ANqA4cokTXDoIK0B +/9lcYCCsAeLgfuB48cDhxc9xgABAyc9wgAA8VvIP4AdI2s9wgABkT89xgACwBuIP4AcI2gDdz3GA +AFwooaGioc9wgAB0K6mgwgxgAgOBz3CgACwgz3GAAOQrUIAQgEWhBqHqD+ABqaHBAc/58cAA2c9y +gAC4lyCiz3CAAIwjIKA9sjC5PrLRwOB+4HjgfuB48cAiCe/5INukwc9xoADIHGmhz3GgAJQTANpb +oc9xgABAEqCBM2g1eYt3MGU9Zc92gAA8y1MggQBshte7RQnRANYN4AqpcIfoz3GgAMwXANhA8B+G +m7gfpjQWgBAijRsIQQDpcEAlARREbVoK4AhAJgMcDdgl8B6GkbiSuB6m5vEfCVEBQSoCUkAlABTp +cVYJb/3Buh+GnLgfpg3YEfA/hiy4wLgDuJm5P6YkhQXgJXtgpyWFIacmhSKnJ4UjpwPgz3GgAMwX +z3KgAJQTHKIB2IroH4Yg2Ze4H6bPcKAAyBwqoBzwAMAD2hgZGIABwATbGRkYgALAGhkYgAPAGxkY +gBQZmICKFgAREBkYgM9woADIHGegFhmYgHEA7/mkwOB48cACCM/5pBABAKLB2wlfBiDZz3OgAMgc +KaOkEAEAXQneATGIz3WgABAUI7nAuQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwnw58J9AQUDzHx +dswn6pAB3kL2AN7r7sWARX7HpbGIhiX8Hxi9pXrPdaAAzBdaoBbwRYDPcaAAEBRHoaQQAQAVCZ4C +MYjXuoYh/A8YuUV5OqDPdaAAzBcN2QHaA+ENHZiQDh1YkCaAGR1YkCeAGh1YkCiAGx1YkAPZFB1Y +kHAQAQEQHViQcBABAc91oAD0BwThJ6VHo6QQAQCZuaQYQACFB6/5osDxwBYPr/kE2Qh1DRIONgbY +DRoYMM93oAAUBAqnz3CAADBWCg/ABwCFAg/gBwTZAYX6DuAHONkIFQQQAYUAEAUBCQwQABUNBQEK +IcAP63IZ2Iy4QQYv+2/bA4XSDuAHiHEBhUKFIJAFhcIO4AdCecqnDQev+Q0amDPxwJYOj/kods93 +gQD4EztnZItAJxERjCPDjxpyP2cS9ADZBPAB4S95z3KAAEASFQkTBECCs2m1fbJi9uokrwPwaHHP +dYAAQBJAhQO5NXkQ4llhqgzgBxDaRI8AhUAuARIDulV6WGAgsCSPAIUDuTV5MmA4YEUiggJAsEok +wHAB2agggAMVDkAQMiFDIACFANoDu3V7eGBAsAHhL3kA2BDdCHbPcYAAxHoWeUAgQC8I4UoM4AcG +2mG9AW7pDXWQD3g1Bo/58cDODY/5osEIdyh1GnLPcIEA+BMZYSSJQCARAYwhw4/PdoAAQBIAIFID +BPIocg/wANoE8AHiT3r1CjOEAIZzanV7cGD46AQagiAghgO6VXrpcBDhWWHiC+AHENoEEoIgAIZA +LQESA7pVelhgILAEEoIgIIYDulV6UGFZYUUgwAIAsUokwHAB2KgggAMVDQAQMiEDICCGANoDu3V7 +eWFAsQHgD3hAJwAUz3GAAGR7PgzgBwLai3FAIEAvfgvgBwLagcEKcEHgcgvgBwTaAN8Q3Ytwz3GA +AMR69nkI4VoL4AcG2mG9AeftDXWQ738EEoEgAIbPdYAAeLIBwgO5NXkC4DhgQKgEEoEgAIYDuTV5 +OGAA2SgdQhABwQWli3cQ4CelJoXpcmoNoAhohQQSgiAghgiFA7pVegThWWECDOAHBdoBwCaF6XIB +4EHABYUQ4EINoAhphdUEr/miwOB48cB+DI/5CHbPdYAAeAcAhSh3huiA5uIgggMh8M9wgABsOb4P +QAjPcIAApCPPcYAARAfAoACBBX/goc9xgABoMAKBAeACoQTwugoP+wCF/ujPcIAAfAcAgPjojQSP ++eB4z3KgAPxEOYIEIb6PAAAIIADYBfQ9gvm5AvIB2OB/D3jxwADYnLjPcaAArC8coRqBUSCAghqB +C/KquBqhGoHnCB6A8gvv/AHYCfCKuBqhGoHTCB+A7gvv/AHYANmbuc9woADQGzGglg8ACkoNAArP +cIAAFDAAgEIgAIDKIGIA0cDgfuB48cDhxc9xgAC4l36RXZEQu2V6Ad0bCg8Az3GAACA3RCg+B9oO +YAgAIUAOqXAC8ADY4QOP+UaBCeojgWCBIoJieTBwANgC9gHY4H7gePHAUguP+Qh1z3aAALg53g/v +/8lxB+ipcNIP7/9AJgEYg+gA2Anwz3GAAJg5vg/v/6lweegB2IkDj/ngePHAkggAAAboAgkAAA8I +UQDPcIAA/CIAgIPoANgS8AoJAACP6PoIAACL6M9wgADcHyyQz3CAAJQcHpDjCQGAAdjRwOB+4H8B +2OB/ANjxwLhwz3GgAKwvGIEZCJ4GCiHAD+tyiiCMCWfbJQIv+0okAAAVgRsIHwAKIcAP63KKIMwJ +aNsNAi/7SiQAAAHY0cDgfs9wgAB4BwCAgODMIGKABPQA2AXw/QgQggHY4H7xwM9xgABCB2CJz3CA +AEMHQIiEKx8AACGAf4AAhNMw4PAggAALCB8AJggAAIPoANgL8CCJz3CAAEDNhCkfADQgQA536AHY +0cDgfuB4z3CAAHgHAICF4AHY4H/AeM9wgAB4BwCAhuAB2OB/wHjgfwDY4H8B2OB/ANjgfwHYz3CA +AHATAIgG6M9wgABYEwGIA/AB2OB+DQleRwnIvbgJGhgwANmduc9woADQGzGg4H7gePHAugmP+c91 +oADIHyQVDpYVDh4ShRUAlhIND/yKIAQAJB0YkFEmgJDUCUIK+QGP+fHAhgmv+TTYCgmAAM93gAAA +ci8IHgTOC+ACANiiC+ACAdiKJhAQAN3yD6/+qXAUJ0wTYb4AtPUOdZAB5Q7wANuKIhAACgpgBHB4 +FCfMEGG6ALT1CnWAAeOVAY/58cAqCa/5NNihwQDdqgigAEDFz3eAAABaMwgeBFoM4AAB2APeCr4A +2Iy4uGAQeItxTg3gAAHaFCdME2G+ALTrDnWQAeUiDMAAEPAF2wq7A9oKunhlnglgBBB4FCdME2G6 +ALTzCnWAAeUpAa/5ocDgeM9xAQDENM9wgADMFeB/JKDxwOHFb9iVuM91oADIHxIdGJDPcAEAQDwV +HRiQXg3ACIogBAAOpf0Aj/ngeOHFANvPcoAARJFKJAB0z3WAALyRaHCoIAACQCUBEhR5YLEB4Ehw +z3GgAAQlD6FWIgAEEaFWIgAFEKHgf8HF4HjxwD4Ij/nPdYAAlBwFhc92oADEJ3UeGJAMlXYeGJAH +hXkeGJAQlXoeGJAqDu//AN8b6Hce2JN4HtiTgB7Yk4Ee2JMHhYYeGJAQlYceGJAHhYoeGJAQlYse +GJAFhYgeGJAMlYkeGJAFhYQeGJAMlYUeGJDB2FAeGJAtAI/54cUIccO4z3KAAMSR9CIDAMm7cHHK +JCJ0yiAiAOggIgL0Ig0Ayb0JCUADAeDgf8HF8cDhxQh1z3GgAMQnGREAhgHagOAREQCGwHqA4gCl +0SDhhwDYM/TPcIAAuMsMgM9xoADIH2TgHqEQ2A6hAdgVGRiAvgsgCgvYUSEAxsogIgAY9CUIXkfP +caAA1AsWgTiBJOAVCEUAmgsgCgPYCQsfQAkInkQY2APwANiA4Mog4gTPcaAAkCM+gSClgQdP+eB4 +8cACD0/5z3aAAJQcFSYBEECBaYK4ikErwADAuBe4x3AAAIAc5LvPICIG4LtO388gogDKJ4IfAABO +AYblzydhEikLXwHPdYAA3B8YFQQRvpYbDQERoYbEFQ0WEQ1fEaCGxBUNFgcNXhGBuFEjAILPIKIF +G6L8okCBz3A6BEpwHaKggQfYCg5gAAq4BCCADwcAAAAwuFUIFQIzJgBwgACIPkAnAXIUeQB5iiAE +AB6lGfCKIBAAHqUV8ADYi7gepRHwANiMuB6lDfAA2I24HqUJ8APYDLgepQXwANiOuB6lgiABAYkG +b/kepQohwA/rcozYjbi+24u7SiQAAIUF7/oKJQAB4HghgADaUyF+gAvyANqZulEhQIDKIoIPAACD +AMAqYgbPcaAAtEdMGYCAZpBIIwMDR5AQuwQjgw8PAAAAyLpFe0iQDLoEIoIPAAAA8GV6UBmAgECA +WQrRAGKAz3KfALj/faJFgFwZgIBGgGAZgIBHgHwZgIBIgGQZgIBJgGgZgIBKgIAZgIBLgGwZgIBM +gHAZgIBNgIQZgIBOgHQZgIBPgHgZgIBQgIgZgIBAgCsKEQJFgJwZgIBGgKAZgIBHgLwZgIBIgKQZ +gIBJgKgZgIAKgMAZAIDPcAAAVVXgfuB48cAiDU/5CHUBgM92gADsGgCmAoUA3+KmAabPcND+AABC +CK//BKbPcJ8AuP/9oACFz3WgALRHMQjRAXoKAADPcAM/Aj+bHRiQz3AJPws/nB0YkADYl7hMHQCQ +byBDAJMdGJAG8G8gQwBMHQCQhg1P/iCGGQneB89woADIOx2ABujPcAAAVVUK8M9wnwC4//2geOnP +cAAArd7xBE/5IpBIIUEBQCkCAyOQYoDLuY+5RXnPcp8AuP99os9yoADsRieiI4A1oiSANqIFgBei +z3AAAFVV4H7xwEoMb/kA26bBz3GAAOwaYKFhoWKhz3agALRHLBYBkAokgA8AAFVVSiQAeGhxqCBA +As9ygADAETV6YKIB4QDZmLmVHliQSiSAcc9ygADsGggSBQALEJAAAN05ddh1qXKpcxl1qCABBL9g +5I8AIEoDDQ/QHxUkQTNgoQHjSicAAA8nRwMLIMChCfIVJEEzIIFKIwAQDyNLEAPwSiMAECqICyHA +gQUhyRIJ8hUkQTMggUonAAAPJ0cAA/BKJwAABSLCAZDvFSRBMyCBDBAFAD/fCiSADwAArd4PIEgQ +BBrCExEPURIVJEEzIIEA2g8iQgATDxESFSRBMyCBSiYAAA8mRgAB5c91gADsGggdQBGA48okgQ8A +AK3eNvIliGSIBiKCAcW6ELkFI4MPAAAAP2V5BSGBDwA/AACbHliQZ4gmiAi7ZXloiBC7ZXlpiBi7 +ZXmcHliQBiEBEsW5n7mZHliQANmVHpiQmblMHkCQJIBYHkCQCpCUHhiQbyBDAJMeGJCeC0/+iHAp +A2/5psDhxeHGz3KgAMBGz3OgAOBGSiQAcgDdqCAAAxYgTgMhhgHlBBpQACKGBBtQADGAz3KgALRH +mBpYgDKAsxpYgBOAtBoYgM9wAABVVcHG4H/BxfHAtMEF2BW4QcDPcB8A//9CwADZQ8FEwUXBRsFH +wT/YSMBJwUrBS8FMwU3BTsFPwVDBUcHPcAAA//9SwFPAdg/v/4twtMDRwOB+4HjhxeHGJIjPcoAA +AFemiMK5LmIA2Q8hgQPPc4AAJJZAg4TtJnpAoxjwRXkgoyWIFSONAyOlJohFiFlhJqUggIwhEIBF +94ohEAAgoCO5IaMAgCq4AqMA2c9woADwNiygI4MloCaDJqAkgyegJ4MooCWDKaAogyqgIYMroCKD +LaAggySgwcbgf8HF8cB2CU/5ocH6cBtxO3JAwwojACEKJEAhCiWAIQomwCHPd4AA8AUghwDYgOHK +IIEPAADIG/QIQQBacACHiOjPcAAAzBvmCEAAOnAE8EohACAAh4noz3AAAAQc0ghAABpwA/BKIAAg +AdjPdaAAyB8TpQbYz3aAAKw1AKYEHsAVCB4AFgDADB5AFhQewBQYHgAVBKYcHkAVD8AgHoAVCabP +cIAACBskgCCBKqYogCCBDIArpgCADKagFQAQDaakFQAQDqaoFQAQD6bPcEN1qBIQpgCHhuhWCGAA +KNgD8ADYEaYAh4DgANhECEEAEqZTJ8B1E6YByFQeABcWphIVAJZQHgAXF6YTFQCWLyGHBBimFBUA +lgi5GaYVFQCWGqYkFQCWG6YWFQCWHKbPcIAAeDQXgB2meB6AGnwewBqAHgAbhB5AG0gVAJaIHgAQ +z3CAAAAABICMHgAQUyAAIxC4JXgvIUcEJXiQHgAQyXBGCGAAJdlFAG/5ocDgePHAJghP+c9zgABA +NkODAN/PdaAALCCwhdJq1H5+ZqWmBKZAIkKAJqZDowbyAoPjowHgAqNZAE/5z3GAAAgbCIEA2kCg +DIEB2UCgz3CgALAfNKDgfvHAegkAAIwg/4/KICEA0cDgfuB48cDCDy/5atiiwYtxAdq6D2AASHOP +6AohwA/rcs9wAADSFIojxQSKJIEKEQev+kolAABAJIExRNgB2o4PYABIc4/oCiHAD+tyz3AAANMU +iiPFBYokAQHlBq/6SiUAAP4K7/kGFAAxkQgQAIHBa9gB2lYPYABIc5DoCiHAD+tyz3AAANQUiiOF +B4okwQqtBq/6SiUAAAQUADFAJIEwAdoqD2AASHOP6AQUBTEKIcAP63LPcAAA1BSKI0UIgQav+ook +wQoCFAAxz3aAAFQ8G3hBKMUATCWAjAAeQBHU9gohwA/rcs9wAADVFIojhQlNBq/6iiTBCh3Yz3aA +AFQ8AKa4cAAUADHPdYEARBxALYIAqXG2DmAAAduQ6AAUBDEAFgUQCiHAD+tyz3AAANYUDQav+ooj +BQxAhicKcgAA2BYlARBgiYYj/w0juw0LUQBhiQTrYrthqQHg6QiCgADY0QYv+aLA4HjxwEoOD/mn +wTpwenEaclpzi3DPcYAAwD8GDy/5GtrPcYAAVDwggQDYgOG4cboALgCKJf8fz3GAAEwTABGEAIom +/x/JdQLw6XZMIYCjAdrPcYEARBwWeWCJwiKMAEQjjwD9f3cKwQPhiUQjAgQkukQjBgJBLsYARCMB +ASK5WwiBIR0MUQCA4cwiIYAH8oHhzCJhgADaAvQB2k96BfCA4gHawHo3ClEATCIApgHawiKKAIYj +/Q8nuw8JgACA4swgYaAL9DJ3zCMhgAnyA+8F6wsJwiMPDsITyXcE8AHZCPAIdQHgZwhEgQDZiiD/ +D4TpgOXKIEoDjCD/j8oggQ//////FfIyJII0z3GBAEQcDwpRAGJxFnkCEcAACfAWeQsKkQAGEcAA +A/AHEcAAeQUv+afA8cA+Dc//KglP/34OwAYKDA//CiHAD+tyPdiKIwsOSiQAAIUEr/oKJQAB4Hjx +wM9wgACUHAKAwhAABlEgQIDADAIG0cDgfuB48cDaDA/5GnAodTpyANnPcIAAYK8goM9wgAAomJoM +7/qKIQwGz3KgANQLfoIAJYEfAAAAQM9wgAD4BmJ5YKDNuc9wgAC4yy+iDIDPcqAAyB9k4B6iENgO +ogHYFRoYgE1whiD8A9DgzCCCjwAAgAAS8owgA4QT8gohwA/rcgokgArPcAAAMhGKIxoN1QOv+rhz +CnCiDa/7KnIE8EoN7/oKcBPoz3KAADzLP4Kc4LO5P6IA2s9xgAD4kEupz3GAACyOTLHKIIEAdQQP ++eB48cAaDA/5z3CgAMQnUhABhkEQAIaGIOOPAN0G8uu50SGigTryz3CAAJQcA4AJgM92gAAomC0I +XgEmCgAEiegUjoHgyiAhAbQNIf/KIWEAz3CAALibAIANCJ4ALghgABCWtK7PcIAAuJugoE1whiD8 +A4wgAoAM9M9xgAB0EwCBAeCCCiAEAKG+Co/7BvCMIAOEuA3B+vEDD/ngfuB48cB+Cw/5z3aAADwH +AN0L8BDYuHgLIQCAeAvi/sogQgMB5fEN9JAghoDhyiAhAAgP4QLKIQEAtQMP+eB44H7geOB+4Hjg +fuB44cXhxkEtAFTBuBcIFQEzJgBwgABQPkAngXIUeQB5ANgX8M9xgAA8y5gRgABAKAIGhiD9D1Ig +wAFFuEV4z3KgAIgkEKIfgbO4H6FK8AHYENvPcaAAyBxpoc9zgAA8y5gTjQAA2s92gACUUsaGQC0B +FoYl/R9SJc0RxXlFvaV5z3WgAIgkMKU/gwLdRCg+DQAhgH+AAAjolbk/o89xoADwF72hpICKEwMB +pqGjgBTjpqGigFMjw4CmoaGApqHAICEIwCAiDGCAc6FsaGCDc6H4EAOCc6H8EACAE6FKocHG4H/B +xeB48cBOCi/5ANt5ClIAn3KoIIAOwJBvYVMmTRADvbh/o4AB5sCwUyZOkKV/46Ao9KGA532hoOKA +Qy3OE+d+3WUEJY8fAP8A/wQlgh//AP8AKL8IukV/wqDnfqGg3WVDLU8XoaDHf8Kg/WVDLY4QoaDn +fuKg3WUA2sKgoaBDoAHjcHs1Ag/58cDOCS/5AdqiwQh1WthgwADYQcCLcWoP7/+pcIHGqXDJcV4P +7/8E2gCVyXHBuE4gAgGpcEoP7//BugECL/miwGGAYKECgOB/AKLgeCGgQqAA2SCw4H8joKHB8cBu +CS/5OXGlwSQcQjEIdxlyuHOIdQDYQMAgh4HGyXDWD+//QYfJcClx+g7v/wbayXAJcfIO7/8G2onB +yXDmDu//AdqLcclw3g7v/wPayXCocdIO7/+pclIP7//JcMlwyHGGD+//6HII3G8BL/mlwOB48cDh +xaHBCHXPcNS6/spAwATwgg2gCQHYz3GfALj/uqEE2Buhi3AeoQDanbrPcKAA0BtRoM9wAG0AEBmh +AQleRwDA0wiAj9S6/sotAS/5ocAA289ynwC4/xqie6I+os9wAGwEABmi4H7xwJoIL/mYcCh2Gggg +AEh1BiCBA4hwTgggAKV56QAP+c9xgAAEI2CJz3KfALj/BuvPcdC6/so+ohqiDuvPcKAAOC4FgAQg +gA/AAAAA8QiAj8AAAABq2Bi4GaIcguB+4Hjhxc9ygAAEI6CKz3KfALj/Be3Pc9C6/sp+ohqiO6IO +7c9woAA4LgWABCCAD8AAAADxCICPwAAAAGnYGLgZouB/wcXgeOB+4HjxwPIPz/jrcM91gACQJJgV +AJZ7CJ4AFgoP/892gACUHMkWABaluMkeGBCTFQCWpbiTHRiQ1xYAFqW41x4YEA6GpbgOpgCGyBAA +BoYgf47KICIAyiECAEALovnKIqIBAYbIEAAGhiB/jsogYgDKISIAJAui+coiogEAhs9xgABAycQQ +AAYluMC4CqEGCQ/+f9gKuM9xoADQGxOhf9gQoQDYlbgQoc9xAACIIAoKIAAG2M9xoADwNgSBRiDA +AQShz3CAAPAFAICA4MoggQ8AAJQA6A7h/8ohIQbPcIAAWBYAgFEgQIAgDCIByiAiAHEHz/jxwAIP +7/gB2IILYAgA3c9wpQAIDM92gADgIqKgBIZRIICADA5C+s9xAACEDJYJIAAG2AvIBSCADwEAAPwL +GhgwBIYjCJ4Az3CAABQwAICL6OoLb/+KIMYICwhRAL4NQAUM8ADZnrnPcKAA/EQhoOB4oaAuCOAG +ANhWCI/83gsAAXIKoAcB2KYIr/sB2OEGz/jxwG4Oz/iIdQDfCugZCFEAAd7PcIAAURPAqAbwz3CA +AFET4KgJ6RsJUQAB2c9wgABOEyCoBfDPcIAAThPgqArqGQpRAAHZz3CAAFATIKgG8M9wgABQE+Co +z3agAMgfz3CAAFETGB7YkwCIiiEQABHoz3CAANEbAIgL6M9wAwBADUUeGBAwpgLYGB4YkALwMabP +cIAAThMAiBvoz3CAANIbAIgX6M9wAgCqLSAeGJDPcIAAKAAhHhiQz3CAAFwFIh4YkBgWAJZFIAAD +GB4YkM9wgABQEwCICOgYFgCWhSABBBgeGJAPC1EAGBYAloi4GB4YkBgWAJaAuBgeGJAY7QDYlLjP +dYAAnAcApXHYBrguDe///Nkghc9wAABMHB4N7/+fuRgWAJaFuBgeGJCpBc/48cCYcAPpIwwSCM9w +gADkBQAQBQAKIcAP63LPcAAA2g6ZBG/6edvPcIAADCMVIAABIKDRwOB+4HgA2UokgHHPc4AA9Ioo +cqggwAHwI4AAAeIFeeB/LyhBAOHFANpKJIBxz3WAAPSKSHOoIIAB8CXBEAHjJXoA2Z65GXkEIYAA +QiAAgMogYgDgf8HF4HjxwM9xoADIH6QRAgDPcIAA5CsAgDWBz3OAAEiOliBBDxByANrKIm8AAYPV +uYHgAdgC8gCDDQhRAA0JhA8AAIgTANgD8AHYgeLMIGKAkA5h+8og4QHRwOB+AuEweUFpDQoDACJ4 +EHgD8ALYz3GgAMgfHqEQ2A6hAdgVGRiA4H7gePHA4cVQ3QDaz3OgAMgfr6NeowIgQgBeowHaFRuY +gEDaTqMEIL7PAAIAELAPwf99BM/44HgA2c9wgAC4myGgz3CAADzLHJBiuEggQAAQec9yoADIHx+C +EHgIIQEAMHkC2BUaGIA/ouB+AuEweUFpDQoDACJ4EHgD8ALYz3GgAMgfH6GKIBgIDqEC2BUZGIDg +fgDZz3CAALibIKAhoOB/IqDhxeHGz3GBAHgURYEk6M9xoADIH0ARDgbPc4AAPMtAKI0CQhMAAXyT +0H7YYLtjYrsIIwMAAnsJIsIAAtgVGRiAz3CAAJQcX6EDgCKAz3CAALibIqDBxuB/wcXgePHAug0A +Aghxz3CAABw4+g6ABwLZz3CBAKwbJKDRwOB+8cDhxc9wgADEmwOAz3WBAKwbEQhfABcIHgAIjQ8I +UQAE2GIL7/0EpQ3wlg7P/m4NAAIIcc9wgAAcOK4OgAcC2ASlTQPP+OB48cDhxc91gADEmxWFgOAM +DwICehUAFgrogODKJA1w4HjoIC0B4HjgeB0Dz/jxwM9wgQCsGwSAGwjRAM9wgAA8ywCQhiD8AIwg +AoC4D8H/FdjRwOB+8cDPcYAAQgcAiY3oz3CAAODUGogPCN4AAdiGCSAGAKkX8M9wgQCsG89xoAAs +IDCBBYAieM9xgAAkrgChKHDPcYAAUK2SCCAH1NoeD8//0cDgfuB48cDhxQh1z3CBAKwbBIAH6BYI +gAEApQHYAvAA2IECz/jxwAYKz/jPcIAAKJiVEIAAAN2A4FIALADKIkwDM23PcoAA5Jg1eSJiBCKC +DwcA8P8kui8rgQBOI4EHL3kA2w8jQwDPcYAA8FZuYc9xgQDEG7Z54YEGIsKA5X7Boev1AeWvfb0N +ApBtCHIAANmYcBNpz3OAAOSYFXgDYwQjgw/4AQAAQSvDhBnyLyiBAE4gjgfPfgDdDyWNE89wgADo +Vq5gz3CBAMQbNnjggAYjQ4PlfsCg7PUI8M9wgQDEGzZ4YICAu2CgQiRAAAHhpQh1gC95nQHP+OHE +/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwcyLH8HAiy/BxIsvwciLL8HMiy4cXhxuHH/BwI +tPwcSLT8HAi/aiSAEOHEaiTAEOHE8cDPdaAA0BtcFRAQe9iyCK//iiEEA89wnwC4/x2A63bLcM9w +AABEHEYI7/8KJ8AfOnAXhQfYOgjv/wq4UyBBBwfYbgjv/wq4z3CgANQLGIBCIAAISCAAAM9zgACI +Ms9xgACcByCBvBsYAAshQITKICIDLvQfCJEgFwmeJYnoUSFApWTYyiCBDwAAXAAg8DTYHvCMIASg +GfJMIACiEfII9hsIUCAnCBEhhtgS8BcIECSMIAGgC/RM2ArwZtgI8DzYBvBG2ATwVNgC8ITYkxMD +BulxyXIKJAAEhQcv+golQATgfuB44H8B2PHA4cUIdShwBevPcYAAAHIE8M9xgAAAWlt6pgjv+LR5 +UQDv+AHY4HjPcIAATgYAkAboANnPcKQAHEAyoOB+4HjPcIAATgYAkAboA9nPcKQAHEAyoOB+4HgA +2c9wgABgr+B/IKDxwIYPj/gacADez3CBAHgUFBATABYQASHPcIAAwCMAgCCgOfDdZrR9QCAPIQAn +UhMAIkAjAZBWDyAJCrjPcYAAwCMggUAuEREM4SJxAKG4ZwKQqWcKuAUp/gQyDyAJJ3AIcS4Kr/oA +EAAgz3GAAMAjIIFCdQThInEAoQGNAeYFKP4Ez3CAAMAjAIAI4CJwABhADhYQACGRDgSQRQeP+OB4 +8cDuDq/4A9mCJAI7OnEI6KkIUACBCJAAKnWM8M91gABgr+WNi3AybzR5ACVQEAgQkCAAJUQQAdkK +CG/6CnIK8DJvNHk6ZUiKACVEEEUKAQQIdiZoJ9gArg/YAa4A2ASuA64HtgkUgAAB5wKuChSAAMG/ +Ba5AJAAD2gzgBgjaENkwriaNQCZAFEAhUSS1D0GQ5a3E8c9xgABgr1YRgABUEY0Ah7hWGQIAVCHA +CotxA+WiDOAGqXI+8M91gACYr4twgg8v+kCNI9pAqALaQajPcoAAoHtikgjiamIiaEKoAo1huAsI +1AMA2iDwMyYAcIAAbD5AJ4JyFHoAeooi/gkW8IoifgsS8IoiPgsQ8IoiPgwM8IoifgwK8Ioifg0G +8Ioi/g0E8Ioivg4BjQfdQngBqZ/HQCcAFYoKb/rQ2aoUgTCVxslwuWEweRoLb/oA2kAnABVRwFLG +i3BTwFAcRDMODW/6kcDpBa/4gCQCO/HAjg2P+Ah1DpCzCBQBqXCyCKAJANkgiIHhzCGigE/0IYib +CRUBMyZBcIAAXD5AJ4ByNHgAeKlwigigCQTZAIh7CFEAqXB+CKAJCNkAiG8IUQCA2c9wgABwfCaw +MLknsCDYK/DPdoAA/QUAjjkIUQCpcFIIoAkE2QCIAdmC4MB5FQhQAILgzCCCjwAA/gAI8gDYCfC+ +DKABqXAF8GIK4AGpcACui+gQ2M9xgABwfAh0hrEwvIexRgnACUEFj/jgeOB+4HjPcQEAxwPPcKAA +7CcmoOB+/BwItPHAGnA6DK//JNiYcFEgAIDKIcEPyiLBB8oggQ8AAFEmyiOBDwAAKQEEBCH6yiUB +BM9xoACsLxiBhwgRIA8IngbPcIAAmCMAgEB49NgA2dILr/8B2jTYANmRucYLr/8A2jDYiiEGALoL +r/8A2jTYANkD2q4Lr/8UusYLr/8w2MK4CQhRAADYA/AE2M9yAQDGA89xoADsJ0ahz3OgALQPPIMj +6QESBDZwEwUACiHAD+tyz3AAAFImeQMv+oojRQaauBihhghgCYogDwrPcIAAmCMAgEB4cghgCQHY +Fgkv/4ogBQOH6ATY0cDgfwQUEDRE2c9woADIHCmgTghgCQHYzg1AAcLx8cCqC4/4osEodgokgIAA +3891oAAsIEAVEBAAHMQzE/J3DFAATCSAgILyCiHAD+tyz3AAAFQmiiNEBfECL/oKJQAEMmgEIYEP +AAD8/y4Lr/8s2BCFAiAABIwgD4oI994Kr/8s2Ah37wgegAXwAIaAuACmygqv/zTYFwheBQCGANkA +2oG4AKY02JIKr/+VujC/AhzEM3zwD3kQuQUhgg8AAIL9z3GgAOwnRqEEIIAPAAAAH0i4hrgQuAUg +gA8AAEL9BqEQhQIgAASMIA+KC/eLcdIJr/mKIA8NABQAMecIHoAE8ACGgLgApoHBugmv+YogTwwE +FAAxDQieAACGgbgApot1iiCPD54Jr/mpcSDACLgCHAQwiiDPD4oJr/mpcSDBAhQAMSV4AhwEMDLw +z3EDAEL+z3egAOwnJqfPcQQAAv4mp4a4EHgQuAUggA8AAEL9BqcQhQIgAASMIA+KC/eLcUIJr/mK +IE8PABQAMecIHoEE8ACGgLgAps9wBgAC/wanQCSBMB4Jr/mKIM8OAhQAMX0Cr/iiwOB44H7geOB+ +4HjPcacAiEkA2gsIUQAD2A6hAvBOoeB+4HjhxeHGz3WAAOAjoI0A3sCjke2B4MwhIYAN8gsKEwjA +ownwwOIG2Ab2QiIACEO4AuAAo8HG4H/BxbhwQNwAIQCD8cAOACQAmHGMIAKAi/YKIcAP63LPcAAA +yRQZAS/6iiPID89wgACAQfQgAAHPcYAAgEIEKH4BL3D1IQEBQigDBMG7UrgEKX4BL3FCKQIEwbpS +uYHjwCBpAIHiwCFpAIggPgCJIMEPiCE+AIkhwQ+A4NYgKwiA4dYhKwhyCQAA0cDgfuB48cAiCY/4 +ocE6cQDfgODKIcEPyiLBB8oggQ8AAMoUyiOBDwAA0wLKJMEAhAAh+solwQPPcYAA5CNAsc9xgADm +I+CxTCEAoMolzhNkAC4AyibOExp3WncF8Ml3GnVqcEAgUwCLcQHa1gjv/wDbABQNMS8jyCSpdim9 +yL6/5dklKRRMIgCgyiDCA8ohggPKIgIESA0iAMojQgPJcN4O7/+pcUIhUSC1CXWgQCJSIMlwHgkg +AKlxxQCv+KHA4HjxwG4Ij/g6cM9wgADgIwCIGnGVCBEAz3GAAOgGpYkEiR1lMnXKIcwPyiLMB8og +jA8AAMsUyiOMDwAAOAPKJEwEsAfs+colTAMA3c93gADhIwDeCfAA2SCv7g7v/4rZAebPfgAggS+A +AOgGJokBaTEOAxBAKYAgFHi1eNR4z3OAAByyEGNSbW3oAuAQeNR6z3OAABCyUmPg6QHZ3/EB5a99 +sQ3SkCkAj/jxwM4PT/jPc4AA5iNAk1MiTYAg8kcNkRDPdYAA6AYJrSitIoXPdoAA5CMAlindEr3P +d4AA4SMVJQwQIKTgjwfvViAPCPB/9X0gpQHgALYH8M91gADoBgutKq0B4tkHb/hAs+B48cBmD0/4 +CHYacc91gADmI+CVC/DMfxIJr/hAKUBxRbiODe//CnEglYwhEIC09p0HT/jgePHAJg9P+Ah2z3CA +AOAjAIh6caHBGnLLCBEAz3GAAOgGpYkEiR1lcnXKIcwPyiLMB8ogjA8AAMwUyiOMDwAAhQPKJMwE +bAbs+colTANKIQAgAN0K8AEeUhAGj4ToIK4B5gHlr33Pd4AA6AYAJwAUBogB4GMNIxACd0ArgCAU +eBUgQAS0eM9xgAAcsjQhEgAA2cUKEKCLcUpwAtqmDq//ANsL6AEUgDABHhIQBo/a6AEUgDAArtXx +CiHAD+tyz3AAAM0UiiOOBgokgATpBe/5SiWAAEAhUSAvIUckeQnSoKEGb/ihwADbYKkRCHIAYKoN +CNMDYKngf2CqDwiSCMDgBfYB2ACpEfDk4Ib2jCACg8ogrADJ9owgQoSJ9owgQokH9gPYAKkB2OB/ +AKrgfvHA/g1P+KPBSiEAIItxKnBKIAAhCnL+Da//KnOO6AohwA/rclPYBriKIwUBCiRABFUF7/kK +JQAEIMIVChIAAMBBKAECUyHEABMMEgEB2c9wgADgI1UCIAAgqM9xgADoBkCpAhkCAUEoDgNTJsUQ +AxlCAUwlwIDKIskHyiCJDwAAwhTKI4kPAABYAfwE6fnKIckPQSgCBFMixgAEGYIBQSgCBVMixQAF +GUIBTCZAgMwl7IDKIckPyiLJB8ogiQ8AAMMUyiOJDwAAXgG8BOn5yiSJAUEoAgZTIsQABhkCAUEo +BQcHGUIBTCRAgMwlbIDKIskHyiCJDwAAxBTKI4kPAABkAYQE6fnKIckPBBSFMIwlAYS0ACwAARlC +AQohwA/rcs9wAADFFIojRQpdBO/5mHPPdYAAHLIA3wPwAefvf0EoAQLDuW0PQxAA3hPwQCmBIDR5 +ChSAMBUhQQEB5s9+FHm5YQAZBASAIAIjLyAIJADAQSgBBsO5AeHDDkOQgsEKcALakgyv/wDbCxSE +MC8oAQFOIIUHLyVHAbUN0oAKIcAP63LPcAAAxhTdA+/5iiNGAkAhUSAvIUckQSgBBMO5ewlCoATw +bQ5TgEEoAQXDuQp1qQlyAEogACBKIgAgBfBAIlIgLyKHJEEoAQPDuXsKQyBKIQAgFPACvtR+ChSA +MBUmThFAIVEgLyFHJBR+ACaAH4AAHLKgsIAlAhOwfQDAQSgBBwHhuwlDoDC4w7gAIA4EgsGpcALa +3guv/wDbCxSEMC8oAQFOIIUHLyVHAasN8oDPfgohwA/rcs9wAADHFCkD7/mKI4YIQCBQIC8gByRB +KAEFw7llCEKg09kIuQDYA97PcoAAELIA27JodH1dZSC1AeNve1YhAQjxC7KAMHlhvgHg5w51kA94 +sQNv+KPA4HjxwDoLT/iiwUDAQcJAKBQFQCkXBQDdQCoTBUArEgUB3kolgCGpdwTwCnXKdwDAFbgT +eBQgwAXiDG/4B9kCIFADAiBAI9IMb/gO2cx+CiFALgQpPnAvcKx+ACENdR1lAcAVuBN4FCCABK4M +b/gH2QIg1gMCJsAjogxv+A7ZBCh+BC9x7H4AIcB0GWFCLQAVEgnv/1S5QiVVIAHmkQ11oM9+4QJv ++KLA4HjxwJYKT/g6cLpxz3CAADzLAJBKJEAgANlKIEAghiD8AIwgAoDCJAIlSiKAIM9wgAD4kCuo +z3agANAPJRYPliUWDZZCIYAgEBYWlisIRAMCIFEDDCGApMoiLiBuCO/46XCYcADYKQwQIBUPUBEN +D9ASB/BKIwAgLvAB2APwAtjPcYAAWBMkgQshAIAE8gDaA/AB2gAiQCNaDu/5ynEKIwCgGPInDJAD +z3CAAFgbFiAAAUCABogrDwEQE+qpcGB6qnEKIACgBvLCdRAeWJNpChGgTCMAoMwgIqAR8gDYEPAK +IcAP63LPcAAAMRGKIxcLSiQAAD0B7/kKJQABE9jlAU/48cDhxc9wgAC0JQgQBABMJACAyiHBD8oi +wQfKIIEPAABpGcojgQ8AANABBAHh+colAQHPcqUACAwIEgUAANlMJQCAzCUihMohwg/KIsIHyiCC +DwAAfRnKI4IPAADXAdAA4vnKJCIAQNgCos9wgAC0u2CACvD0IE0Az3CmAACANXgB4aCg0uGEKwIK +ACRADrT3pBADAc9xpACgP32hphAAAR6hCBpAAYUBT/jgePHAgiQDMotwz3GAAPQ+vglv+MjaSiRA +dgDZqCBAAxYkQDBhgECQK9gSuAHhVXhgoDB5gCQDMtHA4H7gePHAvg4gAEfYANrPcasAoP9ZoQfY +GqFYodHA4H7gfuB44H7gePHAz3GAALQlOIGA4SAOAgDRwOB+8cDPcYAAtCU9gYDhhA8CANHA4H4t +BEAIKQRACCUEQAgA2c9wgAC0uyGgVQRgAiKg8cDhxc91gAC0u54NYAKpcLhwAIUS6EokgHPPc4AA +xCMA2aggwAJAg0QpvgMyIkIOPwpAAQHhEfAA2UokgHnPcoAAsE+oIEACRCm+AzIiQw4fC0ABAeEK +IcAP63LPcAAAhhmKI0QBeQev+UokAABtAG/4KHDPcIAAtLtAgCOADOrPcIAAxCMAgEQpvgMN4DIg +QA4J8M9wgAC9T0QpvgMyIEAO4H7PcAAAAT/PcaoA8EMFoc9wAAA+PQahz3IAAD09R6GKIMwPCKEJ +2Iy4CaHPcAAAFhwKoc9wAAAfHwuhz3AAABwWDKGR2AS4DaHPcAAAAz8OoU+hz3AAAD0+EKGKIMQP +EaHgfuB48cBWDw/4SgqgAgDeQg0gAAfYRg7v/xpwz3WkALg9rBUAFs93pQDYy2nawNmiuKwdGBDM +p/YdmBPPcBUAKyuaHRgQyh2YEMsdWBCg2MQdGBDPcAAAbm6bHRgQiiDEAJ8dGBAa2PMdGBD0HRgQ +ZNjIHRgQqtjJHRgQzB2YEM0dWBA52c9wpQAIDD6gFg/P/84JIAAKcBjYlR0YEM9xgADEGsGhyNgC +oQChA6HPcQEAoNDPcIAA1BTUGEAAlNgLp0HZz3ClAMx/LaDPcKQADIDCoOkGD/jxwBoIAAAqD8// +qg0AAFIKD/vRwOB+4HjxwGIOD/jPcIAAYMhAIBIGCHHPcIAAIAYgoADexKgE30QuPhcKIUAuACGA +f4AAYMgSDu/5HNmELgoSACGNf4AA0LupcP4N7/mKIQoChC4CFwAhgH+AAPDFGnDqDe/5nNkAIZEk +ABlAI2G/oR0YFLUPdZAB5kkGD/jxwPYNL/hEKD4HACGOf4AAYMgQrgHf8a4hrkCuYq4DHgIRcq5S +CSAAEx4CETEGD/jxwL4NL/hEKD4HGnA6cc9xgABgyC9wGmFRihthHwpQAAohwA/rcs9wAACyKF7b +iiTDDxEFr/kKJQAEFQjQIM9ygAAgBgQaAgQ4YACiAYsgi1KL6gsgAHOLNg8AAQpwMg0gACpxuQUP ++PHA4cUIdfoO4AUA2KoPj/tE2c9woADIHCmghg5v+BzYz3CgAKwvGID6uFALYQLKIEED/9nPcKsA +oP85oDigMg7gAKlwkQUP+PHA4cVKDO//CHXuD6ACqXB9BQ/4z3GgAMgcCKE5Bm/4BtjgePHA8gwP ++KLBooFgkM92gABoBrh7o4FkfWCGpXumgQGQuHingWCmpHihhkAhDwSleAGmHeoBgQIcxDAwuwQc +xDAAHAQwIIGLdWB5qXABhyGGAhxEMDC5BBxEMCCHABwEMGB5qXAA2ACmAabxBC/4osDxwIIML/ic +2Qh2z3WAAPDFhCgCBy93Qgzv+QAlQB5SDaAB+GUCCSAAyXDBBA/44HjxwFYML/gB2oQoAgcAIY1/ +gADwxc9wgAAgBgCAKHYgiACGmR2CEEyFMLgPeIkKUQAD2pkdghCBCQEABNiZHQIQEIWN6AXYmR0C +EAiGEqUDhhGlHIYUpReGE6WpcKYOYAHJcRCFAeBRCDQEEKUG2JkdAhCpcNILoAHJcalw6gygAclx +qXBSC6AByXGpcDYNoAHJcalwQg2gAalxmBWAEBkIUQAH2JkdAhByCCAAAm0A2JgdAhANBA/48cDh +xQh1hCgCBwAhgH+AAPDFz3KAAHQxSJIfCl4AIIEXCVQBANktoC6gXgygAS+g8gggAKlw3QMP+OB4 +hCgCBwAhgH+AAPDFz3GAAHQxKJEJCV4AAdksoADZ4H8woOB48cA+Cw/4CHUmCSAABdhAlSGVCLpF +ec9ypAC4PZsaWAAilc9zpAC0RcoaWAAjlcsaWAAklcQaWAAllcYaWAAmlccaWAAnlcIaWAAolcMa +WAAplcUaWAAqlaMaWADPcYAAlBwjgSiBAN4ZCR4ATJUrlVt6RXlTG1iALZVUG1iABvBTG5iDVBuY +gy6VVhtYgC+VWBtYgDCVVRtYgDGVVxtYgDKVWhtYgDOVXBtYgDSVWRtYgDWVWxtYgIINz//tAg/4 +8cCEKAIHz3GAAHQxKJFTIUGAz3KAAPLFL3AF8iYP7/9YYNHA4H7gePHA4cXPcIAAuCMggAHdYHmp +cOe4J7hSIAAAyiUiEMohQgPKIeEBwLgTeMK4z3KnABRIC6Isos9wqgDgB7OgjQIP+OB48cDhxc9x +oADIHKiBCKFCC2/4BthxAi/4qXDgePHA9gkP+Ah2z3WAALS7AKUhpVitfgnv/3mt7gnv/wOlBKXP +cKAAeEUAgAQggA9wAAAAQSg+hQDd9fVaC+AFqXDPcasAoP+5oQfYGqG4oT4PQAKA5gHYwHgM4AYN +r/oB2QECD/jxwIIJD/gId891gAC0uxiNSHY6cRpzEwoBAIXuGY0LCAEEANgC8AHYLyIHIOlwcgxg +AslxIIUA2A8PQRAhhTJxzCIhoALyAdgvJgfwGq0X8ulwKnHJckoP7/8KczYPwAIBhc9xgABMBgCx +AIUBsRiNBKmSDuACCnAI8IDnAdjAeAzgegyv+gHZVQEP+PHACHMA2QLahCsKAgAhgH+AANC7hCkE +DwTgTgzgBSdwYbrpCnWAAeHRwOB+8cDPcIEAmBaiCO/5iiEJDM9wgAC0H5YI7/kU2c9wgADYIooI +7/kU2dHA4H7xwJYID/iiwTpwGnEA3ZIO7/8H2JpwAtmpcFpwenEA2zRoAnEodRQhACBocsKFBBAP +Bdh/w4UB4sR/5XvxCvSAIOUBgQIcxDAwuwAcBDAggQQcxDBgeYtwQiNBIL8JdYBAIkAgRgvv/4pw +gQAv+KLA8cAuCA/4OnBacc93gADMMQyPz3aAALS7pYaGIP8BQ7gOJQ2Qz3CAAKgjIIDKJWIQYHkE +2CDoGo6A4MwlIZAc8gDYEN0acAK4FXjHcIAAOCUggAbpIoAV6WB5KnBhvekNdZBAIEAgANgargyP +hiD/AUO4BaZ2Dm/4SnARAA/4CiHAD+tyz3AAAGUZN9sKJAAEJQdv+bhz4HjxwEKQIZBgkBC6RXkp +2hK6FSLDACCjAJDwIgAA0cDgfvHA4cXPcYAA0MgAgQDdFejPcoAA/MgAogiBoKGkoQiijgmv+gnY +igmv+gPYz3CAAIw4sgrABs9wgABcKJ4KoAADgM9wgAAcLLEH7/evqOB4NQVP+vHArg7gAuHFz3CA +AFQ4ggrgBgDdz3CAAHA4dgrABs9wgACMOGoKwAbPcIAAXCiioCoJr/oD2M9wgADkK6OgaQfv96Gg +8cDhxc9xoACsLxyBvYEEfc9wgADQGwCIEwhRAM9wwN8BAByhKNkYuQnw/L3ED8IC9r00CoL6ANmb +uc9woADQGzGgIQfP9+B48cAiCAAAog4AANHA4H7geM9wgABcKACAgeAB2OB/wHjxwIYOz/fPcIAA +QMnHgMC+geYB3s9xgADILQCBwH5RCF8AgbgAoc91oACsLxiFDQieBhiFurgYpQLYFqXPcIAAqCMg +gGB5ANgZCBECygqgCArYC/DPcKAAqCANgOTgivcVhfUIHoAKCe//yXCFBs/3cBUEEFQVBRAKIcAP +63KKIEwJfQVv+Yojhg3geFMgYMHPcKAArC8ZgIYgPgMD8gDYA/B/6AHYLyAHgAfyAdrPcYAA6AVB +qeB+8cDhxc9xgADcP0CBIYGnwUbBz3GAAFwoIoFFwhUkQjDPcaAALCCwgc9xAQAIFkDBAdlBwULB +ENlDwUTARYIA2AzZCHOYcLhwACWHHwAAAH1KDO/82HDtBe/3p8DxwMoLD/7PcqAAwC8A2YgaQAAT +gou4E6LPcIAASBIBkBC4RSAAD8AaAADPcIAAcCtCC2/6IKDRwOB+4HjxwADZm7nPcKAA0BsxoJoK +gAAM6M9wgACQBiCAz3CAAJwr8CBAAEB40cDgfvHAAg3P9xpwz3CAAEDJB4DPcYAAlBxTIA8AgecB +3yCBxBEBBsB/OwleAc9xgABIEqGRz3GAALAGwIE85blmZOEfCQQECiHAD+ty3WWKIMwIWtsKJAAE +LQRv+VUlRRYhCNEAz3CAAEgSQZDPcYAAsAYggTziWWFk4QIgUCALyAQggA/+//8DCxoYMAvIh7gL +GhgwGg+v/+lwz3WgAMAvSQ9REBCFNQgfAM92gACwIyCGYHkB2A8IUQEghmB5AtgdCJAAQBUEEAoh +wA/rcoogjAiN27EDb/m4c4ogEAERpRCF/wgfgBSFq7gUpc9wgABYFgCAguAS2MAoIgbKICEAzyBh +Bhmlz3GgAMgfGBEAhqG4GBkYgIogEAARoQnYCLgPoROFqbgTpc9wgABAyQeAg+DMIOKBBvRAKIAg +n7iIHQAQAgrABs9xgADILQDYGQTv9wCh4HjxwA0JUQD2CwAABPDSCwAA0cDgfvHAYgmgAOHF5g5v ++hrYz3CAAHQrAJDPcoAAKMlSIAEAwLkB4SCqANkXCF8Az3WAAOQraoULC1AAa4WB4wL0AdkjqkEo +gQLAuTSqKbjAuM9xgABcKMED7/cAoeB48cBCC8/3z3WgAMAvF4Uahc92oADIH4gVABAH2BkeGJAB +2AhxCHIIc64M7/6YcIAVDxAiv94PoAbpcM9xgAD8MxKB+GASoQDYiB0AEAnYCLgOplkDz/fgePHA +9gzP/4DgANnKIEEAGfJmDyAHKHDPcYAAkAYggYogTAbGDGAAA9oaDmAAA9geDE/8CNgiDCAAiiH/ +DwHY0cDgfuB48cDPcIAAkAYAgBMI0QDeDI/89gvP/+oOAADRwOB+4HjxwIYK7/dKJEBxAN7PdYAA +5CtAJQMcqCBABM9xgAB0K9V544EVI4wD4KQLCFEAAd/joQHmz34B2LUC7/dEHQIQz3CAANDIAdkk +qCWoz3GAAHQrAJGGIBgAqLgAsdrYA6nPcAAAUMMBoc9wAQCghn0EYAACofHAz3KAABwsDoqhwV0I +UQAPih8IEwGA4HQP4f/KIGEAD4oB4A94D6qhwNHA4H4A2A2qDqo6CCAAD6qWD8//ANgKDO//jLjP +cK0LvrpAwM9wgADwBQCAiuiLcATZfdo92woOYAUXu+Lx4PHgeOHFz3KAAOQrRBKAAEAiAwwnCFEA +SiRAcQDZqCAAA/AjTQDPcIAAgCs1eAHhoKAveQDYRBoCAOB/wcXgeADaz3GAABwsT6kB2A2pTqlM +qVCpUalSqVOp4H9UqeB48cBKCe/3AdrPcYAAlBxjgXiLOQsRAQCBz3GAAFwoxBAABiW4UiAAACGB +wLgB2oDhz3GBAHgUJoHAeoDhzCAhgMwiIoB88oDwEQgeAM9wgAAoyQCICQhRAJhyBPBKJAAAz3Cg +ACwgcIDPdoAA5CtFhqaGAiOAgADayiJvAAIjT4MA3colbxAXDgVwAEAAAAfqAiOAD04AASAFphcO +xXMAQAAAB+0CI4APTgABIAamAYYW6M93gAB0KwCG4YcfZxEPBRAZD8UQEQsEAAjwCQsEAAkPxRAA +2APwAdgBpiCBxBEDBkErQQFRIQCAyiZhEAbyKYaD4W8mCxDPcYAAXCghgc93gQB4FOaHgOEB2cB5 +gOAB2MB4hid/Hobn0SNigQDbAvQB24DlzCIigMwjIoDMICKAzCEigMwmIpAE9ADYBfD9DBCAAdht +AM/34HjxwAoJwALPcIAA4CIEgFEggID0DML9CdkIuc9woACwHzSg0cDgfuB4z3KAAFwoIYIGeSGi +ANnPcIAAQMkwoCWA4H8xoPHAvg+P9891gABcKCGFJXgBpc9xgABAyRCBocGF6AHYEKEFgRGhLg5v +/YtwAMHPcAEAPAoZCEAAz3ABAAgWEQkAAM9wAQAIMwsJAQASDa/8AdgA3s9wgADkK8Ggiglv+gfY +hglv+gjY0g6AAs9wgABUOKoKgAbPcIAAcDieCoAGz3CAAJQcAIDEEAAGDQheAYYNIADJcAXwegpg +AAOFjQev96HA8cAaD4/3CHYA3cYN7/8ocIDgyiBBAwwJ4v/KIIIDaQeP9+B48cDPcIAABJgIgEUI +3wHPcYAAdCtCgSGBz3CAAMgrQKDPcIAA5CsnoM9xgACQBiCBiiBGALoIYAAC2hIKYAAC2IYI4AUC +2GYKD/oI8M9wgABcKPoJYAADgNHA4H7xwJYOj/codT0I0QDPcYAASBIhkc9zgACwBkCDPOE6YiGD +ZOJZYSEJRAMKIcAP63KKII0BiiPGB0okAADVBS/5CiUAAc9xgABAyc92oAAsIPCGngtgAAehsg3A +BqIPL/wB2DIJ7/+pcAHYig9gAOlxz3WgAKwvHIUTCF8GGIWIuBilVg/v96DYB/DPcYAAyC0AgYK4 +AKHCCs//SgpAANCGYg8v/AHY+gwAAIIKYAgy2M9wAIIBABylpgsv+gImwBMA2DIPYADJcTUGj/fx +wOHFz3GAACjJABGEACEMcwClwQMRhQAVDVAACiHAD+tyiiANASEFL/nx2zcMkQADiZnoANgAqc9x +gACQBiCB+dgH3YIPIACpctoIYACpcM9wgABcKEoOr/+joD4Oj/9e8M9xgADQyASJHQhRAAWJFQhR +AM9wAAD//z4O7/8A2Z0IEADPcYAAlBwAgcQQAAYNCF4BA4EYiBsIEQHPcYAAkAYggYogxAQeDyAA +AtoC2DTw9gpAAGkIhA8AABQEz3CAAFwoAIANCFEAGgkP+ijoANnPcKAALCCwgM9wAQA8CkDAAdhB +wELAQ8FEwQbZCHIA25hzuHMAJYcfAAAAfZ4Lr/zYc89xgACQBiCBiiAECrYOIAAB2gHYCghAACUF +r/elwOB44H7gePHAogyv9wDZz3KgACwg0ILPcIAA5CsIgM93gQB4FAImDRDPcIAAKMnlh2OABS/+ +EDd1AdugiMIjzgClwQsNUBADiCMIUQDPcIAAXCgjoM9xgACQBiCBz9hGDiAAANoA2Efwz3WAAJQc +AIXEEAAGhwheAYMLUQADhRiIewjRAM9wgABcKAGAt+jPcIAAwBoAkIHgAdjAeAy4WwiADwAAABCw +gs9wAQAIFkDAAdhBwELBEdhDwADYjLhEwChwDNkB2ghzmHC4cAAlhx8AAAB9pgqv/Nhwz3CAAOQr +z3GAAJAGIIHIoNjYug0gAAjaCNgODwAAGQSv96XA8cDhxQDZz3CgANAbm7kxoM9wgADgIgSAOwie +AB4LT//PdYAAlBxNhT6VUyIAANoMIAQB2wCFxBAABhsIXgEDhRiIEwgQAc9wgABAyQeAEQjeAM9w +gABcKAOADPDPcYAAkAYggYogSQc+DSAAAtoC2JIOAACtA4/38cAyC4/3z3KgACwgMILPcIAACBsE +gM92gADkKwCAoIYCIUMD13MAAKAPAN/L989zgQB4FKWD1bhBLYMQYn0LCEQDAYag6GOG4aZvC1AA +z3WAANDIAIUc6AWFGugwggJ513EAAFDDAdjCIA4AJei2CM//BIXlpeOmoLgEpUYP7/kA2Bvw/g0v ++gfYF/AF6waGAnknCVIAUyCAwQSmDfTPcYAAkAYggYogSwKGDCAAAtraDSAAAtjlAo/34HjxwOHF +ocGKIP8POgwgAEDAYQhRAM9wgACUHACAxBAABiMIXgHPcIAAwBoAkM9xgACQBoHgAdjAeAy4JQiA +DwAAABDPcYAAkAYggYogRQcmDCAAANp6DSAAANg58CCBiiBFCBIMIAAF2mYNIAAF2C/wz3CAAHAr +QIAA2QsKUQAgoCXwz3HA3wEAz3CgAKwvPKDPcACA///OCu//AdkX6OoLoAWLcAolAJAR8s9xgACQ +BiCBiiDGAb4LIAAD2hINIAAD2KlwHgvv/wDBJQKv96HA8cC4cM9wgACQBgAQBADPcYAAoCdALIAA +FHgVIEABAGEVCJECCiHAD+tyiiDNAPUAL/mg28oMAADRwOB+4H7gePHA4cXPcIAAlBwDgBiIHwgR +AQohwA/rcoogTQGKI4QNSiQAAL0AL/m4cxoPAAAIdc9wAAC/3x4K7/8A2QsIUQCMJRCVEPfGDm/8 +AdjPcYAAkAYggYogRQIKCyAAANpiDCAAANh5AY/34H7gePHA/giP94oIwAbPdYAAWBYAhc92oACs +Lx8IkAAYhhcIngYahlIgAAALCB4AHIYLCB4HKgqP/xyGNwgeAM9wgABUOACAQiAAgMogYgCR6M9y +gAB0KwmCGwgVAc9xgACUHCCBxBEBBgsJXgEB4AmiTgqP+I4Mz/0bCFAAAIUTCJAAz3CAAJAGAICD +4MgMwf/dAI/34HjxwGoIj/fPcIAAXCgAgC0IUADPdYAAkAYghYDhzCHigcwhIoII8oog0QAA3jYK +IADJcsClTgpP/J0Aj/cKJACA8cAM8gohwA/rcoogTQKKI44NkQfv+Lhz4giP/2YO7/8C2M9wAQAI +FrIOb/wB2dHA4H7gePHA9g9v9wbYFgoP+s9wgABsE0okAAAAGAABz3CAAJQcA4AYiBcIEQEKIcAP +63KKIMwN6ts5B+/4uHPPcIAAlDYSC0AGz3CgACwg0IDPdYAA5CsghQImQBARDgJwAAAgTuIKL/oH +2MClz3CBAHgUBoBRIACAzAoi+sogIgJKCaAFANjhB0/34HjxwOHFkgkv+gjYz3WAAJAGAIWH4Mwg +IoI38s9xgADkK0GBB+rPcqAALCBQgkChz3KBAHgURoJTCh4AhODMIGKBFvTPcoAAXCgCgofoAII7 +CFAAA4EZ6ADZz3CAANDIKaAqoADYPgmv/4y4D/CA4MwgooEL9AOBANoG6M9woAAsIBCAAqFDoSCF +h+HMISKCUfLPdYAA5CsBhYPoA4Uj6M9wgADAGgCQgeAB2MB4DLg3CIEPAAAAEBIN7/8B2M9wgABc +KACAawhRAAOFgeAsC+H5yiBhAAOFgOAgC+H5yiChACfwjunPcoAA0MgKggmiANgKos9woAAsIBCA +BqLPcIAAwBoAkIHgAdjAeAy4IwiBDwAAABDPcIAAXCgBgInoiiCFBkYIIAAC2poJIAAC2LUGT/fg +eM9ygADkKwGCANmF6AOCgOAC8gHZUyCAwQSiAdrCIoEAANiA4cwiIYAC8gHY4H8PeOHF4cbPdYAA +bCjAFQMWEwvVD9Jr1H6+ZgCmIaZCpgFrxbjAHRgQwcbgf8HFz3GAABwsDYkzCFEAz3CAAHQrAJDp +uNEgooII9ADYDqkNqRUEr/8PqQHYDqkPiUIgAIAlA6//yiBiAOB+8cCeDU/3/gmP/89zgAB0KwCT +z3KAACjJQSiBAMC5IarPcYAAwBogkYHhAdnAeQy5HwmBDwAAABCig89xgADIK6ChoYPPcYAA5Cun +oTbwz3GAAFwooIEpDVEQz3aAANDIJI4PCVEAJY6B4QHZAvIA2YDhyiGCDwAAECcD9CKDz3aAAMgr +IKYpDVEQz3WAANDIJI0PCVEAJY2B4QHZAvIA2YDhyiGCDwAAECcD9CGDz3WAAOQrJ6Wpcc91oAAs +INCF5YECJs0TCQ3fF8Wh5oECJs0TCQ3fF8ahKIOG6c9xgQB4FCiRI6IluMC44g3v+QPZFQVP9/HA +z3GAAJAGABEEALhwz3KAADQsQCyAABZ4FSBAAQBiFQhRAQohwA/rcoogjQD5A+/4dtsAGUABuwiQ +AD0IEQHPcYAA0MgAgasIEADPcoAA/MgAogiBCKIA2AChBKF6Du/5CdhyDu/5A9jPcIAAjDiaDwAG +0cDgfiMIUQDODSAFANgLyAQggA/+//8DCxoYMAvIh7gLGhgw7vHPcIAA4CIEgCEIngDPcIAAFDAA +gIroNgnv/ZDYDQhRAA4LwAMO8ADanroA2c9woAD8REGg4HghoHoNIAUocM9wgACUHAOAGIgNCBEB +qgpP/YXoMgxAAsLxwvHxwLoLT/fPdaAAwC86hc9ygADILQCCdwgfAIC4AKLPcIAAQMnHgMC+geYB +3sB+DQkeBxCFCQgfAADYA/AB2A94H+4whR8JnwJAFQQQTBUFEAohwA/rcoogTAnZAu/4iiOFBhMI +UQCKIBABEaXeD+AHCtiKIBAAEqXSD+AHBdjPcIAAoCMggGB5yXCdA0/34HjPcYAAXChAgScKUQDP +c4AA0MgEiw0IUQAFi4HgAdgD8gDYgODKIIIPAAAQJwX0z3CAAHQrAoDPc4AAyCsAoykKUQDPcoAA +0MgEig8IUQAFioHgAdgC8gDYgODKIIIPAAAQJwb0z3CAAHQrAYDPcoAA5CsHogkG7/8DgeB44H7g +eM9ygAB0KyCSA4qAuae4ormGuCCy4H8DqvHAkgpP9892gADwBQCGn+gKCm/+VNgzCF4BAd2gps9w +gADIKxYL4AcDgM9xgACUBgCBgbgAoc9wgADMIz4OYAgAgKlwBPAA2ALwAdixAk/3z3KAAHQrIJID +ioC5p7iiuYa4ILLgfwOq8cBaCCAA4cUeCCAACHXmCCAACHNwdcojRQMQc4ECb/fKIMUA8cDhxaHB +AN1AxaYIL/2LcILgiiD/Dwzyz3CAAJg5A4AggADAIniA4MogTANNAm/3ocDgePHAocEA2EDAz3CA +ACjJIYiLcCcJUQDPcaAALCAwgc9ygADkK0iCQnkPDkVwTgAAIIIID/0D8GIID/0RCJEAiiD/D6HA +0cDgfs9wgAC4OQOAIIAAwCJ4gODKICwA8/HgeOHFz3GAAAgbJIEggc9zgAC4OUOD1bmggkaDiiD/ +D4DiBfICgqJ4SCAAAAkgQABquEggAADgf8HFz3GAALg5C4FAgA6BgODKIIEP/////wryAoBCeEgg +AACZIAYASCAAAOB+4HjxwP4IT/ehwQh3z3CgACwgQBASAM9wgAA8y1+AAN1EJwETiOFBKoABGnKG +IP4vSiFAIMIhQiTAuEEvQhPAus92gADkKxYmAxBBo4jhzCAhgAj0AYYE6NIIj/wE8GoIj/zPcIAA +lBwDgBiIDwhRAM9ygQAQDBfwng6P/Tfoz3CAANwfCIhjCNEBz3CAADzLmBCAAM9ygQAQDAK4FngA +YksIXgPPcIAAPMuYEIEAEmkWeBpiKw8eEwCCiLgAogHYD6rPcIAAlBwBgMAQAAYRIECAzCGig4gI +AggH8JIIIAivqoDggAgCCM9wgACQBiCAh+HMISKgQvJKcH8IECAIponpz3GAANDICoEB4AqhJvBG +FoAQRQhRAM9w7f6+ukDAz3CAAPAFAICA4MogAQfKISEByiKBDwAAfQDKI2EPJAzhBMAr4QVGHkIT +RR5CExoOb/9HHkIThgqP+QeGJoZCcAIgQgAJCt8HBqZMFoAQDQhRAEweQhMC8ACm4Qcv96HA4Hjx +wIoPD/cIds9woAAsIPCAHQ7yEQDdCiHAD+tyiiANAoojCQOYdeEGr/i4czcJkAH2Do//z3CAAOQr +6KDPcIAAkAYAgIDgzCDigQnyz3CAAFwoAYCA4NQJgfnPcIAAdCupoM9wgADIK89xgABcKCCB8CCA +A/hgDwlRAM9xgAB0K6mhz3OAAOQrJYMCIEIACQrfBwWjXQcP9/HA4cUIdQTZz3CgAMgcKKAiCK/3 +FtjPcaAAwC8TgYDlzyDiAtAg4QIToYDlPNoG9M9wgABIEkCQz3CAAEgSAZAQuEV4wBkAACEHD/fP +cqAALCBQgiJ6z3GAALAGFXkAgRcIhQDPcIAAlBwAgMQQAAYHCF4BQKHgfvHAfg4P9wDez3CgALQP +vIAKCCAFyXDPcoAAHIsEks9xoADsJxC4hSCEAAahBZIQuIUgjQAGoQeCz3OnABRIB6MIghCjA4LP +c6QAuD2bGxgABIKmGxgABYKSGxgABoKjGxgAz3CkAOz/xqCKIIoABqGqD+AEr3jPcIAA4CIEgFEg +gIBsCKIGyiBiAGEGD/fgeOB+4HjgfuB48cDiDQ/3z3GnABRIAN2ooQeBz3aAAByLB6YQgc9ypwA0 +RAimp6HPcPMP//wQoaDYtqGauPUaGADPcaQAuD2bEQAGz3eAAAAbA6amEQAGBKaSEQAGBaajEQAG +Bqb/2JsZWAOmGRgAkhkYAKMZGADPcaQA7P/PcAAA//+noQahAIcB4ACnFQhRAAHZz3CgAMgcMaDm +CeAHKHAE2D4ML/hAJgESDdgyDC/4QCaBEs9wKAACAc9xoADsJwahiiCNAAahAIdCIECAAKcF9M9w +oADIHLGgeQUP9+B48cAKDQ/3USDAgQ0SDzbPc4AA7MkDEg02z3GAAPzK9HsRixAThAAS8gHgCHIy +FYUQZ5ECGQIBz3ZBAIMAZrHPc4AA+DQDqRHwQCRCADEVhRBCqcATAwEDqc92IQCCAGaxz3OAAPw0 +Ew2FAMShAIMB4ACjBIFT8M9zgAAMyutjAePBhWSpANpwjXcOHhEvJQgA739JJ8QQ8mvPcIEAEAz2 +f+Bg0o0RCJ4Fz3CBAFAOdngBiAPwSHAAJI8PgQBQDnZ/5I8IJs4TCCYAEKBwSSDOAxZr1XjPdoEA +0A8AZs92gQBQD3Z+YYbPdoAAlBzEhtiGxXsEI4MPAAAACGZ4AvADhQKhmBWAEGiJDQsAAESpYNgY +uATwANiduAShWQQP9+B48cDhxQPIpBAAAFEgAIDPcIAAlBwEgATyG5AD8BqQbgiABrvoz3CgABQE +A9kjoCDYDBocMM9xgACAMxaBAeAWoQPIANqYEAEApBADAJQYQACeEAEBrLuSGEQAvhABAa27gBAN +AaQYwACQGEQAfhABAYAYhAA9ZbAQAQGieTB5sBhEAIIQAQF+GIQAhiPlj7IYRABYC0L9zQMP9+B4 +8cBOCy/3CHMQiTMRjQAB2kCrDRIPNs92gAAUyu5mz3KAAETKSNzBqw0SDzYCIg4D9CbOE8GzDRIO +NvAiggNBo0GBIwoeAdKJz3KBAFAOFnrcq0CKhiJ/DFx6BLpFftyrA/CA2lyrBLgFfb2rHJHPcoAA +jMoPsw3I8CIAAASzB8gFo1QRAAEMswCRDbOgEYIASKMGyAQggA8CAEEADQiBDwIAAACIukijBsiG +IL6PBPKJukijnBEAAc9zgAB8Oia4wLhAKAIDD4HAuA24RXjpAi/3AKPxwHIKL/cc2hpwz3CAAEIH +AIjPdoAAZDoKIYAvgAA00IQoHwAghgAhRC7PdYAAOM1AoQAlQR4AJUIeKIFAIgMHACVAHk8hTwPo +ogKIYaYNCF4Ag7mNuSiiz3CAAMQHAqMY2AKmz3CAAGAHAIAMHgARz3GAAEgHDgqv+iCBANnPcqAA +LCBQgmGGCwhyAEqjWGAKo89wgABCBwAQhwCELx8AJ3VCjS9wsQpfABkIESDPcYAAcNAbYc9wgABU +B2CgSvDPcoAAVAdAgkGKRCi+KMdwgABUzRfgQCKEADIgQg4vJAcBz3CAAFgHAuJPegAQhQBBCnIA +AiWDAIQvHwAvcAAhTw4AJ4YfgABUzUQovihAJo8FMidPHjtjx3OAACzQCOMbYwHhL3ngq9EJooAC +JYMAhC8fAAAhQC4bY89wgABUB2CgDpUCIAABDrUOlVhgDrVlpgfwz3GAAEzQOGAFpg6VcQEv9wSm +4HjxwOHFCHUGjSWNCLgFeS94KLkveQi4p7msuKy5JXgPeSi4CLkleAWtKLgGrQDZKHBhHQIQKLhi +HQIQKHAHrSi4CK1AJUAU0gjv+CDaQCVAHADZxgjv+BDaqXBB4ADZugjv+AjaqXBR4ADZrgjv+BDa +z3CAAKQGYIBBKwEEL3kIuUErAgZFeW96KLsIum97ZXoQukV5Ka0ouSqtKLkrrSi5AYAsrUEoAQQv +eUEoAgYIuUV5D3oouA94CLpFeBC4JXgNrSi4Dq0ouA+tKLgQrV/YCLi5AC/3AbXxwDYIL/cA2c93 +gACkBmWXIwtyAIIkAjjPdYAAJJHPcoAAIHoqYjxlAeEvefMJ4oBArESXIQpyAADdz3OAAASRz3GA +AAB6qWG8YwHlr331DaKQIKxukLDjIgElAADei3IeC+AHyXGBxZTBQCUAFyoOIAUQ2kAlABfJccYP +r/gQ2gIUADGLclYkBDMPeSi4CLkleGRob3vPcIAABJFmCu/8KI9KJAB0yXCoIIADACQCMAAkATBg +EYEAUBKCAL8KQQAB4A94Io0BjQi5JXgPfii4D3gIvgV+BZecwUAgEARAJcASLyAHJLINIAUQ2lYk +ATTPcIAAJJGiDSAFRZecwozAyXEaDKABCnP7jc9wgAAYBs9xgABAEmCB6GADuBV4EGPCuF8IUQHP +eCMIEwROIDwEqCBAAwIggQMAJAIwg3EwEYEAAeAPeDAaQgAAJ40fgQD4EySNBdgDuTV5O2MAsySN +z3CAAEASQICMwAO5NXkQ4llhJg0gBRDaJ/AA2D3wACeNH4EA+BMkjQHYA7k1eTtjALMkjc9wgABA +EkCAjMADuTV5E+JZYfIMIAXJcs9wgABAEiCARI0TDlETA7pVelBhWWGMuACxRI3PcIAAQBIggAi/ +A7pVelBhWWHleACxRI3PcIAAQBIggAO6VXpQYVlhg7gAsQHYpQbv9oAkAjjgePHAEgggAALY/gkA +ANHA4H7xwCYOz/bPd4AAlBwVJxAQABAOIAh1FJYLCFIBiOAC2ML2ANgapkokAHIA2aggQA3PcIAA +FE30IEIAz3CAAPiuNHhAsM9wgAAkT/QgQgDPcIAAKK80eECwz3CAACRN9CBCAM9wgAAIrzR4QLDP +cIAANE/0IEIAz3CAAFCvNHhAsM9wgAAMT/QgQgDPcIAAGK80eAHhQLAIhuW4BNnKISEANKYRCB4B +CdlGHkQQLtoG8BTZRh5EEDLaW7ZZjllhMHlGHkQQGuE6thUIHgAK2FQeBBAG2FYeBBAH2AnwENhU +HgQQANhWHgQQBdgPplYPYAOpcDyOKHBEHkIQhiADAOa5WB4CEMoiQQAL8lAhwwFvekQewhBQIMMB +b3hYHsIQEwleAUhzhiMDAG96RB7CEA0JHgGluFgeAhALCd4ApLpEHoIQLw2QEGILr/mpcAAQACC5 +EAAGUSBAgPHYwCgiAcoggQ8AAJMAwCghAYQeABAY2I24E6YIhg8I3gC2F4AQibgD8J0XgBASps9w +oACsLxmAz3GAAOAiMLjAuO4MYAcFoQiGBCC+jwAGAAAA3wryNrjAuBt4AeBaHgQQAtgapgTwWh7E +EwDYF6YYpmINb/2pcCiGAdpIc0EpAAU1uVIgAABSIQEAwLjAudYN7/2Ycp0Ez/bgePHANgzv9gfY +z3agAMgfSB4YkM93gACUHCOHz3WsANQBGoFMHhiQguAC2MogIgDQHQCQiiAEAA+mRhEAAbAeABBG +EQABtB4AEB/YCLgOpgiBUSAAgADYi7gK8hCmMg9P+c9woACkMAGAhLgK8BGmJg9P+c9woACkMAGA +pLjPcaAApDABoc9wgAC4OgCAFQgeAIYg/w4iuBS4z3GAAGAFC6HuCU/5UglAAX4OQAP+DkADz3AA +AFVVWh4YkAHZWR5YkM9wpgAoAC+gA4daEAEBz3CmAOgHJqBqCA/9A4caCuAEDZAA2IwdGJAH2I0d +GJAA2IsdGJDPcIAAqCMggGB5BNgN6M9xgABYFBqBO4EkeA8IXgR2CuAAAtgE8JINIAYB2M9yoADE +Jw8SAIZjh0QgAQIbgw8aGIAPEgCGo7gPGhiADxIAhgV5DxpYgDyDz3CgADAQJKDPcIAAPMsQeI8a +GIDPcIAAJJLPcYAAJKIQeBC5JXiQGhiAiiAEAJIaGIAdg0AaAIDPcIAA1BtTGhiADxIAhp+4DxoY +gADYEBoAgB6DHBoYgPkCz/bxwH4Kz/ZukAh34+OYJEEzGnGT9wDZvg2gB4tygcYijgGOCLkleA96 +KLgIug95BSGRAA0I3gChAyAAANgJCBEg9wifgVEhwKHRISKi0SFiovPzCwgQIOMJHqNeFoEQXRaA +EAi5JXgPeSi4D3gIuQUgUgAmjgWOCLkleCeOELkleCiOGLkleEEoAQQveUEoAgYIuUV5D3oouA94 +CLpFeBC4So4FeQmOCLpFeEuOELpFeEyOGLpFeEEoAgRPekEoAwYIumV6D3souA94CLtleBC4BXrP +c4AApAYBg18KJIBTIYQgDQoBAACDTwkEgCCjQaPPc4AAcHwgszC5IbNCszC6TCRAgEOzn8XA9Mlw +TeBWJYES2g/gBBDayXBN4ADZdgmv+BDai3AhkItyL3gIuCi5JXhkaG97z3CAAASRENkaDK/8ViUE +EkokAHQA2KggAAMaZRllQBGBAFASggAwcm31AeAPeOlwANmLcmoMoAdul0AmQBtWJYETcg/gBBDa +ViTTN89wgAAkkUAjASFeD+AEENqXCBAgViWAEyDZiiIEAItzY+PiDWABCiSABItwY+BAIwElNg/g +BEpyMiSAPwAADAGMIEOHOfUyJIA/AAANAUIgkgEyJIA/AAAOAYDgLyKIJCv1MiSAPwAADwGP4CX1 +MiSAPwAAEAGMIAKLHfUyJIA/AAARAYHgF/UyJII/AAASAUAjACdAJQEYUyJQAM4O4ARKchfwViWA +EyDZiiIEAItzY+NSDWABCiSABItwY+BAJQEYpg7gBEpyRCEALEIoEAFAJQAYCnHJcg0KEShaCg/9 +BPCOCQ/9Fg+v/4twz3CAAASRENmLcmPb3gqv/FYlBBNWJQATmfDJcE3gVSVBFVoO4AQQ2slwTeAA +2fYPb/gQ2otwIZCLci94CLgouSV4ZGhve89wgAAEkRDZvguv/FYlBBJKJAB0ANioIIADGmUZZUAR +gQBUEoIAMHJaBcL/AeAPeOlwANmLcuoKoAdul4tyz3OAACSRY+JzCBAgQirBIFYk0TdocGG5Mguv ++Cpz+BSAMIwgQ4ceBcL/+RSBMPoUgDCA4EIhkgEOBeL/LyKIJPsUgDCP4P4Ewv/8FIAwjCACi/IE +wv/9FIAwgeDqBML//hSAMEAlARhTIFAAQCEAIooN4ARKcg3wQirBIGhwYbnKCq/4QCUDGEQhACxC +KBABQCUAGApxyXINChEoKgkP/QTwXggP/eYNr/+LcM9wgAAEkRDZi3Jj29IKr/xWJUQTViVAE8lx +TeEyDeAEENqSDKAH6XAgkItw1gxv+IYh/Q8B2AEHr/aVJEEz4H7gePHAz3CAAPSKGBAEAAohwA/r +cs9wAADlDt7bEQYv+EolAADgeM9xgAD0igWB4H8GofHAeg6v9gK4FXgAII0PgAAkrgiVUyAQAM9w +gAAomNeIju7PcYAA+JALiYYg/4wE8sCJBvDPcIAAtLvBgLoNoAPJcM9ygAA8y1YSAQHPc4AAistA +IQQLz3GAAEIH4InPcYAAQs2ELx8QNCFBDoYhfww8eRQjQQCMIP+PYIkCJMEADfIA2xEOtRMPIwMA +CZVleAm1BfAFhWV4BaUNCBAgB5URCQUAJ7UjggSCIaUCpca1LQaP9oDg8cA02Af0Tg2P/VAgQQQF +8EYNj/1PIEEEfg2v/TTY0cDgfoDg8cD02Aj0Kg2P/VAgAQD02AfwHg2P/Qhx9NiAuVYNj/3RwOB+ +4HjPcIEArBsggM9wgADEmwTpIIAD8CKAz3CgACwgEIA4YM9xgAAcB+B/AqHgePHAUg2P9s9ygAC8 +MGKSz3WAAOQ/QIWkwUDCQpXYEQQAz3WAAPBABByEMECFQsJClQwchDC0gFyBCwpkA9hyAiJGA1OA +t4FQdcIlhhDPcoAAdDEGEgUByBEOAP/aCLpEfii+AByEM8wRDgBEfii+AhyEM9ARDgBKJMBwxHoo +ugQchDDsEQIACByEMPARAgD0EQEAChyEMAwcRDAA2kh2qCDAAwPZFQmOAxQkgTPgkQgiwgMkkQkj +QwAB5gAlgREFKYEPAwAAIC9xBS0+AQ0JRQ6MEAEAAeED8ADZsICMGEAAVSDOBVMlwRAUJkEQQLFc +EAIBSiQAdADfqCAAAvQmwRMwcsoiSwAB51UgwQeQGIQAwr0UIU0DYLV8EAMBSiQAcgDaqCAAAvQh +jQAII0MDAeIG43B7khjEAIEEr/akwOB48cASDK/2mHBvfwO/pG/PcIAAvDC2YKJvtWAG5/BgEQtR +AuqRjCcCmMogawAVClEAdHlBkR1lIwpCAwJ6QbEK8BcKkQB0eUGRWGAPDgIQAbEB2ZgcQgAlBI/2 +4HjxwLYLr/YA2c9wgAAomFUgRAdoEAABgODPcIAAKJhW8moQAgE9ClIAz3OAABwHAYPPdYAAoFbw +JE4AUybPFdd3rAAAD8wngp/yAABQDPQ4vsK+AeEvec5l3wmigMV4AaMA2QTwAaMB2YEJEQDPcIAA +KJhsEA0BdQ1yEADaz3OAABwHz3CAAKyY8CCAAFMgzgXXdqwAAA/MJoKf8gAAUAn0OLgTCFAAFQiQ +AAHZCfAB2RzwAIOCuATwAIOBuACjAeJPesMKQoMS8AWQz3KAABwHIIJRIACBAYKAucUgogTPICEA +AaIgogDZ3QkRAM93gADEmxWH0Qh0AADeM241eQAnRBBZFIQA+WHPcIAAKJhEEIAAcm51e891gAAk +rnplSJJ9ZQsIAQGDuki1z3OAABwHYYN8EYAACyDAgAbyTyIAARB6CLXPc4AAHAdgg30RgAALIMCA +BfJPIkABEHoItc9wgABCBwCIfhGDAIQoHwDPcIAAOs0yIEAOCyDAgAXyTyKAARB6CLX44gz0z3CA +AHCYXOECCm/4iHJIlYTogrpItfziDfSWC+//yXAIlQHZgLgItc9wgQCsGyioAeYVh89+Ow4EkM9w +gAAomJUQgAAI6M9wgADEmwOACQifAADYA/AB2C8mB/CF8soPr/0A389wgADEmxWAgOD2AA4AAN5q +8BNuFXjPcoAAtJgZYi2JACIFABNvFXgAIIIPgADEm1kShgAAIIIPgADEmxJvFXjPdYAAJK4bZWiT +HWULCYEBg7totc9xgQDEG9Z5fBKAAAQRBAALIACBBvJPIwABEHsItX0SgAAggQsgQIAG8k8jQAEQ +ewi1z3CAAEIHAIh+EoEAhCgfAM9wgAA6zTIgQA4LIECABvJPI4ABEHsItfjjGPRAJQAEVSLBBeoI +b/jIcpDoCJWCuAi1hgrv/+lwCJUB2YC4CLXPcIEArBsoqAHmz37PcIAAKJiVEIAAKQ4CkAHnz3CA +AMSbFYDvfxUPBJDPcIAAHAeWCG/4CNnPcIEAxBuKCG/4gNnPcIAAxJt1gCcLdAAA2c9ygAAkrrJp +tX24YgiQXWUB4S95hiABD+8J5IAIte0Aj/bgePHAfgiP9nSAXIHYEQ0AcHLCIsYA94EzgDB3widG +EALbz3GAAHQx9CHEAAYRBQEA2S6g+mIFKoIPAwAAIC9xBSx+Aw0JZXCMEA4AbqAFLX4DGwlFDpAQ +AQGUEAIBAuELCYIA5ObD9wHZLqB9AI/24HjhxeHGdIBcgdgRDgACIsQAU4A3gTwQBwCMEAgAAiGF +AM9xgAB0MQLa9CGKAAYRCQHPdYAAvDBClWGVChEGAZIQAQGjlQgjQwAAJQEBBSmBDwMAACAKJEAO +BSq+Ey0JBXEqkIwhAojS9gLZL6CQEAEBfmWUGEQAIZBnDkMQonkhsAHZmBhCAC3wBSm+Ey0MRQ4p +D5AAkBABAZQQDgEC4Q0JggOMIAGZyvfBkAHZ3WUzCmIDL6ChsOfxGw+RAKGQACbBABMJQwMCJY0R +obAB2ZgYQgCQEAEBlBhEAADZL6AJIsIAIZANCkIAQbAB2ZgYQgDBxuB/wcXgeCJoANpAsEokwHXP +cIAAvDCoIIACFiCDAGCTFCGMAAHiT3pgtOB+4HjxwO4OT/ZygMiB2BECAHB2wibGEHGAI4FwccIh +xgAA389zgAB0MfQjxAMB3dlhBSmBDwMAACAvcQUsvgD0I0MDDQllcO2gAtktoAfwBSu+AAcJRQ6t +oAEHT/bgeEiBUqBDgVGgXIFUoDeB4H8zoOB48cCCDm/2AtsIdSh2AdgAsalwXgrv/02FTYWpcMlx +Ugrv/wPbTYWpcMlxRgrv/wXbTYWpcMlxOgrv/wbbToWpcMlxLgrv/wnbToWpcMlxIgrv/wTbmQZP +9s9woAAsIBCAz3KAANDIBaLPcIAABJgIgADbGQjeAQSKCwhRACWKCQlQAAHbIIII6wCCgeDMICKA +EvIP8BDpDwhRAAWKgeAB2ALyANiA4BgBwvgNCVAAAtjgfwCi4H7gePHAyg1P9s92gAAAGwCGAeAA +pgDdFQhRAAHZz3CgAMgcMaA6CiAHKHDPcIAAxAYgkIa5ELkFIYIPAADCEs9xoADsJ0ahAZAQuAUg +gA8AAAITBqEAhkIgQIAApgb0z3CgAMgcsaDRBU/28cBiDU/2z3CAADglGYAA3YHgyiHCD8oiwgfK +IIIPAACoE8ojgg8AAJAByiRCA6wE4vfKJUIDz3aAAAAbAIYB4ACmFwhRAAHZz3CgAMgcMaCiCSAH +KHDPcIAAxAYjkASQwrnCuAO4JXgQuIUgjQDPcaAA7CcGoQCGQiBAgACmBvTPcKAAyByxoEUFT/bx +wNYMT/bPdoAAABsAhgHgAKYA3RUIUQAB2c9woADIHDGgRgkgByhwz3KAAHgmAIrPcaAA7CcQuAUg +gA8AAMJpBqEBihC4BSCADwAAAmoGoQCGQiBAgACmBfTPcKAAyByxoOEET/bgePHAZgxP9gogAKDP +dYAAZDwAFQQQKvLPcKQAuD0A2jcMEQCbEAMGz3GAAGg8YKGmEAMGz3GAAGw8YKGSEAMGz3GAAFw8 +YKGjEAMGz3GAAGA8YKGbGJgA/9mmGFgAkhhYAKMYWAAB2DXwTCQAgMohwQ/KIsEHyiCBDwAAfhnK +I4EPAAD8AmAD4ffKJQEEz3CAAGg8IIDPcKQAuD2bGFgAz3GAAGw8IIGmGFgAz3GAAFw8IIGSGFgA +z3GAAGA8IIGjGFgAz3CAAOAiBIAiuMC4Pg0ABPkDb/YAHQAU4HjxwIYLb/YA2M91gACoIyCFQHkn +CBEDz3aAALAjIIZgeQLYi+gghmB5A9iH6O4Kb/1Q2AsIngEA2ALwAdgvIQcgz3CAAKguz3eAAMQj +Eg+v+QCnz3GAAPQ0FIEB4BShz3GAAAAbAIEB4AChFQhRAAHYz3GgAMgcEaGqD8AGz3GAALQlBIEr +CFEAJoHPdqAA7CdgeQDYz3CAALS7GIiX6M9wAQAGAQamz3ASAAYEFvAKIcAP63LPcAAAhxmKI8UJ +SiQAAEkC7/cKJQABz3ABAAcBBqbPcBIABwQGps9wgAC0uyCAA4Ar6eCHRCi+A8bYkrgGpiCFJ3dg +eQDYcwgQAyCFYHkA2GcIEAQghWB5ANhfCFAEIIVgeQDYUwiQBM9wOQACMwamz3A5AIJMBqbPcDkA +AmYGpsfYlbgY8EQovgMAIY9/gACwT8fYkrgGps9wAAACMwamz3AAAIJMBqbPcAAAAmYGpsbYlbgG +ptYPD/7PcIAAtLsYiM9xgAC0uyoNIAQggS8JECDPcAAAAm4Gps9wwQBCbgamz3ADAMJuBqbPcDYA +QpcGps9wAgBCawamz3AQAIdyBqYFjxC4BSCADwAAQnAGpgSPELgFIIAPAACCcAamA48QuAUggA8A +AMJwBqYCjxC4BSCADwAAAnEGpgmPELgFIIAPAABCcQamCI8QuAUggA8AAIJxBqYHjxC4BSCADwAA +wnEGpgaPELgFIIAPAAACcgamAY8QuAUggA8AAEJyBqYLjxC4BSCADwAAgnMGpgqPELgFIIAPAADC +cwamIIVgeQDYJQgQAyCFYHkA2BkIEAQghWB5ANgRCFAEIIVgeQDYEwiRBAyPELgFIIAPAADCfwam +z3ABAEZqBqbPd6AAyB+kFxAQFQkQIM9wUADGcwamz3AgAMdzHfAghWB5ANg1CBADIIVgeQDYKQgQ +BCCFYHkA2CEIUAQghWB5ANgVCJAEz3CAAAZ0BqbPcIAAB3QGps9wgADGcwamz3BAAEJ0BqbPcIAA +x3MGps9wAgBGagamz3AQAMZqBqbPcIAAtLtYiM9xgAC0uwCIJImA4gHawHrPc4AAtLv+DmAGeYsk +2BjZDg3gBjPaLwhQAM9wgAD0NFAQBADPcIAAtLsMEAUACiHAD+tyz3AAAIoZrQev94ojBwcPCRAg +z3AGAEJrBqbPcBAAx2oGps9wEACGcgamDwkQIM9wAgBGagamogyABsYLgAYk2AHZqgzgBjPaLQhQ +AM9wgAD0NFAQBADPcIAAtLsMEAUACiHAD+tyz3AAAKooRQev94ojxwykFwAQz3GAAPQ0AiAABBOh +z3ACAEdqBqYghWB5ANgtCBADIIVgeQDYIQgQBCCFYHkA2BkIUAQghWB5ANgNCJAEz3BlAMJuBqbP +cIAAABsAgM9xgAAAG0IgQIAAoQT0ANhRHxiQtQcP9vHASg8P9s9wgAA4JRSAgOCL8j4NL/4H2Hpw +z3CAAMwxDIiGIP8BQ7hhuIbg9AANAM92gAC0uySGz3KAAOS5MyYAcIAAYD5AIhELBLk0eUAiEApA +IhIGQCIPCEAiDQQ6YkAnAXIUeQB5z3GAAOAmSHBV8M9xgAAAJwRqUfDPcYAAICdAIgACS/BAIgAD +z3GAAOAm2gkv/gDaBIbPcYAAACcEuBR4uGA78EAiAAfPcYAA4Ca6CS/+ANoEhs9xgAAgJwS4FHj4 +YCvwQCIABc9xgAAAJ5oJL/4A2gSGz3GAACAnBLgUeEJwG/BAIgAJz3GAAOAmegkv/gDaBIbPcYAA +ACcEuBR4AnBmCS/+ANoEhs9xgAAgJwS4FHgicFIJL/4B2joJL/5qcH0GD/bgePHAz3CAADglD4AR +6M9wgAC0uwSAz3GAADS7ArgUeDhgz3GAAEAnYg0P/tHA4H7gePHAAg4v9kTaz3CAAGxPz3GAAJjJ +RgxgBADeAt0WCCAAyXBhvfkNdZAB5kUGD/bgePHAyg0v9gDaz3GAAJQcFXlggQS4ACCQD4AA7Ey5 +G5gAAIEEEA8gz3aAAGxPvhjYA6CBQoaKIAcPYYYdZfAdgBDsHcAQIIFGhs91gACYyWWGOGD4GIAA +FibBE/QYwAAWJcATBOAE4S4OL/YI2gwQACAWfhZ9BG0kbhoOL/YI2rEFD/bgePHARg0v9hLZqcEI +du4JYAaLcEokAHEA2qgggAIWJIAwKIgLCZIAYbkoqAHiAsIBw891gACUHNV9AIWKIQcP9G7Hd4AA +7Ew4YOwYwADwGIAAAIUGwgXDOGD4GIAAg8H0GMAABBcQEM9wgACYyRYgAAQE4J4NL/YI2uOHz3CA +AJjJh8H2eATgig0v9gjaAMAghbkZGAAghbkRAAYVCB4AvhnYAyCFvxEABoC4CPC+GRgEIIW/EQAG +oLimCq/8vxkYAITolgqP/AToANgD8AHYEHb8D6EGyiCBAwCFuRABBlEhQIDx2cApIgHKIYEPAACT +AMApIQE2Da/6hBhAAK0EL/apwOB48cBKDA/2z3aAAFA8z3WAADwHEukgho3pAKV+D6/4DthuDG/+ +iiAQAAHYAKYO8CCFJXgL8D4Or/gO2DoMb/6KIBAAANgApgClbQQP9vHA7gsP9s9xgACMIwCBoLgA +oUILb/sB2M9wgAC4lwAQBABMJMCAyiHND8oizQfKII0PAACBDMojjQ8AANoAOAOt98ol7QCnDHQA +AN0UbQAggQ+AALiXB5HGkeSRELgFfgWRQ5EQuAV/ApEQukV4GnCCDu/3yXFacM9wgAC0VvAgQQNE +LT4XCiFALgAhgH+AACw3IKCSCu/6CnAIcQAhgC+AACA3Jg/ABAcOxBOY789wgACoVvAgQQNELT4X +L3YAIYB/gADUNyCgXgrv+kpwCHEAJoAfgADIN/IOwATPcIAAuJcAgAHlaQ0EkGEDD/bgeOB+4HjP +cYAA6CPPcIAAtCXgfyKg4H7gePHA9goP9gDez3WAANzJz3CAALAjIIDApWB5AdiD4Mohwg/KIsIH +yiCCDwAAmBnKI4IPAADrAMokYgA0AqL3yiWCAwCFmLgApQDYwa3CrY64AaUCpc92gAC0I0CGBthg +egHZQIYH2GB6AdkBjfUCL/YAreB44H7geOB+4HjxwM9wgAA4OgCAcwhUAc9woACsLxqAUiAAAGMI +HwDPcYAAHIsLgQHgC6HPcIAAnCMAgEB4Lg4AAM9wgACYIwCAQHiaDoAAwgnP/TYPD/zPcKAAeEUA +gAQggA9wAAAAQSg+hff1z3CAAJQcI4BIgTSRUyIAAF4LoAIB2yoMr/gS2NHA4H7xwOHFtMHPdaAA +tEdxFQCWBCCAD3AAAABBKD6F9fWKIP8Pbx0YkGsdGJCWDu/4i3CmDU/8DuhvFQSWaxUFlgohwA/r +cs9wAACxEyUBr/c02/oJz/giC8ADEQIv9rTA4HhAiAHYAKFougK6VXrHcoAAOCVjgmOhYYJhoWKC +YqFkgmSh4H8AouB48cBqCQ/2z3eAADw6BocDgM91gAAciyCASYUAIoAPLQDAxgJ5gQlyAKHBz3aA +AAAbAIYB4ACmFwhRAAHZz3CgAMgcMaC6DaAGKHCLcRIIL/dC2ACGQiBAgACmB/QA2c9woADIHDGg +ABQEMQQkvo8AABf/yiHCD8oiwgfKIIIPAACmE8ojIgxgAKL3yiUiAACFgrjGDCAAAKUiCCAAAdgA +haK4AKUphcdxLQDAxo4M4ATpcCEBL/ahwPHAiggP9q/Bz3GAAPQ/AIFKJAAgTcAEic93gACUHG7A +A4cIgFMgFwA3FIAwQMAuwEHANhSAMELAz3CAAFgUOoAbgCR4MbjPcaAAtEdHEQGGwLiA4cwgIoA+ +BAEAz3CAAByLABAEAFEkQIDKIcEPyiLBB8oggQ8AAKoTyiOBDwAAWgCsB2H3yiUBBc9wgABMBiCQ +z3CAAByLIrAA2Z65z3CgALRHUxhYgOB4UxgYhSYKz/7PdoAAABsAhgHgAKYVCFEAz3GgAMgcAdgR +oXoMgAYtwM91oADsJxC4BSCADwAAQi0GpUAkgTy+Du/2QtjPcAgAhxAGpQCGQiBAgACmB/TPcKAA +yBxEGAAFz3CAAKSyFiDABSSAAIAKucm4BCGBDw8AAPwFec9wpwAUSC2gmg+P/UPAFw8QIIoh/w/P +cKAAtEdvGFiAaxhYgAHYz3GgALRHYBkYgAOHMiCADwAA2AKA4AHYwHgPuJC4m7ifuF8ZGIAAhgHg +AKYTCFEAz3GgAMgcAdgRocILgAZAJIE+Gg7v9hHYIIZCIUGAB/TPcKAAyBxEGAAFz3CAABwwB4hK +IAAggeAB2MIgAQCA4ETAUAIlAAolACQAwgHAQnhHwM9woAC0R3EQAIYEIIAPcAAAAEEoPoX19c9w +pwAUSFwYAAUvJwcUEwgRIM9wgABHBAalSiEAIAfwSiGAIM9ygABGBEalAeEgphUJUQDPcaAAyBwB +2BGhIguABgW/8H8Qv4G/h7+Mv+alIIZCIUGABvTPcKAAyBxEGAAFSiIAIUp3AeFhvyCmEwlRAM9x +oADIHAHYEaHmCoAGAsEVbyV4EHgQuIUgigAGpelwgCCCDRB4RcAGuIG4l7gGpelwgCBCDxB4RsAG +uIG4l7gGpc9wAAACLwalz3AAAMIwBqUAhkIgQIAApgf0z3CgAMgcRBgABYjAicGKwovDRgqgBEAk +BDwswIjoz3GAAEQ1EIkB4A94EKkdCFEgGQ8QIK4JT/wRCFEAMBwCNU8lACAvJQcgz3GAAKSyFiHB +BTARGQAIws9wgABUixYg1gMJwPAegCD0HgAgB8CIInwALyMAIAQrviAvcIoP7/oogQ4gmA8AAAAB +CcCIIHwABCj+BC9wcg/v+itxDiCBDwAAAAEJIIM/AAD/AQkhgg8AAP8BSCMDAEgiAgAswFQe2CBV +HpggIQhRAAwUBDBAKQAhQCyBAThg9XjHcIAA4LJisEOwAIYB4ACmFQhRAM9xoADIHAHYEaGaCYAG +A8FAKQAhBrk4YPV4x3CAAOCyIpA8egXBELoGuYG5RXkmpQOQBsEceAa5gbkQuAV5JqUghkIhQYAG +9M9woADIHEQYAAVCIlIgTCIAoFIGzf8EwEAgUCAScL4Fxv86FAAxUSDAgcoggg+AAEYEyiCBD4AA +RwQGpQHhIKYVCVEAz3GgAMgcAdgRoQ4JgAYyFAAxELiBuIe4jLgGpQCGQiBAgACmB/TPcKAAyBxE +GAAF3g2P/s9woAC0R3EQAIYEIIAPcAAAAEEoPoX19ZIMj/jPcIAAHIsMgM9xgAAci6JwDKENgQHg +DaE1BO/1r8AA2c9wgAA4iyyoLajgfy6o4H7geIC4z3GgAOwnBqHgfs9wgAAHIc9xoADsJwahz3CA +AEc6BqHPcIAAx1MGoc9wgADHJAahz3CAAAc+BqHPcIAAh1cGoUnZz3CnAIhJMKDgfuB4AdnPcKAA +yBwwoEvZz3CkABxAJKDgfuB4z3EBACQ+z3CAAKAj4H8goM9xgAAciwCBgLjgfwCh4HjxwH4L7/W4 +cFMggQDPcIAANFYoYIHgyiHCD8oiwgfKIIIPAACVGcokgg8AAP4AyAJi98oj4gfPdoAAsCMghmB5 +AdgnCNAAIIbrdWB5Adi4cM9wAACWGQohwA+pciLbmQJv94okgw+FA+/1AdgJ2eB/IKDgePHA4cXP +dYAAsCMghWB5AtiA4CCFCNgI9EB5EHnPcIAAzAkH8EB5EHnPcIAAtApSCs/2agygAwHYfgjP/UIP +AAAqCAAAOQPP9QhxWIkBgAKhiOpZiYDiwiCiAMAgoQACoeB+4HjgfuB48cCeCs/1z3aAAAAbAIYB +4ACmAN8VCFEAAdnPcKAAyBwxoBIPYAYocMfYlLjPdaAA7CcGpc9wAwCCbAalz3ADAMJ0BqXPcAMA +QpYGpcbYkLgGpeIOYAYK2M9wAACCbAal0g5gBgrYz3AAAMJ0BqXGDmAGCtjPcAUAQpYGpbYOYAaK +IAcNz3AAAEKWBqWmDmAGCtjPcBMAxgAGpZoOYAYy2ACGQiBAgACmBfTPcKAAyBzxoFUCz/XgePHA +5gnP9c9yoACsLzWCAN8PCR4AAdvPcaAA7CdmoYjoz3CAAJwjAIBAeErwFYJRIACAyiHBD8oiwQfK +IIEPAAB/GcojgQ8AAKoAyiTBABQBYffKJcEAz3ATAMcAz3WgAOwnBqXPcBAABmkGpcfYlbgGpc92 +gAAAGwCGAeAAphcIUQAB2c9woADIHDGg7g1gBihwz3AAAEItBqXPcAAAgkYGpc9wAABCYAalAIZC +IECAAKYG9M9woADIHPGgkQHP9fHAKgnP9c9wgACoIyCAocFgeQTYMujPdoAAABsAhgDdAeAAHEQz +AKYVCFEAAdnPcKAAyBwxoIYNYAYocItx3g+v9gDYAIZCIECAAKYF9M9woADIHLGgABQBMc91gAC0 +I4Yh/wxAhUK5YHoC2AAUATFAhQPYYHrBuR0B7/WhwOB48cCiCO/1A9jPdoAAqCMghs91gAB0L2B5 +osEG6CCGYHkE2IboRwMgAEgVBBAD2Bpwz3enABRIz3agAOwnXg6v/QXYDqXPcIAAABsAgAHgz3GA +AAAbAKEXCFEAAdnPcKAAyBwxoNYMYAYocAPYLg+v9qlxBNgmD6/2Im0F2B4Pr/YkbQrYFg+v9iZt +D9gOD6/2QCUBEjbYBg+v9kAlgRI32PoOr/ZAJQETONjyDq/2QCWBEwiHBKUNhwWlDocGpc9wpwCY +RxyAB6UXhwilFocJpc9wqwCg/xiAC6XPcKsAoP8ZgAylz3CrAKD/GoANpc9wAwDGAwamxtiQuAam +z3AsAAIBBqbPcFkAQgEGpoogigAGps9wQACHDQamz3DRAMINBqbPcMAABw4Gps9wgAAAGyCAEQlR +AM9yoADIHADYEaIB2AinANgNpw6nz3CnAJhHz3JQAP8AXKAA2BenFqf82s9wqwCg/1igfNpZoBqA +z3KrAKD/gLgaos9wgAAAGyCgEwlRAM9xoADIHAHYEaGuC0AGz3BAAIYNBqbPcBAAAg4GpotwIgxg +BIHBNoUAwCJ4BCiADwAAdAkVhTeFAnmmCO/1L3ABwk/gz3GAAMiMFKVXoRihz3BAAIcNBqbPcBEA +Bg4Gps9wgAAAGwCAz3GAAAAbQiBAgAChBvTPcaAAyBwA2BGhi3DCC2AEgcE2hQDAInjiDG/7EqUy +hVWFLHg3hS8gQA5CeTlhOgjv9TV54LgceMAgYgCCIMQCz3GAAMiMEqUTpRahz3CAAAAbAIABwgHg +VaHPcYAAABsAoRMIUQDPcaAAyBwB2BGh0gpABgGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAG +pgSVELiFII8ABqYFlRC4BSCADwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbPcIAA +ABsAgM9xgAAAG0IgQIAAoQb0z3GgAMgcANgRoQSFK4UIpwWFDacGhQ6nCIUXpwmFFqfPcKsAoP84 +oCyFOaAthTqgogiv/Q6FSBUEEIwkgoBE9owkP4EO9h4KYAYK2AoNAARCIEAggOACBc3/SBUEEIwk +goBE9owkP4EN9gohwA/rcs9wAAC0GYojRQzRBC/3uHPPcIAATxMAiAfoz3CAANQvABAEAIhwmQWv +9aLA4HjPcIAAdC/gfxSA4HjPcQEAKFXPcgEAHEx1Bi/6ANjgeOB+4HjxwM9wgACcIwCAQHjPcIAA +mCMAgEB40cDgfuB4ANnPcIAA3AbgfyCg8cDmDI/1z3CAAKgjIIChwWB5BNiB4JH0Cgov/PfYgeCL +9ADYABwEMM93gAAAGwCHAeAApxUIUQAB2c9woADIHDGgOglgBihwi3UA2I4Lr/apcQAUBTGocIYg +/AOMIAOMDfIKIcAP63LPcAAAvhmKIwQB8QMv94okgw/PdoAAtCNAhoYl/A8A2GB6Qi2BAUCGAdhg +egPZAdhCC6/2qXFAhgjYYHoAFAExABQFMUwlAIDKIcIPyiLCB8oggg8AAJoZyiOCDwAAEgGYAyL3 +yiRiAALYCguv9qlxQIYE2GB6ABQBMRLY9gqv9qlxQIYF2GB6ABQBMQAUBTFMJcCAzCUigcohwg/K +IsIHyiCCDwAAnBnKI4IPAAAZAUgDIvfKJGIAAIdCIECAAKcW9M9xoADIHADYEaEQ8M91gAC0I0CF +AdhgegPZQIUE2GB6CHFAhQXYYHoE2fkDr/WhwOB48cCOC4/1z3WAAAAbAIUB4AClAN4VCFEAAdnP +cKAAyBwxoP4PIAYocM9wgAAGIc9xoADsJwahz3CAAEY6BqHPcIAAxlMGoc9wgADGJAahz3CAAAY+ +BqHPcIAAhlcGoQCFQiBAgAClBvTPcKAAyBzRoM9wpwCISdCggQOP9QjZz3CAANzJ4H8joPHABguP +9c92gAAAGwCGAeAApgDdFQhRAAHZz3CgAMgcMaB2DyAGKHDPcAAAwizPcaAA7CcGoc9wAAACRgah +z3AAAMJfBqEAhkIgQIAApgb0z3CgAMgcsaAZA4/18cDSDC/4FtjmDAAEz3GAAJQcAIHEEAAGDwhf +AQGBxBAABg0IXgHCDG/4E9jPcIAAkCMggGB5C9jRwOB+8cCmD+/7iiCIBQ7oUggv/QDYz3CAAKgj +IIBgeQTYgOC8DgL/0cDgfs9wgACUHAOACIDPcYAA3MkJCB4AAYkD8AKJ4H8AqeB48cC4cY3oCiHA +D+tyz3AAAKcZiiPEC4kBL/eKJIMPz3GAANzJIIFMJQCABCGBDwAHAABBKQMGANnKJE1x6CBtA/Ag +RQAEJYIPAQAAwC66ZXoLC4EAAeHRwOB+CiHAD+tyz3AAAKgZiiMEDjUBL/dKJEAA4HjxwOHFAN3P +cIAAFAamCCAAoKDPcKcAFEiooA0Cj/XgePHAocG4cADYQMBTJYAAJwhQAEUIkABPCBABCiHAD+ty +z3AAAKsZiiOKCuEAL/eKJIMPz3CAALAjIIBgeQHYhOAB2cB5z3AAACLSNHjPcYEAExkP8M9wAAAj +0s9xgQAWGQfwz3AAACTSz3GBABkZKdoSuvAiAAAOIIIPAAEAAEDCi3BqD6ADA9qhwNHA4H7gePHA ++giP9QPIlBAAAM92gAAAGwQgkA8BAADAAIZBKJAjAeAApgDdFwhRAAHZz3CgAMgcMaBeDSAGKHDP +cSQABwHPcKAA7CcmoIohhQAmoFMggSArCVAAZQmQAIEJEAEKIcAP63LPcAAAiBmKIwYDiiSDDwkA +L/cKJQAEz3GAAJQcI4EogVEhAIDKIYIPgADHIMohgQ+AAIckJqDPcQQAxzEmoACGQiBAgACmBvTP +cKAAyByxoKkAj/XPcYAAlBwjgSiBUSEAgMohgg+AAAc6yiGBD4AAxz3i8c9xgACUHCOBKIFRIQCA +yiGCD4AAh1PKIYEPgABHV9Lx8cDPcYAAlBwjgS8oAQAogcC5ACGDDwAAItJOIIEHKdgSuPAgwADP +c4AAtLt4i89ygQATGaHBQMCG6wIggA8AAADAQMCLcDR5WWEaDqADA9qhwNHA4H7gePHAsg9v9bhw +z3AsAAYBz3OgAOwnBqPPcqsAoP8aglMljQAA2SUNUBBpDZAQqQ0QEQohwA/rcs9wAACBGYojhQPp +Bu/2iiSDD891gACUHKOFqIXPdgIAggJRJQCQyiWCH4AAxiDKJYEfgACGJKajxqPPdQQAxjGmo891 +SABCAaajz3OnABRIN6OAuBqikQdP9c9xgACUHCOBKIHPdQIAggJRIQCAyiGCD4AABjrKIYEPgADG +PSajpqPPcQQAxjEmo89xSgBCASajAdvPcacAFEh3odzxz3WAAJQco4Wohc92AgCCAlElAJDKJYIf +gACGU8olgR+AAEZXpqPGo891BADGMaajz3VMAEIBu/HxwKIOT/UDyAHdz3anABRIlBAAAKimBCCA +DwEAAMDaDu//Lrj/2Ju4z3KnAJhHHKLPcYAAFAYAgQDfgODKIcIPyiLCB8oggg8AAKwZyiOCDwAA +sgDKJMIDxAXi9solwgP2prqipQZv9aCh4HjxwDIOT/XPcKYAnD8ZgK0IHgDPdoAAIAYAhkaAoBIA +Bi8oAQBOIIEHQSnQABEI1SBIcIAgCgAyIAAEkOgKIcAP63LPcAAArRmKI0sCiiSDD2EF7/YKJQAE +z3WBAAgZQCXAEqoNL/cJ2QDYVgqv/w8gAASA4ADYDyAABAX0LgzP/wPwsg3P/wPIuRCAABt4gLhA +hgqtJoKWIUEDACEABBiIjCDDjwJxBfJhuA94GKkmgqARAAafGRgA0gvP/9kFT/XPcSoAFQDPcIAA +WDrgfyCg8cBeDU/1OnAbfc9wpgCcP2QQEAAtCB8gjg6v9QPYYb2MJf+f8/UKIcAP63LPcAAApChR +2wokQASpBO/2CiUABH0FT/XxwCINT/XPcaAArC86gVIhAQBRIQCAocEA3X/0z3aAAAAbswgQAGIK +j//Pd4AAqCMgh2B5qXATCBADIIdgealwIIZZCBEEAIYB4ACmFQhRAAHZz3CgAMgcMaBeCSAGKHCL +cbYLb/aKIAcFAIZCIECAAKYG9M9woADIHLGgABQFMVcN0AAKIcAP63LPcAAAiRnq2w0E7/aYcwHh +IKYVCVEAAdnPcKAAyBwxoA4JIAYocM9xBgACdc9woADsJyagAIZCIECAAKYJ9M9woADIHLGgA/C2 +CAAAAIYB4ACmFQhRAAHZz3CgAMgcMaDOCCAGKHDPcIAAlBwDgM9xoADsJw6AgLgGoQCGQiBAgACm +BfTPcKAAyByxoHUEb/WhwPHAaggAAM9wgACoIyCAYHkD2IDggA7CA89wgADgIgSAGQieAM9xgACU +HE2BPpFTIgAAMg3gAQHb0cDgfvHA4cXPdYAAbC8AhRsIHwDaCUADMg5P+2oJz/g6Ds//AIWAuACl +HQRP9eB48cDaCO/7iiAEAhHohg6P/8YPz//PcIAAqCMggGB5BNgF6HoIj/8OCAAA0cDgfuB48cBy +C0/1z3WAAGwvAIU5CF8Az3CAAKgjIIBgeQTYFOiKCO/74tgQ6DoJb/0H2MYK4AMIdjYIT/82Di/9 +yXAAhYG4AKWZA0/14H7gePHA4cUIdZhxSHBocQDaDgggAKlzhQNP9fHACgtv9fhwWSQcONhxGXK4 +c4okBHAA2agggAEAJEAwIKgB4QDbiiQEcGhwaHGoIMAFMiTCMAAkzzAdYjInQAAB4dBxuGAPeMoh +JgAyJA0wACQOMAHjoK9ArgDZKwh0EChyAeEveTIkTTBCIEgQACRDMLpiT3oyJI4wACSAMMCr4wh1 +kKCoTCQAgMokDXHoIC0HAeEveTIkQDAAJEMwGmJPejIkjjAAJI0wwKsArTIkQzB4YA94MiQDMAAV +gABneAEdEgCtAm/1ViQcOPHAPgpP9aQQAQAVCR4GthABAc9woACYAz6gnvAAFg1BvLAAFgJBXbAA +Fg5Az6AAFgJBQBiEAAAWAkBRoAAWAkFIGIQARCUCEzUKEAEY23IYxAAAFgNAc6AAFgNBUBjEAAAW +A0FUGMQAEQoRAqlzhiPzD4wjDIAO8hjbFvAQ23IYxAAA389zgAD8yuezENsM8B7bchjEAAAWD0D2 +oAAWD0FcGMQDqXeGJ/0cjCcCkgn0AuNwe3IYxAAAFg9BAvAA32AYxAMJC14AABYPQSh0hCQMkAT0 +ANoi8JnqUSYAkNEhIoIV8tCIqLnPcoEAEAykGEAAAr7WfsJiCwqeB4u5pBhAAADaWqBboObxABYC +QFqgABYCQFugCNp0EA4BvhAPAcJ/Yn9Cf7gQggCYuaQYQADPcaAAmANCf3piUHpyGIQAuhACAfB/ +cBjEA6V6XLA+gbYYRABRAU/18cDmCG/1SiRAdc91gABgFsCFz3OAABwPqCBABmhwMm40eTpgQoIB +5jhgDerPcaAALCAwgSJ613JJawDSAN/D9+KgqubKJiYQ4HgFAW/1wKXxwM9wgACkDQ7ZAdqCCiAA +ANvPcIAA3A0J2QHacgogAEhzz3CAANAMKtkA2mIKIAAA289wgAB4DQvZANpSCiAAAdvRwOB+4Hjx +wATYLgpv+wHZz3CAAAkwAIjPcYAACjAyCyAAIInRwOB+4HjPcIAAcDyFAwAE4HjxwIbo7ggAAADZ +IqDRwOB+8cASCE/14g6P+892gADgBmbYIm4B2gIIr/xIc4voCiHAD+tyz3AAALYU2duKJIEJOfAC +FgURTCUAgMwlgo8AAP//DfQKIcAP63LPcAAAtxTc2zkHr/aKJIEJZ9jJcQHatg9v/EhzjOgKIcAP +63LPcAAAuBTf24okwQkV8AGWJG4B2gHgEHiSD2/8SHOhlo/oCiHAD+tyz3AAALkU4ttAJUQQ6Qav +9kolAAACbRB4Jm4B2mYPb/xIc4zoCiHAD+tyoZbPcAAAuhTl20AlhBDr8a0HD/XPcaAAYB0SsRSR +4H7xwLhxNQhRAAkNUgAZDdIDCiHAD+typ9gFuJzbjQav9kokAABALYAAFHhCIAEDz3CAADwOGWEf +8M9wgABMEjIgQAGMIMOPyiHBD8oiwQfKIIEPAADhFMojgQ8AAKIATAah9sokIQACuBR4ACCBD4AA +HA8ocNHA4H4RCB4CBCC+jwAAABgB2AP0ANjgfwCp4HjxwKIOD/XPdYAATgYAjc92gABMBl4P7/8g +jkGIz3GAABAwXwrfAAKAqehfCh4Bz3KAAMAfAJZnik8IwQAAlWGKRwjBAM9wgABQBgCIRoo7CgEA +z3CAAJQcDoAvCF4Bz3CAAAwwQIAL6s9woAAsIBCAQngPCIQPMQEALQDYAvAB2I0GL/UAqc9wgAAE +GwCId+j38eB48cDyDQ/1ocEacDpyaHa9CXIAANiacRUgDSDPcYAA4AYAFZMQAhWSELpw440hkQGN +Ado4YBB4i3HaDW/8SHMS6AAUADFAKoIgBCCBDwAAAP9HuVR6MwkQIMdygAA8Dhjwz3CAAOAGwZCh +jQohwA/rcs9wAAC7FIojhAAAJkQTCQWv9golQAXHcoAAHA8AGsIEA+4CqgLwAaolCB4ADO4DioC4 +A6oSbxR4G2Jji1hggbtjqOSqA+4mqgLwJapCJEEgVQl1gEAlQCB5BS/1ocDgeOHFUyANAKCpBCCB +DwAGAABCIQGABCCAD0AAAADKIWIAIKrXcEAAAAAB2MB4AKvgf8HF4HjxwIzo1g3P/89xoAAsIDCB +x3FJawDSIqDRwOB+8cDuDC/12HEKJoCQiHXMIyKABvJCJgYBLyaHAaIN7//Icc9xgAB4BgChJe4k +iAK5NHlDiAPhAhCFACMKHwAKIcAP63LPcAAA4hSKI4gFSiQAABUEr/YKJYABCGEbCF8ACiHAD+ty +z3AAAOMUiiOIBu/xARCFAFElAIDKIcEPyiCBDwAA5BTKI4EPAAAoAsoiwQff8+G90SUigcohwg/K +IsIHyiCCDwAA5RTKI4IPAAAvArQDovbKJIIBKw0eEFElwIDKIcEPyiLBB8oggQ8AAOYUyiOBDwAA +NgKMA6H2yiSBAXkED/XgePHA+gsP9aHBCHcodRpyAN7PcKAAtA9wEBEAig3gAslwi3FAJEIwQCSD +MKIO7/+pcA8IECDPcIAAZJYBiAToSiQAAATwSiSAACDAARSCMOlxyg7v/wIUgzDPcIAACjAAiIDg +zCcCkAvyz3CAAHgGAIDCoM9wgAAIMMCoMQ1eEc9xgADAHweJJQ8BEAGJUyUCEBkKAQAEJY0fAAYA +AIDlAdoGicB6HQoAAM9wgAAFG8Coz3CAAAwwwKDPcIAAEDDAqOIM4AIvIEcEkQMv9aHA4HjxwE4K +z//PcIAATAYAkIDghAzC/9HA4H7gfuB48cAKC8//fgrP/0YMQAUCDY/8UghAAdHA4H7geOB+4Hjx +wM9wgAAQMACIjehODM//ieiQ2QPIkLmgGEAAANjRwOB+z3CAAFwWAIgR6M9woAAABAyIjCACgADZ +CfSR2gPIkLqgGIAAKHDr8QHY6fHgeM9xgACUHPAhAQAoEYAAKIGVBu//ANrgePHA4cXYcM9ygADA +H891gABMBgCVZ4rPcYAABBsrCwEAz3CAAE4GAJBhih8LAQDPcIAAUAYAiEaKDwoBAM9wgAAFGwCI +AvAA2KoL7/8Aqc9wgABQBkCIz3GAAE4GAIkgjYDiAdrAeshzAN0+De//mHXPcIAAeAYAgAGIz3GA +AFwWCwgeAQHYAKkC8KCpeQIP9c9xgADAH89wgABMBgCQR4kxCgEAz3CAAE4GAJBBiSUKAQDPcIAA +UAYAiCaJFQkBAM9wgAAEGyCIz3CAAAUbIKjgfuB48cC6CQ/1z3aAACiYFI4pCFEABNiKCy/7AdnP +cIAATgYAiM9xgABMBo4M7/8giQDYFK4t8LaOK+3Pd4AACDAAj2G4JQ0AEE4Jz//PcIEAeBQFgCFt +BSh+AM9wgABwPC4N4AMvcc9wgABOBiCQz3CAAAkwoK8gqM9wgABMBiCQz3CAAAowIKgA2BauNY4J +6c9wgABOBgoJ7/8AiADYFa6FAS/1AdjPcKAALCAwgM9wgAAMMOB/IKDgePHA9ggP9aHBCHYacTpy +AN3PcKAAtA9wEBIAigrgAqlwBYbjjotxQCSDMKIL7/9AJEIwCoYaCu//QCRBMCcPVBAUIUwjIIwg +wAEUgjACFIMw8CBOI8YL7/9TJgQQAeXlDcSTQgrgAi8ghwTpAC/1ocDxwGINz/8WCUAF0cDgfuB4 +8cDhxc9wgABAyQDZJaDPcIAAXCgioM9xgACUHACBxBAABncIXgEDgRiIbwgQAc91gADgOACFQiAA +gMogYgAnCFEAogvgA6lwz3GAAKg4AIFCIACAyiBiAIXoKHD2C+ADIoXPdYAA/DgAhUIgAIDKIGIA +JwhRAG4L4AOpcM9xgADEOACBQiAAgMogYgCF6ChwwgvgAyKFZQAP9eB44cUA289ygADsyRQiDQBg +tWi1GmIgGsIAwB3EECgawgDPcYAAmMkWeSKRMBrCANAdxBCAHdwQeB1EEAHZiBpCAM9xgACMyhV5 +YKHgHcQQ8B3EEOB/wcXgePHAqgov/BHYuejPcYAAwB/PcIAATAYAkEeJVQoBAM9wgABOBgCQQYlF +CgEAz3CAAFAGAIgmiTkJAQDPcIAAjCMAgJro7gvAAojoC8gFIIAPAAAAPAsaGDDeC8ACiOgLyAUg +gA8AAADUCxoYMAvIkLgLGhgwcg5P+wPwAgzP9dHA4H7geADZnLnPcKAArC89oOB+4Hj9Ak/7IQGv +9xXY4HjgfuB4ocHxwOHFrMEA2UrBkNkYuUjBz3OAANzJIIMEII0PAQAAwIYh/gMkuQ65CyVAkE7A +jsIW8td1AAAAQMwlgp8AAACAzCWCnwEAAAAE9CGDA/Aig664r7iwuAV5IKIOwwjAi3UEI4EPAQAA +wC65QCkCBkV4SMCKIAYGScBBw6lwANpKCSAAAdvPcYAAWBQagTuBJHgnCB4CCsALwYQoBA4AIYB/ +gQCYFgK5COA0eSFgz3CnAIhJL6DODyAEqXAI3KcG7/SswKHB8cAmDu/0CHKtwQjYSsCQ2Bi4ScDP +cIAA3MmggAQhjg8BAADAhiX+EyS9Dr0LJkCTUMGQwxby13YAAABAzCaCnwAAAIDMJoKfAQAAAAT0 +AYAD8AKArrmvubC5JXgAoxDDCcUEI4EPAQAAwC65QCkABgV9ScUfCp4BCsAEI76PAAAAGEUgwABK +wAXyhSAQAUrAJQoeAZu9z3CgACwgBYAA2wK4briA4MogzADJuKV4ScAG8AkKHgKdvUnFEMCBxULA +qXBCCCAAAtsDyAzCz3GAAFgUuRiCABqBO4EkeBsIHgICus9wgQCgFlR6QWDPcKcAiEkvoMoOIASp +cAjcmwXv9K3A8cAiDc/0o8FhgAh1QMMA2AqlbQteAgQjgA8BAADALrjPcoAAGEwKYkkiggBhukul +EmoUeMdwgQCQF8qAz3eAAHTLxqULgM92gACUHAWlw4YgwNSG9Y8EfuR+Cb5AKQ8C5X7FeAQjgw8A +AAAQZXgHpQiFGOKeuAilS6WP8DcKngLPcIAAmDoAgEHAQsAhCB4ChiD/CSO4AeAVCJQACwiRAAbY +YcAk8AfYYcAi8CLAYcAe8EHDz3KAACAGQIJGgp4SAgYrCpEBBCO+jwAAABgP9M9ygACUHESCSIIE +Ir6PAAYAAAXyAdgKpQPwCqUA2AHGQQ4eEkLGIsKg4soiIQAEJo8fAQAAwEEvhBNEJg8WI78B5wQm +jh8GAAAAMb4AJsUTz3aAABhMMiYOEQImThET8FMmwhDPd4AABE9dekpnBCaOHwEAAMAuvs93gAAY +TM5nYb7WekulEwseAiDHz3aAACBM7mYC8AHehCgEDgAhgH+BAJgWArpUekdgYb5YYOalAYAEI4MP +LwAA3Sa7xXtSI8MDBaVnpc9wgADcyQOAAN8dCE4Az3CAALg6AIAVCB4AhiB/Dx14QCjPAwTwAN+P +v5vvz3aAAKgjIIZgeQDYJQgQAyCGYHkA2BkIEAQghmB5ANgRCFAEIIZgeQDYCwiRBCYJb/wA2AiF +BX/opY0D7/SjwOB48cAiC8/0z3WAAMgjAIXEkMlw8gigAIYg/AMAhclxhglgAIYh/APPc4AAuMsL +CJEGIYOAuSGjSoMB4kqjz3OgAMQnkRMBhsO5GwmBAIolCBATG1iDkRMBhsO5CwmAABIbWIMtA8/0 +4HjxwLIK7/QA2M9xoADEJ1IRAoYVEQKGQhEDhhELngcB2M9xgAA8y2GxUSLAgBpwyiViFBL0USDA +xsolohQM9M9woADQDyAQAYYfEACGEHEA3colYhXpDREQz3aAADzLH4bLCB4EqBYBEJTYngpgAsly +z3egANAPUQgQIM9wgACQBiCAz3CgAPwlz3KAANDIjOkzgAqCGWEqos9yAP8AqoogiAUM8BOAJJIZ +YTB5JLKKIIgFz3IA/wD/+gtP/QCW8giv/TSWlBcAEM9ygACAMwHZGehtggHjbaJrgnhgC6LPcIAA +BBsgqB+GDwieA89wgAAABiCgB/APCN4Dz3CAAAQGIKDPcKAA/CUTgGyCeGAMos9yAKAIAOxwQKBv +IkMA7HBAoA4fWJD+DkAFz3AAAP9/z3GgAAwkAaEb2ASh2QHv9Klw4HjgfwPY8cDhxaHB2glv+4tw +sugAFAUwHQ0eAH4IAADPcYAAPMtDgc9xgAC4m0GhJPALDZ4Aig7P/x7wDQ1eAhoOz/8a8DsN3gAI +2M91oADEJxMdGJCmDcAAHQgQBQLYPB0AkM9wgAA8yyOAz3CAALibIaAZ2JcIUIZxAe/0ocAKIcAP +63IX2Iy4iiPHAGEAb/aKJIMP8cDhxc9wgAA8yz+ABCGBD///jzgEJYBfAABwxyV4z3GAADzLH6FE +IgBTz3WAADzLQwgRAj8NXlE2D8//nB0AEBMNnlPPcIAA6BwFiJgdAhAU8BUN3lPPcIAA+B8ZiJgd +AhAM8AOFVg8v9iSFmB0CEATwANicHQAQnBUAEIDgzCDigF7yz3CgAKggCIAfhREIHwENDd9SgNiY +HQIQmBWAEEAoAQYRCN8BgrkfCp5TRg0AAhvwH4VRIoDTs7gfpcUhgg8AAAAHRSEABs9xgADIyyyJ +hiH9D1IhwQFFuSV4z3GgAIgkEKGKINYAz3GgAMQnfhkYgM9woADUCwHaUqAE2BAZGIDPdYAAPMsf +hUcIngEUlUMIXwHPcKAALCAPgJvorXGOCW/5ViVAFYAVABCUuIAdABAfhZC4H6UN8M9xgAAEMw+B +AeAPoRDZz3CgAJAjPaAFAO/0GdjxwIIPr/QA2Qh2AYDBuIPgyiBBIAXyIg4gAMlwGnBMIACgxPQQ +hlEggIHA8hCGz3WAADzLDwieA89wgADoHAWIDfAQhg8I3gPPcIAA+B8ZiAXwBYYmhg4OD/aYHQIQ +gBUAEAQgvo8QcAAAB/StceoIb/lWJUAVEYbPcYAAvAYAoUEoAQNTIcUAmBWBEEEoBgUUaQUgRAEP +Cd4BHoWVuB6lefAmDy/7TyRAAusIFQTPcYAA5JGYFYMQ8CEBAEArAgaGI/0PUiPDAUW7ZXrPc6AA +xCdBG5iAANqMugImTwD6Ysu613IAAAAIQC0PA5C/UvcFJ48RYhvYg4wiAoDH989xgAB4NBKBAeAS +oQDZnblF8OV5YhtYgFkOhXAAAMAPDiKDDwAAABDPcoAARJEWeiCCJQs1CAQSBQAA2A8gwABhuE4j +DwgBKcIDeHkFeQAtwAAFehfwQiMDCADYDyDAAGG4eHkFIQIAiiH/Dwvwz3OAAHg0E4OKIf8PKHIB +4BOjAdjPc4AABLAAqwIbBAEho0KjvfEA2Zy5gBUAECV4gB0AEEAmABKgHQAQAtnPcKAA9CYjoCWG +z3CAALibIaApBq/0CnDgePHAtg2P9Ah1VSBQBA3MosHtuNEgYoAH8gTIwg6v/5gQAADPcIAAuMsM +gM9xoADIH2TgHqEQ2A6hAdgVGRiAAYWD6P8LHsABhcG4g+DW9AAQACBBwAQUDzEQhSy/BhQSMXUI +ngENzHUI3gIQhc92gAA8yxEIngPPcIAA6BwFiA7wEIURCN4Dz3CAAPgfGYgG8AWFJoUKDA/257iY +HgIQyiZhEAbyPoaVuT6mAN4EuM9xgABMskaR5XgTCIAAz3KAAHg0CYIA3gHgCaIEkRsIgQ8AAP// +AN4J8M9xgAAEMw2BAN4B4A2hAZWc4Ij0BBARIAgQECDPcKAA9CYC2SOgI4XPcIAAuJshoGoLIACp +cIDggPQm7s9yoADELBwaQATPcYAAyMsgGgAELIlALwMTELmfuSV7QSoBIWV5JqINEgE3HQneAhDa +q7kMGpwwDRpcMM9ygAD8MyeCAeEnog0SATcNCR4DGtisuQ0aXDClDhAQz3aAABCK4BYDEEWFRCs+ +BwAmQR5AoUyVAeNCsc9ygADIy6yK4B7AEM9ygABMsqip6akKGYQEDBlABESSEBkABBC9DL9BKgMh +5X1lfUqxz3OgAMAvRxtYg5TiwCKGDwAAkwDPdaAAaCzwJYIQS7GPEwKGCfCjEwKGUSIAgY8TAoYG +9PUK3oEH8AjYDPDnusoiIQBAwgEUgzDGusa7eKlZqQEEr/SiwOB48cDhxc9xgACUHCOBSIFZCh4A +hiD/Ac9ygAAYTEO4CmIA24DiyiHBD8oiwQfKIOEHzyAhA8ojgQ8AAG8AyiTBAOQCIfbKJSEAz3Cq +AAxQEwq0ALmBgL25oQHZJaAE8KC9uaFloL0Dj/TxwEYLj/QIdQ3MUyBAgAfyBMhKDK//mBAAAAGF +wbiD4MomIRAF8s4JIACpcAh2sQ4REBCFCQifAQDZRfAMzHkI3gANzFMgQIANEgI2HfQAIoAPgAB0 +ygHZz3aAAMwxIKgRjlEgAIBQDeIDyiBCABGOFwheAc9wgAAcMAOIgOAgD+EByiAhARDYDBocMM9x +gACAMxeBAeAXoQPIDRIBNoQQAgHPcIAAaMo1eCmAWWEpoBrexPHPcYAABDMNgQHgDaEB2c9wgAAE +GwHaQKjPcIAAuMtOgAaCAeAGogPwAdkC2s9woAD0JkOgQ4XPcIAAuJuA4UGgXAgCA7kCr/TJcOB4 +z3OAADzLWBOBAADajuk8k2K5ELlFIUMBz3GgAPQmY6HPcYAAuJtBockAAADxwBoKj/QIdgGAwbiD +4ADdBfK2CCAAyXAIdbHtEIZHCJ4BDMzPcYAAiDIxCF4BQNgMGhwwVREABgDaAeBVGRgADcjPcYAA +7MkUeQPIQKniCq//mBAAAAfwrBEAAAHgrBkAAM9wgAAEGwHZIKjPcIAAuMsugAaBAeAGoQLZz3Cg +APQmI6Ajhs9wgAC4myGg+QGv9Klw4H8I2PHAJLlTIcIAz3GAAMRRVnkTChACQZBhgQTicHLKICIC +A/QggUB50cDgfuB4z3GAALjLLIHPcqAAyB9k4T6iENkuogHZFRpYgCGAhOn9Cx7AIYDBuSEJ0QDP +cIAABBsB2SCoz3CAALjLLoAGgQHgBqEA2Q3wIYBRIQCAANnKIeEFAYBRIECAyiGhBOB/KHDgePHA +8giP9M92gAC4ywGGBCC+jwBwAAA58i8pAQDPcIAAVDD0IE0AK4ZPJYAQEgkgAkmGlOiMJQOQz3GA +AIgyCPS6EQAGAeC6GRgAH/C5EQAGAeC5GRgAGfABhiEIngfPcYAAzDEMiU+JGwoAABGJUSDAgDgP +QQIH8ADZz3CAAASwIKjaDQAF2QCP9OB48cBiCI/0CHYBgMG4AN8nCNEAz3WAADzLjw8REBCGdwie +ARCGGQieA89wgADoHAWIEvDiDu//yXAId+3xEIYRCN4Dz3CAAPgfGYgG8AWGJobuDs/1mB0CEBEI +3gEehZW4HqUfhZe4H6WAFQAQBCC+jxBwAAAP9Jy4gB0AEDCGtgkv+VYlQBVAJgASoB0AEADYBbYB +2c9wgAAEGyCotBUBEAaBAeAGoVgVgBCZ6L4Nz/oF6BCG7bgB2AL0ANjPcYAAnsv0IQAAPJU4YGK4 +ELiAuM9xoAD0JgOhBvAC2c9woAD0JiOgJYbPcIAAuJshoN0Hb/TpcPHAag9v9ADZCHYBgMG4g+DK +IEEgBfIKDu//yXAacM9woAAsIAaAEHhMIACgz3WAADzLyiciEFb0MIZlCZ4BPJUTCQMAJYbPcIAA +uJsCgLcJAQAQhg8IngPPcIAA6BwFiA3wEIYPCN4Dz3CAAPgfGYgF8AWGJobWDc/1mB0CEIAVABAE +IL6PEHAAAAr06gzP+gvoEIYTCF4DAd8I8ADfGPD+Do/7FPAA3zCGlggv+VYlQBWAFQAQqBUBEJ64 +gB0AEEAmABKgHQAQ2QleggHZz3CAAAQbIKi0FQEQBoEB4AahWBWBEM9woAD0JpPpz3GAAJ7LXJX0 +IcEDWWFiuRC5gLkI8LQVARALgQHgC6HI8QLZI6Alhs9wgAC4myGgsQZv9Apw4HjxwE4OT/TPcKAA +qCAIgM92gAA8yw8NnlPPcIAA6BwFiAzwEQ3eU89wgAD4HxmIBvADhvYM7/UkhpgeAhAfhhUIHwER +DV9TDQ1fUoDYmB4CEJgWgBAXCN4BP4aXuT+mPoaVuT6mANkB3RbwnBYBECUJUQA/hlEhQILPcYAA +lBwjgSmBBfJEIQ0EBfBEIQ0CA/AB3QTZGLgleM9xoACIJBChH4YzCJ4BFJYrCF8BxgpAApHoz3Cg +ACwgD4AF6A3MFwjeAR+GkLgfpq1xUg/v+FYmQBWb7QsKnlOGCsABFfCGIv/cz3GAADzLD/QBgRsI +HgCYEYAAz3GBABAMArgWeABh/rgYCkL7z3CgAFAMIIDPcIAA/AYE2iCgz3CgAJAjXaDPcoAAPMsf +gg0I3wQPgoDgANgp8heCihICARlhBOILCJ9E/wkexs91gAA8y5gVgBDnuADbCfQCuM9zgQAQDBZ4 +A2Mtu8C7ihUAEU8VjRDPdoAAlBzwJsMQQnmieO4PL/tPkzkFT/TgePHA4cWhwQDYQMDPcYAABDMP +gQHgD6ED2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoBDYz3WgAMQn +EB0YkOYM7/qLcJboABQFMB0NnwAKIcAP63IN2Iy4iiNfB9ED7/WKJIMPBNkTHViQG9kWHViQuQRv +9KHA4HjxwM9wgAA4rwYML/YY2c9wgAC0jfoLL/YY2dHA4H7gePHAFgxP9Bpwz3WgANQLEIUA3qHB +QMYhCFAACiHAD+tyD9iMuIojlgiKJIMPaQPv9QolAATPcaAA/EQZgQQgvo8AAAggAvQdgREI0CQ+ +DO/6i3CA4MogAiBCIMEglOFKAQ0AMiZBcIAAAD5AJ4ByNHgAeM9wgAC4yy6ACIEB4Aih0grAAADZ +KHA88M9wgAC4yy6AB4EB4Aeh9vHPcIAAuMsugAyBAeAMoe7xz3CAALjLLoACgQHgAqEi8M9xgACA +MwWBAeAFoRzwz3CAALjLLoADgQHgA6EB2QDYFPDPcYAAeDQagQHgGqGmDaADAdjK8c9xgAB4NBSB +AeAUoQHYCHGA4TQJggDPcIAAPMsfgBcI3gTPcIAA+JDLqM9wgAAsjsywA9gRpeB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB4EaUxA2/0ocDPcZ8AuP8YgZC4GKEYgbC4GKHPcIAAuMsugAWB +AeBOCCAABaHG8c9wgAC4yy6ABIEB4DoIIAAEobzxz3CAALjLLoARgQHgEaG08c9xgACAMw6BAeAO +oZnxCiHAD+tyQdiMuIoj2Ac68eB48cBiCk/0z3CAALjLDIDPdaAAyB8Q3gHfZOAepc6lFR3Yk64O +4AQJ2APYHqXOpRUd2JPPcKAADCQHgATo9wsewIkCT/TxwOHFz3GAAJQcI4EpgVEhQIDKIKIAJ/RE +uM9xgABEMMO4CWEJCR4ANQ2fUTUJXgDPdYAAlBwDhRiIIQhQAOoPj/oI6M9wgADcHwiIDQjQAQOF +GIgNCJEACQ2eUQHYA/AA2DUCT/TgePHArglP9EQiEVNNd4Yn/BNNcAQikF8AAABABCWAXwAAACBB +KH6DBfKWD4/6g+gA3gLwAd7PdYAAPMsfhQkIXgQA3bzw/QkRoHYPj/oe6M9wgADcHwiIh+DMIGKC +FvQBhYwg/48S9CSVz3AAAP//HQkBAAWFjCD/jwj0DJXXcAAA///KJWEQmvLPcIAAlBzwIIADKYAN +CV4Bz3GAAMBMBfDPcYAAzEwYiAphQS8AEc9xgADYTAhhFHrPcIAARFJOYCsOHhAfhQh0hCQJkA/0 +5L7RICKCH/IBhYwg/48b9ASVMwiBDwAA//8K8A0OXhAfhSMIngIJDp4QCQ0eUgHdDPATDt4Qz3Cg +AAwkEYCMIP+P9vMA3ea+yiUiEKYOj/oI6AQlvt8AAAAiyiViEI0NEBAVDt4REQgRIM9xgAA8yx+B +k7gfoREOXhHPcYAAPMsfgY24H6GMJwKQDvTPcYAAPMsBgYwg/48H9ASRDQiADwAA//8A3YwnApDM +J4KfAABQAAf0z3GAADzLH4GTuB+hz3CAAJQcAoDCEAAGEOiMJwKQzCeCnwAAUAAI9M9ygAA8yy+C +At0leA+iVQBv9Klw4HjxwOoPL/SA26LBAN3PcYAAPMu+ob+hoLGvoU8ZQgOAGUADjBlEA5gZwgCE +GUADz3KgAMgfpBIAAPgSDgCsGUADQhlEA8J4sBkAAM9wgACMirmgz3CAAPTLoKAE3s9wgAC8BsCg +mRGAAKC4mRkCAM9woADEJ2QYWIPPdgAA/38TGJiDG94WGJiDGhhYg4on/x/PdqAA/ET9pvmmiieY +Hc92oABQDOKmcaJwojwYQIOKIxgIbqKAEgMApBlAA1EjQIDPc4AAuJtYGUIDDPJCEACGBCC+jwDA +AAAE8gGDAugCo6GjgBpAA89zgACIMs9wgACUHEOAKQmeQx+Bi7gfoVUjwAW0GQAACtgcsRuSlhkE +AAbZz3CgAMgcKaAL8EAjAAO0GQAAENgcsRqSlhkEAM9xoADUCxCBHwhRAAohwA/rcgvYjLiKI9UA +iiSDDyUGr/W4cwHdsKFRIEDGbAIhAMol4RDPd4AAPMu0FwEQAIEB4ACh+tgqCm/7ANkg2M92gAAU +zKYPYAMApgHYz3KgAMgfE6LPcYAACBsIgQCAbIFggySBQCYQFQARBAD4EgIAANkCIICAAaYA2AMj +QwBQHwQQUh8EEFQfBBACJIEAz3CAAJQcYqZDgCOmFJLPcaUACAwJtgiCwLgItgARBABTJEUBUyRB +AEwfQhGD4cohwQ/KIsEHyiBhBcojgQ8AAJwLZAWh9c8gIQMEJIEPAAAA4C25f4eaH0IQFB4AER0L +3gIEuYG5JXgItgfYB/AA2RUgDCAgpAPwBNgB4PMIFIIIguu4CAqCBR+HK7hTIAUAUSCAxabyz3GA +AOAiBoEB4A94BqFBKYBDz3GAAOAiZoHPcaAAtA83gcC4MHMA2pv0z3GgAKggJoGMIYOOJgENALBw +jfTPdYAAFMwFhc92pACQQfWGNoYEIIAPAAAA4C2456XPc4AAPMsopQ0IHgBQG8QDCfBQG4QABCeP +H///AADnpQ8IXgAwv1IbxAMF8FIbhADwf+elDQieAFQbRAAJ8FQbhAAEIYEP//8AACilDYYGpQQg +gA8AAAD+KbhWGwQAH4NHCN4Cz3CqAAAEBIAJpc9wgAC0jSCIRGg16WEJdAACEIQAn3EA2KgggAP0 +Ig8AFd4TvvAmzxPPdoAAFMsVfgHg4KYc8M9wgAA4ryCIRGgZ6QIQhACA4cokTXDKIC0A6CCtA/Qi +DwAp3hK+8CbPE892gAAUyxV+AeDgpiGtAh0CEbQTAQAC3QGBAeABoQzwBCC+z2AAAAAD9ATdBPAJ +Cx5AA92B5U7zLw2REALdBCC+z4ABAADKJaIRBvRRIwDAyiXiEOsNkJDPcKAAMBADgIDgyiViEYbl +MgQCAM92gAA8yxyWQiCEAB+G67gvJAgBe/LPcaoAAASigc9wpQAIDACABCWDHwAAAP8ouwQggA8A +AADgibsbemV6z3OAABTMUqaso02jAIFIFo8QlOcKoxnyBvYzD5ESI7gO8B0P0B3u5xP0RSj+AkEp +wHBRJcCRwiBiAAfdC/BFKP4CQSkAcfrxIrj48QDYCN0hgRemK6Mcsx8IEQXPd4AAlBzjh+iHBCe+ +nwAGAAAD8oy6UqbkucolIhLhucolIRKGIf4PQSkCAU0eghAok0V5KLMpDdERIwi0Awfdz3GAAJQc +I4GEEQEAEwkEAM9xoAAwECiBCQhAAAjdh+XKIAEB0A4h+8ohIQArAwAAz3CmAAgEAYAEIIAPMAAA +ADS4Qh4EEEIWAREZCF9Gz3CgAKggCIAZYTB5cg4v+4hwBfCSDi/7iHAEIIBPgAEAAADZMQiBDwAB +AAAB2E4eAhDPcoAAFMyaFoAQQh5EEE0eQhA3pimiBLgokom4JXgIsnPwTR5CEM9wpgCMAz2ABCGC +DzgAAABBKsAEmh4CEAQhgA8AAADwJbosuEV4z3KAADzLEqYNCN5HEoKMuBKiUyHDAkgSjgB3ouC+ +0SHihwfdA/QI3c9wgAAUzCmgmhKBAOiQBLnleSiwfLAygi2gfQ3REc9xpgCMA72BBCWBHwEAAAAw +uU4aQgCpoE4SgAAb6FsOURNTCB9GFNjPcaAAyB8eoRDYDqEB2BUZGIAK3VEgAMbKJeIRUSMAwMol +IhLxDZCSFPAnC5QDz3CAAJQcA4CEEAAAFwjEAM9woAAwEAiACwsBAAfdAvAI3Yfl5fTPdoAAPMtO +FoAQgODd8s9ypgDUBCwSAIA0EhKAOBIPgMsSEAZKcca56XKGIv0PBrpFeUpyhiL9DwS6RXkEIIIP +AgAAACe6RXlEJwIcDbpFeelyhiLzDwQggA84AAAADrpFeSW4JXhEJ4EQFLkleIi4RCcBEkEpwYBS +IEAFEqZYHkIQyiGCDwAA///KIYEPAAAQHzpxN4ZAHkQQBCKBL/8DAP8ouTemwg6v+ADarB4AEHEP +nhRIFoMQMoag49Eh4YIw8gQhgo8AAAABCPJEIQ0GI70B5RUNlRAEIY0PAAAAJEENgB8AAAAkBCGN +DwYAAAAxvTEN1RAVDZEQFOpEIQ0GI70B5R0NkRAD6szjCvZXhjJyyiKODwEAiA3MII6AzvcVDgVw +AQCIDc9xgAB4NByBAeAcoQjdM/CGIf8JQSnNAM9wgACwIyCAAeVgeQbYLwhEA89wgACUHAOACIAE +IL6PAAYAAADYyiBiADKGBCGBDwAAAAgruRUIRQCmDAAACHWU4Mol4hML8M9woAAwEAiAN4YQcQfd +yiViElgWghDPcYAAFMwIkQe6iLpFeAixF4YwGQAEHLEShuuhDaGsFgAQKBmABB2xDQ3REXoIAAAI +dYztIg5gABXdHg0v+wh2gObMICKAyiUhEIDllAui/8ogQgMA2M9xoADUCxChz3CAAMjLDYgRCB4A +z3CgAIgkHoALGhwwOgxAAAzMhiD5jwr0hOXMJeKQBvQA2I+4DBocMDLZz3CgAMgcKqCtB+/zosDx +wFYPz/MA3c9woADUCxiAQiAACIDgyiBMA89xgADgIiWBgeGKIZkOCPTPcYAAlBwjgT6BgCGZDhBx +ANjKIG0EdQgRAM9ygAA8y1gSgQCA4cohIgAi9AwSAzcnC94ADRIBN1MhfoAN8uu5N4IF8qDhAdnA +eQjwjuEB2cB5BPAnC18BANnPc4AAlBxjg2mDfXtSIwMAwLtkeQfpP4KRuT+iCvA3gunx9gsAAFgS +gQCA4SgLAQCA4H4CAgDPdoAAPMtYFoAQEugC2c9woAD0JiOgz3CAALiboaDA2ZkWgBCAuJkeAhAo +cAPwQtjPcaAAxCe/GRiAAdgMGUCDEBkYgB+G8bgiAgIAEoY3hh4Mr/gA2qweABAfhsUI3gLPcYAA +lBxjgUgWgBA0gwR5RCECAUQgAQxCKQQBgHLPcYAASB1TIkYAMiGBAYm5PKZUg3AWgRDPd4AAcEwE +IYUATRaCEIYh/wNEuQQlhQCgcfQnQRBiHkQQz3GAAGwgMiGBAYm5PaZ0FoEQ9IMkf4Yh/wNEuUR/ +P2fPcYAAcEz0IcEDZB5EEDKGOqZ0gzumZHgEes9wgACATIBy9CCDAM9wgACoTPQggACOHsQQkB7E +EJIeBBCUHgQQTh5CE5nwThaBEM9wgADcLwCAwLipCRAAgOAA28ohIgAL9HKGSBaBEAQjgw8AAAAI +e3vCuQAhjQ+AADwdUI24jcdxgABoIM93gAD4rgiJZX28pnAWjRBlesO9vH30J00TZXgwiWV5PaZ0 +FoEQw7k8efQnQRBiHkQTWqZoFoMQZB5EEM9xgAAIr8O7fHv0IcIAG6aOHoQQz3KAAFCv9CLDAGwW +gBDDuBx49CEBAJIexBCQHkQQ9CIAAD3wgOAA2QX0SBaBEMO5PHnPcIAAOB0oYM9ygAD4rhymcBaA +EMO4HHj0IgAAYh4EEM9wgABcIChgHaZ0FoAQw7gcePQiAADPcYAACK9ShmQeBBBIFoAQw7gcePQh +AwBaps9xgABQr/QhAACOHsQQW6aQHsQQkh4EEJQeBBASDEABz3CAAJQcA4AIgA8I3gJOFoAQgOBA +CEIFWBaAEAXowgoP/wPwwgoAAI0Ez/PgeM9xoADEJxURA4YE2BMZGIAb2BYZGIAD2s9woADUC1Gg +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhRoOS74SDCBxbYUhEAhuC44SDBB8og4QUJ +CF4ACQveAOB/EtgB2c9wgAAEG89ygAA8y7QSAwAgqAaDAeAGox+CDwieA89wgAAABiCgB/APCN4D +z3CAAAQGIKAV2OB+4HjgfuB48cB6C8/zz3CAADzLMoAnCV4Cz3GAAJQcI4FIEIIANIFEeVEhgIBI +2soigQ8AAJAAAvAO2gDfz3GgAKggJ4GsEA0AWWGxccIlRRDKJeYSsHjSDu/6CtnPcIAAdCsAkM92 +oADEJwsIHgGMJQOSA/cA3RnwqgygAQDYz3CrAKD/+qD6Du/9ANgZFgCWBegC2BAeGJDPcYAAeDQb +gWq9uGAU3RuhGRYAlojoUSEAxjgPYQTKIGEALQPv86lw4HjgfuB44H7gePHA4cXPcIAA4AYAkM9x +gADkuajaAd2AIEQLEHiiCi/7qXOA4MohwQ/KIsEHyiCBDwAAtRTKI4EPAADMAMokIQDwAWH1yiUB +ARYKQADPcIAAOCXdAu/ztKDxwP4LoAEA2K4MT/dSDw/+3gmP+0oO7/0A2P/Zz3CrAKD/OaA4oNHA +4H7gePHA4cXPcYAAlBzwIQIASiRAAMMSAQYPeDIigg8AAB8DBCGDDwAGAACA4wHbwHsEIY0PQAAA +ANd1QAAAAMIkAgH+C6/7wLllAs/z4HjxwOoJz/PyDyACCHXPcYAAPMsfgc92oADEJ7C4H6EZFgCW +ANkE6ALYEB4YkM9woADUCzegog4AASIMIAMB2AXt3ghAAAXwvghAAKINz/oZFgCWBegC2BAeGJD9 +Ac/z4HjxwCYLoAEB2ADZz3CAAPwzLqCiC2/2GdjRwOB+8cBiCc/zosGLdtIJb/rJcAolAJAZ9M9w +gAA8y89xoAAMJDuBV4AwcsolIhIghg0JHgQC2YwYRAAEJYJfAABwxz+ARXk/oIDlugMCAADA6bjW +8s91gADIIwCFiiEIAOSQz3agAMQnEx5YkM9xgAA8yz+BOneGIfwjhQleBEEpASHDuc9ygADEUTZ6 +IIJAeQh1GRYAlgToAtgQHhiQz3AAAP9/Ex4YkBvYFh4YkAPZz3CgANQLMaDgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeDGgz3CAAIyKGYCA4DAOQgGa5RoDAgDPcIEACBkiDiADAN0LAwAA +Ug5v/ypwGnAAheoOL/8qcXIPL/8Id4jnzCfilcolwRMr8hsIECDuCiAAgcAKJQCQHPSGDe//AcAY +8APZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgAN0PD5EWz3CBAAgZ +pg0AA4DljgICAPIPgAHPcIAAPMsfgBEIngMB2c9wgAAABiCgCfAPCN4DAdnPcIAABAYgoBEWAJYA +3UHAMQifAC4Ib/qBwAolAJAQ9AQUBTAdDZ8ACiHAD+tyCtiMuIojxwoVBy/1iiSDD4DlKgICAATY +Ex4YkBvYFh4YkM9wgACMihmAgOAcDUIBCwIAAOC4wfLPdoAAPMsShoYgOgCMIASCWA+FAc9xoAAM +JDyBF4YieGS4EHiKHgQQRCIAUxcIEQIfhg8IXwRRJUDRAdgF9ADYA/B2DU//nB4AEC7o1ghP/wol +AJDX9A3MIQjeAR+GHQieAS8ghwqMIAKGCPTPcYAAPMsfgZi4H6GWCSAAgcAKJQCQwfTPdoAAPMsf +hisIHgSoFgEQ1NgmDyAByXIH6DoMQAQL8AYKT/+s8M9xgAD0NB6BAeAeoQHfz3CAAAQbtBYBEOCo +BoEB4AahH4bzuIgKgvoPhoDgmAmC+h+GEQieAwHZz3CAAAAGIKAJ8A8I3gMB2c9wgAAEBiCgANjP +caAAyBwHoTDYCqGqC+//AcAfhicIHgYQ2AwaHDDPcIEACBnyCwADDcgAIIEPgAB0yh+G4Km4uB+m +AJaGIPwAjCACgBr0QgwP+pjoA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg +eOB4MaAAlu4Mb/w0lkPwQcAV3wsI3wDpdR/wCNjPdqAAxCcTHhiQXgrP/wh1KwgQBQLYPB4AkCEW +AZbPcIAAuJshoBEWAJbTCJ+AIg4v+oHACiUAkOHzPw1RFc9woACQIx6ABBQEMFEggIDKIcEPyiLB +B8ogYQLPICEDyiOBDwAA5AT0BCH1yiUhAFYJ7/+IcAh1qXC9Ba/zosDgePHAYg2P86HBCHYA2EDA +AKa+DS/6i3AKJQCQhfTPcKAABCUigACGBCGBD/8AX/8FIQIAQKZTIYIAUyCDAGV6pQrRAc9wgAA8 +yx+AeQqeU7cInwYEIL6PAB4AAAT0AIYJ8AEKn0AAhgsKHkCFuACmz3KAADzLP4IRCV4GiLiLuI64 +AKZB8CkJ3gZPIAECibmNuYu5jrkgph6CBCCADwIAAABSIEAEKrgleACmLfD8ucUggg8AAAAF5PWF +IBwAAKYj8PW4AIYf8oYgHACFIBgAAKYBCh9BAIYvCt5AhrgAphPwUyEDAFMgAgAFI76AyiXhFQny +hiF/D4Ygfw8FIT6AyiWhFM9wgADIywyIxLhAKAEGAIYleFEggMQAprAIYgTKICIIqXCpBK/zocDg +ePHA4cUA3QXYC7jSD6/6qXHiDY/0z3CAADzLH4AVCN8CxQ0VEcEIX0WfCB9FAeVO8ADZnLnPcKAA +0BswoAHZz3CkAJhAPKAF2AfwBgsAAHoIYAQF2AHYcghABGMNFREEIL7PMAAAAAHlyiUiEC0LH0AJ +CF5FRwmeQzMIH0fZCN7F1Qmew89wqgAABAGAhiA/CwDduwjRgBPwtgoAAM9xgAD8Mw6BAeAOoQnw +ANmcuc9woADQGzCgmgoAAADZz3CkAJhAPKAQ8ADdDQsfQPoPIAQB2KjxegoAAM9xgAD8Mw6BAeAO +ocUDj/MMzEQgPoo58kEI3gANEgI3gNjPcYAAgDMMGhwwDQreAh2BAeAdoQXwFYEB4BWhEQrfAADZ +z3CgACwgL6ANzIYgggLgfw0aHDAvCF4BiiAEAAwaHDDPcYAAgDMUgQHgFKENzADZRiCAAg0aHDDP +cKAALCAvoOB+4H7xwOHFLQgRAikKn1HPcYAAPMt/gYYj9w+3gc9yoAAMJByCFOAIJQAQXIKKEQEB +EfCV6M9zgAA8yzeDz3KgAAwkHIIIIQAAihMBAVyCf4NGD0AEz3GAAMwjAKHxAo/z4HjxwM9wgAA8 +yxSQUSDAgc9wgADMIwCABfJuDkAEA/C6DkAE0cDgfuB48cBKCo/zz3aAAMwjAIaA4MogYQUj8s9x +gAD8BiCBz3KAAPgGQILHcQAAAEDPdYAAPMtCec25z3KgANQLL6IggDhggg3v8zeFAIYA30CAN4VZ +YRoOoAQgoOlwWQKP8+B48cBeDYAEz3OAAMwjAIMF6JINgAQAo9HA4H7gePHAz3CAAIQyz3GAAJDo +z3IAAGAiogjgBACAANnPcIAAzCMgoNHA4H7xwKoJj/PPcIEAVBoAgK0IEADPcIAAzCMAgAboApCG +IP+JTPREIgBTSwgRAq4Pz/+mDu//CNgqD8//z3WAAMwjCiYAkACFCPSA4OwOwv9yD+//yXAghQzp +ApEK6IjucgxgBACBLg2gBACFKPCiDEAEJPCGIv/cz3KAADzLEvQfgiEIXgOKCKAEAdgI2M9xgABw +fAh0hrEwvH4NoASHsQ7wnBIAABUI0QA0kpgSgAAl2sO5Hg2v9ADbXQGv8xXY4HjxwIYKYAEB2B4K +7/MD2CYIAAB2CmABAdjRwOB+8cDmD8//lgzP/8YMj/rRwOB+4HjxwLoIj/PPcaAA/EQFgQDevLgF +oUIKYAHJcAPd2gnv86lwz3GgADAQoqHPcIAA4CKiofUAr/PGoPHAz3CgALQPN4DPcIAA4CIGgA0J +AQC2D8//BPCaD8//0cDgfuHF4cYA2QfYANq0abR9x3WAAOS5VX3AlYwmAp0A24X2jCaFksP2/97A +tcGdCw5TH4wmP5FC9mG1AeJPes8KEoNhuAHhxQh1gC95wcbgf8HF8cAOCI/zAN3PcIAAKJgGDu/5 +tKgS6AjegOXMJaKQzCUikcwlYpEACKL+yiBCA2G+6Q51kAHlHfCKJAFxz3GAAOzJqCCAAQQZUAPg +eADZSiQAcs9ygACYyaggwAIWIkAAYpDPcIAAZMo0eAHhYLDPdYAAlBzPdoAAQJtAJQAXJG7mDaAB +BtpAJQAVQCaBEtoNoAEG2kAlABdAJgEUyg2gAQbaDoVRIECBjAyCAnINz/mA4NwOwv/PcQAA///P +cIEATBYsoAoP7/kroLEHT/PgePHAPg9v8xTZz3WAAIwg2Nz+Di/1AiUAE89wgADYIvIOL/UU2c92 +gACUHEAmABUApsDcAiUAEwGmAN2pcKlxpgov9AbaAdipcZoKL/QG2gCGSiSAcKlxAqYDpqggwAUV +JkIQYIKKIMYNDbMAggHhqaAAgqmgAILAGFgDAILBGFgDAILCGFgDG9nPcIAAzDEdB2/zLKjxwJIO +T/MacDpxSHaKC+/5mnMIdQQmgB8ABgAAgOBKIkAgwiKCJAQmjh9AAAAA13ZAAAAASiNAIMIjwiTP +cIAAIAbEiADfAghgAelwjO0D3i8hBwQvIkcEyXBKc1YIb/sKJMAEyXB+CG/7inGE7TINgAIE8GIN +gALPcIAA4CIEgCEIngDPcIAAFDAAgIroOdhSC+/5i7gNCFEAKg3P/w3wANmeuc9woAD8RCGg4Hjh +oJYPIAEA2DEGT/PgePHA6g1P86PBCHbPcIAAlBzwIIMDiicLFi2T/WM8eihwhiHxD8K6R7kkeoYg +/gNEuB8JgAAKIcAP63KD2I24iiPSDUokAAAhBe/0CiUAAUiDf2c7ulMiAoBAr02TwLpBrQvy95OG +J/8ZQ7/nrXeThiP+B0W7aK0U6s9ygAAoMBUiAwAAizV6Aq3hi+Ot4ovkrWOLZa0jitYM4AAmrYtw +qXEODm/zDNoAwAHBjgiv9ALCi3CpcfoNb/MM2gDAAcFiCK/0AsLPcYAAcAYAod4N4APJcIEFb/Oj +wPHAFg1v81fYz3WAAJQcI4XPcoAAdAZ3kQCiCwseAF/YAKILC54AhbgAogsLXgCHuACiiiYLFsth +2WEA2oDjyiCBAM9ypQDoDwaiAInPcaAApDCA4AGBzyDiANAg4QABoQoPz/YDhc9xoADIHE+AAuBI +oaYMYAHIYAOFmgiv/Q6AAQVP8+HFz3CAAJQcA4ApgEQhg4AA2iT0iQoVBAAijQ+AANQbAI2guACt +gBWAEKC4gB0CEEAVgBCguEAdAhAQjaC4EK2QFYAQoLiQHQIQUBWAEKC4UB0CEAHi4PFFChUEACKN +D4AA1BsAjYC4AK2AFYAQgLiAHQIQQBWAEIC4QB0CEBCNgLgQrZAVgBCAuJAdAhBQFYAQgLhQHQIQ +AeLg8SMJngHPcoAA1BsIioC4CKqIEoAAgLiIGgIASBKAAIC4EPCS689ygADUGwiKoLgIqogSgACg +uIgaAgBIEoAAoLhIGgIAANg/CR4ASiQAdOB4qCAABisIngAAIIMPgADUGyATgQCAuSAbQgCgE4EA +gLmgG0IAYBOBAIC5YBtCAAHgHPBKJAB04HioIAAGKwieAAAggw+AANQbIBOCAKC6IBuCAKATggCg +uqAbggBgE4IAoLpgG4IAAeDgf8HF8cAyC0/zz3aAAJQcGnALCFEAAIYC8AGGxBAABhUmDRRMIACg +Ad8luFMgBQAghcB/QCEABsQRAQYbCV8BCiHAD+tygdiNuIojjQ9pAu/0CiQABIoiCw1ZYAAWA0BY +YGCgABYAQAGhABaAQAipABaAQAmpz3CAAOAiBYARCFEAQIUAFgBBD7IE8AAWAEEAFoBACqkAFoBA +C6kAFoBADKkAFoBAABYAQQexABYAQQixABYAQIIOT/0AhcgQAAaGIH+OQfTwJsATyBAABoYgf447 +9ApwVgov+AHZNgxv/C8gBwSaDOADCnDPcIAA3B8skB6WDQkAAJYPz/hLCAEEAIXEEAEGCnAlucC5 +Iguv9QDazg4AAYnoC8gFIIAPAAAAPAsaGDC+DgABiegLyAUggA8AAADUCxoYMAvIkLgLGhgwrgyP +89YKz/dRAk/z4HjxwMYJb/MA2QokAKChwcohYQAU8s9wgADgIhAQBQAdDZ8ACiHAD+tyftiNuIoj +CA01Ae/0CiQABc91gACUHBUlDhUAhhUlUhAkEBUAABIBICAQFgAoEBcBQS1PISmBGhAYAcC/JblT +IRMAhg1gAw3ZiiCJAIpxcgvv++lyyg4v/opwAIYJgCW4UyAQAIpwTgkv+ADZTCQAoEgJwf95CBAg +De8KIcAP63J/2I24iiOJB0okAACxAO/0uHPWDYABogrv9wHYAIYIgA8IHgAsFYAQhOAD2AL0Bdg6 +cCELESDiCU/7iglP+89wgAAcMAOIgOBUDaEAyiAhACwVgBCE4MoggQ8AAIAANA1h+8ohYQBKIwAg +S/CmDm//inBGCu/3ANgsFYAQhODKIIEPAACAAAwNYfvKISEAIQwRIIYJT/t+CU/7CgrP9roOj/mA +4KgKwvYA2B/wngrP9qYOj/mE6P4IAAQW8M9wgADcHwiIieDMIOKB8PXPcIAABEAAgATZvdoe20DA +i3C+DOAAGLsB2HpwAIYIgA8IHgAsFYAQhOAE2AL0Btg6cACGKIAUkAQhj48ABgAABX8H8va5wiei +EMAnoRAqcIpxlgvv9elygODKIEIEhAvi9cohwgMNCxAg7gjP95/wDg6P+QTZz3CAAOAi9gtv/SSg +IIbIEQAGhiB/jkH0wglv/IpwJgrgA4pwABIAIMgQAAaGIH+OQPTPcIAA3B8skB6VDwkAABYNz/ht +CAEFinAKcaoIr/UB2n/ZEbnPcKAAsB80oPoOj/lCDAABiOgLyAUggA8AAAA8CxoYMDIMAAGI6AvI +BSCADwAAANQLGhgwC8iQuAsaGDAiCo/zDPAkGUAFIIYgGYAFIIYoGcQFIIYaGQQGWg2P+QnoANgL +DBEgrg/AAwPwjg/AAwHdLgvgAalwz3CAANQaigrgAaCoKQxRIM9wgADcHwiIieDMIOKBA/QRCBEg +EQgRAiINj/kE6LoJD/WOCk/53g+P9wTKkODMIIKPAACzAA7yCiHAD+tyARIENpLYjbiKI40GVQav +9AolAAXuCqABANjtBi/zocDxwMIOD/MMzADeewgeAM9woADIH7AQAgDPcYAAlBwjgQLiRhEBAWG5 +CCJBAD6gENkuoAHZFRhYgM9wgQAIFQMaGDDPcIEA0BWiDaACBBoYMM9woAD8RCWASiBAILy5JaAM +zIYg/4HPcIAAFAYAgMIgASSA4KQMgv0EII9PMAAAAB3wNwheA04Oz/7PcKAA/EQlgLy5JaDPcIAA +/DMOgIwgAo2I93IJ7/UZ2L4P4ADJcAzMMwjfA8l3GnYA2M9xgAB4NAyhz3CAAAgbEIAAgA6hUPBG +Ce/1GdiOD+AAANgB3kjwBNjPcaAAyB8GGhgwH4GA4IogDADKIIIPAAAAAg6hA9gVuBIZGIC9AgAA +DBIBN0sIXkUGyIYg8Y8h9M91gACIMogVABYEIb6PAAAAUAHgiB0YEATyBNgMGhwwlg3P/s9woAD8 +RCWAvLkloGsVABaDCIWPAAC0AAHeDMzRCB8B4wifAYYg/4Wt8lEjAMB79AbIBCC+jwOA6FPK9ZEI +X8WODW/6AN7PdaAAyB83CBAg/4WgFQAQCScAEOTgy/bPcIAAmMkAgA8IXgDepWIPoAAQ2OTnx/dA +FQEWMHlCCW/6ENiKIAgAoB2AEw6lH4WF6IogBAAOpe4MAAEv2JW4Eh0YkM9wAQDA/BUdGJCqCYAC +z3GAAHg0DIFNgQgiAAANoc9wgAAIGxCAT4FggA6BAnsAyggiwgCI4E+h0/QD2c9woABALTCgABqC +M87wDcxTIECAoPMEyAMSATYDGhgwBBpYMKoLgALPcKAA/EQlgLy5JaDPcIAAFAYAgIDgvAqC/Yjx +EQhfxQzMz3WAAIAzQQjeAIDYDBocMA3MEQjeAh2FAeAdpQDeBfAVhQHgFaXPcIAAzDERiFEgAICg +DmICyiBiABHvHIUB4BylDfCKIAQADBocMBSFAeAUpQXvG4UB4BulDMx5CN4BDcwEIIQPAAAAGDsM +gA8AAAAIZg2P9w3MRwjeAM9woAAsICWABoAK4S8IRAADEgE2AtgMGhwwUNiiDS/+mBEBAJ3x3grv ++MlwDwgeAAjYm7gGGhgwKvEE2AYaGDAm8QPIoBAAAPC4ANg+8s4OD/gA2Ja4OvBPCB8CcwhfAgQg +vo8AAABQDPIZCx5AiiEEAM9woACwHzSgBNgGGhgwDczvuATzz3GgAKggSIHPcYAAtMsvkTBy9AXF +/6+48QXv/w0aHDA2Du/7iiAEAK4Mr/cA3QPIoBAAAPC4qXAG8loOD/gA2JW47guAA7fxTg4v+AHY +ANiQuPjxAeAAGgIwYQMP8/HA7goP889wgABoMADf6KDPdYAAQAcBhYYgeY/rpQf0A9iSD2/5C7iN +6AbZz3CAAHgHIKDPcIAAfAfgoBkCIAAA2M9wgAB8BwCAgOAMAgIAAhWFEAMVhhDPdoAAOM1AJpIQ +qHCEKB8AL3MAI4EPgABA1BUhgQEbkTqRQCYRGkAmEBUAJsQQBBQEAXpmQ4LbY0ojQCAf6CEIRQAK +IcAP63LPcAAAeyeKI8YBCiTABM0Br/S4cw/qUHDKIcYPyiCGDwAAfCfKI4YPAACJAcoixgdt9yEJ +BQEKIcAP63LPcAAAfSeKI0YDSiRAAJEBr/S4cw/qUHHKIcYPyiCGDwAAfifKI4YPAACPAcoixgdt +9wyFkOgHhY7oz3CgALAfZBjABM9wgAAIGwiAAIAcHcAUCaXPdoAAlBwDhiWDKKCocIQoHwAAIYB/ +gAAE1DDg9CCBAQOGNLADhiaDKaADhiWTLbAC2AhxQg2v8wDa+gpAAAKNhCgfAC9xMCBCIAONx3GA +AATUMOH0IQEAUyIAAM4Kr/8A2wKNhCgfAC9xMCFAIAAhgg+AADTSI40CuTR5mgzgAFlhag1gAQHY +8gnAACKNQ42EKR8AACGAf4AAhNNVeGyAGwseAM9zoACwH2QbwATPc4AACBtog2CDYqVihoQpHwDC +Ew4Ggb7CG5gDDIDAuFIgAAAbeFV4ACCCD4AAQNQ04jQiQQ4KuTIiQC4opc9xgAB4BxcIXgDPcIAA +FM0gEIAAgeAF2ALyBNgAoc9wgAB8B+CgDIWA4MogIQAYDKH1yiEBAAHY8QAP8wohwA/rcs9wAAB/ +J4ojBwhKJIAADQCv9Lhz4HjhxeHGCHUA2M9zgABAB89xgAA4zc9ygAAE1GKLA/AB4A94w2mEKx8A +MiZOHhkIgwOEKx8AACJODjDm9CYOEOMNgZME8Iog/w/BxuB/wcXgePHAMghP+ADY0cDgfvHAyg1v ++eHFMujPcYAAKJgUiV0IUAA3iQnpz3CAALS7AYAQcQHYwHgU8M9ygAD4kAuKhiD/jB7yz3GAALS7 +YYGkigDYCwtAAyCKCQtBAAHYz3GAAGwHAKEVCFEAz3CAAFA5JoAjgSCBlgvAATkAD/N+Dw/47vHg +eM9xgABEBwCBgLgAoc9xgABoMAWBAeAFoQbZz3CAAHgHIKAA2c9wgAB8B+B/IKDgePHAhg/P8s9w +gABCBwCIz3OAAEMHwIsB3YQoHwAvcQAhgg+AAITTmHAw4vAigAPAuIHgACGAD4AABNQw4PQghQPH +cYAAOM3AfQHm44nPfjkO4xPAq/QgjwMtD0ERFO3wIo8DJQ8fEAHm44nPfhcOwxP0II8DDw9BEQXt +8CKPA+sPHpDAqwOJVw4DEPAigAOELB8AwLhSIAAAG3jVeAAggQ+AAEDUNOE0IUAOz3GAAGAHCrgA +ocdwAAAAGIILT/nPcoAAeAfPcYAAfAcH6APYAKIA2AChBfAG2Pvx+g7P/xEH7/IA2PHAog7P8qXB +z3CAAEAHBBAFAAHdz3aAAHwHqHSEJIaQABYEEBPyTCQAgBwM4vfKICIBAdnPcIAAeAcgoADdz3CA +AFg8oKipd13wXwwRAALaz3GAAHgHQKHPd4AAWDwgj6CmAN6J6c9xoAAsIDCBx3EAAAB9LaA0EAcA +z3AAANhvQMAE2EHAAd1CxUPGRMapcBDZBNoA25hzuHPaDO/32HPAr6l3L/AzDFEAA9iqCm/5C7iA +4A/0z3CAAFg8oKiKC+/3BNjPcIAAeAegoADYAKYA3QHfF/A9DJEAz3GAAFg8AN/gqU8lgQAhoM9x +gABoMAaB4KYB4Aahz3CAAHgHoKDpdYDlWA8BAOlwAQbv8qXACiHAD+tyz3AAAHonAQVv9IojhQLx +wOHFz3KAAEAHIYKlwSh0hCQGkM91gAB8BwAVBRAX8gsNUQCqDY/0CfCFuSGiz3GAAGgwCoEB4Aqh +AdnPcIAAeAcgoADYAKUq8E8NEQAB2kClhiE5jwDYz3WgACwgz3MAANhvBNmwhUDDQcFCwgXyENlD +wQLwQ8BEwADYBtkE2ghzmHC4cAAlhx8AAAB9wgvv99hwA/APDVEAAdhZBe/ypcDPcIAAeAcZDZEA +hbkhos9ygABoMCqCAeEqogHZw/EAEAQACiHAD+tyz3AAAIQnKQRv9IojTgjxwKIMz/LPdoAAQAch +hlAhDACnvFAkDJIvKkEABvJSDa/0TiLABxbwKHSEJAaQFfI+Da/0TiLABwGGz3WAAKQjhiAGAAGm +AIUE6EB4ANgApbUE7/IB2M9wgAB8BwCAgOCW9FEhAIDPdYAAlBx79AKOQ46EKB8AL3AAIIEPgACE +0zDh8CGDAAHZArpmeTR6x3KAAEDUNOIQYgq4CKbHcAAAABi6CG/5SiBAIMMVARYId89wgADsyTR4 +EYiA4B4Jb/nCIAIkgOfMICKgzCAigELyAo7PcYAANNSEKB8AL3ATYc9xgABMBiCRQ4U3C0EAx3CA +ADjNZYAoglMjDwBTIQ0AHw9BEwOIgeDEI4EPAAYAAMQhgQ8ABgAAzCNBgAPyANkC8AHZCYLPc4AA +eAcsphEIXgGG6RiKg+AC2APyA9gAowDZz3CAAHwH0gwgACCggvGA54Dzz3GAAHg0HoEB4B6hePEm +CqAAAdgAhcQQAAYluJYOb/XAuF4Nb/UU2FYLL/sE2B4PAACqCA/6ZPEKIcAP63LPcAAAeSf920ok +gACFAm/0uHPxwAILz/LPcIAAfAcAgIDglfRCC6/0Ad4C2NoKr/fJcc9wgAAgBgCAz3eAAJQcJoCe +EQAGprieGRgAI4dIgTSRUyIAABoMb//Jc3YMIAAA3QLYqXFWDm/zAtoih8IRAAahuMIZGAAAh8QQ +AAYluMC49g1v9alxz3CgALAf2aDPcIAACBsIgCCAz3CAAEAHIqC2DGADAtiKDiAByXDPcIAA4CIE +gCEIngDPcIAAFDAAgIrojg8v+YogzA4NCFEAYglP/w3wANmeuc9woAD8RCGg4HihoM4LoAAA2J4K +z/1Dh89xgAB4BwmCFwheAc9wgABABwyAhegYioPgB9gX8s9wgABAB0KIz3CAAEjNhCofADAgQA4I +6M9wgABABwGAhiA5jwTywKEE8AjYAKHPcIAAfAegoDUC7/IA2AohwA/rcs9wAACDJ4ojTQZKJIAA +MQFv9Lhz8cDhxc9xgABABwQRBADPdYAAfAeIdIQkBpAK8gHZz3CAAHgHIKAA2AClRPAAhbLoiHQC +iYQkhpCEKB8AACGAf4AAOM0N8hAQBQAKIcAP63LPcAAAjSfVAG/0iiMPALYIr/cEgAhxz3CAAGw5 +Eg2AAc9xgABoMAyBAeAMoV4Lb/UU2FoJL/sE2APYAKUB2BLwJQjRAM9ygABoMA2CAeANos9wgAB4 +BwHaQKAA2AClB6F1Ac/yCiHAD+tyz3AAAIUniiPPBkokgABhAG/0uHPgePHA1gwAACoMb/UU2BoJ +L/sE2AHZz3CAAHgHIKAA2c9wgAB8ByCg0cDgfuB4z3CAAJQcA4ANkIYgfw7PcoAAAA4JCJEBIJIn +eIC4ALLPcYAAOM0Fsc9xgAD01OB/B7HgePHAegjP8s92gABAByKOz3CAAETNQiCQAoQpHwAwIEAO +0ghv9imGCHcBhs91gAB8B4YgeY8L9ADY+gwv+Yy4B+gMhoDgzCdhkBj0AIWB4IAIgfQMhoDgzCdh +kAj0z3GAAGgwAIEB4AChBtnPcIAAeAcgoADYAKWf8AKOI46EKB8AACGAf4AAhNMw4PAgQAAA31sI +HgAIhvIPL/YihowgEIBKACkAIIWB4SQIgfQDhs9zgABoMOijEugkhgDaAN8PJ08QBiDAgy8vARAD +pk4ngRcB4vb1JKZIowXZz3CAAHgHIKAE2AClANhl8CCF2wmVATMmQXCAAIA+QCcAcjR4AHgCjoQo +HwAyIEAuUSBAgNwKwQICjiOOhCgfAAAhgH+AAITTMODwIEAAz3KAAHgHBdkRCB4AgLgDpgDYBKYg +pTvwz3OgALAfAdgZo89zgAAIG+iDYIdipmCHIKIA2WqmIKUp8AOGk+gF2c9wgAB4ByCgz3GgALAf +4KUB2Bmhz3GAAAgbKIEggSqmFfARCB8ALygBAE4ggQckpm4Mr/sEhs9wgABkOgHewgxgAMClyXAD +8AHYLQeP8s9xgABoMAeBAeAHoQXYkPEKIcAP63JP2Ae4iiNJCkokgAAhBi/0uHPgeM9woABMLguA +07gpAeACBtnxwOHFz3WgADguR4XPcIAAZDAA2UCgJ6XqDmADINgHhYq4B6ULyAQggA////8DCxoY +MAvIj7gLGhgwC8iQuAsaGDDFBo/y4HjxwKoPz//PcIAAZDAggM9woAA4Liegpg6P/dHA4H7gePHA +Ig6P8lYLL/kB3YDgz3aAAEAHAYbAfYYgeQ9CIACAyiBiAAi4BX0A2LIKL/mMuIDgAdjAeBC4BSB+ +gyLyC4YrCFEAAo4jjoQoHwAAIYB/gACE0zV4LICAuSygz3CAAGgwgNkpoADYC6YG2c9wgAB4ByCg +z3GAAHwHANgAob/wYo5DjoQrHwAvcAAgjQ+AAITTVX0shVMhBIAi9OuGQQ9REE8kAwBSIwMAe3tV +e4C5x3OAAEDULKU04xBjz3GAAGgwgN2poQq4ANkIps9woAAsIAOAK6YCpgTZyvHPdYAAOM2EKx8A +QCUAEzAgQA6uDS/2KYZAJZARG+gMhpnoKIbPcAAAARQIIQAAmSAKAI4NL/Yihgbo/gxAAIoNj/+n +8c9xgABoMACBAeAAoZ/xz3eAAHwHAIcR6KsIEAEKIcAP63LPcAAAgieKI0sOSiSAAFEEL/S4cwiG +Qg0v9iKGC+gF2c9wgAB4ByCgBNgApwDYRfACjoQoHwAvcBllI5EdZSjpI47HcIAAhNMw4PAgQABB +CB4AApUKuAINL/YqhiHoz3KAAIgyGYI4ggJ5BIJFgkJ4OGAijoQpHwA0IEEuFQkEAM9xgABoMAGB +AeABoRPwBdnPcIAAeAcgoATYAKcB2A3wCIZKDC/2IoYKIQCAEgAPACIMQACuDI//jQSP8s9zgABQ +OQaDA4BAgGhw6g9gAVlhQg4v9RTY4/HgePHADgyP8s92gAB8BwCGgeBIDEH0AN3PcIAAeAegoM9w +gABsOUYPYAGgps9wgABQOToPQAHPcIAAQwegqM9wgABEB6Cgz3CAAFwHoKDPcIAAaDCpoALYqXFa +Dy/zCHIdBI/y4HjgfuB44H7geBS4JXjPcaAAOC4GoQaBAQjeB+B+ANvPcaAAwC+lGdiAD9oIuqMR +AIZEeIwgEID88xQZ2ICjEQCGCyCAgPz14H6U4MoiBQCF9whygCLCBM9xoABoLPAhgQAA289yoADE +LGeiaKIMuJ24n7gleAai4H7xwDILj/IIdp4P7/8odclwgg/v/6lxiQOP8uB44cUw2wDdz3CgAMgc +aaAD2s9xoADMFyEZmIBOoaegaqDgf8HF8cDuCq/yANnPcKAADCRYgM91gAA8y61wQSqGB4Yg9w+Y +FYMQKbh2ecBxx3GBAPgTFXkAEYQAz3CAAEASIIBALM4A1X7QYdlhRCCPgFMgjgAEIoAPACAAAMwg +IoAG9IDnzCAhgADYA/QB2M93oADEJ0ArBQaGI/0PUiPDAcUMMwRFu4DmzCAigFzyz3CAAJRS8CCH +A0AuhgMFJsYBBSWAAQV7QR/YkGMOkRAfhRDamrgfpQjYTx0CEM9woADIHEmgB4HPcqAA8BcGogaB +BqIFgQaiBIEGogDYCqKKFQARaLgQeIodBBAAlYYg/4wD9AHYHaISC0ADrejPcIAAzCMggADYArEl +8E4VgBCj6IoVABFMpWS4EHiKHQQQBNlPHUIQGQ7RECsXAZZkuBB4ih0EEAzYLaVPHQIQlgjv+Ihw +CfAFI0MBQR/YkB+Fs7gfpQkCj/LgeBDaz3GgAMgcSaEB289xoADwF2qhpBACAE0K3gIC2l2hz3OA +AAjoRINGoUODRqFCg0ahQYNGoXAQAAEc4FMgwIAE9EAjAAgE8EAjAAxAgFOhTGhAglOh+BACglOh +/BAAgBOhD/BckIYi/4wD9H2hSIBGoUeARqFGgEahBYAGoeB+4cUvgM9zoADwF89yoAD8FyijQBAB +ASqyMYAoo0gQAQEqsjOAKKNQEAEBKrI8kIYh8w+MIQyAB/Q2gCijXBABASqycBABAbyQCOGosr2Q +qLJUEA0BqLJgEA0BqLK5gKejuoCno7uAp6NyEAABOGAQeAiyz3CgAPQHJ6AC2c9woADIHCeg4H/B +xfHA8gqP+KYOj/jRwOB+4HhRIACAz3KAAGAFz3CgAOwnANkK8gDZl7kxos9ygABGBAHZBvAxos9y +gABHBEagBbkweRC5gbmHuYy5JqDgfuB48cBCCI/yz3WAADzLF4XPdoEAmBQLCBAGWBWAEAToGoVb +hQTwHIVdhc9xgADcLyCBEwkfADKFBCGBDwAAABAleCV6z3H+//8/JHgBpgDf4qZEeS2mDtj2De/4 +DqYH6M9xgADMHwIIoAAB2M9xgACoHPYPYAAA2BeFDwgRBQHYAa4xHgIQBPDhrjEewhMdAI/yocHx +wKIPT/I6cQh2SHcWCa/6AN2B4MogQiML9M9wgADAGgCQgeAB2MB4QCgQA8lwhiD8AIwgAoUj9M9w +gAA8y5gQgADnuMogIgAK9AK4FnjPcYEAEAwAYS24wLjPcYAAvAYggVEhgIDPcYAAtMsUeQTyINqt +kQrwmNqrkQbwz3CAAHjLs5AO2gGXQCUBFREJAwCieEggAAAQeAPwANhacADYKnGpc+4OoAOYcAoh +AKAE9NoMAAM6cEwhAKAA2Ej0BSCAIw1xALENcQAZhAQjhw1wIKAolw1wILCMJgKVFfKMJgORHfKM +JgOVJPIKIcAP63IT2Iy4z3MAAJQKiiSDDy0G7/O4c89wgAA8y7QQAQAPgQHgD6HGCSAA6XAS8M9w +gAA8y7QQAQAOgQHgDqEK8M9wgAA8y7QQAQANgQHgDaHPcaAA9AcA2AShAdgacM9xoADIH/gRAgBC +dQIlgBBIIAAAX4EQeD0IhABDh89wgAC4m0KgoNgPoQDYH6HPcIAAPMsckGK4QnAfoQLYFRkYgA0J +ECBRIEDGINgD8oDYDqGMJgOVBvTPcIAAPMsckAnwjCYDkQj0z3CAALTLD5DGCa/5ANmmCs/+DMyG +IPmPEvSMJgORyiAhAM8goQMI8kwiAKAA2M8gIgPKICEBDBocMApwCNwPBk/y8cC6DU/yocEIdyIP +b/oA3RUIUQDPcIAAwBoAkAHdgeDAfQy9z3CBAIQVBIDPcoAAKK8EIIAPAAAAEEUgQQNAwSDAw7gc +ePQiAwDPcKAALCAPgHC7FQjkAADe8Hhwe84I4AMU2gkIHgbJcDjwA9jPcaAA9AcFoYUlAxkNcKCw +DXDAsIoi/w8NcECgz3IAAP//DXBAsAPIz3OBABAMz3KAAJQcEIgCuBZ4AGMtuMC48CIAAKCADXCg +oAPIEIgCuBZ4AGMtuMC48CIAAEKQDXBAsMShVgoAAwHYSQVv8qHA4HjxwNYMT/LPcoAABLAgihLp +wYKigs9xgAC8BgISEAHggc9ygAB4NCuCNL8B4SuiMPDPcqAAxCcREgGGAN/1CZ6BZBIDhmQa2IMC +2RMaWIAvKcEATiGCBxPrz3GAAESRVnnAgaGBz3GAAMSR9CGQAM9xgADkkfAhjwAK8M9ygAB4NCqC +6XXpdhp3AeEqokGADXFAoSSQDXAgsM9xgAD0ywCBBuhCgQ1wQKAA2AChz3CAAJQcA4AIgOu4yiCC +A8ohQgPKIsIDYAjiA8ojAgRTIMAgz3GAALwGIIEUvwy45XgXCZ4AgrgNcQChDXDAoA1woKAd8A1x +AKFKJAB0qCAAA0QmgRAPuVMmABAleA1xAKEivkokAHSoIMACRCWBEA+5UyUAECV4DXEAoSK9EQRP +8uB48cCuC0/yCHYodShwSHFeCCAAaHKB4MoggQMQCCEAyiFBA/kDT/LgeCK5BvDscmCiBOBhufkJ +tYBggM9woADUC22gA9nPcKAARB01oOB+4HhBKYGACfIvJElwqCDAAQQQAgTscUCh4H7xwEYLT/Kh +wQh1SHbPcKAArC8ZgAQggA9wAAAA13AgAAAAAdjAeC8mB/AA2soggQAt8gvMABxEME8gwQMCHEQw +AeAQeAQggA8AAP+/j7gLGhwwz3CgANQLOIBCIQEIgOHKIYwAQCUAEhBxTAkFAwflBCWNHwAA/P/F +fZ29n73scKCgAMHscCCgAdgpA2/yocDxwOHFHgxv+gDdgeDKIEIDCfTPcIAAwBoAkIHgAdjAeAy4 +hSADAQPaz3GgAPQHRaENcgCyA8gA212QDXBAsAPIUYANcECgA8hIEAIBDXBAsGSh2QJP8uB48cBe +Ck/yz3WAABCK4BUAEADegODQ90QuPhcAIUBzHNnF2h7bjg7v/xi74BUAEAHm5w4EkADYlQJv8uAd +ABDgePHAHgpP8iGACiYAkBCJw7jKIcEPyiLBB8ogoQbKI4EPAACqAM8gIQM58oDhyiHBD8oiwQfK +IOEGyiOBDwAAqwDPICEDK/ICuM9xgQAQDBZ4AGHPcYAAVAYtuMC4DKkjhiCRhiH8AIwhAoAM9M9x +gACUHPAhAQC/EQAGgbi/GRgAAYaigAXtAYUD6ACFjOgKIcAP63Ic2Iy4udtKJEAA+QDv87hzCwif +QZoOAAAH6ACFgNkooAGFQHgd8AGGIJAUyBBxyiHND8oizQcd2MojjQ8AAMYAzyAtAyH3Lgqv+Mlw +ogwgAAGFz3CAAFQG3gzgAgyImQFP8uB48cAiCW/yANoId89wgABDByCIo8HPcIAAQgcAiAEcwjOE +KB8AACGAf4AABNQu4PQgQABgwQMcAjAB2AIcgjDPdqAAyB8Tps9xgAAIGwyBAIBCwAiBAIBBwM9w +gADwBQCAgODKIAEHyiEhA8oigQ8AAIQAyiOhBwQN4f/AKyEGz3OAAHgHz3WAAGgwCxIBN16VhNhg +g/YM4AKYd9oIAAOkFgAQE6XlAG/yo8DgeAjZ7HAgoAPZANrPcKAAFAQloAHI7HEAoc9woADUC02g +4H7gePHA4cWlwQhyANvPcKAALCCwgEDBBthBwELDQ8NEwwHYHtmYc7hzACWHHwAAAH0+CqAA2HOV +AG/ypcDgePHA4cWkwc9wgABCByCIz3CAAEMHYIiEKR8AACGBf4AABNQw4fQhwQAA2s91gABoMGDB +z3GAAEzNMCFADsC4ARwCMAmFSaUCHAIwCIVIpQHZAxwCMM9woACwHzmgz3GAAAgbDIEAgELACIEA +gEHAz3CAAIgyPYAJgDhgQ8DPcIAA8AUAgIDgyiABB8ohIQTKIoEPAACDAMojoQfUC+H/wCshBgAU +hDALEgE3z3OAAHgHXpWD2MoL4AJgg9UHL/KkwPHApcHPcIAAQgcgiM9wgABDB2CIhCkfAAAhgX+A +AATUMOH0IcEAANrPc4AACBtjwc9xgABMzTAhQA4B2cC4DRwCMM9woACwHzmgDIMAgEHACIMAgEDA +BIMAgA4cgjAPHIIwQsDPcIAA8AUAgETBgODKIAEHyiEhBcoigQ8AAIIAyiOhBygL4f/AKyEGz3KA +AGgwDBSEMAsSATfPc4AAeAdekoLYGgvgAmCDpcDRwOB+CMiHuAgaGDAJyJu4CRoYMArIChoYMAvI +h7gLGhgwDMgMGhgw4H7geM9xgAAciwCBgbjgfwCh4HjPcYAAHIvgfwOx4Hjhxc9yoACsLwDZqujP +cKAAtA88oBiCwQifBhWCuQgeABqCtQgeAM9zgAAAG0CDAWoPCFEAAd3PcKAAyByxoM91gABHaM9w +oADsJ6agQKOJChEAz3CgAMgcMaA+8BiCbwifBhWCZwgeABqCYwgeAM9zgAAAG0CDAWoPCFEAAd3P +cKAAyByxoM91gABGaM9woADsJ6agQKPgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HiF6s9woADIHDGgAdnPcKAAtA88oOB/wcXPcoAArDEVeuB/IKLxwJhwCiHAD+tyCiXA +B89wAACiGeUEr/NW2+B4z3KAAIgxFXrgfyCi8cCYcAohwA/rcgolwAfPcAAAoxm9BK/zXtvgeM9y +gADAMRV64H8govHAmHAKIcAP63IKJcAHz3AAAKQZlQSv82bb4HjxwKQQAQANCV8GCg1P+AfwINnP +cKAAyBwpoAPZz3CgABAUJaDRwOB+4cUDuDV4z3GAAIw8AmFKJAB0ANmoIMACFiJAAKGAYIAp2BK4 +AeF1eKCg4H/BxeB4z3CAACAGAIChwSaAnhEABoa4nhkYAOB/ocDgeOB+4HjPcYAAVAbgfwSh4Hjx +wOHFz3KAAJQcI4I4iR8JEQEKIcAP63KKIIwOiiMGAkokAADlA6/zuHMggsQRAQZzCV4Bz3KAAFQ4 +IIJCIQGAyiFiAK/pj+gKIcAP63KKIMwOiiOGA0okAACxA6/zCiUAASaCI4FhuKCBz3GAAAgbJIEg +gdW5PWXPcYEAeBQlgQUpPgAndUhw1g/gAEIlgRLPcIAAcDgAJYEfAACIE8IPwABlBA/y4HjxwOoL +D/JAEAEBz3OAAKQGQhACASSzkOFFs8wiLITKIckPyiLJB8ogiQ8AAAcCyiMpD8okaQAsA6nzyiUp +AB8JcgAA3p9xz3WAAASRqCDAAclg3GUB5s9+IKwjCnIAAN2fcs9xgAAkkaggQAJAIAIIqmK8YQHl +r31ArDGAIKMSgNUDL/IBo+B44H8A2OB/ANjxwFoLD/LPdYAAxAbMjQ2Nwr7CuBZ+z34aCO/8DdgG +uIG4EL7FeM9xoADsJwahBIXPcaUA6A8GoQWFB6GJAw/y8cAWCw/yz3alAOgPJoanhs9wgADEBgDf +JKCloNYPr/wN2Aa4gbjPcaAA7CcGoeamRSXNH6emSQMP8uB4z3GAAMAfz3CAAEwGAJBHiSsKAQDP +cIAATgYAkEGJHwoBAM9wgABQBgCIJokPCQEAz3CAAIwjAIAC8ADY4H7geOHF4cYA3TMJ0AcLCdMH +CwkTAADYE/AZCfMHH95OIfwH4HioIIABDyWNE2G+CQhOAKV4A/CmeACiAdjBxuB/wcXxwFoKL/Io +2N4JD/nPdYAArCNAhQh2BCCEDwAA8P8A2GB6QSwBAUCFAdhEJgQTYHpBLIEAQIUC2GB6UyZBEKoJ +L/kA2ECFCHdBKAECA9hgesC5QIVBL0ESBNhgesC5z3EAAIi2z3CAAKgjIKDPcAEAsLtRAi/yAKXx +wP4MT/y6CE/8z3EAALC2z3CAALAj3g7v+yCgz3EBANi7z3CAALQjIKDRwOB+4HjxwLYJL/JQ2DYJ +D/nPdYAAvCNAhQh2ANhgelMmQRBAhQHYyXFgeoYh/Q/PcQAA1LbPcIAAuCMgoM9wAQAAvOUBL/IA +pfHA4cVeD+/5B9i2DS/8CHWuD8//Tg5P/FYM7/mpcMkBD/LgeOB+4HjgfuB48cBCCS/ySidAAAh1 +AN/AuIHgwifCAalxhiH+A0S5qXKGIvEPR7oJ2M9zgADMMQyrEKsOqw+rRCWAExx4DasEJY4fAAAA +DEq+uHbTqwQlhh8AAAAwQi4OA9h21KuxG8IDUyB+gMohwQ/KIIEPAACRGsojgQ8AAHsAyiLBBxzy +Vw8QAER4EHLKIcIPyiCCDwAAkhrKI4IPAACFAMoiwgcM9CR6IQmAAAohwA/rcs9wAACTGobbiiTD +DwUAr/NKJQAAtukKIcAP63LPcAAAlBqH2/LxCw4TASEOUwAKIcAP63LPcAAAlRqN24okww/RB2/z +CiWAAQkOQgEbDVMACiHAD+tyz3AAAJYakNu1B2/ziiTDD1MgAQCGIH8PHHgZYS95BwlDATOrCQmD +ATSrigpgAQDYLgggAKlwcQAP8uB+4HjgfuB4ANkPIQEAL3kTaSV4z3GAAMwx4H8MqeB44H7geOB+ +4HjxwN4P7/EA26HBBLjPcoEAmBQUeB1ikN4aYgGCGL7IpYomBBLPcv7//z/JpQR6gOFAwsolwQAL +8giBBCCADwAAADBCIAWAyiViAE0NEADPcIAA3MkAEAQAyIEEJIYPAAcAAAQmjh8AAAAwLL5hvkEu +BgZAJoATDyICAEDChQ6PAwohwA/rcj7YjLiKI4oOzQZv87h2z3CAABwwB4iB4M8ioQMv8s9zgADc +yc92gAA8y5oWgRADiwshAIAh8kwWgRAA21MhTgBEIQ8DDyODA0K/AN4PJs4ThiH/AwQmDpAA30S5 +BHsPJ08Q5HjKJgEQgOPKI4EDDrtlegPwAYMFekDCz3CAANzJIICLcoYh/gMkuUApgwMgggQhjg8B +AADACybAkBby13YAAABAzCaCnwAAAIDMJoKfAQAAAAT0AYAD8AKArrmvubC5JXgAogAUBDAEJIGP +AQAAwAr0CiHAD+tyRtiMuPUFb/OKI4sJCIUuuUApAgYEHQARRXgIpYogBQYJpc9wgACQywSIgOCK +IAUOyiCBDwAA2AEJpalwANoB3h4JL/3Jc8CtnQbv8aHA4HgKJQCA8cAR8icNkAApDdAACiHAD+ty +iiDNDoojBAWNBW/ziiSDD7YLAADRwOB+ZgsAAP3xGgsAAPnx4HjxwO4Nz/EIdc9wgADkKwmAiejP +cIAAdCspgAzg8CBOAALwAd6KIP8PAKXPcYAAlBwAgcQQAAZpCF8BhgyP+gCljgsv+alwgODKJeIR +ovS6C0/4hugAhYwg/48N9M9wgACwIyCAYHkB2IHgBd3KJSIRkPDPcYAASBIhkc9zgACwBkCDPOE6 +YiGDZOIU4VlhMHAB3cIlThOzfcG9fPADgRiIKQgRAeILj/oApc9xgABIEiGRz3OAALAGQIM84Tpi +IYNk4hThWWHl8c9wgABUOACAz3eAAEiOQiAQgPYKr/rKIGIgAKUBhw8IhQMGCq/3yXEIds9wgAAI +GwSAz3GBAHgUAIAlgUlu1bgFKb4AJ3BquCCFSCAAADBwyiBGAET3AKVKIEAgz3GAAEgSYZHPcYAA +sAZAgSGBPOMB3XpiZOIU4TpiUHDCJU4Ts31TJU2QIvJBCFEgz3CAAFQ4+g+AAM9wgABwOO4PgADP +cIAAGDnmD4AAz3CAADQ52g+AACGHEQmlA8lwFgggAAHZBPDaD4//wQTv8alw4HjxwFYM7/G4cYDg +yiHBD8oiwQfKIIEPAABLA8oj4Q7KJCEAtANh88olAQHPd4AAqDgmhyOBIIHPcoAACBtEgkCCz3aB +AHgUUyJNBTa6ACIQAD1lRYZhuAUqPgAndQIlQBCMIBeHSvfPcIAASI4hgAUpvgAndQAgUCAhDRAA +YQ1QAJsNkAAKIcAP63KKII0OkNtFA2/ziiSDD8oJT/gR6M9wgADcHyyQz3CAAJQcHpATCQAAAiWB +HwAAAAzpcATw6XBCJQEVZg+AAM9wgADEOAAlgR8AAIgTVg+AAEvwhglP+M9xgAAYORLoz3CAANwf +TJDPcIAAlBwekBEKAAAocAIlgR8AAAAMBfAocEIlgRceD4AAz3CAADQ52/FKCU/4z3GAAOA4EejP +cIAA3B9MkM9wgACUHB6QEwoAAChwAiWBHwAAAAwE8ChwQiUBFd4OgADPcIAA/DgAJYEfAACIE84O +gAAKcMm4z3GAAEiOA6EGhoG4SQPv8Qam8cDhxc91gACMODoOoACpcM9wgADAKyCAz3CAAMQrAIAJ +IQEAz3CAANDICIAJIQIAz3CgACwgMICpcHoOoABZYRkDz/HxwM9wgABIjgGADwhRAM9wgAB0KweA +z3GAAOA4IIFCIQGAyiFiAJDpz3GAAEDJLIGK6c9xgAAoyWIPb/cjgQoO7/8C2dHA4H7xwFoKz/HP +cIAACBsEgKCAz3CAAFQ4AIBCIACAyiBiADa9h+jPcIAAcDiODYAAz3CAACjJIYjPcIAAqDjPdoAA +SI6K6SCAQiEBgMohYgAE6SCGreliDYAAz3CAAMQ4Wg2AAAGG7g5v9whxIYYPeB0JBQAKIcAP63KK +IA0D19tKJAAAUQFv87hzz3GAAOA4IIFCIQGAyiFiAAbpHWUjhsm9Cw1AEFoN7/8A2R0Cz/HgeOHF +4carChAAQCLDAyS7w7oC8ADalQoVBDMmgnCAALQ+QCeNclR9IH3AiAEZkgMB4AEQggQBGZIAARCC +BAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIE +ARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAEIjQ4Cz +9cHG4H/BxeHF4cYj6mNqIrvBugLwANo1ChUBMyaCcIAAoD5AJ41yVH0gfcCABBmQAwTgBBACBAQZ +kAAEEAIEBBmQAAQQAgQEGZAAQiNDgOP1wcbgf8HF4cXhxqsKEABAIsMDJLvDugLwANqVChUEMyaC +cIAApD5AJ41yVH0gfcCQAhmUAwLgAhACBQIZlAACEAIFAhmUAAIQAgUCGZQAAhACBQIZlAACEAIF +AhmUAAIQAgUCGZQAAhACBQIZlAACEAIFAhmUAAIQAgUCGZQAAhACBQIZlAACEAIFAhmUAAIQAgUC +GZQAAhACBQIZlAACEAIFAhmUAAIQAgUCGZQAQiNDgLP1wcbgf8HF8cDyD6/xUyFCAE4iDQHPcqAA +FATJggDbDiaCHwAAAAZQccohxg/KIsYHyiCGDwAAxiLKI4YPAACbAsokZgAsBybzyiXGAIDhyiRN +cMoizQDoIC0CTmDPcaAAOAQB4sipHQ1QEBENkBAdDdEQz3CgADgEaKjPcKAAOARoqM9woAA4BGio +2QeP8fHARg+P8bpwenH6cppzCiIAIQogQCHIdQohwCEKJ0CTz3GBAB4MyidiEBJvFngIYUwjAKAE +uIYg/gMFf8ohzA/KIswHyiCMDwAAwSHKI4wPAADuAMokbACIBizzyiXMBB0InkHPcIAABJiA2Sig +DMAD6EB4gfB+Dk//f/DPdoAAgDoBhgDZ5g5v8zjaAIYc2SCgAYYY2SCwz3GAAJQcFSFWAwAWASBT +gQ3B8KjPd4AAtAcoGEAERXmkuSGgANkzGEIA6XEioAohQIMxGMIEMhjCBDQYxAXKIWIAsgpv9wzg +he3PcYAAQJsE8M9xgABgmyOmz3AAAEgRALEY2AKmDQ1QIIogBQIAsQzAhejPcAEAuLgBpwAWACC5 +EAAGLQgeAEGGGtgAsgKmAJGHuACxANgLsQGCrbgBohEMECDPcIAAeC0EgDMaAgApChAgIYYBgZi4 +AaEDgZ+4A6HPcYAAhAYAFgAgABkEBECAAYBBoQKh3gtv/8lwGQaP8eB48cDKDY/xunB6cfpyCiIA +IQohQCHIdQokwCEKIECDz3KBAB4MyiBiAAhxArgWeAhiTCMAoAS4hiD+AwUgUADKIcwPyiLMB8og +jA8AAL8hyiOMDwAAlgDKJGwADAUs88olzAQMwIzoCiHAD+tyh9gGuJfbSiQAAPEEL/O4cxUInkHP +cIAABJiA2SigDMBAeGfwz3aAAIA6AYYA3+lxUg1v8zjaAIYc2SCgAYYQ2SCwz3GAAJQcFSFWAwAW +ASAzgTMYwgPPd4AAvAcQGAIEpLmNuZm5IaDpcSKgCiFAgygYAAUxGMIEMhjCBDQYxAXKIWIAHglv +9wzghu3PcYAAQJsF8M9xgABgmyOmpNgAsRDYAqYLDVEgpNiMuACxz3CAAJQcGZCOuI+4AbEMwAGn +KQoQICGGAYGYuAGhA4GfuAOhz3GAAIQGABYAIAAZRARAgAGAQaECoX4Kb//JcLkEj/HgePHA4cXP +dYAAmDUAjYwgw48P9M9ygAA4OAaCA4AggMdxDwAAoDYIoABIcP7YAK3VBI/x4HjxwFoMr/EA2M91 +gQDQDkokAHSA3qggAAUIcQHgTyDCARYlQxBHq4oiCAACuTZ5x3GBABAMQKEA2kKxxqnA2H8dAhDP +dYAA9AbArc9wgQCQC4DZCgxv8yhywa3PcIAA+B/ZqM9wgADoHF0Er/HFqOB48cDmC4/xocEIdwoO +L/QY2M92gACIMgGGq+jPcKAA1AsYgADdQiAACIDgyiBMA4wgCIVI98EWABYB4MEeGBAb8J3YABwE +MAvM6XECHAQwAeAQeAQggA8AAP+/j7gLGhwwAMAe2ioIIAAYuqGmA/BhuAGmGggAAADYHg9v+UAm +ARLNA6/xocDgeOB+4HjxwFILj/EIdxpxOnLPdoAAlBwDhs91gACIMhSQELh2CC/4AqWA4MogIiDP +cIAA8AUAgIvohSEIJE8hQCefuOxxAKHscOCgA4YIgA0IHgAChYG4AqXPcIAAUAYAiIToAoWDuAKl +z3CgACwgEIDPc4AAEDRyHRgQSiTAcADYqCDABc9xgAAoBiCJgOEM2soiIQBEKL4Dz3GBACgaJ3Iz +IYIAQCMBAxlhAeBAqUAlDhIuDi/0yXAPCBAgIoUA2IC5IqUD8Iog/w/PcYAA8AUggWcVDxZoFQQW +lOkA2wjw7HIgogR5BB5QEAHjjCOCgCCGuPfPcqAA1AstoiR4AKZnHdgTaB0YEQDYrQKv8dwdABDg +eGUG7/8A2OB48cBCCq/x2HA6CCAAAN3JaCsOEhD4cKl3MiaAAxUIEgwRCJMOjg7P9DJvOHgFfQHn +QidHAOUPdYBhvnECr/GpcAhyA/AB4CCI/ungf0J44HjxwPYJj/HPdaAA/EQdhTmF7g4gAgDeANie +uAGl4HjBpcWlQQKP8eB4z3GgAMg7DoGIuA6haSBAAP7x4HjxwM9wgACUHAOAGIgdCBEBCiHAD+ty +iiAMDoojhQpKJAAAEQEv87hzugsv9APYz3CAANDIABAEABkMEQAKIcAP63KKIEwOiiMFDOkAL/O4 +c89wgADAGgCQgeAB2MB4DLgpCIEPAAAAEM9woAAsIBCAz3GAAOQrAqEC2AOhz3EBAAgz5ghv/wHY +0cDgfvHAJgmP8c91gABAyS+FSiAAIIDhyiHBD8oiwQfKIIEPAAC+IcojgQ8AAEgAyiQBBHQAIfPK +JcEAz3CAAMIaQIjPcIAABJhgeUigPB0AFAoLL/QC2DUBj/HxwNYIj/GSDGAACHXPcaAAyB9FhQzo +bhEOBgKAZIXEekV7bhnYACKFAKEL8G4RAAZEeG4ZGAAc2Bi4FRkYgAUBj/HgeIDgAdnAec9wgACU +NeB/IKDxwH4Ij/HPcIAAqCMggKLBYHkE2IDgqAIBAM9xgAAAGwCBAeAAoRcIUQAB2c9woADIHDGg +3gwgAihwOg5v+QXYz3WAAHQvDqXPcYAAABsAgQHgAKEVCFEAAdnPcKAAyBwxoLIMIAIocAPYCg9v +8qlxBNgCD2/yIm0F2PoOb/IkbQrY8g5v8iZtD9jqDm/yQCUBEjbY3g5v8kAlgRI32NYOb/JAJQET +ONjKDm/yQCWBE893pwAUSAiHz3GnAJhHBKUNh89yqwCg/wWlDofPdqAA7CcGpRyBB6UXhwilFocJ +pRiCC6UZggylGoINpc9wAwDGAwamxtiQuAamz3AsAAIBBqbPcFkAQgEGpoogigAGps9wQACHDQam +z3DRAMINBqbPcMAABw4Gps9wgAAAGwCAz3KAAAAbQiBAgACiBvTPcqAAyBwA2BGiAdgIpwDYDacO +p89wUAD/AByhANgXpxan/NnPcKsAoP84oHzZOaAagM9xqwCg/4C4GqHPcCoAAg4GpotwGgwgAIHB +AMHPcIAAyIw1pTKgAcEvoM9wGgACDgami3D6CyAAgcEAwc9wgADIjDalM6ABwTCgz3AmAAIOBqaL +cNoLIACBwQDBz3CAAMiMNKA3pQHBMaDPcIAAABsAgAHgz3GAAAAbAKETCFEAz3GgAMgcAdgRoRoL +AAIBlRC4hSCEAAamApUQuIUghQAGpgOVELiFIIsABqYElRC4hSCPAAamBZUQuAUggA8AAIINBqYG +lRC4BSCADwAAwg0GpgeVELgFIIAPAAACDgamz3CAAAAbAIDPcYAAABtCIECAAKEG9M9xoADIHADY +EaEEhSuFCKcFhQ2nBoUOpwiFF6cJhRanz3CrAKD/OKAshTmgLYU6oOoIb/kOhc9wgAAAG89xgAAA +GwCAQiBAgAChBvTPcaAAyBwA2BGhKQZv8aLA4HjxwL4NT/F+CAAAz3aAAMQ6Agsv9wCGCHUAhhkN +ABAmC2/7qXCSCa/7oKbSDy/0EdhuDU/2z3CgACwgMIDPcIAAnAbpBW/xIKDxwLoP7/+hwc9wgACc +NQCABNli2h7bQMCLcLIJL/8Yu6HA0cDgfuB48cB2D+/zFtgA2NHA4H7gePHAOg1v8QfYJgtP+Qh3 +z3CgALQP3IDGDi//ANh6DI/7z3WAAJw15g+v+wClQIXPcYAAsDoAoc9xgAD8M0qhbgxv/Auhlg4v +/8948g8v+elwz3CAANQaAIg3CFEAQIWKIEQEz3WAAMQaI4UaYjhgEHIB2cIhRQAE2AXp5gyP9ACF +BPDODI/0AoVGDuABA6UVBU/x4HjxwM9wgACUNQCAnOi2D2/4FtiY6M9wgACoIyCAYHkE2BDoz3CA +AJQjYIDPcQEA5NML2GB7BNrCD+/zFtjRwOB+z3GAAJQcAIHEEAAGDwhfAQGBxBAABhUIXgGODi/0 +E9iGDi/0Edjs8erx4HjxwM9wgABQFgCAz3GAAJwGG3jCDO/0IIEI6AHZz3CAANQadg/v/yCo0cDg +fvHADgxP8Qh3fdgNuM9xgQB4FMWBlg1v8clxjCACgM9xgABUFgDdh/cdeIwgAoAB5Xz3AChCAwUq +vgPPcoAAUBYWuAChz3GAAJg1ABpADoTv/9gAqQCJjCDDjywPgf8ZBE/x4HjxwJYLT/E6cHpxSHdo +dgokACEA2s9xqwCg/1mhB9gaoVihHgggAgHYGdnPcKcAmEc6oBYO7/se2M9ypwAUSB2CvoJsEhAA +cBISAACnoKb3uMUggg8A/wAA0yDhBfe9xSWCHwD/AADTJeEVSg1v9oohEAAIdqlwPg1v9oohEAAI +dUAoACIuDW/2iiEIAAh3QCoAIiINb/aKIQgA0XkZ4Sx5L3GxehniTHovcgAZgCMPD2IQABtAIwDY +BPD/CIOAAdgpA2/xABwCIPHA5gpP8Qh1KHZuD+ABCtgB2M9xpwCYRxqhXg/gAQrYz3CmAJw/ZBAE +AFEkAIDKIcEPyiLBB8oggQ8AAL8ZyiOBDwAAuAAYAuHyyiUhAM9wpwAUSCyAHYAApve4xSCCDwD/ +AADTIOEF6QJv8QCl4HjxwJ4M7/MG2H4LT/zPcIAAlBwDgBiIHwgRAQohwA/rcoogDA+KIwYLSiQA +AMEB7/K4c89xgAB0KwmBCwgVAQHgCaHPcYEAeBQGgUYgQAEGoc9wgACQBiCAFQmRAIogRg8ODO/5 +BNpmDe/5BNjRwOB+8cDPcYAA5CsJgQHgCaHPcYEAeBQGgYK4BqHPcIAAHDADiIDgOA6h/sogoQAm +De/zBtjRwOB+4HjPcIAATRMAiBsIUQDPcaAArC8ZgfC4GYHPIKIDzyChAhmh4H7lAy/0EdjgePHA +z3CAAJQcA4AYEIQAHQwRAQohwA/rcoogTA+KI0cK+QDv8kolAADPcKAALCAwgM9wgACUNjoNIACW +IUEPz3CAAEDJDIAS6M9wgADAGgCQgeAB2MB4DLgRCIEPAAAAEMoIIAAA2CDwSgpP/M9wgABsEwCA +lujPcYEAeBQGgUYgQAEGoc9wgACQBiCAFQmRAIogiAQGC+/5BNpeDO/5BNgaCw/60cDgfvHAz3CA +ABg5AIBCIACAyiBiAIjoz3GAAOQrCYEB4Amhz3GBAHgUBoGCuAahGgzv8wbYz3CAAEDJDIAY6M9w +gABcKAKAEujPcIAAwBoAkIHgAdjAeAy4FQiBDwAAABCmCCAAANjRwOB+z3CAABwwA4iF6OIMr/4C +2Pbx9vHgfuB48cDPcIAAlBwDgBiIHQgRAQohwA/rcoogzA+KI8oFSiQAANEHr/K4c89woAAsIDCA +z3CAAJQ2EgwgAJYhQQ/PcIAAkAYggBcJkQCKIAoIJgrv+QTaegvv+QTYAdnPcIAAXCgioM9xgQB4 +FAaBRiBAARoJb/wGoR4KD/rRwOB+4HjxwM9wgACUHAOAGIgdCBEBCiHAD+tyiiAND4ojig9KJAAA +UQev8rhzz3GBAHgUBNgGoc9wgABcKAHZIqDPcIAAHDADiIDgDAyh/sogoQD6Cu/zBtjyCu/zCNjR +wOB+4HjPcIAAlDbxAgAA4HjxwNoK7/MT2M9wgAAIGwSAIIDPcIAAvBEgoNHA4H7gePHA4cXPcIAA +xJsDgM91gQCsGxEIXgAE2L4PL/YEpRzwA9gEpQDYCK3PcIAAJK4SD+/y1NkAhQToYbgApX4OT/4B +hQHgAaXPcKAALCAQgEIOb/4FpY0HD/EIcgDYxQAv9xDZ4HgIcgHYuQAv9yDZ4HgIcgLYrQAv90DZ +4HgIccEAL/cA2AhxuQAv9wHYCHGxAC/3AtiVAE/y8cDPcIAAlBwDgBgQhAAdDBEBCiHAD+tyiiCM +D4ojCQMtBq/ySiUAAM9woAAsIDCAz3CAAJQ2bgogAJYhQQ/PcYEAeBQGgUYgQAEGoc9wgACQBiCA +FQmRAIogiQdyCO/5BNrKCe/5BNiGCA/60cDgfvHAz3GBAHgUBoGCuAahz3CAABwwA4iA4KQKof7K +IKEAkgnv8wbY0cDgfuB48cCGCe/zFNiyDI/y0cDgfvHAdgnv8xTYZg5v+QTY0cDgfuB48cD/2c9w +gACYNYIJr/8gqMoJz//RwOB+8cDhxQDdz3CAAIwjoKBGDW/2qXCKIP8POg+v8qlxVQYP8eB4kQRP +9/HA0g0v8UokQADAgaCAAd/RdcIkAgHRdaGBYYDCJ84TAd6xc8B+sXMB28IjzgBMJACAzCYikMoj +YgAK9IXrgObMJyKQA/IC2wLwANsU6yELUAA5C5EAoIDAgQGAIYECJY2ToKIDIEAAAaIQ8ADYAKIB +ogzwoIHAgCGBAYACJY2ToKIDIQEAIaKxBS/xaHDgePHA4cUmgECAQiICgMoiYgCA4sohwg/KIsIH +yiCCDwAANhHKI4IPAAB3AMokIgCQBKLyyiUCAWCBFQtAAEKAooNCfQ0NUxBgg/ULQYBBgwGjYKBB +oACiRICmgEAlAxYXCl4ARoUG6qKCQoBCfQcNUhAAo0SApoBAJQMXFwreAEeFBuqigkKAQn0HDVIQ +AKNBgAsJgQDeC6//BoAhBQ/x4HjxwKIMD/EIdgCAQiABgMohYgAA2CbpJoZBhgHfMHIghkGGQaEg +ogCmz3Ct3gIAAaamhsB/BoURDgEQqXBWCCAAAtkGpaaGB4UPDgEQqXBGCCAACNkHpQXveguv/waG +AdipBA/xIIAQccohIQDgfyhw8cAyDA/xCHWKD+//KHYId8Kl4g7v/6lwgQQv8elw4HhAgBUKAABk +ggsjQIAF9ECC9woBgADa4H9IcOB4z3KgAMgf9BIAALzbGLsEIIAP//8A8PQaAAALyGV4CxoYMBUa +2IDPc4AACBsIgwDZIKAMgyCgCYMgoA2DIKAKgyCgDoMgoAuDIKAPgyCgz3AADA8ApBpAAA6iD9gM +uBCi4H7gePHAlgsP8c91oADQG9OFEQ6eFs9wgAC4OUoJAAAPDt4Wz3CAANg5PgkAABEOHhfPcIAA ++DkuCQAADw5eF89wgAAYOiIJAAARDt4Xz3CAAJg5EgkAALzYGLgTpakDD/HgePHAMgsv8QDbCHfP +dqAAyB+kFgAQz3WAAAgb+GCkHgAQAdgTpiiFDIVAgQCAACLCg0ChLIUBIMAAAKEC2BOmKYVNhQCB +QIIAIMCDAKENhQEiwgBAoATYE6YqhQ6FQIEAgAAiwoNAoS6FASDAAAChCNgTpiuFD4VAgQCAACLC +g0ChL4UBIMAAAKEEhQCAcgmv8+lxJIUAoQWFAIBmCa/z6XElhQChBoUAgFYJr/PpcSaFAKEHhQCA +Sgmv8+lxJ4UAoQ/YmrgOpg/YDLgQps9wgACYOZIJj//PdYAAuDmGCa//qXCCCa//QCUAGHoJr/9W +JQAScgmv/1YlABOhAg/x4HjxwDIKD/EIdyDwAIYhhiGgAKEA2ACmz3Ct3gIAAaamhgaFEQ4BEKlw ++g3v/wLZBqWmhgeFDw4BEKlw6g3v/wjZB6UjhmB5yXCuDe//6XAKJgCQCPIDhyCAAoYieK8IUoAC +Ca//6XA1Ag/x4HgP2Jq4z3GgALAfFaEP2Ay4F6HgfvHApgkP8c9ygAA8yz+COnCqwQDYIQneAs9z +gACUHGODdINIEoEAwN1keYYh/w4iuTp9BPAU3QLYihIBAQJ5EoIE4UIPr/UA2poKYAACIE8DA9jP +caAAyB8Toc91gAAIGwiFAIBCwAyFAIBDwAmFAIBEwA2FAIBFwASFwIAFhQAQEgBAEQAGANkfZ89w +gAAomECAAYAAIsKDASBAAEDCQcCLdx8JUSDKDY/yhMEacOlwMgvv/4bCCHcIEAIhC/CCwelwIgvv +/4bCCHfPcIEAeBREkM9xgQB4FGWBBsEEuxcLZABAKoACGwhFAAJ5/whEgAbwhsCCDGAASHEIcUbB +LQ+REH4Pb/PJcAh2SnByD2/zBsEGwlpwBMMHwQXAACLCgAEgQABEwhXwlO+CD2/zyXAIdkpwdg9v +8wbBBMNacAbBBcAHwgIjQ4BEwwMggABFwBkPUBDPcIAAlBwDgBiIhODMJyGQANgD9AHYLyYH8ET0 +yXAOD2/zA9kId0pwAg9v8wPZCHYAwAHBQCDAgEEhAQBBwQTBQMAFwEAhwYBBIAAARMFCCWAARcAV +CREgBIXgoAiFAMEgoAyFAcEgoCUJkSAEheCgCIUAwSCgDIUBwSCgBYXAoAmFBMEgoA2FBcEgoBUJ +USAFhcCgCYUAwSCgDYUBwSCgDQAv8arA4HjhxeHGz3CAAJQcw4DPcYAAXLLPdYAAAHpUFQAWwaHP +coAAVHsA2wKhQCIABgOhZKF0qQjmFIXHoSwZwgAIoUAigAgJoUAiAAsKodAVABDNoUQZwgAOoUAi +gA0PoVYiAAIQocHG4H/BxfHAQg/P8BpwaHVligSKCLtneAC1B4pGigi4R3gBtUGJAIlKIQAiCLpH +eAK1Q4kCiQi6R3gDtQSJJYkIuSd4ANkEtVMhDwAUIM4jQY5acSCOCLpHeSd4ZgogABB4IJVCIVEg +OGAibxB4FCBCIAC1IIpBigi6R3kneEIKIAAQeCGVRG84YBB4FCCBIAG1QIkhiQi5R3kneCYKIAAQ +eCKVBuc4YBB4FCDBIwK1QIkhiQi5R3kneAYKIAAQeCOVOGAQeAO1QY4gjgi6R3kneO4JIAAQeCSV +OGAQeEpxOGAQeAS1AeFjCXWgL3m1Bs/w8cBiDs/wpcEIdgKLKHWYcGTAAIsAEgYBERwCMHlwAhIH +AQQSCAEQFAAx5JIGEgUBACDJAwCRLyFIEgcgQAKSCSAAEHgAIIoBAZUvIogSByCAAn4JIAAQeAAg +xgEClS8miAEHIIABagkgABB4ACAHAgOVLyfIAQcgwAFWCSAAEHgAJQUABJUvJUgBByBAAUIJIAAQ +eB9nBZXwf+d4MgkgABB4JpUhcBB4B3k8eg+5JXpQegAigQIweQAcRDBHlSd6XHkPukV5MHkAIYIB +UHpceQIchDAPukV5MHkAIcIBUHpceQQchDAPukV5MHkAIUIBUHpceQYchDAPukV5MHk/Z/B//HkI +HMQzD7/leTB5OGBpcca5hbkIuQUhwQIgthB4IJUKHAQwJ3gceAi4BSAAAQG2AMABpgHAAqYCwAOm +jQXv8KXA8cAaDc/wosFKIAAgAd/PcIAAoAYAiAsgwIMo8kAozSDPdoAAXLK0fbhmuWYEgCOBTgwv +/wXauGYCgLpmIWgiogLgQcC5Zs9wgABcsqBgIYG+ZmSGi3J+De//EOAA2QAlgB+AAHCyIKj7f+9/ +QCBQIC8gBySbDxGSANnPcIAAoAYgqP0E7/CiwA97SLgPeM9ygAAAVPQiAABAKAECSLgFefQiwAAw +eeB/J3jgePHAz3KAAIg5IIKA4cohwQ/KIsEHyiCBDwAANBHKI4EPAADjBsokIQDEA2HyyiUBAQGi +AdrPcaAAyB9QoUoZmABIGRgA0cDgfs9xgACIOSCBANiD4cwhIoAC9AHY4H8PeAoiAIDxwBfy4g/P +/4DgyiHBD8oiwQfKIIEPAAAzEcojgQ8AANwGyiQhAGQDYfLKJQEBz3CAAIg5QKDRwOB+4HgA2M9x +gADQyAWhBIGguAShEQdv8wPY4Hg2uDa5MHDWIIUPAACAAOB/InjgePHApgvP8AonAJDPdoEAeBTP +dYAAuDkP9M9wgABcUslx4gkv/xTang7v8alwQCUAGBHwGQ+REC4Ij/LJccYJL/8U2kAlABgM8Mlw +Yg/gAAXZqXByDs/xz3CAAJg5Zg7P8QSWCrgFpgaGhiDDDwam/gogAOlw8gzP8ZUDz/DxwADZz3CA +AAgjGgggACCgz3CAAHg2dg6P/9HA4H7geADZz3KAAPgGI6IkoiWiJqInoiKiz3CAAJQ5IKDPcIAA +ODogoDGyMLLPcIAA0C3gfyCg4HjxwM9xgAAIIwCBlOgB2AChANnPcIAAvBG2D+//IKDPcIAAsBwQ +iIPgcAkhAMogYQHRwOB+8cCiCs/wHghv96TBgODECQIAz3CAALwRAIDPcYAA0C3KDu//IIHPdoAA ++AYwllGWWWEwcMogLgDCIE0AQobPcYAAlDnPd4AAODqP6g3oYIcbY2CnYIEbY2Chz3OAAAQzsoMd +ZbKjz3OAAAAGYIMA3QcLUQCgoSCBQ8JAwSCHQsDPcIAA8AUAgEHBgODKIAEHyiEhBMoigQ8AAKIA +yiOhB1gOYf7AKyEGANhiDq/4i3HPcIAA8AUAgIPooKcR8ACHHwgUCkYJ4AEA2ATYz3GAAHB8CHSG +sTC8Og7gAYexz3CAALwRIIDPcIAA0C2iprG2IKCwts9wgAAABqCg0gtv8xPYAIcdCFQBXgggAAHY +Ig+P+s9xgAD8Mx2BAeAdoQXwRgggAAXY5QHv8KTAFdgA2s9xoADIH28ZGADg2JC4EKEJ2LAZAAC0 +GQAAeNhCGRgAANiauA+hpBmAAM9wAAwAGQ6h4H7PcoAAeDYmgiOBYbhggc9xgAC8ESCB1bl5Yc9z +gQB4FGWDBSs+ACdxx3EAAAAQ4QSv/0hw8cDhxc91gAD4BgeFk+jPcIAACCMAgB8IUQDuC8/3FwiQ +Bs9wgAAIGwSAAIAFpQHYB6VRAc/w4HjxwOHFz3WAAPgGB4UZ6M9wgAAIIwCAKwhRALYLz/cjCJAG +z3CAAAgbBIAAgAal7gzv/yWFMJU4YBC1ANgHpQ0Bz/DgeM9wgAAIIwCAFwhRAM9wgAAIGwSAIIDP +cIAA+AYjoOB+8cDPcIAACCMAgCUIUQDPcIAACBsEgM9ygAD4BgCABKKWDO//I4IxkjhgEbLRwOB+ +8cA2CO/wiiEIAAh1z3CgAMgfMKAB2UEYWABWCQAAz3aBAHgUA4YlhtW4MHDKIc0PyiLNB8ogjQ8A +ADURyiONDwAAmwDKJC0AcAct8solDQGqDE/ymgxv8gh3GnCA5cwlYpBK9M91gAAIGwiFIIYgoAyF +IYYgoACFJYYgoASFI4YgoMYND/flCBAAz3CAANwfCIjZCNEBBYXAgACABCaOH8D/AABTIFEFBIUA +gIoOL/MKcdW4RYUFfgLbwKLPcqAAyB9zosmFAiBBhGCGTYVAggoABABCKcAHB/Aklwq5AiFBBBlh +ANgCI0OAAyIBAGCmDYU78HUNkRAEl891gAAIGyGFCrgAoc9wgACUHACAxBAABlEgQIEJhSDyz3GA +ANwfKIk5CdEBz3GgAMgfAdpToSiFANsggUyFAiEBhECCIKANhQMiwgBAoASFAIDqDS/zCnElhQCh +CvAghyCgDYUhhyCgI4YFhSCgLQeP8ADZlrnPcKAA0BszoOB4AwueReB+z3CAALg5J4AG6QOAQIAC +gUJ4BfDPcP8P///gfs9xgACUHCSBKIEEIb6PAAYAAKHBBPQTCR8ACfAEIL6PAAAAGAPyANgC8AHY +z3GmAKQAF6Hgf6HA8cDhxQh1z3GgALRHcREAhgQggA9wAAAAQSg+hfj1iiD/D28ZGIBrGRiAA9oP +us9woADQG1GgBYXPcoAAuDpZGRiABoVAgloZGIAHhVsZGIAJhVgZGIAIhVcZGIAEIIAPAAAAgA8K +HwCA4AbYyiDhAQLwANjPcoAAlBxDgkiCz3OAAGAFIwoeAE8gAgKNupe6RqMFIIIPgABAOkejBSCA +D4AAwFMP8AUggg+AAMAkRqMFIIIPgAAAPkejBSCAD4AAgFcIo4QRAIYJowaFWgzv8yGF+g7v/wGF +CQaP8PHAhg2v8ADaOnDPcIAAzDEMiM92oAC0R0QgAQ5CKdAACnVxFgGWBCGBD3AAAABBKT6F+fVD +FgGWRiEBDUMeWJBXFgGWvLm/uVceWJBfFgGWv7lfHliQANmeuVMeWJDgeFMemJBgHhiQfgkP/M9w +gACoIyCAYHkE2BXoTCFAoJQKofrKIEEDz3eAALw6AI8XDQAQz3CAADglNoBgeQDYAB8CFJYIj/JD +FgCWRSAADZ+4Qx4YkI0JECAjCVAgYwmQIAohwA/rcoogWgqKI40CSiQAADkEL/IKJUAEz3CAAJQc +A4AQvZu9MiCADwAA2AKfvYDgAdjAeA+4pXhfHhiQcRYAlgQggA9wAAAAQSg+hfn1iiD/D28eGJBr +HhiQEvDPcIAAlBwDgBC9MiCADwAA2AKfvYDgAdjAeA+4pXhfHhiQBsiE4JgPIfPKIKEEmQSP8PHA +QgyP8Ah1KHbSDa/wAYCghRC5QS0AFDhgwg2v8MlxELmweDhgtg2v8EAugRKBBK/wKHDxwA4Mr/AE +2QDYz3WgALRHSx0YkADakLp3HZiQAdp3HZiQz3KgAIREGKIA2pG6dx2YkALadx2YkM9yoACIRBii +ANiSuHcdGJB3HViQgNh3HRiQANieuFQdGJAA2Jy4VB0YkM92gAC0Bclwdgtv8hzZz3CAAKgFagtv +8grZyXAhHRiQz3CAADQEEHhJHRiQ7QOP8OB48cCI6M9wgAAklkILb/Ik2dHA4H7xwGYLj/DKCGAB +CHaqDIAAz3GgAMgfCHVA2A+hQBEBBjB56g6v98lwqQOv8Klw4HjxwDILr/BKJAByz3CgAIggAN6o +IEAPdQ7QEaCAz3GAAJjJz3KBAHgU1nloiUeCemLPc4AAZMrUe53tACaNH4AAXMr4jRMPkRDgk/t/ +I5GAvyR/4LMF8AsPURAikSCzANk4rc91oADIHPqFIJPkeSyzBPAskwkJRQNZYQTwrLO5Yokhzw8E +GFAAAeYA2c9wgQB4FAkDr/AnoPHAABYEQAcaGDEAFgVAARpYMQQSgTCc4coiwgfKIIIPAADcDsoj +gg8AAPQK6AEi8sohwg9qDqAADtnRwOB+4HjxwFYKj/AacA3Iz3eAAIzK8CcBEM91gADsyQMSAjYI +GEQgAZKA4A0SATYA3g7yFCVDEIATDgfLDhAQAN6AG5wD8BuEA+AbhAMUJUMQwLMBgj0InwPIs9Ab +hAMQis9xgQAQDAK4FngbYWWTJQtyADhgYbtlsBCKcmh2e3phRZJ5YYbqJpFRIUCA+AgC8g3IACCB +D4AACMrEqcyp1KnPcYAAmMkWeRR9IpHAHYQTFX94HUQQAxIBNsCnAYEEIIAPAAAAYC0IgQ8AAAAg +EInPcYEAEAwCuBZ4AGHtuMomYhDPcIAAzBvUeCCQEOEgsAPZz3CgABQEMKDqCOABCnA98HASDQHg +EwEBAiFOAxENhBPCfaJ4EHiAGxwAz3CgANQHDxAOhgDd8BuEA3ASAgHAG0QDQnkweeAbRADQEwEB +AeEwefATBQHQG0QAUyV+gMohwg/KIsIHyiDiDcojgg8AAOcNyiSCDwAA/gBsACLyzyAiAwPZExhY +gEUBj/DgePHA1giv8ADYz3GAAGA6AKEMzM92oADUB1EgAIAD2CAeGJCjwVLyFB4YkAMSATYAFgRA +BxoYMQAWBUABGlgxBMqc4MoiwgfKIIIPAADcDsojgg8AAPQKBAAi8sohwg8ocIIMoAAO2QMSATYQ +iVMgwgCGIP4DRLhQqcQZAgACus9wgQAQDFZ6QGDPcoAAlBwtuMC48CIAAASiuRACBs9wgACYyUCg +DxYAlrQZBAAGyP4M7/UNEgI2AxIBNpIRAAH+Ca/7lBEBACrwSiRAABQeGJEAFgBABxoYMAAWBUAB +GlgxBMqc4Mohwg/KIsIHyiDiCcojgg8AAGYCYAfi8c8gIgMDEgI2tBIAAQ8eGJCUEgAADQheAhII +z/cDEgI2DRINNs9wgADsyRQgQwMok6Hp8IrPcYEAEAy1eAK/9n/hYZgSDwAtue6g9qDAuc9wgADM +G/QgQQC8GkQA0BMAAQQhgQ8AAPD/w7gleNAbBAAF8NATAAG8GgQAAdigGgAAbgxv+/CKgOCoAyEA +AxINNgbIUSCAgZwDAgAhhREJngaQ2JC4jQMgAKAdABACv89wgQAQDEAgggP2f+tixBWCEBEKwACR +2JC4aQMgAKAdABBqhc9yoAAsIPCCjCP/jw3yYn8XD4UfAIAAAIfYkLhFAyAAoB0AEPCNAr/2f+Ng +BCO+jwAAABP4YDnyEwteAovYkLghAyAAoB0AEFcLHwMFkJboB8gEIIAPAMAAABUIgQ8AwAAAEdgU +uPkCIACgHQAQiNiQuO0CIACgHQAQpBUAELS4pB0AEJIVABGnuJIdBBCeFQARp7jNAiAAnh0EEIXY +kLjBAiAAoB0AEGKQMxWAEE0LDgAHyAQggA8AwAAAMQiBDwDAAAAIjSkIUwCkFQAQtLikHQAQkhUA +Eae4kh0EEJ4VABGnuJ4dBBAK8BEJngGN2JC4bQIgAKAdABAGyFEgAIAYAgEAUg+P/wMSDTYIcqgd +ABDPcIAACBsEgLAVBxEggFUnQAbVuc9zgQB4FAsJBQAF2AejBYMieIwgCYbKISUApBUAEAkhgQDy +uKwdQBDn8pgVgRDDuQfIPHkEIIgPAQAA8A0SBDbPcIAAmMkWIAABZZCsFQAQQSgIEwkgzwB+FQAR +gBUDERtjz3CAAJQcBIBGEAABG2MIJ88QYn+YFQMQ6LsA2IfyRCMABgQjgQ8GAAAAI7gxuQHgOGDP +cYAAAFYyIQYABCOFD8AAAABBLYUFMiFAAUErgQJSIQEAwLkDucBwGOGF4MohjQ8BAIkN1SEOAKQV +ABBJCB4FIn+EFQERAidAEEggAABCuEErQQPAufRp9H9occa5SSHBBTR/z3GAAGRN8WENC94CQSkD +ARQjQQAFKT4AQSkAcgDZWfBBL4UQQStPA8C/BL/0f2hwxrhJIMAFFH/PcIAAZE3wYA0L3gJBKA8B +FCcAEAUofgFBKQByhBUPEflhQStPA8C/EOEEv0EphQD0f2hxxrlJIcEFNH/PcYAAZE3xYQ0L3gJB +KQMBFCNBAAUpfgFBKQFyH/BRI0CCyiECABv0A+fPcIAAPE3wIEEAIr8FKf4DL3BTIAMAeGCEFQMR +HXgn4yK7BSn+AC9xUyEDAHlhPXnPc6AAxCwvoy6jQCgBFp65QCwPBeV5JXjAHQAQCqPPcYAAuDAB +2AChBfBPgrAVBxEPCsUBBdgYuKAdABDPcIAAfAZBgCCVCSGBAACIEQhRABkWAJYQcQDYA/cB2Izo +A9gYuKAdABDPcYAAgDMTgQHgE6GgFQAQBCC+jwEBAAAU9JIVABGUFQEQkBUCEbIVAxF2C6ABSiRA +AAMSDTagFQEQJXigHQAQBCC+jwEBAAAF8k4ND/YLA0AAA8zPcZ8AuP8YoQbIUSAAgMohQQPKICEg +c/KkFQAQXwieBM9xgAC4MACBgOAA3i3yANgAoX4VDhGAFQARz3GAAJQcJIHYYEYRDgEeZgMJnkXP +cKAAxCwLgFMggQT+uMwhIoAJ8pgVABDWCC/1ANp0uB5mAvAA3gMSATYI8A3Iz3GAAJjJFnnFkalx +SiAAIM9woADIH6wVAxCI7qQVAhCxuqQdgBAE8AkjgwMD2hi6T6D4EAIAoWoII0MDQnugGMAAANqY +uk6gC+6kEQAA8bgNzMUgogTPIGEADRocMAGRCOgNyM9ygADsyvQiAAAF6AGBDwieAw3MgLgNGhww +Nggv+yhwAxICNrySRCUAE9UIEAENyM9xgADsyRR5wBEAAWGCpXgcshcLXgNUEgMBvBINAcO7pXtU +GsQAhiD9DIwgAoIZ9BCKArgWeMdwgQAQDGWQIwtSAAaQGwheABELUQBgEgABhLhgGgQABfAcko24 +HLIBkiTo0BEDAVQSAAHDu2V4VBoEAIARAQeF6TySirk8sqQSDQAXDR4SaBIDAVMgwQB5YTB5aBpE +ABUNXhJqEoEAw7g4YA94ahoCAAfIz3GAAPzKBCCADwDAAAAPCIEPAMAAAA4ZBAQE8ADYi7gHsQGS +FOgNyM9xgADsyRR50BEAAVMgwIAK8vARAQHPcKAAmAM+oLYaRACkEgAABCC+jwAAADAH9IYg5Y+s +C2IAyiCCACYPwAAF6DYOj/2o8APIpBAAAAQgvo8AAAAwsvL0uEALwfQDEgE2pBEAAJ0IHgMSDu/y +AdgDEgE2HbHPcIAAlBykgHoKb/gA3hsIUQDPcIAAwBoAkIHgAN7PJiETyiYCFAPYz3GgAPQHBaGF +JgIdDXDAsAPIXZANcECwA8hPgA8KHgBChQ1wQKBGlQbwDXBAoAPIQBACAQ1wQLADyFGADXBAoAPI +SBACAQ1wQLAQGQAEA8iUEAAAUSBAgsAIgfemDA/5IwBAAAGBIQgeBs9wgACEBgCQHbHPcIAAiAZA +gAGAUaESoQjwWg3v8gLYAxIBNh2xqg3P/QPI9gyv/3gQAAGA4OIHAgADEgM2AYOYEwEAlBtAAC0I +HgbPdYEACBmpcOIML/locRDYDBocMA3Mo7gNGhwwwg2v/6lwqwcAAJ4TAAG+EwIBkhsEAJAbhABu +C6ABghMDARsIHgYD2c9woAAUBCOgiiAQAH8HIAAGGhgwA8ikEAEAhiHljygKQgADEg42pBYAEPS4 +aAIBALCOz3CBAPAKtnjPcqAALCBPgoQWDxEgkAgiwgPierAWAxFk4+sLpQAJIkEAUm1Wes93gQAQ +DEJnBCKND4ADAAA3vWW9gOXKJQwUBCKCDxgAAAAzug3iSiEAIA8hkSDjiAINL/aYFgAQmBYCEAkg +QQTtusogYiBAKAMhdHtIcMa4SSDABRR7z3CAAGRNcGANCt4CQSgCARQiAAAouLh4A+AEIIAPAAD8 +/89ygQD4FAOiz3KgAMQsDaLsogfIDRIDNgQggA8BAADwLLgYuJ24FLtleAV5KqLPcYAA9DQIgQHg +CKEBCZ5Fz3CgAMQsC4AEII0P8AcAADS9UyCBBAsIngcfDZUQAxIONkogACDPcYAA/DMBgQHgAaEA +2C/wAJYQ4OcIRYCkFgAQ97jVIUIDz3eBAPgUIKeip5gWABBWDO/0ANoBp89xgAD8MwKBAeACoQCB +HWXPcIAAlBwDgAmAoKERCF4ADcxGIIACDRocMAMSDjYB2EogACCSFgERNuiUFgAQz3KBAPgUopLA +gkDAz3OlAKz/z3KAAJQc2KNEglYSAgEU4kJ9A+UivbplumJIIkIABbpFIkIDVqNRIcCByiCCLwAA +gAAgwQQggA8AAAAgJbgFIQEEJXiJuI64GaPuCg/ydwUAAKQWABCnuZIeRBC0uKQeABCUFgAQkBYD +Ec9xpQCs/0DAsBYCEXihz3OAAJQcZINWEwMBFONiegPiIrpbYnpiSCJCAAW6RSJCA1ahIMIEIIAP +AAAAICW4BSICBEV4ibiOuBmhA9nPcKAA9AcloA3ImBYCEM9xgAAkyhV5QKGkFgAQCHSEJBqQGfQE +IL6PAAAACQjysguv/clwKgyv/QPIDfBwFgERz3CgAPQHJ6DPcKAAyBwcGAAEA8ikEAAAUSAAgSwP +gfQDyAGAEQhfBgIK7/IE2AMSATYdsXIOL/gA3hsIUQDPcIAAwBoAkIHgAN7PJiETyiYCFM91oAD0 +BxmFgODKIcIPyiLCB8og4gzPICIDyiOCDwAAbgrKJAIEOASi8colAgQDyByQxXgNcQCxA8g9kA1w +ILADyC+ADXAgoAPIQBABAQ1wILADyDGADXAgoAPISBABAQ1wILADEgE2HJGGIP8MPwgQATOBDXAg +oAPIUBABAQ1wILADyFQQAQENcCCwAxIBNhyRhiDzD4wgDIAJ9DaBDXAgoAPIXBABAQ1wILADEgE2 +HJGGIP0MjCACghv0YBEBAQ1wILADEgE2pBEAACcI3gU5gQ1wIKADEgE2pBEAAGQZAAS4GQIEuhkE +BLe4pBkAAKQRAAAEIL6PAABACAfyAYHwuCgIwvIO8DqBDXAgoAMSATakEQAAhiDzjwTyO4ENcCCg +AdkrpQPaSKXPc4AA3C0NEg02QIMA2DsNgBDPcqAAOC5FggQigg/AAAAAIQqAD8AAAAD12AW4z3Kf +ALj/GqK7omnYGLgZoihwBwhRAKCjz3CgAPxEPYAZgGcI3wIEIb6PAAYAAC304HjgeOB4UwheQwPI +z3GgAMgfsBAAAZYgQQ8eoRDYDqEB2BUZGICiD6AAQdgvCF5Dz3CAAGA6AdkgoAPIpBABAJq5pBhA +AIoNb/8B2M9xgAD0NA2BAeANoVoMAAAEIL6PBgDKAJhwHvLPcIAA3BoDgIDgyiHCD8oiwgfKIOIK +zyAiA8ojgg8AAD8ETAKi8colAgHPcYAA9DQQgQHgWwIgABChA9nPcKAAFAQloAMSATYBgVEI3gCk +EQAAz3KAAJQcUSAAgASCA/K7kATwwgpv97qQz3GAAMwxEYktCB4AEIkjghC4MiGBDwAA2AKfuIDh +AdnAeQ+5JXjPcaAA/EQNoQTwdhENAQ3MUyBAgAnyBsgEEgE2sgtv9Q0SAjbPdoEACBnJcO4O7/gD +EgE2A8gGEhA2z3eAAMgboBARAAHYAKe+Dm//qXAA2SCnCeiGIH6P0/IDyKAYQAQGGhg0AxIBNpIR +AAERCJ4Cqri+C6/6khkEAAMSAjZ+EgEBghIAAYASAwE4YBtjDcjPcYAAaMpwexV5CYF4YAmhAYLZ +CN4Atgzv+IDYBhICNgQigg8CAAEADRIBNxkKgQ8CAAAAEQheB08hwgANGpwwBvCjuTB6DRpcMAMS +AzYBg1sIngFPIsACjLgNGhwwMIsQejMTgADPdYAATLIEuSV4z3GgADguJIEGtRDwLy5BEE4mgxcA +3g8mzhDGec92gADg5/QmzhARCIAD8enPcAAA//8EtQPwZLUI2AwaHDDPcIAAzDERiBUIXgHPcIAA +HDCWCK/9AIgNEgI3A8gBgP24zyLiAdAi4QHPcYAAgDMWgQ0anDAB4BahLfAQ2AwaHDANzKO4DRoc +MIYOb//JcAMSAjYBkgnoDcjPcYAA7Mr0IQAAC+gBghMInwMNyAHaACCBD4AAdMpAqQ3MUyBAgAny +BBIBNoogBAB6Ci/7mBEBAAPIGpAKCe/4DRIBNg3MHwjeAM9wgAD8ygMSATYCgJgZAAAGyD4Nb/UN +EgI2wQAv8KPA8cDhxanBi3WpcM9xgADQPhYJL/Ak2qlw/gzv+AMSATbGDyABqXC1AC/wqcDxwOHF +AxIBNqKBIIWGDi/+JNqO7QohwA/rclnYjLju20okAACNB2/xCiUAAQGFgODiIAIAeQAP8PHA8g/P +75gkwTMacADYThwYMAAWjkAAFoVAABaPQAAWkkALClIhLyIHJEwiAKHKIcoPyiLKB8ogig8AALUo +yiOKDwAAUADKJCoAMAdq8coligRBLQABUyARgCv0WQ0QAKhyhiL8B89wgADcySOIRbpTJc0ARnng +ucogQgPKICEAViTMOQCs4bnKIEIDyiAhAIt0gCREHgCsUSGAgMogQgPKICEAi3SAJIQeAKwF8FMl +/oAm9ADdhCoKIi93ACeCH4AA0LsqcYQpBA8E4gAiTg7JcDILIABI2VYmABkmCyAABtnHd4AAPL4j +hy0JESCBuSOnThQBNiSnJacQ8AohwA/rchC+z3AAAK8obtttBm/xBSbEE4K5I6fPcoAAIAYL7c9z +gABgyCCLfIsLCcEABBoCBACCEIhScMoggQMkCuH9yiFBBJoPT/QFB+/vlSTBM/HArg7v7wDZz3Cg +APxEdBAEAHmABCOCjwAAAAgL9AQkvo8ABgAAB/QDyKQQAADTCJ4Gz3CAAJQcBIDPcaAAyB9GEAAB +H6Eg2A6hDQyeBpYOT/MN8E8MXgbeCY/yAxIBNqAZAACGIH6PA/QA3wLwAd+IcEoLoABocQPez3Wg +ANQH0qUeC0/9z3CAAMgbAICA4MwnIpAD9BMdmJMDyKAQAAAw8AMSATYZDN4EbyBDAKAZAACKIAgA +BhoYMNnxUSSAhADYzyDiBfX1pBEAAAsIngYF2BC47fEJ6s9ygAB4NBCCAeAQovbxCiHAD+tyCiUA +CDLYz3MAACUJMQVv8Yy4KHAVBs/v8cCkEAEADwleApIIz/3RwOB+KHSEJBKQEfINCV8Gjg0P9gfw +INnPcKAAyBwpoAPZz3CgABAUJaDr8evx8cBqDc/vCicAkBpxAN0W8ulxLyhBAE4gggfPcKAADC1P +evAggADCuA8lDRAA2A8ggAAGIQGA7/Uk7S8oQQNOII4HDRqYM/XYBbjyDO/2yXENyM9xoAAUBAqh +z3GgAGQu8CEBANO5CnB2CS/15HkeDe/6yXAA2A8ggAMGJQ2Q3/XPcoAA3C0AggfZDRpYMD8I0AHP +cKAAOC4FgAQggA/AAAAAIwiAD8AAAAD12AW4z3OfALj/GqM7o2nYGLgZowHYAvAA2AcIUQAgos9w +oAAUBCqg/QTP7+B48cDhxc9wgADwzM91gABCB2CNQYiEKx8AACGBf4AAcNDSCi/+AuIgjc9wgABA +B0CQhCkfAAAhgH+AAFTN0QTv70Cw4HjxwFYMz+8odkYhzQAdZUoIIAAiucG+Hw5QEBMOkBAdDtEQ +ABaAQAEdEhAAFoBAAR0SEAAWgEAArYkEz++A4cokTXDgeOggrQEAFoFAARhSAOB+4HirCRAAQCHC +AyS6w7kC8ADZlQkVBDMmQXCAAJA+QCcDcjR7AHsAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFA +BBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAE +GFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAEIiQoCz9eB+gOHKJE1w +4HjoIK0BABYBQQIYVADgfuB48cA2C8/vAN3PdwAABB1KIAAiqXYVIoAzDhABBgDYz3KgABQEyqKo +oieiBKI9ZYjhaLnKIQ4A0grv9ulwQiBQICDn1Qh1oAHmUQPP7+B/ANjxwNoKz+8acM9wgADYOjIg +EgTPcIAAKAbRiBKISiMAIBB2ocFUASkAABzANGp3CiHAJAPwenVELr4TACJALs9xgQAoGjMhDQC7 +fTEIMyatfc9xgABYFBqBO4EkeB0IHgLPcIAAKAYLiItzyXGKCG/3qXIAwAJ9rX0AJoAfgAAoBhwQ +wQDPcoAAnDUAigXa5g4gAKlzz3GAAKg6IIEA3UokgHEieKggAAVzbnR7tXvPcoAA5I15YiGJemIL +6SEJAAAnCEIALw1TEQHlr30K8EIlkRAvIUckYb2vfRHwAxLPAADZanUM8IDlSiEAIMolYRAF8kIl +URAvIUckAdks6fNu9H8VJ0ETz3OAAOSNOmMAI0UAFSdPFPljIYlBivtjNwmjAOOLAiJEAAMVggAE +v/B/IngEui8kCAECJ4MQbHgvIEYOZgvv74hxDngCfwjn7n9Ev+1/CQgSJgrn7X/JcApxegwgAOly +AebPcIAAKAYSiM9+EHbABsz/uQHv76HA4HjxwGoJz+8odYDizCMigAnyLG0vec92gAAoBjOuBvDP +cYAAKAazqalxz3aAACgGtK4ArlWu+gkgAHauABCJAOGIyXASiNGOEHaaAQkARCk+Fy9xhC4DEQom +QA4AIUMOCiWAD4AAXI6gc0ApghBUeoQuARUKJ0AOACJNDgoggB+BACwZACBEEwAmjR+AACgGTCEA +kMwhYpAn9BoTwAAA2RitGxPAAEokgHEcrRiLIB0CEKggAAYUJEAAQYizbrR9NX3HdYAA5I0AEMAA +QK0VI0IAAa0BEsAAAeECrQCKL3kDrXjwARPAAJnoANpYrVytIB2CEEokgHEA2agggAMTbhR4NXjH +cIAA5I1AqEGoQqhDqAHhL3le8Hy5ACGKATqLbLoAIkARGojgcgAiBgLuCCAA6XIYrQAiQBEbiDuL +3gggAOlyHK0AIkARGIg4iwAlhQLKCCAA6XIgHQIQAN1KIIARFCZKAxQkSwMBEoAQAROBEKoIIADp +cjNuNHm1ecdxgADkjQCp+HEAEoAQABOBEI4IIADpcgEfAgAVJUsDFSNKAwETgBABEoEQcgggAOly +Ah8CAAATgBAAEoEQYgggAOlyAx8CAEIgSBAB5ZkIdZCvfQHmz3CAACgGEojPfhB2cAbM/wDZz3CA +AKQ66Qev7yCo8cDPcIAAnDUAgM9xgACgOiCBTWgwcsAgbAHMIQyAJAsJANHA4H7geAJ5LXlMeVYh +AXJHuThg4H8PeOB48cC4cTUIUQAJDVIAHQ3SAwohwA/rcs9wAADXFIojiAKZBi/xSiQAAEAtgQBk +uQAhgA+AAOQOHfDPcIAATBIyIEEBjCHDj8ohwQ/KIsEHyiCBDwAA2BTKI4EPAAAQAlwGIfHKJCEA +z3CAABQRNXjRwOB+4HjxwM9ygAA6BgpqogkgAClqxg0AAM4IAADPcYAAmFYggc9wgACkDSIIIAAB +2s9xgACUViCBz3CAANAMDgggAADa0cDgfvHAfg6P7xpwSHeRCXIAAN06cRUgQCNAiAKIDO/PdoAA +5A4VfgK4FHjHcIAAPA4L8M92gAAUERV+ArgUeMdwgAAcDyGISwkeAAUQwQAirgYQwAADrulwfgwg +AEhxAK6A4MwgYoDKICEAEvJEKD4HACGAf4AAWI7FEIMA4RCBAAIiwAAQeAe4vg+v72J5Aa5CIUEg +gQl1gAHlRQaP7/HA6g2P789wgAAoBhEQiADPcIAAKAYSiKsIAgJKJgAASiHAEUQuPgcvcIQoAxEn +cAAggQ+AAFiOHxHLAAAggQ+AAFiOHhHKAPhwAN4G3wAnjQ+AAFiO1X0HjWlxBdqYcBIKIAAFFcMQ +QC6CAFR6hCgBFQAiQQ7UecdxgQAsGbhxAKmIcElxB9rqCSAABhXDEAEdAgBhvwHmtw91kM9+QiFJ +EEAmRgCBCXWQLyaHAUAgSBDPcIAAKAYSiC8gBxJhCAOCkQWP7+B4AttgqADYAKkB2OB/AKrgeKHB +8cAODY/vocFlwgh2KHXPcIAATgaFwYtyQCRDMIILIAAAiEQuvhYAJUAeFBTBMM93gACokPhgdw0z +FiCoUyWAEE0IUwFGJc0Rr30b8AEUgDAAJoEfgQCYFlJtVHpZYSDCAKlELr4WACVAHkSpFBTBMPhg +IKjJcF4IIACpcQHlr31TJYAQywhSgSHwARSCMBJtFHgAJoEfgQCYFjhgQKggwkSoyXAyCCAAqXEP +8EIlABYPeAEUgTDHdoEAsBcCuBR4HmYgwCiuDK4I3K8Er++hwOB44H7gePHANgyP7wDez3CgALQP +cBAQAMoNb/3JcM9xgAAoBrKJcYklDcIQz3KAAEiWf9gUI88AX2cAr8GvAeNvewXY8Q3jkAKvz3CA +AFiOQZDPdYAAqDrApRrqz3CAALA6AICMIB+E1PYlCIMPAACgD0J4QImA4oohDwrAKOIABfREKL4D +L3B2DY/vAKUA3Q7ez3eAALw8wgjv/6hnYb4B5fcOdZCvfc9wgACcNSCAz3CAAKA6IKAqDW/9LyAH +BOEDj+/geA54LHgpagDYDyBAACdwWnjgfw4gwADgePHAUguP7893gAAoBgCPGgzv/zOPz3CAAJw6 +ABDQAM9xgADAHxSPR4kfCgEAAI8hiRcIQQDPcIAApToAEMAACSAABC8gBSCxjwPwAeWvfRKPEHX8 +AAkAAN5KIoAjz3CAAJ06AIgQ6EQtvhMAJkAez3GAAJw6ABHCAAAggQ+BACgaQKlf8M9wgACoIyCA +YHkA2BkIEQPPcIAArDzJYAIgQCANeEggQAAE8EggQCAvIQUgz3CAALw8y2ATj6lx1gpv9lWPCSBA +BC8hBSDPcIAAqCMggGB5ANgAJZMfgABEBhsIEATPcIAAqCMggGB5ANgEE4EgGwgRA89xgACkB8lh +BBOAICJ4CSBBBAjwz3CAAJw8yGACeQkhQQRELb4TACZAHsdwgQAoGiCoOnATj6lxSg+v/8lyABHB +IAJ5ABlCIEIiUiAB5hkKdaDPfoHxXQKP7/HAEgqP7wh1z3CAAOMjAIgodxMNARDPcIAA4iMAiD0P +ABDPdoAAKAapcEAmgRKWCy/3QCbCEiqOBG6mCi/3S44Kjl4JL/crjs9wgADjI6Coz3CAAOIj4Kgh +Ao/v4cWZ6Iwhwo0B2Fn2SiSAcc9zgAA4j6ggwAOha0QoPgcyJU0eFw1DEAftEwiQAQHgD3gA2APw +YbgPeOB/wcXgeOHF4cYAEc0ACQ0TEADdoKkb6A0NExAA2ACpAN3PcIAAnDsAkAsNAhCpaK19oKnP +cIAA9DoUIE4DoI6gqgARwQA0eAGIGfALDRMQAN2gqc9wgABIPACQDQ0CEKlorX2gqc9wgACgOxQg +TgOgjqCqABHBADR4AYgAq8HG4H/BxeB48cD6CK/vANihwQAcBDDPdYAA4AYAlc92gABYjslxiiIE +Ct4I7/YB24/oCiHAD+tyABUEEc9wAADbFIfbi7s1AC/xiiUECgAWhBBMJACByiHLD8oiywfKIIsP +AADcFMojiw8AAIwAzyPrAggAK/HKJSsAyghP9oDgyiHCD8oiwgfKIIIPAADdFMojgg8AAJIAzyPi +AsokIgDYB+LwyiUiAItxRdgB2loI7/YB24/oCiHAD+tyz3AAAN4UlduLu4okQQGxB+/wSiUAAAAU +ADEB2YYg/g/A4MB5z3CAAEwTIKiFAK/vocDgePHAEgiP7wh113UlAACAANhK989xgQB4FCWBJQlF +AyJ9AeD58c9wgQB4FMWAqXB+Ca/vyXEFLj4QAiVNHowgEIDKIcYPyiLGB8oghg8AAM0iyiPmDMok +JgAwB+bwyiUGARa4HQCv76V4z3GAAHwGDQhRAAHYAKkBqQCJgeDKIIEPAADECcoggg8AAIAA4H8B +oc9ygAB4JiCKGWEgqiGKOGDgfwGqQYkCuBZ4x3CBABAMSKgiieB/KajPcaAALCAwgThgz3GAAOQr +4H8Foc9xgACUHPAhAQCKIAgA4H8OoeB4DRICNgQgvo9gAAAAz3OAAOzJVHvHcoAAXMoIcQXyA8gc +kBcIngIEIYEPYQAAABMJgQ8BAAAAANgAswHYHPAMzAMSATYbCN4BMhGBAAGLDQhBAADYAavz8QHg +AasL8DERgQAAiwsIQQAA2ACr5/EB4ACrAtjgfxiq4cXhxs9ygAAYBoDgwCIiAf/dEmkWeAAggw+B +ABcMoKsA3UokAHHPc4EA+BOoIIACrmJ4ZTZ4xKiuYgHlr33AqMHG4H/BxeB48cByDk/vz3CAAFgW +AIChwZsIkADPdoAAFDDPdYAAGDAAhSCGZQkAAM9wgADgIgSAQMENCJ4ATyEAAUDAiOmKDm/0ANhq +Dk/0Kg9P9s9wgADwBQCAgODKIAEHyiEhAcoigQ8AAKEAyiNhD1wKIf3AK+EFIIYJ6QCFh+hODm/0 +AdgCDk/2IIYgpRHphg9P9H/YCrjPcaAA0BsToX/YEKEA2JW4EKEaCS/yAdg1Bm/vocDxwL4NT+/P +cYAAlBwVeUCBCIIEIIMPgAAAAEQgDwIvuwa/ZX8EIIMPAAEAAEErTgPlfiy7xXvBEg4GwBINBmEL +gAMEIL6PgAEAAB7yz3aAANwfyI4xDtERvrgIokCBCIIEIIMPgAAAAEQgAQIvuwa5ZXkEIIAPAAEA +AEEoQwMleyy4BXvBGtgACu0vKUEDTiGABxIIIAAQJQ0Q+e2JBU/v8cAeDW/vmHAbCBQECiHAD+ty +cdiNuIojjQuBBO/wSiUABEokAHQA26gggA5ALI0BdX1ALIIAx3WBANAPAIXPcYEAEAxWet24QWEA +pfG50SAiggjyRCACBiO6AeIVCpUAz3KBAFAOFiICAUCKCQoeAJ64FPAtucC5z3eAAJQc8CdPEFIg +TgLBFwEWCyGAgwfyKIfhCZ6Hn7gApQHj6QRP789xgACUHPAhAADPcYAAmMm7EAIGuhADBkKhYaG8 +EAIGvRAABkWh4H8GoeB4z3GAAJQc8CEAAM9xgACYyb4QAAYWIQIAApIasQOSG7EIijgZAgAA2OB/ +HbHxwM9wgADwBQCAhuimC2/2VNgD8ADYRCACAhsIHgEA289xnwC4/32hAtvPcYAAWBZgoc9xgAAU +MFEgQIAAgc8gYgDQIGEAAKE9CJ4Az3GAAKw6AIExCgAAz3CAAE8TAIhAoRcIUQDPcYAA1C8AgQsI +UgBquAChAdnPcIAA1BpyDu/9IKjRwOB+4H7geOB+4HjPcYAAeDRcGcAHnbieuM9xoADIHA2h4Hjg +eOB44HjgeOB44HjgeOB+8cAg289yoADIH3CiQxoYAADYyg/v/424caLRwOB+4HjxwEYLT++hwTpw +KHYacs93oAAsIDCHz3CAAHAvIKAQh89xgABwLyCBz3WAAOAtIngApYtxDgpv8CpwAIUTCAUEABQA +McR42w4BkAHYAvAA2FUDb++hwOB48cDPcqAALCBAEgQAQBIFAA8J3wIEIL6PAAYAACDyQQkfA89x +AAAQJwPwQBIFAM9woAD8RBmA7LgCJQABA/TvCEKAHQiCDwAAECcKIcAP63KKIJoKadsdAu/wjLvR +wOB+z3CgAPQH8cBXCB5DJ4AZgDB5OGADuJYgQgXPcaAAyB8eoRDYDqEB2BUZGIDWDu//gdgvCB5D +z3CAAGA6AdkgoAPIpBABAJq5pBhAAL4Mr/4B2M9xgAD0NA2BAeANoQPZz3CgAPQHKqDRwOB+8cAA +2QrYz3KgAMgfHqIQ2A6iAdgVGhiAKHAH8AHZBCCADyAAAABRIADDzCEhgMwgIYAS9CELH0DPcqAA +/EQdglmCANnZCt+CBCC+jwAGAADm9efxLQseQM9wgABgOgHZIKADyKQQAQCauaQYQAAyDK/+AdjP +cYAA9DQNgQHgDaFRIADDANgK9M9xgAB4NBCBAeAQoQDYmLjRwOB+8cCSCU/vCHbPcKAALCCwgAvw +PgtP8M9wDwBAQgoK7/KpcR8IUADPcKAA1AsYgEIgAAhIIAAA3wiEg8UBT+8KIcAP63LPcAAAziJe +24okww+5AO/wuHPgePHAIglv7wHZpcEacM91gAAYBlp1Jg1v/4twABSFMAEUkTALCFEgQCUSEQsN +UgAdDVIBCiHAD+tyz3AAACklrNtxAO/wSiRAAEwlAIAmAQ4AqHAAFo5AABaUQA8MMiR6cIwkw68l +9AAWAEEAFo9AABaAQAAWAEGFDBMkKO/PcIAAQBIAgEAszSC1fRDguGCuDG//BNnPcIAAQBIAgEwh +QKAdZcwnYZMa9ADYjLgX8AohwA/rcs9wAAAqJbfbSiRAAPEHr/AKJQAFCiHAD+tyz3AAACslwNv0 +8QDYALXPcIAAQBIAgEAswSA1eTJgOGAFIkIEQLAE3QfwgcAE3T4Mb/+pcQAijCMAHAIVz3CAAJQc +8CAABB7fwBACBi8pgQACJ0AQJOoyaM9zgQAXDDZ5K2MTC44DACaBH4EA+BMWeQAZAgUALYETCyHA +gAnyACaBH4EA+BMWeQQZAgUQIgKALymBAAInQBDg9UIjQCCA4OYGzf+mCM/zAQBv76XA4H7geOB+ +4HjgfuB44H7geOB+4HjgfuB44H8B2OB+4HjgfuB44H7geOB+4HjgfuB44H7gePHAig8P789wgACE +Ms9xgACQ6M9yAABgIlYOYAAAgMoPT/YuCEAARgsAAM91gACoIyCFYHkD2AboIIVgeQTYhOiSDw/+ +z3CAAAB6AN7JcT4P7/CKIgUFz3CAAJQGwKDPcIAA/QXAqM9woAAsIDCAz3CAAOgFz3WAAHB8IaDP +cIAAoH3AoKlwyXECD+/wiiKEC//YZQcv7xCtUSLA0c9ygAA8ywDZA/I0ksO5H4LPc4AA2C9RIECC +z3CAAAB61SDiDNUg4QQ2eACjIpB7kiUJwgAlC0IAIZB6khkJwgAZC0IAAJA4kg0IQgANCQIACQre +UgHYA/AA2OB+8cCODi/vANm+CSAACHYIdwOQz3WAAJQGz3GAAAhDArVyCSAA6XCS6M9xgAAAQ2YJ +IADpcBHoApXXcAAAgTfMIIKPAACA8wnyA5YI4AO2DpZouA62F/DPcYAAEEMSCSAA6XAulgnoA5Zk +uS62BOADtgjYArUH8C94CLgouS95BXkitclwZgkgAADZz3GAAFSWB7EClddwAACIjmwIofbKIIED +VQYP7+B48cDmDS/vANtLgLKQSiSAcWh2XWVTJUAQTiAEAQAkQgOoIAACARWPFMhhAebneAV7setK +JIBxAN6oIAACARWPFMhhAebneAV7pesA2EwkAIDKJA1x6CAtAgEVjxQOYQHg537Fe5frQCIAAwPw +DOBWIo4C0XDggMCC537Fe0334YDBgud+xXvigMKC534FI4OD7vMA2BbwAYBBggd6BSODgFDl+fVA +JI4AFQ6VEQEVghTIYQHmR3j5DrSRBXvr6wHYjQUP70CJYIgNC4EAQYlhiAkLgAAA2AfwQogCifkK +AYAB2OB/D3jgeECRYJANC4EAQZFhkAkLgAAA2AfwQpACkfkKAYAB2OB/D3jgeAhxz3CAAIQyUQNg +AACA4HhLgAOQWGDgfzhg4HjxwOHFq4ADkLhgOGBIcQ4Lb/1ociEFD+9LgAOQWGDgfzBg4HjPcIAA +hDIAgBEDYAAA2eB48cCODA/vz3WAAMwjAIUA3oToqgkAAAClCegikIfpWg0AAPnxugkAAAClBujC +kFMmDpH6889xgACUBiCBxLkFJk6QDfIvLoETz3GBANQdTiaCF/AhgQBAeQjwzgkAAIDgVA6i8cog +YgORBA/vz3ACAOQiz3GBANQdBKHPcAIAWCQDoc9wAgCQIwKhz3ACADAiAaHPcAIA4CLgfwCh8cDq +Cw/vrpAIdkMNchDjkAuGDODwYA95CLkouAV5LrZAJ4ATDuEDtgNpHw1kEEYg0AAiCCAAyXACJQ2U +AnfUB+//8H8D8ADYArYFBA/v4HjxwOHFDg3v/wh1PgsgAKlwZgogAKlwAQQP7+B44cXhxqCBYIDB +gWd9YIKke6GAp36hgsR9pXuigcKAp36igsR9pXujgAOBB30DgqR4BSD+gAHYwHjBxuB/wcXgePHA +Qgsv77hyCHUod892gACEMphzBfBIcDYKYAAggdoJYAAAhkAlARwbCGUAQIYBgoDgANkE8iCCB4IZ +Ye3pANgW8DIKYABIcBLoMNkgoO6wANogGIIAKBgAAUAgAQwroAYYRAFTsEKwIRiCAD0DD+/xwM9y +gACEMsYJYAAAgoXoQIIBgoPoANgE8ACCJ4I4YNHA4H7xwK4KD+/PcYAAhDIggUCQZ4HAgQIgzwAb +D6ITXWfCfcGBwn0ZDRIQA4EZDQMQeGUJ8GKBI4FifQkNQxBYYAPwANjVAg/v4HjxwM9wgACEMloJ +YAAAgAfoz3CAAJQGAIAD6ADYAvAB2NHA4H7gfwuA4H8LgPHAJgoP7zpwQCATAih2GnJMIwCiyiHB +D8oiwQfKIIEPAAC7IcojgQ8AALIByiTBAIQBofDKJSEAz3CAALQ6AICEKAIlpGgndZEVgBAJCFUE +ANg18EIgEgQvIogkQCWUECpwEg3v/wDZQCUCGC8liAMJJYEEMHk9CVIAAN17bTIkwyBEJY4RABAE +Adp7wbvPdoAADE30Js4QYJIHIwMBCyOAgw/0AuWufQLi1Q1ikALgDCWAhAHYwiALAMEBD+8A2AAg +0CQAGAIgIRGAIGG4D3ghGQIgvvHgeOHFcpAF8ADaUbAB43B7QWkfCsIAS4BtYowlw59RkMAiYQD0 +8+MKkoFysAHYA/BysADY4H/BxeB48cDhxQh1z3CBAFQaAICBCB4ADpXm4HgACwAjlQDagiDBB1G1 +MrUZYTB5og/v/6lwgOAB2An0ApXiuMwlIpAE8qK4ArUA2EkIUQDPcYAAlBypcPYK7/8jgSKVRCEC +ARLoBeouCyAAqXAS6AHYz3GAAHB8CHSGsTC8Ig0gAIexCPCA4swlIpAE8qK5IrUVAQ/v8cDhxREI +UQDGDk/7vg1v+wDYDPAE2ADZKHJCDe//KHPPcYAAzCMAoc91gADMIwCFkgvv/wCAUgwgAACF1QAP +7/HAVggP7wh1Eg7v/0AgEAIIds9wgAA8ywCQz3eAAFSWFwgeAkAmABTpcZIPL/0D2kAmgBII8ARu +6XGCDy/9A9pAJgAUJm92Dy/9A9rPcIAAlAYCkAa3AN4P8AHYLyYH8AAgjCMArAjyIRWAEAHgD3gh +HQIQAebPcIAAtDoggACBLQ4FEIQuAhUncQ6VlRGCABDgGQiEAOlwVG7HcoEAbBo6DO//FOHb6ADY +2vEhFYAQNOgDlQDeAuADtQ6VYrgOtQLwAebPcIAAtDoAgACAQQ4FEDIggCN36M96qXBGDe//cNlx +6AKVDwieANYJIACpcBToAtrPcIAAcHxIcSawMLknsNCoxgsgAEhwCPADlWK4A7UOlQLgDrWhB+/u +IRWAEM9yoACsLxmCANmpuBmiQNrPcIAAdCtBoM9wgADoBeB/IKjgePHACHPPcIAAhDIAgBYOIAAg +gwCD0cDgfvHAAg/P7s9wgQAQDA6Iz3WAAPwFQI0EuIDiyiQicsohIgDoIOICAN4PJk4QCyaAkAr0 +AeEvec9xgACUBgCBobgAoQrwxnpArYYg/gMl2toKL/AA2xkH7+4B2OB48cDhxaPBz3KAACgHYooh +is9wgQAQDKOKABKEAAQjgw8AAMD/Dogl2kIrhQFAwgDbBLiGIf8AQcNCuULDhiD+AwHa2HOwfbIJ +L/D4dQHYzQbv7qPA4H8A2PHABegikKS5IrCaDw/0ygpv/gDYz3GgAKwvGYGJuBmhAdjRwOB+4Hjx +wCYOz+7PdYAAYK8HjQToBo0FrQDeGg8v9slwBY0mjfUJAYDGrcWtx63PcIAAlAZhBu/uAIDgePHA +z3CAAKB7IJBBkAcJgwAhsAYMAADPcIAAlAYAgNHA4H7gePHA4cXPdYAAYK8qDi/2QCUAH74Jz/gA +2FIdBBDPcIAAlAYdBu/uAIDxwJoNz+6kwVoL7/8IdQh2JI5RIQCAz3GAAFR7AJAF8kAhDwQD8EAh +DwJEIAEDFQkRAghxhiH8A4whAoAC2UP2ANkY4ei40SBiggbYAvQA2DhgD3jYYEAgEAKpcHoI7/8u +lQIgBAQglgDYUSHAgS8kCAHKJQEABfIMllMgxQAKJgAHQCQHMelwJG5AJgIUogvv9QpzqXBCCO// +LpWCwV4LL/0I2gTtApWiuAK1AMACwQ8JAQABwAPBEHEB2ALyANg9Be/upMDgePHA4cUIdc9woAAs +IBCAz3GAAHB8R5EGkRC6RXiN6AohwA/rcm7Yjbiy20okAAAlBG/wCiUAAQ4Nz/MF7QKVo7gCtQ0F +7+4B2OHFz3KAANgvYIIc6891gAA8yx+FGQjeBg2FAaMwFYEQMhWAEAi5JXgAswrwEQieBhiVALMa +lQGzG5UCswDYAKLgf8HFz3GAADzLLpFTIcGADPQlCp5Sz3GAADzLP4EEIb6PABgAAAjyANpCsM9x +nwC4/1eh4H7gePHA4cXPdYAAYK9AhQfqz3OAAJQGIINFeSCjANkgpYfoz3CAAJQGAIAE6D4Pb/EN +2F0Ez+7PcYAAPMs/gRUJXgYjkAThI7AukGS5LrDgfwTYHQneBiOQCOEjsC6QbLkusAToIpCCuSKw +CNjgfhMJngYjkAjhI7AukGi5LrD28eB/ANjgePHAlgvP7s9xgABwfGeRRpEQu2V6juoKIcAP63Ju +2I24iiOHCUokAADlAm/wSiUAAM91gQBUGiCFz3aAAMwj6LnGIoKP//8T/g/yFggP9gDYAKUAhmYO +r/8AgG4JT/tiDW/xDdgN8AshAIAghgXyCekCkYO4BPAF6QKRhLgCsYUDz+7gePHABgvP7gh3z3GA +AGzLUSLA0c9wgAA8ywDaBPJUkMO6YImiiQi7BSXQEB+AwYHPc4AA2C9RIECCz3CAAAB6AtnVIOIM +yiFhANUg4QQ6cQO5NHlWeAAhjQ+AAFyyIYATDmQQAKMPDkEQAJALCAIEANgw8AKFHw4BEBSNK+gD +hSRv4KXuCS/9BdoAhcKoANgUrR/wAeDbDgGQFI0bCFAABIUkb+Clygkv/QXaAIXCqAHYFK0fDgN0 +AAAAgOClz3KAAKAGAIoPIEAEKg3v/QCqAdiVAs/u8cAyCs/uCHU6cRpyz3GAADR7DJHPc4AAXLJo +dwHgEHhAIQ4GDLGM6AeByXIB4AehAIMhgxDgugrv/WODAY4qcQCtAY7GuIW4Aa0AjgKtINgDrQGG +AaVDhwpwggvv/alzMQLP7uHF4cbPcYAAoHvPcIAAnDUAgGOZAnsPC3IAQCECAhxrBPBze0S7c3ih +kWCRont4YA54SiTAcQDbqCCAAW1iCQ0DEAHjApEJCwAAYrHBxuB/wcXgeOHFFOlhgKWAhutDgITq +oKAhoAzwQIB6YgsNgRB5YSGgBPBDgDpiQ6AA2SWgJqDgf8HF4HjxwCOABOkmCAAAB/ASCCAAYIAI +IwAA0cDgfuB4QIAhgASAWWHgfyJ4QoAjgACAWWHgfyJ4ANtioGCgY6BhoGagZaAnoOB/RKAhgITp +A4AE6ADYA/AB2OB+QYAXCYQAIoAgoCOAIaAA2SOgIqAG8CJ6QaBAgFlhIKDgfuB48cDhxSh1I4AI +cw/pog/P/zcIRAMZ7UKDI4OmozpiRaMHg1hgFvB+D8//IIMTCEQAC+gQdcogRQMGo0GD8PEA2APp +CwlFAwDYBPAFoweDpqP5AM/u8cCCCO/uCHHPcqAAwC+jEgCGAN31CB6BB8hAGhiADcgNCJEBJgjv +/ihwF/DPdoEACBkKjgfoQCaAEgrhng7v/AraCo4I6M9xgADgNBeRAeAQeBexqq6ZAM/u4HihwfHA +FgjP7qLBSMEacEh1CiEAIWcJXgIC2c9woADIH0kYWIAowVNt7uFQeAX0Kggv8otxGfATCdENG3gQ +eBoIL/KLcRDwCwkRBRx4CfANCZECAByEMAfwz3AAAP//ABwEMOB4ANjPcqkApP+5ogAUATGCuDei +GqJI8F0JHgJMIQCg0SDioUL0z3KlAKz/z3CAAJQcuKIEgFYQAAEU4AJ7A+Miu3hjeGBIIEAABbhF +IEADFqJBKMAhwLh3aCjABCGBDwAAACAluWV4JXiJuI64GaIc8CjAgODKIcEPyiLBB8ogIQ7PICED +yiMhBc8jIQPKJCEAqAYh8MolwQAFvaV4z3GlAKz/FqHPcqAAyB/PdaAAtEdXFQCWAN9KJEAABCC+ +jwAoAADCJAIBbxUAlgQghQ+AAAAABCCDDyAAAAAEII4PAAYAAA8MEABAEgEGCwnUAADZAvAB2dhx +ExIBhgQgvo8AOAAABCGHDwAAAIDMJiGAwCdhEAUjQQEFIcEBBSG+gwT0pw+Ukg0PEACA48wmIZCF +8msVBJaRDBAAiHSEJNCRC/LPcYAAgDMQgQDdAeAQoZy9WvAXDN4Az3GAAIAzEYEB4BGhQt1Q8Ih0 +hCQCmAjyz3GAAPQ0EYEB4BGhDvATDJ4Bz3GAAPQ0BIEB4AShBPBTJD6DBPIA3TjwFwxeAzIMD/3P +cYAAcDUFgQHgBaH08QohwA/rcm8VBZZE2Iy46dt9BS/wjLsI689xgAB4NBCBAeAQoeLxKO4ZCJ4G +z3KAAPQ0L4IA3QHhL6KRvQvwHQheBs9ygAD0NDKCQt0B4TKizgpv/4hxmL1F8HEVBJZvFQWWCiHA +D+tyOdjPcwAAAhEdBS/wjLiqCw/9z3GAAHg0EYEB4BGhsPETEgCG8LjKICEA6Alh/88goQNrFQGW +WBUAlgsgQIAc8m8VAJbPdaAA9AdTIECAAdgM8gml4HgA2Amlz3GAAHA1CIEB4Aihtg/v/QHYA9gK +pQXdmL0D8ADdl+0XCN4hHQkRIAHZz3CgAPQHLKAD2QXwA9nPcKAA9AcloFEggKJoDgL5F/ADEgE2 +z3CBAAgVDwkAAM9wgQDQFRsJAQCSEQABqriSGQQAnhEAAaq4nhkEAM9xgACAMw+BAeAPoc9wgAC0 +uyGAz3CAAJQcA4AUkB0JAQDPcYAAWBQagTuBJHhRIACCmAoi9sogYgCpcAjc8wSv7qLA4HihwfHA +igyP7ih1CHYacgQhvo8BAADAaHct9C8NHhJEJQAWI7ghaAQlgB8GAAAAMbg4YAQlgR8GAAAB13EC +AAAByiChAALwAdghCFAAEwiQAIPgANjKIOEBwCihAwrwz3CAANzJAoAG8M9wgADcyQGABX3JcPoN +r/mpcclwqXEKculz8gvv/0okQACA4NwJQf8I3GMEj+7geM9wpACQQU2Az3GAAFDMQrEagAOxBCCA +D/8AAAAwuASxz3CAAFDMANoRCF5Gz3GAADzLMoELCZ4CQrBDsESw4H9ZsOB44cXPdYAAUMwJpSql +eLVLpQHYGbXgf8HFSiQAegDZqCCAAgDaz3CAAFDMNXhAoAHh4H4AABEAAAAAQAEAAAAAAKgSQ3UB +BgAFAAAAAAAAAACsNYAAQDaAADSJgADsGoAAoAeAAOwEgIEPGhsiAAAbJQIAG0AAABtxD0UAIgBc +ADkHAABiBmAAYgAAWDhgRcAQcEXAEHhFwBCQRcAQbAAAYQgAWG74DwBhAAATJQAAEyQkEMARgAAT +JUdoEyQEKMARAIATJDgcwBEPABMiAQATMAQowBEPcxMiggETMAQowBEPdBMiAgITMAQowBEPdRMi +QgITMAQowBEPFBUiAQAVJg9yEyIIAMwRD0QAIgoAAEAAQABwDgAAYQAAEyUCABMk7BzAEQ92EyIY +CMoRCQATQBwIyhEJABNAIAjKEQ94EyIEAMoRAAABJAAAASUGAABhD3YTIixIxxEPeBMiAADGEQMA +ASQAAAElAAATJcIsEyQEKMARAkYTJAQowBHCXxMkBCjAEQ9FACIAXAA5LAAAZAAAEyQBABMlOBzA +EQ93EyLgHMARAgABYg8BEyIECMAReAXAEgQowBEPEwIifAXAEgQowBEPEwcigAXAEgQowBEPEwQi +AgBxcAcAAGH/ABMlAhATJAQowBEAABMlAAATJMhJxxEGAABhAAATJQIQEyQEKMARAAATJUkAEyTI +SccRD3ATIgEAEzAEKMARAwATJAAAEyUECMARAAATJDhFwBGEBcASGCjAEQ8TAyIEAABhAABYOAAA +EyQBABMlOBzAEQAAFSQAAAAhZAWAgQAAwBYPG1AiaAWAgQAAwBYPGxoibAWAgQAAwBYPGxkicAWA +gQAAwBYAAACFYAWAgQAAwBYPGwQiHAQbZhsBG2gUHMAQCgAbQAQAG24LAABhDxwdIgEAHSb5DwBh +dAWAgQAAwBYFABti7ASAgQ8aGyIAABslAgAbQAAAG3FkDAAQAMAGEQEABCf8AARkAAAbJAIAGyU4 +HMAR7ASAgQ8aGyIAABslAgAbQAAAG3EAABslQAAbJDAcwBHsBICBDxobIgAAGyUCABtAAAAbcRQG +gIEAAMAWAgETZEIBEyQEKMARYDqAgQAAwBYGARNiBAjAEAQAE2QPXAAiCgAAQAAGAHAZAABhAAAT +JAAAEyUAAMAXAAhYMMggwBBwRcAQEAjAEAAAEyUDABMkHAjAERwIwBEAABMkBAjAEQ8UFSIEABUm ++/8wMgMAEyQYCMARDxQVIgIAFSYEADAwAAATJBBFwBEYCMARABBYMA98EyIIAMwRAAATJQAAEyQ0 +SMcRD3sTIgEAEzAEKMARDxQVIgIAFSb/ABMlAhATJAQowBEPFBUiAgAVJtwGgIEAAMAWwiwTJAQo +wBECRhMkBCjAEcJfEyQEKMARD00TIgQQxRECABMk8BzAEQEAEyTsHMARAAATJHAAEyUQHMARAAAT +JQAAEyTgHMARgAATJUZoEyQEKMARAAATJQEAEyQkEMARAAAVJAAAACEPDhoiAABAFgABG3ANAABh +gABjJP/+GzIAAEAXAAAbJQ8bDyLQBYCB/wAbMgIAG0EAGxooAADAFgAAGyUCABtAAAAbcQEAZHAH +AABhAQBjJAAAGySyBYCBAABAF6gFgIEAAEAW7Q8AYQIAZHAQAABhAgBjJAEAGySyBYCBAABAF6oF +gIEAAEAW5A8AYQQAZHAHAABhAgBjJAIAGySyBYCBAABAF6wFgIEAAEAW2w8AYQAAHSQAAAAhAAIP +bgkAAGGyBYCBAABAFgAAGyWuBYCBABsaKAAAABYBABsmAAAAFw0AAGHIBYCBAABAFgIAGyYBEBto +AAAbJAAAQBe0BYCBABobKA8bDiLMBYCBAABAFgEAGyYAAEAXNASAgQ8aGyIAABslAgAbQAAAG3EA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAKA +ALgGgAAAAAAAAAAAACgAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAACQ0RFAoNExcZGRkZCQkAAASYgAAAAAAABJiAAAAAAAAUzYAAoHAAADCAAAAAAAAA +MYAAAIiIMzMygAAAAKqqijOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaAAAAAAAAAN4AAAAAAAAA4 +gAAAAAAAADmAAAAAAAAAOoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAAAKqqCgA+gAAAU4WIiD+A +AAAAAAAwMIAAAAAAAAAxgAAAmplYVTKAAAAAqqqqM4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAA +AAAAAAA3gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAA +qqoKAD6AAABVmJmqP4AAAAAAAFAwgAAAAAAAADGAAAAAAAAAMoAAAAAAAAAzgAAAAAAAADSAAAAA +AAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAAAAAAAAO4AAAAAA +AAA8gAAAAAAAAD2AAAAAAAAAPoAAAAAAAAA/gAAAAAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAA +ADOAAAAAAAAANIAAAJp5AAA1gAAAqqqqqjaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAA +OoAAAKqqqgo7gAAAAHCZqjyAAAAAAAAAPYAAAAAAAAA+gAAAAAAAAD+AAAAAAAAA//8AALQAIAAZ +ASAAtQAhABoBIQAEAAgA1AEDALMBBAB4ADwA3QA8AHkAagDeAGoAqAABAA0BAQCcAcwAnQHMANUB +zADWAcwApAGAAF0CNgBKAg0ATAIPAE0CAQCtAQYAuAEAALsBVgCPAIgA9ACIAJAAAAD1AAAAkQAG +APYABgCFAAQA6wAEAFACCwBRAgMAUgIBAFMCAABUAgsAVQIDAFYCAQBXAgAAuQHBANABAABmAgYA +aAIHAGoCBgBsAgcAbgIFAHACDAB9AgYAfwIHAIECBgCDAgcAhQIFAIcCDAChAUAA+/8AAP//AAC0 +ACAAGQEgALUAIQAaASEABAAIANQBAwCzAQQAeAA8AN0APAB5AGoA3gBqAKgAAQANAQEAnAHMAJ0B +zADVAcwA1gHMAKQBgABdAjMASgIOAEwCDgBNAgEArQEHALgBAAC7AVYAjwCIAPQAiACQAAAA9QAA +AJEABgD2AAYAhQAEAOsABABQAgsAUQIDAFICAQBTAgAAlAILAJUCAwCWAgEAlwIAAFQCCwBVAgMA +VgIBAFcCAACYAgsAmQIDAJoCAQCbAgAAuQHBANABBABmAgYAaAIHAGoCBgBsAgcAbgIFAHACDAB9 +AgYAfwIHAIECBgCDAgcAhQIFAIcCDABLAgEAoQFAALIAMAAXATAAswAAABgBAACcAg8AoQIPAKAC +iACfAogAngKIAJ0CiAClAogApAKIAKMCiACiAogA+/8AAAAAAAACAAAADdIS0hPSFNIM0hXSC9IC +0hHSBEMAEBQQCRAREAFAG9Ic0gDSCgALAAQADgC1ABoBDwBCALwAwwAhASgBtgC3ALgAuQC9AL4A +vwDAABsBHAEdAR4BIgEjASQBJQERAAAACgAAAAoAAAC2AAAAtwAAALgAAAC5AAAAtgAAALcAAAC4 +AAAAuQAAAL0AAAC+AAAAvwAAAMAAAAC9AAAAvgAAAL8AAADAAAAAEtIAABLSAAAAAAIALABkAHQA +gACMAKEABwAAAAAAAQACAAMAAAAAALcTIgC4FCMAuRUkALsWJQC8FyYAvRgnAMAZKADEGikABxsA +AAgcAQALHQIADB4DABAfBAAiIQUAJCIGACYjBwAoJAgAKiUJACwmCgAuJwsAMCgMADQpDQA4Kg4A +PCsPAEAsEABkLhEAaC8SAGwwEwBwMRQAdDIVAHgzFgB8NBcAgDUYAIQ2GQCINxoAjDgbAJE6HACV +Ox0AmTweAJ09HwChPiAApT8hACRJBgIsSgoCNEsNATxMDwFkTREBbE4TAXRPFQF8UBcBhFEZAZVS +HQGdUx8BAQQAAAIFAQADBgIABAcDAAUIBAAGCQUABwoGAAgLBwAJDAgACg0JAAsOCgAMDwsADRAM +AA4RDQABQAAEAkEBBANCAgQEQwMEBUQEBAZFBQQHRgYECEcHBAlICAQEAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBXgAAAAAAAsgws +Af////////8AAf//AgP///8E//////////////////////8F/wb/B/8I/wn/Cv8L/wz///8N//// +Dv///w////8Q//////////////////////////////////////////////8R////Ev///xP///8U +////Ff///xb///8X////GP///xn///8a////G/////8c////Hf///x7///8f////IP///yH///// +/////////////////yIjJP8lJif//yj///8p//////////////////////////////////////// +//////////////////////////////////////8AAAEAAQEAAAAAAAAAAQAAAAAAAAAAAAAAAAAA +AwAAAAAAAAABAAAAAAAAAIAqAQAAAAAA+GgAAAEAAAAE0AEAAgAAAHjPAQADAAAApBkCAAQAAACA +KgEABQAAADwRAQAGAAAAfOQAAAcAAADEEQEACAAAAOQ7AAAJAAAAbFwAAAoAAAAUwAAACwAAAPA1 +AAAMAAAApBwCAA0AAAC03QAADgAAAPTdAAAPAAAAsN0AABAAAADw3QAAEQAAALg+AQASAAAAjOYB +ABMAAACwLwAAFAAAADhiAQAVAAAAiE4BABYAAAA0XgEAFwAAAOTOAQAYAAAAqIcBABkAAAD8AwEA +GgAAAHwqAQAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// +////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgjAAA4IwAAOCMAADUdwAA4IwAAOCMAAA4eAAA4IwAAOCM +AADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAAVH4AAJx9AACMfQAABH0AAMR9AADsfAAA4IwA +AOCMAAAwhAAAAIcAAKyIAADgjAAA4IwAAOCMAABIjAAASIMAAICDAADsggAA4IwAAOCMAADgjAAA +BIwAAOCMAADMggAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADg +jAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCM +AADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAAD4eAAA4IwAAOCMAADgjAAA4IwAAOCMAABoiQAA4IwA +AOCMAADgjAAA4IwAAOCMAABceQAA4IwAAMh6AABoegAA+HkAAFh6AACQdQAA4IwAAGR1AADgjAAA +4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAPB0AADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADg +jAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAALB8AADgjAAA4IwAAHR+ +AADgjAAA4IwAAOCMAADgjAAA4IwAALx/AACkfgAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwA +AOCMAADgjAAA4IwAAOCMAADgegAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAJyLAADgjAAA +/IsAAAiJAADgjAAA4IwAAJBzAADIiAAA4IwAAOCMAAAMfQAAJH0AAOCMAADgjAAAGHkAANR1AADg +jAAA4IwAAOCMAACIgwAA1HwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAABR8AADgjAAACI0AAJSN +AAB0jQAArI0AAECNAAAojQAAtI0AAASNAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwA +ACB5AADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4I8AAOyQAAAYdAAAZHQAAOCMAADgjAAA +4IwAAOCMAADgjAAABHYAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADgjAAA4IwAAOCMAADg +jAAA4IwAAHSOAAC4jQAAJI8AAAiPAABIjgAA0I0AADyPAADwjgAA4IwAAOCMAADgjAAA4IwAAOCM +AADgjAAA4IwAAOCMAAA4dgAAJHcAAMR2AABUjwAAfHQAAKx3AABEeAAA4IwAAOCMAADgjAAA4IwA +ADB4AAA0eAAA4IwAAOCMAADYdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnJsAAOSZAAAAnQAADJwAABSeAAAA +AAEA/////wAAAAD//////////wEAAAD4EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA +AAAAAND+AAAAAAAAAAAYIKAAICCgAEAhoABIIaAAHCCgACQgoABEIaAATCGgACggoAAwIKAAaCGg +AHAhoAAsIKAANCCgAGwhoAB0IaAAOCCgADwgoAB4IaAAfCGgAJgRAAAA/wMAUBMAAAD/BQDcEQAA +AP8tALgRAAAA/z0ANBEAAAD/BABcEQAAAP8lAKTCAAAA/90AbBIAABAQTAA4EwAAAP8iAAASAAAA +/yYA2BIAAAD/KACkEgAAAP8gAJTBAAAAIAAA2MAAAAD/MAAAAAAAAAAAAAABAQA8PDw8PDw8PDw8 +PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAAPDw8 +PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwVFRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAA +AAAAADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA +AAAAAAAAAAAAAAAAAABEAgEAJKkAAMQiAAAkqQAAJKkAACSpAACEDAAAnN0BAHjPAAAkqQAAJKkA +AMgyAADIMgAAyDIAAMgyAADIMgAAyDIAAMgyAAAkqQAAJKkAACSpAAAkqQAA9FMAACSpAAAkqQAA +JKkAACSpAAAkqQAAXM8AACSpAAAkqQAAGMAAAAAAAAAs6QAAMOkAALQCAACgAgAAJD4BAAAAAACU +tgAApLsBALy2AADMuwEA4LYAAPS7AQC4l4AA5C2AACSSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAACEAIQAhACEAIQAhACEAIQAhACEAIUAhgCGAAQABQAGAAcACAAIAAkACgAKAAsADAAM +AA0ADgAOAA8AJgAnACgAKQAqAEYARgBHAEgASABJAEoASgBLAEwAaABpAGoAagBrAGwAbABtAG4A +bgBvAHAAcABxAHIAcgBzAHMAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAAK +AD8AAACEAIQAhACEAIQAhACEAIQAhACEAIUAhgCGAAQABQAGAAcACAAIAAkACgAKAAsADAAMAA0A +DgAOAA8AJgAnACgAKQAqAEYARgBHAEgASABJAEoASgBLAEwAaABpAGoAagBrAGwAbABtAG4AbgBv +AHAAcABxAHIAcgBzAHMAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAAKAD8A +AAAAAGQhAAAsIQAApLKAAAACAAAAAAAAsPgAAID4AACktIAAQAUAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAALT4AAAAOwEANLuAAFQAAAAAAAAAsPgAANQ5AQDkuYAAUAEAAAAAAACw+AAA0DMBAMgG +gAAIAAAAAQAAALD4AAB89wAAAAAAAFABAAAAAAAAsPgAAFw0AQB4JoAAAgAAAAAAAACw+AAAaDMB +AMQGgAAEAAAAAAAAALj4AACA+AAAiLuAACoAAAAAAAAAsPgAAID4AACgNYAACAAAAAAAAAAAAAAA +iPgAAAAAAAAAAAAAAQAAAAAAAACc+AAAAAAAAAAAAAAAAAAAAAAAAIT4AAAAAAAAAAAAAAAAAACw ++AAAGL4BAAAAAAAAAAAAAAAAALD4AADYvQEA0AaAAAQAAAAAAAAAbgBuAGkAwACgAFAAgAC+AFAB +fQA+AAEAAQABAFgCKADmAS0AVQM8ANwBYwAAAG4AbgBpAMAAoABQAIAAvgBQAX0APgABAAEAAQBY +AigA5gEtAFUDPADcAWMAAAAAAAAAAQEAAIwBAQAV0gAAAAAAAP8DAACMAQEADNIAAAAAAAD/AQAA +jAEBABXSAAAKAAAAAPwPAIwBAQAM0gAACQAAAAD+AwCMAQEAFdIAABQAAAAAAPA/jAEBAAzSAAAS +AAAAAAD8B4wBAQAG0gAAAAAAAP8BAACMAQEAB9IAAAAAAAD/AwAAjAEBAAbSAAAJAAAAAP4DAIwB +AQAH0gAACgAAAAD8DwCMAQEABtIAABIAAAAAAPwHjAEBAAfSAAAUAAAAAADwPwAAAAAAAAAAAAAA +AAEAAAABAAAACgAAAAUAAAAFAAAABgAAAAoAAAAKAAAABgAAAAQAAAAFAAAABgAAAAUAAAAFAAAA +BgAAAAYAAAAGAAAABgAAAAcAAAAHAAAABwAAAAgAAAAIAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAA +AAAAAQAAAAIAAAABAAAAAgAAAAEAAAABAAAAAwAAAAMAAAACAAAAAQAAAAQAAAAAAAAAAAAAAAIA +AAABAAAAAQAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAA +AAAAACwBAABeAQAAAQAAAAEAAAABAAAAAQAAAAMAAAAAAAAAAAAAAGQLAQDIDwEAuA4BADQQAQDE +DwEA/A0BADAQAQCMDAEAiAwBAGDjFgAg1hMAAAAAABAAAAAAgAAAAACgABAnAADoAwAA6AMAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAABAAAAAQAAAAIAAAAFAAAAAgAAAAIAAAAFAAAA +AgAAAAIAAAABAAAAAQAAAAUAAAAFAAAAAgAAAAUAAAAFAAAAAAAAAAUAAAACAAAAAgAAAAAAAAAA +AAAAAAAAAAUAAAAFAAAAAAAAAAUAAAACAAAAAgAAAAUAAAAFAAAABQAAAAAAAAAFAAAAAgAAAAUA +AAABAAAAAQAAAAIAAAACAAAAAgAAAAUAAAAFAAAAAgAAAAUAAAABAAAAAQAAAAIAAAACAAAAAgAA +AAUAAAAFAAAAAgAAAAIAAAAFAAAAAQAAAAIAAAAFAAAAAgAAAAUAAAAFAAAABAAAAAUAAAAFAAAA +AQAAAAUAAAAFAAAABQAAAAIAAAACAAAABQAAAAUAAAAFAAAAAQAAAAUAAAAFAAAABQAAAAIAAAAC +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAARAA +AQAAAAKAAAFCAAYCEAACIAAAA8AAAUMABgMQAALAAAADwAABQwAGBBAAAkAAAAKAAAFEAAYFEQAA +QAAAA8AAAUUABgYRAADgAAADwAABRQAGBxEAAQAAAAKAAAFGAAYIEQACIAAAA8AAAUcABgkRAALA +AAADwAABRwAGChEAAkAAAAKAAAFIAAYLEgAAQAAAA8AAAUkABgwSAADgAAADwAABSQAGDRIAAQAA +AAKAAAFKAAYOEgACAAAAAoAAAUwABgF4ADAAAABQAAAEtjwGAngARAAAAFAAAAS5PAYDeQAIAAAA +UAAABLs8BgR5ABwAAABQAAAEvjwGBXkAMAAAAFAAAATAPAYGeQBEAAAAUAAABMM8Bgd6AAgAAABQ +AAAExTwGCHoAHAAAAFAAAATIPAYJegAwAAAAUAAABMo8Bgp6AEQAAABQAAAEzTwGC3sACAAAAFAA +AATPPAYMewAcAAAAUAAABNI8Bg17ADAAAABQAAAE1DwGDnwAEAAAAFAAAATaPgYAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAQABAQAAAQABAAIBAAACAAEAAgEAAAKAgICAgICAgAGAAoCAgICAwACQANAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuAAAAbgACAG4AbgBuAAIA +aQBpAG4AAQDAAMAA6AABAKAAoAA2AQMAUABQAPUAAQCAAIAA6AABAL4AvgC+AAEAUAFQAVABAQB9 +AH0ArwADAD4APgA+AAEAAQABAAEAAQABAAEAAQABAAEAAQABAAEAWAJYAlgCAQAoACgAKAABAOYB +5gHmAQEALQAtAC0AAQBVA1UDVQMBADwAPAA8AAEA3AHcAdwBAQBjAGMAYwABAAAAAAAAAAAAMgAF +ADIABQACAAgAZACgAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw6IAAAQAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAjAqMCgAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAABY2gEAFQAAAAMAAACYOYAAAAAAAAAAAAAAAAAApNkBAAUAAAADAAAAmDmAAAAA +AAAAAAAAAAAAAJjZAQAKAAAAAwAAAJg5gAAAAAAAAAAAAAAAAABk1wEACgAAAAMAAACYOYAAAAAA +AAAAAAAAAAAAtNgBAAoAAAAAAAAAuDmAAAAAAAAAAAAAAAAAALTYAQAKAAAAAAAAALg5gAAAAAAA +AAAAAAAAAAC02AEACgAAAAAAAAC4OYAAAAAAAAAAAAAAAAAAtNgBAAoAAAAAAAAAuDmAAAAAAAAA +AAAAAAAAALTYAQAKAAAAAAAAALg5gAAAAAAAAAAAAAAAAAC02AEACgAAAAAAAAC4OYAAAAAAAAAA +AAAAAAAAtNgBAAoAAAAAAAAAuDmAAAAAAAAAAAAAAAAAALTYAQAKAAAAAAAAALg5gAAAAAAAAAAA +AAAAAAC02AEACgAAAAAAAAC4OYAAAAAAAAAAAAAAAAAAtNgBAAoAAAAAAAAAuDmAAAAAAAAAAAAA +AAAAALTYAQAKAAAAAAAAALg5gAAAAAAAAAAAAAAAAAC02AEACgAAAAAAAAC4OYAAAAAAAAAAAAAA +AAAAxNkBAAoAAAADAAAAmDmAAAAAAAAAAAAAAAAAABzbAQAFAAAAAwAAAJg5gAAAAAAAAAAAAAAA +AAC81gEACgAAAAAAAAC4OYAAAAAAAAAAAAAAAAAALNcBAAoAAAAAAAAAuDmAAAAAAAAAAAAAAAAA +AFzlAQAKAAAAAwAAAJg5gAAAAAAAAAAAAAAAAACQ1wEACgAAAAAAAAC4OYAAAAAAAAAAAAAAAAAA +ONgBAAoAAAAAAAAAuDmAAAAAAAAAAAAAAAAAALjYAQAKAAAAAAAAALg5gAAAAAAAAAAAAAAAAAA4 +2QEACgAAAAAAAAC4OYAAAAAAAAAAAAAAAAAAXNoBAAoAAAAAAAAAuDmAAAAAAAAAAAAAAAAAAMza +AQAKAAAAAAAAALg5gAAAAAAAAAAAAAAAAAD42gEABgAAAAAAAAC4OYAAAAAAAAAAAAAAAAAACNsB +AAYAAAAAAAAAuDmAAAAAAAAAAAAAAAAAAAAAAACYOYAAmDmAALggoABsIKAAAIABAP9//P8AAAAA +AAAAALg5gAC4OYAApCCgADggoAABAAAA/P///wAAAAAAAAAA2DmAANg5gACoIKAAPCCgABAAAADH +////AAAAAAAAAAD4OYAA+DmAAKwgoAB4IaAAQAEAAD/+//8AAAAAAAAAABg6gAAYOoAAsCCgAHwh +oAAADAAA//H//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIjXAQAVAAAAAwAAAJg5gAAAAAAAUAAA +AAAAAABUBoAAgJuAABgAAABAm4AAAAAAAAAAAAAAAAAAVAaAAICbgAAYAAAAQJuAAAAAAAAAAAAA +AAAAAH8AAAAAAAAAAH8AAAAAAAAAAAAAAAAAAKB9gAAAAAAAAAAAAP//AAABAAAAAAAAAAcAAAAA +AAAAAAAAAAAAAAAAAQIDBAQEBAQFBgcICAgICAkKCwwNAABuO2g7YjtcO246aDpiOlw6bjloOWI5 +XDluK2grYitcK24qaCpiKlwqbiloKWIpXCluKGgoYihcKG4naCdiJ1wnbiZoJmImXCZuJWglYiVc +JW4kaCRiJFwkbiNoI2IjXCNuImgiYiJcIm4haCFiIVwhbiBoIGIgXCBiE1wTbhJoEmISXBJuEWgR +YhFcEW4QaBBiEFwQbgJoAmICXAJuAWgBYgFcAW4AaABUAAAAbjtoO2I7XDtuOmg6YjpcOm45aDli +OVw5bitoK2IrXCtuKmgqYipcKm4paCliKVwpbihoKGIoXChuJ2gnYidcJ24maCZiJlwmbiVoJWIl +XCVuJGgkYiRcJG4jaCNiI1wjbiJoImIiXCJuIWghYiFcIW4gaCBiIFwgbhJoEmISXBJuEWgRYhFc +EW4QaBBiEFwQVxBSEE0QSRBuAWgBYgFcAW4AaABiAFwAVAAAAAAAAAAAAAAAHQAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBYAQAIAAAAAwAAAJg5gADMB4AATAiAAMwIgABM +CYAACg0RFAoNERQZGRkZCgoAAAAAAAAGBgYGCQkJCQAGAAAABQYHCA0ODxAVFhcYGQAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAADBSamhwkmpqampqTmm6BPzUJiysAAAAyAAAAjwCMAIoAQwAPACBo +NwAAABEAPjogEQAAAiUAAAwvAAACLzk5AAolPLdHb4oABxQnYi4AAAIAFwAAFg4WFAAAAABCQhcA +BRAKIDBAAAAGBgoS9hX2BvYJ9gz2D/YA9gMAgAAAAABYW2NjMQAADBAUGCAIBAAAPDg0MCwoJCAc +GBQQDAgEAAsHAwA7NzMvKycjHxsXEw8LBwMAOzczLysnIx8bFxMPCwcDMTY6MzQ6MzYAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgAAABAAAAAdAAAANwAAAG8AAACgAAAA +cAAAAAUAAAD2AAAAWgAAAB8AAABIAAAAIAAAAEgAAAAIAAAAAQAAADMAAAB/AAAANAAAAH8AAAA3 +AAAAAQAAADgAAABPAAAAOwAAAH8AAAA8AAAAfwAAADEAAAAAAAAAMgAAAAAAAAA1AAAAAAAAADYA +AAAAAAAAOQAAAAAAAAA6AAAAAAAAAA0AAAAqAAAADgAAAHoAAAAPAAAAEAAAAPMAAABIAAAA9AAA +AEgAAAAAAAAAAQEBAQEBAQECAgICAgICAgMDAwMDAwMDAQIAAAQAAAAFAAAAAAAAAAAAAAAAAAAA +AAAAAKEDDh7hAAAAoQMOHuEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoQMOHuEAAAAV9mP2sPb89kb3kPfY +9x/4Zfip+O34L/lw+bD57vkr+mf6ovrc+hT7S/uB+7b76vsc/E38ffyr/Nn8Bf0w/Vn9gv2p/c/9 +9P0X/jn+Wv56/pj+tv7S/u3+Bv8e/zX/S/9g/3P/hf+W/6b/tP/B/83/2P/h/+n/8P/2//r//f// +///////9//r/9v/w/+n/4f/Y/83/wf+0/6b/lv+F/3P/YP9L/zX/Hv8G/+3+0v62/pj+ev5a/jn+ +F/70/c/9qf2C/Vn9MP0F/dn8q/x9/E38HPzq+7b7gftL+xT73Pqi+mf6K/ru+bD5cPkv+e34qfhl ++B/42PeQ90b3/Paw9mP2cLmDupa7qry+vdK+57/8wBHCJ8M9xFPFasaAx5fIr8nGyt7L9swPzifP +QNBZ0XLSjNOm1L/V2tb01w7ZKdpE21/cet2W3rHfzeDp4QXjIeQ+5Vrmd+eT6LDpzerq6wftJO5C +71/wffGa8rjz1fTz9RH3L/hM+Wr6iPum/MT94v4AAB4BPAJaA3gElgW0BtEH7wgNCisLSAxmDYMO +oQ++ENwR+RIWFDMVUBZtF4kYphnCGt8b+xwXHjMfTyBqIYYioSO8JNcl8iYMKCYpQSpaK3Qsji2n +LsAv2TDxMQozIjQ6NVE2aTeAOJY5rTrDO9k87z0EPxlALkFCQlZDakR9RaqqAwAAAAAAqqoDAAD4 +AAAAqgP///8AAFCn9FFTZUF+w6QXGpZeJzrLa6s78UWdH6tY+qyTA+NLVfowIPZtdq2RdsyIJUwC +9fzX5U/XyyrFgEQ1Jo+jYrVJWrHeZxu6JZgO6kXhwP5dAnUvwxLwTIGjl0aNxvnTa+dfjwOVnJIV +63ptv9pZUpUtg77U0yF0WClp4ElEyMmOaonCdXh5jvRrPliZ3XG5J7ZP4b4XrYjwZqwgybQ6zn0Y +St9jgjEa5WAzUZdFf1Ni4HdksYSua7scoIH+lCsI+VhoSHAZ/UWPh2zelLf4e1Ij03Or4gJLcleP +H+Mqq1VmByjrsgPCtS+ae8WGpQg30/KHKDCypb8jumoDAlyCFu0rHM+KkrR5p/DyB/Oh4mlOzfTa +ZdW+BQYfYjTRiv6mxJ1TLjSgVfOiMuGKBXXr9qQ57IMLqu9gQAafcV5REG69+YohPj0G3ZauBT7d +Rr3mTbWNVJEFXcRxb9QGBP8VUGAk+5gZl+m91sxDQIl3ntlnvULosIiLiQc4Wxnn2+7IeUcKfKHp +D0J8yR6E+AAAAACDhoAJSO0rMqxwER5Oclps+/8O/VY4hQ8e1a49JzktNmTZDwohplxo0VRbmzou +NiSxZwoMD+dXk9KW7rSekZsbT8XAgKIg3GFpS3daFhoSHAq6k+LlKqDAQ+AiPB0XGxILDQkOrceL +8rmoti3IqR4UhRnxV0wHda+73Znu/WB/o58mAfe89XJcxTtmRDR++1t2KUOL3MYjy2j87bZj8eS4 +ytwx1xCFY0JAIpcTIBHGhH0kSoX4PbvSETL5rm2hKcdLL54d8zCy3OxShg3Q48F3bBazK5m5cKn6 +SJQRImTpR8SM/KgaP/Cg2Cx9Vu+QMyLHTkmHwdE42f6iyow2C9SYz4H1pijeeqUmjrfapL+tP+Sd +OiwNknhQm8xfamJGflTCE4326LjYkF73OS71r8OCvoBdn3yT0GmpLdVvsxIlzzuZrMinfRgQbmOc +6Hu7O9sJeCbN9BhZbgG3muyomk+DZW6V5n7m/6oIz7wh5ugV79mb57rONm9K1Amf6tZ8sCmvsqQx +MSM/KjCUpcbAZqI1N7xOdKbKgvyw0JDgFdinM0qYBPH32uxBDlDNfy/2kReN1k12TbDvQ1RNqszf +BJbk47XRnhuIaky4HyzBf1FlRgTqXp1dNYwBc3SH+i5BC/taHWezUtLbkjNWEOkTR9ZtjGHXmnoM +oTeOFPhZiTwT6+4nqc41yWG37eUc4TyxR3pZ39KcP3PyVXnOFBi/N8dz6s33U1uq/V8Ubz3fhttE +eIHzr8o+xGi5LDQkOF9Ao8Jywx0WDCXivItJPChBlQ3/cQGoOd6zDAic5LTYkMFWZGGEy3twtjLV +dFxsSEJXuNBSCWrVMDalOL9Ao56B89f7fOM5gpsv/4c0jkNExN7py1R7lDKmwiM97kyVC0L6w04I +LqFmKNkksnZboklti9Elcvj2ZIZomBbUpFzMXWW2kmxwSFD97bnaXhVGV6eNnYSQ2KsAjLzTCvfk +WAW4s0UG0Cwej8o/DwLBr70DAROKazqREUFPZ9zql/LPzvC05nOWrHQi5601heL5N+gcdd9uR/Ea +cR0pxYlvt2IOqhi+G/xWPkvG0nkgmtvA/njNWvQf3agziAfHMbESEFkngOxfYFF/qRm1Sg0t5Xqf +k8mc76DgO02uKvWwyOu7PINTmWEXKwR+unfWJuFpFGNVIQx9pWNjxoR8fPiZd3fujXt79g3y8v+9 +a2vWsW9v3lTFxZFQMDBgAwEBAqlnZ859KytWGf7+52LX17Xmq6tNmnZ27EXKyo+dgoIfQMnJiYd9 +ffoV+vrv61lZsslHR44L8PD77K2tQWfU1LP9oqJf6q+vRb+cnCP3pKRTlnJy5FvAwJvCt7d1HP39 +4a6Tkz1qJiZMWjY2bEE/P34C9/f1T8zMg1w0NGj0paVRNOXl0Qjx8fmTcXHic9jYq1MxMWI/FRUq +DAQECFLHx5VlIyNGXsPDnSgYGDChlpY3DwUFCrWami8JBwcONhISJJuAgBs94uLfJuvrzWknJ07N +srJ/n3V16hsJCRKeg4MddCwsWC4aGjQtGxs2sm5u3O5aWrT7oKBb9lJSpE07O3Zh1ta3zrOzfXsp +KVI+4+PdcS8vXpeEhBP1U1OmaNHRuQAAAAAs7e3BYCAgQB/8/OPIsbF57Vtbtr5qatRGy8uN2b6+ +Z0s5OXLeSkqU1ExMmOhYWLBKz8+Fa9DQuyrv78XlqqpPFvv77cVDQ4bXTU2aVTMzZpSFhRHPRUWK +EPn56QYCAgSBf3/+8FBQoEQ8PHi6n58l46ioS/NRUaL+o6NdwEBAgIqPjwWtkpI/vJ2dIUg4OHAE +9fXx37y8Y8G2tnd12tqvYyEhQjAQECAa///lDvPz/W3S0r9Mzc2BFAwMGDUTEyYv7OzD4V9fvqKX +lzXMRESIORcXLlfExJPyp6dVgn5+/Ec9PXqsZGTI511duisZGTKVc3PmoGBgwJiBgRnRT0+ef9zc +o2YiIkR+KipUq5CQO4OIiAvKRkaMKe7ux9O4uGs8FBQoed7ep+JeXrwdCwsWdtvbrTvg4NtWMjJk +Tjo6dB4KChTbSUmSCgYGDGwkJEjkXFy4XcLCn27T073vrKxDpmJixKiRkTmklZUxN+Tk04t5efIy +5+fVQ8jIi1k3N263bW3ajI2NAWTV1bHSTk6c4KmpSbRsbNj6VlasB/T08yXq6s+vZWXKjnp69Omu +rkcYCAgQ1bq6b4h4ePBvJSVKci4uXCQcHDjxpqZXx7S0c1HGxpcj6OjLfN3doZx0dOghHx8+3UtL +lty9vWGGi4sNhYqKD5BwcOBCPj58xLW1capmZszYSEiQBQMDBgH29vcSDg4co2Fhwl81NWr5V1eu +0Lm5aZGGhhdYwcGZJx0dOrmenic44eHZE/j467OYmCszEREiu2lp0nDZ2amJjo4Hp5SUM7abmy0i +Hh48koeHFSDp6clJzs6H/1VVqngoKFB639+lj4yMA/ihoVmAiYkJFw0NGtq/v2Ux5ubXxkJChLho +aNDDQUGCsJmZKXctLVoRDw8ey7Cwe/xUVKjWu7ttOhYWLAABAQIBAgIDAQEBAQEBAQECAgICAgIC +AgMDAwMDAwMDBAQEBAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQEBAQEBAQEBAQEBAQE +BAQEBAQAAAA6AQIB1QDfANoAogB1AH8AigUqAzkBqAGKBcoC2QBIAQEDDwcKFDduagEaAdkA6AAK +AboAeQCIAMoBSgHiAPkAygHqAIIAmQB00UUX6KKLLgAFBwEDBAAFAQUAAAAFBgACBAAFAAUAAAEC +AQIDBAAABQYHCAkKAAAFAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAEAAAAAgAAAAUAAAAAAP8AAP// +/ygAKAAwACwALAAoADwANABAADwAjABsAFgASAD0ALAAf/8HDx8/AQMwAAAANgAAAAwAAAASAAAA +GAAAACQAAAAGAAAACQAAAAUABwIDBAYGQAOABsAJAA2AEwAaQB2AIIAGAA2AEwAaACcANIA6AEHA +CYATQB0AJ4A6AE7AV4BhmQMzB9kKcw6mFeYcgCAZJDMHcw6mFeYcWSvMOQBBM0jZCqYVgCBZKwBB +plaAYVlsndiJnU7sxE40SIM0J3ZiJxqkQRoTO7ETERiBEQ/8wA9O7MROJ3ZiJxqkQRoTO7ETDdIg +DYmd2AkIjMAIB37gBzRIgzQapEEaERiBEQ3SIA0IjMAIBmmQBrCy1QUFVEAFJ3ZiJxM7sRMN0iAN +iZ3YCQZpkAbETuwEBEZgBAM/8AOqqqqqGqRBGhM7sRMP/MAPERiBEQ3SIA0KqIAKEzuxEw/8wA8P +/MAPDdIgDQu0QAsLtEALiZ3YCQ3SIA0KqIAKCqiACgiMwAgHeIAHB3iABwZpkAYP/MAPDdIgDQu0 +QAsN0iANC7RAC4md2AkIjMAIiZ3YCQiMwAgHfuAHB37gB8EsKQcKqIAKCIzACAd4gAcIjMAIB3iA +BwZpkAawstUFBmmQBrCy1QUFVEAFBVRABdYdxgQBBw8fP3///2bmAAAFBgECAwQAAFQAVABsAGAA +XABUAIwAeAANDwUHCQsBAygAKAA0ADAALAAsAEQAPAAsACwAPAA0ADAALABUAEQAVVVVAUtoLwFV +VVUF4ziOA6qqqgJxHMcBqqqqCsdxHAcABAAAZAAAAAAAAAAPAD8AAQAAAA8APwABAAAADwA/AAEA +AAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAgAAAA8APwABAAAAIhYAAIAAAAMAAAFZAAAk +FgABAAAAAwAAAVoAACYWAAIAAAAEAAABWgAAKBYAAgAAAAMAAAFbAAAqFgACgAAAAwAAAVwAACwX +AAAAAAAEAAABXAAALhcAAIAAAAMAAAFdAAAwFwABAAAAAwAAAV4AADQXAAIAAAADAAABXwAANhcA +AoAAAAMAAAFgAAA4GAAAAAAABAAAAWAAADwYAAEAAAADAAABYgAAPhgAAgAAAAQAAAFiAABAGAAC +AAAAAwAAAWMAAGQbAAIAAAADAAABbwABZhsAAoAAAAMAAAFwAAFoHAAAAAAABAAAAXAAAWwcAAEA +AAADAAABcgABbhwAAgAAAAQAAAFyAAFwHAACAAAAAwAAAXMAAnQdAAAAAAAEAAABdAACdh0AAIAA +AAMAAAF1AAJ4HQABAAAAAwAAAXYAAnwdAAIAAAADAAABdwADfh0AAoAAAAMAAAF4AAOAHgAAAAAA +BAAAAXgAA4QeAAEAAAADAAABegADhh4AAgAAAAQAAAF6AASIHgACAAAAAwAAAXsABIwfAAAAAAAE +AAABfAAEkR8AAUAAAAMAAAF+AASVHwADAAAABAAAAX8ABZcfAALAAAADAAABgAAFmSAAAEAAAAMA +AAGBAAWdIAABQAAAAwAAAYIABZ8gAAHAAAADAAABgwAFoSAAAwAAAAQAAAGDAAWlIQAAQAAAAwAA +AYUABaxvAQAAAAAArG8BAAAAAACsbwEAAAAAAKxvAQAAAAAArG8BAAAAAACsbwEAAAAAAKxvAQAA +AAAArG8BAAAAAACoaQEAGAAAAGxrAQAgAAAAzHABABQAAADAcQEAFAAAABhvAQAOAAAA7G0BAA4A +AADsbgEAFAAAAOxuAQAUAAAAQANAQEBAQEABgQCEQEBANQFAATVAlQAAAAAAAAAAAABkAAAAAJAB +AAoAAAD0oAEAiKQBAIyiAQAwngEAsKgBAAirAQAspgEAsKMBAICnAQAEAAAAHBEAABwyAAAcMwAA +BAAAABwVAAAcAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAApcaE+JnujfYN/73Wsd5UkVBgAwKpzn1WGediteZNmuxFj50fQImH+hXv67LJjgv77EFn +s/1f6kW/I/dTluRbm8J1HOGuPWpMWmxBfgL1T4NcaPRRNNEI+ZPic6tTYj8qDAhSlWVGXp0oMKE3 +Dwq1LwkONiSbGz3fJs1pTs1/n+obEp4ddFguNC02stzutPtb9qRNdmG3zn17Uj7dcV6XE/WmaLkA +ACzBYEAf48h57ba+1EaN2WdLct6U1JjosEqFa7sqxeVPFu3FhteaVWaUEc+KEOkGBIH+8KBEeLol +40vzov5dwICKBa0/vCFIcATx32PBd3WvY0IwIBrlDv1tv0yBFBg1Ji/D4b6iNcyIOS5Xk/JVgvxH +eqzI57orMpXmoMCYGdGef6NmRH5UqzuDC8qMKcfTazwoeafivB0Wdq0721ZkTnQeFNuSCgxsSOS4 +XZ9uve9DpsSoOaQxN9OL8jLVQ4tZbrfajAFksdKc4Em02PqsB/Mlz6/KjvTpRxgQ1W+I8G9Kclwk +OPFXx3NRlyPLfKGc6CE+3ZbcYYYNhQ+Q4EJ8xHGqzNiQBQYB9xIco8Jfavmu0GmRF1iZJzq5JzjZ +E+uzKzMiu9JwqYkHpzO2LSI8khUgyUmH/6p4UHqljwP4WYAJFxraZTHXxoS40MOCsCl3WhEey3v8 +qNZtOiwAAQIEBAAAAAQMDAgEDAQEQAAAAIAAAAAAAQAAAAIAAEAAAAAABAAAQAAAAEAAAAAA8GEA +AAEBAgECAgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAAKgAAAA4AAAAAAAEBAQIE/wgQ +//8c2gEAKNoBADTaAQBA2gEASNoBAFDaAQAAAAABAAAAAgAAAAQAAAAIAAAAEAAAACAAAABAAAAA +gAAAABsAAAA2BAIEAgAAAAABAhAECAAAAAIQBAgAAAAAAQEAAQIBAQEAAAAAAAAAAP////8AAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIANAAAAIAAAgA0AAIANAAAA +IAAAgA0AAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAADAAAA8B0CACAggA8AAEAAaSAAAGkgQABpIAAAaSBAACAggA8AAOgAaSAAAGkgQABpIAAAaSBA +ACAggA8AADDyaSAAAGkgQABpIAAASiAAAEohAABKIgAASiMAAEokAABKJQAASiYAAEonAABKIAAQ +SiEAEEoiABBKIwAQSiQAEEolABBKJgAQSicAEEogACBKIQAgSiIAIEojACBKJAAgSiUAIEomACBK +JwAgSiAAMEohADAKJIA/gQAAQEEsnDBALJwwQiQcNAoigD+AAMBwCiMAN8IMAAdKJgBwaSBAAEom +AHBKJgBwSiYAcEomAHAAFgBwgADwH0B4ICBAhwAAAAAAAAAAAAD8HIi2/BxItvwcCLb8HMi1/ByI +tfwcSLX8HAi1/BzItPwciLT8HEi0/BwItPwcyLP8HIiz/BxIs+B+4HgE3DjdNfDgeATcNN0z8OB4 +BNww3THw4HgE3CzdL/DgeATcKN0t8OB4BNwk3Svw4HgE3CDdKfDgeATcHN0n8OB4BNwY3SXw4HgE +3BTdI/DgeATcEN0h8OB4BNwM3R/w4HgE3AjdHPDgeATcBN0Z8DQUGjAwFBkwLBQYMCgUFzAkFBYw +IBQVMBwUFDAYFBMwFBQSMBAUETAMFBAwAscBxrAkTTOwJB8z4H7geOB44HjgeOB44HgKJIDwBSBE +AOAgwQdEJP6AQSrEAIQAAgAvJALxQiEBAUIgAwHoIKIEBBEEAgQRBQIEEQYCBBEHAgQbCAEEG0gB +BBuIAQQbyAEsACUARCI+gTwAIgBEIvyAQCHBAOAgwQdAI8MAqCCAAQERhAIBGwoBICDABwQRBAIE +EQUCBBsIAdQH4f8EG0gBRCL8gAQRBALJB+//BBsIAUIhQQBCIEMAqCCAAQERhAIBGwoBICDAB89x +oACsLxiBmrgYoVEHYBAF2OB4z3GgAKwvGIGzuLq4GKE9B2AQZNgKIkCAANnuAAEALyYA8EomQABO +AAYATwAgAIol/w/geAoiQIAA2c4AAQBsACQALyYA8FwABQArCDUISiZAAAhxANgCIb6A4CDFB0J5 +AeACIb6A4CDFB0J56wfv/wHgLy0BAEAlRQACJnzxAAAgAAAoQAHoIGIDLyAAgC8hSwACIb6AwCCG +AcIhhgDgfhEAIABKIAAQSiBAEA4iQgAvIAsSziBFgIol/w8IAAUALy0BAEAlRQACJnzxAAAgAAAo +QAFKJkAA6CAiAy8gAIAvIUsAAiG+gMAghgHCIYYASiYAAEIg/pDOIIIBRCB+kM4hggHgfgkAAADg +eAomAPCKIL8PyiBkAOB/LyADAOB/iiD/D/wciLH8HEix/BwIseHD4cLhweHAB8AcHMAx4cDgfwHA +UyJCgeB8TiIDiBYADAABKMwAACmBAAAogADgf4V5TiMDAAAowQDgfwJ44HhTIkKB4HxOIgOIFgAM +AAApzAABKYEAASiAAOB/hXhOIwMAASnAAOB/InngeAh0ANgFKn4AL3EFKj4DACBAjgEhwQ4FKz4D +4H8nceB4MwAgAEokAAAHIcQALyZA8EolAAAQACYALyQEAQ4gQIEDJUEAgOMOAAMADiJCgQMlwwAF +I4WAMAEBAHlzSHQIcihzCiXAgkoiABAaAAQAwCIhGMolAYMvL0EBwCJjEMAiwxFKJwAACiXAgMAn +IQgWAAQAyiWBgC8oQQHAJ2MAwCcDAA4nh4LKJyQAQCdHAAolwAFMJwCIANkQACQAANhIcWhyANtC +JweICiRAcSgAAQBOJwqIfgABAAApgAIBKcEBACqFAqBxASrCAQArhQIBK8MBoHJMIgCYagAJAKgg +gAUAIACAASFBgAEigoABI8MAAiICgwMjw4IMAAYAACICgwEjw4LAIGYAQiQ+gEolAAAgAAEADAAK +AA4iQoEDJcMALyQAgQwAAwAOIECBAyVBAOB+KHBIcWhyANsgIIAPAABEBagggAMAIACAASFBgAEi +goCRcsIiBgPFIGYAICCADwAAeAUA2glqANsvIQIAICCADwAAoAXgeFMiQoHgfE4iA4gWAAwAACnM +AAIpgQABKIAA4H+FeE4jAwACKcAA4H9CKcEH4cUIdRHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HhhvYwl/5/t9eB/wcXgePHA4cXPcIAAgCFNgM91gAAIoyCFt7q4ugQhgQ8DAAAAB7lF +eS2gnghgEADYAIXPcYAAaMtRIICCTInPcIAA0NkyajZ5x3GAAJDWYIFWeEGABfKVu2Chq7oE8LW7 +YKGLukGgC42juPkC7/8LreHF4cbAgGGAoIEBgQAljZMBIMAAoKIBosHG4H/BxeB4osHxwFYKz/9F +wc91gACAISeFFQhBADCVFBQOMQkOQRBZHYIQ0BUBFh0IQQDPcYAAjCQ8kRQUDTENDUEQz3GAAOQk +WamL6s91gADQB8GNgOYA2cogQQAk8iGtCwqRAwHYHvBBKA0CB31BKAEEp3nPd4AA0Aegj1MlRREf +DTIExrkKIcAP63LPcAAAzRuf2z0G4ACKJIMPDw2eEQDYDNwnAs//z3aAAFDZFiZNEaeNoK/JdRYl +TREApRQUADFGrcdxgAAQ1gK1AIkHrQAZQgEAG0IBx/HxwIIJz/8IyM9yoADIHw4aGIAJyA8aGIAK +yBAaGIALEgE2AsgkeBEaGIAMyM9xgAAwOi0aGIAAgQHgAKHDuFcIUQMLyH/ZCrkkeC8oAQBOIIIH +ANgPIIAABCEBgEIijQIZ8gsjQMAX9M9woACIIPAgUAPPdoAAYDcAhs93gABkNw0NARAAhxJwWAmB +BqCmAB8AFFUBz//geJ/hzCDuh8wgToAG9wJ5QWkLChEIiiH/DwbwANkPIYEAYbkYeeB/KHDxwLII +7/+KIA8KgiQCOppxenJac4h1qHcKIYAhCiDAIcIJYACewYpwuglgAItxgsZqcLIJYADJcUpwqglg +AITBqXCiCWAAhsGIxelwlglgAKlxKnCOCWAAisEKcIYJYACMwalwisG2DOAAkMKLcMlxqgzgAJLC +yXCEwaIM4ACUwobAqXGWDOAAlsKYxpDAksHGDqAAyXKax5TAlsG6DqAA6XLJcOlxdgzgAJzCnMCe +waYMIACOwp/FygygEARtjsBKCSAAJG23CBAAhsCKwYIN7/9AJQITi3CEwXYN7/9AJQIVlMBAJQET +bg6gAMlykMBAJQEVYg6gAOlyyXDpcR4M4ACcwozAnMFODqAAyXJqDqAAyXDJcI7BPgwgAEAlAheS +wEAlARMyDqAAyXKWwEAlARUmDqAA6XLJcOlx3gvgAJzCjMCcwRIOoADJcslwjsEGDCAAQCUCGZYI +YABAJQAXz3GAAFQIEKGGCGAAQCUAGc9xgABUCBGhB/AA2c9wgABUCDCgMaCBB6//gCQCOuB4z3GA +AJxw4H8IYeB48cAqD6//2HAodkhxiHUyDu//yXAId6lwJg7v/6hxCHEALoADBH8mfwArQAMkeGUH +r//lePHAIgrABc9xgAB8G/AhAABAeM9woADQG4DaUKDPcIAABCAAgADZDwgeAs9wnwC4/z2g0cDg +fuB4YIBAgQGAIYFQc8wgQYDhIMEHyiAhADBwhvYE9gkKxQDgfwHYiiD/D+B+4HiA4cokTXDoIG0C +z3GgAFAMJYEBGFIA4H7xwHYOj//PcIAAgCEDgBiIpcFKIAAgHQgRAQohwA/rcoogjA1k2wokAATB +AuAAuHPPd4AAJCAkhyCBVg+gBoogBw6KIJkFSg+gBmfZz3WAALyuiiDZBjoPoAYsjYog2QYuD6AG +LY2KINkGJg+gBi+NiiDZBhoPoAYujYog2QYSD6AGMI2KINkGBg+gBjGNz3aAAHA1z3CAAKxY6gpg +DiQeABTPcIAAyFjaCkAOz3CAAHBZ0gpADs9wgACMWcYKQA4tjQXpbI0bC0IAxg6gBooghw2KIIcN +ug6gBiyNw/AEh0CAz3CAAFigYKAhoEKgz3CAAPjeCJArCQIAz3CAAPjeAdoosM93gADgyM9wgADI +yEynQ4ALCmUAARgCBCOgEI2A4MogYgADphGNFOiS689wgACAIQOACYAZCJ4Awg3gAQfYAdgBps9w +oAAsIBCAAKaKIMkDOg6gBqPZiiCJA89xgABYoCoOoAYigQGGz3GAAFigIIGA4MogYgAYuAV5A4YK +IgCAiiCJA8oiYgAQugIOoAZFec9wgADoMQCAGwhRAM9wgAD43s9xAAAQJ2oOr/8FgBB4AvAA2M9x +gABwyAexA4YMGQQEeQhRAACBguDMIOKABPQB2AChTBaAEGEIUQDPcKAALCDwgM9wAQBIJEDAAdhB +wAgcADQR2EPAANiMuETAANgQ2QTaCHOYcLhwACeHHwAAAH1SCiAF2HCKIMoEbg2gBgDZiiDKA2YN +oAYA2UsWgBAB4A94Sx4CEAyNhugBhoDgMAxBBc9wgAAcWTYJQA4B2c9wgACEGCCgogzgAQbYeQSv +/6XAosHxwA4Mr/+YckXBQSgBAgd5QSgCBCd6xrrPdYAAENZJZV1lJwnfARQUDjHPc4AAUNlocjZ6 +4IILCMED4pITD4ATJ4qnau8J3oEA2CfwxoqG7oDfz3CAANAH4ajPd4AA1CEFjwsOARCA2AWvCfDP +d4AA5CQZjwsOARCA2Bmvxoo2ewAcgAMHioe5AK3PcIAA0AdAiCCoAdhHqwzc3wOP//HAdguP/0h1 +wYBAgWGBAICuDq//yXEApckDr/8hpeB4ocHxwAMSAjfXcgAAAEAB2sIiigAXusdyAA4AAIO67HNA +o+xyAKLCCaAEKHDRwOB/ocDgeKXgH/IJ9i8I0AAzCBABOwhRAeB/Adi94A/yBvYrCFEL4H8C2Mzg +D/KMIEOHDfTgfwbY4H8A2OB/A9jgfwTY4H8F2OB/B9gI2OB+4HjxwOHFiiBSDt4LoAa02c91gAAI +MKlwQCWBGwIIoA0u2gHYKQOv/2EdAhDgePHAngqP/x8ItAAIdQohwA/rcv3Yi7hz20okAAD5BqAA +uHPPd4AACDA3hwAlkB+AAFwwDw1BEAwQgCCA4JHyug+gBwXYOnCKIBIOcgugBqlxRC2+GwAnQB5A +kCGQAN4IukV5z3KkALg9mxpYACKQDBiCI8oaWAAjkLenyxpYACSQxBpYACWQxhpYACaQxxpYACeQ +whpYACiQwxpYACmQxRpYAAqQoxoYAM9wgAA8LSCAYHnJcDUIEAPPcIAAPC0ggGB5yXAlCBAEz3CA +ADwtIIBgeclwFQhQBM9wgAA8LSCAYHnJcAcIkQQA3c9wgACAIQOACIDPcaQAtEUjCB4ARC2+GwAn +QB5skEuQe3tlelMZmIANkFQZGIAF8FMZmINUGZiDRC2+Gyd3DpdWGRiAD5dYGRiAEJdVGRiAEZdX +GRiAEpdaGRiAE5dcGRiAFJdZGRiAFZdbGRiAyg2gBypwoQGP/+B4huDxwADYD/TPcIAA2K6mCu// +BtnPcYAAeK8AgYK4AKEB2NHA4H7geIPg8cAA2An0z3CAANCufgrv/wPZAdjRwOB+4HjxwIHg4cUA +2An0z3CAANOuAd1eCu//qXGpcF0Bj//gePHAluDhxQDYjPfPdYAACKOpcD4K7/8E2QuNg7gLrQHY +NQGP//HAmuDhxQDYjPfPdYAACKMEbRoK7/8E2QuNgrgLrQHYEQGP//HApMGQ4ADZyiBCABP0i3D2 +Ce//ENkAFAAxhODMIGKBCPTPcIAA3MofgAkIXgVMcAHYpMDRwOB+8cBaCI//CHfPcIAAgCEDgBiI +GnGNCBABhOcA3YYAJQDKIEUDz3aAALyuQCYAE6IJ7/8E2S6OsK5TIQAAEa5BKMAgoLldCGQAAiBC +AGO/VQrFAw/qz3GgANAPEBEAhmG6WGAQGRiAJREAhg94AvAPjgDZUyCCIA8hgQAkeC8mB/DPcZ8A +uP8QrhiBzyDiB9Ag4QcYoRiBnrgYoRiBvrgYoQHYHQCP/+B44cT8HMi+/BxIvuHA4cHhwuHD/BwI +sfwcSLH8HIix/BzIsfwcCLL8HEiy/ByIsvwcyLL8HAi/aiSAEOHEaiTAEOHE8cDPcKAA0BsUgM9x +gACEBgQggI/PUQThAKER8i8pAQAPCJ4FLymBD0AAAADPcIAApCzwIEAAQHi6DY//0cDBxGskwBDB +xGskgBDBxJ90BBQLNAQUCjQEFAk0BBQINAQUBzQEFAY0BBQFNAQUBDTBw8HCwcHBwMHERSx+EAom +QH7BxGskgBTBxCAgQIfgeAhyX7hAoeB/AaHgeOB/AICMIFyCAdjgf8IgCwDxwM4Ob/9KJEAAz3WA +AIAhFSUDEACDQCUOFdFwwiQCAfAlDRHIFQUWRCW+gQnyCiHAD+tyjtiNuAEDoAB028gQDQalecgY +WACggwbZRnnIFQAWJHjIHRgQAIPIEAAGhiB/jmgLARDVBk//4HjxwF4Ob/+KIAwJz3WAAOAGJIVi +D0AGBIWJCBEAz3aAANCxExYClgDfhCoICQAhgH+AANSpAqUkiAHb66VspSLpHR7YkwwQBQAEJYEP +wP8AAEEpBAbPcYAA+N4UEQYABS4+AQAhhH8/AP//BCRBAR4eWJAgkIwhgoYB2cIhTgAqpeelJIDP +doAADK7AuSq2z3aAAPwnKK5ArgKIZKUBrh/wBIU7CFEARg+ACADYBKUChSSIk+knhRzgNngkiM9w +gACsJAeIEHEB2cB5z3CAAPgnIKAC2ALwAdgDpe0Fb/8B2PHAfg1v/4ogDAqjwc91gADgBiSFfg5g +BgDeBIWn6KILQAAB2ASlAoUEiIDgYgIBAM9wgAD4JwCAgOBWAgIAz3CAACQgEIDPcoAAMK4AgCOC +GWHPcIAA6CcAgDhgggpgDgKigOAqAgEAefAEhYUIkQAKhZDoDBUEEBAVBRAKIcAP63LPcAAAigxl +AaAAiiOOCyKFR4VAIQAHVnhGiGDCRogBHIIwRogCHIIwR4hhwkeIBRyCMAeIBhwCMIogUwHWDWAG +qBEBAAKFi3G2DeAMqBAAAM9wgAAkIBCAIIDPcIAA/CchoP4KoADFpQPYBKXR8ASFcwjRAEKFJ4VA +IgAHNngFiCkIXgHPcYAAJCADkjCBz3OAAPwnIIFhgwq4YnkNCQQACdgLpYvwBYWN6ASKgOCv8s9w +gAAwrqYJYA4CgIDgp/IFhQXoBdgLpQHYCPDPcIAA+CcAgIDgm/QA2BYPwAaX8ASF3QhRAK4NQAMi +hUeFQCEAB1Z4RYg5Ch4Ag7pFqM9ygADsOsmCz3OAANCxFRuYg/mCxYL+ZhYbmIP4gsSC/mYXG5iD +w4JXgl5mGBuYgwWIWQheAJoPAA6R6AohwA8ChetyHBUFEAQQhADPcAAAiwwdAKAAiiMQAI4PIA4C +2BoPIA4I2CKFBIkXCJEAAdgApQDYDqUGDyAOWtgihQSJCQhRAAHYAaUHhRzhFnkFiYYg/4zKIIIP +AAAwQ3gKYgTKISIAAoUnhRzgNngFiIYg/ocF8gLYBKUr8ATYBKUp8CSFAdhLCREBD6XPd4AAJCAQ +hyCAz3CAAPwnIaA2DGAGiiAMCs9wgAD8JwzZddoe25IOoAwYuwSHz3GAAPAnAID6CeAAIIEGpcSl +BNgDpQHYVQNv/6PA4HjxwOoKb/+KIIwJz3WAAOAGJIXqC0AGBIV7CBEAIoVHhUAhAAdWeESIz3CA +ANgGAJAB3iEKAQDPcIAA2gZAkM9wgAAMrgqQDQoBAMSlANhO8ASJHujPcIAA+CcAgJjoz3CAADCu +I4DPcIAA7CcAgFYIIAY4YIzoiiBMDYILYAaKIU0HWg3gBgDYAdgw8MSlAdgs8ASFWQhRAAKFz3KA +AIAhI4JkgGihI4JlgBzgaaEnhTZ4JIgDggDeNLAC2ATZYgvv/8lyz3OAAAyuQoUHhUAiAQcWeQqT +JIlEgg4IIAzJc8SlA9gDpQHYbQJP/wwVBBAQFQUQCiHAD+tyz3AAAIkMVQZgAIojDgHxwN4JT//P +doAA4AYEhqHBuugkht4KYAaKIIwKAd/PcIAA+CfgoADYD6YApgGmiiCTAcIKYAaKIVkFAt2pcEoI +oATpcc9wgACsBgCAJoCeEQAGprieGRgAqXAA2boK7/8E2loPoA+pcM9wgACAISOASIE0kVMiAABm +D+AL6XOkpulwivAEhmUIkQAkhmYKYAaKIIwKz3GAANgGiiCMDFYKYAYgkc9xgADaBoogzAxGCmAG +IJEChgSIFugJhpToz3KAADCuBoIlgg4ggw8HACChEQtFAAfYC6YB2AymCaYE8DhgBaID2DPwBIYj +CNEAJIYCCmAGiiCMCgvIBCCAD////wMLGhgwBNgh8ASGQwgRASSG4glgBoogjApTIMBAz3GAANha ++g4gAAChz3CAALStOoDPcIAA8KuEKQgJMCBADlEgQIAF2MogoQEEpiPwBIYB3z0IUQHPdYAAtK0a +hQTZmdoe20DAi3D6C6AMGLsahemmhCgICQAhgH+AAMSrK4ChuSugBtgEpgDYBvAEhg8IkAEB2LEA +b/+hwAbYA6YA2NXx4HjxwDoIT//PdYAA4AYEhaXBi+gkhToJYAaKIIwIAoUEiJfoAtgEpQSFpwhR +AAWFjQgRAM9wgAAkIASAz3GAAGhfAIAiDCAOIIGz6ADYN/DPcIAAJCAEgADexaXPcYAA7CcAgNYO +oAAggc9xgABoXwHfBNoAoc9woAAsIEAQBwDPcAAAUIFAwAXYQcBCx0PGRMbJcAbZyXOYdrh2ACeH +DwAAAH2GDaAE2HbkpelwLvAODKAEBdgE2APwBdgB2oPoAdgk8CmFIQlQAEylC6UM8ASFNwiRACSF +eghgBoogjAgJhQkIUQAB2A7w6+gChWoNYAQDgAhxz3CAAHRYugzADQDYBg9ABt3xANiZBy//pcDg +ePHAKg8v/4ogTAnPdYAA4AYkhS4IYAalwQSFgOCn9AKFR4UkgFZ4z3KAAKwkBCGBDwAGAACA4QHZ +Z4ogEI4AwHkTDsEQz3eAAAyu6pfBigsOwBMA3gXwxor7CYGDAd7PcYAA+CfAoZbuz3GAANgGIJEh +C0EAz3GAANoGIJFhihULQQDPcYAA3AYgiUaKCQpAAADZA/AB2ccJEAAcEAQAz3CAADCuDBgAAc9w +gABYoAQQBQDPcIAA+N4FgAUofgFAKYBykHDKIs4HyiCODwAAiAzKI44PAAABA8ACbgDKIc4Pz3CA +AOwnAIAeDOAFgHCF6FIKQA1N8AvIBCCAD////wMLGhgwz3CAAPReAIgA3sWliejPcKAALCAQgMdw +AAAAfRKlSBUHEM9wAAAUgUDABdhBwAHfQsdDxkTG6XAG2QTaANuYc7hz0gugBNhzz3CAAPRewKjk +pelwHPAA2M9xgAD0XgCpAtkjpRTwBIUB3iMIUQAFhZvoz3CAADCuI4DPcIAA7CcAgIIL4AU4YAXo +AdgBBi//pcDPcIAA9F7AqA4KoAQF2ADYBKWk8QXYC6VKDWAGyXAA2c9wgAD0XiCo6fHxwGoND//P +doAA4AYEhukIEQAChgSIE+jPcIAA+CcAgI3oz3CAADCuogogDgKAB+guCOAGANhRAwAAz3CAACQg +EIBHhiCAz3CAAPwnAYACeQKGVngHgA8JBAAB2ASmKQMAAACGC+gXC15AAtnPcKAA0BszoHIIIA4e +2M92gAAkIASGz3WAAOAGAIAKCSAOJoWA4PQCAQAEhs9xgADwJwCAxgugACCBBqUChSeFHOA2eAWI +hiD/jAryz3AAADBDz3GAABgovgsABAKFJ4Uc4DZ4BYhRIECAsAIBAACFCOjPcKAALCAGgIDgnAIC +AHoLAASVAgAABIaB4JD0JIaCDSAGiiBMCs9wgAAkIDCAIIFyDSAGiiBMCgKGJ4Yc4DZ4BRCGAADa +T6aBDh4Az3OAAPwnz3eAAOw6GIckh891gADQsRlhFxUAllirXBcEEAwXBRAAJQUBGBUElgJ5AiUF +ARUVAJYkFwQQAiQEgBYVDZYFh6J4yiWBEATyAd24qw3pQCyPAA0JxANPJYAQBfAF6E8lQBAPfRir +QSnAADhgCQhFAYK9uKtZDl4AAIYO6M9xoAAsICaBDoYieM9xgAD8JwWhQKYF8AGGA+hBpp4KAARi +D8ANJwiQAOt1Vg/ADQwWBBC4cM9wAACMDAohwA+pcu0HIACKIxMLXg/gDQDYAoYnhhzgNngFiIYg +/4wF8gLYBKa68ATYBKa48ASGGwiRAM9wAAAwQ89xgAAYKFoKAAQE2ASmBIaE4Kv0JIZGDCAGiiBM +Cs9wgAAkIBCAIIDPcIAA/CdAIA0HN6AmDCAGiiCMDSKGHBYEEEAhAAcWIAABBYg9CB4AANpKJMBw +SHOoIIAB8CXAEAHjGmID30okQHEA26gggAHwJcATAecbYxEKxQDPcoAA/CcYioK4GKoA3c93gAAw +rqWnDJFAJEIADwolAEemhxEABhEIXgAB2JINoAYMplrwKgpgBguGC8gEIIAP////AwsaGDAODGAI +q6aKIEwNjgsgBoohlA0HhiKGFnmKIEwNegsgBieBAtgDpgKGz3KAAPgnJIiO6SeGHOA2eM9xgACs +JCeJBIgwcAHYwHgAoinwIIIF6QHYA6Yj8CeGNngcEAQAz3CAAFigBBAFAM9wgAD43gWADB8AEQUo +fgFAKYBykHDKIs4HyiCODwAAjQzKI44PAABOBWAGLgDKIc4PpKZNAi//AdgMFgQQEBYFEAohwA/r +cs9wAACODD0GIACKI9UF4HjxwM9wgAD4JwCAG+jPcIAAJC0AgJnomguADInoC8gFIIAPAAAAPAsa +GDCKC4AMiegLyAUggA8AAADUCxoYMAvIkLgLGhgw2gnABdHA4H7gePHAdgkP/0h1QIBhgMGBAIGG +DC//yXEApckBL/8hpeB4QIAhgE4iA4AA2gMiQgBgoOB/QaDhxQHbz3KAAAAGfrLgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4BrhF +IM0Az3CgAOwnpqAKgADbALF+suB/wcXgePHAiiDKBuYJIAYA2fIKAAM6CIAP9g1AD4DZz3CgANAb +MKDRwOB+4HjxwKIID/8acAHfABASARPwWnUR8BUgwCOgkAIQEQEB59d1AAD7//B/dPYZCoAvAAD/ +/89wAAD7/90IgYTBAA//z3aAABwgAIYB4ACmFQhRAAHZz3CgAMgcMaAmCaAPKHAGvYG9QCkAJKV4 +z3GgAOwnBqEAhkIgQIAApt31z3GgAMgcANgRodfx8cDPcIAAxC4AgIHgyiHCD8oiwgfKIIIPAACv +E8ojgg8AAPMByiQiAGwEIgDKJQIBGggAANHA4H7xwNIOwA4OD0AM0cDgfuB48cC+D8/+z3CAAIAh +A4AogM9wgABEssC5NngkgACACrkEIYEPDwAA/Mm4JXjPcacAFEgNoQIJIAehwfpwz3GAABwgAIEB +4AChEwhRAAHYz3GgAMgcEaFaCIAPi3FGDu//QtjPcAgAhxDPd6AA7CcGpwLZANg6cAogQKTaccog +YiAPeS8lACRKIwAgFWkQuIG4h7iMuAanSiQAIYp1CiLAJGG9QChAIUAvgiFYYBUgTgOYdYAkgg3H +doAAgLICli8kCAFALIEBgbkceBC4JXgGpyKWwLm4eQUhwAQvIwggA5aYdYAkQg8vJAgBHHhALIEB +gbkQuCV4BqcDlsC4uHgFIIAELyIIIIog2AfqD+AFqXGKINgH3g/gBapxIpaKINgH0g/gBTx5I5aK +INgHxg/gBTx5QiRUIG0MVaBAKwAkBSCADwAAAi8Gp0AqACQFIIAPAADCMAanQiZBIB0JdYBAIUAg +ABQAMRC4gbiHuIy4BqfPcIAAHCAAgM9xgAAcIEIgQIAAoQb0z3GgAMgcANgRoXUG7/6hwOB48cAA +2I24agzgCwYaGDAMzIYg/4oI8s9wgABYNwCIgODwDUIE0cDgfs9xAwBADc9woACoIC2gz3GAAAQJ +QIEBagChz3CgADguBYAEIIAPwAAAAB0IgA/AAAAASNjPcZ8AuP8aoVuhadgYuBmhz3KAALRWBoID +gCCAx3EAAIgTQQOgDUhw8cC2Dc/+z3GAAKhhIYGjwULBz3GAAIAhFSEQAAAQACDAEA4GLyiBA04g +jQevDhAQEm0WeAAgkg+AAJDWBhKAIM9xgABQ2RZ5AIEikY7lCBxEMMogYQAG8otyWglv/wLBNugA +2M9xgAB4B0CBDyBAAy8hCiAEIYCgAKEH9IDibAiiB8ogIgiveKoNYAQQ2QDfBBrEI4ohCAAAGkAg +qXDpcaYIoAYP2gAQAiDAEgAGBCBABMAaGADPcIAA0Nm2eOCg4aDPcIAA8NW0eOCwECZOky8ogQNO +II0HrPU5Be/+o8DxwOHFCHUE8OIJgA1CCqANqXD86EUFz/6jwULCCRSAMIHgAdjAeBC4AeDgf6PA +4HijweB/o8DgePHACiHAD+tyz3AAAIonHNuKJMMPBQEgALhz4HiiweHFQsFBKAICB3pBKAEER3nP +coAAENbGuSpiJQrfAQgUAzHPdYAAUNmpcVZ5QIELCIEAQpERCsAAR4nvCt6BgNgD8AaJwcXgf6LA +4H7geOB+4HjxwAjIlbgIGhgwCcibuAkaGDALyIq4jbiQuAsaGDDPcIAAgCEDgBiIGQhRAAvIz3EA +AFgprLgLGhgw7gpgBg/Y0cDgfvHA4cUIdT6Iz3CAAFgXQIBAJQAUA7k1eVlh2gngDAramg/v/6lw +SQTP/uB48cDOC8/+SHXBgACAKHJ6CC//yXEApSUE7/4hpeHFYICggQGAIYECI0ODYKIDIEAAAaLg +f8HF4HjxwKXBQcBCwQwcADEQHEAxz3GAAHyUNBnADzAZAA8sGcAOKBmADiQZQA7PcIAAfJQgGEAL +z3CAAHyUHBgAC89wgAB8lBgYwArPcIAAfJQUGIAKz3CAAHyUEBjACM9wgAB8lAwYgAjPcIAAfJQI +GEAIz3GAAACUgBkACHwZwAd4GYAHdBlAB3AZAAdsGQAHaBmABmQZQAZgGQAGXBnABVgZgAVUGUAF +UBkABUwZwARIGYAERBlABEAZAATvoc6hraGMoSwZwAIoGYACJBlAAiAZAAIcGcABGBmAARQZQAEQ +GQABY6FqIAAD2BkAAGogwALUGQAAaiCAAtAZAABqIEAByBkAAGogAAHEGQAAaiDAAMAZAABqIIAA +vBkAAGogQAC4GQAAaiAAALQZAABqIIABzBkAAEDYn7jPcZ8AuP8doc9woP4AABahUyPABAUggA+w +/gAAFqEYgVMnzTVTJcQ1UybFNZS4GKFAwwHAAsHXugwUBjCpc9YJ4AUQFAcwVglgDADYz3GgAMg7 +LoEaC+AFfdj2CMADz3AAAK3e+g2AAAjYANluDCAGmbmlBsAM4HjxwOYJz/7PcoAAgCjPdYAA6F4O +6QCiAIWT6E4KIAEP2CYNYAcI2AHYAKUL8ADewKICCSABD9jWDGAHCNjApRUCz/7geM9xgACELACB +HNrPc4AA4AZAoEKDVSLACQGhoBIAAI24oBoAAM9wgAAoCaQaAACcEgABZ4MEoVUiQA0DoUAiAAd2 +eAWIGQgRCM9wgADYBgCQSHSAJEQTAKwe2wPwGNtioVUiQA14YAWhaQYgDChw4HjxwC4Jz/7PcIAA +OBYDgBDoz3KfALj/HaLPcYAABCAEgQHgs7i1uLi4BKEWos9wgACEBkCAz3aAALASoIYEIoMPDwAA +4AQjgQ8BAAAAEmlkeAd9oKaYdQQijg8AAABAz3WAAKwS4IUDvmR+PXnHf+ClBCQNAAQigg8AAACA +BiNAA0V5ArnkfgQjgw8CAAAAxnhkeSZ4LygBAE4gQQQNGlgwDwmQAc9wgACMyQ6QJ+jPcIAAOAcA +iM9ygACAIfAiAgC/EgIGUyJCgBn0z3KAAPRlBLgAYiMJkQHPcoAAnMn0IgIADerPcoAAWD0jgg0a +GDAB4SOiBPA3CQAAKHDPc6AAFAQKo89ygABYB0CKANkNClEASYMHChQOAdkB3Ynpz3GgAIggFXmg +oRPwBtjc8SoOoAsGGlgzEg5ABYvoANmRuc9woADQGzGgSg3gDalwSQDP/uB44H8A2PHA4cXPcIAA +hAaggHXYBCWNHw8AAODWCOAFiiGFCS8tQRPeD+//TiVAFAolAIAO8gohwA/rcs9wAADeDoojxQoF +BO//TiVEFH/YCrjPcaAA0BsToX/YEKH1B4/+8cB6D4/+z3CAAEQtIIAB3mB5yXDPcYAAVAhigQff +gODMIOKADfTPdYAA7A/hpQDagOPKI2IAc3vCu2KlDPAA2oDjyiNiAHN7wrvPdYAA7A9hpeKlI4HP +c2gf/wBjpYfpxqUTCNAA0aUG8A0JUQAC2AalUaVSpf/YANkJ2ghzSiSAAtIP7/5KJcAEANkT2v/b +SiQABb4P7/5KJUAHE6XPcCAAICAHpT0Hr/4A2IPoANgE8P8IUYAB2EjZDyEBAM9wgABAEOB/MbDx +wKoOj/4IduyIKJbPcIAApAaybyhzhiPzD7Z9QisRAsd1gACQ1mCFCHIJC14DRGjruYogwy8E9B4W +kBANjlEgAICi8nkJ3wArC94C/9gHrUokAHEA2agggAMoYgAhgw+AAHje9nsEqyhiAeEveQCrW/Aj +CRIhCiHAD+tyz3AAAC0liiMLBEokQACZAu//CiVABO65B40yIkIEACGBL4AAeN72eQjyRKkE2QAp +QQQleAetPfBAqQ8gQARj8C0IEiSMIMOvyiHCD8oiwgfKIIIPAAAuJcojgg8AAOQCyiRiAEAC4v/K +JQIE1gnv/8lwCJYLCJ4DAo4JrQPwAY4IrQCFMQjeAgDaR61KJABxz3GAAHjeqCDAAjhi9ngEGAIE +ABgCBAHiT3oBjgitAo4JrSzwTCEAocohyg/KIIoPAAAvJcojig8AAAEDPgfq/8oiygcIlgAhgS+A +AHje7rgHjfZ5CfIEGQIEBNkAKUEEJngHrd3xABkCBADZDyFBBCZ4B60BjgithQWP/vHAKg2P/s9z +gACsB2CDAN7PdZ8AuP/9hXlhz3OAAIgG4KPdpc9zoABQDGCDx3MAAABAInvNuwsLBQDtCx7Az3GA +AIgGYIHPcZ8AuP99oVEjAMDKICIAH/Q5ClEAz3KgANAPEBIBhikIVADPdYAAcBifcGOFqCDAAgKN +JRIPhsG402jYfwHgAq3ne2OlEBpYgAHYAQWP/uB4z3CAAPCw4H8GgOB4z3CAANyw4H7gfuB4KHIJ +ACAAANnhxeHGQCkNAiV9QC0DFKV7JQo0Agh1UyV+kAbyAR1SEGG6+/FBKo4AwbpCJk6QBB3QEP31 +CeovJIlw4HioIEABAR1SEOB4wcbgf8HF8cDhxc91gACsqSCNjCHDjwnyB+jPcIAACFcWCUAN/9gA +rc9wgABUqQDZNaDPcIAAbBggoM9xgAAkLQCBorh+DqAJAKEA2AIK7/8IcVEEj/7xwOHFAN3PcIAA +6AegoM9wgAAkLaCgz3CAAEyuqXSdsDC8nrBKC2AEqXCpcIIPYAipcR0Ej/7gePHAmguP/s9wgAA4 +FgKABxIPNg0SDjYBEhA2EOjPcp8AuP8dos9xgAAEIASBAeCzuLW4uLgEoRaiBtgNGhgwz3WgABQE +CqUJhSboA9gQpQSlz3CAAIjfFgrgDQMaGDCS2QPIkLmgGEAAPg4gBADYCYUO6CgVBBAkFQUQHtgK +IcAP63KMuIkHr/+KIwQGBxrYMwEaGDTPcIAABCDKpQCADRqYMxEIngDPcZ8AuP8A2B2hTQOP/vHA +7gqP/qHBCHUodoogRA/uC6AFqXELDdUQE92X8KlwyXGiDe//ANrPcqD+7ALPcZ8AuP+F6EhwFqG2 +oe/xQCIADhahtqHPcqAAUAwFgs92gAC8rhKuBYITrgmWjCCIgCptRvIR9kUI0AGMIMSBafRbCZQA +z3KAAAij4gvv/kAiAAJIcR/wjCDIgEvyjCAQgFf0BYIJaQsIVQEA3VLwvgigBgDZCHVO8JMJUQDP +coAACKOqC+/+QCKAAguKgbgLqu3xC4mAuAup6fFzCVEAjgvv/otwIMDPcYAACKNTIAIAhiB/D0ip +HHgJqe3xTwmUA89wgACAIQOAGIhDCFAAz3KAADygSHBWC+/+BtlAIgACSgvv/gbZDJKBuAyyv/Ef +CRQBz3KAADygQCIABS4L7/4E2QySgLgMsrHxE90C8BzdiiBED7oKoAUplqlwDQKv/qHA4HjxwM9w +gAA8oAyQDQgeAMIJAAQG8FEgQIBcCwIEz3CAAAijC4gRCFAAEwiRAC4MwATRwOB+Pg3ABPzx/PHg +fuB48cBWCa/+SiRAcc92gABwyCSGAN2oIEACAN8PJ08TCyHAgwT0AeUN8IogSg4+CqAFqXEEhuZ4 +BKYqD2AAqXAEhoDgZAjhAMogYQJ1AY/+4HgIczhg1bvVuQ0J5QA2uAIjQgAK8M9ygAD43kWCAeDJ +uCJ6emIWuOB/RXjgePHA2giv/phyCHXPdoAAzKP0JkAQz3eAAEyjUSBAgsogQQDKJCJ0yiAiAOgg +IgL0JgIQCQpeAgHgRwgVBC27wLvPcoAA8NW0ekArhQJgkgS9hiX4E4m9DyNDAGCyANoWf0CnQafD +uaV5BSFDARR+YLbPcYAA7KMVeQAZAAEC8IDYwQCP/uB+4HjxwOHFz3GAAFyoQYnPdYAAbBjPc4AA +JC0ggwfqAdgApYK5IKMI8ADaQKWiuYDgIKO0CoIJANg+Dq//CHHmC2ACANiJAI/+4HjxwA4Ir/6Y +cAMSATYAkSGBQOD0ucAgogAD4AQggA8AAPz/z3GgANQHDxENhgAgBQETDSURANoNyBUiAzAOEwAG +HWUZEQCGAiVDA3sIxQAF3Qy9z3CgAMgfvqAQ3a6gAd0VGFiDz3afALj/vYbPcIAAiAagoF2mGREA +hgsIxQD7Cx7Az3CAAIgGQIDPcJ8AuP9doDMLHkANyBUiAjAOEgIGz3CfALj/VqB2oBkRAIYKIcAP +63JD2M9zAABEFr0Dr/+MuA8ZWIG1B0/+4HjxwBYPT/6rwc9wgAB43wAQEwAHyAQggA/xAADwQMAN +zADez3WgAMgfUSBAgM9wgAB43yGAA8gP8qAVAhD4FQMQYnkCIlcAdhABAS8nyCVZYQTwhBAXAeJx +OhjEBR+FDwhFADB4Rg/gBQLZAdnPcKAA1Ac0oDOgA9/toBEQAIbPcaAA1AdBwEDgDxkYgBQZmIMD +yKQQAQANCR4CCgyACwTwRx2Yk89woADUBw0QAIZALwEkEHgFIRUAA8ghgAAQEgFDwbgQmAByEAEB +uhAAAQIhFAbiD6AGRMAZCFEAz3CAANgfAJCB4AHYwHgMuELAA/BCxgPIz3GgANQHWYCIGYAApBAB +ANmguBiCA7oYhAO3uaQYQAADwBMIngXPcqAASAhAIgEjBvBAIgEhz3KgAEwIBMACwwNxZXgFJRUg +B2nPcwAA/P9keM9zgAB432ODCCDFAM9zoADUBzWjABpABQIiASUvowIlAQA7o/Cjz3KAAGg3DRIB +NgCCPQhAAM9woAA4LgWABCCAD8AAAAAhCIAPwAAAAPXYBbjPc58AuP8aozujadgYuBmjAdgD8Mlw +CQhRACCiz3CAAHjfBBAEAAIjUyHPcoAANLKIcIAgDwoepRDYDqUB2BUdGJAHyAQggA8BAADwLLgD +EgM2BLIPg86qAKJAEwABArIQi2ATAwFAKAUBw7sFI0MBZrIPqi8jCAHPcIAACMpAIAUJNXgpgM9y +gACMyTtjaaCkFQAQ+BUBEIBwInhFwAHYz3GgANQLEKEDwDW4wLgXuAAggQ8ADgAAz3CAAHjfAoAC +uCvgBCCADwAA/P8leOxxAKEBEgE27HAgoM9wgAB43yKA7HAgqA3IFCIBADCJ7HAgqOxwwLADyJQQ +AQDscCCgDcjwJQEA7HAgsOxwwLDscMCg7HDAoAcSATbscCCgA8ggkFQQAAEQuSV47HEAoQMSAzYB +gx8IHgEyi3CLz3CAANDYdngAiIYgfwwceAS4JXgC8IDY7HEAqQPIO3YwiDMQgAAEuSV47HEAqQPI +GnY8kOxwILADEgM2z3CAAIBanBMBAW+DJrnAucC7DLkNu2V5IKANEgE2ACGAD4AAtMnAqM9wgAA4 +yTZ4NHrAsgKQwBqEAxUlQQB4GgQAz3CAAIAhBIAakNAahANGwM9wgAB43wKAwKGA4MoljhMUAy4A +yiGOI8l3yXU6dkwgAKC48hPwz3GgAPxEHYE5gQQhgo8AAAAIEfQEIL6PAAYAAAv0TwsfQM9woAD0 +BweAAN7VCN6HLfAA3vq4yiaCHwAAAQL5uMomgh8AAAIC/LjKJoIfAAABAgrqz3OAANw8UIOKJggS +AeJQo8YMwA4R8AHZz3CAAHxaIKB2DmANKHDPcYAAWD0NgYomCBIB4A2hBSWNkxDyawIgAADehBIA +ACsIlAydCx9Az3AAAJATFg4ABc9yoADUBw+CEHgZEgGGWODbCQSACfDPc4AAYDwkg4ohECEB4SSj +iwmfIB4a2IMdEgCGBxoYMB0SAIZKwB0SAYYEyCCgHRIBhiGgHRIBhiKgHRIBhiOgHRIBhiSgVicA +Eh4aGIAdEgKGQC8AJFB5BSEVAAQSATaGIvMPABESAYwiDIABgUPAF/Ia2Bbwz3CAAHjfCBAEAAAQ +BQAKIcAP63JX2M9zAACME9EGb/+MuADe0PAg2JpwA3AQeHIZBAAA3gkIESADyHTwA8ATCJ4Fz3Gg +AEgIQCIAIwbwQCIAIc9xoABMCEfBA3BIwATBAsAleAUlFSAIwAfgz3GAAHjfI4EEIIAPAAD8/wgg +VgAMJsCkLAEtAEnASg0AAAUlDZCZ9AHZz3CgANQHFBhYgFUnQRQPGFiAAQofQgjAz3KgANQHFaIH +wwIiACUAG0AFD6IJwwImwCAbogPYEKIqwJzgANmP9AcSDjYAwAQmgh/xAADwUHCV9APIqXLIugIj +kyUIiAy4RXgDEgI3ELpFeOxyAKIKwEAhWTABGhgwBMgDEgI2KHZBxwMaGDAEGpgwIYAAkAHHNLnA +uTR4A+BA5wQggA8AAPz/H2cNEgE2B/AVIkAwDhAABgJ/FSJAMA4QAAbxDwWQA8zPcZ8AuP8Yoc9w +oAD8RD2ABCG+jwAGAABc9BsIECAEyFCIUyLBAIYi/gNEusQYggAwqM9woAAUBMSgB8jPcaAASCwd +oc9wgAB43wKAQCBQIBJwGAXN/wzwz3KAAGA8I4KKIRIgAeEjogLwOnUODMAFUyF+oAT0BgwAAAV9 +nQ0QEIcNXhADyCmIAeEpqM9xgABgPAaBAeAGoT/wCiHAD+tyKBQFMDzYjLjPcwAAGxTpBG//SiRA +AAAUBDBH2AohwA/rcoy4z3MAACMUzQRv/7h2TCAAoM9ygABgPIolEBAJ9AfIz3OgAEgsiiUIEB2j +EQmeBgWCgL0B4AWiufEGgoG9AeAGorPxEw0eEM9xgABgPAWBAeAFoTp1A8ipcci5CIgMuCV4AxIB +NxC5JXjscSp0hCQCkQChQCFPMBzyz3GgANQHgBnABAPMKnLIuhC4RXjscgCizKEB2BQZGICuCeAO +AefPcaD+hADPcJ8AuP82oAMSAjaSEgABBBIBNg0InwKSEQMBbQueAqq4khoEAJIRAAGquC4K4AiS +GQQAENnPcKAA0A8QGFiAJBABhs9ygACI40WSMHkCukV5DBhYgBTZEBhYgM9xgACI42eRRpEY2RC7 +ZXoMGJiAEBhYgM9xgACI42mRSJEQu2V6DBiYgAbwz3CAAIjjyqjPcqAA1AvQoscJECDPcaD+uADP +cJ8AuP82oAbwCNnscCCgAefPcIAAeN8CgPEPBJDPcIAANLIkkJThwCGGDwAAkwDPcKAAaCzwIEAA +z3GAAIBaIIHPd6AA1AcleA2iA9gSp84KQAsPDV4Svg6v/wHABvAD2BMfGJAUH5iTMQgQIM9woAAs +IDCABcAwcAHdyiWGEwQgj08gAAAAz3AAADUVlgkABYDlzCchkOzzz3AAKAgABhoYMAbAUg6gBclx +USFAoK/yz3CgACwgz6Cp8M9wgAA0OhGIOQgeADUIHkPPcYAAgCEjgc9wgAA0OhCIELgyIYEPAADY +Ap+4gOEB2cB5D7kleM9xoAD8RA2hGwsQIM9woAD0B2AYwATPcYAAYDwDgQHgA6HPcIAANLIkkJTh +wCGGDwAAkwDPcKAAaCzwIEAAz3GAAIBaIIEA2s92oADUByV4z3GgANQLDaFMpoogBALiDiAFqXHK +C2ANBsAZFgCWwOCeAA4ADcybCF4AA90gHliTAdgUHhiQBBIBNgAWBEAHGhgxABYFQAEaWDEEypzg +yiLCB8oggg8AANwOyiOCDwAA9AroAWL/yiHCDyhwjgwgDg7ZDxYAlgQSATa0GQQAEx5YkxCJUyDC +AIYg/gNEuMQZAgBQqc9wEiAAAA4KIAQNEgI2BMjPcaAALCCwEAABL4Fk4DBwyiCFDxIoCACE989w +ACgIAAYaGDAA3g3MBCCADwAAAggVCJEABBIBNoogBAAqCWAJmBEBAA3Iz3GAAJzJz3KAAHDIFHnA +sSaSz3CAAHjfAoAZYTB5JrKt2M9yALsAu6oMIAcFuAPIGpCKDGAHDRIBNs0EL/6rwOB48cDhxU8I +XkPPcIAAeN8BgM9xoADIH5YgQQ8eoRDYDqEB2BUZGIAmDaAOQdgnCF5DAdnPcIAAfFogoKoPIA0B +2M9xgABYPQ2BAeANoYolCBIt8M9xoAD8RB2BOYEEIYKPAAAACADdB/QEIL6PAAYAABjyAN36uMol +gh8AAAEC+bjKJYIfAAACAgnqz3OAANw8UIOKJQgSAeJQo4oNgA4H8APZz3CgABQEJaB9BC/+qXDx +wP4LD/4Idc92gACkDQCOqMGzCBEAi3fpcM9xgAAsYqIML/4g2gHYAK4A2I+4CxocMADYFRoCMM92 +gAAAAKC2Dw2BHwAA/soHwIC4R8DPcKAArC8agFIgAAATCB4AAZaAuAG2B8CBuEfAz3CAAOxloIiC +CaAEqq7PcUN1qBJAwYohGgpBwSuOBKZGwOlwY8ENHEIzz3GAAKQ+RMHPcYAAED5FwSDZAdo929oO +YAsXuwjYzg1gBQHZAtnPcIAAzCckoKUDL/6owPHAMgsP/ih2z3GAAIAhLyAHIIToYYED8GCBxBMD +BiW78CENAMC7gOaioaOhzCMhgAHdyiUhEM9zgADIJOiLKw9REuGBxBcPFh8PXhHsk36RFw/AEBEI +UACH6ACBxBAABgcIXwEA3YHiyiUhEADfCgqgC+lwCnBuDiAGqXHPcIAAzCcEgCMIngDPcIAAnDkA +gIvoz3AAABYJEgnABAsIUQAKDoAKDPAA2Z65z3CgAPxEIaDgeOGgwgmgCwDYgOaYC2IAyiBiAJoI +wASF6A4KAA0D8EIKAA3PdYAASBEAjYbojghADAHYAK2tAg/+8cBKCg/+z3WAAHDIxJUg7s9woAAs +IDCAAN8GhSelDiBAAMYLL/7JcQiliiCKCzILIAXJcYogygsmCyAFKIXktc9woAAsIBCA5bUGpWUC +L/4IheB48cDuCQ/+OnDPdYAAcMgAhc9xgACYMQK4FXgVIEAEMCEQAIogSg3mCiAFKnGKIIoN2gog +BQpxIQgRIQAVBBAKIcAP63KKIMwMiiPFAhkGL/8KJUAEaQgQICcIUCA7CJAgJQjQIAAVBBAKIcAP +63KKIAwNiiNFC/EFL/8KJQAEzgoAAB7wiiAKC4IKIAWKIcUGagkAABTwAIUD3hUIUACKIAoNagog +BYohBQnApQDYBaUEhaC4BKXGCWAAA9iRAQ/+8cDPcoAAcMgmkgHhB5IweTEIYwAmsgSKDQhRAAWK +geAB2APyANgO6CIKIAWKIIoOiiDKARYKIAWKIYYMnggAANHA4H7xwOHFz3CAANzKQJBEIgADfwgR +AgDdz3GAAHDIpaEEgaC4BKFLCp8BBJHPcoAAyMgB4ESCEHgtCiUABLEEiQ8IUQAFiYHgAdgC8gDY +CuiKIMoBtgkgBYohhgE+CAAAGfDPcIAAcDUDgBDoA9gP8M9xAAD//5IJIAWKIAoOz3GAAHA1A4EC +6KOhBNiWCQAA3QAP/uB48cDhxc9zgABwyAQThAAPDFEABYuB4AHYAvIA2IvoBROFAAohwA/rcoog +jQ6hBC//ztsC2ACjAN0Ek6mjpaOmswqjBIOks6C4BKOKIMoBJgkgBdXZEgtgBqlwfQAP/uB48cDh +xYogCg0KCSAFwNnPdYAAcMiKIMoL+gggBSiFANkD2AClJaUkhaC5Pg+gCySlRQAP/gDZz3CAAHDI +KqDgfymg4HjxwL4Pz/3uD8//z3CAAJzIYIDPcoAAcMiogGCiz3aAAOgxBIKoogDZwIaguCWiBKIv +DlEQguPMI+KAGPTPcIAAcDUjoArtiiAKC4YIIAWKIQQLbg/P/wrw0goAAAbwAdtgoiiioLgEosEH +z/3xwFIP7/0A2M9xoAAsIFCBz3aAAHDIJI7PdYAAnMgIpQsJUQAljgkJUAAB2KLoKoYc6QaGtggv +/g4ggADPcQAAECclCQUAz3GAAPjeJYGZIc0KGQhFAAXwz3AAABAnCKUC2AfwANgH8AmG+OgB2ACl +AdhNB8/94HjxwOHFCHWKIAoO4g/gBKlxz3GAAHDIBIEPIEADBKE+DyAACdgpB8/98cCuDs/9z3ag +ACwgEIbPdYAAcMgHpc9wgADkWJoLoAwA34ogigueD+AEJJUAFQUQJQ1QAEwlgIDMJeKATvIKIcAP +63KKIEwNiiMIB9ECL/+KJIMPBJWA4JbyDgzP/89wgAD43gWAKIWZIM0KMHAB2MIgDgCA4Ijyz3CA +AAA16aDXcQAAECdvIAsAH+gEjQ8IUQAFjYHgAdkC8gDZiiAKCwjpIg/gBIohxwSqDc//bPASD+AE +iiEHBs9wAACIE/YN7/8IpWDwiiAKC/oO4ASKIQcI4g3P/1jwBJWh6CWVCIWB4cAggQ8AAIgTA/Ib +eAiliiAKC84O4ASKIUcNz3CAAPjeBYAohZkgzQowcAHYwiAOALboCgkAADTwEQhRAIogCguKIYcO +KvAIhR1413AAABAnCKVvIAsAHOgEjQ0IUQAFjYHgAdkD8gDZiiAKCwnpcg7gBIohiAH6DM//EvBm +DuAEiiHIAs9wAACIEwilCPCKIAoLiiHIBEoOwAQ2Dc//BJUFtYogigs6DuAEJJXktRCGhQXv/Qal +8cDPcYAAWKBBgc9xgAD43iWBBSm+ADBwyiBOAAwhAPDPcQAAECeODu/9yiBFDs9xgADIyASh0cDg +fuB48cDhxQDYz3OAAHDIAKPPdaAALCAQhQHZz3KAAJzIBqMQhSCiBqLPcIAAADUDiCSrjCCDhiSq +BPIlqiWr7gsgAAPYEQXP/eB48cDhxc91gABwyIogigyaDeAEIIUB2PUE7/0Apc9wgACAIQOAz3Gk +ABxACIDAuBN4wbgSoeB+4HjhxQDaSiQAdM91gABMo89zgADEo0hwqCAAA0AjAQIUeUCxFiUBEECh +QaEB4EokwHMA2aggQALPcIAA8NU0eECwAeHPcIAAdAdBoM9wgAA8oEyw4H/BxeB4BfBCecdwQAAA +AM9ygAD43kWC8wpEgFMgQwVwccAgjQ9AAAAAwCCNAOB/IngG8GJ5AiCAD0AAAADPcoAA+N5lgu8L +RIBTIEIFOmILC4QAOGAH8AIggA9AAAAAYng4YOB+8cCiC8/9z3CAAGjLDIgZCN8BArjPcYAAkNYW +eAVhLb3AvQPw/91CCoAECejPcIAAyCQIiIfgAtgC8gDYz3GAALyud4nPcoAAVLshggkLQAAggoTp +Ad8D8ADfz3aAAIAhIIbEEQEGVQleAajtI4Y4iUkJEAEmC4AMz3GAAGg7Ge/PcoAArAcCggHgAqIA +2M9ygABYWgCiz3KAALRZAKLPcoAAjAYAohGBAeARoQTwEIEB4BChdgwP/q4JgAQO6M9wgADIJAiI +iODMJWGQBvTOCqAMAdg6CYAFjCXDn0nyEe/PcYAAbBgAgQvoANgAoc9xgAAkLQCBorg+DeAIAKE+ +DQAMz3GAAPjeBoFFIEABBqHPd4AACKMLj1EgwICgD8L9C49RIICA2AwCBP4MwANKCYAEgODwCiIA +yiAiBgbtAIbEEAAGKwhfAc9xgACkOQSJD+gDiYroiiDQDl4L4ASKIUUDcg3gCgPYvgogABXYnQLP +/eB44cXPcYAAcBgAiQHbYakk6M9woACwH3mgz3CAACQgCICjgWCAAoEA2jENARDPcIAAiBgAiIPo +AdgK8AGBAiMNAPcNhZ9MAEBLQalIcAcIUQBhoUKp4H/BxaKh7/GA4AHYwiAMAM9ygABwGACqAdgB +qgDYAqoBogKiA6LgfySi4HjxwK4Jz/0IdSh3SHaKIEcNsgrgBIohVgMRDRQUDtjpcWYML/8A2oTo +E90t8M9ygAC8rkhw6gov/gzZz3GAAHAYAIkP6M9wgADcygCQhiD8AIwgAoAF9AWSZJJneAOhQiUA +E74PoAXJcQolAJAL9M9wgADcygCQhiD8AIwgAoAED8H/lQHv/alw8cAeCc/9OnAacTIK4ARn2GjY +KgrgBCpxHwkUJwohwA/rcs9wAADjDoPbCiRABGkF7/4KJQAETCCAocohxg/KIIYPAADkDsojhg8A +AIQAyiLGB233ANrPcYAAwJWeuhUhAQQAgQEqQgRGeL4JYAcAoQ0Bz/2NB+//BdngePHA4cUA3c9w +gADAlSYML/8c2RvYpgggAAXZSiQAd89xgACQGKggwAIWIUADBBAFAJh1Dw1BEUAkTQDpAM/9CiHA +D+tyd9gFuNEE7/5T2+B48cDPcIAAwJUYEAUALyxBAUwkAIfKIsYHyiCGDwAA4g7KI4YPAACrAKAE +5v7KIcYPz3CAAJAYFiAAAQCAQHjRwOB+4HjxwOHFz3ADAEANz3WgAMgfRR0YEKoPz/+A2BUdGJBx +AM/94HjxwOoPj/06cBpx/gjgBGXYZtj2COAEKnEfCRQnCiHAD+tyz3AAAOMOY9sKJEAENQTv/gol +AARMIIChyiHGD8oghg8AAOQOyiOGDwAAZADKIsYHbfcA2s9wgADAlZ66FSAABCCAASpCBEV5ighg +ByCg2QeP/Y0H7/8F2eB48cByD6/9/9rPcIAA0LETGJiAHBiYgADez3GAAOAGw6HPcIAA9CdAoAHa +z3CAAPgnQKDModCh0aHPocChwaEC3cl3z3CAAMSrhC8IGQAgQg5LgidwACGQf4AA0KtGIsIAS6Ae +DGAMQCAAIWG9JBiCI9MNdZAB5wLYANk2CG/+BNrCDuAEAdhRB4/94HjgfuB44H7geOB+4HjgfwHY +4H7geOB+4HjgfwDY4H7geOB+4HjgfuB44H7geADZz3CgAMAdJ6AmoC2g4H7PcYAA5DsSgQHgEqEN +yMdwgACoySyIAeEveSyoz3CAANyVAogTCEMAiiAIAAYaGDCK2JC4B/CKIBAABhoYMELYmLjgfgLY +z3GgAMAdDaEh2AahAdgHoeB+8cBWDo/9mBACAAQigQ8AAAAIO3kEIoMPAAAAECV7z3GAAIAhpIFW +JU4UViUPFZgQgQAVCl4ChiH/A0S5L2eJv+lxGfBRIgCCvBUCEQzywrmAJQIZP2Xojz1lMI1lf/B/ +RXkJ8MO5PHk/Zj5mMI7oj0V5iBjAA2V5RQav/YwYQADxwOHFA8ikEAEAmBACAFEhAIByEAEBSHAG +8kYK4AIA2gh1B/AB4ToK4AIA2qxohg+ADM9yoADIH/gSAQADyM9zgACQ1hCIArgWeABj7bjPcIAA +JCAI9AHbc6JIgECCDIBggAjwAttzokmAQIINgGCAAiVAEFhgEHLAI20ADXEAoQ1wYKAAFgBAABYA +QAPIz3KgAPQHcBABAWi5J6JwEAEBaLkweakFr/1wGEQA8cAqDY/9z3agAMgfoBYEEPgWAxAA30kI +EQEDEgE2pBEAAHYRAgERCB4Fz3CAAHjfoYAE8IIRDQENzFEgAIGEEQABCfICJcEQAiRDAAgjAwAE +8IYRAwEbY2hxcfCVCFEADRIBNwPIeBACAUcJHgFRIUCAz3GAAIAhJIFUEQEBCfJ+EA0BIn1ifQIk +QwMr8IAQAwHPdYAAcNUAI0QAcIh2fWCVACMNAYQQAwG7YxvwpBABABUJHgVwiM9xgABw1XZ5YJEE +8IIQAwHPcYAAgCEkgYAQDQFUEQEBPWW7Y4QQDQG7Y4AQDQG5YX4QDQFCfSfwQwiRAAMSDTYNzHgV +AhFRIACBz3CAAIAhBIBUEAEBCfKAFQARInhieAIkAwAH8IIVAxGEFQARO2MbY4AVDRFCfQXw6XPp +cul16XENzBEIXgADyHYQAgFiujpiDPAVC3IAYrrPcIAAgCEEgEYQAAEaYvgWABBdZQJ9H4YZDQQQ +oNgPpv+mX6YC2BUeGJCA2A6mEQSv/XB44HjxwKILj/3PcYAAgCHwIQIAViJFBAiCViIEBVEgwICK +IAgAyiAhALwaBABKJAByANmoIEAPz3WAADBn/IouZeR+LyiBA04ggwfPcIAAGGlvYAAlQwDgq0QS +jwDkfi8ugRNOJo8X7mDIq8iCIQ7eEB2KhuHTIKYALygBAE4gjQfPcIAAmGWoYBHwz3aAAFhnLmbO +ZbyKxH1YEo4AxH0vLUETTiWOF8hgEKsB4UokAHIA26ggwA/cis9xgAD0aG9hz3WAABhp5H4vKIED +TiCPB+9lACXAAPyoRBKPAOR+Ly6BE04mjxfuZSQYggPIgh8O3hA9ioDj0yGhAC8pQQBOIY0Hz3GA +AJhlqWEQ8ATryWsD8Gh2zmE8isR5WBKOAMR5LylBAE4hjgfJZSwYQgAB40okAHEA2KggAAXPcYAA +lGV9iglhACQMAAHgZHkvKUEATiGDB89xgACYZWlhIKytAo/94cXhxs9zpAC0RSkTAIbPcYAA7DrI +GQAAKxMAhswZAADPcKUACAwDgOQZAAAOEwCGEHowuNQZAADQGYAADxMAhtgZAADPcIAAGMvUiLaI +6BmAA3iI7BlAAw2Q8BnAACzgAiCCA/QZgAACIEIDYnj4GYAA/BkAAMHG4H/Bxc9wgABcWgaAA4Ag +gM9wgADoleB/KaDgeOHF4caYcM9ygABwGQWCIIJmgsq4ELjKuQUhAYABgsq7ELvKuAUjBQBnggKC +yrsQu8q4BSMHAGiCA4LKu8q4ELsFIwYAJPIAFA4ALyhBAE4ggwcA2A8gwAASfQQgQwGkfmV+AByA +A9qCpH7Fe3qieYIEII4BBCDAAaR7xXt5oniCpHsEIUGDZXgYot/1wcbgf8HF4HjxwBIJj/06cAWB +oIHKuBC4yr0FJQ2QAYEmgcq4yrkQuQUhEAAB3hnyBCWAkxPyLygBAE4gggfwIYEgAN8PJ48QCOkE +JwAUQiAAgGB5yiBiAOZ9237q7R0Bj/3geOB/ANihwfHAsgiP/aPBCHVIwM92gABwGRqG+4Y8hgR/ +JH+nf0HHrgmgBIog2ASKINgEogmgBKlxlu/RDREQxg/gBArYxQgQAAohwA/rcs9wAACNE4ojRwBK +JAAA0QSv/golAAEEFAExGOkgFAAxCyBAgA3yz3CAACwtYIDPcQAAcFAM2GB7A9oI8Ijoz3CAACgt +IIBgeQzYBhQBMRjpIhQAMQsgQIAN8s9wgAAsLWCAz3EAAHBQDdhgewTaCPCI6M9wgAAoLSCAYHkN +2AQnUJMK8nII7/8K2IogGAj2CKAECnET8JHtiiDYBOoIoASKIUcLHg+v/wrYiiAYBNYIoATpcWII +AAC8pgjcFwCv/aPA8cCuD0/9CHYA3Yog2AO2CKAEyXHPcIAAcBlagDuARHkA2g8iggMEIkMAQiMD +gMojYgAvJsfwAd/KIEEDB/IcgCR4tg7v/0V46XDNB0/94HjxwOHFocEB2EDAz3WAAHAZCoUbCB4A +i3AE2WfaPdvGCuAKF7sKhaC4CqWtB2/9ocDxwCoPT/0acCh1SHdodjhjZtk92gYL4AoXuhcIUQAK +cOIK4AqpcelwsgrgCslxYQdP/eB48cD2Dk/9psEodRpyYMAA2AEcAjAB2AIcAjADHAIwi3CiDWAH +gcEG7QTBCnBgfQXCA8GO6QohwA/rcs9wAACME+7biiTDDyUDr/64c2B5ANgJB2/9psDgePHAmg5P +/aLBAd7PdYAAcBk6hRuFJHg8hQQhEACaD2AEiiCYA2cIECAC8Nt+BCCAo/3zLygBAE4gkQcVJU4U +HYZcHUAUgODKIcEPyiLBB8oggQ8AAI8TyiOBDwAAHALKJAEEsAKh/solQQTSD4//HYZAeHYPj/+K +IJgDPg9gBCpxANgPIEAEBiAQIGIN7/8KcIogmAMiD2AEPIVhBm/9osDxwLTBiiCYAw4PYAQA2VoN +YACLcIogmAP+DmAEENm0wNHA4H7xwLTBiiCYA+oOYAQC2XYNoACLcIogmAPaDmAECdm0wNHA4H7g +fuB4ANnPcIAAQC/gfzig8cC0wYogmAO2DmAEA9nOCOAAi3CKIJgDpg5gBAvZiiCYA54OYAQR2bTA +0cDgfuB44H7gePHAdg1v/QDZz3aAAHAZF4bPdYAAgJgPIQEAGYYkeEIgAIDKIGIAocEB3xcIUQDP +cQEAdL4L2EoO7/9VJcIXN4YA2A8gQAA4hiR4QiAAgMogYgAA2SMIUQAL2GDAARxCMAIcwjMDHMIz +i3AE2VUlwhfaDe//VNsA2GUFb/2hwOB48cAGDQAEz3ABABxACejPcYAAcBm4GQAAG4GRuBuhz3AB +AIA/COjPcYAAcBkeoRuBgbgboc9wAAB0Uwroz3GAAHAZlBkAABuBiLgboc9wAAB4Uwroz3GAAHAZ +mBkAABuBibgboc9wAAC0Uwroz3GAAHAZnBkAABuBirgboc9wAQA0Rwroz3GAAHAZ2BkAABuBmbgb +odHA4H7xwOHFocHPcoAARLLPdYAAcBkXhQDZDyEBABiFJHhCIACAyiBiAAHbANkjCFEACNhgwAEc +QjACHMIwAxzCMItwBNnyDO//iiMIAAjYANkaDe//KHIA2IEEb/2hwPHA+gtv/QjZz3Kt3u++Sgqg +Ajpwtg8gACpwkQjQAM9wgADolQOQTiDPAVEP1RHPcIAAYA4aDiAB9CDAAwDeAN0E2BpwKnDpccly +CiSAD63e774GCqACqXPKDyAAKnBNCNAAQiBAIN8IdYAB5QHm0w6UkAHnuw/UkSpwz3Kt3u++1gmg +AhDZRg8gACpwHQjQAM9xrd7vvsIJoAIqcAoP7/8qcIPgyiAiALEDT/3xwFILb/0D2qbBGnBGCWAL +g8EDwc9wgAB8EhQUBzAA3vAgRQDPcIAAhBLwIEYAz3WAAOwHDtjEpUDABNhBwM9wrd7vvkLABMIK +cIDbXgmgAphzzgkgAApwfQjQAAPDz3CAAJwSQoXwIMEAwKUMFRAQwaUI6c93gACkEvAnwBCG6MCl +waUA2RnwhCoMA6YIYAAvcA4ggQ8AAAABIKUDwIQoDCPwJwEQjghgAC9wDiCBDwAAAAEhpQSFGwhR +AACFEXiMIAeNwvfApTF5jCEHjcP3waUA2OECb/2mwOB48cB6Cm/9BNqmwW4IYAuLcc9wAAAb0gDd +qXHiDCABqXIAwc9wAAAc0tIMIAGpcgDBz3CAAAwOAcIVIEEAAJECwQW6ng0gAUV5A8CA4NoABQDP +doAA7AfS2Ai4GdmeDCABANrPcAAAItJAJgES1gogAQTaz3AAACPSQCYBE8YKIAEA2s9wAAAg0oTB +ugogAQDahcfPcAAAIdLpcaoKIAEA2gKGF9mODOAKQCYCEgOGF9mCDOAKQCYCEwTAF9l2DOAKhMIF +wBfZbgzgCulyAoYA2YYPIACLuQKmA4YA2XoPIACLuQOmBMAA2Qi4bg8gAIu5CHcFwADZCLheDyAA +i7kihjF5GeEFKX4AI4YvclB3MXkZ4QUpfgAvccwgRYCF9wPAAeU3CEWDA8APCEUDAdnPcIAA7Ack +oADYqQFv/abA4HjxwD4Jb/0J2qnBCHYqDyALi3H2Ca/9IcAIcULYggwgAQW5DBQEMADByXAGwgol +gA+t3u++Wg9gAgLDng4gAMlwVQjQAADBBcLPcIAAVA4A3fAgQAAEwQq6BCKCDw8AAPzJuUV5Vgsg +AalyogngDQXYIBQEMADByXAGwgolgA+t3u++Dg9gAgfDOg7v/8lwg+DKIEIDFQFv/anA4HjxwH4I +b/0C2qfBmnCODiALg8HPcIAAFGMAgADZRcDPcAAAEdL6CiABKHLPcAAAEtIA2e4KIAEocs9wAAAT +0gDZ3gogAShyz3AAABTSANnSCiABKHLPcAAAAUQH2cIKIAEA2s9woAC0D3AQFwByD6AKAdj+COAN +Bdi82IoLIAEA2cPYggsgAQDZiiBECHYLIAEA2YogBApuCyABANklxbXYYgsgAalxiiCEBloLIAGp +cQPYQMAE3kHGz3et3u++QseKcATBA8Ie25hzSiUAAEomAAAiDmACSicAAI4O7/+KcIPg1/LPdYAA +7AcIFRYQDBUSEA7YQMBBxkLHinAEwQPCHtuYc0olAABKJgAA5g1gAkonAABSDu//inCD4LnyCBUV +EAwVEBAO2EDAQcZCx4pwBMEDwuHbmHNKJQAASiYAALINYAJKJwAAHg7v/4pwg+Cf8ggVERAMFRMQ +A9hAwEHGQseKcATBA8Lh25hzSiUAAEomAAB+DWACSicAAOoN7/+KcIPghfLChaOFVg6gCi8gxwUE +wc9ygACcEgIhQKXPc4AAjBI1egCiAiMAJM9ygACkEjV6AKLD2jV7QKPPc4AAlBI1e0CjIfTiC8AD +CiHAD+tyEOjPcKAA/ER0EAQAZBAFAM9wAACxEyUDb/6KI0kKz3AAAK0TiiOJCkokAAARA2/+CiUA +AZzoogvAAwohwA/rchDoz3CgAPxEdBAEAGQQBQDPcAAAsRPlAm/+iiOJDM9wAACuE4ojyQzh8QIl +gCXZYAIhQYQQ8gIlQiQMei4MIAAvcATCAiUBIM9wgAB8ElV4IKACIIAkuWACIcGEEPICIMIkDHoG +DCAAL3AEwgIgASDPcIAAhBJVeCCgANg5Bi/9p8DxwHIO4AAA2M9wAAAN0gDZegggAQDaz3AAAAzS +ANluCCABANrPcAAAFdLPcfMP//xaCCABANrPcAAAG9IA2U4IIAEA2s9wAAAC0qDZmrk+CCABANoJ +2Iy4ANkyCCABANoU2Iy4/9kmCCABANoA2Iy4/9kaCCABANoR2Iy4/9kOCCABANoC2I64ANkCCCAB +ANoB2I64z3EAAP//8g/gAADaz3AAAAvSANniD+AAANrPcAAADdIB2dYP4AAA2s9wAAAS0gDZxg/g +AADaz3AAABPSANm6D+AAANrPcAAAFNIA2aoP4AAA2gDY0cDgfvHAIg0P/aTBi3EB3Q4LIAupcs9w +gADAYQCAQcAE2GYIIAEs2Q7YXgggAQDZIca12FIIIAHJcYoghAZKCCAByXGKIEYAPgggAclxAMCA +4MwgooDMIOKAzCBigcwgooHMICKCzCBigswg4oLKIUIDA/QD2YHgzCCigMwg4oDMIKKBzCDigcwg +IoLMIKKCzCDiggDdBfSBuS95gN2E4MwgYoHMIKKBzCDigcwgIoLMIGKCzCCigswg4oID9IO5L3nG +D+AAD9iDwRIO4AAR2APBg72leUPBrg/gABHYANixBC/9pMDgePHA4cWhwYtxLgogCwHaz3WAAPiX +ABQEMM9wgACsDVYlARIS2joO4AAA2wAUBDDPcIAAqA2pcQHaJg7gAALbz3CAANANJG0d2ioO4AAA +wwDYYQQv/aHA4HjxwMoLL/0D2qPBunDSCSALi3EBwc9wgABcDgDf9CBOAALBz3CAAHAOgOb0IFQA +z3CAAOwH4KDhoMwmopDMJmKRzCaikcolwhMC9ADdgebMJuKQzCbikcwmIpID9AHdhObMJmKSzCai +kswm4pIC9ALdag3P/6pwz3Kt3u++uglgAslxRg7v/6pw7QjQAADAgODMIKKBUPSA5swmYpDMJiKR +SvQCwJEIEQDPcIAAfBK1eFpw4KDPcIAAhBK1eHpw4KDPcIAAnBK1eBpw4KDPcIAApBK1eDpw4KDP +cIAAjBK1eOCgz3CAAJQStXjgoKpwyXHPc63e775CCWACqXJKCu//qnB1CNAAAMEAEgAghuEB2cB5 +A7m1ecdxgABEsgChABMAIAShABAAIBt4CKEAEQAgG3gMoapwqXHJcgokgA+t3u++9ghgAopzRg+v +/6pwKQjQAADAz3GAAOwHQIEEvga42GAVIAAFx3CAAICyIYFCsCOwANilAi/9o8DgePHApMGLcV4I +IAsE2gDAAcEEuDV4z3GAABQOEGGuDeAAAsEAwAHBBLg1eM9xgAA0DhBhmg3gAAPBANikwNHA4H7x +wKHBRgugAotyAMChwNHA4H7gePHA+gkP/a7BunCacXpyWnMKIQAhCiBAIYLFtg7gDalwhMauDuAN +yXCmDuANhsCiDuANiMCaDuANisCMx5IO4A3pcKpwF9mGDKAKi3KKcBfZegygCoHCAMDWCq/9qXEB +wM4Kr/3JcalwqXE6CC/+qXLJcMlxLggv/slyqXDJcR4PL/2GwmpwF9lCDKAKi3JKcBfZOgygCoHC +AMCWCq/9qXEBwI4Kr/3JcalwqXH2D+/9qXLJcMlx7g/v/clyqXDJcdoOL/2IwipwZgqv/YrBiMCK +wdIP7/3pculwC9luDS/+6XKGwHIKb/3pcYDgAdgY9gpwPgqv/YrBiMCKwaYP7/3pculwC9lGDS/+ +6XKGwEoKb/3pcYDgAtjKICoALQEv/a7A4HjxwPIIL/0C2qLBCHbeDuAKi3EAwADdqXEE2khzSiRA +AaYJb/1KJcABCHEqDOAAS9jJcM9yrd7vvgoPIAIBwcoLIADJcIPgyiBCAxUBL/2iwPHAoggv/QjZ +z3Kt3u++5g4gAgh2dgggAMlwawjQAADZz3WAAOAIIKXPcq3e777GDiACyXA6CSAAyXBLCNAAIIVA +IUGAIKXy8yiVyXAWCSAASpXPca3e776aDiACyXCGCCAAyXAfCNAAyXDPcq3e776CDiACENkWCCAA +yXCD4MogIgCNAA/94HjxwOHFocGLcQoO4AoB2s91gAB8mQAUBDDPcIAAQA+pcRfaGgrgAADbABQE +MM9wgAA4D1UlwRUD2gIK4AAC289wgABwD1YlQRML2gYK4AAAwwDYPQAv/aHA8cC+D+/8ANnPcoAA +fJnPdYAAcBkXhUh3DyEBABmFJHhCIACAyiBiAKHBAd4VCFEAz3EBAHS+ENiOCK//gCICADeFANgP +IEAAOIUkeEIgAIDKIGIAANklCFEAENhgwAEcQjACHIIzAxyCM4twBNlWJwIUIgiv/yhzANitB+/8 +ocDPcIAA+JkisOB/Q7DxwBYP7/wB2qHBunAiDeAKi3EAwc9wgABwCc92gADgCPAgQAAgps9xrd7v +vgGmWg0gAqpw8gggAKpw5QjQAM9xrd7vvkINIAKqcKIJIACqcM0I0ACqcA/Zz3Ot3u++Kg0gAgLa +4g3v/6pwAN9KJMAnrQjQAAgWEBAMFhEQ2ncD8Kl36XU78Jp1OfAAJM0jvX2wfapwqXHPc63e777q +DCACCtqmDe//qnB1CNAACBYSEM9wgABELSCADBYTEGB5AdiB4ApwKnFKcmpzyiSBDwAAzRrKJYEP +AADjF8okgg8AAE0ZyiWCDwAAjBY6DM//mwhQgJEIkIBKJkAgAiTAIwsIlACLDhCggeDKJQ4Vz3CA +APgO9CBAA6SmBaYA2EUG7/yhwOB48cASDu/8DNqpwc92QB//AM91PAA8PM9xgADMYbYO7/yLcM9w +gABAD89xgACEDhfa5gjgAADbz3AAAAvSDBwEMM9wAAAC0g4cBDDPcAAAG9IQHAQwz3AAABzSRcUS +HAQwz3WAAOAIIIUA2A8gQABHwAGFRsaFwQTaSMCDwJoI4AAA289wgAA4D89xgAB4DgPahgjgAALb +ANgA2fYPoAAC2gHYANnqD6AAAtoAhRUkATAggQLY2g+gAALaANjBBe/8qcDgePHA4cWhwc9wgADg +CCCAUNgPIE0Az3CAAHAPz3GAAOAOYgjgAAvaBdgAHAQwAhxEM4twQCSBME4I4AAB2rPYcgjgAADZ +iiAEBmYI4AAA2YogxQ9eCOAAANkA2GkF7/yhwPHA4cWhwYtx3grgCgHaAMHPcAAAA9I9eVIPoAAA +2tLYCLgT2UYPoAAA2s91gADoCM9wAAAg0qlxeg2gAATaz3AAACHSJG1uDaAABNoA2BUF7/yhwPHA +ggzP/JpxSHfPcIAAVAhkEBIAz3CAAFQIXBAQAAzZAN0ocHpwz3CAAEAJ8CBRA0pwIg7v/CpxAnAT +eBYO7/yKIQ8KCHbPcIAAVAgagAYO7/wqcc9xgABUCDiBOGATePIN7/yKIQ8Kz3GAAFQIO4GO71Rp +VHpALIMhdHt6YrV6x3KAAHCa1KoVqhDwHQ9REFRpVHpALIMhdHt6YrV6x3KAAHCa1qoXqjkJkQCN +70AsgSE0eYAhAgS1ecdxgABwmtSpFakO8B0PURBALIEhNHmAIQIEtXnHcYAAcJrWqRepQiNAIEEI +dYAB5e0D7/wA2PHAfgvP/KXBunAA2M92gABUCHQWGBBEwADYA6bPcIAARC0ggEAg2TAKIoAvAAAI +0gHdYHmpcDpwAtiEHgAQTCGAoMwh4qAE9IQeQBMDhoQWARAwcOoCBgCA4MoigS8AAAjSgeDKIoEv +AAAJ0gDdTCGAoMwhIqDMIeKgQvQG3UDwEIYIphGGCaYDhofoBtjSDKAAVibBEgOGDwhRAAjYwgyg +AFYmwRIWhsO4DQh0AxamC9gWps9xgABACfAhAAAphkiGDHlkHkAeDHoEhmgeQB6D6AWGCegGhoPo +B4YF6IDizCEhgAb0ANgXphimGaYapqpwqXEeDu//Q4YB5YflMgIGAM93gAC8WrV/AIcB2o7gwiKO +AEKmgOIj2cohAgYacYDiJtnKIUIGygygAHpxz3CAAIgPz3GAAOAPA9pyDaAAAtsDhoHgyiChAMoh +YQTYDKEAyiKhAEwhwKDKIKEAyiFhAsQMoQDKIgEAz3Gt3u++igggAqpwugov/qpwg+Di8s9wgACQ +D89xgADsDxXaIg2gAADbRgsv/gOGz3CAALwPz3GAAEAQOg2gABLaz3Gt3u++SgggAqpwOgigAKpw +g+DA8gCHPoYApkApAAJAKQIEBXrPcAAAC9JFeU4MoAAA2oonvx1Ax0HHCthCwM9wrd7vvkPAqnAj +hgpySnNKJIACSiWAAkomgALyD+ABTiYHAF4LIACqcIPglPIQhj6GBKYRhldpBaZAKcADBXo9ec9w +AAAL0kV58gugAADaQMdBxwrYQsDPcK3e775DwKpwI4ZqckpzSiSAAkolgAJKJoACmg/gAU4mBwAG +CyAAqnDVCNAAMIZRhoTHBYYmpkemE3hUeESGF6YTeFN6NHpYpoohDwo6CmAC6XIYhhAUFDCKIQ8K +E3gmCmAC6XIXhhAUFzCKIQ8KE3gWCmAC6XIEwIohDwpCIJYCGIYTeAIKYALpcgTAPoZCIJMCQCkA +AkApAgQFes9wAAAL0kV5PgugAADaAByANQQcwDQK2ELAz3Ct3u++Q8CqcCOGCnJKc0AkhCJAJ4Ui +CiYAAeIO4AEKJ8AETgogAKpwg+BYBcL/CvADhoQWARAB4DBwIAXl/wOmANh9AO/8pcDgePHAXgjv +/AjZz3Kt3u++pg7gAQh3OgkgAOlweQjQAADepgigAMlwz3WAAFQI26Ug2B6l36XJcAS4RSDAAByl +HaXPca3e775uDuAB6XBuDO//6XBBCNAAG4UB4N8I9IAbpc9xrd7vvk4O4AHpcDoJIADpcCEI0ADp +cM9yrd7vvjYO4AEQ2coIIADpcIPgyiAiADUAz/zxwMYPr/wE2qTBGnC6DaAKi3ECwAPDAN2pcQja +SiRAAoIIL/1KJUAECHEBwB4KoACpcgpwz3Kt3u++5g3gAQDBGgogAApwbQjQAM92gABUCM9wAAAg +0lYmQRI6CKAABNrPcAAAIdJVJsEUKgigAATaMobzhkEpwAXAuBi4E3gleEEvwRXAuRi5M3klfxKm +z3EAAGgf86byCO/8CLgUps9xAABoH+II7/xALwASFaapcHkHr/ykwOB48cDhxaHBi3EGDaAKAdrP +dYAAAJoAFAQwz3CAAJAPqXEV2hYJoAAA2wAUBDDPcIAAiA9VJUEVA9r+CKAAAtvPcIAAvA9WJQET +EtoCCaAAAMMA2DkHr/yhwPHAug6v/ADZz3WAAHAZF4XPdoAAAJoPIQEAGYUkeEIgAIDKIGIAocEB +3xcIUQDPcQEAdL4J2I4PL/9VJkIYN4UA2A8gQAA4hSR4QiAAgMogYgAA2SUIUQAJ2GDAARxCMAIc +wjMDHMIzi3AE2VUmQhgeDy//iiMVAADYqQav/KHA8cA+Dq/8CtqqwQh2KgygCotxBtiKCaAAAcEI +2IIJoAABwRAUBDDJcADBAsIKJYAPrd7vvloM4AEDwzoO7//JcIMI0ADPdYAAVAgUhRgUBDAKpRWF +AMEKJYAPrd7vvgLCDaXJcCoM4AEFwwoO7//JcFMI0AAUhSAUBDALpRWFAMEKJYAPrd7vvgLCDqXJ +cAIM4AEHw94N7//JcCsI0AB0hVQVBhDJcDQVBBA4FQUQbKUkFAcwKoU8HYARvgzv/EuFANjpBa/8 +qsDxwKHBi3FqC6AKAdrS2Ai4AdniD2AAANoA2KHA0cDgfvHAUg2P/KnBQMBBwQDYSMCCxf4JoA2p +cITG9gmgDclwhsfuCaAN6XAAwIty3g8gChfZAcCBwtYPIAoX2QDAMg4v/alxAcAqDi/9yXGpcKlx +kguv/alyyXDJcYoLr/3JcqlwyXF2Cu/86XIGwAfBiMNaCaAKAdoIwEEFr/ypwOB48cDODK/8CNka +cM92gAAACALYB6YK2Ammz3Kt3u++CgvgAQpw3gwgAApwg+B78gDfCg1gAOlwz3CAAEQtIIDgpmB5 +AdgIdYLgzCUikMwl4pAD9AbYAKYAhpsI1QHPcYAAPF/wIQAAAdmO4AKmwiFOAK4OYAAjpuGmAtgR +poLlzCUikMwl4pAE9AHYEaYA2AXwAYYB4AGmMYZRCEUAz3Gt3u++hgrgAQpwmg0gAApwdwjQAM9x +rd7vvm4K4AEKcDYOIAAKcF8I0ADqpv/YC6YKcM9yrd7vvlIK4AEghpYOIAAKcLEI0YAf8ACGAeBx +CPSBAKbPca3e774uCuABCnBiDi//CnAfCNAACnDPcq3e774WCuABENnuCyAACnCD4MogIgARBI/8 +4HjxwKILj/wacM9wgABELSCAz3aAAAAIYHkB2DpwAoYB3Y7gwiVOEwGGUiUNEIDgBtjKICIC2g5g +AEAlARQKcM9yrd7vvroJ4AFAJQEU5gsgAApwg+ASAgEAz3AAAAfSz3EDAPDAxg1gAADaz3AAAAbS +ANm6DWAAANohhgpwBNoKJIAPrd7vvnoJ4AH/2/IIYAAKcIPg6fLPcAAAINJVJsEU0gtgAATaz3AA +ACHSViaBEsILYAAE2hOGog3v/zSGCHfPcAAAB9LPcQQADjleDWAAANrPcAAABtIA2VINYAAA2iGG +CnAE2gokgA+t3u++EgngAf/bighgAApwg+C18s9wAAAg0lUmwRRqC2AABNrPcAAAIdJWJoESWgtg +AATaE4Y6De//NIYCINADjCAErgHfyielECEIEyACho7gAdjCIA4ACOgBhoDgAd/KJaERBPIA3al3 +ZwhSIGMIgy8AAHySz3AAAFDDAgyv/ApxgODKIGwAyPaMIAKIyiCGDwAAnwDPcYAA3FrwIQAAFXja +C6/8iiEPCh1lQ9gjDfQSBaYBhovoAoaO4AHYwiAOAIHgCN3KJ6EQA/II3QHfdQ4DdAAAJPTPcQAA +UMOeC6/8CnCA4MogbADH9owgAojKIIYPAACfAM9xgADcWvAhAAAVeHoLr/yKIQ8KIYaa6SKGjuEB +2cIhTgApCVEADQjUAE4gjQMA3w7wTiDNAgDfz3AAAAvSz3EgACAgBgxgAOlyAYYEv/1lkOgG2NoM +YACpcQLYCtnqC2AACHIfCdEgAtgJ2QjwCNi+DGAAqXEC2BHZzgtgAALapKYA2J0Bj/zgePHANgmP +/KHBOnAC3oogASnPdYAAAAgQ2BDw7IUA2EDACnH4ZxV4cgogAotyWgygB4twAMAB5hp3QCYPFFcO +NRMhhVMI1AOA4QbYyiAiAlYMYADpceSlKnDPcq3e7742D6AB6XFiCSAAKnBDCNAAKoVLhSpwAdsK +JYAPrd7vvhYPoAGKJMMPLgggACpwjwjRgA3wQCaPE4DhBtjKICICBgxgAEAmgRPkpQDY7QCv/KHA +8cCGCK/8BNqkwRpwfg5gCotxAMHPdoAAAAhhhs9wgAAsXwQUETAA3fAgwgDPcIAANF/wIM8Az3AA +AAbSWHnSCmAAqXLPcAAAB9IAKcEjwgpgAKlyCnDPcq3e776GDqABJIa2CCAACnBPCNAAIYYCwgpw +CiSAD63e775qDqABA8PiDSAACnAzCNAAz3AAACDSVSbBFMIIYAAE2s9wAAAh0lYmgRKyCGAABNoT +hpIK7/80hgymqXAxAK/8pMDxwOHFocGLccYNYAoB2s91gACAmAAUBDDPcIAA/BCpcRPa1glgAADb +ABQEMM9wgAD0EFUlwRQD2r4JYAAC289wgAAkEVYlwRIS2sIJYAAAwwDY+Qdv/KHA8cBuD2/8AdoI +ds9wgADIYQCAosFAwIHBXg1gCslwAcLPcYAAAAiLc8lwxbpBwroIIAYggSDAPgogCgfZGnABFIAw +MgogCgfZCHYKcADZCNrJc0okQAL+D6/8SiVABFpwAhSAMA4KIAoH2Qh1AxSAMAIKIAoH2Qh3qXAA +2Qja6XNKJEACzg+v/EolQAQ6cM9wAAAI0kpxZglgAADaQdgJuApxWglgAAHaz3AAAAGCyXFKCWAA +AdrPcAAACdIqcT4JYAAA2s9wAAACgqlxLglgAAHaz3AAAAOC6XEiCWAAAdoA2OkGb/yiwPHA4cUA +2AhxCglgAALaAdgA2QIJYAAC2gLYCtn2CGAAAtrPcIAARC0ggGB5AdgIdYPgyiChAMohYQLYCGEA +yiKhAM9ygAAACGOCz3GAAIQQgOXMJeKQDvTPcIAACAnwIMAAAqHPcIAAEAnwIMAADfDPcIAAWF/w +IMAAAqHPcIAAYF/wIMAAA6HPcGgf/wAEoc9wIAAwMAqhBaLPcIAAZBAQ2voIYAAA22EGb/wA2OB4 +8cDiDW/8C9rPcIAAxBDPcYAA3BAGCWAAocHPdYAAAAhBhQXYSNkiCWAADyGBAAOFz3aAAAxfi3cV +JgAQAJBeDyAA6XEDhQDBFSYAEACQ+ghgAMa5A4XPdoAAHF8VJgAQAJA6DyAA6XEDhQDBFSYAEACQ +1ghgAMa5ANjRBW/8ocDxwF4NT/yhwRpwi3EB3lILYArJcs91gAAACACFArgUeAAgjw+AAPyYAMDI +pQClz3CAAEQtIIBgeclwCHZrCNEAz3AAAAvSQNmaDyAAANoG2HYIYAAIcQrYbghgAALZM9gA2YIP +IAAC2jTYANl2DyAAAto32ADZbg8gAALaONgA2WIPIAAC2jvYANlaDyAAAto82ADZTg8gAALaAtgJ +2UYPIAAC2gzwz3Gt3u++CgugAQpwCgnv/wpw2QjQAAKFz3Gt3u++juAB2MIgDgCB4ApwHPTmCoAB +kgkgAApwtQjQAADYBPAIhQHgJ4WbCGUACKXPca3e777CCqABCnCeCCAACnDlCNGARvBBDtEQqgqA +AYoIIAAKcH0I0ADPca3e776WCqABCnBCCSAACnBlCNAAz3Gt3u++ggqgAQpwKgkgAApwQwjRACbw +bgqAARoJIAAKcEEI0ADPca3e775aCqABCnDGCu//CnApCNAAz3Gt3u++RgqgAQpwIgggAApwFQjQ +ACGFCoU1fwC3C4UBtwDYMQRv/KHA4HjxwMoLb/wB2wh3z3WAAAAISoUphQolgA+t3u++AN5ZYUuF +/gmgAZh2Fgvv/+lwmwjQAAyFKoUC20mFDaXpcAolgA+t3u++WWFLhdYJoAGYdu4K7//pcHMI0AAM +hSqFAdtJhQ6l6XAKJYAPrd7vvkJ5S4WuCaABmHbGCu//6XBLCNAADIUqhQLbSYUPpelwCiWAD63e +775CeUuFhgmgAZh2ngrv/+lwIwjQADAVBRA8FQQQCoUphUAdQBFNhboM4AVuhQqlyXBtA0/84Hjx +wAILb/yKJMMPCHbPdYAAAAhrhUmFCiWAD63e774qhXpiMgmgAQPbSgrv/8lwoQjQAAyFS4UKJYAP +rd7vvmmFKoUNpclwemIE2woJoAGKJMMPIgrv/8lwdQjQAAyFS4UKJYAPrd7vvmmFKoUOpclwYnoD +294IoAGKJMMP9gnv/8lwTQjQAAyFS4UKJYAPrd7vvmmFKoUPpclwYnoE27YIoAGKJMMPzgnv/8lw +IQjQADAVBRA8FQQQC4UphUAdQBFNheoL4AVuhQulANihAk/88cCjwYtxJghgCgPaAMHPcAAAG9KP +6QHZlgwgAADaz3AAABzSAdmKDCAAANoC2ArZDvAC2XoMIAAA2s9wAAAc0gDZbgwgAADaAtgR2WIM +IAAC2gLBz3AAAAXSVgwgAADaAcHS2Ai4O3kB4UYMIAAA2gDYo8DRwOB+8cC2CW/8Bdihwc91gABU +CEOFSNkGDSAADyGBAAKFz3aAABRfi3cVJgAQAJBCCyAA6XEChQDBFSYAEACQ3gwgAMa5AoXPdoAA +JF8VJgAQAJAeCyAA6XEChQDBFSYAEACQugwgAMa5ANi1AW/8ocDgeKHB4cXhxrhwz3CAAFS7EBAG +AM9wgADELgWAmHGhwYYk9w/nCBAAz3CAAGhdAIAfCIEBz3CAAHBdAIATCEEBz3CAAGxdAIDDCAAB +ABxAMSDCARSBMPDeUyLAAMR6UyHHACR+VHpALo0BtH26YhV6z3GAAES0SGHUfghzhiP9D3t7OmJB +imV4SHOGI/0Pe3vdZRUlzRG+YcKOZXrJc4Yj/Q97e7lhI4llfihzhiP9D3t7ZXknDBAAz3WqAOAH +c4URCx4ASKUJpSqly6UQ8AilSaXKpSulCvAJukV4z3KnABRIA6IJuSV+xKLPcYAAaF0AGYABz3CA +AHBdABhAAc9wgABsXQAYAAGhwMHGwcXgf6HA8cDPcQCCAQDPcKAArC88oM9wgACcOQCAi+jPcIAA +cBsAgA8IkAA+DcAC0cDgfjIKQABOD6AEb9iH6M4I4AwK2B4KQADz8fPxz3KAAJw5IIIGeeB/IKLg +eM9ygACcOSCCJXjgfwCi4HgEKIAPAAAvukIpwnRQekQq/gICIEAOEHgD6AHiUHoLCDMBQLGD6ADY +AvCA2OB+4HglA4/98cCSDw/8OnDPdYAAHCAAhQHgAKUVCFEAAdnPcKAAyBwxoEoI4AwocMIMYAQH +2Bpwz3agAOwn64amDCAGKnALpgCFQiBAgAClBvTPcaAAyBwA2BGhwgtgBApwmQcv/Olw8cAuDw/8 +OnAodRpyfgxgBAfYWnAPCJ4gngrgBsjYUCCQIEwggKAZ8gj2IwgQIEUIUSAV2BO4DfAlCBAkNQgR +KJYIoAMqcAClD/Ap2BK48CBABAClCfAr2BK4+/HPcKAA7CcZgAClUgtgBEpwHQcP/AohwA/rcs9w +AACKE3vbCiRABCkDb/0KJQAE4HjxwKYOD/wIdzpxGnMfCnQAAN5IdfQngBMVIYEjWg/v/wpyYb3x +DXWQAebdBg/84HjxwHoOD/yhwQh3GnEjCnQAAN5IdfQngBMeCCAAi3EAwBQgjCNhvQC07Q11kAHm +sQYv/KHA8cBGDg/8ocEacM92gAAcIACGAeAodQCmFQhRAAHZz3CgAMgcMaD2DqAMKHBuC2AEB9gI +d4oM4AKz2Bboi3HSDC/9CnAAFAAxAKUAhkIgQIAApgf0ANnPcKAAyBwxoGoKYATpcEUGL/yhwOB4 +8cANDN4ALg/P/wTw2ggAANHA4H7xwA0L3gBKD8//BPD2CAAA0cDgfvHAtg0P/Ah1juAB3sImjRPP +cKAAtA/8gN4MoAkA2MlwqXEB2v4KYARIc84MoAnveO0FD/zxwHYND/w6cCh1GnLGCmAEB9hMIICg +WnAb8gz2JwgQIE0IUSAV2BO4FSBABKCgG/ArCBAkOQgRKCpwUg9gA6lxEfAp2BK4FSBABKCgC/Ar +2BK4FSBABKCgBfDPcKAA7Ce5oJ4JYARKcGkFD/wKIcAP63LPcAAAiRNK2wokQAR1AW/9CiUABOB4 +8cDyDA/8CHc6cRpzHwp0AADeSHX0J4AT8CGBI14P7/8KcmG98Q11kAHmKQUP/OB48cDGDA/8CHca +cR8KdAAA3kh19CeAExoIIAD0IIEjYb3zDXWQAeYFBQ/84HjxwJYMD/wacM92gAAcIACGAeAodQCm +FwhRAAHZz3CgAMgcMaBKDaAMKHDGCWAEB9g6cOIK4AKT2BjosH1AKI8hgb8QvaV/z3CgAOwn5qAA +hkIgQIAA2QCmBfTPcKAAyBwxoLoIYAQqcI0ED/zPcYAAgCEjgc9ygADgBzIhgw8AAB8DAaIyIYEP +AAAZA2GySHAgsgjZc9oe24kHYAkYu+B48cDPcIAAgCEDgAmAUSBAgcogYgAMDWL+yiEiAM9xgADY +BoogjAzuDCADIJGCC6/9AdjRwOB+4HjxwMILD/zPdYAAVLsihc92rACQAQkJUQMYjYfoeQnRAhiN +dQgRAOuGMBYQEM9wgABELSCAYHkC2CKFnuinvxEJUQNGIMAjRSAAAxPwz3CAADwtIIBgeQDYDwhR +BEYgwCNFIIADBfBGIMAjRSCAAuumDKYW8I3h0CfhEeXzz3CAADwtIIBgeQDYkeDQJ+ER6POHv9nx +BdgMpqDYC6aJAw/88cAqCy/8iiIEDs9wgACsBgCAz3aAAFyoJoBAJgAUUgggCgThAYbPdYAAgCEi +hsgdGBDPcoAArCTJHVgQIZYnqiCOBCCADwAGAACA4AHYwHghqgaqAN5qDmAIyXDPcIAAISBSC2/+ +wKh2CcACCOh6CcAChuhiCq/9yXAq8M9wgAAkICSAIIG2CyADiiBMDIogkwGqCyADqdkC2DYJYAEB +2WIIoAwC2COFSIE0kVMiAAB2COAIAduKIIwOggsgA7PZANmeuc9wgACAKCCgyQIP/PHA4cULCDIM +CHUdDZIeCiHAD+tyz3AAAJohItuYdakGL/24c0IlABylAi/8D3jgePHAJgov/JhwQYGwiXcKHgFy +ic92gACQ1vJt9n/mZjTKCBGFAEkgwAARDp4Vz3aAANDYtn7BjgPwAN7HcIAA0Ni2eASICCMDAAgj +gwMAI0ABSSDDAxZtdXjPc4AAUNoDY89wgADQ2bZ4z3WAAIAhpIW4hQGApXgEIIAPAAAACAZ7AvBj +gei7mBnAAADdCfKkEQAAAN2XvZG4lLikGQAAOwweAM9wgACAIcSAwLrIhgQmjh8AQAAAPr4e5th6 +RXuYGcAAHQueB6QRAACFJQEUjLiRuKQZAACcGUADHvAnC94HpBECAIUlARSWvZi9jbqRuqQZgACc +GUADJIAQgZ64EKEK8JS9lr2cGUADJIAQgZ64n7gQoXkBD/zxwAoJL/wD2M92gAA8LSCGQHmA4G3y +IIZgeQTY0wgQACCGYHkA2Ge4FQgVAzMmAHCAADBgQCcBchR5AHkA2ELwz3CAAEQtIIBgeQHYgOAB +2MB4OPDPdYAARC0ghWB5AdgjCFAAIIVgeQHYGwjQACCFYHkB2A8IkAAghWB5AdjBCFGAAdge8M9w +gABELSCAYHkB2IXgAdjAeBTwz3CAAEQtIIBgeQHYgeAB2MB4CvDPcIAARC0ggGB5AdiD4AHYwHgv +CFAAIIbrdWB5ANgacM9wgABELSCAYHkB2LhwN9gKIcAPqXKU25kEL/0KJAAEgQAP/OB48cAaCA/8 +z3WAAJiuIBWAEM92gADgBhcIUQAA3z4PYAnpcALYA6bkpgPwAdgFpoogzAj+CCADKIVJAA/8z3CA +AJiuKIDPcoAA4AYveAsIUQAC2ASiA/AB2AWi1QAgA4ogzAjgeM9wgACwqSiAz3KAAOAGL3gLCFEA +BNgEogPwAdgFoq0AIAOKIMwI4HgNyMdwgACoyTSIAeEveTSoHQkyAQMSAjbPcAMAhACgGgAAiiAI +AAYaGDAL8IogEAAGGhgwz3ACAYQAoBoAAIogBABhACADANnPcqAALCBwggnoAiNCABMOhHAAgAAA +DwiEAADYBPD/CMWAAdjgfuB48cAeD+/7mHClwSh3uHMA3gQjgA//AAAAGLoFem95CLn/2Ai4ZHgo +uAV5RXkI3fQkgAMneETAQgrgChAUADESFAIxYb1AKAEEBXlHeUTBEBQCMRQkgDNAsNcNdZAB5lMl +wgVApwAUDQEH2QfwEH0UJ0wQALRhuRQkQDC7e0+9AJCle3B76Qm1gHhgBCCADwAAAP8QuAV6QKft +Bu/7pcDgePHANggAANoIAADaCAAA0cDgfuB4z3GAAPwnQCEAA1UhwgURCIUAANkEGFAA+wiEgOB+ +4HjxwJoI4AUA2IIIL/0A2M9wgADYWVYJD/3PcIAAuFlOCQ/90gkP/goNgAcA2CYLoAKA2WYJgApm +CkAClgvACo4IgAEeCIACANgmDy/+CHFKCoAJjgiAAnYKYAH/2AYPAAGKIIUPCHHGDeAECHLRwOB+ +8cDeDe/7iiD/D891oAA4LseFB6XPcKAAVC4LgNO4BiYAcA8A//+2C+ALFtneDYABx6UZBs/74Hjg +fuB48cDhxQDdz3CAAHgHoKDPcIAAPKCssG4K4AqpcGYPz/xCCGAKqXAODkAD2glP/YoOAAGKIAYK +CHFGDeAECHK+Cm/8qXCKCk/8zQXP+wDZz3CgAOwnK6DgfvHAz3CAANyVXgzgCwPZigvAANHA4H7g +ePHA4cWkwYtwRgzgCwTZz3WAABwgAIUB4AClFwhRAAHZz3CgAMgcMaDWDWAMKHAAhUIgQIAApQf0 +ANnPcKAAyBwxoD4LwABhBe/7pMDxwKHBi3D+C+ALAdkmC8AAocDRwOB+4HjxwKHBi3CqC+ALBNkA +wFEgQIBgDOIFyiCiAADAUSCAgOAKAgoAwFEgwICkDAIGAMBRIACBtAkCBsYP4AoB2M9xgK7gAexw +IKAByOxxAKHPcoAAIJaKJIF9ANmoIAAC8CJDAOxwYKAB4fYK4AAA2KHA0cDgfvHA4cWjwQHYQMDP +dYAAcBmpcCoL4Atc2dYND/46hRuFJHg8hQR5gcCCCm/+QcEBwDuFBHlBwTYN4AKKIFgEVSVAH/4K +b/6pcc9wgADoGvIKb/5AJQEbi3BGCeAABNlCC2/+AcAAhYboBYWA4IwMQf4qDQ/+WQTv+6PA4Hjx +wOHFz3CAAIhhAICiwUHAgcAB3eYK4AupcYogFwrSDOACARIBNiHCiiAXCgUUgTAQur4M4AJFeUDF +i3DmCOAABNkRBO/7osDxwKHBi3CuCuALAdkAwC8kBwAAHAAxGwjeAQcSBTYKIcAP63KKIMUA2Qfv +/CfbiiAXCnYM4AIBEgE2Og5gAUDYognAACoIgAahwNHA4H7gePHARgvP+891gADcHwKFI4UB3hBx +wH6pcEoK4AsD2XYJwAAE7gKFA/AAhYkD7/sDpeB+4HjxwOHFz3WAAPQfqXDmCeALENkAFQQQIQxQ +AEEM0AApDBABCiHAD+tyj9iNuJjbUQfv/LhzAYUMuAQggA8BAADwAaUM8CGFz3CAAGA5IKAjhc9w +gABmGCCoA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoCIJ4AAB2AEDz/vg +ePHA4cUA2c9ygAAEICCiIaIios9w0P4AAASiABYNQKCiABYDQGGiABYAQAAWAEAlDd4X/7tA2M8g +4gfKIIEPAADQAM8g4QfPcZ8AuP8doQbwz3CfALj/PaADzNdwAAAAQAHYwiAKABe4x3AADgAAg7id +uJ+47HEAoQESATbscCCglgjgAAHYpghAAnECz/vgePHAABYCQKHBQMIBFIAwDwgeAM9xgADEnwTw +z3GAAMSvQKFgiQHaCPAAFgBAFSGMAACkAeJ9ePUIhYAXCx4AABYAQQPwANgVIYwAAKQB4vkKVIED +zNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HIAogESAjbscECgPgjgAAKJocDRwOB+4HjxwOHF +z3WAAPgIqXBCCOALCNkAhc9xoAC4HgKhAYUDoZoPgAC9Ac/7kQeAAPHApMGLcB4I4AsQ2QPM13AA +AABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChARIBNuxwIKAAwFEgAIADwAb0AsGGDeAAANoF8AYM +IAIBwYYPgACkwNHA4H4JAAAABQAAAPHALg+AAJUFwAngePHA4cW0wYt1qXDqD6ALFNkAwIbgzCDi +gQb03gygAqlwCHEk8A8IkQCyDaACqXAIcRzwEQhRADIPoAKpcAhxFvCD4MwgIoIH9NILoAKpcAhx +DPARCBEBTg2gAqlwCHEG8D0IUQKKIYQAA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxyAKIB +EgI27HBAoNYOoAAocLUA7/u0wAohwA/rcnzYjbh324u7SiQAAJUE7/wKJQAB4HjxwOHFosGLdalw +Mg+gCwLZOg+gAqlwVg6AAHkA7/uiwPHA9g+P+wAWEEChwUwggKDKIcYPyiLGB8oghg8AAI8MyiOG +DwAAjAXKJAYEPATm/MolJgAAHAA0i3WpcAYNoAAE2YogzArKCOACCnGEKAgpL3cAJ44fgADQq6oM +YAoEbs9wgAC0rRqAIQgABCQWgBAi6KlwBNmZ2h7bBgsgCRi7ANgkHgIQGPDHd4AAxKsLh4G4C6fP +cIAA4AYvgAHaBelEoATYBvAA2SygSaAkoAXY+g7AAqUHr/uhwOB48cDhxc9wgAAkICSAIIFGCOAC +iiDMDc9wgACAKACABCC+jwDAAAAJ9M9wgACsqQCIjCDDjwTy5gov/QHYz3WAAFyoqXAaDqALUtnS +DoAGo4WKIEwO/g+gAqlxNg2AAIogjA7yD6ACatm6DOAAqXAIcc9wgAAIV0IMQAr+2c9wgACsqTUH +r/sgqPHAz3CAAEyuzg2gCw3Z+gyAAMoKgAXRwOB+4HjxwIYOr/uKIMwOosGiD6ACiiEFBotwpg2g +CwLZAxSRMCEJkiAEFIUwCiHAD+tyz3AAAIQMiiOFCdEC7/wKJEAEAhSAMM92gADgBoQpCCkvdyAe +AhDPcIAA6Kv5YCyJQCASAwAUFDEAINMDHOmKIEwNPg+gAoohBQyKIEwNMg+gAipx+ghgAUIkgCEB +2BG2/9ghHgIQQCYAGEoLoAAE2WnwANgRtiEeQhTPdYAA1KlAJRAS/WWLcKlx3gugCQLaQCUAEr4M +oAtCJIEhACeAH4AA1KkIEAUAz3CAAPjeBYBTJUEFEHHKIcYPyiLGB8oghg8AAIUMyiOGDwAAhAEM +Aub8yiRGBEoOoAYqcEokgHAA2aggwAOEKQgJL3AyIgIgCOoIFQUQMCAEIE0MQAEB4UAmABiyCqAA +BNkB2QwbQiCHFQAWgLiHHRgQwgvgAihwiiBMDV4OoAKKIcYIiiBMDVIOoAIihYogTA1GDqACKnFt +Ba/7osAKIcAP63LPcAAAhgyJAe/8iiPGBQAWAEBdA4AA8cDhxc91gACoy6lwHgygCwPZAYXPcaAA +gCUMoQKFDaEAjVEgAIAA2I64BPIPoQPwEKEqC4AATQWP++B44H7geOB+4HjgfuB44H7geOB+4Hjx +wLYMr/sE2aPBAN9Cx3oMoAuLcD7Yug2gAgESATY+2K4NoAIEFAExPtimDaACBhQBMQPM13AAAABA +AdjCIAoAF7gAIIEPAA4AAAYUADEbeBPgBCCADwAA/P8leJ24n7jscQChARIBNuxwIKAAwexwIKAE +FAEx7HAgsAYUATHscCCwBhQEMR0MHgABEgU2CiHAD+tyz3AAAE8mkQDv/GnbAd3PcQAAIiImDaAC +PtimDyADqXACwSV4QsAAwFEgAIDKJaIQyiGCDwAAMzMADaICyiCiD89woAAsIEAQEAAD8AHnBhQA +MYEPAxAEFAAxgsYtDZEQG3gQeMlxaghgA6ly7HEAqQQUADHJcRt4AeAQeFIIYAOpcuxxAKkI8Mlx +RghgA6ly7HEAsQQUADFAIEUAz3CgACwgEIAvJUgBAiAABNdwAQCghpwH5f8EHEQxCBQEMAohwA/r +cs9wAABQJs0Hr/yM294OAAPPcKAALCAwgD7YXgygAgIhAQQ/2FIMoAICwc4JoAACwJEDr/ujwOB4 +8cAAFoVApsENDTMGABxCMRsNEwIKIcAP63LPcAAAZhmV23kHr/xKJEAAABaAQAEcAjAAFoBAAhwC +MAAWgEADHAIwi3CuCaAFgcECwo7qABSFMAohwA/rcs9wAABnGZ/bOQev/Iokww8EwGB6BcEDwYvp +CiHAD+tyABSFMM9wAABoGaPb7vEBwIDg4yBCAMogIgDqCIAApsDRwOB+8cDPcIAAADWmCaALCdla +DoAEigqABPIKgATGCIAA0cDgfuB48cDPcIAABDeCCaALB9muCIAA0cDgfuB48cClwYtwbgmgCwXZ +AMAtCB4Az3CAAIAhA4AYiB0IUQAA2Jq4z3GgAMgfD6EBwKQZAADD2Bq4DqFqCIAApcDRwOB+4Hjh +BGAFANjgePHAz3CAAGg54gigCyjZSgiAANHA4H7gePHA4cUAFgBAz3WAAHAbAKU9CJEAANnPcJ8A +uP89oBzZFfDPcKAAyDs2gEQhAgc2gIYh/wglejaAhiH/CEV5z3KgAKggTYLk4o/37enyD0AAIIVd +CVUBMyZBcIAAXGBAJ4ByNHgAeDgQBABYEAUACiHAD+tyz3AAAJkh5QWv/C/brgvgAlTYKQheAM9x +gACcOQCBgbiODuALAKEK8NYJ7/0B2PoMwAIE8HoPwAO5AY/78cCqDMAHig9AANHA4H7gePHArgpg +CADYz3CAAIAhyBABBsC5geEB2cB5ggrgCzwQgADRwOB+4HjxwOHFz3WAAIAhAIXEEAAGHQheAQoh +wA/rcoXYjbiKI5wPSiRAAFEFr/y4cyYNAAm6DWAKAdjPcIAAyCQIiD0I0QEBhcQQAAYxCF4BNgzP +/M9xgAD43gSQJYEKuB0IQAAKIcAP63KG2I24iiNdAkokAAAFBa/8uHNyCo/8TgvgCQDY4gjAAtIO +QAD1AI/74HjxwE4LYAgA2DYMj/zPcYAAcLsCic4J4AsgidHA4H7gePHAosGLcDYPYAsI2QDAz3GA +AOQ5AKEI6AYUADEDsQQUADECsYIOQACiwNHA4H7gePHAocGB2GDAA8wCHAQwAMDGDO/7AtmhwNHA +4H7xwKHBgNhgwAPMAhwEMM9woADUAxyQ1goAAQDAngzv+wLZIg7gCALYocDRwOB+4HjxwAohwA/r +cs9wAAAwJYojjAeKJIMPNQSv/EolAADgePHA4cUg289xoADIHGmhABYAQM9yoAAQFAyiABYFQAHd +TCUAgMohwQ/KIsEHyiCBDwAALCXKI4EPAAAJAewDofzKJEEDGBpAAWgZQAED2A+iuaFqobYNQADZ +B0/78cDhxa3Bi3WpcHYOYAsN2QDAHXhTIAEARCk+DalwACGBf4AACNU2DWAJDdqCDUAApQdv+63A +4HiRAiAMANjgePHAHg9v+4ogkg2swSYIoALF2YtwKg5gCwzZABQAMbDoz3WAADwtIIXPdoAACDBg +eQDYQCSPMCUIEAMghWB5ANgZCBAEIIVgeQDYEQhQBCCFYHkA2A0IkQTpcMlxGNoF8OlwyXEu2gIM +QAkB2GAeAhAXhoDgBAzh+8ogIQAAFAAxMQhRAIog0g2qD2AC3tlAJIAwz3WAAAgwQCWBG8oLYAku +2gHYN4VhHQIQgeHMC8H7vgxAANEGb/uswOB48cBWDm/7F9m3wXoNYAuLcCPASiJAIFMg0ACGIP4D +QigRASUIMiQMHAI0CiHAD+tyctiNuIojDwMKJIAElQKv/AolAARIFAUwIMBAKI4gz3WAAJDW1n5R +IACAwGVBLU8DwL++ZoYg9w9c9I3oCiHAD+tyc9iNuIojzwRZAq/8CiQABIogTwUKcboNYASocgHA +AsEKcnYLr/tmbn8IEADpcK4K4AsKcQ0UgDCFIMEADRwCMIog/w9TwACGqbgAphLAhiD7Dyi4D65K +JAB0ANioIAAD/9q7YEAogSA2eRLjO2NAqwHgCnDKCeALi3HPcIAAgCHwIMEDwBEABg8gAATAGRgA +D44PCFEAgOfMIKKjRAoCDAHfAvAC32oL4AEKcAfwgODKJ4EUyiciEoHnuPQghs9wgACAIQOAGIgo +dYYl+x8hCFAA4gsAAiCGGejPcIAAyCQIiCcI0QFBKUADHwgeABPAEsIXCB4ChiL7D0EqBAJPjgsK +AAGouFPAE8ASwgZ5RHgleACmhiD7DwvtgODKIAEEyiEhAFAIIQPKIuEDDh5CFADYz3GAANDZFiEB +BECGAKEBoQsKXwUA2Iu4AaEPCp4FAYFFIAAGAaHqDa/8i3ANFIAwPwheAVgUADEFtloUADEGtgWW +F+hGCwACDugGlhMIXgAuCK/8CnBiCQAMBdgSrgDYBbYH8ApwANnaD+ACD9oNFIAwNQheAFAUADEC +thToAN0Q2DpwApYRIECDyiACBMohQgOwD+ICyiJCA0IhQCDnCHWAAeUNFIAwDwgeAQpwggzgAFUU +gTANFIAwOwjeADXBVhQCMQpwIgvv/BLDjCACgLhwDfQKIcAP63J02I24iiOSD00Ar/xKJEAAUSXA +gconIhFKCuALCnADzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQESATbscCCgMgpgAOlw +6QNv+7fA8cB6C2/7iiBTCaTBAN2pcWILYASpcs92gABQ3gCOSiRAIKGuAh4CFQHgAK6jrqGmoqak +pqWmuK65rgHAuq4CwQemA8AopgmmAdheDGACqXGBwGIKYAsB2QHAB6ZadbXwgsBSCmALAtkBjgLB +Ad/jrgHgAa4DwCimCabpcCoMYALpcQLAi3L+Dq/7A8EEIAAFLyQHIALZAq4AwCOuAaYKDGAC6XBM +JACgjfIAwc9ygACQ1kojACASaRZ4AGIPI1MgLbhTIBAAiiBUBaoKYAQKcs9wgAB4BwAQEQAvJcok +z3GAAHgH+K4EJUAkAKED2SOuEB7AFBQeABQIHkAUA6aqC2AC6XDPcIAAeAcAgIzoGQkQIKoN4AMg +2ATZI675rooLYALpcAXZI65+C2ACAdggwNIK4AAQ2QDAArgWeAAggQ+AAJDWorGKIAgAAKEG2SOu +VgtgAgHYAMAA2b4N4AIP2gDAgNkCuBZ4x3CAAJDWKKgpqAfZI64yC2ACAdjPcIAAgCHwIAIEz3OA +ANDZwBIBBgQhQAXAGhgAAMIA2c9wgADw1VZ7IKMho1R45g7gC6CwCejWDsALCNkjrvqu6gpgAgHY +QCJSICHAUnCYBs3/CdkjrtYKYAIB2APM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChARIB +NuxwIKBWCGAAinAK2SOungpgAgHYuQFv+6TA4HjxwIogVQsA2VIJYAQocmoLQAm6DwAA0cDgfuB4 +8cDhxQAWDUADzAHa13AAAABAAcjCIooAF7rHcgAOAAA+DGAJUyUBEFElQJDPcYAA7DoB2MogIQCd +AW/7AKHgePHAocGLcDoIYAsB2QAUBTAZDREACiHAD+tyidiNuEXbbQVv/EokQADPcYAAfMkDGUIB +QC2AAwKhSiTAcADaqCCAAgDYDyCAAAsgQIED9AHiA/AOuAGhGg8AAKHA0cDgfuB+4HjxwKIIT/sA +FhJBABYAQc9xgACQ1kAqgCAWeDAhBQCiwUEtQAMjCjQkUyATAAohwA/rcnXYjbiKIxgCSiRAAO0E +b/xKJQAAHQ1eAgohwA/rcnbYjbiKI1gC0QRv/AokgATPcIAA0NgWIIAEGnBuDyALAtnPcIAAcNUW +IIAEXg8gCwLZQCqVIQAlgC+AAFDaTg8gCxDZi3BGDyALAdkAJYAvgABQ2roOoAUQ2QEQgCAhCBIE +CiHAD+tyd9iNuIojmApKJEAAZQRv/AolgAQA3RDYOnAVJUAjz3GAAFDaMCEUAAQkgq8AAAABBBwA +NUjyRCQOJiO+AeYEJIAvBgAAADG4IcHfYKDh0SThojXyA+oXDpUQBCSELwAAACRbDIAPAAAAJFMI +1QANCJEAJepHDpEQBOrM4T4ACQDPcIAARC0ggGB5BtgvCIQDz3CAAIAh8CDABMMQAAYB2QQgvo8A +BgAABCSALwAAAAjCIUEAK7gLCQUAANgC8AHYD3gE8AHf6XAEJIEvAQAAwC65z3KAADRwKWIwdwHZ +wiFNAIDgzCEigBbyQiFAIC0IdYAB5QIQgCDPcYAAHGUIYTkIUAAKIcAP63J52I24iiMZADnxCiHA +D89wgACAIfAgwATrcoojWA/DEAQGeNiNuEEDb/wKJQAFAxCAIAhhFwiQAAohwA/rcnrYjbiKI5kC +GfEuDaALSnDPcIAAcNUWIIAEIJDPcgAAGBUJIYEA5gwgACCwxQYv+6LA4HjxwAAWgUDPcIAAoFog +qAAWhEAAFoFAz3CAAKlaIKgAFoBAUCS+gcohwg/KIsIHyiCCDwAA2hTKI4IPAACBB7gCYvzKJSIA +z3CAANgGAJAG6EYOQAtODUALfgwAANHA4H7lACALANjgePHAIg4v+wDZSiQAcqggQAIAFgJAFSJA +MA4YmAAB4QAWDUAAFg5A3g0AC89woAAUBKygz3CgANQL3KA2DAAAUQYP++B48cDWDS/7CNmiwQES +DjbPdaAAOC4cFRAQpgwgC4twABQEMADfBCS+j/D/AADKIcIPyiLCB8oggg8AAKYoyiOCDwAA4QYE +AmL8yiXCAFEkQILKIcIPyiLCB8oggg8AAKcoyiOCDwAA5AbgAWL8yiXCAOeldgrgCz/YAMAEFAEx +B6VaCyALgrkcHQAUogsgAAEamDOpBS/7osDxwADY/gogAAQSgTAEEoUwCiHAD+tyONiKIw8BlQFv +/EokAADgfuB48cDhxaHBH92LcDIMIAsE2WG9+Q1VkFYLAAB5BS/7ocDxwKnBi3DCDCALEtk+CwAA +qcDRwOB+4HgAFgBAABYAQAAWgEAAFoBAABYAQQAWgEAAFoBAABaAQAAWgEAAFgBBABYAQQAWAEAB +AwAA8cDhxaHBC92LcMYLIAsE2WG9+Q1VkOoKAAANBS/7ocDxwK3Bi3CqCyALDdnSCgAArcDRwOB+ +4Hg1B+AKAdjgeOB+4HjxwKHBANlAwQAWAkAAFgBANQpQAAPM13AAAABAAdjCIAoAF7jHcAAOAABF +IAADnbifuOxyAKIBEgI27HBAoOxwIKAf8MIJYAWLcAPMAdnXcAAAAEAB2MIgCgAXuMdwAA4AAIS4 +nbifuOxyAKIBEgI27HBAoOxwIKAAwuxwQKCCCiAAKHChwNHA4H7gePHA3gsv+wLZz3eAALhangsg +C+lwQIfPdqAA7CfPdYAARC2XCh4AK4ZEIoAAhiL/DiK6obkUurS5BSCDAGV5K6YEIIAPEAACAAQi +gg8QAAIAz3GAAAAGRXgLoSCFBN5geclwGwjQASCFYHnJcA8IkAEghWB5AdglCFEAAIfPcaAAyBwR +CF4AAdgeoZIIgAUG8ADYHqH+DwAFIIVgeQHYaQhRAQCHYQjeAM9woABEHcWgw6DEoCjwz3CgAMgc +Adk+oAuGgbgLplYIgAUghWB5AdglCFEBz3CAAIAhA4AIgBkIHgAA2ZS5z3CAAAAGK6ALhpS4CfDP +cIAAAAYA2SugC4a0uAumKgkAAD0DD/vxwM9wgABgF5YKIAsC2RYJAADRwOB+4HjxwL4KL/sA2gh1 +KHbPcKAA1As4gEIhAQiA4cohjABAJgASEHGMDYULA8zXcAAAAEAB2MIgCgAXuAAggQ8ADgAAB24E +IIAPAAD8/yV4nbifuOxxAKEBEgE27HAgoCK+BvDscQChBOVhvvkOtZAAheIIAAC5Ag/74HjxwOHF +z3KgANQLA92xogDbcKIDEgI313IAAABAAdrCIooAF7rHcgAOAABFIgIGnbqfuuxzQKMC2hQagjAF +EgM27HJgogsSAjcB4gsanDDscgCiARICNuxwQKDscCCgz3CgALAfAdk5oM9xgAAkIAiBQIDscECg +DIEAgF4IAADPcaAAyDsOgYi4DqExAg/74HgDzNdwAAAAQAHYwiAKABe4x3AADgAATyCBAJ25n7ns +cCCgz3CgABQEA9kloAESAjbPcKAA1AtNoM9woABEHTWg4H7geAPaz3GgABQERaHPcaAA1AsNoc9w +oABEHVWg4H4D2s9xoAAUBEWhz3GgANQLDaHgfgPaz3GgABQERaHPcaAA/AsMqc9woABEHVWg4H7g +fuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4z3OgAKggMYPPcoAA/CcDgjhgA6IB2BKj4H7gePHA +5ggv+7hxz3CAALStaBAEAEogACBMJICAyiLGB8oghg8AAJEMyiOGDwAAtwcsBSb8yiHGD89wgADg +BgeAhCwICQAhgX+AANSpFnnHgX8NEQDPcIAAhCgaDG/8iiEPD89wgAAYKA4Mb/wg2c9wpQAIDKCA +UyVNkBLyKQ1QECsNkBAKIcAP63LPcAAAkgyKI58HmHXFBC/8CiUABP/YB/D/2Ai4A/D/2BC4z3GA +AAAGDKGtoc6hANmRuc9woADQGzGgjg0gCgHYHfDPc4AAAAYOg5voz3GAABBmz3KAAIQoz3WAAPwn +iiTDfwpwqCDAAg9hFSXDE+eD8CIOAAHg/mbHo0kAD/s4EwQACiHAD+tyz3AAAJMMiiMfDEEEL/wK +JQAE4HjhxeHGz3CgABQEA9kjoA3Iz3KAAJzKYZLPcYAAjMnEihQhDQBotQAggw+AAKzJOOHAq2KC +FXkGkmChAxIDNsAdBBAEgqATAQCGIcMPJXigGwAAwcbgf8HF8cByD8/6CHYqDqABKHWA4NElYpMB +2AP0ANgEuM91gAAY3xR4CWUdZRUJUQCGCSAKqXBmCG/9AY0A2ACtAYWhB+/6AKbxwBYPz/oNEgE2 +z3egALwtz3CAAIAhLqcEgADdRhARAVYgUgRWIJMEDRIQN1YgFAVGIMAgAxICNg0aHDCkEgAAhLik +GgAAAZKiwYYaRAMI6M9wgACMyvQgQAAJ6AGCDwifA1AgACAvIAggUyB+oD4DAQDPdoAA7DppFgAW +AeAEEgM2aR4YEKQbQAMBkpUIEADPcIAAjMk0eIAQAQeFCREA0BABAVMhwYAU9HISAQHgkiJ/uBKB +ACJ/8H/gGMQDpBIBAIYh848G8mi/8H/gGMQDcBIPAeAQAAEhkuJ48XDCJw4QwiHOA3QSAAE4YLgS +gQB0G0QDoLM4YBB4kBsEAL4bBAAQihCrAYIBowiKCKsSigDaEquWujLwGgngAYogBQEPh/kI3oVP +h1MiwAJNCp4FEwiVA6cWABa2ugHgpx4YEBzwZLgEEgE2EHiQGQQABCKADwAAAPAsuHQZRAOgsRCp +obEDyL4ZRANhgKiphiP/DYS7YaESiBKp9royAgEAANiWuAQSATakGQAAKQpeBXoL7/4A2AQSATak +EQAABCCCDwIAAAAtugUiAgQvIIggP/ABgacIHgE0ylCJSSDEAPJqz3CAAJDW9n/gYHKJEQieBc9w +gADQ2FZ4AYgD8ADYACSPD4AA0NhWf+SPCCPDAwgjAABJIMMDFmp1eM9zgABQ2gBjz3OAANDZVntB +g89zgACAIWSDeINlegQigg8AAAAIRniYGQAAANiWuEGBhiL/DUEIHgWfChAAmBGCAEAiAClIYM9z +gADcr0DAIMLDulx69COCAFHwCiHAD+tyNNiMuF/bBbuKJIMPMQEv/EolAACYEQMAnBlAA0cLXgKA +uKQZAAAp6pgRgADPcoAAgCFDgoYg/wNEuDIkACCJuEDAIMNUgmR6hiP/A4Yi/w5Eu3piT3rPc4AA +dGX0I4IAHfAVCx4CCeqYEYIAQCIAKUhgDPCE6gDaSHAR8JgRgADDuBx4MiMAIEDAIMLPc4AAhK/D +ulx69COCAIgZAACYEQAAhBmEAJARAQGuCCAAANoEEgE2AxINNoQRAgGCGQQAz3OgAMgfWGAQeLAZ +BAD4EwIAsBUPEUJ/z3KAAIAhRIIAIdEjVBIEAQAkTwQfZ6ATAwDwfzkLxANQgpgVAxALIsCAFvQw +iVCNMHLRIyKCFvKGI/8JI7sB4yELlAACus9xgACQ1lZ6QWERCV4EuBYAFgHguB4YEA3wgHAQeIYd +BBBqFgAWDRocNAHgah4YEMED7/qiwKHB8cBuC8/6CHVGwOi9KHDOACEASHYDuEAgkAVEJQIWI7oE +JY8fBgAAAAHiQS9AFAQlgR/AAAAAWGA2uc9ygAAAcKlzxrspYghiOGBBLYESUiEBAMC5A7kY4YXg +yiGNDwEAiQ3VIQ4ALyFIIAQlgR8AAAAYz3CAAMBn13EAAAAIHgAiAPAgwAAmwaDhEgABAM9xQnvQ +XgUofgAKIMAOCnEFKT4ACiDADiS4AeAE71MgAQA4YAIpgSMhDV4Tz3KAAPxoQJIFKj4AACGAfwAA +/z8uuF8AIAAZYVcAIAAVeVElQJJWACEAJsW35SIACwAzaFMlAhDPcIAAvGXwIIAABSk+AAogwA4B +4AbwiuXAKOEAwCiiAM9xgACAISOBwNo0gaR5hiH/DiK5OnraehliMHgI3KMCz/ozaFMlwBAceM9y +gABAafAiAAAW4QUpPgAKIMAOAeAU2YUH7//aec9xgAAkICSBQSiCBdW4IIFBKYMF1bkCec9wgAD4 +3mJ6BYDJugUovgAncc9wgADYWQOAAIDgfzhgz3GAACQgJIEggUEogwXVuEEpggXVuRkJJQBbY89y +gAD43kWCWWECeQHjA/ACeUArgAWZB+//JXjxwFoMz/qmCe/6UNlFwEogACACCq/+hsUjCDUlBBUB +FAXAFSAABCCgQCBQIO0JgY+t3u++JNzbAc/6CiHAD+tyz3AAAIsTiiMHC5hz0QXv+wolAATxwOHF +mHAZCPQAuHEKIcAP63J92I24tQXv+/Dbz3CAAIAh8CABAYojCw1AIQIGeGJPDREAqIF6YqCiSYFB +oFyJSKhdiUmoKhGCAEqoKxGCAEuoLBGCAEyoTZFHsFeRSLBIgQQigg8ABgAAgOIB2sB6UqhUkVOo +KIHAuS2oGvA5DVEAYmJIoUGASaFIiFypSYhdqUqIKhmCAEuIKxmCAEyILBmCAFOIVLFHkE2xCJAX +sSEBz/oKIcAP63KQ2I24DQXv+4ojhAfgePHAkgjP+s92gADcnwQWBRBCJUEAheFMAS0AosEyJkFw +gAAYYEAnAHI0eAB4AtgApgHZz3CAANgfILCOC+AHKHAChs91gACcHyiFR4UIFQQQDyBAAAKmz3CA +AHwfNXhAoBgVBREMFQYQz3CAAKg1ANk0qM9wAADgrUDABYUQFQcQQcAajTuNQIXeDqAIYYWKIBkB +FgngATqNYfDPcIAA2h8B2SCoz3CAAJwfJ4DPcIAA4MgvoGIIL/0C2FHwBNgApgDYz3eAANgf/grg +BwC3z3WAAJwfAoZIhWeFDyCBAM9wgAB8H1V4YKAipuzYhg+gA0CXCBUEEM9wAADgrRgVBREMFQYQ +QMAFhRAVBxBBwBqNO41AhVIOoAhhhSQVgBBIhQDZUSAAgQSGDyGBAAnyAdvPcoAAqDV0qgV5JKYD +8CZ4BKa2DKADANij8a4LD/wH8IogGQFSCOABIoahB6/6osAIFgQQCiHAD+tyz3AAAEIfkQPv+4oj +RAfxwOHFiiAZACYI4AGt2QHdz3CAANyfoKAA2M9xgADYHy4K4AcAsaYMIACpcGUHj/rxwOHFANjP +dYAA3J9aCCAAAKUqDu/8Atgihc9ygADYH3fYqg6gA0CSOQeP+vHAvg6P+gDez3eAANgfwLfiCeAH +yXDPdYAA3J/CpcOlxKWKIMkAyXF2DqADQJcB2PUGr/oApeB48cDPcYAA3J8AEQUAGw1UAQohwA/r +cs9wAABBH5nb2QLv+4okgw8Boc9wgADEH/AgQAFAeNHA4H7xwE4Oj/rPdYAA3J8EFQUQosFJDVAA +Iw2QANsNUAEIFQQQCiHAD+tyz3AAAEQfkQLv+4ojRwbPcIAA2h8B2SCoz3CAAJwfJ4DPcIAA4Mgv +oIIO7/wC2FHwBNgApQDZz3CAANgfILAeCeAHKHDPdoAAnB8ChUiGZ4YPIIEAz3CAAHwfVXgipWCg +pg2gA4oghgsIFgQQGBYFEc9wAADgrQwWBhBAwAWGEBYHEEHAGo47jkCGcgygCGGGJBaAEAHfSIYA +2VEgAIEEhQ8hgQAI8s9ygACoNfSqBXkkpQTwJngEpdIKoAMA2IogGQF6DqABOo4D8MIJD/zBBa/6 +osDxwFINj/rPdoAA3J8EFgUQQiVBAITh5gANADMmQXCAACBgQCeAcjR4AHgChs9xgACcH0iBJ4EP +IIAAAqbPcIAAfB9VeCCgWfDPcIAA2h+A2SCoz3CAAJwfJ4DPcIAA4MgvoHYN7/wC2EfwCpaMIAKA +EfQA2M91gADYHw4I4AcAtSKGiiAFBK4MoANAlQHYAKYz8APYAKYx8AOGjCDDjwHfEvQA2M91gADY +H94PoAcAtSKGiiBFCuCmegygA0CV+ggP/BvwANkPIQEAAoYGIECAEvQA2M91gADYH64PoAcAtSKG +iiCFDE4MoANAlcoIL/zgpgPwAqbFBI/6CBYEEAohwA/rcs9wAABDH7kA7/uKI0YA4HjxwOHFz3WA +ANyfBBUFEEIlQQCTCZUBMyZBcIAAKGBAJ4ByNHgAeM9wgADaH4DZIKjPcIAAnB8ngM9wgADgyC+g +ggzv/ALYLfAChc9xgACcH0iBJ4EPIIAAAqXPcIAAfB9VeCCgHfADhYwgw48B2gnyANkPIQEAAoUG +IECADfTPcIAA2B9AsO4OoAcB2APYFggv/AClBfACpQPwAdgApRkEj/oIFQQQCiHAD+tyz3AAAEUf +/Qev+4ojSAvgePHAhguP+gh2iiBZAYoMoAHJcc91gADcn8Ol5gzv/wXYI4XPcoAA2B+g2DoLoANA +ksEDj/rxwEYLr/qKIJkBz3WAANyfUgygASKFz3CAAJiuCIAA3ye4wLgTeMa4AeAKtQjYOnAA3gKF +DybOEwsmAJA38gSFCyCAgx7yxngEpc9wgACYriAQgAAtCFAAz3GAAKg1EIkB4A94EKmKIAoF+gug +Aclxz3GAAJiuCIGGIMMPgLgIoYogmQHeC6AB6XHPcIAAfB8VINADABAAIIDg4iACAAKFANkAGEAg +xngCpUIhQCAB538IdYDvfyqVz3aAANgfAJYXCVEAj+gA2c9wgACoNTSoiiAKBATwh+iKIEoEhgug +AQDZAYUTCFABAJaB4APYyiAiAdoLz/+xAo/64HjPcoAA3J8iggDbDyMDAGZ5IqLPcYAAfB8A2hV5 +4H9Aoc9zgADcn0KDDyJCAEKjz3KAAHwfNXrgfwCi4HjxwBoKr/oZcQh2iHXPcYAAnB8aqRsZAgJA +oRAZwAEMGYABoqEDwBgZRAEExQehJsCooSQZAgAHwGGhBaGKIBkC6gqgAalxU9jJca4JoAOpcibA +FQgeAFfYyXGeCaADqXIG2AbwgeYC2MogYgAmC8//FQKP+vHAmgmP+jpwz3aAABwgAIYB4M91oADI +HwCmEQhRAAHYUR0YkE4KAAukFRAQz3CAAEAvJoDPd4AAVLtgeQDYAYcp6CTYGNlOCiALM9ofCFAA +BBcFEAohwA/rcs9wAAB0GY3bsQWv+wokQAQk2AHZJgogCzPaHwhQAAQXBRAKIcAP63LPcAAAqyiS +24kFr/sKJEAEpBUBEIogGA8eCqABAiEBBACGQiBAgACmBfQA2FEdGJBJAY/64HjxwO4Ir/qKIBgO +z3aAAAA57gmgATKGz3CAAEAvBICK6M9xAACtC9oJoAGKIBgOPvAyhuTh1vbPdYAAZF0AhdrgUPaK +IFgOugmgAQjZQIUyhoogmA4QuqoJoAFFeQjYG/Da4UgACgDPdYAAZF0AheTg3PaKIFgOigmgAYoh +Pw5AhTKGiiCYDhC6dgmgAUV5iiA/DnIMwAoghUgWABEQua4O7/8leBKGAKWxAI/64H7geOB+4HjP +cIAAWDdAiBEKHgDPcaAArC8ZgYq4GaERCl4Az3GgAKwvGYGOuBmh4H7geM9xoADIOx2BB+iC2BSh +z3AAgBEUDqHgfvHA4cW0wYt1qXDPcYAA3GGmCK/6UNrCDkAB/gtgAalwSQCv+rTA4HjPcIAAaMts +iM9xgAA8oIwjAoAKkUEoAgMM8hkI3wICu3Z7x3OAAJDWApMPIIAAArMA2OB/DLHgePHAkg9v+lRo +hiL4A08iQwJTIcIABSLEAM9ygADw1RR6j+GKIw8MyiApAAn2AJIA3Q8lTRCKI88PpngAsgDZSiQA +dM92gABMo89ygADEo891gADIo6ggwAQUIkAA5JBkfxkPAREA3+SwFiZAEOCg4aBAJQAZNXjgoAHh +gQdP+uB48cAA2p66ANnPcKAA/ERBoOB4IaA+DuAHKHALyAQggA/+//8DCxoYMAvIh7gLGhgw0cDg +fvHA4g5P+kh2gOAB3UT2iiX/HxN4CQkTALN9M3kUIQAAegiv+jt5rHgAHkAeIQdv+gHY4HihwfHA +4cVCwJhxSHWA4ADaRPYB2hN4QsCGCCAIgsACwALqE3hCCK/6iHEApQjc9wZP+uB48cDhxQhyAd2A +4cohwQ/KIsEHyiCBDwAAmxPKI4EPAABcAMokIQDAAqH7yiUBAYDiRPZTeool/x8JCRMAM3mzfRQh +gADuD2/6O3mseKEGb/ovcOB48cDhxc91gAA8oM9wgACAISOAQIUAgUMKAQACkUKVOwoBAAKFcgmv ++yOFjCACgBXyz3KAAHQHIYIA2w8jAwACuGZ5FnghogAggQ+AAJDWAIGquIi4AKEA2EEGb/oMteB4 +z3CfALj/z3Gg/vAENqDPcKAAyB88gEAQAAbPcJ8AuP9YGAAISiTAcc9xAAAIgaggAAIp2BK48CBA +AAHh4H7gePHA4cXPcAAA///PdYAAWKADpc9wgACsWHIKAAnPcIAAyFhqCgAJz3CAAHBZXgoACc9w +gACMWVYKAAkA2SClBdgBpSKliiDJA04OYAGKIcwEggyv/AbYfgyv/AnYnQVP+gfZz3KgANQHGhpY +gA3oGRIBhgkgQwAPEgGGAiDAgHlhDxpYgPX14H7xwPoMT/oDEgM2CHcNEg42z3GAAIzJEIvPcoAA +kNbUeQK4FngFYjGJLb1YYMC9DOkhgxUJXgPPcYAAuCC0eaCREOWgsSWQIwlSAGG5JbAQizJoNnk7 +YmWTOmKH6yaSUSFAgFgIgvvyDgAKzg5gBQ3IA8gB2aAYQADPcQ8A///uCCAA6XDdBE/68cBqDG/6 +A9jPdqAA1AcTHhiQDxYRlgAWAUAAFg1AosHPcLD+AADTuQV5QMXPcp8AuP82olMlwRQleBaiIMAh +CBAHCiHAD+tyNdiMuM9zAAD0DJhzjQCv+0olAAAAFg9A8H8AFhBAQOdRIAClwCeiEAPnBCePHwAA +/P8H8M9wAAAFDfoOAAEZFgCWQicBFPEIRIAAIcAjDx4YkAPYIB4YkBkWAJYnCBQCHxYAlkHAIcCc +4Mohwg/KIsIHNtjKI4IPAAARDc8gIgPF9drYugxgAalxBCCALwAAAEDxA2/6osDxwIoLb/rI2oIk +AzIIdSh2z3GAAExiQgxv+otwz3CAADgWDYDPcZ8AuP8N6B2hz3KAAAQgBIIB4LO4tbi4uASiFqHP +cKAAFAQB2kSgz3KAAOQ7GILivQHgGKLPcKD+EAEWoUAuABSleBahyiAiALQOwf8acA3Iz3GgAGQu +z3KgADgu8CEBANO5B4IkeAQgkQOn8JIOz//PdoAAiOMacMlwOg+gA4txBgggC8lwmfAD389woAAU +BPCg5KAAFgRABxoYMQAWBUABGlgxBMo9CBEHi3DiCWAKDtkkwFMgwQCGIP4DRLjEHAIwZMFEJo0U +Mw5eEI7YkLigHAAw1Q4eEYbYkLigHAAwZPDrcs9wAADcDs9zAAD0Cu0Gb/sKIcAPEQgQIIzYkLig +HAAwUvACuTZ5x3GAAJDWQIFIdIQkDJAN8hEKXgKL2JC4oBwAMAHdQPCI2JC4+vFOiVBwkdjPICIE +9PUBwBEIngYB3ZDYkLigHAAwLvAzFIAwIpEtCQ4AB8gEIIAPAMAAAB0IgQ8AwAAAIsCA4MogiQ8A +AI0ArAfp/88gKQQKwYwh/48S8s9woAAsIBCAInjXcACAAADKIIUPAACHAIQH5f/PICUETCAAoMwl +IZBf9c9woAAUBOOgTCAAoKl2ZfVTJn6QCPLPcKAAFAQJgIDgXfVlDl4QAdpXCRAgKnEvKEEATiCD +B5TjyiXFEIX3aHWAJcIUz3CgAGgs8CBAA5TjD3jKJ8UQhPdod4AnwhHPdaAAGCzwJc0TsXDKIiIA +CeoA2A8gwAAGIQGA2vUB2ALwANiA4CvzjQFv+oAkAzLxwCoJT/oacGYLoAEw2JhwKbhRIACAyiHC +D8oiwgfKIIIPAADpFMojgg8AAMcAcAVi+8olIgAs2HYLoAFAKIEgAd6KJQ8aKgugATDYmHApuBkI +HgCMJg+aJvKmCeAKAdhhvecNdZAB5gYLoAE02E8gAQWVuToLoAE02PYKoAEs2Ah17gqgATTYuHAz +CF4FCiHAD+tyz3AAAOsU49sBBW/7SiQAAAohwA/rcs9wAADqFNTb7QRv+0olAADVAG/6QS0AFOB4 +8cBmCE/6CHcA3slwNgwgBMlxA9jJdRpwCe9ELT4XACGAf4AAeFdODcAICu9ELT4XACGAf4AAIFg6 +DcAIQiBAINcIdYAB5c9wgABMrsl0nbAwvJ6wz3CAAOgHpgpgBcCgaQBP+uB+4HjxwM91gACEBnzY +DglgASCFABUEEAohwA8BEgU263LPcAAA2w5NBG/7j9vgeOB+4HjxwMYPD/rPcKAAVC4rgAfd07kv +KEEATiCPB89woADAL6UQEoYUEBGGz3agABQEqqaGC2AHgNjz2AW4gNkWCqABn7kNEhA29dgFuAoK +oAGpcaqmDRpYMwTwA9gFpqmGG+187UEtgJAK8i8kCXDgeKgggAEAFgBA4HhTJU2QCfIvJElz4Hio +IEABABaAQOB4qYbo8fPYfgmgAQW4yQjfh/XYBbiyCaABCnEoHgAUlOcNGhg0yiHFA4X36XGAIcIB +z3CgABgs8CBCAJTnyiHFA4X36XGAIcIEz3CgAGgsNXgEv0Cgx3eAAEzTFYc2hwV5F4e4hyV4BSUN +kMohwg/KIsIHyiCCDwAAwiHKI4IPAACNB8okQgMsA2L7yiUiAIDZz3CgANAbMKDPcKAAwC+lGJiE +FBhYhO0GD/rxwIYOD/qkEQAAKHVRIACACtjKICEEmBUBEAQhvo8BAADAdh0EEDD0LQkeAkQhAAYj +uEFoBCGADwYAAAAxuFhgBCGCDwYAAAHXcgIAAAHKIKEAA/AB2CMIUAAVCJAAg+AA2Mog4QHAKKED +C/DPcIAAfMkCgAXwz3CAAHzJAYAFeZgdQBCeFQARlB1AEJIdBBCCFQARkBUREbIdBBAA2IAdBBB+ +HQQQA8jPdqAA1AdBkBAVkhAI6g3Iz3GAAIzK9CEAABPoGRYAlh8IFQ4NzM9xgADkO0YggAINGhww +GoEB4H8CIAAaoQ8WFJYJ6g3Iz3GAAIzK9CEAAAPoAdgF8APYEx4YkADYBxIPNgESEDYAFgRAenAH +GhgxABYFQAEaWDEEypzgyiLCB8oggg8AANwOyiOCDwAA9ArQAWL7yiHCD6lwegwgCg7ZHwtRIATI +AZAg6M9xgABYPRqBAeAaoRyBAeAcoRbwA8gBkBToDcjPcYAAXMr0IQAAUyDAgAr0z3GAAFg9GoEB +4BqhG4EB4BuhAxIBNgGBHQieA1QRAAFTIMCACPTPcYAAWD0ZgQHgGaECFQURKQ0QAAGF7rjKIcIP +yiLCB8ogogvPICIDyiOCDwAAtQc0AWL7yiRiAACVsHDKIcwPyiLMB8og7AvPICwDyiOMDwAAuAcQ +AWz7yiRsABCNUyDBAIYg/gNEuMQdAhCkFQAQMK1HCJ8FBxICNgIiwQMA2A8JUAACJ4EQjCHDjwL0 +AdiT6A3Mz3GAAOQ7RiCAAg0aHDAZgQHgGaEPHhiVBxrYMwEaGDSD8Aca2DMBGhg0ANh0HQQQfglg +AKlwz3GAAAhwC2F0FQIRz3GAABBw8CEAAHpiUHqkFQEQdB2EECV4pB0AEATIAZAT6B0LUSABlbgV +jxBYYCCV+GAQeL4dBBBZYT9nDvC+FQARCfAglbgVgBBZYThgEHi+HQQQCHeQHQQQDxYAlrQdBBB+ +CeAEqXAQjTJ3zCCBhBPyCiHAD+tyQCkNJEAoDgQw2Iy4ANuLuwUlxBMFAG/7BSaFFKQVABAIdIQk +GpAh8j0IXgIDyAGQGugNyM9xgACMyRR5gBEAB5Lo0BEAAWoVjxAB4MO4+GAPeGodAhD2DqAAqXBq +HcITBfDqDqAAqXAPHhiVfQMP+uB48cAqCw/6GnAA36QZwAPPcIAAgCEEgNCJ8KAHyAQggA8AwAAA +KHUzCIEPAMAAAA3Iz3GAAIzJFHkRiY/oz3CAAHDV1ngiiAiNDwhDAApwxggv/qlx3PBRIACghvIE +FQQQgQweAQ3Iz3KAAIzJFHoREoUAD3hJIMIAcm7PcIAAkNZ2e2BgMo0TCJ4Fz3CAANDY1ngBiALw +ANjHcoAA0NjWekSKCCGBAAghAQAAIUABSSDBAxZuNXjPcYAAUNoAYc9ygACAIUSCz3GAANDZ1nlY +giGBRXkEIYEPAAAACCZ4A/ADhc9xgACAIZgdABAkgSiBBCGBDwBAAAA+uVMkAgAe4Th6RXiYHQAQ +FwieB6QVABCMuKQdABBQ2JwdABB48CsI3gekFQAQjbikHQAQz3BAAVAAnB0AEM9wgACAISSAEIGe +uBChZPAF2BS4nB0AEM9wgACAIaQdwBMkgBCBnrifuBChVvCPCF4nAYVzCB4BEo00EoEwSSHBAHJu +z3KAAJDWdntiYhEKngXPcoAA0NjWekGKA/AA2sdxgADQ2NZ5JIkIIEAACCCAAEkgwQMWbjV4z3KA +AIAhRILPcYAAUNoBYc9wgADQ2dZ4WIIBgEV4BCCADwAAAAgGeQLwI4WYHUAQDcjPcoAAxMkVeiCi +nB3AEwXwBdgUuJwdABARCB4lANiRuKQdABAE8KQdwBN0HcQTcg4gAKlwz3GAAAhwdBUCEQlhWWEw +eXQdRBDPcYAAEHDwIQAApBUBECV4mBUBEKQdABAZCV4CCtl2HUQQeB1EEIC4pB0AEBXwENnPcoAA +gCF2HUQQQ4JIghMK3gAK2XgdRBCDuKQdABAD8HgdRBBmCm/8qXCkFQAQRCB+gowVgRAY8s9ygACA +IUOCVIIkeoYh/wNEuYYi/w46Ys9xgACcZfQhkQDPcYAAdGX0IZIADvDDuc9ygAC0rzx59CJRAM9y +gACEr/QiUgCYFQUQUyAEgMogggQV9IgVgRBRJQCCw7k8edEgIoUI8s9wgADcr/QgQAAH8M9wgACE +r/QgQAAhhQsJ3gCEHQQQA/CEHcQTHQ0eAkQlAgYjugHiBCWADwYAAAAxuBpiA/AB2gPIAZAj6A3I +z3GAAIzK9CEAAILoAZW4FYMQdBUBEQQlvo8BAADAeWE4YBB4vh0EEA/0CiHAD+tyLNiMuIojGgkt +BC/7iiSDDwCV5vE9ClAAguLMIuKAyiHCD8oiwgfKIGILzyAiA8ojgg8AALUGyiQiAPgDIvvKJQIB +z3CAANDY1ngDiAfwz3CAANDY1ngCiIwVARAOuCV4jB0AEM9wgACsBkCABoKgEAAGh+jPcIAAqFoA +iLcIEAANEgM2rwuQAQCVz3GAAFg9nwgSDM9wgACMyXR4EYiLCBEAgwwRAHsIHiCeFQARz3OAAEQ9 +irieHQQQFpMB4BB4FrMByOehBaGYFQEQrrmvubC5mB1AEAaCoBAABi8oAQBOIIIHI7oO4g8hgACk +FQEQmB0AELS5pB1AEJ4VARGnuZ4dRBDPcYAAnFoAoQQggA///9P2mB0AEA3YmB0CEAnwENgG8AjY +BPAC2ALwAdgHoZgVABC+FQERFgsv/wDapBUBEAQhvo8AAAAwgh0EEFDyjBUCEJwVABGUHYAQkh0E +EIAdhBQDEgM2GQkeAxTYkB0EECpwfh0EEHgTDgEK8A7YkB0EEH4dxBN4Ew4BSnDCeBB4sh0EEM9w +gAA4yQCAhiB/jwv0mBUOEBMOXxJhk4XrkbmSuaQdQBAQuCV4pB0AEAQigg8AAAAQz3GAAIAhZIFS +IgIDEIMFelCjRIEQggQggQ8AAAAQPXkleBCiFPCYFQEQgB3EE5QdQBCeFQERfh3EE5IdRBC+FQER +sh0EEJAdRBCAFQARfhUCEYIVAREaYoQVABFZYThgEHiwHQQQpBUAEM9xnwC4/xahnBUAEBah1QXP ++eB48cCCDc/5OgtP/M9wgABoywyIz3GAAJDWArgWeABhLbhTIACABfTPdYAA7DoN8M9xgACAISCB +xBEBBs91gADsOlEhQIEE9AHZ3B1AEM9xgACAIfAhAADPcoAAqFkgghiIRQk1AUEdGBAzJkFwgABY +YEAnAHI0eAB47gjgCAPYfgjgCEDYANjgHQAQDvDPc6AAqCAxgwKCAN7Cojhg4B0AEAHYEqNJBc/5 +8cDhxQfYDRoYMM9xoADUBxoZGIAOEQ2Gz3CAADgWSIAHGlgzD+rPcJ8AuP9doM9zgAAEIESDAeKz +urW6uLpEo1agz3CgAEgsvqAfEQCGARoYMATKnODMIIKPAACRAAbyABYAQAAWAEADzM9xnwC4/xih +iiBGBHYN4AABEgE2ARIBNn3YMgzgAgcSAjbBBO/5BMrgePHAuHECuc9ygACQ1jZ5MCJEAFEkQILK +IsIHyiCCDwAAyyLKI4IPAACTA4gAIvvKIcIPQC2BAc9ygABQ2iFiUSFAgooiCAXKImEDz3GAANDY +FiFBASKJDrlFeSCg0cDgfvHA5gvP+c9ygAAkIESCz3WAAFigYoVAgja7NrpQc9YijQ8AAIAAwIU9 +Yn5mHQ2FEwohwA/rcoogjQKKIxAEmHYRAC/7uHUeZv8NhZNYYAUE7/kOIIAD4HjgfwDY4H8B2M9x +gAAUOuB/8CEAAPHAmHAKIcAP63IKJcAHz3AAAJ8Z0Qfv+jvb4HjPcYAA8Dngf/AhAADxwJhwCiHA +D+tyCiXAB83YBbitB+/6RNvPcYAAKDrgf/AhAADxwJhwCiHAD+tyCiXAB89wAAChGYUH7/pN2+B4 +4cXPdYAABD4ChUKdz3OAAAA5NIMdCFEAInpOeuTiAJ0E9jODxuFS9gDYAqUBnQ7wQnkueYwhA4IB +nYj2M4PQ4cT2AdgCpQCd4H/Bxc9xgAAsBySB4H8goBGI4H/CuOB4z3GAALhZRoGKIf8PIKAG6iKC +IKAB2APwAtjgfs9xgADYWUaBiiH/DyCgBuoigiCgAdgD8ALY4H6KIf8PIKDPc4AA2FlGgxLqJIIb +CV4Az3GAAABZDwpAAM9xgAAcWREKQQBAguULgYAC2AXwIoIgoAHY4H7xwC4Kz/nPCBAAz3aAADSy +L47PcIAA0NjPdYAAgCE2eCKIA4UA389yoAAsIDQQEQE8EhIADo6A4JwAKQDKJakQjCIBpJAAJQDK +JSURZJaU48Ajhg8AAJMAz3CgAGgs8CDQAOWiUNhFIUECGNoODKAKINv4uMolIhIu9APYz3GgAPQH +BaGE2g1wQLBCIgAoDXIAskCGDXBAoEKWDXBAsAOFQIANcECgA4VCkA1wQLAGlkAoAiXDuAy4grgF +eg1wQKDkoQ6OAeAOrnYP4AgqcAHdEPAA3c92gAA0shYN4AYElgDYz3GAAOQ7Dq4egQHgHqGZAe/5 +qXDgePHAPgnP+RpwhCgICQAhgX+AANSphxENBs9wgADgBgKAoL2HGVgDBIgP6AOBjegKIcAP63LJ +2AS4iiOcDgokAARxBe/6uHUCgZvoz3KAANCxExIAhowgw48K8s9wgAAkIASAAIACoRwaGIQW8M9w +gAD0JwAYAAR2C2AIANgM8KoOz/6EKAgpCHEAIYB/gADUqyoOQAgNAc/58cCmCM/5GnCKIEwLsgng +AApxz3aAAEyuKQjUIB6WOhYFEQohwA/rchC4BSUFAM9wAACDDIojhQ/hBO/6CiQABEAoDSHdZSWV +BJUQuSV4OejPcIAArHDwIAEERCg+JwAhgH+AANhXL3cgoCOVApUQuR4O7/4leAhxACeAH4AAzFei +DUAIz3CAAKBw8CABBAAngB+AADBXR5UgoCOVApUQuhC5JXgmlQIPL/tFeeINz/4IcQAngB+AACRX +ag1ACF6WHZYA2Q8hAQQQukV4BiBAgAHdHbYwuB62GfTPcYAAJC0AgaC4WgrgBAChz3CAACQgBICW +2h7bIIDPcIAAjK6ioCGgDNkqCyAHGLsQ2s9xgADoBwCBACoCBEZ48Qev+QCh8cCOD4/5AN3PdoAA +TK4+lg8lDRAdlhC5JXgGIH6DQfTPcYAAJC0AgYC4AKHPcIAA2AbPcYAArCQAkEeJNwoBAM9wgADa +BgCQQYkrCgEAz3CAANwGAIgmiRsJAQALyAQggA/+//8DCxoYMAvIh7gLGhgwz3CAACQgBIDPcYAA +jK6W2h7bAIAAoQDYAqEocAzZfgogBxi7ANj6C2AAgNk+lh2WELkleKV4HbYwuE0Hr/ketuB48cDh +xWIMYAAodYDgyiBBA5wKoQPKIWEANQeP+TEHz//xwLYOj/lGC+AHAN3PcKAA0BsRgBcI3gPSCeAI +AdjPcYAAWD0JgQHgCaEGyAMSDjZDCB4ApBYAEDsIngTPcYAA7DkAgRfooKEBCZ5Fz3CgAMQsq4Df +2HYPoACpcVMlgRT+vcwhIoAH8pgWABDSCu/+ANoDEgE2oBEAACEIHgSKIAgADBocMPrYQg+gAKAR +AQDmC2AEA8g28EcIHgUHyNCJANozEY8ABCCADwEAAPBBKA0Dz3GgADguB4EPIkIDAdxGeAehDcj+ +CmAKACwAEMd3gACQ1gK+1n4S599noK8DEgE2iiAQAAYaGDD72N4OoACgEQEAA8igEIAAxOBQDgEK +A9nPcKAAFAQjoBUGj/ngePHApg2P+c91gAAIowGFz3OAANDZRCAEg89wgABoywyI0mjWfsd2gACQ +1kCGFnshgxLyUCKPBeCmRiEBBiGjDQwRAZG/4KYF8LG6trpAptYLAAoH8Ja6QKZFIQEGIaMLjaK4 +rQWv+Qut4cXhxs9wgABoy0yIjCICgM9zgAAIoxfyyovPcIAA0NkyajZ5x3GAAJDWVnhAgaGABe6V +ukChq70E8LW6QKGLvaGgANgLq8HG4H/BxaHB8cBRIACC4cWoACEACHVEJQMWBCWCHwYAAAAjuzG6 +AeN6YgQlgB/AAAAANrjPc4AAAHBKYwhjWGBBLYISUiICAMC6A7oY4oXgyiKNDwEAiQ3VIg4AUHFS +ACUAANjtvRgAIQACIYAAz3EcR8dxBSh+AAogwA4D8CK4QS1BE8C5BLk0ealyxrpJIsIFVHnPcoAA +YGcyYg8N3hJBKgEBFCGCAAUqPgBBKQByCNy/BI/5CiHAD+tyO9iMuM9zAABXEkokAACdAO/6CiUA +AfHAJgyP+c9wgABoywyIjCACgCvyMmg2ecdxgACQ1qCBz3OAANDZz3eAAAij5JcWe0GDUCWOFYYn +ux/AoYwnRJBGIgIGQaMF9JG+wKEL8LG9tr2goQ8PURCWvaChRSICBkGjQgoACgDZz3CAAAijIQSv ++Suo4H7geOB+4HjgfuB44H8A2OB+4HjxwBoKz/ngeOB44HjgeGkggAFvIT8AaSAAAPfx8cB+C4/5 +GnDPdqAA0A8A3QfwEBYAlv1h+GAQHhiQI21vCEQgJRYDliUWApYvJMcAJRYAlk9/D30IvaV/1wwR +g4LnzCfik8wnIpfKJUIQIfTPdYAA2K5JrSUWApYKrUutJRYClmitTK2iaRUP0RPPcIAA5a5+DO/5 +DdkN5RMPERfPcIAA8q5uDO/5DdkN5RAWAJYCIEEjOGAQHhiQRQOv+QHY4HjxwOIKj/mhwQh1KHaE +5QDYmPeLcDoM7/kE2QDAGwiAD5oJUG/PcaAA1AsPgWS9uGAPoQHYBvCpcCYP7//JcQ94DQOv+aHA +4HjPc4AAJC1Ag0V4AKMZ6c9xgACsJM9wgADYBgCQR4k5CgEAz3CAANoGAJBBiSkKAQDPcIAA3AYA +iCaJHQkBAAvIBCCAD/7//wMLGhgwC8iHuAsaGDDgfuB44H7gePHAz3OAAKQGaHAuDCAABNkEayYM +IAAE2dHA4H4A2M9xgABYBwGpBQbgCQCp8cDhxbYPb/0x2LRorg9v/TPYBX0Yvc9wgACQYDYOoAeQ +vSi4YQKv+aV44HjhxTJoNnnPcoAAkNYhYs9ygACAIS25wLnwIkMAKINRIQCAz3GAAHzJQYEJ8jyL +gOHFIoEPAAAKAgPyRSJCA0okAHQA26gggAI2aHV5ACGND4AAUNpApQHjAN3Pc4AA0NgWIwIAoKqh +qgHZIqoD2SOqSiQAcalyqCDAAXliFnmkqQHi4H/BxeB44cVKJAB4ANioIAAIANvPdYAABCBAhQ8j +AwALIsCAD/JBhQsiwIBA2s8i4gfKIoEPAADQAM8i4QcC8ADaz3OAADgWFXtAowHg4H/Bxc9wgABc +WgaAA4AggM9wgADolSmgTQEv/BHY4HjxwPIIr/kB2c9wgADMJ/YIL/8koIogxQ/PdqAAyB8ZHhiQ +AdgB2ShyKHOGDuAAmHEaCO/7AN/2Cc/7z3WgANAP9aXPcKAAwC96EAGGibmLuXoYWIDPcYAAAM0Q +GFiABdn0GECAAgzAAaIJz/6WCwAHQNnPcJ8AuP8yoF4IgAmA2c9woAAUBCygHR1YkJ4PQAgWDgAI +Qg1gCOlwB9hIHhiQvg0ABvYKgAGODwAAVg2AA2oMAAdeCkADNgqAB74IQACeDoAG1guP+74IAAGa +CwAIogoP/zYLgASCDgABhgwABvYOAAWuC8AD8g5P/pYNQASODUAEsg0AB89wAAD+yvoLT/tZAI/5 +4HjxwOYPT/nPd4AAgCEDhwiAwLiqDKAILyAAIADdz3agALRHz3CgAIxEuKAA2JO4dx4YkAjYdx4Y +kADYnrhTHhiQ4HjPcIAA3AAQeFMeWJNHHhiQz3CAAIwDEHhIHhiQTyCAI0UgAA1PIMYHNNhEHhiQ +HNhFHhiQz3CAANyVAYhGHhiQz3CAADQ6Xg7gBAyISiSAcM9xgAAY36ggQAPPcIAAfMlBgHRtdHs7 +YwKAQ6MB5QSjz3WAAHhaAIUE6GQeGJBDHpiRWgqgCAHYA4cIgECFHQgeAFMiQQASuUQiAAMOuCV4 +hiL/Awq6RXgS8EhwhiDzDwq4BCKBDwAAAAwGuSV4BCKBDwAAADACuSV4z3GAAFwtOQdv+QKh8cDh +xRDdHgygAalwB9kLuc9yoADwFzGiz3EAAPD/OKKyoi4LgAElB0/54HjxwKYOb/kA2s9wgADgBkOg +/9vPcIAA0LETGNiASiSAcEhxqCBAB4QpCAkAIY5/gADQq893gADYWUGmBt2lps91AQDU06SmRqbn +piQeghAAIY1/gADwq0ClAeHPcIAA0LEcGNiAz3GAAIQsAIEc2kCgGNgOCCAAAqGVBk/5OdnPcKUA +CAw+oOB+/9nPcIAArKkgqADZz3CAAFSp4H81oOB4ANqA4cokTXDoIK0B/9lcYCCsAeLgfuB48cDh +xc9xgADgyM9wgAA8cCYLYAdI2s9wgABgac9xgADYBxYLYAcI2gDdz3GAAOgxoaGioc9wgAAANamg +Hg9gAgOBz3CgACwgz3GAAHA1UIAQgEWhBqEaD+ABqaEJBk/58cAA2c9ygABMriCiz3CAACQtIKA9 +sjC5PrLRwOB+4HjgfuB48cBqDW/5INkA2s91oADIHCmlz3GgAJQTW6HPc4AAWBdgg/Noz3aAANzK +DIb1f1MgxAXwY/tjUyCPAKTBi3E7D9EQH4abuB+mNBaAEOKLGwjBAyhwQCMBBERrJg8gCEAmAxwN +2irwHoaRuJK4HqbPcKAAzBcr8CEPURFBKgJSQCMABMG6yg1v/YhzH4acuB+mDdoU8Cy4UyACAB+G +A7qZuB+m5IMF4gUnABEAoQWDAaEGgwKhB4MDoQPiz3CgAMwXz3GgAJQTXKEB2ojqH4aXuB+mINgK +pRnwAMED2hgYWIABwRkYWIACwRoYWIADwRsYWIAUGJiAihYBERAYWIAE2SelFhiYgM0Eb/mkwPHA +XgxP+aQQAQCiwdsJXwYg2c9zoADIHCmjpBABAF0J3gExiM91oAAQFCO5wLkDuQXhA9pPpUaFQcKN +4RDeyibiEQYUDzGMJ8OfCfQEFA8x8XbMJ+qQAd5C9gDe6+7FgEV+x6WxiIYl/B8YvaV6z3WgAMwX +WqAW8EWAz3GgABAUR6GkEAEAFQmeAjGI17qGIfwPGLlFeTqgz3WgAMwXDdkB2gPhDR2YkA4dWJAm +gBkdWJAngBodWJAogBsdWJAD2RQdWJBwEAEBEB1YkHAQAQHPdaAA9AcE4SelR6OkEAEAmbmkGEAA +4QNv+aLA8cByC2/5BNkIdQ0SDjYG2A0aGDDPd6AAFAQKp89wgAAwcJ4JQAcAhZYJYAcE2QGFjglg +BzjZCBUEEAGFABAFAQkMEAAVDQUBCiHAD+tyGdiMuJEHb/pv2wOFZglgB4hxAYVChSCQBYVWCWAH +QnnKp2kDb/kNGpgz4H7geM9yoAD8RDmCBCG+jwAACCAA2AX0PYL5uQLyAdjgfw948cAA2Jy4z3Gg +AKwvHKEagVEggIIagQvyqrgaoRqB5wgegMoKL/0B2AnwirgaoRqB0wgfgMYKL/0B2ADZm7nPcKAA +0BsxoAYKwAnCD4AJz3CAAJw5AIBCIACAyiBiANHA4H7gePHA4cXPcYAATK5+kV2RELtlegHdGwoP +AM9xgAB4V0QoPgdaD+AHACFADqlwAvAA2LkCT/lGgQnqI4FggSKCYnkwcADYAvYB2OB+4HjxwCoK +T/kIdc92gADYWd4P7//JcQfoqXDSD+//QCYBGIPoANgJ8M9xgAC4Wb4P7/+pcHnoAdhhAk/54HjP +cIAAAAYOgIDgAdjgf8B48cCSCAAABuiOCAAADwhRAM9wgAD4JwCAg+gA2BLwjggAAI/ofggAAIvo +z3CAAMgkLJDPcIAAgCEekOMJAYAB2NHA4H7ZAOAAEdjgePHAuHDPcaAArC8YgRkIngYKIcAP63KK +IIwJZ9vhBW/6SiQAABWBGwgfAAohwA/rcoogzAlo28kFb/pKJAAAAdjRwOB+4H8A2OB/ANjgfwDY +4H8A2OB/AdjgfwDY4H8B2M9wgACIGACIBujPcIAAcBgBiAPwAdjgfg0JXkcJyL24CRoYMADZnbnP +cKAA0BsxoOB+4HjxwP4IT/nPdaAAyB8kFQ6WFQ4eEoUVAJYWCo/7iiAEACQdGJATDp4QiiDXCuIJ +YADJcbINwAk1AU/54HjxwL4Ib/k02PYKgADPd4AAAIwvCB4E7gngAgDYwgngAgHYiiYQEADdag/v +/qlwFCdME2G+ALT1DnWQAeUO8ADbiiIQAIIJIARweBQnzBBhugC09Qp1gAHjzQBP+fHAYghv+TTY +ocEA3ZYKoABAxc93gAAAdDMIHgTeC+AAAdgD3gq+ANiMuLhgEHiLcdoM4AAB2hQnTBNhvgC06w51 +kAHlpgvAABDwBdsKuwPaCrp4ZRYJIAQQeBQnTBNhugC08wp1gAHlYQBv+aHA4HjPcAEADDXPcYAA +cBlhGRgAz3AAAIRTVSFCB0AhAwMG6B2jG4GDuBuhz3AAAFBTBugCohuBgrgboc9wAAAsUwboAKIb +gYC4G6HgfuB48cDhxW/YlbjPdaAAyB8SHRiQz3ABAEA8FR0YkL4NQAiKIAQADqX5Bw/54HjhxQDb +z3KAAEyjSiQAdM91gADEo2hwqCAAAkAlARIUeWCxAeBIcM9xoAAEJQ+hViIABBGhViIABRCh4H/B +xeB48cA6Dw/5z3WAAIAhBYXPdqAAxCd1HhiQDJV2HhiQB4V5HhiQEJV6HhiQ4g3v/wDfG+h3HtiT +eB7Yk4Ae2JOBHtiTB4WGHhiQEJWHHhiQB4WKHhiQEJWLHhiQBYWIHhiQDJWJHhiQBYWEHhiQDJWF +HhiQwdhQHhiQKQcP+eHFCHHDuM9ygADMo/QiAwDJu3BxyiQidMogIgDoICIC9CINAMm9CQlAAwHg +4H/BxfHA4cUIdc9xoADEJxkRAIYB2oDgEREAhsB6gOIApdEg4YcA2DP0z3CAAFjLDIDPcaAAyB9k +4B6hENgOoQHYFRkYgOoOoAkL2FEhAMbKICIAGPQlCF5Hz3GgANQLFoE4gSTgFQhFAMYOoAkD2AkL +H0AJCJ5EGNgD8ADYgODKIOIEz3GgAJAjPoEgpX0GD/ngePHA/g0P+c92gACAIRUmARBAgWmCuIpB +K8AAwLgXuMdwAACAHOS7zyAiBuC7Tt/PIKIAyieCHwAATgGG5c8nYRIpC18Bz3WAAMgkGBUEEb6W +Gw0BEaGGxBUNFhENXxGghsQVDRYHDV4RgbhRIwCCzyCiBRui/KJAgc9wOgRKcB2ioIEH2LoPYAAK +uAQggA8HAAAAMLhVCBUCMyYAcIAAZGBAJwFyFHkAeYogBAAepRnwiiAQAB6lFfAA2Iu4HqUR8ADY +jLgepQ3wANiNuB6lCfAD2Ay4HqUF8ADYjrgepYIgAQGFBS/5HqUKIcAP63KM2I24vtuLu0okAAB1 +AW/6CiUAAeB48cDPcYAA3DwXoeB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeNHA4H7geCGAANpTIX6AC/IA2pm6USFAgMoigg8AAIMAwCpiBs9xoAC0R0wZgIBm +kEgjAwNHkBC7BCODDw8AAADIukV7SJAMugQigg8AAADwZXpQGYCAQIBZCtEAYoDPcp8AuP99okWA +XBmAgEaAYBmAgEeAfBmAgEiAZBmAgEmAaBmAgEqAgBmAgEuAbBmAgEyAcBmAgE2AhBmAgE6AdBmA +gE+AeBmAgFCAiBmAgECAKwoRAkWAnBmAgEaAoBmAgEeAvBmAgEiApBmAgEmAqBmAgAqAwBkAgM9w +AABVVeB+4HjxwN4LD/kIdgGAz3WAAAQgAKUChs93nwC4/wGlANgCpc9w0P4AAGIKr/8EpQDYHacA +hs92oAC0Ry8I0QGGCgAAz3ADPwI/mx4YkM9wCT8LP5weGJAA2Je4TB4AkG8gQwCTHhiQBfBvIEMA +TB4AkGoLj/4AhSsI3gfPcKAAyDsdgA/oz3CAADgWH4AN6B2nBIUB4LO4tbi4uBanBKUD8ADYHafP +cAAAVVWdAw/5IpBIIUEBQCkCAyOQYoDLuY+5RXnPcp8AuP99os9yoADsRieiI4A1oiSANqIFgBei +z3AAAFVV4H7xwPYKL/kA26bBz3GAAAQgYKFhoWKhz3agALRHLBYBkAokgA8AAFVVSiQAeGhxqCBA +As9ygAA4FjV6YKIB4QDZmLmVHliQSiSAcc9ygAAEIAgSBQALEJAAAN05ddh1qXKpcxl1qCABBL9g +5I8AIEoDDQ/QHxUkQTNgoQHjSicAAA8nRwMLIMChCfIVJEEzIIFKIwAQDyNLEAPwSiMAECqICyHA +gQUhyRIJ8hUkQTMggUonAAAPJ0cAA/BKJwAABSLCAZDvFSRBMyCBDBAFAD/fCiSADwAArd4PIEgQ +BBrCExEPURIVJEEzIIEA2g8iQgATDxESFSRBMyCBSiYAAA8mRgAB5c91gAAEIAgdQBGA48okgQ8A +AK3eNvIliGSIBiKCAcW6ELkFI4MPAAAAP2V5BSGBDwA/AACbHliQZ4gmiAi7ZXloiBC7ZXlpiBi7 +ZXmcHliQBiEBEsW5n7mZHliQANmVHpiQmblMHkCQJIBYHkCQCpCUHhiQbyBDAJMeGJByCY/+iHDV +AS/5psDhxeHGz3KgAMBGz3OgAOBGSiQAcgDdqCAAAxYgTgMhhgHlBBpQACKGBBtQADGAz3KgALRH +mBpYgDKAsxpYgBOAtBoYgM9wAABVVcHG4H/BxfHAtMEF2BW4QcDPcB8A//9CwADZQ8FEwUXBRsFH +wT/YSMBJwUrBS8FMwU3BTsFPwVDBUcHPcAAA//9SwFPAdg/v/4twtMDRwOB+4HjhxeHGJIjPcoAA +uHCmiMK5LmIA2Q8hgQPPc4AALKhAg4TtJnpAoxjwRXkgoyWIFSONAyOlJohFiFlhJqUggIwhEIBF +94ohEAAgoCO5IaMAgCq4AqMA2c9woADwNiygI4MloCaDJqAkgyegJ4MooCWDKaAogyqgIYMroCKD +LaAggySgwcbgf8HF8cAiCA/5CHeacbpy2nMKIgAhCiNAIQohgCHPcAAAyBtqCmAACiDAIfpwz3AA +AMwbWgpAABtwz3AAAAQcTgpAAM92oADIHztwAdgTpgbYz3WAABA+AKXhpQgdABUMHUAVEB2AFRQd +gBQYHcAUHB1AFA7AIB0AFM9xgAAkIAmlBIEAgAqlCIEAgAulDIEAgAyloBYAEA2lpBYAEA6lqBYA +EA+lz3BDdagSEKXiCWAAKNgRpdoJYAAA2BKlUyfAdROlAchUHQAXFqUSFgCWUB0AFxelExYAls9x +oADIHBilFBYAllMhAjMZpRUWAJYQuhqlJBYAlhulFhYAlhylz3CAANw8F4Adpc9wgAAQPngYgArP +cIAAED58GMAKz3CAAIw+BBgAC89wgAAQPoQYQAsogYgYQADPcYAAAAAkgYwYQAAvIccFCLklei8h +BwZFeZAYQAC+CWAAJdkJB8/48cDuDs/4z3OAAKQ+Q4MA3c92oAAsINCG8mr0f39nxacEpwHijCII +gCanQ6OF9wKDo6MB4AKjIQfP+OB4z3GAACQgCIEA2kCgDIEB2UCgz3CgALAfNKDgfvHAmg7v+Iog +TA2iD+//iiGYBAvIAN4EIIAP////AwsaGDAmDiAAyXDPdYAA4AYRhYDg1AwiAMogYgDNBu/40KXx +wOHFggkgAAh1jCD/jwj0iiAHClYP7/+pcQDYsQbP+PHAOg7v+GrYosGLcQHaVgmgAEhzj+gKIcAP +63LPcAAA0hSKI8UEiiSBCn0CL/pKJQAAQCSBMUTYAdoqCaAASHOP6AohwA/rcs9wAADTFIojxQWK +JAEBUQIv+kolAAAGD2/5BhQAMZEIEACBwWvYAdryCKAASHOQ6AohwA/rcs9wAADUFIojhQeKJMEK +GQIv+kolAAAEFAAxQCSBMAHaxgigAEhzj+gEFAUxCiHAD+tyz3AAANQUiiNFCO0BL/qKJMEKAhQA +Mc92gADwXht4QSjFAEwlgIwAHkAR1PYKIcAP63LPcAAA1RSKI4UJuQEv+ookwQod2M92gADwXgCm +uHAAFAAxz3WAANTkQC2CAKlxUgigAAHbkOgAFAQxABYFEAohwA/rcs9wAADWFHkBL/qKIwUMQIYn +CnIAANgWJQEQYImGI/8NI7sNC1EAYYkE62K7YakB4OkIgoAA2EkF7/iiwOB48cDCDM/4p8E6cHpx +GnJac4twz3GAAIxhfg3v+Braz3GAAPBeIIEA2IDhuHG6AC4AiiX/H89xgABkGAARhACKJv8fyXUC +8Ol2TCGAowHaz3GAANTkFnlgicIijABEI48A/X93CsED4YlEIwIEJLpEIwYCQS7GAEQjAQEiuVsI +gSEdDFEAgOHMIiGAB/KB4cwiYYAA2gL0AdpPegXwgOIB2sB6NwpRAEwiAKYB2sIiigCGI/0PJ7sP +CYAAgOLMIGGgC/Qyd8wjIYAJ8gPvBesLCcIjDw7CE8l3BPAB2QjwCHUB4GcIRIEA2Yog/w+E6YDl +yiBKA4wg/4/KIIEP/////xXyMiSCNM9xgADU5A8KUQBicRZ5AhHAAAnwFnkLCpEABhHAAAPwBxHA +APED7/inwPHA8gzP/3TYrgzv/4ohSwqiCk//igpABu4PD/8KIcAP63I92IojCw5KJAAA5Qfv+Qol +AAHxwM9wgACAIQKAwhAABlEgQICIDsIF0cDgfuB48cBKC8/4GnAodTpyz3CAALyuyg4v+kTZz3Kg +ANQLfoIAJYEfAAAAQM9wgACsB2J5YKDNuc9wgABYyy+iDIDPcqAAyB9k4B6iENgOogHYFRoYgE1w +hiD8A9DgzCCCjwAAgAAS8owgA4QT8gohwA/rcgokgArPcAAAMhGKIxoNRQfv+bhzCnAiCS/7KnIE +8N4PL/oKcBvoz3GfALj/z3Og/mwDdqEWoc9zgADcyj+DANqc4LO5P6PPcYAACKNLqc9xgAA8oEyx +yiCBAOECz/jgePHAhgrP+M9woADEJ1IQAYZBEACGhiDjjwDdBvLrudEhooFI8s9wgACAIQOACYDP +doAAvK4tCF4BXgnAA4noFI6B4MogIQGoDyH/yiFhAM9wgAB4rwCADQieAM4KYAAQlrSuz3CAAHiv +oKBNcIYg/AOMIAKAGvTPcYAAjBgAgQHgAKHPcIAAgCEDgBiIhOBIDgH/iiBHDQIL7/+KIcsDrgnA +A0IOz/oG8IwgA4RACEH6QQLP+PHAzgnP+ADeAt3Pd4AAxKtAJwAbhC4IGTAgQA5RIACAbAgi/8og +ggNhvekNdZAB5g4IIAAA2AECz/jgeIDg8cAQ2AryDgoP++oMYAGKIAQA0cDgfsoID/ueDGABiiAE +ADINgAcNCJEATg2gBwDY8vHw8eB48cBeCc/4z3aAAOgHAN0L8BDYuHgLIQCAmAgi/8ogQgMB5fEN +9JAghoDhyiAhAAQNoQLKIQEAlQHP+OB48cDhxc91gADgBhCFn+jWDIAHguDwDKEHyiAhAAHYEKVO +CC/7Edg+CGAAENgRpQnoPggv+xDYEgxgAYogBADPcAAAmOLiDW//gNlNAc/44HjxwNIIz/jPdoAA +4AbPdYAAYCgDhvAlABBAeH3oIQHP+PHAz3GAAIAoAIETCIEPAIAAAHoNj/zRwOB+AIEhCIEPAEAA +AM9wgAAkICSAIIGWCe//iiBMDH4Mj/zv8e3x4HgB2s9xgAD8J0OpGKEocGTZddoe290DIAYYu+B4 +8cDPcYAA4AYDoc4IL/sR2KYLYAGKIAgA0cDgfvHAOgjv+AHaocHPcYAA+CdAoVsIUQDPdYAAtK0a +hYwgw48K8gDahCgICQAhgX+AAPSrQKnPdoAA4AYMhgbojg/v/wuGANgMpv/YGqVKDCAHi3AN6HYK +wAMAwc9wgAD0JyCgfgpgBwDYEfAeD+/6EdhaCsAD6gpgAYogCAB+C4AHguCcC6EHyiAhAB0A7/ih +wPHAz3AAACBOJgsACc9xgAB8KAChz3EAALgLz3CAAOgnIKDPcAAAiBMGCwAJz3GAAOwnAKHPcA8A +QEL2CgAJz3GAAPAnAKEF2OYKIAkLuM9xgACALACh0cDgfuB44cXhxkEtAFTBuBcIFQEzJgBwgABM +YEAngXIUeQB5ANgX8M9xgADcypgRgABAKAIGhiD9D1IgwAFFuEV4z3KgAIgkEKIfgbO4H6FK8AHY +ENvPcaAAyBxpoc9zgADcypgTjQAA2s92gACsbMaGQC0BFoYl/R9SJc0RxXlFvaV5z3WgAIgkMKU/ +gwLdRCg+DQAhgH+AAAjVlbk/o89xoADwF72hpICKEwMBpqGjgBTjpqGigFMjw4CmoaGApqHAICEI +wCAiDGCAc6FsaGCDc6H4EAOCc6H8EACAE6FKocHG4H/BxeB48cDhxaHBCHXPcNS6/spAwATwJg8g +CQHYz3GfALj/uqEE2Buhi3AeoQDanbrPcKAA0BtRoM9wAG0AEBmhBPAyCa//MNj7CV7HiiCbBS4P +r/+pcYogmwUmD6//AMEAwLcIgI/Uuv7KeQav+KHAANvPcp8AuP8aonuiPqLPcABsBAAZouB+8cDm +Da/4mHAodhoIIABIdQYggQOIcE4IIACleTUGj/jPcYAAnCxgic9ynwC4/wbrz3HQuv7KPqIaog7r +z3CgADguBYAEIIAPwAAAAPEIgI/AAAAAatgYuBmiHILgfuB44cXPcoAAnCygis9ynwC4/wXtz3PQ +uv7KfqIaojuiDu3PcKAAOC4FgAQggA/AAAAA8QiAj8AAAABp2Bi4GaLgf8HF4Hjhxc91oP7oAwDa +z3OfALj/tqOA4cokTXDoIC0D8CCBADaj4HjgeOB44HjgeOB4AeLgf8HF8cAKDY/4CHfPcqD+uATP +cJ8AuP9WoCcJdAAA3Sh2Lg/v/xUnQBPgeOB44HjgeOB44HhhvusOdZAB5TkFj/jgePHAygyP+Ah3 +z3Kg/oAEz3CfALj/VqAnCXQAAN0odu4O7//wJ0AT4HjgeOB44HjgeOB4Yb7rDnWQAeX5BI/44Hjh +xc91oP4gBADaz3OfALj/tqOA4cokTXDoIC0D8CCBACCB4HjgeOB44HjgeOB4AeLgf8HF8cBWDK/4 +iiAKBut1Xg2v/4ohRA+KIAoGUg2v/6lxz3aAAHAbAIY3CF8Az3WAABggAIVSIIAAAKUI8M9woACo +IA2A5OAYAQUATg7v/1TYABUEEIYg/w7nCAGBiiAKBg4Nr/+KIUUDz3eAAHwpmBcAln0IngCmCQ// +z3WAAIAhyRUAFqW4yR0YEJMXAJaluJMfGJDXFQAWpbjXHRgQDoWluA6lAIXIEAAGhiB/jsogIgDK +IQIA2Awi+coiogEBhcgQAAaGIH+OyiBiAMohIgDADCL5yiKiAQCFz3GAAODIxBAABiW4wLj2DK/8 +CqGKIAoGegyv/4ohRQlODA/+f9gKuM9xoADQGxOhf9gQoQDYlbgQoc9xAABYICoKIAAG2M9xoADw +NgSBRiDAAQShlNiqDe//GNmKIAoGMgyv/yCGAIZRIECAWAoiAcogIgCKIAoGGgyv/4ohBgBlA4/4 +CiHAD+ty29gEuIojBQJdB6/5SiUAAOB48cDmCq/4iiBKBu4Lr/+KIYYCwgjgBwHYz3ClAAgMAN3P +doAAzCeioASGUSCAgHwOgvnPcQAAOAqWCSAABtgLyAUggA8BAAD8CxoYMASGIwieAM9wgACcOQCA +i+j6CG//iiDGCAsIUQDuDQAFDPAA2Z65z3CgAPxEIaDgeKGgpgkgBgDYhgyP/FIKAAEaDeAGAdii +Ce/6Adi5Ao/48cBGCo/4iHUA3wroGQhRAAHez3CAAGgYwKgG8M9wgABoGOCoCekbCVEAAdnPcIAA +ZRggqAXwz3CAAGUY4KgK6hkKUQAB2c9wgABnGCCoBvDPcIAAZxjgqM92oADIH89wgABoGBge2JMA +iIohEAAR6M9wgAC9IACIC+jPcAMAQA1FHhgQMKYC2BgeGJAC8DGmz3CAAGUYAIgb6M9wgAC+IACI +F+jPcAIA8B0gHhiQz3CAACgAIR4YkM9wgAD8BSIeGJAYFgCWRSAAAxgeGJDPcIAAZxgAiAjoGBYA +loUgAQQYHhiQDwtRABgWAJaIuBgeGJAYFgCWgLgYHhiQGO0A2JS4z3WAAAAJAKVx2Aa4ugvv//zZ +IIXPcAAATByqC+//n7kYFgCWhbgYHhiQgQGP+PHAmHAD6SMMEgjPcIAAhAYAEAUACiHAD+tyz3AA +ANoOZQWv+Xnbz3CAAKQsFSAAASCg0cDgfuB4ANlKJIBxz3OAAMCVKHKoIMAB8COAAAHiBXngfy8o +QQDhxQDaSiSAcc91gADAlUhzqCCAAfAlwRAB4yV6ANmeuRl5BCGAAEIgAIDKIGIA4H/BxeB48cCK +IMkDmgmv/4ohzAfPcaAAyB+kEQIAz3CAAHA1AIA1gc9zgABYoJYgQQ8QcgDayiJvAAGD1bmB4AHY +AvIAgw0IUQANCYQPAACIEwDYA/AB2IHizCBigIAPofrKIOEB0cDgfgLhMHlBaQ0KAwAieBB4A/AC +2M9xoADIHx6hENgOoQHYFRkYgOB+4HjxwOHFUN0A2s9zoADIH6+jXqMCIEIAXqMB2hUbmIBA2k6j +BCC+zwACABCwD8H/SQCP+OB4ANnPcIAAeK8hoM9wgADcyhyQYrhIIEAAEHnPcqAAyB8fghB4CCEB +ADB5AtgVGhiAP6LgfgLhMHlBaQ0KAwAieBB4A/AC2M9xoADIHx+hiiAYCA6hAtgVGRiA4H4A2c9w +gAB4ryCgIaDgfyKg4cXhxs9xgAD43kWBJOjPcaAAyB9AEQ4Gz3OAANzKQCiNAkITAAF8k9B+2GC7 +Y2K7CCMDAAJ7CSLCAALYFRkYgM9wgACAIV+hA4AigM9wgAB4ryKgwcbgf8HF4HjgfwDY4cT8HMi+ +/BxIvuHA4cHhwuHD/BwIsfwcSLH8HIix/BzIsfwcCLL8HEiy/ByIsvwcyLLhxeHG4cf8HAi0/BxI +tPwciLT8HMi0/BwIv2okgBDhxGokwBDhxPHAz3WgAMgfGRUSlnvYrg9v/4ohBAPPdp8AuP/9hgoh +wCdA2Z+5PabPcaD+HAA2plMmwDQFIIAPsP4AABamz3AAAEQcogjv/wogwC96cBkVAJYjCB4CWB6A +FyEVAJYiFQCWz3GAAPgIAIEWpgGBFqb9pgfYcgjv/wq4UyBBBwfYpgjv/wq4z3CgANQLGIBCIAAI +SCAAAM91gADsOrwdGBDPcIAAAAkAgAsgwITKJiITyiBiAF/0gwqRIG/YKgjv/wa4z3AAANAbHgjP +/89wAADUGxYIz//PcAAA2BsKCM//B9gGCO//CrjPcAAABBz6D4//z3AAAAgc7g+P/89wAAAMHOYP +j//PcAAAEBzaD4//z3AAAEQc0g+P/xsLniW8FQAWiehBK04lwL4DvlzmAdgh8DTeHvCMIgSgGfJM +IgCiEfII9hsKUCAnChEhht4S8BcKECSMIgGgC/RM3grwZt4I8DzeBvBG3gTwVN4C8ITeANiB4JgJ +wQSTFQMWyXAKcSpyCiSABJEBr/kKJcAE4HjgfuB44H8B2M9ygADgBiKCJYkS6c9xgAC0rXqBz3GA +APCrhCsICTAhQQ4NCV8ACNgLogHYCaIA2ASiBdgDouB+8cDhxQh1KHAF689xgAAAjATwz3GAAAB0 +W3qCDW/4tHktBW/4AdjgeM9wgADaBgCQBugA2c9wpAAcQDKg4H7geM9wgADaBgCQBugD2c9wpAAc +QDKg4H7geOB+4HjPcQEAxwPPcKAA7CcmoOB+8cBmDE/4GnCiDq//JNiYcFEgAIDKIcEPyiLBB8og +gQ8AAFEmyiOBDwAAKQGsAKH5yiUBBM9xoACsLxiBkQgRIA8IngbPcIAAMC0AgEB49NgA2ToOr/8B +2jTYANmRuS4Or/8A2jDYiiEGACIOr/8A2jTYANkD2hYOr/8Uui4Or/8w2MK4CQhRAADYCPAE3T/Y +7gxv/6lxqXDPcgEAxgPPcaAA7CdGoc9zoAC0DzyDJOkBEgQ2cBMFAAohwA/rcs9wAABSJhUAr/mK +I0UGmrgYoWoM4AiKIA8Kz3CAADAtAIBAeFoM4AgB2PYJL/+KIAUDhOgE2NUDT/hE2c9woADIHCmg +OgzgCAHY6gyAAb7x4HjxwFYLT/iiwSh2CiSAgADfz3WgACwgQBUQEAAcxDMT8oMMUABMJICAjvIK +IcAP63LPcAAAVCaKI0QFkQdv+QolAAQyaAQhgQ8AAPz/jg2v/yzYEIUCIAAEjCAPigj3Pg2v/yzY +CHfvCB6ACPAghoC5IKb+C2//P9giDa//NNgfCF4FIIaBuSCm5gtv/z/YNNgA2QDa5gyv/5W6ML8C +HMQzhfAPeRC5BSGCDwAAgv3PcaAA7CdGoQQggA8AAAAfSLiGuBC4BSCADwAAQv0GoRCFAiAABIwg +D4oL94txQglv+YogDw0AFAAx5wgegAfwIIaAuSCmegtv/z/YgcEiCW/5iiBPDAQUADERCJ4AIIaB +uSCmXgtv/z/Yi3WKII8PAglv+alxIMAIuAIcBDCKIM8P7ghv+alxIMECFAAxJXgCHAQwNfDPcQMA +Qv7Pd6AA7Ccmp89xBAAC/ianhrgQeBC4BSCADwAAQv0GpxCFAiAABIwgD4oL94txpghv+YogTw8A +FAAx5wgegQfwIIaAuSCm3gpv/z/Yz3AGAAL/BqdAJIEwfghv+Yogzw5A2MIKb/8CFAExAhQAMQEC +b/iiwOB44H7geOB+4HjxwOHFCHWKIBQNngpv/6lxANjPcacAiEmB5cog4QAOoekBT/jxwHIJT/jP +dYAAbC2gjQDewKOb7YHgzCEhgBfyCwoTCMCjANgJ8MDiBtgG9kIiAAhDuALgAKNQeRC5EH2KIJQN +Qgpv/6V5mQFP+OB4uHBA3AAhAIPxwA4AJACYcYwgAoCL9gohwA/rcs9wAADJFHEFb/mKI8gPz3CA +AJxj9CAAAc9xgACcZAQofgEvcPUhAQFCKAMEwbtSuAQpfgEvcUIpAgTBulK5gePAIGkAgeLAIWkA +iCA+AIkgwQ+IIT4AiSHBD4Dg1iArCIDh1iErCLYJAADRwOB+4HjxwIYIT/ihwTpxAN+A4MohwQ/K +IsEHyiCBDwAAyhTKI4EPAADTAsokwQDcBGH5yiXBA89xgABwLUCxz3GAAHIt4LFMIQCgyiXOE2QA +LgDKJs4TGndadwXwyXcadWpwQCBTAItxAdpeC+//ANsAFA0xLyPIJKl2Kb3Ivr/l2SUpFEwiAKDK +IMIDyiGCA8oiAgTMDSIAyiNCA8lw3g7v/6lxQiFRILUJdaBAIlIgyXBiCSAAqXEpAG/4ocDgePHA +yg8P+Hpwz3CAAGwtAIgacdcIEQDPcYAAoAeliQSJHWVydcohzA/KIswHyiCMDwAAyxTKI4wPAAA4 +A8okzAQIBGz5yiVMAwDdAN4o8ADZz3CAAG0tIKhKcIrZ6g7v/ypyz3CAAG0tAIhTJcEQGLnDuBy4 +BXnPeBC4BXmKIFQNbghv/+V5LyGIBBC5iiBUDV4Ib/8FIUEEAebPfgAggS+AAKAHJokBaTcOAxBA +K4IgVHq1etR6z3OAAASyV2MSbWzvQCeSEC8iiCTUeM9ygAD4sTQiEQB7CRGAAdm68QHlr31rDdKQ +PQcP+OB48cDuDg/4z3OAAHItQJNTIk2AIPJHDZEQz3WAAKAHCa0orSKFz3aAAHAtAJYp3RK9z3eA +AG0tFSUMECCk4I8H71YgDwjwf/V9IKUB4AC2B/DPdYAAoAcLrSqtAeL5Bi/4QLPgePHAhg4P+Ah2 +GnHPdYAAci3glQvwzH8yCG/4QClAcUW4Sg3v/wpxIJWMIRCAtPa9Bg/44HjxwEYOD/gIds9wgABs +LQCIenGA4KHBGnKC9M9xgACgB6WJBIkdZXJ1yiHMD8oizAfKIIwPAADMFMojjA8AAIUDyiTMBIAC +bPnKJUwDAN8A3R/wARSAMAEeEhAGEYEgARSAMITpAR4SECDAAxSCMAEUgTAYuBS6BXoCFIAwELgF +eooglA3mDi//RXkB5a99z3GAAKAHACEABAaIAeB5DSMQACERBEArgCAUePV4tHjPcYAABLI0IRIA +UyfAEBi4r3kQuQV5iiCUDaIOL/8FIYEEANkzChAgi3FKcALapgjv/wDbcwgRgAohwA/rcs9wAADN +FIojjgYKJIAEzQFv+UolgAABHlIQBhGAIIMIEYABHlIQvfEB5+9/Nw/SkIEFL/ihwOB4ANtgqREI +cgBgqg0I0wNgqeB/YKoPCJIIwOAF9gHYAKkR8OTghvaMIAKDyiCsAMn2jCBChIn2jCBCiQf2A9gA +qQHY4H8AquB+8cDeDA/4o8FKIQAgi3EqcEogACEKcgII7/8qc47oCiHAD+tyU9gGuIojBQEKJEAE +KQFv+QolAAQgwhUKEgAAwEEoAQJTIcQAEwwSAQHZz3CAAGwtVQIgACCoz3GAAKAHQKkCGQIBQSgO +A1MmxRADGUIBTCXAgMoiyQfKIIkPAADCFMojiQ8AAFgB0ABp+cohyQ9BKAIEUyLGAAQZggFBKAIF +UyLFAAUZQgFMJkCAzCXsgMohyQ/KIskHyiCJDwAAwxTKI4kPAABeAZAAafnKJIkBQSgCBlMixAAG +GQIBQSgFBwcZQgFMJECAzCVsgMoiyQfKIIkPAADEFMojiQ8AAGQBWABp+cohyQ8EFIUwjCUBhLQA +LAABGUIBCiHAD+tyz3AAAMUUiiNFCjEAb/mYc891gAAEsgDfA/AB5+9/QSgBAsO5bQ9DEADeE/BA +KYEgNHkKFIAwFSFBAQHmz34UeblhABkEBIAgAiMvIAgkAMBBKAEGw7kB4cMOQ5CCwQpwAtqWDq// +ANsLFIQwLygBAU4ghQcvJUcBtQ3SgAohwA/rcs9wAADGFLEHL/mKI0YCQCFRIC8hRyRBKAEEw7l7 +CUKgBPBtDlOAQSgBBcO5CnWpCXIASiAAIEoiACAF8EAiUiAvIockQSgBA8O5ewpDIEohACAU8AK+ +1H4KFIAwFSZOEUAhUSAvIUckFH4AJoAfgAAEsqCwgCUCE7B9AMBBKAEHAeG7CUOgMLjDuAAgDgSC +walwAtriDa//ANsLFIQwLygBAU4ghQcvJUcBqw3ygM9+CiHAD+tyz3AAAMcU/QYv+YojhghAIFAg +LyAHJEEoAQXDuWUIQqDT2Qi5ANgD3s9ygAD4sQDbsmh0fV1lILUB4297ViEBCPELsoAweWG+AeDn +DnWQD3iRAi/4o8DgePHAGgoP+KLBQMBBwkAoFAVAKRcFAN1AKhMFQCsSBQHeSiWAIal3BPAKdcp3 +AMAVuBN4FCDABcILL/gH2QIgUAMCIEAjsgsv+A7ZzH4KIUAuBCk+cC9wrH4AIQ11HWUBwBW4E3gU +IIAEjgsv+AfZAiDWAwImwCOCCy/4DtkEKH4EL3HsfgAhwHQZYUItABWOCO//VLlCJVUgAeaRDXWg +z37BAS/4osDgePHAdgkP+Ah2unHPcIAA3MoAkADZSiNAIEoiQCCGIPwAjCACgMIjwiRKIIAgz3CA +AAijK6iacc9woADQDyUQD4YlEA2GYr4QEBGGKw5kE0AkVCCifhJ2yiAuIB4Ob/jpcJhwANgpCxAg +FQ9QEQ0P0BIH8EomACAx8AHYA/AC2M9xgABwGCSBCyEAgATyANoD8AHaACBAI9YLb/kqcQomAKAb +8icMEALPcIAAdCAWIAABQIAGiD0PARAc6qlwYHqqcQoiAKAJ8iJ1z3CgANAPEBhYg2cIEaDPcaD+ +YALPcp8AuP9MJgCgzCIioBLyANgT8AohwA/rcs9wAAAxEYojFwtKJAAA/QQv+QolAAEocBaiE9g4 +4TaiEL4FJgEVNqKlAA/44HjxwOHFz3CAAEAvCBAEAEwkAIDKIcEPyiLBB8oggQ8AAGkZyiOBDwAA +0AG0BCH5yiUBAc9ypQAIDAgSBQAA2UwlAIDMJSKEyiHCD8oiwgfKIIIPAAB9Gcojgg8AANcBgAQi ++cokIgBA2AKiz3CAAFS7YIAK8PQgTQDPcKYAAIA1eAHhoKDS4YQrAgoAJEAOtPekEAMBz3GkAKA/ +faGmEAABHqEIGkABQQAP+OB48cCCJAMyi3DPcYAAwGB6CC/4yNpKJEB2ANmoIEADFiRAMGGAQJAr +2BK4AeFVeGCgMHmAJAMy0cDgfuB48cDWDCAAR9gA2s9xqwCg/1mhB9gaoVih0cDgfuB+4HjgfuB4 +8cDPcYAAQC84gYDhXAwCANHA4H7xwM9xgABALz2BgOHQDQIA0cDgfh0GwAcZBsAHFQbABwDZz3CA +AFS7IaC5AyACIqDxwOHFz3WAAFS7Ag0gAqlwuHAAhRLoSiSAc89zgABULQDZqCDAAkCDRCm+AzIi +Qg4/CkABAeER8ADZSiSAec9ygACsaaggQAJEKb4DMiJDDh8LQAEB4QohwA/rcs9wAACGGYojRAEp +Ay/5SiQAACkH7/cocM9wgABUu0CAI4AM6s9wgABULQCARCm+Aw3gMiBADgnwz3CAALlpRCm+AzIg +QA7gfs9wAAABP89xqgDwQwWhz3AAAD49BqHPcgAAPT1HoYogzA8IoQnYjLgJoc9wAAAWHAqhz3AA +AB8fC6HPcAAAHBYMoZHYBLgNoc9wAAADPw6hT6HPcAAAPT4QoYogxA8RoeB+4HjxwBIOz/fKCWAC +AN1aCyAAB9hGDu//GnDPdqQAuD2sFgAWz3elANjLOdmiuKweGBCsp89wFQArK/YeWBOaHhgQiiDE +AJ8eGBAa2PMeGBD0HhgQZNjIHhgQqtjJHhgQadjMHhgQwNjNHhgQz3ClAAgMPqAuD8//HgogAApw +GNiVHhgQz3GAANwfoaHI2AKhAKEDoc9xAQBUx89wgADsGdQYQACU2AunQdnPcKUAzH8toM9wpAAM +gKKgvQXP9/HAGggAAEIPz/8ODAAAWgiP+tHA4H7gePHANg3P989wgAAAyEAgEgYIcc9wgACsBiCg +AN7EqATfRC4+FwohQC4AIYB/gAAAyJoIb/kc2YQuChIAIY1/gABwu6lwhghv+YohCgKELgIXACGA +f4AAkMUacHIIb/mc2QAhkSQAGUAjYb+hHRgUtQ91kAHmHQXP9/HAugzP9wh3WnE6chpzCiMAIYom +GxjJcMYN7/7pcUQvPhcAIY1/gAAAyMlwsg3v/iGNyXCqDe/+II3JcKIN7/4ijclwmg3v/iON8K0B +2BGtAR2CFAAdQhQCHQIUAx3CFBIdAhQTHcIUXgkgAOlwpQTP9+B48cBODO/3RCg+BxpwOnHPcYAA +AMgvcBphUYobYR8KUAAKIcAP63LPcAAAsihe24okww+VAC/5CiUABBUI0CDPcoAArAYEGgIEOGAA +ogGLIItSi+IJIABzixoJQAEKcFILIAAqcUkEz/fxwOHFCHUqC2AFANiSDs/7RNnPcKAAyBwpoL4I +L/gc2M9woACsLxiAFQifBoogEQPSDO/+S9l+CiACqXD/2c9wqwCg/zmgOKAmDCABqXAZBM/34Hjx +wOHFEgzv/wh1Ug9gAqlwAQTP989xoADIHAihZQAv+AbY4HjxwHYLz/eiwaKBYJDPdoAAQAe4e6OB +ZH1ghqV7poEBkLh4p4FgpqR4oYZAIQ8EpXgBph3qAYECHMQwMLsEHMQwABwEMCCBi3VgealwAYch +hgIcRDAwuQQcRDAghwAcBDBgealwANgApgGmdQPv96LA4H7geOB+4HjgfuB44H7gePHA4cXPcIAA +TC0ggAHdYHmpcOe4J7hSIAAAyiUiEMohQgPKIeEBwLgTeMK4z3KnABRIC6Isos9wqgDgB7OgMQPP +9+B48cDhxc9xoADIHKiBCKGOD+/3BtgVA+/3qXDgePHAmgrP9wh2z3WAAFS7AKUhpVitZgvv/3mt +1gvv/wOlBKUG8HoNr/6KIIkMz3CgAHhFAIAEIIAPcAAAAEEoPoUA3fL1kglgBalwz3GrAKD/uaEH +2BqhuKGaCEACgOYB2MB4DOBeCy/6AdmdAs/34HjxwBoKz/cId891gABUuxiNSHYacTpzEwoBAIXu +GY0LCEEEANgC8AHYLyIHIOlwzg0gAslxIIUA2A8PQRAhhRJxzCIhoALyAdgvJgfwGq0r8oogWwjm +Cu/+6XGKIFsI3grv/gpxiiBbCNIK7/7JcYogWwjKCu/+KnHpcApxyXIWD+//KnNyCMACAYXPcYAA +2AYAsQCFAbEYjQSpvg+gAipwCPCA5wHYwHgM4KoKL/oB2cUBz/fxwAhzANkC2oQrCgIAIYB/gABw +u4QpBA8E4HYKYAUncGG66Qp1gAHh0cDgfvHAz3CAABjhxgwv+YohCQzPcIAAoCS6DC/5FNnPcIAA +xCeuDC/5FNnRwOB+8cAGCc/3osE6cBpxAN1eDu//B9iacALZqXBacHpxANs0aAJxKHUUIQAgaHLC +hQQQDwXYf8OFAeLEf+V78Qr0gCDlAYECHMQwMLsAHAQwIIEEHMQwYHmLcEIjQSC/CXWAQCJAIDIN +7/+KcPEA7/eiwPHAngjP9zpwWnHPd4AANDoMj892gABUu6WGhiD/AUO4DiUNkM9wgAA8LSCAyiVi +EGB5BNgg6BqOgODMJSGQHPIA2BDdGnACuBV4x3CAAMQuIIAG6SKAFelgeSpwYb3pDXWQQCBAIADY +Gq4Mj4Yg/wFDuAWmkg0v+EpwgQDP9wohwA/rcs9wAABlGTfbCiQABIkE7/i4c+B48cDhxQh1IJAC +lUGVELgFeinYErgVIEEAQKEglfAgQQAdCkAAAgnv/oog0QMClSGVELgFefII7/6KINEDTQDP9/HA +4cXPdYAAcMgghRvp2gjv/oogSgwAhQfoz3GAAJzIAKEIhQihANgApQSl9g7v+QnY8g7v+QPYz3CA +AORYngxABs9wgADoMfYI4AADgIogCgOWCO/+iiEPAgDZz3CAAKg16Qev9y+okQLP+fHA4cWKIMkD +cgjv/oohDgeyCOACAN3PcIAArFhSDEAGz3CAAMhYSgxABs9wgADkWD4MQAaKIMoBQgjv/oohzgjP +cIAA6DGioG4O7/kD2M9wgABwNaOgiQev96Gg8cDhxc9xoACsLxyBvYEEfc9wgAC8IACIEwhRAM9w +wN8BAByhKNkYuRvwiiDJA/IPr/6KIU8JiiCJA+YPr/6pcRUNHheKIIoF1g+v/oohDwviCcAC9r3w +D8L5ANmbuc9woADQGzGgHQeP9+B48cAiCAAAjglAANHA4H7geM9wgADoMQCAgeAB2OB/wHjxwIIO +j/fPcIAA4MjHgMC+geYB3s9xgABUNwCBwH5bCF8AgbgAoc91oADALxOFDQieBhOFurgTpQLYEaXP +cIAAPC0ggGB5ANgZCBECAg8gCArYC/DPcKAAqCANgOTgj/cQhfUIHoCCCu//yXAVFQCWgLgVHRiQ +eQaP91wVBBBAFQUQCiHAD+tyiiBMCWEC7/iKI4YN8cDeDY/3CHXPdqAAwC8ahjm4UiAAAFMgEQAU +hhEI3wAKCC//JNjyuADfA/IB31EWAJaL6KMWAJYEIIAPAAAAD4wgEIAD9ADYAvAB2BpwBCGSTwAE +AADPcAAACBzOD8/+P7hSIAMABCCATwIAAADXcAIAAAAB2sB6DHCGID0AgOAB2cB5EwieQc9wgADU +BwCAgeAA2AL0AdgB3uW9yiGBI0MJECDmvconYRAd7+O9yiJhIDMKECDkvcojYQAT6+K9yiBhIB8I +ECDhvcoiYQAL6uC9yiFhAAfpUSXAkcogYQCD6ADYAvAB2FEFr/cPeOB48cD+DI/3p8EIds9wgACw +YSCAAYBFwUbAiiDKAfINr/4taM9wgADoMQKARMYM2RUkAjDPcKAALCCwgM9wAQBIJEDAAdhBwELA +ENhDwEWCANgIc5hwuHAAJYcfAAAAfYoKL/3YcAUFr/enwOB48cCiDg/+z3KgAMAvANmIGkAAE4KL +uBOiz3CAAGAXAZAQuEUgAA/AGgAAz3CAAPw0hg+v+SCg0cDgfuB48cBWDK/3ANmbuc9woADQGzGg +HgjgAADeJejPcIAAOBYxgM91gAAEIAzpz3CfALj/PaAkhQHhs7m1ubi5JKU2oM9wgADUByCAz3CA +ACg18CBAAEB4AIUPCF4Ez3CfALj/3aBhBI/34HjxwOYLr/dU2Rpwz3aAAODIp4bAvYHlAd3AfeYM +r/6KIMkDiiBJB9oMr/4Kcc9wgACAIQCAxBAABjkIXgHPcIAAYBcBkM9xgADYB+CBPOAZZ2ThIQkE +BAohwA/rch9niiDMCFrbCiQABPEHr/hVJ0UWB4YA3x8I0QDPcIAAYBchkM9wgADYBwCAPOE4YGTg +AiAQIAvIBCCAD/7//wMLGhgwC8iHuAsaGDBWD6//qXDPcZ8AuP9dgc9wgACIBkCg/aEc2Rfwz3Cg +AMg7NoBWgIYh/wiGIv8IRXlWgIYi/whFec9yoACoIE2C5OJKAAUA7OneDoAAz3agAMAvURYAlobo +DHSEJMKfJPIXhkUIXwbPcIAAcBsAgDkIXwAKIcAP63IKJAAIURYFloogTAgtB6/4f9s4EAQAWBAF +AAohwA/rcs9wAACZIRUHr/gv21ENURCKIMkDqguv/ofZEIY1CB8Az3WAAEQtIIVgeQHYDwhRASCF +YHkC2B0IkABAFgQQCiHAD+tyiiCMCI3b0Qav+LhziiAQARGmEIb/CB+AFIaruBSmz3CAAHAbAICC +4BLYwCgiBsogIQDPIGEGGabPcaAAyB8YEQCGobgYGRiAiiAQABGhCdgIuA+hE4apuBOmz3CAAODI +B4CD4Mwg4oEG9EAogCCfuIgeABDWCUAGz3CAAFQ3SQKv9+Cg8cANCVEAQg0AAATw/gwAANHA4H7x +wK4NoADhxUoK7/ka2M9wgAAANQCQz3KAAMjIUiABAMC5AeEgqgDZFwhfAM91gABwNWqFCwtQAGuF +geMC9AHZI6pBKIECwLk0qim4wLjPcYAA6DHxAa/3AKHgePHAbgmv94ogiQrPdqAAwC+3hvqGiBYQ +EG4Kr/7o2YogiQpmCq/+qXGKIIkKWgqv/ulxiiCJClIKr/4KcTCGSgqv/oogiQozhj4Kr/6KIIkK +B9jPd6AAyB8ZHxiQAdgIcQhyCHPKDu/+mHBKC+/+VNgVCB8Bz3CAAIgGIIDPcJ8AuP89oIAWDRAi +vWIPIAapcIogiQryCa/+qXHPcYAAYDwSgbhgEqEA2IgeABAJ2Ai4DqchAY/34HjxwL4Ir/cA2c91 +nwC4/12Fz3aAAIgGQKY9pRzZFfDPc6AAyDs2g0QhAgc2g4Yh/wglejaDhiH/CEV5z3KgAKggTYLk +4of37emKCs//kOgA2C3wOBMEAFgTBQAKIcAP63LPcAAAmSHFBK/4L9sAhh2lOg6gBgDYiiAJBVYJ +r/6KIUwGz3GAANQHIIGKIEwGDgigAAPakgmgAAPYBg9P/AjYSg0gAIoh/w8B2IEAj/fgePHAz3CA +ANQHAIATCNEAFgnP/F4Jz//eCEAA0cDgfuB48cDiD2/3ltkacPYIr/6KIAoDAN0KIYAvgACgNQXf +z3aAAAA1tX4DhhUhTCMApBUIUSCKIAoDygiv/pzZAdgDpmG/AeXbD3WQr30B2c9wgABwNfEHb/dE +GEIA4HjPcIAAcMgB2SSoJajPcYAAADUAkYYgGACouACx2tgDqc9wAABQwwGhz3ABAKCG2QdgAAKh +8cDhxc91gACoNQ6NocF9CFEAiiAKA1oIr/7J2S+NLwkzAYogCgNKCK/+zdkPjYroiiAKAzoIr/7R +2ToP7/8B2A+NAeAPeA+tIPAmCK/+2tkA2A2tDq0+CCAAD61yD8//ANgCCu//jLjPcK0LvrpAwItw +BNl92j3bZgrgBBe7iiAKA+4Pb/7x2UkHb/ehwOB48cDhxYogCgPWD2/+r9nPcoAAcDVEEoAAQCID +DCcIUQBKJEBxANmoIAAD8CNNAM9wgAAMNTV4AeGgoC95ANhEGgIAAQdP9+B4ANrPcYAAqDVPqQHY +DalOqUypUKlRqVKpU6lUqYogCgN1B2/+h9ngePHAWg5v9wHaz3GAAIAhY4F4izkLEQEAgc9xgADo +McQQAAYluFIgAAAhgcC4AdqA4c9xgAD43iaBwHqA4cwgIYDMIiKAfPKA8BEIHgDPcIAAyMgAiAkI +UQCYcgTwSiQAAM9woAAsIHCAz3aAAHA1RYamhgIjgIAA2soibwACI0+DAN3KJW8QFw4FcABAAAAH +6gIjgA9OAAEgBaYXDsVzAEAAAAftAiOAD04AASAGpgGGFujPd4AAADUAhuGHH2cRDwUQGQ/FEBEL +BAAI8AkLBAAJD8UQANgD8AHYAaYggcQRAwZBK0EBUSEAgMomYRAG8imGg+FvJgsQz3GAAOgxIYHP +d4AA+N7mh4DhAdnAeYDgAdjAeIYnfx6G59EjYoEA2wL0AduA5cwiIoDMIyKAzCAigMwhIoDMJiKQ +BPQA2AXw/QwQgAHYfQVP9+B48cCKINAHHg5v/oohRgAuCIACz3CAAMwnBIBRIICACA3C/QnZCLnP +cKAAsB80oNHA4H7gePHA4cUIdYogyQPmDW/+iiHFBYogiQPaDW/+qXHPcYAA6DEBgaZ4AaEA2c9w +gADgyDCgJYAdBW/3MaDgePHAogxP96HBCHaKIIkHpg1v/slxz3GAANQHiiCJB5YNb/4ggc91gADo +MQGFz3GAAODIBX4QgcGlhegB2BChBYERoZ4Jr/2LcADBz3ABANwVGQhAAM9wAQBIJBEJAADPcAEA +HDMLCQEAtgjv/AHYAN7PcIAAcDXBoHYLr/kH2HILr/kI2HYNQALPcIAArFgaCQAGz3CAAMhYDgkA +Bs9wgACAIQCAxBAABhcIXgGKIEoCAg1v/hx5mg8gAMlwBPBODWAAA4VJBG/3ocDgePHA1gtv97hw +cg3v/yhwgOAA2cogQQAn8s92nwC4/x2Gz3WAAIgGAKU9phzZFfDPcKAAyDs2gFaAhiH/CIYi/whF +eVaAhiL/CEV5z3KgAKggTYLk4on37emSDa//qHAghT2m4QNP9zgQBABYEAUACiHAD+tyz3AAAJkh +yQdv+C/b8cDPcIAAmK4IgGkI3wHPcYAAADVCgSGBz3CAAFQ1QKDPcIAAcDUnoIogyQM6DG/+iiHF +D4ogyQQuDG/+iiFGAM9xgADUByCBiiBGAOYKYAAC2m4MYAAC2IogyQMKDG/+iiHGAFYKIAUC2DIL +T/kI8M9wgADoMUoMYAADgNHA4H7xwM4KT/cIdSh2iiBJB9oLb/6KIQYHPw3REM9wgABgFwGQz3KA +ANgHIII84BlhAYJk4ThgHwiEAwohwA/rcoogjQGKI8YHSiQAAPkGb/gKJQABiiBZBZILb/6KIUYI +z3CAAODIz3egACwgQBcQEA4OYACnoH4KQAbPcIAAJCAkgCCBZgtv/oogSQfPdaAArC88hVYLb/6K +IEkHiiBJB0oLb/7JcRoJb/wB2EIOr//JcAHY7gqgAApxHIUVCF8GGIWIuBil9g5v96DYCPDPcYAA +VDcAgYK4AKGKIEkHCgtv/oohxwB+CM//VgxAANCH1ghv/AHYUg4AAIogSQfqCm/+iiFHBp4K4Acy +2M9wAIIBABylrgxv+QImABQA2IIKoADJcYogGQXCCm/+iiGHCgUCT/fgePHA4cXPcYAAyMgAEYQA +IQxzAKXBAxGFABUNUAAKIcAP63KKIA0B6QVv+PHbSwyRAAOJo+gA2ACpiiDJCHYKb/742YogCQZu +Cm/++dnPcYAA1AcggfnYB90mCWAAqXKuCmAAqXDPcIAA6DHSCa//o6DGCY//cPDPcYAAcMgEiR0I +UQAFiRUIUQDPcAAA//9CDe//ANnBCBAAz3GAAIAhAIHEEAAGDQheAQOBGIgzCBEBiiDJCP4Jb/6K +IYQEiiDJBPIJb/6KIcQEz3GAANQHIIGKIMQEqghgAALaAtg68KYNQAB1CIQPAAAUBM9wgADoMQCA +DQhRAF4JT/ku6ADZz3CgACwgsIDPcAEA3BVAwAHYQcBCwEPBRMEG2QhyANuYc7hzACWHHwAAAH1i +Dq/82HOKIIkEfglv/oohBArPcYAA1AcggYogBAo2CGAAAdoB2LoJQADBAG/3pcDgeOB+4HjxwD4I +T/fPd6AALCDQh89wgABwNQiApcECJgIQz3CAAMjIz3OAAPjeZYMjgAUrfgA3cgHZQIjCIU4AAN0L +ClAAA4g3CFEAz3CAAOgxo6CKIMkDAglv/s7ZiiBJBPYIb/7P2c9xgADUByCBz9iyDyAAANoA2FLw +z3KAAIAhAILEEAAGnQheAZkJUQADghiIkQjRAM9wgADoMQGAhQgRAM9wgADYHwCQgeAB2MB4DLhx +CIAPAAAAEIogyQOaCG/+1dnwh89wAQBIJEDAAdhBwELFEdhDwADYjLhEwKlwDNkB2qlzmHW4dQAn +hx8AAAB9Pg2v/Nh1z3CAAHA1yKCKIEkGUghv/tjZz3GAANQHIIHY2A4PIAAI2gjYkghAAIkHL/el +wOB48cDhxQDZm7nPcKAA0BsxoIogSgEaCG/+iiEIDc9wgADMJwSAUSCAgIogSgEM9IohSA7+Dw/+ +z3CAAOgxSghgAAOAUPDqDy/+iiGID6IPD/+KIEoB2g8v/oohiQDPdYAAgCFNhT6VUyIAALIM4AMB +24ogSgG6Dy/+iiFJAwCFxBAABhsIXgEDhRiIEwgQAc9wgADgyAeAEQjeAIogSgGKIUkFyfGKIEoB +hg8v/oohyQaKIMkEeg8v/oohSQfPcYAA1AcggYogSQcyDiAAAtq6DyAAAtiKIEoBVg8v/oohiQex +Bg/38cA2Dg/3z3KgACwgMILPcIAAJCAEgM92gABwNQCAoIYCIUMD13MAAKAPAN/L989zgAD43qWD +1bhBLYMQYn0LCEQDAYaM6GOG4aYdC1EAiiAKAvoOL/6KIQoJPPBeDm/5B9g48M91gABwyACFF+gF +hRXoMIICeddxAABQwwHYwiAOACjoWg6P/wSF5aXjpqC4BKXSDi/5ANgc8AbrBoYCeTEJUgBTIIDB +BKYU9IogyQSaDi/+iiFLAs9xgADUByCBiiBLAlINIAAC2toOIAAC2M0FD/fxwGYNL/eKIP8PocEG +DSAAQMB7CFEAz3CAAIAhAIDEEAAGJQheAc9wgADYHwCQz3WAANQHgeAB2MB4DLgvCIAPAAAAEIog +SQQuDi/+iiFFB89xgADUByCBiiBFB+YMIAAA2m4OIAAA2FDwiiCJBQoOL/6KIUUIIIWKIEUIxgwg +AAXaTg4gAAXYQPDPdYAA/DQAhQDeFQhRAIogygraDS/+iiFFCsClMvDPccDfAQDPcKAArC88oM9w +AID//9YI7/8B2SToQgzgBItwCiUAkB7yiiDJA6INL/6KIcYAiiAJBZYNL/6KIcYBz3GAANQHIIGK +IMYBTgwgAAPa1g0gAAPYqXCSCe//AMHJBC/3ocDgePHAuHDPcIAA1AcAEAQAz3GAACwxQCyAABR4 +FSBAAQBhFQiRAgohwA/rcoogzQCVAG/4oNuKDQAA0cDgfuB+4HjxwOHFz3CAAIAhA4AYiB8IEQEK +IcAP63KKIE0BiiOEDUokAABdAG/4uHPOCEAACHXPcAAAv98OCO//ANkLCFEAjCUQlRz3iiAKC94M +L/6KIQUBQgiv/AHYiiBJBMoML/6KIUUCz3GAANQHIIGKIEUCggsgAADaCg0gAADYDQQP9+B+4Hjx +wJILD/fKCwAGiiBKAZYML/6KIYcNz3WAAHAbAIXPdqAArC8rCJAAGIYXCJ4GGoZSIAAACwgeAByG +FwgeB4ogSgFiDC/+iiEIAKoMT/8chjcIHgDPcIAArFgAgEIgAIDKIGIAkejPcoAAADUJghsIFQHP +cYAAgCEggcQRAQYLCV4BAeAJojyGGgwv/oogCQviDA/4JgjP/RkIUAAAhRUIkADPcIAA1AcAgIPg +yAvB/00DD/fxwN4KD/fPcIAA6DEAgC0IUADPdYAA1AcghYDhzCHigcwhIoII8oog0QAA3o4KIADJ +csCljgtP/BEDD/cKJACA8cAM8gohwA/rcoogTQKKI44N+QYv+LhzHgtP/y4O7/8C2M9wAQBIJEII +r/wB2dHA4H7gePHAagov9wbYrglP+c9wgACEGEokAAAAGAABz3CAAIAhA4AYiBcIEQEKIcAP63KK +IMwN6tuhBi/4uHPPcIAA7FYuD4AFz3CgACwg0IDPdYAAcDUghQImQBARDgJwAAAgTooKb/kH2MCl +z3CAAPjeBoBRIACAdApi+cogIgJSCeAEANhVAg/34HjxwN4JL/eKIMkD6gov/oohxAMeCW/5CNjP +doAA1AcAhofgzCAiglDyz3WAAHA1IYUG6c9xoAAsIDCBIKXPcYAA+N4mgYEJHgCE4MwgYoEj9M9x +gADoMQKBhugAgWkIUAADhTLoiiBKAooKL/6KIcQJiiDKAX4KL/6KIQQKANnPcIAAcMgpoCqgANhe +DG//jLga8IDgzCCigRb0A4UA3w3oz3CgACwgEIACpYogyQNGCi/+iiHEDIogyQM6Ci/+iiGEDeOl +IIaH4cwhIoJd8s91gABwNQGFhOgDhSroz3CAANgfAJCB4AHYwHgMuEEIgQ8AAAAQiiBKAvoJL/6K +IYUAjgzv/wHYz3CAAOgxAIB7CFEAA4WB4PQJIfnKIGEAA4WA4OgJIfnKIKEAL/CN6c9xgABwyAqB +CaEA2Aqhz3CgACwgEIAGoc9wgADYHwCQgeAB2MB4DLgzCIEPAAAAEM9wgADoMQGAkeiKIMkEhgkv +/oohhQYghooghQZGCCAAAtrKCSAAAtjBAA/34HjPcoAAcDUBggDZhegDgoDgAvIB2VMggMEEogHa +wiKBAADYgOHMIiGAAvIB2OB/D3jhxeHGz3WAAPgxwBUDFhML1Q/Sa9R+vmYApiGmQqYBa8W4wB0Y +EMHG4H/BxfHA4cWKIAoDAgkv/o3Zz3WAAKg1DY1VCFEAiiAKA+4IL/6Q2c9wgAAANQCQ6bjRIKKC +DvSKIAoD0ggv/pXZANgOrQ2t6giv/w+tEPCKIAoDuggv/p3ZAdgOrQ+NQiAAgK4Pb//KIGIABQAP +9/HAig/P9roNT//Pc4AAADUAk89ygADIyEEogQDAuSGqz3GAANgfIJGB4QHZwHkMuR8JgQ8AAAAQ +ooPPcYAAVDWgoaGDz3GAAHA1p6E28M9xgADoMaCBKQ1REM92gABwyCSODwlRACWOgeEB2QLyANmA +4cohgg8AABAnA/Qig892gABUNSCmKQ1REM91gABwyCSNDwlRACWNgeEB2QLyANmA4cohgg8AABAn +A/Qhg891gABwNSelqXHPdaAALCDQheWBAibNEwkN3xfFoeaBAibNEwkN3xfGoSiDhunPcYAA+N4o +kSOiJbjAuNIML/kD2QEHz/bxwOHFz3GAANQHABEEALhwz3KAAMA1QCyAABZ4FSBAAQBiFwhRAQoh +wA/rcoogjQDVAi/4dtsAGUABxQiQAEkIEQHPdYAAcMgghbUJEABeD+/9iiBKDACFB+jPcYAAnMgA +oQiFCKEA2AClBKV6DS/5Cdh2DS/5A9jPcIAA5FgiC4AFPvAjCFEATg1gBADYC8gEIIAP/v//Awsa +GDALyIe4CxoYMCzwz3CAAMwnBIAhCJ4Az3CAAJw5AICK6E4Mr/2Q2A0IUQBGCYADDvAA2p66ANnP +cKAA/ERBoOB4IaD6DGAEKHDPcIAAgCEDgBiIDQgRAQIKT/2E6DIIAAIRBs/28cCWDc/2z3agAMAv +OobPcoAAVDcAgpcIHwCAuACiz3CAAODIB4AB3cC4geDAfQ0JHgcQhgkIHwAA3wPwAd/vfy/tiiCJ +CmYO7/2KIcUFMIZaDu/9iiCJChCGIQifAkAWBBBMFgUQCiHAD+tyiiBMCZUBL/iKI4UGGw9REIog +EAERpuYNYAcK2DCGIg7v/YogiQqKIBAAEqbODWAHBdjPcIAAOC0ggGB5qXBVBc/24HjxwIogyQP2 +De/9iiEGBc9xgADoMUCBKQpRAM9zgABwyASLDwhRAAWLgeAB2ALyANiA4Moggg8AABAnBvTPcIAA +ADUCgM9zgABUNQCjJwpRAM9ygABwyASKDQhRAAWKgeAB2APyANiA4Moggg8AABAnBfTPcIAAADUB +gM9ygABwNQei0g3v/wOB0cDgfvHAz3AAAAgckg4v/qHBHwjeB89woAAsIBCABNl82j3bQMCLcLoP +IAQXu6HA0cDgfuB+4HjgfwHY4H7gePHA4cXPcQMAQA3PcKAAqCAtoM9xoADALxSB8LgUgQzyBCCA +DwgAAADXcAgAAAAB2MB4B/CGIH8PguAB2MB4wQgRABURAIaguBUZGIAR8M9woACoIA2A5ODPdaAA +rC+O9xyFkQhfBgx0hCTCn0L0yg0v/1rYbehE8IogiQO2DO/9iiHJCc9xoADUCzuBpgzv/YogiQMs +cZ4M7/2KIIkDOYWSDO/9iiCJA7YNL/4k2Ahxggzv/YogiQOmDS/+iiAJAwhxcgzv/YogiQPrdZIN +L/4k2Lhwz3CgANQLbBAEAIogjQoKIcAPqXKlB+/3iiOJC89xoADMKxKBgLgSoZkDz/bxwFoIIADh +xR4IIAAIdeYIIAAIc3B1yiNFAxBzeQPv9sogxQDxwOHFocEA3UDFRggv/YtwguCKIP8PDPLPcIAA +uFkDgCCAAMAieIDgyiBMA0UD7/ahwOB48cChwQDYQMDPcIAAyMghiItwJwlRAM9xoAAsIDCBz3KA +AHA1SIJCeQ8ORXBOAAAgIggP/QPwAggP/REIkQCKIP8PocDRwOB+z3CAANhZA4AggADAIniA4Mog +LADz8eB44cXPcYAAJCAkgSCBz3OAANhZQ4PVuaCCRoOKIP8PgOIF8gKConhIIAAACSBAAGq4SCAA +AOB/wcXPcYAA2FkLgUCADoGA4MoggQ//////CvICgEJ4SCAAAJkgBgBIIAAA4H7gePHA5gnP9qHB +GnDPcKAALCBAEBQAz3eAANzKP4cA3kQgFSPPdYAAcDVBKYAB2nGGJv4vTCUAokojQCDCI8IkUyAR +AEEoQSPAuRYlUhQEGkAgiiDZBcIK7/2KIcoCTCUAoswhIaAI9AGFBOjGCY/8BPCOCY/8z3CAAIAh +A4AYiA8IUQDPcYAAkNYU8D4Ij/086M9wgADIJAiIbQjRAZgXgBDPcYAAkNYCuBZ4AGFZCF4DmBeA +EEAh1QMCuBZ4OGA9CB4jIICIuSCgTgrv/YogiQOYF4EQAdoSaRZ4onBAqM9wgACAIQGAwBAABhEg +QIDMIaKDAA5CBwjwBg5gB8+ogOD0DUIHz3eAANQHAIe7CNABBBIAIIHgyiCBDwAAXAb4CeH9yiFB +BKMLECCPDhAgAIcgHQAVjuiKIMkD3gnv/YohCwPPcYAAcMgKgQHgCqEh8EYVgBA3CFEAz3Dt/r66 +QMCLcATZfdo92x4MIAQXu4ogCgOmCe/9iiELCEYdghNFHYITuglv/0cdghOKD4/4B4UmhYJwAiBC +AAcK3wcGpUwVgBAnCFEATB2CE4ogigRqCe/9ANkJ8IogGQZeCe/9iiELDwAdABVtAO/2ocDxwDYI +z/YIdc9woAAsIPCAHQ3yEQDeCiHAD+tyiiANAoojCQOYdoEE7/e4c0MJkAEuDY//z3CAAHA16KDP +cIAA1AcAgIDgzCDigQ/yz3CAAOgxAYCJ6IogCgvyCO/9iiGJBaIOj/jPcIAAADXJoM9xgADYH4og +WQfSCO/9IJHPcYAA6DHPcIAAVDUggfAgQAP4YA8JUQDPcYAAADXJoc9zgABwNSWDAiBCAAkK3wcF +o+0Hj/bxwOHFCHUE2c9woADIHCigWgzv9hbYz3GgAMAvE4GA5c8g4gLQIOECE6GA5TzaBvTPcIAA +YBdAkM9wgABgFwGQELhFeMAZAACxB4/2z3KgACwgUIIies9xgADYBxV5AIEXCIUAz3CAAIAhAIDE +EAAGBwheAUCh4H7xwA4Pj/YA3s9woAC0D7yAOg4gBMlwz3KAAOiVBJLPcaAA7CcQuIUghAAGoQWS +ELiFII0ABqEHgs9zpwAUSAejCIIQowOCz3OkALg9mxsYAASCphsYAAWCkhsYAAaCoxsYAM9wpADs +/8agiiCKAAah2g0gBK94z3CAAMwnBIBRIICAvAniBcogYgDxBo/24HjgfuB4ANjPcYAA/CcDqc9w +gADgBkeAAoBCqRzgVnhEiEmpBYjgfwqp4H7gePHATg6P9s9xpwAUSADdqKEHgc92gADolQemEIHP +cqcANEQIpqehz3DzD//8EKGg2Lahmrj1GhgAz3GkALg9mxEABs93gAAcIAOmphEABgSmkhEABgWm +oxEABgam/9ibGVgDphkYAJIZGACjGRgAz3GkAOz/z3AAAP//p6EGoQCHAeAApxUIUQAB2c9woADI +HDGgjg4gByhwBNh6DK/3QCYBEg3Ybgyv90AmgRLPcCgAAgHPcaAA7CcGoYogjQAGoQCHQiBAgACn +BfTPcKAAyByxoOUFj/bgePHAdg2P9lEgwIENEg82z3OAAIzJAxINNs9xgACcyvR7EYsQE4QAEvIB +4AhyMhWFEGeRAhkCAc92QQCDAGaxz3OAAFw9A6kR8EAkQgAxFYUQQqnAEwMBA6nPdiEAggBmsc9z +gABgPRMNhQDEoQCDAeAAowSBU/DPc4AArMnrYwHjwYVkqQDacI13Dh4RLyUIAO9/SSfEEPJrz3CA +AJDW9n/gYNKNEQieBc9wgADQ2HZ4AYgD8EhwACSPD4AA0Nh2f+SPCCbOEwgmABCgcEkgzgMWa9V4 +z3aAAFDaAGbPdoAA0Nl2fmGGz3aAAIAhxIbYhsV7BCODDwAAAAhmeALwA4UCoZgVgBBoiQ0LAABE +qWDYGLgE8ADYnbgEocUEj/bgePHA4cUDyKQQAABRIACAz3CAAIAhBIAE8huQA/AakD4KwAW76M9w +oAAUBAPZI6Ag2AwaHDDPcYAA5DsWgQHgFqEDyADamBABAKQQAwCUGEAAnhABAay7khhEAL4QAQGt +u4AQDQGkGMAAkBhEAH4QAQGAGIQAPWWwEAEBonkwebAYRACCEAEBfhiEAIYj5Y+yGEQAaA8C/TkE +j/bgePHAuguv9ghzEIkzEY0AAdpAqw0SDzbPdoAAtMnuZs9ygADkyUjcwasNEg82AiIOA/QmzhPB +sw0SDjbwIoIDQaNBgSMKHgHSic9ygADQ2BZ63KtAioYifwxcegS6RX7cqwPwgNpcqwS4BX29qxyR +z3KAACzKD7MNyPAiAAAEswfIBaNUEQABDLMAkQ2zoBGCAEijBsgEIIAPAgBBAA0IgQ8CAAAAiLpI +owbIhiC+jwTyibpIo5wRAAHPc4AAgFomuMC4QCgCAw+BwLgNuEV4VQOv9gCj8cASCCAAAtj+CQAA +0cDgfvHA0gqP9s93gACAIRUnEBAAEA4gCHUUlgsIUgGI4ALYwvYA2BqmSiQAcgDZqCBADc9wgAAQ +Z/QgQgDPcIAAhK80eECwz3CAACBp9CBCAM9wgAC0rzR4QLDPcIAAIGf0IEIAz3CAAJSvNHhAsM9w +gAAwafQgQgDPcIAA3K80eECwz3CAAAhp9CBCAM9wgACkrzR4AeFAsAiG5bgE2cohIQA0phEIHgEJ +2UYeRBAu2gbwFNlGHkQQMtpbtlmOWWEweUYeRBAa4Tq2FQgeAArYVB4EEAbYVh4EEAfYCfAQ2FQe +BBAA2FYeBBAF2A+mpghgA6lwPI4ocEQeQhCGIAMA5rlYHgIQyiJBAAvyUCHDAW96RB7CEFAgwwFv +eFgewhATCV4BSHOGIwMAb3pEHsIQDQkeAaW4WB4CEAsJ3gCkukQeghAvDZAQ8g3v+KlwABAAILkQ +AAZRIECA8djAKCIByiCBDwAAkwDAKCEBhB4AEBjYjbgTpgiGDwjeALYXgBCJuAPwnReAEBKmz3Cg +AKwvGYDPcYAAzCcwuMC4Lg3gBgWhCIYEIL6PAAYAAADfCvI2uMC4G3gB4FoeBBAC2BqmBPBaHsQT +ANgXphimEgtv/alwKIYB2khzQSkABTW5UiAAAFIhAQDAuMC5qg7v/ZhySQGP9uB48cDiCK/2B9jP +daAAyB9IHRiQz3CAAIAhI4DPdqwA1AEagUwdGJCC4ALYyiAiANAeAJCKIAQAD6VGEQABz3egAKQw +sB0AEEYRAAG0HQAQH9gIuA6lCIFRIACAANiLuAjyEKWaCc/4AYeEuAfwEaWSCc/4AYekuAGnz3CA +ALhaAIAVCB4AhiD/DiK4FLjPcYAAAAYLodoLr/gB384OwADqDwADaghAA89wAABVVVodGJDPcKYA +KABZHdiT76DPcIAAgCEDgFoQAQHPcKYA6AcmoCoID/3PcIAAgCEDgFoMIAQNkADYjB4YkAfYjR4Y +kADYix4YkM9wgAA8LSCAYHkE2BLoz3GAAHAZGoE7gSR4GQheBIog2AniCK/96XFuD2AAAtgF8PIK +oAUB2M9yoADEJw8SAIZEIAMCz3CAAIAhI4AbgQ8aGIAPEgCGo7gPGhiADxIAhgV7DxrYgHyBz3Cg +ADAQZKDPcIAA3MoQeI8aGIDPcIAALKTPc4AALLQQeBC7ZXiQGhiAiiAEAJIaGIAdgUAaAIDPcIAA +wCBTGhiADxIAhp+4DxoYgADYEBoAgB6BHBoYgJUHT/bgfuB48cDPcIAAwJUYEAQACiHAD+tyz3AA +AOUO3tt9A6/3SiUAAOB48cDhxc91gADAlWrYCgiv/SaFJYUmpQIIr/1r2F0HT/aA4PHANNgH9BoJ +z/1QIEEEBfASCc/9TyBBBEoJ7/002NHA4H6A4PHA9NgI9PYIz/1QIAEA9NgH8OoIz/0IcfTYgLki +Cc/90cDgfuB48cDhxaHBaHVEIsAChiL/A0YiwgNUega5NHlZYRV5x3GAAHyai3AI4TIPb/YE2qlw +i3EqD2/2BNoA2NUGb/ahwPHAVg5P9qHBCHUAJI4AYn4CJk4RoHJiegIiAoEA2EDADfIsfot2L3BI +cYYP7/vJcm4JoAHJcADAAn2pcIEGb/ahwOB48cDhxYogCgseD2/9c9nPdYAAcMiKIAoLDg9v/SCF +z3GgACwgMIElpc9xgACYriiBANgXCd4BJI0LCVEAJY0JCVAAAdgK6ACFgeDMICKAIvKKIMoMfNka +8Iogyg3KDm/9gtkghRbpBI0NCFEABY2B4AHYA/IA2AXoPg1P+ArwFQlQAIogygyN2Z4OT/0C2ACl ++QVP9vHAgg1P9s92gAAcIACGAeAApgDdFQhRAAHZz3CgAMgcMaAuDuAGKHDPcIAAfAcgkIa5ELkF +IYIPAADCEs9xoADsJ0ahAZAQuAUggA8AAAITBqEAhkIgQIAApgb0z3CgAMgcsaCJBU/28cAaDU/2 +z3CAAMQuGYAA3YHgyiHCD8oiwgfKIIIPAACoE8ojgg8AAJAByiRCA1gBovfKJUIDz3aAABwgAIYB +4ACmFwhRAAHZz3CgAMgcMaCWDeAGKHDPcIAAfAcjkASQwrnCuAO4JXgQuIUgjQDPcaAA7CcGoQCG +QiBAgACmBvTPcKAAyByxoP0ET/bxwI4MT/bPdoAAHCAAhgHgAKYA3RUIUQAB2c9woADIHDGgOg3g +Bihwz3KAAAQwAIrPcaAA7CcQuAUggA8AAMJpBqEBihC4BSCADwAAAmoGoQCGQiBAgACmBfTPcKAA +yByxoJkET/bgePHAHgxP9gogAKDPdYAAAF8AFQQQKvLPcKQAuD0A2jcMEQCbEAMGz3GAAARfYKGm +EAMGz3GAAAhfYKGSEAMGz3GAAPheYKGjEAMGz3GAAPxeYKGbGJgA/9mmGFgAkhhYAKMYWAAB2DXw +TCQAgMohwQ/KIsEHyiCBDwAAfhnKI4EPAAD8AgwAoffKJQEEz3CAAARfIIDPcKQAuD2bGFgAz3GA +AAhfIIGmGFgAz3GAAPheIIGSGFgAz3GAAPxeIIGjGFgAz3CAAMwnBIAiuMC4lgrAA7EDb/YAHQAU +4HjxwD4Lb/YA2M91gAA8LSCFQHknCBEDz3aAAEQtIIZgeQLYi+gghmB5A9iH6FoNr/1Q2AsIngEA +2ALwAdgvIQcgz3CAADQ4z3eAAFQtNg8v+gCnz3GAAFg9FIEB4BShz3GAABwgAIEB4AChFQhRAAHY +z3GgAMgcEaGeC8AGz3GAAEAvBIErCFEAJoHPdqAA7CdgeQDYz3CAAFS7GIiX6M9wAQAGAQamz3AS +AAYEFvAKIcAP63LPcAAAhxmKI8UJSiQAAPUGb/cKJQABz3ABAAcBBqbPcBIABwQGps9wgABUuyCA +A4Ar6eCHRCi+A8bYkrgGpiCFJ3dgeQDYcwgQAyCFYHkA2GcIEAQghWB5ANhfCFAEIIVgeQDYUwiQ +BM9wOQACMwamz3A5AIJMBqbPcDkAAmYGpsfYlbgY8EQovgMAIY9/gACsacfYkrgGps9wAAACMwam +z3AAAIJMBqbPcAAAAmYGpsbYlbgGpuoOT/7PcIAAVLsYiM9xgABUu5oK4AMggS8JECDPcAAAAm4G +ps9wwQBCbgamz3ADAMJuBqbPcDYAQpcGps9wAgBCawamz3AQAIdyBqYFjxC4BSCADwAAQnAGpgSP +ELgFIIAPAACCcAamA48QuAUggA8AAMJwBqYCjxC4BSCADwAAAnEGpgmPELgFIIAPAABCcQamCI8Q +uAUggA8AAIJxBqYHjxC4BSCADwAAwnEGpgaPELgFIIAPAAACcgamAY8QuAUggA8AAEJyBqYLjxC4 +BSCADwAAgnMGpgqPELgFIIAPAADCcwamIIVgeQDYJQgQAyCFYHkA2BkIEAQghWB5ANgRCFAEIIVg +eQDYEwiRBAyPELgFIIAPAADCfwamz3ABAEZqBqbPd6AAyB+kFxAQFQkQIM9wUADGcwamz3AgAMdz +HfAghWB5ANg1CBADIIVgeQDYKQgQBCCFYHkA2CEIUAQghWB5ANgVCJAEz3CAAAZ0BqbPcIAAB3QG +ps9wgADGcwamz3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqbPcIAAVLtYiM9xgABUuwCI +JImA4gHawHrPc4AAVLvaCWAGeYsk2BjZAgngBjPaLwhQAM9wgABYPVAQBADPcIAAVLsMEAUACiHA +D+tyz3AAAIoZWQRv94ojBwcPCRAgz3AGAEJrBqbPcBAAx2oGps9wEACGcgamDwkQIM9wAgBGagam +yg9ABtIOQAYk2AHZngjgBjPapBcAEM9xgABYPQIgAAQToc9wAgBHagamIIVgeQDYLQgQAyCFYHkA +2CEIEAQghWB5ANgZCFAEIIVgeQDYDQiQBM9wZQDCbgamz3CAABwgAIDPcYAAHCBCIECAAKEE9ADY +UR8YkJkHD/bxwC4PD/bPcIAAxC4UgIDgi/J+DG/+B9h6cM9wgAA0OgyIhiD/AUO4YbiG4PQADQDP +doAAVLskhs9ygACEuTMmAHCAAFBgQCIRCwS5NHlAIhAKQCISBkAiDwhAIg0EOmJAJwFyFHkAec9x +gABsMEhwVfDPcYAAjDAEalHwz3GAAKwwQCIAAkvwQCIAA89xgABsMDoLb/4A2gSGz3GAAIwwBLgU +eLhgO/BAIgAHz3GAAGwwGgtv/gDaBIbPcYAArDAEuBR4+GAr8EAiAAXPcYAAjDD6Cm/+ANoEhs9x +gACsMAS4FHhCcBvwQCIACc9xgABsMNoKb/4A2gSGz3GAAIwwBLgUeAJwxgpv/gDaBIbPcYAArDAE +uBR4InCyCm/+AdqaCm/+anBhBg/24HjxwM9wgADELg+AEejPcIAAVLsEgM9xgADUugK4FHg4YM9x +gADMMNYMT/7RwOB+4HjxwOYNL/ZE2s9wgABoac9xgAA4yRYLIAQA3gLdFgggAMlwYb35DXWQAeYp +Bg/24HjxwK4NL/YA2s9xgACAIRV5YIEEuAAgkA+AAPBluRuYAACBBBAPIM92gABoab4Y2AOggUKG +iiAHD2GGHWXwHYAQ7B3AECCBRobPdYAAOMllhjhg+BiAABYmwRP0GMAAFiXAEwTgBOESDi/2CNoM +EAAgFn4WfQRtJG7+DS/2CNqVBQ/24HjxwCoNL/YS2anBCHbuDCAGi3BKJABxANqoIIACFiSAMCiI +CwmSAGG5KKgB4gLCAcPPdYAAgCHVfQCFiiEHD/Rux3eAAPBlOGDsGMAA8BiAAACFBsIFwzhg+BiA +AIPB9BjAAAQXEBDPcIAAOMkWIAAEBOCCDS/2CNrjh89wgAA4yYfB9ngE4G4NL/YI2gDAIIW5GRgA +IIW5EQAGFQgeAL4Z2AMghb8RAAaAuAjwvhkYBCCFvxEABqC4Rgvv/L8ZGACE6DYLz/wE6ADYA/AB +2BB2eAuhBsoggQMAhbkQAQZRIUCA8dnAKSIByiGBDwAAkwDAKSEBigov+4QYQACRBC/2qcDgePHA +LgwP9s92gADsXs91gADoBxLpIIaN6QCllgxv+A7Ybg+v/oogEAAB2ACmDvAghSV4C/BGC2/4Dtga +D6/+iiAQAADYAKYApVEED/bxwNILD/bPcYAAJC0AgaC4AKFmC+/7AdjPcIAATK4AEAQATCTAgMoh +zQ/KIs0HyiCNDwAAgQzKI40PAADaABAAbffKJe0AxQx0AADdFG0AIIEPgABMrgeR5pHEkRC4BX8F +kUORELgFfgKRELpFeBpwagqv9+lxWnDPcIAArHDwIEEDRC0+FwohQC4AIYB/gACEVyCgLglv+wpw +CHEAIYAvgAB4V7IIwASKIMwORgwv/enZiiAMCD4ML/1KcYogDAgyDC/9yXEJD4QTme7PcIAAoHDw +IEEDRC0+Fy92ACGAf4AALFggoN4Ib/tKcAhxACaAH4AAIFhiCMAEz3CAAEyuAIAB5UkNBJAlAw/2 +4H7geM9xgAB0Lc9wgABAL+B/IqDgfuB48cC+Cg/2AN7PdYAAfMnPcIAARC0ggMClYHkB2IPgyiHC +D8oiwgfKIIIPAACYGcojgg8AAOsAyiRiAPAGIvfKJYIDAIWYuAClANjBrcKtjrgBpQKlz3aAAEgt +QIYG2GB6AdlAhgfYYHoB2QGNvQIv9gCt4HjgfuB44H7gePHAz3CAAFhaAIB9CFQBz3CgAKwvGoBS +IAAAbQgfAM9xgADolQuBAeALoc9wgAA0LQCAQHieDgAAz3CAADAtAIBAeEIPgADOCg/+DgqP/Abw +9gzv/IogiQzPcKAAeEUAgAQggA9wAAAAQSg+hfL1z3CAAIAhI4BIgTSRUyIAAMIPoAIB2woJb/gS +2NHA4H7gePHA4cW0wYogmAm6Ci/9WtkF8KYM7/yKIIkMz3WgALRHcRUAlgQggA9wAAAAQSg+hfH1 +iiD/D28dGJBrHRiQcg2v+Itwdg6P/A7obxUElmsVBZYKIcAP63LPcAAAsRPBBS/3NNuGD0/4agiA +A7kBL/a0wOB4QIgB2AChaLoCulV6x3KAAMQuY4JjoWGCYaFigmKhZIJkoeB/AKLgePHAEgkP9s93 +gABcWgaHA4DPdYAA6JUggEmFACKADy0AwMYCeYEJcgChwc92gAAcIACGAeAAphcIUQAB2c9woADI +HDGgngmgBihwi3GKD+/2QtgAhkIgQIAApgf0ANnPcKAAyBwxoAAUBDEEJL6PAAAX/8ohwg/KIsIH +yiCCDwAAphPKIyIM/AQi98olIgAAhYK4Fg0gAAClIgggAAHYAIWiuAClKYXHcS0AwMbeDaAE6XDJ +AC/2ocDxwDIID/avwc9xgAC4YQCBSiQAIE3ABInPd4AAgCFuwAOHCIBTIBcANxSAMEDALsBBwDYU +gDBCwM9wgABwGTqAG4AkeM9xoAC0R0cRAYYxuMC4h+mKIJgMiQQgAEzZgOB4BAEAz3CAAOiVABAE +AFEkQIDKIcEPyiLBB8oggQ8AAKoTyiOBDwAAWgBABCH3yiUBBc91gADYBoogGAfSCC/9IJUglc9w +gADolSKwANmeuc9woAC0R1MYWIDgeFMYGIVOCU//z3WAABwgAIUB4AClEwhRAM9xoADIHAHYEaFO +CIAGLcDPdqAA7CcQuAUggA8AAEItBqZAJIE8Jg7v9kLYz3AIAIcQBqYAhUIgQIAApQb0z3CgAMgc +RBgABc9wgABEshYgwAUkgACACrnJuAQhgQ8PAAD8BXnPcKcAFEgtoHIID/5DwBkPECCKIf8Pz3Cg +ALRHbxhYgGsYWIAB2M9xoAC0R2AZGIADhzIggA8AANgCgOAB2MB4D7iQuJu4n7hfGRiAAIUB4ACl +FQhRAM9xoADIHAHYEaGSD0AGQCSBPn4N7/YR2ACFQiBAgAClB/TPcaAAyBxEGQAFz3GAAKQ5J4lK +IQAggeEB2cIhQQCA4UTBcgIlAAolQCQAwQHAInhHwAbwfgnv/IogiQzPcKAAtEdxEACGBCCAD3AA +AABBKD6F8vXPcKcAFEhcGAAFLydHFBUJESDPcIAARwQGpkogACAI8EoggCDPcYAARgQmpoogWAg6 +D+/8KnGKIFgHMg/v/ApxAIUB4AClFQhRAM9xoADIHAHYEaHSDkAGBb/wfxC/gb+Hv4y/5qYAhUIg +QIAG9M9xoADIHEQZAAVKIgAhSncB4GG/AKUTCFEAz3GgAMgcAdgRoZYOQAYCwRVvJXgQeBC4hSCK +AAam6XCAIIINEHhFwAa4gbiXuAam6XCAIEIPEHhGwAa4gbiXuAamz3AAAAIvBqbPcAAAwjAGpgCF +QiBAgAClB/TPcKAAyBxEGAAFiMCJwYrCi8OKCGAEQCQEPCzAiOjPcYAAqD0QiQHgD3gQqR0JUSAZ +DxAgSgqP/BEIUQAwHAI1TyUAIC8lByDPcYAARLIWIcEFMBEZAAjCz3CAACCWFiDWAwnA8B6AIPQe +ACAHwIgifAAvIwAgBCu+IC9wgg5v+yiBDiCYDwAAAAEJwIggfAAEKP4EL3BqDm/7K3EOIIEPAAAA +AQkggz8AAP8BCSGCDwAA/wFIIwMASCICACzAVB7YIFUemCAhCFEADBQEMEAoACFALIEBOGD1eMdw +gACAsmKwQ7AAhQHgAKUVCFEAz3GgAMgcAdgRoUoNQAYDwUAoACEGuThg9XjHcIAAgLIikDx6BcEQ +uga5gblFeSamA5AGwRx4BrkQuIG5JXgGpgCFQiBAgAClB/TPcaAAyBxEGQAFQiJSIEwiAKBSBs3/ +BMFAIVEgMnGeBcb/OhQBMVEhwIHKIYIPgABGBMohgQ+AAEcEJqYB4AClEwhRAM9xoADIHAHYEaG+ +DEAGMhQAMRC4gbiHuIy4BqYAhUIgQIAApQb0z3CgAMgcRBgABb4MD/8F8MoOr/yKIIkMz3CgALRH +cRAAhgQggA9wAAAAQSg+hfH13glP+M9wgADolQyAz3GAAOiVonAMoQ2BAeANoQjwiiCYDIohBAOO +DM/8jQPv9a/A4HgA2c9wgAAEliyoLajgfy6o4H7geIC4z3GgAOwnBqHgfs9wgAAHIc9xoADsJwah +z3CAAEc6BqHPcIAAx1MGoc9wgADHJAahz3CAAAc+BqHPcIAAh1cGoUnZz3CnAIhJMKDgfuB4AdnP +cKAAyBwwoEvZz3CkABxAJKDgfuB4z3EBAFw+z3CAADgt4H8goM9xgADolQCBgLjgfwCh4HjxwNYK +7/W4cFMggQDPcIAANHAoYIHgyiHCD8oiwgfKIIIPAACVGcokgg8AAP4AFAfi9soj4gfPdoAARC0g +hmB5AdgnCNAAIIbrdWB5Adi4cM9wAACWGQohwA+pciLb5Qbv9ookgw/dAu/1AdgJ2eB/IKDgePHA +4cXPdYAARC0ghWB5AtiA4CCFCNgI9EB5EHnPcIAAeAsH8EB5EHnPcIAAYAyGCc/2YglgAwHYMg/P +/V4PAAAqCAAAkQLP9QhxWIkBgAKhiOpZiYDiwiCiAMAgoQACoeB+4HjgfuB48cD2Cc/1z3aAABwg +AIYB4ACmAN8VCFEAAdnPcKAAyBwxoKYKYAYocMfYlLjPdaAA7CcGpc9wAwCCbAalz3ADAMJ0BqXP +cAMAQpYGpcbYkLgGpXYKYAYK2M9wAACCbAalZgpgBgrYz3AAAMJ0BqVaCmAGCtjPcAUAQpYGpUoK +YAaKIAcNz3AAAEKWBqU6CmAGCtjPcBMAxgAGpS4KYAYy2ACGQiBAgACmBfTPcKAAyBzxoK0Bz/Xg +ePHAPgnP9c9yoACsLzWCAN8PCR4AAdvPcaAA7CdmoYjoz3CAADQtAIBAeErwFYJRIACAyiHBD8oi +wQfKIIEPAAB/GcojgQ8AAKoAyiTBAGAF4fbKJcEAz3ATAMcAz3WgAOwnBqXPcBAABmkGpcfYlbgG +pc92gAAcIACGAeAAphcIUQAB2c9woADIHDGggglgBihwz3AAAEItBqXPcAAAgkYGpc9wAABCYAal +AIZCIECAAKYG9M9woADIHPGg6QDP9fHAggjP9c9wgAA8LSCAocFgeQTYMujPdoAAHCAAhgDdAeAA +HEQzAKYVCFEAAdnPcKAAyBwxoBoJYAYocItxBg+v9gDYAIZCIECAAKYF9M9woADIHLGgABQBMc91 +gABILYYh/wxAhUK5YHoC2AAUATFAhQPYYHrBuXUA7/WhwOB48cD6D6/1A9jPdoAAPC0ghs91gAAA +OWB5osEG6CCGYHkE2IboZQMgAEgVBBAD2Bpwz3enABRIz3agAOwnEg3v/QXYDqXPcIAAHCAAgAHg +z3GAABwgAKEXCFEAAdnPcKAAyBwxoGoIYAYocAPYVg6v9qlxBNhODq/2Im0F2EYOr/YkbQrYPg6v +9iZtD9g2Dq/2QCUBEjbYLg6v9kAlgRI32CIOr/ZAJQETONgaDq/2QCWBEwiHBKUNhwWlDocGpc9w +pwCYRxyAB6UXhwilFocJpc9wqwCg/xiAC6XPcKsAoP8ZgAylz3CrAKD/GoANpc9wAwDGAwamxtiQ +uAamz3AsAAIBBqbPcFkAQgEGpoogigAGps9wQACHDQamz3DRAMINBqbPcMAABw4Gps9wgAAcICCA +EQlRAM9yoADIHADYEaIB2AinANgNpw6nz3CnAJhHz3JQAP8AXKAA2BenFqf82s9wqwCg/1igfNpZ +oBqAz3KrAKD/gLgaos9wgAAcICCgEwlRAM9xoADIHAHYEaFCDwAGz3BAAIYNBqbPcBAAAg4Gpotw +SgogBIHBNoUAwCJ4BCiADwAAdAkVhTeFAnn+D6/1L3ABwk/gz3GAAJSXFKVXoRihz3BAAIcNBqbP +cBEABg4Gps9wgAAcIACAz3GAABwgQiBAgAChBvTPcaAAyBwA2BGhi3DqCSAEgcE2hQDAInjiCu/7 +EqUyhVWFLHg3hS8gQA5CeTlhkg+v9TV54LgceMAgYgCCIMQCz3GAAJSXEqUTpRahz3CAABwgAIAB +wgHgVaHPcYAAHCAAoRMIUQDPcaAAyBwB2BGhZg4ABgGVELiFIIQABqYClRC4hSCFAAamA5UQuIUg +iwAGpgSVELiFII8ABqYFlRC4BSCADwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbP +cIAAHCAAgM9xgAAcIEIgQIAAoQb0z3GgAMgcANgRoQSFK4UIpwWFDacGhQ6nCIUXpwmFFqfPcKsA +oP84oCyFOaAthTqgdgnv/Q6FMoWMIYKARfaMIT+BDPa2DSAGCtgWC8ADQiBAIIDgBgXN/wbw4g2v +/Iog0QUyhYwhgoBF9owhP4EF9s4Nr/yKIBELSBUEEIwkgoBF9owkP4EM9gohwA/rcs9wAAC0GYoj +RQwBAe/2uHPPcIAAZhgAiAboz3CAAGA5ABAEAIhw1QSv9aLAz3CAAAA54H8UgOB4z3EBAAhWz3IB +AOBMNQOv+gDY4HjgfuB48cDPcIAANC0AgEB4z3CAADAtAIBAeNHA4H7geADZz3CAAJQH4H8goPHA +IgyP9c9wgAA8LSCAocFgeQTYgeCR9H4Kb/z32IHgi/QA2AAcBDDPd4AAHCAAhwHgAKcVCFEAAdnP +cKAAyBwxoLIMIAYocIt1ANiaCq/2qXEAFAUxqHCGIPwDjCADjA3yCiHAD+tyz3AAAL4ZiiMEASEA +7/aKJIMPz3aAAEgtQIaGJfwPANhgekItgQFAhgHYYHoD2QHYTgqv9qlxQIYI2GB6ABQBMQAUBTFM +JQCAyiHCD8oiwgfKIIIPAACaGcojgg8AABIByAei9sokYgAC2BYKr/apcUCGBNhgegAUATES2AIK +r/apcUCGBdhgegAUATEAFAUxTCXAgMwlIoHKIcIPyiLCB8oggg8AAJwZyiOCDwAAGQF4B6L2yiRi +AACHQiBAgACnFvTPcaAAyBwA2BGhEPDPdYAASC1AhQHYYHoD2UCFBNhgeghxQIUF2GB6BNk1A6/1 +ocDgePHAygqP9c91gAAcIACFAeAApQDeFQhRAAHZz3CgAMgcMaB2CyAGKHDPcIAABiHPcaAA7CcG +oc9wgABGOgahz3CAAMZTBqHPcIAAxiQGoc9wgAAGPgahz3CAAIZXBqEAhUIgQIAApQb0z3CgAMgc +0aDPcKcAiEnQoL0Cj/UI2c9wgAB8yeB/I6DxwEIKj/XPdoAAHCAAhgHgAKYA3RUIUQAB2c9woADI +HDGg7gogBihwz3AAAMIsz3GgAOwnBqHPcAAAAkYGoc9wAADCXwahAIZCIECAAKYG9M9woADIHLGg +VQKP9fHAMgnv9xbY1grAA89xgACAIQCBxBAABg8IXwEBgcQQAAYNCF4BEgov+BPYz3CAACgtIIBg +eQvY0cDgfvHAGghv/IogiAUO6AoIb/0A2M9wgAA8LSCAYHkE2IDgQA4C/9HA4H7PcIAAgCEDgAiA +z3GAAHzJCQgeAAGJA/ACieB/AKngePHAuHGN6AohwA/rcs9wAACnGYojxAu5Ba/2iiSDD89xgAB8 +ySCBTCUAgAQhgQ8ABwAAQSkDBgDZyiRNceggbQPwIEUABCWCDwEAAMAuumV6CwuBAAHh0cDgfgoh +wA/rcs9wAACoGYojBA5lBa/2SiRAAOB48cDhxQDdz3CAAKAGpgggAKCgz3CnABRIqKBJAY/14Hjx +wKHBuHAA2EDAUyWAACcIUABFCJAATwgQAQohwA/rcs9wAACrGYojigoRBa/2iiSDD89wgABELSCA +YHkB2ITgAdnAec9wAAAi0jR4z3GAAJPjD/DPcAAAI9LPcYAAluMH8M9wAAAk0s9xgACZ4ynaErrw +IgAADiCCDwABAABAwotwkg1gAwPaocDRwOB+4HjxwDYIj/UDyJQQAADPdoAAHCAEIJAPAQAAwACG +QSiQIwHgAKYA3RcIUQAB2c9woADIHDGg1gggBihwz3EkAAcBz3CgAOwnJqCKIYUAJqBTIIEgKwlQ +AGUJkACBCRABCiHAD+tyz3AAAIgZiiMGA4okgw85BK/2CiUABM9xgACAISOBKIFRIQCAyiGCD4AA +xyDKIYEPgACHJCagz3EEAMcxJqAAhkIgQIAApgb0z3CgAMgcsaDlB0/1z3GAAIAhI4EogVEhAIDK +IYIPgAAHOsohgQ+AAMc94vHPcYAAgCEjgSiBUSEAgMohgg+AAIdTyiGBD4AAR1fS8fHAz3GAAIAh +I4EvKAEAKIHAuQAhgw8AACLSTiCBBynYErjwIMAAz3OAAFS7eIvPcoAAk+OhwUDAhusCIIAPAAAA +wEDAi3A0eVlhQgxgAwPaocDRwOB+4HjxwO4Ob/W4cM9wLAAGAc9zoADsJwajz3KrAKD/GoJTJY0A +ANklDVAQaQ2QEKkNEBEKIcAP63LPcAAAgRmKI4UDGQOv9ookgw/PdYAAgCGjhaiFz3YCAIICUSUA +kMolgh+AAMYgyiWBH4AAhiSmo8ajz3UEAMYxpqPPdUgAQgGmo89zpwAUSDejgLgaos0GT/XPcYAA +gCEjgSiBz3UCAIICUSEAgMohgg+AAAY6yiGBD4AAxj0mo6ajz3EEAMYxJqPPcUoAQgEmowHbz3Gn +ABRId6Hc8c91gACAIaOFqIXPdgIAggJRJQCQyiWCH4AAhlPKJYEfgABGV6ajxqPPdQQAxjGmo891 +TABCAbvx8cDaDU/1A8iUEAAAAd7PdacAFEjIpQQgkA8BAADA2g7v/0EogCP/2Ju4z3enAJhHHKeK +IBINvg5v/EEogSPPcYAAoAYAgYDgyiHCD8oiwgfKIIIPAACsGcojgg8AALIAyiQiAOgBovbKJQIB +ANgWpdqnzQVv9cCh8cBiDU/1z3CmAJw/GYC9CB4Az3WAAKwGAIVGgKASAAYvKAEATiCBB0Ep0AAR +CNUgSHCAIAoAMiAABJDoCiHAD+tyz3AAAK0ZiiNLAookgw+FAa/2CiUABM92gACI40AmwBKOCO/2 +CdkA2C4Kr/8PIAAEgOAA2A8gAAQF9CIMz/8D8KYNz/8DyLkQgAAbeIC4Cq4AhSaAliFBAwAhAAQY +iIwgw48CcQXyYbgPeBipiiBSDQDZxg1v/A8hAQQAhSaAoBEABp8ZGAC2C8//+QRP9c9xKgAVAM9w +gAB4WuB/IKDxwH4MT/U6cBt9z3CmAJw/ZBAQAC0IHyBWCa/1A9hhvYwl/5/z9QohwA/rcs9wAACk +KFHbCiRABL0Ar/YKJQAEnQRP9fHAQgxP9c9xoACsLzqBUiEBAFEhAIChwQDdf/TPdoAAHCCzCBAA +KgqP/893gAA8LSCHYHmpcBMIEAMgh2B5qXAghlkIEQQAhgHgAKYVCFEAAdnPcKAAyBwxoLoM4AUo +cItxpgpv9oogBwUAhkIgQIAApgb0z3CgAMgcsaAAFAUxVw3QAAohwA/rcs9wAACJGerbIQCv9phz +AeEgphUJUQAB2c9woADIHDGgagzgBShwz3EGAAJ1z3CgAOwnJqAAhkIgQIAApgn0z3CgAMgcsaAD +8LYIAAAAhgHgAKYVCFEAAdnPcKAAyBwxoCoM4AUocM9wgACAIQOAz3GgAOwnDoCAuAahAIZCIECA +AKYF9M9woADIHLGglQNv9aHA8cBqCAAAz3CAADwtIIBgeQPYgOBUDIIDz3CAAMwnBIAZCJ4Az3GA +AIAhTYE+kVMiAAD2CCACAdvRwOB+8cDhxc91gAD4OACFGwgfAHIOwAK6CM/7xglP+ToOz/8AhYC4 +AKU9A0/14HjxwDIJL/yKIAQCEehqDo//xg/P/89wgAA8LSCAYHkE2AXoQgiP/w4IAADRwOB+4Hjx +wJIKT/XPdYAA+DgAhTkIXwDPcIAAPC0ggGB5BNgU6OIIL/zi2BDotg9v/QfYmgigAwh2jg8P/9IO +b/3JcACFgbgApbkCT/XgfuB48cBCCk/1pBABABUJHga2EAEBz3CgAJgDPqCe8AAWDUG8sAAWAkFd +sAAWDkDPoAAWAkFAGIQAABYCQFGgABYCQUgYhABEJQITNQoQARjbchjEAAAWA0BzoAAWA0FQGMQA +ABYDQVQYxAARChECqXOGI/MPjCMMgA7yGNsW8BDbchjEAADfz3OAAJzK57MQ2wzwHttyGMQAABYP +QPagABYPQVwYxAOpd4Yn/RyMJwKSCfQC43B7chjEAAAWD0EC8ADfYBjEAwkLXgAAFg9BKHSEJAyQ +BPQA2iLwmepRJgCQ0SEighXy0Iiouc9ygACQ1qQYQAACvtZ+wmILCp4Hi7mkGEAAANpaoFug5vEA +FgJAWqAAFgJAW6AI2nQQDgG+EA8Bwn9if0J/uBCCAJi5pBhAAM9xoACYA0J/emJQenIYhAC6EAIB +8H9wGMQDpXpcsD6BthhEAFUBT/XxwOoIb/WKIAcGz3aAAHgb7glv/CCGFd3Pd4AAlBMAhulxUmgB +4ACmVHpYYQKAWWER6M9yoAAsIFCCQnjXcElrANIA28f3YqGKIMcFsglv/CCJAIYJCJQKANgApmG9 +ww1VkPEAT/XgePHAz3CAACASDtkB2uYKIAAA289wgABYEgnZAdrWCiAASHPPcIAATBEq2QDaxgog +AADbz3CAAPQRC9kA2rYKIAAB29HA4H7gePHA4cXPdYAAkjmKIEcGQglv/CCNBNiSDa/7AdnPcIAA +kTkAiIoLIAAgjYkAT/XgePHAz3GAAJI5iiDHBhIJb/wgic9wgABsX/oMwAPRwOB+8cDYcYro+ggA +AADZIqCKIMcF7ghv/Mhx0cDgfvHA0g8P9WoPz/vPdoAAmAdm2CJuAdrmCu/8SHOL6AohwA/rcs9w +AAC2FNnbiiSBCTnwAhYFEUwlAIDMJYKPAAD//w30CiHAD+tyz3AAALcU3NvtA2/2iiSBCWfYyXEB +2poK7/xIc4zoCiHAD+tyz3AAALgU39uKJMEJFfABliRuAdoB4BB4dgrv/EhzoZaP6AohwA/rcs9w +AAC5FOLbQCVEEJ0Db/ZKJQAAAm0QeCZuAdpKCu/8SHOM6AohwA/rcqGWz3AAALoU5dtAJYQQ6/Ft +Bw/1z3GgAGAdErEUkeB+8cC4cTUIUQAJDVIAGQ3SAwohwA/rcqfYBbic20EDb/ZKJAAAQC2AABR4 +QiABA89wgAC0EhlhH/DPcIAAZBcyIEABjCDDj8ohwQ/KIsEHyiCBDwAA4RTKI4EPAACiAAADYfbK +JCEAArgUeAAggQ+AAJQTKHDRwOB+EQgeAgQgvo8AAAAYAdgD9ADY4H8AqeB48cBeDg/1z3WAANoG +AI3Pd4AA2AZeD+//II9BiM92gACYOSCXDwreAAHYAK6KIMcDSPACgAXoANgArpC5QPBnCh4Bz3KA +AKwkB4pbCQEAAJVhilMIwQDPcIAA3AYAiEaKQwoBAM9wgACAIQ6ANwheAc9wgACUOUCAANsO6s9w +oAAsIBCAQngRCIUPMQEALQHaQK4E8GCuANoQuoogRwNFeRDwz3CAACAgAIgH6AHYAK6KIAcDBvAA +2ACukbmKIAcEsg4P/AEGL/UAjuB48cB6DQ/1ocEacDpyaHa9CXIAANiacRUgDSDPcYAAmAcAFZMQ +AhWSELpw440hkQGNAdo4YBB4i3GGCO/8SHMS6AAUADFAKoIgBCCBDwAAAP9HuVR6MwkQIMdygAC0 +Ehjwz3CAAJgHwZChjQohwA/rcs9wAAC7FIojhAAAJkQThQFv9golQAXHcoAAlBMAGsIEA+4CqgLw +AaolCB4ADO4DioC4A6oSbxR4G2Jji1hggbtjqOSqA+4mqgLwJapCJEEgVQl1gEAlQCABBS/1ocDg +eOHFUyANAKCpBCCBDwAGAABCIQGABCCAD0AAAADKIWIAIKrXcEAAAAAB2MB4AKvgf8HF4HjxwJDo +ng3P/89xoAAsIDCBx3FJawDSIqCKDS/8iiCHBdHA4H7xwG4ML/XYcQomgJCIdcwjIoAG8kImBgEv +JocBYg3v/8hxz3GAAFAHAKEl7iSIArk0eUOIA+ECEIUAIwofAAohwA/rcs9wAADiFIojiAVKJAAA +iQBv9golgAEIYRsIXwAKIcAP63LPcAAA4xSKI4gG7/EBEIUAUSUAgMohwQ/KIIEPAADkFMojgQ8A +ACgCyiLBB9/z4b3RJSKByiHCD8oiwgfKIIIPAADlFMojgg8AAC8CKABi9sokggErDR4QUSXAgMoh +wQ/KIsEHyiCBDwAA5hTKI4EPAAA2AgAAYfbKJIEB+QMP9eB48cB6Cw/1ocEIdSh3GnIA3s9woAC0 +D3AQEQCKIMcAegwv/KlxngqgAslwi3FAJEIwQCSDMI4O7//pcA0IESBKJAAACfDPcIAAXKgBiPno +SiSAACDAARSCMKlxwg7v/wIUgzDPcIAAkjkAiIDgzCUCkAryz3CAAFAHAIDCoM9wgACQOcCoLw9e +Ec9xgACsJAeJIw0BEAGJUycCEBsKAQAEJ48fAAYAAIDnAdoGicB6HwoAAM9wgAAhIMCoz3CAAJQ5 +wKDPcIAAmDnAqIogxwDKCy/8qXHuCaACLyBHBP0CL/WhwOB48cDPcYAAAD6KIIcBpgsv/CCBpgnP +/89wgADYBgCQgOAgDML/0cDgfuB+4HjxwKYKz//uCc//9g4ABX4Nz/x2DUAB0cDgfuB4z3EAAK3e +ZQMv/IoghwngePHA4cXPcIAAmDkAiJDo3gvP/47oiiBHBADdQgsv/KlxkNmQuQPIoBhAABfwz3CA +AHQbAIgQ6M9woAAABCyIjCECgADdCPQWCy/8iiCHBJHZkLnq8QHdaQIv9alwz3GAAIAh8CEBACgR +gAAogVkG7/8A2uB48cDSCQ/1CHfPcoAArCTPdoAA2AYAlmeKz3GAACAgLQsBAM9wgADaBgCQYYod +CwEAz3CAANwGAIhGihEKAQDPcIAAISAAiAPwANguC+//AKnPcIAA3AZAiM9xgADaBgCJII6A4gHa +wHrpcwDd/gzv/5h1z3CAAFAHAIABiM9ygAB0GyCWDwgeAQHYAKqKIEcDBPCgqooghwNOCg/8nQEP +9c9xgACsJM9wgADYBgCQR4kxCgEAz3CAANoGAJBBiSUKAQDPcIAA3AYAiCaJFQkBAM9wgAAgICCI +z3CAACEgIKjgfuB48cDuCA/1z3aAALyuFI4pCFEABNhGDm/7AdnPcIAA2gYAiM9xgADYBjoM7/8g +iQDYFK418LaOM+3Pd4AAkDkAj2G4NQ0AEKIIz//PcIAA+N4FgCFtBSh+AM9wgABsXwoOoAMvcYog +hwbPcYAA2AaWCS/8IJHPcIAA2gYgkM9wgACROaCvIKjPcIAA2AYgkM9wgACSOSCoANgWrjWOCenP +cIAA2gZiCO//AIgA2BWuqQAv9QHYz3CgACwgMIDPcIAAlDngfyCg4HjxwB4I7//hxc9wgACcIRCI +z3WAAFyoGwgRAYogDwoeCS/8iiFKBAKNFgggACGFAo0hhXYM7/8B2mUAD/XxwOYP7/TYcaHBGnCL +cUAkQjBAJIMwFgvv/8hwARSAMAjoAhSAMAboQiAQIS8gByQgwM4I7/8KcQEUgTAD6aKIAvChiIog +xwG2CC/8yHFAKAAmQC0CFAV6ARSAMAIUgTAIuAV6iiDHAZYIL/xFeeG90SXikAPyIw0eEQohwA/r +cs9wAADnFIojTQNKJAAAzQMv9golAAS1B+/0ocDxwEYPz/ShwRpwAN7PcKAAtA9wEBEAeg5gAslw +iiBHAUIIL/wKcYQoCCkAIY1/gADUqSXwQCUAFxYghAMFFIAAhiD+hxryBIWLcUAkgzBAJE8wPgrv +/+lyqBUAEH4I7//pcSDABBSBAAEUgjACFIMwdgrv/0okwAAB5gyVuQ4EkIogRwHeD+/7CnEGDmAC +LyBHBBUH7/ShwPHAGgzP/4IKAAXRwOB+4HjxwKoO7/SKIYsGAN3PcIAA4MiloKYP7/uKIMoBz3CA +AOgxoqDPcYAAgCEAgcQQAAatCF4BA4EYiKUIEAGKIMkDeg/v+4ohiwjPcIAAJCAEgM91gAA4WSCA +iiCJA14P7/s2uQCFQiAAgMogYgAxCFEAPgugA6lwz3aAAABZAIZCIACAyiBiAIzoiiCJDi4P7/uK +IUsLyXCKC6ADIoXPdYAAVFkAhUIgAIDKIGIAMQhRAP4KoAOpcM92gAAcWQCGQiAAgMogYgCM6Iog +iQ7uDu/7iiGLDslwSgugAyKFOQbP9OHFANvPcoAAjMkUIg0AYLVotRpiIBrCAMAdxBAoGsIAz3GA +ADjJFnkikTAawgDQHcQQgB3cEHgdRBAB2YgaQgDPcYAALMoVeWCh4B3EEPAdxBDgf8HF4HjxwLIM +b/wR2Lnoz3GAAKwkz3CAANgGAJBHiVUKAQDPcIAA2gYAkEGJRQoBAM9wgADcBgCIJok5CQEAz3CA +ACQtAICa6BYPQAKI6AvIBSCADwAAADwLGhgwBg9AAojoC8gFIIAPAAAA1AsaGDALyJC4CxoYMFYN +j/sD8DYLz/XRwOB+4HgA2Zy5z3CgAKwvPaDgfuB4BQKP+/HAJgwv9xXYiiDQB94N7/tI2dHA4H7g +eOB+4HgggADagOFF9gHaM3kgoIAhAYB/3MAhBANHuSCgA+ozeSCg4H6hwfHA4cWswQDZSsGQ2Ri5 +SMHPc4AAfMkggwQgjQ8BAADAhiH+AyS5DrkLJUCQTsCOwhby13UAAABAzCWCnwAAAIDMJYKfAQAA +AAT0IYMD8CKDrrivuLC4BXkgog7DCMCLdQQjgQ8BAADALrlAKQIGRXhIwIogBgZJwEHDqXAA2koJ +IAAB289xgABwGRqBO4EkeCcIHgIKwAvBhCgEDgAhgH+AABjhArkI4DR5IWDPcKcAiEkvoCYO4AOp +cAjcUwTv9KzAocHxwNIL7/QIcq3BCNhKwJDYGLhJwM9wgAB8yaCABCGODwEAAMCGJf4TJL0OvQsm +QJNQwZDDFvLXdgAAAEDMJoKfAAAAgMwmgp8BAAAABPQBgAPwAoCuua+5sLkleACjEMMJxQQjgQ8B +AADALrlAKQAGBX1JxR8KngEKwAQjvo8AAAAYRSDAAErABfKFIBABSsAlCh4Bm73PcKAALCAFgADb +ArhuuIDgyiDMAMm4pXhJwAbwCQoeAp29ScUQwIHFQsCpcEIIIAAC2wPIDMLPcYAAcBm5GIIAGoE7 +gSR4GwgeAgK6z3CAACDhVHpBYM9wpwCISS+gIg3gA6lwCNxHA+/0rcDxwM4Kz/SjwWGACHVAwwDY +CqVtC14CBCOADwEAAMAuuM9ygAAcZQpiSSKCAGG6S6USahR4x3CAABDiyoDPd4AAFMvGpQuAz3aA +AIAhBaXDhiDA1Ib1jwR+5H4JvkApDwLlfsV4BCODDwAAABBleAelCIUY4p64CKVLpY/wNwqeAs9w +gACcWgCAQcBCwCEIHgKGIP8JI7gB4BUIlAALCJEABthhwCTwB9hhwCLwIsBhwB7wQcPPcoAArAZA +gkaCnhICBisKkQEEI76PAAAAGA/0z3KAAIAhRIJIggQivo8ABgAABfIB2AqlA/AKpQDYAcZBDh4S +QsYiwqDiyiIhAAQmjx8BAADAQS+EE0QmDxYjvwHnBCaOHwYAAAAxvgAmxRPPdoAAHGUyJg4RAiZO +ERPwUybCEM93gAAAaV16SmcEJo4fAQAAwC6+z3eAABxlzmdhvtZ6S6UTCx4CIMfPdoAAJGXuZgLw +Ad6EKAQOACGAf4AAGOECulR6R2Bhvlhg5qUBgAQjgw8vAADdJrvFe1IjwwMFpWelz3CAAHzJA4AA +3x0ITgDPcIAAuFoAgBUIHgCGIH8PHXhAKM8DBPAA34+/m+/PdoAAPC0ghmB5ANglCBADIIZgeQDY +GQgQBCCGYHkA2BEIUAQghmB5ANgLCJEETg9v/ADYCIUFf+ilOQHv9KPA4HjxwM4Iz/TPdYAAWC0A +hcSQyXAuCqAAhiD8AwCFyXHuCWAAhiH8A89zgABYywsIkQYhg4C5IaNKgwHiSqPPc6AAxCeREwGG +w7kbCYEAiiUIEBMbWIOREwGGw7kLCYAAEhtYg9kAz/TgePHAXgjv9ADYz3GgAKggKIHPcaAA1As4 +gc9xoADEJ1IRAoYVEQKGQhEDhhELngcB2M9xgADcymGxUSLAgBpwyiViFBL0USDAxsolohQM9M9w +oADQDyAQAYYfEACGEHEA3colYhXpDREQz3aAANzKH4bLCB4EqBYBEJTYTg/gAclyz3egANAPUQgQ +IM9wgADUByCAz3CgAPwlz3KAAHDIjOkzgAqCGWEqos9yAP8AqoogiAUM8BOAJJIZYTB5JLKKIIgF +z3IA/wD/eg+P/QCWlg3v/TSWlBcAEM9ygADkOwHZGehtggHjbaJrgnhgC6LPcIAAICAgqB+GDwie +A89wgACMBiCgB/APCN4Dz3CAAJAGIKDPcKAA/CUTgGyCeGAMos9yAKAIAOxwQKBvIkMA7HBAoA4f +WJASCUAFz3AAAP9/z3GgAAwkAaEb2AShdQev9Klw4HjgfwHY8cDhxaHBegiv+4twsugAFAUwHQ0e +AH4IAADPcYAA3MpDgc9xgAB4r0GhJPALDZ4Aeg7P/x7wDQ1eAgoOz/8a8DsN3gAI2M91oADEJxMd +GJBqD8AAHQgQBQLYPB0AkM9wgADcyiOAz3CAAHivIaAZ2JcIUIYNB6/0ocAKIcAP63IX2Iy4iiPH +APEC7/WKJIMP8cDhxc9wgADcyj+ABCGBD///jzgEJYBfAABwxyV4z3GAANzKH6FEIgBTz3WAANzK +QwgRAj8NXlE2D8//nB0AEBMNnlPPcIAA1CEFiJgdAhAU8BUN3lPPcIAA5CQZiJgdAhAM8AOFignv +9SSFmB0CEATwANicHQAQnBUAEIDgzCDigHHyz3CAADgWC4AP6M9ynwC4/x2iz3GAAAQgBIEB4LO4 +tbi4uAShFqLPcKAAqCAIgB+FDwgfAQsN31KA2JgdAhCYFYAQQCgBBhMI3wGCuR0KnlPKCcABGvAf +hVEigNOzuB+lxSGCDwAAAAdFIQAGz3GAAGjLLImGIf0PUiHBAUW5JXjPcaAAiCQQoYog1gDPcaAA +xCd+GRiAz3CgANQLAdpSoATYEBkYgM91gADcyh+FSQieARSVQQhfAc9woAAsIA+AmuitccYNr/lW +JUAVgBUAEJS4gB0AEB+FkLgfpQzwz3GAAGg7D4EB4A+hENnPcKAAkCM9oHkFr/QZ2OB48cD2DK/0 +ANkIdgGAwbiD4MogQSAF8mIOIADJcBpwTCAAoMT0EIZRIICBwPIQhs91gADcyg8IngPPcIAA1CEF +iA3wEIYPCN4Dz3CAAOQkGYgF8AWGJoYaCM/1mB0CEIAVABAEIL6PEHAAAAf0rXEiDa/5ViVAFRGG +z3GAAHQHAKFBKAEDUyHFAJgVgRBBKAYFFGkFIEQBDwneAR6FlbgepXnwng1v+08kQALrCBUEz3GA +AOyjmBWDEPAhAQBAKwIGhiP9D1IjwwFFu2V6z3OgAMQnQRuYgADajLoCJk8A+mLLutdyAAAACEAt +DwOQv1L3BSePEWIb2IOMIgKAx/fPcYAA3DwSgQHgEqEA2Z25RfDleWIbWIBZDoVwAADADw4igw8A +AAAQz3KAAEyjFnoggiULNQgEEgUAANgPIMAAYbhOIw8IASnCA3h5BXkALcAABXoX8EIjAwgA2A8g +wABhuHh5BSECAIoh/w8L8M9zgADcPBODiiH/DyhyAeATowHYz3OAAOyvAKsCGwQBIaNCo73xANmc +uYAVABAleIAdABBAJgASoB0AEALZz3CgAPQmI6Alhs9wgAB4ryGgnQOv9Apw4HjxwCYLj/QIdlUg +UAQNzKLB7bjRIGKAB/IEyIoOr/+YEAAAz3CAAFjLDIDPcaAAyB9k4B6hENgOoQHYFRkYgAGGg+j/ +Cx7AAYbBuIPg4vQAEAAgQcAEFAAxQSgRAxCGBhQTMYcIngENzIMI3gIQhs93gADcyg8IngPPcIAA +1CEFiA3wEIYPCN4Dz3CAAOQkGYgF8AWGJoYWDo/1USDAgZgfAhAB3QryHocA3ZW4HqeKIAUJmguv ++6lxmBeAEM9xgAA0sgS4RpEFIEAEFQiAAM9ygADcPAmCAN0B4AmiBJElCIEPAAD//wDdDPDPcIAA +aDstgADdAeEtoFILr/uKIAUMAZac4Ib0BBASIAgQDyDPcKAA9CYC2SOgI4bPcIAAeK8hoJILIADJ +cIDggPQk7c9yoADELBwagATPcYAAaMvooiyJQCkDIxC5n7lleUErAyFleSaiDRIBNx0J3gIQ2qu5 +DBqcMA0aXDDPcoAAYDwnggHhJ6INEgE3DQkeAxrYrLkNGlwwpQ0QEM91gADclOAVAxBFhkQrPgcA +JUEeQKFMlgHjQrHPcoAAaMvMiuAdwBDPcoAANLLIqQkZQgQKGcQEDBmABESS5KFAKQMjEL5BKw0h +xXule0qxz3WgAMAvRx3YkJTiwCKGDwAAkwDPc6AAaCzwI4IAS7GPFQOWB/CjFQKWjxUDlhEKHwH3 +C96BB/AI2Azw57vKIyEAQMMBFIIwxrvGulipealVAa/0osDgePHA4cXPcYAAgCEjgUiBWQoeAIYg +/wHPcoAAHGVDuApiANuA4sohwQ/KIsEHyiDhB88gIQPKI4EPAABvAMokwQA0BaH1yiUhAM9wqgAM +UBMKtAC5gYC9uaEB2SWgBPCgvbmhZaAZAY/08cCiCI/0CHUNzFMgQIAH8gTI+guv/5gQAAABhcG4 +g+DKJiEQBfL2CSAAqXAIdsMOERAQhQkInwEA2U7wDMyDCN4ADcxTIECADRICNiL0ACKAD4AAFMoB +2c92gAA0OiCoEY5RIACAbAuiA8ogQgARjiEIXgHPcIAApDkDiIroiiAQDxPZLgmv+4u5RgugAQTY +ENgMGhwwz3GAAOQ7F4EB4BehA8gNEgE2hBACAc9wgAAIyjV4KYBZYSmgGt6+8c9wgABoOy2AAeEt +oOoIr/uKIMUJAdnPcIAAICAB2kCoz3CAAFjLToAGggHgBqIC8AHZAtrPcKAA9CZDoEOFz3CAAHiv +gOFBoCwMggIFAK/0yXDPc4AA3MpYE4EAANqO6TyTYrkQuUUhQwHPcaAA9CZjoc9xgAB4r0Gh4QAA +APHAZg9P9Ah2AYDBuIPgAN0F8s4IIADJcAh1te0Qhk8IngEMzM9ygADsOjEIXgFA2AwaHDBVEgAG +z3GAAIzJAeBVGhgADcgA2hR5A8hAqYIKr/+YEAAAC/CsEgEAAeGsGkAAFgiv+4ogBQrPcIAAICAB +2SCoz3CAAFjLLoAGgQHgBqEC2c9woAD0JiOgI4bPcIAAeK8hoD0Hb/SpcOB/CNjxwMIOT/QIdSh3 +JJXKD2/7iiDEC0EvDhHDvs9xgADAa9Z5Ew4QEgGVQYEE4FBwCNgE9CCBYHmpcPEGT/TPcYAAWMss +gc9yoADIH2ThPqIQ2S6iAdkVGliAIYCE6f0LHsAhgMG5IQnRAM9wgAAgIAHZIKjPcIAAWMsugAaB +AeAGoQDZDfAhgFEhAIAA2coh4QUBgFEgQIDKIaEE4H8ocOB48cAmDk/0z3aAAFjLAYYEIL6PAHAA +ADnyLykBAM9wgADcOfQgTQArhk8lgBBaDaABSYaU6IwlA5DPcYAA7DoI9LoRAAYB4LoZGAAf8LkR +AAYB4LkZGAAZ8AGGIQieB89xgAA0OgyJT4kbCgAAEYlRIMCAAAoBAgfwANnPcIAA7K8gqIYPwAQN +Bk/04HjxwJYNT/QIdgGAwbgA3ycI0QDPdYAA3MqPDxEQEIZ3CJ4BEIYZCJ4Dz3CAANQhBYgS8OIO +7//JcAh37fEQhhEI3gPPcIAA5CQZiAbwBYYmhroIj/WYHQIQEQjeAR6FlbgepR+Fl7gfpYAVABAE +IL6PEHAAAA/0nLiAHQAQMIauDW/5ViVAFUAmABKgHQAQANgFtgHZz3CAACAgIKi0FQEQBoEB4Aah +WBWAEJnorgsP+wXoEIbtuAHYAvQA2M9xgAA+y/QhAAA8lThgYrgQuIC4z3GgAPQmA6EG8ALZz3Cg +APQmI6Alhs9wgAB4ryGgEQVv9Olw8cCeDG/0ANkIdQGAwbiD4MogQSAF8goO7/+pcBpwz3CgACwg +BoAQeEwgAKDPdoAA3MrKJyIQVvQwhWUJngE8lhMJAwAlhc9wgAB4rwKAtwkBABCFDwieA89wgADU +IQWIDfAQhQ8I3gPPcIAA5CQZiAXwBYUmhaIPT/WYHgIQgBYAEAQgvo8QcAAACvTaCg/7C+gQhRMI +XgMB3wjwAN8Y8FYPz/sU8ADfMIWODG/5ViZAFYAWABCoFgEQnriAHgAQQCUAEqAeABDZCV6CAdnP +cIAAICAgqLQWARAGgQHgBqFYFoEQz3CgAPQmmunPcYAAPstclvQhwQNZYWK5ELmAuQ/wtBYBEAuB +AeALobQWARCKIEULogxv+yuBwvEC2SOgJYXPcIAAeK8hoNkDb/QKcPHAdgtP9M9wgAA4FguAEOjP +cp8AuP8dos9xgAAEIASBAeCzuLW4uLgEoRaiz3CgAKggCIDPdoAA3MoRDZ5Tz3CAANQhBYgN8A8N +3lPPcIAA5CQZiAXwA4aODm/1JIaYHgIQH4YTCB8BDw1fUwsNX1KA2JgeAhCYFoAQGwjeAV+GPoaz +upW5l7o+pl+mANkB3RbwnBYBECUJUQA/hlEhQILPcYAAgCEjgSmBBfJEIQ0EBfBEIQ0CA/AB3QTZ +GLgleM9xoACIJBChH4YzCJ4BFJYrCF8BFg3AAZHoz3CgACwgD4AF6A3MFwjeAR+GkLgfpq1xFgtv ++VYmQBWb7QsKnlOWDkABFfBEIj7Tz3GAANzKD/QBgRsIHgCYEYAAz3GAAJDWArgWeABh/rgAC4L7 +z3CgAFAMAIDPdoAAsAcE2c91gADcygCmz3CgAJAjPaAfhQ0I3wQPhYDgANgv8k1xKgtv+4ogRA43 +hYoVAhEAhgTiGWELCJ9E/wkexs91gADcypgVgBDnuADbCfQCuM9zgACQ1hZ4A2Mtu8C7ihUAEU8V +jRDPdoAAgCHwJsMQQnmieHIOb/tPky0CT/TgePHA4cWhwQDYQMDPcYAAaDsPgQHgD6ED2c9woADU +CzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoM91oADEJxUVAJbPcZ8AuP8WoTEV +AJYWoRDYEB0YkMoKL/uLcJfoABQFMBsNnwAKIcAP63IN2Iy4iiNfB6kFb/WKJIMPBNkTHViQG9kW +HViQnQFv9KHA8cDPcIAAxK+eDK/1GNnPcIAAxJ+SDK/1GNnRwOB+4HjxwPoIT/QacM91oADUCxCF +AN+hwUDHIQhQAAohwA/rcg/YjLiKI5YIiiSDD0EFb/UKJQAEz3Cg/jwCz3afALj/FqZYHgAUz3Gg +APxEGYEEIL6PAAAIIAP0HYETCNAkFgov+4twgODKIAIgQiDBIJThbAENADImQXCAAABgQCcAcjR4 +AHjPcYAAWMtOgQiCAeAIog6BCIAWpvYLwAAA2ShwSfDPcoAAWMsuggeBAeAHoQ6CB4AWpvTxz3KA +AFjLLoIMgQHgDKEOggyAFqbo8c9ygABYyy6CAoEB4AKhDoICgCbwz3GAAOQ7BYEB4AWhIPDPcoAA +WMsuggOBAeADoQ6CA4AWpgHZANgV8M9xgADcPBqBAeAaoRamGgtgAwHYvvHPcYAA3DwUgQHgFKEW +pgHYCHGA4awLggDPcIAA3MofgBUI3gTPcIAACKPrqM9wgAA8oOywA9gRpeB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB4EaXlBy/0ocAYhs9ygABYy5C4GKYYhrC4GKYuggWBAeAFoQ6CBYAW +pk4IAADF8c9ygABYyy6CBIEB4AShDoIEgPPxz3KAAFjLLoIRgQHgEaEOghGAsPHPcYAA5DsOgQHg +DqGV8QohwA/rckHYjLiKI9gHIPHxwBIPD/TPcIAAWMsMgM92oADIHxDdAd9k4B6mrqYVHtiTz3Gg +/uQBz3CfALj/NqB+D6AECdgD2B6mrqYVHtiTBfDaCS/7iiBVDs9woAAMJAeABOjvCx7AIQcP9PHA +z3CAALgW5gmv+wHZb9gGuJ4Jr/sI2QfYCriSCa/7BdnRwOB+4HjxwOHFz3GAAIAhI4EpgVEhQIDK +IKIAJ/REuM9xgADMOcO4CWEJCR4ANQ2fUTUJXgDPdYAAgCEDhRiIIQhQABYNz/oI6M9wgADIJAiI +DQjQAQOFGIgNCJEACQ2eUQHYA/AA2KUGD/TgePHAIg4P9EQiEFNNdoYm/BNNcE1wBCWAXwAAACBB +KH6DBPLKDM/6hOgA3wPwAd/PdYAA3MofhQsIXgQA3Zrw/wgRoKoMz/of6M9wgADIJAiIh+DMIGKC +F/QBhYwg/48T9CSVz3AAAP//GwkBAAWFjCD/jwn0DJXXcAAA///KJWEQePLPcIAAgCHwIMEDCYEP +CF4Bz3CAAMRlBPDPcIAA0GU4iSpgQS4AEc9xgADcZQhhFnrPcIAAQGxIYA8IHgA/hYYh9o8V8g0I +XgA/hSMJngIJCJ4ACQ0eUgHdDPATCN4Az3GgAAwkMYGMIf+P9vMA3VEggIHKJSIQ8gvP+gfoBCW+ +3wAAACLKJWIQJ+3PcYAA3MofgR8IHgKMJgKQzCaCnwAAUADMJoKfAADQAAP0k7gfoc9wgACAIQKA +whAABhrojCYCkMwmgp8AAFAAEvRPgUV4D6EN8M9wgACAIQOACYAPCF8AjCYCkAT0CQieAQLdFQUv +9Klw4HjxwKIMD/TPcIAAOBYAgKLBAN4Q6M9ynwC4/x2iz3GAAAQgBIEB4LO4tbi4uAShFqLPcYAA +3Mreod+hwLHPoU8ZggOAGYADjBmEA4DbmBnCAIQZgAPPcqAAyB+kEgAA+BINAKwZgANCGYQDoniw +GQAAz3CAAFiV2aDPcIAAlMvAoATdz3CAAHQHoKCZEYAAoLiZGQIAz3CgAMQnZBiYg891AAD/fxMY +WIMb3RYYWIMaGJiDiif/H891oAD8RP2l+aWKJ5gdz3WgAFAM4qVxonCiPBiAg4ojGAhuooASAwCk +GYADUSNAgM9zgAB4r1gZggML8kIQAIYEIL6PAMAAAAXyAYMD6AKjwaOAGoADz3OAAOw6z3CAAIAh +Q4A1CZ5DH4GLuB+hVSPABbQZAAAK2ByxG5KWGQQAiiBEC4oML/sA2QbZz3CgAMgcKaAQ8EAjAAO0 +GQAAENgcsRqSlhkEAIoghAtiDC/7ANnPcaAA1AsQgR0IUQAKIcAP63IL2Iy4iiPVAIokgw+ZBy/1 +uHMB3bChFQhfRs9woACoICaAB4C7AiAAA93PcIAA3Mq0EAEAAIEB4ACh+tjWCq/7ANkg2M93gAC0 +y8YMIAMApwHYz3GgAMgfE6HPc4AAJCAIg0AnEBVAgAyDABAEAASDz3OfALj/ABAFAPgRAADPcaAA +MBAhgTajz3GgAAwkJ4ECIgKANqMA2QMkQwACJQEAz3CAANzKUBiEA1IYhANUGIQDI6fPcIAAgCFB +pyOAYqcUkc9ypQAIDAm3CIHAuAi3ABIEAM9ygADcylMkRQFMGkIBUyRCAIPiyiHBD8oiwQfKIGEF +yiOBDwAAnAuoBiH1zyAhAwQkgw8AAADgz3KAANzKLbuaGsIAX4IUHwARGQreAgS7gbtleAi3B9gH +8BUgDCDApAPwBNgB4PUIFIIIgeu4kA7CBM9wgADcyh+AK7hTIBAAUSCAxaryz3GAAMwnBoEB4A94 +BqFBKYBDz3GAAMwnRoHPcaAAtA83gcC4AN0VCkEAz3GgAKggJoGMIYOOxPcD3aDwCQgABATdnPDP +c4AAtMsFg89ypACQQfWCNoIEIIAPAAAA4C2456PPdoAA3Mooow0IHgBQHsQTCfBQHkQTBCePH/// +AADnow8IXgAwv1IexBMF8FIeRBPwf+ejDQieAFQeRBAJ8FQeRBMEIYEP//8AACijDYIGowQggA8A +AAD+KbhWHgQQH4ZHCN4Cz3CqAAAEBIAJo89wgADEnyCIRGg16WEJdAACEIQAn3EA2KgggAP0Ig8A +Fd0TvfAlzxPPdYAAtMoVfQHg4KUc8M9wgADEryCIRGgZ6QIQhACA4cokTXDKIC0A6CCtA/QiDwAp +3RK98CXPE891gAC0yhV9AeDgpSGrAhsCAbQWARAC3QGBAeABoRbwBCC+z2AAAAAI9IoghQeSCS/7 +DBIBN27xEQseQIogxQd+CS/7ANli8WoL7/rx2IHlPfMxDZEQAt0EIL7PgAEAAMolohEF9FEjAMDK +JeIQ7Q2QkM9woAAwEAOAgODKJWIRhuU0BAIAz3aAANzKHJZCIIQAH4bruC8kCAF88s9wqgAABKKA +z3GlAAgMIIEEJYIfAAAA/yi6BCGBDwAAAOCJujt7RXvPcoAAtMtypqyibaIggEgWjxCU5yqiGvIF +9jUPkRIjuQ3wHw/QHe7nEvRFKf4CQSnBcFElwJHCIWIAB90K8EUp/gJBKQFx+/EiufnxANkI3QGA +N6YLojyyHQkRBc93gACAIeOH6IcEJ76fAAYAAATyjLtypuS4yiUiEuG4yiUhEoYg/g9BKAMBTR7C +EAiSZXgIsisN0RElCbQDB93PcIAAgCEDgIQQAAARCEQAz3CgADAQCIAHCQAACN2H5cogAQEoD2H7 +yiEhACkDAADPcKYACAQBgAQggA8wAAAANLhCHgQQQhYBERsIX0bPcKAAqCAIgBlhMHnODm/7iHAE +8O4Ob/uIcAQggE+AAQAAANkzCIEPAAEAAAHYTh4CEM9ygAC0y5oWgBBCHkQQTR5CEDemKaIEuCiS +ibgleAiycvBNHkIQz3CmAIwDPYAEIYAPOAAAAEEowgSaHoIQBCGCDwAAAPAsuiW4RXjPcoAA3MoS +pgsI3kcSgoy4EqJTIc4CSBKDANei4LvRIeKHB90C9Ajdz3CAALTLKaCaEoEA6JAEueV5KLDcsDKC +LaB/DdERz3GmAIwDvYEEJYEfAQAAADC5ThpCAKmgThKAABzoWQtRA1EIH0YU2M9xoADIHx6hENgO +oQHYFRkYgArdUSAAxsol4hFRIwDAyiUiEvMNkJIV8CUOlBPPcIAAgCEDgIQQAAAVCIQDz3CgADAQ +CIAJDgEQB90D8Ajdh+Xk9M92gADcyk4WgBCA4N7yz3KmANQELBIBgDQSEoA4Eg+AyxIQBkpwxrjp +coYi/Q8GukV4SnKGIv0PBLpFeAQhgg8CAAAAJ7pFeEQnAhwNukV46XKGIvMPBCGBDzgAAAAOuiW5 +RXgleEQngRAUuSV4iLhEJwESQSnBgFIgQAUSplgeQhDKIYIPAAD//8ohgQ8AABAfOnE3hkAeRBAE +IoEv/wMA/yi5N6aeCS/5ANqsHgAQcw+eFEgWgxAyhqDj0SHhgjHyBCGCjwAAAAEH8kQhDQYjvQHl +Fw2VEAQhjQ8AAAAkQw2AHwAAACQEIY0PBgAAADG9Lw3VEBMNkRAT6kQhDQYjvQHlHw2REATqzOML +9leGMnLKIo4PAQCIDcwgjoDN9xcOBXABAIgNz3GAANw8HIEB4ByhCN0y8IYh/wlBKc0Az3CAAEQt +IIAB5WB5BtgtCEQDz3CAAIAhA4AIgAQgvo8ABgAAANnKIWIAEoYEIIAPAAAACCu4EwkFAPIMAAAI +dZTgyiXiEwrwz3CgADAQCIA3hhBxB93KJWISWBaCEM9xgAC0ywiRB7qIukV4CLEXhjAZAAQcsRKG +66ENoawWABAoGYAEHbELDdERZggAAAh1gOXKJSEQgOXoCqL/yiBCAwDYz3GgANQLEKHPcIAAaMsN +iBEIHgDPcKAAiCQegAsaHDCSDkAADMyGIPmPCvSE5cwl4pAG9ADYj7gMGhwwMtnPcKAAyBwqoOUD +7/OiwPHAjgvP889woADUCxiAQiAACEggAADPcYAAzCclgYHhiiGZDgj0z3GAAIAhI4E+gYAhmQ4Q +cQDdyiVtFHMNERDPdoAA3MpYFoAQgODKICIAIfQMEgE3JQneAA3MUyB+gAzy67gXhgbyoOAB2MB4 +CfCO4AHYwHgF8CUJXwEA2M9xgACAISOBKYE9eVIhAQDAuSR4COgfhpG4H6YL8BeG6vFaDAAAWBaA +EIDgNAsBAIDldAICAM91gADcylgVgBAU6ALZz3CgAPQmI6DPcYAAeK8A2AGhwNmZFYAQgLiZHQIQ +KHAD8ELYz3GgAMQnvxkYgADYDBkAgAHYEBkYgB+F8bgSAgIAEoU3hQ4P7/gA2qwdABAfhbUI3gLP +cIAAgCFDgEgVgRAUgiR4RCADAUQhAAxCKAQBgHPPcIAANCLBu2hgibgcpXAVjhD0gk0VgBDEf4Ym +/xMEf0S+32fPdoAAdGX0Js8TYh3EE893gABYJWtnibt9pXSCdBWPEOR7hif/EwR7RL/7Y/QmwxBk +HcQQcoV6pVSCe6VEeSR4z3GAAIRlgHD0IQIAz3GAAKxl9CEAAI4dhBCQHYQQkh0EEJQdBBAA2E4d +AhCZ8E4VgRDPcIAAZDkAgMC4qQkQAIDgANvKICIAC/RyhUgVgBAEI4MPAAAACHt7wrgAII4PgAAo +IjCO2I7HcIAAVCXPd4AAhK9IiGV+3KVwFY4QZXnDvtx+9CeOE2V6EIhiHYQTBXt9pXQVgBDDuBx4 +9CcAEDqlz3GAAJSvZB0EEGgVgBDDuBx49CEDAFuljh3EEM9zgADcr/QjAACSHQQQbBWAEMO4HHj0 +IQEAkB1EEPQjAAA98IDgANgF9EgVgBDDuBx4z3GAACQiCWHPcoAAhK88pXAVgRDDuTx59CJBAGId +RBDPcYAASCUIYR2ldBWAEMO4HHj0IgAAz3GAAJSvUoVkHQQQSBWAEMO4HHj0IQMAWqXPcYAA3K/0 +IQAAjh3EEFulkB3EEJIdBBCUHQQQbg/AAM9wgACAIQOACIAPCN4CThWAEIDgWAuCBFgVgBAF6G4J +D/8D8CINAAAIddEA7/OpcOB48cDhxc9xoADEJxURA4YE2BMZGIAb2BYZGIAD2s9woADUC1Gg4Hjg +eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhRoOS7yiWiFSn0UhEAhuC4yiXhFSPyCwheAAsL +3gAS3R3wAdnPcIAAICDPcoAA3Mq0EgMAIKgGgwHgBqMfghEIngPPcIAAjAYgoAjwDQjeA89wgACQ +BiCgFd2KIAQM1gjv+gDZMQDv86lw4HjB2BQaAjDPcYAAgCEDgRiIAdvPcoAA3MqG4BeCwiPBAAzg +GCDAAGYaBABmEgABA+AEIIAPAAD8/524n7jscwCjBcjscwCjA4EYiDeChuAB2MIgAQAYIQEA7HAg +oOB+4HjxwFIPj/PPcIAA3MoygCcJXgLPcYAAgCEjgUgQggA0gUR5USGAgEjayiKBDwAAkAAC8A7a +AN/PcaAAqCAngawQDQBZYbFxwiVFEMol5hKweN4OL/sK2c9wgAAANQCQz3agAMQnCwgeAYwlA5ID +9wDdGfAiDiABANjPcKsAoP/6oHoL7/0A2BkWAJYF6ALYEB4YkM9xgADcPBuBar24YBTdG6EZFgCW +iOhRIQDGQA8hBMogYQAFB6/zqXDgeOHFz3GAALTLQYnA2xQawjDPc4AAgCFjgxJqR+AEIIAPAAD8 +/2mDKrvAuxe7x3MADgAAZXjscwCjBcjscwCjSiTAcwDbqCDAAfAhzQDscKCgAeMdCnQAANnPcIAA +tMrwIEMA7HBgoAHh8QmEgADZz3CgANQLLaALzAHgEHgEIIAPAAD/v4+4CxocMM9xoACIJB6h4H/B +xeB48cD+DY/zz3eAANzKQJcIdkhxhiH8A0IpBQFEIggDjBcBEUIoiBBA2M91oADQDwojQIAQHRiQ +yiNiAKwXABBAK4YFz3OAALTLLyQIAB2zOBMHAUAsBAQFJwABDB0YkGGLArtI4xAd2JBmFwMReWEw +eWYfRBANCp8CDpdTIMCAEfLPcIAAgCEDgAmAUSAAgD3YwCjiBcogoQfAKCEGCfBAKAARoHDPcoAA +wCAIYhe4A+EEIYEPAAD8/wUggAEleJ24n7gMHRiQC8wB4BB4BCCADwAA/7+PuAsaHDAOHZiTIBUA +ls9wgACAIQOACIAhCN4CHQ4fESYIoATJcM9wgADwy6DZxNo9234IIAEXu1kFj/PxwOHFz3CAAJgH +AJDPcYAAhLmo2gHdgCBECxB4/g8v+6lzgODKIcEPyiLBB8oggQ8AALUUyiOBDwAAzADKJCEAHAHh +9MolAQGmCEAAz3CAAMQuFQWv87Sg8cDWCyABANg+D4/3TgoP/loNj/sqCe/9ANj/2c9wqwCg/zmg +OKDRwOB+4HjxwOHFz3GAAIAh8CECAEokQADDEgEGD3gyIoIPAAAfAwQhgw8ABgAAgOMB28B7BCGN +D0AAAADXdUAAAADCJAIBYg+v+8C5nQSP8+B48cAiDI/zrgjgAQh1z3GAANzKH4GwuB+hz3CfALj/ +WBjACM9znwC4/1gbAAjPcqAA0A8Qgs92oADEJxajz3CAAMwnBoAWoxkWAJYA2QToAtgQHhiQGBpY +gMYPgAD2DqACAdgF7UoPAAAF8CoPAADqCw/7GRYAlgXoAtgQHhiQEQSP8+B48cDPcJ8AuP9YGAAI +z3CfALj/WBhACM9wgADMFvYO7/oj2cYMT//RwOB+4HjxwK4KIAEB2ADZz3CAAGA8LqCuCu/1GdjR +wOB+8cBKC4/zosGLdr4Mb/rJcAolAJAZ9M9wgADcys9xoAAMJDuBV4AwcsolIhIghg0JHgQC2YwY +RAAEJYJfAABwxz+ARXk/oIDlxAMCAADA6bjW8s91gABYLQCFiiEIAOSQz3agAMQnEx5YkM9xgADc +yj+BOneGIfwjhQleBEEpASHDuc9ygADAazZ6IIJAeQh1GRYAlgToAtgQHhiQz3AAAP9/Ex4YkBvY +Fh4YkAPZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgz3CAAFiVGYCA +4GQPwgCa5SQDAgDPcIAAiONuCeACAN0VAwAAygtv/ypwGnAAhY4LL/8qcSYML/8Id4jnzCfilcol +wRMr8hsIECD2CiAAgcAKJQCQHPQqDO//AcAY8APZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeDGgAN0PD5EWz3CAAIjj8gjAAoDlmAICAG4PAAHPcIAA3MofgBEIngMB2c9w +gACMBiCgCfAPCN4DAdnPcIAAkAYgoBEWAJYA3UHAMQifABoLb/qBwAolAJAQ9AQUBTAdDZ8ACiHA +D+tyCtiMuIojxwrxBa/0iiSDD4DlNAICAATYEx4YkBvYFh4YkM9wgABYlRmAgOBQDsIAFQIAAOC4 +xvLPdoAA3MoShoYgOgCMIASC1A4FAc9xoAAMJDyBF4YieGS4EHiKHgQQRCIAUxcIEQIfhg8IXwRR +JUDRAdgF9ADYA/DuCk//nB4AEC7olg0P/wolAJDc9A3MIQjeAR+GHQieAS8ghwqMIAKGCPTPcYAA +3MofgZi4H6GeCSAAgcAKJQCQxvTPdoAA3MofhisIHgSoFgEQ1NgiCOAAyXIH6JoKAAQL8PoOD/+x +8M9xgABYPR6BAeAeoQHfz3CAACAgtBYBEOCoBoEB4AahH4bzuAQOgvoPhoDgEA2C+h+GEQieAwHZ +z3CAAIwGIKAJ8A8I3gMB2c9wgACQBiCgANjPcaAAyBwHoTDYCqFOCu//AcCKIIQNVgmv+gHBH4Yp +CB4GENgMGhwwz3CAAIjjNg+AAg3IACCBD4AAFMofhuCpuLgfpgCWhiD8AIwgAoAb9NoOD/qX6APZ +z3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgAJbSDa/8NJZE8EHAFd8J +CN8A6XUg8AjYz3agAMQnEx4YkGIIz/8IdS0IEAUC2DweAJAhFgGWz3CAAHivIaARFgCW0QifgAIJ +b/qBwAolAJDi8z0NURXPcKAAkCMegAQUBDBRIICAyiHBD8oiwQfKIGECzyAhA8ojgQ8AAOQExAOh +9MolIQDuDq//iHAIdalwnQdv86LA8cBCD0/zocEIdgDYQMAApqIIb/qLcAolAJCF9M9woAAEJSKA +AIYEIYEP/wBf/wUhAgBAplMhggBTIIMAZXqlCtEBz3CAANzKH4B5Cp5TtwifBgQgvo8AHgAABPQA +hgnwAQqfQACGCwoeQIW4AKbPcoAA3Mo/ghEJXgaIuIu4jrgApkHwKQneBk8gAQKJuY25i7mOuSCm +HoIEIIAPAgAAAFIgQAQquCV4AKYt8Py5xSCCDwAAAAXk9YUgHAAApiPw9bgAhh/yhiAcAIUgGAAA +pgEKH0EAhi8K3kCGuACmE/BTIQMAUyACAAUjvoDKJeEVCfKGIX8PhiB/DwUhPoDKJaEUz3CAAGjL +DIjEuEAoAQYAhiV4USCAxACmwA7iA8ogIgipcIkGb/OhwOB48cDhxQDdBdgLuOYN7/qpceYPT/TP +cIAA3MofgBUI3wLFDRURwQhfRZ8IH0UB5U7wANmcuc9woADQGzCgAdnPcKQAmEA8oAXYB/A+CQAA +lg7gAwXYAdiODsADYw0VEQQgvs8wAAAAAeXKJSIQLQsfQAkIXkVHCZ5DMwgfR9kI3sXVCZ7Dz3Cq +AAAEAYCGID8LAN27CNGAE/DuCAAAz3GAAGA8DoEB4A6hCfAA2Zy5z3CgANAbMKDSCAAAANnPcKQA +mEA8oBDwAN0NCx9AFg7gAwHYqPGyCAAAz3GAAGA8DoEB4A6hpQVP8+HFDMxEID6KSPJXCN4AgNgM +GhwwDczPcYAA5DvPcqD+WAHPc58AuP8A3REI3gIdgQHgHaFIcAfwFYEB4BWhQCIADRajDcwPCN8A +z3CgACwgr6ANzIYgggINGhwwHvA9CF4BiiAEAAwaHDDPcYAA5DsUgQHgFKENzADZRiCAAg0aHDDP +cKAALCAvoM9xoP64Ac9wnwC4/zag4H/BxfHAzgvgAAHYbgmv8wPYJggAAL4L4AAB2NHA4H7xwOYP +z/9eDs//ogzP+tHA4H7gePHAYgxP889xoAD8RAWBAN68uAWhigvgAMlwA90qCa/zqXDPcaAAMBCi +oc9wgADMJ6KhnQRv88ag8cDPcKAAtA83gM9wgADMJwaADQkBALYPz/8E8JoPz//RwOB+8cD6C2/z +ANkH2BpxOnAA3kAoACEUeMdwgACEuRUgjQMAlYwgAo0A34T2jCCFgsn2/9gAtYogEQPeDG/6/9kB +nQsIUw+MID+BR/bhtYogEQPGDG/6ANkB5s9+uQ4Sk0IhQCBAIEEgpwh1gC957QNP8/HAlgtP8wDd +z3CAALyuSgov+rSoEugI3oDlzCWikMwlIpHMJWKRqA1i/sogQgNhvukOdZAB5R3wiiQBcc9xgACM +yagggAEEGVAD4HgA2UokAHLPcoAAOMmoIMACFiJAAGKQz3CAAATKNHgB4WCwz3WAAIAhz3aAAACv +QCUAFyRuWghgAQbaQCUAFUAmgRJOCGABBtpAJQAXQCYBFD4IYAEG2iwVgBAhCBEBiiAPCvoLb/qK +IVsFPBWAEPIKb/4thSoPj/kOhRcIXgGKIIcO2gtv+ooh2wiWCEACigkP+oDgjA7C/89xAAD//89w +gADM4Cygagsv+iugCQNP8/HAmgpv8xTZz3WAAHgl2NwODq/0AiUAE89wgADEJwIOr/QU2c92gACA +IUAmABUApsDcAiUAEwGmAN2pcKlxkgvv8wbaAdipcYYL7/MG2gCGSiSAcKlxAqYDpqggwAUVJkIQ +YIKKIMYNDbMAggHhqaAAgqmgAILAGFgDAILBGFgDAILCGFgDG9nPcIAANDp5Am/zLKjxwO4JT/Ma +cDpxSHYeCC/6mnMIdQQmgB8ABgAAgOBKIkAgwiKCJAQmjh9AAAAA13ZAAAAASiNAIMIjwiTPcIAA +rAbEiADf/gjgAOlwjO0D3i8hBwQvIkcEyXBKc94Mb/sKJMAEyXBKDW/7inGE7ToJQAIE8GoJQALP +cIAAzCcEgCEIngDPcIAAnDkAgIroOdjmD+/5i7gNCFEA3gzP/w3wANmeuc9woAD8RCGg4HjhoJII +4AAA2I0BT/PgePHARglP86PBCHbPcIAAgCHwIIMDiicLFi2T/WM8eihwhiHxD8K6R7kkeoYg/gNE +uB8JgAAKIcAP63KD2I24iiPSDUokAABxBW/0CiUAAUiDf2c7ulMiAoBAr02TwLpBrQvy95OGJ/8Z +Q7/nrXeThiP+B0W7aK0c6s9ygACwORUiAwAAizV6Aq0Bi89xqqqqqgOtAosErQOLBa0Digatvglv ++oog0A8eD2AAAo2LcKlxWglv8wzaAMABwd4Lb/QCwotwqXFGCW/zDNoAwAHBsgtv9ALCz3GAAEgH +AKHKDKADyXDNAG/zo8DxwGIIb/NX2M91gACAISOFz3KAAEwHd5EAogsLHgBf2ACiCwueAIW4AKIL +C14Ah7gAooomCxbLYdlhANqA48oggQDPcqUA6A8GogCJz3GgAKQwgOABgc8g4gDQIOEAAaGuCk/3 +A4XPcaAAyBxPgALgSKGGDeAAyGADhY4Mb/0OgE0AT/Phxc9wgACAIQOAKYBEIYOAANok9IkKFQQA +Io0PgADAIACNoLgArYAVgBCguIAdAhBAFYAQoLhAHQIQEI2guBCtkBWAEKC4kB0CEFAVgBCguFAd +AhAB4uDxRQoVBAAijQ+AAMAgAI2AuACtgBWAEIC4gB0CEEAVgBCAuEAdAhAQjYC4EK2QFYAQgLiQ +HQIQUBWAEIC4UB0CEAHi4PEjCZ4Bz3KAAMAgCIqAuAiqiBKAAIC4iBoCAEgSgACAuBDwkuvPcoAA +wCAIiqC4CKqIEoAAoLiIGgIASBKAAKC4SBoCAADYPwkeAEokAHTgeKggAAYrCJ4AACCDD4AAwCAg +E4EAgLkgG0IAoBOBAIC5oBtCAGATgQCAuWAbQgAB4BzwSiQAdOB4qCAABisIngAAIIMPgADAICAT +ggCguiAbggCgE4IAoLqgG4IAYBOCAKC6YBuCAAHg4H/BxfHAfg4P8892gACAIRpwCwhRAACGAvAB +hsQQAAYVJg0UTCAAoAHfJbhTIAUAIIXAf0AhAAbEEQEGGwlfAQohwA/rcoHYjbiKI40PqQJv9Aok +AASKIgsNWWAAFgNAWGBgoAAWAEABoQAWgEAIqQAWgEAJqc9wgADMJwWAEQhRAECFABYAQQ+yBPAA +FgBBABaAQAqpABaAQAupABaAQAypABaAQAAWAEEHsQAWAEEIsQAWAEB2Ck/9AIXIEAAGhiB/jkf0 +8CbAE8gQAAaGIH+OQfSKINMBwg4v+oohDgcKcE4Mb/gB2coKr/wvIAcEcgugAwpwz3CAAMgkLJAe +lg0JAAD6CU/5SwgBBACFxBABBgpwJbnAuToKL/UA2lYPgACJ6AvIBSCADwAAADwLGhgwRg+AAIno +C8gFIIAPAAAA1AsaGDALyJC4CxoYMLYLT/OGCw/4kQUP8+B48cAGDS/zANkKJACgocHKIWEAFPLP +cIAAzCcQEAUAHQ2fAAohwA/rcn7YjbiKIwgNaQFv9AokAAXPdYAAgCEVJQ4VAIYVJVIQJBAVAAAS +ASAgEBYAKBAXAUEtTyEpgRoQGAHAvyW5UyETAOILIAMN2YogiQCKcZYML/zpcsYKL/6KcACGCYAl +uFMgEACKcEYLb/gA2UwkAKAACcH/nwgQIA3vCiHAD+tyf9iNuIojiQdKJAAA5QBv9LhziiBQD4IN +L/o3lWIPAAFaCy/4AdgAhgiAEQgeACwVgBCE4APYA/QF2DpwNQsRIN4MT/tuDE/7iiCQBUoNL/qK +IckOz3CAAKQ5A4iK6IogEA42DS/6iiEJD0oPIAAA2CwVgBAZCBEBiiCPDhoNL/qKIQoAgNgeCq/7 +AdlKIwAgTfCKD2//inDiCi/4ANgsFYAQGwgRAYogjw7uDC/6iiHKA4DY7gmv+wDZIQwRIGIMT/ta +DE/7dg0P94oKz/mA4BQOAvcA2B/wCg4P93YKz/mE6KoIwAMW8M9wgADIJAiIieDMIOKB8PXPcIAA +2GEAgATZvdoe20DAi3D+DmAAGLsB2HpwAIYIgA8IHgAsFYAQhOAE2AL0Btg6cACGKIAUkAQhj48A +BgAABX8H8va5wieiEMAnoRAqcIpxagxv9elygODKIEIEWAxi9cohwgMNCxAgcgkP+J/w3gnP+QTZ +z3CAAMwnsg8v/SSgIIbIEQAGhiB/jkH0Kgiv/Ipw0gigA4pwABIAIMgQAAaGIH+OQPTPcIAAyCQs +kB6VDwkAAE4PD/ltCAEFinAKcZYP7/QB2n/ZEbnPcKAAsB80oBILz/meDIAAiOgLyAUggA8AAAA8 +CxoYMI4MgACI6AvIBSCADwAAANQLGhgwC8iQuAsaGDD+CE/zDPAkGUAFIIYgGYAFIIYoGcQFIIYa +GQQGKgnP+QnoANgLDBEgXg+AAwPwQg+AAwHdEg1gAalwz3CAAOwfbgxgAaCoKQxRIM9wgADIJAiI +ieDMIOKBA/QRCBEgEQgRAvIIz/kE6MIIj/QKCY/5YggP+ATKkODMIIKPAACzAA7yCiHAD+tyARIE +NpLYjbiKI40GXQYv9AolAAVSDCABANgBAi/zocDxwNIJD/PPdoAA4AYAhkogACCA4IANggHPcIAA +OBYDgADfEOjPcp8AuP8dos9xgAAEIASBAeCzuLW4uLgEoRaiDMyBCB4Az3OgAMgfsBMAAM9ygACA +IUOCAuBGEgEBYbkIIEEAPqMQ2A6jAdgVGxiAz3CAAIjfAxoYMM9wgABQ4OoJYAIEGhgwz3GgAPxE +BYFKIUAgvLgFoQzMhiD/gc9wgACgBgCAwiFBJIDgRAiC/QQgjk8wAAAAz3WgAMgfCvAxCF8Dz3Wg +AMgfCnYKIQAkz3CAACQgEIDPcYAA3DzsoQCADqHT8M91oADIHwDfz/A+DM/+z3GgAPxEBYG8uAWh +z3CAAGA8DoCMIAKNh/dSCW/1GdgGCKAAANgMzM91oADIH6sI3oME2AYaGDAfhYDgiiAMAMoggg8A +AAACDqUD2BW4Eh0YkACGgOAYDIIBz3CAAAQgAIAEIL6PAAAPOADZBfLPcJ8AuP89oMkAD/MehQwS +ATdjCF5FBsiGIPGPLfTPdYAA7DqIFQAWBCG+jwAAAFAB4IgdGBAE8gTYDBocMI4L7/4A389woAD8 +RCWAvLkloGsVABZlCIUPAAC0AM9wgAAEIACADwjeAs9wnwC4//2gSiBAIAzMVQgfAYsInwGGIP+F +xfJRIwDAsPJRIEDFrPQMzM91gADkO1EgwIDp8oDYDBocMA3M67ii8h2FAeAdpUogACCf8EYIb/UZ +2P4OYADpcHUCIABKIEAgDcxTIECAW/MEyAMSATYDGhgwLghgAgQaWDDPcKAA/EQlgM91oADIHwDf +vLkloM9wgACgBgCAFehv8AYIYAIA389woAD8RCWAvLkloM9wgACgBgCAz3WgAMgfvwgRAAbIBCC+ +jwOA6FNt9VEgQMVr9aoKj/o3CRAg34WgFQAQCSYAEOTgy/bPcIAAOMkAgA8IXgD+pYIIYAAQ2OTm +x/dAFQEWMHl2D2/6ENiKIAgAoB3AEw6lH4WF6IogBAAOpYIMgAAv2JW4Eh0YkM9wAQDA/BUdGJAO +DQACz3GAAGg3AIGH4NDyz3CgADguBYAEIIAPwAAAANdwwAAAAL/y9dgFuM9ynwC4/xqiB9gbomnY +GLgZogHYsvCyDU/9o/EA36jwFYUB4BWlz3CAADQ6EYhRIACAsAkiAsogYgAF7hyFAeAcpQzMAN+v +CN4BDcwEIIQPAAAAGGcMgA8AAAAIjg7P9w3MfQjeAM9xoAAsIAWBJoEK4F8JBAADEgE2AtgMGhww +UNheCi/+mBEBALYOAALPcKAA/EQlgM91oADIH7y5JaBH8YogBAAMGhwwFIUB4BSlSe4bhQHgG6XF +8b4LL/kKcA8IHgAI2Ju4BhoYMFDwz3WgAMgfBNgGGhgwQ/EDyKAQAADwuOlwGvLOCI/4ANiWuBTw +MQgeAkYIb/yKIAQA7g3v9+l1A8igEAAA8LipcAbypgiP+ADYlbgKCkADBNjW8c9xoADIHxMIXgKO +CK/4AdgA2JC48vEEIL6PAAAAUAryEQseQIogBAAOoQTYBhoYMA3MHQjeA0ARAgbPcYAAVMsvkQ0K +RACvuA0aHDDPdaAAyB/vBc//ANgJCFEAB9gAoc9wgADgBgCAgOCsCIIBz3GAANw8DIFNgQgiAAAN +oc9wgAAkIBCAT4FggA6BAnsAyggiwgBPoRkIEQID2c9woABALTCgXwTv/wAawjMB4FcE7/8AGgIw +4HjgfuB44H7geOB+4HjxwOHFFLgleM91oAA4LgalBfDCD6/5iiBcCAaF9wjehyEFz/LxwKYMz/LP +caD+nAMA389wnwC4/zagz3agAMAvpR7Ykw/dCL0F8IoPr/mKIJwCoxYAlqR4jCAQgPfzFB7Ykwbw +bg+v+Yog3ASjFgCWCyBAg/j1vQTP8uB4lODKIgUAhfcIcoAiwgTPcaAAaCzwIYEAANvPcqAAxCxn +omiiDLiduJ+4JXgGouB+8cAiDM/yCHZyD+//KHXJcEYP7/+pcXkEz/LgeOHFMNsA3c9woADIHGmg +A9rPcaAAzBchGZiATqGnoGqg4H/BxfHA3gvv8gDZz3CgAAwkWIDPdYAA3MqtcEEqhgeGIPcPmBWD +ECm4dnnAccdxgAB43hV5ABGEAM9wgABYFyCAQCzOANV+0GHZYUQgj4BTII4ABCKADwAgAADMICKA +BvSA58wgIYAA2AP0AdjPd6AAxCdAKwUGhiP9D1IjwwGzDDMERbuA5swgIoBT8s9wgACsbPAghwNA +LoYDBSbGAQUlgAEFe0Ef2JBRDpEQH4UQ2pq4H6UI2E8dAhDPcKAAyBxJoAeBz3KgAPAXBqIGgQai +BYEGogSBBqIA2AqiihUAEWi4EHiKHQQQAJWGIP+MKPQB2B2iJvBOFYAQouiKFQARTKVkuBB4ih0E +EATZTx1CEBsO0RArFwGWZLgQeIodBBAM2C2lTx0CEFINb/mIcAjwBSNDAUEf2JAfhbO4H6UJA8/y +ENrPcaAAyBxJoQHbz3GgAPAXaqGkEAIATQreAgLaXaHPc4AACNVEg0ahQ4NGoUKDRqFBg0ahcBAA +ARzgUyDAgAT0QCMACATwQCMADECAU6FMaECCU6H4EAKCU6H8EACAE6EP8FyQhiL/jAP0faFIgEah +R4BGoUaARqEFgAah4H7hxS+Az3OgAPAXz3KgAPwXKKNAEAEBKrIxgCijSBABASqyM4Aoo1AQAQEq +sjyQhiHzD4whDIAH9DaAKKNcEAEBKrJwEAEBvJAI4aiyvZCoslQQDQGosmAQDQGosrmAp6O6gKej +u4Cno3IQAAE4YBB4CLLPcKAA9AcnoALZz3CgAMgcJ6Dgf8HF8cBeDw/5wgpP+dHA4H7gePHAignP +8s9xgAAABs91oADsJwDeHQgeAADYl7gRoQHez3CAAEYEBqWKIBEAC9kK8NGhz3CAAEcEBqWKIBEA +CtlaCs/5FW4QeBC4gbiHuIy4BqWlAc/y4HjxwC4Jz/LPdYAA3MoXhc92gAAY3wsIEAZYFYAQBOga +hVuFBPAchV2Fz3GAAGQ5IIETCR8AMoUEIYEPAAAAECV4JXrPcf7//z8keAGmAN/ipkR5LaYO2J4P +b/kOpgfoz3GAALgkgg5gAAHYz3GAAJQhdg5gAADYF4UPCBEFAdgBrjEeAhAE8OGuMR7CEwkBz/Kh +wfHAjgjP8jpxCHZIdwYKL/sA3YHgyiBCIwv0z3CAANgfAJCB4AHYwHhAKBADyXCGIPwAjCAChSP0 +z3CAANzKmBCAAOe4yiAiAAr0ArgWeM9xgACQ1gBhLbjAuM9xgAB0ByCBUSGAgM9xgABUyxR5BPIg +2q2RCvCY2quRBvDPcIAAGMuzkA7aAZdAJQEVEQkDAKJ4SCAAABB4A/AA2FpwANgqcalzQg5gA5hw +CiEAoAT0PgpAAzpwTCEAoADYTfQFIIAjDXEAsQ1xABmEBCOHDXAgoCiXDXAgsIoghQDWCO/5yXGM +JgKVFPKMJgORHvKMJgOVI/IKIcAP63IT2Iy4z3MAAJQKiiSDDwUE7/O4c89wgADcyrQQAQAPgQHg +D6HGCSAA6XAT8M9wgADcyrQQAQAOgQHgDqEJ8M9wgADcyrQQAQANgQHgDaHPcaAA9AcA2AShAdga +cM9xoADIH/gRAgBCdQIlgBBIIAAAX4EQeDsIhABDh89wgAB4r0KgoNgPoQDYH6HPcIAA3MockGK4 +QnAfoQLYFRkYgA8JECBRIEDGINgC8oDYDqGMJgOVB/TPcIAA3MockAjwjCYDkQn0z3CAAFTLD5Da +Di/6ANmqCU//DMyGIPmPEfSMJgORyiAhAM8goQMJ8kwiAKAA2M8gIgPKICEBDBocMApwCNzzBo/y +4HjxwJoOj/KhwQh3Bggv+wDdFQhRAM9wgADYHwCQAd2B4MB9DL3PcIAABOAEgM9ygAC0rwQggA8A +AAAQRSBBA0DBIMDDuBx49CIDAM9woAAsIA+AcLsVCOQAAN7weHB7fgigAxTaCQgeBslwOPAD2M9x +oAD0BwWhhSUDGQ1woLANcMCwiiL/Dw1wQKDPcgAA//8NcECwA8jPc4AAkNbPcoAAgCEQiAK4FngA +Yy24wLjwIgAAoIANcKCgA8gQiAK4FngAYy24wLjwIgAAQpANcECwxKGuDwADAdgpBq/yocDgePHA +sg2P8hpwz3GAAOyvAIkV6MGBooHPcIAAdAcCEREB4IDPcYAA3DwLgTS/AeALoTPwkgiv+YogCwjP +caAAxCcREQCGAN/vCJ6BZBEChmQZ2IMC2BMZGIAvKIEATiCBBxLqz3CAAEyjNnjAgKGAz3CAAMyj +9CBRAM9wgADso/AgTwAL8M9xgADcPAqB6XXpdjp3AeAKoQQQASANcCCgCBABIQ1wILDPcYAAlMsA +gQfoQoENcECgANgAoc9wgACAIQOACIDruMogggPKIUIDyiLCA3AJogPKI0IEUyHAIM9xgAB0ByCB +FL8MuOV4FQmeAIK4DXEAoQ1wwKANcKCgHvANcQChSiQAdKggwAJEJoEQD7lTJgAQJXgNcQChIr5K +JAB0qCAAA0QlgRAPuVMlABAleA1xAKEivdkEj/LxwIIMj/IIdih1KHBIcV4IIABocoHgyiCBAxAI +IQDKIUEDzQSP8uB4IrkG8OxyYKIE4GG5+Qm1gGCAz3CgANQLbaAD2c9woABEHTWg4H7geEEpgYAJ +8i8kSXCoIMABBBACBOxxQKHgfvHAEgyP8qHBCHfPdqAArC8ZhgQggA9wAAAA13AgAAAAAdjAeC8m +B/AodRpyE/SKIMkD+gyv+YohzAU5hu4Mr/mKIIkDiiCJA+IMr/mpcQDYLfALzAAcRDNPIMEDAhxE +MAHgEHgEIIAPAAD/v4+4CxocMM9woADUCziAQiEBCEghAQBAJwASEHGEDgUDB+cEJ48fAAD8/wUn +ABSduJ+47HEAoQDB7HAgoAHYzQOv8qHA8cDhxdYM7/oA3YHgyiBCAwn0z3CAANgfAJCB4AHYwHgM +uIUgAwED2s9xoAD0B0WhDXIAsgPIANtdkA1wQLADyFGADXBAoAPISBACAQ1wQLBkoY0Dj/LgePHA +EguP8s91gADclOAVABAA3oDg0PdELj4XACFAcxzZxdoe224O7/8Yu+AVABAB5ucOBJAA2EkDr/Lg +HQAQ4HjxwNIKj/IhgAomAJAQicO4yiHBD8oiwQfKIKEGyiOBDwAAqgDPICEDOfKA4cohwQ/KIsEH +yiDhBsojgQ8AAKsAzyAhAyvyArjPcYAAkNYWeABhz3GAACwHLbjAuAypI4YgkYYh/ACMIQKADPTP +cYAAgCHwIQEAvxEABoG4vxkYAAGGooAF7QGFA+gAhYzoCiHAD+tyHNiMuLnbSiRAAKEGr/O4cwsI +n0GeDAAADOiKIM4CMguv+cDZAIWA2SigAYVAeB/wAYYgkBTIEHHKIc0PyiLNBx3YyiONDwAAxgC+ +B+3/zyAtA3oOL/nJcAILIAABhc9wgAAsBx4JIAMMiEECj/LgePHAo8EA2WDBARwCMAMcQjACHEIw +AdnPcKAAsB85oM9xgAAkIAyBAICE2kLACIEAgAzZHttBwItwFg3v/xi7o8DRwOB+z3CAAJiuKIDP +cJ8AuP8A2jagCNnscCCgA9nPcKAAFAQloAHI7HEAoc9woADUC02g4H7gePHAUgmP8qXBCHcodoog +mQZWCq/5WtkA2c9woAAsILCAQMYG2EHAQsFDwUTBAdge2elyANuYc7hzACWHHwAAAH16CaAA2HN1 +Aa/ypcAIyIe4CBoYMAnIm7gJGhgwCsgKGhgwC8iHuAsaGDAMyAwaGDDgfuB4z3GAAOiVAIGBuOB/ +AKHgeM9xgADoleB/A7HgeOHFz3KgAKwvANmq6M9woAC0DzygGILBCJ8GFYK5CB4AGoK1CB4Az3OA +ABwgQIMBag8IUQAB3c9woADIHLGgz3WAAEdoz3CgAOwnpqBAo4kKEQDPcKAAyBwxoD7wGIJvCJ8G +FYJnCB4AGoJjCB4Az3OAABwgQIMBag8IUQAB3c9woADIHLGgz3WAAEZoz3CgAOwnpqBAo+B44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeIXqz3CgAMgcMaAB2c9woAC0Dzyg +4H/Bxc9ygAAUOhV6IKL1AK/5iiCSDuB48cCYcAohwA/rcgolwAfPcAAAohkxBK/zVtvgeM9ygADw +ORV6IKLFAK/5iiDSDuB48cCYcAohwA/rcgolwAfPcAAAoxkBBK/zXtvgeM9ygAAoOhV6IKKVAK/5 +iiASD+B48cCYcAohwA/rcgolwAfPcAAApBnRA6/zZtvgePHApBABAA0JXwb2Cg/5B/Ag2c9woADI +HCmgA9nPcKAAEBQloNHA4H7hxQO4NXjPcYAAiF8CYUokAHQA2aggwAIWIkAAoYBggCnYErgB4XV4 +oKDgf8HF4HjPcIAArAYAgKHBJoCeEQAGhrieGRgA4H+hwOB44H7geM9xgAAsB+B/BKHgePHA1g5P +8s9ygACAISOCOIkdCREBCiHAD+tyiiCMDoojBgJKJAAAIQOv87hzIILEEQEGjQleAc92gACsWCCG +QiEBgMohYgC86Y7oCiHAD+tyiiDMDoojhgNKJAAA6QKv8wolAAEmhiOBz3eAACQgoIEkhyCB1bk9 +Zc9xgAD43iWBYbgFKT4AJ3WKIIkLXg9v+alxBIcggIogiQtSD2/5NrnJcK4LIAFCJYESz3CAAMhY +ACWBHwAAiBOWCwABgQZP8uB/ANjgfwDYIIAHueB/IKDxwAoOT/LPdYAAfAfMjQ2Nwr7CuBZ+z36q +Cy/9DdgGuIG4EL7FeM9xoADsJwahBIXPcaUA6A8GoQWFB6E5Bk/y8cDGDU/yz3alAOgPJoanhs9w +gAB8BwDfJKCloGYLL/0N2Aa4gbjPcaAA7CcGoeamRSXNH6em+QVP8uB4z3GAAKwkz3CAANgGAJBH +iSsKAQDPcIAA2gYAkEGJHwoBAM9wgADcBgCIJokPCQEAz3CAACQtAIAC8ADY4H7geOHF4cYA3TMJ +0AcLCdMHCwkTAADYE/AZCfMHH95OIfwH4HioIIABDyWNE2G+CQhOAKV4A/CmeACiAdjBxuB/wcXx +wKHBANpAwroP7/+LcgDAocDRwOB+4HjxwPIMb/Io2CoPj/nPdYAAQC1AhQh2BCCEDwAA8P8A2GB6 +QSwBAUCFAdhEJgQTYHpBLIEAQIUC2GB6UyZBEPYOr/kA2ECFCHdBKAECA9hgesC5QIVBL0ESBNhg +esC5z3EAAKzFz3CAADwtIKDPcAEAWLEApc9x/soCAI4Nb/mKIJIP2QRP8uB48cBKCM/86guP/M9x +AADUxc9wgABELZ4Jb/wgoM9xAQCIsc9wgABILSCgz3H+ygEATg1v+Yogkg/RwOB+8cAyDG/yUNhm +Do/5z3WAAFAtQIUIdgDYYHpTJkEQQIUB2MlxYHqGIf0Pz3EAAPjFz3CAAEwtIKDPcAEAuLEApc9x +/soDAP4Mb/mKIJIPUQRP8uB48cDhxSYJr/oH2MoIr/wIdZ4Pz/9+Cc/8Pgiv+qlwNQRP8uB44H7g +eOB+4HjxwK4Lb/JKJ0AACHUA38C4geDCJ8IBqXGGIf4DRLmpcoYi8Q9HugnYz3OAADQ6DKsQqw6r +D6tEJYATHHgNqwQljh8AAAAMSr64dtOrBCWGHwAAADBCLg4D2HbUq7EbwgNTIH6AyiHBD8oggQ8A +AJEayiOBDwAAewDKIsEHHPJXDxAARHgQcsohwg/KIIIPAACSGsojgg8AAIUAyiLCBwz0JHohCYAA +CiHAD+tyz3AAAJMahtuKJMMPZQdv80olAAC26QohwA/rcs9wAACUGofb8vELDhMBIQ5TAAohwA/r +cs9wAACVGo3biiTDDzEHb/MKJYABCQ5CARsNUwAKIcAP63LPcAAAlhqQ2xUHb/OKJMMPUyABAIYg +fw8ceBlhL3kHCUMBM6sJCYMBNKu2DWABANguCCAAqXDdAk/y4H7geOB+4HgA2Q8hAQAveRNpJXjP +cYAANDrgfwyp4HjgfuB44H7gePHASgpv8gDbocEEuM9ygAAY3xR4HWKQ3hpiAYIYvsiliiYEEs9y +/v//P8mlBHqA4UDCyiXBAAvyCIEEIIAPAAAAMEIgBYDKJWIATQ0QAM9wgAB8yQAQBADIgQQkhg8A +BwAABCaOHwAAADAsvmG+QS4GBkAmgBMPIgIAQMKFDo8DCiHAD+tyPtiMuIojig4tBm/zuHbPcIAA +pDkHiIHgzyKhAy/yz3OAAHzJz3aAANzKmhaBEAOLCyEAgCHyTBaBEADbUyFOAEQhDwMPI4MDQr8A +3g8mzhOGIf8DBCYOkADfRLkEew8nTxDkeMomARCA48ojgQMOu2V6A/ABgwV6QMLPcIAAfMkggIty +hiH+AyS5QCmDAyCCBCGODwEAAMALJsCQFvLXdgAAAEDMJoKfAAAAgMwmgp8BAAAABPQBgAPwAoCu +ua+5sLkleACiABQEMAQkgY8BAADACvQKIcAP63JG2Iy4VQVv84ojiwkIhS65QCkCBgQdABFFeAil +iiAFBgmlz3CAADDLBIiA4IogBQ7KIIEPAADYAQmlqXAA2gHe3g1v/clzwK0JAW/yocDgeAolAIDx +wBHyJw2QACkN0AAKIcAP63KKIM0OiiMEBe0Eb/OKJIMPPgwAANHA4H7SCwAA/fFqCwAA+fHgePHA +WghP8gh1z3CAAHA1CYCJ6M9wgAAANSmADODwIE4AAvAB3oog/w8Apc9xgACAIQCBxBAABmkIXwH6 +DU/7AKUeCe/5qXCA4Mol4hGi9OIOz/iG6ACFjCD/jw30z3CAAEQtIIBgeQHYgeAF3colIhGQ8M9x +gABgFyGRz3OAANgHQIM84TpiIYNk4hThWWEwcAHdwiVOE7N9wb188AOBGIgpCBEBVg1P+wClz3GA +AGAXIZHPc4AA2AdAgzzhOmIhg2TiFOFZYeXxz3CAAKxYAIDPd4AAWKBCIBCAagxv+8ogYiAApQGH +DwiFA5YLb/jJcQh2z3CAACQgBIDPcYAA+N4AgCWBSW7VuAUpvgAncGq4IIVIIAAAMHDKIEYARPcA +pUogQCDPcYAAYBdhkc9xgADYB0CBIYE84wHdemJk4hThOmJQcMIlThOzfVMlTZAi8kEIUSDPcIAA +rFgODMAAz3CAAMhYAgzAAM9wgABwWfoLwADPcIAAjFnuC8AAIYcRCaUDyXAWCCAAAdkE8P4Pj/8t +By/yqXDgePHAxg4v8rhxCicAkMohwQ/KIsEHyiCBDwAASwPKI+EOyiQhABADYfPKJQEBz3CAAABZ +BoADgACAz3GAACQgJIFJb8CBz3GAAPjeUyZNFSWBHWUFKb4AJ3UCJQIQjCIXhza+/mZJ989wgABY +oAGABSh+ACd1HmYjDRAAfQ1QANUNkAAKIcAP63KKII0OkNupAm/ziiSDD/YMz/gU6M9wgADIJCyQ +z3CAAIAhHpAVCQAAz3CAAABZAiWBHwAAAAwH8M9wgAAAWUIlARV2C8AAz3CAABxZACWBHwAAiBNi +C8AAiiBJDPYOL/lCJQEViiBJDMlxYvCWDM/4z3GAAHBZEujPcIAAyCRMkM9wgACAIR6QEQoAAChw +AiWBHwAAAAwF8ChwQiWBFxoLwADPcIAAjFkAJYEfAACIEwYLwACKIAkNmg4v+UIlgReKIAkNyXE0 +8DoMz/jPcYAAOFkS6M9wgADIJEyQz3CAAIAhHpARCgAAKHACJYEfAAAADAXwKHBCJQEVvgrgAMm+ +z3CAAFRZACWBHwAAiBOqCsAAz3CAAFigw6CKIMkNNg4v+UIlARWKIMkN6XEmDg/5z3GAAPjeBoGB +uG0FL/IGofHA/gwP8s93gADkWPoJ4ADpcM9wgABMNSCAz3CAAFA1AIDPdqAALCAJIQEAz3CAAHDI +CIAJIQ0AMIbpcDoK4AC5YTCGiiAKAMoNL/m5YTCGiiAKDL4NL/m5YQ0FD/LgePHA4cXPcIAAWKAB +gA0IUQDPcIAAADUHgM9xgAA4WSCBQiEBgMohYgCb6c9xgADgyCyBl+nPcYAAyMiGCG/4I4EIdYog +yQNuDS/5sdmKIMkDYg0v+alxqXCCDe//Atm5BA/y4HjxwD4MD/LPcIAAJCAEgKCAz3CAAKxYAIBC +IACAyiBiADa9h+jPcIAAyFgaCcAAz3CAAMjIIYjPcIAAAFnPdoAAWKCK6SCAQiEBgMohYgAE6SCG +renuCMAAz3CAABxZ5gjAAAGG9g8v+AhxIYYPeB0JBQAKIcAP63KKIA0D19tKJAAAKQBv87hzz3GA +ADhZIIFCIQGAyiFiAAbpHWUjhsm9Cw1AENIM7/8A2QEED/LgePHAYgsP8lpwGnHacPpxOnJ6cwDY +mnBvJUMQCHZKIMA3O3AId7pw6XCqcS4OL/IB2gAgQIMBIYEDHg4v8gtyQiBYsMpzQyEZMPJxzCDB +gAr3ACdPkwEllSMCJhagAydXIKlwyXEeDi/yAdoFIH6ACHUodtv16XCqcelyNg4v8qpzAiISoOlw +AyBQIKpxyg0v8gHaBSI+pAh1KHYQ8gUlvpMM8ipwANlKcgYOL/IKc6lyHg4v8slzmnAqcADZ6XLy +DS/yqnMAJAIg2QIv8gAbgCDhxeHGqwoQAEAiwwMku8O6AvAA2pUKFQQzJoJwgACAYEAnjXJUfSB9 +wIgBGZIDAeABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgAB +EIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQ +ggQBGZIAARCCBAEZkgBCI0OAs/XBxuB/wcXhxeHGI+pjaiK7wboC8ADaNQoVATMmgnCAAHxgQCeN +clR9IH3AgAQZkAME4AQQAgQEGZAABBACBAQZkAAEEAIEBBmQAEIjQ4Dj9cHG4H/BxfHAugkv8lMh +QgBOIg0Bz3KgABQEyYIA2w4mgh8AAAAGUHHKIcYPyiLGB8oghg8AAMYiyiOGDwAAmwLKJGYA6AUm +88olxgCA4cokTXDKIs0A6CAtAk5gz3GgADgEAeLIqR0NUBARDZAQHQ3REM9woAA4BGioz3CgADgE +aKjPcKAAOARoqKEBD/LxwA4JD/IacHpx+nK6cwoiACEKJEAhyHUKIcAhCiFAg89ygACe1sohYgAS +aRZ4CGJMIwCgBLgId4Yn/hMlf8ohzA/KIswHyiCMDwAAwSHKI4wPAADuAMokbABEBSzzyiXMBB8I +nkHPcIAAmK6A2SigDMAE6EB4jfAyD0//ifBMIECgiiBKA8oggg8AAI4Ctgkv+QDZz3aAAIRaAYYA +2SIMb/M42gCGHNkgoAGGGNkgsM9xgACAIRUhVgMAFgEgU4ENwfCoz3eAADAJKBhABEV5pLkhoADZ +MxhCAOlxIqAKIUCDMRjCBDIYwgQ0GMQFyiFiAP4LL/gM4IXtz3GAAACvBPDPcYAAIK8jps9wAABI +EQCxGNgCpg0IUCCKIAUCALEMwIXoz3ABAKivAacAFgAguRAABi0IHgBBhhrYALICpgCRh7gAsQDY +C7EBgq24AaIRDRAgz3CAAAQ3BIAzGgIAKQoQICGGAYGYuAGhA4GfuAOhz3GAAGAHABYAIAAZBAVA +gAGAQaECodoMb//JcMkHz/HgePHAeg/P8bpwenH6cgoiACEKIUAhyHUKJMAhCiBAg89ygACe1sog +YgAIcQK4FngIYkwjAKAEuIYg/gMFIFAAyiHMD8oizAfKIIwPAAC/IcojjA8AAJYAyiRsALADLPPK +JcwEDMCM6AohwA/rcofYBriX20okAACVAy/zuHMVCJ5Bz3CAAJiugNkooAzAQHhn8M92gACEWgGG +AN/pcY4Kb/M42gCGHNkgoAGGENkgsM9xgACAIRUhVgMAFgEgM4EzGMIDz3eAADgJEBgCBKS5jbmZ +uSGg6XEioAohQIMoGAAFMRjCBDIYwgQ0GMQFyiFiAGoKL/gM4Ibtz3GAAACvBfDPcYAAIK8jpqTY +ALEQ2AKmCw1RIKTYjLgAsc9wgACAIRmQjriPuAGxDMABpykKECAhhgGBmLgBoQOBn7gDoc9xgABg +BwAWACAAGUQEQIABgEGhAqF6C2//yXBpBs/x4HjxwOHFz3WAAPw9AI2MIMOPD/TPcoAAkFgGggOA +IIDHcQ8AAKCOC6AASHD+2ACthQbP8eB48cAKDu/xANjPdYAAUNlKJAB0gN6oIAAFCHEB4E8gwgEW +JUMQR6uKIggAArk2ecdxgACQ1kChANpCscapwNh/HQIQz3WAANAHwK3PcIAAENaA2UYJb/MocsGt +z3CAAOQk2ajPcIAA1CENBu/xxajgePHAlg3P8aHBCHfeDC/0GNjPdoAA7DoghgGGgOHMICGAK/TP +cKAA1AsYgADdQiAACIDgyiBMA4wgCIVI98EWABYB4MEeGBAc8J3YABwEMAvM6XECHAQwAeAQeAQg +gA8AAP+/j7gLGhwwAMAe2ioIIAAYuqGmBPAE6GG4AaYWCAAAANgWCi/6QCYBEnUF7/GhwOB+4Hjx +wPoMz/EIdxpxOnLPdoAAgCEDhs91gADsOhSQELhSC6/4AqWA4MogIiDPcIAAcAcAgIvohSEIJE8h +QCefuOxxAKHscOCgA4YIgA0IHgAChYG4AqXPcIAA3AYAiIToAoWDuAKlz3CgACwgEIDPc4AAdDxy +HRgQSiTAcADYqCDABc9xgAC0BiCJgOEM2soiIQBEKL4Dz3GAAKjkJ3IzIYIAQCMBAxlhAeBAqUAl +DhKWDS/0yXAPCBAgIoUA2IC5IqUD8Iog/w/PcYAAcAcggWcVDxZoFQQWlOkA2wjw7HIgogR5BB5Q +EAHjjCOCgCCGuPfPcqAA1AstoiR4AKZnHdgTaB0YEQDYVQTv8dwdABDgeF0G7/8A2OB48cDPcoAA +4AYCgiWIAdgH6QjZpgsv+SuiB/DPcYAA+CcKCu/yAKHRwOB+4HjxwL4L7/HYcDoIIAAA3cloKw4S +EPhwqXcyJoADFQgSDBEIkw5GCc/1Mm84eAV9AedCJ0cA5Q91gGG+7QPv8alwCHID8AHgIIj+6eB/ +QnjgePHAcgvP8c91oAD8RB2FOYXSDGACAN4A2J64AaXgeMGlxaW9A8/x4HjPcaqqu7vPcJ8AuP82 +oDagNqA2oM9xoADIOw6BiLgOoWkgQAD+8eB48cDPcIAAgCEDgBiIHQgRAQohwA/rcoogDA6KI4UK +SiQAAG0H7/K4c4ogCgsGDO/4iiFFCzoKL/QD2M9wgABwyAAQBAAZDBEACiHAD+tyiiBMDoojBQw5 +B+/yuHPPcIAA2B8AkIHgAdjAeAy4KwiBDwAAABDPcKAALCAQgM9xgABwNQKhAtgDoc9xAQAcM0IJ +b/8B2AfwiiAKC5oL7/iKIYUO0cDgfuB48cByCs/xz3WAAODIL4VKIAAggOHKIcEPyiLBB8oggQ8A +AL4hyiOBDwAASADKJAEEtAbh8solwQDPcIAA2h9AiM9wgACYrmB5SKA8HQAUegkv9ALYgQLP8fHA +IgrP8YYPYAAIdc9xoADIH0WFDOhuEQ4GAoBkhcR6RXtuGdgAIoUAoQvwbhEABkR4bhkYABzYGLgV +GRiAUQLP8eB4gOAB2cB5z3CAAPg94H8goPHAygnP8c9wgAA8LSCAosFgeQTYgOCoAgEAz3GAABwg +AIEB4AChFwhRAAHZz3CgAMgcMaBmCmACKHDiDu/5BdjPdYAAADkOpc9xgAAcIACBAeAAoRUIUQAB +2c9woADIHDGgOgpgAihwA9gmCO/yqXEE2B4I7/IibQXYFgjv8iRtCtgOCO/yJm0P2AYI7/JAJQES +Ntj6D6/yQCWBEjfY8g+v8kAlARM42OYPr/JAJYETz3enABRICIfPcacAmEcEpQ2Hz3KrAKD/BaUO +h892oADsJwalHIEHpReHCKUWhwmlGIILpRmCDKUagg2lz3ADAMYDBqbG2JC4BqbPcCwAAgEGps9w +WQBCAQamiiCKAAamz3BAAIcNBqbPcNEAwg0Gps9wwAAHDgamz3CAABwgAIDPcoAAHCBCIECAAKIG +9M9yoADIHADYEaIB2AinANgNpw6nz3BQAP8AHKEA2BenFqf82c9wqwCg/zigfNk5oBqAz3GrAKD/ +gLgaoc9wKgACDgami3A2DCAAgcEAwc9wgACUlzWlMqABwS+gz3AaAAIOBqaLcBYMIACBwQDBz3CA +AJSXNqUzoAHBMKDPcCYAAg4Gpotw9gsgAIHBAMHPcIAAlJc0oDelAcExoM9wgAAcIACAAeDPcYAA +HCAAoRMIUQDPcaAAyBwB2BGhoghAAgGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAGpgSVELiF +II8ABqYFlRC4BSCADwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbPcIAAHCAAgM9x +gAAcIEIgQIAAoQb0z3GgAMgcANgRoQSFK4UIpwWFDacGhQ6nCIUXpwmFFqfPcKsAoP84oCyFOaAt +hTqgsgvv+Q6Fz3CAABwgz3GAABwgAIBCIECAAKEG9M9xoADIHADYEaF1B6/xosDgePHACg+P8X4I +AADPdoAAYF1yC+/3AIYIdQCGGQ0AEKoMr/upcIYL7/ugpjIPL/QR2O4ND/fPcKAALCAwgM9wgABs +BzUHr/EgoPHAug/v/6HBz3CAAAA+AIAE2WLaHttAwItwKgov/xi7ocDRwOB+4HjxwOYN7/MW2ADY +0cDgfuB48cCGDq/xB9jOC8/5CHfPcKAAtA/cgLINL/8A2M9xoAAsIDCBdg+v+IogkQVeDs/7z3WA +AAA+5gkv/AClQIXPcYAAtFoAoc9xgABgPEqhhg+v/Auhcg0v/894qgrv+elwz3CAAOwfAIhDCFEA +QIWKIEQEz3WAANwfI4UaYjhgEHIB2MIgBQAM6IogEQsOD6/4ANkaDm/1BNgAhQbw/g1v9QTYAoUW +CyACA6VFBo/x4HjxwM9wgAD4PQCAnOgODS/5FtiY6M9wgAA8LSCAYHkE2BDoz3CAACwtYIDPcQEA +mMoL2GB7BNomDu/zFtjRwOB+z3GAAIAhAIHEEAAGDwhfAQGBxBAABhUIXgHSDS/0E9jKDS/0Edjs +8erx4HjxwM9wgABoGwCAz3GAAGwHG3gWDq/1IIEI6AHZz3CAAOwfdg/v/yCo0cDgfvHAPg2P8Qh3 +fdgNuM9xgAD43sWBxg6v8clxjCACgM9xgABsGwDdh/cdeIwgAoAB5Xz3AChCAwUqvgPPcoAAaBsW +uAChz3GAAPw9ABpADoTv/9gAqQCJjCDDj6wOgf9JBY/x4HjxwMYMj/E6cHpxSHdodgokACEA2s9x +qwCg/1mhB9gaoVihig0gAgHYGdnPcKcAmEc6oCYIb/we2M9ypwAUSB2CvoJsEhAAcBISAACnoKb3 +uMUggg8A/wAA0yDhBfe9xSWCHwD/AADTJeEV/g0v94ohEAAIdqlw8g0v94ohEAAIdUAoACLiDS/3 +iiEIAAh3QCoAItYNL/eKIQgA0XkZ4Sx5L3GxehniTHovcgAZgCMPD2IQABtAIwDYBPD/CIOAAdhZ +BK/xABwCIPHAFgyP8Qh1KHbaDCACCtgB2M9xpwCYRxqhygwgAgrYz3CmAJw/ZBAEAFEkAIDKIcEP +yiLBB8oggQ8AAL8ZyiOBDwAAuAA8AOHyyiUhAM9wpwAUSCyAHYAApve4xSCCDwD/AADTIOEFGQSv +8QCl4HjxwJ4Lj/HPcoAAMK7Egowmw5878v/ZJKLAoIQuCBkAIY1/gADUqQSNCiBALgHfkugChc9x +gAB8KGYKL/MggQhxz3CAACQgBIAAgIIPQACE6AHYHPDPcIAA/CcijcCoIajPcaAAsB/5oc9xgAAk +IDCBIIEA3SGgwgrv+OlwACCAL4AA9KugqADYeQOP8fHA4cUIdc9wgAAkIASAIICKIMkLFgyv+Da5 +iiDJCw4Mr/gihUIK7/MG2DIOj/zPcIAAgCEDgBiIHQgRAQohwA/rcoogDA+KIwYLSiQAADkHr/K4 +c89xgAAANQmBCQgVAQHgCaHPcYAA+N4GgUYgQAEGoc91gADUBwCFJQiRAIogSQWqC6/4iiFGDyCF +iiBGD2YKr/oE2u4Lr/oE2PECj/HxwOHFCHXPcIAAJCAEgCCAiiAJDHYLr/g2uYogCQxuC6/4IoXP +cYAAcDUJgQHgCaHPcYAA+N4GgYK4BqHPcIAApDkDiIroiiCQDkILr/iKIccFVg2v/gLYiiDJAy4L +r/iKIYcGlgrv8wbYhQKP8eB48cDhxQh1/9nPcIAArKkgqG8gQwASCO/yAdnPcIAAJCAkgCCB9gqv ++IogzA0GhQOAQoUggIogiADiCq/4QnlBAo/x4HgVAi/0EdjgePHA4cUIdc9wgAAkIASAIICKIIkM +ugqv+Da5iiCJDLIKr/gihc9wgACAIQOAGBCEABsMEQEKIcAP63KKIEwPiiNHCukFr/JKJQAAz3Cg +ACwgMIDPcIAA7FbaDiAAliFBD89wgADgyAyAF+jPcIAA2B8AkIHgAdjAeAy4HwiBDwAAABCKIMkD +Sgqv+IohBw4GCSAAANgm8GoMj/zPcIAAhBgAgJ7oz3GAAPjeBoFGIEABBqHPdYAA1AcAhSUIkQCK +IEkFDgqv+IohiAQghYogiATKCK/6BNpSCq/6BNiOCs/6UQGP8fHA4cUIdc9wgAAkIASAIICKIMkM +1gmv+Da5iiDJDM4Jr/gihc9wgABwWQCAQiAAgMogYgCH6M9xgABwNQmBAeAJoc9xgAD43gaBgrgG +oQ4J7/MG2M9wgADgyAyAFujPcIAA6DECgBLoz3CAANgfAJCB4AHYwHgMuBEIgQ8AAAAQ6gggAADY +EPDPcIAApDkDiIroiiCQDlYJr/iKIUgPaguv/gLYqQCP8eB+4HjxwOHFCHXPcIAAJCAEgCCAiiAJ +DioJr/g2uYogCQ4iCa/4IoXPcIAAgCEDgBiIHwgRAQohwA/rcoogzA+KI8oFSiQAAFUEr/K4c89w +oAAsIDCAz3CAAOxWSg0gAJYhQQ/PdYAA1AcAhSMIkQCKIEkFzgiv+IohCggghYogCgiOD2/6BNoS +Ca/6BNiKIMoBsgiv+IohyggB2c9wgADoMSKgz3GAAPjeBoFGIEABwgqv/AahKgnP+u0HT/HgePHA +4cUIdc9wgAAkIASAIICKIEkObgiv+Da5iiBJDmYIr/gihc9wgACAIQOAGIgfCBEBCiHAD+tyiiAN +D4ojig9KJAAAmQOv8rhzz3GAAPjeBNgGoYogygEqCK/4iiHLAc9wgADoMQHZIqDPcIAApDkDiIvo +iiCQDgoIr/iKIYsCHgqv/gLYbg+v8wbYZg+v8wjYVQdP8eB4z3CAAOxW2QMAAOB48cBOD6/zE9jP +cIAAJCAEgCCAz3CAADQWIKDRwOB+4HgIcgDY0Qev9xDZ4HgIcgHYxQev9yDZ4HgIcgLYuQev90DZ +4HgIcc0Hr/cA2AhxxQev9wHYCHG9B6/3AthRAI/y8cDhxQh1z3CAACQgBIAggIogSQ1qD2/4NrmK +IEkNYg9v+CKFz3CAAIAhA4AYEIQAGwwRAQohwA/rcoogjA+KIwkDmQKv8kolAADPcKAALCAwgM9w +gADsVooLIACWIUEPz3GAAPjeBoFGIEABBqHPdYAA1AcAhSUIkQCKIEkFAg9v+IohiQcghYogiQe+ +DW/6BNpGD2/6BNiCD4/6RQZP8fHA4cUIdc9wgAAkIASAIICKIIkNyg5v+Da5iiCJDcIOb/gihc9x +gAD43gaBgrgGoc9wgACkOQOIiuiKIJAOog5v+IohCQ22CK/+AtgCDq/zBtjxBU/x4HjxwP/Zz3CA +APw9Mg9v/yCo+g+P/9HA4H7xwFYNT/HPdYAA9CcAFRAQjCDDrwjyiiAMDVYOb/iKIYcCIfCS6M9w +gAC0rWgQBAAKIcAP63LPcAAAhwyKI8cDiQGv8golAAQIcYIhCADPcIAA1KkOIEAAvg5v8YohCAka +cM9wgADQsRMQAoaMIsOP/9kG8hwYGIQgpQzwExgYhCClANnPcIAA4AYkoLILj/gpBU/xAdnPcIAA +4AYkoKEDj/jgePHA4cUA3SILr/ipcIYI7/KpcDINj/POCM/yz3CAAGwYDQVv8aCg4HjxwHIOz/f+ +Ds/34g3P99HA4H7geOHFz3KgAMgfpBIDAM9xgADgBg2BEHPCIwYARPdieBN7v4IOgbtjeGAOoQHY +ShoYAOB/wcXPcqAALCBmgs9xgADgBg6BYngOoRCCLQNv9g2h8cAqDG/xSiRAAMCBoIAB39F1wiQC +AdF1oYFhgMInzhMB3rFzwH6xcwHbwiPOAEwkAIDMJiKQyiNiAAr0heuA5swnIpAD8gLbAvAA2xTr +IQtQADkLkQCggMCBAYAhgQIljZOgogMgQAABohDwANgAogGiDPCggcCAIYEBgAIljZOgogMhAQAh +ogkEb/FocOB48cDhxSaAQIBCIgKAyiJiAIDiyiHCD8oiwgfKIIIPAAA2Ecojgg8AAHcAyiQiANwH +YvLKJQIBYIEVC0AAQoCig0J9DQ1TEGCD9QtBgEGDAaNgoEGgAKJEgKaAQCUDFhcKXgBGhQbqooJC +gEJ9Bw1SEACjRICmgEAlAxcXCt4AR4UG6qKCQoBCfQcNUhAAo0GACwmBAOoIr/8GgHkDT/HgePHA ++gpP8Qh2AIBCIAGAyiFiAADYJukmhkGGAd8wciCGQYZBoSCiAKbPcK3eAgABpqaGwH8GhREOARCp +cFYIIAAC2QalpoYHhQ8OARCpcEYIIAAI2QelBe+GCK//BoYB2AEDT/EggBBxyiEhAOB/KHDxwIoK +T/EIdYoP7/8odgh3wqXiDu//qXDZAm/x6XDgeECAFQoAAGSCCyNAgAX0QIL3CgGAANrgf0hw4HjP +cqAAyB/0EgAAvNsYuwQggA///wDw9BoAAAvIZXgLGhgwFRrYgM9zgAAkIAiDANkgoAyDIKAJgyCg +DYMgoAqDIKAOgyCgC4MgoA+DIKDPcAAMDwCkGkAADqIP2Ay4EKLgfuB48cDuCU/xz3WgANAb04UR +Dp4Wz3CAANhZSgkAAA8O3hbPcIAA+Fk+CQAAEQ4eF89wgAAYWi4JAAAPDl4Xz3CAADhaIgkAABEO +3hfPcIAAuFkSCQAAvNgYuBOlAQJP8eB48cCKCW/xANsId892oADIH6QWABDPdYAAJCD4YKQeABAB +2BOmKIUMhUCBAIAAIsKDQKEshQEgwAAAoQLYE6YphU2FAIFAggAgwIMAoQ2FASLCAECgBNgTpiqF +DoVAgQCAACLCg0ChLoUBIMAAAKEI2BOmK4UPhUCBAIAAIsKDQKEvhQEgwAAAoQSFAID+DG/z6XEk +hQChBYUAgPIMb/PpcSWFAKEGhQCA4gxv8+lxJoUAoQeFAIDWDG/z6XEnhQChD9iauA6mD9gMuBCm +z3CAALhZng5P/891gADYWZIOb/+pcI4Ob/9AJQAYhg5v/1YlABJ+Dm//ViUAE/kAT/HgePHAighP +8Qh3IPAAhiGGIaAAoQDYAKbPcK3eAgABpqaGBoURDgEQqXD6De//AtkGpaaGB4UPDgEQqXDqDe// +CNkHpSOGYHnJcK4N7//pcAomAJAI8gOHIIAChiJ4rwhSgA4Ob//pcI0AT/HgeA/YmrjPcaAAsB8V +oQ/YDLgXoeB+8cD+Dw/xz3KAANzKP4I6cKrBANghCd4Cz3OAAIAhY4N0g0gSgQDA3WR5hiH/DiK5 +On0E8BTdAtiKEgEBAnkSggThUgxv9gDanglgAAIgTgMD2M9xoADIHxOhz3WAACQgCIUAgELADIUA +gEPACYUAgETADYUAgEXABIXggAWFABASAEARAAYeZvwRAADPcIAAvK4A2UCAAYAAIoKDASBAAEDC +QcCLdh8JUSDeCo/yhMEacMlwLgvv/4bCCHYIEAEhC/CCwclwHgvv/4bCCHbPcIAA+N4kkM9ygAD4 +3mWCBsIEuxcLpABAKYACGQiFAAJ6/wiEgAXwsgtgAIbACHJGwi0OkRDpcAYLb/NIcQh3SnD6Cm/z +BsEGwlpwBMMHwQXAACLCgAEgQABEwhbwle7pcAYLb/NIcQh3SnD+Cm/zBsEEw1pwBsEFwAfCAiND +gETDAyCAAEXAGw5QEM9wgACAIQOAGIiE4MwmIZAA2AL0AdgvIAegQ/TpcJIKb/MD2Qh2SnCKCm/z +A9kAwQh3AcBAIcGAQSAAAEHABMBAwQXBQCDAgEEhAQBEwD4IYABFwRcJESAEhcCgCIUAwSCgDIUB +wSCgJwmRIASFwKAIhQDBIKAMhQHBIKAFheCgCYUEwSCgDYUFwSCgFwlRIAWF4KAJhQDBIKANhQHB +IKCKIAcOIg8v+ApxTCAAoAHZwHnPcIAAFKM0qEUGL/GqwOB48cDuDQ/xpcEIdgKLKHWYcGTAAIsA +EgYBERwCMHlwAhIHAQQSCAEQFAAx5JIGEgUBACDJAwCRLyFIEgcgQAIKCSAAEHgAIIoBAZUvIogS +ByCAAvYIIAAQeAAgxgEClS8miAEHIIAB4gggABB4ACAHAgOVLyfIAQcgwAHOCCAAEHgAJQUABJUv +JUgBByBAAboIIAAQeB9nBZXwf+d4qgggABB4JpUhcBB4B3k8eg+5JXpQegAigQIweQAcRDBHlSd6 +XHkPukV5MHkAIYIBUHpceQIchDAPukV5MHkAIcIBUHpceQQchDAPukV5MHkAIUIBUHpceQYchDAP +ukV5MHk/Z/B//HkIHMQzD7/leTB5OGBpcca5hbkIuQUhwQIgthB4IJUKHAQwJ3gceAi4BSAAAQG2 +AMABpgHAAqYCwAOmGQUv8aXAD3tIuA94z3KAAABu9CIAAEAoAQJIuAV59CLAADB54H8neOB48cDP +coAAqFkggoDhyiHBD8oiwQfKIIEPAAA0EcojgQ8AAOMGyiQhAMwAYfLKJQEBAaIB2s9xoADIH1Ch +ShmYAEgZGADRwOB+z3CAAKhZ4H8AgOB4z3GAAKhZIIEA2IPhzCEigAL0Adjgfw94CiIAgPHAF/Li +D8//gODKIcEPyiLBB8oggQ8AADMRyiOBDwAA3AbKJCEAYABh8solAQHPcIAAqFlAoNHA4H7geAhz +KHLPcIAAJCAEgACAAiCADwACAABJACAAaHHhxVMgQgUEII0PwP8AAM9wgAD43gWAAiCDAAQhgg/A +/wAA1bkieKV7RXgQc8ogrQAF9xBzANjKIGYA4H/BxeB48cDhxdhwuHG6D+//mHIIdchwsg/v/4hx +EHXKIK0ACvcQdQDYyiBGAZgP5v/KIQYBxQMP8QDYz3GAAHDIBaEEgaC4BKG9A2/zA9jgeDa4Nrkw +cNYghQ8AAIAA4H8ieOB48cAeCw/xCicAkM92gAD43s91gADYWQ/0z3CAAJhsyXFGCC//FNoaDi/y +qXBAJQAYEfAZD5EQZg5P8slxKggv/xTaQCUAGAzwyXD2CSABBdmpcO4ND/LPcIAAuFniDQ/yBJYK +uAWmBoaGIMMPBqYiCyAA6XCODA/yDQMP8fHAocEIcw4Ib/eLcILgANgG8gDAEHMB2MIgDgChwNHA +4H7gePHAANnPcIAAoCwaCCAAIKDPcIAA0FZyD4//0cDgfuB4ANnPcoAArAcjoiSiJaImoieiIqLP +cIAAtFkgoM9wgABYWiCgMbIwss9wgABcN+B/IKDgePHAz3GAAKAsAIGa6AHYAKEA2c9wgAA0FrYP +7/8goIoghw4eCy/4iiGPB89wgACcIRCIg+BkCSEAyiBhAdHA4H7xwOoJL/GKIMcPpMHyCi/4iiHS +Ao4Iz/eA4KwJAgDPcIAANBYAgM9xgABcN44O7/8ggc92gACsBzCWUZZZYTBwAN3E9wIgTQAChpXo +E+3PcYAAWFoAgbhgAKHPcYAAtFkAgbhgAKHPcYAAaDsSgbhgEqHPcIAAjAYAgADfDQhRAM9wgAC0 +WeCgiiAIAM9xgABYWm4KL/gggc9wgAC0WQCAQsVAwM9wgABYWgCAi3VBwAKGENmi2h7bQ8CpcLIM +b/4YuwDYKg4v+alxz3CAADQWIIDPcIAAXDfipvG2IKDwts9wgACMBuCgUghv8xPYz3CAAFhaAIAf +CFQBYgggAAHYrg7P+s9xgABgPB2BAeAdoQTwSgggAAXYOQEv8aTA4HgV2ADaz3GgAMgfbxkYAODY +kLgQoQnYsBkAALQZAAB42EIZGAAA2Jq4D6GkGYAAz3AADAAZDqHgfs9ygADQViaCI4FhuGCBz3GA +ADQWIIHVuXlhz3OAAPjeZYMFKz4AJ3HHcQAAABDdBa//SHDxwOHFz3WAAKwHB4WT6M9wgACgLACA +HwhRAGoPT/gXCJAGz3CAACQgBIAAgAWlAdgHpaUAD/HgePHA4cXPdYAArAcHhRnoz3CAAKAsAIAr +CFEAMg9P+CMIkAbPcIAAJCAEgACABqXKDO//JYUwlThgELUA2AelYQAP8eB4z3CAAKAsAIAXCFEA +z3CAACQgBIAggM9wgACsByOg4H7xwM9wgACgLACAJQhRAM9wgAAkIASAz3KAAKwHAIAEonIM7/8j +gjGSOGARstHA4H7xwIoP7/CKIQgACHXPcKAAyB8woAHZQRhYAFYJAADPdoAA+N4DhiWG1bgwcMoh +zQ/KIs0HyiCNDwAANRHKI40PAACbAMokLQC4Ay3yyiUNAb4KT/KuCm/yCHcacIDlzCVikEr0z3WA +ACQgCIUghiCgDIUhhiCgAIUlhiCgBIUjhiCg1g2P9+UIEADPcIAAyCQIiNkI0QEFhcCAAIAEJo4f +wP8AAFMgUQUEhQCAEgsv8wpx1bhFhQV+AtvAos9yoADIH3OiyYUCIEGEYIZNhUCCCgAEAEIpwAcH +8CSXCrkCIUEEGWEA2AIjQ4ADIgEAYKYNhTvwdQ2REASXz3WAACQgIYUKuAChz3CAAIAhAIDEEAAG +USBAgQmFIPLPcYAAyCQoiTkJ0QHPcaAAyB8B2lOhKIUA2yCBTIUCIQGEQIIgoA2FAyLCAECgBIUA +gHIKL/MKcSWFAKEK8CCHIKANhSGHIKAjhgWFIKCBBs/wANmWuc9woADQGzOg4HgDC55F4H7PcIAA +2FkngAbpA4BAgAKBQngF8M9w/w///+B+z3GAAIAhJIEogQQhvo8ABgAAocEE9BMJHwAJ8AQgvo8A +AAAYA/IA2ALwAdjPcaYApAAXoeB/ocDxwMINz/DPdaAAtEcIdgbwtgjv94ogiQxxFQCWBCCAD3AA +AABBKD6F9PWKIP8Pbx0YkGsdGJAD2A+4z3GgAMgfExkYgAWGWR0YkAaGWh0YkAeGWx0YkAmGWB0Y +kAiGVx0YkEARAQbPcYAAuFoggQQggA8AAACAEQkfAIDgBtjKIOEBA/AA2M9xgACAISOBKIHPcoAA +AAYlCR4ATyABAo25l7kmogUggQ+AAEA6J6IFIIAPgADAUxDwBSCBD4AAwCQmogUggQ+AAAA+J6IF +IIAPgACAVwiihBUAlgmiBoaeC6/0IYbmDu//AYZFBc/w4HjxwMYMz/A6cM93gAA0OgyPhiD/AUIo +0ADPdqAAtEcKdQXwtg+v94ogiQxxFgCWBCCAD3AAAABBKD6F9fVDFgCWRiAADUMeGJBXFgCWvLi/ +uFceGJBfFgCWv7hfHhiQANieuFMeGJDgeADYUx4YkAyPYB4YkFYLT/zPcIAAPC0ggGB5BNgV6Ewh +QKAACuH6yiBBA893gABcXQCPFw0AEM9wgADELjaAYHkA2AAfAhTOC0/yQxYAlkUgAA2fuEMeGJCX +CRAgIwlQIG0JkCAKIcAP63KKIFoKiiONAkokAABhAC/yCiVABM9wgACAIQOAEL2bvTIggA8AANgC +n72A4AHYwHgPuKV4Xx4YkAbwyg6v94ogiQxxFgCWBCCAD3AAAABBKD6F9PWKIP8Pbx4YkGseGJAT +8M9wgACAIQOAEL0yIIAPAADYAp+9gOAB2MB4D7ileF8eGJAGyITg+Ash88ogoQTFA8/w4HjxwGoL +z/AIdSh2+gzv8AGAoIUQuUEtABQ4YOoM7/DJcRC5sHg4YN4M7/BALoESqQPv8Chw8cA2C+/wBNkA +2M91oAC0R0sdGJAA2pC6dx2YkAHadx2YkM9yoACERBiiANqRuncdmJAC2ncdmJDPcqAAiEQYogDY +krh3HRiQdx1YkIDYdx0YkADYnrhUHRiQANicuFQdGJDPdoAAVAbJcFIOL/Ic2c9wgABIBkYOL/IK +2clwIR0YkM9wgADUBBB4SR0YkBUDz/DgePwcCLTxwB8IdAEacAohwA/rcoog2gt32wokAATxBu/x +uHOKIBkKjgvv9wpxz3OAAFQGJINocDR4IJAfCR4CEBMEAAAQBQEKIcAP63KKINoKvQbv8X7bJIMB +4SSjANoJCRECRKMvIQcEhSEMACCwkNnPcKAA/EQYuSKgC5MB4BB4C7PRwOB/BBQQNOB48cCI6M9w +gAAsqJINL/Ik2dHA4H7xwAIKz/DeC2ABCHZyDoAAz3GgAMgfCHVA2A+hQBEBBjB5uglv+MlwRQLv +8Klw4HjxwM4J7/BKJAByz3CgAIggAN6oIEAPdQ7QEaCAz3GAADjJz3KAAPje1nloiUeCemLPc4AA +BMrUe53tACaNH4AA/Mn4jRMPkRDgk/t/I5GAvyR/4LMF8AsPURAikSCzANk4rc91oADIHPqFIJPk +eSyzBPAskwkJRQNZYQTwrLO5Yokhzw8EGFAAAeYA2c9wgAD43qUB7/AnoPHAABYEQAcaGDEAFgVA +ARpYMQQSgTCc4coiwgfKIIIPAADcDsojgg8AAPQKeAXi8cohwg8iCOAADtnRwOB+4HjxwPIIz/Aa +cA3Iz3eAACzK8CcBEM91gACMyQMSAjYIGEQgAZKA4A0SATYA3g7yFCVDEIATDgfVDhAQAN6AG5wD +8BuEA+AbhAMUJUMQwLMBgj0InwPIs9AbhAMQis9xgACQ1gK4FngbYWWTJQtyADhgYbtlsBCKcmh2 +e3phRZJ5YYbqJpFRIUCALAzC8Q3IACCBD4AAqMnEqcyp1KnPcYAAOMkWeRR9IpHAHYQTFX94HUQQ +AxIBNsCnAYEEIIAPAAAAYC0IgQ8AAAAgEInPcYAAkNYCuBZ4AGHtuMomYhDPcIAAuCDUeCCQEOEg +sAPZz3CgABQEMKAaDWABCnDZ2A4J7/cBEgE2PvBwEg0B4BMBAQIhTgMPDYQTwn2ieBB4gBscAM9w +oADUBw8QDoYA3fAbhANwEgIBwBtEA0J5MHngG0QA0BMBAQHhMHnwEwUB0BtEAFMlfoDKIcIPyiLC +B8og4g3KI4IPAADnDcokgg8AAP4A9APi8c8gIgMD2RMYWIDVB4/w8cBmD6/wANjPcYAAfFoAoc9w +gAA4FgGAo8EQ6M9ynwC4/x2iz3GAAAQgBIEB4LO4tbi4uAShFqIMzM91oADUB1EgAIAD2CAdGJBT +8hQdGJADEgE2ABYEQAcaGDEAFgVAARpYMQTKnODKIsIHyiCCDwAA3A7KI4IPAAD0CmQD4vHKIcIP +KHAODqAADtkDEgE2UIlTIsAAhiL+AxCpRLoCuMQZggAWeM9ygACQ1gBiz3KAAIAhLbjAuPAiAAAE +orkQAgbPcIAAOMlAoA8VAJa0GQQABshqC6/2DRICNgMSATaSEQABvgrv+5QRAQAv8EokQAAUHRiR +ABYAQAcaGDAAFgVAARpYMQTKnODKIcIPyiLCB8og4gnKI4IPAABmAsQC4vHPICIDA8i0EAABDx0Y +kMvYVg+v9w0SATYDEg42lBYAEA8IXgKaCU/4AxIONg0SAzbPd4AAjMkUJ8EQCJGi6FCOz3CAAJDW +dX8CulZ6QGCYFgIQLbhOp1anwLjPcoAAuCD0IgIAvB6EENARAAEEIoIPAADw/8O4RXjQGQQABvDQ +EQABvB4EEAHYoB4AEIILr/vQjoDg6gMhAAMSAzYGyFEggIHaAwIAIYMTCZ4GkNiQuM8DIACgGwAA +Ar7PcIAAkNZAIIID1n7OYsQTggATCoADkdiQuKsDIACgGwAAyoPPcqAALCDwgowm/58M8sJ/FQ+F +HwCAAACH2JC4gwMgAKAbAAAQE4QAQCyPAPZ/5mAEJr6fAAAAE/hgWfIRDl4Si9iQuFsDIACgGwAA +Zw4fEyWQnOkHyAQggA8AwAAAIQiBDwDAAAAR2BS4oBsAAOHYFg6v94hxAxIDNiHwiNiQuKAbAADi +2Pbx/g2v9+PYAxIDNqQTAAC0uKQbAACSEwABp7iSGwQAnhMAAae4nhsEAAXwhdiQuKAbAADPcIAA +gCEDgBiIhODaAgIAz3GAABSjDIFQiw8ggAAMoc9xgABUBwCBAeC7AiAAAKHCkDMTgABNDg4QB8gE +IIAPAMAAADEIgQ8AwAAACIspCFMApBMAALS4pBsAAJITAAGnuJIbBACeEwABp7ieGwQACvARCZ4B +jdiQuGsCIACgGwAABshRIACAFgIBAB4Oj/8DEgM2CHKoGwAAz3CAACQgBICwEwcBIIBVJ0AG1bnP +doAA+N4LCQUABdgHpgWGIniMIAmGyiElAKQTAAAJIYEA8risG0AA5vKYE4EAw7kHyDx5BCCIDwEA +APANEgY2z3CAADjJFiCAAcWQrBMAAAkggAOAEw4BfhMPAd9nz3aAAIAhxIZGFg4R/mYIIIADwniY +Ew4AQSgIE+i+AN+G8kQmDxYEJoEfBgAAACO/MbkB5/lhz3eAAABwMidEEEEugRIEJoUfwAAAAFIh +AQBBLYUFMidPEcC5A7kY4YB3hefKIY0PAQCJDdUhzgOkEw8ARw8eFSJ4hBMBASJ4SCAAAEK4QS5P +E8C/BL/0f8lxxrlJIcEFNH/PcYAAYGfxYQ8O3hJBKQ4BFCZBEAUpPgBBKQByAN9Y8EEohABBLkAT +wLj0aPR/yXDGuEkgwAUUf89wgABgZ/BgDw7eEkEoDwEUJwAQBSg+AUEpAHKEEw8B+WEQ4UEphABB +LkETwLkEuTR5yXfGv0knzxX0ec93gABgZzFnDw7eEkEpDgEUJkEQBSk+AUEpD3Ig8FEmQJLKIMID +GvQD4M92gAA4Z/AmQRAiuAUpPgAvcFMgDgDYYIQTDgEdeCfmIr4FKb4DL3dTJwEQP2f9f89xoADE +LO+h7qFAKA4Wnr5ALg8F5X7FeMAbAAAKoc9xgADsOQHYAKEE8E+CsBMHAQ0KxQEF2Bi4oBsAAM9w +gABYB0GAIJMJIYEAAIgPCFEAGRUAlhBxANgC9wHYi+gD2Bi4oBsAAM9xgADkOxOBAeAToaATAAAE +IL6PAQEAABr0khMAAZQTAQCQEwIBshMDAf4PIAFKJEAAAxICNqASAQAleKAaAADO2LIKr/cBEgE2 +AxINNqAVABAEIL6PAQEAAAXy0grP9tcDQAADzM9xnwC4/xihBshRIACAyiAhIHfypBUAEGcIngTP +cYAA7DkAgYDgANgx8gDYAKGAFQARfhUPER9nz3CAAIAhBIBGEAABH2cDCZ5Fz3CgAMQsy4Df2DoK +r/fJcVMmgRT+vswhIoAJ8pgVABCaDa/1ANp0uPhgAvAA2AMSATYI8A3Iz3GAADjJFnkFkalxSiAA +IM9yoADIH6wVDhCI6KQVAxCxu6QdwBAE8AkmDhAD2xi7b6L4EgMAoWsIJk4TYn6gGoADANuYu26i +C+ikEQAA8bgNzMUgogTPIGEADRocMAGRCOgNyM9ygACMyvQiAAAF6AGBDwieAw3MgLgNGhwwzNiO +Ca/3BhIBNjIOL/sDyAMSATZ8kUQjAAPTCBABDcjPcoAAjMkUesASAAFleGGBHLEVC14DVBEDAbwR +DQHDu6V7VBnEAIYg/QyMIAKCGPQQiQK4FnjHcIAAkNZlkCELUgAGkB0IXgATC1EAYBEAAYS4YBkE +AATwHJGNuByxAZEl6NASAAFUEQMBw7gFe1QZxACAEgAHhOgckYq4HLGkEQ0AFQ0eEmgRAgFTI8AA +WGAQeGgZBAATDV4SahGAAMO7eGAPeGoZAgAHyM9ygACcygQggA8AwAAAEQiBDwDAAAAOGgQEBfAA +2Iu4B7IBkRPoDcjPcoAAjMkUetASAAFTIMCACfLwEgIBz3CgAJgDXqC2GYQApBEAAAQgvo8AAAAw +CPSGIOWPGA1iAMogQgCeCQABDuhKC4/9A9nPcKAAFAQjoIogEACLAWAABhoYMAPIpBAAAAQgvo8A +AAAwzvITCB8F8g9P9dbYKgiv9wYSATYDyKQQAQCpCR4DFgiv983Y1gnv8gHYAxIBNh2xz3CAAIAh +xIBeCO/4AN0ZCFEAz3CAANgfAJCB4ADdzyUhE8olAhQD2M9xoAD0BwWhhSUCHQ1woLADyF2QDXBA +sAPIT4ARCh4AQoYNcECgRpYH8A1wQKADyEAQAgENcECwA8hRgA1wQKADyEgQAgENcECwEBkABAPI +lBAAAFEgQILECQH4GgrP+QYSATa3AGAA0NhyD2/30dgDEgE2AYEfCB4Gz3CAAGAHAJAdsc9wgABk +B0CAAYBRoRKhB/AOCe/yAtgDEgE2HbHGCs/9A8gmDK//eBAAAYDgbgBCANLYJg9v9wpxAxIDNgGD +mBMBAJQbQAArCB4Gz3WAAIjjqXA6Cu/5aHEQ2AwaHDANzKO4DRocMOoMr/+pcC8AQACeEwABvhMC +AZIbBACQG4QABghgAYITAwEIdc/Yzg5v96lxHw0eFgPZz3CgABQEI6CKIBAABhoYMP3Y6wcgAKlx +A8ikEAEAhiHlj0wLQgADEg02pBUAEPS4jgIBAHCNz3KAAHDVdnrPcKAALCAPgIQVDhEgkggggAPC +eLAVDhFk5tFwBAEuAAkgQQACu89wgACQ1nZ7YGAEII4PgAMAADe+Zb6A5somDBQEIIAPGAAAADO4 +DeAB30oiACAPIhIgAxKRACII7/aYFQAQCSCBBJgVABDtuMogwiNAKAMhdHsIcsa6SSLCBVR7z3KA +AGBncmIPCN4CQSoAARQgggAouth6A2oEIIAPAAD8/89ygAB43wOiz3KgAMQsDaIwGkAEB8gNEgM2 +BCCADwEAAPAsuBi4nbgUu2V4BXkqos9ygABYPQiCAeAIoqINb/fe2AMJnkXPcKAAxCzLgN/Yjg1v +98lxBCaPH/AHAAA0v1MmgRQRDp4XDQ+UEACVEOAdCEQAAxINNkogACDPcYAAYDwBgQHgAaEA2Szw +pBUAEPe41SHCA892gAB43yCm4qaYFQAQrgiv9QDaAabPcYAAYDwCgQHgAqEAgfhgAKHPcIAAgCED +gAmADwheAA3MRiCAAg0aHDADEg02AdlKIAAgkhUAETnplBUBEM9ygAB436KSwIJAwc9zpQCs/89y +gACAIdijRIJWEgIBFOJCfQPlIr26ZbpiSCJCAAW6RSJCA1ajUSDAgcoggi8AAIAAIMAEIYEPAAAA +ICW5BSAABCV4ibiOuBmjz3CgAKggCIBCDM/xzwUAAKQVARCnuJIdBBC0uaQdQBCUFQAQkBUDEc9x +pQCs/0DAsBUCEXihz3OAAIAhZINWEwMBFONiegPiIrpbYnpiSCJCAAW6RSJCA1ahIMIEIIAPAAAA +ICW4BSICBEV4ibiOuBmhz3CgAKggCIAD2c9woAD0ByWgDciYFQIQz3GAAMTJFXlAoaQVABAIdIQk +GpAY9AQgvo8AAAAJCfI+CK/9qXC6CK/9A8gM8HAVARHPcKAA9AcnoM9woADIHBwYAAQDEgE209jG +C2/3pBEBAAPIpBAAABMIHwF2C0/129iuC2/3BhIBNgPIAYATCF8GYg2v8gTYAxIBNh2x8guv+ADe +GQhRAM9wgADYHwCQgeAA3s8mIRPKJgIUz3WgAPQHGYUP6AohwA/rcjPYjLjPcwAAbgoKJAAEsQZv +8QolAAQDyByQxXgNcQCxA8g9kA1wILADyC+ADXAgoAPIQBABAQ1wILADyDGADXAgoAPISBABAQ1w +ILADEgE2HJGGIP8MQQgQATOBDXAgoAPIUBABAQ1wILADyFQQAQENcCCwAxIBNhyRhiDzD4wgDIAK +9DaBDXAgoAPIXBABAQ1wILADEgE2HJGGIP0MjCACghz0YBEBAQ1wILADEgE2pBEAACUI3gU5gQ1w +IKADEgE2pBEAAGQZAAS4GQIEuhkEBLe4pBkAAKQRAAAEIL6PAABACAbyAYHwuJALgvIP8DqBDXAg +oAMSATakEQAAhiDzjwXyO4ENcCCgAdkrpQPaSKXPc4AAaDcNEg02QIMA2DkNgBDPcqAAOC5FggQi +gg/AAAAAHwqAD8AAAAD12AW4z3KfALj/GqK7omnYGLgZoihwCQhRAKCjz3CgAPxEPYAZgGkI3wIE +Ib6PAAYAAC704HjgeOB4VQheQwPIz3GgAMgfsBAAAZYgQQ8eoRDYDqEB2BUZGIBWCeAAQdgtCF5D +z3CAAHxaAdkgoAPIpBABAJq5pBhAAM4Lb/8B2M9xgABYPQ2BAeANoQYNAAAacNTYkglv9wpxBCC+ +rwYAygAi8s9wgAD0HwOAgODKIcIPyiLCByvYyiOCDwAAPwTPICIDBfXPcYAAWD0QgQHgEKHPcaD+ +6ADPcJ8AuP82oIcCAAAD2c9woAAUBCWgAxIBNgGBUQjeAKQRAADPcoAAgCFRIACABIID8ruQBPBa +C+/3upDPcYAANDoRiS0IHgADgjCJELkyIIAPAADYAp+5gOAB2MB4D7gleM9xoAD8RA2hBPB2EQ0B +DcxTIECADvLV2NYIb/cGEgE2BsgEEgE2Ggkv9g0SAjbPdoAAiOPJcOoLr/kDEgE2A8gGEhA2z3eA +ALQgoBARAAHYAKeKDW//qXAA2SCnCuiGIH6P5fIDyKAYQAQGGhg0AxIBNpIRAAEPCJ4Cqrj6Ce/6 +khkEAAMSAjZ+EgEBghIAAYASAwE4YBtjDcjPcYAACMoVeQmBcHsbY2mhAYLjCN4A19g6CG/3ANmu +Ca/5gNgGEgE2BCGBDwIAAQANEgI3FwmBDwIAAAAPCF4HTyLBAA0aXDAF8KO6UHkNGpwwAxICNgGC +WQieAU8hwAKMuBB5DRocMBCKMxKCAAS4RXjPdYAANLLPcqAAOC5Egga1EfAvLoEQTiaDFwDeDybO +EMZ6z3aAAODU9CbOEBMIgAPy6s9wAAD//wS1AvBktQjYDBocMM9wgAA0OhGIFwheAc9wgACkOfIM +b/0AiA0SATcDyAGA/bjPIeIB0CHhAQ0aXDDPcYAA5DsWgQHgFqEx8BDYDBocMA3Mo7gNGhwwSg1v +/8lw2NhKDy/3ARIBNgMSAjYBkgnoDcjPcYAAjMr0IQAAC+gBghMInwMNyAHaACCBD4AAFMpAqQ3M +UyBAgAnyBBIBNoogBAAmCm/7mBEBAAPIGpC2DW/5DRIBNg3MBhIBNiUI3gDqDi/319jPcIAAnMoD +EgE2AoCYGQAABsiKCi/2DRICNgYSATbc2MYOD/f9BS/wo8DxwOHFqcGLdalwz3GAAJxgWg4v8CTa +qXDWCa/5AxIBNp4K4ACpcPkFL/CpwPHA4cUDEgE2ooEghbYKL/4k2o7tCiHAD+tyWdiMuO7bSiQA +AMUBb/EKJQABAYWA4OIgAgC9BQ/w8cAqDQ/wmCTBMzpwANhOHBgwABaTQAAWkEAAFpRAABaSQAsK +UiEvIkckTCIAocohyg/KIsoHyiCKDwAAtSjKI4oPAABQAMokKgBoAWrxyiWKBEEoDiHAvkApASSK +IJMC9g0v98V5q+5ZCBAgz3CAAHzJA4gKcYYh/AdFuSZ4UyDNIOC4yiFCA8ohIQBWJMw5IKzhuMoh +QgPKISEAi3SAJEQeIKxRIICAyiBCA8ogIQCLdIAkhB4ArAXwUyD+oCz0AN2EKgoiL3C6cMdwgABw +u4QuBB8E4AAgUA5EKj4nACGAf4AAAMjgiAGIkne4cMwgwYQh8gohwA/rckAsDSRAKw4kh9iNuIjb +BSXEE6UAb/EFJYUDCiHAD+tyQCsOJM9wAACvKG7bBSYEFYkAb/EKJQAECnAuCyAASNlWIAApJgsg +AAbZACWAL4AA3L0jgInugbkjoE4UATYkoCWgA/CCuSOgA4CGIH8OhuCKIBMDyiCCDwAAywTiDC/3 +KnHPcYAArAYL7c9wgAAAyECIHIgLCgEABBlCBACBEIgbCIEECnC+DK/9yXGKIBINrgwv904UATbi +CQ/1xQMv8JUkwTPgePHAfgsv8ADZz3CgAPxEdBAQANmABCaCnwAAAAgL9AQgvq8ABgAAB/QDyKQQ +AAD6uIfyz3CAAIAhBIDPcaAAyB9GEAABH6Eg2A6hGQieJqoLD/SKIAQAQgwv9wDZAN098CUIXiZy +DG/yAd0DEgI2CHGgGgAAhiB+j8IlQRMaDC/3/Ngr8AMSATYbCN4kbyBDAKAZAACKIAgABhoYMIog +RALb8R0IniQA2Je4oBkAAIogCAAGGhgwiiCEAs/xpBEAAFMIngYF2BC4oBkAAIogCAAGGhgwAN3P +cJ8AuP9YGAAICnAWDKAAyXED3s93oADUB9Knkg4P/c9wgAC0IACAgODMJSKQA/QTH5iTA8igEAAA +GPAJ6s9ygADcPBCCAeAQotLxCiHAD+tyCiUACDLYjLjPcwAAJQm9Bi/xCiQABChwoQIP8PHApBAB +AA8JXgLeCo/90cDgfih0hCQSkBHyDQlfBsYNj/YH8CDZz3CgAMgcKaAD2c9woAAQFCWg6/Hr8fHA ++gkP8AonAJA6cQDdFvLpcS8oQQBOIIIHz3CgAAwtT3rwIIAAwrgPJQ0QANgPIIAABiEBgO/1Ku0v +KEEDTiCOBw0amDP12AW4Ogxv98lxDcjPcqAAFAQKos9xoABkLvAhAABTINAEKYKuCi/32tgqcAIO +r/UEIMEjxgsv+8lwANgPIIADBiUNkNn1z3KAAGg3AIIH2Q0aWDA/CNABz3CgADguBYAEIIAPwAAA +ACMIgA/AAAAA9dgFuM9znwC4/xqjO6Np2Bi4GaMB2ALwANgHCFEAIKLPcKAAFAQqoH0BD/DgePHA +IgkP8Ch2RiHNAB1lMgggACK5wb4fDlAQEw6QEB0O0RAAFoBAAR0SEAAWgEABHRIQABaAQACtVQEP +8KsJEABAIcIDJLrDuQLwANmVCRUEMyZBcIAAbGBAJwNyNHsAewAWAUAEGFAAABYBQAQYUAAAFgFA +BBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAE +GFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAQiJCgLP1 +4H6A4cokTXDgeOggrQEAFgFBAhhUAOB+4HjxwBoID/AA3c93AAAEHUogACKpdhUigDMOEAEGANjP +cqAAFATKoqiiJ6IEoj1liOFoucohDgBqCm/36XBCIFAgIOfVCHWgAeY1AA/w4H8A2PHAvg/P76HB +GnBKIwAgABzANIogBwnOCC/3CnHPcIAAdF0yIBIEz3CAALQG0YgSiBB2UgEJAGp3CiHAJALwenVE +Lr4TACJALs9xgACo5DMhDQC7fS8IMyatfc9xgABwGRqBO4EkeB8IHgLPcIAAtAYLiItzyXHuDa/3 +qXIAwAJ9rX0AJoAfgAC0BhwQwQDPcoAAAD4AigXaLg8gAKlzz3GAAKxaIIEA3UokgHEieKggQAVz +bnR7tXvPcoAA9J95YiGJemIK6SMJAAApCEIAMQ1TEQHlr30L8EIlkRAvIUckYb2vfRDwAxLPAADZ +anUN8IDlSiEAIMolYRAG8kIlURAvIUckAdkt6fNu9H8VJ0ETz3OAAPSfOmMAI0UAFSdPFPljIYlB +ivtjNQmjAOOLAiJEAAMVggAEv/B/IngEui8kCAECJ4MQbHgvIEYOPggv8IhxDngCfwjn7n9Ev+1/ +CwgSJgrn7X/JcApxqgwgAOlyAebPcIAAtAYSiM9+EHbCBsz/lQbv76HA8cBCDs/vCHYodUh3GnNP +eRC5D3gIuAV5iiBHCD4P7/aleYDnzCAioAjyLG0vec9wgAC0BjOoB/DPcIAAtAazqKlxz3KAALQG +tKrAqvWqFhoCBA4KIADJcAAQhwDhiM9wgAC0BtGIEogQdp4BCQBELz4HL3GELgMRCiRADgAhQw4K +IYAfgABsoCFzQC+CAFR6hC4BFQolQA4AIk0OCiaAD4AArOMAJkgDACaNH4AAtAZMJwCAzCdigCb0 +GhPAAADZGK0bE8AASiSAcRytGIsgHQIQqCBABhQgQBBBiLNutH01fcd1gAD0nwAQwABArRUjQgAB +rQESwAAB4QKtAIoveQOtevABE8AAmOgA2litXK0gHYIQSiSAcQDZqCDAAxNuFHg1eMdwgAD0n0Co +QahCqEOoAeEveWDwfLkAJEQAbLoAIkEBACGFAQAkQAIaiDqL+gggAOlyGK0AJEACG4g7i+oIIADp +chytACRAAhiIOIsAJEQC1gggAOlyIB0CEADdSiKAERQlSwMUIEkTAROAEAERgRC2CCAA6XIzbjR5 +tXnHcYAA9J8AqdhxABOAEAARgRCaCCAA6XIBHgIAFSRLAxUjSQMBE4AQARGBEH4IIADpcgIeAgAA +E4AQABGBEG4IIADpcgMeAgBCIkoQAeWZCnWQr30B5s9wgAC0BhKIz34Qdm4GzP8A2c9wgACoWpkE +7+8gqPHA4cXPdYAAAD6KIMcJOg3v9iCFAIXPcYAApFoggU1oMHLAIGwBzCEMgCQLCQB9BM/v4HgC +eS15THlWIQFyR7k4YOB/D3jgePHAuHE1CFEACQ1SAB0N0gMKIcAP63LPcAAA1xSKI4gCOQAv8Uok +AABALYEAZLkAIYAPgABcEx3wz3CAAGQXMiBBAYwhw4/KIcEPyiLBB8oggQ8AANgUyiOBDwAAEAL8 +B+HwyiQhAM9wgACMFTV40cDgfuB48cDPcoAAxgYKaqIJIAApagYOAADOCAAAz3GAAJhwIIHPcIAA +IBIiCCAAAdrPcYAAlHAggc9wgABMEQ4IIAAA2tHA4H7xwCoLz+8acEh3kQlyAADdOnEVIEAjQIgC +iAzvz3aAAFwTFX4CuBR4x3CAALQSC/DPdoAAjBUVfgK4FHjHcIAAlBMhiEsJHgAFEMEAIq4GEMAA +A67pcL4MIABIcQCugODMIGKAyiAhABLyRCg+BwAhgH+AAGigxRCDAOEQgQACIsAAEHgHuGoM7+9i +eQGuQiFBIIEJdYAB5fECz+/xwJYKz+/PcIAAtAYREIgAz3CAALQGEoirCAICSiYAAEohwBFELj4H +L3CEKAMRJ3AAIIEPgABooB8RywAAIIEPgABooB4RygD4cADeBt8AJ40PgABooNV9B41pcQXamHAu +CiAABRXDEEAuggBUeoQoARUAIkEO1HnHcYAArOO4cQCpiHBJcQfaBgogAAYVwxABHQIAYb8B5rcP +dZDPfkIhSRBAJkYAgQl1kC8mhwFAIEgQz3CAALQGEogvIAcSYQgDgj0Cz+/geALbYKgA2ACpAdjg +fwCq4HihwfHAugnP76HBZcIIdih1z3CAANoGhcGLckAkQzDCCyAAAIhELr4WACVAHhQUwTDPd4AA +uKL4YHcNMxYgqFMlgBBNCFMBRiXNEa99G/ABFIAwACaBH4AAGOFSbVR6WWEgwgCpRC6+FgAlQB5E +qRQUwTD4YCCoyXBeCCAAqXEB5a99UyWAEMsIUoEh8AEUgjASbRR4ACaBH4AAGOE4YECoIMJEqMlw +MgggAKlxD/BCJQAWD3gBFIEwx3aAADDiArgUeB5mIMAorgyuCNxbAe/vocDgeOB+4HjxwOIIz+8A +3s9woAC0D3AQEACKIMcIz3GAAAA+3gnv9iCBBghv/clwz3GAALQGsokRiSUNAhDPcoAAUKh/2xQg +DwBfZ2Cvwa8B4A94BdvxDSOQYq/PcIAAaKBBkM91gACsWsClCOrPcIAAtFoAgIwgH4QE9gDZFfD9 +CIOPAACgD0J4QImA4oohDwrAKOIABfREKL4DL3AOCs/vCHEApV4J7/aKIMcIAN0O3s93gAC4X2oI +7/+oZ2G+AeX5DnWQr33PcIAAAD4ggM9wgACkWiCgVg8v/S8gBwRtAM/vDngseClqANgPIEAAJ3Ba +eOB/DiDAAOB48cDiD6/viiCHCM93gAC0BvYI7/YzjwCP8gvv/zOPz3CAAKBaABDQAM9xgACsJBSP +R4khCgEAAI8hiRkIQQDPcIAAqVoAEMAACSAABC8gBSCxjwTwAeWvfRKPEHX6AAkAAN5KIoAjz3CA +AKFaAIgR6EQtvhMAJkAez3GAAKBaABHCAAAggQ+AAKjkQKle8M9wgAA8LSCAYHkA2BsIEQPPcIAA +qF/JYAIgQCANeEggQAAD8EggQCAvIQUgz3CAALhfy2ATj6lx2gjv9lWPCSBABC8hBSDPcIAAPC0g +gGB5ANgAJZMfgADQBhkIEATPcIAAPC0ggGB5ANgEE4EgGQgRA89xgAAYCclhBBOAICJ4CSBBBAnw +z3CAAJhfyGACeQkhQQRELb4TACZAHsdwgACo5CCoOnATj6lx6g6v/8lyABHBIAJ5ABlCIEIiUiAB +5hsKdaDPfoDx5QaP7+B48cCWDo/vCHXPcIAAby0AiCh3Ew0BEM9wgABuLQCIUw8AEM92gAC0Bqlw +QCaBEjoJr/dAJsISCo6veiuOGLoIuAV6iiBUDWYPr/ZFeSqOBG7yD2/3S44KjmYOb/crjs9wgABv +LaCoz3CAAG4t4KiRBo/v4HjhxZnojCHCjQHYWfZKJIBxz3OAAEihqCDAA6FrRCg+BzIlTR4XDUMQ +B+0TCJABAeAPeADYA/BhuA944H/BxeB44cXhxgARzQAJDRMQAN2gqRvoDQ0TEADYAKkA3c9wgAA4 +XgCQCw0CEKlorX2gqc9wgACQXRQgTgOgjqCqABHBADR4AYgZ8AsNExAA3aCpz3CAAOReAJANDQIQ +qWitfaCpz3CAADxeFCBOA6COoKoAEcEANHgBiACrwcbgf8HF4HjxwGYNr+8A2KHBABwEMM91gACY +BwCVz3aAAGigyXGKIgQKbghv9wHbj+gKIcAP63IAFQQRz3AAANsUh9uLu5UB7/CKJQQKABaEEEwk +AIHKIcsPyiLLB8ogiw8AANwUyiOLDwAAjADPI+sCaAHr8MolKwC+Do/2gODKIcIPyiLCB8oggg8A +AN0UyiOCDwAAkgDPI+ICyiQiADgB4vDKJSIAi3FF2AHa6g8v9wHbj+gKIcAP63LPcAAA3hSV24u7 +iiRBAREB7/BKJQAAABQAMQHZhiD+D8DgwHnPcIAAZBggqPEEr++hwOB48cB+DI/vCHXXdSUAAIAA +2Er3z3GAAPjeJYElCUUDIn0B4Pnxz3CAAPjexYCpcOoNr+/JcQUuPhACJU0ejCAQgMohxg/KIsYH +yiCGDwAAzSLKI+YMyiQmAJAA5vDKJQYBFriJBK/vpXjPcYAAWAcNCFEAAdgAqQGpAImB4MoggQ8A +AMQJyiCCDwAAgADgfwGh8cDuC4/vCHXPdoAABDCKINgO7gyv9iCOiiDYDuIMr/YhjgCOuGAArgGO +HWUtBK/voa7geEGJArgWeMdwgACQ1kioIongfymoz3GAAIAh8CEBAIogCADgfw6h4HgNEgI2BCC+ +j2AAAADPc4AAjMlUe8dygAD8yQhxBfIDyByQFwieAgQhgQ9hAAAAEwmBDwEAAAAA2ACzAdgc8AzM +AxIBNhsI3gEyEYEAAYsNCEEAANgBq/PxAeABqwvwMRGBAACLCwhBAADYAKvn8QHgAKsC2OB/GKrh +xeHGz3KAAKQGgODAIiIB/90SaRZ4ACCDD4AAl9agqwDdSiQAcc9zgAB43qgggAKuYnhlNnjEqK5i +AeWvfcCowcbgf8HF4HjxwNIKr++KIMoFocHPdYAAoDlAlc92gACcOSCWELrGC6/2RXnPcIAAcBsA +gHcIkAAAhSCGTQkAAM9wgADMJwSAQMENCJ4ATyEAAUDAiOlKCi/1ANg+Cg/1lg/P9otwBNmh2j3b +7g3v/Be7IIYJ6QCFh+gmCi/1AdgCDs/2IIYgpRHpPgsP9X/YCrjPcaAA0BsToX/YEKEA2JW4EKG2 +Cu/xAdidAq/vocDxwCYKj+/PcYAAgCEVeUCBCIIEIIMPgAAAAEQgDwIvuwa/ZX8EIIMPAAEAAEEr +TgPlfiy7xXvBEg4GwBINBmELgAMEIL6PgAEAAB7yz3aAAMgkyI4xDtERvrgIokCBCIIEIIMPgAAA +AEQgAQIvuwa5ZXkEIIAPAAEAAEEoQwMleyy4BXvBGtgACu0vKUEDTiGABxIIIAAQJQ0Q+e3xAY/v +8cCGCa/vmHAbCBQECiHAD+tycdiNuIojjQvdBa/wSiUABEokAHQA26gggA5ALI0BdX1ALIIAx3WA +AFDaAIXPcYAAkNZWet24QWEApfG50SAiggjyRCACBiO6AeIVCpUAz3KAANDYFiICAUCKCQoeAJ64 +FPAtucC5z3eAAIAh8CdPEFIgTgLBFwEWCyGAgwfyKIfhCZ6Hn7gApQHjUQGP789xgACAIfAhAADP +cYAAOMm7EAIGuhADBkKhYaG8EAIGvRAABkWh4H8GoeB4z3GAAIAh8CEAAM9xgAA4yb4QAAYWIQIA +ApIasQOSG7EIijgZAgAA2OB/HbHxwOHFz3OgAKwvGYPwuBmDAN0M8gQggA8IAAAA13AIAAAAAdjA +eAfwhiB/D4LgAdjAeBroGYMEIIAPDgAAAEIgAIDKIGIAIQhQAAohwA/rcmQTBADPcAAArg2Z26EE +r/BKJQAAagrv9lTYRCABAkcIHgHPcp8AuP+9ohzaFfDPc6AAyDtWg7aDhiL/CIYl/xileraDhiX/ +GKV6z3WgAKggrYXk5ZD37eoC289ygABwG2CiUSBAgM9ygACcOQCCEfKBuBDwOBMEAFgTBQAKIcAP +63LPcAAAmSElBK/wL9uhuACiPwieAM9ygACwWgCCMwkAAM9wgABmGACIIKIVCFEAz3GAAGA5AIEJ +CFIAargAoQHZz3CAAOwf8gjv/SCo6QdP7+B44H7geM9xgADcPFwZwAfPcYAAJCBQgZ24nrgggs9x +oADIHA2h4HjgeOB44HjgeOB44HjgeACC4H7xwOHFIN3Pc6AAyB+wo0MbGAAA2LoP7/+NuLGjjQdP +7/HADg9P76HBGnAodkh3iiARBRYIr/Z62YogEQUKCK/2CnGKIBEFAgiv9slxiiARBfYPb/bpcc9w +oAAsIDCAz3CAAPw4IKDPcKAALCAQgM9xgAD8OCCBz3WAAGw3IngApYtxdg1v8ApwAIUVCMUDABQA +McR40w4BkAHYA/AA2PUGb++hwPHAig5P7891oAAsIEAVEBBAFQUQDwnfAgQgvo8ABgAAJvJNCR8D +z3YAABAnB/Bi2GYJb/aMuEAVBRDPcKAA/EQZgOy4AiUABAP05wiCgyEIgg8AABAnCiHAD+tyiiCa +CmnbjLuZAq/wCiQABIEGT+/PcKAA9AfxwFcIHkMngBmAMHk4YAO4liBCBc9xoADIHx6hENgOoQHY +FRkYgI4O7/+B2C8IHkPPcIAAfFoB2SCgA8ikEAEAmrmkGEAABgmv/gHYz3GAAFg9DYEB4A2hA9nP +cKAA9AcqoNHA4H7xwADZCtjPcqAAyB8eohDYDqIB2BUaGIAocAfwAdkEIIAPIAAAAFEgAMPMISGA +zCAhgBf0KwsfQM9wAACfF34IT/bPcqAA/EQdglmCANnRCt+CBCC+jwAGAADi9eHxLwseQM9wgAB8 +WgHZIKADyKQQAQCauaQYQABuCK/+AdjPcYAAWD0NgQHgDaFRIADDANgJ9M9xgADcPBCBAeAQoQDY +mLjRwOB+4HjxwAYNb+8A2Qh3z3CgACwgQBAQAM91nwC4/x2Fz3aAAIgGPaUApgzwxg5P8M9wDwBA +QpYNb/MKcSEIUADPcKAA1AsYgEIgAAhIIAAA3QjEgwCGHaUVBU/vAIYKIcAP63Je2x2lz3AAAM4i +iiTDDw0Br/C4c/HAggxv7wHZpcEacM91gACkBlp1ogtv/4twABSFMAEUkTALCFEgQCUSEQsNUgAd +DVIBCiHAD+tyz3AAACklrNvFAK/wSiRAAEwlAIAmAQ4AqHAAFo5AABaUQA8MMiR6cIwkw68l9AAW +AEEAFo9AABaAQAAWAEGFDBMkKO/PcIAAWBcAgEAszSC1fRDguGAqC2//BNnPcIAAWBcAgEwhQKAd +ZcwnYZMa9ADYjLgX8AohwA/rcs9wAAAqJbfbSiRAAEUAr/AKJQAFCiHAD+tyz3AAACslwNv08QDY +ALXPcIAAWBcAgEAswSA1eTJgOGAFIkIEQLAE3QfwgcAE3boKb/+pcQAijCMAHAIVz3CAAIAh8CAA +BB7fwBACBi8pgQACJ0AQJOoyaM9zgACX1jZ5K2MTC44DACaBH4AAeN4WeQAZAgUALYETCyHAgAny +ACaBH4AAeN4WeQQZAgUQIgKALymBAAInQBDg9UIjQCCA4OYGzf92CU/0YQNv76XA4H7geOB+4Hjg +fuB44H7geOB+4HjgfwHY4H7geOB+4HjgfuB44H7geOB+4HjgfuB48cDqCk/vCHUG8M9wAABrDuIN +D/bPdqAAwC+jFgCW7wgegQfIQB4YkA3IDwiRAUYNL/+pcHzwz3eAAIjjCo8J6EAngBJAJYES6g8v +/Qraz3CgANQLGIBCIAAISCAAALDggA3l/8ogJQwDyAOQJbjAuBe4x3AADgAARSABC+xwIKABEgE2 +7HAgoCCF7HAgoCGF7HAgoCKF7HAgoCOF7HAgoCSF7HAgoCWF7HAgoCaF7HAgoCeF7HAgoCiF7HAg +oAfwz3AAAE4OLg0P9qMWAJb1CB6BB8gEIIAPAQAA8Cy4lODAIIYPAACTAM9xoABoLPAhDQDPcIAA +gFrAgNnYAgtv9gUmQROWCG/0BSZAEyqPDumKIFIN6gpv9oe5z3GAAEQ9F5EB4BB4F7EA2AqvJQJP +76HB8cCiCU/vo8FMwRpwSHU6cwoiACFpCV4CAtnPcKAAyB9JGFiALMFTbe7hUHgG9L4JL/OBwRrw +EQnRDRt4EHiuCS/zgcER8AkJEQUceArwCwmRAgQchDAG8M9wAAD//wQcBDDgeADYz3KpAKT/uaIE +FAExgrg3ohqiCfBvCR4CTCIAoNEg4qEF8s91oADIH0zwz3KlAKz/z3CAAIAhuKIEgFYQAAEU4AIh +AyAD4yK7eGN4YEggQAAFuEUgQAMWokEowCHAuHdoLMAEIYEPAAAAICW5z3WgAMgfZXgleIm4jrgZ +okAVABYg8CzAgODKIcEPyiLBB8ogIQ7PICEDyiMhBc8jIQPKJCEAIAVh8MolwQAFvaV4z3GlAKz/ +FqHPdaAAyB9AFQAWz3agALRHVxYBlkojACBKJEAgBCG+jwAoAADPcYAAJCAwgSCBwiQCJQXwsthu +Cy/2jLhvFgCWBCCED4AAAAAEIIIPIAAAAAQggw8ABgAADwwQIEAVARYLCdQAANkC8AHZExUPlgQg +vo8AOAAABCePHwAAAIDMISGAwCNhIAUiAQHleQUh/oAE9KMLlKIF74DizCMhgI3yaxYTlpsLECBq +dIQk0JEK8s9xgADkOxCBAN0B4BChnL1f8BUL3iDPcYAA5DsRgQHgEaFC3VXwanSEJAKYCfLPcYAA +WD0RgQHgEaEN8BULniHPcYAAWD0EgQHgBKEF8FMjPqMD8gDdO/AZC14jJgxP/c9xgADUPQWBAeAF +ofXxvgnP9AohwA/rcm8WBZZE2Iy46duMu9kDb/AKJMAECerPcYAA3DwQgQHgEKHd8S7rFwieBs9y +gABYPS+CAN0B4S+ikb0K8CkIXgbPcoAAWD0ygkLdAeEyopoI7/9qcd3YANkyCG/2mLmYvUnwcRYE +lm8WBZYKIcAP63I52M9zAAACEW0Db/CMuIoLT/3PcYAA3DwRgQHgEaGn8RMVAJbwuMogIQB0D6H/ +zyChA2sWAZZYFgCWCyBAgCDybxYAls91oAD0B1MgQIAB2BDyCaXgeADYCaXPcYAA1D0IgQHgCKHP +cZ8AuP8WocoJb/4B2APYCqUF3Zi9A/AA3ZftFwjeIR0KESAB2c9woAD0ByygA9kF8APZz3CgAPQH +JaBRIICigAjC+R7wAxIBNs9wgACI3w8JAADPcIAAUOAbCQEAkhEAAaq4khkEAJ4RAAGquJ4ZBADP +caD+ZADPcJ8AuP82oM9wgADkBgCAB+jPcYAA/CcFgSJwBaHPcYAA5DsPgQHgD6HPcIAAVLshgM9w +gACAIQOAFJAdCQEAz3GAAHAZGoE7gSR4USAAgkQM4vbKIGIAqXAI3AsGL++jwOB4ocHxwLoND+8o +dQh2GnIEIb6PAQAAwGh3LfQvDR4SRCUAFiO4IWgEJYAfBgAAADG4OGAEJYEfBgAAAddxAgAAAcog +oQAC8AHYIQhQABMIkACD4ADYyiDhAcAooQMK8M9wgAB8yQKABvDPcIAAfMkBgAV9yXB+CW/6qXHJ +cKlxCnLpc4oL7/9KJEAAgOCED4H/CNyTBQ/v4HjPcKQAkEFNgM9xgADwy0KxGoADsQQggA//AAAA +MLgEsc9wgADwywDaEQheRs9xgADcyjKBCwmeAkKwQ7BEsOB/WbDgePHA5gwv75hwz3CAANzKDpDP +doAA8MsAts9wgADcykgQBQAEJY+PAAAAAgDbA/IXDR4Cz3GmAOj/C4EDpgyBBKYD8GSmY6bPdaQA +tEUMFQKWDRUAlv/ZLyCHEBC5BCJJACzvMhUBllMhjwD/ZyG2/9n0fwi5739EeUAvBhIAJkcAACDI +EwUnBwJALwEWBCKCDwD/AABALwgUOmIAIEgS/9kFJwcCCLkFIsIBBCBHAPhgACeBASV45bZPeQQi +gg//AAAAKLpFeSO2D3gEtgQVAJYCtiMNHgJEJQAGI7gB4BcIlADPcaYA6P8NgQWmDoEGpgPwZqZl +pgDaSiSAcAbZjbmoIAADKdgSuPAgQwBAJgAfVXgB4WCgAeLPcIAA3MoAkDgeABFVJkEUGrbPcIAA +yMuyCS/9CNobFQCWz3GlANjLGaYcFQCWGqYdFQCWG6YOgRymD4EdpiYVAJYeps9wpACQfxyA6QMv +7x+m4Hjhxc91gADwywmlKqV4tUulAdgZteB/wcVKJAB6ANmoIIACANrPcIAA8Ms1eECgAeHgfuB4 +ANkgoOB/IaAEAAAAAEABAAAAAACoEkN1AQYAAQAAAAAAAAAAED6AAKQ+gAAAlIAABCCAAAQJgACM +BYCBDxobIgAAGyUCABtAAAAbcTAGgIEAAMAWDxsLIjQGgIEAAMAWDxsKIjgGgIEAAMAWDxsIIoQo +gIECAFxuEQAAYfhBxBAPGwkiAAsJOQIACmIDAQpiBAIKYgAACUAEAABhCQAJQAIAAGEKAAlAAAAA +YQIACUEACRooAADAFgEAGyYAAMAXBAAdJgEACCfpAAhkDyAbIjgGgIEAAMAXjAWAgQ8aGyIAABsl +AgAbQAAAG3EPRQAiAFwAOQcAAGIGYABiAABYOGBFwBBwRcAQeEXAEJBFwBBsAABhCABYbvgPAGEA +ABMlAAATJCQQwBGAABMlR2gTJAQowBEAgBMkOBzAEQ8AEyIBABMwBCjAEQ9zEyKCARMwBCjAEQ90 +EyICAhMwBCjAEQ91EyJCAhMwBCjAEQ8UFSIBABUmD3ITIggAzBEPRAAiCgAAQABAAHAOAABhAAAT +JQIAEyTsHMARD3YTIhgIyhEJABNAHAjKEQkAE0AgCMoRD3gTIgQAyhEAAAEkAAABJQYAAGEPdhMi +LEjHEQ94EyIAAMYRAwABJAAAASUAABMlwiwTJAQowBECRhMkBCjAEcJfEyQEKMARD0UAIgBcADks +AABkAAATJAEAEyU4HMARD3cTIuAcwBECAAFiDwETIgQIwBEYBsASBCjAEQ8TAiIcBsASBCjAEQ8T +ByIgBsASBCjAEQ8TBCICAHFwBwAAYf8AEyUCEBMkBCjAEQAAEyUAABMkyEnHEQYAAGEAABMlAhAT +JAQowBEAABMlSQATJMhJxxEPcBMiAQATMAQowBEDABMkAAATJQQIwBEAABMkOEXAESQGwBIYKMAR +DxMDIgQAAGEAAFg4AAATJAEAEyU4HMARAAAVJAAAACEEBoCBAADAFg8bUCIIBoCBAADAFg8bGiIM +BoCBAADAFg8bGSIQBoCBAADAFgAAAIUABoCBAADAFg8bBCIcBBtmGwEbaBQcwBAKABtABAAbbgsA +AGEPHB0iAQAdJvkPAGEUBoCBAADAFgUAG2KMBYCBDxobIgAAGyUCABtAAAAbcWQMABAAwAYRAQAE +J/wABGQAABskAgAbJTgcwBGMBYCBDxobIgAAGyUCABtAAAAbcQAAGyVAABskMBzAEYwFgIEPGhsi +AAAbJQIAG0AAABtxoAaAgQAAwBYCARNkQgETJAQowBF8WoCBAADAFgYBE2IECMAQBAATZA9cACIK +AABAAAYAcBkAAGEAABMkAAATJQAAwBcACFgwyCDAEHBFwBAQCMAQAAATJQMAEyQcCMARHAjAEQAA +EyQECMARDxQVIgQAFSb7/zAyAwATJBgIwBEPFBUiAgAVJgQAMDAAABMkEEXAERgIwBEAEFgwD3wT +IggAzBEAABMlAAATJDRIxxEPexMiAQATMAQowBEPFBUiAgAVJv8AEyUCEBMkBCjAEQ8UFSICABUm +lAeAgQAAwBbCLBMkBCjAEQJGEyQEKMARwl8TJAQowBEPTRMiBBDFEQIAEyTwHMARAQATJOwcwBEA +ABMkcAATJRAcwBEAABMlAAATJOAcwBGAABMlRmgTJAQowBEAABMlAQATJCQQwBEAABUkAAAAIQ8O +GiIAAEAWAAEbcA0AAGGAAGMk//4bMgAAQBcAABslDxsPInAGgIH/ABsyAgAbQQAbGigAAMAWAAAb +JQIAG0AAABtxAQBkcAcAAGEBAGMkAAAbJFIGgIEAAEAXSAaAgQAAQBbtDwBhAgBkcBAAAGECAGMk +AQAbJFIGgIEAAEAXSgaAgQAAQBbkDwBhBABkcAcAAGECAGMkAgAbJFIGgIEAAEAXTAaAgQAAQBbb +DwBhAAAdJAAAACEAAg9uCQAAYVIGgIEAAEAWAAAbJU4GgIEAGxooAAAAFgEAGyYAAAAXDQAAYWgG +gIEAAEAWAgAbJgEQG2gAABskAABAF1QGgIEAGhsoDxsOImwGgIEAAEAWAQAbJgAAQBfUBICBDxob +IgAAGyUCABtAAAAbcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAC8AoAAPACAAAAAAAAAAAAAKACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAcAAAAA +AAAABwAAAAkNERQKDRMXGRkZGQkJAACwqYAAeIEAAJiugAAAAAAAmK6AAAAAAADfAAAAGQEAAGIB +AAC+AQAAMgIAAMMCAAB7AwAAYgQAAIQFAADyBgAAvggAAAILAAABAAAAAAAAADCAAAAAAAAAMYAA +AIiIMzMygAAAAKqqijOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaAAAAAAAAAN4AAAAAAAAA4gAAA +AAAAADmAAAAAAAAAOoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAAAKqqCgA+gAAAU4WIiD+AAAAA +AAAwMIAAAAAAAAAxgAAAmplYVTKAAAAAqqqqM4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAAAAAA +AAA3gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAAqqoK +AD6AAABVmJmqP4AAAAAAAFAwgAAAAAAAADGAAAAAAAAAMoAAAAAAAAAzgAAAAAAAADSAAAAAAAAA +NYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAAAAAAAAO4AAAAAAAAA8 +gAAAAAAAAD2AAAAAAAAAPoAAAAAAAAA/gAAAAAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAAADOA +AAAAAAAANIAAAJp5AAA1gAAAqqqqqjaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAA +AKqqqgo7gAAAAHCZqjyAAAAAAAAAPYAAAAAAAAA+gAAAAAAAAD+AAAAAAAAA//8AALQAIAAZASAA +tQAhABoBIQAEAAgA1AEDALMBBAB4ADwA3QA8AHkAagDeAGoAqAABAA0BAQCcAcwAnQHMANUBzADW +AcwApAGAAF0CNgBKAg0ATAIPAE0CAQCtAQYAuAEAALsBVgCPAIgA9ACIAJAAAAD1AAAAkQAGAPYA +BgCFAAQA6wAEAFACCwBRAgMAUgIBAFMCAABUAgsAVQIDAFYCAQBXAgAAuQHBANABAABmAgYAaAIH +AGoCBgBsAgcAbgIFAHACDAB9AgYAfwIHAIECBgCDAgcAhQIFAIcCDAChAUAA+/8AAP//AAC0ACAA +GQEgALUAIQAaASEABAAIANQBAwCzAQQAeAA8AN0APAB5AGoA3gBqAKgAAQANAQEAnAHMAJ0BzADV +AcwA1gHMAKQBgABdAjMASgIOAEwCDgBNAgEArQEHALgBAAC7AVYAjwCIAPQAiACQAAAA9QAAAJEA +BgD2AAYAhQAEAOsABABQAgsAUQIDAFICAQBTAgAAlAILAJUCAwCWAgEAlwIAAFQCCwBVAgMAVgIB +AFcCAACYAgsAmQIDAJoCAQCbAgAAuQHBANABBABmAgYAaAIHAGoCBgBsAgcAbgIFAHACDAB9AgYA +fwIHAIECBgCDAgcAhQIFAIcCDABLAgEAoQFAALIAMAAXATAAswAAABgBAACcAg8AoQIPAKACiACf +AogAngKIAJ0CiAClAogApAKIAKMCiACiAogA+/8AAAAAAAACAAAADdIS0hPSFNIM0hXSC9IC0hHS +BEMAEBQQCRAREAFAG9Ic0gDSCgALAAQADgC1ABoBDwBCALwAwwAhASgBtgC3ALgAuQC9AL4AvwDA +ABsBHAEdAR4BIgEjASQBJQERAAAACgAAAAoAAAC2AAAAtwAAALgAAAC5AAAAtgAAALcAAAC4AAAA +uQAAAL0AAAC+AAAAvwAAAMAAAAC9AAAAvgAAAL8AAADAAAAAEtIAABLSAAAAAAIALABkAHQAgACM +AKEABwAAAAAAAQACAAMAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAABwAAAAcAAAAAAAAAAwAAAAQAAAADAAAAAAAAAP8DAAADAAAAAAAAAAAAAAAAAAAAAQAA +AAEAAAAAAAAAAAAAACwAAQAAAAEAAQABAAAAAAAAAAAAAQABAAIAAgACAAMAAwAEAAQABQAFAAYA +BgAHAAcACAAIAAkACQAKAAoACwALAAwADAANAA0ADgAOAA8AAAABAAIAAAAL0g7SDdII0gnSCtIS +0hPSFNIR0hDSAtIB0gPSAIAF0gRDG9Ic0gTSAEUw0jHSAAC1ABoBgQEFAAQADwAQAAoACwAMAE4A +AAAAAAEAAgAAAA3SEdIQ0gLSAdID0hvSC9IAgAXSEtIT0hTSBEMI0gnSCtIc0gbSB9Jw0gAAtQAa +AYEBBAAPAIMA6ABOAZIA9wBdAQYACAAJAAoACwAMAAUAAAAAAAAAAAAKAAAAAQAAAAAAAAAAAAAA +AAAAAAMAAAAEAAAAAwAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAP8DAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAALAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQABAAAABNIN0hHS +ENIC0gHSA9Ib0gCABdIL0hLSE9IU0gRDcNIAAAAAAQAAAAEAAAABAAAAAQAAAAMAAAACAAAAAwAA +AAMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAP8DAAAAAAAAtQAaAYEBBAAPAAYACAAJAAoACwAMAAAA +AAAAAAAALAABABUAFQAVAAEAAQABAAAAAAABAAIAAAAc0g3SEdIQ0gLSAdID0hvSC9IAgAXSEtIT +0hTSBEMG0gfSBNJw0gAAtQAaAYEBBQAEAAYACAAJAAoACwAMAIMAkgDoAPcATgFdAQ8AAAAAALcT +IgC4FCMAuRUkALsWJQC8FyYAvRgnAMAZKADEGikABxsAAAgcAQALHQIADB4DABAfBAAiIQUAJCIG +ACYjBwAoJAgAKiUJACwmCgAuJwsAMCgMADQpDQA4Kg4APCsPAEAsEABkLhEAaC8SAGwwEwBwMRQA +dDIVAHgzFgB8NBcAgDUYAIQ2GQCINxoAjDgbAJE6HACVOx0AmTweAJ09HwChPiAApT8hACRJBgIs +SgoCNEsNATxMDwFkTREBbE4TAXRPFQF8UBcBhFEZAZVSHQGdUx8BAQQAAAIFAQADBgIABAcDAAUI +BAAGCQUABwoGAAgLBwAJDAgACg0JAAsOCgAMDwsADRAMAA4RDQABQAAEAkEBBANCAgQEQwMEBUQE +BAZFBQQHRgYECEcHBAlICAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAQBwAAEQcAABMHAAAyBsAAMwbAAA0DKAAQAygABwcoABAIKAAKCSg +AGwQoAAYJKAAeCSgAHwkoACAJKAAhCSgAFAQoABUEKAASCagAGAQoABMJqAAZBCgAGgQoABcEKAA +WBCgADAQoAA8EKAANBCgACwMoAAAgaQAAYGkAAOBpACIJKAAjCSgAJAkoACUJKAAmCSgAJwkoACg +JKAApCSgAIBxgAAAAAAAsgwsAf////////8AAf//AgP///8E//////////////////////8F/wb/ +B/8I/wn/Cv8L/wz///8N////Dv///w////8Q//////////////////////////////////////// +//////8R////Ev///xP///8U////Ff///xb///8X////GP///xn///8a////G/////8c////Hf// +/x7///8f////IP///yH//////////////////////yIjJP8lJif//yj///8p//////////////// +//////////////////////////////////////////////////////////////8AAQABAQAAAAAA +AAAAAQAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAgyAQAAAAAA+HgAAAEAAAC4xgEAAgAA +ABDGAQADAAAAPBYCAAQAAAAIMgEABQAAAMgeAQAGAAAApPAAAAcAAABQHwEACAAAANgvAAAJAAAA +jFIAAAoAAACMzQAACwAAALAsAAAMAAAAQBYCAA0AAADU5wAADgAAAIDoAAAPAAAAYOcAABAAAABg +6AAAEQAAAPA+AQASAAAARN8BABMAAACEJAAAFAAAAFhkAQAVAAAATE8BABYAAADYXgEAFwAAADzF +AQAYAAAAwI0BABkAAADcDAEAGgAAAAQyAQAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAP//////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsmwAA7JsAAOybAADshwAA +7JsAAOybAABQiAAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAAuJAAAACQAADw +jwAAII8AACiQAADcjgAA7JsAAOybAADMkgAAnJUAALSXAADsmwAA7JsAAOybAABUmwAA0JEAAAiS +AAB0kQAA7JsAAOybAADsmwAAEJsAAOybAABUkQAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsA +AOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA +7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAAAUiQAA7JsAAOybAADs +mwAA7JsAAOybAAB0mAAA7JsAAOybAADsmwAA7JsAAOybAABgjAAA7JsAAHCMAABsjAAAZIwAAGiM +AACchQAA7JsAAFSFAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAANiEAADsmwAA7JsA +AOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAHiKAADwiQAA7JsAAJSKAADsmwAA +NIkAAKCOAADsmwAA7JsAANiQAADsmwAA7JsAAOybAADsmwAA7JsAACSRAAAIkQAA7JsAAOybAADs +mwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAAB0jAAA7JsAAOybAADsmwAAcJgAAOyb +AADsmwAA7JsAAKiaAADsmwAACJsAABCYAADsmwAA7JsAAOiDAADQlwAA7JsAAOybAAAojwAAQI8A +AOybAADsmwAAHIwAAOyFAADsmwAA7JsAAOybAAAQkgAAxI4AAOybAADsmwAA7JsAAOybAADsmwAA +7JsAAASOAADsmwAAFJwAAKCcAACAnAAAuJwAAEycAAA0nAAAwJwAABCcAADsmwAA7JsAAOybAADs +mwAA7JsAAOybAADsmwAA7JsAACSMAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAAUJ0AAFye +AAAAhAAATIQAAOybAADsmwAA7JsAAOybAADsmwAAHIYAAOybAADsmwAA7JsAAOybAADsmwAA7JsA +AOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAADsmwAA +7JsAAOybAADsmwAA7JsAAOybAADsmwAA7JsAAOybAAAghgAAPIcAAKyGAADEnAAAZIQAAMSHAABc +iAAA7JsAAOybAADsmwAA7JsAAEiIAABMiAAA7JsAAOybAADwhwAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcKoA +AJyoAADcqwAA4KoAAPCsAAAAAAEA/////wAAAAD//////////wEAAAB4EQAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAEAAAAAAND+AAAAAAAAAAAAAAAAGCCgACAgoABAIaAASCGgABwgoAAk +IKAARCGgAEwhoAAoIKAAMCCgAGghoABwIaAALCCgADQgoABsIaAAdCGgADggoAA8IKAAeCGgAHwh +oAAwEAAAAP8DANAQAAAA/wUAdBAAAAD/LQBQEAAAAP89AOwPAAAA/wQAFBAAAAD/JQBQzgAAAP/d +AJgQAAAQEEwAAAAAAAAAAAAAAQEAPDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwVFRUV +PDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8 +PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAAAAAAAAAAAAA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8 +PDw8PDw8PDw8PBUVFRU8PDw8FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAQAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQEgAABBoAAEgWAACwEwAAxBsAAFAX +AAD0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAALAeAAECvgAAYAAAAAK+AAAAAAAAAAAAAAAAAAAAAAAAkCgEALLkAAOgiAAAs +uQAALLkAACy5AAA4CgAARNcBADTYAAAsuQAALLkAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAo +AAAsuQAALLkAACy5AAAsuQAAGEkAACy5AAAsuQAALLkAACy5AAAsuQAAGNgAACy5AAAsuQAAkM0A +AAAAAAAY9AAAHPQAALQCAACgAgAAXD4BALjFAABEsQEA4MUAAHSxAQAExgAApLEBAHA3gAAspIAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAIQAhACEAIQAhACEAIQAhACEAIUAhgCGAAQABQAG +AAcACAAIAAkACgAKAAsADAAMAA0ADgAOAA8AJgAnACgAKQAqAEYARgBHAEgASABJAEoASgBLAEwA +aABpAGoAagBrAGwAbABtAG4AbgBvAHAAcABxAHIAcgBzAHMAdAB0AHQAdAB0AHQAdAB0AHQAdAB0 +AHQAdAB0AHQAdAB0AHQAdAAKAD8AAACEAIQAhACEAIQAhACEAIQAhACEAIUAhgCGAAQABQAGAAcA +CAAIAAkACgAKAAsADAAMAA0ADgAOAA8AJgAnACgAKQAqAEYARgBHAEgASABJAEoASgBLAEwAaABp +AGoAagBrAGwAbABtAG4AbgBvAHAAcABxAHIAcgBzAHMAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQA +dAB0AHQAdAB0AHQAdAAKAD8AAAAAAEAhAAAIIQAARLKAAAACAAAAAAAA9AEBAMQBAQBEtIAAQAUA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPgBAQAcOwEA1LqAAFQAAAAAAAAA9AEBAPA5AQCEuYAA +UAEAAAAAAAD0AQEAGDQBAIAHgAAIAAAAAQAAAPQBAQDAAAEAAAAAAFABAAAAAAAA9AEBAKQ0AQAE +MIAAAgAAAAAAAAD0AQEAsDMBAHwHgAAEAAAAAAAAAPwBAQDEAQEAKLuAACoAAAAAAAAA9AEBAMQB +AQAEPoAACAAAAAAAAAAAAAAAzAEBAAAAAAAAAAAAAQAAAAAAAADgAQEAAAAAAAAAAAAAAAAAAAAA +AMgBAQAAAAAAAAAAAAAAAAD0AQEAaLMBAAAAAAAAAAAAAAAAAPQBAQAoswEAiAeAAAQAAAAAAAAA +bgBuAGkAwACgAFAAgAC+AFABfQA+AAEAAQABAFgCKADmAS0AVQM8ANwBYwAAAG4AbgBpAMAAoABQ +AIAAvgBQAX0APgABAAEAAQBYAigA5gEtAFUDPADcAWMAAAAAAAAAAQEAABwJAQAV0gAAAAAAAP8D +AAAcCQEADNIAAAAAAAD/AQAAHAkBABXSAAAKAAAAAPwPABwJAQAM0gAACQAAAAD+AwAcCQEAFdIA +ABQAAAAAAPA/HAkBAAzSAAASAAAAAAD8BxwJAQAG0gAAAAAAAP8BAAAcCQEAB9IAAAAAAAD/AwAA +HAkBAAbSAAAJAAAAAP4DABwJAQAH0gAACgAAAAD8DwAcCQEABtIAABIAAAAAAPwHHAkBAAfSAAAU +AAAAAADwPwAAAAAAAAAAAAAAAAEAAAABAAAACgAAAAUAAAAFAAAABgAAAAoAAAAKAAAABgAAAAQA +AAAFAAAABgAAAAUAAAAFAAAABgAAAAYAAAAGAAAABgAAAAcAAAAHAAAABwAAAAgAAAAIAAAACAAA +AAQAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAABAAAAAgAAAAEAAAABAAAAAwAAAAMAAAACAAAA +AQAAAAQAAAAAAAAAAAAAAAIAAAABAAAAAQAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAABAAAAAAAAACwBAABeAQAAAQAAAAEAAAABAAAAAQAAAAMAAAAAAAAAAAAA +AJAXAQAcHQEAzBsBAKAdAQAYHQEA+BoBAJwdAQDwGAEA7BgBAGDjFgAg1hMAAAAAABAAAAAAgAAA +AACgABAnAADoAwAA6AMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAABAAAAAQAAAAIA +AAAFAAAAAgAAAAIAAAAFAAAAAgAAAAIAAAABAAAAAQAAAAUAAAAFAAAAAgAAAAUAAAAFAAAAAAAA +AAUAAAACAAAAAgAAAAAAAAAAAAAAAAAAAAUAAAAFAAAAAAAAAAUAAAACAAAAAgAAAAUAAAAFAAAA +BQAAAAAAAAAFAAAAAgAAAAUAAAABAAAAAQAAAAIAAAACAAAAAgAAAAUAAAAFAAAAAgAAAAUAAAAB +AAAAAQAAAAIAAAACAAAAAgAAAAUAAAAFAAAAAgAAAAIAAAAFAAAAAQAAAAIAAAAFAAAAAgAAAAUA +AAAFAAAABAAAAAUAAAAFAAAAAQAAAAUAAAAFAAAABQAAAAIAAAACAAAABQAAAAUAAAAFAAAAAQAA +AAUAAAAFAAAABQAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAA +AAAAAAAAAAgAAAAAAAAAARAAAQAAAAKAAAFCAAYCEAACIAAAA8AAAUMABgMQAALAAAADwAABQwAG +BBAAAkAAAAKAAAFEAAYFEQAAQAAAA8AAAUUABgYRAADgAAADwAABRQAGBxEAAQAAAAKAAAFGAAYI +EQACIAAAA8AAAUcABgkRAALAAAADwAABRwAGChEAAkAAAAKAAAFIAAYLEgAAQAAAA8AAAUkABgwS +AADgAAADwAABSQAGDRIAAQAAAAKAAAFKAAYOEgACAAAAAoAAAUwABgF4ADAAAABQAAAEtjwGAngA +RAAAAFAAAAS5PAYDeQAIAAAAUAAABLs8BgR5ABwAAABQAAAEvjwGBXkAMAAAAFAAAATAPAYGeQBE +AAAAUAAABMM8Bgd6AAgAAABQAAAExTwGCHoAHAAAAFAAAATIPAYJegAwAAAAUAAABMo8Bgp6AEQA +AABQAAAEzTwGC3sACAAAAFAAAATPPAYMewAcAAAAUAAABNI8Bg17ADAAAABQAAAE1DwGDnwAEAAA +AFAAAATaPgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEBAAABAAEAAgEAAAIAAQACAQAAAoCAgICAgICA +AYACgICAgIDAAJAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAIwKjAoAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAQAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNIBABUA +AAADAAAAuFmAAAAAAAAAAAAAAAAAAGTSAQAFAAAAAwAAALhZgAAAAAAAAAAAAAAAAABY0gEACgAA +AAMAAAC4WYAAAAAAAAAAAAAAAAAAKM8BAAoAAAAAAAAA2FmAAAAAAAAAAAAAAAAAAADRAQAKAAAA +AAAAANhZgAAAAAAAAAAAAAAAAAAA0QEACgAAAAAAAADYWYAAAAAAAAAAAAAAAAAAANEBAAoAAAAA +AAAA2FmAAAAAAAAAAAAAAAAAAADRAQAKAAAAAAAAANhZgAAAAAAAAAAAAAAAAAAA0QEACgAAAAAA +AADYWYAAAAAAAAAAAAAAAAAAANEBAAoAAAAAAAAA2FmAAAAAAAAAAAAAAAAAAADRAQAKAAAAAAAA +ANhZgAAAAAAAAAAAAAAAAAAA0QEACgAAAAAAAADYWYAAAAAAAAAAAAAAAAAAANEBAAoAAAAAAAAA +2FmAAAAAAAAAAAAAAAAAAADRAQAKAAAAAAAAANhZgAAAAAAAAAAAAAAAAAAA0QEACgAAAAAAAADY +WYAAAAAAAAAAAAAAAAAAANEBAAoAAAAAAAAA2FmAAAAAAAAAAAAAAAAAAGjUAQAGAAAAAAAAANhZ +gAAAAAAAAAAAAAAAAAC80wEABQAAAAMAAAC4WYAAAAAAAAAAAAAAAAAAGM4BAAoAAAAAAAAA2FmA +AAAAAAAAAAAAAAAAALjOAQAKAAAAAAAAANhZgAAAAAAAAAAAAAAAAADk3QEACgAAAAMAAAC4WYAA +AAAAAAAAAAAAAAAAdM8BAAoAAAAAAAAA2FmAAAAAAAAAAAAAAAAAAFjQAQAKAAAAAAAAANhZgAAA +AAAAAAAAAAAAAAAE0QEACgAAAAAAAADYWYAAAAAAAAAAAAAAAAAAwNEBAAoAAAAAAAAA2FmAAAAA +AAAAAAAAAAAAAMTSAQAKAAAAAAAAANhZgAAAAAAAAAAAAAAAAABk0wEACgAAAAAAAADYWYAAAAAA +AAAAAAAAAAAAAAAAALhZgAC4WYAAuCCgAGwgoAAAgAEA/3/8/wAAAAAAAAAA2FmAANhZgACkIKAA +OCCgAAEAAAD8////AAAAAAAAAAD4WYAA+FmAAKggoAA8IKAAEAAAAMf///8AAAAAAAAAABhagAAY +WoAArCCgAHghoABAAQAAP/7//wAAAAAAAAAAOFqAADhagACwIKAAfCGgAAAMAAD/8f//AAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAbM8BABUAAAADAAAAuFmAAAAAAAAAAAAAAAAAACwHgABAr4AAGAAA +AACvgAAAAAAAAAAAAAAAAAB/AAAAAAAAAAB/AAAAAAAAAAAAAAAAAAAAAAAAOAAAAGgAAAB0AAAA +gAAAAIwAAACdAAAABwAAAAAAAAD/////AAAAAC0BAADdAQAAWgIAALoCAAAKAwAATQMAAIcDAAC6 +AwAA6AMAABEEAAA3BAAAWQQAAHoEAACYBAAAtAQAAM4EAADnBAAA/gQAABUFAAAqBQAAPgUAAFEF +AABkBQAAdQUAAIYFAACXBQAApwUAALYFAADFBQAA0wUAAOEFAADuBQAA+wUAAAgGAAAUBgAAIAYA +ACsGAAA3BgAAQgYAAEwGAABXBgAAYQYAAGsGAAB1BgAAfgYAAIgGAACRBgAAmgYAAKIGAACrBgAA +tAYAALwGAADEBgAAzAYAANQGAADbBgAA4wYAAOoGAADyBgAA+QYAAAAHAAAHBwAADgcAABQHAAAb +BwAAIgcAACgHAAAuBwAANQcAADsHAABBBwAARwcAAE0HAABTBwAAWAcAAF4HAABkBwAAaQcAAG8H +AAB0BwAAeQcAAH8HAACEBwAAiQcAAI4HAACTBwAAmAcAAJ0HAACiBwAApwcAAKsHAACwBwAAtQcA +ALkHAAC+BwAAwgcAAMcHAADLBwAA0AcAANQHAADYBwAA3AcAAOEHAADlBwAA6QcAAO0HAADxBwAA +9QcAAPkHAAD9BwAAAQgAAAUIAAAICAAADAgAABAIAAAUCAAAFwgAABsIAAAfCAAAIggAACYIAAAp +CAAALQgAADAIAAA0CAAANwgAADsIAAA+CAAAQQgAAEUIAABICAAASwgAAE8IAABSCAAAVQgAAFgI +AABbCAAAXwgAAGIIAABlCAAAaAgAAGsIAABuCAAAcQgAAHQIAAB3CAAAeggAAH0IAACACAAAgggA +AIUIAACICAAAiwgAAI4IAACRCAAAkwgAAJYIAACZCAAAAAAAAAEAAAAAAAAABwAAAAAAAAAAAAAA +AAAAAAABAgMEBAQEBAUGBwgICAgICQoLDA0AAG47aDtiO1w7bjpoOmI6XDpuOWg5YjlcOW4raCti +K1wrbipoKmIqXCpuKWgpYilcKW4oaChiKFwobidoJ2InXCduJmgmYiZcJm4laCViJVwlbiRoJGIk +XCRuI2gjYiNcI24iaCJiIlwibiFoIWIhXCFuIGggYiBcIGITXBNuEmgSYhJcEm4RaBFiEVwRbhBo +EGIQXBBuAmgCYgJcAm4BaAFiAVwBbgBoAFQAAABuO2g7YjtcO246aDpiOlw6bjloOWI5XDluK2gr +YitcK24qaCpiKlwqbiloKWIpXCluKGgoYihcKG4naCdiJ1wnbiZoJmImXCZuJWglYiVcJW4kaCRi +JFwkbiNoI2IjXCNuImgiYiJcIm4haCFiIVwhbiBoIGIgXCBuEmgSYhJcEm4RaBFiEVwRbhBoEGIQ +XBBXEFIQTRBJEG4BaAFiAVwBbgBoAGIAXABUAAAAAAAAAAAAAAAdAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAgwAAAJIAAACDAAAAkgAAAOgAAAD3AAAA6AAAAPcAAAAAAAAACQAAAAAAAAAKAAAA +OAAAAGgAAAB0AAAAgAAAAIwAAACdAAAABwAAAAAAAAAHAAAABwAAAAcAAAAAAAAAAAAAAAAAAAAA +AAAA9FgBAAgAAAADAAAAuFmAAHgJgAD4CYAAeAqAAPgKgAAKDREUCg0RFBkZGRkKCgAAAAAAAAYG +BgYJCQkJAAYAAAAFBgcIDQ4PEBUWFxgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPGqysJS+srKysrKWsfpFOQwybNgAAADcAmpKPSAAA +DwAgaDcAAAARAD46IBEAAAIlAAAMLwAAAi85OQAKJTy3R2+KAAcUJ2IuAAACABcAAAUQCiAwQAAA +BgYKDSMbIyEAAAAMEBQYIAgEAAA8ODQwLCgkIBwYFBAMCAQACwcDADs3My8rJyMfGxcTDwsHAzE2 +OjI5OjA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIAAAAQAAAAHQAA +ADcAAABvAAAAoAAAAHAAAAAFAAAA9gAAAFoAAAAfAAAASAAAACAAAABIAAAACAAAAAEAAAAzAAAA +fwAAADQAAAB/AAAANwAAAAEAAAA4AAAATwAAADsAAAB/AAAAPAAAAH8AAAAxAAAAAAAAADIAAAAA +AAAANQAAAAAAAAA2AAAAAAAAADkAAAAAAAAAOgAAAAAAAAANAAAAKgAAAA4AAAB6AAAADwAAABAA +AADzAAAASAAAAPQAAABIAAAAAAAAAAEBAQEBAQEBAgICAgICAgIDAwMDAwMDAwECAAAAAAAAAAAA +AAQAAAAFAAAAoQMOHuEAAAChAw4e4QAAAAAAAAAKAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAoQMOHuEAAAAV9mP2sPb89kb3kPfY9x/4Zfip+O34L/lw+bD57vkr+mf6 +ovrc+hT7S/uB+7b76vsc/E38ffyr/Nn8Bf0w/Vn9gv2p/c/99P0X/jn+Wv56/pj+tv7S/u3+Bv8e +/zX/S/9g/3P/hf+W/6b/tP/B/83/2P/h/+n/8P/2//r//f/////////9//r/9v/w/+n/4f/Y/83/ +wf+0/6b/lv+F/3P/YP9L/zX/Hv8G/+3+0v62/pj+ev5a/jn+F/70/c/9qf2C/Vn9MP0F/dn8q/x9 +/E38HPzq+7b7gftL+xT73Pqi+mf6K/ru+bD5cPkv+e34qfhl+B/42PeQ90b3/Paw9mP2cLmDupa7 +qry+vdK+57/8wBHCJ8M9xFPFasaAx5fIr8nGyt7L9swPzifPQNBZ0XLSjNOm1L/V2tb01w7ZKdpE +21/cet2W3rHfzeDp4QXjIeQ+5Vrmd+eT6LDpzerq6wftJO5C71/wffGa8rjz1fTz9RH3L/hM+Wr6 +iPum/MT94v4AAB4BPAJaA3gElgW0BtEH7wgNCisLSAxmDYMOoQ++ENwR+RIWFDMVUBZtF4kYphnC +Gt8b+xwXHjMfTyBqIYYioSO8JNcl8iYMKCYpQSpaK3Qsji2nLsAv2TDxMQozIjQ6NVE2aTeAOJY5 +rTrDO9k87z0EPxlALkFCQlZDakR9RQABAQIBAgIDAQEBAQEBAQECAgICAgICAgMDAwMDAwMDBAQE +BAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAA6AQIB +1QDfANoAogB1AH8AigUqAzkBqAGKBcoC2QBIAQEDDwcKFDduagEaAdkA6AAKAboAeQCIAMoBSgHi +APkAygHqAIIAmQB00UUX6KKLLgAFBwEDBAAFAQUAAAAFBgACBAAFAAUAAAECAQIDBAAABQYHCAkK +AAAJAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAEAAAAAgAAAAUAAAAHBwcHBwcHBwcHBwcHBwcHBwcH +BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcGBgYGBgUFBQUFBAQEBAQDAwMD +AwICAgICAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAKAAoADAALAAsACgAPAA0AEAAPACMAGwAWABIAPQAsAB//wcPHz8BAzAAAAA2AAAA +DAAAABIAAAAYAAAAJAAAAAYAAAAJAAAABQAHAgMEBgZAA4AGwAkADYATABpAHYAggAYADYATABoA +JwA0gDoAQcAJgBNAHQAngDoATsBXgGGZAzMH2QpzDqYV5hyAIBkkMwdzDqYV5hxZK8w5AEEzSNkK +phWAIFkrAEGmVoBhWWyd2ImdTuzETjRIgzQndmInGqRBGhM7sRMRGIERD/zAD07sxE4ndmInGqRB +GhM7sRMN0iANiZ3YCQiMwAgHfuAHNEiDNBqkQRoRGIERDdIgDQiMwAgGaZAGsLLVBQVUQAUndmIn +EzuxEw3SIA2JndgJBmmQBsRO7AQERmAEAz/wA6qqqqoapEEaEzuxEw/8wA8RGIERDdIgDQqogAoT +O7ETD/zADw/8wA8N0iANC7RACwu0QAuJndgJDdIgDQqogAoKqIAKCIzACAd4gAcHeIAHBmmQBg/8 +wA8N0iANC7RACw3SIA0LtEALiZ3YCQiMwAiJndgJCIzACAd+4AcHfuAHwSwpBwqogAoIjMAIB3iA +BwiMwAgHeIAHBmmQBrCy1QUGaZAGsLLVBQVUQAUFVEAF1h3GBAEHDx8/f///ZuYAAAUGAQIDBAAA +VABUAGwAYABcAFQAjAB4AA0PBQcJCwEDKAAoADQAMAAsACwARAA8ACwALAA8ADQAMAAsAFQARABV +VVUBS2gvAVVVVQXjOI4DqqqqAnEcxwGqqqoKx3EcBwAEAABkAAAAAAAAAA8APwABAAAADwA/AAEA +AAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8APwACAAAADwA/AAEAAAAiFgAAgAAA +AwAAAVkAACQWAAEAAAADAAABWgAAJhYAAgAAAAQAAAFaAAAoFgACAAAAAwAAAVsAACoWAAKAAAAD +AAABXAAALBcAAAAAAAQAAAFcAAAuFwAAgAAAAwAAAV0AADAXAAEAAAADAAABXgAANBcAAgAAAAMA +AAFfAAA2FwACgAAAAwAAAWAAADgYAAAAAAAEAAABYAAAPBgAAQAAAAMAAAFiAAA+GAACAAAABAAA +AWIAAEAYAAIAAAADAAABYwAAZBsAAgAAAAMAAAFvAAFmGwACgAAAAwAAAXAAAWgcAAAAAAAEAAAB +cAABbBwAAQAAAAMAAAFyAAFuHAACAAAABAAAAXIAAXAcAAIAAAADAAABcwACdB0AAAAAAAQAAAF0 +AAJ2HQAAgAAAAwAAAXUAAngdAAEAAAADAAABdgACfB0AAgAAAAMAAAF3AAN+HQACgAAAAwAAAXgA +A4AeAAAAAAAEAAABeAADhB4AAQAAAAMAAAF6AAOGHgACAAAABAAAAXoABIgeAAIAAAADAAABewAE +jB8AAAAAAAQAAAF8AASRHwABQAAAAwAAAX4ABJUfAAMAAAAEAAABfwAFlx8AAsAAAAMAAAGAAAWZ +IAAAQAAAAwAAAYEABZ0gAAFAAAADAAABggAFnyAAAcAAAAMAAAGDAAWhIAADAAAABAAAAYMABaUh +AABAAAADAAABhQAFaHIBAAAAAABocgEAAAAAAGhyAQAAAAAAaHIBAAAAAABocgEAAAAAAGhyAQAA +AAAAaHIBAAAAAABocgEAAAAAADRsAQAYAAAA+G0BACAAAACYcwEAFAAAAIx0AQAUAAAAzHEBAA4A +AACQcAEADgAAAKBxAQAUAAAAoHEBABQAAABAI0AlISEhIUBAQEBABQQEAQFAQEBABQVAQAwMQA0M +DAEBAQVAQAUFAAQABEBAAARAQEAFQEBAQEAFQEBABQUFAQEBAUAFBQUBBQEBQAUFBUAFQAUFBQUF +AAAAAAAAAABkAAAAAJABAAoAAAAEAAAAHBEAABwyAAAcMwAABAAAABwVAAAcAgAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAApcaE+JnujfYN/73Wsd5UkVBgAwKpzn1WGediteZNmuxFj50fQImH ++hXv67LJjgv77EFns/1f6kW/I/dTluRbm8J1HOGuPWpMWmxBfgL1T4NcaPRRNNEI+ZPic6tTYj8q +DAhSlWVGXp0oMKE3Dwq1LwkONiSbGz3fJs1pTs1/n+obEp4ddFguNC02stzutPtb9qRNdmG3zn17 +Uj7dcV6XE/WmaLkAACzBYEAf48h57ba+1EaN2WdLct6U1JjosEqFa7sqxeVPFu3FhteaVWaUEc+K +EOkGBIH+8KBEeLol40vzov5dwICKBa0/vCFIcATx32PBd3WvY0IwIBrlDv1tv0yBFBg1Ji/D4b6i +NcyIOS5Xk/JVgvxHeqzI57orMpXmoMCYGdGef6NmRH5UqzuDC8qMKcfTazwoeafivB0Wdq0721Zk +TnQeFNuSCgxsSOS4XZ9uve9DpsSoOaQxN9OL8jLVQ4tZbrfajAFksdKc4Em02PqsB/Mlz6/KjvTp +RxgQ1W+I8G9KclwkOPFXx3NRlyPLfKGc6CE+3ZbcYYYNhQ+Q4EJ8xHGqzNiQBQYB9xIco8Jfavmu +0GmRF1iZJzq5JzjZE+uzKzMiu9JwqYkHpzO2LSI8khUgyUmH/6p4UHqljwP4WYAJFxraZTHXxoS4 +0MOCsCl3WhEey3v8qNZtOiwAAQIEBAAAAAQMDAgEDAQEQAAAAIAAAAAAAQAAAAIAAEAAAAAABAAA +QAAAAEAAAAAA8GEAAAEBAgECAgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAAKgAAAA4A +AAAAAAEBhNIBAJDSAQCc0gEAqNIBALDSAQC40gEAAQEAAQIBAQEAAAAAAAAAAP////8AAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIANAAAAIAAAgA0AAIANAAAAIAAA +gA0AAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAQAAAAsAQAABwAAAAAAAAASAAAABAAAAAsA +AAAIAAAABAAAABw/gAAJAAAABAAAABAYAAAKAAAABAAAAIg+gAALAAAABAAAAKQ+gAAMAAAABAAA +ABAYAAANAAAABAAAABA+gAAOAAAAAAAAAA8AAAAEAAAAFgAAAA== +==== diff --git a/sys/contrib/dev/iwn/iwlwifi-135-6-18.168.6.1.fw.uu b/sys/contrib/dev/iwn/iwlwifi-135-6-18.168.6.1.fw.uu new file mode 100644 index 0000000..2ab1be0 --- /dev/null +++ b/sys/contrib/dev/iwn/iwlwifi-135-6-18.168.6.1.fw.uu @@ -0,0 +1,12344 @@ +Copyright (c) 2006-2012, Intel Corporation. +All rights reserved. + +Redistribution. Redistribution and use in binary form, without +modification, are permitted provided that the following conditions are +met: + +* Redistributions must reproduce the above copyright notice and the + following disclaimer in the documentation and/or other materials + provided with the distribution. +* Neither the name of Intel Corporation nor the names of its suppliers + may be used to endorse or promote products derived from this software + without specific prior written permission. +* No reverse engineering, decompilation, or disassembly of this software + is permitted. + +Limited patent license. Intel Corporation grants a world-wide, +royalty-free, non-exclusive license under patents it now or hereafter +owns or controls to make, have made, use, import, offer to sell and +sell ("Utilize") this software, but solely to the extent that any +such patent is necessary to Utilize the software alone, or in +combination with an operating system licensed under an approved Open +Source license as listed by the Open Source Initiative at +http://opensource.org/licenses. The patent license shall not apply to +any other combinations which include this software. No hardware per +se is licensed hereunder. + +DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. +begin-base64 644 iwlwifi-135-6-18.168.6.1.fw +AAAAAElXTAoxMzUgZncgdjE4LjE2OC42LjEgYnVpbGQgMAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAQaoEgAAAAABAAAAAAAAAAEAAAD8ogIAICCADwAAQABpIAAAaSBAAGkg +AABpIEAAICCADwAA6ABpIAAAaSBAAGkgAABpIEAAICCADwEA9BtpIAAAaSBAAGkgAABKIAAASiEA +AEoiAABKIwAASiQAAEolAABKJgAASicAAEogABBKIQAQSiIAEEojABBKJAAQSiUAEEomABBKJwAQ +SiAAIEohACBKIgAgSiMAIEokACBKJQAgSiYAIEonACBKIAAwSiEAMAokgD+BAABAQSycMEAsnDBC +JBw0CiKAP4AACHsKIwA3Xg4ACEomAHBpIEAASiYAcEomAHBKJgBwSiYAcAAWAHCAAAwhQHggIECH +AAAAAAAAAAAAAPwciLb8HEi2/BwItvwcyLX8HIi1/BxItfwcCLX8HMi0/ByItPwcSLT8HAi0/BzI +s/wciLP8HEiz4H7geATcON018OB4BNw03TPw4HgE3DDdMfDgeATcLN0v8OB4BNwo3S3w4HgE3CTd +K/DgeATcIN0p8OB4BNwc3Sfw4HgE3BjdJfDgeATcFN0j8OB4BNwQ3SHw4HgE3AzdH/DgeATcCN0c +8OB4BNwE3RnwNBQaMDAUGTAsFBgwKBQXMCQUFjAgFBUwHBQUMBgUEzAUFBIwEBQRMAwUEDACxwHG +sCRNM7AkHzPgfuB44HjgeOB44HjgeAokgPAFIEQA4CDBB0Qk/oBBKsQAhAACAC8kAvFCIQEBQiAD +AeggogQEEQQCBBEFAgQRBgIEEQcCBBsIAQQbSAEEG4gBBBvIASwAJQBEIj6BPAAiAEQi/IBAIcEA +4CDBB0AjwwCoIIABARGEAgEbCgEgIMAHBBEEAgQRBQIEGwgB1Afh/wQbSAFEIvyABBEEAskH7/8E +GwgBQiFBAEIgQwCoIIABARGEAgEbCgEgIMAHz3GgAKwvGIGauBihDQdgFAXY4HjPcaAArC8YgbO4 +urgYofkGYBRk2AoiQIAA2e4AAQAvJgDwSiZAAE4ABgBPACAAiiX/D+B4CiJAgADZzgABAGwAJAAv +JgDwXAAFACsINQhKJkAACHEA2AIhvoDgIMUHQnkB4AIhvoDgIMUHQnnrB+//AeAvLQEAQCVFAAIm +fPEAACAAAChAAeggYgMvIACALyFLAAIhvoDAIIYBwiGGAOB+EQAgAEogABBKIEAQDiJCAC8gCxLO +IEWAiiX/DwgABQAvLQEAQCVFAAImfPEAACAAAChAAUomQADoICIDLyAAgC8hSwACIb6AwCCGAcIh +hgBKJgAAQiD+kM4gggFEIH6QziGCAeB+KQAAAOB4/ByIsfwcSLH8HAix4cPhwuHB4cAHwBwcwDHh +wOB/AcAKJgDwiiC/D8ogZADgfy8gAwDgf4og/w/hxQh1EfDgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeGG9jCX/n+314H/BxeB48cDhxc9wgADwIk2Az3WAALilIIW3uri6BCGBDwMAAAAH +uUV5LaDKCGAUANgAhc9xgADgy1EggIJMic9wgABQ4jJqNnnHcYAAEN9ggVZ4QYAF8pW7YKGrugTw +tbtgoYu6QaALjaO4FQXv/wutosHxwJIMz/9Fwc91gADwIieFMHAI9DCVFBQOMTB2BPRZHYIQ0BUB +FjBwDvTPcYAA/CU8kRQUDTEwdQb0z3GAAFQmWamA4gz0z3WAAJwKwY2A5gDZyiBBACXyIa2O4gT0 +Adgh8EEoDQIHfUEoAQSnec93gACcCqCPUyVFEUwlAITGuY32CiHAD+tyz3AAAM0bn9t1AiABiiSD +D1ElgJEG8gDYDNxbBM//z3aAANDhFiZNEaeNoK/JdRYlTREApRQUADFGrcdxgACQ3gK1AIkHrQAZ +QgEAG0IBxPHgePHAtgvP/wjIz3KgAMgfDhoYgAnIDxoYgArIEBoYgAsSATYCyCR4ERoYgAzIz3GA +AFg/LRoYgACBAeAAocO4jeAp9AvIf9kKuSR4LygBAE4gggcA2A8ggAAEIQGAQiKNAhnyCyNAwBf0 +z3CgAIgg8CBQA892gADUOgCGEHXPd4AA2DoG9ACHEnDIDIEHoKYAHwAUiQPP/+B48cDhxQHZz3Cg +ALAfOaDPcYAASCEIgQCArMFJwAyBAIDPcYAA2CXPdYAAELFKwAqBobgKoQiF4LgJ8lEgwIEH9I4M +gAZOC6ACGNiLcalw7gkgESTaz3CAAJgKIIACiYDgEvQEiVEgAIAO8gvIBCCAD/7//wMLGhgwC8iG +uIy4j7iQuAvwC8gFIIAPAQAA/AsaGDALyKy4CxoYMNIOz/+LcDDZkNoe20IMYBAYu89wnwC4/wLZ +NqAowIHgyiHCD8oiwgfKIIIPAADqHMojgg8AAPwAyiQiALwAIgHKJSIAAg6ABoDgB/T+DOAAANj2 +CaAQBtipAu//rMDPcYAAnHrgfwhh4HjxwHYMgAbPcYAAmBzwIQAAQHjPcKAA0BuA2lCgz3CAACAh +AIBRIACCANkG8s9wnwC4/z2g0cDgfvHA6gnv/w/Zz3WAAAjoABYAQAAWAEBVJU4UAKX2DKATBG3J +cLIMoBMilR6Vz3GAAJgK2mDYYAEQhQBMJQCAQKET9AKF8LjKIcEPyiLBB8oggQ8AAOkcyiOBDwAA +wQD4B+EAyiRhAPEBz//geIDhyiRNcOB46CAtAs9xoABQDCWBARhSAOB+4HjxwFoJz//PcIAA8CID +gBiIpcGE4EogACAM9AohwA/rcoogjA1k2wokAASlB+AAuHPPd4AASCEkhyCBvgvgB4ogBw6KIJkF +sgvgB2fZz3WAADSxiiDZBqIL4AcsjYog2QaWC+AHLY2KINkGjgvgBy+NiiDZBoIL4AcujYog2QZ6 +C+AHMI2KINkGbgvgBzGNz3aAAOQ4z3CAALRfugsgEiQeABTPcIAA0F+qCwASz3CAAHhgogsAEs9w +gACUYJYLABItjYDhBPJsjTBzjPYqC+AHiiCHDYoghw0eC+AHLI3I8ASHQIDPcIAACKNgoCGgQqDP +cIAAeOcIkBBxlPbPcIAAeOcB2iiwz3eAAFjJz3CAAEDJTKdDgFBxARgCBML3I6AQjYDgyiBiAAOm +EY2A4BbygOMU9M9wgADwIgOACYBRIICADPKKCKACB9gB2AGmz3CgACwgEIAApoogyQOaCuAHo9mK +IIkDz3GAAAijigrgByKBAYbPcYAACKMggYDgyiBiABi4BXkDhgoiAICKIIkDyiJiABC6YgrgB0V5 +z3CAAFw1AICB4A30z3CAAHjnz3EAABAnRgnv/wWAEHgC8ADYz3GAAOjIB7EDhoHgDBkEBDr0AIGC +4Mwg4oAE9AHYAKFMFoAQgeAw9M9woAAsIPCAz3ABAARUQMAB2EHACBwANBHYQ8AA2Iy4RMAA2BDZ +BNoIc5hwuHAAJ4cfAAAAfYoJ4AXYcIogygTOCeAHANmKIMoDxgngBwDZSxaAEAHgD3hLHgIQDI2A +4AX0AYaA4FwLAQbPcIAAJGD6CQASAdnPcIAA6BcgoGoPYAIG2FEHr/+lwOB4osHxwOYOr/+YckXB +QSgBAgd5QSgCBCd6xrrPdYAAkN5JZee5XWUT9BQUDjHPc4AA0OFocjZ64ILxcAX04pLRdwfyJ4rn +uadq9fMA2CjwxoqA5gf0gN/PcIAAnArhqM93gABEIwWPEHYE9IDYBa8K8M93gABUJhmPEHYE9IDY +Ga/GijZ7AByAAweKh7kArc9wgACcCkCIIKgB2EerDNy3Bo//4HihwfHAAxICN9dyAAAAQAHawiKK +ABe6x3IADgAAg7rsc0Cj7HIAokYPIAUocNHA4H+hwOB4peAf8gn2g+AV8oTgF/KF4Bv04H8B2L3g +D/IG9q3gFfTgfwLYzOAP8owgQ4cN9OB/BtjgfwDY4H8D2OB/BNjgfwXY4H8H2AjY4H7gePHA4cWK +IFIOVgjgB7TZz3WAAHwzqXBAJYEbxgzgEC7aAdgdBq//YR0CEOB48cCSDY//guAIdY33CiHAD+ty +/diLuHPbSiQAAO0D4AC4c893gAB8MzeHACWQH4AA0DMwdQX0DBCAIIDgkvI+CWAJBdg6cIogEg7q +D6AHqXFELb4bACdAHkCQIZAA3gi6RXnPcqQAuD2bGlgAIpAMGIIjyhpYACOQt6fLGlgAJJDEGlgA +JZDGGlgAJpDHGlgAJ5DCGlgAKJDDGlgAKZDFGlgACpCjGhgAz3CAALAuIIBgeclwjOAa8s9wgACw +LiCAYHnJcJDgEvLPcIAAsC4ggGB5yXCR4Aryz3CAALAuIIBgeclwkuAD9ADdz3CAAPAiA4AIgM9x +pAC0RVEgAIAQ8kQtvhsAJ0AebJBLkHt7ZXpTGZiADZBUGRiABvBTGZiDVBmYg0Qtvhsndw6XVhkY +gA+XWBkYgBCXVRkYgBGXVxkYgBKXWhkYgBOXXBkYgBSXWRkYgBWXWxkYgCINIAkqcJEEj//xwFIK +7//hxQ4NAAXPcIAA8CIDgBiIgeAu9M9xgAAI6M9ygACkYgCCYIFgoACCHNtgqARpAaLPcIAAHAsD +oVUhQAQDohjYAqJVIcAFBaIBgQDdWhlEAwSiAoGtuJYPYAYCoYDgEPSSDqAAqXCKC2AQBtgK8PIK +QBSA4AbyygtAFJIIQBQpBI//huDxwADYD/TPcIAAULEqCu//BtnPcYAA8LEAgYK4AKEB2NHA4H7g +eIPg8cAA2An0z3CAAEixAgrv/wPZAdjRwOB+4HjxwIHg4cUA2An0z3CAAEuxAd3iCe//qXGpcMkD +j//gePHAluDhxQDYjPfPdYAAuKWpcMIJ7/8E2QuNg7gLrQHYoQOP//HAmuDhxQDYjPfPdYAAuKUE +bZ4J7/8E2QuNgrgLrQHYfQOP//HApMGQ4ADZyiBCABP0i3B6Ce//ENkAFAAxhODMIGKBCPTPcIAA +VMsfgPW4AvJMcAHYpMDRwOB+8cDGCo//CHfPcIAA8CIDgBiIhOAacUnyhOcA3YwAJQDKIEUDz3aA +ADSxQCYAEyYJ7/8E2S6OsK5TIQAAEa5BKMAgoLkwcGIAJQACIEIAY7/xclYABgCA4g7yz3GgANAP +EBEAhmG6WGAQGRiAJREAhg94A/APjgDZUyCCIA8hgQAkeC8mB/DPcZ8AuP8QrhiBzyDiB9Ag4QcY +oRiBnrgYoRiBvrgYoQHYgQKP/+HE/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwcyLH8HAiy +/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDhxPHAz3CgANAbFIDPcYAAQAkEIICPz1EE4QChEfL2 +uC8pAQAF8i8pgQ9AAAAAz3CAABQu8CBAAEB47g2P/9HAwcRrJMAQwcRrJIAQwcSfdAQUCzQEFAo0 +BBQJNAQUCDQEFAc0BBQGNAQUBTQEFAQ0wcPBwsHBwcDBxEUsfhAKJkB+wcRrJIAUwcQgIECH4HiM +IFyCAdjgf8IgCwDxwEYJr/9KJEAAz3WAAPAiFSUDEACDQCUOFdFwwiQCAfAlDRHIFQUWRCW+gQny +CiHAD+tyjtiNuHkHoAB028gQDQalecgYWACggwbZRnnIFQAWJHjIHRgQAIPIEAAGhiB/jiQIQRRN +AY//4HjxwNYIr/+KIAwJz3WAAJwJJIVeC4AHBIWA4EX0z3aAAEi0ExYClgDfhCoICQAhgH+AAEys +AqUkiAHbgOHrpWylIfIdHtiTDBAFAAQlgQ/A/wAAQSkEBs9xgAB45xQRBgAFLj4BACGEfz8A//8E +JEEBHh5YkCCQjCGChgHZwiFOACql56UkgM92gACEsMC5KrbPdoAAbCkorkCuAohkpQGuH/AEhYHg +HfSOCUAKANgEpQKFJIiA4RP0J4Uc4DZ4JIjPcIAAHCYHiBBxAdnAec9wgABoKSCgAtgC8AHYA6Vh +AK//AdjxwPIPb/+KIAwKo8HPdYAAnAkkhXYKoAcA3gSFgOAo9OoLQAAB2ASlAoUEiIDgcAIBAM9w +gABoKQCAgOBgAgIAz3CAAEghEIDPcoAAqLAAgCOCGWHPcIAAWCkAgDhg7gogEgKigOA4AgEAfvAE +hYLgQvQKhYDgEPQMFQQQEBUFEAohwA/rcs9wAACKDNUFoACKI44LIoVHhUAhAAdWeEaIYMJGiAEc +gjBGiAIcgjBHiGHCR4gFHIIwB4gGHAIwiiBTAcoJoAeoEQEAAoWLcb4IYBCoEAAAz3CAAEghEIAg +gM9wgABsKSGgcg+gAMWlA9gEpdbwBIWD4Dr0QoUnhUAiAAc2eAWIUSBAgRPyz3GAAEghA5Iwgc9z +gABsKSCBYYMKuGJ5MHAF9wnYC6WO8AWFgOAN9ASKgOCy8s9wgACosAoKIBICgIDgqvIFhYDgBvIF +2AulAdgJ8M9wgABoKQCAgOCe9ADY6gtACJrwBIWB4G/0QgrAAyKFR4VAIQAHVnhFiOC6G/KDukWo +z3KAABRAyYLPc4AASLQVG5iD+YLFgv5mFhuYg/iCxIL+ZhcbmIPDgleCXmYYG5iDBYhRIECAK/L6 +D8ARgOAQ9AohwA8ChetyHBUFEAQQhADPcAAAiwyBBKAAiiMQAOoP4BEC2HoP4BEI2CKFBImC4Ar0 +AdgApQDYDqViD+ARWtgihQSJgeAD9AHYAaUHhRzhFnkFiYYg/4zKIIIPAAAwQ4AP4gTKISIAAoUn +hRzgNngFiIYg/ocE8gLYBKUs8ATYBKUo8CSFhOEB2CT0D6XPd4AASCEQhyCAz3CAAGwpIaAiCKAH +iiAMCs9wgABsKQzZddoe2zoP4A8YuwSHz3GAAGApAIDmCGABIIEGpcSlBNgDpQHYvQVv/6PA8cBS +DW//iiCMCc91gACcCSSF1g9ABwSFgOBA9CKFR4VAIQAHVnhEiM9wgACUCQCQEHIB3g70z3CAAJYJ +QJDPcIAAhLAKkBByBPTEpQDYUfAEiYDgH/LPcIAAaCkAgIDgGfTPcIAAqLAjgM9wgABcKQCAJgkg +BzhggOAN9IogTA1mD2AHiiFNByIKYAgA2AHYL/DEpQHYLfAEhYHgK/QChc9ygADwIiOCZIBooSOC +ZYAc4GmhJ4U2eCSIA4IA3jSwAtgE2UoL7//Jcs9zgACEsEKFB4VAIgEHFnkKkySJRILCDWAOyXPE +pQPYA6UB2NEET/8MFQQQEBUFEAohwA/rcs9wAACJDLkCoACKIw4B4HjxwD4MT//PdoAAnAkEhoDg +ocE79CSGwg5gB4ogjAoB389wgABoKeCgANgPpgCmAaaKIJMBog5gB4ohWQUC3alwag4gBelxz3CA +AGgJAIAmgJ4RAAamuJ4ZGACpcADZogrv/wTaxg+gE6lwz3CAAPAiI4BIgTSRUyIAABoNYA7pc6Sm +6XCL8ASGguAz9CSGSg5gB4ogjArPcYAAlAmKIIwMNg5gByCRz3GAAJYJiiDMDCYOYAcgkQKGBIiA +4BfyCYaA4BX0z3KAAKiwBoIlgg4ggw8HACChMHNH9wfYC6YB2AymCaYD8DhgBaID2DLwBIaD4BD0 +JIbiDWAHiiCMCgvIBCCAD////wMLGhgwBNgi8ASGhOAg9CSGvg1gB4ogjApTIMBAz3GAABBjLg8g +AAChz3CAACywOoDPcIAAaK6EKQgJMCBADlEgQIAF2MogoQEEpiTwBIaF4AHfHfTPdYAALLAahQTZ +mdoe20DAi3CWDOAPGLsahemmhCgICQAhgH+AADyuK4ChuSugBtgEpgDYBfAEhobgBvIB2A0Db/+h +wAbYA6YA2Nbx8cCWCk//z3WAAJwJBIWA4KXBDfQkhRoNYAeKIIwIAoUEiIDgGPQC2ASlBIWB4FX0 +BYWA4EX0z3CAAEghBIDPcYAAJGcAgHIM4BEggYDgNPQA2Djwz3CAAEghBIAA3sWlz3GAAFwpAICu +DSABIIHPcYAAJGcB3wTaAKHPcKAALCBAEAcAz3AAALCIQMAF2EHAQsdDxkTGyXAG2clzmHa4dgAn +hw8AAAB9NgxgBdh25KXpcDHwugpgBQXYBNgC8AXYgOAB2gP0Adgl8CmFgeEQ8kylC6UM8ASFguAc +9CSFUgxgB4ogjAgJhYHgBPQB2A/wgODr9QKFfgsgBQOACHHPcIAAfF/6DIARANgGC4AH3fEA2O0B +b/+lwPHAfglv/4ogTAnPdYAAnAkkhQYMYAelwQSFgOCq9AKFR4UkgFZ4z3KAABwmBCGBDwAGAACA +4QHZZ4ogEI4AwHlwdgn0z3eAAISw6pfBivF2A/IA3gXwxorRcf31Ad6A5s9xgABoKcChFfTPcYAA +lAkgkTBzD/TPcYAAlgkgkWGKMHMJ9M9xgACYCSCJRoowcgPyANkC8AHZgOFk8hwQBADPcIAAqLAM +GAABz3CAAAijBBAFAM9wgAB45wWABSh+AUApgHKQcMoizgfKII4PAACIDMojjg8AAAEDFAduAMoh +zg/PcIAAXCkAgN4M4AaAcIDgBfTmDoAQUPALyAQggA////8DCxoYMM9wgAAIZwCIAN6A4MWlCvTP +cKAALCAQgMdwAAAAfRKlSBUHEM9wAAB0iEDABdhBwAHfQsdDxkTG6XAG2QTaANuYc7hzegpgBdhz +z3CAAAhnwKjkpelwH/AA2M9xgAAIZwCpAtkjpRfwBIWB4AHeEvQFhYDgHPTPcIAAqLAjgM9wgABc +KQCAOgzgBjhggOAG8gHYTQBv/6XAz3CAAAhnwKiuCGAFBdgA2ASlovEF2AulPgmgB8lwANnPcIAA +CGcgqOjx4HjxwLIPD//PdoAAnAkEhoDgePQChgSIgOAU8s9wgABoKQCAgOAO9M9wgACosN4K4BEC +gIDgBvLaDCAIANhpAwAAz3CAAEghEIBHhiCAz3CAAGwpAYACeQKGVngHgBBxhvcB2ASmQQMAAACG +gOAM8lEjQMAK8gLZz3CgANAbM6CqCOARHtjPdoAASCEEhs91gACcCQCAPgngESaFgOAIAwEABIbP +cYAAYCkAgIoKIAEggQalAoUnhRzgNngFiIYg/4wJ8s9wAAAwQ89xgACIKZ4IwAQChSeFHOA2eAWI +USBAgMQCAQAAhYDgCPLPcKAALCAGgIDgsAICAFYIwASpAgAABIaB4Jb0JIZCCWAHiiBMCs9wgABI +ITCAIIEyCWAHiiBMCgKGJ4Yc4DZ4BRCGAADaUSYAgE+mQfLPc4AAbCnPd4AAFEAYhySHz3WAAEi0 +GWEXFQCWWKtcFwQQDBcFEAAlBQEYFQSWAnkCJQUBFRUAliQXBBACJASAFhUNlgWHonjKJYEQA/IB +3birgOEO8kAsjwDxcYT3TyWAEAbwgOAG8k8lQBAPfRirQSnAADhgsHBD94K9uKtRJkCALvIAhoDg +DfLPcaAALCAmgQ6GInjPcYAAbCkFoUCmBfABhoDgA/JBpm4PgASKD4ARguAR8ut1fg+AEQwWBBC4 +cM9wAACMDAohwA+pch0EYACKIxMLhg+gEQDYAoYnhhzgNngFiIYg/4wF8gLYBKa+8ATYBKa88ASG +guAL9M9wAAAwQ89xgACIKSoPgAQE2ASmBIaE4K/0JIb6DyAHiiBMCs9wgABIIRCAIIDPcIAAbClA +IA0HN6DaDyAHiiCMDSKGHBYEEEAhAAcWIAABBYhRIACAHfIA2kokwHBIc6ggwAHwJcAQAeMaYgPf +SiRAcQDbqCDAAfAlwBMB5xtjUHPH989ygABsKRiKgrgYqgDdz3eAAKiwpacMkUAkQgAQckemR/eH +EQAGUSBAgAbyAdgmCiAIDKZc8AIOYAcLhgvIBCCAD////wMLGhgwDg7gCaumiiBMDT4PIAeKIZQN +B4YihhZ5iiBMDSoPIAcngQLYA6YChs9ygABoKSSIgOEP9CeGHOA2eM9xgAAcJieJBIgwcAHYwHgA +oinwIIKA4QXyAdgDpiPwJ4Y2eBwQBADPcIAACKMEEAUAz3CAAHjnBYAMHwARBSh+AUApgHKQcMoi +zgfKII4PAACNDMojjg8AAE4FiAJuAMohzg+kpnUEL/8B2AwWBBAQFgUQCiHAD+tyz3AAAI4MZQJg +AIoj1QXgePHAz3CAAGgpAICA4B3yz3CAAJQuAICA4Bv0Xg7AD4DgCPQLyAUggA8AAAA8CxoYMJIO +wA+A4An0C8gFIIAPAAAA1AsaGDALyJC4CxoYMDYNwAbRwOB+4HjxwJILD/8Idc92oAA4LgeGz3EA +AAQqqLgHpiIM4AcN2IDlAN9wDOITyiAiBM91gADQLkUVARYHhiV4B6aKIBUM6g0gB4ohzQ2KIBUM +3g0gB0UVARbPcIAAOCYskM9wgADwIh6QEHELyEUd2BMK8gUggA8AAADUCxoYMAvIkLgG8AUggA8B +AAD8CxoYME4PD/8AhbC45gngEwClgOBsCcITWQMP//HAz3CAAIwVD4CA4A/yz3KfALj/HaLPcYAA +ICEEgQHgs7i1uLi4BKEWonoOgACD4BH0z3GAABCxiiCVB0oNIAcogc9wgAB0YZoNQBHGCOAABdjP +cIAAICEAgO+4BvIA2c9wnwC4/z2g0cDgfvHAz3CAAIwVD4CA4A/yz3KfALj/HaLPcYAAICEEgQHg +s7i1uLi4BKEWog4OgACH4BH0z3GAABCxiiCVB94MIAcogc9wgAB0YS4NQBFaCOAABtjPcIAAICEA +gO+4BvIA2c9wnwC4/z2g0cDgfvHAz3CAAIwVD4CA4A/yz3KfALj/HaLPcYAAICEEgQHgs7i1uLi4 +BKEWoqINgACE4BH0z3GAABCxiiDVB3IMIAcogc9wgAB0YcIMQBHuD6AAAtjPcIAAICEAgO+4BvIA +2c9wnwC4/z2g0cDgfvHAz3CAAIwVD4CA4A/yz3KfALj/HaLPcYAAICEEgQHgs7i1uLi4BKEWojYN +gACI4BH0z3GAABCxiiDVBwYMIAcogc9wgAB0YVYMQBGCD6AAAdjPcIAAICEAgO+4BvIA2c9wnwC4 +/z2g0cDgfvHAz3CAAIwVD4CA4A/yz3KfALj/HaLPcYAAICEEgQHgs7i1uLi4BKEWonXYqgsgB4oh +hQ0+C2AABNgKJQCAyiHCD8oiwgfKIIIPAADfDsojgg8AAHkBWAciAMokYgDPcIAAICEAgO+4BvIA +2c9wnwC4/z2g0cDgfuHFAdvPcoAAqAh+suB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgGuEUgzQDPcKAA7CemoAqAANsAsX6y4H/B +xeB48cCKIMoG8gogBwDZpgxAA9oNQBN6C0ATgNnPcKAA0BswoNHA4H7gePHAKggP/xpwAd8AEBIB +FPBadRLwFSDAI6CQAhARAQHn13UAAPv/8H909gwigK8AAP//CfLPcAAA+/9ScOz1SQAP/892gAA4 +IQCGAeCB4ACmCfQB2c9woADIHDGgZgigEyhwBr2BvUApACSleM9xoADsJwahAIZCIECAAKbc9c9x +oADIHADYEaHW8eB48cDPcIAAODIAgIHgyiHCD8oiwgfKIIIPAACvE8ojgg8AAPMByiQiAPAFIgDK +JQIBGggAANHA4H7xwGIKwBLmDoAP0cDgfuB48cBCD8/+z3CAAPAiA4AogM9wgAC8ssC5NngkgACA +CrkEIYEPDwAA/Mm4JXjPcacAFEgNod4MYAihwfpwz3GAADghAIEB4IHgAKEJ9AHYz3GgAMgcEaGa +D0ATi3FCDu//QtjPcAgAhxDPd6AA7CcGpwLZANg6cAogQKTaccogYiAPeS8lACRKIwAgFWkQuIG4 +h7iMuAanSiQAIYp1CiLAJGG9QChAIUAvgiFYYBUgTgOYdYAkgg3HdoAA+LICli8kCAFALIEBgbkc +eBC4JXgGpyKWwLm4eQUhwAQvIwggA5aYdYAkQg8vJAgBHHhALIEBgbkQuCV4BqcDlsC4uHgFIIAE +LyIIIIog2AfyCCAHqXGKINgH5gggB6pxIpaKINgH2gggBzx5I5aKINgHzgggBzx5QiRUIEwkAKBo +B83/QCsAJAUggA8AAAIvBqdAKgAkBSCADwAAwjAGp0ImQSCA4RQH7f9AIUAgABQAMRC4gbiHuIy4 +BqfPcIAAOCEAgM9xgAA4IUIgQIAAoQf0z3GgAMgcANgRofUF7/6hwPHAANiNuFIIYA4GGhgwDMyG +IP+KCPLPcIAAzDoAiIDg1AkCBdHA4H7PcQMAQA3PcKAAqCAtoM9xgAAYC0CBAWoAoc9woAA4LgWA +BCCAD8AAAADXcMAAAAAK8kjYz3GfALj/GqFboWnYGLgZoc9ygADgWwaCA4AggMdxAACIE7EAYBFI +cAhyz3OAAPxbBoMDgCCAz3CAAEghBIAAgNW4GWEQ4WhwiQBgEUJ54HjxwAhxz3CAAMwvSIjPcIAA +Xi9EKj4LMiBCDue6CfLGugq6z3CAAFhhWghgEVlh0cDgfuB48cDhxc91gACsYQaFA4AggM9wgADM +L2iISohEKz4LACGAf4AASC9VeEyQqXAKuiIIYBFZYYoglQpGD+AGIoUhBc/+4HjPcIAAhC9ckM9z +gACQYSKDaHAKuvUHIBFZYeB48cDhxc9wgADML0iIKojPdYAArGFEKj4LACGAf4AASC81eEyQIoWp +cAq6xg8gEVlhiiCVCuoO4AYihcUEz/7gePHAOgzP/s9xgAA0aiGBo8FCwc9xgADwIhUhEAAAEAAg +wBAOBoDmLyiBA04gjQdY8hJtFngAIJIPgAAQ3wYSgCDPcYAA0OEWeQCBIpGO5QgcRDDKIGEABvKL +cgYNL/8CwYDgN/IA2M9xgAA4CkCBDyBAAy8hCiAEIYCgAKEG9IDi2A3iCMogIgiveJYIIAUQ2QDf +BBrEI4ohCAAAGkAgqXDpcZYJ4AcP2gAQAiDAEgAGBCBABMAaGADPcIAAUOK2eOCg4aDPcIAAcN60 +eOCwECZOky8ogQNOII0HrPW5A+/+o8DgePHA4cUIdQTwTg4AEbIOIBGpcIDg+vXFA8/+4HijwULC +CRSAMIHgAdjAeBC4AeDgf6PA4HijweB/o8DgePHAJgvP/s92gADsCgAWBRBMJUCCyiHGD8oixgfK +IIYPAACGJ8ojhg8AAGMAaAEmAMokpgDPcIAAjBUKgIDgEPLPcZ8AuP8doc9wgAAgIUSAAeKzurW6 +uLpEoFahz3eAABhjAIahhgi4IIcFfTB1CfIQuYogSwVKDeAGpXmgpyCGz3CAAPx18CBAAEB4gODr +889wgAAgIQCAUSCAggbyANnPcJ8AuP89oOUCz/6iweHFQsFBKAICB3pBKAEER3nPcoAAkN7GuSpi +57oS9AgUAzHPdYAA0OGpcVZ5QIFQcAX0QpFwcgbyR4nnuvfzgNgD8AaJwcXgf6LA8cDPcoAAGt8y +aDZ5MWKiwUDBQcCLcAjZntoe29YLYA8Yu6LA0cDgfuB+4HjxwAjIlbgIGhgwCcibuAkaGDALyIq4 +jbiQuAsaGDDPcIAA8CIDgBiIgeAM9AvIz3EAAFAsrLgLGhgwcgqgBw/Y0cDgfvHA4cUIdT6Iz3CA +AKwWQIBAJQAUA7k1eVlhkgkgEAramg/v/6lwEQLP/uB48cClwUHAQsEMHAAxEBxAMc9xgAB8njQZ +wA8wGQAPLBnADigZgA4kGUAOz3CAAHyeIBhAC89wgAB8nhwYAAvPcIAAfJ4YGMAKz3CAAHyeFBiA +Cs9wgAB8nhAYwAjPcIAAfJ4MGIAIz3CAAHyeCBhACM9xgAAAnoAZAAh8GcAHeBmAB3QZQAdwGQAH +bBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAESBmABEQZQARAGQAE76HOoa2hjKEs +GcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAAA9gZAABqIMAC1BkAAGoggALQGQAA +aiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAAuBkAAGogAAC0GQAAaiCAAcwZAABA +2J+4z3GfALj/HaHPcKD+AAAWoVMjwAQFIIAPsP4AABahGIFTJ801UyXENVMmxTWUuBihQMMBwALB +17oMFAYwqXNaCeAGEBQHMOIPYA8A2M9xoADIOy6BngrgBn3YlglABM9wAACt3tYJAAEI2ADZMgpg +B5m57QYAEOB48cDmD4/+z3KAAPApgOHPdYAA/GYO8gCiAIWA4BP0NgigAQ/YDgrgCAjYAdgApQvw +AN7AouYOYAEP2L4J4AgI2MClEQDP/uB4z3GAAPQtAIEc2s9zgACcCUCgQoNVIsAJAaGgEgAAjbig +GgAAz3CAADwLpBoAAJwSAAFngwShVSJADQOhQCIAB3Z4BYig4Az0z3CAAJQJAJBIdIAkRBMArB7b +A/AY22KhVSJADXhgBaGpAmAPKHDgePHAKg+P/s9wgACMFQOAgOAP8s9ynwC4/x2iz3GAACAhBIEB +4LO4tbi4uAShFqLPcIAAQAlAgM92gAAEEqCGBCKDDw8AAOAEI4EPAQAAABJpZHgHfaCmmHUEIo4P +AAAAQM91gAAAEuCFA75kfj15x3/gpQQkDQAEIoIPAAAAgAYjQANFeQK55H4EI4MPAgAAAMZ4ZHkm +eC8oAQBOIEEEhuENGlgwB/LPcIAABMoOkIDgKPLPcIAA/AkAiM9ygADwIvAiAgC/EgIGUyJCgBr0 +z3KAAERvhuEEuABiEvTPcoAAFMr0IgIAgOIM8s9ygACAQiOCDRoYMAHhI6IF8BBxG/IocM9zoAAU +BAqjz3KAABgKQIqB4gDZBfRJg7jigvcB2YDhAd0J9M9xoACIIBV5oKEU8AbY2/GGCCAOBhpYM44L +QAaA4Ar0ANmRuc9woADQGzGgKgugEalwOQaP/vHAzg2v/jDaz3GfALj/VqENGhgwz3GgANQHGhkY +gB8RAIYB3QEaGDAEEoUwTCUAh8ohwg/KIsIHyiCCDwAA6xzKI4IPAABpAfQD4v/KJEIDGREChgPY +IBkYgBQZWIMPEQ6GABYAQAAWAEAAFgNBABYAQQAWD0APGZiD9L9WIwACEHgE8gLgEHgD4AQggA8A +APz/EHIPEQCGQOAeGRiAHREChhv3rboeGRiAHRmYgH4MQAaA4AXyigmv/wDYEvALyAUggA8BAAD8 +CxoYMAvIrLgLGhgwBvCNuh4ZGIAdGZiAfg/gDQYaWDNNBa/+ANjgePHA4cXPcIAAQAmggHXYBCWN +Hw8AAOBiD6AGiiGFCS8tQRPyDu//TiVAFAolAIAO8gohwA/rcs9wAADeDoojxQoNA+//TiVEFH/Y +CrjPcaAA0BsToX/YEKH9BI/+8cB6DI/+CHbsiCiWz3CAAGAJsm8oc4Yj8w+2fUIrEQLHdYAAEN9g +he27CHIC8kRo67mKIMMvBPQeFpAQDY5RIACApPLjuT3067sV8v/YB61KJABxANmoIIADKGIAIYMP +gAD45vZ7BKsoYgHhL3kAq13wTCEAoZD2CiHAD+tyz3AAAC0liiMLBEokQABlAu//CiVABO65B40y +IkIEACGBL4AA+Ob2eQnyRKkE2QApQQQleAetPfBAqQ8gQARj8EwgAKSW9owgw6/KIcIPyiLCB8og +gg8AAC4lyiOCDwAA5ALKJGIADALi/8olAgTaCe//yXAIlu64BfICjgmtA/ABjgitAIXruBjyANpH +rUokAHHPcYAA+OaoIMACOGL2eAQYAgQAGAIEAeJPegGOCK0CjgmtLPBMIQChyiHKD8ogig8AAC8l +yiOKDwAAAQM8B+r/yiLKBwiWACGBL4AA+ObuuAeN9nkJ8gQZAgQE2QApQQQmeAet3fEAGQIEANkP +IUEEJngHrQGOCK1RA4/+8cD2Co/+z3OAAHAKYIMA3s91nwC4//2FeWHPc4AARAngo92lz3OgAFAM +YIPHcwAAAEAie827cHDE91EjAMD0889xgABECWCBz3GfALj/faFRIwDAyiAiAB70geIb9M9yoADQ +DxASAYaA4NP3z3WAANQXn3BjhaggAAMCjSUSD4bBuNNo2H8B4AKt53tjpRAaWIAB2MkCj/7xwF4K +j/7PcIAAjBUPgKzBgOAA3w/yz3KfALj/HaLPcYAAICEEgQHgs7i1uLi4BKEWos9xgADAKBmBz3WA +ABCxobgZoQKVIZUQuAV5AhxEMDC5BBxEMCiFAtrPcKAAsB9IwVmgz3KAAEghCYIAgEnADYIAgErA +ggygBoog1QPPcIAAmAoggIog1QNuDKAGIokIheC4HPJRIMCBGvTPdYAA8CIAhcQQAAbPdoAAFEBR +IECBB/RWC0AFAdjcHgAQAYUYiEEeGBAKCmABGNjPcIAAzC8oiM9wgABcL0QpPgs0IEAOUSAAgcog +AQfKISEMyiKBDwAAkADKI6EHKAshD8ArIQbPcIAAICEAgO+4BfLPcJ8AuP/9oLEBr/6swPHA9gkg +AAHYz3CAANAuIIDruQ/yz3CAAPAiAIDEEAAGUSBAgQXyUSGAggTYAvIC2DYPAADRwOB+8cAKCY/+ +USCAwaXB1AmiBMogogALyJC4CxoYMDYNr/4A3c9wgAB0YSaAI4EggYy9QgzgELlhANnPdoAA0C78 +HkAQz3CgACwg8IDPcAAAQB5AwALYQcAB2ELAQ8FEwQXZBNoA25hzuHPYc+oKoAQAJ0cTAIaLuACm ++QCv/qXA4HjxwIoIj/5RIIDBpcFUCaIEyiCiAAvIkLgLGhgwtgyv/gDdz3CAAHRhJoAjgSCBjL3C +C+AQuWEB2s92gADQLvwegBAA2c9woAAsIPCAz3AAABgfQMAC2EHAQsJDwUTBKHAF2QTaCHOYcLhw +2HBmCqAEACdHEwCGq7gApnkAr/6lwPHADgiP/s91gADQLgCF67gF8mYPAAaA4AryC8gFIIAPAAAA +PAsaGDAqDI/+z3OgADguB4PDuI/gD/IcEwQACiHAD+tyz3AAAMEbiiMEAC0Gr/9KJQAAz3aAADgm +CI6J4AfyiOAR9ACFUSAAgg30+g4ABoDgCfLPcIAArGEGgAOAAIA2C8AA8g4ABoDgCvLPcIAAdGFq +CsAQlg0gAADYCfAIjongCfQAhVEggIAF9ADYbgmgCIy4xQdP/uB48cA+D0/+enCB4AHdwiVBE4Hg +AdjPd4AA8CIgh8B4yBEOBiGHRCa+kcgRAwYE9EQjvoES8gohwA/rckArDQTPcAAAyxuKI0cMCiTA +BHEFr/8FJYUTz3GAADgmXpcskVBxB/TPcoAAzLtBglBxGvIiCgAA6gkgAKlwqgkAAPAnQBPEEAEG +qXAlucC5cgngAADa4gxAEQvIkLgLGhgw+gqP/uIL4BIB2CIOoAsA2BoOoAsC2M92oADAL6kWAJar +FgGWqhYClgV5rBYAlgDdrRYDlgV6rhYAlgV7z3APAAD4BCEBgAQiEAAEIxEAWnUX8i8qQQBOIoAH +z3KgAAwt8CICAFEiAIIA2g8iAgAE9EV9BPAFIpIgBiGBgOv1z3CAADgmLJAelxBxD/TPcIAA0C4A +gAQgvo8AADgQBfSeCgAGgOAo9EwjQKAL9KUWAZZPIgAhhrgGeaUeWJAP8M9wgAA4JiyQHpcQcQny +pRYAlkUlQREmeKUeGJBMI0CgCfLPcIAAOCYskB6XEHEE8soOIBMF2EwjQKAL9KUWAJZFJUERBSEB +BCV4pR4YkDrwTyIAIYa4z3GAAMgvSIEFIEAEBXoA2AihAYfAEAMGgOMvKMEATiCNByHyjuXKJCJ0 +yiAiAOggIgXybQAggQ+AABDf9n8S4e9hjCfDn8ohIgDPIcIDxiJCAAHgECNDgy8owQBOII0H4vWl +FgCWBXqlHpiQeQVP/vHALg1P/s9xoAAsIOaBsIHPdoAAyC8FhgIlAhAEhhByRPdCeAahBvAK2Aah +Vg8AB+SmZQVv/qWm8cDhxc91gADwIhV9AIXPcYAA8LGAIAMAygygDwPaAIXPcYAAHECAIAMDugyg +D4PaPQVP/vHA4cXPdYAA8CIVfSCFz3KAAPCxSHCAIQMAlgygDwPaIIXPcIAAHECAIQMDggygD4Pa +CQVP/uB48cChwc9wgAAMagCAIg5gB0DAi3AE2b3aHts2DuAOGLuhwNHA4H7geM9wgADIL+B/BoDg +eM9wgAC0L+B+z3CAAFgK4H8AgOB48cBCDG/+ANlKJIBw4HioIAAKz3WAAMwwcNwCJQITRCk+Bydy +z3eAABhiAN7AogXbZKLPcwIADENjogHbZaLmokIlAh4AIkAOwKAG2kSgz3ICAKBDQ6BloOagAeFN +BE/+8cDiC0/+z3CAAFgK4IDPcIAAjBUPgIDg730Q8s9xnwC4/x2hz3CAACAhRIAB4rO6tbq4ukSg +VqHPdoAAFWMAjhB1CPKKIBUDMg5gBqlx4K7PcIAAXG7wIEADQHjPcIAAICEAgO+4B/IA2c9wnwC4 +/z2g2QNP/uB48cAeDO//ANjPcIAA0C4AgOC4BvLuuAf0CNgD8AHYcgkAANHA4H7gePHAQgtP/qXB +USCAwQLdDAxiBMogQgMLyJC4CxoYMG4Pb/4A389wgAB0YSaAI4EggYy/eg6gEPlhz3aAANAu/B5A +EwDZz3CgACwgQBAHAM9wAACsHkDAQcVCwUPBRMEB2AXZBNoA25hzuHPYcB4NYAQAJ8cDAIaAuACm +MQNv/qXA8cDCCk/+USCAwaXBjAtiBMogogALyJC4CxoYMO4Ob/4A3c9wgAB0YSaAI4EggYy9+g2g +ELlhA9jPdoAA0C78HgAQANnPcKAALCDwgM9wAACEH0DAAthBwELBQ8FEwShwBdkE2ghzmHC4cEom +QACeDGAEACdHEwCGoLgApq0Cb/6lwOB48cDGDuAF4cWA4AvyC8gFIIAPAAAA1AsaGDBuDk/+z3WA +ANAuAIXnuAbyp7gApQYPYBAA2M9wgAA4JgiIieAI8ojgDvQAhVEgAIIK9M9wgACsYQaAA4AAgJIN +gABZAk/+8cDiCU/+CHbPdYAAWAqKIJUCZgxgBiCFiiDVAsClWgxgBslx2g3P/yUCT/7xwAHZz3CA +AMgvIKDPc4AAkGEGgwOAIIDPcIAASCEFgECAaHDVuvYMoBBZYc9wgACYCiCABImguASp0cDgfuB4 +z3OAAJBhBoMDgCCAz3CAAEghBYBAgGhw1brBBKAQWWEocgkAIAAA2eHF4cZAKQ0CJX1ALQMUiOKl +ewh1kPdTJX6QBvIBHVIQYbr78UEqjgDBukImTpAEHdAQ/fWA4gryLySJcOB4qCCAAQEdUhDgeMHG +4H/BxeB48cDhxc91gAAkrCCNjCHDjwrygOAG8s9wgAAQXtILgBD/2ACtz3CAAMyrANk1oM9wgADQ +FyCgz3GAAJQuAIGiuIoIoAsAoQDY0giv/whxJQFP/uB48cDhxQDdz3CAAPQKoKDPcIAAlC6goM9w +gADEsKl0nbAwvJ6wZgygBKlwqXDmDSAKqXHtAE/+4HjxwGoIT/7PcIAAjBUCgAcSDzaA4A0SDjYB +EhA2D/LPcp8AuP8dos9xgAAgIQSBAeCzuLW4uLgEoRaiBtgNGhgwz3WgABQECqUJhYDgJ/ID2BCl +BKXPcIAACOrWDiARAxoYMJLZA8iQuaAYQABCD2AEANgJhYDgD/IoFQQQJBUFEB7YCiHAD+tyjLhV +Bm//iiMEBgca2DMBGhg0z3CAACAhyqUAgFEggIANGpgzBvLPcZ8AuP8A2B2hFQBP/vHA4cUIdeYO +4AAU2M9wgADwIgCAxBAABiW4pgggAcC4pglgCATYHgzgDqlwEgpADkYPAA6KIAsAEgpgBqlx7QcP +/uB48cByDw/+ocEIdSh2iiBED/YJYAapcYLlA/cT3ZrwqXDJcVoMr/8A2s9yoP4UBoDgz3GfALj/ +BvRIcBahtqHv8UAiAA4Wobahz3KgAFAMBYLPdoAANLESrgWCE64JlowgiIAqbUbyE/aH4CLyjCDE +gWr0guFaAAUAz3KAALileg1v/kAiAAJIcR/wjCDIgEzyjCAQgFj0BYIJaYXgQ/cA3VPwigmgBwDZ +CHVP8IHhSvTPcoAAuKVCDW/+QCKAAguKgbgLqu3xC4mAuAup6fGB4Tj0Jg1v/otwIMDPcYAAuKVT +IAIAhiB/D0ipHHgJqe3xjuFQAAUAz3CAAPAiA4AYiIHgIPLPcoAA7KJIcOoMb/4G2UAiAALiDG/+ +BtkMkoG4DLK/8YThjvfPcoAA7KJAIgAFxgxv/gTZDJKAuAyysfET3QPwHN2KIEQPvghgBimWqXCN +Bi/+ocDxwM9wgADsogyQ4LgE8qoKQAQG8FEgQIAQDEIEz3CAALilC4iB4AjyguAJ9MoIQAXRwOB+ +3glABfzx/PHxwN4ND/7WDcAFgODPdYAA0C4P9AQVBBAKIcAP63LPcAAAvRvD2yUEb/9KJQAAz3aA +ADgmCI4AFQQQh+DRJCGCyiHBD8oiwQfKIIEPAADDG8ojgQ8AAMoA8ANh/8olIQBRJECCNfQA2c9z +gADMLyirAdpJq0qrjB1EEArbjh3CEIfgAtuPHcIQBvKI4A70USQAggzy7BUAEWq4EHiQHQQQCtiU +HQQQB/Bk2JAdBBCUHUQQkh1CEJYdghBVJcAYViXBFQYNYA8L2gCFibgApQHYAaXPcYAA8CIAgcgQ +AAaGIH+OCfQBgcgQAAaGIH+OaAjBAwiOh+AI8s9xoAA4LgeBqLgHoUUFD/7xwNIML/5KJEBxz3aA +AOjIJIYA3aggQAIA3w8nTxMLIcCDBPQB5Q3wiiBKDj4PIAapcQSG5ngEpjYKoACpcASGgODIC+EA +yiBhAvEED/7geAhzOGDVu9W5MHM2uMT3AiNCAArwz3KAAHjnRYIB4Mm4Inp6Yha44H9FeOB48cBW +DC/+mHIIdc92gABEpvQmQBDPd4AAxKVRIECCyiBBAMokInTKICIA6CBiAvQmAhBRIkCCA/IB4JDg +RgAGAC27wLvPcoAAcN60ekArhQJgkgS9hiX4E4m9DyNDAGCyANoWf0CnQafDuaV5BSFDARR+YLbP +cYAAZKYVeQAZAAEC8IDYOQQP/uB+4HjxwOHFz3GAANSqQYnPdYAA0BeA4s9zgACULiCDBvIB2ACl +grkgownwANpApaK5gOAgo2gLQgsA2LILb/8IcWoOIAIA2P0DD/7xwIYLL/6YcAMSATYAkSGBQOD0 +ucAgogAD4AQggA8AAPz/z3GgANQHDxENhgAgBQGQdQDaR/cNyBUiAzAOEwAGHWUZEQCGAiVDAxBz +fAAOAAXdDL3PcKAAyB++oBDdrqAB3RUYWIPPdp8AuP+9hs9wgABECaCgXaYZEQCGEHPF91EjAMD6 +889wgABECUCAz3CfALj/XaBRIwDAGPINyBUiAjAOEgIGz3CfALj/VqB2oBkRAIYKIcAP63JD2M9z +AABEFjEBb/+MuA8ZWIElAw/+8cCKCg/+q8EHyADez3eAAPjnBCCAD/EAAPBAwA3MABcVEM91oADI +H2GHUSBAgAPIDvKgFQIQ+BUBECJ7dhABAQIi1wAvJ8glWWEG8IQQFwEAJ8EgOhjEBR+FEHHF9zB4 +fgzgBgLZAdnPcKAA1Ac0oDOgA9ktoBEQAIbPcaAA1AdBwEDgDxkYgBQZmIMDyKQQAQBRIQCCBfJ+ +DEAOA/BHHZiTz3CgANQHDRABhkAvACQweQUgVAADyCGAABASAUPBuBCYAHIQAQG6EAABAiETBgYK +4AdEwIHgC/TPcIAA9CAAkIHgAdjAeAy4QsAC8ELGA8jPcaAA1AdZgIgZgACkEAEA2aC4GIIDuhiE +A7e5pBhAAAPA9rgI8s9woABICEAiASMH8EAiASHPcKAATAgEwgLDA3FlegUklCBnac9yAAD8/2R6 +Y4cIItAAz3OgANQHNaMAGAAFAiLAJA+jAiCAIBujA9gQo89xgADcOg0SAjYAgVBwHfLPcKAAOC4F +gAQggA/AAAAA13DAAAAADfL12AW4z3OfALj/GqNbo2nYGLgZowHYAvDJcIHgA/RAoQGHliBBDx6l +ENgOpQHYFR0YkM9xgAAUGgGBUSAAgF70iiAEAAChiiDTBnILIAaKIQQAz3CAAOI6AJDPcYAA4DpK +JEAABCCADwAAACjXcAAAACiFFQCWhiD/DkEohQAAkcIkAgEvJgfwLPTPcoAAXD9MigQggA/////C +QCzDAmV4hiL/AUO6hiJ/D4LiAdrAei8mh/AB2sIigQAFIkIBiLgKukV4TyBCAwQggA8AAAA8TyB+ +g1B4QLEE9Iu4ALHPcaAA/ERNgQQggA8AAAA8BCKCD////8NFeA2hB8jPcYAArLIEIIAPAQAA8Cy4 +AxIDNgSxD4POqQChQBMAAQKxEItgEwMBVGjDu2V6RrEPqSGHDRICNs9zgACAykAjBAlVe0mDMHhY +YAmjpBUAEDhg+BUBECJ4RcAB2M9xoADUCxChA8A1uMC4F7gAIIEPAA4AAAKHArgr4AQggA8AAPz/ +JXjscQChARIBNuxwIKAih+xwIKgNEgE2z3CAAATKNHgwiOxwIKjscMCwA8iUEAEA7HAgoA3I8CQB +AOxwILDscMCw7HDAoOxwwKAHEgE27HAgoAPIIJBUEAABELkleOxxAKEDEgI2AYJRIACBAiUVJA7y +MopQis9wgABQ4VZ4AIiGIH8MHHgEuCV4A/CA2OxxAKkDyM9ygADUYjCIMxCAAAS5JXjscQCpA8g7 +djyQ7HAgsAPIGnacEAEBD4AmucC5wLgMuQ24JXgAog0SAjbPcIAABMoAIoEPgAAsysCpz3GAALDJ +VnlUeMCwIpHAGIQD0BiEAxUkggB4GEQAz3CAAPAiBIAakMCiRsDPcIAA+OcCgIDgyiWOExwDLgDK +IY4jyXfJdTp2TCAAoL3yE/DPcaAA/EQdgTmBBCGCjwAAAAgR9AQgvo8ABgAADfRRIwDAJvTPcKAA +9AcHgP+4AN7p8y7wAN76uMomgh8AAAEC+bjKJoIfAAACAvy4yiaCHwAAAQKA4gnyz3OAAARCUIOK +JggSAeJQo0IPQBIS8AHZz3CAAKBiIKC+D6AQKHDPcYAAgEINgYomCBIB4A2hBSWNkxDycwIgAADe +hBIAALLglfdRIwDATfTPcAAAkBNKCsAFz3KgANQHD4IQeBkSAYZY4DBwLPcJ8M9zgACIQSSDiiEQ +IQHhJKNRIYCgRPQeGtiDHRIAhgcaGDAdEgCGSsAdEgGGBMggoB0SAYYhoB0SAYYioB0SAYYjoB0S +AYYkoFYnABIeGhiAHRIChkAvASRQeAUgVAAEEgE2hiLzDwAREgGMIgyAAYFDwBbyGtgV8M9wgAD4 +5wgQBAAAEAUACiHAD+tyV9jPcwAAjBONAy//jLgA3tLwINh6cANwEHhyGQQAAN5MIACgBPQDyHPw +A8D2uAfyz3GgAEgIQCIAIwbwQCIAIc9xoABMCEfBA3BIwATBAsAleAUkFCAIwAfgz3GAAPjnI4EE +IIAPAAD8/wggVgAMJkClLAEtAEnA1g0AAAUlDZCZ9AHZz3CgANQHFBhYgFUnQRQPGFiAUSIAwv71 +CMDPcaAA1AcVoQfCAiLAJAAaAAUPoQnCAiaAIBuhA9gQoSrAnOAA3o/0B8gAwQQggA/xAADwEHGV +9APIqXHIuQIllSUIiAy4JXgDEgE3ELkleOxxAKEKwEAhWTABGhgwBMgDEgE2QccDGhgwBBpYMCGA +AJABxzS5wLk0eAPgQOcEIIAPAAD8/x9nDRIBNgbwFSJAMA4QAAYCfxUiQDAOEAAGEHd39wPMz3Gf +ALj/GKHPcKAA/EQ9gAQhvo8ABgAAYvRMIACgC/IEyFCIUyLBAIYi/gNEusQYggAwqM9woAAUBMSg +B8jPcaAASCwdoc9wgAD45wKAQCBQIBJwDgXN/wzwz3KAAIhBI4KKIRIgAeEjogLwOnUyCcAGUyF+ +oAT0kgwAAAV9gOVS8uG9R/IDyCmIAeEpqM9xgACIQQaBAeAGoUPwCiHAD+tyKBQFMDzYjLjPcwAA +GxShAS//SiRAALIOYAYocAohwA/rcgcSBTZH2Iy4z3MAACMUfQEv/wAUBDBMIACgz3KAAIhBiiUQ +EAn0B8jPc6AASCyKJQgQHaP6uQbyBYKAvQHgBaK18QaCgb0B4Aair/HgvQfyz3GAAIhBBYEB4AWh +OnUDyKlxyLkIiAy4BXkDzBC4JXjscSp0hCQCkQChQCFPMBvyz3GgANQHgBlABQPMKnLIuhC4RXjs +cgCizKEB2BQZGIAeDGASAefPcaD+hADPcJ8AuP82oAMSAjaSEgAB6rgEEgE2BvSSEQMBUSOAgjby +qriSGgQAkhEAAaq4mg9gCpIZBAAQ2c9woADQDxAYWIAkEAKGz3GAAAjuJZFQegK5RXkMGFiAFNkQ +GFiAz3GAAAjuZ5FGkRjZELtlegwYmIAQGFiAz3GAAAjuaZFIkRC7ZXoMGJiABvDPcIAACO7KqM9y +oADUC9CiTCEAoGTyz3Gg/rgAz3CfALj/NqAF8AjZ7HAgoAHnz3CAAPjnAoAQd7f3z3CAAKyyJJCU +4cAhhg8AAJMAz3CgAGgs8CBAAM9xgADUYiCBz3egANQHJXgNogPYEqdyCgAOUSVAkgXy8g2v/wHA +BvAD2BMfGJAUH5iTTCAAoBfyz3CgACwgMIAFwDBwAd3KJYYTBCCPTyAAAADPcAAANRW6DYAFgOXM +JyGQ6/PPcAAoCAAGGhgwBsC+CqAGyXFRIUCg0PLPcKAALCDPoMzwz3CAAFw/EYhRIACAOfJRIADD +N/LPcIAA4DogkChwhiD7D4wgBIAB2MB4geAP9M9woADAHQeABCGBDwAAADyGIP8OIrgKuCV4A/AH +2Aq4z3KAAPAiQ4LPcYAAXD8wiRC5MiKCDwAA2AKfuYDiAdrAeg+6RXkleM9xoAD8RA2hTCUAoA3y +z3CgAPQHYBhABc9xgACIQQOBAeADoc9wgACssiSQlOHAIYYPAACTAM9woABoLPAgQADPcYAA1GIg +gQDaz3agANQHJXjPcaAA1AsNoUymiiAEAs4K4AWpcSIOoBAGwBkWAJbA4KAADgANzFEgQIBM8gPd +IB5YkwHYFB4YkAQSATYAFgRABxoYMQAWBUABGlgxBMqc4MoiwgfKIIIPAADcDsojgg8AAPQKTAbi +/sohwg8ocAILoBEO2Q8WAJYEEgE2tBkEABMeWJMQiVMgwgCGIP4DRLjEGQIAUKnPcBIgAAB6C2AE +DRICNgTIz3GgACwgsBAAAS+BZOAwcMoghQ8SKAgAhffPcAAoCAAGGhgwAN4NzAQggA8AAAIIguAJ +9AQSATaKIAQA6gggC5gRAQANyM9xgAAUys9ygADoyBR5z3CAAPjnwLEigAaSz3aAAKyyGWEweSay +rdjPcgC7ALu2DiAIBbgDyBqQtg5gCA0SATYEls91gABg3fQlARAGljBwE/KOCmAGB8gKIcAP63IE +lgwWBBHPcwAAqRX0JQUQMdhVBe/+jLj5Bq/9q8BRIEDD8cDhxSfyz3CAAPjnAYDPcaAAyB+WIEEP +HqEQ2A6hAdgVGRiACg8gEkHYUSBAwxPyAdnPcIAAoGIgoFoIoBAB2M9xgACAQg2BAeANoYolCBIu +8M9xoAD8RB2BOYEEIYKPAAAACADdB/QEIL6PAAYAABnyAN36uMolgh8AAAEC+bjKJYIfAAACAoDi +CvLPc4AABEJQg4olCBIB4lCjag8AEgbwA9nPcKAAFAQloKEGr/2pcOB48cAiDo/9CHXPdoAAiA8A +joDgqMFY9It36XDPcYAAWGrGDq/9INoB2ACuANiPuAsaHDAA2BUaAjDPdoAAAADXdQAA/sqgtgX0 +B8CAuEfAz3CgAKwvGoBSIAAAUSAAgAjyAZaAuAG2B8CBuEfAz3CAADxvoIhaCSAFqq7PcUN1qBJA +wYohGgpBwSuOBKZGwOlwY8ENHEIzz3GAAMxDRMHPcYAAOENFwSDZAdo92zoPIA4XuwjYsg8gBgHZ +AtnPcIAAPCkkoMUFr/2owOB48cBSDY/9KHaA4M9xgADwIi8gByAD9GGBAvBggcQTAwYlu/AhDQDA +u4DmoqGjocwjIYAB3colIRDPc4AAOCboi4nnF/ThgcQXDxZRJ0CREfLsk36RcHcN8oHgCvKA4An0 +AIHEEAAGUSBAgQP0AN2B4solIRAA364MYA7pcApw5gwgB6lxz3CAADwpBIBRIICAEfLPcIAAFD0A +gIDgC/TPcAAAFgkCC0AFgeAF9GoLgAwM8ADZnrnPcKAA/EQhoOB44aBiDGAOANiA5gfylg1gAAHY +ng1AADIKQAWA4AT0HgpAEATwTgpAEM91gACcEACNgOAG9OIMAA8B2ACtuQSP/fHATgyP/c92gADM +LymOaI4wc891gADQLhpwBfQAhey4o/JKjs9wgABcL0AgkQFEKz4LJ3BVeAaIgeAornP0AIXPd4AA +SC9EKT4LQCcBFTQhQQ7suMC5EfKA4ay4AKUU8rIIgAYIjkQoPgsAJ0AeKpCguSqwCPCA4QbymgiA +BgCFjLgApQiORCg+CzIhQC6B4AHYwiABAH4KIBIKrgiOKo5EKD4LJ3c1f0yXmHCA4s93gACsYelw +GPLPcYAAOCYoiYnhCPKI4Sv0IIVRIQCCJ/RELD4LMiFBLoHhBvRAKoECAnED8Apx2g7AD4oglQoC +DqAFIoeKIJUK9g2gBSKHCI5EKD4Lz3CAAFwvNCBADlEgQIEAhSfyhbgm8C1qCrkCcePxRCk+CzIh +QC7Pd4AArGGA4MogYgDeCSASCq4IjkqORCg+Cy9xACGAD4AASC9VeEyQgOLpcMjzMiFBIIHhwPXC +8aW4AKXPcYAAOCYoiYfhDPKI4RD0z3GAAPAiIYHEEQEGUSFAgQjy4rjPIOIA0CDhAAClUgnAABUD +j/3xwLoKj/3PdYAA6MjElYDmH/LPcKAALCAwgADfBoUnpQ4gQAAyDK/9yXEIpYogigsiDaAFyXGK +IMoLGg2gBSiF5LXPcKAALCAQgOW1BqXVAq/9CIXxwF4Kj/06cM91gADoyACFz3GAAAw1ArgVeBUg +QAQwIRAAiiBKDdoMoAUqcYogig3ODKAFCnFMIAChD/QAFQQQCiHAD+tyiiDMDIojxQKJAO/+CiVA +BEwgAKA38kwgQKAU8kwggKAe8kwgwKAR8gAVBBAKIcAP63KKIAwNiiNFC1UA7/4KJQAE5goAAB3w +iiAKC24MoAWKIcUGfgkAABXwAIWB4APeCfKKIAoNUgygBYohBQnApQDYBaUEhaC4BKUWCmAAA9j5 +AY/94HjxwM9ygADoyCaSAeEHkjB5EHEmstf2BIqB4Ab0BYqB4AHYA/IA2IDgDfIKDKAFiiCKDoog +ygH+C6AFiiGGDKoIAADRwOB+4HjxwOHFz3CAAFTLQJBEIgADiOBD9ADdz3GAAOjIpaEEgVEigIGg +uAShJvQEkc9ygABAyQHgRIIQeFBwBLHU9wSJgeAG9AWJgeAB2APyANiA4AryiiDKAZYLoAWKIYYB +QggAABvwz3CAAOQ4A4CA4BLyA9gR8M9xAAD//3ILoAWKIAoOz3GAAOQ4A4GA4ALyo6EE2KIJAAA1 +AY/94HjxwOHFz3OAAOjIBBOEAEwkQIAG9AWLgeAB2APyANiA4Av0BROFAAohwA/rcoogjQ71Bq/+ +ztsC2ACjAN0Ek6mjpaOmswqjBIOks6C4BKOKIMoB/gqgBdXZLgpgB6lw0QCP/eB48cDhxYogCg3i +CqAFwNnPdYAA6MiKIMoL0gqgBSiFANkD2AClJaUkhaC5DgqgDiSlmQCP/QDZz3CAAOjIKqDgfymg +4HjxwBIIj/3uD8//z3CAABTJYIDPcoAA6MiogGCiz3aAAFw1BIKoogDZwIaguIHmJaIEohj0guPM +I+KAGfSA5c9wgADkOCOgC/KKIAoLWgqgBYohBAtqD8//CfDqCgAAB/AB22CiKKKguASiFQCP/eB4 +8cCiD2/9ANjPcaAALCBQgc92gADoyCSOz3WAABTJgeEIpQX0JY6B4QLyAdiA4CX0KoaA4RzyBoYC +Ca/9DiCAAM9xAAAQJzBw0PfPcYAAeOclgZkhzQowcEr3BfDPcAAAECcIpQLYCPAA2AjwCYaA4Pb1 +AdgApQHYlQdP/fHA4cUIdYogCg6yCaAFqXHPcYAA6MgEgQ8gQAMEoXYPIAAJ2HUHT/3xwPoOT/3P +dqAALCAQhs91gADoyAelz3CAAOxf0gngDwDfiiCKC24JoAUklQAVBRBMJUCAEfJMJYCAzCXigFHy +CiHAD+tyiiBMDYojCAcdBa/+iiSDDwSVgOCd8uYLz//PcIAAeOcFgCiFmSDNCjBwAdjCIA4AgOCN +8s9wgAB0OOmg13EAABAnbyALAIDgIPIEjYHgBfQFjYHgAdkC8gDZgOGKIAoLCfLqCKAFiiHHBJYN +z/9v8N4IoAWKIQcGz3AAAIgT5g3v/wilZfCKIAoLwgigBYohBwjSDc//W/AElYDgIvQllQiFgeHA +IIEPAACIEwPyG3gIpYogCguWCKAFiiFHDc9wgAB45wWAKIWZIM0KMHAB2MIgDgCA4Df0EgkAADfw +geAH9IogCguKIYcOK/AIhR1413AAABAnCKVvIAsAgOAd8gSNgeAG9AWNgeAB2QPyANmA4YogCgsI +8jYIoAWKIYgB4gzP/xPwJgigBYohyALPcAAAiBMIpQfwiiAKC4ohyAQOCIAFIg3P/wSVBbWKIIoL +/g9gBSSV5LUQhsEFb/0GpeB48cDPcYAACKNBgc9xgAB45yWBBSm+ADBwyiBOAAwhAPDPcQAAECfK +Dm/9yiBFDs9xgABAyQSh0cDgfuB48cDhxQDYz3OAAOjIAKPPdaAALCAQhQHZz3KAABTJBqMQhSCi +BqLPcIAAdDgDiCSrjCCDhiSqBPIlqiWrEgwgAAPYTQVP/eB48cDhxc91gADoyIogigxaD2AFIIUB +2DEFb/0Apc9wgADwIgOAz3GkABxACIDAuBN4wbgSoeB+4HjhxQDaSiQAdM91gADEpc9zgAA8pkhw +qCAAA0AjAQIUeUCxFiUBEEChQaEB4EokwHMA2aggQALPcIAAcN40eECwAeHPcIAANApBoM9wgADs +okyw4H/BxeB4BfBCecdwQAAAAM9ygAB450WCUHE391MgQwVwccAgjQ9AAAAAwCCNAOB/IngG8GJ5 +AiCAD0AAAADPcoAAeOdlgnBxN/dTIEIFOmJQc4P3OGAH8AIggA9AAAAAYng4YOB+8cDeC0/9z3CA +AODLDIjnuAr0ArjPcYAAEN8WeAVhLb3AvQPw/90WCwAFgOAI8s9wgAA4JgiIh+AC2APyANjPcYAA +NLF3ic9ygADMuyGCMHME8iCCgOEE9AHfA/AA3892gADwIiCGxBEBBlEhQIEr8oDlKfQjhjiJhOEl +8koJwA+A589xgACQQBjyz3KAAHAKAoIB4AKiANjPcoAAeGIAos9ygADUYQCiz3KAAEgJAKIRgQHg +EaEF8BCBAeAQocYJj/16CgAFgOAO8s9wgAA4JgiIiODMJWGQBvTuCOAPAdjKDEAGjCXDn0/ygOcR +8s9xgADQFwCBgOAL8gDYAKHPcYAAlC4AgaK4pgqgCgChug/ADs9xgAB45waBRSBAAQahz3eAALil +C49RIMCAsA1C/QuPUSCAgBwNQgRSDAAE6goABYDgCAsiAMogIgaA5QjyAIbEEAAGUSBAgRf0z3GA +ABw9BImA4BHyA4mA4Ar0iiDQDgYNYAWKIUUDsg5gDQPYzgogABXYwQJP/eB44cXPcYAA1BcAiQHb +gOBhqSTyz3CgALAfeaDPcIAASCEIgKOBYIACgRB1ANoY9M9wgADsFwCIgOAD9AHYCvABgQIjDQDX +dUwAQEt590GpSHCB4AP0YaFCqeB/wcWioe/xgOAB2MIgDADPcoAA1BcAqgHYAaoA2AKqAaICogOi +4H8kouB48cDOCU/9CHUod0h2iiBHDVYMYAWKIVYDkOWJ9w7Y6XG6Dq/+ANqA4AP0E90t8M9ygAA0 +sUhwIgiv/QzZz3GAANQXAImA4A/yz3CAAFTLAJCGIPwAjCACgAX0BZJkkmd4A6FCJQATJgygBslx +CiUAkAv0z3CAAFTLAJCGIPwAjCACgPwOwf+xAW/9qXDxwDoJT/06cBpx0gtgBWfYaNjKC2AFKnFM +IQCnjvcKIcAP63LPcAAA4w6D2wokQASBB2/+CiUABEwggKHKIcYPyiCGDwAA5A7KI4YPAACEAMoi +xgds9wDaz3GAAMCfnroVIQEEAIEBKkIERnimDWAIAKEpAU/94HiJB+//BdngePHA4cUA3c9wgADA +n2YP7/4c2RvYpgggAAXZSiQAd89xgAD0F6ggwAIWIUADBBAFALB1mHUF9EAkTQABAU/9CiHAD+ty +d9gFuOkGb/5T2+B48cDPcIAAwJ8YEAUALyxBAUwkAIfKIsYHyiCGDwAA4g7KI4YPAACrALgGZv7K +IcYPz3CAAPQXFiAAAQCAQHjRwOB+4HjxwOHFz3ADAEANz3WgAMgfRR0YEKoPz/+A2BUdGJCJAE/9 +4HjxwAIIT/06cBpxmgpgBWXYZtiSCmAFKnFMIQCnjvcKIcAP63LPcAAA4w5j2wokQARJBm/+CiUA +BEwggKHKIcYPyiCGDwAA5A7KI4YPAABkAMoixgds9wDaz3CAAMCfnroVIAAEIIABKkIERXluDGAI +IKDxBw/94HiJB+//BdngePHAhg8v/f/az3CAAEi0ExiYgBwYmIAA3s9xgACcCcOhz3CAAGQpQKAB +2s9wgABoKUCgzKHQodGhz6HAocGhAt3Jd89wgAA8roQvCBkAIEIOS4IncAAhkH+AAEiuRiLCAEug +HgqgD0AgACFhvYDlJBiCIwHnJ/cC2ADZ0g2v/QTaggigBQHYZQcP/eB44H7geOB+4HjgfuB44H8B +2OB+4HjgfuB48cDeDg/9CHfPdYAAwBcAhTpxz3GAADBjRCg+DxUhwHMwIRAAz3GAAFxkBmGKIJMI +TglgBelxiiCTCEYJYAUqcUwgAKAH2MohAgTjIEIAyiBCBIbmyiCCA8wgYYIC9ACFg+AB2sIigQCH +4M9xgAD0GUCpEPSghQohwA/rcooghw8IvenbBSXEE80Eb/4KJUAErQYv/QCl4HjxwFIOD/3Pc4AA +xBeggwDeDyZOEITgzCCigQr0xn2go89zgADIFzV7QKMI8IPgzCBigQT0xX2gowYlvpPKICIAE/SD +4MwgYoEO9IPgAdjCIAEAz3KAAMgX8CJBABt4Dg/v/wTgAdhZBg/94Hj0uPHAFPLPcIAACBoIiIDg +yiBhAFgMoQjKIQEAANjPcaAAwB0IoQTYlLgJodHA4H7xwLIPoAVw2E8gQQbqD6AFcNiqCEAA0cDg +fuB48cDhxY4IoAWiwf4OoAIIdYHlEfSLdaYKoAWpcEIMoAipcIHgCfTPcIAA6CKKC4AFA/DeD0AF +2QUv/aLA8cDhxaLBCHWGCSAAi3DPcoAA1BghwQeCOGAHoiaCBRSAMDhgBqIlggYUgDA4YAWiJIIH +FIAwOGAEoiOCIMA4YAOiARSBMAKCOGACoiGCAhSAMDhgAaIgggMUgDA4YACiqXCAIAcJSHG2DS/9 +INplBS/9osDxwM9wgAA8GRSIgOAK8s9wgAAIGgzZztoe25IOoA0Yu9HA4H7xwMYMD/2hwc91gAA4 +IQCFAeCB4AClCvQB2c9woADIHDGgLg2gEShwi3HWCy/+iiCIDwCFQiBAgAClB/QA2c9woADIHDGg +ABQNMSe9wL3PdoAACBqKINMHAg8gBSiOiiDTB/oOIAWpcQiOsXDKIEID3AqiCMohYgCKDIAItQQv +/aHA4HjxwEIML/0Ic89yoADIH4MSAIYjiwQggA///wDAixpYgCGLwIsGuSV+IosKucV5JXiDGhiA +AYPoGgCAA4tCIACASgggAMogYgADi4DgAN0M8oogxAiEGhiAgxIAhpS4gxoYgAbwhBpYg4MaWINB +BA/9z3KgALAfIoIgoCOCIaCKIP8PAqIDouB+gODKIGIACLiLuM9xgADiOgCxz3GAAOA64H8AsYTg +CPIEuBR4ACCBD4AAdG1ggc9woADIH0RpghjYgEokwHIA2agggALwIkMAz3CgAIAfNXgB4WCg4H7g +eOB+4HjPcYAADEESgQHgEqENyMdwgAAgyiyIAeEveSyoz3CAABQaHIgQccn2iiAIAAYaGDCK2JC4 +B/CKIBAABhoYMELYmLjgfvHADgsP/YHgAdjAeC8hACAveIXgz3KAABQaP6oK9AmKgODQ9AHY6gwg +ACAaAgDK8M9wgACsDxUgUAADEIAgAd2A4AHYIBoCAM93gADiOgCXwH0vJgfwu30K9KV4ALdPJQEW +nLlKDSAFiiATB892gADgOgCWLyYH8Ar0pXgAtk8lARYuDSAFiiATBwCWz3KgAMAdJ4KGIf8OQSmI +ACCXAxCHIJhxL3kwdQAQhiABEIkgJPRMIYCgyiBhEEwhAJAA2coh4gDAKSIDuHEEJIEP////wkAu +wwJleUAvAwJleUAogxJleQUhQQEEIb6PAAAAPCC3BPSLuSC3J4IPe3B1hiH/DiK5NvRMIUCgFfTP +c4AAXD9si4Yj/wFDu4Yjfw+C4wHbwHsvJsfwAdvCI8EAZXkF8EwhgKDKIWEABCCAD////8IKI0CC +QC7NAgV9QC8AAsojYgCleAq5DbsleAV7BCO+jwAAADxweGC2BPSLuAC2TCcAgM9zoAD8RAv0LYME +IYEP////w4q5i7mMuQvwrYMEIIEPAAAAPAQljR/////DpXktowIQgSCB4Qb0AdkoogDZKaIEIIAP +AAAAPCq4CqKtAQ/98cBSCQ/9z3eAABQaH4+F4Ar0IBeAEIHgsAkhAMogIQAA2H7wz3aAAOI6AJYP +eYLhCvSGIMMPALaKIBMHAtmuCyAFnLnPdYAA4DoglS94guAK9IYhww8gtYogEweOCyAFAtkglc9y +oADAHQeCYJZEIAUBLybH8EEthQAB2BP0BCODD////8JPIwQCQC2FAgUlAwEEI76PAAAAPGC2A/SL +u2C2Z4IvfoDmhiP/DiK7JPTPdoAAXD/MjgQhgQ/////CiLmGJv8RQ76GJn8fguYB3sB+LyaH8wHe +wiaBE8V7CrslewQjvo8AAAA8cHlgtQT0i7kgtc9zoAD8RK2DBCGBDwAAADwEJY0f////wyV9Krmt +oyqiANkoogmiKHAfr50AL/0gHwIQ4HjxwBoID/1IdhpzCiMAIQohQCEKIoAhz3WAABQaHa0+rYDg +Ad9BhQ/y6a3qrUYiQgKG4AHbwHshHcIQh+AB28B7CPAA22mtaq1FIkICIR3CE4DhKB3CEAfy6K3r +rUYiggEG8ADZKK0rrUUiggFCIACAQaUGDO//yiBiAMOlxaUQHQAUGB0AFCQdRBQmHUQUIh2CFCMd +ghTdB+/8HB3CFOB48cCGD8/8GnDPdYAAFBoBhYO4AaXPdoAA4joAli8mB/AL9EUgwAAAts9xABED +APYJIAWKIBMHz3CAAOA6AJAvJgfwDvRFIMEAz3CAAOA6ILCKIBMHA9nOCSAFmLnPd6AAyB+FFwCW +hiD/DkEogQAAlg96g+IQ9AQggA/////CCrkleAQhgQ8AAAA8gOEAtgT0i7gAtoUXAZbPcIAA4DoA +kIYh/w4PeoPiIrkY9AQggg/////CCrklelB4BCGBDwAAADyA4c9zgADgOkCzBvSLuM9xgADgOgCx +z3KgAPxELYIEIIAPAAAAPCq4BCGBD////8OKuYu5jLktoogfGJAdjYfgzCCigQXyAdghHQIQCY1M +IECgCq0A2AmtK/TPdYAAOCEAhQHggeAApQf0AdhRHxiQ5g5AEc9wgAAcPQCIz3GgAOwngeAB2MB4 +B7hFIAAGELiFIJEABqH+CC/9AdgAhUIgQIAApQX0ANhRHxiQiiCTBgDZrgggBZm5cQbP/OB48cAK +Ds/8z3WAABQaHY2H4MwgooF88gWFz3aAAOI6A6UGhQSlE5UStSMVgBAiHQIQAJYPeYPhC/SGIMMP +ALaKIBMHA9leCCAFnLnPd4AA4DoAlw95g+EK9IYgww8At4ogEwdCCCAFA9nPcaAAwB0HgQDaRCAF +AWCWQS2FAA/YLybH8Aq4EfQEI4MP////wk8jBAJALYUCBSUDAQsjAIBgtgP0i7tgtieBYJeGIf8O +b36A5iK5D/QEI4MP////woi7CrlleQshAIAweyC3A/SLu2C3z3CgAPxELYAEI4MPAAAAPAQhgQ// +///DZXktoAGFo7gBpQmNIR2CEADZCq0B2AmtiiCTBp4P4ASYuWUFz/zxwOHFAN3PcIAAFBqhoDoJ +7/+pcM9wgADgOgCQz3GgAMAdBCCADwAAADwquAqhBYGloQWBBaE9Bc/84HjxwMIMz/zPc4AAFBoh +E4IAgOIS8igTgQCA4Q7yHROEAAohwA/rcoogRw+KI4cBAQMv/rhzgOJx9CgTgQCA4dAgogN09M9x +gADiOiCJgOFM9EEowgLAus9zoADAHaeDz3aAAOA6IJaGJf8eLyZH8Ft6Ir0q9IHiFfTPcoAAXD9M +ioYi/wFDuoYifw+C4gHawHovJofwAdrCIoEARX0E8ILiyiVhEAQhgQ/////CCr2IuSV9BCW+nwAA +ADyweaC2BPSLuSC2z3WgAPxETYUEIYEPAAAAPAQigg/////DJXpNpSq5KqPPcqAAyB/sEgGA7rkV +9IsSAYaA4RHyz3GAAOA6IJEEIYEPAAAAKNdxAAAAKAr067gK9I64CPDsEgGAUSEAgATyq7j58QUE +z/zxwJILz/zPcoAAFBoBgoYgv4149ADZkrkgohIO4ASKINMGz3WAAOI6AJUPeYHhC/SGIMMPALWK +IBMHAdnuDeAEnLnPdqAAwB0Hhs9ygADgOiCShiD/Di8mR/AA2yK4JPTPd4AAXD/sjwQhgQ/////C +hif/EUO/hid/H4LnAd/Afy8mx/MB38InwRPleAq4BSEPAPB54LIP3wq/CyDAgwT0i7kgss9woAD8 +RO2ABCePH////8OKv4u/jL/toAeGhiD/DkEohAAAlQ/aD3+A5wq6D/QEIIAP////woi4QCyPAuV4 +CyCAgAC1A/SLuAC1aKYC2AmmBCGBDwAAADwquSqm+QLP/OB+4HjgfuB44H7geOB+4HjxwH4K7/wk +2qnBi3XPcYAAEGoyC+/8qXDPd4AAzDAIF4GQz3CAAF4vRCk+CzIgQA7PdoAA0C5RIMCBURYAFh/y +geAu8mIIIAAA2KIIAAAOD0ARAdhAwIHB2twCJwATOgkgDiDaqXAk2bzaHtvWC2ANGLsB2FEeGBAS +8IDgEPKeD+AJVBYAFgDfQMepcCTZvNoe27ILYA0Yu1Ee2BNJAu/8qcDgeAzaz3GAAMwwAuAPeCcZ +AoAA2CgZAoALEYCAJhmCgAgRgoApGQKAAeAPeAsZAoDPcIAAXi9EKj4LMiBADuB/KhkCgOB43djP +cYAA6C8EqQuJB+APeAWpUNgGqW/YB6ma2AipCdjgfwmp8cBuCe/8JNqtwc9xgABIayYK7/yEwM9y +gAA4JgiKh+B8AgIAz3eAAMwwCBeBkAoXg5DPdYAAXC9AJZARA21EKT4LJ3V1fWaNz3aAANAugeNM +AgIAbJLPcoAA8CJeklBzCPRAhgQivo8AADgQLAIBAADdqXIL8EQpPgsAIYN/gABIL1V7bJMB4n1l +RCk+CzIgRA6QcrH3TCSAgMohwg/KIsIHyiCCDwAA2hvKI4IPAADEADAH4v3KJSIAeg2AAz4NoAOY +cAIgAAEghkq447nRISGDUfKA4MQBDAAQdQDZAxxCMAn3ongQdQHhL3n89wMcQjCA4MT2AeEDHEIw +CBeAkAq9RCg+CzIgQS4vcMdwgABIL4DhyiFiADV4DJAKuEHAz3CAAKxhAoBCxelxgiFDBUPAQCTA +MFYP4A0N2l4O7/8N2J4Oz/8KDUARAdhEwIXB2twCJwATNg/gDSDahMAk2bzaHtvSCWANGLsC2FEe +GBCW8ALZz3CgALAfOaBRFgEWg+EIF4CQuHAn9EQoPgsvcDIgASDHcIAASC8KIkCAyiJiABUggwCk +FgIXbJNQcxX0geEB2cIhQQA1eKUWARdMkDByz3CAAEghB/QNgACAUxYBFhBxZPL/2AMcAjBELT4L +MiBBLi9wx3CAAEgvCr2A4cohYgA1eAyQCrhBwM9wgABIIQmAQsUggAAhAAFDwOlxQCTAMIIhQwVy +DuANDdp+De//Ddi6Dc//JgxAEQHYRMCFwdrcAicAE1IO4A0g2oTAJNm82h7b8ghgDRi7A9hRHhgQ +CBeAkEQoPgsyIEIuL3DHcIAASC8KI4CAyiNiABUgwQAskYHipB5cEAHZwiFBADV4DJClHhwQz3CA +AEghDYAAgFMeGBAE8F4Mz/81B6/8rcDgePHAzg6P/JgQAgAEIoEPAAAACDt5BCKDDwAAABAle89x +gADwIqSB6bpWJU4UViUPFZgQgQAI8oYh/wNEuS9nib/pcRnwUSIAgrwVAhEM8sK5gCUCGT9l6I89 +ZTCNZX/wf0V5CfDDuTx5P2Y+ZjCO6I9FeYgYwANleb0Gr/yMGEAA8cDhxQPIpBABAJgQAgBRIQCA +chABAUhwBvJ6DmACANoIdQfwAeFuDmACANqsaP4NQA/PcqAAyB/4EgEAA8jPc4AAEN8QiAK4FngA +Y+24z3CAAEghCPQB23OiSIBAggyAYIAI8ALbc6JJgECCDYBggAIlQBBYYBBywCNtAA1xAKENcGCg +ABYAQAAWAEADyM9yoAD0B3AQAQFouSeicBABAWi5MHkhBq/8cBhEAPHAog2P/M92oADIH6AWBBD4 +FgMQhOAA3yL0AxIBNqQRAAD0uHYRAgEG8s9wgAD456GABPCCEQ0BDcxRIACBhBEAAQnyAiXBEAIk +QwAIIwMABPCGEQMBG2NocXHwgeBK9A0SATcDyOS5eBACASHyUSFAgM9xgADwIiSBVBEBAQnyfhAN +ASJ9Yn0CJEMDK/CAEAMBz3WAAPDdACNEAHCIdn1glQAjDQGEEAMBu2Mb8KQQAQD0uQjycIjPcYAA +8N12eWCRBPCCEAMBz3GAAPAiJIGAEA0BVBEBAT1lu2OEEA0Bu2OAEA0BuWF+EA0BQn0n8ILgIfQD +Eg02Dcx4FQIRUSAAgc9wgADwIgSAVBABAQnygBUAESJ4YngCJAMAB/CCFQMRhBUAETtjG2OAFQ0R +Qn0F8Olz6XLpdelxDcxRIECAB/IDyHYQAgFiujpiC/CA42K6yfbPcIAA8CIEgEYQAAEaYvgWABBd +ZQJ9H4YQdYv3oNgPpv+mX6YC2BUeGJCA2A6miQSv/HB48cAaDI/8z3GAAPAi8CECAFYiRQQIglYi +BAVRIMCAiiAIAMogIQC8GgQASiQAcgDZqCCAD891gACAcPyKLmXkfi8ogQNOIIMHz3CAAGhyb2AA +JUMA4KtEEo8A5H4vLoETTiaPF+5gyKvIglEmwJAP8h2KhuHTIKYALygBAE4gjQfPcIAApG6oYBDw +z3aAAKhwLmbOZbyKxH1YEo4AxH0vLUETTiWOF8hgEKsB4UokAHIA26gggQDcis9xgABEcm9hz3WA +AGhy5H4vKIEDTiCPB+9lACXAAPyoRBKPAOR+Ly6BE04mjxfuZSQYggPIglEmwJAP8j2KgOPTIaEA +LylBAE4hjQfPcYAApG6pYRHwgOMD8slrAvBods5hPIrEeVgSjgDEeS8pQQBOIY4HyWUsGEIAAeNK +JABxANioIEAFz3GAAKBufYoJYQAkDAAB4GR5LylBAE4hgwfPcYAApG5pYSCsIQOP/OB44cXhxs9z +pAC0RSkTAIbPcYAAFEDIGQAAKxMAhswZAADPcKUACAwDgOQZAAAOEwCGEHowuNQZAADQGYAADxMA +htgZAADPcIAAkMvUiLaI6BmAA3iI7BlAAw2Q8BnAACzgAiCCA/QZgAACIEIDYnj4GYAA/BkAAMHG +4H/Bxc9wgAB8YgaAA4AggM9wgADcn+B/KaDgeOHF4caYcM9ygABQGgWCIIJmgsq4ELjKuQUhAYAB +gsq7ELvKuAUjBQBnggKCyrsQu8q4BSMHAGiCA4LKu8q4ELsFIwYAJPIAFA4ALyhBAE4ggwcA2A8g +wAASfQQgQwGkfmV+AByAA9qCpH7Fe3qieYIEII4BBCDAAaR7xXt5oniCpHsEIUGDZXgYot/1wcbg +f8HF4HjxwIIJj/w6cAWBoIHKuBC4yr0FJQ2QAYEmgcq4yrkQuQUhEAAB3hvyBCWAkxTyLygBAE4g +ggfwIYEggOEA3w8njxAJ8gQnABRCIACAYHnKIGIA5n2A5dt+6PWJAY/84HjgfwDYocHxwB4Jj/yj +wQh1SMDPdoAAUBoahvuGPIYEfyR/p39Bx54LoASKINgEiiDYBJILoASpcYDnF/SA5Wz07glgBQrY +gOBm8gohwA/rcs9wAACNE4ojRwBKJAAAPQev/QolAAEEFAExgOEZ8iAUADELIECADfLPcIAAnC5g +gM9xAAAEcAzYYHsD2gnwgOAH9M9wgACYLiCAYHkM2AYUATGA4RnyIhQAMQsgQIAN8s9wgACcLmCA +z3EAAARwDdhgewTaCfCA4Af0z3CAAJguIIBgeQ3YBCdQkwvyvghv/wrYiiAYCN4KoAQKcRPwgOUR +9Iog2ATOCqAEiiFHC2YPL/8K2IogGAS6CqAE6XFiCAAAvKYI3HcAr/yjwPHADgiP/Ah2AN2KINgD +mgqgBMlxz3CAAFAaWoA7gER5ANoPIoIDBCJDAEIjA4DKI2IALybH8AHfyiBBAwfyHIAkeKoO7/9F +eOlwLQCP/OB48cDhxaHBAdhAwM91gABQGgqFUSAAgAzyi3AE2WfaPdtiCSANF7sKhaC4CqUJAK/8 +ocDgePHAhg9P/BpwKHVId2h2OGNm2T3apgkgDRe6geAJ9ApwfgkgDalx6XBOCSANyXG9B0/84Hjx +wFIPT/ymwSh1GnJgwADYARwCMAHYAhwCMAMcAjCLcNIPYAiBwYDlBfIEwQpwYH0FwgPBgOEO9Aoh +wA/rcs9wAACME+7biiTDD30Fr/24c2B5ANhhB2/8psDgePHA8g5P/KLBAd7PdYAAUBo6hRuFJHg8 +hQQhEAB2CaAEiiCYA0wgAKAy8gPw234EIICj/vMvKAEATiCRBxUlThQdhlwdQBSA4MohwQ/KIsEH +yiCBDwAAjxPKI4EPAAAcAsokAQQEBaH9yiVBBA4Mj/8dhkB4KgtP/4ogmAMWCaAEKnEA2A8gQAQG +IBAgSg3v/wpwiiCYA/4IoAQ8hbUGb/yiwOB44H7geADZz3CAALQy4H84oOB+4HjxwMoPAATPcAEA +8IGA4Aryz3GAAFAauBkAABuBkbgboc9wAQAkgYDgCPLPcYAAUBoeoRuBgbgboc9wAADYcoDgCfLP +cYAAUBqUGQAAG4GIuBuhz3AAANxygOAK8s9xgABQGpgZAAAbgYm4G6HPcAAA6HKA4Anyz3GAAFAa +nBkAABuBirgboc9wAQCgiYDgCvLPcYAAUBrYGQAAG4GZuBuh0cDgfvHA4cWhwc9ygAC8ss91gABQ +GheFANkPIQEAGIUkeEIgAIDKIGIAgeAB2wDZD/QI2GDAARxCMAIcwjADHMIwi3AE2dYN7/+KIwgA +CNgA2f4N7/8ocgDYwQVv/KHA8cA6DW/8CNnPcq3e775KDyACOnA+CGAAKnCD4Ejyz3CAANyfA5BO +IM8Bh+dQAAYAz3CAAIQQWg5gAPQgwAMA3gDdBNgacCpw6XHJcgokgA+t3u++Ag8gAqlzUghgACpw +g+Am8kIgQCCA4AHlLPcB5oLmqPcB54fnuAfF/ypwz3Kt3u++0g4gAhDZyg8gACpwg+AO8s9xrd7v +vr4OIAIqcAYP7/8qcIPgyiAiAO0ET/zxwI4Mb/wD2qbBGnByDKANg8EDwc9wgADQERQUBzAA3vAg +RQDPcIAA2BHwIEYAz3WAAPgKDtjEpUDABNhBwM9wrd7vvkLABMIKcIDbWg4gAphz0gkgAApwg+BA +8gPDz3CAAPARQoXwIMEAwKWA4QwVEBDBpQjyz3eAAPgR8CfAEIDgBvTApcGlANkZ8IQqDAMmCWAA +L3AOIIEPAAAAASClA8CEKAwj8CcBEA4JYAAvcA4ggQ8AAAABIaUEhYHgDfQAhRF4jCAHjcL3wKUx +eYwhB43D98GlANgZBG/8psDgePHAsgtv/ATapsGWC6ANi3HPcAAAG9IA3alxGg1gAKlyAMHPcAAA +HNIKDWAAqXIAwc9wgAAwEAHCFSBBAACRAsEFut4NYABFeQPAgODcAAUAz3aAAPgK0tgIuBnZ1gxg +AADaz3AAACLSQCYBEv4KYAAE2s9wAAAj0kAmARPuCmAAANrPcAAAINKEweIKYAAA2oXHz3AAACHS +6XHSCmAAANoChhfZ7g4gDUAmAhIDhhfZ4g4gDUAmAhMEwBfZ1g4gDYTCBcAX2c4OIA3pcgKGANkG +CGAAi7kCpgOGANn6DyAAi7kDpgTAANkIuO4PIACLuQh3BcAA2Qi43g8gAIu5IoYxeRnhBSl+ACOG +L3JQdzF5GeEFKX4AL3HMIEWAhvcDwAHlEHUyB87/A8AQdcb3AdnPcIAA+AokoADY4QJv/KbA8cB2 +Cm/8CdqpwQh2UgqgDYtxOgiv/CHACHFC2MIMYAAFuQwUBDAAwclwBsIKJYAPrd7vvlIMIAICwx4P +IADJcIPgKvIAwQXCz3CAAHgQAN3wIEAABMEKugQigg8PAAD8yblFeY4LYACpcpYK4BAF2CAUBDAA +wclwBsIKJYAPrd7vvgYMIAIHwzoO7//JcIPgyiBCA00Cb/ypwOB48cC2CW/8AtqnwZpwtgmgDYPB +z3CAAGxrAIAA2UXAz3AAABHSMgtgAChyz3AAABLSANkmC2AAKHLPcAAAE9IA2RYLYAAocs9wAAAU +0gDZCgtgAChyz3AAAAFEB9n6CmAAANrPcKAAtA9wEBcANgkgDQHY8gngEAXYvNjKC2AAANnD2MIL +YAAA2YogRAi2C2AAANmKIAQKrgtgAADZJcW12KILYACpcYoghAaaC2AAqXED2EDABN5Bxs93rd7v +vkLHinAEwQPCHtuYc0olAABKJgAAGgsgAkonAACODu//inCD4CwCAQDPdYAA+AoIFRYQDBUSEA7Y +QMBBxkLHinAEwQPCHtuYc0olAABKJgAA3gogAkonAABSDu//inCD4PABAQAIFRUQDBUQEA7YQMBB +xkLHinAEwQPC4duYc0olAABKJgAApgogAkonAAAaDu//inCD4NzyCBUREAwVExAD2EDAQcZCx4pw +BMEDwuHbmHNKJQAASiYAAHIKIAJKJwAA5g3v/4pwg+DC8sKFo4UWCCANLyDHBQTBz3KAAPARAiFA +pc9zgADgETV6AKICIwAkz3KAAPgRNXoAosPaNXtAo89zgADoETV7QKM/9M9woACwHwGAhiD/AYDg +AdjAeC8mB/AT9M9woAD8RHQQBABkEAUACiHAD+tyz3AAALETSQZv/YojCQpCC8ADCiHAD4Dg63IQ +8s9woAD8RHQQBABkEAUAz3AAALETHQZv/YojSQrPcAAArROKI4kKSiQAAAkGb/0KJQABgOA59M9w +oACwHwGAhiD/AYDgAdjAeC8mB/AS9M9woAD8RHQQBABkEAUACiHAD+tyz3AAALETyQVv/YojSQzC +CsADCiHAD4Dg63IP8s9woAD8RHQQBABkEAUAz3AAALEToQVv/YojiQzPcAAArhOKI8kMwfECJYAl +2WACIUGED/ICJUIkDHouDCAAL3AEwgIlASDPcIAA0BFVeCCgAiCAJLlgAiHBhA/yAiDCJAx6Bgwg +AC9wBMICIAEgz3CAANgRVXggoADY8QYv/KfA4HjxwBoOIAAA2M9wAAAN0gDZMghgAADaz3AAAAzS +ANkmCGAAANrPcAAAFdLPcfMP//wSCGAAANrPcAAAG9IA2QYIYAAA2s9wAAAC0qDZmrn2DyAAANoJ +2Iy4ANnqDyAAANoU2Iy4/9neDyAAANoA2Iy4/9nSDyAAANoR2Iy4/9nGDyAAANoC2I64ANm6DyAA +ANoB2I64z3EAAP//qg8gAADaz3AAAAvSANmaDyAAANrPcAAADdIB2Y4PIAAA2s9wAAAS0gDZfg8g +AADaz3AAABPSANlyDyAAANrPcAAAFNIA2WIPIAAA2gDY0cDgfvHA2g0P/KTBi3EB3bYNYA2pcs9w +gABMagCAQcAE2CYIYAAs2Q7YHghgAADZIca12BIIYADJcYoghAYKCGAAyXGKIEYA/g8gAMlxAMCA +4MwgooDMIOKAzCBigcwgooHMICKCzCBigswg4oLKIUIDA/QD2YHgzCCigMwg4oDMIKKBzCDigcwg +IoLMIKKCzCDiggDdBfSBuS95gN2E4MwgYoHMIKKBzCDigcwgIoLMIGKCzCCigswg4oID9IO5L3mG +DyAAD9iDwcINIAAR2APBg72leUPBbg8gABHYANhpBS/8pMDgePHA4cWhwYtx1gxgDQHaz3WAAOyh +ABQEMM9wgADQD1YlARIS2uoNIAAA2wAUBDDPcIAAzA+pcQHa1g0gAALbz3CAAPQPJG0d2t4NIAAA +wwDYGQUv/KHA4HjxwIIML/wD2qPBunB6DGANi3EBwc9wgACAEADf9CBOAALBz3CAAJQQgOb0IFQA +z3CAAPgK4KDhoMwmopDMJmKRzCaikcolwhMC9ADdgebMJuKQzCbikcwmIpID9AHdhObMJmKSzCai +kswm4pIC9ALdag3P/6pwz3Kt3u++Mg7gAclxRg7v/6pwg+B28gDAgODMIKKBUPSA5swmYpDMJiKR +SvQCwIDgSPTPcIAA0BG1eFpw4KDPcIAA2BG1eHpw4KDPcIAA8BG1eBpw4KDPcIAA+BG1eDpw4KDP +cIAA4BG1eOCgz3CAAOgRtXjgoKpwyXHPc63e7766DeABqXLKCe//qnCD4DjyAMEAEgAghuEB2cB5 +A7m1ecdxgAC8sgChABMAIAShABAAIBt4CKEAEQAgG3gMoapwqXHJcgokgA+t3u++bg3gAYpzwg6v +/6pwg+AS8gDAz3GAAPgKQIEEvga42GAVIAAFx3CAAPiyIYFCsCOwANhdAy/8o8DgePHApMGLcQYL +YA0E2gDAAcEEuDV4z3GAADgQEGFuDSAAAsEAwAHBBLg1eM9xgABYEBBhWg0gAAPBANikwNHA4H7x +wKHBZghgAotyAMChwNHA4H7geKHB4cXhxrhwz3CAAMy7EBAGAM9wgAA4MgWAmHGA4KHBhiT3D3Py +z3CAACRjAIDQcA30z3CAACxjAICwcAf0z3CAAChjAICQcGHyABxAMSDCARSBMPDeUyLAAMR6UyHH +ACR+VHpALo0BtH26YhV6z3GAALy0SGHUfghzhiP9D3t7OmJBimV4SHOGI/0Pe3vdZRUlzRG+YcKO +ZXrJc4Yj/Q97e7lhI4llfihzhiP9D0wkAIB7e2V5E/LPdaoA4AdzhVEjAIAG8kilCaUqpculEPAI +pUmlyqUrpQrwCbpFeM9ypwAUSAOiCbklfsSiz3GAACRjABmAAc9wgAAsYwAYQAHPcIAAKGMAGAAB +ocDBxsHF4H+hwPHAtgkP/DoOgAOA4CgPwQIA3hfwcNwCJQATRC4+Fy93igxgDidwQiUAHoIMYA74 +YADZACaAH4AAOjAgqAHmz3WAAMwwaxWAkBB2pvfPcIAAWGFaDEAOz3GAANAuAIGhuK64vQEv/ACh +8cDPcQCCAQDPcKAArC88oM9wgAAUPQCAgOAM9M9wgABQHACAguAG8rYMgAPRwOB+cg1AAEIP4AVv +2IDgB/SeCaAQCtheDUAA8vHy8c9ygAAUPSCCBnngfyCi4HjPcoAAFD0ggiV44H8AouB4BCiADwAA +L7pCKcJ0UHpEKv4CAiBADhB4gOAE8gHiUHqD4ECxA/aA4AP0ANgC8IDY4H7geF0Hj/3xwKIID/w6 +cM91gAA4IQCFAeCB4AClCvQB2c9woADIHDGgFgmgEChwYgygBQfYGnDPdqAA7CfrhlYP4AcqcAum +AIVCIECAAKUG9M9xoADIHADYEaE2CaAFCnCpAC/86XDxwD4ID/w6cCh1GnIeDKAFB9hRIICgWnAG +8nIOoAjI2FAgkCBMIICgHPIL9kwgAKAS8kwgQKAj9BXYE7gO8EwgAKQT8kwgAKgZ9FoJoAQqcACl +EPAp2BK48CBABAClCvAr2BK4+vHPcKAA7CcZgAClugigBUpwJQAP/AohwA/rcs9wAACKE3vbCiRA +BC0GL/0KJQAE8cCuD8/7CHc6cYDiGnMA3s33SHX0J4ATFSGBI1IP7/8KcmG9gOUB5jb35QfP++B4 +8cCCD8/7ocEId4DiGnEA3s/3SHX0J4ATHgggAItxAMAUIIwjYb2A5QC0AeY097kH7/uhwPHATg/P ++6HBGnDPdoAAOCEAhgHggeAodQCmCvQB2c9woADIHDGgug9gEChwBgugBQfYCHduDaADs9iA4BXy +i3FODu/8CnAAFAAxAKUAhkIgQIAApgb0ANnPcKAAyBwxoNIPYAXpcE0H7/uhwFEkwIDxwAXyKg/P +/wPw6ggAANHA4H7geFEjwIDxwAXyQg/P/wPwAgkAANHA4H7gePHAtg7P+wh1juAB3sImjRPPcKAA +tA/8gGoOoAwA2MlwqXEB2o4KoAVIc1oOoAzveO0Gz/vxwHYOz/s6cCh1GnJWCqAFB9hMIICgWnAf +8g72TCAAoBXyTCBAoCj0FdgTuBUgQASgoB3wTCAApBXyTCAAqBz0KnAKCKAEqXER8CnYErgVIEAE +oKAL8CvYErgVIEAEoKAF8M9woADsJ7mg+g5gBUpwYQbP+wohwA/rcs9wAACJE0rbCiRABG0EL/0K +JQAE4HjxwOoNz/sIdzpxgOIacwDezfdIdfQngBPwIYEjVg/v/wpyYb2A5QHmNvchBs/74HjxwL4N +z/sId4DiGnEA3s33SHX0J4ATGgggAPQggSNhvYDlAeY39/0Fz/vgePHAjg3P+xpwz3aAADghAIYB +4IHgKHUApgn0AdnPcKAAyBwxoP4NYBAocE4JoAUH2DpwtgugA5PYgOAZ8rB9QCiPIYG/EL2lf89w +oADsJ+agAIZCIECAANkApgb0z3CgAMgcMaASDmAFKnCFBc/74HjPcYAA8CIjgc9ygACsCjIhgw8A +AB8DAaIyIYEPAAAZA2GySHAgsgjZc9oe270GYAwYu+B48cDPcIAA8CIDgAmAUSBAgcogYgDsDaL+ +yiEiAM9xgACUCYogjAxmD+ADIJH+CO/9AdjRwOB+4HjxwLYMz/vPdYAAzLsihY3hz3asAJABBfQY +jYDgBvSL4Tz0GI2A4Dr064YwFhAQz3CAALguIIBgeQLYgOAihR70jeGnvwb0RiDAI0UgAAMT8M9w +gACwLiCAYHkA2JHgB/RGIMAjRSCAAwXwRiDAI0UggALrpgymFvCN4dAn4RHl889wgACwLiCAYHkA +2JHg0CfhEejzh7/Z8QXYDKag2AumeQTP+/HAGgzP+wh1KHYghUIhAYDKIWIAgOEA2AXy8g4gDqlw +AdgkhYDm0CFiAM8hIgDQISEAzyFhAIDgJKUoDiIOyiBCA0UEz/vgePHA0gvv+4oiBA7PcIAAaAkA +gM92gADUqiaAQCYAFMoKIA0E4QGGz3WAAPAiIobIHRgQz3KAABwmyR1YECGWJ6ogjgQggA8ABgAA +gOAB2MB4IaoGqgDedgmgCslwz3CAAEch5guv/sCo/gmAA4DgCvKCCoADgOAG9I4Pr/3JcCrwz3CA +AEghJIAggd4N4AOKIEwMiiCTAdIN4AOp2QLYng2gAQHZFg8gEALYI4VIgTSRUyIAAG4M4AoB24og +jA6qDeADs9kA2Z65z3CAAPApIKBtA8/78cCw4OHFCHWD9rnlzPYKIcAP63LPcAAAmiEi25h1TQEv +/bhzQiUAHEkD7/sPeOB48cDKCu/7mHBBgeS6sIk78nKJz3aAABDf8m32f+ZmNMr2vggRhQBJIMAA +CPLPdoAAUOG2fsGOA/AA3sdwgABQ4bZ4BIgIIwMACCODAwAjQAFJIMMDFm11eM9zgADQ4gNjz3CA +AFDitnjPdYAA8CKkhbiFAYCleAQggA8AAAAIBnsC8GOB6LuYGcAAAN0J8qQRAAAA3Ze9kbiUuKQZ +AABRJACAHPLPcIAA8CLEgMC6yIYEJo4fAEAAAD6+HubYekV7/ruYGcAADfKkEQAAhSUBFIy4kbik +GQAAnBlAAx3w/7sS8qQRAgCFJQEUlr2YvY26kbqkGYAAnBlAAySAEIGeuBChC/CUvZa9nBlAAySA +EIGeuJ+4EKEdAs/74HjxwKoJ7/sD2M92gACwLiCGQHmA4G3yIIZgeQTYgOBp8iCGYHkA2Ge4i+AK +9zMmAHCAADBoQCcBchR5AHkA2ELwz3CAALguIIBgeQHYgOAB2MB4OPDPdYAAuC4ghWB5AdiB4BHy +IIVgeQHYg+AL8iCFYHkB2ILgB/IghWB5AdiB4N71Adge8M9wgAC4LiCAYHkB2IXgAdjAeBTwz3CA +ALguIIBgeQHYgeAB2MB4CvDPcIAAuC4ggGB5AdiD4AHYwHiB4BfyIIbrdWB5ANgacM9wgAC4LiCA +YHkB2LhwN9gKIcAPqXKU2zkH7/wKJAAEIQHP++B48cC6CM/7z3WAABCxIBWAEIHgz3aAAJwJCfQA +32oIoAzpcALYA6bkpgPwAdgFpoogzAgiC+ADKIXpAM/7z3CAABCxKIDPcoAAnAkveIHgBfQC2ASi +A/AB2AWi+QLgA4ogzAjgePHAVgjP+891gADwCgCFgeAO8gohwA/rcs9wAACHJ4ojRAZKJAAAoQbv +/Lhzz3aAAOwKQIaC4swi4oHKIcIPyiCCDwAAiCfKI4IPAAAaAcoiwgfp9YLiOPTPcYAAtgpgic9x +gABSzYQrHwAyIUEOUSEAgAnyz3GAABCxIBGBAIHhD/QYuhC4BSCBAIUhDABiCuADiiCLAAPYAKYA +30PwUgrgA4ogywgghgCFGLkQuAV5hSGIADoK4AOKIIsAAtgApgClMvDPcYAAELEgEYEAgeEA3yz0 +z3GAALYKYInPcYAAYM0YuoQrHwAwIUEOgOEQuAV6CfLPcIAAuAoAgIYgOY8J8k8iAQLqCeADiiCL +AAHYxPFPIsEC2gngA4ogiwAI2ACm4KWZB4/7iiBLCsIJ4ANIcc9xgAC4CoogSwmyCeADIIEAhkCF +GLgQugV62/HgeM9wgAAorCiAz3KAAJwJL3iB4AX0BNgEogPwAdgFooEB4AOKIMwI4HjxwN4Oj/vP +cIAAjBUKgIDgD/LPcp8AuP8dos9xgAAgIQSBAeCzuLW4uLgEoRaiz3CAAOwKABAEAM92gADwCgAW +BRBMJACBzCVhgMoiwgfKIIIPAACJJ8ojgg8AAFMB8ATi/Mohwg/PdYAAxAoAhQDZz3eAACzNDyEB +AM9wgADACkCAJnogF4EQgeFAoBH0QCwBBkAtAAQleEAsAQIFeYogiwDWCOADRSFBAQXYI/DC4c9y +gABoPQmCDPKMIcKBB/KMIYKCBvKAuAbwRSDAAATwRSBAAQmiQCwABkAtAQQFeUAsAAIFeYogiwCO +COADgbkC2ACmiiBLBH4I4AMghYogSwR2COADKIfPcIAAICEAgFEggIIG8gDZz3CfALj/PaAlBo/7 +gOAA2soggQAR8s9yoACwHwHbeaLPcoAASCFIgmCCAiNCAHBxwiJtAEJ44H4NyMdwgAAgyjSIAeEv +eYThNKgDEgI2jPbPcAMAhACgGgAAiiAIAAYaGDAL8IogEAAGGhgwz3ACAYQAoBoAAIogBADlB6AD +ANnPc6AAsB8B2lmjz3OAAEghaIOA4GCDBfIie3Bwg/cA2ALwSHDgfuB4z3KgACwgcIKA4AryAiNC +ANdyAIAAAAb3UHCG9wDYBfBwcH73AdjgfvHA9gyv+5hwpcEod7hzAN4EI4AP/wAAABi6BXpveQi5 +/9gIuGR4KLgFeUV5CN30JIADJ3hEwBIOIA4QFAAxEhQCMWG9QCgBBAV5R3lEwRAUAjEUJIAzgOVA +sAHmKfdTJcIFQKcAFA0BB9kH8BB9FCdMEAC0YbkUJEAwu3tPvQCQpXuB4XB7eGAy9wQggA8AAAD/ +ELgFekCnxQSv+6XA4HjxwDYIAADeCAAA8ggAANHA4H7geM9xgABsKUAhAANVIcIFUHBG9wDZBBhQ +AFBwvffgfuB48cACCKAHANjWD6/8ANjPcIAA+GGuCM/8z3CAANhhpgjP/G4PD/6+DIAJANjqDiAD +gNkeDcANXgjAAmYPAA6aCsAB0gsAAwDY6gxv/ghxUgnP/jIJgAw+DAADogygAf/YJgmAAYoghQ8I +cUYLIAYIctHA4H7xwLILr/uKIP8Pz3WgADgux4UHpc9woABULguA07gGJgBwDwD//1INYA8W2ZoK +AALHpe0Dj/vgePHAVg9gBwHYKg+v/AHYmgtAENHA4H7gePHA4cUA3c9wgAA4CqCgz3CAAOyirLAm +DiAOqXCmDY/8VghgDalwjg1ABMoKT/2WCIABiiAGCghxsgogBghyig3v+6lwVg3P+40Dj/sA2c9w +oADsJyug4H7xwM9wgACoGSoOYA8T2doLAAEC2A4Mb/4A2dHA4H7gePHAz3CAAPgZCg5gDwTZugsA +AQHY7gtv/gDZ0cDgfuB48cChwYtw7g1gDwHZmgsAAYogUwdKDaADIMGKIFMIQg2gAwEUgTAgwIHg +AdjCIAEAB+CyC2/+ARSBMKHA0cDgfvHAocGLcHINYA8E2QDAUSBAgPQLogfKIKIAAMBRIICA5AoC +DQDAUSDAgAgNwgcAwFEgAIHcCcIHCgxgDgHYz3GAruAB7HAgoAHI7HEAoc9ygAAUoIokgX0A2agg +AALwIkMA7HBgoAHhQgsgAQDYocDRwOB+8cDhxaPBAdhAwM91gABQGqlw8gxgD1zZeg+P/jqFG4Uk +eDyFBHmBwM4P7/5BwQHAO4UEeUHBdgygA4ogWARVJUAfSggv/6lxz3CAAMgbPggv/0AlARuLcJIJ +IAEE2ZIIL/8BwACFgOAF9AWFgODoCQH/Rg5P/hUCr/ujwPHA4cXPcIAAlGkAgKLBQcCBwAHdrgxg +D6lxiiAXChIMoAMBEgE2IcKKIBcKBRSBMBC6/gugA0V5QMWLcDIJIAEE2c0Br/uiwPHAocGLcHYM +YA8B2QDAUSDAgS8kBwAAHAAxDPIHEgU2CiHAD+tyiiDFAJUHr/wn24ogFwqyC6ADARIBNiYI4AFA +2O4JAAHiCEAIocDRwOB+8cACCY/7z3WAAPggAoUjhQHeEHHAfqlwEgxgDwPZwgkAAYDmA/IChQLw +AIVBAa/7A6XgeOB+4HjxwOHFz3WAABAhqXCqC2APENkAFQQQTCRAgBHyTCTAgB/yTCQAgRPyCiHA +D+tyj9iNuJjbAQev/LhzAYUMuAQggA8BAADwAaUL8CGFz3CAANg8IKAjhc9wgAC6FyCoA8zXcAAA +AEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoGYJIAEB2LEAj/vxwOHFANnPcoAAICEg +oiGiIqLPcND+AAAEogAWDUCgogAWA0D/vWGiABYAQAAWAEAQ8v+7QNjPIOIHyiCBDwAA0ADPIOEH +z3GfALj/HaEG8M9wnwC4/z2gA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAg +oNoIIAEB2BIMwAIlAI/74HjxwAAWAkChwUDCARSAMFEgAIAG8s9xgAB0ogXwz3GAADyyQKFgiQHa +B/AAFgBAFSGMAACkAeJ9eBBy+fdRIwCACfIAFgBBA/AA2BUhjAAApAHiheK69wPM13AAAABAAdjC +IAoAF7jHcAAOAACDuJ24n7jscgCiARICNuxwQKB+CCABAomhwNHA4H7gePHA4cXPdYAADAupcP4J +YA8I2QCFz3GgALgeAqEBhQOh2g/AAG0HT/vRB8AA8cCkwYtw2glgDxDZA8zXcAAAAEAB2MIgCgAX +uMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoADAUSAAgAPABvQCwfIOIAEA2gXw1gmgAgHBxg/AAKTA +0cDgfgkAAAAFAAAA8cBuD8AAjQXADOB48cDhxbTBi3WpcKYJYA8U2QDAhuDMIOKBBvQGDGADqXAI +cSTwguAH9N4MYAOpcAhxHPCB4Ab0Yg5gA6lwCHEW8IPgzCAiggf0+gpgA6lwCHEM8ITgBvR6DGAD +qXAIcQbwieAe9IohhAADzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HIAogESAjbscECgFg/g +AChwZQZv+7TACiHAD+tyfNiNuHfbi7tKJAAARQSv/AolAAHgePHA4cWiwYt1qXDuCGAPAtlqDmAD +qXCWDsAAKQZv+6LA8cCmDU/7ABYQQKHBTCCAoMohxg/KIsYHyiCGDwAAjwzKI4YPAACMBcokBgTs +A6b8yiUmAAAcADSLdalwRg3gAATZiiDMCv4PYAMKcYQoCCkvdwAnjh+AAEiuRgjgDQRuz3CAACyw +GoAScBHyJBaAEIDgJPKpcATZmdoe2/IO4AsYuwDYJB4CEBjwx3eAADyuC4eBuAunz3CAAJwJL4CA +4QHaBfJEoATYBvAA2SygSaAkoAXYUg6AA1EFb/uhwOB48cDhxc9wgABIISSAIIF2D2ADiiDMDc9w +gADwKQCABCC+jwDAAAAJ9M9wgAAkrACIjCDDjwTyvgsv/QHYz3WAANSqqXDSDyAPUtnaD0AIo4WK +IEwOLg9gA6lxcg3AAIogjA4iD2ADatkmDiABqXAIcc9wgAAQXt4PgA3+2c9wgAAkrOEEb/sgqPHA +z3CAAMSwhg8gDw3ZNg3AAA4KQAfRwOB+4HjxwDIMb/uKIMwOosHSDmADiiEFBotwXg8gDwLZAxSR +MEwhgKCP9gQUhTAKIcAP63LPcAAAhAyKI4UJfQKv/AokQAQCFIAwz3aAAJwJhCkIKS93IB4CEM9w +gABgrvlgLIlAIBIDgOEAFBQxACDTAxzyiiBMDWoOYAOKIQUMiiBMDV4OYAMqcdYKoAFCJIAhAdgR +tv/YIR4CEEAmABiCC+AABNlr8ADYEbYhHkIUz3WAAEysQCUQEv1li3CpcXYLoAwC2kAlABJyDiAP +QiSBIQAngB+AAEysCBAFAM9wgAB45wWAUyVBBRBxyiHGD8oixgfKIIYPAACFDMojhg8AAIQBtAGm +/MokRgSqD2AIKnBKJIBwANmoIEAEhCkICS9wMiICIIDiCPIIFQUQMCAEIAwkQIEm8gHhQCYAGOYK +4AAE2QHZDBtCIIcVABaAuIcdGBAKC6ADKHCKIEwNhg1gA4ohxgiKIEwNeg1gAyKFiiBMDW4NYAMq +cREDb/uiwAohwA/rcs9wAACGDC0Br/yKI8YFABYAQJEDwADxwOHFz3WAACDMqXDODSAPA9kBhc9x +oACAJQyhAoUNoQCNUSAAgADYjrgE8g+hA/AQoV4LwADxAk/74HjgfuB44H7geOB+4HjgfuB44H7g +ePHAWgpv+wfYo8EA30LHbgsv/gnZi3AmDiAPBNk+2NoMYAMBEgE2PtjODGADBBQBMT7YxgxgAwYU +ATEDzNdwAAAAQAHYwiAKABe4ACCBDwAOAAAGFAAxG3gT4AQggA8AAPz/JXiduJ+47HEAoQESATbs +cCCgAMHscCCgBBQBMexwILAGFAEx7HAgsAYUBDFRJACADfIBEgU2CiHAD+tyz3AAAE8mKQCv/Gnb +Ad3PcQAAIiJGDGADPthuCGAEqXACwSV4QsAAwFEgAIDKJaIQyiGCDwAAMzMgDGIDyiCiD89woAAs +IEAQEAAC8AHnBhQAMRB3gAAKAILlBBQAMYLGFvQbeBB4yXE2CWAEqXLscQCpBBQAMclxG3gB4BB4 +HglgBKly7HEAqQjwyXESCWAEqXLscQCxBBQAMUAgRQDPcKAALCAQgC8lSAECIAAE13ABAKCGmgfl +/wQcRDEIFAQwCiHAD+tyz3AAAFAmZQdv/Izbpg8ABM9woAAsIDCAPth6C2ADAiEBBD/YbgtgAwLB +CNjqCS/+CdnuCeAAAsAhAW/7o8DgePHAABaFQKbBTCUAhgAcQjFE9kwlAIJN9gohwA/rcs9wAABm +GZXbBQdv/EokQAAAFoBAARwCMAAWgEACHAIwABaAQAMcAjCLcA4JYAeBwQLCgOIP9AAUhTAKIcAP +63LPcAAAZxmf28UGb/yKJMMPBMBgegXBA8GA4Qv0CiHAD+tyABSFMM9wAABoGaPb7fEBwIDg4yBC +AMogIgACCcAApsDRwOB+8cDPcIAAdDg6CyAPCdmeC8AFvg+ABSYIwAXeCMAA0cDgfuB48cDPcIAA +eDoWCyAPB9nGCMAA0cDgfuB48cClwYtwAgsgDwXZAMBRIACAFfLPcIAA8CIDgBiIgeAN9ADYmrjP +caAAyB8PoQHApBkAAMPYGrgOoYIIwAClwNHA4H75AyAHANjgePHAz3CAAOA8dgogDyjZYgjAANHA +4H7gePHA4cUAFgBAguDPdYAAUBwApR/0ANnPcJ8AuP89oBzZFfDPcKAAyDs2gEQhAgc2gIYh/wgl +ejaAhiH/CEV5z3KgAKggTYLk4pH3gOHr9QoIwAAghYThXgANADMmQXCAAGBoQCeAcjR4AHg4EAQA +WBAFAAohwA/rcs9wAACZIWkFb/wv2/II4ANU2FEgQIAT8s9xgAAUPQCBgbgOCqAPAKEJ8EYP7/0B +2BIMwAMD8N4LAAU9Bw/74HjxwIoMwAmaD4AA0cDgfuB48cCeC2AKANjPcIAA8CLIEAEGwLmB4QHZ +wHlKDGAPPBCAANHA4H7gePHA4cXPdYAA8CIAhcQQAAZRIECBDfIKIcAP63KF2I24iiOcD0okQADN +BG/8uHO6CwAMMgngDQHYz3CAADgmCIiH4B70AYXEEAAGUSBAgRjy4gnP/M9xgAB45wSQJYEKuDBw +DvIKIcAP63KG2I24iiNdAkokAACBBG/8uHNuCE/8HgvgDADYDgiAA94OgABxBg/74HjxwD4MYAoA +2OoLT/zPcYAA6LsCiZILYA8gidHA4H7gePHAosGLcL4IIA8I2QDAgODPcYAAXD0AoQfyBhQAMQOx +BBQAMQKxjg6AAKLA0cDgfvHAmg0v+4HYocFgwADYARwCMAPMz3aAAOwKAhwEMIogiwcaCGADZNmK +IIsHDghgAyCGiiCLB891gADwCv4PIAMghc9woAAsIEAQEQAAhoDgD/LPcYAAuAoAgYG4AKHPcYAA +aD0DgQHgA6EB2ALwAtgacADA6g5v+wpxz3eAAGg9AxIBN16XgdhghtILoA8KJAAEz3CgACwgEIBA +H0AUTCCAoBGnSB8AFFLyAIaI4Bn0z3CAAMxg4g9ADSIM7/0U2PYOIAUE2CCGQIWKIIsAGLkQumoP +IANFeQDYAKYApYXgA/IA2AXwAIWE4P31AdgvJgfwD/KyDeADFNiA4An0z3CAALBgJoAjgSCBAgiA +DQCGgOAE8gDYBvAAhYDg/PUB2C8mB/AF9MYKwAKA4BDyiiALAAoPIAOf2c9wgAC4CgCALygBAK4M +7/xOIMAHrQQv+6HA4HjxwEYML/uA2KHBAxIBN2DAz3OAAOwKYIPPdYAAaD0CHEQwL6UockogACAB +HAI02gqgDwokAATPcIAAPCkQEAUAUSWAgAz0ABQEMAohwA/rcs9wAAB2J2kCb/xn289wgADsCgCA +gOCUAgIAhg/AC4DgiAICAM9wgAB4OgCAUSAAgXgCAgCKIAoPXg4gAwESATZKDgALz3eAALYKAI+E +KB8AACGAf4AAUM2WDuAOiiELD2CPCiGAL4AAbM2EKx8AACGCf4AAUM0FkoYgfwwceFMggIAI9M9x +gAC4CgCBhrgAoQKKUSBAgGj0hCsfAAAhgH+AAEzQSg7gDhjZAI+EKB8AL3A0IQ0gQiUEFowkB4HN +9wohwA/rcs9wAACBJ5DboQFv/IolBwHPdoAAiNDYYBIO4A6IcQCPz3GAAMgKhCgfADImRR4AJkAe +TCUAgAChDfIKIcAP63LPcAAAdyeV22EBb/yKJIMPoYjPcYAAzApAJYUQTCWAiEAlgh9Aqcz3CiHA +D+tyz3AAAHgnm9sxAW/8iiSDD89xgAAIzc4JYAyocgCPhCgfADQhQS7PcIAAtAogsCDwHBIEAYwk +CIDM9wohwA/rcs9wAACLJ6Tb8QBv/IolCACEKx8AACGAf4AATNBeDeAOiHHPcIAALM0gGAAEANkz +8AAWAkCEKx8AACGAf4AAnNMw4DV4QKAAFgJBACGAf4AAHNQw4DR4QLAAFoBAACGNf4AAPNJSaVR6 +umIQqhGqEqoAFoBAFKoVqhaqABYAQQAhgn+AAFjUNXoasgAWAEEB4RuyYI+EKx8AACGAf4AAUM1D +iFBxjAfl/y91ACWBH4AAzNMAJYIfgABM1NoOAAg+Cu/9FNgWDCAFBNhAjwHIz3WAAPAKhCofAAAh +gX+AAAzVAKHPcIAA7AoghQCAELkYuAV5iLkuDCADiiCLAAHZz3CAAOwKIKAAHQAUPgtv+wDA1gjA +AoDgkAnCDwMSATfPc4AA7Apgg4DYKHIaCKAPSiRAACPwBIUB4ASlz3CgANQDHJBeCEABAMD+Cm/7 +AtkDEgE3z3OAAOwKYIOA2Chy5g9gD0okgAC2DaALAtiKIEoPsgsgAwDZbQEv+6HA8cAKIcAP63LP +cAAAMCWKI4wHiiSDD2kHL/xKJQAA4HjxwOHFINvPcaAAyBxpoQAWAEDPcqAAEBQMogAWBUAB3Uwl +AIDKIcEPyiLBB8oggQ8AACwlyiOBDwAACQEgByH8yiRBAxgaQAFoGUABA9gPormhaqF6CYAADQEP ++/HA4cWtwYt1qXC2C+AODdkAwB14UyABAEQpPg2pcAAhgX+AAIjdWghgDA3aRgmAANkAL/utwOB4 +iQOgDwDY4HjxwFIIL/uKIJINrMHeCiADxdmLcGoL4A4M2QAUADGA4C/0z3WAALAuIIXPdoAAfDNg +eQDYjOBAJI8wEfIghWB5ANiQ4AvyIIVgeQDYkeAH8iCFYHkA2JLgBfTpcMlxGNoE8OlwyXEu2gIP +AAwB2GAeAhAXhoDgRAph+8ogIQAAFAAxgeAX9Iog0g1iCiAD3tlAJIAwz3WAAHwzQCWBG84OIAwu +2gHYN4VhHQIQgeEMCkH7ggiAAAUAL/uswPHAig/v+hfZt8G6CuAOi3AjwEoiQCBTINAAhiD+A0wg +AKRCKBEBDBwCNI/2CiHAD+tyctiNuIojDwMKJIAEyQUv/AolAARIFAUwIMBAKI4gz3WAABDf1n5R +IACAwGVBLU8DwL++ZoYg9w9e9IDgDfQKIcAP63Jz2I24iiPPBIkFL/wKJAAEiiBPBQpxlg5gBahy +AcACwQpyagov+2ZugOA98ulw2glgDwpxDRSAMIUgwQANHAIwiiD/D1PAAIapuACmEsCGIPsPKLgP +rkokAHQA2aggAAP/2rhhQCiDIHZ7EuB4YECoAeEKcPIIYA+Lcc9wgADwIvAgwQPAEQAGDyAABMAZ +GAAPjoHgB/SA58wgoqOkDIIPAd8C8ALfUgpgAgpwB/CA4MongRTKJyISgedQAgIAIIbPcIAA8CID +gBiIKHWB4IYl+x8R8qoNgAKA4CCGGvLPcIAAOCYIiIfgFPRBKUADUSAAgA7yE8DouBLCCvKGIvsP +QSoEAk+OkHIE8qi4U8ATwBLCBnlEeCV4gOUApoYg+w8L8oDgyiABBMohIQDkC+EDyiLhAw4eQhQA +2M9xgABQ4hYhAQRAhgCh9boBoQX0ANiLuAGh9roF8gGBRSAABgGhQglv/ItwDRSAMFEgQIEh8lgU +ADEFtloUADEGtgWWgOAZ8jYNgAKA4BDyBpZRIECACfJiCy/8CnA+DIAPBdgSrgDYBbYH8ApwANlm +C+ADD9oNFIAwUSBAgH7yUBQFMQKWHtovIUoBMHkkeC8pAQACIkAAEHhAKAEhJXjPcaAAwC+iEQGG +EHgQ8C8tQRACIkMDAN0PJc0QpnnPdYAAYN30Jc0QsXAI8oDh8fXPcAAA//8H8HB4z3GAAKyyZLHX +cAAA//8w8s9ygAAg3LRou2IEEwQAI4MFIT6BJvLPcaD+EAfPdp8AuP82ps9xoADALxV5KhEAhhYR +AIagYgohwA8WpgGD63IWpgKDFqYDgxamBBMEAAwTBQCR2I24FQMv/IojkgdMJQCABB5EERTyAN0Q +2DpwApYRIECDyiACBMohQgNwCuIDyiJCA0IhQCCA4AHlMfcNFIAwUSAAgQbyCnA6CSABVRSBMA0U +gDBRIMCAG/I1wVYUAjEKcPYPr/wSw4wgAoC4cA30CiHAD+tydNiNuIojkg+dAi/8SiRAAFElwIHK +JyIRrghgDwpwA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoBINYADpcDkE +7/q3wPHAygvv+oogUwmkwQDdqXFeC2AFqXLPdoAA0OYAjkokQCChrgIeAhUB4ACuo66hpqKmpKal +priuua4BwLquAsEHpgPAKKYJpgHYMg7gAqlxgcC+DqAOAdkBwAemWnW48ILArg6gDgLZAY4CwQHf +464B4AGuA8Aopgmm6XD+DeAC6XECwItydgwv+wPBBCAABS8kByAC2QKuAMAjrgGm3g3gAulwTCQA +oJDyAMHPcoAAEN9KIwAgEmkWeABiDyNTIC24UyAQAIogVAWmCmAFCnLPcIAAOAoAEBEALyXKJM9x +gAA4CviuBCVAJAChA9kjrhAewBQUHgAUCB5AFAOmfg3gAulwz3CAADgKAICA4A70TCEAoAry4gzg +BCDYBNkjrvmuWg3gAulwBdkjrk4N4AIB2CDAhg/gABDZAMACuBZ4ACCBD4AAEN+isYogCAAAoQbZ +I64mDeACAdgAwADZdgjgAw/aAMCA2QK4FnjHcIAAEN8oqCmoB9kjrgIN4AIB2M9wgADwIvAgAgTP +c4AAUOLAEgEGBCFABcAaGAAAwgDZz3CAAHDeVnsgoyGjVHgeCaAPoLCA4AryogiADwjZI676rroM +4AIB2EAiUiAhwFJwkAbN/wnZI66iDOACAdgDzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEA +oQESATbscCCgMgtgAIpwCtkjrmoM4AIB2AUC7/qkwPHAiiBVCwDZSglgBShywg0ADJYKQADRwOB+ +4HjxwOHFABYNQAPMAdrXcAAAAEAByMIiigAXusdyAA4AAMYOIAxTJQEQUSVAkM9xgAAUQAHYyiAh +AOkB7/oAoeB48cChwYtwkgygDgHZABQFMEwlAIAL9AohwA/rconYjbhF27kH7/tKJEAAz3GAAPTJ +AxlCAUAtgAMCoUokwHAA2qggQAIA2A8ggAALIECBBPQB4gTwDrgBofIJQAChwNHA4H7gePHAegzA +B89wgADwIiwQhABMJACBCfTJEAAGUSBAgQXysg7AARDwTCRAgAzyz3CAADgmCBCFAEwlwIHMJWKC +BvSSDA/70cDgfgohwA/rcs9wAADsHCEH7/tf2+B48cCSCM/6ABYSQQAWAEHPcYAAEN9AKoAgFngw +IQUAosFMIgCkQS1AA1MgEwCO9wohwA/rcnXYjbiKIxgCSiRAANkG7/tKJQAAUSVAggzyCiHAD+ty +dtiNuIojWAK9Bu/7CiSABM9wgABQ4RYggAQacGYLoA4C2c9wgADw3RYggARWC6AOAtlAKpUhACWA +L4AA0OJGC6AOENmLcD4LoA4B2QAlgC+AANDiXglgBxDZARCAIJDgjvYKIcAP63J32I24iiOYCkok +QABRBu/7CiWABADdENg6cBUlQCPPcYAA0OIwIRQABCSCrwAAAAEEHAA1TfJEJA4mI74B5gQkgC8G +AAAAMbghwd9goOHRJOGiOvKA4gTygeYL9wQkhC8AAAAkDCSAjwAAACQs8oLgVAANAILgBvSA4iby +guYk9IDiBfLM4UAACQDPcIAAuC4ggGB5BtgQdhb3z3CAAPAi8CDABMMQAAYB2QQgvo8ABgAABCSA +LwAAAAjCIUEAK7gQcUT3ANgD8AHYD3gD8AHf6XAEJIEvAQAAwC65z3KAADR6KWIwdwHZwiFNAIDg +zCEigBjyQiFAIIDgIAft/wHlAhCAIM9xgAAEbghhgeAc8gohwA/rcnnYjbiKIxkAMvEKIcAPz3CA +APAi8CDABOtyiiNYD8MQBAZ42I24IQXv+wolAAUDEIAgCGGC4AnyCiHAD+tyetiNuIojmQIS8SIL +IA9KcM9wgADw3RYggAQgkM9yAAAYFQkhgQBWDyAAILClBq/6osDgePHAABaBQM9wgAD0YiCoABaE +QAAWgUDPcIAA/WIgqAAWgEBQJL6ByiHCD8oiwgfKIIIPAADaFMojgg8AAIEHmATi+8olIgDPcIAA +lAkAkIDgBfJqCsAObgnADu4OAADRwOB+4Hh1BGAOANjgePHA/g2v+gDZSiQAcuB4qCCAAgAWAkAV +IkAwDhiYAAHhABYNQAAWDkDGCYAOz3CgABQErKDPcKAA1AvcoJ4OAAApBo/68cCyDa/6CNmiwQES +DjbPdaAAOC4cFRAQjgigDotwABQEMADfBCS+j/D/AADKIcIPyiLCB8oggg8AAKYoyiOCDwAA4Qbg +A+L7yiXCAFEkQILKIcIPyiLCB8oggg8AAKcoyiOCDwAA5Aa8A+L7yiXCAOelSg5gDz/YAMAEFAEx +B6X+DmAOgrkcHQAUDg4gAAEamDOFBa/6osDxwADYag0gAAQSgTAEEoUwCiHAD+tyONiKIw8BcQPv ++0okAADxwOHFz3WAANAuqXCAIAcP2g9gDgTZQgxAAoDgB/LPcIAAOCYIiIngDvIKIcAP63LPcAAA +1Bt+20okAAAtA+/7CiUAAc9wgADwIiGAxBEABlEgQIHKIcEPyiCBDwAA1hvKI4EPAAB/AMoiwQfm +8/4VABeA4MP2juDJ9gohwA/rcs9wAADXG4Db2PHIEQAGhiB/jgX0YghAAA/wAIWSuAClC8iuuK+4 +CxoYMAvIh7gLGhgwkgjP+iYNAAC5BI/64HjxwDoMj/rPdoAA0C4Ahs91gADML1EgQIIF8iIMQAKA +4CPyANgIrQHYCa1VJsAYOg9gDgvZVSbAGFYmwRXqC+ALC9oIjc93gABcL0QoPgsGbzIgQA6B4AHY +wiABAAqtAIaJuACmFPAIjSmNMHAF9E4gQQAveSmtz3eAAFwvVSbAGEQpPgsncOIOYA4L2WmNA29E +Kz4LMiBADorgyiHJD8ogiQ8AANEbyiOJDwAAagGqACkAyiLJB4LgyiHLD8ogiw8AANIbyiOLDwAA +bAGKACsAyiLLB4HgAdnT9kIgRAAKJABxKHCoIEADRCs+CwAnQR4VeUaJIokwcifyAeAPeJoKQAKA +4B3yz3CAADgmCIiJ4AfyiOAV9ACGUSAAghH00g4P/ILgBfLKDg/8geAJ9M9wgACsYQaAA4AAgK4O +z/zeCwAAYQOP+gohwA/rcs9wAADTG4ojRQxKJAAAUQHv+wolAAHgeDkHYAYB2OB4vQegCQHY4Hjx +wMYKYALhxYDgz3WAANAuDvQEFQQQCiHAD+tyz3AAAL4biiMGBBEB7/u4cwCFiLgApVUlQB6+DWAO +Bdn3FYEQz3CgAMgcGoAKucq4FXg4YJkgCgBEHRgQz3CAADgmCIiH4CX0z3CAAPAiAIDEEAAGUSBA +gRvy7BUAEc9xgAB45yWBCrgwcMohwg/KIsIHyiCCDwAAxBvKI4IPAACeAcokIgCUAOL7yiXCAH4P +QAv2DCANAth2DI/7Jg8gDADYFgzAAuYKAAB5Ao/64HhFAOAJAdjgeGUAYA4B2OB4GQUgDwHY4Hjx +wKHBANlAwQAWAkAAFgBAgeIa8gPM13AAAABAAdjCIAoAF7jHcAAOAABFIAADnbifuOxyAKIBEgI2 +7HBAoOxwIKAf8KYJ4AaLcAPMAdnXcAAAAEAB2MIgCgAXuMdwAA4AAIS4nbifuOxyAKIBEgI27HBA +oOxwIKAAwuxwQKCKCiAAKHChwNHA4H7gePHAVgmv+gLZz3eAAAxjJg1gDulwQIfPdqAA7CfPdYAA +uC7gukvyK4ZEIoAAhiL/DiK6obkUurS5BSCDAGV5K6YEIIAPEAACAAQigg8QAAIAz3GAAKgIRXgL +oSCFBN5geclwh+AL8iCFYHnJcIbgB/IghWB5AdiB4BH0AIfPcaAAyBxRIECAB/IB2B6htggABwXw +ANgeoeIPgAYghWB5AdiF4DX0AIdRIMCAMfLPcKAARB3FoMOgxKAp8M9woADIHAHZPqALhoG4C6Z6 +CAAHIIVgeQHYheAT9M9wgADwIgOACIBRIACAC/IA2ZS5z3CAAKgIK6ALhpS4CPDPcIAAqAgA2Sug +C4a0uAumLgkAALEAj/rgePHAz3CAALQWFgxgDgLZFgkAANHA4H7gePHALgiv+gDaCHUods9woADU +CziAQiEBCIDhyiGMAEAmABIQccAKBQ8DzNdwAAAAQAHYwiAKABe4ACCBDwAOAAAHbgQggA8AAPz/ +JXiduJ+47HEAoQESATbscCCgIr4G8OxxAKEE5WG+geYAhTr34ggAACkAj/rgePHA4cXPcqAA1AsD +3bGiANtwogMSAjfXcgAAAEAB2sIiigAXusdyAA4AAEUiAgadup+67HNAowLaFBqCMAUSAzbscmCi +CxICNwHiCxqcMOxyAKIBEgI27HBAoOxwIKDPcKAAsB8B2Tmgz3GAAEghCIFAgOxwQKAMgQCAXggA +AM9xoADIOw6BiLgOoaEHT/rgeAPM13AAAABAAdjCIAoAF7jHcAAOAABPIIEAnbmfuexwIKDPcKAA +FAQD2SWgARICNs9woADUC02gz3CgAEQdNaDgfuB4A9rPcaAAFARFoc9xoADUCw2hz3CgAEQdVaDg +fgPaz3GgABQERaHPcaAA1AsNoeB+A9rPcaAAFARFoc9xoAD8Cwypz3CgAEQdVaDgfgDZlrnPcKAA +rC88oOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4z3OgAKggMYPPcoAAbCkDgjhgA6IB +2BKj4H7gePHARg5v+rhxz3CAACywaBAEAEogACBMJICAyiLGB8oghg8AAJEMyiOGDwAAtweMBKb7 +yiHGD89wgACcCQeAhCwICQAhgX+AAEysTCUAgBZ5x4E+9M9wgAD0KaIML/yKIQ8Pz3CAAIgpkgwv +/CDZz3ClAAgMoIBTJU2QE/KB5RPyguUU8gohwA/rcs9wAACSDIojnweYdSUEr/sKJQAE/9gG8P/Y +CLgE8P/YELjPcYAAqAgMoa2hzqEA2ZG5z3CgANAbMaDWCmANAdgf8M9zgACoCA6DgOAb9M9xgABg +b89ygAD0Kc91gABsKYokw38KcKggwAIPYRUlwxPng/AiDgAB4P5mx6OlBU/6OBMEAAohwA/rcs9w +AACTDIojHwydA6/7CiUABOB44cXhxs9woAAUBAPZI6ANyM9ygAAUy2GSz3GAAATKxIoUIQ0AaLUA +IIMPgAAkyjjhwKtighV5BpJgoQMSAzbAHQQQBIKgEwEAhiHDDyV4oBsAAMHG4H/BxfHAzgxP+gh2 +HgwgAih1gODRJWKTAdgD9ADYBLjPdYAAmOcUeAllgeEdZQr07gwgDalwrg0v/QGNANgArQGF/QRv ++gCm8cBODoAJ2gxgDADYz3CAADgmCBCEAEwkwIET8kwkAIIV8kwkQIIa8gohwA/rcs9wAADKG7vb +wQKv+0olAACaCg/8vgoAD9HA4H7PcIAA0C4AgFEgAIIF9EoPT/v18eoPz/u2Cg/8C8iuuK+4CxoY +MAvIh7gLGhgwVgiP+uXx4HjxwAoMT/rPcYAAOCYMkc91gADwIt6VDiYOkM9wgACwMA6QyiZiEAyx +AdhKDiAAANnSCSAJAdiGD8/7geAY9ACFxBAABlEgQIED8oDmEPIB2AhxYg6v/AhyC8iQuAsaGDAL +yAUggA8AAADUCfALyK64r7gLGhgwC8iHuAsaGDDSD0/69QNP+uB48cBqC0/6DRIBNs93oAC8Lc9w +gADwIi6nBIAA3UYQEQFWIFIEViCTBA0SEDdWIBQFRiDAIAMSAjYNGhwwpBIAAIS4pBoAAAGSosGA +4IYaRAMI8s9wgAAEy/QgQACA4AnyAYLuuAX0UCAAIC8gCCBTIH6gSgMBAM92gAAUQGkWABYB4AQS +AzZpHhgQpBtAAwGSgOBK8s9wgAAEyjR4gBABB4DhQvTQEAEBUyHBgBT0chIBAeCSIn+4EoEAIn/w +f+AYxAOkEgEAhiHzjwbyaL/wf+AYxANwEg8B4BAAASGS4njxcMInDhDCIc4DdBIAAThguBKBAHQb +RAOgszhgEHiQGwQAvhsEABCKEKsBggGjCIoIqxKKANoSq5a6MvDiDiACiiAFAQ+H97j680+H9rpT +IsACJvKO4En3pxYAFra6AeCnHhgQHPBkuAQSATYQeJAZBAAEIoAPAAAA8Cy4dBlEA6CxEKmhsQPI +vhlEA2GAqKmGI/8NhLthoRKIEqn2uj4CAQAA2Ja49boEEgE2pBkAABLyJg9v/gDYBBIBNqQRAAAE +IIIPAgAAAC26BSICBC8giCBA8AGBUSAAgVLyNMpQiUkgxADyas9wgAAQ3/Z/4GD2uHKJB/LPcIAA +UOFWeAGIAvAA2AAkjw+AAFDhVn/kjwgjwwMIIwAASSDDAxZqdXjPc4AA0OIAY89zgABQ4lZ7QYPP +c4AA8CJkg3iDZXoEIoIPAAAACEZ4mBkAAADYlrj0uEGBhiL/DR/ygOJS8pgRggBAIgApSGDPc4AA +VLJAwCDCw7pcevQjggBW8AohwA/rcjTYjLhf2wW7iiSDD4EHb/tKJQAAmBEDAOm7nBlAAyPygOKA +uKQZAAAs8pgRgADPcoAA8CJDgoYg/wNEuDIkACCJuEDAIMNUgmR6hiP/A4Yi/w5Eu3piT3rPc4AA +gG70I4IAIPBRIwCCCvKA4grymBGCAEAiAClIYA3wgOIF9ADaSHAQ8JgRgADDuBx4MiMAIEDAIMLP +c4AA/LHDulx69COCAIgZAACYEQAAhBmEAJARAQGuCCAAANoEEgE2AxINNoQRAgGCGQQAz3OgAMgf +WGAQeLAZBAD4EwIAsBUPEUJ/z3KAAPAiRIIAIdEjVBIEAQAkTwQfZ6ATAwDwf3B3OAANAFCCmBUD +EAsiwIAW9DCJUI0wctEjIoIW8oYj/wkjuwHjgePQ9wK6z3GAABDfVnpBYfG5CPK4FgAWAeC4HhgQ +DfCAcBB4hh0EEGoWABYNGhw0AeBqHhgQBQBv+qLAocHxwLIPD/oIdUbA6L0ocNAAIQBIdgO4QCCQ +BUQlAhYjugQljx8GAAAAAeJBL0AUBCWBH8AAAABYYDa5z3KAAAB6qXPGuyliCGI4YEEtgRJSIQEA +wLkDuRjhheDKIY0PAQCJDdUhDgAvIUggBCWBHwAAABjPcIAAEHHXcQAAAAgeACIA8CDAACbBoOES +AAEAz3FCe9BeBSh+AAogwA4KcQUpPgAKIMAOgOckuAHgBfJTIAEAOGDtvQIpgSMP8s9ygABMckCS +BSo+AAAhgH8AAP8/LrhdACAAGWFZACAAFXlRJUCSVAAhACbFt+UgAAsAM2hTJQIQz3CAAMhu8CCA +AAUpPgAKIMAOAeAH8IrlwCjhAMAoogDPcYAA8CIjgcDaNIGkeYYh/w4iuTp62noZYjB4CNzjBg/6 +M2hTJcAQHHjPcoAAkHLwIgAAFuEFKT4ACiDADgHgFNmDB+//2nngeM9xgABIISSBQSiCBdW4IIFB +KYMF1bkCec9wgAB452J6BYDJugUovgAncc9wgAD4YQOAAIDgfzhgz3GAAEghJIEggUEogwXVuEEp +ggXVuRBxW2NK989ygAB450WCWWECeQHjA/ACeUArgAWZB+//JXjxwIIIT/rmDS/6UNlFwEogACAy +DS/+hsVMIAClBBUBFE73BcDXca3e774VIAAEIKBAIFAg8vUk3BcGD/oKIcAP63LPcAAAixOKIwcL +mHMRBG/7CiUABOB48cDhxYLgmHC4ccr3CiHAD+tyfdiNuPEDb/vw289wgADwIvAgAQGKIwsNTCUA +gEAhAgZ4Yib0qIF6YqCiSYFBoFyJSKhdiUmoKhGCAEqoKxGCAEuoLBGCAEyoTZFHsFeRSLBIgQQi +gg8ABgAAgOIB2sB6UqhUkVOoKIHAuS2oHPBMJUCAGvRiYkihQYBJoUiIXKlJiF2pSogqGYIAS4gr +GYIATIgsGYIAU4hUsUeQTbEIkBexWQUP+gohwA/rcpDYjbhFA2/7iiOEB+B48cDKDA/6z3aAANAu +VRYBFlYWAhYwcqTBSPeIFgAQAiGDAHhgiB4AEIDhDvKA4gz0VxYAFjhgVx4YEFgWABY4YFgeGBDP +d4AATAkAh4DgAN0D8lgeWBNYFgAWQ8JAwFcWABZCwRDZvtpBwItwHtsiDqAKGLtWHlgTVR5YE6Cn +tQQv+qTA8cBGDA/6z3aAAIyiBBYFEEIlQQCF4UwBLQCiwTImQXCAABhoQCcAcjR4AHgC2ACmAdnP +cIAA9CAgsLYKYAoocAKGz3WAALggKIVHhQgVBBAPIEAAAqbPcIAAmCA1eECgGBUFEQwVBhDPcIAA +HDkA2TSoz3AAADjCQMAFhRAVBxBBwBqNO41AhYYMYAthhYogGQFODiACOo1h8M9wgAD2IAHZIKjP +cIAAuCAngM9wgABYyS+gAgzv/ALYUfAE2ACmANjPd4AA9CAmCmAKALfPdYAAuCAChkiFZ4UPIIEA +z3CAAJggVXhgoCKm7NjmCqAEQJcIFQQQz3AAADjCGBUFEQwVBhBAwAWFEBUHEEHAGo07jUCF+gtg +C2GFJBWAEEiFANlRIACBBIYPIYEACfIB289ygAAcOXSqBXkkpgPwJngEppIPYAQA2KPxkgrP+wfw +iiAZAYoNIAIihlUDL/qiwAgWBBAKIcAP63LPcAAAQh9FAW/7iiNEB/HA4cWKIBkAXg0gAq3ZAd3P +cIAAjKKgoADYz3GAAPQgVglgCgCxtgwgAKlwGQMP+vHA4cUA2M91gACMoloIIAAApcYJ7/wC2CKF +z3KAAPQgd9gKCqAEQJLtAg/68cByCg/6AN7Pd4AA9CDAtwoJYArJcM91gACMosKlw6XEpYogyQDJ +cdYJoARAlwHYqQIv+gCl4HjxwM9xgACMogARBQBMJUCBjPcKIcAP63LPcAAAQR+Z24kAb/uKJIMP +AaHPcIAA4CDwIEABQHjRwOB+4HjxwP4JD/rPdYAAjKIEFQUQTCVAgKLBJfJMJYCAEPJMJUCBbPII +FQQQCiHAD+tyz3AAAEQfOQBv+4ojRwbPcIAA9iAB2SCoz3CAALggJ4DPcIAAWMkvoBoK7/wC2FDw +BNgApQDZz3CAAPQgILA6CGAKKHDPdoAAuCAChUiGZ4YPIIEAz3CAAJggVXgipWCg/gigBIoghgsI +FgQQGBYFEc9wAAA4wgwWBhBAwAWGEBYHEEHAGo47jkCGDgpgC2GGJBaAEAHfSIYA2VEgAIEEhQ8h +gQAJ8s9ygAAcOfSqBXkkpQPwJngEpaYNYAQA2IogGQGmCyACOo4E8JoIz/tpAS/6osDgePHA+ggP ++s92gACMogQWBRBCJUEAhOHmAA0AMyZBcIAAIGhAJ4ByNHgAeAKGz3GAALggSIEngQ8ggAACps9w +gACYIFV4IKBZ8M9wgAD2IIDZIKjPcIAAuCAngM9wgABYyS+gCgnv/ALYR/AKlowgAoAR9ADYz3WA +APQgKg8gCgC1IoaKIAUEAgigBECVAdgApjPwA9gApjHwA4aMIMOPAd8S9ADYz3WAAPQg+g4gCgC1 +IoaKIEUK4KbOD2AEQJXSD4/7G/AA2Q8hAQAChgYgQIAS9ADYz3WAAPQgyg4gCgC1IoaKIIUMog9g +BECVog+v++CmA/ACpm0AD/oIFgQQCiHAD+tyz3AAAEMfYQYv+4ojRgDgePHA4cXPdYAAjKIEFQUQ +QiVBAIXhkAANADMmQXCAAChoQCcAcjR4AHjPcIAA9iCA2SCoz3CAALggJ4DPcIAAWMkvoBYI7/wC +2CzwAoXPcYAAuCBIgSeBDyCAAAKlz3CAAJggVXggoB7wA4WMIMOPAdoI8gDZDyEBAAKFBiBAgA70 +z3CAAPQgQLAGDiAKAdgD2OoOr/sApQbwAqUE8AHYAKW9B8/5CBUEEAohwA/rcs9wAABFH6EFL/uK +I0gL8cAuD8/5CHaKIFkBtgkgAslxz3WAAIyiw6XaDO//Bdgjhc9ygAD0IKDYjg5gBECSaQfP+fHA +7g7v+YogmQHPdYAAjKJ+CSACIoXPcIAAELEIgADfJ7jAuBN4xrgB4Aq1CNg6cADeAoUPJs4TCyYA +kDfyBIULIICDHvLGeASlz3CAABCxIBCAAIHgFvLPcYAAHDkQiQHgD3gQqYogCgUmCSACyXHPcYAA +ELEIgYYgww+AuAihiiCZAQoJIALpcc9wgACYIBUg0AMAEAAggODiIAIAAoUA2QAYQCDGeAKlQiFA +IIDgAed+B+3/738qlYHhz3aAAPQgAJYL9IDgEPQA2c9wgAAcOTSoiiAKBAXwgOAG9IogSgSuCCAC +ANkBhYXgCPIAloHgA9jKICIBxgvP/1EGz/nPcoAAjKIiggDbDyMDAGZ5IqLPcYAAmCAA2hV54H9A +oc9zgACMokKDDyJCAEKjz3KAAJggNXrgfwCi4HjxwL4N7/kZcQh2iHXPcYAAuCAaqRsZAgJAoRAZ +wAEMGYABoqEDwBgZRAEExQehJsCooSQZAgAHwGGhBaGKIBkCEgggAqlxU9jJcf4MYASpcibAUSAA +gAnyV9jJceoMYASpcgbYBfCB5gLYyiBiABYLz/+5Bc/54HjxwDoNz/k6cM92gAA4IQCGAeCB4M91 +oADIHwCmBvQB2FEdGJCqDUAOpBUQEM9wgAC0MiaAz3eAAMy7YHkA2AGHgOAq8iTYGNmmDWAOM9qB +4A7yBBcFEAohwA/rcs9wAAB0GY3bTQMv+wokQAQk2AHZfg1gDjPageAO8gQXBRAKIcAP63LPcAAA +qyiS2yUDL/sKJEAEpBUBEIogGA8+D+ABAiEBBACGQiBAgACmBPQA2FEdGJDlBM/58cCODO/5iiAY +Ds92gAB4PBIP4AEyhs9wgAC0MgSAgOAJ9M9xAACtC/oO4AGKIBgOPfAyhuTh1/bPdYAAIGMAhdrg +UfaKIFgO2g7gAQjZQIUyhoogmA4QusoO4AFFeQjYGvDa4UYACgDPdYAAIGMAheTg3faKIFgOqg7g +AYohPw5AhTKGiiCYDhC6mg7gAUV5iiA/DgYOAA4ghUgWABEQuaoO7/8leBKGAKVRBM/54HjgfuB4 +4H7geM9wgADMOkCI4LoI8s9xoACsLxmBirgZoVEiQIAH8s9xoACsLxmBjrgZoeB+z3GgAMg7HYGA +4AjygtgUoc9wAIARFA6h4H7gePHA4cW0wYt1qXDPcYAAtGk+DO/5UNraC8ABDgngAalw4QPv+bTA +4HjPcIAA4MtsiM9xgADsoowjAoAKkUEoAgMM8uu4CvQCu3Z7x3OAABDfApMPIIAAArMA2OB/DLHg +ePHAKgvv+VRohiL4A08iQwJTIcIABSLEAM9ygABw3hR6j+GKIw8MyiApAAn2AJIA3Q8lTRCKI88P +pngAsgDZSiQAdM92gADEpc9ygAA8ps91gABApqggwAQUIkAA5JBkf5B3DPQA3+SwFiZAEOCg4aBA +JQAZNXjgoAHhGQPP+eB48cAA2p66ANnPcKAA/ERBoOB4IaBiCqAKKHALyAQggA/+//8DCxoYMAvI +h7gLGhgw0cDgfvHAegrP+Uh2gOAB3UT2iiX/HxN4gOFE9rN9M3kUIQAAEgzv+Tt5rHgAHkAeuQLv ++QHY4HjxwOHFCHIB3YDhyiHBD8oiwQfKIIEPAACbE8ojgQ8AAFwAyiQhAIwAIfvKJQEBgOJE9lN6 +iiX/H4DhRPYzebN9FCGAALoL7/k7eax4bQLv+S9w4HjxwOHFz3WAAOyiz3CAAPAiI4BAhQCBEHIf +9AKRQpUQchv0AoVSD+/6I4WMIAKAFfLPcoAANAohggDbDyMDAAK4ZnkWeCGiACCBD4AAEN8Agaq4 +iLgAoQDYDQLv+Qy14HjPcJ8AuP/PcaD+SAc2oM9woADIHzyAQBAABs9wnwC4/1gYAAhKJMBxz3EA +AAiBqCAAAinYErjwIEAAAeHgfuB48cDhxc9wAAD//891gAAIowOlz3CAALRfKgwADM9wgADQXyIM +AAzPcIAAeGAWDAAMz3CAAJRgDgwADADZIKUF2AGlIqWKIMkDngvgAYohzAQ2CK/8BtgyCK/8Cdhp +Ac/5B9nPcqAA1AcaGliAgOAO8hkSAYYJIEMADxIBhgIgwIB5YQ8aWID29eB+4HjxwMIIz/kDEgM2 +CHcNEg42z3GAAATKEIvPcoAAEN/UeQK4FngFYjGJLb2A4VhgwL0L8iGD7bkJ8s9xgAAgIrR5oJEQ +5aCxJZCA4dH2YbklsBCLMmg2eTtiZZOA4zpiB/QmklEhQIAwDsL6Zg5ADc4P4AYNyAPIAdmgGEAA +z3EPAP//7gggAOlwoQDP+fHALgjv+QPYz3agANQHEx4YkA8WEZYAFgFAABYNQKLBz3Cw/gAA07kF +eUDFz3KfALj/NqJTJcEUJXgWoiDAnOAO8gohwA/rcjXYjLjPcwAA9AyYc1EG7/pKJQAAABYPQPB/ +ABYQQEDnUSAApcAnohAD5wQnjx8AAPz/B/DPcAAABQ02DIABGRYAlkInARQQcTb3ACHAIw8eGJAD +2CAeGJAZFgCWiOCT9x8WAJZBwCHAnODKIcIPyiLCBzbYyiOCDwAAEQ3PICIDxfXa2AIK4AGpcQQg +gC8AAABAtQev+aLA8cBOD6/5yNqCJAMyCHUods9xgAB4agYI7/mLcM9wgACMFQ2AgODPcZ8AuP8M +8h2hz3KAACAhBIIB4LO4tbi4uASiFqHPcKAAFAQB2kSgz3KAAAxBGILivQHgGKLPcKD+EAEWoUAu +ABSleBahyiAiALAOwf8acA3Iz3GgAGQuz3KgADgu8CEBANO5B4IkeAQgkQOs8I4Oz//PdoAACO4a +cMlwQgugBItxrgigDslwnvAD389woAAUBPCg5KAAFgRABxoYMQAWBUABGlgxBMqc4B70i3CuCaAN +DtkkwOG+UyDBAIYg/gNEuMQcAjBkwUQmjRQZ8o7YUSYAkZC4oBwAMGvyhtiQuKAcADBn8Otyz3AA +ANwOz3MAAPQKrQTv+gohwA9MIACgB/KM2JC4oBwAMFPwArk2ecdxgAAQ30CBSHSEJAyQDfJRIkCC +CPKL2JC4oBwAMAHdQfCI2JC4+vFOiVBwkdjPICIE9PUBwPq4CPIB3ZDYkLigHAAwL/AzFIAwIpER +IQCAFfIHyAQggA8AwAAA13AAwAAAC/QiwIDgyiCJDwAAjQCsB+n/zyApBArBjCH/jxHyz3CgACwg +EIAieNdwAIAAAMoghQ8AAIcAhAfl/88gJQRMIACgzCUhkFz1z3CgABQE46BMIACgqXZi9VMmfpAH +8s9woAAUBAmAgOBY9eG+M/JMIQCgAdoq8ipxLyhBAE4ggweU48olxRCF92h1gCXCFM9woABoLPAg +QAOU4w94yifFEIT3aHeAJ8IRz3WgABgs8CXNE7FwyiIiAIDiCvIA2A8gwAAGIQGA2vUB2APwANiA +4CTzRQWv+YAkAzLgePHA3gyP+Rpw2g4gAjDYmHApuFEgAIDKIcIPyiLCB8oggg8AAOkUyiOCDwAA +xwAkA+L6yiUiACzY7g4gAkAogSAB3oolDxqeDiACMNiYcCm4USAAgAvyjCYPmifyEg0gDgHYYb2A +5QHmL/d6DiACNNhPIAEFlbmyDiACNNhmDiACLNgIdV4OIAI02PW4uHAY8gohwA/rcs9wAADrFOPb +tQLv+kokAAAKIcAP63LPcAAA6hTU250C7/pKJQAAhQSv+UEtABTxwBoMj/kIdwDeyXB+CaAFyXED +2Ml1gOcacAryRC0+FwAhgH+AAIBe6g7AC4DnCvJELT4XACGAf4AAKF/WDsALQiBAIIDgAeUn989w +gADEsMl0nbAwvJ6wz3CAAPQKkgvgBsCgGQSP+fHAEgtAAYDgEPLPcIAA0C4AgFEggIIK8s9wgAA8 +YY4OwAseDaALANjRwOB+8cDaCC/94cXPc4AAFEDPcYAAnGJAgfQTDQBQdQDYivf4EwEAMHIG9/wT +AQAwcsP3AdjRA4/54HjxwM91gABACXzY4g2gASCFABUEEAohwA8BEgU263LPcAAA2w6dAe/6j9vg +ePHAggpAAYDgMPLPcIAA0C4AgFEggIIq8s9wgADML2iISohEKz4LACGAf4AAXC9VeAaIgeAA2Rr0 +z3KAADxhBoIDgGCAAoJieIDgyiBLAAXZCrkwcEr2BoIDgCCAx3EAAAAULg7gC0hw0cDgfvHArgqv ++QPYrsHPdqAA1AcTHhiQDxYQlhkWAJbA4L73ABYBQAAWD0DTuc9wsP4AAAV5z3WfALj/NqVTJ8EU +JXgWpe94nODKIcIPyiLCB8oggg8AAEAAzyAiA8ojgg8AAJgMyiTCAMQA4vrKJSIAi3B2DWANDtkG +FAExABQAMVEhAIHAIKIAA+AEIJIPAAD8/wvAgOBWIhEiEPIapSzAG6UCwB6lz3AAbAQAGaUG8M9w +AAC1DIYOQAEZFgCWUnC59wAhACQPHhiQA9ggHhiQ4NiCDKAB6XEBwAQggA8AAABAKQKv+a7A4Hjx +wMYJj/kIds9woABkLvAgjQPTvQ0SEDYNGpgz9dgFuPYLIALJcQ3Iz3GgABQEAN8KocIJ4AnJcFpw +AdjPcQAAECfPcqAAyB8+ohDZLqIVGhiATCIAoEohACAPIZEj0PcLIEDEBPRRIwDA/PMLIEDEBvKq +Du//AedSd7T3CyBAxBf0USMAwCTyE/AvKEEDTiCBBwDYDyBAAEAuPpUGfQDYBPRAKT6DA/IB2LIM +AAKA5e31CiHAD+tyV9iMuIojnwFKJAAAfQev+golAAENGhg09dgFuEILIAIKcQ3Iz3GgABQECqE9 +AY/58cDeCI/5z3CgAFQuK4AH3dO5LyhBAE4gjwfPcKAAwC+lEBKGFBARhs92oAAUBKqmlgngCYDY +89gFuIDZ8gogAp+5DRIQNvXYBbjmCiACqXGqpg0aWDME8APYBaaphoDlG/KA5frzQS2AkAryLyQJ +cOB4qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKggQAEAFoBA4Hiphufx89hSCiACBbj/uOH19dgFuIoK +IAIKcSgeABSU5w0aGDTKIcUDhffpcYAhwgHPcKAAGCzwIEIAlOfKIcUDhffpcYAhwgTPcKAAaCw1 +eAS/QKDHd4AAzNsVhzaHBXkXh7iHJXgFJQ2QyiHCD8oiwgfKIIIPAADCIcojgg8AAI0HyiRCA0AG +ovrKJSIAgNnPcKAA0BswoM9woADAL6UYmIQUGFiEAQCP+fHAmg9P+aQRAAAodVEgAIAK2MogIQSY +FQEQBCG+jwEAAMB2HQQQMPTouRbyRCEABiO4QWgEIYAPBgAAADG4WGAEIYIPBgAAAddyAgAAAcog +oQAD8AHYgeAP8oLgCPKD4ADYyiDhAcAooQML8M9wgAD0yQKABfDPcIAA9MkBgAV5mB1AEJ4VABGU +HUAQkh0EEIIVABGQFRERsh0EEADYgB0EEH4dBBADyM92oADUB0GQgOIQFZIQCvINyM9xgAAEy/Qh +AACA4BPyGRYAlrjgT/cNzM9xgAAMQUYggAINGhwwGoEB4JcCIAAaoQ8WFJaA4gnyDcjPcYAABMv0 +IQAAgOAD8gHYBfAD2BMeGJAA2AcSDzYBEhA2ABYEQHpwBxoYMQAWBUABGlgxBMqc4MoiwgfKIIIP +AADcDsojgg8AAPQK3ASi+sohwg+pcJIJYA0O2UwjQKAP9ATIAZCA4CHyz3GAAIBCGoEB4BqhHIEB +4ByhF/ADyAGQgOAT8g3Iz3GAANTK9CEAAFMgwIAL9M9xgACAQhqBAeAaoRuBAeAboQMSATYBge64 +DfJUEQABUyDAgAf0z3GAAIBCGYEB4BmhAhUFEUwlAIAU8gGF7rjKIcIPyiLCB8ogogvPICIDyiOC +DwAAtQc4BKL6yiRiAACVsHDKIcwPyiLMB8og7AvPICwDyiOMDwAAuAcUBKz6yiRsABCNUyDBAIYg +/gNEuMQdAhCkFQAQ9rgwrSL0BxICNgIiwQOB4QDYB/ICJ4EQjCHDjwL0AdiA4BT0DczPcYAADEFG +IIACDRocMBmBAeAZoQ8eGJUHGtgzARoYNInwBxrYMwEaGDQA2HQdBBAaCmAAqXDPcYAACHoLYXQV +AhHPcYAAEHrwIQAAemJQeqQVARB0HYQQJXikHQAQBMgBkIDgFPJMI0CgDfQBlbgVjxBYYCCV+GAQ +eL4dBBBZYT9nDfC+FQARCvAglbgVgBBZYThgEHi+HQQQCHeQHQQQDxYAlrQdBBCKDSAGqXAQjTJ3 +zCCBhBLyCiHAD+tyQCkNJEAoDgQw2Iy4ANuLuwUlxBMBA6/6BSaFFKQVABAIdIQkGpAl8lEgQIIe +8gPIAZCA4BryDcjPcYAABMoUeYARAAeA4BL00BEAAWoVjxAB4MO4+GAPeGodAhDODeAAqXBqHcIT +BfDCDeAAqXAPHhiVdQRP+eB48cAiDE/5GnAA36QZwAPPcIAA8CIEgNCJ8KAHyAQggA8AwAAA13AA +wAAAKHUW9A3Iz3GAAATKFHkRiYDgDvTPcIAA8N3WeCKICI0Qccb2CnAWCa/9qXHh8FEgAKCG8gQV +BBBRJACBQPINyM9ygAAEyhR6ERKFAA94SSDCAHJuz3CAABDfdntgYPa4Mo0H8s9wgABQ4dZ4AYgC +8ADYx3KAAFDh1npEigghgQAIIQEAACFAAUkgwQMWbjV4z3GAANDiAGHPcoAA8CJEgs9xgABQ4tZ5 +WIIhgUV5BCGBDwAAAAgmeAPwA4XPcYAA8CKYHQAQJIEogQQhgQ8AQAAAPrlTJAIAHuE4ekV4/riY +HQAQC/KkFQAQjLikHQAQUNicHQAQe/D/uBPypBUAEI24pB0AEM9wQAFQAJwdABDPcIAA8CIkgBCB +nrgQoWfwBdgUuJwdABDPcIAA8CKkHcATJIAQgZ64n7gQoVnwUSBAp0fyAYVRIACBN/ISjTQSgTBJ +IcEAcm7PcoAAEN92e2Ji9roI8s9ygABQ4dZ6QYoD8ADax3GAAFDh1nkkiQggQAAIIIAASSDBAxZu +NXjPcoAA8CJEgs9xgADQ4gFhz3CAAFDi1nhYggGARXgEIIAPAAAACAZ5AvAjhZgdQBANyM9ygAA8 +yhV6IKKcHcATBfAF2BS4nB0AEFEgAKUH8gDYkbikHQAQA/CkHcATdB3EE/oOIACpcM9xgAAIenQV +AhEJYVlhMHl0HUQQz3GAABB68CEAAKQVARAleJgVARBRIUCCpB0AEAryCtl2HUQQeB1EEIC4pB0A +EBbwENnPcoAA8CJ2HUQQQ4JIglEiwIAI8grZeB1EEIO4pB0AEATweB1EENYKr/ypcKQVABBEIH6C +jBWBEBnyz3KAAPAiQ4JUgiR6hiH/A0S5hiL/Djpiz3GAAKhu9CGRAM9xgACAbvQhkgAN8MO5z3KA +ACyyPHn0IlEAz3KAAPyx9CJSAJgVBRBTIASAyiCCBBb0iBWBEFElAILDuTx50SAihQfyz3CAAFSy +9CBAAAbwz3CAAPyx9CBAACGFUSHAgAXyhB0EEAPwhB3EE1ElAIIN8kQlAgYjugHiBCWADwYAAAAx +uBpiAvAB2gPIAZCA4CTyDcjPcYAABMv0IQAAgOAD9AGVuBWDEHQVAREEJb6PAQAAwHlhOGAQeL4d +BBAO9AohwA/rcizYjLiKIxoJDQdv+ookgw8AlefxgeId8oLizCLigMohwg/KIsIHyiBiC88gIgPK +I4IPAAC1BsokIgDcBmL6yiUCAc9wgABQ4dZ4A4gG8M9wgABQ4dZ4AoiMFQEQDrgleIwdABDPcIAA +aAlAgAaCoBAABoDgB/TPcIAA/GIAiIDgXPINEgM2huNY8gCVr+DPcYAAgEKgAAwAz3CAAATKdHgR +iIDgRvRMJACAQvRRIACgPPKeFQARz3OAAGxCirieHQQQFpMB4BB4FrMByOehBaGYFQEQrrmvubC5 +mB1AEAaCoBAABi8oAQBOIIIHI7oO4g8hgACkFQEQmB0AELS5pB1AEJ4VARGnuZ4dRBDPcYAA8GIA +oQQggA///9P2mB0AEA3YmB0CEArwENgH8AjYBfAC2APwAdgHoZgVABC+FQERqg/v/gDapBUBEAQh +vo8AAAAwgh0EEFPyjBUCEJwVABGUHYAQkh0EEOy5gB2EFAMSAzYL8hTYkB0EECpwfh0EEHgTDgEJ +8A7YkB0EEH4dxBN4Ew4BSnDCeBB4sh0EEM9wgACwyQCAhiB/jw70mBUOEFEmQJII9GGTgOMG9JG5 +krmkHUAQELgleKQdABAEIoIPAAAAEM9xgADwImSBUiICAxCDBXpQo0SBEIIEIIEPAAAAED15JXgQ +ohPwmBUBEIAdxBOUHUAQnhUBEX4dxBOSHUQQvhUBEbIdBBCQHUQQgBUAEX4VAhGCFQERGmKEFQAR +WWE4YBB4sB0EEKQVABDPcZ8AuP8WoZwVABAWoakGD/nxwFoOD/miC4/8z3CAAODLDIjPcYAAEN8C +uBZ4AGEtuFMgAIAF9M91gAAUQA3wz3GAAPAiIIHEEQEGz3WAABRAUSFAgQT0AdncHUAQz3GAAPAi +8CEAAM9ygADIYSCCGIiD4UYALQBBHRgQMyZBcIAAWGhAJ4ByNHgAeL4PoAsD2EoPoAtA2ADY4B0A +EA3wz3OgAKggMYMCggDewqI4YOAdABAB2BKjIQYP+eB48cDhxQfYDRoYMM9xoADUBxoZGIAOEQ2G +z3CAAIwVSICA4gcaWDMQ8s9wnwC4/12gz3OAACAhRIMB4rO6tbq4ukSjVqDPcKAASCy+oB8RAIYB +GhgwBMqc4Mwggo8AAJEABfIAFgBAABYAQAPMz3GfALj/GKGKIEYEyg8gAQESATYBEgE2fdiyDKAD +BxICNpUFL/kEyvHAuHECuc9ygAAQ3zZ5MCJEAFEkQILKIsIHyiCCDwAAyyLKI4IPAACTA1wDYvrK +IcIPQC2BAc9ygADQ4iFiUSFAgooiCAXKImEDz3GAAFDhFiFBASKJDrlFeSCg0cDgfvHAugwP+c9y +gABIIUSCz3WAAAijYoVAgja7NrpQc9YijQ8AAIAAwIU9Yn5msXbO9wohwA/rcoogjQKKIxAEmHbl +Am/6uHUeZrF2//dYYNkEL/kOIIAD4HjPcIAAWAoggM9wgADAeuB/8CBAAOB/AdjPcIAA3FvgfwCA +4HjPcYAAPD/gf/AhAADxwJhwCiHAD+tyCiXAB89wAACfGYkCb/o72+B4z3GAABg/4H/wIQAA8cCY +cAohwA/rcgolwAfN2AW4ZQJv+kTbz3GAAFA/4H/wIQAA8cCYcAohwA/rcgolwAfPcAAAoRk9Am/6 +TdvgeOHFz3WAACxDAoVCnYHgz3OAAHg8NIMO9CJ6Tnrk4gCdBPYzg8bhUvYA2AKlAZ0O8EJ5LnmM +IQOCAZ2I9jOD0OHE9gHYAqUAneB/wcXPcYAAkGEGgQOAz3OAANAuQIACgUJ4SCACAPgTAQD2E4AA +InjsEwEBYbgFKT4AQCmAcuB/WGDgeM9xgACsYQaBA4BAgAKBQnjgf0ggAADgeM9xgADwCSSB4H8g +oBGI4H/CuOB4z3GAANhhRoGA4ooh/w8goAXyIoIgoAHYAvAC2OB+4HjPcYAA+GFGgYDiiiH/DyCg +BfIigiCgAdgC8ALY4H7geIoh/w8goM9zgAD4YUaDgOIS8iSCUSFAgAvyz3GAAAhgMHIH8s9xgAAk +YDByBvRAglBz8fUC2AXwIoIgoAHY4H7xwMIKwACA4DgNIgvKICIA0cDgfvHAz3CAAMwvSIgqiEQq +PgsAIYB/gABcLzV4BoiB4Bj0cgrAAIDgFPLPcYAA8CIAgcgQAAaGIH+OCvQBgcgQAAaGIH+OlAoh +C8ogIQDRwOB+8cAmCg/5gOBl8s92gACssi+Oz3CAAFDhz3WAAPAiNngiiAOFAN/PcqAALCA0EBEB +PBISAA6OgOCcACkAyiWpEIwiAaSQACUAyiUlEWSWlOPAI4YPAACTAM9woABoLPAg0ADlolDYRSFB +AhjaEgkgDiDb+LjKJSISLvQD2M9xoAD0BwWhhNoNcECwQiIAKA1yALJAhg1wQKBClg1wQLADhUCA +DXBAoAOFQpANcECwBpZAKAIlw7gMuIK4BXoNcECg5KEOjgHgDq5eD+ALKnAB3RDwAN3PdoAArLIG +CmAJBJYA2M9xgAAMQQ6uHoEB4B6hkQEv+alw4HjxwDYJD/kacIQoCAkAIYF/gABMrIcRDQbPcIAA +nAkCgKC9hxlYAwSIgOAR8gOBgOAN9AohwA/rcsnYBLiKI5wOCiQABGUHL/q4dQKBgOAc9M9ygABI +tBMSAIaMIMOPC/LPcIAASCEEgACAAqEcGhiEFfDPcIAAZCkAGAAEbgggCwDYDfBaCs/+hCgIKQhx +ACGAf4AATK4ODEALAQEP+eB48cCWCA/5GnCKIEwLJgsgAQpxTCDAoM92gADEsJP3HpY6FgURCiHA +D+tyELgFJQUAz3AAAIMMiiOFD9EGL/oKJAAEQCgNId1lJZUElRC5JXiA4Dnyz3CAAKx68CABBEQo +PicAIYB/gADgXi93IKAjlQKVELnKCe/+JXgIcQAngB+AANRefgtAC89wgACgevAgAQQAJ4AfgAA4 +XkeVIKAjlQKVELoQuSV4JpVyC+/6RXmOCc/+CHEAJ4AfgAAsXkYLQAtelh2WANkPIQEEELpFeAYg +QIAB3R22MLgethn0z3GAAJQuAIGguIIPIAYAoc9wgABIIQSAltoe2yCAz3CAAASxoqAhoAzZVgmg +CRi7ENrPcYAA9AoAgQAqAgRGeN0H7/gAofHAeg/P+ADdz3aAAMSwPpYPJQ0QHZYQuSV4BiB+g0H0 +z3GAAJQuAIGAuAChz3CAAJQJz3GAABwmAJBHiRByG/TPcIAAlgkAkEGJEHIT9M9wgACYCQCIJokQ +cQ30C8gEIIAP/v//AwsaGDALyIe4CxoYMM9wgABIIQSAz3GAAASxltoe2wCAAKEA2AKhKHAM2aoI +oAkYuwDY0gmgAIDZPpYdlhC5JXileB22MLg5B+/4HrbgePHA4cW2CqAAKHWA4MogQQMcDOEEyiFh +ACEHz/gxB8//8cCiDs/4eg1gCgDdz3CgANAbEYDvuAvyRgjgCwHYz3GAAIBCCYEB4AmhBshRIACA +AxIONiLypBYAEPK4HvLPcYAASD4AgYDgGPKgoVEhgMX+889woADELKuA39jeCCABqXFTJYEU/r3M +ISKABvKYFgAQdg6v/gDaAxIBNqARAADwuA/yiiAIAAwaHDD62K4IIAGgEQEA2g6gBQPINfD0uCLy +B8jQiQDaMxGPAAQggA8BAADwQSgNA89xoAA4LgeBDyJCAwHcRngHoQ3I2g6gDQAsABDHd4AAEN8C +vtZ+EuffZ6CvAxIBNoogEAAGGhgw+9hKCCABoBEBAAPIoBCAAMTgVAxBDQPZz3CgABQEI6D5Bc/4 +8cCODc/4z3WAALilAYXPc4AAUOJEIASDz3CAAODLDIjSaNZ+x3aAABDfQIYWeyGDE/JQIo8F4KZM +JACBRiEBBiGjBfSRv+CmBPCxura6QKbOCUANBvCWukCmRSEBBiGjC42iuJEF7/gLreB44cXhxs9w +gADgy0yIjCICgM9zgAC4pRjyyovPcIAAUOIyajZ5x3GAABDfVniA5kCBoYAG8pW6QKGrvQXwtbpA +oYu9oaAA2Aurwcbgf8HF4HihwfHAUSAAguHFqAAhAAh1RCUDFgQlgh8GAAAAI7sxugHjemIEJYAf +wAAAADa4z3OAAAB6SmMIY1hgQS2CElIiAgDAugO6GOKF4MoijQ8BAIkN1SIOAFBxUgAlAADY7b0Y +ACEAAiGAAM9xHEfHcQUofgAKIMAOA/AiuEEtQRPAuQS5NHmpcsa6SSLCBVR5673PcoAAsHAyYgXy +QSoBARQhggAFKj4AQSkAcgjcnwTP+AohwA/rcjvYjLjPcwAAVxJKJAAAfQIv+golAAHxwAYMz/jP +cIAA4MsMiIwgAoAr8jJoNnnHcYAAEN+ggc9zgABQ4s93gAC4peSXFntBg1AljhWGJ7sfwKGMJ0SQ +RiICBkGjBfSRvsChC/CxvYHntr2goQf0lr2goUUiAgZBozYIQA0A2c9wgAC4pQEE7/grqPHAiiBP +CyYO4AD52f4IAADRwOB+z3GAAJghCYGA4AvyB4GB4An0FokB4A94kOAWqQP0ANgWqeB+8cBaC8/4 +z3WAABCxCIXguKzBWvJRIMCBVvTuDK//AN6qC6/7GNiLcalwSgogCiTaAdnPcKAAsB85oM9xgABI +IQiBAIDPd4AAmCFJwAyBAIAw2UrABoeQ2h7bS8CLcMIMYAkYu8G1yKXBpdytw6cqDCAAAtjPcIAA +eOcKEAQBTCQAgAvyCiHAD+tyiiBfBmnbOQEv+rh2Pg2gCslwRocB2c9zgADYIQCDgeLAeYDiOGAA +owHYz3KAANAhIILAeDhgAKIE8A4IAAD5Au/4rMDgePHAC8gFIIAPAQAA/AsaGDDCDs/4rgmv+wvY +rgsgAADY0cDgfs9wgACYIeB/CIDgePHAAdjPcYAAmCEDoc9wgABIIRCAAIAEoQKBgeDQCYH60cDg +fvHANgrP+AAWAEDPcIAA2CUPgFEgQIEN9AohwA/rcoogXwSQ24okww99AC/6uHMAFgBAz3WAAAjo +AKXkbelwJg2gDA/ZVSVOFMlw3gygDCKVxgpP/ggVBRBRJQCEC/QKIcAP63KKIJ8EmNs9AC/6SiRA +AM9wgACkYiCAQIVAoSCAHNpAqc9xgAAkCyOlGNkioFUlwRUloOGgIYXDoCSgANhaHQQQAoWtuEoN +r/8CpYDgF/TPcIAAeOclkIDhiiCPC8f2DgzgAKvZEgkAAAbwAgzgALDZmggAAB4JoAkN2MEBz/jg +ePHAiiBPDOYL4ACP2b4Oz//RwOB+8cDPcIAA+G7PcYAAmCFKCCAKONrqCKAJANjRwOB+4HjxwLoO +z/8A2YLgzCBigMogQgAD9AHYD3jRwOB+8cDPcIAAmCEgEAUATCXAgIv3CiHAD+tyiiBfBVbbVQfv ++UokgADPcIAAMG/wIEABQHjRwOB+4HjxwMoIz/jPcIAASCEEgADelr6ggAQljR/A/wAA3WUU5QAl +jx+AAAAARgqv/qlwCHHPcIAAFF3+CwALNgqv/thlCHHPcIAAMF3qCwALIgqv/ulwCHHPcIAA+Fza +CwALz3CAAJghzQDv+OCg4HjxwFoIz/jPcIAASCEEgADdlr3ggAQnjx/A/wAAv2cQ5wAnkB+AAAAA +2gmv/ulwCHHPcIAATF2SCyALv2fPdoAAeOcFliWGCrj5YboJr/4OIEAACHHPcIAApFxuCwALpgmv +/ulwCHHPcIAAaF1aCyALv2cFhh9nBZYKuIoJr/4OIMADCHHPcIAAwFw+CyALAnVyCa/+CnAIcc9w +gAC8XSoLAAvPcYAAmCEAGQAEBZYlhgq4uWFOCa/+DiBAAAhxz3CAANxcAgsAC/UHj/jxwJIPj/jP +doAAmCGghgDflr/9ZSIJr/6pcAhxz3CAANhd2gogC/1lDgmv/qlwCHHPcIAAhF3GCgALwQev+KCm +8cBSD4/4z3CAAJghwIAA35a//mbiCK/+yXAIcc9wgAD0XZoKIAv+Zs91gAB45wWVJYUKuNlhwgiv +/g4gQACYcM9wgABsXHYKIAuIcaoIr/7JcJhwz3CAAKBdYgogC4hxz3CAAJghwKAFhf5mHmYFlQq4 +hgiv/g4ggAMIcc9wgACIXDoKAAs1B4/44HjxwMoOj/gIdc92gACYIYogTwpOCeAAKIYIhhB1RfeA +5colAhAC9KimiiCPCjIJ4ACpcQUHj/jgePHAkg6P+CYMz/+B4AzyCiHAD+tyiiCfBaHbiiTDD+EE +7/m4c891gACYISOFgeEChQ/0geAA2QXyFI2A4AXy+grv/yalDPAjpQHYBqUI8IDgBvQB3r4KYAnG +pcKlz3CAAHjnChAEAUwkAIAM8gohwA/rcoogHwbA24UE7/lKJQAAfQaP+PHAUgrP+OB44HjgeOB4 +aSCAAW8hPwBpIAAA9/HxwOoNj/gacM92oADQDwDdB/AQFgCW/WH4YBAeGJAjbRJxcgANACUWA5Yl +FgKWLyTHACUWAJZPfw99TCQAgwi9pX/p9YLnzCfik8wnIpfKJUIQIfTPdYAAULFJrSUWApYKrUut +JRYClmitj+dMraJpCPTPcIAAXbH+C+/4DdkN5ZznCfTPcIAAarHuC+/4DdkN5RAWAJYCIEEjOGAQ +HhiQrQWv+AHY4HjxwEoNj/ihwQh1KHaE5QDYmPeLcLoL7/gE2QDA13CaCVBvC/LPcaAA1AsPgWS9 +uGAPoQHYBvCpcCIP7//JcQ94dQWv+KHA4HjPc4AAlC5Ag4DhRXgAoxryz3GAABwmz3CAAJQJAJBH +iRByG/TPcIAAlgkAkEGJEHIT9M9wgACYCQCIJokQcQ30C8gEIIAP/v//AwsaGDALyIe4CxoYMOB+ +8cDPcIAA7AoAgIDgCvLPcYAAaD0LgQHgC6HeDG/6AtjRwOB+8cDPc4AAYAlocFIMIAAE2QRrSgwg +AATZ0cDgfgDYz3GAABgKAalFBuAMAKnxwOHFWgnv/DHYtGhSCe/8M9gFfRi9z3CAAJxowgogCpC9 +KLipBK/4pXjgeOHFMmg2ec9ygAAQ3yFiz3KAAPAiLbnAufAiQwAog1EhAIDPcYAA9MlBgQnyPIuA +4cUigQ8AAAoCA/JFIkIDSiQAdADbqCCAAjZodXkAIY0PgADQ4kClAeMA3c9zgABQ4RYjAgCgqqGq +AdkiqgPZI6pKJABxqXKoIMABeWIWeaSpAeLgf8HF4HjhxUokAHgA2KggAAgA2891gAAgIUCFDyMD +AAsiwIAP8kGFCyLAgEDazyLiB8oigQ8AANAAzyLhBwLwANrPc4AAjBUVe0CjAeDgf8HFz3CAAHxi +BoADgCCAz3CAANyfKaA1Ay/8EdjgePHAOguv+AHZz3CAADwppg+v/iSgiiDFD892oADIHxkeGJAB +2AHZKHIoc3YKYAGYcUoKb/sA31YNT/vPdaAA0A/1pc9woADAL3oQAYaJuYu5ehhYgM9xgACA1RAY +WIAF2fQYQIASDUACNgiP/vIOQAlA2c9wnwC4/zKgtg5ADIDZz3CgABQELKAdHViQ5g8AC04OwAqC +DSAL6XAH2EgeGJBaC4AHmgkAAk4LQAAKCsAExg9ACTYOQASKDsAJcgxAAOYNwAjiDQ/7xgxAAcIL +wAoeCc/+wgrABQYMgAEeCoAHGguABqYIAAXaCw/+KguABSILgAVyCoAJz3AAAP7KHgzP+qECj/jg +ePHALgqP+KXBz3eAAPAiA4cIgMC42g5gCy8gACAA3c92oAC0R89woACMRLigANiTuHceGJAI2Hce +GJAA2J64Ux4YkOB4Ux5Yk89wgABYAhB4Rx4YkM9wgAA8BRB4SB4YkE8ggCNFIAANTyDGBzTYRB4Y +kBzYRR4YkEYeWJPPcIAAXD/SCGAGDIhKJIBwz3GAAJjnqCCAA89ygAD0yQGCdG10eztjA6MCggHl +BKPPdYAAmGIAhYDgBPJkHhiQQx6YkS4LYAsB2AOHCIBRIACAQIUN8lMiQQASuUQiAAMOuCV4hiL/ +Awq6RXgR8EhwhiDzDwq4BCKBDwAAAAwGuSV4BCKBDwAAADACuSV4z3GAANAwAqGLdalwzg8v+hTZ +ONhkwADYBNnuDGALqXLPcAAGGwBOHhiQXQGv+KXA4HjxwOHFEN3SDCACqXAH2Qu5z3KgAPAXMaLP +cQAA8P84orKitgkAAkkBj/jgePHAygiv+ADaz3CAAJwJQ6D/289wgABItBMY2IBKJIBwSHGoIEAH +hCkICQAhjn+AAEiuz3eAAPhhQaYG3aWmz3UCANxApKZGpuemJB6CEAAhjX+AAGiuQKUB4c9wgABI +tBwY2IDPcYAA9C0AgRzaQKAY2A4IIAACobkAj/g52c9wpQAIDD6g4H7/2c9wgAAkrCCoANnPcIAA +zKvgfzWg4HgA2oDhyiRNcOB46CDtAf/ZXGAgrAHi4H7xwOHFz3GAAFjJz3CAADx6Gg+gCUjaz3CA +ALByz3GAAKQKCg+gCQjaAN3PcYAAXDWhoaKhz3CAAHQ4qaDyCCADA4HPcKAALCDPcYAA5DhQgBCA +RaEGoSIIoAKpoS0Aj/jxwADZz3KAAMSwIKLPcIAAlC4goD2yMLk+stHA4H7geOB+4HjxwI4Pb/gg +2QDaz3WgAMgcKaXPcaAAlBNboc9zgACsFmCD82jPdoAAVMsMhvV/UyDEBfBj+2NTII8Ag+ekwYtx +G/Qfhpu4H6Y0FoAQ4ovxcAv0KHBAIwEERGtCD+AKQCYDHA3aKvAehpG4krgeps9woADMFyvwhecO +9EEqAlJAIwAEwboWCu/8iHMfhpy4H6YN2hTwLLhTIAIAH4YDupm4H6bkgwXiBScAEQChBYMBoQaD +AqEHgwOhA+LPcKAAzBfPcaAAlBNcoQHagOIH9B+Gl7gfpiDYCqUY8ADBA9oYGFiAAcEZGFiAAsEa +GFiAA8EbGFiAFBiYgIoWAREQGFiABNknpRYYmIDtBm/4pMDgePHAfg5P+KQQAQD5uaLBcPQg2c9z +oADIHCmjpBABAFEhwIEu8jGIz3WgABAUI7nAuQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwnw58I +9AQUDzHxdswn6pAB3kP2AN6A5ur1xYBFfselsYiGJfwfGL2les91oADMF1qgF/BFgM9xoAAQFEeh +pBABAFEhgIIJ8jGI17qGIfwPGLlFeTqgz3WgAMwXDdkB2gPhDR2YkA4dWJAmgBkdWJAngBodWJAo +gBsdWJAD2RQdWJBwEAEBEB1YkHAQAQHPdaAA9AcE4SelR6OkEAEAmbmkGEAA+QVv+KLA4HjxwIoN +b/gE2Qh1DRIONgbYDRoYMM93oAAUBAqnz3CAADB6qg2ACQCFog2gCQTZAYWaDaAJONkIFQQQTCQA +gAGFABAFAQTyDCRAgcr3CiHAD+tyGdiMuKUDr/lv2wOFbg2gCYhxAYVChSCQBYVeDaAJQnnKp30F +b/gNGpgz8cAODU/4CHbPdYAA7AoAhYDgKHcF9IDm4iCCAy3wiiALAIYPYACKIUkDiiALAHoPYADp +cc9wgADMYMoPgArPcIAArC7PcYAAuArAoACBBX/goc9xgABoPQKBAeACoQTwigmP+QCFgOD89c9w +gADwCgCAgOD29QEFT/jgeM9yoAD8RDmCBCG+jwAACCAA2AX0PYL5uQLyAdjgfw948cAA2Jy4z3Gg +AKwvHKEagVEggIIagQzyqrgaoRqBUSAAgPHzTgtv/AHYC/CKuBqhGoFRIACA5/VKC2/8AdgA2Zu5 +z3CgANAbMaC2CcAMVg+ADM9wgAAUPQCAQiAAgMogYgDRwOB+4HjxwOHFz3GAAMSwfpFdkRC7ZXoR +IgCAAd0M9M9xgACAXkQoPgfaDqAKACFADqlwA/AA2FEET/jgeEaBgOII8iOBYIEigmJ5MHAA2AP2 +AdjgfvHAvgtP+Ah1z3aAAPhh3g/v/8lxgOAJ8qlw0g/v/0AmARiA4AP0ANgK8M9xgADYYboP7/+p +cIDg9/MB2O0DT/jxwOHFz3CAADgmCIiI4KHBB/TPcIAA0C4AgO24H/LPcoAAzDBoEoCAz3OAADow +gOAT8msSgICA4BP0ahKAgFEgwIEL8s9wgADQLgCA4bgF9FEgAIAD9AHYXPAA2FrwgeAT9G4SgICA +4AHYwHhgwJYKIAmLcHMSgICB4Ev0bhKAgIDgR/Is8HMSgYCB4QX0gxKAgIHgCfKB4UoADACDEoCA +geBCAAwAbhKAgIDgBfRvEoCAgOAD8gDYAvAB2GDARgogCYtwcxKAgIHgI/RuEoCAgOAG9G8SgICA +4BvyANhgwBfwgeEB3W4SgIDCJUETgOAF9G8SgICA4APyANgC8AHYYMACCiAJi3CoY4Dg6PUgwOEC +b/ihwOB4z3CAAKgIDoCA4AHY4H/AePHA6ggAAIDgBfJeCQAAgeAH9M9wgABoKQCAgOAD9ADYFPAy +CgAAgOAP9KYJAACA4Av0z3CAADgmLJDPcIAA8CIekBBx7fUB2NHA4H7xwAYKAACA4CD0sg3P+YLg +BPIA2NHA4H7PcIAAOCYIiIfgDfKI4BL0z3CAAPAiAYDEEAAGUSBAgQjyz3CAANAuAIAjuMC46PEB +2ObxvQIgARHY4HjxwLhwz3GgAKwvGIH6uAzyCiHAD+tyiiCMCWfbBQCv+UokAAAVgVEgAIAM9Aoh +wA/rcoogzAlo2+kHb/lKJAAAAdjRwOB+4HjPcIAA7AoAgIDgzCBigAT0ANgF8Ijg/vMB2OB+8cDP +cYAAtgpgic9wgAC3CkCIhCsfAAAhgH+AAJzTMODwIIAAUSAAgAX0KggAAIDgA/QA2AzwIInPcIAA +WM2EKR8ANCBADoDg9fMB2NHA4H7PcIAA7AoAgIXgAdjgf8B4z3CAAOwKAICG4AHY4H/AeM9wgADs +CgCAh+AB2OB/wHjPcKAAxCwagOe4BvRRIACBAdgD9ADY4H7PcIAA0C4BgIHgAdjgf8B4z3CAANAu +AYCC4AHY4H/AeM9wgADQLgGAg+AB2OB/wHjPcIAAWAoggM9wgADAevAgQACA4AHY4H/AeOB48cDG +D+//4cWA4Bzyz3WAADgmCI2H4Bb0zg/P/4DgEvLPcIAA8CIekCyVEHEM9M9wgADQLgCABCC+jwAA +OBAE9ADYA/AB2J0Ab/gPeM9wgABYCiCAz3CAAMB68CBAAIHgAdjgf8B44HjPcIAA0C4BgIDgAdjg +f8B4z3CAAFgKIIDPcIAA5HrwIEAAgOAB2OB/wHjgeM9wgABYCiCAz3CAAOR68CBAAIHgAdjgf8B4 +4HjPcIAA7BcAiIDgB/LPcIAA1BcBiALwAdjgfuB4USFAxwXyCci9uAkaGDAA2Z25z3CgANAbMaDg +fvHAhg8P+M91oADIHyQVDpbovgryhRUAlooJD/uKIAQAJB0YkOK+CfKKINcK7glgAMlxEgzADL0H +D/jgePHARg8v+DTYPgnAAPC4z3eAAACWFfLODmADANiiDmADAdiKJhAQAN0+Cq/+qXAUJ0wTYb6A +5gC0AeU49w7wANuKIhAAKgsgBXB4FCfMEGG6gOIAtAHjOPdVBw/48cDqDi/4NNihwQDd3gjgAEDF +8LjPd4AAAH4Z8pYNIAEB2APeCr4A2Iy4uGAQeItxlg4gAQHaFCdME2G+gOYAtAHlM/deDQABEPAF +2wq7A9oKunhlvgogBRB4FCdME2G6gOIAtAHlN/fpBi/4ocDgeM9xAQBcds9wgADEG+B/JKDxwOHF +b9iVuM91oADIHxIdGJDPcAEAQDwVHRiQcgwAC4ogBAAOpb0GD/jgeADYkLjPcaAAyB8VGRiAz3CA +ALDJRpBbek8iAwBaEQKGOBCAAGR6WGDYGQAA4H7geOHFANvPcoAAxKVKJAB0z3WAADymaHCoIAAC +QCUBEhR5YLEB4Ehwz3GgAAQlD6FWIgAEEaFWIgAFEKHgf8HF4HjxwM4ND/jPdYAA8CIFhc92oADE +J3UeGJAMlXYeGJAHhXkeGJAQlXoeGJCmDe//AN+A4Bzydx7Yk3ge2JOAHtiTgR7YkweFhh4YkBCV +hx4YkAeFih4YkBCVix4YkAWFiB4YkAyViR4YkAWFhB4YkAyVhR4YkMHYUB4YkL0FD/jgeOHFCHHD +uM9ygABEpvQiAwDJu3BxyiQidMogIgDoICIC9CINAMm9sXEC8gHg4H/BxfHA4cUIdc9xoADEJxkR +AIYB2oDgEREAhsB6gOIApdEg4YcA2Db0z3CAANDLDIDPcaAAyB9k4B6hENgOoQHYFRkYgDYNoAwL +2FEhAMbKICIAG/RRIEDHE/LPcaAA1AsWgTiBJOAwcEv3Dg2gDAPYUSMAwAX0USCAxAPyGNgC8ADY +gODKIOIEz3GgAJAjPoEgpQUFD/jxwIoMD/jPdoAA8CIVJgEQQIFpgriKQSvAAMC4F7jHcAAAgBzk +u88gIgbgu07fzyCiAMongh8AAE4BhuXPJ2ES5bsW9M91gAA4JhgVBBG+lpB1D/ShhsQVDRZRJUCR +CPSghsQVDRZRJUCRA/KBuFEjAILPIKIFG6L8okCBz3A6BEpwHaKggQfYAg6gAAq4BCCADwcAAAAw +uIfgVgANADMmAHCAAHBoQCeBchR5AHmKIAQAHqUY8IogEAAepRTwANiLuB6lEPAA2Iy4HqUM8ADY +jbgepQjwA9gMuB6lBPAA2I64HqWCIAEBCQQv+B6lCiHAD+tyjNiNuL7bi7tKJAAA+QFv+QolAAHx +wM9xgAAEQheh4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +0cDgfuB4IYAA2lMhfoAL8gDambpRIUCAyiKCDwAAgwDAKmIGz3GgALRHTBmAgGaQSCMDA0eQELsE +I4MPDwAAAMi6RXtIkAy6BCKCDwAAAPBlelAZgIBAgIPiKvRigM9ynwC4/32iRYBcGYCARoBgGYCA +R4B8GYCASIBkGYCASYBoGYCASoCAGYCAS4BsGYCATIBwGYCATYCEGYCAToB0GYCAT4B4GYCAUICI +GYCAQICI4hP0RYCcGYCARoCgGYCAR4C8GYCASICkGYCASYCoGYCACoDAGQCAz3AAAFVV4H7gePHA +ZgoP+Ah2AYDPdYAAICEApQKGz3efALj/AaUA2AKlz3DQ/gAAog5v/wSlANgdpwCGh+DPdqAAtEcX +9I4KAADPcAM/Aj+bHhiQz3AJPws/nB4YkADYl7hMHgCQbyBDAJMeGJAF8G8gQwBMHgCQVg4P/gCF +/7gX8s9woADIOx2AgOAR8s9wgACMFR+AgOAN8h2nBIUB4LO4tbi4uBanBKUD8ADYHafPcAAAVVUh +Ag/4IpBIIUEBQCkCAyOQYoDLuY+5RXnPcp8AuP99os9yoADsRieiI4A1oiSANqIFgBeiz3AAAFVV +4H7xwHoJL/gA26bBz3GAACAhYKFhoWKhz3agALRHLBYBkAokgA8AAFVVSiQAeGhxqCBAAs9ygACM +FTV6YKIB4QDZmLmVHliQSiSAcc9ygAAgIQgSBQALEJAAAN05ddh1qXKpcxl1qCBBBL9g5I+/5wAg +SgMG8hUkQTNgoQHjSicAAA8nRwMLIMChCfIVJEEzIIFKIwAQDyNLEAPwSiMAECqICyHAgQUhyRIJ +8hUkQTMggUonAAAPJ0cAA/BKJwAAgOcFIsIBD/QVJEEzIIEMEAUAP98KJIAPAACt3g8gSBAEGsIT +iecH9BUkQTMggQDaDyJCAIjnCPQVJEEzIIFKJgAADyZGAAHlz3WAACAhCB1AEYDjyiSBDwAArd43 +8iWIZIgGIoIBxboQuQUjgw8AAAA/ZXkFIYEPAD8AAJseWJBniCaICLtleWiIELtleWmIGLtleZwe +WJAGIQESxbmfuZkeWJAA2ZUemJCZuUweQJAkgFgeQJAKkJQeGJBvIEMAkx4YkFoMD/6IcFUAL/im +wOB44cXhxs9yoADARs9zoADgRkokAHIA3aggAAMWIE4DIYYB5QQaUAAihgQbUAAxgM9yoAC0R5ga +WIAygLMaWIATgLQaGIDPcAAAVVXBxuB/wcXxwLTBBdgVuEHAz3AfAP//QsAA2UPBRMFFwUbBR8E/ +2EjAScFKwUvBTMFNwU7BT8FQwVHBz3AAAP//UsBTwHYP7/+LcLTA0cDgfuB44cXhxiSIz3KAALh6 +pojCuS5iANkPIYEDgOXPc4AApKpAgwX0JnpAoxfwRXkgoyWIFSONAyOlJohFiFlhJqUggIwhEIBE +94ohEAAgoCO5IaMAgCq4AqMA2c9woADwNiygI4MloCaDJqAkgyegJ4MooCWDKaAogyqgIYMroCKD +LaAggySgwcbgf8HF4HjxwJ4Oz/cId5pxunLacwoiACEKI0AhCiGAIc9wAADIG6YIoAAKIMAh+nDP +cAAAzBuWCIAAG3DPcAAABByKCIAAz3agAMgfO3AB2BOmBtjPdYAAOEMApeGlCB0AFQwdQBUQHYAV +FB2AFBgdwBQcHUAUDsAgHQAUz3GAAEghCaUEgQCACqUIgQCAC6UMgQCADKWgFgAQDaWkFgAQDqWo +FgAQD6XPcEN1qBIQpR4IoAAo2BGlFgigAADYEqVTJ8B1E6UByFQdABcWpRIWAJZQHQAXF6UTFgCW +z3GgAMgcGKUUFgCWUyECMxmlFRYAlhC6GqUkFgCWG6UWFgCWHKXPcIAABEIXgB2lz3CAADhDeBiA +Cs9wgAA4Q3wYwArPcIAAtEMEGAALz3CAADhDhBhACyiBiBhAAM9xgAAAACSBjBhAAC8hxwUIuSV6 +LyEHBkV5kBhAAMoJoAAl2YUFz/fxwGoNz/fPc4AAzENDgwDdz3agACwg0IbyavR/f2fFpwSnAeKM +IgiAJqdDo4X3AoOjowHgAqOdBc/34HjPcYAASCEIgQDaQKAMgQHZQKDPcKAAsB80oOB+8cAWDe/3 +iiBMDaIP7/+KIZgEC8gA3gQggA////8DCxoYME4OIADJcM91gACcCRGFgOD0DCIAyiBiAEkF7/fQ +pfHA4cWOCSAACHWMIP+PCPSKIAcKVg/v/6lxANgtBc/38cC2DO/3atiiwYtxAdo+CuAASHOA4BD0 +CiHAD+tyz3AAANIUiiPFBIokgQr1Ai/5SiUAAEAkgTFE2AHaDgrgAEhzgOAP9AohwA/rcs9wAADT +FIojxQWKJAEByQIv+UolAAAGC2/4BhQAMYDgSPKBwWvYAdrWCeAASHOA4A/0CiHAD+tyz3AAANQU +iiOFB4okwQqRAi/5SiUAAAQUADFAJIEwAdqmCeAASHOA4A/0BBQFMQohwA/rcs9wAADUFIojRQhh +Ai/5iiTBCgIUADHPdoAABGcbeEEoxQBMJYCMAB5AEdT2CiHAD+tyz3AAANUUiiOFCS0CL/mKJMEK +HdjPdoAABGcAprhwABQAMc91gABU70AtggCpcTIJ4AAB24DgD/QAFAQxABYFEAohwA/rcs9wAADW +FO0BL/mKIwUMQIaA4gDY0fYWJQEQYImGI/8NI7uB4wb0YYmA4wTyYrthqQHgUHCx9gDYuQPv96LA +4HjxwDILz/enwTpwenEaclpzi3DPcYAAmGnuC+/3GtrPcYAABGcggQDYgOG4ccQALgCKJf8fz3GA +ALgXABGEAIom/x/JdQLw6XZMIYCjAdrPcYAAVO8WeWCJwiKMAEQjjwD9f/FyPfThiUQjAgQkukQj +BgJBLsYADCCAoUQjAQEiuS/0TCRAgA70gOHMIiGAB/KB4cwiYYAA2gL0AdpPegXwgOIB2sB6geIb +9EwiAKYB2sIiigBQcYYj/Q8nuwXygOLMIGGgDfQyd8wjIYAL8oDnA/KA4wXyMncD9vF2hfbJdwTw +AdkJ8Ah1AeCwcFoHxf8A2Yog/w+A4QT0gOXKIEoDjCD/j8oggQ//////FfIyJII0geLPcYAAVO8H +9GJxFnkCEcAACfCC4hZ5BfQGEcAAA/AHEcAAVQLv96fA8cDaDM//dNiWDO//iiFLCr4OD/9CCYAI +5gsP/wohwA/rcj3YiiMLDkokAABJAC/5CiUAAfHAz3CAAPAiAoDCEAAGUSBAgOQMQgfRwOB+4Hjx +wK4Jz/cacCh1OnLPcIAANLFWCK/5RNnPcqAA1At+ggAlgR8AAABAz3CAAHAKYnlgoM25z3CAANDL +L6IMgM9yoADIH2TgHqIQ2A6iAdgVGhiATXCGIPwD0ODMIIKPAACAABLyjCADhBPyCiHAD+tyCiSA +Cs9wAAAyEYojGg2pB+/4uHMKcGYPb/oqcgTwvgmv+QpwgOAc8s9xnwC4/89zoP6UBnahFqHPc4AA +VMs/gwDanOCzuT+jz3GAALilS6nPcYAA7KJMscoggQBBAc/38cDqCM/3z3CgAMQnUhABhkEQAIaG +IOOPAN0G8uu50SGigUvyz3CAAPAiA4AJgM92gAA0sVEgQIEX8hoLwASA4An0FI6B4MogIQGgCyH/ +yiFhAM9wgADwsQCAUSCAgAXy6gqgABCWtK7PcIAA8LGgoE1whiD8A4wgAoAb9M9xgADwFwCBAeAA +oc9wgADwIgOAGIiE4PgNwf6KIEcN4grv/4ohywNmC8AEYgxP+gXwjCADhCAKgfmhAM/34HjxwCoI +z/cA3gLdz3eAADyuQCcAG4QuCBkwIEAOUSAAgNAOov7KIIIDYb2A5QHmMvcOCCAAANhdAM/34HiA +4PHAENgK8lYIj/oyCuABiiAEANHA4H4OD0/65gngAYogBACGCUAKguAG9KIJYAoA2PLx8PHgePHA +ug+P9892gAD0CgDdC/AQ2Lh4CyEAgAQPov7KIEIDAeWD5SCGtveA4cogIQD0DKEDyiEBAPEHj/fg +ePHA4cXPdYAAnAkQhYDgIfQmCUAKguBECWEKyiAhAAHYEKWSDm/6EdhWCKAAENiA4BGlCfJ+Dm/6 +ENhWCeABiiAEAM9wAQAcBCYKb/+A2aUHj/fgePHAKg+P9892gACcCc91gADQKQOG8CUAEEB4gOD7 +83kHj/fgePHAz3GAAPApAIHXcACAAAAF9CYLz/vRwOB+AIHXcABAAAAO9M9wgABIISSAIIFuCe// +iiBMDN4Jz/vv8e3x4HgB2s9xgABsKUOpGKEocGTZddoe23EAYAgYu+B48cDPcYAAnAkDoQ4Pb/oR +2OYI4AGKIAgA0cDgfvHAjg6v9wHaocGB4M9xgABoKUChLfTPdYAALLAahYwgw48K8gDahCgICQAh +gX+AAGyuQKnPdoAAnAkMhoDgB/KKD+//C4YA2Aym/9gapfIMYAmLcIDgDfICDsAEAMHPcIAAZCkg +oNYNoAkA2BHwVg1v+hHY5g3ABCYI4AGKIAgAxg8ACoLg5A8hCsogIQBtBq/3ocDxwM9wAAAgTsYN +wAvPcYAA7CkAoc9xAAC4C89wgABYKSCgz3AAAIgTpg3AC89xgABcKQChz3APAEBClg3AC89xgABg +KQChBdiGDeALC7jPcYAA8C0AodHA4H7geM9xoACsLx2BlrgdoeB+4HjxwDoJAAAOCCAAANjRwOB+ +8cAY2ADZz3I/AA8Irg3gCwLbz3CAANhhI4BAgQXwAIFCeIXgGfbPc6AAIDEAg8C4geAB2MB4LyYH +8PPzDdgBo6IPz//PcT8ADwjKD6//iiBYAtHA4H4KIcAP63LPcAAAoiiKIwcOSiQAAIED7/gKJQAB +4HjxwOHFz3OAANhhI4OggQfwAIGieIXgYAAJAM9yoADAL1gSAAbAuIHgAdjAeC8mB/Dw81YSAQaj +g2CFB/AAhWJ4heBSAAkAWBIABsC4geAB2MB4LyYH8PTzVhpYAOS5KfIEIYEPgP8AADYPr/+KIFgD +ANgg8AohwA/rcs9wAACjKIojCAQKJIAPoAAYMekC7/i4cwohwA/rcs9wAACiKIojBw5KJAAA0QLv ++AolAAEB2M0Ej/fxwFIMr/eKIBgD4g6v/wDZz3WAANhhI4VAgQfwAIFCeIXg+gAJAM92oADAL1gW +ABbAuIHgAdjAeC8mB/Dw80AWARZDhWCChSHCBwfwAIJieIXgBgEJAFgWABbAuIHgAdjAeC8mB/D0 +80AeWBADhSCAA4VAgAbwYIBCe4XjvAAJAFgWAxbAu4HjAdvAey8mx/Dz81wWABbjhQQggg8QAAAA +13IQAAAAAdoEIIMPAQAAAMB613MBAAAAAdsEIIAPAgAAAMB713ACAAAAAdjAeOCHIn+MJwedCvaA +4swjYoDK84DjzCBhgMbz9gsgDATYI4VAgQfwAIFCeIXgXgAJAFgWABbAuIHgAdjAeC8mB/D08wbY +Qh4YEKUDj/cKIcAP63LPcAAAoyiKIwgECiSAD6AAwDCRAe/4uHMKIcAP63LPcAAAoyiKIwgECiSA +D6AAMDFxAe/4uHMKIcAP63LPcAAAoiiKIwcOSiQAAFkB7/gKJQAB4HjxwOIKj/cIdc9wgADYYSOA +YIEH8ECBYnqF4ooACQDPcqAAwC9YEg4GwL6B5gHewH4vJofz8PMH2UIaWABjgMCDBvAgg8J5heF2 +AAkAWBIBBsC5geEB2cB5LyZH8PPzVRIBBmOAIKXAgwbwAIPCeIXgbAAJAFgSAAbAuIHgAdjAeC8m +B/Dz81QSAAYBpeoMr/+KIJgCiiCYAt4Mr/8hhbECj/cKIcAP63LPcAAAoiiKIwcOSiQAAJkA7/gK +JQABCiHAD+tyz3AAAKMoiiMIBAokgA+gABQxeQDv+LhzCiHAD+tyz3AAAKMoiiMIBAokgA+gABAx +WQDv+Lhz4HjxwN4Jj/cIdwGIz3KAACBnRiABBi94Ia992SCvgLhgikYgAAZTI0EAA7kleAGvAePP +doAA2GEjhmCqQIEG8ACBQniF4LgBCQDPdaAAwC9YFQAWwLiB4AHYwHgvJgfw8fNAFRAWQ4YKcCCC +hSDCBwfwYIIie4XjxAEJAFgVAxbAu4HjAdvAey8mx/D080AdGBBDhiCCBvAAgiJ4heB+AQkAWBUA +FsC4geAB2MB4LyYH8PPzXBUAFgQggA8BAAAA13ABAAAAAdjAeIHgP/QjhkCBBvAAgUJ4heBCAQkA +WBUAFsC4geAB2MB4LyYH8PPzXBUAFgQggA8CAAAA13ACAAAAAdjAeC8mB/Af9COGQIEH8ACBQniF +4AYBCQBYFQAWwLiB4AHYwHgvJgfw9PNcFQAWBCCADwEAAADXcAEAAAAB2MB4geDk8wOGIIBBhwbw +YIAie4Xj5AAJAFgVAxbAu4HjAdvAey8mx/Dz81IdmBADhiCAQIcG8GCAInuF47wACQBYFQMWwLuB +4wHbwHsvJsfw8/NTHZgQiiDYAuIKr/8gh4og2ALWCq//IYcjhkCBB/AAgUJ4heCEAAkAWBUAFsC4 +geAB2MB4LyYH8PTzBNhCHRgQI4ZAgQfwAIFCeIXgXAAJAFgVABbAuIHgAdjAeC8mB/D080AdGBRJ +AI/3CiHAD+tyz3AAAKMoiiMIBAokgA+gAMAwPQav+LhzCiHAD+tyz3AAAKMoiiMIBAokgA+gADAx +IQav+LhzCiHAD+tyz3AAAKIoiiMHDkokAAAFBq/4CiUAAeHF4cZBLQBUwbiD4An3MyYAcIAATGhA +J4FyFHkAeQDYF/DPcYAAVMuYEYAAQCgCBoYg/Q9SIMABRbhFeM9yoACIJBCiH4GzuB+hSvAB2BDb +z3GgAMgcaaHPc4AAVMuYE40AANrPdoAAIHbGhkAtARaGJf0fUiXNEcV5Rb2lec91oACIJDClP4MC +3UQoPg0AIYB/gACI3ZW5P6PPcaAA8Be9oaSAihMDAaaho4AU46ahooBTI8OApqGhgKahwCAhCMAg +IgxggHOhbGhgg3Oh+BADgnOh/BAAgBOhSqHBxuB/wcXgePHA4cWhwQh1z3DUuv7KQMAE8CYP4AsB +2M9xnwC4/7qhBNgboYtwHqEA2p26z3CgANAbUaDPcABtABAZoQTw7gpv/zDYUSFAx/vziiCbBfYI +r/+pcYogmwXqCK//AMEAwNdw1Lr+ytfzuQZv96HA4HgA289ynwC4/xqie6I+os9wAGwEABmi4H7x +wCYOb/eYcCh2GgggAEh1BiCBA4hwUgggAKV5dQZP989xgAAMLmCJgOPPcp8AuP8F8s9x0Lr+yj6i +GqKA4w7yz3CgADguBYAEIIAPwAAAANdwwAAAAPbzatgYuBmiHILgfuB44cXPcoAADC6gioDlz3Kf +ALj/BvLPc9C6/sp+ohqiO6KA5Q7yz3CgADguBYAEIIAPwAAAANdwwAAAAPbzadgYuBmi4H/BxeB4 +8cBuDU/3GnEEII4P8AAAAAQggA8BAADwQSgRA891oADALxUlTRRTFQCWz3CgAIQtNL7wIIADYg2g +B8lwCiQAgM93oP6QBBDy6XHPcJ8AuP82oBZuliACAMdwgACA1W4JIAAQ2VUnwRTPcJ8AuP82oEAp +ACEAII4PgAAg3MlwTgkgAATZTCAAoDfyFhUClioVAZYAhqGGB31jhgKGZ3gFJQ2QL3kc9FYiAAgi +eA94wOBW98W6YbnFuTByEvJEIgAIJLjwJgAQUyIPAQDbDyPDAwHixbowcmR4BX3y9QUkfoML8goh +wA/rcljYjLiKI08I9QKv+Lh12QRP9+B48cByDE/3BCCBD/AAAAAEIIAPAQAA8EEoEAPPdaD+pAOp +cM92nwC4/xamz3egAMAvehcAlhUXAJZBKREFohcAlgYPb/cB2BUnABRTEAGGFhABhioQAIbyDm/3 +AdgVJ08UmBcAlpAXAJZxFwCWQCUAGxamQCnAIcdwgACA1VIIIAAg2VYlQBIWpkApgCGWIAIAx3CA +AIDVOgggABDZVSVAGRamz3GAACDcQCgAIThgIgggAATZViWAFhamz3CAAGDdDgggAArZDQRP9+B4 +4cXPdaD+nAIA2s9znwC4/7ajgOHKJE1w4HjoIG0D8CCBADaj4HjgeOB44HjgeOB4AeLgf8HF4Hjx +wHYLT/cId89yoP5sA89wnwC4/1aggOEA3dH3KHZaDe//FSdAE+B44HjgeOB44HjgeGG+gOYB5TP3 +pQNP9+B48cA2C0/3CHfPcqD+NAPPcJ8AuP9WoIDhAN3R9yh2Gg3v//AnQBPgeOB44HjgeOB44Hhh +voDmAeUz92UDT/fgeOHFz3Wg/tQCANrPc58AuP+2o4DhyiRNcOB46CBtA/AggQAggeB44HjgeOB4 +4HjgeAHi4H/BxeB48cC+Cm/3iiAKBut1Sg1v/4ohRA+KIAoGPg1v/6lxz3aAAFAcAIZRIECAGvTP +dYAANCEAhVIggAAApQnwz3CgAKggDYDk4BwBBQB2DO//VNgAFQQQhiD/DpBw8vWKIAoG9gxv/4oh +RQPPd4AA7CqYFwCWUSCAgD7yog2P/s91gADwIskVABaluMkdGBCTFwCWpbiTHxiQ1xUAFqW41x0Y +EA6FpbgOpQCFyBAABoYgf47KICIAyiECAMQI4vfKIqIBAYXIEAAGhiB/jsogYgDKISIArAji98oi +ogEAhc9xgABYycQQAAYluMC4gg2v+wqhiiAKBmIMb/+KIUUJGg9P/X/YCrjPcaAA0BsToX/YEKEA +2JW4EKHPcQAA0CBKCiAABtjPcaAA8DYEgUYgwAEEoZTY0gvv/xjZiiAKBhoMb/8ghgCGUSBAgJwP +IgHKICIAiiAKBgIMb/+KIQYAyQFP9wohwA/rctvYBLiKIwUCwQdv+EolAADgePHASglv94ogSgbW +C2//iiGGAhIPIAoB2M9wpQAIDADdz3aAADwpoqAEhlEggIAYD0L4z3EAABAHtgkgAAbYC8gFIIAP +AQAA/AsaGDAEhlEggIAR8s9wgAAUPQCAgOAL9DYP7/6KIMYIgeAF9JoPAAYM8ADZnrnPcKAA/EQh +oOB4oaCSCCAIANgSDY/7DNjWCS/6ANmODwABxg3gCAHY4g/v+QHYEQFP9/HAnghP94DgiHUA3wny +geAL9AHez3CAALwXwKgF8M9wgAC8F+CogOEJ8oHhC/QB2c9wgAC5FyCoBfDPcIAAuRfgqIDiCfKB +4gv0AdnPcIAAuxcgqAXwz3CAALsX4KjPdqAAyB/PcIAAvBcYHtiTAIiA4IohEAAS8s9wgAAlIgCI +gOAM8s9wAwBADUUeGBAwpgLYGB4YkAPwMabPcIAAuRcAiIDgHPLPcIAAJiIAiIDgFvLPcAIA+qIg +HhiQz3CAACgAIR4YkM9wgACkCCIeGJAYFgCWRSAAAxgeGJDPcIAAuxcAiIDgCPIYFgCWhSABBBge +GJCB4wf0GBYAloi4GB4YkBgWAJaAuBgeGJCA5RnyANiUuM91gAAUCwClcdgGuMIJ7//82SCFz3AA +AEwctgnv/5+5GBYAloW4GB4YkMkHD/fgeIDh8cCYcAXyTCQAiI/2z3CAAEAJABAFAAohwA/rcs9w +AADaDqUFb/h5289wgAAULhUgAAEgoNHA4H7geADZSiSAcc9zgADAnyhyqCDAAfAjgAAB4gV54H8v +KEEA4cUA2kokgHHPdYAAwJ9Ic6gggAHwJcEQAeMlegDZnrkZeQQhgABCIACAyiBiAOB/wcXgePHA +iiDJA14Jb/+KIcwHz3GgAMgfpBECAM9wgADkOACANYHPc4AACKOWIEEPEHIA2soibwABg9W5geAB +2ALyAIOB4Ab013EAAIgThPcA2APwAdiB4swgYoCoDeH5yiDhAdHA4H4C4TB5QWlQcMT2IngQeAPw +AtjPcaAAyB8eoRDYDqEB2BUZGIDgfuB48cDhxVDdANrPc6AAyB+vo16jAiBCAF6jAdoVG5iAQNpO +owQgvs8AAgAQsA/B/4kGD/fgeADZz3CAAPCxIaDPcIAAVMsckGK4SCBAABB5z3KgAMgfH4IQeAgh +AQAweQLYFRoYgD+i4H4C4TB5QWlQcMT2IngQeAPwAtjPcaAAyB8foYogGAgOoQLYFRkYgOB+ANnP +cIAA8LEgoCGg4H8ioOHF4caA4M9xgAB450WBJfLPcaAAyB9AEQ4Gz3OAAFTLQCiNAkITAAF8k9B+ +2GC7Y2K7CCMDAAJ7CSLCAALYFRkYgM9wgADwIl+hA4AigM9wgADwsSKgwcbgf8HF4H7geOB/ANjh +xPwcyL78HEi+4cDhweHC4cP8HAix/BxIsfwciLH8HMix/BwIsvwcSLL8HIiy/BzIsuHF4cbhx/wc +CLT8HEi0/ByItPwcyLT8HAi/aiSAEOHEaiTAEOHE8cDPdaAAyB8ZFRKWe9huDy//iiEEA892nwC4 +//2GCiHAJ0DZn7k9ps9xoP4cADamUybANAUggA+w/gAAFqbPcAAARByeDq//CiDAL3pwGRUAllEg +AIIQ8lgegBchFQCWIhUAls9xgAAMCwCBFqYBgRam/aYH2G4Or/8KuFMgQQcH2KYOr/8KuM9woADU +CxiAQiAACEggAADPdYAAFEC8HRgQz3CAABQLAIALIMCEyiYiE8ogYgBm9EwigKBB9G/YIg6v/wa4 +z3AAANAbFg6P/89wAADUGw4Oj//PcAAA2BsCDo//B9j+Da//CrjPcAAABBzyDY//z3AAAAgc5g2P +/89wAAAMHN4Nj//PcAAAEBzSDY//z3AAAEQcyg2P/1EjgKUN8rwVABaA4An0QStOJcC+A75c5gHY +JPA03iHwjCIEoBzyTCIAohTyCvZMIkCgDvJMIgChFPSG3hPwTCIApAryjCIBoAz0TN4L8GbeCfA8 +3gfwRt4F8FTeA/CE3gDYgeAwCsEFkxUDFslwCnEqcgokgAS9AW/4CiXABPHARgsv9wHaosHPdoAA +zC8Ijs91gABML0QoPgtAJQAVJ3ASC2AIi3EIjoHH6XFEKD4LQCUAFidw+gpgCAHaCI5EKD4LACVB +HkAhAA0U4eYKYAgB2giORCg+CwAlQR5AIQAOGOHOCmAIAdoIjkAlAR1EKD4Li3AncboKYAgB2giO +OOVEKD4L6XAAJUEepgpgCAHaHQMv96LA4H7geOB/AdjPcoAAnAkigiWJgOES8s9xgAAssHqBz3GA +AGiuhCsICTAhQQ5RIUCABPQI2AuiAdgJogDYBKIF2AOi4H7xwOHFgOMIdShwBvLPcYAAAJYF8M9x +gAAAflt6Egsv97R5wQIv9wHYz3CAAJYJAJCA4AfyANnPcKQAHEAyoOB+z3CAAJYJAJCA4AfyA9nP +cKQAHEAyoOB+8cAGCg/3MHK6ACUAWnAiegHiKHdAKoAgz3GAABDfGnI7ZxZ4GmNSiowiw48AIxEA +Q/LPdoAA0C5ghgDd8LsPJY0QDvLPcqAASC5LgtO6CyWAkAbyAGFRIECCJ/KaCc/+gOAW9M9wgAA4 +JiyQz3CAAPAiHpAQcRP0AIYEIL6PAAA4EA30Fg6P/oDgCfLPcaAAOC4HgaV4B6EM8EYWABaleEYe +GBAG8EUWABaleEUeGBD/2RIZQiBCIEIggOJWB+3/IW+hAQ/34HjPcQEAxwPPcKAA7CcmoOB+8cA2 +CQ/3GnAyC6//JNiYcFEgAIDKIcEPyiLBB8oggQ8AAFEmyiOBDwAAKQF8ByH4yiUBBM9xoACsL0wg +AKAYgUj0+rgG8s9wgACgLgCAQHj02ADZxgqv/wHaNNgA2ZG5ugqv/wDaMNiKIQYArgqv/wDaNNgA +2QPaogqv/xS6vgqv/zDYwriB4AP0ANgH8ATdP9hCCy//qXGpcM9yAQDGA89xoADsJ0ahz3OgALQP +PIOA4SXyARIENnATBQAKIcAP63LPcAAAUibhBi/4iiNFBpq4GKHyCKALiiAPCs9wgACgLgCAQHji +CKALAdieDq/+iiAFA4DgBfQE2KEAD/dE2c9woADIHCmgvgigCwHYignAAb3x8cAiCA/3osEodgok +gIAA3891oAAsIEAVEBAAHMQzFPJMJECAQfJMJICAkvIKIcAP63LPcAAAVCaKI0QFWQYv+AolAAQy +aAQhgQ8AAPz/Hgqv/yzYEIUCIAAEjCAPigr3xgmv/yzYUSAAgAh39PMI8CCGgLkgpkoKL/8/2KoJ +r/802PW4DfIghoG5IKYyCi//P9g02ADZANpuCa//lbowvwIcxDOI8A95ELkFIYIPAACC/c9xoADs +J0ahBCCADwAAAB9IuIa4ELgFIIAPAABC/QahEIUCIAAEjCAPigz3i3GCDu/3iiAPDQAUADFRIACA +8fMI8CCGgLkgpsYJL/8/2IHBYg7v94ogTwwEFAAxUSCAgAjyIIaBuSCmpgkv/z/Yi3WKII8PPg7v +96lxIMAIuAIcBDCKIM8PKg7v96lxIMECFAAxJXgCHAQwNvDPcQMAQv7Pd6AA7Ccmp89xBAAC/ian +hrgQeBC4BSCADwAAQv0GpxCFAiAABIwgD4oM94tx4g3v94ogTw8AFAAxUSAAgfHzCPAghoC5IKYm +CS//P9jPcAYAAv8Gp0AkgTC2De/3iiDPDkDYCgkv/wIUATECFAAxxQbv9qLAz3GAAPAiAIECoQOh +z3CgADguiiH/Dyegz3CAANAu8QSv+IohCADgePHAkg2v/uHFgOBa8s91gADQLgAVBBAA2VEkAILK +IcEPyiLBB8oggQ8AAMkbyiOBDwAARwVwBCH4yiUhAIQVABBXHVgQWB1YEAHghB0AEM9wgABMCSCg +VhUAFgHgVh0YEM9wgAA0sS2IgOHJ9kyIUHHF9vYdQhD4HYAQ6gzgASTgAIXtuBD0jbiGCOAHAKWA +4Ar0C8gFIIAPAAAA1AsaGDDeCQ/3AIXuuAryrrg+Ca/4AKWF4KQLofjKICEC8QXP9vHA4cUIdYog +FA0GCC//qXEA2M9xpwCISYHlyiDhAA6hzQXP9vHAVg3P9s91gADgMKCNAN6A5cCjGvSB4MwhIYAW +8qDiRPbAowDYCvDA4gbYBfZCIgAIQ7gC4ACjUHkQuRB9iiCUDaoP7/6leXkFz/a4cEDcACEAg/HA +DgAkAJhxjCACgIv2CiHAD+tyz3AAAMkUVQMv+IojyA/PcIAA9Gv0IAABz3GAAPRsBCh+AS9w9SEB +AUIoAwTBu1K4BCl+AS9xQikCBMG6UrmB48AgaQCB4sAhaQCIID4AiSDBD4ghPgCJIcEPgODWICsI +gOHWISsIvgkAANHA4H7gePHAagzP9qHBOnEA34DgyiHBD8oiwQfKIIEPAADKFMojgQ8AANMCyiTB +AMACIfjKJcEDz3GAAOQwQLHPcYAA5jDgsUwhAKDKJc4TaAAuAMomzhMad1p3BfDJdxp1anBAIFMA +i3EB2q4J7/8A2wAUDTEvI8gkqXYpvci+v+XZJSkUTCIAoMogwgPKIYIDyiICBPgNIgDKI0IDyXDe +Du//qXFCIVEgTCEAoLAH7f9AIlIgyXBmCSAAqXEJBO/2ocDgePHAqgvP9npwz3CAAOAwAIiA4Bpx +bPTPcYAAZAqliQSJHWVydcohzA/KIswHyiCMDwAAyxTKI4wPAAA4A8okzAToASz4yiVMAwDdAN4o +8ADZz3CAAOEwIKhKcIrZ5g7v/ypyz3CAAOEwAIhTJcEQGLnDuBy4BXnPeBC4BXmKIFQN0g3v/uV5 +LyGIBBC5iiBUDcIN7/4FIUEEAebPfgAggS+AAGQKJokBaRB2OgAKAEArgiBUerV61HrPc4AAfLJX +Y4DnEm3q80AnkhAvIogk1HiA4c9ygABwsjQiEQC59QHZuPEB5a99g+ViB8v/FQPP9vHAygrP9s9z +gADmMECTUyJNgCHyguUk9M91gABkCgmtKK0ihc92gADkMACWKd0Svc93gADhMBUlDBAgpOCPgOcG +8lYgDwjwf/V9IKUB4AC2BvDPdYAAZAoLrSqtAeLVAu/2QLPxwGIKz/YIdhpxz3WAAOYw4JUL8Mx/ +Dgzv9kApQHFFuEIN7/8KcSCVjCEQgLT2mQLP9uB48cAiCs/2CHbPcIAA4DAAiHpxgOChwRpyhvTP +cYAAZAqliQSJHWVydcohzA/KIswHyiCMDwAAzBTKI4wPAACFA8okzARcACz4yiVMAwDfAN0g8AEU +gDABHhIQBhGBIIDhARSAMAP0AR4SECDAAxSCMAEUgTAYuBS6BXoCFIAwELgFeooglA1GDO/+RXkB +5a99z3GAAGQKACEABAaIAeAQdXoAKgAAIREEQCuAIBR49Xi0eM9xgAB8sjQhEgBTJ8AQGLiveRC5 +BXmKIJQN/gvv/gUhgQRMIgCgANkY8otxSnAC2uoOr/8A24DgtfUKIcAP63LPcAAAzRSKI44GCiSA +BKEH7/dKJYAAAR5SEAYRgCCA4L71AR5SELrxAefvf4PnLgfL/1UB7/ahwOB4ANuA4GCpYKrG9o7g +BPZgqeB/YKqi4If2wOAF9gHYAKkR8OTghvaMIAKDyiCsAMn2jCBChIn2jCBCiQf2A9gAqQHY4H8A +quB+8cCyCM/2o8FKIQAgi3EqcEogACEKckIOr/8qc4DgD/QKIcAP63JT2Aa4iiMFAQokQAT9Bu/3 +CiUABCDCgOKK9gDAQSgBAlMhxABMJMCAyfYB2c9wgADgMG8CIAAgqM9xgABkCkCpAhkCAUEoDgNT +JsUQAxlCAUwlwIDKIskHyiCJDwAAwhTKI4kPAABYAaAG6ffKIckPQSgCBFMixgAEGYIBQSgCBVMi +xQAFGUIBTCZAgMwl7IDKIckPyiLJB8ogiQ8AAMMUyiOJDwAAXgFgBun3yiSJAUEoAgZTIsQABhkC +AUEoBQcHGUIBTCRAgMwlbIDKIskHyiCJDwAAxBTKI4kPAABkASgG6ffKIckPBBSFMIwlAYS+ACwA +ARlCAQohwA/rcs9wAADFFIojRQoBBu/3mHPPdYAAfLIA3wPwAefvf0EoAQLDuTB3dAAKAADeEvBA +KYEgNHkKFIAwFSFBAQHmz34UeblhABkEBIAgAiMvIAgkAMBBKAEGw7kB4TB2vgfK/4LBCnAC2s4M +r/8A2wsUhDAvKAEBTiCFBy8lRwFMJcCArgfL/wohwA/rcs9wAADGFHkF7/eKI0YCQCFRIC8hRyRB +KAEEw7kycW4Hyf8F8EwmAIBgB8n/QSgBBcO5gOEKdbIALABKIAAgSiIAIAXwQCJSIC8ihyRBKAED +w7lScYIADABKIQAgFfACvtR+ChSAMBUmThFAIVEgLyFHJBR+ACaAH4AAfLKgsIAlAhOwfQDAQSgB +BwHhMnG2B8z/MLjDuAAgDgSCwalwAtoKDK//ANsLFIQwLygBAU4ghQcvJUcBTCXAgKQH6//Pfgoh +wA/rcs9wAADHFLUE7/eKI4YIQCBQIC8gByRBKAEFw7kScVwHyf/T2Qi5ANgD3s9ygABwsgDbsmh0 +fV1lILUB4297guNWIQEIMHm39mG+gOYB4A94MPdJBq/2o8DxwNINj/aiwUDAQcJAKBQFQCkXBQDd +QCoTBUArEgUB3kolgCGpdwTwCnXKdwDAFbgTeBQgwAV6D6/2B9kCIFADAiBAI2oPr/YO2cx+CiFA +LgQpPnAvcKx+ACENdR1lAcAVuBN4FCCABEYPr/YH2QIg1gMCJsAjOg+v9g7ZBCh+BC9x7H4AIcB0 +GWFCLQAVYgjv/1S5QiVVIEwlAKAB5owH7f/PfnUFr/aiwOB48cAqDY/2CHa6cc9wgABUywCQANlK +I0AgSiJAIIYg/ACMIAKAwiPCJEoggCDPcIAAuKUrqJpxz3CgANAPJRAPhiUQDYZivhAQEYaxdkAk +VCCS96J+EnbKIC4g3g7v9ulwTCMAoJhwANgT8oXnCfKL5wXyCPBKJgAgM/AB2ALwAtjPcYAA1Bck +gQshAIAD8gDaAvAB2gAgQCO6CS/4KnEKJgCgH/JMJACCEvLPcIAA3CEWIAABQIAGiBB3IPSA4h7y +qXBgeqpxCiIAoAvyInXPcKAA0A8QGFiDTCAAoK31z3Gg/ogFz3KfALj/TCYAoMwiIqAS8gDYE/AK +IcAP63LPcAAAMRGKIxcLSiQAAKkC7/cKJQABKHAWohPYOOE2ohC+BSYBFTaiUQSP9uB48cDhxc9w +gAC0MggQBABMJACAyiHBD8oiwQfKIIEPAABpGcojgQ8AANABYALh98olAQHPcqUACAwIEgUAANlM +JQCAzCUihMohwg/KIsIHyiCCDwAAfRnKI4IPAADXASwC4vfKJCIAQNgCos9wgADMu2CACvD0IE0A +z3CmAACANXgB4aCg0uGEKwIKACRADrT3pBADAc9xpACgP32hphAAAR6hCBpAAe0Dj/bgePHAgiQD +Motwz3GAAMxoJgyv9sjaSiRAdgDZqCBAAxYkQDBhgECQK9gSuAHhVXhgoDB5gCQDMtHA4H7gePHA +Eg8gAEfYANrPcasAoP9ZoQfYGqFYodHA4H7gfuB44H7gePHAz3GAALQyOIGA4XQOAgDRwOB+8cDP +cYAAtDI9gYDhIAhCANHA4H7VBUAK0QVACs0FQAoA2c9wgADMuyGgnQHgAiKg8cDhxc91gADMuxoL +4AKpcLhwAIWA4BPySiSAc89zgADILgDZqCCAAkCDRCm+AzIiQg6wch7yAeEQ8ADZSiSAec9ygAD8 +cqgggAJEKb4DMiJDDrBzDvIB4QohwA/rcs9wAACGGYojRAHRAO/3SiQAANECr/YocOB4z3CAAMy7 +QICA4iOAC/LPcIAAyC4AgEQpvgMN4DIgQA4I8M9wgAAJc0QpvgMyIEAO4H7geM9wAAABP89xqgDw +QwWhz3AAAD49BqHPcgAAPT1HoYogzA8IoQnYjLgJoc9wAAAWHAqhz3AAAB8fC6HPcAAAHBYMoZHY +BLgNoc9wAAADPw6hT6HPcAAAPT4QoYogxA8RoeB+4HjxwLYJj/YeCCADAN2ODSAAB9g+Du//GnDP +dqQAuD2sFgAWz3elANjLOdmiuKweGBCsp89wFQArK/YeWBOaHhgQiiDEAJ8eGBAa2PMeGBD0HhgQ +ZNjIHhgQqtjJHhgQadjMHhgQwNjNHhgQz3ClAAgMPqAuD8//JgogAApwGNiVHhgQz3GAAPggoaHI +2AKhAKEDoc9xAgCcMc9wgADMGtQYQACU2AunQdnPcKUAzH8toM9wpAAMgKKgYQGP9vHAGggAAEIP +z/9WDgAAsgoP+tHA4H7gePHA2giP9s9wgAB4yEAgEgYIcc9wgABoCSCgAN7EqATfRC4+FwohQC4A +IYB/gAB4yGYPL/gc2YQuChIAIY1/gADou6lwUg8v+IohCgKELgIXACGAf4AACMYacD4PL/ic2QAh +kSQAGUAjYb+A56EdGBSwB+3/AebBAI/24HjxwFoIj/YId1pxOnIacwojACGKJhsYyXDqCq/+6XFE +Lz4XACGNf4AAeMjJcNYKr/4hjclwzgqv/iCNyXDGCq/+Io3JcL4Kr/4jjfCtAdgRrQEdghQAHUIU +Ah0CFAMdwhQSHQIUEx3CFGYJIADpcEUAj/bgePHA7g9v9kQoPgcacDpxz3GAAHjIL3AaYVGKgeIb +YQ/yCiHAD+tyz3AAALIoXtuKJMMPNQav9wolAARMIMCgCfLPcoAAaAkEGgIEOGAAogGLIItSix4M +IABzi4IIgAEKcJYNIAAqcekHT/bgePHA4cUIdVIPIAcA2G4Mz/pE2c9woADIHCmgPgqv9hzYz3Cg +AKwvGID6uAr0iiARA/IJr/5L2YYI4AKpcP/Zz3CrAKD/OaA4oJIPIAGpcLUHT/bgePHA4cUCDO// +CHW2DSADqXCdB0/2z3GgAMgcCKHlAa/2BtjgePHAEg9P9qLBooFgkM92gAAECrh7o4FkfWCGpXum +gQGQuHingWCmpHihhkAhDwSA4qV4AaYc8gGBAhzEMDC7BBzEMAAcBDAggYt1YHmpcAGHIYYCHEQw +MLkEHEQwIIcAHAQwYHmpcADYAKYBpg0Hb/aiwOB48cCeDm/2nNkIds91gAAIxoQoAgcvdzoNL/gA +JUAeygggAvhlBgkgAMlw3QZP9uB48cByDm/2AdqEKAIHACGNf4AACMbPcIAAaAkAgCh2IIgAhpkd +ghBMhTC4geIPeEb0EHED2pkdghBA9ATYmR0CEBCFgOAM9AXYmR0CEAiGEqUDhhGlHIYUpReGE6Wp +cAIL4AHJcRCFAeCQ4FAAJQAQpQbYmR0CEKlwPg/gAclxqXBeCCACyXGpcL4O4AHJcalwqgggAslx +qXC2CCACqXGYFYAQgeAK9AfYmR0CEHIIIAACbQDYmB0CECUGT/bxwOHFCHWEKAIHACGAf4AACMbP +coAABD9IklEiQIAO8iCBheGK9wDZLaAuoM4P4AEvoPYIIACpcPEFT/aEKAIHACGAf4AACMbPcYAA +BD8okVEhQIAD8gHZLKAA2eB/MKDxwFYNT/YIdSoJIAAF2ECVIZUIukV5z3KkALg9mxpYACKVz3Ok +ALRFyhpYACOVyxpYACSVxBpYACWVxhpYACaVxxpYACeVwhpYACiVwxpYACmVxRpYACqVoxpYAM9x +gADwIiOBKIFRIQCAAN4L8kyVK5VbekV5UxtYgC2VVBtYgAXwUxuYg1QbmIMulVYbWIAvlVgbWIAw +lVUbWIAxlVcbWIAylVobWIAzlVwbWIA0lVkbWIA1lVsbWIB6Dc//BQVP9uB48cCEKAIHz3GAAAQ/ +KJFTIUGAz3KAAArGL3AF8iIP7/9YYNHA4H7gePHA4cXPcIAAwC4ggAHdYHmpcOe4J7hSIAAAyiUi +EMohQgPKIeEBwLgTeMK4z3KnABRIC6Isos9wqgDgB7OgoQRP9uB48cDhxc9xoADIHKiBCKHiDm/2 +BtiFBG/2qXDgePHABgxP9gh2z3WAAMy7AKUhpVitKgnv/3mtngnv/wOlBKUH3+lw/gwv+QnZBfBa +CG/+iiCJDM9woAB4RQCABCCAD3AAAABBKD6FAN3x9YYLIAepcM9wqwCg/7mg+qC4oLYMwAII2L4M +L/kJ2YDmAdjAeA3grgwv+QHZ9QNP9uB48cB6C0/2CHfPdYAAzLsYjUh2EHIacTpzCPSA5gT0GY0y +cAT0ANgD8AHYLyIHIOlw2gngAslxIIUwdwDYBvQhhRJxzCIhoAPyAdgvJgfwGq0q8oogWwjKDW/+ +6XGKIFsIvg1v/gpxiiBbCLYNb/7JcYogWwiqDW/+KnHpcApxyXICD+//KnMqDUADAYXPcYAAlAkA +sQCFAbEYjQSpbgxgAypwCfCA5wHYwHgN4PYLL/kB2SUDT/bgePHACHMA2QLahCsKAgAhgH+AAOi7 +hCkEDwTgagwgBydwYbqA4gHhMvfRwOB+8cDPcIAAmOtKCS/4iiEJDM9wgAAQJj4JL/gU2c9wgAA0 +KTIJL/gU2dHA4H7xwGIKT/aiwTpwGnEA3UoO7/8H2JpwAtmpcFpwenEA2zRoAnEodRQhACBocsKF +BBAPBdh/w4UB4sR/g+LleyDltvcBgQIcxDAwuwAcBDAggQQcxDBgeYtwQiNBIIDhvgft/0AiQCDy +Cu//inBJAm/2osDgePHA9glP9jpwWnHPd4AAXD8Mj892gADMu6WGhiD/AUO4DiUNkM9wgACwLiCA +yiViEGB5BNiA4CPyGo6A4MwlIZAd8gDYEN0acAK4FXjHcIAAODIggIDhB/IigIDhFPJgeSpwYb2A +5UAgQCAv9wDYGq4Mj4Yg/wFDuAWm8guv9kpw0QFP9gohwA/rcs9wAABlGTfbCiQABN0Hb/e4c/HA +4cUIdSCQApVBlRC4BXop2BK4FSBBAEChIJXwIEEAMHIO8toLb/6KINEDApUhlRC4BXnKC2/+iiDR +A6EBT/bxwOHFz3WAAOjIIIWA4R3yrgtv/oogSgwAhYDgB/LPcYAAFMkAoQiFCKEA2AClBKUuCC/5 +CdgqCC/5A9jPcIAA7F/aC4AIz3CAAFw19gngAAOAiiAKA2oLb/6KIQ8CANnPcIAAHDk5AW/2L6il +A8/48cDhxYogyQNGC2/+iiEOBzYPYAMA3c9wgAC0X44LgAjPcIAA0F+GC4AIz3CAAOxfeguACIog +ygEWC2/+iiHOCM9wgABcNaKgpg/v+APYz3CAAOQ4o6DZAG/2oaDxwOHFz3GgAKwvHIG9gQR9z3CA +ACQiAIiB4An0z3DA3wEAHKEo2Ri5G/CKIMkDxgpv/oohTwmKIIkDugpv/qlx/L0K8oogigWqCm/+ +iiEPC3YIgAP2vXAKAvkA2Zu5z3CgANAbMaBtAE/24HjxwCIIAADKCUAA0cDgfuB4z3CAAFw1AICB +4AHY4H/AePHA0g8P9s9wgABYyceAwL6B5gHez3GAAMg6AIHAfuG4LPSBuAChz3WgAMAvE4X6uATy +E4W6uBOlAtgRpc9wgACwLiCAYHkA2IjgDPQOCOAKCtgM8M9woACoIA2A5OCQ9xCFUSAAgPjzMgjv +/8lwFRUAloC4FR0YkMUHD/ZcFQQQQBUFEAohwA/rcoogTAmxBW/3iiOGDeB48cAqDw/2CHXPdqAA +wC8ahjm4UiAAAFMgEQAUhlEgwIAH9BYJ7/4k2PK4AN8C8gHfURYAloDgC/SjFgCWBCCADwAAAA+M +IBCAA/QA2ALwAdgacAQhkk8ABAAAz3AAAAgc1gjP/j+4UiADAAQggE8CAAAA13ACAAAAAdrAegxw +hiA9AIDgAdnAeVEggMEI8s9wgACgCgCAgeAA2AP0AdgB3uW9yiGBI0whAKAo8ua9yidhEIDnIvLj +vcoiYSBMIgCgHPLkvcojYQCA4xjy4r3KIGEgTCAAoBLy4b3KImEAgOIM8uC9yiFhAIDhCPJRJcCR +yiBhAIDgBPQA2APwAdiJBi/2D3jxwDYOD/anwQh2z3CAADxqIIABgEXBRsCKIMoBrghv/i1oz3CA +AFw1AoBExgzZFSQCMM9woAAsILCAz3ABAARUQMAB2EHAQsAQ2EPARYIA2AhzmHC4cAAlhx8AAAB9 +Hghv/NhwPQYv9qfA4HjxwLYNj/3PcqAAwC8A2YgaQAATgou4E6LPcIAAtBYBkBC4RSAAD8AaAADP +cIAAcDiCCO/4IKDRwOB+4HjxwI4NL/YA2Zu5z3CgANAbMaASCeAAAN6A4Cfyz3CAAIwVMYCA4c91 +gAAgIQzyz3CfALj/PaAkhQHhs7m1ubi5JKU2oM9wgACgCiCAz3CAAJw48CBAAEB4AIXxuAXyz3Cf +ALj/3aCVBQ/24HjxwBoNL/ZU2Rpwz3aAAFjJp4bAvYHlAd3AfZ4PL/6KIMkDiiBJB5IPL/4Kcc9w +gADwIgCAxBAABlEgQIEb8s9wgAC0FgGQz3GAAKQK4IE84BlnZOEScY/3CiHAD+tyH2eKIMwIWtsK +JAAEJQNv91UnRRYHhoPgAN8O9M9wgAC0FiGQz3CAAKQKAIA84ThgZOACIBAgCtimDe/4AdkLyAQg +gA/+//8DCxoYMAvIh7gLGhgw5gyv/6lwz3GfALj/XYHPcIAARAlAoP2hHNkW8M9woADIOzaAVoCG +If8IhiL/CEV5VoCGIv8IRXnPcqAAqCBNguTiTgAFAIDh6/XCD4AAz3agAMAvURYAloDgBfQMdIQk +wp8k8heG+bgi9M9wgABQHACAUSBAgBr0CiHAD+tyCiQACFEWBZaKIEwIUQJv93/bOBAEAFgQBQAK +IcAP63LPcAAAmSE5Am/3L9uB5Sr0iiDJA1IOL/6H2RCGUSAAgBn0z3WAALguIIVgeQHYheAG9CCF +YHkC2ILgDfJAFgQQCiHAD+tyiiCMCI3b8QFv97hziiAQARGmEIZRIACA/vUUhqu4FKbPcIAAUBwA +gILgEtjAKCIGyiAhAM8gYQYZps9xoADIHxgRAIahuBgZGICKIBAAEaEJ2Ai4D6EThqm4E6bPcIAA +WMkHgIPgzCDigQb0QCiAIJ+4iB4AEOYIgAjPcIAAyDppAy/24KCB4fHABPRODQAABPAKDQAA0cDg +fvHAig6gAOHFVgvv+BrYz3CAAHQ4AJDPcoAAQMlSIAEAwLkB4eG4IKoA2Qv0z3WAAOQ4aoWB4wXy +a4WB4wL0AdkjqkEogQLAuTSqKbjAuM9xgABcNREDL/YAoeB48cCOCi/2iiCJCs92oADAL7eG+oaI +FhAQEg0v/ujZiiCJCgoNL/6pcYogiQr+DC/+6XGKIIkK9gwv/gpxMIbuDC/+iiCJCjOG4gwv/oog +iQoH2M93oADIHxkfGJAB2AhxCHIIc5IJ7/6YcCoMr/5U2FEgAIEJ9M9wgABECSCAz3CfALj/PaCA +Fg0QIr1uDmAIqXCKIIkKlgwv/qlxz3GAAIhBEoG4YBKhANiIHgAQCdgIuA6nPQIP9vHA3gkv9gDZ +z3WfALj/XYXPdoAARAlApj2lHNkV8M9zoADIOzaDRCECBzaDhiH/CCV6NoOGIf8IRXnPcqAAqCBN +guTiifeA4ev1XgrP/4DgEPQA2C3wOBMEAFgTBQAKIcAP63LPcAAAmSHhBy/3L9sAhh2lQg/gCADY +iiAJBfYLL/6KIUwGz3GAAKAKIIGKIEwG1gigAAPaXgqgAAPYwgqP+wjYXg0gAIoh/w8B2J0BD/bg +ePHAz3CAAKAKAICD4Af0fg7P+yoJz/8GCUAA0cDgfuB48cD+CC/2ltkacJYLL/6KIAoDAN0KIYAv +gAAUOQXfz3aAAHQ4tX4DhkwgQKAVIUwjAKQJ9IogCgNmCy/+nNkB2AOmYb+A5wHlr30r9wHZz3CA +AOQ4CQEv9kQYQgDPcIAA6MgB2SSoJajPcYAAdDgAkYYgGACouACx2tgDqc9wAABQwwGhz3ABAKCG +oQCgAAKh8cDhxc91gAAcOQ6NgeChwT30iiAKA/oKL/7J2S+NhOGKIAoDVPbqCi/+zdkPjYDgCfSK +IAoD2gov/tHZNg/v/wHYD40B4A94D60h8MIKL/7a2QDYDa0OrToIIAAPrXIPz/8A2OIJ7/+MuM9w +rQu+ukDAi3AE2X3aPdvCCaAGF7uKIAoDigov/vHZZQAv9qHA8cDhxYogCgN2Ci/+r9nPcoAA5DhE +EoAAgeBAIgMME/RKJEBxANmoIAAD8CNNAM9wgACAODV4AeGgoC95ANhEGgIAHQAP9uB4ANrPcYAA +HDlPqQHYDalOqUypUKlRqVKpU6lUqYogCgMVAi/+h9ngePHAdg/v9QHaz3GAAPAiY4F4i4TjGvQA +gc9xgABcNcQQAAYluFIgAAAhgcC4AdqA4c9xgAB45yaBwHqA4cwgIYDMIiKAgPKF8FEgAIAH8s9w +gABAyQCIgeAD9JhyA/BKJAAAz3CgACwgcIDPdoAA5DhFhqaGAiOAgADayiJvAAIjT4MA3colbxDX +cABAAADJ94DiB/ICI4APTgABIAWm13cAQAAAyPeA5QbyAiOAD04AASAGpgGGgOAW8s93gAB0OACG +4YcfZ/Fwxvfxc8r3EHOG9wjwEHOE9/FzxPcA2APwAdgBpiCBxBEDBkErQQFRIQCAyiZhEAbyKYaD +4W8mCxDPcYAAXDUhgc93gAB45+aHgOEB2cB5gOAB2MB4hid/Hobn0SNigQDbAvQB24DlzCIigMwj +IoDMICKAzCEigMwmIpAE9ADYBvBMJACA/PMB2I0Gz/XxwIog0Ae2CC/+iiFGAIYOAAPPcIAAPCkE +gFEggIDUC0L9CdkIuc9woACwHzSg0cDgfuB48cDhxQh1iiDJA34IL/6KIcUFiiCJA3IIL/6pcc9x +gABcNQGBpngBoQDZz3CAAFjJMKAlgDEG7/UxoOB48cC2Dc/1ocEIdoogiQc+CC/+yXHPcYAAoAqK +IIkHLggv/iCBz3WAAFw1AYXPcYAAWMkFfhCBgODBpQb0AdgQoQWBEaFGCu/8i3AAwc9wAQDQRDBw +C/LPcAEABFQQcQfyz3ABAGR0EHEE9CIO7/sB2ADez3CAAOQ4waByDK/4B9hqDK/4CNi+CwADz3CA +ALRfFghACM9wgADQXw4IQAjPcIAA8CIAgMQQAAZRIECBC/KKIEoClg/v/Rx5yg8gAMlwBPAODmAA +A4VZBe/1ocDgePHA5gzv9bhwZg3v/yhwgOAA2cogQQAo8s92nwC4/x2Gz3WAAEQJAKU9phzZFfDP +cKAAyDs2gFaAhiH/CIYi/whFeVaAhiL/CEV5z3KgAKggTYLk4or3gOHr9VYNr/+ocCCFPabtBM/1 +OBAEAFgQBQAKIcAP63LPcAAAmSHVAi/3L9vgePHAz3CAABCxCIBRIMCBM/TPcYAAdDhCgSGBz3CA +AMg4QKDPcIAA5DgnoIogyQPKDu/9iiHFD4ogyQS+Du/9iiFGAM9xgACgCiCBiiBGAJ4LYAAC2iYN +YAAC2IogyQOaDu/9iiHGAN4N4AYC2OYLT/gH8M9wgABcNQINYAADgNHA4H7gePHA1gvP9Qh1KHaK +IEkHZg7v/YohBgeD5R30z3CAALQWAZDPcoAApAoggjzgGWEBgmThOGAQdg/3CiHAD+tyiiCNAYoj +xgdKJAAAAQIv9wolAAGKIFkFHg7v/YohRgjPcIAAWMnPd6AALCBAFxAQ0g5gAKeghgmACM9wgABI +ISSAIIHyDe/9iiBJB891oACsLzyF4g3v/YogSQeKIEkH1g3v/clxwgxv+wHYFg6v/8lwAdjGC6AA +CnEchfm4CPQYhYi4GKXiDe/1oNgI8M9xgADIOgCBgrgAoYogSQeWDe/9iiHHAGYIz/8WDUAA0Id+ +DG/7AdgJ2AIMr/gA2XIOAACKIEkHbg3v/YohRwZaC2AKMtjPcACCAQAcpXINb/gCJgAUANhSC6AA +yXGKIBkFRg3v/YohhwoFA8/14HjxwOHFz3GAAEDJABGEAEwkAIClwQ72AxGFAEwlQIAK8gohwA/r +coogDQHlAC/38dtMJICAJfQDiYDgI/QA2ACpiiDJCPIM7/342YogCQbqDO/9+dnPcYAAoAoggfnY +B93KCWAAqXJWC2AAqXDPcIAAXDV6Ca//o6BuCY//cvDPcYAA6MgEiYHgDPQFiYHgCvTPcAAA//8q +De//ANmA4GLyz3GAAPAiAIHEEAAGUSBAgQXyA4EYiITgGPSKIMkIegzv/YohhASKIMkEbgzv/Yoh +xATPcYAAoAoggYogxAROCWAAAtoC2DzwWg5AAIwgEIVwAAUAz3CAAFw1AICB4Ab0AgpP+IDgLvIA +2c9woAAsILCAz3ABANBEQMAB2EHAQsBDwUTBBtkIcgDbmHO4cwAlhx8AAAB9sgvv+9hziiCJBPYL +7/2KIQQKz3GAAKAKIIGKIAQK1ghgAAHaAdheCkAAtQHv9aXA4HjgfuB48cAyCc/1z3egACwg0IfP +cIAA5DgIgKXBAiYCEM9wgABAyc9zgAB452WDI4AFK34AN3IB2UCIwiFOAIHiAN0F8gOIgeAZ9M9w +gABcNaOgiiDJA3oL7/3O2YogSQRuC+/9z9nPcYAAoAoggc/YUghgAADaANhT8M9ygADwIgCCxBAA +BlEgQIFN8oHhS/QDghiIg+BH9M9wgABcNQGAgOBB9M9wgAD0IACQgeAB2MB4DLjXcAAAABA18oog +yQMOC+/91dnwh89wAQAEVEDAAdhBwELFEdhDwADYjLhEwKlwDNkB2qlzmHW4dQAnhx8AAAB9igrv ++9h1z3CAAOQ4yKCKIEkGygrv/djZz3GAAKAKIIHY2K4PIAAI2gjYNglAAH0A7/WlwPHA4cUA2Zu5 +z3CgANAbMaCKIEoBkgrv/YohCA3PcIAAPCkEgFEggICKIEoBDPSKIUgOdgrP/c9wgABcNe4IYAAD +gFLwYgrv/YohiA/qDA//iiBKAVIK7/2KIYkAz3WAAPAiTYU+lVMiAAD6COAEAduKIEoBMgrv/Yoh +SQMAhcQQAAZRIECBDfIDhRiIhOAJ8s9wgABYyQeAUSDAgAbyiiBKAYohSQXH8YogSgH6Ce/9iiHJ +BoogyQTuCe/9iiFJB89xgACgCiCBiiBJB84OIAAC2loIYAAC2IogSgHKCe/9iiGJB6EHj/XxwCYP +j/XPcqAALCAwgs9wgABIIQSAz3aAAOQ4AICghgIhQwPXcwAAoA8A38v3z3OAAHjnpYPVuEEtgxBi +fbFwhPcBhoDgDfRjhoHj4aYN9IogCgJqCe/9iiEKCT/wOg9v+AfYO/DPdYAA6MgAhYDgGfIFhYDg +F/IwggJ513EAAFDDAdjCIA4AgOAp8iYOj/8EheWl46aguASlbg8v+ADYHfCA4wXyBoYCeYDh1/ZT +IIDBBKYT9IogyQQGCe/9iiFLAs9xgACgCiCBiiBLAuYNIAAC2m4PIAAC2LUGj/XgePHASg6v9Yog +/w+hwSoNIABAwIHgPPTPcIAA8CIAgMQQAAZRIECBEfLPcIAA9CAAkM91gACgCoHgAdjAeAy413AA +AAAQFPKKIEkElgjv/YohRQfPcYAAoAoggYogRQd2DSAAANr+DiAAANhS8IogiQVuCO/9iiFFCCCF +iiBFCFYNIAAF2t4OIAAF2ELwz3WAAHA4AIWB4ADeCfSKIMoKQgjv/YohRQrApTLwz3HA3wEAz3Cg +AKwvPKDPcACA//+qCO//AdmA4CTyog+gBotwCiUAkB7yiiDJAwYI7/2KIcYAiiAJBfoPr/2KIcYB +z3GAAKAKIIGKIMYB2gwgAAPaZg4gAAPYqXBqCe//AMGpBa/1ocDgePHAuHDPcIAAoAoAEAQAz3GA +AKA0QCyAABR4FSBAAQBhiuAK9AohwA/rcoogzQB1A+/2oNsaDgAA0cDgfuB+4HjxwOHFz3CAAPAi +A4AYiITgDfQKIcAP63KKIE0BiiOEDUokAAA9A+/2uHNuCUAACHXPcAAAv9/eD6//ANmB4AX0jCUQ +lRz3iiAKC0IPr/2KIQUBeg2v+wHYiiBJBC4Pr/2KIUUCz3GAAKAKIIGKIEUCDgwgAADamg0gAADY +7QSP9eB+4HjxwHIMj/WqCkAIiiBKAfoOr/2KIYcNz3WAAFAcAIWC4M92oACsLxbyGIb6uAryGoZS +IAAAUSAAgATyHIb8uAryiiBKAcIOr/2KIQgANgxP/xyGUSAAgB3yz3CAALRfAIBCIACAyiBiAIDg +E/TPcoAAdDgJgoTgTffPcYAA8CIggcQRAQZRIUCBA/IB4AmiPIZ2Dq/9iiAJCzoOj/ZiDw/9geAM +8gCFguAI8s9wgACgCgCAg+CsC8H/JQSP9fHAtguP9c9wgABcNQCAgeAU8s91gACgCiCFgOHMIeKB +zCEiggjyiiDRAADeEgsgAMlywKWyCI/76QOP9QokAIDxwAzyCiHAD+tyiiBNAoojjg3RAe/2uHOm +Ck//Jg7v/wLYz3ABAARUdg2v+wHZ0cDgfuB48cBCC6/1BthuCk/4z3CAAOgXSiQAAAAYAAHPcIAA +8CIDgBiIhOAL9AohwA/rcoogzA3q23kB7/a4c89wgABQXPINwAcI2BYMb/gG2c9woAAsINCAz3WA +AOQ4IIUCJkAQ13AAACBOBvZGC2/4B9jApc9wgAB45waAUSAAgDALYvjKICICngygBgDYJQOP9eB4 +8cCuCq/1iiDJAz4Nr/2KIcQD1glv+AjYz3aAAKAKAIaH4MwgIoJV8s91gADkOCGFgOEH8s9xoAAs +IDCBIKXPcYAAeOcmgVEhAIBD8oTgzCBigSX0z3GAAFw1AoGA4Aj0AIGB4DXyA4WA4DPyiiBKAtYM +r/2KIcQJiiDKAcoMr/2KIQQKANnPcIAA6MgpoCqgANjuC2//jLgb8IDgzCCigRf0A4WA4ADfDPLP +cKAALCAQgAKliiDJA44Mr/2KIcQMiiDJA4IMr/2KIYQN46UghofhzCEigmLyz3WAAOQ4AYWA4AX0 +A4WA4Cnyz3CAAPQgAJCB4AHYwHgMuNdwAAAAEB30iiBKAkIMr/2KIYUAcgzv/wHYz3CAAFw1AICB +4D70A4WB4GgKIfjKIGEAA4WA4FwKIfjKIKEAMPCA4Q30z3GAAOjICoEJoQDYCqHPcKAALCAQgAah +z3CAAPQgAJCB4AHYwHgMuNdwAAAAEBb0z3CAAFw1AYCA4BD0iiDJBMoLr/2KIYUGIIaKIIUGrggg +AALaOgogAALYfQGP9c9ygADkOAGCgOAA2QT0A4KA4APyAdlTIIDBBKIB2sIigQAA2IDhzCIhgAPy +Adjgfw944HjxwOHFz3GAAOjIRImB4gDYD/QEqQHdz3CAAOQ4qqCq2c9wgAB0ON4IIAAjqKlwKQGP +9eB48cDhxc9xgADoyESJgOIA2A/0Ad2kqc9xgADkOAqhzNnPcIAAdDiqCCAAI6ipcPUAj/XgeOHF +4cbPdYAAbDXAFQMWv+NH99Jr1H6+ZgCmIaZCpgFrxbjAHRgQwcbgf8HF8cDhxYogCgPaCq/9jdnP +dYAAHDkNjYHgKPSKIAoDxgqv/ZDZz3CAAHQ4AJDpuNEgooIO9IogCgOqCq/9ldkA2A6tDa0iCK// +D60Q8IogCgOSCq/9ndkB2A6tD41CIACA5g5v/8ogYgBZAI/18cDeD0/17gxP/89zgAB0OACTz3KA +AEDJQSiBAMC5IarPcYAA9CAgkYHhAdnAeQy513EAAAAQDfSig89xgADIOKChoYPPcYAA5DinoTbw +z3GAAFw1oIGB5RL0z3aAAOjIJI6B4QX0JY6B4QHZAvIA2YDhyiGCDwAAECcD9CKDgeXPdoAAyDgg +phL0z3WAAOjIJI2B4QX0JY2B4QHZAvIA2YDhyiGCDwAAECcD9CGDz3WAAOQ4J6Wpcc91oAAsINCF +5YECJs0T/70C9MWh5oECJs0T/70C9MahKIOA4QX0z3GAAHjnKJEjoiW4wLgCDS/4A9lVB0/14Hjx +wOHFz3GAAKAKABEEALhwz3KAADQ5QCyAABZ4FSBAAQBiheAJ9AohwA/rcoogjQAlBa/2dtuC4AAZ +QAFk8oTgI/TPdYAA6MgghYDhXPIyCa/9iiBKDACFgOAI8s9xgAAUyQChCIUIoQDYAKUEpbINL/gJ +2KoNL/gD2M9wgADsX1oJwAdA8IHgEPQqDiAGANgLyAQggA/+//8DCxoYMAvIh7gLGhgwMPDPcIAA +PCkEgFEggIAP8s9wgAAUPQCAgOAJ9HYML/2Q2IHgBfTaDEAEDfAA2p66ANnPcKAA/ERBoOB4IaDO +DSAGKHDPcIAA8CIDgBiIhOAG9NIMj/yA4AT0tg2AAlkGT/XxwN4NT/XPdqAAwC86hs9ygADIOgCC +4LhM9IC4AKLPcIAAWMkHgAHdwLiB4MB9/LkF8hCGUSAAgAP0AN8C8AHfgOXvfzDyiiCJCi4Ir/2K +IcUFMIYiCK/9iiCJChCGUSCAgg/0QBYEEEwWBRAKIcAP63KKIEwJ2QOv9oojhQaB5wz0iiAQARGm +4g3gCQrYMIbmD2/9iiCJCoogEAASps4N4AkF2M9wgACoLiCAYHmpcJUFT/XxwIogyQO+D2/9iiEG +Bc9xgABcNUCBgeIS9M9zgADoyASLgeAF9AWLgeAB2ALyANiA4Moggg8AABAnBvTPcIAAdDgCgIHi +z3OAAMg4AKMT9M9ygADoyASKgeAG9AWKgeAB2APyANiA4Moggg8AABAnBfTPcIAAdDgBgM9ygADk +OAeixg3v/wOB0cDgfvHAz3AAAAgclg7v/aHB/7gN8s9woAAsIBCABNl82j3bQMCLcD4O4AUXu6HA +0cDgfuB+4HjgfwHY4H7gePHA4cXPcQMAQA3PcKAAqCAtoM9xoADALxSB8LgUgQzyBCCADwgAAADX +cAgAAAAB2MB4B/CGIH8PguAB2MB4gOBf9BURAIaguBUZGIAR8M9woACoIA2A5ODPdaAArC+P9xyF ++bhH9Ax0hCTCn0P0wgwv/1rYgODt80PwiiCJA34Ob/2KIckJz3GgANQLO4FuDm/9iiCJAyxxYg5v +/YogiQM5hVoOb/2KIIkDug3v/STYCHFKDm/9iiCJA6oN7/2KIAkDCHE2Dm/9iiCJA+t1lg3v/STY +uHDPcKAA1AtsEAQAiiCNCgohwA+pcukBr/aKI4kLz3GgAMwrEoGAuBKh3QNP9eB48cBaCCAA4cUe +CCAACHXmCCAACHNwdcojRQMQc7kDb/XKIMUA8cDhxaHBAN1AxR4Ib/yLcILgiiD/Dwzyz3CAANhh +A4AggADAIniA4MogTAOFA2/1ocDgePHAocEA2EDAz3CAAEDJIYiB4YtwEfTPcaAALCAwgc9ygADk +OEiCQnnXcU4AACDF9wIIT/wD8N4PD/yC4Ab0iiD/D6HA0cDgfs9wgAD4YQOAIIAAwCJ4gODKICwA +8/HgeOHFz3GAAEghJIEggc9zgAD4YUOD1bmggkaDiiD/D4DiBfICgqJ4SCAAAAkgQABquEggAADg +f8HFz3GAAPhhC4FAgA6BgODKIIEP/////wryAoBCeEggAACZIAYASCAAAOB+4HjxwCYKT/WhwRpw +z3CgACwgQBAUAM93gABUyz+HAN5EIBUjz3WAAOQ4QSmAAdpxhib+L0wlAKJKI0AgwiPCJFMgEQBB +KEEjwLkWJVIUBBpAIIog2QWGDG/9iiHKAkwlAKLMISGgCfQBhYDgBfKyDo/7A/AeDo/7z3CAAPAi +A4AYiIHgBvTPcYAAEN8W8BIJD/2A4D3yz3CAADgmCIiH4Df0mBeAEM9xgAAQ3wK4FngAYe24LfKY +F4AQUSAAo0Ah1QMCuBZ4OGAd8iCAiLkgoA4Mb/2KIIkDmBeBEAHaEmkWeKJwQKjPcIAA8CIBgMAQ +AAYRIECAzCGig2gPwgkH8C4IIArPqIDgtA/CCc93gACgCgCHh+Bf8gQSACCB4MoggQ8AAFwGtAth +/cohQQRMIwCgUfJMJgCgR/IAh4DgIB0AFQ70iiDJA5YLb/2KIQsDz3GAAOjICoEB4AqhIfBGFYAQ +geAb9M9w7f6+ukDAi3AE2X3aPduSCuAFF7uKIAoDXgtv/YohCwhGHYITRR2CE9IIb/9HHYITXg+P +9weFJoWCcAIgQgD/ugP0BqVMFYAQgeAR9EwdghOKIIoEIgtv/QDZCfCKIBkGFgtv/YohCw8AHQAV +oQBv9aHA8cBqCE/1CHXPcKAALCDwgIflAN6M9gohwA/rcoogDQKKIwkDmHa1Bm/2uHOG4SLyigyP +/89wgADkOOigz3CAAKAKAICA4Mwg4oEQ8s9wgABcNQGAgOAK9IogCgumCm/9iiGJBW4Oj/fPcIAA +dDjJoM9xgAD0IIogWQeKCm/9IJHPcYAAXDXPcIAAyDgggfAgQAOB4fhgBvTPcYAAdDjJoc9zgADk +OCWDAiBCAP+6A/QFoyEAT/XgePHA4cUIdQTZz3CgAMgcKKBuCm/1FtjPcaAAwC8TgYDlzyDiAtAg +4QIToYDlPNoG9M9wgAC0FkCQz3CAALQWAZAQuEV4wBkAAOEHD/XPcqAALCBQgiJ6z3GAAKQKFXkA +gRByzPfPcIAA8CIAgMQQAAZRIECBAvJAoeB+4HjxwDoPD/UA3s9woAC0D7yA8g7gBclwz3KAANyf +BJLPcaAA7CcQuIUghAAGoQWSELiFII0ABqEHgs9zpwAUSAejCIIQowOCz3OkALg9mxsYAASCphsY +AAWCkhsYAAaCoxsYAM9wpADs/8agiiCKAAahkg7gBa94z3CAADwpBIBRIICAcAgiCMogYgAdBw/1 +4HjgfuB4ANjPcYAAbCkDqc9wgACcCUeAAoBCqRzgVnhEiEmpBYjgfwqp8cDaDc/8gOAz8s9wgAA4 +JiyQz3CAAPAiHpAQcSnyz3CAAMwvaIhKiEQrPgsAIYB/gABcL1V4BojPcYAA0C6B4Bf0AIGKuGYO +7/wAoYDg3AhiB8ogIgDPcoAAPGEGggOAIIDHcQAAACh+CaAHSHDRwOB+4HjxwAoOD/XPcacAFEgA +3aihB4HPdoAA3J8HphCBz3KnADRECKanoc9w8w///BChoNi2oZq49RoYAM9xpAC4PZsRAAbPd4AA +OCEDpqYRAAYEppIRAAYFpqMRAAYGpv/YmxlYA6YZGACSGRgAoxkYAM9xpADs/89wAAD//6ehBqEA +hwHggeAApwr0AdnPcKAAyBwxoAYOoAkocATYrgwv9kAmARIN2KIML/ZAJoESz3AoAAIBz3GgAOwn +BqGKII0ABqEAh0IgQIAApwX0z3CgAMgcsaChBQ/14HjxwDIND/VRIMCBDRIPNs9zgAAEygMSDTbP +cYAAFMv0exGLEBOEABLyAeAIcjIVhRBnkQIZAgHPdkEAgwBmsc9zgACEQgOpEfBAJEIAMRWFEEKp +wBMDAQOpz3YhAIIAZrHPc4AAiEKwcsf3xKEAgwHgAKMEgVTwz3OAACTK62MB48GFZKlRJgCRANpw +jTryLyUIAO9/SSfEEPJrz3CAABDf9n/gYPa40o0H8s9wgABQ4XZ4AYgC8EhwACSPD4AAUOF2f+SP +CCbOEwgmABCgcEkgzgMWa9V4z3aAANDiAGbPdoAAUOJ2fmGGz3aAAPAixIbYhsV7BCODDwAAAAhm +eAPwA4UCoZgVgBBoiRBzBfJEqWDYGLgD8ADYnbgEoX0ED/XxwOHFA8ikEAAAUSAAgM9wgADwIgSA +BPIbkAPwGpDqCQAIgOA69M9woAAUBAPZI6Ag2AwaHDDPcYAADEEWgQHgFqEDyADamBABAKQQAwCU +GEAAnhABAay7khhEAL4QAQGtu4AQDQGkGMAAkBhEAH4QAQGAGIQAPWWwEAEBonkwebAYRACCEAEB +fhiEAIYj5Y+yGEQAAA2C/PEDD/XxwHYLL/UIcxCJMxGNAAHaQKsNEg82z3aAACzK7mbPcoAAXMpI +3MGrDRIPNgIiDgP0Js4TwbMNEg428CKCA0GjQYFRIgCBEPLSic9ygABQ4RZ63KtAioYifwxcegS6 +RX7cqwTwgNpcqwS4BX29qxyRz3KAAKTKD7MNyPAiAAAEswfIBaNUEQABDLMAkQ2zoBGCAEijBsgE +IIAPAgBBANdwAgAAAAP0iLpIowbIhiC+jwPyibpIo5wRAAHPc4AA1GImuMC4QCgCAw+BwLgNuEV4 +DQMv9QCj4Hjhxc9wAADQLs9zgADoCQGjz3CAABCxAKPPcYAACOjPcoAApGIAgqCBoKAAghzdoKgE +aQGiVSFABAOiGNgColUhwAUFogGBBKJocAOhAoGNuAKh4H/BxeB48cA+Ci/1HNoacM9wgAC2CgCI +z3aAALxiCiGAL4AATNCEKB8AIIYAIUQuz3WAAFDNQKEAJUEeACVCHiiBQCIDBwAlQB5PIU8D6KIC +iFEgQIBhpgXyg7mNuSiiz3CAAFQLAqMY2AKmz3CAANQKAIAMHgARz3GAALwKFgxv+SCBANnPcqAA +LCBQgoDgYYZKo8T2WGAKo89wgAC2CgAQhwCELx8AJ3VCjVEiQIAvcFj0TCAAoAv0z3GAAIjQG2HP +cIAAyApgoErwz3KAAMgKQIJBikQovijHcIAAbM0X4EAihAAyIEIOLyQHAc9wgADMCgLiT3qA4gAQ +hQBAACwAAiWDAIQvHwAvcAAhTw4AJ4YfgABszUQovihAJo8FMidPHjtjx3OAAETQCOMbYwHhL3lQ +ceCrAiWDAKb2hC8fAAAhQC4bY89wgADICmCgDpUCIAABDrUOlVhgDrVlpgfwz3GAAGTQOGAFpg6V +NQEv9QSm4HjxwMIID/UIdQCIjODPdoAAzDBoFoGQyPSA4QfyA41pFoKQEHLH8oDh+A7C+AHYaB4C +kCGNguHKICEAzCHig3v0ax4CkCONgOBpHkKQJI1qHkKQzfYFbclxgiFCA5IPIAYN2nMWgJBsHgKQ +axaAkILgDfRAJYAUyXGCIUEPcg8gBg3agxaAkG0eApBrFoCQgOAiAS4ASiQAIM9wgACsYQaAA4BA +LBAhoIAAIJIvgAA8MIogVQy6Ci/9AxKBIIogVQwAII8vgADQLqYKL/1cFwEWiiBVDJoKL/1dFwEW +iiBVDI4KL/1eFwEWiiCVDIIKL/2pcV4XExZydVQADgACJdAUXRcRFgpwbgkv9SpxBSk+IFwXAhYC +IEEuUHHAIGYAAxKBIIwhw48R9AUpPiAAIc90CPCc4QLYhvMA2GgeApA78KJ/ANgY8Iwgw4/E92p3 ++vEwcFD3BSk+IAAhz3SifwJ5L3kAJIAvgAA4MCCoANgE8AHYAN+A4BD0iiDVDPIJL/3pcXDcAiYA +E0QsPicncLIKYAe5Z2sWgJBAJFQgknD8Bs3/CfCA4QfyANh6De/4aB4CkGUHz/TgePHAEgggAALY +AgoAANHA4H7xwAoPz/TPd4AA8CIVJxAQABAOIAh1FJaF4IX2iOAC2ML2ANgapkokAHIA2aggQA3P +cIAAYHD0IEIAz3CAAPyxNHhAsM9wgABwcvQgQgDPcIAALLI0eECwz3CAAHBw9CBCAM9wgAAMsjR4 +QLDPcIAAgHL0IEIAz3CAAFSyNHhAsM9wgABYcvQgQgDPcIAAHLI0eAHhQLAIhuW4BNnKISEA5Lg0 +pgbyCdlGHkQQLtoG8BTZRh5EEDLaW7ZZjlEgAIBZYTB5Rh5EEBrhOrYJ8grYVB4EEAbYVh4EEAfY +CPAQ2FQeBBAA2FYeBBAF2A+mOgggBKlwPI4ocEQeQhCGIAMA5rlYHgIQyiJBAAzyUCHDAW96RB7C +EFAgwwFveFgewhDluQjySHOGIwMAb3pEHsIQ5LkF8qW4WB4CEFEhwIAF8qS6RB6CEILlFfKuCW/4 +qXAAEAAguRAABlEgQIDx2MAoIgHKIIEPAACTAMAoIQGEHgAQGNiNuBOmCIZRIMCABvK2F4AQibgE +8J0XgBASps9woACsLxmAz3GAADwpMLjAuFYPIAkFoQiGBCC+jwAGAAAA3wvyNrjAuBt4AeBaHgQQ +AtgapgPwWh7EEwDYF6YYprYI7/ypcCiGAdpIc0EpAAU1uVIgAABSIQEAwLjAuYYMr/2YcnkFz/Tx +wBYN7/QH2M91oADIH0gdGJDPcIAA8CIjgM92rADUARqBTB0YkILgAtjKICIA0B4AkIogBAAPpUYR +AAHPd6AApDCwHQAQRhEAAbQdABAf2Ai4DqUIgVEgAIAA2Iu4CPIQpboNj/cBh4S4B/ARpbINj/cB +h6S4AafPcIAADGMAgOC4CvKGIP8OIrgUuM9xgACoCAuh0g9v9wHfug1AAX4PwAMGCAAEz3AAAFVV +Wh0YkM9wpgAoAFkd2JPvoM9wgADwIgOAWhABAc9wpgDoByagFgpP/M9wgADwIgOAogngBQ2QANiM +HhiQB9iNHhiQANiLHhiQz3CAALAuIIBgeQTYgOAT8s9xgABQGhqBO4EkePG4C/KKINgJlg7v/Olx +eg3gAALYBPCuDaAHAdjPcqAAxCcPEgCGRCADAs9wgADwIiOAG4EPGhiADxIAhqO4DxoYgA8SAIYF +ew8a2IB8gc9woAAwEGSgz3CAAFTLEHiPGhiAz3CAAKSmz3OAAKS2EHgQu2V4kBoYgIogBACSGhiA +HYFAGgCAz3CAACgiUxoYgA8SAIafuA8aGIAA2BAaAIAegRwaGIDJA8/04HjgfuB48cDPcIAAwJ8Y +EAQACiHAD+tyz3AAAOUO3tutAS/2SiUAAOB48cDhxc91gADAn2rYvg3v/CaFJYUmpbYN7/xr2I0D +z/TxwM9zgADoIiSLUyDFAEwlgINSIQEAJKvM9wohwA/rcoogyAGKI8kOWQEv9kokAADPcoAAVBwV +IkIBI4oEIL6PAAYAAMW5I6siisW5IqsI9AGKxbgDqwCKxbgCqwGLRiDADwGrzghv/Whw0cDgfuB4 +8cCeCs/0z3aAAKgZQhYAEeC4oI4H8qlxhiH+D0EpvoED9ATfC/DJcCoJr/ZM2ZoKYAAB30IWABGg +rkQgAQFBKb6Az3WAADwZA/IijiKtRCCBAC8mQvAM8jGGJKVKFgERaB1EEEkWgRBqHUIQRCABAkEp +/oAH8iyOLq0tjiytI44trQhxhiH+D0EpvoEH8soJYARAFoAQQhYAEUQgAQRBKT6BBPIhhiGlRCAB +CEEpfoED8iKGIqVRIACAyiAhIDvyII5EIQAOhiH9Dye5Q7hrHUIQD60Arc9xgAAAGQmBKgpgACuB +II2H4cwhooEA2B/0AtgPrUIWABGGIP0PQSj+gQv0h+EB38InwRP7f+lw/g2v90AmARTmCUAAANjP +caAAwB0IoQTYCaEB2BpwAI7AuAGtQhYAEYYg/Q9BKP6BB/LpcMoNr/dAJgEUAhWEEGgVBRFqFYYQ +AI0hjUGFHgnv92KFBg2v90AlABNMIECgQPTPdoAAOCEAhgHggeAApgr0AdnPcKAAyBwxoKYJYAko +cADYVgzv9464GnAuuMC4BLhPIMEAz3CAABw9AIjPd6AA7CeB4AHYwHgHuCV4ELiFIJEABqeqC+/0 +AdhPIAAgBqcAhkIgQIAApgb0z3GgAMgcANgRoTYJ7/cA2AjwDMiIuAwaGDD2DM/0AI2A4PDZwCki +Bsoh4QPAKSEGMgvv/IogkwbxAM/04HiA4PHANNgH9IIKT/1QIEEEBfB6Ck/9TyBBBLYKb/002NHA +4H6A4PHA9NgI9F4KT/1QIAEA9NgH8FIKT/0IcfTYgLmOCk/90cDgfuB4z3GgAKwvgOAVgdAg4gHP +IOEBFaHgfuB48cDhxQh1iiCTB7YK7/yKIUkFjgjv9694hQDv9AjY4HjxwIogkweaCu/8iiFJAvIJ +z/cI2NHA4H7xwOHFCHWKIJMHfgrv/IohyQjPcAAA//9OCAAAANheDiAACHGmD+//qXA9AO/0CNjx +wIogkwdSCu/8+9kSDc//z3CAADwZAIiC4Ar0z3CAAOQZA5CMIMOPANgD8gLY0cDgfuB48cCOD6/0 +iiCTBxoK7/yKIQUGAN2pcNoPIACpcc92gAA8GQOOgeAa9AGOgeCjrg30Sgzv/6lwBgsP/d4PIAkC +2A4P7/+pcJ4PAAA6DyAAtK4A2MYNIAAIcaEHr/QI2OB48cAqD6/0iiFECaHBCHe2Ce/8iiCTBw4P +IAAB3s91gAA8GQGNgeDDrRb0xg7v/8lwhg8gCQrYpgoP/XoJL/0A2M9xoACcMQuBmribuAuhzgvv +/+lwFg8AANStz3WAADghAIUB4IHgAKUI9M9woADIHNGgRg8gCQHYi3HuDa/1iiCIDwCFQiBAgACl +B/QA2c9woADIHDGgABQAMSe4wLgaDSAAAdkI2O0Gr/ShwPHAiiCTBxIJ7/yKIQQECNjRwOB+8cBm +Dq/0iiEJDBpw9gjv/IogkwfPdYAAPBkWFQQRTCQAgBUVhRAF9EwlQIIQ9kwkAIAF8kwlgIKK9goh +wA/rcoogSACVBO/1iiPKD0wkAIAU8gDYDyBAAQQgAAELtV4IIACocEAlABqyDG/2QNlAJQAWqgxv +9hDZBg7v/wpwTQav9AjY8cCKIJMHegjv/IohCQ/Pc4AAPBkCE4QAaBMFAWoThgAAiyGLQYOaDa/3 +YoMI2NHA4H7gePHAng2P9FpwBSKBL766AAA6CO/8iiDTCQDfDyePFOl0hCSJkgneSiOAIg70CiHA +D+tyiiDIAIojxwcKJIAE5QPv9bhzz3WAADwZS5VAJRAWCyLAg0AlERoI9EAqASSKIBMKRXnJd5Xw +5npLtYog0wnaD6/8SHEWFQQRTCQAgGnyANkKJMB0KHCoIIADESRAgAjy8CFCIFBwyiNFIMoghQAB +4S95TCOAokT2TCMAoAz2CiHAD+tyiiCIAGVoZQPv9QolwAQVJc4UFRWFECqG8CFAIRBxzvcKIcAP +63JAKw4iiiAIAIojyAM5A+/1BSWFA0ArASSKINMKUg+v/AUhAQEVJZQUKBQAICqGEHFcACYAyibG +FE4Lr/fFv89wgADkCCKQANoPIsIExbrmeSKwIpBFeSKwMiDAJGYJr/cqhkqGiiDTCigUASAIukV5 +C/AWC4/3ANnPcIAA5AgisCuViiBTCuoOr/xqdkwiQKAJ38on4RArlRUhjCQA2AAiEiTVrQCkABoC +IBC+iiCTCsV5vg6P/GEEr/TpcPHACgyP9Dpwz3aAADwZiiDTCKIOr/wrlgDdDyVNFKl0hCSJkkAm +EhpAJhMWDfQKIcAP63KKIMgAiiOGBAokQARJAu/1uHNLlgQlgBAQdQn0QCkBJIogEwlFeQnfUPDP +cIAA+BkyIE8Ez3GAAIwPRCeAEx148CEBAIDhUycDEAr0iiDTCAUhgS/QugAACd848BUmUBQoGEAg +gOIAI0wkYKwK9FMlQhHPcIAA5AhCsBUeQhQV8BWO8CIAIBBx0/cOCq/3FR5CFM9wgADkCCKQUyVC +EUV5IrAoEAEgLgiv91MnABBMIUCgAd/CJ8ETA78LlgHnBX2weYog0wirtrYNj/xhA6/06XDgePHA +EguP9M9ygABMPmKSz3WAAARqQIWkwUDCQpXYEQQAz3WAAEBrBByEMECFQsJClQwchDC0gFyBsXLY +coP3AiJGA1OAt4FQdcIlhhDPcoAABD8GEgUByBEOAP/aCLpEfii+AByEM8wRDgBEfii+AhyEM9AR +DgBKJMBwxHoougQchDDsEQIACByEMPARAgD0EQEAChyEMAwcRDAA2kh2qCAABAPZESGAgwnyFCSB +M+CRCCLCAySRCSNDAAHmACWBEQUpgQ8DAAAgL3EFLT4BN3FF94wQAQAB4QLwANmwgIwYQABVIM4F +UyXBEBQmQRBAsVwQAgFKJAB0AN+oIEAC9CbBEzByyiJLAAHnVSDBB5AYhADCvRQhTQNgtXwQAwFK +JAByANqoIMAB9CGNAAgjQwMB4gbjcHuSGMQAQQKv9KTA8cDSCa/0mHBvfwO/pG/PcIAATD62YKJv +tWCJ4wbn8GAG9OqRjCcCmMogawCB4gr0dHlBkR1lsXKP9gJ6QbEK8ILiC/R0eUGRWGAQdoX2AbEB +2ZgcQgDlAY/04HjxwHoJj/QIdSh2z3CAAAgaggxv96ioXgmgBalwgOUN9K4ID/+B5gn0BNoA2c9w +oADAHUigKaCxAY/04HjxwD4Jr/QA2Qh1AYjCuIHgY/TPdoAAQBoBhkGFByC+gA70AIVAhgQggA// +/wAABCKCD///AAAHIj6ATfIA2M9xgAAIGgqpAo3luA/0z3KAAOgiRIqQ4gHawHpEeFEgAIAD8gHY +CqkCjYYg/wxCuAmpI44DjcC5wLgQcSjygOAi8gSNRY3FuFMiQQCGIv8MQrqEKJMICiRAjllhhClJ +DAAhBXHMJSKAC/QKIcAP63KKIAgB+Qav9YojSAOIcKhxBPAA2Ahx2ggAAAGFAdkBpgCFAKYB3h/w +guAD8gDZGvDPcoAASBoBgmGFByD+gA70IIUAggQhgQ///wAABCCAD///AAAHIH6A6/NhogCFAdkA +ogDegOEK8gGFz3GAAAgaAaEAhTYLb/cAoYEAr/TJcOB4ANnPcIAACBoqqCioKagrqCGgIKDPcIAA +QBohoCCgz3CAAEgaIaDgfyCg4HgF2M9xgACoGQKpAdgDqYog/w8BoQKhDNjgfwypz3KAADRcBoID +gCCAx3EtAMDGGQPgBkhwz3CAADRcmQLABuB48cCeD0/0KHXPdoAAABkrppThCaYA38X3QiUAFQLw +6XAKpslwDabJcCYOL/Yg2YDlz3GgAMAdCPLPcIAAkBkXiIHgDfQFgbW4trgFoQWBBaGmDu/+Ix7C +EwzwBYEFoQWBlbiWuAWhAdhaDu/+Ix4CEJUHT/TxwCoPT/R0gFyB2BENAHBywiLGAPeBM4Awd8In +RhAC289xgAAEP/QhxAAGEQUBANkuoPpiBSqCDwMAACAvcQUsfgM3cYwQDgDC926gBS1+AzdxTfeQ +EAEBlBACAQLhUHGD9uTmw/cB2S6gKQdP9OB44cXhxnSAXIHYEQ4AAiLEAFOAN4E8EAcAjBAIAAIh +hQDPcYAABD8C2vQhigAGEQkBz3WAAEw+QpVhlQoRBgGSEAEBo5UII0MAACUBAQUpgQ8DAAAgCiRA +DgUqvhMMJECO1vcqkIwhAojS9gLZL6CQEAEBfmWUGEQAIZAwdmwACgCieSGwAdmYGEIAMPAFKb4T +DCRAjlb3TCeAgBTykBABAZQQDgEC4TB2BPaMIAGZyvfBkAHZ3WWxci+gmPahsOXxTCeAgAz0oZAA +JsEAMHXI9gIljRGhsAHZmBhCAJAQAQGUGEQAANkvoAkiwgAhkDByhfZBsAHZmBhCAMHG4H/BxSJo +ANpAsEokwHXPcIAATD6oIIACFiCDAGCTFCGMAAHiT3pgtOB+4HjxwJINT/RygMiB2BECAHB2wibG +EHGAI4FwccIhxgAA389zgAAEP/QjxAMB3dlhBSmBDwMAACAvcQUsvgA3cfQjQwPtoMT3AtktoAfw +BSu+ADdxQ/etoKUFT/TgeEiBUqBDgVGgXIFUoDeB4H8zoOB48cAmDW/0AtsIdSh2AdgAsalwQgvv +/02FTYWpcMlxNgvv/wPbTYWpcMlxKgvv/wXbTYWpcMlxHgvv/wbbToWpcMlxEgvv/wnbToWpcMlx +Bgvv/wTbPQVP9PHA4cWKIAoLWg9v/HPZz3WAAOjIiiAKC0oPb/wghc9xoAAsIDCBJaXPcYAAELEo +gVEhwIEA2AvyJI2B4QT0JY2B4QPyAdiA4AryAIWB4MwgIoAk8oogygx82RzwiiDKDQIPb/yC2SCF +gOEY8gSNgeAF9AWNgeAB2ALyANiA4AXylgvP9grwgeEI8oogygyN2dIOT/wC2AClqQRP9PHAMgxP +9M92gAA4IQCGAeCB4ACmAN0K9AHZz3CgAMgcMaCaDOAIKHDPcIAAPAogkIa5ELkFIYIPAADCEs9x +oADsJ0ahAZAQuAUggA8AAAITBqEAhkIgQIAApgb0z3CgAMgcsaA5BE/08cDKC0/0z3CAADgyGYAA +3YHgyiHCD8oiwgfKIIIPAACoE8ojgg8AAJAByiRCAwgCovXKJUIDz3aAADghAIYB4IHgAKYJ9AHZ +z3CgAMgcMaACDOAIKHDPcIAAPAojkASQwrnCuAO4JXgQuIUgjQDPcaAA7CcGoQCGQiBAgACmBvTP +cKAAyByxoK0DT/TxwD4LT/TPdoAAOCEAhgHggeAApgDdCvQB2c9woADIHDGgpgvgCChwz3KAAHgz +AIrPcaAA7CcQuAUggA8AAMJpBqEBihC4BSCADwAAAmoGoQCGQiBAgACmBfTPcKAAyByxoEkDT/Tg +ePHAzgpP9AogAKDPdYAAFGcAFQQQK/JMJACAz3CkALg9ANoa9JsQAwbPcYAAGGdgoaYQAwbPcYAA +HGdgoZIQAwbPcYAADGdgoaMQAwbPcYAAEGdgoZsYmAD/2aYYWACSGFgAoxhYAAHYNPBMJACAyiHB +D8oiwQfKIIEPAAB+GcojgQ8AAPwCvACh9colAQTPcIAAGGcggM9wpAC4PZsYWADPcYAAHGcggaYY +WADPcYAADGcggZIYWADPcYAAEGcggaMYWADPcIAAPCkEgCK4wLjOCQAFXQJv9AAdABTxwO4Jb/QA +2M91gACwLiCFQHmM4BT0z3aAALguIIZgeQLYgOAM9CCGYHkD2IDgCPTGC+/8UNhRIICBBPIA2APw +AdgvIQcgz3CAAKw7z3eAAMgu7gxv+ACnz3GAAIBCFIEB4BShz3GAADghAIEB4IHgAKEJ9AHYz3Gg +AMgcEaEGCsAIz3GAALQyBIGB4BX0JoHPdqAA7CdgeQDYz3CAAMy7GIiA4Bf0z3ABAAYBBqbPcBIA +BgQW8AohwA/rcs9wAACHGYojxQlKJAAAnQdv9QolAAHPcAEABwEGps9wEgAHBAamz3CAAMy7IICA +4QOALPLgh0QovgPG2JK4BqYghSd3YHkA2IzgOPIghWB5ANiQ4DLyIIVgeQDYkeAu8iCFYHkA2JLg +KPLPcDkAAjMGps9wOQCCTAamz3A5AAJmBqbH2JW4GfBEKL4DACGPf4AA/HLH2JK4BqbPcAAAAjMG +ps9wAACCTAamz3AAAAJmBqbG2JW4BqYeDM/9z3CAAMy7GIjPcYAAzLvaCSAFIIFMIQCgFfLPcAAA +Am4Gps9wwQBCbgamz3ADAMJuBqbPcDYAQpcGps9wAgBCawamz3AQAIdyBqYFjxC4BSCADwAAQnAG +pgSPELgFIIAPAACCcAamA48QuAUggA8AAMJwBqYCjxC4BSCADwAAAnEGpgmPELgFIIAPAABCcQam +CI8QuAUggA8AAIJxBqYHjxC4BSCADwAAwnEGpgaPELgFIIAPAAACcgamAY8QuAUggA8AAEJyBqYL +jxC4BSCADwAAgnMGpgqPELgFIIAPAADCcwamIIVgeQDYjOAQ8iCFYHkA2JDgDPIghWB5ANiR4Aby +IIVgeQDYkuAJ9AyPELgFIIAPAADCfwamz3ABAEZqBqbPd6AAyB+kFxAQTCEAoAnyz3BQAMZzBqbP +cCAAx3Mc8CCFYHkA2IzgGfIghWB5ANiQ4BPyIIVgeQDYkeAP8iCFYHkA2JLgCfLPcIAABnQGps9w +gAAHdAamz3CAAMZzBqbPcEAAQnQGps9wgADHcwamz3ACAEZqBqbPcBAAxmoGps9wgADMu1iIz3GA +AMy7AIgkiYDiAdrAes9zgADMu5oMIAh5iyTYGNliD6AIM9qB4Bbyz3CAAIBCUBAEAM9wgADMuwwQ +BQAKIcAP63LPcAAAihn5BG/1iiMHB0whAKAF8s9wBgBCawamz3AQAMdqBqbPcBAAhnIGpkwhAKAG +8s9wAgBGagamqgpACK4JQAgk2AHZ9g6gCDPageAV8s9wgACAQlAQBADPcIAAzLsMEAUACiHAD+ty +z3AAAKookQRv9YojxwykFwAQz3GAAIBCAiAABBOhz3ACAEdqBqYghWB5ANiM4BXyIIVgeQDYkOAP +8iCFYHkA2JHgC/IghWB5ANiS4AXyz3BlAMJuBqbPcIAAOCEAgM9xgAA4IUIgQIAAoQX0ANhRHxiQ +DQYP9OB48cCeDQ/0z3CAADgyFICA4Ivyfgnv/QfYenDPcIAAXD8MiIYg/wFDuGG4huD0AA0Az3aA +AMy7JIbPcoAA/LkzJgBwgABQaEAiEQsEuTR5QCIQCkAiEgZAIg8IQCINBDpiQCcBchR5AHnPcYAA +4DNIcFXwz3GAAAA0BGpR8M9xgAAgNEAiAAJL8EAiAAPPcYAA4DMODq/9ANoEhs9xgAAANAS4FHi4 +YDvwQCIAB89xgADgM+4Nr/0A2gSGz3GAACA0BLgUePhgK/BAIgAFz3GAAAA0zg2v/QDaBIbPcYAA +IDQEuBR4QnAb8EAiAAnPcYAA4DOuDa/9ANoEhs9xgAAANAS4FHgCcJoNr/0A2gSGz3GAACA0BLgU +eCJwhg2v/QHabg2v/Wpw0QQP9OB48cDPcIAAODIPgIDgEPLPcIAAzLsEgM9xgABMuwK4FHg4YM9x +gABANOYJz/3RwOB+8cBWDC/0RNrPcIAAuHLPcYAAsMlWC2AFAN4C3RYIIADJcGG9gOUB5jr3mQQP +9OB48cAeDC/0ANrPcYAA8CIVeWCBBLgAIJAPgABAb7kbmAAAgQQQDyDPdoAAuHK+GNgDoIFChoog +Bw9hhh1l8B2AEOwdwBAggUaGz3WAALDJZYY4YPgYgAAWJsET9BjAABYlwBME4AThggwv9AjaDBAA +IBZ+Fn0EbSRubgwv9AjaBQQP9OB48cCaCy/0EtmpwQh2bg/gB4twSiQAcQDaqCCAAhYkgDAoiIHh +w/ZhuSioAeICwgHDz3WAAPAi1X0AhYohBw/0bsd3gABAbzhg7BjAAPAYgAAAhQbCBcM4YPgYgACD +wfQYwAAEFxAQz3CAALDJFiAABATg8gsv9Aja44fPcIAAsMmHwfZ4BODeCy/0CNoAwCCFuRkYACCF +uREABlEgAIAJ8r4Z2AMghb8RAAaAuAfwvhkYBCCFvxEABqC45grv+78ZGACA4AX0VgrP+4DgA/IA +2ALwAdgQdvwPYQjKIIEDAIW5EAEGUSFAgPHZwCkiAcohgQ8AAJMAwCkhAYYLr/mEGEAA/QIv9KnA +8cCaCg/0z3aAAABngOHPdYAA9AoS8iCGgOEN9ACl6grv9g7Ywgwv/oogEAAB2ACmDvAghSV4C/CW +Ce/2DthuDC/+iiAQAADYAKYApbkCD/TxwDoKD/TPcYAAlC4AgaC4AKEaDm/6AdjPcIAAxLAAEAQA +TCTAgMohzQ/KIs0HyiCNDwAAgQzKI40PAADaAHgAbfXKJe0ATCQAgMgALgAA3RRtACCBD4AAxLAH +keaRxJEQuAV/BZFDkRC4BX4CkRC6RXgacFIN7/XpcVpwz3CAAKx68CBBA0QtPhcKIUAuACGAf4AA +jF4goFIL7/kKcAhxACGAL4AAgF4GDUAGiiDMDi4ML/zp2YogDAgmDC/8SnGKIAwIGgwv/Mlx0XeD +94DmGPTPcIAAoHrwIEEDRC0+Fy92ACGAf4AANF8goP4K7/lKcAhxACaAH4AAKF+yDEAGz3CAAMSw +AIAB5RB1RAfF/4UBD/TgfuB4z3GAAOgwz3CAALQy4H8ioOB+4HjxwB4JD/QA3s91gAD0yc9wgAC4 +LiCAwKVgeQHYg+DKIcIPyiLCB8oggg8AAJgZyiOCDwAA6wDKJGIAUAci9colggMAhZi4AKUA2MGt +wq2OuAGlAqXPdoAAvC5AhgbYYHoB2UCGB9hgegHZAY0dAS/0AK3geOB+4HjgfuB48cDPcIAAeGIA +gIXgfAAFAM9woACsLxqAUiAAAFEgAIA09M9xgADcnwuBAeALoc9wgACkLgCAQHgyDwAAz3CAAKAu +AIBAeJ4IwAB+DU/9Ig5P+wbwygzv+4ogiQzPcKAAeEUAgAQggA9wAAAAQSg+hfL1z3CAAPAiI4BI +gTSRUyIAAHIJIAMB204Pr/YS2NHA4H7gePHA4cW0wYogmAmaCi/8WtkH2BYJ7/YB2QXwcgzv+4og +iQzPdaAAtEdxFQCWBCCAD3AAAABBKD6F8fWKIP8Pbx0YkGsdGJAF8EIM7/sw2M9woACwHwGAhiD/ +AYDgAdjAeC8mB/Dy82YKr/eLcA4Lj/uA4A/ybxUElmsVBZYKIcAP63LPcAAAsRPxBS/1NNsI2JYI +7/YB2UINT/fqDoAE5Qfv87TAQIgB2AChaLoCulV6x3KAADgyY4JjoWGCYaFigmKhZIJkoeB/AKLg +ePHAPg/P8893gAB8YgaHA4DPdYAA3J8ggEmFACKADy0AwMYCeYDhggAsAKHBz3aAADghAIYB4IHg +AKYK9AHZz3CgAMgcMaCGD2AIKHCLcS4O7/RC2ACGQiBAgACmBvQA2c9woADIHDGgABQEMQQkvo8A +ABf/yiHCD8oiwgfKIIIPAACmE8ojIgwkBSL1yiUiAACFgrh2DSAAAKUmCCAAAdgAhaK4AKUphcdx +LQDAxvoJYAbpcPEG7/OhwOB48cBaDs/zz3GAAERqAIGvwU3ABInPd4AA8CJuwAOHCIBTIBMANxSA +MEHALsBCwDYUgDBDwM9wgABQGjqAG4AkeM9xoAC0R0cRAYYxuIDhwLgG9IogmAztBCAATNmA4NwE +AQDPcIAA3J8AEAQAUSRAgMohwQ/KIsEHyiCBDwAAqhPKI4EPAABaAGgEIfXKJSEAz3WAAJQJiiAY +B4IIL/wglSCVz3CAANyfIrAA2Z65z3CgALRHUxhYgOB4ANlTGFiAug+P/s92gAA4IQCGAeCB4ACm +CfTPcaAAyBwB2BGhMg5ACC3Az3WgAOwnELgFIIAPAABCLQalQCSBPMYM7/RC2M9wCACHEAalAIZC +IECAAKYG9M9xoADIHADYEaHPcIAAvLIWIMAEJIAAgAq5ybgEIYEPDwAA/AV5z3CnABRILaDyCk/9 +TCMAoETAD/KKIf8Pz3CgALRHbxhYgGsYWIAH2D4Or/YD2QHYz3GgALRHYBkYgM9wgADgOiCQKHCG +IPsPjCAEgAHYwHiB4BD0z3CgAMAdB4AEIYEPAAAAPIYg/w4iuAq4JXgE8AfYCrgjhzIhgQ8AANgC +gOEB2cB5D7mQuZu5n7kleM9xoAC0R18ZGIAAhgHggeAApgj0z3GgAMgcAdgRoSoNQAhAJIE+0gvv +9BHYAIZCIECAAKYH9M9yoADIHADZMaLPcYAAHD0niUohACCB4QHZwiFBAIDhRcF2AiUACiJAJALA +AcECIFkABvDSCO/7iiCJDM9woAC0R3EQAIYEIIAPcAAAAEEoPoXy9c9wpwAUSADZN6BMIQCgLydH +FAj0z3CAAEcEBqUacQjwSiCAIM9xgABGBCaliiBYCJoO7/sqcYogWAeSDu/7CnEAhgHggeAApgj0 +z3GgAMgcAdgRoWoMQAgFv/B/EL+Bv4e/jL/mpQCGQiBAgAb0z3KgAMgcANkxokolACGqdwHggeBh +vwCmCfTPcaAAyBwB2BGhLgxACAPANW8leBB4ELiFIIoABqXpcIAggg0QeEbABriBuJe4BqXpcIAg +Qg8QeEfABriBuJe4BqXPcAAAAi8Gpc9wAADCMAalAIZCIECAAKYH9M9xoADIHADYEaGIwInBisKL +w7oIoAVAJAQ8LMCA4An0z3GAANBCEIkB4A94EKlMIUCgD/RMIwCgC/KGDk/7geAH9ADYbMBPIgAg +LyIHIM9xgAC8shYhwQQwERgACMLPcIAAFKAWINQDCcDwHIAg9BwAIAgigA///wH/LyZAJgQuPiAv +cIoIL/oogQ4glw8AAAABCcCIIHwABCi+BS9wcggv+gtxDiCCDwAAAAEJJ4EvAAD/AQkigA8AAP8B +SCEBAEggAAAswlQcWCCB4lUcGCAM9ATDQCgCIQa7emL1esdygAD4siKyA7IAhgHggeAApgj0z3Gg +AMgcAdgRod4KQAgEwUAoACEGwga5OGD1eMdwgAD4siKQBrqBujx5ELlFeSalA5AceQfAELkGuIG4 +JXgGpQCGQiBAgACmB/TPcqAAyBwA2TGiQiVVIEwlAKBOBs3/BcFAIVEgMnGaBcb/OhQBMVEhwIHK +IYIPgABGBMohgQ+AAEcEJqUB4IHgAKYJ9M9xoADIHAHYEaFSCkAIMhQAMRC4gbiHuIy4BqUAhkIg +QIAApgb0z3GgAMgcANgRoUwjAKDKICICsAqi9soh4gBaCo/+BfAKDq/7iiCJDM9woAC0R3EQAIYE +IIAPcAAAAEEoPoXx9TYPD/fPcIAA3J8MgM9xgADcn0JwDKENgQHgDaEI8IogmAyKIQQD2gvP+1UB +7/OvwOB4ANnPcIAA+J8sqC2o4H8uqOB+4HjxwCYJz/MIdi64wLgEuE8gwQDPcIAAHD0AiM91oADs +J4HgAdjAeAe4JXgQuIUgkQAGpb4L7/MB2IC+xqVVAc/zz3CAAAchz3GgAOwnBqHPcIAARzoGoc9w +gADHUwahz3CAAMckBqHPcIAABz4Goc9wgACHVwahSdnPcKcAiEkwoOB+4HgB2c9woADIHDCgS9nP +cKQAHEAkoOB+4HjPcQEA/H/PcIAAqC7gfyCgz3GAANyfAIGAuOB/AKHgePHAagjv87hwUyCBAM9w +gAA0eihggeDKIcIPyiLCB8oggg8AAJUZyiSCDwAA/gCoBuL0yiPiB892gAC4LiCGYHkB2IPgEfIg +hut1YHkB2Lhwz3AAAJYZCiHAD6lyItt5Bu/0iiSDD3EA7/MB2AnZ4H8goOB48cDhxc91gAC4LiCF +YHkC2IDgIIUI2Aj0QHkQec9wgABcDQfwQHkQec9wgABEDpIPj/R2D2AEAdhWC0/9og8AACoIAAAl +AM/zCHFYiQGAgOICoQn0WYmA4sIgogDAIKEAAqHgfuB+4HjxwIoPj/PPdoAAOCEAhgHggeAApgDf +CvQB2c9woADIHDGg9g8gCChwx9iUuM91oADsJwalz3ADAIJsBqXPcAMAwnQGpc9wAwBClgalxtiQ +uAalxg8gCArYz3AAAIJsBqW2DyAICtjPcAAAwnQGpaoPIAgK2M9wBQBClgalmg8gCIogBw3PcAAA +QpYGpYoPIAgK2M9wEwDGAAalfg8gCDLYAIZCIECAAKYF9M9woADIHPGgQQeP8+B48cDODo/zGnDP +daAArC8VhVEgAIAg8gDY/gnv9o64CHcuuMC4BLhPIMEAz3CAABw9AIjPdqAA7CeB4AHYwHgHuCV4 +ELiFIJEABqZWCe/zAdiAv+amTCAAoAf0z3CAAKQuAIBAeErwFYVRIACAyiHBD8oiwQfKIIEPAAB/ +GcojgQ8AAKoAyiTBALgE4fTKJcEAz3ATAMcAz3agAOwnBqbPcBAABmkGpsfYlbgGps91gAA4IQCF +AeCB4AClCvQB2c9woADIHDGgmg4gCChwz3AAAEItBqbPcAAAgkYGps9wAABCYAamAIVCIECAAKUG +9M9xoADIHADYEaE5Bo/z8cDaDY/zz3CAALAuIIChwWB5BNiA4DPyz3aAADghAIYA3QHggeAAHEQz +AKYJ9AHZz3CgAMgcMaAqDiAIKHCLcdIMr/QA2ACGQiBAgACmBvTPcKAAyByxoAAUATHPdYAAvC6G +If8MQIVCuWB6AtgAFAExQIUD2GB6wbnNBa/zocDxwFINr/MD2M92gACwLiCGz3WAAHg8YHmiwYDg +BvIghmB5BNiA4Ab0ZwMgAEgVBBAD2Bpwz3enABRIz3agAOwn9ghv/QXYDqXPcIAAOCEAgAHggeDP +cYAAOCEAoQn0AdnPcKAAyBwxoHoNIAgocAPYIgyv9KlxBNgaDK/0Im0F2BIMr/QkbQrYCgyv9CZt +D9gCDK/0QCUBEjbY+guv9EAlgRI32O4Lr/RAJQETONjmC6/0QCWBEwiHBKUNhwWlDocGpc9wpwCY +RxyAB6UXhwilFocJpc9wqwCg/xiAC6XPcKsAoP8ZgAylz3CrAKD/GoANpc9wAwDGAwamxtiQuAam +z3AsAAIBBqbPcFkAQgEGpoogigAGps9wQACHDQamz3DRAMINBqbPcMAABw4Gps9wgAA4ISCAgeEG +9M9yoADIHADYEaIB2AinANgNpw6nz3CnAJhHz3JQAP8AXKAA2BenFqf82s9wqwCg/1igfNpZoBqA +z3KrAKD/gLgaooHhz3CAADghIKAJ9M9xoADIHAHYEaFSDAAIz3BAAIYNBqbPcBAAAg4Gpotw8glg +BYHBNoUAwCJ4BCiADwAAdAkVhTeFAnlSDa/zL3ABwk/gz3GAAIihFKVXoRihz3BAAIcNBqbPcBEA +Bg4Gps9wgAA4IQCAz3GAADghQiBAgAChBvTPcaAAyBwA2BGhi3CSCWAFgcE2hQDAInh+D2/6EqUy +hVWFLHg3hS8gQA5CeTlh5gyv8zV54LgceMAgYgCCIMQCz3GAAIihEqUTpRahz3CAADghAIABwgHg +VaGB4M9xgAA4IQChCfTPcaAAyBwB2BGhdgsACAGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAG +pgSVELiFII8ABqYFlRC4BSCADwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbPcIAA +OCEAgM9xgAA4IUIgQIAAoQb0z3GgAMgcANgRoQSFK4UIpwWFDacGhQ6nCIUXpwmFFqfPcKsAoP84 +oCyFOaAthTqgLgsv/Q6FMoWMIYKARfaMIT+BDPbGCiAICtiyCgAFQiBAIIDgBgXN/wbwugyv+4og +0QUyhYwhgoBF9owhP4EF9qYMr/uKIBELSBUEEIwkgoBF9owkP4EM9gohwA/rcs9wAAC0GYojRQxV +AO/0uHPPcIAAuhcAiIDgB/LPcIAA2DwAEAQAiHAlAq/zosDgeM9wgAB4POB/FIDgeM9xAQAEmc9y +AQCQjyUDL/kA2OB44H7gePHAz3CAAKQuAIBAeM9wgACgLgCAQHjRwOB+4HgA2c9wgABUCuB/IKDx +wHIJj/PPcIAAsC4ggKHBYHkE2IHgkfSqDy/799iB4Iv0ANgAHAQwz3eAADghAIcB4IHgAKcK9AHZ +z3CgAMgcMaC+CSAIKHCLdQDYYgiv9KlxABQFMahwhiD8A4wgA4wN8gohwA/rcs9wAAC+GYojBAFx +B6/0iiSDD892gAC8LkCGhiX8DwDYYHpCLYEBQIYB2GB6A9kB2BYIr/SpcUCGCNhgegAUATEAFAUx +TCUAgMohwg/KIsIHyiCCDwAAmhnKI4IPAAASARgHovTKJGIAAtjeD2/0qXFAhgTYYHoAFAExEtjK +D2/0qXFAhgXYYHoAFAExABQFMUwlwIDMJSKByiHCD8oiwgfKIIIPAACcGcojgg8AABkByAai9Mok +YgAAh0IgQIAApxb0z3GgAMgcANgRoRDwz3WAALwuQIUB2GB6A9lAhQTYYHoIcUCFBdhgegTZhQCv +86HA4HjxwBoIj/PPdYAAOCEAhQHggeAApQDeCvQB2c9woADIHDGgggggCChwz3CAAAYhz3GgAOwn +BqHPcIAARjoGoc9wgADGUwahz3CAAMYkBqHPcIAABj4Goc9wgACGVwahAIVCIECAAKUG9M9woADI +HNGgz3CnAIhJ0KANAI/zCNnPcIAA9MngfyOg8cCSD0/zz3aAADghAIYB4IHgAKYA3Qr0AdnPcKAA +yBwxoPoP4AcocM9wAADCLM9xoADsJwahz3AAAAJGBqHPcAAAwl8GoQCGQiBAgACmBvTPcKAAyByx +oKUHT/PxwGoOL/YW2G4KAAXPcYAA8CIAgcQQAAZRIECBB/QBgcQQAAZRIECBBPL+Du/2E9jPcIAA +mC4ggGB5C9jRwOB+8cBCDS/7iiCIBYDgDfJyCa/8ANjPcIAAsC4ggGB5BNiA4NwMAv/RwOB+4HjP +cIAA8CIDgAiAz3GAAPTJUSAAgAPyAYkC8AKJ4H8AqYDg8cC4cQ70CiHAD+tyz3AAAKcZiiPEC/0E +r/SKJIMPz3GAAPTJIIFMJQCABCGBDwAHAABBKQMGANnKJE1x4HjoIG0D8CBFAAQlgg8BAADALrpl +elBzBfQB4dHA4H4KIcAP63LPcAAAqBmKIwQOqQSv9EokQADgePHA4cUA3c9wgABcCaYIIACgoM9w +pwAUSKigjQZP8+B48cChwbhwANhAwFMlgACB4BHyguAg8oTgJfIKIcAP63LPcAAAqxmKI4oKVQSv +9Iokgw/PcIAAuC4ggGB5AdiE4AHZwHnPcAAAItI0eM9xgAAT7g/wz3AAACPSz3GAABbuB/DPcAAA +JNLPcYAAGe4p2hK68CIAAA4ggg8AAQAAQMKLcKYMoAQD2qHA0cDgfuB48cB6DU/zA8iUEAAAz3aA +ADghBCCQDwEAAMAAhkEokCMB4IHgAKYA3Qn0AdnPcKAAyBwxoNYN4AcocM9xJAAHAc9woADsJyag +iiGFACagUyCBIIHhE/KC4TDyhOE+8gohwA/rcs9wAACIGYojBgOKJIMPfQOv9AolAATPcYAA8CIj +gSiBUSEAgMohgg+AAMcgyiGBD4AAhyQmoM9xBADHMSagAIZCIECAAKYG9M9woADIHLGgKQVP889x +gADwIiOBKIFRIQCAyiGCD4AABzrKIYEPgADHPeLxz3GAAPAiI4EogVEhAIDKIYIPgACHU8ohgQ+A +AEdX0vHxwM9xgADwIiOBLygBACiBwLkAIYMPAAAi0k4ggQcp2BK48CDAAM9zgADMu3iLz3KAABPu +gOOhwUDAB/QCIIAPAAAAwEDAi3A0eVlhUgugBAPaocDRwOB+8cAyDG/zuHDPcCwABgHPc6AA7CcG +o89yqwCg/xqCUyWNAIHlANkS8oLlNPKE5VTyCiHAD+tyz3AAAIEZiiOFA10Cr/SKJIMPz3WAAPAi +o4Wohc92AgCCAlElAJDKJYIfgADGIMolgR+AAIYkpqPGo891BADGMaajz3VIAEIBpqPPc6cAFEg3 +o4C4GqIRBE/zz3GAAPAiI4Eogc91AgCCAlEhAIDKIYIPgAAGOsohgQ+AAMY9JqOmo89xBADGMSaj +z3FKAEIBJqMB289xpwAUSHeh3PHPdYAA8CKjhaiFz3YCAIICUSUAkMolgh+AAIZTyiWBH4AARlem +o8ajz3UEAMYxpqPPdUwAQgG78fHAHgtP8wPIlBAAAAHez3WnABRIyKUEIJAPAQAAwNoO7/9BKIAj +/9ibuM93pwCYRxyniiASDYYNb/tBKIEjz3GAAFwJAIGA4Mohwg/KIsIHyiCCDwAArBnKI4IPAACy +AMokIgAsAaL0yiUCAQDYFqXapxEDb/PAofHApgpP889wpgCcPxmAUSAAgF/yz3WAAGgJAIVGgKAS +AAYvKAEATiCBB0Ep0ABMIICgCfdIcIAgCgAyIAAEgOAP9AohwA/rcs9wAACtGYojSwKKJIMPxQCv +9AolAATPdoAACO5AJsAS8ggv9QnZANjWCa//DyAABIDgANgPIAAEBPQeDM//BPCeDc//A8i5EIAA +G3iAuAquAIUmgJYhQQMAIQAEGIiMIMOPAnEE8mG4D3gYqYogUg0A2YoMb/sPIQEEAIUmgKARAAaf +GRgAsgvP/zkCT/PgeM9xKgAVAM9wgACYYuB/IKDxwLoJT/M6cBt9z3CmAJw/ZBAQAFEgAKAV9HYM +b/MD2GG9jCX/n/P1CiHAD+tyz3AAAKQoUdsKJEAE+Qdv9AolAATZAU/z4HjxwHYJT/PPcaAArC86 +gVIhAQBRIQCAocEA3pj0gODPdYAAOCFY8s4Jj//Pd4AAsC4gh2B5yXCM4AfyIIdgeclwkOAghSv0 +AIUB4IHgAKUK9AHZz3CgAMgcMaCuCeAHKHCLcVYIb/SKIAcFAIVCIECAAKUG9M9woADIHNGgABQF +MUwlwIAq8gohwA/rcs9wAACJGerbVQdv9JhzAeGB4SClCfQB2c9woADIHDGgWgngByhwz3EGAAJ1 +z3CgAOwnJqAAhUIgQIAApQj0z3CgAMgc0aAE8OoIAAAAhQHggeAApQn0AdnPcKAAyBwxoBoJ4Aco +cM9wgADwIgOAxgtv9g6Az3GAABw9GnAuuMC4BLggiYO4z3egAOwngeEB2cB5B7kleBC4hSCRAAan +Hgtv8wHYTyAAIAanAIVCIECAAKUG9M9woADIHNGgkQBv86HA4HjxwG4IAADPcIAAsC4ggGB5A9iA +4KALwgTPcIAAPCkEgFEggIAL8s9xgADwIk2BPpFTIgAASglgAgHb0cDgfuB48cDhxc91gABwPACF +USAAgAz0hgwABHILj/omDk/3/g3P/wCFgLgApTkAT/PxwA4O7/qKIAQCgOAR8hoOj//GD8//z3CA +ALAuIIBgeQTYgOAF8qoPT/8OCAAA0cDgfuB48cCODw/zz3WAAHA8AIVRIECAHfTPcIAAsC4ggGB5 +BNiA4BXytg3v+uLYgOAP8j4L7/wH2NYPoAQIdiYOD/8uCO/8yXAAhYG4AKWxBw/z4HjgfuB48cA2 +Dw/zpBABAPi5CPK2EAEBz3CgAJgDPqCf8AAWDUG8sAAWAkFdsAAWDkDPoAAWAkFAGIQAABYCQFGg +ABYCQUgYhABEJQIThOIa8hjbchjEAAAWA0CI4nOgABYDQVAYxAAAFgNBVBjEAAj0qXOGI/MPjCMM +gA7yGNsW8BDbchjEAADfz3OAABTL57MQ2wzwHttyGMQAABYPQPagABYPQVwYxAOpd4Yn/RyMJwKS +CfQC43B7chjEAAAWD0EC8ADf4btgGMQDBPIAFg9BKHSEJAyQBPQA2iPwgOIa9FEmAJDRISKCFPLQ +iKi5z3KAABDfpBhAAAK+1n7CYv66BPKLuaQYQAAA2lqgW6Dm8QAWAkBaoAAWAkBboAjadBAOAb4Q +DwHCf2J/Qn+4EIIAmLmkGEAAz3GgAJgDQn96YlB6chiEALoQAgHwf3AYxAOlelywPoG2GEQASQYP +8+B48cDaDS/ziiAHBs92gACUHGIIb/sghhXdz3eAAOgSAIbpcVJoAeAAplR6WGECgIDgWWES8s9y +oAAsIFCCQnjXcElrANIA28j3YqGKIMcFJghv+yCJAIaq4IP3ANgApmG9gOW+B83/3QUP8+B48cDP +cIAAdBEO2QHa/gogAADbz3CAAKwRCdkB2u4KIABIc89wgACgECrZANreCiAAANvPcIAASBEL2QDa +zgogAAHb0cDgfuB48cDhxc91gAAKPYogRwayDy/7II0E2BYIr/oB2c9wgAAJPQCIsgsgACCNdQUP +8+B48cDPcYAACj2KIMcGgg8v+yCJz3CAAChn0g9ABdHA4H6A4PHA2HEL9AIJAAAA2SKgiiDHBVoP +L/vIcdHA4H7gePHAugwP88oNz/rPdoAAXApm2CJuAdo6Ci/8SHOA4Az0CiHAD+tyz3AAALYU2duK +JIEJPPACFgURTCUAgMwlgo8AAP//DPQKIcAP63LPcAAAtxTc29ECb/SKJIEJZ9jJcQHa7gkv/Ehz +gOAM9AohwA/rcs9wAAC4FN/biiTBCRbwAZYkbgHaAeAQeMYJL/xIc4DgoZYO9AohwA/rcs9wAAC5 +FOLbQCVEEH0Cb/RKJQAAAm0QeCZuAdqWCS/8SHOA4Az0CiHAD+tyoZbPcAAAuhTl20AlhBDq8U0E +D/PPcaAAYB0SsRSR4H6B4PHAuHEc9EwlAIDE9kwlgIPM9gohwA/rcqfYBbic2x0Cb/RKJAAAQC2A +ABR4QiABA89wgAAIEhlhH/DPcIAAuBYyIEABjCDDj8ohwQ/KIsEHyiCBDwAA4RTKI4EPAACiANwB +YfTKJCEAArgUeAAggQ+AAOgSKHDRwOB+6LgI8gQgvo8AAAAYAdgD9ADY4H8AqeB48cA6Cw/zz3WA +AJYJAI3Pd4AAlAlaD+//II9BiM92gAAQPeO6IJcH8gHYAK6KIMcDTfACgIDgBvIA2ACukLlF8FEi +AIEz8s9ygAAcJgeKEHEt9ACVYYpwcCn0z3CAAJgJAIhGihByI/TPcIAA8CIOgFEgQIEb8s9wgAAM +PUCAgOIA2w7yz3CgACwgEIBCeNdwMQEALUT3AdpArgTwYK4A2hC6iiBHA0V5EfDPcIAARiEAiIDg +BvIB2ACuiiAHAwfwANgArpG5iiAHBAoND/vVAi/zAI7xwE4KD/OhwRpwOnKA4Wh2yAAsAADYmnEV +IA0gz3GAAFwKABWTEAIVkhC6cOONIZEBjQHaOGAQeItxxg/v+0hzgOAT8gAUADFMIQCgQCqCIAQg +gQ8AAAD/R7lUehjyx3KAAAgSF/DPcIAAXArBkKGNCiHAD+tyz3AAALsUiiOEAAAmRBNRAG/0CiVA +BcdygADoEoDmABrCBAPyAqoC8AGqUSAAgBPygOYM8gOKgLgDqhJvFHgbYmOLWGCBu2Oo5KqA5gTy +JqoD8CWqQiRBIIDhRgft/0AlQCDFAS/zocDgeOHFUyANAKCpBCCBDwAGAABCIQGABCCAD0AAAADK +IWIAIKrXcEAAAAAB2MB4AKvgf8HF4HiA4PHAD/SCDc//z3GgACwgMIHHcUlrANIioNILL/uKIIcF +0cDgfuB48cAuCS/z2HEKJoCQiHXMIyKABvJCJgYBLyaHAUIN7//IcYDmz3GAABQKAKEm8iSIArk0 +eUOIA+FRIgCAAhCFAA/0CiHAD+tyz3AAAOIUiiOIBUokAABFBy/0CiWAAQhhUSBAgAz0CiHAD+ty +z3AAAOMUiiOIBu/xARCFAFElAIDKIcEPyiCBDwAA5BTKI4EPAAAoAsoiwQfd8+G90SUigcohwg/K +IsIHyiCCDwAA5RTKI4IPAAAvAuAGIvTKJIIBUSUAkBPyUSXAgMohwQ/KIsEHyiCBDwAA5hTKI4EP +AAA2ArgGIfTKJIEBsQAP8+B48cAyCA/zocEIdSh3GnIA3s9woAC0D3AQEQCKIMcAtgov+6lx4g+g +A8lwi3FAJEIwQCSDMIIO7//pcEwgAKAF9EokAAAJ8M9wgADUqgGIgOD49UokgAAgwAEUgjCpcbYO +7/8CFIMwz3CAAAo9AIiA4MwlApAK8s9wgAAUCgCAwqDPcIAACD3AqOW/F/LPcYAAHCYHiRB1EfQB +iVMnAhAQcgv0BCePHwAGAACA5wHaBonAehByDfLPcIAARyHAqM9wgAAMPcCgz3CAABA9wKiKIMcA +Agov+6lxLg+gAy8gRwSxB+/yocDgePHAz3GAAChDiiCHAd4JL/sggWoJz//PcIAAlAkAkIDg+AvC +/9HA4H7gfuB48cByCs//tgnP/9YPwAZeDg/8igyAAdHA4H7geM9xAACt3p0BL/uKIIcJ4HjxwOHF +z3CAABA9AIiA4BL0sgvP/4DgDvSKIEcEAN12CS/7qXGQ2ZC5A8igGEAAGPDPcIAAkBwAiIDgEfLP +cKAAAAQsiIwhAoAA3Qn0Rgkv+4oghwSR2ZC56PEB3RUH7/KpcOB4z3GAAPAi8CEBACgRgAAogU0G +7/8A2uB48cB+Ds/yCHfPcoAAHCbPdoAAlAkAlmeKEHPPcYAARiEU9M9wgACWCQCQYYoQcw70z3CA +AJgJAIhGihByBvTPcIAARyEAiAPwANj+Cu//AKnPcIAAmAlAiM9xgACWCQCJII6A4gHawHrpcwDd +6gzv/5h1z3CAABQKAIABiM9ygACQHFEgAIEglgbyAdgAqoogRwMF8KCqiiCHA34ID/tJBs/y4HjP +cYAAHCbPcIAAlAkAkEeJEHIY9M9wgACWCQCQQYkQchD0z3CAAJgJAIgmiRBxCvTPcIAARiEgiM9w +gABHISCo4H7gePHAlg3P8s92gAA0sRSOgeAS9ATYhghv+gHZz3CAAJYJAIjPcYAAlAkeDO//IIkA +2BSuNvC2joDlMvLPd4AACD0Aj2G4EHUZ8loIz//PcIAAeOcFgCFtBSh+AM9wgAAoZ54IYAUvcYog +hwbPcYAAlAm+D+/6IJHPcIAAlgkgkM9wgAAJPaCvIKjPcIAAlAkgkM9wgAAKPSCoANgWrjWOgOEJ +8s9wgACWCRoI7/8AiADYFa5NBe/yAdjPcKAALCAwgM9wgAAMPeB/IKDgePHA1g+v/+HFz3CAAAwj +EIiE4M91gADUqgv0iiAPCkYP7/qKIUoEAo1qCCAAIYUCjSGFYgzv/wHaCQXP8vHAigzP8s9wgADw +IjwQkACtgIogBwISD+/6CnFTJQAQogjv/wpxAYhRIACByiHCD8oiwgfKIIIPAADoFMojgg8AAGID +yiQiALQCIvTKJQIEnQTP8vHANgzv8thxocEacItxQCRCMEAkgzCiCu//yHABFIAwgOAK8gIUgDCA +4AbyQiAQIS8gByQgwDoI7/8KcQEUgTCA4QTyoogD8KGIiiDHAYYO7/rIcUAoACZALQIUBXoBFIAw +AhSBMAi4BXqKIMcBZg7v+kV54b3RJeKQBfJRJQCRD/IKIcAP63LPcAAA5xSKI00DSiQAABUCL/QK +JQAE/QPv8qHA8cCOC8/yocEacADez3CgALQPcBARAE4LoAPJcIogRwEODu/6CnGEKAgpACGNf4AA +TKwl8EAlABcWIIQDBRSAAIYg/oca8gSFi3FAJIMwQCRPMMIJ7//pcqgVABDqD6//6XEgwAQUgQAB +FIIwAhSDMP4J7/9KJMAAAeYMlRB2uAfF/4ogRwGqDe/6CnHWCqADLyBHBFkD7/KhwOB48cDuCs/y +ocEIdxpxOnIA3s9woAC0D3AQEgCuCqADyXCjj4ogBwFuDe/6qXEFh4txQCSDMEIJ7/9AJEIwCodu +D6//QCRBMIDl0vcUIYwjIIwgwAEUgjACFIMw8CCPI3YJ7/9TJwQQAeaxdrH3iiAHASIN7/qpcVIK +oAMvIIcEzQLv8qHA8cAmC8//agrABtHA4H7gePHAYgrP8gokAIDPcIAACOikaFUgQQQEEAYBBfIM +JICBjPcKIcAP63LPcAAA2xuq26UAL/QKJYABMiEAAQAhAwEAIQ4BACEFAWKLw44AIQIBBBWFAIwg +Q4fMI4GPAABQAMwmgZ8AAG8AzCWBjwAAmgAH9OWKiecF9OaKjOcS8gohwA/rchi4ELsFIw0ACL7F +fc9wAADeG7XbPQAv9AUlRQMBigImAgFAIJAAAiIChMohxA/KIsQHyiCEDwAA3xvKI4QPAAC8ABAA +JPTKJQQEgOLG9oBxqgggBAAhAAQAlQDZAiAABAC1z3CAAMgv2QHv8jag4HjxwHYJ7/KKIYsGAN3P +cIAAWMmloPYL7/qKIMoBz3CAAFw1oqDPcYAA8CIAgcQQAAZRIECBV/IDgRiIhOBT8oogyQPKC+/6 +iiGLCM9wgABIIQSAz3WAAEBgIICKIIkDrgvv+ja5AIVCIACAyiBiAIHgGPT2CyAFqXDPdoAACGAA +hkIgAIDKIGIAgOAM9IogiQ56C+/6iiFLC8lwQgwgBSKFz3WAAFxgAIVCIACAyiBiAIHgGfSyCyAF +qXDPdoAAJGAAhkIgAIDKIGIAgOAL9IogiQ46C+/6iiGLDslw/gsgBSKFAQHP8uB44cUA289ygAAE +yhQiDQBgtWi1GmIgGsIAwB3EECgawgDPcYAAsMkWeSKRMBrCANAdxBCAHdwQeB1EEAHZiBpCAM9x +gACkyhV5YKHgHcQQ8B3EEOB/wcXgePHANgmv+xHYgOA99M9xgAAcJs9wgACUCQCQR4kQciz0z3CA +AJYJAJBBiRByJPTPcIAAmAkAiCaJEHEe9M9wgACULgCAgOAc9HYKgAOA4An0C8gFIIAPAAAAPAsa +GDCuCoADgOAI9AvIBSCADwAAANQLGhgwC8iQuAsaGDBOCY/6A/DKC4/z0cDgfuB4ANmcuc9woACs +Lz2g4H7geCUDT/rxwMoOb/UV2Iog0AceCu/6r9nRwOB+4HjxwM9xgAAcPQiJgeAU9AOJgODG9mG4 +A6nRwOB+gOAM9IogUA7uCe/6iiGHAJoL4AIB2PTx8vHgeKHB8cDhxazBANlKwW8hQwBIwc9zgAD0 +ySCDBCCNDwEAAMCGIf4DJLkOuQslQJBOwI7CFvLXdQAAAEDMJYKfAAAAgMwlgp8BAAAABPQhgwPw +IoOuuK+4sLgFeSCiDsMIwIt1BCOBDwEAAMAuuUApAgZFeEjAiiAGBknAQcOpcADaUgkgAAHbz3GA +AFAaGoE7gSR4USAAghLyCsALwYQoBA4AIYB/gACY6wK5COA0eSFgz3CnAIhJL6DaDmAFqXAI3PsG +r/KswOB4ocHxwHoOr/IIcq3BCNhKwG8gQwBJwM9wgAD0yaCABCGODwEAAMCGJf4TJL0OvQsmQJNQ +wZDDFvLXdgAAAEDMJoKfAAAAgMwmgp8BAAAABPQBgAPwAoCuua+5sLkleACjEMMJxQQjgQ8BAADA +LrlAKQAG5roFfUnFDfIKwAQjvo8AAAAYRSDAAErABfKFIBABSsDkuhDym73PcKAALCAFgADbArhu +uIDgyiDMAMm4pXhJwAbw6LoE8p29ScUQwIHFQsCpcEYIIAAC2wPIDMLPcYAAUBq5GIIAGoE7gSR4 +USAAggzyArrPcIAAoOtUekFgz3CnAIhJL6DSDWAFqXAI3OsFr/KtwOB48cByDa/yuHGjwQh1IYCY +c0DB6bkA22qgVvIEIYAPAQAAwC64z3KAAARuCmJJIoIAz3OAANw8AINhugsgAIFLpRzyz3aAAPQZ +wI6A5gP0AN4I8M92gAAIGsiOgOb58wHeLyaH8wryLygBAE4gjgfWewGDBqUCgwrwEmoUeMdwgACQ +7GqAZqULgAWlIMDPc4AA8CJjg892gACMy9WOBCGBDwAAABB0gxjiBHtkfkAtAwIJvsV7ZXgFeQiF +J6WeuAilS6Wy8FEigIIa8s9wgADwYgCAQcDouELAD/KGIP8JI7gB4IHgyfeC4AT0BthhwCXwB9hh +wCHwIsBhwB/wQcHPcIAAaAkAgAaAnhAABobgFPQEIb6PAAAAGA70z3CAAPAiBIAIgAQgvo8ABgAA +BPIB3+qlBPBqpQDfAcDouB3yQsAiwqDiyiIhAAQgjg8BAADALr5EIAYGQS7DAAHjBCCGDwYAAABB +LkAEG2PPcIAABG7IYGJ4EvBTIMIAz3OAAFByXXpKYwQggA8BAADALrjPc4AABG4IY2G46LkWekul +CPIgw89wgAAMbmtgA/AB289wgADcPAAQBgALJgCBHPLPdoAA9BnAjoDmA/QA3gjwz3aAAAgayI6A +5vnzAd4vJofzCvIvKoEBTiKOB9Z4QYBGpQKADvACuoQvBB4AIYB/gACY61R6RmBYYMalAYAFpWG7 +BCGBDy8AAN1BKYABZXhSIMADB6XPcIAA9MkjgBEhQIEA3w7yz3CAAAxjAIDguAryhiB/Dx14QCjP +AwTwAN+Pv4DnHPTPdoAAsC4ghmB5ANiM4BHyIIZgeQDYkOAL8iCGYHkA2JHgB/IghmB5ANiS4AT0 +fg2v+wDYCIUFf+ilTQOv8qPA8cDiCo/yz3WAAMwuAIXEkMlwQg6gAIYg/AMAhclxPgxgAIYh/AOa +4M9zgADQywX0IYOAuSGjSoMB4kqjz3OgAMQnkRMBhsO5UHEN9IolCBATG1iDkRMBhsO5UHED8hIb +WIPtAo/y4HjxwHIKr/IA2M9xoACoICiBz3GgANQLOIHPcaAAxCdSEQKGFREChkIRA4b+uwbyAdjP +cYAAVMthsVEiwIAacMolYhQS9FEgwMbKJaIUDPTPcKAA0A8gEAGGHxAAhhBxAN3KJWIVgOXN9M92 +gABUyx+G8Li+8qgWARCU2I4P4ALJcs9xgAAUGgGBUSAAgAHfTfQA2I64AKGKINMGANlyDK/6jrnP +cKAAwB0ngM9wgADgOkCQhiH/Di8mh/AiuSf0z3OAAFw/bIsEIoIP////woi6hiP/AUO7hiN/D4Lj +AdvAey8mx/AB28IjwQBleQq5JXpPIkEDBCKCDwAAADxPIn6DMHogsAP0i7pAsM9woAD8RC2ABCKC +DwAAADwEIYEP////w0V5LaBMIACgKPLPcIAAoAoggM9woAD8JYDhz3KAAOjIDPQzgAqCGWEqos9y +AP8AqoogiAUM8BOAJJIZYTB5JLKKIIgFz3IA/wD/lggP/QCWxg4v/TSWz3CgANAPlBACAIDiz3GA +AAxBG/INgQHgDaELgVhgC6HPcIAARiEB2kCoH4buuAfyz3CAAEgJ4KAH8O+4BfLPcIAATAngoM9w +oAD8JROATIFYYAyhz3EAoAgA7HAgoG8hQwDscCCgz3CgANAPDhjYgy4KAAfPcAAA/3/PcaAADCQB +oRvYBKHZAK/yqXDgfwHY8cDhxaHBTgtv+otwgOA39AAUBTBRJQCADPKGCAAAz3GAAFTLQ4HPcYAA +8LFBoSfwUSWAgATyxg3P/yHwUSVAggTyUg3P/xvwUSXAgBzyCNjPdaAAxCcTHRiQEgsAAZTgDfIC +2DwdAJDPcIAAVMsjgM9wgADwsSGgGdiZ4MXzaQCv8qHACiHAD+tyF9iMuIojxwBNBq/ziiSDD+B4 +8cDOD0/yz3CAAFTLP4AEIYEP//+POAQlgF8AAHDHJXjPcYAAVMsfoUQiAFOI4M92gABUyyD0USVA +0R7yJg/P/1ElgNOcHgAQCfLPcIAARCMFiJgeAhAA3RHwUSXA0wfyz3CAAFQmGYj18QOG7gyv8ySG +8fEA3ZweQBOcFgAQgODMIOKA6PLPcIAAjBULgIDgD/LPcp8AuP8dos9xgAAgIQSBAeCzuLW4uLgE +oRaiz3CgAMgfQBAABoDgb/TPd4AAFBoSl1EgAIBKIEAgyiBBIwGHhiC/jWH0ANiMuACniiDTBgDZ +hgmv+oy5z3CgAMgfhRAAhoYg/w5BKIQAz3CAAOA6IJAvJkfwKvTPc4AAXD9siwHahiP/AUO7hiN/ +D4LjAdvAey8mx/DKJYIQBSUNEQQhgQ/////CQCjCIkV5Cr2leU8hQgMEIYEPAAAAPE8hfoNQeUCw +BPSLuSCwz3KgAPxEDYIEIYEPAAAAPCq5BCCAD////8OKuIu4jLgNos9woADIH4gYWIASl1MgAQAc +eA+5JXgStx+GUSAAgQf0USXA0gX0gNiYHgIQmBaAEFEgwIFAKAEGCfRRIoDTgrkO8i4PgAIa8B+G +USKA07O4H6bFIYIPAAAAB0UhAAbPcYAA4MssiYYh/Q9SIcEBRbkleM9xoACIJBChiiDWAM9xoADE +J34ZGIDPcKAA1AsB2lKgBNgQGRiAz3WAAFTLH4VRIICBJfIUlVEgQIEh9M9woAAsIA+AgOAb9K1x +0ggv+FYlQBWAFQAQlLiAHQAQH4WQuB+lDfDPcYAAkEAPgQHgD6EQ2c9woACQIz2gyQVv8hnY8cBe +DW/yANkIdgGAwbiD4MogQSAF8gYPIADJcBpwTCAAoMf0EIZRIICBw/IQhs91gABUy+64B/LPcIAA +RCMFiA3wEIbvuAfyz3CAAFQmGYgF8AWGJoaWCo/zmB0CEIAVABAEIL6PEHAAAAf0rXEuCC/4ViVA +FRGGz3GAADQKAKFBKAEDUyHFAJgVgRBBKAYFUSHAgRRpBSBEAQbyHoWVuB6lfPByDy/6TyRAApDg +7AAGAM9xgABkppgVgxDwIQEAQCsCBoYj/Q9SI8MBRbtles9zoADEJ0EbmIAA2oy6AiZPAPpiy7rX +cgAAAAhALQ8DkL9S9wUnjxFiG9iDjCICgMf3z3GAAARCEoEB4BKhANmduUbw5XliG1iA13IAAMAP +UgAOAA4igw8AAAAQz3KAAMSlFnqg4yCCBBIFAE/3ANgPIMAAYbhOIw8IASnCA3h5BXkALcAABXoW +8EIjAwgA2A8gwABhuHh5BSECAIoh/w8K8M9zgAAEQhODiiH/DyhyAeATowHYz3OAAGSyAKsCGwQB +IaNCo73xANmcuYAVABAleIAdABBAJgASoB0AEALZz3CgAPQmI6Alhs9wgADwsSGgAQRv8gpw8cCG +C0/yCHVVIFEEDcyiwe240SBigAfyBMhCDK//mBAAAM9wgADQywyAz3GgAMgfZOAeoRDYDqEB2BUZ +GIABhYDgBfRRIwDA+/MBhcG4g+BEAgIAABEAIEHABBQAMUEoEgMQhVEggIEGFBAxRPINzOu4RfIQ +hc92gABUy+64B/LPcIAARCMFiA3wEIXvuAfyz3CAAFQmGYgF8AWFJoWGCI/zUSDAgZgeAhDKI2Eg +DPIehgDflbgepoogBQl2DW/66XF6d5gWgBDPcYAArLIEuEaRBSCABFBwCfLPcoAABEIJgkojACAB +4AmiBJHXcAAA//8R9EojACAN8M9wgACQQC2AAN8B4S2gKg1v+oogBQx6dwGVnODA9AQRFCAIEREg +z3CgAPQmAtkjoCOFz3CAAPCxIaAeDCAAqXAKJACAufTPcIAArLJkkM9xgAAg3EwjAKBAKwUBACFC +AT/yz3afALj/z3Cg/hgFFqbPcKAAwC8VIMYAKhYHhhYWBobPd4AAINwwJ0ERNqYhgjamIoI2piOC +NqZIGBiFz3GAAODLSRhYhCyJQCoOIxC5n7nFeUEoDiHFeUcYWIANzOu4DfIQ2au4DBpcMA0aHDDP +cYAAiEEHgQHgB6ENEgE37LkG8kokgAasuQ0aXDBMIwCgYfLPdoAA3J7gFgEQ5YVEKT4HACZAHuCg +rJUB4aKwz3WAAODLrI3gHkAQQCoBI6ioCRiCBBC9ChgEBKV5DBgABUEoDSEQGEAEpXlqsM91oADA +L0cdWJCU48Ajhg8AAJMAz3GgAGgs8CHBACuwjxUBlue5IvTPc6D+UAWjFQGWUSEAgY8VAZYV9Gh3 +z3afALj/9qbggue59qbhgvam4oL2puOC9qbr8wjwSiQAAgvw57nKISEAQMEBFIIwxrnGulioOaiI +cCkBb/KiwOB48cDhxc9xgADwIiOBSIFRIgCAK/KGIP8Bz3KAAARuQ7gKYgDbgOLKIcEPyiLBB8og +4QfPICEDyiOBDwAAbwDKJMEAEAdh88olIQCB4s9wqgAMULmBxveAvbmhAdkloAXwoL25oWWg9QBP +8uB48cB6CE/yCHUNzFMgQIAH8gTIJgmv/5gQAAABhcG4g+DKJiEQBfIKCiAAqXAIdoDmY/QQhVEg +gIED9ADZUPAMzFEgwIBB8g3MUyBAgA0SAjYk9AAigA+AAIzKAdnPdoAAXD8gqBGOUSAAgMgJIgXK +IEIAEY5RIECBEPLPcIAAHD0DiIDgCvSKIBAPE9mCCm/6i7kyDGACBNgQ2AwaHDDPcYAADEEXgQHg +F6EDyA0SATaEEAIBz3CAAIDKNXgpgFlhKaAa3rvxz3CAAJBALYAB4S2gPgpv+oogxQkB2c9wgABG +IQHaQKjPcIAA0MtOgAaCAeAGogLwAdkC2s9woAD0JkOgQ4XPcIAA8LGA4UGgRA6CA9UHL/LJcM9z +gABUy1gTgQCA4QDaD/Q8k2K5ELlFIUMBz3GgAPQmY6HPcYAA8LFBoe0AAADgePHAMg8P8gh2AYDB +uIPgAN0F8tYIIADJcAh1gOU29BCGUSCAgSbyDMzPcoAAFEBRIECBF/JA2AwaHDBVEgAGz3GAAATK +AeBVGhgADcgA2hR5A8hAqZoPb/+YEAAACvCsEgEAAeGsGkAAXglv+oogBQrPcIAARiEB2SCoz3CA +ANDLLoAGgQHgBqEC2c9woAD0JiOgI4bPcIAA8LEhoAEHL/KpcOB44H8I2PHAhg4P8gh1KHcklRIJ +b/qKIMQLQS8OEcO+iObPcYAAEHXWeQfyAZVBgQTgUHAI2AT0IIFgealwtQYP8s9xgADQyyyBz3Kg +AMgfZOE+ohDZLqIB2RUaWIAhgIDhBPRRIwDA/PMhgMG5g+EQ9M9wgABGIQHZIKjPcIAA0MsugAaB +AeAGoQDZDfAhgFEhAIAA2coh4QUBgFEgQIDKIaEE4H8ocOB48cDmDQ/yz3WAANDLAYUEIL6PAHAA +AIzyLykBAM9wgABUPfQgTgArhU8mgBBGC6ACSYWA4BP0jCYDkM9xgAAUQAf0uhEABgHguhkYAHDw +uREABgHguRkYAGrwAYX+uGHyz3WAAFw/DI0vjRBxCPIRjVEgwIAE9NIKAANY8M9xgAAUGgGBUSAA +gFD0ANiOuAChiiDTBgDZ5g8v+o65z3CgAMAdB4DPcoAA4DqGIP8OQSiBAACSLyYH8CT0bI0EIIAP +////woi4hiP/AUO7hiN/D4LjAdvAey8mx/AB28IjwQBleQq5JXhPIEEDBCCADwAAADxPIH6DMHgg +sgT0i7gAss9yoAD8RC2CBCCADwAAADwEIYEP////wyV4DaIG8ADZz3CAAGSyIKhaDoAGJQUP8vHA +sgwP8gh2AYDBuIPgAN8S9IDnz3WAAFTLSfQQhlEggIE78hCG7rgL8s9wgABEIwWIE/A2Du//yXAI +d+vxEIbvuAfyz3CAAFQmGYgF8AWGJobqCU/zUSDAgZgdAhAI8h6FlbgepR+Fl7gfpYAVABAEIL6P +EHAAAA/0nLiAHQAQMIZqD6/3ViVAFUAmABKgHQAQANgFtgHZz3CAAEYhIKi0FQEQBoEB4AahWBWA +EIDgGfReC8/5gOAF8hCG7bgB2AL0ANjPcYAAtsv0IQAAPJU4YGK4ELiAuM9xoAD0JgOhBvAC2c9w +oAD0JiOgJYbPcIAA8LEhoCUEL/LpcPHAsgsv8gDZCHUBgMG4g+DKIEEgBfJaDe//qXAacM9woAAs +IAaAEHhMIACgz3aAAFTLyiciEFn0MIVRIYCBMvI8ljBwyPYlhc9wgADwsQKAEHFd9BCF7rgG8s9w +gABEIwWIDvAQhe+4BvLPcIAAVCYZiAbwBYUmhcYIT/OYHgIQgBYAEAQgvo8QcAAACvSGCs/5gOAL +8hCF7bgJ8gHfCPAA3xnw0ggP+xXwAN8whUIOr/dWJkAVgBYAEKgWARCeuIAeABBRIUCCQCUAEqAe +ABDq8wHZz3CAAEYhIKi0FgEQBoEB4AahWBaBEIDhz3CgAPQmGvTPcYAAtstclvQhwQNZYWK5ELmA +uQ/wtBYBEAuBAeALobQWARCKIEULMg0v+iuBwPEC2SOgJYXPcIAA8LEhoOUCL/IKcPHAfgoP8s9w +gACMFQuAgOAP8s9ynwC4/x2iz3GAACAhBIEB4LO4tbi4uAShFqLPdqAAyB9AFgAWgOBi9M91gAAU +GgGFhiC/jfKVwL9Y9ADYjLgApYog0wYA2b4ML/qMuYUWAJbPcoAA4DqGIP8OQSiBAACSLyYH8Cj0 +z3OAAFw/bIsEIIAP////wgu/5XiGI/8BQ7uGI38PguMB28B7LybH8AHbwiPBAGV5CrkleE8gQQME +IIAPAAAAPE8gfoMweCCyBPSLuACyz3KgAPxELYIEIIAPAAAAPCq4BCGBD////8OKuYu5jLktooge +GJASlVMgAQAceA+5JXgStVElgNPPdoAAVMsH8s9wgABEIwWIDfBRJcDTB/LPcIAAVCYZiAXwA4bi +Di/zJIaYHgIQH4ZRIACBCvRRJUDTCPRRJUDSBPSA2JgeAhCYFoAQ57gM8j+GXoazuZe5lbo/pl6m +ANkB3RfwnBYBEIHhEfQ/hlEhQILPcYAA8CIjgSmBBPJEIQ0EBvBEIQ0CAvAB3QTZGLgleM9xoACI +JBChH4ZRIICBG/IUllEgQIEX9HYMwAKA4BP0z3CgACwgD4CA4AXyDcxRIMCBCfIfhpC4H6atceoL +r/dWJkAVgOUc9FEigNMF8roJQAIW8EQiPtPPcYAAVMsQ9AGBUSAAgAzymBGAAM9xgAAQ3wK4FngA +Yf645AiC+s9woABQDACAz3WAAHQKBNnPdoAAVMsApc9woACQIz2gH4bzuAX0D4aA4ADYMPJNcdYK +L/qKIEQOF4YghYoWAhEZYQTiUSCAxAT0USEAxvzzz3WAAFTLmBWAEOe4ANsK9AK4z3OAABDfFngD +Yy27wLuKFQARTxWNEM92gADwIvAmwxBCeaJ4Ng4v+k+TSQAP8vHA4cWhwQDYQMDPcYAAkEAPgQHg +D6ED2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoM91oADEJxUVAJbP +cZ8AuP8WoTEVAJYWoRDYEB0YkGIK7/mLcIDgF/QAFAUwUSWAgA30CiHAD+tyDdiMuIojXwfNBS/z +iiSDDwTZEx1YkBvZFh1YkMEH7/GhwPHAz3CAADyy6g2v8xjZz3CAAHSi3g2v8xjZ0cDgfuB48cAe +D8/xGnDPd6AA1AsQhwDdgeChwUDFDvIKIcAP63IP2Iy4iiOWCIokgw9lBS/zCiUABM9woP54As92 +nwC4/xamWB4AFM9xoAD8RBmBBCC+jwAACCAH9B2B+bjKIEEDAvIB2A94geAH9M9xgAAMQQKBAeAC +oUwgwKQI8ooJ7/mLcIDgyiACIEIgwSCU4W4BDQAyJkFwgAAAaEAngHI0eAB4z3GAANDLToEIggHg +CKIOgQiAFqZKDcAAANkocErwz3KAANDLLoIHgQHgB6EOggeAFqbz8c9ygADQyy6CDIEB4AyhDoIM +gBam6fHPcoAA0MsuggKBAeACoQ6CAoAn8M9xgAAMQQWBAeAFoR/wz3KAANDLLoIDgQHgA6EOggOA +FqYB2QDYFvDPcYAABEIagQHgGqEWpqoPoAQB2L3xz3GAAARCFIEB4BShFqYB2AhxgOEYDIIAz3CA +AFTLH4DzuAnyz3CAALilq6jPcIAA7KKssAPYEafgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeBGn6QXv8aHAGIbPcoAA0MuQuBimGIawuBimLoIFgQHgBaEOggWAFqZSCAAAxvHPcoAA0Msu +ggSBAeAEoQ6CBID08c9ygADQyy6CEYEB4BGhDoIRgLHxz3GAAAxBDoEB4A6hlPEKIcAP63JB2Iy4 +JQbv/4oj2AfxwBYNz/HPcIAA0MsMgM92oADIHxDdAd9k4B6mrqYVHtiTz3Gg/iACz3CfALj/NqA+ +DWAGCdgD2B6mrqYVHtiTBfBWCe/5iiBVDs9woAAMJAeAgOAE8lEjAMD18yEFz/HxwM9wgAAMFnoJ +r/oB2W/YBrgyCa/6CNkH2Aq4Jgmv+gXZ0cDgfuB48cDhxc9xgADwIiOBKYFRIUCAyiCiACv0RLjP +cYAARD3DuAlh4LkF8lElgNEc9FEhQIAc8s91gADwIgOFGIiB4A/yqguP+YDgB/LPcIAAOCYIiIfg +BfIDhRiIguAG9FElgNEE8gHYA/AA2J0Ez/HgePHAGgzP8UQiEFNNdoYm/BNNcE1wBCWAXwAAACBB +KH6DBfJaC4/5gOAD9ADfAvAB3891gABUyx+F8bgE8gDdpPBMIACg/PU2C4/5gOAe8s9wgAA4JgiI +h+DMIGKCFvQBhYwg/48S9CSVz3AAAP//EHEM9AWFjCD/jwj0DJXXcAAA///KJWEQgPLPcIAA8CLw +IMEDCYFRIECBBfLPcIAA0G4E8M9wgADcbjiJKmBBLgARz3GAAOhuCGEWes9wgACQdUhg4LgF8j+F +hiH2jxfy4bgF8j+FUSGAghHy4rgE8lElANIE8gHdDPDjuAnyz3GgAAwkMYGMIf+P9vMA3VEggIHK +JSIQdgqP+YDgCPIEJb7fAAAAIsolYhCA5Sjyz3GAAFTLH4HouA/yjCYCkMwmgp8AAFAAzCaCnwAA +0AAD9JO4H6HPcIAA8CICgMIQAAaA4BryjCYCkMwmgp8AAFAAFPRPgUV4D6EP8M9wgADwIgOACYDh +uAf0jCYCkAb0USCAgQLyAt35Au/xqXDgePHAhgrP8c9wgACMFQCAosGA4ADeD/LPcp8AuP8dos9x +gAAgIQSBAeCzuLW4uLgEoRaiz3GAAFTL3qHfocCxz6FPGYIDgBmAA4wZhAOA25gZwgCEGYADz3Kg +AMgfpBIAAPgSDQCsGYADQhmEA6J4sBkAAM9wgABYn9mgz3CAAAzMwKAE3c9wgAA0CqCgmRGAAKC4 +mRkCAM9woADEJ2QYmIPPdQAA/38TGFiDG90WGFiDGhiYg4on/x/PdaAA/ET9pfmliieYHc91oABQ +DOKlcaJwojwYgIOKIxgIbqKAEgMApBmAA1EjQIDPc4AA8LFYGYIDDfJCEACGBCC+jwDAAAAF8gGD +gOAD8gKjwaOAGoADUSGAw89zgAAUQM9wgADwIkOAGfIfgYu4H6FVI8AFtBkAAArYHLEbkpYZBACK +IEQL6gvv+QDZBtnPcKAAyBwpoA/wQCMAA7QZAAAQ2ByxGpKWGQQAiiCEC8IL7/kA2c9xoADUCxCB +geAN9AohwA/rcgvYjLiKI9UAiiSDD3UH7/K4cwHdsKFRIEDGCvTPcKAAqCAmgAeAxQIgAAPdz3CA +AFTLtBABAACBAeAAofrYcgqv+gDZINjPd4AALMyiCKAEAKcB2M9xoADIHxOhz3OAAEghCINAJxAV +QIAMgwAQBAAEg89znwC4/wAQBQD4EQAAz3GgADAQIYE2o89xoAAMJCeBAiICgDajANkDJEMAAiUB +AM9wgABUy1AYhANSGIQDVBiEAyOnz3CAAPAiQacjgGKnFJHPcqUACAwJtwiBwLgItwASBADPcoAA +VMtTJEUBTBpCAVMkQgCD4sohwQ/KIsEHyiBhBcojgQ8AAJwLhAbh8s8gIQMEJIMPAAAA4M9ygABU +yy27mhrCAF+C67oUHwARDPIEu4G7ZXgItwfYB/AVIAwgwKQD8ATYAeCI4Lr3CIHruIAJwgbPcIAA +VMsfgCu4UyAQAFEggMWu8s9xgAA8KQaBAeAPeAahQSmAQ89xgAA8KUaBz3GgALQPN4HAuDByAN0I +9M9xoACoICaBjCGDjsT3A92l8BJwBPIE3aHwz3OAACzMBYPPcqQAkEH1gjaCBCCADwAAAOAtuOC4 +56PPdoAAVMsoowTyUB7EEwnwUB5EEwQnjx///wAA56PhuAXyML9SHsQTBfBSHkQT8H/no1EggIAF +8lQeRBAI8FQeRBMEIYEP//8AACijDYIGowQggA8AAAD+KbhWHgQQH4bruCTyz3CqAAAEBIAJo89w +gAB0oiCIgOFEaDfygOFkAC4AAhCEAJ9xANioIMAD9CIPABXdE73wJc8Tz3WAACzLFX0B4OClHvDP +cIAAPLIgiIDhRGgZ8gIQhACA4cokTXDKIC0A6CCtA/QiDwAp3RK98CXPE891gAAsyxV9AeDgpSGr +AhsCAbQWARAC3QGBAeABoRfwBCC+z2AAAAAI9IoghQfqCO/5DBIBN2rxUSMAwAfyiiDFB9YI7/kA +2Vzxtgqv+fHYgeU584LlF/QC3QQgvs+AAQAAyiWiEQb0USMAwMol4hCC5fXzz3CgADAQA4CA4Mol +YhGG5UAEAgDPdoAAVMsclkIghAAfhuu4LyQIAXvyz3CqAAAEooDPcaUACAwggQQlgh8AAAD/KLoE +IYEPAAAA4Im6O3tFe89ygAAszHKmrKJtoiCASBaPEJTnKqIZ8gb2iucZ9CO5DvC35w7y7ucT9EUp +/gJBKcFwUSXAkcIhYgAH3QvwRSn+AkEpAXH68SK5+PEA2QjdAYA3ppThC6I8sg30z3eAAPAi44fo +hwQnvp8ABgAAA/KMu3Km5LjKJSIS4bjKJSEShiD+D0EoAwFNHsIQCJKH5WV4CLIU9I7hB92P989w +gADwIgOAhBAAABBxB/fPcKAAMBAIgBBxAvII3YflyiABAbwOYfrKISEAOQMAAM9wpgAIBAGABCCA +DzAAAAA0uFEgQMZCHgQQQhYBEQv0z3CgAKggCIAZYTB5Xg5v+ohwBPB+Dm/6iHAEIIBPgAEAANdw +AAEAAADZFfQB2E4eAhDPcoAALMyaFoAQQh5EEE0eQhA3pimiBLgokom4JXgIsnXwTR5CEM9wpgCM +Az2AUSDAxwQhgA84AAAAQSjCBJoeghAEIYIPAAAA8Cy6JbhFeM9ygABUyxKmBPISgoy4EqJTIc4C +SBKDANei4LvRIeKHB90D9Ajdz3CAACzMKaCaEoEA6JAEueV5KLDcsIflMoItoED0z3GmAIwDvYEE +JYEfAQAAADC5ThpCAKmgThKAAIDgHfKN4y30USAAxif0FNjPcaAAyB8eoRDYDqEB2BUZGIAK3VEg +AMbKJeIRUSMAwMolIhKK5fjzFPCO5pH3z3CAAPAiA4CEEAAAEHYJ989woAAwEAiAEHYD9AfdAvAI +3Yfl6PTPdoAAVMtOFoAQgODg8s9ypgDUBCwSAYA0EhKAOBIPgMsSEAZKcMa46XKGIv0PBrpFeEpy +hiL9DwS6RXgEIYIPAgAAACe6RXhEJwIcDbpFeOlyhiLzDwQhgQ84AAAADroluUV4JXhEJ4EQFLkl +eIi4RCcBEkEpwYBSIEAFEqZYHkIQyiGCDwAA///KIYEPAAAQHzpxN4ZAHkQQBCKBL/8DAP8ouTem +Jgtv9wDa8r+sHgAQO/JIFoMQMoag49Eh4YIz8gQhgo8AAAABCPJEIQ0GI70B5YHlCvcEIY0PAAAA +JNd1AAAAJCHyBCGNDwYAAAAxvYLlMgANAILlCvSA4hXyRCENBiO9AeWC5Q/0gOIE8szjC/ZXhjJy +yiKODwEAiA3MII6AzffXcAEAiA3H989xgAAEQhyBAeAcoQjdMvCGIf8JQSnNAM9wgAC4LiCAAeVg +eQbYEHUW989wgADwIgOACIAEIL6PAAYAAADZyiFiABKGBCCADwAAAAgruBBxSfcCDQAACHWU4Mol +4hMK8M9woAAwEAiAN4YQcQfdyiViElgWghDPcYAALMwIkQe6iLpFeAixF4YwGQAEHLEShuuhDaGs +FgAQKBmABB2xh+UF9GoIAAAIdYDlyiUhEIDliAqi/8ogQgMA2M9xoADUCxChz3CAAODLDYhRIACA +B/LPcKAAiCQegAsaHDCeD0AADMyGIPmPCfSE5cwl4pAF9ADYj7gMGhwwMtnPcKAAyBwqoKUBr/Gi +wOB48cBOCY/xz3CgANQLGIBCIAAISCAAAM9xgAA8KSWBgeGKIZkOCPTPcYAA8CIjgT6BgCGZDhBx +AN3KJW0UgOU79M92gABUy1gWgBCA4MogIgAi9AwSATfjuRDyDcxTIH6ADPLruBeGBvKg4AHYwHgK +8I7gAdjAeAbwUSFAgRL0ANjPcYAA8CIjgSmBPXlSIQEAwLkkeIDgCPIfhpG4H6YL8BeG6PFyDAAA +WBaAEIDgPAsBAIDleAICAM91gABUy1gVgBCA4BPyAtnPcKAA9CYjoM9xgADwsQDYAaHA2ZkVgBCA +uJkdAhAocALwQtjPcaAAxCe/GRiAANgMGQCAAdgQGRiAH4XxuBQCAgAShTeFhghv9wDarB0AEB+F +67hZ8s9wgADwIkOASBWBEBSCJHhEIAMBRCEADEIoBAGAc89wgACkI8G7aGCJuBylcBWOEPSCTRWA +EMR/hib/EwR/RL7fZ892gACAbvQmzxNiHcQTz3eAAMgma2eJu32ldIJ0FY8Q5HuGJ/8TBHtEv/tj +9CbDEGQdxBByhXqlVIJ7pUR5JHjPcYAAkG6AcPQhAgDPcYAAuG70IQAAjh2EEJAdhBCSHQQQlB0E +EADYTh0CEJjwThWBEM9wgADcPIDhAIDAuFPygOAA28ogIgAK9HKFSBWAEAQjgw8AAAAIe3vCuAAg +jg+AAJgjMI7YjsdwgADEJs93gAD8sUiIZX7cpXAVjhBlecO+3H70J44TZXoQiGIdhBMFe32ldBWA +EMO4HHj0JwAQOqXPcYAADLJkHQQQaBWAEMO4HHj0IQMAW6WOHcQQz3OAAFSy9CMAAJIdBBBsFYAQ +w7gcePQhAQCQHUQQ9CMAADzwgOAA2Ab0SBWAEMO4HHjPcYAAlCMJYc9ygAD8sTylcBWBEMO5PHn0 +IkEAYh1EEM9xgAC4JghhHaV0FYAQw7gcePQiAADPcYAADLJShWQdBBBIFYAQw7gcePQhAwBapc9x +gABUsvQhAACOHcQQW6WQHcQQkh0EEJQdBBC+CsABz3CAAPAiA4AIgOu4BvJOFYAQgOAcDkIGWBWA +EIDgBfLCDc/+A/BCDQAACHWJBm/xqXDgePHA4cXPcaAAxCcVEQOGBNgTGRiAG9gWGRiAA9rPcKAA +1AtRoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4UaDku8olohUr9FIRAIbguMol4RUl +8lEgQIAF8lEjwIAD8hLdHfAB2c9wgABGIc9ygABUy7QSAwAgqAaDAeAGox+C7rgG8s9wgABICSCg +CPDvuAbyz3CAAEwJIKAV3YogBAwOCK/5ANnlBW/xqXDgeMHYFBoCMM9xgADwIgOBGIgB289ygABU +y4bgF4LCI8EADOAYIMAAZhoEAGYSAAED4AQggA8AAPz/nbifuOxzAKMFyOxzAKMDgRiIN4KG4AHY +wiABABghAQDscCCg4H7gePHABg1P8XIJj/TPcIAAVMsygFEhQIIS8s9xgADwIiOBSBCCADSBRHlR +IYCASNrKIoEPAACQAAPwDtoA389xoACoICeBrBANAFlhsXHCJUUQyiXmErB4Tg4v+grZz3CAAHQ4 +AJDPdqAAxCdRIACBBfKMJQOSA/cA3R3wWgwgAgDYz3CrAKD/+qAA2MIPb/SOuFYLj/0ZFgCWgOAF +8gLYEB4YkM9xgAAEQhuBar24YBTdG6EZFgCWgOAH9FEhAMagDOEFyiBhAKkEb/GpcOHFz3GAACzM +QYnA2xQawjDPc4AA8CJjgxJqR+AEIIAPAAD8/2mDKrvAuxe7x3MADgAAZXjscwCjBcjscwCjSiTA +cwDbqCDAAfAhzQDscKCgAeOA4gDZzPfPcIAALMvwIEMA7HBgoAHhUHG49wDZz3CgANQLLaALzAHg +EHgEIIAPAAD/v4+4CxocMM9xoACIJB6h4H/BxeB48cCiC0/xz3eAAFTLQJcIdkhxhiH8A0IpBQFE +IggDjBcBEUIoiBBA2M91oADQDwojQIAQHRiQyiNiAKwXABBAK4YFz3OAACzMLyQIAB2zOBMHAUAs +BAQFJwABDB0YkGGLArtI4xAd2JBmFwMRUSKAgnlhMHlmH0QQBfQOl1MgwIAQ8s9wgADwIgOACYBR +IACAPdjAKOIFyiChB8AoIQYK8EAoABGgcM9ygAAoIghiF7gD4QQhgQ8AAPz/BSCAASV4nbifuAwd +GJALzAHgEHgEIIAPAAD/v4+4CxocMA4dmJMgFQCWz3CAAPAiA4AIgOu4D/Lkvg302gpgBslwz3CA +AGjMoNnE2j3bXgzgARe7/QJP8eB48cDhxc9wgABcCgCQz3GAAPy5qNoB3YAgRAsQeAoIb/qpc4Dg +yiHBD8oiwQfKIIEPAAC1FMojgQ8AAMwAyiQhALwAofLKJQEBkglAAM9wgAA4MrUCb/G0oPHAAgog +AgDYHg+P9Z4Kz/1OD4/6ANhmDW/0jrj6CI/9/9nPcKsAoP85oDig0cDgfvHA4cXPcYAA8CLwIQIA +SiRAAMMSAQYPeDIigg8AAB8DBCGDDwAGAACA4wHbwHsEIY0PQAAAANd1QAAAAMIkAgFeCe/6wLk5 +Ak/x4HjxwL4JT/GSCOACCHXPcYAAVMsfgbC4H6HPcJ8AuP9YGMAIz3OfALj/WBsACM9yoADQDxCC +z3agAMQnFqPPcIAAPCkGgBajGRYAloDgANkF8gLYEB4YkBgaWIBaCoABGgsgBAHYgOUF8i4IQAAF +8A4IQABCCw/6GRYAloDgBPIC2BAeGJClAU/x8cDPcJ8AuP9YGAAIz3CfALj/WBhACM9wgAAgFiIO +7/kj2V4MT//RwOB+4HjxwNIIIAIB2ADZz3CAAIhBLqAuCC/0GdjRwOB+8cDiCE/xosGLdsYLL/nJ +cAolAJAZ9M9wgABUy89xoAAMJDuBV4AwcsolIhIghvC5BPIC2YwYRAAEJYJfAABwxz+ARXk/oIDl +ggQCAADA6bja8s91gADMLgCFiiEIAOSQz3agAMQnEx5YkM9xgABUyz+BOnfxuYYh/CND8kEpASHD +uc9ygAAQdTZ6IIJAeQh1GRYAloDgBfIC2BAeGJDPcAAA/38THhiQG9gWHhiQA9nPcKAA1AsxoOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaDPcIAAWJ8ZgIDgPAvCAZrl4gMCAM9wgAAI +7vYOIAQA3dMDAABiC2//KnAacACFXgkv/ypx/gkv/wh3iOfMJ+KVyiXBEy3yTCAAoAvysgsgAIHA +CiUAkBz0Ggzv/wHAGPAD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hgx +oADdmucH9M9wgAAI7noOAASA5VIDAgAqDgACz3CAAFTLH4DuuAjyAdnPcIAASAkgoAnw77gH8gHZ +z3CAAEwJIKARFgCWAN1RIICAQcAY9BoKL/mBwAolAJAS9AQUBTBRJYCADPQKIcAP63IK2Iy4iiPH +CoEFb/KKJIMPgOXqAgIABNgTHhiQG9gWHhiQz3CAAFifGYCA4CQKwgHLAgAA4Lg+AgEAz3aAAFTL +EoaGIDoAjCAEgowNBQLPcaAADCQ8gReGInhkuBB4ih4EEEQiAFOI4Ar0H4bxuAb0USVA0QHYBvQA +2ATwggpP/4DgnB4AEITyFgwP/wolAJBqAgIADcxRIMCBEfIfhlEggIEN8i8ghwqMIAKGB/TPcYAA +VMsfgZi4H6FOCiAAgcAKJQCQNgICAM92gABUyx+G8Lhn8qgWARDU2NILoAHJcgh3z3KAABQaAYJR +IACAS/QA2Y65IKK+CG/5iiDTBs9woADAHSeAz3KAAOA6AJKGIf8OLyYH8CK5J/TPc4AAXD9siwQg +gA/////CiLiGI/8BQ7uGI38PguMB28B7LybH8AHbwiPBAGV5CrkleE8gQQMEIIAPAAAAPE8gfoMw +eCCyA/SLuACyz3GgAPxETYEEIIAPAAAAPAQigg/////DRXgNoYDnB/I2D4AFC/CyDQ//tPDPcYAA +gEIegQHgHqEB389wgABGIbQWARDgqAaBAeAGoR+G87iADEL5D4aA4IwLQvkfhu64CPIB2c9wgABI +CSCgCfDvuAfyAdnPcIAATAkgoADYz3GgAMgcB6Ew2Aqhignv/wHAiiCEDboPL/kBwR+G+LgS8hDY +DBocMM9wgAAI7goMAAQNyAAggQ+AAIzKH4bgqbi4H6YAloYg/ACMIAKAHPQuDc/4gOAY9APZz3Cg +ANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgAJZyCu/7NJZF8FEgwIBBwBXf +BPTpdSHwCNjPdqAAxCcTHhiQig+P/5TgCHUV8gLYPB4AkCEWAZbPcIAA8LEhoBEWAJZRIICA5vVO +D+/4gcAKJQCQ4POV5R30z3CgAJAjHoAEFAQwUSCAgMohwQ/KIsEHyiBhAs8gIQPKI4EPAADkBKAC +YfLKJSEAEg6v/4hwCHWpcHUEL/GiwOB48cAaDA/xocEIdgDYQMAApuoO7/iLcAolAJCK9M9woAAE +JSKAAIYEIYEP/wBf/wUhAgBAplMhggBTIIMAZXqH4lX0USKA089wgABUyx+APfL6uF70BCC+jwAe +AAAD9ACGCvBRIoDA//VRIgDAAIYE8oW4AKbPcoAAVMs/gvm5B/KIuIu4jrgApkLw+7kT8k8gAQKJ +uY25i7mOuSCmHoIEIIAPAgAAAFIgQAQquCV4AKYu8Py5xSCCDwAAAAXj9YUgHAAApiTw9bgAhiLy +hiAcAIUgGAAAplEiAMH/9VEiwMAAhhbyhrgAphLwUyEDAFMgAgAFI76AyiXhFQryhiF/D4Ygfw8F +IT6AyiWhFM9wgADgywyIxLhAKAEGAIYleFEggMQApkgLogXKICIIqXBZAy/xocDxwOHFAN0F2Au4 +dgzv+alxNg0P8s9wgABUyx+A67gN9ITl2gAGAFEgQMVp9FEgAMVV9AHlVPAA2Zy5z3CgANAbMKAB +2c9wpACYQDygBdgI8FIJAAAaC6AFBdgB2BILgAWE5W4ABgAEIL7PMAAAAAHlyiUiEFEjAMAa9FEg +QMUF8lEhgMMl8lEgAMcb9FEgwMXl81EhgMPj889wqgAABAGAhiA/C4PgAN3U9RPw9ggAAM9xgACI +QQ6BAeAOoQnwANmcuc9woADQGzCg2ggAAADZz3CkAJhAPKAR8ADdUSMAwAX0jgqgBQHYnPG6CAAA +z3GAAIhBDoEB4A6hYQIP8eB44cUMzEQgPopK8uO4KvKA2AwaHDANzM9xgAAMQc9yoP6UAc9znwC4 +/+u4AN0G8h2BAeAdoUhwB/AVgQHgFaFAIgANFqMNzFEgwIAG9M9woAAsIK+gDcyGIIICDRocMCDw +USBAgRzyiiAEAAwaHDDPcYAADEEUgQHgFKENzADZRiCAAg0aHDDPcKAALCAvoM9xoP70Ac9wnwC4 +/zag4H/BxfHADgngAQHYBgwv8QPYJggAAP4I4AEB2NHA4H7xwOYPz/9CDs//FgvP+dHA4H7gePHA +FgkP8c9xoAD8RAWBAN68uAWhygjgAclwA93CCy/xqXDPcaAAMBCioc9wgAA8KaKhUQEv8cag8cDP +cKAAtA83gM9wgAA8KQaAEHEE9LYPz/8E8JoPz//RwOB+8cCuCC/xANkH2BpxOnAA3kAoACEUeMdw +gAD8uRUgjQMAlYwgAo0A34T2jCCFgsn2/9gAtYogEQMWCy/5/9kBnbzgBfaMID+BR/bhtYogEQP+ +Ci/5ANkB5s9+jOa0B8v/QiFAIIDgQCBBIKIH7f8veZ0AD/HxwEYID/EA3c9wgAA0sZIPr/i0qIDg +E/II3oDlzCWikMwlIpHMJWKRkA8i/sogQgNhvoDmAeUz9xzwiiQBcc9xgAAEyqggQAEEGVAD4HgA +2UokAHLPcoAAsMmoIAADFiJAAGKQz3CAAHzKNHgB4WCwz3WAAPAiz3aAAHixQCUAFyRu2g4gAgba +QCUAFUAmgRLKDiACBtpAJQAXQCYBFL4OIAIG2iwVgBCE4A/0iiAPCioKL/mKIVsFPBWAEE4LL/4t +hUYOD/gOhVEgQIEJ8ooghw4KCi/5iiHbCDoLgANmD4/4gOCEDsL/z3EAAP//z3CAAEzrLKCCCe/4 +K6C1B8/w8cBGD+/wFNnPdYAA6CbY3OINr/ICJQATz3CAADQp1g2v8hTZz3aAAPAiQCYAFQCmwNwC +JQATAaYA3alwqXHGDW/xBtoB2Klxug1v8QbaAIZKJIBwqXECpgOmqCDABRUmQhBggoogxg0NswCC +AeGpoACCqaAAgsAYWAMAgsEYWAMAgsIYWAMb2c9wgABcPyUH7/AsqPHAmg7P8BpwOnFIdlIMr/ia +cwh1BCaAHwAGAACA4EoiQCDCIoIkBCaOH0AAAADXdkAAAABKI0AgwiPCJM9wgABoCcSIAN82DqAB +6XCA5Q30A94vIQcELyJHBMlwSnPqDW/6CiTABMlwUg5v+opxgOUE9OILgAME8BIMgAPPcIAAPCkE +gFEggIAQ8s9wgAAUPQCAgOAK9DnYZgyv+Iu4geAE9M4Mz/8N8ADZnrnPcKAA/EQhoOB44aDCDaAB +ANgxBs/w4HjxwOoNz/CjwQh2z3CAAPAi8CCDA4onCxYtk/1jPHoocIYh8Q/Cuke5JHpQcYYg/gNE +uA/yCiHAD+tyg9iNuIoj0g1KJAAAFQQv8golAAFIg39nO7pTIgKAQK9Nk8C6Qa0L8veThif/GUO/ +5613k4Yj/gdFu2itgOIb8s9ygAAoPRUiAwAAizV6Aq0Bi89xqqqqqgOtAosErQOLBa0Digat4g/v ++Iog0A++CGABAo2LcKlx/g3v8AzaAMABwQIKL/ICwotwqXHqDe/wDNoAwAHB1gkv8gLCz3GAAAwK +AKFmDyAFyXBtBe/wo8DgePHAAg3v8FfYz3WAAPAiI4XPcoAAEAp3keC7AKID8l/YAKLiuwPyhbgA +olEjQIAE8oe4AKKKJgsWy2HZYQDagOPKIIEAz3KlAOgPBqIAic9xoACkMIDgAYHPIOIA0CDhAAGh +jglP9QOFz3GgAMgcT4AC4EihSgvgAchgA4XGD+/zDoBeCw/96QTP8OB44cXPcIAA8CIDgCmARCGD +gADaJfSQ4owABgAAIo0PgAAoIgCNoLgArYAVgBCguIAdAhBAFYAQoLhAHQIQEI2guBCtkBWAEKC4 +kB0CEFAVgBCguFAdAhAB4t7xkOJEAAYAACKND4AAKCIAjYC4AK2AFYAQgLiAHQIQQBWAEIC4QB0C +EBCNgLgQrZAVgBCAuJAdAhBQFYAQgLhQHQIQAeLf8ea5EfLPcoAAKCIIioC4CKqIEoAAgLiIGgIA +SBKAAIC4EfCA4xH0z3KAACgiCIqguAiqiBKAAKC4iBoCAEgSgACguEgaAgBRIQCAANgd8kokAHTg +eKggAAbiuBXyACCDD4AAKCIgE4EAgLkgG0IAoBOBAIC5oBtCAGATgQCAuWAbQgAB4BzwSiQAdOB4 +qCAABuK4FfIAIIMPgAAoIiATggCguiAbggCgE4IAoLqgG4IAYBOCAKC6YBuCAAHg4H/BxfHADgvP +8IHgz3aAAPAiGnAD9ACGAvABhsQQAAYVJg0UTCAAoAHfJbhTIAUAIIXAf0AhAAbEEQEGUSFAgQz0 +CiHAD+tygdiNuIojjQ81AS/yCiQABIoiCw1ZYAAWA0BYYGCgABYAQAGhABaAQAipABaAQAmpz3CA +ADwpBYCB4Af0QIUAFgBBD7ID8AAWAEEAFoBACqkAFoBAC6kAFoBADKkAFoBAABYAQQexABYAQQix +ABYAQDoJD/0AhcgQAAaGIH+OSvTwJsATyBAABoYgf45C9Iog0wHWDO/4iiEOBwpwngyv9gHZIgvv ++y8gBwQSDiAFCnDPcIAAOCYskB6WEHEF8rYNj/cScCb0AIXEEAEGCnAlucC5qgwv8wDaggyAAYDg +CfQLyAUggA8AAAA8CxoYMLoMgAGA4Aj0C8gFIIAPAAAA1AsaGDALyJC4CxoYMAoOz/CeCk/2GQLP +8PHAkgnv8ADZCiQAoKHByiFhABXyz3CAADwpEBAFAFElgIAN9AohwA/rcn7YjbiKIwgN9Qfv8Qok +AAXPdYAA8CIVJQ4VAIYVJVIQJBAVAAASASAgEBYAKBAXAUEtTyEpgRoQGAHAvyW5UyETAHYMoAQN +2YogiQCKccoIb/vpcqYK7/2KcACGCYAluFMgEACKcJILr/YA2UwkAKDcCMH/TCAAoFjygOcO8goh +wA/rcn/YjbiKI4kHSiQAAG0H7/G4c4ogUA+KC+/4N5X6DQACggpv9gHYAIYIgFEgAIAJ8iwVgBCE +4AXyRg7v8wPfBPBCDu/zBd9MIwCgOncb9AYIj/qSD0/6iiCQBUYL7/iKIckOz3CAABw9A4iA4Av0 +iiAQDi4L7/iKIQkP2gzgAADYLBWAEITgC/SKII8OFgvv+IohCgCA2HINr/oB2UojACBR8GIOb/+K +cPoJb/YA2CwVgBCE4Az0iiCPDuYK7/iKIcoDgNhGDa/6ANlMJACgDvSGD0/6fg9P+hIMD/UuCI/4 +gODIDAL1ANgg8KoMD/UaCI/4gOAF9KYIgAUV8M9wgAA4JgiIieDMIOKB7vXPcIAAVGoAgATZvdoe +20DAi3CuCWABGLsB2HpwAIYIgFEgAIAH8iwVgBCE4ATYAvQG2DpwAIYogBSQBCGPjwAGAAAFfwfy +9rnCJ6IQwCehECpwinFeCa/z6XKA4MogQgS4CKLzyiHCA0wjAKAF8m4IT/al8OYOT/gE2c9wgAA8 +KVoO7/wkoCCGyBEABoYgf45E9F4I7/uKcFILIAWKcAASACDIEAAGhiB/jkH0z3CAADgmLJAelRBx +BvLmCo/3knA39IpwCnHiCS/zAdp/2RG5z3CgALAfNKC+CI/4rgmAAYDgCPQLyAUggA8AAAA8CxoY +MOIJgAGA4An0C8gFIIAPAAAA1AsaGDALyJC4CxoYMDYLz/AN8CQZQAUghiAZgAUghigZxAUghhoZ +BAYuDk/4gOAK8kwkAKAA2AT0lg5ABQTwbgxABQHdzgtgAqlwz3CAAAghHgtgAqCoTCRAoBT0z3CA +ADgmCIiJ4Mwg4oEE9EwgAKAI9IjgCPSCDk/4gOAE8qIIj/IiCw/4Ug8P9gTKkODMIIKPAACzAA7y +CiHAD+tyARIENpLYjbiKI40GvQTv8QolAAW+CiACANhhBq/wocDxwDoOj/AA3c92gADwIgjfAIbE +EAEGQSlAAVEgAIAO8oDlzCWikMwlIpHMJWKRBvSA5cwlopAN9FEhQIEM9IDlzCWikMwlIpHMJWKR +BPRmDe/9qXBhv4DnuAft/wHlz3eAABwmz3WAAJixQCcAFSRt4gzgAQbaQCcAE0AlgRLWDOABBtpA +JwAVQCUBFMYM4AEG2s4WABbPcaAAxCfPcoAA/CV3GRiAGJJ4GRiA0BYAFoAZGIAckoEZGIAPEQCG +g7gPGRiA3QWP8PHAag2P8M92gACcCQCGSiAAIIDg+A7CAs9wgACMFQOAgOAA3w/yz3KfALj/HaLP +cYAAICEEgQHgs7i1uLi4BKEWogzM4Lg/8s9zoADIH7ATAADPcoAA8CJDggLgRhIBAWG5CCBBAD6j +ENgOowHYFRsYgM9wgAAI6gMaGDDPcIAA0Op6DaADBBoYMM9xoAD8RAWBSiFAILy4BaEMzIYg/4HP +cIAAXAkAgMIhQSSA4JgOAv0EII5PMAAAAM91oADIHwnw7bgX9M91oADIHwp2CiEAJM9wgABIIRCA +z3GAAARC7KEAgA6h1/DPdaAAyB8A39Hw8gnP/s9xoAD8RAWBvLgFoc9wgACIQQ6AjCACjYj30gxv +8xnYKgxgAQDYDMzPdaAAyB/vuNTzBNgGGhgwH4WA4IogDADKIIIPAAAAAg6lA9gVuBIdGJAAhoDg +jA3CAs9wgAAgIQCABCC+jwAADzgA2Qbyz3CfALj/PaBdBI/wHoVRIEDFDBIBNzHyBsiGIPGPLfTP +dYAAFECIFQAWBCG+jwAAAFAB4IgdGBAE8gTYDBocMD4J7/4A389woAD8RCWAvLkloGsVABaMIAKN +YgAGAM9wgAAgIQCA67gF8s9wnwC4//2gSiBAIAzM5Lgr9Oa4R/SGIP+FzfJRIwDAt/JRIEDFs/QM +zM91gAAMQVEgwIDoAQEAgNgMGhwwDczruKfyHYUB4B2lSiAAIKTwxgtv8xnYGgtgAelwkQIgAEog +QCANzFMgQIBY8wTIAxIBNgMaGDC2C6ADBBpYMM9woAD8RCWAz3WgAMgfAN+8uSWgz3CAAFwJAICA +4BXydPCOC6ADAN/PcKAA/EQlgLy5JaDPcIAAXAkAgIDgz3WgAMgfYvQGyAQgvo8DgOhTavVRIEDF +aPWmCI/5Og+P80whAKAb8t+FoBUAEAkmABDk4M32z3CAALDJAIBRIECABfL+pToKIAEQ2OTmx/dA +FQEWMHm+DG/5ENiKIAgAoB3AEw6lH4WA4AT0iiAEAA6lLgmAAS/YlbgSHRiQz3ABAMD8FR0YkIYI +gAPPcYAA3DoAgYfg1vLPcKAAOC4FgAQggA/AAAAA13DAAAAAxfL12AW4z3KfALj/GqIH2BuiadgY +uBmiAdi68PILD/2d8QDfrvAVhQHgFaXPcIAAXD8RiFEgAIC8C2IDyiBiAIDmBfIchQHgHKUMzOe4 +AN9a8g3MBCCEDwAAABgMJICPAAAACDPytgwP9g3MUSDAgD/yz3GgACwgBYEmgQrgMHBgAA0AAxIB +NgLYDBocMFDYMgvv/ZgRAQAqCoADz3CgAPxEJYDPdaAAyB+8uSWgPvGKIAQADBocMBSFgOYB4BSl +xfMbhQHgG6XB8UIPb/cKcFEgAIAG8gjYm7gGGhgwUvDPdaAAyB8E2AYaGDA38QPIoBAAAPC46XAZ +8oIIz/YA2Ja4FfDouBfyAgxv+4ogBAAKDC/26XUDyKAQAADwuKlwBfJaCM/2ANiVuH4LwAQE2NXx +6bjPcaAAyB8I8j4I7/YB2ADYkLjz8QQgvo8AAABQCvJRIwDACPKKIAQADqEE2AYaGDANzO+4DPJA +EQIGz3GAAMzLL5EwcoT3r7gNGhwwz3WgAMgf1wXP/wDYgeAE9AfYAKHPcIAAnAkAgIDgBArCAs9x +gAAEQgyBTYEIIgAADaHPcIAASCEQgE+BYIAOgQJ7AMoIIsIAiOBPoQr0A9nPcKAAQC0woEEE7/8A +GsIzAeA5BO//ABoCMOB4z3GAANw84H8AoeB48cA2CK/wiiCLAc93gADwCsoKr/gghwDYz3aAALQK +z3GAAGg9CKELpgGGhiB5jxbyz3WAAOwKAIUghxi4ELkFeYUhGACWCq/4iiCLAAbYAKUA2OsCIAAA +pwPYMgwv+Au4gOAghwf0z3WAAOwKAIUYuObxgOHKAgIAAhaEEAMWhRDPdYAAUM1AJZEQhCwfAC9w +ACCBD4AAWNQVIUEBW5E6kUAlEhpAJRAVACUGEAQWBgGA4rhgA4Ah8jByyiHFD8oghQ8AAHsnyiOF +DwAAhwE+ACUAyiLFB4DgD/IQcsohxg/KIIYPAAB8J8ojhg8AAIkByiLGB0v30HFO9wohwA/rcs9w +AAB9J4ojRgNKJEAApQWv8bhzgOAQ8hBxyiHGD8oghg8AAH4nyiOGDwAAjwHKIsYHbfcMhoDgI/QH +hoDgIfQB2M9xoACwHxmhz3CAAEghCIAAgIQsHwAJpgAhgH+AABzUMOD0IEEBcgmv+IogSwaKIEsG +Zgmv+CmGAdgHpgKOz3GAAPAihCgfAAAlQh4jgUWCSKFDjgAhgX+AABzUMOH0IYIAz3GAAPAiI4HP +cIAA8CJUsc9xgADwIgAlQh4jgUaCJ3VJoQOAJZUtsALYCHEyDe/wANraDUAAAo4jjoQoHwAAIYB/ +gAAc1DDgMCBCLvQgQQBTIgAAng9v/wDbAo7PdYAA7AqEKB8AMCJBLs4Ir/iKIBMBAo6EKB8AL3Ew +IkAgACGCD4AATNIjjgK5NHmqDyABWWGKIEsHogiv+CCFegrgAQHYqgwAASKOQ46EKR8AACGAf4AA +nNMVIIQAMBQAAFEgAIAN8gHYz3OgALAfGaPPcIAASCEIgACAAqbPcIAA8CICgIQpHwDCEAMGgbvC +GNgAMBQAAMC4UiAAABt4VXgAIIIPgABY1DTiNCJBDgq5MiFALiimIIVRIECAAIcYuRC4BXkR8s9w +gAAszSAQgACB4An0hSEUAAIIr/iKIIsABdgH8Iq58g9v+IogiwAE2AClANgApwKOI46EKB8AACGA +f4AAHNQw4PQgQQDOD2/4iiALBM9wgABIITCAIIG6D2/4iiALBAyGgODKICEAIA4h88ohAQAB2FkF +T/AKIcAP63LPcAAAfyeKIwcISiSAAGEDr/G4c/HAmgnP9gDY0cDgfvHAkgsv+OHFgOA08s9xgAA0 +sRSJgeAu8jeJgOEJ8s9wgADMuwGAEHEB2MB4FPDPcoAAuKULioYg/4we8s9xgADMu2GBpIqxcwDY +BfIgijBzAvQB2IHgz3GAAOAKAKEK9M9wgACwYCaAI4EggdoPgALlBE/w4gjP9u7x4HjxwGYMT/DP +cYAAuAoAgc91gADsCs92gADwCoC4AKHPcYAAaD0FgQHgBaEghQCGGLkQuAV5hSEYAMIOb/iKIIsA +BtgApQDYjQRv8ACm8cAWDE/wz3CAALYKAIjPc4AAtwpAiwHemHCEKB8AL3AAII0PgACc0zDl8CWB +EMC5geEAIIEPgAAc1DDh9CGFAMdwgABQzcB+AeLjiE968XI+ACoAQKv0IY8AsHcZ9IDmF/LwJY8Q +UScAkBP0AeLjiE968XJM9vQhjwCwdwj0gOYG8vAljxBRJwCQ8vNAqwOIEHJ6AAoA8CWAEIQsHwDA +uFIgAAAbeFV4ACCBD4AAWNQ04TQhQA7PcYAA1AoKuAChx3AAAAAYmg/P9891gADsCiCFz3aAAPAK +QIYYuYDgELpFeQ3yhSEMAMYNb/iKIIsAA9gApQDYAKYL8IUhGACyDW/4iiCLAAbY9fGuDs//cQNv +8ADY8cACC2/wiiBLAaXBz3aAAPAKig1v+CCGz3eAALQKBBcFEAHdqHSEJIaQABYEECDyTCQAgKQL +YvbKICIBz3WAAOwKAIUghhi4QCkCBAV6iLqKIIsARg1v+EV5AdgApQDdz3CAAAlnoKipd4zwTCQA +gEP0iiDLACYNb/gA2c9wgADsCiCGAIAQuRi4BXmFIUgACg1v+IogiwDPcIAA7AoC2aCmIKDPdYAA +CWcAjYDgCvTPcKAALCAQgMdwAAAAfQ2nNBcHEM9wAADYiEDABNhBwAHeQsYA2EPARMDJcBDZBNoA +25hzuHNmDG/22HMA2ACtyXfJdUbwTCRAgCL0A9hODu/3C7iA4Br0z3CAAAlnoKjKCm/2BNgAhs93 +gADsCiCHELgYuQV5iLlyDG/4iiCLAKCnANgApgh1Ad8k8EwkgIAn9ADYz3GAAAlnAKlPJYAAAafP +cYAAaD0Ggc93gADsCgHgBqEAh0AsAQQYuAV5iLkqDG/4iiCLAKCnAN2gpql3gOVECUEA6XDhAW/w +pcAKIcAP63LPcAAAeifZB2/xiiOFAuB48cBeCW/wiiCLAqXBz3aAAPAK5gtv+CCGz3eAALQKAYcI +dIQkBpAAFgUQJPJMJUCABPTCCA/yCvCFuAGnz3GAAGg9CoEB4Aqhz3WAAOwKAIUAFgUQGLhALQEE +BXmIuZoLb/iKIIsAAdgApQDYAKZE8EwlAIA89M9wgADsCgCAQC0CBEAoAQYIuEV5BXmKIIsAZgtv ++IC5AYcB2kCmz3WgACwgsIWGIDmPANnPcwAA2IgE2EDDQcBCwgTyENhDwAPwQ8FEwQDYBtkE2ghz +mHC4cAAlhx8AAAB9zgpv9thwiiALBRYLb/iKIc4DBfBMJUCABfQB2NEAb/ClwEwlgIDPdYAA7AoA +FQQQDPSFuAGnz3GAAGg9CoEB4AqhQCwABp3xCiHAD+tyz3AAAIQnoQZv8YojTgjxwCIIT/DPdYAA +tAoBhc92gADwCi8vARCKIAsBpgpv+CCGIYVQIQwAp7xQJAySB/JKCC/yTifAFxvwKHSEJAaQGvI6 +CC/yTifAFwGFhiAGAAGliiBLAG4Kb/gA2c91gACsLgCFgOAF8kB4ANgApRUAb/AB2ACGgOC89FEh +AIDPd4AA8CKV9AKNI42EKB8AL3AAIIIPgACc0zDi8CJDAAHaArlmelR5x3GAAFjUNOEQYQq4CKXH +cAAAABi6C+/3SiFAIMMXARYacM9wgAAEyjR4EYiA4FIN7/fCIUIkTCAAoMwhIqDMICKAU/Iijc9w +gABM1IQpHwAvclNgz3CAAJQJAJAQcyOHGvTHcoAAUM1lggiBUyMEAFMgDwCQdw70Q4qB4sQjgQ8A +BgAAxCCBDwAGAADMIwGABPIA2APwAdhJgQylz3WAAOwKYIVRIkCBQIYYuxC6ZXoP8oDgDfQYiYPg +CfRPIkECXglv+IogiwAC2AnwTyIBAom5Sglv+IogiwAD2AClANgiDiAAAKZx8UwgAKAI9IogCwgq +CW/42dlp8c9xgAAEQh6BAeAeoWHxDgvgAAHYAIfEEAAGJbh6D+/ywLiiDe/yFNh2CG/6BNjqCEAA +Io3PcIAADNWEKR8AMCBBDuIIb/iKIMoPAgkP+UHxCiHAD+tyz3AAAHkn/dtKJIAAmQRv8bhz8cAi +Di/wiiBLAs9xgADwCqoIb/gggc9wgADwCgCAgOC29JYN7/EB3oogEwKOCG/4iiGMBALYWggv9slx +z3CAAGgJAIDPdYAA8CImgM93gAC0Cp4RAAamuJ4ZGAAjhUiBNJFTIgAAEg8v/8lzeg0AAALYANlu +DK/wAtoihcIRAAahuMIZGAAAhcQQAAYluMC4og7v8gDZI4WKIMsDHghv+DSRz3CgALAf2aDPcIAA +SCEIgACAAqdaCaAEAtjeCaAByXDPcIAAPCkEgFEggIAR8s9wgAAUPQCAgOAL9JYL7/eKIMwOgeAF +9PoLD/8M8ADYnrjPcaAA/EQBoeB4ANgBoe4MwADuDE/9A4UpgM91gADsCkCFUSFAgc9xgADwCiCB +GLoQuUV5EPJMh4DiDPQYiIPgCvSFIRwAgg8v+IogiwAH2B3wQo/PcIAAYM2EKh8AMCBADoDgBvIB +h4YgOY8J8oi5Wg8v+IogiwDApQjwi7lKDy/4iiCLAAjYAKUA2c9wgADwCiCgBQUv8ChwCiHAD+ty +z3AAAIMniiNNBkokgADxAm/xuHPgePHAegwv8IogywLPdYAA8AoCDy/4IIXPdoAAtAoCjs93gABQ +zYQoHwBAJwAUMCBBDuIOL/iKIMsCBBYEEIh0hCQGkACFEvLPdoAA7AoghhC4GLkFeYi5vg4v+Iog +iwAB2ACmANgApVvwgOBA9Ih0Ao6EJIaQhCgfACd3DvIQFwUQCiHAD+tyz3AAAI0nXQJv8YojDwDC +De/1BIcIcc9wgADMYEIPQALPcYAAaD0MgQHgDKECC+/yFNjWDS/6BNjPcIAA7AoAgECFQCgBBhC6 +CLhFeQV5iiCLADoOL/hFIcEAA9gApQHYG/CD4Bv0z3KAAGg9LYLPd4AA7AoQuAHhLaIghxi5BXmI +uQoOL/iKIIsAAdgApwDYAKUHpskDD/AKIcAP63LPcAAAhSeKI88GSiSAALkBb/G4c/HAPgsP8M91 +gAC0CiKNz3CAAFzNQiCQAoQpHwAwIEAO3g1v9CmFCHcBhc92gADwCoYgeY8M9ADYUg+v94y4gOAG +8gyFgODMJ2GQJfQAhoHghArB8QyFgODMJ2GQB/TPcYAAaD0AgQHgAKEghs91gADsCgCFELkYuAV5 +hSEYAF4NL/iKIIsABtgApQDf1QEgAOCmAo0jjYQoHwAAIYB/gACc0zDg8CBAAFEgAIA58giF2gxv +9CKFjCAQgGYAKQAghoHhFArB8QDYz3OAAGg9CKMDhYDgEfIkhQDaAN8PJ08QBiDAgy8vARADpU4n +gRcB4vX1JKVIowCGz3WAAOwKIIUQuBi5BXmFIRQB0gwv+IogiwAF2AClBNgApgDfovAghoXhdAEN +ADImQXCAAGhoQCeAcjR4AHgCjQDfhCgfADIgQC5RIECAyiPCAwX0ogzAA2CGAo0jjYQoHwAAIYB/ +gACc0zDg8CBAABC7z3GAAOwKIIHguEApAgZlegzygLgDpeSlCLkleoogiwBFIkEBgPAB2M9xoACw +Hxmhz3CAAEghKIAAgQKlAIFPIgECirkKpSoML/iKIIsABdjPcYAA7AoAoeCmAd9O8AOFgOAk9M93 +gADsCgCHGLiQuJK4TyABAoq5+gsv+IogiwAF2ACnANgAps9woACwHwHf+aDPcIAASCEIgACACqWK +IEsEzgsv+ADZKPDguAf0LygBAE4ggQckpd4O7/oEhc9wgADsCgCAQIZAKAEGELoIuEV5BXmKIIsA +mgsv+IC5Ad/PcIAAvGJqDKAA4KaKIEsEggsv+CSFQQEv8Olwz3GAAGg9B4EB4Aehz3CAAOwKIIBA +KQAGkbgIuQV5iiCLAEUhQQFOCw/4BdhE8QohwA/rck/YB7iKI0kKSiSAAA0HL/G4c89woABMLguA +07hVAuADBtnxwOHFz3WgADguR4XPcIAAZD0A2UCgJ6VyCeAEINgHhYq4B6ULyAQggA////8DCxoY +MAvIj7gLGhgwC8iQuAsaGDC9AA/w4HjxwKoPz//PcIAAZD0ggM9woAA4Lieg+g8P/dHA4H7gePHA +GggP8BYOr/cB3YDgz3aAALQKAYbAfYYgeQ9CIACAyiBiAAi4BX0A2D4Mr/eMuIDgAdjAeBC4BSB+ +gy7yC4aB4BX0Ao4jjoQoHwAAIYB/gACc0zV4LICAuSygz3CAAGg9gNkpoADYC6bPdoAA7AoAhs91 +gADwCiCFGLgQuQV5hSEYADIKL/iKIIsABtgApgDYFQIgAAClQo5jjoQqHwAvcAAgjQ+AAJzTdX0s +hVMhBIAy9OuGgecu9E8kAgBSIgIAW3p1eoC5x3KAAFjULKU04hBiz3GAAGg9gN2poQq4ANkIps9w +oAAsIAOAK6bPdYAA8AoCpgCFz3aAAOwKIIYQuBi5BXmKua4JL/iKIIsABNi/8c93gABQzYQqHwBA +JwATMCBADrYJb/QphoDgQCeQER7yDIaA4Br0KIbPcAAAARQIIQAAmSAKAJIJb/QihoDgB/K6DIAA +sgqP/4fxz3GAAGg9AIEB4AChgfHPdYAA8AoAhYDgEfKE4HvyCiHAD+tyz3AAAIIniiNLDkokgAD9 +BC/xuHMIhkIJb/QihoDgFfIghc92gADsCgCGELkYuAV5hSEUAQIJL/iKIIsABdgApgTYAKUA2G7w +Ao6EKB8AL3AZZyORgOEfZzjyI47HcIAAnNMw4PAgQABRIACALvIClwq45ghv9CqGgOBT8s9ygAAU +QDmCGIIieCSCRYJCeRlhAo6EKB8ANCBALhBxFveWCC/4iiCLBM9wgABIITCAIIGGCC/4iiCLBM9x +gABoPQGBAeABoR3wIIXPdoAA7AoAhhC5GLgFeYUhFAFaCC/4iiCLAAXYAKYE2AClG/AIhvYPL/Qi +hgoiAIAQAA8AkguAAIoJj/8Q8M9zgACwYAaDA4AggGhw8ghgAllhugyv8hTYAdjZBc/v8cB2De/v +iiCLCc93gAC4Cv4P7/cgh891gADwCgCFgeDoDIHxz3CAAOwKQIAghYogiwAYuhC52g/v90V5AN7P +cIAA7ArAoM9wgADMYB4IYALApc9wgACwYBIIQALPcIAAtwrAqMCnz3CAANAKwKDPcIAAaD3JoALY +yXG+C2/wCHJdBc/v8cDhxYLgz3WAABw9mHAR8kwkAIEg8gAVhRAKIcAP63LPcAAAqxo9Ay/xiiPG +CYogkAxaD+/3iiHGAa4KAAABjSCNEHEE9AKNAK0c8CIIYAAArRLwiiAQDTIP7/eKIcYGJggAAIog +kAoiD+/3iiFGCAHYBK3PcYAAXD8RiaW4EanpBM/v8cBuDO/vANjPcoAAXD+sEgQAz3OAABw9QCyB +ADR5PWJZYTSBs4UwdQHfB/YBq+KrAiFOAwbw4asCqwIlThDpcIrmAKtG9s9wgAA8IchgA/AI2KV5 +13EAAP//A6sG8kAkQADCuKwaAADeCQAAfg8gAACLZQTP7+B4CiQAgPHAEPLPcIAAHD0FEIUACiHA +D+tyz3AAAKMaSQIv8eLbiiAQDGYO7/fj2c9wgADwIgOAmgrgAA2Q0cDgfvHAugvP7891gAAcPQQV +hhBMJoCBjvYKIcAP63LPcAAAoRq924okgw/9AS/xCiWAAS8lBwAFrUAugAAVeBUgQAHPcYAAuD0G +YYfmyiHBD8oiwQfKIIEPAACiGsojgQ8AAMQAxAEh8cokgQGG5hbyTCXAgAz0z3CAAOhgMg4AAs9w +gAAEYSYOAAIkjc9wgAAwPvAgQQBgeclwjQPP7/HAHgvP789wgACgCgCAh+DKJYEfAAAQJ8olgh8A +AIgTz3GAAOhgBoEDgMCAz3CAAEghBIAAgNW4HmYocEYOIAJCJoESz3CAAARhOg4gArlmOQPP7/HA +4cWC4M91gAAcPZhwDfIFFYUQCiHAD+tyz3AAAKQaFQEv8fPbiiCQDDYN7/f02QGNEg4gAACtiiDQ +CiIN7/f62QLY+QLv7wSt4HjxwOHFguDPdYAAHD2YcA7yBRWFEAohwA/rcs9wAAClGskAL/GKI4QN +iiCQDOYM7/eKIcQNAo3CDSAAAK2KIFAL0gzv94ohRA8E2KkC7+8Erc9wgABcP6wQAQDPcgAA//8C +uTR5OGBToOB/VKDxwAYKz+/Pd4AAkMvPdYAAHD0AFYUQz3aAABRATCVAgBQXkRDQFpAQzfYEFYQQ +CiHAD+tyz3AAAKgaRQAv8YojCwSKIBUOYgzv96hxjCEBqF4ABgANlyzgAiBABECND3uA4ncWARYK +9AQhgQ//AAD/JXt3HtgQEfCB4gr0BCGND/8A/wBAKwECpXkF8DB5ELtleXceWBDPcYAAXD+sEQMA +TOECcAK7dHtVe3lhAKG5Ac/v4HjxwM9ygAAcPSiKgeEZ9CmKMHAX8oHgCaoN9M9wgADoYC4MAALP +cIAABGEmDAAC0cDgfgSKg+AF9AoOz//58fnx8cDhxYHgz3WAABw9mHAm8kwkwIAN8gUVhRAKIcAP +63LPcAAAphplB+/wiiOECYog0AyCC+/3iiEEBM9xgABcPxGJhbgRqYogkAtqC+/3iiEEBQXYBK0W +8IogUAxWC+/3iiFEBqoOz/+KIBALRgvv94ohRAcD2AStCY2A4IQNwf8RAc/v8cDhxQokAIDPdYAA +HD0R8kwkAIEq8gUVhRAKIcAP63LPcAAApxrhBu/wiiMFC4ogEAz+Cu/3iiHFBM9xgABcPxGJpbgR +qYogkArmCu/3iiHFBQHYBK0D2AOtAY22CyAAAK0ODs//FPCKIBANwgrv94ohxQgWDs//sgvP/4og +kAquCu/3iiEFCgHYBK2BAM/v8cDhxRS4JXjPdaAAOC4GpQXwdgyv94ogXAgGhf+4+/NdAM/vz3Gg +ALwtFXlZgTGBz3OgAMAvMHIK9KATAYYRIQCAAdjCIAEABLgG8EAiAAQieMO44H7gePHArg+P789x +oP7EBgDfz3CfALj/NqDPdqAAwC+lHtiTD90IvQXwCgyv94ognAKjFgCWpHiMIBCA9/MUHtiTBvDu +C6/3iiDcBKMWAJYLIECD+PXFB4/v4HiU4MoiBQCF9whygCLCBM9xoABoLPAhgQAA289yoADELGei +aKIMuJ24n7gleAai4H7xwCoPj+8IdnIP7/8odclwEg/v/6lxgQeP7+B44cUw2wDdz3CgAMgcaaAD +2s9xoADMFyEZmIBOoaegaqDgf8HF8cDmDq/vANnPcKAADCRYgM91gABUy61wQSqGB4Yg9w+YFYMQ +Kbh2ecBxx3GAAPjmFXkAEYQAz3CAAKwWIIBALM4A1X7QYdlhRCCPgFMgjgAEIoAPACAAAMwgIoAG +9IDnzCAhgADYA/QB2M93oADEJ0ArBQaGI/0PTCQAhFIjwwG0ACoARbuA5swgIoBU8s9wgAAgdvAg +hwNALoYDguYFJsYBBSWAAQV7QR/YkCb0H4UQ2pq4H6UI2E8dAhDPcKAAyBxJoAeBz3KgAPAXBqIG +gQaiBYEGogSBBqIA2AqiihUAEWi4EHiKHQQQAJWGIP+MKfQB2B2iJ/BOFYAQgOAj9IoVABFMpWS4 +EHiKHQQQg+YE2U8dQhAM9CsXAZZkuBB4ih0EEAzYLaVPHQIQLg4v94hwCfAFI0MBQR/YkB+Fs7gf +pQ0Gj+/geBDaz3GgAMgcSaEB289xoADwF2qhpBACAOu6JvIC2l2hz3OAAIjdRINGoUODRqFCg0ah +QYNGoXAQAAEc4FMgwIAE9EAjAAgE8EAjAAxAgFOhTGhAglOh+BACglOh/BAAgBOhD/BckIYi/4wD +9H2hSIBGoUeARqFGgEahBYAGoeB+4cUvgM9zoADwF89yoAD8FyijQBABASqyMYAoo0gQAQEqsjOA +KKNQEAEBKrI8kIYh8w+MIQyAB/Q2gCijXBABASqycBABAbyQCOGosr2QqLJUEA0BqLJgEA0BqLK5 +gKejuoCno7uAp6NyEAABOGAQeAiyz3CgAPQHJ6AC2c9woADIHCeg4H/BxfHAFggP954LD/fRwOB+ +4HjxwIIMj+8A3lEgAIDPcoAAqAjPdYAAOCEAhQHgJPIA2Ze5MaKB4AClCfQB2c9woADIHDGg3gwg +BChwz3GAAEYEz3CgAOwnJqAAhUIgQIAApQX0z3CgAMgc0aCKIBEAC9kB2iLw0aKB4AClCvQB2c9w +oADIHDGgngwgBChwz3GAAEcEz3CgAOwnJqAAhUIgQIAApQb0z3CgAMgc0aCKIBEACtkA2noOr/ca +cgCFAeCB4M93oADsJwClCfQB2c9woADIHDGgTgwgBChwQChAIRB4ELiBuIe4jLgGpwCFQiBAgACl +BvTPcKAAyBzRoPkDj+/xwJYLj+/PdYAAVMsXhZjgz3aAAJjnBvJYFYAQgOAF8lqFO4UD8FyFPYXP +cIAA3DwAgFEgAIAJ9BKFBCCADwAAABAFegV5z3D+//8/BHpBpgDf4qYkeA2mDtiaCm/3DqaA4Ajy +z3GAACgmXgugAAHYz3GAAAQjUgugAADYF4WU4Ab0Ad2hrjEeQhMG8OGuMR7CEwDdz3aAABQaAYaG +IL+NQPQA2Y25IKaGDa/3iiDTBoDlBfRAJgITA/BAJgIUIILPcKAAwB1SIQ4AB4DAvkQgBAHPcIAA +4jqgkC8mR/NBLIQAHfQEJY0f////wgu+xX2IvUAsgwKle08jDgMEI40PAAAAPE8lDBNPJEyTjb7A +sAX0i7uMu427YLAvIUMAIKLdAo/vocHxwGIKj+86cQh2SHeKCm/5AN2B4MogQiML9M9wgAD0IACQ +geAB2MB4QCgQA8lwhiD8AIwgAoUj9M9wgABUy5gQgADnuMogIgAK9AK4FnjPcYAAEN8AYS24wLjP +cYAANAoggVEhgIDPcYAAzMsUeQTyINqtkQrwmNqrkQbwz3CAAJDLs5AO2gGXQCUBFRBxRvaieEgg +AAAQeAPwANhacADYKnGpcwYNYASYcAohAKAE9NILAAQ6cEwhAKAA2E30BSCAIw1xALENcQAZhAQj +hw1wIKAolw1wILCKIIUALgyv98lxjCYClRTyjCYDkR7yjCYDlSPyCiHAD+tyE9iMuM9zAACUCook +gw/ZB6/wuHPPcIAAVMu0EAEAD4EB4A+hygkgAOlwE/DPcIAAVMu0EAEADoEB4A6hCfDPcIAAVMu0 +EAEADYEB4A2hz3GgAPQHANgEoQHYGnDPcaAAyB/4EQIAQnUCJYAQSCAAAF+BEHhQcD4ABQBDh89w +gADwsUwhAKBCoKDYD6EA2B+hz3CAAFTLHJBiuEJwH6EC2BUZGIAF8lEgQMYg2ALygNgOoYwmA5UH +9M9wgABUyxyQCPCMJgORCfTPcIAAzMsPkGoKb/gA2cIOT/4MzIYg+Y8R9IwmA5HKICEAzyChAwny +TCIAoADYzyAiA8ogIQEMGhwwCnAI3MMAj+/gePHAagiP76HBCHeGCG/5AN2B4Ar0z3CAAPQgAJAB +3YHgwH0Mvc9wgACE6gSAz3KAACyyBCCADwAAABBFIEEDQMEgwMO4HHj0IgMAz3CgACwgD4BwuxBz +AN4I9/B4cHtaD2AEFNr4uATyyXA48APYz3GgAPQHBaGFJQMZDXCgsA1wwLCKIv8PDXBAoM9yAAD/ +/w1wQLADyM9zgAAQ389ygADwIhCIArgWeABjLbjAuPAiAACggA1woKADyBCIArgWeABjLbjAuPAi +AABCkA1wQLDEoToJAAQB2PkHb++hwOB48cCCD0/vGnDPcYAAZLIAiYDgFvLBgaKBz3CAADQKAhER +AeCAz3GAAARCC4E0vwHgC6E28NYLb/eKIAsIz3GgAMQnEREAhlEggIEA3/TzZBEChmQZ2IMC2BMZ +GICA4i8ogQBOIIEHE/LPcIAAxKU2eMCAoYDPcIAARKb0IFEAz3CAAGSm8CBPAArwz3GAAARCCoHp +del2OncB4AqhBBABIA1wIKAIEAEhDXAgsM9xgAAMzACBgOAH8kKBDXBAoADYAKHPcIAA8CIDgAiA +67jKIIIDyiFCA8oiwgNMCKIEyiNCBFMhwCDPcYAANAoggRS/USGAgAy45XgJ8oK4DXEAoQ1wwKAN +cKCgH/ANcQChSiQAdOB4qCDAAkQmgRAPuVMmABAleA1xAKEivkokAHTgeKggwAJEJYEQD7lTJQAQ +JXgNcQChIr2dBk/v4HjxwEIOT+8Idih1KHBIcWIIIABocoHgyiCBAxAIIQDKIUEDjQZP7+B4IrkG +8OxyYKIE4GG5geFggDr3z3CgANQLbaAD2c9woABEHTWg4H7geEEpgYAK8i8kSXDgeKgggAEEEAIE +7HFAoeB+4HjxwM4NT++hwQh3z3agAKwvGYYEIIAPcAAAANdwIAAAAAHYwHgvJgfwKHUachP0iiDJ +AzoIr/eKIcwFOYYuCK/3iiCJA4ogiQMiCK/3qXEA2C3wC8wAHEQzTyDBAwIcRDAB4BB4BCCADwAA +/7+PuAsaHDDPcKAA1As4gEIhAQhIIQEAQCcAEhBxBAgFBAfnBCePHwAA/P8FJwAUnbifuOxxAKEA +wexwIKAB2IkFb++hwPHA4cVCDS/5AN2B4MogQgMJ9M9wgAD0IACQgeAB2MB4DLiFIAMBA9rPcaAA +9AdFoQ1yALIDyADbXZANcECwA8hRgA1wQKADyEgQAgENcECwZKFJBU/v4HjxwM4MT+/PdYAA3J7g +FQAQAN6A4ND3RC4+FwAhQHMc2cXaHttqDu//GLvgFQAQAeYQdrP3ANgFBW/v4B0AEOB48cCODE/v +IYAKJgCQEInDuMohwQ/KIsEHyiChBsojgQ8AAKoAzyAhAzzygOHKIcEPyiLBB8og4QbKI4EPAACr +AM8gIQMu8gK4z3GAABDfFngAYc9xgADwCS24wLgMqSOGIJGGIfwAjCECgAz0z3GAAPAi8CEBAL8R +AAaBuL8ZGAABhqKAgOUI8gGFgOAE8gCFgOAN9AohwA/rchzYjLi520okQABVAq/wuHNRIIDBBvR6 +DwAAgOAN8oogzgJmDm/3wNkAhYDZKKABhUB4HvABhiCQFMgQccohzQ/KIs0HHdjKI40PAADGALgH +7f/PIC0DEg7v9slwTg0gAAGFz3CAAPAJ6gjgAwyI8QNP789wgACkYvEGz//gePHAcgtP76TBCHeK +IIsD/g1v9+lxz3CAALcKIIgBHMIzz3CAALYKAIhgwYQoHwAAIYB/gAAc1C7g9CBAAADdAxwCMM92 +gAA4IQCGAeCB4ACmCPQB2M9xoADIHBGhogvAA4PBTgpv8IogiA8AhkIgQIAApgb0z3CgAMgcsaAM +FAAxJ7jAuAIcAjAB2M92oADIHxOmz3GAAEghDIEAgITaQsAIgQCADNke20HAi3CKDO//GLvPc4AA +7ArPdYAAaD0LEgE3XpWE2GCDYgngA5h3tggABKQWABATpQEDb++kwOB4z3CAABCxKIDPcJ8AuP8A +2jagCNnscCCgA9nPcKAAFAQloAHI7HEAoc9woADUC02g4H7gePHAXgpP76XBCHcodoogmQbmDG/3 +WtkA2c9woAAsILCAQMYG2EHAQsFDwUTBAdge2elyANuYc7hzACWHHwAAAH2KDKAA2HOBAm/vpcDx +wBYKT++kwc91gAC2CkCNz3CAALcKIIiEKh8AACGAf4AAHNQw4PQgQAAA3g95YMB6DG/3iiBLAyCN +z3CAAGTNz3WAAGg9hCkfADAgQA7AuAEcAjAJhcmlAhwCMAiFyKUB2QMcAjDPcKAAsB85oM9xgABI +IQyBAICD2kLACIEAgB7bQcDPcIAAFEA9gAmAOGBDwItwENlCC+//GLsAFIQwCxIBN89zgADsCl6V +g9geCOADYIPNAW/vpMDgePHA4cWlwc9wgAC2CiCIz3CAALcKQIiEKR8AACGBf4AAHNQw4fQhggAA +3U95Y8LPcoAAZM0wIkAOwLgNHAIwsgtv94ogCwPPcaAAsB8B2Bmhz3KAAEghLIIggR7bQcEogiCB +QMEkgiCBDhxCM0TAi3BCwQ8cQjMU2YLaogrv/xi7z3KAAGg9DBSEMAsSATfPc4AA7ApekoLYdg+g +A2CDMQFv76XACMiHuAgaGDAJyJu4CRoYMArIChoYMAvIh7gLGhgwDMgMGhgw4H7geM9xgADcnwCB +gbjgfwCh4HjPcYAAIDA2iVEhwIEO8s9xgADQLiCB4bnKIWIABfRRIQCABPIA2SCo4H7geM9xgADc +n+B/A7HgeM9xgADcW+B/AKHgeOHFgODPcqAArC8A2Sv0z3CgALQPPKAYgvq4ZPQVglEgAIBg8hqC +USAAgFzyz3OAADghQIMBaoHgBvQB3c9woADIHLGgz3WAAEdoz3CgAOwnpqCA4kCjRvTPcKAAyBwx +oEDwGIL6uDn0FYJRIACANfIaglEgAIAx8s9zgAA4IUCDAWqB4Ab0Ad3PcKAAyByxoM91gABGaM9w +oADsJ6agQKPgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HiA4gX0z3Cg +AMgcMaAB2c9woAC0Dzyg4H/Bxc9ygAA8PxV6IKLhAW/3iiCSDuB48cCYcAohwA/rcgolwAfPcAAA +ohmZBW/wVtvgeM9ygAAYPxV6IKKxAW/3iiDSDuB48cCYcAohwA/rcgolwAfPcAAAoxlpBW/wXtvg +eM9ygABQPxV6IKKBAW/3iiASD+B48cCYcAohwA/rcgolwAfPcAAApBk5BW/wZtvgePHApBABAPm5 +BPQ+CM/2B/Ag2c9woADIHCmgA9nPcKAAEBQloNHA4H7hxQO4NXjPcYAARGcCYUokAHQA2aggwAIW +IkAAoYBggCnYErgB4XV4oKDgf8HF4HjPcIAAaAkAgKHBJoCeEQAGhrieGRgA4H+hwOB44H7geM9x +gADwCeB/BKHgePHAPg4P789ygADwIiOCOImE4Q70CiHAD+tyiiCMDoojBgJKJAAAiQRv8LhzIILE +EQEGUSFAgUfyz3aAALRfIIZCIQGAyiFiAIDhPfSA4A/0CiHAD+tyiiDMDoojhgNKJAAATQRv8Aol +AAEmhiOBz3eAAEghoIEkhyCB1bk9Zc9xgAB45yWBYbgFKT4AJ3WKIIkLRghv96lxBIcggIogiQs2 +CG/3NrnJcP4IoAFCJYESz3CAANBfACWBHwAAiBPqCIAB5QUP7+B48cB2Dc/2gOAf9FINz/aA4Avy +z3CAADgmLJDPcIAA8CIekBBxD/TODM/2gOAN8s9wgADQLgCA67gH8qoMz/aA4AP0AdgC8ADY0cDg +fvHAhgzP9oDgHPKeDM/2gOAU8s9wgAA4JiyQz3CAAPAiHpAQcQ70z3CAANAuAIAEIL6PAAA4EAb0 +egnP9oDgBPQB2APwANjRwOB+4HjxwOIMD+/PdYAAPArMjQ2Nwr7CuBZ+z36ODe/7DdgGuIG4EL7F +eM9xoADsJwahBIXPcaUA6A8GoQWFB6ERBQ/v8cCeDA/vz3alAOgPJoanhs9wgAA8CgDfJKCloEoN +7/sN2Aa4gbjPcaAA7CcGoeamRSXNH6em0QQP7+B4z3GAABwmz3CAAJQJAJBHiRByFfTPcIAAlgkA +kEGJEHIN9M9wgACYCQCIJokQcQf0z3CAAJQuAIAC8ADY4H7geOHFn+HhxgDdGPKe4QP2gOFD9gDY +FPCf4R/eSvZOIfwH4HioIIABDyWNE2G+ESBAgAPypXgC8KZ4AKIB2MHG4H/BxeB48cDeCy/vKNjW +DY/3z3WAALQuQIUIdgQghA8AAPD/ANhgekEsAQFAhQHYRCYEE2B6QSyBAECFAthgelMmQRCiDa/3 +ANhAhQh3QSgBAgPYYHrAuUCFQS9BEgTYYHrAuc9xAAD03M9wgACwLiCgz3ACAPAZAKXPcf7KAgD+ +DS/3iiCSD8UDD+/gePHA5gmP+34NT/vPcQAAHN3PcIAAuC4qCi/7IKDPcQIAIBrPcIAAvC4goM9x +/soBAL4NL/eKIJIP0cDgfvHAHgsv71DYEg2P9891gADELkCFCHYA2GB6UyZBEECFAdjJcWB6hiH9 +D89xAABA3c9wgADALiCgz3ACAFAaAKXPcf7KAwBuDS/3iiCSDz0DD+/gePHA4cWiDq/4B9giCm/7 +CHWeD8//GguP+44Lr/ipcCEDD+/geOB+4HjgfuB48cCaCi/vUyABAIHhSidAAMInwgEId4Yn/hNE +vwhzhiPxD0e7CdnPcoAAXD8sqjCqLqovqkQggQM8eRlxLaoEIIQPAAAADEIsjQK4dbOqBCCEDwAA +ADBCLA4D2HbUqgDYsRoCAFMhfoDKIcEPyiCBDwAAkRrKI4EPAABOAsoiwQcf8kwnAIAu8gQgwBAQ +c8ohwg/KIIIPAACSGsojgg8AAFgCyiLCBw305Htwdw/yCiHAD+tyz3AAAJMaiiNJBookww9JAG/w +SiUAAIDnPfQKIcAP63LPcAAAlBqKI4kG8fFMJsCABPZMJgCAEPYKIcAP63LPcAAAlRqKIwkIiiTD +DwkAb/AKJYABDCWAgQT2TCUAgA72CiHAD+tyz3AAAJYaiiPJCOUHL/CKJMMPUyEAAIYhfw88eThg +D3iwcEL2E6rQcEP2FKoSC+ABANi1AQ/v4H7geOB+4HgA2Q8hAQAveRNpJXjPcYAAXD/gfwyp4Hjx +wCYJD+9RIACAGnAH8oogUQCyCy/3CnGD8EQggCMceJhwz3WAAFw/Da0EIIEvAAAADEq5M61TIECA +yiHBD8oiwQfKIIEPAACpGsojgQ8AAPoBSAch8MolAQTPdoAAHD0HjoDgzCGhgAPyANgK8M9wgADw +IgOACYBRIECB9/MB2A95CK4+Cy/3iiCQDweOgeANFYQQUyQBABj0gOHKIcEPyiLBB8oggQ8AAKoa +yiOBDwAABALkBiHwyiUBBADYAa4A3QHf4q4R8IDhAN0B2Afyoa4A3QHfqXD28VEkQID68wGuoq4I +d8ILb/8AriiOgeEEjg70gOAV9IogkArGCi/3iiHIB+SuA9gDrgvwgOAJ8oogUAquCi/3iiHICaSu +bQAP7+B48cDhxc91gAAcPSeNMHAQ8getz3CAAPAiA4DGDu//DZAHjYDgYAkh+8ogoQBRAA/v4H7g +ePHA0g/v7gDbocEEuM9ygACY5xR4HWIaYgGCbyZDEMiliiYEEs9y/v//P8mlBHqA4UDCyiXBAAvy +CIEEIIAPAAAAMEIgBYDKJWIATCUAgCbyz3CAAPTJABAEAMiBBCSGDwAHAAAEJo4fAAAAMCy+Yb5B +LgYGQCaAExEmgIMPIgIAQMJC9AohwA/rcj7YjLiKI4oOsQUv8Lh2z3CAABw9B4iB4M8ioQMv8s9z +gAD0yc92gABUy5oWgRADiwshAIAh8kwWgRAA21MhTgBEIQ8DDyODA0K/AN4PJs4ThiH/AwQmDpAA +30S5BHsPJ08Q5HjKJgEQgOPKI4EDDrtlegPwAYMFekDCz3CAAPTJIICLcoYh/gMkuUApgwMgggQh +jg8BAADACybAkBby13YAAABAzCaCnwAAAIDMJoKfAQAAAAT0AYAD8AKArrmvubC5JXgAogAUBDAE +JIGPAQAAwAr0CiHAD+tyRtiMuNkEL/CKI4sJCIUuuUApAgYEHQARRXgIpYogBQYJpc9wgACoywSI +gOCKIAUOyiCBDwAA2AEJpalwANoB3r4Ib/zJc8CtjQbv7qHA4HgKJQCA8cAT8kwlgIAT8kwlwIAU +8gohwA/rcoogzQ6KIwQFbQQv8Iokgw9WDAAA0cDgfuYLAAD98X4LAAD58eB48cDaDc/uCHXPcIAA +5DgJgIDgCvTPcIAAdDgpgAzg8CBOAAPwAd6KIP8PAKXPcYAA8CIAgcQQAAZRIECBM/Q2C4/5AKVe +CO/3qXCA4Mol4hGk9I4Nj/aA4AX0AIWMIP+PDPTPcIAAuC4ggGB5AdiB4AXdyiUiEZLwz3GAALQW +IZHPc4AApApAgzzhOmIhg2TiFOFZYTBwAd3CJU4Ts33BvXzwA4EYiITgE/SSCo/5AKXPcYAAtBYh +kc9zgACkCkCDPOE6YiGDZOIU4Vlh5PHPcIAAtF8AgM93gAAIo0IgEICiCa/5yiBiIAClAYcQdsb3 +Ogjv9clxCHbPcIAASCEEgM9xgAB45wCAJYFJbtW4BSm+ACdwargghUggAAAwcMogRgBF9wClSiBA +IM9xgAC0FmGRz3GAAKQKQIEhgTzjAd16YmTiFOE6YlBwwiVOE7N9UyVNkCLyTCBAoCD0z3CAALRf +cg8AAc9wgADQX2YPAAHPcIAAeGBeDwABz3CAAJRgUg8AASGHMHbJcMb3FgggAAHZBPAODo//pQTv +7qlw4HjxwD4M7+64cQonAJDKIcEPyiLBB8oggQ8AAEsDyiPhDsokIQCIAiHwyiUBAc9wgAAIYAaA +A4AAgM9xgABIISSBSW/Agc9xgAB451MmTRUlgR1lBSm+ACd1AiUCEIwiF4c2vv5mSffPcIAACKMB +gAUofgAndR5mTCUAgBLyTCVAgD7yTCWAgGvyCiHAD+tyiiCNDpDbGQIv8Iokgw/+Co/2gOAU8s9w +gAA4JiyQz3CAAPAiHpAQcQryz3CAAAhgAiWBHwAAAAwH8M9wgAAIYEIlARXWDgABz3CAACRgACWB +HwAAiBPCDgABiiBJDOoN7/ZCJQEViiBJDMlxZPCeCo/2gODPcYAAeGAR8s9wgAA4JkyQz3CAAPAi +HpAQcgfyKHACJYEfAAAADATwKHBCJYEXdg4AAc9wgACUYAAlgR8AAIgTZg4AAYogCQ2ODe/2QiWB +F4ogCQ3JcTTwQgqP9oDgz3GAAEBgEvLPcIAAOCZMkM9wgADwIh6QEHII8ihwAiWBHwAAAAwF8Chw +QiUBFRoOIAHJvs9wgABcYAAlgR8AAIgTBg4AAc9wgAAIo8OgiiDJDSYN7/ZCJQEViiDJDelxFg3P +9s9xgAB45waBgbjZAu/uBqHxwGoKz+7Pd4AA7F9SDSAB6XDPcIAAwDgggM9wgADEOACAz3agACwg +CSEBAM9wgADoyAiACSENADCG6XCWDSABuWEwhoogCgC6DO/2uWEwhoogCgyuDO/2uWF5As/u4Hjx +wOHFz3CAAAijAYCB4Ab0z3CAAHQ4B4DPcYAAQGAggUIhAYDKIWIAgOEd9M9xgABYySyBgOEX9M9x +gABAyRoNr/UjgQh1iiDJA1oM7/ax2YogyQNODO/2qXGpcHIN7/8C2SECz+7gePHApgnP7s9wgABI +IQSAoIDPcIAAtF8AgEIgAIDKIGIAgOA2vQb0z3CAANBfagwAAc9wgABAySGIz3CAAAhggOHPdoAA +CKMM9CCAQiEBgMohYgCA4QTyIIaA4S70OgwAAc9wgAAkYDIMAAEBhoIMr/UIcSGGD3gwcMz3CiHA +D+tyiiANA9fbSiQAAIkH7++4c89xgABAYCCBQiEBgMohYgCA4QfyHWUjhsm9MHUE8roM7/8A2V0B +z+6A4uHF4cZW8kAiwwMku8O6AvAA2o/ilgANADMmgnCAAIxoQCcNc1R9IH3AiAEZkgMB4AEQggQB +GZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZ +kgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmS +AEIjQ4Cz9cHG4H/BxeB4gOJYYFlhC/IvJIlw4HioIMAB/xCCgv8ZioDgfoDi4cXhxiTyY2oiu8G6 +A/AA2oPiGfczJoJwgACIaEAnDXNUfSB9wIAEGZADBOAEEAIEBBmQAAQQAgQEGZAABBACBAQZkABC +I0OA5PXBxuB/wcXgePHAxg+v7lMhQgBOIg0Bz3KgABQEyYIA2w4mgh8AAAAGUHHKIcYPyiLGB8og +hg8AAMYiyiOGDwAAmwLKJGYA9AXm78olxgCA4cokTXDKIs0A6CAtAk5gz3GgADgEAeLIqYHlDvKC +5Qjyg+UO9M9woAA4BGioz3CgADgEaKjPcKAAOARoqK0Hj+7xwBoPj+4acHpx+nK6cwoiACEKJEAh +yHUKIcAhCiFAg89ygAAe38ohYgASaRZ4CGJMIwCgBLgId4Yn/hMlf8ohzA/KIswHyiCMDwAAwSHK +I4wPAADuAMokbABQBezvyiXMBFEggMEP8s9wgAAQsYDZKKAMwIDgBPJAeJPwLgxP/4/wTCBAoIog +SgPKIIIPAACOAkIJ7/YA2c92gADYYgGGANlSDW/wONoAhhzZIKABhhjZILDPcYAA8CIVIVYDABYB +IFOBDcHwqM93gABECygYQARFeaS5IaAA2TMYQgDpcSKgCiFAgzEYwgQyGMIENBjEBcohYgAyCa/1 +DOCA5Qb0z3GAAHixBfDPcYAAmLEjps9wAABIEQCxTCBAoBjYAqYE8oogBQIAsQzAgOAE9M9wAgCc +FgGnABYAILkQAAZRIACAF/JBhhrYALICpgCRh7gAsQDYC7EBgkwlAKCtuAGiB/LPcIAAeDoEgDMa +AgBMIgCgFPIhhgGBmLgBoQOBn7gDoc9xgAAgCgAWACAAGQQFQIABgEGhAqEaCW//yXDFBY/u4Hjx +wHYNj+66cHpx+nIKIgAhCiFAIch1CiTAIQogQIPPcoAAHt/KIGIACHECuBZ4CGJMIwCgBLiGIP4D +BSBQAMohzA/KIswHyiCMDwAAvyHKI4wPAACWAMokbACsA+zvyiXMBAzAgOAN9AohwA/rcofYBriX +20okAACNA+/vuHNRIIDBCvLPcIAAELGA2SigDMBAeGrwz3aAANhiAYYA3+lxrgtv8DjaAIYc2SCg +AYYQ2SCwz3GAAPAiFSFWAwAWASAzgTMYwgPPd4AATAsQGAIEpLmNuZm5IaDpcSKgCiFAgygYAAUx +GMIEMhjCBDQYxAXKIWIAjg9v9QzggOUF9M9xgAB4sQTwz3GAAJixI6ak2ACxTCVAoBDYAqYF9KTY +jLgAsc9wgADwIhmQjriPuAGxTCIAoAzAAacT8iGGAYGYuAGhA4GfuAOhz3GAACAKABYAIAAZRARA +gAGAQaECobIPL//JcFkEj+7xwOHFz3WAACRDAI2MIMOPD/TPcoAAmF8GggOAIIDHcQ8AAKByD+AA +SHD+2ACteQSP7uB48cD+C6/uANjPdYAA0OFKJAB0gN6oIAAFCHEB4E8gwgEWJUMQR6uKIggAArk2 +ecdxgAAQ30ChANpCscapwNh/HQIQz3WAAJwKwK3PcIAAkN6A2WIKb/AocsGtz3CAAFQm2ajPcIAA +RCMBBK/uxajgePHAiguP7qHBCHe6Cm/xGNjPdoAAFEAghgGGgOHMICGAK/TPcKAA1AsYgADdQiAA +CIDgyiBMA4wgCIVI98EWABYB4MEeGBAd8J3YABwEMAvM6XECHAQwAeAQeAQggA8AAP+/j7gLGhww +AMAe2loIIAAYuqGmBfCA4APyYbgBphoIAAAA2JoML/hAJgESZQOv7qHA4HjxwM9wgADwIgOAGIiF +4A/0z3ABAKCGugrAAroMT/QIcc9wgAAgYToOwADRwOB+4HjxwL4Kj+4IdxpxOnLPdoAA8CIDhs91 +gAAUQBSQELjyCG/2AqWA4MogIiDPcIAAMAoAgIDgCvSFIQgkTyFAJ5+47HEAoexw4KADhgiAUSAA +gATyAoWBuAKlz3CAAJgJAIiA4AX0AoWDuAKlz3CgACwgEIDPc4AAnEFyHRgQSiTAcADYqCAABs9x +gABwCSCJgOEM2soiIQBEKL4Dz3GAACjvJ3IzIYIAQCMBAxlhAeBAqUAlDhK6DG/xyXBMIACgB/Ii +hQDYgLkipQPwiiD/D89xgAAwCiCBZxUPFoDhaBUEFhP0ANsH8OxyIKIEeQQeUBAB44wjgoAghrf3 +z3KgANQLLaIkeACmZx3YE2gdGBEA2A0Cr+7cHQAQJQbv/wDY4HjxwM9ygACcCQKCJYiA4QHYBvII +2QoL7/Yrogjwz3GAAGgpng1v7wCh0cDgfvHAegmv7thwPgggAADdyWiA5pb2+HCpdzImgAOw4Ir2 +ueAI9l4Oj/Iybzh4BX0B50InRwBMJwCAYb4w96UBr+6pcOB4CHID8AHgIIiA4f714H9CePHAKgmP +7s91oAD8RB2FOYVGCiADAN4A2J64AaXgeMGlxaV1AY/u4HjPcaqqu7vPcJ8AuP82oDagNqA2oM9x +oADIOw6BiLgOoWkgQAD+8eB48cDPcIAA8CIDgBiIhOAO9AohwA/rcoogDA6KI4UKSiQAACUHr++4 +c4ogCgtCC6/2iiFFC9oPL/ED2M9wgADoyAAQBABMJACAC/QKIcAP63KKIEwOiiMFDO0Gr++4c89w +gAD0IACQgeAB2MB4DLjXcAAAABAS9M9woAAsIBCAz3GAAOQ4AqEC2AOhz3EBAGR06g0v/wHYCPCK +IAoL0gqv9oohhQ7RwOB+8cAqCI/uz3WAAFjJL4VKIAAggOHKIcEPyiLBB8oggQ8AAL4hyiOBDwAA +SADKJAEEbAah78olwQDPcIAA9iBAiM9wgAAQsWB5SKA8HQAUGg8v8QLYOQCP7vHA2g9P7i4L4AAI +dYDgz3GgAMgfRYUN8m4RDgYCgGSFxHpFe24Z2AAihQChCvBuEQAGRHhuGRgAHNgYuBUZGIAFAI/u +gOAB2cB5z3CAACBD4H8goPHAgg9P7s9wgACwLiCAosFgeQTYgOCoAgEAz3GAADghAIEB4IHgAKEJ +9AHZz3CgAMgcMaDaD+ACKHAqCy/4BdjPdYAAeDwOpc9xgAA4IQCBAeCB4AChCvQB2c9woADIHDGg +rg/gAihwA9hWDm/vqXEE2E4Ob+8ibQXYRg5v7yRtCtg+Dm/vJm0P2DYOb+9AJQESNtgqDm/vQCWB +EjfYIg5v70AlARM42BYOb+9AJYETz3enABRICIfPcacAmEcEpQ2Hz3KrAKD/BaUOh892oADsJwal +HIEHpReHCKUWhwmlGIILpRmCDKUagg2lz3ADAMYDBqbG2JC4BqbPcCwAAgEGps9wWQBCAQamiiCK +AAamz3BAAIcNBqbPcNEAwg0Gps9wwAAHDgamz3CAADghAIDPcoAAOCFCIECAAKIG9M9yoADIHADY +EaIB2AinANgNpw6nz3BQAP8AHKEA2BenFqf82c9wqwCg/zigfNk5oBqAz3GrAKD/gLgaoc9wKgAC +Dgami3BCDCAAgcEAwc9wgACIoTWlMqABwS+gz3AaAAIOBqaLcCIMIACBwQDBz3CAAIihNqUzoAHB +MKDPcCYAAg4GpotwAgwgAIHBAMHPcIAAiKE0oDelAcExoM9wgAA4IQCAAeCB4M9xgAA4IQChCfTP +caAAyBwB2BGhFg7AAgGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAGpgSVELiFII8ABqYFlRC4 +BSCADwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbPcIAAOCEAgM9xgAA4IUIgQIAA +oQb0z3GgAMgcANgRoQSFK4UIpwWFDacGhQ6nCIUXpwmFFqfPcKsAoP84oCyFOaAthTqgzg3v9w6F +z3CAADghz3GAADghAIBCIECAAKEG9M9xoADIHADYEaEtBW/uosDgePHAwgxP7n4IAADPdoAAHGNm +CG/1AIYIdQCGEHUK8gIMb/qpcHYLr/qgpooM7/ER2AYIj/TPcKAALCAwgM9wgAAsCu0Eb+4goPHA +ug/v/6HBz3CAAChDAIAE2WLaHttAwItwIg7v/hi7ocDRwOB+4HjxwIYLL/EW2ADY0cDgfuB48cA+ +DG/uB9gWCA/4CHfPcKAAtA/cgPYLL/8A2M9xoAAsIDCBsg5v9oogkQW+Do/6z3WAAChDTgrv+gCl +QIXPcYAACGMAoc9xgACIQUqhfgmv+wuhtgsv/894xgzv9+lwz3CAAAghAIiB4CL0QIWKIEQEz3WA +APggI4UaYjhgEHIB2MIgBQCA4AvyiiARC0oOb/YA2boKb/IE2ACFBfCiCm/yBNgChcoOoAIDpfkD +T+7xwM9wgAAgQwCAgOAd9IYML/cW2IDgGfTPcIAAsC4ggGB5BNiA4BHyz3CAAJwuYIDPcQIA4DQL +2GB7BNrCCy/xFtjRwOB+z3GAAPAiAIHEEAAGUSBAgQj0AYHEEAAGUSBAgQnyHgvv8RPYGgvv8RHY +6fHp8fHAz3CAAEgcAIDPcYAALAobeO4Nr/IggYDgCfIB2c9wgAAIIWoP7/8gqNHA4H7gePHA6gpP +7gh3fdgNuM9xgAB458WBcgxv7slxjCACgM9xgABMHADdh/cdeIwgAoAB5Xz3AChCAwUqvgPPcoAA +SBwWuAChgOfPcYAAJEMAGkAOA/T/2ACpAImMIMOPYA6B//ECT+7xwHIKT+46cHpxSHdodgokACEA +2s9xqwCg/1mhB9gaoVih8grgAgHYGdnPcKcAmEc6oJYIL/se2M9ypwAUSB2CvoJsEhAAcBISAACn +oKb3uMUggg8A/wAA0yDhBfe9xSWCHwD/AADTJeEV3g9v9IohEAAIdqlw0g9v9IohEAAIdUAoACLC +D2/0iiEIAAh3QCoAIrYPb/SKIQgA0XkZ4Sx5L3GxehniTHovcjB3ABmAIwAbQCOD9gDYBPBQcH32 +AdgFAm/uABwCIPHAwglP7gh1KHZCCuACCtgB2M9xpwCYRxqhMgrgAgrYz3CmAJw/ZBAEAFEkAIDK +IcEPyiLBB8oggQ8AAL8ZyiOBDwAAuADoB2HvyiUhAM9wpwAUSCyAHYAApve4xSCCDwD/AADTIOEF +xQFv7gCl4HjxwEoJT+7PcoAAqLDEgowmw5898v/ZJKLAoIQuCBkAIY1/gABMrASNCiBALoDgAd8S +9AKFz3GAAOwplgwv8CCBCHHPcIAASCEEgACAIgvAAIDgBPQB2Bzwz3CAAGwpIo3AqCGoz3GgALAf ++aHPcYAASCEwgSCBAN0hoBYKr/bpcAAggC+AAGyuoKgA2CEBT+7xwM9wgABIIQSAz3GfALj/AIDV +uBahLg3P/s9xoADQGxOBkLgcoVoIL/8A2NHA4H7xwOHFCHXPcIAASCEEgCCAiiDJCxILb/Y2uYog +yQsKC2/2IoWiD+/wBtjuCI/7z3CAAPAiA4AYiITgDvQKIcAP63KKIAwPiiMGC0okAACxBm/vuHPP +cYAAdDgJgYTgRPcB4Amhz3GAAHjnBoFGIEABBqHPdYAAoAoAhYLgEPSKIEkFpgpv9oohRg8ghYog +Rg+KD6/4BNoWCe/4BNhpAE/u8cDhxQh1z3CAAEghBIAggIogCQxyCm/2NrmKIAkMagpv9iKFz3GA +AOQ4CYEB4Amhz3GAAHjnBoGCuAahz3CAABw9A4iA4Av0iiCQDjoKb/aKIccF5gtv/gLYiiDJAyoK +b/aKIYcG+g/v8AbY+QcP7vHA4cUIdf/Zz3CAACSsIKhvIEMAig9v7wHZz3CAAEghJIAggfIJb/aK +IMwNBoUDgEKFIICKIIgA3glv9kJ5uQcP7uB4LQev8RHY4HjxwOHFCHXPcIAASCEEgCCAiiCJDLYJ +b/Y2uYogiQyuCW/2IoXPcIAA8CIDgBgQhABMJACBDPQKIcAP63KKIEwPiiNHCl0Fb+9KJQAAz3Cg +ACwgMIDPcIAAUFxCCqAAliFBDwfY6g/v8AbZz3CAAFjJDICA4Bfyz3CAAPQgAJCB4AHYwHgMuNdw +AAAAEAv0iiDJAzoJb/aKIQcO9gogAADYJ/AaD0/7z3CAAOgXAICA4B30z3GAAHjnBoFGIEABBqHP +dYAAoAoAhYLgEfSKIEkF+ghv9oohiAQghYogiATiDa/4BNpqD6/4BNjOD8/4vQYP7uB48cDhxQh1 +z3CAAEghBIAggIogyQzCCG/2NrmKIMkMughv9iKFz3CAAHhgAIBCIACAyiBiAIDgCPTPcYAA5DgJ +gQHgCaHPcYAAeOcGgYK4BqFeDu/wBtjPcIAAWMkMgIDgF/LPcIAAXDUCgIDgEfLPcIAA9CAAkIHg +AdjAeAy413AAAAAQBfTaCiAAANgQ8M9wgAAcPQOIgOAK9IogkA46CG/2iiFID+YJb/4C2AkGD+7g +fuB48cCODQ/uosGA4MohgQ+t3q3eB/ImgCOBIIECgAJ5Bghv9oogTw3PdYAAmCEBhYHgDPSKIE8N +7g8v9oohhgoA2MIKb/UBpVPw3gpP9YHgAdjAeC8mB5AP8oogDw3GDy/2iiHGDQHYugzv7walWg5v +9QLYtgpP9YLgDfIKIcAP63KKIN8FiiMHAIokww9tA2/vuHNyCk/1z3CAAHjnBZCA4EoADAAKhQjZ +QcALhZTaHttAwItwmg6v/hi7iiCPDmYPL/aKIQcEiiCPDloPL/YrhYogjw5ODy/2KoWA5gX0QgzP +7wHYB6UA2AulEQUv7qLA8cDhxQh1BoADgEKFIICKIA8LIg8v9kJ5z3CAAHjnBZCA4MX2Jg1P9QPw +4gxP9Q4IIACpcN0ED+7xwGYML+6KIA8K8g4v9oohhQgCCu/1AN6A4M91gACYIQ30iiDPDtYOL/aK +IcUJAdgBpaoO7//JcD/wC8gEIIAP/v//AwsaGDALyIe4CxoYMAvIkLgLGhgwUghP7soNz/VyDO/w +C9jPcIAASCEQgCSFAIDHcQAAABQieNdwAIAAAEj3iiAPCnYOL/aKIQUPw6VuCW/1wqWA4AQNYfXK +IGEAz3CAAHjnBZCA4MogiQ8AAEAAAA4J+B0ED+7gePHA4cUIdc9wgABIIQSAIICKIAkOKg4v9ja5 +iiAJDiIOL/Yihc9wgADwIgOAGIiE4A30CiHAD+tyiiDMD4ojygVKJAAA0QFv77hzz3CgACwgMIDP +cIAAUFy2DmAAliFBDwfYYgzv8AbZz3WAAKAKAIWC4BH0iiBJBcYNL/aKIQoIIIWKIAoIrgqv+ATa +Ngyv+ATYiiDKAaoNL/aKIcoIAdnPcIAAXDUioM9xgAB45waBRiBAAXoLb/sGoXIMz/hhAw/u4Hjx +wOHFCHXPcIAASCEEgCCAiiBJDmYNL/Y2uYogSQ5eDS/2IoXPcIAA8CIDgBiIhOAN9AohwA/rcoog +DQ+KI4oPSiQAAA0Bb++4c89xgAB45wTYBqGKIMoBIg0v9oohywHPcIAAXDUB2SKgz3CAABw9A4iA +4Ar0iiCQDgINL/aKIYsCrg4v/gLYygrv8AbYxgrv8AjYxQIP7vHAz3CAAFBcNg1AAAjYWgvv8AbZ +0cDgfvHAogrv8BPYz3CAAEghBIAggM9wgACIFSCg0cDgfuB4CHIA2E0DL/UQ2eB4CHIB2EEDL/Ug +2eB4CHIC2DUDL/VA2eB4CHFJAy/1ANgIcUEDL/UB2AhxOQMv9QLYOQQP7/HA4cUIdc9wgABIIQSA +IICKIEkNVgwv9ja5iiBJDU4ML/Yihc9wgADwIgOAGBCEAEwkAIEM9AohwA/rcoogjA+KIwkD/Qcv +70olAADPcKAALCAwgM9wgABQXOIMYACWIUEPB9iKCu/wBtnPcYAAeOcGgUYgQAEGoc91gACgCgCF +guAR9IogSQXiCy/2iiGJByCFiiCJB8oIr/gE2lIKr/gE2LYKz/ilAQ/u4HjxwOHFCHXPcIAASCEE +gCCAiiCJDaoLL/Y2uYogiQ2iCy/2IoXPcYAAeOcGgYK4BqHPcIAAHD0DiIDgC/SKIJAOfgsv9ooh +CQ0qDS/+AthKCe/wBthJAQ/u8cA+Ce/wFNiiDQ/v0cDgfvHAz3GAAOwKiiALBkoLL/YggR4J7/AU +2PYKL/gE2NHA4H7geCEBT/vxwM9wgAAcPQOIgOAK9IogkA4eCy/2iiHNAcoML/4C2NHA4H7hAO/w +GNjgePHA/9nPcIAAJEM2DG//IKhCDY//0cDgfvHATggP7s91gABkKQAVEBCMIMOvCPKKIAwN0gov +9oohhwIi8IDgE/TPcIAALLBoEAQACiHAD+tyz3AAAIcMiiPHA4EGL+8KJQAECHGCIQgAz3CAAEys +DiBAALYJL+6KIQgJGnDPcIAASLQTEAKGjCLDj//ZBfIcGBiEIKUL8BMYGIQgpQDZz3CAAJwJJKBO +CE/2IQAP7uB4AdnPcIAAnAkkoDkAT/bgePHArg/P7c9wgACsYQaAz3WAANAuI4AggSoKL/aKIJUL +Atg+C6/vAaWC4BTyMguP74DgEPIqC4/vCHEKCi/2iiAVCh4Lj+8VJQEQFIEB4BShz3CAADgmLJDP +doAA8CIelhBxGfILyAQggA/////DCxoYMAvIh7gLGhgwegsP7gCGxBAABlEgQIEF8gCF67gD2ALy +Bdg6DY/vANhiCS/4jLh5B8/t8cDhxc9wgAA4JgiIh+At9M9wgADwIgGAHtnAEAMGgOMvKMEAAiEC +ABLyjuIJ8hJqFnjPdYAAH98IZYDgCvIQI4OALyjBAAIhAgDx9QHYA/AA2IDgGfLeDo/1gOBUCSIA +yiAiABHwKguP9c9ygADQLiCCobmA4K65IKIH8hILj/WA4PALwfT5Bs/t4HjxwOHFz3CAAMwvSIgq +iEQqPgsAIYB/gABcLzV4BojPdYAA0C6B4BT0z3GAAPAiAIHIEAAGhiB/jgr0AYHIEAAGhiB/jowO +4f/KICEAAIWquKEG7+0ApeB48cAaDs/tCHXPd4AAzDBw3AInARMieMoP7+0c2Qh2QicAHjRuACGR +D4AA0C5cEQEmQoVELj4XJ3BSCWAAWWEAJoAfgAAgMDiIgOEacNX2jCHDj0X2YbkveTiogOHN9nDc +AicAE10RASZChUQuPhcncBoJYABZYTYKj/WA4AHaGhiCIAfyJgqP9YDgBAvB9O0Fz+3gePHA4cXP +cYAAlDAieD4P7+0c2QYKr/UIdQAlgR+AADowgOAA2kCpB/TuCY/1gODgCsL01QXP7eB48cBSDc/t +z3CAAKxhBoAjgCCB3g/v9Yog1QvyCI/vgeAV8uoIj++A4BHy4giP7whxvg/v9Yog1QjSCI/vz3GA +ANAuFXkLgQHgC6HPcIAA0C4ggM9wgAA4JkyQz3CAAPAi8LkekA/yEHIK9AQhvo8AADgQBvRODI/1 +gOC78koJ7+4B2M9wgAA4JiyQz3CAAPAiHpAQcQr0z3CAANAuAIAEIL6PAAA4EATyAd8D8ADfz3CA +AJBhjggv8ulxz3CAADgmCIiI4BD0AN0C3kQtPhcAIYB/gACUMG4IL/LpcWG+gOYB5TX3+giP9Rpw +z3CAADgmLJDPcIAA8CIekBBxDfTPcIAA0C4AgAQgvo8AADgQBfRMIACgPvQLyAQggA////8rCxoY +MAvIh7gLGhgwcggP7s9wgAA4JgiIh+As9M9wgADwIgGAwBAPBoDnLyjBA04gjgcg8o7mF/KybrZ9 +x3WAABDfBZWA4M/2BpVRIECACfK6CS/vz3iWCoACBdgSrQDYBbUQJ4+TLyjBA04gjgfk9c9wgAA4 +JgiIiOAo9M9wgAA4JiyQz3CAAPAiHpAQcQv0z3CAANAuAIAEIL6PAAA4EBTyz3CAAPAiAYDEEAAG +USBAgcwgIqAK8s9wgADQLgCAUSAAgAfYA/IG2JIJj+/JA8/t4HjxwM9xgADQLvwRAgCD4kQADQAz +JoJwgABcaEAngHJUeAB4HYEB4B2hBdgS8B6BAeAeoQLYDPAfgQHgH6EG2AjwgBEAAAHggBkAAAHY +OgmP79HA4H7xwAoLz+0Ids9wgACMFQ+AgOAQ8s9ynwC4/x2iz3GAACAhBIEB4LO4tbi4uAShFqLP +cIAAkGEGgM91gADQLiOAIIFmDe/1iiAVC89wgAA4JgiIh+DuAQIAgOZR8vgVABCA4OKGE/T2FYAQ +gOAP9gohwA/rcs9wAAC/G4ojCAZKJAAA/QAv7wolAAFhuOIN7+74HQAQYg3v7ulwz3CAAJgKAID4 +FQEQIqj4FQAQgOAn9JIJj/WA4BHydgiAAoogFQTmDO/1iiFIDM9wgACYCiCABImAuASpz3CAAMwv +SIgqiEQqPgsAIYB/gABcLzV4BoiB4MgNIfDKIMEDAIXwuIAOou7KIGIAvg1P74HgFPK2DU/vCHGS +DO/1iiAVCaYNT+8VJQEQAoEB4AKhAIWHuO8BIAAApYDmBfIAhae4AKULyJC4CxoYMBIO7+1KIAAg +z3OgAJAjHINRIMCAEPRwEwQACiHAD+tyz3AAAOUbiiNJCQ0AL+8KJQAE+g6P+BYOT/7PcaAA0BsT +gZC4HKHPcIAAICEAgO+4B/LPcJ8AuP90GAAEz3CAAJgKIIACiYDgt/QEiVEgAIA/8ooglQTqC+/1 +iiHJDc9woABILuuAz3agADgu078HhuR4RR0YEIogFQzGC+/16XGKIBUMvgvv9UUVARYHhuZ4B6Ya +CqACENgAhc9xAADwH5C4AKUHhoi4B6amCa/2DdgLyAQggA/+//8DCxoYMAvIjriQuAsaGDAqDc/t +z3CAAJgKIIAEiaC4BKlt8PgVABCA4OKGDvT2FYAQgOAK9gohwA/rcm/YBriKI4oID/FhuAoM7+74 +HQAQz3CAAPAiAYDEEAAGUSBAgQny+BUAEIDgwAuh88ogwQPPdoAAzDBoFoCQgOAj8moWgJBRIMCB +HfLyDE/1ahaBkBpwAIXGuQq5gbgApc9wgABYYbYLIAD5YUwgAKAL9MoMT/WA4AfyAIWOuLYNr/QA +pboMT/WA4AbyVRUAFgHgVR0YEPgVABCA4BP0CBaAkAoWgZBEKD4LACGAf4AAXC81eAaIgeCoCyHw +yiDBA1UAz+3gePHA7g+P7Qh3z3CAAKxhBoAjgCCBcgrv9Yog1QrPcIAAjBUPgIDgAN0P8s9ynwC4 +/x2iz3GAACAhBIEB4LO4tbi4uAShFqIih89wgADQLs92gADML0AYWAAIjs9xgABfL0QoPgsyIUQO +So5CJEEAUHHI9kAiRQAvJUcBCh5CEQXwqq5KJQAARCg+CwAhgH+AAEgvFSBCAUySgOIO9LBxyfZA +JUUALyVHAQoeQhEE8KquSiUAABUgQAEMkIDgyiLMB8ogjA8AAOYbyiOMDwAA5QOMBezuyiHMD5IK +z+4IjiqORCg+CwAhgH+AAFwvNXgmiIDh6XAE9M4OQAIE8KYMQALPcIAAICEAgO+4BvLPcJ8AuP+9 +oEEHj+3xwOHFAN3mDu/1qXDSDW/vqXA+D0/wHg5P789wgADQFy0Hr+2goOB48cBuDg/1+g4P9d4N +D/XRwOB+4Hjhxc9yoADIH6QSAwDPcYAAnAkNgRBzwiMGAET3YngTe7+CDoG7Y3hgDqEB2EoaGADg +f8HFz3KgACwgZoLPcYAAnAkOgWJ4DqEQgu0HL/MNofHASg6v7UokQADAgaCAAd/RdcIkAgHRdaGB +YYDCJ84TAd6xc8B+sXMB28IjzgBMJACAzCYikMojYgAL9IDjBvSA5swnIpAE8gLbA/AA24DjFPKB +4w7yguMa9KCAwIEBgCGBAiWNk6CiAyBAAAGiEPAA2ACiAaIM8KCBwIAhgQGAAiWNk6CiAyEBACGi +JQav7Whw4HjxwOHFJoBAgEIiAoDKImIAgOLKIcIPyiLCB8oggg8AADYRyiOCDwAAdwDKJCIA+APi +7solAgFggTBzCvJCgKKDQn2A5QT2YIMwc/r1QYMBo2CgQaAAokSApoBRIkCAQCUDFgvyRoWA4gby +ooJCgEJ9gOXD9gCjRICmgFEiwIBAJQMXC/JHhYDiBvKigkKAQn2A5cP2AKNBgFBxBfRGDS//BoCN +BY/t4HjxwA4Nj+0IdgCAQiABgMohYgCA4QDYKPImhkGGAd8wciCGQYZBoSCiAKbPcK3eAgABpqaG +wH8GhRB2B/SpcFoIIAAC2QalpoYHhRB2BvSpcEYIIAAI2QelgOcF8t4ML/8GhgHYEQWP7SCAEHHK +ISEA4H8ocPHAmgyP7Qh1hg/v/yh2CHfCpdYO7/+pcOkEr+3pcOB4QIAQcgjyZIILI0CABfRAghBy ++/UA2uB/SHDgeM9yoADIH/QSAAC82xi7BCCAD///APD0GgAAC8hleAsaGDAVGtiAz3OAAEghCIMA +2SCgDIMgoAmDIKANgyCgCoMgoA6DIKALgyCgD4MgoM9wAAwPAKQaQAAOog/YDLgQouB+4HjxwP4L +j+3PdaAA0BvThfq+BvLPcIAA+GFKCQAA+74H8s9wgAAYYj4JAAD8vgbyz3CAADhiLgkAAP2+B/LP +cIAAWGIiCQAA/74G8s9wgADYYRIJAAC82Bi4E6URBI/t4HjxwJoLr+0A2wh3z3agAMgfpBYAEM91 +gABIIfhgpB4AEAHYE6YohQyFQIEAgAAiwoNAoSyFASDAAAChAtgTpimFTYUAgUCCACDAgwChDYUB +IsIAQKAE2BOmKoUOhUCBAIAAIsKDQKEuhQEgwAAAoQjYE6YrhQ+FQIEAgAAiwoNAoS+FASDAAACh +BIUAgNIOL/DpcSSFAKEFhQCAxg4v8OlxJYUAoQaFAIC2Di/w6XEmhQChB4UAgKoOL/DpcSeFAKEP +2Jq4DqYP2Ay4EKbPcIAA2GH2Cg//z3WAAPhh6gov/6lw5gov/0AlABjeCi//ViUAEtYKL/9WJQAT +CQOP7eB48cCaCo/tCHcg8ACGIYYhoAChANgAps9wrd4CAAGmpoYGhRB2BvSpcPoN7/8C2QalpoYH +hRB2B/SpcOoN7/8I2QelI4Zgeclwrg3v/+lwCiYAkAnyA4cggAKGIniA4K4HzP9mCi//6XCZAo/t +D9iauM9xoACwHxWhD9gMuBeh4H7xwA4Kj+3PcoAAVMs/gjpw67mqwQDYEPLPc4AA8CJjg3SDSBKB +AMDdZHmGIf8OIrk6fQTwFN0C2IoSAQECeRKCBOEeCm/zANquCWAAAiBOAwPYz3GgAMgfE6HPdYAA +SCEIhQCAQsAMhQCAQ8AJhQCARMANhQCARcAEheCABYUAEBIAQBEABh5m/BEAAM9wgAA0sQDZQIAB +gAAigoMBIEAAQMJMIUCgQcCLdg70Gg0P74TBGnDJcB4L7/+Gwgh2CBABIQzwgsHJcAoL7/+Gwgh2 +z3CAAHjnJJDPcoAAeOdlggbCBLtQc0ApgAKI91BwS/cCelBwvvcG8M4MYACGwAhyRsKC5hX06XDW +DC/wSHEId0pwzgwv8AbBBsJacATDB8EFwAAiwoABIEAARMIW8IDmFfTpcNYML/BIcQh3SnDODC/w +BsEEw1pwBsEFwAfCAiNDgETDAyCAAEXAgeYL8s9wgADwIgOAGIiE4MwmIZAA2AL0AdgvIAegRvTp +cGIML/AD2Qh2SnBaDC/wA9kAwQh3AcBAIcGAQSAAAEHABMBAwQXBQCDAgEEhAQBEwEoIYABFwUwh +AKAK9ASFwKAIhQDBIKAMhQHBIKBMIYCgEfQEhcCgCIUAwSCgDIUBwSCgBYXgoAmFBMEgoA2FBcEg +oEwhQKAK9AWF4KAJhQDBIKANhQHBIKCKIAcOqgqv9QpxTCAAoAHZwHnPcIAAmCE0qE0Ar+2qwPHA +9g9P7aXBCHYCiyh1mHBkwACLABIGAREcAjB5cAISBwEEEggBEBQAMeSSBhIFAQAgyQMAkS8hSBIH +IEACCgkgABB4ACCKAQGVLyKIEgcggAL2CCAAEHgAIMYBApUvJogBByCAAeIIIAAQeAAgBwIDlS8n +yAEHIMABzgggABB4ACUFAASVLyVIAQcgQAG6CCAAEHgfZwWV8H/neKoIIAAQeCaVIXAQeAd5PHoP +uSV6UHoAIoECMHkAHEQwR5Unelx5D7pFeTB5ACGCAVB6XHkCHIQwD7pFeTB5ACHCAVB6XHkEHIQw +D7pFeTB5ACFCAVB6XHkGHIQwD7pFeTB5P2fwf/x5CBzEMw+/5XkweThgaXHGuYW5CLkFIcECILYQ +eCCVChwEMCd4HHgIuAUgAAEBtgDAAaYBwAKmAsADpiEHb+2lwA97SLgPeM9ygAAAePQiAABAKAEC +SLgFefQiwAAweeB/J3jgePHAz3KAAMhhIIKA4cohwQ/KIsEHyiCBDwAANBHKI4EPAADjBsokIQDU +BKHuyiUBAQGiAdrPcaAAyB9QoUoZmABIGRgA0cDgfs9wgADIYeB/AIDgeM9xgADIYSCBANiD4cwh +IoAC9AHY4H8PeAoiAIDxwBfy4g/P/4DgyiHBD8oiwQfKIIEPAAAzEcojgQ8AANwGyiQhAGgEoe7K +JQEBz3CAAMhhQKDRwOB+4HgIcyhyz3CAAEghBIAAgAIggA8AAgAASQAgAGhx4cVTIEIFBCCND8D/ +AADPcIAAeOcFgAIggwAEIYIPwP8AANW5Inile0V4EHPKIK0ABfcQcwDYyiBmAOB/wcXgePHA4cXY +cLhxug/v/5hyCHXIcLIP7/+IcRB1yiCtAAr3EHUA2MogRgGYD+b/yiEGAc0FT+0A2M9xgADoyAWh +BIGguAShsQUv8APY4Hg2uDa5MHDWIIUPAACAAOB/InjgePHAJg1P7QonAJDPdoAAeOfPdYAA+GEP +9M9wgADodclxHgyv/hTaogmv7qlwQCUAGBHwgucK9J4ID+/JcQIMr/4U2kAlABgM8MlwCghgAQXZ +qXB2CY/uz3CAANhhagmP7gSWCrgFpgaGhiDDDwamKgsgAOlwFg9P7hUFT+3xwKHBCHOyCW/0i3CC +4ADYBvIAwBBzAdjCIA4AocDRwOB+4HjxwADZz3CAABAuGgggACCgz3CAABhcZg+P/9HA4H7geADZ +z3KAAHAKI6IkoiWiJqInoiKiz3CAANRhIKDPcIAAeGIgoDGyMLLPcIAA0DrgfyCg4HjxwM9xgAAQ +LgCBgOAZ9AHYAKEA2c9wgACIFbYP7/8goIoghw6mDm/1iiGPB89wgAAMIxCIg+BsCSEAyiBhAdHA +4H7gePHA7gtv7Yogxw+kwXoOb/WKIdICcgoP9YDgsAkCAM9wgACIFQCAz3GAANA6ig7v/yCBz3aA +AHAKMJZRlllhMHAA3cT3AiBNAAKGgOAV9IDlE/LPcYAAeGIAgbhgAKHPcYAA1GEAgbhgAKHPcYAA +kEASgbhgEqHPcIAASAkAgIHgAN8G9M9wgADUYeCgiiAIAM9xgAB4YvINb/Uggc9wgADUYQCAQsVA +wM9wgAB4YgCAi3VBwAKGENmi2h7bQ8CpcPIM7/0YuwDYdg3v9qlxz3CAAIgVIIDPcIAA0DripvG2 +IKDwts9wgABICeCgOgov8BPYz3CAAHhiAICF4I33YgggAAHYTgpP+c9xgACIQR2BAeAdoQTwSggg +AAXYOQNv7aTA4HgV2ADaz3GgAMgfbxkYAODYkLgQoQnYsBkAALQZAAB42EIZGAAA2Jq4D6GkGYAA +z3AADAAZDqHgfs9ygAAYXCaCI4FhuGCBz3GAAIgVIIHVuXlhz3OAAHjnZYMFKz4AJ3HHcQAAABDN +Ba//SHDxwOHFz3WAAHAKB4WA4BT0z3CAABAuAICB4A70JgsP9prgCvLPcIAASCEEgACABaUB2Ael +oQJP7fHA4cXPdYAAcAoHhYDgGvLPcIAAEC4AgIHgFPTuCg/2muAQ8s9wgABIIQSAAIAGpb4M7/8l +hTCVOGAQtQDYB6VdAk/tz3CAABAuAICB4Av0z3CAAEghBIAggM9wgABwCiOg4H7xwM9wgAAQLgCA +geAQ9M9wgABIIQSAz3KAAHAKAIAEomoM7/8jgjGSOGARstHA4H7xwIoJb+2KIQgACHXPcKAAyB8w +oAHZQRhYAFYJAADPdoAAeOcDhiWG1bgwcMohzQ/KIs0HyiCNDwAANRHKI40PAACbAMokLQC4B23u +yiUNAe4Mz+7eDO/uCHcacIDlzCVikEr0z3WAAEghCIUghiCgDIUhhiCgAIUlhiCgBIUjhiCgbggP +9YDgcPLPcIAAOCYIiIfgavQFhcCAAIAEJo4fwP8AAFMgUQUEhQCA1gzv7wpx1bhFhQV+AtvAos9y +oADIH3OiyYUCIEGEYIZNhUCCCgAEAEIpwAcH8CSXCrkCIUEEGWEA2AIjQ4ADIgEAYKYNhTvwguU6 +9ASXz3WAAEghIYUKuAChz3CAAPAiAIDEEAAGUSBAgQmFIPLPcYAAOCYoiYfhGvTPcaAAyB8B2lOh +KIUA2yCBTIUCIQGEQIIgoA2FAyLCAECgBIUAgDYM7+8KcSWFAKEK8CCHIKANhSGHIKAjhgWFIKCB +AE/tANmWuc9woADQGzOg4HhRI4DF//PgfuB4z3CAAPhhJ4CA4QfyA4BAgAKBQngE8M9w/w///+B+ +4HjPcYAA8CIkgSiBBCG+jwAGAAChwQX0USEAgAj0CPAEIL6PAAAAGATyANgD8AHYz3GmAKQAF6Hg +f6HA4HjxwLIPD+3PdqAAtEcIdQbwIgwv9YogiQxxFgCWBCCAD3AAAABBKD6F9PWKIP8Pbx4YkGse +GJAD2A+4z3KgAMgfExoYgAWFz3OAAOI6WR4YkAaFIJNaHhiQB4Uod1seGJAJhYYn+x9YHhiQCIWM +JwSQAd/AfwQghQ8ABwAAQS0FBi8mx/PKIeEBwCmhAiPy7bkG9AQhgQ/////DMHmFEg+Ghif/HkEv +hBBEJY8AgudKJUAAwiVCAQUlDwEKv+V5MH8EIYEPAAAAPIy/jLmNv4254LMleFceGJBAEgAGCIXP +cYAADGMggQQggA8AAACAUSEAgAf0gOAG2Mog4QEC8ADYz3GAAPAiI4EogVEhAIDPcYAAqAgQ8k8g +AgKNupe6RqEFIIIPgABAOkehBSCAD4AAwFMQ8AUggg+AAMAkRqEFIIIPgAAAPkehBSCAD4AAgFcI +oYQWAJYJoQaFkgsv8SGFZg7v/wGFtQYP7eB48cA+Dg/tOnDPd4AAXD8Mj4Yg/wFCKNAAz3agALRH +CnUF8KYKL/WKIIkMcRYAlgQggA9wAAAAQSg+hfX1QxYAlkYgAA1DHhiQVxYAlgQggA//b//DVx4Y +kF8WAJYEIIAP/3//w18eGJAA2J64Ux4YkOB4ANhTHhiQDI9gHhiQ6gzP+s9wgACwLiCAYHkE2IDg +FfJMIUCgDA0h+cogQQPPd4AAFGMAjxB1CfLPcIAAODI2gGB5ANgAHwIUwgkP70MWAJZMIQCgRSAA +DZ+4Qx4YkIjyTCFAoBLyTCGAoFPyCiHAD+tyiiBaCoojjQJKJAAAxQNv7golQATPcIAA4DogkChw +hiD7D4wgBIAB2MB4geAP9M9woADAHQeABCGBDwAAADyGIP8OIrgKuCV4A/AH2Aq4z3GAAPAiI4EQ +vZu9MiGBDwAA2AKfvYDhAdnAeQ+5JX2leF8eGJAF8G4JL/WKIIkMcRYAlgQggA9wAAAAQSg+hfX1 +iiD/D28eGJBrHhiQMPDPcIAA4DogkChwhiD7D4wgBIAB2MB4geAQ9M9woADAHQeABCGBDwAAADyG +IP8OIrgKuCV4BPAH2Aq4z3GAAPAiI4EQvTIhgQ8AANgCn72A4QHZwHkPuaV5JXhfHhiQBsiE4NAM +4e/KIKEEsQQP7fHAWgwP7Qh1KHbqDS/tAYCghRC5QS0AFDhg2g0v7clxELmweDhgzg0v7UAugRKZ +BC/tKHDxwBoMD+2F4TpwGnGM9wohwA/rcoog2guw2wokAAR1Am/uuHNMIcCgjPcKIcAP63KKIBoL +stsKJEAEWQJv7rhzz3CAAPAICHXmaBQlTRQAlVEgAIIM8gAVBBEKIcAP63KKIFoLt9stAm/uuHMA +goHgBPRvIEMAA/AA2Jq4IYKeuNCKgeEB2cB5G7klfgV+AoIxioHgAdjAeBy4CLkleAV+A4IyioHg +AdjAeB24ELkleAV+iiAZCwYOL/XJcQDYIncAry8gBwSIuAC1z3CgAOBEFSBABMCgpQMP7eB48cBK +Cy/tBNkA2M91oAC0R0sdGJAA2pC6dx2YkAHadx2YkM9yoACERBiiANqRuncdmJAC2ncdmJDPcqAA +iEQYogDYkrh3HRiQdx1YkIDYdx0YkADYnrhUHRiQANicuFQdGJDPdoAA/AjJcI4J7+4c2c9wgADw +CIIJ7+4K2clwIR0YkM9wgAB8BxB4SR0YkCkDD+3gePwcCLSF4PHAGnCN9wohwA/rcoog2gt32wok +AAQFAW/uuHOKIBkKJg0v9Qpxz3OAAPwIJINocDR4IJBRIQCCDvIQEwQAABAFAQohwA/rcoog2grR +AG/uftskgwHhiOEkowDaA/REoy8hBwSFIQwAILCQ2c9woAD8RBi5IqALkwHgEHgLs9HA4H8EFBA0 +gODxwAf0z3CAAKSqygjv7iTZ0cDgfuB48cASCg/tqgugAQh2PgrAAM9xoADIHwh1QNgPoUARAQYw +eYoL7/XJcFUCL+2pcOB48cDeCS/tSiQAcs9woACIIADeqCCAD4fmOfKggM9xgACwyc9ygAB459Z5 +aIlHgnpigOXPc4AAfMrUex70ACaNH4AAdMr4jYLnCPTgk/t/I5GAvyR/4LMG8IHnBPQikSCzANk4 +rc91oADIHPqFIJPkeSyzBfAskzB1w/dZYQPwrLO5Yokhzw8EGFAAAeYA2c9wgAB457EBL+0noOB4 +8cAAFgRABxoYMQAWBUABGlgxBBKBMJzhyiLCB8oggg8AANwOyiOCDwAA9AqEByLuyiHCDzoM4AAO +2dHA4H7gePHA/ggP7RpwDcjPd4AApMrwJwEQz3WAAATKAxICNggYRCABkoDgDRIBNgDeDvIUJUMQ +gBMOB4DmafIA3oAbnAPwG4QD4BuEAxQlQxDAswGC7rgf9Miz0BuEAxCKz3GAABDfArgWeBthZZOA +4zhg0fZhu2WwEIpyaHZ7emFFkoDieWEH9CaRUSFAgEwOAu4NyAAggQ+AACDKxKnMqdSpz3GAALDJ +FnkUfSKRwB2EExV/eB1EEAMSATbApwGBBCCADwAAAGDXcAAAACAT9BCJz3GAABDfArgWeABh7bjK +JmIQz3CAACAi1HggkBDhILAD2c9woAAUBDCgCgrgAQpw2diaCi/1ARIBNj3wcBINAeATAQECIU4D +sXYG98J9ongQeIAbHADPcKAA1AcPEA6GAN3wG4QDcBICAcAbRANCeTB54BtEANATAQEB4TB58BMF +AdAbRABTJX6AyiHCD8oiwgfKIOINyiOCDwAA5w3KJIIPAAD+APwFIu7PICIDA9kTGFiA4QfP7OB4 +8cByD+/sANjPcYAAoGIAoc9wgACMFQGAgOCjwQ/yz3KfALj/HaLPcYAAICEEgQHgs7i1uLi4BKEW +ogzMz3agANQHUSAAgAPYIB4YkKvyFB4YkAMSATYAFgRABxoYMQAWBUABGlgxBMqc4MoiwgfKIIIP +AADcDsojgg8AAPQKbAUi7sohwg8ocB4K4AAO2QMSATbPc4AAEN8Qic91gAAUGlMgwgCGIP4DRLjE +GQIAEmoWeFCpAGPPcoAA8CItuMC48CIAAASiuRACBs9wgACwyUCgDxYAlrQZBAAGyHIKr/MNEgI2 +A8jhgCIVgBAEJ48fAAAAEFMgEAABhVEgAIBK9EDZIKUOCS/1iiDTBoDnzCAhoDfyz3eAAOI6AJcv +JgfwCvSAuAC3z3EAEQEA5ggv9YogEwfPcKAAwB0HgIYg/w5BKIEAAJcPeoHiG/QEIIAP////woi4 +i7gKuSV4TyACAwQggQ8AAAA8TyEMA08kTJONukC3BfSLuIy4jbgAtyIVgBBTIAEAHHgHuSV4Ih0C +EAMSATaSEQABag8v+pQRAQAw8EokQAAUHhiRABYAQAcaGDAAFgVAARpYMQTKnODKIcIPyiLCB8og +4gnKI4IPAABmAhgEIu7PICIDA8i0EAABDx4YkMvYLggv9Q0SATYDEgI2lBIAAFEgQIIG8lYLz/UD +EgI2DRIDNs9wgAAEyhQgwQCokYDlIvTwis91gAAQ33V4Ar/2f+VlmBIPAC297qD2oM9wgAAgIsC9 +9CBDA7waxADQEQABBCODDwAA8P/DuGV40BkEAAbw0BEAAbwaBAAB2KAaAAAeDu/5sIqA4GQEIQAD +EgM2BshRIICBVAQCACGD+rkH8pDYkLhJBCAAoBsAAAK9z3CAABDfQCCCA7Z9rWLEE4IAsXIH8pHY +kLglBCAAoBsAAKqDz3KgACwgUIKMJf+fDPKietdyAIAAAEj3h9iQuP0DIACgGwAAUIvyavZ/5WAE +Jb6fAAAAE/hgWvLpvQjyi9iQuNkDIACgGwAA7L009CWQgOEb9AfIBCCADwDAAADXcADAAAAN9BHY +FLigGwAA4djuDu/0SHEDEgM2IPCI2JC4oBsAAOLY9fHWDu/049gDEgM2pBMAALS4pBsAAJITAAGn +uJIbBACeEwABp7ieGwQABvCF2JC4oBsAAM9wgADwIgOAGIiE4FQDAgDPcYAAmCEMgVCLDyCAAAyh +z3GAANQhAIEB4DkDIAAAoUKQMxOAABEiAIAn8gfIBCCADwDAAADXcADAAAAU9AiLgOAV9qQTAAC0 +uKQbAACSEwABp7iSGwQAnhMAAae4nhsEAAvwUSGAgQfyjdiQuOUCIACgGwAABshRIACAFAIBAG4L +j/8DEgM2CHKoGwAAz3CAAEghBICwEwcBIIBVJ0AG1bkQcc91gAB450T3BdgHpQWFIniMIAmGyiEl +AKQTAAAJIYEA8risG0AA6vKYE4EAw7kHyDx5BCCIDwEAAPANEgY2z3CAALDJFiCAAaWQrBMAAEEo +CBMJIE8DgBMAAX4TDQEdZc9wgADwIgSARhAAAR1lCCdPE6J/mBMNAOi9ANiG8kQlARYjuQQlgB8G +AAAAAeExuDhgz3GAAAB6MiEFAAQlhB/AAAAAQSyEBTIhAAFBLYESUiEBAMC5A7mgcBjhheDKIY0P +AQCJDdUhDgCkEwAA9Lgj8iJ/hBMBAQInQBBIIAAAQrhBLU8TwL8Ev/R/qXHGuUkhwQU0f+u9z3GA +ALBw8WEF8kEpDQEUJUEQBSk+AEEpAHIA3VfwQS+EEEEtTxPAvwS/9H+pcMa4SSDABRR/673PcIAA +sHDwYAXyQSgPARQnABAFKD4BQSkAcoQTDwHrvflhQS1PE8C/EOEEv0EphAD0f6lxxrlJIcEFNH/P +cYAAsHDxYQXyQSkNARQlQRAFKT4BQSkNch/wUSVAksolAhAZ9APnz3CAAIhw8CBBACK/BSn+Ay9w +UyANALhghBMNAR14J+UivQUpfgNTIQ1wJ3W9fc9xoADELK+hrqFAKA0Wnr1ALg8F5X2leMAbAAAK +oc9xgABIPgHYAKEI8M9woAAsIE+AsBMHAfByRvcF2Bi4oBsAAM9wgAAYCkGAIJMJIYEAAIiB4Af0 +GRYAlhBxANgC9wHYgOAM9APYGLigGwAAz3GAAAxBE4EB4BOhDcjPcoAAABmG4AHYIxKBAMB4geED +8gHYIPDPcYAAQBojiVEhAID5889xgAAIGiiJgeHz9YHgiiEzCMohgg///wz+z3CgACwgEIBMgkJ4 +gOBD9hBxIfYA2IDgDPRC2Ji4oBsAAM9xgAD8QgOBAeADoaATAAAEIL6PAQEAABn0khMAAZQTAQCQ +EwIBshMDAcYLoAFKJEAAAxICNqASAQAleKAaAADO2A4L7/QBEgE2AxIONqAWABAEIL6PAQEAAAby +ugnP81kGQAADzM9xnwC4/xihBshRIACAyiAhIHvypBYAEPK4M/LPcYAASD4AgYDgAN8z8gDYAKGA +FgARfhYPER9nz3CAAPAiBIBGEAABH2dRIYDF/vPPcKAAxCyrgN/Ykgrv9KlxUyWBFP69zCEigAny +mBYAECoIr/IA2nS4H2cC8ADfAxICNgjwDcjPcYAAsMkWeeWRyXJKIAAggOfPcaAAyB+sFgAQB/Sk +FgMQsbukHsAQA/AJIMADA9sYu2+h+BEDAIDnoWsIIEADYnigGQAAANiYuA6hC/KkEgAA8bgNzMUg +ogTPIGEADRocMAGSgOAK8g3Iz3GAAATL9CEAAIDgBfIBgu64BfINzIC4DRocMMzY3gnv9AYSATYK +CK/5A8gDEgI2PJJEIQADhOBt8g3Iz3OAAATKFHvAEwABJXghgu25HLIK8lQSAQG8Eg0Bw7mleVQa +RACGIP0MjCACghn0EIoCuBZ4x3CAABDfJZCA4dH2BpBRIECADfKB4Qj0YBIAAYS4YBoEAAXwHJKN +uByyAZKA4Cfy0BMAAVQSDQHDuAV9VBpEA4ATAAeA4AX0HJKKuByypBIDAOi7CfJoEgABUyXBEDhg +EHhoGgQAUSNAggnyahKAAMO9uGAPeGoaAgAHyM9xgAAUywQggA8AwAAA13AAwAAABPQOGQQEBfAA +2Iu4B7EBkoDgFPINyM9xgAAEyhR50BEAAVMgwIAK8vARAQHPcKAAmAM+oLYaRACkEgAABCC+jwAA +ADAH9IYg5Y+kD2IAyiCCACIIQAGA4A7yAg/P/APZz3CgABQEI6CKIBAA+QNgAAYaGDADyKQQAAAE +IL6PAAAAMEwCAQD0uAj0XgpP8tbYagjv9AYSATYDyKQQAQDsuaryWgjv9M3YGggv8AHYAxIBNh2x +z3CAAPAixIDKDW/2AN2B4Av0z3CAAPQgAJCB4ADdzyUhE8olAhQD2M9xoAD0BwWhhSUCHQ1woLAD +yF2QDXBAsAPIT4DgugfyQoYNcECgRpYG8A1wQKADyEAQAgENcECwA8hRgA1wQKADyEgQAgENcECw +EBkABAPIlBAAAFEgQILsCoH1GgmP9wzMUSBAgVXyz3GAABQaAYFRIACATfSKIAgAAKGKINMGng+v +9IohCADPcKAAwB0HgM9ygADgOoYg/w5BKIEAAJIvJgfwJ/TPc4AAXD9si4Yj/wFDu4Yjfw+C4wHb +wHsvJsfwyiBiIAUhAQQEIIAP////woi4CrkleE8gQQMEIIAPAAAAPE8gfoMweCCyA/SLuACyz3Kg +APxELYIEIIAPAAAAPAQhgQ/////DJXgNogYSATZ1AmAA0NgGD6/00dgDEgE2AYH4uA/yz3CAACAK +AJAdsc9wgAAkCkCAAYBRoRKhB/CmDu/vAtgDEgE2HbEaDw/9A8gmCq//eBAAAYDgLAJCANLYug6v +9ApxAxIDNgGDmBMBAPi4lBtAABXyz3WAAAjuqXCOCK/3aHEQ2AwaHDANzKO4DRocMO4Kr/+pcO0B +QACeEwABvhMCAZIbBACQG4QAIgugAYITAwEIdc/YYg6v9Klx+L0P8gPZz3CgABQEI6CKIBAABhoY +MP3YqQFgAKlxA8ikEAEAhiHljyQNQgADEg42pBYAEPS4kAIBAHCOz3CAAPDddnjPcqAALCBPgoQW +DREgkAgiQgOierAWDRFk5bFyAgEuAAkiQQACu89ygAAQ33Z7YmIEIo0PgAMAADe9Zb2A5colDBQE +IoIPGAAAADO6DeIA3w8njxADEJEAVg6v85gWABCYFgIQCSDBA+26yiBiIEAoAyF0e0hwxrhJIMAF +FHvrus9wgACwcHBgBfJBKAIBFCIAACi4uHgD4AQggA8AAPz/z3KAAPjnA6LPcqAAxCwNojAaQAQH +yA0SAzYEIIAPAQAA8Cy4GLiduBS7ZXgFeSqiz3KAAIBCCIIB4AiiOg2v9N7YUSGAxf/zz3CgAMQs +q4Df2CYNr/SpcQQljx/wBwAA/r00v1MlgRQH8oHnxfcAlhDgEHEN9wMSDjZKIAAgz3GAAIhBAYEB +4AGhANks8KQWABD3uNUhwgPPdYAA+OcgpeKlmBYAEH4Kb/IA2gGlz3GAAIhBAoEB4AKhAIH4YACh +z3CAAPAiA4AJgFEgQIAH8g3MRiCAAg0aHDADEg42AdlKIAAggOGSFgAROvKUFgEQz3KAAPjnopLA +gkDBz3OlAKz/z3KAAPAi2KNEglYSAgEU4kJ9A+UivbplumJIIkIABbpFIkIDVqNRIMCByiCCLwAA +gAAgwAQhgQ8AAAAgJbkFIAAEJXiJuI64GaPPcKAAqCAIgNoOT+6JBwAApBYBEKe4kh4EELS5pB5A +EJQWABCQFgMRz3GlAKz/QMCwFgIReKHPc4AA8CJkg1YTAwEU42J6A+IiultiemJIIkIABbpFIkID +VqEgwgQggA8AAAAgJbgFIgIERXiJuI64GaHPcKAAqCAIgAPZz3CgAPQHJaANyJgWAhDPcYAAPMoV +eUChpBYAEAh0hCQakBn0BCC+jwAAAAkI8k4L7/zJcMYL7/wDyA3wcBYBEc9woAD0Byegz3CgAMgc +HBgABAMSATbT2FYLr/SkEQEAA8ikEAAAUSAAgQn0Lg0P8tvYPguv9AYSATYDyAGA+bgH9PYK7+8E +2AMSATYdsa4Ib/YA34HgDPTPcIAA9CAAkIHgAN/PJyETyicCFM92oAD0BxmGgOAQ8gohwA/rcjPY +jLjPcwAAbgoKJAAEuQav7QolAAQDyByQ5XgNcQCxA8jPdYAAFBo9kA1wILADyC+ADXAgoAPIQBAB +AQ1wILADyDGADXAgoAPISBABAQ1wILADEgE2HJGGIP8MhOAe8jOBDXAgoAPIUBABAQ1wILADyFQQ +AQENcCCwAxIBNhyRhiDzD4wgDIAK9DaBDXAgoAPIXBABAQ1wILADEgE2HJGGIP0MjCACghz0YBEB +AQ1wILADEgE2pBEAAPe4EvI5gQ1wIKADEgE2pBEAAGQZAAS4GQIEuhkEBLe4pBkAAKQRAAAEIL6P +AABACAbyAYHwuBwJwu8P8DqBDXAgoAMSATakEQAAhiDzjwXyO4ENcCCgAd/rpgPZKKbPcoAA3DoN +EgE2YIJwcQDYHPLPc6AAOC5lgwQjgw/AAAAA13PAAAAADfL12AW4z3OfALj/GqM7o2nYGLgZo+lw +geAC9CCiA8gBgFEgwIABhcC4XvKA4Kb0iiAEAACliiDTBnYJr/SKIQQAz3CAAOI6AJAEIIAPAAAA +KNdwAAAAKMonAhTPcKAAwB0ngM9wgADgOkCQhiH/Di8mh/AiuSn0z3OAAFw/bIuGI/8BQ7uGI38P +guMB28B7LybH8MogYiAFIQEEBCKCD////8ILv+V6iLoKuUV5TyFDAwQhgQ8AAAA8TyF+g3B6YLAD +9Iu6QLDPcaAA/EQNgQQigg8AAAA8BCCAD////8NFeA2hTPCA4Er0iiAEAACliiDTBr4Ir/SKIQQA +z3CgAMAdB4CGIP8OQSiBAM9wgADgOkCQT3sScyT0z3OAAFw/bIuGI/8BQ7uGI38PguMB28B7LybH +8MogYiAFIQEEBCKCD////8IKuYi6RXkEIb6PAAAAPDB6ILAE9Iu6QLDPcaAA/EQNgQQigg8AAAA8 +BCCAD////8MFek2hz3CgAPxEPYAZgOu4NPQEIb6PAAYAADD04HjgeOB4USBAwyryA8jPcaAAyB+w +EAABliBBDx6hENgOoQHYFRkYgLYN4ABB2FEgQMMW8s9wgACgYgHZIKADyKQQAQCauaQYQAD6Di// +AdjPcYAAgEINgQHgDaFmDQAAGnDU2LoPb/QKcQQgvq8GAMoAI/LPcIAAECEDgIDgyiHCD8oiwgcr +2Mojgg8AAD8EqATi/88gIgPPcYAAgEIQgQHgEKHPcaD+6ADPcJ8AuP82oNkCAAAD2c9woAAUBCWg +AxIBNgGBUSDAgEfypBEAAM9ygADwIlEgAIAEggPyu5AE8GYKb/W6kM9xgABcPxGJUSAAgDPyz3CA +AOA6YJBocIYg+w+MIASAAdjAeIHgEPTPcKAAwB0HgAQjgw8AAAA8hiD/DiK4CrhleATwB9gKuEOC +MIkQuTIigg8AANgCn7mA4gHawHoPukV5JXjPcaAA/EQNoQPwdhENAQ3MUyBAgA3y1di6Dm/0BhIB +NgbIBBIBNmoM7/INEgI2z3eAAAju6XCSCG/3AxIBNgPIBhIQNs92gAAcIqAQEQAB2ACm3glv/6lw +gOAA2SCmCvKGIH6P7PIDyKAYQAQGGhg0AxIBNpIRAAHquAfyqrgWCS/5khkEAAMSAjZ+EgEBghIA +AYASAwE4YBtjDcjPcYAAgMpwexV5CYF4YAmhAYJRIMCAc/LX2B4Ob/QA2U4OL/eA2AYSATYEIYEP +AgABANdxAgAAAA0SAjcH9P24BfKDug0anDAG8FAiwAAQeg0aHDADEgE2AYFRIICBLfJPIsACjLgQ +eg0aHDAQiTMRgQAEuCV4z3WAAKyyz3GgADguJIEGtRHwLy5BEE4mgxcA3g8mzhDGec92gABg3fQm +zhDRcAjygOHw9c9wAAD//wS1A/BktQjYDBocMM9wgABcPxGIUSBAgQnyz3CAABw9Sg6v/ACIDRIC +NwPIAYD9uM8i4gHQIuEBz3GAAAxBFoENGpwwAeAWoTPwENgMGhwwDcyjuA0aHDCWCW//6XDY2CYN +b/QBEgE2AxICNgGSgOAJ8g3Iz3GAAATL9CEAAIDgC/IBgu64CfQNyAHaACCBD4AAjMpAqQ3MUyBA +gAnyBBIBNoogBADSC6/5mBEBAAPIGpDWCS/3DRIBNg3MUSDAgAYSATYR8sIMb/TX2M9wgAAUywMS +ATYCgJgZAAAGyOYN7/INEgI2BhIBNtzYmgxP9FUCb+yjwOB48cDhxanBi3WpcM9xgACoaKoKb+wk +2qlwag4v9wMSATbWCyABqXBJAm/sqcDxwOHFAxIBNqKBIIXWCK/9JNqA5Q30CiHAD+tyWdiMuO7b +SiQAABUAr+0KJQABAYWA4OIgAgANAk/s4HjxwHYJT+yYJMEzOnAA2E4cGDAAFpNAABaQQAAWlEAA +FpJATCIAocT2LyJHJEwiAKHKIcoPyiLKB8ogig8AALUoyiOKDwAAUADKJCoAsAdq7coligRBKA4h +wL5AKQEkiiCTAsYLb/TFeYDmLPRMIACgK/LPcIAA9MkDiApxhiH8B0W5JnhTIM0g4LjKIUIDyiEh +AFYkzDkgrOG4yiFCA8ohIQCLdIAkRB4grFEggIDKIEIDyiAhAIt0gCSEHgCsBvBTIP6gK/QA3YQq +CiIvcLpwx3CAAOi7hC4EHwTgACBQDkQqPicAIYB/gAB4yOCIAYiSd7hwzCDBhCDyCiHAD+tyQCwN +JEArDiSH2I24iNsFJcQT7QZv7QUlhQMKIcAP63JAKw4kz3AAAK8obtsFJgQVzQZv7QolAAQKcIIL +IABI2VYgACl2CyAABtkAJYAvgABUvoDmI4AJ9IG5I6BOFAE2JKAloAPwgrkjoAOAhiB/DobgiiAT +A8oggg8AAMsEqgpv9CpxgOXPcYAAaAkK8s9wgAB4yECIHIgQcgT0BBlCBACBEIhScAz0CnCaCS/9 +yXGKIBINcgpv9E4UATayCM/xBQBv7JUkwTPxwMIPL+wA2c9woAD8RHQQEADZgAQmgp8AAAAIC/QE +IL6vAAYAAAf0A8ikEAAA+riM8s9wgADwIgSAz3GgAMgfUSCApkYQAAEfoSDYDqEL8uoJj/CKIAQA +Bgpv9ADZAN0/8FEgQKYS8gYML+8B3QMSAjYIcaAaAACGIH6PwiVBE94Jb/T82C3wUSDApAMSATYM +8m8gQwCgGQAAiiAIAAYaGDCKIEQC2vFRIICkDPIA2Je4oBkAAIogCAAGGhgwiiCEAszxpBEAAPq4 +KfIF2BC4oBkAAIogCAAGGhgwAN3PcJ8AuP9YGAAICnAOCOAAyXED3s93oADUB9Knxg9P/M9wgAAc +IgCAgODMJSKQA/QTH5iTA8igEAAAGfCA4gjyz3KAAARCEIIB4BCi0vEKIcAP63IKJQAIMtiMuM9z +AAAlCfUEb+0KJAAEKHDdBg/s4HjxwKQQAQDpuQXyrg/P/NHA4H4odIQkEpAR8vm5BPTeD4/zB/Ag +2c9woADIHCmgA9nPcKAAEBQloOvx6/HxwDIOD+wKJwCQOnEA3Rby6XEvKEEATiCCB89woAAMLU96 +8CCAAMK4DyUNEADYDyCAAAYhAYDv9YDlK/IvKEEDTiCOBw0amDP12AW4Mgjv9MlxDcjPcqAAFAQK +os9xoABkLvAhAABTINAEKYJmCG/02tgqcHIOb/IEIMEjNg1v+clwANgPIIADBiUNkNj1z3KAANw6 +AIIH2YfgDRpYMB7yz3CgADguBYAEIIAPwAAAANdwwAAAAA7y9dgFuM9znwC4/xqjO6Np2Bi4GaMB +2APwANiB4AL0IKLPcKAAFAQqoLEFD+zxwOHFz3CAAAjNz3WAALYKYI1BiIQrHwAAIYF/gACI0E4M +b/0C4iCNz3CAALQKQJCEKR8AACGAf4AAbM2RBS/sQLDgePHAFg0P7Ch2RiHNAB1lMgggACK5wb6B +5g3yguYH8oPmDPQAFoBAAR0SEAAWgEABHRIQABaAQACtSQUP7IDhVvJAIcIDJLrDuQLwANmP4ZYA +DQAzJkFwgAB4aEAng3I0ewB7ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQ +AAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAA +ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUABCIkKAs/XgfuB4gOHKJE1w4HjoIK0BABYB +QQIYVADgfuB48cAKDA/sAN3PdwAABB1KIAAiqXYVIoAzDhABBgDYz3KgABQEyqKooieiBKI9ZYjh +aLnKIQ4AHg6v9OlwQiBQIEwgAKAg5wHmJvclBA/s4HjgfwDY8cCqCw/socEacEojACAAHMA0iiAH +CT4OL/QKcc9wgACIZTIgEgTPcIAAcAnRiBKIEHZcAQkAancKIcAkAvB6dUQuvhMAIkAuz3GAACjv +MyENAEwgAKa7fa19V/bPcYAAUBoagTuBJHhRIACCDfLPcIAAcAkLiItzyXHyDS/1qXIAwAJ9rX0A +JoAfgABwCRwQwQDPcoAAKEMAigXaWg8gAKlzz3GAAABjIIEA3UokgHEieKgggAVzbnR7tXvPcoAA +pKJ5YiGJgOF6YgvyEHEQ8hBxE/aF5Vf2AeWvfQrwQiWREC8hRyRhva99EfADEs8AANlqdQzwgOVK +IQAgyiVhEAXyQiVREC8hRyQB2YDhLfLzbvR/FSdBE89zgACkojpjACNFABUnTxT5YyGJQYowcvtj +44vY9gIiRAADFYIABL/wfyJ4BLovJAgBAieDEGx4LyBGDiIML+yIcQ54An8I5+5/RL/tf0wgAKaE +9grn7X/JcApxxgwgAOlyAebPcIAAcAkSiM9+EHa2Bsz/dQIv7KHA4HjxwCIKD+wIdih1SHcac095 +ELkPeAi4BXmKIEcIogwv9KV5gOfMICKgCPIsbS95z3CAAHAJM6gH8M9wgABwCbOoqXHPcoAAcAm0 +qsCq9aoWGgIEFgogAMlwABCHAOGIz3CAAHAJ0YgSiBB2pAEJAEQvPgcvcYQuAxEKJEAOACFDDgoh +gB+AAByjIXNAL4IAVHqELgEVCiVADgAiTQ4KJoAPgAAs7gAmSAMAJo0fgABwCUwnAIDMJ2KAJvQa +E8AAANkYrRsTwABKJIBxHK0YiyAdAhCoIEAGFCBAEEGIs260fTV9x3WAAKSiABDAAECtFSNCAAGt +ARLAAAHhAq0Aii95A6198AETwACA4Bn0ANpYrVytIB2CEEokgHEA2agggAMTbhR4NXjHcIAApKJA +qEGoQqhDqAHhL3lh8Hy5ACREAGy6ACJBAQAhhQEAJEACGog6iwIJIADpchitACRAAhuIO4vyCCAA +6XIcrQAkQAIYiDiLACREAt4IIADpciAdAhAA3UoigBEUJUsDFCBJEwETgBABEYEQvgggAOlyM240 +ebV5x3GAAKSiAKnYcQATgBAAEYEQngggAOlyAR4CABUkSwMVI0kDAROAEAERgRCGCCAA6XICHgIA +ABOAEAARgRByCCAA6XIDHgIAQiJKEEwiAJAB5ZIH7f+vfQHmz3CAAHAJEojPfhB2ZgbM/wDZz3CA +APxicQAv7CCo4HjxwOHFz3WAAChDiiDHCZYKL/QghQCFz3GAAPhiIIFNaDBywCBsAcwhDIA8CwkA +VQAP7OB4AnkteUx5ViEBcke5OGDgfw944HiB4PHAuHEc9EwlAIDE9kwlgIPO9gohwA/rcs9wAADX +FIojiAINBi/tSiQAAEAtgQBkuQAhgA+AALASHfDPcIAAuBYyIEEBjCHDj8ohwQ/KIsEHyiCBDwAA +2BTKI4EPAAAQAtAFIe3KJCEAz3CAAOAUNXjRwOB+4HjxwM9ygACCCQpqsgkgAClqJg4AANYIAADP +cYAAmHoggc9wgAB0ESIIIAAB2s9xgACUeiCBz3CAAKAQDgggAADa0cDgfvHA/g7P6xpwgOFId5QA +LAAA3TpxFSBAI4DnQIgCiAzyz3aAALASFX4CuBR4x3CAAAgSC/DPdoAA4BQVfgK4FHjHcIAA6BIh +iFEhAIAk8gUQwQAirgYQwAADrulw0gwgAEhxAK6A4MwgYoDKICEAE/JEKD4HACGAf4AAGKPFEIMA +4RCBAAIiwAAQeAe4Nggv7GJ5Aa5CIUEggOF6B+3/AeW9Bs/r8cBiDs/rz3CAAHAJERCIAM9wgABw +CRKIEXC0AAsASiYAAEohwBFELj4HL3CEKAMRJ3AAIIEPgAAYox8RywAAIIEPgAAYox4RygD4cADe +Bt8AJ40PgAAYo9V9B41pcQXamHA+CiAABRXDEEAuggBUeoQoARUAIkEO1HnHcYAALO64cQCpiHBJ +cQfaFgogAAYVwxABHQIAYb+A5wHmtAft/89+QiFJEEwhAJBAJkYAegft/y8mhwFAIEgQz3CAAHAJ +EogvIAcSEXBWB8r//QXP6wLbYKgA2ACpAdjgfwCq4HihwfHAfg3P66HBZcIIdih1z3CAAJYJhcGL +ckAkQzDSCyAAAIhELr4WACVAHhQUwTDPd4AAaKWY5fhgegAqACCoUyWAEIXgTAAKAEYlzRGvfRvw +ARSAMAAmgR+AAJjrUm1UellhIMIAqUQuvhYAJUAeRKkUFMEw+GAgqMlwXgggAKlxAeWvfVMlgBCF +4KP2IfABFIIwEm0UeAAmgR+AAJjrOGBAqCDCRKjJcDIIIACpcQ/wQiUAFg94ARSBMMd2gACw7AK4 +FHgeZiDAKK4MrgjcGwXv66HA4HjgfuB48cCiDM/rAN7PcKAAtA9wEBAAiiDHCM9xgAAoQyIP7/Mg +gVIMr/zJcM9xgABwCbKJEYmxcBD2z3KAAMiqf9sUIA8AX2dgr8GvAeAPeLFwBdtir/b2z3CAABij +QZDPdYAAAGOA4sClCfLPcIAACGMAgIwgH4QD9gDZFPDXcAAAoA979kJ4QImA4oohDwrAKOIABPRE +KL4DL3DKDc/rCHEApZ4O7/OKIMcIAN0O3s93gAB0Zz4I7/+oZ2G+gOYB5a99OffPcIAAKEMggM9w +gAD4YiCgoguv/C8gBwQtBM/r4HgOeCx4KWoA2A8gQAAncFp44H8OIMAA4HjxwJ4L7+uKIIcIz3eA +AHAJNg7v8zOPAI/WC+//M4/PcIAA9GIAENAAz3GAABwmFI9HiRByDvQAjyGJMHAK9M9wgAD9YgAQ +wAAJIAAELyAFILGPBPAB5a99Eo8QdQABCQAA3koigCPPcIAA9WIAiIDgEPJELb4TACZAHs9xgAD0 +YgARwgAAIIEPgAAo70CpX/DPcIAAsC4ggGB5ANiM4Az0z3CAAGRnyWACIEAgDXhIIEAABPBIIEAg +LyEFIM9wgAB0Z8tgE4+pcRYO7/NVjwkgQAQvIQUgz3CAALAuIIBgeQDYACWTH4AAjAmQ4Avyz3CA +ALAuIIBgeQDYjOAEE4EgC/TPcYAALAvJYQQTgCAieAkgQQQI8M9wgABUZ8hgAnkJIUEERC2+EwAm +QB7HcIAAKO8gqDpwE4+pcboOr//JcgARwSACeQAZQiBCIlIgTCIAoAHmEgft/89+fvGZAs/r8cBO +Cs/rCHXPcIAA4zAAiBB1KHcH9M9wgADiMACIEHcn8s92gABwCalwQCaBEh4JL/VAJsISCo6veiuO +GLoIuAV6iiBUDaIM7/NFeSqOBG7OD+/0S44Kjj4O7/Qrjs9wgADjMKCoz3CAAOIw4KhJAs/r4HiA +4OHFGvSMIcKNOAAqAAHYSiSAcc9zgAD4o6ggAASha0QoPgcyJU0esXHM9oDlCPKG4AjyAeAPeADY +BPBhuA944H/BxeHF4cYAEc0AgOVE9gDdoKmA4BzygOVF9gDYAKkA3c9wgABMZgCQEHWE9qlorX2g +qc9wgACkZRQgTgOgjqCqABHBADR4AYga8IDlRPYA3aCpz3CAAPhmAJAQdYX2qWitfaCpz3CAAFBm +FCBOA6COoKoAEcEANHgBiACrwcbgf8HF8cAaCe/rANihwQAcBDDPdYAAXAoAlc92gAAYo8lxiiIE +Co4Or/QB24DgEPQKIcAP63IAFQQRz3AAANsUh9uLu0UH7+yKJQQKABaEEEwkAIHKIcsPyiLLB8og +iw8AANwUyiOLDwAAjADPI+sCGAfr7MolKwDyC8/zgODKIcIPyiLCB8oggg8AAN0UyiOCDwAAkgDP +I+ICyiQiAOwG4uzKJSIAi3FF2AHaBg6v9AHbgOAP9AohwA/rcs9wAADeFJXbi7uKJEEBwQbv7Eol +AAAAFAAxAdmGIP4PwODAec9wgAC4FyCooQDv66HA4HjxwC4Iz+sIddd1JQAAgADYSvfPcYAAeOcl +gTB10PcifQHg+fHPcIAAeOfFgKlwmgnv68lxBS4+EAIlTR6MIBCAyiHGD8oixgfKIIYPAADNIsoj +5gzKJCYAQAbm7MolBgEWuDkA7+ulePHAwg+v65hwz3eAANhhA4e4cSCABvCggCJ9heVgAQkAz3Wg +AMAvWBUOFsC+geYB3sB+LyaH8/HzQRUAFgQghg8AAMAPQS6+ga70A4cggAfwwIAifoXmDAEJAFgV +DhbAvoHmAd7Afi8mh/P080AdmBADhyCABvBAgCJ6heLkAAkAWBUCFsC6geIB2sB6LyaH8PPzVx0Y +EYHjKvQDhyCAB/BAgCJ6heK8AAkAWBUCFsC6geIB2sB6LyaH8PTzBdhRHRgQA4cggC8jRwEH8ECA +InqF4pAACQBYFQIWwLqB4gHawHovJofw9PNFHdgQA4cggAbwQIAieoXiaAAJAFgVAhbAuoHiAdrA +ei8mh/Dz8wXYQh0YEM9zoAAsINCDA4cy5iCAB/BAgCJ6heJUAAkAWBUCFsC6geIB2sB6LyaH8PTz +QRUBFvO5K/Qwg8J5gOHq9gohwA/rcs9wAAChKGDbCvAKIcAP63LPcAAAoiiKIwcOSiQAAL0E7+wK +JQABCiHAD+tyz3AAAKMoiiMIBAokgA+gAMQwnQTv7LhziiDXDL4I7/OocYUGj+uB4M9xgAAYCgT0 +AdgAqQGpAImB4MoggQ8AAMQJyiCCDwAAgADgfwGh8cD2DY/rCHXPdoAAeDOKINgOegjv8yCOiiDY +Dm4I7/MhjgCOuGAArgGOHWU1Bq/roa7geEGJArgWeMdwgAAQ30ioIongfymoz3GAAPAi8CEBAIog +CADgfw6h4HgNEgI2BCC+j2AAAADPc4AABMpUe8dygAB0yghxBvIDyByQUSCAggryBCGBD2EAAADX +cQEAAAAG9ADYALMB2B7wDMxRIMCBAxIBNg3yMhGBAAGLMHAE9ADYAavy8QHgAasL8DERgQAAizBw +BfQA2ACr5vEB4ACrAtjgfxiq4cXhxs9ygABgCYDgwCIiAf/dEmkWeAAggw+AABffoKsA3UokAHHP +c4AA+OaoIIACrmJ4ZTZ4xKiuYgHlr33AqMHG4H/BxeB48cDWDK/riiDKBaHBz3WAABg9QJXPdoAA +FD0glhC6Tg+v80V5z3CAAFAcAICC4ETyAIUghhBxKvLPcIAAPCkEgFEggIBAwQXyTyEAAUDAgOEI +9K4I7/EA2KIIz/EyC0/0i3AE2aHaPdsuDi/8F7sghoDhC/IAhYDgB/SGCO/xAdiWCU/0IIYgpYDh +FvKeCc/xf9gKuM9xoADQGxOhf9gQoQDYlbgQoZ4Mb+4B2AvYQg1v7gHZjQSv66HA4HjxwBYMj+vP +cYAA8CIVeUCBCIIEIIMPgAAAAEQgDwIvuwa/ZX8EIIMPAAEAAEErTgPlfiy7xXvBEg4G0XPAEg0G +MPIEIL6PgAEAAB7yz3aAADgmyI6H5hj0vrgIokCBCIIEIIMPgAAAAEQgAQIvuwa5ZXkEIIAPAAEA +AEEoQwMleyy4BXuA5cEa2AAM8i8pQQNOIYAHEgggABAlDRCA5fj13QOP6/HAcguv65hwkOCN9woh +wA/rcnHYjbiKI40LyQHv7EolAARKJAB0ANuoIMAOQCyNAXV9QCyCAMd1gADQ4gCFz3GAABDfVnrd +uEFhAKXxudEgIoII8kQgAgYjugHigeIL989ygABQ4RYiAgFAilEiAIAD8p64E/AtucC5z3eAAPAi +8CdPEFIgTgLBFwEWCyGAgwbyKIf+ue/zn7gApQHjPQOP6+B4z3GAAPAi8CEAAM9xgACwybsQAga6 +EAMGQqFhobwQAga9EAAGRaHgfwah4HjPcYAA8CLwIQAAz3GAALDJvhAABhYhAgACkhqxA5IbsQiK +OBkCAADY4H8dsfHA4cXPc6AArC8Zg/C4GYMA3QzyBCCADwgAAADXcAgAAAAB2MB4B/CGIH8PguAB +2MB4gOAZ8hmDBCCADw4AAABCIACAyiBiAIHgD/IKIcAP63JkEwQAz3AAAK4NmduJAO/sSiUAABIM +L/RU2OS4RCABAiPyz3KfALj/vaIc2hbwz3OgAMg7VoO2g4Yi/wiGJf8YpXq2g4Yl/xiles91oACo +IK2F5OWS94Di7PUC289ygABQHGCiUSBAgM9ygAAUPQCCEfKBuBDwOBMEAFgTBQAKIcAP63LPcAAA +mSEJAO/sL9uhuFEggIAAoh7yz3KAAARjAIIQcRjyz3CAALoXAIiB4CCiCfTPcYAA2DwAgYDgw/Zq +uAChAdnPcIAACCEeDS/9IKjJAY/r4H7geOB+4HjxwD4Jj+tKIAAgz3GAAMwvz3CAANAuz3OAAFwv +SIkKdQzwRCo+CwAhgX+AAEgvtXkskQHlACBQIEQqPgsvcT9j44/xdT5jr/fPcoAAOCZIiofiRvRG +jsdxgABIL4HiAdrCIoEAVXkYEQQBTCSAgk72CiHAD+tyz3AAAMUbiiNEBjUHr+xKJYAC7BABAfYQ +gAAseC91EnWV96lwSgqv6wpxgOF78gohwA/rcs9wAADGG4ojRAgKJAAE/Qav7Lh1CnAiCq/rqXGA +4WfyCiHAD+tyz3AAAMcbiiOECe7xiOJJ9ECAUSIAgkXyRo7HcYAASC+B4gHawiKBAFV5GBEEAUwk +gILKIcsPyiCLDwAAzBvKI4sPAAAuAWwH6//KIssH7BARAQwgQKQW9ypwugmv6wpxgOEz8gohwA/r +cs9wAADPG4ojRA0KJAAEbQav7AolQAQKcJIJr+sqcYDhH/IKIcAP63LPcAAA0BuKI4QO7PFMIACg +yiHBD8oiwQfKIIEPAADIG8ojgQ8AAEAByiQBBCgGoezKJSEACQCP6+B4z3GAAARCXBnAB89xgABI +IVCBnbieuCCCz3GgAMgcDaHgeOB44HjgeOB44HjgeOB4AILgfvHA4cUg3c9zoADIH7CjQxsYAADY +ug/v/424saPRB0/r8cBSD0/rocEacCh2SHeKIBEF3gmv83rZiiARBdIJr/MKcYogEQXKCa/zyXGK +IBEFvgmv8+lxz3CgACwgMIDPcIAAdDwgoM9woAAsIBCAz3GAAHQ8IIHPdYAA5DoieACli3EyDm/s +CnAAhRB3yPcAFAAxxHgQdun1AdgD8ADYOQdv66HA8cDODk/rz3WgACwgQBUQEEAVBRDruQf0BCC+ +jwAGAAAm8uy5JPTPdgAAECcH8GLYIgtv84y4QBUFEM9woAD8RBmA7LgCJQAEA/TRcLH213AAABAn +jPYKIcAP63KKIJoKaduMu90Er+wKJAAExQZP61EgAMPPcKAA9AfxwCvyJ4AZgDB5OGADuJYgQgXP +caAAyB8eoRDYDqEB2BUZGICODu//gdhRIADDFfLPcIAAoGIB2SCgA8ikEAEAmrmkGEAAzg8v/gHY +z3GAAIBCDYEB4A2hA9nPcKAA9AcqoNHA4H7xwADZCtjPcqAAyB8eohDYDqIB2BUaGIAocAfwAdkE +IIAPIAAAAFEgAMPMISGAzCAhgBj0USMAwBT0z3AAAJ8XMgpP889yoAD8RB2CWYLrugDZ5vUEIL6P +AAYAAOD14fFRIwDAFfLPcIAAoGIB2SCgA8ikEAEAmrmkGEAAMg8v/gHYz3GAAIBCDYEB4A2hUSAA +wwDYCfTPcYAABEIQgQHgEKEA2Ji40cDgfuB48cBCDW/rANkId89woAAsIEAQEADPdZ8AuP8dhc92 +gABECT2lAKYM8IIPT+zPcA8AQEL6D6/vCnGB4BDyz3CgANQLGIBCIAAISCAAABB3LvcAhh2lUQVP +6wCGCiHAD+tyXtsdpc9wAADOIookww9JA6/suHPxwL4Mb+sB2aXBGnDPdYAAYAladeoPL/+LcEwg +QKAAFIUwARSRMAT0QCUSEUwlAIDE9kwlAIHN9gohwA/rcs9wAAApJazb/QKv7EokQABMJQCANAEO +AKhwABaOQAAWlEBMJACkenCF9owkw68o9AAWAEEAFo9AABaAQAAWAEFMJACkhgAKAIDnJ/LPcIAA +rBYAgEAszSC1fRDguGBiDy//BNnPcIAArBYAgEwhQKAdZcwnYZMZ9ADYjLgY8AohwA/rcs9wAAAq +JbfbSiRAAHUCr+wKJQAFCiHAD+tyz3AAACslwNvz8QDYALXPcIAArBYAgEAswSA1eTJgOGAFIkIE +QLAE3QbwgcAE3fYOL/+pcQAijCMAHAIVz3CAAPAi8CAABB7fwBACBoDiLymBAAInQBAl8jJoz3OA +ABffNnkrYxEjgIMI8gAmgR+AAPjmFnkAGQIFAC2BEwshwIAI8gAmgR+AAPjmFnkEGQIFECICgC8p +gQACJ0AQ3vVCI0AggODYBs3/LgzP8IkDb+ulwOB48cAKIcAP63KKIEUBxttKJAAAoQGv7AolAAHg +ePHAHgtP689xgAAI6EAhEQFVIU4Ez3CAAMgvFoAA34DgViFNA5wIgvgAEQQhACSBAzB1OAAGAECN +jCJDhwGNEvRCjdDiDvRDje/iDPREjYwigoYI9EWNieIE9L9gAufCfwLgHWUwdan3gOfKJwERz3OA +AOgvBYtAIJAAVSRABAJwjCAIgMohzQ/KIs0HyiCNDwAAwhvKI40PAACQAPgArezKJQ0EkHfYZ0f3 +ACABBEoKr/wCJMIDBGvZZ4YJr/wKcgARASHPcIAAyC8CcQAZRCCtAm/r9qDgePHA4cUIdc9wgAA4 +JgiIh+DMIGKCBfLCDs/ygOAe8s9wgADQLgCAUSCAghj0MgoP84DgFPLPcYAA8CIAgcgQAAaGIH+O +CvQBgcgQAAaGIH+OVAph/cogQQNtAk/rz3GAANAuAIGiuOB/AKHgePHA4glP6zoJD/OA4CTyz3CA +ADgmCIiH4B70z3aAANAuAIbxuBjyz3CgAEguC4DPdaAAOC7TuOeFBH8HheZ4B6WmCiAAENgHhai/ +5XgHpQCGsbgApvUBT+vxwOYID/OA4Bfyz3CAADgmCIiH4BH0z3OAANAuAIPwuNEgYYQJ9M9yoAA4 +LieCkbiIuSeiAKPRwOB+4HjxwFIJT+vPcKAASC4LgM91oAA4LtO4x4UEfgeFxngHpTIKIAAQ2AeF +pb7FeAelkQFP6+B44cXPcIAA8CIBgB7ZwBADBoDjLyjBAAIhAgAT8o7iCvISahZ4z3WAAB/fCGWB +4AvyECODgC8owQACIQIA8PUB2ALwANjgf8HFz3CAAMgvFoBCIACA4H/KIGIA4HjxwOHFz3WAANAu +AIXvuAfyr7hCCSAAAKU58PIPz/KA4ATyGgzP8DPwAIXyuAXysriKDO/wAKXmD8/ygOAn8s9wgADM +L0iIKohEKj4LACGAf4AAXC81eAaIgeAZ9HIID/OA4BXyz3CAADgmCIiH4MwgYoIG8tIMz/KA4Any +AIVRIICClAhh/cogIQCtAE/r4HjxwDIIT+tWCC/zCHaA4Abyygpv/clwEvDPdYAA0C4AhVEggIIK +8s9wgAA8YfYKj/0Ahaq4AKXu8WUAT+sA2c9wgADIL+B/NqDPcYAA0C4AgYK4AKEA2CkCb/WMuPHA +zg8P689wgACQYboKr/0A389wgACsYa4Kr/0C3c9wgABYYaIKj/3PcIAAPGGaCo/9z3aAAMwwcNwC +JgETRC8+FwogQC6CCq/9ACFADkImAB52Cq/9AnBhvYDlAecr99EHD+vxwM9ygADwIgCCz3GAANAu +yBAABoYgf44n9AGCyBAABoYgf44h9APYcg/v8gGhgOAF8uoJb/0A2AXw6grP7FYNz+wA2M9xoADE +J3cZGIB4GRiAgBkYgIEZGIAPEQCGo7gPGRiABPAAgY+4AKHRwOB+8cDqDg/rCHbPcKAAwC+lEBSG +FBAThqIQEoaKIBUMeglv88lxz3Gg/lgBz3CfALj/NqAiD2/7SiAAIIDmKfLJdy8pwQNOIZEHANgv +IUckDyBABAZ/z3CgAGQu8CBNBFMlzZQFIFAjEPIvKUEDTiGABwDZDyEBAAsiQKAmfSwPQvuA5fT1 +qgyv8SpwgOfa9clwag5v+wpxJPAvKIEDTiCPB+9/ANgPIMADBn7PcKAAZC7wIM0DUyXNlBLyLylB +A04hgAcA2Q8hAQAmfUAvARUMuCV4ugjv8wHZgOXx9YDm3vXPcKAAwC+lGBiFFBjYhFEGD+vgeOB+ +4HjgfuB48cACDg/rCHUG8M9wAABrDnIKD/PPdqAAwC+jFgCWUSAAgfXzB8hAHhiQDciG4Ab0Cgzv +/qlwgPDPd4AACO4Kj4DgCfJAJ4ASQCWBEs4Mb/wK2s9woADUCxiAQiAACEggAACw4FgI5f/KICUM +A8gDkCW4wLgXuMdwAA4AAEUgAQvscCCgARIBNuxwIKAghexwIKAhhexwIKAihexwIKAjhexwIKAk +hexwIKAlhexwIKAmhexwIKAnhexwIKAohexwIKAH8M9wAABODroJD/OjFgCWUSAAgfjzB8gEIIAP +AQAA8Cy4lODAIIYPAACTAM9xoABoLPAhDQDPcIAA1GLAgNnYmg8v8wUmQRM6Dq/wBSZAEyqPgOEO +8oogUg1+Dy/zh7nPcYAAbEIXkQHgEHgXsQDYCq81BQ/rocHxwLIMD+ujwUzBGnBIdem5OnMKIgAh +MvIC2c9woADIH0kYWIAswVNt7uFQeAb0ugsv74HBGvC34Qj0G3gQeKoLL++BwRHwlOEE9Bx4CvCK +4QX0BByEMAbwz3AAAP//BBwEMOB4ANjPcqkApP+5ogQUATGCuDeiGqIJ8Oi5N/JMIgCg0SDioQXy +z3WgAMgfTPDPcqUArP/PcIAA8CK4ogSAVhAAARTgAiEDIAPjIrt4Y3hgSCBAAAW4RSBAAxaiQSjA +IcC4d2gswAQhgQ8AAAAgJbnPdaAAyB9leCV4ibiOuBmiQBUAFiDwLMCA4MohwQ/KIsEHyiAhDs8g +IQPKIyEFzyMhA8okIQAwAmHsyiXBAAW9pXjPcaUArP8Woc91oADIH0AVABbPdqAAtEdXFgGWSiMA +IEokQCAEIb6PACgAAM9xgABIITCBIIHCJAIlBfCy2PYP7/KMuG8WAJZMJACgBCCED4AAAAAEIIIP +IAAAAAQggw8ABgAABvJAFQEWg+GE9wDZA/AB2RMVD5YEIL6PADgAAAQnjx8AAACAzCEhgMAjYSAF +IgEB5XkFIf6ABfRMI0CingfO/4DnBfKA4swjIYCT8msWE5ZMIwCgT/JqdIQk0JEL8s9xgAAMQRCB +AN0B4BChnL1j8FEjwKAK8s9xgAAMQRGBAeARoULdWfBqdIQkApgJ8s9xgACAQhGBAeARoQ7wUSOA +oQnyz3GAAIBCBIEB4AShBPBTIz6jBPIA3T/wUSNAowrybgmP/M9xgAD8QgWBAeAFofTx8ghP8Qoh +wA/rcm8WBZZE2Iy46duMu9kAb+wKJMAEgOII8s9xgAAEQhCBAeAQodzxgOMu8vq4C/LPcoAAgEIv +ggDdAeEvopG9CvD5uBLyz3KAAIBCMoJC3QHhMqJSC6//anHd2ADZsgwv85i5mL1J8HEWBJZvFgWW +CiHAD+tyOdjPcwAAAhFpAG/sjLjOCI/8z3GAAARCEYEB4BGhpPETFQCW8LjKICEALAqh/88goQNr +FgGWWBYAlgsgQIAg8m8WAJbPdaAA9AdTIECAAdgQ8gml4HgA2Amlz3GAAPxCCIEB4Aihz3GfALj/ +FqFOC+/9AdgD2AqlBd2YvQPwAN2A5Rj0USDAoQzyTCIAoA30AdnPcKAA9AcsoAPZBvAD2c9woAD0 +ByWgUSCAojQOgvcf8AMSATbPcIAACOoQcQbyz3CAANDqEHEM9JIRAAGquJIZBACeEQABqrieGQQA +z3Gg/mQAz3CfALj/NqDPcIAAoAkAgIDgB/LPcYAAbCkFgSJwBaHPcYAADEEPgQHgD6HPcIAAzLsh +gM9wgADwIgOAFJAQcQ70z3GAAFAaGoE7gSR4USAAglQLIvTKIGIAqXAI3P8AL+ujwOB4ocHxwK4I +D+sodQh2GnIEIb6PAQAAwGh3LfTovRXyRCUAFiO4IWgEJYAfBgAAADG4OGAEJYEfBgAAAddxAgAA +AcogoQAC8AHYgeAQ8oLgCfKD4ADYyiDhAcAooQMK8M9wgAD0yQKABvDPcIAA9MkBgAV9yXDKCW/4 +qXHJcKlxCnLpc24L7/9KJEAAgOA4CoH/CNyHAA/r4HjPcKQAkEFNgM9xgABozEKxGoBRIEDGA7EE +IIAP/wAAADC4BLHPcIAAaMwA2gjyz3GAAFTLMoFRIYCCBfJCsEOwRLDgf1mw4HjxwNYP7+qYcM9w +gABUyw6Qz3aAAGjMALbPcIAAVMtIEAUABCWPjwAAAAIA2wTyUSUAggryz3GmAOj/C4EDpgyBBKYE +8GSmY6bPdaQAtEUMFQKWDRUAlv/ZLyCHEIDnELkEIkkALPIyFQGWUyGPAP9nIbb/2fR/CLnvf0R5 +QC8GEgAmRwAAIMgTBScHAkAvARYEIoIPAP8AAEAvCBQ6YgAgSBL/2QUnBwIIuQUiwgEEIEcA+GAA +J4EBJXjltk95BCKCD/8AAAAoukV5I7YPeAS2BBUAllElAIICthDyRCUABiO4AeCB4Mr3z3GmAOj/ +DYEFpg6BBqYE8GamZaYA2kokgHAG2Y25qCBAAynYErjwIEMAQCYAH1V4AeFgoAHiz3CAAFTLAJA4 +HgARVSZBFBq2z3CAAEDMjg4v/AjaGxUAls9xpQDYyxmmHBUAlhqmHRUAlhumDoEcpg+BHaYmFQCW +HqbPcKQAkH8cgNUG7+ofpuHFz3WAAGjMCaUqpXi1S6UB2Bm14H/BxUokAHoA2agggAIA2s9wgABo +zDV4QKAB4eB+AAACAAAAAEABAAAAAACoEkN1AQYAAQAAAAAAAAAAOEOAAMxDgAAAnoAAICGAABgL +gABsIMAQDxsJItwdwBAKABtAEAAbbh4AAGEKABtB5B3AEQAACiQAAAolAQAKJv4FCmRAABtwAgAA +YQgAX3AFAABhIAAbcAcAAGEIAF9uAQAAYQQAAGEUQ4CBAADAFgEAGyYAAMAXAQAKJAAACiUPCmMi +CABfcAoAAGEPHB0iCQAdJg9fGyI4GYCBAADAFzsAAGEAABslAAEbJFwcwBE3AABhOBmAgQAAwBYg +ABtwMwAAYTQZgIEAAMAWDxsKIg8bGiIPCRsiAQAbMAAAwBff/wwk//8MJSAAGjAEABonAAwaOQAA +wBYPCQsiAQAbcBkAAGEAGwkpKBmAgQAAwBYAGwkpAIAJcBMAAGEPChoiIAAaMAgAGicADBo5AADA +FgEAG3ARAABhDwsJIgAbCSkoGYCBAADAFgAbCSkPCRsiAIAJbgQAAGEoAAkkAAkbKQCAG3AFAABh +JBmAgQAAwBYACxsoMBmAgQAAwBcPChsiBAAbJgAMGzk0GYCBAADAFzQIgIEPGhsiAAAbJQIAG0AA +ABtx2AiAgQAAwBYPGwsi3AiAgQAAwBYPGwoi4AiAgQAAwBYPGwgi9CmAgQIAXG4RAABh+EHEEA8b +CSIACwk5AgAKYgMBCmIEAgpiAAAJQAQAAGEJAAlAAgAAYQoACUAAAABhAgAJQQAJGigAAMAWAQAb +JgAAwBcEAB0mAQAIJ+kACGQPIBsi4AiAgQAAwBc0CICBDxobIgAAGyUCABtAAAAbcQ9FACIAXAA5 +BwAAYgZgAGIAAFg4YEXAEHBFwBB4RcAQkEXAEHkAAGEPeRMi6B3AEQEAUiS0H8AQAgATcAMAAGEI +AFgwCABkMQcAAGEPE1Ii7AjAEkIEEyQIABMxAQBSbhAAEzEEKMARCABYbugPAGEAABMlAAATJCQQ +wBGAABMlR2gTJAQowBEAgBMkOBzAEQ8AEyIBABMwBCjAEQ9zEyKCARMwBCjAEQ90EyICAhMwBCjA +EQ8UFSIBABUmD3ITIggAzBEPRAAiCgAAQABAAHAOAABhAAATJQIAEyTsHMARD3YTIhgIyhEJABNA +HAjKEQkAE0AgCMoRD3gTIgQAyhEAAAEkAAABJQYAAGEPdhMiLEjHEQ94EyIAAMYRAwABJAAAASUA +ABMlwiwTJAQowBECRhMkBCjAEcJfEyQEKMARD0UAIgBcADksAABkAAATJAEAEyU4HMARD3cTIuAc +wBECAAFiDwETIgQIwBHACMASBCjAEQ8TAiLECMASBCjAEQ8TByLICMASBCjAEQ8TBCICAHFwBwAA +Yf8AEyUCEBMkBCjAEQAAEyUAABMkyEnHEQYAAGEAABMlAhATJAQowBEAABMlSQATJMhJxxEPcBMi +AQATMAQowBEDABMkAAATJQQIwBEAABMkOEXAEcwIwBIYKMARDxMDIgQAAGEAAFg4AAATJAEAEyU4 +HMARAAAVJAAAACGsCICBAADAFg8bUCKwCICBAADAFg8bGiK0CICBAADAFg8bGSK4CICBAADAFgAA +AIWoCICBAADAFg8bBCIcBBtmGwEbaBQcwBAKABtABAAbbgsAAGEPHB0iAQAdJvkPAGG8CICBAADA +FgUAG2I0CICBDxobIgAAGyUCABtAAAAbcWQMABAAwAYRAQAEJ/wABGQAABskAgAbJTgcwBE0CICB +DxobIgAAGyUCABtAAAAbcQAAGyVAABskMBzAETQIgIEPGhsiAAAbJQIAG0AAABtxkEXAEA9kASIK +AAFACAABcCoAAGEAAAEkCAABJQ8BYyIIAFhuBgAAYSQQwBABABNuAgAAYQACXDEBAABhACBYMOQI +QBL//xNu/Q8AYQFCEyQAABMlBCjAEeQIQBL//xNu/Q8AYewIwBJCBBMkGAATMQQowBFgRcAQcEXA +EAMHfWICABMkAAATJegdwBH4/0wzAQBMMQEAUiToCEAS//8TbgMAAGEkEMAQAQATcAIAAGEAABUk +AAAAIQ8AAGEPfRMi6B3AEQEAUiS0H8AQAgATcAIAAGEIAGQxAAAAIQ8TUiLsCMASQgQTJAgAEzEB +AFJuEAATMQQowBFcCYCBAADAFgIBE2RCARMkBCjAEaBigIEAAMAWBgETYgQIwBAEABNkD1wAIgoA +AEAABgBwGQAAYQAAEyQAABMlAADAFwAIWDDIIMAQcEXAEBAIwBAAABMlAwATJBwIwBEcCMARAAAT +JAQIwBEPFBUiBAAVJvv/MDIDABMkGAjAEQ8UFSICABUmBAAwMAAAEyQQRcARGAjAEQAQWDAPfBMi +CADMEQAAEyUAABMkNEjHEQ97EyIBABMwBCjAEQ8UFSICABUm/wATJQIQEyQEKMARDxQVIgIAFSZU +CoCBAADAFsIsEyQEKMARAkYTJAQowBHCXxMkBCjAEQ9NEyIEEMURAgATJPAcwBEBABMk7BzAEQAA +EyRwABMlEBzAEQAAEyUAABMk4BzAEYAAEyVGaBMkBCjAEQAAEyUBABMkJBDAEQAAFSQAAAAhDw4a +IgAAQBYAARtwDQAAYYAAYyT//hsyAABAFwAAGyUPGw8iGAmAgf8AGzICABtBABsaKAAAwBYAABsl +AgAbQAAAG3EBAGRwBwAAYQEAYyQAABsk+giAgQAAQBfwCICBAABAFu0PAGECAGRwEAAAYQIAYyQB +ABsk+giAgQAAQBfyCICBAABAFuQPAGEEAGRwBwAAYQIAYyQCABsk+giAgQAAQBf0CICBAABAFtsP +AGEAAB0kAAAAIQACD24JAABh+giAgQAAQBYAABsl9giAgQAbGigAAAAWAQAbJgAAABcNAABhEAmA +gQAAQBYCABsmARAbaAAAGyQAAEAX/AiAgQAaGygPGw4iFAmAgQAAQBYBABsmAABAF3wHgIEPGhsi +AAAbJQIAG0AAABtxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAGwEgAC4AYAAAAAAAAAAAAAoAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAABCxgAAMBgAAELGAANTlAAAJDREUCg0TFxkZGRkJCQAAKKyAACiKAAAQsYAA +AAAAABCxgAAAAAAALM2AAFCKAAAwgAAAAAAAADGAAACIiDMzMoAAAACqqoozgAAAAAAAADSAAAAA +AAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAAAAAAAAO4AAAAAA +AAA8gAAAAAAAAD2AAACqqgoAPoAAAFOFiIg/gAAAAAAAMDCAAAAAAAAAMYAAAJqZWFUygAAAAKqq +qjOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAA +OoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAAAKqqCgA+gAAAVZiZqj+AAAAAAABQMIAAAAAAAAAx +gAAAAAAAADKAAAAAAAAAM4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAAAAAAAAA3gAAAAAAAADiA +AAAAAAAAOYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAAAAAAAD6AAAAAAAAAP4AA +AAAAAAAwgAAAAAAAADGAAAAAAAAAMoAAAAAAAAAzgAAAAAAAADSAAACaeQAANYAAAKqqqqo2gAAA +AAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAACqqqoKO4AAAABwmao8gAAAAAAAAD2AAAAA +AAAAPoAAAAAAAAA/gAAAAAAAAP//AAC0ACAAGQEgALUAIQAaASEABAAIANQBAwCzAQQAeAA8AN0A +PAB5AGoA3gBqAKgAAQANAQEAnAHMAJ0BzADVAcwA1gHMAKQBgABdAjYASgINAEwCDwBNAgEArQEG +ALgBAAC7AVYAjwCIAPQAiACQAAAA9QAAAJEABgD2AAYAhQAEAOsABABQAgsAUQIDAFICAQBTAgAA +VAILAFUCAwBWAgEAVwIAALkBwQDQAQAAZgIGAGgCBwBqAgYAbAIHAG4CBQBwAgwAfQIGAH8CBwCB +AgYAgwIHAIUCBQCHAgwAoQFAAPv/AAD//wAAtAAgABkBIAC1ACEAGgEhAAQACADUAQMAswEEAHgA +PADdADwAeQBqAN4AagCoAAEADQEBAJwBzACdAcwA1QHMANYBzACkAYAAXQIzAEoCDgBMAg4ATQIB +AK0BBwC4AQAAuwFWAI8AiAD0AIgAkAAAAPUAAACRAAYA9gAGAIUABADrAAQAUAILAFECAwBSAgEA +UwIAAJQCCwCVAgMAlgIBAJcCAABUAgsAVQIDAFYCAQBXAgAAmAILAJkCAwCaAgEAmwIAALkBwQDQ +AQQAZgIGAGgCBwBqAgYAbAIHAG4CBQBwAgwAfQIGAH8CBwCBAgYAgwIHAIUCBQCHAgwASwIBAKEB +QACyADAAFwEwALMAAAAYAQAAnAIPAKECDwCgAogAnwKIAJ4CiACdAogApQKIAKQCiACjAogAogKI +APv/AAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAAAAAAAAEAAAEBAAAAAAEB +AAAAAAAAAAAAAAAAAQEBAQIAAAAN0hLSE9IU0gzSFdIL0gLSEdIEQwAQFBAJEBEQAUAb0hzSANIK +AAsABAAOALUAGgEPAEIAvADDACEBKAG2ALcAuAC5AL0AvgC/AMAAGwEcAR0BHgEiASMBJAElAREA +AAAKAAAACgAAALYAAAC3AAAAuAAAALkAAAC2AAAAtwAAALgAAAC5AAAAvQAAAL4AAAC/AAAAwAAA +AL0AAAC+AAAAvwAAAMAAAAAS0gAAEtIAAAAAAgAsAGQAdACAAIwAoQAHAAAAAAABAAIAAwAAAAAA +txMiALgUIwC5FSQAuxYlALwXJgC9GCcAwBkoAMQaKQAHGwAACBwBAAsdAgAMHgMAEB8EACIhBQAk +IgYAJiMHACgkCAAqJQkALCYKAC4nCwAwKAwANCkNADgqDgA8Kw8AQCwQAGQuEQBoLxIAbDATAHAx +FAB0MhUAeDMWAHw0FwCANRgAhDYZAIg3GgCMOBsAkTocAJU7HQCZPB4AnT0fAKE+IAClPyEAJEkG +AixKCgI0Sw0BPEwPAWRNEQFsThMBdE8VAXxQFwGEURkBlVIdAZ1THwEBBAAAAgUBAAMGAgAEBwMA +BQgEAAYJBQAHCgYACAsHAAkMCAAKDQkACw4KAAwPCwANEAwADhENAAFAAAQCQQEEA0ICBARDAwQF +RAQEBkUFBAdGBgQIRwcECUgIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAABAHAAARBwAAEwcAADIGwAAzBsAADQMoABADKAAHBygAEAgoAAo +JKAAbBCgABgkoAB4JKAAfCSgAIAkoACEJKAAUBCgAFQQoABIJqAAYBCgAEwmoABkEKAAaBCgAFwQ +oABYEKAAMBCgADwQoAA0EKAALAygAACBpAABgaQAA4GkAIgkoACMJKAAkCSgAJQkoACYJKAAnCSg +AKAkoACkJKAAgHuAAAAAAACyDCwB/////////wAB//8CA////wT//////////////////////wX/ +Bv8H/wj/Cf8K/wv/DP///w3///8O////D////xD///////////////////////////////////// +/////////xH///8S////E////xT///8V////Fv///xf///8Y////Gf///xr///8b/////xz///8d +////Hv///x////8g////If//////////////////////IiMk/yUmJ///KP///yn///////////// +/////////////////////////////////////////////////////////////////wABAAEBAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAANhlAQAA +AAAA4H8AAAEAAAAAMQIAAgAAAFgwAgADAAAAJJsCAAQAAADYZQEABQAAAPBNAQAGAAAAZBoBAAcA +AACATgEACAAAAFw8AAAJAAAANHIAAAoAAAAs6AAACwAAAEw1AAAMAAAAKJsCAA0AAAB4CQEADgAA +ACwKAQAPAAAABAkBABAAAAAICgEAEQAAAJCAAQASAAAAQFUCABMAAAAIJgAAFAAAAJypAQAVAAAA +/JEBABYAAAAkogEAFwAAAIAvAgAYAAAAKNgBABkAAACkOwEAGgAAANRlAQAbAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAA//////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARoAAAEgAAAFIAEuCSIBMg8gBzAT +IgsyGSARMB0iFTIjIBswJyIfMS0gAAAxHwAANxkAADsVAAAAAAAAAAAAABCsAAAQrAAAEKwAADyS +AAAQrAAAEKwAAKCSAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAA8mwAAgJoA +AHCaAACYmQAAqJoAAFSZAAAQrAAAEKwAAJihAABMpQAAaKcAABCsAAAQrAAAEKwAAHirAACcoAAA +1KAAAECgAAAQrAAAEKwAABCsAAA0qwAAEKwAACCgAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQ +rAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCs +AAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAAGSTAAAQrAAAEKwA +ABCsAAAQrAAAEKwAAISoAAAQrAAAEKwAABCsAAAQrAAAEKwAALyWAAAQrAAAzJYAAMiWAADAlgAA +xJYAAOCPAAAQrAAAmI8AABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAHI8AABCsAAAQ +rAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAzJQAAESUAAAQrAAA6JQAABCs +AACEkwAAGJkAABCsAAAQrAAAXJsAABCsAAAQrAAAEKwAABCsAAAQrAAA4JwAAIybAAAQrAAAEKwA +ABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAANCWAAAQrAAAEKwAABCsAAAoqAAA +EKwAABCsAAAQrAAAyKoAABCsAAAsqwAAxKcAABCsAAAQrAAAKI4AAISnAAAQrAAAEKwAAKCZAAC4 +mQAAEKwAABCsAAB4lgAAMJAAABCsAAAQrAAAEKwAANygAAA8mQAAEKwAABCsAAAQrAAAEKwAABCs +AAAQrAAAdJgAABCsAAD0rAAANK8AAGiuAAA8rwAAYK4AAFiuAABErwAANKwAABCsAAAQrAAAEKwA +ABCsAAAQrAAAEKwAABCsAAAQrAAAgJYAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAADYrwAA +7LAAAEiOAABojgAAEKwAABCsAAAQrAAAEKwAABCsAABkkAAAEKwAABCsAAAQrAAAEKwAABCsAAAQ +rAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCs +AAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAAGiQAACIkQAA+JAAAEyvAACojgAAFJIA +AKySAAAQrAAAEKwAABCsAAAQrAAAmJIAAJySAAAQrAAAEKwAAECSAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8 +vgAA6LwAADTAAAAwvwAASMEAAAAAAQD/////AAAAAP//////////AQAAABAPAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAA0P4AAAAAAAAAAAMDAwMEBAQFBQYAABggoAAgIKAAQCGg +AEghoAAcIKAAJCCgAEQhoABMIaAAKCCgADAgoABoIaAAcCGgACwgoAA0IKAAbCGgAHQhoAA4IKAA +PCCgAHghoAB8IaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEDQAAAP8DAGQOAAAA/wUACA4AAAD/LQDkDQAAAP89AIAN +AAAA/wQAqA0AAAD/JQDo6wAAAP/dACwOAAAQEEwAAAAAAAAAAAAAAQEAPDw8PDw8PDw8PDw8PDw8 +PDw8PDw8PDw8PDw8PDw8PDwVFRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAADw8PDw8PDw8 +PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAAAAAAAAAAAAA8 +PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8FRUVFTw8PDwAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAP8AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAFgQAACwFwAA4BMAADwRAAB8GQAA8BQAAJgWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwCYAAuLGAABgAAAB4sYAA +AAAAAAAAAAAAAAAAAAAAANQ4AQDczQAAaCMAANzNAADczQAA3M0AABAHAAA0TQIArPkAANzNAADc +zQAABCoAAAQqAAAEKgAABCoAAAQqAAAEKgAABCoAANzNAADczQAA3M0AANzNAAAAWQAA3M0AANzN +AADczQAA3M0AANzNAACQ+QAA3M0AANzNAAAk6wAAAAAAAIAeAQCEHgEAtAIAAKACAAD8fwEAAAAA +AADdAADcGQIAKN0AAAwaAgBM3QAAPBoCAOg6gACkpoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAFAAYABwAIAAgACQAKAAoACwAMAAwADQAOAA4A +DwAmACcAKAApACoARgBGAEcASABIAEkASgBKAEsATABoAGkAagBqAGsAbABsAG0AbgBuAG8AcABw +AHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AAoAPwAAAIQA +hACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAFAAYABwAIAAgACQAKAAoACwAMAAwADQAOAA4ADwAm +ACcAKAApACoARgBGAEcASABIAEkASgBKAEsATABoAGkAagBqAGsAbABsAG0AbgBuAG8AcABwAHEA +cgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AAoAPwAAAAAAvCEA +AIQhAAC8soAAAAIAAAAAAABILgEAGC4BALy0gABABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +TC4BAKx8AQBMu4AAVAAAAAAAAABILgEAgHsBAPy5gABQAQAAAAAAAEguAQBodQEAQAqAAAgAAAAB +AAAASC4BABQtAQAAAAAAUAEAAAAAAABILgEA9HUBAHgzgAACAAAAAAAAAEguAQAAdQEAPAqAAAQA +AAAAAAAAUC4BABguAQCgu4AAKgAAAAAAAABILgEAGC4BACxDgAAIAAAAAAAAAAAAAAAgLgEAAAAA +AAAAAAABAAAAAAAAADQuAQAAAAAAAAAAAAAAAAAAAAAAHC4BAAAAAAAAAAAAAAAAAEguAQCQHAIA +AAAAAAAAAAAAAAAASC4BAFAcAgBICoAABAAAAAAAAABuAG4AaQDAAKAAUACAAL4AUAF9AD4AAQAB +AAEAWAIoAOYBLQBVAzwA3AFjAAAAbgBuAGkAwACgAFAAgAC+AFABfQA+AAEAAQABAFgCKADmAS0A +VQM8ANwBYwAAAAAAAAABAQAAyDcBABXSAAAAAAAA/wMAAMg3AQAM0gAAAAAAAP8BAADINwEAFdIA +AAoAAAAA/A8AyDcBAAzSAAAJAAAAAP4DAMg3AQAV0gAAFAAAAAAA8D/INwEADNIAABIAAAAAAPwH +yDcBAAbSAAAAAAAA/wEAAMg3AQAH0gAAAAAAAP8DAADINwEABtIAAAkAAAAA/gMAyDcBAAfSAAAK +AAAAAPwPAMg3AQAG0gAAEgAAAAAA/AfINwEAB9IAABQAAAAAAPA/AAAAAAAAAAAAAAAAAQAAAAEA +AAAKAAAABQAAAAUAAAAGAAAACgAAAAoAAAAGAAAABAAAAAUAAAAGAAAABQAAAAUAAAAGAAAABgAA +AAYAAAAGAAAABwAAAAcAAAAHAAAACAAAAAgAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAABAAAA +AgAAAAEAAAACAAAAAQAAAAEAAAADAAAAAwAAAAIAAAABAAAABAAAAAAAAAAAAAAAAgAAAAEAAAAB +AAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAALAEA +AF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAAAAAAkEYBADxMAQDoSgEAwEwBADhMAQAISgEA +vEwBAPxHAQD4RwEAYOMWACDWEwAAAAAAEAAAAACAAAAAAKAAECcAAOgDAADoAwAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAACAAAAAgAAAAEAAAABAAAAAgAAAAUAAAACAAAAAgAAAAUAAAACAAAAAgAA +AAEAAAABAAAABQAAAAUAAAACAAAABQAAAAUAAAAAAAAABQAAAAIAAAACAAAAAAAAAAAAAAAAAAAA +BQAAAAUAAAAAAAAABQAAAAIAAAACAAAABQAAAAUAAAAFAAAAAAAAAAUAAAACAAAABQAAAAEAAAAB +AAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAABQAAAAEAAAABAAAAAgAAAAIAAAACAAAABQAAAAUA +AAACAAAAAgAAAAUAAAABAAAAAgAAAAUAAAACAAAABQAAAAUAAAAEAAAABQAAAAUAAAABAAAABQAA +AAUAAAAFAAAAAgAAAAIAAAAFAAAABQAAAAUAAAABAAAABQAAAAUAAAAFAAAAAgAAAAIAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAARAAAQAA +AAKAAAFCAAYCEAACIAAAA8AAAUMABgMQAALAAAADwAABQwAGBBAAAkAAAAKAAAFEAAYFEQAAQAAA +A8AAAUUABgYRAADgAAADwAABRQAGBxEAAQAAAAKAAAFGAAYIEQACIAAAA8AAAUcABgkRAALAAAAD +wAABRwAGChEAAkAAAAKAAAFIAAYLEgAAQAAAA8AAAUkABgwSAADgAAADwAABSQAGDRIAAQAAAAKA +AAFKAAYOEgACAAAAAoAAAUwABgF4ADAAAABQAAAEtjwGAngARAAAAFAAAAS5PAYDeQAIAAAAUAAA +BLs8BgR5ABwAAABQAAAEvjwGBXkAMAAAAFAAAATAPAYGeQBEAAAAUAAABMM8Bgd6AAgAAABQAAAE +xTwGCHoAHAAAAFAAAATIPAYJegAwAAAAUAAABMo8Bgp6AEQAAABQAAAEzTwGC3sACAAAAFAAAATP +PAYMewAcAAAAUAAABNI8Bg17ADAAAABQAAAE1DwGDnwAEAAAAFAAAATaPgYAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAABAAEBAAABAAEAAgEAAAIAAQACAQAAAoCAgICAgICAAYACgICAgIDAAJAA0AAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAGAAAABgAAAAYAAAAGAAAAAgAA +AAYAAAAGAAAABwAAAAYAAAAGAAAAAwAAAAEAAAAHAAAABgAAAAIAAAAGAAAABgAAAAcAAAAGAAAA +BgAAAAAAAAAEAAAABwAAAAYAAAAEAAAABgAAAAYAAAACAAAAOAUCAGgGAgAUCAIAtAYCAJgIAgA8 +BAIAAAAAAG4AAABuAAIAbgBuAG4AAgBpAGkAbgABAMAAwADoAAEAoACgADYBAwBQAFAA9QABAIAA +gADoAAEAvgC+AL4AAQBQAVABUAEBAH0AfQCvAAMAPgA+AD4AAQABAAEAAQABAAEAAQABAAEAAQAB +AAEAAQBYAlgCWAIBACgAKAAoAAEA5gHmAeYBAQAtAC0ALQABAFUDVQNVAwEAPAA8ADwAAQDcAdwB +3AEBAGMAYwBjAAEAAAAAAAAAAAAyAAUAMgAFAAIACABkAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAA +AIwKjAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAQAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAFg/AgAVAAAAAwAAANhhgAAAAAAAAAAAAAAAAABwOAIABgAAAAAAAAD4YYAAAAAA +AAAAAAAAAAAA/D4CAAUAAAADAAAA2GGAAAAAAAAAAAAAAAAAAGxcAAAVAAAAAwAAANhhgAAAAAAA +AAAAAAAAAADkPgIACgAAAAMAAADYYYAAAAAAAAAAAAAAAAAApDsCAAQAAAAAAAAA+GGAAAAAAAAA +AAAAAAAAAKQ7AgAEAAAAAAAAAPhhgAAAAAAAAAAAAAAAAACkOwIABAAAAAAAAAD4YYAAAAAAAAAA +AAAAAAAApDsCAAQAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAKQ7AgAEAAAAAAAAAPhhgAAAAAAAAAAA +AAAAAACUPAIABgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAzDwCAAQAAAAAAAAA+GGAAAAAAAAAAAAA +AAAAAMw8AgAEAAAAAAAAAPhhgAAAAAAAAAAAAAAAAADMPAIABAAAAAAAAAD4YYAAAAAAAAAAAAAA +AAAAzDwCAAQAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAJQ8AgAGAAAAAAAAAPhhgAAAAAAAAAAAAAAA +AACUPAIABgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAlDwCAAYAAAAAAAAA+GGAAAAAAAAAAAAAAAAA +AMw8AgAEAAAAAAAAAPhhgAAAAAAAAAAAAAAAAADMPAIABAAAAAAAAAD4YYAAAAAAAAAAAAAAAAAA +sDkCAAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAKA7AgAKAAAAAAAAAPhhgAAAAAAAAAAAAAAAAACg +OwIACgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAoDsCAAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAKA7 +AgAKAAAAAAAAAPhhgAAAAAAAAAAAAAAAAACgOwIACgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAoDsC +AAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAKA7AgAKAAAAAAAAAPhhgAAAAAAAAAAAAAAAAACgOwIA +CgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAoDsCAAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAKA7AgAK +AAAAAAAAAPhhgAAAAAAAAAAAAAAAAACgOwIACgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAoDsCAAoA +AAAAAAAA+GGAAAAAAAAAAAAAAAAAAHRBAgAGAAAAAAAAAPhhgAAAAAAAAAAAAAAAAADEQAIABQAA +AAMAAADYYYAAAAAAAAAAAAAAAAAAoDgCAAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAEA5AgAKAAAA +AAAAAPhhgAAAAAAAAAAAAAAAAADcUwIACgAAAAMAAADYYYAAAAAAAAAAAAAAAAAA/DkCAAoAAAAA +AAAA+GGAAAAAAAAAAAAAAAAAAPA6AgAKAAAAAAAAAPhhgAAAAAAAAAAAAAAAAACIPQIACgAAAAAA +AAD4YYAAAAAAAAAAAAAAAAAATD4CAAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAAFw/AgAKAAAAAAAA +APhhgAAAAAAAAAAAAAAAAAAIQAIACgAAAAAAAAD4YYAAAAAAAAAAAAAAAAAAYEACAAYAAAAAAAAA ++GGAAAAAAAAAAAAAAAAAAHBAAgAGAAAAAAAAAPhhgAAAAAAAAAAAAAAAAACUQAIACgAAAAAAAAD4 +YYAAAAAAAAAAAAAAAAAAmEACAAoAAAAAAAAA+GGAAAAAAAAAAAAAAAAAALxAAgABAAAAAAAAAPhh +gAAAAAAAAAAAAAAAAAC0QgIACgAAAAEAAAAYYoAAAAAAAAAAAAAAAAAAKEICAAUAAAABAAAAGGKA +AAAAAAAAAAAAAAAAAMxFAgAGAAAAAQAAABhigAAAAAAAAAAAAAAAAAAgRgIABgAAAAEAAAAYYoAA +AAAAAAAAAAAAAAAAQEkCAAoAAAABAAAAGGKAAAAAAAAAAAAAAAAAAAAAAADYYYAA2GGAALggoABs +IKAAAIABAP9//P8AAAAAAAAAAPhhgAD4YYAApCCgADggoAABAAAA/P///wAAAAAAAAAAGGKAABhi +gACoIKAAPCCgABAAAADH////AAAAAAAAAAA4YoAAOGKAAKwgoAB4IaAAQAEAAD/+//8AAAAAAAAA +AFhigABYYoAAsCCgAHwhoAAADAAA//H//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPQ5AgAVAAAA +AwAAANhhgAAAAAAAUAAAAAAAAADwCYAAuLGAABgAAAB4sYAAAAAAAAAAAADwCYAAuLGAABgAAAB4 +sYAAAAAAAAAAAAAAAAAA8AmAALixgAAYAAAAeLGAAAAAAAAAAAAAAAAAAH8AAAAAAAAAAH8AAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAP8AAP//AAABAAAAAAAAAAcAAAAAAAAAAAAAAAAAAACwagEAcGkB +AAAAAAAAAAAAAAAAAAAAAAAUbQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAUbQEAfGsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AACwagEAcGkBAAAAAAAoaQEAAAAAAEBpAQAUbQEAfGsBAAAAAAAAAAAAAAAAAEhrAQAoaQEACGkB +AAAAAACwagEAcGkBAARqAQCkaQEAAAAAAEBpAQAUbQEAfGsBAChpAQAIaQEAxGoBAAAAAAAoaQEA +CGkBAAcAAAAAAAAABgAAAAIAAAACAAAAAgAAAAIAAAAGAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAcAAAABAAAABgAAAAcAAAAHAAAABwAAAAcAAAABAAAABgAAAAEAAAABAAAAAAAAAAEA +AAABAAAAAQAAAAcAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAA +AAIAAAACAAAAAgAAAAcAAAADAAAAAwAAAAcAAAAEAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAA +AwAAAAMAAAADAAAAAwAAAAcAAAAEAAAABAAAAAQAAAAEAAAABwAAAAMAAAAEAAAABAAAAAQAAAAE +AAAAAwAAAAQAAAAEAAAABAAAAAAAAAAAAQIDBAQEBAQFBgcICAgICAkKCwwNAABuO2g7YjtcO246 +aDpiOlw6bjloOWI5XDluK2grYitcK24qaCpiKlwqbiloKWIpXCluKGgoYihcKG4naCdiJ1wnbiZo +JmImXCZuJWglYiVcJW4kaCRiJFwkbiNoI2IjXCNuImgiYiJcIm4haCFiIVwhbiBoIGIgXCBiE1wT +bhJoEmISXBJuEWgRYhFcEW4QaBBiEFwQbgJoAmICXAJuAWgBYgFcAW4AaABUAAAAbjtoO2I7XDtu +Omg6YjpcOm45aDliOVw5bitoK2IrXCtuKmgqYipcKm4paCliKVwpbihoKGIoXChuJ2gnYidcJ24m +aCZiJlwmbiVoJWIlXCVuJGgkYiRcJG4jaCNiI1wjbiJoImIiXCJuIWghYiFcIW4gaCBiIFwgbhJo +EmISXBJuEWgRYhFcEW4QaBBiEFwQVxBSEE0QSRBuAWgBYgFcAW4AaABiAFwAVAAAAAAAAAAAAAAA +HQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJwBAAgAAAAD +AAAA2GGAAFwLgADcC4AAXAyAANwMgAAKDREUCg0RFBkZGRkKCgAAAAAAAAYGBgYJCQkJAAYAAAAF +BgcIDQ4PEBUWFxgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8arKwlL6ysrKyspax+kU5DDJs2AAAANwCako9IAAAP +ACBoNwAAABEAPjogEQAAAiUAAAwvAAACLzk5AAolPLpHcY0ABxctaTQAAAIAFwAABRAKIDBAAAAG +BgoABQoPDSQcJCIAAAAAR5ivr0kAAAwQFBggCAQAADw4NDAsKCQgHBgUEAwIBAALBwMAOzczLysn +Ix8bFxMPCwcDMTc6MDA6MjQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +IgAAABAAAAAdAAAANwAAAG8AAACgAAAAcAAAAAUAAAD2AAAAWgAAAB8AAABIAAAAIAAAAEgAAAAI +AAAAAQAAADMAAAB/AAAANAAAAH8AAAA3AAAAAQAAADgAAABPAAAAOwAAAH8AAAA8AAAAfwAAADEA +AAAAAAAAMgAAAAAAAAA1AAAAAAAAADYAAAAAAAAAOQAAAAAAAAA6AAAAAAAAAA0AAAAqAAAADgAA +AHoAAAAPAAAAEAAAAPMAAABIAAAA9AAAAEgAAAAAAAAAAQEBAQEBAQECAgICAgICAgMDAwMDAwMD +AQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABQAAAKEDDh7hAAAAoQMOHuEAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoQMOHuEAAAAV9mP2 +sPb89kb3kPfY9x/4Zfip+O34L/lw+bD57vkr+mf6ovrc+hT7S/uB+7b76vsc/E38ffyr/Nn8Bf0w +/Vn9gv2p/c/99P0X/jn+Wv56/pj+tv7S/u3+Bv8e/zX/S/9g/3P/hf+W/6b/tP/B/83/2P/h/+n/ +8P/2//r//f/////////9//r/9v/w/+n/4f/Y/83/wf+0/6b/lv+F/3P/YP9L/zX/Hv8G/+3+0v62 +/pj+ev5a/jn+F/70/c/9qf2C/Vn9MP0F/dn8q/x9/E38HPzq+7b7gftL+xT73Pqi+mf6K/ru+bD5 +cPkv+e34qfhl+B/42PeQ90b3/Paw9mP2cLmDupa7qry+vdK+57/8wBHCJ8M9xFPFasaAx5fIr8nG +yt7L9swPzifPQNBZ0XLSjNOm1L/V2tb01w7ZKdpE21/cet2W3rHfzeDp4QXjIeQ+5Vrmd+eT6LDp +zerq6wftJO5C71/wffGa8rjz1fTz9RH3L/hM+Wr6iPum/MT94v4AAB4BPAJaA3gElgW0BtEH7wgN +CisLSAxmDYMOoQ++ENwR+RIWFDMVUBZtF4kYphnCGt8b+xwXHjMfTyBqIYYioSO8JNcl8iYMKCYp +QSpaK3Qsji2nLsAv2TDxMQozIjQ6NVE2aTeAOJY5rTrDO9k87z0EPxlALkFCQlZDakR9RQAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKqqqqqqqqqqqqqqrqqq +qqoo/wDMqqoAAKqqAMyqqgAAAEAAwAAAAAAAUADwAEAA8Kqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq +qqqqqqqqqqqqAAAAAAAAAAAAAAAAAAAAAAABAQIBAgIDAQEBAQEBAQECAgICAgICAgMDAwMDAwMD +BAQEBAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAACk +NAAA8DYAACQxAAAkMAAApDAAAMQ1AADsLwAA7DUAAGw2AAA6AQIB1QDfANoAogB1AH8AigUqAzkB +qAGKBcoC2QBIAQEDDwcKFDduagEaAdkA6AAKAboAeQCIAMoBSgHiAPkAygHqAIIAmQB00UUX6KKL +LgAFBwEDBAAFAQUAAAAFBgACBAAFAAUAAAECAQIDBAAABQYHCAkKAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANznAACg6gAAsOUAAAEAAAAA +AAAAAQAAAAIAAAADAAAAAAAAAAQAAAACAAAABQAAAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH +BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgICAgIB +AQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAoACgAMAAsACwAKAA8ADQAQAA8AIwAbABYAEgA9ACwAH//Bw8fPwEDMAAAADYAAAAMAAAAEgAA +ABgAAAAkAAAABgAAAAkAAAAFAAcCAwQGBkADgAbACQANgBMAGkAdgCCABgANgBMAGgAnADSAOgBB +wAmAE0AdACeAOgBOwFeAYZkDMwfZCnMOphXmHIAgGSQzB3MOphXmHFkrzDkAQTNI2QqmFYAgWSsA +QaZWgGFZbJ3YiZ1O7MRONEiDNCd2YicapEEaEzuxExEYgREP/MAPTuzETid2YicapEEaEzuxEw3S +IA2JndgJCIzACAd+4Ac0SIM0GqRBGhEYgREN0iANCIzACAZpkAawstUFBVRABSd2YicTO7ETDdIg +DYmd2AkGaZAGxE7sBARGYAQDP/ADqqqqqhqkQRoTO7ETD/zADxEYgREN0iANCqiAChM7sRMP/MAP +D/zADw3SIA0LtEALC7RAC4md2AkN0iANCqiACgqogAoIjMAIB3iABwd4gAcGaZAGD/zADw3SIA0L +tEALDdIgDQu0QAuJndgJCIzACImd2AkIjMAIB37gBwd+4AfBLCkHCqiACgiMwAgHeIAHCIzACAd4 +gAcGaZAGsLLVBQZpkAawstUFBVRABQVUQAXWHcYEAQcPHz9///9m5gAABQYBAgMEAABUAFQAbABg +AFwAVACMAHgADQ8FBwkLAQMoACgANAAwACwALABEADwALAAsADwANAAwACwAVABEAFVVVQFLaC8B +VVVVBeM4jgOqqqoCcRzHAaqqqgrHcRwHAAQAAGQAAAAAAAAADwA/AAEAAAAPAD8AAQAAAA8APwAB +AAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAIAAAAPAD8AAQAAACIWAACAAAADAAABWQAA +JBYAAQAAAAMAAAFaAAAmFgACAAAABAAAAVoAACgWAAIAAAADAAABWwAAKhYAAoAAAAMAAAFcAAAs +FwAAAAAABAAAAVwAAC4XAACAAAADAAABXQAAMBcAAQAAAAMAAAFeAAA0FwACAAAAAwAAAV8AADYX +AAKAAAADAAABYAAAOBgAAAAAAAQAAAFgAAA8GAABAAAAAwAAAWIAAD4YAAIAAAAEAAABYgAAQBgA +AgAAAAMAAAFjAABkGwACAAAAAwAAAW8AAWYbAAKAAAADAAABcAABaBwAAAAAAAQAAAFwAAFsHAAB +AAAAAwAAAXIAAW4cAAIAAAAEAAABcgABcBwAAgAAAAMAAAFzAAJ0HQAAAAAABAAAAXQAAnYdAACA +AAADAAABdQACeB0AAQAAAAMAAAF2AAJ8HQACAAAAAwAAAXcAA34dAAKAAAADAAABeAADgB4AAAAA +AAQAAAF4AAOEHgABAAAAAwAAAXoAA4YeAAIAAAAEAAABegAEiB4AAgAAAAMAAAF7AASMHwAAAAAA +BAAAAXwABJEfAAFAAAADAAABfgAElR8AAwAAAAQAAAF/AAWXHwACwAAAAwAAAYAABZkgAABAAAAD +AAABgQAFnSAAAUAAAAMAAAGCAAWfIAABwAAAAwAAAYMABaEgAAMAAAAEAAABgwAFpSEAAEAAAAMA +AAGFAAWkugEAAAAAAKS6AQAAAAAApLoBAAAAAACkugEAAAAAAKS6AQAAAAAApLoBAAAAAACkugEA +AAAAAKS6AQAAAAAAzLMBABgAAACUtQEAIAAAAHy8AQAUAAAAeL0BABQAAAAAugEADgAAALi4AQAO +AAAA0LkBABQAAADQuQEAFAAAAEAjQCUhISEhQEBAQEAFBAQBAUBAQEAFBUBADAxADQwMAQEBBUBA +BQUABAAEQEAABEBAQAVAQEBAQAVAQEAFBQUBAQEBQAUFBQEFAQFABQUFQAVABQUFBQUAAAAAAAAA +AGQAAAAAkAEACgAAAET0AQAE+QEALPYBAOzwAQDs/QEAEAECAAz7AQDQ9wEAtPwBAAQAAAAcEQAA +HDIAABwzAAAEAAAAHBUAABwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAKXGhPiZ7o32Df+91rHeVJFQYAMCqc59VhnnYrXmTZrsRY+dH0CJh/oV +7+uyyY4L++xBZ7P9X+pFvyP3U5bkW5vCdRzhrj1qTFpsQX4C9U+DXGj0UTTRCPmT4nOrU2I/KgwI +UpVlRl6dKDChNw8KtS8JDjYkmxs93ybNaU7Nf5/qGxKeHXRYLjQtNrLc7rT7W/akTXZht859e1I+ +3XFelxP1pmi5AAAswWBAH+PIee22vtRGjdlnS3LelNSY6LBKhWu7KsXlTxbtxYbXmlVmlBHPihDp +BgSB/vCgRHi6JeNL86L+XcCAigWtP7whSHAE8d9jwXd1r2NCMCAa5Q79bb9MgRQYNSYvw+G+ojXM +iDkuV5PyVYL8R3qsyOe6KzKV5qDAmBnRnn+jZkR+VKs7gwvKjCnH02s8KHmn4rwdFnatO9tWZE50 +HhTbkgoMbEjkuF2fbr3vQ6bEqDmkMTfTi/Iy1UOLWW632owBZLHSnOBJtNj6rAfzJc+vyo706UcY +ENVviPBvSnJcJDjxV8dzUZcjy3yhnOghPt2W3GGGDYUPkOBCfMRxqszYkAUGAfcSHKPCX2r5rtBp +kRdYmSc6uSc42RPrsyszIrvScKmJB6czti0iPJIVIMlJh/+qeFB6pY8D+FmACRca2mUx18aEuNDD +grApd1oRHst7/KjWbTosAAECBAQAAAAEDAwIBAwEBEAAAACAAAAAAAEAAAACAABAAAAAAAQAAEAA +AABAAAAAAPBhAAABAQIBAgIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAACoAAAAOAAAA +AAABARw/AgAoPwIAND8CAEA/AgBIPwIAUD8CAAEBAAECAQEBAAAAAAEAAAAAAAAAAAAAAAAAAAAB +AAAAAAAAAAEAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAAAA +AAD/////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACADQAAACAA +AIANAACADQAAACAAAIANAAAABgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAIAvAgAgIIAPAABAAGkgAABpIEAAaSAA +AGkgQAAgIIAPAADoAGkgAABpIEAAaSAAAGkgQAAgIIAPAABw6GkgAABpIEAAaSAAAEogAABKIQAA +SiIAAEojAABKJAAASiUAAEomAABKJwAASiAAEEohABBKIgAQSiMAEEokABBKJQAQSiYAEEonABBK +IAAgSiEAIEoiACBKIwAgSiQAIEolACBKJgAgSicAIEogADBKIQAwCiSAP4EAAEBBLJwwQCycMEIk +HDQKIoA/gAAIWQojADeuC8AGSiYAcGkgQABKJgBwSiYAcEomAHBKJgBwABYAcIAAoB1AeCAgQIcA +AAAAAAAAAAAA/ByItvwcSLb8HAi2/BzItfwciLX8HEi1/BwItfwcyLT8HIi0/BxItPwcCLT8HMiz +/ByIs/wcSLPgfuB4BNw43TXw4HgE3DTdM/DgeATcMN0x8OB4BNws3S/w4HgE3CjdLfDgeATcJN0r +8OB4BNwg3Snw4HgE3BzdJ/DgeATcGN0l8OB4BNwU3SPw4HgE3BDdIfDgeATcDN0f8OB4BNwI3Rzw +4HgE3ATdGfA0FBowMBQZMCwUGDAoFBcwJBQWMCAUFTAcFBQwGBQTMBQUEjAQFBEwDBQQMALHAcaw +JE0zsCQfM+B+4HjgeOB44HjgeOB4CiSA8AUgRADgIMEHRCT+gEEqxACEAAIALyQC8UIhAQFCIAMB +6CCiBAQRBAIEEQUCBBEGAgQRBwIEGwgBBBtIAQQbiAEEG8gBLAAlAEQiPoE8ACIARCL8gEAhwQDg +IMEHQCPDAKgggAEBEYQCARsKASAgwAcEEQQCBBEFAgQbCAHUB+H/BBtIAUQi/IAEEQQCyQfv/wQb +CAFCIUEAQiBDAKgggAEBEYQCARsKASAgwAfPcaAArC8YgZq4GKHpBKAQBdjgeM9xoACsLxiBs7i6 +uBih1QSgEGTYCiJAgADZ7gABAC8mAPBKJkAATgAGAE8AIACKJf8P4HgKIkCAANnOAAEAbAAkAC8m +APBcAAUAKwg1CEomQAAIcQDYAiG+gOAgxQdCeQHgAiG+gOAgxQdCeesH7/8B4C8tAQBAJUUAAiZ8 +8QAAIAAAKEAB6CBiAy8gAIAvIUsAAiG+gMAghgHCIYYA4H4RACAASiAAEEogQBAOIkIALyALEs4g +RYCKJf8PCAAFAC8tAQBAJUUAAiZ88QAAIAAAKEABSiZAAOggIgMvIACALyFLAAIhvoDAIIYBwiGG +AEomAABCIP6QziCCAUQgfpDOIYIB4H4JAAAA4HgKJgDwiiC/D8ogZADgfy8gAwDgf4og/w/8HIix +/BxIsfwcCLHhw+HC4cHhwAfAHBzAMeHA4H8BwPHAFg3P/wh2WnIBiUCJELgYugd6AokIuEd4Q4kH +egCG4oYHIIcARYkEiRC6GLhHeEaJCLpHeEeJB3oBhqOGByCIAAiJSYkYuBC6B3oKiQi4B3oLiUd4 +TYkHfwyJELoYuEd4TokIui+JR3gneAd9SiNAIV7w3gqgBQDZCHfqcNYKoAUB2Qd/6HDKCqAFAtkH +fwlwwgqgBQPZIIbneAchBwBBKwAGrgqgBQDZCHMpcKYKoAUB2Qd7SXCaCqAFAtkHe2lwkgqgBQPZ +IYZneAchCABBLgAmfgqgBQDZCHMKcHYKoAUB2Qd7KnBqCqAFAtkHe4hwYgqgBQPZ4oZneAd/QS0A +FlIKoAUA2QhzinBGCqAFAdkHe8hwPgqgBQLZB3uqcDIKoAUD2aOGZ3gHfUEvAAYiCqAFANkIc0Et +ABQPeBYKoAUB2Qd7QS8AEg94BgqgBQLZB3svIAcC+gmgBQPZJIZneAchBQBBKAAW6gmgBQDZCHNB +LwAED3jaCaAFAdkHe0EtABIPeM4JoAUC2Qd773jCCaAFA9lneGWGB3tBLwAWsgmgBQDZmHBBKAAU +D3imCaAFAdkHJAQAQS8AAg94lgmgBQLZByQEAK94igmgBQPZJoYHIAABByEWAEEtABZ2CaAFANkI +dUEvABQPeGYJoAUB2Qd9QSgAEg94WgmgBQLZB30vIMcBTgmgBQPZp3inhkIjU6BBLQkEQSsQBAd9 +IOZBLRcUQS4AIi8gxxBBLQoSLyOHFUEtAQIvJEcDQS4UJEErAgIvJUchLyfHJS8nBwAvIUcSLyKH +Ei8gByQvIUcgLyQHJS8mhwBBLQAGBPXmCKAFBNkEII8PAP8AAOpw1gigBQTZ/9kQuSR4B3/ocMYI +oAUE2f/ZCLkkeAd/CXC2CKAFBNkPeCCG53gneEEoAQYAGkIgQSgBBAEaQiBBKAECAxoCIAIaQiBB +KwAGhgigBQTZBCCDDwD/AAApcHYIoAUE2f/ZELkkeAd7SXBmCKAFBNn/2Qi5JHgHe2lwVgigBQTZ +D3ghhmd4J3hBKAEGBBpCIEEoAQQFGkIgQSgBAgcaAiAGGkIgQS4AJioIoAUE2QQggw8A/wAACnAa +CKAFBNn/2RC5JHgHeypwCgigBQTZ/9kIuSR4B3uIcPoPYAUE2Q94IoZneCd4QSgBBggaQiBBKAEE +CRpCIEEoAQILGgIgChpCIEEtABbKD2AFBNkEIIMPAP8AAIpwug9gBQTZ/9kQuSR4B3vIcKoPYAUE +2f/ZCLkkeAd7qnCaD2AFBNkPeCOGZ3gneEEoAQYMGkIgQSgBBA0aQiBBKAECDhpCIIEB7/8PGgIg +4HjxwE4Jz/+eCSAACHUA2SjYFSVCEBUlAxDAg+CCwKLgo8GD4YLBouGjwoPigsKi4qPDg+OCBOFk +uMOi2QkigOOjCdsEhRDlOLheD2AFBNkPeBoPYAUA2Qh2AIUwuA94Sg9gBQTZD3gGD2AFAdkHfgCF +KLgPeDIPYAUE2Q947g5gBQLZB34AjSIPYAUE2Q943g5gBQPZx3gApQGFOLgKD2AFBNkPeMYOYAUA +2Qh2AYUwuA949g5gBQTZD3iyDmAFAdkHfgGFKLgPeN4OYAUE2Q94mg5gBQLZB34Ejc4OYAUE2Q94 +ig5gBQPZx3gBpQKFOLi2DmAFBNkPeHIOYAUA2Qh2AoUwuA94og5gBQTZD3heDmAFAdkHfgKFKLgP +eIoOYAUE2Q94Rg5gBQLZB34IjXoOYAUE2Q94Ng5gBQPZx3gCpQOFOLhiDmAFBNkPeB4OYAUA2Qh2 +A4UwuA94Tg5gBQTZD3gKDmAFAdkHfgOFKLgPeDYOYAUE2Q948g1gBQLZB34MjSYOYAUE2Q944g1g +BQPZYbuA48d4rgbt/wOlGQDP//HArg+P/2GJQIkQuxi6Z3piiQi7Z3pjiQDfZ3pAoESJZYkYuhC7 +R3tGiQi6R3tHiWd6QaBIiWmJGLoQu0d7SokIukd7S4lnekKgbYlMiRC7GLpnem6JCLsviWd6Ct0n +ekOgw4AIc0EuABQPeJoNYAUE2SCDBCCADwD/AAAHIQQAQS4AEg94gg1gBQTZBCCAD/8AAAAHJAQA +z3huDWAFBNkEIIAPAAAA/wckBABBLgAWVg1gBQTZD3jPcYAAwFjwIcEDByAAASd4IYMEoyd4IoMF +oyd4I4MGo2G9J3gHo0AjAASDDXWQAectB4//4cUIdRHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HhhvYwl/5/t9eB/wcXgePHA4cXPcIAAXB9NgM91gAA4kyCFt7q4ugQhgQ8DAAAAB7lF +eS2gggpgEADYAIXPcYAACM5RIICCTInPcIEAUBEyajZ5x3GBABAOYIFWeEGABfKVu2Chq7oE8LW7 +YKGLukGgC42juKEGr/8LraLB8cAeDo//RcHPdYAAXB8nhRUIQQAwlRQUDjEJDkEQWR2CENAVARYd +CEEAz3GAAGgiPJEUFA0xDQ1BEM9xgADAIlmpi+rPdYAAnAnBjYDmANnKIEEAJPIhrQsKkQMB2B7w +QSgNAgd9QSgBBKd5z3eAAJwJoI9TJUURHw0yBMa5CiHAD+tyz3AAAM0bn9sRBSABiiSDDw8NnhEA +2Azc7wWP/892gQDQEBYmTRGnjaCvyXUWJU0RAKUUFAAxRq3HcYEAkA0CtQCJB60AGUIBABtCAcfx +8cBKDY//CMjPcqAAyB8OGhiACcgPGhiACsgQGhiACxIBNgLIJHgRGhiADMjPcYAAkDQtGhiAAIEB +4AChw7hXCFEDC8h/2Qq5JHgvKAEATiCCBwDYDyCAAAQhAYBCIo0CGfILI0DAF/TPcKAAiCDwIFAD +z3aAAJwwAIbPd4AAoDANDQEQAIcScJAMAQagpgAfABQdBY//4HjPcYAAnFjgfwhh4HjxwL4IQAXP +cYAALBnwIQAAQHiA2c9woADQGzCg0cDgfoDhyiRNcOggbQLPcaAAUAwlgQEYUgDgfvHAbgyP/89w +gABcHwOAGIilwUogACAdCBEBCiHAD+tyiiCMDWTbCiQABMUDIAG4c891gACsLs9wgAAcO5YIoA4k +HQAUz3CAADg7igiADs9wgADgO34IgA7PcIAA/Dt2CIAOz3eAAGiabY+A457yTI9QczgBDADPcIAA +0B0EgCCAz3CAAIiQQKBhoCKgz3CBAHgWCJApCwIAz3CBAHgWz3GAAIDLaLAB3s9wgABoy8yhI4AN +CeUAARgCBGOgEI+A4MogYgADpRGPE+iT6s9wgABcHwOACYAbCJ4A6g4gAgfYAdgBpc9woAAsIBCA +AKXPcIAAJCsAgB0IUQDPcIEAeBbPcQAAECcKDa//BYAQeAPwANjPcYAAEMsHsQOFDBkEBGMIUQAA +gYLgzCDigAP0AdgAoUwVgBBPCFEAz3CgACwg0IDPcAEAfBZAwAHYQcAIHAA0EdhDwADYjLhEwADY +ENkE2ghzmHC4cAAmhx8AAAB9HgqgBNhwSxWAEAHgD3hLHQIQDI+F6AGFgODwCsEEz3CAAIw7Pg9A +DgHZz3CAABQWIKAiDiACBtgpA6//pcDgeKLB8cC+Cq//mHJFwUEoAQIHeUEoAgQnesa6z3WBAJAN +SWVdZScJ3wEUFA4xz3OBANAQaHI2euCCCwjBA+KSEw+AEyeKp2rvCd6BANgn8MaKhu6A389wgACc +CeGoz3eAALAfBY8LDgEQgNgFrwnwz3eAAMAiGY8LDgEQgNgZr8aKNnsAHIADB4qHuQCtz3CAAJwJ +QIggqAHYR6sM3I8Cj/+hwfHAAxICN9dyAAAAQAHawiKKABe6x3IADgAAg7rsc0Cj7HIAom4LIAQo +cNHA4H+hwOB4peAt8hH2YwiQCITgJfIH9i/oZwjRAOB/ANg3CFABWwgRCOB/C9iMIEOHG/LM4Bvy +reAR8gf2NwiQCT8IEQrgfwrYMwgQDDMIUQ/gfwPY4H8B2OB/AtjgfwTY4H8F2OB/BtjgfwfY4H8I +2OB/CdjgfwzY4H8N2A7Y4H7gePHA4cXPdYAARCmpcEAlgRu+COANLtoB2NEBr/9hHQIQ8cBKCY// +Hwi0AAh1CiHAD+ty/diLuHPbSiQAALEAIAG4c893gABEKTeHACWQH4AAmCkPDUEQDBCAIIDgjPJ+ +D2AHBdg6cEQtvhsAJ0AeQJAhkADeCLpFec9ypAC4PZsaWAAikAwYgiPKGlgAI5C3p8saWAAkkMQa +WAAlkMYaWAAmkMcaWAAnkMIaWAAokMMaWAApkMUaWAAKkKMaGADPcIAAcCYggGB5yXA3CBADz3CA +AHAmIIBgeclwJwgQBM9wgABwJiCAYHnJcBcIUATPcIAAcCYggGB5yXAJCJEEAN3PcIAAXB8DgAiA +z3GkALRFIQgeAEQtvhsAJ0AebJBLkHt7ZXpTGZiADZBUGRiABvBTGZiDVBmYg0Qtvhsndw6XVhkY +gA+XWBkYgBCXVRkYgBGXVxkYgBKXWhkYgBOXXBkYgBSXWRkYgBWXWxkYgHoLYAcqcFUAj/+G4PHA +ANgP9M9wgACEmmYL7/8G2c9xgAD4nQCBgrgAoQHY0cDgfuB48cCD4OHFANgY9M91gABomkAlABU2 +C+//A9nPcIAAXB8DgBSQNY0TCQAAz3GAAHzNH4GNuB+hAdgRAI//8cCB4OHFANgJ9M9wgAB/mgHd +/grv/6lxqXD1B0//4HjxwJbg4cUA2Iz3z3WAADiTqXDeCu//BNkLjYO4C60B2M0HT//xwJrg4cUA +2Iz3z3WAADiTBG26Cu//BNkLjYK4C60B2KkHT//xwDIPT/+jwc92gACgsSaOQCYNEgK5NHmO4D1l +ANgl9Itwhgrv/wzZAhSAMJzoENnPcIAA2AkgsASOJG0ArSDAAa0DFIAwAq2BwPYOoA0C2kaOAeJP +eieORiLAAMG6Rq4leAeuAdg5B2//o8DxwKTBkOAA2cogQgAT9ItwKgrv/xDZABQAMYTgzCBigQj0 +z3CAAHzNH4AJCF4FTHAB2KTA0cDgfoHgANnKIEIAFPTPcKAAUAwlgM9zgACgfQGTL3kTCQAAz3KA +ANgJAJIhs4G4ALIB2OB+4HjxwE4OT/+G4ADYKfTPcIAA0B0EgM93gACgsVYnERIAgFIXDREPp4Pl +yiUmEL5l1H4AIZAjCnCaCe//BtkidgGWCugAEIAgCOjPcYAA2AkAkYa4ALFSH0QTAdhVBk//4HiA +4ADYCPTPcYAA2AkAkYK4ALEB2OB+4HjxwNoNT/8Id89wgABcHwOAGIgacY0IEAGE5wDdhgAlAMog +RQPPdoAAaJpAJgATKgnv/wTZLo6wrlMhAAARrkEowCCguV0IZAACIEIAY79VCsUDD+rPcaAA0A8Q +EQCGYbpYYBAZGIAlEQCGD3gC8A+OANlTIIIgDyGBACR4LyYH8M9xnwC4/xCuGIHPIOIH0CDhBxih +GIGeuBihGIG+uBihAdidBU//4HjhxPwcyL78HEi+4cDhweHC4cP8HAix/BxIsfwciLH8HMix/BwI +svwcSLL8HIiy/BzIsvwcCL9qJIAQ4cRqJMAQ4cTxwM9woADQGxSAz3GAAIwIBCCAj89RBOEAoRHy +LykBAA8IngUvKYEPQAAAAM9wgADUJfAgQABAeHIPj//RwMHEayTAEMHEaySAEMHEn3QEFAs0BBQK +NAQUCTQEFAg0BBQHNAQUBjQEFAU0BBQENMHDwcLBwcHAwcRFLH4QCiZAfsHEaySAFMHEICBAh+B4 +jCBcggHY4H/CIAsA8cBeDG//SiRAAM91gABcHxUlAxAAg0AlDhXRcMIkAgHwJQ0RyBUFFkQlvoEJ +8gohwA/rco7YjbidA+AAdNvIEA0GpXnIGFgAoIMG2UZ5yBUAFiR4yB0YEACDyBAABoYgf44wDgEQ +ZQRP/+B48cDuC2//gNoIdyh2BIFAJg0WI7hTIEEBOGUBGJIATiHCDx0KNQIA2coLAAHJcGoIIACp +calwANk42gPwaLq2CwABBIYUpgWGFabJcEoIIACpcclw6XH2CqANENrJcADZkgsgAQTa8QNP/+B4 +z3FFZwEjIKDPcc3viashoM9xupj+3CKgz3EyEHZUI6AA2SSg4H8loPHAWgtv/5hwYIAMEAYAQoCh +gOKBByaAAKR4ByCOAQCBx3cgJNtwAiCAD5UoiFvYYBtjF2s5u2V4ByJDA7hgBHsHI44AYYECI4MP +OBeqSH5mwHZALgMTNL7FewclDhAbY2R+p37+ZtpiQCpOBOOBL7rFegcjDgB6YkR+B34CJ48fQj4S +Mf5m3WVALY4VKr3kgcV9ByOOAF1lpH5nfgInjx+DClHw/mbYYNdo5YE5uMV4ByJOA7hgBH5Hfsd3 +h0cqxv5m22NAKw4D5oE0u8V7ByUOEBtjZH6nfgInjx/PV+25/mbaYkAqTgTngS+6xXoHIw4AemJE +fgd+AiePH7kC/2r+Zt1lQC2OFSq96IHFfQcjjgBdZaR+Z37Hd4Bp2Jj+Zthg12jpgTm4xXgHIk4D +uGAEfkd+AiePH7t0UQj+ZttjQCsOAzS76oHFewclDhAbY2R+p34CJ48fAABPpP5m2mJAKk4EL7rr +gcV6ByMOAHpiRH4HfgInjx+jdkIo/mbdZUAtjhUqveyBpX4HI40AXmbEfWd9x3eQayIR/WW4YLdo +ObjtgaV4ByKNA9hgBH1HfQInjx9nAm2O/WW7Y0ArDQM0u+6BpXsHJg0QG2Nkfcd9AiePH4ZZcrz9 +ZbpiQCpNBC+6RX19ZQcjAgCkejwRBQAHIg8AACWCD7RJIQj6YtpiQCqOBSq6xXrhgbpiByWOEGR+ +p34CJ48f4Qme2v5m2GDVaDu4BX7mgV5mByKAA6R4R3gCJ48fvz/ATPhgeGBAKEMCN7gFe+uB22MH +I4ADRHjHeMd3XiZRWvhguGBAKI0DMrgFfeCBfWUHI0ADxHhneAInjx9JFlY4+GBYYEAoAgUsuEV4 +5YG4YAclAhBkeqd6AiePH9Apo+/6Ytpi1Wo7usV66oEaYgcgjgCkfgd+x3dEAlMU/mbbY0ArTgI3 +u2V+XmYHJoMQBHsHI48AAiWDD14nfxn7Y31lQC2DEzK9ZX3kgd1lByZDE0R7x3sCJ48fLBg4BPtj +eGBAKAMFLLgFe+mBu2MHJcAQxHineMd34SHmzfhgWGBVaDu4BXp6YgcjgACkeDgRBwAHIM8AAieA +D8g8Kvj4YNhgQChOAje4xXjjgVhgByCOAGR+R34CJ48fKgt58v5m3WVALY4T6IEyvaV+HmYHII0D +RH0Hfcd3WkXtFP1lu2NAKw0FLLtlfe2B3WUHJkMTBHvHewInjx8cVvsW+2N6YnVq4oE7umV6umIH +JYMQxHunewInjx8QAwhc+2N4YEAoQwI3uAV754FbYwcjgACkeEd4x3dvZ9kC+GDYYEAojgMyuAV+ +7IF+ZgcjgANEeGd4AiePH9VydrP4YLhgQCgNBSy45YGleNhgByYNEGd9AiePHwUAvsb9ZbpitGro +gTy6pXoaYgcgjQDHfQInjx+OeH8J/WW7Y0ArzQLrgTW7ZX1dZQclgxAHe8d3nW0iYftj22NAKw4E +MLvFe7tjByXPEEd/AieODxoC9Mf+ZthgQCjOBSm44YHFeHhgByMOAKd+AiePH0FbvBXfZ/pi1Grk +gTy6RX4eZgcgggNnesd33kupz/piumJAKs0C54E1ukV93WUHJYITB3oCJ48fRAmgtF9n+2NAKwIE +6oEwu0V7u2MHJcIQx3oCJ48fQEGQQ19n+GBAKMIFKbjtgQV6emIHI4AAp3jHd5soxn74YNhg1Gg8 +uOCBBX5eZgcigANneAInjx9eFQbY+GC4YEAozQI1uOOBBX3dZQclgBNHeAInjx8QK3vP+GB4YEAo +AwTmgTC4ZXi4YAclAxDHe8d3iAQFHftjemJAKsMF6YEpukV7G2MHIMIAp3oCJ48fKybHL/pi2mLU +auyBPLrFenpiByOOAAd+AiePHyQZG2b+Zt1lQC3OEjW9xX1dZQcljxBnfwAljg+iH/h8/mbYYEAo +DgQwuOKBBX6+ZgclgBNHeAInjx9TO5up+GB4YEAowwXggSm4ZXiye9hgBXvHewInjx/WC7zd+2N6 +YnZq54E6ukV7G2PSemV6B3rHdypDl//6YrpiQCqNAu6BNrpFfRJ6fWWlemd6AiePH2tUWdz6Ytpi +QCrOA+WBMbrFenJ+umJFfqd+AiePH2wDx1/+ZthgQChOBSu47IHFeFhgsn4Ffkd+x3dbZcNZ/mbb +Y9ZrOrvjgWV+UnseZsV7B3sCJ48f83BuM/tju2NAK40C6oE2u2V9EnvdZaV7x3sCJ48fEACDC/tj +emJAKsMD4YExumV60nu6YkV7p3sCJ48fe3ovon9n+GBAKEMFK7jogQV7snhbY2V4R3jHd6hvT374 +YNhg1mg6uAV+Unh+ZsV4Z3gCJY8P0wEgGR9n/WVALYAS5oE2vaV42GByfQV9x30CJ48f/lzsvL9n ++mJAKs0D7YExuqV60n0aYkV9B33HdwhOoRG/Z/tj5IFAK00FK7tlfRJ7XWWle0d7AiePH6wIfoH7 +Y35m64F2bjq+xXtSfrtjZX6nfgInjx/FQssN32f4YEAojgI2uOKBBX6yeCmBfmbFeGd4x3fXKrvS +H2f6YkAqwAMxugV6cnjaYkV4AiGBD3kUbyzHeBlhuWFAKUAFK7kFeQAUDQBZYbtjABzAAAQUAwB5 +YQQcQAAIFAEAWWEIHEAAACaBAw0EL/8MHEAA4HjxwJILD/8Idkh1RIAodxYiQQMkoAsJpQAFgAHg +BaZBLUEXOGBBKsEAUyFBgQWmQCYQFh/yQNwOIRED6XA9DWQUAnG2CmANKnLJcPoPr/8KcSJ3AiVN +FA3wngpgDUDayXDiD6//QCYBFkDngiUBEMDl6XBAJgEWcvd+CmANqXJ1Aw//4HjxwM9wgADEJQCA +G+jPcIAAVCYAgJnopggADYnoC8gFIIAPAAAAPAsaGDCWCAANiegLyAUggA8AAADUCxoYMAvIkLgL +GhgwngqABdHA4H7gePHAxgov/2d6z3WAANwJoIUVJU0RwIVEeWd5QyjABkMuDxIEJ48fAP8A/0Mu +DhYEJo4f/wD/AOV+wKXZYcdxglqZee0CL/84YPHAfgov/5hwQCVNA892gADcCcCGw73wJk8TQCUN +AsO98CZNE+d9QCWPAMO/8CbPE1MlwAAVfgCG531nekR5p3hDKMAHAKZneRlhx3GCWpl5QyzABpEC +L/84YOB48cAiCi//mHBAJU0Dz3aAANwJwIbDvUAlDwLDv/AmzxPwJk0T531AJY8Aw7/wJs8TUyXA +ABV+AIbnfUd5Z3kHfUMtwBcAphlhx3HZbqHrQyzABjkCL/84YPHAygkv/5hwQCVNA892gADcCcCG +w71AJQ8Cw7/wJk0T8CbPE1MlwACnf0AljQDDvfAmTRMVfgCG532neAUiTQBEeaR7QyjAB2V5GWEA +pgIhgQ/kcCRDQyzABtkBL/84YPHAagkv/5hwQCVNA892gADcCcCGw71AJQ8Cw7/wJs8T8CZNE+d9 +QCWPAMO/8CbPE1MlwAAVfgCG531HeWd5B31DLcAXAKYZYQIhgQ+dNSo+QyzABn0BL/84YOB44cUB +289ygAAICH6y4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeAa4RSDNAM9woADsJ6agCoAA2wCxfrLgf8HF4HjxwHYKgAJSDoAPBgyA +D4DZz3CgANAbMKDRwOB+8cB+CA//GnAB3wAQEgET8Fp1EfAVIMAjoJACEBEBAefXdQAA+//wf3T2 +GQqALwAA///PcAAA+//dCIGEnQAP/892gADIHQCGAeAAphUIUQAB2c9woADIHDGgmg6gDyhwBr2B +vUApACSleM9xoADsJwahAIZCIECAAKbd9c9xoADIHADYEaHX8fHAz3CAAAAoAICB4Mohwg/KIsIH +yiCCDwAArxPKI4IPAADzAcokIgBUB2IAyiUCARoIAADRwOB+8cBODQAPSgrADNHA4H7gePHAtg/P +/s9wgABcHwOAKIDPcIAA5LTAuTZ4JIAAgAq5BCGBDw8AAPzJuCV4z3GnABRIDaEOCOAGocEacM9x +gADIHQCBAeAAoRUIUQAB2c9woADIHDGgzg2gDyhwi3FSDu//QtjPcAgAhxDPc6AA7CcGowLZANiY +cAomAIH4cQ94yiZiAADeBbgQuIG4h7iMuAajBNifcMl3qCAADGG4QCiBIUAuQgE6YrhwFXqAJYIN +x3KAACC1IpIvJUgBQC2NAYG9PHkQuaV5JqMiksC5GHnFeTB+o5K4cIAlQg8vJUgBQC2BAbx9gbkQ +vaV5JqMjksC5GHnleTB/EL4FJo4fAAACL8ajEL8FJ48fAADCMOajQidBAGMJdYBAJEAAABQAMRC4 +gbiHuIy4BqPPcIAAyB0AgM9xgADIHUIgQIAAoQf0z3GgAMgcANgRodEG7/6hwPHAANiNuKII4AsG +GhgwDMyGIP+KCPLPcIAAlDAAiIDgOA/CA9HA4H7xwM9xAwBADc9woACoIC2gz3GgAKwvGYHwuBmB +C/IEIIAPCAAAANdwCAAAAAHYwHgG8IYgfw+C4AHYwHjPcoAASAoggmFpjOjPcIAAkAgBiIboYKIu +DuAFSNgD8GCiz3KAACQ5BoIDgCCAx3EAAIgTogrgDUhw0cDgfuB48cC6Dc/+z3GAAOxBIYGjwULB +z3GAAFwfFSEQAAAQACDAEA4GLyiBA04gjQevDhAQEm0WeAAgkg+BABAOBhKAIM9xgQDQEBZ5AIEi +kY7lCBxEMMogYQAG8otyrgpv/wLBNugA2M9xgABoCUCBDyBAAy8hCiAEIYCgAKEH9IDi6A0iB8og +IgiveKoO4AMQ2QDfBBrEI4ohCAAAGkAgqXDpcdIIYAYP2gAQAiDAEgAGBCBABMAaGADPcIEAUBG2 +eOCg4aDPcIEAcA20eOCwECZOky8ogQNOII0HrPU9Be/+o8DxwOHFCHUE8D4JwA2eCeANqXD86EkF +z/6jwULCCRSAMIHgAdjAeBC4AeDgf6PA4HijweB/o8DgePHAogzP/r7BOnFacoh2CiBAIeh1l8fp +cF4JoADQ2QPYYcAFHII0CwoRIAndPvAlClAgUwqQIAohwA/rcs9wAACxDcvbCiSABOEDYABKJQAA +lBQAMQYcgjNAKIEhCxxCMwccAjBIuGLAQCmAIIG4JXgQeQkcAjBIuQocQjBIvWPF1fGcFIAwQCkB +Iwu4BXkweEi4BxwCMJgUADEGHEIwBt1iwEi4CRwCMHYUgTCIxslwuWEweWYJoAAA2kTHRcaBwEbA +HBxEM14LoACEwDEE7/6+wOB48cDhxaPBAN1AxUHCQsMC2qlzmHW4ddh1Fg/v//h1NQTv/qPA8cC2 +C+/+QCEDBaLBCHcodUokAHIA2agggASE4W8gCwDwIwIAUyFOAE4mwBADuBl6ACRAMECoAeHPdoAA +fECpcMlxBPCpcCJubglgAAHaBYWGIPgBjCAHgPb1i3apcMlxVglgAAjaSiQAdQDYqCDAA0EogQDw +JUEQUyBDAE4jwgADull5HGcgrAHgqXAA2S4LoAAE2slwANkiC6AACNqBA+/+osDPcUVnASMgoM9x +ze+JqyGgz3G6mP7cIqDPcTIQdlQjoM9x0sPw4SSgANkmoOB/JaDxwOIK7/4ZcM9wgADcCSCgABAO +EAQQDxAIEAcQDBAGEMlwEBAEEOlx6HLIc/IPr/9KJQAAACANAUMviRCpcMlxKXLocwokgAHWD6// +SiVAAMBw2HBDLooQqXFJcilzCiTAAb4Pr/9KJYAAACDOAUMthxDJcMhx6HJJcwokQAKiD6//SiXA +AAAgTwJDLokA6XDJcSly6HMKJIAChg+v/0olAAFBcNhwQy6KEOlxSXIpcwokwAFqD6//SiVAAQAg +zQFDL4cQqXDIcehySXMKJEACTg+v/0olgAEAIE4CQy6JAMlwqXEpcuhzCiSAAjIPr/9KJcABQXDY +cEMtihDJcUlyKXMKJMABGg+v/0olAAIAIM8BQy6HEOlwyHHocklzCiRAAv4Or/9KJUACACBNAkMu +iQCpcOlxKXLocwokgALiDq//SiWAAkFw2HBDL4oQqXFJcilzCiTAAcYOr/9KJcACACDOAUMthxDJ +cMhx6HJJcwokQAKqDq//SiUAAwAgTQJDLokAqXDJcSly6HMKJIACjg6v/0olQANBcNhwQy6KEKlx +SXIpcwokwAF2Dq//SiWAAwAgzwFDLYcQ6XDIcehySXMKJEACWg6v/0olwAMAIE0CQy6JAKlw6XEp +cuhzCiSAAoYOr/9KJQAEQXDYcEMvihCpcUlyKXMKJMABag6v/0olQAQAIM4BQy2HEMlwyHHocklz +CiRAAk4Or/9KJYAEACBNAkMuiQCpcMlxKXLocwokgAIyDq//SiXABEFw2HBDLooQqXFJcilzCiTA +AXYOr/9KJQAFACDPAUMthxDpcMhx6HJJcwokQAJaDq//SiVABQAgTQJDLokAqXDpcSly6HMKJIAC +Pg6v/0olgAVBcNhwQy+KEKlxSXIpcwokwAEiDq//SiXABQAgzgFDLYcQyXDIcehySXMKJEACBg6v +/0olAAYAIE0CQy6JAKlwyXEpcuhzCiSAAuoNr/9KJUAGQXDYcEMuihCpcUlyKXMKJMAB0g2v/0ol +gAYAIM8BQy2HEOlwyHHocklzCiRAArYNr/9KJcAGACBNAkMuiQCpcOlxKXLocwokgAKaDa//SiUA +B0Fw2HBDL4oQqXFJcilzCiTAAX4Nr/9KJUAHACDOAUMthxDJcMhx6HJJcwokQAJiDa//SiWABwAg +TQJDLokAqXDJcSly6HMKJIACRg2v/0olwAdBcNhwQy6KEKlxSXIpcwokwAEuDa//SiUACAAgzwFD +LYcQ6XDIcehySXMKJEACEg2v/0olQAgAIE0CQy6JAKlw6XEpcuhzCiSAAvYMr/9KJYAIQXDYcEMv +ihCpcUlyKXMKJMAB2gyv/0olwAgAIM4BQy2HEMlwyHHocklzCiRAAr4Mr/9KJQAJACBNAkMuiQCp +cMlxKXLocwokgAKiDK//SiVACUFw2HBDLooQqXFJcilzCiTAAYoMr/9KJYAJACDPAUMthxDpcMhx +6HJJcwokQAJuDK//SiXACQAgTQJDLokAqXDpcSly6HMKJIACqgyv/0olAApBcNhwQy+KEKlxSXIp +cwokwAGODK//SiVACgAgzgFDLYcQyXDIcehySXMKJEACcgyv/0olgAoAIE0CQy6JAKlwyXEpcuhz +CiSAAlYMr/9KJcAKQXDYcEMuihCpcUlyKXMKJMABPgyv/0olAAsAIM8BQy2HEOlwyHHocklzCiRA +AiIMr/9KJUALACBNAkMuiQCpcOlxKXLocwokgAIGDK//SiWAC0Fw2HBDL4oQqXFJcilzCiTAAeoL +r/9KJcALACDOAUMthxDJcMhx6HJJcwokQALOC6//SiUADAAgTQJDLokAqXDJcSly6HMKJIACsguv +/0olQAxBcNhwQy6KEKlxSXIpcwokwAGaC6//SiWADAAgzwFDLYcQ6XDIcehySXMKJEACfguv/0ol +wAwAIE0CQy6JAKlw6XEpcuhzCiSAAmILr/9KJQANQXDYcEMvihCpcUlyKXMKJMABRguv/0olQA0A +IM4BQy2HEMlwyHHocklzCiRAAioLr/9KJYANACBNAkMuiQCpcMlxKXLocwokgAIOC6//SiXADUFw +2HBDLooQqXFJcilzCiTAAfYKr/9KJQAOACDPAUMthxDpcMhx6HJJcwokQALaCq//SiVADgAgTQJD +LokAqXDpcSly6HMKJIACvgqv/0olgA5BcNhwQy+KEKlxSXIpcwokwAGiCq//SiXADgAgzgFDLYcQ +yXDIcehySXMKJEAC5gqv/0olAA8AIE0CQy6JAKlwyXEpcuhzCiSAAsoKr/9KJUAPQXDYcEMuihCp +cUlyKXMKJMABsgqv/0olgA8AIM8BQy2HEOlwyHHocklzCiRAApYKr/9KJcAPACBNAkMuiQCpcOlx +KXLocwokgAJ6Cq//iiUBAEFw2HBDL4oQqXFJcilzCiTAAV4Kr/+KJUEAACDOAUMthxDJcMhx6HJJ +cwokQAJCCq//iiWBAAAgTQJDLokAqXDJcSly6HMKJIACJgqv/4olwQBBcNhwQy6KEKlxSXIpcwok +wAEOCq//iiUBAQAgzwFDLYcQ6XDIcehySXMKJEAC8gmv/4olQQEAIE0CQy6JAKlw6XEpcuhzCiSA +AtYJr/+KJYEBQXDYcEMvihCpcUlyKXMKJMABugmv/4olwQEAIM4BQy2HEMlwyHHocklzCiRAAp4J +r/+KJQECACBNAkMuiQCpcMlxKXLocwokgAKCCa//iiVBAkFw2HBDLooQqXFJcilzCiTAAWoJr/+K +JYECACDPAUMtixDpcMhxaXJJcwokQAJOCa//iiXBAgAgTQJDLoYAqXDpcchyaXMKJIACMgmv/4ol +AQNBcPhwQy+JEKlxKXLIcwokwAIWCa//iiVBAwAgzgJDLY0QyXDocalyKXMKJIAB+giv/4olgQMA +JgYAQy+PAMhwyXHpcqlzCiRAAt4Ir/+KJcEDABABECFwQy6CEBlhBBAAEMBwBBgAEAgQABBYYAgY +ABAMEAAQABhAEB9nEBAAEAwYwBMdZXECr/4QGEAT8cD6CY/+CHY6cSWASHdzb0EpwgD2ecW6JaAN +CeUABoAB4AamQS9BFzhgBqb4Yr/gPAAOAEAmEBdA3A4iDQMqcAAggSAaCeAMqXLJcNYOr/8KcQjw +yXDODq//ACVBFEDlQCXAH/EIxIMA2gPwAN1AJgEXACVAFFlh5gjgDAInQhPZAY/+8cB+CY/+z3WA +ACAKABUFEDMNVQLPdoAAiD3Pd4AAcFQD8AAVBRABhUAtAQIleCCGBwhAAACm8CdAEUB4c+ipAY/+ +CiHAD+tyz3AAAIYnY9upACAASiSAAKLB4cVCwUEoAgIHekEoAQRHec9ygQCQDca5KmIlCt8BCBQD +Mc91gQDQEKlxVnlAgQsIgQBCkREKwABHie8K3oGA2APwBonBxeB/osDgfuB44H7geAjIlbgIGhgw +CcibuAkaGDALyIq4jbiQuAsaGDDgfuB48cDhxQh1PojPcIAA6BRAgEAlABQDuTV5WWGqCOAMCtq+ +D+//qXAFAY/+4HjxwKXBQcBCwQwcADEQHEAxz3GAALCLNBnADzAZAA8sGcAOKBmADiQZQA7PcIAA +sIsgGEALz3CAALCLHBgAC89wgACwixgYwArPcIAAsIsUGIAKz3CAALCLEBjACM9wgACwiwwYgAjP +cIAAsIsIGEAIz3GAADSLgBkACHwZwAd4GYAHdBlAB3AZAAdsGQAHaBmABmQZQAZgGQAGXBnABVgZ +gAVUGUAFUBkABUwZwARIGYAERBlABEAZAATvoc6hraGMoSwZwAIoGYACJBlAAiAZAAIcGcABGBmA +ARQZQAEQGQABY6FqIAAD2BkAAGogwALUGQAAaiCAAtAZAABqIEAByBkAAGogAAHEGQAAaiDAAMAZ +AABqIIAAvBkAAGogQAC4GQAAaiAAALQZAABqIIABzBkAAEDDAcACwVMnzTUMFAYwUyXENVMmxTXX +uqlzEg4gBRAUBzDSCWAMANjmCAADz3AAAK3eMg+AAH4N4A0A2M91oACsLxmFibgZpc9wgACYCACA +gODKICECyiEhADgPYQXPIWEGz3CAAJwIAYApCF4AQNnPcIAAcH4msDC5J7AZhfC4GYUF8o64GaUH +8Iq4GaUF8E4MoAYA2PUFwAzgeADbYKghqEKo4H8D4PHArg5P/s9zgADIJc91gAAUP0CFDOkAo5Tq +4gkgAQ/YRg+gBgjYAdgApQzwAN7AowjqpgggAQ/YEg+gBgjYwKXZBk/+8cBmDk/+z3CAAIwIAIDP +doAA4BCghs93gADcEAQggg8PAADgBCKBDwEAAAByaUR7Z32gpgQgjg8AAABAmHWghwO+RH4EIIAP +AAAAgMd9oKcEIwMBBiLPAMR9pn89eSV4ArgEIoIPAgAAAAR6BieAEC8oAQBOIEIEDRqYMA8KkAHP +cIAALMwOkCfoz3CAAAgJAIjPcYAAXB/wIQEAvxEBBlMhQYAZ9M9xgADwTgS4AWEjCpEBz3CAADzM +9CBAAA3oz3KAALw3A4INGlgwAeADogTwNwpAAEhxz3OgABQEKqPPcoAAJAlAigDYDQpRAEmDBwoU +DgHYAdqJ6M9woACIIDV4QKAH8AbZ3PGaDyALBhqYML0FT/7gePHARg1P/gh27Igols9wgADACLJv +KHOGI/MPtn1CKxECx3WBABAOYIUIcgkLXgNEaOu5iiDDLwT0HhaQEA2OUSAAgKLyeQnfACsL3gL/ +2AetSiQAcQDZqCCAAyhiACGDD4EA+BX2ewSrKGIB4S95AKtb8CMJEiEKIcAP63LPcAAALSWKIwsE +SiRAAEEE7/8KJUAE7rkHjTIiQgQAIYEvgQD4FfZ5CPJEqQTZAClBBCV4B6098ECpDyBABGPwLQgS +JIwgw6/KIcIPyiLCB8oggg8AAC4lyiOCDwAA5ALKJGIA6APi/8olAgS2C+//yXAIlgsIngMCjgmt +A/ABjgitAIUxCN4CANpHrUokAHHPcYEA+BWoIMACOGL2eAQYAgQAGAIEAeJPegGOCK0CjgmtLPBM +IQChyiHKD8ogig8AAC8lyiOKDwAAAQM+B+r/yiLKBwiWACGBL4EA+BXuuAeN9nkJ8gQZAgQE2QAp +QQQmeAet3fEAGQIEANkPIUEEJngHrQGOCK0hBE/+8cDGC0/+z3OAAKAJYIN5Yc9zoABQDGCDx3MA +AABAInvNuwsLBQDtCx7AUSMAwMogIgAf9DkKUQDPdaAA0A8QFQOWKQhUAM9ygAAAFp9wI4KoIMAC +AoolFQ+WwbjTaNh/AeACqud5I6IQHdiQAdjBA0/+4HjPcIAASLPgfwaA4HjPcIAANLPgfuB+4Hjx +wDoLb/4G2gh1KHcgsM92gABcHwOGCOB+CqAMJG0DhkAlgRJyCqAMBtoDhkAlARQI4GYKoAwG2gDY +AbUMtUQnAZLPcIEAVBzRJ+KREPLPcoAA2MtAgoYi/wtFIsIBTLUa2lqtS5AQ4kuwB/AY2lqtQpAQ +4kKwz3CBAPgVS7UAiM9ygADoFECCA7gVeBBiUyCAgMwhIoAF8gCVjrgAtQUDT/7gePHAigpP/gh2 +OnEacuRoz3CBAPgVAIjPcYAA6BQggQDdA7gVeDQhEgChrhzYAK6htulwqXFmCiAAONoEHkQUCNgC +pkAmABTKDeADqXHPcIEAEA4OiDceQhM1HkITvLYEuIYg/gMUroog/w8Lpg/YNh4CEFMigKC9tswg +IqAQ8hkI0QAL2BWuCnBAJwEVZgmgDBDaB/ALCJEACtj28bGvSQJP/uB48cDqCW/+BtqCJAM9OnAa +cc92gQD4FQCOz3eAAOgUIIcDuBV4FWHPcIAAAEUiCaAMmMHPcAAAiI5mHAQwmsEqcA4JoAxk2lMl +jZBs2GTyWw3REECOIIeWwJ/FA7pVehDhWWEuCaAPViVCEwogAIRWJU4TyiBiABN9z3CAAFwfQ4BV +JMY8ViSHNs9wgABUfUAiAQKYw4okAQteCGAFUyWFEHzdlsc78FkNkRAgjgCHz3OAADR9A7k1eRDg +PmAskwHhMHlAIwIGLLOJ6Q2TAeAQeA2zhegOkwHgDrNYHEQwANhaHAIwINhbHAIwAZJ03VwcBDAC +kl4cBDCWxxHwCiHAD+tyz3AAALwh7tuYc2EA7/9KJQAACHUA3pjHj8BMIACgiiEGAsohgQ8AAAgB +jg3P/1YUgTCLcLlhMHkmDu//yXKPwNQcADCLcNgcADDcHMAz4BxEMxIIIABVJEA97QBv/oAkAz3x +wJIIT/4IdQCAAJAnuMC4E3hTIE4AAthiCSAHyXENGpgzz3GgABQEyqHPcoAA4AkAghS+AeAPeACi +xXgLoQGFYgmgDDzZAIVaCaAMOogChVIJoAwmlQYIwASlAE/+4HgocjEAIAAA2eHF4cYA3YDiyiSJ +cOggKQKuYapgwnpPeoPqAeUA2khwwcbgf8HF4HjhxeHGQCkNAiV9QC0DFKV7JQo0Agh1UyV+kAby +AR1SEGG6+/FBKo4AwbpCJk6QBB3QEP31CeovJIlw4HioIEABAR1SEOB4wcbgf8HF8cCuDy/+BtgN +Eg42ARIQNg0aGDDPdaAAFAQKpQmFBxIPNifoA9gQpQSlz3CBAAgXvg6gDQMaGDCS2QPIkLmgGEAA +9gpgAwDYCYUP6CgVBBAkFQUQHtgKIcAP63KMuNEGr/+KIwQGBxrYMwEaGDTKpaEHL/4NGpgz8cDh +xQh1YgngABTYz3CAAFwfAIDEEAAGJbiCCuAAwLi6D2AGBNj2DuALqXAGDIALxgmAC30HD/7xwOHF +ocG5CPQACHUyC+//ANqtCBAAz3OgAFAMBYPPcoAAaJoSqgWDE6oJkowgxIEqbSfyEvbbCNAAh+B4 +9IEJUQDPcoAAOJMyCq/+QCKAAguKgbgLqg/wjCCIgDLyjCDIgEnyjCAQgGL0BYMJaQsIVQEA2F3w +UgzgBQDZWfAfCZQAz3KAADiT8gmv/kAiAAJIcQuJgLgLqe3xJQlRAN4Jr/6LcCDAz3GAADiTUyAC +AIYgfw9IqRx4Cant8RPYOfD9CZSDz3CAAFwfA4AYiPEIUIDPcoAAbJBIcKIJr/4G2UAiAAKWCa/+ +BtkMkoG4DLLB8c0JFIHPcoAAbJBAIgAFegmv/gTZDJKAuAyys/GxCdGBz3CAANAJYgmv/gfZz3CA +AJQmEglgDwCApfEc2E0GL/6hwPHA4cXPcIAAbJAMkAsIHgDyDgADBfBRIECAXAhCA89wgAA4kwuI +DwhQAILgQAsBBAPwVgwABM91gADYCQCVMQieAM9ygAB8zUwSgADPcYAAzM3BuPQhAADPcYAA2LEB +qUgSgAACqeoOYAUB2ACVUSAAgRAJQg8A2M0FL/4AteB44H7gePHA4cUA2M91gAAQy0okQHEkhagg +gAIA2w8jAwALIcCAA/QB4AXwZnk6D2AAJKUEhYDgRA+hAMogYQKJBQ/+4HgIczhg1bvVuQ0J5QA2 +uAIjQgAK8M9ygQB4FkWCAeDJuCJ6emIWuOB/RXjgePHA3gwv/phyCHXPdoAABJT0JkAQz3eAAIST +USBAgsogQQDKJCJ0yiAiAOggIgL0JgIQCQpeAgHgRwgVBC27wLvPcoEAcA20ekArhQJgkgS9hiX4 +E4m9DyNDAGCyANoWf0CnQafDuaV5BSFDARR+YLbPcYAAJJQVeQAZAAEC8IDYxQQP/uB+4HjxwD4M +D/6CJAMyCHZacUh1OnNIcItxngtgDAjaQCrQIEAlABIqcY4LYAwKcobA3gpv/slxBdgG2ZpwenFC +IA0iXwpyICJ1SncKJYAkgsaLcMlxYgtgDAjaBCy+JA8UgTAAIUB1J3gPHAIwqXCEwUYLYAwI2obA +yXGqDi/+yXLJcItxMgtgDAjahMCpcSYLYAwI2mG/aL25D3WQQiVVIEIjQSCZCXWAQiRAIEokAHIA +2aggAAIyJEAwjCCCiQT0AeEA2ATwiiD/D8UDL/6AJAMy8cDhxZhwA8igkAGAQOX0uMAlohAD5c9y +oADUBw8SA4YEJY0fAAD8/xMLJQGAdQ3IFSIBMA4RAAYbYxkSAIYCJcEQRwhFAAXYDLjPc6AAyB8e +oxDYDqMB2BUbGIAZEgCGCQhFAPkLHsAfCx5AGRIAhgohwA/rckPYjLjPcwAARBaBAq//uHUPGliD +dQMP/uB48cDOCg/+q8HPcIEA+BYAEBMAB8gEIIAP8QAA8EDADcwA3s91oADIH1EgQIDPcIEA+BYh +gAPID/KgFQIQ+BUDEGJ5AiJXAHYQAQEvJ8glWWEE8IQQFwHicToYxAUfhQ8IRQAweD4PIAUC2QHZ +z3CgANQHNKAzoAPf7aAREACGz3GgANQHQcBA4A8ZGIAUGZiDA8ikEAEADQkeAsYJgAsE8EcdmJPP +cKAA1AcNEACGQC8BJBB4BSEVAAPIIYAAEBIBQ8G4EJgAchABAboQAAECIRQGCgwgBkTAGQhRAM9w +gACIHQCQgeAB2MB4DLhCwAPwQsYDyM9xoADUB1mAiBmAAKQQAQDZoLgYggO6GIQDt7mkGEAAA8AT +CJ4Fz3KgAEgIQCIBIwbwQCIBIc9yoABMCATAAsMDcWV4BSUVIAdpz3MAAPz/ZHjPc4EA+BZjgwgg +xADPc6AA1Ac1owAaQAUCIgElL6MCJAEAO6Pwo89xgACkMA0SAjYAgT0IgADPcKAAOC4FgAQggA/A +AAAAIQiAD8AAAAD12AW4z3OfALj/GqNbo2nYGLgZowHYA/DJcAkIUQBAoc9wgQD4FgQQBQACIxMh +z3GAAIy0qHCAIA8KHqUQ2A6lAdgVHRiQB8gEIIAPAQAA8Cy4AxIDNgSxD4POqQChQBMAAQKxEItg +EwMBQCgEAcO7BSMDAWaxD6kvI0gBz3CAAKjMQCAECVV4SYDPcYAALMxbY2mgpBUAEPgVAhCgcEJ4 +RcAB2M9yoADUCxCiA8A1uMC4F7gAIIIPAA4AAM9wgQD4FgKAArgr4AQggA8AAPz/RXjscgCiARIC +NuxwQKDPcIEA+BZCgOxwQKgNyBQhAgBQiuxwQKjscMCwA8iUEAIA7HBAoA3I8CQCAOxwQLDscMCw +7HDAoOxwwKAHEgI27HBAoAPIQJBUEAABELpFeOxyAKIDEgM2AYMfCB4BUotwi89wgQBQEHZ4AIiG +IH8MHHgEuEV4AvCA2OxyAKoDyDt2UIgzEIAABLoFeuxwQKgDyBp2XJDscECwAxIDNs9wgABEPZwT +AgFvgya6wLrAuwy6DbtlekCgDRICNgAigA+AAFTMwKjPcIAA2MtWeFR5wLECkMAZhAMVJIIAeBkE +AM9wgABcHwSAGpDQGYQDRsDPcIEA+BYCgMCigODKJ44TCgMuAMohjiPJdcl3OnZMIACgs/IT8M9x +oAD8RB2BOYEEIYKPAAAACBH0BCC+jwAGAAAL9E8LH0DPcKAA9AcHgADe1Qjehy3wAN76uMomgh8A +AAEC+bjKJoIfAAACAvy4yiaCHwAAAQIK6s9zgABAN1CDiiYIEgHiUKPqDYAOEfAB2c9wgAAoPSCg +bgpgDShwz3GAALw3DYGKJggSAeANoQUnj5ML8mECIAAA3oQSAAAhCJQMkwsfQM9yoADUBw+CEHgZ +EgGGWODnCQSACvDPc4AAxDYkg4ohECEB4SSjiQmfIB4aWIMdEgCGBxoYMB0SAIZKwB0SAYYEyCCg +HRIBhiGgHRIBhiKgHRIBhiOgHRIBhiSgViUAEh4aGIAdEgGGQC8CJDB4BSCVAAQSAjaGIfMPABIS +AYwhDIABgkPAFvIa2BXwz3CBAPgWCBAEAAAQBQAKIcAP63JX2M9zAACME6EFb/+MuADe0fAg2Jpw +A3AQeHIaBAAA3gsIESADyHPwA8ARCJ4Fz3GgAEgIQCIAIwfwQCIAIc9xoABMCEfBA3BIwATBAsAl +eAUlFSAIwAfgz3GBAPgWI4EEIIAPAAD8/wggVgAMJsCkLgEtAEnAFg0AAAUnD5CY9AHZz3CgANQH +FBhYgFUlQRQPGFiAAwofQgjAz3KgANQHFaIHwwIiACUAG0AFD6IJwwImwCAbogPYEKIqwJzgANmQ +9AcSDjYAwAQmgh/xAADwUHCU9API6XLIugIjkyUIiAy4RXgDEgI3ELpFeOxyAKIKwEAhWTABGhgw +BMgDEgI2KHZBxQMaGDAEGpgwIYAAkAHFNLnAuTR4A+BA5QQggA8AAPz/HWUNEgE2BvAVIkAwDhAA +BgJ9FSJAMA4QAAbvDQWQA8zPcZ8AuP8Yoc9woAD8RF2ABCK+jwAGAABd9BkIECAEyFCIUyLBAIYi +/gNEusQYggAwqM9woAAUBMSgB8jPcaAASCwdoc9wgQD4FgKAQCBQIBJwIAXN/wvwz3KAAMQ2I4KK +IRIgAeEjogPwOnciDQAFUyF+oAX00gsAAAV/nw8QEIkPXhADyCmIAeEpqM9xgADENgaBAeAGoUDw +CiHAD+tyKBQFMDzYjLjPcwAAGxS1A2//SiRAAAAUBDBH2AohwA/rcoy4z3MAACMUmQNv/7h2TCAA +oM9xgADENoonEBAI9AfIz3OgAEgsiicIEB2jDwqeBgWBgL8B4AWhuPEGgYG/AeAGobTxEQ8eEM9x +gADENgWBAeAFoTp3A8jpcci5CIgMuCV4AxIBNxC5JXjscSp0hCQCkQChQCFNMBTyz3GgANQHgBnA +BAPMKnLIuhC4RXjscgCizKEB2BQZGIDOCqAOAeUDEgI2khIAAQQSATYNCJ8CkhEDAW0LngKquJIa +BACSEQABqrj+DWAIkhkEABDZz3CgANAPEBhYgCQQAYbPcoEACBtFkjB5ArpFeQwYWIAU2RAYWIDP +cYEACBtnkUaRGNkQu2V6DBiYgBAYWIDPcYEACBtpkUiRELtlegwYmIAG8M9wgQAIG8qoz3KgANQL +0KKvCRAgBfAI2exwIKAB5c9wgQD4FgKA8w0EkM9wgACMtCSQlOHAIYYPAACTAM9woABoLPAgQADP +cYAARD0ggc91oADUByV4DaID2BKlmghACw0PXhIeD6//AcAH8APYEx0YkBQdmJMpCBAgz3CgACwg +MIAFwDBwAdnKIYYDBCCATyAAAACA4cwgIYDx889wACgIAAYaGDAGwHoO4ATJcVEhQKCq8s9woAAs +IM+gpPDPcIAAlDQRiDkIHgA1CB5Dz3GAAFwfI4HPcIAAlDQQiBC4MiGBDwAA2AKfuIDhAdnAeQ+5 +JXjPcaAA/EQNoRsLECDPcKAA9AdgGMAEz3GAAMQ2A4EB4AOhz3CAAIy0JJCU4cAhhg8AAJMAz3Cg +AGgs8CBAAM9xgABEPSCBANrPdqAA1AcleM9xoADUCw2hTKYuCGANBsAZFgCWwOCgAA4ADcyZCF4A +A90gHliTAdgUHhiQBBIBNgAWBEAHGhgxABYFQAEaWDEEypzgyiLCB8oggg8AANwOyiOCDwAA9Ark +AGL/yiHCDyhwOg/gDQ7ZDxYAlgQSATa0GQQAEx5YkxCJUyDCAIYg/gNEuMQZAgBQqc9wEiAAAEoO +IAMNEgI2BMjPcaAALCCwEAABL4Fk4DBwyiCFDxIoCACF989wACgIAAYaGDAA3g3MBCCADwAAAggX +CJEABBIBNoogBADKC+AImBEBAA3Iz3GAADzMz3KAABDLFHnPcIEA+BbAsSKABpIZYTB5JrKt2M9y +ALsAuyoLYAYFuAPIGpCeCaAGDRIBNsEA7/2rwPHA4cVPCF5Dz3CBAPgWAYDPcaAAyB+WIEEPHqEQ +2A6hAdgVGRiAvg5gDkHYJwheQwHZz3CAACg9IKDeCyANAdjPcYAAvDcNgQHgDaGKJQgSLfDPcaAA +/EQdgTmBBCGCjwAAAAgA3Qf0BCC+jwAGAAAY8gDd+rjKJYIfAAABAvm4yiWCHwAAAgIJ6s9zgABA +N1CDiiUIEgHiUKPqDkAOB/AD2c9woAAUBCWgcQDv/alw8cDyD4/9CHXPdoAAoA4AjqjBzwgRAIt3 +6XDPcYAACEKWCO/9INoB2ACuANiPuAsaHDAA2BUaAjDPdoAAAACgtg8NgR8AAP7KB8CAuEfAz3Cg +AKwvGoBSIAAAEwgeAAGWgLgBtgfAgbhHwM9wgADoTqCIWgrgA6quz3FDdagSQMGKIRoKQcErjgSm +DRxCM0bAY8HPcYAACDlEwc9xgAB0OM91gACYCACFRcGA4MogwQPKISEIyiJhAMojYQ+MDGELwCvh +BQCFgODKICECZA+hBMohYQAC2c9wgACoJSSgfQev/ajA8cAKD4/9KHbPcYAAXB8vIAcghOhhgQPw +YIHEEwMGJbvwIQ0AwLuA5qKho6HMIyGAAd3KJSEQz3OAAKQi6IsrD1ES4YHEFw8WHw9eEeyTfpEX +D8AQEQhQAIfoAIHEEAAGBwhfAQDdgeLKJSEQAN9CCaAL6XAKcEoJoAWpcc9wgACoJQSAIwieAM9w +gADcMgCAi+jPcAAAFgkmDAAECwhRAIoOAAoM8ADZnrnPcKAA/EQhoOB44aD6CKALANiA5rAJYgDK +IGIArgsABIXoOg7ADAPwbg7ADM91gAB0DwCNhuiyDgAMAdgArYUGj/3xwCIOj/3PdYAAEMsklRLp +z3egACwgUIcA3gaFR6WiD6/9DiCAAAilxLUQh8W1BqVZBq/9CIXgePHAz3GAABDLABEEALhwz3KA +ANQqQCyAABV4FSBAATAiBgAZDhEBCiHAD+tyiiDMDDUFL/+KI8UCTw4QACMOUAAtDpAAIw7QAAoh +wA/rcoogDA2KI0ULEQUv/wolgAEyCgAA0cDgfhYJAAD98QPYCQxQAAChANgFoQSBoLgEob4IYAAD +2O/x7/HxwM9ygAAQywaSAeAnkhB4HQkjAAayBIoNCFEABYqB4AHYA/IA2IDgeAgCANHA4H7PcIAA +fM0gkEQhAANjCBECANvPcoAAEMtlogSCoLgEoj0JnwEEks9xgABoywHgJIEQeB8JJQAEsgSKDwhR +AAWKgeAB2ALyANiA4CgAAgDPcIAArC4DgAroA9gJ8M9xgACsLgOBAuhjoQTYWQEAAOB+8cDPc4AA +EMsEE4QADQxRAAWLgeAB2APyANiM6AUThQAKIcAP63KKII0OFQQv/87bAtgAowDYJJMJowWjBrMq +oySDoLkkoyoPoAUEs9HA4H7PcoAAEMsA2SWiJIID2ACioLk1B6ALJKIA2c9wgAAQyyqg4H8poOB4 +8cBODI/97g/P/89wgAA8y2CAz3KAABDLqIBgos92gAAkKwSCqKIA2cCGoLglogSiIw5REILjzCPi +gBL0z3CAAKwuI6AE7ZYPz/8K8EoKAAAG8AHbYKIooqC4BKJdBI/98cDuC6/9ANjPcaAALCBQgc92 +gAAQyySOz3WAADzLCKULCVEAJY4JCVAAAdii6CqGHOkGhlINr/0OIIAAz3EAABAnJQkFAM9xgQB4 +FiWBmSHNChkIRQAF8M9wAAAQJwilAtgH8ADYB/AJhvjoAdgApQHY6QOP/eB4z3KAABDLJIIPIQEA +JKK1BiAACdjxwF4Lj/3PdqAALCAQhs91gAAQywelz3CAAFQ7og9gDADfABUFECcNUABMJYCAzCXi +gDzyCiHAD+tyiiBMDYojCAeZAi//iiSDDwSVzwgQAO4Mz//PcIEAeBYFgCiFmSDNCjBwAdjCIA4A +swgQAM9wgAA8Lumg13EAABAnbyALABHoBI0NCFEABY2B4AHYA/IA2AXoCg7P/0Hwz3AAAIgTCKVO +Ds//O/AElZroJZUIhYHhwCCBDwAAiBMD8ht4z3GBAHgWJYEIpZkhzQoQcQHYwiAOAJ/o1ggAAB/w +NwhQAAiFHXjXcAAAECcIpW8gCwAR6ASNDQhRAAWNgeAB2APyANgF6JoNz/8H8M9wAACIEwil3g3P +/wSVBbXktRCGqQKv/Qal8cDPcYAAiJBBgc9xgQB4FiWBBSm+ADBwyiBOAAwhAPDPcQAAECeyC6/9 +yiBFDs9xgABoywSh0cDgfuB48cDhxQDYz3OAABDLAKPPdaAALCAQhQHZz3KAADzLBqMQhSCiBqLP +cIAAPC4DiCSrjCCDhiSqBPIlqiWr7gsgAAPYNQKP/eB4AdnPcIAAEMvgfyCgz3CAAFwfA4DPcaQA +HEAIgMC4E3jBuBKh4H7geOHFANpKJAB0z3WAAISTz3OAAPyTSHCoIAADQCMBAhR5QLEWJQEQQKFB +oQHgSiTAcwDZqCBAAs9wgQBwDTR4QLAB4c9wgABkCUGgz3CAAGyQTLDgf8HF4HgF8EJ5x3BAAAAA +z3KBAHgWRYLzCkSAUyBDBXBxwCCND0AAAADAII0A4H8ieAbwYnkCIIAPQAAAAM9ygQB4FmWC7wtE +gFMgQgU6YgsLhAA4YAfwAiCAD0AAAABieDhg4H7xwNIIj/3PcIAACM4MiBkI3wECuM9xgQAQDhZ4 +BWEtvcC9A/D/3S4PwAMJ6M9wgACkIgiIh+AC2ALyANjPcYAAaJp3ic9ygAD0vSGCCQtAACCChOkB +2QPwANkacc93gABcHyCHxBEBBosJXgGHDREQI4c4iX8JEAGuD0AMz3GAAMw1NQgQIM9ygACgCQKC +AeACos9wgAAAPQDaQKDPcIAAXDxAoM9wgACoCECgEYEB4BGhBfAQgQHgEKGuC8/9z3aAANgJIJYT +CV4A+guADgCWobgQeQC2HwmeAQ4MgA7PcYAA3LELkQHgEHgLsQCWprgAtmIOwAMP6M9wgACkIgiI +iODMJWGQB/QeD2AMAdguDsAEjCXDn0byIwgQIM9xgAD8FQCBC+gA2AChz3GAAFQmAIGiuBYJoAgA +oWYMAAzPcYEAeBYGgUUgQAEGoc92gAA4kwuOUSDAgPAIwv0LjlEggICsDEIDQgoAA/oNwAOA4LQK +IgDKICIGBu0Ah8QQAAYhCF8Bz3GAAOQyBIkK6AOJgOCgDOEKyiDhAI4KIAAV2JUHT/3hxc9xgAAA +FgCJAdthqSToz3CgALAfeaDPcIAA0B0IgKOBYIACgQDaMQ0BEM9wgAAYFgCIg+gB2ArwAYECIw0A +9w2Fn0wAQEtBqUhwBwhRAGGhQqngf8HFoqHv8YDgAdjCIAwAz3KAAAAWAKoB2AGqANgCqgGiAqID +ouB/JKLgePHA4cUIdRMINASYcg7Y4gov/wDag+gT3Szwz3KAAGiaSHAKCu/9DNnPcYAAABYAiQ7o +z3CAAHzNAJCGIPwAjCACgAb0BZJkkmd4A6FCJQATJgwgBYhxCiUAkAz0z3CAAHzNAJCGIPwAjCAC +gBQPwf+5Bm/9qXDgePHAmHC4cZzgyiLGB8oghg8AAOMOyiOGDwAAgwCYBeb+yiHGD0wlgIHKIsYH +yiCGDwAA5A7KI4YPAACEAHgF5v7KIcYPANrPcYAA9IyeuhUhQQEAgQEqAgFGeM4PoAYAodHA4H6d +B+//BdngePHA4cUA3c9wgAD0jJYNL/8c2RvYpgggAAXZSiQAd89xgAAgFqggwAIWIUADBBAFAJh1 +Dw1BEUAkTQANBk/9CiHAD+tyd9gFuAEF7/5T2+B48cDPcIAA9IwYEAUALyxBAUwkAIfKIsYHyiCG +DwAA4g7KI4YPAACrANAE5v7KIcYPz3CAACAWFiAAAQCAQHjRwOB+4HjxwOHFz3ADAEANz3WgAMgf +RR0YEKoPz/+A2BUdGJCVBU/94HjxwJhwuHGc4MoixgfKIIYPAADjDsojhg8AAGMAdATm/sohxg9M +JYCByiLGB8oghg8AAOQOyiOGDwAAZABUBOb+yiHGDwDaz3CAAPSMnroVIEABIIABKgIBRXmqDqAG +IKDRwOB+nQfv/wXZ4HjgfuB44H7geOB+4HjgfwHY4H7geOB+4HjgfwDY4H7geOB+4HjgfuB44H7g +eOB+4HjPcYAASDYSgQHgEqENyMdwgABIzCyIAeEveRcJcgAsqIogCAAGGhgwitiQuAfwiiAQAAYa +GDBC2Ji44H7gfuB48cA6DE/9mBACAAQigQ8AAAAIO3kEIoMPAAAAECV7z3GAAFwfpIFWJU4UViUP +FZgQgQAVCl4ChiH/A0S5L2eJv+lxGfBRIgCCvBUCEQzywrmAJQIZP2Xojz1lMI1lf/B/RXkJ8MO5 +PHk/Zj5mMI7oj0V5iBjAA2V5KQRv/YwYQADxwOHFA8ikEAEAmBACAFEhAIByEAEBSHAG8r4JIAIA +2gh1B/AB4bIJIAIA2qxovg2ADM9yoADIH/gSAQADyM9zgQAQDhCIArgWeABj7bjPcIAA0B0I9AHb +c6JIgECCDIBggAjwAttzokmAQIINgGCAAiVAEFhgEHLAI20ADXEAoQ1wYKAAFgBAABYAQAPIz3Kg +APQHcBABAWi5J6JwEAEBaLkweY0Db/1wGEQA8cAOC0/9z3agAMgfoBYEEPgWAxAA30kIEQEDEgE2 +pBEAAHYRAgERCB4Fz3CBAPgWoYAE8IIRDQENzFEgAIGEEQABCfICJcEQAiRDAAgjAwAE8IYRAwEb +Y2hxcfCVCFEADRIBNwPIeBACAUcJHgFRIUCAz3GAAFwfJIFUEQEBCfJ+EA0BIn1ifQIkQwMr8IAQ +AwHPdYEA8AwAI0QAcIh2fWCVACMNAYQQAwG7YxvwpBABABUJHgVwiM9xgQDwDHZ5YJEE8IIQAwHP +cYAAXB8kgYAQDQFUEQEBPWW7Y4QQDQG7Y4AQDQG5YX4QDQFCfSfwQwiRAAMSDTYNzHgVAhFRIACB +z3CAAFwfBIBUEAEBCfKAFQARInhieAIkAwAH8IIVAxGEFQARO2MbY4AVDRFCfQXw6XPpcul16XEN +zBEIXgADyHYQAgFiujpiDPAVC3IAYrrPcIAAXB8EgEYQAAEaYvgWABBdZQJ9H4YZDQQQoNgPpv+m +X6YC2BUeGJCA2A6m9QFv/XB44HjxwIYJT/3PcYAAXB/wIQIAViJFBAiCViIEBVEgwICKIAgAyiAh +ALwaBABKJAByANmoIEAPz3WAADRP/IouZeR+LyiBA04ggwfPcIAAHFFvYAAlQwDgq0QSjwDkfi8u +gRNOJo8X7mDIq8iCIQ7eEB2KhuHTIKYALygBAE4gjQfPcIAAlE6oYBHwz3aAAFxPLmbOZbyKxH1Y +Eo4AxH0vLUETTiWOF8hgEKsB4UokAHIA26ggwA/cis9xgAD4UG9hz3WAABxR5H4vKIEDTiCPB+9l +ACXAAPyoRBKPAOR+Ly6BE04mjxfuZSQYggPIgh8O3hA9ioDj0yGhAC8pQQBOIY0Hz3GAAJROqWEQ +8ATryWsD8Gh2zmE8isR5WBKOAMR5LylBAE4hjgfJZSwYQgAB40okAHEA2KggAAXPcYAAkE59iglh +ACQMAAHgZHkvKUEATiGDB89xgACUTmlhIKyRAE/94cXhxs9zpAC0RSkTAIbPcYAAUDXIGQAAKxMA +hswZAADPcKUACAwDgOQZAAAOEwCGEHowuNQZAADQGYAADxMAhtgZAADPcIAAuM3UiLaI6BmAA3iI +7BlAAw2Q8BnAACzgAiCCA/QZgAACIEIDYnj4GYAA/BkAAMHG4H/Bxc9wgAAEPQaAA4AggM9wgABc +jeB/KaDgeOHF4caYcM9ygAAgFwWCIIJmgsq4ELjKuQUhAYABgsq7ELvKuAUjBQBnggKCyrsQu8q4 +BSMHAGiCA4LKu8q4ELsFIwYAJPIAFA4ALyhBAE4ggwcA2A8gwAASfQQgQwGkfmV+AByAA9qCpH7F +e3qieYIEII4BBCDAAaR7xXt5oniCpHsEIUGDZXgYot/1wcbgf8HF4HjxwPYOD/06cAWBoIHKuBC4 +yr0FJQ2QAYEmgcq4yrkQuQUhEAAB3hnyBCWAkxPyLygBAE4gggfwIYEgAN8PJ48QCOkEJwAUQiAA +gGB5yiBiAOZ9237q7QEHD/3geOB/ANihwfHAmg4P/aPBCHZHwM91gAAgFxuFOoX8hSR4BH8HJ4+T +QccW9LEOERAGCmAECtilCBAACiHAD+tyz3AAAI0TiiNHAEokAADRBa/+CiUAAQQUATEY6RwUADEL +IECADfLPcIAAXCZggM9xAACMWgzYYHsD2gjwiOjPcIAAWCYggGB5DNgGFAExGOkeFAAxCyBAgA3y +z3CAAFwmYIDPcQAAjFoN2GB7BNoI8Ijoz3CAAFgmIIBgeQ3YCyeAkwXyMgnv/wrYB/CH7gII7/8K +2FYIAADcpQjcMwYv/aPA8cDGDS/9ANrPc4AAIBc7g7qDAN4PJg4QpHkEJkAQQiAAgMogYgAvJgfw +Ad3KIIEAB/IcgyR48g7v/8V4qXD1BQ/94HjxwOHFocEB2EDAz3WAACAXCoUbCB4Ai3AE2WfaPdu6 +CuAKF7sKhaC4CqXNBS/9ocDxwEoND/0acCh1SHdodjhjZtk92voK4AoXuhcIUQAKcNYK4Aqpcelw +pgrgCslxgQUP/eB48cAWDQ/9psEodRpyYMAA2AEcAjAB2AIcAjADHAIwi3DeCyAHgcEG7QTBCnBg +fQXCA8GO6QohwA/rcs9wAACME+7biiTDD1EEr/64c2B5ANgpBS/9psDgePHAugwv/QHZosHPdYAA +IBcahVuFBHochQQgkIAt8gPwO3kEIECg/vMvKAEATiCRB1wdQBQVJU0UHYWA4MohwQ/KIsEHyiCB +DwAAjxPKI4EPAAAcAsokAQTkA6H+yiVBBCYIz/8dhUB43g+P/wDYDyBABAYgECCyDe//CnCdBC/9 +osDgeOB+4HgB2c9wgAB8KOB/OKDgfuB48cDmC4ADz3ABADhACejPcYAAIBe4GQAAG4GRuBuhz3AB +ALA/COjPcYAAIBceoRuBgbgboc9wAADwXAroz3GAACAXlBkAABuBiLgboc9wAAD0XAroz3GAACAX +mBkAABuBibgboc9wAAAAXQroz3GAACAXnBkAABuBirgboc9wAQA0Rwroz3GAACAX2BkAABuBmbgb +odHA4H7xwOHFocHPcoAA5LTPdYAAIBcXhQDZDyEBABiFJHhCIACAyiBiAAHbANkjCFEACNhgwAEc +QjACHMIwAxzCMItwBNkGDu//iiMIAAjYANkuDu//KHIA2LUDL/2hwPHALgsv/QjZz3Kt3u++Egvg +ATpwtg8gACpwkQjQAM9wgABcjQOQTiDPAVEP1RHPcIAAXA9ODWAA9CDAAwDeAN0E2BpwKnDpccly +CiSAD63e777OCuABqXPKDyAAKnBNCNAAQiBAIN8IdYAB5QHm0w6UkAHnuw/UkSpwz3Kt3u++ngrg +ARDZRg8gACpwHQjQAM9xrd7vvooK4AEqcAoP7/8qcIPgyiAiAOUCD/3xwIYKL/0D2qbBGnCOCmAL +g8EDwc9wgACsEBQUBzAA3vAgRQDPcIAAtBDwIEYAz3WAACgKDtjEpUDABNhBwM9wrd7vvkLABMIK +cIDbJgrgAZhzzgkgAApwfQjQAAPDz3CAAMwQQoXwIMEAwKUMFRAQwaUI6c93gADUEPAnwBCG6MCl +waUA2RnwhCoMA6YIYAAvcA4ggQ8AAAABIKUDwIQoDCPwJwEQjghgAC9wDiCBDwAAAAEhpQSFGwhR +AACFEXiMIAeNwvfApTF5jCEHjcP3waUA2BUCL/2mwOB48cCuCS/9BNqmwbYJYAuLcc9wAAAb0gDd +qXEWDGAAqXIAwc9wAAAc0gYMYACpcgDBz3CAAAgPAcIVIEEAAJECwQW60gxgAEV5A8CA4NoABQDP +doAAKArS2Ai4GdnSC2AAANrPcAAAItJAJgESCgpgAATaz3AAACPSQCYBE/oJYAAA2s9wAAAg0oTB +7glgAADahcfPcAAAIdLpcd4JYAAA2gKGF9lyD+AKQCYCEgOGF9lmD+AKQCYCEwTAF9laD+AKhMIF +wBfZUg/gCulyAoYA2YYPIACLuQKmA4YA2XoPIACLuQOmBMAA2Qi4bg8gAIu5CHcFwADZCLheDyAA +i7kihjF5GeEFKX4AI4YvclB3MXkZ4QUpfgAvccwgRYCF9wPAAeU3CEWDA8APCEUDAdnPcIAAKAok +oADY3QAv/abA4HjxwHIIL/0J2qnBCHZyCGALi3GqC2/9IcAIcULYtgtgAAW5DBQEMADByXAGwgol +gA+t3u++IgjgAQLDng4gAMlwVQjQAADBBcLPcIAAUA8A3fAgQAAEwQq6BCKCDw8AAPzJuUV5igpg +AKlybg6gDQXYIBQEMADByXAGwgolgA+t3u++1g+gAQfDOg7v/8lwg+DKIEIDSQAv/anA4HjxwLIP +7/wC2qfBmnDWDyALg8HPcIAA+EIAgADZRcDPcAAAEdIuCmAAKHLPcAAAEtIA2SIKYAAocs9wAAAT +0gDZEgpgAChyz3AAABTSANkGCmAAKHLPcAAAAUQH2fYJYAAA2s9woAC0D3AQFwAGCuAKAdjKDaAN +Bdi82L4KYAAA2cPYtgpgAADZiiBECKoKYAAA2YogBAqiCmAAANklxbXYlgpgAKlxiiCEBo4KYACp +cQPYQMAE3kHGz3et3u++QseKcATBA8Ie25hzSiUAAEomAADqDqABSicAAI4O7/+KcIPg1/LPdYAA +KAoIFRYQDBUSEA7YQMBBxkLHinAEwQPCHtuYc0olAABKJgAArg6gAUonAABSDu//inCD4LnyCBUV +EAwVEBAO2EDAQcZCx4pwBMEDwuHbmHNKJQAASiYAAHoOoAFKJwAAHg7v/4pwg+Cf8ggVERAMFRMQ +A9hAwEHGQseKcATBA8Lh25hzSiUAAEomAABGDqABSicAAOoN7/+KcIPghfLChaOF6gjgCi8gxwUE +wc9ygADMEAIhQKXPc4AAvBA1egCiAiMAJM9ygADUEDV6AKLD2jV7QKPPc4AAxBA1e0CjIfRiCkAD +CiHAD+tyEOjPcKAA/ER0EAQAZBAFAM9wAACxE2UFb/6KI0kKz3AAAK0TiiOJCkokAABRBW/+CiUA +AZzoIgpAAwohwA/rchDoz3CgAPxEdBAEAGQQBQDPcAAAsRMlBW/+iiOJDM9wAACuE4ojyQzh8QIl +gCXZYAIhQYQQ8gIlQiQMei4MIAAvcATCAiUBIM9wgACsEFV4IKACIIAkuWACIcGEEPICIMIkDHoG +DCAAL3AEwgIgASDPcIAAtBBVeCCgANhtBe/8p8DxwKYNIAAA2M9wAAAN0gDZrg8gAADaz3AAAAzS +ANmiDyAAANrPcAAAFdLPcfMP//yODyAAANrPcAAAG9IA2YIPIAAA2s9wAAAC0qDZmrlyDyAAANoJ +2Iy4ANlmDyAAANoU2Iy4/9laDyAAANoA2Iy4/9lODyAAANoR2Iy4/9lCDyAAANoC2I64ANk2DyAA +ANoB2I64z3EAAP//Jg8gAADaz3AAAAvSANkWDyAAANrPcAAADdIB2QoPIAAA2s9wAAAS0gDZ+g4g +AADaz3AAABPSANnuDiAAANrPcAAAFNIA2d4OIAAA2gDY0cDgfvHAVgzP/KTBi3EB3VYMIAupcs9w +gAD8QQCAQcAE2JoPIAAs2Q7Ykg8gAADZIca12IYPIADJcYoghAZ+DyAAyXGKIEYAcg8gAMlxAMCA +4MwgooDMIOKAzCBigcwgooHMICKCzCBigswg4oLKIUIDA/QD2YHgzCCigMwg4oDMIKKBzCDigcwg +IoLMIKKCzCDiggDdBfSBuS95gN2E4MwgYoHMIKKBzCDigcwgIoLMIGKCzCCigswg4oID9IO5L3n6 +DiAAD9iDwUYNIAAR2APBg72leUPB4g4gABHYANjlA+/8pMDgePHA4cWhwYtxdgsgCwHaz3WAAGyP +ABQEMM9wgACoDlYlARIS2m4NIAAA2wAUBDDPcIAApA6pcQHaWg0gAALbz3CAAMwOJG0d2l4NIAAA +wwDYlQPv/KHA4HjxwP4K7/wD2qPBunAaCyALi3EBwc9wgABYDwDf9CBOAALBz3CAAGwPgOb0IFQA +z3CAACgK4KDhoMwmopDMJmKRzCaikcolwhMC9ADdgebMJuKQzCbikcwmIpID9AHdhObMJmKSzCai +kswm4pIC9ALdag3P/6pwz3Kt3u++ggqgAclxRg7v/6pw7QjQAADAgODMIKKBUPSA5swmYpDMJiKR +SvQCwJEIEQDPcIAArBC1eFpw4KDPcIAAtBC1eHpw4KDPcIAAzBC1eBpw4KDPcIAA1BC1eDpw4KDP +cIAAvBC1eOCgz3CAAMQQtXjgoKpwyXHPc63e774KCqABqXJKCu//qnB1CNAAAMEAEgAghuEB2cB5 +A7m1ecdxgADktAChABMAIAShABAAIBt4CKEAEQAgG3gMoapwqXHJcgokgA+t3u++vgmgAYpzRg+v +/6pwKQjQAADAz3GAACgKQIEEvga42GAVIAAFx3CAACC1IYFCsCOwANjZAe/8o8DgePHApMGLcaYJ +IAsE2gDAAcEEuDV4z3GAABAPEGHiDCAAAsEAwAHBBLg1eM9xgAAwDxBhzgwgAAPBANikwNHA4H7x +wKHBdgvgAYtyAMChwNHA4H7geKHB4cXhxrhwz3CAAPS9EBAGAM9wgAAAKAWAmHGhwYYk9w/nCBAA +z3CAAJQ9AIAfCIEBz3CAAJw9AIATCEEBz3CAAJg9AIDDCAABABxAMSDCARSBMPDeUyLAAMR6UyHH +ACR+VHpALo0BtH26YhV6z3GAAOS2SGHUfghzhiP9D3t7OmJBimV4SHOGI/0Pe3vdZRUlzRG+YcKO +ZXrJc4Yj/Q97e7lhI4llfihzhiP9D3t7ZXknDBAAz3WqAOAHc4URCx4ASKUJpSqly6UQ8AilSaXK +pSulCvAJukV4z3KnABRIA6IJuSV+xKLPcYAAlD0AGYABz3CAAJw9ABhAAc9wgACYPQAYAAGhwMHG +wcXgf6HA8cDPcQCCAQDPcKAArC88oM9wgADcMgCAi+jPcIAAIBkAgA8IkACKDAAD0cDgftoJQACS +DeAEb9iH6GYOYA0K2MYJQADz8fPxz3KAANwyIIIGeeB/IKLgeM9ygADcMiCCJXjgfwCi4HgEKIAP +AAAvukIpwnRQekQq/gICIEAOEHgD6AHiUHoLCDMBQLGD6ADYAvCA2OB+4HhxB0/+8cCSD4/8OnDP +dYAAyB0AhQHgAKUVCFEAAdnPcKAAyBwxoOINYA0ocNoNoAQH2Bpwz3agAOwn64biDKAGKnALpgCF +QiBAgAClBvTPcaAAyBwA2BGhugqgBApwmQev/Olw8cAuD4/8OnAodRpylg2gBAfYWnAPCJ4gjgpg +B8jYUCCQIEwggKAZ8gj2IwgQIEUIUSAV2BO4DfAlCBAkNQgRKHIOoAMqcAClD/Ap2BK48CBABACl +CfAr2BK4+/HPcKAA7CcZgAClSgqgBEpwHQeP/AohwA/rcs9wAACKE3vbCiRABDUGL/4KJQAE4Hjx +wKYOj/wIdzpxGnMfCnQAAN5IdfQngBMVIYEjWg/v/wpyYb3xDXWQAebdBo/84HjxwHoOj/yhwQh3 +GnEjCnQAAN5IdfQngBMeCCAAi3EAwBQgjCNhvQC07Q11kAHmsQav/KHA8cBGDo/8ocEacM92gADI +HQCGAeAodQCmFQhRAAHZz3CgAMgcMaCODGANKHCGDKAEB9gId8YLIAOz2Bboi3ECDa/9CnAAFAAx +AKUAhkIgQIAApgf0ANnPcKAAyBwxoGIJoATpcEUGr/yhwOB48cANDN4ALg/P/wTw2ggAANHA4H7x +wA0L3gBKD8//BPD2CAAA0cDgfvHAtg2P/Ah1juAB3sImjRPPcKAAtA/8gD4IoAoA2MlwqXEB2hYM +oARIcy4IoArveO0Fj/zxwHYNj/w6cCh1GnLeC6AEB9hMIICgWnAb8gz2JwgQIE0IUSAV2BO4FSBA +BKCgG/ArCBAkOQgRKCpwEg2gA6lxEfAp2BK4FSBABKCgC/Ar2BK4FSBABKCgBfDPcKAA7Ce5oJYI +oARKcGkFj/wKIcAP63LPcAAAiRNK2wokQASBBC/+CiUABOB48cDyDI/8CHc6cRpzHwp0AADeSHX0 +J4AT8CGBI14P7/8KcmG98Q11kAHmKQWP/OB48cDGDI/8CHcacR8KdAAA3kh19CeAExoIIAD0IIEj +Yb3zDXWQAeYFBY/84HjxwJYMj/wacM92gADIHQCGAeAodQCmFwhRAAHZz3CgAMgcMaDiCmANKHDe +CqAEB9g6cB4KIAOT2BjosH1AKI8hgb8QvaV/z3CgAOwn5qAAhkIgQIAA2QCmBfTPcKAAyBwxoLIP +YAQqcI0Ej/zxwC4Mj/zPdYAA9L0ihc92rACQAQkJUQMYjYfoeQnRAhiNdQgRAOuGMBYQEM9wgAB4 +JiCAYHkC2CKFnuinvxEJUQNGIMAjRSAAAxPwz3CAAHAmIIBgeQDYDwhRBEYgwCNFIIADBfBGIMAj +RSCAAuumDKYW8I3h0CfhEeXzz3CAAHAmIIBgeQDYkeDQJ+ER6POHv9nxBdgMpqDYC6b1A4/88cDh +xQsIMgwIdR0Nkh4KIcAP63LPcAAAmiEi25h18QIv/rhzQiUAHOEDr/wPeOB48cBiC6/8mHBBgbCJ +dwoeAXKJz3aBABAO8m32f+ZmNMoIEYUASSDAABEOnhXPdoEAUBC2fsGOA/AA3sdwgQBQELZ4BIgI +IwMACCODAwAjQAFJIMMDFm11eM9zgQDQEQNjz3CBAFARtnjPdYAAXB+khbiFAYCleAQggA8AAAAI +BnsC8GOB6LuYGcAAAN0J8qQRAAAA3Ze9kbiUuKQZAAA7DB4Az3CAAFwfxIDAusiGBCaOHwBAAAA+ +vh7m2HpFe5gZwAAdC54HpBEAAIUlARSMuJG4pBkAAJwZQAMe8CcL3gekEQIAhSUBFJa9mL2NupG6 +pBmAAJwZQAMkgBCBnrgQoQrwlL2WvZwZQAMkgBCBnrifuBChtQKP/PHARgqv/APYz3aAAHAmIIZA +eYDgbfIghmB5BNjTCBAAIIZgeQDYZ7gVCBUDMyYAcIAANEBAJwFyFHkAeQDYQvDPcIAAeCYggGB5 +AdiA4AHYwHg48M91gAB4JiCFYHkB2CMIUAAghWB5AdgbCNAAIIVgeQHYDwiQACCFYHkB2MEIUYAB +2B7wz3CAAHgmIIBgeQHYheAB2MB4FPDPcIAAeCYggGB5AdiB4AHYwHgK8M9wgAB4JiCAYHkB2IPg +AdjAeC8IUAAghut1YHkA2Bpwz3CAAHgmIIBgeQHYuHA32AohwA+pcpTb4QAv/gokAAS9AY/84Hjx +wM9xgAAkCgCBIQhQAAohwA/rcs9wAACHJ4ojRAZKJAAAsQAv/rhzz3KAACAKAIKC4Mwg4oHKIcIP +yiCCDwAAiCfKI4IPAAAaAcoiwgfp9TcIkQDPcIAA6glgiM9wgAB6z4QrHwAyIEAOFQgeAM9wgABE +miAQgAAJCFEAA9gh8ALYAKIf8M9wgABEmiAQgAAtCFEAz3CAAOoJYIjPcIAAiM+EKx8AMCBADgro +z3CAAOwJAICGIDmPCNgD8gHYAKIA2ACh0cDgfvHAz3CAACAKABAEAM9xgAAkCgARBQBMJACBzCVh +gMoiwgfKIIIPAACJJ8ojgg8AAFMB2Afi/cohwg/PcIAA+AkAgADbz3KAAPQJDyMDAACCZngAos9w +gABUzyAQgwCB4wXYF/LC489ygAAwMwmCDfKMI8KBBvKMI4KCB/KAuAfwRSDAAAPwRSBAAQmiAtgA +odHA4H6A4ADayiCBABHyz3KgALAfAdt5os9ygADQHUiCYIICI0IAcHHCIm0AQnjgfg3Ix3CAAEjM +NIgB4S95NKgdCTIBAxICNs9wAwCEAKAaAACKIAgABhoYMAvwiiAQAAYaGDDPcAIBhACgGgAA4H7P +c6AAsB8B2lmjz3OAANAdaINggwToInsJCMQAANgD8Ehw4H7PcqAALCBwggnoAiNCABMOhHAAgAAA +DwiEAADYBPD/CMWAAdjgfuB48cBCD2/8mHClwSh3uHMA3gQjgA//AAAAGLoFem95CLn/2Ai4ZHgo +uAV5RXkI3fQkgAMneETAegugCxAUADESFAIxYb1AKAEEBXlHeUTBEBQCMRQkgDNAsNcNdZAB5lMl +wgVApwAUDQEH2QfwEH0UJ0wQALRhuRQkQDC7e0+9AJCle3B76Qm1gHhgBCCADwAAAP8QuAV6QKcR +B2/8pcDgePHASglgBgDY1giv/QDYz3CAAIA8qgmP/c9wgABgPKIJj/32DM/+RgsACADYbgrgAoDZ +eglAC5oNQAJCDIALbgmAATINgAIA2L4JL/8IcQ4OQAqiDYACPgxgAf/Y1ghAAYoghQ8Ica4IIAUI +ctHA4H7xwDYOb/yKIP8Pz3WgADgux4UHpc9woABULguA07gGJgBwDwD//3YKoAwW2XIOgAHHpXEG +T/zgeOB+4HjxwOHFAN3PcIAAaAmgoM9wgABskKywPgugC6lwmg9P/coKIAupcKYKgAMeDg/+WghA +AYogBgoIcS4IIAUIcmoM7/ypcEIMz/wlBk/8ANnPcKAA7CcroOB+8cCeDW/8E9nPcIAAEI1qC6AM +AN3PdqAAyB+CHliTSiTAcqlwqCAAAs9xoACAHxV5oKEB4ALYix4YkEzYi7iDHliTgx4YkA/YiB4Y +kM93gADIHQCHAeAApw8IUQAB2FEeGJCmCwANz3CAAOQyAIjPcaAA7CeB4AHYwHgHuIO4ELiFIJEA +BqFaDq/8AdgB2M9xoADsJwahAIdCIECAAKcE9FEeWJMmDsAAXQVP/PHA9gxv/ATZpMHCCqAMi3DP +dYAAyB0AhQHgAKUVCFEAAdnPcKAAyBwxoDILIA0ocM9wgADkMgCIAN7PcaAA7CeB4AHYwHgHuIO4 +ELiFIJEABqHiDa/8AdgAhUIgQIAApQX0z3CgAMgc0aC2DcAA9QRv/KTA8cChwYtwUgqgDAHZng3A +AKHA0cDgfuB48cChwYtw5gmgDATZAMBRIECAGAxiBsogogAAwFEggIDIDMIKAMBRIMCAaAyCBgDA +USAAgVAJggaiD6ALAdjPcYCu4AHscCCgAcjscQChz3KAAJSNiiSBfQDZqCAAAvAiQwDscGCgAeFu +DeAAANihwNHA4H7xwOHFo8EB2EDAz3WAACAXqXBmCaAMXNmeD8/+OoUbhSR4PIUEeYHAOgwv/0HB +AcEbhSR4QcBVJUAfvgwv/6lxz3CAAJgYsgwv/0AlARuLcMYL4AAE2QINL/8BwACFhugFhYDgEA4B +/w4Pz/79A2/8o8DgePHA4cXPcIAAvEEAgKLBQcCBwAHdQgmgDKlxQMWLcIYL4AAE2dEDb/yiwOB4 +8cChwYtwJgmgDAHZAMAvJAcAABwAMRsI3gEHEgU2CiHAD+tyiiDFAKUC7/0n24IOYAFA2EoMwAAW +CAAHocDRwOB+4HjxwBILT/zPdYAAjB0ChSOFAd4QccB+qXDOCKAMA9keDMAABO4ChQPwAIVVA2/8 +A6XxwOHFz3WAAJwIqXCqCKAMAtn6C8AAIIUL6c9woAAsIFCAz3CAAHg5hg8gC1lhKQNP/OB48cDh +xc91gACkHalwIgigDBDZABUEECEMUABBDNAAKQwQAQohwA/rco/YjbiY2/kB7/24cwGFDLgEIIAP +AQAA8AGlDPAhhc9wgACcMiCgI4XPcIAA9xUgqAPM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7js +cQChARIBNuxwIKCaC+AAAdidAk/84HjxwADYz3GAALQdAKEBoQKhz3DQ/gAABKEAFgBAABYAQAAW +AEAAFgBAA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoD4L4AAC2FYNQALR +wOB+4HjxwAAWAkChwUDCARSAMA8IHgDPcYAA9I8E8M9xgAB4sUChYIkB2gjwABYAQBUhjAAApAHi +fXj1CIWAFwseAAAWAEED8ADYFSGMAACkAeL5ClSBA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbif +uOxyAKIBEgI27HBAoNIK4AACiaHA0cDgfuB48cDhxc91gAA8Cqlwrg5gDAjZAIXPcaAAuB4CoQGF +A6FCCsAAiQFP/DkCwADxwKTBi3CKDmAMENkDzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEA +oQESATbscCCgAMBRIACAA8AG9ALB5g7gAADaBfCuDiACAcEuCsAApMDRwOB+CQAAAAUAAADxwNYJ +wADdB4AK4HjxwOHFtMGLdalwbg5gDBTZAMCG4Mwg4oEG9NoL4AKpcAhxI/APCJEAngzgAqlwCHEb +8BEIUQAeDuACqXAIcRXwg+DMICKCB/TOCuACqXAIcQvwEQgRAToM4AKpcAhxBfA7CFECAtkDzNdw +AAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HIAogESAjbscECgggngAChwgQBv/LTACiHAD+tyfNiN +uHfbi7tKJAAAbQev/QolAAHxwOHFosGLdalwug1gDALZKg7gAqlwAgnAAEkAb/yiwAAWAEDxAMAA +8cDhxc91gABIzqlwjg1gDAPZAYXPcaAAgCUMoQKFDaEAjVEgAIAA2I64BPIPoQPwEKG+CMAABQBP +/OB48cCKDy/8FdnPdoAABJ5SDWAMyXCeCMAAAYbPdYEArB1aC2ACAKUEFgUQKw0QAAAWBBBMJICC +yiLFB8oghQ8AAPsqyiOFDwAAdQC4BqX9yiHFDwgWBBBMJICCyiHFD8oixQfKIIUPAAD8KsojhQ8A +AHgAkAal/colJQADhhkI3gD+CYAFCHHPcIAA5DrKCwALAtgD8AHYYQcv/ASl8cDqDg/8ABYEQM91 +gAB4n3QdABGMJAGJyiHND8oizQfKII0PAAD+KsojjQ8AAMUANAat/colLQAhDHQAAN7Pd4AA4J9A +JwATegxgDArZAeYdhc9+8Q4EkL4PgAD1Bg/8z3CAAJCvqQagAIohHwTgePHAfg4P/AAWBEDPdYAA +BJ5UHQARTCSAgsohzQ/KIs0HyiCNDwAA/SrKI40PAACqAMQFrf3KJS0AAN4M8FYlwRITbhV4OGAO +DGAMCtkB5s9+FYXtDgSQUg+AAJEGD/zgeM9wgQCsHSGAz3CAAJCvzBhAAC0GoADU2fHA/g0v/ATZ +o8EA3kLGegxgDItwA8zXcAAAAEAB2MIgCgAXuAAggQ8ADgAABhQAMRt4E+AEIIAPAAD8/yV4nbif +uOxxAKEBEgE27HAgoADB7HAgoAQUATHscCCwBhQBMexwILAGFAQxGwweAAESBTYKIcAP63LPcAAA +TyYBBa/9adtCCaADAdgCwQDFJXhCwM9woAAsIEAQEADAvQHlA/AB5gYUADGBDgMQBBQAMYLHLQ2R +EBt4EHjpcRIKoAOpcuxxAKkEFAAx6XEbeAHgEHj6CaADqXLscQCpCPDpce4JoAOpcuxxALEEFAAx +QCBFAM9woAAsIBCALyVIAQIgAATXcAEAoIacB+X/BBxEMQgUBDAKIcAP63LPcAAAUCZhBK/9jNuO +CIADSg6gAALANQUv/KPA8cAAFoVApsENDTMGABxCMRsNEwIKIcAP63LPcAAAZhmV2ykEr/1KJEAA +ABaAQAEcAjAAFoBAAhwCMAAWgEADHAIwi3BuCyAGgcECwo7qABSFMAohwA/rcs9wAABnGZ/b6QOv +/Yokww8EwGB6BcEDwYvpCiHAD+tyABSFMM9wAABoGaPb7vEBwIDg4yBCAMogIgBqDYAApsDRwOB+ +8cDPcIAAPC4CCmAMCdn2CcAEvg6ABPYOgARGDYAA0cDgfuB48cDPcIAAQDDeCWAMB9kuDYAA0cDg +fuB48cClwYtwyglgDAXZFg2AAKXA0cDgfuB4CQfgBQDY4HjxwM9wgACoMlIJYAwo2fYMgADRwOB+ +4HjxwOHFABYAQM91gAAgGQClDwiRAADZz3CfALj/PaDODIAAIIVBCVUBMyZBcIAAVEBAJwByNHgA +eIYLIANU2CkIXgDPcYAA3DIAgYG42g6gDAChCvC6Dq/+AdjuCwADBPA2CEAE0QMP/PHA+glACH4M +gADRwOB+4HjxwBIJ4AgA2M9wgABcH8gQAQbAuYHhAdnAefIKoAw8EIAA0cDgfuB48cDhxc91gABc +HwCFxBAABh0IXgEKIcAP63KF2I24iiOcD0okQAB1Aq/9uHOqCgAKSghgCwHYz3CAAKQiCIg9CNEB +AYXEEAAGMQheAY4Pj/3PcYEAeBYEkCWBCrgdCEAACiHAD+tyhtiNuIojXQJKJAAAKQKv/bhzZgwP +/ZYPoAoA2N4PwALGC4AADQMP/OB48cCmCeAIANi2CY/9z3GAABC+Aok+CqAMIInRwOB+4HjxwKLB +i3DuDyAMCNkAwM9xgAAkMwChCOgGFAAxA7EEFAAxArF2C4AAosDRwOB+4HjxwDYKL/yB2KHBYMAD +zADfz3aAACAKAhwEMM9woAAsIEAQEQAAhgEcwjMQ6M9xgADsCQCBgbgAoc9xgAAwMwOBAeADoQHY +A/AC2BpwAMDSD2/8CnHPdYAAMDMDEgE3XpWB2GCGFgjgDAokAATPcKAALCAQgEAdQBQRpUgdABSX +CJAgAIYnCBECz3CAADQ8Eg7ACtoLr/4U2EYKYAQE2OCmz3CAACQK4KAA2AsIUAEA2Ajwz3CAACQK +AID3CBGBAdgvJgfwDfIKDSADFNiJ6M9wgAAYPCaAI4EggTYOwAoAhgPoANgH8M9wgAAkCgCA++gB +2C8mB/AF9PIOQAIL6M9wgADsCQCALygBAP4J7/1OIMAHhQEv/KHA8cAeCS/8gNihwQMSATdgwM9z +gAAgCmCDz3WAADAzAhxEMC+lKHJKIAAgARwCNDYPoAwKJAAEz3CAAKglEBAFABsNnwAAFAQwCiHA +D+tyz3AAAHYnTQCv/Wbbz3CAACAKAICA4HQCAgDmDsAJgOBsAgIAz3CAAEAwAIBRIACBXAICAM91 +gAD43qlwIg4gDIohCw8CFYQQRCQ+gw30AxIFNwohwA/rcs9wAACOJ/UHb/1320EswQDAuc93gADq +CSCvqXCEKR8AACGBf4AAeM9qCGAKv9pgjwohgC+AAJTPhCsfAAAhgn+AAHjPBZKGIH8MHHhTIICA +CPTPcYAA7AkAgYa4AKECis8IXwCEKx8AACGAf4AAdNKWDSAMGNkAj4QoHwAvcDQhDSBCJQQWjCQH +gcz3CiHAD+tyz3AAAIEnmNthB2/9iiUHAc92gACw0thgWg0gDIhxAI/PcYAA/AmEKB8AMiZFHgAm +QB4AoRsNEAAKIcAP63LPcAAAdyed2yUHb/2KJIMPoYjPcYAAAApAJYUQQCWCHx8N9AhAqQohwA/r +cs9wAAB4J6Pb+QZv/Yokgw/PcYAAMM/KDiAKqHIAj4QoHwA0IUEuz3CAAOgJILAf8BwSBAGMJAiA +zfcKIcAP63LPcAAAiyes27kGb/2KJQgAhCsfAAAhgH+AAHTSrgwgDIhxz3CAAFTPIBgABADZMvAA +FgJAhCsfAAAhgH+AAMTVMOA1eECgABYCQQAhgH+AAETWMOA0eECwABaAQAAhjX+AAGTUUmlUerpi +EKoRqhKqABaAQBSqFaoWqgAWAEEAIYJ/gACA1jV6GrIAFgBBAeEbsmCPhCsfAAAhgH+AAHjPQ4iP +CaSAL3UAJYEfgAD01QAlgh+AAHTWjg7ABkCPAciEKh8AACGBf4AANNcAoQDAVgxv/AHZ6gxAAoDg +qAjCDAMSATfPcIAAIApggIDYKHJKJEAAGfAEhQHgBKXPcKAA1AMckJ4JAAEAwBoMb/wC2QMSATfP +cIAAIApggIDYKHJKJIAAXgyADHUG7/uhwPHACiHAD+tyz3AAADAliiOMB4okgw99BW/9SiUAAOB4 +8cDhxSDbz3GgAMgcaaEAFgBAz3KgABAUDKIAFgVAAd1MJQCAyiHBD8oiwQfKIIEPAAAsJcojgQ8A +AAkBNAVh/cokQQMYGkABaBlAAQPYD6K5oWqhzg5AABUGz/vxwOHFrcGLdalwagsgDA3ZAMAdeFMg +AQBEKT4NqXAAIYF/gAAI6oYNIAoN2poOQADhBe/7rcDgeAEGoAwA2OB48cBaDe/7DNmswSoLIAyL +cAAUADGv6M91gABwJiCFz3aAAEQpYHkA2EAkjzAjCBADIIVgeQDYGwgQBCCFYHkA2A8IUAQghWB5 +ANgPCJEE6XDJcRjaBPDpcMlxLtpaDAAKAdhgHgIQF4aA4KALYfzKICEAABQAMSkIUQBAJIAwz3WA +AEQpQCWBGy4MIAou2gHYN4VhHQIQgeFwC0H86g1AACEF7/uswOB48cCmDO/7F9m3wYIKIAyLcCPA +SiJAIFMg0ACGIP4DQigRASUIMiQMHAI0CiHAD+tyctiNuIojDwMKJIAE8QNv/QolAARIFAUwIMBA +KI4gz3WBABAO1n5RIACAwGVBLU8DwL++ZoYg9w9c9I3oCiHAD+tyc9iNuIojzwS1A2/9CiQABIog +TwUKcZoOYASocgHAAsEKcv4NL/xmbn8IEADpcDIPYAwKcQ0UgDCFIMEADRwCMIog/w9TwACGqbgA +phLAhiD7Dyi4D65KJAB0ANioIAAD/9q7YEAogSA2eRLjO2NAqwHgCnA6DmAMi3HPcIAAXB/wIMED +wBEABg8gAATAGRgAD44PCFEAgOfMIKKjzA2CDAHfAvAC354O4AEKcAfwgODKJ4EUyiciEoHnuPQg +hs9wgABcHwOAGIgodYYl+x8hCFAA6glAAiCGGejPcIAApCIIiCcI0QFBKUADHwgeABPAEsIXCB4C +hiL7D0EqBAJPjgsKAAGouFPAE8ASwgZ5RHgleACmhiD7DwvtgODKIAEEyiEhAMgOIQPKIuEDDh5C +FADYz3GBAFARFiEBBECGAKEBoQsKXwUA2Iu4AaEPCp4FAYFFIAAGAaGeDW/9i3ANFIAwPwheAVgU +ADEFtloUADEGtgWWF+hOCUACDugGlhMIXgDmCW/9CnDqDIAMBdgSrgDYBbYH8ApwANlSDiADD9oN +FIAwNQheAFAUADECthToAN0Q2DpwApYRIECDyiACBMohQgMoDiIDyiJCA0IhQCDnCHWAAeUNFIAw +DwgeAQpwzgvgAFUUgTANFIAwOwjeADXBVhQCMQpwbg2v/RLDjCACgLhwDfQKIcAP63J02I24iiOS +D6kBb/1KJEAAUSXAgconIhHWDmAMCnADzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQES +ATbscCCgXgtgAOlwOQLv+7fA8cDOCe/7iiBTCaTBAN2pcUIMYASpcs92gQDQFQCOSiRAIKGuAh4C +FQHgAK6jrqGmoqakpqWmuK65rgHAuq4CwQemA8AopgmmgcByD+ALAdkBwAemenWJ8ILAYg/gCwLZ +AY4DwQHf464B4AGuAsAppgimsg4v/ItyBCAABS8kB6AC2SOuAq4AwSGmbfISaRZ4z3KBABAOAGJK +IQAgDyFRIC24UyAQAIogVAWqC2AECnLPcYAAaAlAgS8iSiT4rhAeQBQEIoCgFB4AFAChA9kjrkKm +A6YG9AbqqgkgBCDY+a4F2AOuIMBqCuAAENkAwDJoNnkAIYIPgQAQDoohCACisiCiBtkjrgDZhgwg +Aw/aAMKA2RJqFnjHcIEAEA4oqCmoB9gDrs9wgABcH/AgAATPc4EAUBFWe8AQAQYEIYEEwBhYAADZ +IKPPcIEAcA0ho1R4xgqgDKCwB+i2CoAMCNgDrvquQCNTICHAcnDwBs3/CdgDrgPM13AAAABAAdjC +IAoAF7jHcAAOAACDuJ24n7jscQChARIBNuxwIKDWCWAAinAK2AOufQDv+6TA4HjxwIogVQsA2Z4K +YAQoctYMAApSCUAA0cDgfuB48cDhxQAWDUADzAHa13AAAABAAcjCIooAF7rHcgAOAACiDSAKUyUB +EFElQJDPcYAAUDUB2MogIQBZAO/7AKHgePHAocGLcK4N4AsB2QAUBTAZDREACiHAD+tyidiNuEXb +NQcv/UokQADPcYAAHMwDGUIBQC2AAwKhSiTAcADaqCCAAgDYDyCAAAsgQIED9AHiA/AOuAGhsghA +AKHA0cDgfvHAYg+P+wAWEkEAFgBBz3GBABAOQCqAIBZ4MCEFAKLBQS1AAyMKNCRTIBMACiHAD+ty +ddiNuIojGAJKJEAAuQYv/UolAAAdDV4CCiHAD+tydtiNuIojWAKdBi/9CiSABM9wgQBQEBYggAQa +cOYM4AsC2c9wgQDwDBYggATWDOALAtlAKpUhACWAL4EA0BHGDOALENmLcL4M4AsB2QAlgC+BANAR +hg0gBhDZARCAICEIEgQKIcAP63J32I24iiOYCkokQAAxBi/9CiWABADdENg6cBUlQCPPcYEA0BEw +IRQABCSCrwAAAAEEHAA1SPJEJA4mI74B5gQkgC8GAAAAMbghwd9goOHRJOGiNfID6hcOlRAEJIQv +AAAAJFsMgA8AAAAkUwjVAA0IkQAl6kcOkRAE6szhPgAJAM9wgAB4JiCAYHkG2C8IhAPPcIAAXB/w +IMAEwxAABgHZBCC+jwAGAAAEJIAvAAAACMIhQQAruAsJBQAA2ALwAdgPeATwAd/pcAQkgS8BAADA +LrnPcoAANFgpYjB3AdnCIU0AgODMISKAFvJCIUAgLQh1gAHlAhCAIM9xgAAYTghhOQhQAAohwA/r +cnnYjbiKIxkAOfEKIcAPz3CAAFwf8CDABOtyiiNYD8MQBAZ42I24DQUv/QolAAUDEIAgCGEXCJAA +CiHAD+tyetiNuIojmQIZ8SoKYAxKcM9wgQDwDBYggAQgkM9yAAAYFQkhgQCCDiAAILCFBa/7osDg +ePHAABaBQM9wgABkPSCoABaEQAAWgUDPcIAAbT0gqAAWgEBQJL6ByiHCD8oiwgfKIIIPAADaFMoj +gg8AAIEHhAQi/colIgDPcIAA9AgAkAboagsADI4KAAwaDgAA0cDgfr0GoAsA2OB48cDiDK/7ANlK +JAByqCBAAgAWAkAVIkAwDhiYAAHhABYNQAAWDkBWC8ALz3CgABQErKDPcKAA1AvcoNINAAARBY/7 +4HjxwJYMr/sI2aLBARIONs91oAA4LhwVEBAGCuALi3AAFAQwAN8EJL6P8P8AAMohwg/KIsIHyiCC +DwAApijKI4IPAADhBtADIv3KJcIAUSRAgsohwg/KIsIHyiCCDwAApyjKI4IPAADkBqwDIv3KJcIA +56VyDmAMP9gAwAQUATEHpYII4AuCuRwdABQ+DSAAARqYM2kEr/uiwPHAANiaDCAABBKBMAQShTAK +IcAP63I42IojDwFhAy/9SiQAAOB+4HjxwOHFocEf3YtwqgngCwTZYb35DVWQ8gwAADkEr/uhwPHA +qcGLcDoK4AsS2doMAACpwNHA4H7geAAWAEAAFgBAABaAQAAWgEAAFgBBABaAQAAWgEAAFoBAABaA +QAAWAEEAFgBBABYAQJ0EAADxwOHFocEL3YtwPgngCwTZYb35DVWQhgwAAM0Dr/uhwPHArcGLcCIJ +4AsN2W4MAACtwNHA4H7geA0FoAsB2OB44H7gePHAz3CBAFQc+gjgCwbZSgwAANHA4H7gePHAEguv ++0Laz3aAAHB+z3CAAEx8DgvgCUAmgRnPd4EAVBxAJwASQCaBFPoK4AkE2gKXyXURtgPMiiTBctdw +AAAAQAHYwiAKABe4x3AADgAAhSAEDZ24n7jscQChARIBNuxwIKAA2aggAALwJUIQ7HBAoAHhBQOP ++/HA4cXPdYAAAHypcGYI4AsT2bYLAACiD2AJqXAB2c9wgACkCO0Cr/shqOB48cByCq/7AdmhwT4I +4AuLcADAz3WAAKB/ABUFEKBwEHiU4MohyQ/KIskHyiCJDwAAuCHKI4kPAACQALABKf3KJGkAAN4M +8CCFBG3ZYYQpAgUncPYPoAsl2QHm0H4AwOsOBJA6CwAA2g4gAQAUADEAhQDBOGAApWkCr/uhwPHA +z3CAAKQIqg+gCwHZEgsAANHA4H7gePHAz3CAAFR9kg+gC0rZ+goAABYLgArRwOB+4HjxwM9wgABM +fI4PoAtC2d4KAADRwOB+4HjxwM9wgACgfV4PoAvQ2cYKAADRwOB+4HjxwKHBANlAwQAWAkAAFgBA +NQpQAAPM13AAAABAAdjCIAoAF7jHcAAOAABFIAADnbifuOxyAKIBEgI27HBAoOxwIKAf8OYOoAWL +cAPMAdnXcAAAAEAB2MIgCgAXuMdwAA4AAIS4nbifuOxyAKIBEgI27HBAoOxwIKAAwuxwQKCCCiAA +KHChwNHA4H7gePHAAgmv+wLZz3eAAIA9eg+gC+lwQIfPdqAA7CfPdYAAeCaXCh4AK4ZEIoAAhiL/ +DiK6obkUurS5BSCDAGV5K6YEIIAPEAACAAQigg8QAAIAz3GAAAgIRXgLoSCFBN5geclwGwjQASCF +YHnJcA8IkAEghWB5AdglCFEAAIfPcaAAyBwRCF4AAdgeocINwAUG8ADYHqEiDYAFIIVgeQHYaQhR +AQCHYQjeAM9woABEHcWgw6DEoCjwz3CgAMgcAdk+oAuGgbgLpoYNwAUghWB5AdglCFEBz3CAAFwf +A4AIgBkIHgAA2ZS5z3CAAAgIK6ALhpS4CfDPcIAACAgA2SugC4a0uAumKgkAAGEAj/vxwM9wgADw +FHIOoAsC2RYJAADRwOB+4HjxwOIPb/sA2gh1KHbPcKAA1As4gEIhAQiA4cohjABAJgASEHEACEUM +A8zXcAAAAEAB2MIgCgAXuAAggQ8ADgAAB24EIIAPAAD8/yV4nbifuOxxAKEBEgE27HAgoCK+BvDs +cQChBOVhvvkOtZAAheIIAADdB0/74HjxwOHFz3KgANQLA92xogDbcKIDEgI313IAAABAAdrCIooA +F7rHcgAOAABFIgIGnbqfuuxzQKMC2hQagjAFEgM27HJgogsSAjcB4gsanDDscgCiARICNuxwQKDs +cCCgz3CgALAfAdk5oM9xgADQHQiBQIDscECgDIEAgF4IAADPcaAAyDsOgYi4DqFVB0/74HgDzNdw +AAAAQAHYwiAKABe4x3AADgAATyCBAJ25n7nscCCgz3CgABQEA9kloAESAjbPcKAA1AtNoM9woABE +HTWg4H7geAPaz3GgABQERaHPcaAA1AsNoc9woABEHVWg4H4D2s9xoAAUBEWhz3GgAPwLDKnPcKAA +RB1VoOB+4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOHF4cbPcKAAFAQD2SOgDcjPcoAAPM1h +ks9xgAAszMSKFCENAGi1ACCDD4AATMw44cCrYoIVeQaSYKEDEgM2wB0EEASCoBMBAIYhww8leKAb +AADBxuB/wcXxwOoNT/sIdloM4AEodYDg0SVikwHYA/QA2AS4z3WBAJgWFHgJZR1lFQlRAFII4Aqp +cB4JL/4BjQDYAK0BhRkGb/sApvHAmg1P+6LBDRICNs9zoAC8Lc9wgABcH06jJIAA3UYREQENEhA3 +ViEGBUYgwCADEg42DRocMKQWABCEuKQeABABllYhiARWIUcEhh5EEwjoz3CAACzN9CCAAAnoAYYP +CJ8DUCAAIC8gCCBTIH6gSAMBAM9wgABQNWkQAAbPcYAAUDUB4GkZGAAEEgE2pBlAAwGWjwgQAM9w +gAAszFR4gBAPB38PERDQEAMBUyPDgBX0chYDEeCWYn+4FoMQYn/wf+AYxAOkFgMQhiPzjwXyaL/w +f+AYxANwFg8R4BAAAWGW4njxcMInDhDCI84DdBYAERtjuBaAEHQZRAOgsXhgEHiQGQQAvhkEABCO +ANsQqQGGAaEIjgipEo4SqZa7MPAPg/8I3oVvg1MjwAJVC54FIQiVA89wgABQNacQAAa2u892gABQ +NQHgpx4YEBrwZLgQeJAZBAAEI4APAAAA8Cy4EKl0GUQDoLGhsb4ZRAMBhqiphiD/DYS4AaESjhKp +9rs4AgEAANiWuKQZAAApC14Ftgjv/gDYBBIBNqQRAAAEIIMPAgAAAC27BSMCBC8giCA+8AGBpQge +AXCJT3pJIsAAz3KBABAO8mv2f+Ji0okRCp4Fz3KBAFAQdnpBigPwANrHcIEAUBB2eASICCYOEAgm +ghBJIsIDFmtVeM9ygQDQEQBiz3KBAFARdnrPc4AAXB9kg3iDQYJlegQigg8AAAAIRniYGQAAANiW +uEGBhiL/DUMIHgWhChAAmBGCAEAnAAlIYM9zgACQsUDAIMLDulx69COCAFLwCiHAD+tyNNiMuF/b +BbuKJIMPuQLv/EolAACYEQMAnBlAA0kLXgKAuKQZAAAo6pgRgADPcoAAXB9DgoYg/wNEuDImAACJ +uEDAIMNUgmR6hiP/A4Yi/w5Eu3piT3rPc4AAcE70I4IAHvATCx4CCOqYEYIAQCcACUhgC/CF6gDa +SHAQ8JgRgADDuBx4MiAAEEDAIMLPc4AAOLHDulx69COCAIgZAACYEQAAhBmEAJARAQG6CCAAANoE +EgM2AxINNs92oADIH4QTAgGCGwQAGmJQerAbhAD4FgEQsBUAESJ4ACBPBM9wgABcHwSAVBABAT9n +X2egFg4Q8H87DsQTEICYFQ4QCyCAgxf0cIsQjXBw0SYikhryhib/GUEuwxAB4ykLlAACuBZ4z3OB +ABAOAGMZCF4Ez3GAAFA1uBEABgHguBkYABDwWWEweYYdRBDPcYAAUDVqEQAGDRocNAHgahkYAEUC +b/uiwOB4ocHxwNoJT/sIdUbA6L0ocM4AIQBIdgO4QCCQBUQlAhYjugQljx8GAAAAAeJBL0AUBCWB +H8AAAABYYDa5z3KAAABYqXPGuyliCGI4YEEtgRJSIQEAwLkDuRjhheDKIY0PAQCJDdUhDgAvIUgg +BCWBHwAAABjPcIAAxE/XcQAAAAgeACIA8CDAACbBoOESAAEAz3FCe9BeBSh+AAogwA4KcQUpPgAK +IMAOJLgB4ATvUyABADhgAimBIyENXhPPcoAAAFFAkgUqPgAAIYB/AAD/Py64XwAgABlhVwAgABV5 +USVAklYAIQAmxbflIgALADNoUyUCEM9wgAC4TvAggAAFKT4ACiDADgHgBvCK5cAo4QDAKKIAz3GA +AFwfI4HA2jSBpHmGIf8OIrk6etp6GWIweAjcDwFP+zNoUyXAEBx4z3KAAERR8CIAABbhBSk+AAog +wA4B4BTZhQfv/9p5z3GAANAdJIFBKIIF1bgggUEpgwXVuQJ5z3CBAHgWYnoFgMm6BSi+ACdxz3CA +AIA8A4AAgOB/OGDPcYAA0B0kgSCBQSiDBdW4QSmCBdW5GQklAFtjz3KBAHgWRYJZYQJ5AeMD8AJ5 +QCuABZkH7/8lePHAxgpP+xIIb/tQ2UXASiAAIG4Ir/6GxSMINSUEFQEUBcAVIAAEIKBAIFAg7QmB +j63e774k3EcAT/sKIcAP63LPcAAAixOKIwcLmHNJB6/8CiUABPHA4cWYcBkI9AC4cQohwA/rcn3Y +jbgtB6/88NvPcIAAXB/wIAEBiiMLDUAhAgZ4Yk8NEQCogXpioKJJgUGgXIlIqF2JSagqEYIASqgr +EYIAS6gsEYIATKhNkUewV5FIsEiBBCKCDwAGAACA4gHawHpSqFSRU6gogcC5Laga8DkNUQBiYkih +QYBJoUiIXKlJiF2pSogqGYIAS4grGYIATIgsGYIAU4hUsUeQTbEIkBexjQcP+wohwA/rcpDYjbiF +Bq/8iiOEB+B48cD+Dg/7z3WAAAyQBBUFEEIlQQCF4TYBLQCiwfUmQXCAABhAQCcAcjR4AHgC2ACl +AdnPcIAAiB0gsCYMoAgocAKFz3OAAEwdKINHgwgTBAAPIEAAAqXPcIAALB01eECgGBMFAQwTBgDP +cIAA5C4A2TSoz3AAAESfQMAFgxATBwBBwBqLO4tAgxIIoAlhg1zwz3CAAIodAdkgqM9wgABMHSeA +z3CAAIDLL6CmCe/9AthK8ATYAKUA2M93gACIHaILoAgAt892gABMHQKFSIZnhg8ggQDPcIAALB1V +eGCgIqXs2I4I4ANAlwgWBBDPcAAARJ8YFgURDBYGEEDABYYQFgcQQcAajjuOQIaSD2AJYYYkFoAQ +SIYA2VEgAIEEhQ8hgQAK8gHbz3KAAOQudKoFeSSlBPAmeASlEg6gAwDYBPAODs/8IQYv+6LACBUE +EAohwA/rcs9wAABCHyEFr/yKI0QH4HjxwOHFAd3PcIAADJCgoADYz3GAAIgd5gqgCACxXgwgAKlw +8QUP++B48cDhxQDYz3WAAAyQWgggAACljg+v/QLYIoXPcoAAiB132MIPoANAksEFD/vxwEYND/sA +3s93gACIHcC3lgqgCMlwz3WAAAyQwqXDpcSliiDJAMlxjg+gA0CXAdh9BS/7AKXgePHAz3GAAAyQ +ABEFABsNVAEKIcAP63LPcAAAQR+Z220Er/yKJIMPAaHPcIAAdB3wIEABQHjRwOB+8cDWDA/7z3WA +AAyQBBUFEKLBSQ1QACMNkADRDVABCBUEEAohwA/rcs9wAABEHyUEr/yKI0cGz3CAAIodAdkgqM9w +gABMHSeAz3CAAIDLL6DWD6/9AthM8ATYAKUA2c9wgACIHSCw0gmgCChwz3aAAEwdAoVIhmeGDyCB +AM9wgAAsHVV4IqVgoL4OoAOKIIYLCBYEEBgWBRHPcAAARJ8MFgYQQMAFhhAWBxBBwBqOO45AhsIN +YAlhhiQWgBAB30iGANlRIACBBIUPIYEACPLPcoAA5C70qgV5JKUE8CZ4BKVCDKADANgE8D4Mz/xR +BC/7osDgePHA4gsP+892gAAMkAQWBRBCJUEAhOHmAA0AMyZBcIAAJEBAJ4ByNHgAeAKGz3GAAEwd +SIEngQ8ggAACps9wgAAsHVV4IKBZ8M9wgACKHYDZIKjPcIAATB0ngM9wgACAyy+g0g6v/QLYR/AK +lowgAoAR9ADYz3WAAIgdygigCAC1IoaKIAUEzg2gA0CVAdgApjPwA9gApjHwA4aMIMOPAd8S9ADY +z3WAAIgdmgigCAC1IoaKIEUK4KaaDaADQJV2C8/8G/AA2Q8hAQAChgYgQIAS9ADYz3WAAIgdagig +CAC1IoaKIIUMbg2gA0CVRgvv/OCmA/ACplUDD/sIFgQQCiHAD+tyz3AAAEMfVQKv/IojRgDgePHA +4cXPdYAADJAEFQUQQiVBAJMJlQEzJkFwgAAsQEAngHI0eAB4z3CAAIodgNkgqM9wgABMHSeAz3CA +AIDLL6DeDa/9Atgt8AKFz3GAAEwdSIEngQ8ggAACpc9wgAAsHVV4IKAd8AOFjCDDjwHaCfIA2Q8h +AQAChQYgQIAN9M9wgACIHUCwqg9gCAHYA9iSCu/8AKUF8AKlA/AB2AClqQIP+wgVBBAKIcAP63LP +cAAARR+ZAa/8iiNIC+B48cDhxc91gAAMkAOl+gzv/wXYI4XPcoAAiB2g2GYMoANAkmkCD/vgePHA +4gkP+89wgABEmgiAz3WAAAyQAN8nuMC4E3jGuAHgCrUI2DpwAN4ChQ8mzhMLIICDLfIEhQsggIMZ +8sZ4BKXPcIAARJoIgA95IwlQAM9ygADkLjCKhiDDD4C4AeEveTCqz3GAAESaCKHPcIAALB0VINAD +ABAAIIDg4iACAAKFANkAGEAgxngCpUIhQCAB55UIdYDvf0qVz3CAAIgdIJCB4swhIYAH9ADaz3CA +AOQuVKgBhREIUAGB4QPYyiAiAR4Mz/99AQ/7z3KAAAyQIoIA2w8jAwBmeSKiz3GAACwdANoVeeB/ +QKHPc4AADJBCgw8iQgBCo89ygAAsHTV64H8AouB48cDqCC/7GXEIdYh2z3GAAEwdGqkbGQICQKEQ +GcABDBmAAcKhA8AYGUQBBMYHoSbAyKEkGQIAB8BhoQWhU9ipcRYLoAPJcibAEwgeAFfYqXEGC6AD +yXIG2AXwgeUC2MogYgB6C8//8QAP++B48cB2CA/7GnDPdoAAyB0AhgHgz3egAMgfAKYRCFEAAdhR +HxiQvg6AC6QXABDPcIAAfCgmgM91gAD0vWB5ANgBhSnoJNgY2b4OoAsz2h8IUAAEFQUQCiHAD+ty +z3AAAHQZjduVB2/8CiQABCTYAdmWDqALM9ofCFAABBUFEAohwA/rcs9wAACrKJLbbQdv/AokAAQA +hkIgQIAApgX0ANhRHxiQOQAP++B48cDWD8/6z3CAAHwoBIAl6M91gAA8MjKF5OHK9s92gACQPQCG +2uDKICsCjPba4VX2z3aAAJA9AIbk4M/2iiA/DuoJgAsghkgVABEQuQ4P7/8leBKFAKbtB8/64Hjx +wM9wgACcCAGAUSAAgCAIAgDRwOB+4HiB4IfYyiAiAM9xgAB0OOB/AaHgeM9wgAB4OQCAQiAAgMog +YgAH6AHZz3CAAPUVIKgM8M9xoACsLxmB8LgZgc8gogPPIKECGaHgfuB4z3CAAJQwQIgRCh4Az3Gg +AKwvGYGKuBmhEQpeAM9xoACsLxmBjrgZoeB+4HjPcaAAyDsdgQfogtgUoc9wAIARFA6h4H7PcIAA +CM5siM9xgABskIwjAoAKkUEoAgMM8hkI3wICu3Z7x3OBABAOApMPIIAAArMA2OB/DLHgePHAlg7v ++lRohiL4A08iQwJTIcIABSLEAM9ygQBwDRR6j+GKIw8MyiApAAn2AJIA3Q8lTRCKI88PpngAsgDZ +SiQAdM92gACEk89ygAD8k891gAAAlKggwAQUIkAA5JBkfxkPAREA3+SwFiZAEOCg4aBAJQAZNXjg +oAHhhQbP+uB48cAA2p66ANnPcKAA/ERBoOB4IaCiCOAIKHALyAQggA/+//8DCxoYMAvIh7gLGhgw +0cDgfvHA5g3P+kh2gOAB3UT2iiX/HxN4CQkTALN9M3kUIQAAfg/v+jt5rHgAHkAeJQbv+gHY4Hjx +wOHFCHIB3YDhyiHBD8oiwQfKIIEPAACbE8ojgQ8AAFwAyiQhAAQFYfzKJQEBgOJE9lN6iiX/HwkJ +EwAzebN9FCGAACYP7/o7eax42QXv+i9w4HjxwOHFz3WAAGyQz3CAAFwfI4BAhQCBQwoBAAKRQpU7 +CgEAAoUSDG/8I4WMIAKAFfLPcoAAZAkhggDbDyMDAAK4ZnkWeCGiACCBD4EAEA4Agaq4iLgAoQDY +eQXv+gy14HjxwOHFz3AAAP//z3WAAIiQA6XPcIAAHDtCCcAJz3CAADg7OgnACc9wgADgOy4JwAnP +cIAA/DsmCcAJANkgpQXYAaUipeIOb/0G2N4Ob/0J2CEFz/oH2c9yoADUBxoaWIAN6BkSAYYJIEMA +DxIBhgIgwIB5YQ8aWID19eB+8cB+DM/6AxIDNgh3DRIONs9xgAAszBCLz3KBABAO1HkCuBZ4BWIx +iS29WGDAvQzpIYMVCV4Dz3GAAJQetHmgkRDloLElkCMJUgBhuSWwEIsyaDZ5O2Jlkzpih+smklEh +QIBEC0L8jg3ACjIN4AUNyAPIAdmgGEAAz3EPAP//vgggAOlwYQTP+vHA9gvv+gPZz3KgANQHExpY +gA8SA4YAFgBAABYAQKLBQMAgwB8IEAcKIcAP63I12Iy4z3MAAPQMmHM5A2/8SiUAAAAWDUCwfQAW +AEBA5fS4wCWiEAPlBCWNHwAA/P8ZEg6GQiUPFPsOxJO7Yw8a2IAgGliAGRIBhikJFAIfEgGGQcEh +wZzhyiHCD8oiwgfKIKINyiOCDwAAEQ3PICIDzvUEIIAPAAAAQLUD7/qiwOB48cA+C+/6yNqCJAMy +CHUods9xgAAoQvYL7/qLcAHaz3CgABQERKDPcoAASDYYggDZAeDivRiiyiBCIAX0Fg/P/xpwDcjP +caAAZC7PcqAAOC7wIQAAJ4LTuCR4BCCRA6Hw8g7P/xpwnfAD389woAAUBPCg5KAAFgRABxoYMQAW +BUABGlgxBMo/CBEHi3CSCCALDtkkwVMhwACGIf4DRLnEHEIwZMBEJo0UMQ5eEI7YkLigHAAw2Q4e +EYbYkLigHAAwZvDrcs9wAADcDs9zAAD0CvEBb/wKIcAPDwgQIIzYkLigHAAwVPACuBZ4x3CBABAO +QIBIdIQkDJAM8hMKXgKL2JC4oBwAMAHdQvCI2JC4+/FOiFBxyiCCDwAAkQDPICIE8fUBwREJngYB +3ZDYkLigHAAwLvAikDMUgDAtCQ4AB8gEIIAPAMAAAB0IgQ8AwAAAIsCA4MogiQ8AAI0Apgfp/88g +KQQKwYwh/48S8s9woAAsIBCAInjXcACAAADKIIUPAACHAH4H5f/PICUETCAAoMwlIZBm9c9woAAU +BOOgTCAAoKl2YvVTJn6QCPLPcKAAFAQJgIDgWvVlDl4QAdpXCRAgKnEvKEEATiCDB5TjyiXFEIX3 +aHWAJcIUz3CgAGgs8CBAA5TjD3jKJ8UQhPdod4AnwhHPdaAAGCzwJc0TsXDKIiIACeoA2A8gwAAG +IQGA2vUB2ALwANiA4CjzgQHv+oAkAzLxwB4Jz/oacBoJ4AEw2JhwKbhRIACAyiHCD8oiwgfKIIIP +AADpFMojgg8AAMcAcABi/MolIgAs2CoJ4AFAKIEgAd6KJQ8a3gjgATDYmHApuBkIHgCMJg+aJvIy +D2ALAdhhvecNdZAB5roI4AE02E8gAQWVue4I4AE02KoI4AEs2Ah1ogjgATTYuHAzCF4FCiHAD+ty +z3AAAOsU49sBAG/8SiQAAAohwA/rcs9wAADqFNTb7Qcv/EolAADJAO/6QS0AFOB48cBaCM/6CHcA +3slwggygBMlxA9jJdRpwCe9ELT4XACGAf4AA6DmaDIAJCu9ELT4XACGAf4AAkDqGDIAJQiBAINcI +dYAB5c9wgAD4mcl0nbAwvJ6wz3CAAOQJegngBcCgXQDP+uB+4HjxwNIPb/3hxc9zgABQNc9xgAAk +PUCB9BMNABkNpBAA2PgTAQANCYQA/BMBADByw/cB2D0Az/rgePHAz3CAAIwIABAEAAESBTYKIcAP +63LPcAAA2w4dBy/8j9vgeOB+4HjxwIoPj/rPcKAAVC4rgAfd07kvKEEATiCPB89woADAL6UQEoYU +EBGGz3agABQEqqY6DSAIgNjz2AW4gNmaD6ABn7kNEhA29dgFuI4PoAGpcaqmDRpYMwTwA9gFpqmG +G+187UEtgJAK8i8kCXDgeKgggAEAFgBA4HhTJU2QCfIvJElz4HioIEABABaAQOB4qYbo8fPYAg+g +AQW4yQjfh/XYBbg2D6ABCnEoHgAUlOcNGhg0yiHFA4X36XGAIcIBz3CgABgs8CBCAJTnyiHFA4X3 +6XGAIcIEz3CgAGgsNXgEv0Cgx3eAAEzoFYc2hwV5F4e4hyV4BSUNkMohwg/KIsIHyiCCDwAAwiHK +I4IPAACNB8okQgP8BSL8yiUiAIDZz3CgANAbMKDPcKAAwC+lGJiEFBhYhLEGj/oC2c9wgAAgGd0G +oAEgoOB48cA6Do/6pBEAACh1USAAgArYyiAhBJgVARAEIb6PAQAAwHYdBBAw9C0JHgJEIQAGI7hB +aAQhgA8GAAAAMbhYYAQhgg8GAAAB13ICAAAByiChAAPwAdgjCFAAFQiQAIPgANjKIOEBwCihAwvw +z3CAABzMAoAF8M9wgAAczAGABXmYHUAQnhUAEZQdQBCSHQQQghUAEZAVERGyHQQQANiAHQQQfh0E +EAPIz3agANQHQZAQFZIQCOoNyM9xgAAszfQhAAAT6BkWAJYfCBUODczPcYAASDZGIIACDRocMBqB +AeB/AiAAGqEPFhSWCeoNyM9xgAAszfQhAAAD6AHYBfAD2BMeGJAA2AcSDzYBEhA2ABYEQHpwBxoY +MQAWBUABGlgxBMqc4MoiwgfKIIIPAADcDsojgg8AAPQKkAQi/Mohwg+pcOYK4AoO2R8LUSAEyAGQ +IOjPcYAAvDcagQHgGqEcgQHgHKEW8APIAZAU6A3Iz3GAAPzM9CEAAFMgwIAK9M9xgAC8NxqBAeAa +oRuBAeAboQMSATYBgR0IngNUEQABUyDAgAj0z3GAALw3GYEB4BmhAhUFESkNEAABhe64yiHCD8oi +wgfKIKILzyAiA8ojgg8AALUH9AMi/MokYgAAlbBwyiHMD8oizAfKIOwLzyAsA8ojjA8AALgH0AMs +/MokbAAQjVMgwQCGIP4DRLjEHQIQpBUAEDCtRwifBQcSAjYCIsEDANgPCVAAAieBEIwhw48C9AHY +k+gNzM9xgABINkYggAINGhwwGYEB4BmhDx4YlQca2DMBGhg0g/AHGtgzARoYNADYdB0EENYKYACp +cM9xgAAIWAthdBUCEc9xgAAQWPAhAAB6YlB6pBUBEHQdhBAleKQdABAEyAGQE+gdC1EgAZW4FY8Q +WGAglfhgEHi+HQQQWWE/Zw7wvhUAEQnwIJW4FYAQWWE4YBB4vh0EEAh3kB0EEA8WAJa0HQQQNgpg +BalwEI0yd8wggYQT8gohwA/rckApDSRAKA4EMNiMuADbi7sFJcQTxQIv/AUmhRSkFQAQCHSEJBqQ +IfI9CF4CA8gBkBroDcjPcYAALMwUeYARAAeS6NARAAFqFY8QAeDDuPhgD3hqHQIQegvgAKlwah3C +EwXwbgvgAKlwDx4YlTEDj/rgePHA3gqP+hpwAN+kGcADz3CAAFwfBIDQifCgB8gEIIAPAMAAACh1 +MwiBDwDAAAANyM9xgAAszBR5EYmP6M9wgQDwDNZ4IogIjQ8IQwAKcD4P7/2pcdzwUSAAoIbyBBUE +EIEMHgENyM9ygAAszBR6ERKFAA94SSDCAHJuz3CBABAOdntgYDKNEwieBc9wgQBQENZ4AYgC8ADY +x3KBAFAQ1npEigghgQAIIQEAACFAAUkgwQMWbjV4z3GBANARAGHPcoAAXB9Egs9xgQBQEdZ5WIIh +gUV5BCGBDwAAAAgmeAPwA4XPcYAAXB+YHQAQJIEogQQhgQ8AQAAAPrlTJAIAHuE4ekV4mB0AEBcI +ngekFQAQjLikHQAQUNicHQAQePArCN4HpBUAEI24pB0AEM9wQAFQAJwdABDPcIAAXB8kgBCBnrgQ +oWTwBdgUuJwdABDPcIAAXB+kHcATJIAQgZ64n7gQoVbwjwheJwGFcwgeARKNNBKBMEkhwQBybs9y +gQAQDnZ7YmIRCp4Fz3KBAFAQ1npBigPwANrHcYEAUBDWeSSJCCBAAAgggABJIMEDFm41eM9ygABc +H0SCz3GBANARAWHPcIEAUBHWeFiCAYBFeAQggA8AAAAIBnkC8COFmB1AEA3Iz3KAAGTMFXogopwd +wBMF8AXYFLicHQAQEQgeJQDYkbikHQAQBPCkHcATdB3EE8oPIACpcM9xgAAIWHQVAhEJYVlhMHl0 +HUQQz3GAABBY8CEAAKQVARAleJgVARCkHQAQGQleAgrZdh1EEHgdRBCAuKQdABAV8BDZz3KAAFwf +dh1EEEOCSIITCt4ACtl4HUQQg7ikHQAQA/B4HUQQNgwv/alwpBUAEEQgfoKMFYEQGPLPcoAAXB9D +glSCJHqGIf8DRLmGIv8OOmLPcYAAmE70IZEAz3GAAHBO9CGSAA7ww7nPcoAAaLE8efQiUQDPcoAA +OLH0IlIAmBUFEFMgBIDKIIIEFfSIFYEQUSUAgsO5PHnRICKFCPLPcIAAkLH0IEAAB/DPcIAAOLH0 +IEAAIYULCd4AhB0EEAPwhB3EEx0NHgJEJQIGI7oB4gQlgA8GAAAAMbgaYgPwAdoDyAGQLOgNyM9x +gAAszfQhAACC6AGVuBWDEHQVAREEJb6PAQAAwHlhOGAQeL4dBBAG9E8lhQOYHUARBCW+jwEAAMAO +9AohwA/rcizYjLiKIxoJ2Qbv+4okgw8Ald7xOwpQAILizCLigMohwg/KIsIHyiBiC88gIgPKI4IP +AAC1BsokIgCoBuL7yiUCAc9wgQBQENZ4A4gG8M9wgQBQENZ4AoiMFQEQDrgleIwdABDPcIAAyAhA +gAaCoBAABojoz3CAAGw9AIi1CBAADRIDNq0LkAEAlc9xgAC8N50IEgzPcIAALMx0eBGIjQgRAIUM +EQB9CB4gnhUAEc9zgACoN4q4nh0EEBaTAeAQeBazAcjnoQWhmBUBEK65r7mwuZgdQBAGgqAQAAYv +KAEATiCCByO6DuIPIYAApBUBEJgdABC0uaQdQBCeFQERp7meHUQQz3GAAGA9AKEEIIAP///T9pgd +ABAN2JgdAhAK8BDYB/AI2AXwAtgD8AHYB6GYFQAQvhUBEUoML/8A2qQVARAEIb6PAAAAMIIdBBBR +8owVAhCcFQARlB2AEJIdBBCAHYQUAxIDNhcJHgMU2JAdBBAqcH4dBBB4Ew4BCfAO2JAdBBB+HcQT +eBMOAUpwwngQeLIdBBDPcIAA2MsAgIYgf48M9JgVDhARDl8SYZOG65G5krmkHUAQELgleKQdABAE +IoIPAAAAEM9xgABcH2SBUiICAxCDBXpQo0SBEIIEIIEPAAAAED15JXgQohPwmBUBEIAdxBOUHUAQ +nhUBEX4dxBOSHUQQvhUBEbIdBBCQHUQQgBUAEX4VAhGCFQERGmKEFQARWWE4YBB4jQVv+rAdBBDg +ePHANg1P+goND/3PcIAACM4MiM9xgQAQDgK4FngAYS24UyAAgAX0z3WAAFA1DfDPcYAAXB8ggcQR +AQbPdYAAUDVRIUCBBPQB2dwdQBDPcYAAXB/wIQAAz3KAAFA8IIIYiEUJNQFBHRgQMyZBcIAAaEBA +JwByNHgAeKoJoAkD2EYJoAlA2ADY4B0AEA7wz3OgAKggMYMCggDewqI4YOAdABAB2BKj/QRP+vHA +jgxv+rhxArnPcoEAEA42eTAiRACiwQ0MXgPPcoAAHCMF8M9ygAD4H0AiAwZAIgEHUSRAgsoiwgfK +IIIPAADLIsojgg8AAKwDvAPi+8ohwg/PdoEA0BFALY0BpmZAxiDFDQ4eEsK9qmEO8BEOXhJEJQEc +RLkqY4m6BvBTJcEQPHkqYs9xgQBQEBYhQQEiiQ65RXkgoGUEb/qiwPHAB9jPcaAA1AcaGRiADhEC +hg0aGDDPcKAASCxeoB8RAIYHGpgwARoYMATKnODMIIKPAACRAAbyABYAQAAWAEADzM9xnwC4/xih +fdgSDuACARIBNgTK0cDgfuB48cC4cQK5z3KBABAONnkwIkQAUSRAgsoiwgfKIIIPAADLIsojgg8A +AJMD5ALi+8ohwg9ALYEBz3KBANARIWJRIUCCiiIIBcoiYQPPcYEAUBAWIUEBIokOuUV5IKDRwOB+ +8cAyC0/6z3KAAKB/+HJAIgYBYwh0AADaz3GBAGwcmHIAFwIAuHAA3YByhCoCBRRqACZDDh9h1Go+ +ZrV+AeUA2PcNNJEApkokAHKoIMADQIsaesC6U30aZ6CqoYsafcC9s32oqgHgQiVAALcIdYBAJEIA +KQNP+uB48cC+Ck/6z3KAANAdRILPdYAAiJBihUCCNrs2ulBz1iKNDwAAgADAhT1ifmYdDYUTCiHA +D+tyiiCNAoojEASYdvUB7/u4dR5m/w2Fk1hg3QJv+g4ggAPgeOB/ANjgfwHYz3GAAHQ04H/wIQAA +8cCYcAohwA/rcgolwAfPcAAAnxm1Ae/7O9vgeM9xgABQNOB/8CEAAPHAmHAKIcAP63IKJcAHzdgF +uJEB7/tE289xgACINOB/8CEAAPHAmHAKIcAP63IKJcAHz3AAAKEZaQHv+03b4HgfCREBz3GAABhJ +CGFAKAICBXpAKAEERXkYuCV4DvDPcoAAGEXwIgAAA/BDKAACYbkveYwhw4/79eB+4HjPcoAAGErw +IgAAFwkQAWG5L3mMIcOPFPJDKAAC+fEEIIAPAAAA/0EoAQKGIMMPBSBCAEApAARFeBi5JXjgfuB4 +4cXPdYAAaDgChUKdz3OAADwyNIMdCFEAInpOeuTiAJ0E9jODxuFS9gDYAqUBnQ7wQnkueYwhA4IB +nYj2M4PQ4cT2AdgCpQCd4H/Bxc9xgAD8CCSB4H8goBGI4H/CuOB4z3GAAGA8RoGKIf8PIKAG6iKC +IKAB2APwAtjgfs9xgACAPEaBiiH/DyCgBuoigiCgAdgD8ALY4H6KIf8PIKDPc4AAgDxGgxLqJIIb +CV4Az3GAAHA7DwpAAM9xgACMOxEKQQBAguULgYAC2AXwIoIgoAHY4H7xwIoIT/rPCBAAz3aAAIy0 +L47PcIEAUBDPdYAAXB82eCKIA4UA389yoAAsIDQQEQE8EhIADo6A4JwAKQDKJakQjCIBpJAAJQDK +JSURZJaU48Ajhg8AAJMAz3CgAGgs8CDQAOWiUNhFIUECGNpuDaALINv4uMolIhIu9APYz3GgAPQH +BaGE2g1wQLBCIgAoDXIAskCGDXBAoEKWDXBAsAOFQIANcECgA4VCkA1wQLAGlkAoAiXDuAy4grgF +eg1wQKDkoQ6OAeAOrkIOoAkqcAHdEPAA3c92gACMtGINoAcElgDYz3GAAEg2Dq4egQHgHqH1By/6 +qXDgePHAmg8P+s92gAD4mSsI9AAacB6WOhYFEQohwA/rchC4BSUFAM9wAACDDIojhQ/tBq/7CiQA +BEAoDSHdZSWVBJUQuSV4OOjPcIAAtFjwIAEERCg+JwAhgH+AAEg6L3cgoCOVApUQubIO7/4leAhx +ACeAH4AAPDr6CwAJz3CAAKhY8CABBAAngB+AAKA5R5UgoCOVApUQuhC5JXgmlfoJL/xFeXYOz/4I +cQAngB+AAJQ5vgsACV6WHZYA2Q8hAQQQukV4BiBAgAHdHbYwuB62FPTPcYAAVCYAgaC4OghgBQCh +z3CAANAdBIAggM9wgAA4mqKgIaAQ2s9xgADkCQCBACoCBEZ4+QYv+gCh4HjxwJYOL/oA2g8iAgDP +c4AA+Jkekz2TELgFeQYhvoA29M91gABUJgCFgLgApc9wgAD0CM91gACIIgCQx403DgEQz3CAAPYI +AJDBjSsOARDPcIAA+AgAiKaNGw0BEAvIBCCAD/7//wMLGhgwC8iHuAsaGDDPcIAA0B0EgM91gAA4 +mgCAAKUA2AKlRXk9szC5dQYv+j6z8cDhxdYKoAAodYDgyiBBAxwKIQTKIWEAXQYP+lEHz//xwN4N +D/rqDKAIAN3PcKAA0BsRgBcI3gM6CaAJAdjPcYAAvDcJgQHgCaEGyAMSAjY7CB4ApBIAADMIngTP +cYAAgDMAgRPooKEBCZ5Fz3CgAMQsC4BTIIEE/rjMISKAB/KYEgAAlgvv/gDaAxIBNqARAAAXCB4E +iiAIAAwaHDAmDOAEKHAu8EkIHgUHyNCJANozEY8ABCCADwEAAPBBKA0Dz3GgADguB4EPIkIDAdxG +eAehDchyD+AKACwAEMd3gQAQDgK+1n4S599noK+KIBAABhoYMAPIoBCAAMTgOAvBCgPZz3CgABQE +I6BdBQ/64HiiwfHAQcJiwwolAAGBw0AkBDISCCAAAdrRwOB/osDgePHAugwP+oIkAzwIdyh1GnI6 +cwokACEKIkAhwOFVJNM3i3bS9ioJ7/rJcMlw6XEKCS/7qXJVI0Amqgjv+slxVSNPJhDdlsAA2YoM +7/tB2kAjACgA2X4M7/tB2ulwlsHOC2AIqXLpcEAjASjCC2AIqXKKJAFwANmoIIAFACRCMFgSggAA +JEAwRyKCDVgYggAAJEIwnBKCAAHhhyIBB5wYggCuCO/6yXDJcJbBjggv+0DaHwhyIADdCnfwIUEj +MiRCI3YIL/vJcGG/8Q91kAHlSnASCO/6yXF6CO/6yXDJcEAjAShWCC/7QNrJcEpxSggv+xDaSnDu +D6/6yXEVBC/6gCQDPOB4osHxwEHCQsMKJQABgcNAJAQyEgggAAHa0cDgf6LA4HjxwJILD/qCJAM5 +unCacUh3GnMKIwAhCiFAIZfFqXAA3slxjgvv+0HaVSTSN0AiACnJcX4L7/tB2qpwqXHKCmAIinKq +cEAiASm+CmAIinKKJAFwqCCABQAkgTNcEYEAACSAM0chgQ1cGEIAACSBM6ARgQAB5ochAQegGEIA +i3YeCG/7yXDJcKlxIgmv+0DaHw90EADd8CBBI/AjQiMOCa/7yXBhv/EPdZAB5SpwSg8v+8lx6g8v ++8lwyXBAIgEp7giv+0DayXAqceIIr/sU2ipwJg8v+8lxDQMv+oAkAzngePHAygoP+s91gAA4kwGF +z3OBAFARRCAEg89wgAAIzgyI0mjWfsd2gQAQDkCGFnshgxLyUCKPBeCmRiEBBiGjDQwRAZG/4KYF +8LG6trpApjYPgAoH8Ja6QKZFIQEGIaMLjaK40QIv+gut4cXhxs9wgAAIzkyIjCICgM9zgAA4kxfy +yovPcIEAUBEyajZ5x3GBABAOVnhAgaGABe6VukChq70E8LW6QKGLvaGgANgLq8HG4H/BxaHB8cBR +IACC4cWoACEACHVEJQMWBCWCHwYAAAAjuzG6AeN6YgQlgB/AAAAANrjPc4AAAFhKYwhjWGBBLYIS +UiICAMC6A7oY4oXgyiKNDwEAiQ3VIg4AUHFSACUAANjtvRgAIQACIYAAz3EcR8dxBSh+AAogwA4D +8CK4QS1BE8C5BLk0ealyxrpJIsIFVHnPcoAAZE8yYg8N3hJBKgEBFCGCAAUqPgBBKQByCNzjAQ/6 +CiHAD+tyO9iMuM9zAABXEkokAADNAK/7CiUAAfHASgkP+s9wgAAIzgyIjCACgCvyMmg2ecdxgQAQ +DqCBz3OBAFARz3eAADiT5JcWe0GDUCWOFYYnux/AoYwnRJBGIgIGQaMF9JG+wKEL8LG9tr2goQ8P +URCWvaChRSICBkGjog2ACgDZz3CAADiTRQEv+iuo4H7geOB/ANjgfuB48cB+C0/64HjgeOB44Hhp +IIABbyE/AGkgAAD38fHAqggP+hpwz3agANAPAN0H8BAWAJb9YfhgEB4YkCNtbwhEICUWA5YlFgKW +LyTHACUWAJZPfw99CL2lf9cMEYOC58wn4pPMJyKXyiVCECH0z3WAAISaSa0lFgKWCq1LrSUWApZo +rUytomkVD9ETz3CAAJGasgtv+g3ZDeUTDxEXz3CAAJ6aogtv+g3ZDeUQFgCWAiBBIzhgEB4YkHEA +L/oB2OB48cAKCA/6jCAEgIAAJgAId3kPFBXPdoAAaJpWJkATZgtv+gLZaBYAEWEIUQBWJoATUgtv ++gTZVCZAHUoLb/oC2WoWABFFCHMBaL8CuD0PBBAA3QvwVSZAF7V4Kgtv+gTZZL8B5a99ahYAEe0N +ApBVJsAWEgtv+gLZbBYAEQ0IcwFivwK4CQ8FEADYGPAA3QvwVSZAGLV47gpv+gTZZL8B5a99bBYA +Ee0NApDPcaAA1AsPgR9nAdjvobkHz/nxwKDgCHEA2An3z3CAAGiaMaC2Cm/6SOAB2NHA4H7gePHA +Gg/v+QDaOnCMIASASiBAIMIgDSTPcKAA0A8lEACGz3WAAGiaz3eAAPSaQCdSE5QdAhDPcKAA0A8l +EACGQCcTEwLelR0CEJYVgRCVFYAQOGCQ4MogiSB/CFEgANgT8EYKb/oQ4JYVgRAB4S95E2kVeDIi +ACCWHUIQHmZAJEAgD3iacJUVgBBPDAMgE2kVeGJwFgpv+gHZlhWAEM9xgAAkmwO4FXg4YP4Jb/oE +2ZYVgBADuBV4QnDuCW/6AdmWFYAQA7gVeBlnLYkG5pUJcoj4YEogACDPcqAA0A8QEgCGAiGBIzhg +EBoYgIUG7/kKcPHAQg7P+aHBCHUodlkNNBEA2Itwoglv+gTZAMA1CIAP8gEAUDcIgA/yBQBQGwiA +D5oJUG/PcaAA1AsPgWS9uGAPoQHYEPCpcEoN7//JcQvwqXDmDe//yXEF8Axttg7v/8lxD3hJBu/5 +ocDgeM9zgABUJkCDRXgAoxnpz3GAAIgiz3CAAPQIAJBHiTkKAQDPcIAA9ggAkEGJKQoBAM9wgAD4 +CACIJokdCQEAC8gEIIAP/v//AwsaGDALyIe4CxoYMOB+4HjxwM9wgAAgCgCAC+jPcYAAMDMLgQHg +C6EqDq/7AtjRwOB+4HjxwM9zgADACGhwBgwgAATZBGv+CyAABNnRwOB+ANjPcYAAJAkBqWEHYAoA +qfHA4cWWCW/9Mdi0aI4Jb/0z2AV9GL3PcIAAxEDOC2AIkL0ouH0F7/mleOB44cUyaDZ5z3KBABAO +IWLPcoAAXB8tucC58CJDACiDUSEAgM9xgAAczEGBCfI8i4DhxSKBDwAACgID8kUiQgNKJAB0ANuo +IIACNmh1eQAhjQ+BANARQKUB4wDdz3OBAFAQFiMCAKCqoaoB2SKqA9kjqkokAHGpcqggwAF5YhZ5 +pKkB4uB/wcXgeOHFSiQAeADYqCAACADbz3WAALQdQIUPIwMACyLAgA/yQYULIsCAQNrPIuIHyiKB +DwAA0ADPIuEHAvAA2s9zgABoFBV7QKMB4OB/wcXPcIAABD0GgAOAIIDPcIAAXI0poFUGr/wR2OB4 +8cASDM/5z3CAAHjPwogTDp4QANnPcIAA6gkgqB3wz3CAACDXuojjvcohYgD09c9wgAAEngwQBAAf +DF8ACiHAD+tyCL7PcAAA+iqKI40HPQNv+wAmRRMpBM/54HjxwLIL7/kB2c9wgACoJSSgiiDFD892 +oADIHxkeGJAocChyKHOWDeAAmHG+DW/8AN/6Dk/8z3WgANAP9aXPcKAAwC96EAGGibmLuXoYWIDP +cYAAAOIQGFiABdn0GECAXg7AAeINj/72CcAHQNnPcJ8AuP8yoNoJAAqA2c9woAAUBCygHR1YkLoK +AAk2CMAIggggCelwB9hIHhiQ4gxABgYNgAECCkAAHggABJ4KwAd+DYADrg8ACPYKQABqC0AHaglP +/MYPwAAaDoAI8g3P/t4MwARCCUAB1gtABqIPQAUmDYAKfg4ABH4MT/62CMAErgjABOILwAfPcAAA +/srGCg/8GQPP+fHAqgrP+aXBz3eAAFwfA4cIgMC4ZghgCS8gACAA3c92oAC0R89woACMRLigANiT +uHceGJAI2HceGJAA2J64Ux4YkOB4Ux5Yk89wgAC4ARB4Rx4YkM9wgACcBBB4SB4YkE8ggCNFIAAN +TyDGBzTYRB4YkBzYRR4YkEYeWJPPcIAAlDSGDyAFDIhKJIBwz3GBAJgWqCCAA89ygAAczAGCdG10 +eztjA6MCggHlBKPPdYAAID0AhQPoZB4YkEMemJFmDSAJAdgDhwiAQIUfCB4AUyJBABK5RCIAAw64 +JXiGIv8DCrpFeBHwSHCGIPMPCrgEIoEPAAAADAa5JXgEIoEPAAAAMAK5JXjPcYAAmCYCoYt1qXBy +Ca/7FNk42GTAANgE2ZIOIAmpcs9wAAYbAE4eGJDdAe/5pcDgePHA4cUQ3doPoAGpcAfZC7nPcqAA +8Bcxos9xAADw/ziisqLKDIAByQHP+eB4ANqA4cokTXDoIK0B/9lcYCCsAeLgfuB48cDhxc9xgACA +y89wgAA8WH4IIAhI2s9wgABkUc9xgABYCW4IIAgI2gDdz3GAACQroaGioc9wgAA8LqmgwgxgAgOB +z3CgACwgz3GAAKwuUIAQgEWhBqHqD+ABqaFNAc/58cAA2c9ygAD4mSCiz3CAAFQmIKA9sjC5PrLR +wOB+4HjgfuB48cCuCO/5INukwc9xoADIHGmhz3GgAJQTANpboc9xgADoFKCBM2g1eYt3MGU9Zc92 +gAB8zVMggQBshte7RQnRADYP4AqpcIfoz3GgAMwXANhA8B+Gm7gfpjQWgBAijRsIQQDpcEAlARRE +beYK4AhAJgMcDdgl8B6GkbiSuB6m5vEfCVEBQSoCUkAlABTpceIIb/3Buh+GnLgfpg3YEfA/hiy4 +wLgDuJm5P6YkhQXgJXtgpyWFIacmhSKnJ4UjpwPgz3GgAMwXz3KgAJQTHKIB2IroH4Yg2Ze4H6bP +cKAAyBwqoBzwAMAD2hgZGIABwATbGRkYgALAGhkYgAPAGxkYgBQZmICKFgAREBkYgM9woADIHGeg +FhmYgP0Hr/mkwOB48cCOD4/5pBABAKLB2wlfBiDZz3OgAMgcKaOkEAEAXQneATGIz3WgABAUI7nA +uQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwnw58J9AQUDzHxdswn6pAB3kL2AN7r7sWARX7HpbGI +hiX8Hxi9pXrPdaAAzBdaoBbwRYDPcaAAEBRHoaQQAQAVCZ4CMYjXuoYh/A8YuUV5OqDPdaAAzBcN +2QHaA+ENHZiQDh1YkCaAGR1YkCeAGh1YkCiAGx1YkAPZFB1YkHAQAQEQHViQcBABAc91oAD0BwTh +J6VHo6QQAQCZuaQYQAARB6/5osDxwKIOr/kE2Qh1DRIONgbYDRoYMM93oAAUBAqnz3CAADBYlg/A +BwCFjg/gBwTZAYWGD+AHONkIFQQQAYUAEAUBCQwQABUNBQEKIcAP63IZ2Iy4zQUv+2/bA4VeD+AH +iHEBhUKFIJAFhU4P4AdCecqnmQav+Q0amDPxwCIOj/kods93gQD4FTtnZItAJxERjCPDjxpyP2cS +9ADZBPAB4S95z3KAAOgUFQkTBECCs2m1fbJi9uokrwPwaHHPdYAA6BRAhQO5NXkQ4llhNg3gBxDa +RI8AhUAuARIDulV6WGAgsCSPAIUDuTV5MmA4YEUiggJAsEokwHAB2agggAMVDkAQMiFDIACFANoD +u3V7eGBAsAHhL3kA2BDdCHbPcYAAxHwWeUAgQC8I4dYM4AcG2mG9AW7pDXWQD3jBBY/58cBaDY/5 +osEIdyh1GnLPcIEA+BUZYSSJQCARAYwhw4/PdoAA6BQAIFIDBPIocg/wANoE8AHiT3r1CjOEAIZz +anV7cGD46AQagiAghgO6VXrpcBDhWWFuDOAHENoEEoIgAIZALQESA7pVelhgILAEEoIgIIYDulV6 +UGFZYUUgwAIAsUokwHAB2KgggAMVDQAQMiEDICCGANoDu3V7eWFAsQHgD3hAJwAUz3GAAGR9ygzg +BwLai3FAIEAvCgzgBwLagcEKcEHg/gvgBwTaAN8Q3Ytwz3GAAMR89nkI4eYL4AcG2mG9AeftDXWQ +738EEoEgAIbPdYAAuLQBwgO5NXkC4DhgQKgEEoEgAIYDuTV5OGAA2SgdQhABwQWli3cQ4CelJoXp +cvYNoAhohQQSgiAghgiFA7pVegThWWGODOAHBdoBwCaF6XIB4EHABYUQ4M4NoAhphWEEr/miwOB4 +8cAKDI/5CHbPdYAAIAoAhSh3huiA5uIgggMh8M9wgAA0PEoIgAjPcIAAbCbPcYAA7AnAoACBBX/g +oc9xgAAwMwKBAeACoQTwRgoP+wCF/ujPcIAAJAoAgPjoGQSP+eB4z3KgAPxEOYIEIb6PAAAIIADY +BfQ9gvm5AvIB2OB/D3jxwADYnLjPcaAArC8coRqBUSCAghqBC/KquBqhGoHnCB6Afgvv/AHYCfCK +uBqhGoHTCB+Aegvv/AHYANmbuc9woADQGzGg9ghACqoOAArPcIAA3DIAgEIgAIDKIGIA0cDgfuB4 +8cDhxc9xgAD4mX6RXZEQu2V6Ad0bCg8Az3GAAOg5RCg+B2YPYAgAIUAOqXAC8ADYbQOP+UaBCeoj +gWCBIoJieTBwANgC9gHY4H7gePHA3gqP+Qh1z3aAAIA83g/v/8lxB+ipcNIP7/9AJgEYg+gA2Anw +z3GAAGA8vg/v/6lweegB2BUDj/ngePHAkggAAAboAgkAAA8IUQDPcIAAxCUAgIPoANgS8AoJAACP +6PoIAACL6M9wgACkIiyQz3CAAFwfHpDjCQGAAdjRwOB+4H8B2OB/ANjxwLhwz3GgAKwvGIEZCJ4G +CiHAD+tyiiCMCWfbsQEv+0okAAAVgRsIHwAKIcAP63KKIMwJaNuZAS/7SiQAAAHY0cDgfs9wgAAg +CgCAgODMIGKABPQA2AXw/QgQggHY4H7xwM9xgADqCWCJz3CAAOsJQIiEKx8AACGAf4AAxNUw4PAg +gAALCB8AJggAAIPoANgL8CCJz3CAAIDPhCkfADQgQA536AHY0cDgfuB4z3CAACAKAICF4AHY4H/A +eM9wgAAgCgCAhuAB2OB/wHjgfwDY4H8B2OB/ANjgfwHYz3CAABgWAIgG6M9wgAAAFgGIA/AB2OB+ +DQleRwnIvbgJGhgwANmduc9woADQGzGg4H7gePHARgmP+c91oADIHyQVDpYVDh4ShRUAlp4MD/yK +IAQAJB0YkFEmgJA0C0IKhQGP+fHAEgmv+TTYCgmAAM93gAAAdC8IHgTOC+ACANiiC+ACAdiKJhAQ +AN3KD6/+qXAUJ0wTYb4AtPUOdZAB5Q7wANuKIhAAlgpgBHB4FCfMEGG6ALT1CnWAAeMhAY/58cC2 +CK/5NNihwQDdqgigAEDFz3eAAABcMwgeBFoM4AAB2APeCr4A2Iy4uGAQeItxTg3gAAHaFCdME2G+ +ALTrDnWQAeUiDMAAEPAF2wq7A9oKunhlKgpgBBB4FCdME2G6ALTzCnWAAeW1AK/5ocDgeM9xAQA4 +Nc9wgACUGOB/JKDxwOHFb9iVuM91oADIHxIdGJDPcAEAQDwVHRiQvg7ACIogBAAOpYkAj/ngeOHF +ANvPcoAAhJNKJAB0z3WAAPyTaHCoIAACQCUBEhR5YLEB4Ehwz3GgAAQlD6FWIgAEEaFWIgAFEKHg +f8HF4HjxwMoPT/nPdYAAXB8Fhc92oADEJ3UeGJAMlXYeGJAHhXkeGJAQlXoeGJAqDu//AN8b6Hce +2JN4HtiTgB7Yk4Ee2JMHhYYeGJAQlYceGJAHhYoeGJAQlYseGJAFhYgeGJAMlYkeGJAFhYQeGJAM +lYUeGJDB2FAeGJC5B0/54cUIccO4z3KAAASU9CIDAMm7cHHKJCJ0yiAiAOggIgL0Ig0Ayb0JCUAD +AeDgf8HF8cDhxQh1z3GgAMQnGREAhgHagOAREQCGwHqA4gCl0SDhhwDYM/TPcIAA+M0MgM9xoADI +H2TgHqEQ2A6hAdgVGRiAHg0gCgvYUSEAxsogIgAY9CUIXkfPcaAA1AsWgTiBJOAVCEUA+gwgCgPY +CQsfQAkInkQY2APwANiA4Mog4gTPcaAAkCM+gSClDQdP+eB48cCODk/5z3aAAFwfFSYBEECBaYK4 +ikErwADAuBe4x3AAAIAc5LvPICIG4LtO388gogDKJ4IfAABOAYblzydhEikLXwHPdYAApCIYFQQR +vpYbDQERoYbEFQ0WEQ1fEaCGxBUNFgcNXhGBuFEjAILPIKIFG6L8okCBz3A6BEpwHaKggQfYCg5g +AAq4BCCADwcAAAAwuFUIFQIzJgBwgACIQEAnAXIUeQB5iiAEAB6lGfCKIBAAHqUV8ADYi7gepRHw +ANiMuB6lDfAA2I24HqUJ8APYDLgepQXwANiOuB6lgiABARUGb/kepQohwA/rcozYjbi+24u7SiQA +ABEF7/oKJQAB4HghgADaUyF+gAvyANqZulEhQIDKIoIPAACDAMAqYgbPcaAAtEdMGYCAZpBIIwMD +R5AQuwQjgw8PAAAAyLpFe0iQDLoEIoIPAAAA8GV6UBmAgECAWQrRAGKAz3KfALj/faJFgFwZgIBG +gGAZgIBHgHwZgIBIgGQZgIBJgGgZgIBKgIAZgIBLgGwZgIBMgHAZgIBNgIQZgIBOgHQZgIBPgHgZ +gIBQgIgZgIBAgCsKEQJFgJwZgIBGgKAZgIBHgLwZgIBIgKQZgIBJgKgZgIAKgMAZAIDPcAAAVVXg +fuB48cCuDE/5CHUBgM92gAC0HQCmAoUA3+KmAabPcND+AAAaCK//BKbPcJ8AuP/9oACFz3WgALRH +MQjRAXoKAADPcAM/Aj+bHRiQz3AJPws/nB0YkADYl7hMHQCQbyBDAJMdGJAG8G8gQwBMHQCQXg1P +/iCGGQneB89woADIOx2ABujPcAAAVVUK8M9wnwC4//2geOnPcAAArd59BE/5IpBIIUEBQCkCAyOQ +YoDLuY+5RXnPcp8AuP99os9yoADsRieiI4A1oiSANqIFgBeiz3AAAFVV4H7xwNYLb/kA26bBz3GA +ALQdYKFhoWKhz3agALRHLBYBkAokgA8AAFVVSiQAeGhxqCBAAs9ygABoFDV6YKIB4QDZmLmVHliQ +SiSAcc9ygAC0HQgSBQALEJAAAN05ddh1qXKpcxl1qCABBL9g5I8AIEoDDQ/QHxUkQTNgoQHjSicA +AA8nRwMLIMChCfIVJEEzIIFKIwAQDyNLEAPwSiMAECqICyHAgQUhyRIJ8hUkQTMggUonAAAPJ0cA +A/BKJwAABSLCAZDvFSRBMyCBDBAFAD/fCiSADwAArd4PIEgQBBrCExEPURIVJEEzIIEA2g8iQgAT +DxESFSRBMyCBSiYAAA8mRgAB5c91gAC0HQgdQBGA48okgQ8AAK3eNvIliGSIBiKCAcW6ELkFI4MP +AAAAP2V5BSGBDwA/AACbHliQZ4gmiAi7ZXloiBC7ZXlpiBi7ZXmcHliQBiEBEsW5n7mZHliQANmV +HpiQmblMHkCQJIBYHkCQCpCUHhiQbyBDAJMeGJB2C0/+iHC1Am/5psDhxeHGz3KgAMBGz3OgAOBG +SiQAcgDdqCAAAxYgTgMhhgHlBBpQACKGBBtQADGAz3KgALRHmBpYgDKAsxpYgBOAtBoYgM9wAABV +VcHG4H/BxfHAtMEF2BW4QcDPcB8A//9CwADZQ8FEwUXBRsFHwT/YSMBJwUrBS8FMwU3BTsFPwVDB +UcHPcAAA//9SwFPAdg/v/4twtMDRwOB+4HjhxeHGJIjPcoAAAFmmiMK5LmIA2Q8hgQPPc4AAZJhA +g4TtJnpAoxjwRXkgoyWIFSONAyOlJohFiFlhJqUggIwhEIBF94ohEAAgoCO5IaMAgCq4AqMA2c9w +oADwNiygI4MloCaDJqAkgyegJ4MooCWDKaAogyqgIYMroCKDLaAggySgwcbgf8HF8cACCU/5ocH6 +cBtxO3JAwwojACEKJEAhCiWAIQomwCHPd4AAmAgghwDYgOHKIIEPAADIG/QIQQBacACHiOjPcAAA +zBvmCEAAOnAE8EohACAAh4noz3AAAAQc0ghAABpwA/BKIAAgAdjPdaAAyB8TpQbYz3aAAHQ4AKYE +HsAVCB4AFgDADB5AFhQewBQYHgAVBKYcHkAVD8AgHoAVCabPcIAA0B0kgCCBKqYogCCBDIArpgCA +DKagFQAQDaakFQAQDqaoFQAQD6bPcEN1qBIQpgCHhuhWCGAAKNgD8ADYEaYAh4DgANhECEEAEqZT +J8B1E6YByFQeABcWphIVAJZQHgAXF6YTFQCWLyGHBBimFBUAlgi5GaYVFQCWGqYkFQCWG6YWFQCW +HKbPcIAAQDcXgB2meB6AGnwewBqAHgAbhB5AG0gVAJaIHgAQz3CAAAAABICMHgAQUyAAIxC4JXgv +IUcEJXiQHgAQyXBGCGAAJdnRBy/5ocDgePHAsg8P+c9zgAAIOUODAN/PdaAALCCwhdJq1H5+ZqWm +BKZAIkKAJqZDowbyAoPjowHgAqPlBw/5z3GAANAdCIEA2kCgDIEB2UCgz3CgALAfNKDgfvHAegkA +AIwg/4/KICEA0cDgfuB48cBODy/5atiiwYtxAdq6D2AASHOP6AohwA/rcs9wAADSFIojxQSKJIEK +nQav+kolAABAJIExRNgB2o4PYABIc4/oCiHAD+tyz3AAANMUiiPFBYokAQFxBq/6SiUAAIoK7/kG +FAAxkQgQAIHBa9gB2lYPYABIc5DoCiHAD+tyz3AAANQUiiOFB4okwQo5Bq/6SiUAAAQUADFAJIEw +AdoqD2AASHOP6AQUBTEKIcAP63LPcAAA1BSKI0UIDQav+ookwQoCFAAxz3aAABw/G3hBKMUATCWA +jAAeQBHU9gohwA/rcs9wAADVFIojhQnZBa/6iiTBCh3Yz3aAABw/AKa4cAAUADHPdYEARB5ALYIA +qXG2DmAAAduQ6AAUBDEAFgUQCiHAD+tyz3AAANYUmQWv+oojBQxAhicKcgAA2BYlARBgiYYj/w0j +uw0LUQBhiQTrYrthqQHg6QiCgADYXQYv+aLA4HjxwNYND/mnwTpwenEaclpzi3DPcYAAwEGSDi/5 +GtrPcYAAHD8ggQDYgOG4cboALgCKJf8fz3GAAPQVABGEAIom/x/JdQLw6XZMIYCjAdrPcYEARB4W +eWCJwiKMAEQjjwD9f3cKwQPhiUQjAgQkukQjBgJBLsYARCMBASK5WwiBIR0MUQCA4cwiIYAH8oHh +zCJhgADaAvQB2k96BfCA4gHawHo3ClEATCIApgHawiKKAIYj/Q8nuw8JgACA4swgYaAL9DJ3zCMh +gAnyA+8F6wsJwiMPDsITyXcE8AHZCPAIdQHgZwhEgQDZiiD/D4TpgOXKIEoDjCD/j8oggQ////// +FfIyJII0z3GBAEQeDwpRAGJxFnkCEcAACfAWeQsKkQAGEcAAA/AHEcAABQUv+afA8cA+Dc//AglP +/woPwAbiCw//CiHAD+tyPdiKIwsOSiQAABEEr/oKJQAB4HjxwM9wgABcHwKAwhAABlEgQIBMDQIG +0cDgfuB48cBmDA/5GnAodTpyANnPcIAAoLEgoM9wgABomiYM7/qKIQwGz3KgANQLfoIAJYEfAAAA +QM9wgACgCWJ5YKDNuc9wgAD4zS+iDIDPcqAAyB9k4B6iENgOogHYFRoYgE1whiD8A9DgzCCCjwAA +gAAS8owgA4QT8gohwA/rcgokgArPcAAAMhGKIxoNYQOv+rhzCnAuDa/7KnIE8NYM7/oKcBPoz3KA +AHzNP4Kc4LO5P6IA2s9xgAA4k0upz3GAAGyQTLHKIIEAAQQP+eB48cCmCw/5z3CgAMQnUhABhkEQ +AIaGIOOPAN0G8uu50SGigTryz3CAAFwfA4AJgM92gABomi0IXgGyCgAEiegUjoHgyiAhAYwNIf/K +IWEAz3CAAPidAIANCJ4ALghgABCWtK7PcIAA+J2goE1whiD8A4wgAoAM9M9xgAAcFgCBAeAOCyAE +AKFKCo/7BvCMIAOERA3B+n0DD/ngfuB48cAKCw/5z3aAAOQJAN0L8BDYuHgLIQCAUAvi/sogQgMB +5fEN9JAghoDhyiAhAAgP4QLKIQEAQQMP+eB44H7geOB+4HjgfuB44cXhxkEtAFTBuBcIFQEzJgBw +gABQQEAngXIUeQB5ANgX8M9xgAB8zZgRgABAKAIGhiD9D1IgwAFFuEV4z3KgAIgkEKIfgbO4H6FK +8AHYENvPcaAAyBxpoc9zgAB8zZgTjQAA2s92gACUVMaGQC0BFoYl/R9SJc0RxXlFvaV5z3WgAIgk +MKU/gwLdRCg+DQAhgH+AAAjqlbk/o89xoADwF72hpICKEwMBpqGjgBTjpqGigFMjw4CmoaGApqHA +ICEIwCAiDGCAc6FsaGCDc6H4EAOCc6H8EACAE6FKocHG4H/BxeB48cDaCS/5ANt5ClIAn3KoIIAO +wJBvYVMmTRADvbh/o4AB5sCwUyZOkKV/46Ao9KGA532hoOKAQy3OE+d+3WUEJY8fAP8A/wQlgh// +AP8AKL8IukV/wqDnfqGg3WVDLU8XoaDHf8Kg/WVDLY4QoaDnfuKg3WUA2sKgoaBDoAHjcHvBAQ/5 +8cBaCS/5AdqiwQh1WthgwADYQcCLcWoP7/+pcIHGqXDJcV4P7/8E2gCVyXHBuE4gAgGpcEoP7//B +uo0BL/miwGGAYKECgOB/AKLgeCGgQqAA2SCw4H8joKHB8cD6CC/5OXGlwSQcQjEIdxlyuHOIdQDY +QMAgh4HGyXDWD+//QYfJcClx+g7v/wbayXAJcfIO7/8G2onByXDmDu//AdqLcclw3g7v/wPayXCo +cdIO7/+pclIP7//JcMlwyHGGD+//6HII3PsAL/mlwOB48cDhxaHBCHXPcNS6/spAwATw4g6gCQHY +z3GfALj/uqEE2Buhi3AeoQDanbrPcKAA0BtRoM9wAG0AEBmhAQleRwDA0wiAj9S6/sq5AC/5ocAA +289ynwC4/xqie6I+os9wAGwEABmi4H7xwCYIL/mYcCh2GgggAEh1BiCBA4hwTgggAKV5dQAP+c9x +gADMJWCJz3KfALj/BuvPcdC6/so+ohqiDuvPcKAAOC4FgAQggA/AAAAA8QiAj8AAAABq2Bi4GaIc +guB+4Hjhxc9ygADMJaCKz3KfALj/Be3Pc9C6/sp+ohqiO6IO7c9woAA4LgWABCCAD8AAAADxCICP +wAAAAGnYGLgZouB/wcXgeOB+4HjxwH4Pz/jrcM91gABYJ5gVAJZ7CJ4A7gkP/892gABcH8kWABal +uMkeGBCTFQCWpbiTHRiQ1xYAFqW41x4YEA6GpbgOpgCGyBAABoYgf47KICIAyiECAMwKovnKIqIB +AYbIEAAGhiB/jsogYgDKISIAsAqi+coiogEAhs9xgACAy8QQAAYluMC4CqHeCA/+f9gKuM9xoADQ +GxOhf9gQoQDYlbgQoc9xAACIIAoKIAAG2M9xoADwNgSBRiDAAQShz3CAAJgIAICA4MoggQ8AAJQA +6A7h/8ohIQbPcIAAIBkAgFEgQIAgDCIByiAiAP0Gz/jxwI4O7/gB2OIMYAgA3c9wpQAIDM92gACo +JaKgBIZRIICAmA1C+s9xAACEDJYJIAAG2AvIBSCADwEAAPwLGhgwBIYjCJ4Az3CAANwyAICL6OoL +b/+KIMYICwhRAEoOQAUM8ADZnrnPcKAA/EQhoOB4oaC6COAGANjiD0/83gsAAf4KoAcB2DIIr/sB +2G0Gz/jxwPoNz/iIdQDfCugZCFEAAd7PcIAA+RXAqAbwz3CAAPkV4KgJ6RsJUQAB2c9wgAD2FSCo +BfDPcIAA9hXgqArqGQpRAAHZz3CAAPgVIKgG8M9wgAD4FeCoz3agAMgfz3CAAPkVGB7YkwCIiiEQ +ABHoz3CAAJkeAIgL6M9wAwBADUUeGBAwpgLYGB4YkALwMabPcIAA9hUAiBvoz3CAAJoeAIgX6M9w +AgB+LyAeGJDPcIAAKAAhHhiQz3CAAAQIIh4YkBgWAJZFIAADGB4YkM9wgAD4FQCICOgYFgCWhSAB +BBgeGJAPC1EAGBYAloi4GB4YkBgWAJaAuBgeGJAY7QDYlLjPdYAARAoApXHYBrguDe///Nkghc9w +AABMHB4N7/+fuRgWAJaFuBgeGJA1Bc/48cCYcAPpIwwSCM9wgACMCAAQBQAKIcAP63LPcAAA2g4l +BG/6edvPcIAA1CUVIAABIKDRwOB+4HgA2UokgHHPc4AA9IwocqggwAHwI4AAAeIFeeB/LyhBAOHF +ANpKJIBxz3WAAPSMSHOoIIAB8CXBEAHjJXoA2Z65GXkEIYAAQiAAgMogYgDgf8HF4HjxwM9xoADI +H6QRAgDPcIAArC4AgDWBz3OAAIiQliBBDxByANrKIm8AAYPVuYHgAdgC8gCDDQhRAA0JhA8AAIgT +ANgD8AHYgeLMIGKAHA5h+8og4QHRwOB+AuEweUFpDQoDACJ4EHgD8ALYz3GgAMgfHqEQ2A6hAdgV +GRiA4H7gePHA4cVQ3QDaz3OgAMgfr6NeowIgQgBeowHaFRuYgEDaTqMEIL7PAAIAELAPwf8JBM/4 +4HgA2c9wgAD4nSGgz3CAAHzNHJBiuEggQAAQec9yoADIHx+CEHgIIQEAMHkC2BUaGIA/ouB+AuEw +eUFpDQoDACJ4EHgD8ALYz3GgAMgfH6GKIBgIDqEC2BUZGIDgfgDZz3CAAPidIKAhoOB/IqDhxeHG +z3GBAHgWRYEk6M9xoADIH0ARDgbPc4AAfM1AKI0CQhMAAXyT0H7YYLtjYrsIIwMAAnsJIsIAAtgV +GRiAz3CAAFwfX6EDgCKAz3CAAPidIqDBxuB/wcXgePHAug0AAghxz3CAAOQ6hg+ABwLZz3CBAKwd +JKDRwOB+8cDhxc9wgAAEngOAz3WBAKwdEQhfABcIHgAIjQ8IUQAE2DoL7/0EpQ3wbg7P/m4NAAII +cc9wgADkOjoPgAcC2ASl2QLP+OB48cDhxc91gAAEnhWFgOAMDwICehUAFgrogODKJA1w4HjoIC0B +4HjgeKkCz/jxwM9wgQCsHQSAGwjRAM9wgAB8zQCQhiD8AIwgAoC4D8H/FdjRwOB+8cDPcYAA6gkA +iY3oz3CAACDXGogPCN4AAdgSCiAGAKkX8M9wgQCsHc9xoAAsIDCBBYAieM9xgABksAChKHDPcYAA +kK8eCSAH1NoeD8//0cDgfuB48cDhxQh1z3CBAKwdBIAH6BYIgAEApQHYAvAA2A0Cz/jxwJIJz/jP +cIAAaJqVEIAAAN2A4FIALADKIkwDM23PcoAAJJs1eSJiBCKCDwcA8P8kui8rgQBOI4EHL3kA2w8j +QwDPcYAA8FhuYc9xgQDEHbZ54YEGIsKA5X7Boev1AeWvfb0NApBtCHIAANmYcBNpz3OAACSbFXgD +YwQjgw/4AQAAQSvDhBnyLyiBAE4gjgfPfgDdDyWNE89wgADoWK5gz3CBAMQdNnjggAYjQ4PlfsCg +7PUI8M9wgQDEHTZ4YICAu2CgQiRAAAHhpQh1gC95KQHP+OHE/BzIvvwcSL7hwOHB4cLhw/wcCLH8 +HEix/ByIsfwcyLH8HAiy/BxIsvwciLL8HMiy4cXhxuHH/BwItPwcSLT8HAi/aiSAEOHEaiTAEOHE +8cDPdaAA0BtcFRAQe9iyCK//iiEEA89wnwC4/x2A63bLcM9wAABEHEYI7/8KJ8AfOnAXhQfYOgjv +/wq4UyBBBwfYbgjv/wq4z3CgANQLGIBCIAAISCAAAM9zgABQNc9xgABECiCBvBsYAAshQITKICID +LvQfCJEgFwmeJYnoUSFApWTYyiCBDwAAXAAg8DTYHvCMIASgGfJMIACiEfII9hsIUCAnCBEhhtgS +8BcIECSMIAGgC/RM2ArwZtgI8DzYBvBG2ATwVNgC8ITYkxMDBulxyXIKJAAEEQcv+golQATgfuB4 +4H8B2PHA4cUIdShwBevPcYAAAHQE8M9xgAAAXFt6Mgjv+LR53Qev+AHY4HjPcIAA9ggAkAboANnP +cKQAHEAyoOB+4HjPcIAA9ggAkAboA9nPcKQAHEAyoOB+4HgA2c9wgACgseB/IKDxwBIPj/gacADe +z3CBAHgWFBATABYQASHPcIAAiCYAgCCgOfDdZrR9QCAPIQAnUhMAIkAjAZC2CGAJCrjPcYAAiCYg +gUAuEREM4SJxAKG4ZwKQqWcKuAUp/gSSCGAJJ3AIcboJr/oAEAAgz3GAAIgmIIFCdQThInEAoQGN +AeYFKP4Ez3CAAIgmAIAI4CJwABhADhYQACGRDgSQ0QaP+OB48cB6Dq/4A9mCJAI7OnEI6KkIUACB +CJAAKnWM8M91gACgseWNi3AybzR5ACVQEAgQkCAAJUQQAdmWDy/6CnIK8DJvNHk6ZUiKACVEEEUK +AQQIdiZoJ9gArg/YAa4A2ASuA64HtgkUgAAB5wKuChSAAMG/Ba5AJAADZg3gBgjaENkwriaNQCZA +FEAhUSS1D0GQ5a3E8c9xgACgsVYRgABUEY0Ah7hWGQIAVCHACotxA+UuDeAGqXI+8M91gADYsYtw +Dg8v+kCNI9pAqALaQajPcoAAoH1ikgjiamIiaEKoAo1huAsI1AMA2iDwMyYAcIAAbEBAJ4JyFHoA +eooi/gkW8IoifgsS8IoiPgsQ8IoiPgwM8IoifgwK8Ioifg0G8Ioi/g0E8Ioivg4BjQfdQngBqZ/H +QCcAFRYKb/rQ2aoUgTCVxslwuWEweaYKb/oA2kAnABVRwFLGi3BTwFAcRDOaDG/6kcB1Ba/4gCQC +O/HAGg2P+Ah1DpCzCBQBqXASCqAJANkgiIHhzCGigE/0IYibCRUBMyZBcIAAXEBAJ4ByNHgAeKlw +6gmgCQTZAIh7CFEAqXDeCaAJCNkAiG8IUQCA2c9wgABwfiawMLknsCDYK/DPdoAApQgAjjkIUQCp +cLIJoAkE2QCIAdmC4MB5FQhQAILgzCCCjwAA/gAI8gDYCfC+DKABqXAF8GIK4AGpcACui+gQ2M9x +gABwfgh0hrEwvIexpgrACc0Ej/jgeOB+4HjPcQEAxwPPcKAA7CcmoOB+/BwItPHAGnA6DK//JNiY +cFEgAIDKIcEPyiLBB8oggQ8AAFEmyiOBDwAAKQGQAyH6yiUBBM9xoACsLxiBhwgRIA8IngbPcIAA +YCYAgEB49NgA2dILr/8B2jTYANmRucYLr/8A2jDYiiEGALoLr/8A2jTYANkD2q4Lr/8UusYLr/8w +2MK4CQhRAADYA/AE2M9yAQDGA89xoADsJ0ahz3OgALQPPIMj6QESBDZwEwUACiHAD+tyz3AAAFIm +BQMv+oojRQaauBih5glgCYogDwrPcIAAYCYAgEB40glgCQHYFgkv/4ogBQOH6ATY0cDgfwQUEDRE +2c9woADIHCmgrglgCQHYzg1AAcLx8cA2C4/4osEodgokgIAA3891oAAsIEAVEBAAHMQzE/J3DFAA +TCSAgILyCiHAD+tyz3AAAFQmiiNEBX0CL/oKJQAEMmgEIYEPAAD8/y4Lr/8s2BCFAiAABIwgD4oI +994Kr/8s2Ah37wgegAXwAIaAuACmygqv/zTYFwheBQCGANkA2oG4AKY02JIKr/+VujC/AhzEM3zw +D3kQuQUhgg8AAIL9z3GgAOwnRqEEIIAPAAAAH0i4hrgQuAUggA8AAEL9BqEQhQIgAASMIA+KC/eL +cV4Jr/mKIA8NABQAMecIHoAE8ACGgLgApoHBRgmv+YogTwwEFAAxDQieAACGgbgApot1iiCPDyoJ +r/mpcSDACLgCHAQwiiDPDxYJr/mpcSDBAhQAMSV4AhwEMDLwz3EDAEL+z3egAOwnJqfPcQQAAv4m +p4a4EHgQuAUggA8AAEL9BqcQhQIgAASMIA+KC/eLcc4Ir/mKIE8PABQAMecIHoEE8ACGgLgAps9w +BgAC/wanQCSBMKoIr/mKIM8OAhQAMQkCr/iiwOB44H7geOB+4HjPcacAiEkA2gsIUQAD2A6hAvBO +oeB+4HjhxeHGz3WAAKgmoI0A3sCjke2B4MwhIYAN8gsKEwjAownwwOIG2Ab2QiIACEO4AuAAo8HG +4H/BxbhwQNwAIQCD8cAOACQAmHGMIAKAi/YKIcAP63LPcAAAyRSlAC/6iiPID89wgACAQ/QgAAHP +cYAAgEQEKH4BL3D1IQEBQigDBMG7UrgEKX4BL3FCKQIEwbpSuYHjwCBpAIHiwCFpAIggPgCJIMEP +iCE+AIkhwQ+A4NYgKwiA4dYhKwhyCQAA0cDgfuB48cCuCI/4ocE6cQDfgODKIcEPyiLBB8oggQ8A +AMoUyiOBDwAA0wLKJMEAEAAh+solwQPPcYAArCZAsc9xgACuJuCxTCEAoMolzhNkAC4AyibOExp3 +WncF8Ml3GnVqcEAgUwCLcQHa1gjv/wDbABQNMS8jyCSpdim9yL6/5dklKRRMIgCgyiDCA8ohggPK +IgIESA0iAMojQgPJcN4O7/+pcUIhUSC1CXWgQCJSIMlwHgkgAKlxUQCv+KHA4HjxwPoPT/g6cM9w +gACoJgCIGnGVCBEAz3GAAJAJpYkEiR1lMnXKIcwPyiLMB8ogjA8AAMsUyiOMDwAAOAPKJEwEPAfs ++colTAMA3c93gACpJgDeCfAA2SCv7g7v/4rZAebPfgAggS+AAJAJJokBaTEOAxBAKYAgFHi1eNR4 +z3OAAFy0EGNSbW3oAuAQeNR6z3OAAFC0UmPg6QHZ3/EB5a99sQ3SkLUHT/jxwFoPT/jPc4AAriZA +k1MiTYAg8kcNkRDPdYAAkAkJrSitIoXPdoAArCYAlindEr3Pd4AAqSYVJQwQIKTgjwfvViAPCPB/ +9X0gpQHgALYH8M91gACQCQutKq0B4mUHb/hAs+B48cDyDk/4CHYacc91gACuJuCVC/DMf54Ir/hA +KUBxRbiODe//CnEglYwhEIC09ikHT/jgePHAsg5P+Ah2z3CAAKgmAIh6caHBGnLLCBEAz3GAAJAJ +pYkEiR1lcnXKIcwPyiLMB8ogjA8AAMwUyiOMDwAAhQPKJMwE+AXs+colTANKIQAgAN0K8AEeUhAG +j4ToIK4B5gHlr33Pd4AAkAkAJwAUBogB4GMNIxACd0ArgCAUeBUgQAS0eM9xgABctDQhEgAA2cUK +EKCLcUpwAtqmDq//ANsL6AEUgDABHhIQBo/a6AEUgDAArtXxCiHAD+tyz3AAAM0UiiOOBgokgAR1 +Be/5SiWAAEAhUSAvIUckeQnSoC0Gb/ihwADbYKkRCHIAYKoNCNMDYKngf2CqDwiSCMDgBfYB2ACp +EfDk4Ib2jCACg8ogrADJ9owgQoSJ9owgQokH9gPYAKkB2OB/AKrgfvHAig1P+KPBSiEAIItxKnBK +IAAhCnL+Da//KnOO6AohwA/rclPYBriKIwUBCiRABOEE7/kKJQAEIMIVChIAAMBBKAECUyHEABMM +EgEB2c9wgACoJlUCIAAgqM9xgACQCUCpAhkCAUEoDgNTJsUQAxlCAUwlwIDKIskHyiCJDwAAwhTK +I4kPAABYAYgE6fnKIckPQSgCBFMixgAEGYIBQSgCBVMixQAFGUIBTCZAgMwl7IDKIckPyiLJB8og +iQ8AAMMUyiOJDwAAXgFIBOn5yiSJAUEoAgZTIsQABhkCAUEoBQcHGUIBTCRAgMwlbIDKIskHyiCJ +DwAAxBTKI4kPAABkARAE6fnKIckPBBSFMIwlAYS0ACwAARlCAQohwA/rcs9wAADFFIojRQrpA+/5 +mHPPdYAAXLQA3wPwAefvf0EoAQLDuW0PQxAA3hPwQCmBIDR5ChSAMBUhQQEB5s9+FHm5YQAZBASA +IAIjLyAIJADAQSgBBsO5AeHDDkOQgsEKcALakgyv/wDbCxSEMC8oAQFOIIUHLyVHAbUN0oAKIcAP +63LPcAAAxhRpA+/5iiNGAkAhUSAvIUckQSgBBMO5ewlCoATwbQ5TgEEoAQXDuQp1qQlyAEogACBK +IgAgBfBAIlIgLyKHJEEoAQPDuXsKQyBKIQAgFPACvtR+ChSAMBUmThFAIVEgLyFHJBR+ACaAH4AA +XLSgsIAlAhOwfQDAQSgBBwHhuwlDoDC4w7gAIA4EgsGpcALa3guv/wDbCxSEMC8oAQFOIIUHLyVH +AasN8oDPfgohwA/rcs9wAADHFLUC7/mKI4YIQCBQIC8gByRBKAEFw7llCEKg09kIuQDYA97PcoAA +ULQA27JodH1dZSC1AeNve1YhAQjxC7KAMHlhvgHg5w51kA94PQNv+KPA4HjxwMYKT/iiwUDAQcJA +KBQFQCkXBQDdQCoTBUArEgUB3kolgCGpdwTwCnXKdwDAFbgTeBQgwAVuDG/4B9kCIFADAiBAI14M +b/gO2cx+CiFALgQpPnAvcKx+ACENdR1lAcAVuBN4FCCABDoMb/gH2QIg1gMCJsAjLgxv+A7ZBCh+ +BC9x7H4AIcB0GWFCLQAVEgnv/1S5QiVVIAHmkQ11oM9+bQJv+KLA4HjxwCIKT/g6cLpxz3CAAHzN +AJBKJEAgANlKIEAghiD8AIwgAoDCJAIlSiKAIM9wgAA4kyuoz3agANAPJRYPliUWDZZCIYAgEBYW +lisIRAMCIFEDDCGApMoiLiD6D6/46XCYcADYKQwQIBUPUBEND9ASB/BKIwAgLvAB2APwAtjPcYAA +ABYkgQshAIAE8gDaA/AB2gAiQCPmDe/5ynEKIwCgGPInDJADz3CAACAeFiAAAUCABogrDwEQE+qp +cGB6qnEKIACgBvLCdRAeWJNpChGgTCMAoMwgIqAR8gDYEPAKIcAP63LPcAAAMRGKIxcLSiQAAMkA +7/kKJQABE9hxAU/48cDhxc9wgAB8KAgQBABMJACAyiHBD8oiwQfKIIEPAABpGcojgQ8AANABkADh ++colAQHPcqUACAwIEgUAANlMJQCAzCUihMohwg/KIsIHyiCCDwAAfRnKI4IPAADXAVwA4vnKJCIA +QNgCos9wgAD0vWCACvD0IE0Az3CmAACANXgB4aCg0uGEKwIKACRADrT3pBADAc9xpACgP32hphAA +AR6hCBpAAREBT/jgePHAgiQDMotwz3GAAPRASglv+MjaSiRAdgDZqCBAAxYkQDBhgECQK9gSuAHh +VXhgoDB5gCQDMtHA4H7gePHAvg4gAEfYANrPcasAoP9ZoQfYGqFYodHA4H7gfuB44H7gePHAz3GA +AHwoOIGA4SAOAgDRwOB+8cDPcYAAfCg9gYDhhA8CANHA4H6NBUAIiQVACIUFQAgA2c9wgAD0vSGg +VQRgAiKg8cDhxc91gAD0vdINYAKpcLhwAIUS6EokgHPPc4AAjCYA2aggwAJAg0QpvgMyIkIOPwpA +AQHhEfAA2UokgHnPcoAAsFGoIEACRCm+AzIiQw4fC0ABAeEKIcAP63LPcAAAhhmKI0QBBQev+Uok +AAD5By/4KHDPcIAA9L1AgCOADOrPcIAAjCYAgEQpvgMN4DIgQA4J8M9wgAC9UUQpvgMyIEAO4H7P +cAAAAT/PcaoA8EMFoc9wAAA+PQahz3IAAD09R6GKIMwPCKEJ2Iy4CaHPcAAAFhwKoc9wAAAfHwuh +z3AAABwWDKGR2AS4DaHPcAAAAz8OoU+hz3AAAD0+EKGKIMQPEaHgfuB48cDiDg/4pgqgAgDeQg0g +AAfYRg7v/xpwz3WkALg9rBUAFs93pQDYy2nawNmiuKwdGBDMp/YdmBPPcBUAKyuaHRgQyh2YEMsd +WBCg2MQdGBDPcAAAbm6bHRgQiiDEAJ8dGBAa2PMdGBD0HRgQZNjIHRgQqtjJHRgQzB2YEM0dWBA5 +2c9wpQAIDD6gFg/P/84JIAAKcBjYlR0YEM9xgACMHcGhyNgCoQChA6HPcQEAoNHPcIAAnBfUGEAA +lNgLp0HZz3ClAMx/LaDPcKQADIDCoHUGD/jxwBoIAAAqD8//qg0AAN4JD/vRwOB+4HjxwO4ND/jP +cIAAoMpAIBIGCHHPcIAAyAggoADexKgE30QuPhcKIUAuACGAf4AAoMqeDe/5HNmELgoSACGNf4AA +EL6pcIoN7/mKIQoChC4CFwAhgH+AADDIGnB2De/5nNkAIZEkABlAI2G/oR0YFLUPdZAB5tUFD/jx +wIINL/hEKD4HACGOf4AAoMoQrgHf8a4hrkCuYq4DHgIRcq5SCSAAEx4CEb0FD/jxwEoNL/hEKD4H +GnA6cc9xgACgyi9wGmFRihthHwpQAAohwA/rcs9wAACyKF7biiTDD50Er/kKJQAEFQjQIM9ygADI +CAQaAgQ4YACiAYsgi1KL6gsgAHOLNg8AAQpwMg0gACpxRQUP+PHA4cUIdYYP4AUA2DYPj/tE2c9w +oADIHCmgEg5v+BzYz3CgAKwvGID6uIQLYQLKIEED/9nPcKsAoP85oDigMg7gAKlwHQUP+PHA4cVK +DO//CHVKCOACqXAJBQ/4z3GgAMgcCKHFBW/4BtjgePHAfgwP+KLBooFgkM92gAAQCbh7o4FkfWCG +pXumgQGQuHingWCmpHihhkAhDwSleAGmHeoBgQIcxDAwuwQcxDAAHAQwIIGLdWB5qXABhyGGAhxE +MDC5BBxEMCCHABwEMGB5qXAA2ACmAaZ9BC/4osDxwA4ML/ic2Qh2z3WAADDIhCgCBy93zgvv+QAl +QB5SDaAB+GUCCSAAyXBNBA/44HjxwOILL/gB2oQoAgcAIY1/gAAwyM9wgADICACAKHYgiACGmR2C +EEyFMLgPeIkKUQAD2pkdghCBCQEABNiZHQIQEIWN6AXYmR0CEAiGEqUDhhGlHIYUpReGE6WpcKYO +YAHJcRCFAeBRCDQEEKUG2JkdAhCpcNILoAHJcalw6gygAclxqXBSC6AByXGpcDYNoAHJcalwQg2g +AalxmBWAEBkIUQAH2JkdAhByCCAAAm0A2JgdAhCZAw/48cDhxQh1hCgCBwAhgH+AADDIz3KAADw0 +SJIfCl4AIIEXCVQBANktoC6gXgygAS+g8gggAKlwaQMP+OB4hCgCBwAhgH+AADDIz3GAADw0KJEJ +CV4AAdksoADZ4H8woOB48cDKCg/4CHUmCSAABdhAlSGVCLpFec9ypAC4PZsaWAAilc9zpAC0Rcoa +WAAjlcsaWAAklcQaWAAllcYaWAAmlccaWAAnlcIaWAAolcMaWAAplcUaWAAqlaMaWADPcYAAXB8j +gSiBAN4ZCR4ATJUrlVt6RXlTG1iALZVUG1iABvBTG5iDVBuYgy6VVhtYgC+VWBtYgDCVVRtYgDGV +VxtYgDKVWhtYgDOVXBtYgDSVWRtYgDWVWxtYgIINz/95Ag/48cCEKAIHz3GAADw0KJFTIUGAz3KA +ADLIL3AF8iYP7/9YYNHA4H7gePHA4cXPcIAAgCYggAHdYHmpcOe4J7hSIAAAyiUiEMohQgPKIeEB +wLgTeMK4z3KnABRIC6Isos9wqgDgB7OgGQIP+OB48cDhxc9xoADIHKiBCKHOCm/4Btj9AS/4qXDg +ePHAggkP+Ah2z3WAAPS9AKUhpVitfgnv/3mt7gnv/wOlBKXPcKAAeEUAgAQggA9wAAAAQSg+hQDd +9fXmC+AFqXDPcasAoP+5oQfYGqG4oZoPQAKA5gHYwHgM4JIMr/oB2Y0BD/jxwA4JD/gId891gAD0 +vRiNSHY6cRpzEwoBAIXuGY0LCAEEANgC8AHYLyIHIOlwzgxgAslxIIUA2A8PQRAhhTJxzCIhoALy +AdgvJgfwGq0X8ulwKnHJckoP7/8Kc8IPwAIBhc9xgAD0CACxAIUBsRiNBKkeD+ACCnAI8IDnAdjA +eAzgBgyv+gHZ4QAP+PHACHMA2QLahCsKAgAhgH+AABC+hCkEDwTg2gzgBSdwYbrpCnWAAeHRwOB+ +8cDPcIEAmBguCO/5iiEJDM9wgAB8IiII7/kU2c9wgACgJRYI7/kU2dHA4H7xwCIID/iiwTpwGnEA +3ZIO7/8H2JpwAtmpcFpwenEA2zRoAnEodRQhACBocsKFBBAPBdh/w4UB4sR/5XvxCvSAIOUBgQIc +xDAwuwAcBDAggQQcxDBgeYtwQiNBIL8JdYBAIkAgRgvv/4pwDQAv+KLA8cC6D8/3OnBacc93gACU +NAyPz3aAAPS9pYaGIP8BQ7gOJQ2Qz3CAAHAmIIDKJWIQYHkE2CDoGo6A4MwlIZAc8gDYEN0acAK4 +FXjHcIAAACgggAbpIoAV6WB5KnBhvekNdZBAIEAgANgargyPhiD/AUO4BaYCDm/4SnCdB8/3CiHA +D+tyz3AAAGUZN9sKJAAEsQZv+bhz4HjxwEKQIZBgkBC6RXkp2hK6FSLDACCjAJDwIgAA0cDgfvHA +4cXPcYAAEMsAgQDdFejPcoAAPMsAogiBoKGkoQiiGgmv+gnYFgmv+gPYz3CAAFQ7PgvABs9wgAAk +K54KoAADgM9wgADkLj0H7/evqOB4wQRP+vHAOg/gAuHFz3CAABw7DgvgBgDdz3CAADg7AgvABs9w +gABUO/YKwAbPcIAAJCuioLYIr/oD2M9wgACsLqOg9Qbv96Gg8cDhxc9xoACsLxyBvYEEfc9wgACY +HgCIEwhRAM9wwN8BAByhKNkYuQnw/L1QCAID9r3ACYL6ANmbuc9woADQGzGgrQbP9+B48cAiCAAA +og4AANHA4H7geM9wgAAkKwCAgeAB2OB/wHjxwBIOz/fPcIAAgMvHgMC+geYB3s9xgACQMACBwH5R +CF8AgbgAoc91oACsLxiFDQieBhiFurgYpQLYFqXPcIAAcCYggGB5ANgZCBECKgygCArYC/DPcKAA +qCANgOTgivcVhfUIHoAKCe//yXARBs/3cBUEEFQVBRAKIcAP63KKIEwJCQVv+Yojhg3geFMgYMHP +cKAArC8ZgIYgPgMD8gDYA/B/6AHYLyAHgAfyAdrPcYAAkAhBqeB+8cDhxc9xgADcQUCBIYGnwUbB +z3GAACQrIoFFwhUkQjDPcaAALCCwgc9xAQB8FkDBAdlBwULBENlDwUTARYIA2AzZCHOYcLhwACWH +HwAAAH0iDO/82HB5Be/3p8DxwMoLD/7PcqAAwC8A2YgaQAATgou4E6LPcIAA8BQBkBC4RSAAD8Aa +AADPcIAAOC7OCm/6IKDRwOB+4HjxwADZm7nPcKAA0BsxoJoKgAAM6M9wgAA4CSCAz3CAAGQu8CBA +AEB40cDgfvHAjgzP9xpwz3CAAIDLB4DPcYAAXB9TIA8AgecB3yCBxBEBBsB/OwleAc9xgADwFKGR +z3GAAFgJwIE85blmZOEfCQQECiHAD+ty3WWKIMwIWtsKJAAEuQNv+VUlRRYhCNEAz3CAAPAUQZDP +cYAAWAkggTziWWFk4QIgUCALyAQggA/+//8DCxoYMAvIh7gLGhgwGg+v/+lwz3WgAMAvSQ9REBCF +NQgfAM92gAB4JiCGYHkB2A8IUQEghmB5AtgdCJAAQBUEEAohwA/rcoogjAiN2z0Db/m4c4ogEAER +pRCF/wgfgBSFq7gUpc9wgAAgGQCAguAS2MAoIgbKICEAzyBhBhmlz3GgAMgfGBEAhqG4GBkYgIog +EAARoQnYCLgPoROFqbgTpc9wgACAyweAg+DMIOKBBvRAKIAgn7iIHQAQjgrABs9xgACQMADYpQPv +9wCh4HjxwA0JUQD2CwAABPDSCwAA0cDgfvHAYgmgAOHFcg5v+hrYz3CAADwuAJDPcoAAaMtSIAEA +wLkB4SCqANkXCF8Az3WAAKwuaoULC1AAa4WB4wL0AdkjqkEogQLAuTSqKbjAuM9xgAAkK00D7/cA +oeB48cDOCs/3z3WgAMAvF4Uahc92oADIH4gVABAH2BkeGJAB2AhxCHIIc64M7/6YcIAVDxAiv2oI +4AbpcM9xgADENhKB+GASoQDYiB0AEAnYCLgOpuUCz/fgePHA9gzP/4DgANnKIEEAGfLGCGAHKHDP +cYAAOAkggYogTAbGDGAAA9oaDmAAA9j2C0/8CNgiDCAAiiH/DwHY0cDgfuB48cDPcIAAOAkAgBMI +0QC2DI/89gvP/+oOAADRwOB+4HjxwBIK7/dKJEBxAN7PdYAArC5AJQMcqCBABM9xgAA8LtV544EV +I4wD4KQLCFEAAd/joQHmz34B2EEC7/dEHQIQz3CAABDLAdkkqCWoz3GAADwuAJGGIBgAqLgAsdrY +A6nPcAAAUMMBoc9wAQCghn0EYAACofHAz3KAAOQuDoqhwV0IUQAPih8IEwGA4HQP4f/KIGEAD4oB +4A94D6qhwNHA4H4A2A2qDqo6CCAAD6qWD8//ANgKDO//jLjPcK0LvrpAwM9wgACYCACAiuiLcATZ +fdo925YOYAUXu+Lx4PHgeOHFz3KAAKwuRBKAAEAiAwwnCFEASiRAcQDZqCAAA/AjTQDPcIAASC41 +eAHhoKAveQDYRBoCAOB/wcXgeADaz3GAAOQuT6kB2A2pTqlMqVCpUalSqVOp4H9UqeB48cDWCO/3 +AdrPcYAAXB9jgXiLOQsRAQCBz3GAACQrxBAABiW4UiAAACGBwLgB2oDhz3GBAHgWJoHAeoDhzCAh +gMwiIoB88oDwEQgeAM9wgABoywCICQhRAJhyBPBKJAAAz3CgACwgcIDPdoAArC5FhqaGAiOAgADa +yiJvAAIjT4MA3colbxAXDgVwAEAAAAfqAiOAD04AASAFphcOxXMAQAAAB+0CI4APTgABIAamAYYW +6M93gAA8LgCG4YcfZxEPBRAZD8UQEQsEAAjwCQsEAAkPxRAA2APwAdgBpiCBxBEDBkErQQFRIQCA +yiZhEAbyKYaD4W8mCxDPcYAAJCshgc93gQB4FuaHgOEB2cB5gOAB2MB4hid/Hobn0SNigQDbAvQB +24DlzCIigMwjIoDMICKAzCEigMwmIpAE9ADYBfD9DBCAAdj5B4/34HjxwJYJwALPcIAAqCUEgFEg +gIDMDML9CdkIuc9woACwHzSg0cDgfuB4z3KAACQrIYIGeSGiANnPcIAAgMswoCWA4H8xoPHASg+P +9891gAAkKyGFJXgBpc9xgACAyxCBocGF6AHYEKEFgRGhBg5v/YtwAMHPcAEAsAoZCEAAz3ABAHwW +EQkAAM9wAQB8MwsJAQDqDK/8AdgA3s9wgACsLsGgFglv+gfYEglv+gjYXg+AAs9wgAAcOzYLgAbP +cIAAODsqC4AGz3CAAFwfAIDEEAAGDQheAYYNIADJcAXwegpgAAOFGQev96HA8cCmDo/3CHYA3cYN +7/8ocIDgyiBBAwwJ4v/KIIID9QaP9+B48cDPcIAARJoIgEUI3wHPcYAAPC5CgSGBz3CAAJAuQKDP +cIAArC4noM9xgAA4CSCBiiBGALoIYAAC2hIKYAAC2BIJ4AUC2PIJD/oI8M9wgAAkK/oJYAADgNHA +4H7xwCIOj/codT0I0QDPcYAA8BQhkc9zgABYCUCDPOE6YiGDZOJZYSEJRAMKIcAP63KKII0BiiPG +B0okAABhBS/5CiUAAc9xgACAy892oAAsIPCGngtgAAehPg7ABnoPL/wB2DIJ7/+pcAHYig9gAOlx +z3WgAKwvHIUTCF8GGIWIuBil4g7v96DYB/DPcYAAkDAAgYK4AKHCCs//SgpAANCGOg8v/AHY+gwA +AOILYAgy2M9wAIIBABylMgsv+gImwBMA2DIPYADJccEFj/fxwOHFz3GAAGjLABGEACEMcwClwQMR +hQAVDVAACiHAD+tyiiANAa0EL/nx2zcMkQADiZnoANgAqc9xgAA4CSCB+dgH3YIPIACpctoIYACp +cM9wgAAkK0oOr/+joD4Oj/9e8M9xgAAQywSJHQhRAAWJFQhRAM9wAAD//z4O7/8A2Z0IEADPcYAA +XB8AgcQQAAYNCF4BA4EYiBsIEQHPcYAAOAkggYogxAQeDyAAAtoC2DTw9gpAAGkIhA8AABQEz3CA +ACQrAIANCFEApggP+ijoANnPcKAALCCwgM9wAQCwCkDAAdhBwELAQ8FEwQbZCHIA25hzuHMAJYcf +AAAAfXYLr/zYc89xgAA4CSCBiiAECrYOIAAB2gHYCghAALEEr/elwOB44H7gePHALgyv9wDZz3Kg +ACwg0ILPcIAArC4IgM93gQB4FgImDRDPcIAAaMvlh2OABS/+EDd1AdugiMIjzgClwQsNUBADiCMI +UQDPcIAAJCsjoM9xgAA4CSCBz9hGDiAAANoA2Efwz3WAAFwfAIXEEAAGhwheAYMLUQADhRiIewjR +AM9wgAAkKwGAt+jPcIAAiB0AkIHgAdjAeAy4WwiADwAAABCwgs9wAQB8FkDAAdhBwELBEdhDwADY +jLhEwChwDNkB2ghzmHC4cAAlhx8AAAB9fgqv/Nhwz3CAAKwuz3GAADgJIIHIoNjYug0gAAjaCNgO +DwAApQOv96XA8cDhxQDZz3CgANAbm7kxoM9wgACoJQSAOwieAB4LT//PdYAAXB9NhT6VUyIAAGYN +IAQB2wCFxBAABhsIXgEDhRiIEwgQAc9wgACAyweAEQjeAM9wgAAkKwOADPDPcYAAOAkggYogSQc+ +DSAAAtoC2JIOAAA5A4/38cC+Co/3z3KgACwgMILPcIAA0B0EgM92gACsLgCAoIYCIUMD13MAAKAP +AN/L989zgQB4FqWD1bhBLYMQYn0LCEQDAYag6GOG4aZvC1AAz3WAABDLAIUc6AWFGugwggJ513EA +AFDDAdjCIA4AJei2CM//BIXlpeOmoLgEpdIO7/kA2Bvwig0v+gfYF/AF6waGAnknCVIAUyCAwQSm +DfTPcYAAOAkggYogSwKGDCAAAtraDSAAAthxAo/34HjxwOHFocGKIP8POgwgAEDAYQhRAM9wgABc +HwCAxBAABiMIXgHPcIAAiB0AkM9xgAA4CYHgAdjAeAy4JQiADwAAABDPcYAAOAkggYogRQcmDCAA +ANp6DSAAANg58CCBiiBFCBIMIAAF2mYNIAAF2C/wz3CAADguQIAA2QsKUQAgoCXwz3HA3wEAz3Cg +AKwvPKDPcACA///OCu//AdkX6HYMoAWLcAolAJAR8s9xgAA4CSCBiiDGAb4LIAAD2hINIAAD2Klw +Hgvv/wDBsQGv96HA8cC4cM9wgAA4CQAQBADPcYAAaCpALIAAFHgVIEABAGEVCJECCiHAD+tyiiDN +AIEAL/mg28oMAADRwOB+4H7gePHA4cXPcIAAXB8DgBiIHwgRAQohwA/rcoogTQGKI4QNSiQAAEkA +L/m4cxoPAAAIdc9wAAC/3x4K7/8A2QsIUQCMJRCVEPeeDm/8AdjPcYAAOAkggYogRQIKCyAAANpi +DCAAANgFAY/34H7gePHAigiP9xYJwAbPdYAAIBkAhc92oACsLx8IkAAYhhcIngYahlIgAAALCB4A +HIYLCB4HKgqP/xyGNwgeAM9wgAAcOwCAQiAAgMogYgCR6M9ygAA8LgmCGwgVAc9xgABcHyCBxBEB +BgsJXgEB4Ami2gmP+I4Mz/0bCFAAAIUTCJAAz3CAADgJAICD4MgMwf9pAI/34HjxwPYPT/fPcIAA +JCsAgC0IUADPdYAAOAkghYDhzCHigcwhIoII8oog0QAA3jYKIADJcsClJgpP/CkAj/cKJACA8cAM +8gohwA/rcoogTQKKI44NHQfv+Lhz4giP/2YO7/8C2M9wAQB8FooOb/wB2dHA4H7gePHAgg9v9wbY +ogkP+s9wgAAUFkokAAAAGAABz3CAAFwfA4AYiBcIEQEKIcAP63KKIMwN6tvFBu/4uHPPcIAAXDme +C0AGz3CgACwg0IDPdYAArC4ghQImQBARDgJwAAAgTm4KL/oH2MClz3CBAHgWBoBRIACAWAoi+sog +IgLWCaAFANhtB0/34HjxwOHFHgkv+gjYz3WAADgJAIWH4MwgIoI38s9xgACsLkGBB+rPcqAALCBQ +gkChz3KBAHgWRoJTCh4AhODMIGKBFvTPcoAAJCsCgofoAII7CFAAA4EZ6ADZz3CAABDLKaAqoADY +Pgmv/4y4D/CA4MwgooEL9AOBANoG6M9woAAsIBCAAqFDoSCFh+HMISKCUfLPdYAArC4BhYPoA4Uj +6M9wgACIHQCQgeAB2MB4DLg3CIEPAAAAEBIN7/8B2M9wgAAkKwCAawhRAAOFgeC4CuH5yiBhAAOF +gOCsCuH5yiChACfwjunPcoAAEMsKggmiANgKos9woAAsIBCABqLPcIAAiB0AkIHgAdjAeAy4IwiB +DwAAABDPcIAAJCsBgInoiiCFBkYIIAAC2poJIAAC2EEGT/fgeM9ygACsLgGCANmF6AOCgOAC8gHZ +UyCAwQSiAdrCIoEAANiA4cwiIYAC8gHY4H8PeOHF4cbPdYAANCvAFQMWEwvVD9Jr1H6+ZgCmIaZC +pgFrxbjAHRgQwcbgf8HFz3GAAOQuDYkzCFEAz3CAADwuAJDpuNEgooII9ADYDqkNqRUEr/8PqQHY +DqkPiUIgAIAlA6//yiBiAOB+8cAqDU/3/gmP/89zgAA8LgCTz3KAAGjLQSiBAMC5IarPcYAAiB0g +kYHhAdnAeQy5HwmBDwAAABCig89xgACQLqChoYPPcYAArC6noTbwz3GAACQroIEpDVEQz3aAABDL +JI4PCVEAJY6B4QHZAvIA2YDhyiGCDwAAECcD9CKDz3aAAJAuIKYpDVEQz3WAABDLJI0PCVEAJY2B +4QHZAvIA2YDhyiGCDwAAECcD9CGDz3WAAKwuJ6Wpcc91oAAsINCF5YECJs0TCQ3fF8Wh5oECJs0T +CQ3fF8ahKIOG6c9xgQB4FiiRI6IluMC4bg3v+QPZoQRP9/HAz3GAADgJABEEALhwz3KAAPwuQCyA +ABZ4FSBAAQBiFQhRAQohwA/rcoogjQCFA+/4dtsAGUABuwiQAD0IEQHPcYAAEMsAgasIEADPcoAA +PMsAogiBCKIA2AChBKEGDu/5Cdj+De/5A9jPcIAAVDsmCEAG0cDgfiMIUQBaDiAFANgLyAQggA/+ +//8DCxoYMAvIh7gLGhgw7vHPcIAAqCUEgCEIngDPcIAA3DIAgIroNgnv/ZDYDQhRAJoLwAMO8ADa +nroA2c9woAD8REGg4HghoAYOIAUocM9wgABcHwOAGIgNCBEBggpP/YXovgxAAsLxwvHxwEYLT/fP +daAAwC86hc9ygACQMACCdwgfAIC4AKLPcIAAgMvHgMC+geYB3sB+DQkeBxCFCQgfAADYA/AB2A94 +H+4whR8JnwJAFQQQTBUFEAohwA/rcoogTAllAu/4iiOFBhMIUQCKIBABEaU+CSAICtiKIBAAEqUy +CSAIBdjPcIAAaCYggGB5yXApA0/34HjPcYAAJCtAgScKUQDPc4AAEMsEiw0IUQAFi4HgAdgD8gDY +gODKIIIPAAAQJwX0z3CAADwuAoDPc4AAkC4AoykKUQDPcoAAEMsEig8IUQAFioHgAdgC8gDYgODK +IIIPAAAQJwb0z3CAADwuAYDPcoAArC4HogkG7/8DgeB44H7geM9ygAA8LiCSA4qAuae4ormGuCCy +4H8DqvHAHgpP9892gACYCACGn+gKCm/+VNgzCF4BAd2gps9wgACQLnYM4AcDgM9xgAA8CQCBgbgA +oc9wgACUJp4PYAgAgKlwBPAA2ALwAdg9Ak/3z3KAADwuIJIDioC5p7iiuYa4ILLgfwOq8cBaCCAA +4cUeCCAACHXmCCAACHNwdcojRQMQcw0Cb/fKIMUA8cDhxaHBAN1AxX4IL/2LcILgiiD/Dwzyz3CA +AGA8A4AggADAIniA4MogTAPZAW/3ocDgePHAocEA2EDAz3CAAGjLIYiLcCcJUQDPcaAALCAwgc9y +gACsLkiCQnkPDkVwTgAAIFoID/0D8DoID/0RCJEAiiD/D6HA0cDgfs9wgACAPAOAIIAAwCJ4gODK +ICwA8/HgeOHFz3GAANAdJIEggc9zgACAPEOD1bmggkaDiiD/D4DiBfICgqJ4SCAAAAkgQABquEgg +AADgf8HFz3GAAIA8C4FAgA6BgODKIIEP/////wryAoBCeEggAACZIAYASCAAAOB+4HjxwIoIT/eh +wQh3z3CgACwgQBASAM9wgAB8zV+AAN1EJwETiOFBKoABGnKGIP4vSiFAIMIhQiTAuEEvQhPAus92 +gACsLhYmAxBBo4jhzCAhgAj0AYYE6KoIj/wE8EIIj/zPcIAAXB8DgBiIDwhRAM9ygQAQDhfwng6P +/Tfoz3CAAKQiCIhjCNEBz3CAAHzNmBCAAM9ygQAQDgK4FngAYksIXgPPcIAAfM2YEIEAEmkWeBpi +Kw8eEwCCiLgAogHYD6rPcIAAXB8BgMAQAAYRIECAzCGig+gJAggH8PIJIAivqoDg4AkCCM9wgAA4 +CSCAh+HMISKgQvJKcH8IECAIponpz3GAABDLCoEB4AqhJvBGFoAQRQhRAM9w7f6+ukDAz3CAAJgI +AICA4MogAQfKISEByiKBDwAAfQDKI2EPsAzhBMAr4QVGHkITRR5CExoOb/9HHkITEgqP+QeGJoZC +cAIgQgAJCt8HBqZMFoAQDQhRAEweQhMC8ACmbQcv96HA4HjxwBYPD/cIds9woAAsIPCAHQ7yEQDd +CiHAD+tyiiANAoojCQOYdW0Gr/i4czcJkAH2Do//z3CAAKwu6KDPcIAAOAkAgIDgzCDigQnyz3CA +ACQrAYCA4GAJgfnPcIAAPC6poM9wgACQLs9xgAAkKyCB8CCAA/hgDwlRAM9xgAA8Lqmhz3OAAKwu +JYMCIEIACQrfBwWj6QYP9/HA4cUIdQTZz3CgAMgcKKCuD2/3FtjPcaAAwC8TgYDlzyDiAtAg4QIT +oYDlPNoG9M9wgADwFECQz3CAAPAUAZAQuEV4wBkAAK0GD/fPcqAALCBQgiJ6z3GAAFgJFXkAgRcI +hQDPcIAAXB8AgMQQAAYHCF4BQKHgfvHACg4P9wDez3CgALQPvICWCCAFyXDPcoAAXI0Eks9xoADs +JxC4hSCEAAahBZIQuIUgjQAGoQeCz3OnABRIB6MIghCjA4LPc6QAuD2bGxgABIKmGxgABYKSGxgA +BoKjGxgAz3CkAOz/xqCKIIoABqE2CCAFr3jPcIAAqCUEgFEggID4CKIGyiBiAO0FD/fgeOB+4Hjg +fuB48cBuDQ/3z3GnABRIAN2ooQeBz3aAAFyNB6YQgc9ypwA0RAimp6HPcPMP//wQoaDYtqGauPUa +GADPcaQAuD2bEQAGz3eAAMgdA6amEQAGBKaSEQAGBaajEQAGBqb/2JsZWAOmGRgAkhkYAKMZGADP +caQA7P/PcAAA//+noQahAIcB4ACnFQhRAAHZz3CgAMgcMaBGC+AHKHAE2MoLL/hAJgESDdi+Cy/4 +QCaBEs9wKAACAc9xoADsJwahiiCNAAahAIdCIECAAKcF9M9woADIHLGgBQUP9+B48cCWDA/3USDA +gQ0SDzbPc4AALMwDEg02z3GAADzN9HsRixAThAAS8gHgCHIyFYUQZ5ECGQIBz3ZBAIMAZrHPc4AA +wDcDqRHwQCRCADEVhRBCqcATAwEDqc92IQCCAGaxz3OAAMQ3Ew2FAMShAIMB4ACjBIFT8M9zgABM +zOtjAePBhWSpANpwjXcOHhEvJQgA739JJ8QQ8mvPcIEAEA72f+Bg0o0RCJ4Fz3CBAFAQdngBiAPw +SHAAJI8PgQBQEHZ/5I8IJs4TCCYAEKBwSSDOAxZr1XjPdoEA0BEAZs92gQBQEXZ+YYbPdoAAXB/E +htiGxXsEI4MPAAAACGZ4AvADhQKhmBWAEGiJDQsAAESpYNgYuATwANiduASh5QMP9+B48cDhxQPI +pBAAAFEgAIDPcIAAXB8EgATyG5AD8BqQzgmABrvoz3CgABQEA9kjoCDYDBocMM9xgABINhaBAeAW +oQPIANqYEAEApBADAJQYQACeEAEBrLuSGEQAvhABAa27gBANAaQYwACQGEQAfhABAYAYhAA9ZbAQ +AQGieTB5sBhEAIIQAQF+GIQAhiPlj7IYRABYC0L9WQMP9+B48cDaCi/3CHMQiTMRjQAB2kCrDRIP +Ns92gABUzO5mz3KAAITMSNzBqw0SDzYCIg4D9CbOE8GzDRIONvAiggNBo0GBIwoeAdKJz3KBAFAQ +Fnrcq0CKhiJ/DFx6BLpFftyrA/CA2lyrBLgFfb2rHJHPcoAAzMwPsw3I8CIAAASzB8gFo1QRAAEM +swCRDbOgEYIASKMGyAQggA8CAEEADQiBDwIAAACIukijBsiGIL6PBPKJukijnBEAAc9zgABEPSa4 +wLhAKAIDD4HAuA24RXh1Ai/3AKPxwP4JL/cc2hpwz3CAAOoJAIjPdoAALD0KIYAvgAB00oQoHwAg +hgAhRC7PdYAAeM9AoQAlQR4AJUIeKIFAIgMHACVAHk8hTwPoogKIYaYNCF4Ag7mNuSiiz3CAAGwK +AqMY2AKmz3CAAAgKAIAMHgARz3GAAPAJmgmv+iCBANnPcqAALCBQgmGGCwhyAEqjWGAKo89wgADq +CQAQhwCELx8AJ3VCjS9wsQpfABkIESDPcYAAsNIbYc9wgAD8CWCgSvDPcoAA/AlAgkGKRCi+KMdw +gACUzxfgQCKEADIgQg4vJAcBz3CAAAAKAuJPegAQhQBBCnIAAiWDAIQvHwAvcAAhTw4AJ4YfgACU +z0QovihAJo8FMidPHjtjx3OAAGzSCOMbYwHhL3ngq9EJooACJYMAhC8fAAAhQC4bY89wgAD8CWCg +DpUCIAABDrUOlVhgDrVlpgfwz3GAAIzSOGAFpg6V/QAv9wSm4HjxwOHFCHUGjSWNCLgFeS94KLkv +eQi4p7msuKy5JXgPeSi4CLkleAWtKLgGrQDZKHBhHQIQKLhiHQIQKHAHrSi4CK1AJUAUXgjv+CDa +QCVAHADZUgjv+BDaqXBB4ADZRgjv+AjaqXBR4ADZOgjv+BDaz3CAAEwJYIBBKwEEL3kIuUErAgZF +eW96KLsIum97ZXoQukV5Ka0ouSqtKLkrrSi5AYAsrUEoAQQveUEoAgYIuUV5D3oouA94CLpFeBC4 +JXgNrSi4Dq0ouA+tKLgQrV/YCLhFAC/3AbXxwMIP7/YA2c93gABMCWWXIwtyAIIkAjjPdYAAZJPP +coAAIHwqYjxlAeEvefMJ4oBArESXIQpyAADdz3OAAESTz3GAAAB8qWG8YwHlr331DaKQIKxukLDj +IgElAADei3J+DOAHyXGBxZTBQCUAF7YOIAUQ2kAlABfJcVIPr/gQ2gIUADGLclYkBDMPeSi4CLkl +eGRob3vPcIAARJM+Cu/8KI9KJAB0yXCoIIADACQCMAAkATBgEYEAUBKCAL8KQQAB4A94Io0BjQi5 +JXgPfii4D3gIvgV+BZecwUAgEARAJcASLyAHJD4OIAUQ2lYkATTPcIAAZJMuDiAFRZecwozAyXGm +DKABCnP7jc9wgADACM9xgADoFGCB6GADuBV4EGPCuF8IUQHPeCMIEwROIDwEqCBAAwIggQMAJAIw +g3EwEYEAAeAPeDAaQgAAJ40fgQD4FSSNBdgDuTV5O2MAsySNz3CAAOgUQICMwAO5NXkQ4llhsg0g +BRDaJ/AA2D3wACeNH4EA+BUkjQHYA7k1eTtjALMkjc9wgADoFECAjMADuTV5E+JZYX4NIAXJcs9w +gADoFCCARI0TDlETA7pVelBhWWGMuACxRI3PcIAA6BQggAi/A7pVelBhWWHleACxRI3PcIAA6BQg +gAO6VXpQYVlhg7gAsQHYMQbv9oAkAjjgePHAEgggAALY/gkAANHA4H7xwLINz/bPd4AAXB8VJxAQ +ABAOIAh1FJYLCFIBiOAC2ML2ANgapkokAHIA2aggQA3PcIAAFE/0IEIAz3CAADixNHhAsM9wgAAk +UfQgQgDPcIAAaLE0eECwz3CAACRP9CBCAM9wgABIsTR4QLDPcIAANFH0IEIAz3CAAJCxNHhAsM9w +gAAMUfQgQgDPcIAAWLE0eAHhQLAIhuW4BNnKISEANKYRCB4BCdlGHkQQLtoG8BTZRh5EEDLaW7ZZ +jllhMHlGHkQQGuE6thUIHgAK2FQeBBAG2FYeBBAH2AnwENhUHgQQANhWHgQQBdgPpuIPYAOpcDyO +KHBEHkIQhiADAOa5WB4CEMoiQQAL8lAhwwFvekQewhBQIMMBb3hYHsIQEwleAUhzhiMDAG96RB7C +EA0JHgGluFgeAhALCd4ApLpEHoIQLw2QEO4Kr/mpcAAQACC5EAAGUSBAgPHYwCgiAcoggQ8AAJMA +wCghAYQeABAY2I24E6YIhg8I3gC2F4AQibgD8J0XgBASps9woACsLxmAz3GAAKglMLjAuE4OYAcF +oQiGBCC+jwAGAAAA3wryNrjAuBt4AeBaHgQQAtgapgTwWh7EEwDYF6YYpmINb/2pcCiGAdpIc0Ep +AAU1uVIgAABSIQEAwLjAudYN7/2YcikEz/bgePHAwgvv9gfYz3agAMgfSB4YkM93gABcHyOHz3Ws +ANQBGoFMHhiQguAC2MogIgDQHQCQiiAEAA+mRhEAAbAeABBGEQABtB4AEB/YCLgOpgiBUSAAgADY +i7gK8hCmvg5P+c9woACkMAGAhLgK8BGmsg5P+c9woACkMAGApLjPcaAApDABoc9wgACAPQCAFQge +AIYg/w4iuBS4z3GAAAgIC6F6CU/5rglAAQoPQAOKD0ADz3AAAFVVWh4YkAHZWR5YkM9wpgAoAC+g +A4daEAEBz3CmAOgHJqBCCA/9A4emCuAEDZAA2IwdGJAH2I0dGJAA2IsdGJDPcIAAcCYggGB5BNgN +6M9xgAAgFxqBO4EkeA8IXgR2CuAAAtgE8B4OIAYB2M9yoADEJw8SAIZjh0QgAQIbgw8aGIAPEgCG +o7gPGhiADxIAhgV5DxpYgDyDz3CgADAQJKDPcIAAfM0QeI8aGIDPcIAAZJTPcYAAZKQQeBC5JXiQ +GhiAiiAEAJIaGIAdg0AaAIDPcIAAnB5TGhiADxIAhp+4DxoYgADYEBoAgB6DHBoYgIUCz/bxwAoK +z/ZukAh34+OYJEEzGnGT9wDZHg+gB4tygcYijgGOCLkleA96KLgIug95BSGRAA0I3gChAyAAANgJ +CBEg9wifgVEhwKHRISKi0SFiovPzCwgQIOMJHqNeFoEQXRaAEAi5JXgPeSi4D3gIuQUgUgAmjgWO +CLkleCeOELkleCiOGLkleEEoAQQveUEoAgYIuUV5D3oouA94CLpFeBC4So4FeQmOCLpFeEuOELpF +eEyOGLpFeEEoAgRPekEoAwYIumV6D3souA94CLtleBC4BXrPc4AATAkBg18KJIBTIYQgDQoBAACD +TwkEgCCjQaPPc4AAcH4gszC5IbNCszC6TCRAgEOzn8XA9MlwTeBWJYESZgggBRDayXBN4ADZAgmv ++BDai3AhkItyL3gIuCi5JXhkaG97z3CAAESTENnyC6/8ViUEEkokAHQA2KggAAMaZRllQBGBAFAS +ggAwcm31AeAPeOlwANmLcsoNoAdul0AmQBtWJYET/g/gBBDaViTTN89wgABkk0AjASHqD+AEENqX +CBAgViWAEyDZiiIEAItzY+NuDmABCiSABItwY+BAIwElwg/gBEpyMiSAPwAADAGMIEOHOfUyJIA/ +AAANAUIgkgEyJIA/AAAOAYDgLyKIJCv1MiSAPwAADwGP4CX1MiSAPwAAEAGMIAKLHfUyJIA/AAAR +AYHgF/UyJII/AAASAUAjACdAJQEYUyJQAFoP4ARKchfwViWAEyDZiiIEAItzY+PeDWABCiSABItw +Y+BAJQEYMg/gBEpyRCEALEIoEAFAJQAYCnHJcg0KEShaCg/9BPCOCQ/9Fg+v/4twz3CAAESTENmL +cmPbtgqv/FYlBBNWJQATmfDJcE3gVSVBFeYO4AQQ2slwTeAA2YIPb/gQ2otwIZCLci94CLgouSV4 +ZGhve89wgABEkxDZlguv/FYlBBJKJAB0ANioIIADGmUZZUARgQBUEoIAMHJaBcL/AeAPeOlwANmL +ckoMoAdul4tyz3OAAGSTY+JzCBAgQirBIFYk0TdocGG5vgqv+Cpz+BSAMIwgQ4ceBcL/+RSBMPoU +gDCA4EIhkgEOBeL/LyKIJPsUgDCP4P4Ewv/8FIAwjCACi/IEwv/9FIAwgeDqBML//hSAMEAlARhT +IFAAQCEAIhYO4ARKcg3wQirBIGhwYblWCq/4QCUDGEQhACxCKBABQCUAGApxyXINChEoKgkP/QTw +XggP/eYNr/+LcM9wgABEkxDZi3Jj26oKr/xWJUQTViVAE8lxTeG+DeAEENryDaAH6XAgkItwYgxv ++IYh/Q8B2I0Gr/aVJEEz4H7gePHAz3CAAPSMGBAEAAohwA/rcs9wAADlDt7bnQUv+EolAADgeM9x +gAD0jAWB4H8GofHABg6v9gK4FXgAII0PgABksAiVUyAQAM9wgABomteIju7PcYAAOJMLiYYg/4wE +8sCJBvDPcIAA9L3BgEYOoAPJcM9ygAB8zVYSAQHPc4AAys1AIQQLz3GAAOoJ4InPcYAAgs+ELx8Q +NCFBDoYhfww8eRQjQQCMIP+PYIkCJMEADfIA2xEOtRMPIwMACZVleAm1BfAFhWV4BaUNCBAgB5UR +CQUAJ7UjggSCIaUCpca1uQWP9oDg8cA02Af0Tg2P/VAgQQQF8EYNj/1PIEEEfg2v/TTY0cDgfoDg +8cD02Aj0Kg2P/VAgAQD02AfwHg2P/Qhx9NiAuVYNj/3RwOB+4HjPcIEArB0ggM9wgAAEngTpIIAD +8CKAz3CgACwgEIA4YM9xgADECeB/AqHgePHA3gyP9s9ygACEM2KSz3WAAORBQIWkwUDCQpXYEQQA +z3WAAPBCBByEMECFQsJClQwchDC0gFyBCwpkA9hyAiJGA1OAt4FQdcIlhhDPcoAAPDQGEgUByBEO +AP/aCLpEfii+AByEM8wRDgBEfii+AhyEM9ARDgBKJMBwxHoougQchDDsEQIACByEMPARAgD0EQEA +ChyEMAwcRDAA2kh2qCDAAwPZFQmOAxQkgTPgkQgiwgMkkQkjQwAB5gAlgREFKYEPAwAAIC9xBS0+ +AQ0JRQ6MEAEAAeED8ADZsICMGEAAVSDOBVMlwRAUJkEQQLFcEAIBSiQAdADfqCAAAvQmwRMwcsoi +SwAB51UgwQeQGIQAwr0UIU0DYLV8EAMBSiQAcgDaqCAAAvQhjQAII0MDAeIG43B7khjEAA0Er/ak +wOB48cCeC6/2mHBvfwO/pG/PcIAAhDO2YKJvtWAG5/BgEQtRAuqRjCcCmMogawAVClEAdHlBkR1l +IwpCAwJ6QbEK8BcKkQB0eUGRWGAPDgIQAbEB2ZgcQgCxA4/24HjxwEILr/YA2c9wgABomlUgRAdo +EAABgODPcIAAaJpW8moQAgE9ClIAz3OAAMQJAYPPdYAAoFjwJE4AUybPFdd3rAAAD8wngp/yAABQ +DPQ4vsK+AeEvec5l3wmigMV4AaMA2QTwAaMB2YEJEQDPcIAAaJpsEA0BdQ1yEADaz3OAAMQJz3CA +AOya8CCAAFMgzgXXdqwAAA/MJoKf8gAAUAn0OLgTCFAAFQiQAAHZCfAB2RzwAIOCuATwAIOBuACj +AeJPesMKQoMS8AWQz3KAAMQJIIJRIACBAYKAucUgogTPICEAAaIgogDZ3QkRAM93gAAEnhWH0Qh0 +AADeM241eQAnRBBZFIQA+WHPcIAAaJpEEIAAcm51e891gABksHplSJJ9ZQsIAQGDuki1z3OAAMQJ +YYN8EYAACyDAgAbyTyIAARB6CLXPc4AAxAlgg30RgAALIMCABfJPIkABEHoItc9wgADqCQCIfhGD +AIQoHwDPcIAAes8yIEAOCyDAgAXyTyKAARB6CLX44gz0z3CAALCaXOGOCW/4iHJIlYTogrpItfzi +DfSWC+//yXAIlQHZgLgItc9wgQCsHSioAeYVh89+Ow4EkM9wgABompUQgAAI6M9wgAAEngOACQif +AADYA/AB2C8mB/CF8soPr/0A389wgAAEnhWAgOD2AA4AAN5q8BNuFXjPcoAA9JoZYi2JACIFABNv +FXgAIIIPgAAEnlkShgAAIIIPgAAEnhJvFXjPdYAAZLAbZWiTHWULCYEBg7totc9xgQDEHdZ5fBKA +AAQRBAALIACBBvJPIwABEHsItX0SgAAggQsgQIAG8k8jQAEQewi1z3CAAOoJAIh+EoEAhCgfAM9w +gAB6zzIgQA4LIECABvJPI4ABEHsItfjjGPRAJQAEVSLBBXYIb/jIcpDoCJWCuAi1hgrv/+lwCJUB +2YC4CLXPcIEArB0oqAHmz37PcIAAaJqVEIAAKQ4CkAHnz3CAAASeFYDvfxUPBJDPcIAAxAkiCG/4 +CNnPcIEAxB0WCG/4gNnPcIAABJ51gCcLdAAA2c9ygABksLJptX24YgiQXWUB4S95hiABD+8J5IAI +tXkAj/bgePHACgiP9nSAXIHYEQ0AcHLCIsYA94EzgDB3widGEALbz3GAADw09CHEAAYRBQEA2S6g ++mIFKoIPAwAAIC9xBSx+Aw0JZXCMEA4AbqAFLX4DGwlFDpAQAQGUEAIBAuELCYIA5ObD9wHZLqAJ +AI/24HjhxeHGdIBcgdgRDgACIsQAU4A3gTwQBwCMEAgAAiGFAM9xgAA8NALa9CGKAAYRCQHPdYAA +hDNClWGVChEGAZIQAQGjlQgjQwAAJQEBBSmBDwMAACAKJEAOBSq+Ey0JBXEqkIwhAojS9gLZL6CQ +EAEBfmWUGEQAIZBnDkMQonkhsAHZmBhCAC3wBSm+Ey0MRQ4pD5AAkBABAZQQDgEC4Q0JggOMIAGZ +yvfBkAHZ3WUzCmIDL6ChsOfxGw+RAKGQACbBABMJQwMCJY0RobAB2ZgYQgCQEAEBlBhEAADZL6AJ +IsIAIZANCkIAQbAB2ZgYQgDBxuB/wcXgeCJoANpAsEokwHXPcIAAhDOoIIACFiCDAGCTFCGMAAHi +T3pgtOB+4HjxwHoOT/ZygMiB2BECAHB2wibGEHGAI4FwccIhxgAA389zgAA8NPQjxAMB3dlhBSmB +DwMAACAvcQUsvgD0I0MDDQllcO2gAtktoAfwBSu+AAcJRQ6toI0GT/bgeEiBUqBDgVGgXIFUoDeB +4H8zoOB48cAODm/2AtsIdSh2AdgAsalwXgrv/02FTYWpcMlxUgrv/wPbTYWpcMlxRgrv/wXbTYWp +cMlxOgrv/wbbToWpcMlxLgrv/wnbToWpcMlxIgrv/wTbJQZP9s9woAAsIBCAz3KAABDLBaLPcIAA +RJoIgADbGQjeAQSKCwhRACWKCQlQAAHbIIII6wCCgeDMICKAEvIP8BDpDwhRAAWKgeAB2ALyANiA +4KQAwvgNCVAAAtjgfwCi4H7gePHAVg1P9s92gADIHQCGAeAApgDdFQhRAAHZz3CgAMgcMaCaCyAH +KHDPcIAAbAkgkIa5ELkFIYIPAADCEs9xoADsJ0ahAZAQuAUggA8AAAITBqEAhkIgQIAApgb0z3Cg +AMgcsaBdBU/28cDuDE/2z3CAAAAoGYAA3YHgyiHCD8oiwgfKIIIPAACoE8ojgg8AAJAByiRCAzgE +4vfKJUIDz3aAAMgdAIYB4ACmFwhRAAHZz3CgAMgcMaACCyAHKHDPcIAAbAkjkASQwrnCuAO4JXgQ +uIUgjQDPcaAA7CcGoQCGQiBAgACmBvTPcKAAyByxoNEET/bxwGIMT/bPdoAAyB0AhgHgAKYA3RUI +UQAB2c9woADIHDGgpgogByhwz3KAAEApAIrPcaAA7CcQuAUggA8AAMJpBqEBihC4BSCADwAAAmoG +oQCGQiBAgACmBfTPcKAAyByxoG0ET/bgePHA8gtP9gogAKDPdYAALD8AFQQQKvLPcKQAuD0A2jcM +EQCbEAMGz3GAADA/YKGmEAMGz3GAADQ/YKGSEAMGz3GAACQ/YKGjEAMGz3GAACg/YKGbGJgA/9mm +GFgAkhhYAKMYWAAB2DXwTCQAgMohwQ/KIsEHyiCBDwAAfhnKI4EPAAD8AuwC4ffKJQEEz3CAADA/ +IIDPcKQAuD2bGFgAz3GAADQ/IIGmGFgAz3GAACQ/IIGSGFgAz3GAACg/IIGjGFgAz3CAAKglBIAi +uMC4yg0ABIUDb/YAHQAU4HjxwBILb/YA2M91gABwJiCFQHknCBEDz3aAAHgmIIZgeQLYi+gghmB5 +A9iH6O4Kb/1Q2AsIngEA2ALwAdgvIQcgz3CAAHAxz3eAAIwmng6v+QCnz3GAALw3FIEB4BShz3GA +AMgdAIEB4AChFQhRAAHYz3GgAMgcEaEKCQAHz3GAAHwoBIErCFEAJoHPdqAA7CdgeQDYz3CAAPS9 +GIiX6M9wAQAGAQamz3ASAAYEFvAKIcAP63LPcAAAhxmKI8UJSiQAANUB7/cKJQABz3ABAAcBBqbP +cBIABwQGps9wgAD0vSCAA4Ar6eCHRCi+A8bYkrgGpiCFJ3dgeQDYcwgQAyCFYHkA2GcIEAQghWB5 +ANhfCFAEIIVgeQDYUwiQBM9wOQACMwamz3A5AIJMBqbPcDkAAmYGpsfYlbgY8EQovgMAIY9/gACw +UcfYkrgGps9wAAACMwamz3AAAIJMBqbPcAAAAmYGpsbYlbgGptYPD/7PcIAA9L0YiM9xgAD0vbYN +IAQggS8JECDPcAAAAm4Gps9wwQBCbgamz3ADAMJuBqbPcDYAQpcGps9wAgBCawamz3AQAIdyBqYF +jxC4BSCADwAAQnAGpgSPELgFIIAPAACCcAamA48QuAUggA8AAMJwBqYCjxC4BSCADwAAAnEGpgmP +ELgFIIAPAABCcQamCI8QuAUggA8AAIJxBqYHjxC4BSCADwAAwnEGpgaPELgFIIAPAAACcgamAY8Q +uAUggA8AAEJyBqYLjxC4BSCADwAAgnMGpgqPELgFIIAPAADCcwamIIVgeQDYJQgQAyCFYHkA2BkI +EAQghWB5ANgRCFAEIIVgeQDYEwiRBAyPELgFIIAPAADCfwamz3ABAEZqBqbPd6AAyB+kFxAQFQkQ +IM9wUADGcwamz3AgAMdzHfAghWB5ANg1CBADIIVgeQDYKQgQBCCFYHkA2CEIUAQghWB5ANgVCJAE +z3CAAAZ0BqbPcIAAB3QGps9wgADGcwamz3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqbP +cIAA9L1YiM9xgAD0vQCIJImA4gHawHrPc4AA9L1eCKAGeYsk2BjZbg7gBjPaLwhQAM9wgAC8N1AQ +BADPcIAA9L0MEAUACiHAD+tyz3AAAIoZOQev94ojBwcPCRAgz3AGAEJrBqbPcBAAx2oGps9wEACG +cgamDwkQIM9wAgBGagamAg6ABiYNgAYk2AHZCg7gBjPaLQhQAM9wgAC8N1AQBADPcIAA9L0MEAUA +CiHAD+tyz3AAAKoo0Qav94ojxwykFwAQz3GAALw3AiAABBOhz3ACAEdqBqYghWB5ANgtCBADIIVg +eQDYIQgQBCCFYHkA2BkIUAQghWB5ANgNCJAEz3BlAMJuBqbPcIAAyB0AgM9xgADIHUIgQIAAoQT0 +ANhRHxiQQQcP9vHA1g4P9s9wgAAAKBSAgOCL8j4NL/4H2Hpwz3CAAJQ0DIiGIP8BQ7hhuIbg9AAN +AM92gAD0vSSGz3KAACS8MyYAcIAAYEBAIhELBLk0eUAiEApAIhIGQCIPCEAiDQQ6YkAnAXIUeQB5 +z3GAAKgpSHBV8M9xgADIKQRqUfDPcYAA6ClAIgACS/BAIgADz3GAAKgp2gkv/gDaBIbPcYAAyCkE +uBR4uGA78EAiAAfPcYAAqCm6CS/+ANoEhs9xgADoKQS4FHj4YCvwQCIABc9xgADIKZoJL/4A2gSG +z3GAAOgpBLgUeEJwG/BAIgAJz3GAAKgpegkv/gDaBIbPcYAAyCkEuBR4AnBmCS/+ANoEhs9xgADo +KQS4FHgicFIJL/4B2joJL/5qcAkGD/bgePHAz3CAAAAoD4AR6M9wgAD0vQSAz3GAAHS9ArgUeDhg +z3GAAAgqYg0P/tHA4H7gePHAjg0v9kTaz3CAAGxRz3GAANjL0gxgBADeAt0WCCAAyXBhvfkNdZAB +5tEFD/bgePHAVg0v9gDaz3GAAFwfFXlggQS4ACCQD4AA7E65G5gAAIEEEA8gz3aAAGxRvhjYA6CB +QoaKIAcPYYYdZfAdgBDsHcAQIIFGhs91gADYy2WGOGD4GIAAFibBE/QYwAAWJcATBOAE4boNL/YI +2gwQACAWfhZ9BG0kbqYNL/YI2j0FD/bgePHA0gwv9hLZqcEIdk4LYAaLcEokAHEA2qgggAIWJIAw +KIgLCZIAYbkoqAHiAsIBw891gABcH9V9AIWKIQcP9G7Hd4AA7E44YOwYwADwGIAAAIUGwgXDOGD4 +GIAAg8H0GMAABBcQEM9wgADYyxYgAAQE4CoNL/YI2uOHz3CAANjLh8H2eATgFg0v9gjaAMAghbkZ +GAAghbkRAAYVCB4AvhnYAyCFvxEABoC4CPC+GRgEIIW/EQAGoLimCq/8vxkYAITolgqP/AToANgD +8AHYEHZcCeEGyiCBAwCFuRABBlEhQIDx2cApIgHKIYEPAACTAMApIQEODa/6hBhAADkEL/apwOB4 +8cDWCw/2z3aAABg/z3WAAOQJEukgho3pAKUKD6/4DthuDG/+iiAQAAHYAKYO8CCFJXgL8MoNr/gO +2DoMb/6KIBAAANgApgCl+QMP9vHAegsP9s9xgABUJgCBoLgAoRoLb/sB2M9wgAD4mQAQBABMJMCA +yiHND8oizQfKII0PAACBDMojjQ8AANoAxAKt98ol7QCnDHQAAN0UbQAggQ+AAPiZB5HGkeSRELgF +fgWRQ5EQuAV/ApEQukV4GnAODu/3yXFacM9wgAC0WPAgQQNELT4XCiFALgAhgH+AAPQ5IKBqCu/6 +CnAIcQAhgC+AAOg5sg/ABAcOxBOY789wgACoWPAgQQNELT4XL3YAIYB/gACcOiCgNgrv+kpwCHEA +JoAfgACQOn4PwATPcIAA+JkAgAHlaQ0EkO0CD/bgeOB+4HjPcYAAsCbPcIAAfCjgfyKg4H7gePHA +ggoP9gDez3WAABzMz3CAAHgmIIDApWB5AdiD4Mohwg/KIsIHyiCCDwAAmBnKI4IPAADrAMokYgDA +AaL3yiWCAwCFmLgApQDYwa3CrY64AaUCpc92gAB8JkCGBthgegHZQIYH2GB6AdkBjYECL/YAreB4 +4H7geOB+4HjxwM9wgAAAPQCAcwhUAc9woACsLxqAUiAAAGMIHwDPcYAAXI0LgQHgC6HPcIAAZCYA +gEB4Lg4AAM9wgABgJgCAQHgmD4AAwgnP/Q4PD/zPcKAAeEUAgAQggA9wAAAAQSg+hff1z3CAAFwf +I4BIgTSRUyIAAOoLoAIB27YLr/gS2NHA4H7xwOHFtMHPdaAAtEdxFQCWBCCAD3AAAABBKD6F9fWK +IP8Pbx0YkGsdGJAiDu/4i3CmDU/8DuhvFQSWaxUFlgohwA/rcs9wAACxE7EAr/c024YJz/iuC8AD +nQEv9rTA4HhAiAHYAKFougK6VXrHcoAAAChjgmOhYYJhoWKCYqFkgmSh4H8AouB48cD2CA/2z3eA +AAQ9BocDgM91gABcjSCASYUAIoAPLQDAxgJ5gQlyAKHBz3aAAMgdAIYB4ACmFwhRAAHZz3CgAMgc +MaAaD6AGKHCLcZ4P7/ZC2ACGQiBAgACmB/QA2c9woADIHDGgABQEMQQkvo8AABf/yiHCD8oiwgfK +IIIPAACmE8ojIgzsB2L3yiUiAACFgrjGDCAAAKUiCCAAAdgAhaK4AKUphcdxLQDAxhoN4ATpcK0A +L/ahwPHAFggP9q/Bz3GAAPRBAIFKJAAgTcAEic93gABcH27AA4cIgFMgFwA3FIAwQMAuwEHANhSA +MELAz3CAACAXOoAbgCR4MbjPcaAAtEdHEQGGwLiA4cwgIoA+BAEAz3CAAFyNABAEAFEkQIDKIcEP +yiLBB8oggQ8AAKoTyiOBDwAAWgA4B2H3yiUBBc9wgAD0CCCQz3CAAFyNIrAA2Z65z3CgALRHUxhY +gOB4UxgYhSYKz/7PdoAAyB0AhgHgAKYVCFEAz3GgAMgcAdgRodoNgAYtwM91oADsJxC4BSCADwAA +Qi0GpUAkgTxKDu/2QtjPcAgAhxAGpQCGQiBAgACmB/TPcKAAyBxEGAAFz3CAAOS0FiDABSSAAIAK +ucm4BCGBDw8AAPwFec9wpwAUSC2gmg+P/UPAFw8QIIoh/w/PcKAAtEdvGFiAaxhYgAHYz3GgALRH +YBkYgAOHMiCADwAA2AKA4AHYwHgPuJC4m7ifuF8ZGIAAhgHgAKYTCFEAz3GgAMgcAdgRoSINgAZA +JIE+pg3v9hHYIIZCIUGAB/TPcKAAyBxEGAAFz3CAAOQyB4hKIAAggeAB2MIgAQCA4ETAUAIlAAol +ACQAwgHAQnhHwM9woAC0R3EQAIYEIIAPcAAAAEEoPoX19c9wpwAUSFwYAAUvJwcUEwgRIM9wgABH +BAalSiEAIAfwSiGAIM9ygABGBEalAeEgphUJUQDPcaAAyBwB2BGhggyABgW/8H8Qv4G/h7+Mv+al +IIZCIUGABvTPcKAAyBxEGAAFSiIAIUp3AeFhvyCmEwlRAM9xoADIHAHYEaFGDIAGAsEVbyV4EHgQ +uIUgigAGpelwgCCCDRB4RcAGuIG4l7gGpelwgCBCDxB4RsAGuIG4l7gGpc9wAAACLwalz3AAAMIw +BqUAhkIgQIAApgf0z3CgAMgcRBgABYjAicGKwovD0gqgBEAkBDwswIjoz3GAAAw4EIkB4A94EKkd +CFEgGQ8QIK4JT/wRCFEAMBwCNU8lACAvJQcgz3GAAOS0FiHBBTARGQAIws9wgACUjRYg1gMJwPAe +gCD0HgAgB8CIInwALyMAIAQrviAvcGIP7/oogQ4gmA8AAAABCcCIIHwABCj+BC9wSg/v+itxDiCB +DwAAAAEJIIM/AAD/AQkhgg8AAP8BSCMDAEgiAgAswFQe2CBVHpggIQhRAAwUBDBAKQAhQCyBAThg +9XjHcIAAILVisEOwAIYB4ACmFQhRAM9xoADIHAHYEaH6CoAGA8FAKQAhBrk4YPV4x3CAACC1IpA8 +egXBELoGuYG5RXkmpQOQBsEceAa5gbkQuAV5JqUghkIhQYAG9M9woADIHEQYAAVCIlIgTCIAoFIG +zf8EwEAgUCAScL4Fxv86FAAxUSDAgcoggg+AAEYEyiCBD4AARwQGpQHhIKYVCVEAz3GgAMgcAdgR +oW4KgAYyFAAxELiBuIe4jLgGpQCGQiBAgACmB/TPcKAAyBxEGAAF3g2P/s9woAC0R3EQAIYEIIAP +cAAAAEEoPoX19R4Mj/jPcIAAXI0MgM9xgABcjaJwDKENgQHgDaHBA+/1r8AA2c9wgAB4jSyoLajg +fy6o4H7gePHAkgvP9Qh2LrjAuAS4TyDBAM9wgADkMgCIz3WgAOwngeAB2MB4B7gleBC4hSCRAAal +ngwv9gHYgL7GpcEDz/XPcIAAByHPcaAA7CcGoc9wgABHOgahz3CAAMdTBqHPcIAAxyQGoc9wgAAH +Pgahz3CAAIdXBqFJ2c9wpwCISTCg4H7geAHZz3CgAMgcMKBL2c9wpAAcQCSg4H7geM9xAQCYPs9w +gABoJuB/IKDPcYAAXI0AgYC44H8AoeB48cDWCu/1uHBTIIEAz3CAADRYKGCB4Mohwg/KIsIHyiCC +DwAAlRnKJIIPAAD+ACACYvfKI+IHz3aAAHgmIIZgeQHYJwjQACCG63VgeQHYuHDPcAAAlhkKIcAP +qXIi2/EBb/eKJIMP3QLv9QHYCdngfyCg4HjxwOHFz3WAAHgmIIVgeQLYgOAghQjYCPRAeRB5z3CA +AHQMB/BAeRB5z3CAAFwNqgnP9sIMoAMB2EoIz/1qDwAAKggAAJECz/UIcViJAYACoYjqWYmA4sIg +ogDAIKEAAqHgfuB44H7gePHA9gnP9c92gADIHQCGAeAApgDfFQhRAAHZz3CgAMgcMaA+CKAGKHDH +2JS4z3WgAOwnBqXPcAMAgmwGpc9wAwDCdAalz3ADAEKWBqXG2JC4BqUOCKAGCtjPcAAAgmwGpf4P +YAYK2M9wAADCdAal8g9gBgrYz3AFAEKWBqXiD2AGiiAHDc9wAABClgal0g9gBgrYz3ATAMYABqXG +D2AGMtgAhkIgQIAApgX0z3CgAMgc8aCtAc/14HjxwD4Jz/UId892oACsLxWGMwgeAM9wgADkMgCI +z3WgAOwngeAB2MB4B7hFIAAGELiFIJEABqVKCi/2AdgB2I64BqWI789wgABkJgCAQHhL8BWGUSAA +gMohwQ/KIsEHyiCBDwAAfxnKI4EPAACqAMokwQBIAGH3yiXBAM9wEwDHAM92oADsJwamz3AQAAZp +BqbH2JW4BqbPdYAAyB0AhQHgAKUXCFEAAdnPcKAAyBwxoPYOYAYocM9wAABCLQamz3AAAIJGBqbP +cAAAQmAGpgCFQiBAgAClB/TPcaAAyBwA2BGhxQDP9eB48cBaCM/1z3CAAHAmIIChwWB5BNgy6M92 +gADIHQCGAN0B4AAcRDMAphUIUQAB2c9woADIHDGgig5gBihwi3EOD6/2ANgAhkIgQIAApgX0z3Cg +AMgcsaAAFAExz3WAAHwmhiH/DECFQrlgegLYABQBMUCFA9hgesG5TQDv9aHA4HjxwNIPr/UD2M92 +gABwJiCGz3WAADwyYHmiwQboIIZgeQTYhuhHAyAASBUEEAPYGnDPd6cAFEjPdqAA7CcCDq/9BdgO +pc9wgADIHQCAAeDPcYAAyB0AoRcIUQAB2c9woADIHDGg2g1gBihwA9heDq/2qXEE2FYOr/YibQXY +Tg6v9iRtCthGDq/2Jm0P2D4Or/ZAJQESNtg2Dq/2QCWBEjfYKg6v9kAlARM42CIOr/ZAJYETCIcE +pQ2HBaUOhwalz3CnAJhHHIAHpReHCKUWhwmlz3CrAKD/GIALpc9wqwCg/xmADKXPcKsAoP8agA2l +z3ADAMYDBqbG2JC4BqbPcCwAAgEGps9wWQBCAQamiiCKAAamz3BAAIcNBqbPcNEAwg0Gps9wwAAH +Dgamz3CAAMgdIIARCVEAz3KgAMgcANgRogHYCKcA2A2nDqfPcKcAmEfPclAA/wBcoADYF6cWp/za +z3CrAKD/WKB82lmgGoDPcqsAoP+AuBqiz3CAAMgdIKATCVEAz3GgAMgcAdgRobIMQAbPcEAAhg0G +ps9wEAACDgami3BSDGAEgcE2hQDAIngEKIAPAAB0CRWFN4UCedYPr/UvcAHCT+DPcYAACI8UpVeh +GKHPcEAAhw0Gps9wEQAGDgamz3CAAMgdAIDPcYAAyB1CIECAAKEG9M9xoADIHADYEaGLcPILYASB +wTaFAMAieF4Mb/sSpTKFVYUseDeFLyBADkJ5OWFqD6/1NXnguBx4wCBiAIIgxALPcYAACI8SpROl +FqHPcIAAyB0AgAHCAeBVoc9xgADIHQChEwhRAM9xoADIHAHYEaHWC0AGAZUQuIUghAAGpgKVELiF +IIUABqYDlRC4hSCLAAamBJUQuIUgjwAGpgWVELgFIIAPAACCDQamBpUQuAUggA8AAMINBqYHlRC4 +BSCADwAAAg4Gps9wgADIHQCAz3GAAMgdQiBAgAChBvTPcaAAyBwA2BGhBIUrhQinBYUNpwaFDqcI +hRenCYUWp89wqwCg/zigLIU5oC2FOqBGCK/9DoVIFQQQjCSCgET2jCQ/gQ72IgtgBgrYOg0ABEIg +QCCA4AIFzf9IFQQQjCSCgET2jCQ/gQ32CiHAD+tyz3AAALQZiiNFDAEEL/e4c89wgAD3FQCIB+jP +cIAAnDIAEAQAiHDJBK/1osDgeM9wgAA8MuB/FIDgeM9xAQAoVs9yAQDsTPEFL/oA2OB44H7gePHA +z3CAAGQmAIBAeM9wgABgJgCAQHjRwOB+4HgA2c9wgACECeB/IKDxwBYMj/XPcIAAcCYggKHBYHkE +2IHgkfSuCS/899iB4Iv0ANgAHAQwz3eAAMgdAIcB4ACnFQhRAAHZz3CgAMgcMaA+CmAGKHCLdQDY +vgqv9qlxABQFMahwhiD8A4wgA4wN8gohwA/rcs9wAAC+GYojBAEhAy/3iiSDD892gAB8JkCGhiX8 +DwDYYHpCLYEBQIYB2GB6A9kB2HIKr/apcUCGCNhgegAUATEAFAUxTCUAgMohwg/KIsIHyiCCDwAA +mhnKI4IPAAASAcgCIvfKJGIAAtg6Cq/2qXFAhgTYYHoAFAExEtgmCq/2qXFAhgXYYHoAFAExABQF +MUwlwIDMJSKByiHCD8oiwgfKIIIPAACcGcojgg8AABkBeAIi98okYgAAh0IgQIAApxb0z3GgAMgc +ANgRoRDwz3WAAHwmQIUB2GB6A9lAhQTYYHoIcUCFBdhgegTZKQOv9aHA4HjxwL4Kj/XPdYAAyB0A +hQHgAKUA3hUIUQAB2c9woADIHDGgAglgBihwz3CAAAYhz3GgAOwnBqHPcIAARjoGoc9wgADGUwah +z3CAAMYkBqHPcIAABj4Goc9wgACGVwahAIVCIECAAKUG9M9woADIHNGgz3CnAIhJ0KCxAo/1CNnP +cIAAHMzgfyOg8cA2Co/1z3aAAMgdAIYB4ACmAN0VCFEAAdnPcKAAyBwxoHoIYAYocM9wAADCLM9x +oADsJwahz3AAAAJGBqHPcAAAwl8GoQCGQiBAgACmBvTPcKAAyByxoEkCj/XxwAIML/gW2BYNAATP +cYAAXB8AgcQQAAYPCF8BAYHEEAAGDQheAfILb/gT2M9wgABYJiCAYHkL2NHA4H7xwEoP7/uKIIgF +Duj2D+/8ANjPcIAAcCYggGB5BNiA4GAOAv/RwOB+z3CAAFwfA4AIgM9xgAAczAkIHgABiQPwAong +fwCp4HjxwLhxjegKIcAP63LPcAAApxmKI8QLuQAv94okgw/PcYAAHMwggUwlAIAEIYEPAAcAAEEp +AwYA2cokTXHoIG0D8CBFAAQlgg8BAADALrplegsLgQAB4dHA4H4KIcAP63LPcAAAqBmKIwQOZQAv +90okQADgePHA4cUA3c9wgAC8CKYIIACgoM9wpwAUSKigPQGP9eB48cChwbhwANhAwFMlgAAnCFAA +RQiQAE8IEAEKIcAP63LPcAAAqxmKI4oKEQAv94okgw/PcIAAeCYggGB5AdiE4AHZwHnPcAAAItI0 +eM9xgQATGw/wz3AAACPSz3GBABYbB/DPcAAAJNLPcYEAGRsp2hK68CIAAA4ggg8AAQAAQMKLcJoP +oAMD2qHA0cDgfuB48cAqCI/1A8iUEAAAz3aAAMgdBCCQDwEAAMAAhkEokCMB4ACmAN0XCFEAAdnP +cKAAyBwxoGIOIAYocM9xJAAHAc9woADsJyagiiGFACagUyCBICsJUABlCZAAgQkQAQohwA/rcs9w +AACIGYojBgOKJIMPOQfv9golAATPcYAAXB8jgSiBUSEAgMohgg+AAMcgyiGBD4AAhyQmoM9xBADH +MSagAIZCIECAAKYG9M9woADIHLGg2QdP9c9xgABcHyOBKIFRIQCAyiGCD4AABzrKIYEPgADHPeLx +z3GAAFwfI4EogVEhAIDKIYIPgACHU8ohgQ+AAEdX0vHxwM9xgABcHyOBLygBACiBwLkAIYMPAAAi +0k4ggQcp2BK48CDAAM9zgAD0vXiLz3KBABMbocFAwIbrAiCADwAAAMBAwItwNHlZYUoOoAMD2qHA +0cDgfuB48cDiDm/1uHDPcCwABgHPc6AA7CcGo89yqwCg/xqCUyWNAADZJQ1QEGkNkBCpDRARCiHA +D+tyz3AAAIEZiiOFAxkG7/aKJIMPz3WAAFwfo4Wohc92AgCCAlElAJDKJYIfgADGIMolgR+AAIYk +pqPGo891BADGMaajz3VIAEIBpqPPc6cAFEg3o4C4GqLBBk/1z3GAAFwfI4Eogc91AgCCAlEhAIDK +IYIPgAAGOsohgQ+AAMY9JqOmo89xBADGMSajz3FKAEIBJqMB289xpwAUSHeh3PHPdYAAXB+jhaiF +z3YCAIICUSUAkMolgh+AAIZTyiWBH4AARlemo8ajz3UEAMYxpqPPdUwAQgG78fHA0g1P9QPIAd3P +dqcAFEiUEAAAqKYEIIAPAQAAwNoO7/8uuP/Ym7jPcqcAmEccos9xgAC8CACBAN+A4Mohwg/KIsIH +yiCCDwAArBnKI4IPAACyAMokwgP0BOL2yiXCA/amuqLVBW/1oKHgePHAYg1P9c9wpgCcPxmArQge +AM92gADICACGRoCgEgAGLygBAE4ggQdBKdAAEQjVIEhwgCAKADIgAASQ6AohwA/rcs9wAACtGYoj +SwKKJIMPkQTv9golAATPdYEACBtAJcAS2gwv9wnZANguCq//DyAABIDgANgPIAAEBfQuDM//A/Cy +Dc//A8i5EIAAG3iAuECGCq0mgpYhQQMAIQAEGIiMIMOPAnEF8mG4D3gYqSaCoBEABp8ZGADSC8// +CQVP9c9xKgAVAM9wgAAgPeB/IKDxwI4MT/U6cBt9z3CmAJw/ZBAQAC0IHyC+Da/1A9hhvYwl/5/z +9QohwA/rcs9wAACkKFHbCiRABNkD7/YKJQAErQRP9fHATgxP9c9xoACsLzqBUiEBAFEhAIChwQDe +lvTPdYAAyB2zCBAAOgqP/893gABwJiCHYHnJcBMIEAMgh2B5yXAghVkIEQQAhQHgAKUVCFEAAdnP +cKAAyBwxoGIKIAYocItx5gpv9oogBwUAhUIgQIAApQb0z3CgAMgc0aAAFAUxVw3QAAohwA/rcs9w +AACJGerbPQPv9phzAeEgpRUJUQAB2c9woADIHDGgEgogBihwz3EGAAJ1z3CgAOwnJqAAhUIgQIAA +pQn0z3CgAMgc0aAD8OYIAAAAhQHgAKUVCFEAAdnPcKAAyBwxoNIJIAYocM9wgABcHwOAz3GAAOQy +OBAQACCJz3egAOwnQSiAI4HhwLgB2QS4wHmDuAe5JXgQuIUgkQAGp24Mr/UB2E8gACAGpwCFQiBA +gAClBvTPcKAAyBzRoG0Db/WhwOB48cBqCAAAz3CAAHAmIIBgeQPYgOCADsIDz3CAAKglBIAZCJ4A +z3GAAFwfTYE+kVMiAAAyDeABAdvRwOB+8cDhxc91gAA0MgCFGwgfANoJQAN+DU/7agjP+AoOz/8A +hYC4AKUdA0/14HjxwE4I7/uKIAQCEehWDo//xg/P/89wgABwJiCAYHkE2AXoIgiP/w4IAADRwOB+ +4HjxwHIKT/XPdYAANDIAhTkIXwDPcIAAcCYggGB5BNgU6P4Pr/vi2BDorghv/QfYxgrgAwh2qg8P +/6oNL/3JcACFgbgApZkCT/XgfuB48cDhxQh1mHFIcGhxANoOCCAAqXOFAk/18cAKCm/1+HBZJBw4 +2HEZcrhziiQEcADZqCCAAQAkQDAgqAHhANuKJARwaHBocaggwAUyJMIwACTPMB1iMidAAAHh0HG4 +YA94yiEmADIkDTAAJA4wAeOgr0CuANkrCHQQKHIB4S95MiRNMEIgSBAAJEMwumJPejIkjjAAJIAw +wKvjCHWQoKhMJACAyiQNceggLQcB4S95MiRAMAAkQzAaYk96MiSOMAAkjTDAqwCtMiRDMHhgD3gy +JAMwABWAAGd4AR0SAK0Bb/VWJBw48cA+CU/1pBABABUJHga2EAEBz3CgAJgDPqCe8AAWDUG8sAAW +AkFdsAAWDkDPoAAWAkFAGIQAABYCQFGgABYCQUgYhABEJQITNQoQARjbchjEAAAWA0BzoAAWA0FQ +GMQAABYDQVQYxAARChECqXOGI/MPjCMMgA7yGNsW8BDbchjEAADfz3OAADzN57MQ2wzwHttyGMQA +ABYPQPagABYPQVwYxAOpd4Yn/RyMJwKSCfQC43B7chjEAAAWD0EC8ADfYBjEAwkLXgAAFg9BKHSE +JAyQBPQA2iLwmepRJgCQ0SEighXy0Iiouc9ygQAQDqQYQAACvtZ+wmILCp4Hi7mkGEAAANpaoFug +5vEAFgJAWqAAFgJAW6AI2nQQDgG+EA8Bwn9if0J/uBCCAJi5pBhAAM9xoACYA0J/emJQenIYhAC6 +EAIB8H9wGMQDpXpcsD6BthhEAFEAT/XxwOYPL/VKJEB1z3WAACgZwIXPc4AAxBGoIEAGaHAybjR5 +OmBCggHmOGAN6s9xoAAsIDCBInrXcklrANIA38P34qCq5somJhDgeAUAb/XApfHAz3CAAEwQDtkB +2oIKIAAA289wgACEEAnZAdpyCiAASHPPcIAAeA8q2QDaYgogAADbz3CAACAQC9kA2lIKIAAB29HA +4H7gePHABNh6CW/7AdnPcIAA0TIAiM9xgADSMjILIAAgidHA4H7geM9wgAA4P4UDAATgePHAhuju +CAAAANkioNHA4H7xwBIPD/VWDo/7z3aAAIgJZtgibgHadg9v/Ehzi+gKIcAP63LPcAAAthTZ24ok +gQk58AIWBRFMJQCAzCWCjwAA//8N9AohwA/rcs9wAAC3FNzbOQav9ookgQln2MlxAdoqD2/8SHOM +6AohwA/rcs9wAAC4FN/biiTBCRXwAZYkbgHaAeAQeAYPb/xIc6GWj+gKIcAP63LPcAAAuRTi20Al +RBDpBa/2SiUAAAJtEHgmbgHa2g5v/EhzjOgKIcAP63Khls9wAAC6FOXbQCWEEOvxrQYP9c9xoABg +HRKxFJHgfvHAuHE1CFEACQ1SABkN0gMKIcAP63Kn2AW4nNuNBa/2SiQAAEAtgAAUeEIgAQPPcIAA +5BAZYR/wz3CAAPQUMiBAAYwgw4/KIcEPyiLBB8oggQ8AAOEUyiOBDwAAogBMBaH2yiQhAAK4FHgA +IIEPgADEEShw0cDgfhEIHgIEIL6PAAAAGAHYA/QA2OB/AKngePHAog0P9c91gAD2CACNz3aAAPQI +Xg/v/yCOQYjPcYAA2DJfCt8AAoCp6F8KHgHPcoAAiCIAlmeKTwjBAACVYYpHCMEAz3CAAPgIAIhG +ijsKAQDPcIAAXB8OgC8IXgHPcIAA1DJAgAvqz3CgACwgEIBCeA8IhA8xAQAtANgC8AHYjQUv9QCp +z3CAAMwdAIh36Pfx4HjxwPIMD/WhwRpwOnJodr0JcgAA2JpxFSANIM9xgACICQAVkxACFZIQunDj +jSGRAY0B2jhgEHiLcU4Nb/xIcxLoABQAMUAqgiAEIIEPAAAA/0e5VHozCRAgx3KAAOQQGPDPcIAA +iAnBkKGNCiHAD+tyz3AAALsUiiOEAAAmRBMJBK/2CiVABcdygADEEQAawgQD7gKqAvABqiUIHgAM +7gOKgLgDqhJvFHgbYmOLWGCBu2Oo5KoD7iaqAvAlqkIkQSBVCXWAQCVAIHkEL/WhwOB44cVTIA0A +oKkEIIEPAAYAAEIhAYAEIIAPQAAAAMohYgAgqtdwQAAAAAHYwHgAq+B/wcXgePHAjOjWDc//z3Gg +ACwgMIHHcUlrANIioNHA4H7xwO4LL/XYcQomgJCIdcwjIoAG8kImBgEvJocBog3v/8hxz3GAACAJ +AKEl7iSIArk0eUOIA+ECEIUAIwofAAohwA/rcs9wAADiFIojiAVKJAAAFQOv9golgAEIYRsIXwAK +IcAP63LPcAAA4xSKI4gG7/EBEIUAUSUAgMohwQ/KIIEPAADkFMojgQ8AACgCyiLBB9/z4b3RJSKB +yiHCD8oiwgfKIIIPAADlFMojgg8AAC8CtAKi9sokggErDR4QUSXAgMohwQ/KIsEHyiCBDwAA5hTK +I4EPAAA2AowCofbKJIEBeQMP9eB48cD6Cg/1ocEIdyh1GnIA3s9woAC0D3AQEQCKDeACyXCLcUAk +QjBAJIMwog7v/6lwDwgQIM9wgACkmAGIBOhKJAAABPBKJIAAIMABFIIw6XHKDu//AhSDMM9wgADS +MgCIgODMJwKQC/LPcIAAIAkAgMKgz3CAANAywKgxDV4Rz3GAAIgiB4klDwEQAYlTJQIQGQoBAAQl +jR8ABgAAgOUB2gaJwHodCgAAz3CAAM0dwKjPcIAA1DLAoM9wgADYMsCo4gzgAi8gRwSRAi/1ocDg +ePHATgrP/89wgAD0CACQgOCEDML/0cDgfuB+4HjxwAoLz/9+Cs//Gg1ABXYMj/xSCEAB0cDgfuB4 +4H7gePHAz3CAANgyAIiN6E4Mz/+J6JDZA8iQuaAYQAAA2NHA4H7PcIAAJBkAiBHoz3CgAAAEDIiM +IAKAANkJ9JHaA8iQuqAYgAAocOvxAdjp8eB4z3GAAFwf8CEBACgRgAAogZUG7/8A2uB48cDhxdhw +z3KAAIgiz3WAAPQIAJVnis9xgADMHSsLAQDPcIAA9ggAkGGKHwsBAM9wgAD4CACIRooPCgEAz3CA +AM0dAIgC8ADYqgvv/wCpz3CAAPgIQIjPcYAA9ggAiSCNgOIB2sB6yHMA3T4N7/+Ydc9wgAAgCQCA +AYjPcYAAJBkLCB4BAdgAqQLwoKl5AQ/1z3GAAIgiz3CAAPQIAJBHiTEKAQDPcIAA9ggAkEGJJQoB +AM9wgAD4CACIJokVCQEAz3CAAMwdIIjPcIAAzR0gqOB+4HjxwLoID/XPdoAAaJoUjikIUQAE2NYK +L/sB2c9wgAD2CACIz3GAAPQIjgzv/yCJANgUri3wto4r7c93gADQMgCPYbglDQAQTgnP/89wgQB4 +FgWAIW0FKH4Az3CAADg/Lg3gAy9xz3CAAPYIIJDPcIAA0TKgryCoz3CAAPQIIJDPcIAA0jIgqADY +Fq41jgnpz3CAAPYICgnv/wCIANgVroUAL/UB2M9woAAsIDCAz3CAANQy4H8goOB48cD2D8/0ocEI +dhpxOnIA3c9woAC0D3AQEgCKCuACqXAFhuOOi3FAJIMwogvv/0AkQjAKhhoK7/9AJEEwJw9UEBQh +TCMgjCDAARSCMAIUgzDwIE4jxgvv/1MmBBAB5eUNxJNCCuACLyCHBOkH7/ShwPHAYg3P/+oJQAXR +wOB+4HjxwOHFz3CAAIDLANkloM9wgAAkKyKgz3GAAFwfAIHEEAAGdwheAQOBGIhvCBABz3WAAKg7 +AIVCIACAyiBiACcIUQCiC+ADqXDPcYAAcDsAgUIgAIDKIGIAhegocPYL4AMihc91gADEOwCFQiAA +gMogYgAnCFEAbgvgA6lwz3GAAIw7AIFCIACAyiBiAIXoKHDCC+ADIoVlB8/04HjhxQDbz3KAACzM +FCINAGC1aLUaYiAawgDAHcQQKBrCAM9xgADYyxZ5IpEwGsIA0B3EEIAd3BB4HUQQAdmIGkIAz3GA +AMzMFXlgoeAdxBDwHcQQ4H/BxeB48cAeCi/8Edi56M9xgACIIs9wgAD0CACQR4lVCgEAz3CAAPYI +AJBBiUUKAQDPcIAA+AgAiCaJOQkBAM9wgABUJgCAmujuC8ACiOgLyAUggA8AAAA8CxoYMN4LwAKI +6AvIBSCADwAAANQLGhgwC8iQuAsaGDDmDU/7A/ACC8/10cDgfuB4ANmcuc9woACsLz2g4H7geHEC +T/shAK/3FdjgeOB+4HihwfHA4cWswQDZSsFvIUMASMHPc4AAHMwggwQgjQ8BAADAhiH+AyS5DrkL +JUCQTsCOwhby13UAAABAzCWCnwAAAIDMJYKfAQAAAAT0IYMD8CKDrrivuLC4BXkgog7DCMCLdQQj +gQ8BAADALrlAKQIGRXhIwIogBgZJwEHDqXAA2koJIAAB289xgAAgFxqBO4EkeCcIHgIKwAvBhCgE +DgAhgH+BAJgYArkI4DR5IWDPcKcAiEkvoM4PIASpcAjcpwXv9KzAocHxwCYN7/QIcq3BCNhKwG8g +QwBJwM9wgAAczKCABCGODwEAAMCGJf4TJL0OvQsmQJNQwZDDFvLXdgAAAEDMJoKfAAAAgMwmgp8B +AAAABPQBgAPwAoCuua+5sLkleACjEMMJxQQjgQ8BAADALrlAKQAGBX1JxR8KngEKwAQjvo8AAAAY +RSDAAErABfKFIBABSsAlCh4Bm73PcKAALCAFgADbArhuuIDgyiDMAMm4pXhJwAbwCQoeAp29ScUQ +wIHFQsCpcEIIIAAC2wPIDMLPcYAAIBe5GIIAGoE7gSR4GwgeAgK6z3CBAKAYVHpBYM9wpwCISS+g +yg4gBKlwCNybBO/0rcDxwCIMz/SjwWGACHVAwwDYCqVtC14CBCOADwEAAMAuuM9ygAAYTgpiSSKC +AGG6S6USahR4x3CBAJAZyoDPd4AAtM3GpQuAz3aAAFwfBaXDhiDA1Ib1jwR+5H4JvkApDwLlfsV4 +BCODDwAAABBleAelCIUY4p64CKVLpY/wNwqeAs9wgABgPQCAQcBCwCEIHgKGIP8JI7gB4BUIlAAL +CJEABthhwCTwB9hhwCLwIsBhwB7wQcPPcoAAyAhAgkaCnhICBisKkQEEI76PAAAAGA/0z3KAAFwf +RIJIggQivo8ABgAABfIB2AqlA/AKpQDYAcZBDh4SQsYiwqDiyiIhAAQmjx8BAADAQS+EE0QmDxYj +vwHnBCaOHwYAAAAxvgAmxRPPdoAAGE4yJg4RAiZOERPwUybCEM93gAAEUV16SmcEJo4fAQAAwC6+ +z3eAABhOzmdhvtZ6S6UTCx4CIMfPdoAAIE7uZgLwAd6EKAQOACGAf4EAmBgCulR6R2Bhvlhg5qUB +gAQjgw8vAADdJrvFe1IjwwMFpWelz3CAABzMA4AA3x0ITgDPcIAAgD0AgBUIHgCGIH8PHXhAKM8D +BPAA34+/m+/PdoAAcCYghmB5ANglCBADIIZgeQDYGQgQBCCGYHkA2BEIUAQghmB5ANgLCJEEmghv +/ADYCIUFf+iljQLv9KPA4HjxwCIKz/TPdYAAkCYAhcSQyXDyCKAAhiD8AwCFyXGGCWAAhiH8A89z +gAD4zQsIkQYhg4C5IaNKgwHiSqPPc6AAxCeREwGGw7kbCYEAiiUIEBMbWIOREwGGw7kLCYAAEhtY +gy0Cz/TgePHAsgnv9ADYz3GgAMQnUhEChhURAoZCEQOGEQueBwHYz3GAAHzNYbFRIsCAGnDKJWIU +EvRRIMDGyiWiFAz0z3CgANAPIBABhh8QAIYQcQDdyiViFekNERDPdoAAfM0fhssIHgSoFgEQlNie +CmACyXLPd6AA0A9RCBAgz3CAADgJIIDPcKAA/CXPcoAAEMuM6TOACoIZYSqiz3IA/wCqiiCIBQzw +E4AkkhlhMHkksoogiAXPcgD/AP9uC0/9AJZmCK/9NJaUFwAQz3KAAEg2AdkZ6G2CAeNtomuCeGAL +os9wgADMHSCoH4YPCJ4Dz3CAAKgIIKAH8A8I3gPPcIAArAggoM9woAD8JROAbIJ4YAyiz3IAoAgA +7HBAoG8iQwDscECgDh9YkNIPQAXPcAAA/3/PcaAADCQBoRvYBKHZAO/0qXDgeOB/A9jxwOHFocFO +CW/7i3Cy6AAUBTAdDR4AfggAAM9xgAB8zUOBz3GAAPidQaEk8AsNngCKDs//HvANDV4CGg7P/xrw +Ow3eAAjYz3WgAMQnEx0YkKYNwAAdCBAFAtg8HQCQz3CAAHzNI4DPcIAA+J0hoBnYlwhQhnEA7/Sh +wAohwA/rchfYjLiKI8cAYQcv9ookgw/xwOHFz3CAAHzNP4AEIYEP//+POAQlgF8AAHDHJXjPcYAA +fM0foUQiAFPPdYAAfM1DCBECPw1eUTYPz/+cHQAQEw2eU89wgACwHwWImB0CEBTwFQ3eU89wgADA +IhmImB0CEAzwA4VWDi/2JIWYHQIQBPAA2JwdABCcFQAQgODMIOKAXvLPcKAAqCAIgB+FEQgfAQ0N +31KA2JgdAhCYFYAQQCgBBhEI3wGCuR8KnlNGDQACG/AfhVEigNOzuB+lxSGCDwAAAAdFIQAGz3GA +AAjOLImGIf0PUiHBAUW5JXjPcaAAiCQQoYog1gDPcaAAxCd+GRiAz3CgANQLAdpSoATYEBkYgM91 +gAB8zR+FRwieARSVQwhfAc9woAAsIA+Am+itcdoIb/lWJUAVgBUAEJS4gB0AEB+FkLgfpQ3wz3GA +AMw1D4EB4A+hENnPcKAAkCM9oAUHr/QZ2PHAgg6v9ADZCHYBgMG4g+DKIEEgBfIiDiAAyXAacEwg +AKDE9BCGUSCAgcDyEIbPdYAAfM0PCJ4Dz3CAALAfBYgN8BCGDwjeA89wgADAIhmIBfAFhiaGDg0P +9pgdAhCAFQAQBCC+jxBwAAAH9K1xNghv+VYlQBURhs9xgABkCQChQSgBA1MhxQCYFYEQQSgGBRRp +BSBEAQ8J3gEehZW4HqV58JoOL/tPJEAC6wgVBM9xgAAklJgVgxDwIQEAQCsCBoYj/Q9SI8MBRbtl +es9zoADEJ0EbmIAA2oy6AiZPAPpiy7rXcgAAAAhALQ8DkL9S9wUnjxFiG9iDjCICgMf3z3GAAEA3 +EoEB4BKhANmduUXw5XliG1iAWQ6FcAAAwA8OIoMPAAAAEM9ygACEkxZ6IIIlCzUIBBIFAADYDyDA +AGG4TiMPCAEpwgN4eQV5AC3AAAV6F/BCIwMIANgPIMAAYbh4eQUhAgCKIf8PC/DPc4AAQDcTg4oh +/w8ocgHgE6MB2M9zgABEsgCrAhsEASGjQqO98QDZnLmAFQAQJXiAHQAQQCYAEqAdABAC2c9woAD0 +JiOgJYbPcIAA+J0hoCkFr/QKcOB48cC2DI/0CHVVIFAEDcyiwe240SBigAfyBMjCDq//mBAAAM9w +gAD4zQyAz3GgAMgfZOAeoRDYDqEB2BUZGIABhYPo/wsewAGFwbiD4Nb0ABAAIEHABBQPMRCFLL8G +FBIxdQieAQ3MdQjeAhCFz3aAAHzNEQieA89wgACwHwWIDvAQhREI3gPPcIAAwCIZiAbwBYUmhQoL +D/bnuJgeAhDKJmEQBvI+hpW5PqYA3gS4z3GAAIy0RpHleBMIgADPcoAAQDcJggDeAeAJogSRGwiB +DwAA//8A3gnwz3GAAMw1DYEA3gHgDaEBlZzgiPQEEBEgCBAQIM9woAD0JgLZI6Ajhc9wgAD4nSGg +agsgAKlwgOCA9Cbuz3KgAMQsHBpABM9xgAAIziAaAAQsiUAvAxMQuZ+5JXtBKgEhZXkmog0SATcd +Cd4CENqruQwanDANGlwwz3KAAMQ2J4IB4SeiDRIBNw0JHgMa2Ky5DRpcMKUOEBDPdoAAEIzgFgMQ +RYVEKz4HACZBHkChTJUB40Kxz3KAAAjOrIrgHsAQz3KAAIy0qKnpqQoZhAQMGUAERJIQGQAEEL0M +v0EqAyHlfWV9SrHPc6AAwC9HG1iDlOLAIoYPAACTAM91oABoLPAlghBLsY8TAoYJ8KMTAoZRIgCB +jxMChgb09QregQfwCNgM8Oe6yiIhAEDCARSDMMa6xrt4qVmpAQOv9KLA4HjxwOHFz3GAAFwfI4FI +gVkKHgCGIP8Bz3KAABhOQ7gKYgDbgOLKIcEPyiLBB8og4QfPICEDyiOBDwAAbwDKJMEA5AEh9sol +IQDPcKoADFATCrQAuYGAvbmhAdkloATwoL25oWWgvQKP9PHARgqP9Ah1DcxTIECAB/IEyEoMr/+Y +EAAAAYXBuIPgyiYhEAXyzgkgAKlwCHaxDhEQEIUJCJ8BANlF8AzMeQjeAA3MUyBAgA0SAjYd9AAi +gA+AALTMAdnPdoAAlDQgqBGOUSAAgFAN4gPKIEIAEY4XCF4Bz3CAAOQyA4iA4CAP4QHKICEBENgM +Ghwwz3GAAEg2F4EB4BehA8gNEgE2hBACAc9wgACozDV4KYBZYSmgGt7E8c9xgADMNQ2BAeANoQHZ +z3CAAMwdAdpAqM9wgAD4zU6ABoIB4AaiA/AB2QLaz3CgAPQmQ6BDhc9wgAD4nYDhQaBcCAIDuQGv +9Mlw4HjPc4AAfM1YE4EAANqO6TyTYrkQuUUhQwHPcaAA9CZjoc9xgAD4nUGhyQAAAPHAGgmP9Ah2 +AYDBuIPgAN0F8rYIIADJcAh1se0QhkcIngEMzM9xgABQNTEIXgFA2AwaHDBVEQAGANoB4FUZGAAN +yM9xgAAszBR5A8hAqeIKr/+YEAAAB/CsEQAAAeCsGQAAz3CAAMwdAdkgqM9wgAD4zS6ABoEB4Aah +AtnPcKAA9CYjoCOGz3CAAPidIaD5AK/0qXDgfwjY8cAkuVMhwgDPcYAAxFNWeRMKEAJBkGGBBOJw +csogIgID9CCBQHnRwOB+4HjPcYAA+M0sgc9yoADIH2ThPqIQ2S6iAdkVGliAIYCE6f0LHsAhgMG5 +IQnRAM9wgADMHQHZIKjPcIAA+M0ugAaBAeAGoQDZDfAhgFEhAIAA2coh4QUBgFEgQIDKIaEE4H8o +cOB48cDyD0/0z3aAAPjNAYYEIL6PAHAAADnyLykBAM9wgAAcM/QgTQArhk8lgBASCSACSYaU6Iwl +A5DPcYAAUDUI9LoRAAYB4LoZGAAf8LkRAAYB4LkZGAAZ8AGGIQieB89xgACUNAyJT4kbCgAAEYlR +IMCAOA9BAgfwANnPcIAARLIgqK4OAAXZB0/04HjxwGIPT/QIdgGAwbgA3ycI0QDPdYAAfM2PDxEQ +EIZ3CJ4BEIYZCJ4Dz3CAALAfBYgS8OIO7//JcAh37fEQhhEI3gPPcIAAwCIZiAbwBYYmhu4Nz/WY +HQIQEQjeAR6FlbgepR+Fl7gfpYAVABAEIL6PEHAAAA/0nLiAHQAQMIYCCS/5ViVAFUAmABKgHQAQ +ANgFtgHZz3CAAMwdIKi0FQEQBoEB4AahWBWAEJnoMg3P+gXoEIbtuAHYAvQA2M9xgADezfQhAAA8 +lThgYrgQuIC4z3GgAPQmA6EG8ALZz3CgAPQmI6Alhs9wgAD4nSGg3QZv9Olw8cBqDm/0ANkIdgGA +wbiD4MogQSAF8goO7//JcBpwz3CgACwgBoAQeEwgAKDPdYAAfM3KJyIQVvQwhmUJngE8lRMJAwAl +hs9wgAD4nQKAtwkBABCGDwieA89wgACwHwWIDfAQhg8I3gPPcIAAwCIZiAXwBYYmhtYMz/WYHQIQ +gBUAEAQgvo8QcAAACvReDM/6C+gQhhMIXgMB3wjwAN8Y8HIOj/sU8ADfMIbiD+/4ViVAFYAVABCo +FQEQnriAHQAQQCYAEqAdABDZCV6CAdnPcIAAzB0gqLQVARAGgQHgBqFYFYEQz3CgAPQmk+nPcYAA +3s1clfQhwQNZYWK5ELmAuQjwtBUBEAuBAeALocjxAtkjoCWGz3CAAPidIaCxBW/0CnDgePHATg1P +9M9woACoIAiAz3aAAHzNDw2eU89wgACwHwWIDPARDd5Tz3CAAMAiGYgG8AOG9gvv9SSGmB4CEB+G +FQgfARENX1MNDV9SgNiYHgIQmBaAEBcI3gE/hpe5P6Y+hpW5PqYA2QHdFvCcFgEQJQlRAD+GUSFA +gs9xgABcHyOBKYEF8kQhDQQF8EQhDQID8AHdBNkYuCV4z3GgAIgkEKEfhjMIngEUlisIXwHGCkAC +kejPcKAALCAPgAXoDcwXCN4BH4aQuB+mrXGeDu/4ViZAFZvtCwqeU4YKwAEV8IYi/9zPcYAAfM0P +9AGBGwgeAJgRgADPcYEAEA4CuBZ4AGH+uIwJQvvPcKAAUAwggM9wgACkCQTaIKDPcKAAkCNdoM9y +gAB8zR+CDQjfBA+CgOAA2CnyF4KKEgIBGWEE4gsIn0T/CR7Gz3WAAHzNmBWAEOe4ANsJ9AK4z3OB +ABAOFngDYy27wLuKFQARTxWNEM92gABcH/AmwxBCeaJ4Yg8v+0+TOQRP9OB48cDhxaHBANhAwM9x +gADMNQ+BAeAPoQPZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgENjP +daAAxCcQHRiQWgzv+otwlugAFAUwHQ2fAAohwA/rcg3YjLiKI18H0QLv9Yokgw8E2RMdWJAb2RYd +WJC5A2/0ocDgePHAz3CAAHixBgsv9hjZz3CAAPSP+gov9hjZ0cDgfuB48cAWC0/0GnDPdaAA1AsQ +hQDeocFAxiEIUAAKIcAP63IP2Iy4iiOWCIokgw9pAu/1CiUABM9xoAD8RBmBBCC+jwAACCAC9B2B +EQjQJLIL7/qLcIDgyiACIEIgwSCU4UoBDQAyJkFwgAAAQEAngHI0eAB4z3CAAPjNLoAIgQHgCKHS +CsAAANkocDzwz3CAAPjNLoAHgQHgB6H28c9wgAD4zS6ADIEB4Ayh7vHPcIAA+M0ugAKBAeACoSLw +z3GAAEg2BYEB4AWhHPDPcIAA+M0ugAOBAeADoQHZANgU8M9xgABANxqBAeAaoaYNoAMB2Mrxz3GA +AEA3FIEB4BShAdgIcYDhNAmCAM9wgAB8zR+AFwjeBM9wgAA4k8uoz3CAAGyQzLAD2BGl4HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgRpTECb/ShwM9xnwC4/xiBkLgYoRiBsLgYoc9wgAD4 +zS6ABYEB4E4IIAAFocbxz3CAAPjNLoAEgQHgOgggAAShvPHPcIAA+M0ugBGBAeARobTxz3GAAEg2 +DoEB4A6hmfEKIcAP63JB2Iy4iiPYBzrx4HjxwGIJT/TPcIAA+M0MgM91oADIHxDeAd9k4B6lzqUV +HdiTgg/gBAnYA9gepc6lFR3Yk89woAAMJAeABOj3Cx7AiQFP9PHA4cXPcYAAXB8jgSmBUSFAgMog +ogAn9ES4z3GAAAwzw7gJYQkJHgA1DZ9RNQleAM91gABcHwOFGIghCFAAXg+P+gjoz3CAAKQiCIgN +CNABA4UYiA0IkQAJDZ5RAdgD8ADYNQFP9OB48cCuCE/0RCIRU013hif8E01wBCKQXwAAAEAEJYBf +AAAAIEEofoMF8goPj/qD6ADeAvAB3s91gAB8zR+FCQheBADdvPD9CRGg6g6P+h7oz3CAAKQiCIiH +4MwgYoIW9AGFjCD/jxL0JJXPcAAA//8dCQEABYWMIP+PCPQMlddwAAD//8olYRCa8s9wgABcH/Ag +gAMpgA0JXgHPcYAAwE4F8M9xgADMThiICmFBLwARz3GAANhOCGEUes9wgABEVE5gKw4eEB+FCHSE +JAmQD/TkvtEgIoIf8gGFjCD/jxv0BJUzCIEPAAD//wrwDQ5eEB+FIwieAgkOnhAJDR5SAd0M8BMO +3hDPcKAADCQRgIwg/4/28wDd5r7KJSIQGg6P+gjoBCW+3wAAACLKJWIQjQ0QEBUO3hERCBEgz3GA +AHzNH4GTuB+hEQ5eEc9xgAB8zR+BjbgfoYwnApAO9M9xgAB8zQGBjCD/jwf0BJENCIAPAAD//wDd +jCcCkMwngp8AAFAAB/TPcYAAfM0fgZO4H6HPcIAAXB8CgMIQAAYQ6IwnApDMJ4KfAABQAAj0z3KA +AHzNL4IC3SV4D6JVBy/0qXDgePHA6g4v9IDbosEA3c9xgAB8zb6hv6Ggsa+hTxlCA4AZQAOMGUQD +mBnCAIQZQAPPcqAAyB+kEgAA+BIOAKwZQANCGUQDwniwGQAAz3CAAIyMuaDPcIAANM6goATez3CA +AGQJwKCZEYAAoLiZGQIAz3CgAMQnZBhYg892AAD/fxMYmIMb3hYYmIMaGFiDiif/H892oAD8RP2m ++aaKJ5gdz3agAFAM4qZxonCiPBhAg4ojGAhuooASAwCkGUADUSNAgM9zgAD4nVgZQgMM8kIQAIYE +IL6PAMAAAATyAYMC6AKjoaOAGkADz3OAAFA1z3CAAFwfQ4ApCZ5DH4GLuB+hVSPABbQZAAAK2Byx +G5KWGQQABtnPcKAAyBwpoAvwQCMAA7QZAAAQ2ByxGpKWGQQAz3GgANQLEIEfCFEACiHAD+tyC9iM +uIoj1QCKJIMPJQWv9bhzAd2woVEgQMZsAiEAyiXhEM93gAB8zbQXARAAgQHgAKH62J4Jb/sA2SDY +z3aAAFTOpg9gAwCmAdjPcqAAyB8Tos9xgADQHQiBAIBsgWCDJIFAJhAVABEEAPgSAgAA2QIggIAB +pgDYAyNDAFAfBBBSHwQQVB8EEAIkgQDPcIAAXB9ipkOAI6YUks9xpQAIDAm2CILAuAi2ABEEAFMk +RQFTJEEATB9CEYPhyiHBD8oiwQfKIGEFyiOBDwAAnAtkBKH1zyAhAwQkgQ8AAADgLbl/h5ofQhAU +HgARHQveAgS5gbkleAi2B9gH8ADZFSAMICCkA/AE2AHg8wgUggiC67jcCoIFH4cruFMgBQBRIIDF +pvLPcYAAqCUGgQHgD3gGoUEpgEPPcYAAqCVmgc9xoAC0DzeBwLgwcwDam/TPcaAAqCAmgYwhg44m +AQ0AsHCN9M91gABUzgWFz3akAJBB9YY2hgQggA8AAADgLbjnpc9zgAB8zSilDQgeAFAbxAMJ8FAb +hAAEJ48f//8AAOelDwheADC/UhvEAwXwUhuEAPB/56UNCJ4AVBtEAAnwVBuEAAQhgQ///wAAKKUN +hgalBCCADwAAAP4puFYbBAAfg0cI3gLPcKoAAAQEgAmlz3CAAPSPIIhEaDXpYQl0AAIQhACfcQDY +qCCAA/QiDwAV3hO+8CbPE892gABUzRV+AeDgphzwz3CAAHixIIhEaBnpAhCEAIDhyiRNcMogLQDo +IK0D9CIPACneEr7wJs8Tz3aAAFTNFX4B4OCmIa0CHQIRtBMBAALdAYEB4AGhDPAEIL7PYAAAAAP0 +BN0E8AkLHkAD3YHlTvMvDZEQAt0EIL7PgAEAAMolohEG9FEjAMDKJeIQ6w2QkM9woAAwEAOAgODK +JWIRhuUyBAIAz3aAAHzNHJZCIIQAH4bruC8kCAF78s9xqgAABKKBz3ClAAgMAIAEJYMfAAAA/yi7 +BCCADwAAAOCJuxt6ZXrPc4AAVM5SpqyjTaMAgUgWjxCU5wqjGfIG9jMPkRIjuA7wHQ/QHe7nE/RF +KP4CQSnAcFElwJHCIGIAB90L8EUo/gJBKQBx+vEiuPjxANgI3SGBF6YroxyzHwgRBc93gABcH+OH +6IcEJ76fAAYAAAPyjLpSpuS5yiUiEuG5yiUhEoYh/g9BKQIBTR6CECiTRXkosykN0REjCLQDB93P +cYAAXB8jgYQRAQATCQQAz3GgADAQKIEJCEAACN2H5cogAQFEDiH7yiEhACsDAADPcKYACAQBgAQg +gA8wAAAANLhCHgQQQhYBERkIX0bPcKAAqCAIgBlhMHnmDS/7iHAF8AYOL/uIcAQggE+AAQAAANkx +CIEPAAEAAAHYTh4CEM9ygABUzpoWgBBCHkQQTR5CEDemKaIEuCiSibgleAiyc/BNHkIQz3CmAIwD +PYAEIYIPOAAAAEEqwASaHgIQBCGADwAAAPAluiy4RXjPcoAAfM0Spg0I3kcSgoy4EqJTIcMCSBKO +AHei4L7RIeKHB90D9Ajdz3CAAFTOKaCaEoEA6JAEueV5KLB8sDKCLaB9DdERz3GmAIwDvYEEJYEf +AQAAADC5ThpCAKmgThKAABvoWw5RE1MIH0YU2M9xoADIHx6hENgOoQHYFRkYgArdUSAAxsol4hFR +IwDAyiUiEvENkJIU8CcLlAPPcIAAXB8DgIQQAAAXCMQAz3CgADAQCIALCwEAB90C8Ajdh+Xl9M92 +gAB8zU4WgBCA4N3yz3KmANQELBIAgDQSEoA4Eg+AyxIQBkpxxrnpcoYi/Q8GukV5SnKGIv0PBLpF +eQQggg8CAAAAJ7pFeUQnAhwNukV56XKGIvMPBCCADzgAAAAOukV5JbgleEQngRAUuSV4iLhEJwES +QSnBgFIgQAUSplgeQhDKIYIPAAD//8ohgQ8AABAfOnE3hkAeRBAEIoEv/wMA/yi5N6YODq/4ANqs +HgAQcQ+eFEgWgxAyhqDj0SHhgjDyBCGCjwAAAAEI8kQhDQYjvQHlFQ2VEAQhjQ8AAAAkQQ2AHwAA +ACQEIY0PBgAAADG9MQ3VEBUNkRAU6kQhDQYjvQHlHQ2REAPqzOMK9leGMnLKIo4PAQCIDcwgjoDO +9xUOBXABAIgNz3GAAEA3HIEB4ByhCN0z8IYh/wlBKc0Az3CAAHgmIIAB5WB5BtgvCEQDz3CAAFwf +A4AIgAQgvo8ABgAAANjKIGIAMoYEIYEPAAAACCu5FQhFAKYMAAAIdZTgyiXiEwvwz3CgADAQCIA3 +hhBxB93KJWISWBaCEM9xgABUzgiRB7qIukV4CLEXhjAZAAQcsRKG66ENoawWABAoGYAEHbENDdER +eggAAAh1jO0iDmAAFd2SDC/7CHaA5swgIoDKJSEQgOWUC6L/yiBCAwDYz3GgANQLEKHPcIAACM4N +iBEIHgDPcKAAiCQegAsaHDA6DEAADMyGIPmPCvSE5cwl4pAG9ADYj7gMGhwwMtnPcKAAyBwqoK0G +7/OiwPHAVg7P8wDdz3CgANQLGIBCIAAIgODKIEwDz3GAAKglJYGB4YohmQ4I9M9xgABcHyOBPoGA +IZkOEHEA2MogbQR1CBEAz3KAAHzNWBKBAIDhyiEiACL0DBIDNycL3gANEgE3UyF+gA3y67k3ggXy +oOEB2cB5CPCO4QHZwHkE8CcLXwEA2c9zgABcH2ODaYN9e1IjAwDAu2R5B+k/gpG5P6IK8DeC6fH2 +CwAAWBKBAIDhKAsBAIDgfgICAM92gAB8zVgWgBAS6ALZz3CgAPQmI6DPcIAA+J2hoMDZmRaAEIC4 +mR4CEChwA/BC2M9xoADEJ78ZGIAB2AwZQIMQGRiAH4bxuCICAgAShjeGaguv+ADarB4AEB+GxQje +As9xgABcH2OBSBaAEDSDBHlEIQIBRCABDEIpBAGAcs9xgAAQIFMiRgAyIYEBibk8plSDcBaBEM93 +gABwTgQhhQBNFoIQhiH/A0S5BCWFAKBx9CdBEGIeRBDPcYAANCMyIYEBibk9pnQWgRD0gyR/hiH/ +A0S5RH8/Z89xgABwTvQhwQNkHkQQMoY6pnSDO6ZkeAR6z3CAAIBOgHL0IIMAz3CAAKhO9CCAAI4e +xBCQHsQQkh4EEJQeBBBOHkITmfBOFoEQz3CAAKQyAIDAuKkJEACA4ADbyiEiAAv0coZIFoEQBCOD +DwAAAAh7e8K5ACGND4AABCBQjbiNx3GAADAjz3eAADixCIllfbymcBaNEGV6w728ffQnTRNleDCJ +ZXk9pnQWgRDDuTx59CdBEGIeRBNapmgWgxBkHkQQz3GAAEixw7t8e/QhwgAbpo4ehBDPcoAAkLH0 +IsMAbBaAEMO4HHj0IQEAkh7EEJAeRBD0IgAAPfCA4ADZBfRIFoEQw7k8ec9wgAAAIChgz3KAADix +HKZwFoAQw7gcePQiAABiHgQQz3CAACQjKGAdpnQWgBDDuBx49CIAAM9xgABIsVKGZB4EEEgWgBDD +uBx49CEDAFqmz3GAAJCx9CEAAI4exBBbppAexBCSHgQQlB4EEBIMQAHPcIAAXB8DgAiADwjeAk4W +gBCA4BQJQgVYFoAQBejCCg//A/DCCgAAjQPP8+B4z3GgAMQnFREDhgTYExkYgBvYFhkYgAPaz3Cg +ANQLUaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeFGg5LvhIMIHFthSEQCG4LjhIMEH +yiDhBQkIXgAJC94A4H8S2AHZz3CAAMwdz3KAAHzNtBIDACCoBoMB4AajH4IPCJ4Dz3CAAKgIIKAH +8A8I3gPPcIAArAggoBXY4H7geOB+4HjxwHoKz/PPcIAAfM0ygCcJXgLPcYAAXB8jgUgQggA0gUR5 +USGAgEjayiKBDwAAkAAC8A7aAN/PcaAAqCAngawQDQBZYbFxwiVFEMol5hKweEYO7/oK2c9wgAA8 +LgCQz3agAMQnCwgeAYwlA5ID9wDdGvCqDKABANjPcKsAoP/6oADYbg7v/Y64GRYAlgToAtgQHhiQ +z3GAAEA3G4FqvbhgFN0boRkWAJaH6FEhAMYMCKEEyiBhAC0C7/OpcOB+4HjgfuB48cDhxc9wgACI +CQCQz3GAACS8qNoB3YAgRAsQeBYKL/upc4DgyiHBD8oiwQfKIIEPAAC1FMojgQ8AAMwAyiQhAPAA +YfXKJQEBFgpAAM9wgAAAKN0B7/O0oPHA/gugAQDYrgtP9yIPD/5SCY/7ANi+De/9jrj/2c9wqwCg +/zmgOKDRwOB+8cDhxc9xgABcH/AhAgBKJEAAwxIBBg94MiKCDwAAHwMEIYMPAAYAAIDjAdvAewQh +jQ9AAAAA13VAAAAAwiQCAXILr/vAuWUBz/PgePHA6gjP8/IPIAIIdc9xgAB8zR+Bz3agAMQnsLgf +oRkWAJYA2QToAtgQHhiQz3CgANQLN6CiDgABIgwgAwHYBe3eCEAABfC+CEAAFg3P+hkWAJYF6ALY +EB4YkP0Az/PgePHAJgugAQHYANnPcIAAxDYuoKIKb/YZ2NHA4H7xwGIIz/OiwYt2Rglv+slwCiUA +kBn0z3CAAHzNz3GgAAwkO4FXgDByyiUiEiCGDQkeBALZjBhEAAQlgl8AAHDHP4BFeT+ggOW6AwIA +AMDpuNbyz3WAAJAmAIWKIQgA5JDPdqAAxCcTHliQz3GAAHzNP4E6d4Yh/COFCV4EQSkBIcO5z3KA +AMRTNnoggkB5CHUZFgCWBOgC2BAeGJDPcAAA/38THhiQG9gWHhiQA9nPcKAA1AsxoOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaDPcIAAjIwZgIDgMA5CAZrlGgMCAM9wgQAIG/YOIAMA +3QsDAABSDm//KnAacACF6g4v/ypxcg8v/wh3iOfMJ+KVyiXBEyvyGwgQIO4KIACBwAolAJAc9IYN +7/8BwBjwA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaAA3Q8PkRbP +cIEACBt6DgADgOWOAgIA8g+AAc9wgAB8zR+AEQieAwHZz3CAAKgIIKAJ8A8I3gMB2c9wgACsCCCg +ERYAlgDdQcAxCJ8Aog8v+oHACiUAkBD0BBQFMB0NnwAKIcAP63IK2Iy4iiPHChUGL/WKJIMPgOUq +AgIABNgTHhiQG9gWHhiQz3CAAIyMGYCA4BwNQgELAgAA4LjB8s92gAB8zRKGhiA6AIwgBIJYD4UB +z3GgAAwkPIEXhiJ4ZLgQeIoeBBBEIgBTFwgRAh+GDwhfBFElQNEB2AX0ANgD8HYNT/+cHgAQLujW +CE//CiUAkNf0DcwhCN4BH4YdCJ4BLyCHCowgAoYI9M9xgAB8zR+BmLgfoZYJIACBwAolAJDB9M92 +gAB8zR+GKwgeBKgWARDU2CYPIAHJcgfoDg1ABAvwBgpP/6zwz3GAALw3HoEB4B6hAd/PcIAAzB20 +FgEQ4KgGgQHgBqEfhvO4/AmC+g+GgOAMCYL6H4YRCJ4DAdnPcIAAqAggoAnwDwjeAwHZz3CAAKwI +IKAA2M9xoADIHAehMNgKoaoL7/8BwB+GJwgeBhDYDBocMM9wgQAIG8YMAAMNyAAggQ+AALTMH4bg +qbi4H6YAloYg/ACMIAKAGvS2Cw/6mOgD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HgxoACWYgxv/DSWQ/BBwBXfCwjfAOl1H/AI2M92oADEJxMeGJBeCs//CHUrCBAFAtg8 +HgCQIRYBls9wgAD4nSGgERYAltMIn4CWDS/6gcAKJQCQ4fM/DVEVz3CgAJAjHoAEFAQwUSCAgMoh +wQ/KIsEHyiBhAs8gIQPKI4EPAADkBPQDIfXKJSEAVgnv/4hwCHWpcL0Er/OiwOB48cBiDI/zocEI +dgDYQMAApjINL/qLcAolAJCF9M9woAAEJSKAAIYEIYEP/wBf/wUhAgBAplMhggBTIIMAZXqlCtEB +z3CAAHzNH4B5Cp5TtwifBgQgvo8AHgAABPQAhgnwAQqfQACGCwoeQIW4AKbPcoAAfM0/ghEJXgaI +uIu4jrgApkHwKQneBk8gAQKJuY25i7mOuSCmHoIEIIAPAgAAAFIgQAQquCV4AKYt8Py5xSCCDwAA +AAXk9YUgHAAApiPw9bgAhh/yhiAcAIUgGAAApgEKH0EAhi8K3kCGuACmE/BTIQMAUyACAAUjvoDK +JeEVCfKGIX8PhiB/DwUhPoDKJaEUz3CAAAjODIjEuEAoAQYAhiV4USCAxACmhAliBMogIgipcKkD +r/OhwOB48cDhxQDdBdgLuEYPr/qpceIMj/TPcIAAfM0fgBUI3wLFDRURwQhfRZ8IH0UB5U7wANmc +uc9woADQGzCgAdnPcKQAmEA8oAXYB/AGCwAATglgBAXYAdhGCUAEYw0VEQQgvs8wAAAAAeXKJSIQ +LQsfQAkIXkVHCZ5DMwgfR9kI3sXVCZ7Dz3CqAAAEAYCGID8LAN27CNGAE/C2CgAAz3GAAMQ2DoEB +4A6hCfAA2Zy5z3CgANAbMKCaCgAAANnPcKQAmEA8oBDwAN0NCx9AzghgBAHYqPF6CgAAz3GAAMQ2 +DoEB4A6hxQKP8wzMRCA+ijnyQQjeAA0SAjeA2M9xgABINgwaHDANCt4CHYEB4B2hBfAVgQHgFaER +Ct8AANnPcKAALCAvoA3MhiCCAuB/DRocMC8IXgGKIAQADBocMM9xgABINhSBAeAUoQ3MANlGIIAC +DRocMM9woAAsIC+g4H7gfvHA4cUtCBECKQqfUc9xgAB8zX+BhiP3D7eBz3KgAAwkHIIU4AglABBc +gooRAQER8JXoz3OAAHzNN4PPcqAADCQcggghAACKEwEBXIJ/gxoIgATPcYAAlCYAofEBj/PgePHA +z3CAAHzNFJBRIMCBz3CAAJQmAIAF8kIPQAQD8I4PQATRwOB+4HjxwEoJj/PPdoAAlCYAhoDgyiBh +BSPyz3GAAKQJIIHPcoAAoAlAgsdxAAAAQM91gAB8zUJ5zbnPcqAA1AsvoiCAOGCCDO/zN4UAhgDf +QIA3hVlh7g6gBCCg6XBZAY/z4HjxwDIOgATPc4AAlCYAgwXoZg6ABACj0cDgfuB48cDPcIAATDXP +cYAAkOrPcgAAYCJ2CeAEAIAA2c9wgACUJiCg0cDgfvHAqgiP889wgQBUHACArQgQAM9wgACUJgCA +BugCkIYg/4lM9EQiAFNLCBECrg/P/6YO7/8I2CoPz//PdYAAlCYKJgCQAIUI9IDg7A7C/3IP7//J +cCCFDOkCkQroiO5GDWAEAIECDqAEAIUo8HYNQAQk8IYi/9zPcoAAfM0S9B+CIQheA14JoAQB2AjY +z3GAAHB+CHSGsTC8Ug6gBIexDvCcEgAAFQjRADSSmBKAACXaw7keDK/0ANtdAK/zFdjgePHAhgpg +AQHYHgnv8wPYJggAAHYKYAEB2NHA4H7xwOYPz/+WDM//OgyP+tHA4H7gePHAug9P889xoAD8RAWB +AN68uAWhQgpgAclwA93aCO/zqXDPcaAAMBCioc9wgACoJaKh9Qdv88ag8cDPcKAAtA83gM9wgACo +JQaADQkBALYPz/8E8JoPz//RwOB+4cXhxgDZB9gA2rRptH3HdYAAJLxVfcCVjCYCnQDbhfaMJoWS +w/b/3sC1wZ0LDlMfjCY/kUL2YbUB4k96zwoSg2G4AeHFCHWAL3nBxuB/wcXxwA4PT/MA3c9wgABo +mnoN7/m0qBLoCN6A5cwlopDMJSKRzCVikQAIov7KIEIDYb7pDnWQAeUd8IokAXHPcYAALMyoIIAB +BBlQA+B4ANlKJAByz3KAANjLqCDAAhYiQABikM9wgACkzDR4AeFgsM91gABcH892gACAnUAlABck +buYNoAEG2kAlABVAJoES2g2gAQbaQCUAF0AmARTKDaABBtoOhVEgQIGMDIIC5gzP+YDg3A7C/89x +AAD//89wgQBMGCygfg7v+SugsQZP8+B48cA+Dm/zFNnPdYAAVCPY3P4NL/UCJQATz3CAAKAl8g0v +9RTZz3aAAFwfQCYAFQCmwNwCJQATAaYA3alwqXGmCS/0BtoB2Klxmgkv9AbaAIZKJIBwqXECpgOm +qCDABRUmQhBggoogxg0NswCCAeGpoACCqaAAgsAYWAMAgsEYWAMAgsIYWAMb2c9wgACUNB0Gb/Ms +qPHAkg1P8xpwOnFIdv4K7/macwh1BCaAHwAGAACA4EoiQCDCIoIkBCaOH0AAAADXdkAAAABKI0Ag +wiPCJM9wgADICMSIAN8CCGAB6XCM7QPeLyEHBC8iRwTJcEpzyg8v+wokwATJcPIPL/uKcYTtMg2A +AgTwYg2AAs9wgACoJQSAIQieAM9wgADcMgCAiug52MYK7/mLuA0IUQAqDc//DfAA2Z65z3CgAPxE +IaDgeOGglg8gAQDYMQVP8+B48cDqDE/zo8EIds9wgABcH/AggwOKJwsWLZP9Yzx6KHCGIfEPwrpH +uSR6hiD+A0S4HwmAAAohwA/rcoPYjbiKI9INSiQAACEE7/QKJQABSIN/Zzu6UyICgECvTZPAukGt +C/L3k4Yn/xlDv+etd5OGI/4HRbtorRTqz3KAAPAyFSIDAACLNXoCreGL463ii+StY4tlrSOK1gzg +ACati3CpcQ4Nb/MM2gDAAcGOD2/0AsKLcKlx+gxv8wzaAMABwWIPb/QCws9xgAAYCQChsg7gA8lw +gQRv86PA8cAWDG/zV9jPdYAAXB8jhc9ygAAcCXeRAKILCx4AX9gAogsLngCFuACiCwteAIe4AKKK +JgsWy2HZYQDagOPKIIEAz3KlAOgPBqIAic9xoACkMIDgAYHPIOIA0CDhAAGhCg7P9gOFz3GgAMgc +T4AC4EihpgxgAchgA4UOCK/9DoABBE/z4cXPcIAAXB8DgCmARCGDgADaJPSJChUEACKND4AAnB4A +jaC4AK2AFYAQoLiAHQIQQBWAEKC4QB0CEBCNoLgQrZAVgBCguJAdAhBQFYAQoLhQHQIQAeLg8UUK +FQQAIo0PgACcHgCNgLgArYAVgBCAuIAdAhBAFYAQgLhAHQIQEI2AuBCtkBWAEIC4kB0CEFAVgBCA +uFAdAhAB4uDxIwmeAc9ygACcHgiKgLgIqogSgACAuIgaAgBIEoAAgLgQ8JLrz3KAAJweCIqguAiq +iBKAAKC4iBoCAEgSgACguEgaAgAA2D8JHgBKJAB04HioIAAGKwieAAAggw+AAJweIBOBAIC5IBtC +AKATgQCAuaAbQgBgE4EAgLlgG0IAAeAc8EokAHTgeKggAAYrCJ4AACCDD4AAnB4gE4IAoLogG4IA +oBOCAKC6oBuCAGATggCgumAbggAB4OB/wcXxwDIKT/PPdoAAXB8acAsIUQAAhgLwAYbEEAAGFSYN +FEwgAKAB3yW4UyAFACCFwH9AIQAGxBEBBhsJXwEKIcAP63KB2I24iiOND2kB7/QKJAAEiiILDVlg +ABYDQFhgYKAAFgBAAaEAFoBACKkAFoBACanPcIAAqCUFgBEIUQBAhQAWAEEPsgTwABYAQQAWgEAK +qQAWgEALqQAWgEAMqQAWgEAAFgBBB7EAFgBBCLEAFgBA9g1P/QCFyBAABoYgf45B9PAmwBPIEAAG +hiB/jjv0CnCiCS/4AdmqC2/8LyAHBG4N4AMKcM9wgACkIiyQHpYNCQAA4g7P+EsIAQQAhcQQAQYK +cCW5wLkiCq/1ANrODgABiegLyAUggA8AAAA8CxoYML4OAAGJ6AvIBSCADwAAANQLGhgwC8iQuAsa +GDCuC4/zIgrP91EBT/PgePHAxghv8wDZCiQAoKHByiFhABTyz3CAAKglEBAFAB0NnwAKIcAP63J+ +2I24iiMIDTUA7/QKJAAFz3WAAFwfFSUOFQCGFSVSECQQFQAAEgEgIBAWACgQFwFBLU8hKYEaEBgB +wL8luVMhEwBaDmADDdmKIIkAinHmCu/76XLKDi/+inAAhgmAJbhTIBAAinCaCC/4ANlMJACgSAnB +/3kIECAN7wohwA/rcn/YjbiKI4kHSiQAALEHr/S4c9YNgAHuCe/3AdgAhgiADwgeACwVgBCE4APY +AvQF2DpwIQsRIFYJT/v+CE/7z3CAAOQyA4iA4FQNoQDKICEALBWAEITgyiCBDwAAgACoDGH7yiFh +AEojACBL8KYOb/+KcJIJ7/cA2CwVgBCE4MoggQ8AAIAAgAxh+8ohIQAhDBEg+ghP+/IIT/sKCc/2 +Lg6P+YDgqAnC9gDYH/CeCc/2Gg6P+YTo0gkABBbwz3CAAKQiCIiJ4Mwg4oHw9c9wgAAEQgCABNm9 +2h7bQMCLcL4M4AAYuwHYenAAhgiADwgeACwVgBCE4ATYAvQG2DpwAIYogBSQBCGPjwAGAAAFfwfy +9rnCJ6IQwCehECpwinGWCu/16XKA4MogQgSECuL1yiHCAw0LECA6CM/3n/CCDY/5BNnPcIAAqCVq +C2/9JKAghsgRAAaGIH+OQfQ2CW/8inD6CuADinAAEgAgyBAABoYgf45A9M9wgACkIiyQHpUPCQAA +YgzP+G0IAQWKcApxqg9v9QHaf9kRuc9woACwHzSgbg6P+UIMAAGI6AvIBSCADwAAADwLGhgwMgwA +AYjoC8gFIIAPAAAA1AsaGDALyJC4CxoYMCIJj/MM8CQZQAUghiAZgAUghigZxAUghhoZBAbODI/5 +CegA2AsMESCCCAAEA/BiCAAEAd0uC+ABqXDPcIAAnB2KCuABoKgpDFEgz3CAAKQiCIiJ4Mwg4oED +9BEIESARCBEClgyP+QTouggP9doJT/kqD4/3BMqQ4Mwggo8AALMADvIKIcAP63IBEgQ2ktiNuIoj +jQZVBa/0CiUABe4KoAEA2O0FL/OhwPHAwg0P8wzMAN57CB4Az3CgAMgfsBACAM9xgABcHyOBAuJG +EQEBYbkIIkEAPqAQ2S6gAdkVGFiAz3CBAAgXAxoYMM9wgQDQF3YOoAIEGhgwz3CgAPxEJYBKIEAg +vLkloAzMhiD/gc9wgAC8CACAwiABJIDgdAyC/QQgj08wAAAAHfA3CF4DTg7P/s9woAD8RCWAvLkl +oM9wgADENg6AjCACjYj3cgjv9RnYvg/gAMlwDMwzCN8DyXcadgDYz3GAAEA3DKHPcIAA0B0QgACA +DqFQ8EYI7/UZ2I4P4AAA2AHeSPAE2M9xoADIHwYaGDAfgYDgiiAMAMoggg8AAAACDqED2BW4EhkY +gL0CAAAMEgE3SwheRQbIhiDxjyH0z3WAAFA1iBUAFgQhvo8AAABQAeCIHRgQBPIE2AwaHDCWDc/+ +z3CgAPxEJYC8uSWgaxUAFoMIhY8AALQAAd4MzNEIHwHjCJ8BhiD/ha3yUSMAwHv0BsgEIL6PA4Do +U8r1kQhfxQINb/oA3s91oADIHzcIECD/haAVABAJJwAQ5ODL9s9wgADYywCADwheAN6lYg+gABDY +5OfH90AVARYwebYIb/oQ2IogCACgHYATDqUfhYXoiiAEAA6l7gwAAS/YlbgSHRiQz3ABAMD8FR0Y +kH4KgALPcYAAQDcMgU2BCCIAAA2hz3CAANAdEIBPgWCADoECewDKCCLCAIjgT6HT9APZz3CgAEAt +MKAAGoIzzvANzFMgQICg8wTIAxIBNgMaGDAEGlgwfgyAAs9woAD8RCWAvLkloM9wgAC8CACAgOCM +CoL9iPERCF/FDMzPdYAASDZBCN4AgNgMGhwwDcwRCN4CHYUB4B2lAN4F8BWFAeAVpc9wgACUNBGI +USAAgKAOYgLKIGIAEe8chQHgHKUN8IogBAAMGhwwFIUB4BSlBe8bhQHgG6UMzHkI3gENzAQghA8A +AAAYOwyADwAAAAiyDI/3DcxHCN4Az3CgACwgJYAGgArhLwhEAAMSATYC2AwaHDBQ2KINL/6YEQEA +nfEqCu/4yXAPCB4ACNibuAYaGDAq8QTYBhoYMCbxA8igEAAA8LgA2D7yGg4P+ADYlrg68E8IHwJz +CF8CBCC+jwAAAFAM8hkLHkCKIQQAz3CgALAfNKAE2AYaGDANzO+4BPPPcaAAqCBIgc9xgAD0zS+R +MHL0BcX/r7jxBe//DRocMKoN7/uKIAQA+guv9wDdA8igEAAA8LipcAbypg0P+ADYlbjCDIADt/Ga +DS/4AdgA2JC4+PEB4AAaAjBhAg/z8cDuCQ/zz3CAADAzAN/ooM91gADoCQGFhiB5j+ulB/QD2AYP +b/kLuI3oBtnPcIAAIAogoM9wgAAkCuCgGQIgAADYz3CAACQKAICA4AwCAgACFYUQAxWGEM92gAB4 +z0AmkhCocIQoHwAvcwAjgQ+AAIDWFSGBARuROpFAJhEaQCYQFQAmxBAEFAQBemZDgttjSiNAIB/o +IQhFAAohwA/rcs9wAAB7J4ojxgEKJMAEzQCv9LhzD+pQcMohxg/KIIYPAAB8J8ojhg8AAIkByiLG +B233IQkFAQohwA/rcs9wAAB9J4ojRgNKJEAAkQCv9LhzD+pQccohxg/KIIYPAAB+J8ojhg8AAI8B +yiLGB233DIWQ6AeFjujPcKAAsB9kGMAEz3CAANAdCIAAgBwdwBQJpc92gABcHwOGJYMooKhwhCgf +AAAhgH+AAETWMOD0IIEBA4Y0sAOGJoMpoAOGJZMtsALYCHFCDK/zANr6CkAAAo2EKB8AL3EwIEIg +A43HcYAARNYw4fQhAQBTIgAAzgqv/wDbAo2EKB8AL3EwIUAgACGCD4AAdNQjjQK5NHmaDOAAWWFq +DWABAdjyCcAAIo1DjYQpHwAAIYB/gADE1VV4bIAbCx4Az3OgALAfZBvABM9zgADQHWiDYINipWKG +hCkfAMITDgaBvsIbmAMMgMC4UiAAABt4VXgAIIIPgACA1jTiNCJBDgq5MiJALiilz3GAACAKFwhe +AM9wgABUzyAQgACB4AXYAvIE2AChz3CAACQK4KAMhYDgyiAhABgLofXKIQEAAdjxB8/yCiHAD+ty +z3AAAH8niiMHCEokgAANB2/0uHPgeOHF4cYIdQDYz3OAAOgJz3GAAHjPz3KAAETWYosD8AHgD3jD +aYQrHwAyJk4eGQiDA4QrHwAAIk4OMOb0Jg4Q4w2BkwTwiiD/D8HG4H/BxeB48cB+Dw/4ANjRwOB+ +8cA+DW/54cUy6M9xgABomhSJXQhQADeJCenPcIAA9L0BgBBxAdjAeBTwz3KAADiTC4qGIP+MHvLP +cYAA9L1hgaSKANgLC0ADIIoJC0EAAdjPcYAAFAoAoRUIUQDPcIAAGDwmgCOBIIGWC8ABOQfP8soO +D/ju8eB4z3GAAOwJAIGAuAChz3GAADAzBYEB4AWhBtnPcIAAIAogoADZz3CAACQK4H8goOB48cCG +Ds/yz3CAAOoJAIjPc4AA6wnAiwHdhCgfAC9xACGCD4AAxNWYcDDi8CKAA8C4geAAIYAPgABE1jDg +9CCFA8dxgAB4z8B9Aebjic9+OQ7jE8Cr9CCPAy0PQREU7fAijwMlDx8QAebjic9+Fw7DE/QgjwMP +D0ERBe3wIo8D6w8ekMCrA4lXDgMQ8CKAA4QsHwDAuFIgAAAbeNV4ACCBD4AAgNY04TQhQA7PcYAA +CAoKuAChx3AAAAAY9gpP+c9ygAAgCs9xgAAkCgfoA9gAogDYAKEF8AbY+/H6Ds//EQbv8gDY8cCi +Dc/ypcHPcIAA6AkEEAUAAd3PdoAAJAqodIQkhpAAFgQQE/JMJACAaAvi98ogIgEB2c9wgAAgCiCg +AN3PcIAAID+gqKl3XfBfDBEAAtrPcYAAIApAoc93gAAgPyCPoKYA3onpz3GgACwgMIHHcQAAAH0t +oDQQBwDPcAAA2G9AwATYQcAB3ULFQ8ZExqlwENkE2gDbmHO4cyYM7/fYc8CvqXcv8DMMUQAD2B4K +b/kLuIDgD/TPcIAAID+gqNYK7/cE2M9wgAAgCqCgANgApgDdAd8X8D0MkQDPcYAAID8A3+CpTyWB +ACGgz3GAADAzBoHgpgHgBqHPcIAAIAqgoOl1gOVYDwEA6XABBe/ypcAKIcAP63LPcAAAeicBBG/0 +iiOFAvHA4cXPcoAA6AkhgqXBKHSEJAaQz3WAACQKABUFEBfyCw1RAKoMj/QJ8IW5IaLPcYAAMDMK +gQHgCqEB2c9wgAAgCiCgANgApSrwTw0RAAHaQKWGITmPANjPdaAALCDPcwAA2G8E2bCFQMNBwULC +BfIQ2UPBAvBDwETAANgG2QTaCHOYcLhwACWHHwAAAH0OC+/32HAD8A8NUQAB2FkE7/KlwM9wgAAg +ChkNkQCFuSGiz3KAADAzKoIB4SqiAdnD8QAQBAAKIcAP63LPcAAAhCcpA2/0iiNOCPHAogvP8s92 +gADoCSGGUCEMAKe8UCQMki8qQQAG8lIMr/ROIsAHFvAodIQkBpAV8j4Mr/ROIsAHAYbPdYAAbCaG +IAYAAaYAhQToQHgA2ACltQPv8gHYz3CAACQKAICA4Jb0USEAgM91gABcH3v0Ao5DjoQoHwAvcAAg +gQ+AAMTVMOHwIYMAAdkCumZ5NHrHcoAAgNY04hBiCrgIpsdwAAAAGC4Ib/lKIEAgwxUBFgh3z3CA +ACzMNHgRiIDgkghv+cIgAiSA58wgIqDMICKAQvICjs9xgAB01oQoHwAvcBNhz3GAAPQIIJFDhTcL +QQDHcIAAeM9lgCiCUyMPAFMhDQAfD0ETA4iB4MQjgQ8ABgAAxCGBDwAGAADMI0GAA/IA2QLwAdkJ +gs9zgAAgCiymEQheAYbpGIqD4ALYA/ID2ACjANnPcIAAJArSDCAAIKCC8YDngPPPcYAAQDcegQHg +HqF48SYKoAAB2ACFxBAABiW4lg1v9cC4Xgxv9RTYygov+wTYHg8AAB4ID/pk8QohwA/rcs9wAAB5 +J/3bSiSAAIUBb/S4c/HAAgrP8s9wgAAkCgCAgOCV9EIKr/QB3gLYJgqv98lxz3CAAMgIAIDPd4AA +XB8mgJ4RAAamuJ4ZGAAjh0iBNJFTIgAAGgxv/8lzdgwgAADdAtipcVYNb/MC2iKHwhEABqG4whkY +AACHxBAABiW4wLj2DG/1qXHPcKAAsB/ZoM9wgADQHQiAIIDPcIAA6AkioIoNYAMC2IoOIAHJcM9w +gACoJQSAIQieAM9wgADcMgCAiugCDy/5iiDMDg0IUQBiCU//DfAA2Z65z3CgAPxEIaDgeKGgzgug +AADYngrP/UOHz3GAACAKCYIXCF4Bz3CAAOgJDICF6BiKg+AH2Bfyz3CAAOgJQojPcIAAiM+EKh8A +MCBADgjoz3CAAOgJAYCGIDmPBPLAoQTwCNgAoc9wgAAkCqCgNQHv8gDYCiHAD+tyz3AAAIMniiNN +BkokgAAxAG/0uHPxwOHFz3GAAOgJBBEEAM91gAAkCoh0hCQGkAryAdnPcIAAIAogoADYAKVE8ACF +suiIdAKJhCSGkIQoHwAAIYB/gAB4zw3yEBAFAAohwA/rcs9wAACNJ9UHL/SKIw8AAgiv9wSACHHP +cIAANDwSDYABz3GAADAzDIEB4AyhXgpv9RTYzggv+wTYA9gApQHYEvAlCNEAz3KAADAzDYIB4A2i +z3CAACAKAdpAoADYAKUHoXUAz/IKIcAP63LPcAAAhSeKI88GSiSAAGEHL/S4c+B48cDWDAAAKgtv +9RTYjggv+wTYAdnPcIAAIAogoADZz3CAACQKIKDRwOB+4HjPcIAAXB8DgA2QhiB/Ds9ygACoEAkI +kQEgkid4gLgAss9xgAB4zwWxz3GAADTX4H8HseB48cB6D4/yz3aAAOgJIo7PcIAAhM9CIJAChCkf +ADAgQA7SDy/2KYYIdwGGz3WAACQKhiB5jwv0ANhuDC/5jLgH6AyGgODMJ2GQGPQAhYHggA9B9AyG +gODMJ2GQCPTPcYAAMDMAgQHgAKEG2c9wgAAgCiCgANgApZ/wAo4jjoQoHwAAIYB/gADE1TDg8CBA +AADfWwgeAAiG8g4v9iKGjCAQgEoAKQAghYHhJA9B9AOGz3OAADAz6KMS6CSGANoA3w8nTxAGIMCD +Ly8BEAOmTieBFwHi9vUkpkijBdnPcIAAIAogoATYAKUA2GXwIIXbCZUBMyZBcIAAgEBAJwByNHgA +eAKOhCgfADIgQC5RIECAsAvBAgKOI46EKB8AACGAf4AAxNUw4PAgQADPcoAAIAoF2REIHgCAuAOm +ANgEpiClO/DPc6AAsB8B2Bmjz3OAANAd6INgh2KmYIcgogDZaqYgpSnwA4aT6AXZz3CAACAKIKDP +caAAsB/gpQHYGaHPcYAA0B0ogSCBKqYV8BEIHwAvKAEATiCBBySm4guv+wSGz3CAACw9Ad7CDGAA +wKXJcAPwAdgtBo/yz3GAADAzB4EB4AehBdiQ8QohwA/rck/YB7iKI0kKSiSAACEFL/S4c+B4z3Cg +AEwuC4DTuP0B4AIG2fHA4cXPdaAAOC5Hhc9wgAAsMwDZQKAnpb4PYAMg2AeFirgHpQvIBCCAD/// +/wMLGhgwC8iPuAsaGDALyJC4CxoYMMUFj/LgePHAqg/P/89wgAAsMyCAz3CgADguJ6CmDo/90cDg +fuB48cAiDY/yygov+QHdgODPdoAA6AkBhsB9hiB5D0IgAIDKIGIACLgFfQDYJgov+Yy4gOAB2MB4 +ELgFIH6DIvILhisIUQACjiOOhCgfAAAhgH+AAMTVNXgsgIC5LKDPcIAAMDOA2SmgANgLpgbZz3CA +ACAKIKDPcYAAJAoA2AChv/BijkOOhCsfAC9wACCND4AAxNVVfSyFUyEEgCL064ZBD1EQTyQDAFIj +AwB7e1V7gLnHc4AAgNYspTTjEGPPcYAAMDOA3amhCrgA2Qimz3CgACwgA4ArpgKmBNnK8c91gAB4 +z4QrHwBAJQATMCBADq4ML/YphkAlkBEb6AyGmegohs9wAAABFAghAACZIAoAjgwv9iKGBuj+DEAA +ig2P/6fxz3GAADAzAIEB4AChn/HPd4AAJAoAhxHoqwgQAQohwA/rcs9wAACCJ4ojSw5KJIAAUQMv +9LhzCIZCDC/2IoYL6AXZz3CAACAKIKAE2ACnANhF8AKOhCgfAC9wGWUjkR1lKOkjjsdwgADE1TDg +8CBAAEEIHgAClQq4Agwv9iqGIejPcoAAUDUZgjiCAnkEgkWCQng4YCKOhCkfADQgQS4VCQQAz3GA +ADAzAYEB4AGhE/AF2c9wgAAgCiCgBNgApwHYDfAIhkoLL/YihgohAIASAA8AIgxAAK4Mj/+NA4/y +z3OAABg8BoMDgECAaHDqD2ABWWFCDS/1FNjj8eB48cAOC4/yz3aAACQKAIaB4EgLQfQA3c9wgAAg +CqCgz3CAADQ8Rg9gAaCmz3CAABg8Og9AAc9wgADrCaCoz3CAAOwJoKDPcIAABAqgoM9wgAAwM6mg +AtipcVoOL/MIch0Dj/LgeOB+4HjgfuB4FLgleM9xoAA4LgahBoEBCN4H4H4A289xoADAL6UZ2IAP +2gi6oxEAhkR4jCAQgPzzFBnYgKMRAIYLIICA/PXgfpTgyiIFAIX3CHKAIsIEz3GgAGgs8CGBAADb +z3KgAMQsZ6Joogy4nbifuCV4BqLgfvHAMgqP8gh2ng/v/yh1yXCCD+//qXGJAo/y4HjhxTDbAN3P +cKAAyBxpoAPaz3GgAMwXIRmYgE6hp6BqoOB/wcXxwO4Jr/IA2c9woAAMJFiAz3WAAHzNrXBBKoYH +hiD3D5gVgxApuHZ5wHHHcYEA+BUVeQARhADPcIAA6BQggEAszgDVftBh2WFEII+AUyCOAAQigA8A +IAAAzCAigAb0gOfMICGAANgD9AHYz3egAMQnQCsFBoYj/Q9SI8MBxQwzBEW7gObMICKAXPLPcIAA +lFTwIIcDQC6GAwUmxgEFJYABBXtBH9iQYw6REB+FENqauB+lCNhPHQIQz3CgAMgcSaAHgc9yoADw +FwaiBoEGogWBBqIEgQaiANgKoooVABFouBB4ih0EEACVhiD/jAP0AdgdouYLQAOt6M9wgACUJiCA +ANgCsSXwThWAEKPoihUAEUylZLgQeIodBBAE2U8dQhAZDtEQKxcBlmS4EHiKHQQQDNgtpU8dAhAK +CO/4iHAJ8AUjQwFBH9iQH4WzuB+lCQGP8uB4ENrPcaAAyBxJoQHbz3GgAPAXaqGkEAIATQreAgLa +XaHPc4AACOpEg0ahQ4NGoUKDRqFBg0ahcBAAARzgUyDAgAT0QCMACATwQCMADECAU6FMaECCU6H4 +EAKCU6H8EACAE6EP8FyQhiL/jAP0faFIgEahR4BGoUaARqEFgAah4H7hxS+Az3OgAPAXz3KgAPwX +KKNAEAEBKrIxgCijSBABASqyM4Aoo1AQAQEqsjyQhiHzD4whDIAH9DaAKKNcEAEBKrJwEAEBvJAI +4aiyvZCoslQQDQGosmAQDQGosrmAp6O6gKeju4Cno3IQAAE4YBB4CLLPcKAA9AcnoALZz3CgAMgc +J6Dgf8HF8cA+Co/4Gg6P+NHA4H7geFEgAIDPcoAACAjPcKAA7CcA2QryANmXuTGiz3KAAEYEAdkG +8DGiz3KAAEcERqAFuTB5ELmBuYe5jLkmoOB+4HjxwEIPT/LPdYAAfM0Xhc92gQCYFgsIEAZYFYAQ +BOgahVuFBPAchV2Fz3GAAKQyIIETCR8AMoUEIYEPAAAAECV4JXrPcf7//z8keAGmAN/ipkR5LaYO +2GoN7/gOpgfoz3GAAJQiAgigAAHYz3GAAHAf9g9gAADYF4UPCBEFAdgBrjEeAhAE8OGuMR7CEx0H +T/KhwfHAog5P8jpxCHZId4oIr/oA3YHgyiBCIwv0z3CAAIgdAJCB4AHYwHhAKBADyXCGIPwAjCAC +hSP0z3CAAHzNmBCAAOe4yiAiAAr0ArgWeM9xgQAQDgBhLbjAuM9xgABkCSCBUSGAgM9xgAD0zRR5 +BPIg2q2RCvCY2quRBvDPcIAAuM2zkA7aAZdAJQEVEQkDAKJ4SCAAABB4A/AA2FpwANgqcalzwg+g +A5hwCiEAoAT0rg0AAzpwTCEAoADYSPQFIIAjDXEAsQ1xABmEBCOHDXAgoCiXDXAgsIwmApUV8owm +A5Ed8owmA5Uk8gohwA/rchPYjLjPcwAAlAqKJIMPLQXv87hzz3CAAHzNtBABAA+BAeAPocYJIADp +cBLwz3CAAHzNtBABAA6BAeAOoQrwz3CAAHzNtBABAA2BAeANoc9xoAD0BwDYBKEB2Bpwz3GgAMgf ++BECAEJ1AiWAEEggAABfgRB4PQiEAEOHz3CAAPidQqCg2A+hANgfoc9wgAB8zRyQYrhCcB+hAtgV +GRiADQkQIFEgQMYg2APygNgOoYwmA5UG9M9wgAB8zRyQCfCMJgORCPTPcIAA9M0PkDoJr/kA2aYK +z/4MzIYg+Y8S9IwmA5HKICEAzyChAwjyTCIAoADYzyAiA8ogIQEMGhwwCnAI3A8FT/LxwLoMT/Kh +wQh3lg5v+gDdFQhRAM9wgACIHQCQAd2B4MB9DL3PcIEAhBcEgM9ygABosQQggA8AAAAQRSBBA0DB +IMDDuBx49CIDAM9woAAsIA+AcLsVCOQAAN7weHB7ogngAxTaCQgeBslwOPAD2M9xoAD0BwWhhSUD +GQ1woLANcMCwiiL/Dw1wQKDPcgAA//8NcECwA8jPc4EAEA7PcoAAXB8QiAK4FngAYy24wLjwIgAA +oIANcKCgA8gQiAK4FngAYy24wLjwIgAAQpANcECwxKEqCwADAdhJBG/yocDgePHA1gtP8s9ygABE +siCKEunBgqKCz3GAAGQJAhIQAeCBz3KAAEA3K4I0vwHhK6Iw8M9yoADEJxESAYYA3/UJnoFkEgOG +ZBrYgwLZExpYgC8pwQBOIYIHE+vPcYAAhJNWecCBoYHPcYAABJT0IZAAz3GAACSU8CGPAArwz3KA +AEA3KoLpdel2GncB4SqiQYANcUChJJANcCCwz3GAADTOAIEG6EKBDXBAoADYAKHPcIAAXB8DgAiA +67jKIIIDyiFCA8oiwgM0CeIDyiMCBFMgwCDPcYAAZAkggRS/DLjleBcJngCCuA1xAKENcMCgDXCg +oB3wDXEAoUokAHSoIAADRCaBEA+5UyYAECV4DXEAoSK+SiQAdKggwAJEJYEQD7lTJQAQJXgNcQCh +Ir0RA0/y4HjxwK4KT/IIdih1KHBIcV4IIABocoHgyiCBAxAIIQDKIUED+QJP8uB4IrkG8OxyYKIE +4GG5+Qm1gGCAz3CgANQLbaAD2c9woABEHTWg4H7geEEpgYAJ8i8kSXCoIMABBBACBOxxQKHgfvHA +RgpP8qHBCHVIds9woACsLxmABCCAD3AAAADXcCAAAAAB2MB4LyYH8ADayiCBAC3yC8wAHEQwTyDB +AwIcRDAB4BB4BCCADwAA/7+PuAsaHDDPcKAA1As4gEIhAQiA4cohjABAJQASEHEgCgUDB+UEJY0f +AAD8/8V9nb2fvexwoKAAwexwIKAB2CkCb/KhwPHA4cWSC2/6AN2B4MogQgMJ9M9wgACIHQCQgeAB +2MB4DLiFIAMBA9rPcaAA9AdFoQ1yALIDyADbXZANcECwA8hRgA1wQKADyEgQAgENcECwZKHZAU/y +4HjxwF4JT/LPdYAAEIzgFQAQAN6A4ND3RC4+FwAhQHMc2cXaHtuODu//GLvgFQAQAebnDgSQANiV +AW/y4B0AEOB48cAeCU/yIYAKJgCQEInDuMohwQ/KIsEHyiChBsojgQ8AAKoAzyAhAznygOHKIcEP +yiLBB8og4QbKI4EPAACrAM8gIQMr8gK4z3GBABAOFngAYc9xgAD8CC24wLgMqSOGIJGGIfwAjCEC +gAz0z3GAAFwf8CEBAL8RAAaBuL8ZGAABhqKABe0BhQPoAIWM6AohwA/rchzYjLi520okQAD5B6/z +uHMLCJ9Bmg4AAAfoAIWA2SigAYVAeB3wAYYgkBTIEHHKIc0PyiLNBx3YyiONDwAAxgDPIC0DIfei +Ca/4yXCiDCAAAYXPcIAA/AiyDeACDIiZAE/y4HjxwCIIb/IA2gh3z3CAAOsJIIijwc9wgADqCQCI +ARzCM4QoHwAAIYB/gABE1i7g9CBAAGDBAxwCMAHYAhyCMM92oADIHxOmz3GAANAdDIEAgELACIEA +gEHAz3CAAJgIAICA4MogAQfKISEDyiKBDwAAhADKI6EHBA3h/8ArIQbPc4AAIArPdYAAMDMLEgE3 +XpWE2GCDyg3gAph3rgkAA6QWABATpeUHL/KjwOB4CNnscCCgA9kA2s9woAAUBCWgAcjscQChz3Cg +ANQLTaDgfuB48cDhxaXBCHIA289woAAsILCAQMEG2EHAQsNDw0TDAdge2ZhzuHMAJYcfAAAAfT4K +oADYc5UHL/KlwOB48cDhxaTBz3CAAOoJIIjPcIAA6wlgiIQpHwAAIYF/gABE1jDh9CHBAADaz3WA +ADAzYMHPcYAAjM8wIUAOwLgBHAIwCYVJpQIcAjAIhUilAdkDHAIwz3CgALAfOaDPcYAA0B0MgQCA +QsAIgQCAQcDPcIAAUDU9gAmAOGBDwM9wgACYCACAgODKIAEHyiEhBMoigQ8AAIMAyiOhB9QL4f/A +KyEGABSEMAsSATfPc4AAIApelYPYngzgAmCD1QYv8qTA8cClwc9wgADqCSCIz3CAAOsJYIiEKR8A +ACGBf4AARNYw4fQhwQAA2s9zgADQHWPBz3GAAIzPMCFADgHZwLgNHAIwz3CgALAfOaAMgwCAQcAI +gwCAQMAEgwCADhyCMA8cgjBCwM9wgACYCACARMGA4MogAQfKISEFyiKBDwAAggDKI6EHKAvh/8Ar +IQbPcoAAMDMMFIQwCxIBN89zgAAgCl6SgtjuC+ACYIOlwNHA4H4IyIe4CBoYMAnIm7gJGhgwCsgK +GhgwC8iHuAsaGDAMyAwaGDDgfuB4z3GAAFyNAIGBuOB/AKHgeM9xgABcjeB/A7HgeOHFz3KgAKwv +ANmq6M9woAC0DzygGILBCJ8GFYK5CB4AGoK1CB4Az3OAAMgdQIMBag8IUQAB3c9woADIHLGgz3WA +AEdoz3CgAOwnpqBAo4kKEQDPcKAAyBwxoD7wGIJvCJ8GFYJnCB4AGoJjCB4Az3OAAMgdQIMBag8I +UQAB3c9woADIHLGgz3WAAEZoz3CgAOwnpqBAo+B44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeIXqz3CgAMgcMaAB2c9woAC0Dzyg4H/Bxc9ygAB0NBV64H8govHAmHAKIcAP +63IKJcAHz3AAAKIZ5QOv81bb4HjPcoAAUDQVeuB/IKLxwJhwCiHAD+tyCiXAB89wAACjGb0Dr/Ne +2+B4z3KAAIg0FXrgfyCi8cCYcAohwA/rcgolwAfPcAAApBmVA6/zZtvgePHApBABAA0JXwZ+DE/4 +B/Ag2c9woADIHCmgA9nPcKAAEBQloNHA4H7hxQO4NXjPcYAAVD8CYUokAHQA2aggwAIWIkAAoYBg +gCnYErgB4XV4oKDgf8HF4HjPcIAAyAgAgKHBJoCeEQAGhrieGRgA4H+hwOB44H7geM9xgAD8COB/ +BKHgePHA4cXPcoAAXB8jgjiJHwkRAQohwA/rcoogjA6KIwYCSiQAAOUCr/O4cyCCxBEBBnMJXgHP +coAAHDsggkIhAYDKIWIAr+mP6AohwA/rcoogzA6KI4YDSiQAALECr/MKJQABJoIjgWG4oIHPcYAA +0B0kgSCB1bk9Zc9xgQB4FiWBBSk+ACd1SHDWD+AAQiWBEs9wgAA4OwAlgR8AAIgTwg/AAGUDD/Lg +ePHA6goP8kAQAQHPc4AATAlCEAIBJLOQ4UWzzCIshMohyQ/KIskHyiCJDwAABwLKIykPyiRpACwC +qfPKJSkAHwlyAADen3HPdYAARJOoIMAByWDcZQHmz34grCMKcgAA3Z9yz3GAAGSTqCBAAkAgAgiq +YrxhAeWvfUCsMYAgoxKA1QIv8gGj4HjgfwDY4H8A2PHAWgoP8s91gABsCcyNDY3CvsK4Fn7PfhoI +7/wN2Aa4gbgQvsV4z3GgAOwnBqEEhc9xpQDoDwahBYUHoYkCD/LxwBYKD/LPdqUA6A8mhqeGz3CA +AGwJAN8koKWg1g+v/A3YBriBuM9xoADsJwah5qZFJc0fp6ZJAg/y4HjPcYAAiCLPcIAA9AgAkEeJ +KwoBAM9wgAD2CACQQYkfCgEAz3CAAPgIAIgmiQ8JAQDPcIAAVCYAgALwANjgfuB44cXhxgDdMwnQ +BwsJ0wcLCRMAANgT8BkJ8wcf3k4h/AfgeKgggAEPJY0TYb4JCE4ApXgD8KZ4AKIB2MHG4H/BxfHA +Wgkv8ijYUgkP+c91gAB0JkCFCHYEIIQPAADw/wDYYHpBLAEBQIUB2EQmBBNgekEsgQBAhQLYYHpT +JkEQHgkv+QDYQIUId0EoAQID2GB6wLlAhUEvQRIE2GB6wLnPcQAA1LbPcIAAcCYgoM9wAQCwvFEB +L/IApfHAzgxP/IoIT/zPcQAA/LbPcIAAeCZSDu/7IKDPcQEA2LzPcIAAfCYgoNHA4H7gePHAtggv +8lDYqggP+c91gACEJkCFCHYA2GB6UyZBEECFAdjJcWB6hiH9D89xAAAgt89wgACAJiCgz3ABAAC9 +5QAv8gCl8cDhxdIO7/kH2F4NL/wIda4Pz/8eDk/8ygvv+alwyQAP8uB44H7geOB+4HjxwEIIL/JK +J0AACHUA38C4geDCJ8IBqXGGIf4DRLmpcoYi8Q9HugnYz3OAAJQ0DKsQqw6rD6tEJYATHHgNqwQl +jh8AAAAMSr64dtOrBCWGHwAAADBCLg4D2HbUq7EbwgNTIH6AyiHBD8oggQ8AAJEayiOBDwAAewDK +IsEHHPJXDxAARHgQcsohwg/KIIIPAACSGsojgg8AAIUAyiLCBwz0JHohCYAACiHAD+tyz3AAAJMa +htuKJMMPBQdv80olAAC26QohwA/rcs9wAACUGofb8vELDhMBIQ5TAAohwA/rcs9wAACVGo3biiTD +D9EGb/MKJYABCQ5CARsNUwAKIcAP63LPcAAAlhqQ27UGb/OKJMMPUyABAIYgfw8ceBlhL3kHCUMB +M6sJCYMBNKuKCmABANguCCAAqXBxB8/x4H7geOB+4HgA2Q8hAQAveRNpJXjPcYAAlDTgfwyp4Hjg +fuB44H7gePHA3g7v8QDbocEEuM9ygQCYFhR4HWIaYgGCbyZDEMiliiYEEs9y/v//P8mlBHqA4UDC +yiXBAAvyCIEEIIAPAAAAMEIgBYDKJWIATQ0QAM9wgAAczAAQBADIgQQkhg8ABwAABCaOHwAAADAs +vmG+QS4GBkAmgBMPIgIAQMKFDo8DCiHAD+tyPtiMuIojig7NBW/zuHbPcIAA5DIHiIHgzyKhAy/y +z3OAABzMz3aAAHzNmhaBEAOLCyEAgCHyTBaBEADbUyFOAEQhDwMPI4MDQr8A3g8mzhOGIf8DBCYO +kADfRLkEew8nTxDkeMomARCA48ojgQMOu2V6A/ABgwV6QMLPcIAAHMwggItyhiH+AyS5QCmDAyCC +BCGODwEAAMALJsCQFvLXdgAAAEDMJoKfAAAAgMwmgp8BAAAABPQBgAPwAoCuua+5sLkleACiABQE +MAQkgY8BAADACvQKIcAP63JG2Iy49QRv84ojiwkIhS65QCkCBgQdABFFeAiliiAFBgmlz3CAANDN +BIiA4IogBQ7KIIEPAADYAQmlqXAA2gHeHgkv/clzwK2dBe/xocDgeAolAIDxwBHyJw2QACkN0AAK +IcAP63KKIM0OiiMEBY0Eb/OKJIMPtgsAANHA4H5mCwAA/fEaCwAA+fHgePHA7gzP8Qh1z3CAAKwu +CYCJ6M9wgAA8LimADODwIE4AAvAB3oog/w8Apc9xgABcHwCBxBAABmkIXwH6C4/6AKUCCy/5qXCA +4Mol4hGi9C4LT/iG6ACFjCD/jw30z3CAAHgmIIBgeQHYgeAF3colIhGQ8M9xgADwFCGRz3OAAFgJ +QIM84TpiIYNk4hThWWEwcAHdwiVOE7N9wb188AOBGIgpCBEBVguP+gClz3GAAPAUIZHPc4AAWAlA +gzzhOmIhg2TiFOFZYeXxz3CAABw7AIDPd4AAiJBCIBCAagqv+sogYiAApQGHDwiFA1IJr/fJcQh2 +z3CAANAdBIDPcYEAeBYAgCWBSW7VuAUpvgAncGq4IIVIIAAAMHDKIEYARPcApUogQCDPcYAA8BRh +kc9xgABYCUCBIYE84wHdemJk4hThOmJQcMIlThOzfVMlTZAi8kEIUSDPcIAAHDv6D4AAz3CAADg7 +7g+AAM9wgADgO+YPgADPcIAA/DvaD4AAIYcRCaUDyXAWCCAAAdkE8NoPj//BA+/xqXDgePHAVgvv +8bhxgODKIcEPyiLBB8oggQ8AAEsDyiPhDsokIQC0AmHzyiUBAc93gABwOyaHI4Eggc9ygADQHUSC +QILPdoEAeBZTIk0FNroAIhAAPWVFhmG4BSo+ACd1AiVAEIwgF4dK989wgACIkCGABSm+ACd1ACBQ +ICENEABhDVAAmw2QAAohwA/rcoogjQ6Q20UCb/OKJIMPPglP+BHoz3CAAKQiLJDPcIAAXB8ekBMJ +AAACJYEfAAAADOlwBPDpcEIlARVmD4AAz3CAAIw7ACWBHwAAiBNWD4AAS/D6CE/4z3GAAOA7EujP +cIAApCJMkM9wgABcHx6QEQoAAChwAiWBHwAAAAwF8ChwQiWBFx4PgADPcIAA/Dvb8b4IT/jPcYAA +qDsR6M9wgACkIkyQz3CAAFwfHpATCgAAKHACJYEfAAAADATwKHBCJQEV3g6AAM9wgADEOwAlgR8A +AIgTzg6AAApwybjPcYAAiJADoQaGgbhJAu/xBqbxwOHFz3WAAFQ7Og6gAKlwz3CAAIguIIDPcIAA +jC4AgAkhAQDPcIAAEMsIgAkhAgDPcKAALCAwgKlweg6gAFlhGQLP8fHAz3CAAIiQAYAPCFEAz3CA +ADwuB4DPcYAAqDsggUIhAYDKIWIAkOnPcYAAgMssgYrpz3GAAGjLrg5v9yOBCg7v/wLZ0cDgfvHA +WgnP8c9wgADQHQSAoIDPcIAAHDsAgEIgAIDKIGIANr2H6M9wgAA4O44NgADPcIAAaMshiM9wgABw +O892gACIkIrpIIBCIQGAyiFiAATpIIat6WINgADPcIAAjDtaDYAAAYY6Dm/3CHEhhg94HQkFAAoh +wA/rcoogDQPX20okAABRAG/zuHPPcYAAqDsggUIhAYDKIWIABukdZSOGyb0LDUAQWg3v/wDZHQHP +8eB44cXhxqsKEABAIsMDJLvDugLwANqVChUEMyaCcIAAtEBAJ41yVH0gfcCIARmSAwHgARCCBAEZ +kgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmS +AAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIA +QiNDgLP1wcbgf8HF4cXhxiPqY2oiu8G6AvAA2jUKFQEzJoJwgACgQEAnjXJUfSB9wIAEGZADBOAE +EAIEBBmQAAQQAgQEGZAABBACBAQZkABCI0OA4/XBxuB/wcXhxeHGqwoQAEAiwwMku8O6AvAA2pUK +FQQzJoJwgACkQEAnjXJUfSB9wJACGZQDAuACEAIFAhmUAAIQAgUCGZQAAhACBQIZlAACEAIFAhmU +AAIQAgUCGZQAAhACBQIZlAACEAIFAhmUAAIQAgUCGZQAAhACBQIZlAACEAIFAhmUAAIQAgUCGZQA +AhACBQIZlAACEAIFAhmUAAIQAgUCGZQAAhACBQIZlABCI0OAs/XBxuB/wcXxwPIOr/FTIUIATiIN +Ac9yoAAUBMmCANsOJoIfAAAABlBxyiHGD8oixgfKIIYPAADGIsojhg8AAJsCyiRmACwGJvPKJcYA +gOHKJE1wyiLNAOggLQJOYM9xoAA4BAHiyKkdDVAQEQ2QEB0N0RDPcKAAOARoqM9woAA4BGioz3Cg +ADgEaKjZBo/x8cBGDo/xunB6cfpymnMKIgAhCiBAIch1CiHAIQonQJPPcYEAHg7KJ2IQEm8WeAhh +TCMAoAS4hiD+AwV/yiHMD8oizAfKIIwPAADBIcojjA8AAO4AyiRsAIgFLPPKJcwEHQieQc9wgABE +moDZKKAMwAPoQHiB8H4OT/9/8M92gABIPQGGANnmDW/zONoAhhzZIKABhhjZILDPcYAAXB8VIVYD +ABYBIFOBDcHwqM93gABcCigYQARFeaS5IaAA2TMYQgDpcSKgCiFAgzEYwgQyGMIENBjEBcohYgD+ +CW/3DOCF7c9xgACAnQTwz3GAAKCdI6bPcAAASBEAsRjYAqYNDVAgiiAFAgCxDMCF6M9wAQC4uQGn +ABYAILkQAAYtCB4AQYYa2ACyAqYAkYe4ALEA2AuxAYKtuAGiEQwQIM9wgABAMASAMxoCACkKECAh +hgGBmLgBoQOBn7gDoc9xgAAsCQAWACAAGQQEQIABgEGhAqHeC2//yXAZBY/x4HjxwMoMj/G6cHpx ++nIKIgAhCiFAIch1CiTAIQogQIPPcoEAHg7KIGIACHECuBZ4CGJMIwCgBLiGIP4DBSBQAMohzA/K +IswHyiCMDwAAvyHKI4wPAACWAMokbAAMBCzzyiXMBAzAjOgKIcAP63KH2Aa4l9tKJAAA8QMv87hz +FQieQc9wgABEmoDZKKAMwEB4Z/DPdoAASD0BhgDf6XFSDG/zONoAhhzZIKABhhDZILDPcYAAXB8V +IVYDABYBIDOBMxjCA893gABkChAYAgSkuY25mbkhoOlxIqAKIUCDKBgABTEYwgQyGMIENBjEBcoh +YgBqCG/3DOCG7c9xgACAnQXwz3GAAKCdI6ak2ACxENgCpgsNUSCk2Iy4ALHPcIAAXB8ZkI64j7gB +sQzAAacpChAgIYYBgZi4AaEDgZ+4A6HPcYAALAkAFgAgABlEBECAAYBBoQKhfgpv/8lwuQOP8eB4 +8cDhxc91gABgOACNjCDDjw/0z3KAAAA7BoIDgCCAx3EPAACgNgigAEhw/tgArdUDj/HgePHAWguv +8QDYz3WBANAQSiQAdIDeqCAABQhxAeBPIMIBFiVDEEeriiIIAAK5NnnHcYEAEA5AoQDaQrHGqcDY +fx0CEM91gACcCcCtz3CBAJANgNkKC2/zKHLBrc9wgADAItmoz3CAALAfXQOv8cWo4HjxwOYKj/Gh +wQh3Cg0v9BjYz3aAAFA1AYar6M9woADUCxiAAN1CIAAIgODKIEwDjCAIhUj3wRYAFgHgwR4YEBvw +ndgAHAQwC8zpcQIcBDAB4BB4BCCADwAA/7+PuAsaHDAAwB7aKgggABi6oaYD8GG4AaYaCAAAANiS +Dm/5QCYBEs0Cr/GhwOB44H7gePHAUgqP8Qh3GnE6cs92gABcHwOGz3WAAFA1FJAQuOoP7/cCpYDg +yiAiIM9wgACYCACAi+iFIQgkTyFAJ5+47HEAoexw4KADhgiADQgeAAKFgbgCpc9wgAD4CACIhOgC +hYO4AqXPcKAALCAQgM9zgADYNnIdGBBKJMBwANioIMAFz3GAANAIIImA4QzayiIhAEQovgPPcYEA +KBwncjMhggBAIwEDGWEB4ECpQCUOEi4NL/TJcA8IECAihQDYgLkipQPwiiD/D89xgACYCCCBZxUP +FmgVBBaU6QDbCPDsciCiBHkEHlAQAeOMI4KAIIa4989yoADUCy2iJHgApmcd2BNoHRgRANitAa/x +3B0AEOB4ZQbv/wDY4HjxwEIJr/HYcDoIIAAA3cloKw4SEPhwqXcyJoADFQgSDBEIkw6ODc/0Mm84 +eAV9AedCJ0cA5Q91gGG+cQGv8alwCHID8AHgIIj+6eB/QnjgePHA9giP8c91oAD8RB2FOYXCDyAC +AN4A2J64AaXgeMGlxaVBAY/x4HjPcaAAyDsOgYi4DqFpIEAA/vHgePHAz3CAAFwfA4AYiB0IEQEK +IcAP63KKIAwOiiOFCkokAAARAC/zuHO6Ci/0A9jPcIAAEMsAEAQAGQwRAAohwA/rcoogTA6KIwUM +6Qfv8rhzz3CAAIgdAJCB4AHYwHgMuCkIgQ8AAAAQz3CgACwgEIDPcYAArC4CoQLYA6HPcQEAfDPm +CG//AdjRwOB+8cAmCI/xz3WAAIDLL4VKIAAggOHKIcEPyiLBB8oggQ8AAL4hyiOBDwAASADKJAEE +dAfh8solwQDPcIAAih1AiM9wgABEmmB5SKA8HQAUCgov9ALYNQCP8fHA1g9P8ZIMYAAIdc9xoADI +H0WFDOhuEQ4GAoBkhcR6RXtuGdgAIoUAoQvwbhEABkR4bhkYABzYGLgVGRiABQCP8eB4gOAB2cB5 +z3CAAFw44H8goPHAfg9P8c9wgABwJiCAosFgeQTYgOCoAgEAz3GAAMgdAIEB4AChFwhRAAHZz3Cg +AMgcMaCyDSACKHCuDW/5BdjPdYAAPDIOpc9xgADIHQCBAeAAoRUIUQAB2c9woADIHDGghg0gAihw +A9gKDm/yqXEE2AIOb/IibQXY+g1v8iRtCtjyDW/yJm0P2OoNb/JAJQESNtjeDW/yQCWBEjfY1g1v +8kAlARM42MoNb/JAJYETz3enABRICIfPcacAmEcEpQ2Hz3KrAKD/BaUOh892oADsJwalHIEHpReH +CKUWhwmlGIILpRmCDKUagg2lz3ADAMYDBqbG2JC4BqbPcCwAAgEGps9wWQBCAQamiiCKAAamz3BA +AIcNBqbPcNEAwg0Gps9wwAAHDgamz3CAAMgdAIDPcoAAyB1CIECAAKIG9M9yoADIHADYEaIB2Ain +ANgNpw6nz3BQAP8AHKEA2BenFqf82c9wqwCg/zigfNk5oBqAz3GrAKD/gLgaoc9wKgACDgami3Aa +DCAAgcEAwc9wgAAIjzWlMqABwS+gz3AaAAIOBqaLcPoLIACBwQDBz3CAAAiPNqUzoAHBMKDPcCYA +Ag4Gpotw2gsgAIHBAMHPcIAACI80oDelAcExoM9wgADIHQCAAeDPcYAAyB0AoRMIUQDPcaAAyBwB +2BGh7gsAAgGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAGpgSVELiFII8ABqYFlRC4BSCADwAA +gg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbPcIAAyB0AgM9xgADIHUIgQIAAoQb0z3Gg +AMgcANgRoQSFK4UIpwWFDacGhQ6nCIUXpwmFFqfPcKsAoP84oCyFOaAthTqgXghv+Q6Fz3CAAMgd +z3GAAMgdAIBCIECAAKEG9M9xoADIHADYEaEpBW/xosDgePHAvgxP8X4IAADPdoAAjD1OCi/3AIYI +dQCGGQ0AEJoKb/upcAYJr/ugptIOL/QR2LoMT/bPcKAALCAwgM9wgABECekEb/EgoPHAug/v/6HB +z3CAAGQ4AIAE2WLaHttAwItwsgkv/xi7ocDRwOB+4HjxwHYO7/MW2ADY0cDgfuB48cA6DG/xB9ia +Ck/5CHfPcKAAtA/cgMYOL/8A2EoMj/vPdYAAZDi2D6/7AKVAhc9xgAB4PQChz3GAAMQ2SqFuDG/8 +C6GWDi//z3hmDy/56XDPcIAAnB0AiDcIUQBAhYogRATPdYAAjB0jhRpiOGAQcgHZwiFFAATYBenm +C4/0AIUE8M4Lj/QChRoP4AEDpRUET/HgePHAz3CAAFw4AICc6CoPb/gW2Jjoz3CAAHAmIIBgeQTY +EOjPcIAAXCZggM9xAQDk1AvYYHsE2sIO7/MW2NHA4H7PcYAAXB8AgcQQAAYPCF8BAYHEEAAGFQhe +AY4NL/QT2IYNL/QR2Ozx6vHgePHAz3CAABgZAIDPcYAARAkbeMIL7/QggQjoAdnPcIAAnB12D+// +IKjRwOB+8cAOC0/xCHd92A24z3GBAHgWxYGWDG/xyXGMIAKAz3GAABwZAN2H9x14jCACgAHlfPcA +KEIDBSq+A89ygAAYGRa4AKHPcYAAYDgAGkAOhO//2ACpAImMIMOPLA+B/xkDT/HgePHAlgpP8Tpw +enFId2h2CiQAIQDaz3GrAKD/WaEH2BqhWKHyCCACAdgZ2c9wpwCYRzqg5g3v+x7Yz3KnABRIHYK+ +gmwSEABwEhIAAKegpve4xSCCDwD/AADTIOEF973FJYIfAP8AANMl4RWWDG/2iiEQAAh2qXCKDG/2 +iiEQAAh1QCgAInoMb/aKIQgACHdAKgAibgxv9oohCADReRnhLHkvcbF6GeJMei9yABmAIw8PYhAA +G0AjANgE8P8Ig4AB2CkCb/EAHAIg8cDmCU/xCHUodkIIIAIK2AHYz3GnAJhHGqEyCCACCtjPcKYA +nD9kEAQAUSQAgMohwQ/KIsEHyiCBDwAAvxnKI4EPAAC4ABgB4fLKJSEAz3CnABRILIAdgACm97jF +IIIPAP8AANMg4QXpAW/xAKXgePHAngvv8wbYfgtP/M9wgABcHwOAGIgfCBEBCiHAD+tyiiAMD4oj +BgtKJAAAwQDv8rhzz3GAADwuCYELCBUBAeAJoc9xgQB4FgaBRiBAAQahz3CAADgJIIAVCZEAiiBG +D4IL7/kE2toM7/kE2NHA4H7xwM9xgACsLgmBAeAJoc9xgQB4FgaBgrgGoc9wgADkMgOIgOA4DqH+ +yiChACYM7/MG2NHA4H7geM9wgAD1FQCIGwhRAM9xoACsLxmB8LgZgc8gogPPIKECGaHgfuUCL/QR +2OB48cDPcIAAXB8DgBgQhAAdDBEBCiHAD+tyiiBMD4ojRwr5B6/ySiUAAM9woAAsIDCAz3CAAFw5 +Og0gAJYhQQ/PcIAAgMsMgBLoz3CAAIgdAJCB4AHYwHgMuBEIgQ8AAAAQygggAADYIPBKCk/8z3CA +ABQWAICW6M9xgQB4FgaBRiBAAQahz3CAADgJIIAVCZEAiiCIBHoK7/kE2tIL7/kE2I4KD/rRwOB+ +8cDPcIAA4DsAgEIgAIDKIGIAiOjPcYAArC4JgQHgCaHPcYEAeBYGgYK4BqEaC+/zBtjPcIAAgMsM +gBjoz3CAACQrAoAS6M9wgACIHQCQgeAB2MB4DLgVCIEPAAAAEKYIIAAA2NHA4H7PcIAA5DIDiIXo +4gyv/gLY9vH28eB+4HjxwM9wgABcHwOAGIgdCBEBCiHAD+tyiiDMD4ojygVKJAAA0Qav8rhzz3Cg +ACwgMIDPcIAAXDkSDCAAliFBD89wgAA4CSCAFwmRAIogCgiaCe/5BNruCu/5BNgB2c9wgAAkKyKg +z3GBAHgWBoFGIEABGglv/AahkgkP+tHA4H7gePHAz3CAAFwfA4AYiB0IEQEKIcAP63KKIA0PiiOK +D0okAABRBq/yuHPPcYEAeBYE2Aahz3CAACQrAdkioM9wgADkMgOIgOAMDKH+yiChAPoJ7/MG2PIJ +7/MI2NHA4H7geM9wgABcOfECAADgePHA2gnv8xPYz3CAANAdBIAggM9wgABkFCCg0cDgfuB48cDh +xc9wgAAEngOAz3WBAKwdEQheAATYCg8v9gSlHPAD2ASlANgIrc9wgABksBIO7/LU2QCFBOhhuACl +fg5P/gGFAeABpc9woAAsIBCAQg5v/gWljQYP8QhyANgRAC/3ENngeAhyAdgFAC/3INngeAhyAtj5 +B+/2QNngeAhxDQAv9wDYCHEFAC/3AdgIcf0H7/YC2JUHD/LxwM9wgABcHwOAGBCEAB0MEQEKIcAP +63KKIIwPiiMJAy0Fr/JKJQAAz3CgACwgMIDPcIAAXDluCiAAliFBD89xgQB4FgaBRiBAAQahz3CA +ADgJIIAVCZEAiiCJB+YPr/kE2j4J7/kE2PoPz/nRwOB+8cDPcYEAeBYGgYK4BqHPcIAA5DIDiIDg +pAqh/sogoQCSCO/zBtjRwOB+4HjxwIYI7/MU2LILj/LRwOB+8cB2CO/zFNjaDW/5BNjRwOB+4Hjx +wP/Zz3CAAGA4ggmv/yCoygnP/9HA4H7xwOHFAN3PcIAAVCagoJIMb/apcIog/w86Dq/yqXFVBQ/x +4HgFBE/38cDSDC/xSiRAAMCBoIAB39F1wiQCAdF1oYFhgMInzhMB3rFzwH6xcwHbwiPOAEwkAIDM +JiKQyiNiAAr0heuA5swnIpAD8gLbAvAA2xTrIQtQADkLkQCggMCBAYAhgQIljZOgogMgQAABohDw +ANgAogGiDPCggcCAIYEBgAIljZOgogMhAQAhorEEL/FocOB48cDhxSaAQIBCIgKAyiJiAIDiyiHC +D8oiwgfKIIIPAAA2Ecojgg8AAHcAyiQiAJADovLKJQIBYIEVC0AAQoCig0J9DQ1TEGCD9QtBgEGD +AaNgoEGgAKJEgKaAQCUDFhcKXgBGhQbqooJCgEJ9Bw1SEACjRICmgEAlAxcXCt4AR4UG6qKCQoBC +fQcNUhAAo0GACwmBAN4Lr/8GgCEED/HgePHAogsP8Qh2AIBCIAGAyiFiAADYJukmhkGGAd8wciCG +QYZBoSCiAKbPcK3eAgABpqaGwH8GhREOARCpcFYIIAAC2QalpoYHhQ8OARCpcEYIIAAI2QelBe96 +C6//BoYB2KkDD/EggBBxyiEhAOB/KHDxwDILD/EIdYoP7/8odgh3wqXiDu//qXCBAy/x6XDgeECA +FQoAAGSCCyNAgAX0QIL3CgGAANrgf0hw4HjPcqAAyB/0EgAAvNsYuwQggA///wDw9BoAAAvIZXgL +GhgwFRrYgM9zgADQHQiDANkgoAyDIKAJgyCgDYMgoAqDIKAOgyCgC4MgoA+DIKDPcAAMDwCkGkAA +DqIP2Ay4EKLgfuB48cCWCg/xz3WgANAb04URDp4Wz3CAAIA8SgkAAA8O3hbPcIAAoDw+CQAAEQ4e +F89wgADAPC4JAAAPDl4Xz3CAAOA8IgkAABEO3hfPcIAAYDwSCQAAvNgYuBOlqQIP8eB48cAyCi/x +ANsId892oADIH6QWABDPdYAA0B34YKQeABAB2BOmKIUMhUCBAIAAIsKDQKEshQEgwAAAoQLYE6Yp +hU2FAIFAggAgwIMAoQ2FASLCAECgBNgTpiqFDoVAgQCAACLCg0ChLoUBIMAAAKEI2BOmK4UPhUCB +AIAAIsKDQKEvhQEgwAAAoQSFAIByCK/z6XEkhQChBYUAgGYIr/PpcSWFAKEGhQCAVgiv8+lxJoUA +oQeFAIBKCK/z6XEnhQChD9iauA6mD9gMuBCmz3CAAGA8kgmP/891gACAPIYJr/+pcIIJr/9AJQAY +egmv/1YlABJyCa//ViUAE6EBD/HgePHAMgkP8Qh3IPAAhiGGIaAAoQDYAKbPcK3eAgABpqaGBoUR +DgEQqXD6De//AtkGpaaGB4UPDgEQqXDqDe//CNkHpSOGYHnJcK4N7//pcAomAJAI8gOHIIAChiJ4 +rwhSgAIJr//pcDUBD/HgeA/YmrjPcaAAsB8VoQ/YDLgXoeB+8cCmCA/xz3KAAHzNP4I6cKrBANgh +Cd4Cz3OAAFwfY4N0g0gSgQDA3WR5hiH/DiK5On0E8BTdAtiKEgEBAnkSggThjg6v9QDamgpgAAIg +TwMD2M9xoADIHxOhz3WAANAdCIUAgELADIUAgEPACYUAgETADYUAgEXABIXAgAWFABASAEARAAYA +2R9nz3CAAGiaQIABgAAiwoMBIEAAQMJBwIt3HwlRIMoMj/KEwRpw6XAyC+//hsIIdwgQAiEL8ILB +6XAiC+//hsIId89wgQB4FkSQz3GBAHgWZYEGwQS7FwtkAEAqgAIbCEUAAnn/CESABvCGwI4MYABI +cQhxRsEtD5EQfg5v88lwCHZKcHIOb/MGwQbCWnAEwwfBBcAAIsKAASBAAETCFfCU74IOb/PJcAh2 +SnB2Dm/zBsEEw1pwBsEFwAfCAiNDgETDAyCAAEXAGQ9QEM9wgABcHwOAGIiE4MwnIZAA2AP0Adgv +JgfwRPTJcA4Ob/MD2Qh3SnACDm/zA9kIdgDAAcFAIMCAQSEBAEHBBMFAwAXAQCHBgEEgAABEwUIJ +YABFwBUJESAEheCgCIUAwSCgDIUBwSCgJQmRIASF4KAIhQDBIKAMhQHBIKAFhcCgCYUEwSCgDYUF +wSCgFQlRIAWFwKAJhQDBIKANhQHBIKANB+/wqsDgeOHF4cbPcIAAXB/DgM9xgACctM91gAAAfFQV +ABbBoc9ygABUfQDbAqFAIgAGA6FkoXSpCOYUhcehLBnCAAihQCKACAmhQCIACwqh0BUAEM2hRBnC +AA6hQCKADQ+hViIAAhChwcbgf8HF8cBCDs/wGnBodWWKBIoIu2d4ALUHikaKCLhHeAG1QYkAiUoh +ACIIukd4ArVDiQKJCLpHeAO1BIkliQi5J3gA2QS1UyEPABQgziNBjlpxII4Iukd5J3hmCiAAEHgg +lUIhUSA4YCJvEHgUIEIgALUgikGKCLpHeSd4QgogABB4IZVEbzhgEHgUIIEgAbVAiSGJCLlHeSd4 +JgogABB4IpUG5zhgEHgUIMEjArVAiSGJCLlHeSd4BgogABB4I5U4YBB4A7VBjiCOCLpHeSd47gkg +ABB4JJU4YBB4SnE4YBB4BLUB4WMJdaAvebUFz/DxwGINz/ClwQh2AosodZhwZMAAiwASBgERHAIw +eXACEgcBBBIIARAUADHkkgYSBQEAIMkDAJEvIUgSByBAApIJIAAQeAAgigEBlS8iiBIHIIACfgkg +ABB4ACDGAQKVLyaIAQcggAFqCSAAEHgAIAcCA5UvJ8gBByDAAVYJIAAQeAAlBQAElS8lSAEHIEAB +QgkgABB4H2cFlfB/53gyCSAAEHgmlSFwEHgHeTx6D7klelB6ACKBAjB5ABxEMEeVJ3pceQ+6RXkw +eQAhggFQelx5AhyEMA+6RXkweQAhwgFQelx5BByEMA+6RXkweQAhQgFQelx5BhyEMA+6RXkweT9n +8H/8eQgcxDMPv+V5MHk4YGlxxrmFuQi5BSHBAiC2EHgglQocBDAneBx4CLgFIAABAbYAwAGmAcAC +pgLAA6aNBO/wpcDxwBoMz/CiwUogACAB389wgABICQCICyDAgyjyQCjNIM92gACctLR9uGa5ZgSA +I4FODC//Bdq4ZgKAumYhaCKiAuBBwLlmz3CAAJy0oGAhgb5mZIaLcn4N7/8Q4ADZACWAH4AAsLQg +qPt/739AIFAgLyAHJJsPEZIA2c9wgABICSCo/QPv8KLAD3tIuA94z3KAAABW9CIAAEAoAQJIuAV5 +9CLAADB54H8neOB48cDPcoAAUDwggoDhyiHBD8oiwQfKIIEPAAA0EcojgQ8AAOMGyiQhAMQCYfLK +JQEBAaIB2s9xoADIH1ChShmYAEgZGADRwOB+z3GAAFA8IIEA2IPhzCEigAL0Adjgfw94CiIAgPHA +F/LiD8//gODKIcEPyiLBB8oggQ8AADMRyiOBDwAA3AbKJCEAZAJh8solAQHPcIAAUDxAoNHA4H7g +eADYz3GAABDLBaEEgaC4BKERBm/zA9jgeDa4NrkwcNYghQ8AAIAA4H8ieOB48cCmCs/wCicAkM92 +gQB4Fs91gACAPA/0z3CAAFxUyXHiCS//FNqeDe/xqXBAJQAYEfAZD5EQLg9P8slxxgkv/xTaQCUA +GAzwyXA2CCABBdmpcHINz/HPcIAAYDxmDc/xBJYKuAWmBoaGIMMPBqb+CiAA6XDyC8/xlQLP8PHA +ANnPcIAA0CUaCCAAIKDPcIAAQDl2Do//0cDgfuB4ANnPcoAAoAkjoiSiJaImoieiIqLPcIAAXDwg +oM9wgAAAPSCgMbIwss9wgACYMOB/IKDgePHAz3GAANAlAIGU6AHYAKEA2c9wgABkFLYP7/8goM9w +gAB4HxCIg+BwCSEAyiBhAdHA4H7xwKIJz/CSDy/3pMGA4MQJAgDPcIAAZBQAgM9xgACYMMoO7/8g +gc92gACgCTCWUZZZYTBwyiAuAMIgTQBChs9xgABcPM93gAAAPY/qDehghxtjYKdggRtjYKHPc4AA +zDWygx1lsqPPc4AAqAhggwDdBwtRAKChIIFDwkDBIIdCwM9wgACYCACAQcGA4MogAQfKISEEyiKB +DwAAogDKI6EHWA5h/sArIQYA2NYNr/iLcc9wgACYCACAg+igpxHwAIcfCBQKGgrgAQDYBNjPcYAA +cH4IdIaxMLwOD+ABh7HPcIAAZBQggM9wgACYMKKmsbYgoLC2z3CAAKgIoKDSCm/zE9gAhx0IVAFe +CCAAAdiWDo/6z3GAAMQ2HYEB4B2hBfBGCCAABdjlAO/wpMAV2ADaz3GgAMgfbxkYAODYkLgQoQnY +sBkAALQZAAB42EIZGAAA2Jq4D6GkGYAAz3AADAAZDqHgfs9ygABAOSaCI4FhuGCBz3GAAGQUIIHV +uXlhz3OBAHgWZYMFKz4AJ3HHcQAAABDhBK//SHDxwOHFz3WAAKAJB4WT6M9wgADQJQCAHwhRAGIL +z/cXCJAGz3CAANAdBIAAgAWlAdgHpVEAz/DgePHA4cXPdYAAoAkHhRnoz3CAANAlAIArCFEAKgvP +9yMIkAbPcIAA0B0EgACABqXuDO//JYUwlThgELUA2AelDQDP8OB4z3CAANAlAIAXCFEAz3CAANAd +BIAggM9wgACgCSOg4H7xwM9wgADQJQCAJQhRAM9wgADQHQSAz3KAAKAJAIAEopYM7/8jgjGSOGAR +stHA4H7xwDYPr/CKIQgACHXPcKAAyB8woAHZQRhYAFYJAADPdoEAeBYDhiWG1bgwcMohzQ/KIs0H +yiCNDwAANRHKI40PAACbAMokLQBwBi3yyiUNAaoLT/KaC2/yCHcacIDlzCVikEr0z3WAANAdCIUg +hiCgDIUhhiCgAIUlhiCgBIUjhiCgOg0P9+UIEADPcIAApCIIiNkI0QEFhcCAAIAEJo4fwP8AAFMg +UQUEhQCAig0v8wpx1bhFhQV+AtvAos9yoADIH3OiyYUCIEGEYIZNhUCCCgAEAEIpwAcH8CSXCrkC +IUEEGWEA2AIjQ4ADIgEAYKYNhTvwdQ2REASXz3WAANAdIYUKuAChz3CAAFwfAIDEEAAGUSBAgQmF +IPLPcYAApCIoiTkJ0QHPcaAAyB8B2lOhKIUA2yCBTIUCIQGEQIIgoA2FAyLCAECgBIUAgOoML/MK +cSWFAKEK8CCHIKANhSGHIKAjhgWFIKAtBo/wANmWuc9woADQGzOg4HgDC55F4H7PcIAAgDwngAbp +A4BAgAKBQngF8M9w/w///+B+z3GAAFwfJIEogQQhvo8ABgAAocEE9BMJHwAJ8AQgvo8AAAAYA/IA +2ALwAdjPcaYApAAXoeB/ocDxwOHFCHXPcaAAtEdxEQCGBCCAD3AAAABBKD6F+PWKIP8PbxkYgGsZ +GIAD2g+6z3CgANAbUaAFhc9ygACAPVkZGIAGhUCCWhkYgAeFWxkYgAmFWBkYgAiFVxkYgAQggA8A +AACADwofAIDgBtjKIOEBAvAA2M9ygABcH0OCSILPc4AACAgjCh4ATyACAo26l7pGowUggg+AAEA6 +R6MFIIAPgADAUw/wBSCCD4AAwCRGowUggg+AAAA+R6MFIIAPgACAVwijhBEAhgmjBoVaC+/zIYX6 +Du//AYUJBY/w8cCGDK/wANo6cM9wgACUNAyIz3agALRHRCABDkIp0AAKdXEWAZYEIYEPcAAAAEEp +PoX59UMWAZZGIQENQx5YkFcWAZYEIYEP/2//w1ceWJBfFgGWBCGBD/9//8NfHliQANmeuVMeWJDg +eFMemJBgHhiQdgkP/M9wgABwJiCAYHkE2BboTCFAoPwJofrKIEEDz3eAAIQ9AI8VDQAQz3CAAAAo +NoBgeQDYAB8CFIoPT/JDFgCWRSAADZ+4Qx4YkI8JECAlCVAgZQmQIAohwA/rcoogWgqKI40CSiQA +AC0DL/IKJUAEz3CAAFwfA4AQvZu9MiCADwAA2AKfvYDgAdjAeA+4pXhfHhiQcRYAlgQggA9wAAAA +QSg+hfj1iiD/D28eGJBrHhiQE/DPcIAAXB8DgBC9MiCADwAA2AKfvYDgAdjAeA+4pXhfHhiQBsiE +4JAOIfPKIKEEkQOP8OB48cA2C4/wCHUodsYMr/ABgKCFELlBLQAUOGC2DK/wyXEQubB4OGCqDK/w +QC6BEnUDr/AocPHAAguv8LhwGQl0AZhxCiHAD+tyiiDaC7DbYQIv8rhzGw3UAAohwA/rcoogGguy +2wokQAFFAi/yuHPPcIAAUAgIc6ZoFCNDAQCTHQgeAgATBAEKIcAP63KKIFoLt9sdAi/yuHMAgg0I +UQBvIEMAA/AA2Jq4IYKeuAHegeEwisB+G77FeSV4IoLRioHhAdnAeRy5CL7FeQV5A4KgdVKKgeAB +2MB4HbgQugV6ANgArS8gBwGIuACzz3CgAOBERXkVIEABIKCpAo/w8cA6Cq/wBNkA2M91oAC0R0sd +GJAA2pC6dx2YkAHadx2YkM9yoACERBiiANqRuncdmJAC2ncdmJDPcqAAiEQYogDYkrh3HRiQdx1Y +kIDYdx0YkADYnrhUHRiQANicuFQdGJDPdoAAXAjJcKIJb/Ic2c9wgABQCJYJb/IK2clwIR0YkM9w +gADcBhB4SR0YkBkCj/DgePHAiOjPcIAAZJhuCW/yJNnRwOB+8cCSCY/wyghgAQh2qgyAAM9xoADI +Hwh1QNgPoUARAQYweYoNr/fJcNUBr/CpcOB48cBeCa/wSiQAcs9woACIIADeqCBAD3UO0BGggM9x +gADYy89ygQB4FtZ5aIlHgnpiz3OAAKTM1Hud7QAmjR+AAJzM+I0TD5EQ4JP7fyORgL8kf+CzBfAL +D1EQIpEgswDZOK3PdaAAyBz6hSCT5HksswTwLJMJCUUDWWEE8KyzuWKJIc8PBBhQAAHmANnPcIEA +eBY1Aa/wJ6DxwAAWBEAHGhgxABYFQAEaWDEEEoEwnOHKIsIHyiCCDwAA3A7KI4IPAAD0ChQAIvLK +IcIPag6gAA7Z0cDgfuB48cCCCI/wGnANyM93gADMzPAnARDPdYAALMwDEgI2CBhEIAGSgOANEgE2 +AN4O8hQlQxCAEw4Hyw4QEADegBucA/AbhAPgG4QDFCVDEMCzAYI9CJ8DyLPQG4QDEIrPcYEAEA4C +uBZ4G2FlkyULcgA4YGG7ZbAQinJodnt6YUWSeWGG6iaRUSFAgCQPwvENyAAggQ+AAEjMxKnMqdSp +z3GAANjLFnkUfSKRwB2EExV/eB1EEAMSATbApwGBBCCADwAAAGAtCIEPAAAAIBCJz3GBABAOArgW +eABh7bjKJmIQz3CAAJQe1HggkBDhILAD2c9woAAUBDCg6gjgAQpwPfBwEg0B4BMBAQIhTgMRDYQT +wn2ieBB4gBscAM9woADUBw8QDoYA3fAbhANwEgIBwBtEA0J5MHngG0QA0BMBAQHhMHnwEwUB0BtE +AFMlfoDKIcIPyiLCB8og4g3KI4IPAADnDcokgg8AAP4AmAbi8c8gIgMD2RMYWIBxB0/w4HjxwAIP +b/AA2M9xgAAoPQChDMzPdqAA1AdRIACAA9ggHhiQo8FS8hQeGJADEgE2ABYEQAcaGDEAFgVAARpY +MQTKnODKIsIHyiCCDwAA3A7KI4IPAAD0CjAG4vHKIcIPKHCCDKAADtkDEgE2EIlTIMIAhiD+A0S4 +UKnEGQIAArrPcIEAEA5WekBgz3KAAFwfLbjAuPAiAAAEorkQAgbPcIAA2MtAoA8WAJa0GQQABsh2 +C+/1DRICNgMSATaSEQABKgmv+5QRAQAq8EokQAAUHhiRABYAQAcaGDAAFgVAARpYMQTKnODKIcIP +yiLCB8og4gnKI4IPAABmAowF4vHPICIDAxICNrQSAAEPHhiQlBIAAA0IXgKyDo/3AxICNg0SDTbP +cIAALMwUIEMDKJOh6fCKz3GBABAOtXgCv/Z/4WGYEg8ALbnuoPagwLnPcIAAlB70IEEAvBpEANAT +AAEEIYEPAADw/8O4JXjQGwQABfDQEwABvBoEAAHYoBoAAJoLb/vwioDgqAMhAAMSDTYGyFEggIGc +AwIAIYURCZ4GkNiQuI0DIACgHQAQAr/PcIEAEA5AIIID9n/rYsQVghARCsAAkdiQuGkDIACgHQAQ +aoXPcqAALCDwgowj/48N8mJ/Fw+FHwCAAACH2JC4RQMgAKAdABDwjQK/9n/jYAQjvo8AAAAT+GA5 +8hMLXgKL2JC4IQMgAKAdABBXCx8DBZCW6AfIBCCADwDAAAAVCIEPAMAAABHYFLj5AiAAoB0AEIjY +kLjtAiAAoB0AEKQVABC0uKQdABCSFQARp7iSHQQQnhUAEae4zQIgAJ4dBBCF2JC4wQIgAKAdABBi +kDMVgBBNCw4AB8gEIIAPAMAAADEIgQ8AwAAACI0pCFMApBUAELS4pB0AEJIVABGnuJIdBBCeFQAR +p7ieHQQQCvARCZ4BjdiQuG0CIACgHQAQBshRIACAGAIBAH4Oj/8DEg02CHKoHQAQz3CAANAdBICw +FQcRIIBVJ0AG1bnPc4EAeBYLCQUABdgHowWDIniMIAmGyiElAKQVABAJIYEA8risHUAQ5/KYFYEQ +w7kHyDx5BCCIDwEAAPANEgQ2z3CAANjLFiAAAWWQrBUAEEEoCBMJIM8AfhUAEYAVAxEbY89wgABc +HwSARhAAARtjCCfPEGJ/mBUDEOi7ANiH8kQjAAYEI4EPBgAAACO4MbkB4Dhgz3GAAABYMiEGAAQj +hQ/AAAAAQS2FBTIhQAFBK4ECUiEBAMC5A7nAcBjhheDKIY0PAQCJDdUhDgCkFQAQSQgeBSJ/hBUB +EQInQBBIIAAAQrhBK0EDwLn0afR/aHHGuUkhwQU0f89xgABkT/FhDQveAkEpAwEUI0EABSk+AEEp +AHIA2VnwQS+FEEErTwPAvwS/9H9ocMa4SSDABRR/z3CAAGRP8GANC94CQSgPARQnABAFKH4BQSkA +coQVDxH5YUErTwPAvxDhBL9BKYUA9H9occa5SSHBBTR/z3GAAGRP8WENC94CQSkDARQjQQAFKX4B +QSkBch/wUSNAgsohAgAb9APnz3CAADxP8CBBACK/BSn+Ay9wUyADAHhghBUDER14J+MiuwUp/gAv +cVMhAwB5YT15z3OgAMQsL6Muo0AoARaeuUAsDwXleSV4wB0AEAqjz3GAAIAzAdgAoQXwT4KwFQcR +DwrFAQXYGLigHQAQz3CAACQJQYAglQkhgQAAiBEIUQAZFgCWEHEA2AP3AdiM6APYGLigHQAQz3GA +AEg2E4EB4BOhoBUAEAQgvo8BAQAAFPSSFQARlBUBEJAVAhGyFQMRdgugAUokQAADEg02oBUBECV4 +oB0AEAQgvo8BAQAABfLGCw/2CwNAAAPMz3GfALj/GKEGyFEgAIDKIUEDyiAhIHPypBUAEF8IngTP +cYAAgDMAgYDgAN4t8gDYAKF+FQ4RgBUAEc9xgABcHySB2GBGEQ4BHmYDCZ5Fz3CgAMQsC4BTIIEE +/rjMISKACfKYFQAQTg/v9ADadLgeZgLwAN4DEgE2CPANyM9xgADYyxZ5xZGpcUogACDPcKAAyB+s +FQMQiO6kFQIQsbqkHYAQBPAJI4MDA9oYuk+g+BACAKFqCCNDA0J7oBjAAADamLpOoAvupBEAAPG4 +DczFIKIEzyBhAA0aHDABkQjoDcjPcoAALM30IgAABegBgQ8IngMNzIC4DRocMGIP7/oocAMSAja8 +kkQlABPVCBABDcjPcYAALMwUecARAAFhgqV4HLIXC14DVBIDAbwSDQHDu6V7VBrEAIYg/QyMIAKC +GfQQigK4FnjHcIEAEA5lkCMLUgAGkBsIXgARC1EAYBIAAYS4YBoEAAXwHJKNuByyAZIk6NARAwFU +EgABw7tleFQaBACAEQEHhek8koq5PLKkEg0AFw0eEmgSAwFTIMEAeWEweWgaRAAVDV4SahKBAMO4 +OGAPeGoaAgAHyM9xgAA8zQQggA8AwAAADwiBDwDAAAAOGQQEBPAA2Iu4B7EBkhToDcjPcYAALMwU +edARAAFTIMCACvLwEQEBz3CgAJgDPqC2GkQApBIAAAQgvo8AAAAwB/SGIOWPrAtiAMogggAmD8AA +BehiDY/9qPADyKQQAAAEIL6PAAAAMLLy9Li4CcH0AxIBNqQRAACdCB4DPgzv8gHYAxIBNh2xz3CA +AFwfpIAaCW/4AN4bCFEAz3CAAIgdAJCB4ADezyYhE8omAhQD2M9xoAD0BwWhhSYCHQ1wwLADyF2Q +DXBAsAPIT4APCh4AQoUNcECgRpUG8A1wQKADyEAQAgENcECwA8hRgA1wQKADyEgQAgENcECwEBkA +BAPIlBAAAFEgQIJgD0H3RgsP+SMAQAABgSEIHgbPcIAALAkAkB2xz3CAADAJQIABgFGhEqEI8IYL +7/IC2AMSATYdsdYMz/0DyPYMr/94EAABgODiBwIAAxIDNgGDmBMBAJQbQAAtCB4Gz3WBAAgbqXCC +Cy/5aHEQ2AwaHDANzKO4DRocMMINr/+pcKsHAACeEwABvhMCAZIbBACQG4QAbgugAYITAwEbCB4G +A9nPcKAAFAQjoIogEAB/ByAABhoYMAPIpBABAIYh5Y8oCkIAAxIONqQWABD0uGgCAQCwjs9wgQDw +DLZ4z3KgACwgT4KEFg8RIJAIIsID4nqwFgMRZOPrC6UACSJBAFJtVnrPd4EAEA5CZwQijQ+AAwAA +N71lvYDlyiUMFAQigg8YAAAAM7oN4kohACAPIZEg44h6Cy/2mBYAEJgWAhAJIEEE7brKIGIgQCgD +IXR7SHDGuEkgwAUUe89wgABkT3BgDQreAkEoAgEUIgAAKLi4eAPgBCCADwAA/P/PcoEA+BYDos9y +oADELA2i7KIHyA0SAzYEIIAPAQAA8Cy4GLiduBS7ZXgFeSqiz3GAALw3CIEB4AihAQmeRc9woADE +LAuABCCND/AHAAA0vVMggQQLCJ4HHw2VEAMSDjZKIAAgz3GAAMQ2AYEB4AGhANgv8ACWEODnCEWA +pBYAEPe41SFCA893gQD4FiCnoqeYFgAQzgrv9ADaAafPcYAAxDYCgQHgAqEAgR1lz3CAAFwfA4AJ +gKChEQheAA3MRiCAAg0aHDADEg42AdhKIAAgkhYBETbolBYAEM9ygQD4FqKSwIJAwM9zpQCs/89y +gABcH9ijRIJWEgIBFOJCfQPlIr26ZbpiSCJCAAW6RSJCA1ajUSHAgcoggi8AAIAAIMEEIIAPAAAA +ICW4BSEBBCV4ibiOuBmjGgkP8ncFAACkFgAQp7mSHkQQtLikHgAQlBYAEJAWAxHPcaUArP9AwLAW +AhF4oc9zgABcH2SDVhMDARTjYnoD4iK6W2J6YkgiQgAFukUiQgNWoSDCBCCADwAAACAluAUiAgRF +eIm4jrgZoQPZz3CgAPQHJaANyJgWAhDPcYAAZMwVeUChpBYAEAh0hCQakBn0BCC+jwAAAAkI8t4K +r/3JcFYLr/0DyA3wcBYBEc9woAD0Byegz3CgAMgcHBgABAPIpBAAAFEgAIGkDYH0A8gBgBEIXwYu +CO/yBNgDEgE2HbESDS/4AN4bCFEAz3CAAIgdAJCB4ADezyYhE8omAhTPdaAA9AcZhYDgyiHCD8oi +wgfKIOIMzyAiA8ojgg8AAG4KyiQCBGQCovHKJQIEA8gckMV4DXEAsQPIPZANcCCwA8gvgA1wIKAD +yEAQAQENcCCwA8gxgA1wIKADyEgQAQENcCCwAxIBNhyRhiD/DD8IEAEzgQ1wIKADyFAQAQENcCCw +A8hUEAEBDXAgsAMSATYckYYg8w+MIAyACfQ2gQ1wIKADyFwQAQENcCCwAxIBNhyRhiD9DIwgAoIb +9GARAQENcCCwAxIBNqQRAAAnCN4FOYENcCCgAxIBNqQRAABkGQAEuBkCBLoZBAS3uKQZAACkEQAA +BCC+jwAAQAgH8gGB8LhUDoLyDvA6gQ1wIKADEgE2pBEAAIYg848E8juBDXAgoAHZK6UD2kilz3OA +AKQwDRINNkCDANg7DYAQz3KgADguRYIEIoIPwAAAACEKgA/AAAAA9dgFuM9ynwC4/xqiu6Jp2Bi4 +GaIocAcIUQCgo89woAD8RD2AGYBnCN8CBCG+jwAGAAAt9OB44HjgeFMIXkMDyM9xoADIH7AQAAGW +IEEPHqEQ2A6hAdgVGRiAog+gAEHYLwheQ89wgAAoPQHZIKADyKQQAQCauaQYQAC2DG//AdjPcYAA +vDcNgQHgDaFaDAAABCC+jwYAygCYcB7yz3CAAKQdA4CA4Mohwg/KIsIHyiDiCs8gIgPKI4IPAAA/ +BHgAovHKJQIBz3GAALw3EIEB4FsCIAAQoQPZz3CgABQEJaADEgE2AYFRCN4ApBEAAM9ygABcH1Eg +AIAEggPyu5AE8GIJb/e6kM9xgACUNBGJLQgeABCJI4IQuDIhgQ8AANgCn7iA4QHZwHkPuSV4z3Gg +APxEDaEE8HYRDQENzFMgQIAJ8gbIBBIBNioKb/UNEgI2z3aBAAgbyXCODe/4AxIBNgPIBhIQNs93 +gACQHqAQEQAB2ACnvg5v/6lwANkgpwnohiB+j9PyA8igGEAEBhoYNAMSATaSEQABEQieAqq4ugqv ++pIZBAADEgI2fhIBAYISAAGAEgMBOGAbYw3Iz3GAAKjMcHsVeQmBeGAJoQGC2QjeAFYL7/iA2AYS +AjYEIoIPAgABAA0SATcZCoEPAgAAABEIXgdPIcIADRqcMAbwo7kweg0aXDADEgM2AYNbCJ4BTyLA +Aoy4DRocMDCLEHozE4AAz3WAAIy0BLkleM9xoAA4LiSBBrUQ8C8uQRBOJoMXAN4PJs4QxnnPdoAA +4On0Js4QEQiAA/Hpz3AAAP//BLUD8GS1CNgMGhwwz3CAAJQ0EYgVCF4Bz3CAAOQywg9v/QCIDRIC +NwPIAYD9uM8i4gHQIuEBz3GAAEg2FoENGpwwAeAWoS3wENgMGhwwDcyjuA0aHDCGDm//yXADEgI2 +AZIJ6A3Iz3GAACzN9CEAAAvoAYITCJ8DDcgB2gAggQ+AALTMQKkNzFMgQIAJ8gQSATaKIAQApgkv ++5gRAQADyBqQqg+v+A0SATYNzB8I3gDPcIAAPM0DEgE2AoCYGQAABsi2C2/1DRICNu0G7++jwPHA +4cWpwYt1qXDPcYAA0EBCD+/vJNqpcJ4L7/gDEgE2xg8gAalw4Qbv76nA8cDhxQMSATaigSCFsg0v +/iTaju0KIcAP63JZ2Iy47ttKJAAAuQVv8QolAAEBhYDg4iACAKUGz+/xwB4Oz++YJMEzGnAA2E4c +GDAAFo5AABaFQAAWj0AAFpJACwpSIS8iByRMIgChyiHKD8oiygfKIIoPAAC1KMojig8AAFAAyiQq +AFwFavHKJYoEQS0AAVMgEYAr9FkNEACocoYi/AfPcIAAHMwjiEW6UyXNAEZ54LnKIEIDyiAhAFYk +zDkArOG5yiBCA8ogIQCLdIAkRB4ArFEhgIDKIEIDyiAhAIt0gCSEHgCsBfBTJf6AJvQA3YQqCiIv +dwAngh+AABC+KnGEKQQPBOIAIk4OyXAyCyAASNlWJgAZJgsgAAbZx3eAAHzAI4ctCREggbkjp04U +ATYkpyWnEPAKIcAP63IQvs9wAACvKG7bmQRv8QUmxBOCuSOnz3KAAMgIC+3Pc4AAoMogi3yLCwnB +AAQaAgQAghCIUnDKIIEDUAnh/cohQQQSDk/0MQXv75UkwTPxwNoM7+8A2c9woAD8RHQQBAB5gAQj +go8AAAAIC/QEJL6PAAYAAAf0A8ikEAAA0wieBs9wgABcHwSAz3GgAMgfRhAAAR+hINgOoQ0MngbC +DE/zDfBPDF4GCgiP8gMSATagGQAAhiB+jwP0AN8C8AHfiHBKC6AAaHED3s91oADUB9KlSgpP/c9w +gACQHgCAgODMJyKQA/QTHZiTA8igEAAAMPADEgE2GQzeBG8gQwCgGQAAiiAIAAYaGDDZ8VEkgIQA +2M8g4gX19aQRAAALCJ4GBdgQuO3xCerPcoAAQDcQggHgEKL28QohwA/rcgolAAgy2M9zAAAlCV0D +b/GMuChwQQTP7/HApBABAA8JXgK+D4/90cDgfih0hCQSkBHyDQlfBi4MD/YH8CDZz3CgAMgcKaAD +2c9woAAQFCWg6/Hr8fHAlgvP7wonAJAacQDdFvLpcS8oQQBOIIIHz3CgAAwtT3rwIIAAwrgPJQ0Q +ANgPIIAABiEBgO/1JO0vKEEDTiCOBw0amDP12AW4kgvv9slxDcjPcaAAFAQKoc9xoABkLvAhAQDT +uQpw7g/v9OR5Sgzv+slwANgPIIADBiUNkN/1z3KAAKQwAIIH2Q0aWDA/CNABz3CgADguBYAEIIAP +wAAAACMIgA/AAAAA9dgFuM9znwC4/xqjO6Np2Bi4GaMB2ALwANgHCFEAIKLPcKAAFAQqoCkDz+/g +ePHA4cXPcIAAMM/PdYAA6glgjUGIhCsfAAAhgX+AALDS/gkv/gLiII3PcIAA6AlAkIQpHwAAIYB/ +gACUz/0C7+9AsOB48cCCCs/vKHZGIc0AHWVKCCAAIrnBvh8OUBATDpAQHQ7REAAWgEABHRIQABaA +QAEdEhAAFoBAAK21As/vgOHKJE1w4HjoIK0BABaBQAEYUgDgfuB4qwkQAEAhwgMkusO5AvAA2ZUJ +FQQzJkFwgACQQEAnA3I0ewB7ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQ +AAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAA +ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUABCIkKAs/XgfoDhyiRNcOB46CCtAQAWAUEC +GFQA4H7gePHAYgnP7wDdz3cAAAQdSiAAIql2FSKAMw4QAQYA2M9yoAAUBMqiqKInogSiPWWI4Wi5 +yiEOAHIJ7/bpcEIgUCAg59UIdaAB5n0Bz+/gfwDY8cAGCc/vGnDPcIAAoD0yIBIEz3CAANAI0YgS +iEojACAQdqHBVAEpAAAcwDRqdwohwCQD8Hp1RC6+EwAiQC7PcYEAKBwzIQ0Au30xCDMmrX3PcYAA +IBcagTuBJHgdCB4Cz3CAANAIC4iLc8lxKg8v96lyAMACfa19ACaAH4AA0AgcEMEAz3KAAGQ4AIoF +2uYOIACpc89xgABwPSCBAN1KJIBxInioIAAFc250e7V7z3KAACSQeWIhiXpiC+khCQAAJwhCAC8N +UxEB5a99CvBCJZEQLyFHJGG9r30R8AMSzwAA2Wp1DPCA5UohACDKJWEQBfJCJVEQLyFHJAHZLOnz +bvR/FSdBE89zgAAkkDpjACNFABUnTxT5YyGJQYr7YzcJowDjiwIiRAADFYIABL/wfyJ4BLovJAgB +AieDEGx4LyBGDpIJ7++IcQ54An8I5+5/RL/tfwkIEiYK5+1/yXAKcXoMIADpcgHmz3CAANAIEojP +fhB2wAbM/+UHr++hwOB48cCWD4/vKHWA4swjIoAJ8ixtL3nPdoAA0Agzrgbwz3GAANAIs6mpcc92 +gADQCLSuAK5VrvoJIAB2rgAQiQDhiMlwEojRjhB2mgEJAEQpPhcvcYQuAxEKJkAOACFDDgolgA+A +AJyQoHNAKYIQVHqELgEVCidADgAiTQ4KIIAfgQAsGwAgRBMAJo0fgADQCEwhAJDMIWKQJ/QaE8AA +ANkYrRsTwABKJIBxHK0YiyAdAhCoIAAGFCRAAEGIs260fTV9x3WAACSQABDAAECtFSNCAAGtARLA +AAHhAq0Aii95A6148AETwACZ6ADaWK1crSAdghBKJIBxANmoIIADE24UeDV4x3CAACSQQKhBqEKo +Q6gB4S95XvB8uQAhigE6i2y6ACJAERqI4HIAIgYC7gggAOlyGK0AIkARG4g7i94IIADpchytACJA +ERiIOIsAJYUCygggAOlyIB0CEADdSiCAERQmSgMUJEsDARKAEAETgRCqCCAA6XIzbjR5tXnHcYAA +JJAAqfhxABKAEAATgRCOCCAA6XIBHwIAFSVLAxUjSgMBE4AQARKBEHIIIADpcgIfAgAAE4AQABKB +EGIIIADpcgMfAgBCIEgQAeWZCHWQr30B5s9wgADQCBKIz34QdnAGzP8A2c9wgABsPRUGr+8gqPHA +z3CAAGQ4AIDPcYAAaD0ggU1oMHLAIGwBzCEMgCQLCQDRwOB+4HgCeS15THlWIQFyR7k4YOB/D3jg +ePHAuHE1CFEACQ1SAB0N0gMKIcAP63LPcAAA1xSKI4gCxQQv8UokAABALYEAZLkAIYAPgACMER3w +z3CAAPQUMiBBAYwhw4/KIcEPyiLBB8oggQ8AANgUyiOBDwAAEAKIBCHxyiQhAM9wgAC8EzV40cDg +fuB48cDPcoAA4ggKaqIJIAApasYNAADOCAAAz3GAAJhYIIHPcIAATBAiCCAAAdrPcYAAlFgggc9w +gAB4Dw4IIAAA2tHA4H7xwKoMj+8acEh3kQlyAADdOnEVIEAjQIgCiAzvz3aAAIwRFX4CuBR4x3CA +AOQQC/DPdoAAvBMVfgK4FHjHcIAAxBEhiEsJHgAFEMEAIq4GEMAAA67pcH4MIABIcQCugODMIGKA +yiAhABLyRCg+BwAhgH+AAJiQxRCDAOEQgQACIsAAEHgHuOoNr+9ieQGuQiFBIIEJdYAB5XEEj+/x +wBYMj+/PcIAA0AgREIgAz3CAANAIEoirCAICSiYAAEohwBFELj4HL3CEKAMRJ3AAIIEPgACYkB8R +ywAAIIEPgACYkB4RygD4cADeBt8AJ40PgACYkNV9B41pcQXamHASCiAABRXDEEAuggBUeoQoARUA +IkEO1HnHcYEALBu4cQCpiHBJcQfa6gkgAAYVwxABHQIAYb8B5rcPdZDPfkIhSRBAJkYAgQl1kC8m +hwFAIEgQz3CAANAIEogvIAcSYQgDgr0Dj+/geALbYKgA2ACpAdjgfwCq4HihwfHAOguP76HBZcII +dih1z3CAAPYIhcGLckAkQzCCCyAAAIhELr4WACVAHhQUwTDPd4AA6JL4YHcNMxYgqFMlgBBNCFMB +RiXNEa99G/ABFIAwACaBH4EAmBhSbVR6WWEgwgCpRC6+FgAlQB5EqRQUwTD4YCCoyXBeCCAAqXEB +5a99UyWAEMsIUoEh8AEUgjASbRR4ACaBH4EAmBg4YECoIMJEqMlwMgggAKlxD/BCJQAWD3gBFIEw +x3aBALAZArgUeB5mIMAorgyuCNzbAq/vocDgeOB+4HjxwGIKj+8A3s9woAC0D3AQEAD2DG/9yXDP +cYAA0AiyiXGJJQ3CEM9ygACImH/YFCPPAF9nAK/BrwHjb3sF2PEN45ACr89wgACYkEGQz3WAAHA9 +wKUa6s9wgAB4PQCAjCAfhNT2JQiDDwAAoA9CeECJgOKKIQ8KwCjiAAX0RCi+Ay9woguP7wClAN0O +3s93gACEP8II7/+oZ2G+AeX3DnWQr33PcIAAZDgggM9wgABoPSCgVgxv/S8gBwQNAo/v4HgOeCx4 +KWoA2A8gQAAncFp44H8OIMAA4HjxwH4Jj+/Pd4AA0AgAjxoM7/8zj89wgABkPQAQ0ADPcYAAiCIU +j0eJHwoBAACPIYkXCEEAz3CAAG09ABDAAAkgAAQvIAUgsY8D8AHlr30SjxB1/AAJAADeSiKAI89w +gABlPQCIEOhELb4TACZAHs9xgABkPQARwgAAIIEPgQAoHECpX/DPcIAAcCYggGB5ANgZCBEDz3CA +AHQ/yWACIEAgDXhIIEAABPBIIEAgLyEFIM9wgACEP8tgE4+pcXYJb/ZVjwkgQAQvIQUgz3CAAHAm +IIBgeQDYACWTH4AA7AgbCBAEz3CAAHAmIIBgeQDYBBOBIBsIEQPPcYAATArJYQQTgCAieAkgQQQI +8M9wgABkP8hgAnkJIUEERC2+EwAmQB7HcIEAKBwgqDpwE4+pcUoPr//JcgARwSACeQAZQiBCIlIg +AeYZCnWgz36B8YkAj+/xwD4Ij+8Idc9wgACrJgCIKHcTDQEQz3CAAKomAIg9DwAQz3aAANAIqXBA +JoESNgov90AmwhIqjgRuRgkv90uOCo7+D+/2K47PcIAAqyagqM9wgACqJuCoTQCP7+HFmeiMIcKN +AdhZ9kokgHHPc4AAeJGoIMADoWtEKD4HMiVNHhcNQxAH7RMIkAEB4A94ANgD8GG4D3jgf8HF4Hjh +xeHGABHNAAkNExAA3aCpG+gNDRMQANgAqQDdz3CAAGQ+AJALDQIQqWitfaCpz3CAALw9FCBOA6CO +oKoAEcEANHgBiBnwCw0TEADdoKnPcIAAED8AkA0NAhCpaK19oKnPcIAAaD4UIE4DoI6gqgARwQA0 +eAGIAKvBxuB/wcXgePHAJg9v7wDYocEAHAQwz3WAAIgJAJXPdoAAmJDJcYoiBAp+D6/2AduP6Aoh +wA/rcgAVBBHPcAAA2xSH24u7YQbv8IolBAoAFoQQTCQAgcohyw/KIssHyiCLDwAA3BTKI4sPAACM +AM8j6wI0BuvwyiUrAGoPD/aA4Mohwg/KIsIHyiCCDwAA3RTKI4IPAACSAM8j4gLKJCIABAbi8Mol +IgCLcUXYAdr6Dq/2AduP6AohwA/rcs9wAADeFJXbi7uKJEEB3QXv8EolAAAAFAAxAdmGIP4PwODA +ec9wgAD0FSCosQZv76HA4HjxwD4OT+8Iddd1JQAAgADYSvfPcYEAeBYlgSUJRQMifQHg+fHPcIEA +eBbFgKlwqg9v78lxBS4+EAIlTR6MIBCAyiHGD8oixgfKIIYPAADNIsoj5gzKJCYAXAXm8MolBgEW +uEkGb++leM9xgAAkCQ0IUQAB2ACpAakAiYHgyiCBDwAAxAnKIIIPAACAAOB/AaHPcoAAQCkgihlh +IKohijhg4H8BqkGJArgWeMdwgQAQDkioIongfymoz3GgACwgMIE4YM9xgACsLuB/BaHPcYAAXB/w +IQEAiiAIAOB/DqHgeA0SAjYEIL6PYAAAAM9zgAAszFR7x3KAAJzMCHEF8gPIHJAXCJ4CBCGBD2EA +AAATCYEPAQAAAADYALMB2BzwDMwDEgE2GwjeATIRgQABiw0IQQAA2AGr8/EB4AGrC/AxEYEAAIsL +CEEAANgAq+fxAeAAqwLY4H8YquHF4cbPcoAAwAiA4MAiIgH/3RJpFngAIIMPgQAXDqCrAN1KJABx +z3OBAPgVqCCAAq5ieGU2eMSormIB5a99wKjBxuB/wcXgePHAngxP789wgAAgGQCAocGbCJAAz3aA +ANwyz3WAAOAyAIUghmUJAADPcIAAqCUEgEDBDQieAE8hAAFAwIjpAg1v9ADY4gxP9MoNT/bPcIAA +mAgAgIDgyiABB8ohIQHKIoEPAAChAMojYQ+ICSH9wCvhBSCGCekAhYfoxgxv9AHYogxP9iCGIKUR +6f4NT/R/2Aq4z3GgANAbE6F/2BChANiVuBChRg/v8QHYYQRv76HA8cDqC0/vz3GAAFwfFXlAgQiC +BCCDD4AAAABEIA8CL7sGv2V/BCCDDwABAABBK04D5X4su8V7wRIOBsASDQZhC4ADBCC+j4ABAAAe +8s92gACkIsiOMQ7REb64CKJAgQiCBCCDD4AAAABEIAECL7sGuWV5BCCADwABAABBKEMDJXssuAV7 +wRrYAArtLylBA04hgAcSCCAAECUNEPnttQNP7/HASgtv75hwGwgUBAohwA/rcnHYjbiKI40LrQLv +8EolAARKJAB0ANuoIIAOQCyNAXV9QCyCAMd1gQDQEQCFz3GBABAOVnrduEFhAKXxudEgIoII8kQg +AgYjugHiFQqVAM9ygQBQEBYiAgFAigkKHgCeuBTwLbnAuc93gABcH/AnTxBSIE4CwRcBFgshgIMH +8iiH4Qmeh5+4AKUB4xUDT+/PcYAAXB/wIQAAz3GAANjLuxACBroQAwZCoWGhvBACBr0QAAZFoeB/ +BqHgeM9xgABcH/AhAADPcYAA2Mu+EAAGFiECAAKSGrEDkhuxCIo4GQIAANjgfx2x8cDPcIAAmAgA +gIboRgpv9lTYA/AA2EQgAgIbCB4BANvPcZ8AuP99oQLbz3GAACAZYKHPcYAA3DJRIECAAIHPIGIA +0CBhAAChPQieAM9xgAB0PQCBMQoAAM9wgAD3FQCIQKEXCFEAz3GAAJwyAIELCFIAargAoQHZz3CA +AJwdng3v/SCo0cDgfuB+4HjgfuB4z3GAAEA3XBnAB524nrjPcaAAyBwNoeB44HjgeOB44HjgeOB4 +4HjgfvHAINvPcqAAyB9wokMaGAAA2MoP7/+NuHGi0cDgfuB48cByCU/vocE6cCh2GnLPd6AALCAw +h89wgAA4MiCgEIfPcYAAODIggc91gACoMCJ4AKWLcToIb/AqcACFEwgFBAAUADHEeNsOAZAB2ALw +ANiBAW/vocDgePHAz3KgACwgQBIEAEASBQAPCd8CBCC+jwAGAAAg8kEJHwPPcQAAECcD8EASBQDP +cKAA/EQZgOy4AiUAAQP07whCgB0Igg8AABAnCiHAD+tyiiCaCmnbSQDv8Iy70cDgfs9woAD0B/HA +VwgeQyeAGYAweThgA7iWIEIFz3GgAMgfHqEQ2A6hAdgVGRiA1g7v/4HYLwgeQ89wgAAoPQHZIKAD +yKQQAQCauaQYQADqC6/+AdjPcYAAvDcNgQHgDaED2c9woAD0Byqg0cDgfvHAANkK2M9yoADIHx6i +ENgOogHYFRoYgChwB/AB2QQggA8gAAAAUSAAw8whIYDMICGAEvQhCx9Az3KgAPxEHYJZggDZ2Qrf +ggQgvo8ABgAA5vXn8S0LHkDPcIAAKD0B2SCgA8ikEAEAmrmkGEAAXguv/gHYz3GAALw3DYEB4A2h +USAAwwDYCvTPcYAAQDcQgQHgEKEA2Ji40cDgfvHAvg8P7wh2z3CgACwgsIAL8GoJT/DPcA8AQEI2 +CO/yqXEfCFAAz3CgANQLGIBCIAAISCAAAN8IhIPxBw/vCiHAD+tyz3AAAM4iXtuKJMMP5Qav8Lhz +4HjxwE4PL+8B2aXBGnDPdYAAwAhadSYNb/+LcAAUhTABFJEwCwhRIEAlEhELDVIAHQ1SAQohwA/r +cs9wAAApJazbnQav8EokQABMJQCAJgEOAKhwABaOQAAWlEAPDDIkenCMJMOvJfQAFgBBABaPQAAW +gEAAFgBBhQwTJCjvz3CAAOgUAIBALM0gtX0Q4Lhgrgxv/wTZz3CAAOgUAIBMIUCgHWXMJ2GTGvQA +2Iy4F/AKIcAP63LPcAAAKiW320okQAAdBq/wCiUABQohwA/rcs9wAAArJcDb9PEA2AC1z3CAAOgU +AIBALMEgNXkyYDhgBSJCBECwBN0H8IHABN0+DG//qXEAIowjABwCFc9wgABcH/AgAAQe38AQAgYv +KYEAAidAECTqMmjPc4EAFw42eStjEwuOAwAmgR+BAPgVFnkAGQIFAC2BEwshwIAJ8gAmgR+BAPgV +FnkEGQIFECICgC8pgQACJ0AQ4PVCI0AggODmBs3/Hg+P8y0GL++lwOB+4HjgfuB44H7geOB+4Hjg +fuB44H7geOB/AdjgfuB44H7geOB+4HjgfuB44H7geOB+4HjxwLYND+/PcIAATDXPcYAAkOrPcgAA +YCJWDmAAAIBqDk/2LghAAEYLAADPdYAAcCYghWB5A9gG6CCFYHkE2ITovg4P/s9wgAAAfADeyXFq +De/wiiIFBc9wgAA8CcCgz3CAAKUIwKjPcKAALCAwgM9wgACQCM91gABwfiGgz3CAAKB/wKCpcMlx +Lg3v8IoihAv/2JEFL+8QrVEiwNHPcoAAfM0A2QPyNJLDuR+Cz3OAAKAyUSBAgs9wgAAAfNUg4gzV +IOEENngAoyKQe5IlCcIAJQtCACGQepIZCcIAGQtCAACQOJINCEIADQkCAAkK3lIB2APwANjgfvHA +ugwv7wDZvgkgAAh2CHcDkM91gAA8Cc9xgAAIRQK1cgkgAOlwkujPcYAAAEVmCSAA6XAR6AKV13AA +AIE3zCCCjwAAgPMJ8gOWCOADtg6WaLgOthfwz3GAABBFEgkgAOlwLpYJ6AOWZLkutgTgA7YI2AK1 +B/AveAi4KLkveQV5IrXJcGYJIAAA2c9xgACUmAexApXXcAAAiI4MD2H2yiCBA4EED+/gePHAEgwv +7wDbS4CykEokgHFodl1lUyVAEE4gBAEAJEIDqCAAAgEVjxTIYQHm53gFe7HrSiSAcQDeqCAAAgEV +jxTIYQHm53gFe6XrANhMJACAyiQNceggLQIBFY8UDmEB4Od+xXuX60AiAAMD8AzgViKOAtFw4IDA +gud+xXtN9+GAwYLnfsV74oDCgud+BSODg+7zANgW8AGAQYIHegUjg4BQ5fn1QCSOABUOlREBFYIU +yGEB5kd4+Q60kQV76+sB2LkDD+9AiWCIDQuBAEGJYYgJC4AAANgH8EKIAon5CgGAAdjgfw944HhA +kWCQDQuBAEGRYZAJC4AAANgH8EKQApH5CgGAAdjgfw944HgIcc9wgABMNVEDYAAAgOB4S4ADkFhg +4H84YOB48cDhxauAA5C4YDhgSHE6Cm/9aHJNAw/vS4ADkFhg4H8wYOB4z3CAAEw1AIARA2AAANng +ePHAugoP7891gACUJgCFAN6E6KoJAAAApQnoIpCH6VoNAAD58boJAAAApQbowpBTJg6R+vPPcYAA +PAkggcS5BSZOkA3yLy6BE89xgQDUH04mghfwIYEAQHkI8M4JAACA4IAMovHKIGIDvQIP789wAgC4 +JM9xgQDUHwShz3ACACwmA6HPcAIAZCUCoc9wAgAEJAGhz3ACALQk4H8AofHAFgoP766QCHZDDXIQ +45ALhgzg8GAPeQi5KLgFeS62QCeAEw7hA7YDaR8NZBBGINAAIgggAMlwAiUNlAJ31Afv//B/A/AA +2AK2MQIP7+B48cDhxQ4N7/8IdT4LIACpcGYKIACpcC0CD+/geOHF4caggWCAwYFnfWCCpHuhgKd+ +oYLEfaV7ooHCgKd+ooLEfaV7o4ADgQd9A4KkeAUg/oAB2MB4wcbgf8HF4HjxwG4JL++4cgh1KHfP +doAATDWYcwXwSHA2CmAAIIHaCWAAAIZAJQEcGwhlAECGAYKA4ADZBPIgggeCGWHt6QDYFvAyCmAA +SHAS6DDZIKDusADaIBiCACgYAAFAIAEMK6AGGEQBU7BCsCEYggBpAQ/v8cDPcoAATDXGCWAAAIKF +6ECCAYKD6ADYBPAAgieCOGDRwOB+8cDaCA/vz3GAAEw1IIFAkGeBwIECIM8AGw+iE11nwn3BgcJ9 +GQ0SEAOBGQ0DEHhlCfBigSOBYn0JDUMQWGAD8ADYAQEP7+B48cDPcIAATDVaCWAAAIAH6M9wgAA8 +CQCAA+gA2ALwAdjRwOB+4H8LgOB/C4DxwFIID+86cEAgEwIodhpyTCMAosohwQ/KIsEHyiCBDwAA +uyHKI4EPAACyAcokwQCwB2HwyiUhAM9wgAB8PQCAhCgCJaRoJ3WRFYAQCQhVBADYNfBCIBIELyKI +JEAllBAqcBIN7/8A2UAlAhgvJYgDCSWBBDB5PQlSAADde20yJMMgRCWOEQAQBAHae8G7z3aAAAxP +9CbOEGCSByMDAQsjgIMP9ALlrn0C4tUNYpAC4AwlgIQB2MIgCwDtB8/uANgAINAkABgCICERgCBh +uA94IRkCIL7x4HjhxXKQBfAA2lGwAeNwe0FpHwrCAEuAbWKMJcOfUZDAImEA9PPjCpKBcrAB2APw +crAA2OB/wcXgePHA4cUIdc9wgQBUHACAgQgeAA6V5uB4AAsAI5UA2oIgwQdRtTK1GWEweaIP7/+p +cIDgAdgJ9AKV4rjMJSKQBPKiuAK1ANhJCFEAz3GAAFwfqXD2Cu//I4EilUQhAgES6AXqLgsgAKlw +EugB2M9xgABwfgh0hrEwvCINIACHsQjwgOLMJSKQBPKiuSK1QQfP7vHA4cURCFEA8g1P++oMb/sA +2AzwBNgA2ShyQg3v/yhzz3GAAJQmAKHPdYAAlCYAhZIL7/8AgFIMIAAAhQEHz+7xwIIOz+4IdRIO +7/9AIBACCHbPcIAAfM0AkM93gACUmBcIHgJAJgAU6XG+Di/9A9pAJoASCPAEbulxrg4v/QPaQCYA +FCZvog4v/QPaz3CAADwJApAGtwDeD/AB2C8mB/AAIIwjAKwI8iEVgBAB4A94IR0CEAHmz3CAAHw9 +IIAAgS0OBRCELgIVJ3EOlZURggAQ4BkIhADpcFRux3KBAGwcOgzv/xTh2+gA2NrxIRWAEDToA5UA +3gLgA7UOlWK4DrUC8AHmz3CAAHw9AIAAgEEOBRAyIIAjd+jPeqlwRg3v/3DZcegClQ8IngDWCSAA +qXAU6ALaz3CAAHB+SHEmsDC5J7DQqMYLIABIcAjwA5ViuAO1DpUC4A61zQXv7iEVgBDPcqAArC8Z +ggDZqbgZokDaz3CAADwuQaDPcIAAkAjgfyCo4HjxwAhzz3CAAEw1AIAWDiAAIIMAg9HA4H7xwC4N +z+7PcIEAEA4OiM91gACkCECNBLiA4sokInLKISIA6CDiAgDeDyZOEAsmgJAK9AHhL3nPcYAAPAkA +gaG4AKEK8MZ6QK2GIP4DJdoGCS/wANtFBe/uAdjgePHA4cWjwc9ygADQCWKKIYrPcIEAEA6jigAS +hAAEI4MPAADA/w6IJdpCK4UBQMIA2wS4hiH/AEHDQrlCw4Yg/gMB2thzsH3eD+/v+HUB2PkE7+6j +wOB/ANjxwAXoIpCkuSKwEg4P9MoKb/4A2M9xoACsLxmBibgZoQHY0cDgfuB48cBSDM/uz3WAAKCx +B40E6AaNBa0A3roNL/bJcAWNJo31CQGAxq3Frcetz3CAADwJjQTv7gCA4HjxwM9wgACgfSCQQZAH +CYMAIbAGDAAAz3CAADwJAIDRwOB+4HjxwOHFz3WAAKCxygwv9kAlAB9eCM/4ANhSHQQQz3CAADwJ +SQTv7gCA8cDGC8/upMFaC+//CHUIdiSOUSEAgM9xgABUfQCQBfJAIQ8EA/BAIQ8CRCABAxUJEQII +cYYh/AOMIQKAAtlD9gDZGOHouNEgYoIG2AL0ANg4YA942GBAIBACqXB6CO//LpUCIAQEIJYA2FEh +wIEvJAgByiUBAAXyDJZTIMUACiYAB0AkBzHpcCRuQCYCFEIK7/UKc6lwQgjv/y6VgsGKCi/9CNoE +7QKVorgCtQDAAsEPCQEAAcADwRBxAdgC8gDYaQPv7qTA4HjxwOHFCHXPcKAALCAQgM9xgABwfkeR +BpEQukV4jegKIcAP63Ju2I24sttKJAAAUQJv8AolAAGGC8/zBe0ClaO4ArU5A+/uAdjhxc9ygACg +MmCCHOvPdYAAfM0fhRkI3gYNhQGjMBWBEDIVgBAIuSV4ALMK8BEIngYYlQCzGpUBsxuVArMA2ACi +4H/Bxc9xgAB8zS6RUyHBgAz0JQqeUs9xgAB8zT+BBCG+jwAYAAAI8gDaQrDPcZ8AuP9XoeB+4Hjx +wOHFz3WAAKCxQIUH6s9zgAA8CSCDRXkgowDZIKWH6M9wgAA8CQCABOhqDW/xDdiJAs/uz3GAAHzN +P4EVCV4GI5AE4SOwLpBkuS6w4H8E2B0J3gYjkAjhI7AukGy5LrAE6CKQgrkisAjY4H4TCZ4GI5AI +4SOwLpBouS6w9vHgfwDY4HjxwMIJz+7PcYAAcH5nkUaRELtleo7qCiHAD+tybtiNuIojhwlKJAAA +EQFv8EolAADPdYEAVBwghc92gACUJui5xiKCj///E/4P8rYOz/UA2AClAIZmDq//AICaCE/7jgtv +8Q3YDfALIQCAIIYF8gnpApGDuATwBekCkYS4ArGxAc/u4HjxwDIJz+4Id89xgACszVEiwNHPcIAA +fM0A2gTyVJDDumCJookIuwUl0BAfgMGBz3OAAKAyUSBAgs9wgAAAfALZ1SDiDMohYQDVIOEEOnED +uTR5VngAIY0PgACctCGAEw5kEACjDw5BEACQCwgCBADYMPAChR8OARAUjSvoA4Ukb+ClGgkv/QXa +AIXCqADYFK0f8AHg2w4BkBSNGwhQAASFJG/gpfYIL/0F2gCFwqgB2BStHw4DdAAAAIDgpc9ygABI +CQCKDyBABFYM7/0AqgHYwQDP7vHAXgjP7gh1OnEacs9xgAA0fQyRz3OAAJy0aHcB4BB4QCEOBgyx +jOgHgclyAeAHoQCDIYMQ4OYJ7/1jgwGOKnEArQGOxriFuAGtAI4CrSDYA60BhgGlQ4cKcK4K7/2p +c10Az+7hxeHGz3GAAKB9z3CAAGQ4AIBjmQJ7DwtyAEAhAgIcawTwc3tEu3N4oZFgkaJ7eGAOeEok +wHEA26gggAFtYgkNAxAB4wKRCQsAAGKxwcbgf8HF4HjhxRTpYYClgIbrQ4CE6qCgIaAM8ECAemIL +DYEQeWEhoATwQ4A6YkOgANkloCag4H/BxeB48cAjgATpJggAAAfwEgggAGCACCMAANHA4H7geECA +IYAEgFlh4H8ieEKAI4AAgFlh4H8ieADbYqBgoGOgYaBmoGWgJ6Dgf0SgIYCE6QOABOgA2APwAdjg +fkGAFwmEACKAIKAjgCGgANkjoCKgBvAiekGgQIBZYSCg4H7gePHA4cUodSOACHMP6aIPz/83CEQD +Ge1CgyODpqM6YkWjB4NYYBbwfg/P/yCDEwhEAAvoEHXKIEUDBqNBg/DxANgD6QsJRQMA2ATwBaMH +g6ajJQeP7vHArg6v7ghxz3KgAMAvoxIAhgDd9QgegQfIQBoYgA3IDQiRASYI7/4ocBfwz3aBAAgb +Co4H6EAmgBIK4coN7/wK2gqOCOjPcYAAqDcXkQHgEHgXsaquxQaP7uB4ocHxwEIOj+6iwUjBGnBI +dQohACFnCV4CAtnPcKAAyB9JGFiAKMFTbe7hUHgF9FYO7/GLcRnwEwnRDRt4EHhGDu/xi3EQ8AsJ +EQUceAnwDQmRAgAchDAH8M9wAAD//wAcBDDgeADYz3KpAKT/uaIAFAExgrg3ohqiSPBdCR4CTCEA +oNEg4qFC9M9ypQCs/89wgABcH7iiBIBWEAABFOACewPjIrt4Y3hgSCBAAAW4RSBAAxaiQSjAIcC4 +d2gowAQhgQ8AAAAgJblleCV4ibiOuBmiHPAowIDgyiHBD8oiwQfKICEOzyAhA8ojIQXPIyEDyiQh +ANQEIfDKJcEABb2leM9xpQCs/xahz3KgAMgfz3WgALRHVxUAlgDfSiRAAAQgvo8AKAAAwiQCAW8V +AJYEIIUPgAAAAAQggw8gAAAABCCODwAGAAAPDBAAQBIBBgsJ1AAA2QLwAdnYcRMSAYYEIL6PADgA +AAQhhw8AAACAzCYhgMAnYRAFI0EBBSHBAQUhvoME9KcPlJINDxAAgOPMJiGQhfJrFQSWkQwQAIh0 +hCTQkQvyz3GAAEg2EIEA3QHgEKGcvVrwFwzeAM9xgABINhGBAeARoULdUPCIdIQkApgI8s9xgAC8 +NxGBAeARoQ7wEwyeAc9xgAC8NwSBAeAEoQTwUyQ+gwTyAN048BcMXgNeCw/9z3GAADg4BYEB4AWh +9PEKIcAP63JvFQWWRNiMuOnbqQMv8Iy7COvPcYAAQDcQgQHgEKHi8SjuGQieBs9ygAC8Ny+CAN0B +4S+ikb0L8B0IXgbPcoAAvDcygkLdAeEyos4Kb/+IcZi9RfBxFQSWbxUFlgohwA/rcjnYz3MAAAIR +SQMv8Iy41goP/c9xgABANxGBAeARobDxExIAhvC4yiAhAOgJYf/PIKEDaxUBllgVAJYLIECAHPJv +FQCWz3WgAPQHUyBAgAHYDPIJpeB4ANgJpc9xgAA4OAiBAeAIoeIO7/0B2APYCqUF3Zi9A/AA3Zft +FwjeIR0JESAB2c9woAD0ByygA9kF8APZz3CgAPQHJaBRIICiZA0C+RfwAxIBNs9wgQAIFw8JAADP +cIEA0BcbCQEAkhEAAaq4khkEAJ4RAAGquJ4ZBADPcYAASDYPgQHgD6HPcIAA9L0hgM9wgABcHwOA +FJAdCQEAz3GAACAXGoE7gSR4USAAgjgJIvbKIGIAqXAI3B8Dr+6iwOB4ocHxwLYKj+4odQh2GnIE +Ib6PAQAAwGh3LfQvDR4SRCUAFiO4IWgEJYAfBgAAADG4OGAEJYEfBgAAAddxAgAAAcogoQAC8AHY +IQhQABMIkACD4ADYyiDhAcAooQMK8M9wgAAczAKABvDPcIAAHMwBgAV9yXAmDa/5qXHJcKlxCnLp +c/IL7/9KJEAAgODcCUH/CNyPAo/u4HjPcKQAkEFNgM9xgACQzkKxGoADsQQggA//AAAAMLgEsc9w +gACQzgDaEQheRs9xgAB8zTKBCwmeAkKwQ7BEsOB/WbDgeOHFz3WAAJDOCaUqpXi1S6UB2Bm14H/B +xUokAHoA2agggAIA2s9wgACQzjV4QKAB4eB+AAARAAAAAEABAAAAAACoEkN1AQYABQAAAAAAAAAA +dDiAAAg5gAA0i4AAtB2AAEgKgABsIMAQDxsJItwdwBAKABtAEAAbbh4AAGEKABtB5B3AEQAACiQA +AAolAQAKJv4FCmRAABtwAgAAYQgAX3AFAABhIAAbcAcAAGEIAF9uAQAAYQQAAGFQOICBAADAFgEA +GyYAAMAXAQAKJAAACiUPCmMiCABfcAoAAGEPHB0iCQAdJg9fGyIcF4CBAADAFzsAAGEAABslAAEb +JFwcwBE3AABhHBeAgQAAwBYgABtwMwAAYRgXgIEAAMAWDxsKIg8bGiIPCRsiAQAbMAAAwBf3/wwk +//8MJQgAGjAEABonAAwaOQAAwBYPCQsiAQAbcBkAAGEAGwkpEBeAgQAAwBYAGwkpAIAJcBMAAGEP +ChoiCAAaMAgAGicADBo5AADAFgEAG3ARAABhDwsJIgAbCSkQF4CBAADAFgAbCSkPCRsiAIAJbgQA +AGEoAAkkAAkbKQCAG3AFAABhDBeAgQAAwBYACxsoFBeAgQAAwBcPChsiBAAbJgAMGzkYF4CBAADA +F5QHgIEPGhsiAAAbJQIAG0AAABtxD0UAIgBcADkHAABiBmAAYgAAWDhgRcAQcEXAEHhFwBCQRcAQ +eQAAYQ95EyLoHcARAQBSJLQfwBACABNwAwAAYQgAWDAIAGQxBwAAYQ8TUiJMCMASQgQTJAgAEzEB +AFJuEAATMQQowBEIAFhu6A8AYQAAEyUAABMkJBDAEYAAEyVHaBMkBCjAEQCAEyQ4HMARDwATIgEA +EzAEKMARD3MTIoIBEzAEKMARD3QTIgICEzAEKMARDxQVIgEAFSYPchMiCADMEQ9EACIKAABAAEAA +cA4AAGEAABMlAgATJOwcwBEPdhMiGAjKEQkAE0AcCMoRCQATQCAIyhEPeBMiBADKEQAAASQAAAEl +BgAAYQ92EyIsSMcRD3gTIgAAxhEDAAEkAAABJQAAEyXCLBMkBCjAEQJGEyQEKMARwl8TJAQowBEP +RQAiAFwAOSwAAGQAABMkAQATJTgcwBEPdxMi4BzAEQIAAWIPARMiBAjAESAIwBIEKMARDxMCIiQI +wBIEKMARDxMHIigIwBIEKMARDxMEIgIAcXAHAABh/wATJQIQEyQEKMARAAATJQAAEyTISccRBgAA +YQAAEyUCEBMkBCjAEQAAEyVJABMkyEnHEQ9wEyIBABMwBCjAEQMAEyQAABMlBAjAEQAAEyQ4RcAR +LAjAEhgowBEPEwMiBAAAYQAAWDgAABMkAQATJTgcwBEAABUkAAAAIQwIgIEAAMAWDxtQIhAIgIEA +AMAWDxsaIhQIgIEAAMAWDxsZIhgIgIEAAMAWAAAAhQgIgIEAAMAWDxsEIhwEG2YbARtoFBzAEAoA +G0AEABtuCwAAYQ8cHSIBAB0m+Q8AYRwIgIEAAMAWBQAbYpQHgIEPGhsiAAAbJQIAG0AAABtxZAwA +EADABhEBAAQn/AAEZAAAGyQCABslOBzAEZQHgIEPGhsiAAAbJQIAG0AAABtxAAAbJUAAGyQwHMAR +lAeAgQ8aGyIAABslAgAbQAAAG3GQRcAQD2QBIgoAAUAIAAFwKgAAYQAAASQIAAElDwFjIggAWG4G +AABhJBDAEAEAE24CAABhAAJcMQEAAGEAIFgwRAhAEv//E279DwBhAUITJAAAEyUEKMARRAhAEv// +E279DwBhTAjAEkIEEyQYABMxBCjAEWBFwBBwRcAQAwB9YgIAEyQAABMl6B3AEfj/TDMBAEwxAQBS +JEgIQBL//xNuAwAAYSQQwBABABNwAgAAYQAAFSQAAAAhDwAAYQ99EyLoHcARAQBSJLQfwBACABNw +AgAAYQgAZDEAAAAhDxNSIkwIwBJCBBMkCAATMQEAUm4QABMxBCjAEbwIgIEAAMAWAgETZEIBEyQE +KMARKD2AgQAAwBYGARNiBAjAEAQAE2QPXAAiCgAAQAAGAHAZAABhAAATJAAAEyUAAMAXAAhYMMgg +wBBwRcAQEAjAEAAAEyUDABMkHAjAERwIwBEAABMkBAjAEQ8UFSIEABUm+/8wMgMAEyQYCMARDxQV +IgIAFSYEADAwAAATJBBFwBEYCMARABBYMA98EyIIAMwRAAATJQAAEyQ0SMcRD3sTIgEAEzAEKMAR +DxQVIgIAFSb/ABMlAhATJAQowBEPFBUiAgAVJoQJgIEAAMAWwiwTJAQowBECRhMkBCjAEcJfEyQE +KMARD00TIgQQxRECABMk8BzAEQEAEyTsHMARAAATJHAAEyUQHMARAAATJQAAEyTgHMARgAATJUZo +EyQEKMARAAATJQEAEyQkEMARAAAVJAAAACEPDhoiAABAFgABG3ANAABhgABjJP/+GzIAAEAXAAAb +JQ8bDyJ4CICB/wAbMgIAG0EAGxooAADAFgAAGyUCABtAAAAbcQEAZHAHAABhAQBjJAAAGyRaCICB +AABAF1AIgIEAAEAW7Q8AYQIAZHAQAABhAgBjJAEAGyRaCICBAABAF1IIgIEAAEAW5A8AYQQAZHAH +AABhAgBjJAIAGyRaCICBAABAF1QIgIEAAEAW2w8AYQAAHSQAAAAhAAIPbgkAAGFaCICBAABAFgAA +GyVWCICBABsaKAAAABYBABsmAAAAFw0AAGFwCICBAABAFgIAGyYBEBtoAAAbJAAAQBdcCICBABob +KA8bDiJ0CICBAABAFgEAGyYAAEAX3AaAgQ8aGyIAABslAgAbQAAAG3EAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzAOAAGAJgAAAAAAAAAAAACgA +gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ0RFAoN +ExcZGRkZCQkAAESagAAAAAAARJqAAAAAAABUz4AAoHAAADCAAAAAAAAAMYAAAIiIMzMygAAAAKqq +ijOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAA +OoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAAAKqqCgA+gAAAU4WIiD+AAAAAAAAwMIAAAAAAAAAx +gAAAmplYVTKAAAAAqqqqM4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAAAAAAAAA3gAAAAAAAADiA +AAAAAAAAOYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAAqqoKAD6AAABVmJmqP4AA +AAAAAFAwgAAAAAAAADGAAAAAAAAAMoAAAAAAAAAzgAAAAAAAADSAAAAAAAAANYAAAAAAAAA2gAAA +AAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAAAAAAAAO4AAAAAAAAA8gAAAAAAAAD2AAAAA +AAAAPoAAAAAAAAA/gAAAAAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAAADOAAAAAAAAANIAAAJp5 +AAA1gAAAqqqqqjaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAKqqqgo7gAAAAHCZ +qjyAAAAAAAAAPYAAAAAAAAA+gAAAAAAAAD+AAAAAAAAA//8AALQAIAAZASAAtQAhABoBIQAEAAgA +1AEDALMBBAB4ADwA3QA8AHkAagDeAGoAqAABAA0BAQCcAcwAnQHMANUBzADWAcwApAGAAF0CNgBK +Ag0ATAIPAE0CAQCtAQYAuAEAALsBVgCPAIgA9ACIAJAAAAD1AAAAkQAGAPYABgCFAAQA6wAEAFAC +CwBRAgMAUgIBAFMCAABUAgsAVQIDAFYCAQBXAgAAuQHBANABAABmAgYAaAIHAGoCBgBsAgcAbgIF +AHACDAB9AgYAfwIHAIECBgCDAgcAhQIFAIcCDAChAUAA+/8AAP//AAC0ACAAGQEgALUAIQAaASEA +BAAIANQBAwCzAQQAeAA8AN0APAB5AGoA3gBqAKgAAQANAQEAnAHMAJ0BzADVAcwA1gHMAKQBgABd +AjMASgIOAEwCDgBNAgEArQEHALgBAAC7AVYAjwCIAPQAiACQAAAA9QAAAJEABgD2AAYAhQAEAOsA +BABQAgsAUQIDAFICAQBTAgAAlAILAJUCAwCWAgEAlwIAAFQCCwBVAgMAVgIBAFcCAACYAgsAmQID +AJoCAQCbAgAAuQHBANABBABmAgYAaAIHAGoCBgBsAgcAbgIFAHACDAB9AgYAfwIHAIECBgCDAgcA +hQIFAIcCDABLAgEAoQFAALIAMAAXATAAswAAABgBAACcAg8AoQIPAKACiACfAogAngKIAJ0CiACl +AogApAKIAKMCiACiAogA+/8AAAAAAAACAAAADdIS0hPSFNIM0hXSC9IC0hHSBEMAEBQQCRAREAFA +G9Ic0gDSCgALAAQADgC1ABoBDwBCALwAwwAhASgBtgC3ALgAuQC9AL4AvwDAABsBHAEdAR4BIgEj +ASQBJQERAAAACgAAAAoAAAC2AAAAtwAAALgAAAC5AAAAtgAAALcAAAC4AAAAuQAAAL0AAAC+AAAA +vwAAAMAAAAC9AAAAvgAAAL8AAADAAAAAEtIAABLSAAAAAAIALABkAHQAgACMAKEABwAAAAAAAQAC +AAMAAAAAALcTIgC4FCMAuRUkALsWJQC8FyYAvRgnAMAZKADEGikABxsAAAgcAQALHQIADB4DABAf +BAAiIQUAJCIGACYjBwAoJAgAKiUJACwmCgAuJwsAMCgMADQpDQA4Kg4APCsPAEAsEABkLhEAaC8S +AGwwEwBwMRQAdDIVAHgzFgB8NBcAgDUYAIQ2GQCINxoAjDgbAJE6HACVOx0AmTweAJ09HwChPiAA +pT8hACRJBgIsSgoCNEsNATxMDwFkTREBbE4TAXRPFQF8UBcBhFEZAZVSHQGdUx8BAQQAAAIFAQAD +BgIABAcDAAUIBAAGCQUABwoGAAgLBwAJDAgACg0JAAsOCgAMDwsADRAMAA4RDQABQAAEAkEBBANC +AgQEQwMEBUQEBAZFBQQHRgYECEcHBAlICAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBZgAAAAAAAsgwsAf////////8AAf//AgP/ +//8E//////////////////////8F/wb/B/8I/wn/Cv8L/wz///8N////Dv///w////8Q//////// +//////////////////////////////////////8R////Ev///xP///8U////Ff///xb///8X//// +GP///xn///8a////G/////8c////Hf///x7///8f////IP///yH//////////////////////yIj +JP8lJif//yj///8p//////////////////////////////////////////////////////////// +//////////////////8AAAEAAQEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAA +APQqAQAAAAAA+GgAAAEAAAAE0QEAAgAAAHjQAQADAAAAeBsCAAQAAAD0KgEABQAAALARAQAGAAAA +8OQAAAcAAAA4EgEACAAAAOQ7AAAJAAAAbFwAAAoAAABgwAAACwAAAPA1AAAMAAAAeB4CAA0AAAAo +3gAADgAAAGjeAAAPAAAAJN4AABAAAABk3gAAEQAAACw/AQASAAAAjOcBABMAAACwLwAAFAAAADhj +AQAVAAAAWE8BABYAAAA0XwEAFwAAAOTPAQAYAAAAqIgBABkAAABwBAEAGgAAAPAqAQAbAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAA//////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyNAAAsjQAALI0AACB4AAAs +jQAALI0AAIR4AAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAACgfgAA6H0AANh9 +AABQfQAAEH4AADh9AAAsjQAALI0AAHyEAABMhwAA+IgAACyNAAAsjQAALI0AAJSMAACUgwAAzIMA +ADiDAAAsjQAALI0AACyNAABQjAAALI0AABiDAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAA +LI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAs +jQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AAER5AAAsjQAALI0AACyN +AAAsjQAALI0AALSJAAAsjQAALI0AACyNAAAsjQAALI0AAKh5AAAsjQAAFHsAALR6AABEegAApHoA +ANx1AAAsjQAAsHUAACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAAPHUAACyNAAAsjQAA +LI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAs +jQAA/HwAACyNAAAsjQAAwH4AACyNAAAsjQAALI0AACyNAAAsjQAACIAAAPB+AAAsjQAALI0AACyN +AAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AACx7AAAsjQAALI0AACyNAAAsjQAALI0A +ACyNAAAsjQAA6IsAACyNAABIjAAAVIkAACyNAAAsjQAAkHMAABSJAAAsjQAALI0AAFh9AABwfQAA +LI0AACyNAABkeQAAIHYAACyNAAAsjQAALI0AANSDAAAgfQAALI0AACyNAAAsjQAALI0AACyNAAAs +jQAAYHwAACyNAABUjQAA4I0AAMCNAAD4jQAAjI0AAHSNAAAAjgAAUI0AACyNAAAsjQAALI0AACyN +AAAsjQAALI0AACyNAAAsjQAAbHkAACyNAAAsjQAALI0AACyNAAAsjQAALI0AACyNAAAskAAAOJEA +ADx0AACwdAAALI0AACyNAAAsjQAALI0AACyNAABQdgAALI0AACyNAAAsjQAALI0AACyNAAAsjQAA +LI0AACyNAAAsjQAALI0AACyNAAAsjQAAwI4AAASOAABwjwAAVI8AAJSOAAAcjgAAiI8AADyPAAAs +jQAALI0AACyNAAAsjQAALI0AACyNAAAsjQAALI0AAIR2AABwdwAAEHcAAKCPAADIdAAA+HcAAJB4 +AAAsjQAALI0AACyNAAAsjQAAfHgAAIB4AAAsjQAALI0AACR4AAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADomwAA +MJoAAEydAABYnAAAYJ4AAAAAAQD/////AAAAAP//////////AQAAAPgTAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAgAAAAAA0P4AAAAAAAAAABggoAAgIKAAQCGgAEghoAAcIKAAJCCgAEQh +oABMIaAAKCCgADAgoABoIaAAcCGgACwgoAA0IKAAbCGgAHQhoAA4IKAAPCCgAHghoAB8IaAAmBEA +AAD/AwBQEwAAAP8FANwRAAAA/y0AuBEAAAD/PQA0EQAAAP8EAFwRAAAA/yUA8MIAAAD/3QBsEgAA +EBBMADgTAAAA/yIAABIAAAD/JgDYEgAAAP8oAKQSAAAA/yAA4MEAAAAgAAAkwQAAAP8wAAAAAAAA +AAAAAAEBADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAA +AAAAAAAAAAAAAAAAAAA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8FRUV +FTw8PDwAAAAAAAAAAAAAAAAAAAAAPDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwVFRUV +PDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAALgCAQBwqQAAxCIAAHCpAABwqQAAcKkAAIQM +AACc3gEA7M8AAHCpAABwqQAAyDIAAMgyAADIMgAAyDIAAMgyAADIMgAAyDIAAHCpAABwqQAAcKkA +AHCpAAD0UwAAcKkAAHCpAABwqQAAcKkAAHCpAADQzwAAcKkAAHCpAABkwAAAAAAAAKDpAACk6QAA +tAIAAKACAACYPgEAAAAAAOC2AACkvAEACLcAAMy8AQAstwAA9LwBAPiZgACsMIAAZJSAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAFAAYA +BwAIAAgACQAKAAoACwAMAAwADQAOAA4ADwAmACcAKAApACoARgBGAEcASABIAEkASgBKAEsATABo +AGkAagBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0AHQA +dAB0AHQAdAB0AHQAdAB0AAoAPwAAAIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAFAAYABwAI +AAgACQAKAAoACwAMAAwADQAOAA4ADwAmACcAKAApACoARgBGAEcASABIAEkASgBKAEsATABoAGkA +agBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0 +AHQAdAB0AHQAdAB0AAoAPwAAAAAAZCEAACwhAADktIAAAAIAAAAAAAAk+QAA9PgAAOS2gABABQAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKPkAAHQ7AQB0vYAAVAAAAAAAAAAk+QAASDoBACS8gABQ +AQAAAAAAACT5AABENAEAcAmAAAgAAAABAAAAJPkAAPD3AAAAAAAAUAEAAAAAAAAk+QAA0DQBAEAp +gAACAAAAAAAAACT5AADcMwEAbAmAAAQAAAAAAAAALPkAAPT4AADIvYAAKgAAAAAAAAAk+QAA9PgA +AGg4gAAIAAAAAAAAAAAAAAD8+AAAAAAAAAAAAAABAAAAAAAAABD5AAAAAAAAAAAAAAAAAAAAAAAA ++PgAAAAAAAAAAAAAAAAAACT5AAAYvwEAAAAAAAAAAAAAAAAAJPkAANi+AQB4CYAABAAAAAAAAABu +AG4AaQDAAKAAUACAAL4AUAF9AD4AAQABAAEAWAIoAOYBLQBVAzwA3AFjAAAAbgBuAGkAwACgAFAA +gAC+AFABfQA+AAEAAQABAFgCKADmAS0AVQM8ANwBYwAAAAAAAAABAQAAAAIBABXSAAAAAAAA/wMA +AAACAQAM0gAAAAAAAP8BAAAAAgEAFdIAAAoAAAAA/A8AAAIBAAzSAAAJAAAAAP4DAAACAQAV0gAA +FAAAAAAA8D8AAgEADNIAABIAAAAAAPwHAAIBAAbSAAAAAAAA/wEAAAACAQAH0gAAAAAAAP8DAAAA +AgEABtIAAAkAAAAA/gMAAAIBAAfSAAAKAAAAAPwPAAACAQAG0gAAEgAAAAAA/AcAAgEAB9IAABQA +AAAAAPA/AAAAAAAAAAAAAAAAAQAAAAEAAAAKAAAABQAAAAUAAAAGAAAACgAAAAoAAAAGAAAABAAA +AAUAAAAGAAAABQAAAAUAAAAGAAAABgAAAAYAAAAGAAAABwAAAAcAAAAHAAAACAAAAAgAAAAIAAAA +BAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAEAAAACAAAAAQAAAAEAAAADAAAAAwAAAAIAAAAB +AAAABAAAAAAAAAAAAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAEAAAAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAAAAAA +2AsBADwQAQAsDwEAqBABADgQAQBwDgEApBABAAANAQD8DAEAYOMWACDWEwAAAAAAEAAAAACAAAAA +AKAAECcAAOgDAADoAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgAAAAEAAAABAAAAAgAA +AAUAAAACAAAAAgAAAAUAAAACAAAAAgAAAAEAAAABAAAABQAAAAUAAAACAAAABQAAAAUAAAAAAAAA +BQAAAAIAAAACAAAAAAAAAAAAAAAAAAAABQAAAAUAAAAAAAAABQAAAAIAAAACAAAABQAAAAUAAAAF +AAAAAAAAAAUAAAACAAAABQAAAAEAAAABAAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAABQAAAAEA +AAABAAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAAAgAAAAUAAAABAAAAAgAAAAUAAAACAAAABQAA +AAUAAAAEAAAABQAAAAUAAAABAAAABQAAAAUAAAAFAAAAAgAAAAIAAAAFAAAABQAAAAUAAAABAAAA +BQAAAAUAAAAFAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAA +AAAAAAAACAAAAAAAAAABEAABAAAAAoAAAUIABgIQAAIgAAADwAABQwAGAxAAAsAAAAPAAAFDAAYE +EAACQAAAAoAAAUQABgURAABAAAADwAABRQAGBhEAAOAAAAPAAAFFAAYHEQABAAAAAoAAAUYABggR +AAIgAAADwAABRwAGCREAAsAAAAPAAAFHAAYKEQACQAAAAoAAAUgABgsSAABAAAADwAABSQAGDBIA +AOAAAAPAAAFJAAYNEgABAAAAAoAAAUoABg4SAAIAAAACgAABTAAGAXgAMAAAAFAAAAS2PAYCeABE +AAAAUAAABLk8BgN5AAgAAABQAAAEuzwGBHkAHAAAAFAAAAS+PAYFeQAwAAAAUAAABMA8BgZ5AEQA +AABQAAAEwzwGB3oACAAAAFAAAATFPAYIegAcAAAAUAAABMg8Bgl6ADAAAABQAAAEyjwGCnoARAAA +AFAAAATNPAYLewAIAAAAUAAABM88Bgx7ABwAAABQAAAE0jwGDXsAMAAAAFAAAATUPAYOfAAQAAAA +UAAABNo+BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEBAAABAAEAAgEAAAIAAQACAQAAAoCAgICA +gICAAYACgICAgIDAAJAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AG4AAABuAAIAbgBuAG4AAgBpAGkAbgABAMAAwADoAAEAoACgADYBAwBQAFAA9QABAIAAgADoAAEA +vgC+AL4AAQBQAVABUAEBAH0AfQCvAAMAPgA+AD4AAQABAAEAAQABAAEAAQABAAEAAQABAAEAAQBY +AlgCWAIBACgAKAAoAAEA5gHmAeYBAQAtAC0ALQABAFUDVQNVAwEAPAA8ADwAAQDcAdwB3AEBAGMA +YwBjAAEAAAAAAAAAAAAyAAUAMgAFAAIACABkAKAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AHDqgAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAACM +CowKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjbAQAVAAAAAwAAAGA8gAAAAAAAAAAAAAAAAACk +2gEABQAAAAMAAABgPIAAAAAAAAAAAAAAAAAAmNoBAAoAAAADAAAAYDyAAAAAAAAAAAAAAAAAAGTY +AQAKAAAAAwAAAGA8gAAAAAAAAAAAAAAAAAC02QEACgAAAAAAAACAPIAAAAAAAAAAAAAAAAAAtNkB +AAoAAAAAAAAAgDyAAAAAAAAAAAAAAAAAALTZAQAKAAAAAAAAAIA8gAAAAAAAAAAAAAAAAAC02QEA +CgAAAAAAAACAPIAAAAAAAAAAAAAAAAAAtNkBAAoAAAAAAAAAgDyAAAAAAAAAAAAAAAAAALTZAQAK +AAAAAAAAAIA8gAAAAAAAAAAAAAAAAAC02QEACgAAAAAAAACAPIAAAAAAAAAAAAAAAAAAtNkBAAoA +AAAAAAAAgDyAAAAAAAAAAAAAAAAAALTZAQAKAAAAAAAAAIA8gAAAAAAAAAAAAAAAAAC02QEACgAA +AAAAAACAPIAAAAAAAAAAAAAAAAAAtNkBAAoAAAAAAAAAgDyAAAAAAAAAAAAAAAAAALTZAQAKAAAA +AAAAAIA8gAAAAAAAAAAAAAAAAADE2gEACgAAAAMAAABgPIAAAAAAAAAAAAAAAAAAHNwBAAUAAAAD +AAAAYDyAAAAAAAAAAAAAAAAAALzXAQAKAAAAAAAAAIA8gAAAAAAAAAAAAAAAAAAs2AEACgAAAAAA +AACAPIAAAAAAAAAAAAAAAAAAXOYBAAoAAAADAAAAYDyAAAAAAAAAAAAAAAAAAJDYAQAKAAAAAAAA +AIA8gAAAAAAAAAAAAAAAAAA42QEACgAAAAAAAACAPIAAAAAAAAAAAAAAAAAAuNkBAAoAAAAAAAAA +gDyAAAAAAAAAAAAAAAAAADjaAQAKAAAAAAAAAIA8gAAAAAAAAAAAAAAAAABc2wEACgAAAAAAAACA +PIAAAAAAAAAAAAAAAAAAzNsBAAoAAAAAAAAAgDyAAAAAAAAAAAAAAAAAAPjbAQAGAAAAAAAAAIA8 +gAAAAAAAAAAAAAAAAAAI3AEABgAAAAAAAACAPIAAAAAAAAAAAAAAAAAAAAAAAGA8gABgPIAAuCCg +AGwgoAAAgAEA/3/8/wAAAAAAAAAAgDyAAIA8gACkIKAAOCCgAAEAAAD8////AAAAAAAAAACgPIAA +oDyAAKggoAA8IKAAEAAAAMf///8AAAAAAAAAAMA8gADAPIAArCCgAHghoABAAQAAP/7//wAAAAAA +AAAA4DyAAOA8gACwIKAAfCGgAAAMAAD/8f//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiNgBABUA +AAADAAAAYDyAAAAAAABQAAAAAAAAAPwIgADAnYAAGAAAAICdgAAAAAAAAAAAAAAAAAD8CIAAwJ2A +ABgAAACAnYAAAAAAAAAAAAAAAAAAfwAAAAAAAAAAfwAAAAAAAAAAAAAAAAAAoH+AAAAAAAAAAAAA +//8AAAEAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAABAgMEBAQEBAUGBwgICAgICQoLDA0AAG47aDti +O1w7bjpoOmI6XDpuOWg5YjlcOW4raCtiK1wrbipoKmIqXCpuKWgpYilcKW4oaChiKFwobidoJ2In +XCduJmgmYiZcJm4laCViJVwlbiRoJGIkXCRuI2gjYiNcI24iaCJiIlwibiFoIWIhXCFuIGggYiBc +IGITXBNuEmgSYhJcEm4RaBFiEVwRbhBoEGIQXBBuAmgCYgJcAm4BaAFiAVwBbgBoAFQAAABuO2g7 +YjtcO246aDpiOlw6bjloOWI5XDluK2grYitcK24qaCpiKlwqbiloKWIpXCluKGgoYihcKG4naCdi +J1wnbiZoJmImXCZuJWglYiVcJW4kaCRiJFwkbiNoI2IjXCNuImgiYiJcIm4haCFiIVwhbiBoIGIg +XCBuEmgSYhJcEm4RaBFiEVwRbhBoEGIQXBBXEFIQTRBJEG4BaAFiAVwBbgBoAGIAXABUAAAAAAAA +AAAAAAAdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FkBAAgAAAADAAAA +YDyAAHQKgAD0CoAAdAuAAPQLgAAKDREUCg0RFBkZGRkKCgAAAAAAAAYGBgYJCQkJAAYAAAAFBgcI +DQ4PEBUWFxgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAADBSamhwkmpqampqTmm6BPzUJiysAAAAyAAAAjwCMAIoAQwAPACBoNwAAABEAPjogEQAA +AiUAAAwvAAACLzk5AAolPLdHb4oABxQnYi4AAAIAFwAAFg4WFAAAAABCQhcABRAKIDBAAAAGBgoS +9hX2BvYJ9gz2D/YA9gMAgAAAAABYW2NjMQAADBAUGCAIBAAAPDg0MCwoJCAcGBQQDAgEAAsHAwA7 +NzMvKycjHxsXEw8LBwMAOzczLysnIx8bFxMPCwcDMTc6MDI6NTkAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAIgAAABAAAAAdAAAANwAAAG8AAACgAAAAcAAAAAUAAAD2AAAA +WgAAAB8AAABIAAAAIAAAAEgAAAAIAAAAAQAAADMAAAB/AAAANAAAAH8AAAA3AAAAAQAAADgAAABP +AAAAOwAAAH8AAAA8AAAAfwAAADEAAAAAAAAAMgAAAAAAAAA1AAAAAAAAADYAAAAAAAAAOQAAAAAA +AAA6AAAAAAAAAA0AAAAqAAAADgAAAHoAAAAPAAAAEAAAAPMAAABIAAAA9AAAAEgAAAAAAAAAAQEB +AQEBAQECAgICAgICAgMDAwMDAwMDAQIAAAQAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAKEDDh7hAAAA +oQMOHuEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoQMOHuEAAAAV9mP2sPb89kb3kPfY9x/4Zfip+O34L/lw ++bD57vkr+mf6ovrc+hT7S/uB+7b76vsc/E38ffyr/Nn8Bf0w/Vn9gv2p/c/99P0X/jn+Wv56/pj+ +tv7S/u3+Bv8e/zX/S/9g/3P/hf+W/6b/tP/B/83/2P/h/+n/8P/2//r//f/////////9//r/9v/w +/+n/4f/Y/83/wf+0/6b/lv+F/3P/YP9L/zX/Hv8G/+3+0v62/pj+ev5a/jn+F/70/c/9qf2C/Vn9 +MP0F/dn8q/x9/E38HPzq+7b7gftL+xT73Pqi+mf6K/ru+bD5cPkv+e34qfhl+B/42PeQ90b3/Paw +9mP2cLmDupa7qry+vdK+57/8wBHCJ8M9xFPFasaAx5fIr8nGyt7L9swPzifPQNBZ0XLSjNOm1L/V +2tb01w7ZKdpE21/cet2W3rHfzeDp4QXjIeQ+5Vrmd+eT6LDpzerq6wftJO5C71/wffGa8rjz1fTz +9RH3L/hM+Wr6iPum/MT94v4AAB4BPAJaA3gElgW0BtEH7wgNCisLSAxmDYMOoQ++ENwR+RIWFDMV +UBZtF4kYphnCGt8b+xwXHjMfTyBqIYYioSO8JNcl8iYMKCYpQSpaK3Qsji2nLsAv2TDxMQozIjQ6 +NVE2aTeAOJY5rTrDO9k87z0EPxlALkFCQlZDakR9RaqqAwAAAAAAqqoDAAD4AAAAqgP///8AAFCn +9FFTZUF+w6QXGpZeJzrLa6s78UWdH6tY+qyTA+NLVfowIPZtdq2RdsyIJUwC9fzX5U/XyyrFgEQ1 +Jo+jYrVJWrHeZxu6JZgO6kXhwP5dAnUvwxLwTIGjl0aNxvnTa+dfjwOVnJIV63ptv9pZUpUtg77U +0yF0WClp4ElEyMmOaonCdXh5jvRrPliZ3XG5J7ZP4b4XrYjwZqwgybQ6zn0YSt9jgjEa5WAzUZdF +f1Ni4HdksYSua7scoIH+lCsI+VhoSHAZ/UWPh2zelLf4e1Ij03Or4gJLclePH+Mqq1VmByjrsgPC +tS+ae8WGpQg30/KHKDCypb8jumoDAlyCFu0rHM+KkrR5p/DyB/Oh4mlOzfTaZdW+BQYfYjTRiv6m +xJ1TLjSgVfOiMuGKBXXr9qQ57IMLqu9gQAafcV5REG69+YohPj0G3ZauBT7dRr3mTbWNVJEFXcRx +b9QGBP8VUGAk+5gZl+m91sxDQIl3ntlnvULosIiLiQc4Wxnn2+7IeUcKfKHpD0J8yR6E+AAAAACD +hoAJSO0rMqxwER5Oclps+/8O/VY4hQ8e1a49JzktNmTZDwohplxo0VRbmzouNiSxZwoMD+dXk9KW +7rSekZsbT8XAgKIg3GFpS3daFhoSHAq6k+LlKqDAQ+AiPB0XGxILDQkOrceL8rmoti3IqR4UhRnx +V0wHda+73Znu/WB/o58mAfe89XJcxTtmRDR++1t2KUOL3MYjy2j87bZj8eS4ytwx1xCFY0JAIpcT +IBHGhH0kSoX4PbvSETL5rm2hKcdLL54d8zCy3OxShg3Q48F3bBazK5m5cKn6SJQRImTpR8SM/Kga +P/Cg2Cx9Vu+QMyLHTkmHwdE42f6iyow2C9SYz4H1pijeeqUmjrfapL+tP+SdOiwNknhQm8xfamJG +flTCE4326LjYkF73OS71r8OCvoBdn3yT0GmpLdVvsxIlzzuZrMinfRgQbmOc6Hu7O9sJeCbN9BhZ +bgG3muyomk+DZW6V5n7m/6oIz7wh5ugV79mb57rONm9K1Amf6tZ8sCmvsqQxMSM/KjCUpcbAZqI1 +N7xOdKbKgvyw0JDgFdinM0qYBPH32uxBDlDNfy/2kReN1k12TbDvQ1RNqszfBJbk47XRnhuIaky4 +HyzBf1FlRgTqXp1dNYwBc3SH+i5BC/taHWezUtLbkjNWEOkTR9ZtjGHXmnoMoTeOFPhZiTwT6+4n +qc41yWG37eUc4TyxR3pZ39KcP3PyVXnOFBi/N8dz6s33U1uq/V8Ubz3fhttEeIHzr8o+xGi5LDQk +OF9Ao8Jywx0WDCXivItJPChBlQ3/cQGoOd6zDAic5LTYkMFWZGGEy3twtjLVdFxsSEJXuNBSCWrV +MDalOL9Ao56B89f7fOM5gpsv/4c0jkNExN7py1R7lDKmwiM97kyVC0L6w04ILqFmKNkksnZboklt +i9Elcvj2ZIZomBbUpFzMXWW2kmxwSFD97bnaXhVGV6eNnYSQ2KsAjLzTCvfkWAW4s0UG0Cwej8o/ +DwLBr70DAROKazqREUFPZ9zql/LPzvC05nOWrHQi5601heL5N+gcdd9uR/EacR0pxYlvt2IOqhi+ +G/xWPkvG0nkgmtvA/njNWvQf3agziAfHMbESEFkngOxfYFF/qRm1Sg0t5Xqfk8mc76DgO02uKvWw +yOu7PINTmWEXKwR+unfWJuFpFGNVIQx9pWNjxoR8fPiZd3fujXt79g3y8v+9a2vWsW9v3lTFxZFQ +MDBgAwEBAqlnZ859KytWGf7+52LX17Xmq6tNmnZ27EXKyo+dgoIfQMnJiYd9ffoV+vrv61lZsslH +R44L8PD77K2tQWfU1LP9oqJf6q+vRb+cnCP3pKRTlnJy5FvAwJvCt7d1HP394a6Tkz1qJiZMWjY2 +bEE/P34C9/f1T8zMg1w0NGj0paVRNOXl0Qjx8fmTcXHic9jYq1MxMWI/FRUqDAQECFLHx5VlIyNG +XsPDnSgYGDChlpY3DwUFCrWami8JBwcONhISJJuAgBs94uLfJuvrzWknJ07NsrJ/n3V16hsJCRKe +g4MddCwsWC4aGjQtGxs2sm5u3O5aWrT7oKBb9lJSpE07O3Zh1ta3zrOzfXspKVI+4+PdcS8vXpeE +hBP1U1OmaNHRuQAAAAAs7e3BYCAgQB/8/OPIsbF57Vtbtr5qatRGy8uN2b6+Z0s5OXLeSkqU1ExM +mOhYWLBKz8+Fa9DQuyrv78XlqqpPFvv77cVDQ4bXTU2aVTMzZpSFhRHPRUWKEPn56QYCAgSBf3/+ +8FBQoEQ8PHi6n58l46ioS/NRUaL+o6NdwEBAgIqPjwWtkpI/vJ2dIUg4OHAE9fXx37y8Y8G2tnd1 +2tqvYyEhQjAQECAa///lDvPz/W3S0r9Mzc2BFAwMGDUTEyYv7OzD4V9fvqKXlzXMRESIORcXLlfE +xJPyp6dVgn5+/Ec9PXqsZGTI511duisZGTKVc3PmoGBgwJiBgRnRT0+ef9zco2YiIkR+KipUq5CQ +O4OIiAvKRkaMKe7ux9O4uGs8FBQoed7ep+JeXrwdCwsWdtvbrTvg4NtWMjJkTjo6dB4KChTbSUmS +CgYGDGwkJEjkXFy4XcLCn27T073vrKxDpmJixKiRkTmklZUxN+Tk04t5efIy5+fVQ8jIi1k3N263 +bW3ajI2NAWTV1bHSTk6c4KmpSbRsbNj6VlasB/T08yXq6s+vZWXKjnp69OmurkcYCAgQ1bq6b4h4 +ePBvJSVKci4uXCQcHDjxpqZXx7S0c1HGxpcj6OjLfN3doZx0dOghHx8+3UtLlty9vWGGi4sNhYqK +D5BwcOBCPj58xLW1capmZszYSEiQBQMDBgH29vcSDg4co2Fhwl81NWr5V1eu0Lm5aZGGhhdYwcGZ +Jx0dOrmenic44eHZE/j467OYmCszEREiu2lp0nDZ2amJjo4Hp5SUM7abmy0iHh48koeHFSDp6clJ +zs6H/1VVqngoKFB639+lj4yMA/ihoVmAiYkJFw0NGtq/v2Ux5ubXxkJChLhoaNDDQUGCsJmZKXct +LVoRDw8ey7Cwe/xUVKjWu7ttOhYWLAABAQIBAgIDAQEBAQEBAQECAgICAgICAgMDAwMDAwMDBAQE +BAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAA6AQIB +1QDfANoAogB1AH8AigUqAzkBqAGKBcoC2QBIAQEDDwcKFDduagEaAdkA6AAKAboAeQCIAMoBSgHi +APkAygHqAIIAmQB00UUX6KKLLgAFBwEDBAAFAQUAAAAFBgACBAAFAAUAAAECAQIDBAAABQYHCAkK +AAAFAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAEAAAAAgAAAAUAAAAAAP8AAP///ygAKAAwACwALAAo +ADwANABAADwAjABsAFgASAD0ALAAf/8HDx8/AQMwAAAANgAAAAwAAAASAAAAGAAAACQAAAAGAAAA +CQAAAAUABwIDBAYGQAOABsAJAA2AEwAaQB2AIIAGAA2AEwAaACcANIA6AEHACYATQB0AJ4A6AE7A +V4BhmQMzB9kKcw6mFeYcgCAZJDMHcw6mFeYcWSvMOQBBM0jZCqYVgCBZKwBBplaAYVlsndiJnU7s +xE40SIM0J3ZiJxqkQRoTO7ETERiBEQ/8wA9O7MROJ3ZiJxqkQRoTO7ETDdIgDYmd2AkIjMAIB37g +BzRIgzQapEEaERiBEQ3SIA0IjMAIBmmQBrCy1QUFVEAFJ3ZiJxM7sRMN0iANiZ3YCQZpkAbETuwE +BEZgBAM/8AOqqqqqGqRBGhM7sRMP/MAPERiBEQ3SIA0KqIAKEzuxEw/8wA8P/MAPDdIgDQu0QAsL +tEALiZ3YCQ3SIA0KqIAKCqiACgiMwAgHeIAHB3iABwZpkAYP/MAPDdIgDQu0QAsN0iANC7RAC4md +2AkIjMAIiZ3YCQiMwAgHfuAHB37gB8EsKQcKqIAKCIzACAd4gAcIjMAIB3iABwZpkAawstUFBmmQ +BrCy1QUFVEAFBVRABdYdxgQBBw8fP3///2bmAAAFBgECAwQAAFQAVABsAGAAXABUAIwAeAANDwUH +CQsBAygAKAA0ADAALAAsAEQAPAAsACwAPAA0ADAALABUAEQAVVVVAUtoLwFVVVUF4ziOA6qqqgJx +HMcBqqqqCsdxHAcABAAAZAAAAAAAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8A +PwABAAAADwA/AAEAAAAPAD8AAgAAAA8APwABAAAAIhYAAIAAAAMAAAFZAAAkFgABAAAAAwAAAVoA +ACYWAAIAAAAEAAABWgAAKBYAAgAAAAMAAAFbAAAqFgACgAAAAwAAAVwAACwXAAAAAAAEAAABXAAA +LhcAAIAAAAMAAAFdAAAwFwABAAAAAwAAAV4AADQXAAIAAAADAAABXwAANhcAAoAAAAMAAAFgAAA4 +GAAAAAAABAAAAWAAADwYAAEAAAADAAABYgAAPhgAAgAAAAQAAAFiAABAGAACAAAAAwAAAWMAAGQb +AAIAAAADAAABbwABZhsAAoAAAAMAAAFwAAFoHAAAAAAABAAAAXAAAWwcAAEAAAADAAABcgABbhwA +AgAAAAQAAAFyAAFwHAACAAAAAwAAAXMAAnQdAAAAAAAEAAABdAACdh0AAIAAAAMAAAF1AAJ4HQAB +AAAAAwAAAXYAAnwdAAIAAAADAAABdwADfh0AAoAAAAMAAAF4AAOAHgAAAAAABAAAAXgAA4QeAAEA +AAADAAABegADhh4AAgAAAAQAAAF6AASIHgACAAAAAwAAAXsABIwfAAAAAAAEAAABfAAEkR8AAUAA +AAMAAAF+AASVHwADAAAABAAAAX8ABZcfAALAAAADAAABgAAFmSAAAEAAAAMAAAGBAAWdIAABQAAA +AwAAAYIABZ8gAAHAAAADAAABgwAFoSAAAwAAAAQAAAGDAAWlIQAAQAAAAwAAAYUABaxwAQAAAAAA +rHABAAAAAACscAEAAAAAAKxwAQAAAAAArHABAAAAAACscAEAAAAAAKxwAQAAAAAArHABAAAAAACo +agEAGAAAAGxsAQAgAAAAzHEBABQAAADAcgEAFAAAABhwAQAOAAAA7G4BAA4AAADsbwEAFAAAAOxv +AQAUAAAAQANAQEBAQEABgQCEQEBANQFAATVAlQAAAAAAAAAAAABkAAAAAJABAAoAAAD0oQEAiKUB +AIyjAQAwnwEAsKkBAAisAQAspwEAsKQBAICoAQAEAAAAHBEAABwyAAAcMwAABAAAABwVAAAcAgAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApcaE+Jnu +jfYN/73Wsd5UkVBgAwKpzn1WGediteZNmuxFj50fQImH+hXv67LJjgv77EFns/1f6kW/I/dTluRb +m8J1HOGuPWpMWmxBfgL1T4NcaPRRNNEI+ZPic6tTYj8qDAhSlWVGXp0oMKE3Dwq1LwkONiSbGz3f +Js1pTs1/n+obEp4ddFguNC02stzutPtb9qRNdmG3zn17Uj7dcV6XE/WmaLkAACzBYEAf48h57ba+ +1EaN2WdLct6U1JjosEqFa7sqxeVPFu3FhteaVWaUEc+KEOkGBIH+8KBEeLol40vzov5dwICKBa0/ +vCFIcATx32PBd3WvY0IwIBrlDv1tv0yBFBg1Ji/D4b6iNcyIOS5Xk/JVgvxHeqzI57orMpXmoMCY +GdGef6NmRH5UqzuDC8qMKcfTazwoeafivB0Wdq0721ZkTnQeFNuSCgxsSOS4XZ9uve9DpsSoOaQx +N9OL8jLVQ4tZbrfajAFksdKc4Em02PqsB/Mlz6/KjvTpRxgQ1W+I8G9KclwkOPFXx3NRlyPLfKGc +6CE+3ZbcYYYNhQ+Q4EJ8xHGqzNiQBQYB9xIco8Jfavmu0GmRF1iZJzq5JzjZE+uzKzMiu9JwqYkH +pzO2LSI8khUgyUmH/6p4UHqljwP4WYAJFxraZTHXxoS40MOCsCl3WhEey3v8qNZtOiwAAQIEBAAA +AAQMDAgEDAQEQAAAAIAAAAAAAQAAAAIAAEAAAAAABAAAQAAAAEAAAAAA8GEAAAEBAgECAgMAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAAKgAAAA4AAAAAAAEBAQIE/wgQ//8c2wEAKNsBADTb +AQBA2wEASNsBAFDbAQAAAAABAAAAAgAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAABsAAAA2BAIE +AgAAAAABAhAECAAAAAIQBAgAAAAAAQEAAQIBAQEAAAAAAAAAAP////8AAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIANAAAAIAAAgA0AAIANAAAAIAAAgA0AAAAGAAAA +BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAKwfAgAg +IIAPAABAAGkgAABpIEAAaSAAAGkgQAAgIIAPAADoAGkgAABpIEAAaSAAAGkgQAAgIIAPAACA8mkg +AABpIEAAaSAAAEogAABKIQAASiIAAEojAABKJAAASiUAAEomAABKJwAASiAAEEohABBKIgAQSiMA +EEokABBKJQAQSiYAEEonABBKIAAgSiEAIEoiACBKIwAgSiQAIEolACBKJgAgSicAIEogADBKIQAw +CiSAP4EAAEBBLJwwQCycMEIkHDQKIoA/gADAdAojADcSDQAHSiYAcGkgQABKJgBwSiYAcEomAHBK +JgBwABYAcIAAuCJAeCAgQIcAAAAAAAAAAAAA/ByItvwcSLb8HAi2/BzItfwciLX8HEi1/BwItfwc +yLT8HIi0/BxItPwcCLT8HMiz/ByIs/wcSLPgfuB4BNw43TXw4HgE3DTdM/DgeATcMN0x8OB4BNws +3S/w4HgE3CjdLfDgeATcJN0r8OB4BNwg3Snw4HgE3BzdJ/DgeATcGN0l8OB4BNwU3SPw4HgE3BDd +IfDgeATcDN0f8OB4BNwI3Rzw4HgE3ATdGfA0FBowMBQZMCwUGDAoFBcwJBQWMCAUFTAcFBQwGBQT +MBQUEjAQFBEwDBQQMALHAcawJE0zsCQfM+B+4HjgeOB44HjgeOB4CiSA8AUgRADgIMEHRCT+gEEq +xACEAAIALyQC8UIhAQFCIAMB6CCiBAQRBAIEEQUCBBEGAgQRBwIEGwgBBBtIAQQbiAEEG8gBLAAl +AEQiPoE8ACIARCL8gEAhwQDgIMEHQCPDAKgggAEBEYQCARsKASAgwAcEEQQCBBEFAgQbCAHUB+H/ +BBtIAUQi/IAEEQQCyQfv/wQbCAFCIUEAQiBDAKgggAEBEYQCARsKASAgwAfPcaAArC8YgZq4GKEN +AaAQBdjgeM9xoACsLxiBs7i6uBih+QCgEGTYCiJAgADZ7gABAC8mAPBKJkAATgAGAE8AIACKJf8P +4HgKIkCAANnOAAEAbAAkAC8mAPBcAAUAKwg1CEomQAAIcQDYAiG+gOAgxQdCeQHgAiG+gOAgxQdC +eesH7/8B4C8tAQBAJUUAAiZ88QAAIAAAKEAB6CBiAy8gAIAvIUsAAiG+gMAghgHCIYYA4H4RACAA +SiAAEEogQBAOIkIALyALEs4gRYCKJf8PCAAFAC8tAQBAJUUAAiZ88QAAIAAAKEABSiZAAOggIgMv +IACALyFLAAIhvoDAIIYBwiGGAEomAABCIP6QziCCAUQgfpDOIYIB4H4JAAAA4HgKJgDwiiC/D8og +ZADgfy8gAwDgf4og/w/8HIix/BxIsfwcCLHhw+HC4cHhwAfAHBzAMeHA4H8BwFMiQoHgfE4iA4gW +AAwAASjMAAApgQAAKIAA4H+FeU4jAwAAKMEA4H8CeOB4UyJCgeB8TiIDiBYADAAAKcwAASmBAAEo +gADgf4V4TiMDAAEpwADgfyJ54HgIdADYBSp+AC9xBSo+AwAgQI4BIcEOBSs+A+B/J3HgeDMAIABK +JAAAByHEAC8mQPBKJQAAEAAmAC8kBAEOIECBAyVBAIDjDgADAA4iQoEDJcMABSOFgDABAQB5c0h0 +CHIocwolwIJKIgAQGgAEAMAiIRjKJQGDLy9BAcAiYxDAIsMRSicAAAolwIDAJyEIFgAEAMolgYAv +KEEBwCdjAMAnAwAOJ4eCyickAEAnRwAKJcABTCcAiADZEAAkAADYSHFocgDbQicHiAokQHEoAAEA +TicKiH4AAQAAKYACASnBAQAqhQKgcQEqwgEAK4UCASvDAaByTCIAmGoACQCoIIAFACAAgAEhQYAB +IoKAASPDAAIiAoMDI8OCDAAGAAAiAoMBI8OCwCBmAEIkPoBKJQAAIAABAAwACgAOIkKBAyXDAC8k +AIEMAAMADiBAgQMlQQDgfihwSHFocgDbICCADwAARAWoIIADACAAgAEhQYABIoKAkXLCIgYDxSBm +ACAggA8AAHgFANoJagDbLyECACAggA8AAKAF4HhTIkKB4HxOIgOIFgAMAAApzAACKYEAASiAAOB/ +hXhOIwMAAinAAOB/QinBB+HFCHUR8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Yb2M +Jf+f7fXgf8HF4HjxwOHFz3CAAEgkTYDPdYAASKcghbe6uLoEIYEPAwAAAAe5RXktoFoKYBAA2ACF +z3GAAKjPUSCAgkyJz3CAANDdMmo2ecdxgACQ2mCBVnhBgAXylbtgoau6BPC1u2Chi7pBoAuNo7j5 +Au//C63hxeHGwIBhgKCBAYEAJY2TASDAAKCiAaLBxuB/wcXgeKLB8cBWCs//RcHPdYAASCQnhRUI +QQAwlRQUDjEJDkEQWR2CENAVARYdCEEAz3GAAFQnPJEUFA0xDQ1BEM9xgACsJ1mpi+rPdYAAeArB +jYDmANnKIEEAJPIhrQsKkQMB2B7wQSgNAgd9QSgBBKd5z3eAAHgKoI9TJUURHw0yBMa5CiHAD+ty +z3AAAM0bn9s9BuAAiiSDDw8NnhEA2AzcJwLP/892gABQ3RYmTRGnjaCvyXUWJU0RAKUUFAAxRq3H +cYAAENoCtQCJB60AGUIBABtCAcfx8cCCCc//CMjPcqAAyB8OGhiACcgPGhiACsgQGhiACxIBNgLI +JHgRGhiADMjPcYAA+DwtGhiAAIEB4AChw7hXCFEDC8h/2Qq5JHgvKAEATiCCBwDYDyCAAAQhAYBC +Io0CGfILI0DAF/TPcKAAiCDwIFADz3aAACg6AIbPd4AALDoNDQEQAIcScKgJgQagpgAfABRVAc// +4Hif4cwg7ofMIE6ABvcCeUFpCwoRCIoh/w8G8ADZDyGBAGG5GHngfyhw8cCyCO//iiAPCoIkAjqa +cXpyWnOIdah3CiGAIQogwCHCCWAAnsGKcLoJYACLcYLGanCyCWAAyXFKcKoJYACEwalwoglgAIbB +iMXpcJYJYACpcSpwjglgAIrBCnCGCWAAjMGpcIrBtgzgAJDCi3DJcaoM4ACSwslwhMGiDOAAlMKG +wKlxlgzgAJbCmMaQwJLBxg6gAMlymseUwJbBug6gAOlyyXDpcXYM4ACcwpzAnsGmDCAAjsKfxYYO +oBAEbY7ASgkgACRttwgQAIbAisGCDe//QCUCE4twhMF2De//QCUCFZTAQCUBE24OoADJcpDAQCUB +FWIOoADpcslw6XEeDOAAnMKMwJzBTg6gAMlyag6gAMlwyXCOwT4MIABAJQIXksBAJQETMg6gAMly +lsBAJQEVJg6gAOlyyXDpcd4L4ACcwozAnMESDqAAyXLJcI7BBgwgAEAlAhmWCGAAQCUAF89xgAD8 +ChChhghgAEAlABnPcYAA/AoRoQfwANnPcIAA/AowoDGggQev/4AkAjrgeM9xgACcdOB/CGHgePHA +Kg+v/9hwKHZIcYh1Mg7v/8lwCHepcCYO7/+ocQhxAC6AAwR/Jn8AK0ADJHhlB6//5XjxwEoKwAXP +cYAARB7wIQAAQHjPcKAA0BuA2lCgz3CAAMwiAIAA2Q8IHgLPcJ8AuP89oNHA4H7geGCAQIEBgCGB +UHPMIEGA4SDBB8ogIQAwcIb2BPYJCsUA4H8B2Iog/w/gfuB4gOHKJE1w6CBtAs9xoABQDCWBARhS +AOB+8cB2Do//z3CAAEgkA4AYiKXBSiAAIB0IEQEKIcAP63KKIIwNZNsKJAAEwQLgALhzz3eAAOwi +JIcggaYPoAaKIAcOiiCZBZoPoAZn2c91gAD8soog2QaKD6AGLI2KINkGfg+gBi2NiiDZBnYPoAYv +jYog2QZqD6AGLo2KINkGYg+gBjCNiiDZBlYPoAYxjc92gAA4OM9wgAB0W8YLYA4kHgAUz3CAAJBb +tgtADs9wgAA4XK4LQA7PcIAAVFyiC0AOLY0F6WyNGwtCABYPoAaKIIcNiiCHDQoPoAYsjcPwBIdA +gM9wgACYpGCgIaBCoM9wgAD44giQKwkCAM9wgAD44gHaKLDPd4AAIM3PcIAACM1Mp0OACwplAAEY +AgQjoBCNgODKIGIAA6YRjRTokuvPcIAASCQDgAmAGQieAMIN4AEH2AHYAabPcKAALCAQgACmiiDJ +A4oOoAaj2YogiQPPcYAAmKR6DqAGIoEBhs9xgACYpCCBgODKIGIAGLgFeQOGCiIAgIogiQPKImIA +ELpSDqAGRXnPcIAAsDQAgBsIUQDPcIAA+OLPcQAAECdqDq//BYAQeALwANjPcYAAsMwHsQOGDBkE +BHkIUQAAgYLgzCDigAT0AdgAoUwWgBBhCFEAz3CgACwg8IDPcAEAmCRAwAHYQcAIHAA0EdhDwADY +jLhEwADYENkE2ghzmHC4cAAnhx8AAAB9egogBdhwiiDKBL4NoAYA2YogygO2DaAGANlLFoAQAeAP +eEseAhAMjYboAYaA4FgMQQXPcIAA5FsSCkAOAdnPcIAALBsgoKIM4AEG2HkEr/+lwKLB8cAODK// +mHJFwUEoAQIHeUEoAgQnesa6z3WAABDaSWVdZScJ3wEUFA4xz3OAAFDdaHI2euCCCwjBA+KSEw+A +EyeKp2rvCd6BANgn8MaKhu6A389wgAB4CuGoz3eAAJwkBY8LDgEQgNgFrwnwz3eAAKwnGY8LDgEQ +gNgZr8aKNnsAHIADB4qHuQCtz3CAAHgKQIggqAHYR6sM3N8Dj//xwHYLj/9IdcGAQIFhgQCArg6v +/8lxAKXJA6//IaXgeKHB8cADEgI313IAAABAAdrCIooAF7rHcgAOAACDuuxzQKPscgCi6gmgBChw +0cDgf6HA4Hil4B/yCfYvCNAAMwgQATsIUQHgfwHYveAP8gb2KwhRC+B/AtjM4A/yjCBDhw304H8G +2OB/ANjgfwPY4H8E2OB/BdjgfwfYCNjgfuB48cDhxYogUg4uDKAGtNnPdYAA0DKpcEAlgRveCKAN +LtoB2CkDr/9hHQIQ4HjxwJ4Kj/8fCLQACHUKIcAP63L92Iu4c9tKJAAA+QagALhzz3eAANAyN4cA +JZAfgAAkMw8NQRAMEIAggOCR8goI4AcF2DpwiiASDsILoAapcUQtvhsAJ0AeQJAhkADeCLpFec9y +pAC4PZsaWAAikAwYgiPKGlgAI5C3p8saWAAkkMQaWAAlkMYaWAAmkMcaWAAnkMIaWAAokMMaWAAp +kMUaWAAKkKMaGADPcIAABDAggGB5yXA1CBADz3CAAAQwIIBgeclwJQgQBM9wgAAEMCCAYHnJcBUI +UATPcIAABDAggGB5yXAHCJEEAN3PcIAASCQDgAiAz3GkALRFIwgeAEQtvhsAJ0AebJBLkHt7ZXpT +GZiADZBUGRiABfBTGZiDVBmYg0Qtvhsndw6XVhkYgA+XWBkYgBCXVRkYgBGXVxkYgBKXWhkYgBOX +XBkYgBSXWRkYgBWXWxkYgBoOoAcqcKEBj//geIbg8cAA2A/0z3CAABizpgrv/wbZz3GAALizAIGC +uAChAdjRwOB+4HiD4PHAANgJ9M9wgAAQs34K7/8D2QHY0cDgfuB48cCB4OHFANgJ9M9wgAATswHd +Xgrv/6lxqXBdAY//4HjxwJbg4cUA2Iz3z3WAAEinqXA+Cu//BNkLjYO4C60B2DUBj//xwJrg4cUA +2Iz3z3WAAEinBG0aCu//BNkLjYK4C60B2BEBj//xwKTBkOAA2cogQgAT9Itw9gnv/xDZABQAMYTg +zCBigQj0z3CAABzPH4AJCF4FTHAB2KTA0cDgfvHAWgiP/wh3z3CAAEgkA4AYiBpxjQgQAYTnAN2G +ACUAyiBFA892gAD8skAmABOiCe//BNkujrCuUyEAABGuQSjAIKC5XQhkAAIgQgBjv1UKxQMP6s9x +oADQDxARAIZhulhgEBkYgCURAIYPeALwD44A2VMggiAPIYEAJHgvJgfwz3GfALj/EK4Ygc8g4gfQ +IOEHGKEYgZ64GKEYgb64GKEB2B0Aj//geOHE/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwc +yLH8HAiy/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDhxPHAz3CgANAbFIDPcYAALAkEIICPz1EE +4QChEfIvKQEADwieBS8pgQ9AAAAAz3CAAGwv8CBAAEB4ug2P/9HAwcRrJMAQwcRrJIAQwcSfdAQU +CzQEFAo0BBQJNAQUCDQEFAc0BBQGNAQUBTQEFAQ0wcPBwsHBwcDBxEUsfhAKJkB+wcRrJIAUwcQg +IECH4HgIcl+4QKHgfwGh4HjgfwCAjCBcggHY4H/CIAsA8cDODm//SiRAAM91gABIJBUlAxAAg0Al +DhXRcMIkAgHwJQ0RyBUFFkQlvoEJ8gohwA/rco7YjbgBA6AAdNvIEA0GpXnIGFgAoIMG2UZ5yBUA +FiR4yB0YEACDyBAABoYgf44kDQEQ1QZP/+B48cBeDm//iiAMCc91gACICSSFsg9ABgSFiQgRAM92 +gAAQthMWApYA34QqCAkAIYB/gAAUrgKlJIgB2+ulbKUi6R0e2JMMEAUABCWBD8D/AABBKQQGz3GA +APjiFBEGAAUuPgEAIYR/PwD//wQkQQEeHliQIJCMIYKGAdnCIU4AKqXnpSSAz3aAAEyywLkqts92 +gADEKiiuQK4CiGSlAa4f8ASFOwhRAJYPgAgA2ASlAoUkiJPpJ4Uc4DZ4JIjPcIAAdCcHiBBxAdnA +ec9wgADAKiCgAtgC8AHYA6XtBW//AdjxwH4Nb/+KIAwKo8HPdYAAiAkkhc4OYAYA3gSFp+iiC0AA +AdgEpQKFBIiA4GICAQDPcIAAwCoAgIDgVgICAM9wgADsIhCAz3KAAHCyAIAjghlhz3CAALAqAIA4 +YF4LYA4CooDgKgIBAHnwBIWFCJEACoWQ6AwVBBAQFQUQCiHAD+tyz3AAAIoMZQGgAIojjgsihUeF +QCEAB1Z4RohgwkaIARyCMEaIAhyCMEeIYcJHiAUcgjAHiAYcAjCKIFMBJg5gBqgRAQAChYtxkg7g +DKgQAADPcIAA7CIQgCCAz3CAAMQqIaD+CqAAxaUD2ASl0fAEhXMI0QBChSeFQCIABzZ4BYgpCF4B +z3GAAOwiA5Iwgc9zgADEKiCBYYMKuGJ5DQkEAAnYC6WL8AWFjegEioDgr/LPcIAAcLKCCmAOAoCA +4KfyBYUF6AXYC6UB2Ajwz3CAAMAqAICA4Jv0ANhmD8AGl/AEhd0IUQCuDUADIoVHhUAhAAdWeEWI +OQoeAIO6RajPcoAAtD3Jgs9zgAAQthUbmIP5gsWC/mYWG5iD+ILEgv5mFxuYg8OCV4JeZhgbmIMF +iFkIXgB2CEAOkegKIcAPAoXrchwVBRAEEIQAz3AAAIsMHQCgAIojEABqCGAOAtj2DyAOCNgihQSJ +FwiRAAHYAKUA2A6l4g8gDlrYIoUEiQkIUQAB2AGlB4Uc4RZ5BYmGIP+MyiCCDwAAMEOgCmIEyiEi +AAKFJ4Uc4DZ4BYiGIP6HBfIC2ASlK/AE2ASlKfAkhQHYSwkRAQ+lz3eAAOwiEIcggM9wgADEKiGg +hgxgBoogDArPcIAAxCoM2XXaHttuD6AMGLsEh89xgAC4KgCA+gngACCBBqXEpQTYA6UB2FUDb/+j +wOB48cDqCm//iiCMCc91gACICSSFOgxABgSFewgRACKFR4VAIQAHVnhEiM9wgACACQCQAd4hCgEA +z3CAAIIJQJDPcIAATLIKkA0KAQDEpQDYTvAEiR7oz3CAAMAqAICY6M9wgABwsiOAz3CAALQqAICm +CCAGOGCM6IogTA3SC2AGiiFNB6oN4AYA2AHYMPDEpQHYLPAEhVkIUQAChc9ygABIJCOCZIBooSOC +ZYAc4GmhJ4U2eCSIA4IA3jSwAtgE2WIL7//Jcs9zgABMskKFB4VAIgEHFnkKkySJRILqCCAMyXPE +pQPYA6UB2G0CT/8MFQQQEBUFEAohwA/rcs9wAACJDFUGYACKIw4B8cDeCU//z3aAAIgJBIahwbro +JIYuC2AGiiCMCgHfz3CAAMAq4KAA2A+mAKYBpoogkwESC2AGiiFZBQLdqXByCKAE6XHPcIAAVAkA +gCaAnhEABqa4nhkYAKlwANm6Cu//BNoWCeAPqXDPcIAASCQjgEiBNJFTIgAAQgggDOlzpKbpcIrw +BIZlCJEAJIa2CmAGiiCMCs9xgACACYogjAymCmAGIJHPcYAAggmKIMwMlgpgBiCRAoYEiBboCYaU +6M9ygABwsgaCJYIOIIMPBwAgoRELRQAH2AumAdgMpgmmBPA4YAWiA9gz8ASGIwjRACSGUgpgBoog +jAoLyAQggA////8DCxoYMATYIfAEhkMIEQEkhjIKYAaKIIwKUyDAQM9xgACgXfoOIAAAoc9wgAD0 +sTqAz3CAADCwhCkICTAgQA5RIECABdjKIKEBBKYj8ASGAd89CFEBz3WAAPSxGoUE2ZnaHttAwItw +1gygDBi7GoXppoQoCAkAIYB/gAAEsCuAobkroAbYBKYA2AbwBIYPCJABAdixAG//ocAG2AOmANjV +8eB48cA6CE//z3WAAIgJBIWlwYvoJIWKCWAGiiCMCAKFBIiX6ALYBKUEhacIUQAFhY0IEQDPcIAA +7CIEgM9xgAAwYgCA/gwgDiCBs+gA2Dfwz3CAAOwiBIAA3sWlz3GAALQqAIDWDqAAIIHPcYAAMGIB +3wTaAKHPcKAALCBAEAcAz3AAAFCBQMAF2EHAQsdDxkTGyXAG2clzmHa4dgAnhw8AAAB9rg2gBNh2 +5KXpcC7wNgygBAXYBNgD8AXYAdqD6AHYJPAphSEJUABMpQulDPAEhTcIkQAkhcoIYAaKIIwICYUJ +CFEAAdgO8OvoAoWSDWAEA4AIcc9wgAA8W5YNwA0A2FYPQAbd8QDYmQcv/6XA4HjxwCoPL/+KIEwJ +z3WAAIgJJIV+CGAGpcEEhYDgp/QChUeFJIBWeM9ygAB0JwQhgQ8ABgAAgOEB2WeKIBCOAMB5Ew7B +EM93gABMsuqXwYoLDsATAN4F8MaK+wmBgwHez3GAAMAqwKGW7s9xgACACSCRIQtBAM9xgACCCSCR +YYoVC0EAz3GAAIQJIIlGigkKQAAA2QPwAdnHCRAAHBAEAM9wgABwsgwYAAHPcIAAmKQEEAUAz3CA +APjiBYAFKH4BQCmAcpBwyiLOB8ogjg8AAIgMyiOODwAAAQPAAm4AyiHOD89wgAC0KgCAbgzgBYBw +heguC0ANTfALyAQggA////8DCxoYMM9wgAC8YQCIAN7FpYnoz3CgACwgEIDHcAAAAH0SpUgVBxDP +cAAAFIFAwAXYQcAB30LHQ8ZExulwBtkE2gDbmHO4c/oLoATYc89wgAC8YcCo5KXpcBzwANjPcYAA +vGEAqQLZI6UU8ASFAd4jCFEABYWb6M9wgABwsiOAz3CAALQqAIDSC+AFOGAF6AHYAQYv/6XAz3CA +ALxhwKg2CqAEBdgA2ASlpPEF2Aulmg1gBslwANnPcIAAvGEgqOnx8cBqDQ//z3aAAIgJBIbpCBEA +AoYEiBPoz3CAAMAqAICN6M9wgABwsn4LIA4CgAfofgjgBgDYUQMAAM9wgADsIhCAR4YggM9wgADE +KgGAAnkChlZ4B4APCQQAAdgEpikDAAAAhgvoFwteQALZz3CgANAbM6BOCSAOHtjPdoAA7CIEhs91 +gACICQCA5gkgDiaFgOD0AgEABIbPcYAAuCoAgMYLoAAggQalAoUnhRzgNngFiIYg/4wK8s9wAAAw +Q89xgADgKuYLAAQChSeFHOA2eAWIUSBAgLACAQAAhQjoz3CgACwgBoCA4JwCAgCiCwAElQIAAASG +geCQ9CSG0g0gBoogTArPcIAA7CIwgCCBwg0gBoogTAoChieGHOA2eAUQhgAA2k+mgQ4eAM9zgADE +Ks93gAC0PRiHJIfPdYAAELYZYRcVAJZYq1wXBBAMFwUQACUFARgVBJYCeQIlBQEVFQCWJBcEEAIk +BIAWFQ2WBYeieMolgRAE8gHduKsN6UAsjwANCcQDTyWAEAXwBehPJUAQD30Yq0EpwAA4YAkIRQGC +vbirWQ5eAACGDujPcaAALCAmgQ6GInjPcYAAxCoFoUCmBfABhgPoQabGCgAEPggADicIkADrdTII +AA4MFgQQuHDPcAAAjAwKIcAPqXLtByAAiiMTCzoIIA4A2AKGJ4Yc4DZ4BYiGIP+MBfIC2ASmuvAE +2ASmuPAEhhsIkQDPcAAAMEPPcYAA4CqCCgAEBNgEpgSGhOCr9CSGlgwgBoogTArPcIAA7CIQgCCA +z3CAAMQqQCANBzegdgwgBoogjA0ihhwWBBBAIQAHFiAAAQWIPQgeAADaSiTAcEhzqCCAAfAlwBAB +4xpiA99KJEBxANuoIIAB8CXAEwHnG2MRCsUAz3KAAMQqGIqCuBiqAN3Pd4AAcLKlpwyRQCRCAA8K +JQBHpocRAAYRCF4AAdjiDaAGDKZa8HoKYAYLhgvIBCCAD////wMLGhgwXgxgCKumiiBMDd4LIAaK +IZQNB4YihhZ5iiBMDcoLIAYngQLYA6YChs9ygADAKiSIjuknhhzgNnjPcYAAdCcniQSIMHAB2MB4 +AKIp8CCCBekB2AOmI/AnhjZ4HBAEAM9wgACYpAQQBQDPcIAA+OIFgAwfABEFKH4BQCmAcpBwyiLO +B8ogjg8AAI0MyiOODwAATgVgBi4AyiHOD6SmTQIv/wHYDBYEEBAWBRAKIcAP63LPcAAAjgw9BiAA +iiPVBeB48cDPcIAAwCoAgBvoz3CAAOwvAICZ6HYMgAyJ6AvIBSCADwAAADwLGhgwZgyADInoC8gF +IIAPAAAA1AsaGDALyJC4CxoYMCoKwAXRwOB+4HjxwHYJD/9IdUCAYYDBgQCBhgwv/8lxAKXJAS// +IaXgeECAIYBOIgOAANoDIkIAYKDgf0Gg4cUB289ygACoCH6y4HjgeOB44HjgeOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeAa4RSDNAM9woADsJ6ag +CoAA2wCxfrLgf8HF4HjxwIogygY2CiAGANnyCgAD9gmAD7IPQA+A2c9woADQGzCg0cDgfuB48cCi +CA//GnAB3wAQEgET8Fp1EfAVIMAjoJACEBEBAefXdQAA+//wf3T2GQqALwAA///PcAAA+//dCIGE +wQAP/892gADkIgCGAeAAphUIUQAB2c9woADIHDGg4gqgDyhwBr2BvUApACSleM9xoADsJwahAIZC +IECAAKbd9c9xoADIHADYEaHX8fHAz3CAAIwxAICB4Mohwg/KIsIHyiCCDwAArxPKI4IPAADzAcok +IgBsBCIAyiUCARoIAADRwOB+8cCOCAAP6g9ADNHA4H7gePHAvg/P/s9wgABIJAOAKIDPcIAAhLbA +uTZ4JIAAgAq5BCGBDw8AAPzJuCV4z3GnABRIDaFSCSAHocH6cM9xgADkIgCBAeAAoRMIUQAB2M9x +oADIHBGhFgqAD4txRg7v/0LYz3AIAIcQz3egAOwnBqcC2QDYOnAKIECk2nHKIGIgD3kvJQAkSiMA +IBVpELiBuIe4jLgGp0okACGKdQoiwCRhvUAoQCFAL4IhWGAVIE4DmHWAJIINx3aAAMC2ApYvJAgB +QCyBAYG5HHgQuCV4BqcilsC5uHkFIcAELyMIIAOWmHWAJEIPLyQIARx4QCyBAYG5ELgleAanA5bA +uLh4BSCABC8iCCCKINgHOgggBqlxiiDYBy4IIAaqcSKWiiDYByIIIAY8eSOWiiDYBxYIIAY8eUIk +VCBtDFWgQCsAJAUggA8AAAIvBqdAKgAkBSCADwAAwjAGp0ImQSAdCXWAQCFAIAAUADEQuIG4h7iM +uAanz3CAAOQiAIDPcYAA5CJCIECAAKEG9M9xoADIHADYEaF1Bu/+ocDgePHAANiNuEYN4AsGGhgw +DMyGIP+KCPLPcIAAIDoAiIDgGA5CBNHA4H7PcQMAQA3PcKAAqCAtoM9xgACsC0CBAWoAoc9woAA4 +LgWABCCAD8AAAAAdCIAPwAAAAEjYz3GfALj/GqFboWnYGLgZoc9ygAB8WQaCA4AggMdxAACIEx0E +oA1IcPHAtg3P/s9xgACoZSGBo8FCwc9xgABIJBUhEAAAEAAgwBAOBi8ogQNOII0Hrw4QEBJtFngA +IJIPgACQ2gYSgCDPcYAAUN0WeQCBIpGO5QgcRDDKIGEABvKLcloJb/8CwTboANjPcYAAIApAgQ8g +QAMvIQogBCGAoAChB/SA4rwIogfKICIIr3jSDWAEENkA3wQaxCOKIQgAABpAIKlw6XH2CKAGD9oA +EAIgwBIABgQgQATAGhgAz3CAANDdtnjgoOGgz3CAAPDZtHjgsBAmTpMvKIEDTiCNB6z1OQXv/qPA +8cDhxQh1BPC+CoANHgugDalw/OhFBc/+o8FCwgkUgDCB4AHYwHgQuAHg4H+jwOB4o8Hgf6PA4Hjx +wAohwA/rcs9wAACKJxzbiiTDDwUBIAC4c+B4osHhxULBQSgCAgd6QSgBBEd5z3KAABDaxrkqYiUK +3wEIFAMxz3WAAFDdqXFWeUCBCwiBAEKREQrAAEeJ7wregYDYA/AGicHF4H+iwOB+4HjgfuB48cAI +yJW4CBoYMAnIm7gJGhgwC8iKuI24kLgLGhgwz3CAAEgkA4AYiBkIUQALyM9xAABYKay4CxoYMD4L +YAYP2NHA4H7xwOHFCHU+iM9wgAAAGkCAQCUAFAO5NXlZYbYK4AwK2poP7/+pcEkEz/7gePHAzgvP +/kh1wYAAgChyeggv/8lxAKUlBO/+IaXhxWCAoIEBgCGBAiNDg2CiAyBAAAGi4H/BxeB48cClwUHA +QsEMHAAxEBxAMc9xgAB8mDQZwA8wGQAPLBnADigZgA4kGUAOz3CAAHyYIBhAC89wgAB8mBwYAAvP +cIAAfJgYGMAKz3CAAHyYFBiACs9wgAB8mBAYwAjPcIAAfJgMGIAIz3CAAHyYCBhACM9xgAAAmIAZ +AAh8GcAHeBmAB3QZQAdwGQAHbBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAESBmA +BEQZQARAGQAE76HOoa2hjKEsGcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAAA9gZ +AABqIMAC1BkAAGoggALQGQAAaiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAAuBkA +AGogAAC0GQAAaiCAAcwZAABA2J+4z3GfALj/HaHPcKD+AAAWoVMjwAQFIIAPsP4AABahGIFTJ801 +UyXENVMmxTWUuBihQMMBwALB17oMFAYwqXMmCuAFEBQHMDIKYAwA2M9xoADIOy6BagvgBX3YHgnA +A89wAACt3voNgAAI2ADZvgwgBpm5gQfADOB48cDmCc/+z3KAAEgrz3WAALBhDukAogCFk+hOCiAB +D9h2DWAHCNgB2AClC/AA3sCiAgkgAQ/YJg1gBwjYwKUVAs/+4HjPcYAATC8AgRzaz3OAAIgJQKBC +g1UiwAkBoaASAACNuKAaAADPcIAA0AukGgAAnBIAAWeDBKFVIkANA6FAIgAHdngFiBkIEQjPcIAA +gAkAkEh0gCREEwCsHtsD8BjbYqFVIkANeGAFoUUHIAwocOB48cAuCc/+z3CAAOAYA4AQ6M9ynwC4 +/x2iz3GAAMwiBIEB4LO4tbi4uAShFqLPcIAALAlAgM92gABYFaCGBCKDDw8AAOAEI4EPAQAAABJp +ZHgHfaCmmHUEIo4PAAAAQM91gABUFeCFA75kfj15x3/gpQQkDQAEIoIPAAAAgAYjQANFeQK55H4E +I4MPAgAAAMZ4ZHkmeC8oAQBOIEEEDRpYMA8JkAHPcIAAzM0OkCfoz3CAAOAJAIjPcoAASCTwIgIA +vxICBlMiQoAZ9M9ygAD0aQS4AGIjCZEBz3KAANzN9CICAA3qz3KAACBAI4INGhgwAeEjogTwNwkA +AChwz3OgABQECqPPcoAAAApAigDZDQpRAEmDBwoUDgHZAd2J6c9xoACIIBV5oKET8AbY3PEGD6AL +BhpYM2IOQAWL6ADZkbnPcKAA0BsxoAYP4A2pcEkAz/7geOB/ANjxwOHFz3CAACwJoIB12AQljR8P +AADgJgngBYohhQkvLUET3g/v/04lQBQKJQCADvIKIcAP63LPcAAA3g6KI8UKBQTv/04lRBR/2Aq4 +z3GgANAbE6F/2BCh9QeP/vHAeg+P/s9wgAAMMCCAAd5geclwz3GAAPwKYoEH34DgzCDigA30z3WA +AJQS4aUA2oDjyiNiAHN7wrtipQzwANqA48ojYgBze8K7z3WAAJQSYaXipSOBz3NoH/8AY6WH6cal +EwjQANGlBvANCVEAAtgGpVGlUqX/2ADZCdoIc0okgALSD+/+SiXABADZE9r/20okAAW+D+/+SiVA +BxOlz3AgACAgB6U9B6/+ANiD6ADYBPD/CFGAAdhI2Q8hAQDPcIAA6BLgfzGw8cCqDo/+CHbsiCiW +z3CAAEwJsm8oc4Yj8w+2fUIrEQLHdYAAkNpghQhyCQteA0Ro67mKIMMvBPQeFpAQDY5RIACAovJ5 +Cd8AKwveAv/YB61KJABxANmoIIADKGIAIYMPgAB44vZ7BKsoYgHhL3kAq1vwIwkSIQohwA/rcs9w +AAAtJYojCwRKJEAAmQLv/wolQATuuQeNMiJCBAAhgS+AAHji9nkI8kSpBNkAKUEEJXgHrT3wQKkP +IEAEY/AtCBIkjCDDr8ohwg/KIsIHyiCCDwAALiXKI4IPAADkAsokYgBAAuL/yiUCBNYJ7//JcAiW +CwieAwKOCa0D8AGOCK0AhTEI3gIA2ketSiQAcc9xgAB44qggwAI4YvZ4BBgCBAAYAgQB4k96AY4I +rQKOCa0s8EwhAKHKIcoPyiCKDwAALyXKI4oPAAABAz4H6v/KIsoHCJYAIYEvgAB44u64B432eQny +BBkCBATZAClBBCZ4B63d8QAZAgQA2Q8hQQQmeAetAY4IrYUFj/7xwCoNj/7Pc4AAVApggwDez3Wf +ALj//YV5Yc9zgAAwCeCj3aXPc6AAUAxgg8dzAAAAQCJ7zbsLCwUA7QsewM9xgAAwCWCBz3GfALj/ +faFRIwDAyiAiAB/0OQpRAM9yoADQDxASAYYpCFQAz3WAABgbn3BjhaggwAICjSUSD4bBuNNo2H8B +4AKt53tjpRAaWIAB2AEFj/7geM9wgAAwteB/BoDgeM9wgAActeB+4H7geChyCQAgAADZ4cXhxkAp +DQIlfUAtAxSleyUKNAIIdVMlfpAG8gEdUhBhuvvxQSqOAMG6QiZOkAQd0BD99QnqLySJcOB4qCBA +AQEdUhDgeMHG4H/BxfHA4cXPdYAA7K0gjYwhw48J8gfoz3CAANBZ8glADf/YAK3PcIAAlK0A2TWg +z3CAABQbIKDPcYAA7C8AgaK4Wg+gCQChANgCCu//CHFRBI/+8cDhxQDdz3CAAJAKoKDPcIAA7C+g +oM9wgACMsql0nbAwvJ6wcgtgBKlwqXDSD2AIqXEdBI/+4HjxwJoLj/7PcIAA4BgCgAcSDzYNEg42 +ARIQNhDoz3KfALj/HaLPcYAAzCIEgQHgs7i1uLi4BKEWogbYDRoYMM91oAAUBAqlCYUm6APYEKUE +pc9wgACI49IL4A0DGhgwktkDyJC5oBhAAGYOIAQA2AmFDugoFQQQJBUFEB7YCiHAD+tyjLiJB6// +iiMEBgca2DMBGhg0z3CAAMwiyqUAgA0amDMRCJ4Az3GfALj/ANgdoU0Dj/7xwO4Kj/6hwQh1KHaK +IEQPPgygBalxCw3VEBPdl/CpcMlxog3v/wDaz3Kg/uwCz3GfALj/hehIcBahtqHv8UAiAA4Wobah +z3KgAFAMBYLPdoAA/LISrgWCE64JlowgiIAqbUbyEfZFCNABjCDEgWn0WwmUAM9ygABIp+IL7/5A +IgACSHEf8IwgyIBL8owgEIBX9AWCCWkLCFUBAN1S8A4JoAYA2Qh1TvCTCVEAz3KAAEinqgvv/kAi +gAILioG4C6rt8QuJgLgLqenxcwlRAI4L7/6LcCDAz3GAAEinUyACAIYgfw9IqRx4Cant8U8JlAPP +cIAASCQDgBiIQwhQAM9ygAB8pEhwVgvv/gbZQCIAAkoL7/4G2QySgbgMsr/xHwkUAc9ygAB8pEAi +AAUuC+/+BNkMkoC4DLKx8RPdAvAc3YogRA8KC6AFKZapcA0Cr/6hwOB48cDPcIAAfKQMkA0IHgDq +CQAEBvBRIECAhAsCBM9wgABIpwuIEQhQABMIkQBWDMAE0cDgfmYNwAT88fzx4H7gePHAVgmv/kok +QHHPdoAAsMwkhgDdqCBAAgDfDydPEwshwIME9AHlDfCKIEoOjgqgBalxBIbmeASmKg9gAKlwBIaA +4GQI4QDKIGECdQGP/uB4CHM4YNW71bkNCeUANrgCI0IACvDPcoAA+OJFggHgybgienpiFrjgf0V4 +4HjxwNoIr/6Ycgh1z3aAAAyo9CZAEM93gACMp1EgQILKIEEAyiQidMogIgDoICIC9CYCEAkKXgIB +4EcIFQQtu8C7z3KAAPDZtHpAK4UCYJIEvYYl+BOJvQ8jQwBgsgDaFn9Ap0Gnw7mleQUhQwEUfmC2 +z3GAACyoFXkAGQABAvCA2MEAj/7gfuB48cDhxc9xgACcrEGJz3WAABQbz3OAAOwvIIMH6gHYAKWC +uSCjCPAA2kClormA4CCjkAuCCQDYPg6v/whx5gtgAgDYiQCP/uB48cAOCK/+mHADEgE2AJEhgUDg +9LnAIKIAA+AEIIAPAAD8/89xoADUBw8RDYYAIAUBEw0lEQDaDcgVIgMwDhMABh1lGREAhgIlQwN7 +CMUABd0Mvc9woADIH76gEN2uoAHdFRhYg892nwC4/72Gz3CAADAJoKBdphkRAIYLCMUA+wsewM9w +gAAwCUCAz3CfALj/XaAzCx5ADcgVIgIwDhICBs9wnwC4/1agdqAZEQCGCiHAD+tyQ9jPcwAARBa9 +A6//jLgPGViBtQdP/uB48cAWD0/+q8HPcIAAeOMAEBMAB8gEIIAP8QAA8EDADcwA3s91oADIH1Eg +QIDPcIAAeOMhgAPID/KgFQIQ+BUDEGJ5AiJXAHYQAQEvJ8glWWEE8IQQFwHicToYxAUfhQ8IRQAw +eJYP4AUC2QHZz3CgANQHNKAzoAPf7aAREACGz3GgANQHQcBA4A8ZGIAUGZiDA8ikEAEADQkeAuYM +gAsE8EcdmJPPcKAA1AcNEACGQC8BJBB4BSEVAAPIIYAAEBIBQ8G4EJgAchABAboQAAECIRQGMgjg +BkTAGQhRAM9wgACgIgCQgeAB2MB4DLhCwAPwQsYDyM9xoADUB1mAiBmAAKQQAQDZoLgYggO6GIQD +t7mkGEAAA8ATCJ4Fz3KgAEgIQCIBIwbwQCIBIc9yoABMCATAAsMDcWV4BSUVIAdpz3MAAPz/ZHjP +c4AAeONjgwggxQDPc6AA1Ac1owAaQAUCIgElL6MCJQEAO6Pwo89ygAAwOg0SATYAgj0IQADPcKAA +OC4FgAQggA/AAAAAIQiAD8AAAAD12AW4z3OfALj/GqM7o2nYGLgZowHYA/DJcAkIUQAgos9wgAB4 +4wQQBAACI1Mhz3KAAHS2iHCAIA8KHqUQ2A6lAdgVHRiQB8gEIIAPAQAA8Cy4AxIDNgSyD4POqgCi +QBMAAQKyEItgEwMBQCgFAcO7BSNDAWayD6ovIwgBz3CAAEjOQCAFCTV4KYDPcoAAzM07Y2mgpBUA +EPgVARCAcCJ4RcAB2M9xoADUCxChA8A1uMC4F7gAIIEPAA4AAM9wgAB44wKAArgr4AQggA8AAPz/ +JXjscQChARIBNuxwIKDPcIAAeOMigOxwIKgNyBQiAQAwiexwIKjscMCwA8iUEAEA7HAgoA3I8CUB +AOxwILDscMCw7HDAoOxwwKAHEgE27HAgoAPIIJBUEAABELkleOxxAKEDEgM2AYMfCB4BMotwi89w +gADQ3HZ4AIiGIH8MHHgEuCV4AvCA2OxxAKkDyDt2MIgzEIAABLkleOxxAKkDyBp2PJDscCCwAxID +Ns9wgABIXZwTAQFvgya5wLnAuwy5DbtleSCgDRIBNgAhgA+AAPTNwKjPcIAAeM02eDR6wLICkMAa +hAMVJUEAeBoEAM9wgABIJASAGpDQGoQDRsDPcIAAeOMCgMChgODKJY4TFAMuAMohjiPJd8l1OnZM +IACguPIT8M9xoAD8RB2BOYEEIYKPAAAACBH0BCC+jwAGAAAL9E8LH0DPcKAA9AcHgADe1Qjehy3w +AN76uMomgh8AAAEC+bjKJoIfAAACAvy4yiaCHwAAAQIK6s9zgACkP1CDiiYIEgHiUKOCDsAOEfAB +2c9wgABEXSCgUg9gDShwz3GAACBADYGKJggSAeANoQUljZMQ8msCIAAA3oQSAAArCJQMnQsfQM9w +AACQE2YOAAXPcqAA1AcPghB4GRIBhljg2wkEgAnwz3OAACg/JIOKIRAhAeEko4sJnyAeGtiDHRIA +hgcaGDAdEgCGSsAdEgGGBMggoB0SAYYhoB0SAYYioB0SAYYjoB0SAYYkoFYnABIeGhiAHRIChkAv +ACRQeQUhFQAEEgE2hiLzDwAREgGMIgyAAYFDwBfyGtgW8M9wgAB44wgQBAAAEAUACiHAD+tyV9jP +cwAAjBPRBm//jLgA3tDwINiacANwEHhyGQQAAN4JCBEgA8h08APAEwieBc9xoABICEAiACMG8EAi +ACHPcaAATAhHwQNwSMAEwQLAJXgFJRUgCMAH4M9xgAB44yOBBCCADwAA/P8IIFYADCbApCwBLQBJ +wEoNAAAFJQ2QmfQB2c9woADUBxQYWIBVJ0EUDxhYgAEKH0IIwM9yoADUBxWiB8MCIgAlABtABQ+i +CcMCJsAgG6ID2BCiKsCc4ADZj/QHEg42AMAEJoIf8QAA8FBwlfQDyKlyyLoCI5MlCIgMuEV4AxIC +NxC6RXjscgCiCsBAIVkwARoYMATIAxICNih2QccDGhgwBBqYMCGAAJABxzS5wLk0eAPgQOcEIIAP +AAD8/x9nDRIBNgfwFSJAMA4QAAYCfxUiQDAOEAAG8Q8FkAPMz3GfALj/GKHPcKAA/EQ9gAQhvo8A +BgAAXPQbCBAgBMhQiFMiwQCGIv4DRLrEGIIAMKjPcKAAFATEoAfIz3GgAEgsHaHPcIAAeOMCgEAg +UCAScBgFzf8M8M9ygAAoPyOCiiESIAHhI6IC8Dp1XgzABVMhfqAE9AYMAAAFfZ0NEBCHDV4QA8gp +iAHhKajPcYAAKD8GgQHgBqE/8AohwA/rcigUBTA82Iy4z3MAABsU6QRv/0okQAAAFAQwR9gKIcAP +63KMuM9zAAAjFM0Eb/+4dkwgAKDPcoAAKD+KJRAQCfQHyM9zoABILIolCBAdoxEJngYFgoC9AeAF +ornxBoKBvQHgBqKz8RMNHhDPcYAAKD8FgQHgBaE6dQPIqXHIuQiIDLgleAMSATcQuSV47HEqdIQk +ApEAoUAhTzAc8s9xoADUB4AZwAQDzCpyyLoQuEV47HIAosyhAdgUGRiAagvgDgHnz3Gg/oQAz3Cf +ALj/NqADEgI2khIAAQQSATYNCJ8CkhEDAW0LngKquJIaBACSEQABqrjaCuAIkhkEABDZz3CgANAP +EBhYgCQQAYbPcoAAiOdFkjB5ArpFeQwYWIAU2RAYWIDPcYAAiOdnkUaRGNkQu2V6DBiYgBAYWIDP +cYAAiOdpkUiRELtlegwYmIAG8M9wgACI58qoz3KgANQL0KLHCRAgz3Gg/rgAz3CfALj/NqAG8AjZ +7HAgoAHnz3CAAHjjAoDxDwSQz3CAAHS2JJCU4cAhhg8AAJMAz3CgAGgs8CBAAM9xgABIXSCBz3eg +ANQHJXgNogPYEqeqC0ALDw1eEr4Or/8BwAbwA9gTHxiQFB+YkzEIECDPcKAALCAwgAXAMHAB3col +hhMEII9PIAAAAM9wAAA1FeYJAAWA5cwnIZDs889wACgIAAYaGDAGwKIOoAXJcVEhQKCv8s9woAAs +IM+gqfDPcIAA/DwRiDkIHgA1CB5Dz3GAAEgkI4HPcIAA/DwQiBC4MiGBDwAA2AKfuIDhAdnAeQ+5 +JXjPcaAA/EQNoRsLECDPcKAA9AdgGMAEz3GAACg/A4EB4AOhz3CAAHS2JJCU4cAhhg8AAJMAz3Cg +AGgs8CBAAM9xgABIXSCBANrPdqAA1AcleM9xoADUCw2hTKaKIAQCMg8gBalxhg1gDQbAGRYAlsDg +ngAOAA3MmwheAAPdIB5YkwHYFB4YkAQSATYAFgRABxoYMQAWBUABGlgxBMqc4MoiwgfKIIIPAADc +Dsojgg8AAPQK6AFi/8ohwg8ocEoOIA4O2Q8WAJYEEgE2tBkEABMeWJMQiVMgwgCGIP4DRLjEGQIA +UKnPcBIgAAA2CiAEDRICNgTIz3GgACwgsBAAAS+BZOAwcMoghQ8SKAgAhPfPcAAoCAAGGhgwAN4N +zAQggA8AAAIIFQiRAAQSATaKIAQABgpgCZgRAQANyM9xgADczc9ygACwzBR5wLEmks9wgAB44wKA +GWEweSayrdjPcgC7ALv6DCAHBbgDyBqQ2gxgBw0SATbNBC/+q8DgePHA4cVPCF5Dz3CAAHjjAYDP +caAAyB+WIEEPHqEQ2A6hAdgVGRiA4g6gDkHYJwheQwHZz3CAAERdIKCGCGANAdjPcYAAIEANgQHg +DaGKJQgSLfDPcaAA/EQdgTmBBCGCjwAAAAgA3Qf0BCC+jwAGAAAY8gDd+rjKJYIfAAABAvm4yiWC +HwAAAgIJ6s9zgACkP1CDiiUIEgHiUKNGD4AOB/AD2c9woAAUBCWgfQQv/qlw8cD+Cw/+CHXPdoAA +TBAAjqjBswgRAIt36XDPcYAALGaiDC/+INoB2ACuANiPuAsaHDAA2BUaAjDPdoAAAACgtg8NgR8A +AP7KB8CAuEfAz3CgAKwvGoBSIAAAEwgeAAGWgLgBtgfAgbhHwM9wgADsaaCIqgmgBKquz3FDdagS +QMGKIRoKQcErjgSmRsDpcGPBDRxCM89xgABsQUTBz3GAANhARcEg2QHaPdu2D2ALF7sI2B4OYAUB +2QLZz3CAAJQqJKClAy/+qMDxwDILD/4ods9xgABIJC8gByCE6GGBA/BggcQTAwYlu/AhDQDAu4Dm +oqGjocwjIYAB3colIRDPc4AAkCfoiysPURLhgcQXDxYfD14R7JN+kRcPwBARCFAAh+gAgcQQAAYH +CF8BAN2B4solIRAA3+YKoAvpcApwvg4gBqlxz3CAAJQqBIAjCJ4Az3CAAGQ8AICL6M9wAAAWCWIJ +wAQLCFEA5g6ACgzwANmeuc9woAD8RCGg4HjhoJ4KoAsA2IDmmAtiAMogYgDqCMAEhejqCgANA/Ae +CwANz3WAAPATAI2G6GoJQAwB2ACtrQIP/vHASgoP/s91gACwzMSVIO7PcKAALCAwgADfBoUnpQ4g +QADGCy/+yXEIpYogiguCCyAFyXGKIMoLdgsgBSiF5LXPcKAALCAQgOW1BqVlAi/+CIXgePHA7gkP +/jpwz3WAALDMAIXPcYAAYDQCuBV4FSBABDAhEACKIEoNNgsgBSpxiiCKDSoLIAUKcSEIESEAFQQQ +CiHAD+tyiiDMDIojxQIZBi//CiVABGkIECAnCFAgOwiQICUI0CAAFQQQCiHAD+tyiiAMDYojRQvx +BS//CiUABM4KAAAe8IogCgvSCiAFiiHFBmoJAAAU8ACFA94VCFAAiiAKDboKIAWKIQUJwKUA2AWl +BIWguASlxglgAAPYkQEP/vHAz3KAALDMJpIB4QeSMHkxCGMAJrIEig0IUQAFioHgAdgD8gDYDuhy +CiAFiiCKDoogygFmCiAFiiGGDJ4IAADRwOB+8cDhxc9wgAAcz0CQRCIAA38IEQIA3c9xgACwzKWh +BIGguAShSwqfAQSRz3KAAAjNAeBEghB4LQolAASxBIkPCFEABYmB4AHYAvIA2AroiiDKAQYKIAWK +IYYBPggAABnwz3CAADg4A4AQ6APYD/DPcQAA///iCSAFiiAKDs9xgAA4OAOBAuijoQTYlgkAAN0A +D/7gePHA4cXPc4AAsMwEE4QADwxRAAWLgeAB2ALyANiL6AUThQAKIcAP63KKII0OoQQv/87bAtgA +owDdBJOpo6WjprMKowSDpLOguASjiiDKAXYJIAXV2WILYAapcH0AD/7gePHA4cWKIAoNWgkgBcDZ +z3WAALDMiiDKC0oJIAUohQDZA9gApSWlJIWguRoI4AskpUUAD/4A2c9wgACwzCqg4H8poOB48cC+ +D8/97g/P/89wgADczGCAz3KAALDMqIBgos92gACwNASCqKIA2cCGoLglogSiLw5REILjzCPigBj0 +z3CAADg4I6AK7YogCgvWCCAFiiEEC24Pz/8K8NIKAAAG8AHbYKIooqC4BKLBB8/98cBSD+/9ANjP +caAALCBQgc92gACwzCSOz3WAANzMCKULCVEAJY4JCVAAAdii6CqGHOkGhrYIL/4OIIAAz3EAABAn +JQkFAM9xgAD44iWBmSHNChkIRQAF8M9wAAAQJwilAtgH8ADYB/AJhvjoAdgApQHYTQfP/eB48cDh +xQh1iiAKDjIIIAWpcc9xgACwzASBDyBAAwShPg8gAAnYKQfP/fHArg7P/c92oAAsIBCGz3WAALDM +B6XPcIAArFt2DKAMAN+KIIoL7g/gBCSVABUFECUNUABMJYCAzCXigE7yCiHAD+tyiiBMDYojCAfR +Ai//iiSDDwSVgOCW8g4Mz//PcIAA+OIFgCiFmSDNCjBwAdjCIA4AgOCI8s9wgADIN+mg13EAABAn +byALAB/oBI0PCFEABY2B4AHZAvIA2YogCgsI6XIP4ASKIccEqg3P/2zwYg/gBIohBwbPcAAAiBP2 +De//CKVg8IogCgtKD+AEiiEHCOINz/9Y8ASVoegllQiFgeHAIIEPAACIEwPyG3gIpYogCgseD+AE +iiFHDc9wgAD44gWAKIWZIM0KMHAB2MIgDgC26AoJAAA08BEIUQCKIAoLiiGHDirwCIUdeNdwAAAQ +JwilbyALABzoBI0NCFEABY2B4AHZA/IA2YogCgsJ6cIO4ASKIYgB+gzP/xLwtg7gBIohyALPcAAA +iBMIpQjwiiAKC4ohyASaDsAENg3P/wSVBbWKIIoLig7gBCSV5LUQhoUF7/0GpfHAz3GAAJikQYHP +cYAA+OIlgQUpvgAwcMogTgAMIQDwz3EAABAnjg7v/cogRQ7PcYAACM0EodHA4H7gePHA4cUA2M9z +gACwzACjz3WgACwgEIUB2c9ygADczAajEIUgogaiz3CAAMg3A4gkq4wgg4YkqgTyJaolq+4LIAAD +2BEFz/3gePHA4cXPdYAAsMyKIIoM6g3gBCCFAdj1BO/9AKXPcIAASCQDgM9xpAAcQAiAwLgTeMG4 +EqHgfuB44cUA2kokAHTPdYAAjKfPc4AABKhIcKggAANAIwECFHlAsRYlARBAoUGhAeBKJMBzANmo +IEACz3CAAPDZNHhAsAHhz3CAABwKQaDPcIAAfKRMsOB/wcXgeAXwQnnHcEAAAADPcoAA+OJFgvMK +RIBTIEMFcHHAII0PQAAAAMAgjQDgfyJ4BvBieQIggA9AAAAAz3KAAPjiZYLvC0SAUyBCBTpiCwuE +ADhgB/ACIIAPQAAAAGJ4OGDgfvHAogvP/c9wgACozwyIGQjfAQK4z3GAAJDaFngFYS29wL0D8P/d +kgqABAnoz3CAAJAnCIiH4ALYAvIA2M9xgAD8sneJz3KAAJS/IYIJC0AAIIKE6QHfA/AA3892gABI +JCCGxBEBBlUJXgGo7SOGOIlJCRABAgyADM9xgAAwPhnvz3KAAFQKAoIB4AKiANjPcoAAIF0Aos9y +gAB8XACiz3KAADQJAKIRgQHgEaEE8BCBAeAQoXYMD/7+CYAEDujPcIAAkCcIiIjgzCVhkAb0qgug +DAHYigmABYwlw59J8hHvz3GAABQbAIEL6ADYAKHPcYAA7C8AgaK4Gg7gCAChGg4ADM9xgAD44gaB +RSBAAQahz3eAAEinC49RIMCAoA/C/QuPUSCAgAANAgQmDcADmgmABIDg8AoiAMogIgYG7QCGxBAA +BisIXwHPcYAAbDwEiQ/oA4mK6Iog0A6uC+AEiiFFA04O4AoD2L4KIAAV2J0Cz/3geOHFz3GAABgb +AIkB22GpJOjPcKAAsB95oM9wgADsIgiAo4FggAKBANoxDQEQz3CAADAbAIiD6AHYCvABgQIjDQD3 +DYWfTABAS0GpSHAHCFEAYaFCqeB/wcWioe/xgOAB2MIgDADPcoAAGBsAqgHYAaoA2AKqAaICogOi +4H8kouB48cCuCc/9CHUod0h2iiBHDQIL4ASKIVYDEQ0UFA7Y6XFmDC//ANqE6BPdLfDPcoAA/LJI +cOoKL/4M2c9xgAAYGwCJD+jPcIAAHM8AkIYg/ACMIAKABfQFkmSSZ3gDoUIlABMOCOAFyXEKJQCQ +C/TPcIAAHM8AkIYg/ACMIAKABA/B/5UB7/2pcPHAHgnP/TpwGnGCCuAEZ9ho2HoK4AQqcR8JFCcK +IcAP63LPcAAA4w6D2wokQARpBe/+CiUABEwggKHKIcYPyiCGDwAA5A7KI4YPAACEAMoixgdt9wDa +z3GAAMCZnroVIQEEAIEBKkIERngOCmAHAKENAc/9jQfv/wXZ4HjxwOHFAN3PcIAAwJkmDC//HNkb +2KYIIAAF2UokAHfPcYAAOBuoIMACFiFAAwQQBQCYdQ8NQRFAJE0A6QDP/QohwA/rcnfYBbjRBO/+ +U9vgePHAz3CAAMCZGBAFAC8sQQFMJACHyiLGB8oghg8AAOIOyiOGDwAAqwCgBOb+yiHGD89wgAA4 +GxYgAAEAgEB40cDgfuB48cDhxc9wAwBADc91oADIH0UdGBCqD8//gNgVHRiQcQDP/eB48cDqD4/9 +OnAacU4J4ARl2GbYRgngBCpxHwkUJwohwA/rcs9wAADjDmPbCiRABDUE7/4KJQAETCCAocohxg/K +IIYPAADkDsojhg8AAGQAyiLGB233ANrPcIAAwJmeuhUgAAQggAEqQgRFedoIYAcgoNkHj/2NB+// +BdngePHAcg+v/f/az3CAABC2ExiYgBwYmIAA3s9xgACICcOhz3CAALwqQKAB2s9wgADAKkCgzKHQ +odGhz6HAocGhAt3Jd89wgAAEsIQvCBkAIEIOS4IncAAhkH+AABCwRiLCAEug+gxgDEAgACFhvSQY +giPTDXWQAecC2ADZNghv/gTaEg/gBAHYUQeP/eB44H7geOB+4HjgfuB44H8B2OB+4HjgfuB44H8A +2OB+4HjgfuB44H7geOB+4HgA2c9woADAHSegJqAtoOB+z3GAAKw+EoEB4BKhDcjHcIAA6M0siAHh +L3ksqM9wgADcmQKIEwhDAIogCAAGGhgwitiQuAfwiiAQAAYaGDBC2Ji44H4C2M9xoADAHQ2hIdgG +oQHYB6HgfvHAVg6P/ZgQAgAEIoEPAAAACDt5BCKDDwAAABAle89xgABIJKSBViVOFFYlDxWYEIEA +FQpeAoYh/wNEuS9nib/pcRnwUSIAgrwVAhEM8sK5gCUCGT9l6I89ZTCNZX/wf0V5CfDDuTx5P2Y+ +ZjCO6I9FeYgYwANleUUGr/2MGEAA8cDhxQPIpBABAJgQAgBRIQCAchABAUhwBvJuCuACANoIdQfw +AeFiCuACANqsaGIIwAzPcqAAyB/4EgEAA8jPc4AAkNoQiAK4FngAY+24z3CAAOwiCPQB23OiSIBA +ggyAYIAI8ALbc6JJgECCDYBggAIlQBBYYBBywCNtAA1xAKENcGCgABYAQAAWAEADyM9yoAD0B3AQ +AQFouSeicBABAWi5MHmpBa/9cBhEAPHAKg2P/c92oADIH6AWBBD4FgMQAN9JCBEBAxIBNqQRAAB2 +EQIBEQgeBc9wgAB446GABPCCEQ0BDcxRIACBhBEAAQnyAiXBEAIkQwAIIwMABPCGEQMBG2NocXHw +lQhRAA0SATcDyHgQAgFHCR4BUSFAgM9xgABIJCSBVBEBAQnyfhANASJ9Yn0CJEMDK/CAEAMBz3WA +AHDZACNEAHCIdn1glQAjDQGEEAMBu2Mb8KQQAQAVCR4FcIjPcYAAcNl2eWCRBPCCEAMBz3GAAEgk +JIGAEA0BVBEBAT1lu2OEEA0Bu2OAEA0BuWF+EA0BQn0n8EMIkQADEg02Dcx4FQIRUSAAgc9wgABI +JASAVBABAQnygBUAESJ4YngCJAMAB/CCFQMRhBUAETtjG2OAFQ0RQn0F8Olz6XLpdelxDcwRCF4A +A8h2EAIBYro6YgzwFQtyAGK6z3CAAEgkBIBGEAABGmL4FgAQXWUCfR+GGQ0EEKDYD6b/pl+mAtgV +HhiQgNgOphEEr/1weOB48cCiC4/9z3GAAEgk8CECAFYiRQQIglYiBAVRIMCAiiAIAMogIQC8GgQA +SiQAcgDZqCBAD891gAAwa/yKLmXkfi8ogQNOIIMHz3CAABhtb2AAJUMA4KtEEo8A5H4vLoETTiaP +F+5gyKvIgiEO3hAdiobh0yCmAC8oAQBOII0Hz3CAAJhpqGAR8M92gABYay5mzmW8isR9WBKOAMR9 +Ly1BE04ljhfIYBCrAeFKJAByANuoIMAP3IrPcYAA9GxvYc91gAAYbeR+LyiBA04gjwfvZQAlwAD8 +qEQSjwDkfi8ugRNOJo8X7mUkGIIDyIIfDt4QPYqA49MhoQAvKUEATiGNB89xgACYaalhEPAE68lr +A/Bods5hPIrEeVgSjgDEeS8pQQBOIY4HyWUsGEIAAeNKJABxANioIAAFz3GAAJRpfYoJYQAkDAAB +4GR5LylBAE4hgwfPcYAAmGlpYSCsrQKP/eHF4cbPc6QAtEUpEwCGz3GAALQ9yBkAACsTAIbMGQAA +z3ClAAgMA4DkGQAADhMAhhB6MLjUGQAA0BmAAA8TAIbYGQAAz3CAAFjP1Ii2iOgZgAN4iOwZQAMN +kPAZwAAs4AIgggP0GYAAAiBCA2J4+BmAAPwZAADBxuB/wcXPcIAAJF0GgAOAIIDPcIAAKJrgfymg +4HjhxeHGmHDPcoAAOBwFgiCCZoLKuBC4yrkFIQGAAYLKuxC7yrgFIwUAZ4ICgsq7ELvKuAUjBwBo +ggOCyrvKuBC7BSMGACTyABQOAC8oQQBOIIMHANgPIMAAEn0EIEMBpH5lfgAcgAPagqR+xXt6onmC +BCCOAQQgwAGke8V7eaJ4gqR7BCFBg2V4GKLf9cHG4H/BxeB48cASCY/9OnAFgaCByrgQuMq9BSUN +kAGBJoHKuMq5ELkFIRAAAd4Z8gQlgJMT8i8oAQBOIIIH8CGBIADfDyePEAjpBCcAFEIgAIBgecog +YgDmfdt+6u0dAY/94HjgfwDYocHxwLIIj/2jwQh1SMDPdoAAOBwahvuGPIYEfyR/p39Bx/4JoASK +INgEiiDYBPIJoASpcZbv0Q0REBYIIAUK2MUIEAAKIcAP63LPcAAAjROKI0cASiQAANEEr/4KJQAB +BBQBMRjpIBQAMQsgQIAN8s9wgAD0L2CAz3EAAHBQDNhgewPaCPCI6M9wgADwLyCAYHkM2AYUATEY +6SIUADELIECADfLPcIAA9C9ggM9xAABwUA3YYHsE2gjwiOjPcIAA8C8ggGB5DdgEJ1CTCvJyCO// +CtiKIBgIRgmgBApxE/CR7Yog2AQ6CaAEiiFHCx4Pr/8K2IogGAQmCaAE6XFiCAAAvKYI3BcAr/2j +wPHArg9P/Qh2AN2KINgDBgmgBMlxz3CAADgcWoA7gER5ANoPIoIDBCJDAEIjA4DKI2IALybH8AHf +yiBBAwfyHIAkeLYO7/9FeOlwzQdP/eB48cDhxaHBAdhAwM91gAA4HAqFGwgeAItwBNln2j3bogvg +Che7CoWguAqlrQdv/aHA8cAqD0/9GnAodUh3aHY4Y2bZPdriC+AKF7oXCFEACnC+C+AKqXHpcI4L +4ArJcWEHT/3gePHA9g5P/abBKHUacmDAANgBHAIwAdgCHAIwAxwCMItw8g1gB4HBBu0EwQpwYH0F +wgPBjukKIcAP63LPcAAAjBPu24okww8lA6/+uHNgeQDYCQdv/abA4HjxwJoOT/2iwQHez3WAADgc +OoUbhSR4PIUEIRAA6g9gBIogmANnCBAgAvDbfgQggKP98y8oAQBOIJEHFSVOFB2GXB1AFIDgyiHB +D8oiwQfKIIEPAACPE8ojgQ8AABwCyiQBBLACof7KJUEE0g+P/x2GQHh2D4//iiCYA44PYAQqcQDY +DyBABAYgECBiDe//CnCKIJgDcg9gBDyFYQZv/aLA8cC0wYogmANeD2AEANlaDWAAi3CKIJgDTg9g +BBDZtMDRwOB+8cC0wYogmAM6D2AEAtl2DaAAi3CKIJgDKg9gBAnZtMDRwOB+4H7geADZz3CAAAgy +4H84oPHAtMGKIJgDBg9gBAPZzgjgAItwiiCYA/YOYAQL2YogmAPuDmAEEdm0wNHA4H7geOB+4Hjx +wHYNb/0A2c92gAA4HBeGz3WAAMCcDyEBABmGJHhCIACAyiBiAKHBAd8XCFEAz3EBAFC/C9hKDu// +VSXCFzeGANgPIEAAOIYkeEIgAIDKIGIAANkjCFEAC9hgwAEcQjACHMIzAxzCM4twBNlVJcIX2g3v +/1TbANhlBW/9ocDgePHAVg0ABM9wAQBsQAnoz3GAADgcuBkAABuBkbgboc9wAQDQPwjoz3GAADgc +HqEbgYG4G6HPcAAAdFMK6M9xgAA4HJQZAAAbgYi4G6HPcAAAeFMK6M9xgAA4HJgZAAAbgYm4G6HP +cAAAtFMK6M9xgAA4HJwZAAAbgYq4G6HPcAEAuEcK6M9xgAA4HNgZAAAbgZm4G6HRwOB+8cDhxaHB +z3KAAIS2z3WAADgcF4UA2Q8hAQAYhSR4QiAAgMogYgAB2wDZIwhRAAjYYMABHEIwAhzCMAMcwjCL +cATZ8gzv/4ojCAAI2ADZGg3v/yhyANiBBG/9ocDxwPoLb/0I2c9yrd7vvnIKoAI6cLYPIAAqcJEI +0ADPcIAAKJoDkE4gzwFRD9URz3CAAAgRGg4gAfQgwAMA3gDdBNgacCpw6XHJcgokgA+t3u++Lgqg +Aqlzyg8gACpwTQjQAEIgQCDfCHWAAeUB5tMOlJAB57sP1JEqcM9yrd7vvv4JoAIQ2UYPIAAqcB0I +0ADPca3e777qCaACKnAKD+//KnCD4MogIgCxA0/98cBSC2/9A9qmwRpwIgpgC4PBA8HPcIAAJBUU +FAcwAN7wIEUAz3CAACwV8CBGAM91gACUCg7YxKVAwATYQcDPcK3e775CwATCCnCA24YJoAKYc84J +IAAKcH0I0AADw89wgABEFUKF8CDBAMClDBUQEMGlCOnPd4AATBXwJ8AQhujApcGlANkZ8IQqDAOm +CGAAL3AOIIEPAAAAASClA8CEKAwj8CcBEI4IYAAvcA4ggQ8AAAABIaUEhRsIUQAAhRF4jCAHjcL3 +wKUxeYwhB43D98GlANjhAm/9psDgePHAegpv/QTapsFKCWALi3HPcAAAG9IA3alx4gwgAalyAMHP +cAAAHNLSDCABqXIAwc9wgAC0EAHCFSBBAACRAsEFup4NIAFFeQPAgODaAAUAz3aAAJQK0tgIuBnZ +ngwgAQDaz3AAACLSQCYBEtYKIAEE2s9wAAAj0kAmARPGCiABANrPcAAAINKEwboKIAEA2oXHz3AA +ACHS6XGqCiABANoChhfZag3gCkAmAhIDhhfZXg3gCkAmAhMEwBfZUg3gCoTCBcAX2UoN4ArpcgKG +ANmGDyAAi7kCpgOGANl6DyAAi7kDpgTAANkIuG4PIACLuQh3BcAA2Qi4Xg8gAIu5IoYxeRnhBSl+ +ACOGL3JQdzF5GeEFKX4AL3HMIEWAhfcDwAHlNwhFgwPADwhFAwHZz3CAAJQKJKAA2KkBb/2mwOB4 +8cA+CW/9CdqpwQh2BghgC4tx9gmv/SHACHFC2IIMIAEFuQwUBDAAwclwBsIKJYAPrd7vvoIPYAIC +w54OIADJcFUI0AAAwQXCz3CAAPwQAN3wIEAABMEKugQigg8PAAD8yblFeVYLIAGpcl4L4A0F2CAU +BDAAwclwBsIKJYAPrd7vvjYPYAIHwzoO7//JcIPgyiBCAxUBb/2pwOB48cB+CG/9AtqnwZpwag8g +C4PBz3CAABRnAIAA2UXAz3AAABHS+gogAShyz3AAABLSANnuCiABKHLPcAAAE9IA2d4KIAEocs9w +AAAU0gDZ0gogAShyz3AAAAFEB9nCCiABANrPcKAAtA9wEBcATgjgCgHYugrgDQXYvNiKCyABANnD +2IILIAEA2YogRAh2CyABANmKIAQKbgsgAQDZJcW12GILIAGpcYoghAZaCyABqXED2EDABN5Bxs93 +rd7vvkLHinAEwQPCHtuYc0olAABKJgAASg5gAkonAACODu//inCD4Nfyz3WAAJQKCBUWEAwVEhAO +2EDAQcZCx4pwBMEDwh7bmHNKJQAASiYAAA4OYAJKJwAAUg7v/4pwg+C58ggVFRAMFRAQDthAwEHG +QseKcATBA8Lh25hzSiUAAEomAADaDWACSicAAB4O7/+KcIPgn/IIFREQDBUTEAPYQMBBxkLHinAE +wQPC4duYc0olAABKJgAApg1gAkonAADqDe//inCD4IXywoWjhTIPoAovIMcFBMHPcoAARBUCIUCl +z3OAADQVNXoAogIjACTPcoAATBU1egCiw9o1e0Cjz3OAADwVNXtAoyH0MgzAAwohwA/rchDoz3Cg +APxEdBAEAGQQBQDPcAAAsRMlA2/+iiNJCs9wAACtE4ojiQpKJAAAEQNv/golAAGc6PILwAMKIcAP +63IQ6M9woAD8RHQQBABkEAUAz3AAALET5QJv/oojiQzPcAAArhOKI8kM4fECJYAl2WACIUGEEPIC +JUIkDHouDCAAL3AEwgIlASDPcIAAJBVVeCCgAiCAJLlgAiHBhBDyAiDCJAx6BgwgAC9wBMICIAEg +z3CAACwVVXggoADYOQYv/afA8cByDuAAANjPcAAADdIA2XoIIAEA2s9wAAAM0gDZbgggAQDaz3AA +ABXSz3HzD//8WgggAQDaz3AAABvSANlOCCABANrPcAAAAtKg2Zq5PgggAQDaCdiMuADZMgggAQDa +FNiMuP/ZJgggAQDaANiMuP/ZGgggAQDaEdiMuP/ZDgggAQDaAtiOuADZAgggAQDaAdiOuM9xAAD/ +//IP4AAA2s9wAAAL0gDZ4g/gAADaz3AAAA3SAdnWD+AAANrPcAAAEtIA2cYP4AAA2s9wAAAT0gDZ +ug/gAADaz3AAABTSANmqD+AAANoA2NHA4H7xwCIND/2kwYtxAd3qCyALqXLPcIAAwGUAgEHABNhm +CCABLNkO2F4IIAEA2SHGtdhSCCAByXGKIIQGSgggAclxiiBGAD4IIAHJcQDAgODMIKKAzCDigMwg +YoHMIKKBzCAigswgYoLMIOKCyiFCAwP0A9mB4MwgooDMIOKAzCCigcwg4oHMICKCzCCigswg4oIA +3QX0gbkveYDdhODMIGKBzCCigcwg4oHMICKCzCBigswgooLMIOKCA/SDuS95xg/gAA/Yg8ESDuAA +EdgDwYO9pXlDwa4P4AAR2ADYsQQv/aTA4HjxwOHFocGLcQoLIAsB2s91gAA4nAAUBDDPcIAAVBBW +JQESEto6DuAAANsAFAQwz3CAAFAQqXEB2iYO4AAC289wgAB4ECRtHdoqDuAAAMMA2GEEL/2hwOB4 +8cDKCy/9A9qjwbpwrgogC4txAcHPcIAABBEA3/QgTgACwc9wgAAYEYDm9CBUAM9wgACUCuCg4aDM +JqKQzCZikcwmopHKJcITAvQA3YHmzCbikMwm4pHMJiKSA/QB3YTmzCZikswmopLMJuKSAvQC3WoN +z/+qcM9yrd7vvuIJYALJcUYO7/+qcO0I0AAAwIDgzCCigVD0gObMJmKQzCYikUr0AsCRCBEAz3CA +ACQVtXhacOCgz3CAACwVtXh6cOCgz3CAAEQVtXgacOCgz3CAAEwVtXg6cOCgz3CAADQVtXjgoM9w +gAA8FbV44KCqcMlxz3Ot3u++aglgAqlySgrv/6pwdQjQAADBABIAIIbhAdnAeQO5tXnHcYAAhLYA +oQATACAEoQAQACAbeAihABEAIBt4DKGqcKlxyXIKJIAPrd7vvh4JYAKKc0YPr/+qcCkI0AAAwM9x +gACUCkCBBL4GuNhgFSAABcdwgADAtiGBQrAjsADYpQIv/aPA4HjxwKTBi3E6CSALBNoAwAHBBLg1 +eM9xgAC8EBBhrg3gAALBAMABwQS4NXjPcYAA3BAQYZoN4AADwQDYpMDRwOB+8cChwW4LoAKLcgDA +ocDRwOB+4HjxwPoJD/2uwbpwmnF6clpzCiEAIQogQCGCxXIIIA6pcITGagggDslwYgggDobAXggg +DojAVgggDorAjMdOCCAO6XCqcBfZYg2gCotyinAX2VYNoAqBwgDA1gqv/alxAcDOCq/9yXGpcKlx +Oggv/qlyyXDJcS4IL/7JcqlwyXEeDy/9hsJqcBfZHg2gCotySnAX2RYNoAqBwgDAlgqv/alxAcCO +Cq/9yXGpcKlx9g/v/alyyXDJce4P7/3JcqlwyXHaDi/9iMIqcGYKr/2KwYjAisHSD+/96XLpcAvZ +bg0v/ulyhsByCm/96XGA4AHYGPYKcD4Kr/2KwYjAisGmD+/96XLpcAvZRg0v/ulyhsBKCm/96XGA +4ALYyiAqAC0BL/2uwOB48cDyCC/9AtqiwQh2ug/gCotxAMAA3alxBNpIc0okQAGmCW/9SiXAAQhx +KgzgAEvYyXDPcq3e774yDyACAcHKCyAAyXCD4MogQgMVAS/9osDxwKIIL/0I2c9yrd7vvg4PIAII +dnYIIADJcGsI0AAA2c91gACICyClz3Kt3u++7g4gAslwOgkgAMlwSwjQACCFQCFBgCCl8vMolclw +FgkgAEqVz3Gt3u++wg4gAslwhgggAMlwHwjQAMlwz3Kt3u++qg4gAhDZFgggAMlwg+DKICIAjQAP +/eB48cDhxaHBi3HmDuAKAdrPdYAAvJ0AFAQwz3CAAOgRqXEX2hoK4AAA2wAUBDDPcIAA4BFVJcEV +A9oCCuAAAtvPcIAAGBJWJUETC9oGCuAAAMMA2D0AL/2hwPHAvg/v/ADZz3KAALydz3WAADgcF4VI +dw8hAQAZhSR4QiAAgMogYgChwQHeFQhRAM9xAQBQvxDYjgiv/4AiAgA3hQDYDyBAADiFJHhCIACA +yiBiAADZJQhRABDYYMABHEIwAhyCMwMcgjOLcATZVicCFCIIr/8ocwDYrQfv/KHAz3CAADieIrDg +f0Ow8cAWD+/8Adqhwbpw/g3gCotxAMHPcIAAGAzPdoAAiAvwIEAAIKbPca3e774BpoINIAKqcPII +IACqcOUI0ADPca3e775qDSACqnCiCSAAqnDNCNAAqnAP2c9zrd7vvlINIAIC2uIN7/+qcADfSiTA +J60I0AAIFhAQDBYRENp3A/Cpd+l1O/CadTnwACTNI719sH2qcKlxz3Ot3u++Eg0gAgrapg3v/6pw +dQjQAAgWEhDPcIAADDAggAwWExBgeQHYgeAKcCpxSnJqc8okgQ8AAM0ayiWBDwAA4xfKJIIPAABN +Gcolgg8AAIwWOgzP/5sIUICRCJCASiZAIAIkwCMLCJQAiw4QoIHgyiUOFc9wgACgEfQgQAOkpgWm +ANhFBu/8ocDgePHAEg7v/AzaqcHPdkAf/wDPdTwAPDzPcYAAzGW2Du/8i3DPcIAA6BHPcYAALBEX +2uYI4AAA289wAAAL0gwcBDDPcAAAAtIOHAQwz3AAABvSEBwEMM9wAAAc0kXFEhwEMM91gACICyCF +ANgPIEAAR8ABhUbGhcEE2kjAg8CaCOAAANvPcIAA4BHPcYAAIBED2oYI4AAC2wDYANn2D6AAAtoB +2ADZ6g+gAALaAIUVJAEwIIEC2NoPoAAC2gDYwQXv/KnA4HjxwOHFocHPcIAAiAsggFDYDyBNAM9w +gAAYEs9xgACIEWII4AAL2gXYABwEMAIcRDOLcEAkgTBOCOAAAdqz2HII4AAA2YogBAZmCOAAANmK +IMUPXgjgAADZANhpBe/8ocDxwOHFocGLcboL4AoB2gDBz3AAAAPSPXlSD6AAANrS2Ai4E9lGD6AA +ANrPdYAAkAvPcAAAINKpcXoNoAAE2s9wAAAh0iRtbg2gAATaANgVBe/8ocDxwIIMz/yacUh3z3CA +APwKZBASAM9wgAD8ClwQEAAM2QDdKHB6cM9wgADoC/AgUQNKcCIO7/wqcQJwE3gWDu/8iiEPCgh2 +z3CAAPwKGoAGDu/8KnHPcYAA/Ao4gThgE3jyDe/8iiEPCs9xgAD8CjuBju9UaVR6QCyDIXR7emK1 +esdygACwntSqFaoQ8B0PURBUaVR6QCyDIXR7emK1esdygACwntaqF6o5CZEAje9ALIEhNHmAIQIE +tXnHcYAAsJ7UqRWpDvAdD1EQQCyBITR5gCECBLV5x3GAALCe1qkXqUIjQCBBCHWAAeXtA+/8ANjx +wH4Lz/ylwbpwANjPdoAA/Ap0FhgQRMAA2AOmz3CAAAwwIIBAINkwCiKALwAACNIB3WB5qXA6cALY +hB4AEEwhgKDMIeKgBPSEHkATA4aEFgEQMHDqAgYAgODKIoEvAAAI0oHgyiKBLwAACdIA3UwhgKDM +ISKgzCHioEL0Bt1A8BCGCKYRhgmmA4aH6AbY0gygAFYmwRIDhg8IUQAI2MIMoABWJsESFobDuA0I +dAMWpgvYFqbPcYAA6AvwIQAAKYZIhgx5ZB5AHgx6BIZoHkAeg+gFhgnoBoaD6AeGBeiA4swhIYAG +9ADYF6YYphmmGqaqcKlxHg7v/0OGAeWH5TICBgDPd4AAhF21fwCHAdqO4MIijgBCpoDiI9nKIQIG +GnGA4ibZyiFCBsoMoAB6cc9wgAAwEs9xgACIEgPacg2gAALbA4aB4MogoQDKIWEE2AyhAMoioQBM +IcCgyiChAMohYQLEDKEAyiIBAM9xrd7vvrIIIAKqcLoKL/6qcIPg4vLPcIAAOBLPcYAAlBIV2iIN +oAAA20YLL/4Dhs9wgABkEs9xgADoEjoNoAAS2s9xrd7vvnIIIAKqcDoIoACqcIPgwPIAhz6GAKZA +KQACQCkCBAV6z3AAAAvSRXlODKAAANqKJ78dQMdBxwrYQsDPcK3e775DwKpwI4YKckpzSiSAAkol +gAJKJoACGgggAk4mBwBeCyAAqnCD4JTyEIY+hgSmEYZXaQWmQCnAAwV6PXnPcAAAC9JFefILoAAA +2kDHQccK2ELAz3Ct3u++Q8CqcCOGanJKc0okgAJKJYACSiaAAsIP4AFOJgcABgsgAKpw1QjQADCG +UYaExwWGJqZHphN4VHhEhhemE3hTejR6WKaKIQ8KYgpgAulyGIYQFBQwiiEPChN4TgpgAulyF4YQ +FBcwiiEPChN4PgpgAulyBMCKIQ8KQiCWAhiGE3gqCmAC6XIEwD6GQiCTAkApAAJAKQIEBXrPcAAA +C9JFeT4LoAAA2gAcgDUEHMA0CthCwM9wrd7vvkPAqnAjhgpySnNAJIQiQCeFIgomAAEKD+ABCifA +BE4KIACqcIPgWAXC/wrwA4aEFgEQAeAwcCAF5f8DpgDYfQDv/KXA4HjxwF4I7/wI2c9yrd7vvs4O +4AEIdzoJIADpcHkI0AAA3qYIoADJcM91gAD8CtulINgepd+lyXAEuEUgwAAcpR2lz3Gt3u++lg7g +Aelwbgzv/+lwQQjQABuFAeDfCPSAG6XPca3e7752DuAB6XA6CSAA6XAhCNAA6XDPcq3e775eDuAB +ENnKCCAA6XCD4MogIgA1AM/88cDGD6/8BNqkwRpwlg6gCotxAsADwwDdqXEI2kokQAKCCC/9SiVA +BAhxAcAeCqAAqXIKcM9yrd7vvg4O4AEAwRoKIAAKcG0I0ADPdoAA/ArPcAAAINJWJkESOgigAATa +z3AAACHSVSbBFCoIoAAE2jKG84ZBKcAFwLgYuBN4JXhBL8EVwLkYuTN5JX8Sps9xAABoH/Om8gjv +/Ai4FKbPcQAAaB/iCO/8QC8AEhWmqXB5B6/8pMDgePHA4cWhwYtx4g2gCgHaz3WAAECeABQEMM9w +gAA4EqlxFdoWCaAAANsAFAQwz3CAADASVSVBFQPa/gigAALbz3CAAGQSViUBExLaAgmgAADDANg5 +B6/8ocDxwLoOr/wA2c91gAA4HBeFz3aAAECeDyEBABmFJHhCIACAyiBiAKHBAd8XCFEAz3EBAFC/ +CdiODy//VSZCGDeFANgPIEAAOIUkeEIgAIDKIGIAANklCFEACdhgwAEcQjACHMIzAxzCM4twBNlV +JkIYHg8v/4ojFQAA2KkGr/yhwPHAPg6v/AraqsEIdgYNoAqLcQbYigmgAAHBCNiCCaAAAcEQFAQw +yXAAwQLCCiWAD63e776CDOABA8M6Du//yXCDCNAAz3WAAPwKFIUYFAQwCqUVhQDBCiWAD63e774C +wg2lyXBSDOABBcMKDu//yXBTCNAAFIUgFAQwC6UVhQDBCiWAD63e774Cwg6lyXAqDOABB8PeDe// +yXArCNAAdIVUFQYQyXA0FQQQOBUFEGylJBQHMCqFPB2AEb4M7/xLhQDY6QWv/KrA8cChwYtxRgyg +CgHa0tgIuAHZ4g9gAADaANihwNHA4H7xwFINj/ypwUDAQcEA2EjAgsW6C6ANqXCExrILoA3JcIbH +qgugDelwAMCLcroIYAoX2QHAgcKyCGAKF9kAwDIOL/2pcQHAKg4v/clxqXCpcZILr/2pcslwyXGK +C6/9yXKpcMlxdgrv/OlyBsAHwYjDNgqgCgHaCMBBBa/8qcDgePHAzgyv/AjZGnDPdoAAqAoC2Aem +CtgJps9yrd7vvjIL4AEKcN4MIAAKcIPge/IA3woNYADpcM9wgAAMMCCA4KZgeQHYCHWC4MwlIpDM +JeKQA/QG2ACmAIabCNUBz3GAAARi8CEAAAHZjuACpsIhTgCuDmAAI6bhpgLYEaaC5cwlIpDMJeKQ +BPQB2BGmANgF8AGGAeABpjGGUQhFAM9xrd7vvq4K4AEKcJoNIAAKcHcI0ADPca3e776WCuABCnA2 +DiAACnBfCNAA6qb/2AumCnDPcq3e7756CuABIIaWDiAACnCxCNGAH/AAhgHgcQj0gQCmz3Gt3u++ +VgrgAQpwYg4v/wpwHwjQAApwz3Kt3u++PgrgARDZ7gsgAApwg+DKICIAEQSP/OB48cCiC4/8GnDP +cIAADDAggM92gACoCmB5Adg6cAKGAd2O4MIlThMBhlIlDRCA4AbYyiAiAtoOYABAJQEUCnDPcq3e +777iCeABQCUBFOYLIAAKcIPgEgIBAM9wAAAH0s9xAwDwwMYNYAAA2s9wAAAG0gDZug1gAADaIYYK +cATaCiSAD63e776iCeAB/9vyCGAACnCD4Onyz3AAACDSVSbBFNILYAAE2s9wAAAh0lYmgRLCC2AA +BNoThqIN7/80hgh3z3AAAAfSz3EEAA45Xg1gAADaz3AAAAbSANlSDWAAANohhgpwBNoKJIAPrd7v +vjoJ4AH/24oIYAAKcIPgtfLPcAAAINJVJsEUagtgAATaz3AAACHSViaBEloLYAAE2hOGOg3v/zSG +AiDQA4wgBK4B38onpRAhCBMgAoaO4AHYwiAOAAjoAYaA4AHfyiWhEQTyAN2pd2cIUiBjCIMvAAB8 +ks9wAABQwwIMr/wKcYDgyiBsAMj2jCACiMoghg8AAJ8Az3GAAKRd8CEAABV42guv/IohDwodZUPY +Iw30EgWmAYaL6AKGjuAB2MIgDgCB4AjdyiehEAPyCN0B33UOA3QAACT0z3EAAFDDnguv/ApwgODK +IGwAx/aMIAKIyiCGDwAAnwDPcYAApF3wIQAAFXh6C6/8iiEPCiGGmukiho7hAdnCIU4AKQlRAA0I +1ABOII0DAN8O8E4gzQIA389wAAAL0s9xIAAgIAYMYADpcgGGBL/9ZZDoBtjaDGAAqXEC2ArZ6gtg +AAhyHwnRIALYCdkI8AjYvgxgAKlxAtgR2c4LYAAC2qSmANidAY/84HjxwDYJj/yhwTpwAt6KIAEp +z3WAAKgKENgQ8OyFANhAwApx+GcVeJoKIAKLcjYNoAeLcADAAeYad0AmDxRXDjUTIYVTCNQDgOEG +2MogIgJWDGAA6XHkpSpwz3Kt3u++Xg+gAelxYgkgACpwQwjQACqFS4UqcAHbCiWAD63e774+D6AB +iiTDDy4IIAAqcI8I0YAN8EAmjxOA4QbYyiAiAgYMYABAJoET5KUA2O0Ar/yhwPHAhgiv/ATapMEa +cFoPYAqLcQDBz3aAAKgKYYbPcIAA9GEEFBEwAN3wIMIAz3CAAPxh8CDPAM9wAAAG0lh50gpgAKly +z3AAAAfSACnBI8IKYACpcgpwz3Kt3u++rg6gASSGtgggAApwTwjQACGGAsIKcAokgA+t3u++kg6g +AQPD4g0gAApwMwjQAM9wAAAg0lUmwRTCCGAABNrPcAAAIdJWJoESsghgAATaE4aSCu//NIYMpqlw +MQCv/KTA8cDhxaHBi3GiDmAKAdrPdYAAwJwAFAQwz3CAAKQTqXET2tYJYAAA2wAUBDDPcIAAnBNV +JcEUA9q+CWAAAtvPcIAAzBNWJcESEtrCCWAAAMMA2PkHb/yhwPHAbg9v/AHaCHbPcIAAyGUAgKLB +QMCBwToOYArJcAHCz3GAAKgKi3PJcMW6QcIKCSAGIIEgwBoLIAoH2RpwARSAMA4LIAoH2Qh2CnAA +2QjayXNKJEAC/g+v/EolQARacAIUgDDqCiAKB9kIdQMUgDDeCiAKB9kId6lwANkI2ulzSiRAAs4P +r/xKJUAEOnDPcAAACNJKcWYJYAAA2kHYCbgKcVoJYAAB2s9wAAABgslxSglgAAHaz3AAAAnSKnE+ +CWAAANrPcAAAAoKpcS4JYAAB2s9wAAADgulxIglgAAHaANjpBm/8osDxwOHFANgIcQoJYAAC2gHY +ANkCCWAAAtoC2ArZ9ghgAALaz3CAAAwwIIBgeQHYCHWD4MogoQDKIWEC2AhhAMoioQDPcoAAqApj +gs9xgAAsE4DlzCXikA70z3CAALAL8CDAAAKhz3CAALgL8CDAAA3wz3CAACBi8CDAAAKhz3CAAChi +8CDAAAOhz3BoH/8ABKHPcCAAMDAKoQWiz3CAAAwTENr6CGAAANthBm/8ANjgePHA4g1v/Avaz3CA +AGwTz3GAAIQTBglgAKHBz3WAAKgKQYUF2EjZIglgAA8hgQADhc92gADUYYt3FSYAEACQXg8gAOlx +A4UAwRUmABAAkPoIYADGuQOFz3aAAORhFSYAEACQOg8gAOlxA4UAwRUmABAAkNYIYADGuQDY0QVv +/KHA8cBeDU/8ocEacItxAd4uDGAKyXLPdYAAqAoAhQK4FHgAII8PgAA8nQDAyKUApc9wgAAMMCCA +YHnJcAh2awjRAM9wAAAL0kDZmg8gAADaBth2CGAACHEK2G4IYAAC2TPYANmCDyAAAto02ADZdg8g +AALaN9gA2W4PIAAC2jjYANliDyAAAto72ADZWg8gAALaPNgA2U4PIAAC2gLYCdlGDyAAAtoM8M9x +rd7vvjILoAEKcAoJ7/8KcNkI0AAChc9xrd7vvo7gAdjCIA4AgeAKcBz0DguAAZIJIAAKcLUI0AAA +2ATwCIUB4CeFmwhlAAilz3Gt3u++6gqgAQpwngggAApw5QjRgEbwQQ7RENIKgAGKCCAACnB9CNAA +z3Gt3u++vgqgAQpwQgkgAApwZQjQAM9xrd7vvqoKoAEKcCoJIAAKcEMI0QAm8JYKgAEaCSAACnBB +CNAAz3Gt3u++ggqgAQpwxgrv/wpwKQjQAM9xrd7vvm4KoAEKcCIIIAAKcBUI0AAhhQqFNX8AtwuF +AbcA2DEEb/yhwOB48cDKC2/8AdsId891gACoCkqFKYUKJYAPrd7vvgDeWWFLhSYKoAGYdhYL7//p +cJsI0AAMhSqFAttJhQ2l6XAKJYAPrd7vvllhS4X+CaABmHbuCu//6XBzCNAADIUqhQHbSYUOpelw +CiWAD63e775CeUuF1gmgAZh2xgrv/+lwSwjQAAyFKoUC20mFD6XpcAolgA+t3u++QnlLha4JoAGY +dp4K7//pcCMI0AAwFQUQPBUEEAqFKYVAHUARTYUKDeAFboUKpclwbQNP/OB48cACC2/8iiTDDwh2 +z3WAAKgKa4VJhQolgA+t3u++KoV6YloJoAED20oK7//JcKEI0AAMhUuFCiWAD63e775phSqFDaXJ +cHpiBNsyCaABiiTDDyIK7//JcHUI0AAMhUuFCiWAD63e775phSqFDqXJcGJ6A9sGCaABiiTDD/YJ +7//JcE0I0AAMhUuFCiWAD63e775phSqFD6XJcGJ6BNveCKABiiTDD84J7//JcCEI0AAwFQUQPBUE +EAuFKYVAHUARTYU6DOAFboULpQDYoQJP/PHAo8GLcQIJYAoD2gDBz3AAABvSj+kB2ZYMIAAA2s9w +AAAc0gHZigwgAADaAtgK2Q7wAtl6DCAAANrPcAAAHNIA2W4MIAAA2gLYEdliDCAAAtoCwc9wAAAF +0lYMIAAA2gHB0tgIuDt5AeFGDCAAANoA2KPA0cDgfvHAtglv/AXYocHPdYAA/ApDhUjZBg0gAA8h +gQAChc92gADcYYt3FSYAEACQQgsgAOlxAoUAwRUmABAAkN4MIADGuQKFz3aAAOxhFSYAEACQHgsg +AOlxAoUAwRUmABAAkLoMIADGuQDYtQFv/KHA4HihweHF4ca4cM9wgACUvxAQBgDPcIAAjDEFgJhx +ocGGJPcP5wgQAM9wgAAwYACAHwiBAc9wgAA4YACAEwhBAc9wgAA0YACAwwgAAQAcQDEgwgEUgTDw +3lMiwADEelMhxwAkflR6QC6NAbR9umIVes9xgACEuEhh1H4Ic4Yj/Q97ezpiQYpleEhzhiP9D3t7 +3WUVJc0RvmHCjmV6yXOGI/0Pe3u5YSOJZX4oc4Yj/Q97e2V5JwwQAM91qgDgB3OFEQseAEilCaUq +pculEPAIpUmlyqUrpQrwCbpFeM9ypwAUSAOiCbklfsSiz3GAADBgABmAAc9wgAA4YAAYQAHPcIAA +NGAAGAABocDBxsHF4H+hwPHAz3EAggEAz3CgAKwvPKDPcIAAZDwAgIvoz3CAADgeAIAPCJAAjg3A +AtHA4H4yCkAAng+gBG/Yh+iKCuAMCtgeCkAA8/Hz8c9ygABkPCCCBnngfyCi4HjPcoAAZDwggiV4 +4H8AouB4BCiADwAAL7pCKcJ0UHpEKv4CAiBADhB4A+gB4lB6CwgzAUCxg+gA2ALwgNjgfuB4JQOP +/fHAkg8P/Dpwz3WAAOQiAIUB4AClFQhRAAHZz3CgAMgcMaAGCuAMKHASDWAEB9gacM92oADsJ+uG +9gwgBipwC6YAhUIgQIAApQb0z3GgAMgcANgRoRIMYAQKcJkHL/zpcPHALg8P/DpwKHUacs4MYAQH +2FpwDwieIEoL4AbI2FAgkCBMIICgGfII9iMIECBFCFEgFdgTuA3wJQgQJDUIESjmCKADKnAApQ/w +KdgSuPAgQAQApQnwK9gSuPvxz3CgAOwnGYAApaILYARKcB0HD/wKIcAP63LPcAAAihN72wokQAQp +A2/9CiUABOB48cCmDg/8CHc6cRpzHwp0AADeSHX0J4ATFSGBI1oP7/8KcmG98Q11kAHm3QYP/OB4 +8cB6Dg/8ocEIdxpxIwp0AADeSHX0J4ATHgggAItxAMAUIIwjYb0AtO0NdZAB5rEGL/yhwPHARg4P +/KHBGnDPdoAA5CIAhgHgKHUAphUIUQAB2c9woADIHDGgsgjgDChwvgtgBAfYCHfaDOACs9gW6Itx +0gwv/QpwABQAMQClAIZCIECAAKYH9ADZz3CgAMgcMaC6CmAE6XBFBi/8ocDgePHADQzeAC4Pz/8E +8NoIAADRwOB+8cANC94ASg/P/wTw9ggAANHA4H7xwLYND/wIdY7gAd7CJo0Tz3CgALQP/IC6DaAJ +ANjJcKlxAdpOC2AESHOqDaAJ73jtBQ/88cB2DQ/8OnAodRpyFgtgBAfYTCCAoFpwG/IM9icIECBN +CFEgFdgTuBUgQASgoBvwKwgQJDkIESgqcKIPYAOpcRHwKdgSuBUgQASgoAvwK9gSuBUgQASgoAXw +z3CgAOwnuaDuCWAESnBpBQ/8CiHAD+tyz3AAAIkTStsKJEAEdQFv/QolAATgePHA8gwP/Ah3OnEa +cx8KdAAA3kh19CeAE/AhgSNeD+//CnJhvfENdZAB5ikFD/zgePHAxgwP/Ah3GnEfCnQAAN5IdfQn +gBMaCCAA9CCBI2G98w11kAHmBQUP/OB48cCWDA/8GnDPdoAA5CIAhgHgKHUAphcIUQAB2c9woADI +HDGgBg+gDChwFgpgBAfYOnAyC+ACk9gY6LB9QCiPIYG/EL2lf89woADsJ+agAIZCIECAANkApgX0 +z3CgAMgcMaAKCWAEKnCNBA/8z3GAAEgkI4HPcoAAiAoyIYMPAAAfAwGiMiGBDwAAGQNhskhwILII +2XPaHttlAKAJGLvgePHAz3CAAEgkA4AJgFEgQIHKIGIADA1i/sohIgDPcYAAgAmKIIwMPg0gAyCR +gguv/QHY0cDgfuB48cDCCw/8z3WAAJS/IoXPdqwAkAEJCVEDGI2H6HkJ0QIYjXUIEQDrhjAWEBDP +cIAADDAggGB5AtgihZ7op78RCVEDRiDAI0UgAAMT8M9wgAAEMCCAYHkA2A8IUQRGIMAjRSCAAwXw +RiDAI0UggALrpgymFvCN4dAn4RHl889wgAAEMCCAYHkA2JHg0CfhEejzh7/Z8QXYDKag2AumiQMP +/PHAKgsv/IoiBA7PcIAAVAkAgM92gACcrCaAQCYAFC4JIAoE4QGGz3WAAEgkIobIHRgQz3KAAHQn +yR1YECGWJ6ogjgQggA8ABgAAgOAB2MB4IaoGqgDeRg9gCMlwz3CAAOkiUgtv/sCoxgnAAgjoygnA +AoboYgqv/clwKvDPcIAA7CIkgCCBBgwgA4ogTAyKIJMB+gsgA6nZAtheCWABAdkeCqAMAtgjhUiB +NJFTIgAAUgngCAHbiiCMDtILIAOz2QDZnrnPcIAASCsgoMkCD/zxwOHFCwgyDAh1HQ2SHgohwA/r +cs9wAACaISLbmHWpBi/9uHNCJQAcpQIv/A944HjxwCYKL/yYcEGBsIl3Ch4BconPdoAAkNrybfZ/ +5mY0yggRhQBJIMAAEQ6eFc92gADQ3LZ+wY4D8ADex3CAANDctngEiAgjAwAII4MDACNAAUkgwwMW +bXV4z3OAAFDeA2PPcIAA0N22eM91gABIJKSFuIUBgKV4BCCADwAAAAgGewLwY4Hou5gZwAAA3Qny +pBEAAADdl72RuJS4pBkAADsMHgDPcIAASCTEgMC6yIYEJo4fAEAAAD6+HubYekV7mBnAAB0Lngek +EQAAhSUBFIy4kbikGQAAnBlAAx7wJwveB6QRAgCFJQEUlr2YvY26kbqkGYAAnBlAAySAEIGeuBCh +CvCUvZa9nBlAAySAEIGeuJ+4EKF5AQ/88cAKCS/8A9jPdoAABDAghkB5gOBt8iCGYHkE2NMIEAAg +hmB5ANhnuBUIFQMzJgBwgAAwZEAnAXIUeQB5ANhC8M9wgAAMMCCAYHkB2IDgAdjAeDjwz3WAAAww +IIVgeQHYIwhQACCFYHkB2BsI0AAghWB5AdgPCJAAIIVgeQHYwQhRgAHYHvDPcIAADDAggGB5AdiF +4AHYwHgU8M9wgAAMMCCAYHkB2IHgAdjAeArwz3CAAAwwIIBgeQHYg+AB2MB4LwhQACCG63VgeQDY +GnDPcIAADDAggGB5Adi4cDfYCiHAD6lylNuZBC/9CiQABIEAD/zgePHAGggP/M91gADYsiAVgBDP +doAAiAkXCFEAAN8aCKAJ6XAC2AOm5KYD8AHYBaaKIMwITgkgAyiFSQAP/M9wgADYsiiAz3KAAIgJ +L3gLCFEAAtgEogPwAdgFoiUBIAOKIMwI4HjPcIAA8K0ogM9ygACICS94CwhRAATYBKID8AHYBaL9 +ACADiiDMCOB4DcjHcIAA6M00iAHhL3k0qB0JMgEDEgI2z3ADAIQAoBoAAIogCAAGGhgwC/CKIBAA +BhoYMM9wAgGEAKAaAACKIAQAsQAgAwDZz3KgACwgcIIJ6AIjQgATDoRwAIAAAA8IhAAA2ATw/wjF +gAHY4H7gePHAHg/v+5hwpcEod7hzAN4EI4AP/wAAABi6BXpveQi5/9gIuGR4KLgFeUV5CN30JIAD +J3hEwB4L4AoQFAAxEhQCMWG9QCgBBAV5R3lEwRAUAjEUJIAzQLDXDXWQAeZTJcIFQKcAFA0BB9kH +8BB9FCdMEAC0YbkUJEAwu3tPvQCQpXtwe+kJtYB4YAQggA8AAAD/ELgFekCn7Qbv+6XA4HjxwDYI +AADaCAAA2ggAANHA4H7geM9xgADEKkAhAANVIcIFEQiFAADZBBhQAPsIhIDgfuB48cDqCOAFANiC +CC/9ANjPcIAAoFxWCQ/9z3CAAIBcTgkP/dIJD/7mDYAHANh2C6ACgNlCCoAKjgpAAnIMwAq2CIAB +bgiAAgDYJg8v/ghxJguACd4IgAKeCmAB/9guDwABiiCFDwhxFg7gBAhy0cDgfvHA3g3v+4og/w/P +daAAOC7HhQelz3CgAFQuC4DTuAYmAHAPAP//cg3gCxbZBg6AAcelGQbP++B44H7gePHA4cUA3c9w +gAAgCqCgz3CAAHykrLBKC+AKqXBmD8/8HglgCqlwXg5AA9oJT/2yDgABiiAGCghxlg3gBAhyvgpv +/KlwigpP/M0Fz/sA2c9woADsJyug4H7xwM9wgADcmRoO4AsT2bILwADRwOB+4HjxwDIN7/sE2aTB +Ag7gC4twz3WAAOQiAIUB4AClFQhRAAHZz3CgAMgcMaCSD2AMKHDPcIAAbDwAiADez3GgAOwngeAB +2MB4B7iDuBC4hSCRAAahxgkv/AHYAIVCIECAAKUF9M9woADIHNGgPgvAADEF7/ukwPHAocGLcJIN +4AsB2SYLwAChwNHA4H7gePHAocGLcD4N4AsE2QDAUSBAgIgM4gXKIKIAAMBRIICAlAsCCgDAUSDA +gCgNAgYAwFEgAIEQCgIGegggCwHYz3GAruAB7HAgoAHI7HEAoc9ygABgmookgX0A2aggAALwIkMA +7HBgoAHh9grgAADYocDRwOB+8cDhxaPBAdhAwM91gAA4HKlwvgzgC1zZrg0P/jqFG4UkeDyFBHmB +wFoKb/5BwQHAO4UEeUHBXg3gAoogWARVJUAf1gpv/qlxz3CAALAdygpv/kAlARuLcEYJ4AAE2RoL +b/4BwACFhugFhYDgZAxB/gIND/4xBO/7o8DgePHA4cXPcIAAiGUAgKLBQcCBwAHdegzgC6lxiiAX +CvoM4AIBEgE2IcKKIBcKBRSBMBC65gzgAkV5QMWLcOYI4AAE2ekD7/uiwPHAocGLcEIM4AsB2QDA +LyQHAAAcADEbCN4BBxIFNgohwA/rcoogxQCxB+/8J9uKIBcKngzgAgESATY6DmABQNiiCcAA3giA +BqHA0cDgfuB48cAeC8/7z3WAAKQiAoUjhQHeEHHAfqlw3gvgCwPZdgnAAATuAoUD8ACFYQPv+wOl +4H7gePHA4cXPdYAAvCKpcHoL4AsQ2QAVBBAhDFAAQQzQACkMEAEKIcAP63KP2I24mNspB+/8uHMB +hQy4BCCADwEAAPABpQzwIYXPcIAAKDwgoCOFz3CAAA4bIKgDzNdwAAAAQAHYwiAKABe4x3AADgAA +g7iduJ+47HEAoQESATbscCCgIgngAAHY2QLP++B48cDhxQDZz3KAAMwiIKIhoiKiz3DQ/gAABKIA +Fg1AoKIAFgNAYaIAFgBAABYAQCUN3hf/u0DYzyDiB8oggQ8AANAAzyDhB89xnwC4/x2hBvDPcJ8A +uP89oAPM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChARIBNuxwIKCWCOAAAdimCEACSQLP +++B48cAAFgJAocFAwgEUgDAPCB4Az3GAAASkBPDPcYAABLRAoWCJAdoI8AAWAEAVIYwAAKQB4n14 +9QiFgBcLHgAAFgBBA/AA2BUhjAAApAHi+QpUgQPM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7js +cgCiARICNuxwQKA+COAAAomhwNHA4H7gePHA4cXPdYAAoAupcNYJ4AsI2QCFz3GgALgeAqEBhQOh +mg+AAJUBz/uRB4AA8cCkwYtwsgngCxDZA8zXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEB +EgE27HAgoADAUSAAgAPABvQCwYYN4AAA2gXwBgwgAgHBhg+AAKTA0cDgfgkAAAAFAAAA8cAuD4AA +SQbACeB48cDhxbTBi3WpcH4J4AsU2QDAhuDMIOKBBvQGDaACqXAIcSTwDwiRANoNoAKpcAhxHPAR +CFEAWg+gAqlwCHEW8IPgzCAiggf0+gugAqlwCHEM8BEIEQF2DaACqXAIcQbwPQhRAoohhAADzNdw +AAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HIAogESAjbscECg1g6gAChwjQDv+7TACiHAD+tyfNiN +uHfbi7tKJAAAbQTv/AolAAHgePHA4cWiwYt1qXDGCOALAtliD6ACqXBWDoAAUQDv+6LA8cDOD4/7 +ABYQQKHBTCCAoMohxg/KIsYHyiCGDwAAjwzKI4YPAACMBcokBgQUBOb8yiUmAAAcADSLdalwBg2g +AATZiiDMCvII4AIKcYQoCCkvdwAnjh+AABCwXg1gCgRuz3CAAPSxGoAhCAAEJBaAECLoqXAE2Zna +Htu6CyAJGLsA2CQeAhAY8Md3gAAEsAuHgbgLp89wgACICS+AAdoF6USgBNgG8ADZLKBJoCSgBdgi +D8ACfQev+6HA4HjxwOHFz3CAAOwiJIAggW4I4AKKIMwNz3CAAEgrAIAEIL6PAMAAAAn0z3CAAOyt +AIiMIMOPBPK+Ci/9AdjPdYAAnKypcK4PoAtS2YYPgAajhYogTA4mCOACqXE2DYAAiiCMDhoI4AJq +2boM4ACpcAhxz3CAANBZ9gxACv7Zz3CAAOytDQev+yCo8cDPcIAAjLJiD6ALDdn6DIAA8gqABdHA +4H7gePHAXg6v+4ogzA6iwcoPoAKKIQUGi3A6D6ALAtkDFJEwIQmSIAQUhTAKIcAP63LPcAAAhAyK +I4UJqQLv/AokQAQCFIAwz3aAAIgJhCkIKS93IB4CEM9wgAAosPlgLIlAIBIDABQUMQAg0wMc6Yog +TA1mD6ACiiEFDIogTA1aD6ACKnH6CGABQiSAIQHYEbb/2CEeAhBAJgAYSgugAATZafAA2BG2IR5C +FM91gAAUrkAlEBL9ZYtwqXGSDKAJAtpAJQASUg6gC0IkgSEAJ4AfgAAUrggQBQDPcIAA+OIFgFMl +QQUQccohxg/KIsYHyiCGDwAAhQzKI4YPAACEAeQB5vzKJEYE/g6gBipwSiSAcADZqCDAA4QpCAkv +cDIiAiAI6ggVBRAwIAQgTQxAAQHhQCYAGLIKoAAE2QHZDBtCIIcVABaAuIcdGBDqC+ACKHCKIEwN +hg6gAoohxgiKIEwNeg6gAiKFiiBMDW4OoAIqcUUFr/uiwAohwA/rcs9wAACGDGEB7/yKI8YFABYA +QF0DgADxwOHFz3WAAOjPqXCyDaALA9kBhc9xoACAJQyhAoUNoQCNUSAAgADYjrgE8g+hA/AQoSoL +gAAlBY/74HjgfuB44H7geOB+4HjgfuB44H7gePHAjgyv+wTZo8EA30LHDg6gC4twPtjiDaACARIB +Nj7Y1g2gAgQUATE+2M4NoAIGFAExA8zXcAAAAEAB2MIgCgAXuAAggQ8ADgAABhQAMRt4E+AEIIAP +AAD8/yV4nbifuOxxAKEBEgE27HAgoADB7HAgoAQUATHscCCwBhQBMexwILAGFAQxHQweAAESBTYK +IcAP63LPcAAATyZpAO/8adsB3c9xAAAiIk4NoAI+2M4PIAOpcALBJXhCwADAUSAAgMolohDKIYIP +AAAzMygNogLKIKIPz3CgACwgQBAQAAPwAecGFAAxgQ8DEAQUADGCxi0NkRAbeBB4yXGSCGADqXLs +cQCpBBQAMclxG3gB4BB4eghgA6ly7HEAqQjwyXFuCGADqXLscQCxBBQAMUAgRQDPcKAALCAQgC8l +SAECIAAE13ABAKCGnAfl/wQcRDEIFAQwCiHAD+tyz3AAAFAmpQev/IzbBg8AA89woAAsIDCAPtiG +DKACAiEBBD/YegygAgLBzgmgAALAaQOv+6PA4HjxwAAWhUCmwQ0NMwYAHEIxGw0TAgohwA/rcs9w +AABmGZXbUQev/EokQAAAFoBAARwCMAAWgEACHAIwABaAQAMcAjCLcNYJoAWBwQLCjuoAFIUwCiHA +D+tyz3AAAGcZn9sRB6/8iiTDDwTAYHoFwQPBi+kKIcAP63IAFIUwz3AAAGgZo9vu8QHAgODjIEIA +yiAiAOoIgACmwNHA4H7xwM9wgADINzoLoAsJ2YIOgASyCoAEGguABMYIgADRwOB+4HjxwM9wgADM +ORYLoAsH2a4IgADRwOB+4HjxwKXBi3ACC6ALBdkAwC0IHgDPcIAASCQDgBiIHQhRAADYmrjPcaAA +yB8PoQHApBkAAMPYGrgOoWoIgAClwNHA4H7geAkFYAUA2OB48cDPcIAAMDx2CqALKNlKCIAA0cDg +fuB48cDhxQAWAEDPdYAAOB4ApT0IkQAA2c9wnwC4/z2gHNkV8M9woADIOzaARCECBzaAhiH/CCV6 +NoCGIf8IRXnPcqAAqCBNguTij/ft6fIPQAAghV0JVQEzJkFwgABcZEAngHI0eAB4OBAEAFgQBQAK +IcAP63LPcAAAmSG9Ba/8L9vWC+ACVNgpCF4Az3GAAGQ8AIGBuCIIIAwAoQrwrgnv/QHYIg3AAgTw +og/AA5EBj/vxwF4NwAeKD0AA0cDgfuB48cBiC2AIANjPcIAASCTIEAEGwLmB4QHZwHkWDOALPBCA +ANHA4H7gePHA4cXPdYAASCQAhcQQAAYdCF4BCiHAD+tyhdiNuIojnA9KJEAAKQWv/Lhz2g0ACW4O +YAoB2M9wgACQJwiIPQjRAQGFxBAABjEIXgEODM/8z3GAAPjiBJAlgQq4HQhAAAohwA/rcobYjbiK +I10CSiQAAN0Er/y4c0oKj/wCDOAJANgKCcAC0g5AAM0Aj/vgePHAAgxgCADYDgyP/M9xgACwvwKJ +YgvgCyCJ0cDgfuB48cCiwYtwygigCwjZAMDPcYAArDwAoQjoBhQAMQOxBBQAMQKxgg5AAKLA0cDg +fuB48cChwYHYYMADzAIcBDAAwJ4M7/sC2aHA0cDgfvHAocGA2GDAA8wCHAQwz3CgANQDHJDWCgAB +AMB2DO/7AtnWDuAIAtihwNHA4H7gePHACiHAD+tyz3AAADAliiOMB4okgw8NBK/8SiUAAOB48cDh +xSDbz3GgAMgcaaEAFgBAz3KgABAUDKIAFgVAAd1MJQCAyiHBD8oiwQfKIIEPAAAsJcojgQ8AAAkB +xAOh/MokQQMYGkABaBlAAQPYD6K5oWqhtg1AALEHT/vxwOHFrcGLdalwCgigCw3ZAMAdeFMgAQBE +KT4NqXAAIYF/gAAI2eoNYAkN2oINQAB9B2/7rcDgeCUEIAwA2OB48cD2Dm/7iiCSDazBTgigAsXZ +i3C+D2ALDNkAFAAxsOjPdYAABDAghc92gADQMmB5ANhAJI8wJQgQAyCFYHkA2BkIEAQghWB5ANgR +CFAEIIVgeQDYDQiRBOlwyXEY2gXw6XDJcS7atgxACQHYYB4CEBeGgODcC+H7yiAhAAAUADExCFEA +iiDSDdIPYALe2UAkgDDPdYAA0DJAJYEbfgxgCS7aAdg3hWEdAhCB4aQLwfu+DEAAqQZv+6zA4Hjx +wC4Ob/sX2bfBDg9gC4twI8BKIkAgUyDQAIYg/gNCKBEBJQgyJAwcAjQKIcAP63Jy2I24iiMPAwok +gARtAq/8CiUABEgUBTAgwEAojiDPdYAAkNrWflEgAIDAZUEtTwPAv75mhiD3D1z0jegKIcAP63Jz +2I24iiPPBDECr/wKJAAEiiBPBQpx4g1gBKhyAcACwQpyTguv+2ZufwgQAOlwQgzgCwpxDRSAMIUg +wQANHAIwiiD/D1PAAIapuACmEsCGIPsPKLgPrkokAHQA2KggAAP/2rtgQCiBIDZ5EuM7Y0CrAeAK +cF4L4AuLcc9wgABIJPAgwQPAEQAGDyAABMAZGAAPjg8IUQCA58wgoqPYCwIMAd8C8ALfagvgAQpw +B/CA4MongRTKJyISgee49CCGz3CAAEgkA4AYiCh1hiX7HyEIUAAKDAACIIYZ6M9wgACQJwiIJwjR +AUEpQAMfCB4AE8ASwhcIHgKGIvsPQSoEAk+OCwoAAai4U8ATwBLCBnlEeCV4AKaGIPsPC+2A4Mog +AQTKISEAeAghA8oi4QMOHkIUANjPcYAA0N0WIQEEQIYAoQGhCwpfBQDYi7gBoQ8KngUBgUUgAAYB +ocINr/yLcA0UgDA/CF4BWBQAMQW2WhQAMQa2BZYX6G4LAAIO6AaWEwheAAYIr/wKcPYKAAwF2BKu +ANgFtgfwCnAA2QIIIAMP2g0UgDA1CF4AUBQAMQK2FOgA3RDYOnAClhEgQIPKIAIEyiFCA9gP4gLK +IkIDQiFAIOcIdYAB5Q0UgDAPCB4BCnCCDOAAVRSBMA0UgDA7CN4ANcFWFAIxCnD6Cu/8EsOMIAKA +uHAN9AohwA/rcnTYjbiKI5IPJQCv/EokQABRJcCByiciEd4L4AsKcAPM13AAAABAAdjCIAoAF7jH +cAAOAACDuJ24n7jscQChARIBNuxwIKAyCmAA6XDBA2/7t8DxwFILb/uKIFMJpMEA3alxigtgBKly +z3aAAFDiAI5KJEAgoa4CHgIVAeAArqOuoaaipqSmpaa4rrmuAcC6rgLBB6YDwCimCaYB2IYMYAKp +cYHA9gtgCwHZAcAHplp1tfCCwOYLYAsC2QGOAsEB3+OuAeABrgPAKKYJpulwUgxgAulxAsCLctYO +r/sDwQQgAAUvJAcgAtkCrgDAI64BpjIMYALpcEwkAKCN8gDBz3KAAJDaSiMAIBJpFngAYg8jUyAt +uFMgEACKIFQF0gpgBApyz3CAACAKABARAC8lyiTPcYAAIAr4rgQlQCQAoQPZI64QHsAUFB4AFAge +QBQDptILYALpcM9wgAAgCgCAjOgZCRAg0g3gAyDYBNkjrvmusgtgAulwBdkjrqYLYAIB2CDA0grg +ABDZAMACuBZ4ACCBD4AAkNqisYogCAAAoQbZI65+C2ACAdgAwADZ5g3gAg/aAMCA2QK4FnjHcIAA +kNooqCmoB9kjrloLYAIB2M9wgABIJPAgAgTPc4AA0N3AEgEGBCFABcAaGAAAwgDZz3CAAPDZVnsg +oyGjVHh6CCAMoLAJ6GoIAAwI2SOu+q4SC2ACAdhAIlIgIcBScJgGzf8J2SOu/gpgAgHYA8zXcAAA +AEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKEBEgE27HAgoFYIYACKcArZI67GCmACAdiRAW/7pMDg +ePHAiiBVCwDZeglgBChyHgxACboPAADRwOB+4HjxwOHFABYNQAPMAdrXcAAAAEAByMIiigAXusdy +AA4AAPIMYAlTJQEQUSVAkM9xgAC0PQHYyiAhAHUBb/sAoeB48cChwYtwzglgCwHZABQFMBkNEQAK +IcAP63KJ2I24RdtFBW/8SiRAAM9xgAC8zQMZQgFALYADAqFKJMBwANqoIIACANgPIIAACyBAgQP0 +AeID8A64AaEaDwAAocDRwOB+4H7gePHAeghP+wAWEkEAFgBBz3GAAJDaQCqAIBZ4MCEFAKLBQS1A +AyMKNCRTIBMACiHAD+tyddiNuIojGAJKJEAAxQRv/EolAAAdDV4CCiHAD+tydtiNuIojWAKpBG/8 +CiSABM9wgADQ3BYggAQacAIJYAsC2c9wgABw2RYggATyCGALAtlAKpUhACWAL4AAUN7iCGALENmL +cNoIYAsB2QAlgC+AAFDePg+gBRDZARCAICEIEgQKIcAP63J32I24iiOYCkokQAA9BG/8CiWABADd +ENg6cBUlQCPPcYAAUN4wIRQABCSCrwAAAAEEHAA1SPJEJA4mI74B5gQkgC8GAAAAMbghwd9goOHR +JOGiNfID6hcOlRAEJIQvAAAAJFsMgA8AAAAkUwjVAA0IkQAl6kcOkRAE6szhPgAJAM9wgAAMMCCA +YHkG2C8IhAPPcIAASCTwIMAEwxAABgHZBCC+jwAGAAAEJIAvAAAACMIhQQAruAsJBQAA2ALwAdgP +eATwAd/pcAQkgS8BAADALrnPcoAANHQpYjB3AdnCIU0AgODMISKAFvJCIUAgLQh1gAHlAhCAIM9x +gAAcaQhhOQhQAAohwA/rcnnYjbiKIxkAOfEKIcAPz3CAAEgk8CDABOtyiiNYD8MQBAZ42I24GQNv +/AolAAUDEIAgCGEXCJAACiHAD+tyetiNuIojmQIZ8cIOoAtKcM9wgABw2RYggAQgkM9yAAAYFQkh +gQDmDCAAILCdBi/7osDgePHAABaBQM9wgABoXSCoABaEQAAWgUDPcIAAcV0gqAAWgEBQJL6ByiHC +D8oiwgfKIIIPAADaFMojgg8AAIEHkAJi/MolIgDPcIAAgAkAkAbo2g9AC+IOQAt+DAAA0cDgfnkC +IAsA2OB48cD6DS/7ANlKJAByqCBAAgAWAkAVIkAwDhiYAAHhABYNQAAWDkByDwALz3CgABQErKDP +cKAA1AvcoDYMAAApBg/74HjxwK4NL/sI2aLBARIONs91oAA4LhwVEBA6DiALi3AAFAQwAN8EJL6P +8P8AAMohwg/KIsIHyiCCDwAApijKI4IPAADhBtwBYvzKJcIAUSRAgsohwg/KIsIHyiCCDwAApyjK +I4IPAADkBrgBYvzKJcIA56UKDOALP9gAwAQUATEHpe4MIAuCuRwdABSiCyAAARqYM4EFL/uiwPHA +ANj+CiAABBKBMAQShTAKIcAP63I42IojDwFtAW/8SiQAAOB+4HjxwOHFocEf3Ytwxg0gCwTZYb35 +DVWQVgsAAFEFL/uhwPHAqcGLcFYOIAsS2T4LAACpwNHA4H7geAAWAEAAFgBAABaAQAAWgEAAFgBB +ABaAQAAWgEAAFoBAABaAQAAWAEEAFgBBABYAQAEDAADxwOHFocEL3YtwWg0gCwTZYb35DVWQ6goA +AOUEL/uhwPHArcGLcD4NIAsN2dIKAACtwNHA4H7geMkAIAsB2OB44H7gePHAocEA2UDBABYCQAAW +AEA1ClAAA8zXcAAAAEAB2MIgCgAXuMdwAA4AAEUgAAOduJ+47HIAogESAjbscECg7HAgoB/wHgpg +BYtwA8wB2ddwAAAAQAHYwiAKABe4x3AADgAAhLiduJ+47HIAogESAjbscECg7HAgoADC7HBAoIIK +IAAocKHA0cDgfuB48cC2Cy/7AtnPd4AAgF0yDSAL6XBAh892oADsJ891gAAMMJcKHgArhkQigACG +Iv8OIrqhuRS6tLkFIIMAZXkrpgQggA8QAAIABCKCDxAAAgDPcYAAqAhFeAuhIIUE3mB5yXAbCNAB +IIVgeclwDwiQASCFYHkB2CUIUQAAh89xoADIHBEIXgAB2B6hFgmABQbwANgeoVoIQAUghWB5Adhp +CFEBAIdhCN4Az3CgAEQdxaDDoMSgKPDPcKAAyBwB2T6gC4aBuAum2giABSCFYHkB2CUIUQHPcIAA +SCQDgAiAGQgeAADZlLnPcIAAqAgroAuGlLgJ8M9wgACoCADZK6ALhrS4C6YqCQAAFQMP+/HAz3CA +AAgaKgwgCwLZFgkAANHA4H7gePHAlgov+wDaCHUods9woADUCziAQiEBCIDhyiGMAEAmABIQcSAP +hQsDzNdwAAAAQAHYwiAKABe4ACCBDwAOAAAHbgQggA8AAPz/JXiduJ+47HEAoQESATbscCCgIr4G +8OxxAKEE5WG++Q61kACF4ggAAJECD/vgePHA4cXPcqAA1AsD3bGiANtwogMSAjfXcgAAAEAB2sIi +igAXusdyAA4AAEUiAgadup+67HNAowLaFBqCMAUSAzbscmCiCxICNwHiCxqcMOxyAKIBEgI27HBA +oOxwIKDPcKAAsB8B2Tmgz3GAAOwiCIFAgOxwQKAMgQCAXggAAM9xoADIOw6BiLgOoQkCD/vgeAPM +13AAAABAAdjCIAoAF7jHcAAOAABPIIEAnbmfuexwIKDPcKAAFAQD2SWgARICNs9woADUC02gz3Cg +AEQdNaDgfuB4A9rPcaAAFARFoc9xoADUCw2hz3CgAEQdVaDgfgPaz3GgABQERaHPcaAA1AsNoeB+ +A9rPcaAAFARFoc9xoAD8Cwypz3CgAEQdVaDgfuB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjP +c6AAqCAxg89ygADEKgOCOGADogHYEqPgfuB48cC+CC/7uHHPcIAA9LFoEAQASiAAIEwkgIDKIsYH +yiCGDwAAkQzKI4YPAAC3BwQFJvzKIcYPz3CAAIgJB4CELAgJACGBf4AAFK4WeceBfw0RAM9wgABM +K/ILb/yKIQ8Pz3CAAOAq5gtv/CDZz3ClAAgMoIBTJU2QEvIpDVAQKw2QEAohwA/rcs9wAACSDIoj +nweYdZ0EL/wKJQAE/9gH8P/YCLgD8P/YELjPcYAAqAgMoa2hzqEA2ZG5z3CgANAbMaAiDyAKAdgd +8M9zgACoCA6Dm+jPcYAAEGrPcoAATCvPdYAAxCqKJMN/CnCoIMACD2EVJcMT54PwIg4AAeD+Zsej +IQAP+zgTBAAKIcAP63LPcAAAkwyKIx8MGQQv/AolAATgeOHF4cbPcKAAFAQD2SOgDcjPcoAA3M5h +ks9xgADMzcSKFCENAGi1ACCDD4AA7M044cCrYoIVeQaSYKEDEgM2wB0EEASCoBMBAIYhww8leKAb +AADBxuB/wcXxwEoPz/oIdlIOoAEodYDg0SVikwHYA/QA2AS4z3WAABjjFHgJZR1lFQlRADoKIAqp +cD4Ib/0BjQDYAK0BhXkH7/oApvHA7g7P+g0SATbPd6AAvC3PcIAASCQupwSAAN1GEBEBViBSBFYg +kwQNEhA3ViAUBUYgwCADEgI2DRocMKQSAACEuKQaAAABkqLBhhpEAwjoz3CAAMzO9CBAAAnoAYIP +CJ8DUCAAIC8gCCBTIH6gPgMBAM92gAC0PWkWABYB4AQSAzZpHhgQpBtAAwGSlQgQAM9wgADMzTR4 +gBABB4UJEQDQEAEBUyHBgBT0chIBAeCSIn+4EoEAIn/wf+AYxAOkEgEAhiHzjwbyaL/wf+AYxANw +Eg8B4BAAASGS4njxcMInDhDCIc4DdBIAAThguBKBAHQbRAOgszhgEHiQGwQAvhsEABCKEKsBggGj +CIoIqxKKANoSq5a6MvBCCeABiiAFAQ+H+QjehU+HUyLAAk0KngUTCJUDpxYAFra6AeCnHhgQHPBk +uAQSATYQeJAZBAAEIoAPAAAA8Cy4dBlEA6CxEKmhsQPIvhlEA2GAqKmGI/8NhLthoRKIEqn2ujIC +AQAA2Ja4BBIBNqQZAAApCl4FUgvv/gDYBBIBNqQRAAAEIIIPAgAAAC26BSICBC8giCA/8AGBpwge +ATTKUIlJIMQA8mrPcIAAkNr2f+BgcokRCJ4Fz3CAANDcVngBiAPwANgAJI8PgADQ3FZ/5I8II8MD +CCMAAEkgwwMWanV4z3OAAFDeAGPPc4AA0N1We0GDz3OAAEgkZIN4g2V6BCKCDwAAAAhGeJgZAAAA +2Ja4QYGGIv8NQQgeBZ8KEACYEYIAQCIAKUhgz3OAABy0QMAgwsO6XHr0I4IAUfAKIcAP63I02Iy4 +X9sFu4okgw8JAS/8SiUAAJgRAwCcGUADRwteAoC4pBkAACnqmBGAAM9ygABIJEOChiD/A0S4MiQA +IIm4QMAgw1SCZHqGI/8DhiL/DkS7emJPes9zgAB0afQjggAd8BULHgIJ6pgRggBAIgApSGAM8ITq +ANpIcBHwmBGAAMO4HHgyIwAgQMAgws9zgADEs8O6XHr0I4IAiBkAAJgRAACEGYQAkBEBAa4IIAAA +2gQSATYDEg02hBECAYIZBADPc6AAyB9YYBB4sBkEAPgTAgCwFQ8RQn/PcoAASCREggAh0SNUEgQB +ACRPBB9noBMDAPB/OQvEA1CCmBUDEAsiwIAW9DCJUI0wctEjIoIW8oYj/wkjuwHjIQuUAAK6z3GA +AJDaVnpBYREJXgS4FgAWAeC4HhgQDfCAcBB4hh0EEGoWABYNGhw0AeBqHhgQmQPv+qLAocHxwEYL +z/oIdUbA6L0ocM4AIQBIdgO4QCCQBUQlAhYjugQljx8GAAAAAeJBL0AUBCWBH8AAAABYYDa5z3KA +AAB0qXPGuyliCGI4YEEtgRJSIQEAwLkDuRjhheDKIY0PAQCJDdUhDgAvIUggBCWBHwAAABjPcIAA +wGvXcQAAAAgeACIA8CDAACbBoOESAAEAz3FCe9BeBSh+AAogwA4KcQUpPgAKIMAOJLgB4ATvUyAB +ADhgAimBIyENXhPPcoAA/GxAkgUqPgAAIYB/AAD/Py64XwAgABlhVwAgABV5USVAklYAIQAmxbfl +IgALADNoUyUCEM9wgAC8afAggAAFKT4ACiDADgHgBvCK5cAo4QDAKKIAz3GAAEgkI4HA2jSBpHmG +If8OIrk6etp6GWIweAjcewLP+jNoUyXAEBx4z3KAAEBt8CIAABbhBSk+AAogwA4B4BTZhQfv/9p5 +z3GAAOwiJIFBKIIF1bgggUEpgwXVuQJ5z3CAAPjiYnoFgMm6BSi+ACdxz3CAAKBcA4AAgOB/OGDP +cYAA7CIkgSCBQSiDBdW4QSmCBdW5GQklAFtjz3KAAPjiRYJZYQJ5AeMD8AJ5QCuABZkH7/8lePHA +MgzP+n4J7/pQ2UXASiAAINoJr/6GxSMINSUEFQEUBcAVIAAEIKBAIFAg7QmBj63e774k3LMBz/oK +IcAP63LPcAAAixOKIwcLmHOpBe/7CiUABPHA4cWYcBkI9AC4cQohwA/rcn3YjbiNBe/78NvPcIAA +SCTwIAEBiiMLDUAhAgZ4Yk8NEQCogXpioKJJgUGgXIlIqF2JSagqEYIASqgrEYIAS6gsEYIATKhN +kUewV5FIsEiBBCKCDwAGAACA4gHawHpSqFSRU6gogcC5Laga8DkNUQBiYkihQYBJoUiIXKlJiF2p +SogqGYIAS4grGYIATIgsGYIAU4hUsUeQTbEIkBex+QDP+gohwA/rcpDYjbjlBO/7iiOEB+B48cBq +CM/6z3aAABykBBYFEEIlQQCF4UwBLQCiwTImQXCAABhkQCcAcjR4AHgC2ACmAdnPcIAAoCIgsEIM +4AcocAKGz3WAAGQiKIVHhQgVBBAPIEAAAqbPcIAARCI1eECgGBUFEQwVBhDPcIAAcDgA2TSoz3AA +AAiuQMAFhRAVBxBBwBqNO41AhZIPoAhhhYogGQE+CeABOo1h8M9wgACiIgHZIKjPcIAAZCIngM9w +gAAgzS+gOggv/QLYUfAE2ACmANjPd4AAoCKyC+AHALfPdYAAZCIChkiFZ4UPIIEAz3CAAEQiVXhg +oCKm7NiuD6ADQJcIFQQQz3AAAAiuGBUFEQwVBhBAwAWFEBUHEEHAGo07jUCFBg+gCGGFJBWAEEiF +ANlRIACBBIYPIYEACfIB289ygABwOHSqBXkkpgPwJngEpt4MoAMA2KPxhgsP/AfwiiAZAXoI4AEi +hnkHr/qiwAgWBBAKIcAP63LPcAAAQh9pA+/7iiNEB/HA4cWKIBkATgjgAa3ZAd3PcIAAHKSgoADY +z3GAAKAi4grgBwCxpgwgAKlwPQeP+vHA4cUA2M91gAAcpFoIIAAApQIO7/wC2CKFz3KAAKAid9jS +DqADQJIRB4/68cCWDo/6AN7Pd4AAoCLAt5YK4AfJcM91gAAcpMKlw6XEpYogyQDJcZ4OoANAlwHY +zQav+gCl4HjxwM9xgAAcpAARBQAbDVQBCiHAD+tyz3AAAEEfmduxAu/7iiSDDwGhz3CAAIwi8CBA +AUB40cDgfvHAJg6P+s91gAAcpAQVBRCiwUkNUAAjDZAA2w1QAQgVBBAKIcAP63LPcAAARB9pAu/7 +iiNHBs9wgACiIgHZIKjPcIAAZCIngM9wgAAgzS+gWg7v/ALYUfAE2AClANnPcIAAoCIgsNIJ4Aco +cM92gABkIgKFSIZnhg8ggQDPcIAARCJVeCKlYKDODaADiiCGCwgWBBAYFgURz3AAAAiuDBYGEEDA +BYYQFgcQQcAajjuOQIYmDaAIYYYkFoAQAd9IhgDZUSAAgQSFDyGBAAjyz3KAAHA49KoFeSSlBPAm +eASl+gqgAwDYiiAZAaIOoAE6jgPwmgkP/JkFr/qiwPHAKg2P+s92gAAcpAQWBRBCJUEAhOHmAA0A +MyZBcIAAIGRAJ4ByNHgAeAKGz3GAAGQiSIEngQ8ggAACps9wgABEIlV4IKBZ8M9wgACiIoDZIKjP +cIAAZCIngM9wgAAgzS+gTg3v/ALYR/AKlowgAoAR9ADYz3WAAKAiwgjgBwC1IoaKIAUE1gygA0CV +AdgApjPwA9gApjHwA4aMIMOPAd8S9ADYz3WAAKAikgjgBwC1IoaKIEUK4KaiDKADQJXSCA/8G/AA +2Q8hAQAChgYgQIAS9ADYz3WAAKAiYgjgBwC1IoaKIIUMdgygA0CVoggv/OCmA/ACpp0Ej/oIFgQQ +CiHAD+tyz3AAAEMfkQDv+4ojRgDgePHA4cXPdYAAHKQEFQUQQiVBAJMJlQEzJkFwgAAoZEAngHI0 +eAB4z3CAAKIigNkgqM9wgABkIieAz3CAACDNL6BaDO/8Atgt8AKFz3GAAGQiSIEngQ8ggAACpc9w +gABEIlV4IKAd8AOFjCDDjwHaCfIA2Q8hAQAChQYgQIAN9M9wgACgIkCwog+gBwHYA9juD+/7AKUF +8AKlA/AB2ACl8QOP+ggVBBAKIcAP63LPcAAARR/VB6/7iiNIC+B48cBeC4/6CHaKIFkBsgygAclx +z3WAABykw6XmDO//Bdgjhc9ygACgIqDYYgugA0CSmQOP+vHAHguv+oogmQHPdYAAHKR6DKABIoXP +cIAA2LIIgADfJ7jAuBN4xrgB4Aq1CNg6cADeAoUPJs4TCyYAkDfyBIULIICDHvLGeASlz3CAANiy +IBCAAC0IUADPcYAAcDgQiQHgD3gQqYogCgUiDKAByXHPcYAA2LIIgYYgww+AuAihiiCZAQYMoAHp +cc9wgABEIhUg0AMAEAAggODiIAIAAoUA2QAYQCDGeAKlQiFAIAHnfwh1gO9/KpXPdoAAoCIAlhcJ +UQCP6ADZz3CAAHA4NKiKIAoEBPCH6IogSgSuC6ABANkBhRMIUAEAloHgA9jKICIB2gvP/4kCj/rg +eM9ygAAcpCKCANsPIwMAZnkios9xgABEIgDaFXngf0Chz3OAABykQoMPIkIAQqPPcoAARCI1euB/ +AKLgePHA8gmv+hlxCHaIdc9xgABkIhqpGxkCAkChEBnAAQwZgAGioQPAGBlEAQTFB6EmwKihJBkC +AAfAYaEFoYogGQISC6ABqXFT2Mlx1gmgA6lyJsAVCB4AV9jJccYJoAOpcgbYBvCB5gLYyiBiACYL +z//tAY/68cByCY/6OnDPdoAA5CIAhgHgz3WgAMgfAKYRCFEAAdhRHRiQ4gsAC6QVEBDPcIAACDIm +gM93gACUv2B5ANgBhynoJNgY2eILIAsz2h8IUAAEFwUQCiHAD+tyz3AAAHQZjduJBa/7CiRABCTY +Adm6CyALM9ofCFAABBcFEAohwA/rcs9wAACrKJLbYQWv+wokQASkFQEQiiAYD0YKoAECIQEEAIZC +IECAAKYF9ADYUR0YkCEBj/rgePHAxgiv+oogGA7PdoAAyDsWCqABMobPcIAACDIEgIroz3EAAK0L +AgqgAYogGA4+8DKG5OHW9s91gAAsYACF2uBQ9oogWA7iCaABCNlAhTKGiiCYDhC60gmgAUV5CNgb +8NrhSAAKAM91gAAsYACF5ODc9oogWA6yCaABiiE/DkCFMoaKIJgOELqeCaABRXmKID8OBg7ACiCF +SBYAERC5rg7v/yV4EoYApYkAj/rgfuB44H7geM9wgAAgOkCIEQoeAM9xoACsLxmBirgZoREKXgDP +caAArC8ZgY64GaHgfuB4z3GgAMg7HYEH6ILYFKHPcACAERQOoeB+8cDhxbTBi3WpcM9xgADcZX4I +r/pQ2uoOQAEmDGABqXAhAK/6tMDgeM9wgACoz2yIz3GAAHykjCMCgAqRQSgCAwzyGQjfAgK7dnvH +c4AAkNoCkw8ggAACswDY4H8MseB48cBqD2/6VGiGIvgDTyJDAlMhwgAFIsQAz3KAAPDZFHqP4Yoj +DwzKICkACfYAkgDdDyVNEIojzw+meACyANlKJAB0z3aAAIynz3KAAASoz3WAAAioqCDABBQiQADk +kGR/GQ8BEQDf5LAWJkAQ4KDhoEAlABk1eOCgAeFZB0/64HjxwADanroA2c9woAD8REGg4HghoPIO +4AcocAvIBCCAD/7//wMLGhgwC8iHuAsaGDDRwOB+8cC6Dk/6SHaA4AHdRPaKJf8fE3gJCRMAs30z +eRQhAABSCK/6O3mseAAeQB75Bm/6AdjgeKHB8cDhxULAmHFIdYDgANpE9gHaE3hCwDoJIAiCwALA +AuoTeBoIr/qIcQClCNzPBk/64HjxwOHFCHIB3YDhyiHBD8oiwQfKIIEPAACbE8ojgQ8AAFwAyiQh +AJgCofvKJQEBgOJE9lN6iiX/HwkJEwAzebN9FCGAAMYPb/o7eax4eQZv+i9w4HjxwOHFz3WAAHyk +z3CAAEgkI4BAhQCBQwoBAAKRQpU7CgEAAoVKCa/7I4WMIAKAFfLPcoAAHAohggDbDyMDAAK4ZnkW +eCGiACCBD4AAkNoAgaq4iLgAoQDYGQZv+gy14HjPcJ8AuP/PcaD+8AQ2oM9woADIHzyAQBAABs9w +nwC4/1gYAAhKJMBxz3EAAAiBqCAAAinYErjwIEAAAeHgfuB48cDhxc9wAAD//891gACYpAOlz3CA +AHRbJgsACc9wgACQWx4LAAnPcIAAOFwSCwAJz3CAAFRcCgsACQDZIKUF2AGlIqWKIMkDdg5gAYoh +zARaDK/8BthWDK/8Cdh1BU/6B9nPcqAA1AcaGliADegZEgGGCSBDAA8SAYYCIMCAeWEPGliA9fXg +fvHA0gxP+gMSAzYIdw0SDjbPcYAAzM0Qi89ygACQ2tR5ArgWeAViMYktvVhgwL0M6SGDFQleA89x +gACAI7R5oJEQ5aCxJZAjCVIAYbklsBCLMmg2eTtiZZM6YofrJpJRIUCAMAiC+4YIQAqCD2AFDcgD +yAHZoBhAAM9xDwD//+4IIADpcLUET/rxwEIMb/oD2M92oADUBxMeGJAPFhGWABYBQAAWDUCiwc9w +sP4AANO5BXlAxc9ynwC4/zaiUyXBFCV4FqIgwCEIEAcKIcAP63I12Iy4z3MAAPQMmHNlAK/7SiUA +AAAWD0DwfwAWEEBA51EgAKXAJ6IQA+cEJ48fAAD8/wfwz3AAAAUNIg8AARkWAJZCJwEU8QhEgAAh +wCMPHhiQA9ggHhiQGRYAlicIFAIfFgCWQcAhwJzgyiHCD8oiwgc22Mojgg8AABENzyAiA8X12tji +DGABqXEEIIAvAAAAQMkDb/qiwPHAYgtv+sjagiQDMgh1KHbPcYAATGYaDG/6i3DPcIAA4BgNgM9x +nwC4/w3oHaHPcoAAzCIEggHgs7i1uLi4BKIWoc9woAAUBAHaRKDPcoAArD4YguK9AeAYos9woP4Q +ARahQC4AFKV4FqHKICIAtA7B/xpwDcjPcaAAZC7PcqAAOC7wIQEA07kHgiR4BCCRA6fwkg7P/892 +gACI5xpwyXBiD6ADi3GaCSALyXCZ8APfz3CgABQE8KDkoAAWBEAHGhgxABYFQAEaWDEEyj0IEQeL +cHYLYAoO2STAUyDBAIYg/gNEuMQcAjBkwUQmjRQzDl4QjtiQuKAcADDVDh4RhtiQuKAcADBk8Oty +z3AAANwOz3MAAPQKxQZv+wohwA8RCBAgjNiQuKAcADBS8AK5NnnHcYAAkNpAgUh0hCQMkA3yEQpe +AovYkLigHAAwAd1A8IjYkLj68U6JUHCR2M8gIgT09QHAEQieBgHdkNiQuKAcADAu8DMUgDAikS0J +DgAHyAQggA8AwAAAHQiBDwDAAAAiwIDgyiCJDwAAjQCsB+n/zyApBArBjCH/jxLyz3CgACwgEIAi +eNdwAIAAAMoghQ8AAIcAhAfl/88gJQRMIACgzCUhkF/1z3CgABQE46BMIACgqXZl9VMmfpAI8s9w +oAAUBAmAgOBd9WUOXhAB2lcJECAqcS8oQQBOIIMHlOPKJcUQhfdodYAlwhTPcKAAaCzwIEADlOMP +eMonxRCE92h3gCfCEc91oAAYLPAlzROxcMoiIgAJ6gDYDyDAAAYhAYDa9QHYAvAA2IDgK/NlAW/6 +gCQDMvHAAglP+hpwjgugATDYmHApuFEgAIDKIcIPyiLCB8oggg8AAOkUyiOCDwAAxwBIBWL7yiUi +ACzYngugAUAogSAB3oolDxpSC6ABMNiYcCm4GQgeAIwmD5om8joL4AoB2GG95w11kAHmLgugATTY +TyABBZW5YgugATTYHgugASzYCHUWC6ABNNi4cDMIXgUKIcAP63LPcAAA6xTj29kEb/tKJAAACiHA +D+tyz3AAAOoU1NvFBG/7SiUAAK0Ab/pBLQAU4HjxwD4IT/oIdwDeyXBeDCAEyXED2Ml1GnAJ70Qt +PhcAIYB/gABAWgIOwAgK70QtPhcAIYB/gADoWu4NwAhCIEAg1wh1gAHlz3CAAIyyyXSdsDC8nrDP +cIAAkApaC2AFwKBBAE/64H7gePHAz3WAACwJfNg2CWABIIUAFQQQCiHADwESBTbrcs9wAADbDiUE +b/uP2+B44H7gePHAng8P+s9woABULiuAB93TuS8oQQBOII8Hz3CgAMAvpRAShhQQEYbPdqAAFASq +pjoMYAeA2PPYBbiA2T4KoAGfuQ0SEDb12AW4MgqgAalxqqYNGlgzBPAD2AWmqYYb7XztQS2AkAry +LyQJcOB4qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKggQAEAFoBA4Hiphujx89imCaABBbjJCN+H9dgF +uNoJoAEKcSgeABSU5w0aGDTKIcUDhffpcYAhwgHPcKAAGCzwIEIAlOfKIcUDhffpcYAhwgTPcKAA +aCw1eAS/QKDHd4AATNcVhzaHBXkXh7iHJXgFJQ2QyiHCD8oiwgfKIIIPAADCIcojgg8AAI0HyiRC +AwQDYvvKJSIAgNnPcKAA0BswoM9woADAL6UYmIQUGFiExQYP+vHAXg4P+qQRAAAodVEgAIAK2Mog +IQSYFQEQBCG+jwEAAMB2HQQQMPQtCR4CRCEABiO4QWgEIYAPBgAAADG4WGAEIYIPBgAAAddyAgAA +AcogoQAD8AHYIwhQABUIkACD4ADYyiDhAcAooQML8M9wgAC8zQKABfDPcIAAvM0BgAV5mB1AEJ4V +ABGUHUAQkh0EEIIVABGQFRERsh0EEADYgB0EEH4dBBADyM92oADUB0GQEBWSEAjqDcjPcYAAzM70 +IQAAE+gZFgCWHwgVDg3Mz3GAAKw+RiCAAg0aHDAagQHgfwIgABqhDxYUlgnqDcjPcYAAzM70IQAA +A+gB2AXwA9gTHhiQANgHEg82ARIQNgAWBEB6cAcaGDEAFgVAARpYMQTKnODKIsIHyiCCDwAA3A7K +I4IPAAD0CqgBYvvKIcIPqXAODiAKDtkfC1EgBMgBkCDoz3GAACBAGoEB4BqhHIEB4ByhFvADyAGQ +FOgNyM9xgACczvQhAABTIMCACvTPcYAAIEAagQHgGqEbgQHgG6EDEgE2AYEdCJ4DVBEAAVMgwIAI +9M9xgAAgQBmBAeAZoQIVBREpDRAAAYXuuMohwg/KIsIHyiCiC88gIgPKI4IPAAC1BwwBYvvKJGIA +AJWwcMohzA/KIswHyiDsC88gLAPKI4wPAAC4B+gAbPvKJGwAEI1TIMEAhiD+A0S4xB0CEKQVABAw +rUcInwUHEgI2AiLBAwDYDwlQAAIngRCMIcOPAvQB2JPoDczPcYAArD5GIIACDRocMBmBAeAZoQ8e +GJUHGtgzARoYNIPwBxrYMwEaGDQA2HQdBBB+CWAAqXDPcYAACHQLYXQVAhHPcYAAEHTwIQAAemJQ +eqQVARB0HYQQJXikHQAQBMgBkBPoHQtRIAGVuBWPEFhgIJX4YBB4vh0EEFlhP2cO8L4VABEJ8CCV +uBWAEFlhOGAQeL4dBBAId5AdBBAPFgCWtB0EEDIK4ASpcBCNMnfMIIGEE/IKIcAP63JAKQ0kQCgO +BDDYjLgA24u7BSXEE90HL/sFJoUUpBUAEAh0hCQakCHyPQheAgPIAZAa6A3Iz3GAAMzNFHmAEQAH +kujQEQABahWPEAHgw7j4YA94ah0CEB4PoACpcGodwhMF8BIPoACpcA8eGJVVAw/64HjxwAILD/oa +cADfpBnAA89wgABIJASA0InwoAfIBCCADwDAAAAodTMIgQ8AwAAADcjPcYAAzM0UeRGJj+jPcIAA +cNnWeCKICI0PCEMACnCeCC/+qXHc8FEgAKCG8gQVBBCBDB4BDcjPcoAAzM0UehEShQAPeEkgwgBy +bs9wgACQ2nZ7YGAyjRMIngXPcIAA0NzWeAGIAvAA2MdygADQ3NZ6RIoIIYEACCEBAAAhQAFJIMED +Fm41eM9xgABQ3gBhz3KAAEgkRILPcYAA0N3WeViCIYFFeQQhgQ8AAAAIJngD8AOFz3GAAEgkmB0A +ECSBKIEEIYEPAEAAAD65UyQCAB7hOHpFeJgdABAXCJ4HpBUAEIy4pB0AEFDYnB0AEHjwKwjeB6QV +ABCNuKQdABDPcEABUACcHQAQz3CAAEgkJIAQgZ64EKFk8AXYFLicHQAQz3CAAEgkpB3AEySAEIGe +uJ+4EKFW8I8IXicBhXMIHgESjTQSgTBJIcEAcm7PcoAAkNp2e2JiEQqeBc9ygADQ3NZ6QYoD8ADa +x3GAANDc1nkkiQggQAAIIIAASSDBAxZuNXjPcoAASCREgs9xgABQ3gFhz3CAANDd1nhYggGARXgE +IIAPAAAACAZ5AvAjhZgdQBANyM9ygAAEzhV6IKKcHcATBfAF2BS4nB0AEBEIHiUA2JG4pB0AEATw +pB3AE3QdxBNyDiAAqXDPcYAACHR0FQIRCWFZYTB5dB1EEM9xgAAQdPAhAACkFQEQJXiYFQEQpB0A +EBkJXgIK2XYdRBB4HUQQgLikHQAQFfAQ2c9ygABIJHYdRBBDgkiCEwreAArZeB1EEIO4pB0AEAPw +eB1EED4Kb/ypcKQVABBEIH6CjBWBEBjyz3KAAEgkQ4JUgiR6hiH/A0S5hiL/Djpiz3GAAJxp9CGR +AM9xgAB0afQhkgAO8MO5z3KAAPSzPHn0IlEAz3KAAMSz9CJSAJgVBRBTIASAyiCCBBX0iBWBEFEl +AILDuTx50SAihQjyz3CAABy09CBAAAfwz3CAAMSz9CBAACGFCwneAIQdBBAD8IQdxBMdDR4CRCUC +BiO6AeIEJYAPBgAAADG4GmID8AHaA8gBkCPoDcjPcYAAzM70IQAAgugBlbgVgxB0FQERBCW+jwEA +AMB5YThgEHi+HQQQD/QKIcAP63Is2Iy4iiMaCQUEL/uKJIMPAJXm8T0KUACC4swi4oDKIcIPyiLC +B8ogYgvPICIDyiOCDwAAtQbKJCIA0AMi+8olAgHPcIAA0NzWeAOIB/DPcIAA0NzWeAKIjBUBEA64 +JXiMHQAQz3CAAFQJQIAGgqAQAAaH6M9wgABwXQCItwgQAA0SAzavC5ABAJXPcYAAIECfCBIMz3CA +AMzNdHgRiIsIEQCDDBEAewgeIJ4VABHPc4AADECKuJ4dBBAWkwHgEHgWswHI56EFoZgVARCuua+5 +sLmYHUAQBoKgEAAGLygBAE4gggcjug7iDyGAAKQVARCYHQAQtLmkHUAQnhUBEae5nh1EEM9xgABk +XQChBCCAD///0/aYHQAQDdiYHQIQCfAQ2AbwCNgE8ALYAvAB2AehmBUAEL4VAREWCy//ANqkFQEQ +BCG+jwAAADCCHQQQUPKMFQIQnBUAEZQdgBCSHQQQgB2EFAMSAzYZCR4DFNiQHQQQKnB+HQQQeBMO +AQrwDtiQHQQQfh3EE3gTDgFKcMJ4EHiyHQQQz3CAAHjNAICGIH+PC/SYFQ4QEw5fEmGTheuRuZK5 +pB1AEBC4JXikHQAQBCKCDwAAABDPcYAASCRkgVIiAgMQgwV6UKNEgRCCBCCBDwAAABA9eSV4EKIU +8JgVARCAHcQTlB1AEJ4VARF+HcQTkh1EEL4VARGyHQQQkB1EEIAVABF+FQIRghUBERpihBUAEVlh +OGAQeLAdBBCkFQAQz3GfALj/FqGcFQAQFqGtBc/54HjxwFoNz/kSC0/8z3CAAKjPDIjPcYAAkNoC +uBZ4AGEtuFMgAIAF9M91gAC0PQ3wz3GAAEgkIIHEEQEGz3WAALQ9USFAgQT0AdncHUAQz3GAAEgk +8CEAAM9ygABwXCCCGIhFCTUBQR0YEDMmQXCAAFhkQCcAcjR4AHiiCeAIA9gyCeAIQNgA2OAdABAO +8M9zoACoIDGDAoIA3sKiOGDgHQAQAdgSoyEFz/nxwOHFB9gNGhgwz3GgANQHGhkYgA4RDYbPcIAA +4BhIgAcaWDMP6s9wnwC4/12gz3OAAMwiRIMB4rO6tbq4ukSjVqDPcKAASCy+oB8RAIYBGhgwBMqc +4Mwggo8AAJEABvIAFgBAABYAQAPMz3GfALj/GKGKIEYEng3gAAESATYBEgE2fdhaDOACBxICNpkE +7/kEyuB48cC4cQK5z3KAAJDaNnkwIkQAUSRAgsoiwgfKIIIPAADLIsojgg8AAJMDYAAi+8ohwg9A +LYEBz3KAAFDeIWJRIUCCiiIIBcoiYQPPcYAA0NwWIUEBIokOuUV5IKDRwOB+8cC+C8/5z3KAAOwi +RILPdYAAmKRihUCCNrs2ulBz1iKNDwAAgADAhT1ifmYdDYUTCiHAD+tyiiCNAoojEASYdukH7/q4 +dR5m/w2Fk1hg3QPv+Q4ggAPgeOB/ANjgfwHYz3GAANw84H/wIQAA8cCYcAohwA/rcgolwAfPcAAA +nxmpB+/6O9vgeM9xgAC4POB/8CEAAPHAmHAKIcAP63IKJcAHzdgFuIUH7/pE289xgADwPOB/8CEA +APHAmHAKIcAP63IKJcAHz3AAAKEZXQfv+k3b4Hjhxc91gADMQAKFQp3Pc4AAyDs0gx0IUQAiek56 +5OIAnQT2M4PG4VL2ANgCpQGdDvBCeS55jCEDggGdiPYzg9DhxPYB2AKlAJ3gf8HFz3GAANQJJIHg +fyCgEYjgf8K44HjPcYAAgFxGgYoh/w8goAbqIoIgoAHYA/AC2OB+z3GAAKBcRoGKIf8PIKAG6iKC +IKAB2APwAtjgfooh/w8goM9zgACgXEaDEuokghsJXgDPcYAAyFsPCkAAz3GAAORbEQpBAECC5QuB +gALYBfAigiCgAdjgfvHABgrP+c8IEADPdoAAdLYvjs9wgADQ3M91gABIJDZ4IogDhQDfz3KgACwg +NBARATwSEgAOjoDgnAApAMolqRCMIgGkkAAlAMolJRFklpTjwCOGDwAAkwDPcKAAaCzwINAA5aJQ +2EUhQQIY2qINoAog2/i4yiUiEi70A9jPcaAA9AcFoYTaDXBAsEIiACgNcgCyQIYNcECgQpYNcECw +A4VAgA1wQKADhUKQDXBAsAaWQCgCJcO4DLiCuAV6DXBAoOShDo4B4A6uCgkgCSpwAd0Q8ADdz3aA +AHS2yg3gBgSWANjPcYAArD4Orh6BAeAeoXEB7/mpcOB48cAWCc/5GnCEKAgJACGBf4AAFK6HEQ0G +z3CAAIgJAoCgvYcZWAMEiA/oA4GN6AohwA/rcsnYBLiKI5wOCiQABEkF7/q4dQKBm+jPcoAAELYT +EgCGjCDDjwryz3CAAOwiBIAAgAKhHBoYhBbwz3CAALwqABgABCoMYAgA2Azwqg7P/oQoCCkIcQAh +gH+AABSw3g5ACOUAz/nxwH4Iz/kacIogTAvaCeAACnHPdoAAjLIpCNQgHpY6FgURCiHAD+tyELgF +JQUAz3AAAIMMiiOFD7kE7/oKJAAEQCgNId1lJZUElRC5JXg56M9wgACsdPAgAQREKD4nACGAf4AA +oFovdyCgI5UClRC5Hg7v/iV4CHEAJ4AfgACUWlYOQAjPcIAAoHTwIAEEACeAH4AA+FlHlSCgI5UC +lRC6ELkleCaV2g4v+0V54g3P/ghxACeAH4AA7FkeDkAIXpYdlgDZDyEBBBC6RXgGIECAAd0dtjC4 +HrYZ9M9xgADsLwCBoLgOC+AEAKHPcIAA7CIEgJbaHtsggM9wgADMsqKgIaAM2d4LIAcYuxDaz3GA +AJAKAIEAKgIERnjJB6/5AKHxwGYPj/kA3c92gACMsj6WDyUNEB2WELkleAYgfoNB9M9xgADsLwCB +gLgAoc9wgACACc9xgAB0JwCQR4k3CgEAz3CAAIIJAJBBiSsKAQDPcIAAhAkAiCaJGwkBAAvIBCCA +D/7//wMLGhgwC8iHuAsaGDDPcIAA7CIEgM9xgADMspbaHtsAgAChANgCoShwDNkyCyAHGLsA2CIM +YACA2T6WHZYQuSV4pXgdtjC4JQev+R624HjxwOHFigxgACh1gODKIEEDxAqhA8ohYQANB4/5MQfP +//HAjg6P+foL4AcA3c9woADQGxGAFwjeA4YK4AgB2M9xgAAgQAmBAeAJoQbIAxIONkMIHgCkFgAQ +OwieBM9xgAC0PACBF+igoQEJnkXPcKAAxCyrgN/Yng+gAKlxUyWBFP69zCEigAfymBYAENIK7/4A +2gMSATagEQAAIQgeBIogCAAMGhww+thqD6AAoBEBAJoMYAQDyDbwRwgeBQfI0IkA2jMRjwAEIIAP +AQAA8EEoDQPPcaAAOC4HgQ8iQgMB3EZ4B6ENyJIMYAoALAAQx3eAAJDaAr7WfhLn32egrwMSATaK +IBAABhoYMPvYBg+gAKARAQADyKAQgADE4OQPAQoD2c9woAAUBCOg7QWP+eB48cB+DY/5z3WAAEin +AYXPc4AA0N1EIASDz3CAAKjPDIjSaNZ+x3aAAJDaQIYWeyGDEvJQIo8F4KZGIQEGIaMNDBEBkb/g +pgXwsbq2ukCmag0ACgfwlrpApkUhAQYhowuNoriFBa/5C63hxeHGz3CAAKjPTIiMIgKAz3OAAEin +F/LKi89wgADQ3TJqNnnHcYAAkNpWeECBoYAF7pW6QKGrvQTwtbpAoYu9oaAA2Aurwcbgf8HFocHx +wFEgAILhxagAIQAIdUQlAxYEJYIfBgAAACO7MboB43piBCWAH8AAAAA2uM9zgAAAdEpjCGNYYEEt +ghJSIgIAwLoDuhjiheDKIo0PAQCJDdUiDgBQcVIAJQAA2O29GAAhAAIhgADPcRxHx3EFKH4ACiDA +DgPwIrhBLUETwLkEuTR5qXLGukkiwgVUec9ygABgazJiDw3eEkEqAQEUIYIABSo+AEEpAHII3JcE +j/kKIcAP63I72Iy4z3MAAFcSSiQAAHUA7/oKJQAB8cD+C4/5z3CAAKjPDIiMIAKAK/IyaDZ5x3GA +AJDaoIHPc4AA0N3Pd4AASKfklxZ7QYNQJY4Vhie7H8ChjCdEkEYiAgZBowX0kb7AoQvwsb22vaCh +Dw9REJa9oKFFIgIGQaPWCwAKANnPcIAASKf5A6/5K6jgfuB44H7geOB+4HjgfwDY4H7gePHA8gnP ++eB44HjgeOB4aSCAAW8hPwBpIAAA9/HxwFYLj/kacM92oADQDwDdB/AQFgCW/WH4YBAeGJAjbW8I +RCAlFgOWJRYCli8kxwAlFgCWT38PfQi9pX/XDBGDgufMJ+KTzCcil8olQhAh9M91gAAYs0mtJRYC +lgqtS60lFgKWaK1MraJpFQ/RE89wgAAls1YM7/kN2Q3lEw8RF89wgAAys0YM7/kN2Q3lEBYAlgIg +QSM4YBAeGJAdA6/5AdjgePHAugqP+aHBCHUodoTlANiY94twEgzv+QTZAMAbCIAPmglQb89xoADU +Cw+BZL24YA+hAdgG8KlwJg/v/8lxD3jlAq/5ocDgeM9zgADsL0CDRXgAoxnpz3GAAHQnz3CAAIAJ +AJBHiTkKAQDPcIAAggkAkEGJKQoBAM9wgACECQCIJokdCQEAC8gEIIAP/v//AwsaGDALyIe4CxoY +MOB+4HjgfuB48cDPc4AATAlocFYMIAAE2QRrTgwgAATZ0cDgfgDYz3GAAAAKAamZB+AJAKnxwOHF +jg9v/THYtGiGD2/9M9gFfRi9z3CAAJBk6g6gB5C9KLg5Aq/5pXjgeOHFMmg2ec9ygACQ2iFiz3KA +AEgkLbnAufAiQwAog1EhAIDPcYAAvM1BgQnyPIuA4cUigQ8AAAoCA/JFIkIDSiQAdADbqCCAAjZo +dXkAIY0PgABQ3kClAeMA3c9zgADQ3BYjAgCgqqGqAdkiqgPZI6pKJABxqXKoIMABeWIWeaSpAeLg +f8HF4HjhxUokAHgA2KggAAgA2891gADMIkCFDyMDAAsiwIAP8kGFCyLAgEDazyLiB8oigQ8AANAA +zyLhBwLwANrPc4AA4BgVe0CjAeDgf8HFz3CAACRdBoADgCCAz3CAACiaKaAlAS/8EdjgePHAygiv ++QHZz3CAAJQq9ggv/ySgiiDFD892oADIHxkeGJAB2AHZKHIoc64O4ACYcfIPr/sA384Jz/vPdaAA +0A/1pc9woADAL3oQAYaJuYu5ehhYgM9xgAAA0RAYWIAF2fQYQIAqDMABognP/koMAAdA2c9wnwC4 +/zKg8gmACYDZz3CgABQELKAdHViQUgiACMoOAAj2DWAI6XAH2EgeGJByDgAGHguAAbYPAACyDYAD +Hg0AB4YKQAPqCoAH5ghAAFIPgAauC4/75ggAAU4MAAiiCg//6guABKoOAAE6DQAGqg8ABTIMwAPy +Dk/+Sg5ABEIOQARmDgAHz3AAAP7K0gtP+zEAj/ngePHAvg9P+aXBz3eAAEgkA4cIgMC4Og6gCC8g +ACAA3c92oAC0R89woACMRLigANiTuHceGJAI2HceGJAA2J64Ux4YkOB4z3CAAFgCEHhTHliTRx4Y +kM9wgAA8BRB4SB4YkE8ggCNFIAANTyDGBzTYRB4YkBzYRR4YkM9wgADcmQGIRh4YkM9wgAD8PBIP +4AQMiEokgHDPcYAAGOOoIIADz3KAALzNAYJ0bXR7O2MDowKCAeUEo891gABAXQCFA+hkHhiQQx6Y +kQ4LoAgB2AOHCIBAhR8IHgBTIkEAErlEIgADDrgleIYi/wMKukV4EfBIcIYg8w8KuAQigQ8AAAAM +BrkleAQigQ8AAAAwArkleM9xgAAkMAKhi3WpcDIK7/oU2TjYZMAA2ATZTgygCKlyz3AABhsATh4Y +kOkGb/mlwOB48cDhxRDdHgygAalwB9kLuc9yoADwFzGiz3EAAPD/OKKyoi4LgAHVBk/54HjxwFYO +b/kA2s9wgACICUOg/9vPcIAAELYTGNiASiSAcEhxqCBAB4QpCAkAIY5/gAAQsM93gACgXEGmBt2l +ps91AQCw1KSmRqbnpiQeghAAIY1/gAAwsEClAeHPcIAAELYcGNiAz3GAAEwvAIEc2kCgGNgOCCAA +AqFFBk/5OdnPcKUACAw+oOB+/9nPcIAA7K0gqADZz3CAAJSt4H81oOB4ANqA4cokTXDoIK0B/9lc +YCCsAeLgfuB48cDhxc9xgAAgzc9wgAA8dLILYAdI2s9wgABgbc9xgACACqILYAcI2gDdz3GAALA0 +oaGioc9wgADIN6mgHg9gAgOBz3CgACwgz3GAADg4UIAQgEWhBqEaD+ABqaG5BU/58cAA2c9ygACM +siCiz3CAAOwvIKA9sjC5PrLRwOB+4HjgfuB48cAaDW/5INkA2s91oADIHCmlz3GgAJQTW6HPc4AA +ABpgg/Noz3aAABzPDIb1f1MgxAXwY/tjUyCPAKTBi3E7D9EQH4abuB+mNBaAEOKLGwjBAyhwQCMB +BERrsg8gCEAmAxwN2irwHoaRuJK4HqbPcKAAzBcr8CEPURFBKgJSQCMABMG6eg1v/YhzH4acuB+m +DdoU8Cy4UyACAB+GA7qZuB+m5IMF4gUnABEAoQWDAaEGgwKhB4MDoQPiz3CgAMwXz3GgAJQTXKEB +2ojqH4aXuB+mINgKpRnwAMED2hgYWIABwRkYWIACwRoYWIADwRsYWIAUGJiAihYBERAYWIAE2Sel +FhiYgH0Eb/mkwPHADgxP+aQQAQCiwdsJXwYg2c9zoADIHCmjpBABAF0J3gExiM91oAAQFCO5wLkD +uQXhA9pPpUaFQcKN4RDeyibiEQYUDzGMJ8OfCfQEFA8x8XbMJ+qQAd5C9gDe6+7FgEV+x6WxiIYl +/B8YvaV6z3WgAMwXWqAW8EWAz3GgABAUR6GkEAEAFQmeAjGI17qGIfwPGLlFeTqgz3WgAMwXDdkB +2gPhDR2YkA4dWJAmgBkdWJAngBodWJAogBsdWJAD2RQdWJBwEAEBEB1YkHAQAQHPdaAA9AcE4Sel +R6OkEAEAmbmkGEAAkQNv+aLA8cAiC2/5BNkIdQ0SDjYG2A0aGDDPd6AAFAQKp89wgAAwdCoKQAcA +hSIKYAcE2QGFGgpgBzjZCBUEEAGFABAFAQkMEAAVDQUBCiHAD+tyGdiMuEEHb/pv2wOF8glgB4hx +AYVChSCQBYXiCWAHQnnKpxkDb/kNGpgz4H7geM9yoAD8RDmCBCG+jwAACCAA2AX0PYL5uQLyAdjg +fw948cAA2Jy4z3GgAKwvHKEagVEggIIagQvyqrgaoRqB5wgegHoKL/0B2AnwirgaoRqB0wgfgHYK +L/0B2ADZm7nPcKAA0BsxoHILwAkuCcAJz3CAAGQ8AIBCIACAyiBiANHA4H7gePHA4cXPcYAAjLJ+ +kV2RELtlegHdGwoPAM9xgABAWkQoPgfmD+AHACFADqlwAvAA2GkCT/lGgQnqI4FggSKCYnkwcADY +AvYB2OB+4HjxwNoJT/kIdc92gACgXN4P7//JcQfoqXDSD+//QCYBGIPoANgJ8M9xgACAXL4P7/+p +cHnoAdgRAk/54HjPcIAAqAgOgIDgAdjgf8B48cCSCAAABuiOCAAADwhRAM9wgADAKgCAg+gA2BLw +jggAAI/ofggAAIvoz3CAAJAnLJDPcIAASCQekOMJAYAB2NHA4H7ZAOAAEdjgePHAuHDPcaAArC8Y +gRkIngYKIcAP63KKIIwJZ9uRBW/6SiQAABWBGwgfAAohwA/rcoogzAlo23kFb/pKJAAAAdjRwOB+ +4H8A2OB/ANjgfwDY4H8A2OB/AdjgfwDY4H8B2M9wgAAwGwCIBujPcIAAGBsBiAPwAdjgfg0JXkcJ +yL24CRoYMADZnbnPcKAA0BsxoOB+4HjxwK4IT/nPdaAAyB8kFQ6WFQ4eEoUVAJbGCY/7iiAEACQd +GJATDp4QiiDXCuIJYADJcR4PwAnlAE/54HjxwG4Ib/k02PYKgADPd4AAAJAvCB4E7gngAgDYwgng +AgHYiiYQEADdQg/v/qlwFCdME2G+ALT1DnWQAeUO8ADbiiIQAA4KIARweBQnzBBhugC09Qp1gAHj +fQBP+fHAEghv+TTYocEA3ZYKoABAxc93gAAAeDMIHgTeC+AAAdgD3gq+ANiMuLhgEHiLcdoM4AAB +2hQnTBNhvgC06w51kAHlpgvAABDwBdsKuwPaCrp4ZaIJIAQQeBQnTBNhugC08wp1gAHlEQBv+aHA +4HjPcAEAXDXPcYAAOBxhGRgAz3AAAIRTVSFCB0AhAwMG6B2jG4GDuBuhz3AAAFBTBugCohuBgrgb +oc9wAAAsUwboAKIbgYC4G6HgfuB48cDhxW/YlbjPdaAAyB8SHRiQz3ABAEA8FR0YkCoPQAiKIAQA +DqWpBw/54HjhxQDbz3KAAIynSiQAdM91gAAEqGhwqCAAAkAlARIUeWCxAeBIcM9xoAAEJQ+hViIA +BBGhViIABRCh4H/BxeB48cDqDg/5z3WAAEgkBYXPdqAAxCd1HhiQDJV2HhiQB4V5HhiQEJV6HhiQ +4g3v/wDfG+h3HtiTeB7Yk4Ae2JOBHtiTB4WGHhiQEJWHHhiQB4WKHhiQEJWLHhiQBYWIHhiQDJWJ +HhiQBYWEHhiQDJWFHhiQwdhQHhiQ2QYP+eHFCHHDuM9ygAAMqPQiAwDJu3BxyiQidMogIgDoICIC +9CINAMm9CQlAAwHg4H/BxfHA4cUIdc9xoADEJxkRAIYB2oDgEREAhsB6gOIApdEg4YcA2DP0z3CA +AJjPDIDPcaAAyB9k4B6hENgOoQHYFRkYgFYI4AkL2FEhAMbKICIAGPQlCF5Hz3GgANQLFoE4gSTg +FQhFADII4AkD2AkLH0AJCJ5EGNgD8ADYgODKIOIEz3GgAJAjPoEgpS0GD/ngePHArg0P+c92gABI +JBUmARBAgWmCuIpBK8AAwLgXuMdwAACAHOS7zyAiBuC7Tt/PIKIAyieCHwAATgGG5c8nYRIpC18B +z3WAAJAnGBUEEb6WGw0BEaGGxBUNFhENXxGghsQVDRYHDV4RgbhRIwCCzyCiBRui/KJAgc9wOgRK +cB2ioIEH2LoPYAAKuAQggA8HAAAAMLhVCBUCMyYAcIAAZGRAJwFyFHkAeYogBAAepRnwiiAQAB6l +FfAA2Iu4HqUR8ADYjLgepQ3wANiNuB6lCfAD2Ay4HqUF8ADYjrgepYIgAQE1BS/5HqUKIcAP63KM +2I24vtuLu0okAAAlAW/6CiUAAeB48cDPcYAApD8XoeB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB44HjgeNHA4H7geCGAANpTIX6AC/IA2pm6USFAgMoigg8AAIMAwCpi +Bs9xoAC0R0wZgIBmkEgjAwNHkBC7BCODDw8AAADIukV7SJAMugQigg8AAADwZXpQGYCAQIBZCtEA +YoDPcp8AuP99okWAXBmAgEaAYBmAgEeAfBmAgEiAZBmAgEmAaBmAgEqAgBmAgEuAbBmAgEyAcBmA +gE2AhBmAgE6AdBmAgE+AeBmAgFCAiBmAgECAKwoRAkWAnBmAgEaAoBmAgEeAvBmAgEiApBmAgEmA +qBmAgAqAwBkAgM9wAABVVeB+4HjxwI4LD/kIdgGAz3WAAMwiAKUChs93nwC4/wGlANgCpc9w0P4A +ADoKr/8EpQDYHacAhs92oAC0Ry8I0QGGCgAAz3ADPwI/mx4YkM9wCT8LP5weGJAA2Je4TB4AkG8g +QwCTHhiQBfBvIEMATB4AkEILj/4AhSsI3gfPcKAAyDsdgA/oz3CAAOAYH4AN6B2nBIUB4LO4tbi4 +uBanBKUD8ADYHafPcAAAVVVNAw/5IpBIIUEBQCkCAyOQYoDLuY+5RXnPcp8AuP99os9yoADsRiei +I4A1oiSANqIFgBeiz3AAAFVV4H7xwKYKL/kA26bBz3GAAMwiYKFhoWKhz3agALRHLBYBkAokgA8A +AFVVSiQAeGhxqCBAAs9ygADgGDV6YKIB4QDZmLmVHliQSiSAcc9ygADMIggSBQALEJAAAN05ddh1 +qXKpcxl1qCABBL9g5I8AIEoDDQ/QHxUkQTNgoQHjSicAAA8nRwMLIMChCfIVJEEzIIFKIwAQDyNL +EAPwSiMAECqICyHAgQUhyRIJ8hUkQTMggUonAAAPJ0cAA/BKJwAABSLCAZDvFSRBMyCBDBAFAD/f +CiSADwAArd4PIEgQBBrCExEPURIVJEEzIIEA2g8iQgATDxESFSRBMyCBSiYAAA8mRgAB5c91gADM +IggdQBGA48okgQ8AAK3eNvIliGSIBiKCAcW6ELkFI4MPAAAAP2V5BSGBDwA/AACbHliQZ4gmiAi7 +ZXloiBC7ZXlpiBi7ZXmcHliQBiEBEsW5n7mZHliQANmVHpiQmblMHkCQJIBYHkCQCpCUHhiQbyBD +AJMeGJBKCY/+iHCFAS/5psDhxeHGz3KgAMBGz3OgAOBGSiQAcgDdqCAAAxYgTgMhhgHlBBpQACKG +BBtQADGAz3KgALRHmBpYgDKAsxpYgBOAtBoYgM9wAABVVcHG4H/BxfHAtMEF2BW4QcDPcB8A//9C +wADZQ8FEwUXBRsFHwT/YSMBJwUrBS8FMwU3BTsFPwVDBUcHPcAAA//9SwFPAdg/v/4twtMDRwOB+ +4HjhxeHGJIjPcoAAuHSmiMK5LmIA2Q8hgQPPc4AAbKxAg4TtJnpAoxjwRXkgoyWIFSONAyOlJohF +iFlhJqUggIwhEIBF94ohEAAgoCO5IaMAgCq4AqMA2c9woADwNiygI4MloCaDJqAkgyegJ4MooCWD +KaAogyqgIYMroCKDLaAggySgwcbgf8HF8cDSD8/4CHeacbpy2nMKIgAhCiNAIQohgCHPcAAAyBtq +CmAACiDAIfpwz3AAAMwbWgpAABtwz3AAAAQcTgpAAM92oADIHztwAdgTpgbYz3WAANhAAKXhpQgd +ABUMHUAVEB2AFRQdgBQYHcAUHB1AFA7AIB0AFM9xgADsIgmlBIEAgAqlCIEAgAulDIEAgAyloBYA +EA2lpBYAEA6lqBYAEA+lz3BDdagSEKXiCWAAKNgRpdoJYAAA2BKlUyfAdROlAchUHQAXFqUSFgCW +UB0AFxelExYAls9xoADIHBilFBYAllMhAjMZpRUWAJYQuhqlJBYAlhulFhYAlhylz3CAAKQ/F4Ad +pc9wgADYQHgYgArPcIAA2EB8GMAKz3CAAFRBBBgAC89wgADYQIQYQAsogYgYQADPcYAAAAAkgYwY +QAAvIccFCLklei8hBwZFeZAYQAC+CWAAJdm5Bs/48cCeDs/4z3OAAGxBQ4MA3c92oAAsINCG8mr0 +f39nxacEpwHijCIIgCanQ6OF9wKDo6MB4AKj0QbP+OB4z3GAAOwiCIEA2kCgDIEB2UCgz3CgALAf +NKDgfvHASg7v+IogTA2iD+//iiGYBAvIAN4EIIAP////AwsaGDAmDiAAyXDPdYAAiAkRhYDg1Awi +AMogYgB9Bu/40KXxwOHFggkgAAh1jCD/jwj0iiAHClYP7/+pcQDYYQbP+PHA6g3v+GrYosGLcQHa +VgmgAEhzj+gKIcAP63LPcAAA0hSKI8UEiiSBCi0CL/pKJQAAQCSBMUTYAdoqCaAASHOP6AohwA/r +cs9wAADTFIojxQWKJAEBAQIv+kolAAC2Dm/5BhQAMZEIEACBwWvYAdryCKAASHOQ6AohwA/rcs9w +AADUFIojhQeKJMEKyQEv+kolAAAEFAAxQCSBMAHaxgigAEhzj+gEFAUxCiHAD+tyz3AAANQUiiNF +CJ0BL/qKJMEKAhQAMc92gAC4YRt4QSjFAEwlgIwAHkAR1PYKIcAP63LPcAAA1RSKI4UJaQEv+ook +wQod2M92gAC4YQCmuHAAFAAxz3WAANToQC2CAKlxUgigAAHbkOgAFAQxABYFEAohwA/rcs9wAADW +FCkBL/qKIwUMQIYnCnIAANgWJQEQYImGI/8NI7sNC1EAYYkE62K7YakB4OkIgoAA2PkE7/iiwOB4 +8cByDM/4p8E6cHpxGnJac4twz3GAAIxlLg3v+Braz3GAALhhIIEA2IDhuHG6AC4AiiX/H89xgAAM +GwARhACKJv8fyXUC8Ol2TCGAowHaz3GAANToFnlgicIijABEI48A/X93CsED4YlEIwIEJLpEIwYC +QS7GAEQjAQEiuVsIgSEdDFEAgOHMIiGAB/KB4cwiYYAA2gL0AdpPegXwgOIB2sB6NwpRAEwiAKYB +2sIiigCGI/0PJ7sPCYAAgOLMIGGgC/Qyd8wjIYAJ8gPvBesLCcIjDw7CE8l3BPAB2QjwCHUB4GcI +RIEA2Yog/w+E6YDlyiBKA4wg/4/KIIEP/////xXyMiSCNM9xgADU6A8KUQBicRZ5AhHAAAnwFnkL +CpEABhHAAAPwBxHAAKED7/inwPHA8gzP/3TYrgzv/4ohSwp6Ck//FgtABsYPD/8KIcAP63I92Ioj +Cw5KJAAAlQfv+QolAAHxwM9wgABIJAKAwhAABlEgQIAUD8IF0cDgfuB48cD6Cs/4GnAodTpyz3CA +APyyeg4v+kTZz3KgANQLfoIAJYEfAAAAQM9wgABUCmJ5YKDNuc9wgACYzy+iDIDPcqAAyB9k4B6i +ENgOogHYFRoYgE1whiD8A9DgzCCCjwAAgAAS8owgA4QT8gohwA/rcgokgArPcAAAMhGKIxoN9Qbv ++bhzCnDSCC/7KnIE8I4PL/oKcBvoz3GfALj/z3Og/mwDdqEWoc9zgAAczz+DANqc4LO5P6PPcYAA +SKdLqc9xgAB8pEyxyiCBAJECz/jgePHANgrP+M9woADEJ1IQAYZBEACGhiDjjwDdBvLrudEhooFI +8s9wgABIJAOACYDPdoAA/LItCF4B6gnAA4noFI6B4MogIQGADyH/yiFhAM9wgAC4swCADQieAM4K +YAAQlrSuz3CAALizoKBNcIYg/AOMIAKAGvTPcYAANBsAgQHgAKHPcIAASCQDgBiIhOAgDgH/iiBH +DQIL7/+KIcsDOgrAA/INz/oG8IwgA4TwDwH68QHP+PHAfgnP+ADeAt3Pd4AABLBAJwAbhC4IGTAg +QA5RIACARAgi/8ogggNhvekNdZAB5g4IIAAA2LEBz/jgeIDg8cAQ2AryvgkP++oMYAGKIAQA0cDg +fnoID/ueDGABiiAEAL4NgAcNCJEA2g2gBwDY8vHw8eB48cAOCc/4z3aAAJAKAN0L8BDYuHgLIQCA +cAgi/8ogQgMB5fEN9JAghoDhyiAhAAQNoQLKIQEARQHP+OB48cDhxc91gACICRCFn+hiDYAHguB8 +DaEHyiAhAAHYEKX+D+/6Edg+CGAAENgRpQno7g/v+hDYEgxgAYogBADPcAAA6OLiDW//gNn9AM/4 +4HjxwIIIz/jPdoAAiAnPdYAAKCsDhvAlABBAeH3o0QDP+PHAz3GAAEgrAIETCIEPAIAAACoNj/zR +wOB+AIEhCIEPAEAAAM9wgADsIiSAIIGWCe//iiBMDC4Mj/zv8e3x4HgB2s9xgADEKkOpGKEocGTZ +ddoe22kEIAYYu+B48cDPcYAAiAkDoX4IL/sR2KYLYAGKIAgA0cDgfvHA6g+v+AHaocHPcYAAwCpA +oVsIUQDPdYAA9LEahYwgw48K8gDahCgICQAhgX+AADSwQKnPdoAAiAkMhgbojg/v/wuGANgMpv/Y +GqXWDCAHi3AN6AILwAMAwc9wgAC8KiCgCgtgBwDYEfDODu/6EdjmCsAD6gpgAYogCAAKDIAHguAo +DKEHyiAhAM0Hr/ihwPHAz3AAACBOkgwACc9xgABEKwChz3EAALgLz3CAALAqIKDPcAAAiBNyDAAJ +z3GAALQqAKHPcA8AQEJiDAAJz3GAALgqAKEF2FIMIAkLuM9xgABILwCh0cDgfuB44cXhxkEtAFTB +uBcIFQEzJgBwgABMZEAngXIUeQB5ANgX8M9xgAAcz5gRgABAKAIGhiD9D1IgwAFFuEV4z3KgAIgk +EKIfgbO4H6FK8AHYENvPcaAAyBxpoc9zgAAcz5gTjQAA2s92gACscMaGQC0BFoYl/R9SJc0RxXlF +vaV5z3WgAIgkMKU/gwLdRCg+DQAhgH+AAAjZlbk/o89xoADwF72hpICKEwMBpqGjgBTjpqGigFMj +w4CmoaGApqHAICEIwCAiDGCAc6FsaGCDc6H4EAOCc6H8EACAE6FKocHG4H/BxeB48cDhxaHBCHXP +cNS6/spAwATwkghgCQHYz3GfALj/uqEE2Buhi3AeoQDanbrPcKAA0BtRoM9wAG0AEBmhBPAyCa// +MNj7CV7HiiCbBS4Pr/+pcYogmwUmD6//AMEAwLcIgI/Uuv7KKQav+KHAANvPcp8AuP8aonuiPqLP +cABsBAAZouB+8cCWDa/4mHAodhoIIABIdQYggQOIcE4IIACleeUFj/jPcYAAZC9gic9ynwC4/wbr +z3HQuv7KPqIaog7rz3CgADguBYAEIIAPwAAAAPEIgI/AAAAAatgYuBmiHILgfuB44cXPcoAAZC+g +is9ynwC4/wXtz3PQuv7KfqIaojuiDu3PcKAAOC4FgAQggA/AAAAA8QiAj8AAAABp2Bi4GaLgf8HF +4Hjhxc91oP7oAwDaz3OfALj/tqOA4cokTXDoIC0D8CCBADaj4HjgeOB44HjgeOB4AeLgf8HF8cC6 +DI/4CHfPcqD+uATPcJ8AuP9WoCcJdAAA3Sh2Lg/v/xUnQBPgeOB44HjgeOB44HhhvusOdZAB5ekE +j/jgePHAegyP+Ah3z3Kg/oAEz3CfALj/VqAnCXQAAN0odu4O7//wJ0AT4HjgeOB44HjgeOB4Yb7r +DnWQAeWpBI/44Hjhxc91oP4gBADaz3OfALj/tqOA4cokTXDoIC0D8CCBACCB4HjgeOB44HjgeOB4 +AeLgf8HF8cAGDK/4iiAKBut1Xg2v/4ohRA+KIAoGUg2v/6lxz3aAADgeAIY3CF8Az3WAAOAiAIVS +IIAAAKUI8M9woACoIA2A5OAYAQUATg7v/1TYABUEEIYg/w7nCAGBiiAKBg4Nr/+KIUUDz3eAAEQs +mBcAln0IngB+CQ//z3WAAEgkyRUAFqW4yR0YEJMXAJaluJMfGJDXFQAWpbjXHRgQDoWluA6lAIXI +EAAGhiB/jsogIgDKIQIAiAwi+coiogEBhcgQAAaGIH+OyiBiAMohIgBwDCL5yiKiAQCFz3GAACDN +xBAABiW4wLimDK/8CqGKIAoGegyv/4ohRQkmDA/+f9gKuM9xoADQGxOhf9gQoQDYlbgQoc9xAABY +ICoKIAAG2M9xoADwNgSBRiDAAQShlNiqDe//GNmKIAoGMgyv/yCGAIZRIECAWAoiAcogIgCKIAoG +Ggyv/4ohBgAVA4/4CiHAD+ty29gEuIojBQINB6/5SiUAAOB48cCWCq/4iiBKBu4Lr/+KIYYCLgrg +BwHYz3ClAAgMAN3PdoAAlCqioASGUSCAgCwOgvnPcQAAOAqWCSAABtgLyAUggA8BAAD8CxoYMASG +IwieAM9wgABkPACAi+j6CG//iiDGCAsIUQB6DgAFDPAA2Z65z3CgAPxEIaDgeKGgMgogBgDYNgyP +/FIKAAGmDeAGAdhSCe/6AdhpAo/48cD2CY/4iHUA3wroGQhRAAHez3CAABAbwKgG8M9wgAAQG+Co +CekbCVEAAdnPcIAADRsgqAXwz3CAAA0b4KgK6hkKUQAB2c9wgAAPGyCoBvDPcIAADxvgqM92oADI +H89wgAAQGxge2JMAiIohEAAR6M9wgACFIwCIC+jPcAMAQA1FHhgQMKYC2BgeGJAC8DGmz3CAAA0b +AIgb6M9wgACGIwCIF+jPcAIArB8gHhiQz3CAACgAIR4YkM9wgACkCCIeGJAYFgCWRSAAAxgeGJDP +cIAADxsAiAjoGBYAloUgAQQYHhiQDwtRABgWAJaIuBgeGJAYFgCWgLgYHhiQGO0A2JS4z3WAAKgL +AKVx2Aa4ugvv//zZIIXPcAAATByqC+//n7kYFgCWhbgYHhiQMQGP+PHAmHAD6SMMEgjPcIAALAkA +EAUACiHAD+tyz3AAANoOFQWv+Xnbz3CAAGwvFSAAASCg0cDgfuB4ANlKJIBxz3OAAMCZKHKoIMAB +8COAAAHiBXngfy8oQQDhxQDaSiSAcc91gADAmUhzqCCAAfAlwRAB4yV6ANmeuRl5BCGAAEIgAIDK +IGIA4H/BxeB48cCKIMkDmgmv/4ohzAfPcaAAyB+kEQIAz3CAADg4AIA1gc9zgACYpJYgQQ8QcgDa +yiJvAAGD1bmB4AHYAvIAgw0IUQANCYQPAACIEwDYA/AB2IHizCBigDAPofrKIOEB0cDgfgLhMHlB +aQ0KAwAieBB4A/AC2M9xoADIHx6hENgOoQHYFRkYgOB+4HjxwOHFUN0A2s9zoADIH6+jXqMCIEIA +XqMB2hUbmIBA2k6jBCC+zwACABCwD8H/+QdP+OB4ANnPcIAAuLMhoM9wgAAczxyQYrhIIEAAEHnP +cqAAyB8fghB4CCEBADB5AtgVGhiAP6LgfgLhMHlBaQ0KAwAieBB4A/AC2M9xoADIHx+hiiAYCA6h +AtgVGRiA4H4A2c9wgAC4syCgIaDgfyKg4cXhxs9xgAD44kWBJOjPcaAAyB9AEQ4Gz3OAABzPQCiN +AkITAAF8k9B+2GC7Y2K7CCMDAAJ7CSLCAALYFRkYgM9wgABIJF+hA4AigM9wgAC4syKgwcbgf8HF +4HjgfwDY4cT8HMi+/BxIvuHA4cHhwuHD/BwIsfwcSLH8HIix/BzIsfwcCLL8HEiy/ByIsvwcyLLh +xeHG4cf8HAi0/BxItPwciLT8HMi0/BwIv2okgBDhxGokwBDhxPHAz3WgAMgfGRUSlnvYrg9v/4oh +BAPPdp8AuP/9hgohwCdA2Z+5PabPcaD+HAA2plMmwDQFIIAPsP4AABamz3AAAEQcogjv/wogwC96 +cBkVAJYjCB4CWB6AFyEVAJYiFQCWz3GAAKALAIEWpgGBFqb9pgfYcgjv/wq4UyBBBwfYpgjv/wq4 +z3CgANQLGIBCIAAISCAAAM91gAC0PbwdGBDPcIAAqAsAgAsgwITKJiITyiBiAF/0gwqRIG/YKgjv +/wa4z3AAANAbHgjP/89wAADUGxYIz//PcAAA2BsKCM//B9gGCO//CrjPcAAABBz6D4//z3AAAAgc +7g+P/89wAAAMHOYPj//PcAAAEBzaD4//z3AAAEQc0g+P/xsLniW8FQAWiehBK04lwL4DvlzmAdgh +8DTeHvCMIgSgGfJMIgCiEfII9hsKUCAnChEhht4S8BcKECSMIgGgC/RM3grwZt4I8DzeBvBG3gTw +VN4C8ITeANiB4CQKwQSTFQMWyXAKcSpyCiSABEEBr/kKJcAE4HjgfuB44H8B2M9ygACICSKCJYkS +6c9xgAD0sXqBz3GAADCwhCsICTAhQQ4NCV8ACNgLogHYCaIA2ASiBdgDouB+8cDhxQh1KHAF689x +gAAAkATwz3GAAAB4W3oyDW/4tHndBG/4AdjgeM9wgACCCQCQBugA2c9wpAAcQDKg4H7geM9wgACC +CQCQBugD2c9wpAAcQDKg4H7geOB+4HjPcQEAxwPPcKAA7CcmoOB+8cAWDE/4GnCiDq//JNiYcFEg +AIDKIcEPyiLBB8oggQ8AAFEmyiOBDwAAKQFcAKH5yiUBBM9xoACsLxiBkQgRIA8IngbPcIAA+C8A +gEB49NgA2ToOr/8B2jTYANmRuS4Or/8A2jDYiiEGACIOr/8A2jTYANkD2hYOr/8Uui4Or/8w2MK4 +CQhRAADYCPAE3T/Y7gxv/6lxqXDPcgEAxgPPcaAA7CdGoc9zoAC0DzyDJOkBEgQ2cBMFAAohwA/r +cs9wAABSJsUHb/mKI0UGmrgYodYN4AiKIA8Kz3CAAPgvAIBAeMYN4AgB2PYJL/+KIAUDhOgE2IUD +T/hE2c9woADIHCmgpg3gCAHY6gyAAb7x4HjxwAYLT/iiwSh2CiSAgADfz3WgACwgQBUQEAAcxDMT +8oMMUABMJICAjvIKIcAP63LPcAAAVCaKI0QFQQdv+QolAAQyaAQhgQ8AAPz/jg2v/yzYEIUCIAAE +jCAPigj3Pg2v/yzYCHfvCB6ACPAghoC5IKb+C2//P9giDa//NNgfCF4FIIaBuSCm5gtv/z/YNNgA +2QDa5gyv/5W6ML8CHMQzhfAPeRC5BSGCDwAAgv3PcaAA7CdGoQQggA8AAAAfSLiGuBC4BSCADwAA +Qv0GoRCFAiAABIwgD4oL94tx8ghv+YogDw0AFAAx5wgegAfwIIaAuSCmegtv/z/YgcHSCG/5iiBP +DAQUADERCJ4AIIaBuSCmXgtv/z/Yi3WKII8Psghv+alxIMAIuAIcBDCKIM8Pnghv+alxIMECFAAx +JXgCHAQwNfDPcQMAQv7Pd6AA7Ccmp89xBAAC/ianhrgQeBC4BSCADwAAQv0GpxCFAiAABIwgD4oL +94txVghv+YogTw8AFAAx5wgegQfwIIaAuSCm3gpv/z/Yz3AGAAL/BqdAJIEwLghv+Yogzw5A2MIK +b/8CFAExAhQAMbEBb/iiwOB44H7geOB+4HjxwOHFCHWKIBQNngpv/6lxANjPcacAiEmB5cog4QAO +oZkBT/jxwCIJT/jPdYAANDCgjQDewKOb7YHgzCEhgBfyCwoTCMCjANgJ8MDiBtgG9kIiAAhDuALg +AKNQeRC5EH2KIJQNQgpv/6V5SQFP+OB4uHBA3AAhAIPxwA4AJACYcYwgAoCL9gohwA/rcs9wAADJ +FCEFb/mKI8gPz3CAAJxn9CAAAc9xgACcaAQofgEvcPUhAQFCKAMEwbtSuAQpfgEvcUIpAgTBulK5 +gePAIGkAgeLAIWkAiCA+AIkgwQ+IIT4AiSHBD4Dg1iArCIDh1iErCLYJAADRwOB+4HjxwDYIT/ih +wTpxAN+A4MohwQ/KIsEHyiCBDwAAyhTKI4EPAADTAsokwQCMBGH5yiXBA89xgAA4MECxz3GAADow +4LFMIQCgyiXOE2QALgDKJs4TGndadwXwyXcadWpwQCBTAItxAdpeC+//ANsAFA0xLyPIJKl2Kb3I +vr/l2SUpFEwiAKDKIMIDyiGCA8oiAgTMDSIAyiNCA8lw3g7v/6lxQiFRILUJdaBAIlIgyXBiCSAA +qXHZBy/4ocDgePHAeg8P+Hpwz3CAADQwAIgacdcIEQDPcYAASAqliQSJHWVydcohzA/KIswHyiCM +DwAAyxTKI4wPAAA4A8okzAS4A2z5yiVMAwDdAN4o8ADZz3CAADUwIKhKcIrZ6g7v/ypyz3CAADUw +AIhTJcEQGLnDuBy4BXnPeBC4BXmKIFQNbghv/+V5LyGIBBC5iiBUDV4Ib/8FIUEEAebPfgAggS+A +AEgKJokBaTcOAxBAK4IgVHq1etR6z3OAAES2V2MSbWzvQCeSEC8iiCTUeM9ygAA4tjQiEQB7CRGA +Adm68QHlr31rDdKQ7QYP+OB48cCeDg/4z3OAADowQJNTIk2AIPJHDZEQz3WAAEgKCa0orSKFz3aA +ADgwAJYp3RK9z3eAADUwFSUMECCk4I8H71YgDwjwf/V9IKUB4AC2B/DPdYAASAoLrSqtAeKpBi/4 +QLPgePHANg4P+Ah2GnHPdYAAOjDglQvwzH/iDy/4QClAcUW4Sg3v/wpxIJWMIRCAtPZtBg/44Hjx +wPYND/gIds9wgAA0MACIenGA4KHBGnKC9M9xgABICqWJBIkdZXJ1yiHMD8oizAfKIIwPAADMFMoj +jA8AAIUDyiTMBDACbPnKJUwDAN8A3R/wARSAMAEeEhAGEYEgARSAMITpAR4SECDAAxSCMAEUgTAY +uBS6BXoCFIAwELgFeooglA3mDi//RXkB5a99z3GAAEgKACEABAaIAeB5DSMQACERBEArgCAUePV4 +tHjPcYAARLY0IRIAUyfAEBi4r3kQuQV5iiCUDaIOL/8FIYEEANkzChAgi3FKcALapgjv/wDbcwgR +gAohwA/rcs9wAADNFIojjgYKJIAEfQFv+UolgAABHlIQBhGAIIMIEYABHlIQvfEB5+9/Nw/SkDEF +L/ihwOB4ANtgqREIcgBgqg0I0wNgqeB/YKoPCJIIwOAF9gHYAKkR8OTghvaMIAKDyiCsAMn2jCBC +hIn2jCBCiQf2A9gAqQHY4H8AquB+8cCODA/4o8FKIQAgi3EqcEogACEKcgII7/8qc47oCiHAD+ty +U9gGuIojBQEKJEAE2QBv+QolAAQgwhUKEgAAwEEoAQJTIcQAEwwSAQHZz3CAADQwVQIgACCoz3GA +AEgKQKkCGQIBQSgOA1MmxRADGUIBTCXAgMoiyQfKIIkPAADCFMojiQ8AAFgBgABp+cohyQ9BKAIE +UyLGAAQZggFBKAIFUyLFAAUZQgFMJkCAzCXsgMohyQ/KIskHyiCJDwAAwxTKI4kPAABeAUAAafnK +JIkBQSgCBlMixAAGGQIBQSgFBwcZQgFMJECAzCVsgMoiyQfKIIkPAADEFMojiQ8AAGQBCABp+coh +yQ8EFIUwjCUBhLQALAABGUIBCiHAD+tyz3AAAMUUiiNFCuEHL/mYc891gABEtgDfA/AB5+9/QSgB +AsO5bQ9DEADeE/BAKYEgNHkKFIAwFSFBAQHmz34UeblhABkEBIAgAiMvIAgkAMBBKAEGw7kB4cMO +Q5CCwQpwAtqWDq//ANsLFIQwLygBAU4ghQcvJUcBtQ3SgAohwA/rcs9wAADGFGEHL/mKI0YCQCFR +IC8hRyRBKAEEw7l7CUKgBPBtDlOAQSgBBcO5CnWpCXIASiAAIEoiACAF8EAiUiAvIockQSgBA8O5 +ewpDIEohACAU8AK+1H4KFIAwFSZOEUAhUSAvIUckFH4AJoAfgABEtqCwgCUCE7B9AMBBKAEHAeG7 +CUOgMLjDuAAgDgSCwalwAtriDa//ANsLFIQwLygBAU4ghQcvJUcBqw3ygM9+CiHAD+tyz3AAAMcU +rQYv+YojhghAIFAgLyAHJEEoAQXDuWUIQqDT2Qi5ANgD3s9ygAA4tgDbsmh0fV1lILUB4297ViEB +CPELsoAweWG+AeDnDnWQD3hBAi/4o8DgePHAygkP+KLBQMBBwkAoFAVAKRcFAN1AKhMFQCsSBQHe +SiWAIal3BPAKdcp3AMAVuBN4FCDABXILL/gH2QIgUAMCIEAjYgsv+A7ZzH4KIUAuBCk+cC9wrH4A +IQ11HWUBwBW4E3gUIIAEPgsv+AfZAiDWAwImwCMyCy/4DtkEKH4EL3HsfgAhwHQZYUItABWOCO// +VLlCJVUgAeaRDXWgz35xAS/4osDgePHAJgkP+Ah2unHPcIAAHM8AkADZSiNAIEoiQCCGIPwAjCAC +gMIjwiRKIIAgz3CAAEinK6iacc9woADQDyUQD4YlEA2GYr4QEBGGKw5kE0AkVCCifhJ2yiAuIM4N +b/jpcJhwANgpCxAgFQ9QEQ0P0BIH8EomACAx8AHYA/AC2M9xgAAYGySBCyEAgATyANoD8AHaACBA +I4YLb/kqcQomAKAb8icMEALPcIAAPCMWIAABQIAGiD0PARAc6qlwYHqqcQoiAKAJ8iJ1z3CgANAP +EBhYg2cIEaDPcaD+YALPcp8AuP9MJgCgzCIioBLyANgT8AohwA/rcs9wAAAxEYojFwtKJAAArQQv ++QolAAEocBaiE9g44TaiEL4FJgEVNqJVAA/44HjxwOHFz3CAAAgyCBAEAEwkAIDKIcEPyiLBB8og +gQ8AAGkZyiOBDwAA0AFkBCH5yiUBAc9ypQAIDAgSBQAA2UwlAIDMJSKEyiHCD8oiwgfKIIIPAAB9 +Gcojgg8AANcBMAQi+cokIgBA2AKiz3CAAJS/YIAK8PQgTQDPcKYAAIA1eAHhoKDS4YQrAgoAJEAO +tPekEAMBz3GkAKA/faGmEAABHqEIGkAB8QfP9+B48cCCJAMyi3DPcYAAwGQqCC/4yNpKJEB2ANmo +IEADFiRAMGGAQJAr2BK4AeFVeGCgMHmAJAMy0cDgfuB48cDWDCAAR9gA2s9xqwCg/1mhB9gaoVih +0cDgfuB+4HjgfuB48cDPcYAACDI4gYDhXAwCANHA4H7xwM9xgAAIMj2BgOHQDQIA0cDgfokHwAeF +B8AHgQfABwDZz3CAAJS/IaC5AyACIqDxwOHFz3WAAJS/Ng0gAqlwuHAAhRLoSiSAc89zgAAcMADZ +qCDAAkCDRCm+AzIiQg4/CkABAeER8ADZSiSAec9ygACsbaggQAJEKb4DMiJDDh8LQAEB4QohwA/r +cs9wAACGGYojRAHZAi/5SiQAANkG7/cocM9wgACUv0CAI4AM6s9wgAAcMACARCm+Aw3gMiBADgnw +z3CAALltRCm+AzIgQA7gfs9wAAABP89xqgDwQwWhz3AAAD49BqHPcgAAPT1HoYogzA8IoQnYjLgJ +oc9wAAAWHAqhz3AAAB8fC6HPcAAAHBYMoZHYBLgNoc9wAAADPw6hT6HPcAAAPT4QoYogxA8RoeB+ +4HjxwMINz/cmCmACAN1aCyAAB9hGDu//GnDPdqQAuD2sFgAWz3elANjLOdmiuKweGBCsp89wFQAr +K/YeWBOaHhgQiiDEAJ8eGBAa2PMeGBD0HhgQZNjIHhgQqtjJHhgQadjMHhgQwNjNHhgQz3ClAAgM +PqAuD8//HgogAApwGNiVHhgQz3GAAKQioaHI2AKhAKEDoc9xAQAwyM9wgAC0HNQYQACU2AunQdnP +cKUAzH8toM9wpAAMgKKgbQXP9/HAGggAAEIPz/8ODAAACgiP+tHA4H7gePHA5gzP989wgABAzEAg +EgYIcc9wgABUCSCgAN7EqATfRC4+FwohQC4AIYB/gABAzEoIb/kc2YQuChIAIY1/gACwv6lwNghv ++YohCgKELgIXACGAf4AA0MkacCIIb/mc2QAhkSQAGUAjYb+hHRgUtQ91kAHmzQTP9/HAagzP9wh3 +WnE6chpzCiMAIYomGxjJcMYN7/7pcUQvPhcAIY1/gABAzMlwsg3v/iGNyXCqDe/+II3JcKIN7/4i +jclwmg3v/iON8K0B2BGtAR2CFAAdQhQCHQIUAx3CFBIdAhQTHcIUXgkgAOlwVQTP9+B48cD+C+/3 +RCg+BxpwOnHPcYAAQMwvcBphUYobYR8KUAAKIcAP63LPcAAAsihe24okww9FAC/5CiUABBUI0CDP +coAAVAkEGgIEOGAAogGLIItSi+IJIABzixoJQAEKcFILIAAqcfkDz/fxwOHFCHW2C2AFANhCDs/7 +RNnPcKAAyBwpoG4IL/gc2M9woACsLxiAFQifBoogEQPSDO/+S9myCiACqXD/2c9wqwCg/zmgOKAm +DCABqXDJA8/34HjxwOHFEgzv/wh1rg9gAqlwsQPP989xoADIHAihFQAv+AbY4HjxwCYLz/eiwaKB +YJDPdoAA6Am4e6OBZH1ghqV7poEBkLh4p4FgpqR4oYZAIQ8EpXgBph3qAYECHMQwMLsEHMQwABwE +MCCBi3VgealwAYchhgIcRDAwuQQcRDAghwAcBDBgealwANgApgGmJQPv96LA4H7geOB+4HjgfuB4 +4H7gePHA4cXPcIAAFDAggAHdYHmpcOe4J7hSIAAAyiUiEMohQgPKIeEBwLgTeMK4z3KnABRIC6Is +os9wqgDgB7Og4QLP9+B48cDhxc9xoADIHKiBCKE+D+/3BtjFAu/3qXDgePHASgrP9wh2z3WAAJS/ +AKUhpVitZgvv/3mt1gvv/wOlBKUG8HoNr/6KIIkMz3CgAHhFAIAEIIAPcAAAAEEoPoUA3fL1Hgpg +Balwz3GrAKD/uaEH2BqhuKH2CEACgOYB2MB4DOAOCy/6AdlNAs/34HjxwMoJz/cId891gACUvxiN +SHYacTpzEwoBAIXuGY0LCEEEANgC8AHYLyIHIOlwKg4gAslxIIUA2A8PQRAhhRJxzCIhoALyAdgv +JgfwGq0r8oogWwjmCu/+6XGKIFsI3grv/gpxiiBbCNIK7/7JcYogWwjKCu/+KnHpcApxyXIWD+// +KnP+CMACAYXPcYAAgAkAsQCFAbEYjQSpSgjgAipwCPCA5wHYwHgM4FoKL/oB2XUBz/fxwAhzANkC +2oQrCgIAIYB/gACwv4QpBA8E4AILYAUncGG66Qp1gAHh0cDgfvHAz3CAABjldgwv+YohCQzPcIAA +aCdqDC/5FNnPcIAAjCpeDC/5FNnRwOB+8cC2CM/3osE6cBpxAN1eDu//B9iacALZqXBacHpxANs0 +aAJxKHUUIQAgaHLChQQQDwXYf8OFAeLEf+V78Qr0gCDlAYECHMQwMLsAHAQwIIEEHMQwYHmLcEIj +QSC/CXWAQCJAIDIN7/+KcKEA7/eiwPHATgjP9zpwWnHPd4AA/DwMj892gACUv6WGhiD/AUO4DiUN +kM9wgAAEMCCAyiViEGB5BNgg6BqOgODMJSGQHPIA2BDdGnACuBV4x3CAAIwxIIAG6SKAFelgeSpw +Yb3pDXWQQCBAIADYGq4Mj4Yg/wFDuAWmQg0v+EpwMQDP9wohwA/rcs9wAABlGTfbCiQABDkE7/i4 +c+B48cDhxQh1IJAClUGVELgFeinYErgVIEEAQKEglfAgQQAdCkAAAgnv/oog0QMClSGVELgFefII +7/6KINED/QeP9/HA4cXPdYAAsMwghRvp2gjv/oogSgwAhQfoz3GAANzMAKEIhQihANgApQSlpg7v ++QnYog7v+QPYz3CAAKxbKg1ABs9wgACwNPYI4AADgIogCgOWCO/+iiEPAgDZz3CAAHA4mQev9y+o +QQLP+fHA4cWKIMkDcgjv/oohDgc+CeACAN3PcIAAdFveDEAGz3CAAJBb1gxABs9wgACsW8oMQAaK +IMoBQgjv/oohzgjPcIAAsDSioB4O7/kD2M9wgAA4OKOgOQev96Gg8cDhxc9xoACsLxyBvYEEfc9w +gACEIwCIEwhRAM9wwN8BAByhKNkYuRvwiiDJA/IPr/6KIU8JiiCJA+YPr/6pcRUNHheKIIoF1g+v +/oohDwtuCsAC9r2gD8L5ANmbuc9woADQGzGgzQaP9+B48cAiCAAAjglAANHA4H7geM9wgACwNACA +geAB2OB/wHjxwDIOj/fPcIAAIM3HgMC+geYB3s9xgAAcOgCBwH5bCF8AgbgAoc91oADALxOFDQie +BhOFurgTpQLYEaXPcIAABDAggGB5ANgZCBECbghgCArYC/DPcKAAqCANgOTgj/cQhfUIHoCCCu// +yXAVFQCWgLgVHRiQKQaP91wVBBBAFQUQCiHAD+tyiiBMCREC7/iKI4YN8cCODY/3CHXPdqAAwC8a +hjm4UiAAAFMgEQAUhhEI3wAKCC//JNjyuADfA/IB31EWAJaL6KMWAJYEIIAPAAAAD4wgEIAD9ADY +AvAB2BpwBCGSTwAEAADPcAAACBzOD8/+P7hSIAMABCCATwIAAADXcAIAAAAB2sB6DHCGID0AgOAB +2cB5EwieQc9wgAB8CgCAgeAA2AL0AdgB3uW9yiGBI0MJECDmvconYRAd7+O9yiJhIDMKECDkvcoj +YQAT6+K9yiBhIB8IECDhvcoiYQAL6uC9yiFhAAfpUSXAkcogYQCD6ADYAvAB2AEFr/cPeOB48cCu +DI/3p8EIds9wgACwZSCAAYBFwUbAiiDKAfINr/4taM9wgACwNAKARMYM2RUkAjDPcKAALCCwgM9w +AQCYJEDAAdhBwELAENhDwEWCANgIc5hwuHAAJYcfAAAAfWIKL/3YcLUEr/enwOB48cCiDg/+z3Kg +AMAvANmIGkAAE4KLuBOiz3CAAAgaAZAQuEUgAA/AGgAAz3CAAMQ3Ng+v+SCg0cDgfuB48cAGDK/3 +ANmbuc9woADQGzGgHgjgAADeJejPcIAA4BgxgM91gADMIgzpz3CfALj/PaAkhQHhs7m1ubi5JKU2 +oM9wgAB8CiCAz3CAAPA38CBAAEB4AIUPCF4Ez3CfALj/3aARBI/34HjxwJYLr/dU2Rpwz3aAACDN +p4bAvYHlAd3AfeYMr/6KIMkDiiBJB9oMr/4Kcc9wgABIJACAxBAABjkIXgHPcIAACBoBkM9xgACA +CuCBPOAZZ2ThIQkEBAohwA/rch9niiDMCFrbCiQABKEHr/hVJ0UWB4YA3x8I0QDPcIAACBohkM9w +gACACgCAPOE4YGTgAiAQIAvIBCCAD/7//wMLGhgwC8iHuAsaGDBWD6//qXDPcZ8AuP9dgc9wgAAw +CUCg/aEc2Rfwz3CgAMg7NoBWgIYh/wiGIv8IRXlWgIYi/whFec9yoACoIE2C5OJKAAUA7OneDoAA +z3agAMAvURYAloboDHSEJMKfJPIXhkUIXwbPcIAAOB4AgDkIXwAKIcAP63IKJAAIURYFloogTAjd +Bq/4f9s4EAQAWBAFAAohwA/rcs9wAACZIcUGr/gv21ENURCKIMkDqguv/ofZEIY1CB8Az3WAAAww +IIVgeQHYDwhRASCFYHkC2B0IkABAFgQQCiHAD+tyiiCMCI3bgQav+LhziiAQARGmEIb/CB+AFIar +uBSmz3CAADgeAICC4BLYwCgiBsogIQDPIGEGGabPcaAAyB8YEQCGobgYGRiAiiAQABGhCdgIuA+h +E4apuBOmz3CAACDNB4CD4Mwg4oEG9EAogCCfuIgeABBiCkAGz3CAABw6+QGv9+Cg8cANCVEAQg0A +AATw/gwAANHA4H7xwK4NoADhxfoJ7/ka2M9wgADINwCQz3KAAAjNUiABAMC5AeEgqgDZFwhfAM91 +gAA4OGqFCwtQAGuFgeMC9AHZI6pBKIECwLk0qim4wLjPcYAAsDShAa/3AKHgePHAHgmv94ogiQrP +dqAAwC+3hvqGiBYQEG4Kr/7o2YogiQpmCq/+qXGKIIkKWgqv/ulxiiCJClIKr/4KcTCGSgqv/oog +iQozhj4Kr/6KIIkKB9jPd6AAyB8ZHxiQAdgIcQhyCHPKDu/+mHBKC+/+VNgVCB8Bz3CAADAJIIDP +cJ8AuP89oIAWDRAive4PIAapcIogiQryCa/+qXHPcYAAKD8SgbhgEqEA2IgeABAJ2Ai4DqfRAI/3 +4HjxwG4Ir/cA2c91nwC4/12Fz3aAADAJQKY9pRzZFfDPc6AAyDs2g0QhAgc2g4Yh/wglejaDhiH/ +CEV5z3KgAKggTYLk4of37emKCs//kOgA2C3wOBMEAFgTBQAKIcAP63LPcAAAmSF1BK/4L9sAhh2l +pg+gBgDYiiAJBVYJr/6KIUwGz3GAAHwKIIGKIEwGDgigAAPakgmgAAPY3g5P/AjYSg0gAIoh/w8B +2DEAj/fgePHAz3CAAHwKAIATCNEA7gjP/F4Jz//eCEAA0cDgfuB48cCSD2/3ltkacPYIr/6KIAoD +AN0KIYAvgABoOAXfz3aAAMg3tX4DhhUhTCMApBUIUSCKIAoDygiv/pzZAdgDpmG/AeXbD3WQr30B +2c9wgAA4OKEHb/dEGEIA4HjPcIAAsMwB2SSoJajPcYAAyDcAkYYgGACouACx2tgDqc9wAABQwwGh +z3ABAKCG2QdgAAKh8cDhxc91gABwOA6NocF9CFEAiiAKA1oIr/7J2S+NLwkzAYogCgNKCK/+zdkP +jYroiiAKAzoIr/7R2ToP7/8B2A+NAeAPeA+tIPAmCK/+2tkA2A2tDq0+CCAAD61yD8//ANgCCu// +jLjPcK0LvrpAwItwBNl92j3b8grgBBe7iiAKA+4Pb/7x2fkGb/ehwOB48cDhxYogCgPWD2/+r9nP +coAAODhEEoAAQCIDDCcIUQBKJEBxANmoIAAD8CNNAM9wgADUNzV4AeGgoC95ANhEGgIAsQZP9+B4 +ANrPcYAAcDhPqQHYDalOqUypUKlRqVKpU6lUqYogCgN1B2/+h9ngePHACg5v9wHaz3GAAEgkY4F4 +izkLEQEAgc9xgACwNMQQAAYluFIgAAAhgcC4AdqA4c9xgAD44iaBwHqA4cwgIYDMIiKAfPKA8BEI +HgDPcIAACM0AiAkIUQCYcgTwSiQAAM9woAAsIHCAz3aAADg4RYamhgIjgIAA2soibwACI0+DAN3K +JW8QFw4FcABAAAAH6gIjgA9OAAEgBaYXDsVzAEAAAAftAiOAD04AASAGpgGGFujPd4AAyDcAhuGH +H2cRDwUQGQ/FEBELBAAI8AkLBAAJD8UQANgD8AHYAaYggcQRAwZBK0EBUSEAgMomYRAG8imGg+Fv +JgsQz3GAALA0IYHPd4AA+OLmh4DhAdnAeYDgAdjAeIYnfx6G59EjYoEA2wL0AduA5cwiIoDMIyKA +zCAigMwhIoDMJiKQBPQA2AXw/QwQgAHYLQVP9+B48cCKINAHHg5v/oohRgC6CIACz3CAAJQqBIBR +IICA4AzC/QnZCLnPcKAAsB80oNHA4H7gePHA4cUIdYogyQPmDW/+iiHFBYogiQPaDW/+qXHPcYAA +sDQBgaZ4AaEA2c9wgAAgzTCgJYDNBG/3MaDgePHAUgxP96HBCHaKIIkHpg1v/slxz3GAAHwKiiCJ +B5YNb/4ggc91gACwNAGFz3GAACDNBX4QgcGlhegB2BChBYERoXYJr/2LcADBz3ABACwWGQhAAM9w +AQCYJBEJAADPcAEAbDMLCQEAjgjv/AHYAN7PcIAAODjBoCYLr/kH2CILr/kI2AIOQALPcIAAdFum +CQAGz3CAAJBbmgkABs9wgABIJACAxBAABhcIXgGKIEoCAg1v/hx5mg8gAMlwBPBODWAAA4X5A2/3 +ocDgePHAhgtv97hwcg3v/yhwgOAA2cogQQAn8s92nwC4/x2Gz3WAADAJAKU9phzZFfDPcKAAyDs2 +gFaAhiH/CIYi/whFeVaAhiL/CEV5z3KgAKggTYLk4on37emSDa//qHAghT2mkQNP9zgQBABYEAUA +CiHAD+tyz3AAAJkheQdv+C/b8cDPcIAA2LIIgGkI3wHPcYAAyDdCgSGBz3CAABw4QKDPcIAAODgn +oIogyQM6DG/+iiHFD4ogyQQuDG/+iiFGAM9xgAB8CiCBiiBGAOYKYAAC2m4MYAAC2IogyQMKDG/+ +iiHGAOIKIAUC2OIKT/kI8M9wgACwNEoMYAADgNHA4H7xwH4KT/cIdSh2iiBJB9oLb/6KIQYHPw3R +EM9wgAAIGgGQz3KAAIAKIII84BlhAYJk4ThgHwiEAwohwA/rcoogjQGKI8YHSiQAAKkGb/gKJQAB +iiBZBZILb/6KIUYIz3CAACDNz3egACwgQBcQEA4OYACnoAoLQAbPcIAA7CIkgCCBZgtv/oogSQfP +daAArC88hVYLb/6KIEkHiiBJB0oLb/7JcfIIb/wB2EIOr//JcAHY7gqgAApxHIUVCF8GGIWIuBil +pg5v96DYCPDPcYAAHDoAgYK4AKGKIEkHCgtv/oohxwB+CM//VgxAANCHrghv/AHYUg4AAIogSQfq +Cm/+iiFHBgoM4Acy2M9wAIIBABylXgxv+QImABQA2IIKoADJcYogGQXCCm/+iiGHCrUBT/fgePHA +4cXPcYAACM0AEYQAIQxzAKXBAxGFABUNUAAKIcAP63KKIA0BmQVv+PHbSwyRAAOJo+gA2ACpiiDJ +CHYKb/742YogCQZuCm/++dnPcYAAfAoggfnYB90mCWAAqXKuCmAAqXDPcIAAsDTSCa//o6DGCY// +cPDPcYAAsMwEiR0IUQAFiRUIUQDPcAAA//9CDe//ANnBCBAAz3GAAEgkAIHEEAAGDQheAQOBGIgz +CBEBiiDJCP4Jb/6KIYQEiiDJBPIJb/6KIcQEz3GAAHwKIIGKIMQEqghgAALaAtg68KYNQAB1CIQP +AAAUBM9wgACwNACADQhRAA4JT/ku6ADZz3CgACwgsIDPcAEALBZAwAHYQcBCwEPBRMEG2QhyANuY +c7hzACWHHwAAAH06Dq/82HOKIIkEfglv/oohBArPcYAAfAoggYogBAo2CGAAAdoB2LoJQABxAG/3 +pcDgeOB+4HjxwO4PD/fPd6AALCDQh89wgAA4OAiApcECJgIQz3CAAAjNz3OAAPjiZYMjgAUrfgA3 +cgHZQIjCIU4AAN0LClAAA4g3CFEAz3CAALA0o6CKIMkDAglv/s7ZiiBJBPYIb/7P2c9xgAB8CiCB +z9iyDyAAANoA2FLwz3KAAEgkAILEEAAGnQheAZkJUQADghiIkQjRAM9wgACwNAGAhQgRAM9wgACg +IgCQgeAB2MB4DLhxCIAPAAAAEIogyQOaCG/+1dnwh89wAQCYJEDAAdhBwELFEdhDwADYjLhEwKlw +DNkB2qlzmHW4dQAnhx8AAAB9Fg2v/Nh1z3CAADg4yKCKIEkGUghv/tjZz3GAAHwKIIHY2A4PIAAI +2gjYkghAADkHL/elwOB48cDhxQDZm7nPcKAA0BsxoIogSgEaCG/+iiEIDc9wgACUKgSAUSCAgIog +SgEM9IohSA7+Dw/+z3CAALA0SghgAAOAUPDqDy/+iiGID6IPD/+KIEoB2g8v/oohiQDPdYAASCRN +hT6VUyIAAD4N4AMB24ogSgG6Dy/+iiFJAwCFxBAABhsIXgEDhRiIEwgQAc9wgAAgzQeAEQjeAIog +SgGKIUkFyfGKIEoBhg8v/oohyQaKIMkEeg8v/oohSQfPcYAAfAoggYogSQcyDiAAAtq6DyAAAtiK +IEoBVg8v/oohiQdhBg/38cDmDQ/3z3KgACwgMILPcIAA7CIEgM92gAA4OACAoIYCIUMD13MAAKAP +AN/L989zgAD44qWD1bhBLYMQYn0LCEQDAYaM6GOG4aYdC1EAiiAKAvoOL/6KIQoJPPAODm/5B9g4 +8M91gACwzACFF+gFhRXoMIICeddxAABQwwHYwiAOACjoWg6P/wSF5aXjpqC4BKWCDi/5ANgc8Abr +BoYCeTEJUgBTIIDBBKYU9IogyQSaDi/+iiFLAs9xgAB8CiCBiiBLAlINIAAC2toOIAAC2H0FD/fx +wBYNL/eKIP8PocEGDSAAQMB7CFEAz3CAAEgkAIDEEAAGJQheAc9wgACgIgCQz3WAAHwKgeAB2MB4 +DLgvCIAPAAAAEIogSQQuDi/+iiFFB89xgAB8CiCBiiBFB+YMIAAA2m4OIAAA2FDwiiCJBQoOL/6K +IUUIIIWKIEUIxgwgAAXaTg4gAAXYQPDPdYAAxDcAhQDeFQhRAIogygraDS/+iiFFCsClMvDPccDf +AQDPcKAArC88oM9wAID//9YI7/8B2STozgzgBItwCiUAkB7yiiDJA6INL/6KIcYAiiAJBZYNL/6K +IcYBz3GAAHwKIIGKIMYBTgwgAAPa1g0gAAPYqXCSCe//AMF5BC/3ocDgePHAuHDPcIAAfAoAEAQA +z3GAAPQzQCyAABR4FSBAAQBhFQiRAgohwA/rcoogzQBFAG/4oNuKDQAA0cDgfuB+4HjxwOHFz3CA +AEgkA4AYiB8IEQEKIcAP63KKIE0BiiOEDUokAAANAG/4uHPOCEAACHXPcAAAv98OCO//ANkLCFEA +jCUQlRz3iiAKC94ML/6KIQUBGgiv/AHYiiBJBMoML/6KIUUCz3GAAHwKIIGKIEUCggsgAADaCg0g +AADYvQMP9+B+4HjxwEILD/dWDAAGiiBKAZYML/6KIYcNz3WAADgeAIXPdqAArC8rCJAAGIYXCJ4G +GoZSIAAACwgeAByGFwgeB4ogSgFiDC/+iiEIAKoMT/8chjcIHgDPcIAAdFsAgEIgAIDKIGIAkejP +coAAyDcJghsIFQHPcYAASCQggcQRAQYLCV4BAeAJojyGGgwv/oogCQuSDA/4JgjP/RkIUAAAhRUI +kADPcIAAfAoAgIPgyAvB//0CD/fxwI4KD/fPcIAAsDQAgC0IUADPdYAAfAoghYDhzCHigcwhIoII +8oog0QAA3o4KIADJcsClZgtP/MECD/cKJACA8cAM8gohwA/rcoogTQKKI44NqQYv+LhzHgtP/y4O +7/8C2M9wAQCYJBoIr/wB2dHA4H7gePHAGgov9wbYXglP+c9wgAAsG0okAAAAGAABz3CAAEgkA4AY +iBcIEQEKIcAP63KKIMwN6ttRBi/4uHPPcIAAtFm6D4AFz3CgACwg0IDPdYAAODgghQImQBARDgJw +AAAgTjoKb/kH2MClz3CAAPjiBoBRIACAJApi+cogIgLeCeAEANgFAg/34HjxwI4JL/eKIMkD6gov +/oohxAPOCG/5CNjPdoAAfAoAhofgzCAiglDyz3WAADg4IYUG6c9xoAAsIDCBIKXPcYAA+OImgYEJ +HgCE4MwgYoEj9M9xgACwNAKBhugAgWkIUAADhTLoiiBKAooKL/6KIcQJiiDKAX4KL/6KIQQKANnP +cIAAsMwpoCqgANheDG//jLga8IDgzCCigRb0A4UA3w3oz3CgACwgEIACpYogyQNGCi/+iiHEDIog +yQM6Ci/+iiGEDeOlIIaH4cwhIoJd8s91gAA4OAGFhOgDhSroz3CAAKAiAJCB4AHYwHgMuEEIgQ8A +AAAQiiBKAvoJL/6KIYUAjgzv/wHYz3CAALA0AIB7CFEAA4WB4KQJIfnKIGEAA4WA4JgJIfnKIKEA +L/CN6c9xgACwzAqBCaEA2Aqhz3CgACwgEIAGoc9wgACgIgCQgeAB2MB4DLgzCIEPAAAAEM9wgACw +NAGAkeiKIMkEhgkv/oohhQYghooghQZGCCAAAtrKCSAAAthxAA/34HjPcoAAODgBggDZhegDgoDg +AvIB2VMggMEEogHawiKBAADYgOHMIiGAAvIB2OB/D3jhxeHGz3WAAMA0wBUDFhML1Q/Sa9R+vmYA +piGmQqYBa8W4wB0YEMHG4H/BxfHA4cWKIAoDAgkv/o3Zz3WAAHA4DY1VCFEAiiAKA+4IL/6Q2c9w +gADINwCQ6bjRIKKCDvSKIAoD0ggv/pXZANgOrQ2t6giv/w+tEPCKIAoDuggv/p3ZAdgOrQ+NQiAA +gK4Pb//KIGIAtQfP9vHAOg/P9roNT//Pc4AAyDcAk89ygAAIzUEogQDAuSGqz3GAAKAiIJGB4QHZ +wHkMuR8JgQ8AAAAQooPPcYAAHDigoaGDz3GAADg4p6E28M9xgACwNKCBKQ1REM92gACwzCSODwlR +ACWOgeEB2QLyANmA4cohgg8AABAnA/Qig892gAAcOCCmKQ1REM91gACwzCSNDwlRACWNgeEB2QLy +ANmA4cohgg8AABAnA/Qhg891gAA4OCelqXHPdaAALCDQheWBAibNEwkN3xfFoeaBAibNEwkN3xfG +oSiDhunPcYAA+OIokSOiJbjAuIIML/kD2bEGz/bxwOHFz3GAAHwKABEEALhwz3KAAIg4QCyAABZ4 +FSBAAQBiFwhRAQohwA/rcoogjQCFAi/4dtsAGUABxQiQAEkIEQHPdYAAsMwghbUJEABeD+/9iiBK +DACFB+jPcYAA3MwAoQiFCKEA2AClBKUqDS/5CdgmDS/5A9jPcIAArFuuC4AFPvAjCFEA2g1gBADY +C8gEIIAP/v//AwsaGDALyIe4CxoYMCzwz3CAAJQqBIAhCJ4Az3CAAGQ8AICK6E4Mr/2Q2A0IUQDS +CYADDvAA2p66ANnPcKAA/ERBoOB4IaCGDWAEKHDPcIAASCQDgBiIDQgRAdoJT/2E6L4IAALBBc/2 +8cBGDc/2z3agAMAvOobPcoAAHDoAgpcIHwCAuACiz3CAACDNB4AB3cC4geDAfQ0JHgcQhgkIHwAA +3wPwAd/vfy/tiiCJCmYO7/2KIcUFMIZaDu/9iiCJChCGIQifAkAWBBBMFgUQCiHAD+tyiiBMCUUB +L/iKI4UGGw9REIogEAERplIPYAcK2DCGIg7v/YogiQqKIBAAEqY6D2AHBdjPcIAAADAggGB5qXAF +Bc/24HjxwIogyQP2De/9iiEGBc9xgACwNECBKQpRAM9zgACwzASLDwhRAAWLgeAB2ALyANiA4Mog +gg8AABAnBvTPcIAAyDcCgM9zgAAcOACjJwpRAM9ygACwzASKDQhRAAWKgeAB2APyANiA4Moggg8A +ABAnBfTPcIAAyDcBgM9ygAA4OAei0g3v/wOB0cDgfvHAz3AAAAgckg4v/qHBHwjeB89woAAsIBCA +BNl82j3bQMCLcEYIYAQXu6HA0cDgfuB+4HjgfwHY4H7gePHA4cXPcQMAQA3PcKAAqCAtoM9xoADA +LxSB8LgUgQzyBCCADwgAAADXcAgAAAAB2MB4B/CGIH8PguAB2MB4wQgRABURAIaguBUZGIAR8M9w +oACoIA2A5ODPdaAArC+O9xyFkQhfBgx0hCTCn0L0yg0v/1rYbehE8IogiQO2DO/9iiHJCc9xoADU +CzuBpgzv/YogiQMscZ4M7/2KIIkDOYWSDO/9iiCJA7YNL/4k2Ahxggzv/YogiQOmDS/+iiAJAwhx +cgzv/YogiQPrdZINL/4k2Lhwz3CgANQLbBAEAIogjQoKIcAPqXJVB+/3iiOJC89xoADMKxKBgLgS +oUkDz/bxwFoIIADhxR4IIAAIdeYIIAAIc3B1yiNFAxBzKQPv9sogxQDxwOHFocEA3UDFHggv/Ytw +guCKIP8PDPLPcIAAgFwDgCCAAMAieIDgyiBMA/UC7/ahwOB48cChwQDYQMDPcIAACM0hiItwJwlR +AM9xoAAsIDCBz3KAADg4SIJCeQ8ORXBOAAAg+g/P/APw2g/P/BEIkQCKIP8PocDRwOB+z3CAAKBc +A4AggADAIniA4MogLADz8eB44cXPcYAA7CIkgSCBz3OAAKBcQ4PVuaCCRoOKIP8PgOIF8gKConhI +IAAACSBAAGq4SCAAAOB/wcXPcYAAoFwLgUCADoGA4MoggQ//////CvICgEJ4SCAAAJkgBgBIIAAA +4H7gePHAlgnP9qHBGnDPcKAALCBAEBQAz3eAABzPP4cA3kQgFSPPdYAAODhBKYAB2nGGJv4vTCUA +okojQCDCI8IkUyARAEEoQSPAuRYlUhQEGkAgiiDZBcIK7/2KIcoCTCUAoswhIaAI9AGFBOieCY/8 +BPBmCY/8z3CAAEgkA4AYiA8IUQDPcYAAkNoU8D4Ij/086M9wgACQJwiIbQjRAZgXgBDPcYAAkNoC +uBZ4AGFZCF4DmBeAEEAh1QMCuBZ4OGA9CB4jIICIuSCgTgrv/YogiQOYF4EQAdoSaRZ4onBAqM9w +gABIJAGAwBAABhEgQIDMIaKDbA9CBwjwcg9gB8+ogOBgD0IHz3eAAHwKAIe7CNABBBIAIIHgyiCB +DwAAXAb4CeH9yiFBBKMLECCPDhAgAIcgHQAVjuiKIMkD3gnv/YohCwPPcYAAsMwKgQHgCqEh8EYV +gBA3CFEAz3Dt/r66QMCLcATZfdo926oMIAQXu4ogCgOmCe/9iiELCEYdghNFHYITuglv/0cdghM6 +D4/4B4UmhYJwAiBCAAcK3wcGpUwVgBAnCFEATB2CE4ogigRqCe/9ANkJ8IogGQZeCe/9iiELDwAd +ABUdAO/2ocDxwOYPj/YIdc9woAAsIPCAHQ3yEQDeCiHAD+tyiiANAoojCQOYdjEE7/e4c0MJkAEu +DY//z3CAADg46KDPcIAAfAoAgIDgzCDigQ/yz3CAALA0AYCJ6IogCgvyCO/9iiGJBVIOj/jPcIAA +yDfJoM9xgACgIoogWQfSCO/9IJHPcYAAsDTPcIAAHDgggfAgQAP4YA8JUQDPcYAAyDfJoc9zgAA4 +OCWDAiBCAAkK3wcFo50Hj/bxwOHFCHUE2c9woADIHCigCgzv9hbYz3GgAMAvE4GA5c8g4gLQIOEC +E6GA5TzaBvTPcIAACBpAkM9wgAAIGgGQELhFeMAZAABhB4/2z3KgACwgUIIies9xgACAChV5AIEX +CIUAz3CAAEgkAIDEEAAGBwheAUCh4H7xwL4Oj/YA3s9woAC0D7yAxg4gBMlwz3KAACiaBJLPcaAA +7CcQuIUghAAGoQWSELiFII0ABqEHgs9zpwAUSAejCIIQowOCz3OkALg9mxsYAASCphsYAAWCkhsY +AAaCoxsYAM9wpADs/8agiiCKAAahZg4gBK94z3CAAJQqBIBRIICASAriBcogYgChBo/24HjgfuB4 +ANjPcYAAxCoDqc9wgACICUeAAoBCqRzgVnhEiEmpBYjgfwqp4H7gePHA/g2P9s9xpwAUSADdqKEH +gc92gAAomgemEIHPcqcANEQIpqehz3DzD//8EKGg2Lahmrj1GhgAz3GkALg9mxEABs93gADkIgOm +phEABgSmkhEABgWmoxEABgam/9ibGVgDphkYAJIZGACjGRgAz3GkAOz/z3AAAP//p6EGoQCHAeAA +pxUIUQAB2c9woADIHDGg+g8gByhwBNgqDK/3QCYBEg3YHgyv90AmgRLPcCgAAgHPcaAA7CcGoYog +jQAGoQCHQiBAgACnBfTPcKAAyByxoJUFj/bgePHAJg2P9lEgwIENEg82z3OAAMzNAxINNs9xgADc +zvR7EYsQE4QAEvIB4AhyMhWFEGeRAhkCAc92QQCDAGaxz3OAACRAA6kR8EAkQgAxFYUQQqnAEwMB +A6nPdiEAggBmsc9zgAAoQBMNhQDEoQCDAeAAowSBU/DPc4AA7M3rYwHjwYVkqQDacI13Dh4RLyUI +AO9/SSfEEPJrz3CAAJDa9n/gYNKNEQieBc9wgADQ3HZ4AYgD8EhwACSPD4AA0Nx2f+SPCCbOEwgm +ABCgcEkgzgMWa9V4z3aAAFDeAGbPdoAA0N12fmGGz3aAAEgkxIbYhsV7BCODDwAAAAhmeALwA4UC +oZgVgBBoiQ0LAABEqWDYGLgE8ADYnbgEoXUEj/bgePHA4cUDyKQQAABRIACAz3CAAEgkBIAE8huQ +A/AakKoLwAW76M9woAAUBAPZI6Ag2AwaHDDPcYAArD4WgQHgFqEDyADamBABAKQQAwCUGEAAnhAB +Aay7khhEAL4QAQGtu4AQDQGkGMAAkBhEAH4QAQGAGIQAPWWwEAEBonkwebAYRACCEAEBfhiEAIYj +5Y+yGEQAaA8C/ekDj/bgePHAaguv9ghzEIkzEY0AAdpAqw0SDzbPdoAA9M3uZs9ygAAkzkjcwasN +Eg82AiIOA/QmzhPBsw0SDjbwIoIDQaNBgSMKHgHSic9ygADQ3BZ63KtAioYifwxcegS6RX7cqwPw +gNpcqwS4BX29qxyRz3KAAGzOD7MNyPAiAAAEswfIBaNUEQABDLMAkQ2zoBGCAEijBsgEIIAPAgBB +AA0IgQ8CAAAAiLpIowbIhiC+jwTyibpIo5wRAAHPc4AASF0muMC4QCgCAw+BwLgNuEV4BQOv9gCj +8cASCCAAAtj+CQAA0cDgfvHAggqP9s93gABIJBUnEBAAEA4gCHUUlgsIUgGI4ALYwvYA2BqmSiQA +cgDZqCBADc9wgAAQa/QgQgDPcIAAxLM0eECwz3CAACBt9CBCAM9wgAD0szR4QLDPcIAAIGv0IEIA +z3CAANSzNHhAsM9wgAAwbfQgQgDPcIAAHLQ0eECwz3CAAAht9CBCAM9wgADkszR4AeFAsAiG5bgE +2cohIQA0phEIHgEJ2UYeRBAu2gbwFNlGHkQQMtpbtlmOWWEweUYeRBAa4Tq2FQgeAArYVB4EEAbY +Vh4EEAfYCfAQ2FQeBBAA2FYeBBAF2A+mMglgA6lwPI4ocEQeQhCGIAMA5rlYHgIQyiJBAAvyUCHD +AW96RB7CEFAgwwFveFgewhATCV4BSHOGIwMAb3pEHsIQDQkeAaW4WB4CEAsJ3gCkukQeghAvDZAQ +og3v+KlwABAAILkQAAZRIECA8djAKCIByiCBDwAAkwDAKCEBhB4AEBjYjbgTpgiGDwjeALYXgBCJ +uAPwnReAEBKmz3CgAKwvGYDPcYAAlCowuMC4mg7gBgWhCIYEIL6PAAYAAADfCvI2uMC4G3gB4Foe +BBAC2BqmBPBaHsQTANgXphimEgtv/alwKIYB2khzQSkABTW5UiAAAFIhAQDAuMC5qg7v/Zhy+QCP +9uB48cCSCK/2B9jPdaAAyB9IHRiQz3CAAEgkI4DPdqwA1AEagUwdGJCC4ALYyiAiANAeAJCKIAQA +D6VGEQABz3egAKQwsB0AEEYRAAG0HQAQH9gIuA6lCIFRIACAANiLuAjyEKVKCc/4AYeEuAfwEaVC +Cc/4AYekuAGnz3CAAIBdAIAVCB4AhiD/DiK4FLjPcYAAqAgLoYoLr/gB3yoPwAB2CEAD9ghAA89w +AABVVVodGJDPcKYAKABZHdiT76DPcIAASCQDgFoQAQHPcKYA6AcmoAIID/3PcIAASCQDgOYMIAQN +kADYjB4YkAfYjR4YkADYix4YkM9wgAAEMCCAYHkE2BLoz3GAADgcGoE7gSR4GQheBIog2AniCK/9 +6XFuD2AAAtgF8H4LoAUB2M9yoADEJw8SAIZEIAMCz3CAAEgkI4AbgQ8aGIAPEgCGo7gPGhiADxIA +hgV7DxrYgHyBz3CgADAQZKDPcIAAHM8QeI8aGIDPcIAAbKjPc4AAbLgQeBC7ZXiQGhiAiiAEAJIa +GIAdgUAaAIDPcIAAiCNTGhiADxIAhp+4DxoYgADYEBoAgB6BHBoYgEUHT/bgfuB48cDPcIAAwJkY +EAQACiHAD+tyz3AAAOUO3tstA6/3SiUAAOB48cDhxc91gADAmWrYCgiv/SaFJYUmpQIIr/1r2A0H +T/aA4PHANNgH9BoJz/1QIEEEBfASCc/9TyBBBEoJ7/002NHA4H6A4PHA9NgI9PYIz/1QIAEA9NgH +8OoIz/0IcfTYgLkiCc/90cDgfuB48cDhxaHBaHVEIsAChiL/A0YiwgNUega5NHlZYRV5x3GAALye +i3AI4eIOb/YE2qlwi3HaDm/2BNoA2IUGb/ahwPHABg5P9qHBCHUAJI4AYn4CJk4RoHJiegIiAoEA +2EDADfIsfot2L3BIcV4P7/vJcvoJoAHJcADAAn2pcDEGb/ahwOB48cDhxYogCgseD2/9c9nPdYAA +sMyKIAoLDg9v/SCFz3GgACwgMIElpc9xgADYsiiBANgXCd4BJI0LCVEAJY0JCVAAAdgK6ACFgeDM +ICKAIvKKIMoMfNka8Iogyg3KDm/9gtkghRbpBI0NCFEABY2B4AHYA/IA2AXo7gxP+ArwFQlQAIog +ygyN2Z4OT/0C2AClqQVP9vHAMg1P9s92gADkIgCGAeAApgDdFQhRAAHZz3CgAMgcMaCaD+AGKHDP +cIAAJAogkIa5ELkFIYIPAADCEs9xoADsJ0ahAZAQuAUggA8AAAITBqEAhkIgQIAApgb0z3CgAMgc +saA5BU/28cDKDE/2z3CAAIwxGYAA3YHgyiHCD8oiwgfKIIIPAACoE8ojgg8AAJAByiRCAwgBovfK +JUIDz3aAAOQiAIYB4ACmFwhRAAHZz3CgAMgcMaACD+AGKHDPcIAAJAojkASQwrnCuAO4JXgQuIUg +jQDPcaAA7CcGoQCGQiBAgACmBvTPcKAAyByxoK0ET/bxwD4MT/bPdoAA5CIAhgHgAKYA3RUIUQAB +2c9woADIHDGgpg7gBihwz3KAAMwyAIrPcaAA7CcQuAUggA8AAMJpBqEBihC4BSCADwAAAmoGoQCG +QiBAgACmBfTPcKAAyByxoEkET/bgePHAzgtP9gogAKDPdYAAyGEAFQQQKvLPcKQAuD0A2jcMEQCb +EAMGz3GAAMxhYKGmEAMGz3GAANBhYKGSEAMGz3GAAMBhYKGjEAMGz3GAAMRhYKGbGJgA/9mmGFgA +khhYAKMYWAAB2DXwTCQAgMohwQ/KIsEHyiCBDwAAfhnKI4EPAAD8ArwHYffKJQEEz3CAAMxhIIDP +cKQAuD2bGFgAz3GAANBhIIGmGFgAz3GAAMBhIIGSGFgAz3GAAMRhIIGjGFgAz3CAAJQqBIAiuMC4 +IgvAA2EDb/YAHQAU4HjxwO4Kb/YA2M91gAAEMCCFQHknCBEDz3aAAAwwIIZgeQLYi+gghmB5A9iH +6FoNr/1Q2AsIngEA2ALwAdgvIQcgz3CAAPw6z3eAABww5g4v+gCnz3GAACBAFIEB4BShz3GAAOQi +AIEB4AChFQhRAAHYz3GgAMgcEaEKDcAGz3GAAAgyBIErCFEAJoHPdqAA7CdgeQDYz3CAAJS/GIiX +6M9wAQAGAQamz3ASAAYEFvAKIcAP63LPcAAAhxmKI8UJSiQAAKUGb/cKJQABz3ABAAcBBqbPcBIA +BwQGps9wgACUvyCAA4Ar6eCHRCi+A8bYkrgGpiCFJ3dgeQDYcwgQAyCFYHkA2GcIEAQghWB5ANhf +CFAEIIVgeQDYUwiQBM9wOQACMwamz3A5AIJMBqbPcDkAAmYGpsfYlbgY8EQovgMAIY9/gACsbcfY +krgGps9wAAACMwamz3AAAIJMBqbPcAAAAmYGpsbYlbgGpuoOT/7PcIAAlL8YiM9xgACUvyYL4AMg +gS8JECDPcAAAAm4Gps9wwQBCbgamz3ADAMJuBqbPcDYAQpcGps9wAgBCawamz3AQAIdyBqYFjxC4 +BSCADwAAQnAGpgSPELgFIIAPAACCcAamA48QuAUggA8AAMJwBqYCjxC4BSCADwAAAnEGpgmPELgF +IIAPAABCcQamCI8QuAUggA8AAIJxBqYHjxC4BSCADwAAwnEGpgaPELgFIIAPAAACcgamAY8QuAUg +gA8AAEJyBqYLjxC4BSCADwAAgnMGpgqPELgFIIAPAADCcwamIIVgeQDYJQgQAyCFYHkA2BkIEAQg +hWB5ANgRCFAEIIVgeQDYEwiRBAyPELgFIIAPAADCfwamz3ABAEZqBqbPd6AAyB+kFxAQFQkQIM9w +UADGcwamz3AgAMdzHfAghWB5ANg1CBADIIVgeQDYKQgQBCCFYHkA2CEIUAQghWB5ANgVCJAEz3CA +AAZ0BqbPcIAAB3QGps9wgADGcwamz3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqbPcIAA +lL9YiM9xgACUvwCIJImA4gHawHrPc4AAlL9GC2AGeYsk2BjZbgrgBjPaLwhQAM9wgAAgQFAQBADP +cIAAlL8MEAUACiHAD+tyz3AAAIoZCQRv94ojBwcPCRAgz3AGAEJrBqbPcBAAx2oGps9wEACGcgam +DwkQIM9wAgBGagamNgmABj4IgAYk2AHZCgrgBjPapBcAEM9xgAAgQAIgAAQToc9wAgBHagamIIVg +eQDYLQgQAyCFYHkA2CEIEAQghWB5ANgZCFAEIIVgeQDYDQiQBM9wZQDCbgamz3CAAOQiAIDPcYAA +5CJCIECAAKEE9ADYUR8YkEkHD/bxwN4OD/bPcIAAjDEUgIDgi/J+DG/+B9h6cM9wgAD8PAyIhiD/ +AUO4YbiG4PQADQDPdoAAlL8khs9ygADEvTMmAHCAAFBkQCIRCwS5NHlAIhAKQCISBkAiDwhAIg0E +OmJAJwFyFHkAec9xgAA0M0hwVfDPcYAAVDMEalHwz3GAAHQzQCIAAkvwQCIAA89xgAA0MzoLb/4A +2gSGz3GAAFQzBLgUeLhgO/BAIgAHz3GAADQzGgtv/gDaBIbPcYAAdDMEuBR4+GAr8EAiAAXPcYAA +VDP6Cm/+ANoEhs9xgAB0MwS4FHhCcBvwQCIACc9xgAA0M9oKb/4A2gSGz3GAAFQzBLgUeAJwxgpv +/gDaBIbPcYAAdDMEuBR4InCyCm/+AdqaCm/+anARBg/24HjxwM9wgACMMQ+AEejPcIAAlL8EgM9x +gAAUvwK4FHg4YM9xgACUM9YMT/7RwOB+4HjxwJYNL/ZE2s9wgABobc9xgAB4zaILIAQA3gLdFggg +AMlwYb35DXWQAebZBQ/24HjxwF4NL/YA2s9xgABIJBV5YIEEuAAgkA+AAPBpuRuYAACBBBAPIM92 +gABobb4Y2AOggUKGiiAHD2GGHWXwHYAQ7B3AECCBRobPdYAAeM1lhjhg+BiAABYmwRP0GMAAFiXA +EwTgBOHCDS/2CNoMEAAgFn4WfQRtJG6uDS/2CNpFBQ/24HjxwNoML/YS2anBCHZaDiAGi3BKJABx +ANqoIIACFiSAMCiICwmSAGG5KKgB4gLCAcPPdYAASCTVfQCFiiEHD/Rux3eAAPBpOGDsGMAA8BiA +AACFBsIFwzhg+BiAAIPB9BjAAAQXEBDPcIAAeM0WIAAEBOAyDS/2CNrjh89wgAB4zYfB9ngE4B4N +L/YI2gDAIIW5GRgAIIW5EQAGFQgeAL4Z2AMghb8RAAaAuAjwvhkYBCCFvxEABqC4Rgvv/L8ZGACE +6DYLz/wE6ADYA/AB2BB25AyhBsoggQMAhbkQAQZRIUCA8dnAKSIByiGBDwAAkwDAKSEBYgov+4QY +QABBBC/2qcDgePHA3gsP9s92gAC0Yc91gACQChLpIIaN6QClRgxv+A7Ybg+v/oogEAAB2ACmDvAg +hSV4C/D2Cm/4DtgaD6/+iiAQAADYAKYApQEED/bxwIILD/bPcYAA7C8AgaC4AKE+C+/7AdjPcIAA +jLIAEAQATCTAgMohzQ/KIs0HyiCNDwAAgQzKI40PAADaAMAHLffKJe0AxQx0AADdFG0AIIEPgACM +sgeR5pHEkRC4BX8FkUORELgFfgKRELpFeBpwGgqv9+lxWnDPcIAArHTwIEEDRC0+FwohQC4AIYB/ +gABMWiCgBglv+wpwCHEAIYAvgABAWj4JwASKIMwORgwv/enZiiAMCD4ML/1KcYogDAgyDC/9yXEJ +D4QTme7PcIAAoHTwIEEDRC0+Fy92ACGAf4AA9FogoLYIb/tKcAhxACaAH4AA6FruCMAEz3CAAIyy +AIAB5UkNBJDVAg/24H7geM9xgAA8MM9wgAAIMuB/IqDgfuB48cBuCg/2AN7PdYAAvM3PcIAADDAg +gMClYHkB2IPgyiHCD8oiwgfKIIIPAACYGcojgg8AAOsAyiRiAKAGIvfKJYIDAIWYuAClANjBrcKt +jrgBpQKlz3aAABAwQIYG2GB6AdlAhgfYYHoB2QGNbQIv9gCt4HjgfuB44H7gePHAz3CAACBdAIB9 +CFQBz3CgAKwvGoBSIAAAbQgfAM9xgAAomguBAeALoc9wgAD8LwCAQHieDgAAz3CAAPgvAIBAeM4P +gADOCg/+5gmP/Abw9gzv/IogiQzPcKAAeEUAgAQggA9wAAAAQSg+hfL1z3CAAEgkI4BIgTSRUyIA +AE4I4AIB27oIb/gS2NHA4H7gePHA4cW0wYogmAm6Ci/9WtkF8KYM7/yKIIkMz3WgALRHcRUAlgQg +gA9wAAAAQSg+hfH1iiD/D28dGJBrHRiQIg2v+Itwdg6P/A7obxUElmsVBZYKIcAP63LPcAAAsRNx +BS/3NNs2D0/49giAA2kBL/a0wOB4QIgB2AChaLoCulV6x3KAAIwxY4JjoWGCYaFigmKhZIJkoeB/ +AKLgePHAwggP9s93gAAkXQaHA4DPdYAAKJoggEmFACKADy0AwMYCeYEJcgChwc92gADkIgCGAeAA +phcIUQAB2c9woADIHDGgCgugBihwi3E6D+/2QtgAhkIgQIAApgf0ANnPcKAAyBwxoAAUBDEEJL6P +AAAX/8ohwg/KIsIHyiCCDwAAphPKIyIMrAQi98olIgAAhYK4Fg0gAAClIgggAAHYAIWiuAClKYXH +cS0AwMZqDqAE6XB5AC/2ocDxwOIPz/Wvwc9xgAC4ZQCBSiQAIE3ABInPd4AASCRuwAOHCIBTIBcA +NxSAMEDALsBBwDYUgDBCwM9wgAA4HDqAG4AkeM9xoAC0R0cRAYYxuMC4h+mKIJgMiQQgAEzZgOB4 +BAEAz3CAACiaABAEAFEkQIDKIcEPyiLBB8oggQ8AAKoTyiOBDwAAWgDwAyH3yiUBBc91gACACYog +GAfSCC/9IJUglc9wgAAomiKwANmeuc9woAC0R1MYWIDgeFMYGIVOCU//z3WAAOQiAIUB4AClEwhR +AM9xoADIHAHYEaG6CYAGLcDPdqAA7CcQuAUggA8AAEItBqZAJIE81g3v9kLYz3AIAIcQBqYAhUIg +QIAApQb0z3CgAMgcRBgABc9wgACEthYgwAUkgACACrnJuAQhgQ8PAAD8BXnPcKcAFEgtoHIID/5D +wBkPECCKIf8Pz3CgALRHbxhYgGsYWIAB2M9xoAC0R2AZGIADhzIggA8AANgCgOAB2MB4D7iQuJu4 +n7hfGRiAAIUB4AClFQhRAM9xoADIHAHYEaH+CIAGQCSBPi4N7/YR2ACFQiBAgAClB/TPcaAAyBxE +GQAFz3GAAGw8J4lKIQAggeEB2cIhQQCA4UTBcgIlAAolQCQAwQHAInhHwAbwfgnv/IogiQzPcKAA +tEdxEACGBCCAD3AAAABBKD6F8vXPcKcAFEhcGAAFLydHFBUJESDPcIAARwQGpkogACAI8EoggCDP +cYAARgQmpoogWAg6D+/8KnGKIFgHMg/v/ApxAIUB4AClFQhRAM9xoADIHAHYEaE+CIAGBb/wfxC/ +gb+Hv4y/5qYAhUIgQIAG9M9xoADIHEQZAAVKIgAhSncB4GG/AKUTCFEAz3GgAMgcAdgRoQIIgAYC +wRVvJXgQeBC4hSCKAAam6XCAIIINEHhFwAa4gbiXuAam6XCAIEIPEHhGwAa4gbiXuAamz3AAAAIv +BqbPcAAAwjAGpgCFQiBAgAClB/TPcKAAyBxEGAAFiMCJwYrCi8MWCWAEQCQEPCzAiOjPcYAAcEAQ +iQHgD3gQqR0JUSAZDxAgSgqP/BEIUQAwHAI1TyUAIC8lByDPcYAAhLYWIcEFMBEZAAjCz3CAAGCa +FiDWAwnA8B6AIPQeACAHwIgifAAvIwAgBCu+IC9wWg5v+yiBDiCYDwAAAAEJwIggfAAEKP4EL3BC +Dm/7K3EOIIEPAAAAAQkggz8AAP8BCSGCDwAA/wFIIwMASCICACzAVB7YIFUemCAhCFEADBQEMEAo +ACFALIEBOGD1eMdwgADAtmKwQ7AAhQHgAKUVCFEAz3GgAMgcAdgRobYOQAYDwUAoACEGuThg9XjH +cIAAwLYikDx6BcEQuga5gblFeSamA5AGwRx4BrkQuIG5JXgGpgCFQiBAgAClB/TPcaAAyBxEGQAF +QiJSIEwiAKBSBs3/BMFAIVEgMnGeBcb/OhQBMVEhwIHKIYIPgABGBMohgQ+AAEcEJqYB4AClEwhR +AM9xoADIHAHYEaEqDkAGMhQAMRC4gbiHuIy4BqYAhUIgQIAApQb0z3CgAMgcRBgABb4MD/8F8MoO +r/yKIIkMz3CgALRHcRAAhgQggA9wAAAAQSg+hfH1jglP+M9wgAAomgyAz3GAACiaonAMoQ2BAeAN +oQjwiiCYDIohBAOODM/8PQPv9a/A4HgA2c9wgABEmiyoLajgfy6o4H7gePHADgvP9Qh2LrjAuAS4 +TyDBAM9wgABsPACIz3WgAOwngeAB2MB4B7gleBC4hSCRAAalwg/v9QHYgL7GpT0Dz/XPcIAAByHP +caAA7CcGoc9wgABHOgahz3CAAMdTBqHPcIAAxyQGoc9wgAAHPgahz3CAAIdXBqFJ2c9wpwCISTCg +4H7geAHZz3CgAMgcMKBL2c9wpAAcQCSg4H7geM9xAQCsPs9wgAAAMOB/IKDPcYAAKJoAgYC44H8A +oeB48cBSCu/1uHBTIIEAz3CAADR0KGCB4Mohwg/KIsIHyiCCDwAAlRnKJIIPAAD+AJAG4vbKI+IH +z3aAAAwwIIZgeQHYJwjQACCG63VgeQHYuHDPcAAAlhkKIcAPqXIi22EG7/aKJIMPWQLv9QHYCdng +fyCg4HjxwOHFz3WAAAwwIIVgeQLYgOAghQjYCPRAeRB5z3CAACAOB/BAeRB5z3CAAAgPAgnP9roJ +YAMB2P4Oz/2GDwAAKggAAA0Cz/UIcViJAYACoYjqWYmA4sIgogDAIKEAAqHgfuB44H7gePHAcgnP +9c92gADkIgCGAeAApgDfFQhRAAHZz3CgAMgcMaDeC2AGKHDH2JS4z3WgAOwnBqXPcAMAgmwGpc9w +AwDCdAalz3ADAEKWBqXG2JC4BqWuC2AGCtjPcAAAgmwGpZ4LYAYK2M9wAADCdAalkgtgBgrYz3AF +AEKWBqWCC2AGiiAHDc9wAABClgalcgtgBgrYz3ATAMYABqVmC2AGMtgAhkIgQIAApgX0z3CgAMgc +8aApAc/14HjxwLoIz/UId892oACsLxWGMwgeAM9wgABsPACIz3WgAOwngeAB2MB4B7hFIAAGELiF +IJEABqVuDe/1AdgB2I64BqWI789wgAD8LwCAQHhL8BWGUSAAgMohwQ/KIsEHyiCBDwAAfxnKI4EP +AACqAMokwQC4BOH2yiXBAM9wEwDHAM92oADsJwamz3AQAAZpBqbH2JW4BqbPdYAA5CIAhQHgAKUX +CFEAAdnPcKAAyBwxoJYKYAYocM9wAABCLQamz3AAAIJGBqbPcAAAQmAGpgCFQiBAgAClB/TPcaAA +yBwA2BGhQQDP9eB48cDWD4/1z3CAAAQwIIChwWB5BNgy6M92gADkIgCGAN0B4AAcRDMAphUIUQAB +2c9woADIHDGgKgpgBihwi3FaDq/2ANgAhkIgQIAApgX0z3CgAMgcsaAAFAExz3WAABAwhiH/DECF +QrlgegLYABQBMUCFA9hgesG5yQev9aHA4HjxwE4Pr/UD2M92gAAEMCCGz3WAAMg7YHmiwQboIIZg +eQTYhuhlAyAASBUEEAPYGnDPd6cAFEjPdqAA7Ce2DO/9BdgOpc9wgADkIgCAAeDPcYAA5CIAoRcI +UQAB2c9woADIHDGgeglgBihwA9iqDa/2qXEE2KINr/YibQXYmg2v9iRtCtiSDa/2Jm0P2IoNr/ZA +JQESNtiCDa/2QCWBEjfYdg2v9kAlARM42G4Nr/ZAJYETCIcEpQ2HBaUOhwalz3CnAJhHHIAHpReH +CKUWhwmlz3CrAKD/GIALpc9wqwCg/xmADKXPcKsAoP8agA2lz3ADAMYDBqbG2JC4BqbPcCwAAgEG +ps9wWQBCAQamiiCKAAamz3BAAIcNBqbPcNEAwg0Gps9wwAAHDgamz3CAAOQiIIARCVEAz3KgAMgc +ANgRogHYCKcA2A2nDqfPcKcAmEfPclAA/wBcoADYF6cWp/zaz3CrAKD/WKB82lmgGoDPcqsAoP+A +uBqiz3CAAOQiIKATCVEAz3GgAMgcAdgRoVIIQAbPcEAAhg0Gps9wEAACDgami3B6CiAEgcE2hQDA +IngEKIAPAAB0CRWFN4UCeVIPr/UvcAHCT+DPcYAA1JsUpVehGKHPcEAAhw0Gps9wEQAGDgamz3CA +AOQiAIDPcYAA5CJCIECAAKEG9M9xoADIHADYEaGLcBoKIASBwTaFAMAieF4K7/sSpTKFVYUseDeF +LyBADkJ5OWHmDq/1NXnguBx4wCBiAIIgxALPcYAA1JsSpROlFqHPcIAA5CIAgAHCAeBVoc9xgADk +IgChEwhRAM9xoADIHAHYEaF2DwAGAZUQuIUghAAGpgKVELiFIIUABqYDlRC4hSCLAAamBJUQuIUg +jwAGpgWVELgFIIAPAACCDQamBpUQuAUggA8AAMINBqYHlRC4BSCADwAAAg4Gps9wgADkIgCAz3GA +AOQiQiBAgAChBvTPcaAAyBwA2BGhBIUrhQinBYUNpwaFDqcIhRenCYUWp89wqwCg/zigLIU5oC2F +OqAaCe/9DoUyhYwhgoBF9owhP4EM9sYOIAYK2EYLwANCIEAggOAGBc3/BvCGDa/8iiDRBTKFjCGC +gEX2jCE/gQX2cg2v/IogEQtIFQQQjCSCgEX2jCQ/gQz2CiHAD+tyz3AAALQZiiNFDFUA7/a4c89w +gAAOGwCIBujPcIAAKDwAEAQAiHApBK/1osDPcIAAyDvgfxSA4HjPcQEA5FbPcgEAjE2xAq/6ANjg +eOB+4HjxwM9wgAD8LwCAQHjPcIAA+C8AgEB40cDgfuB4ANnPcIAAPArgfyCg8cB2C4/1z3CAAAQw +IIChwWB5BNiB4JH0Igpv/PfYgeCL9ADYABwEMM93gADkIgCHAeAApxUIUQAB2c9woADIHDGgwg0g +Bihwi3UA2O4Jr/apcQAUBTGocIYg/AOMIAOMDfIKIcAP63LPcAAAvhmKIwQBdQev9ookgw/PdoAA +EDBAhoYl/A8A2GB6Qi2BAUCGAdhgegPZAdiiCa/2qXFAhgjYYHoAFAExABQFMUwlAIDKIcIPyiLC +B8oggg8AAJoZyiOCDwAAEgEcB6L2yiRiAALYagmv9qlxQIYE2GB6ABQBMRLYVgmv9qlxQIYF2GB6 +ABQBMQAUBTFMJcCAzCUigcohwg/KIsIHyiCCDwAAnBnKI4IPAAAZAcwGovbKJGIAAIdCIECAAKcW +9M9xoADIHADYEaEQ8M91gAAQMECFAdhgegPZQIUE2GB6CHFAhQXYYHoE2YkCr/WhwOB48cAeCo/1 +z3WAAOQiAIUB4AClAN4VCFEAAdnPcKAAyBwxoIYMIAYocM9wgAAGIc9xoADsJwahz3CAAEY6BqHP +cIAAxlMGoc9wgADGJAahz3CAAAY+BqHPcIAAhlcGoQCFQiBAgAClBvTPcKAAyBzRoM9wpwCISdCg +EQKP9QjZz3CAALzN4H8joPHAlgmP9c92gADkIgCGAeAApgDdFQhRAAHZz3CgAMgcMaD+CyAGKHDP +cAAAwizPcaAA7CcGoc9wAAACRgahz3AAAMJfBqEAhkIgQIAApgb0z3CgAMgcsaCpAY/18cCGCO/3 +FtgGC8ADz3GAAEgkAIHEEAAGDwhfAQGBxBAABg0IXgFmCS/4E9jPcIAA8C8ggGB5C9jRwOB+8cC+ +Dy/8iiCIBQ7org8v/QDYz3CAAAQwIIBgeQTYgODkDQL/0cDgfs9wgABIJAOACIDPcYAAvM0JCB4A +AYkD8AKJ4H8AqeB48cC4cY3oCiHAD+tyz3AAAKcZiiPECw0Fr/aKJIMPz3GAALzNIIFMJQCABCGB +DwAHAABBKQMGANnKJE1x6CBtA/AgRQAEJYIPAQAAwC66ZXoLC4EAAeHRwOB+CiHAD+tyz3AAAKgZ +iiMEDrkEr/ZKJEAA4HjxwOHFAN3PcIAASAmmCCAAoKDPcKcAFEiooJ0Aj/XgePHAocG4cADYQMBT +JYAAJwhQAEUIkABPCBABCiHAD+tyz3AAAKsZiiOKCmUEr/aKJIMPz3CAAAwwIIBgeQHYhOAB2cB5 +z3AAACLSNHjPcYAAk+cP8M9wAAAj0s9xgACW5wfwz3AAACTSz3GAAJnnKdoSuvAiAAAOIIIPAAEA +AEDCi3DCDWADA9qhwNHA4H7gePHAig9P9QPIlBAAAM92gADkIgQgkA8BAADAAIZBKJAjAeAApgDd +FwhRAAHZz3CgAMgcMaDmCSAGKHDPcSQABwHPcKAA7CcmoIohhQAmoFMggSArCVAAZQmQAIEJEAEK +IcAP63LPcAAAiBmKIwYDiiSDD40Dr/YKJQAEz3GAAEgkI4EogVEhAIDKIYIPgADHIMohgQ+AAIck +JqDPcQQAxzEmoACGQiBAgACmBvTPcKAAyByxoDkHT/XPcYAASCQjgSiBUSEAgMohgg+AAAc6yiGB +D4AAxz3i8c9xgABIJCOBKIFRIQCAyiGCD4AAh1PKIYEPgABHV9Lx8cDPcYAASCQjgS8oAQAogcC5 +ACGDDwAAItJOIIEHKdgSuPAgwADPc4AAlL94i89ygACT56HBQMCG6wIggA8AAADAQMCLcDR5WWFy +DGADA9qhwNHA4H7gePHAQg5v9bhwz3AsAAYBz3OgAOwnBqPPcqsAoP8aglMljQAA2SUNUBBpDZAQ +qQ0QEQohwA/rcs9wAACBGYojhQNtAq/2iiSDD891gABIJKOFqIXPdgIAggJRJQCQyiWCH4AAxiDK +JYEfgACGJKajxqPPdQQAxjGmo891SABCAaajz3OnABRIN6OAuBqiIQZP9c9xgABIJCOBKIHPdQIA +ggJRIQCAyiGCD4AABjrKIYEPgADGPSajpqPPcQQAxjEmo89xSgBCASajAdvPcacAFEh3odzxz3WA +AEgko4Wohc92AgCCAlElAJDKJYIfgACGU8olgR+AAEZXpqPGo891BADGMaajz3VMAEIBu/HxwC4N +T/UDyJQQAAAB3s91pwAUSMilBCCQDwEAAMDaDu//QSiAI//Ym7jPd6cAmEccp4ogEg1iDm/8QSiB +I89xgABICQCBgODKIcIPyiLCB8oggg8AAKwZyiOCDwAAsgDKJCIAPAGi9solAgEA2Bal2qchBW/1 +wKHxwLYMT/XPcKYAnD8ZgL0IHgDPdYAAVAkAhUaAoBIABi8oAQBOIIEHQSnQABEI1SBIcIAgCgAy +IAAEkOgKIcAP63LPcAAArRmKI0sCiiSDD9kAr/YKJQAEz3aAAIjnQCbAEuIPr/YJ2QDYBgqv/w8g +AASA4ADYDyAABAX0IgzP/wPwpg3P/wPIuRCAABt4gLgKrgCFJoCWIUEDACEABBiIjCDDjwJxBfJh +uA94GKmKIFINANlqDW/8DyEBBACFJoCgEQAGnxkYALYLz/9NBE/1z3EqABUAz3CAAEBd4H8goPHA +0gtP9TpwG33PcKYAnD9kEBAALQgfIKoIr/UD2GG9jCX/n/P1CiHAD+tyz3AAAKQoUdsKJEAEEQCv +9golAATxA0/18cCSC0/1z3GgAKwvOoFSIQEAUSEAgKHBAN6W9M91gADkIrMIEAACCo//z3eAAAQw +IIdgeclwEwgQAyCHYHnJcCCFWQgRBACFAeAApRUIUQAB2c9woADIHDGgyg3gBShwi3H6CW/2iiAH +BQCFQiBAgAClBvTPcKAAyBzRoAAUBTFXDdAACiHAD+tyz3AAAIkZ6tt1B2/2mHMB4SClFQlRAAHZ +z3CgAMgcMaB6DeAFKHDPcQYAAnXPcKAA7CcmoACFQiBAgAClCfTPcKAAyBzRoAPw5ggAAACFAeAA +pRUIUQAB2c9woADIHDGgOg3gBShwz3CAAEgkA4DPcYAAbDw4EBAAIInPd6AA7CdBKIAjgeHAuAHZ +BLjAeYO4B7kleBC4hSCRAAanWg9v9QHYTyAAIAanAIVCIECAAKUG9M9woADIHNGgsQJv9aHA4Hjx +wGoIAADPcIAABDAggGB5A9iA4FQMggPPcIAAlCoEgBkIngDPcYAASCRNgT6RUyIAAPYIIAIB29HA +4H7xwOHFz3WAAMA7AIUbCB8Acg7AAgYIz/vqCE/5Cg7P/wCFgLgApWECT/XgePHApggv/IogBAIR +6DoOj//GD8//z3CAAAQwIIBgeQTYBejqD0//DggAANHA4H7gePHAtglP9c91gADAOwCFOQhfAM9w +gAAEMCCAYHkE2BToVggv/OLYEOgqD2/9B9iaCKADCHYCDw//Rg5v/clwAIWBuACl3QFP9eB+4Hjx +wGYJT/WkEAEAFQkeBrYQAQHPcKAAmAM+oJ7wABYNQbywABYCQV2wABYOQM+gABYCQUAYhAAAFgJA +UaAAFgJBSBiEAEQlAhM1ChABGNtyGMQAABYDQHOgABYDQVAYxAAAFgNBVBjEABEKEQKpc4Yj8w+M +IwyADvIY2xbwENtyGMQAAN/Pc4AA3M7nsxDbDPAe23IYxAAAFg9A9qAAFg9BXBjEA6l3hif9HIwn +ApIJ9ALjcHtyGMQAABYPQQLwAN9gGMQDCQteAAAWD0EodIQkDJAE9ADaIvCZ6lEmAJDRISKCFfLQ +iKi5z3KAAJDapBhAAAK+1n7CYgsKngeLuaQYQAAA2lqgW6Dm8QAWAkBaoAAWAkBboAjadBAOAb4Q +DwHCf2J/Qn+4EIIAmLmkGEAAz3GgAJgDQn96YlB6chiEALoQAgHwf3AYxAOlelywPoG2GEQAeQBP +9fHADghv9YogBwbPdoAAQB5iCW/8IIYV3c93gAA8FgCG6XFSaAHgAKZUelhhAoBZYRHoz3KgACwg +UIJCeNdwSWsA0gDbx/dioYogxwUmCW/8IIkAhgkIlAoA2ACmYb3DDVWQFQBP9eB48cDPcIAAyBQO +2QHa5gogAADbz3CAAAAVCdkB2tYKIABIc89wgAD0EyrZANrGCiAAANvPcIAAnBQL2QDatgogAAHb +0cDgfuB48cDhxc91gABaPIogRwa2CG/8II0E2N4Mr/sB2c9wgABZPACIigsgACCNrQcP9eB48cDP +cYAAWjyKIMcGhghv/CCJz3CAADRi+gzAA9HA4H7xwNhxiuj6CAAAANkioIogxwViCG/8yHHRwOB+ +8cD2Dg/13g7P+892gABACmbYIm4B2loK7/xIc4voCiHAD+tyz3AAALYU2duKJIEJOfACFgURTCUA +gMwlgo8AAP//DfQKIcAP63LPcAAAtxTc2xEDb/aKJIEJZ9jJcQHaDgrv/EhzjOgKIcAP63LPcAAA +uBTf24okwQkV8AGWJG4B2gHgEHjqCe/8SHOhlo/oCiHAD+tyz3AAALkU4ttAJUQQwQJv9kolAAAC +bRB4Jm4B2r4J7/xIc4zoCiHAD+tyoZbPcAAAuhTl20AlhBDr8ZEGD/XPcaAAYB0SsRSR4H7xwLhx +NQhRAAkNUgAZDdIDCiHAD+typ9gFuJzbZQJv9kokAABALYAAFHhCIAEDz3CAAFwVGWEf8M9wgAAM +GjIgQAGMIMOPyiHBD8oiwQfKIIEPAADhFMojgQ8AAKIAJAJh9sokIQACuBR4ACCBD4AAPBYocNHA +4H4RCB4CBCC+jwAAABgB2AP0ANjgfwCp4HjxwIIND/XPdYAAggkAjc93gACACV4P7/8gj0GIz3aA +AGA8IJcPCt4AAdgAroogxwNI8AKABegA2ACukLlA8GcKHgHPcoAAdCcHilsJAQAAlWGKUwjBAM9w +gACECQCIRopDCgEAz3CAAEgkDoA3CF4Bz3CAAFw8QIAA2w7qz3CgACwgEIBCeBEIhQ8xAQAtAdpA +rgTwYK4A2hC6iiBHA0V5EPDPcIAA6CIAiAfoAdgAroogBwMG8ADYAK6RuYogBwQmDg/8JQUv9QCO +4HjxwJ4MD/WhwRpwOnJodr0JcgAA2JpxFSANIM9xgABACgAVkxACFZIQunDjjSGRAY0B2jhgEHiL +cfoPr/xIcxLoABQAMUAqgiAEIIEPAAAA/0e5VHozCRAgx3KAAFwVGPDPcIAAQArBkKGNCiHAD+ty +z3AAALsUiiOEAAAmRBOpAG/2CiVABcdygAA8FgAawgQD7gKqAvABqiUIHgAM7gOKgLgDqhJvFHgb +YmOLWGCBu2Oo5KoD7iaqAvAlqkIkQSBVCXWAQCVAICUEL/WhwOB44cVTIA0AoKkEIIEPAAYAAEIh +AYAEIIAPQAAAAMohYgAgqtdwQAAAAAHYwHgAq+B/wcXgePHAkOieDc//z3GgACwgMIHHcUlrANIi +oP4ML/yKIIcF0cDgfvHAkgsv9dhxCiaAkIh1zCMigAbyQiYGAS8mhwFiDe//yHHPcYAA+AkAoSXu +JIgCuTR5Q4gD4QIQhQAjCh8ACiHAD+tyz3AAAOIUiiOIBUokAACtBy/2CiWAAQhhGwhfAAohwA/r +cs9wAADjFIojiAbv8QEQhQBRJQCAyiHBD8oggQ8AAOQUyiOBDwAAKALKIsEH3/PhvdElIoHKIcIP +yiLCB8oggg8AAOUUyiOCDwAALwJMByL2yiSCASsNHhBRJcCAyiHBD8oiwQfKIIEPAADmFMojgQ8A +ADYCJAch9sokgQEdAw/14HjxwJ4KD/WhwQh1KHcacgDez3CgALQPcBARAIogxwDuCy/8qXGeCqAC +yXCLcUAkQjBAJIMwjg7v/+lwDQgRIEokAAAJ8M9wgACcrAGI+ehKJIAAIMABFIIwqXHCDu//AhSD +MM9wgABaPACIgODMJQKQCvLPcIAA+AkAgMKgz3CAAFg8wKgvD14Rz3GAAHQnB4kjDQEQAYlTJwIQ +GwoBAAQnjx8ABgAAgOcB2gaJwHofCgAAz3CAAOkiwKjPcIAAXDzAoM9wgABgPMCoiiDHAD4LL/yp +ce4JoAIvIEcEIQIv9aHA4HjxwM9xgADIQIoghwEaCy/8IIGmCc//z3CAAIAJAJCA4CAMwv/RwOB+ +4H7gePHApgrP/+4Jz//WDwAF8gzP/HYNQAHRwOB+4HjPcQAArd7ZAi/8iiCHCeB48cDhxc9wgABg +PACIkOjeC8//juiKIEcEAN22Ci/8qXGQ2ZC5A8igGEAAF/DPcIAAPB4AiBDoz3CgAAAELIiMIQKA +AN0I9IoKL/yKIIcEkdmQuerxAd2NAS/1qXDPcYAASCTwIQEAKBGAACiBWQbv/wDa4HjxwPYID/UI +d89ygAB0J892gACACQCWZ4rPcYAA6CItCwEAz3CAAIIJAJBhih0LAQDPcIAAhAkAiEaKEQoBAM9w +gADpIgCIA/AA2C4L7/8Aqc9wgACECUCIz3GAAIIJAIkgjoDiAdrAeulzAN3+DO//mHXPcIAA+AkA +gAGIz3KAADweIJYPCB4BAdgAqoogRwME8KCqiiCHA8IJD/zBAA/1z3GAAHQnz3CAAIAJAJBHiTEK +AQDPcIAAggkAkEGJJQoBAM9wgACECQCIJokVCQEAz3CAAOgiIIjPcIAA6SIgqOB+4HjxwBIID/XP +doAA/LIUjikIUQAE2JINb/sB2c9wgACCCQCIz3GAAIAJOgzv/yCJANgUrjXwto4z7c93gABYPACP +Ybg1DQAQogjP/89wgAD44gWAIW0FKH4Az3CAADRiCg6gAy9xiiCHBs9xgACACQoJL/wgkc9wgACC +CSCQz3CAAFk8oK8gqM9wgACACSCQz3CAAFo8IKgA2BauNY4J6c9wgACCCWII7/8AiADYFa7NB+/0 +AdjPcKAALCAwgM9wgABcPOB/IKDgePHAHgjv/+HFz3CAAGQkEIjPdYAAnKwbCBEBiiAPCpIIL/yK +IUoEAo0WCCAAIYUCjSGFdgzv/wHaiQfP9PHACg/v9NhxocEacItxQCRCMEAkgzAWC+//yHABFIAw +COgCFIAwBuhCIBAhLyAHJCDAzgjv/wpxARSBMAPpoogC8KGIiiDHASoIL/zIcUAoACZALQIUBXoB +FIAwAhSBMAi4BXqKIMcBCggv/EV54b3RJeKQA/IjDR4RCiHAD+tyz3AAAOcUiiNNA0okAADxAi/2 +CiUABNkG7/ShwPHAag7P9KHBGnAA3s9woAC0D3AQEQB6DmACyXCKIEcBtg/v+wpxhCgIKQAhjX+A +ABSuJfBAJQAXFiCEAwUUgACGIP6HGvIEhYtxQCSDMEAkTzA+Cu//6XKoFQAQfgjv/+lxIMAEFIEA +ARSCMAIUgzB2Cu//SiTAAAHmDJW5DgSQiiBHAVIP7/sKcQYOYAIvIEcEOQbv9KHA8cAaDM//YgsA +BdHA4H7gePHAzg3v9IohiwYA3c9wgAAgzaWgGg/v+4ogygHPcIAAsDSioM9xgABIJACBxBAABq0I +XgEDgRiIpQgQAYogyQPuDu/7iiGLCM9wgADsIgSAz3WAAABcIICKIIkD0g7v+za5AIVCIACAyiBi +ADEIUQA+C6ADqXDPdoAAyFsAhkIgAIDKIGIAjOiKIIkOog7v+4ohSwvJcIoLoAMihc91gAAcXACF +QiAAgMogYgAxCFEA/gqgA6lwz3aAAORbAIZCIACAyiBiAIzoiiCJDmIO7/uKIYsOyXBKC6ADIoVd +Bc/04cUA289ygADMzRQiDQBgtWi1GmIgGsIAwB3EECgawgDPcYAAeM0WeSKRMBrCANAdxBCAHdwQ +eB1EEAHZiBpCAM9xgABszhV5YKHgHcQQ8B3EEOB/wcXgePHAJgxv/BHYuejPcYAAdCfPcIAAgAkA +kEeJVQoBAM9wgACCCQCQQYlFCgEAz3CAAIQJAIgmiTkJAQDPcIAA7C8AgJroFg9AAojoC8gFIIAP +AAAAPAsaGDAGD0ACiOgLyAUggA8AAADUCxoYMAvIkLgLGhgwygyP+wPwWgrP9dHA4H7geADZnLnP +cKAArC89oOB+4Hh5AY/78cBKCy/3FdiKINAHUg3v+0jZ0cDgfuB44H7geCCAANqA4UX2AdozeSCg +gCEBgH/cwCEEA0e5IKAD6jN5IKDgfqHB8cDhxazBANlKwW8hQwBIwc9zgAC8zSCDBCCNDwEAAMCG +If4DJLkOuQslQJBOwI7CFvLXdQAAAEDMJYKfAAAAgMwlgp8BAAAABPQhgwPwIoOuuK+4sLgFeSCi +DsMIwIt1BCOBDwEAAMAuuUApAgZFeEjAiiAGBknAQcOpcADaSgkgAAHbz3GAADgcGoE7gSR4Jwge +AgrAC8GEKAQOACGAf4AAGOUCuQjgNHkhYM9wpwCISS+gJg7gA6lwCNx3A+/0rMChwfHA9grv9Ahy +rcEI2ErAbyBDAEnAz3CAALzNoIAEIY4PAQAAwIYl/hMkvQ69CyZAk1DBkMMW8td2AAAAQMwmgp8A +AACAzCaCnwEAAAAE9AGAA/ACgK65r7mwuSV4AKMQwwnFBCOBDwEAAMAuuUApAAYFfUnFHwqeAQrA +BCO+jwAAABhFIMAASsAF8oUgEAFKwCUKHgGbvc9woAAsIAWAANsCuG64gODKIMwAybileEnABvAJ +Ch4Cnb1JxRDAgcVCwKlwQgggAALbA8gMws9xgAA4HLkYggAagTuBJHgbCB4CArrPcIAAIOVUekFg +z3CnAIhJL6AiDeADqXAI3GsC7/StwPHA8gnP9KPBYYAIdUDDANgKpW0LXgIEI4APAQAAwC64z3KA +ABxpCmJJIoIAYbpLpRJqFHjHcIAAEObKgM93gABUz8alC4DPdoAASCQFpcOGIMDUhvWPBH7kfgm+ +QCkPAuV+xXgEI4MPAAAAEGV4B6UIhRjinrgIpUulj/A3Cp4Cz3CAAGRdAIBBwELAIQgeAoYg/wkj +uAHgFQiUAAsIkQAG2GHAJPAH2GHAIvAiwGHAHvBBw89ygABUCUCCRoKeEgIGKwqRAQQjvo8AAAAY +D/TPcoAASCREgkiCBCK+jwAGAAAF8gHYCqUD8AqlANgBxkEOHhJCxiLCoOLKIiEABCaPHwEAAMBB +L4QTRCYPFiO/AecEJo4fBgAAADG+ACbFE892gAAcaTImDhECJk4RE/BTJsIQz3eAAABtXXpKZwQm +jh8BAADALr7Pd4AAHGnOZ2G+1npLpRMLHgIgx892gAAkae5mAvAB3oQoBA4AIYB/gAAY5QK6VHpH +YGG+WGDmpQGABCODDy8AAN0mu8V7UiPDAwWlZ6XPcIAAvM0DgADfHQhOAM9wgACAXQCAFQgeAIYg +fw8deEAozwME8ADfj7+b7892gAAEMCCGYHkA2CUIEAMghmB5ANgZCBAEIIZgeQDYEQhQBCCGYHkA +2AsIkQTCDm/8ANgIhQV/6KVdAO/0o8DgePHA8g+P9M91gAAgMACFxJDJcC4KoACGIPwDAIXJce4J +YACGIfwDz3OAAJjPCwiRBiGDgLkho0qDAeJKo89zoADEJ5ETAYbDuRsJgQCKJQgQExtYg5ETAYbD +uQsJgAASG1iD/QeP9OB48cCCD6/0ANjPcaAAqCAogc9xoADUCziBz3GgAMQnUhEChhURAoZCEQOG +EQueBwHYz3GAABzPYbFRIsCAGnDKJWIUEvRRIMDGyiWiFAz0z3CgANAPIBABhh8QAIYQcQDdyiVi +FekNERDPdoAAHM8fhssIHgSoFgEQlNhOD+AByXLPd6AA0A9RCBAgz3CAAHwKIIDPcKAA/CXPcoAA +sMyM6TOACoIZYSqiz3IA/wCqiiCIBQzwE4AkkhlhMHkksoogiAXPcgD/AP/uDo/9AJYKDe/9NJaU +FwAQz3KAAKw+AdkZ6G2CAeNtomuCeGALos9wgADoIiCoH4YPCJ4Dz3CAADQJIKAH8A8I3gPPcIAA +OAkgoM9woAD8JROAbIJ4YAyiz3IAoAgA7HBAoG8iQwDscECgDh9YkPIJQAXPcAAA/3/PcaAADCQB +oRvYBKGZBq/0qXDgeOB/AdjxwOHFocHuD2/7i3Cy6AAUBTAdDR4AfggAAM9xgAAcz0OBz3GAALiz +QaEk8AsNngB6Ds//HvANDV4CCg7P/xrwOw3eAAjYz3WgAMQnEx0YkGoPwAAdCBAFAtg8HQCQz3CA +ABzPI4DPcIAAuLMhoBnYlwhQhjEGr/ShwAohwA/rchfYjLiKI8cAFQLv9Yokgw/xwOHFz3CAABzP +P4AEIYEP//+POAQlgF8AAHDHJXjPcYAAHM8foUQiAFPPdYAAHM9DCBECPw1eUTYPz/+cHQAQEw2e +U89wgACcJAWImB0CEBTwFQ3eU89wgACsJxmImB0CEAzwA4WuCO/1JIWYHQIQBPAA2JwdABCcFQAQ +gODMIOKAcfLPcIAA4BgLgA/oz3KfALj/HaLPcYAAzCIEgQHgs7i1uLi4BKEWos9woACoIAiAH4UP +CB8BCw3fUoDYmB0CEJgVgBBAKAEGEwjfAYK5HQqeU8oJwAEa8B+FUSKA07O4H6XFIYIPAAAAB0Uh +AAbPcYAAqM8siYYh/Q9SIcEBRbkleM9xoACIJBChiiDWAM9xoADEJ34ZGIDPcKAA1AsB2lKgBNgQ +GRiAz3WAABzPH4VJCJ4BFJVBCF8Bz3CgACwgD4Ca6K1xEg2v+VYlQBWAFQAQlLiAHQAQH4WQuB+l +DPDPcYAAMD4PgQHgD6EQ2c9woACQIz2gnQSv9BnY4HjxwBoMr/QA2Qh2AYDBuIPgyiBBIAXyYg4g +AMlwGnBMIACgxPQQhlEggIHA8hCGz3WAABzPDwieA89wgACcJAWIDfAQhg8I3gPPcIAArCcZiAXw +BYYmhj4Pj/WYHQIQgBUAEAQgvo8QcAAAB/StcW4Mr/lWJUAVEYbPcYAAHAoAoUEoAQNTIcUAmBWB +EEEoBgUUaQUgRAEPCd4BHoWVuB6lefASDW/7TyRAAusIFQTPcYAALKiYFYMQ8CEBAEArAgaGI/0P +UiPDAUW7ZXrPc6AAxCdBG5iAANqMugImTwD6Ysu613IAAAAIQC0PA5C/UvcFJ48RYhvYg4wiAoDH +989xgACkPxKBAeASoQDZnblF8OV5YhtYgFkOhXAAAMAPDiKDDwAAABDPcoAAjKcWeiCCJQs1CAQS +BQAA2A8gwABhuE4jDwgBKcIDeHkFeQAtwAAFehfwQiMDCADYDyDAAGG4eHkFIQIAiiH/Dwvwz3OA +AKQ/E4OKIf8PKHIB4BOjAdjPc4AALLQAqwIbBAEho0KjvfEA2Zy5gBUAECV4gB0AEEAmABKgHQAQ +AtnPcKAA9CYjoCWGz3CAALizIaDBAq/0CnDgePHASgqP9Ah2VSBQBA3MosHtuNEgYoAH8gTIig6v +/5gQAADPcIAAmM8MgM9xoADIH2TgHqEQ2A6hAdgVGRiAAYaD6P8LHsABhsG4g+Di9AAQACBBwAQU +ADFBKBEDEIYGFBMxhwieAQ3MgwjeAhCGz3eAABzPDwieA89wgACcJAWIDfAQhg8I3gPPcIAArCcZ +iAXwBYYmhjoNj/VRIMCBmB8CEAHdCvIehwDdlbgep4ogBQkOC6/7qXGYF4AQz3GAAHS2BLhGkQUg +QAQVCIAAz3KAAKQ/CYIA3QHgCaIEkSUIgQ8AAP//AN0M8M9wgAAwPi2AAN0B4S2gxgqv+4ogBQwB +lpzghvQEEBIgCBAPIM9woAD0JgLZI6Ajhs9wgAC4syGgkgsgAMlwgOCA9CTtz3KgAMQsHBqABM9x +gACoz+iiLIlAKQMjELmfuWV5QSsDIWV5JqINEgE3HQneAhDaq7kMGpwwDRpcMM9ygAAoPyeCAeEn +og0SATcNCR4DGtisuQ0aXDClDRAQz3WAANyY4BUDEEWGRCs+BwAlQR5AoUyWAeNCsc9ygACoz8yK +4B3AEM9ygAB0tsipCRlCBAoZxAQMGYAERJLkoUApAyMQvkErDSHFe6V7SrHPdaAAwC9HHdiQlOLA +IoYPAACTAM9zoABoLPAjggBLsY8VA5YH8KMVApaPFQOWEQofAfcL3oEH8AjYDPDnu8ojIQBAwwEU +gjDGu8a6WKl5qXkAr/SiwOB48cDhxc9xgABIJCOBSIFZCh4AhiD/Ac9ygAAcaUO4CmIA24DiyiHB +D8oiwQfKIOEHzyAhA8ojgQ8AAG8AyiTBAFgEofXKJSEAz3CqAAxQEwq0ALmBgL25oQHZJaAE8KC9 +uaFloD0Aj/TxwMYPT/QIdQ3MUyBAgAfyBMj6C6//mBAAAAGFwbiD4MomIRAF8vYJIACpcAh2ww4R +EBCFCQifAQDZTvAMzIMI3gANzFMgQIANEgI2IvQAIoAPgABUzgHZz3aAAPw8IKgRjlEgAIBsC6ID +yiBCABGOIQheAc9wgABsPAOIiuiKIBAPE9miCK/7i7lGC6ABBNgQ2AwaHDDPcYAArD4XgQHgF6ED +yA0SATaEEAIBz3CAAEjONXgpgFlhKaAa3r7xz3CAADA+LYAB4S2gXgiv+4ogxQkB2c9wgADoIgHa +QKjPcIAAmM9OgAaCAeAGogLwAdkC2s9woAD0JkOgQ4XPcIAAuLOA4UGgLAyCAikHb/TJcM9zgAAc +z1gTgQAA2o7pPJNiuRC5RSFDAc9xoAD0JmOhz3GAALizQaHhAAAA8cCKDk/0CHYBgMG4g+AA3QXy +zgggAMlwCHW17RCGTwieAQzMz3KAALQ9MQheAUDYDBocMFUSAAbPcYAAzM0B4FUaGAANyADaFHkD +yECpggqv/5gQAAAL8KwSAQAB4awaQACKD2/7iiAFCs9wgADoIgHZIKjPcIAAmM8ugAaBAeAGoQLZ +z3CgAPQmI6Ajhs9wgAC4syGgYQZv9Klw4H8I2PHA5g1P9Ah1KHcklT4Pb/uKIMQLQS8OEcO+z3GA +AMBv1nkTDhASAZVBgQTgUHAI2AT0IIFgealwFQZP9M9xgACYzyyBz3KgAMgfZOE+ohDZLqIB2RUa +WIAhgITp/QsewCGAwbkhCdEAz3CAAOgiAdkgqM9wgACYzy6ABoEB4AahANkN8CGAUSEAgADZyiHh +BQGAUSBAgMohoQTgfyhw4HjxwEoNT/TPdoAAmM8BhgQgvo8AcAAAOfIvKQEAz3CAAKQ89CBNACuG +TyWAEFoNoAFJhpTojCUDkM9xgAC0PQj0uhEABgHguhkYAB/wuREABgHguRkYABnwAYYhCJ4Hz3GA +APw8DIlPiRsKAAARiVEgwIAACgECB/AA2c9wgAAstCCoZggABTEFT/TgePHAugxP9Ah2AYDBuADf +JwjRAM91gAAcz48PERAQhncIngEQhhkIngPPcIAAnCQFiBLw4g7v/8lwCHft8RCGEQjeA89wgACs +JxmIBvAFhiaG3g9P9ZgdAhARCN4BHoWVuB6lH4WXuB+lgBUAEAQgvo8QcAAAD/ScuIAdABAwhvoM +b/lWJUAVQCYAEqAdABAA2AW2AdnPcIAA6CIgqLQVARAGgQHgBqFYFYAQmegiCw/7BegQhu24AdgC +9ADYz3GAAH7P9CEAADyVOGBiuBC4gLjPcaAA9CYDoQbwAtnPcKAA9CYjoCWGz3CAALizIaA1BG/0 +6XDxwMILb/QA2Qh1AYDBuIPgyiBBIAXyCg7v/6lwGnDPcKAALCAGgBB4TCAAoM92gAAcz8onIhBW +9DCFZQmeATyWEwkDACWFz3CAALizAoC3CQEAEIUPCJ4Dz3CAAJwkBYgN8BCFDwjeA89wgACsJxmI +BfAFhSaFxg5P9ZgeAhCAFgAQBCC+jxBwAAAK9E4KD/sL6BCFEwheAwHfCPAA3xjwyg7P+xTwAN8w +hdoLb/lWJkAVgBYAEKgWARCeuIAeABBAJQASoB4AENkJXoIB2c9wgADoIiCotBYBEAaBAeAGoVgW +gRDPcKAA9Caa6c9xgAB+z1yW9CHBA1lhYrkQuYC5D/C0FgEQC4EB4AuhtBYBEIogRQsWDG/7K4HC +8QLZI6Alhc9wgAC4syGg/QJv9Apw8cCaCk/0z3CAAOAYC4AQ6M9ynwC4/x2iz3GAAMwiBIEB4LO4 +tbi4uAShFqLPcKAAqCAIgM92gAAczxENnlPPcIAAnCQFiA3wDw3eU89wgACsJxmIBfADhrINb/Uk +hpgeAhAfhhMIHwEPDV9TCw1fUoDYmB4CEJgWgBAbCN4BX4Y+hrO6lbmXuj6mX6YA2QHdFvCcFgEQ +JQlRAD+GUSFAgs9xgABIJCOBKYEF8kQhDQQF8EQhDQID8AHdBNkYuCV4z3GgAIgkEKEfhjMIngEU +lisIXwEWDcABkejPcKAALCAPgAXoDcwXCN4BH4aQuB+mrXFiCm/5ViZAFZvtCwqeU5YOQAEV8EQi +PtPPcYAAHM8P9AGBGwgeAJgRgADPcYAAkNoCuBZ4AGH+uHQKgvvPcKAAUAwAgM92gABYCgTZz3WA +ABzPAKbPcKAAkCM9oB+FDQjfBA+FgOAA2C/yTXGeCm/7iiBEDjeFihUCEQCGBOIZYQsIn0T/CR7G +z3WAABzPmBWAEOe4ANsJ9AK4z3OAAJDaFngDYy27wLuKFQARTxWNEM92gABIJPAmwxBCeaJ45g1v ++0+TUQFP9OB48cDhxaHBANhAwM9xgAAwPg+BAeAPoQPZz3CgANQLMaDgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeDGgz3WgAMQnFRUAls9xnwC4/xahMRUAlhahENgQHRiQPgov+4twl+gA +FAUwGw2fAAohwA/rcg3YjLiKI18HzQRv9Yokgw8E2RMdWJAb2RYdWJDBAG/0ocDxwM9wgAAEtMIL +r/UY2c9wgAAEpLYLr/UY2dHA4H7gePHAHghP9Bpwz3WgANQLEIUA36HBQMchCFAACiHAD+tyD9iM +uIojlgiKJIMPZQRv9QolAATPcKD+PALPdp8AuP8WplgeABTPcaAA/EQZgQQgvo8AAAggA/QdgRMI +0CSKCS/7i3CA4MogAiBCIMEglOFsAQ0AMiZBcIAAAGRAJwByNHgAeM9xgACYz06BCIIB4AiiDoEI +gBam9gvAAADZKHBJ8M9ygACYzy6CB4EB4AehDoIHgBam9PHPcoAAmM8uggyBAeAMoQ6CDIAWpujx +z3KAAJjPLoICgQHgAqEOggKAJvDPcYAArD4FgQHgBaEg8M9ygACYzy6CA4EB4AOhDoIDgBamAdkA +2BXwz3GAAKQ/GoEB4BqhFqYaC2ADAdi+8c9xgACkPxSBAeAUoRamAdgIcYDhrAuCAM9wgAAczx+A +FQjeBM9wgABIp+uoz3CAAHyk7LAD2BGl4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgR +pQkHL/ShwBiGz3KAAJjPkLgYphiGsLgYpi6CBYEB4AWhDoIFgBamTggAAMXxz3KAAJjPLoIEgQHg +BKEOggSA8/HPcoAAmM8ughGBAeARoQ6CEYCw8c9xgACsPg6BAeAOoZXxCiHAD+tyQdiMuIoj2Acg +8fHANg4P9M9wgACYzwyAz3agAMgfEN0B32TgHqauphUe2JPPcaD+5AHPcJ8AuP82oF4I4AQJ2APY +HqauphUe2JMF8E4JL/uKIFUOz3CgAAwkB4AE6O8LHsBFBg/08cDPcIAAYBlaCa/7Adlv2Aa4Egmv ++wjZB9gKuAYJr/sF2dHA4H7gePHA4cXPcYAASCQjgSmBUSFAgMogogAn9ES4z3GAAJQ8w7gJYQkJ +HgA1DZ9RNQleAM91gABIJAOFGIghCFAAigzP+gjoz3CAAJAnCIgNCNABA4UYiA0IkQAJDZ5RAdgD +8ADYyQUP9OB48cBGDQ/0RCIQU012hib8E01wTXAEJYBfAAAAIEEofoME8j4Mz/qE6ADfA/AB3891 +gAAczx+FCwheBADdmvD/CBGgHgzP+h/oz3CAAJAnCIiH4MwgYoIX9AGFjCD/jxP0JJXPcAAA//8b +CQEABYWMIP+PCfQMlddwAAD//8olYRB48s9wgABIJPAgwQMJgQ8IXgHPcIAAxGkE8M9wgADQaTiJ +KmBBLgARz3GAANxpCGEWes9wgABAcEhgDwgeAD+FhiH2jxXyDQheAD+FIwmeAgkIngAJDR5SAd0M +8BMI3gDPcaAADCQxgYwh/4/28wDdUSCAgcolIhBmC8/6B+gEJb7fAAAAIsolYhAn7c9xgAAczx+B +HwgeAowmApDMJoKfAABQAMwmgp8AANAAA/STuB+hz3CAAEgkAoDCEAAGGuiMJgKQzCaCnwAAUAAS +9E+BRXgPoQ3wz3CAAEgkA4AJgA8IXwCMJgKQBPQJCJ4BAt05BC/0qXDgePHAxgsP9M9wgADgGACA +osEA3hDoz3KfALj/HaLPcYAAzCIEgQHgs7i1uLi4BKEWos9xgAAcz96h36HAsc+hTxmCA4AZgAOM +GYQDgNuYGcIAhBmAA89yoADIH6QSAAD4Eg0ArBmAA0IZhAOieLAZAADPcIAAWJnZoM9wgADUz8Cg +BN3PcIAAHAqgoJkRgACguJkZAgDPcKAAxCdkGJiDz3UAAP9/ExhYgxvdFhhYgxoYmIOKJ/8fz3Wg +APxE/aX5pYonmB3PdaAAUAzipXGicKI8GICDiiMYCG6igBIDAKQZgANRI0CAz3OAALizWBmCAwvy +QhAAhgQgvo8AwAAABfIBgwPoAqPBo4AagAPPc4AAtD3PcIAASCRDgDUJnkMfgYu4H6FVI8AFtBkA +AArYHLEbkpYZBACKIEQL/gsv+wDZBtnPcKAAyBwpoBDwQCMAA7QZAAAQ2ByxGpKWGQQAiiCEC9YL +L/sA2c9xoADUCxCBHQhRAAohwA/rcgvYjLiKI9UAiiSDD70GL/W4cwHdsKEVCF9Gz3CgAKggJoAH +gLsCIAAD3c9wgAAcz7QQAQAAgQHgAKH62EoKr/sA2SDYz3eAAPTPxgwgAwCnAdjPcaAAyB8Toc9z +gADsIgiDQCcQFUCADIMAEAQABIPPc58AuP8AEAUA+BEAAM9xoAAwECGBNqPPcaAADCQngQIiAoA2 +owDZAyRDAAIlAQDPcIAAHM9QGIQDUhiEA1QYhAMjp89wgABIJEGnI4BipxSRz3KlAAgMCbcIgcC4 +CLcAEgQAz3KAABzPUyRFAUwaQgFTJEIAg+LKIcEPyiLBB8ogYQXKI4EPAACcC8wFIfXPICEDBCSD +DwAAAODPcoAAHM8tu5oawgBfghQfABEZCt4CBLuBu2V4CLcH2AfwFSAMIMCkA/AE2AHg9QgUggiB +67hwD8IEz3CAABzPH4AruFMgEABRIIDFqvLPcYAAlCoGgQHgD3gGoUEpgEPPcYAAlCpGgc9xoAC0 +DzeBwLgA3RUKQQDPcaAAqCAmgYwhg47E9wPdoPAJCAAEBN2c8M9zgAD0zwWDz3KkAJBB9YI2ggQg +gA8AAADgLbjno892gAAczyijDQgeAFAexBMJ8FAeRBMEJ48f//8AAOejDwheADC/Uh7EEwXwUh5E +E/B/56MNCJ4AVB5EEAnwVB5EEwQhgQ///wAAKKMNggajBCCADwAAAP4puFYeBBAfhkcI3gLPcKoA +AAQEgAmjz3CAAASkIIhEaDXpYQl0AAIQhACfcQDYqCCAA/QiDwAV3RO98CXPE891gAD0zhV9AeDg +pRzwz3CAAAS0IIhEaBnpAhCEAIDhyiRNcMogLQDoIK0D9CIPACndEr3wJc8Tz3WAAPTOFX0B4OCl +IasCGwIBtBYBEALdAYEB4AGhFvAEIL7PYAAAAAj0iiCFBwYJL/sMEgE3bvERCx5AiiDFB/IIL/sA +2WLx3grv+vHYgeU98zENkRAC3QQgvs+AAQAAyiWiEQX0USMAwMol4hDtDZCQz3CgADAQA4CA4Mol +YhGG5TQEAgDPdoAAHM8clkIghAAfhuu4LyQIAXzyz3CqAAAEooDPcaUACAwggQQlgh8AAAD/KLoE +IYEPAAAA4Im6O3tFe89ygAD0z3KmrKJtoiCASBaPEJTnKqIa8gX2NQ+REiO5DfAfD9Ad7ucS9EUp +/gJBKcFwUSXAkcIhYgAH3QrwRSn+AkEpAXH78SK5+fEA2QjdAYA3pguiPLIdCREFz3eAAEgk44fo +hwQnvp8ABgAABPKMu3Km5LjKJSIS4bjKJSEShiD+D0EoAwFNHsIQCJJleAiyKw3RESUJtAMH3c9w +gABIJAOAhBAAABEIRADPcKAAMBAIgAcJAAAI3YflyiABAZwOYfvKISEAKQMAAM9wpgAIBAGABCCA +DzAAAAA0uEIeBBBCFgERGwhfRs9woACoIAiAGWEweUIOb/uIcATwYg5v+4hwBCCAT4ABAAAA2TMI +gQ8AAQAAAdhOHgIQz3KAAPTPmhaAEEIeRBBNHkIQN6YpogS4KJKJuCV4CLJy8E0eQhDPcKYAjAM9 +gAQhgA84AAAAQSjCBJoeghAEIYIPAAAA8Cy6JbhFeM9ygAAczxKmCwjeRxKCjLgSolMhzgJIEoMA +16Lgu9Eh4ocH3QL0CN3PcIAA9M8poJoSgQDokAS55XkosNywMoItoH8N0RHPcaYAjAO9gQQlgR8B +AAAAMLlOGkIAqaBOEoAAHOhZC1EDUQgfRhTYz3GgAMgfHqEQ2A6hAdgVGRiACt1RIADGyiXiEVEj +AMDKJSIS8w2QkhXwJQ6UE89wgABIJAOAhBAAABUIhAPPcKAAMBAIgAkOARAH3QPwCN2H5eT0z3aA +ABzPThaAEIDg3vLPcqYA1AQsEgGANBISgDgSD4DLEhAGSnDGuOlyhiL9Dwa6RXhKcoYi/Q8EukV4 +BCGCDwIAAAAnukV4RCcCHA26RXjpcoYi8w8EIYEPOAAAAA66JblFeCV4RCeBEBS5JXiIuEQnARJB +KcGAUiBABRKmWB5CEMohgg8AAP//yiGBDwAAEB86cTeGQB5EEAQigS//AwD/KLk3puoIL/kA2qwe +ABBzD54USBaDEDKGoOPRIeGCMfIEIYKPAAAAAQfyRCENBiO9AeUXDZUQBCGNDwAAACRDDYAfAAAA +JAQhjQ8GAAAAMb0vDdUQEw2REBPqRCENBiO9AeUfDZEQBOrM4wv2V4Yycsoijg8BAIgNzCCOgM33 +Fw4FcAEAiA3PcYAApD8cgQHgHKEI3TLwhiH/CUEpzQDPcIAADDAggAHlYHkG2C0IRAPPcIAASCQD +gAiABCC+jwAGAAAA2cohYgAShgQggA8AAAAIK7gTCQUA8gwAAAh1lODKJeITCvDPcKAAMBAIgDeG +EHEH3colYhJYFoIQz3GAAPTPCJEHuoi6RXgIsReGMBkABByxEobroQ2hrBYAECgZgAQdsQsN0RFm +CAAACHWA5colIRCA5egKov/KIEIDANjPcaAA1AsQoc9wgACozw2IEQgeAM9woACIJB6ACxocMJIO +QAAMzIYg+Y8K9ITlzCXikAb0ANiPuAwaHDAy2c9woADIHCqgCQPv86LA8cCyCs/zz3CgANQLGIBC +IAAISCAAAM9xgACUKiWBgeGKIZkOCPTPcYAASCQjgT6BgCGZDhBxAN3KJW0Ucw0REM92gAAcz1gW +gBCA4MogIgAh9AwSATclCd4ADcxTIH6ADPLruBeGBvKg4AHYwHgJ8I7gAdjAeAXwJQlfAQDYz3GA +AEgkI4EpgT15UiEBAMC5JHgI6B+GkbgfpgvwF4bq8VoMAABYFoAQgOA0CwEAgOV0AgIAz3WAABzP +WBWAEBToAtnPcKAA9CYjoM9xgAC4swDYAaHA2ZkVgBCAuJkdAhAocAPwQtjPcaAAxCe/GRiAANgM +GQCAAdgQGRiAH4XxuBICAgAShTeFWg7v+ADarB0AEB+FtQjeAs9wgABIJEOASBWBEBSCJHhEIAMB +RCEADEIoBAGAc89wgAD8JMG7aGCJuBylcBWOEPSCTRWAEMR/hib/EwR/RL7fZ892gAB0afQmzxNi +HcQTz3eAACAoa2eJu32ldIJ0FY8Q5HuGJ/8TBHtEv/tj9CbDEGQdxBByhXqlVIJ7pUR5JHjPcYAA +hGmAcPQhAgDPcYAArGn0IQAAjh2EEJAdhBCSHQQQlB0EEADYTh0CEJnwThWBEM9wgAAsPACAwLip +CRAAgOAA28ogIgAL9HKFSBWAEAQjgw8AAAAIe3vCuAAgjg+AAPAkMI7YjsdwgAAcKM93gADEs0iI +ZX7cpXAVjhBlecO+3H70J44TZXoQiGIdhBMFe32ldBWAEMO4HHj0JwAQOqXPcYAA1LNkHQQQaBWA +EMO4HHj0IQMAW6WOHcQQz3OAABy09CMAAJIdBBBsFYAQw7gcePQhAQCQHUQQ9CMAAD3wgOAA2AX0 +SBWAEMO4HHjPcYAA7CQJYc9ygADEszylcBWBEMO5PHn0IkEAYh1EEM9xgAAQKAhhHaV0FYAQw7gc +ePQiAADPcYAA1LNShWQdBBBIFYAQw7gcePQhAwBapc9xgAActPQhAACOHcQQW6WQHcQQkh0EEJQd +BBBuD8AAz3CAAEgkA4AIgA8I3gJOFYAQgOA4DIIEWBWAEAXobgkP/wPwIg0AAAh19Qev86lw4Hjx +wOHFz3GgAMQnFREDhgTYExkYgBvYFhkYgAPaz3CgANQLUaDgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeFGg5LvKJaIVKfRSEQCG4LjKJeEVI/ILCF4ACwveABLdHfAB2c9wgADoIs9ygAAc +z7QSAwAgqAaDAeAGox+CEQieA89wgAA0CSCgCPANCN4Dz3CAADgJIKAV3YogBAxKCO/6ANlVB6/z +qXDgeMHYFBoCMM9xgABIJAOBGIgB289ygAAcz4bgF4LCI8EADOAYIMAAZhoEAGYSAAED4AQggA8A +APz/nbifuOxzAKMFyOxzAKMDgRiIN4KG4AHYwiABABghAQDscCCg4H7gePHAdg6P889wgAAczzKA +JwleAs9xgABIJCOBSBCCADSBRHlRIYCASNrKIoEPAACQAALwDtoA389xoACoICeBrBANAFlhsXHC +JUUQyiXmErB4Ug4v+wrZz3CAAMg3AJDPdqAAxCcLCB4BjCUDkgP3AN0a8CIOIAEA2M9wqwCg//qg +ANjuCu/9jrgZFgCWBOgC2BAeGJDPcYAApD8bgWq9uGAU3RuhGRYAlofoUSEAxiAIYQTKIGEAKQav +86lw4cXPcYAA9M9BicDbFBrCMM9zgABIJGODEmpH4AQggA8AAPz/aYMqu8C7F7vHcwAOAABleOxz +AKMFyOxzAKNKJMBzANuoIMAB8CHNAOxwoKAB4x0KdAAA2c9wgAD0zvAgQwDscGCgAeHxCYSAANnP +cKAA1AstoAvMAeAQeAQggA8AAP+/j7gLGhwwz3GgAIgkHqHgf8HF4HjxwCINj/PPd4AAHM9Alwh2 +SHGGIfwDQikFAUQiCAOMFwERQiiIEEDYz3WgANAPCiNAgBAdGJDKI2IArBcAEEArhgXPc4AA9M8v +JAgAHbM4EwcBQCwEBAUnAAEMHRiQYYsCu0jjEB3YkGYXAxF5YTB5Zh9EEA0KnwIOl1MgwIAR8s9w +gABIJAOACYBRIACAPdjAKOIFyiChB8AoIQYJ8EAoABGgcM9ygACIIwhiF7gD4QQhgQ8AAPz/BSCA +ASV4nbifuAwdGJALzAHgEHgEIIAPAAD/v4+4CxocMA4dmJMgFQCWz3CAAEgkA4AIgCEI3gIdDh8R +BgmgBMlwz3CAADDQoNnE2j3bfgggARe7fQSP8/HA4cXPcIAAQAoAkM9xgADEvajaAd2AIEQLEHhy +Dy/7qXOA4MohwQ/KIsEHyiCBDwAAtRTKI4EPAADMAMokIQBAAOH0yiUBAaYIQADPcIAAjDE5BK/z +tKDxwNYLIAEA2GIOj/ceCg/+zgyP+wDYngjv/Y64/9nPcKsAoP85oDig0cDgfvHA4cXPcYAASCTw +IQIASiRAAMMSAQYPeDIigg8AAB8DBCGDDwAGAACA4wHbwHsEIY0PQAAAANd1QAAAAMIkAgHWDq/7 +wLnBA4/z4HjxwEYLj/OuCOABCHXPcYAAHM8fgbC4H6HPcJ8AuP9YGMAIz3OfALj/WBsACM9yoADQ +DxCCz3agAMQnFqPPcIAAlCoGgBajGRYAlgDZBOgC2BAeGJAYGliAxg+AAPYOoAIB2AXtSg8AAAXw +Kg8AAF4LD/sZFgCWBegC2BAeGJA1A4/z4HjxwM9wnwC4/1gYAAjPcJ8AuP9YGEAIz3CAAHQZag7v ++iPZxgxP/9HA4H7gePHArgogAQHYANnPcIAAKD8uoNIJ7/UZ2NHA4H7xwG4Kj/OiwYt2Mgxv+slw +CiUAkBn0z3CAABzPz3GgAAwkO4FXgDByyiUiEiCGDQkeBALZjBhEAAQlgl8AAHDHP4BFeT+ggOXE +AwIAAMDpuNbyz3WAACAwAIWKIQgA5JDPdqAAxCcTHliQz3GAABzPP4E6d4Yh/COFCV4EQSkBIcO5 +z3KAAMBvNnoggkB5CHUZFgCWBOgC2BAeGJDPcAAA/38THhiQG9gWHhiQA9nPcKAA1AsxoOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaDPcIAAWJkZgIDgZA/CAJrlJAMCAM9wgACI504K +4AIA3RUDAADKC2//KnAacACFjgsv/ypxJgwv/wh3iOfMJ+KVyiXBEyvyGwgQIPYKIACBwAolAJAc +9CoM7/8BwBjwA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaAA3Q8P +kRbPcIAAiOfSCcACgOWYAgIAbg8AAc9wgAAczx+AEQieAwHZz3CAADQJIKAJ8A8I3gMB2c9wgAA4 +CSCgERYAlgDdQcAxCJ8Ajgpv+oHACiUAkBD0BBQFMB0NnwAKIcAP63IK2Iy4iiPHChUFr/SKJIMP +gOU0AgIABNgTHhiQG9gWHhiQz3CAAFiZGYCA4FAOwgAVAgAA4LjG8s92gAAczxKGhiA6AIwgBILU +DgUBz3GgAAwkPIEXhiJ4ZLgQeIoeBBBEIgBTFwgRAh+GDwhfBFElQNEB2AX0ANgD8O4KT/+cHgAQ +LuiWDQ//CiUAkNz0DcwhCN4BH4YdCJ4BLyCHCowgAoYI9M9xgAAczx+BmLgfoZ4JIACBwAolAJDG +9M92gAAczx+GKwgeBKgWARDU2CII4ADJcgfoegsABAvw+g4P/7Hwz3GAACBAHoEB4B6hAd/PcIAA +6CK0FgEQ4KgGgQHgBqEfhvO4eA2C+g+GgOCEDIL6H4YRCJ4DAdnPcIAANAkgoAnwDwjeAwHZz3CA +ADgJIKAA2M9xoADIHAehMNgKoU4K7/8BwIoghA3KCK/6AcEfhikIHgYQ2AwaHDDPcIAAiOcWCMAC +DcgAIIEPgABUzh+G4Km4uB+mAJaGIPwAjCACgBv0Tg4P+pfoA9nPcKAA1AsxoOB44HjgeOB44Hjg +eOB44HjgeOB44HjgeOB44HjgeOB4MaAAlkYNr/w0lkTwQcAV3wkI3wDpdSDwCNjPdqAAxCcTHhiQ +YgjP/wh1LQgQBQLYPB4AkCEWAZbPcIAAuLMhoBEWAJbRCJ+Adghv+oHACiUAkOLzPQ1RFc9woACQ +Ix6ABBQEMFEggIDKIcEPyiLBB8ogYQLPICEDyiOBDwAA5AToAqH0yiUhAO4Or/+IcAh1qXDBBm/z +osDxwGYOT/OhwQh2ANhAwACmFghv+otwCiUAkIX0z3CgAAQlIoAAhgQhgQ//AF//BSECAECmUyGC +AFMggwBleqUK0QHPcIAAHM8fgHkKnlO3CJ8GBCC+jwAeAAAE9ACGCfABCp9AAIYLCh5AhbgAps9y +gAAczz+CEQleBoi4i7iOuACmQfApCd4GTyABAom5jbmLuY65IKYeggQggA8CAAAAUiBABCq4JXgA +pi3w/LnFIIIPAAAABeT1hSAcAACmI/D1uACGH/KGIBwAhSAYAACmAQofQQCGLwreQIa4AKYT8FMh +AwBTIAIABSO+gMol4RUJ8oYhfw+GIH8PBSE+gMoloRTPcIAAqM8MiMS4QCgBBgCGJXhRIIDEAKag +D+IDyiAiCKlwrQVv86HA4HjxwOHFAN0F2Au4Wg3v+qlxCg9P9M9wgAAczx+AFQjfAsUNFRHBCF9F +nwgfRQHlTvAA2Zy5z3CgANAbMKAB2c9wpACYQDygBdgH8D4JAAB2D+ADBdgB2G4PwANjDRURBCC+ +zzAAAAAB5colIhAtCx9ACQheRUcJnkMzCB9H2QjexdUJnsPPcKoAAAQBgIYgPwsA3bsI0YAT8O4I +AADPcYAAKD8OgQHgDqEJ8ADZnLnPcKAA0BswoNIIAAAA2c9wpACYQDygEPAA3Q0LH0D2DuADAdio +8bIIAADPcYAAKD8OgQHgDqHJBE/z4cUMzEQgPopI8lcI3gCA2AwaHDANzM9xgACsPs9yoP5YAc9z +nwC4/wDdEQjeAh2BAeAdoUhwB/AVgQHgFaFAIgANFqMNzA8I3wDPcKAALCCvoA3MhiCCAg0aHDAe +8D0IXgGKIAQADBocMM9xgACsPhSBAeAUoQ3MANlGIIACDRocMM9woAAsIC+gz3Gg/rgBz3CfALj/ +NqDgf8HF8cDOC+AAAdiSCK/zA9gmCAAAvgvgAAHY0cDgfvHA5g/P/14Oz/8WDM/60cDgfuB48cCG +C0/zz3GgAPxEBYEA3ry4BaGKC+AAyXAD3U4Ir/OpcM9xoAAwEKKhz3CAAJQqoqHBA2/zxqDxwM9w +oAC0DzeAz3CAAJQqBoANCQEAtg/P/wTwmg/P/9HA4H7xwB4Lb/MA2QfYGnE6cADeQCgAIRR4x3CA +AMS9FSCNAwCVjCACjQDfhPaMIIWCyfb/2AC1iiARA1IMb/r/2QGdCwhTD4wgP4FH9uG1iiARAzoM +b/oA2QHmz365DhKTQiFAIEAgQSCnCHWAL3kRA0/z8cC6Ck/zAN3PcIAA/LK+CS/6tKgS6AjegOXM +JaKQzCUikcwlYpGoDWL+yiBCA2G+6Q51kAHlHfCKJAFxz3GAAMzNqCCAAQQZUAPgeADZSiQAcs9y +gAB4zaggwAIWIkAAYpDPcIAARM40eAHhYLDPdYAASCTPdoAAQLNAJQAXJG5aCGABBtpAJQAVQCaB +Ek4IYAEG2kAlABdAJgEUPghgAQbaLBWAECEIEQGKIA8Kbgtv+oohWwU8FYAQ8gpv/i2Fdg6P+Q6F +FwheAYoghw5OC2/6iiHbCJYIQAL+CA/6gOCMDsL/z3EAAP//z3CAAMzkLKDeCi/6K6AtAk/z8cC+ +CW/zFNnPdYAAQCjY3DINr/QCJQATz3CAAIwqJg2v9BTZz3aAAEgkQCYAFQCmwNwCJQATAaYA3alw +qXG2Cu/zBtoB2Klxqgrv8wbaAIZKJIBwqXECpgOmqCDABRUmQhBggoogxg0NswCCAeGpoACCqaAA +gsAYWAMAgsEYWAMAgsIYWAMb2c9wgAD8PJ0Bb/MsqPHAEglP8xpwOnFIdpIP7/macwh1BCaAHwAG +AACA4EoiQCDCIoIkBCaOH0AAAADXdkAAAABKI0AgwiPCJM9wgABUCcSIAN/+COAA6XCM7QPeLyEH +BC8iRwTJcEpzUgxv+wokwATJcL4Mb/uKcYTtOglAAgTwaglAAs9wgACUKgSAIQieAM9wgABkPACA +iug52FoP7/mLuA0IUQDeDM//DfAA2Z65z3CgAPxEIaDgeOGgkgjgAADYsQBP8+B48cBqCE/zo8EI +ds9wgABIJPAggwOKJwsWLZP9Yzx6KHCGIfEPwrpHuSR6hiD+A0S4HwmAAAohwA/rcoPYjbiKI9IN +SiQAAJUEb/QKJQABSIN/Zzu6UyICgECvTZPAukGtC/L3k4Yn/xlDv+etd5OGI/4HRbtorRzqz3KA +AHg8FSIDAACLNXoCrQGLz3GqqqqqA60CiwStA4sFrQOKBq0yCW/6iiDQDx4PYAACjYtwqXF+CG/z +DNoAwAHBAgtv9ALCi3CpcWoIb/MM2gDAAcHWCm/0AsLPcYAA8AkAoaoNoAPJcPEHL/OjwPHAhg8v +81fYz3WAAEgkI4XPcoAA9Al3kQCiCwseAF/YAKILC54AhbgAogsLXgCHuACiiiYLFsth2WEA2oDj +yiCBAM9ypQDoDwaiAInPcaAApDCA4AGBzyDiANAg4QABodIJT/cDhc9xoADIHE+AAuBIoYYN4ADI +YAOFAgxv/Q6AcQcP8+HFz3CAAEgkA4ApgEQhg4AA2iT0iQoVBAAijQ+AAIgjAI2guACtgBWAEKC4 +gB0CEEAVgBCguEAdAhAQjaC4EK2QFYAQoLiQHQIQUBWAEKC4UB0CEAHi4PFFChUEACKND4AAiCMA +jYC4AK2AFYAQgLiAHQIQQBWAEIC4QB0CEBCNgLgQrZAVgBCAuJAdAhBQFYAQgLhQHQIQAeLg8SMJ +ngHPcoAAiCMIioC4CKqIEoAAgLiIGgIASBKAAIC4EPCS689ygACIIwiKoLgIqogSgACguIgaAgBI +EoAAoLhIGgIAANg/CR4ASiQAdOB4qCAABisIngAAIIMPgACIIyATgQCAuSAbQgCgE4EAgLmgG0IA +YBOBAIC5YBtCAAHgHPBKJAB04HioIAAGKwieAAAggw+AAIgjIBOCAKC6IBuCAKATggCguqAbggBg +E4IAoLpgG4IAAeDgf8HF8cCiDQ/zz3aAAEgkGnALCFEAAIYC8AGGxBAABhUmDRRMIACgAd8luFMg +BQAghcB/QCEABsQRAQYbCV8BCiHAD+tygdiNuIojjQ/NAW/0CiQABIoiCw1ZYAAWA0BYYGCgABYA +QAGhABaAQAipABaAQAmpz3CAAJQqBYARCFEAQIUAFgBBD7IE8AAWAEEAFoBACqkAFoBAC6kAFoBA +DKkAFoBAABYAQQexABYAQQixABYAQOoJT/0AhcgQAAaGIH+OR/TwJsATyBAABoYgf45B9Iog0wE2 +Di/6iiEOBwpwmgtv+AHZPgqv/C8gBwRSDKADCnDPcIAAkCcskB6WDQkAAEYJT/lLCAEEAIXEEAEG +CnAlucC5Xgkv9QDaVg+AAInoC8gFIIAPAAAAPAsaGDBGD4AAiegLyAUggA8AAADUCxoYMAvIkLgL +Ghgw2gpP89IKD/i1BA/z4HjxwCoML/MA2QokAKChwcohYQAU8s9wgACUKhAQBQAdDZ8ACiHAD+ty +ftiNuIojCA2NAG/0CiQABc91gABIJBUlDhUAhhUlUhAkEBUAABIBICAQFgAoEBcBQS1PISmBGhAY +AcC/JblTIRMAwgwgAw3ZiiCJAIpxCgwv/Olyxgov/opwAIYJgCW4UyAQAIpwkgpv+ADZTCQAoAAJ +wf+fCBAgDe8KIcAP63J/2I24iiOJB0okAAAJAG/0uHOKIFAP9gwv+jeVYg8AAaYKL/gB2ACGCIAR +CB4ALBWAEITgA9gD9AXYOnA1CxEgUgxP++ILT/uKIJAFvgwv+oohyQ7PcIAAbDwDiIroiiAQDqoM +L/qKIQkPSg8gAADYLBWAEBkIEQGKII8Ojgwv+oohCgCA2JIJr/sB2UojACBN8IoPb/+KcC4KL/gA +2CwVgBAbCBEBiiCPDmIML/qKIcoDgNhiCa/7ANkhDBEg1gtP+84LT/uaDA/3/gnP+YDgOA0C9wDY +H/AuDQ/36gnP+YToignAAxbwz3CAAJAnCIiJ4Mwg4oHw9c9wgADYZQCABNm92h7bQMCLcP4OYAAY +uwHYenAAhgiADwgeACwVgBCE4ATYAvQG2DpwAIYogBSQBCGPjwAGAAAFfwfy9rnCJ6IQwCehECpw +inGOC2/16XKA4MogQgR8C2L1yiHCAw0LECC+CA/4n/BSCc/5BNnPcIAAlComDy/9JKAghsgRAAaG +IH+OQfSeD2/8inCyCaADinAAEgAgyBAABoYgf45A9M9wgACQJyyQHpUPCQAAmg4P+W0IAQWKcApx +ug7v9AHaf9kRuc9woACwHzSghgrP+Z4MgACI6AvIBSCADwAAADwLGhgwjgyAAIjoC8gFIIAPAAAA +1AsaGDALyJC4CxoYMCIIT/MM8CQZQAUghiAZgAUghigZxAUghhoZBAaeCM/5CegA2AsMESA+CMAD +A/AiCMADAd0SDWABqXDPcIAAtCJuDGABoKgpDFEgz3CAAJAnCIiJ4Mwg4oED9BEIESARCBECZgjP ++QTo5g9P9FYIj/muD8/3BMqQ4Mwggo8AALMADvIKIcAP63IBEgQ2ktiNuIojjQaBBS/0CiUABVIM +IAEA2CUBL/OhwPHA9ggP8892gACICQCGSiAAIIDggA2CAc9wgADgGAOAAN8Q6M9ynwC4/x2iz3GA +AMwiBIEB4LO4tbi4uAShFqIMzIEIHgDPc6AAyB+wEwAAz3KAAEgkQ4IC4EYSAQFhuQggQQA+oxDY +DqMB2BUbGIDPcIAAiOMDGhgwz3CAAFDkygpgAgQaGDDPcaAA/EQFgUohQCC8uAWhDMyGIP+Bz3CA +AEgJAIDCIUEkgOAUCIL9BCCOTzAAAADPdaAAyB8K8DEIXwPPdaAAyB8KdgohACTPcIAA7CIQgM9x +gACkP+yhAIAOodPwz3WgAMgfAN/P8D4Mz/7PcaAA/EQFgby4BaHPcIAAKD8OgIwgAo2H93YIb/UZ +2AYIoAAA2AzMz3WgAMgfqwjegwTYBhoYMB+FgOCKIAwAyiCCDwAAAAIOpQPYFbgSHRiQAIaA4BgM +ggHPcIAAzCIAgAQgvo8AAA84ANkF8s9wnwC4/z2g7QfP8h6FDBIBN2MIXkUGyIYg8Y8t9M91gAC0 +PYgVABYEIb6PAAAAUAHgiB0YEATyBNgMGhwwjgvv/gDfz3CgAPxEJYC8uSWgaxUAFmUIhQ8AALQA +z3CAAMwiAIAPCN4Cz3CfALj//aBKIEAgDMxVCB8BiwifAYYg/4XF8lEjAMCw8lEgQMWs9AzMz3WA +AKw+USDAgOnygNgMGhwwDczruKLyHYUB4B2lSiAAIJ/wag8v9RnY/g5gAOlwdQIgAEogQCANzFMg +QIBb8wTIAxIBNgMaGDAOCWACBBpYMM9woAD8RCWAz3WgAMgfAN+8uSWgz3CAAEgJAIAV6G/w5ghg +AgDfz3CgAPxEJYC8uSWgz3CAAEgJAIDPdaAAyB+/CBEABsgEIL6PA4DoU231USBAxWv1HgqP+jcJ +ECDfhaAVABAJJgAQ5ODL9s9wgAB4zQCADwheAP6lgghgABDY5ObH90AVARYweeoOb/oQ2IogCACg +HcATDqUfhYXoiiAEAA6lggyAAC/YlbgSHRiQz3ABAMD8FR0YkO4NAALPcYAAMDoAgYfg0PLPcKAA +OC4FgAQggA/AAAAA13DAAAAAv/L12AW4z3KfALj/GqIH2BuiadgYuBmiAdiy8IINT/2j8QDfqPAV +hQHgFaXPcIAA/DwRiFEgAICwCSICyiBiAAXuHIUB4BylDMwA368I3gENzAQghA8AAAAYZwyADwAA +AAjaDc/3Dcx9CN4Az3GgACwgBYEmgQrgXwkEAAMSATYC2AwaHDBQ2F4KL/6YEQEAlg8AAs9woAD8 +RCWAz3WgAMgfvLkloEfxiiAEAAwaHDAUhQHgFKVJ7huFAeAbpcXxCgsv+QpwDwgeAAjYm7gGGhgw +UPDPdaAAyB8E2AYaGDBD8QPIoBAAAPC46XAa8hoIj/gA2Ja4FPAxCB4Cug8v/IogBAA6De/36XUD +yKAQAADwuKlwBvLyD0/4ANiVuOoKQAME2Nbxz3GgAMgfEwheAtoPb/gB2ADYkLjy8QQgvo8AAABQ +CvIRCx5AiiAEAA6hBNgGGhgwDcwdCN4DQBECBs9xgACUzy+RDQpEAK+4DRocMM91oADIH+8Fz/8A +2AkIUQAH2AChz3CAAIgJAICA4KwIggHPcYAApD8MgU2BCCIAAA2hz3CAAOwiEIBPgWCADoECewDK +CCLCAE+hGQgRAgPZz3CgAEAtMKBfBO//ABrCMwHgVwTv/wAaAjDgeOB+4HjgfuB44H7gePHA4cUU +uCV4z3WgADguBqUF8DYPr/mKIFwIBoX3CN6HRQTP8vHAygvP8s9xoP6cAwDfz3CfALj/NqDPdqAA +wC+lHtiTD90IvQXw/g6v+YognAKjFgCWpHiMIBCA9/MUHtiTBvDiDq/5iiDcBKMWAJYLIECD+PXh +A8/y4HiU4MoiBQCF9whygCLCBM9xoABoLPAhgQAA289yoADELGeiaKIMuJ24n7gleAai4H7xwEYL +z/IIdnIP7/8odclwRg/v/6lxnQPP8uB44cUw2wDdz3CgAMgcaaAD2s9xoADMFyEZmIBOoaegaqDg +f8HF8cACC+/yANnPcKAADCRYgM91gAAcz61wQSqGB4Yg9w+YFYMQKbh2ecBxx3GAAHjiFXkAEYQA +z3CAAAAaIIBALM4A1X7QYdlhRCCPgFMgjgAEIoAPACAAAMwgIoAG9IDnzCAhgADYA/QB2M93oADE +J0ArBQaGI/0PUiPDAbMMMwRFu4DmzCAigFPyz3CAAKxw8CCHA0AuhgMFJsYBBSWAAQV7QR/YkFEO +kRAfhRDamrgfpQjYTx0CEM9woADIHEmgB4HPcqAA8BcGogaBBqIFgQaiBIEGogDYCqKKFQARaLgQ +eIodBBAAlYYg/4wo9AHYHaIm8E4VgBCi6IoVABFMpWS4EHiKHQQQBNlPHUIQGw7RECsXAZZkuBB4 +ih0EEAzYLaVPHQIQxgxv+YhwCPAFI0MBQR/YkB+Fs7gfpS0Cz/IQ2s9xoADIHEmhAdvPcaAA8Bdq +oaQQAgBNCt4CAtpdoc9zgAAI2USDRqFDg0ahQoNGoUGDRqFwEAABHOBTIMCABPRAIwAIBPBAIwAM +QIBToUxoQIJTofgQAoJTofwQAIAToQ/wXJCGIv+MA/R9oUiARqFHgEahRoBGoQWABqHgfuHFL4DP +c6AA8BfPcqAA/Bcoo0AQAQEqsjGAKKNIEAEBKrIzgCijUBABASqyPJCGIfMPjCEMgAf0NoAoo1wQ +AQEqsnAQAQG8kAjhqLK9kKiyVBANAaiyYBANAaiyuYCno7qAp6O7gKejchAAAThgEHgIss9woAD0 +ByegAtnPcKAAyBwnoOB/wcXxwKoOD/k2Ck/50cDgfuB48cCuCM/yz3GAAKgIz3WgAOwnAN4dCB4A +ANiXuBGhAd7PcIAARgQGpYogEQAL2Qrw0aHPcIAARwQGpYogEQAK2c4Jz/kVbhB4ELiBuIe4jLgG +pckAz/LgePHAUgjP8s91gAAczxeFz3aAABjjCwgQBlgVgBAE6BqFW4UE8ByFXYXPcYAALDwggRMJ +HwAyhQQhgQ8AAAAQJXgles9x/v//PyR4AaYA3+KmRHktpg7YEg9v+Q6mB+jPcYAAgCeCDmAAAdjP +cYAAXCR2DmAAANgXhQ8IEQUB2AGuMR4CEATw4a4xHsITLQDP8qHB8cCyD4/yOnEIdkh3egkv+wDd +geDKIEIjC/TPcIAAoCIAkIHgAdjAeEAoEAPJcIYg/ACMIAKFI/TPcIAAHM+YEIAA57jKICIACvQC +uBZ4z3GAAJDaAGEtuMC4z3GAABwKIIFRIYCAz3GAAJTPFHkE8iDarZEK8Jjaq5EG8M9wgABYz7OQ +DtoBl0AlARURCQMAonhIIAAAEHgD8ADYWnAA2CpxqXMiD2ADmHAKIQCgBPQeC0ADOnBMIQCgANhN +9AUggCMNcQCxDXEAGYQEI4cNcCCgKJcNcCCwiiCFAEoI7/nJcYwmApUU8owmA5Ee8owmA5Uj8goh +wA/rchPYjLjPcwAAlAqKJIMPKQPv87hzz3CAABzPtBABAA+BAeAPocYJIADpcBPwz3CAABzPtBAB +AA6BAeAOoQnwz3CAABzPtBABAA2BAeANoc9xoAD0BwDYBKEB2Bpwz3GgAMgf+BECAEJ1AiWAEEgg +AABfgRB4OwiEAEOHz3CAALizQqCg2A+hANgfoc9wgAAczxyQYrhCcB+hAtgVGRiADwkQIFEgQMYg +2ALygNgOoYwmA5UH9M9wgAAczxyQCPCMJgORCfTPcIAAlM8PkE4OL/oA2aoJT/8MzIYg+Y8R9Iwm +A5HKICEAzyChAwnyTCIAoADYzyAiA8ogIQEMGhwwCnAI3BcGj/LgePHAvg2P8qHBCHd6D+/6AN0V +CFEAz3CAAKAiAJAB3YHgwH0Mvc9wgAAE5ASAz3KAAPSzBCCADwAAABBFIEEDQMEgwMO4HHj0IgMA +z3CgACwgD4BwuxUI5AAA3vB4cHteCaADFNoJCB4GyXA48APYz3GgAPQHBaGFJQMZDXCgsA1wwLCK +Iv8PDXBAoM9yAAD//w1wQLADyM9zgACQ2s9ygABIJBCIArgWeABjLbjAuPAiAACggA1woKADyBCI +ArgWeABjLbjAuPAiAABCkA1wQLDEoY4IQAMB2E0Fr/KhwOB48cDWDI/yGnDPcYAALLQAiRXowYGi +gc9wgAAcCgIREQHggM9xgACkPwuBNL8B4AuhM/AGCK/5iiALCM9xoADEJxERAIYA3+8InoFkEQKG +ZBnYgwLYExkYgC8ogQBOIIEHEurPcIAAjKc2eMCAoYDPcIAADKj0IFEAz3CAACyo8CBPAAvwz3GA +AKQ/CoHpdel2OncB4AqhBBABIA1wIKAIEAEhDXAgsM9xgADUzwCBB+hCgQ1wQKAA2AChz3CAAEgk +A4AIgOu4yiCCA8ohQgPKIsIDUAqiA8ojQgRTIcAgz3GAABwKIIEUvwy45XgVCZ4AgrgNcQChDXDA +oA1woKAe8A1xAKFKJAB0qCDAAkQmgRAPuVMmABAleA1xAKEivkokAHSoIAADRCWBEA+5UyUAECV4 +DXEAoSK9/QOP8vHApguP8gh2KHUocEhxXgggAGhygeDKIIEDEAghAMohQQPxA4/y4HgiuQbw7HJg +ogTgYbn5CbWAYIDPcKAA1AttoAPZz3CgAEQdNaDgfuB4QSmBgAnyLyRJcKggwAEEEAIE7HFAoeB+ +8cA2C4/yocEId892oACsLxmGBCCAD3AAAADXcCAAAAAB2MB4LyYH8Ch1GnIT9IogyQNuDK/5iiHM +BTmGYgyv+YogiQOKIIkDVgyv+alxANgt8AvMABxEM08gwQMCHEQwAeAQeAQggA8AAP+/j7gLGhww +z3CgANQLOIBCIQEISCEBAEAnABIQcWQPBQMH5wQnjx8AAPz/BScAFJ24n7jscQChAMHscCCgAdjx +Aq/yocDxwOHFSgzv+gDdgeDKIEIDCfTPcIAAoCIAkIHgAdjAeAy4hSADAQPaz3GgAPQHRaENcgCy +A8gA212QDXBAsAPIUYANcECgA8hIEAIBDXBAsGShsQKP8uB48cA2Co/yz3WAANyY4BUAEADegODQ +90QuPhcAIUBzHNnF2h7bbg7v/xi74BUAEAHm5w4EkADYbQKv8uAdABDgePHA9gmP8iGACiYAkBCJ +w7jKIcEPyiLBB8ogoQbKI4EPAACqAM8gIQM58oDhyiHBD8oiwQfKIOEGyiOBDwAAqwDPICEDK/IC +uM9xgACQ2hZ4AGHPcYAA1AktuMC4DKkjhiCRhiH8AIwhAoAM9M9xgABIJPAhAQC/EQAGgbi/GRgA +AYaigAXtAYUD6ACFjOgKIcAP63Ic2Iy4udtKJEAAxQWv87hzCwifQZ4MAAAM6IogzgKmCq/5wNkA +hYDZKKABhUB4H/ABhiCQFMgQccohzQ/KIs0HHdjKI40PAADGAL4H7f/PIC0D7g0v+clwAgsgAAGF +z3CAANQJ/gkgAwyIZQGP8uB48cCjwQDZYMEBHAIwAxxCMAIcQjAB2c9woACwHzmgz3GAAOwiDIEA +gITaQsAIgQCADNke20HAi3AWDe//GLujwNHA4H7PcIAA2LIogM9wnwC4/wDaNqAI2exwIKAD2c9w +oAAUBCWgAcjscQChz3CgANQLTaDgfuB48cB2CI/ypcEIdyh2iiCZBsoJr/la2QDZz3CgACwgsIBA +xgbYQcBCwUPBRMEB2B7Z6XIA25hzuHMAJYcfAAAAfXoJoADYc5kAr/KlwAjIh7gIGhgwCcibuAka +GDAKyAoaGDALyIe4CxoYMAzIDBoYMOB+4HjPcYAAKJoAgYG44H8AoeB4z3GAACia4H8DseB44cXP +cqAArC8A2aroz3CgALQPPKAYgsEInwYVgrkIHgAagrUIHgDPc4AA5CJAgwFqDwhRAAHdz3CgAMgc +saDPdYAAR2jPcKAA7CemoECjiQoRAM9woADIHDGgPvAYgm8InwYVgmcIHgAagmMIHgDPc4AA5CJA +gwFqDwhRAAHdz3CgAMgcsaDPdYAARmjPcKAA7CemoECj4HjgeOB44HjgeOB44HjgeOB44HjgeOB4 +4HjgeOB44HjgeOB44HjgeOB4herPcKAAyBwxoAHZz3CgALQPPKDgf8HFz3KAANw8FXogomkAr/mK +IJIO4HjxwJhwCiHAD+tyCiXAB89wAACiGVUDr/NW2+B4z3KAALg8FXogojkAr/mKINIO4HjxwJhw +CiHAD+tyCiXAB89wAACjGSUDr/Ne2+B4z3KAAPA8FXogogkAr/mKIBIP4HjxwJhwCiHAD+tyCiXA +B89wAACkGfUCr/Nm2+B48cCkEAEADQlfBmoKD/kH8CDZz3CgAMgcKaAD2c9woAAQFCWg0cDgfuHF +A7g1eM9xgABQYgJhSiQAdADZqCDAAhYiQAChgGCAKdgSuAHhdXigoOB/wcXgeM9wgABUCQCAocEm +gJ4RAAaGuJ4ZGADgf6HA4HjgfuB4z3GAANQJ4H8EoeB48cD6DU/yz3KAAEgkI4I4iR0JEQEKIcAP +63KKIIwOiiMGAkokAABFAq/zuHMggsQRAQaNCV4Bz3aAAHRbIIZCIQGAyiFiALzpjugKIcAP63KK +IMwOiiOGA0okAAANAq/zCiUAASaGI4HPd4AA7CKggSSHIIHVuT1lz3GAAPjiJYFhuAUpPgAndYog +iQvSDm/5qXEEhyCAiiCJC8YOb/k2uclwrgsgAUIlgRLPcIAAkFsAJYEfAACIE5YLAAGlBU/y4H8A +2OB/ANgggAe54H8goPHALg1P8s91gAAkCsyNDY3CvsK4Fn7PfqoLL/0N2Aa4gbgQvsV4z3GgAOwn +BqEEhc9xpQDoDwahBYUHoV0FT/LxwOoMT/LPdqUA6A8mhqeGz3CAACQKAN8koKWgZgsv/Q3YBriB +uM9xoADsJwah5qZFJc0fp6YdBU/y4HjPcYAAdCfPcIAAgAkAkEeJKwoBAM9wgACCCQCQQYkfCgEA +z3CAAIQJAIgmiQ8JAQDPcIAA7C8AgALwANjgfuB44cXhxgDdMwnQBwsJ0wcLCRMAANgT8BkJ8wcf +3k4h/AfgeKgggAEPJY0TYb4JCE4ApXgD8KZ4AKIB2MHG4H/BxfHAocEA2kDCug/v/4tyAMChwNHA +4H7gePHAFgxv8ijYng6P+c91gAAIMECFCHYEIIQPAADw/wDYYHpBLAEBQIUB2EQmBBNgekEsgQBA +hQLYYHpTJkEQag6v+QDYQIUId0EoAQID2GB6wLlAhUEvQRIE2GB6wLnPcQAA1MXPcIAABDAgoM9w +AQA0sgClz3H+ygIAAg1v+Yogkg/9A0/y4HjxwBoIz/y6C4/8z3EAAPzFz3CAAAwwEglv/CCgz3EB +AGSyz3CAABAwIKDPcf7KAQDCDG/5iiCSD9HA4H7xwFYLb/JQ2NoNj/nPdYAAGDBAhQh2ANhgelMm +QRBAhQHYyXFgeoYh/Q/PcQAAIMbPcIAAFDAgoM9wAQCUsgClz3H+ygMAcgxv+Yogkg91A0/y4Hjx +wOHFmgiv+gfYcgiv/Ah1ng/P/04Jz/yyD2/6qXBZA0/y4HjgfuB44H7gePHA0gpv8konQAAIdQDf +wLiB4MInwgGpcYYh/gNEualyhiLxD0e6CdjPc4AA/DwMqxCrDqsPq0QlgBMceA2rBCWOHwAAAAxK +vrh206sEJYYfAAAAMEIuDgPYdtSrsRvCA1MgfoDKIcEPyiCBDwAAkRrKI4EPAAB7AMoiwQcc8lcP +EABEeBByyiHCD8oggg8AAJIayiOCDwAAhQDKIsIHDPQkeiEJgAAKIcAP63LPcAAAkxqG24okww+J +Bm/zSiUAALbpCiHAD+tyz3AAAJQah9vy8QsOEwEhDlMACiHAD+tyz3AAAJUajduKJMMPVQZv8wol +gAEJDkIBGw1TAAohwA/rcs9wAACWGpDbOQZv84okww9TIAEAhiB/Dxx4GWEveQcJQwEzqwkJgwE0 +q7YNYAEA2C4IIACpcAECT/LgfuB44H7geADZDyEBAC95E2kleM9xgAD8POB/DKngeOB+4HjgfuB4 +8cBuCW/yANuhwQS4z3KAABjjFHgdYhpiAYJvJkMQyKWKJgQSz3L+//8/yaUEeoDhQMLKJcEAC/II +gQQggA8AAAAwQiAFgMolYgBNDRAAz3CAALzNABAEAMiBBCSGDwAHAAAEJo4fAAAAMCy+Yb5BLgYG +QCaAEw8iAgBAwoUOjwMKIcAP63I+2Iy4iiOKDlEFb/O4ds9wgABsPAeIgeDPIqEDL/LPc4AAvM3P +doAAHM+aFoEQA4sLIQCAIfJMFoEQANtTIU4ARCEPAw8jgwNCvwDeDybOE4Yh/wMEJg6QAN9EuQR7 +DydPEOR4yiYBEIDjyiOBAw67ZXoD8AGDBXpAws9wgAC8zSCAi3KGIf4DJLlAKYMDIIIEIY4PAQAA +wAsmwJAW8td2AAAAQMwmgp8AAACAzCaCnwEAAAAE9AGAA/ACgK65r7mwuSV4AKIAFAQwBCSBjwEA +AMAK9AohwA/rckbYjLh5BG/ziiOLCQiFLrlAKQIGBB0AEUV4CKWKIAUGCaXPcIAAcM8EiIDgiiAF +DsoggQ8AANgBCaWpcADaAd7eDW/9yXPArS0Ab/KhwOB4CiUAgPHAEfInDZAAKQ3QAAohwA/rcoog +zQ6KIwQFEQRv84okgw8+DAAA0cDgftILAAD98WoLAAD58eB48cB+Dw/yCHXPcIAAODgJgInoz3CA +AMg3KYAM4PAgTgAC8AHeiiD/DwClz3GAAEgkAIHEEAAGaQhfAW4NT/sApZII7/mpcIDgyiXiEaL0 +Vg7P+IboAIWMIP+PDfTPcIAADDAggGB5AdiB4AXdyiUiEZDwz3GAAAgaIZHPc4AAgApAgzzhOmIh +g2TiFOFZYTBwAd3CJU4Ts33BvXzwA4EYiCkIEQHKDE/7AKXPcYAACBohkc9zgACACkCDPOE6YiGD +ZOIU4Vlh5fHPcIAAdFsAgM93gACYpEIgEIDeC2/7yiBiIAClAYcPCIUD4gpv+MlxCHbPcIAA7CIE +gM9xgAD44gCAJYFJbtW4BSm+ACdwargghUggAAAwcMogRgBE9wClSiBAIM9xgAAIGmGRz3GAAIAK +QIEhgTzjAd16YmTiFOE6YlBwwiVOE7N9UyVNkCLyQQhRIM9wgAB0Ww4MwADPcIAAkFsCDMAAz3CA +ADhc+gvAAM9wgABUXO4LwAAhhxEJpQPJcBYIIAAB2QTw/g+P/1EGL/KpcOB48cDqDS/yuHEKJwCQ +yiHBD8oiwQfKIIEPAABLA8oj4Q7KJCEANAJh88olAQHPcIAAyFsGgAOAAIDPcYAA7CIkgUlvwIHP +cYAA+OJTJk0VJYEdZQUpvgAndQIlAhCMIheHNr7+Zkn3z3CAAJikAYAFKH4AJ3UeZiMNEAB9DVAA +1Q2QAAohwA/rcoogjQ6Q280Bb/OKJIMPagzP+BToz3CAAJAnLJDPcIAASCQekBUJAADPcIAAyFsC +JYEfAAAADAfwz3CAAMhbQiUBFXYLwADPcIAA5FsAJYEfAACIE2ILwACKIEkMag4v+UIlARWKIEkM +yXFi8AoMz/jPcYAAOFwS6M9wgACQJ0yQz3CAAEgkHpARCgAAKHACJYEfAAAADAXwKHBCJYEXGgvA +AM9wgABUXAAlgR8AAIgTBgvAAIogCQ0ODi/5QiWBF4ogCQ3JcTTwrgvP+M9xgAAAXBLoz3CAAJAn +TJDPcIAASCQekBEKAAAocAIlgR8AAAAMBfAocEIlARW+CuAAyb7PcIAAHFwAJYEfAACIE6oKwADP +cIAAmKTDoIogyQ2qDS/5QiUBFYogyQ3pcZoND/nPcYAA+OIGgYG4kQQv8gah8cAiDA/yz3eAAKxb ++gngAOlwz3CAABQ4IIDPcIAAGDgAgM92oAAsIAkhAQDPcIAAsMwIgAkhDQAwhulwOgrgALlhMIaK +IAoAPg0v+blhMIaKIAoMMg0v+blhMQQP8uB48cDhxc9wgACYpAGADQhRAM9wgADINweAz3GAAABc +IIFCIQGAyiFiAJvpz3GAACDNLIGX6c9xgAAIzdIPL/gjgQh1iiDJA+IML/mx2YogyQPWDC/5qXGp +cIIN7/8C2d0DD/LgePHAYgsP8s9wgADsIgSAoIDPcIAAdFsAgEIgAIDKIGIANr2H6M9wgACQWxoJ +wADPcIAACM0hiM9wgADIW892gACYpIrpIIBCIQGAyiFiAATpIIat6e4IwADPcIAA5FvmCMAAAYZC +Dy/4CHEhhg94HQkFAAohwA/rcoogDQPX20okAABNBy/zuHPPcYAAAFwggUIhAYDKIWIABukdZSOG +yb0LDUAQ0gzv/wDZJQMP8uB48cCGCg/yWnAacdpw+nE6cnpzANiacG8lQxAIdkogwDc7cAh3unDp +cKpxUg0v8gHaACBAgwEhgQNCDS/yC3JCIFiwynNDIRkw8nHMIMGACvcAJ0+TASWVIwImFqADJ1cg +qXDJcUINL/IB2gUgfoAIdSh22/XpcKpx6XJaDS/yqnMCIhKg6XADIFAgqnHuDC/yAdoFIj6kCHUo +dhDyBSW+kwzyKnAA2UpyKg0v8gpzqXJCDS/yyXOacCpwANnpchYNL/KqcwAkAiD9AS/yABuAIOHF +4carChAAQCLDAyS7w7oC8ADalQoVBDMmgnCAAIBkQCeNclR9IH3AiAEZkgMB4AEQggQBGZIAARCC +BAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIE +ARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAEIjQ4Cz +9cHG4H/BxeHF4cYj6mNqIrvBugLwANo1ChUBMyaCcIAAfGRAJ41yVH0gfcCABBmQAwTgBBACBAQZ +kAAEEAIEBBmQAAQQAgQEGZAAQiNDgOP1wcbgf8HF8cDeCC/yUyFCAE4iDQHPcqAAFATJggDbDiaC +HwAAAAZQccohxg/KIsYHyiCGDwAAxiLKI4YPAACbAsokZgAMBSbzyiXGAIDhyiRNcMoizQDoIC0C +TmDPcaAAOAQB4sipHQ1QEBENkBAdDdEQz3CgADgEaKjPcKAAOARoqM9woAA4BGioxQAP8vHAMggP +8hpwenH6crpzCiIAIQokQCHIdQohwCEKIUCDz3KAAJ7ayiFiABJpFngIYkwjAKAEuAh3hif+EyV/ +yiHMD8oizAfKIIwPAADBIcojjA8AAO4AyiRsAGgELPPKJcwEHwieQc9wgADYsoDZKKAMwAToQHiN +8DIPT/+J8EwgQKCKIEoDyiCCDwAAjgIqCS/5ANnPdoAATF0BhgDZRgtv8zjaAIYc2SCgAYYY2SCw +z3GAAEgkFSFWAwAWASBTgQ3B8KjPd4AA2AsoGEAERXmkuSGgANkzGEIA6XEioAohQIMxGMIEMhjC +BDQYxAXKIWIASgsv+Azghe3PcYAAQLME8M9xgABgsyOmz3AAAEgRALEY2AKmDQhQIIogBQIAsQzA +hejPcAEAhLABpwAWACC5EAAGLQgeAEGGGtgAsgKmAJGHuACxANgLsQGCrbgBohENECDPcIAAzDkE +gDMaAgApChAgIYYBgZi4AaEDgZ+4A6HPcYAACAoAFgAgABkEBUCAAYBBoQKh2gxv/8lw7QbP8eB4 +8cCeDs/xunB6cfpyCiIAIQohQCHIdQokwCEKIECDz3KAAJ7ayiBiAAhxArgWeAhiTCMAoAS4hiD+ +AwUgUADKIcwPyiLMB8ogjA8AAL8hyiOMDwAAlgDKJGwA1AIs88olzAQMwIzoCiHAD+tyh9gGuJfb +SiQAALkCL/O4cxUInkHPcIAA2LKA2SigDMBAeGfwz3aAAExdAYYA3+lxsglv8zjaAIYc2SCgAYYQ +2SCwz3GAAEgkFSFWAwAWASAzgTMYwgPPd4AA4AsQGAIEpLmNuZm5IaDpcSKgCiFAgygYAAUxGMIE +MhjCBDQYxAXKIWIAtgkv+Azghu3PcYAAQLMF8M9xgABgsyOmpNgAsRDYAqYLDVEgpNiMuACxz3CA +AEgkGZCOuI+4AbEMwAGnKQoQICGGAYGYuAGhA4GfuAOhz3GAAAgKABYAIAAZRARAgAGAQaECoXoL +b//JcI0Fz/HgePHA4cXPdYAAxEAAjYwgw48P9M9ygABYWwaCA4AggMdxDwAAoI4LoABIcP7YAK2p +Bc/x4HjxwC4N7/EA2M91gABQ3UokAHSA3qggAAUIcQHgTyDCARYlQxBHq4oiCAACuTZ5x3GAAJDa +QKEA2kKxxqnA2H8dAhDPdYAAeArArc9wgAAQ2oDZaghv8yhywa3PcIAArCfZqM9wgACcJDEF7/HF +qOB48cC6DM/xocEIdwIML/QY2M92gAC0PSCGAYaA4cwgIYAr9M9woADUCxiAAN1CIAAIgODKIEwD +jCAIhUj3wRYAFgHgwR4YEBzwndgAHAQwC8zpcQIcBDAB4BB4BCCADwAA/7+PuAsaHDAAwB7aKggg +ABi6oaYE8AToYbgBphYIAAAA2IoJL/pAJgESmQTv8aHA4H7gePHAHgzP8Qh3GnE6cs92gABIJAOG +z3WAALQ9FJAQuMYKr/gCpYDgyiAiIM9wgAAYCgCAi+iFIQgkTyFAJ5+47HEAoexw4KADhgiADQge +AAKFgbgCpc9wgACECQCIhOgChYO4AqXPcKAALCAQgM9zgAA8P3IdGBBKJMBwANioIMAFz3GAAFwJ +IImA4QzayiIhAEQovgPPcYAAqOgncjMhggBAIwEDGWEB4ECpQCUOEroML/TJcA8IECAihQDYgLki +pQPwiiD/D89xgAAYCiCBZxUPFmgVBBaU6QDbCPDsciCiBHkEHlAQAeOMI4KAIIa4989yoADUCy2i +JHgApmcd2BNoHRgRANh5A+/x3B0AEOB4XQbv/wDY4HjxwM9ygACICQKCJYgB2AfpCNkaCy/5K6IH +8M9xgADAKi4J7/IAodHA4H7gePHA4grv8dhwOgggAADdyWgrDhIQ+HCpdzImgAMVCBIMEQiTDmoI +z/Uybzh4BX0B50InRwDlD3WAYb4RA+/xqXAIcgPwAeAgiP7p4H9CeOB48cCWCs/xz3WgAPxEHYU5 +hbINYAIA3gDYnrgBpeB4waXFpeECz/HgeM9xqqq7u89wnwC4/zagNqA2oDagz3GgAMg7DoGIuA6h +aSBAAP7x4HjxwM9wgABIJAOAGIgdCBEBCiHAD+tyiiAMDoojhQpKJAAAkQbv8rhziiAKC3oL7/iK +IUULXgkv9APYz3CAALDMABAEABkMEQAKIcAP63KKIEwOiiMFDF0G7/K4c89wgACgIgCQgeAB2MB4 +DLgrCIEPAAAAEM9woAAsIBCAz3GAADg4AqEC2AOhz3EBAGwzQglv/wHYB/CKIAoLDgvv+IohhQ7R +wOB+4HjxwJYJz/HPdYAAIM0vhUogACCA4cohwQ/KIsEHyiCBDwAAviHKI4EPAABIAMokAQTYBeHy +yiXBAM9wgACiIkCIz3CAANiyYHlIoDwdABSeCC/0AtilAc/x8cBGCc/xhg9gAAh1z3GgAMgfRYUM +6G4RDgYCgGSFxHpFe24Z2AAihQChC/BuEQAGRHhuGRgAHNgYuBUZGIB1Ac/x4HiA4AHZwHnPcIAA +wEDgfyCg8cDuCM/xz3CAAAQwIICiwWB5BNiA4KgCAQDPcYAA5CIAgQHgAKEXCFEAAdnPcKAAyBwx +oEYLYAIocFYO7/kF2M91gADIOw6lz3GAAOQiAIEB4AChFQhRAAHZz3CgAMgcMaAaC2ACKHAD2EoP +r/KpcQTYQg+v8iJtBdg6D6/yJG0K2DIPr/ImbQ/YKg+v8kAlARI22B4Pr/JAJYESN9gWD6/yQCUB +EzjYCg+v8kAlgRPPd6cAFEgIh89xpwCYRwSlDYfPcqsAoP8FpQ6Hz3agAOwnBqUcgQelF4cIpRaH +CaUYggulGYIMpRqCDaXPcAMAxgMGpsbYkLgGps9wLAACAQamz3BZAEIBBqaKIIoABqbPcEAAhw0G +ps9w0QDCDQamz3DAAAcOBqbPcIAA5CIAgM9ygADkIkIgQIAAogb0z3KgAMgcANgRogHYCKcA2A2n +DqfPcFAA/wAcoQDYF6cWp/zZz3CrAKD/OKB82TmgGoDPcasAoP+AuBqhz3AqAAIOBqaLcDYMIACB +wQDBz3CAANSbNaUyoAHBL6DPcBoAAg4GpotwFgwgAIHBAMHPcIAA1Js2pTOgAcEwoM9wJgACDgam +i3D2CyAAgcEAwc9wgADUmzSgN6UBwTGgz3CAAOQiAIAB4M9xgADkIgChEwhRAM9xoADIHAHYEaGC +CUACAZUQuIUghAAGpgKVELiFIIUABqYDlRC4hSCLAAamBJUQuIUgjwAGpgWVELgFIIAPAACCDQam +BpUQuAUggA8AAMINBqYHlRC4BSCADwAAAg4Gps9wgADkIgCAz3GAAOQiQiBAgAChBvTPcaAAyBwA +2BGhBIUrhQinBYUNpwaFDqcIhRenCYUWp89wqwCg/zigLIU5oC2FOqAmC+/5DoXPcIAA5CLPcYAA +5CIAgEIgQIAAoQb0z3GgAMgcANgRoZkGr/GiwOB48cAuDo/xfggAAM92gAAoYL4K7/cAhgh1AIYZ +DQAQHgyv+6lw+grv+6CmVg4v9BHYOg0P989woAAsIDCAz3CAABQKWQav8SCg8cC6D+//ocHPcIAA +yEAAgATZYtoe20DAi3AqCi//GLuhwNHA4H7gePHACg3v8xbYANjRwOB+4HjxwKoNr/EH2EILz/kI +d89woAC0D9yAsg0v/wDYz3GgACwgMIHqDq/4iiCRBS4Oz/vPdYAAyEC2CS/8AKVAhc9xgAB8XQCh +z3GAACg/SqGGD6/8C6FyDS//z3geCu/56XDPcIAAtCIAiEMIUQBAhYogRATPdYAApCIjhRpiOGAQ +cgHYwiAFAAzoiiARC4IOr/gA2T4Nb/UE2ACFBvAiDW/1BNgChfYLIAIDpWkFj/HgePHAz3CAAMBA +AICc6IIML/kW2Jjoz3CAAAQwIIBgeQTYEOjPcIAA9C9ggM9xAQB0ywvYYHsE2koN7/MW2NHA4H7P +cYAASCQAgcQQAAYPCF8BAYHEEAAGFQheAfYML/QT2O4ML/QR2Ozx6vHgePHAz3CAADAeAIDPcYAA +FAobeDoNr/UggQjoAdnPcIAAtCJ2D+//IKjRwOB+8cBiDI/xCHd92A24z3GAAPjixYHqDa/xyXGM +IAKAz3GAADQeAN2H9x14jCACgAHlfPcAKEIDBSq+A89ygAAwHha4AKHPcYAAxEAAGkAOhO//2ACp +AImMIMOPrA6B/20Ej/HgePHA6guP8TpwenFId2h2CiQAIQDaz3GrAKD/WaEH2BqhWKFqDiACAdgZ +2c9wpwCYRzqg9g8v/B7Yz3KnABRIHYK+gmwSEABwEhIAAKegpve4xSCCDwD/AADTIOEF973FJYIf +AP8AANMl4RVKDS/3iiEQAAh2qXA+DS/3iiEQAAh1QCgAIi4NL/eKIQgACHdAKgAiIg0v94ohCADR +eRnhLHkvcbF6GeJMei9yABmAIw8PYhAAG0AjANgE8P8Ig4AB2H0Dr/EAHAIg8cA6C4/xCHUodroN +IAIK2AHYz3GnAJhHGqGqDSACCtjPcKYAnD9kEAQAUSQAgMohwQ/KIsEHyiCBDwAAvxnKI4EPAAC4 +AGAHofLKJSEAz3CnABRILIAdgACm97jFIIIPAP8AANMg4QU9A6/xAKXgePHAwgqP8c9ygABwssSC +jCbDnzvy/9kkosCghC4IGQAhjX+AABSuBI0KIEAuAd+S6AKFz3GAAEQrigkv8yCBCHHPcIAA7CIE +gACAgg9AAIToAdgc8M9wgADEKiKNwKghqM9xoACwH/mhz3GAAOwiMIEggQDdIaA2Cu/46XAAIIAv +gAA0sKCoANidAo/x8cDhxQh1z3CAAOwiBIAggIogyQuKC6/4NrmKIMkLgguv+CKFZgnv8wbYMg6P +/M9wgABIJAOAGIgdCBEBCiHAD+tyiiAMD4ojBgtKJAAAXQav8rhzz3GAAMg3CYEJCBUBAeAJoc9x +gAD44gaBRiBAAQahz3WAAHwKAIUlCJEAiiBJBR4Lr/iKIUYPIIWKIEYP2gmv+gTaYguv+gTYFQKP +8fHA4cUIdc9wgADsIgSAIICKIAkM6gqv+Da5iiAJDOIKr/gihc9xgAA4OAmBAeAJoc9xgAD44gaB +grgGoc9wgABsPAOIiuiKIJAOtgqv+IohxwVWDa/+AtiKIMkDogqv+Iohhwa6Ce/zBtipAY/x4Hjx +wOHFCHX/2c9wgADsrSCobyBDADYPr/IB2c9wgADsIiSAIIFqCq/4iiDMDQaFA4BChSCAiiCIAFYK +r/hCeWUBj/HgeDkBL/QR2OB48cDhxQh1z3CAAOwiBIAggIogiQwuCq/4NrmKIIkMJgqv+CKFz3CA +AEgkA4AYEIQAGwwRAQohwA/rcoogTA+KI0cKDQWv8kolAADPcKAALCAwgM9wgAC0WdoOIACWIUEP +z3CAACDNDIAX6M9wgACgIgCQgeAB2MB4DLgfCIEPAAAAEIogyQO+Ca/4iiEHDgYJIAAA2CbwagyP +/M9wgAAsGwCAnujPcYAA+OIGgUYgQAEGoc91gAB8CgCFJQiRAIogSQWCCa/4iiGIBCCFiiCIBD4I +r/oE2sYJr/oE2AIKz/p1AI/x8cDhxQh1z3CAAOwiBIAggIogyQxKCa/4NrmKIMkMQgmv+CKFz3CA +ADhcAIBCIACAyiBiAIfoz3GAADg4CYEB4Amhz3GAAPjiBoGCuAahMgjv8wbYz3CAACDNDIAW6M9w +gACwNAKAEujPcIAAoCIAkIHgAdjAeAy4EQiBDwAAABDqCCAAANgQ8M9wgABsPAOIiuiKIJAOygiv ++IohSA9qC6/+AtjNB0/x4H7gePHA4cUIdc9wgADsIgSAIICKIAkOngiv+Da5iiAJDpYIr/gihc9w +gABIJAOAGIgfCBEBCiHAD+tyiiDMD4ojygVKJAAAeQOv8rhzz3CgACwgMIDPcIAAtFlKDSAAliFB +D891gAB8CgCFIwiRAIogSQVCCK/4iiEKCCCFiiAKCAIPb/oE2oYIr/oE2IogygEmCK/4iiHKCAHZ +z3CAALA0IqDPcYAA+OIGgUYgQAHCCq/8BqGeCM/6EQdP8eB48cDhxQh1z3CAAOwiBIAggIogSQ7i +D2/4NrmKIEkO2g9v+CKFz3CAAEgkA4AYiB8IEQEKIcAP63KKIA0PiiOKD0okAAC9Aq/yuHPPcYAA ++OIE2AahiiDKAZ4Pb/iKIcsBz3CAALA0AdkioM9wgABsPAOIi+iKIJAOfg9v+IohiwIeCq/+AtiS +Dq/zBtiKDq/zCNh5Bk/x4HjPcIAAtFnZAwAA4HjxwHIOr/MT2M9wgADsIgSAIIDPcIAA3BggoNHA +4H7geAhyANgdB6/3ENngeAhyAdgRB6/3INngeAhyAtgFB6/3QNngeAhxGQev9wDYCHERB6/3AdgI +cQkHr/cC2HUHT/LxwOHFCHXPcIAA7CIEgCCAiiBJDd4Ob/g2uYogSQ3WDm/4IoXPcIAASCQDgBgQ +hAAbDBEBCiHAD+tyiiCMD4ojCQO9Aa/ySiUAAM9woAAsIDCAz3CAALRZigsgAJYhQQ/PcYAA+OIG +gUYgQAEGoc91gAB8CgCFJQiRAIogSQV2Dm/4iiGJByCFiiCJBzINb/oE2roOb/oE2PYOj/ppBU/x +8cDhxQh1z3CAAOwiBIAggIogiQ0+Dm/4NrmKIIkNNg5v+CKFz3GAAPjiBoGCuAahz3CAAGw8A4iK +6IogkA4WDm/4iiEJDbYIr/4C2CYNr/MG2BUFT/HgePHA/9nPcIAAxEAyD2//IKj6D4//0cDgfvHA +egxP8c91gAC8KgAVEBCMIMOvCPKKIAwNyg1v+IohhwIh8JLoz3CAAPSxaBAEAAohwA/rcs9wAACH +DIojxwOtAK/yCiUABAhxgiEIAM9wgAAUrg4gQADiDW/xiiEICRpwz3CAABC2ExAChowiw4//2Qby +HBgYhCClDPATGBiEIKUA2c9wgACICSSgJguP+E0ET/EB2c9wgACICSSgFQOP+OB48cDhxQDdlgqv ++Klwqg+v8qlwVgyP8/IPj/LPcIAAFBsxBG/xoKDgePHA5g3P93IOz/dWDc/30cDgfuB44cXPcqAA +yB+kEgMAz3GAAIgJDYEQc8IjBgBE92J4E3u/gg6Bu2N4YA6hAdhKGhgA4H/Bxc9yoAAsIGaCz3GA +AIgJDoFieA6hEIJ5Am/2DaHxwE4Lb/FKJEAAwIGggAHf0XXCJAIB0XWhgWGAwifOEwHesXPAfrFz +AdvCI84ATCQAgMwmIpDKI2IACvSF64DmzCcikAPyAtsC8ADbFOshC1AAOQuRAKCAwIEBgCGBAiWN +k6CiAyBAAAGiEPAA2ACiAaIM8KCBwIAhgQGAAiWNk6CiAyEBACGiLQNv8Whw4HjxwOHFJoBAgEIi +AoDKImIAgOLKIcIPyiLCB8oggg8AADYRyiOCDwAAdwDKJCIAAAdi8solAgFggRULQABCgKKDQn0N +DVMQYIP1C0GAQYMBo2CgQaAAokSApoBAJQMWFwpeAEaFBuqigkKAQn0HDVIQAKNEgKaAQCUDFxcK +3gBHhQbqooJCgEJ9Bw1SEACjQYALCYEA6giv/waAnQJP8eB48cAeCk/xCHYAgEIgAYDKIWIAANgm +6SaGQYYB3zByIIZBhkGhIKIAps9wrd4CAAGmpobAfwaFEQ4BEKlwVgggAALZBqWmhgeFDw4BEKlw +RgggAAjZB6UF74YIr/8GhgHYJQJP8SCAEHHKISEA4H8ocPHArglP8Qh1ig/v/yh2CHfCpeIO7/+p +cP0Bb/HpcOB4QIAVCgAAZIILI0CABfRAgvcKAYAA2uB/SHDgeM9yoADIH/QSAAC82xi7BCCAD/// +APD0GgAAC8hleAsaGDAVGtiAz3OAAOwiCIMA2SCgDIMgoAmDIKANgyCgCoMgoA6DIKALgyCgD4Mg +oM9wAAwPAKQaQAAOog/YDLgQouB+4HjxwBIJT/HPdaAA0BvThREOnhbPcIAAoFxKCQAADw7eFs9w +gADAXD4JAAARDh4Xz3CAAOBcLgkAAA8OXhfPcIAAAF0iCQAAEQ7eF89wgACAXBIJAAC82Bi4E6Ul +AU/x4HjxwK4Ib/EA2wh3z3agAMgfpBYAEM91gADsIvhgpB4AEAHYE6YohQyFQIEAgAAiwoNAoSyF +ASDAAAChAtgTpimFTYUAgUCCACDAgwChDYUBIsIAQKAE2BOmKoUOhUCBAIAAIsKDQKEuhQEgwAAA +oQjYE6YrhQ+FQIEAgAAiwoNAoS+FASDAAAChBIUAgCIMb/PpcSSFAKEFhQCAFgxv8+lxJYUAoQaF +AIAGDG/z6XEmhQChB4UAgPoLb/PpcSeFAKEP2Jq4DqYP2Ay4EKbPcIAAgFyeDk//z3WAAKBckg5v +/6lwjg5v/0AlABiGDm//ViUAEn4Ob/9WJQATHQBP8eB48cCuDw/xCHcg8ACGIYYhoAChANgAps9w +rd4CAAGmpoYGhREOARCpcPoN7/8C2QalpoYHhQ8OARCpcOoN7/8I2QelI4Zgeclwrg3v/+lwCiYA +kAjyA4cggAKGInivCFKADg5v/+lwsQcP8eB4D9iauM9xoACwHxWhD9gMuBeh4H7xwCIPD/HPcoAA +HM8/gjpwqsEA2CEJ3gLPc4AASCRjg3SDSBKBAMDdZHmGIf8OIrk6fQTwFN0C2IoSAQECeRKCBOGe +C2/2ANqeCWAAAiBOAwPYz3GgAMgfE6HPdYAA7CIIhQCAQsAMhQCAQ8AJhQCARMANhQCARcAEheCA +BYUAEBIAQBEABh5m/BEAAM9wgAD8sgDZQIABgAAigoMBIEAAQMJBwIt2HwlRIAIKj/KEwRpwyXAu +C+//hsIIdggQASEL8ILByXAeC+//hsIIds9wgAD44iSQz3KAAPjiZYIGwgS7FwukAEApgAIZCIUA +Anr/CISABfC6C2AAhsAIckbCLQ6REOlwKgpv80hxCHdKcB4Kb/MGwQbCWnAEwwfBBcAAIsKAASBA +AETCFvCV7ulwKgpv80hxCHdKcCIKb/MGwQTDWnAGwQXAB8ICI0OARMMDIIAARcAbDlAQz3CAAEgk +A4AYiITgzCYhkADYAvQB2C8gB6BD9Olwtglv8wPZCHZKcK4Jb/MD2QDBCHcBwEAhwYBBIAAAQcAE +wEDBBcFAIMCAQSEBAETAPghgAEXBFwkRIASFwKAIhQDBIKAMhQHBIKAnCZEgBIXAoAiFAMEgoAyF +AcEgoAWF4KAJhQTBIKANhQXBIKAXCVEgBYXgoAmFAMEgoA2FAcEgoIogBw6WDi/4CnFMIACgAdnA +ec9wgABUpzSoaQUv8arA4HjxwBIND/GlwQh2AosodZhwZMAAiwASBgERHAIweXACEgcBBBIIARAU +ADHkkgYSBQEAIMkDAJEvIUgSByBAAgoJIAAQeAAgigEBlS8iiBIHIIAC9gggABB4ACDGAQKVLyaI +AQcggAHiCCAAEHgAIAcCA5UvJ8gBByDAAc4IIAAQeAAlBQAElS8lSAEHIEABugggABB4H2cFlfB/ +53iqCCAAEHgmlSFwEHgHeTx6D7klelB6ACKBAjB5ABxEMEeVJ3pceQ+6RXkweQAhggFQelx5AhyE +MA+6RXkweQAhwgFQelx5BByEMA+6RXkweQAhQgFQelx5BhyEMA+6RXkweT9n8H/8eQgcxDMPv+V5 +MHk4YGlxxrmFuQi5BSHBAiC2EHgglQocBDAneBx4CLgFIAABAbYAwAGmAcACpgLAA6Y9BC/xpcAP +e0i4D3jPcoAAAHL0IgAAQCgBAki4BXn0IsAAMHngfyd44HjxwM9ygABwXCCCgOHKIcEPyiLBB8og +gQ8AADQRyiOBDwAA4wbKJCEA8Ach8solAQEBogHaz3GgAMgfUKFKGZgASBkYANHA4H7PcIAAcFzg +fwCA4HjPcYAAcFwggQDYg+HMISKAAvQB2OB/D3gKIgCA8cAX8uIPz/+A4MohwQ/KIsEHyiCBDwAA +MxHKI4EPAADcBsokIQCEByHyyiUBAc9wgABwXECg0cDgfuB4CHMocs9wgADsIgSAAIACIIAPAAIA +AEkAIABoceHFUyBCBQQgjQ/A/wAAz3CAAPjiBYACIIMABCGCD8D/AADVuSJ4pXtFeBBzyiCtAAX3 +EHMA2MogZgDgf8HF4HjxwOHF2HC4cboP7/+Ycgh1yHCyD+//iHEQdcogrQAK9xB1ANjKIEYBmA/m +/8ohBgHpAg/xANjPcYAAsMwFoQSBoLgEoeECb/MD2OB4Nrg2uTBw1iCFDwAAgADgfyJ44HjxwEIK +D/EKJwCQz3aAAPjiz3WAAKBcD/TPcIAAmHDJcUYIL/8U2j4NL/KpcEAlABgR8BkPkRCKDU/yyXEq +CC//FNpAJQAYDPDJcNYKIAEF2alwEg0P8s9wgACAXAYND/IElgq4BaYGhoYgww8GpiILIADpcLIL +D/IxAg/x8cChwQhzWg8v94twguAA2AbyAMAQcwHYwiAOAKHA0cDgfuB48cAA2c9wgABoLxoIIAAg +oM9wgACYWXIPj//RwOB+4HgA2c9ygABUCiOiJKIloiaiJ6Iios9wgAB8XCCgz3CAACBdIKAxsjCy +z3CAACQ64H8goOB48cDPcYAAaC8AgZroAdgAoQDZz3CAANwYtg/v/yCgiiCHDpIKL/iKIY8Hz3CA +AGQkEIiD4GQJIQDKIGEB0cDgfvHADgkv8Yogxw+kwWYKL/iKIdICAgjP94DgrAkCAM9wgADcGACA +z3GAACQ6jg7v/yCBz3aAAFQKMJZRlllhMHAA3cT3AiBNAAKGlegT7c9xgAAgXQCBuGAAoc9xgAB8 +XACBuGAAoc9xgAAwPhKBuGASoc9wgAA0CQCAAN8NCFEAz3CAAHxc4KCKIAgAz3GAACBd4gkv+CCB +z3CAAHxcAIBCxUDAz3CAACBdAICLdUHAAoYQ2aLaHttDwKlwsgxv/hi7ANieDS/5qXHPcIAA3Bgg +gM9wgAAkOuKm8bYgoPC2z3CAADQJ4KB2Dy/zE9jPcIAAIF0AgB8IVAFiCCAAAdgiDs/6z3GAACg/ +HYEB4B2hBPBKCCAABdhdAC/xpMDgeBXYANrPcaAAyB9vGRgA4NiQuBChCdiwGQAAtBkAAHjYQhkY +AADYmrgPoaQZgADPcAAMABkOoeB+z3KAAJhZJoIjgWG4YIHPcYAA3BgggdW5eWHPc4AA+OJlgwUr +PgAnccdxAAAAEN0Fr/9IcPHA4cXPdYAAVAoHhZPoz3CAAGgvAIAfCFEA3g5P+BcIkAbPcIAA7CIE +gACABaUB2AelyQfP8OB48cDhxc91gABUCgeFGejPcIAAaC8AgCsIUQCmDk/4IwiQBs9wgADsIgSA +AIAGpcoM7/8lhTCVOGAQtQDYB6WFB8/w4HjPcIAAaC8AgBcIUQDPcIAA7CIEgCCAz3CAAFQKI6Dg +fvHAz3CAAGgvAIAlCFEAz3CAAOwiBIDPcoAAVAoAgASicgzv/yOCMZI4YBGy0cDgfvHArg7v8Ioh +CAAIdc9woADIHzCgAdlBGFgAVgkAAM92gAD44gOGJYbVuDBwyiHND8oizQfKII0PAAA1EcojjQ8A +AJsAyiQtANwCLfLKJQ0B4glP8tIJb/IIdxpwgOXMJWKQSvTPdYAA7CIIhSCGIKAMhSGGIKAAhSWG +IKAEhSOGIKBKDY/35QgQAM9wgACQJwiI2QjRAQWFwIAAgAQmjh/A/wAAUyBRBQSFAIA2Ci/zCnHV +uEWFBX4C28Ciz3KgAMgfc6LJhQIgQYRghk2FQIIKAAQAQinABwfwJJcKuQIhQQQZYQDYAiNDgAMi +AQBgpg2FO/B1DZEQBJfPdYAA7CIhhQq4AKHPcIAASCQAgMQQAAZRIECBCYUg8s9xgACQJyiJOQnR +Ac9xoADIHwHaU6EohQDbIIFMhQIhAYRAgiCgDYUDIsIAQKAEhQCAlgkv8wpxJYUAoQrwIIcgoA2F +IYcgoCOGBYUgoKUFz/AA2Za5z3CgANAbM6DgeAMLnkXgfs9wgACgXCeABukDgECAAoFCeAXwz3D/ +D///4H7PcYAASCQkgSiBBCG+jwAGAAChwQT0EwkfAAnwBCC+jwAAABgD8gDYAvAB2M9xpgCkABeh +4H+hwPHA5gzP8M91oAC0Rwh2BvAqCO/3iiCJDHEVAJYEIIAPcAAAAEEoPoX09Yog/w9vHRiQax0Y +kAPYD7jPcaAAyB8TGRiABYZZHRiQBoZaHRiQB4ZbHRiQCYZYHRiQCIZXHRiQQBEBBs9xgACAXSCB +BCCADwAAAIARCR8AgOAG2Mog4QED8ADYz3GAAEgkI4Eogc9ygACoCCUJHgBPIAECjbmXuSaiBSCB +D4AAQDonogUggA+AAMBTEPAFIIEPgADAJCaiBSCBD4AAAD4nogUggA+AAIBXCKKEFQCWCaIGhsIK +r/QhhuYO7/8BhmkEz/DgePHA6gvP8Dpwz3eAAPw8DI+GIP8BQijQAM92oAC0Rwp1BfAqD6/3iiCJ +DHEWAJYEIIAPcAAAAEEoPoX19UMWAJZGIAANQx4YkFcWAJYEIIAP/2//w1ceGJBfFgCWBCCAD/9/ +/8NfHhiQANieuFMeGJDgeADYUx4YkAyPYB4YkE4LT/zPcIAABDAggGB5BNgW6EwhQKBoCeH6yiBB +A893gAAkYACPFQ0AEM9wgACMMTaAYHkA2AAfAhTmCk/yQxYAlkUgAA2fuEMeGJCZCRAgJQlQIG8J +kCAKIcAP63KKIFoKiiONAkokAAB5B+/xCiVABM9wgABIJAOAEL2bvTIggA8AANgCn72A4AHYwHgP +uKV4Xx4YkAXwNg6v94ogiQxxFgCWBCCAD3AAAABBKD6F9fWKIP8Pbx4YkGseGJAS8M9wgABIJAOA +EL0yIIAPAADYAp+9gOAB2MB4D7ileF8eGJAGyITgEAsh88ogoQTdAs/w8cCGCs/wCHUodhYM7/AB +gKCFELlBLQAUOGAGDO/wyXEQubB4OGD6C+/wQC6BEsUC7/AocPHARgrP8DpwHQl0ARpxCiHAD+ty +iiDaC7DbCiQABKEG7/G4cxsJ1CAKIcAP63KKIBoLstsKJEAEhQbv8bhzz3CAAPAICHXmaBQlTRQA +lR0IHgIAFQQRCiHAD+tyiiBaC7fbXQbv8bhzAIINCFEAbyBDAAPwANiauCGCnrjQioHhAdnAeRu5 +JX4FfgKCMYqB4AHYwHgcuAi5JXgFfgOCMoqB4AHYwHgduBC5JXgFfoogGQsCC+/3yXEA2CJ3AK8v +IAcEiLgAtc9woADgRBUgQATAoNUBz/DgePHAegnv8ATZANjPdaAAtEdLHRiQANqQuncdmJAB2ncd +mJDPcqAAhEQYogDakbp3HZiQAtp3HZiQz3KgAIhEGKIA2JK4dx0YkHcdWJCA2HcdGJAA2J64VB0Y +kADYnLhUHRiQz3aAAPwIyXCWDC/yHNnPcIAA8AiKDC/yCtnJcCEdGJDPcIAAfAcQeEkdGJBZAc/w +4Hj8HAi08cAfCHQBGnAKIcAP63KKINoLd9sKJAAENQXv8bhziiAZCiIK7/cKcc9zgAD8CCSDaHA0 +eCCQHwkeAhATBAAAEAUBCiHAD+tyiiDaCgEF7/F+2ySDAeEkowDaCQkRAkSjLyEHBIUhDAAgsJDZ +z3CgAPxEGLkioAuTAeAQeAuz0cDgfwQUEDTgePHAiOjPcIAAbKzWCy/yJNnRwOB+8cBGCM/w3gtg +AQh2cg6AAM9xoADIHwh1QNgPoUARAQYweU4Ib/jJcIkA7/CpcOB48cASCO/wSiQAcs9woACIIADe +qCBAD3UO0BGggM9xgAB4zc9ygAD44tZ5aIlHgnpiz3OAAETO1Hud7QAmjR+AADzO+I0TD5EQ4JP7 +fyORgL8kf+CzBfALD1EQIpEgswDZOK3PdaAAyBz6hSCT5HksswTwLJMJCUUDWWEE8KyzuWKJIc8P +BBhQAAHmANnPcIAA+OLpB6/wJ6DxwAAWBEAHGhgxABYFQAEaWDEEEoEwnOHKIsIHyiCCDwAA3A7K +I4IPAAD0CrwD4vHKIcIPIgjgAA7Z0cDgfuB48cA2D4/wGnANyM93gABszvAnARDPdYAAzM0DEgI2 +CBhEIAGSgOANEgE2AN4O8hQlQxCAEw4H1Q4QEADegBucA/AbhAPgG4QDFCVDEMCzAYI9CJ8DyLPQ +G4QDEIrPcYAAkNoCuBZ4G2FlkyULcgA4YGG7ZbAQinJodnt6YUWSeWGG6iaRUSFAgHAKwvENyAAg +gQ+AAOjNxKnMqdSpz3GAAHjNFnkUfSKRwB2EExV/eB1EEAMSATbApwGBBCCADwAAAGAtCIEPAAAA +IBCJz3GAAJDaArgWeABh7bjKJmIQz3CAAIAj1HggkBDhILAD2c9woAAUBDCgGg1gAQpw2diiD6/3 +ARIBNj7wcBINAeATAQECIU4DDw2EE8J9ongQeIAbHADPcKAA1AcPEA6GAN3wG4QDcBICAcAbRANC +eTB54BtEANATAQEB4TB58BMFAdAbRABTJX6AyiHCD8oiwgfKIOINyiOCDwAA5w3KJIIPAAD+ADgC +4vHPICIDA9kTGFiAGQaP8PHAqg2v8ADYz3GAAERdAKHPcIAA4BgBgKPBEOjPcp8AuP8dos9xgADM +IgSBAeCzuLW4uLgEoRaiDMzPdaAA1AdRIACAA9ggHRiQU/IUHRiQAxIBNgAWBEAHGhgxABYFQAEa +WDEEypzgyiLCB8oggg8AANwOyiOCDwAA9AqoAeLxyiHCDyhwDg6gAA7ZAxIBNlCJUyLAAIYi/gMQ +qUS6ArjEGYIAFnjPcoAAkNoAYs9ygABIJC24wLjwIgAABKK5EAIGz3CAAHjNQKAPFQCWtBkEAAbI +1gmv9g0SAjYDEgE2khEAAd4J7/uUEQEAL/BKJEAAFB0YkQAWAEAHGhgwABYFQAEaWDEEypzgyiHC +D8oiwgfKIOIJyiOCDwAAZgIIAeLxzyAiAwPItBAAAQ8dGJDL2OoNr/cNEgE2AxIONpQWABAPCF4C +LghP+AMSDjYNEgM2z3eAAMzNFCfBEAiRouhQjs9wgACQ2nV/ArpWekBgmBYCEC24TqdWp8C4z3KA +AIAj9CICALwehBDQEQABBCKCDwAA8P/DuEV40BkEAAbw0BEAAbweBBAB2KAeABCiCq/70I6A4OoD +IQADEgM2BshRIICB2gMCACGDEwmeBpDYkLjPAyAAoBsAAAK+z3CAAJDaQCCCA9Z+zmLEE4IAEwqA +A5HYkLirAyAAoBsAAMqDz3KgACwg8IKMJv+fDPLCfxUPhR8AgAAAh9iQuIMDIACgGwAAEBOEAEAs +jwD2f+ZgBCa+nwAAABP4YFnyEQ5eEovYkLhbAyAAoBsAAGcOHxMlkJzpB8gEIIAPAMAAACEIgQ8A +wAAAEdgUuKAbAADh2KoMr/eIcQMSAzYh8IjYkLigGwAA4tj28ZIMr/fj2AMSAzakEwAAtLikGwAA +khMAAae4khsEAJ4TAAGnuJ4bBAAF8IXYkLigGwAAz3CAAEgkA4AYiITg2gICAM9xgABUpwyBUIsP +IIAADKHPcYAA/AkAgQHguwIgAAChwpAzE4AATQ4OEAfIBCCADwDAAAAxCIEPAMAAAAiLKQhTAKQT +AAC0uKQbAACSEwABp7iSGwQAnhMAAae4nhsEAArwEQmeAY3YkLhrAiAAoBsAAAbIUSAAgBYCAQA+ +DY//AxIDNghyqBsAAM9wgADsIgSAsBMHASCAVSdABtW5z3aAAPjiCwkFAAXYB6YFhiJ4jCAJhsoh +JQCkEwAACSGBAPK4rBtAAObymBOBAMO5B8g8eQQgiA8BAADwDRIGNs9wgAB4zRYggAHFkKwTAAAJ +IIADgBMOAX4TDwHfZ892gABIJMSGRhYOEf5mCCCAA8J4mBMOAEEoCBPovgDfhvJEJg8WBCaBHwYA +AAAjvzG5Aef5Yc93gAAAdDInRBBBLoESBCaFH8AAAABSIQEAQS2FBTInTxHAuQO5GOGAd4XnyiGN +DwEAiQ3VIc4DpBMPAEcPHhUieIQTAQEieEggAABCuEEuTxPAvwS/9H/Jcca5SSHBBTR/z3GAAGBr +8WEPDt4SQSkOARQmQRAFKT4AQSkAcgDfWPBBKIQAQS5AE8C49Gj0f8lwxrhJIMAFFH/PcIAAYGvw +YA8O3hJBKA8BFCcAEAUoPgFBKQByhBMPAflhEOFBKYQAQS5BE8C5BLk0ecl3xr9JJ88V9HnPd4AA +YGsxZw8O3hJBKQ4BFCZBEAUpPgFBKQ9yIPBRJkCSyiDCAxr0A+DPdoAAOGvwJkEQIrgFKT4AL3BT +IA4A2GCEEw4BHXgn5iK+BSm+Ay93UycBED9n/X/PcaAAxCzvoe6hQCgOFp6+QC4PBeV+xXjAGwAA +CqHPcYAAtDwB2AChBPBPgrATBwENCsUBBdgYuKAbAADPcIAAAApBgCCTCSGBAACIDwhRABkVAJYQ +cQDYAvcB2IvoA9gYuKAbAADPcYAArD4TgQHgE6GgEwAABCC+jwEBAAAa9JITAAGUEwEAkBMCAbIT +AwH+DyABSiRAAAMSAjagEgEAJXigGgAAzthGCa/3ARIBNgMSDTagFQAQBCC+jwEBAAAF8j4Jz/bX +A0AAA8zPcZ8AuP8YoQbIUSAAgMogISB38qQVABBnCJ4Ez3GAALQ8AIGA4ADYMfIA2AChgBUAEX4V +DxEfZ89wgABIJASARhAAAR9nAwmeRc9woADELMuA39jOCK/3yXFTJoEU/r7MISKACfKYFQAQBgyv +9QDadLj4YALwANgDEgE2CPANyM9xgAB4zRZ5BZGpcUogACDPcqAAyB+sFQ4QiOikFQMQsbukHcAQ +BPAJJg4QA9sYu2+i+BIDAKFrCCZOE2J+oBqAAwDbmLtuogvopBEAAPG4DczFIKIEzyBhAA0aHDAB +kQjoDcjPcoAAzM70IgAABegBgQ8IngMNzIC4DRocMMzYIgiv9wYSATZSDS/7A8gDEgE2fJFEIwAD +0wgQAQ3Iz3KAAMzNFHrAEgABZXhhgRyxFQteA1QRAwG8EQ0Bw7ule1QZxACGIP0MjCACghj0EIkC +uBZ4x3CAAJDaZZAhC1IABpAdCF4AEwtRAGARAAGEuGAZBAAE8ByRjbgcsQGRJejQEgABVBEDAcO4 +BXtUGcQAgBIAB4ToHJGKuByxpBENABUNHhJoEQIBUyPAAFhgEHhoGQQAEw1eEmoRgADDu3hgD3hq +GQIAB8jPcoAA3M4EIIAPAMAAABEIgQ8AwAAADhoEBAXwANiLuAeyAZET6A3Iz3KAAMzNFHrQEgAB +UyDAgAny8BICAc9woACYA16gthmEAKQRAAAEIL6PAAAAMAj0hiDljxgNYgDKIEIAngkAAQ7oagqP +/QPZz3CgABQEI6CKIBAAiwFgAAYaGDADyKQQAAAEIL6PAAAAMM7yEwgfBV4OT/XW2L4Ob/cGEgE2 +A8ikEAEAqQkeA6oOb/fN2BoI7/IB2AMSATYdsc9wgABIJMSA8g6v+ADdGQhRAM9wgACgIgCQgeAA +3c8lIRPKJQIUA9jPcaAA9AcFoYUlAh0NcKCwA8hdkA1wQLADyE+AEQoeAEKGDXBAoEaWB/ANcECg +A8hAEAIBDXBAsAPIUYANcECgA8hIEAIBDXBAsBAZAAQDyJQQAABRIECCWAgB+K4Iz/kGEgE2twBg +ANDYBg5v99HYAxIBNgGBHwgeBs9wgAAICgCQHbHPcIAADApAgAGAUaESoQfwUg+v8gLYAxIBNh2x +5gnP/QPIJgyv/3gQAAGA4G4AQgDS2LoNb/cKcQMSAzYBg5gTAQCUG0AAKwgeBs91gACI56lwzgjv ++WhxENgMGhwwDcyjuA0aHDDqDK//qXAvAEAAnhMAAb4TAgGSGwQAkBuEAAYIYAGCEwMBCHXP2GIN +b/epcR8NHhYD2c9woAAUBCOgiiAQAAYaGDD92OsHIACpcQPIpBABAIYh5Y9MC0IAAxINNqQVABD0 +uI4CAQBwjc9ygABw2XZ6z3CgACwgD4CEFQ4RIJIIIIADwniwFQ4RZObRcAQBLgAJIEEAArvPcIAA +kNp2e2BgBCCOD4ADAAA3vmW+gObKJgwUBCCADxgAAAAzuA3gAd9KIgAgDyISIAMSkQCODq/2mBUA +EAkggQSYFQAQ7bjKIMIjQCgDIXR7CHLGukkiwgVUe89ygABga3JiDwjeAkEqAAEUIIIAKLrYegNq +BCCADwAA/P/PcoAAeOMDos9yoADELA2iMBpABAfIDRIDNgQggA8BAADwLLgYuJ24FLtleAV5KqLP +coAAIEAIggHgCKI2DG/33tgDCZ5Fz3CgAMQsy4Df2CIMb/fJcQQmjx/wBwAANL9TJoEUEQ6eFw0P +lBAAlRDgHQhEAAMSDTZKIAAgz3GAACg/AYEB4AGhANks8KQVABD3uNUhwgPPdoAAeOMgpuKmmBUA +EBoPb/UA2gGmz3GAACg/AoEB4AKhAIH4YAChz3CAAEgkA4AJgA8IXgANzEYggAINGhwwAxINNgHZ +SiAAIJIVABE56ZQVARDPcoAAeOOiksCCQMHPc6UArP/PcoAASCTYo0SCVhICARTiQn0D5SK9umW6 +YkgiQgAFukUiQgNWo1EgwIHKIIIvAACAACDABCGBDwAAACAluQUgAAQleIm4jrgZo89woACoIAiA +hgrP8c8FAACkFQEQp7iSHQQQtLmkHUAQlBUAEJAVAxHPcaUArP9AwLAVAhF4oc9zgABIJGSDVhMD +ARTjYnoD4iK6W2J6YkgiQgAFukUiQgNWoSDCBCCADwAAACAluAUiAgRFeIm4jrgZoc9woACoIAiA +A9nPcKAA9AcloA3ImBUCEM9xgAAEzhV5QKGkFQAQCHSEJBqQGPQEIL6PAAAACQnyXg9v/alw2g9v +/QPIDPBwFQERz3CgAPQHJ6DPcKAAyBwcGAAEAxIBNtPYWgpv96QRAQADyKQQAAATCB8B4glP9dvY +Qgpv9wYSATYDyAGAEwhfBqYLr/IE2AMSATYdsYYKr/gA3hkIUQDPcIAAoCIAkIHgAN7PJiETyiYC +FM91oAD0BxmFD+gKIcAP63Iz2Iy4z3MAAG4KCiQABPUEb/EKJQAEA8gckMV4DXEAsQPIPZANcCCw +A8gvgA1wIKADyEAQAQENcCCwA8gxgA1wIKADyEgQAQENcCCwAxIBNhyRhiD/DEEIEAEzgQ1wIKAD +yFAQAQENcCCwA8hUEAEBDXAgsAMSATYckYYg8w+MIAyACvQ2gQ1wIKADyFwQAQENcCCwAxIBNhyR +hiD9DIwgAoIc9GARAQENcCCwAxIBNqQRAAAlCN4FOYENcCCgAxIBNqQRAABkGQAEuBkCBLoZBAS3 +uKQZAACkEQAABCC+jwAAQAgG8gGB8LjUCYLyD/A6gQ1wIKADEgE2pBEAAIYg848F8juBDXAgoAHZ +K6UD2kilz3OAADA6DRINNkCDANg5DYAQz3KgADguRYIEIoIPwAAAAB8KgA/AAAAA9dgFuM9ynwC4 +/xqiu6Jp2Bi4GaIocAkIUQCgo89woAD8RD2AGYBpCN8CBCG+jwAGAAAu9OB44HjgeFUIXkMDyM9x +oADIH7AQAAGWIEEPHqEQ2A6hAdgVGRiAVgngAEHYLQheQ89wgABEXQHZIKADyKQQAQCauaQYQADu +Cm//AdjPcYAAIEANgQHgDaEGDQAAGnDU2CYIb/cKcQQgvq8GAMoAIvLPcIAAvCIDgIDgyiHCD8oi +wgcr2Mojgg8AAD8EzyAiAwX1z3GAACBAEIEB4BChz3Gg/ugAz3CfALj/NqCHAgAAA9nPcKAAFAQl +oAMSATYBgVEI3gCkEQAAz3KAAEgkUSAAgASCA/K7kATw7gnv97qQz3GAAPw8EYktCB4AA4IwiRC5 +MiCADwAA2AKfuYDgAdjAeA+4JXjPcaAA/EQNoQTwdhENAQ3MUyBAgA7y1dhqDy/3BhIBNgbIBBIB +NoYP7/UNEgI2z3aAAIjnyXB+Cq/5AxIBNgPIBhIQNs93gAB8I6AQEQAB2ACnig1v/6lwANkgpwro +hiB+j+XyA8igGEAEBhoYNAMSATaSEQABDwieAqq46gjv+pIZBAADEgI2fhIBAYISAAGAEgMBOGAb +Yw3Iz3GAAEjOFXkJgXB7G2NpoQGC4wjeANfYzg4v9wDZQgiv+YDYBhIBNgQhgQ8CAAEADRICNxcJ +gQ8CAAAADwheB08iwQANGlwwBfCjulB5DRqcMAMSAjYBglkIngFPIcACjLgQeQ0aHDAQijMSggAE +uEV4z3WAAHS2z3KgADguRIIGtRHwLy6BEE4mgxcA3g8mzhDGes92gADg2PQmzhATCIAD8urPcAAA +//8EtQLwZLUI2AwaHDDPcIAA/DwRiBcIXgHPcIAAbDwSDG/9AIgNEgE3A8gBgP24zyHiAdAh4QEN +Glwwz3GAAKw+FoEB4BahMfAQ2AwaHDANzKO4DRocMEoNb//JcNjY3g0v9wESATYDEgI2AZIJ6A3I +z3GAAMzO9CEAAAvoAYITCJ8DDcgB2gAggQ+AAFTOQKkNzFMgQIAJ8gQSATaKIAQARglv+5gRAQAD +yBqQSgxv+Q0SATYNzAYSATYlCN4Afg0v99fYz3CAANzOAxIBNgKAmBkAAAbI9ggv9g0SAjYGEgE2 +3NhaDQ/3QQQv8KPA8cDhxanBi3WpcM9xgACcZJ4ML/Ak2qlwagiv+QMSATaeCuAAqXA9BC/wqcDx +wOHFAxIBNqKBIIXWCS/+JNqO7QohwA/rclnYjLju20okAAAJAG/xCiUAAQGFgODiIAIAAQQP8PHA +bgsP8JgkwTM6cADYThwYMAAWk0AAFpBAABaUQAAWkkALClIhLyJHJEwiAKHKIcoPyiLKB8ogig8A +ALUoyiOKDwAAUADKJCoArAcq8coligRBKA4hwL5AKQEkiiCTAooML/fFeavuWQgQIM9wgAC8zQOI +CnGGIfwHRbkmeFMgzSDguMohQgPKISEAViTMOSCs4bjKIUIDyiEhAIt0gCREHiCsUSCAgMogQgPK +ICEAi3SAJIQeAKwF8FMg/qAs9ADdhCoKIi9wunDHcIAAsL+ELgQfBOAAIFAORCo+JwAhgH+AAEDM +4IgBiJJ3uHDMIMGEIfIKIcAP63JALA0kQCsOJIfYjbiI2wUlxBPpBi/xBSWFAwohwA/rckArDiTP +cAAAryhu2wUmBBXNBi/xCiUABApwLgsgAEjZViAAKSYLIAAG2QAlgC+AABzCI4CJ7oG5I6BOFAE2 +JKAloAPwgrkjoAOAhiB/DobgiiATA8oggg8AAMsEdgsv9ypxz3GAAFQJC+3PcIAAQMxAiByICwoB +AAQZQgQAgRCIGwiBBApw3guv/clxiiASDUILL/dOFAE2TggP9QkCL/CVJMEz4HjxwMIJL/AA2c9w +oAD8RHQQEADZgAQmgp8AAAAIC/QEIL6vAAYAAAf0A8ikEAAA+riH8s9wgABIJASAz3GgAMgfRhAA +AR+hINgOoRkInibuCQ/0iiAEANYKL/cA2QDdPfAlCF4mtgpv8gHdAxICNghxoBoAAIYgfo/CJUET +rgov9/zYK/ADEgE2GwjeJG8gQwCgGQAAiiAIAAYaGDCKIEQC2/EdCJ4kANiXuKAZAACKIAgABhoY +MIoghALP8aQRAABTCJ4GBdgQuKAZAACKIAgABhoYMADdz3CfALj/WBgACApwFgygAMlxA97Pd6AA +1AfSp7IND/3PcIAAfCMAgIDgzCUikAP0Ex+YkwPIoBAAABjwCerPcoAApD8QggHgEKLS8QohwA/r +cgolAAgy2Iy4z3MAACUJAQUv8QokAAQocOUAD/DxwKQQAQAPCV4C/gmP/dHA4H4odIQkEpAR8g0J +XwZaDI/2B/Ag2c9woADIHCmgA9nPcKAAEBQloOvx6/HxwD4ID/AKJwCQOnEA3Rby6XEvKEEATiCC +B89woAAMLU968CCAAMK4DyUNEADYDyCAAAYhAYDv9SrtLyhBA04gjgcNGpgz9dgFuM4Kb/fJcQ3I +z3KgABQECqLPcaAAZC7wIQAAUyDQBCmCQgkv99rYKnBuDK/1BCDBI+YKL/vJcADYDyCAAwYlDZDZ +9c9ygAAwOgCCB9kNGlgwPwjQAc9woAA4LgWABCCAD8AAAAAjCIAPwAAAAPXYBbjPc58AuP8aozuj +adgYuBmjAdgC8ADYBwhRACCiz3CgABQEKqDBB8/v4HjxwGYPz+8odkYhzQAdZTIIIAAiucG+Hw5Q +EBMOkBAdDtEQABaAQAEdEhAAFoBAAR0SEAAWgEAArZkHz++rCRAAQCHCAyS6w7kC8ADZlQkVBDMm +QXCAAGxkQCcDcjR7AHsAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYB +QAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFA +BBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAEIiQoCz9eB+gOHKJE1w4HjoIK0BABYBQQIYVADg +fuB48cBeDs/vAN3PdwAABB1KIAAiqXYVIoAzDhABBgDYz3KgABQEyqKooieiBKI9ZYjhaLnKIQ4A +/ghv9+lwQiBQICDn1Qh1oAHmeQbP7+B/ANjxwAIOz++hwRpwSiMAIAAcwDSKIAcJYg/v9gpxz3CA +ADxgMiASBM9wgABcCdGIEogQdlIBCQBqdwohwCQC8Hp1RC6+EwAiQC7PcYAAqOgzIQ0Au30vCDMm +rX3PcYAAOBwagTuBJHgfCB4Cz3CAAFwJC4iLc8lxggyv96lyAMACfa19ACaAH4AAXAkcEMEAz3KA +AMhAAIoF2i4PIACpc89xgAB0XSCBAN1KJIBxInioIEAFc250e7V7z3KAADSkeWIhiXpiCukjCQAA +KQhCADENUxEB5a99C/BCJZEQLyFHJGG9r30Q8AMSzwAA2Wp1DfCA5UohACDKJWEQBvJCJVEQLyFH +JAHZLenzbvR/FSdBE89zgAA0pDpjACNFABUnTxT5YyGJQYr7YzUJowDjiwIiRAADFYIABL/wfyJ4 +BLovJAgBAieDEGx4LyBGDoIO7++IcQ54An8I5+5/RL/tfwsIEiYK5+1/yXAKcaoMIADpcgHmz3CA +AFwJEojPfhB2wgbM/9kE7++hwPHAhgzP7wh2KHVIdxpzT3kQuQ94CLgFeYogRwjSDe/2pXmA58wg +IqAI8ixtL3nPcIAAXAkzqAfwz3CAAFwJs6ipcc9ygABcCbSqwKr1qhYaAgQOCiAAyXAAEIcA4YjP +cIAAXAnRiBKIEHaeAQkARC8+By9xhC4DEQokQA4AIUMOCiGAH4AArKQhc0AvggBUeoQuARUKJUAO +ACJNDgomgA+AAKznACZIAwAmjR+AAFwJTCcAgMwnYoAm9BoTwAAA2RitGxPAAEokgHEcrRiLIB0C +EKggQAYUIEAQQYizbrR9NX3HdYAANKQAEMAAQK0VI0IAAa0BEsAAAeECrQCKL3kDrXrwARPAAJjo +ANpYrVytIB2CEEokgHEA2aggwAMTbhR4NXjHcIAANKRAqEGoQqhDqAHhL3lg8Hy5ACREAGy6ACJB +AQAhhQEAJEACGog6i/oIIADpchitACRAAhuIO4vqCCAA6XIcrQAkQAIYiDiLACREAtYIIADpciAd +AhAA3UoigBEUJUsDFCBJEwETgBABEYEQtgggAOlyM240ebV5x3GAADSkAKnYcQATgBAAEYEQmggg +AOlyAR4CABUkSwMVI0kDAROAEAERgRB+CCAA6XICHgIAABOAEAARgRBuCCAA6XIDHgIAQiJKEAHl +mQp1kK99AebPcIAAXAkSiM9+EHZuBsz/ANnPcIAAcF3dAu/vIKjxwOHFz3WAAMhAiiDHCc4L7/Yg +hQCFz3GAAGxdIIFNaDBywCBsAcwhDIAkCwkAwQLP7+B4AnkteUx5ViEBcke5OGDgfw944HjxwLhx +NQhRAAkNUgAdDdIDCiHAD+tyz3AAANcUiiOIAn0G7/BKJAAAQC2BAGS5ACGAD4AABBYd8M9wgAAM +GjIgQQGMIcOPyiHBD8oiwQfKIIEPAADYFMojgQ8AABACQAbh8MokIQDPcIAANBg1eNHA4H7gePHA +z3KAAG4JCmqiCSAAKWoGDgAAzggAAM9xgACYdCCBz3CAAMgUIgggAAHaz3GAAJR0IIHPcIAA9BMO +CCAAANrRwOB+8cBuCc/vGnBId5EJcgAA3TpxFSBAI0CIAogM7892gAAEFhV+ArgUeMdwgABcFQvw +z3aAADQYFX4CuBR4x3CAADwWIYhLCR4ABRDBACKuBhDAAAOu6XC+DCAASHEAroDgzCBigMogIQAS +8kQoPgcAIYB/gACopMUQgwDhEIEAAiLAABB4B7iuCu/vYnkBrkIhQSCBCXWAAeU1Ac/v8cDaCM/v +z3CAAFwJERCIAM9wgABcCRKIqwgCAkomAABKIcARRC4+By9whCgDESdwACCBD4AAqKQfEcsAACCB +D4AAqKQeEcoA+HAA3gbfACeND4AAqKTVfQeNaXEF2phwLgogAAUVwxBALoIAVHqEKAEVACJBDtR5 +x3GAAKznuHEAqYhwSXEH2gYKIAAGFcMQAR0CAGG/Aea3D3WQz35CIUkQQCZGAIEJdZAvJocBQCBI +EM9wgABcCRKILyAHEmEIA4KBAM/v4HgC22CoANgAqQHY4H8AquB4ocHxwP4Pj++hwWXCCHYodc9w +gACCCYXBi3JAJEMwwgsgAACIRC6+FgAlQB4UFMEwz3eAAPim+GB3DTMWIKhTJYAQTQhTAUYlzRGv +fRvwARSAMAAmgR+AABjlUm1UellhIMIAqUQuvhYAJUAeRKkUFMEw+GAgqMlwXgggAKlxAeWvfVMl +gBDLCFKBIfABFIIwEm0UeAAmgR+AABjlOGBAqCDCRKjJcDIIIACpcQ/wQiUAFg94ARSBMMd2gAAw +5gK4FHgeZiDAKK4Mrgjcnwev76HA4HjgfuB48cAmD4/vAN7PcKAAtA9wEBAAiiDHCM9xgADIQHII +7/YggSYPL/3JcM9xgABcCbKJEYklDQIQz3KAAJCsf9sUIA8AX2dgr8GvAeAPeAXb8Q0jkGKvz3CA +AKikQZDPdYAAdF3ApQjqz3CAAHxdAICMIB+EBPYA2RXw/QiDjwAAoA9CeECJgOKKIQ8KwCjiAAX0 +RCi+Ay9wUgjP7whxAKXyD6/2iiDHCADdDt7Pd4AAgGJqCO//qGdhvgHl+Q51kK99z3CAAMhAIIDP +cIAAbF0goHYOL/0vIAcEsQaP7w54LHgpagDYDyBAACdwWnjgfw4gwADgePHAJg6v74oghwjPd4AA +XAmKD6/2M48Aj/IL7/8zj89wgABoXQAQ0ADPcYAAdCcUj0eJIQoBAACPIYkZCEEAz3CAAHFdABDA +AAkgAAQvIAUgsY8E8AHlr30SjxB1+gAJAADeSiKAI89wgABpXQCIEehELb4TACZAHs9xgABoXQAR +wgAAIIEPgACo6ECpXvDPcIAABDAggGB5ANgbCBEDz3CAAHBiyWACIEAgDXhIIEAAA/BIIEAgLyEF +IM9wgACAYstgE4+pcW4Pr/ZVjwkgQAQvIQUgz3CAAAQwIIBgeQDYACWTH4AAeAkZCBAEz3CAAAQw +IIBgeQDYBBOBIBkIEQPPcYAAwAvJYQQTgCAieAkgQQQJ8M9wgABgYshgAnkJIUEERC2+EwAmQB7H +cIAAqOggqDpwE4+pceoOr//JcgARwSACeQAZQiBCIlIgAeYbCnWgz36A8SkFj+/gePHA2gyP7wh1 +z3CAADcwAIgodxMNARDPcIAANjAAiFMPABDPdoAAXAmpcEAmgRLOD2/3QCbCEgqOr3orjhi6CLgF +eoogVA36Da/2RXkqjgRuhg5v90uOCo76DG/3K47PcIAANzCgqM9wgAA2MOCo1QSP7+B44cWZ6Iwh +wo0B2Fn2SiSAcc9zgACIpaggwAOha0QoPgcyJU0eFw1DEAftEwiQAQHgD3gA2APwYbgPeOB/wcXg +eOHF4cYAEc0ACQ0TEADdoKkb6A0NExAA2ACpAN3PcIAAAGEAkAsNAhCpaK19oKnPcIAAWGAUIE4D +oI6gqgARwQA0eAGIGfALDRMQAN2gqc9wgACsYQCQDQ0CEKlorX2gqc9wgAAEYRQgTgOgjqCqABHB +ADR4AYgAq8HG4H/BxeB48cCqC6/vANihwQAcBDDPdYAAQAoAlc92gACopMlxiiIECgIPL/cB24/o +CiHAD+tyABUEEc9wAADbFIfbi7vZB6/wiiUECgAWhBBMJACByiHLD8oiywfKIIsPAADcFMojiw8A +AIwAzyPrAqwHq/DKJSsAUg2P9oDgyiHCD8oiwgfKIIIPAADdFMojgg8AAJIAzyPiAsokIgB8B6Lw +yiUiAItxRdgB2n4OL/cB24/oCiHAD+tyz3AAAN4UlduLu4okQQFVB6/wSiUAAAAUADEB2YYg/g/A +4MB5z3CAAAwbIKg1A6/vocDgePHAwgqP7wh113UlAACAANhK989xgAD44iWBJQlFAyJ9AeD58c9w +gAD44sWAqXAuDK/vyXEFLj4QAiVNHowgEIDKIcYPyiLGB8oghg8AAM0iyiPmDMokJgDUBqbwyiUG +ARa4zQKv76V4z3GAAAAKDQhRAAHYAKkBqQCJgeDKIIEPAADECcoggg8AAIAA4H8BofHAMgqP7wh1 +z3aAAMwyiiDYDoILr/Ygjoog2A52C6/2IY4AjrhgAK4Bjh1lcQKv76Gu4HhBiQK4FnjHcIAAkNpI +qCKJ4H8pqM9xgABIJPAhAQCKIAgA4H8OoeB4DRICNgQgvo9gAAAAz3OAAMzNVHvHcoAAPM4IcQXy +A8gckBcIngIEIYEPYQAAABMJgQ8BAAAAANgAswHYHPAMzAMSATYbCN4BMhGBAAGLDQhBAADYAavz +8QHgAasL8DERgQAAiwsIQQAA2ACr5/EB4ACrAtjgfxiq4cXhxs9ygABMCYDgwCIiAf/dEmkWeAAg +gw+AAJfaoKsA3UokAHHPc4AAeOKoIIACrmJ4ZTZ4xKiuYgHlr33AqMHG4H/BxeB48cAWCa/viiDK +BaHBz3WAAGg8QJXPdoAAZDwglhC6Wgqv9kV5z3CAADgeAIB3CJAAAIUghk0JAADPcIAAlCoEgEDB +DQieAE8hAAFAwIjptggv9QDYqggP9SoOz/aLcATZodo92w4N7/wXuyCGCekAhYfokggv9QHYlgzP +9iCGIKUR6aoJD/V/2Aq4z3GgANAbE6F/2BChANiVuBCh+gjv8QHY4QCv76HA8cBqCI/vz3GAAEgk +FXlAgQiCBCCDD4AAAABEIA8CL7sGv2V/BCCDDwABAABBK04D5X4su8V7wRIOBsASDQZhC4ADBCC+ +j4ABAAAe8s92gACQJ8iOMQ7REb64CKJAgQiCBCCDD4AAAABEIAECL7sGuWV5BCCADwABAABBKEMD +JXssuAV7wRrYAArtLylBA04hgAcSCCAAECUNEPntNQCP7/HAyg9v75hwGwgUBAohwA/rcnHYjbiK +I40LIQSv8EolAARKJAB0ANuoIIAOQCyNAXV9QCyCAMd1gABQ3gCFz3GAAJDaVnrduEFhAKXxudEg +IoII8kQgAgYjugHiFQqVAM9ygADQ3BYiAgFAigkKHgCeuBTwLbnAuc93gABIJPAnTxBSIE4CwRcB +FgshgIMH8iiH4Qmeh5+4AKUB45UHT+/PcYAASCTwIQAAz3GAAHjNuxACBroQAwZCoWGhvBACBr0Q +AAZFoeB/BqHgeM9xgABIJPAhAADPcYAAeM2+EAAGFiECAAKSGrEDkhuxCIo4GQIAANjgfx2x8cDh +xc9zoACsLxmD8LgZgwDdDPIEIIAPCAAAANdwCAAAAAHYwHgH8IYgfw+C4AHYwHga6BmDBCCADw4A +AABCIACAyiBiACEIUAAKIcAP63JkEwQAz3AAAK4NmdvlAq/wSiUAAP4I7/ZU2EQgAQJHCB4Bz3Kf +ALj/vaIc2hXwz3OgAMg7VoO2g4Yi/wiGJf8YpXq2g4Yl/xiles91oACoIK2F5OWQ9+3qAtvPcoAA +OB5golEgQIDPcoAAZDwAghHygbgQ8DgTBABYEwUACiHAD+tyz3AAAJkhaQKv8C/bobgAoj8IngDP +coAAeF0AgjMJAADPcIAADhsAiCCiFQhRAM9xgAAoPACBCQhSAGq4AKEB2c9wgAC0IhII7/0gqC0G +T+/geOB+4HjPcYAApD9cGcAHz3GAAOwiUIGduJ64IILPcaAAyBwNoeB44HjgeOB44HjgeOB44HgA +guB+8cDhxSDdz3OgAMgfsKNDGxgAANi6D+//jbixo9EFT+/xwFINT++hwRpwKHZId4ogEQWqDm/2 +etmKIBEFng5v9gpxiiARBZYOb/bJcYogEQWKDm/26XHPcKAALCAwgM9wgADEOyCgz3CgACwgEIDP +cYAAxDsggc91gAA0OiJ4AKWLcboLb/AKcACFFQjFAwAUADHEeNMOAZAB2APwANg5BW/vocDxwM4M +T+/PdaAALCBAFRAQQBUFEA8J3wIEIL6PAAYAACbyTQkfA892AAAQJwfwYtj6Dy/2jLhAFQUQz3Cg +APxEGYDsuAIlAAQD9OcIgoMhCIIPAAAQJwohwA/rcoogmgpp24y73QCv8AokAATFBE/vz3CgAPQH +8cBXCB5DJ4AZgDB5OGADuJYgQgXPcaAAyB8eoRDYDqEB2BUZGICODu//gdgvCB5Dz3CAAERdAdkg +oAPIpBABAJq5pBhAACYIr/4B2M9xgAAgQA2BAeANoQPZz3CgAPQHKqDRwOB+8cAA2QrYz3KgAMgf +HqIQ2A6iAdgVGhiAKHAH8AHZBCCADyAAAABRIADDzCEhgMwgIYAX9CsLH0DPcAAAnxcSDw/2z3Kg +APxEHYJZggDZ0QrfggQgvo8ABgAA4vXh8S8LHkDPcIAARF0B2SCgA8ikEAEAmrmkGEAAjg9v/gHY +z3GAACBADYEB4A2hUSAAwwDYCfTPcYAApD8QgQHgEKEA2Ji40cDgfuB48cBKC2/vANkId89woAAs +IEAQEADPdZ8AuP8dhc92gAAwCT2lAKYM8AoNT/DPcA8AQELaC2/zCnEhCFAAz3CgANQLGIBCIAAI +SCAAAN0IxIMAhh2lWQNP7wCGCiHAD+tyXtsdpc9wAADOIookww9RB2/wuHPxwMYKb+8B2aXBGnDP +dYAATAladaILb/+LcAAUhTABFJEwCwhRIEAlEhELDVIAHQ1SAQohwA/rcs9wAAApJazbCQdv8Eok +QABMJQCAJgEOAKhwABaOQAAWlEAPDDIkenCMJMOvJfQAFgBBABaPQAAWgEAAFgBBhQwTJCjvz3CA +AAAaAIBALM0gtX0Q4LhgKgtv/wTZz3CAAAAaAIBMIUCgHWXMJ2GTGvQA2Iy4F/AKIcAP63LPcAAA +KiW320okQACJBm/wCiUABQohwA/rcs9wAAArJcDb9PEA2AC1z3CAAAAaAIBALMEgNXkyYDhgBSJC +BECwBN0H8IHABN26Cm//qXEAIowjABwCFc9wgABIJPAgAAQe38AQAgYvKYEAAidAECTqMmjPc4AA +l9o2eStjEwuOAwAmgR+AAHjiFnkAGQIFAC2BEwshwIAJ8gAmgR+AAHjiFnkEGQIFECICgC8pgQAC +J0AQ4PVCI0AggODmBs3/4g8P9KUBb++lwOB+4HjgfuB44H7geOB+4HjgfuB44H8B2OB+4HjgfuB4 +4H7geOB+4HjgfuB44H7gePHALglP7wh1BvDPcAAAaw52DA/2z3agAMAvoxYAlu8IHoEHyEAeGJAN +yA8IkQFGDS//qXB88M93gACI5wqPCehAJ4ASQCWBEgoPL/0K2s9woADUCxiAQiAACEggAACw4IAN +5f/KICUMA8gDkCW4wLgXuMdwAA4AAEUgAQvscCCgARIBNuxwIKAghexwIKAhhexwIKAihexwIKAj +hexwIKAkhexwIKAlhexwIKAmhexwIKAnhexwIKAohexwIKAH8M9wAABODsILD/ajFgCW9QgegQfI +BCCADwEAAPAsuJTgwCCGDwAAkwDPcaAAaCzwIQ0Az3CAAEhdwIDZ2JYJb/YFJkETAg8v9AUmQBMq +jw7piiBSDX4Jb/aHuc9xgAAMQBeRAeAQeBexANgKr2kAT++hwfHA5g8P76PBTMEacEh1OnMKIgAh +aQleAgLZz3CgAMgfSRhYgCzBU23u4VB4BvQCCC/zgcEa8BEJ0Q0beBB48g/v8oHBEfAJCREFHHgK +8AsJkQIEHIQwBvDPcAAA//8EHAQw4HgA2M9yqQCk/7miBBQBMYK4N6IaognwbwkeAkwiAKDRIOKh +BfLPdaAAyB9M8M9ypQCs/89wgABIJLiiBIBWEAABFOACIQMgA+Miu3hjeGBIIEAABbhFIEADFqJB +KMAhwLh3aCzABCGBDwAAACAluc91oADIH2V4JXiJuI64GaJAFQAWIPAswIDgyiHBD8oiwQfKICEO +zyAhA8ojIQXPIyEDyiQhAGQDYfDKJcEABb2leM9xpQCs/xahz3WgAMgfQBUAFs92oAC0R1cWAZZK +IwAgSiRAIAQhvo8AKAAAz3GAAOwiMIEggcIkAiUF8LLYAgov9oy4bxYAlgQghA+AAAAABCCCDyAA +AAAEIIMPAAYAAA8MECBAFQEWCwnUAADZAvAB2RMVD5YEIL6PADgAAAQnjx8AAACAzCEhgMAjYSAF +IgEB5XkFIf6ABPSjC5SiBe+A4swjIYCN8msWE5abCxAganSEJNCRCvLPcYAArD4QgQDdAeAQoZy9 +X/AVC94gz3GAAKw+EYEB4BGhQt1V8Gp0hCQCmAnyz3GAACBAEYEB4BGhDfAVC54hz3GAACBABIEB +4AShBfBTIz6jA/IA3TvwGQteI0YLT/3PcYAAnEAFgQHgBaH18SoIz/QKIcAP63JvFgWWRNiMuOnb +jLsdAm/wCiTABAnqz3GAAKQ/EIEB4BCh3fEu6xcIngbPcoAAIEAvggDdAeEvopG9CvApCF4Gz3KA +ACBAMoJC3QHhMqKaCO//anHd2ADZxg4v9pi5mL1J8HEWBJZvFgWWCiHAD+tyOdjPcwAAAhGxAW/w +jLiqCk/9z3GAAKQ/EYEB4BGhp/ETFQCW8LjKICEAdA+h/88goQNrFgGWWBYAlgsgQIAg8m8WAJbP +daAA9AdTIECAAdgQ8gml4HgA2Amlz3GAAJxACIEB4Aihz3GfALj/FqHqCG/+AdgD2AqlBd2YvQPw +AN2X7RcI3iEdChEgAdnPcKAA9AcsoAPZBfAD2c9woAD0ByWgUSCAonAPgvke8AMSATbPcIAAiOMP +CQAAz3CAAFDkGwkBAJIRAAGquJIZBACeEQABqrieGQQAz3Gg/mQAz3CfALj/NqDPcIAAjAkAgAfo +z3GAAMQqBYEicAWhz3GAAKw+D4EB4A+hz3CAAJS/IYDPcIAASCQDgBSQHQkBAM9xgAA4HBqBO4Ek +eFEgAILYCuL2yiBiAKlwCNxPBC/vo8DgeKHB8cD+Cw/vKHUIdhpyBCG+jwEAAMBody30Lw0eEkQl +ABYjuCFoBCWAHwYAAAAxuDhgBCWBHwYAAAHXcQIAAAHKIKEAAvAB2CEIUAATCJAAg+AA2Mog4QHA +KKEDCvDPcIAAvM0CgAbwz3CAALzNAYAFfclwnghv+qlxyXCpcQpy6XOKC+//SiRAAIDghA+B/wjc +1wMP7+B4z3CkAJBBTYDPcYAAMNBCsRqAA7EEIIAP/wAAADC4BLHPcIAAMNAA2hEIXkbPcYAAHM8y +gQsJngJCsEOwRLDgf1mw4HjxwCoLL++YcM9wgAAczw6Qz3aAADDQALbPcIAAHM9IEAUABCWPjwAA +AAIA2wPyFw0eAs9xpgDo/wuBA6YMgQSmA/BkpmOmz3WkALRFDBUClg0VAJb/2S8ghxAQuQQiSQAs +7zIVAZZTIY8A/2chtv/Z9H8Iue9/RHlALwYSACZHAAAgyBMFJwcCQC8BFgQigg8A/wAAQC8IFDpi +ACBIEv/ZBScHAgi5BSLCAQQgRwD4YAAngQEleOW2T3kEIoIP/wAAACi6RXkjtg94BLYEFQCWArYj +DR4CRCUABiO4AeAXCJQAz3GmAOj/DYEFpg6BBqYD8GamZaYA2kokgHAG2Y25qCAAAynYErjwIEMA +QCYAH1V4AeFgoAHiz3CAABzPAJA4HgARVSZBFBq2z3CAAAjQ0ggv/QjaGxUAls9xpQDYyxmmHBUA +lhqmHRUAlhumDoEcpg+BHaYmFQCWHqbPcKQAkH8cgC0CL+8fpuB44cXPdYAAMNAJpSqleLVLpQHY +GbXgf8HFSiQAegDZqCCAAgDaz3CAADDQNXhAoAHh4H7geADZIKDgfyGgBAAAAABAAQAAAAAAqBJD +dQEGAAEAAAAAAAAAANhAgABsQYAAAJiAAMwigACsC4AAbCDAEA8bCSLcHcAQCgAbQBAAG24eAABh +CgAbQeQdwBEAAAokAAAKJQEACib+BQpkQAAbcAIAAGEIAF9wBQAAYSAAG3AHAABhCABfbgEAAGEE +AABhtECAgQAAwBYBABsmAADAFwEACiQAAAolDwpjIggAX3AKAABhDxwdIgkAHSYPXxsiNByAgQAA +wBc7AABhAAAbJQABGyRcHMARNwAAYTQcgIEAAMAWIAAbcDMAAGEwHICBAADAFg8bCiIPGxoiDwkb +IgEAGzAAAMAX9/8MJP//DCUIABowBAAaJwAMGjkAAMAWDwkLIgEAG3AZAABhABsJKSgcgIEAAMAW +ABsJKQCACXATAABhDwoaIggAGjAIABonAAwaOQAAwBYBABtwEQAAYQ8LCSIAGwkpKByAgQAAwBYA +GwkpDwkbIgCACW4EAABhKAAJJAAJGykAgBtwBQAAYSQcgIEAAMAWAAsbKCwcgIEAAMAXDwobIgQA +GyYADBs5MByAgQAAwBc0CICBDxobIgAAGyUCABtAAAAbcdgIgIEAAMAWDxsLItwIgIEAAMAWDxsK +IuAIgIEAAMAWDxsIIkwrgIECAFxuEQAAYfhBxBAPGwkiAAsJOQIACmIDAQpiBAIKYgAACUAEAABh +CQAJQAIAAGEKAAlAAAAAYQIACUEACRooAADAFgEAGyYAAMAXBAAdJgEACCfpAAhkDyAbIuAIgIEA +AMAXNAiAgQ8aGyIAABslAgAbQAAAG3EPRQAiAFwAOQcAAGIGYABiAABYOGBFwBBwRcAQeEXAEJBF +wBB5AABhD3kTIugdwBEBAFIktB/AEAIAE3ADAABhCABYMAgAZDEHAABhDxNSIuwIwBJCBBMkCAAT +MQEAUm4QABMxBCjAEQgAWG7oDwBhAAATJQAAEyQkEMARgAATJUdoEyQEKMARAIATJDgcwBEPABMi +AQATMAQowBEPcxMiggETMAQowBEPdBMiAgITMAQowBEPFBUiAQAVJg9yEyIIAMwRD0QAIgoAAEAA +QABwDgAAYQAAEyUCABMk7BzAEQ92EyIYCMoRCQATQBwIyhEJABNAIAjKEQ94EyIEAMoRAAABJAAA +ASUGAABhD3YTIixIxxEPeBMiAADGEQMAASQAAAElAAATJcIsEyQEKMARAkYTJAQowBHCXxMkBCjA +EQ9FACIAXAA5LAAAZAAAEyQBABMlOBzAEQ93EyLgHMARAgABYg8BEyIECMARwAjAEgQowBEPEwIi +xAjAEgQowBEPEwciyAjAEgQowBEPEwQiAgBxcAcAAGH/ABMlAhATJAQowBEAABMlAAATJMhJxxEG +AABhAAATJQIQEyQEKMARAAATJUkAEyTISccRD3ATIgEAEzAEKMARAwATJAAAEyUECMARAAATJDhF +wBHMCMASGCjAEQ8TAyIEAABhAABYOAAAEyQBABMlOBzAEQAAFSQAAAAhrAiAgQAAwBYPG1AisAiA +gQAAwBYPGxoitAiAgQAAwBYPGxkiuAiAgQAAwBYAAACFqAiAgQAAwBYPGwQiHAQbZhsBG2gUHMAQ +CgAbQAQAG24LAABhDxwdIgEAHSb5DwBhvAiAgQAAwBYFABtiNAiAgQ8aGyIAABslAgAbQAAAG3Fk +DAAQAMAGEQEABCf8AARkAAAbJAIAGyU4HMARNAiAgQ8aGyIAABslAgAbQAAAG3EAABslQAAbJDAc +wBE0CICBDxobIgAAGyUCABtAAAAbcZBFwBAPZAEiCgABQAgAAXAqAABhAAABJAgAASUPAWMiCABY +bgYAAGEkEMAQAQATbgIAAGEAAlwxAQAAYQAgWDDkCEAS//8Tbv0PAGEBQhMkAAATJQQowBHkCEAS +//8Tbv0PAGHsCMASQgQTJBgAEzEEKMARYEXAEHBFwBADAH1iAgATJAAAEyXoHcAR+P9MMwEATDEB +AFIk6AhAEv//E24DAABhJBDAEAEAE3ACAABhAAAVJAAAACEPAABhD30TIugdwBEBAFIktB/AEAIA +E3ACAABhCABkMQAAACEPE1Ii7AjAEkIEEyQIABMxAQBSbhAAEzEEKMARSAmAgQAAwBYCARNkQgET +JAQowBFEXYCBAADAFgYBE2IECMAQBAATZA9cACIKAABAAAYAcBkAAGEAABMkAAATJQAAwBcACFgw +yCDAEHBFwBAQCMAQAAATJQMAEyQcCMARHAjAEQAAEyQECMARDxQVIgQAFSb7/zAyAwATJBgIwBEP +FBUiAgAVJgQAMDAAABMkEEXAERgIwBEAEFgwD3wTIggAzBEAABMlAAATJDRIxxEPexMiAQATMAQo +wBEPFBUiAgAVJv8AEyUCEBMkBCjAEQ8UFSICABUmPAqAgQAAwBbCLBMkBCjAEQJGEyQEKMARwl8T +JAQowBEPTRMiBBDFEQIAEyTwHMARAQATJOwcwBEAABMkcAATJRAcwBEAABMlAAATJOAcwBGAABMl +RmgTJAQowBEAABMlAQATJCQQwBEAABUkAAAAIQ8OGiIAAEAWAAEbcA0AAGGAAGMk//4bMgAAQBcA +ABslDxsPIhgJgIH/ABsyAgAbQQAbGigAAMAWAAAbJQIAG0AAABtxAQBkcAcAAGEBAGMkAAAbJPoI +gIEAAEAX8AiAgQAAQBbtDwBhAgBkcBAAAGECAGMkAQAbJPoIgIEAAEAX8giAgQAAQBbkDwBhBABk +cAcAAGECAGMkAgAbJPoIgIEAAEAX9AiAgQAAQBbbDwBhAAAdJAAAACEAAg9uCQAAYfoIgIEAAEAW +AAAbJfYIgIEAGxooAAAAFgEAGyYAAAAXDQAAYRAJgIEAAEAWAgAbJgEQG2gAABskAABAF/wIgIEA +GhsoDxsOIhQJgIEAAEAWAQAbJgAAQBd8B4CBDxobIgAAGyUCABtAAAAbcQAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsBIAAuAGAAAAAAAAAAAAA +KACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAcAAAAAAAAABwAAAAkNERQKDRMXGRkZGQkJAADwrYAA +eIEAANiygAAAAAAA2LKAAAAAAADfAAAAGQEAAGIBAAC+AQAAMgIAAMMCAAB7AwAAYgQAAIQFAADy +BgAAvggAAAILAAABAAAAAAAAADCAAAAAAAAAMYAAAIiIMzMygAAAAKqqijOAAAAAAAAANIAAAAAA +AAA1gAAAAAAAADaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAAAAAAA7gAAAAAAA +ADyAAAAAAAAAPYAAAKqqCgA+gAAAU4WIiD+AAAAAAAAwMIAAAAAAAAAxgAAAmplYVTKAAAAAqqqq +M4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAAAAAAAAA3gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6 +gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAAqqoKAD6AAABVmJmqP4AAAAAAAFAwgAAAAAAAADGA +AAAAAAAAMoAAAAAAAAAzgAAAAAAAADSAAAAAAAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAA +AAAAAAA5gAAAAAAAADqAAAAAAAAAO4AAAAAAAAA8gAAAAAAAAD2AAAAAAAAAPoAAAAAAAAA/gAAA +AAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAAADOAAAAAAAAANIAAAJp5AAA1gAAAqqqqqjaAAAAA +AAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAKqqqgo7gAAAAHCZqjyAAAAAAAAAPYAAAAAA +AAA+gAAAAAAAAD+AAAAAAAAA//8AALQAIAAZASAAtQAhABoBIQAEAAgA1AEDALMBBAB4ADwA3QA8 +AHkAagDeAGoAqAABAA0BAQCcAcwAnQHMANUBzADWAcwApAGAAF0CNgBKAg0ATAIPAE0CAQCtAQYA +uAEAALsBVgCPAIgA9ACIAJAAAAD1AAAAkQAGAPYABgCFAAQA6wAEAFACCwBRAgMAUgIBAFMCAABU +AgsAVQIDAFYCAQBXAgAAuQHBANABAABmAgYAaAIHAGoCBgBsAgcAbgIFAHACDAB9AgYAfwIHAIEC +BgCDAgcAhQIFAIcCDAChAUAA+/8AAP//AAC0ACAAGQEgALUAIQAaASEABAAIANQBAwCzAQQAeAA8 +AN0APAB5AGoA3gBqAKgAAQANAQEAnAHMAJ0BzADVAcwA1gHMAKQBgABdAjMASgIOAEwCDgBNAgEA +rQEHALgBAAC7AVYAjwCIAPQAiACQAAAA9QAAAJEABgD2AAYAhQAEAOsABABQAgsAUQIDAFICAQBT +AgAAlAILAJUCAwCWAgEAlwIAAFQCCwBVAgMAVgIBAFcCAACYAgsAmQIDAJoCAQCbAgAAuQHBANAB +BABmAgYAaAIHAGoCBgBsAgcAbgIFAHACDAB9AgYAfwIHAIECBgCDAgcAhQIFAIcCDABLAgEAoQFA +ALIAMAAXATAAswAAABgBAACcAg8AoQIPAKACiACfAogAngKIAJ0CiAClAogApAKIAKMCiACiAogA ++/8AAAAAAAACAAAADdIS0hPSFNIM0hXSC9IC0hHSBEMAEBQQCRAREAFAG9Ic0gDSCgALAAQADgC1 +ABoBDwBCALwAwwAhASgBtgC3ALgAuQC9AL4AvwDAABsBHAEdAR4BIgEjASQBJQERAAAACgAAAAoA +AAC2AAAAtwAAALgAAAC5AAAAtgAAALcAAAC4AAAAuQAAAL0AAAC+AAAAvwAAAMAAAAC9AAAAvgAA +AL8AAADAAAAAEtIAABLSAAAAAAIALABkAHQAgACMAKEABwAAAAAAAQACAAMAAAAAAAAAAAAAAAAA +AAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAcAAAAAAAAAAwAAAAQAAAAD +AAAAAAAAAP8DAAADAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAACwAAQAAAAEAAQABAAAA +AAAAAAAAAQABAAIAAgACAAMAAwAEAAQABQAFAAYABgAHAAcACAAIAAkACQAKAAoACwALAAwADAAN +AA0ADgAOAA8AAAABAAIAAAAL0g7SDdII0gnSCtIS0hPSFNIR0hDSAtIB0gPSAIAF0gRDG9Ic0gTS +AEUw0jHSAAC1ABoBgQEFAAQADwAQAAoACwAMAE4AAAAAAAEAAgAAAA3SEdIQ0gLSAdID0hvSC9IA +gAXSEtIT0hTSBEMI0gnSCtIc0gbSB9Jw0gAAtQAaAYEBBAAPAIMA6ABOAZIA9wBdAQYACAAJAAoA +CwAMAAUAAAAAAAAAAAAKAAAAAQAAAAAAAAAAAAAAAAAAAAMAAAAEAAAAAwAAAAAAAAADAAAAAAAA +AAAAAAAAAAAAAAAAAP8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAABAAAA +AAAAAAAAAAAAAAAAAAAAAAEAAQABAAAABNIN0hHSENIC0gHSA9Ib0gCABdIL0hLSE9IU0gRDcNIA +AAAAAQAAAAEAAAABAAAAAQAAAAMAAAACAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAP8D +AAAAAAAAtQAaAYEBBAAPAAYACAAJAAoACwAMAAAAAAAAAAAALAABABUAFQAVAAEAAQABAAAAAAAB +AAIAAAAc0g3SEdIQ0gLSAdID0hvSC9IAgAXSEtIT0hTSBEMG0gfSBNJw0gAAtQAaAYEBBQAEAAYA +CAAJAAoACwAMAIMAkgDoAPcATgFdAQ8AAAAAALcTIgC4FCMAuRUkALsWJQC8FyYAvRgnAMAZKADE +GikABxsAAAgcAQALHQIADB4DABAfBAAiIQUAJCIGACYjBwAoJAgAKiUJACwmCgAuJwsAMCgMADQp +DQA4Kg4APCsPAEAsEABkLhEAaC8SAGwwEwBwMRQAdDIVAHgzFgB8NBcAgDUYAIQ2GQCINxoAjDgb +AJE6HACVOx0AmTweAJ09HwChPiAApT8hACRJBgIsSgoCNEsNATxMDwFkTREBbE4TAXRPFQF8UBcB +hFEZAZVSHQGdUx8BAQQAAAIFAQADBgIABAcDAAUIBAAGCQUABwoGAAgLBwAJDAgACg0JAAsOCgAM +DwsADRAMAA4RDQABQAAEAkEBBANCAgQEQwMEBUQEBAZFBQQHRgYECEcHBAlICAQAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBwAAEQcAABM +HAAAyBsAAMwbAAA0DKAAQAygABwcoABAIKAAKCSgAGwQoAAYJKAAeCSgAHwkoACAJKAAhCSgAFAQ +oABUEKAASCagAGAQoABMJqAAZBCgAGgQoABcEKAAWBCgADAQoAA8EKAANBCgACwMoAAAgaQAAYGk +AAOBpACIJKAAjCSgAJAkoACUJKAAmCSgAJwkoACgJKAApCSgAIB1gAAAAAAAsgwsAf////////8A +Af//AgP///8E//////////////////////8F/wb/B/8I/wn/Cv8L/wz///8N////Dv///w////8Q +//////////////////////////////////////////////8R////Ev///xP///8U////Ff///xb/ +//8X////GP///xn///8a////G/////8c////Hf///x7///8f////IP///yH///////////////// +/////yIjJP8lJif//yj///8p//////////////////////////////////////////////////// +//////////////////////////8AAQABAQAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAwAAAAAAAAAB +AAAAAAAAAFgyAQAAAAAA+HgAAAEAAACUxwEAAgAAAOzGAQADAAAA+BcCAAQAAABYMgEABQAAABgf +AQAGAAAA9PAAAAcAAACgHwEACAAAANgvAAAJAAAAjFIAAAoAAAC0zQAACwAAALAsAAAMAAAA/BcC +AA0AAAAk6AAADgAAANDoAAAPAAAAsOcAABAAAACw6AAAEQAAAEA/AQASAAAAIOABABMAAACEJAAA +FAAAADRlAQAVAAAA+E8BABYAAAC0XwEAFwAAABjGAQAYAAAAnI4BABkAAAAsDQEAGgAAAFQyAQAb +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABScAAAUnAAAFJwA +ABSIAAAUnAAAFJwAAHiIAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAADgkAAA +KJAAABiQAABIjwAAUJAAAASPAAAUnAAAFJwAAPSSAADElQAA3JcAABScAAAUnAAAFJwAAHybAAD4 +kQAAMJIAAJyRAAAUnAAAFJwAABScAAA4mwAAFJwAAHyRAAAUnAAAFJwAABScAAAUnAAAFJwAABSc +AAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwA +ABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAADyJAAAUnAAA +FJwAABScAAAUnAAAFJwAAJyYAAAUnAAAFJwAABScAAAUnAAAFJwAAIiMAAAUnAAAmIwAAJSMAACM +jAAAkIwAAMSFAAAUnAAAfIUAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAAIUAABSc +AAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAoIoAABiKAAAUnAAAvIoA +ABScAABciQAAyI4AABScAAAUnAAAAJEAABScAAAUnAAAFJwAABScAAAUnAAATJEAADCRAAAUnAAA +FJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAAJyMAAAUnAAAFJwAABScAACY +mAAAFJwAABScAAAUnAAA0JoAABScAAAwmwAAOJgAABScAAAUnAAA6IMAAPiXAAAUnAAAFJwAAFCP +AABojwAAFJwAABScAABEjAAAFIYAABScAAAUnAAAFJwAADiSAADsjgAAFJwAABScAAAUnAAAFJwA +ABScAAAUnAAALI4AABScAAA8nAAAyJwAAKicAADgnAAAdJwAAFycAADonAAAOJwAABScAAAUnAAA +FJwAABScAAAUnAAAFJwAABScAAAUnAAATIwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAB4 +nQAAhJ4AAACEAAB0hAAAFJwAABScAAAUnAAAFJwAABScAABEhgAAFJwAABScAAAUnAAAFJwAABSc +AAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwA +ABScAAAUnAAAFJwAABScAAAUnAAAFJwAABScAAAUnAAAFJwAAEiGAABkhwAA1IYAAOycAACMhAAA +7IcAAISIAAAUnAAAFJwAABScAAAUnAAAcIgAAHSIAAAUnAAAFJwAABiIAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AACYqgAAxKgAAASsAAAIqwAAGK0AAAAAAQD/////AAAAAP//////////AQAAAHgRAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAA0P4AAAAAAAAAAAAAAAAYIKAAICCgAEAhoABIIaAA +HCCgACQgoABEIaAATCGgACggoAAwIKAAaCGgAHAhoAAsIKAANCCgAGwhoAB0IaAAOCCgADwgoAB4 +IaAAfCGgADAQAAAA/wMA0BAAAAD/BQB0EAAAAP8tAFAQAAAA/z0A7A8AAAD/BAAUEAAAAP8lAHjO +AAAA/90AmBAAABAQTAAAAAAAAAAAAAABAQA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8 +PBUVFRU8PDw8FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAAPDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8 +PDw8PDw8PDwVFRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAADw8PDw8PDw8PDw8PDw8PDw8 +PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAABAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANASAAAEGgAASBYAALATAADE +GwAAUBcAAPQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAADUCYAAgLOAABgAAABAs4AAAAAAAAAAAAAAAAAAAAAAAHQKAQBUuQAA +6CIAAFS5AABUuQAAVLkAADgKAAAg2AEAhNgAAFS5AABUuQAAACgAAAAoAAAAKAAAACgAAAAoAAAA +KAAAACgAAFS5AABUuQAAVLkAAFS5AAAYSQAAVLkAAFS5AABUuQAAVLkAAFS5AABo2AAAVLkAAFS5 +AAC4zQAAAAAAAGj0AABs9AAAtAIAAKACAACsPgEA4MUAACCyAQAIxgAAULIBACzGAACAsgEAODqA +AGyogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYA +BAAFAAYABwAIAAgACQAKAAoACwAMAAwADQAOAA4ADwAmACcAKAApACoARgBGAEcASABIAEkASgBK +AEsATABoAGkAagBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQA +dAB0AHQAdAB0AHQAdAB0AHQAdAB0AAoAPwAAAIQAhACEAIQAhACEAIQAhACEAIQAhQCGAIYABAAF +AAYABwAIAAgACQAKAAoACwAMAAwADQAOAA4ADwAmACcAKAApACoARgBGAEcASABIAEkASgBKAEsA +TABoAGkAagBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAcwB0AHQAdAB0AHQAdAB0AHQAdAB0 +AHQAdAB0AHQAdAB0AHQAdAB0AAoAPwAAAAAAQCEAAAghAACEtoAAAAIAAAAAAABEAgEAFAIBAIS4 +gABABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAIBAGw7AQAUv4AAVAAAAAAAAABEAgEAQDoB +AMS9gABQAQAAAAAAAEQCAQBoNAEAKAqAAAgAAAABAAAARAIBABABAQAAAAAAUAEAAAAAAABEAgEA +9DQBAMwygAACAAAAAAAAAEQCAQAANAEAJAqAAAQAAAAAAAAATAIBABQCAQBov4AAKgAAAAAAAABE +AgEAFAIBAMxAgAAIAAAAAAAAAAAAAAAcAgEAAAAAAAAAAAABAAAAAAAAADACAQAAAAAAAAAAAAAA +AAAAAAAAGAIBAAAAAAAAAAAAAAAAAEQCAQBEtAEAAAAAAAAAAAAAAAAARAIBAAS0AQAwCoAABAAA +AAAAAABuAG4AaQDAAKAAUACAAL4AUAF9AD4AAQABAAEAWAIoAOYBLQBVAzwA3AFjAAAAbgBuAGkA +wACgAFAAgAC+AFABfQA+AAEAAQABAFgCKADmAS0AVQM8ANwBYwAAAAAAAAABAQAAbAkBABXSAAAA +AAAA/wMAAGwJAQAM0gAAAAAAAP8BAABsCQEAFdIAAAoAAAAA/A8AbAkBAAzSAAAJAAAAAP4DAGwJ +AQAV0gAAFAAAAAAA8D9sCQEADNIAABIAAAAAAPwHbAkBAAbSAAAAAAAA/wEAAGwJAQAH0gAAAAAA +AP8DAABsCQEABtIAAAkAAAAA/gMAbAkBAAfSAAAKAAAAAPwPAGwJAQAG0gAAEgAAAAAA/AdsCQEA +B9IAABQAAAAAAPA/AAAAAAAAAAAAAAAAAQAAAAEAAAAKAAAABQAAAAUAAAAGAAAACgAAAAoAAAAG +AAAABAAAAAUAAAAGAAAABQAAAAUAAAAGAAAABgAAAAYAAAAGAAAABwAAAAcAAAAHAAAACAAAAAgA +AAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAEAAAACAAAAAQAAAAEAAAADAAAAAwAA +AAIAAAABAAAABAAAAAAAAAAAAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAA +AAAAAAAA4BcBAGwdAQAcHAEA8B0BAGgdAQBIGwEA7B0BAEAZAQA8GQEAYOMWACDWEwAAAAAAEAAA +AACAAAAAAKAAECcAAOgDAADoAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgAAAAEAAAAB +AAAAAgAAAAUAAAACAAAAAgAAAAUAAAACAAAAAgAAAAEAAAABAAAABQAAAAUAAAACAAAABQAAAAUA +AAAAAAAABQAAAAIAAAACAAAAAAAAAAAAAAAAAAAABQAAAAUAAAAAAAAABQAAAAIAAAACAAAABQAA +AAUAAAAFAAAAAAAAAAUAAAACAAAABQAAAAEAAAABAAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAA +BQAAAAEAAAABAAAAAgAAAAIAAAACAAAABQAAAAUAAAACAAAAAgAAAAUAAAABAAAAAgAAAAUAAAAC +AAAABQAAAAUAAAAEAAAABQAAAAUAAAABAAAABQAAAAUAAAAFAAAAAgAAAAIAAAAFAAAABQAAAAUA +AAABAAAABQAAAAUAAAAFAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAA +AAAAAAAAAAAAAAAACAAAAAAAAAABEAABAAAAAoAAAUIABgIQAAIgAAADwAABQwAGAxAAAsAAAAPA +AAFDAAYEEAACQAAAAoAAAUQABgURAABAAAADwAABRQAGBhEAAOAAAAPAAAFFAAYHEQABAAAAAoAA +AUYABggRAAIgAAADwAABRwAGCREAAsAAAAPAAAFHAAYKEQACQAAAAoAAAUgABgsSAABAAAADwAAB +SQAGDBIAAOAAAAPAAAFJAAYNEgABAAAAAoAAAUoABg4SAAIAAAACgAABTAAGAXgAMAAAAFAAAAS2 +PAYCeABEAAAAUAAABLk8BgN5AAgAAABQAAAEuzwGBHkAHAAAAFAAAAS+PAYFeQAwAAAAUAAABMA8 +BgZ5AEQAAABQAAAEwzwGB3oACAAAAFAAAATFPAYIegAcAAAAUAAABMg8Bgl6ADAAAABQAAAEyjwG +CnoARAAAAFAAAATNPAYLewAIAAAAUAAABM88Bgx7ABwAAABQAAAE0jwGDXsAMAAAAFAAAATUPAYO +fAAQAAAAUAAABNo+BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQEAAAEAAQACAQAAAgABAAIBAAACgICA +gICAgIABgAKAgICAgMAAkADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAjAqMCgAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAABAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACc +0wEAFQAAAAMAAACAXIAAAAAAAAAAAAAAAAAAQNMBAAUAAAADAAAAgFyAAAAAAAAAAAAAAAAAADTT +AQAKAAAAAwAAAIBcgAAAAAAAAAAAAAAAAAAE0AEACgAAAAAAAACgXIAAAAAAAAAAAAAAAAAA3NEB +AAoAAAAAAAAAoFyAAAAAAAAAAAAAAAAAANzRAQAKAAAAAAAAAKBcgAAAAAAAAAAAAAAAAADc0QEA +CgAAAAAAAACgXIAAAAAAAAAAAAAAAAAA3NEBAAoAAAAAAAAAoFyAAAAAAAAAAAAAAAAAANzRAQAK +AAAAAAAAAKBcgAAAAAAAAAAAAAAAAADc0QEACgAAAAAAAACgXIAAAAAAAAAAAAAAAAAA3NEBAAoA +AAAAAAAAoFyAAAAAAAAAAAAAAAAAANzRAQAKAAAAAAAAAKBcgAAAAAAAAAAAAAAAAADc0QEACgAA +AAAAAACgXIAAAAAAAAAAAAAAAAAA3NEBAAoAAAAAAAAAoFyAAAAAAAAAAAAAAAAAANzRAQAKAAAA +AAAAAKBcgAAAAAAAAAAAAAAAAADc0QEACgAAAAAAAACgXIAAAAAAAAAAAAAAAAAARNUBAAYAAAAA +AAAAoFyAAAAAAAAAAAAAAAAAAJjUAQAFAAAAAwAAAIBcgAAAAAAAAAAAAAAAAAD0zgEACgAAAAAA +AACgXIAAAAAAAAAAAAAAAAAAlM8BAAoAAAAAAAAAoFyAAAAAAAAAAAAAAAAAAMDeAQAKAAAAAwAA +AIBcgAAAAAAAAAAAAAAAAABQ0AEACgAAAAAAAACgXIAAAAAAAAAAAAAAAAAANNEBAAoAAAAAAAAA +oFyAAAAAAAAAAAAAAAAAAODRAQAKAAAAAAAAAKBcgAAAAAAAAAAAAAAAAACc0gEACgAAAAAAAACg +XIAAAAAAAAAAAAAAAAAAoNMBAAoAAAAAAAAAoFyAAAAAAAAAAAAAAAAAAEDUAQAKAAAAAAAAAKBc +gAAAAAAAAAAAAAAAAAAAAAAAgFyAAIBcgAC4IKAAbCCgAACAAQD/f/z/AAAAAAAAAACgXIAAoFyA +AKQgoAA4IKAAAQAAAPz///8AAAAAAAAAAMBcgADAXIAAqCCgADwgoAAQAAAAx////wAAAAAAAAAA +4FyAAOBcgACsIKAAeCGgAEABAAA//v//AAAAAAAAAAAAXYAAAF2AALAgoAB8IaAAAAwAAP/x//8A +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABI0AEAFQAAAAMAAACAXIAAAAAAAAAAAAAAAAAA1AmAAICz +gAAYAAAAQLOAAAAAAAAAAAAAAAAAAH8AAAAAAAAAAH8AAAAAAAAAAAAAAAAAAAAAAAA4AAAAaAAA +AHQAAACAAAAAjAAAAJ0AAAAHAAAAAAAAAP////8AAAAALQEAAN0BAABaAgAAugIAAAoDAABNAwAA +hwMAALoDAADoAwAAEQQAADcEAABZBAAAegQAAJgEAAC0BAAAzgQAAOcEAAD+BAAAFQUAACoFAAA+ +BQAAUQUAAGQFAAB1BQAAhgUAAJcFAACnBQAAtgUAAMUFAADTBQAA4QUAAO4FAAD7BQAACAYAABQG +AAAgBgAAKwYAADcGAABCBgAATAYAAFcGAABhBgAAawYAAHUGAAB+BgAAiAYAAJEGAACaBgAAogYA +AKsGAAC0BgAAvAYAAMQGAADMBgAA1AYAANsGAADjBgAA6gYAAPIGAAD5BgAAAAcAAAcHAAAOBwAA +FAcAABsHAAAiBwAAKAcAAC4HAAA1BwAAOwcAAEEHAABHBwAATQcAAFMHAABYBwAAXgcAAGQHAABp +BwAAbwcAAHQHAAB5BwAAfwcAAIQHAACJBwAAjgcAAJMHAACYBwAAnQcAAKIHAACnBwAAqwcAALAH +AAC1BwAAuQcAAL4HAADCBwAAxwcAAMsHAADQBwAA1AcAANgHAADcBwAA4QcAAOUHAADpBwAA7QcA +APEHAAD1BwAA+QcAAP0HAAABCAAABQgAAAgIAAAMCAAAEAgAABQIAAAXCAAAGwgAAB8IAAAiCAAA +JggAACkIAAAtCAAAMAgAADQIAAA3CAAAOwgAAD4IAABBCAAARQgAAEgIAABLCAAATwgAAFIIAABV +CAAAWAgAAFsIAABfCAAAYggAAGUIAABoCAAAawgAAG4IAABxCAAAdAgAAHcIAAB6CAAAfQgAAIAI +AACCCAAAhQgAAIgIAACLCAAAjggAAJEIAACTCAAAlggAAJkIAAAAAAAAAQAAAAAAAAAHAAAAAAAA +AAAAAAAAAAAAAAECAwQEBAQEBQYHCAgICAgJCgsMDQAAbjtoO2I7XDtuOmg6YjpcOm45aDliOVw5 +bitoK2IrXCtuKmgqYipcKm4paCliKVwpbihoKGIoXChuJ2gnYidcJ24maCZiJlwmbiVoJWIlXCVu +JGgkYiRcJG4jaCNiI1wjbiJoImIiXCJuIWghYiFcIW4gaCBiIFwgYhNcE24SaBJiElwSbhFoEWIR +XBFuEGgQYhBcEG4CaAJiAlwCbgFoAWIBXAFuAGgAVAAAAG47aDtiO1w7bjpoOmI6XDpuOWg5Yjlc +OW4raCtiK1wrbipoKmIqXCpuKWgpYilcKW4oaChiKFwobidoJ2InXCduJmgmYiZcJm4laCViJVwl +biRoJGIkXCRuI2gjYiNcI24iaCJiIlwibiFoIWIhXCFuIGggYiBcIG4SaBJiElwSbhFoEWIRXBFu +EGgQYhBcEFcQUhBNEEkQbgFoAWIBXAFuAGgAYgBcAFQAAAAAAAAAAAAAAB0AAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAACDAAAAkgAAAIMAAACSAAAA6AAAAPcAAADoAAAA9wAAAAAAAAAJAAAAAAAA +AAoAAAA4AAAAaAAAAHQAAACAAAAAjAAAAJ0AAAAHAAAAAAAAAAcAAAAHAAAABwAAAAAAAAAAAAAA +AAAAAAAAAADQWQEACAAAAAMAAACAXIAAIAyAAKAMgAAgDYAAoA2AAAoNERQKDREUGRkZGQoKAAAA +AAAABgYGBgkJCQkABgAAAAUGBwgNDg8QFRYXGBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AA8arKwlL6ysrKyspax+kU5DDJs2AAAANwCako9IAAAPACBoNwAAABEAPjogEQAAAiUAAAwvAAAC +Lzk5AAolPLdHb4oABxQnYi4AAAIAFwAABRAKIDBAAAAGBgoNIxsjIQAAAAwQFBggCAQAADw4NDAs +KCQgHBgUEAwIBAALBwMAOzczLysnIx8bFxMPCwcDMTY6NTc6MzcAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAIgAAABAAAAAdAAAANwAAAG8AAACgAAAAcAAAAAUAAAD2AAAA +WgAAAB8AAABIAAAAIAAAAEgAAAAIAAAAAQAAADMAAAB/AAAANAAAAH8AAAA3AAAAAQAAADgAAABP +AAAAOwAAAH8AAAA8AAAAfwAAADEAAAAAAAAAMgAAAAAAAAA1AAAAAAAAADYAAAAAAAAAOQAAAAAA +AAA6AAAAAAAAAA0AAAAqAAAADgAAAHoAAAAPAAAAEAAAAPMAAABIAAAA9AAAAEgAAAAAAAAAAQEB +AQEBAQECAgICAgICAgMDAwMDAwMDAQIAAAAAAAAAAAAABAAAAAUAAAChAw4e4QAAAKEDDh7hAAAA +AAAAAAoAAAARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChAw4e4QAAABX2 +Y/aw9vz2RveQ99j3H/hl+Kn47fgv+XD5sPnu+Sv6Z/qi+tz6FPtL+4H7tvvq+xz8Tfx9/Kv82fwF +/TD9Wf2C/an9z/30/Rf+Of5a/nr+mP62/tL+7f4G/x7/Nf9L/2D/c/+F/5b/pv+0/8H/zf/Y/+H/ +6f/w//b/+v/9//////////3/+v/2//D/6f/h/9j/zf/B/7T/pv+W/4X/c/9g/0v/Nf8e/wb/7f7S +/rb+mP56/lr+Of4X/vT9z/2p/YL9Wf0w/QX92fyr/H38Tfwc/Or7tvuB+0v7FPvc+qL6Z/or+u75 +sPlw+S/57fip+GX4H/jY95D3Rvf89rD2Y/ZwuYO6lruqvL690r7nv/zAEcInwz3EU8VqxoDHl8iv +ycbK3sv2zA/OJ89A0FnRctKM06bUv9Xa1vTXDtkp2kTbX9x63Zbesd/N4OnhBeMh5D7lWuZ355Po +sOnN6urrB+0k7kLvX/B98ZryuPPV9PP1Efcv+Ez5avqI+6b8xP3i/gAAHgE8AloDeASWBbQG0Qfv +CA0KKwtIDGYNgw6hD74Q3BH5EhYUMxVQFm0XiRimGcIa3xv7HBceMx9PIGohhiKhI7wk1yXyJgwo +JilBKlordCyOLacuwC/ZMPExCjMiNDo1UTZpN4A4ljmtOsM72TzvPQQ/GUAuQUJCVkNqRH1FAAEB +AgECAgMBAQEBAQEBAQICAgICAgICAwMDAwMDAwMEBAQEBAQEBAECAgICAgIDAwMDAwMDAwMDAwMD +AwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAADoBAgHVAN8A2gCiAHUAfwCKBSoDOQGoAYoFygLZ +AEgBAQMPBwoUN25qARoB2QDoAAoBugB5AIgAygFKAeIA+QDKAeoAggCZAHTRRRfooosuAAUHAQME +AAUBBQAAAAUGAAIEAAUABQAAAQIBAgMEAAAFBgcICQoAAAkAAAAAAAAAAQAAAAIAAAADAAAAAAAA +AAQAAAACAAAABQAAAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH +BwcHBwcHBwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgICAgIBAQEBAQAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoACgAMAAsACwAKAA8ADQA +QAA8AIwAbABYAEgA9ACwAH//Bw8fPwEDMAAAADYAAAAMAAAAEgAAABgAAAAkAAAABgAAAAkAAAAF +AAcCAwQGBkADgAbACQANgBMAGkAdgCCABgANgBMAGgAnADSAOgBBwAmAE0AdACeAOgBOwFeAYZkD +MwfZCnMOphXmHIAgGSQzB3MOphXmHFkrzDkAQTNI2QqmFYAgWSsAQaZWgGFZbJ3YiZ1O7MRONEiD +NCd2YicapEEaEzuxExEYgREP/MAPTuzETid2YicapEEaEzuxEw3SIA2JndgJCIzACAd+4Ac0SIM0 +GqRBGhEYgREN0iANCIzACAZpkAawstUFBVRABSd2YicTO7ETDdIgDYmd2AkGaZAGxE7sBARGYAQD +P/ADqqqqqhqkQRoTO7ETD/zADxEYgREN0iANCqiAChM7sRMP/MAPD/zADw3SIA0LtEALC7RAC4md +2AkN0iANCqiACgqogAoIjMAIB3iABwd4gAcGaZAGD/zADw3SIA0LtEALDdIgDQu0QAuJndgJCIzA +CImd2AkIjMAIB37gBwd+4AfBLCkHCqiACgiMwAgHeIAHCIzACAd4gAcGaZAGsLLVBQZpkAawstUF +BVRABQVUQAXWHcYEAQcPHz9///9m5gAABQYBAgMEAABUAFQAbABgAFwAVACMAHgADQ8FBwkLAQMo +ACgANAAwACwALABEADwALAAsADwANAAwACwAVABEAFVVVQFLaC8BVVVVBeM4jgOqqqoCcRzHAaqq +qgrHcRwHAAQAAGQAAAAAAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAA +AA8APwABAAAADwA/AAIAAAAPAD8AAQAAACIWAACAAAADAAABWQAAJBYAAQAAAAMAAAFaAAAmFgAC +AAAABAAAAVoAACgWAAIAAAADAAABWwAAKhYAAoAAAAMAAAFcAAAsFwAAAAAABAAAAVwAAC4XAACA +AAADAAABXQAAMBcAAQAAAAMAAAFeAAA0FwACAAAAAwAAAV8AADYXAAKAAAADAAABYAAAOBgAAAAA +AAQAAAFgAAA8GAABAAAAAwAAAWIAAD4YAAIAAAAEAAABYgAAQBgAAgAAAAMAAAFjAABkGwACAAAA +AwAAAW8AAWYbAAKAAAADAAABcAABaBwAAAAAAAQAAAFwAAFsHAABAAAAAwAAAXIAAW4cAAIAAAAE +AAABcgABcBwAAgAAAAMAAAFzAAJ0HQAAAAAABAAAAXQAAnYdAACAAAADAAABdQACeB0AAQAAAAMA +AAF2AAJ8HQACAAAAAwAAAXcAA34dAAKAAAADAAABeAADgB4AAAAAAAQAAAF4AAOEHgABAAAAAwAA +AXoAA4YeAAIAAAAEAAABegAEiB4AAgAAAAMAAAF7AASMHwAAAAAABAAAAXwABJEfAAFAAAADAAAB +fgAElR8AAwAAAAQAAAF/AAWXHwACwAAAAwAAAYAABZkgAABAAAADAAABgQAFnSAAAUAAAAMAAAGC +AAWfIAABwAAAAwAAAYMABaEgAAMAAAAEAAABgwAFpSEAAEAAAAMAAAGFAAVEcwEAAAAAAERzAQAA +AAAARHMBAAAAAABEcwEAAAAAAERzAQAAAAAARHMBAAAAAABEcwEAAAAAAERzAQAAAAAAEG0BABgA +AADUbgEAIAAAAHR0AQAUAAAAaHUBABQAAACocgEADgAAAGxxAQAOAAAAfHIBABQAAAB8cgEAFAAA +AEAjQCUhISEhQEBAQEAFBAQBAUBAQEAFBUBADAxADQwMAQEBBUBABQUABAAEQEAABEBAQAVAQEBA +QAVAQEAFBQUBAQEBQAUFBQEFAQFABQUFQAVABQUFBQUAAAAAAAAAAGQAAAAAkAEACgAAAAQAAAAc +EQAAHDIAABwzAAAEAAAAHBUAABwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClxoT4me6N +9g3/vdax3lSRUGADAqnOfVYZ52K15k2a7EWPnR9AiYf6Fe/rssmOC/vsQWez/V/qRb8j91OW5Fub +wnUc4a49akxabEF+AvVPg1xo9FE00Qj5k+Jzq1NiPyoMCFKVZUZenSgwoTcPCrUvCQ42JJsbPd8m +zWlOzX+f6hsSnh10WC40LTay3O60+1v2pE12YbfOfXtSPt1xXpcT9aZouQAALMFgQB/jyHnttr7U +Ro3ZZ0ty3pTUmOiwSoVruyrF5U8W7cWG15pVZpQRz4oQ6QYEgf7woER4uiXjS/Oi/l3AgIoFrT+8 +IUhwBPHfY8F3da9jQjAgGuUO/W2/TIEUGDUmL8PhvqI1zIg5LleT8lWC/Ed6rMjnuisyleagwJgZ +0Z5/o2ZEflSrO4MLyowpx9NrPCh5p+K8HRZ2rTvbVmROdB4U25IKDGxI5Lhdn26970OmxKg5pDE3 +04vyMtVDi1lut9qMAWSx0pzgSbTY+qwH8yXPr8qO9OlHGBDVb4jwb0pyXCQ48VfHc1GXI8t8oZzo +IT7dltxhhg2FD5DgQnzEcarM2JAFBgH3Ehyjwl9q+a7QaZEXWJknOrknONkT67MrMyK70nCpiQen +M7YtIjySFSDJSYf/qnhQeqWPA/hZgAkXGtplMdfGhLjQw4KwKXdaER7Le/yo1m06LAABAgQEAAAA +BAwMCAQMBARAAAAAgAAAAAABAAAAAgAAQAAAAAAEAABAAAAAQAAAAADwYQAAAQECAQICAwAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQAAAAqAAAADgAAAAAAAQFg0wEAbNMBAHjTAQCE0wEAjNMB +AJTTAQABAQABAgEBAQAAAAAAAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAgA0AAAAgAACADQAAgA0AAAAgAACADQAAAAYAAAAEAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAYAAAAEAAAALAEAAAcAAAAAAAAAEgAAAAQAAAALAAAACAAAAAQAAADMQ4AACQAAAAQAAAAQ +GAAACgAAAAQAAAA4Q4AACwAAAAQAAABsQYAADAAAAAQAAAAQGAAADQAAAAQAAADYQIAADgAAAAAA +AAAPAAAABAAAABYAAAA= +==== diff --git a/sys/crypto/aesni/aesencdec.h b/sys/crypto/aesni/aesencdec.h index 5e4f128..80951a4 100644 --- a/sys/crypto/aesni/aesencdec.h +++ b/sys/crypto/aesni/aesencdec.h @@ -1,5 +1,6 @@ /*- * Copyright 2013 John-Mark Gurney <jmg@FreeBSD.org> + * Copyright 2015 Netflix, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -27,6 +28,11 @@ * */ +#ifndef _AESENCDEC_H_ +#define _AESENCDEC_H_ + +#include <crypto/aesni/aesni_os.h> + #include <wmmintrin.h> static inline void @@ -103,6 +109,7 @@ aesni_dec8(int rounds, const __m128i *keysched, __m128i a, out[7] = _mm_aesdeclast_si128(h, keysched[i + 1]); } +/* rounds is passed in as rounds - 1 */ static inline __m128i aesni_enc(int rounds, const __m128i *keysched, const __m128i from) { @@ -110,11 +117,13 @@ aesni_enc(int rounds, const __m128i *keysched, const __m128i from) int i; tmp = from ^ keysched[0]; - - for (i = 0; i < rounds; i++) + for (i = 1; i < rounds; i += 2) { + tmp = _mm_aesenc_si128(tmp, keysched[i]); tmp = _mm_aesenc_si128(tmp, keysched[i + 1]); + } - return _mm_aesenclast_si128(tmp, keysched[i + 1]); + tmp = _mm_aesenc_si128(tmp, keysched[rounds]); + return _mm_aesenclast_si128(tmp, keysched[rounds + 1]); } static inline __m128i @@ -125,8 +134,13 @@ aesni_dec(int rounds, const __m128i *keysched, const __m128i from) tmp = from ^ keysched[0]; - for (i = 0; i < rounds; i++) + for (i = 1; i < rounds; i += 2) { + tmp = _mm_aesdec_si128(tmp, keysched[i]); tmp = _mm_aesdec_si128(tmp, keysched[i + 1]); + } - return _mm_aesdeclast_si128(tmp, keysched[i + 1]); + tmp = _mm_aesdec_si128(tmp, keysched[rounds]); + return _mm_aesdeclast_si128(tmp, keysched[rounds + 1]); } + +#endif /* _AESENCDEC_H_ */ diff --git a/sys/crypto/aesni/aesni.c b/sys/crypto/aesni/aesni.c index 7d7a740..602247a 100644 --- a/sys/crypto/aesni/aesni.c +++ b/sys/crypto/aesni/aesni.c @@ -1,8 +1,13 @@ /*- * Copyright (c) 2005-2008 Pawel Jakub Dawidek <pjd@FreeBSD.org> * Copyright (c) 2010 Konstantin Belousov <kib@FreeBSD.org> + * Copyright (c) 2014 The FreeBSD Foundation * All rights reserved. * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: @@ -39,16 +44,37 @@ __FBSDID("$FreeBSD$"); #include <sys/rwlock.h> #include <sys/bus.h> #include <sys/uio.h> +#include <sys/mbuf.h> +#include <sys/mutex.h> +#include <sys/smp.h> #include <crypto/aesni/aesni.h> #include <cryptodev_if.h> +#include <opencrypto/gmac.h> + +static struct mtx_padalign *ctx_mtx; +static struct fpu_kern_ctx **ctx_fpu; struct aesni_softc { + int dieing; int32_t cid; uint32_t sid; TAILQ_HEAD(aesni_sessions_head, aesni_session) sessions; struct rwlock lock; }; +#define AQUIRE_CTX(i, ctx) \ + do { \ + (i) = PCPU_GET(cpuid); \ + mtx_lock(&ctx_mtx[(i)]); \ + (ctx) = ctx_fpu[(i)]; \ + } while (0) +#define RELEASE_CTX(i, ctx) \ + do { \ + mtx_unlock(&ctx_mtx[(i)]); \ + (i) = -1; \ + (ctx) = NULL; \ + } while (0) + static int aesni_newsession(device_t, uint32_t *sidp, struct cryptoini *cri); static int aesni_freesession(device_t, uint64_t tid); static void aesni_freesession_locked(struct aesni_softc *sc, @@ -56,7 +82,7 @@ static void aesni_freesession_locked(struct aesni_softc *sc, static int aesni_cipher_setup(struct aesni_session *ses, struct cryptoini *encini); static int aesni_cipher_process(struct aesni_session *ses, - struct cryptodesc *enccrd, struct cryptop *crp); + struct cryptodesc *enccrd, struct cryptodesc *authcrd, struct cryptop *crp); MALLOC_DEFINE(M_AESNI, "aesni_data", "AESNI Data"); @@ -79,23 +105,45 @@ aesni_probe(device_t dev) return (EINVAL); } - if ((cpu_feature & CPUID_SSE2) == 0) { - device_printf(dev, "No SSE2 support but AESNI!?!\n"); + if ((cpu_feature2 & CPUID2_SSE41) == 0) { + device_printf(dev, "No SSE4.1 support.\n"); return (EINVAL); } - device_set_desc_copy(dev, "AES-CBC,AES-XTS"); + device_set_desc_copy(dev, "AES-CBC,AES-XTS,AES-GCM,AES-ICM"); return (0); } +static void +aensi_cleanctx(void) +{ + int i; + + /* XXX - no way to return driverid */ + CPU_FOREACH(i) { + if (ctx_fpu[i] != NULL) { + mtx_destroy(&ctx_mtx[i]); + fpu_kern_free_ctx(ctx_fpu[i]); + } + ctx_fpu[i] = NULL; + } + free(ctx_mtx, M_AESNI); + ctx_mtx = NULL; + free(ctx_fpu, M_AESNI); + ctx_fpu = NULL; +} + static int aesni_attach(device_t dev) { struct aesni_softc *sc; + int i; sc = device_get_softc(dev); + sc->dieing = 0; TAILQ_INIT(&sc->sessions); sc->sid = 1; + sc->cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC); if (sc->cid < 0) { @@ -103,8 +151,23 @@ aesni_attach(device_t dev) return (ENOMEM); } + ctx_mtx = malloc(sizeof *ctx_mtx * (mp_maxid + 1), M_AESNI, + M_WAITOK|M_ZERO); + ctx_fpu = malloc(sizeof *ctx_fpu * (mp_maxid + 1), M_AESNI, + M_WAITOK|M_ZERO); + + CPU_FOREACH(i) { + ctx_fpu[i] = fpu_kern_alloc_ctx(0); + mtx_init(&ctx_mtx[i], "anifpumtx", NULL, MTX_DEF); + } + rw_init(&sc->lock, "aesni_lock"); crypto_register(sc->cid, CRYPTO_AES_CBC, 0, 0); + crypto_register(sc->cid, CRYPTO_AES_ICM, 0, 0); + crypto_register(sc->cid, CRYPTO_AES_NIST_GCM_16, 0, 0); + crypto_register(sc->cid, CRYPTO_AES_128_NIST_GMAC, 0, 0); + crypto_register(sc->cid, CRYPTO_AES_192_NIST_GMAC, 0, 0); + crypto_register(sc->cid, CRYPTO_AES_256_NIST_GMAC, 0, 0); crypto_register(sc->cid, CRYPTO_AES_XTS, 0, 0); return (0); } @@ -116,6 +179,7 @@ aesni_detach(device_t dev) struct aesni_session *ses; sc = device_get_softc(dev); + rw_wlock(&sc->lock); TAILQ_FOREACH(ses, &sc->sessions, next) { if (ses->used) { @@ -125,14 +189,18 @@ aesni_detach(device_t dev) return (EBUSY); } } + sc->dieing = 1; while ((ses = TAILQ_FIRST(&sc->sessions)) != NULL) { TAILQ_REMOVE(&sc->sessions, ses, next); - fpu_kern_free_ctx(ses->fpu_ctx); free(ses, M_AESNI); } rw_wunlock(&sc->lock); - rw_destroy(&sc->lock); crypto_unregister_all(sc->cid); + + rw_destroy(&sc->lock); + + aensi_cleanctx(); + return (0); } @@ -144,28 +212,52 @@ aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri) struct cryptoini *encini; int error; - if (sidp == NULL || cri == NULL) + if (sidp == NULL || cri == NULL) { + CRYPTDEB("no sidp or cri"); return (EINVAL); + } sc = device_get_softc(dev); + if (sc->dieing) + return (EINVAL); + ses = NULL; encini = NULL; for (; cri != NULL; cri = cri->cri_next) { switch (cri->cri_alg) { case CRYPTO_AES_CBC: + case CRYPTO_AES_ICM: case CRYPTO_AES_XTS: - if (encini != NULL) + case CRYPTO_AES_NIST_GCM_16: + if (encini != NULL) { + CRYPTDEB("encini already set"); return (EINVAL); + } encini = cri; break; + case CRYPTO_AES_128_NIST_GMAC: + case CRYPTO_AES_192_NIST_GMAC: + case CRYPTO_AES_256_NIST_GMAC: + /* + * nothing to do here, maybe in the future cache some + * values for GHASH + */ + break; default: + CRYPTDEB("unhandled algorithm"); return (EINVAL); } } - if (encini == NULL) + if (encini == NULL) { + CRYPTDEB("no cipher"); return (EINVAL); + } rw_wlock(&sc->lock); + if (sc->dieing) { + rw_wunlock(&sc->lock); + return (EINVAL); + } /* * Free sessions goes first, so if first session is used, we need to * allocate one. @@ -177,13 +269,6 @@ aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri) rw_wunlock(&sc->lock); return (ENOMEM); } - ses->fpu_ctx = fpu_kern_alloc_ctx(FPU_KERN_NORMAL | - FPU_KERN_NOWAIT); - if (ses->fpu_ctx == NULL) { - free(ses, M_AESNI); - rw_wunlock(&sc->lock); - return (ENOMEM); - } ses->id = sc->sid++; } else { TAILQ_REMOVE(&sc->sessions, ses, next); @@ -195,6 +280,7 @@ aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri) error = aesni_cipher_setup(ses, encini); if (error != 0) { + CRYPTDEB("setup failed"); rw_wlock(&sc->lock); aesni_freesession_locked(sc, ses); rw_wunlock(&sc->lock); @@ -208,15 +294,14 @@ aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri) static void aesni_freesession_locked(struct aesni_softc *sc, struct aesni_session *ses) { - struct fpu_kern_ctx *ctx; uint32_t sid; + rw_assert(&sc->lock, RA_WLOCKED); + sid = ses->id; TAILQ_REMOVE(&sc->sessions, ses, next); - ctx = ses->fpu_ctx; - bzero(ses, sizeof(*ses)); + *ses = (struct aesni_session){}; ses->id = sid; - ses->fpu_ctx = ctx; TAILQ_INSERT_HEAD(&sc->sessions, ses, next); } @@ -248,11 +333,13 @@ aesni_process(device_t dev, struct cryptop *crp, int hint __unused) { struct aesni_softc *sc = device_get_softc(dev); struct aesni_session *ses = NULL; - struct cryptodesc *crd, *enccrd; - int error; + struct cryptodesc *crd, *enccrd, *authcrd; + int error, needauth; error = 0; enccrd = NULL; + authcrd = NULL; + needauth = 0; /* Sanity check. */ if (crp == NULL) @@ -266,6 +353,7 @@ aesni_process(device_t dev, struct cryptop *crp, int hint __unused) for (crd = crp->crp_desc; crd != NULL; crd = crd->crd_next) { switch (crd->crd_alg) { case CRYPTO_AES_CBC: + case CRYPTO_AES_ICM: case CRYPTO_AES_XTS: if (enccrd != NULL) { error = EINVAL; @@ -273,11 +361,41 @@ aesni_process(device_t dev, struct cryptop *crp, int hint __unused) } enccrd = crd; break; + + case CRYPTO_AES_NIST_GCM_16: + if (enccrd != NULL) { + error = EINVAL; + goto out; + } + enccrd = crd; + needauth = 1; + break; + + case CRYPTO_AES_128_NIST_GMAC: + case CRYPTO_AES_192_NIST_GMAC: + case CRYPTO_AES_256_NIST_GMAC: + if (authcrd != NULL) { + error = EINVAL; + goto out; + } + authcrd = crd; + needauth = 1; + break; + default: - return (EINVAL); + error = EINVAL; + goto out; } } - if (enccrd == NULL || (enccrd->crd_len % AES_BLOCK_LEN) != 0) { + + if (enccrd == NULL || (needauth && authcrd == NULL)) { + error = EINVAL; + goto out; + } + + /* CBC & XTS can only handle full blocks for now */ + if ((enccrd->crd_alg == CRYPTO_AES_CBC || enccrd->crd_alg == + CRYPTO_AES_XTS) && (enccrd->crd_len % AES_BLOCK_LEN) != 0) { error = EINVAL; goto out; } @@ -293,7 +411,7 @@ aesni_process(device_t dev, struct cryptop *crp, int hint __unused) goto out; } - error = aesni_cipher_process(ses, enccrd, crp); + error = aesni_cipher_process(ses, enccrd, authcrd, crp); if (error != 0) goto out; @@ -307,21 +425,26 @@ uint8_t * aesni_cipher_alloc(struct cryptodesc *enccrd, struct cryptop *crp, int *allocated) { + struct mbuf *m; struct uio *uio; struct iovec *iov; uint8_t *addr; - if (crp->crp_flags & CRYPTO_F_IMBUF) - goto alloc; - else if (crp->crp_flags & CRYPTO_F_IOV) { + if (crp->crp_flags & CRYPTO_F_IMBUF) { + m = (struct mbuf *)crp->crp_buf; + if (m->m_next != NULL) + goto alloc; + addr = mtod(m, uint8_t *); + } else if (crp->crp_flags & CRYPTO_F_IOV) { uio = (struct uio *)crp->crp_buf; if (uio->uio_iovcnt != 1) goto alloc; iov = uio->uio_iov; - addr = (u_char *)iov->iov_base + enccrd->crd_skip; + addr = (uint8_t *)iov->iov_base; } else - addr = (u_char *)crp->crp_buf; + addr = (uint8_t *)crp->crp_buf; *allocated = 0; + addr += enccrd->crd_skip; return (addr); alloc: @@ -362,37 +485,74 @@ MODULE_DEPEND(aesni, crypto, 1, 1, 1); static int aesni_cipher_setup(struct aesni_session *ses, struct cryptoini *encini) { - struct thread *td; + struct fpu_kern_ctx *ctx; int error; + int kt, ctxidx; + + kt = is_fpu_kern_thread(0); + if (!kt) { + AQUIRE_CTX(ctxidx, ctx); + error = fpu_kern_enter(curthread, ctx, + FPU_KERN_NORMAL | FPU_KERN_KTHR); + if (error != 0) + goto out; + } - td = curthread; - error = fpu_kern_enter(td, ses->fpu_ctx, FPU_KERN_NORMAL | - FPU_KERN_KTHR); - if (error != 0) - return (error); error = aesni_cipher_setup_common(ses, encini->cri_key, encini->cri_klen); - fpu_kern_leave(td, ses->fpu_ctx); + + if (!kt) { + fpu_kern_leave(curthread, ctx); +out: + RELEASE_CTX(ctxidx, ctx); + } return (error); } +/* + * authcrd contains the associated date. + */ static int aesni_cipher_process(struct aesni_session *ses, struct cryptodesc *enccrd, - struct cryptop *crp) + struct cryptodesc *authcrd, struct cryptop *crp) { - struct thread *td; - uint8_t *buf; - int error, allocated; + struct fpu_kern_ctx *ctx; + uint8_t iv[AES_BLOCK_LEN]; + uint8_t tag[GMAC_DIGEST_LEN]; + uint8_t *buf, *authbuf; + int error, allocated, authallocated; + int ivlen, encflag; + int kt, ctxidx; + + encflag = (enccrd->crd_flags & CRD_F_ENCRYPT) == CRD_F_ENCRYPT; + + if ((enccrd->crd_alg == CRYPTO_AES_ICM || + enccrd->crd_alg == CRYPTO_AES_NIST_GCM_16) && + (enccrd->crd_flags & CRD_F_IV_EXPLICIT) == 0) + return (EINVAL); buf = aesni_cipher_alloc(enccrd, crp, &allocated); if (buf == NULL) return (ENOMEM); - td = curthread; - error = fpu_kern_enter(td, ses->fpu_ctx, FPU_KERN_NORMAL | - FPU_KERN_KTHR); - if (error != 0) - goto out1; + authbuf = NULL; + authallocated = 0; + if (authcrd != NULL) { + authbuf = aesni_cipher_alloc(authcrd, crp, &authallocated); + if (authbuf == NULL) { + error = ENOMEM; + goto out1; + } + } + + kt = is_fpu_kern_thread(0); + if (!kt) { + AQUIRE_CTX(ctxidx, ctx); + error = fpu_kern_enter(curthread, ctx, + FPU_KERN_NORMAL|FPU_KERN_KTHR); + if (error != 0) + goto out2; + } if ((enccrd->crd_flags & CRD_F_KEY_EXPLICIT) != 0) { error = aesni_cipher_setup_common(ses, enccrd->crd_key, @@ -401,48 +561,105 @@ aesni_cipher_process(struct aesni_session *ses, struct cryptodesc *enccrd, goto out; } - if ((enccrd->crd_flags & CRD_F_ENCRYPT) != 0) { + /* XXX - validate that enccrd and authcrd have/use same key? */ + switch (enccrd->crd_alg) { + case CRYPTO_AES_CBC: + case CRYPTO_AES_ICM: + ivlen = AES_BLOCK_LEN; + break; + case CRYPTO_AES_XTS: + ivlen = 8; + break; + case CRYPTO_AES_NIST_GCM_16: + ivlen = 12; /* should support arbitarily larger */ + break; + } + + /* Setup iv */ + if (encflag) { if ((enccrd->crd_flags & CRD_F_IV_EXPLICIT) != 0) - bcopy(enccrd->crd_iv, ses->iv, AES_BLOCK_LEN); + bcopy(enccrd->crd_iv, iv, ivlen); + else + arc4rand(iv, ivlen, 0); + if ((enccrd->crd_flags & CRD_F_IV_PRESENT) == 0) crypto_copyback(crp->crp_flags, crp->crp_buf, - enccrd->crd_inject, AES_BLOCK_LEN, ses->iv); - if (ses->algo == CRYPTO_AES_CBC) { - aesni_encrypt_cbc(ses->rounds, ses->enc_schedule, - enccrd->crd_len, buf, buf, ses->iv); - } else /* if (ses->algo == CRYPTO_AES_XTS) */ { - aesni_encrypt_xts(ses->rounds, ses->enc_schedule, - ses->xts_schedule, enccrd->crd_len, buf, buf, - ses->iv); - } + enccrd->crd_inject, ivlen, iv); } else { if ((enccrd->crd_flags & CRD_F_IV_EXPLICIT) != 0) - bcopy(enccrd->crd_iv, ses->iv, AES_BLOCK_LEN); + bcopy(enccrd->crd_iv, iv, ivlen); else crypto_copydata(crp->crp_flags, crp->crp_buf, - enccrd->crd_inject, AES_BLOCK_LEN, ses->iv); - if (ses->algo == CRYPTO_AES_CBC) { + enccrd->crd_inject, ivlen, iv); + } + + if (authcrd != NULL && !encflag) + crypto_copydata(crp->crp_flags, crp->crp_buf, + authcrd->crd_inject, GMAC_DIGEST_LEN, tag); + else + bzero(tag, sizeof tag); + + /* Do work */ + switch (ses->algo) { + case CRYPTO_AES_CBC: + if (encflag) + aesni_encrypt_cbc(ses->rounds, ses->enc_schedule, + enccrd->crd_len, buf, buf, iv); + else aesni_decrypt_cbc(ses->rounds, ses->dec_schedule, - enccrd->crd_len, buf, ses->iv); - } else /* if (ses->algo == CRYPTO_AES_XTS) */ { + enccrd->crd_len, buf, iv); + break; + case CRYPTO_AES_ICM: + /* encryption & decryption are the same */ + aesni_encrypt_icm(ses->rounds, ses->enc_schedule, + enccrd->crd_len, buf, buf, iv); + break; + case CRYPTO_AES_XTS: + if (encflag) + aesni_encrypt_xts(ses->rounds, ses->enc_schedule, + ses->xts_schedule, enccrd->crd_len, buf, buf, + iv); + else aesni_decrypt_xts(ses->rounds, ses->dec_schedule, ses->xts_schedule, enccrd->crd_len, buf, buf, - ses->iv); + iv); + break; + case CRYPTO_AES_NIST_GCM_16: + if (encflag) + AES_GCM_encrypt(buf, buf, authbuf, iv, tag, + enccrd->crd_len, authcrd->crd_len, ivlen, + ses->enc_schedule, ses->rounds); + else { + if (!AES_GCM_decrypt(buf, buf, authbuf, iv, tag, + enccrd->crd_len, authcrd->crd_len, ivlen, + ses->enc_schedule, ses->rounds)) + error = EBADMSG; } + break; } + if (allocated) crypto_copyback(crp->crp_flags, crp->crp_buf, enccrd->crd_skip, enccrd->crd_len, buf); - if ((enccrd->crd_flags & CRD_F_ENCRYPT) != 0) - crypto_copydata(crp->crp_flags, crp->crp_buf, - enccrd->crd_skip + enccrd->crd_len - AES_BLOCK_LEN, - AES_BLOCK_LEN, ses->iv); + + if (!error && authcrd != NULL) { + crypto_copyback(crp->crp_flags, crp->crp_buf, + authcrd->crd_inject, GMAC_DIGEST_LEN, tag); + } + out: - fpu_kern_leave(td, ses->fpu_ctx); + if (!kt) { + fpu_kern_leave(curthread, ctx); +out2: + RELEASE_CTX(ctxidx, ctx); + } + out1: if (allocated) { bzero(buf, enccrd->crd_len); free(buf, M_AESNI); } + if (authallocated) + free(authbuf, M_AESNI); return (error); } diff --git a/sys/crypto/aesni/aesni.h b/sys/crypto/aesni/aesni.h index ff1d1a2..3d5adec 100644 --- a/sys/crypto/aesni/aesni.h +++ b/sys/crypto/aesni/aesni.h @@ -56,7 +56,6 @@ struct aesni_session { uint8_t enc_schedule[AES_SCHED_LEN] __aligned(16); uint8_t dec_schedule[AES_SCHED_LEN] __aligned(16); uint8_t xts_schedule[AES_SCHED_LEN] __aligned(16); - uint8_t iv[AES_BLOCK_LEN]; int algo; int rounds; /* uint8_t *ses_ictx; */ @@ -65,7 +64,6 @@ struct aesni_session { int used; uint32_t id; TAILQ_ENTRY(aesni_session) next; - struct fpu_kern_ctx *fpu_ctx; }; /* @@ -88,6 +86,9 @@ void aesni_encrypt_ecb(int rounds, const void *key_schedule /*__aligned(16)*/, size_t len, const uint8_t *from, uint8_t *to); void aesni_decrypt_ecb(int rounds, const void *key_schedule /*__aligned(16)*/, size_t len, const uint8_t *from, uint8_t *to); +void aesni_encrypt_icm(int rounds, const void *key_schedule /*__aligned(16)*/, + size_t len, const uint8_t *from, uint8_t *to, + const uint8_t iv[AES_BLOCK_LEN]); void aesni_encrypt_xts(int rounds, const void *data_schedule /*__aligned(16)*/, const void *tweak_schedule /*__aligned(16)*/, size_t len, @@ -96,6 +97,16 @@ void aesni_decrypt_xts(int rounds, const void *data_schedule /*__aligned(16)*/, const void *tweak_schedule /*__aligned(16)*/, size_t len, const uint8_t *from, uint8_t *to, const uint8_t iv[AES_BLOCK_LEN]); +/* GCM & GHASH functions */ +void AES_GCM_encrypt(const unsigned char *in, unsigned char *out, + const unsigned char *addt, const unsigned char *ivec, + unsigned char *tag, uint32_t nbytes, uint32_t abytes, int ibytes, + const unsigned char *key, int nr); +int AES_GCM_decrypt(const unsigned char *in, unsigned char *out, + const unsigned char *addt, const unsigned char *ivec, + const unsigned char *tag, uint32_t nbytes, uint32_t abytes, int ibytes, + const unsigned char *key, int nr); + int aesni_cipher_setup_common(struct aesni_session *ses, const uint8_t *key, int keylen); uint8_t *aesni_cipher_alloc(struct cryptodesc *enccrd, struct cryptop *crp, diff --git a/sys/crypto/aesni/aesni_ghash.c b/sys/crypto/aesni/aesni_ghash.c new file mode 100644 index 0000000..54c8815 --- /dev/null +++ b/sys/crypto/aesni/aesni_ghash.c @@ -0,0 +1,804 @@ +/*- + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * This software was developed by John-Mark Gurney under + * the sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * 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$ + * + */ + +/* + * Figure 5, 8 and 12 are copied from the Intel white paper: + * Intel® Carry-Less Multiplication Instruction and its Usage for + * Computing the GCM Mode + * + * and as such are: + * Copyright © 2010 Intel 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: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifdef _KERNEL +#include <crypto/aesni/aesni.h> +#include <crypto/aesni/aesni_os.h> +#else +#include <stdint.h> +#endif + +#include <wmmintrin.h> +#include <emmintrin.h> +#include <smmintrin.h> + +static inline int +m128icmp(__m128i a, __m128i b) +{ + __m128i cmp; + + cmp = _mm_cmpeq_epi32(a, b); + + return _mm_movemask_epi8(cmp) == 0xffff; +} + +#ifdef __i386__ +static inline __m128i +_mm_insert_epi64(__m128i a, int64_t b, const int ndx) +{ + + if (!ndx) { + a = _mm_insert_epi32(a, b, 0); + a = _mm_insert_epi32(a, b >> 32, 1); + } else { + a = _mm_insert_epi32(a, b, 2); + a = _mm_insert_epi32(a, b >> 32, 3); + } + + return a; +} +#endif + +/* some code from carry-less-multiplication-instruction-in-gcm-mode-paper.pdf */ + +/* Figure 5. Code Sample - Performing Ghash Using Algorithms 1 and 5 (C) */ +static void +gfmul(__m128i a, __m128i b, __m128i *res) +{ + __m128i tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9; + + tmp3 = _mm_clmulepi64_si128(a, b, 0x00); + tmp4 = _mm_clmulepi64_si128(a, b, 0x10); + tmp5 = _mm_clmulepi64_si128(a, b, 0x01); + tmp6 = _mm_clmulepi64_si128(a, b, 0x11); + + tmp4 = _mm_xor_si128(tmp4, tmp5); + tmp5 = _mm_slli_si128(tmp4, 8); + tmp4 = _mm_srli_si128(tmp4, 8); + tmp3 = _mm_xor_si128(tmp3, tmp5); + tmp6 = _mm_xor_si128(tmp6, tmp4); + + tmp7 = _mm_srli_epi32(tmp3, 31); + tmp8 = _mm_srli_epi32(tmp6, 31); + tmp3 = _mm_slli_epi32(tmp3, 1); + tmp6 = _mm_slli_epi32(tmp6, 1); + + tmp9 = _mm_srli_si128(tmp7, 12); + tmp8 = _mm_slli_si128(tmp8, 4); + tmp7 = _mm_slli_si128(tmp7, 4); + tmp3 = _mm_or_si128(tmp3, tmp7); + tmp6 = _mm_or_si128(tmp6, tmp8); + tmp6 = _mm_or_si128(tmp6, tmp9); + + tmp7 = _mm_slli_epi32(tmp3, 31); + tmp8 = _mm_slli_epi32(tmp3, 30); + tmp9 = _mm_slli_epi32(tmp3, 25); + + tmp7 = _mm_xor_si128(tmp7, tmp8); + tmp7 = _mm_xor_si128(tmp7, tmp9); + tmp8 = _mm_srli_si128(tmp7, 4); + tmp7 = _mm_slli_si128(tmp7, 12); + tmp3 = _mm_xor_si128(tmp3, tmp7); + + tmp2 = _mm_srli_epi32(tmp3, 1); + tmp4 = _mm_srli_epi32(tmp3, 2); + tmp5 = _mm_srli_epi32(tmp3, 7); + tmp2 = _mm_xor_si128(tmp2, tmp4); + tmp2 = _mm_xor_si128(tmp2, tmp5); + tmp2 = _mm_xor_si128(tmp2, tmp8); + tmp3 = _mm_xor_si128(tmp3, tmp2); + tmp6 = _mm_xor_si128(tmp6, tmp3); + + *res = tmp6; +} + +/* + * Figure 8. Code Sample - Performing Ghash Using an Aggregated Reduction + * Method */ +static void +reduce4(__m128i H1, __m128i H2, __m128i H3, __m128i H4, + __m128i X1, __m128i X2, __m128i X3, __m128i X4, __m128i *res) +{ + /*algorithm by Krzysztof Jankowski, Pierre Laurent - Intel*/ + __m128i H1_X1_lo, H1_X1_hi, H2_X2_lo, H2_X2_hi, H3_X3_lo, + H3_X3_hi, H4_X4_lo, H4_X4_hi, lo, hi; + __m128i tmp0, tmp1, tmp2, tmp3; + __m128i tmp4, tmp5, tmp6, tmp7; + __m128i tmp8, tmp9; + + H1_X1_lo = _mm_clmulepi64_si128(H1, X1, 0x00); + H2_X2_lo = _mm_clmulepi64_si128(H2, X2, 0x00); + H3_X3_lo = _mm_clmulepi64_si128(H3, X3, 0x00); + H4_X4_lo = _mm_clmulepi64_si128(H4, X4, 0x00); + + lo = _mm_xor_si128(H1_X1_lo, H2_X2_lo); + lo = _mm_xor_si128(lo, H3_X3_lo); + lo = _mm_xor_si128(lo, H4_X4_lo); + + H1_X1_hi = _mm_clmulepi64_si128(H1, X1, 0x11); + H2_X2_hi = _mm_clmulepi64_si128(H2, X2, 0x11); + H3_X3_hi = _mm_clmulepi64_si128(H3, X3, 0x11); + H4_X4_hi = _mm_clmulepi64_si128(H4, X4, 0x11); + + hi = _mm_xor_si128(H1_X1_hi, H2_X2_hi); + hi = _mm_xor_si128(hi, H3_X3_hi); + hi = _mm_xor_si128(hi, H4_X4_hi); + + tmp0 = _mm_shuffle_epi32(H1, 78); + tmp4 = _mm_shuffle_epi32(X1, 78); + tmp0 = _mm_xor_si128(tmp0, H1); + tmp4 = _mm_xor_si128(tmp4, X1); + tmp1 = _mm_shuffle_epi32(H2, 78); + tmp5 = _mm_shuffle_epi32(X2, 78); + tmp1 = _mm_xor_si128(tmp1, H2); + tmp5 = _mm_xor_si128(tmp5, X2); + tmp2 = _mm_shuffle_epi32(H3, 78); + tmp6 = _mm_shuffle_epi32(X3, 78); + tmp2 = _mm_xor_si128(tmp2, H3); + tmp6 = _mm_xor_si128(tmp6, X3); + tmp3 = _mm_shuffle_epi32(H4, 78); + tmp7 = _mm_shuffle_epi32(X4, 78); + tmp3 = _mm_xor_si128(tmp3, H4); + tmp7 = _mm_xor_si128(tmp7, X4); + + tmp0 = _mm_clmulepi64_si128(tmp0, tmp4, 0x00); + tmp1 = _mm_clmulepi64_si128(tmp1, tmp5, 0x00); + tmp2 = _mm_clmulepi64_si128(tmp2, tmp6, 0x00); + tmp3 = _mm_clmulepi64_si128(tmp3, tmp7, 0x00); + + tmp0 = _mm_xor_si128(tmp0, lo); + tmp0 = _mm_xor_si128(tmp0, hi); + tmp0 = _mm_xor_si128(tmp1, tmp0); + tmp0 = _mm_xor_si128(tmp2, tmp0); + tmp0 = _mm_xor_si128(tmp3, tmp0); + + tmp4 = _mm_slli_si128(tmp0, 8); + tmp0 = _mm_srli_si128(tmp0, 8); + + lo = _mm_xor_si128(tmp4, lo); + hi = _mm_xor_si128(tmp0, hi); + + tmp3 = lo; + tmp6 = hi; + + tmp7 = _mm_srli_epi32(tmp3, 31); + tmp8 = _mm_srli_epi32(tmp6, 31); + tmp3 = _mm_slli_epi32(tmp3, 1); + tmp6 = _mm_slli_epi32(tmp6, 1); + + tmp9 = _mm_srli_si128(tmp7, 12); + tmp8 = _mm_slli_si128(tmp8, 4); + tmp7 = _mm_slli_si128(tmp7, 4); + tmp3 = _mm_or_si128(tmp3, tmp7); + tmp6 = _mm_or_si128(tmp6, tmp8); + tmp6 = _mm_or_si128(tmp6, tmp9); + + tmp7 = _mm_slli_epi32(tmp3, 31); + tmp8 = _mm_slli_epi32(tmp3, 30); + tmp9 = _mm_slli_epi32(tmp3, 25); + + tmp7 = _mm_xor_si128(tmp7, tmp8); + tmp7 = _mm_xor_si128(tmp7, tmp9); + tmp8 = _mm_srli_si128(tmp7, 4); + tmp7 = _mm_slli_si128(tmp7, 12); + tmp3 = _mm_xor_si128(tmp3, tmp7); + + tmp2 = _mm_srli_epi32(tmp3, 1); + tmp4 = _mm_srli_epi32(tmp3, 2); + tmp5 = _mm_srli_epi32(tmp3, 7); + tmp2 = _mm_xor_si128(tmp2, tmp4); + tmp2 = _mm_xor_si128(tmp2, tmp5); + tmp2 = _mm_xor_si128(tmp2, tmp8); + tmp3 = _mm_xor_si128(tmp3, tmp2); + tmp6 = _mm_xor_si128(tmp6, tmp3); + + *res = tmp6; +} + +/* + * Figure 12. AES-GCM: Processing Four Blocks in Parallel with Aggregated + * Every Four Blocks + */ +/* + * per NIST SP-800-38D, 5.2.1.1, len(p) <= 2^39-256 (in bits), or + * 2^32-256*8*16 bytes. + */ +void +AES_GCM_encrypt(const unsigned char *in, unsigned char *out, + const unsigned char *addt, const unsigned char *ivec, + unsigned char *tag, uint32_t nbytes, uint32_t abytes, int ibytes, + const unsigned char *key, int nr) +{ + int i, j ,k; + __m128i tmp1, tmp2, tmp3, tmp4; + __m128i tmp5, tmp6, tmp7, tmp8; + __m128i H, H2, H3, H4, Y, T; + __m128i *KEY = (__m128i*)key; + __m128i ctr1, ctr2, ctr3, ctr4; + __m128i ctr5, ctr6, ctr7, ctr8; + __m128i last_block = _mm_setzero_si128(); + __m128i ONE = _mm_set_epi32(0, 1, 0, 0); + __m128i EIGHT = _mm_set_epi32(0, 8, 0, 0); + __m128i BSWAP_EPI64 = _mm_set_epi8(8,9,10,11,12,13,14,15,0,1,2,3,4,5,6, + 7); + __m128i BSWAP_MASK = _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14, + 15); + __m128i X = _mm_setzero_si128(); + + if (ibytes == 96/8) { + Y = _mm_loadu_si128((__m128i*)ivec); + Y = _mm_insert_epi32(Y, 0x1000000, 3); + /*(Compute E[ZERO, KS] and E[Y0, KS] together*/ + tmp1 = _mm_xor_si128(X, KEY[0]); + tmp2 = _mm_xor_si128(Y, KEY[0]); + for (j=1; j < nr-1; j+=2) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[j]); + + tmp1 = _mm_aesenc_si128(tmp1, KEY[j+1]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[j+1]); + } + tmp1 = _mm_aesenc_si128(tmp1, KEY[nr-1]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[nr-1]); + + H = _mm_aesenclast_si128(tmp1, KEY[nr]); + T = _mm_aesenclast_si128(tmp2, KEY[nr]); + + H = _mm_shuffle_epi8(H, BSWAP_MASK); + } else { + tmp1 = _mm_xor_si128(X, KEY[0]); + for (j=1; j <nr; j++) + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + H = _mm_aesenclast_si128(tmp1, KEY[nr]); + + H = _mm_shuffle_epi8(H, BSWAP_MASK); + Y = _mm_setzero_si128(); + + for (i=0; i < ibytes/16; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)ivec)[i]); + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + Y = _mm_xor_si128(Y, tmp1); + gfmul(Y, H, &Y); + } + if (ibytes%16) { + for (j=0; j < ibytes%16; j++) + ((unsigned char*)&last_block)[j] = ivec[i*16+j]; + tmp1 = last_block; + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + Y = _mm_xor_si128(Y, tmp1); + gfmul(Y, H, &Y); + } + tmp1 = _mm_insert_epi64(tmp1, (uint64_t)ibytes*8, 0); + tmp1 = _mm_insert_epi64(tmp1, 0, 1); + + Y = _mm_xor_si128(Y, tmp1); + gfmul(Y, H, &Y); + Y = _mm_shuffle_epi8(Y, BSWAP_MASK); /*Compute E(K, Y0)*/ + tmp1 = _mm_xor_si128(Y, KEY[0]); + for (j=1; j < nr; j++) + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + T = _mm_aesenclast_si128(tmp1, KEY[nr]); + } + + gfmul(H,H,&H2); + gfmul(H,H2,&H3); + gfmul(H,H3,&H4); + + for (i=0; i<abytes/16/4; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)addt)[i*4]); + tmp2 = _mm_loadu_si128(&((__m128i*)addt)[i*4+1]); + tmp3 = _mm_loadu_si128(&((__m128i*)addt)[i*4+2]); + tmp4 = _mm_loadu_si128(&((__m128i*)addt)[i*4+3]); + + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + tmp2 = _mm_shuffle_epi8(tmp2, BSWAP_MASK); + tmp3 = _mm_shuffle_epi8(tmp3, BSWAP_MASK); + tmp4 = _mm_shuffle_epi8(tmp4, BSWAP_MASK); + tmp1 = _mm_xor_si128(X, tmp1); + + reduce4(H, H2, H3, H4, tmp4, tmp3, tmp2, tmp1, &X); + } + for (i=i*4; i<abytes/16; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)addt)[i]); + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X = _mm_xor_si128(X,tmp1); + gfmul(X, H, &X); + } + if (abytes%16) { + last_block = _mm_setzero_si128(); + for (j=0; j<abytes%16; j++) + ((unsigned char*)&last_block)[j] = addt[i*16+j]; + tmp1 = last_block; + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X =_mm_xor_si128(X,tmp1); + gfmul(X,H,&X); + } + + ctr1 = _mm_shuffle_epi8(Y, BSWAP_EPI64); + ctr1 = _mm_add_epi64(ctr1, ONE); + ctr2 = _mm_add_epi64(ctr1, ONE); + ctr3 = _mm_add_epi64(ctr2, ONE); + ctr4 = _mm_add_epi64(ctr3, ONE); + ctr5 = _mm_add_epi64(ctr4, ONE); + ctr6 = _mm_add_epi64(ctr5, ONE); + ctr7 = _mm_add_epi64(ctr6, ONE); + ctr8 = _mm_add_epi64(ctr7, ONE); + + for (i=0; i<nbytes/16/8; i++) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + tmp2 = _mm_shuffle_epi8(ctr2, BSWAP_EPI64); + tmp3 = _mm_shuffle_epi8(ctr3, BSWAP_EPI64); + tmp4 = _mm_shuffle_epi8(ctr4, BSWAP_EPI64); + tmp5 = _mm_shuffle_epi8(ctr5, BSWAP_EPI64); + tmp6 = _mm_shuffle_epi8(ctr6, BSWAP_EPI64); + tmp7 = _mm_shuffle_epi8(ctr7, BSWAP_EPI64); + tmp8 = _mm_shuffle_epi8(ctr8, BSWAP_EPI64); + + ctr1 = _mm_add_epi64(ctr1, EIGHT); + ctr2 = _mm_add_epi64(ctr2, EIGHT); + ctr3 = _mm_add_epi64(ctr3, EIGHT); + ctr4 = _mm_add_epi64(ctr4, EIGHT); + ctr5 = _mm_add_epi64(ctr5, EIGHT); + ctr6 = _mm_add_epi64(ctr6, EIGHT); + ctr7 = _mm_add_epi64(ctr7, EIGHT); + ctr8 = _mm_add_epi64(ctr8, EIGHT); + + tmp1 =_mm_xor_si128(tmp1, KEY[0]); + tmp2 =_mm_xor_si128(tmp2, KEY[0]); + tmp3 =_mm_xor_si128(tmp3, KEY[0]); + tmp4 =_mm_xor_si128(tmp4, KEY[0]); + tmp5 =_mm_xor_si128(tmp5, KEY[0]); + tmp6 =_mm_xor_si128(tmp6, KEY[0]); + tmp7 =_mm_xor_si128(tmp7, KEY[0]); + tmp8 =_mm_xor_si128(tmp8, KEY[0]); + + for (j=1; j<nr; j++) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[j]); + tmp3 = _mm_aesenc_si128(tmp3, KEY[j]); + tmp4 = _mm_aesenc_si128(tmp4, KEY[j]); + tmp5 = _mm_aesenc_si128(tmp5, KEY[j]); + tmp6 = _mm_aesenc_si128(tmp6, KEY[j]); + tmp7 = _mm_aesenc_si128(tmp7, KEY[j]); + tmp8 = _mm_aesenc_si128(tmp8, KEY[j]); + } + tmp1 =_mm_aesenclast_si128(tmp1, KEY[nr]); + tmp2 =_mm_aesenclast_si128(tmp2, KEY[nr]); + tmp3 =_mm_aesenclast_si128(tmp3, KEY[nr]); + tmp4 =_mm_aesenclast_si128(tmp4, KEY[nr]); + tmp5 =_mm_aesenclast_si128(tmp5, KEY[nr]); + tmp6 =_mm_aesenclast_si128(tmp6, KEY[nr]); + tmp7 =_mm_aesenclast_si128(tmp7, KEY[nr]); + tmp8 =_mm_aesenclast_si128(tmp8, KEY[nr]); + + tmp1 = _mm_xor_si128(tmp1, + _mm_loadu_si128(&((__m128i*)in)[i*8+0])); + tmp2 = _mm_xor_si128(tmp2, + _mm_loadu_si128(&((__m128i*)in)[i*8+1])); + tmp3 = _mm_xor_si128(tmp3, + _mm_loadu_si128(&((__m128i*)in)[i*8+2])); + tmp4 = _mm_xor_si128(tmp4, + _mm_loadu_si128(&((__m128i*)in)[i*8+3])); + tmp5 = _mm_xor_si128(tmp5, + _mm_loadu_si128(&((__m128i*)in)[i*8+4])); + tmp6 = _mm_xor_si128(tmp6, + _mm_loadu_si128(&((__m128i*)in)[i*8+5])); + tmp7 = _mm_xor_si128(tmp7, + _mm_loadu_si128(&((__m128i*)in)[i*8+6])); + tmp8 = _mm_xor_si128(tmp8, + _mm_loadu_si128(&((__m128i*)in)[i*8+7])); + + _mm_storeu_si128(&((__m128i*)out)[i*8+0], tmp1); + _mm_storeu_si128(&((__m128i*)out)[i*8+1], tmp2); + _mm_storeu_si128(&((__m128i*)out)[i*8+2], tmp3); + _mm_storeu_si128(&((__m128i*)out)[i*8+3], tmp4); + _mm_storeu_si128(&((__m128i*)out)[i*8+4], tmp5); + _mm_storeu_si128(&((__m128i*)out)[i*8+5], tmp6); + _mm_storeu_si128(&((__m128i*)out)[i*8+6], tmp7); + _mm_storeu_si128(&((__m128i*)out)[i*8+7], tmp8); + + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + tmp2 = _mm_shuffle_epi8(tmp2, BSWAP_MASK); + tmp3 = _mm_shuffle_epi8(tmp3, BSWAP_MASK); + tmp4 = _mm_shuffle_epi8(tmp4, BSWAP_MASK); + tmp5 = _mm_shuffle_epi8(tmp5, BSWAP_MASK); + tmp6 = _mm_shuffle_epi8(tmp6, BSWAP_MASK); + tmp7 = _mm_shuffle_epi8(tmp7, BSWAP_MASK); + tmp8 = _mm_shuffle_epi8(tmp8, BSWAP_MASK); + + tmp1 = _mm_xor_si128(X, tmp1); + + reduce4(H, H2, H3, H4, tmp4, tmp3, tmp2, tmp1, &X); + + tmp5 = _mm_xor_si128(X, tmp5); + reduce4(H, H2, H3, H4, tmp8, tmp7, tmp6, tmp5, &X); + } + for (k=i*8; k<nbytes/16; k++) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + ctr1 = _mm_add_epi64(ctr1, ONE); + tmp1 = _mm_xor_si128(tmp1, KEY[0]); + for (j=1; j<nr-1; j+=2) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp1 = _mm_aesenc_si128(tmp1, KEY[j+1]); + } + tmp1 = _mm_aesenc_si128(tmp1, KEY[nr-1]); + tmp1 = _mm_aesenclast_si128(tmp1, KEY[nr]); + tmp1 = _mm_xor_si128(tmp1, _mm_loadu_si128(&((__m128i*)in)[k])); + _mm_storeu_si128(&((__m128i*)out)[k], tmp1); + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X = _mm_xor_si128(X, tmp1); + gfmul(X,H,&X); + } + //If remains one incomplete block + if (nbytes%16) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + tmp1 = _mm_xor_si128(tmp1, KEY[0]); + for (j=1; j<nr-1; j+=2) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp1 = _mm_aesenc_si128(tmp1, KEY[j+1]); + } + tmp1 = _mm_aesenc_si128(tmp1, KEY[nr-1]); + tmp1 = _mm_aesenclast_si128(tmp1, KEY[nr]); + tmp1 = _mm_xor_si128(tmp1, _mm_loadu_si128(&((__m128i*)in)[k])); + last_block = tmp1; + for (j=0; j<nbytes%16; j++) + out[k*16+j] = ((unsigned char*)&last_block)[j]; + for ((void)j; j<16; j++) + ((unsigned char*)&last_block)[j] = 0; + tmp1 = last_block; + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X = _mm_xor_si128(X, tmp1); + gfmul(X, H, &X); + } + tmp1 = _mm_insert_epi64(tmp1, (uint64_t)nbytes*8, 0); + tmp1 = _mm_insert_epi64(tmp1, (uint64_t)abytes*8, 1); + + X = _mm_xor_si128(X, tmp1); + gfmul(X,H,&X); + X = _mm_shuffle_epi8(X, BSWAP_MASK); + T = _mm_xor_si128(X, T); + _mm_storeu_si128((__m128i*)tag, T); +} + +/* My modification of _encrypt to be _decrypt */ +int +AES_GCM_decrypt(const unsigned char *in, unsigned char *out, + const unsigned char *addt, const unsigned char *ivec, + const unsigned char *tag, uint32_t nbytes, uint32_t abytes, int ibytes, + const unsigned char *key, int nr) +{ + int i, j ,k; + __m128i tmp1, tmp2, tmp3, tmp4; + __m128i tmp5, tmp6, tmp7, tmp8; + __m128i H, H2, H3, H4, Y, T; + __m128i *KEY = (__m128i*)key; + __m128i ctr1, ctr2, ctr3, ctr4; + __m128i ctr5, ctr6, ctr7, ctr8; + __m128i last_block = _mm_setzero_si128(); + __m128i ONE = _mm_set_epi32(0, 1, 0, 0); + __m128i EIGHT = _mm_set_epi32(0, 8, 0, 0); + __m128i BSWAP_EPI64 = _mm_set_epi8(8,9,10,11,12,13,14,15,0,1,2,3,4,5,6, + 7); + __m128i BSWAP_MASK = _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14, + 15); + __m128i X = _mm_setzero_si128(); + + if (ibytes == 96/8) { + Y = _mm_loadu_si128((__m128i*)ivec); + Y = _mm_insert_epi32(Y, 0x1000000, 3); + /*(Compute E[ZERO, KS] and E[Y0, KS] together*/ + tmp1 = _mm_xor_si128(X, KEY[0]); + tmp2 = _mm_xor_si128(Y, KEY[0]); + for (j=1; j < nr-1; j+=2) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[j]); + + tmp1 = _mm_aesenc_si128(tmp1, KEY[j+1]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[j+1]); + } + tmp1 = _mm_aesenc_si128(tmp1, KEY[nr-1]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[nr-1]); + + H = _mm_aesenclast_si128(tmp1, KEY[nr]); + T = _mm_aesenclast_si128(tmp2, KEY[nr]); + + H = _mm_shuffle_epi8(H, BSWAP_MASK); + } else { + tmp1 = _mm_xor_si128(X, KEY[0]); + for (j=1; j <nr; j++) + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + H = _mm_aesenclast_si128(tmp1, KEY[nr]); + + H = _mm_shuffle_epi8(H, BSWAP_MASK); + Y = _mm_setzero_si128(); + + for (i=0; i < ibytes/16; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)ivec)[i]); + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + Y = _mm_xor_si128(Y, tmp1); + gfmul(Y, H, &Y); + } + if (ibytes%16) { + for (j=0; j < ibytes%16; j++) + ((unsigned char*)&last_block)[j] = ivec[i*16+j]; + tmp1 = last_block; + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + Y = _mm_xor_si128(Y, tmp1); + gfmul(Y, H, &Y); + } + tmp1 = _mm_insert_epi64(tmp1, (uint64_t)ibytes*8, 0); + tmp1 = _mm_insert_epi64(tmp1, 0, 1); + + Y = _mm_xor_si128(Y, tmp1); + gfmul(Y, H, &Y); + Y = _mm_shuffle_epi8(Y, BSWAP_MASK); /*Compute E(K, Y0)*/ + tmp1 = _mm_xor_si128(Y, KEY[0]); + for (j=1; j < nr; j++) + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + T = _mm_aesenclast_si128(tmp1, KEY[nr]); + } + + gfmul(H,H,&H2); + gfmul(H,H2,&H3); + gfmul(H,H3,&H4); + + for (i=0; i<abytes/16/4; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)addt)[i*4]); + tmp2 = _mm_loadu_si128(&((__m128i*)addt)[i*4+1]); + tmp3 = _mm_loadu_si128(&((__m128i*)addt)[i*4+2]); + tmp4 = _mm_loadu_si128(&((__m128i*)addt)[i*4+3]); + + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + tmp2 = _mm_shuffle_epi8(tmp2, BSWAP_MASK); + tmp3 = _mm_shuffle_epi8(tmp3, BSWAP_MASK); + tmp4 = _mm_shuffle_epi8(tmp4, BSWAP_MASK); + + tmp1 = _mm_xor_si128(X, tmp1); + + reduce4(H, H2, H3, H4, tmp4, tmp3, tmp2, tmp1, &X); + } + for (i=i*4; i<abytes/16; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)addt)[i]); + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X = _mm_xor_si128(X,tmp1); + gfmul(X, H, &X); + } + if (abytes%16) { + last_block = _mm_setzero_si128(); + for (j=0; j<abytes%16; j++) + ((unsigned char*)&last_block)[j] = addt[i*16+j]; + tmp1 = last_block; + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X =_mm_xor_si128(X,tmp1); + gfmul(X,H,&X); + } + + /* This is where we validate the cipher text before decrypt */ + for (i = 0; i<nbytes/16/4; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)in)[i*4]); + tmp2 = _mm_loadu_si128(&((__m128i*)in)[i*4+1]); + tmp3 = _mm_loadu_si128(&((__m128i*)in)[i*4+2]); + tmp4 = _mm_loadu_si128(&((__m128i*)in)[i*4+3]); + + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + tmp2 = _mm_shuffle_epi8(tmp2, BSWAP_MASK); + tmp3 = _mm_shuffle_epi8(tmp3, BSWAP_MASK); + tmp4 = _mm_shuffle_epi8(tmp4, BSWAP_MASK); + + tmp1 = _mm_xor_si128(X, tmp1); + + reduce4(H, H2, H3, H4, tmp4, tmp3, tmp2, tmp1, &X); + } + for (i = i*4; i<nbytes/16; i++) { + tmp1 = _mm_loadu_si128(&((__m128i*)in)[i]); + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X = _mm_xor_si128(X, tmp1); + gfmul(X,H,&X); + } + if (nbytes%16) { + last_block = _mm_setzero_si128(); + for (j=0; j<nbytes%16; j++) + ((unsigned char*)&last_block)[j] = in[i*16+j]; + tmp1 = last_block; + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + X = _mm_xor_si128(X, tmp1); + gfmul(X, H, &X); + } + + tmp1 = _mm_insert_epi64(tmp1, (uint64_t)nbytes*8, 0); + tmp1 = _mm_insert_epi64(tmp1, (uint64_t)abytes*8, 1); + + X = _mm_xor_si128(X, tmp1); + gfmul(X,H,&X); + X = _mm_shuffle_epi8(X, BSWAP_MASK); + T = _mm_xor_si128(X, T); + + if (!m128icmp(T, _mm_loadu_si128((const __m128i*)tag))) + return 0; //in case the authentication failed + + ctr1 = _mm_shuffle_epi8(Y, BSWAP_EPI64); + ctr1 = _mm_add_epi64(ctr1, ONE); + ctr2 = _mm_add_epi64(ctr1, ONE); + ctr3 = _mm_add_epi64(ctr2, ONE); + ctr4 = _mm_add_epi64(ctr3, ONE); + ctr5 = _mm_add_epi64(ctr4, ONE); + ctr6 = _mm_add_epi64(ctr5, ONE); + ctr7 = _mm_add_epi64(ctr6, ONE); + ctr8 = _mm_add_epi64(ctr7, ONE); + + for (i=0; i<nbytes/16/8; i++) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + tmp2 = _mm_shuffle_epi8(ctr2, BSWAP_EPI64); + tmp3 = _mm_shuffle_epi8(ctr3, BSWAP_EPI64); + tmp4 = _mm_shuffle_epi8(ctr4, BSWAP_EPI64); + tmp5 = _mm_shuffle_epi8(ctr5, BSWAP_EPI64); + tmp6 = _mm_shuffle_epi8(ctr6, BSWAP_EPI64); + tmp7 = _mm_shuffle_epi8(ctr7, BSWAP_EPI64); + tmp8 = _mm_shuffle_epi8(ctr8, BSWAP_EPI64); + + ctr1 = _mm_add_epi64(ctr1, EIGHT); + ctr2 = _mm_add_epi64(ctr2, EIGHT); + ctr3 = _mm_add_epi64(ctr3, EIGHT); + ctr4 = _mm_add_epi64(ctr4, EIGHT); + ctr5 = _mm_add_epi64(ctr5, EIGHT); + ctr6 = _mm_add_epi64(ctr6, EIGHT); + ctr7 = _mm_add_epi64(ctr7, EIGHT); + ctr8 = _mm_add_epi64(ctr8, EIGHT); + + tmp1 =_mm_xor_si128(tmp1, KEY[0]); + tmp2 =_mm_xor_si128(tmp2, KEY[0]); + tmp3 =_mm_xor_si128(tmp3, KEY[0]); + tmp4 =_mm_xor_si128(tmp4, KEY[0]); + tmp5 =_mm_xor_si128(tmp5, KEY[0]); + tmp6 =_mm_xor_si128(tmp6, KEY[0]); + tmp7 =_mm_xor_si128(tmp7, KEY[0]); + tmp8 =_mm_xor_si128(tmp8, KEY[0]); + + for (j=1; j<nr; j++) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp2 = _mm_aesenc_si128(tmp2, KEY[j]); + tmp3 = _mm_aesenc_si128(tmp3, KEY[j]); + tmp4 = _mm_aesenc_si128(tmp4, KEY[j]); + tmp5 = _mm_aesenc_si128(tmp5, KEY[j]); + tmp6 = _mm_aesenc_si128(tmp6, KEY[j]); + tmp7 = _mm_aesenc_si128(tmp7, KEY[j]); + tmp8 = _mm_aesenc_si128(tmp8, KEY[j]); + } + tmp1 =_mm_aesenclast_si128(tmp1, KEY[nr]); + tmp2 =_mm_aesenclast_si128(tmp2, KEY[nr]); + tmp3 =_mm_aesenclast_si128(tmp3, KEY[nr]); + tmp4 =_mm_aesenclast_si128(tmp4, KEY[nr]); + tmp5 =_mm_aesenclast_si128(tmp5, KEY[nr]); + tmp6 =_mm_aesenclast_si128(tmp6, KEY[nr]); + tmp7 =_mm_aesenclast_si128(tmp7, KEY[nr]); + tmp8 =_mm_aesenclast_si128(tmp8, KEY[nr]); + + tmp1 = _mm_xor_si128(tmp1, + _mm_loadu_si128(&((__m128i*)in)[i*8+0])); + tmp2 = _mm_xor_si128(tmp2, + _mm_loadu_si128(&((__m128i*)in)[i*8+1])); + tmp3 = _mm_xor_si128(tmp3, + _mm_loadu_si128(&((__m128i*)in)[i*8+2])); + tmp4 = _mm_xor_si128(tmp4, + _mm_loadu_si128(&((__m128i*)in)[i*8+3])); + tmp5 = _mm_xor_si128(tmp5, + _mm_loadu_si128(&((__m128i*)in)[i*8+4])); + tmp6 = _mm_xor_si128(tmp6, + _mm_loadu_si128(&((__m128i*)in)[i*8+5])); + tmp7 = _mm_xor_si128(tmp7, + _mm_loadu_si128(&((__m128i*)in)[i*8+6])); + tmp8 = _mm_xor_si128(tmp8, + _mm_loadu_si128(&((__m128i*)in)[i*8+7])); + + _mm_storeu_si128(&((__m128i*)out)[i*8+0], tmp1); + _mm_storeu_si128(&((__m128i*)out)[i*8+1], tmp2); + _mm_storeu_si128(&((__m128i*)out)[i*8+2], tmp3); + _mm_storeu_si128(&((__m128i*)out)[i*8+3], tmp4); + _mm_storeu_si128(&((__m128i*)out)[i*8+4], tmp5); + _mm_storeu_si128(&((__m128i*)out)[i*8+5], tmp6); + _mm_storeu_si128(&((__m128i*)out)[i*8+6], tmp7); + _mm_storeu_si128(&((__m128i*)out)[i*8+7], tmp8); + + tmp1 = _mm_shuffle_epi8(tmp1, BSWAP_MASK); + tmp2 = _mm_shuffle_epi8(tmp2, BSWAP_MASK); + tmp3 = _mm_shuffle_epi8(tmp3, BSWAP_MASK); + tmp4 = _mm_shuffle_epi8(tmp4, BSWAP_MASK); + tmp5 = _mm_shuffle_epi8(tmp5, BSWAP_MASK); + tmp6 = _mm_shuffle_epi8(tmp6, BSWAP_MASK); + tmp7 = _mm_shuffle_epi8(tmp7, BSWAP_MASK); + tmp8 = _mm_shuffle_epi8(tmp8, BSWAP_MASK); + } + for (k=i*8; k<nbytes/16; k++) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + ctr1 = _mm_add_epi64(ctr1, ONE); + tmp1 = _mm_xor_si128(tmp1, KEY[0]); + for (j=1; j<nr-1; j+=2) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp1 = _mm_aesenc_si128(tmp1, KEY[j+1]); + } + tmp1 = _mm_aesenc_si128(tmp1, KEY[nr-1]); + tmp1 = _mm_aesenclast_si128(tmp1, KEY[nr]); + tmp1 = _mm_xor_si128(tmp1, _mm_loadu_si128(&((__m128i*)in)[k])); + _mm_storeu_si128(&((__m128i*)out)[k], tmp1); + } + //If remains one incomplete block + if (nbytes%16) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + tmp1 = _mm_xor_si128(tmp1, KEY[0]); + for (j=1; j<nr-1; j+=2) { + tmp1 = _mm_aesenc_si128(tmp1, KEY[j]); + tmp1 = _mm_aesenc_si128(tmp1, KEY[j+1]); + } + tmp1 = _mm_aesenc_si128(tmp1, KEY[nr-1]); + tmp1 = _mm_aesenclast_si128(tmp1, KEY[nr]); + tmp1 = _mm_xor_si128(tmp1, _mm_loadu_si128(&((__m128i*)in)[k])); + last_block = tmp1; + for (j=0; j<nbytes%16; j++) + out[k*16+j] = ((unsigned char*)&last_block)[j]; + } + return 1; //when sucessfull returns 1 +} diff --git a/sys/crypto/aesni/aesni_os.h b/sys/crypto/aesni/aesni_os.h new file mode 100644 index 0000000..273c3f9 --- /dev/null +++ b/sys/crypto/aesni/aesni_os.h @@ -0,0 +1,33 @@ +/*- + * Copyright 2015 Craig Rodrigues <rodrigc@FreeBSD.org> + * 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$ + * + */ + +#if defined(__GNUC__) && defined(_KERNEL) +/* Suppress inclusion of gcc's mm_malloc.h header */ +#define _MM_MALLOC_H_INCLUDED 1 +#endif diff --git a/sys/crypto/aesni/aesni_wrap.c b/sys/crypto/aesni/aesni_wrap.c index 39819a6..e5e2a69 100644 --- a/sys/crypto/aesni/aesni_wrap.c +++ b/sys/crypto/aesni/aesni_wrap.c @@ -3,8 +3,13 @@ * Copyright (c) 2010 Konstantin Belousov <kib@FreeBSD.org> * Copyright (c) 2010-2011 Pawel Jakub Dawidek <pawel@dawidek.net> * Copyright 2012-2013 John-Mark Gurney <jmg@FreeBSD.org> + * Copyright (c) 2014 The FreeBSD Foundation * All rights reserved. * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: @@ -29,15 +34,18 @@ #include <sys/cdefs.h> __FBSDID("$FreeBSD$"); - + #include <sys/param.h> #include <sys/libkern.h> #include <sys/malloc.h> #include <sys/proc.h> #include <sys/systm.h> #include <crypto/aesni/aesni.h> - + +#include <opencrypto/gmac.h> + #include "aesencdec.h" +#include <smmintrin.h> MALLOC_DECLARE(M_AESNI); @@ -176,6 +184,104 @@ aesni_decrypt_ecb(int rounds, const void *key_schedule, size_t len, } } +/* + * mixed endian increment, low 64bits stored in hi word to be compatible + * with _icm's BSWAP. + */ +static inline __m128i +nextc(__m128i x) +{ + const __m128i ONE = _mm_setr_epi32(0, 0, 1, 0); + const __m128i ZERO = _mm_setzero_si128(); + + x = _mm_add_epi64(x, ONE); + __m128i t = _mm_cmpeq_epi64(x, ZERO); + t = _mm_unpackhi_epi64(t, ZERO); + x = _mm_sub_epi64(x, t); + + return x; +} + +void +aesni_encrypt_icm(int rounds, const void *key_schedule, size_t len, + const uint8_t *from, uint8_t *to, const uint8_t iv[AES_BLOCK_LEN]) +{ + __m128i tot; + __m128i tmp1, tmp2, tmp3, tmp4; + __m128i tmp5, tmp6, tmp7, tmp8; + __m128i ctr1, ctr2, ctr3, ctr4; + __m128i ctr5, ctr6, ctr7, ctr8; + __m128i BSWAP_EPI64; + __m128i tout[8]; + struct blocks8 *top; + const struct blocks8 *blks; + size_t i, cnt; + + BSWAP_EPI64 = _mm_set_epi8(8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7); + + ctr1 = _mm_loadu_si128((__m128i*)iv); + ctr1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + + cnt = len / AES_BLOCK_LEN / 8; + for (i = 0; i < cnt; i++) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + ctr2 = nextc(ctr1); + tmp2 = _mm_shuffle_epi8(ctr2, BSWAP_EPI64); + ctr3 = nextc(ctr2); + tmp3 = _mm_shuffle_epi8(ctr3, BSWAP_EPI64); + ctr4 = nextc(ctr3); + tmp4 = _mm_shuffle_epi8(ctr4, BSWAP_EPI64); + ctr5 = nextc(ctr4); + tmp5 = _mm_shuffle_epi8(ctr5, BSWAP_EPI64); + ctr6 = nextc(ctr5); + tmp6 = _mm_shuffle_epi8(ctr6, BSWAP_EPI64); + ctr7 = nextc(ctr6); + tmp7 = _mm_shuffle_epi8(ctr7, BSWAP_EPI64); + ctr8 = nextc(ctr7); + tmp8 = _mm_shuffle_epi8(ctr8, BSWAP_EPI64); + ctr1 = nextc(ctr8); + + blks = (const struct blocks8 *)from; + top = (struct blocks8 *)to; + aesni_enc8(rounds - 1, key_schedule, tmp1, tmp2, tmp3, tmp4, + tmp5, tmp6, tmp7, tmp8, tout); + + top->blk[0] = blks->blk[0] ^ tout[0]; + top->blk[1] = blks->blk[1] ^ tout[1]; + top->blk[2] = blks->blk[2] ^ tout[2]; + top->blk[3] = blks->blk[3] ^ tout[3]; + top->blk[4] = blks->blk[4] ^ tout[4]; + top->blk[5] = blks->blk[5] ^ tout[5]; + top->blk[6] = blks->blk[6] ^ tout[6]; + top->blk[7] = blks->blk[7] ^ tout[7]; + + from += AES_BLOCK_LEN * 8; + to += AES_BLOCK_LEN * 8; + } + i *= 8; + cnt = len / AES_BLOCK_LEN; + for (; i < cnt; i++) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + ctr1 = nextc(ctr1); + + tot = aesni_enc(rounds - 1, key_schedule, tmp1); + + tot = tot ^ _mm_loadu_si128((const __m128i *)from); + _mm_storeu_si128((__m128i *)to, tot); + + from += AES_BLOCK_LEN; + to += AES_BLOCK_LEN; + } + + /* handle remaining partial round */ + if (len % AES_BLOCK_LEN != 0) { + tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64); + tot = aesni_enc(rounds - 1, key_schedule, tmp1); + tot = tot ^ _mm_loadu_si128((const __m128i *)from); + memcpy(to, &tot, len % AES_BLOCK_LEN); + } +} + #define AES_XTS_BLOCKSIZE 16 #define AES_XTS_IVSIZE 8 #define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ @@ -333,8 +439,15 @@ int aesni_cipher_setup_common(struct aesni_session *ses, const uint8_t *key, int keylen) { + int decsched; + + decsched = 1; switch (ses->algo) { + case CRYPTO_AES_ICM: + case CRYPTO_AES_NIST_GCM_16: + decsched = 0; + /* FALLTHROUGH */ case CRYPTO_AES_CBC: switch (keylen) { case 128: @@ -347,6 +460,7 @@ aesni_cipher_setup_common(struct aesni_session *ses, const uint8_t *key, ses->rounds = AES256_ROUNDS; break; default: + CRYPTDEB("invalid CBC/ICM/GCM key length"); return (EINVAL); } break; @@ -359,6 +473,7 @@ aesni_cipher_setup_common(struct aesni_session *ses, const uint8_t *key, ses->rounds = AES256_ROUNDS; break; default: + CRYPTDEB("invalid XTS key length"); return (EINVAL); } break; @@ -367,13 +482,13 @@ aesni_cipher_setup_common(struct aesni_session *ses, const uint8_t *key, } aesni_set_enckey(key, ses->enc_schedule, ses->rounds); - aesni_set_deckey(ses->enc_schedule, ses->dec_schedule, ses->rounds); - if (ses->algo == CRYPTO_AES_CBC) - arc4rand(ses->iv, sizeof(ses->iv), 0); - else /* if (ses->algo == CRYPTO_AES_XTS) */ { + if (decsched) + aesni_set_deckey(ses->enc_schedule, ses->dec_schedule, + ses->rounds); + + if (ses->algo == CRYPTO_AES_XTS) aesni_set_enckey(key + keylen / 16, ses->xts_schedule, ses->rounds); - } return (0); } diff --git a/sys/crypto/rijndael/rijndael-api-fst.c b/sys/crypto/rijndael/rijndael-api-fst.c index 187177b..bf7b4d1 100644 --- a/sys/crypto/rijndael/rijndael-api-fst.c +++ b/sys/crypto/rijndael/rijndael-api-fst.c @@ -34,7 +34,8 @@ __FBSDID("$FreeBSD$"); typedef u_int8_t BYTE; -int rijndael_makeKey(keyInstance *key, BYTE direction, int keyLen, char *keyMaterial) { +int rijndael_makeKey(keyInstance *key, BYTE direction, int keyLen, + const char *keyMaterial) { u_int8_t cipherKey[RIJNDAEL_MAXKB]; if (key == NULL) { @@ -83,7 +84,7 @@ int rijndael_cipherInit(cipherInstance *cipher, BYTE mode, char *IV) { } int rijndael_blockEncrypt(cipherInstance *cipher, keyInstance *key, - BYTE *input, int inputLen, BYTE *outBuffer) { + const BYTE *input, int inputLen, BYTE *outBuffer) { int i, k, numBlocks; u_int8_t block[16], iv[4][4]; @@ -198,7 +199,7 @@ int rijndael_blockEncrypt(cipherInstance *cipher, keyInstance *key, * @return length in octets (not bits) of the encrypted output buffer. */ int rijndael_padEncrypt(cipherInstance *cipher, keyInstance *key, - BYTE *input, int inputOctets, BYTE *outBuffer) { + const BYTE *input, int inputOctets, BYTE *outBuffer) { int i, numBlocks, padLen; u_int8_t block[16], *iv, *cp; @@ -232,10 +233,10 @@ int rijndael_padEncrypt(cipherInstance *cipher, keyInstance *key, case MODE_CBC: iv = cipher->IV; for (i = numBlocks; i > 0; i--) { - ((u_int32_t*)block)[0] = ((u_int32_t*)input)[0] ^ ((u_int32_t*)iv)[0]; - ((u_int32_t*)block)[1] = ((u_int32_t*)input)[1] ^ ((u_int32_t*)iv)[1]; - ((u_int32_t*)block)[2] = ((u_int32_t*)input)[2] ^ ((u_int32_t*)iv)[2]; - ((u_int32_t*)block)[3] = ((u_int32_t*)input)[3] ^ ((u_int32_t*)iv)[3]; + ((u_int32_t*)block)[0] = ((const u_int32_t*)input)[0] ^ ((u_int32_t*)iv)[0]; + ((u_int32_t*)block)[1] = ((const u_int32_t*)input)[1] ^ ((u_int32_t*)iv)[1]; + ((u_int32_t*)block)[2] = ((const u_int32_t*)input)[2] ^ ((u_int32_t*)iv)[2]; + ((u_int32_t*)block)[3] = ((const u_int32_t*)input)[3] ^ ((u_int32_t*)iv)[3]; rijndaelEncrypt(key->rk, key->Nr, block, outBuffer); iv = outBuffer; input += 16; @@ -261,7 +262,7 @@ int rijndael_padEncrypt(cipherInstance *cipher, keyInstance *key, } int rijndael_blockDecrypt(cipherInstance *cipher, keyInstance *key, - BYTE *input, int inputLen, BYTE *outBuffer) { + const BYTE *input, int inputLen, BYTE *outBuffer) { int i, k, numBlocks; u_int8_t block[16], iv[4][4]; @@ -360,7 +361,7 @@ int rijndael_blockDecrypt(cipherInstance *cipher, keyInstance *key, } int rijndael_padDecrypt(cipherInstance *cipher, keyInstance *key, - BYTE *input, int inputOctets, BYTE *outBuffer) { + const BYTE *input, int inputOctets, BYTE *outBuffer) { int i, numBlocks, padLen; u_int8_t block[16]; u_int32_t iv[4]; diff --git a/sys/crypto/rijndael/rijndael-api-fst.h b/sys/crypto/rijndael/rijndael-api-fst.h index 122bf52..e5f596a 100644 --- a/sys/crypto/rijndael/rijndael-api-fst.h +++ b/sys/crypto/rijndael/rijndael-api-fst.h @@ -56,18 +56,18 @@ typedef struct { /* changed order of the components */ /* Function prototypes */ -int rijndael_makeKey(keyInstance *, u_int8_t, int, char *); +int rijndael_makeKey(keyInstance *, u_int8_t, int, const char *); int rijndael_cipherInit(cipherInstance *, u_int8_t, char *); -int rijndael_blockEncrypt(cipherInstance *, keyInstance *, u_int8_t *, int, - u_int8_t *); -int rijndael_padEncrypt(cipherInstance *, keyInstance *, u_int8_t *, int, - u_int8_t *); +int rijndael_blockEncrypt(cipherInstance *, keyInstance *, const u_int8_t *, + int, u_int8_t *); +int rijndael_padEncrypt(cipherInstance *, keyInstance *, const u_int8_t *, + int, u_int8_t *); -int rijndael_blockDecrypt(cipherInstance *, keyInstance *, u_int8_t *, int, - u_int8_t *); -int rijndael_padDecrypt(cipherInstance *, keyInstance *, u_int8_t *, int, - u_int8_t *); +int rijndael_blockDecrypt(cipherInstance *, keyInstance *, const u_int8_t *, + int, u_int8_t *); +int rijndael_padDecrypt(cipherInstance *, keyInstance *, const u_int8_t *, + int, u_int8_t *); #endif /* __RIJNDAEL_API_FST_H */ diff --git a/sys/crypto/sha2/sha2.c b/sys/crypto/sha2/sha2.c index 66ec6e9..5bb52f3 100644 --- a/sys/crypto/sha2/sha2.c +++ b/sys/crypto/sha2/sha2.c @@ -121,20 +121,10 @@ __FBSDID("$FreeBSD$"); * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t * types and pointing out recent ANSI C support for uintXX_t in inttypes.h. */ -#if 0 /*def SHA2_USE_INTTYPES_H*/ - typedef uint8_t sha2_byte; /* Exactly 1 byte */ typedef uint32_t sha2_word32; /* Exactly 4 bytes */ typedef uint64_t sha2_word64; /* Exactly 8 bytes */ -#else /* SHA2_USE_INTTYPES_H */ - -typedef u_int8_t sha2_byte; /* Exactly 1 byte */ -typedef u_int32_t sha2_word32; /* Exactly 4 bytes */ -typedef u_int64_t sha2_word64; /* Exactly 8 bytes */ - -#endif /* SHA2_USE_INTTYPES_H */ - /*** SHA-256/384/512 Various Length Definitions ***********************/ /* NOTE: Most of these are in sha2.h */ @@ -183,8 +173,6 @@ typedef u_int64_t sha2_word64; /* Exactly 8 bytes */ */ /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */ #define R(b,x) ((x) >> (b)) -/* 32-bit Rotate-right (used in SHA-256): */ -#define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b)))) /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */ #define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b)))) @@ -192,12 +180,6 @@ typedef u_int64_t sha2_word64; /* Exactly 8 bytes */ #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) -/* Four of six logical functions used in SHA-256: */ -#define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x))) -#define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x))) -#define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x))) -#define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x))) - /* Four of six logical functions used in SHA-384 and SHA-512: */ #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x))) #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x))) @@ -210,43 +192,10 @@ typedef u_int64_t sha2_word64; /* Exactly 8 bytes */ * only. */ static void SHA512_Last(SHA512_CTX*); -static void SHA256_Transform(SHA256_CTX*, const sha2_word32*); static void SHA512_Transform(SHA512_CTX*, const sha2_word64*); /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/ -/* Hash constant words K for SHA-256: */ -static const sha2_word32 K256[64] = { - 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, - 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, - 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL, - 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, - 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, - 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, - 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, - 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL, - 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL, - 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, - 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, - 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, - 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, - 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL, - 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, - 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL -}; - -/* Initial hash value H for SHA-256: */ -static const sha2_word32 sha256_initial_hash_value[8] = { - 0x6a09e667UL, - 0xbb67ae85UL, - 0x3c6ef372UL, - 0xa54ff53aUL, - 0x510e527fUL, - 0x9b05688cUL, - 0x1f83d9abUL, - 0x5be0cd19UL -}; - /* Hash constant words K for SHA-384 and SHA-512: */ static const sha2_word64 K512[80] = { 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, @@ -323,301 +272,6 @@ static const char *sha2_hex_digits = "0123456789abcdef"; /*** SHA-256: *********************************************************/ -void SHA256_Init(SHA256_CTX* context) { - if (context == (SHA256_CTX*)0) { - return; - } - bcopy(sha256_initial_hash_value, context->state, SHA256_DIGEST_LENGTH); - bzero(context->buffer, SHA256_BLOCK_LENGTH); - context->bitcount = 0; -} - -#ifdef SHA2_UNROLL_TRANSFORM - -/* Unrolled SHA-256 round macros: */ - -#if BYTE_ORDER == LITTLE_ENDIAN - -#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ - REVERSE32(*data++, W256[j]); \ - T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ - K256[j] + W256[j]; \ - (d) += T1; \ - (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ - j++ - - -#else /* BYTE_ORDER == LITTLE_ENDIAN */ - -#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ - T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ - K256[j] + (W256[j] = *data++); \ - (d) += T1; \ - (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ - j++ - -#endif /* BYTE_ORDER == LITTLE_ENDIAN */ - -#define ROUND256(a,b,c,d,e,f,g,h) \ - s0 = W256[(j+1)&0x0f]; \ - s0 = sigma0_256(s0); \ - s1 = W256[(j+14)&0x0f]; \ - s1 = sigma1_256(s1); \ - T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \ - (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \ - (d) += T1; \ - (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ - j++ - -static void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { - sha2_word32 a, b, c, d, e, f, g, h, s0, s1; - sha2_word32 T1, *W256; - int j; - - W256 = (sha2_word32*)context->buffer; - - /* Initialize registers with the prev. intermediate value */ - a = context->state[0]; - b = context->state[1]; - c = context->state[2]; - d = context->state[3]; - e = context->state[4]; - f = context->state[5]; - g = context->state[6]; - h = context->state[7]; - - j = 0; - do { - /* Rounds 0 to 15 (unrolled): */ - ROUND256_0_TO_15(a,b,c,d,e,f,g,h); - ROUND256_0_TO_15(h,a,b,c,d,e,f,g); - ROUND256_0_TO_15(g,h,a,b,c,d,e,f); - ROUND256_0_TO_15(f,g,h,a,b,c,d,e); - ROUND256_0_TO_15(e,f,g,h,a,b,c,d); - ROUND256_0_TO_15(d,e,f,g,h,a,b,c); - ROUND256_0_TO_15(c,d,e,f,g,h,a,b); - ROUND256_0_TO_15(b,c,d,e,f,g,h,a); - } while (j < 16); - - /* Now for the remaining rounds to 64: */ - do { - ROUND256(a,b,c,d,e,f,g,h); - ROUND256(h,a,b,c,d,e,f,g); - ROUND256(g,h,a,b,c,d,e,f); - ROUND256(f,g,h,a,b,c,d,e); - ROUND256(e,f,g,h,a,b,c,d); - ROUND256(d,e,f,g,h,a,b,c); - ROUND256(c,d,e,f,g,h,a,b); - ROUND256(b,c,d,e,f,g,h,a); - } while (j < 64); - - /* Compute the current intermediate hash value */ - context->state[0] += a; - context->state[1] += b; - context->state[2] += c; - context->state[3] += d; - context->state[4] += e; - context->state[5] += f; - context->state[6] += g; - context->state[7] += h; - - /* Clean up */ - a = b = c = d = e = f = g = h = T1 = 0; -} - -#else /* SHA2_UNROLL_TRANSFORM */ - -static void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { - sha2_word32 a, b, c, d, e, f, g, h, s0, s1; - sha2_word32 T1, T2, *W256; - int j; - - W256 = (sha2_word32*)context->buffer; - - /* Initialize registers with the prev. intermediate value */ - a = context->state[0]; - b = context->state[1]; - c = context->state[2]; - d = context->state[3]; - e = context->state[4]; - f = context->state[5]; - g = context->state[6]; - h = context->state[7]; - - j = 0; - do { -#if BYTE_ORDER == LITTLE_ENDIAN - /* Copy data while converting to host byte order */ - REVERSE32(*data++,W256[j]); - /* Apply the SHA-256 compression function to update a..h */ - T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j]; -#else /* BYTE_ORDER == LITTLE_ENDIAN */ - /* Apply the SHA-256 compression function to update a..h with copy */ - T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++); -#endif /* BYTE_ORDER == LITTLE_ENDIAN */ - T2 = Sigma0_256(a) + Maj(a, b, c); - h = g; - g = f; - f = e; - e = d + T1; - d = c; - c = b; - b = a; - a = T1 + T2; - - j++; - } while (j < 16); - - do { - /* Part of the message block expansion: */ - s0 = W256[(j+1)&0x0f]; - s0 = sigma0_256(s0); - s1 = W256[(j+14)&0x0f]; - s1 = sigma1_256(s1); - - /* Apply the SHA-256 compression function to update a..h */ - T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + - (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); - T2 = Sigma0_256(a) + Maj(a, b, c); - h = g; - g = f; - f = e; - e = d + T1; - d = c; - c = b; - b = a; - a = T1 + T2; - - j++; - } while (j < 64); - - /* Compute the current intermediate hash value */ - context->state[0] += a; - context->state[1] += b; - context->state[2] += c; - context->state[3] += d; - context->state[4] += e; - context->state[5] += f; - context->state[6] += g; - context->state[7] += h; - - /* Clean up */ - a = b = c = d = e = f = g = h = T1 = T2 = 0; -} - -#endif /* SHA2_UNROLL_TRANSFORM */ - -void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) { - unsigned int freespace, usedspace; - - if (len == 0) { - /* Calling with no data is valid - we do nothing */ - return; - } - - /* Sanity check: */ - assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0); - - usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH; - if (usedspace > 0) { - /* Calculate how much free space is available in the buffer */ - freespace = SHA256_BLOCK_LENGTH - usedspace; - - if (len >= freespace) { - /* Fill the buffer completely and process it */ - bcopy(data, &context->buffer[usedspace], freespace); - context->bitcount += freespace << 3; - len -= freespace; - data += freespace; - SHA256_Transform(context, (sha2_word32*)context->buffer); - } else { - /* The buffer is not yet full */ - bcopy(data, &context->buffer[usedspace], len); - context->bitcount += len << 3; - /* Clean up: */ - usedspace = freespace = 0; - return; - } - } - while (len >= SHA256_BLOCK_LENGTH) { - /* Process as many complete blocks as we can */ - SHA256_Transform(context, (const sha2_word32*)data); - context->bitcount += SHA256_BLOCK_LENGTH << 3; - len -= SHA256_BLOCK_LENGTH; - data += SHA256_BLOCK_LENGTH; - } - if (len > 0) { - /* There's left-overs, so save 'em */ - bcopy(data, context->buffer, len); - context->bitcount += len << 3; - } - /* Clean up: */ - usedspace = freespace = 0; -} - -void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) { - sha2_word32 *d = (sha2_word32*)digest; - unsigned int usedspace; - - /* Sanity check: */ - assert(context != (SHA256_CTX*)0); - - /* If no digest buffer is passed, we don't bother doing this: */ - if (digest != (sha2_byte*)0) { - usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH; -#if BYTE_ORDER == LITTLE_ENDIAN - /* Convert FROM host byte order */ - REVERSE64(context->bitcount,context->bitcount); -#endif - if (usedspace > 0) { - /* Begin padding with a 1 bit: */ - context->buffer[usedspace++] = 0x80; - - if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) { - /* Set-up for the last transform: */ - bzero(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace); - } else { - if (usedspace < SHA256_BLOCK_LENGTH) { - bzero(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace); - } - /* Do second-to-last transform: */ - SHA256_Transform(context, (sha2_word32*)context->buffer); - - /* And set-up for the last transform: */ - bzero(context->buffer, SHA256_SHORT_BLOCK_LENGTH); - } - } else { - /* Set-up for the last transform: */ - bzero(context->buffer, SHA256_SHORT_BLOCK_LENGTH); - - /* Begin padding with a 1 bit: */ - *context->buffer = 0x80; - } - /* Set the bit count: */ - *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount; - - /* Final transform: */ - SHA256_Transform(context, (sha2_word32*)context->buffer); - -#if BYTE_ORDER == LITTLE_ENDIAN - { - /* Convert TO host byte order */ - int j; - for (j = 0; j < 8; j++) { - REVERSE32(context->state[j],context->state[j]); - *d++ = context->state[j]; - } - } -#else - bcopy(context->state, d, SHA256_DIGEST_LENGTH); -#endif - } - - /* Clean up state data: */ - bzero(context, sizeof(*context)); - usedspace = 0; -} - char *SHA256_End(SHA256_CTX* context, char buffer[]) { sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest; int i; @@ -641,7 +295,7 @@ char *SHA256_End(SHA256_CTX* context, char buffer[]) { return buffer; } -char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) { +char* SHA256_Data(const void *data, unsigned int len, char *digest) { SHA256_CTX context; SHA256_Init(&context); diff --git a/sys/crypto/sha2/sha2.h b/sys/crypto/sha2/sha2.h index 639d58b..59e91f6 100644 --- a/sys/crypto/sha2/sha2.h +++ b/sys/crypto/sha2/sha2.h @@ -56,70 +56,17 @@ extern "C" { #define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1) -/*** SHA-256/384/512 Context Structures *******************************/ -/* NOTE: If your architecture does not define either u_intXX_t types or - * uintXX_t (from inttypes.h), you may need to define things by hand - * for your system: - */ -#if 0 -typedef unsigned char u_int8_t; /* 1-byte (8-bits) */ -typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */ -typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */ -#endif -/* - * Most BSD systems already define u_intXX_t types, as does Linux. - * Some systems, however, like Compaq's Tru64 Unix instead can use - * uintXX_t types defined by very recent ANSI C standards and included - * in the file: - * - * #include <inttypes.h> - * - * If you choose to use <inttypes.h> then please define: - * - * #define SHA2_USE_INTTYPES_H - * - * Or on the command line during compile: - * - * cc -DSHA2_USE_INTTYPES_H ... - */ -#if 0 /*def SHA2_USE_INTTYPES_H*/ - -typedef struct _SHA256_CTX { - uint32_t state[8]; - uint64_t bitcount; - uint8_t buffer[SHA256_BLOCK_LENGTH]; -} SHA256_CTX; +/*** SHA-384/512 Context Structures *******************************/ typedef struct _SHA512_CTX { uint64_t state[8]; uint64_t bitcount[2]; uint8_t buffer[SHA512_BLOCK_LENGTH]; } SHA512_CTX; -#else /* SHA2_USE_INTTYPES_H */ - -typedef struct _SHA256_CTX { - u_int32_t state[8]; - u_int64_t bitcount; - u_int8_t buffer[SHA256_BLOCK_LENGTH]; -} SHA256_CTX; -typedef struct _SHA512_CTX { - u_int64_t state[8]; - u_int64_t bitcount[2]; - u_int8_t buffer[SHA512_BLOCK_LENGTH]; -} SHA512_CTX; - -#endif /* SHA2_USE_INTTYPES_H */ - typedef SHA512_CTX SHA384_CTX; -/*** SHA-256/384/512 Function Prototypes ******************************/ - -void SHA256_Init(SHA256_CTX *); -void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t); -void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); -char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); -char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); +/*** SHA-384/512 Function Prototypes ******************************/ void SHA384_Init(SHA384_CTX*); void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t); @@ -137,4 +84,6 @@ char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); } #endif /* __cplusplus */ +#include "sha256.h" + #endif /* __SHA2_H__ */ diff --git a/sys/crypto/sha2/sha256.h b/sys/crypto/sha2/sha256.h new file mode 100644 index 0000000..c828379 --- /dev/null +++ b/sys/crypto/sha2/sha256.h @@ -0,0 +1,86 @@ +/*- + * Copyright 2005 Colin Percival + * 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$ + */ + +#ifndef _SHA256_H_ +#define _SHA256_H_ + +#ifndef _KERNEL +#include <sys/types.h> +#endif + +typedef struct SHA256Context { + uint32_t state[8]; + uint64_t count; + uint8_t buf[64]; +} SHA256_CTX; + +__BEGIN_DECLS + +/* Ensure libmd symbols do not clash with libcrypto */ + +#ifndef SHA256_Init +#define SHA256_Init _libmd_SHA256_Init +#endif +#ifndef SHA256_Update +#define SHA256_Update _libmd_SHA256_Update +#endif +#ifndef SHA256_Final +#define SHA256_Final _libmd_SHA256_Final +#endif +#ifndef SHA256_End +#define SHA256_End _libmd_SHA256_End +#endif +#ifndef SHA256_File +#define SHA256_File _libmd_SHA256_File +#endif +#ifndef SHA256_FileChunk +#define SHA256_FileChunk _libmd_SHA256_FileChunk +#endif +#ifndef SHA256_Data +#define SHA256_Data _libmd_SHA256_Data +#endif + +#ifndef SHA256_Transform +#define SHA256_Transform _libmd_SHA256_Transform +#endif +#ifndef SHA256_version +#define SHA256_version _libmd_SHA256_version +#endif + +void SHA256_Init(SHA256_CTX *); +void SHA256_Update(SHA256_CTX *, const void *, size_t); +void SHA256_Final(unsigned char [32], SHA256_CTX *); +char *SHA256_End(SHA256_CTX *, char *); +char *SHA256_Data(const void *, unsigned int, char *); +#ifndef _KERNEL +char *SHA256_File(const char *, char *); +char *SHA256_FileChunk(const char *, char *, off_t, off_t); +#endif +__END_DECLS + +#endif /* !_SHA256_H_ */ diff --git a/sys/crypto/sha2/sha256c.c b/sys/crypto/sha2/sha256c.c new file mode 100644 index 0000000..da9b02c --- /dev/null +++ b/sys/crypto/sha2/sha256c.c @@ -0,0 +1,316 @@ +/*- + * Copyright 2005 Colin Percival + * 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/endian.h> +#include <sys/types.h> + +#ifdef _KERNEL +#include <sys/systm.h> +#else +#include <string.h> +#endif + +#include "sha256.h" + +#if BYTE_ORDER == BIG_ENDIAN + +/* Copy a vector of big-endian uint32_t into a vector of bytes */ +#define be32enc_vect(dst, src, len) \ + memcpy((void *)dst, (const void *)src, (size_t)len) + +/* Copy a vector of bytes into a vector of big-endian uint32_t */ +#define be32dec_vect(dst, src, len) \ + memcpy((void *)dst, (const void *)src, (size_t)len) + +#else /* BYTE_ORDER != BIG_ENDIAN */ + +/* + * Encode a length len/4 vector of (uint32_t) into a length len vector of + * (unsigned char) in big-endian form. Assumes len is a multiple of 4. + */ +static void +be32enc_vect(unsigned char *dst, const uint32_t *src, size_t len) +{ + size_t i; + + for (i = 0; i < len / 4; i++) + be32enc(dst + i * 4, src[i]); +} + +/* + * Decode a big-endian length len vector of (unsigned char) into a length + * len/4 vector of (uint32_t). Assumes len is a multiple of 4. + */ +static void +be32dec_vect(uint32_t *dst, const unsigned char *src, size_t len) +{ + size_t i; + + for (i = 0; i < len / 4; i++) + dst[i] = be32dec(src + i * 4); +} + +#endif /* BYTE_ORDER != BIG_ENDIAN */ + +/* Elementary functions used by SHA256 */ +#define Ch(x, y, z) ((x & (y ^ z)) ^ z) +#define Maj(x, y, z) ((x & (y | z)) | (y & z)) +#define SHR(x, n) (x >> n) +#define ROTR(x, n) ((x >> n) | (x << (32 - n))) +#define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) +#define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) +#define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3)) +#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10)) + +/* SHA256 round function */ +#define RND(a, b, c, d, e, f, g, h, k) \ + t0 = h + S1(e) + Ch(e, f, g) + k; \ + t1 = S0(a) + Maj(a, b, c); \ + d += t0; \ + h = t0 + t1; + +/* Adjusted round function for rotating state */ +#define RNDr(S, W, i, k) \ + RND(S[(64 - i) % 8], S[(65 - i) % 8], \ + S[(66 - i) % 8], S[(67 - i) % 8], \ + S[(68 - i) % 8], S[(69 - i) % 8], \ + S[(70 - i) % 8], S[(71 - i) % 8], \ + W[i] + k) + +/* + * SHA256 block compression function. The 256-bit state is transformed via + * the 512-bit input block to produce a new state. + */ +static void +SHA256_Transform(uint32_t * state, const unsigned char block[64]) +{ + uint32_t W[64]; + uint32_t S[8]; + uint32_t t0, t1; + int i; + + /* 1. Prepare message schedule W. */ + be32dec_vect(W, block, 64); + for (i = 16; i < 64; i++) + W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16]; + + /* 2. Initialize working variables. */ + memcpy(S, state, 32); + + /* 3. Mix. */ + RNDr(S, W, 0, 0x428a2f98); + RNDr(S, W, 1, 0x71374491); + RNDr(S, W, 2, 0xb5c0fbcf); + RNDr(S, W, 3, 0xe9b5dba5); + RNDr(S, W, 4, 0x3956c25b); + RNDr(S, W, 5, 0x59f111f1); + RNDr(S, W, 6, 0x923f82a4); + RNDr(S, W, 7, 0xab1c5ed5); + RNDr(S, W, 8, 0xd807aa98); + RNDr(S, W, 9, 0x12835b01); + RNDr(S, W, 10, 0x243185be); + RNDr(S, W, 11, 0x550c7dc3); + RNDr(S, W, 12, 0x72be5d74); + RNDr(S, W, 13, 0x80deb1fe); + RNDr(S, W, 14, 0x9bdc06a7); + RNDr(S, W, 15, 0xc19bf174); + RNDr(S, W, 16, 0xe49b69c1); + RNDr(S, W, 17, 0xefbe4786); + RNDr(S, W, 18, 0x0fc19dc6); + RNDr(S, W, 19, 0x240ca1cc); + RNDr(S, W, 20, 0x2de92c6f); + RNDr(S, W, 21, 0x4a7484aa); + RNDr(S, W, 22, 0x5cb0a9dc); + RNDr(S, W, 23, 0x76f988da); + RNDr(S, W, 24, 0x983e5152); + RNDr(S, W, 25, 0xa831c66d); + RNDr(S, W, 26, 0xb00327c8); + RNDr(S, W, 27, 0xbf597fc7); + RNDr(S, W, 28, 0xc6e00bf3); + RNDr(S, W, 29, 0xd5a79147); + RNDr(S, W, 30, 0x06ca6351); + RNDr(S, W, 31, 0x14292967); + RNDr(S, W, 32, 0x27b70a85); + RNDr(S, W, 33, 0x2e1b2138); + RNDr(S, W, 34, 0x4d2c6dfc); + RNDr(S, W, 35, 0x53380d13); + RNDr(S, W, 36, 0x650a7354); + RNDr(S, W, 37, 0x766a0abb); + RNDr(S, W, 38, 0x81c2c92e); + RNDr(S, W, 39, 0x92722c85); + RNDr(S, W, 40, 0xa2bfe8a1); + RNDr(S, W, 41, 0xa81a664b); + RNDr(S, W, 42, 0xc24b8b70); + RNDr(S, W, 43, 0xc76c51a3); + RNDr(S, W, 44, 0xd192e819); + RNDr(S, W, 45, 0xd6990624); + RNDr(S, W, 46, 0xf40e3585); + RNDr(S, W, 47, 0x106aa070); + RNDr(S, W, 48, 0x19a4c116); + RNDr(S, W, 49, 0x1e376c08); + RNDr(S, W, 50, 0x2748774c); + RNDr(S, W, 51, 0x34b0bcb5); + RNDr(S, W, 52, 0x391c0cb3); + RNDr(S, W, 53, 0x4ed8aa4a); + RNDr(S, W, 54, 0x5b9cca4f); + RNDr(S, W, 55, 0x682e6ff3); + RNDr(S, W, 56, 0x748f82ee); + RNDr(S, W, 57, 0x78a5636f); + RNDr(S, W, 58, 0x84c87814); + RNDr(S, W, 59, 0x8cc70208); + RNDr(S, W, 60, 0x90befffa); + RNDr(S, W, 61, 0xa4506ceb); + RNDr(S, W, 62, 0xbef9a3f7); + RNDr(S, W, 63, 0xc67178f2); + + /* 4. Mix local working variables into global state */ + for (i = 0; i < 8; i++) + state[i] += S[i]; +} + +static unsigned char PAD[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* Add padding and terminating bit-count. */ +static void +SHA256_Pad(SHA256_CTX * ctx) +{ + unsigned char len[8]; + uint32_t r, plen; + + /* + * Convert length to a vector of bytes -- we do this now rather + * than later because the length will change after we pad. + */ + be64enc(len, ctx->count); + + /* Add 1--64 bytes so that the resulting length is 56 mod 64 */ + r = (ctx->count >> 3) & 0x3f; + plen = (r < 56) ? (56 - r) : (120 - r); + SHA256_Update(ctx, PAD, (size_t)plen); + + /* Add the terminating bit-count */ + SHA256_Update(ctx, len, 8); +} + +/* SHA-256 initialization. Begins a SHA-256 operation. */ +void +SHA256_Init(SHA256_CTX * ctx) +{ + + /* Zero bits processed so far */ + ctx->count = 0; + + /* Magic initialization constants */ + ctx->state[0] = 0x6A09E667; + ctx->state[1] = 0xBB67AE85; + ctx->state[2] = 0x3C6EF372; + ctx->state[3] = 0xA54FF53A; + ctx->state[4] = 0x510E527F; + ctx->state[5] = 0x9B05688C; + ctx->state[6] = 0x1F83D9AB; + ctx->state[7] = 0x5BE0CD19; +} + +/* Add bytes into the hash */ +void +SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len) +{ + uint64_t bitlen; + uint32_t r; + const unsigned char *src = in; + + /* Number of bytes left in the buffer from previous updates */ + r = (ctx->count >> 3) & 0x3f; + + /* Convert the length into a number of bits */ + bitlen = len << 3; + + /* Update number of bits */ + ctx->count += bitlen; + + /* Handle the case where we don't need to perform any transforms */ + if (len < 64 - r) { + memcpy(&ctx->buf[r], src, len); + return; + } + + /* Finish the current block */ + memcpy(&ctx->buf[r], src, 64 - r); + SHA256_Transform(ctx->state, ctx->buf); + src += 64 - r; + len -= 64 - r; + + /* Perform complete blocks */ + while (len >= 64) { + SHA256_Transform(ctx->state, src); + src += 64; + len -= 64; + } + + /* Copy left over data into buffer */ + memcpy(ctx->buf, src, len); +} + +/* + * SHA-256 finalization. Pads the input data, exports the hash value, + * and clears the context state. + */ +void +SHA256_Final(unsigned char digest[32], SHA256_CTX * ctx) +{ + + /* Add padding */ + SHA256_Pad(ctx); + + /* Write the hash */ + be32enc_vect(digest, ctx->state, 32); + + /* Clear the context state */ + memset((void *)ctx, 0, sizeof(*ctx)); +} + +#ifdef WEAK_REFS +/* When building libmd, provide weak references. Note: this is not + activated in the context of compiling these sources for internal + use in libcrypt. + */ +#undef SHA256_Init +__weak_reference(_libmd_SHA256_Init, SHA256_Init); +#undef SHA256_Update +__weak_reference(_libmd_SHA256_Update, SHA256_Update); +#undef SHA256_Final +__weak_reference(_libmd_SHA256_Final, SHA256_Final); +#undef SHA256_Transform +__weak_reference(_libmd_SHA256_Transform, SHA256_Transform); +#endif diff --git a/sys/crypto/via/padlock_hash.c b/sys/crypto/via/padlock_hash.c index 9dffc40..c952b63 100644 --- a/sys/crypto/via/padlock_hash.c +++ b/sys/crypto/via/padlock_hash.c @@ -75,7 +75,7 @@ struct padlock_sha_ctx { CTASSERT(sizeof(struct padlock_sha_ctx) <= sizeof(union authctx)); static void padlock_sha_init(struct padlock_sha_ctx *ctx); -static int padlock_sha_update(struct padlock_sha_ctx *ctx, uint8_t *buf, +static int padlock_sha_update(struct padlock_sha_ctx *ctx, const uint8_t *buf, uint16_t bufsize); static void padlock_sha1_final(uint8_t *hash, struct padlock_sha_ctx *ctx); static void padlock_sha256_final(uint8_t *hash, struct padlock_sha_ctx *ctx); @@ -83,16 +83,16 @@ static void padlock_sha256_final(uint8_t *hash, struct padlock_sha_ctx *ctx); static struct auth_hash padlock_hmac_sha1 = { CRYPTO_SHA1_HMAC, "HMAC-SHA1", 20, SHA1_HASH_LEN, SHA1_HMAC_BLOCK_LEN, sizeof(struct padlock_sha_ctx), - (void (*)(void *))padlock_sha_init, - (int (*)(void *, uint8_t *, uint16_t))padlock_sha_update, + (void (*)(void *))padlock_sha_init, NULL, NULL, + (int (*)(void *, const uint8_t *, uint16_t))padlock_sha_update, (void (*)(uint8_t *, void *))padlock_sha1_final }; static struct auth_hash padlock_hmac_sha256 = { CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256", 32, SHA2_256_HASH_LEN, SHA2_256_HMAC_BLOCK_LEN, sizeof(struct padlock_sha_ctx), - (void (*)(void *))padlock_sha_init, - (int (*)(void *, uint8_t *, uint16_t))padlock_sha_update, + (void (*)(void *))padlock_sha_init, NULL, NULL, + (int (*)(void *, const uint8_t *, uint16_t))padlock_sha_update, (void (*)(uint8_t *, void *))padlock_sha256_final }; @@ -167,7 +167,7 @@ padlock_sha_init(struct padlock_sha_ctx *ctx) } static int -padlock_sha_update(struct padlock_sha_ctx *ctx, uint8_t *buf, uint16_t bufsize) +padlock_sha_update(struct padlock_sha_ctx *ctx, const uint8_t *buf, uint16_t bufsize) { if (ctx->psc_size - ctx->psc_offset < bufsize) { diff --git a/sys/dev/ath/ah_osdep.c b/sys/dev/ath/ah_osdep.c index 043ebed..fe4a657 100644 --- a/sys/dev/ath/ah_osdep.c +++ b/sys/dev/ath/ah_osdep.c @@ -96,9 +96,8 @@ static SYSCTL_NODE(_hw_ath, OID_AUTO, hal, CTLFLAG_RD, 0, #ifdef AH_DEBUG int ath_hal_debug = 0; -SYSCTL_INT(_hw_ath_hal, OID_AUTO, debug, CTLFLAG_RW, &ath_hal_debug, +SYSCTL_INT(_hw_ath_hal, OID_AUTO, debug, CTLFLAG_RWTUN, &ath_hal_debug, 0, "Atheros HAL debugging printfs"); -TUNABLE_INT("hw.ath.hal.debug", &ath_hal_debug); #endif /* AH_DEBUG */ static MALLOC_DEFINE(M_ATH_HAL, "ath_hal", "ath hal data"); @@ -138,6 +137,24 @@ ath_hal_ether_sprintf(const u_int8_t *mac) #ifdef AH_DEBUG +/* + * XXX This is highly relevant only for the AR5416 and later + * PCI/PCIe NICs. It'll need adjustment for other hardware + * variations. + */ +static int +ath_hal_reg_whilst_asleep(struct ath_hal *ah, uint32_t reg) +{ + + if (reg >= 0x4000 && reg < 0x5000) + return (1); + if (reg >= 0x6000 && reg < 0x7000) + return (1); + if (reg >= 0x7000 && reg < 0x8000) + return (1); + return (0); +} + void DO_HALDEBUG(struct ath_hal *ah, u_int mask, const char* fmt, ...) { @@ -253,6 +270,13 @@ ath_hal_reg_write(struct ath_hal *ah, u_int32_t reg, u_int32_t val) bus_space_tag_t tag = BUSTAG(ah); bus_space_handle_t h = ah->ah_sh; + /* Debug - complain if we haven't fully waken things up */ + if (! ath_hal_reg_whilst_asleep(ah, reg) && + ah->ah_powerMode != HAL_PM_AWAKE) { + ath_hal_printf(ah, "%s: reg=0x%08x, val=0x%08x, pm=%d\n", + __func__, reg, val, ah->ah_powerMode); + } + if (ath_hal_alq) { struct ale *ale = ath_hal_alq_get(ah); if (ale) { @@ -278,6 +302,13 @@ ath_hal_reg_read(struct ath_hal *ah, u_int32_t reg) bus_space_handle_t h = ah->ah_sh; u_int32_t val; + /* Debug - complain if we haven't fully waken things up */ + if (! ath_hal_reg_whilst_asleep(ah, reg) && + ah->ah_powerMode != HAL_PM_AWAKE) { + ath_hal_printf(ah, "%s: reg=0x%08x, pm=%d\n", + __func__, reg, ah->ah_powerMode); + } + if (ah->ah_config.ah_serialise_reg_war) mtx_lock_spin(&ah_regser_mtx); val = bus_space_read_4(tag, h, reg); @@ -330,6 +361,13 @@ ath_hal_reg_write(struct ath_hal *ah, u_int32_t reg, u_int32_t val) bus_space_tag_t tag = BUSTAG(ah); bus_space_handle_t h = ah->ah_sh; + /* Debug - complain if we haven't fully waken things up */ + if (! ath_hal_reg_whilst_asleep(ah, reg) && + ah->ah_powerMode != HAL_PM_AWAKE) { + ath_hal_printf(ah, "%s: reg=0x%08x, val=0x%08x, pm=%d\n", + __func__, reg, val, ah->ah_powerMode); + } + if (ah->ah_config.ah_serialise_reg_war) mtx_lock_spin(&ah_regser_mtx); bus_space_write_4(tag, h, reg, val); @@ -344,6 +382,13 @@ ath_hal_reg_read(struct ath_hal *ah, u_int32_t reg) bus_space_handle_t h = ah->ah_sh; u_int32_t val; + /* Debug - complain if we haven't fully waken things up */ + if (! ath_hal_reg_whilst_asleep(ah, reg) && + ah->ah_powerMode != HAL_PM_AWAKE) { + ath_hal_printf(ah, "%s: reg=0x%08x, pm=%d\n", + __func__, reg, ah->ah_powerMode); + } + if (ah->ah_config.ah_serialise_reg_war) mtx_lock_spin(&ah_regser_mtx); val = bus_space_read_4(tag, h, reg); diff --git a/sys/dev/ath/ath_dfs/null/dfs_null.c b/sys/dev/ath/ath_dfs/null/dfs_null.c index 36b2042..c980a79 100644 --- a/sys/dev/ath/ath_dfs/null/dfs_null.c +++ b/sys/dev/ath/ath_dfs/null/dfs_null.c @@ -43,6 +43,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <sys/kernel.h> #include <sys/lock.h> +#include <sys/malloc.h> #include <sys/mutex.h> #include <sys/errno.h> @@ -53,6 +54,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_arp.h> #include <net/ethernet.h> /* XXX for ether_sprintf */ diff --git a/sys/dev/ath/ath_hal/ah.c b/sys/dev/ath/ath_hal/ah.c index 7187d57..4eb7fb6 100644 --- a/sys/dev/ath/ath_hal/ah.c +++ b/sys/dev/ath/ath_hal/ah.c @@ -55,7 +55,9 @@ ath_hal_probe(uint16_t vendorid, uint16_t devid) */ struct ath_hal* ath_hal_attach(uint16_t devid, HAL_SOFTC sc, - HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, HAL_STATUS *error) + HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, + HAL_STATUS *error) { struct ath_hal_chip * const *pchip; @@ -66,7 +68,8 @@ ath_hal_attach(uint16_t devid, HAL_SOFTC sc, /* XXX don't have vendorid, assume atheros one works */ if (chip->probe(ATHEROS_VENDOR_ID, devid) == AH_NULL) continue; - ah = chip->attach(devid, sc, st, sh, eepromdata, error); + ah = chip->attach(devid, sc, st, sh, eepromdata, ah_config, + error); if (ah != AH_NULL) { /* copy back private state to public area */ ah->ah_devid = AH_PRIVATE(ah)->ah_devid; @@ -786,6 +789,8 @@ ath_hal_getcapability(struct ath_hal *ah, HAL_CAPABILITY_TYPE type, return HAL_OK; case HAL_CAP_RX_LNA_MIXING: /* Hardware uses an RX LNA mixer to map 2 antennas to a 1 stream receiver */ return pCap->halRxUsingLnaMixing ? HAL_OK : HAL_ENOTSUPP; + case HAL_CAP_DO_MYBEACON: /* Hardware supports filtering my-beacons */ + return pCap->halRxDoMyBeacon ? HAL_OK : HAL_ENOTSUPP; default: return HAL_EINVAL; } @@ -848,10 +853,11 @@ ath_hal_getregdump(struct ath_hal *ah, const HAL_REGRANGE *regs, int i; for (i = 0; space >= 2*sizeof(uint32_t); i++) { - u_int r = regs[i].start; - u_int e = regs[i].end; - *dp++ = (r<<16) | e; - space -= sizeof(uint32_t); + uint32_t r = regs[i].start; + uint32_t e = regs[i].end; + *dp++ = r; + *dp++ = e; + space -= 2*sizeof(uint32_t); do { *dp++ = OS_REG_READ(ah, r); r += sizeof(uint32_t); @@ -875,6 +881,7 @@ ath_hal_getdiagstate(struct ath_hal *ah, int request, const void *args, uint32_t argsize, void **result, uint32_t *resultsize) { + switch (request) { case HAL_DIAG_REVS: *result = &AH_PRIVATE(ah)->ah_devid; @@ -932,6 +939,10 @@ ath_hal_getdiagstate(struct ath_hal *ah, int request, } else return AH_FALSE; return AH_TRUE; + case HAL_DIAG_CHANSURVEY: + *result = &AH_PRIVATE(ah)->ah_chansurvey; + *resultsize = sizeof(HAL_CHANNEL_SURVEY); + return AH_TRUE; } return AH_FALSE; } @@ -1427,3 +1438,32 @@ ath_hal_mhz2ieee_2ghz(struct ath_hal *ah, HAL_CHANNEL_INTERNAL *ichan) else return 15 + ((ichan->channel - 2512) / 20); } + +/* + * Clear the current survey data. + * + * This should be done during a channel change. + */ +void +ath_hal_survey_clear(struct ath_hal *ah) +{ + + OS_MEMZERO(&AH_PRIVATE(ah)->ah_chansurvey, + sizeof(AH_PRIVATE(ah)->ah_chansurvey)); +} + +/* + * Add a sample to the channel survey. + */ +void +ath_hal_survey_add_sample(struct ath_hal *ah, HAL_SURVEY_SAMPLE *hs) +{ + HAL_CHANNEL_SURVEY *cs; + + cs = &AH_PRIVATE(ah)->ah_chansurvey; + + OS_MEMCPY(&cs->samples[cs->cur_sample], hs, sizeof(*hs)); + cs->samples[cs->cur_sample].seq_num = cs->cur_seq; + cs->cur_sample = (cs->cur_sample + 1) % CHANNEL_SURVEY_SAMPLE_COUNT; + cs->cur_seq++; +} diff --git a/sys/dev/ath/ath_hal/ah.h b/sys/dev/ath/ath_hal/ah.h index 2480803..facfceb1 100644 --- a/sys/dev/ath/ath_hal/ah.h +++ b/sys/dev/ath/ath_hal/ah.h @@ -199,6 +199,7 @@ typedef enum { HAL_CAP_SERIALISE_WAR = 245, /* serialise register access on PCI */ HAL_CAP_ENFORCE_TXOP = 246, /* Enforce TXOP if supported */ HAL_CAP_RX_LNA_MIXING = 247, /* RX hardware uses LNA mixing */ + HAL_CAP_DO_MYBEACON = 248, /* Supports HAL_RX_FILTER_MYBEACON */ } HAL_CAPABILITY_TYPE; /* @@ -404,6 +405,7 @@ typedef enum { HAL_RX_FILTER_PROM = 0x00000020, /* Promiscuous mode */ HAL_RX_FILTER_PROBEREQ = 0x00000080, /* Allow probe request frames */ HAL_RX_FILTER_PHYERR = 0x00000100, /* Allow phy errors */ + HAL_RX_FILTER_MYBEACON = 0x00000200, /* Filter beacons other than mine */ HAL_RX_FILTER_COMPBAR = 0x00000400, /* Allow compressed BAR */ HAL_RX_FILTER_COMP_BA = 0x00000800, /* Allow compressed blockack */ HAL_RX_FILTER_PHYRADAR = 0x00002000, /* Allow phy radar errors */ @@ -538,6 +540,7 @@ typedef enum { typedef struct { u_int32_t cyclecnt_diff; /* delta cycle count */ u_int32_t rxclr_cnt; /* rx clear count */ + u_int32_t extrxclr_cnt; /* ext chan rx clear count */ u_int32_t txframecnt_diff; /* delta tx frame count */ u_int32_t rxframecnt_diff; /* delta rx frame count */ u_int32_t listen_time; /* listen time in msec - time for which ch is free */ @@ -847,6 +850,48 @@ typedef struct { #define HAL_RSSI_EP_MULTIPLIER (1<<7) /* pow2 to optimize out * and / */ +/* + * This is the ANI state and MIB stats. + * + * It's used by the HAL modules to keep state /and/ by the debug ioctl + * to fetch ANI information. + */ +typedef struct { + uint32_t ast_ani_niup; /* ANI increased noise immunity */ + uint32_t ast_ani_nidown; /* ANI decreased noise immunity */ + uint32_t ast_ani_spurup; /* ANI increased spur immunity */ + uint32_t ast_ani_spurdown;/* ANI descreased spur immunity */ + uint32_t ast_ani_ofdmon; /* ANI OFDM weak signal detect on */ + uint32_t ast_ani_ofdmoff;/* ANI OFDM weak signal detect off */ + uint32_t ast_ani_cckhigh;/* ANI CCK weak signal threshold high */ + uint32_t ast_ani_ccklow; /* ANI CCK weak signal threshold low */ + uint32_t ast_ani_stepup; /* ANI increased first step level */ + uint32_t ast_ani_stepdown;/* ANI decreased first step level */ + uint32_t ast_ani_ofdmerrs;/* ANI cumulative ofdm phy err count */ + uint32_t ast_ani_cckerrs;/* ANI cumulative cck phy err count */ + uint32_t ast_ani_reset; /* ANI parameters zero'd for non-STA */ + uint32_t ast_ani_lzero; /* ANI listen time forced to zero */ + uint32_t ast_ani_lneg; /* ANI listen time calculated < 0 */ + HAL_MIB_STATS ast_mibstats; /* MIB counter stats */ + HAL_NODE_STATS ast_nodestats; /* Latest rssi stats from driver */ +} HAL_ANI_STATS; + +typedef struct { + uint8_t noiseImmunityLevel; + uint8_t spurImmunityLevel; + uint8_t firstepLevel; + uint8_t ofdmWeakSigDetectOff; + uint8_t cckWeakSigThreshold; + uint32_t listenTime; + + /* NB: intentionally ordered so data exported to user space is first */ + uint32_t txFrameCount; /* Last txFrameCount */ + uint32_t rxFrameCount; /* Last rx Frame count */ + uint32_t cycleCount; /* Last cycleCount + (to detect wrap-around) */ + uint32_t ofdmPhyErrCount;/* OFDM err count since last reset */ + uint32_t cckPhyErrCount; /* CCK err count since last reset */ +} HAL_ANI_STATE; struct ath_desc; struct ath_tx_status; @@ -1262,6 +1307,7 @@ typedef struct int ath_hal_show_bb_panic; int ath_hal_ant_ctrl_comm2g_switch_enable; int ath_hal_ext_atten_margin_cfg; + int ath_hal_min_gainidx; int ath_hal_war70c; uint32_t ath_hal_mci_config; } HAL_OPS_CONFIG; @@ -1297,6 +1343,9 @@ struct ath_hal { uint32_t ah_intrstate[8]; /* last int state */ uint32_t ah_syncstate; /* last sync intr state */ + /* Current powerstate from HAL calls */ + HAL_POWER_MODE ah_powerMode; + HAL_OPS_CONFIG ah_config; const HAL_RATE_TABLE *__ahdecl(*ah_getRateTable)(struct ath_hal *, u_int mode); @@ -1583,6 +1632,18 @@ struct ath_hal { void __ahdecl(*ah_btCoexDisable)(struct ath_hal *); int __ahdecl(*ah_btCoexEnable)(struct ath_hal *); + /* Bluetooth MCI methods */ + void __ahdecl(*ah_btMciSetup)(struct ath_hal *, + uint32_t, void *, uint16_t, uint32_t); + HAL_BOOL __ahdecl(*ah_btMciSendMessage)(struct ath_hal *, + uint8_t, uint32_t, uint32_t *, uint8_t, + HAL_BOOL, HAL_BOOL); + uint32_t __ahdecl(*ah_btMciGetInterrupt)(struct ath_hal *, + uint32_t *, uint32_t *); + uint32_t __ahdecl(*ah_btMciGetState)(struct ath_hal *, + uint32_t, uint32_t *); + void __ahdecl(*ah_btMciDetach)(struct ath_hal *); + /* LNA diversity configuration */ void __ahdecl(*ah_divLnaConfGet)(struct ath_hal *, HAL_ANT_COMB_CONFIG *); @@ -1611,7 +1672,8 @@ extern const char *__ahdecl ath_hal_probe(uint16_t vendorid, uint16_t devid); * be returned if the status parameter is non-zero. */ extern struct ath_hal * __ahdecl ath_hal_attach(uint16_t devid, HAL_SOFTC, - HAL_BUS_TAG, HAL_BUS_HANDLE, uint16_t *eepromdata, HAL_STATUS* status); + HAL_BUS_TAG, HAL_BUS_HANDLE, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, HAL_STATUS* status); extern const char *ath_hal_mac_name(struct ath_hal *); extern const char *ath_hal_rf_name(struct ath_hal *); diff --git a/sys/dev/ath/ath_hal/ah_decode.h b/sys/dev/ath/ath_hal/ah_decode.h index 07c4ac7..3aca975 100644 --- a/sys/dev/ath/ath_hal/ah_decode.h +++ b/sys/dev/ath/ath_hal/ah_decode.h @@ -53,6 +53,8 @@ enum { AH_MARK_ANI_POLL, /* ar*AniReset, listen time */ AH_MARK_ANI_CONTROL, /* ar*AniReset, cmd */ AH_MARK_RX_CTL, /* RX DMA control */ + AH_MARK_CHIP_POWER, /* chip power control, mode */ + AH_MARK_CHIP_POWER_DONE, /* chip power control done, status */ }; enum { @@ -61,6 +63,7 @@ enum { AH_MARK_RX_CTL_DMA_START, AH_MARK_RX_CTL_DMA_STOP, AH_MARK_RX_CTL_DMA_STOP_ERR, + AH_MARK_RX_CTL_DMA_STOP_OK, }; #endif /* _ATH_AH_DECODE_H_ */ diff --git a/sys/dev/ath/ath_hal/ah_devid.h b/sys/dev/ath/ath_hal/ah_devid.h index 43d994d..1e4d473 100644 --- a/sys/dev/ath/ath_hal/ah_devid.h +++ b/sys/dev/ath/ath_hal/ah_devid.h @@ -92,6 +92,7 @@ #define AR9300_DEVID_AR946X_PCIE 0x0034 #define AR9300_DEVID_AR9330 0x0035 #define AR9300_DEVID_QCA9565 0x0036 +#define AR9300_DEVID_AR1111_PCIE 0x0037 #define AR9300_DEVID_QCA955X 0x0039 #define AR_SUBVENDOR_ID_NOG 0x0e11 /* No 11G subvendor ID */ diff --git a/sys/dev/ath/ath_hal/ah_internal.h b/sys/dev/ath/ath_hal/ah_internal.h index 908f33e..0c855d4 100644 --- a/sys/dev/ath/ath_hal/ah_internal.h +++ b/sys/dev/ath/ath_hal/ah_internal.h @@ -50,8 +50,8 @@ #endif typedef struct { - uint16_t start; /* first register */ - uint16_t end; /* ending register or zero */ + uint32_t start; /* first register */ + uint32_t end; /* ending register or zero */ } HAL_REGRANGE; typedef struct { @@ -91,6 +91,7 @@ struct ath_hal_chip { const char *(*probe)(uint16_t vendorid, uint16_t devid); struct ath_hal *(*attach)(uint16_t devid, HAL_SOFTC, HAL_BUS_TAG, HAL_BUS_HANDLE, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah, HAL_STATUS *error); }; #ifndef AH_CHIP @@ -280,7 +281,9 @@ typedef struct { halAntDivCombSupportOrg : 1, halRadioRetentionSupport : 1, halSpectralScanSupport : 1, - halRxUsingLnaMixing : 1; + halRxUsingLnaMixing : 1, + halRxDoMyBeacon : 1, + halHwUapsdTrig : 1; uint32_t halWirelessModes; uint16_t halTotalQueues; @@ -419,9 +422,13 @@ struct ath_hal_private { uint32_t ah_fatalState[6]; /* AR_ISR+shadow regs */ int ah_rxornIsFatal; /* how to treat HAL_INT_RXORN */ -#ifndef ATH_NF_PER_CHAN + /* Only used if ATH_NF_PER_CHAN is defined */ HAL_NFCAL_HIST_FULL nf_cal_hist; -#endif /* ! ATH_NF_PER_CHAN */ + + /* + * Channel survey history - current channel only. + */ + HAL_CHANNEL_SURVEY ah_chansurvey; /* channel survey */ }; #define AH_PRIVATE(_ah) ((struct ath_hal_private *)(_ah)) @@ -1026,4 +1033,15 @@ ath_hal_getantennaallowed(struct ath_hal *ah, */ extern int ath_hal_mhz2ieee_2ghz(struct ath_hal *, HAL_CHANNEL_INTERNAL *); +/* + * Clear the channel survey data. + */ +extern void ath_hal_survey_clear(struct ath_hal *ah); + +/* + * Add a sample to the channel survey data. + */ +extern void ath_hal_survey_add_sample(struct ath_hal *ah, + HAL_SURVEY_SAMPLE *hs); + #endif /* _ATH_AH_INTERAL_H_ */ diff --git a/sys/dev/ath/ath_hal/ah_regdomain.c b/sys/dev/ath/ath_hal/ah_regdomain.c index 807db44..fb0c841 100644 --- a/sys/dev/ath/ath_hal/ah_regdomain.c +++ b/sys/dev/ath/ath_hal/ah_regdomain.c @@ -169,6 +169,11 @@ isEepromValid(struct ath_hal *ah) if (regDomainPairs[i].regDmnEnum == rd) return AH_TRUE; } + + if (rd == FCC_UBNT) { + return AH_TRUE; + } + HALDEBUG(ah, HAL_DEBUG_REGDOMAIN, "%s: invalid regulatory domain/country code 0x%x\n", __func__, rd); return AH_FALSE; diff --git a/sys/dev/ath/ath_hal/ah_regdomain/ah_rd_regenum.h b/sys/dev/ath/ath_hal/ah_regdomain/ah_rd_regenum.h index bc569cb..d8d211e 100644 --- a/sys/dev/ath/ath_hal/ah_regdomain/ah_rd_regenum.h +++ b/sys/dev/ath/ath_hal/ah_regdomain/ah_rd_regenum.h @@ -51,6 +51,7 @@ enum { FCC2_FCCA = 0x20, /* Canada */ FCC2_WORLD = 0x21, /* Australia & HK */ FCC2_ETSIC = 0x22, + FCC_UBNT = 0x2A, /* Ubiquity PicoStation M2HP */ FRANCE_RES = 0x31, /* Legacy France for OEM */ FCC3_FCCA = 0x3A, /* USA & Canada w/5470 band, 11h, DFS enabled */ FCC3_WORLD = 0x3B, /* USA & Canada w/5470 band, 11h, DFS enabled */ diff --git a/sys/dev/ath/ath_hal/ar5210/ar5210.h b/sys/dev/ath/ath_hal/ar5210/ar5210.h index 48ccc20..3e372f7 100644 --- a/sys/dev/ath/ath_hal/ar5210/ar5210.h +++ b/sys/dev/ath/ath_hal/ar5210/ar5210.h @@ -108,7 +108,6 @@ struct ath_hal_5210 { uint32_t ah_txDescInterruptMask; uint32_t ah_txEolInterruptMask; uint32_t ah_txUrnInterruptMask; - HAL_POWER_MODE ah_powerMode; uint8_t ah_bssid[IEEE80211_ADDR_LEN]; HAL_TX_QUEUE_INFO ah_txq[HAL_NUM_TX_QUEUES]; /* beacon+cab+data */ /* @@ -121,6 +120,8 @@ struct ath_hal_5210 { u_int ah_slottime; /* user-specified slot time */ u_int ah_acktimeout; /* user-specified ack timeout */ u_int ah_ctstimeout; /* user-specified cts timeout */ + + uint16_t ah_associd; /* association id */ }; #define AH5210(ah) ((struct ath_hal_5210 *)(ah)) diff --git a/sys/dev/ath/ath_hal/ar5210/ar5210_attach.c b/sys/dev/ath/ath_hal/ar5210/ar5210_attach.c index 3c0ed71..ceafa99 100644 --- a/sys/dev/ath/ath_hal/ar5210/ar5210_attach.c +++ b/sys/dev/ath/ath_hal/ar5210/ar5210_attach.c @@ -183,7 +183,7 @@ static HAL_BOOL ar5210FillCapabilityInfo(struct ath_hal *ah); */ static struct ath_hal * ar5210Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, - uint16_t *eepromdata, HAL_STATUS *status) + uint16_t *eepromdata, HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { #define N(a) (sizeof(a)/sizeof(a[0])) struct ath_hal_5210 *ahp; @@ -219,7 +219,7 @@ ar5210Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, AH_PRIVATE(ah)->ah_powerLimit = AR5210_MAX_RATE_POWER; AH_PRIVATE(ah)->ah_tpScale = HAL_TP_SCALE_MAX; /* no scaling */ - ahp->ah_powerMode = HAL_PM_UNDEFINED; + ah->ah_powerMode = HAL_PM_UNDEFINED; ahp->ah_staId1Defaults = 0; ahp->ah_rssiThr = INIT_RSSI_THR; ahp->ah_sifstime = (u_int) -1; diff --git a/sys/dev/ath/ath_hal/ar5210/ar5210_misc.c b/sys/dev/ath/ath_hal/ar5210/ar5210_misc.c index 8170880..5eaa18e 100644 --- a/sys/dev/ath/ath_hal/ar5210/ar5210_misc.c +++ b/sys/dev/ath/ath_hal/ar5210/ar5210_misc.c @@ -315,6 +315,7 @@ ar5210WriteAssocid(struct ath_hal *ah, const uint8_t *bssid, uint16_t assocId) /* XXX save bssid for possible re-use on reset */ OS_MEMCPY(ahp->ah_bssid, bssid, IEEE80211_ADDR_LEN); + ahp->ah_associd = assocId; OS_REG_WRITE(ah, AR_BSS_ID0, LE_READ_4(ahp->ah_bssid)); OS_REG_WRITE(ah, AR_BSS_ID1, LE_READ_2(ahp->ah_bssid+4) | ((assocId & 0x3fff)<<AR_BSS_ID1_AID_S)); diff --git a/sys/dev/ath/ath_hal/ar5210/ar5210_power.c b/sys/dev/ath/ath_hal/ar5210/ar5210_power.c index 1c6909b..ec5e75d 100644 --- a/sys/dev/ath/ath_hal/ar5210/ar5210_power.c +++ b/sys/dev/ath/ath_hal/ar5210/ar5210_power.c @@ -93,7 +93,6 @@ ar5210SetPowerModeSleep(struct ath_hal *ah, int setChip) HAL_BOOL ar5210SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) { - struct ath_hal_5210 *ahp = AH5210(ah); #ifdef AH_DEBUG static const char* modes[] = { "AWAKE", @@ -105,25 +104,30 @@ ar5210SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) int status = AH_TRUE; HALDEBUG(ah, HAL_DEBUG_POWER, "%s: %s -> %s (%s)\n", __func__, - modes[ahp->ah_powerMode], modes[mode], + modes[ah->ah_powerMode], modes[mode], setChip ? "set chip " : ""); switch (mode) { case HAL_PM_AWAKE: + if (setChip) + ah->ah_powerMode = mode; status = ar5210SetPowerModeAwake(ah, setChip); break; case HAL_PM_FULL_SLEEP: ar5210SetPowerModeSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; case HAL_PM_NETWORK_SLEEP: ar5210SetPowerModeAuto(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; default: HALDEBUG(ah, HAL_DEBUG_ANY, "%s: unknown power mode %u\n", __func__, mode); return AH_FALSE; } - ahp->ah_powerMode = mode; - return status; + return status; } HAL_POWER_MODE diff --git a/sys/dev/ath/ath_hal/ar5210/ar5210_reset.c b/sys/dev/ath/ath_hal/ar5210/ar5210_reset.c index 1d50f99..1dba729 100644 --- a/sys/dev/ath/ath_hal/ar5210/ar5210_reset.c +++ b/sys/dev/ath/ath_hal/ar5210/ar5210_reset.c @@ -152,8 +152,12 @@ ar5210Reset(struct ath_hal *ah, HAL_OPMODE opmode, /* Restore previous led state */ OS_REG_WRITE(ah, AR_PCICFG, OS_REG_READ(ah, AR_PCICFG) | ledstate); +#if 0 OS_REG_WRITE(ah, AR_BSS_ID0, LE_READ_4(ahp->ah_bssid)); OS_REG_WRITE(ah, AR_BSS_ID1, LE_READ_2(ahp->ah_bssid + 4)); +#endif + /* BSSID, association id, ps-poll */ + ar5210WriteAssocid(ah, ahp->ah_bssid, ahp->ah_associd); OS_REG_WRITE(ah, AR_TXDP0, 0); OS_REG_WRITE(ah, AR_TXDP1, 0); diff --git a/sys/dev/ath/ath_hal/ar5211/ar5211.h b/sys/dev/ath/ath_hal/ar5211/ar5211.h index c50531e..6f04624 100644 --- a/sys/dev/ath/ath_hal/ar5211/ar5211.h +++ b/sys/dev/ath/ath_hal/ar5211/ar5211.h @@ -119,7 +119,6 @@ struct ath_hal_5211 { uint32_t ah_txEolInterruptMask; uint32_t ah_txUrnInterruptMask; HAL_TX_QUEUE_INFO ah_txq[HAL_NUM_TX_QUEUES]; - HAL_POWER_MODE ah_powerMode; HAL_ANT_SETTING ah_diversityControl; /* antenna setting */ uint32_t ah_calibrationTime; HAL_BOOL ah_bIQCalibration; diff --git a/sys/dev/ath/ath_hal/ar5211/ar5211_attach.c b/sys/dev/ath/ath_hal/ar5211/ar5211_attach.c index 4549295..3416dc0 100644 --- a/sys/dev/ath/ath_hal/ar5211/ar5211_attach.c +++ b/sys/dev/ath/ath_hal/ar5211/ar5211_attach.c @@ -203,7 +203,7 @@ ar5211GetRadioRev(struct ath_hal *ah) static struct ath_hal * ar5211Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, - HAL_STATUS *status) + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { #define N(a) (sizeof(a)/sizeof(a[0])) struct ath_hal_5211 *ahp; diff --git a/sys/dev/ath/ath_hal/ar5211/ar5211_power.c b/sys/dev/ath/ath_hal/ar5211/ar5211_power.c index 776cfb3..e646d90 100644 --- a/sys/dev/ath/ath_hal/ar5211/ar5211_power.c +++ b/sys/dev/ath/ath_hal/ar5211/ar5211_power.c @@ -95,7 +95,6 @@ ar5211SetPowerModeNetworkSleep(struct ath_hal *ah, int setChip) HAL_BOOL ar5211SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) { - struct ath_hal_5211 *ahp = AH5211(ah); #ifdef AH_DEBUG static const char* modes[] = { "AWAKE", @@ -107,25 +106,30 @@ ar5211SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) int status = AH_TRUE; HALDEBUG(ah, HAL_DEBUG_POWER, "%s: %s -> %s (%s)\n", __func__, - modes[ahp->ah_powerMode], modes[mode], + modes[ah->ah_powerMode], modes[mode], setChip ? "set chip " : ""); switch (mode) { case HAL_PM_AWAKE: + if (setChip) + ah->ah_powerMode = mode; status = ar5211SetPowerModeAwake(ah, setChip); break; case HAL_PM_FULL_SLEEP: ar5211SetPowerModeSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; case HAL_PM_NETWORK_SLEEP: ar5211SetPowerModeNetworkSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; default: HALDEBUG(ah, HAL_DEBUG_ANY, "%s: unknown power mode %u\n", __func__, mode); return AH_FALSE; } - ahp->ah_powerMode = mode; - return status; + return status; } HAL_POWER_MODE diff --git a/sys/dev/ath/ath_hal/ar5212/ar5212.h b/sys/dev/ath/ath_hal/ar5212/ar5212.h index 6d38d65..938a68c 100644 --- a/sys/dev/ath/ath_hal/ar5212/ar5212.h +++ b/sys/dev/ath/ath_hal/ar5212/ar5212.h @@ -200,6 +200,7 @@ struct ar5212AniState { #define HAL_ANI_ENA 0x00000001 /* ANI operation enabled */ #define HAL_RSSI_ANI_ENA 0x00000002 /* rssi-based processing ena'd*/ +#if 0 struct ar5212Stats { uint32_t ast_ani_niup; /* ANI increased noise immunity */ uint32_t ast_ani_nidown; /* ANI decreased noise immunity */ @@ -219,6 +220,7 @@ struct ar5212Stats { HAL_MIB_STATS ast_mibstats; /* MIB counter stats */ HAL_NODE_STATS ast_nodestats; /* Latest rssi stats from driver */ }; +#endif /* * NF Cal history buffer @@ -258,7 +260,7 @@ struct ath_hal_5212 { * Runtime state. */ uint32_t ah_maskReg; /* copy of AR_IMR */ - struct ar5212Stats ah_stats; /* various statistics */ + HAL_ANI_STATS ah_stats; /* various statistics */ RF_HAL_FUNCS *ah_rfHal; uint32_t ah_txDescMask; /* mask for TXDESC */ uint32_t ah_txOkInterruptMask; @@ -270,7 +272,6 @@ struct ath_hal_5212 { uint32_t ah_intrTxqs; /* tx q interrupt state */ /* decomp mask array */ uint8_t ah_decompMask[HAL_DECOMP_MASK_SIZE]; - HAL_POWER_MODE ah_powerMode; HAL_ANT_SETTING ah_antControl; /* antenna setting */ HAL_BOOL ah_diversity; /* fast diversity setting */ enum { @@ -320,7 +321,6 @@ struct ath_hal_5212 { struct ar5212AniParams ah_aniParams5; /* 5GHz parameters */ struct ar5212AniState *ah_curani; /* cached last reference */ struct ar5212AniState ah_ani[AH_MAXCHAN]; /* per-channel state */ - HAL_CHANNEL_SURVEY ah_chansurvey; /* channel survey */ /* AR5416 uses some of the AR5212 ANI code; these are the ANI methods */ HAL_BOOL (*ah_aniControl) (struct ath_hal *, HAL_ANI_CMD cmd, int param); @@ -345,6 +345,9 @@ struct ath_hal_5212 { uint32_t ah_txBusy; uint32_t ah_rx_chainmask; uint32_t ah_tx_chainmask; + + /* Used to return ANI statistics to the diagnostic API */ + HAL_ANI_STATS ext_ani_stats; }; #define AH5212(_ah) ((struct ath_hal_5212 *)(_ah)) @@ -627,7 +630,7 @@ extern void ar5212AniAttach(struct ath_hal *, const struct ar5212AniParams *, const struct ar5212AniParams *, HAL_BOOL ena); extern void ar5212AniDetach(struct ath_hal *); extern struct ar5212AniState *ar5212AniGetCurrentState(struct ath_hal *); -extern struct ar5212Stats *ar5212AniGetCurrentStats(struct ath_hal *); +extern HAL_ANI_STATS *ar5212AniGetCurrentStats(struct ath_hal *); extern HAL_BOOL ar5212AniControl(struct ath_hal *, HAL_ANI_CMD cmd, int param); extern HAL_BOOL ar5212AniSetParams(struct ath_hal *, const struct ar5212AniParams *, const struct ar5212AniParams *); diff --git a/sys/dev/ath/ath_hal/ar5212/ar5212_ani.c b/sys/dev/ath/ath_hal/ar5212/ar5212_ani.c index 8e87a2f..c7b5932 100644 --- a/sys/dev/ath/ath_hal/ar5212/ar5212_ani.c +++ b/sys/dev/ath/ath_hal/ar5212/ar5212_ani.c @@ -110,7 +110,7 @@ ar5212AniGetCurrentState(struct ath_hal *ah) /* * Return the current statistics. */ -struct ar5212Stats * +HAL_ANI_STATS * ar5212AniGetCurrentStats(struct ath_hal *ah) { struct ath_hal_5212 *ahp = AH5212(ah); @@ -869,7 +869,6 @@ ar5212AniGetListenTime(struct ath_hal *ah) int32_t listenTime = 0; int good; HAL_SURVEY_SAMPLE hs; - HAL_CHANNEL_SURVEY *cs = AH_NULL; /* * We shouldn't see ah_curchan be NULL, but just in case.. @@ -879,21 +878,13 @@ ar5212AniGetListenTime(struct ath_hal *ah) return (0); } - cs = &ahp->ah_chansurvey; - /* * Fetch the current statistics, squirrel away the current * sample, bump the sequence/sample counter. */ OS_MEMZERO(&hs, sizeof(hs)); good = ar5212GetMibCycleCounts(ah, &hs); - if (cs != AH_NULL) { - OS_MEMCPY(&cs->samples[cs->cur_sample], &hs, sizeof(hs)); - cs->samples[cs->cur_sample].seq_num = cs->cur_seq; - cs->cur_sample = - (cs->cur_sample + 1) % CHANNEL_SURVEY_SAMPLE_COUNT; - cs->cur_seq++; - } + ath_hal_survey_add_sample(ah, &hs); if (ANI_ENA(ah)) aniState = ahp->ah_curani; diff --git a/sys/dev/ath/ath_hal/ar5212/ar5212_attach.c b/sys/dev/ath/ath_hal/ar5212/ar5212_attach.c index e0af27c..a95f244 100644 --- a/sys/dev/ath/ath_hal/ar5212/ar5212_attach.c +++ b/sys/dev/ath/ath_hal/ar5212/ar5212_attach.c @@ -317,7 +317,7 @@ ar5212IsMacSupported(uint8_t macVersion, uint8_t macRev) static struct ath_hal * ar5212Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, - HAL_STATUS *status) + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { #define AH_EEPROM_PROTECT(ah) \ (AH_PRIVATE(ah)->ah_ispcie)? AR_EEPROM_PROTECT_PCIE : AR_EEPROM_PROTECT) diff --git a/sys/dev/ath/ath_hal/ar5212/ar5212_misc.c b/sys/dev/ath/ath_hal/ar5212/ar5212_misc.c index 71ee845..e2f1eb7 100644 --- a/sys/dev/ath/ath_hal/ar5212/ar5212_misc.c +++ b/sys/dev/ath/ath_hal/ar5212/ar5212_misc.c @@ -1052,6 +1052,7 @@ ar5212GetDiagState(struct ath_hal *ah, int request, void **result, uint32_t *resultsize) { struct ath_hal_5212 *ahp = AH5212(ah); + HAL_ANI_STATS *astats; (void) ahp; if (ath_hal_getdiagstate(ah, request, args, argsize, result, resultsize)) @@ -1083,9 +1084,16 @@ ar5212GetDiagState(struct ath_hal *ah, int request, 0 : sizeof(struct ar5212AniState); return AH_TRUE; case HAL_DIAG_ANI_STATS: - *result = ar5212AniGetCurrentStats(ah); - *resultsize = (*result == AH_NULL) ? - 0 : sizeof(struct ar5212Stats); + OS_MEMZERO(&ahp->ext_ani_stats, sizeof(ahp->ext_ani_stats)); + astats = ar5212AniGetCurrentStats(ah); + if (astats == NULL) { + *result = NULL; + *resultsize = 0; + } else { + OS_MEMCPY(&ahp->ext_ani_stats, astats, sizeof(HAL_ANI_STATS)); + *result = &ahp->ext_ani_stats; + *resultsize = sizeof(ahp->ext_ani_stats); + } return AH_TRUE; case HAL_DIAG_ANI_CMD: if (argsize != 2*sizeof(uint32_t)) @@ -1113,10 +1121,6 @@ ar5212GetDiagState(struct ath_hal *ah, int request, return ar5212AniSetParams(ah, args, args); } break; - case HAL_DIAG_CHANSURVEY: - *result = &ahp->ah_chansurvey; - *resultsize = sizeof(HAL_CHANNEL_SURVEY); - return AH_TRUE; } return AH_FALSE; } diff --git a/sys/dev/ath/ath_hal/ar5212/ar5212_power.c b/sys/dev/ath/ath_hal/ar5212/ar5212_power.c index 3f755bd..3068510 100644 --- a/sys/dev/ath/ath_hal/ar5212/ar5212_power.c +++ b/sys/dev/ath/ath_hal/ar5212/ar5212_power.c @@ -119,7 +119,6 @@ ar5212SetPowerModeNetworkSleep(struct ath_hal *ah, int setChip) HAL_BOOL ar5212SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) { - struct ath_hal_5212 *ahp = AH5212(ah); #ifdef AH_DEBUG static const char* modes[] = { "AWAKE", @@ -131,24 +130,29 @@ ar5212SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) int status = AH_TRUE; HALDEBUG(ah, HAL_DEBUG_POWER, "%s: %s -> %s (%s)\n", __func__, - modes[ahp->ah_powerMode], modes[mode], + modes[ah->ah_powerMode], modes[mode], setChip ? "set chip " : ""); switch (mode) { case HAL_PM_AWAKE: + if (setChip) + ah->ah_powerMode = mode; status = ar5212SetPowerModeAwake(ah, setChip); break; case HAL_PM_FULL_SLEEP: ar5212SetPowerModeSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; case HAL_PM_NETWORK_SLEEP: ar5212SetPowerModeNetworkSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; default: HALDEBUG(ah, HAL_DEBUG_ANY, "%s: unknown power mode %u\n", __func__, mode); return AH_FALSE; } - ahp->ah_powerMode = mode; return status; } diff --git a/sys/dev/ath/ath_hal/ar5212/ar5212_reset.c b/sys/dev/ath/ath_hal/ar5212/ar5212_reset.c index ccdccb6..fd3b473 100644 --- a/sys/dev/ath/ath_hal/ar5212/ar5212_reset.c +++ b/sys/dev/ath/ath_hal/ar5212/ar5212_reset.c @@ -197,7 +197,8 @@ ar5212Reset(struct ath_hal *ah, HAL_OPMODE opmode, saveFrameSeqCount = 0; /* NB: silence compiler */ /* Blank the channel survey statistics */ - OS_MEMZERO(&ahp->ah_chansurvey, sizeof(ahp->ah_chansurvey)); + ath_hal_survey_clear(ah); + #if 0 /* * XXX disable for now; this appears to sometimes cause OFDM diff --git a/sys/dev/ath/ath_hal/ar5312/ar5312_attach.c b/sys/dev/ath/ath_hal/ar5312/ar5312_attach.c index 4ca1a4d..5c84eb8 100644 --- a/sys/dev/ath/ath_hal/ar5312/ar5312_attach.c +++ b/sys/dev/ath/ath_hal/ar5312/ar5312_attach.c @@ -62,7 +62,7 @@ ar5312AniSetup(struct ath_hal *ah) static struct ath_hal * ar5312Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, - HAL_STATUS *status) + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { struct ath_hal_5212 *ahp = AH_NULL; struct ath_hal *ah; diff --git a/sys/dev/ath/ath_hal/ar5312/ar5312_power.c b/sys/dev/ath/ath_hal/ar5312/ar5312_power.c index 94a0f1c..7db6d80 100644 --- a/sys/dev/ath/ath_hal/ar5312/ar5312_power.c +++ b/sys/dev/ath/ath_hal/ar5312/ar5312_power.c @@ -71,7 +71,6 @@ ar5312SetPowerModeNetworkSleep(struct ath_hal *ah, int setChip) HAL_BOOL ar5312SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) { - struct ath_hal_5212 *ahp = AH5212(ah); #ifdef AH_DEBUG static const char* modes[] = { "AWAKE", @@ -83,7 +82,7 @@ ar5312SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) int status = AH_TRUE; HALDEBUG(ah, HAL_DEBUG_POWER, "%s: %s -> %s (%s)\n", __func__, - modes[ahp->ah_powerMode], modes[mode], + modes[ah->ah_powerMode], modes[mode], setChip ? "set chip " : ""); switch (mode) { case HAL_PM_AWAKE: @@ -100,7 +99,7 @@ ar5312SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) __func__, mode); return AH_FALSE; } - ahp->ah_powerMode = mode; + ah->ah_powerMode = mode; return status; } diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_ani.c b/sys/dev/ath/ath_hal/ar5416/ar5416_ani.c index 3f9bc69..fadd5ad 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_ani.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_ani.c @@ -818,7 +818,6 @@ ar5416AniGetListenTime(struct ath_hal *ah) int32_t listenTime = 0; int good; HAL_SURVEY_SAMPLE hs; - HAL_CHANNEL_SURVEY *cs = AH_NULL; /* * We shouldn't see ah_curchan be NULL, but just in case.. @@ -828,21 +827,13 @@ ar5416AniGetListenTime(struct ath_hal *ah) return (0); } - cs = &ahp->ah_chansurvey; - /* * Fetch the current statistics, squirrel away the current - * sample, bump the sequence/sample counter. + * sample. */ OS_MEMZERO(&hs, sizeof(hs)); good = ar5416GetMibCycleCounts(ah, &hs); - if (cs != AH_NULL) { - OS_MEMCPY(&cs->samples[cs->cur_sample], &hs, sizeof(hs)); - cs->samples[cs->cur_sample].seq_num = cs->cur_seq; - cs->cur_sample = - (cs->cur_sample + 1) % CHANNEL_SURVEY_SAMPLE_COUNT; - cs->cur_seq++; - } + ath_hal_survey_add_sample(ah, &hs); if (ANI_ENA(ah)) aniState = ahp->ah_curani; diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_attach.c b/sys/dev/ath/ath_hal/ar5416/ar5416_attach.c index 99bab06..a20499a 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_attach.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_attach.c @@ -297,7 +297,7 @@ ar5416GetRadioRev(struct ath_hal *ah) static struct ath_hal * ar5416Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, - HAL_STATUS *status) + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { struct ath_hal_5416 *ahp5416; struct ath_hal_5212 *ahp; @@ -1059,6 +1059,11 @@ ar5416FillCapabilityInfo(struct ath_hal *ah) if (! AH_PRIVATE(ah)->ah_ispcie) pCap->halSerialiseRegWar = 1; + /* + * AR5416 and later NICs support MYBEACON filtering. + */ + pCap->halRxDoMyBeacon = AH_TRUE; + return AH_TRUE; } diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_beacon.c b/sys/dev/ath/ath_hal/ar5416/ar5416_beacon.c index e2bf6c7..6691c11 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_beacon.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_beacon.c @@ -197,6 +197,25 @@ ar5416SetStaBeaconTimers(struct ath_hal *ah, const HAL_BEACON_STATE *bs) * beacon jitter; cab timeout is max time to wait for cab * after seeing the last DTIM or MORE CAB bit */ + +/* + * I've bumped these to 30TU for now. + * + * Some APs (AR933x/AR934x?) in 2GHz especially seem to not always + * transmit beacon frames at exactly the right times and with it set + * to 10TU, the NIC starts not waking up at the right times to hear + * these slightly-larger-jitering beacons. It also never recovers + * from that (it doesn't resync? I'm not sure.) + * + * So for now bump this to 30TU. Ideally we'd cap this based on + * the beacon interval so the sum of CAB+BEACON timeouts never + * exceeded the beacon interval. + * + * Now, since we're doing all the math in the ath(4) driver in TU + * rather than TSF, we may be seeing the result of dumb rounding + * errors causing the jitter to actually be a much bigger problem. + * I'll have to investigate that with a fine tooth comb. + */ #define CAB_TIMEOUT_VAL 10 /* in TU */ #define BEACON_TIMEOUT_VAL 10 /* in TU */ #define SLEEP_SLOP 3 /* in TU */ @@ -248,6 +267,13 @@ ar5416SetStaBeaconTimers(struct ath_hal *ah, const HAL_BEACON_STATE *bs) OS_REG_SET_BIT(ah, AR_TIMER_MODE, AR_TIMER_MODE_TBTT | AR_TIMER_MODE_TIM | AR_TIMER_MODE_DTIM); + +#define HAL_TSFOOR_THRESHOLD 0x00004240 /* TSF OOR threshold (16k us) */ + + /* TSF out of range threshold */ +// OS_REG_WRITE(ah, AR_TSFOOR_THRESHOLD, bs->bs_tsfoor_threshold); + OS_REG_WRITE(ah, AR_TSFOOR_THRESHOLD, HAL_TSFOOR_THRESHOLD); + HALDEBUG(ah, HAL_DEBUG_BEACON, "%s: next DTIM %d\n", __func__, bs->bs_nextdtim); HALDEBUG(ah, HAL_DEBUG_BEACON, "%s: next beacon %d\n", diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_cal.c b/sys/dev/ath/ath_hal/ar5416/ar5416_cal.c index d51417f4..35bb8d4 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_cal.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_cal.c @@ -663,7 +663,7 @@ ar5416LoadNF(struct ath_hal *ah, const struct ieee80211_channel *chan) * by the median we just loaded. This will be initial (and max) value * of next noise floor calibration the baseband does. */ - for (i = 0; i < AR5416_NUM_NF_READINGS; i ++) + for (i = 0; i < AR5416_NUM_NF_READINGS; i ++) { /* Don't write to EXT radio CCA registers unless in HT/40 mode */ /* XXX this check should really be cleaner! */ @@ -676,6 +676,7 @@ ar5416LoadNF(struct ath_hal *ah, const struct ieee80211_channel *chan) val |= (((uint32_t)(-50) << 1) & 0x1ff); OS_REG_WRITE(ah, ar5416_cca_regs[i], val); } + } } /* diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_interrupts.c b/sys/dev/ath/ath_hal/ar5416/ar5416_interrupts.c index 631ca2f..32ce2ed 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_interrupts.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_interrupts.c @@ -337,6 +337,9 @@ ar5416SetInterrupts(struct ath_hal *ah, HAL_INT ints) /* Write the new IMR and store off our SW copy. */ HALDEBUG(ah, HAL_DEBUG_INTERRUPT, "%s: new IMR 0x%x\n", __func__, mask); OS_REG_WRITE(ah, AR_IMR, mask); + /* Flush write */ + (void) OS_REG_READ(ah, AR_IMR); + mask = OS_REG_READ(ah, AR_IMR_S2) & ~(AR_IMR_S2_TIM | AR_IMR_S2_DTIM | AR_IMR_S2_DTIMSYNC | diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_power.c b/sys/dev/ath/ath_hal/ar5416/ar5416_power.c index 43a9241..dff9a85 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_power.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_power.c @@ -124,7 +124,6 @@ ar5416SetPowerModeNetworkSleep(struct ath_hal *ah, int setChip) HAL_BOOL ar5416SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) { - struct ath_hal_5212 *ahp = AH5212(ah); #ifdef AH_DEBUG static const char* modes[] = { "AWAKE", @@ -134,27 +133,35 @@ ar5416SetPowerMode(struct ath_hal *ah, HAL_POWER_MODE mode, int setChip) }; #endif int status = AH_TRUE; + +#if 0 if (!setChip) return AH_TRUE; +#endif HALDEBUG(ah, HAL_DEBUG_POWER, "%s: %s -> %s (%s)\n", __func__, - modes[ahp->ah_powerMode], modes[mode], setChip ? "set chip " : ""); + modes[ah->ah_powerMode], modes[mode], setChip ? "set chip " : ""); switch (mode) { case HAL_PM_AWAKE: + if (setChip) + ah->ah_powerMode = mode; status = ar5416SetPowerModeAwake(ah, setChip); break; case HAL_PM_FULL_SLEEP: ar5416SetPowerModeSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; case HAL_PM_NETWORK_SLEEP: ar5416SetPowerModeNetworkSleep(ah, setChip); + if (setChip) + ah->ah_powerMode = mode; break; default: HALDEBUG(ah, HAL_DEBUG_ANY, "%s: unknown power mode 0x%x\n", __func__, mode); return AH_FALSE; } - ahp->ah_powerMode = mode; return status; } diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416_reset.c b/sys/dev/ath/ath_hal/ar5416/ar5416_reset.c index eb31f08..baf0ccc 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416_reset.c +++ b/sys/dev/ath/ath_hal/ar5416/ar5416_reset.c @@ -120,9 +120,10 @@ ar5416Reset(struct ath_hal *ah, HAL_OPMODE opmode, HALASSERT(AH_PRIVATE(ah)->ah_eeversion >= AR_EEPROM_VER14_1); /* Blank the channel survey statistics */ - OS_MEMZERO(&ahp->ah_chansurvey, sizeof(ahp->ah_chansurvey)); + ath_hal_survey_clear(ah); /* XXX Turn on fast channel change for 5416 */ + /* * Preserve the bmiss rssi threshold and count threshold * across resets diff --git a/sys/dev/ath/ath_hal/ar5416/ar5416reg.h b/sys/dev/ath/ath_hal/ar5416/ar5416reg.h index 435599c..0ee1e70 100644 --- a/sys/dev/ath/ath_hal/ar5416/ar5416reg.h +++ b/sys/dev/ath/ath_hal/ar5416/ar5416reg.h @@ -476,10 +476,10 @@ /* Sleep control */ #define AR5416_SLEEP1_ASSUME_DTIM 0x00080000 #define AR5416_SLEEP1_CAB_TIMEOUT 0xFFE00000 /* Cab timeout (TU) */ -#define AR5416_SLEEP1_CAB_TIMEOUT_S 22 +#define AR5416_SLEEP1_CAB_TIMEOUT_S 21 #define AR5416_SLEEP2_BEACON_TIMEOUT 0xFFE00000 /* Beacon timeout (TU)*/ -#define AR5416_SLEEP2_BEACON_TIMEOUT_S 22 +#define AR5416_SLEEP2_BEACON_TIMEOUT_S 21 /* Sleep Registers */ #define AR_SLP32_HALFCLK_LATENCY 0x000FFFFF /* rising <-> falling edge */ diff --git a/sys/dev/ath/ath_hal/ar9001/ar9130_attach.c b/sys/dev/ath/ath_hal/ar9001/ar9130_attach.c index 4f478c0..c270bab 100644 --- a/sys/dev/ath/ath_hal/ar9001/ar9130_attach.c +++ b/sys/dev/ath/ath_hal/ar9001/ar9130_attach.c @@ -69,7 +69,9 @@ static HAL_BOOL ar9130FillCapabilityInfo(struct ath_hal *ah); */ static struct ath_hal * ar9130Attach(uint16_t devid, HAL_SOFTC sc, - HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, HAL_STATUS *status) + HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, + HAL_STATUS *status) { struct ath_hal_5416 *ahp5416; struct ath_hal_5212 *ahp; diff --git a/sys/dev/ath/ath_hal/ar9001/ar9160_attach.c b/sys/dev/ath/ath_hal/ar9001/ar9160_attach.c index 979ba1a..5bda519 100644 --- a/sys/dev/ath/ath_hal/ar9001/ar9160_attach.c +++ b/sys/dev/ath/ath_hal/ar9001/ar9160_attach.c @@ -114,6 +114,7 @@ ar9160InitPLL(struct ath_hal *ah, const struct ieee80211_channel *chan) static struct ath_hal * ar9160Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { struct ath_hal_5416 *ahp5416; diff --git a/sys/dev/ath/ath_hal/ar9002/ar9280_attach.c b/sys/dev/ath/ath_hal/ar9002/ar9280_attach.c index 2a67fe5..3be3e35 100644 --- a/sys/dev/ath/ath_hal/ar9002/ar9280_attach.c +++ b/sys/dev/ath/ath_hal/ar9002/ar9280_attach.c @@ -148,6 +148,7 @@ ar9280InitPLL(struct ath_hal *ah, const struct ieee80211_channel *chan) static struct ath_hal * ar9280Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { struct ath_hal_9280 *ahp9280; diff --git a/sys/dev/ath/ath_hal/ar9002/ar9285_attach.c b/sys/dev/ath/ath_hal/ar9002/ar9285_attach.c index edb6f26..eb3490a 100644 --- a/sys/dev/ath/ath_hal/ar9002/ar9285_attach.c +++ b/sys/dev/ath/ath_hal/ar9002/ar9285_attach.c @@ -133,6 +133,7 @@ ar9285_eeprom_print_diversity_settings(struct ath_hal *ah) static struct ath_hal * ar9285Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { struct ath_hal_9285 *ahp9285; diff --git a/sys/dev/ath/ath_hal/ar9002/ar9287_attach.c b/sys/dev/ath/ath_hal/ar9002/ar9287_attach.c index 010e2c3..0ea565c 100644 --- a/sys/dev/ath/ath_hal/ar9002/ar9287_attach.c +++ b/sys/dev/ath/ath_hal/ar9002/ar9287_attach.c @@ -111,6 +111,7 @@ ar9287AniSetup(struct ath_hal *ah) static struct ath_hal * ar9287Attach(uint16_t devid, HAL_SOFTC sc, HAL_BUS_TAG st, HAL_BUS_HANDLE sh, uint16_t *eepromdata, + HAL_OPS_CONFIG *ah_config, HAL_STATUS *status) { struct ath_hal_9287 *ahp9287; diff --git a/sys/dev/ath/ath_rate/sample/sample.c b/sys/dev/ath/ath_rate/sample/sample.c index b3f82fa..36cd679 100644 --- a/sys/dev/ath/ath_rate/sample/sample.c +++ b/sys/dev/ath/ath_rate/sample/sample.c @@ -51,6 +51,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <sys/kernel.h> #include <sys/lock.h> +#include <sys/malloc.h> #include <sys/mutex.h> #include <sys/errno.h> @@ -61,6 +62,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_arp.h> #include <net/ethernet.h> /* XXX for ether_sprintf */ @@ -889,8 +891,8 @@ ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an, if (!mrr || ts->ts_finaltsi == 0) { if (!IS_RATE_DEFINED(sn, final_rix)) { - device_printf(sc->sc_dev, "%s: ts_rate=%d ts_finaltsi=%d\n", - __func__, ts->ts_rate, ts->ts_finaltsi); + device_printf(sc->sc_dev, "%s: ts_rate=%d ts_finaltsi=%d, final_rix=%d\n", + __func__, ts->ts_rate, ts->ts_finaltsi, final_rix); badrate(ifp, 0, ts->ts_rate, long_tries, status); return; } diff --git a/sys/dev/ath/ath_rate/sample/sample.h b/sys/dev/ath/ath_rate/sample/sample.h index 7438a3d..1c57dee 100644 --- a/sys/dev/ath/ath_rate/sample/sample.h +++ b/sys/dev/ath/ath_rate/sample/sample.h @@ -113,7 +113,7 @@ struct sample_node { #ifdef _KERNEL #define ATH_NODE_SAMPLE(an) ((struct sample_node *)&(an)[1]) -#define IS_RATE_DEFINED(sn, rix) (((sn)->ratemask & (1<<(rix))) != 0) +#define IS_RATE_DEFINED(sn, rix) (((uint64_t) (sn)->ratemask & (1ULL<<((uint64_t) rix))) != 0) #ifndef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) diff --git a/sys/dev/ath/if_ath.c b/sys/dev/ath/if_ath.c index 6e58896..3787500 100644 --- a/sys/dev/ath/if_ath.c +++ b/sys/dev/ath/if_ath.c @@ -73,6 +73,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -164,6 +165,7 @@ static void ath_bmiss_vap(struct ieee80211vap *); static void ath_bmiss_proc(void *, int); static void ath_key_update_begin(struct ieee80211vap *); static void ath_key_update_end(struct ieee80211vap *); +static void ath_update_mcast_hw(struct ath_softc *); static void ath_update_mcast(struct ifnet *); static void ath_update_promisc(struct ifnet *); static void ath_updateslot(struct ifnet *); @@ -238,17 +240,14 @@ SYSCTL_INT(_hw_ath, OID_AUTO, anical, CTLFLAG_RW, &ath_anicalinterval, 0, "ANI calibration (msecs)"); int ath_rxbuf = ATH_RXBUF; /* # rx buffers to allocate */ -SYSCTL_INT(_hw_ath, OID_AUTO, rxbuf, CTLFLAG_RW, &ath_rxbuf, +SYSCTL_INT(_hw_ath, OID_AUTO, rxbuf, CTLFLAG_RWTUN, &ath_rxbuf, 0, "rx buffers allocated"); -TUNABLE_INT("hw.ath.rxbuf", &ath_rxbuf); int ath_txbuf = ATH_TXBUF; /* # tx buffers to allocate */ -SYSCTL_INT(_hw_ath, OID_AUTO, txbuf, CTLFLAG_RW, &ath_txbuf, +SYSCTL_INT(_hw_ath, OID_AUTO, txbuf, CTLFLAG_RWTUN, &ath_txbuf, 0, "tx buffers allocated"); -TUNABLE_INT("hw.ath.txbuf", &ath_txbuf); int ath_txbuf_mgmt = ATH_MGMT_TXBUF; /* # mgmt tx buffers to allocate */ -SYSCTL_INT(_hw_ath, OID_AUTO, txbuf_mgmt, CTLFLAG_RW, &ath_txbuf_mgmt, +SYSCTL_INT(_hw_ath, OID_AUTO, txbuf_mgmt, CTLFLAG_RWTUN, &ath_txbuf_mgmt, 0, "tx (mgmt) buffers allocated"); -TUNABLE_INT("hw.ath.txbuf_mgmt", &ath_txbuf_mgmt); int ath_bstuck_threshold = 4; /* max missed beacons */ SYSCTL_INT(_hw_ath, OID_AUTO, bstuck, CTLFLAG_RW, &ath_bstuck_threshold, @@ -278,6 +277,293 @@ ath_legacy_attach_comp_func(struct ath_softc *sc) } } +/* + * Set the target power mode. + * + * If this is called during a point in time where + * the hardware is being programmed elsewhere, it will + * simply store it away and update it when all current + * uses of the hardware are completed. + */ +void +_ath_power_setpower(struct ath_softc *sc, int power_state, const char *file, int line) +{ + ATH_LOCK_ASSERT(sc); + + sc->sc_target_powerstate = power_state; + + DPRINTF(sc, ATH_DEBUG_PWRSAVE, "%s: (%s:%d) state=%d, refcnt=%d\n", + __func__, + file, + line, + power_state, + sc->sc_powersave_refcnt); + + if (sc->sc_powersave_refcnt == 0 && + power_state != sc->sc_cur_powerstate) { + sc->sc_cur_powerstate = power_state; + ath_hal_setpower(sc->sc_ah, power_state); + + /* + * If the NIC is force-awake, then set the + * self-gen frame state appropriately. + * + * If the nic is in network sleep or full-sleep, + * we let the above call leave the self-gen + * state as "sleep". + */ + if (sc->sc_cur_powerstate == HAL_PM_AWAKE && + sc->sc_target_selfgen_state != HAL_PM_AWAKE) { + ath_hal_setselfgenpower(sc->sc_ah, + sc->sc_target_selfgen_state); + } + } +} + +/* + * Set the current self-generated frames state. + * + * This is separate from the target power mode. The chip may be + * awake but the desired state is "sleep", so frames sent to the + * destination has PWRMGT=1 in the 802.11 header. The NIC also + * needs to know to set PWRMGT=1 in self-generated frames. + */ +void +_ath_power_set_selfgen(struct ath_softc *sc, int power_state, const char *file, int line) +{ + + ATH_LOCK_ASSERT(sc); + + DPRINTF(sc, ATH_DEBUG_PWRSAVE, "%s: (%s:%d) state=%d, refcnt=%d\n", + __func__, + file, + line, + power_state, + sc->sc_target_selfgen_state); + + sc->sc_target_selfgen_state = power_state; + + /* + * If the NIC is force-awake, then set the power state. + * Network-state and full-sleep will already transition it to + * mark self-gen frames as sleeping - and we can't + * guarantee the NIC is awake to program the self-gen frame + * setting anyway. + */ + if (sc->sc_cur_powerstate == HAL_PM_AWAKE) { + ath_hal_setselfgenpower(sc->sc_ah, power_state); + } +} + +/* + * Set the hardware power mode and take a reference. + * + * This doesn't update the target power mode in the driver; + * it just updates the hardware power state. + * + * XXX it should only ever force the hardware awake; it should + * never be called to set it asleep. + */ +void +_ath_power_set_power_state(struct ath_softc *sc, int power_state, const char *file, int line) +{ + ATH_LOCK_ASSERT(sc); + + DPRINTF(sc, ATH_DEBUG_PWRSAVE, "%s: (%s:%d) state=%d, refcnt=%d\n", + __func__, + file, + line, + power_state, + sc->sc_powersave_refcnt); + + sc->sc_powersave_refcnt++; + + if (power_state != sc->sc_cur_powerstate) { + ath_hal_setpower(sc->sc_ah, power_state); + sc->sc_cur_powerstate = power_state; + + /* + * Adjust the self-gen powerstate if appropriate. + */ + if (sc->sc_cur_powerstate == HAL_PM_AWAKE && + sc->sc_target_selfgen_state != HAL_PM_AWAKE) { + ath_hal_setselfgenpower(sc->sc_ah, + sc->sc_target_selfgen_state); + } + + } +} + +/* + * Restore the power save mode to what it once was. + * + * This will decrement the reference counter and once it hits + * zero, it'll restore the powersave state. + */ +void +_ath_power_restore_power_state(struct ath_softc *sc, const char *file, int line) +{ + + ATH_LOCK_ASSERT(sc); + + DPRINTF(sc, ATH_DEBUG_PWRSAVE, "%s: (%s:%d) refcnt=%d, target state=%d\n", + __func__, + file, + line, + sc->sc_powersave_refcnt, + sc->sc_target_powerstate); + + if (sc->sc_powersave_refcnt == 0) + device_printf(sc->sc_dev, "%s: refcnt=0?\n", __func__); + else + sc->sc_powersave_refcnt--; + + if (sc->sc_powersave_refcnt == 0 && + sc->sc_target_powerstate != sc->sc_cur_powerstate) { + sc->sc_cur_powerstate = sc->sc_target_powerstate; + ath_hal_setpower(sc->sc_ah, sc->sc_target_powerstate); + } + + /* + * Adjust the self-gen powerstate if appropriate. + */ + if (sc->sc_cur_powerstate == HAL_PM_AWAKE && + sc->sc_target_selfgen_state != HAL_PM_AWAKE) { + ath_hal_setselfgenpower(sc->sc_ah, + sc->sc_target_selfgen_state); + } + +} + +/* + * Configure the initial HAL configuration values based on bus + * specific parameters. + * + * Some PCI IDs and other information may need tweaking. + * + * XXX TODO: ath9k and the Atheros HAL only program comm2g_switch_enable + * if BT antenna diversity isn't enabled. + * + * So, let's also figure out how to enable BT diversity for AR9485. + */ +static void +ath_setup_hal_config(struct ath_softc *sc, HAL_OPS_CONFIG *ah_config) +{ + /* XXX TODO: only for PCI devices? */ + + if (sc->sc_pci_devinfo & (ATH_PCI_CUS198 | ATH_PCI_CUS230)) { + ah_config->ath_hal_ext_lna_ctl_gpio = 0x200; /* bit 9 */ + ah_config->ath_hal_ext_atten_margin_cfg = AH_TRUE; + ah_config->ath_hal_min_gainidx = AH_TRUE; + ah_config->ath_hal_ant_ctrl_comm2g_switch_enable = 0x000bbb88; + /* XXX low_rssi_thresh */ + /* XXX fast_div_bias */ + device_printf(sc->sc_dev, "configuring for %s\n", + (sc->sc_pci_devinfo & ATH_PCI_CUS198) ? + "CUS198" : "CUS230"); + } + + if (sc->sc_pci_devinfo & ATH_PCI_CUS217) + device_printf(sc->sc_dev, "CUS217 card detected\n"); + + if (sc->sc_pci_devinfo & ATH_PCI_CUS252) + device_printf(sc->sc_dev, "CUS252 card detected\n"); + + if (sc->sc_pci_devinfo & ATH_PCI_AR9565_1ANT) + device_printf(sc->sc_dev, "WB335 1-ANT card detected\n"); + + if (sc->sc_pci_devinfo & ATH_PCI_AR9565_2ANT) + device_printf(sc->sc_dev, "WB335 2-ANT card detected\n"); + + if (sc->sc_pci_devinfo & ATH_PCI_KILLER) + device_printf(sc->sc_dev, "Killer Wireless card detected\n"); + +#if 0 + /* + * Some WB335 cards do not support antenna diversity. Since + * we use a hardcoded value for AR9565 instead of using the + * EEPROM/OTP data, remove the combining feature from + * the HW capabilities bitmap. + */ + if (sc->sc_pci_devinfo & (ATH9K_PCI_AR9565_1ANT | ATH9K_PCI_AR9565_2ANT)) { + if (!(sc->sc_pci_devinfo & ATH9K_PCI_BT_ANT_DIV)) + pCap->hw_caps &= ~ATH9K_HW_CAP_ANT_DIV_COMB; + } + + if (sc->sc_pci_devinfo & ATH9K_PCI_BT_ANT_DIV) { + pCap->hw_caps |= ATH9K_HW_CAP_BT_ANT_DIV; + device_printf(sc->sc_dev, "Set BT/WLAN RX diversity capability\n"); + } +#endif + + if (sc->sc_pci_devinfo & ATH_PCI_D3_L1_WAR) { + ah_config->ath_hal_pcie_waen = 0x0040473b; + device_printf(sc->sc_dev, "Enable WAR for ASPM D3/L1\n"); + } + +#if 0 + if (sc->sc_pci_devinfo & ATH9K_PCI_NO_PLL_PWRSAVE) { + ah->config.no_pll_pwrsave = true; + device_printf(sc->sc_dev, "Disable PLL PowerSave\n"); + } +#endif + +} + +/* + * Attempt to fetch the MAC address from the kernel environment. + * + * Returns 0, macaddr in macaddr if successful; -1 otherwise. + */ +static int +ath_fetch_mac_kenv(struct ath_softc *sc, uint8_t *macaddr) +{ + char devid_str[32]; + int local_mac = 0; + char *local_macstr; + + /* + * Fetch from the kenv rather than using hints. + * + * Hints would be nice but the transition to dynamic + * hints/kenv doesn't happen early enough for this + * to work reliably (eg on anything embedded.) + */ + snprintf(devid_str, 32, "hint.%s.%d.macaddr", + device_get_name(sc->sc_dev), + device_get_unit(sc->sc_dev)); + + if ((local_macstr = getenv(devid_str)) != NULL) { + uint32_t tmpmac[ETHER_ADDR_LEN]; + int count; + int i; + + /* Have a MAC address; should use it */ + device_printf(sc->sc_dev, + "Overriding MAC address from environment: '%s'\n", + local_macstr); + + /* Extract out the MAC address */ + count = sscanf(local_macstr, "%x%*c%x%*c%x%*c%x%*c%x%*c%x", + &tmpmac[0], &tmpmac[1], + &tmpmac[2], &tmpmac[3], + &tmpmac[4], &tmpmac[5]); + if (count == 6) { + /* Valid! */ + local_mac = 1; + for (i = 0; i < ETHER_ADDR_LEN; i++) + macaddr[i] = tmpmac[i]; + } + /* Done! */ + freeenv(local_macstr); + local_macstr = NULL; + } + + if (local_mac) + return (0); + return (-1); +} + #define HAL_MODE_HT20 (HAL_MODE_11NG_HT20 | HAL_MODE_11NA_HT20) #define HAL_MODE_HT40 \ (HAL_MODE_11NG_HT40PLUS | HAL_MODE_11NG_HT40MINUS | \ @@ -293,6 +579,7 @@ ath_attach(u_int16_t devid, struct ath_softc *sc) u_int wmodes; uint8_t macaddr[IEEE80211_ADDR_LEN]; int rx_chainmask, tx_chainmask; + HAL_OPS_CONFIG ah_config; DPRINTF(sc, ATH_DEBUG_ANY, "%s: devid 0x%x\n", __func__, devid); @@ -311,8 +598,17 @@ ath_attach(u_int16_t devid, struct ath_softc *sc) device_get_unit(sc->sc_dev)); CURVNET_RESTORE(); + /* + * Configure the initial configuration data. + * + * This is stuff that may be needed early during attach + * rather than done via configuration calls later. + */ + bzero(&ah_config, sizeof(ah_config)); + ath_setup_hal_config(sc, &ah_config); + ah = ath_hal_attach(devid, sc, sc->sc_st, sc->sc_sh, - sc->sc_eepromdata, &status); + sc->sc_eepromdata, &ah_config, &status); if (ah == NULL) { if_printf(ifp, "unable to attach hardware; HAL status %u\n", status); @@ -340,6 +636,10 @@ ath_attach(u_int16_t devid, struct ath_softc *sc) ath_xmit_setup_legacy(sc); } + if (ath_hal_hasmybeacon(sc->sc_ah)) { + sc->sc_do_mybeacon = 1; + } + /* * Check if the MAC has multi-rate retry support. * We do this by trying to setup a fake extended @@ -604,6 +904,8 @@ ath_attach(u_int16_t devid, struct ath_softc *sc) #ifdef ATH_ENABLE_DFS | IEEE80211_C_DFS /* Enable radar detection */ #endif + | IEEE80211_C_PMGT /* Station side power mgmt */ + | IEEE80211_C_SWSLEEP ; /* * Query the hal to figure out h/w crypto support. @@ -901,8 +1203,14 @@ ath_attach(u_int16_t devid, struct ath_softc *sc) */ sc->sc_hasveol = ath_hal_hasveol(ah); - /* get mac address from hardware */ - ath_hal_getmac(ah, macaddr); + /* get mac address from kenv first, then hardware */ + if (ath_fetch_mac_kenv(sc, macaddr) == 0) { + /* Tell the HAL now about the new MAC */ + ath_hal_setmac(ah, macaddr); + } else { + ath_hal_getmac(ah, macaddr); + } + if (sc->sc_hasbmask) ath_hal_getbssidmask(ah, sc->sc_hwbssidmask); @@ -993,6 +1301,14 @@ ath_attach(u_int16_t devid, struct ath_softc *sc) if (bootverbose) ieee80211_announce(ic); ath_announce(sc); + + /* + * Put it to sleep for now. + */ + ATH_LOCK(sc); + ath_power_setpower(sc, HAL_PM_FULL_SLEEP); + ATH_UNLOCK(sc); + return 0; bad2: ath_tx_cleanup(sc); @@ -1038,7 +1354,22 @@ ath_detach(struct ath_softc *sc) * it last * Other than that, it's straightforward... */ + + /* + * XXX Wake the hardware up first. ath_stop() will still + * wake it up first, but I'd rather do it here just to + * ensure it's awake. + */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ath_power_setpower(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + + /* + * Stop things cleanly. + */ ath_stop(ifp); + ieee80211_ifdetach(ifp->if_l2com); taskqueue_free(sc->sc_tq); #ifdef ATH_TX99_DIAG @@ -1401,6 +1732,10 @@ ath_vap_delete(struct ieee80211vap *vap) struct ath_hal *ah = sc->sc_ah; struct ath_vap *avp = ATH_VAP(vap); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + DPRINTF(sc, ATH_DEBUG_RESET, "%s: called\n", __func__); if (ifp->if_drv_flags & IFF_DRV_RUNNING) { /* @@ -1409,11 +1744,13 @@ ath_vap_delete(struct ieee80211vap *vap) * the vap state by any frames pending on the tx queues. */ ath_hal_intrset(ah, 0); /* disable interrupts */ - ath_draintxq(sc, ATH_RESET_DEFAULT); /* stop hw xmit side */ /* XXX Do all frames from all vaps/nodes need draining here? */ ath_stoprecv(sc, 1); /* stop recv side */ + ath_draintxq(sc, ATH_RESET_DEFAULT); /* stop hw xmit side */ } + /* .. leave the hardware awake for now. */ + ieee80211_vap_detach(vap); /* @@ -1501,6 +1838,9 @@ ath_vap_delete(struct ieee80211vap *vap) } ath_hal_intrset(ah, sc->sc_imask); } + + /* Ok, let the hardware asleep. */ + ath_power_restore_power_state(sc); ATH_UNLOCK(sc); } @@ -1520,12 +1860,25 @@ ath_suspend(struct ath_softc *sc) * NB: don't worry about putting the chip in low power * mode; pci will power off our socket on suspend and * CardBus detaches the device. + * + * XXX TODO: well, that's great, except for non-cardbus + * devices! */ /* - * XXX ensure none of the taskqueues are running + * XXX This doesn't wait until all pending taskqueue + * items and parallel transmit/receive/other threads + * are running! + */ + ath_hal_intrset(sc->sc_ah, 0); + taskqueue_block(sc->sc_tq); + + ATH_LOCK(sc); + callout_stop(&sc->sc_cal_ch); + ATH_UNLOCK(sc); + + /* * XXX ensure sc_invalid is 1 - * XXX ensure the calibration callout is disabled */ /* Disable the PCIe PHY, complete with workarounds */ @@ -1546,8 +1899,12 @@ ath_reset_keycache(struct ath_softc *sc) struct ath_hal *ah = sc->sc_ah; int i; + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); for (i = 0; i < sc->sc_keymax; i++) ath_hal_keyreset(ah, i); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); ieee80211_crypto_reload_keys(ic); } @@ -1599,11 +1956,24 @@ ath_resume(struct ath_softc *sc) sc->sc_curchan != NULL ? sc->sc_curchan : ic->ic_curchan); ath_hal_setchainmasks(sc->sc_ah, sc->sc_cur_txchainmask, sc->sc_cur_rxchainmask); + + /* Ensure we set the current power state to on */ + ATH_LOCK(sc); + ath_power_setselfgen(sc, HAL_PM_AWAKE); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ath_power_setpower(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ath_hal_reset(ah, sc->sc_opmode, sc->sc_curchan != NULL ? sc->sc_curchan : ic->ic_curchan, AH_FALSE, &status); ath_reset_keycache(sc); + ATH_RX_LOCK(sc); + sc->sc_rx_stopped = 1; + sc->sc_rx_resetted = 1; + ATH_RX_UNLOCK(sc); + /* Let DFS at it in case it's a DFS channel */ ath_dfs_radar_enable(sc, ic->ic_curchan); @@ -1631,6 +2001,10 @@ ath_resume(struct ath_softc *sc) if (sc->sc_resume_up) ieee80211_resume_all(ic); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + /* XXX beacons ? */ } @@ -1688,6 +2062,10 @@ ath_intr(void *arg) return; } + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + if ((ifp->if_flags & IFF_UP) == 0 || (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { HAL_INT status; @@ -1697,6 +2075,10 @@ ath_intr(void *arg) ath_hal_getisr(ah, &status); /* clear ISR */ ath_hal_intrset(ah, 0); /* disable further intr's */ ATH_PCU_UNLOCK(sc); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); return; } @@ -1736,6 +2118,11 @@ ath_intr(void *arg) /* Short-circuit un-handled interrupts */ if (status == 0x0) { ATH_PCU_UNLOCK(sc); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + return; } @@ -1791,44 +2178,46 @@ ath_intr(void *arg) if (status & HAL_INT_RXEOL) { int imask; ATH_KTR(sc, ATH_KTR_ERROR, 0, "ath_intr: RXEOL"); - ATH_PCU_LOCK(sc); - /* - * NB: the hardware should re-read the link when - * RXE bit is written, but it doesn't work at - * least on older hardware revs. - */ - sc->sc_stats.ast_rxeol++; - /* - * Disable RXEOL/RXORN - prevent an interrupt - * storm until the PCU logic can be reset. - * In case the interface is reset some other - * way before "sc_kickpcu" is called, don't - * modify sc_imask - that way if it is reset - * by a call to ath_reset() somehow, the - * interrupt mask will be correctly reprogrammed. - */ - imask = sc->sc_imask; - imask &= ~(HAL_INT_RXEOL | HAL_INT_RXORN); - ath_hal_intrset(ah, imask); - /* - * Only blank sc_rxlink if we've not yet kicked - * the PCU. - * - * This isn't entirely correct - the correct solution - * would be to have a PCU lock and engage that for - * the duration of the PCU fiddling; which would include - * running the RX process. Otherwise we could end up - * messing up the RX descriptor chain and making the - * RX desc list much shorter. - */ - if (! sc->sc_kickpcu) - sc->sc_rxlink = NULL; - sc->sc_kickpcu = 1; - ATH_PCU_UNLOCK(sc); + if (! sc->sc_isedma) { + ATH_PCU_LOCK(sc); + /* + * NB: the hardware should re-read the link when + * RXE bit is written, but it doesn't work at + * least on older hardware revs. + */ + sc->sc_stats.ast_rxeol++; + /* + * Disable RXEOL/RXORN - prevent an interrupt + * storm until the PCU logic can be reset. + * In case the interface is reset some other + * way before "sc_kickpcu" is called, don't + * modify sc_imask - that way if it is reset + * by a call to ath_reset() somehow, the + * interrupt mask will be correctly reprogrammed. + */ + imask = sc->sc_imask; + imask &= ~(HAL_INT_RXEOL | HAL_INT_RXORN); + ath_hal_intrset(ah, imask); + /* + * Only blank sc_rxlink if we've not yet kicked + * the PCU. + * + * This isn't entirely correct - the correct solution + * would be to have a PCU lock and engage that for + * the duration of the PCU fiddling; which would include + * running the RX process. Otherwise we could end up + * messing up the RX descriptor chain and making the + * RX desc list much shorter. + */ + if (! sc->sc_kickpcu) + sc->sc_rxlink = NULL; + sc->sc_kickpcu = 1; + ATH_PCU_UNLOCK(sc); + } /* - * Enqueue an RX proc, to handled whatever + * Enqueue an RX proc to handle whatever * is in the RX queue. - * This will then kick the PCU. + * This will then kick the PCU if required. */ sc->sc_rx.recv_sched(sc, 1); } @@ -1902,10 +2291,18 @@ ath_intr(void *arg) ATH_KTR(sc, ATH_KTR_ERROR, 0, "ath_intr: RXORN"); sc->sc_stats.ast_rxorn++; } + if (status & HAL_INT_TSFOOR) { + device_printf(sc->sc_dev, "%s: TSFOOR\n", __func__); + sc->sc_syncbeacon = 1; + } } ATH_PCU_LOCK(sc); sc->sc_intr_cnt--; ATH_PCU_UNLOCK(sc); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); } static void @@ -1936,6 +2333,8 @@ ath_fatal_proc(void *arg, int pending) static void ath_bmiss_vap(struct ieee80211vap *vap) { + struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc; + /* * Workaround phantom bmiss interrupts by sanity-checking * the time of our last rx'd frame. If it is within the @@ -1944,6 +2343,16 @@ ath_bmiss_vap(struct ieee80211vap *vap) * be dispatched up for processing. Note this applies only * for h/w beacon miss events. */ + + /* + * XXX TODO: Just read the TSF during the interrupt path; + * that way we don't have to wake up again just to read it + * again. + */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + if ((vap->iv_flags_ext & IEEE80211_FEXT_SWBMISS) == 0) { struct ifnet *ifp = vap->iv_ic->ic_ifp; struct ath_softc *sc = ifp->if_softc; @@ -1961,12 +2370,32 @@ ath_bmiss_vap(struct ieee80211vap *vap) if (tsf - lastrx <= bmisstimeout) { sc->sc_stats.ast_bmiss_phantom++; + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + return; } } + + /* + * There's no need to keep the hardware awake during the call + * to av_bmiss(). + */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + + /* + * Attempt to force a beacon resync. + */ + sc->sc_syncbeacon = 1; + ATH_VAP(vap)->av_bmiss(vap); } +/* XXX this needs a force wakeup! */ int ath_hal_gethangstate(struct ath_hal *ah, uint32_t mask, uint32_t *hangs) { @@ -1989,6 +2418,12 @@ ath_bmiss_proc(void *arg, int pending) DPRINTF(sc, ATH_DEBUG_ANY, "%s: pending %u\n", __func__, pending); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + + ath_beacon_miss(sc); + /* * Do a reset upon any becaon miss event. * @@ -2002,6 +2437,13 @@ ath_bmiss_proc(void *arg, int pending) ath_reset(ifp, ATH_RESET_NOLOSS); ieee80211_beacon_miss(ifp->if_l2com); } + + /* Force a beacon resync, in case they've drifted */ + sc->sc_syncbeacon = 1; + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); } /* @@ -2041,6 +2483,13 @@ ath_init(void *arg) ATH_LOCK(sc); /* + * Force the sleep state awake. + */ + ath_power_setselfgen(sc, HAL_PM_AWAKE); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ath_power_setpower(sc, HAL_PM_AWAKE); + + /* * Stop anything previously setup. This is safe * whether this is the first time through or not. */ @@ -2057,12 +2506,19 @@ ath_init(void *arg) ath_update_chainmasks(sc, ic->ic_curchan); ath_hal_setchainmasks(sc->sc_ah, sc->sc_cur_txchainmask, sc->sc_cur_rxchainmask); + if (!ath_hal_reset(ah, sc->sc_opmode, ic->ic_curchan, AH_FALSE, &status)) { if_printf(ifp, "unable to reset hardware; hal status %u\n", status); ATH_UNLOCK(sc); return; } + + ATH_RX_LOCK(sc); + sc->sc_rx_stopped = 1; + sc->sc_rx_resetted = 1; + ATH_RX_UNLOCK(sc); + ath_chan_change(sc, ic->ic_curchan); /* Let DFS at it in case it's a DFS channel */ @@ -2090,11 +2546,11 @@ ath_init(void *arg) * state cached in the driver. */ sc->sc_diversity = ath_hal_getdiversity(ah); - sc->sc_lastlongcal = 0; + sc->sc_lastlongcal = ticks; sc->sc_resetcal = 1; sc->sc_lastcalreset = 0; - sc->sc_lastani = 0; - sc->sc_lastshortcal = 0; + sc->sc_lastani = ticks; + sc->sc_lastshortcal = ticks; sc->sc_doresetcal = AH_FALSE; /* * Beacon timers were cleared here; give ath_newstate() @@ -2112,6 +2568,7 @@ ath_init(void *arg) */ if (ath_startrecv(sc) != 0) { if_printf(ifp, "unable to start recv logic\n"); + ath_power_restore_power_state(sc); ATH_UNLOCK(sc); return; } @@ -2120,8 +2577,7 @@ ath_init(void *arg) * Enable interrupts. */ sc->sc_imask = HAL_INT_RX | HAL_INT_TX - | HAL_INT_RXEOL | HAL_INT_RXORN - | HAL_INT_TXURN + | HAL_INT_RXORN | HAL_INT_TXURN | HAL_INT_FATAL | HAL_INT_GLOBAL; /* @@ -2132,12 +2588,29 @@ ath_init(void *arg) sc->sc_imask |= (HAL_INT_RXHP | HAL_INT_RXLP); /* + * If we're an EDMA NIC, we don't care about RXEOL. + * Writing a new descriptor in will simply restart + * RX DMA. + */ + if (! sc->sc_isedma) + sc->sc_imask |= HAL_INT_RXEOL; + + /* * Enable MIB interrupts when there are hardware phy counters. * Note we only do this (at the moment) for station mode. */ if (sc->sc_needmib && ic->ic_opmode == IEEE80211_M_STA) sc->sc_imask |= HAL_INT_MIB; + /* + * XXX add capability for this. + * + * If we're in STA mode (and maybe IBSS?) then register for + * TSFOOR interrupts. + */ + if (ic->ic_opmode == IEEE80211_M_STA) + sc->sc_imask |= HAL_INT_TSFOOR; + /* Enable global TX timeout and carrier sense timeout if available */ if (ath_hal_gtxto_supported(ah)) sc->sc_imask |= HAL_INT_GTT; @@ -2149,6 +2622,7 @@ ath_init(void *arg) callout_reset(&sc->sc_wd_ch, hz, ath_watchdog, sc); ath_hal_intrset(ah, sc->sc_imask); + ath_power_restore_power_state(sc); ATH_UNLOCK(sc); #ifdef ATH_TX99_DIAG @@ -2169,6 +2643,12 @@ ath_stop_locked(struct ifnet *ifp) __func__, sc->sc_invalid, ifp->if_flags); ATH_LOCK_ASSERT(sc); + + /* + * Wake the hardware up before fiddling with it. + */ + ath_power_set_power_state(sc, HAL_PM_AWAKE); + if (ifp->if_drv_flags & IFF_DRV_RUNNING) { /* * Shutdown the hardware and driver: @@ -2201,17 +2681,29 @@ ath_stop_locked(struct ifnet *ifp) } ath_hal_intrset(ah, 0); } - ath_draintxq(sc, ATH_RESET_DEFAULT); + /* XXX we should stop RX regardless of whether it's valid */ if (!sc->sc_invalid) { ath_stoprecv(sc, 1); ath_hal_phydisable(ah); } else sc->sc_rxlink = NULL; + ath_draintxq(sc, ATH_RESET_DEFAULT); ath_beacon_free(sc); /* XXX not needed */ } + + /* And now, restore the current power state */ + ath_power_restore_power_state(sc); } -#define MAX_TXRX_ITERATIONS 1000 +/* + * Wait until all pending TX/RX has completed. + * + * This waits until all existing transmit, receive and interrupts + * have completed. It's assumed that the caller has first + * grabbed the reset lock so it doesn't try to do overlapping + * chip resets. + */ +#define MAX_TXRX_ITERATIONS 100 static void ath_txrx_stop_locked(struct ath_softc *sc) { @@ -2230,7 +2722,8 @@ ath_txrx_stop_locked(struct ath_softc *sc) sc->sc_txstart_cnt || sc->sc_intr_cnt) { if (i <= 0) break; - msleep(sc, &sc->sc_pcu_mtx, 0, "ath_txrx_stop", 1); + msleep(sc, &sc->sc_pcu_mtx, 0, "ath_txrx_stop", + msecs_to_ticks(10)); i--; } @@ -2277,7 +2770,7 @@ ath_txrx_start(struct ath_softc *sc) * Another, cleaner way should be found to serialise all of * these operations. */ -#define MAX_RESET_ITERATIONS 10 +#define MAX_RESET_ITERATIONS 25 static int ath_reset_grablock(struct ath_softc *sc, int dowait) { @@ -2295,7 +2788,11 @@ ath_reset_grablock(struct ath_softc *sc, int dowait) break; } ATH_PCU_UNLOCK(sc); - pause("ath_reset_grablock", 1); + /* + * 1 tick is likely not enough time for long calibrations + * to complete. So we should wait quite a while. + */ + pause("ath_reset_grablock", msecs_to_ticks(100)); i--; ATH_PCU_LOCK(sc); } while (i > 0); @@ -2360,6 +2857,13 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) /* Try to (stop any further TX/RX from occuring */ taskqueue_block(sc->sc_tq); + /* + * Wake the hardware up. + */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_PCU_LOCK(sc); /* @@ -2385,13 +2889,6 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) ATH_PCU_UNLOCK(sc); /* - * Should now wait for pending TX/RX to complete - * and block future ones from occuring. This needs to be - * done before the TX queue is drained. - */ - ath_draintxq(sc, reset_type); /* stop xmit side */ - - /* * Regardless of whether we're doing a no-loss flush or * not, stop the PCU and handle what's in the RX queue. * That way frames aren't dropped which shouldn't be. @@ -2399,6 +2896,13 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) ath_stoprecv(sc, (reset_type != ATH_RESET_NOLOSS)); ath_rx_flush(sc); + /* + * Should now wait for pending TX/RX to complete + * and block future ones from occuring. This needs to be + * done before the TX queue is drained. + */ + ath_draintxq(sc, reset_type); /* stop xmit side */ + ath_settkipmic(sc); /* configure TKIP MIC handling */ /* NB: indicate channel change so we do a full reset */ ath_update_chainmasks(sc, ic->ic_curchan); @@ -2409,6 +2913,11 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) __func__, status); sc->sc_diversity = ath_hal_getdiversity(ah); + ATH_RX_LOCK(sc); + sc->sc_rx_stopped = 1; + sc->sc_rx_resetted = 1; + ATH_RX_UNLOCK(sc); + /* Let DFS at it in case it's a DFS channel */ ath_dfs_radar_enable(sc, ic->ic_curchan); @@ -2454,9 +2963,13 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) * reset counter - this way ath_intr() doesn't end up * disabling interrupts without a corresponding enable * in the rest or channel change path. + * + * Grab the TX reference in case we need to transmit. + * That way a parallel transmit doesn't. */ ATH_PCU_LOCK(sc); sc->sc_inreset_cnt--; + sc->sc_txstart_cnt++; /* XXX only do this if sc_inreset_cnt == 0? */ ath_hal_intrset(ah, sc->sc_imask); ATH_PCU_UNLOCK(sc); @@ -2473,6 +2986,8 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) /* Restart TX/RX as needed */ ath_txrx_start(sc); + /* XXX TODO: we need to hold the tx refcount here! */ + /* Restart TX completion and pending TX */ if (reset_type == ATH_RESET_NOLOSS) { for (i = 0; i < HAL_NUM_TX_QUEUES; i++) { @@ -2497,6 +3012,14 @@ ath_reset(struct ifnet *ifp, ATH_RESET_TYPE reset_type) ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; IF_UNLOCK(&ifp->if_snd); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + + ATH_PCU_LOCK(sc); + sc->sc_txstart_cnt--; + ATH_PCU_UNLOCK(sc); + /* Handle any frames in the TX queue */ /* * XXX should this be done by the caller, rather than @@ -2637,6 +3160,7 @@ ath_buf_clone(struct ath_softc *sc, struct ath_buf *bf) tbf->bf_status = bf->bf_status; tbf->bf_m = bf->bf_m; tbf->bf_node = bf->bf_node; + KASSERT((bf->bf_node != NULL), ("%s: bf_node=NULL!", __func__)); /* will be setup by the chain/setup function */ tbf->bf_lastds = NULL; /* for now, last == self */ @@ -2738,6 +3262,11 @@ ath_transmit(struct ifnet *ifp, struct mbuf *m) sc->sc_txstart_cnt++; ATH_PCU_UNLOCK(sc); + /* Wake the hardware up already */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_KTR(sc, ATH_KTR_TX, 0, "ath_transmit: start"); /* * Grab the TX lock - it's ok to do this here; we haven't @@ -2846,7 +3375,7 @@ ath_transmit(struct ifnet *ifp, struct mbuf *m) DPRINTF(sc, ATH_DEBUG_XMIT, "%s: out of txfrag buffers\n", __func__); sc->sc_stats.ast_tx_nofrag++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ath_freetx(m); goto bad; } @@ -2894,7 +3423,7 @@ ath_transmit(struct ifnet *ifp, struct mbuf *m) * * XXX should use atomics? */ - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); nextfrag: /* * Pass the frame to the h/w for transmission. @@ -2914,7 +3443,7 @@ nextfrag: next = m->m_nextpkt; if (ath_tx_start(sc, ni, bf, m)) { bad: - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); reclaim: bf->bf_m = NULL; bf->bf_node = NULL; @@ -2971,6 +3500,11 @@ finish: sc->sc_txstart_cnt--; ATH_PCU_UNLOCK(sc); + /* Sleep the hardware if required */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + ATH_KTR(sc, ATH_KTR_TX, 0, "ath_transmit: finished"); return (retval); @@ -2998,7 +3532,6 @@ ath_key_update_begin(struct ieee80211vap *vap) DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__); taskqueue_block(sc->sc_tq); - IF_LOCK(&ifp->if_snd); /* NB: doesn't block mgmt frames */ } static void @@ -3008,7 +3541,6 @@ ath_key_update_end(struct ieee80211vap *vap) struct ath_softc *sc = ifp->if_softc; DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__); - IF_UNLOCK(&ifp->if_snd); taskqueue_unblock(sc->sc_tq); } @@ -3019,16 +3551,25 @@ ath_update_promisc(struct ifnet *ifp) u_int32_t rfilt; /* configure rx filter */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); rfilt = ath_calcrxfilter(sc); ath_hal_setrxfilter(sc->sc_ah, rfilt); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); DPRINTF(sc, ATH_DEBUG_MODE, "%s: RX filter 0x%x\n", __func__, rfilt); } +/* + * Driver-internal mcast update call. + * + * Assumes the hardware is already awake. + */ static void -ath_update_mcast(struct ifnet *ifp) +ath_update_mcast_hw(struct ath_softc *sc) { - struct ath_softc *sc = ifp->if_softc; + struct ifnet *ifp = sc->sc_ifp; u_int32_t mfilt[2]; /* calculate and install multicast filter */ @@ -3056,11 +3597,33 @@ ath_update_mcast(struct ifnet *ifp) if_maddr_runlock(ifp); } else mfilt[0] = mfilt[1] = ~0; + ath_hal_setmcastfilter(sc->sc_ah, mfilt[0], mfilt[1]); + DPRINTF(sc, ATH_DEBUG_MODE, "%s: MC filter %08x:%08x\n", __func__, mfilt[0], mfilt[1]); } +/* + * Called from the net80211 layer - force the hardware + * awake before operating. + */ +static void +ath_update_mcast(struct ifnet *ifp) +{ + struct ath_softc *sc = ifp->if_softc; + + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + + ath_update_mcast_hw(sc); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); +} + void ath_mode_init(struct ath_softc *sc) { @@ -3086,7 +3649,7 @@ ath_mode_init(struct ath_softc *sc) ath_hal_setmac(ah, IF_LLADDR(ifp)); /* calculate and install multicast filter */ - ath_update_mcast(ifp); + ath_update_mcast_hw(sc); } /* @@ -3118,8 +3681,13 @@ ath_setslottime(struct ath_softc *sc) __func__, ic->ic_curchan->ic_freq, ic->ic_curchan->ic_flags, ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long", usec); + /* Wake up the hardware first before updating the slot time */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); ath_hal_setslottime(ah, usec); + ath_power_restore_power_state(sc); sc->sc_updateslot = OK; + ATH_UNLOCK(sc); } /* @@ -3136,6 +3704,8 @@ ath_updateslot(struct ifnet *ifp) * When not coordinating the BSS, change the hardware * immediately. For other operation we defer the change * until beacon updates have propagated to the stations. + * + * XXX sc_updateslot isn't changed behind a lock? */ if (ic->ic_opmode == IEEE80211_M_HOSTAP || ic->ic_opmode == IEEE80211_M_MBSS) @@ -4041,14 +4611,12 @@ ath_tx_process_buf_completion(struct ath_softc *sc, struct ath_txq *txq, struct ath_tx_status *ts, struct ath_buf *bf) { struct ieee80211_node *ni = bf->bf_node; - struct ath_node *an = NULL; ATH_TX_UNLOCK_ASSERT(sc); ATH_TXQ_UNLOCK_ASSERT(txq); /* If unicast frame, update general statistics */ if (ni != NULL) { - an = ATH_NODE(ni); /* update statistics */ ath_tx_update_stats(sc, ts, bf); } @@ -4257,6 +4825,10 @@ ath_tx_proc_q0(void *arg, int npending) sc->sc_txq_active &= ~txqs; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_KTR(sc, ATH_KTR_TXCOMP, 1, "ath_tx_proc_q0: txqs=0x%08x", txqs); @@ -4277,6 +4849,10 @@ ath_tx_proc_q0(void *arg, int npending) sc->sc_txproc_cnt--; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + ath_tx_kick(sc); } @@ -4298,6 +4874,10 @@ ath_tx_proc_q0123(void *arg, int npending) sc->sc_txq_active &= ~txqs; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_KTR(sc, ATH_KTR_TXCOMP, 1, "ath_tx_proc_q0123: txqs=0x%08x", txqs); @@ -4330,6 +4910,10 @@ ath_tx_proc_q0123(void *arg, int npending) sc->sc_txproc_cnt--; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + ath_tx_kick(sc); } @@ -4350,6 +4934,10 @@ ath_tx_proc(void *arg, int npending) sc->sc_txq_active &= ~txqs; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_KTR(sc, ATH_KTR_TXCOMP, 1, "ath_tx_proc: txqs=0x%08x", txqs); /* @@ -4375,6 +4963,10 @@ ath_tx_proc(void *arg, int npending) sc->sc_txproc_cnt--; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + ath_tx_kick(sc); } #undef TXQACTIVE @@ -4401,6 +4993,10 @@ ath_txq_sched_tasklet(void *arg, int npending) sc->sc_txproc_cnt++; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_TX_LOCK(sc); for (i = 0; i < HAL_NUM_TX_QUEUES; i++) { if (ATH_TXQ_SETUP(sc, i)) { @@ -4409,6 +5005,10 @@ ath_txq_sched_tasklet(void *arg, int npending) } ATH_TX_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + ATH_PCU_LOCK(sc); sc->sc_txproc_cnt--; ATH_PCU_UNLOCK(sc); @@ -4916,14 +5516,15 @@ ath_chan_set(struct ath_softc *sc, struct ieee80211_channel *chan) ATH_PCU_LOCK(sc); + /* Disable interrupts */ + ath_hal_intrset(ah, 0); + /* Stop new RX/TX/interrupt completion */ if (ath_reset_grablock(sc, 1) == 0) { device_printf(sc->sc_dev, "%s: concurrent reset! Danger!\n", __func__); } - ath_hal_intrset(ah, 0); - /* Stop pending RX/TX completion */ ath_txrx_stop_locked(sc); @@ -4967,6 +5568,11 @@ ath_chan_set(struct ath_softc *sc, struct ieee80211_channel *chan) } sc->sc_diversity = ath_hal_getdiversity(ah); + ATH_RX_LOCK(sc); + sc->sc_rx_stopped = 1; + sc->sc_rx_resetted = 1; + ATH_RX_UNLOCK(sc); + /* Let DFS at it in case it's a DFS channel */ ath_dfs_radar_enable(sc, chan); @@ -5056,6 +5662,17 @@ ath_calibrate(void *arg) HAL_BOOL aniCal, shortCal = AH_FALSE; int nextcal; + ATH_LOCK_ASSERT(sc); + + /* + * Force the hardware awake for ANI work. + */ + ath_power_set_power_state(sc, HAL_PM_AWAKE); + + /* Skip trying to do this if we're in reset */ + if (sc->sc_inreset_cnt) + goto restart; + if (ic->ic_flags & IEEE80211_F_SCAN) /* defer, off channel */ goto restart; longCal = (ticks - sc->sc_lastlongcal >= ath_longcalinterval*hz); @@ -5085,6 +5702,7 @@ ath_calibrate(void *arg) sc->sc_doresetcal = AH_TRUE; taskqueue_enqueue(sc->sc_tq, &sc->sc_resettask); callout_reset(&sc->sc_cal_ch, 1, ath_calibrate, sc); + ath_power_restore_power_state(sc); return; } /* @@ -5156,6 +5774,10 @@ restart: __func__); /* NB: don't rearm timer */ } + /* + * Restore power state now that we're done. + */ + ath_power_restore_power_state(sc); } static void @@ -5241,6 +5863,10 @@ ath_set_channel(struct ieee80211com *ic) struct ifnet *ifp = ic->ic_ifp; struct ath_softc *sc = ifp->if_softc; + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + (void) ath_chan_set(sc, ic->ic_curchan); /* * If we are returning to our bss channel then mark state @@ -5251,6 +5877,7 @@ ath_set_channel(struct ieee80211com *ic) ATH_LOCK(sc); if (!sc->sc_scanning && ic->ic_curchan == ic->ic_bsschan) sc->sc_syncbeacon = 1; + ath_power_restore_power_state(sc); ATH_UNLOCK(sc); } @@ -5283,6 +5910,7 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) int i, error, stamode; u_int32_t rfilt; int csa_run_transition = 0; + enum ieee80211_state ostate = vap->iv_state; static const HAL_LED_STATE leds[] = { HAL_LED_INIT, /* IEEE80211_S_INIT */ @@ -5296,7 +5924,7 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) }; DPRINTF(sc, ATH_DEBUG_STATE, "%s: %s -> %s\n", __func__, - ieee80211_state_name[vap->iv_state], + ieee80211_state_name[ostate], ieee80211_state_name[nstate]); /* @@ -5308,10 +5936,34 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) */ IEEE80211_LOCK_ASSERT(ic); - if (vap->iv_state == IEEE80211_S_CSA && nstate == IEEE80211_S_RUN) + /* Before we touch the hardware - wake it up */ + ATH_LOCK(sc); + /* + * If the NIC is in anything other than SLEEP state, + * we need to ensure that self-generated frames are + * set for PWRMGT=0. Otherwise we may end up with + * strange situations. + * + * XXX TODO: is this actually the case? :-) + */ + if (nstate != IEEE80211_S_SLEEP) + ath_power_setselfgen(sc, HAL_PM_AWAKE); + + /* + * Now, wake the thing up. + */ + ath_power_set_power_state(sc, HAL_PM_AWAKE); + + /* + * And stop the calibration callout whilst we have + * ATH_LOCK held. + */ + callout_stop(&sc->sc_cal_ch); + ATH_UNLOCK(sc); + + if (ostate == IEEE80211_S_CSA && nstate == IEEE80211_S_RUN) csa_run_transition = 1; - callout_drain(&sc->sc_cal_ch); ath_hal_setledstate(ah, leds[nstate]); /* set LED */ if (nstate == IEEE80211_S_SCAN) { @@ -5321,6 +5973,13 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) * [re]setup beacons. Unblock the task q thread so * deferred interrupt processing is done. */ + + /* Ensure we stay awake during scan */ + ATH_LOCK(sc); + ath_power_setselfgen(sc, HAL_PM_AWAKE); + ath_power_setpower(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ath_hal_intrset(ah, sc->sc_imask &~ (HAL_INT_SWBA | HAL_INT_BMISS)); sc->sc_imask &= ~(HAL_INT_SWBA | HAL_INT_BMISS); @@ -5333,6 +5992,11 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) stamode = (vap->iv_opmode == IEEE80211_M_STA || vap->iv_opmode == IEEE80211_M_AHDEMO || vap->iv_opmode == IEEE80211_M_IBSS); + + /* + * XXX Dont need to do this (and others) if we've transitioned + * from SLEEP->RUN. + */ if (stamode && nstate == IEEE80211_S_RUN) { sc->sc_curaid = ni->ni_associd; IEEE80211_ADDR_COPY(sc->sc_curbssid, ni->ni_bssid); @@ -5435,11 +6099,14 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) * beacon to update the beacon timer and thus we * won't get notified of the missing beacons. */ - sc->sc_syncbeacon = 1; -#if 0 - if (csa_run_transition) -#endif - ath_beacon_config(sc, vap); + if (ostate != IEEE80211_S_RUN && + ostate != IEEE80211_S_SLEEP) { + DPRINTF(sc, ATH_DEBUG_BEACON, + "%s: STA; syncbeacon=1\n", __func__); + sc->sc_syncbeacon = 1; + + if (csa_run_transition) + ath_beacon_config(sc, vap); /* * PR: kern/175227 @@ -5453,7 +6120,8 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) * timer fires (too often), leading to a STA * disassociation. */ - sc->sc_beacons = 1; + sc->sc_beacons = 1; + } break; case IEEE80211_M_MONITOR: /* @@ -5479,6 +6147,14 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) sc->sc_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER; sc->sc_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER; sc->sc_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER; + + /* + * Force awake for RUN mode. + */ + ATH_LOCK(sc); + ath_power_setselfgen(sc, HAL_PM_AWAKE); + ath_power_setpower(sc, HAL_PM_AWAKE); + /* * Finally, start any timers and the task q thread * (in case we didn't go through SCAN state). @@ -5490,6 +6166,8 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) DPRINTF(sc, ATH_DEBUG_CALIBRATE, "%s: calibration disabled\n", __func__); } + ATH_UNLOCK(sc); + taskqueue_unblock(sc->sc_tq); } else if (nstate == IEEE80211_S_INIT) { /* @@ -5509,9 +6187,43 @@ ath_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) #ifdef IEEE80211_SUPPORT_TDMA ath_hal_setcca(ah, AH_TRUE); #endif + } else if (nstate == IEEE80211_S_SLEEP) { + /* We're going to sleep, so transition appropriately */ + /* For now, only do this if we're a single STA vap */ + if (sc->sc_nvaps == 1 && + vap->iv_opmode == IEEE80211_M_STA) { + DPRINTF(sc, ATH_DEBUG_BEACON, "%s: syncbeacon=%d\n", __func__, sc->sc_syncbeacon); + ATH_LOCK(sc); + /* + * Always at least set the self-generated + * frame config to set PWRMGT=1. + */ + ath_power_setselfgen(sc, HAL_PM_NETWORK_SLEEP); + + /* + * If we're not syncing beacons, transition + * to NETWORK_SLEEP. + * + * We stay awake if syncbeacon > 0 in case + * we need to listen for some beacons otherwise + * our beacon timer config may be wrong. + */ + if (sc->sc_syncbeacon == 0) { + ath_power_setpower(sc, HAL_PM_NETWORK_SLEEP); + } + ATH_UNLOCK(sc); + } } bad: ieee80211_free_node(ni); + + /* + * Restore the power state - either to what it was, or + * to network_sleep if it's alright. + */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); return error; } @@ -5566,7 +6278,16 @@ ath_newassoc(struct ieee80211_node *ni, int isnew) an->an_mcastrix = ath_tx_findrix(sc, tp->mcastrate); an->an_mgmtrix = ath_tx_findrix(sc, tp->mgmtrate); + DPRINTF(sc, ATH_DEBUG_NODE, "%s: %6D: reassoc; isnew=%d, is_powersave=%d\n", + __func__, + ni->ni_macaddr, + ":", + isnew, + an->an_is_powersave); + + ATH_NODE_LOCK(an); ath_rate_newassoc(sc, an, isnew); + ATH_NODE_UNLOCK(an); if (isnew && (vap->iv_flags & IEEE80211_F_PRIVACY) == 0 && sc->sc_hasclrkey && @@ -5806,10 +6527,14 @@ ath_watchdog(void *arg) struct ath_softc *sc = arg; int do_reset = 0; + ATH_LOCK_ASSERT(sc); + if (sc->sc_wd_timer != 0 && --sc->sc_wd_timer == 0) { struct ifnet *ifp = sc->sc_ifp; uint32_t hangs; + ath_power_set_power_state(sc, HAL_PM_AWAKE); + if (ath_hal_gethangstate(sc->sc_ah, 0xffff, &hangs) && hangs != 0) { if_printf(ifp, "%s hang detected (0x%x)\n", @@ -5817,8 +6542,10 @@ ath_watchdog(void *arg) } else if_printf(ifp, "device timeout\n"); do_reset = 1; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); sc->sc_stats.ast_watchdog++; + + ath_power_restore_power_state(sc); } /* @@ -5916,6 +6643,13 @@ ath_ioctl_diag(struct ath_softc *sc, struct ath_diag *ad) goto bad; } } + + + ATH_LOCK(sc); + if (id != HAL_DIAG_REGS) + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + if (ath_hal_getdiagstate(ah, id, indata, insize, &outdata, &outsize)) { if (outsize < ad->ad_out_size) ad->ad_out_size = outsize; @@ -5925,6 +6659,12 @@ ath_ioctl_diag(struct ath_softc *sc, struct ath_diag *ad) } else { error = EINVAL; } + + ATH_LOCK(sc); + if (id != HAL_DIAG_REGS) + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + bad: if ((ad->ad_id & ATH_DIAG_IN) && indata != NULL) free(indata, M_TEMP); @@ -5947,14 +6687,17 @@ ath_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) switch (cmd) { case SIOCSIFFLAGS: - ATH_LOCK(sc); if (IS_RUNNING(ifp)) { /* * To avoid rescanning another access point, * do not call ath_init() here. Instead, * only reflect promisc mode settings. */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); ath_mode_init(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); } else if (ifp->if_flags & IFF_UP) { /* * Beware of being called during attach/detach @@ -5968,14 +6711,12 @@ ath_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) if (!sc->sc_invalid) ath_init(sc); /* XXX lose error */ } else { + ATH_LOCK(sc); ath_stop_locked(ifp); -#ifdef notyet - /* XXX must wakeup in places like ath_vap_delete */ if (!sc->sc_invalid) - ath_hal_setpower(sc->sc_ah, HAL_PM_FULL_SLEEP); -#endif + ath_power_setpower(sc, HAL_PM_FULL_SLEEP); + ATH_UNLOCK(sc); } - ATH_UNLOCK(sc); break; case SIOCGIFMEDIA: case SIOCSIFMEDIA: @@ -5983,8 +6724,10 @@ ath_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) break; case SIOCGATHSTATS: /* NB: embed these numbers to get a consistent view */ - sc->sc_stats.ast_tx_packets = ifp->if_opackets; - sc->sc_stats.ast_rx_packets = ifp->if_ipackets; + sc->sc_stats.ast_tx_packets = if_get_counter_default(ifp, + IFCOUNTER_OPACKETS); + sc->sc_stats.ast_rx_packets = if_get_counter_default(ifp, + IFCOUNTER_IPACKETS); sc->sc_stats.ast_tx_rssi = ATH_RSSI(sc->sc_halstats.ns_avgtxrssi); sc->sc_stats.ast_rx_rssi = ATH_RSSI(sc->sc_halstats.ns_avgrssi); #ifdef IEEE80211_SUPPORT_TDMA @@ -6341,7 +7084,7 @@ ath_tx_update_tim(struct ath_softc *sc, struct ieee80211_node *ni, /* * Don't bother grabbing the lock unless the queue is empty. */ - if (&an->an_swq_depth != 0) + if (an->an_swq_depth != 0) return; if (an->an_is_powersave && @@ -6511,6 +7254,6 @@ ath_node_recv_pspoll(struct ieee80211_node *ni, struct mbuf *m) MODULE_VERSION(if_ath, 1); MODULE_DEPEND(if_ath, wlan, 1, 1, 1); /* 802.11 media layer */ -#if defined(IEEE80211_ALQ) || defined(AH_DEBUG_ALQ) +#if defined(IEEE80211_ALQ) || defined(AH_DEBUG_ALQ) || defined(ATH_DEBUG_ALQ) MODULE_DEPEND(if_ath, alq, 1, 1, 1); #endif diff --git a/sys/dev/ath/if_ath_ahb.c b/sys/dev/ath/if_ath_ahb.c index 59593b6..ffe825d 100644 --- a/sys/dev/ath/if_ath_ahb.c +++ b/sys/dev/ath/if_ath_ahb.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/systm.h> +#include <sys/malloc.h> #include <sys/module.h> #include <sys/kernel.h> #include <sys/lock.h> @@ -55,6 +56,7 @@ __FBSDID("$FreeBSD$"); #include <net/if.h> #include <net/if_media.h> #include <net/if_arp.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> @@ -151,19 +153,30 @@ ath_ahb_attach(device_t dev) eepromsize = ATH_EEPROM_DATA_SIZE * 2; } - rid = 0; device_printf(sc->sc_dev, "eeprom @ %p (%d bytes)\n", (void *) eepromaddr, eepromsize); - psc->sc_eeprom = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, (uintptr_t) eepromaddr, - (uintptr_t) eepromaddr + (uintptr_t) (eepromsize - 1), 0, RF_ACTIVE); + /* + * XXX this assumes that the parent device is the nexus + * and will just pass through requests for all of memory. + * + * Later on, when this has to attach off of the actual + * AHB, this won't work. + * + * Ideally this would be done in machdep code in mips/atheros/ + * and it'd expose the EEPROM via the firmware interface, + * so the ath/ath_ahb drivers can be loaded as modules + * after boot-time. + */ + psc->sc_eeprom = bus_alloc_resource(dev, SYS_RES_MEMORY, + &rid, (uintptr_t) eepromaddr, + (uintptr_t) eepromaddr + (uintptr_t) (eepromsize - 1), 0, RF_ACTIVE); if (psc->sc_eeprom == NULL) { device_printf(dev, "cannot map eeprom space\n"); goto bad0; } - /* XXX uintptr_t is a bandaid for ia64; to be fixed */ - sc->sc_st = (HAL_BUS_TAG)(uintptr_t) rman_get_bustag(psc->sc_sr); + sc->sc_st = (HAL_BUS_TAG) rman_get_bustag(psc->sc_sr); sc->sc_sh = (HAL_BUS_HANDLE) rman_get_bushandle(psc->sc_sr); /* * Mark device invalid so any interrupts (shared or otherwise) @@ -348,6 +361,7 @@ static driver_t ath_ahb_driver = { }; static devclass_t ath_devclass; DRIVER_MODULE(ath, nexus, ath_ahb_driver, ath_devclass, 0, 0); +DRIVER_MODULE(ath, apb, ath_ahb_driver, ath_devclass, 0, 0); MODULE_VERSION(ath, 1); MODULE_DEPEND(ath, wlan, 1, 1, 1); /* 802.11 media layer */ MODULE_DEPEND(ath, if_ath, 1, 1, 1); /* if_ath driver */ diff --git a/sys/dev/ath/if_ath_beacon.c b/sys/dev/ath/if_ath_beacon.c index 11b0426..a672c71 100644 --- a/sys/dev/ath/if_ath_beacon.c +++ b/sys/dev/ath/if_ath_beacon.c @@ -73,6 +73,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -381,7 +382,7 @@ ath_beacon_update(struct ieee80211vap *vap, int item) /* * Handle a beacon miss. */ -static void +void ath_beacon_miss(struct ath_softc *sc) { HAL_SURVEY_SAMPLE hs; @@ -748,6 +749,11 @@ ath_beacon_generate(struct ath_softc *sc, struct ieee80211vap *vap) * * More thought is required here. */ + /* + * XXX can we even stop TX DMA here? Check what the + * reference driver does for cabq for beacons, given + * that stopping TX requires RX is paused. + */ ath_tx_draintxq(sc, cabq); } } @@ -915,7 +921,7 @@ ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap) struct ieee80211_node *ni; u_int32_t nexttbtt, intval, tsftu; u_int32_t nexttbtt_u8, intval_u8; - u_int64_t tsf; + u_int64_t tsf, tsf_beacon; if (vap == NULL) vap = TAILQ_FIRST(&ic->ic_vaps); /* XXX */ @@ -931,9 +937,17 @@ ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap) ni = ieee80211_ref_node(vap->iv_bss); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + /* extract tstamp from last beacon and convert to TU */ nexttbtt = TSF_TO_TU(LE_READ_4(ni->ni_tstamp.data + 4), LE_READ_4(ni->ni_tstamp.data)); + + tsf_beacon = ((uint64_t) LE_READ_4(ni->ni_tstamp.data + 4)) << 32; + tsf_beacon |= LE_READ_4(ni->ni_tstamp.data); + if (ic->ic_opmode == IEEE80211_M_HOSTAP || ic->ic_opmode == IEEE80211_M_MBSS) { /* @@ -979,14 +993,63 @@ ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap) */ tsf = ath_hal_gettsf64(ah); tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE; - do { - nexttbtt += intval; - if (--dtimcount < 0) { - dtimcount = dtimperiod - 1; - if (--cfpcount < 0) - cfpcount = cfpperiod - 1; + + DPRINTF(sc, ATH_DEBUG_BEACON, + "%s: beacon tsf=%llu, hw tsf=%llu, nexttbtt=%u, tsftu=%u\n", + __func__, + (unsigned long long) tsf_beacon, + (unsigned long long) tsf, + nexttbtt, + tsftu); + DPRINTF(sc, ATH_DEBUG_BEACON, + "%s: beacon tsf=%llu, hw tsf=%llu, tsf delta=%lld\n", + __func__, + (unsigned long long) tsf_beacon, + (unsigned long long) tsf, + (long long) tsf - + (long long) tsf_beacon); + + DPRINTF(sc, ATH_DEBUG_BEACON, + "%s: nexttbtt=%llu, beacon tsf delta=%lld\n", + __func__, + (unsigned long long) nexttbtt, + (long long) ((long long) nexttbtt * 1024LL) - (long long) tsf_beacon); + + /* XXX cfpcount? */ + + if (nexttbtt > tsftu) { + uint32_t countdiff, oldtbtt, remainder; + + oldtbtt = nexttbtt; + remainder = (nexttbtt - tsftu) % intval; + nexttbtt = tsftu + remainder; + + countdiff = (oldtbtt - nexttbtt) / intval % dtimperiod; + if (dtimcount > countdiff) { + dtimcount -= countdiff; + } else { + dtimcount += dtimperiod - countdiff; + } + } else { //nexttbtt <= tsftu + uint32_t countdiff, oldtbtt, remainder; + + oldtbtt = nexttbtt; + remainder = (tsftu - nexttbtt) % intval; + nexttbtt = tsftu - remainder + intval; + countdiff = (nexttbtt - oldtbtt) / intval % dtimperiod; + if (dtimcount > countdiff) { + dtimcount -= countdiff; + } else { + dtimcount += dtimperiod - countdiff; } - } while (nexttbtt < tsftu); + } + + DPRINTF(sc, ATH_DEBUG_BEACON, + "%s: adj nexttbtt=%llu, rx tsf delta=%lld\n", + __func__, + (unsigned long long) nexttbtt, + (long long) ((long long)nexttbtt * 1024LL) - (long long)tsf); + memset(&bs, 0, sizeof(bs)); bs.bs_intval = intval; bs.bs_nexttbtt = nexttbtt; @@ -1033,9 +1096,12 @@ ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap) bs.bs_sleepduration = roundup(bs.bs_sleepduration, bs.bs_dtimperiod); DPRINTF(sc, ATH_DEBUG_BEACON, - "%s: tsf %ju tsf:tu %u intval %u nexttbtt %u dtim %u nextdtim %u bmiss %u sleep %u cfp:period %u maxdur %u next %u timoffset %u\n" + "%s: tsf %ju tsf:tu %u intval %u nexttbtt %u dtim %u " + "nextdtim %u bmiss %u sleep %u cfp:period %u " + "maxdur %u next %u timoffset %u\n" , __func__ - , tsf, tsftu + , tsf + , tsftu , bs.bs_intval , bs.bs_nexttbtt , bs.bs_dtimperiod @@ -1112,8 +1178,11 @@ ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap) if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol) ath_beacon_start_adhoc(sc, vap); } - sc->sc_syncbeacon = 0; ieee80211_free_node(ni); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); #undef FUDGE #undef TSF_TO_TU } diff --git a/sys/dev/ath/if_ath_beacon.h b/sys/dev/ath/if_ath_beacon.h index f3f73d7..a940268 100644 --- a/sys/dev/ath/if_ath_beacon.h +++ b/sys/dev/ath/if_ath_beacon.h @@ -48,5 +48,7 @@ extern int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_node *ni); extern void ath_beacon_return(struct ath_softc *sc, struct ath_buf *bf); extern void ath_beacon_free(struct ath_softc *sc); extern void ath_beacon_proc(void *arg, int pending); +extern void ath_beacon_miss(struct ath_softc *sc); #endif + diff --git a/sys/dev/ath/if_ath_btcoex.c b/sys/dev/ath/if_ath_btcoex.c index fff6f3b..b78f866 100644 --- a/sys/dev/ath/if_ath_btcoex.c +++ b/sys/dev/ath/if_ath_btcoex.c @@ -44,6 +44,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <sys/kernel.h> #include <sys/lock.h> +#include <sys/malloc.h> #include <sys/mutex.h> #include <sys/errno.h> @@ -54,6 +55,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_arp.h> #include <net/ethernet.h> /* XXX for ether_sprintf */ @@ -186,6 +188,72 @@ ath_btcoex_cfg_wb225(struct ath_softc *sc) return (0); } +/* + * Initial AR9462 / (WB222) bluetooth coexistence settings, + * just for experimentation. + * + * Return 0 for OK; errno for error. + */ +static int +ath_btcoex_cfg_wb222(struct ath_softc *sc) +{ + HAL_BT_COEX_INFO btinfo; + HAL_BT_COEX_CONFIG btconfig; + struct ath_hal *ah = sc->sc_ah; + + if (! ath_hal_btcoex_supported(ah)) + return (EINVAL); + + bzero(&btinfo, sizeof(btinfo)); + bzero(&btconfig, sizeof(btconfig)); + + device_printf(sc->sc_dev, "Enabling WB222 BTCOEX\n"); + + btinfo.bt_module = HAL_BT_MODULE_JANUS; /* XXX not used? */ + btinfo.bt_coex_config = HAL_BT_COEX_CFG_MCI; + + /* + * MCI uses a completely different interface to speak + * to the bluetooth module - it's a command based + * thing over a serial line, rather than + * state pins to/from the bluetooth module. + * + * So, the GPIO configuration, polarity, etc + * doesn't matter on MCI devices; it's just + * completely ignored by the HAL. + */ + btinfo.bt_gpio_bt_active = 4; + btinfo.bt_gpio_bt_priority = 8; + btinfo.bt_gpio_wlan_active = 5; + + btinfo.bt_active_polarity = 1; /* XXX not used */ + btinfo.bt_single_ant = 0; /* 2 antenna on WB222 */ + btinfo.bt_isolation = 0; /* in dB, not used */ + + ath_hal_btcoex_set_info(ah, &btinfo); + + btconfig.bt_time_extend = 0; + btconfig.bt_txstate_extend = 1; /* true */ + btconfig.bt_txframe_extend = 1; /* true */ + btconfig.bt_mode = HAL_BT_COEX_MODE_SLOTTED; + btconfig.bt_quiet_collision = 1; /* true */ + btconfig.bt_rxclear_polarity = 1; /* true */ + btconfig.bt_priority_time = 2; + btconfig.bt_first_slot_time = 5; + btconfig.bt_hold_rxclear = 1; /* true */ + + ath_hal_btcoex_set_config(ah, &btconfig); + + /* + * Enable antenna diversity. + */ + ath_hal_btcoex_set_parameter(ah, HAL_BT_COEX_ANTENNA_DIVERSITY, 1); + + return (0); +} + + + #if 0 /* @@ -241,6 +309,8 @@ ath_btcoex_attach(struct ath_softc *sc) if (strncmp(profname, "wb195", 5) == 0) { ret = ath_btcoex_cfg_wb195(sc); + } else if (strncmp(profname, "wb222", 5) == 0) { + ret = ath_btcoex_cfg_wb222(sc); } else if (strncmp(profname, "wb225", 5) == 0) { ret = ath_btcoex_cfg_wb225(sc); } else { diff --git a/sys/dev/ath/if_ath_debug.c b/sys/dev/ath/if_ath_debug.c index e3c73f5..d21ad6f 100644 --- a/sys/dev/ath/if_ath_debug.c +++ b/sys/dev/ath/if_ath_debug.c @@ -92,9 +92,8 @@ __FBSDID("$FreeBSD$"); uint64_t ath_debug = 0; SYSCTL_DECL(_hw_ath); -SYSCTL_QUAD(_hw_ath, OID_AUTO, debug, CTLFLAG_RW, &ath_debug, +SYSCTL_QUAD(_hw_ath, OID_AUTO, debug, CTLFLAG_RWTUN, &ath_debug, 0, "control debugging printfs"); -TUNABLE_QUAD("hw.ath.debug", &ath_debug); void ath_printrxbuf(struct ath_softc *sc, const struct ath_buf *bf, diff --git a/sys/dev/ath/if_ath_debug.h b/sys/dev/ath/if_ath_debug.h index 83597af..40c0b9a 100644 --- a/sys/dev/ath/if_ath_debug.h +++ b/sys/dev/ath/if_ath_debug.h @@ -68,6 +68,7 @@ enum { ATH_DEBUG_SW_TX_FILT = 0x400000000ULL, /* SW TX FF */ ATH_DEBUG_NODE_PWRSAVE = 0x800000000ULL, /* node powersave */ ATH_DEBUG_DIVERSITY = 0x1000000000ULL, /* Diversity logic */ + ATH_DEBUG_PWRSAVE = 0x2000000000ULL, ATH_DEBUG_ANY = 0xffffffffffffffffULL }; diff --git a/sys/dev/ath/if_ath_keycache.c b/sys/dev/ath/if_ath_keycache.c index 6c2749f..fe99f10 100644 --- a/sys/dev/ath/if_ath_keycache.c +++ b/sys/dev/ath/if_ath_keycache.c @@ -62,6 +62,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -77,6 +78,7 @@ __FBSDID("$FreeBSD$"); #include <dev/ath/if_ath_debug.h> #include <dev/ath/if_ath_keycache.h> +#include <dev/ath/if_ath_misc.h> #ifdef ATH_DEBUG static void @@ -197,6 +199,7 @@ ath_keyset(struct ath_softc *sc, struct ieee80211vap *vap, u_int8_t gmac[IEEE80211_ADDR_LEN]; const u_int8_t *mac; HAL_KEYVAL hk; + int ret; memset(&hk, 0, sizeof(hk)); /* @@ -250,13 +253,19 @@ ath_keyset(struct ath_softc *sc, struct ieee80211vap *vap, } else mac = k->wk_macaddr; + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); if (hk.kv_type == HAL_CIPHER_TKIP && (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) { - return ath_keyset_tkip(sc, k, &hk, mac); + ret = ath_keyset_tkip(sc, k, &hk, mac); } else { KEYPRINTF(sc, k->wk_keyix, &hk, mac); - return ath_hal_keyset(ah, k->wk_keyix, &hk, mac); + ret = ath_hal_keyset(ah, k->wk_keyix, &hk, mac); } + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + + return (ret); #undef N } @@ -491,6 +500,8 @@ ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: delete key %u\n", __func__, keyix); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); ath_hal_keyreset(ah, keyix); /* * Handle split tx/rx keying required for TKIP with h/w MIC. @@ -514,6 +525,8 @@ ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) } } } + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); return 1; } diff --git a/sys/dev/ath/if_ath_led.c b/sys/dev/ath/if_ath_led.c index 33cc512..a55e036 100644 --- a/sys/dev/ath/if_ath_led.c +++ b/sys/dev/ath/if_ath_led.c @@ -122,6 +122,11 @@ __FBSDID("$FreeBSD$"); void ath_led_config(struct ath_softc *sc) { + + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + /* Software LED blinking - GPIO controlled LED */ if (sc->sc_softled) { ath_hal_gpioCfgOutput(sc->sc_ah, sc->sc_ledpin, @@ -144,6 +149,10 @@ ath_led_config(struct ath_softc *sc) ath_hal_gpioCfgOutput(sc->sc_ah, sc->sc_led_net_pin, HAL_GPIO_OUTPUT_MUX_MAC_NETWORK_LED); } + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); } static void diff --git a/sys/dev/ath/if_ath_lna_div.c b/sys/dev/ath/if_ath_lna_div.c index 4ae81a3..f0a33a5 100644 --- a/sys/dev/ath/if_ath_lna_div.c +++ b/sys/dev/ath/if_ath_lna_div.c @@ -44,6 +44,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <sys/kernel.h> #include <sys/lock.h> +#include <sys/malloc.h> #include <sys/mutex.h> #include <sys/errno.h> @@ -54,6 +55,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_arp.h> #include <net/ethernet.h> /* XXX for ether_sprintf */ @@ -207,6 +209,10 @@ bad: return (error); } +/* + * XXX need to low_rssi_thresh config from ath9k, to support CUS198 + * antenna diversity correctly. + */ static HAL_BOOL ath_is_alt_ant_ratio_better(int alt_ratio, int maxdelta, int mindelta, int main_rssi_avg, int alt_rssi_avg, int pkt_count) diff --git a/sys/dev/ath/if_ath_misc.h b/sys/dev/ath/if_ath_misc.h index 0c99bc7..711e69e8 100644 --- a/sys/dev/ath/if_ath_misc.h +++ b/sys/dev/ath/if_ath_misc.h @@ -128,6 +128,19 @@ extern void ath_start_task(void *arg, int npending); extern void ath_tx_dump(struct ath_softc *sc, struct ath_txq *txq); /* + * Power state tracking. + */ +extern void _ath_power_setpower(struct ath_softc *sc, int power_state, const char *file, int line); +extern void _ath_power_set_selfgen(struct ath_softc *sc, int power_state, const char *file, int line); +extern void _ath_power_set_power_state(struct ath_softc *sc, int power_state, const char *file, int line); +extern void _ath_power_restore_power_state(struct ath_softc *sc, const char *file, int line); + +#define ath_power_setpower(sc, ps) _ath_power_setpower(sc, ps, __FILE__, __LINE__) +#define ath_power_setselfgen(sc, ps) _ath_power_set_selfgen(sc, ps, __FILE__, __LINE__) +#define ath_power_set_power_state(sc, ps) _ath_power_set_power_state(sc, ps, __FILE__, __LINE__) +#define ath_power_restore_power_state(sc) _ath_power_restore_power_state(sc, __FILE__, __LINE__) + +/* * Kick the frame TX task. */ static inline void diff --git a/sys/dev/ath/if_ath_pci.c b/sys/dev/ath/if_ath_pci.c index 91cb425..5610882 100644 --- a/sys/dev/ath/if_ath_pci.c +++ b/sys/dev/ath/if_ath_pci.c @@ -37,6 +37,7 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/systm.h> +#include <sys/malloc.h> #include <sys/module.h> #include <sys/kernel.h> #include <sys/lock.h> @@ -53,6 +54,7 @@ __FBSDID("$FreeBSD$"); #include <net/if.h> #include <net/if_media.h> #include <net/if_arp.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> @@ -78,6 +80,98 @@ struct ath_pci_softc { void *sc_ih; /* interrupt handler */ }; +/* + * XXX eventually this should be some system level definition + * so modules will hvae probe/attach information like USB. + * But for now.. + */ +struct pci_device_id { + int vendor_id; + int device_id; + + int sub_vendor_id; + int sub_device_id; + + int driver_data; + + int match_populated:1; + int match_vendor_id:1; + int match_device_id:1; + int match_sub_vendor_id:1; + int match_sub_device_id:1; +}; + +#define PCI_VDEVICE(v, s) \ + .vendor_id = (v), \ + .device_id = (s), \ + .match_populated = 1, \ + .match_vendor_id = 1, \ + .match_device_id = 1 + +#define PCI_DEVICE_SUB(v, d, dv, ds) \ + .match_populated = 1, \ + .vendor_id = (v), .match_vendor_id = 1, \ + .device_id = (d), .match_device_id = 1, \ + .sub_vendor_id = (dv), .match_sub_vendor_id = 1, \ + .sub_device_id = (ds), .match_sub_device_id = 1 + +#define PCI_VENDOR_ID_ATHEROS 0x168c +#define PCI_VENDOR_ID_SAMSUNG 0x144d +#define PCI_VENDOR_ID_AZWAVE 0x1a3b +#define PCI_VENDOR_ID_FOXCONN 0x105b +#define PCI_VENDOR_ID_ATTANSIC 0x1969 +#define PCI_VENDOR_ID_ASUSTEK 0x1043 +#define PCI_VENDOR_ID_DELL 0x1028 +#define PCI_VENDOR_ID_QMI 0x1a32 +#define PCI_VENDOR_ID_LENOVO 0x17aa +#define PCI_VENDOR_ID_HP 0x103c + +#include "if_ath_pci_devlist.h" + +/* + * Attempt to find a match for the given device in + * the given device table. + * + * Returns the device structure or NULL if no matching + * PCI device is found. + */ +static const struct pci_device_id * +ath_pci_probe_device(device_t dev, const struct pci_device_id *dev_table, int nentries) +{ + int i; + int vendor_id, device_id; + int sub_vendor_id, sub_device_id; + + vendor_id = pci_get_vendor(dev); + device_id = pci_get_device(dev); + sub_vendor_id = pci_get_subvendor(dev); + sub_device_id = pci_get_subdevice(dev); + + for (i = 0; i < nentries; i++) { + /* Don't match on non-populated (eg empty) entries */ + if (! dev_table[i].match_populated) + continue; + + if (dev_table[i].match_vendor_id && + (dev_table[i].vendor_id != vendor_id)) + continue; + if (dev_table[i].match_device_id && + (dev_table[i].device_id != device_id)) + continue; + if (dev_table[i].match_sub_vendor_id && + (dev_table[i].sub_vendor_id != sub_vendor_id)) + continue; + if (dev_table[i].match_sub_device_id && + (dev_table[i].sub_device_id != sub_device_id)) + continue; + + /* Match */ + return (&dev_table[i]); + } + + return (NULL); +} + #define BS_BAR 0x10 #define PCIR_RETRY_TIMEOUT 0x41 #define PCIR_CFG_PMCSR 0x48 @@ -148,9 +242,15 @@ ath_pci_attach(device_t dev) const struct firmware *fw = NULL; const char *buf; #endif + const struct pci_device_id *pd; sc->sc_dev = dev; + /* Do this lookup anyway; figure out what to do with it later */ + pd = ath_pci_probe_device(dev, ath_pci_id_table, nitems(ath_pci_id_table)); + if (pd) + sc->sc_pci_devinfo = pd->driver_data; + /* * Enable bus mastering. */ @@ -171,8 +271,7 @@ ath_pci_attach(device_t dev) device_printf(dev, "cannot map register space\n"); goto bad; } - /* XXX uintptr_t is a bandaid for ia64; to be fixed */ - sc->sc_st = (HAL_BUS_TAG)(uintptr_t) rman_get_bustag(psc->sc_sr); + sc->sc_st = (HAL_BUS_TAG) rman_get_bustag(psc->sc_sr); sc->sc_sh = (HAL_BUS_HANDLE) rman_get_bushandle(psc->sc_sr); /* * Mark device invalid so any interrupts (shared or otherwise) @@ -180,6 +279,13 @@ ath_pci_attach(device_t dev) */ sc->sc_invalid = 1; + ATH_LOCK_INIT(sc); + ATH_PCU_LOCK_INIT(sc); + ATH_RX_LOCK_INIT(sc); + ATH_TX_LOCK_INIT(sc); + ATH_TX_IC_LOCK_INIT(sc); + ATH_TXSTATUS_LOCK_INIT(sc); + /* * Arrange interrupt line. */ @@ -230,7 +336,7 @@ ath_pci_attach(device_t dev) if (fw == NULL) { device_printf(dev, "%s: couldn't find firmware\n", __func__); - goto bad3; + goto bad4; } device_printf(dev, "%s: EEPROM firmware @ %p\n", @@ -240,30 +346,20 @@ ath_pci_attach(device_t dev) if (! sc->sc_eepromdata) { device_printf(dev, "%s: can't malloc eepromdata\n", __func__); - goto bad3; + goto bad4; } memcpy(sc->sc_eepromdata, fw->data, fw->datasize); firmware_put(fw, 0); } #endif /* ATH_EEPROM_FIRMWARE */ - ATH_LOCK_INIT(sc); - ATH_PCU_LOCK_INIT(sc); - ATH_RX_LOCK_INIT(sc); - ATH_TX_LOCK_INIT(sc); - ATH_TX_IC_LOCK_INIT(sc); - ATH_TXSTATUS_LOCK_INIT(sc); - error = ath_attach(pci_get_device(dev), sc); if (error == 0) /* success */ return 0; - ATH_TXSTATUS_LOCK_DESTROY(sc); - ATH_PCU_LOCK_DESTROY(sc); - ATH_RX_LOCK_DESTROY(sc); - ATH_TX_IC_LOCK_DESTROY(sc); - ATH_TX_LOCK_DESTROY(sc); - ATH_LOCK_DESTROY(sc); +#ifdef ATH_EEPROM_FIRMWARE +bad4: +#endif bus_dma_tag_destroy(sc->sc_dmat); bad3: bus_teardown_intr(dev, psc->sc_irq, psc->sc_ih); @@ -271,6 +367,14 @@ bad2: bus_release_resource(dev, SYS_RES_IRQ, 0, psc->sc_irq); bad1: bus_release_resource(dev, SYS_RES_MEMORY, BS_BAR, psc->sc_sr); + + ATH_TXSTATUS_LOCK_DESTROY(sc); + ATH_PCU_LOCK_DESTROY(sc); + ATH_RX_LOCK_DESTROY(sc); + ATH_TX_IC_LOCK_DESTROY(sc); + ATH_TX_LOCK_DESTROY(sc); + ATH_LOCK_DESTROY(sc); + bad: return (error); } diff --git a/sys/dev/ath/if_ath_pci_devlist.h b/sys/dev/ath/if_ath_pci_devlist.h new file mode 100644 index 0000000..ae65909 --- /dev/null +++ b/sys/dev/ath/if_ath_pci_devlist.h @@ -0,0 +1,669 @@ +/*- + * Copyright (c) 2014 Qualcomm Atheros. + * 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, + * without modification. + * 2. Redistributions in binary form must reproduce at minimum a disclaimer + * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any + * redistribution must be conditioned upon including a substantially + * similar Disclaimer requirement for further binary redistribution. + * + * NO WARRANTY + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY + * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES. + * + * $FreeBSD$ + */ + +static const struct pci_device_id ath_pci_id_table[] = { + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0023) }, /* PCI */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0024) }, /* PCI-E */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0027) }, /* PCI */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0029) }, /* PCI */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x002A) }, /* PCI-E */ + + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + PCI_VENDOR_ID_AZWAVE, + 0x1C71), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + PCI_VENDOR_ID_FOXCONN, + 0xE01F), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + 0x11AD, /* LITEON */ + 0x6632), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + 0x11AD, /* LITEON */ + 0x6642), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + PCI_VENDOR_ID_QMI, + 0x0306), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + 0x185F, /* WNC */ + 0x309D), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + 0x10CF, /* Fujitsu */ + 0x147C), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + 0x10CF, /* Fujitsu */ + 0x147D), + .driver_data = ATH_PCI_D3_L1_WAR }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002A, + 0x10CF, /* Fujitsu */ + 0x1536), + .driver_data = ATH_PCI_D3_L1_WAR }, + + /* AR9285 card for Asus */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x002B, + PCI_VENDOR_ID_AZWAVE, + 0x2C37), + .driver_data = ATH_PCI_BT_ANT_DIV }, + + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x002B) }, /* PCI-E */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x002C) }, /* PCI-E 802.11n bonded out */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x002D) }, /* PCI */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x002E) }, /* PCI-E */ + + /* Killer Wireless (3x3) */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0030, + 0x1A56, + 0x2000), + .driver_data = ATH_PCI_KILLER }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0030, + 0x1A56, + 0x2001), + .driver_data = ATH_PCI_KILLER }, + + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0030) }, /* PCI-E AR9300 */ + + /* PCI-E CUS198 */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x2086), + .driver_data = ATH_PCI_CUS198 | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x1237), + .driver_data = ATH_PCI_CUS198 | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x2126), + .driver_data = ATH_PCI_CUS198 | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x126A), + .driver_data = ATH_PCI_CUS198 | ATH_PCI_BT_ANT_DIV }, + + /* PCI-E CUS230 */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x2152), + .driver_data = ATH_PCI_CUS230 | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_FOXCONN, + 0xE075), + .driver_data = ATH_PCI_CUS230 | ATH_PCI_BT_ANT_DIV }, + + /* WB225 */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_ATHEROS, + 0x3119), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_ATHEROS, + 0x3122), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x185F, /* WNC */ + 0x3119), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x185F, /* WNC */ + 0x3027), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0x4105), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0x4106), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0x410D), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0x410E), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0x410F), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0xC706), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0xC680), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_SAMSUNG, + 0xC708), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_LENOVO, + 0x3218), + .driver_data = ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_LENOVO, + 0x3219), + .driver_data = ATH_PCI_BT_ANT_DIV }, + + /* AR9485 cards with PLL power-save disabled by default. */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x2C97), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x2100), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x1C56, /* ASKEY */ + 0x4001), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x11AD, /* LITEON */ + 0x6627), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x11AD, /* LITEON */ + 0x6628), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_FOXCONN, + 0xE04E), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_FOXCONN, + 0xE04F), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x144F, /* ASKEY */ + 0x7197), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x1B9A, /* XAVI */ + 0x2000), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x1B9A, /* XAVI */ + 0x2001), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x1186), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x1F86), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x1195), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_AZWAVE, + 0x1F95), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x1B9A, /* XAVI */ + 0x1C00), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + 0x1B9A, /* XAVI */ + 0x1C01), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0032, + PCI_VENDOR_ID_ASUSTEK, + 0x850D), + .driver_data = ATH_PCI_NO_PLL_PWRSAVE }, + + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0032) }, /* PCI-E AR9485 */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0033) }, /* PCI-E AR9580 */ + + /* PCI-E CUS217 */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_AZWAVE, + 0x2116), + .driver_data = ATH_PCI_CUS217 }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + 0x11AD, /* LITEON */ + 0x6661), + .driver_data = ATH_PCI_CUS217 }, + + /* AR9462 with WoW support */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_ATHEROS, + 0x3117), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_LENOVO, + 0x3214), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_ATTANSIC, + 0x0091), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_AZWAVE, + 0x2110), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_ASUSTEK, + 0x850E), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + 0x11AD, /* LITEON */ + 0x6631), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + 0x11AD, /* LITEON */ + 0x6641), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + PCI_VENDOR_ID_HP, + 0x1864), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + 0x14CD, /* USI */ + 0x0063), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + 0x14CD, /* USI */ + 0x0064), + .driver_data = ATH_PCI_WOW }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0034, + 0x10CF, /* Fujitsu */ + 0x1783), + .driver_data = ATH_PCI_WOW }, + + /* Killer Wireless (2x2) */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0030, + 0x1A56, + 0x2003), + .driver_data = ATH_PCI_KILLER }, + + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0034) }, /* PCI-E AR9462 */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0037) }, /* PCI-E AR1111/AR9485 */ + + /* CUS252 */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ATHEROS, + 0x3028), + .driver_data = ATH_PCI_CUS252 | + ATH_PCI_AR9565_2ANT | + ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_AZWAVE, + 0x2176), + .driver_data = ATH_PCI_CUS252 | + ATH_PCI_AR9565_2ANT | + ATH_PCI_BT_ANT_DIV }, + + /* WB335 1-ANT */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_FOXCONN, + 0xE068), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x185F, /* WNC */ + 0xA119), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0632), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x06B2), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0842), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x6671), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x1B9A, /* XAVI */ + 0x2811), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x1B9A, /* XAVI */ + 0x2812), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x1B9A, /* XAVI */ + 0x28A1), + .driver_data = ATH_PCI_AR9565_1ANT }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_AZWAVE, + 0x218A), + .driver_data = ATH_PCI_AR9565_1ANT }, + + /* WB335 1-ANT / Antenna Diversity */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ATHEROS, + 0x3025), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ATHEROS, + 0x3026), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ATHEROS, + 0x302B), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_FOXCONN, + 0xE069), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x185F, /* WNC */ + 0x3028), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0622), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0672), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0662), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x06A2), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0682), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_AZWAVE, + 0x213A), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_HP, + 0x18E3), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_HP, + 0x217F), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_HP, + 0x2005), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_DELL, + 0x020C), + .driver_data = ATH_PCI_AR9565_1ANT | ATH_PCI_BT_ANT_DIV }, + + /* WB335 2-ANT / Antenna-Diversity */ + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_SAMSUNG, + 0x411A), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_SAMSUNG, + 0x411B), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_SAMSUNG, + 0x411C), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_SAMSUNG, + 0x411D), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_SAMSUNG, + 0x411E), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ATHEROS, + 0x3027), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ATHEROS, + 0x302C), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0642), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0652), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0612), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0832), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x11AD, /* LITEON */ + 0x0692), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_AZWAVE, + 0x2130), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_AZWAVE, + 0x213B), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_AZWAVE, + 0x2182), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x144F, /* ASKEY */ + 0x7202), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x1B9A, /* XAVI */ + 0x2810), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x1B9A, /* XAVI */ + 0x28A2), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x185F, /* WNC */ + 0x3027), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + 0x185F, /* WNC */ + 0xA120), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_FOXCONN, + 0xE07F), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_FOXCONN, + 0xE081), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_LENOVO, + 0x3026), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_LENOVO, + 0x4026), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_ASUSTEK, + 0x85F2), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, + 0x0036, + PCI_VENDOR_ID_DELL, + 0x020E), + .driver_data = ATH_PCI_AR9565_2ANT | ATH_PCI_BT_ANT_DIV }, + + /* PCI-E AR9565 (WB335) */ + { PCI_VDEVICE(PCI_VENDOR_ID_ATHEROS, 0x0036), + .driver_data = ATH_PCI_BT_ANT_DIV }, + + { 0 } +}; + diff --git a/sys/dev/ath/if_ath_rx.c b/sys/dev/ath/if_ath_rx.c index d9e212b..bed9488 100644 --- a/sys/dev/ath/if_ath_rx.c +++ b/sys/dev/ath/if_ath_rx.c @@ -73,6 +73,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -165,10 +166,22 @@ ath_calcrxfilter(struct ath_softc *sc) /* XXX ic->ic_monvaps != 0? */ if (ic->ic_opmode == IEEE80211_M_MONITOR || (ifp->if_flags & IFF_PROMISC)) rfilt |= HAL_RX_FILTER_PROM; + + /* + * Only listen to all beacons if we're scanning. + * + * Otherwise we only really need to hear beacons from + * our own BSSID. + */ if (ic->ic_opmode == IEEE80211_M_STA || - ic->ic_opmode == IEEE80211_M_IBSS || - sc->sc_swbmiss || sc->sc_scanning) - rfilt |= HAL_RX_FILTER_BEACON; + ic->ic_opmode == IEEE80211_M_IBSS || sc->sc_swbmiss) { + if (sc->sc_do_mybeacon && ! sc->sc_scanning) { + rfilt |= HAL_RX_FILTER_MYBEACON; + } else { /* scanning, non-mybeacon chips */ + rfilt |= HAL_RX_FILTER_BEACON; + } + } + /* * NB: We don't recalculate the rx filter when * ic_protmode changes; otherwise we could do @@ -232,6 +245,8 @@ ath_legacy_rxbuf_init(struct ath_softc *sc, struct ath_buf *bf) struct mbuf *m; struct ath_desc *ds; + /* XXX TODO: ATH_RX_LOCK_ASSERT(sc); */ + m = bf->bf_m; if (m == NULL) { /* @@ -316,6 +331,23 @@ ath_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, { struct ieee80211vap *vap = ni->ni_vap; struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc; + uint64_t tsf_beacon_old, tsf_beacon; + uint64_t nexttbtt; + int64_t tsf_delta; + int32_t tsf_delta_bmiss; + int32_t tsf_remainder; + uint64_t tsf_beacon_target; + int tsf_intval; + + tsf_beacon_old = ((uint64_t) LE_READ_4(ni->ni_tstamp.data + 4)) << 32; + tsf_beacon_old |= LE_READ_4(ni->ni_tstamp.data); + +#define TU_TO_TSF(_tu) (((u_int64_t)(_tu)) << 10) + tsf_intval = 1; + if (ni->ni_intval > 0) { + tsf_intval = TU_TO_TSF(ni->ni_intval); + } +#undef TU_TO_TSF /* * Call up first so subsequent work can use information @@ -327,14 +359,79 @@ ath_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, /* update rssi statistics for use by the hal */ /* XXX unlocked check against vap->iv_bss? */ ATH_RSSI_LPF(sc->sc_halstats.ns_avgbrssi, rssi); + + tsf_beacon = ((uint64_t) LE_READ_4(ni->ni_tstamp.data + 4)) << 32; + tsf_beacon |= LE_READ_4(ni->ni_tstamp.data); + + nexttbtt = ath_hal_getnexttbtt(sc->sc_ah); + + /* + * Let's calculate the delta and remainder, so we can see + * if the beacon timer from the AP is varying by more than + * a few TU. (Which would be a huge, huge problem.) + */ + tsf_delta = (long long) tsf_beacon - (long long) tsf_beacon_old; + + tsf_delta_bmiss = tsf_delta / tsf_intval; + + /* + * If our delta is greater than half the beacon interval, + * let's round the bmiss value up to the next beacon + * interval. Ie, we're running really, really early + * on the next beacon. + */ + if (tsf_delta % tsf_intval > (tsf_intval / 2)) + tsf_delta_bmiss ++; + + tsf_beacon_target = tsf_beacon_old + + (((unsigned long long) tsf_delta_bmiss) * (long long) tsf_intval); + + /* + * The remainder using '%' is between 0 .. intval-1. + * If we're actually running too fast, then the remainder + * will be some large number just under intval-1. + * So we need to look at whether we're running + * before or after the target beacon interval + * and if we are, modify how we do the remainder + * calculation. + */ + if (tsf_beacon < tsf_beacon_target) { + tsf_remainder = + -(tsf_intval - ((tsf_beacon - tsf_beacon_old) % tsf_intval)); + } else { + tsf_remainder = (tsf_beacon - tsf_beacon_old) % tsf_intval; + } + + DPRINTF(sc, ATH_DEBUG_BEACON, "%s: old_tsf=%llu, new_tsf=%llu, target_tsf=%llu, delta=%lld, bmiss=%d, remainder=%d\n", + __func__, + (unsigned long long) tsf_beacon_old, + (unsigned long long) tsf_beacon, + (unsigned long long) tsf_beacon_target, + (long long) tsf_delta, + tsf_delta_bmiss, + tsf_remainder); + + DPRINTF(sc, ATH_DEBUG_BEACON, "%s: tsf=%llu, nexttbtt=%llu, delta=%d\n", + __func__, + (unsigned long long) tsf_beacon, + (unsigned long long) nexttbtt, + (int32_t) tsf_beacon - (int32_t) nexttbtt + tsf_intval); + if (sc->sc_syncbeacon && - ni == vap->iv_bss && vap->iv_state == IEEE80211_S_RUN) { + ni == vap->iv_bss && + (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) { + DPRINTF(sc, ATH_DEBUG_BEACON, + "%s: syncbeacon=1; syncing\n", + __func__); /* * Resync beacon timers using the tsf of the beacon * frame we just received. */ ath_beacon_config(sc, vap); + sc->sc_syncbeacon = 0; } + + /* fall thru... */ case IEEE80211_FC0_SUBTYPE_PROBE_RESP: if (vap->iv_opmode == IEEE80211_M_IBSS && @@ -607,7 +704,7 @@ ath_rx_pkt(struct ath_softc *sc, struct ath_rx_status *rs, HAL_STATUS status, rs->rs_keyix-32 : rs->rs_keyix); } } - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); rx_error: /* * Cleanup any pending partial frame. @@ -733,7 +830,7 @@ rx_accept: rs->rs_antenna |= 0x4; } - ifp->if_ipackets++; + if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); sc->sc_stats.ast_ant_rx[rs->rs_antenna]++; /* @@ -879,6 +976,14 @@ rx_next: #define ATH_RX_MAX 128 +/* + * XXX TODO: break out the "get buffers" from "call ath_rx_pkt()" like + * the EDMA code does. + * + * XXX TODO: then, do all of the RX list management stuff inside + * ATH_RX_LOCK() so we don't end up potentially racing. The EDMA + * code is doing it right. + */ static void ath_rx_proc(struct ath_softc *sc, int resched) { @@ -900,6 +1005,7 @@ ath_rx_proc(struct ath_softc *sc, int resched) u_int64_t tsf; int npkts = 0; int kickpcu = 0; + int ret; /* XXX we must not hold the ATH_LOCK here */ ATH_UNLOCK_ASSERT(sc); @@ -910,6 +1016,10 @@ ath_rx_proc(struct ath_softc *sc, int resched) kickpcu = sc->sc_kickpcu; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + DPRINTF(sc, ATH_DEBUG_RX_PROC, "%s: called\n", __func__); ngood = 0; nf = ath_hal_getchannoise(ah, sc->sc_curchan); @@ -995,8 +1105,26 @@ ath_rx_proc(struct ath_softc *sc, int resched) if (ath_rx_pkt(sc, rs, status, tsf, nf, HAL_RX_QUEUE_HP, bf, m)) ngood++; rx_proc_next: - TAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list); - } while (ath_rxbuf_init(sc, bf) == 0); + /* + * If there's a holding buffer, insert that onto + * the RX list; the hardware is now definitely not pointing + * to it now. + */ + ret = 0; + if (sc->sc_rxedma[HAL_RX_QUEUE_HP].m_holdbf != NULL) { + TAILQ_INSERT_TAIL(&sc->sc_rxbuf, + sc->sc_rxedma[HAL_RX_QUEUE_HP].m_holdbf, + bf_list); + ret = ath_rxbuf_init(sc, + sc->sc_rxedma[HAL_RX_QUEUE_HP].m_holdbf); + } + /* + * Next, throw our buffer into the holding entry. The hardware + * may use the descriptor to read the link pointer before + * DMAing the next descriptor in to write out a packet. + */ + sc->sc_rxedma[HAL_RX_QUEUE_HP].m_holdbf = bf; + } while (ret == 0); /* rx signal state monitoring */ ath_hal_rxmonitor(ah, &sc->sc_halstats, sc->sc_curchan); @@ -1028,6 +1156,13 @@ rx_proc_next: * constantly write over the same frame, leading * the RX driver code here to get heavily confused. */ + /* + * XXX Has RX DMA stopped enough here to just call + * ath_startrecv()? + * XXX Do we need to use the holding buffer to restart + * RX DMA by appending entries to the final + * descriptor? Quite likely. + */ #if 1 ath_startrecv(sc); #else @@ -1065,6 +1200,13 @@ rx_proc_next: #undef PA2DESC /* + * Put the hardware to sleep again if we're done with it. + */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + + /* * If we hit the maximum number of frames in this round, * reschedule for another immediate pass. This gives * the TX and TX completion routines time to run, which @@ -1111,6 +1253,58 @@ ath_legacy_flushrecv(struct ath_softc *sc) ath_rx_proc(sc, 0); } +static void +ath_legacy_flush_rxpending(struct ath_softc *sc) +{ + + /* XXX ATH_RX_LOCK_ASSERT(sc); */ + + if (sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending != NULL) { + m_freem(sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending); + sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending = NULL; + } + if (sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending != NULL) { + m_freem(sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending); + sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending = NULL; + } +} + +static int +ath_legacy_flush_rxholdbf(struct ath_softc *sc) +{ + struct ath_buf *bf; + + /* XXX ATH_RX_LOCK_ASSERT(sc); */ + /* + * If there are RX holding buffers, free them here and return + * them to the list. + * + * XXX should just verify that bf->bf_m is NULL, as it must + * be at this point! + */ + bf = sc->sc_rxedma[HAL_RX_QUEUE_HP].m_holdbf; + if (bf != NULL) { + if (bf->bf_m != NULL) + m_freem(bf->bf_m); + bf->bf_m = NULL; + TAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list); + (void) ath_rxbuf_init(sc, bf); + } + sc->sc_rxedma[HAL_RX_QUEUE_HP].m_holdbf = NULL; + + bf = sc->sc_rxedma[HAL_RX_QUEUE_LP].m_holdbf; + if (bf != NULL) { + if (bf->bf_m != NULL) + m_freem(bf->bf_m); + bf->bf_m = NULL; + TAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list); + (void) ath_rxbuf_init(sc, bf); + } + sc->sc_rxedma[HAL_RX_QUEUE_LP].m_holdbf = NULL; + + return (0); +} + /* * Disable the receive h/w in preparation for a reset. */ @@ -1122,6 +1316,8 @@ ath_legacy_stoprecv(struct ath_softc *sc, int dodelay) ((_pa) - (_sc)->sc_rxdma.dd_desc_paddr))) struct ath_hal *ah = sc->sc_ah; + ATH_RX_LOCK(sc); + ath_hal_stoppcurecv(ah); /* disable PCU */ ath_hal_setrxfilter(ah, 0); /* clear recv filter */ ath_hal_stopdmarecv(ah); /* disable DMA engine */ @@ -1155,22 +1351,23 @@ ath_legacy_stoprecv(struct ath_softc *sc, int dodelay) } } #endif - /* - * Free both high/low RX pending, just in case. - */ - if (sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending != NULL) { - m_freem(sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending); - sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending = NULL; - } - if (sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending != NULL) { - m_freem(sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending); - sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending = NULL; - } + + (void) ath_legacy_flush_rxpending(sc); + (void) ath_legacy_flush_rxholdbf(sc); + sc->sc_rxlink = NULL; /* just in case */ + + ATH_RX_UNLOCK(sc); #undef PA2DESC } /* + * XXX TODO: something was calling startrecv without calling + * stoprecv. Let's figure out what/why. It was showing up + * as a mbuf leak (rxpending) and ath_buf leak (holdbf.) + */ + +/* * Enable the receive h/w following a reset. */ static int @@ -1179,9 +1376,18 @@ ath_legacy_startrecv(struct ath_softc *sc) struct ath_hal *ah = sc->sc_ah; struct ath_buf *bf; + ATH_RX_LOCK(sc); + + /* + * XXX should verify these are already all NULL! + */ sc->sc_rxlink = NULL; - sc->sc_rxedma[HAL_RX_QUEUE_LP].m_rxpending = NULL; - sc->sc_rxedma[HAL_RX_QUEUE_HP].m_rxpending = NULL; + (void) ath_legacy_flush_rxpending(sc); + (void) ath_legacy_flush_rxholdbf(sc); + + /* + * Re-chain all of the buffers in the RX buffer list. + */ TAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list) { int error = ath_rxbuf_init(sc, bf); if (error != 0) { @@ -1197,6 +1403,8 @@ ath_legacy_startrecv(struct ath_softc *sc) ath_hal_rxena(ah); /* enable recv descriptors */ ath_mode_init(sc); /* set filters, etc. */ ath_hal_startpcurecv(ah); /* re-enable PCU/DMA engine */ + + ATH_RX_UNLOCK(sc); return 0; } diff --git a/sys/dev/ath/if_ath_rx_edma.c b/sys/dev/ath/if_ath_rx_edma.c index 2be8627..7aa818f 100644 --- a/sys/dev/ath/if_ath_rx_edma.c +++ b/sys/dev/ath/if_ath_rx_edma.c @@ -73,6 +73,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -159,10 +160,20 @@ ath_edma_stoprecv(struct ath_softc *sc, int dodelay) struct ath_hal *ah = sc->sc_ah; ATH_RX_LOCK(sc); + ath_hal_stoppcurecv(ah); ath_hal_setrxfilter(ah, 0); - ath_hal_stopdmarecv(ah); + /* + * + */ + if (ath_hal_stopdmarecv(ah) == AH_TRUE) + sc->sc_rx_stopped = 1; + + /* + * Give the various bus FIFOs (not EDMA descriptor FIFO) + * time to finish flushing out data. + */ DELAY(3000); /* Flush RX pending for each queue */ @@ -217,10 +228,6 @@ ath_edma_reinit_fifo(struct ath_softc *sc, HAL_RX_QUEUE qtype) /* * Start receive. - * - * XXX TODO: this needs to reallocate the FIFO entries when a reset - * occurs, in case the FIFO is filled up and no new descriptors get - * thrown into the FIFO. */ static int ath_edma_startrecv(struct ath_softc *sc) @@ -229,35 +236,31 @@ ath_edma_startrecv(struct ath_softc *sc) ATH_RX_LOCK(sc); + /* + * Sanity check - are we being called whilst RX + * isn't stopped? If so, we may end up pushing + * too many entries into the RX FIFO and + * badness occurs. + */ + /* Enable RX FIFO */ ath_hal_rxena(ah); /* - * Entries should only be written out if the - * FIFO is empty. - * - * XXX This isn't correct. I should be looking - * at the value of AR_RXDP_SIZE (0x0070) to determine - * how many entries are in here. - * - * A warm reset will clear the registers but not the FIFO. - * - * And I believe this is actually the address of the last - * handled buffer rather than the current FIFO pointer. - * So if no frames have been (yet) seen, we'll reinit the - * FIFO. - * - * I'll chase that up at some point. + * In theory the hardware has been initialised, right? */ - if (ath_hal_getrxbuf(sc->sc_ah, HAL_RX_QUEUE_HP) == 0) { + if (sc->sc_rx_resetted == 1) { DPRINTF(sc, ATH_DEBUG_EDMA_RX, "%s: Re-initing HP FIFO\n", __func__); ath_edma_reinit_fifo(sc, HAL_RX_QUEUE_HP); - } - if (ath_hal_getrxbuf(sc->sc_ah, HAL_RX_QUEUE_LP) == 0) { DPRINTF(sc, ATH_DEBUG_EDMA_RX, "%s: Re-initing LP FIFO\n", __func__); ath_edma_reinit_fifo(sc, HAL_RX_QUEUE_LP); + sc->sc_rx_resetted = 0; + } else { + device_printf(sc->sc_dev, + "%s: called without resetting chip?\n", + __func__); } /* Add up to m_fifolen entries in each queue */ @@ -265,6 +268,9 @@ ath_edma_startrecv(struct ath_softc *sc) * These must occur after the above write so the FIFO buffers * are pushed/tracked in the same order as the hardware will * process them. + * + * XXX TODO: is this really necessary? We should've stopped + * the hardware already and reinitialised it, so it's a no-op. */ ath_edma_rxfifo_alloc(sc, HAL_RX_QUEUE_HP, sc->sc_rxedma[HAL_RX_QUEUE_HP].m_fifolen); @@ -275,6 +281,11 @@ ath_edma_startrecv(struct ath_softc *sc) ath_mode_init(sc); ath_hal_startpcurecv(ah); + /* + * We're now doing RX DMA! + */ + sc->sc_rx_stopped = 0; + ATH_RX_UNLOCK(sc); return (0); @@ -285,7 +296,16 @@ ath_edma_recv_sched_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, int dosched) { + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ath_edma_recv_proc_queue(sc, qtype, dosched); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask); } @@ -293,8 +313,17 @@ static void ath_edma_recv_sched(struct ath_softc *sc, int dosched) { + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ath_edma_recv_proc_queue(sc, HAL_RX_QUEUE_HP, dosched); ath_edma_recv_proc_queue(sc, HAL_RX_QUEUE_LP, dosched); + + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask); } @@ -308,6 +337,10 @@ ath_edma_recv_flush(struct ath_softc *sc) sc->sc_rxproc_cnt++; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + /* * Flush any active frames from FIFO -> deferred list */ @@ -317,9 +350,18 @@ ath_edma_recv_flush(struct ath_softc *sc) /* * Process what's in the deferred queue */ + /* + * XXX: If we read the tsf/channoise here and then pass it in, + * we could restore the power state before processing + * the deferred queue. + */ ath_edma_recv_proc_deferred_queue(sc, HAL_RX_QUEUE_HP, 0); ath_edma_recv_proc_deferred_queue(sc, HAL_RX_QUEUE_LP, 0); + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + ATH_PCU_LOCK(sc); sc->sc_rxproc_cnt--; ATH_PCU_UNLOCK(sc); @@ -348,6 +390,21 @@ ath_edma_recv_proc_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, ATH_RX_LOCK(sc); +#if 1 + if (sc->sc_rx_resetted == 1) { + /* + * XXX We shouldn't ever be scheduled if + * receive has been stopped - so complain + * loudly! + */ + device_printf(sc->sc_dev, + "%s: sc_rx_resetted=1! Bad!\n", + __func__); + ATH_RX_UNLOCK(sc); + return; + } +#endif + do { bf = re->m_fifo[re->m_fifo_head]; /* This shouldn't occur! */ @@ -419,24 +476,6 @@ ath_edma_recv_proc_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, "ath edma rx proc: npkts=%d\n", npkts); - /* Handle resched and kickpcu appropriately */ - ATH_PCU_LOCK(sc); - if (dosched && sc->sc_kickpcu) { - ATH_KTR(sc, ATH_KTR_ERROR, 0, - "ath_edma_recv_proc_queue(): kickpcu"); - 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 - * re-enable the RX FIFO? - */ - sc->sc_kickpcu = 0; - } - ATH_PCU_UNLOCK(sc); - return; } @@ -449,18 +488,20 @@ ath_edma_recv_proc_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, static void ath_edma_flush_deferred_queue(struct ath_softc *sc) { - struct ath_buf *bf, *next; + struct ath_buf *bf; ATH_RX_LOCK_ASSERT(sc); /* Free in one set, inside the lock */ - TAILQ_FOREACH_SAFE(bf, - &sc->sc_rx_rxlist[HAL_RX_QUEUE_LP], bf_list, next) { + while (! TAILQ_EMPTY(&sc->sc_rx_rxlist[HAL_RX_QUEUE_LP])) { + bf = TAILQ_FIRST(&sc->sc_rx_rxlist[HAL_RX_QUEUE_LP]); + TAILQ_REMOVE(&sc->sc_rx_rxlist[HAL_RX_QUEUE_LP], bf, bf_list); /* Free the buffer/mbuf */ ath_edma_rxbuf_free(sc, bf); } - TAILQ_FOREACH_SAFE(bf, - &sc->sc_rx_rxlist[HAL_RX_QUEUE_HP], bf_list, next) { + while (! TAILQ_EMPTY(&sc->sc_rx_rxlist[HAL_RX_QUEUE_HP])) { + bf = TAILQ_FIRST(&sc->sc_rx_rxlist[HAL_RX_QUEUE_HP]); + TAILQ_REMOVE(&sc->sc_rx_rxlist[HAL_RX_QUEUE_HP], bf, bf_list); /* Free the buffer/mbuf */ ath_edma_rxbuf_free(sc, bf); } @@ -494,6 +535,10 @@ ath_edma_recv_proc_deferred_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, ATH_RX_UNLOCK(sc); /* Handle the completed descriptors */ + /* + * XXX is this SAFE call needed? The ath_buf entries + * aren't modified by ath_rx_pkt, right? + */ TAILQ_FOREACH_SAFE(bf, &rxlist, bf_list, next) { /* * Skip the RX descriptor status - start at the data offset @@ -519,7 +564,9 @@ ath_edma_recv_proc_deferred_queue(struct ath_softc *sc, HAL_RX_QUEUE qtype, /* Free in one set, inside the lock */ ATH_RX_LOCK(sc); - TAILQ_FOREACH_SAFE(bf, &rxlist, bf_list, next) { + while (! TAILQ_EMPTY(&rxlist)) { + bf = TAILQ_FIRST(&rxlist); + TAILQ_REMOVE(&rxlist, bf, bf_list); /* Free the buffer/mbuf */ ath_edma_rxbuf_free(sc, bf); } @@ -551,12 +598,25 @@ ath_edma_recv_tasklet(void *arg, int npending) sc->sc_rxproc_cnt++; ATH_PCU_UNLOCK(sc); + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ath_edma_recv_proc_queue(sc, HAL_RX_QUEUE_HP, 1); ath_edma_recv_proc_queue(sc, HAL_RX_QUEUE_LP, 1); ath_edma_recv_proc_deferred_queue(sc, HAL_RX_QUEUE_HP, 1); ath_edma_recv_proc_deferred_queue(sc, HAL_RX_QUEUE_LP, 1); + /* + * XXX: If we read the tsf/channoise here and then pass it in, + * we could restore the power state before processing + * the deferred queue. + */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + /* XXX inside IF_LOCK ? */ if ((ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0) { #ifdef IEEE80211_SUPPORT_SUPERG @@ -835,10 +895,13 @@ ath_edma_setup_rxfifo(struct ath_softc *sc, HAL_RX_QUEUE qtype) qtype); return (-EINVAL); } - device_printf(sc->sc_dev, "%s: type=%d, FIFO depth = %d entries\n", - __func__, - qtype, - re->m_fifolen); + + if (bootverbose) + device_printf(sc->sc_dev, + "%s: type=%d, FIFO depth = %d entries\n", + __func__, + qtype, + re->m_fifolen); /* Allocate ath_buf FIFO array, pre-zero'ed */ re->m_fifo = malloc(sizeof(struct ath_buf *) * re->m_fifolen, @@ -929,10 +992,12 @@ ath_recv_setup_edma(struct ath_softc *sc) (void) ath_hal_setrxbufsize(sc->sc_ah, sc->sc_edma_bufsize - sc->sc_rx_statuslen); - device_printf(sc->sc_dev, "RX status length: %d\n", - sc->sc_rx_statuslen); - device_printf(sc->sc_dev, "RX buffer size: %d\n", - sc->sc_edma_bufsize); + if (bootverbose) { + device_printf(sc->sc_dev, "RX status length: %d\n", + sc->sc_rx_statuslen); + device_printf(sc->sc_dev, "RX buffer size: %d\n", + sc->sc_edma_bufsize); + } sc->sc_rx.recv_stop = ath_edma_stoprecv; sc->sc_rx.recv_start = ath_edma_startrecv; diff --git a/sys/dev/ath/if_ath_spectral.c b/sys/dev/ath/if_ath_spectral.c index 5cfb1a9..e4afdae 100644 --- a/sys/dev/ath/if_ath_spectral.c +++ b/sys/dev/ath/if_ath_spectral.c @@ -43,6 +43,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <sys/kernel.h> #include <sys/lock.h> +#include <sys/malloc.h> #include <sys/mutex.h> #include <sys/errno.h> @@ -53,6 +54,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_arp.h> #include <net/ethernet.h> /* XXX for ether_sprintf */ diff --git a/sys/dev/ath/if_ath_sysctl.c b/sys/dev/ath/if_ath_sysctl.c index 0a5719a..45c8ae4 100644 --- a/sys/dev/ath/if_ath_sysctl.c +++ b/sys/dev/ath/if_ath_sysctl.c @@ -62,6 +62,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -107,13 +108,26 @@ static int ath_sysctl_slottime(SYSCTL_HANDLER_ARGS) { struct ath_softc *sc = arg1; - u_int slottime = ath_hal_getslottime(sc->sc_ah); + u_int slottime; int error; + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + slottime = ath_hal_getslottime(sc->sc_ah); + ATH_UNLOCK(sc); + error = sysctl_handle_int(oidp, &slottime, 0, req); if (error || !req->newptr) - return error; - return !ath_hal_setslottime(sc->sc_ah, slottime) ? EINVAL : 0; + goto finish; + + error = !ath_hal_setslottime(sc->sc_ah, slottime) ? EINVAL : 0; + +finish: + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + + return error; } static int @@ -399,12 +413,14 @@ ath_sysctl_txagg(SYSCTL_HANDLER_ARGS) ATH_RX_LOCK(sc); for (i = 0; i < 2; i++) { - printf("%d: fifolen: %d/%d; head=%d; tail=%d\n", + printf("%d: fifolen: %d/%d; head=%d; tail=%d; m_pending=%p, m_holdbf=%p\n", i, sc->sc_rxedma[i].m_fifo_depth, sc->sc_rxedma[i].m_fifolen, sc->sc_rxedma[i].m_fifo_head, - sc->sc_rxedma[i].m_fifo_tail); + sc->sc_rxedma[i].m_fifo_tail, + sc->sc_rxedma[i].m_rxpending, + sc->sc_rxedma[i].m_holdbf); } i = 0; TAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list) { @@ -430,7 +446,15 @@ ath_sysctl_rfsilent(SYSCTL_HANDLER_ARGS) return error; if (!ath_hal_setrfsilent(sc->sc_ah, rfsilent)) return EINVAL; - sc->sc_rfsilentpin = rfsilent & 0x1c; + /* + * Earlier chips (< AR5212) have up to 8 GPIO + * pins exposed. + * + * AR5416 and later chips have many more GPIO + * pins (up to 16) so the mask is expanded to + * four bits. + */ + sc->sc_rfsilentpin = rfsilent & 0x3c; sc->sc_rfsilentpol = (rfsilent & 0x2) != 0; return 0; } diff --git a/sys/dev/ath/if_ath_tdma.c b/sys/dev/ath/if_ath_tdma.c index c075d01..de1a91c 100644 --- a/sys/dev/ath/if_ath_tdma.c +++ b/sys/dev/ath/if_ath_tdma.c @@ -73,6 +73,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -476,16 +477,19 @@ ath_tdma_update(struct ieee80211_node *ni, DPRINTF(sc, ATH_DEBUG_TDMA_TIMER, "rs->rstamp %llu rstamp %llu tsf %llu txtime %d, nextslot %llu, " "nextslottu %d, nextslottume %d\n", - (unsigned long long) rs->rs_tstamp, rstamp, tsf, txtime, - nextslot, nextslottu, TSF_TO_TU(nextslot >> 32, nextslot)); + (unsigned long long) rs->rs_tstamp, + (unsigned long long) rstamp, + (unsigned long long) tsf, txtime, + (unsigned long long) nextslot, + nextslottu, TSF_TO_TU(nextslot >> 32, nextslot)); DPRINTF(sc, ATH_DEBUG_TDMA, " beacon tstamp: %llu (0x%016llx)\n", - le64toh(ni->ni_tstamp.tsf), - le64toh(ni->ni_tstamp.tsf)); + (unsigned long long) le64toh(ni->ni_tstamp.tsf), + (unsigned long long) le64toh(ni->ni_tstamp.tsf)); DPRINTF(sc, ATH_DEBUG_TDMA_TIMER, "nexttbtt %llu (0x%08llx) tsfdelta %d avg +%d/-%d\n", - nexttbtt, + (unsigned long long) nexttbtt, (long long) nexttbtt, tsfdelta, TDMA_AVG(sc->sc_avgtsfdeltap), TDMA_AVG(sc->sc_avgtsfdeltam)); @@ -579,7 +583,7 @@ ath_tdma_update(struct ieee80211_node *ni, DPRINTF(sc, ATH_DEBUG_TDMA_TIMER, "%s: calling ath_hal_adjusttsf: TSF=%llu, tsfdelta=%d\n", __func__, - tsf, + (unsigned long long) tsf, tsfdelta); #ifdef ATH_DEBUG_ALQ diff --git a/sys/dev/ath/if_ath_tx.c b/sys/dev/ath/if_ath_tx.c index 8bacd92..096278e 100644 --- a/sys/dev/ath/if_ath_tx.c +++ b/sys/dev/ath/if_ath_tx.c @@ -59,10 +59,12 @@ __FBSDID("$FreeBSD$"); #include <sys/kthread.h> #include <sys/taskqueue.h> #include <sys/priv.h> +#include <sys/ktr.h> #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -759,37 +761,21 @@ ath_tx_handoff_hw(struct ath_softc *sc, struct ath_txq *txq, ("ath_tx_handoff_hw called for mcast queue")); /* - * XXX racy, should hold the PCU lock when checking this, - * and also should ensure that the TX counter is >0! + * XXX We should instead just verify that sc_txstart_cnt + * or ath_txproc_cnt > 0. That would mean that + * the reset is going to be waiting for us to complete. */ - KASSERT((sc->sc_inreset_cnt == 0), - ("%s: TX during reset?\n", __func__)); + if (sc->sc_txproc_cnt == 0 && sc->sc_txstart_cnt == 0) { + device_printf(sc->sc_dev, + "%s: TX dispatch without holding txcount/txstart refcnt!\n", + __func__); + } -#if 0 /* - * This causes a LOR. Find out where the PCU lock is being - * held whilst the TXQ lock is grabbed - that shouldn't - * be occuring. + * XXX .. this is going to cause the hardware to get upset; + * so we really should find some way to drop or queue + * things. */ - ATH_PCU_LOCK(sc); - if (sc->sc_inreset_cnt) { - ATH_PCU_UNLOCK(sc); - DPRINTF(sc, ATH_DEBUG_RESET, - "%s: called with sc_in_reset != 0\n", - __func__); - DPRINTF(sc, ATH_DEBUG_XMIT, - "%s: queued: TXDP[%u] = %p (%p) depth %d\n", - __func__, txq->axq_qnum, - (caddr_t)bf->bf_daddr, bf->bf_desc, - txq->axq_depth); - /* XXX axq_link needs to be set and updated! */ - ATH_TXQ_INSERT_TAIL(txq, bf, bf_list); - if (bf->bf_state.bfs_aggr) - txq->axq_aggr_depth++; - return; - } - ATH_PCU_UNLOCK(sc); -#endif ATH_TXQ_LOCK(txq); @@ -1613,6 +1599,7 @@ ath_tx_normal_setup(struct ath_softc *sc, struct ieee80211_node *ni, error = ath_tx_dmasetup(sc, bf, m0); if (error != 0) return error; + KASSERT((ni != NULL), ("%s: ni=NULL!", __func__)); bf->bf_node = ni; /* NB: held reference */ m0 = bf->bf_m; /* NB: may have changed */ wh = mtod(m0, struct ieee80211_frame *); @@ -2104,6 +2091,7 @@ ath_tx_raw_start(struct ath_softc *sc, struct ieee80211_node *ni, int do_override; uint8_t type, subtype; int queue_to_head; + struct ath_node *an = ATH_NODE(ni); ATH_TX_LOCK_ASSERT(sc); @@ -2163,6 +2151,7 @@ ath_tx_raw_start(struct ath_softc *sc, struct ieee80211_node *ni, return error; m0 = bf->bf_m; /* NB: may have changed */ wh = mtod(m0, struct ieee80211_frame *); + KASSERT((ni != NULL), ("%s: ni=NULL!", __func__)); bf->bf_node = ni; /* NB: held reference */ /* Always enable CLRDMASK for raw frames for now.. */ @@ -2181,12 +2170,24 @@ ath_tx_raw_start(struct ath_softc *sc, struct ieee80211_node *ni, rt = sc->sc_currates; KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode)); + + /* Fetch first rate information */ rix = ath_tx_findrix(sc, params->ibp_rate0); + try0 = params->ibp_try0; + + /* + * Override EAPOL rate as appropriate. + */ + if (m0->m_flags & M_EAPOL) { + /* XXX? maybe always use long preamble? */ + rix = an->an_mgmtrix; + try0 = ATH_TXMAXTRY; /* XXX?too many? */ + } + txrate = rt->info[rix].rateCode; if (params->ibp_flags & IEEE80211_BPF_SHORTPRE) txrate |= rt->info[rix].shortPreamble; sc->sc_txrix = rix; - try0 = params->ibp_try0; ismrr = (params->ibp_try1 != 0); txantenna = params->ibp_pri >> 2; if (txantenna == 0) /* XXX? */ @@ -2259,8 +2260,7 @@ ath_tx_raw_start(struct ath_softc *sc, struct ieee80211_node *ni, /* Blank the legacy rate array */ bzero(&bf->bf_state.bfs_rc, sizeof(bf->bf_state.bfs_rc)); - bf->bf_state.bfs_rc[0].rix = - ath_tx_findrix(sc, params->ibp_rate0); + bf->bf_state.bfs_rc[0].rix = rix; bf->bf_state.bfs_rc[0].tries = try0; bf->bf_state.bfs_rc[0].ratecode = txrate; @@ -2352,11 +2352,16 @@ ath_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, "%s: sc_inreset_cnt > 0; bailing\n", __func__); error = EIO; ATH_PCU_UNLOCK(sc); - goto bad0; + goto badbad; } sc->sc_txstart_cnt++; ATH_PCU_UNLOCK(sc); + /* Wake the hardware up already */ + ATH_LOCK(sc); + ath_power_set_power_state(sc, HAL_PM_AWAKE); + ATH_UNLOCK(sc); + ATH_TX_LOCK(sc); if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || sc->sc_invalid) { @@ -2419,7 +2424,7 @@ ath_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, } } sc->sc_wd_timer = 5; - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); sc->sc_stats.ast_tx_raw++; /* @@ -2435,7 +2440,14 @@ ath_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, sc->sc_txstart_cnt--; ATH_PCU_UNLOCK(sc); + + /* Put the hardware back to sleep if required */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + return 0; + bad2: ATH_KTR(sc, ATH_KTR_TX, 3, "ath_raw_xmit: bad2: m=%p, params=%p, " "bf=%p", @@ -2445,17 +2457,23 @@ bad2: ATH_TXBUF_LOCK(sc); ath_returnbuf_head(sc, bf); ATH_TXBUF_UNLOCK(sc); -bad: +bad: ATH_TX_UNLOCK(sc); ATH_PCU_LOCK(sc); sc->sc_txstart_cnt--; ATH_PCU_UNLOCK(sc); -bad0: + + /* Put the hardware back to sleep if required */ + ATH_LOCK(sc); + ath_power_restore_power_state(sc); + ATH_UNLOCK(sc); + +badbad: ATH_KTR(sc, ATH_KTR_TX, 2, "ath_raw_xmit: bad0: m=%p, params=%p", m, params); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); sc->sc_stats.ast_tx_raw_fail++; ieee80211_free_node(ni); @@ -2748,8 +2766,8 @@ ath_tx_update_baw(struct ath_softc *sc, struct ath_node *an, INCR(tid->baw_head, ATH_TID_MAX_BUFS); } DPRINTF(sc, ATH_DEBUG_SW_TX_BAW, - "%s: baw is now %d:%d, baw head=%d\n", - __func__, tap->txa_start, tap->txa_wnd, tid->baw_head); + "%s: tid=%d: baw is now %d:%d, baw head=%d\n", + __func__, tid->tid, tap->txa_start, tap->txa_wnd, tid->baw_head); } static void @@ -3242,8 +3260,11 @@ ath_tx_tid_pause(struct ath_softc *sc, struct ath_tid *tid) ATH_TX_LOCK_ASSERT(sc); tid->paused++; - DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, "%s: paused = %d\n", - __func__, tid->paused); + DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, "%s: [%6D]: tid=%d, paused = %d\n", + __func__, + tid->an->an_node.ni_macaddr, ":", + tid->tid, + tid->paused); } /* @@ -3260,15 +3281,21 @@ ath_tx_tid_resume(struct ath_softc *sc, struct ath_tid *tid) * until it's actually resolved. */ if (tid->paused == 0) { - DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, - "%s: %6D: paused=0?\n", __func__, - tid->an->an_node.ni_macaddr, ":"); + device_printf(sc->sc_dev, + "%s: [%6D]: tid=%d, paused=0?\n", + __func__, + tid->an->an_node.ni_macaddr, ":", + tid->tid); } else { tid->paused--; } - DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, "%s: unpaused = %d\n", - __func__, tid->paused); + DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, + "%s: [%6D]: tid=%d, unpaused = %d\n", + __func__, + tid->an->an_node.ni_macaddr, ":", + tid->tid, + tid->paused); if (tid->paused) return; @@ -3334,8 +3361,8 @@ ath_tx_tid_filt_comp_buf(struct ath_softc *sc, struct ath_tid *tid, ATH_TX_LOCK_ASSERT(sc); if (! tid->isfiltered) { - DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, "%s: filter transition\n", - __func__); + DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, "%s: tid=%d; filter transition\n", + __func__, tid->tid); tid->isfiltered = 1; ath_tx_tid_pause(sc, tid); } @@ -3355,15 +3382,20 @@ static void ath_tx_tid_filt_comp_complete(struct ath_softc *sc, struct ath_tid *tid) { struct ath_buf *bf; + int do_resume = 0; ATH_TX_LOCK_ASSERT(sc); if (tid->hwq_depth != 0) return; - DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, "%s: hwq=0, transition back\n", - __func__); - tid->isfiltered = 0; + DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, "%s: tid=%d, hwq=0, transition back\n", + __func__, tid->tid); + if (tid->isfiltered == 1) { + tid->isfiltered = 0; + do_resume = 1; + } + /* XXX ath_tx_tid_resume() also calls ath_tx_set_clrdmask()! */ ath_tx_set_clrdmask(sc, tid->an); @@ -3373,16 +3405,21 @@ ath_tx_tid_filt_comp_complete(struct ath_softc *sc, struct ath_tid *tid) ATH_TID_INSERT_HEAD(tid, bf, bf_list); } - ath_tx_tid_resume(sc, tid); + /* And only resume if we had paused before */ + if (do_resume) + ath_tx_tid_resume(sc, tid); } /* * Called when a single (aggregate or otherwise) frame is completed. * - * Returns 1 if the buffer could be added to the filtered list - * (cloned or otherwise), 0 if the buffer couldn't be added to the + * Returns 0 if the buffer could be added to the filtered list + * (cloned or otherwise), 1 if the buffer couldn't be added to the * filtered list (failed clone; expired retry) and the caller should * free it and handle it like a failure (eg by sending a BAR.) + * + * since the buffer may be cloned, bf must be not touched after this + * if the return value is 0. */ static int ath_tx_tid_filt_comp_single(struct ath_softc *sc, struct ath_tid *tid, @@ -3402,8 +3439,9 @@ ath_tx_tid_filt_comp_single(struct ath_softc *sc, struct ath_tid *tid, "%s: bf=%p, seqno=%d, exceeded retries\n", __func__, bf, - bf->bf_state.bfs_seqno); - return (0); + SEQNO(bf->bf_state.bfs_seqno)); + retval = 1; /* error */ + goto finish; } /* @@ -3423,11 +3461,12 @@ ath_tx_tid_filt_comp_single(struct ath_softc *sc, struct ath_tid *tid, DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, "%s: busy buffer couldn't be cloned (%p)!\n", __func__, bf); - retval = 1; + retval = 1; /* error */ } else { ath_tx_tid_filt_comp_buf(sc, tid, nbf); - retval = 0; + retval = 0; /* ok */ } +finish: ath_tx_tid_filt_comp_complete(sc, tid); return (retval); @@ -3452,10 +3491,11 @@ ath_tx_tid_filt_comp_aggr(struct ath_softc *sc, struct ath_tid *tid, if (bf->bf_state.bfs_retries > SWMAX_RETRIES) { sc->sc_stats.ast_tx_swretrymax++; DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, - "%s: bf=%p, seqno=%d, exceeded retries\n", + "%s: tid=%d, bf=%p, seqno=%d, exceeded retries\n", __func__, + tid->tid, bf, - bf->bf_state.bfs_seqno); + SEQNO(bf->bf_state.bfs_seqno)); TAILQ_INSERT_TAIL(bf_q, bf, bf_list); goto next; } @@ -3463,8 +3503,8 @@ ath_tx_tid_filt_comp_aggr(struct ath_softc *sc, struct ath_tid *tid, if (bf->bf_flags & ATH_BUF_BUSY) { nbf = ath_tx_retry_clone(sc, tid->an, tid, bf); DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, - "%s: busy buffer cloned: %p -> %p", - __func__, bf, nbf); + "%s: tid=%d, busy buffer cloned: %p -> %p, seqno=%d\n", + __func__, tid->tid, bf, nbf, SEQNO(bf->bf_state.bfs_seqno)); } else { nbf = bf; } @@ -3475,8 +3515,8 @@ ath_tx_tid_filt_comp_aggr(struct ath_softc *sc, struct ath_tid *tid, */ if (nbf == NULL) { DPRINTF(sc, ATH_DEBUG_SW_TX_FILT, - "%s: buffer couldn't be cloned! (%p)\n", - __func__, bf); + "%s: tid=%d, buffer couldn't be cloned! (%p) seqno=%d\n", + __func__, tid->tid, bf, SEQNO(bf->bf_state.bfs_seqno)); TAILQ_INSERT_TAIL(bf_q, bf, bf_list); } else { ath_tx_tid_filt_comp_buf(sc, tid, nbf); @@ -3717,7 +3757,7 @@ ath_tx_tid_drain_print(struct ath_softc *sc, struct ath_node *an, txq = sc->sc_ac2q[tid->ac]; tap = ath_tx_get_tx_tid(an, tid->tid); - DPRINTF(sc, ATH_DEBUG_SW_TX, + DPRINTF(sc, ATH_DEBUG_SW_TX | ATH_DEBUG_RESET, "%s: %s: %6D: bf=%p: addbaw=%d, dobaw=%d, " "seqno=%d, retry=%d\n", __func__, @@ -3729,7 +3769,7 @@ ath_tx_tid_drain_print(struct ath_softc *sc, struct ath_node *an, bf->bf_state.bfs_dobaw, SEQNO(bf->bf_state.bfs_seqno), bf->bf_state.bfs_retries); - DPRINTF(sc, ATH_DEBUG_SW_TX, + DPRINTF(sc, ATH_DEBUG_SW_TX | ATH_DEBUG_RESET, "%s: %s: %6D: bf=%p: txq[%d] axq_depth=%d, axq_aggr_depth=%d\n", __func__, pfx, @@ -3739,7 +3779,7 @@ ath_tx_tid_drain_print(struct ath_softc *sc, struct ath_node *an, txq->axq_qnum, txq->axq_depth, txq->axq_aggr_depth); - DPRINTF(sc, ATH_DEBUG_SW_TX, + DPRINTF(sc, ATH_DEBUG_SW_TX | ATH_DEBUG_RESET, "%s: %s: %6D: bf=%p: tid txq_depth=%d hwq_depth=%d, bar_wait=%d, " "isfiltered=%d\n", __func__, @@ -3751,7 +3791,7 @@ ath_tx_tid_drain_print(struct ath_softc *sc, struct ath_node *an, tid->hwq_depth, tid->bar_wait, tid->isfiltered); - DPRINTF(sc, ATH_DEBUG_SW_TX, + DPRINTF(sc, ATH_DEBUG_SW_TX | ATH_DEBUG_RESET, "%s: %s: %6D: tid %d: " "sched=%d, paused=%d, " "incomp=%d, baw_head=%d, " @@ -3811,7 +3851,7 @@ ath_tx_tid_drain(struct ath_softc *sc, struct ath_node *an, if (t == 0) { ath_tx_tid_drain_print(sc, an, "norm", tid, bf); - t = 1; +// t = 1; } ATH_TID_REMOVE(tid, bf, bf_list); @@ -3827,7 +3867,7 @@ ath_tx_tid_drain(struct ath_softc *sc, struct ath_node *an, if (t == 0) { ath_tx_tid_drain_print(sc, an, "filt", tid, bf); - t = 1; +// t = 1; } ATH_TID_FILT_REMOVE(tid, bf, bf_list); @@ -4084,6 +4124,19 @@ ath_tx_normal_comp(struct ath_softc *sc, struct ath_buf *bf, int fail) DPRINTF(sc, ATH_DEBUG_SW_TX, "%s: hwq_depth < 0: %d\n", __func__, atid->hwq_depth); + /* If the TID is being cleaned up, track things */ + /* XXX refactor! */ + if (atid->cleanup_inprogress) { + atid->incomp--; + if (atid->incomp == 0) { + DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, + "%s: TID %d: cleaned up! resume!\n", + __func__, tid); + atid->cleanup_inprogress = 0; + ath_tx_tid_resume(sc, atid); + } + } + /* * If the queue is filtered, potentially mark it as complete * and reschedule it as needed. @@ -4131,6 +4184,16 @@ ath_tx_comp_cleanup_unaggr(struct ath_softc *sc, struct ath_buf *bf) ATH_TX_LOCK(sc); atid->incomp--; + + /* XXX refactor! */ + if (bf->bf_state.bfs_dobaw) { + ath_tx_update_baw(sc, an, atid, bf); + if (!bf->bf_state.bfs_addedbaw) + DPRINTF(sc, ATH_DEBUG_SW_TX, + "%s: wasn't added: seqno %d\n", + __func__, SEQNO(bf->bf_state.bfs_seqno)); + } + if (atid->incomp == 0) { DPRINTF(sc, ATH_DEBUG_SW_TX_CTRL, "%s: TID %d: cleaned up! resume!\n", @@ -4143,14 +4206,72 @@ ath_tx_comp_cleanup_unaggr(struct ath_softc *sc, struct ath_buf *bf) ath_tx_default_comp(sc, bf, 0); } + +/* + * This as it currently stands is a bit dumb. Ideally we'd just + * fail the frame the normal way and have it permanently fail + * via the normal aggregate completion path. + */ +static void +ath_tx_tid_cleanup_frame(struct ath_softc *sc, struct ath_node *an, + int tid, struct ath_buf *bf_head, ath_bufhead *bf_cq) +{ + struct ath_tid *atid = &an->an_tid[tid]; + struct ath_buf *bf, *bf_next; + + ATH_TX_LOCK_ASSERT(sc); + + /* + * Remove this frame from the queue. + */ + ATH_TID_REMOVE(atid, bf_head, bf_list); + + /* + * Loop over all the frames in the aggregate. + */ + bf = bf_head; + while (bf != NULL) { + bf_next = bf->bf_next; /* next aggregate frame, or NULL */ + + /* + * If it's been added to the BAW we need to kick + * it out of the BAW before we continue. + * + * XXX if it's an aggregate, assert that it's in the + * BAW - we shouldn't have it be in an aggregate + * otherwise! + */ + if (bf->bf_state.bfs_addedbaw) { + ath_tx_update_baw(sc, an, atid, bf); + bf->bf_state.bfs_dobaw = 0; + } + + /* + * Give it the default completion handler. + */ + bf->bf_comp = ath_tx_normal_comp; + bf->bf_next = NULL; + + /* + * Add it to the list to free. + */ + TAILQ_INSERT_TAIL(bf_cq, bf, bf_list); + + /* + * Now advance to the next frame in the aggregate. + */ + bf = bf_next; + } +} + /* * Performs transmit side cleanup when TID changes from aggregated to - * unaggregated. + * unaggregated and during reassociation. * - * - Discard all retry frames from the s/w queue. - * - Fix the tx completion function for all buffers in s/w queue. - * - Count the number of unacked frames, and let transmit completion - * handle it later. + * For now, this just tosses everything from the TID software queue + * whether or not it has been retried and marks the TID as + * pending completion if there's anything for this TID queued to + * the hardware. * * The caller is responsible for pausing the TID and unpausing the * TID if no cleanup was required. Otherwise the cleanup path will @@ -4161,18 +4282,19 @@ ath_tx_tid_cleanup(struct ath_softc *sc, struct ath_node *an, int tid, ath_bufhead *bf_cq) { struct ath_tid *atid = &an->an_tid[tid]; - struct ieee80211_tx_ampdu *tap; struct ath_buf *bf, *bf_next; ATH_TX_LOCK_ASSERT(sc); DPRINTF(sc, ATH_DEBUG_SW_TX_BAW, - "%s: TID %d: called\n", __func__, tid); + "%s: TID %d: called; inprogress=%d\n", __func__, tid, + atid->cleanup_inprogress); /* * Move the filtered frames to the TX queue, before * we run off and discard/process things. */ + /* XXX this is really quite inefficient */ while ((bf = ATH_TID_FILT_LAST(atid, ath_bufhead_s)) != NULL) { ATH_TID_FILT_REMOVE(atid, bf, bf_list); @@ -4187,47 +4309,35 @@ ath_tx_tid_cleanup(struct ath_softc *sc, struct ath_node *an, int tid, */ bf = ATH_TID_FIRST(atid); while (bf) { - if (bf->bf_state.bfs_isretried) { - bf_next = TAILQ_NEXT(bf, bf_list); - ATH_TID_REMOVE(atid, bf, bf_list); - if (bf->bf_state.bfs_dobaw) { - ath_tx_update_baw(sc, an, atid, bf); - if (!bf->bf_state.bfs_addedbaw) - DPRINTF(sc, ATH_DEBUG_SW_TX_BAW, - "%s: wasn't added: seqno %d\n", - __func__, - SEQNO(bf->bf_state.bfs_seqno)); - } - bf->bf_state.bfs_dobaw = 0; - /* - * Call the default completion handler with "fail" just - * so upper levels are suitably notified about this. - */ - TAILQ_INSERT_TAIL(bf_cq, bf, bf_list); - bf = bf_next; - continue; - } - /* Give these the default completion handler */ - bf->bf_comp = ath_tx_normal_comp; - bf = TAILQ_NEXT(bf, bf_list); + /* + * Grab the next frame in the list, we may + * be fiddling with the list. + */ + bf_next = TAILQ_NEXT(bf, bf_list); + + /* + * Free the frame and all subframes. + */ + ath_tx_tid_cleanup_frame(sc, an, tid, bf, bf_cq); + + /* + * Next frame! + */ + bf = bf_next; } /* - * Calculate what hardware-queued frames exist based - * on the current BAW size. Ie, what frames have been - * added to the TX hardware queue for this TID but - * not yet ACKed. + * If there's anything in the hardware queue we wait + * for the TID HWQ to empty. */ - tap = ath_tx_get_tx_tid(an, tid); - /* Need the lock - fiddling with BAW */ - while (atid->baw_head != atid->baw_tail) { - if (atid->tx_buf[atid->baw_head]) { - atid->incomp++; - atid->cleanup_inprogress = 1; - atid->tx_buf[atid->baw_head] = NULL; - } - INCR(atid->baw_head, ATH_TID_MAX_BUFS); - INCR(tap->txa_start, IEEE80211_SEQ_RANGE); + if (atid->hwq_depth > 0) { + /* + * XXX how about we kill atid->incomp, and instead + * replace it with a macro that checks that atid->hwq_depth + * is 0? + */ + atid->incomp = atid->hwq_depth; + atid->cleanup_inprogress = 1; } if (atid->cleanup_inprogress) @@ -4560,9 +4670,19 @@ ath_tx_comp_cleanup_aggr(struct ath_softc *sc, struct ath_buf *bf_first) ATH_TX_LOCK(sc); /* update incomp */ + atid->incomp--; + + /* Update the BAW */ bf = bf_first; while (bf) { - atid->incomp--; + /* XXX refactor! */ + if (bf->bf_state.bfs_dobaw) { + ath_tx_update_baw(sc, an, atid, bf); + if (!bf->bf_state.bfs_addedbaw) + DPRINTF(sc, ATH_DEBUG_SW_TX, + "%s: wasn't added: seqno %d\n", + __func__, SEQNO(bf->bf_state.bfs_seqno)); + } bf = bf->bf_next; } @@ -4585,10 +4705,11 @@ ath_tx_comp_cleanup_aggr(struct ath_softc *sc, struct ath_buf *bf_first) ATH_TX_UNLOCK(sc); - /* Handle frame completion */ + /* Handle frame completion as individual frames */ bf = bf_first; while (bf) { bf_next = bf->bf_next; + bf->bf_next = NULL; ath_tx_default_comp(sc, bf, 1); bf = bf_next; } @@ -5030,6 +5151,10 @@ ath_tx_aggr_comp_unaggr(struct ath_softc *sc, struct ath_buf *bf, int fail) "%s: isfiltered=1, fail=%d\n", __func__, fail); freeframe = ath_tx_tid_filt_comp_single(sc, atid, bf); + /* + * If freeframe=0 then bf is no longer ours; don't + * touch it. + */ if (freeframe) { /* Remove from BAW */ if (bf->bf_state.bfs_addedbaw) @@ -5065,7 +5190,6 @@ ath_tx_aggr_comp_unaggr(struct ath_softc *sc, struct ath_buf *bf, int fail) if (freeframe) ath_tx_default_comp(sc, bf, fail); - return; } /* @@ -5495,7 +5619,7 @@ ath_txq_sched(struct ath_softc *sc, struct ath_txq *txq) * a frame; be careful. */ if (! ath_tx_tid_can_tx_or_sched(sc, tid)) { - continue; + goto loop_done; } if (ath_tx_ampdu_running(sc, tid->an, tid->tid)) ath_tx_tid_hw_queue_aggr(sc, tid->an, tid); @@ -5518,7 +5642,7 @@ ath_txq_sched(struct ath_softc *sc, struct ath_txq *txq) if (txq->axq_depth >= sc->sc_hwq_limit_nonaggr) { break; } - +loop_done: /* * If this was the last entry on the original list, stop. * Otherwise nodes that have been rescheduled onto the end @@ -5771,12 +5895,26 @@ ath_addba_stop(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) */ TAILQ_INIT(&bf_cq); ATH_TX_LOCK(sc); - ath_tx_tid_cleanup(sc, an, tid, &bf_cq); + /* - * Unpause the TID if no cleanup is required. + * In case there's a followup call to this, only call it + * if we don't have a cleanup in progress. + * + * Since we've paused the queue above, we need to make + * sure we unpause if there's already a cleanup in + * progress - it means something else is also doing + * this stuff, so we don't need to also keep it paused. */ - if (! atid->cleanup_inprogress) + if (atid->cleanup_inprogress) { ath_tx_tid_resume(sc, atid); + } else { + ath_tx_tid_cleanup(sc, an, tid, &bf_cq); + /* + * Unpause the TID if no cleanup is required. + */ + if (! atid->cleanup_inprogress) + ath_tx_tid_resume(sc, atid); + } ATH_TX_UNLOCK(sc); /* Handle completing frames and fail them */ @@ -5810,19 +5948,25 @@ ath_tx_node_reassoc(struct ath_softc *sc, struct ath_node *an) tid = &an->an_tid[i]; if (tid->hwq_depth == 0) continue; - ath_tx_tid_pause(sc, tid); DPRINTF(sc, ATH_DEBUG_NODE, "%s: %6D: TID %d: cleaning up TID\n", __func__, an->an_node.ni_macaddr, ":", i); - ath_tx_tid_cleanup(sc, an, i, &bf_cq); /* - * Unpause the TID if no cleanup is required. + * In case there's a followup call to this, only call it + * if we don't have a cleanup in progress. */ - if (! tid->cleanup_inprogress) - ath_tx_tid_resume(sc, tid); + if (! tid->cleanup_inprogress) { + ath_tx_tid_pause(sc, tid); + ath_tx_tid_cleanup(sc, an, i, &bf_cq); + /* + * Unpause the TID if no cleanup is required. + */ + if (! tid->cleanup_inprogress) + ath_tx_tid_resume(sc, tid); + } } ATH_TX_UNLOCK(sc); @@ -5852,19 +5996,43 @@ ath_bar_response(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, struct ath_node *an = ATH_NODE(ni); struct ath_tid *atid = &an->an_tid[tid]; int attempts = tap->txa_attempts; + int old_txa_start; DPRINTF(sc, ATH_DEBUG_SW_TX_BAR, - "%s: %6D: called; txa_tid=%d, atid->tid=%d, status=%d, attempts=%d\n", + "%s: %6D: called; txa_tid=%d, atid->tid=%d, status=%d, attempts=%d, txa_start=%d, txa_seqpending=%d\n", __func__, ni->ni_macaddr, ":", tap->txa_tid, atid->tid, status, - attempts); + attempts, + tap->txa_start, + tap->txa_seqpending); /* Note: This may update the BAW details */ + /* + * XXX What if this does slide the BAW along? We need to somehow + * XXX either fix things when it does happen, or prevent the + * XXX seqpending value to be anything other than exactly what + * XXX the hell we want! + * + * XXX So for now, how I do this inside the TX lock for now + * XXX and just correct it afterwards? The below condition should + * XXX never happen and if it does I need to fix all kinds of things. + */ + ATH_TX_LOCK(sc); + old_txa_start = tap->txa_start; sc->sc_bar_response(ni, tap, status); + if (tap->txa_start != old_txa_start) { + device_printf(sc->sc_dev, "%s: tid=%d; txa_start=%d, old=%d, adjusting\n", + __func__, + tid, + tap->txa_start, + old_txa_start); + } + tap->txa_start = old_txa_start; + ATH_TX_UNLOCK(sc); /* Unpause the TID */ /* diff --git a/sys/dev/ath/if_ath_tx_edma.c b/sys/dev/ath/if_ath_tx_edma.c index 5498dd5..7d14920 100644 --- a/sys/dev/ath/if_ath_tx_edma.c +++ b/sys/dev/ath/if_ath_tx_edma.c @@ -73,6 +73,7 @@ __FBSDID("$FreeBSD$"); #include <machine/bus.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -865,12 +866,14 @@ ath_xmit_setup_edma(struct ath_softc *sc) (void) ath_hal_gettxstatuslen(sc->sc_ah, &sc->sc_tx_statuslen); (void) ath_hal_getntxmaps(sc->sc_ah, &sc->sc_tx_nmaps); - device_printf(sc->sc_dev, "TX descriptor length: %d\n", - sc->sc_tx_desclen); - device_printf(sc->sc_dev, "TX status length: %d\n", - sc->sc_tx_statuslen); - device_printf(sc->sc_dev, "TX buffers per descriptor: %d\n", - sc->sc_tx_nmaps); + if (bootverbose) { + device_printf(sc->sc_dev, "TX descriptor length: %d\n", + sc->sc_tx_desclen); + device_printf(sc->sc_dev, "TX status length: %d\n", + sc->sc_tx_statuslen); + device_printf(sc->sc_dev, "TX buffers per descriptor: %d\n", + sc->sc_tx_nmaps); + } sc->sc_tx.xmit_setup = ath_edma_dma_txsetup; sc->sc_tx.xmit_teardown = ath_edma_dma_txteardown; diff --git a/sys/dev/ath/if_athvar.h b/sys/dev/ath/if_athvar.h index 6b074d6..e888ca2 100644 --- a/sys/dev/ath/if_athvar.h +++ b/sys/dev/ath/if_athvar.h @@ -82,6 +82,25 @@ #define ATH_BEACON_CWMAX_DEFAULT 0 /* default cwmax for ap beacon q */ /* + * The following bits can be set during the PCI (and perhaps non-PCI + * later) device probe path. + * + * It controls some of the driver and HAL behaviour. + */ + +#define ATH_PCI_CUS198 0x0001 +#define ATH_PCI_CUS230 0x0002 +#define ATH_PCI_CUS217 0x0004 +#define ATH_PCI_CUS252 0x0008 +#define ATH_PCI_WOW 0x0010 +#define ATH_PCI_BT_ANT_DIV 0x0020 +#define ATH_PCI_D3_L1_WAR 0x0040 +#define ATH_PCI_AR9565_1ANT 0x0080 +#define ATH_PCI_AR9565_2ANT 0x0100 +#define ATH_PCI_NO_PLL_PWRSAVE 0x0200 +#define ATH_PCI_KILLER 0x0400 + +/* * The key cache is used for h/w cipher state and also for * tracking station state such as the current tx antenna. * We also setup a mapping table between key cache slot indices @@ -510,6 +529,7 @@ struct ath_rx_edma { int m_fifo_tail; int m_fifo_depth; struct mbuf *m_rxpending; + struct ath_buf *m_holdbf; }; struct ath_tx_edma_fifo { @@ -565,6 +585,8 @@ struct ath_softc { int sc_tx_statuslen; int sc_tx_nmaps; /* Number of TX maps */ int sc_edma_bufsize; + int sc_rx_stopped; /* XXX only for EDMA */ + int sc_rx_resetted; /* XXX only for EDMA */ void (*sc_node_cleanup)(struct ieee80211_node *); void (*sc_node_free)(struct ieee80211_node *); @@ -621,7 +643,8 @@ struct ath_softc { sc_resetcal : 1,/* reset cal state next trip */ sc_rxslink : 1,/* do self-linked final descriptor */ sc_rxtsf32 : 1,/* RX dec TSF is 32 bits */ - sc_isedma : 1;/* supports EDMA */ + sc_isedma : 1,/* supports EDMA */ + sc_do_mybeacon : 1; /* supports mybeacon */ /* * Second set of flags. @@ -864,6 +887,25 @@ struct ath_softc { void (*sc_bar_response)(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, int status); + + /* + * Powersave state tracking. + * + * target/cur powerstate is the chip power state. + * target selfgen state is the self-generated frames + * state. The chip can be awake but transmitted frames + * can have the PWRMGT bit set to 1 so the destination + * thinks the node is asleep. + */ + HAL_POWER_MODE sc_target_powerstate; + HAL_POWER_MODE sc_target_selfgen_state; + + HAL_POWER_MODE sc_cur_powerstate; + + int sc_powersave_refcnt; + + /* ATH_PCI_* flags */ + uint32_t sc_pci_devinfo; }; #define ATH_LOCK_INIT(_sc) \ @@ -1038,6 +1080,8 @@ void ath_intr(void *); ((*(_ah)->ah_updateTxTrigLevel)((_ah), (_inc))) #define ath_hal_setpower(_ah, _mode) \ ((*(_ah)->ah_setPowerMode)((_ah), (_mode), AH_TRUE)) +#define ath_hal_setselfgenpower(_ah, _mode) \ + ((*(_ah)->ah_setPowerMode)((_ah), (_mode), AH_FALSE)) #define ath_hal_keycachesize(_ah) \ ((*(_ah)->ah_getKeyCacheSize)((_ah))) #define ath_hal_keyreset(_ah, _ix) \ @@ -1266,6 +1310,8 @@ void ath_intr(void *); #define ath_hal_setintmit(_ah, _v) \ ath_hal_setcapability(_ah, HAL_CAP_INTMIT, \ HAL_CAP_INTMIT_ENABLE, _v, NULL) +#define ath_hal_hasmybeacon(_ah) \ + (ath_hal_getcapability(_ah, HAL_CAP_DO_MYBEACON, 1, NULL) == HAL_OK) #define ath_hal_hasenforcetxop(_ah) \ (ath_hal_getcapability(_ah, HAL_CAP_ENFORCE_TXOP, 0, NULL) == HAL_OK) diff --git a/sys/dev/e1000/if_em.c b/sys/dev/e1000/if_em.c index 49e5abd..691292d 100644 --- a/sys/dev/e1000/if_em.c +++ b/sys/dev/e1000/if_em.c @@ -211,15 +211,15 @@ static int em_detach(device_t); static int em_shutdown(device_t); static int em_suspend(device_t); static int em_resume(device_t); -#ifdef EM_MULTIQUEUE + static int em_mq_start(struct ifnet *, struct mbuf *); static int em_mq_start_locked(struct ifnet *, struct tx_ring *); static void em_qflush(struct ifnet *); -#else + static void em_start(struct ifnet *); static void em_start_locked(struct ifnet *, struct tx_ring *); -#endif + static int em_ioctl(struct ifnet *, u_long, caddr_t); static void em_init(void *); static void em_init_locked(struct adapter *); @@ -926,13 +926,13 @@ em_resume(device_t dev) (ifp->if_drv_flags & IFF_DRV_RUNNING) && adapter->link_active) { for (int i = 0; i < adapter->num_queues; i++, txr++) { EM_TX_LOCK(txr); -#ifdef EM_MULTIQUEUE + if (!drbr_empty(ifp, txr->br)) em_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp, txr); -#endif + EM_TX_UNLOCK(txr); } } @@ -942,7 +942,7 @@ em_resume(device_t dev) } -#ifndef EM_MULTIQUEUE + static void em_start_locked(struct ifnet *ifp, struct tx_ring *txr) { @@ -1005,7 +1005,7 @@ em_start(struct ifnet *ifp) } return; } -#else /* EM_MULTIQUEUE */ + /********************************************************************* * Multiqueue Transmit routines * @@ -1112,7 +1112,7 @@ em_qflush(struct ifnet *ifp) } if_qflush(ifp); } -#endif /* EM_MULTIQUEUE */ + /********************************************************************* * Ioctl entry point @@ -1513,13 +1513,13 @@ em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) EM_TX_LOCK(txr); em_txeof(txr); -#ifdef EM_MULTIQUEUE + if (!drbr_empty(ifp, txr->br)) em_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp, txr); -#endif + EM_TX_UNLOCK(txr); return (rx_done); @@ -1587,13 +1587,13 @@ em_handle_que(void *context, int pending) EM_TX_LOCK(txr); em_txeof(txr); -#ifdef EM_MULTIQUEUE + if (!drbr_empty(ifp, txr->br)) em_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp, txr); -#endif + EM_TX_UNLOCK(txr); if (more) { taskqueue_enqueue(adapter->tq, &adapter->que_task); @@ -1621,13 +1621,13 @@ em_msix_tx(void *arg) ++txr->tx_irq; EM_TX_LOCK(txr); em_txeof(txr); -#ifdef EM_MULTIQUEUE + if (!drbr_empty(ifp, txr->br)) em_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp, txr); -#endif + /* Reenable this interrupt */ E1000_WRITE_REG(&adapter->hw, E1000_IMS, txr->ims); @@ -1722,13 +1722,13 @@ em_handle_tx(void *context, int pending) EM_TX_LOCK(txr); em_txeof(txr); -#ifdef EM_MULTIQUEUE + if (!drbr_empty(ifp, txr->br)) em_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp, txr); -#endif + E1000_WRITE_REG(&adapter->hw, E1000_IMS, txr->ims); EM_TX_UNLOCK(txr); } @@ -1752,13 +1752,13 @@ em_handle_link(void *context, int pending) if (adapter->link_active) { for (int i = 0; i < adapter->num_queues; i++, txr++) { EM_TX_LOCK(txr); -#ifdef EM_MULTIQUEUE + if (!drbr_empty(ifp, txr->br)) em_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp, txr); -#endif + EM_TX_UNLOCK(txr); } } @@ -3101,16 +3101,15 @@ em_setup_interface(device_t dev, struct adapter *adapter) ifp->if_hw_tsomaxsegcount = EM_MAX_SCATTER; ifp->if_hw_tsomaxsegsize = EM_TSO_SEG_SIZE; -#ifdef EM_MULTIQUEUE /* Multiqueue stack interface */ ifp->if_transmit = em_mq_start; ifp->if_qflush = em_qflush; -#else + ifp->if_start = em_start; IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1); ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1; IFQ_SET_READY(&ifp->if_snd); -#endif + ether_ifattach(ifp, adapter->hw.mac.addr); diff --git a/sys/dev/e1000/if_igb.c b/sys/dev/e1000/if_igb.c index 620fbad..4bb5b57 100644 --- a/sys/dev/e1000/if_igb.c +++ b/sys/dev/e1000/if_igb.c @@ -43,9 +43,7 @@ #include <sys/param.h> #include <sys/systm.h> -#ifndef IGB_LEGACY_TX #include <sys/buf_ring.h> -#endif #include <sys/bus.h> #include <sys/endian.h> #include <sys/kernel.h> @@ -189,15 +187,12 @@ static int igb_detach(device_t); static int igb_shutdown(device_t); static int igb_suspend(device_t); static int igb_resume(device_t); -#ifndef IGB_LEGACY_TX static int igb_mq_start(struct ifnet *, struct mbuf *); static int igb_mq_start_locked(struct ifnet *, struct tx_ring *); static void igb_qflush(struct ifnet *); static void igb_deferred_mq_start(void *, int); -#else static void igb_start(struct ifnet *); static void igb_start_locked(struct tx_ring *, struct ifnet *ifp); -#endif static int igb_ioctl(struct ifnet *, u_long, caddr_t); static void igb_init(void *); static void igb_init_locked(struct adapter *); @@ -361,7 +356,6 @@ TUNABLE_INT("hw.igb.max_interrupt_rate", &igb_max_interrupt_rate); SYSCTL_INT(_hw_igb, OID_AUTO, max_interrupt_rate, CTLFLAG_RDTUN, &igb_max_interrupt_rate, 0, "Maximum interrupts per second"); -#ifndef IGB_LEGACY_TX /* ** Tuneable number of buffers in the buf-ring (drbr_xxx) */ @@ -369,7 +363,6 @@ static int igb_buf_ring_size = IGB_BR_SIZE; TUNABLE_INT("hw.igb.buf_ring_size", &igb_buf_ring_size); SYSCTL_INT(_hw_igb, OID_AUTO, buf_ring_size, CTLFLAG_RDTUN, &igb_buf_ring_size, 0, "Size of the bufring"); -#endif /* ** Header split causes the packet header to @@ -876,15 +869,15 @@ igb_resume(device_t dev) (ifp->if_drv_flags & IFF_DRV_RUNNING) && adapter->link_active) { for (int i = 0; i < adapter->num_queues; i++, txr++) { IGB_TX_LOCK(txr); -#ifndef IGB_LEGACY_TX + /* Process the stack queue only if not depleted */ if (((txr->queue_status & IGB_QUEUE_DEPLETED) == 0) && !drbr_empty(ifp, txr->br)) igb_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) igb_start_locked(txr, ifp); -#endif + IGB_TX_UNLOCK(txr); } } @@ -894,7 +887,6 @@ igb_resume(device_t dev) } -#ifdef IGB_LEGACY_TX /********************************************************************* * Transmit entry point @@ -972,7 +964,6 @@ igb_start(struct ifnet *ifp) return; } -#else /* ~IGB_LEGACY_TX */ /* ** Multiqueue Transmit Entry: @@ -1092,7 +1083,6 @@ igb_qflush(struct ifnet *ifp) } if_qflush(ifp); } -#endif /* ~IGB_LEGACY_TX */ /********************************************************************* * Ioctl entry point @@ -1427,15 +1417,15 @@ igb_handle_que(void *context, int pending) IGB_TX_LOCK(txr); igb_txeof(txr); -#ifndef IGB_LEGACY_TX + /* Process the stack queue only if not depleted */ if (((txr->queue_status & IGB_QUEUE_DEPLETED) == 0) && !drbr_empty(ifp, txr->br)) igb_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) igb_start_locked(txr, ifp); -#endif + IGB_TX_UNLOCK(txr); /* Do we need another? */ if (more) { @@ -1478,15 +1468,15 @@ igb_handle_link_locked(struct adapter *adapter) if ((ifp->if_drv_flags & IFF_DRV_RUNNING) && adapter->link_active) { for (int i = 0; i < adapter->num_queues; i++, txr++) { IGB_TX_LOCK(txr); -#ifndef IGB_LEGACY_TX + /* Process the stack queue only if not depleted */ if (((txr->queue_status & IGB_QUEUE_DEPLETED) == 0) && !drbr_empty(ifp, txr->br)) igb_mq_start_locked(ifp, txr); -#else + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) igb_start_locked(txr, ifp); -#endif + IGB_TX_UNLOCK(txr); } } @@ -1580,13 +1570,10 @@ igb_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) do { more = igb_txeof(txr); } while (loop-- && more); -#ifndef IGB_LEGACY_TX if (!drbr_empty(ifp, txr->br)) igb_mq_start_locked(ifp, txr); -#else if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) igb_start_locked(txr, ifp); -#endif IGB_TX_UNLOCK(txr); } @@ -1619,15 +1606,12 @@ igb_msix_que(void *arg) IGB_TX_LOCK(txr); igb_txeof(txr); -#ifndef IGB_LEGACY_TX /* Process the stack queue only if not depleted */ if (((txr->queue_status & IGB_QUEUE_DEPLETED) == 0) && !drbr_empty(ifp, txr->br)) igb_mq_start_locked(ifp, txr); -#else if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) igb_start_locked(txr, ifp); -#endif IGB_TX_UNLOCK(txr); more_rx = igb_rxeof(que, adapter->rx_process_limit, NULL); @@ -2390,9 +2374,7 @@ igb_allocate_legacy(struct adapter *adapter) { device_t dev = adapter->dev; struct igb_queue *que = adapter->queues; -#ifndef IGB_LEGACY_TX struct tx_ring *txr = adapter->tx_rings; -#endif int error, rid = 0; /* Turn off all interrupts */ @@ -2411,9 +2393,7 @@ igb_allocate_legacy(struct adapter *adapter) return (ENXIO); } -#ifndef IGB_LEGACY_TX TASK_INIT(&txr->txq_task, 0, igb_deferred_mq_start, txr); -#endif /* * Try allocating a fast interrupt and the associated deferred @@ -2495,10 +2475,8 @@ igb_allocate_msix(struct adapter *adapter) i,igb_last_bind_cpu); igb_last_bind_cpu = CPU_NEXT(igb_last_bind_cpu); } -#ifndef IGB_LEGACY_TX TASK_INIT(&que->txr->txq_task, 0, igb_deferred_mq_start, que->txr); -#endif /* Make tasklet for deferred handling */ TASK_INIT(&que->que_task, 0, igb_handle_que, que); que->tq = taskqueue_create("igb_que", M_NOWAIT, @@ -2722,9 +2700,9 @@ igb_free_pci_resources(struct adapter *adapter) for (int i = 0; i < adapter->num_queues; i++, que++) { if (que->tq != NULL) { -#ifndef IGB_LEGACY_TX + taskqueue_drain(que->tq, &que->txr->txq_task); -#endif + taskqueue_drain(que->tq, &que->que_task); taskqueue_free(que->tq); } @@ -3125,15 +3103,15 @@ igb_setup_interface(device_t dev, struct adapter *adapter) ifp->if_softc = adapter; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; ifp->if_ioctl = igb_ioctl; -#ifndef IGB_LEGACY_TX + ifp->if_transmit = igb_mq_start; ifp->if_qflush = igb_qflush; -#else + ifp->if_start = igb_start; IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1); ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1; IFQ_SET_READY(&ifp->if_snd); -#endif + ether_ifattach(ifp, adapter->hw.mac.addr); @@ -3372,11 +3350,11 @@ igb_allocate_queues(struct adapter *adapter) error = ENOMEM; goto err_tx_desc; } -#ifndef IGB_LEGACY_TX + /* Allocate a buf ring */ txr->br = buf_ring_alloc(igb_buf_ring_size, M_DEVBUF, M_WAITOK, &txr->tx_mtx); -#endif + } /* @@ -3433,9 +3411,9 @@ err_tx_desc: igb_dma_free(adapter, &txr->txdma); free(adapter->rx_rings, M_DEVBUF); rx_fail: -#ifndef IGB_LEGACY_TX + buf_ring_free(txr->br, M_DEVBUF); -#endif + free(adapter->tx_rings, M_DEVBUF); tx_fail: free(adapter->queues, M_DEVBUF); @@ -3691,10 +3669,10 @@ igb_free_transmit_buffers(struct tx_ring *txr) tx_buffer->map = NULL; } } -#ifndef IGB_LEGACY_TX + if (txr->br != NULL) buf_ring_free(txr->br, M_DEVBUF); -#endif + if (txr->tx_buffers != NULL) { free(txr->tx_buffers, M_DEVBUF); txr->tx_buffers = NULL; @@ -5000,10 +4978,10 @@ igb_rxeof(struct igb_queue *que, int count, int *done) */ M_HASHTYPE_SET(rxr->fmp, M_HASHTYPE_OPAQUE); } else { -#ifndef IGB_LEGACY_TX + rxr->fmp->m_pkthdr.flowid = que->msix; M_HASHTYPE_SET(rxr->fmp, M_HASHTYPE_OPAQUE); -#endif + } sendmp = rxr->fmp; /* Make sure to set M_PKTHDR. */ diff --git a/sys/dev/gpioapu/gpioapu.c b/sys/dev/gpioapu/gpioapu.c new file mode 100644 index 0000000..11e5e13 --- /dev/null +++ b/sys/dev/gpioapu/gpioapu.c @@ -0,0 +1,336 @@ +/*- + * Copyright (c) 2013 Ermal Luci <eri@FreeBSD.org> + * 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> + +#include <sys/types.h> +#include <sys/param.h> +#include <sys/conf.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/systm.h> +#include <sys/sysctl.h> +#include <sys/priv.h> +#include <sys/bus.h> +#include <machine/bus.h> +#include <sys/rman.h> +#include <machine/resource.h> +#include <sys/proc.h> +#include <sys/uio.h> + +#include <dev/pci/pcivar.h> +#include <isa/isavar.h> + +/* SB7xx RRG 2.3.3.1.1. */ +#define AMDSB_PMIO_INDEX 0xcd6 +#define AMDSB_PMIO_DATA (PMIO_INDEX + 1) +#define AMDSB_PMIO_WIDTH 2 + +#define AMDSB_SMBUS_DEVID 0x43851002 +#define AMDSB8_SMBUS_REVID 0x40 + +#define IOMUX_OFFSET 0xD00 +#define GPIO_SPACE_OFFSET 0x100 +#define GPIO_SPACE_SIZE 0x100 +/* SB8xx RRG 2.3.3. */ +#define AMDSB8_PM_WDT_EN 0x24 + +#define GPIO_187 187 // MODESW +#define GPIO_189 189 // LED1# +#define GPIO_190 190 // LED2# +#define GPIO_191 191 // LED3# +#define GPIO_OUTPUT 0x08 +#define GPIO_INPUT 0x28 + +struct gpioapu_softc { + device_t dev; + struct cdev *cdev; + struct resource *res_ctrl; + struct resource *res_count; + int rid_ctrl; + int rid_count; +}; + +static int gpioapu_open(struct cdev *dev, int flags, int fmt, + struct thread *td); +static int gpioapu_close(struct cdev *dev, int flags, int fmt, + struct thread *td); +static int gpioapu_write(struct cdev *dev, struct uio *uio, int ioflag); +static int gpioapu_read(struct cdev *dev, struct uio *uio, int ioflag); + +static struct cdevsw gpioapu_cdevsw = { + .d_version = D_VERSION, + .d_open = gpioapu_open, + .d_read = gpioapu_read, + .d_write = gpioapu_write, + .d_close = gpioapu_close, + .d_name = "gpioapu", +}; + +static void gpioapu_identify(driver_t *driver, device_t parent); +static int gpioapu_probe(device_t dev); +static int gpioapu_attach(device_t dev); +static int gpioapu_detach(device_t dev); + +static device_method_t gpioapu_methods[] = { + DEVMETHOD(device_identify, gpioapu_identify), + DEVMETHOD(device_probe, gpioapu_probe), + DEVMETHOD(device_attach, gpioapu_attach), + DEVMETHOD(device_detach, gpioapu_detach), + {0, 0} +}; + +static devclass_t gpioapu_devclass; + +static driver_t gpioapu_driver = { + "gpioapu", + gpioapu_methods, + sizeof(struct gpioapu_softc) +}; + +DRIVER_MODULE(gpioapu, isa, gpioapu_driver, gpioapu_devclass, NULL, NULL); + + +static uint8_t +pmio_read(struct resource *res, uint8_t reg) +{ + bus_write_1(res, 0, reg); /* Index */ + return (bus_read_1(res, 1)); /* Data */ +} + +#if 0 +static void +pmio_write(struct resource *res, uint8_t reg, uint8_t val) +{ + bus_write_1(res, 0, reg); /* Index */ + bus_write_1(res, 1, val); /* Data */ +} +#endif + +/* ARGSUSED */ +static int +gpioapu_open(struct cdev *dev __unused, int flags __unused, int fmt __unused, + struct thread *td) +{ + int error; + + error = priv_check(td, PRIV_IO); + if (error != 0) + return (error); + error = securelevel_gt(td->td_ucred, 0); + if (error != 0) + return (error); + + return (error); +} + +static int +gpioapu_read(struct cdev *dev, struct uio *uio, int ioflag) { + struct gpioapu_softc *sc = dev->si_drv1; + uint8_t tmp; + char ch; + int error; + + tmp = bus_read_1(sc->res_ctrl, GPIO_187); +#ifdef DEBUG + device_printf(sc->dev, "returned %x\n", (u_int)tmp); +#endif + if (tmp & 0x80) + ch = '1'; + else + ch = '0'; + + error = uiomove(&ch, sizeof(ch), uio); + + return (error); +} +static int +gpioapu_write(struct cdev *dev, struct uio *uio, int ioflag) { + struct gpioapu_softc *sc = dev->si_drv1; + char ch[3]; + uint8_t old; + int error, i, start; + + error = uiomove(ch, sizeof(ch), uio); + if (error) + return (error); + + start = GPIO_189; + for (i = 0; i < 3; i++) { + old = bus_read_1(sc->res_ctrl, start + i); +#ifdef DEBUG + device_printf(sc->dev, "returned %x - %c\n", (u_int)old, ch[i]); +#endif + if (ch[i] == '1') + old &= 0x80; + else + old = 0xc8; + bus_write_1(sc->res_ctrl, start + i, old); + } + + return (error); +} + +static int +gpioapu_close(struct cdev *dev __unused, int flags __unused, int fmt __unused, + struct thread *td) +{ + struct gpioapu_softc *sc = dev->si_drv1; + int i, start; + + start = GPIO_187; + for (i = 0; i < 2; i++) { + bus_write_1(sc->res_ctrl, start, 0xc8); + } + + return (0); +} + +static void +gpioapu_identify(driver_t *driver, device_t parent) +{ + device_t child; + device_t smb_dev; + + if (resource_disabled("gpioapu", 0)) + return; + + + if (device_find_child(parent, "gpioapu", -1) != NULL) + return; + + /* + * Try to identify SB600/SB7xx by PCI Device ID of SMBus device + * that should be present at bus 0, device 20, function 0. + */ + smb_dev = pci_find_bsf(0, 20, 0); + if (smb_dev == NULL) + return; + + if (pci_get_devid(smb_dev) != AMDSB_SMBUS_DEVID) + return; + + child = BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE, "gpioapu", -1); + if (child == NULL) + device_printf(parent, "add gpioapu child failed\n"); +} + +static int +gpioapu_probe(device_t dev) +{ + struct resource *res; + uint32_t addr; + int rid; + int rc, i; + char *value; + + value = getenv("smbios.system.product"); + device_printf(dev, "Environment returned %s\n", value); + if (value == NULL || strncmp(value, "APU", strlen("APU"))) + return (ENXIO); + + /* Do not claim some ISA PnP device by accident. */ + if (isa_get_logicalid(dev) != 0) + return (ENXIO); + + rc = bus_set_resource(dev, SYS_RES_IOPORT, 0, AMDSB_PMIO_INDEX, + AMDSB_PMIO_WIDTH); + if (rc != 0) { + device_printf(dev, "bus_set_resource for IO failed\n"); + return (ENXIO); + } + rid = 0; + res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0ul, ~0ul, + AMDSB_PMIO_WIDTH, RF_ACTIVE | RF_SHAREABLE); + if (res == NULL) { + device_printf(dev, "bus_alloc_resource for IO failed\n"); + return (ENXIO); + } + + /* Find base address of memory mapped WDT registers. */ + for (addr = 0, i = 0; i < 4; i++) { + addr <<= 8; + addr |= pmio_read(res, AMDSB8_PM_WDT_EN + 3 - i); + } + addr &= 0xFFFFF000; + device_printf(dev, "Address on reg 0x24 is 0x%x/%u\n", addr, addr); + + bus_release_resource(dev, SYS_RES_IOPORT, rid, res); + bus_delete_resource(dev, SYS_RES_IOPORT, rid); + + rc = bus_set_resource(dev, SYS_RES_MEMORY, 0, addr + GPIO_SPACE_OFFSET, + GPIO_SPACE_SIZE); + if (rc != 0) { + device_printf(dev, "bus_set_resource for memory failed\n"); + return (ENXIO); + } + + return (0); +} + +static int +gpioapu_attach(device_t dev) +{ + struct gpioapu_softc *sc; + + sc = device_get_softc(dev); + sc->dev = dev; + sc->rid_ctrl = 0; + + sc->res_ctrl = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->rid_ctrl, 0ul, ~0ul, + GPIO_SPACE_SIZE, RF_ACTIVE | RF_SHAREABLE); + if (sc->res_ctrl == NULL) { + device_printf(dev, "bus_alloc_resource for memory failed\n"); + return (ENXIO); + } + + sc->dev = dev; + sc->cdev = make_dev(&gpioapu_cdevsw, 0, + UID_ROOT, GID_WHEEL, 0600, "gpioapu"); + + sc->cdev->si_drv1 = sc; + + return (0); + +} + +static int +gpioapu_detach(device_t dev) +{ + struct gpioapu_softc *sc; + + sc = device_get_softc(dev); + + if (sc->res_ctrl != NULL) { + bus_release_resource(dev, SYS_RES_MEMORY, sc->rid_ctrl, + sc->res_ctrl); + bus_delete_resource(dev, SYS_RES_MEMORY, sc->rid_ctrl); + } + + destroy_dev(sc->cdev); + + return (0); +} diff --git a/sys/dev/ichwd/ichwd.c b/sys/dev/ichwd/ichwd.c index 9f8704f..73fcd7e 100644 --- a/sys/dev/ichwd/ichwd.c +++ b/sys/dev/ichwd/ichwd.c @@ -53,6 +53,7 @@ * (document no. 252516-001) sections 9.10 and 9.11. * * ICH6/7/8 support by Takeharu KATO <takeharu1219@ybb.ne.jp> + * SoC PMC support by Denir Li <denir.li@cas-well.com> */ #include <sys/cdefs.h> @@ -74,161 +75,216 @@ __FBSDID("$FreeBSD$"); #include <dev/ichwd/ichwd.h> static struct ichwd_device ichwd_devices[] = { - { DEVICEID_82801AA, "Intel 82801AA watchdog timer", 1 }, - { DEVICEID_82801AB, "Intel 82801AB watchdog timer", 1 }, - { DEVICEID_82801BA, "Intel 82801BA watchdog timer", 2 }, - { DEVICEID_82801BAM, "Intel 82801BAM watchdog timer", 2 }, - { DEVICEID_82801CA, "Intel 82801CA watchdog timer", 3 }, - { DEVICEID_82801CAM, "Intel 82801CAM watchdog timer", 3 }, - { DEVICEID_82801DB, "Intel 82801DB watchdog timer", 4 }, - { DEVICEID_82801DBM, "Intel 82801DBM watchdog timer", 4 }, - { DEVICEID_82801E, "Intel 82801E watchdog timer", 5 }, - { DEVICEID_82801EB, "Intel 82801EB watchdog timer", 5 }, - { DEVICEID_82801EBR, "Intel 82801EB/ER watchdog timer", 5 }, - { DEVICEID_6300ESB, "Intel 6300ESB watchdog timer", 5 }, - { DEVICEID_82801FBR, "Intel 82801FB/FR watchdog timer", 6 }, - { DEVICEID_ICH6M, "Intel ICH6M watchdog timer", 6 }, - { DEVICEID_ICH6W, "Intel ICH6W watchdog timer", 6 }, - { DEVICEID_ICH7, "Intel ICH7 watchdog timer", 7 }, - { DEVICEID_ICH7DH, "Intel ICH7DH watchdog timer", 7 }, - { DEVICEID_ICH7M, "Intel ICH7M watchdog timer", 7 }, - { DEVICEID_ICH7MDH, "Intel ICH7MDH watchdog timer", 7 }, - { DEVICEID_NM10, "Intel NM10 watchdog timer", 7 }, - { DEVICEID_ICH8, "Intel ICH8 watchdog timer", 8 }, - { DEVICEID_ICH8DH, "Intel ICH8DH watchdog timer", 8 }, - { DEVICEID_ICH8DO, "Intel ICH8DO watchdog timer", 8 }, - { DEVICEID_ICH8M, "Intel ICH8M watchdog timer", 8 }, - { DEVICEID_ICH8ME, "Intel ICH8M-E watchdog timer", 8 }, - { DEVICEID_63XXESB, "Intel 63XXESB watchdog timer", 8 }, - { DEVICEID_ICH9, "Intel ICH9 watchdog timer", 9 }, - { DEVICEID_ICH9DH, "Intel ICH9DH watchdog timer", 9 }, - { DEVICEID_ICH9DO, "Intel ICH9DO watchdog timer", 9 }, - { DEVICEID_ICH9M, "Intel ICH9M watchdog timer", 9 }, - { DEVICEID_ICH9ME, "Intel ICH9M-E watchdog timer", 9 }, - { DEVICEID_ICH9R, "Intel ICH9R watchdog timer", 9 }, - { DEVICEID_ICH10, "Intel ICH10 watchdog timer", 10 }, - { DEVICEID_ICH10D, "Intel ICH10D watchdog timer", 10 }, - { DEVICEID_ICH10DO, "Intel ICH10DO watchdog timer", 10 }, - { DEVICEID_ICH10R, "Intel ICH10R watchdog timer", 10 }, - { DEVICEID_PCH, "Intel PCH watchdog timer", 10 }, - { DEVICEID_PCHM, "Intel PCH watchdog timer", 10 }, - { DEVICEID_P55, "Intel P55 watchdog timer", 10 }, - { DEVICEID_PM55, "Intel PM55 watchdog timer", 10 }, - { DEVICEID_H55, "Intel H55 watchdog timer", 10 }, - { DEVICEID_QM57, "Intel QM57 watchdog timer", 10 }, - { DEVICEID_H57, "Intel H57 watchdog timer", 10 }, - { DEVICEID_HM55, "Intel HM55 watchdog timer", 10 }, - { DEVICEID_Q57, "Intel Q57 watchdog timer", 10 }, - { DEVICEID_HM57, "Intel HM57 watchdog timer", 10 }, - { DEVICEID_PCHMSFF, "Intel PCHMSFF watchdog timer", 10 }, - { DEVICEID_QS57, "Intel QS57 watchdog timer", 10 }, - { DEVICEID_3400, "Intel 3400 watchdog timer", 10 }, - { DEVICEID_3420, "Intel 3420 watchdog timer", 10 }, - { DEVICEID_3450, "Intel 3450 watchdog timer", 10 }, - { DEVICEID_CPT0, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT1, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT2, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT3, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT4, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT5, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT6, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT7, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT8, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT9, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT10, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT11, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT12, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT13, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT14, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT15, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT16, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT17, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT18, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT19, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT20, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT21, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT22, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT23, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT23, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT25, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT26, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT27, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT28, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT29, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT30, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_CPT31, "Intel Cougar Point watchdog timer", 10 }, - { DEVICEID_PATSBURG_LPC1, "Intel Patsburg watchdog timer", 10 }, - { DEVICEID_PATSBURG_LPC2, "Intel Patsburg watchdog timer", 10 }, - { DEVICEID_PPT0, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT1, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT2, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT3, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT4, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT5, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT6, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT7, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT8, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT9, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT10, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT11, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT12, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT13, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT14, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT15, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT16, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT17, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT18, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT19, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT20, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT21, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT22, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT23, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT24, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT25, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT26, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT27, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT28, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT29, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT30, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_PPT31, "Intel Panther Point watchdog timer", 10 }, - { DEVICEID_LPT0, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT1, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT2, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT3, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT4, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT5, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT6, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT7, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT8, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT9, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT10, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT11, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT12, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT13, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT14, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT15, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT16, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT17, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT18, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT19, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT20, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT21, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT22, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT23, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT24, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT25, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT26, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT27, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT28, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT29, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT30, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_LPT31, "Intel Lynx Point watchdog timer", 10 }, - { DEVICEID_WCPT2, "Intel Wildcat Point watchdog timer", 10 }, - { DEVICEID_WCPT4, "Intel Wildcat Point watchdog timer", 10 }, - { DEVICEID_WCPT6, "Intel Wildcat Point watchdog timer", 10 }, - { DEVICEID_DH89XXCC_LPC, "Intel DH89xxCC watchdog timer", 10 }, - { DEVICEID_COLETOCRK_LPC, "Intel Coleto Creek watchdog timer", 10 }, - { 0, NULL, 0 }, + { DEVICEID_82801AA, "Intel 82801AA watchdog timer", 1, 1 }, + { DEVICEID_82801AB, "Intel 82801AB watchdog timer", 1, 1 }, + { DEVICEID_82801BA, "Intel 82801BA watchdog timer", 2, 1 }, + { DEVICEID_82801BAM, "Intel 82801BAM watchdog timer", 2, 1 }, + { DEVICEID_82801CA, "Intel 82801CA watchdog timer", 3, 1 }, + { DEVICEID_82801CAM, "Intel 82801CAM watchdog timer", 3, 1 }, + { DEVICEID_82801DB, "Intel 82801DB watchdog timer", 4, 1 }, + { DEVICEID_82801DBM, "Intel 82801DBM watchdog timer", 4, 1 }, + { DEVICEID_82801E, "Intel 82801E watchdog timer", 5, 1 }, + { DEVICEID_82801EB, "Intel 82801EB watchdog timer", 5, 1 }, + { DEVICEID_82801EBR, "Intel 82801EB/ER watchdog timer", 5, 1 }, + { DEVICEID_6300ESB, "Intel 6300ESB watchdog timer", 5, 1 }, + { DEVICEID_82801FBR, "Intel 82801FB/FR watchdog timer", 6, 2 }, + { DEVICEID_ICH6M, "Intel ICH6M watchdog timer", 6, 2 }, + { DEVICEID_ICH6W, "Intel ICH6W watchdog timer", 6, 2 }, + { DEVICEID_ICH7, "Intel ICH7 watchdog timer", 7, 2 }, + { DEVICEID_ICH7DH, "Intel ICH7DH watchdog timer", 7, 2 }, + { DEVICEID_ICH7M, "Intel ICH7M watchdog timer", 7, 2 }, + { DEVICEID_ICH7MDH, "Intel ICH7MDH watchdog timer", 7, 2 }, + { DEVICEID_NM10, "Intel NM10 watchdog timer", 7, 2 }, + { DEVICEID_ICH8, "Intel ICH8 watchdog timer", 8, 2 }, + { DEVICEID_ICH8DH, "Intel ICH8DH watchdog timer", 8, 2 }, + { DEVICEID_ICH8DO, "Intel ICH8DO watchdog timer", 8, 2 }, + { DEVICEID_ICH8M, "Intel ICH8M watchdog timer", 8, 2 }, + { DEVICEID_ICH8ME, "Intel ICH8M-E watchdog timer", 8, 2 }, + { DEVICEID_63XXESB, "Intel 63XXESB watchdog timer", 8, 2 }, + { DEVICEID_ICH9, "Intel ICH9 watchdog timer", 9, 2 }, + { DEVICEID_ICH9DH, "Intel ICH9DH watchdog timer", 9, 2 }, + { DEVICEID_ICH9DO, "Intel ICH9DO watchdog timer", 9, 2 }, + { DEVICEID_ICH9M, "Intel ICH9M watchdog timer", 9, 2 }, + { DEVICEID_ICH9ME, "Intel ICH9M-E watchdog timer", 9, 2 }, + { DEVICEID_ICH9R, "Intel ICH9R watchdog timer", 9, 2 }, + { DEVICEID_ICH10, "Intel ICH10 watchdog timer", 10, 2 }, + { DEVICEID_ICH10D, "Intel ICH10D watchdog timer", 10, 2 }, + { DEVICEID_ICH10DO, "Intel ICH10DO watchdog timer", 10, 2 }, + { DEVICEID_ICH10R, "Intel ICH10R watchdog timer", 10, 2 }, + { DEVICEID_PCH, "Intel PCH watchdog timer", 10, 2 }, + { DEVICEID_PCHM, "Intel PCH watchdog timer", 10, 2 }, + { DEVICEID_P55, "Intel P55 watchdog timer", 10, 2 }, + { DEVICEID_PM55, "Intel PM55 watchdog timer", 10, 2 }, + { DEVICEID_H55, "Intel H55 watchdog timer", 10, 2 }, + { DEVICEID_QM57, "Intel QM57 watchdog timer", 10, 2 }, + { DEVICEID_H57, "Intel H57 watchdog timer", 10, 2 }, + { DEVICEID_HM55, "Intel HM55 watchdog timer", 10, 2 }, + { DEVICEID_Q57, "Intel Q57 watchdog timer", 10, 2 }, + { DEVICEID_HM57, "Intel HM57 watchdog timer", 10, 2 }, + { DEVICEID_PCHMSFF, "Intel PCHMSFF watchdog timer", 10, 2 }, + { DEVICEID_QS57, "Intel QS57 watchdog timer", 10, 2 }, + { DEVICEID_3400, "Intel 3400 watchdog timer", 10, 2 }, + { DEVICEID_3420, "Intel 3420 watchdog timer", 10, 2 }, + { DEVICEID_3450, "Intel 3450 watchdog timer", 10, 2 }, + { DEVICEID_CPT0, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT1, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT2, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT3, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT4, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT5, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT6, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT7, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT8, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT9, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT10, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT11, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT12, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT13, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT14, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT15, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT16, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT17, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT18, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT19, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT20, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT21, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT22, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT23, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT24, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT25, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT26, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT27, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT28, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT29, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT30, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_CPT31, "Intel Cougar Point watchdog timer", 10, 2 }, + { DEVICEID_PATSBURG_LPC1, "Intel Patsburg watchdog timer", 10, 2 }, + { DEVICEID_PATSBURG_LPC2, "Intel Patsburg watchdog timer", 10, 2 }, + { DEVICEID_PPT0, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT1, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT2, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT3, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT4, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT5, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT6, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT7, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT8, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT9, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT10, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT11, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT12, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT13, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT14, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT15, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT16, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT17, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT18, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT19, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT20, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT21, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT22, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT23, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT24, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT25, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT26, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT27, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT28, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT29, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT30, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_PPT31, "Intel Panther Point watchdog timer", 10, 2 }, + { DEVICEID_LPT0, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT1, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT2, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT3, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT4, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT5, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT6, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT7, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT8, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT9, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT10, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT11, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT12, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT13, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT14, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT15, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT16, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT17, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT18, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT19, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT20, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT21, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT22, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT23, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT24, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT25, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT26, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT27, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT28, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT29, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT30, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_LPT31, "Intel Lynx Point watchdog timer", 10, 2 }, + { DEVICEID_WCPT1, "Intel Wildcat Point watchdog timer", 10, 2 }, + { DEVICEID_WCPT2, "Intel Wildcat Point watchdog timer", 10, 2 }, + { DEVICEID_WCPT3, "Intel Wildcat Point watchdog timer", 10, 2 }, + { DEVICEID_WCPT4, "Intel Wildcat Point watchdog timer", 10, 2 }, + { DEVICEID_WCPT6, "Intel Wildcat Point watchdog timer", 10, 2 }, + { DEVICEID_WBG0, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG1, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG2, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG3, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG4, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG5, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG6, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG7, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG8, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG9, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG10, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG11, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG12, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG13, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG14, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG15, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG16, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG17, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG18, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG19, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG20, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG21, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG22, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG23, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG24, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG25, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG26, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG27, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG28, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG29, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG30, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_WBG31, "Intel Wellsburg watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP0, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP1, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP2, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP3, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP4, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP5, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP6, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_LPT_LP7, "Intel Lynx Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP1, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP2, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP3, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP5, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP6, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP7, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_WCPT_LP9, "Intel Wildcat Point-LP watchdog timer", 10, 2 }, + { DEVICEID_DH89XXCC_LPC, "Intel DH89xxCC watchdog timer", 10, 2 }, + { DEVICEID_COLETOCRK_LPC, "Intel Coleto Creek watchdog timer", 10, 2 }, + { DEVICEID_AVN0, "Intel Avoton/Rangeley SoC watchdog timer",10, 3 }, + { DEVICEID_AVN1, "Intel Avoton/Rangeley SoC watchdog timer",10, 3 }, + { DEVICEID_AVN2, "Intel Avoton/Rangeley SoC watchdog timer",10, 3 }, + { DEVICEID_AVN3, "Intel Avoton/Rangeley SoC watchdog timer",10, 3 }, + { DEVICEID_BAYTRAIL, "Intel Bay Trail SoC watchdog timer", 10, 3 }, + { DEVICEID_BRASWELL, "Intel Braswell SoC watchdog timer", 10, 3 }, + { 0, NULL, 0, 0 }, }; static devclass_t ichwd_devclass; @@ -241,7 +297,7 @@ static devclass_t ichwd_devclass; bus_read_4((sc)->tco_res, (off)) #define ichwd_read_smi_4(sc, off) \ bus_read_4((sc)->smi_res, (off)) -#define ichwd_read_gcs_4(sc, off) \ +#define ichwd_read_gcs_pmc_4(sc, off) \ bus_read_4((sc)->gcs_res, (off)) #define ichwd_write_tco_1(sc, off, val) \ @@ -252,7 +308,7 @@ static devclass_t ichwd_devclass; bus_write_4((sc)->tco_res, (off), (val)) #define ichwd_write_smi_4(sc, off, val) \ bus_write_4((sc)->smi_res, (off), (val)) -#define ichwd_write_gcs_4(sc, off, val) \ +#define ichwd_write_gcs_pmc_4(sc, off, val) \ bus_write_4((sc)->gcs_res, (off), (val)) #define ichwd_verbose_printf(dev, ...) \ @@ -352,7 +408,7 @@ ichwd_tmr_disable(struct ichwd_softc *sc) static __inline void ichwd_tmr_reload(struct ichwd_softc *sc) { - if (sc->ich_version <= 5) + if (sc->tco_version == 1) ichwd_write_tco_1(sc, TCO_RLD, 1); else ichwd_write_tco_2(sc, TCO_RLD, 1); @@ -369,7 +425,7 @@ ichwd_tmr_set(struct ichwd_softc *sc, unsigned int timeout) if (timeout < TCO_RLD_TMR_MIN) timeout = TCO_RLD_TMR_MIN; - if (sc->ich_version <= 5) { + if (sc->tco_version == 1) { uint8_t tmr_val8 = ichwd_read_tco_1(sc, TCO_TMR1); tmr_val8 &= (~TCO_RLD1_TMR_MAX & 0xff); @@ -399,20 +455,40 @@ ichwd_clear_noreboot(struct ichwd_softc *sc) int rc = 0; /* try to clear the NO_REBOOT bit */ - if (sc->ich_version <= 5) { - status = pci_read_config(sc->ich, ICH_GEN_STA, 1); - status &= ~ICH_GEN_STA_NO_REBOOT; - pci_write_config(sc->ich, ICH_GEN_STA, status, 1); - status = pci_read_config(sc->ich, ICH_GEN_STA, 1); - if (status & ICH_GEN_STA_NO_REBOOT) - rc = EIO; - } else { - status = ichwd_read_gcs_4(sc, 0); - status &= ~ICH_GCS_NO_REBOOT; - ichwd_write_gcs_4(sc, 0, status); - status = ichwd_read_gcs_4(sc, 0); - if (status & ICH_GCS_NO_REBOOT) - rc = EIO; + switch (sc->tco_version) + { + case 1: + status = pci_read_config(sc->ich, ICH_GEN_STA, 1); + status &= ~ICH_GEN_STA_NO_REBOOT; + pci_write_config(sc->ich, ICH_GEN_STA, status, 1); + status = pci_read_config(sc->ich, ICH_GEN_STA, 1); + if (status & ICH_GEN_STA_NO_REBOOT) + rc = EIO; + break; + + case 2: + status = ichwd_read_gcs_pmc_4(sc, 0); + status &= ~ICH_GCS_NO_REBOOT; + ichwd_write_gcs_pmc_4(sc, 0, status); + status = ichwd_read_gcs_pmc_4(sc, 0); + if (status & ICH_GCS_NO_REBOOT) + rc = EIO; + break; + + case 3: + status = ichwd_read_gcs_pmc_4(sc, 0); + status &= ~ICH_PMC_NO_REBOOT; + ichwd_write_gcs_pmc_4(sc, 0, status); + status = ichwd_read_gcs_pmc_4(sc, 0); + if (status & ICH_PMC_NO_REBOOT) + rc = EIO; + break; + + default: + ichwd_verbose_printf(sc->device, + "Unknown TCO Version: %d, can't set NO_REBOOT.\n", + sc->tco_version); + break; } if (rc) @@ -463,7 +539,7 @@ ichwd_find_ich_lpc_bridge(struct ichwd_device **id_p) return (NULL); ichwd_verbose_printf(ich, "found ICH%d or equivalent chipset: %s\n", - id->version, id->desc); + id->ich_version, id->desc); if (id_p) *id_p = id; @@ -481,7 +557,7 @@ ichwd_identify(driver_t *driver, device_t parent) struct ichwd_device *id_p; device_t ich = NULL; device_t dev; - uint32_t rcba; + uint32_t base_address; int rc; ich = ichwd_find_ich_lpc_bridge(&id_p); @@ -497,14 +573,40 @@ ichwd_identify(driver_t *driver, device_t parent) device_set_desc_copy(dev, id_p->desc); - if (id_p->version >= 6) { - /* get RCBA (root complex base address) */ - rcba = pci_read_config(ich, ICH_RCBA, 4); - rc = bus_set_resource(ich, SYS_RES_MEMORY, 0, - (rcba & 0xffffc000) + ICH_GCS_OFFSET, ICH_GCS_SIZE); - if (rc) + switch (id_p->tco_version) + { + case 1: + break; + + case 2: + /* get RCBA (root complex base address) */ + base_address = pci_read_config(ich, ICH_RCBA, 4); + rc = bus_set_resource(ich, SYS_RES_MEMORY, 0, + (base_address & 0xffffc000) + ICH_GCS_OFFSET, + ICH_GCS_SIZE); + if (rc) + ichwd_verbose_printf(dev, + "Can not set TCO v%d memory resource for RCBA\n", + id_p->tco_version); + break; + + case 3: + /* get PBASE (Power Management Controller base address) */ + base_address = pci_read_config(ich, ICH_PBASE, 4); + rc = bus_set_resource(ich, SYS_RES_MEMORY, 0, + (base_address & 0xfffffe00) + ICH_PMC_OFFSET, + ICH_PMC_SIZE); + if (rc) + ichwd_verbose_printf(dev, + "Can not set TCO v%d memory resource for PBASE\n", + id_p->tco_version); + break; + + default: ichwd_verbose_printf(dev, - "Can not set memory resource for RCBA\n"); + "Can not set unknown TCO v%d memory resource for unknown base address\n", + id_p->tco_version); + break; } } @@ -535,7 +637,8 @@ ichwd_attach(device_t dev) goto fail; } sc->ich = ich; - sc->ich_version = id_p->version; + sc->ich_version = id_p->ich_version; + sc->tco_version = id_p->tco_version; /* get ACPI base address */ pmbase = pci_read_config(ich, ICH_PMBASE, 2) & ICH_PMBASE_MASK; @@ -564,7 +667,7 @@ ichwd_attach(device_t dev) } sc->gcs_rid = 0; - if (sc->ich_version >= 6) { + if (sc->tco_version >= 2) { sc->gcs_res = bus_alloc_resource_any(ich, SYS_RES_MEMORY, &sc->gcs_rid, RF_ACTIVE|RF_SHAREABLE); if (sc->gcs_res == NULL) { @@ -577,7 +680,7 @@ ichwd_attach(device_t dev) goto fail; ichwd_verbose_printf(dev, "%s (ICH%d or equivalent)\n", - device_get_desc(dev), sc->ich_version); + id_p->desc, sc->ich_version); /* * Determine if we are coming up after a watchdog-induced reset. Some diff --git a/sys/dev/ichwd/ichwd.h b/sys/dev/ichwd/ichwd.h index 0699279..dc24a9d 100644 --- a/sys/dev/ichwd/ichwd.h +++ b/sys/dev/ichwd/ichwd.h @@ -34,13 +34,15 @@ struct ichwd_device { uint16_t device; char *desc; - unsigned int version; + unsigned int ich_version; + unsigned int tco_version; }; struct ichwd_softc { device_t device; device_t ich; int ich_version; + int tco_version; int active; unsigned int timeout; @@ -59,6 +61,7 @@ struct ichwd_softc { }; #define VENDORID_INTEL 0x8086 +#define DEVICEID_BAYTRAIL 0x0f1c #define DEVICEID_CPT0 0x1c40 #define DEVICEID_CPT1 0x1c41 #define DEVICEID_CPT2 0x1c42 @@ -125,6 +128,11 @@ struct ichwd_softc { #define DEVICEID_PPT29 0x1e5d #define DEVICEID_PPT30 0x1e5e #define DEVICEID_PPT31 0x1e5f +#define DEVICEID_AVN0 0x1f38 +#define DEVICEID_AVN1 0x1f39 +#define DEVICEID_AVN2 0x1f3a +#define DEVICEID_AVN3 0x1f3b +#define DEVICEID_BRASWELL 0x229c #define DEVICEID_DH89XXCC_LPC 0x2310 #define DEVICEID_COLETOCRK_LPC 0x2390 #define DEVICEID_82801AA 0x2410 @@ -210,9 +218,58 @@ struct ichwd_softc { #define DEVICEID_LPT29 0x8c5d #define DEVICEID_LPT30 0x8c5e #define DEVICEID_LPT31 0x8c5f +#define DEVICEID_WCPT1 0x8cc1 #define DEVICEID_WCPT2 0x8cc2 +#define DEVICEID_WCPT3 0x8cc3 #define DEVICEID_WCPT4 0x8cc4 #define DEVICEID_WCPT6 0x8cc6 +#define DEVICEID_WBG0 0x8d40 +#define DEVICEID_WBG1 0x8d41 +#define DEVICEID_WBG2 0x8d42 +#define DEVICEID_WBG3 0x8d43 +#define DEVICEID_WBG4 0x8d44 +#define DEVICEID_WBG5 0x8d45 +#define DEVICEID_WBG6 0x8d46 +#define DEVICEID_WBG7 0x8d47 +#define DEVICEID_WBG8 0x8d48 +#define DEVICEID_WBG9 0x8d49 +#define DEVICEID_WBG10 0x8d4a +#define DEVICEID_WBG11 0x8d4b +#define DEVICEID_WBG12 0x8d4c +#define DEVICEID_WBG13 0x8d4d +#define DEVICEID_WBG14 0x8d4e +#define DEVICEID_WBG15 0x8d4f +#define DEVICEID_WBG16 0x8d50 +#define DEVICEID_WBG17 0x8d51 +#define DEVICEID_WBG18 0x8d52 +#define DEVICEID_WBG19 0x8d53 +#define DEVICEID_WBG20 0x8d54 +#define DEVICEID_WBG21 0x8d55 +#define DEVICEID_WBG22 0x8d56 +#define DEVICEID_WBG23 0x8d57 +#define DEVICEID_WBG24 0x8d58 +#define DEVICEID_WBG25 0x8d59 +#define DEVICEID_WBG26 0x8d5a +#define DEVICEID_WBG27 0x8d5b +#define DEVICEID_WBG28 0x8d5c +#define DEVICEID_WBG29 0x8d5d +#define DEVICEID_WBG30 0x8d5e +#define DEVICEID_WBG31 0x8d5f +#define DEVICEID_LPT_LP0 0x9c40 +#define DEVICEID_LPT_LP1 0x9c41 +#define DEVICEID_LPT_LP2 0x9c42 +#define DEVICEID_LPT_LP3 0x9c43 +#define DEVICEID_LPT_LP4 0x9c44 +#define DEVICEID_LPT_LP5 0x9c45 +#define DEVICEID_LPT_LP6 0x9c46 +#define DEVICEID_LPT_LP7 0x9c47 +#define DEVICEID_WCPT_LP1 0x9cc1 +#define DEVICEID_WCPT_LP2 0x9cc2 +#define DEVICEID_WCPT_LP3 0x9cc3 +#define DEVICEID_WCPT_LP5 0x9cc5 +#define DEVICEID_WCPT_LP6 0x9cc6 +#define DEVICEID_WCPT_LP7 0x9cc7 +#define DEVICEID_WCPT_LP9 0x9cc9 /* ICH LPC Interface Bridge Registers (ICH5 and older) */ #define ICH_GEN_STA 0xd4 @@ -226,6 +283,12 @@ struct ichwd_softc { #define ICH_GCS_SIZE 0x4 #define ICH_GCS_NO_REBOOT 0x20 +/* SoC Power Management Configuration Registers */ +#define ICH_PBASE 0x44 +#define ICH_PMC_OFFSET 0x08 +#define ICH_PMC_SIZE 0x4 +#define ICH_PMC_NO_REBOOT 0x10 + /* register names and locations (relative to PMBASE) */ #define SMI_BASE 0x30 /* base address for SMI registers */ #define SMI_LEN 0x08 diff --git a/sys/dev/if_ndis/if_ndis.c b/sys/dev/if_ndis/if_ndis.c index eae33c5..6533f54 100644 --- a/sys/dev/if_ndis/if_ndis.c +++ b/sys/dev/if_ndis/if_ndis.c @@ -3315,7 +3315,7 @@ done: DPRINTF(("scan: bssid %s chan %dMHz (%d/%d) rssi %d\n", ether_sprintf(wb->nwbx_macaddr), freq, sp.bchan, chanflag, rssi)); - ieee80211_add_scan(vap, &sp, &wh, 0, rssi, noise); + ieee80211_add_scan(vap, ic->ic_curchan, &sp, &wh, 0, rssi, noise); wb = (ndis_wlan_bssid_ex *)((char *)wb + wb->nwbx_len); } free(bl, M_DEVBUF); diff --git a/sys/dev/iwi/if_iwi.c b/sys/dev/iwi/if_iwi.c index e6ee051..b6de4b6 100644 --- a/sys/dev/iwi/if_iwi.c +++ b/sys/dev/iwi/if_iwi.c @@ -64,6 +64,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -83,6 +84,7 @@ __FBSDID("$FreeBSD$"); #include <dev/iwi/if_iwireg.h> #include <dev/iwi/if_iwivar.h> +#include <dev/iwi/if_iwi_ioctl.h> #define IWI_DEBUG #ifdef IWI_DEBUG @@ -936,10 +938,13 @@ iwi_media_status(struct ifnet *ifp, struct ifmediareq *imr) struct ieee80211vap *vap = ifp->if_softc; struct ieee80211com *ic = vap->iv_ic; struct iwi_softc *sc = ic->ic_ifp->if_softc; + struct ieee80211_node *ni; /* read current transmission rate from adapter */ - vap->iv_bss->ni_txrate = + ni = ieee80211_ref_node(vap->iv_bss); + ni->ni_txrate = iwi_cvtrate(CSR_READ_4(sc, IWI_CSR_CURRENT_TX_RATE)); + ieee80211_free_node(ni); ieee80211_media_status(ifp, imr); } @@ -1230,7 +1235,7 @@ iwi_frame_intr(struct iwi_softc *sc, struct iwi_rx_data *data, int i, */ mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (mnew == NULL) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } @@ -1251,7 +1256,7 @@ iwi_frame_intr(struct iwi_softc *sc, struct iwi_rx_data *data, int i, panic("%s: could not load old rx mbuf", device_get_name(sc->sc_dev)); } - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } @@ -1358,16 +1363,44 @@ iwi_checkforqos(struct ieee80211vap *vap, frm += frm[1] + 2; } - ni = vap->iv_bss; + ni = ieee80211_ref_node(vap->iv_bss); ni->ni_capinfo = capinfo; ni->ni_associd = associd & 0x3fff; if (wme != NULL) ni->ni_flags |= IEEE80211_NODE_QOS; else ni->ni_flags &= ~IEEE80211_NODE_QOS; + ieee80211_free_node(ni); #undef SUBTYPE } +static void +iwi_notif_link_quality(struct iwi_softc *sc, struct iwi_notif *notif) +{ + struct iwi_notif_link_quality *lq; + int len; + + len = le16toh(notif->len); + + DPRINTFN(5, ("Notification (%u) - len=%d, sizeof=%zu\n", + notif->type, + len, + sizeof(struct iwi_notif_link_quality) + )); + + /* enforce length */ + if (len != sizeof(struct iwi_notif_link_quality)) { + DPRINTFN(5, ("Notification: (%u) too short (%d)\n", + notif->type, + len)); + return; + } + + lq = (struct iwi_notif_link_quality *)(notif + 1); + memcpy(&sc->sc_linkqual, lq, sizeof(sc->sc_linkqual)); + sc->sc_linkqual_valid = 1; +} + /* * Task queue callbacks for iwi_notification_intr used to avoid LOR's. */ @@ -1537,9 +1570,12 @@ iwi_notification_intr(struct iwi_softc *sc, struct iwi_notif *notif) case IWI_NOTIF_TYPE_CALIBRATION: case IWI_NOTIF_TYPE_NOISE: - case IWI_NOTIF_TYPE_LINK_QUALITY: + /* XXX handle? */ DPRINTFN(5, ("Notification (%u)\n", notif->type)); break; + case IWI_NOTIF_TYPE_LINK_QUALITY: + iwi_notif_link_quality(sc, notif); + break; default: DPRINTF(("unknown notification type %u flags 0x%x len %u\n", @@ -1615,7 +1651,7 @@ iwi_tx_intr(struct iwi_softc *sc, struct iwi_tx_ring *txq) DPRINTFN(15, ("tx done idx=%u\n", txq->next)); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); txq->queued--; txq->next = (txq->next + 1) % IWI_TX_RING_COUNT; @@ -1816,7 +1852,7 @@ iwi_tx_start(struct ifnet *ifp, struct mbuf *m0, struct ieee80211_node *ni, /* h/w table is full */ m_freem(m0); ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return 0; } iwi_write_ibssnode(sc, @@ -1971,7 +2007,7 @@ iwi_start_locked(struct ifnet *ifp) ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; if (iwi_tx_start(ifp, m, ni, ac) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; } @@ -2002,7 +2038,7 @@ iwi_watchdog(void *arg) if (sc->sc_tx_timer > 0) { if (--sc->sc_tx_timer == 0) { if_printf(ifp, "device timeout\n"); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ieee80211_runtask(ic, &sc->sc_restarttask); } } @@ -2058,11 +2094,25 @@ iwi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) case SIOCGIFADDR: error = ether_ioctl(ifp, cmd, data); break; + case SIOCGIWISTATS: + IWI_LOCK(sc); + /* XXX validate permissions/memory/etc? */ + error = copyout(&sc->sc_linkqual, ifr->ifr_data, + sizeof(struct iwi_notif_link_quality)); + IWI_UNLOCK(sc); + break; + case SIOCZIWISTATS: + IWI_LOCK(sc); + memset(&sc->sc_linkqual, 0, + sizeof(struct iwi_notif_link_quality)); + IWI_UNLOCK(sc); + error = 0; + break; default: error = EINVAL; break; } - return error; + return error; } static void @@ -2803,7 +2853,7 @@ iwi_auth_and_assoc(struct iwi_softc *sc, struct ieee80211vap *vap) { struct ieee80211com *ic = vap->iv_ic; struct ifnet *ifp = vap->iv_ifp; - struct ieee80211_node *ni = vap->iv_bss; + struct ieee80211_node *ni; struct iwi_configuration config; struct iwi_associate *assoc = &sc->assoc; struct iwi_rateset rs; @@ -2813,6 +2863,8 @@ iwi_auth_and_assoc(struct iwi_softc *sc, struct ieee80211vap *vap) IWI_LOCK_ASSERT(sc); + ni = ieee80211_ref_node(vap->iv_bss); + if (sc->flags & IWI_FLAG_ASSOCIATED) { DPRINTF(("Already associated\n")); return (-1); @@ -2971,6 +3023,7 @@ iwi_auth_and_assoc(struct iwi_softc *sc, struct ieee80211vap *vap) le16toh(assoc->intval))); error = iwi_cmd(sc, IWI_CMD_ASSOCIATE, assoc, sizeof *assoc); done: + ieee80211_free_node(ni); if (error) IWI_STATE_END(sc, IWI_FW_ASSOCIATING); diff --git a/sys/dev/iwi/if_iwi_ioctl.h b/sys/dev/iwi/if_iwi_ioctl.h new file mode 100644 index 0000000..0f4f447 --- /dev/null +++ b/sys/dev/iwi/if_iwi_ioctl.h @@ -0,0 +1,25 @@ +/*- + * Copyright (c) 2014 Adrian Chadd <adrian@FreeBSD.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $FreeBSD$ + */ +#ifndef __IF_IWI_IOCTL_H__ +#define __IF_IWI_IOCTL_H__ + +/* XXX how should I pick appropriate ioctl numbers? */ +#define SIOCGIWISTATS _IOWR('i', 147, struct ifreq) +#define SIOCZIWISTATS _IOWR('i', 148, struct ifreq) + +#endif /* __IF_IWI_IOCTL_H__ */ diff --git a/sys/dev/iwi/if_iwireg.h b/sys/dev/iwi/if_iwireg.h index fb56fa5..bc05ad2 100644 --- a/sys/dev/iwi/if_iwireg.h +++ b/sys/dev/iwi/if_iwireg.h @@ -221,6 +221,7 @@ struct iwi_notif_association { /* structure for notification IWI_NOTIF_TYPE_SCAN_CHANNEL */ struct iwi_notif_scan_channel { uint8_t nchan; + /* XXX this is iwi_cmd_stats, and a u8 reserved field */ uint8_t reserved[47]; } __packed; @@ -239,6 +240,68 @@ struct iwi_notif_beacon_state { uint32_t number; } __packed; +/* structure(s) for notification IWI_NOTIF_TYPE_LINK_QUALITY */ + +#define RX_FREE_BUFFERS 32 +#define RX_LOW_WATERMARK 8 + +#define SUP_RATE_11A_MAX_NUM_CHANNELS 8 +#define SUP_RATE_11B_MAX_NUM_CHANNELS 4 +#define SUP_RATE_11G_MAX_NUM_CHANNELS 12 + +// Used for passing to driver number of successes and failures per rate +struct iwi_rate_histogram { + union { + uint32_t a[SUP_RATE_11A_MAX_NUM_CHANNELS]; + uint32_t b[SUP_RATE_11B_MAX_NUM_CHANNELS]; + uint32_t g[SUP_RATE_11G_MAX_NUM_CHANNELS]; + } success; + union { + uint32_t a[SUP_RATE_11A_MAX_NUM_CHANNELS]; + uint32_t b[SUP_RATE_11B_MAX_NUM_CHANNELS]; + uint32_t g[SUP_RATE_11G_MAX_NUM_CHANNELS]; + } failed; +} __packed; + +/* statistics command response */ +struct iwi_cmd_stats { + uint8_t cmd_id; + uint8_t seq_num; + uint16_t good_sfd; + uint16_t bad_plcp; + uint16_t wrong_bssid; + uint16_t valid_mpdu; + uint16_t bad_mac_header; + uint16_t reserved_frame_types; + uint16_t rx_ina; + uint16_t bad_crc32; + uint16_t invalid_cts; + uint16_t invalid_acks; + uint16_t long_distance_ina_fina; + uint16_t dsp_silence_unreachable; + uint16_t accumulated_rssi; + uint16_t rx_ovfl_frame_tossed; + uint16_t rssi_silence_threshold; + uint16_t rx_ovfl_frame_supplied; + uint16_t last_rx_frame_signal; + uint16_t last_rx_frame_noise; + uint16_t rx_autodetec_no_ofdm; + uint16_t rx_autodetec_no_barker; + uint16_t reserved; +} __packed; + +#define SILENCE_OVER_THRESH (1) +#define SILENCE_UNDER_THRESH (2) + +struct iwi_notif_link_quality { + struct iwi_cmd_stats stats; + uint8_t rate; + uint8_t modulation; + struct iwi_rate_histogram histogram; + uint8_t silence_notification_type; /* SILENCE_OVER/UNDER_THRESH */ + uint16_t silence_count; +} __packed; + /* received frame header */ struct iwi_frame { uint32_t reserved1[2]; diff --git a/sys/dev/iwi/if_iwivar.h b/sys/dev/iwi/if_iwivar.h index 42ca92e..b38bbd9 100644 --- a/sys/dev/iwi/if_iwivar.h +++ b/sys/dev/iwi/if_iwivar.h @@ -215,6 +215,9 @@ struct iwi_softc { struct iwi_rx_radiotap_header sc_rxtap; struct iwi_tx_radiotap_header sc_txtap; + + struct iwi_notif_link_quality sc_linkqual; + int sc_linkqual_valid; }; #define IWI_STATE_BEGIN(_sc, _state) do { \ diff --git a/sys/dev/iwn/if_iwn.c b/sys/dev/iwn/if_iwn.c index 806a408..ab98204 100644 --- a/sys/dev/iwn/if_iwn.c +++ b/sys/dev/iwn/if_iwn.c @@ -1,11 +1,10 @@ /*- - * Copyright (c) 2013 Cedric GROSS <c.gross@kreiz-it.fr> - * Copyright (c) 2011 Intel Corporation - * Copyright (c) 2007-2009 - * Damien Bergamini <damien.bergamini@free.fr> - * Copyright (c) 2008 - * Benjamin Close <benjsc@FreeBSD.org> + * Copyright (c) 2007-2009 Damien Bergamini <damien.bergamini@free.fr> + * Copyright (c) 2008 Benjamin Close <benjsc@FreeBSD.org> * Copyright (c) 2008 Sam Leffler, Errno Consulting + * Copyright (c) 2011 Intel Corporation + * Copyright (c) 2013 Cedric GROSS <c.gross@kreiz-it.fr> + * Copyright (c) 2013 Adrian Chadd <adrian@FreeBSD.org> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -57,6 +56,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -77,6 +77,9 @@ __FBSDID("$FreeBSD$"); #include <dev/iwn/if_iwnreg.h> #include <dev/iwn/if_iwnvar.h> #include <dev/iwn/if_iwn_devid.h> +#include <dev/iwn/if_iwn_chip_cfg.h> +#include <dev/iwn/if_iwn_debug.h> +#include <dev/iwn/if_iwn_ioctl.h> struct iwn_ident { uint16_t vendor; @@ -97,12 +100,19 @@ static const struct iwn_ident iwn_ident_table[] = { { 0x8086, IWN_DID_x030_4, "Intel Centrino Advanced-N 6230" }, { 0x8086, IWN_DID_6150_1, "Intel Centrino Wireless-N + WiMAX 6150" }, { 0x8086, IWN_DID_6150_2, "Intel Centrino Wireless-N + WiMAX 6150" }, + { 0x8086, IWN_DID_2x00_1, "Intel(R) Centrino(R) Wireless-N 2200 BGN" }, + { 0x8086, IWN_DID_2x00_2, "Intel(R) Centrino(R) Wireless-N 2200 BGN" }, + /* XXX 2200D is IWN_SDID_2x00_4; there's no way to express this here! */ { 0x8086, IWN_DID_2x30_1, "Intel Centrino Wireless-N 2230" }, { 0x8086, IWN_DID_2x30_2, "Intel Centrino Wireless-N 2230" }, { 0x8086, IWN_DID_130_1, "Intel Centrino Wireless-N 130" }, { 0x8086, IWN_DID_130_2, "Intel Centrino Wireless-N 130" }, { 0x8086, IWN_DID_100_1, "Intel Centrino Wireless-N 100" }, { 0x8086, IWN_DID_100_2, "Intel Centrino Wireless-N 100" }, + { 0x8086, IWN_DID_105_1, "Intel Centrino Wireless-N 105" }, + { 0x8086, IWN_DID_105_2, "Intel Centrino Wireless-N 105" }, + { 0x8086, IWN_DID_135_1, "Intel Centrino Wireless-N 135" }, + { 0x8086, IWN_DID_135_2, "Intel Centrino Wireless-N 135" }, { 0x8086, IWN_DID_4965_1, "Intel Wireless WiFi Link 4965" }, { 0x8086, IWN_DID_6x00_1, "Intel Centrino Ultimate-N 6300" }, { 0x8086, IWN_DID_6x00_2, "Intel Centrino Advanced-N 6200" }, @@ -119,6 +129,8 @@ static const struct iwn_ident iwn_ident_table[] = { { 0x8086, IWN_DID_5x50_2, "Intel WiMAX/WiFi Link 5350" }, { 0x8086, IWN_DID_5x50_3, "Intel WiMAX/WiFi Link 5150" }, { 0x8086, IWN_DID_5x50_4, "Intel WiMAX/WiFi Link 5150" }, + { 0x8086, IWN_DID_6035_1, "Intel Centrino Advanced 6235" }, + { 0x8086, IWN_DID_6035_2, "Intel Centrino Advanced 6235" }, { 0, 0, NULL } }; @@ -126,6 +138,7 @@ static int iwn_probe(device_t); static int iwn_attach(device_t); static int iwn4965_attach(struct iwn_softc *, uint16_t); static int iwn5000_attach(struct iwn_softc *, uint16_t); +static int iwn_config_specific(struct iwn_softc *, uint16_t); static void iwn_radiotap_attach(struct iwn_softc *); static void iwn_sysctlattach(struct iwn_softc *); static struct ieee80211vap *iwn_vap_create(struct ieee80211com *, @@ -200,7 +213,7 @@ static void iwn5000_tx_done(struct iwn_softc *, struct iwn_rx_desc *, struct iwn_rx_data *); static void iwn_tx_done(struct iwn_softc *, struct iwn_rx_desc *, int, uint8_t); -static void iwn_ampdu_tx_done(struct iwn_softc *, int, int, int, void *); +static void iwn_ampdu_tx_done(struct iwn_softc *, int, int, int, int, void *); static void iwn_cmd_done(struct iwn_softc *, struct iwn_rx_desc *); static void iwn_notif_intr(struct iwn_softc *); static void iwn_wakeup_intr(struct iwn_softc *); @@ -257,14 +270,17 @@ static int iwn4965_set_gains(struct iwn_softc *); static int iwn5000_set_gains(struct iwn_softc *); static void iwn_tune_sensitivity(struct iwn_softc *, const struct iwn_rx_stats *); +static void iwn_save_stats_counters(struct iwn_softc *, + const struct iwn_stats *); static int iwn_send_sensitivity(struct iwn_softc *); +static void iwn_check_rx_recovery(struct iwn_softc *, struct iwn_stats *); static int iwn_set_pslevel(struct iwn_softc *, int, int, int); static int iwn_send_btcoex(struct iwn_softc *); static int iwn_send_advanced_btcoex(struct iwn_softc *); static int iwn5000_runtime_calib(struct iwn_softc *); static int iwn_config(struct iwn_softc *); -static uint8_t *ieee80211_add_ssid(uint8_t *, const uint8_t *, u_int); -static int iwn_scan(struct iwn_softc *); +static int iwn_scan(struct iwn_softc *, struct ieee80211vap *, + struct ieee80211_scan_state *, struct ieee80211_channel *); static int iwn_auth(struct iwn_softc *, struct ieee80211vap *vap); static int iwn_run(struct iwn_softc *, struct ieee80211vap *vap); static int iwn_ampdu_rx_start(struct ieee80211_node *, @@ -292,6 +308,7 @@ static int iwn5000_send_calibration(struct iwn_softc *); static int iwn5000_send_wimax_coex(struct iwn_softc *); static int iwn5000_crystal_calib(struct iwn_softc *); static int iwn5000_temp_offset_calib(struct iwn_softc *); +static int iwn5000_temp_offset_calibv2(struct iwn_softc *); static int iwn4965_post_alive(struct iwn_softc *); static int iwn5000_post_alive(struct iwn_softc *); static int iwn4965_load_bootcode(struct iwn_softc *, const uint8_t *, @@ -316,6 +333,7 @@ static int iwn_hw_init(struct iwn_softc *); static void iwn_hw_stop(struct iwn_softc *); static void iwn_radio_on(void *, int); static void iwn_radio_off(void *, int); +static void iwn_panicked(void *, int); static void iwn_init_locked(struct iwn_softc *); static void iwn_init(void *); static void iwn_stop_locked(struct iwn_softc *); @@ -331,80 +349,6 @@ static char *iwn_get_csr_string(int); static void iwn_debug_register(struct iwn_softc *); #endif -#ifdef IWN_DEBUG -enum { - IWN_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ - IWN_DEBUG_RECV = 0x00000002, /* basic recv operation */ - IWN_DEBUG_STATE = 0x00000004, /* 802.11 state transitions */ - IWN_DEBUG_TXPOW = 0x00000008, /* tx power processing */ - IWN_DEBUG_RESET = 0x00000010, /* reset processing */ - IWN_DEBUG_OPS = 0x00000020, /* iwn_ops processing */ - IWN_DEBUG_BEACON = 0x00000040, /* beacon handling */ - IWN_DEBUG_WATCHDOG = 0x00000080, /* watchdog timeout */ - IWN_DEBUG_INTR = 0x00000100, /* ISR */ - IWN_DEBUG_CALIBRATE = 0x00000200, /* periodic calibration */ - 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_REGISTER = 0x20000000, /* print chipset register */ - IWN_DEBUG_TRACE = 0x40000000, /* Print begin and start driver function */ - IWN_DEBUG_FATAL = 0x80000000, /* fatal errors */ - IWN_DEBUG_ANY = 0xffffffff -}; - -#define DPRINTF(sc, m, fmt, ...) do { \ - if (sc->sc_debug & (m)) \ - printf(fmt, __VA_ARGS__); \ -} while (0) - -static const char * -iwn_intr_str(uint8_t cmd) -{ - switch (cmd) { - /* Notifications */ - case IWN_UC_READY: return "UC_READY"; - case IWN_ADD_NODE_DONE: return "ADD_NODE_DONE"; - case IWN_TX_DONE: return "TX_DONE"; - case IWN_START_SCAN: return "START_SCAN"; - case IWN_STOP_SCAN: return "STOP_SCAN"; - case IWN_RX_STATISTICS: return "RX_STATS"; - case IWN_BEACON_STATISTICS: return "BEACON_STATS"; - case IWN_STATE_CHANGED: return "STATE_CHANGED"; - case IWN_BEACON_MISSED: return "BEACON_MISSED"; - case IWN_RX_PHY: return "RX_PHY"; - case IWN_MPDU_RX_DONE: return "MPDU_RX_DONE"; - case IWN_RX_DONE: return "RX_DONE"; - - /* Command Notifications */ - case IWN_CMD_RXON: return "IWN_CMD_RXON"; - case IWN_CMD_RXON_ASSOC: return "IWN_CMD_RXON_ASSOC"; - case IWN_CMD_EDCA_PARAMS: return "IWN_CMD_EDCA_PARAMS"; - case IWN_CMD_TIMING: return "IWN_CMD_TIMING"; - case IWN_CMD_LINK_QUALITY: return "IWN_CMD_LINK_QUALITY"; - case IWN_CMD_SET_LED: return "IWN_CMD_SET_LED"; - case IWN5000_CMD_WIMAX_COEX: return "IWN5000_CMD_WIMAX_COEX"; - case IWN5000_CMD_CALIB_CONFIG: return "IWN5000_CMD_CALIB_CONFIG"; - case IWN5000_CMD_CALIB_RESULT: return "IWN5000_CMD_CALIB_RESULT"; - case IWN5000_CMD_CALIB_COMPLETE: return "IWN5000_CMD_CALIB_COMPLETE"; - case IWN_CMD_SET_POWER_MODE: return "IWN_CMD_SET_POWER_MODE"; - case IWN_CMD_SCAN: return "IWN_CMD_SCAN"; - case IWN_CMD_SCAN_RESULTS: return "IWN_CMD_SCAN_RESULTS"; - case IWN_CMD_TXPOWER: return "IWN_CMD_TXPOWER"; - case IWN_CMD_TXPOWER_DBM: return "IWN_CMD_TXPOWER_DBM"; - case IWN5000_CMD_TX_ANT_CONFIG: return "IWN5000_CMD_TX_ANT_CONFIG"; - case IWN_CMD_BT_COEX: return "IWN_CMD_BT_COEX"; - case IWN_CMD_SET_CRITICAL_TEMP: return "IWN_CMD_SET_CRITICAL_TEMP"; - case IWN_CMD_SET_SENSITIVITY: return "IWN_CMD_SET_SENSITIVITY"; - case IWN_CMD_PHY_CALIB: return "IWN_CMD_PHY_CALIB"; - } - return "UNKNOWN INTR NOTIF/CMD"; -} -#else -#define DPRINTF(sc, m, fmt, ...) do { (void) sc; } while (0) -#endif - static device_method_t iwn_methods[] = { /* Device interface */ DEVMETHOD(device_probe, iwn_probe), @@ -448,6 +392,15 @@ iwn_probe(device_t dev) } static int +iwn_is_3stream_device(struct iwn_softc *sc) +{ + /* XXX for now only 5300, until the 5350 can be tested */ + if (sc->hw_type == IWN_HW_REV_TYPE_5300) + return (1); + return (0); +} + +static int iwn_attach(device_t dev) { struct iwn_softc *sc = (struct iwn_softc *)device_get_softc(dev); @@ -515,6 +468,11 @@ iwn_attach(device_t dev) sc->hw_type = (IWN_READ(sc, IWN_HW_REV) >> IWN_HW_REV_TYPE_SHIFT) & IWN_HW_REV_TYPE_MASK; sc->subdevice_id = pci_get_subdevice(dev); + + /* + * 4965 versus 5000 and later have different methods. + * Let's set those up first. + */ if (sc->hw_type == IWN_HW_REV_TYPE_4965) error = iwn4965_attach(sc, pci_get_device(dev)); else @@ -525,6 +483,16 @@ iwn_attach(device_t dev) goto fail; } + /* + * Next, let's setup the various parameters of each NIC. + */ + error = iwn_config_specific(sc, pci_get_device(dev)); + if (error != 0) { + device_printf(dev, "could not attach device, error %d\n", + error); + goto fail; + } + if ((error = iwn_hw_prepare(sc)) != 0) { device_printf(dev, "hardware not ready, error %d\n", error); goto fail; @@ -634,17 +602,16 @@ iwn_attach(device_t dev) ic->ic_txstream = sc->ntxchains; /* - * The NICs we currently support cap out at 2x2 support - * separate from the chains being used. - * - * This is a total hack to work around that until some - * per-device method is implemented to return the - * actual stream support. + * Some of the 3 antenna devices (ie, the 4965) only supports + * 2x2 operation. So correct the number of streams if + * it's not a 3-stream device. */ - if (ic->ic_rxstream > 2) - ic->ic_rxstream = 2; - if (ic->ic_txstream > 2) - ic->ic_txstream = 2; + if (! iwn_is_3stream_device(sc)) { + if (ic->ic_rxstream > 2) + ic->ic_rxstream = 2; + if (ic->ic_txstream > 2) + ic->ic_txstream = 2; + } ic->ic_htcaps = IEEE80211_HTCAP_SMPS_OFF /* SMPS mode disabled */ @@ -710,6 +677,15 @@ iwn_attach(device_t dev) TASK_INIT(&sc->sc_reinit_task, 0, iwn_hw_reset, sc); TASK_INIT(&sc->sc_radioon_task, 0, iwn_radio_on, sc); TASK_INIT(&sc->sc_radiooff_task, 0, iwn_radio_off, sc); + TASK_INIT(&sc->sc_panic_task, 0, iwn_panicked, sc); + + sc->sc_tq = taskqueue_create("iwn_taskq", M_WAITOK, + taskqueue_thread_enqueue, &sc->sc_tq); + error = taskqueue_start_threads(&sc->sc_tq, 1, 0, "iwn_taskq"); + if (error != 0) { + device_printf(dev, "can't start threads, error %d\n", error); + goto fail; + } iwn_sysctlattach(sc); @@ -724,6 +700,13 @@ iwn_attach(device_t dev) goto fail; } +#if 0 + device_printf(sc->sc_dev, "%s: rx_stats=%d, rx_stats_bt=%d\n", + __func__, + sizeof(struct iwn_stats), + sizeof(struct iwn_stats_bt)); +#endif + if (bootverbose) ieee80211_announce(ic); DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__); @@ -734,6 +717,488 @@ fail: return error; } +/* + * Define specific configuration based on device id and subdevice id + * pid : PCI device id + */ +static int +iwn_config_specific(struct iwn_softc *sc, uint16_t pid) +{ + + switch (pid) { +/* 4965 series */ + case IWN_DID_4965_1: + case IWN_DID_4965_2: + case IWN_DID_4965_3: + case IWN_DID_4965_4: + sc->base_params = &iwn4965_base_params; + sc->limits = &iwn4965_sensitivity_limits; + sc->fwname = "iwn4965fw"; + /* Override chains masks, ROM is known to be broken. */ + sc->txchainmask = IWN_ANT_AB; + sc->rxchainmask = IWN_ANT_ABC; + /* Enable normal btcoex */ + sc->sc_flags |= IWN_FLAG_BTCOEX; + break; +/* 1000 Series */ + case IWN_DID_1000_1: + case IWN_DID_1000_2: + switch(sc->subdevice_id) { + case IWN_SDID_1000_1: + case IWN_SDID_1000_2: + case IWN_SDID_1000_3: + case IWN_SDID_1000_4: + case IWN_SDID_1000_5: + case IWN_SDID_1000_6: + case IWN_SDID_1000_7: + case IWN_SDID_1000_8: + case IWN_SDID_1000_9: + case IWN_SDID_1000_10: + case IWN_SDID_1000_11: + case IWN_SDID_1000_12: + sc->limits = &iwn1000_sensitivity_limits; + sc->base_params = &iwn1000_base_params; + sc->fwname = "iwn1000fw"; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 6x00 Series */ + case IWN_DID_6x00_2: + case IWN_DID_6x00_4: + case IWN_DID_6x00_1: + case IWN_DID_6x00_3: + sc->fwname = "iwn6000fw"; + sc->limits = &iwn6000_sensitivity_limits; + switch(sc->subdevice_id) { + case IWN_SDID_6x00_1: + case IWN_SDID_6x00_2: + case IWN_SDID_6x00_8: + //iwl6000_3agn_cfg + sc->base_params = &iwn_6000_base_params; + break; + case IWN_SDID_6x00_3: + case IWN_SDID_6x00_6: + case IWN_SDID_6x00_9: + ////iwl6000i_2agn + case IWN_SDID_6x00_4: + case IWN_SDID_6x00_7: + case IWN_SDID_6x00_10: + //iwl6000i_2abg_cfg + case IWN_SDID_6x00_5: + //iwl6000i_2bg_cfg + sc->base_params = &iwn_6000i_base_params; + sc->sc_flags |= IWN_FLAG_INTERNAL_PA; + sc->txchainmask = IWN_ANT_BC; + sc->rxchainmask = IWN_ANT_BC; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 6x05 Series */ + case IWN_DID_6x05_1: + case IWN_DID_6x05_2: + switch(sc->subdevice_id) { + case IWN_SDID_6x05_1: + case IWN_SDID_6x05_4: + case IWN_SDID_6x05_6: + //iwl6005_2agn_cfg + case IWN_SDID_6x05_2: + case IWN_SDID_6x05_5: + case IWN_SDID_6x05_7: + //iwl6005_2abg_cfg + case IWN_SDID_6x05_3: + //iwl6005_2bg_cfg + case IWN_SDID_6x05_8: + case IWN_SDID_6x05_9: + //iwl6005_2agn_sff_cfg + case IWN_SDID_6x05_10: + //iwl6005_2agn_d_cfg + case IWN_SDID_6x05_11: + //iwl6005_2agn_mow1_cfg + case IWN_SDID_6x05_12: + //iwl6005_2agn_mow2_cfg + sc->fwname = "iwn6000g2afw"; + sc->limits = &iwn6000_sensitivity_limits; + sc->base_params = &iwn_6000g2_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 6x35 Series */ + case IWN_DID_6035_1: + case IWN_DID_6035_2: + switch(sc->subdevice_id) { + case IWN_SDID_6035_1: + case IWN_SDID_6035_2: + case IWN_SDID_6035_3: + case IWN_SDID_6035_4: + sc->fwname = "iwn6000g2bfw"; + sc->limits = &iwn6235_sensitivity_limits; + sc->base_params = &iwn_6235_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 6x50 WiFi/WiMax Series */ + case IWN_DID_6050_1: + case IWN_DID_6050_2: + switch(sc->subdevice_id) { + case IWN_SDID_6050_1: + case IWN_SDID_6050_3: + case IWN_SDID_6050_5: + //iwl6050_2agn_cfg + case IWN_SDID_6050_2: + case IWN_SDID_6050_4: + case IWN_SDID_6050_6: + //iwl6050_2abg_cfg + sc->fwname = "iwn6050fw"; + sc->txchainmask = IWN_ANT_AB; + sc->rxchainmask = IWN_ANT_AB; + sc->limits = &iwn6000_sensitivity_limits; + sc->base_params = &iwn_6050_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 6150 WiFi/WiMax Series */ + case IWN_DID_6150_1: + case IWN_DID_6150_2: + switch(sc->subdevice_id) { + case IWN_SDID_6150_1: + case IWN_SDID_6150_3: + case IWN_SDID_6150_5: + // iwl6150_bgn_cfg + case IWN_SDID_6150_2: + case IWN_SDID_6150_4: + case IWN_SDID_6150_6: + //iwl6150_bg_cfg + sc->fwname = "iwn6050fw"; + sc->limits = &iwn6000_sensitivity_limits; + sc->base_params = &iwn_6150_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 6030 Series and 1030 Series */ + case IWN_DID_x030_1: + case IWN_DID_x030_2: + case IWN_DID_x030_3: + case IWN_DID_x030_4: + switch(sc->subdevice_id) { + case IWN_SDID_x030_1: + case IWN_SDID_x030_3: + case IWN_SDID_x030_5: + // iwl1030_bgn_cfg + case IWN_SDID_x030_2: + case IWN_SDID_x030_4: + case IWN_SDID_x030_6: + //iwl1030_bg_cfg + case IWN_SDID_x030_7: + case IWN_SDID_x030_10: + case IWN_SDID_x030_14: + //iwl6030_2agn_cfg + case IWN_SDID_x030_8: + case IWN_SDID_x030_11: + case IWN_SDID_x030_15: + // iwl6030_2bgn_cfg + case IWN_SDID_x030_9: + case IWN_SDID_x030_12: + case IWN_SDID_x030_16: + // iwl6030_2abg_cfg + case IWN_SDID_x030_13: + //iwl6030_2bg_cfg + sc->fwname = "iwn6000g2bfw"; + sc->limits = &iwn6000_sensitivity_limits; + sc->base_params = &iwn_6000g2b_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 130 Series WiFi */ +/* XXX: This series will need adjustment for rate. + * see rx_with_siso_diversity in linux kernel + */ + case IWN_DID_130_1: + case IWN_DID_130_2: + switch(sc->subdevice_id) { + case IWN_SDID_130_1: + case IWN_SDID_130_3: + case IWN_SDID_130_5: + //iwl130_bgn_cfg + case IWN_SDID_130_2: + case IWN_SDID_130_4: + case IWN_SDID_130_6: + //iwl130_bg_cfg + sc->fwname = "iwn6000g2bfw"; + sc->limits = &iwn6000_sensitivity_limits; + sc->base_params = &iwn_6000g2b_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 100 Series WiFi */ + case IWN_DID_100_1: + case IWN_DID_100_2: + switch(sc->subdevice_id) { + case IWN_SDID_100_1: + case IWN_SDID_100_2: + case IWN_SDID_100_3: + case IWN_SDID_100_4: + case IWN_SDID_100_5: + case IWN_SDID_100_6: + sc->limits = &iwn1000_sensitivity_limits; + sc->base_params = &iwn1000_base_params; + sc->fwname = "iwn100fw"; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; + +/* 105 Series */ +/* XXX: This series will need adjustment for rate. + * see rx_with_siso_diversity in linux kernel + */ + case IWN_DID_105_1: + case IWN_DID_105_2: + switch(sc->subdevice_id) { + case IWN_SDID_105_1: + case IWN_SDID_105_2: + case IWN_SDID_105_3: + //iwl105_bgn_cfg + case IWN_SDID_105_4: + //iwl105_bgn_d_cfg + sc->limits = &iwn2030_sensitivity_limits; + sc->base_params = &iwn2000_base_params; + sc->fwname = "iwn105fw"; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; + +/* 135 Series */ +/* XXX: This series will need adjustment for rate. + * see rx_with_siso_diversity in linux kernel + */ + case IWN_DID_135_1: + case IWN_DID_135_2: + switch(sc->subdevice_id) { + case IWN_SDID_135_1: + case IWN_SDID_135_2: + case IWN_SDID_135_3: + sc->limits = &iwn2030_sensitivity_limits; + sc->base_params = &iwn2030_base_params; + sc->fwname = "iwn135fw"; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; + +/* 2x00 Series */ + case IWN_DID_2x00_1: + case IWN_DID_2x00_2: + switch(sc->subdevice_id) { + case IWN_SDID_2x00_1: + case IWN_SDID_2x00_2: + case IWN_SDID_2x00_3: + //iwl2000_2bgn_cfg + case IWN_SDID_2x00_4: + //iwl2000_2bgn_d_cfg + sc->limits = &iwn2030_sensitivity_limits; + sc->base_params = &iwn2000_base_params; + sc->fwname = "iwn2000fw"; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice) \n", + pid, sc->subdevice_id, sc->hw_type); + return ENOTSUP; + } + break; +/* 2x30 Series */ + case IWN_DID_2x30_1: + case IWN_DID_2x30_2: + switch(sc->subdevice_id) { + case IWN_SDID_2x30_1: + case IWN_SDID_2x30_3: + case IWN_SDID_2x30_5: + //iwl100_bgn_cfg + case IWN_SDID_2x30_2: + case IWN_SDID_2x30_4: + case IWN_SDID_2x30_6: + //iwl100_bg_cfg + sc->limits = &iwn2030_sensitivity_limits; + sc->base_params = &iwn2030_base_params; + sc->fwname = "iwn2030fw"; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 5x00 Series */ + case IWN_DID_5x00_1: + case IWN_DID_5x00_2: + case IWN_DID_5x00_3: + case IWN_DID_5x00_4: + sc->limits = &iwn5000_sensitivity_limits; + sc->base_params = &iwn5000_base_params; + sc->fwname = "iwn5000fw"; + switch(sc->subdevice_id) { + case IWN_SDID_5x00_1: + case IWN_SDID_5x00_2: + case IWN_SDID_5x00_3: + case IWN_SDID_5x00_4: + case IWN_SDID_5x00_9: + case IWN_SDID_5x00_10: + case IWN_SDID_5x00_11: + case IWN_SDID_5x00_12: + case IWN_SDID_5x00_17: + case IWN_SDID_5x00_18: + case IWN_SDID_5x00_19: + case IWN_SDID_5x00_20: + //iwl5100_agn_cfg + sc->txchainmask = IWN_ANT_B; + sc->rxchainmask = IWN_ANT_AB; + break; + case IWN_SDID_5x00_5: + case IWN_SDID_5x00_6: + case IWN_SDID_5x00_13: + case IWN_SDID_5x00_14: + case IWN_SDID_5x00_21: + case IWN_SDID_5x00_22: + //iwl5100_bgn_cfg + sc->txchainmask = IWN_ANT_B; + sc->rxchainmask = IWN_ANT_AB; + break; + case IWN_SDID_5x00_7: + case IWN_SDID_5x00_8: + case IWN_SDID_5x00_15: + case IWN_SDID_5x00_16: + case IWN_SDID_5x00_23: + case IWN_SDID_5x00_24: + //iwl5100_abg_cfg + sc->txchainmask = IWN_ANT_B; + sc->rxchainmask = IWN_ANT_AB; + break; + case IWN_SDID_5x00_25: + case IWN_SDID_5x00_26: + case IWN_SDID_5x00_27: + case IWN_SDID_5x00_28: + case IWN_SDID_5x00_29: + case IWN_SDID_5x00_30: + case IWN_SDID_5x00_31: + case IWN_SDID_5x00_32: + case IWN_SDID_5x00_33: + case IWN_SDID_5x00_34: + case IWN_SDID_5x00_35: + case IWN_SDID_5x00_36: + //iwl5300_agn_cfg + sc->txchainmask = IWN_ANT_ABC; + sc->rxchainmask = IWN_ANT_ABC; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; +/* 5x50 Series */ + case IWN_DID_5x50_1: + case IWN_DID_5x50_2: + case IWN_DID_5x50_3: + case IWN_DID_5x50_4: + sc->limits = &iwn5000_sensitivity_limits; + sc->base_params = &iwn5000_base_params; + sc->fwname = "iwn5000fw"; + switch(sc->subdevice_id) { + case IWN_SDID_5x50_1: + case IWN_SDID_5x50_2: + case IWN_SDID_5x50_3: + //iwl5350_agn_cfg + sc->limits = &iwn5000_sensitivity_limits; + sc->base_params = &iwn5000_base_params; + sc->fwname = "iwn5000fw"; + break; + case IWN_SDID_5x50_4: + case IWN_SDID_5x50_5: + case IWN_SDID_5x50_8: + case IWN_SDID_5x50_9: + case IWN_SDID_5x50_10: + case IWN_SDID_5x50_11: + //iwl5150_agn_cfg + case IWN_SDID_5x50_6: + case IWN_SDID_5x50_7: + case IWN_SDID_5x50_12: + case IWN_SDID_5x50_13: + //iwl5150_abg_cfg + sc->limits = &iwn5000_sensitivity_limits; + sc->fwname = "iwn5150fw"; + sc->base_params = &iwn_5x50_base_params; + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id :" + "0x%04x rev %d not supported (subdevice)\n", pid, + sc->subdevice_id,sc->hw_type); + return ENOTSUP; + } + break; + default: + device_printf(sc->sc_dev, "adapter type id : 0x%04x sub id : 0x%04x" + "rev 0x%08x not supported (device)\n", pid, sc->subdevice_id, + sc->hw_type); + return ENOTSUP; + } + return 0; +} + static int iwn4965_attach(struct iwn_softc *sc, uint16_t pid) { @@ -769,6 +1234,8 @@ iwn4965_attach(struct iwn_softc *sc, uint16_t pid) /* Override chains masks, ROM is known to be broken. */ sc->txchainmask = IWN_ANT_AB; sc->rxchainmask = IWN_ANT_ABC; + /* Enable normal btcoex */ + sc->sc_flags |= IWN_FLAG_BTCOEX; DPRINTF(sc, IWN_DEBUG_TRACE, "%s: end\n",__func__); @@ -809,58 +1276,6 @@ iwn5000_attach(struct iwn_softc *sc, uint16_t pid) sc->reset_noise_gain = IWN5000_PHY_CALIB_RESET_NOISE_GAIN; sc->noise_gain = IWN5000_PHY_CALIB_NOISE_GAIN; - switch (sc->hw_type) { - case IWN_HW_REV_TYPE_5100: - sc->limits = &iwn5000_sensitivity_limits; - sc->fwname = "iwn5000fw"; - /* Override chains masks, ROM is known to be broken. */ - sc->txchainmask = IWN_ANT_B; - sc->rxchainmask = IWN_ANT_AB; - break; - case IWN_HW_REV_TYPE_5150: - sc->limits = &iwn5150_sensitivity_limits; - sc->fwname = "iwn5150fw"; - break; - case IWN_HW_REV_TYPE_5300: - case IWN_HW_REV_TYPE_5350: - sc->limits = &iwn5000_sensitivity_limits; - sc->fwname = "iwn5000fw"; - break; - case IWN_HW_REV_TYPE_1000: - sc->limits = &iwn1000_sensitivity_limits; - sc->fwname = "iwn1000fw"; - break; - case IWN_HW_REV_TYPE_6000: - sc->limits = &iwn6000_sensitivity_limits; - sc->fwname = "iwn6000fw"; - if (pid == 0x422c || pid == 0x4239) { - sc->sc_flags |= IWN_FLAG_INTERNAL_PA; - /* Override chains masks, ROM is known to be broken. */ - sc->txchainmask = IWN_ANT_BC; - sc->rxchainmask = IWN_ANT_BC; - } - break; - case IWN_HW_REV_TYPE_6050: - sc->limits = &iwn6000_sensitivity_limits; - sc->fwname = "iwn6050fw"; - /* Override chains masks, ROM is known to be broken. */ - sc->txchainmask = IWN_ANT_AB; - sc->rxchainmask = IWN_ANT_AB; - break; - case IWN_HW_REV_TYPE_6005: - sc->limits = &iwn6000_sensitivity_limits; - if (pid != 0x0082 && pid != 0x0085) { - sc->fwname = "iwn6000g2bfw"; - sc->sc_flags |= IWN_FLAG_ADV_BTCOEX; - } else - sc->fwname = "iwn6000g2afw"; - break; - default: - device_printf(sc->sc_dev, "adapter type %d not supported\n", - sc->hw_type); - DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end in error\n",__func__); - return ENOTSUP; - } return 0; } @@ -959,6 +1374,10 @@ iwn_detach(device_t dev) ieee80211_draintask(ic, &sc->sc_radiooff_task); iwn_stop(sc); + + taskqueue_drain_all(sc->sc_tq); + taskqueue_free(sc->sc_tq); + callout_drain(&sc->watchdog_to); callout_drain(&sc->calib_to); ieee80211_ifdetach(ic); @@ -1184,7 +1603,7 @@ iwn_init_otprom(struct iwn_softc *sc) iwn_nic_unlock(sc); /* Set auto clock gate disable bit for HW with OTP shadow RAM. */ - if (sc->hw_type != IWN_HW_REV_TYPE_1000) { + if (sc->base_params->shadow_ram_support) { IWN_SETBITS(sc, IWN_DBG_LINK_PWR_MGMT, IWN_RESET_LINK_PWR_MGMT_DIS); } @@ -1197,11 +1616,12 @@ iwn_init_otprom(struct iwn_softc *sc) * Find the block before last block (contains the EEPROM image) * for HW without OTP shadow RAM. */ - if (sc->hw_type == IWN_HW_REV_TYPE_1000) { + if (! sc->base_params->shadow_ram_support) { /* Switch to absolute addressing mode. */ IWN_CLRBITS(sc, IWN_OTP_GP, IWN_OTP_GP_RELATIVE_ACCESS); base = prev = 0; - for (count = 0; count < IWN1000_OTP_NBLOCKS; count++) { + for (count = 0; count < sc->base_params->max_ll_items; + count++) { error = iwn_read_prom_data(sc, base, &next, 2); if (error != 0) return error; @@ -1210,7 +1630,7 @@ iwn_init_otprom(struct iwn_softc *sc) prev = base; base = le16toh(next); } - if (count == 0 || count == IWN1000_OTP_NBLOCKS) + if (count == 0 || count == sc->base_params->max_ll_items) return EIO; /* Skip "next" word. */ sc->prom_base = prev + 1; @@ -1316,16 +1736,12 @@ fail: iwn_dma_contig_free(dma); static void iwn_dma_contig_free(struct iwn_dma_info *dma) { - if (dma->map != NULL) { - if (dma->vaddr != NULL) { - bus_dmamap_sync(dma->tag, dma->map, - BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(dma->tag, dma->map); - bus_dmamem_free(dma->tag, dma->vaddr, dma->map); - dma->vaddr = NULL; - } - bus_dmamap_destroy(dma->tag, dma->map); - dma->map = NULL; + if (dma->vaddr != NULL) { + bus_dmamap_sync(dma->tag, dma->map, + BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); + bus_dmamap_unload(dma->tag, dma->map); + bus_dmamem_free(dma->tag, dma->vaddr, dma->map); + dma->vaddr = NULL; } if (dma->tag != NULL) { bus_dma_tag_destroy(dma->tag); @@ -1459,7 +1875,7 @@ iwn_alloc_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring) &paddr, BUS_DMA_NOWAIT); if (error != 0 && error != EFBIG) { device_printf(sc->sc_dev, - "%s: can't not map mbuf, error %d\n", __func__, + "%s: can't map mbuf, error %d\n", __func__, error); goto fail; } @@ -1620,6 +2036,10 @@ iwn_reset_tx_ring(struct iwn_softc *sc, struct iwn_tx_ring *ring) m_freem(data->m); data->m = NULL; } + if (data->ni != NULL) { + ieee80211_free_node(data->ni); + data->ni = NULL; + } } /* Clear TX descriptors. */ memset(ring->desc, 0, ring->desc_dma.size); @@ -1768,7 +2188,7 @@ iwn4965_read_eeprom(struct iwn_softc *sc) iwn_read_prom_data(sc, IWN4965_EEPROM_DOMAIN, sc->eeprom_domain, 4); /* Read the list of authorized channels (20MHz ones only). */ - for (i = 0; i < 7; i++) { + for (i = 0; i < IWN_NBANDS - 1; i++) { addr = iwn4965_regulatory_bands[i]; iwn_read_eeprom_channels(sc, i, addr); } @@ -1798,7 +2218,7 @@ iwn4965_read_eeprom(struct iwn_softc *sc) #ifdef IWN_DEBUG /* Print samples. */ if (sc->sc_debug & IWN_DEBUG_ANY) { - for (i = 0; i < IWN_NBANDS; i++) + for (i = 0; i < IWN_NBANDS - 1; i++) iwn4965_print_power_group(sc, i); } #endif @@ -1859,16 +2279,13 @@ iwn5000_read_eeprom(struct iwn_softc *sc) sc->eeprom_domain, 4); /* Read the list of authorized channels (20MHz ones only). */ - for (i = 0; i < 7; i++) { - if (sc->hw_type >= IWN_HW_REV_TYPE_6000) - addr = base + iwn6000_regulatory_bands[i]; - else - addr = base + iwn5000_regulatory_bands[i]; + for (i = 0; i < IWN_NBANDS - 1; i++) { + addr = base + sc->base_params->regulatory_bands[i]; iwn_read_eeprom_channels(sc, i, addr); } /* Read enhanced TX power information for 6000 Series. */ - if (sc->hw_type >= IWN_HW_REV_TYPE_6000) + if (sc->base_params->enhanced_TX_power) iwn_read_eeprom_enhinfo(sc); iwn_read_prom_data(sc, IWN5000_EEPROM_CAL, &val, 2); @@ -1879,6 +2296,14 @@ iwn5000_read_eeprom(struct iwn_softc *sc) hdr.version, hdr.pa_type, le16toh(hdr.volt)); sc->calib_ver = hdr.version; + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2) { + sc->eeprom_voltage = le16toh(hdr.volt); + iwn_read_prom_data(sc, base + IWN5000_EEPROM_TEMP, &val, 2); + sc->eeprom_temp_high=le16toh(val); + iwn_read_prom_data(sc, base + IWN5000_EEPROM_VOLT, &val, 2); + sc->eeprom_temp = le16toh(val); + } + if (sc->hw_type == IWN_HW_REV_TYPE_5150) { /* Compute temperature offset. */ iwn_read_prom_data(sc, base + IWN5000_EEPROM_TEMP, &val, 2); @@ -2215,6 +2640,52 @@ rate2plcp(int rate) return 0; } +static int +iwn_get_1stream_tx_antmask(struct iwn_softc *sc) +{ + + return IWN_LSB(sc->txchainmask); +} + +static int +iwn_get_2stream_tx_antmask(struct iwn_softc *sc) +{ + int tx; + + /* + * The '2 stream' setup is a bit .. odd. + * + * For NICs that support only 1 antenna, default to IWN_ANT_AB or + * the firmware panics (eg Intel 5100.) + * + * For NICs that support two antennas, we use ANT_AB. + * + * For NICs that support three antennas, we use the two that + * wasn't the default one. + * + * XXX TODO: if bluetooth (full concurrent) is enabled, restrict + * this to only one antenna. + */ + + /* Default - transmit on the other antennas */ + tx = (sc->txchainmask & ~IWN_LSB(sc->txchainmask)); + + /* Now, if it's zero, set it to IWN_ANT_AB, so to not panic firmware */ + if (tx == 0) + tx = IWN_ANT_AB; + + /* + * If the NIC is a two-stream TX NIC, configure the TX mask to + * the default chainmask + */ + else if (sc->ntxchains == 2) + tx = sc->txchainmask; + + return (tx); +} + + + /* * Calculate the required PLCP value from the given rate, * to the given node. @@ -2228,19 +2699,14 @@ iwn_rate_to_plcp(struct iwn_softc *sc, struct ieee80211_node *ni, { #define RV(v) ((v) & IEEE80211_RATE_VAL) struct ieee80211com *ic = ni->ni_ic; - uint8_t txant1, txant2; 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)) { + if (rate & IEEE80211_RATE_MCS) { /* * Set the initial PLCP value to be between 0->31 for * MCS 0 -> MCS 31, then set the "I'm an MCS rate!" @@ -2267,15 +2733,15 @@ iwn_rate_to_plcp(struct iwn_softc *sc, struct ieee80211_node *ni, } /* - * If it's a two stream rate, enable TX on both - * antennas. - * - * XXX three stream rates? + * Ensure the selected rate matches the link quality + * table entries being used. */ - if (rate > 0x87) - plcp |= IWN_RFLAG_ANT(txant1 | txant2); + if (rate > 0x8f) + plcp |= IWN_RFLAG_ANT(sc->txchainmask); + else if (rate > 0x87) + plcp |= IWN_RFLAG_ANT(iwn_get_2stream_tx_antmask(sc)); else - plcp |= IWN_RFLAG_ANT(txant1); + plcp |= IWN_RFLAG_ANT(iwn_get_1stream_tx_antmask(sc)); } else { /* * Set the initial PLCP - fine for both @@ -2297,7 +2763,8 @@ iwn_rate_to_plcp(struct iwn_softc *sc, struct ieee80211_node *ni, plcp |= IWN_RFLAG_CCK; /* Set antenna configuration */ - plcp |= IWN_RFLAG_ANT(txant1); + /* XXX TODO: is this the right antenna to use for legacy? */ + plcp |= IWN_RFLAG_ANT(iwn_get_1stream_tx_antmask(sc)); } DPRINTF(sc, IWN_DEBUG_TXRATE, "%s: rate=0x%02x, plcp=0x%08x\n", @@ -2502,14 +2969,14 @@ iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, if ((flags & IWN_RX_NOERROR) != IWN_RX_NOERROR) { DPRINTF(sc, IWN_DEBUG_RECV, "%s: RX flags error %x\n", __func__, flags); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } /* Discard frames that are too short. */ - if (len < sizeof (*wh)) { + if (len < sizeof (struct ieee80211_frame_ack)) { DPRINTF(sc, IWN_DEBUG_RECV, "%s: frame too short: %d\n", __func__, len); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } @@ -2517,7 +2984,7 @@ iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, if (m1 == NULL) { DPRINTF(sc, IWN_DEBUG_ANY, "%s: no mbuf to restock ring\n", __func__); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } bus_dmamap_unload(ring->data_dmat, data->map); @@ -2540,7 +3007,7 @@ iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, ring->desc[ring->cur] = htole32(paddr >> 8); bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map, BUS_DMASYNC_PREWRITE); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } @@ -2558,7 +3025,10 @@ iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, /* Grab a reference to the source node. */ wh = mtod(m, struct ieee80211_frame *); - ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); + if (len >= sizeof(struct ieee80211_frame_min)) + ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); + else + ni = NULL; nf = (ni != NULL && ni->ni_vap->iv_state == IEEE80211_S_RUN && (ic->ic_flags & IEEE80211_F_SCAN) == 0) ? sc->noise : -95; @@ -2629,8 +3099,9 @@ iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc, uint16_t ssn; uint8_t tid; int ackfailcnt = 0, i, lastidx, qid, *res, shift; + int tx_ok = 0, tx_err = 0; - DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); + DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT, "->%s begin\n", __func__); bus_dmamap_sync(sc->rxq.data_dmat, data->map, BUS_DMASYNC_POSTREAD); @@ -2660,6 +3131,7 @@ iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc, KASSERT(ni != NULL, ("no node")); KASSERT(m != NULL, ("no mbuf")); + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: freeing m=%p\n", __func__, m); ieee80211_tx_complete(ni, m, 1); txq->queued--; @@ -2685,22 +3157,32 @@ iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc, if (wn->agg[tid].nframes > (64 - shift)) return; + /* + * Walk the bitmap and calculate how many successful and failed + * attempts are made. + * + * Yes, the rate control code doesn't know these are A-MPDU + * subframes and that it's okay to fail some of these. + */ ni = tap->txa_ni; bitmap = (le64toh(ba->bitmap) >> shift) & wn->agg[tid].bitmap; for (i = 0; bitmap; i++) { if ((bitmap & 1) == 0) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + tx_err ++; ieee80211_ratectl_tx_complete(ni->ni_vap, ni, IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL); } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); + tx_ok ++; ieee80211_ratectl_tx_complete(ni->ni_vap, ni, IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL); } bitmap >>= 1; } - DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__); + DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT, + "->%s: end; %d ok; %d err\n",__func__, tx_ok, tx_err); } @@ -2728,25 +3210,24 @@ iwn5000_rx_calib_results(struct iwn_softc *sc, struct iwn_rx_desc *desc, switch (calib->code) { case IWN5000_PHY_CALIB_DC: - if ((sc->sc_flags & IWN_FLAG_INTERNAL_PA) == 0 && - (sc->hw_type == IWN_HW_REV_TYPE_5150 || - sc->hw_type >= IWN_HW_REV_TYPE_6000) && - sc->hw_type != IWN_HW_REV_TYPE_6050) + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_DC) idx = 0; break; case IWN5000_PHY_CALIB_LO: - idx = 1; + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_LO) + idx = 1; break; case IWN5000_PHY_CALIB_TX_IQ: - idx = 2; + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TX_IQ) + idx = 2; break; case IWN5000_PHY_CALIB_TX_IQ_PERIODIC: - if (sc->hw_type < IWN_HW_REV_TYPE_6000 && - sc->hw_type != IWN_HW_REV_TYPE_5150) + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TX_IQ_PERIODIC) idx = 3; break; case IWN5000_PHY_CALIB_BASE_BAND: - idx = 4; + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_BASE_BAND) + idx = 4; break; } if (idx == -1) /* Ignore other results. */ @@ -2763,11 +3244,72 @@ iwn5000_rx_calib_results(struct iwn_softc *sc, struct iwn_rx_desc *desc, return; } DPRINTF(sc, IWN_DEBUG_CALIBRATE, - "saving calibration result code=%d len=%d\n", calib->code, len); + "saving calibration result idx=%d, code=%d len=%d\n", idx, calib->code, len); sc->calibcmd[idx].len = len; memcpy(sc->calibcmd[idx].buf, calib, len); } +static void +iwn_stats_update(struct iwn_softc *sc, struct iwn_calib_state *calib, + struct iwn_stats *stats, int len) +{ + struct iwn_stats_bt *stats_bt; + struct iwn_stats *lstats; + + /* + * First - check whether the length is the bluetooth or normal. + * + * If it's normal - just copy it and bump out. + * Otherwise we have to convert things. + */ + + if (len == sizeof(struct iwn_stats) + 4) { + memcpy(&sc->last_stat, stats, sizeof(struct iwn_stats)); + sc->last_stat_valid = 1; + return; + } + + /* + * If it's not the bluetooth size - log, then just copy. + */ + if (len != sizeof(struct iwn_stats_bt) + 4) { + DPRINTF(sc, IWN_DEBUG_STATS, + "%s: size of rx statistics (%d) not an expected size!\n", + __func__, + len); + memcpy(&sc->last_stat, stats, sizeof(struct iwn_stats)); + sc->last_stat_valid = 1; + return; + } + + /* + * Ok. Time to copy. + */ + stats_bt = (struct iwn_stats_bt *) stats; + lstats = &sc->last_stat; + + /* flags */ + lstats->flags = stats_bt->flags; + /* rx_bt */ + memcpy(&lstats->rx.ofdm, &stats_bt->rx_bt.ofdm, + sizeof(struct iwn_rx_phy_stats)); + memcpy(&lstats->rx.cck, &stats_bt->rx_bt.cck, + sizeof(struct iwn_rx_phy_stats)); + memcpy(&lstats->rx.general, &stats_bt->rx_bt.general_bt.common, + sizeof(struct iwn_rx_general_stats)); + memcpy(&lstats->rx.ht, &stats_bt->rx_bt.ht, + sizeof(struct iwn_rx_ht_phy_stats)); + /* tx */ + memcpy(&lstats->tx, &stats_bt->tx, + sizeof(struct iwn_tx_stats)); + /* general */ + memcpy(&lstats->general, &stats_bt->general, + sizeof(struct iwn_general_stats)); + + /* XXX TODO: Squirrel away the extra bluetooth stats somewhere */ + sc->last_stat_valid = 1; +} + /* * Process an RX_STATISTICS or BEACON_STATISTICS firmware notification. * The latter is sent by the firmware after each received beacon. @@ -2782,6 +3324,7 @@ iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc, struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); struct iwn_calib_state *calib = &sc->calib; struct iwn_stats *stats = (struct iwn_stats *)(desc + 1); + struct iwn_stats *lstats; int temp; DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); @@ -2796,12 +3339,26 @@ iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc, bus_dmamap_sync(sc->rxq.data_dmat, data->map, BUS_DMASYNC_POSTREAD); - DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: received statistics, cmd %d\n", - __func__, desc->type); + DPRINTF(sc, IWN_DEBUG_CALIBRATE | IWN_DEBUG_STATS, + "%s: received statistics, cmd %d, len %d\n", + __func__, desc->type, le16toh(desc->len)); sc->calib_cnt = 0; /* Reset TX power calibration timeout. */ + /* + * Collect/track general statistics for reporting. + * + * This takes care of ensuring that the bluetooth sized message + * will be correctly converted to the legacy sized message. + */ + iwn_stats_update(sc, calib, stats, le16toh(desc->len)); + + /* + * And now, let's take a reference of it to use! + */ + lstats = &sc->last_stat; + /* Test if temperature has changed. */ - if (stats->general.temp != sc->rawtemp) { + if (lstats->general.temp != sc->rawtemp) { /* Convert "raw" temperature to degC. */ sc->rawtemp = stats->general.temp; temp = ops->get_temperature(sc); @@ -2816,25 +3373,51 @@ iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc, if (desc->type != IWN_BEACON_STATISTICS) return; /* Reply to a statistics request. */ - sc->noise = iwn_get_noise(&stats->rx.general); + sc->noise = iwn_get_noise(&lstats->rx.general); DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: noise %d\n", __func__, sc->noise); /* Test that RSSI and noise are present in stats report. */ - if (le32toh(stats->rx.general.flags) != 1) { + if (le32toh(lstats->rx.general.flags) != 1) { DPRINTF(sc, IWN_DEBUG_ANY, "%s\n", "received statistics without RSSI"); return; } if (calib->state == IWN_CALIB_STATE_ASSOC) - iwn_collect_noise(sc, &stats->rx.general); - else if (calib->state == IWN_CALIB_STATE_RUN) - iwn_tune_sensitivity(sc, &stats->rx); + iwn_collect_noise(sc, &lstats->rx.general); + else if (calib->state == IWN_CALIB_STATE_RUN) { + iwn_tune_sensitivity(sc, &lstats->rx); + /* + * XXX TODO: Only run the RX recovery if we're associated! + */ + iwn_check_rx_recovery(sc, lstats); + iwn_save_stats_counters(sc, lstats); + } DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__); } /* + * Save the relevant statistic counters for the next calibration + * pass. + */ +static void +iwn_save_stats_counters(struct iwn_softc *sc, const struct iwn_stats *rs) +{ + struct iwn_calib_state *calib = &sc->calib; + + /* Save counters values for next call. */ + calib->bad_plcp_cck = le32toh(rs->rx.cck.bad_plcp); + calib->fa_cck = le32toh(rs->rx.cck.fa); + calib->bad_plcp_ht = le32toh(rs->rx.ht.bad_plcp); + calib->bad_plcp_ofdm = le32toh(rs->rx.ofdm.bad_plcp); + calib->fa_ofdm = le32toh(rs->rx.ofdm.fa); + + /* Last time we received these tick values */ + sc->last_calib_ticks = ticks; +} + +/* * Process a TX_DONE firmware notification. Unfortunately, the 4965AGN * and 5000 adapters have different incompatible TX status formats. */ @@ -2850,15 +3433,18 @@ iwn4965_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, ring = &sc->txq[qid]; DPRINTF(sc, IWN_DEBUG_XMIT, "%s: " - "qid %d idx %d retries %d nkill %d rate %x duration %d status %x\n", - __func__, desc->qid, desc->idx, stat->ackfailcnt, - stat->btkillcnt, stat->rate, le16toh(stat->duration), + "qid %d idx %d RTS retries %d ACK retries %d nkill %d rate %x duration %d status %x\n", + __func__, desc->qid, desc->idx, + stat->rtsfailcnt, + stat->ackfailcnt, + stat->btkillcnt, + stat->rate, le16toh(stat->duration), le32toh(stat->status)); bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD); if (qid >= sc->firstaggqueue) { iwn_ampdu_tx_done(sc, qid, desc->idx, stat->nframes, - &stat->status); + stat->ackfailcnt, &stat->status); } else { iwn_tx_done(sc, desc, stat->ackfailcnt, le32toh(stat->status) & 0xff); @@ -2877,9 +3463,12 @@ iwn5000_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, ring = &sc->txq[qid]; DPRINTF(sc, IWN_DEBUG_XMIT, "%s: " - "qid %d idx %d retries %d nkill %d rate %x duration %d status %x\n", - __func__, desc->qid, desc->idx, stat->ackfailcnt, - stat->btkillcnt, stat->rate, le16toh(stat->duration), + "qid %d idx %d RTS retries %d ACK retries %d nkill %d rate %x duration %d status %x\n", + __func__, desc->qid, desc->idx, + stat->rtsfailcnt, + stat->ackfailcnt, + stat->btkillcnt, + stat->rate, le16toh(stat->duration), le32toh(stat->status)); #ifdef notyet @@ -2890,7 +3479,7 @@ iwn5000_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD); if (qid >= sc->firstaggqueue) { iwn_ampdu_tx_done(sc, qid, desc->idx, stat->nframes, - &stat->status); + stat->ackfailcnt, &stat->status); } else { iwn_tx_done(sc, desc, stat->ackfailcnt, le16toh(stat->status) & 0xff); @@ -2926,11 +3515,11 @@ iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt, * Update rate control statistics for the node. */ if (status & IWN_TX_FAIL) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL); } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL); } @@ -2977,12 +3566,19 @@ iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt, static void iwn_cmd_done(struct iwn_softc *sc, struct iwn_rx_desc *desc) { - struct iwn_tx_ring *ring = &sc->txq[4]; + struct iwn_tx_ring *ring; struct iwn_tx_data *data; + int cmd_queue_num; - if ((desc->qid & 0xf) != 4) + if (sc->sc_flags & IWN_FLAG_PAN_SUPPORT) + cmd_queue_num = IWN_PAN_CMD_QUEUE; + else + cmd_queue_num = IWN_CMD_QUEUE_NUM; + + if ((desc->qid & IWN_RX_DESC_QID_MSK) != cmd_queue_num) return; /* Not a command ack. */ + ring = &sc->txq[cmd_queue_num]; data = &ring->data[desc->idx]; /* If the command was mapped in an mbuf, free it. */ @@ -2998,7 +3594,7 @@ iwn_cmd_done(struct iwn_softc *sc, struct iwn_rx_desc *desc) static void iwn_ampdu_tx_done(struct iwn_softc *sc, int qid, int idx, int nframes, - void *stat) + int ackfailcnt, void *stat) { struct iwn_ops *ops = &sc->ops; struct ifnet *ifp = sc->sc_ifp; @@ -3015,14 +3611,60 @@ iwn_ampdu_tx_done(struct iwn_softc *sc, int qid, int idx, int nframes, uint8_t tid; int bit, i, lastidx, *res, seqno, shift, start; + /* XXX TODO: status is le16 field! Grr */ + DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: nframes=%d, status=0x%08x\n", + __func__, + nframes, + *status); -#ifdef NOT_YET + tap = sc->qid2tap[qid]; + tid = tap->txa_tid; + wn = (void *)tap->txa_ni; + ni = tap->txa_ni; + + /* + * XXX TODO: ACK and RTS failures would be nice here! + */ + + /* + * A-MPDU single frame status - if we failed to transmit it + * in A-MPDU, then it may be a permanent failure. + * + * XXX TODO: check what the Linux iwlwifi driver does here; + * there's some permanent and temporary failures that may be + * handled differently. + */ if (nframes == 1) { - if ((*status & 0xff) != 1 && (*status & 0xff) != 2) + if ((*status & 0xff) != 1 && (*status & 0xff) != 2) { +#ifdef NOT_YET printf("ieee80211_send_bar()\n"); - } #endif + /* + * If we completely fail a transmit, make sure a + * notification is pushed up to the rate control + * layer. + */ + ieee80211_ratectl_tx_complete(ni->ni_vap, + ni, + IEEE80211_RATECTL_TX_FAILURE, + &ackfailcnt, + NULL); + } else { + /* + * If nframes=1, then we won't be getting a BA for + * this frame. Ensure that we correctly update the + * rate control code with how many retries were + * needed to send it. + */ + ieee80211_ratectl_tx_complete(ni->ni_vap, + ni, + IEEE80211_RATECTL_TX_SUCCESS, + &ackfailcnt, + NULL); + } + } bitmap = 0; start = idx; @@ -3061,6 +3703,7 @@ iwn_ampdu_tx_done(struct iwn_softc *sc, int qid, int idx, int nframes, ssn = tap->txa_start & 0xfff; } + /* This is going nframes DWORDS into the descriptor? */ seqno = le32toh(*(status + nframes)) & 0xfff; for (lastidx = (seqno & 0xff); ring->read != lastidx;) { data = &ring->data[ring->read]; @@ -3074,7 +3717,7 @@ iwn_ampdu_tx_done(struct iwn_softc *sc, int qid, int idx, int nframes, KASSERT(ni != NULL, ("no node")); KASSERT(m != NULL, ("no mbuf")); - + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: freeing m=%p\n", __func__, m); ieee80211_tx_complete(ni, m, 1); ring->queued--; @@ -3129,12 +3772,12 @@ iwn_notif_intr(struct iwn_softc *sc) desc = mtod(data->m, struct iwn_rx_desc *); DPRINTF(sc, IWN_DEBUG_RECV, - "%s: qid %x idx %d flags %x type %d(%s) len %d\n", - __func__, desc->qid & 0xf, desc->idx, desc->flags, + "%s: cur=%d; qid %x idx %d flags %x type %d(%s) len %d\n", + __func__, sc->rxq.cur, desc->qid & 0xf, desc->idx, desc->flags, desc->type, iwn_intr_str(desc->type), le16toh(desc->len)); - if (!(desc->qid & 0x80)) /* Reply to a command. */ + if (!(desc->qid & IWN_UNSOLICITED_RX_NOTIF)) /* Reply to a command. */ iwn_cmd_done(sc, desc); switch (desc->type) { @@ -3229,7 +3872,8 @@ iwn_notif_intr(struct iwn_softc *sc) BUS_DMASYNC_POSTREAD); #ifdef IWN_DEBUG uint32_t *status = (uint32_t *)(desc + 1); - DPRINTF(sc, IWN_DEBUG_INTR, "state changed to %x\n", + DPRINTF(sc, IWN_DEBUG_INTR | IWN_DEBUG_STATE, + "state changed to %x\n", le32toh(*status)); #endif break; @@ -3254,11 +3898,11 @@ iwn_notif_intr(struct iwn_softc *sc) #ifdef IWN_DEBUG struct iwn_stop_scan *scan = (struct iwn_stop_scan *)(desc + 1); - DPRINTF(sc, IWN_DEBUG_STATE, + DPRINTF(sc, IWN_DEBUG_STATE | IWN_DEBUG_SCAN, "scan finished nchan=%d status=%d chan=%d\n", scan->nchan, scan->status, scan->chan); #endif - + sc->sc_is_scanning = 0; IWN_UNLOCK(sc); ieee80211_scan_next(vap); IWN_LOCK(sc); @@ -3410,8 +4054,10 @@ iwn_intr(void *arg) r2 = 0; /* Unused. */ } else { r1 = IWN_READ(sc, IWN_INT); - if (r1 == 0xffffffff || (r1 & 0xfffffff0) == 0xa5a5a5a0) + if (r1 == 0xffffffff || (r1 & 0xfffffff0) == 0xa5a5a5a0) { + IWN_UNLOCK(sc); return; /* Hardware gone! */ + } r2 = IWN_READ(sc, IWN_FH_INT); } @@ -3442,8 +4088,8 @@ iwn_intr(void *arg) #endif /* Dump firmware error log and stop. */ iwn_fatal_intr(sc); - ifp->if_flags &= ~IFF_UP; - iwn_stop_locked(sc); + + taskqueue_enqueue(sc->sc_tq, &sc->sc_panic_task); goto done; } if ((r1 & (IWN_INT_FH_RX | IWN_INT_SW_RX | IWN_INT_RX_PERIODIC)) || @@ -3541,6 +4187,115 @@ iwn5000_reset_sched(struct iwn_softc *sc, int qid, int idx) } #endif +/* + * Check whether OFDM 11g protection will be enabled for the given rate. + * + * The original driver code only enabled protection for OFDM rates. + * It didn't check to see whether it was operating in 11a or 11bg mode. + */ +static int +iwn_check_rate_needs_protection(struct iwn_softc *sc, + struct ieee80211vap *vap, uint8_t rate) +{ + struct ieee80211com *ic = vap->iv_ic; + + /* + * Not in 2GHz mode? Then there's no need to enable OFDM + * 11bg protection. + */ + if (! IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) { + return (0); + } + + /* + * 11bg protection not enabled? Then don't use it. + */ + if ((ic->ic_flags & IEEE80211_F_USEPROT) == 0) + return (0); + + /* + * If it's an 11n rate - no protection. + * We'll do it via a specific 11n check. + */ + if (rate & IEEE80211_RATE_MCS) { + return (0); + } + + /* + * Do a rate table lookup. If the PHY is CCK, + * don't do protection. + */ + if (ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_CCK) + return (0); + + /* + * Yup, enable protection. + */ + return (1); +} + +/* + * return a value between 0 and IWN_MAX_TX_RETRIES-1 as an index into + * the link quality table that reflects this particular entry. + */ +static int +iwn_tx_rate_to_linkq_offset(struct iwn_softc *sc, struct ieee80211_node *ni, + uint8_t rate) +{ + struct ieee80211_rateset *rs; + int is_11n; + int nr; + int i; + uint8_t cmp_rate; + + /* + * Figure out if we're using 11n or not here. + */ + if (IEEE80211_IS_CHAN_HT(ni->ni_chan) && ni->ni_htrates.rs_nrates > 0) + is_11n = 1; + else + is_11n = 0; + + /* + * Use the correct rate table. + */ + if (is_11n) { + rs = (struct ieee80211_rateset *) &ni->ni_htrates; + nr = ni->ni_htrates.rs_nrates; + } else { + rs = &ni->ni_rates; + nr = rs->rs_nrates; + } + + /* + * Find the relevant link quality entry in the table. + */ + for (i = 0; i < nr && i < IWN_MAX_TX_RETRIES - 1 ; i++) { + /* + * The link quality table index starts at 0 == highest + * rate, so we walk the rate table backwards. + */ + cmp_rate = rs->rs_rates[(nr - 1) - i]; + if (rate & IEEE80211_RATE_MCS) + cmp_rate |= IEEE80211_RATE_MCS; + +#if 0 + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: idx %d: nr=%d, rate=0x%02x, rateentry=0x%02x\n", + __func__, + i, + nr, + rate, + cmp_rate); +#endif + + if (cmp_rate == rate) + return (i); + } + + /* Failed? Start at the end */ + return (IWN_MAX_TX_RETRIES - 1); +} + static int iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) { @@ -3561,7 +4316,7 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) uint16_t qos; u_int hdrlen; bus_dma_segment_t *seg, segs[IWN_MAX_SCATTER]; - uint8_t tid, ridx, txant, type; + uint8_t tid, type; int ac, i, totlen, error, pad, nsegs = 0, rate; DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); @@ -3582,6 +4337,7 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) } ac = M_WME_GETAC(m); if (m->m_flags & M_AMPDU_MPDU) { + uint16_t seqno; struct ieee80211_tx_ampdu *tap = &ni->ni_tx_ampdu[ac]; if (!IEEE80211_AMPDU_RUNNING(tap)) { @@ -3589,9 +4345,27 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) return EINVAL; } + /* + * Queue this frame to the hardware ring that we've + * negotiated AMPDU TX on. + * + * Note that the sequence number must match the TX slot + * being used! + */ ac = *(int *)tap->txa_private; + seqno = ni->ni_txseqs[tid]; *(uint16_t *)wh->i_seq = - htole16(ni->ni_txseqs[tid] << IEEE80211_SEQ_SEQ_SHIFT); + htole16(seqno << IEEE80211_SEQ_SEQ_SHIFT); + ring = &sc->txq[ac]; + if ((seqno % 256) != ring->cur) { + device_printf(sc->sc_dev, + "%s: m=%p: seqno (%d) (%d) != ring index (%d) !\n", + __func__, + m, + seqno, + seqno % 256, + ring->cur); + } ni->ni_txseqs[tid]++; } ring = &sc->txq[ac]; @@ -3606,13 +4380,13 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) rate = tp->mcastrate; else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) rate = tp->ucastrate; + else if (m->m_flags & M_EAPOL) + rate = tp->mgmtrate; else { /* XXX pass pktlen */ (void) ieee80211_ratectl_rate(ni, NULL, 0); rate = ni->ni_txrate; } - 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_PROTECTED) { @@ -3669,13 +4443,18 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) /* NB: Group frames are sent using CCK in 802.11b/g. */ if (totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) { flags |= IWN_TX_NEED_RTS; - } else if ((ic->ic_flags & IEEE80211_F_USEPROT) && - ridx >= IWN_RIDX_OFDM6) { + } else if (iwn_check_rate_needs_protection(sc, vap, rate)) { if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) flags |= IWN_TX_NEED_CTS; else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) flags |= IWN_TX_NEED_RTS; + } else if ((rate & IEEE80211_RATE_MCS) && + (ic->ic_htprotmode == IEEE80211_PROT_RTSCTS)) { + flags |= IWN_TX_NEED_RTS; } + + /* XXX HT protection? */ + if (flags & (IWN_TX_NEED_RTS | IWN_TX_NEED_CTS)) { if (sc->hw_type != IWN_HW_REV_TYPE_4965) { /* 5000 autoselects RTS/CTS or CTS-to-self. */ @@ -3722,13 +4501,11 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) if (tx->id == sc->broadcast_id) { /* Group or management frame. */ tx->linkq = 0; - /* XXX Alternate between antenna A and B? */ - txant = IWN_LSB(sc->txchainmask); - tx->rate |= htole32(IWN_RFLAG_ANT(txant)); } else { - tx->linkq = ni->ni_rates.rs_nrates - ridx - 1; + tx->linkq = iwn_tx_rate_to_linkq_offset(sc, ni, rate); flags |= IWN_TX_LINKQ; /* enable MRR */ } + /* Set physical address of "scratch area". */ tx->loaddr = htole32(IWN_LOADDR(data->scratch_paddr)); tx->hiaddr = IWN_HIADDR(data->scratch_paddr); @@ -3751,7 +4528,7 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) return error; } /* Too many DMA segments, linearize mbuf. */ - m1 = m_collapse(m, M_NOWAIT, IWN_MAX_SCATTER); + m1 = m_collapse(m, M_NOWAIT, IWN_MAX_SCATTER - 1); if (m1 == NULL) { device_printf(sc->sc_dev, "%s: could not defrag mbuf\n", __func__); @@ -3773,8 +4550,16 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni) data->m = m; data->ni = ni; - DPRINTF(sc, IWN_DEBUG_XMIT, "%s: qid %d idx %d len %d nsegs %d\n", - __func__, ring->qid, ring->cur, m->m_pkthdr.len, nsegs); + DPRINTF(sc, IWN_DEBUG_XMIT, + "%s: qid %d idx %d len %d nsegs %d flags 0x%08x rate 0x%04x plcp 0x%08x\n", + __func__, + ring->qid, + ring->cur, + m->m_pkthdr.len, + nsegs, + flags, + rate, + tx->rate); /* Fill TX descriptor. */ desc->nsegs = 1; @@ -3821,9 +4606,9 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni, const struct ieee80211_bpf_params *params) { struct iwn_ops *ops = &sc->ops; - struct ifnet *ifp = sc->sc_ifp; +// struct ifnet *ifp = sc->sc_ifp; struct ieee80211vap *vap = ni->ni_vap; - struct ieee80211com *ic = ifp->if_l2com; +// struct ieee80211com *ic = ifp->if_l2com; struct iwn_tx_cmd *cmd; struct iwn_cmd_data *tx; struct ieee80211_frame *wh; @@ -3835,7 +4620,7 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m, uint32_t flags; u_int hdrlen; int ac, totlen, error, pad, nsegs = 0, i, rate; - uint8_t ridx, type, txant; + uint8_t type; DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); @@ -3851,16 +4636,8 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m, desc = &ring->desc[ring->cur]; data = &ring->data[ring->cur]; - /* Choose a TX rate index. */ + /* Choose a TX rate. */ rate = params->ibp_rate0; - 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); - return EINVAL; - } - totlen = m->m_pkthdr.len; /* Prepare TX firmware command. */ @@ -3930,17 +4707,10 @@ 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); + tx->rate = iwn_rate_to_plcp(sc, ni, rate); /* 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)); @@ -3964,7 +4734,7 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m, return error; } /* Too many DMA segments, linearize mbuf. */ - m1 = m_collapse(m, M_NOWAIT, IWN_MAX_SCATTER); + m1 = m_collapse(m, M_NOWAIT, IWN_MAX_SCATTER - 1); if (m1 == NULL) { device_printf(sc->sc_dev, "%s: could not defrag mbuf\n", __func__); @@ -4038,7 +4808,7 @@ iwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, struct iwn_softc *sc = ifp->if_softc; int error = 0; - DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); + DPRINTF(sc, IWN_DEBUG_XMIT | IWN_DEBUG_TRACE, "->%s begin\n", __func__); if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { ieee80211_free_node(ni); @@ -4063,13 +4833,13 @@ iwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, if (error != 0) { /* NB: m is reclaimed on tx failure */ ieee80211_free_node(ni); - ifp->if_oerrors++; - } - sc->sc_tx_timer = 5; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + } else + sc->sc_tx_timer = 5; IWN_UNLOCK(sc); - DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__); + DPRINTF(sc, IWN_DEBUG_TRACE | IWN_DEBUG_XMIT, "->%s: end\n",__func__); return error; } @@ -4093,6 +4863,8 @@ iwn_start_locked(struct ifnet *ifp) IWN_LOCK_ASSERT(sc); + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: called\n", __func__); + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || (ifp->if_drv_flags & IFF_DRV_OACTIVE)) return; @@ -4108,11 +4880,12 @@ iwn_start_locked(struct ifnet *ifp) ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; if (iwn_tx_data(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; - continue; - } - sc->sc_tx_timer = 5; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + } else + sc->sc_tx_timer = 5; } + + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: done\n", __func__); } static void @@ -4174,6 +4947,18 @@ iwn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) case SIOCGIFMEDIA: error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); break; + case SIOCGIWNSTATS: + IWN_LOCK(sc); + /* XXX validate permissions/memory/etc? */ + error = copyout(&sc->last_stat, ifr->ifr_data, + sizeof(struct iwn_stats)); + IWN_UNLOCK(sc); + break; + case SIOCZIWNSTATS: + IWN_LOCK(sc); + memset(&sc->last_stat, 0, sizeof(struct iwn_stats)); + IWN_UNLOCK(sc); + break; default: error = EINVAL; break; @@ -4187,19 +4972,26 @@ iwn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) static int iwn_cmd(struct iwn_softc *sc, int code, const void *buf, int size, int async) { - struct iwn_tx_ring *ring = &sc->txq[4]; + struct iwn_tx_ring *ring; struct iwn_tx_desc *desc; struct iwn_tx_data *data; struct iwn_tx_cmd *cmd; struct mbuf *m; bus_addr_t paddr; int totlen, error; + int cmd_queue_num; DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); if (async == 0) IWN_LOCK_ASSERT(sc); + if (sc->sc_flags & IWN_FLAG_PAN_SUPPORT) + cmd_queue_num = IWN_PAN_CMD_QUEUE; + else + cmd_queue_num = IWN_CMD_QUEUE_NUM; + + ring = &sc->txq[cmd_queue_num]; desc = &ring->desc[ring->cur]; data = &ring->data[ring->cur]; totlen = 4 + size; @@ -4293,42 +5085,87 @@ iwn_set_link_quality(struct iwn_softc *sc, struct ieee80211_node *ni) { #define RV(v) ((v) & IEEE80211_RATE_VAL) struct iwn_node *wn = (void *)ni; - struct ieee80211_rateset *rs = &ni->ni_rates; + struct ieee80211_rateset *rs; struct iwn_cmd_link_quality linkq; - uint8_t txant; int i, rate, txrate; + int is_11n; DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); - /* Use the first valid TX antenna. */ - txant = IWN_LSB(sc->txchainmask); - memset(&linkq, 0, sizeof linkq); linkq.id = wn->id; - linkq.antmsk_1stream = txant; - linkq.antmsk_2stream = IWN_ANT_AB; - linkq.ampdu_max = 64; + linkq.antmsk_1stream = iwn_get_1stream_tx_antmask(sc); + linkq.antmsk_2stream = iwn_get_2stream_tx_antmask(sc); + + linkq.ampdu_max = 32; /* XXX negotiated? */ linkq.ampdu_threshold = 3; linkq.ampdu_limit = htole16(4000); /* 4ms */ + DPRINTF(sc, IWN_DEBUG_XMIT, + "%s: 1stream antenna=0x%02x, 2stream antenna=0x%02x, ntxstreams=%d\n", + __func__, + linkq.antmsk_1stream, + linkq.antmsk_2stream, + sc->ntxchains); + + /* + * Are we using 11n rates? Ensure the channel is + * 11n _and_ we have some 11n rates, or don't + * try. + */ + if (IEEE80211_IS_CHAN_HT(ni->ni_chan) && ni->ni_htrates.rs_nrates > 0) { + rs = (struct ieee80211_rateset *) &ni->ni_htrates; + is_11n = 1; + } else { + rs = &ni->ni_rates; + is_11n = 0; + } + /* Start at highest available bit-rate. */ - if (IEEE80211_IS_CHAN_HT(ni->ni_chan)) + /* + * XXX this is all very dirty! + */ + if (is_11n) txrate = ni->ni_htrates.rs_nrates - 1; 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; + /* + * XXX TODO: ensure the last two slots are the two lowest + * rate entries, just for now. + */ + if (i == 14 || i == 15) + txrate = 0; + + if (is_11n) + rate = IEEE80211_RATE_MCS | rs->rs_rates[txrate]; else rate = RV(rs->rs_rates[txrate]); /* Do rate -> PLCP config mapping */ plcp = iwn_rate_to_plcp(sc, ni, rate); linkq.retry[i] = plcp; + DPRINTF(sc, IWN_DEBUG_XMIT, + "%s: i=%d, txrate=%d, rate=0x%02x, plcp=0x%08x\n", + __func__, + i, + txrate, + rate, + le32toh(plcp)); - /* Special case for dual-stream rates? */ + /* + * The mimo field is an index into the table which + * indicates the first index where it and subsequent entries + * will not be using MIMO. + * + * Since we're filling linkq from 0..15 and we're filling + * from the higest MCS rates to the lowest rates, if we + * _are_ doing a dual-stream rate, set mimo to idx+1 (ie, + * the next entry.) That way if the next entry is a non-MIMO + * entry, we're already pointing at it. + */ if ((le32toh(plcp) & IWN_RFLAG_MCS) && RV(le32toh(plcp)) > 7) linkq.mimo = i + 1; @@ -4337,6 +5174,15 @@ iwn_set_link_quality(struct iwn_softc *sc, struct ieee80211_node *ni) if (txrate > 0) txrate--; } + /* + * If we reached the end of the list and indeed we hit + * all MIMO rates (eg 5300 doing MCS23-15) then yes, + * set mimo to 15. Setting it to 16 panics the firmware. + */ + if (linkq.mimo > 15) + linkq.mimo = 15; + + DPRINTF(sc, IWN_DEBUG_XMIT, "%s: mimo = %d\n", __func__, linkq.mimo); DPRINTF(sc, IWN_DEBUG_TRACE, "->%s: end\n",__func__); @@ -4374,13 +5220,14 @@ iwn_add_broadcast_node(struct iwn_softc *sc, int async) memset(&linkq, 0, sizeof linkq); linkq.id = sc->broadcast_id; - linkq.antmsk_1stream = txant; - linkq.antmsk_2stream = IWN_ANT_AB; + linkq.antmsk_1stream = iwn_get_1stream_tx_antmask(sc); + linkq.antmsk_2stream = iwn_get_2stream_tx_antmask(sc); linkq.ampdu_max = 64; linkq.ampdu_threshold = 3; linkq.ampdu_limit = htole16(4000); /* 4ms */ /* Use lowest mandatory bit-rate. */ + /* XXX rate table lookup? */ if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) linkq.retry[0] = htole32(0xd); else @@ -4442,6 +5289,12 @@ iwn_set_led(struct iwn_softc *sc, uint8_t which, uint8_t off, uint8_t on) DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__); +#if 0 + /* XXX don't set LEDs during scan? */ + if (sc->sc_is_scanning) + return; +#endif + /* Clear microcode LED ownership. */ IWN_CLRBITS(sc, IWN_LED, IWN_LED_BSM_CTRL); @@ -4681,6 +5534,7 @@ iwn5000_set_txpower(struct iwn_softc *sc, struct ieee80211_channel *ch, int async) { struct iwn5000_cmd_txpower cmd; + int cmdid; DPRINTF(sc, IWN_DEBUG_TRACE, "->Doing %s\n", __func__); @@ -4692,8 +5546,15 @@ iwn5000_set_txpower(struct iwn_softc *sc, struct ieee80211_channel *ch, cmd.global_limit = 2 * IWN5000_TXPOWER_MAX_DBM; /* 16 dBm */ cmd.flags = IWN5000_TXPOWER_NO_CLOSED; cmd.srv_limit = IWN5000_TXPOWER_AUTO; - DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: setting TX power\n", __func__); - return iwn_cmd(sc, IWN_CMD_TXPOWER_DBM, &cmd, sizeof cmd, async); + DPRINTF(sc, IWN_DEBUG_CALIBRATE | IWN_DEBUG_XMIT, + "%s: setting TX power; rev=%d\n", + __func__, + IWN_UCODE_API(sc->ucode_rev)); + if (IWN_UCODE_API(sc->ucode_rev) == 1) + cmdid = IWN_CMD_TXPOWER_DBM_V1; + else + cmdid = IWN_CMD_TXPOWER_DBM; + return iwn_cmd(sc, cmdid, &cmd, sizeof cmd, async); } /* @@ -4893,7 +5754,7 @@ iwn_collect_noise(struct iwn_softc *sc, for (i = 0; i < 3; i++) if (val - calib->rssi[i] > 15 * 20) sc->chainmask &= ~(1 << i); - DPRINTF(sc, IWN_DEBUG_CALIBRATE, + DPRINTF(sc, IWN_DEBUG_CALIBRATE | IWN_DEBUG_XMIT, "%s: RX chains mask: theoretical=0x%x, actual=0x%x\n", __func__, sc->rxchainmask, sc->chainmask); @@ -4907,6 +5768,10 @@ iwn_collect_noise(struct iwn_softc *sc, #ifdef notyet /* XXX Disable RX chains with no antennas connected. */ sc->rxon->rxchain = htole16(IWN_RXCHAIN_SEL(sc->chainmask)); + if (sc->sc_is_scanning) + device_printf(sc->sc_dev, + "%s: is_scanning set, before RXON\n", + __func__); (void)iwn_cmd(sc, IWN_CMD_RXON, sc->rxon, sc->rxonsz, 1); #endif @@ -5014,7 +5879,7 @@ iwn5000_set_gains(struct iwn_softc *sc) cmd.gain[i - 1] |= 1 << 2; /* sign bit */ } } - DPRINTF(sc, IWN_DEBUG_CALIBRATE, + DPRINTF(sc, IWN_DEBUG_CALIBRATE | IWN_DEBUG_XMIT, "setting differential gains Ant B/C: %x/%x (%x)\n", cmd.gain[0], cmd.gain[1], sc->chainmask); return iwn_cmd(sc, IWN_CMD_PHY_CALIB, &cmd, sizeof cmd, 1); @@ -5064,10 +5929,6 @@ iwn_tune_sensitivity(struct iwn_softc *sc, const struct iwn_rx_stats *stats) fa += le32toh(stats->ofdm.fa) - calib->fa_ofdm; fa *= 200 * IEEE80211_DUR_TU; /* 200TU */ - /* Save counters values for next call. */ - calib->bad_plcp_ofdm = le32toh(stats->ofdm.bad_plcp); - calib->fa_ofdm = le32toh(stats->ofdm.fa); - if (fa > 50 * rxena) { /* High false alarm count, decrease sensitivity. */ DPRINTF(sc, IWN_DEBUG_CALIBRATE, @@ -5121,10 +5982,6 @@ iwn_tune_sensitivity(struct iwn_softc *sc, const struct iwn_rx_stats *stats) fa += le32toh(stats->cck.fa) - calib->fa_cck; fa *= 200 * IEEE80211_DUR_TU; /* 200TU */ - /* Save counters values for next call. */ - calib->bad_plcp_cck = le32toh(stats->cck.bad_plcp); - calib->fa_cck = le32toh(stats->cck.fa); - if (fa > 50 * rxena) { /* High false alarm count, decrease sensitivity. */ DPRINTF(sc, IWN_DEBUG_CALIBRATE, @@ -5205,7 +6062,7 @@ iwn_send_sensitivity(struct iwn_softc *sc) cmd.energy_cck = htole16(calib->energy_cck); /* Barker modulation: use default values. */ cmd.corr_barker = htole16(190); - cmd.corr_barker_mrc = htole16(390); + cmd.corr_barker_mrc = htole16(sc->limits->barker_mrc); DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: set sensitivity %d/%d/%d/%d/%d/%d/%d\n", __func__, @@ -5230,6 +6087,86 @@ send: } /* + * Look at the increase of PLCP errors over time; if it exceeds + * a programmed threshold then trigger an RF retune. + */ +static void +iwn_check_rx_recovery(struct iwn_softc *sc, struct iwn_stats *rs) +{ + int32_t delta_ofdm, delta_ht, delta_cck; + struct iwn_calib_state *calib = &sc->calib; + int delta_ticks, cur_ticks; + int delta_msec; + int thresh; + + /* + * Calculate the difference between the current and + * previous statistics. + */ + delta_cck = le32toh(rs->rx.cck.bad_plcp) - calib->bad_plcp_cck; + delta_ofdm = le32toh(rs->rx.ofdm.bad_plcp) - calib->bad_plcp_ofdm; + delta_ht = le32toh(rs->rx.ht.bad_plcp) - calib->bad_plcp_ht; + + /* + * Calculate the delta in time between successive statistics + * messages. Yes, it can roll over; so we make sure that + * this doesn't happen. + * + * XXX go figure out what to do about rollover + * XXX go figure out what to do if ticks rolls over to -ve instead! + * XXX go stab signed integer overflow undefined-ness in the face. + */ + cur_ticks = ticks; + delta_ticks = cur_ticks - sc->last_calib_ticks; + + /* + * If any are negative, then the firmware likely reset; so just + * bail. We'll pick this up next time. + */ + if (delta_cck < 0 || delta_ofdm < 0 || delta_ht < 0 || delta_ticks < 0) + return; + + /* + * delta_ticks is in ticks; we need to convert it up to milliseconds + * so we can do some useful math with it. + */ + delta_msec = ticks_to_msecs(delta_ticks); + + /* + * Calculate what our threshold is given the current delta_msec. + */ + thresh = sc->base_params->plcp_err_threshold * delta_msec; + + DPRINTF(sc, IWN_DEBUG_STATE, + "%s: time delta: %d; cck=%d, ofdm=%d, ht=%d, total=%d, thresh=%d\n", + __func__, + delta_msec, + delta_cck, + delta_ofdm, + delta_ht, + (delta_msec + delta_cck + delta_ofdm + delta_ht), + thresh); + + /* + * If we need a retune, then schedule a single channel scan + * to a channel that isn't the currently active one! + * + * The math from linux iwlwifi: + * + * if ((delta * 100 / msecs) > threshold) + */ + if (thresh > 0 && (delta_cck + delta_ofdm + delta_ht) * 100 > thresh) { + DPRINTF(sc, IWN_DEBUG_ANY, + "%s: PLCP error threshold raw (%d) comparison (%d) " + "over limit (%d); retune!\n", + __func__, + (delta_cck + delta_ofdm + delta_ht), + (delta_cck + delta_ofdm + delta_ht) * 100, + thresh); + } +} + +/* * Set STA mode power saving level (between 0 and 5). * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving. */ @@ -5314,25 +6251,73 @@ iwn_send_advanced_btcoex(struct iwn_softc *sc) 0xc0004000, 0x00004000, 0xf0005000, 0xf0005000, }; struct iwn6000_btcoex_config btconfig; + struct iwn2000_btcoex_config btconfig2k; struct iwn_btcoex_priotable btprio; struct iwn_btcoex_prot btprot; int error, i; + uint8_t flags; memset(&btconfig, 0, sizeof btconfig); - btconfig.flags = 145; - btconfig.max_kill = 5; - btconfig.bt3_t7_timer = 1; - btconfig.kill_ack = htole32(0xffff0000); - btconfig.kill_cts = htole32(0xffff0000); - btconfig.sample_time = 2; - btconfig.bt3_t2_timer = 0xc; - for (i = 0; i < 12; i++) - btconfig.lookup_table[i] = htole32(btcoex_3wire[i]); - btconfig.valid = htole16(0xff); - btconfig.prio_boost = 0xf0; - DPRINTF(sc, IWN_DEBUG_RESET, - "%s: configuring advanced bluetooth coexistence\n", __func__); - error = iwn_cmd(sc, IWN_CMD_BT_COEX, &btconfig, sizeof(btconfig), 1); + memset(&btconfig2k, 0, sizeof btconfig2k); + + flags = IWN_BT_FLAG_COEX6000_MODE_3W << + IWN_BT_FLAG_COEX6000_MODE_SHIFT; // Done as is in linux kernel 3.2 + + if (sc->base_params->bt_sco_disable) + flags &= ~IWN_BT_FLAG_SYNC_2_BT_DISABLE; + else + flags |= IWN_BT_FLAG_SYNC_2_BT_DISABLE; + + flags |= IWN_BT_FLAG_COEX6000_CHAN_INHIBITION; + + /* Default flags result is 145 as old value */ + + /* + * Flags value has to be review. Values must change if we + * which to disable it + */ + if (sc->base_params->bt_session_2) { + btconfig2k.flags = flags; + btconfig2k.max_kill = 5; + btconfig2k.bt3_t7_timer = 1; + btconfig2k.kill_ack = htole32(0xffff0000); + btconfig2k.kill_cts = htole32(0xffff0000); + btconfig2k.sample_time = 2; + btconfig2k.bt3_t2_timer = 0xc; + + for (i = 0; i < 12; i++) + btconfig2k.lookup_table[i] = htole32(btcoex_3wire[i]); + btconfig2k.valid = htole16(0xff); + btconfig2k.prio_boost = htole32(0xf0); + DPRINTF(sc, IWN_DEBUG_RESET, + "%s: configuring advanced bluetooth coexistence" + " session 2, flags : 0x%x\n", + __func__, + flags); + error = iwn_cmd(sc, IWN_CMD_BT_COEX, &btconfig2k, + sizeof(btconfig2k), 1); + } else { + btconfig.flags = flags; + btconfig.max_kill = 5; + btconfig.bt3_t7_timer = 1; + btconfig.kill_ack = htole32(0xffff0000); + btconfig.kill_cts = htole32(0xffff0000); + btconfig.sample_time = 2; + btconfig.bt3_t2_timer = 0xc; + + for (i = 0; i < 12; i++) + btconfig.lookup_table[i] = htole32(btcoex_3wire[i]); + btconfig.valid = htole16(0xff); + btconfig.prio_boost = 0xf0; + DPRINTF(sc, IWN_DEBUG_RESET, + "%s: configuring advanced bluetooth coexistence," + " flags : 0x%x\n", + __func__, + flags); + error = iwn_cmd(sc, IWN_CMD_BT_COEX, &btconfig, + sizeof(btconfig), 1); + } + if (error != 0) return error; @@ -5387,13 +6372,32 @@ iwn_config(struct iwn_softc *sc) DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); - if (sc->hw_type == IWN_HW_REV_TYPE_6005) { - /* Set radio temperature sensor offset. */ + if ((sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET) + && (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2)) { + device_printf(sc->sc_dev,"%s: temp_offset and temp_offsetv2 are" + " exclusive each together. Review NIC config file. Conf" + " : 0x%08x Flags : 0x%08x \n", __func__, + sc->base_params->calib_need, + (IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET | + IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2)); + return (EINVAL); + } + + /* Compute temperature calib if needed. Will be send by send calib */ + if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET) { error = iwn5000_temp_offset_calib(sc); if (error != 0) { device_printf(sc->sc_dev, "%s: could not set temperature offset\n", __func__); - return error; + return (error); + } + } else if (sc->base_params->calib_need & IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2) { + error = iwn5000_temp_offset_calibv2(sc); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: could not compute temperature offset v2\n", + __func__); + return (error); } } @@ -5409,9 +6413,10 @@ iwn_config(struct iwn_softc *sc) } /* Configure valid TX chains for >=5000 Series. */ - if (sc->hw_type != IWN_HW_REV_TYPE_4965) { + if (sc->hw_type != IWN_HW_REV_TYPE_4965 && + IWN_UCODE_API(sc->ucode_rev) > 1) { txmask = htole32(sc->txchainmask); - DPRINTF(sc, IWN_DEBUG_RESET, + DPRINTF(sc, IWN_DEBUG_RESET | IWN_DEBUG_XMIT, "%s: configuring valid TX chains 0x%x\n", __func__, txmask); error = iwn_cmd(sc, IWN5000_CMD_TX_ANT_CONFIG, &txmask, sizeof txmask, 0); @@ -5424,10 +6429,14 @@ iwn_config(struct iwn_softc *sc) } /* Configure bluetooth coexistence. */ - if (sc->sc_flags & IWN_FLAG_ADV_BTCOEX) + error = 0; + + /* Configure bluetooth coexistence if needed. */ + if (sc->base_params->bt_mode == IWN_BT_ADVANCED) error = iwn_send_advanced_btcoex(sc); - else + if (sc->base_params->bt_mode == IWN_BT_SIMPLE) error = iwn_send_btcoex(sc); + if (error != 0) { device_printf(sc->sc_dev, "%s: could not configure bluetooth coexistence, error %d\n", @@ -5463,12 +6472,29 @@ iwn_config(struct iwn_softc *sc) sc->rxon->ht_single_mask = 0xff; sc->rxon->ht_dual_mask = 0xff; sc->rxon->ht_triple_mask = 0xff; + /* + * In active association mode, ensure that + * all the receive chains are enabled. + * + * Since we're not yet doing SMPS, don't allow the + * number of idle RX chains to be less than the active + * number. + */ rxchain = IWN_RXCHAIN_VALID(sc->rxchainmask) | - IWN_RXCHAIN_MIMO_COUNT(2) | - IWN_RXCHAIN_IDLE_COUNT(2); + IWN_RXCHAIN_MIMO_COUNT(sc->nrxchains) | + IWN_RXCHAIN_IDLE_COUNT(sc->nrxchains); sc->rxon->rxchain = htole16(rxchain); + DPRINTF(sc, IWN_DEBUG_RESET | IWN_DEBUG_XMIT, + "%s: rxchainmask=0x%x, nrxchains=%d\n", + __func__, + sc->rxchainmask, + sc->nrxchains); DPRINTF(sc, IWN_DEBUG_RESET, "%s: setting configuration\n", __func__); + if (sc->sc_is_scanning) + device_printf(sc->sc_dev, + "%s: is_scanning set, before RXON\n", + __func__); error = iwn_cmd(sc, IWN_CMD_RXON, sc->rxon, sc->rxonsz, 0); if (error != 0) { device_printf(sc->sc_dev, "%s: RXON command failed\n", @@ -5507,39 +6533,109 @@ iwn_config(struct iwn_softc *sc) return 0; } +static uint16_t +iwn_get_active_dwell_time(struct iwn_softc *sc, + struct ieee80211_channel *c, uint8_t n_probes) +{ + /* No channel? Default to 2GHz settings */ + if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) { + return (IWN_ACTIVE_DWELL_TIME_2GHZ + + IWN_ACTIVE_DWELL_FACTOR_2GHZ * (n_probes + 1)); + } + + /* 5GHz dwell time */ + return (IWN_ACTIVE_DWELL_TIME_5GHZ + + IWN_ACTIVE_DWELL_FACTOR_5GHZ * (n_probes + 1)); +} + /* - * Add an ssid element to a frame. + * Limit the total dwell time to 85% of the beacon interval. + * + * Returns the dwell time in milliseconds. */ -static uint8_t * -ieee80211_add_ssid(uint8_t *frm, const uint8_t *ssid, u_int len) +static uint16_t +iwn_limit_dwell(struct iwn_softc *sc, uint16_t dwell_time) +{ + struct ieee80211com *ic = sc->sc_ifp->if_l2com; + struct ieee80211vap *vap = NULL; + int bintval = 0; + + /* bintval is in TU (1.024mS) */ + if (! TAILQ_EMPTY(&ic->ic_vaps)) { + vap = TAILQ_FIRST(&ic->ic_vaps); + bintval = vap->iv_bss->ni_intval; + } + + /* + * If it's non-zero, we should calculate the minimum of + * it and the DWELL_BASE. + * + * XXX Yes, the math should take into account that bintval + * is 1.024mS, not 1mS.. + */ + if (bintval > 0) { + DPRINTF(sc, IWN_DEBUG_SCAN, + "%s: bintval=%d\n", + __func__, + bintval); + return (MIN(IWN_PASSIVE_DWELL_BASE, ((bintval * 85) / 100))); + } + + /* No association context? Default */ + return (IWN_PASSIVE_DWELL_BASE); +} + +static uint16_t +iwn_get_passive_dwell_time(struct iwn_softc *sc, struct ieee80211_channel *c) { - *frm++ = IEEE80211_ELEMID_SSID; - *frm++ = len; - memcpy(frm, ssid, len); - return frm + len; + uint16_t passive; + + if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) { + passive = IWN_PASSIVE_DWELL_BASE + IWN_PASSIVE_DWELL_TIME_2GHZ; + } else { + passive = IWN_PASSIVE_DWELL_BASE + IWN_PASSIVE_DWELL_TIME_5GHZ; + } + + /* Clamp to the beacon interval if we're associated */ + return (iwn_limit_dwell(sc, passive)); } static int -iwn_scan(struct iwn_softc *sc) +iwn_scan(struct iwn_softc *sc, struct ieee80211vap *vap, + struct ieee80211_scan_state *ss, struct ieee80211_channel *c) { struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; - struct ieee80211_scan_state *ss = ic->ic_scan; /*XXX*/ - struct ieee80211_node *ni = ss->ss_vap->iv_bss; + struct ieee80211_node *ni = vap->iv_bss; struct iwn_scan_hdr *hdr; struct iwn_cmd_data *tx; struct iwn_scan_essid *essid; struct iwn_scan_chan *chan; struct ieee80211_frame *wh; struct ieee80211_rateset *rs; - struct ieee80211_channel *c; uint8_t *buf, *frm; uint16_t rxchain; uint8_t txant; int buflen, error; + int is_active; + uint16_t dwell_active, dwell_passive; + uint32_t extra, scan_service_time; DPRINTF(sc, IWN_DEBUG_TRACE, "->%s begin\n", __func__); + /* + * We are absolutely not allowed to send a scan command when another + * scan command is pending. + */ + if (sc->sc_is_scanning) { + device_printf(sc->sc_dev, "%s: called whilst scanning!\n", + __func__); + return (EAGAIN); + } + + /* Assign the scan channel */ + c = ic->ic_curchan; + sc->rxon = &sc->rx_on[IWN_RXON_BSS_CTX]; buf = malloc(IWN_SCAN_MAXSZ, M_DEVBUF, M_NOWAIT | M_ZERO); if (buf == NULL) { @@ -5555,13 +6651,29 @@ iwn_scan(struct iwn_softc *sc) */ hdr->quiet_time = htole16(10); /* timeout in milliseconds */ hdr->quiet_threshold = htole16(1); /* min # of packets */ + /* + * Max needs to be greater than active and passive and quiet! + * It's also in microseconds! + */ + hdr->max_svc = htole32(250 * 1024); + + /* + * Reset scan: interval=100 + * Normal scan: interval=becaon interval + * suspend_time: 100 (TU) + * + */ + extra = (100 /* suspend_time */ / 100 /* beacon interval */) << 22; + //scan_service_time = extra | ((100 /* susp */ % 100 /* int */) * 1024); + scan_service_time = (4 << 22) | (100 * 1024); /* Hardcode for now! */ + hdr->pause_svc = htole32(scan_service_time); /* Select antennas for scanning. */ rxchain = IWN_RXCHAIN_VALID(sc->rxchainmask) | IWN_RXCHAIN_FORCE_MIMO_SEL(sc->rxchainmask) | IWN_RXCHAIN_DRIVER_FORCE; - if (IEEE80211_IS_CHAN_A(ic->ic_curchan) && + if (IEEE80211_IS_CHAN_A(c) && sc->hw_type == IWN_HW_REV_TYPE_4965) { /* Ant A must be avoided in 5GHz because of an HW bug. */ rxchain |= IWN_RXCHAIN_FORCE_SEL(IWN_ANT_B); @@ -5575,7 +6687,7 @@ iwn_scan(struct iwn_softc *sc) tx->id = sc->broadcast_id; tx->lifetime = htole32(IWN_LIFETIME_INFINITE); - if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) { + if (IEEE80211_IS_CHAN_5GHZ(c)) { /* Send probe requests at 6Mbps. */ tx->rate = htole32(0xd); rs = &ic->ic_sup_rates[IEEE80211_MODE_11A]; @@ -5594,12 +6706,35 @@ iwn_scan(struct iwn_softc *sc) txant = IWN_LSB(sc->txchainmask); tx->rate |= htole32(IWN_RFLAG_ANT(txant)); + /* + * Only do active scanning if we're announcing a probe request + * for a given SSID (or more, if we ever add it to the driver.) + */ + is_active = 0; + + /* + * If we're scanning for a specific SSID, add it to the command. + * + * XXX maybe look at adding support for scanning multiple SSIDs? + */ essid = (struct iwn_scan_essid *)(tx + 1); - if (ss->ss_ssid[0].len != 0) { - essid[0].id = IEEE80211_ELEMID_SSID; - essid[0].len = ss->ss_ssid[0].len; - memcpy(essid[0].data, ss->ss_ssid[0].ssid, ss->ss_ssid[0].len); + if (ss != NULL) { + if (ss->ss_ssid[0].len != 0) { + essid[0].id = IEEE80211_ELEMID_SSID; + essid[0].len = ss->ss_ssid[0].len; + memcpy(essid[0].data, ss->ss_ssid[0].ssid, ss->ss_ssid[0].len); + } + + DPRINTF(sc, IWN_DEBUG_SCAN, "%s: ssid_len=%d, ssid=%*s\n", + __func__, + ss->ss_ssid[0].len, + ss->ss_ssid[0].len, + ss->ss_ssid[0].ssid); + + if (ss->ss_nssid > 0) + is_active = 1; } + /* * Build a probe request frame. Most of the following code is a * copy & paste of what is done in net80211. @@ -5625,53 +6760,96 @@ iwn_scan(struct iwn_softc *sc) /* Set length of probe request. */ tx->len = htole16(frm - (uint8_t *)wh); - c = ic->ic_curchan; + /* + * If active scanning is requested but a certain channel is + * marked passive, we can do active scanning if we detect + * transmissions. + * + * There is an issue with some firmware versions that triggers + * a sysassert on a "good CRC threshold" of zero (== disabled), + * on a radar channel even though this means that we should NOT + * send probes. + * + * The "good CRC threshold" is the number of frames that we + * need to receive during our dwell time on a channel before + * sending out probes -- setting this to a huge value will + * mean we never reach it, but at the same time work around + * the aforementioned issue. Thus use IWL_GOOD_CRC_TH_NEVER + * here instead of IWL_GOOD_CRC_TH_DISABLED. + * + * This was fixed in later versions along with some other + * scan changes, and the threshold behaves as a flag in those + * versions. + */ + + /* + * If we're doing active scanning, set the crc_threshold + * to a suitable value. This is different to active veruss + * passive scanning depending upon the channel flags; the + * firmware will obey that particular check for us. + */ + if (sc->tlv_feature_flags & IWN_UCODE_TLV_FLAGS_NEWSCAN) + hdr->crc_threshold = is_active ? + IWN_GOOD_CRC_TH_DEFAULT : IWN_GOOD_CRC_TH_DISABLED; + else + hdr->crc_threshold = is_active ? + IWN_GOOD_CRC_TH_DEFAULT : IWN_GOOD_CRC_TH_NEVER; + chan = (struct iwn_scan_chan *)frm; chan->chan = htole16(ieee80211_chan2ieee(ic, c)); chan->flags = 0; if (ss->ss_nssid > 0) chan->flags |= htole32(IWN_CHAN_NPBREQS(1)); chan->dsp_gain = 0x6e; - if (IEEE80211_IS_CHAN_5GHZ(c) && - !(c->ic_flags & IEEE80211_CHAN_PASSIVE)) { - chan->rf_gain = 0x3b; - chan->active = htole16(24); - chan->passive = htole16(110); + + /* + * Set the passive/active flag depending upon the channel mode. + * XXX TODO: take the is_active flag into account as well? + */ + if (c->ic_flags & IEEE80211_CHAN_PASSIVE) + chan->flags |= htole32(IWN_CHAN_PASSIVE); + else chan->flags |= htole32(IWN_CHAN_ACTIVE); - } else if (IEEE80211_IS_CHAN_5GHZ(c)) { + + /* + * Calculate the active/passive dwell times. + */ + + dwell_active = iwn_get_active_dwell_time(sc, c, ss->ss_nssid); + dwell_passive = iwn_get_passive_dwell_time(sc, c); + + /* Make sure they're valid */ + if (dwell_passive <= dwell_active) + dwell_passive = dwell_active + 1; + + chan->active = htole16(dwell_active); + chan->passive = htole16(dwell_passive); + + if (IEEE80211_IS_CHAN_5GHZ(c)) chan->rf_gain = 0x3b; - chan->active = htole16(24); - if (sc->rxon->associd) - chan->passive = htole16(78); - else - chan->passive = htole16(110); - hdr->crc_threshold = 0xffff; - } else if (!(c->ic_flags & IEEE80211_CHAN_PASSIVE)) { - chan->rf_gain = 0x28; - chan->active = htole16(36); - chan->passive = htole16(120); - chan->flags |= htole32(IWN_CHAN_ACTIVE); - } else { + else chan->rf_gain = 0x28; - chan->active = htole16(36); - if (sc->rxon->associd) - chan->passive = htole16(88); - else - chan->passive = htole16(120); - hdr->crc_threshold = 0xffff; - } DPRINTF(sc, IWN_DEBUG_STATE, "%s: chan %u flags 0x%x rf_gain 0x%x " - "dsp_gain 0x%x active 0x%x passive 0x%x\n", __func__, + "dsp_gain 0x%x active %d passive %d scan_svc_time %d crc 0x%x " + "isactive=%d numssid=%d\n", __func__, chan->chan, chan->flags, chan->rf_gain, chan->dsp_gain, - chan->active, chan->passive); + dwell_active, dwell_passive, scan_service_time, + hdr->crc_threshold, is_active, ss->ss_nssid); hdr->nchan++; chan++; buflen = (uint8_t *)chan - buf; hdr->len = htole16(buflen); + if (sc->sc_is_scanning) { + device_printf(sc->sc_dev, + "%s: called with is_scanning set!\n", + __func__); + } + sc->sc_is_scanning = 1; + DPRINTF(sc, IWN_DEBUG_STATE, "sending scan command nchan=%d\n", hdr->nchan); error = iwn_cmd(sc, IWN_CMD_SCAN, buf, buflen, 1); @@ -5712,12 +6890,16 @@ iwn_auth(struct iwn_softc *sc, struct ieee80211vap *vap) sc->rxon->ofdm_mask = 0; } else { /* Assume 802.11b/g. */ - sc->rxon->cck_mask = 0x0f; + sc->rxon->cck_mask = 0x03; sc->rxon->ofdm_mask = 0x15; } DPRINTF(sc, IWN_DEBUG_STATE, "rxon chan %d flags %x cck %x ofdm %x\n", sc->rxon->chan, sc->rxon->flags, sc->rxon->cck_mask, sc->rxon->ofdm_mask); + if (sc->sc_is_scanning) + device_printf(sc->sc_dev, + "%s: is_scanning set, before RXON\n", + __func__); error = iwn_cmd(sc, IWN_CMD_RXON, sc->rxon, sc->rxonsz, 1); if (error != 0) { device_printf(sc->sc_dev, "%s: RXON command failed, error %d\n", @@ -5813,6 +6995,10 @@ iwn_run(struct iwn_softc *sc, struct ieee80211vap *vap) sc->rxon->filter |= htole32(IWN_FILTER_BSS); DPRINTF(sc, IWN_DEBUG_STATE, "rxon chan %d flags %x\n", sc->rxon->chan, sc->rxon->flags); + if (sc->sc_is_scanning) + device_printf(sc->sc_dev, + "%s: is_scanning set, before RXON\n", + __func__); error = iwn_cmd(sc, IWN_CMD_RXON, sc->rxon, sc->rxonsz, 1); if (error != 0) { device_printf(sc->sc_dev, @@ -6211,10 +7397,10 @@ iwn5000_query_calibration(struct iwn_softc *sc) int error; memset(&cmd, 0, sizeof cmd); - cmd.ucode.once.enable = 0xffffffff; - cmd.ucode.once.start = 0xffffffff; - cmd.ucode.once.send = 0xffffffff; - cmd.ucode.flags = 0xffffffff; + cmd.ucode.once.enable = htole32(0xffffffff); + cmd.ucode.once.start = htole32(0xffffffff); + cmd.ucode.once.send = htole32(0xffffffff); + cmd.ucode.flags = htole32(0xffffffff); DPRINTF(sc, IWN_DEBUG_CALIBRATE, "%s: sending calibration query\n", __func__); error = iwn_cmd(sc, IWN5000_CMD_CALIB_CONFIG, &cmd, sizeof cmd, 0); @@ -6236,9 +7422,20 @@ iwn5000_send_calibration(struct iwn_softc *sc) { int idx, error; - for (idx = 0; idx < 5; idx++) { - if (sc->calibcmd[idx].buf == NULL) - continue; /* No results available. */ + for (idx = 0; idx < IWN5000_PHY_CALIB_MAX_RESULT; idx++) { + if (!(sc->base_params->calib_need & (1<<idx))) { + DPRINTF(sc, IWN_DEBUG_CALIBRATE, + "No need of calib %d\n", + idx); + continue; /* no need for this calib */ + } + if (sc->calibcmd[idx].buf == NULL) { + DPRINTF(sc, IWN_DEBUG_CALIBRATE, + "Need calib idx : %d but no available data\n", + idx); + continue; + } + DPRINTF(sc, IWN_DEBUG_CALIBRATE, "send calibration result idx=%d len=%d\n", idx, sc->calibcmd[idx].len); @@ -6259,7 +7456,7 @@ iwn5000_send_wimax_coex(struct iwn_softc *sc) { struct iwn5000_wimax_coex wimax; -#ifdef notyet +#if 0 if (sc->hw_type == IWN_HW_REV_TYPE_6050) { /* Enable WiMAX coexistence for combo adapters. */ wimax.flags = @@ -6315,6 +7512,33 @@ iwn5000_temp_offset_calib(struct iwn_softc *sc) return iwn_cmd(sc, IWN_CMD_PHY_CALIB, &cmd, sizeof cmd, 0); } +static int +iwn5000_temp_offset_calibv2(struct iwn_softc *sc) +{ + struct iwn5000_phy_calib_temp_offsetv2 cmd; + + memset(&cmd, 0, sizeof cmd); + cmd.code = IWN5000_PHY_CALIB_TEMP_OFFSET; + cmd.ngroups = 1; + cmd.isvalid = 1; + if (sc->eeprom_temp != 0) { + cmd.offset_low = htole16(sc->eeprom_temp); + cmd.offset_high = htole16(sc->eeprom_temp_high); + } else { + cmd.offset_low = htole16(IWN_DEFAULT_TEMP_OFFSET); + cmd.offset_high = htole16(IWN_DEFAULT_TEMP_OFFSET); + } + cmd.burnt_voltage_ref = htole16(sc->eeprom_voltage); + + DPRINTF(sc, IWN_DEBUG_CALIBRATE, + "setting radio sensor low offset to %d, high offset to %d, voltage to %d\n", + le16toh(cmd.offset_low), + le16toh(cmd.offset_high), + le16toh(cmd.burnt_voltage_ref)); + + return iwn_cmd(sc, IWN_CMD_PHY_CALIB, &cmd, sizeof cmd, 0); +} + /* * This function is called after the runtime firmware notifies us of its * readiness (called in a process context). @@ -6400,7 +7624,10 @@ iwn5000_post_alive(struct iwn_softc *sc) IWN_SETBITS(sc, IWN_FH_TX_CHICKEN, IWN_FH_TX_CHICKEN_SCHED_RETRY); /* Enable chain mode for all queues, except command queue. */ - iwn_prph_write(sc, IWN5000_SCHED_QCHAIN_SEL, 0xfffef); + if (sc->sc_flags & IWN_FLAG_PAN_SUPPORT) + iwn_prph_write(sc, IWN5000_SCHED_QCHAIN_SEL, 0xfffdf); + else + iwn_prph_write(sc, IWN5000_SCHED_QCHAIN_SEL, 0xfffef); iwn_prph_write(sc, IWN5000_SCHED_AGGR_SEL, 0); for (qid = 0; qid < IWN5000_NTXQUEUES; qid++) { @@ -6421,10 +7648,20 @@ iwn5000_post_alive(struct iwn_softc *sc) iwn_prph_write(sc, IWN5000_SCHED_TXFACT, 0xff); /* Mark TX rings (4 EDCA + cmd + 2 HCCA) as active. */ - for (qid = 0; qid < 7; qid++) { - static uint8_t qid2fifo[] = { 3, 2, 1, 0, 7, 5, 6 }; - iwn_prph_write(sc, IWN5000_SCHED_QUEUE_STATUS(qid), - IWN5000_TXQ_STATUS_ACTIVE | qid2fifo[qid]); + if (sc->sc_flags & IWN_FLAG_PAN_SUPPORT) { + /* Mark TX rings as active. */ + for (qid = 0; qid < 11; qid++) { + static uint8_t qid2fifo[] = { 3, 2, 1, 0, 0, 4, 2, 5, 4, 7, 5 }; + iwn_prph_write(sc, IWN5000_SCHED_QUEUE_STATUS(qid), + IWN5000_TXQ_STATUS_ACTIVE | qid2fifo[qid]); + } + } else { + /* Mark TX rings (4 EDCA + cmd + 2 HCCA) as active. */ + for (qid = 0; qid < 7; qid++) { + static uint8_t qid2fifo[] = { 3, 2, 1, 0, 7, 5, 6 }; + iwn_prph_write(sc, IWN5000_SCHED_QUEUE_STATUS(qid), + IWN5000_TXQ_STATUS_ACTIVE | qid2fifo[qid]); + } } iwn_nic_unlock(sc); @@ -6669,6 +7906,8 @@ iwn_read_firmware_leg(struct iwn_softc *sc, struct iwn_fw_info *fw) ptr = (const uint32_t *)fw->data; rev = le32toh(*ptr++); + sc->ucode_rev = rev; + /* Check firmware API version. */ if (IWN_FW_API(rev) <= 1) { device_printf(sc->sc_dev, @@ -6734,6 +7973,7 @@ iwn_read_firmware_tlv(struct iwn_softc *sc, struct iwn_fw_info *fw, } DPRINTF(sc, IWN_DEBUG_RESET, "FW: \"%.64s\", build 0x%x\n", hdr->descr, le32toh(hdr->build)); + sc->ucode_rev = le32toh(hdr->rev); /* * Select the closest supported alternative that is less than @@ -6789,7 +8029,7 @@ iwn_read_firmware_tlv(struct iwn_softc *sc, struct iwn_fw_info *fw, sc->sc_flags |= IWN_FLAG_ENH_SENS; break; case IWN_FW_TLV_PHY_CALIB: - tmp = htole32(*ptr); + tmp = le32toh(*ptr); if (tmp < 253) { sc->reset_noise_gain = tmp; sc->noise_gain = tmp + 1; @@ -6800,8 +8040,16 @@ iwn_read_firmware_tlv(struct iwn_softc *sc, struct iwn_fw_info *fw, DPRINTF(sc, IWN_DEBUG_RESET, "PAN Support found: %d\n", 1); break; - case IWN_FW_TLV_FLAGS : - sc->tlv_feature_flags = htole32(*ptr); + case IWN_FW_TLV_FLAGS: + if (len < sizeof(uint32_t)) + break; + if (len % sizeof(uint32_t)) + break; + sc->tlv_feature_flags = le32toh(*ptr); + DPRINTF(sc, IWN_DEBUG_RESET, + "%s: feature: 0x%08x\n", + __func__, + sc->tlv_feature_flags); break; case IWN_FW_TLV_PBREQ_MAXLEN: case IWN_FW_TLV_RUNT_EVTLOG_PTR: @@ -6873,6 +8121,8 @@ iwn_read_firmware(struct iwn_softc *sc) return error; } + device_printf(sc->sc_dev, "%s: ucode rev=0x%08x\n", __func__, sc->ucode_rev); + /* Make sure text and data sections fit in hardware memory. */ if (fw->main.textsz > sc->fw_text_maxsz || fw->main.datasz > sc->fw_data_maxsz || @@ -6937,9 +8187,8 @@ iwn_apm_init(struct iwn_softc *sc) else IWN_CLRBITS(sc, IWN_GIO, IWN_GIO_L0S_ENA); - if (sc->hw_type != IWN_HW_REV_TYPE_4965 && - sc->hw_type <= IWN_HW_REV_TYPE_1000) - IWN_SETBITS(sc, IWN_ANA_PLL, IWN_ANA_PLL_INIT); + if (sc->base_params->pll_cfg_val) + IWN_SETBITS(sc, IWN_ANA_PLL, sc->base_params->pll_cfg_val); /* Wait for clock stabilization before accessing prph. */ if ((error = iwn_clock_wait(sc)) != 0) @@ -7051,13 +8300,13 @@ iwn5000_nic_config(struct iwn_softc *sc) /* Use internal power amplifier only. */ IWN_WRITE(sc, IWN_GP_DRIVER, IWN_GP_DRIVER_RADIO_2X2_IPA); } - if ((sc->hw_type == IWN_HW_REV_TYPE_6050 || - sc->hw_type == IWN_HW_REV_TYPE_6005) && sc->calib_ver >= 6) { + if (sc->base_params->additional_nic_config && sc->calib_ver >= 6) { /* Indicate that ROM calibration version is >=6. */ IWN_SETBITS(sc, IWN_GP_DRIVER, IWN_GP_DRIVER_CALIB_VER6); } - if (sc->hw_type == IWN_HW_REV_TYPE_6005) - IWN_SETBITS(sc, IWN_GP_DRIVER, IWN_GP_DRIVER_6050_1X2); + if (sc->base_params->additional_gp_drv_bit) + IWN_SETBITS(sc, IWN_GP_DRIVER, + sc->base_params->additional_gp_drv_bit); return 0; } @@ -7192,7 +8441,7 @@ iwn_hw_init(struct iwn_softc *sc) IWN_WRITE(sc, IWN_UCODE_GP1_CLR, IWN_UCODE_GP1_RFKILL); /* Enable shadow registers. */ - if (sc->hw_type >= IWN_HW_REV_TYPE_6000) + if (sc->base_params->shadow_reg_enable) IWN_SETBITS(sc, IWN_SHADOW_REG_CTRL, 0x800fffff); if ((error = ops->load_firmware(sc)) != 0) { @@ -7305,6 +8554,44 @@ iwn_radio_off(void *arg0, int pending) } static void +iwn_panicked(void *arg0, int pending) +{ + struct iwn_softc *sc = arg0; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + int error; + + if (vap == NULL) { + printf("%s: null vap\n", __func__); + return; + } + + device_printf(sc->sc_dev, "%s: controller panicked, iv_state = %d; " + "resetting...\n", __func__, vap->iv_state); + + IWN_LOCK(sc); + + iwn_stop_locked(sc); + iwn_init_locked(sc); + if (vap->iv_state >= IEEE80211_S_AUTH && + (error = iwn_auth(sc, vap)) != 0) { + device_printf(sc->sc_dev, + "%s: could not move to auth state\n", __func__); + } + if (vap->iv_state >= IEEE80211_S_RUN && + (error = iwn_run(sc, vap)) != 0) { + device_printf(sc->sc_dev, + "%s: could not move to run state\n", __func__); + } + + /* Only run start once the NIC is in a useful state, like associated */ + iwn_start_locked(sc->sc_ifp); + + IWN_UNLOCK(sc); +} + +static void iwn_init_locked(struct iwn_softc *sc) { struct ifnet *ifp = sc->sc_ifp; @@ -7396,6 +8683,7 @@ iwn_stop_locked(struct iwn_softc *sc) IWN_LOCK_ASSERT(sc); + sc->sc_is_scanning = 0; sc->sc_tx_timer = 0; callout_stop(&sc->watchdog_to); callout_stop(&sc->calib_to); @@ -7486,10 +8774,11 @@ iwn_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) { struct ieee80211vap *vap = ss->ss_vap; struct iwn_softc *sc = vap->iv_ic->ic_ifp->if_softc; + struct ieee80211com *ic = vap->iv_ic; int error; IWN_LOCK(sc); - error = iwn_scan(sc); + error = iwn_scan(sc, vap, ss, ic->ic_curchan); IWN_UNLOCK(sc); if (error != 0) ieee80211_cancel_scan(vap); @@ -7521,7 +8810,6 @@ iwn_hw_reset(void *arg0, int pending) } #ifdef IWN_DEBUG #define IWN_DESC(x) case x: return #x -#define COUNTOF(array) (sizeof(array) / sizeof(array[0])) /* * Translate CSR code to string @@ -7592,7 +8880,7 @@ iwn_debug_register(struct iwn_softc *sc) DPRINTF(sc, IWN_DEBUG_REGISTER, "CSR values: (2nd byte of IWN_INT_COALESCING is IWN_INT_PERIODIC)%s", "\n"); - for (i = 0; i < COUNTOF(csr_tbl); i++){ + for (i = 0; i < nitems(csr_tbl); i++){ DPRINTF(sc, IWN_DEBUG_REGISTER," %10s: 0x%08x ", iwn_get_csr_string(csr_tbl[i]), IWN_READ(sc, csr_tbl[i])); if ((i+1) % 3 == 0) diff --git a/sys/dev/iwn/if_iwn_chip_cfg.h b/sys/dev/iwn/if_iwn_chip_cfg.h new file mode 100644 index 0000000..ea6f3e1 --- /dev/null +++ b/sys/dev/iwn/if_iwn_chip_cfg.h @@ -0,0 +1,413 @@ +/*- + * Copyright (c) 2013 Cedric GROSS <cg@cgross.info> + * Copyright (c) 2011 Intel Corporation + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $FreeBSD$ + */ + +#ifndef __IF_IWN_CHIP_CFG_H__ +#define __IF_IWN_CHIP_CFG_H__ + +/* ========================================================================== + * NIC PARAMETERS + * + * ========================================================================== + */ + +/* + * Flags for managing calibration result. See calib_need + * in iwn_base_params struct + * + * These are bitmasks that determine which indexes in the calibcmd + * array are pushed up. + */ +#define IWN_FLG_NEED_PHY_CALIB_DC (1<<0) +#define IWN_FLG_NEED_PHY_CALIB_LO (1<<1) +#define IWN_FLG_NEED_PHY_CALIB_TX_IQ (1<<2) +#define IWN_FLG_NEED_PHY_CALIB_TX_IQ_PERIODIC (1<<3) +#define IWN_FLG_NEED_PHY_CALIB_BASE_BAND (1<<4) +/* + * These aren't (yet) included in the calibcmd array, but + * are used as flags for which calibrations to use. + * + * XXX I think they should be named differently and + * stuffed in a different member in the config struct! + */ +#define IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET (1<<5) +#define IWN_FLG_NEED_PHY_CALIB_CRYSTAL (1<<6) +#define IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2 (1<<7) + +/* + * Each chip has a different threshold for PLCP errors that should trigger a + * retune. + */ +#define IWN_PLCP_ERR_DEFAULT_THRESHOLD 50 +#define IWN_PLCP_ERR_LONG_THRESHOLD 100 +#define IWN_PLCP_ERR_EXT_LONG_THRESHOLD 200 + +/* + * Define some parameters for managing different NIC. + * Refer to linux specific file like iwl-xxxx.c to determine correct value + * for NIC. + * + * @max_ll_items: max number of OTP blocks + * @shadow_ram_support: shadow support for OTP memory + * @shadow_reg_enable: HW shadhow register bit + * @no_idle_support: do not support idle mode + * @advanced_bt_coexist : Advanced BT management + * @bt_session_2 : NIC need a new struct for configure BT coexistence. Needed + * only if advanced_bt_coexist is true + * @bt_sco_disable : + * @additional_nic_config: For 6005 series + * @iq_invert : ? But need it for N 2000 series + * @regulatory_bands : XXX + * @enhanced_TX_power : EEPROM Has advanced TX power options. Set 'True' + * if update_enhanced_txpower = iwl_eeprom_enhanced_txpower. + * See iwl-agn-devices.c file to determine that(enhanced_txpower) + * @need_temp_offset_calib : Need to compute some temp offset for calibration. + * @calib_need : Use IWN_FLG_NEED_PHY_CALIB_* flags to specify which + * calibration data ucode need. See calib_init_cfg in iwl-xxxx.c + * linux kernel file + * @support_hostap: Define IEEE80211_C_HOSTAP for ic_caps + * @no_multi_vaps: See iwn_vap_create + * @additional_gp_drv_bit : Specific bit to defined during nic_config + * @bt_mode: BT configuration mode + */ +enum bt_mode_enum { + IWN_BT_NONE, + IWN_BT_SIMPLE, + IWN_BT_ADVANCED +}; + +struct iwn_base_params { + uint32_t pll_cfg_val; + const uint16_t max_ll_items; +#define IWN_OTP_MAX_LL_ITEMS_1000 (3) /* OTP blocks for 1000 */ +#define IWN_OTP_MAX_LL_ITEMS_6x00 (4) /* OTP blocks for 6x00 */ +#define IWN_OTP_MAX_LL_ITEMS_6x50 (7) /* OTP blocks for 6x50 */ +#define IWN_OTP_MAX_LL_ITEMS_2x00 (4) /* OTP blocks for 2x00 */ + const bool shadow_ram_support; + const bool shadow_reg_enable; + const bool bt_session_2; + const bool bt_sco_disable; + const bool additional_nic_config; + const uint32_t *regulatory_bands; + const bool enhanced_TX_power; + const uint16_t calib_need; + const bool support_hostap; + const bool no_multi_vaps; + uint8_t additional_gp_drv_bit; + enum bt_mode_enum bt_mode; + uint32_t plcp_err_threshold; +}; + +static const struct iwn_base_params iwn5000_base_params = { + .pll_cfg_val = IWN_ANA_PLL_INIT, /* pll_cfg_val; */ + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, /* max_ll_items */ + .shadow_ram_support = false, /* shadow_ram_support */ + .shadow_reg_enable = false, /* shadow_reg_enable */ + .bt_session_2 = false, /* bt_session_2 */ + .bt_sco_disable = true, /* bt_sco_disable */ + .additional_nic_config = false, /* additional_nic_config */ + .regulatory_bands = iwn5000_regulatory_bands, /* regulatory_bands */ + .enhanced_TX_power = false, /* enhanced_TX_power */ + .calib_need = + ( IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ_PERIODIC + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND ), + .support_hostap = false, /* support_hostap */ + .no_multi_vaps = true, /* no_multi_vaps */ + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, /* additional_gp_drv_bit */ + .bt_mode = IWN_BT_NONE, /* bt_mode */ + .plcp_err_threshold = IWN_PLCP_ERR_LONG_THRESHOLD, +}; + +/* + * 4965 support + */ +static const struct iwn_base_params iwn4965_base_params = { + .pll_cfg_val = 0, /* pll_cfg_val; */ + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, /* max_ll_items - ignored for 4965 */ + .shadow_ram_support = true, /* shadow_ram_support */ + .shadow_reg_enable = false, /* shadow_reg_enable */ + .bt_session_2 = false, /* bt_session_2 XXX unknown? */ + .bt_sco_disable = true, /* bt_sco_disable XXX unknown? */ + .additional_nic_config = false, /* additional_nic_config - not for 4965 */ + .regulatory_bands = iwn5000_regulatory_bands, /* regulatory_bands */ + .enhanced_TX_power = false, /* enhanced_TX_power - not for 4965 */ + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ_PERIODIC + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND ), + .support_hostap = false, /* support_hostap - XXX should work on fixing! */ + .no_multi_vaps = true, /* no_multi_vaps - XXX should work on fixing! */ + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, /* additional_gp_drv_bit */ + .bt_mode = IWN_BT_SIMPLE, /* bt_mode */ + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + + +static const struct iwn_base_params iwn2000_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_2x00, + .shadow_ram_support = true, + .shadow_reg_enable = false, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = false, + .regulatory_bands = iwn2030_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND + | IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2 ), + .support_hostap = true, + .no_multi_vaps = false, + .additional_gp_drv_bit = IWN_GP_DRIVER_REG_BIT_RADIO_IQ_INVERT, + .bt_mode = IWN_BT_NONE, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + +static const struct iwn_base_params iwn2030_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_2x00, + .shadow_ram_support = true, + .shadow_reg_enable = false, /* XXX check? */ + .bt_session_2 = true, + .bt_sco_disable = true, + .additional_nic_config = false, + .regulatory_bands = iwn2030_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND + | IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSETv2 ), + .support_hostap = true, + .no_multi_vaps = false, + .additional_gp_drv_bit = IWN_GP_DRIVER_REG_BIT_RADIO_IQ_INVERT, + .bt_mode = IWN_BT_ADVANCED, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + +static const struct iwn_base_params iwn1000_base_params = { + .pll_cfg_val = IWN_ANA_PLL_INIT, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_1000, + .shadow_ram_support = false, + .shadow_reg_enable = false, /* XXX check? */ + .bt_session_2 = false, + .bt_sco_disable = false, + .additional_nic_config = false, + .regulatory_bands = iwn5000_regulatory_bands, + .enhanced_TX_power = false, + .calib_need = + ( IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ_PERIODIC + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND + ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, + /* XXX 1000 - no BT */ + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_EXT_LONG_THRESHOLD, +}; +static const struct iwn_base_params iwn_6000_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = false, + .additional_nic_config = false, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; +static const struct iwn_base_params iwn_6000i_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = false, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; +static const struct iwn_base_params iwn_6000g2_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = false, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND + | IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = 0, + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + +static const struct iwn_base_params iwn_6050_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x50, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = true, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; +static const struct iwn_base_params iwn_6150_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x50, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = true, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_6050_1X2, + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + +/* IWL_DEVICE_6035 & IWL_DEVICE_6030 */ +static const struct iwn_base_params iwn_6000g2b_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = false, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND + | IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, + .bt_mode = IWN_BT_ADVANCED, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + +/* + * 6235 series NICs. + */ +static const struct iwn_base_params iwn_6235_base_params = { + .pll_cfg_val = 0, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, + .shadow_ram_support = true, + .shadow_reg_enable = true, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = true, + .regulatory_bands = iwn6000_regulatory_bands, + .enhanced_TX_power = true, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND + | IWN_FLG_NEED_PHY_CALIB_TEMP_OFFSET ), + .support_hostap = false, + .no_multi_vaps = true, + /* XXX 1x2? This NIC is 2x2, right? */ + .additional_gp_drv_bit = IWN_GP_DRIVER_6050_1X2, + .bt_mode = IWN_BT_ADVANCED, + .plcp_err_threshold = IWN_PLCP_ERR_DEFAULT_THRESHOLD, +}; + +static const struct iwn_base_params iwn_5x50_base_params = { + .pll_cfg_val = IWN_ANA_PLL_INIT, + .max_ll_items = IWN_OTP_MAX_LL_ITEMS_6x00, + .shadow_ram_support = true, + .shadow_reg_enable = false, + .bt_session_2 = false, + .bt_sco_disable = true, + .additional_nic_config = false, + .regulatory_bands = iwn5000_regulatory_bands, + .enhanced_TX_power =false, + .calib_need = + (IWN_FLG_NEED_PHY_CALIB_DC + | IWN_FLG_NEED_PHY_CALIB_LO + | IWN_FLG_NEED_PHY_CALIB_TX_IQ + | IWN_FLG_NEED_PHY_CALIB_BASE_BAND ), + .support_hostap = false, + .no_multi_vaps = true, + .additional_gp_drv_bit = IWN_GP_DRIVER_NONE, + .bt_mode = IWN_BT_SIMPLE, + .plcp_err_threshold = IWN_PLCP_ERR_LONG_THRESHOLD, +}; + +#endif /* __IF_IWN_CHIP_CFG_H__ */ diff --git a/sys/dev/iwn/if_iwn_debug.h b/sys/dev/iwn/if_iwn_debug.h new file mode 100644 index 0000000..2932c7e --- /dev/null +++ b/sys/dev/iwn/if_iwn_debug.h @@ -0,0 +1,123 @@ +/*- + * Copyright (c) 2013 Cedric GROSS <c.gross@kreiz-it.fr> + * Copyright (c) 2011 Intel Corporation + * Copyright (c) 2007-2009 + * Damien Bergamini <damien.bergamini@free.fr> + * Copyright (c) 2008 + * Benjamin Close <benjsc@FreeBSD.org> + * Copyright (c) 2008 Sam Leffler, Errno Consulting + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $FreeBSD$ + */ + +#ifndef __IF_IWN_DEBUG_H__ +#define __IF_IWN_DEBUG_H__ + +#ifdef IWN_DEBUG +enum { + IWN_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ + IWN_DEBUG_RECV = 0x00000002, /* basic recv operation */ + IWN_DEBUG_STATE = 0x00000004, /* 802.11 state transitions */ + IWN_DEBUG_TXPOW = 0x00000008, /* tx power processing */ + IWN_DEBUG_RESET = 0x00000010, /* reset processing */ + IWN_DEBUG_OPS = 0x00000020, /* iwn_ops processing */ + IWN_DEBUG_BEACON = 0x00000040, /* beacon handling */ + IWN_DEBUG_WATCHDOG = 0x00000080, /* watchdog timeout */ + IWN_DEBUG_INTR = 0x00000100, /* ISR */ + IWN_DEBUG_CALIBRATE = 0x00000200, /* periodic calibration */ + 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_SCAN = 0x00008000, /* Scan related operations */ + IWN_DEBUG_STATS = 0x00010000, /* Statistics updates */ + IWN_DEBUG_REGISTER = 0x20000000, /* print chipset register */ + IWN_DEBUG_TRACE = 0x40000000, /* Print begin and start driver function */ + IWN_DEBUG_FATAL = 0x80000000, /* fatal errors */ + IWN_DEBUG_ANY = 0xffffffff +}; + +#define DPRINTF(sc, m, fmt, ...) do { \ + if (sc->sc_debug & (m)) \ + printf(fmt, __VA_ARGS__); \ +} while (0) + +static const char * +iwn_intr_str(uint8_t cmd) +{ + switch (cmd) { + /* Notifications */ + case IWN_UC_READY: return "UC_READY"; + case IWN_ADD_NODE_DONE: return "ADD_NODE_DONE"; + case IWN_TX_DONE: return "TX_DONE"; + case IWN_START_SCAN: return "START_SCAN"; + case IWN_STOP_SCAN: return "STOP_SCAN"; + case IWN_RX_STATISTICS: return "RX_STATS"; + case IWN_BEACON_STATISTICS: return "BEACON_STATS"; + case IWN_STATE_CHANGED: return "STATE_CHANGED"; + case IWN_BEACON_MISSED: return "BEACON_MISSED"; + case IWN_RX_PHY: return "RX_PHY"; + case IWN_MPDU_RX_DONE: return "MPDU_RX_DONE"; + case IWN_RX_DONE: return "RX_DONE"; + + /* Command Notifications */ + case IWN_CMD_RXON: return "IWN_CMD_RXON"; + case IWN_CMD_RXON_ASSOC: return "IWN_CMD_RXON_ASSOC"; + case IWN_CMD_EDCA_PARAMS: return "IWN_CMD_EDCA_PARAMS"; + case IWN_CMD_TIMING: return "IWN_CMD_TIMING"; + case IWN_CMD_LINK_QUALITY: return "IWN_CMD_LINK_QUALITY"; + case IWN_CMD_SET_LED: return "IWN_CMD_SET_LED"; + case IWN5000_CMD_WIMAX_COEX: return "IWN5000_CMD_WIMAX_COEX"; + case IWN5000_CMD_CALIB_CONFIG: return "IWN5000_CMD_CALIB_CONFIG"; + case IWN5000_CMD_CALIB_RESULT: return "IWN5000_CMD_CALIB_RESULT"; + case IWN5000_CMD_CALIB_COMPLETE: return "IWN5000_CMD_CALIB_COMPLETE"; + case IWN_CMD_SET_POWER_MODE: return "IWN_CMD_SET_POWER_MODE"; + case IWN_CMD_SCAN: return "IWN_CMD_SCAN"; + case IWN_CMD_SCAN_RESULTS: return "IWN_CMD_SCAN_RESULTS"; + case IWN_CMD_TXPOWER: return "IWN_CMD_TXPOWER"; + case IWN_CMD_TXPOWER_DBM: return "IWN_CMD_TXPOWER_DBM"; + case IWN5000_CMD_TX_ANT_CONFIG: return "IWN5000_CMD_TX_ANT_CONFIG"; + case IWN_CMD_BT_COEX: return "IWN_CMD_BT_COEX"; + case IWN_CMD_SET_CRITICAL_TEMP: return "IWN_CMD_SET_CRITICAL_TEMP"; + case IWN_CMD_SET_SENSITIVITY: return "IWN_CMD_SET_SENSITIVITY"; + case IWN_CMD_PHY_CALIB: return "IWN_CMD_PHY_CALIB"; + + /* Bluetooth commands */ + case IWN_CMD_BT_COEX_PRIOTABLE: return "IWN_CMD_BT_COEX_PRIOTABLE"; + case IWN_CMD_BT_COEX_PROT: return "IWN_CMD_BT_COEX_PROT"; + case IWN_CMD_BT_COEX_NOTIF: return "IWN_CMD_BT_COEX_NOTIF"; + + /* PAN commands */ + case IWN_CMD_WIPAN_PARAMS: return "IWN_CMD_WIPAN_PARAMS"; + case IWN_CMD_WIPAN_RXON: return "IWN_CMD_WIPAN_RXON"; + case IWN_CMD_WIPAN_RXON_TIMING: return "IWN_CMD_WIPAN_RXON_TIMING"; + case IWN_CMD_WIPAN_RXON_ASSOC: return "IWN_CMD_WIPAN_RXON_ASSOC"; + case IWN_CMD_WIPAN_QOS_PARAM: return "IWN_CMD_WIPAN_QOS_PARAM"; + case IWN_CMD_WIPAN_WEPKEY: return "IWN_CMD_WIPAN_WEPKEY"; + case IWN_CMD_WIPAN_P2P_CHANNEL_SWITCH: + return "IWN_CMD_WIPAN_P2P_CHANNEL_SWITCH"; + case IWN_CMD_WIPAN_NOA_NOTIFICATION: + return "IWN_CMD_WIPAN_NOA_NOTIFICATION"; + case IWN_CMD_WIPAN_DEACTIVATION_COMPLETE: + return "IWN_CMD_WIPAN_DEACTIVATION_COMPLETE"; + } + return "UNKNOWN INTR NOTIF/CMD"; +} +#else +#define DPRINTF(sc, m, fmt, ...) do { (void) sc; } while (0) +#endif + +#endif /* __IF_IWN_DEBUG_H__ */ diff --git a/sys/dev/iwn/if_iwn_devid.h b/sys/dev/iwn/if_iwn_devid.h index 23fd0a1..dd08737 100644 --- a/sys/dev/iwn/if_iwn_devid.h +++ b/sys/dev/iwn/if_iwn_devid.h @@ -41,6 +41,20 @@ * DEVICE ID BLOCK * ========================================================================== */ + +/* + * -------------------------------------------------------------------------- + * Device ID for 2x00 series + * -------------------------------------------------------------------------- + */ +#define IWN_DID_2x00_1 0x0890 +#define IWN_DID_2x00_2 0x0891 +/* SubDevice ID */ +#define IWN_SDID_2x00_1 0x4022 +#define IWN_SDID_2x00_2 0x4222 +#define IWN_SDID_2x00_3 0x4422 +#define IWN_SDID_2x00_4 0x4822 + /* * -------------------------------------------------------------------------- * Device ID for 2x30 series @@ -214,6 +228,31 @@ /* * -------------------------------------------------------------------------- + * Device ID for 105 Series + * -------------------------------------------------------------------------- + */ +#define IWN_DID_105_1 0x0894 +#define IWN_DID_105_2 0x0895 +/* SubDevice ID */ +#define IWN_SDID_105_1 0x0022 +#define IWN_SDID_105_2 0x0222 +#define IWN_SDID_105_3 0x0422 +#define IWN_SDID_105_4 0x0822 + +/* + * -------------------------------------------------------------------------- + * Device ID for 135 Series + * -------------------------------------------------------------------------- + */ +#define IWN_DID_135_1 0x0892 +#define IWN_DID_135_2 0x0893 +/* SubDevice ID */ +#define IWN_SDID_135_1 0x0062 +#define IWN_SDID_135_2 0x0262 +#define IWN_SDID_135_3 0x0462 + +/* + * -------------------------------------------------------------------------- * Device ID for 5x00 Series * -------------------------------------------------------------------------- */ diff --git a/sys/dev/iwn/if_iwn_ioctl.h b/sys/dev/iwn/if_iwn_ioctl.h new file mode 100644 index 0000000..1acf464 --- /dev/null +++ b/sys/dev/iwn/if_iwn_ioctl.h @@ -0,0 +1,25 @@ +/*- + * Copyright (c) 2014 Adrian Chadd <adrian@FreeBSD.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $FreeBSD$ + */ +#ifndef __IF_IWN_IOCTL_H__ +#define __IF_IWN_IOCTL_H__ + +/* XXX how should I pick appropriate ioctl numbers? */ +#define SIOCGIWNSTATS _IOWR('i', 145, struct ifreq) +#define SIOCZIWNSTATS _IOWR('i', 146, struct ifreq) + +#endif /* __IF_IWN_IOCTL_H__ */ diff --git a/sys/dev/iwn/if_iwnreg.h b/sys/dev/iwn/if_iwnreg.h index e61d0fd..ed65c0b 100644 --- a/sys/dev/iwn/if_iwnreg.h +++ b/sys/dev/iwn/if_iwnreg.h @@ -17,6 +17,8 @@ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ +#ifndef __IF_IWNREG_H__ +#define __IF_IWNREG_H__ #define IWN_CT_KILL_THRESHOLD 114 /* in Celsius */ #define IWN_CT_KILL_EXIT_THRESHOLD 95 /* in Celsius */ @@ -222,6 +224,7 @@ #define IWN_GP_DRIVER_CALIB_VER6 (1 << 2) #define IWN_GP_DRIVER_6050_1X2 (1 << 3) #define IWN_GP_DRIVER_REG_BIT_RADIO_IQ_INVERT (1 << 7) +#define IWN_GP_DRIVER_NONE 0 /* Possible flags for register IWN_UCODE_GP1_CLR. */ #define IWN_UCODE_GP1_RFKILL (1 << 1) @@ -486,6 +489,7 @@ struct iwn_tx_cmd { #define IWN_CMD_TXPOWER_DBM 149 #define IWN_CMD_TXPOWER 151 #define IWN5000_CMD_TX_ANT_CONFIG 152 +#define IWN_CMD_TXPOWER_DBM_V1 152 #define IWN_CMD_BT_COEX 155 #define IWN_CMD_GET_STATISTICS 156 #define IWN_CMD_SET_CRITICAL_TEMP 164 @@ -882,7 +886,7 @@ struct iwn_scan_essid { struct iwn_scan_hdr { uint16_t len; - uint8_t reserved1; + uint8_t scan_flags; uint8_t nchan; uint16_t quiet_time; uint16_t quiet_threshold; @@ -919,17 +923,53 @@ struct iwn_scan_chan { /* Maximum size of a scan command. */ #define IWN_SCAN_MAXSZ (MCLBYTES - 4) -#define IWN_ACTIVE_DWELL_TIME_24 (30) /* all times in msec */ -#define IWN_ACTIVE_DWELL_TIME_52 (20) -#define IWN_ACTIVE_DWELL_FACTOR_24 (3) -#define IWN_ACTIVE_DWELL_FACTOR_52 (2) +/* + * For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after + * sending probe req. This should be set long enough to hear probe responses + * from more than one AP. + */ +#define IWN_ACTIVE_DWELL_TIME_2GHZ (30) /* all times in msec */ +#define IWN_ACTIVE_DWELL_TIME_5GHZ (20) +#define IWN_ACTIVE_DWELL_FACTOR_2GHZ (3) +#define IWN_ACTIVE_DWELL_FACTOR_5GHZ (2) -#define IWN_PASSIVE_DWELL_TIME_24 (20) /* all times in msec */ -#define IWN_PASSIVE_DWELL_TIME_52 (10) +/* + * For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel. + * Must be set longer than active dwell time. + * For the most reliable scan, set > AP beacon interval (typically 100msec). + */ +#define IWN_PASSIVE_DWELL_TIME_2GHZ (20) /* all times in msec */ +#define IWN_PASSIVE_DWELL_TIME_5GHZ (10) #define IWN_PASSIVE_DWELL_BASE (100) #define IWN_CHANNEL_TUNE_TIME (5) #define IWN_SCAN_CHAN_TIMEOUT 2 +#define IWN_MAX_SCAN_CHANNEL 50 + +/* + * If active scanning is requested but a certain channel is + * marked passive, we can do active scanning if we detect + * transmissions. + * + * There is an issue with some firmware versions that triggers + * a sysassert on a "good CRC threshold" of zero (== disabled), + * on a radar channel even though this means that we should NOT + * send probes. + * + * The "good CRC threshold" is the number of frames that we + * need to receive during our dwell time on a channel before + * sending out probes -- setting this to a huge value will + * mean we never reach it, but at the same time work around + * the aforementioned issue. Thus use IWL_GOOD_CRC_TH_NEVER + * here instead of IWL_GOOD_CRC_TH_DISABLED. + * + * This was fixed in later versions along with some other + * scan changes, and the threshold behaves as a flag in those + * versions. + */ +#define IWN_GOOD_CRC_TH_DISABLED 0 +#define IWN_GOOD_CRC_TH_DEFAULT htole16(1) +#define IWN_GOOD_CRC_TH_NEVER htole16(0xffff) /* Structure for command IWN_CMD_TXPOWER (4965AGN only.) */ #define IWN_RIDX_MAX 32 @@ -1102,6 +1142,12 @@ struct iwn_enhanced_sensitivity_cmd { uint16_t reserved; } __packed; +/* + * Define maximal number of calib result send to runtime firmware + * PS: TEMP_OFFSET count for 2 (std and v2) + */ +#define IWN5000_PHY_CALIB_MAX_RESULT 8 + /* Structures for command IWN_CMD_PHY_CALIB. */ struct iwn_phy_calib { uint8_t code; @@ -1221,17 +1267,91 @@ struct iwn_ucode_info { } __packed; /* Structures for IWN_TX_DONE notification. */ -#define IWN_TX_STATUS_MSK 0xff -#define TX_STATUS_SUCCESS 0x01 -#define TX_STATUS_DIRECT_DONE 0x02 - -#define IWN_TX_SUCCESS 0x00 -#define IWN_TX_FAIL 0x80 /* all failures have 0x80 set */ -#define IWN_TX_FAIL_SHORT_LIMIT 0x82 /* too many RTS retries */ -#define IWN_TX_FAIL_LONG_LIMIT 0x83 /* too many retries */ -#define IWN_TX_FAIL_FIFO_UNDERRRUN 0x84 /* tx fifo not kept running */ -#define IWN_TX_FAIL_DEST_IN_PS 0x88 /* sta found in power save */ -#define IWN_TX_FAIL_TX_LOCKED 0x90 /* waiting to see traffic */ + +/* + * TX command response is sent after *agn* transmission attempts. + * + * both postpone and abort status are expected behavior from uCode. there is + * no special operation required from driver; except for RFKILL_FLUSH, + * which required tx flush host command to flush all the tx frames in queues + */ +#define IWN_TX_STATUS_MSK 0x000000ff +#define IWN_TX_STATUS_DELAY_MSK 0x00000040 +#define IWN_TX_STATUS_ABORT_MSK 0x00000080 +#define IWN_TX_PACKET_MODE_MSK 0x0000ff00 +#define IWN_TX_FIFO_NUMBER_MSK 0x00070000 +#define IWN_TX_RESERVED 0x00780000 +#define IWN_TX_POWER_PA_DETECT_MSK 0x7f800000 +#define IWN_TX_ABORT_REQUIRED_MSK 0x80000000 + +/* Success status */ +#define IWN_TX_STATUS_SUCCESS 0x01 +#define IWN_TX_STATUS_DIRECT_DONE 0x02 + +/* postpone TX */ +#define IWN_TX_STATUS_POSTPONE_DELAY 0x40 +#define IWN_TX_STATUS_POSTPONE_FEW_BYTES 0x41 +#define IWN_TX_STATUS_POSTPONE_BT_PRIO 0x42 +#define IWN_TX_STATUS_POSTPONE_QUIET_PERIOD 0x43 +#define IWN_TX_STATUS_POSTPONE_CALC_TTAK 0x44 + +/* Failures */ +#define IWN_TX_FAIL 0x80 /* all failures have 0x80 set */ +#define IWN_TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY 0x81 +#define IWN_TX_FAIL_SHORT_LIMIT 0x82 /* too many RTS retries */ +#define IWN_TX_FAIL_LONG_LIMIT 0x83 /* too many retries */ +#define IWN_TX_FAIL_FIFO_UNDERRRUN 0x84 /* tx fifo not kept running */ +#define IWN_TX_STATUS_FAIL_DRAIN_FLOW 0x85 +#define IWN_TX_STATUS_FAIL_RFKILL_FLUSH 0x86 +#define IWN_TX_STATUS_FAIL_LIFE_EXPIRE 0x87 +#define IWN_TX_FAIL_DEST_IN_PS 0x88 /* sta found in power save */ +#define IWN_TX_STATUS_FAIL_HOST_ABORTED 0x89 +#define IWN_TX_STATUS_FAIL_BT_RETRY 0x8a +#define IWN_TX_FAIL_STA_INVALID 0x8b /* XXX STA invalid (???) */ +#define IWN_TX_STATUS_FAIL_FRAG_DROPPED 0x8c +#define IWN_TX_STATUS_FAIL_TID_DISABLE 0x8d +#define IWN_TX_STATUS_FAIL_FIFO_FLUSHED 0x8e +#define IWN_TX_STATUS_FAIL_INSUFFICIENT_CF_POLL 0x8f +#define IWN_TX_FAIL_TX_LOCKED 0x90 /* waiting to see traffic */ +#define IWN_TX_STATUS_FAIL_NO_BEACON_ON_RADAR 0x91 + +/* + * TX command response for A-MPDU packet responses. + * + * The status response is different to the non A-MPDU responses. + * In addition, the sequence number is treated as the sequence + * number of the TX command, NOT the 802.11 sequence number! + */ +#define IWN_AGG_TX_STATE_TRANSMITTED 0x00 +#define IWN_AGG_TX_STATE_UNDERRUN_MSK 0x01 +#define IWN_AGG_TX_STATE_FEW_BYTES_MSK 0x04 +#define IWN_AGG_TX_STATE_ABORT_MSK 0x08 + +#define IWN_AGG_TX_STATE_LAST_SENT_TTL_MSK 0x10 +#define IWN_AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK 0x20 + +#define IWN_AGG_TX_STATE_SCD_QUERY_MSK 0x80 + +#define IWN_AGG_TX_STATE_TEST_BAD_CRC32_MSK 0x100 + +#define IWN_AGG_TX_STATE_RESPONSE_MSK 0x1ff +#define IWN_AGG_TX_STATE_DUMP_TX_MSK 0x200 +#define IWN_AGG_TX_STATE_DELAY_TX_MSK 0x400 + +#define IWN_AGG_TX_STATUS_MSK 0x00000fff +#define IWN_AGG_TX_TRY_MSK 0x0000f000 + +#define IWN_AGG_TX_STATE_LAST_SENT_MSK \ + (IWN_AGG_TX_STATE_LAST_SENT_TTL_MSK | \ + IWN_AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK) + +/* # tx attempts for first frame in aggregation */ +#define IWN_AGG_TX_STATE_TRY_CNT_POS 12 +#define IWN_AGG_TX_STATE_TRY_CNT_MSK 0xf000 + +/* Command ID and sequence number of Tx command for this frame */ +#define IWN_AGG_TX_STATE_SEQ_NUM_POS 16 +#define IWN_AGG_TX_STATE_SEQ_NUM_MSK 0xffff0000 struct iwn4965_tx_stat { uint8_t nframes; @@ -1358,6 +1478,12 @@ struct iwn_compressed_ba { uint64_t bitmap; uint16_t qid; uint16_t ssn; + /* extra fields starting with iwn5000 */ +#if 0 + uint8_t txed; /* number of frames sent */ + uint8_t txed_2_done; /* number of frames acked */ + uint16_t reserved1; +#endif } __packed; /* Structure for IWN_START_SCAN notification. */ @@ -1463,7 +1589,7 @@ struct iwn_rx_ht_phy_stats { uint32_t good_ampdu_crc32; uint32_t ampdu; uint32_t fragment; - uint32_t reserved; + uint32_t unsupport_mcs; } __packed; struct iwn_rx_stats { @@ -1473,6 +1599,20 @@ struct iwn_rx_stats { struct iwn_rx_ht_phy_stats ht; } __packed; +struct iwn_rx_general_stats_bt { + struct iwn_rx_general_stats common; + /* additional stats for bt */ + uint32_t num_bt_kills; + uint32_t reserved[2]; +} __packed; + +struct iwn_rx_stats_bt { + struct iwn_rx_phy_stats ofdm; + struct iwn_rx_phy_stats cck; + struct iwn_rx_general_stats_bt general_bt; + struct iwn_rx_ht_phy_stats ht; +} __packed; + struct iwn_tx_stats { uint32_t preamble; uint32_t rx_detected; @@ -1484,7 +1624,7 @@ struct iwn_tx_stats { uint32_t exp_ack; uint32_t ack; uint32_t msdu; - uint32_t busrt_err1; + uint32_t burst_err1; uint32_t burst_err2; uint32_t cts_collision; uint32_t ack_collision; @@ -1498,15 +1638,21 @@ struct iwn_tx_stats { uint32_t underrun; uint32_t bt_ht_kill; uint32_t rx_ba_resp; - uint32_t reserved[2]; + /* + * 6000 series only - LSB=ant A, ant B, ant C, MSB=reserved + * TX power on chain in 1/2 dBm. + */ + uint32_t tx_power; + uint32_t reserved[1]; } __packed; struct iwn_general_stats { - uint32_t temp; - uint32_t temp_m; + uint32_t temp; /* radio temperature */ + uint32_t temp_m; /* radio voltage */ uint32_t burst_check; uint32_t burst; - uint32_t reserved1[4]; + uint32_t wait_for_silence_timeout_cnt; + uint32_t reserved1[3]; uint32_t sleep; uint32_t slot_out; uint32_t slot_idle; @@ -1517,7 +1663,11 @@ struct iwn_general_stats { uint32_t probe; uint32_t reserved2[2]; uint32_t rx_enabled; - uint32_t reserved3[3]; + /* + * This is the number of times we have to re-tune + * in order to get out of bad PHY status. + */ + uint32_t num_of_sos_states; } __packed; struct iwn_stats { @@ -1525,8 +1675,30 @@ struct iwn_stats { struct iwn_rx_stats rx; struct iwn_tx_stats tx; struct iwn_general_stats general; + uint32_t reserved1[2]; } __packed; +struct iwn_bt_activity_stats { + /* Tx statistics */ + uint32_t hi_priority_tx_req_cnt; + uint32_t hi_priority_tx_denied_cnt; + uint32_t lo_priority_tx_req_cnt; + uint32_t lo_priority_tx_denied_cnt; + /* Rx statistics */ + uint32_t hi_priority_rx_req_cnt; + uint32_t hi_priority_rx_denied_cnt; + uint32_t lo_priority_rx_req_cnt; + uint32_t lo_priority_rx_denied_cnt; +} __packed; + +struct iwn_stats_bt { + uint32_t flags; + struct iwn_rx_stats_bt rx_bt; + struct iwn_tx_stats tx; + struct iwn_general_stats general; + struct iwn_bt_activity_stats activity; + uint32_t reserved1[2]; +}; /* Firmware error dump. */ struct iwn_fw_dump { @@ -1564,7 +1736,7 @@ struct iwn_fw_tlv { #define IWN_FW_TLV_INIT_DATA 4 #define IWN_FW_TLV_BOOT_TEXT 5 #define IWN_FW_TLV_PBREQ_MAXLEN 6 -#define IWN_FW_TLV_PAN 7 +#define IWN_FW_TLV_PAN 7 #define IWN_FW_TLV_RUNT_EVTLOG_PTR 8 #define IWN_FW_TLV_RUNT_EVTLOG_SIZE 9 #define IWN_FW_TLV_RUNT_ERRLOG_PTR 10 @@ -1575,7 +1747,7 @@ struct iwn_fw_tlv { #define IWN_FW_TLV_PHY_CALIB 15 #define IWN_FW_TLV_WOWLAN_INST 16 #define IWN_FW_TLV_WOWLAN_DATA 17 -#define IWN_FW_TLV_FLAGS 18 +#define IWN_FW_TLV_FLAGS 18 uint16_t alt; uint32_t len; @@ -1590,6 +1762,60 @@ struct iwn_fw_tlv { #define IWN5000_FWSZ IWN5000_FW_TEXT_MAXSZ /* + * Microcode flags TLV (18.) + */ + +/** + * enum iwn_ucode_tlv_flag - ucode API flags + * @IWN_UCODE_TLV_FLAGS_PAN: This is PAN capable microcode; this previously + * was a separate TLV but moved here to save space. + * @IWN_UCODE_TLV_FLAGS_NEWSCAN: new uCode scan behaviour on hidden SSID, + * treats good CRC threshold as a boolean + * @IWN_UCODE_TLV_FLAGS_MFP: This uCode image supports MFP (802.11w). + * @IWN_UCODE_TLV_FLAGS_P2P: This uCode image supports P2P. + * @IWN_UCODE_TLV_FLAGS_DW_BC_TABLE: The SCD byte count table is in DWORDS + * @IWN_UCODE_TLV_FLAGS_UAPSD: This uCode image supports uAPSD + * @IWN_UCODE_TLV_FLAGS_SHORT_BL: 16 entries of black list instead of 64 in scan + * offload profile config command. + * @IWN_UCODE_TLV_FLAGS_RX_ENERGY_API: supports rx signal strength api + * @IWN_UCODE_TLV_FLAGS_TIME_EVENT_API_V2: using the new time event API. + * @IWN_UCODE_TLV_FLAGS_D3_6_IPV6_ADDRS: D3 image supports up to six + * (rather than two) IPv6 addresses + * @IWN_UCODE_TLV_FLAGS_BF_UPDATED: new beacon filtering API + * @IWN_UCODE_TLV_FLAGS_NO_BASIC_SSID: not sending a probe with the SSID element + * from the probe request template. + * @IWN_UCODE_TLV_FLAGS_D3_CONTINUITY_API: modified D3 API to allow keeping + * connection when going back to D0 + * @IWN_UCODE_TLV_FLAGS_NEW_NSOFFL_SMALL: new NS offload (small version) + * @IWN_UCODE_TLV_FLAGS_NEW_NSOFFL_LARGE: new NS offload (large version) + * @IWN_UCODE_TLV_FLAGS_SCHED_SCAN: this uCode image supports scheduled scan. + * @IWN_UCODE_TLV_FLAGS_STA_KEY_CMD: new ADD_STA and ADD_STA_KEY command API + * @IWN_UCODE_TLV_FLAGS_DEVICE_PS_CMD: support device wide power command + * containing CAM (Continuous Active Mode) indication. + */ +enum iwn_ucode_tlv_flag { + IWN_UCODE_TLV_FLAGS_PAN = (1 << 0), + IWN_UCODE_TLV_FLAGS_NEWSCAN = (1 << 1), + IWN_UCODE_TLV_FLAGS_MFP = (1 << 2), + IWN_UCODE_TLV_FLAGS_P2P = (1 << 3), + IWN_UCODE_TLV_FLAGS_DW_BC_TABLE = (1 << 4), + IWN_UCODE_TLV_FLAGS_NEWBT_COEX = (1 << 5), + IWN_UCODE_TLV_FLAGS_UAPSD = (1 << 6), + IWN_UCODE_TLV_FLAGS_SHORT_BL = (1 << 7), + IWN_UCODE_TLV_FLAGS_RX_ENERGY_API = (1 << 8), + IWN_UCODE_TLV_FLAGS_TIME_EVENT_API_V2 = (1 << 9), + IWN_UCODE_TLV_FLAGS_D3_6_IPV6_ADDRS = (1 << 10), + IWN_UCODE_TLV_FLAGS_BF_UPDATED = (1 << 11), + IWN_UCODE_TLV_FLAGS_NO_BASIC_SSID = (1 << 12), + IWN_UCODE_TLV_FLAGS_D3_CONTINUITY_API = (1 << 14), + IWN_UCODE_TLV_FLAGS_NEW_NSOFFL_SMALL = (1 << 15), + IWN_UCODE_TLV_FLAGS_NEW_NSOFFL_LARGE = (1 << 16), + IWN_UCODE_TLV_FLAGS_SCHED_SCAN = (1 << 17), + IWN_UCODE_TLV_FLAGS_STA_KEY_CMD = (1 << 19), + IWN_UCODE_TLV_FLAGS_DEVICE_PS_CMD = (1 << 20), +}; + +/* * Offsets into EEPROM. */ #define IWN_EEPROM_MAC 0x015 @@ -1731,6 +1957,16 @@ static const uint32_t iwn1000_regulatory_bands[IWN_NBANDS] = { IWN5000_EEPROM_NO_HT40, }; +static const uint32_t iwn2030_regulatory_bands[IWN_NBANDS] = { + IWN5000_EEPROM_BAND1, + IWN5000_EEPROM_BAND2, + IWN5000_EEPROM_BAND3, + IWN5000_EEPROM_BAND4, + IWN5000_EEPROM_BAND5, + IWN6000_EEPROM_BAND6, + IWN5000_EEPROM_BAND7 +}; + #define IWN_CHAN_BANDS_COUNT 7 #define IWN_MAX_CHAN_PER_BAND 14 static const struct iwn_chan_band { @@ -1757,8 +1993,8 @@ static const uint8_t iwn_bss_ac_to_queue[] = { static const uint8_t iwn_pan_ac_to_queue[] = { 5, 4, 6, 7, }; -#define IWN1000_OTP_NBLOCKS 3 -#define IWN6000_OTP_NBLOCKS 4 +#define IWN1000_OTP_NBLOCKS 3 +#define IWN6000_OTP_NBLOCKS 4 #define IWN6050_OTP_NBLOCKS 7 /* HW rate indices. */ @@ -1891,6 +2127,7 @@ struct iwn_sensitivity_limits { uint32_t min_energy_cck; uint32_t energy_cck; uint32_t energy_ofdm; + uint32_t barker_mrc; }; /* @@ -1905,7 +2142,8 @@ static const struct iwn_sensitivity_limits iwn4965_sensitivity_limits = { 200, 400, 97, 100, - 100 + 100, + 390 }; static const struct iwn_sensitivity_limits iwn5000_sensitivity_limits = { @@ -1917,7 +2155,8 @@ static const struct iwn_sensitivity_limits iwn5000_sensitivity_limits = { 170, 400, 95, 95, - 95 + 95, + 390 }; static const struct iwn_sensitivity_limits iwn5150_sensitivity_limits = { @@ -1929,7 +2168,8 @@ static const struct iwn_sensitivity_limits iwn5150_sensitivity_limits = { 170, 400, 95, 95, - 95 + 95, + 390, }; static const struct iwn_sensitivity_limits iwn1000_sensitivity_limits = { @@ -1941,7 +2181,8 @@ static const struct iwn_sensitivity_limits iwn1000_sensitivity_limits = { 170, 400, 95, 95, - 95 + 95, + 390, }; static const struct iwn_sensitivity_limits iwn6000_sensitivity_limits = { @@ -1953,9 +2194,24 @@ static const struct iwn_sensitivity_limits iwn6000_sensitivity_limits = { 160, 310, 97, 97, - 100 + 100, + 390 +}; + +static const struct iwn_sensitivity_limits iwn6235_sensitivity_limits = { + 105, 110, + 192, 232, + 80, 145, + 128, 232, + 125, 175, + 160, 310, + 100, + 110, + 110, + 336 }; + /* Get value from linux kernel 3.2.+ in Drivers/net/wireless/iwlwifi/iwl-2000.c*/ static const struct iwn_sensitivity_limits iwn2030_sensitivity_limits = { 105,110, @@ -2052,3 +2308,5 @@ static const char * const iwn_fw_errmsg[] = { #define IWN_BARRIER_READ_WRITE(sc) \ bus_space_barrier((sc)->sc_st, (sc)->sc_sh, 0, (sc)->sc_sz, \ BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE) + +#endif /* __IF_IWNREG_H__ */ diff --git a/sys/dev/iwn/if_iwnvar.h b/sys/dev/iwn/if_iwnvar.h index 11a233d..b14158b 100644 --- a/sys/dev/iwn/if_iwnvar.h +++ b/sys/dev/iwn/if_iwnvar.h @@ -163,6 +163,7 @@ struct iwn_calib_state { uint32_t bad_plcp_cck; uint32_t fa_cck; uint32_t low_fa; + uint32_t bad_plcp_ht; uint8_t cck_state; #define IWN_CCK_STATE_INIT 0 #define IWN_CCK_STATE_LOFA 1 @@ -249,6 +250,7 @@ struct iwn_softc { #define IWN_FLAG_ENH_SENS (1 << 7) #define IWN_FLAG_ADV_BTCOEX (1 << 8) #define IWN_FLAG_PAN_SUPPORT (1 << 9) +#define IWN_FLAG_BTCOEX (1 << 10) uint8_t hw_type; /* subdevice_id used to adjust configuration */ @@ -306,14 +308,20 @@ struct iwn_softc { struct task sc_reinit_task; struct task sc_radioon_task; struct task sc_radiooff_task; + struct task sc_panic_task; + /* Taskqueue */ + struct taskqueue *sc_tq; + + /* Calibration information */ struct callout calib_to; int calib_cnt; struct iwn_calib_state calib; + int last_calib_ticks; struct callout watchdog_to; struct callout ct_kill_exit_to; struct iwn_fw_info fw; - struct iwn_calib_info calibcmd[5]; + struct iwn_calib_info calibcmd[IWN5000_PHY_CALIB_MAX_RESULT]; uint32_t errptr; struct iwn_rx_stat last_rx_stat; @@ -324,6 +332,22 @@ struct iwn_softc { int ctx; struct ieee80211vap *ivap[IWN_NUM_RXON_CTX]; + /* General statistics */ + /* + * The statistics are reset after each channel + * change. So it may be zeroed after things like + * a background scan. + * + * So for now, this is just a cheap hack to + * expose the last received statistics dump + * via an ioctl(). Later versions of this + * could expose the last 'n' messages, or just + * provide a pipeline for the firmware responses + * via something like BPF. + */ + struct iwn_stats last_stat; + int last_stat_valid; + uint8_t uc_scan_progress; uint32_t rawtemp; int temp; @@ -358,6 +382,9 @@ struct iwn_softc { int sc_tx_timer; int sc_scan_timer; + /* Are we doing a scan? */ + int sc_is_scanning; + struct ieee80211_tx_ampdu *qid2tap[IWN5000_NTXQUEUES]; int (*sc_ampdu_rx_start)(struct ieee80211_node *, @@ -385,8 +412,11 @@ struct iwn_softc { */ int current_pwrsave_level; - /* For specifique params */ - struct iwn_base_params *base_params; + /* For specific params */ + const struct iwn_base_params *base_params; + +#define IWN_UCODE_API(ver) (((ver) & 0x0000FF00) >> 8) + uint32_t ucode_rev; }; #define IWN_LOCK_INIT(_sc) \ diff --git a/sys/dev/ixgbe/if_ix.c b/sys/dev/ixgbe/if_ix.c index 3c6caf7..e85c066 100644 --- a/sys/dev/ixgbe/if_ix.c +++ b/sys/dev/ixgbe/if_ix.c @@ -689,9 +689,7 @@ ixgbe_detach(device_t dev) for (int i = 0; i < adapter->num_queues; i++, que++, txr++) { if (que->tq) { -#ifndef IXGBE_LEGACY_TX taskqueue_drain(que->tq, &txr->txq_task); -#endif taskqueue_drain(que->tq, &que->que_task); taskqueue_free(que->tq); } @@ -1400,13 +1398,10 @@ ixgbe_handle_que(void *context, int pending) ixgbe_rxeof(que); IXGBE_TX_LOCK(txr); ixgbe_txeof(txr); -#ifndef IXGBE_LEGACY_TX if (!drbr_empty(ifp, txr->br)) ixgbe_mq_start_locked(ifp, txr); -#else if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) ixgbe_start_locked(txr, ifp); -#endif IXGBE_TX_UNLOCK(txr); } @@ -1449,13 +1444,10 @@ ixgbe_legacy_irq(void *arg) IXGBE_TX_LOCK(txr); ixgbe_txeof(txr); -#ifdef IXGBE_LEGACY_TX if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) ixgbe_start_locked(txr, ifp); -#else if (!drbr_empty(ifp, txr->br)) ixgbe_mq_start_locked(ifp, txr); -#endif IXGBE_TX_UNLOCK(txr); /* Check for fan failure */ @@ -1511,13 +1503,10 @@ ixgbe_msix_que(void *arg) IXGBE_TX_LOCK(txr); ixgbe_txeof(txr); -#ifdef IXGBE_LEGACY_TX - if (!IFQ_DRV_IS_EMPTY(ifp->if_snd)) + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) ixgbe_start_locked(txr, ifp); -#else if (!drbr_empty(ifp, txr->br)) ixgbe_mq_start_locked(ifp, txr); -#endif IXGBE_TX_UNLOCK(txr); /* Do AIM now? */ @@ -2272,9 +2261,7 @@ ixgbe_allocate_legacy(struct adapter *adapter) { device_t dev = adapter->dev; struct ix_queue *que = adapter->queues; -#ifndef IXGBE_LEGACY_TX struct tx_ring *txr = adapter->tx_rings; -#endif int error, rid = 0; /* MSI RID at 1 */ @@ -2294,9 +2281,7 @@ ixgbe_allocate_legacy(struct adapter *adapter) * Try allocating a fast interrupt and the associated deferred * processing contexts. */ -#ifndef IXGBE_LEGACY_TX TASK_INIT(&txr->txq_task, 0, ixgbe_deferred_mq_start, txr); -#endif TASK_INIT(&que->que_task, 0, ixgbe_handle_que, que); que->tq = taskqueue_create_fast("ixgbe_que", M_NOWAIT, taskqueue_thread_enqueue, &que->tq); @@ -2429,9 +2414,7 @@ ixgbe_allocate_msix(struct adapter *adapter) #endif /* IXGBE_DEBUG */ -#ifndef IXGBE_LEGACY_TX TASK_INIT(&txr->txq_task, 0, ixgbe_deferred_mq_start, txr); -#endif TASK_INIT(&que->que_task, 0, ixgbe_handle_que, que); que->tq = taskqueue_create_fast("ixgbe_que", M_NOWAIT, taskqueue_thread_enqueue, &que->tq); @@ -2709,15 +2692,15 @@ ixgbe_setup_interface(device_t dev, struct adapter *adapter) ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER; ifp->if_hw_tsomaxsegsize = 2048; #endif -#ifndef IXGBE_LEGACY_TX + ifp->if_transmit = ixgbe_mq_start; ifp->if_qflush = ixgbe_qflush; -#else + ifp->if_start = ixgbe_start; IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 2; IFQ_SET_READY(&ifp->if_snd); -#endif + ether_ifattach(ifp, adapter->hw.mac.addr); diff --git a/sys/dev/ixgbe/if_ixv.c b/sys/dev/ixgbe/if_ixv.c index 4ac8613..a3971cc 100644 --- a/sys/dev/ixgbe/if_ixv.c +++ b/sys/dev/ixgbe/if_ixv.c @@ -859,13 +859,10 @@ ixv_msix_que(void *arg) ** has anything queued the task gets ** scheduled to handle it. */ -#ifdef IXGBE_LEGACY_TX if (!IFQ_DRV_IS_EMPTY(&adapter->ifp->if_snd)) ixgbe_start_locked(txr, ifp); -#else if (!drbr_empty(adapter->ifp, txr->br)) ixgbe_mq_start_locked(ifp, txr); -#endif IXGBE_TX_UNLOCK(txr); /* Do AIM now? */ diff --git a/sys/dev/ixgbe/ix_txrx.c b/sys/dev/ixgbe/ix_txrx.c index f70b89e..068048f 100644 --- a/sys/dev/ixgbe/ix_txrx.c +++ b/sys/dev/ixgbe/ix_txrx.c @@ -123,7 +123,6 @@ static __inline void ixgbe_rx_discard(struct rx_ring *, int); static __inline void ixgbe_rx_input(struct rx_ring *, struct ifnet *, struct mbuf *, u32); -#ifdef IXGBE_LEGACY_TX /********************************************************************* * Transmit entry point * @@ -185,7 +184,6 @@ ixgbe_start(struct ifnet *ifp) return; } -#else /* ! IXGBE_LEGACY_TX */ /* ** Multiqueue Transmit driver @@ -333,7 +331,6 @@ ixgbe_qflush(struct ifnet *ifp) } if_qflush(ifp); } -#endif /* IXGBE_LEGACY_TX */ /********************************************************************* @@ -713,10 +710,8 @@ ixgbe_free_transmit_buffers(struct tx_ring *txr) tx_buffer->map = NULL; } } -#ifdef IXGBE_LEGACY_TX if (txr->br != NULL) buf_ring_free(txr->br, M_DEVBUF); -#endif if (txr->tx_buffers != NULL) { free(txr->tx_buffers, M_DEVBUF); txr->tx_buffers = NULL; @@ -2184,7 +2179,6 @@ ixgbe_allocate_queues(struct adapter *adapter) error = ENOMEM; goto err_tx_desc; } -#ifndef IXGBE_LEGACY_TX /* Allocate a buf ring */ txr->br = buf_ring_alloc(IXGBE_BR_SIZE, M_DEVBUF, M_WAITOK, &txr->tx_mtx); @@ -2194,7 +2188,6 @@ ixgbe_allocate_queues(struct adapter *adapter) error = ENOMEM; goto err_tx_desc; } -#endif } /* diff --git a/sys/dev/ixgbe/ixgbe.h b/sys/dev/ixgbe/ixgbe.h index be27e36..f7721f6 100644 --- a/sys/dev/ixgbe/ixgbe.h +++ b/sys/dev/ixgbe/ixgbe.h @@ -717,15 +717,12 @@ ixv_check_ether_addr(u8 *addr) /* Shared Prototypes */ -#ifdef IXGBE_LEGACY_TX void ixgbe_start(struct ifnet *); void ixgbe_start_locked(struct tx_ring *, struct ifnet *); -#else /* ! IXGBE_LEGACY_TX */ int ixgbe_mq_start(struct ifnet *, struct mbuf *); int ixgbe_mq_start_locked(struct ifnet *, struct tx_ring *); void ixgbe_qflush(struct ifnet *); void ixgbe_deferred_mq_start(void *, int); -#endif /* IXGBE_LEGACY_TX */ int ixgbe_allocate_queues(struct adapter *); int ixgbe_allocate_transmit_buffers(struct tx_ring *); diff --git a/sys/dev/oce/oce_if.c b/sys/dev/oce/oce_if.c index f37ef3a..3711503 100644 --- a/sys/dev/oce/oce_if.c +++ b/sys/dev/oce/oce_if.c @@ -1060,11 +1060,10 @@ oce_tx_restart(POCE_SOFTC sc, struct oce_wq *wq) if ((sc->ifp->if_drv_flags & IFF_DRV_RUNNING) != IFF_DRV_RUNNING) return; -#if __FreeBSD_version >= 800000 if (!drbr_empty(sc->ifp, wq->br)) -#else + taskqueue_enqueue_fast(taskqueue_swi, &wq->txtask); + if (!IFQ_DRV_IS_EMPTY(&sc->ifp->if_snd)) -#endif taskqueue_enqueue_fast(taskqueue_swi, &wq->txtask); } @@ -1147,7 +1146,7 @@ oce_tx_task(void *arg, int npending) struct ifnet *ifp = sc->ifp; int rc = 0; -#if __FreeBSD_version >= 800000 + LOCK(&wq->tx_lock); rc = oce_multiq_transmit(ifp, NULL, wq); if (rc) { @@ -1155,9 +1154,9 @@ oce_tx_task(void *arg, int npending) "TX[%d] restart failed\n", wq->queue_index); } UNLOCK(&wq->tx_lock); -#else + oce_start(ifp); -#endif + } diff --git a/sys/dev/ral/rt2560.c b/sys/dev/ral/rt2560.c index 1bda391..02c9310 100644 --- a/sys/dev/ral/rt2560.c +++ b/sys/dev/ral/rt2560.c @@ -45,6 +45,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -958,7 +959,7 @@ rt2560_tx_intr(struct rt2560_softc *sc) ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_SUCCESS, &retrycnt, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); break; case RT2560_TX_SUCCESS_RETRY: @@ -970,7 +971,7 @@ rt2560_tx_intr(struct rt2560_softc *sc) ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_SUCCESS, &retrycnt, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); break; case RT2560_TX_FAIL_RETRY: @@ -982,7 +983,7 @@ rt2560_tx_intr(struct rt2560_softc *sc) ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_FAILURE, &retrycnt, NULL); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; case RT2560_TX_FAIL_INVALID: @@ -990,7 +991,7 @@ rt2560_tx_intr(struct rt2560_softc *sc) default: device_printf(sc->sc_dev, "sending data frame failed " "0x%08x\n", flags); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } bus_dmamap_sync(sc->txq.data_dmat, data->map, @@ -1143,13 +1144,13 @@ rt2560_decryption_intr(struct rt2560_softc *sc) break; if (data->drop) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } if ((le32toh(desc->flags) & RT2560_RX_CIPHER_MASK) != 0 && (le32toh(desc->flags) & RT2560_RX_ICV_ERROR)) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1162,7 +1163,7 @@ rt2560_decryption_intr(struct rt2560_softc *sc) */ mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (mnew == NULL) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1185,7 +1186,7 @@ rt2560_decryption_intr(struct rt2560_softc *sc) panic("%s: could not load old rx mbuf", device_get_name(sc->sc_dev)); } - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1935,7 +1936,7 @@ rt2560_start_locked(struct ifnet *ifp) ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; if (rt2560_tx_data(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; } @@ -1972,7 +1973,7 @@ rt2560_watchdog(void *arg) if (sc->sc_tx_timer > 0 && --sc->sc_tx_timer == 0) { if_printf(ifp, "device timeout\n"); rt2560_init_locked(sc); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); /* NB: callout is reset in rt2560_init() */ return; } @@ -2795,7 +2796,7 @@ rt2560_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return ENOBUFS; /* XXX */ } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if (params == NULL) { /* @@ -2818,7 +2819,7 @@ rt2560_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return 0; bad: - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ieee80211_free_node(ni); RAL_UNLOCK(sc); return EIO; /* XXX */ diff --git a/sys/dev/ral/rt2661.c b/sys/dev/ral/rt2661.c index a0fb158..448ba57 100644 --- a/sys/dev/ral/rt2661.c +++ b/sys/dev/ral/rt2661.c @@ -46,6 +46,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -908,7 +909,7 @@ rt2661_tx_intr(struct rt2661_softc *sc) ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_SUCCESS, &retrycnt, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); break; case RT2661_TX_RETRY_FAIL: @@ -920,14 +921,14 @@ rt2661_tx_intr(struct rt2661_softc *sc) ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_FAILURE, &retrycnt, NULL); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; default: /* other failure */ device_printf(sc->sc_dev, "sending data frame failed 0x%08x\n", val); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } DPRINTFN(sc, 15, "tx done q=%d idx=%u\n", qid, txq->stat); @@ -1014,12 +1015,12 @@ rt2661_rx_intr(struct rt2661_softc *sc) */ DPRINTFN(sc, 5, "PHY or CRC error flags 0x%08x\n", le32toh(desc->flags)); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } if ((le32toh(desc->flags) & RT2661_RX_CIPHER_MASK) != 0) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1032,7 +1033,7 @@ rt2661_rx_intr(struct rt2661_softc *sc) */ mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (mnew == NULL) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1055,7 +1056,7 @@ rt2661_rx_intr(struct rt2661_softc *sc) panic("%s: could not load old rx mbuf", device_get_name(sc->sc_dev)); } - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1630,7 +1631,7 @@ rt2661_start_locked(struct ifnet *ifp) ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; if (rt2661_tx_data(sc, m, ni, ac) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; } @@ -1673,7 +1674,7 @@ rt2661_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return ENOBUFS; /* XXX */ } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); /* * Legacy path; interpret frame contents to decide @@ -1688,7 +1689,7 @@ rt2661_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return 0; bad: - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ieee80211_free_node(ni); RAL_UNLOCK(sc); return EIO; /* XXX */ @@ -1710,7 +1711,7 @@ rt2661_watchdog(void *arg) if (sc->sc_tx_timer > 0 && --sc->sc_tx_timer == 0) { if_printf(ifp, "device timeout\n"); rt2661_init_locked(sc); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); /* NB: callout is reset in rt2661_init() */ return; } diff --git a/sys/dev/ral/rt2860.c b/sys/dev/ral/rt2860.c index 3eb7187..b29a0eb 100644 --- a/sys/dev/ral/rt2860.c +++ b/sys/dev/ral/rt2860.c @@ -46,6 +46,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -1134,7 +1135,7 @@ rt2860_drain_stats_fifo(struct rt2860_softc *sc) } else { ieee80211_ratectl_tx_complete(ni->ni_vap, ni, IEEE80211_RATECTL_TX_FAILURE, &retrycnt, NULL); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } } } @@ -1168,7 +1169,7 @@ rt2860_tx_intr(struct rt2860_softc *sc, int qid) SLIST_INSERT_HEAD(&sc->data_pool, data, next); ring->data[ring->next] = NULL; - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); } ring->queued--; ring->next = (ring->next + 1) % RT2860_TX_RING_COUNT; @@ -1231,7 +1232,7 @@ rt2860_rx_intr(struct rt2860_softc *sc) if (__predict_false(rxd->flags & htole32(RT2860_RX_CRCERR | RT2860_RX_ICVERR))) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1240,14 +1241,14 @@ rt2860_rx_intr(struct rt2860_softc *sc) /* report MIC failures to net80211 for TKIP */ ic->ic_stats.is_rx_locmicfail++; ieee80211_michael_mic_failure(ic, 0/* XXX */); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } #endif m1 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (__predict_false(m1 == NULL)) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1271,7 +1272,7 @@ rt2860_rx_intr(struct rt2860_softc *sc) } /* physical address may have changed */ rxd->sdp0 = htole32(physaddr); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto skip; } @@ -1751,7 +1752,7 @@ rt2860_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, if (error != 0) { /* NB: m is reclaimed on tx failure */ ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } sc->sc_tx_timer = 5; RAL_UNLOCK(sc); @@ -2004,7 +2005,7 @@ rt2860_start_locked(struct ifnet *ifp) ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; if (rt2860_tx(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); continue; } sc->sc_tx_timer = 5; @@ -2028,7 +2029,7 @@ rt2860_watchdog(void *arg) if_printf(ifp, "device timeout\n"); rt2860_stop_locked(sc); rt2860_init_locked(sc); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return; } callout_reset(&sc->watchdog_ch, hz, rt2860_watchdog, sc); diff --git a/sys/dev/random/hash.c b/sys/dev/random/hash.c index cf0feaa..e37f090 100644 --- a/sys/dev/random/hash.c +++ b/sys/dev/random/hash.c @@ -45,7 +45,7 @@ randomdev_hash_init(struct randomdev_hash *context) /* Iterate the hash */ void -randomdev_hash_iterate(struct randomdev_hash *context, void *data, size_t size) +randomdev_hash_iterate(struct randomdev_hash *context, const void *data, size_t size) { SHA256_Update(&context->sha, data, size); } @@ -64,7 +64,7 @@ randomdev_hash_finish(struct randomdev_hash *context, void *buf) * data. Use CBC mode for better avalanche. */ void -randomdev_encrypt_init(struct randomdev_key *context, void *data) +randomdev_encrypt_init(struct randomdev_key *context, const void *data) { rijndael_cipherInit(&context->cipher, MODE_CBC, NULL); rijndael_makeKey(&context->key, DIR_ENCRYPT, KEYSIZE*8, data); @@ -75,7 +75,7 @@ randomdev_encrypt_init(struct randomdev_key *context, void *data) * a multiple of BLOCKSIZE. */ void -randomdev_encrypt(struct randomdev_key *context, void *d_in, void *d_out, unsigned length) +randomdev_encrypt(struct randomdev_key *context, const void *d_in, void *d_out, unsigned length) { rijndael_blockEncrypt(&context->cipher, &context->key, d_in, length*8, d_out); } diff --git a/sys/dev/random/hash.h b/sys/dev/random/hash.h index 4e6a4a0..8655d88 100644 --- a/sys/dev/random/hash.h +++ b/sys/dev/random/hash.h @@ -42,9 +42,9 @@ struct randomdev_key { /* Big! Make static! */ }; void randomdev_hash_init(struct randomdev_hash *); -void randomdev_hash_iterate(struct randomdev_hash *, void *, size_t); +void randomdev_hash_iterate(struct randomdev_hash *, const void *, size_t); void randomdev_hash_finish(struct randomdev_hash *, void *); -void randomdev_encrypt_init(struct randomdev_key *, void *); -void randomdev_encrypt(struct randomdev_key *context, void *, void *, unsigned); +void randomdev_encrypt_init(struct randomdev_key *, const void *); +void randomdev_encrypt(struct randomdev_key *context, const void *, void *, unsigned); #endif diff --git a/sys/dev/usb/wlan/if_rsu.c b/sys/dev/usb/wlan/if_rsu.c index 4ad6ab5..a6b5ebd 100644 --- a/sys/dev/usb/wlan/if_rsu.c +++ b/sys/dev/usb/wlan/if_rsu.c @@ -44,6 +44,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/if_dl.h> #include <net/if_media.h> @@ -71,7 +72,7 @@ __FBSDID("$FreeBSD$"); #ifdef USB_DEBUG static int rsu_debug = 0; SYSCTL_NODE(_hw_usb, OID_AUTO, rsu, CTLFLAG_RW, 0, "USB rsu"); -SYSCTL_INT(_hw_usb_rsu, OID_AUTO, debug, CTLFLAG_RW, &rsu_debug, 0, +SYSCTL_INT(_hw_usb_rsu, OID_AUTO, debug, CTLFLAG_RWTUN, &rsu_debug, 0, "Debug level"); #endif @@ -120,6 +121,7 @@ static const STRUCT_USB_HOST_ID rsu_devs[] = { RSU_DEV_HT(SITECOMEU, WL349V1), RSU_DEV_HT(SITECOMEU, WL353), RSU_DEV_HT(SWEEX2, LW154), + //RSU_DEV_HT(TRENDNET, TEW646UBH), #undef RSU_DEV_HT #undef RSU_DEV }; @@ -1153,16 +1155,9 @@ rsu_event_survey(struct rsu_softc *sc, uint8_t *buf, int len) pktlen = sizeof(*wh) + le32toh(bss->ieslen); if (__predict_false(pktlen > MCLBYTES)) return; - MGETHDR(m, M_NOWAIT, MT_DATA); + m = m_get2(pktlen, M_NOWAIT, MT_DATA, M_PKTHDR); if (__predict_false(m == NULL)) return; - if (pktlen > MHLEN) { - MCLGET(m, M_NOWAIT); - if (!(m->m_flags & M_EXT)) { - m_free(m); - return; - } - } wh = mtod(m, struct ieee80211_frame *); wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_BEACON; @@ -1358,11 +1353,11 @@ rsu_rx_frame(struct rsu_softc *sc, uint8_t *buf, int pktlen, int *rssi) rxdw3 = le32toh(stat->rxdw3); if (__predict_false(rxdw0 & R92S_RXDW0_CRCERR)) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return NULL; } if (__predict_false(pktlen < sizeof(*wh) || pktlen > MCLBYTES)) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return NULL; } @@ -1378,19 +1373,11 @@ rsu_rx_frame(struct rsu_softc *sc, uint8_t *buf, int pktlen, int *rssi) DPRINTFN(5, "Rx frame len=%d rate=%d infosz=%d rssi=%d\n", pktlen, rate, infosz, *rssi); - MGETHDR(m, M_NOWAIT, MT_DATA); + m = m_get2(pktlen, M_NOWAIT, MT_DATA, M_PKTHDR); if (__predict_false(m == NULL)) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return NULL; } - if (pktlen > MHLEN) { - MCLGET(m, M_NOWAIT); - if (__predict_false(!(m->m_flags & M_EXT))) { - ifp->if_ierrors++; - m_freem(m); - return NULL; - } - } /* Finalize mbuf. */ m->m_pkthdr.rcvif = ifp; /* Hardware does Rx TCP checksum offload. */ @@ -1497,7 +1484,7 @@ rsu_rxeof(struct usb_xfer *xfer, struct rsu_data *data, int *rssi) if (__predict_false(len < sizeof(*stat))) { DPRINTF("xfer too short %d\n", len); - sc->sc_ifp->if_ierrors++; + if_inc_counter(sc->sc_ifp, IFCOUNTER_IERRORS, 1); return (NULL); } /* Determine if it is a firmware C2H event or an 802.11 frame. */ @@ -1575,7 +1562,7 @@ tr_setup: } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } break; @@ -1610,7 +1597,7 @@ rsu_txeof(struct usb_xfer *xfer, struct rsu_data *data) ieee80211_free_node(data->ni); data->ni = NULL; } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; } @@ -1654,7 +1641,7 @@ tr_setup: rsu_txeof(xfer, data); STAILQ_INSERT_TAIL(&sc->sc_tx_inactive, data, next); } - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); @@ -1815,11 +1802,11 @@ rsu_start_locked(struct ifnet *ifp) bf = rsu_getbuf(sc); if (bf == NULL) { - ifp->if_iqdrops++; + if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); m_freem(m); ieee80211_free_node(ni); } else if (rsu_tx_start(sc, ni, m, bf) != 0) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); ieee80211_free_node(ni); } @@ -2325,10 +2312,10 @@ rsu_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, RSU_UNLOCK(sc); return (ENOBUFS); } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if (rsu_tx_start(sc, ni, m, bf) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); RSU_UNLOCK(sc); return (EIO); diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c index e1e8f2e..a3dc562 100644 --- a/sys/dev/usb/wlan/if_rum.c +++ b/sys/dev/usb/wlan/if_rum.c @@ -47,6 +47,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -81,7 +82,7 @@ __FBSDID("$FreeBSD$"); static int rum_debug = 0; static SYSCTL_NODE(_hw_usb, OID_AUTO, rum, CTLFLAG_RW, 0, "USB rum"); -SYSCTL_INT(_hw_usb_rum, OID_AUTO, debug, CTLFLAG_RW, &rum_debug, 0, +SYSCTL_INT(_hw_usb_rum, OID_AUTO, debug, CTLFLAG_RWTUN, &rum_debug, 0, "Debug level"); #endif @@ -796,7 +797,7 @@ rum_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) rum_tx_free(data, 0); usbd_xfer_set_priv(xfer, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* FALLTHROUGH */ @@ -850,7 +851,7 @@ tr_setup: DPRINTFN(11, "transfer error, %s\n", usbd_errstr(error)); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); data = usbd_xfer_get_priv(xfer); if (data != NULL) { rum_tx_free(data, error); @@ -896,7 +897,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) if (len < (int)(RT2573_RX_DESC_SIZE + IEEE80211_MIN_LEN)) { DPRINTF("%s: xfer too short %d\n", device_get_nameunit(sc->sc_dev), len); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } @@ -913,14 +914,14 @@ rum_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) * filled RUM_TXRX_CSR2: */ DPRINTFN(5, "PHY or CRC error\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (m == NULL) { DPRINTF("could not allocate mbuf\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } usbd_copy_out(pc, RT2573_RX_DESC_SIZE, @@ -1320,7 +1321,7 @@ rum_start(struct ifnet *ifp) ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; if (rum_tx_data(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; } } @@ -2204,7 +2205,7 @@ rum_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return EIO; } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if (params == NULL) { /* @@ -2225,7 +2226,7 @@ rum_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return 0; bad: - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); RUM_UNLOCK(sc); ieee80211_free_node(ni); return EIO; @@ -2280,7 +2281,7 @@ rum_ratectl_task(void *arg, int pending) (void) ieee80211_ratectl_rate(ni, NULL, 0); ieee80211_free_node(ni); - ifp->if_oerrors += fail; /* count TX retry-fail as Tx errors */ + if_inc_counter(ifp, IFCOUNTER_OERRORS, fail); /* count TX retry-fail as Tx errors */ usb_callout_reset(&rvp->ratectl_ch, hz, rum_ratectl_timeout, rvp); RUM_UNLOCK(sc); diff --git a/sys/dev/usb/wlan/if_run.c b/sys/dev/usb/wlan/if_run.c index 212408f..eeb46d3 100644 --- a/sys/dev/usb/wlan/if_run.c +++ b/sys/dev/usb/wlan/if_run.c @@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -83,7 +84,7 @@ __FBSDID("$FreeBSD$"); #ifdef RUN_DEBUG int run_debug = 0; static SYSCTL_NODE(_hw_usb, OID_AUTO, run, CTLFLAG_RW, 0, "USB run"); -SYSCTL_INT(_hw_usb_run, OID_AUTO, debug, CTLFLAG_RW, &run_debug, 0, +SYSCTL_INT(_hw_usb_run, OID_AUTO, debug, CTLFLAG_RWTUN, &run_debug, 0, "run debug level"); #endif @@ -2575,7 +2576,7 @@ run_drain_fifo(void *arg) if (stat & RT2860_TXQ_OK) (*wstat)[RUN_SUCCESS]++; else - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); /* * Check if there were retries, ie if the Tx success rate is * different from the requested rate. Note that it works only @@ -2621,7 +2622,7 @@ run_iter_func(void *arg, struct ieee80211_node *ni) goto fail; /* count failed TX as errors */ - ifp->if_oerrors += le16toh(sta[0].error.fail); + if_inc_counter(ifp, IFCOUNTER_OERRORS, le16toh(sta[0].error.fail)); retrycnt = le16toh(sta[1].tx.retry); success = le16toh(sta[1].tx.success); @@ -2787,7 +2788,7 @@ run_rx_frame(struct run_softc *sc, struct mbuf *m, uint32_t dmalen) rxwisize += sizeof(uint32_t); if (__predict_false(len > dmalen)) { m_freem(m); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF("bad RXWI length %u > %u\n", len, dmalen); return; } @@ -2797,7 +2798,7 @@ run_rx_frame(struct run_softc *sc, struct mbuf *m, uint32_t dmalen) if (__predict_false(flags & (RT2860_RX_CRCERR | RT2860_RX_ICVERR))) { m_freem(m); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF("%s error.\n", (flags & RT2860_RX_CRCERR)?"CRC":"ICV"); return; } @@ -2826,7 +2827,7 @@ run_rx_frame(struct run_softc *sc, struct mbuf *m, uint32_t dmalen) ieee80211_notify_michael_failure(ni->ni_vap, wh, rxwi->keyidx); m_freem(m); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF("MIC error. Someone is lying.\n"); return; } @@ -2926,7 +2927,7 @@ tr_setup: } if (sc->rx_m == NULL) { DPRINTF("could not allocate mbuf - idle with stall\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); usbd_xfer_set_stall(xfer); usbd_xfer_set_frames(xfer, 0); } else { @@ -2950,7 +2951,7 @@ tr_setup: if (error == USB_ERR_TIMEOUT) device_printf(sc->sc_dev, "device timeout\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } @@ -2999,7 +3000,7 @@ tr_setup: m0 = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (__predict_false(m0 == NULL)) { DPRINTF("could not allocate mbuf\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); break; } m_copydata(m, 4 /* skip 32-bit DMA-len header */, @@ -3071,7 +3072,7 @@ run_bulk_tx_callbackN(struct usb_xfer *xfer, usb_error_t error, u_int index) usbd_xfer_set_priv(xfer, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); /* FALLTHROUGH */ case USB_ST_SETUP: @@ -3090,7 +3091,7 @@ tr_setup: DPRINTF("data overflow, %u bytes\n", m->m_pkthdr.len); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); run_tx_free(pq, data, 1); @@ -3145,7 +3146,7 @@ tr_setup: data = usbd_xfer_get_priv(xfer); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); if (data != NULL) { if(data->ni != NULL) @@ -3568,7 +3569,7 @@ run_sendprot(struct run_softc *sc, mprot = ieee80211_alloc_cts(ic, ni->ni_vap->iv_myaddr, dur); } if (mprot == NULL) { - sc->sc_ifp->if_oerrors++; + if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1); DPRINTF("could not allocate mbuf\n"); return (ENOBUFS); } @@ -3704,20 +3705,20 @@ run_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, if (params == NULL) { /* tx mgt packet */ if ((error = run_tx_mgt(sc, m, ni)) != 0) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); DPRINTF("mgt tx failed\n"); goto done; } } else { /* tx raw packet with param */ if ((error = run_tx_param(sc, m, ni, params)) != 0) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); DPRINTF("tx with param failed\n"); goto done; } } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); done: RUN_UNLOCK(sc); diff --git a/sys/dev/usb/wlan/if_runreg.h b/sys/dev/usb/wlan/if_runreg.h index 3ca01cd..aa54a72 100644 --- a/sys/dev/usb/wlan/if_runreg.h +++ b/sys/dev/usb/wlan/if_runreg.h @@ -962,31 +962,6 @@ struct rt2860_rxwi { #define RT2860_RIDX_MAX 12 /* - * Control and status registers access macros. - */ -#define RAL_READ(sc, reg) \ - bus_space_read_4((sc)->sc_st, (sc)->sc_sh, (reg)) - -#define RAL_WRITE(sc, reg, val) \ - bus_space_write_4((sc)->sc_st, (sc)->sc_sh, (reg), (val)) - -#define RAL_BARRIER_WRITE(sc) \ - bus_space_barrier((sc)->sc_st, (sc)->sc_sh, 0, 0x1800, \ - BUS_SPACE_BARRIER_WRITE) - -#define RAL_BARRIER_READ_WRITE(sc) \ - bus_space_barrier((sc)->sc_st, (sc)->sc_sh, 0, 0x1800, \ - BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE) - -#define RAL_WRITE_REGION_1(sc, offset, datap, count) \ - bus_space_write_region_1((sc)->sc_st, (sc)->sc_sh, (offset), \ - (datap), (count)) - -#define RAL_SET_REGION_4(sc, offset, val, count) \ - bus_space_set_region_4((sc)->sc_st, (sc)->sc_sh, (offset), \ - (val), (count)) - -/* * EEPROM access macro. */ #define RT2860_EEPROM_CTL(sc, val) do { \ diff --git a/sys/dev/usb/wlan/if_uath.c b/sys/dev/usb/wlan/if_uath.c index 6806c33..0796fbe 100644 --- a/sys/dev/usb/wlan/if_uath.c +++ b/sys/dev/usb/wlan/if_uath.c @@ -86,6 +86,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -114,18 +115,16 @@ __FBSDID("$FreeBSD$"); static SYSCTL_NODE(_hw_usb, OID_AUTO, uath, CTLFLAG_RW, 0, "USB Atheros"); static int uath_countrycode = CTRY_DEFAULT; /* country code */ -SYSCTL_INT(_hw_usb_uath, OID_AUTO, countrycode, CTLFLAG_RW | CTLFLAG_TUN, &uath_countrycode, +SYSCTL_INT(_hw_usb_uath, OID_AUTO, countrycode, CTLFLAG_RWTUN, &uath_countrycode, 0, "country code"); -TUNABLE_INT("hw.usb.uath.countrycode", &uath_countrycode); static int uath_regdomain = 0; /* regulatory domain */ SYSCTL_INT(_hw_usb_uath, OID_AUTO, regdomain, CTLFLAG_RD, &uath_regdomain, 0, "regulatory domain"); #ifdef UATH_DEBUG int uath_debug = 0; -SYSCTL_INT(_hw_usb_uath, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, &uath_debug, 0, +SYSCTL_INT(_hw_usb_uath, OID_AUTO, debug, CTLFLAG_RWTUN, &uath_debug, 0, "uath debug level"); -TUNABLE_INT("hw.usb.uath.debug", &uath_debug); enum { UATH_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ UATH_DEBUG_XMIT_DUMP = 0x00000002, /* xmit dump */ @@ -1334,7 +1333,7 @@ uath_watchdog(void *arg) if (--sc->sc_tx_timer == 0) { device_printf(sc->sc_dev, "device timeout\n"); /*uath_init(ifp); XXX needs a process context! */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return; } callout_reset(&sc->watchdog_ch, hz, uath_watchdog, sc); @@ -1815,7 +1814,7 @@ uath_start(struct ifnet *ifp) next = m->m_nextpkt; if (uath_tx_start(sc, m, ni, bf) != 0) { bad: - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); reclaim: STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); UATH_STAT_INC(sc, st_tx_inactive); @@ -1879,7 +1878,7 @@ uath_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, sc->sc_seqnum = 0; if (uath_tx_start(sc, m, ni, bf) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); UATH_STAT_INC(sc, st_tx_inactive); UATH_UNLOCK(sc); @@ -2554,14 +2553,14 @@ uath_data_rxeof(struct usb_xfer *xfer, struct uath_data *data, if (actlen < (int)UATH_MIN_RXBUFSZ) { DPRINTF(sc, UATH_DEBUG_RECV | UATH_DEBUG_RECV_ALL, "%s: wrong xfer size (len=%d)\n", __func__, actlen); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } chunk = (struct uath_chunk *)data->buf; if (chunk->seqnum == 0 && chunk->flags == 0 && chunk->length == 0) { device_printf(sc->sc_dev, "%s: strange response\n", __func__); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); UATH_RESET_INTRX(sc); return (NULL); } @@ -2594,7 +2593,7 @@ uath_data_rxeof(struct usb_xfer *xfer, struct uath_data *data, if ((sc->sc_intrx_len + sizeof(struct uath_rx_desc) + chunklen) > UATH_MAX_INTRX_SIZE) { UATH_STAT_INC(sc, st_invalidlen); - ifp->if_iqdrops++; + if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); if (sc->sc_intrx_head != NULL) m_freem(sc->sc_intrx_head); UATH_RESET_INTRX(sc); @@ -2619,7 +2618,7 @@ uath_data_rxeof(struct usb_xfer *xfer, struct uath_data *data, if (mnew == NULL) { DPRINTF(sc, UATH_DEBUG_RECV | UATH_DEBUG_RECV_ALL, "%s: can't get new mbuf, drop frame\n", __func__); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); if (sc->sc_intrx_head != NULL) m_freem(sc->sc_intrx_head); UATH_RESET_INTRX(sc); @@ -2660,7 +2659,7 @@ uath_data_rxeof(struct usb_xfer *xfer, struct uath_data *data, DPRINTF(sc, UATH_DEBUG_RECV | UATH_DEBUG_RECV_ALL, "%s: bad descriptor (len=%d)\n", __func__, be32toh(desc->len)); - ifp->if_iqdrops++; + if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); UATH_STAT_INC(sc, st_toobigrxpkt); if (sc->sc_intrx_head != NULL) m_freem(sc->sc_intrx_head); @@ -2704,7 +2703,7 @@ uath_data_rxeof(struct usb_xfer *xfer, struct uath_data *data, tap->wr_antnoise = -95; } - ifp->if_ipackets++; + if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); UATH_RESET_INTRX(sc); return (m); @@ -2791,7 +2790,7 @@ setup: } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto setup; } break; @@ -2827,7 +2826,7 @@ uath_data_txeof(struct usb_xfer *xfer, struct uath_data *data) data->ni = NULL; } sc->sc_tx_timer = 0; - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; } @@ -2879,7 +2878,7 @@ setup: if ((sc->sc_flags & UATH_FLAG_INVALID) == 0) ieee80211_free_node(data->ni); data->ni = NULL; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); diff --git a/sys/dev/usb/wlan/if_upgt.c b/sys/dev/usb/wlan/if_upgt.c index 210be1f..dc6dc1b 100644 --- a/sys/dev/usb/wlan/if_upgt.c +++ b/sys/dev/usb/wlan/if_upgt.c @@ -31,6 +31,7 @@ #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -75,9 +76,8 @@ static SYSCTL_NODE(_hw, OID_AUTO, upgt, CTLFLAG_RD, 0, #ifdef UPGT_DEBUG int upgt_debug = 0; -SYSCTL_INT(_hw_upgt, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, &upgt_debug, +SYSCTL_INT(_hw_upgt, OID_AUTO, debug, CTLFLAG_RWTUN, &upgt_debug, 0, "control debugging printfs"); -TUNABLE_INT("hw.upgt.debug", &upgt_debug); enum { UPGT_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ UPGT_DEBUG_RECV = 0x00000002, /* basic recv operation */ @@ -182,7 +182,7 @@ static const STRUCT_USB_HOST_ID upgt_devs[] = { UPGT_DEV(FSC, E5400), UPGT_DEV(GLOBESPAN, PRISM_GT_1), UPGT_DEV(GLOBESPAN, PRISM_GT_2), - UPGT_DEV(NETGEAR, WG111V1_2), + //UPGT_DEV(NETGEAR, WG111V1_2), UPGT_DEV(INTERSIL, PRISM_GT), UPGT_DEV(SMC, 2862WG), UPGT_DEV(USR, USR5422), @@ -416,7 +416,7 @@ upgt_txeof(struct usb_xfer *xfer, struct upgt_data *data) ieee80211_free_node(data->ni); data->ni = NULL; } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); } static void @@ -854,7 +854,7 @@ upgt_start(struct ifnet *ifp) STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, data_tx, next); UPGT_STAT_INC(sc, st_tx_inactive); ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); continue; } sc->sc_tx_timer = 5; @@ -891,7 +891,7 @@ upgt_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, data_tx, next); UPGT_STAT_INC(sc, st_tx_inactive); ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); UPGT_UNLOCK(sc); return (EIO); } @@ -911,7 +911,7 @@ upgt_watchdog(void *arg) if (--sc->sc_tx_timer == 0) { device_printf(sc->sc_dev, "watchdog timeout\n"); /* upgt_init(ifp); XXX needs a process context ? */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return; } callout_reset(&sc->sc_watchdog_ch, hz, upgt_watchdog, sc); @@ -1552,7 +1552,7 @@ upgt_rx(struct upgt_softc *sc, uint8_t *data, int pkglen, int *rssi) tap->wr_rate = upgt_rx_rate(sc, rxdesc->rate); tap->wr_antsignal = rxdesc->rssi; } - ifp->if_ipackets++; + if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); DPRINTF(sc, UPGT_DEBUG_RX_PROC, "%s: RX done\n", __func__); *rssi = rxdesc->rssi; @@ -2293,7 +2293,8 @@ done: * will stall. It's strange, but it works, so we keep reading * the statistics here. *shrug* */ - if (!(ifp->if_opackets % UPGT_TX_STAT_INTERVAL)) + if (!(if_get_counter_default(ifp, IFCOUNTER_OPACKETS) % + UPGT_TX_STAT_INTERVAL)) upgt_get_stats(sc); return (error); @@ -2366,7 +2367,7 @@ setup: } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto setup; } break; @@ -2418,7 +2419,7 @@ setup: if (data->ni != NULL) { ieee80211_free_node(data->ni); data->ni = NULL; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c index 69b41dd..c81b708 100644 --- a/sys/dev/usb/wlan/if_ural.c +++ b/sys/dev/usb/wlan/if_ural.c @@ -49,6 +49,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -82,7 +83,7 @@ __FBSDID("$FreeBSD$"); static int ural_debug = 0; static SYSCTL_NODE(_hw_usb, OID_AUTO, ural, CTLFLAG_RW, 0, "USB ural"); -SYSCTL_INT(_hw_usb_ural, OID_AUTO, debug, CTLFLAG_RW, &ural_debug, 0, +SYSCTL_INT(_hw_usb_ural, OID_AUTO, debug, CTLFLAG_RWTUN, &ural_debug, 0, "Debug level"); #endif @@ -804,7 +805,7 @@ ural_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) ural_tx_free(data, 0); usbd_xfer_set_priv(xfer, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* FALLTHROUGH */ @@ -858,7 +859,7 @@ tr_setup: DPRINTFN(11, "transfer error, %s\n", usbd_errstr(error)); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); data = usbd_xfer_get_priv(xfer); if (data != NULL) { ural_tx_free(data, error); @@ -899,7 +900,7 @@ ural_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) if (len < (int)(RAL_RX_DESC_SIZE + IEEE80211_MIN_LEN)) { DPRINTF("%s: xfer too short %d\n", device_get_nameunit(sc->sc_dev), len); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } @@ -918,14 +919,14 @@ ural_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) * filled RAL_TXRX_CSR2: */ DPRINTFN(5, "PHY or CRC error\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (m == NULL) { DPRINTF("could not allocate mbuf\n"); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } usbd_copy_out(pc, 0, mtod(m, uint8_t *), len); @@ -1369,7 +1370,7 @@ ural_start(struct ifnet *ifp) ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; if (ural_tx_data(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; } } @@ -2209,7 +2210,7 @@ ural_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return EIO; } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if (params == NULL) { /* @@ -2229,7 +2230,7 @@ ural_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, RAL_UNLOCK(sc); return 0; bad: - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); RAL_UNLOCK(sc); ieee80211_free_node(ni); return EIO; /* XXX */ @@ -2283,7 +2284,7 @@ ural_ratectl_task(void *arg, int pending) ieee80211_ratectl_tx_update(vap, ni, &sum, &ok, &retrycnt); (void) ieee80211_ratectl_rate(ni, NULL, 0); - ifp->if_oerrors += fail; /* count TX retry-fail as Tx errors */ + if_inc_counter(ifp, IFCOUNTER_OERRORS, fail); /* count TX retry-fail as Tx errors */ usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp); RAL_UNLOCK(sc); diff --git a/sys/dev/usb/wlan/if_urtw.c b/sys/dev/usb/wlan/if_urtw.c index 5612f19..d2c6ef9 100644 --- a/sys/dev/usb/wlan/if_urtw.c +++ b/sys/dev/usb/wlan/if_urtw.c @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); #include <sys/rman.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -64,9 +65,8 @@ __FBSDID("$FreeBSD$"); static SYSCTL_NODE(_hw_usb, OID_AUTO, urtw, CTLFLAG_RW, 0, "USB Realtek 8187L"); #ifdef URTW_DEBUG int urtw_debug = 0; -SYSCTL_INT(_hw_usb_urtw, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, &urtw_debug, 0, +SYSCTL_INT(_hw_usb_urtw, OID_AUTO, debug, CTLFLAG_RWTUN, &urtw_debug, 0, "control debugging printfs"); -TUNABLE_INT("hw.usb.urtw.debug", &urtw_debug); enum { URTW_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ URTW_DEBUG_RECV = 0x00000002, /* basic recv operation */ @@ -89,9 +89,8 @@ enum { } while (0) #endif static int urtw_preamble_mode = URTW_PREAMBLE_MODE_LONG; -SYSCTL_INT(_hw_usb_urtw, OID_AUTO, preamble_mode, CTLFLAG_RW | CTLFLAG_TUN, +SYSCTL_INT(_hw_usb_urtw, OID_AUTO, preamble_mode, CTLFLAG_RWTUN, &urtw_preamble_mode, 0, "set the preable mode (long or short)"); -TUNABLE_INT("hw.usb.urtw.preamble_mode", &urtw_preamble_mode); /* recognized device vendors/products */ #define urtw_lookup(v, p) \ @@ -1473,7 +1472,7 @@ urtw_start(struct ifnet *ifp) m->m_pkthdr.rcvif = NULL; if (urtw_tx_start(sc, ni, m, bf, URTW_PRIORITY_NORMAL) != 0) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); ieee80211_free_node(ni); break; @@ -1583,10 +1582,10 @@ urtw_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return (ENOBUFS); /* XXX */ } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if (urtw_tx_start(sc, ni, m, bf, URTW_PRIORITY_LOW) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); URTW_UNLOCK(sc); return (EIO); @@ -1919,7 +1918,7 @@ urtw_watchdog(void *arg) if (sc->sc_txtimer > 0) { if (--sc->sc_txtimer == 0) { device_printf(sc->sc_dev, "device timeout\n"); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return; } callout_reset(&sc->sc_watchdog_ch, hz, urtw_watchdog, sc); @@ -3994,7 +3993,7 @@ urtw_rxeof(struct usb_xfer *xfer, struct urtw_data *data, int *rssi_p, usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); if (actlen < (int)URTW_MIN_RXBUFSZ) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } @@ -4005,7 +4004,7 @@ urtw_rxeof(struct usb_xfer *xfer, struct urtw_data *data, int *rssi_p, (actlen - (sizeof(struct urtw_8187b_rxhdr)))); flen = le32toh(rx->flag) & 0xfff; if (flen > actlen) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } rate = (le32toh(rx->flag) >> URTW_RX_FLAG_RXRATE_SHIFT) & 0xf; @@ -4019,7 +4018,7 @@ urtw_rxeof(struct usb_xfer *xfer, struct urtw_data *data, int *rssi_p, (actlen - (sizeof(struct urtw_8187l_rxhdr)))); flen = le32toh(rx->flag) & 0xfff; if (flen > actlen) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } @@ -4031,7 +4030,7 @@ urtw_rxeof(struct usb_xfer *xfer, struct urtw_data *data, int *rssi_p, mnew = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (mnew == NULL) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } @@ -4128,7 +4127,7 @@ setup: } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto setup; } break; @@ -4157,7 +4156,7 @@ urtw_txstatus_eof(struct usb_xfer *xfer) pktretry = val & 0xff; seq = (val >> 16) & 0xff; if (pktretry == URTW_TX_MAXRETRY) - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); DPRINTF(sc, URTW_DEBUG_TXSTATUS, "pktretry %d seq %#x\n", pktretry, seq); } @@ -4185,7 +4184,7 @@ setup: default: if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto setup; } break; @@ -4219,7 +4218,7 @@ urtw_txeof(struct usb_xfer *xfer, struct urtw_data *data) data->ni = NULL; } sc->sc_txtimer = 0; - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; } @@ -4266,7 +4265,7 @@ setup: if (data->ni != NULL) { ieee80211_free_node(data->ni); data->ni = NULL; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); diff --git a/sys/dev/usb/wlan/if_urtwn.c b/sys/dev/usb/wlan/if_urtwn.c index 2475727..28bf713 100644 --- a/sys/dev/usb/wlan/if_urtwn.c +++ b/sys/dev/usb/wlan/if_urtwn.c @@ -47,6 +47,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -77,7 +78,7 @@ __FBSDID("$FreeBSD$"); static int urtwn_debug = 0; SYSCTL_NODE(_hw_usb, OID_AUTO, urtwn, CTLFLAG_RW, 0, "USB urtwn"); -SYSCTL_INT(_hw_usb_urtwn, OID_AUTO, debug, CTLFLAG_RW, &urtwn_debug, 0, +SYSCTL_INT(_hw_usb_urtwn, OID_AUTO, debug, CTLFLAG_RWTUN, &urtwn_debug, 0, "Debug level"); #endif @@ -152,7 +153,9 @@ static const STRUCT_USB_HOST_ID urtwn_devs[] = { URTWN_DEV(TRENDNET, RTL8192CU), URTWN_DEV(ZYXEL, RTL8192CU), /* URTWN_RTL8188E */ + //URTWN_RTL8188E_DEV(DLINK, DWA123D1), URTWN_RTL8188E_DEV(DLINK, DWA125D1), + //URTWN_RTL8188E_DEV(ELECOM, WDC150SU2M), URTWN_RTL8188E_DEV(REALTEK, RTL8188ETV), URTWN_RTL8188E_DEV(REALTEK, RTL8188EU), #undef URTWN_RTL8188E_DEV @@ -173,12 +176,12 @@ static struct ieee80211vap *urtwn_vap_create(struct ieee80211com *, const uint8_t [IEEE80211_ADDR_LEN], const uint8_t [IEEE80211_ADDR_LEN]); static void urtwn_vap_delete(struct ieee80211vap *); -static struct mbuf * urtwn_rx_frame(struct urtwn_softc *, uint8_t *, int, +static struct mbuf * urtwn_rx_frame(struct urtwn_softc *, uint8_t *, int, int *); -static struct mbuf * urtwn_rxeof(struct usb_xfer *, struct urtwn_data *, +static struct mbuf * urtwn_rxeof(struct usb_xfer *, struct urtwn_data *, int *, int8_t *); static void urtwn_txeof(struct usb_xfer *, struct urtwn_data *); -static int urtwn_alloc_list(struct urtwn_softc *, +static int urtwn_alloc_list(struct urtwn_softc *, struct urtwn_data[], int, int); static int urtwn_alloc_rx_list(struct urtwn_softc *); static int urtwn_alloc_tx_list(struct urtwn_softc *); @@ -188,24 +191,24 @@ static void urtwn_free_list(struct urtwn_softc *, struct urtwn_data data[], int); static struct urtwn_data * _urtwn_getbuf(struct urtwn_softc *); static struct urtwn_data * urtwn_getbuf(struct urtwn_softc *); -static int urtwn_write_region_1(struct urtwn_softc *, uint16_t, +static int urtwn_write_region_1(struct urtwn_softc *, uint16_t, uint8_t *, int); static void urtwn_write_1(struct urtwn_softc *, uint16_t, uint8_t); static void urtwn_write_2(struct urtwn_softc *, uint16_t, uint16_t); static void urtwn_write_4(struct urtwn_softc *, uint16_t, uint32_t); -static int urtwn_read_region_1(struct urtwn_softc *, uint16_t, +static int urtwn_read_region_1(struct urtwn_softc *, uint16_t, uint8_t *, int); static uint8_t urtwn_read_1(struct urtwn_softc *, uint16_t); static uint16_t urtwn_read_2(struct urtwn_softc *, uint16_t); static uint32_t urtwn_read_4(struct urtwn_softc *, uint16_t); -static int urtwn_fw_cmd(struct urtwn_softc *, uint8_t, +static int urtwn_fw_cmd(struct urtwn_softc *, uint8_t, const void *, int); static void urtwn_r92c_rf_write(struct urtwn_softc *, int, uint8_t, uint32_t); -static void urtwn_r88e_rf_write(struct urtwn_softc *, int, +static void urtwn_r88e_rf_write(struct urtwn_softc *, int, uint8_t, uint32_t); static uint32_t urtwn_rf_read(struct urtwn_softc *, int, uint8_t); -static int urtwn_llt_write(struct urtwn_softc *, uint32_t, +static int urtwn_llt_write(struct urtwn_softc *, uint32_t, uint32_t); static uint8_t urtwn_efuse_read_1(struct urtwn_softc *, uint16_t); static void urtwn_efuse_read(struct urtwn_softc *); @@ -216,7 +219,7 @@ static void urtwn_r88e_read_rom(struct urtwn_softc *); static int urtwn_ra_init(struct urtwn_softc *); static void urtwn_tsf_sync_enable(struct urtwn_softc *); static void urtwn_set_led(struct urtwn_softc *, int, int); -static int urtwn_newstate(struct ieee80211vap *, +static int urtwn_newstate(struct ieee80211vap *, enum ieee80211_state, int); static void urtwn_watchdog(void *); static void urtwn_update_avgrssi(struct urtwn_softc *, int, int8_t); @@ -234,7 +237,7 @@ static int urtwn_r88e_power_on(struct urtwn_softc *); static int urtwn_llt_init(struct urtwn_softc *); static void urtwn_fw_reset(struct urtwn_softc *); static void urtwn_r88e_fw_reset(struct urtwn_softc *); -static int urtwn_fw_loadpage(struct urtwn_softc *, int, +static int urtwn_fw_loadpage(struct urtwn_softc *, int, const uint8_t *, int); static int urtwn_load_firmware(struct urtwn_softc *); static int urtwn_r92c_dma_init(struct urtwn_softc *); @@ -246,22 +249,22 @@ static void urtwn_cam_init(struct urtwn_softc *); static void urtwn_pa_bias_init(struct urtwn_softc *); static void urtwn_rxfilter_init(struct urtwn_softc *); static void urtwn_edca_init(struct urtwn_softc *); -static void urtwn_write_txpower(struct urtwn_softc *, int, +static void urtwn_write_txpower(struct urtwn_softc *, int, uint16_t[]); static void urtwn_get_txpower(struct urtwn_softc *, int, - struct ieee80211_channel *, + struct ieee80211_channel *, struct ieee80211_channel *, uint16_t[]); static void urtwn_r88e_get_txpower(struct urtwn_softc *, int, - struct ieee80211_channel *, + struct ieee80211_channel *, struct ieee80211_channel *, uint16_t[]); static void urtwn_set_txpower(struct urtwn_softc *, - struct ieee80211_channel *, + struct ieee80211_channel *, struct ieee80211_channel *); static void urtwn_scan_start(struct ieee80211com *); static void urtwn_scan_end(struct ieee80211com *); static void urtwn_set_channel(struct ieee80211com *); static void urtwn_set_chan(struct urtwn_softc *, - struct ieee80211_channel *, + struct ieee80211_channel *, struct ieee80211_channel *); static void urtwn_update_mcast(struct ifnet *); static void urtwn_iq_calib(struct urtwn_softc *); @@ -467,7 +470,7 @@ urtwn_attach(device_t self) ic->ic_vap_delete = urtwn_vap_delete; ic->ic_update_mcast = urtwn_update_mcast; - ieee80211_radiotap_attach(ic, &sc->sc_txtap.wt_ihdr, + ieee80211_radiotap_attach(ic, &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap), URTWN_TX_RADIOTAP_PRESENT, &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), URTWN_RX_RADIOTAP_PRESENT); @@ -489,7 +492,7 @@ urtwn_detach(device_t self) struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; unsigned int x; - + /* Prevent further ioctls. */ URTWN_LOCK(sc); sc->sc_flags |= URTWN_DETACHED; @@ -601,7 +604,7 @@ urtwn_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, vap = &uvp->vap; /* enable s/w bmiss handling for sta mode */ - if (ieee80211_vap_setup(ic, vap, name, unit, opmode, + if (ieee80211_vap_setup(ic, vap, name, unit, opmode, flags | IEEE80211_CLONE_NOBEACONS, bssid, mac) != 0) { /* out of memory */ free(uvp, M_80211_VAP); @@ -657,7 +660,11 @@ urtwn_rx_frame(struct urtwn_softc *sc, uint8_t *buf, int pktlen, int *rssi_p) * This should not happen since we setup our Rx filter * to not receive these frames. */ - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); + return (NULL); + } + if (pktlen < sizeof(*wh) || pktlen > MCLBYTES) { + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } @@ -666,7 +673,7 @@ urtwn_rx_frame(struct urtwn_softc *sc, uint8_t *buf, int pktlen, int *rssi_p) /* Get RSSI from PHY status descriptor if present. */ if (infosz != 0 && (rxdw0 & R92C_RXDW0_PHYST)) { - if (sc->chip & URTWN_CHIP_88E) + if (sc->chip & URTWN_CHIP_88E) rssi = urtwn_r88e_get_rssi(sc, rate, &stat[1]); else rssi = urtwn_get_rssi(sc, rate, &stat[1]); @@ -742,7 +749,7 @@ urtwn_rxeof(struct usb_xfer *xfer, struct urtwn_data *data, int *rssi, usbd_xfer_status(xfer, &len, NULL, NULL, NULL); if (len < sizeof(*stat)) { - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return (NULL); } @@ -857,7 +864,7 @@ tr_setup: } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); goto tr_setup; } break; @@ -891,7 +898,7 @@ urtwn_txeof(struct usb_xfer *xfer, struct urtwn_data *data) data->ni = NULL; } sc->sc_txtimer = 0; - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; } @@ -933,7 +940,7 @@ tr_setup: if (data->ni != NULL) { ieee80211_free_node(data->ni); data->ni = NULL; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } if (error != USB_ERR_CANCELLED) { usbd_xfer_set_stall(xfer); @@ -1177,7 +1184,7 @@ urtwn_efuse_read_1(struct urtwn_softc *sc, uint16_t addr) return (MS(reg, R92C_EFUSE_CTRL_DATA)); urtwn_ms_delay(sc); } - device_printf(sc->sc_dev, + device_printf(sc->sc_dev, "could not read efuse byte at address 0x%x\n", addr); return (0xff); } @@ -1188,7 +1195,7 @@ urtwn_efuse_read(struct urtwn_softc *sc) uint8_t *rom = (uint8_t *)&sc->rom; uint16_t addr = 0; uint32_t reg; - uint8_t off, msk, vol; + uint8_t off, msk; int i; urtwn_efuse_switch_power(sc); @@ -1221,18 +1228,15 @@ urtwn_efuse_read(struct urtwn_softc *sc) printf("\n"); } #endif - /* Disable LDO 2.5V. */ - vol = urtwn_read_1(sc, R92C_EFUSE_TEST + 3); - urtwn_write_1(sc, R92C_EFUSE_TEST + 3, vol & ~(0x80)); - + urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_OFF); } + static void urtwn_efuse_switch_power(struct urtwn_softc *sc) { uint32_t reg; - if (sc->chip & URTWN_CHIP_88E) - urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_ON); + urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_ON); reg = urtwn_read_2(sc, R92C_SYS_ISO_CTRL); if (!(reg & R92C_SYS_ISO_CTRL_PWC_EV12V)) { @@ -1250,16 +1254,6 @@ urtwn_efuse_switch_power(struct urtwn_softc *sc) urtwn_write_2(sc, R92C_SYS_CLKR, reg | R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M); } - - if (!(sc->chip & URTWN_CHIP_88E)) { - uint8_t vol; - - /* Enable LDO 2.5V. */ - vol = urtwn_read_1(sc, R92C_EFUSE_TEST + 3); - vol &= 0x0f; - vol |= 0x30; - urtwn_write_1(sc, R92C_EFUSE_TEST + 3, (vol | 0x80)); - } } static int @@ -1489,7 +1483,7 @@ static void urtwn_set_led(struct urtwn_softc *sc, int led, int on) { uint8_t reg; - + if (led == URTWN_LED_LINK) { if (sc->chip & URTWN_CHIP_88E) { reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0xf0; @@ -1650,7 +1644,7 @@ urtwn_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) if (sc->chip & URTWN_CHIP_88E) ni->ni_txrate = ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates-1]; - else + else urtwn_ra_init(sc); /* Turn link LED on. */ urtwn_set_led(sc, URTWN_LED_LINK, 1); @@ -1678,7 +1672,7 @@ urtwn_watchdog(void *arg) if (sc->sc_txtimer > 0) { if (--sc->sc_txtimer == 0) { device_printf(sc->sc_dev, "device timeout\n"); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return; } callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc); @@ -1761,7 +1755,7 @@ urtwn_r88e_get_rssi(struct urtwn_softc *sc, int rate, void *physt) cck = (struct r88e_rx_cck *)physt; cck_agc_rpt = cck->agc_rpt; lna_idx = (cck_agc_rpt & 0xe0) >> 5; - vga_idx = cck_agc_rpt & 0x1f; + vga_idx = cck_agc_rpt & 0x1f; switch (lna_idx) { case 7: if (vga_idx <= 27) @@ -1801,7 +1795,7 @@ urtwn_r88e_get_rssi(struct urtwn_softc *sc, int rate, void *physt) static int -urtwn_tx_start(struct urtwn_softc *sc, struct ieee80211_node *ni, +urtwn_tx_start(struct urtwn_softc *sc, struct ieee80211_node *ni, struct mbuf *m0, struct urtwn_data *data) { struct ifnet *ifp = sc->sc_ifp; @@ -1842,7 +1836,7 @@ urtwn_tx_start(struct urtwn_softc *sc, struct ieee80211_node *ni, /* in case packet header moved, reset pointer */ wh = mtod(m0, struct ieee80211_frame *); } - + switch (type) { case IEEE80211_FC0_TYPE_CTL: case IEEE80211_FC0_TYPE_MGT: @@ -1854,7 +1848,7 @@ urtwn_tx_start(struct urtwn_softc *sc, struct ieee80211_node *ni, xfer = urtwn_pipes[M_WME_GETAC(m0)]; break; } - + hasqos = 0; /* Fill Tx descriptor. */ @@ -1898,10 +1892,7 @@ urtwn_tx_start(struct urtwn_softc *sc, struct ieee80211_node *ni, txd->txdw4 |= htole32(SM(R92C_TXDW4_RTSRATE, 8)); txd->txdw5 |= htole32(0x0001ff00); /* Send data at OFDM54. */ - if (sc->chip & URTWN_CHIP_88E) - txd->txdw5 |= htole32(0x13 & 0x3f); - else - txd->txdw5 |= htole32(SM(R92C_TXDW5_DATARATE, 11)); + txd->txdw5 |= htole32(SM(R92C_TXDW5_DATARATE, 11)); } else { txd->txdw1 |= htole32( SM(R92C_TXDW1_MACID, 0) | @@ -1982,7 +1973,7 @@ urtwn_start_locked(struct ifnet *ifp, struct urtwn_softc *sc) m->m_pkthdr.rcvif = NULL; if (urtwn_tx_start(sc, ni, m, bf) != 0) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); ieee80211_free_node(ni); break; @@ -2332,7 +2323,7 @@ urtwn_fw_loadpage(struct urtwn_softc *sc, int page, const uint8_t *buf, int len) else mlen = 1; /* XXX fix this deconst */ - error = urtwn_write_region_1(sc, off, + error = urtwn_write_region_1(sc, off, __DECONST(uint8_t *, buf), mlen); if (error != 0) break; @@ -2467,7 +2458,7 @@ fail: static __inline int urtwn_dma_init(struct urtwn_softc *sc) { - + return sc->sc_dma_init(sc); } @@ -3235,10 +3226,10 @@ urtwn_set_chan(struct urtwn_softc *sc, struct ieee80211_channel *c, urtwn_bb_read(sc, R92C_FPGA0_ANAPARAM2) | R92C_FPGA0_ANAPARAM2_CBW20); } - + /* Select 20MHz bandwidth. */ urtwn_rf_write(sc, 0, R92C_RF_CHNLBW, - (sc->rf_chnlbw[0] & ~0xfff) | chan | + (sc->rf_chnlbw[0] & ~0xfff) | chan | ((sc->chip & URTWN_CHIP_88E) ? R88E_RF_CHNLBW_BW20 : R92C_RF_CHNLBW_BW20)); } @@ -3313,7 +3304,7 @@ urtwn_init_locked(void *arg) error = urtwn_alloc_rx_list(sc); if (error != 0) goto fail; - + error = urtwn_alloc_tx_list(sc); if (error != 0) goto fail; @@ -3357,6 +3348,7 @@ urtwn_init_locked(void *arg) urtwn_rxfilter_init(sc); + /* Set response rate. */ reg = urtwn_read_4(sc, R92C_RRSR); reg = RW(reg, R92C_RRSR_RATE_BITMAP, R92C_RRSR_RATE_CCK_ONLY_1M); urtwn_write_4(sc, R92C_RRSR, reg); @@ -3548,10 +3540,10 @@ urtwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, return (ENOBUFS); } - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if (urtwn_tx_start(sc, ni, m, bf) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); URTWN_UNLOCK(sc); return (EIO); diff --git a/sys/dev/usb/wlan/if_urtwnreg.h b/sys/dev/usb/wlan/if_urtwnreg.h index 4eef029..2bbec7a 100644 --- a/sys/dev/usb/wlan/if_urtwnreg.h +++ b/sys/dev/usb/wlan/if_urtwnreg.h @@ -177,13 +177,13 @@ #define R92C_RD_NAV_NXT 0x544 #define R92C_NAV_PROT_LEN 0x546 #define R92C_BCN_CTRL 0x550 -#define R92C_USTIME_TSF 0x551 #define R92C_MBID_NUM 0x552 #define R92C_DUAL_TSF_RST 0x553 #define R92C_BCN_INTERVAL 0x554 #define R92C_DRVERLYINT 0x558 #define R92C_BCNDMATIM 0x559 #define R92C_ATIMWND 0x55a +#define R92C_USTIME_TSF 0x55c #define R92C_BCN_MAX_ERR 0x55d #define R92C_RXTSF_OFFSET_CCK 0x55e #define R92C_RXTSF_OFFSET_OFDM 0x55f diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c index 35a064b..ca1fb06 100644 --- a/sys/dev/usb/wlan/if_zyd.c +++ b/sys/dev/usb/wlan/if_zyd.c @@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -79,7 +80,7 @@ __FBSDID("$FreeBSD$"); static int zyd_debug = 0; static SYSCTL_NODE(_hw_usb, OID_AUTO, zyd, CTLFLAG_RW, 0, "USB zyd"); -SYSCTL_INT(_hw_usb_zyd, OID_AUTO, debug, CTLFLAG_RW, &zyd_debug, 0, +SYSCTL_INT(_hw_usb_zyd, OID_AUTO, debug, CTLFLAG_RWTUN, &zyd_debug, 0, "zyd debug level"); enum { @@ -678,7 +679,7 @@ zyd_intr_read_callback(struct usb_xfer *xfer, usb_error_t error) ieee80211_free_node(ni); } if (le16toh(retry->count) & 0x100) - ifp->if_oerrors++; /* too many retries */ + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); /* too many retries */ break; } case ZYD_NOTIF_IORD: @@ -2187,7 +2188,7 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len) if (len < ZYD_MIN_FRAGSZ) { DPRINTF(sc, ZYD_DEBUG_RECV, "%s: frame too short (length=%d)\n", device_get_nameunit(sc->sc_dev), len); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } pc = usbd_xfer_get_frame(xfer, 0); @@ -2198,7 +2199,7 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len) DPRINTF(sc, ZYD_DEBUG_RECV, "%s: RX status indicated error (%x)\n", device_get_nameunit(sc->sc_dev), stat.flags); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } @@ -2210,7 +2211,7 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len) if (rlen > (int)MCLBYTES) { DPRINTF(sc, ZYD_DEBUG_RECV, "%s: frame too long (length=%d)\n", device_get_nameunit(sc->sc_dev), rlen); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } else if (rlen > (int)MHLEN) m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); @@ -2219,7 +2220,7 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len) if (m == NULL) { DPRINTF(sc, ZYD_DEBUG_RECV, "%s: could not allocate rx mbuf\n", device_get_nameunit(sc->sc_dev)); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); return; } m->m_pkthdr.rcvif = ifp; @@ -2402,7 +2403,7 @@ zyd_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) zyd_tx_free(data, 0); usbd_xfer_set_priv(xfer, NULL); - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* FALLTHROUGH */ @@ -2446,7 +2447,7 @@ tr_setup: DPRINTF(sc, ZYD_DEBUG_ANY, "transfer error, %s\n", usbd_errstr(error)); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); data = usbd_xfer_get_priv(xfer); usbd_xfer_set_priv(xfer, NULL); if (data != NULL) @@ -2607,7 +2608,7 @@ zyd_start(struct ifnet *ifp) ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; if (zyd_tx_start(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); break; } } @@ -2645,7 +2646,7 @@ zyd_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, */ if (zyd_tx_start(sc, m, ni) != 0) { ZYD_UNLOCK(sc); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ieee80211_free_node(ni); return (EIO); } diff --git a/sys/dev/virtio/network/if_vtnet.c b/sys/dev/virtio/network/if_vtnet.c index 5453998..a5e6383 100644 --- a/sys/dev/virtio/network/if_vtnet.c +++ b/sys/dev/virtio/network/if_vtnet.c @@ -139,23 +139,21 @@ static struct mbuf * static int vtnet_txq_enqueue_buf(struct vtnet_txq *, struct mbuf **, struct vtnet_tx_header *); static int vtnet_txq_encap(struct vtnet_txq *, struct mbuf **); -#ifdef VTNET_LEGACY_TX + static void vtnet_start_locked(struct vtnet_txq *, struct ifnet *); static void vtnet_start(struct ifnet *); -#else + static int vtnet_txq_mq_start_locked(struct vtnet_txq *, struct mbuf *); static int vtnet_txq_mq_start(struct ifnet *, struct mbuf *); static void vtnet_txq_tq_deferred(void *, int); -#endif + static void vtnet_txq_start(struct vtnet_txq *); static void vtnet_txq_tq_intr(void *, int); static int vtnet_txq_eof(struct vtnet_txq *); static void vtnet_tx_vq_intr(void *); static void vtnet_tx_start_all(struct vtnet_softc *); -#ifndef VTNET_LEGACY_TX static void vtnet_qflush(struct ifnet *); -#endif static int vtnet_watchdog(struct vtnet_txq *); static void vtnet_rxq_accum_stats(struct vtnet_rxq *, @@ -922,16 +920,16 @@ vtnet_setup_interface(struct vtnet_softc *sc) ifp->if_init = vtnet_init; ifp->if_ioctl = vtnet_ioctl; -#ifndef VTNET_LEGACY_TX + ifp->if_transmit = vtnet_txq_mq_start; ifp->if_qflush = vtnet_qflush; -#else + struct virtqueue *vq = sc->vtnet_txqs[0].vtntx_vq; ifp->if_start = vtnet_start; IFQ_SET_MAXLEN(&ifp->if_snd, virtqueue_size(vq) - 1); ifp->if_snd.ifq_drv_maxlen = virtqueue_size(vq) - 1; IFQ_SET_READY(&ifp->if_snd); -#endif + ifmedia_init(&sc->vtnet_media, IFM_IMASK, vtnet_ifmedia_upd, vtnet_ifmedia_sts); @@ -2209,7 +2207,7 @@ fail: return (error); } -#ifdef VTNET_LEGACY_TX + static void vtnet_start_locked(struct vtnet_txq *txq, struct ifnet *ifp) @@ -2275,7 +2273,7 @@ vtnet_start(struct ifnet *ifp) VTNET_TXQ_UNLOCK(txq); } -#else /* !VTNET_LEGACY_TX */ + static int vtnet_txq_mq_start_locked(struct vtnet_txq *txq, struct mbuf *m) @@ -2387,7 +2385,7 @@ vtnet_txq_tq_deferred(void *xtxq, int pending) VTNET_TXQ_UNLOCK(txq); } -#endif /* VTNET_LEGACY_TX */ + static void vtnet_txq_start(struct vtnet_txq *txq) @@ -2398,13 +2396,13 @@ vtnet_txq_start(struct vtnet_txq *txq) sc = txq->vtntx_sc; ifp = sc->vtnet_ifp; -#ifdef VTNET_LEGACY_TX + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) vtnet_start_locked(txq, ifp); -#else + if (!drbr_empty(ifp, txq->vtntx_br)) vtnet_txq_mq_start_locked(txq, NULL); -#endif + } static void diff --git a/sys/dev/vmware/vmxnet3/if_vmx.c b/sys/dev/vmware/vmxnet3/if_vmx.c index e92cc00..0629f2b 100644 --- a/sys/dev/vmware/vmxnet3/if_vmx.c +++ b/sys/dev/vmware/vmxnet3/if_vmx.c @@ -166,15 +166,15 @@ static int vmxnet3_txq_load_mbuf(struct vmxnet3_txqueue *, struct mbuf **, bus_dmamap_t, bus_dma_segment_t [], int *); static void vmxnet3_txq_unload_mbuf(struct vmxnet3_txqueue *, bus_dmamap_t); static int vmxnet3_txq_encap(struct vmxnet3_txqueue *, struct mbuf **); -#ifdef VMXNET3_LEGACY_TX + static void vmxnet3_start_locked(struct ifnet *); static void vmxnet3_start(struct ifnet *); -#else + static int vmxnet3_txq_mq_start_locked(struct vmxnet3_txqueue *, struct mbuf *); static int vmxnet3_txq_mq_start(struct ifnet *, struct mbuf *); static void vmxnet3_txq_tq_deferred(void *, int); -#endif + static void vmxnet3_txq_start(struct vmxnet3_txqueue *); static void vmxnet3_tx_start_all(struct vmxnet3_softc *); @@ -1731,15 +1731,15 @@ vmxnet3_setup_interface(struct vmxnet3_softc *sc) ifp->if_hw_tsomaxsegcount = VMXNET3_TX_MAXSEGS; ifp->if_hw_tsomaxsegsize = VMXNET3_TX_MAXSEGSIZE; -#ifdef VMXNET3_LEGACY_TX + ifp->if_start = vmxnet3_start; ifp->if_snd.ifq_drv_maxlen = sc->vmx_ntxdescs - 1; IFQ_SET_MAXLEN(&ifp->if_snd, sc->vmx_ntxdescs - 1); IFQ_SET_READY(&ifp->if_snd); -#else + ifp->if_transmit = vmxnet3_txq_mq_start; ifp->if_qflush = vmxnet3_qflush; -#endif + vmxnet3_get_lladdr(sc); ether_ifattach(ifp, sc->vmx_lladdr); @@ -2872,7 +2872,7 @@ vmxnet3_txq_encap(struct vmxnet3_txqueue *txq, struct mbuf **m0) return (0); } -#ifdef VMXNET3_LEGACY_TX + static void vmxnet3_start_locked(struct ifnet *ifp) @@ -2936,7 +2936,7 @@ vmxnet3_start(struct ifnet *ifp) VMXNET3_TXQ_UNLOCK(txq); } -#else /* !VMXNET3_LEGACY_TX */ + static int vmxnet3_txq_mq_start_locked(struct vmxnet3_txqueue *txq, struct mbuf *m) @@ -3043,7 +3043,7 @@ vmxnet3_txq_tq_deferred(void *xtxq, int pending) VMXNET3_TXQ_UNLOCK(txq); } -#endif /* VMXNET3_LEGACY_TX */ + static void vmxnet3_txq_start(struct vmxnet3_txqueue *txq) @@ -3054,13 +3054,13 @@ vmxnet3_txq_start(struct vmxnet3_txqueue *txq) sc = txq->vxtxq_sc; ifp = sc->vmx_ifp; -#ifdef VMXNET3_LEGACY_TX + if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) vmxnet3_start_locked(ifp); -#else + if (!drbr_empty(ifp, txq->vxtxq_br)) vmxnet3_txq_mq_start_locked(txq, NULL); -#endif + } static void diff --git a/sys/dev/wi/if_wi.c b/sys/dev/wi/if_wi.c index 5442d3d..6d58c5c 100644 --- a/sys/dev/wi/if_wi.c +++ b/sys/dev/wi/if_wi.c @@ -87,6 +87,7 @@ __FBSDID("$FreeBSD$"); #include <sys/rman.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> @@ -131,6 +132,7 @@ static int wi_reset(struct wi_softc *); static void wi_watchdog(void *); static int wi_ioctl(struct ifnet *, u_long, caddr_t); static void wi_media_status(struct ifnet *, struct ifmediareq *); +static uint64_t wi_get_counter(struct ifnet *, ift_counter); static void wi_rx_intr(struct wi_softc *); static void wi_tx_intr(struct wi_softc *); @@ -336,6 +338,7 @@ wi_attach(device_t dev) ifp->if_ioctl = wi_ioctl; ifp->if_start = wi_start; ifp->if_init = wi_init; + //ifp->if_get_counter = wi_get_counter; IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; IFQ_SET_READY(&ifp->if_snd); @@ -1027,7 +1030,7 @@ wi_start_locked(struct ifnet *ifp) continue; sc->sc_txnext = cur = (cur + 1) % sc->sc_ntxbuf; - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); } } @@ -1054,7 +1057,7 @@ wi_start_tx(struct ifnet *ifp, struct wi_frame *frmhdr, struct mbuf *m0) || wi_mwrite_bap(sc, fid, off, m0, m0->m_pkthdr.len) != 0; m_freem(m0); if (error) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return -1; } sc->sc_txd[cur].d_len = off; @@ -1181,7 +1184,7 @@ wi_watchdog(void *arg) if (sc->sc_tx_timer && --sc->sc_tx_timer == 0) { if_printf(ifp, "device timeout\n"); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); wi_init_locked(ifp->if_softc); return; } @@ -1326,7 +1329,7 @@ wi_rx_intr(struct wi_softc *sc) /* First read in the frame header */ if (wi_read_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr))) { CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF(("wi_rx_intr: read fid %x failed\n", fid)); return; } @@ -1337,7 +1340,7 @@ wi_rx_intr(struct wi_softc *sc) status = le16toh(frmhdr.wi_status); if (status & WI_STAT_ERRSTAT) { CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF(("wi_rx_intr: fid %x error status %x\n", fid, status)); return; } @@ -1352,7 +1355,7 @@ wi_rx_intr(struct wi_softc *sc) if (off + len > MCLBYTES) { if (ic->ic_opmode != IEEE80211_M_MONITOR) { CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF(("wi_rx_intr: oversized packet\n")); return; } else @@ -1365,7 +1368,7 @@ wi_rx_intr(struct wi_softc *sc) m = m_gethdr(M_NOWAIT, MT_DATA); if (m == NULL) { CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX); - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); DPRINTF(("wi_rx_intr: MGET failed\n")); return; } @@ -1449,13 +1452,13 @@ wi_tx_ex_intr(struct wi_softc *sc) printf(", status=0x%x", status); printf("\n"); } - ifp->if_oerrors++; - } else { + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + } else DPRINTF(("port disconnected\n")); - ifp->if_collisions++; /* XXX */ - } - } else + } else { DPRINTF(("wi_tx_ex_intr: read fid %x failed\n", fid)); + ifp->if_collisions++; /* XXX */ + } CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX_EXC); } @@ -1496,8 +1499,7 @@ wi_tx_intr(struct wi_softc *sc) static __noinline void wi_info_intr(struct wi_softc *sc) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211com *ic = sc->sc_ifp->if_l2com; struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); int i, fid, len, off; u_int16_t ltbuf[2]; @@ -1561,9 +1563,9 @@ wi_info_intr(struct wi_softc *sc) #endif *ptr += stat; } - ifp->if_collisions = sc->sc_stats.wi_tx_single_retries + - sc->sc_stats.wi_tx_multi_retries + - sc->sc_stats.wi_tx_retry_limit; + sc->sc_ifp->if_collisions = sc->sc_stats.wi_tx_single_retries + + sc->sc_stats.wi_tx_multi_retries + + sc->sc_stats.wi_tx_retry_limit; break; default: DPRINTF(("wi_info_intr: got fid %x type %x len %d\n", fid, @@ -1574,6 +1576,27 @@ finish: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_INFO); } +static uint64_t +wi_get_counter(struct ifnet *ifp, ift_counter cnt) +{ +#if 0 + struct wi_softc *sc; + + sc = if_getsoftc(ifp); + + switch (cnt) { + case IFCOUNTER_COLLISIONS: + return (sc->sc_stats.wi_tx_single_retries + + sc->sc_stats.wi_tx_multi_retries + + sc->sc_stats.wi_tx_retry_limit); + default: + return (if_get_counter_default(ifp, cnt)); + } +#else + return 0; +#endif +} + static int wi_write_multi(struct wi_softc *sc) { diff --git a/sys/dev/wi/if_wi_pccard.c b/sys/dev/wi/if_wi_pccard.c index 382a3a3..fd70e77 100644 --- a/sys/dev/wi/if_wi_pccard.c +++ b/sys/dev/wi/if_wi_pccard.c @@ -43,6 +43,7 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/kernel.h> +#include <sys/malloc.h> #include <sys/socket.h> #include <sys/systm.h> #include <sys/module.h> @@ -62,7 +63,6 @@ __FBSDID("$FreeBSD$"); #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_radiotap.h> -#define PCCARD_API_LEVEL 6 #include <dev/pccard/pccardvar.h> #include <dev/pccard/pccard_cis.h> diff --git a/sys/dev/wi/if_wi_pci.c b/sys/dev/wi/if_wi_pci.c index 30cdbc4..198c599 100644 --- a/sys/dev/wi/if_wi_pci.c +++ b/sys/dev/wi/if_wi_pci.c @@ -55,6 +55,7 @@ #include <dev/pci/pcivar.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_media.h> diff --git a/sys/dev/wpi/if_wpi.c b/sys/dev/wpi/if_wpi.c index 6b3929e..7b438c7 100644 --- a/sys/dev/wpi/if_wpi.c +++ b/sys/dev/wpi/if_wpi.c @@ -16,8 +16,6 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#define VERSION "20071127" - #include <sys/cdefs.h> __FBSDID("$FreeBSD$"); @@ -44,7 +42,7 @@ __FBSDID("$FreeBSD$"); * * A similar thing happens with the tx rings. The difference is the firmware * stop processing buffers once the queue is full and until confirmation - * of a successful transmition (tx_intr) has occurred. + * of a successful transmition (tx_done) has occurred. * * The command ring operates in the same manner as the tx queues. * @@ -60,6 +58,7 @@ __FBSDID("$FreeBSD$"); */ #include "opt_wlan.h" +#include "opt_wpi.h" #include <sys/param.h> #include <sys/sysctl.h> @@ -86,58 +85,27 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_arp.h> #include <net/ethernet.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> -#include <net80211/ieee80211_var.h> -#include <net80211/ieee80211_radiotap.h> -#include <net80211/ieee80211_regdomain.h> -#include <net80211/ieee80211_ratectl.h> - #include <netinet/in.h> #include <netinet/in_systm.h> #include <netinet/in_var.h> -#include <netinet/ip.h> #include <netinet/if_ether.h> +#include <netinet/ip.h> + +#include <net80211/ieee80211_var.h> +#include <net80211/ieee80211_radiotap.h> +#include <net80211/ieee80211_regdomain.h> +#include <net80211/ieee80211_ratectl.h> #include <dev/wpi/if_wpireg.h> #include <dev/wpi/if_wpivar.h> - -#define WPI_DEBUG - -#ifdef WPI_DEBUG -#define DPRINTF(x) do { if (wpi_debug != 0) printf x; } while (0) -#define DPRINTFN(n, x) do { if (wpi_debug & n) printf x; } while (0) -#define WPI_DEBUG_SET (wpi_debug != 0) - -enum { - WPI_DEBUG_UNUSED = 0x00000001, /* Unused */ - WPI_DEBUG_HW = 0x00000002, /* Stage 1 (eeprom) debugging */ - WPI_DEBUG_TX = 0x00000004, /* Stage 2 TX intrp debugging*/ - WPI_DEBUG_RX = 0x00000008, /* Stage 2 RX intrp debugging */ - WPI_DEBUG_CMD = 0x00000010, /* Stage 2 CMD intrp debugging*/ - WPI_DEBUG_FIRMWARE = 0x00000020, /* firmware(9) loading debug */ - WPI_DEBUG_DMA = 0x00000040, /* DMA (de)allocations/syncs */ - WPI_DEBUG_SCANNING = 0x00000080, /* Stage 2 Scanning debugging */ - WPI_DEBUG_NOTIFY = 0x00000100, /* State 2 Noftif intr debug */ - WPI_DEBUG_TEMP = 0x00000200, /* TXPower/Temp Calibration */ - WPI_DEBUG_OPS = 0x00000400, /* wpi_ops taskq debug */ - WPI_DEBUG_WATCHDOG = 0x00000800, /* Watch dog debug */ - WPI_DEBUG_ANY = 0xffffffff -}; - -static int wpi_debug = 0; -SYSCTL_INT(_debug, OID_AUTO, wpi, CTLFLAG_RW, &wpi_debug, 0, "wpi debug level"); -TUNABLE_INT("debug.wpi", &wpi_debug); - -#else -#define DPRINTF(x) -#define DPRINTFN(n, x) -#define WPI_DEBUG_SET 0 -#endif +#include <dev/wpi/if_wpi_debug.h> struct wpi_ident { uint16_t vendor; @@ -158,99 +126,160 @@ static const struct wpi_ident wpi_ident_table[] = { { 0, 0, 0, NULL } }; +static int wpi_probe(device_t); +static int wpi_attach(device_t); +static void wpi_radiotap_attach(struct wpi_softc *); +static void wpi_sysctlattach(struct wpi_softc *); +static void wpi_init_beacon(struct wpi_vap *); static struct ieee80211vap *wpi_vap_create(struct ieee80211com *, const char [IFNAMSIZ], int, enum ieee80211_opmode, int, const uint8_t [IEEE80211_ADDR_LEN], const uint8_t [IEEE80211_ADDR_LEN]); static void wpi_vap_delete(struct ieee80211vap *); +static int wpi_detach(device_t); +static int wpi_shutdown(device_t); +static int wpi_suspend(device_t); +static int wpi_resume(device_t); +static int wpi_nic_lock(struct wpi_softc *); +static int wpi_read_prom_data(struct wpi_softc *, uint32_t, void *, int); +static void wpi_dma_map_addr(void *, bus_dma_segment_t *, int, int); static int wpi_dma_contig_alloc(struct wpi_softc *, struct wpi_dma_info *, - void **, bus_size_t, bus_size_t, int); + void **, bus_size_t, bus_size_t); static void wpi_dma_contig_free(struct wpi_dma_info *); -static void wpi_dma_map_addr(void *, bus_dma_segment_t *, int, int); static int wpi_alloc_shared(struct wpi_softc *); static void wpi_free_shared(struct wpi_softc *); -static int wpi_alloc_rx_ring(struct wpi_softc *, struct wpi_rx_ring *); -static void wpi_reset_rx_ring(struct wpi_softc *, struct wpi_rx_ring *); -static void wpi_free_rx_ring(struct wpi_softc *, struct wpi_rx_ring *); +static int wpi_alloc_fwmem(struct wpi_softc *); +static void wpi_free_fwmem(struct wpi_softc *); +static int wpi_alloc_rx_ring(struct wpi_softc *); +static void wpi_update_rx_ring(struct wpi_softc *); +static void wpi_update_rx_ring_ps(struct wpi_softc *); +static void wpi_reset_rx_ring(struct wpi_softc *); +static void wpi_free_rx_ring(struct wpi_softc *); static int wpi_alloc_tx_ring(struct wpi_softc *, struct wpi_tx_ring *, - int, int); + int); +static void wpi_update_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); +static void wpi_update_tx_ring_ps(struct wpi_softc *, + struct wpi_tx_ring *); static void wpi_reset_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); static void wpi_free_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); +static int wpi_read_eeprom(struct wpi_softc *, + uint8_t macaddr[IEEE80211_ADDR_LEN]); +static uint32_t wpi_eeprom_channel_flags(struct wpi_eeprom_chan *); +static void wpi_read_eeprom_band(struct wpi_softc *, int); +static int wpi_read_eeprom_channels(struct wpi_softc *, int); +static struct wpi_eeprom_chan *wpi_find_eeprom_channel(struct wpi_softc *, + struct ieee80211_channel *); +static int wpi_setregdomain(struct ieee80211com *, + struct ieee80211_regdomain *, int, + struct ieee80211_channel[]); +static int wpi_read_eeprom_group(struct wpi_softc *, int); +static int wpi_add_node_entry_adhoc(struct wpi_softc *); +static struct ieee80211_node *wpi_node_alloc(struct ieee80211vap *, + const uint8_t mac[IEEE80211_ADDR_LEN]); +static void wpi_node_free(struct ieee80211_node *); +static void wpi_recv_mgmt(struct ieee80211_node *, struct mbuf *, int, int, + int); +static void wpi_restore_node(void *, struct ieee80211_node *); +static void wpi_restore_node_table(struct wpi_softc *, struct wpi_vap *); static int wpi_newstate(struct ieee80211vap *, enum ieee80211_state, int); -static void wpi_mem_lock(struct wpi_softc *); -static void wpi_mem_unlock(struct wpi_softc *); -static uint32_t wpi_mem_read(struct wpi_softc *, uint16_t); -static void wpi_mem_write(struct wpi_softc *, uint16_t, uint32_t); -static void wpi_mem_write_region_4(struct wpi_softc *, uint16_t, - const uint32_t *, int); -static uint16_t wpi_read_prom_data(struct wpi_softc *, uint32_t, void *, int); -static int wpi_alloc_fwmem(struct wpi_softc *); -static void wpi_free_fwmem(struct wpi_softc *); -static int wpi_load_firmware(struct wpi_softc *); -static void wpi_unload_firmware(struct wpi_softc *); -static int wpi_load_microcode(struct wpi_softc *, const uint8_t *, int); -static void wpi_rx_intr(struct wpi_softc *, struct wpi_rx_desc *, +static void wpi_calib_timeout(void *); +static void wpi_rx_done(struct wpi_softc *, struct wpi_rx_desc *, + struct wpi_rx_data *); +static void wpi_rx_statistics(struct wpi_softc *, struct wpi_rx_desc *, struct wpi_rx_data *); -static void wpi_tx_intr(struct wpi_softc *, struct wpi_rx_desc *); -static void wpi_cmd_intr(struct wpi_softc *, struct wpi_rx_desc *); +static void wpi_tx_done(struct wpi_softc *, struct wpi_rx_desc *); +static void wpi_cmd_done(struct wpi_softc *, struct wpi_rx_desc *); static void wpi_notif_intr(struct wpi_softc *); +static void wpi_wakeup_intr(struct wpi_softc *); +#ifdef WPI_DEBUG +static void wpi_debug_registers(struct wpi_softc *); +#endif +static void wpi_fatal_intr(struct wpi_softc *); static void wpi_intr(void *); -static uint8_t wpi_plcp_signal(int); -static void wpi_watchdog(void *); +static int wpi_cmd2(struct wpi_softc *, struct wpi_buf *); static int wpi_tx_data(struct wpi_softc *, struct mbuf *, - struct ieee80211_node *, int); -static void wpi_start(struct ifnet *); -static void wpi_start_locked(struct ifnet *); + struct ieee80211_node *); +static int wpi_tx_data_raw(struct wpi_softc *, struct mbuf *, + struct ieee80211_node *, + const struct ieee80211_bpf_params *); static int wpi_raw_xmit(struct ieee80211_node *, struct mbuf *, const struct ieee80211_bpf_params *); -static void wpi_scan_start(struct ieee80211com *); -static void wpi_scan_end(struct ieee80211com *); -static void wpi_set_channel(struct ieee80211com *); -static void wpi_scan_curchan(struct ieee80211_scan_state *, unsigned long); -static void wpi_scan_mindwell(struct ieee80211_scan_state *); +static void wpi_start(struct ifnet *); +static void wpi_start_task(void *, int); +static void wpi_watchdog_rfkill(void *); +static void wpi_scan_timeout(void *); +static void wpi_tx_timeout(void *); static int wpi_ioctl(struct ifnet *, u_long, caddr_t); -static void wpi_read_eeprom(struct wpi_softc *, - uint8_t macaddr[IEEE80211_ADDR_LEN]); -static void wpi_read_eeprom_channels(struct wpi_softc *, int); -static void wpi_read_eeprom_group(struct wpi_softc *, int); -static int wpi_cmd(struct wpi_softc *, int, const void *, int, int); -static int wpi_wme_update(struct ieee80211com *); +static int wpi_cmd(struct wpi_softc *, int, const void *, size_t, int); static int wpi_mrr_setup(struct wpi_softc *); +static int wpi_add_node(struct wpi_softc *, struct ieee80211_node *); +static int wpi_add_broadcast_node(struct wpi_softc *, int); +static int wpi_add_ibss_node(struct wpi_softc *, struct ieee80211_node *); +static void wpi_del_node(struct wpi_softc *, struct ieee80211_node *); +static int wpi_updateedca(struct ieee80211com *); +static void wpi_set_promisc(struct wpi_softc *); +static void wpi_update_promisc(struct ifnet *); +static void wpi_update_mcast(struct ifnet *); static void wpi_set_led(struct wpi_softc *, uint8_t, uint8_t, uint8_t); -static void wpi_enable_tsf(struct wpi_softc *, struct ieee80211_node *); -#if 0 -static int wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *); -#endif +static int wpi_set_timing(struct wpi_softc *, struct ieee80211_node *); +static void wpi_power_calibration(struct wpi_softc *); +static int wpi_set_txpower(struct wpi_softc *, int); +static int wpi_get_power_index(struct wpi_softc *, + struct wpi_power_group *, uint8_t, int, int); +static int wpi_set_pslevel(struct wpi_softc *, uint8_t, int, int); +static int wpi_send_btcoex(struct wpi_softc *); +static int wpi_send_rxon(struct wpi_softc *, int, int); +static int wpi_config(struct wpi_softc *); +static uint16_t wpi_get_active_dwell_time(struct wpi_softc *, + struct ieee80211_channel *, uint8_t); +static uint16_t wpi_limit_dwell(struct wpi_softc *, uint16_t); +static uint16_t wpi_get_passive_dwell_time(struct wpi_softc *, + struct ieee80211_channel *); +static uint32_t wpi_get_scan_pause_time(uint32_t, uint16_t); +static int wpi_scan(struct wpi_softc *, struct ieee80211_channel *); static int wpi_auth(struct wpi_softc *, struct ieee80211vap *); +static int wpi_config_beacon(struct wpi_vap *); +static int wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *); +static void wpi_update_beacon(struct ieee80211vap *, int); +static void wpi_newassoc(struct ieee80211_node *, int); static int wpi_run(struct wpi_softc *, struct ieee80211vap *); -static int wpi_scan(struct wpi_softc *); -static int wpi_config(struct wpi_softc *); -static void wpi_stop_master(struct wpi_softc *); -static int wpi_power_up(struct wpi_softc *); -static int wpi_reset(struct wpi_softc *); -static void wpi_hwreset(void *, int); -static void wpi_rfreset(void *, int); -static void wpi_hw_config(struct wpi_softc *); +static int wpi_load_key(struct ieee80211_node *, + const struct ieee80211_key *); +static void wpi_load_key_cb(void *, struct ieee80211_node *); +static int wpi_set_global_keys(struct ieee80211_node *); +static int wpi_del_key(struct ieee80211_node *, + const struct ieee80211_key *); +static void wpi_del_key_cb(void *, struct ieee80211_node *); +static int wpi_process_key(struct ieee80211vap *, + const struct ieee80211_key *, int); +static int wpi_key_set(struct ieee80211vap *, + const struct ieee80211_key *, + const uint8_t mac[IEEE80211_ADDR_LEN]); +static int wpi_key_delete(struct ieee80211vap *, + const struct ieee80211_key *); +static int wpi_post_alive(struct wpi_softc *); +static int wpi_load_bootcode(struct wpi_softc *, const uint8_t *, int); +static int wpi_load_firmware(struct wpi_softc *); +static int wpi_read_firmware(struct wpi_softc *); +static void wpi_unload_firmware(struct wpi_softc *); +static int wpi_clock_wait(struct wpi_softc *); +static int wpi_apm_init(struct wpi_softc *); +static void wpi_apm_stop_master(struct wpi_softc *); +static void wpi_apm_stop(struct wpi_softc *); +static void wpi_nic_config(struct wpi_softc *); +static int wpi_hw_init(struct wpi_softc *); +static void wpi_hw_stop(struct wpi_softc *); +static void wpi_radio_on(void *, int); +static void wpi_radio_off(void *, int); static void wpi_init(void *); -static void wpi_init_locked(struct wpi_softc *, int); -static void wpi_stop(struct wpi_softc *); static void wpi_stop_locked(struct wpi_softc *); - -static int wpi_set_txpower(struct wpi_softc *, struct ieee80211_channel *, - int); -static void wpi_calib_timeout(void *); -static void wpi_power_calibration(struct wpi_softc *, int); -static int wpi_get_power_index(struct wpi_softc *, - struct wpi_power_group *, struct ieee80211_channel *, int); -#ifdef WPI_DEBUG -static const char *wpi_cmd_str(int); -#endif -static int wpi_probe(device_t); -static int wpi_attach(device_t); -static int wpi_detach(device_t); -static int wpi_shutdown(device_t); -static int wpi_suspend(device_t); -static int wpi_resume(device_t); +static void wpi_stop(struct wpi_softc *); +static void wpi_scan_start(struct ieee80211com *); +static void wpi_scan_end(struct ieee80211com *); +static void wpi_set_channel(struct ieee80211com *); +static void wpi_scan_curchan(struct ieee80211_scan_state *, unsigned long); +static void wpi_scan_mindwell(struct ieee80211_scan_state *); +static void wpi_hw_reset(void *, int); static device_method_t wpi_methods[] = { /* Device interface */ @@ -269,25 +298,15 @@ static driver_t wpi_driver = { wpi_methods, sizeof (struct wpi_softc) }; - static devclass_t wpi_devclass; DRIVER_MODULE(wpi, pci, wpi_driver, wpi_devclass, NULL, NULL); MODULE_VERSION(wpi, 1); -static const uint8_t wpi_ridx_to_plcp[] = { - /* OFDM: IEEE Std 802.11a-1999, pp. 14 Table 80 */ - /* R1-R4 (ral/ural is R4-R1) */ - 0xd, 0xf, 0x5, 0x7, 0x9, 0xb, 0x1, 0x3, - /* CCK: device-dependent */ - 10, 20, 55, 110 -}; - -static const uint8_t wpi_ridx_to_rate[] = { - 12, 18, 24, 36, 48, 72, 96, 108, /* OFDM */ - 2, 4, 11, 22 /*CCK */ -}; +MODULE_DEPEND(wpi, pci, 1, 1, 1); +MODULE_DEPEND(wpi, wlan, 1, 1, 1); +MODULE_DEPEND(wpi, firmware, 1, 1, 1); static int wpi_probe(device_t dev) @@ -304,208 +323,48 @@ wpi_probe(device_t dev) return ENXIO; } -/** - * Load the firmare image from disk to the allocated dma buffer. - * we also maintain the reference to the firmware pointer as there - * is times where we may need to reload the firmware but we are not - * in a context that can access the filesystem (ie taskq cause by restart) - * - * @return 0 on success, an errno on failure - */ -static int -wpi_load_firmware(struct wpi_softc *sc) -{ - const struct firmware *fp; - struct wpi_dma_info *dma = &sc->fw_dma; - const struct wpi_firmware_hdr *hdr; - const uint8_t *itext, *idata, *rtext, *rdata, *btext; - uint32_t itextsz, idatasz, rtextsz, rdatasz, btextsz; - int error; - - DPRINTFN(WPI_DEBUG_FIRMWARE, - ("Attempting Loading Firmware from wpi_fw module\n")); - - WPI_UNLOCK(sc); - - if (sc->fw_fp == NULL && (sc->fw_fp = firmware_get("wpifw")) == NULL) { - device_printf(sc->sc_dev, - "could not load firmware image 'wpifw'\n"); - error = ENOENT; - WPI_LOCK(sc); - goto fail; - } - - fp = sc->fw_fp; - - WPI_LOCK(sc); - - /* Validate the firmware is minimum a particular version */ - if (fp->version < WPI_FW_MINVERSION) { - device_printf(sc->sc_dev, - "firmware version is too old. Need %d, got %d\n", - WPI_FW_MINVERSION, - fp->version); - error = ENXIO; - goto fail; - } - - if (fp->datasize < sizeof (struct wpi_firmware_hdr)) { - device_printf(sc->sc_dev, - "firmware file too short: %zu bytes\n", fp->datasize); - error = ENXIO; - goto fail; - } - - hdr = (const struct wpi_firmware_hdr *)fp->data; - - /* | RUNTIME FIRMWARE | INIT FIRMWARE | BOOT FW | - |HDR|<--TEXT-->|<--DATA-->|<--TEXT-->|<--DATA-->|<--TEXT-->| */ - - rtextsz = le32toh(hdr->rtextsz); - rdatasz = le32toh(hdr->rdatasz); - itextsz = le32toh(hdr->itextsz); - idatasz = le32toh(hdr->idatasz); - btextsz = le32toh(hdr->btextsz); - - /* check that all firmware segments are present */ - if (fp->datasize < sizeof (struct wpi_firmware_hdr) + - rtextsz + rdatasz + itextsz + idatasz + btextsz) { - device_printf(sc->sc_dev, - "firmware file too short: %zu bytes\n", fp->datasize); - error = ENXIO; /* XXX appropriate error code? */ - goto fail; - } - - /* get pointers to firmware segments */ - rtext = (const uint8_t *)(hdr + 1); - rdata = rtext + rtextsz; - itext = rdata + rdatasz; - idata = itext + itextsz; - btext = idata + idatasz; - - DPRINTFN(WPI_DEBUG_FIRMWARE, - ("Firmware Version: Major %d, Minor %d, Driver %d, \n" - "runtime (text: %u, data: %u) init (text: %u, data %u) boot (text %u)\n", - (le32toh(hdr->version) & 0xff000000) >> 24, - (le32toh(hdr->version) & 0x00ff0000) >> 16, - (le32toh(hdr->version) & 0x0000ffff), - rtextsz, rdatasz, - itextsz, idatasz, btextsz)); - - DPRINTFN(WPI_DEBUG_FIRMWARE,("rtext 0x%x\n", *(const uint32_t *)rtext)); - DPRINTFN(WPI_DEBUG_FIRMWARE,("rdata 0x%x\n", *(const uint32_t *)rdata)); - DPRINTFN(WPI_DEBUG_FIRMWARE,("itext 0x%x\n", *(const uint32_t *)itext)); - DPRINTFN(WPI_DEBUG_FIRMWARE,("idata 0x%x\n", *(const uint32_t *)idata)); - DPRINTFN(WPI_DEBUG_FIRMWARE,("btext 0x%x\n", *(const uint32_t *)btext)); - - /* sanity checks */ - if (rtextsz > WPI_FW_MAIN_TEXT_MAXSZ || - rdatasz > WPI_FW_MAIN_DATA_MAXSZ || - itextsz > WPI_FW_INIT_TEXT_MAXSZ || - idatasz > WPI_FW_INIT_DATA_MAXSZ || - btextsz > WPI_FW_BOOT_TEXT_MAXSZ || - (btextsz & 3) != 0) { - device_printf(sc->sc_dev, "firmware invalid\n"); - error = EINVAL; - goto fail; - } - - /* copy initialization images into pre-allocated DMA-safe memory */ - memcpy(dma->vaddr, idata, idatasz); - memcpy(dma->vaddr + WPI_FW_INIT_DATA_MAXSZ, itext, itextsz); - - bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); - - /* tell adapter where to find initialization images */ - wpi_mem_lock(sc); - wpi_mem_write(sc, WPI_MEM_DATA_BASE, dma->paddr); - wpi_mem_write(sc, WPI_MEM_DATA_SIZE, idatasz); - wpi_mem_write(sc, WPI_MEM_TEXT_BASE, - dma->paddr + WPI_FW_INIT_DATA_MAXSZ); - wpi_mem_write(sc, WPI_MEM_TEXT_SIZE, itextsz); - wpi_mem_unlock(sc); - - /* load firmware boot code */ - if ((error = wpi_load_microcode(sc, btext, btextsz)) != 0) { - device_printf(sc->sc_dev, "Failed to load microcode\n"); - goto fail; - } - - /* now press "execute" */ - WPI_WRITE(sc, WPI_RESET, 0); - - /* wait at most one second for the first alive notification */ - if ((error = msleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { - device_printf(sc->sc_dev, - "timeout waiting for adapter to initialize\n"); - goto fail; - } - - /* copy runtime images into pre-allocated DMA-sage memory */ - memcpy(dma->vaddr, rdata, rdatasz); - memcpy(dma->vaddr + WPI_FW_MAIN_DATA_MAXSZ, rtext, rtextsz); - bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); - - /* tell adapter where to find runtime images */ - wpi_mem_lock(sc); - wpi_mem_write(sc, WPI_MEM_DATA_BASE, dma->paddr); - wpi_mem_write(sc, WPI_MEM_DATA_SIZE, rdatasz); - wpi_mem_write(sc, WPI_MEM_TEXT_BASE, - dma->paddr + WPI_FW_MAIN_DATA_MAXSZ); - wpi_mem_write(sc, WPI_MEM_TEXT_SIZE, WPI_FW_UPDATED | rtextsz); - wpi_mem_unlock(sc); - - /* wait at most one second for the first alive notification */ - if ((error = msleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { - device_printf(sc->sc_dev, - "timeout waiting for adapter to initialize2\n"); - goto fail; - } - - DPRINTFN(WPI_DEBUG_FIRMWARE, - ("Firmware loaded to driver successfully\n")); - return error; -fail: - wpi_unload_firmware(sc); - return error; -} - -/** - * Free the referenced firmware image - */ -static void -wpi_unload_firmware(struct wpi_softc *sc) -{ - - if (sc->fw_fp) { - WPI_UNLOCK(sc); - firmware_put(sc->fw_fp, FIRMWARE_UNLOAD); - WPI_LOCK(sc); - sc->fw_fp = NULL; - } -} - static int wpi_attach(device_t dev) { - struct wpi_softc *sc = device_get_softc(dev); - struct ifnet *ifp; + struct wpi_softc *sc = (struct wpi_softc *)device_get_softc(dev); struct ieee80211com *ic; - int ac, error, rid, supportsa = 1; - uint32_t tmp; + struct ifnet *ifp; + int i, error, rid; +#ifdef WPI_DEBUG + int supportsa = 1; const struct wpi_ident *ident; +#endif uint8_t macaddr[IEEE80211_ADDR_LEN]; sc->sc_dev = dev; - if (bootverbose || WPI_DEBUG_SET) - device_printf(sc->sc_dev,"Driver Revision %s\n", VERSION); +#ifdef WPI_DEBUG + error = resource_int_value(device_get_name(sc->sc_dev), + device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug)); + if (error != 0) + sc->sc_debug = 0; +#else + sc->sc_debug = 0; +#endif + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + /* + * Get the offset of the PCI Express Capability Structure in PCI + * Configuration Space. + */ + error = pci_find_cap(dev, PCIY_EXPRESS, &sc->sc_cap_off); + if (error != 0) { + device_printf(dev, "PCIe capability structure not found!\n"); + return error; + } /* * Some card's only support 802.11b/g not a, check to see if * this is one such card. A 0x0 in the subdevice table indicates * the entire subdevice range is to be ignored. */ +#ifdef WPI_DEBUG for (ident = wpi_ident_table; ident->name != NULL; ident++) { if (ident->subdevice && pci_get_subdevice(dev) == ident->subdevice) { @@ -513,143 +372,133 @@ wpi_attach(device_t dev) break; } } +#endif - /* Create the tasks that can be queued */ - TASK_INIT(&sc->sc_restarttask, 0, wpi_hwreset, sc); - TASK_INIT(&sc->sc_radiotask, 0, wpi_rfreset, sc); - - WPI_LOCK_INIT(sc); - - callout_init_mtx(&sc->calib_to, &sc->sc_mtx, 0); - callout_init_mtx(&sc->watchdog_to, &sc->sc_mtx, 0); - - /* disable the retry timeout register */ + /* Clear device-specific "PCI retry timeout" register (41h). */ pci_write_config(dev, 0x41, 0, 1); - /* enable bus-mastering */ + /* Enable bus-mastering. */ pci_enable_busmaster(dev); rid = PCIR_BAR(0); sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE); if (sc->mem == NULL) { - device_printf(dev, "could not allocate memory resource\n"); - error = ENOMEM; - goto fail; + device_printf(dev, "can't map mem space\n"); + return ENOMEM; } - sc->sc_st = rman_get_bustag(sc->mem); sc->sc_sh = rman_get_bushandle(sc->mem); + i = 1; rid = 0; - sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, - RF_ACTIVE | RF_SHAREABLE); + if (pci_alloc_msi(dev, &i) == 0) + rid = 1; + /* Install interrupt handler. */ + sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | + (rid != 0 ? 0 : RF_SHAREABLE)); if (sc->irq == NULL) { - device_printf(dev, "could not allocate interrupt resource\n"); + device_printf(dev, "can't map interrupt\n"); error = ENOMEM; goto fail; } - /* - * Allocate DMA memory for firmware transfers. - */ - if ((error = wpi_alloc_fwmem(sc)) != 0) { - printf(": could not allocate firmware memory\n"); - error = ENOMEM; - goto fail; - } + WPI_LOCK_INIT(sc); + WPI_TX_LOCK_INIT(sc); + WPI_RXON_LOCK_INIT(sc); + WPI_NT_LOCK_INIT(sc); + WPI_TXQ_LOCK_INIT(sc); + WPI_TXQ_STATE_LOCK_INIT(sc); - /* - * Put adapter into a known state. - */ - if ((error = wpi_reset(sc)) != 0) { - device_printf(dev, "could not reset adapter\n"); + /* Allocate DMA memory for firmware transfers. */ + if ((error = wpi_alloc_fwmem(sc)) != 0) { + device_printf(dev, + "could not allocate memory for firmware, error %d\n", + error); goto fail; } - wpi_mem_lock(sc); - tmp = wpi_mem_read(sc, WPI_MEM_PCIDEV); - if (bootverbose || WPI_DEBUG_SET) - device_printf(sc->sc_dev, "Hardware Revision (0x%X)\n", tmp); - - wpi_mem_unlock(sc); - - /* Allocate shared page */ + /* Allocate shared page. */ if ((error = wpi_alloc_shared(sc)) != 0) { device_printf(dev, "could not allocate shared page\n"); goto fail; } - /* tx data queues - 4 for QoS purposes */ - for (ac = 0; ac < WME_NUM_AC; ac++) { - error = wpi_alloc_tx_ring(sc, &sc->txq[ac], WPI_TX_RING_COUNT, ac); - if (error != 0) { - device_printf(dev, "could not allocate Tx ring %d\n",ac); - goto fail; + /* Allocate TX rings - 4 for QoS purposes, 1 for commands. */ + for (i = 0; i < WPI_NTXQUEUES; i++) { + if ((error = wpi_alloc_tx_ring(sc, &sc->txq[i], i)) != 0) { + device_printf(dev, + "could not allocate TX ring %d, error %d\n", i, + error); + goto fail; } } - /* command queue to talk to the card's firmware */ - error = wpi_alloc_tx_ring(sc, &sc->cmdq, WPI_CMD_RING_COUNT, 4); - if (error != 0) { - device_printf(dev, "could not allocate command ring\n"); + /* Allocate RX ring. */ + if ((error = wpi_alloc_rx_ring(sc)) != 0) { + device_printf(dev, "could not allocate RX ring, error %d\n", + error); goto fail; } - /* receive data queue */ - error = wpi_alloc_rx_ring(sc, &sc->rxq); - if (error != 0) { - device_printf(dev, "could not allocate Rx ring\n"); - goto fail; - } + /* Clear pending interrupts. */ + WPI_WRITE(sc, WPI_INT, 0xffffffff); ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211); if (ifp == NULL) { - device_printf(dev, "can not if_alloc()\n"); - error = ENOMEM; + device_printf(dev, "can not allocate ifnet structure\n"); goto fail; } - ic = ifp->if_l2com; + ic = ifp->if_l2com; ic->ic_ifp = ifp; ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ - /* set device capabilities */ + /* Set device capabilities. */ ic->ic_caps = IEEE80211_C_STA /* station mode supported */ + | IEEE80211_C_IBSS /* IBSS mode supported */ + | IEEE80211_C_HOSTAP /* Host access point mode */ | IEEE80211_C_MONITOR /* monitor mode supported */ + | IEEE80211_C_AHDEMO /* adhoc demo mode */ + | IEEE80211_C_BGSCAN /* capable of bg scanning */ | IEEE80211_C_TXPMGT /* tx power management */ | IEEE80211_C_SHSLOT /* short slot time supported */ - | IEEE80211_C_SHPREAMBLE /* short preamble supported */ | IEEE80211_C_WPA /* 802.11i */ -/* XXX looks like WME is partly supported? */ -#if 0 - | IEEE80211_C_IBSS /* IBSS mode support */ - | IEEE80211_C_BGSCAN /* capable of bg scanning */ + | IEEE80211_C_SHPREAMBLE /* short preamble supported */ | IEEE80211_C_WME /* 802.11e */ - | IEEE80211_C_HOSTAP /* Host access point mode */ -#endif + | IEEE80211_C_PMGT /* Station-side power mgmt */ ; + ic->ic_cryptocaps = + IEEE80211_CRYPTO_AES_CCM; + /* * Read in the eeprom and also setup the channels for * net80211. We don't set the rates as net80211 does this for us */ - wpi_read_eeprom(sc, macaddr); - - if (bootverbose || WPI_DEBUG_SET) { - device_printf(sc->sc_dev, "Regulatory Domain: %.4s\n", sc->domain); - device_printf(sc->sc_dev, "Hardware Type: %c\n", - sc->type > 1 ? 'B': '?'); - device_printf(sc->sc_dev, "Hardware Revision: %c\n", - ((le16toh(sc->rev) & 0xf0) == 0xd0) ? 'D': '?'); - device_printf(sc->sc_dev, "SKU %s support 802.11a\n", - supportsa ? "does" : "does not"); + if ((error = wpi_read_eeprom(sc, macaddr)) != 0) { + device_printf(dev, "could not read EEPROM, error %d\n", + error); + goto fail; + } - /* XXX hw_config uses the PCIDEV for the Hardware rev. Must check - what sc->rev really represents - benjsc 20070615 */ +#ifdef WPI_DEBUG + if (bootverbose) { + device_printf(sc->sc_dev, "Regulatory Domain: %.4s\n", + sc->domain); + device_printf(sc->sc_dev, "Hardware Type: %c\n", + sc->type > 1 ? 'B': '?'); + device_printf(sc->sc_dev, "Hardware Revision: %c\n", + ((sc->rev & 0xf0) == 0xd0) ? 'D': '?'); + device_printf(sc->sc_dev, "SKU %s support 802.11a\n", + supportsa ? "does" : "does not"); + + /* XXX hw_config uses the PCIDEV for the Hardware rev. Must + check what sc->rev really represents - benjsc 20070615 */ } +#endif if_initname(ifp, device_get_name(dev), device_get_unit(dev)); ifp->if_softc = sc; @@ -662,43 +511,186 @@ wpi_attach(device_t dev) IFQ_SET_READY(&ifp->if_snd); ieee80211_ifattach(ic, macaddr); - /* override default methods */ + ic->ic_vap_create = wpi_vap_create; + ic->ic_vap_delete = wpi_vap_delete; ic->ic_raw_xmit = wpi_raw_xmit; - ic->ic_wme.wme_update = wpi_wme_update; + ic->ic_node_alloc = wpi_node_alloc; + sc->sc_node_free = ic->ic_node_free; + ic->ic_node_free = wpi_node_free; + ic->ic_wme.wme_update = wpi_updateedca; + ic->ic_update_promisc = wpi_update_promisc; + ic->ic_update_mcast = wpi_update_mcast; + ic->ic_newassoc = wpi_newassoc; ic->ic_scan_start = wpi_scan_start; ic->ic_scan_end = wpi_scan_end; ic->ic_set_channel = wpi_set_channel; ic->ic_scan_curchan = wpi_scan_curchan; ic->ic_scan_mindwell = wpi_scan_mindwell; + ic->ic_setregdomain = wpi_setregdomain; - ic->ic_vap_create = wpi_vap_create; - ic->ic_vap_delete = wpi_vap_delete; + sc->sc_update_rx_ring = wpi_update_rx_ring; + sc->sc_update_tx_ring = wpi_update_tx_ring; - ieee80211_radiotap_attach(ic, - &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap), - WPI_TX_RADIOTAP_PRESENT, - &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), - WPI_RX_RADIOTAP_PRESENT); + wpi_radiotap_attach(sc); + + callout_init_mtx(&sc->calib_to, &sc->rxon_mtx, 0); + callout_init_mtx(&sc->scan_timeout, &sc->rxon_mtx, 0); + callout_init_mtx(&sc->tx_timeout, &sc->txq_state_mtx, 0); + callout_init_mtx(&sc->watchdog_rfkill, &sc->sc_mtx, 0); + TASK_INIT(&sc->sc_reinittask, 0, wpi_hw_reset, sc); + TASK_INIT(&sc->sc_radiooff_task, 0, wpi_radio_off, sc); + TASK_INIT(&sc->sc_radioon_task, 0, wpi_radio_on, sc); + TASK_INIT(&sc->sc_start_task, 0, wpi_start_task, sc); + + sc->sc_tq = taskqueue_create("wpi_taskq", M_WAITOK, + taskqueue_thread_enqueue, &sc->sc_tq); + error = taskqueue_start_threads(&sc->sc_tq, 1, 0, "wpi_taskq"); + if (error != 0) { + device_printf(dev, "can't start threads, error %d\n", error); + goto fail; + } + + wpi_sysctlattach(sc); /* * Hook our interrupt after all initialization is complete. */ - error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET |INTR_MPSAFE, + error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, NULL, wpi_intr, sc, &sc->sc_ih); if (error != 0) { - device_printf(dev, "could not set up interrupt\n"); + device_printf(dev, "can't establish interrupt, error %d\n", + error); goto fail; } if (bootverbose) ieee80211_announce(ic); -#ifdef XXX_DEBUG - ieee80211_announce_channels(ic); + +#ifdef WPI_DEBUG + if (sc->sc_debug & WPI_DEBUG_HW) + ieee80211_announce_channels(ic); #endif + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); return 0; fail: wpi_detach(dev); - return ENXIO; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + return error; +} + +/* + * Attach the interface to 802.11 radiotap. + */ +static void +wpi_radiotap_attach(struct wpi_softc *sc) +{ + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + ieee80211_radiotap_attach(ic, + &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap), + WPI_TX_RADIOTAP_PRESENT, + &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), + WPI_RX_RADIOTAP_PRESENT); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); +} + +static void +wpi_sysctlattach(struct wpi_softc *sc) +{ +#ifdef WPI_DEBUG + struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); + struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); + + SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, + "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug, + "control debugging printfs"); +#endif +} + +static void +wpi_init_beacon(struct wpi_vap *wvp) +{ + struct wpi_buf *bcn = &wvp->wv_bcbuf; + struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; + + cmd->id = WPI_ID_BROADCAST; + cmd->ofdm_mask = 0xff; + cmd->cck_mask = 0x0f; + cmd->lifetime = htole32(WPI_LIFETIME_INFINITE); + + /* + * XXX WPI_TX_AUTO_SEQ seems to be ignored - workaround this issue + * XXX by using WPI_TX_NEED_ACK instead (with some side effects). + */ + cmd->flags = htole32(WPI_TX_NEED_ACK | WPI_TX_INSERT_TSTAMP); + + bcn->code = WPI_CMD_SET_BEACON; + bcn->ac = WPI_CMD_QUEUE_NUM; + bcn->size = sizeof(struct wpi_cmd_beacon); +} + +static struct ieee80211vap * +wpi_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, + enum ieee80211_opmode opmode, int flags, + const uint8_t bssid[IEEE80211_ADDR_LEN], + const uint8_t mac[IEEE80211_ADDR_LEN]) +{ + struct wpi_vap *wvp; + struct ieee80211vap *vap; + + if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ + return NULL; + + wvp = (struct wpi_vap *) malloc(sizeof(struct wpi_vap), + M_80211_VAP, M_NOWAIT | M_ZERO); + if (wvp == NULL) + return NULL; + vap = &wvp->wv_vap; + ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac); + + if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) { + WPI_VAP_LOCK_INIT(wvp); + wpi_init_beacon(wvp); + } + + /* Override with driver methods. */ + vap->iv_key_set = wpi_key_set; + vap->iv_key_delete = wpi_key_delete; + wvp->wv_recv_mgmt = vap->iv_recv_mgmt; + vap->iv_recv_mgmt = wpi_recv_mgmt; + wvp->wv_newstate = vap->iv_newstate; + vap->iv_newstate = wpi_newstate; + vap->iv_update_beacon = wpi_update_beacon; + vap->iv_max_aid = WPI_ID_IBSS_MAX - WPI_ID_IBSS_MIN + 1; + + ieee80211_ratectl_init(vap); + /* Complete setup. */ + ieee80211_vap_attach(vap, ieee80211_media_change, + ieee80211_media_status); + ic->ic_opmode = opmode; + return vap; +} + +static void +wpi_vap_delete(struct ieee80211vap *vap) +{ + struct wpi_vap *wvp = WPI_VAP(vap); + struct wpi_buf *bcn = &wvp->wv_bcbuf; + enum ieee80211_opmode opmode = vap->iv_opmode; + + ieee80211_ratectl_deinit(vap); + ieee80211_vap_detach(vap); + + if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) { + if (bcn->m != NULL) + m_freem(bcn->m); + + WPI_VAP_LOCK_DESTROY(wvp); + } + + free(wvp, M_80211_VAP); } static int @@ -707,43 +699,48 @@ wpi_detach(device_t dev) struct wpi_softc *sc = device_get_softc(dev); struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic; - int ac; + int qid; - if (sc->irq != NULL) - bus_teardown_intr(dev, sc->irq, sc->sc_ih); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); if (ifp != NULL) { ic = ifp->if_l2com; - ieee80211_draintask(ic, &sc->sc_restarttask); - ieee80211_draintask(ic, &sc->sc_radiotask); + ieee80211_draintask(ic, &sc->sc_radioon_task); + ieee80211_draintask(ic, &sc->sc_start_task); + wpi_stop(sc); - callout_drain(&sc->watchdog_to); + + taskqueue_drain_all(sc->sc_tq); + taskqueue_free(sc->sc_tq); + + callout_drain(&sc->watchdog_rfkill); + callout_drain(&sc->tx_timeout); + callout_drain(&sc->scan_timeout); callout_drain(&sc->calib_to); ieee80211_ifdetach(ic); } - WPI_LOCK(sc); + /* Uninstall interrupt handler. */ + if (sc->irq != NULL) { + bus_teardown_intr(dev, sc->irq, sc->sc_ih); + bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), + sc->irq); + pci_release_msi(dev); + } + if (sc->txq[0].data_dmat) { - for (ac = 0; ac < WME_NUM_AC; ac++) - wpi_free_tx_ring(sc, &sc->txq[ac]); + /* Free DMA resources. */ + for (qid = 0; qid < WPI_NTXQUEUES; qid++) + wpi_free_tx_ring(sc, &sc->txq[qid]); - wpi_free_tx_ring(sc, &sc->cmdq); - wpi_free_rx_ring(sc, &sc->rxq); + wpi_free_rx_ring(sc); wpi_free_shared(sc); } - if (sc->fw_fp != NULL) { - wpi_unload_firmware(sc); - } - if (sc->fw_dma.tag) wpi_free_fwmem(sc); - WPI_UNLOCK(sc); - - if (sc->irq != NULL) - bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), - sc->irq); + if (sc->mem != NULL) bus_release_resource(dev, SYS_RES_MEMORY, rman_get_rid(sc->mem), sc->mem); @@ -751,47 +748,169 @@ wpi_detach(device_t dev) if (ifp != NULL) if_free(ifp); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + WPI_TXQ_STATE_LOCK_DESTROY(sc); + WPI_TXQ_LOCK_DESTROY(sc); + WPI_NT_LOCK_DESTROY(sc); + WPI_RXON_LOCK_DESTROY(sc); + WPI_TX_LOCK_DESTROY(sc); WPI_LOCK_DESTROY(sc); + return 0; +} +static int +wpi_shutdown(device_t dev) +{ + struct wpi_softc *sc = device_get_softc(dev); + + wpi_stop(sc); return 0; } -static struct ieee80211vap * -wpi_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, - enum ieee80211_opmode opmode, int flags, - const uint8_t bssid[IEEE80211_ADDR_LEN], - const uint8_t mac[IEEE80211_ADDR_LEN]) +static int +wpi_suspend(device_t dev) { - struct wpi_vap *wvp; - struct ieee80211vap *vap; + struct wpi_softc *sc = device_get_softc(dev); + struct ieee80211com *ic = sc->sc_ifp->if_l2com; - if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ - return NULL; - wvp = (struct wpi_vap *) malloc(sizeof(struct wpi_vap), - M_80211_VAP, M_NOWAIT | M_ZERO); - if (wvp == NULL) - return NULL; - vap = &wvp->vap; - ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac); - /* override with driver methods */ - wvp->newstate = vap->iv_newstate; - vap->iv_newstate = wpi_newstate; + ieee80211_suspend_all(ic); + return 0; +} - ieee80211_ratectl_init(vap); - /* complete setup */ - ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status); - ic->ic_opmode = opmode; - return vap; +static int +wpi_resume(device_t dev) +{ + struct wpi_softc *sc = device_get_softc(dev); + struct ieee80211com *ic = sc->sc_ifp->if_l2com; + + /* Clear device-specific "PCI retry timeout" register (41h). */ + pci_write_config(dev, 0x41, 0, 1); + + ieee80211_resume_all(ic); + return 0; } -static void -wpi_vap_delete(struct ieee80211vap *vap) +/* + * Grab exclusive access to NIC memory. + */ +static int +wpi_nic_lock(struct wpi_softc *sc) { - struct wpi_vap *wvp = WPI_VAP(vap); + int ntries; - ieee80211_ratectl_deinit(vap); - ieee80211_vap_detach(vap); - free(wvp, M_80211_VAP); + /* Request exclusive access to NIC. */ + WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); + + /* Spin until we actually get the lock. */ + for (ntries = 0; ntries < 1000; ntries++) { + if ((WPI_READ(sc, WPI_GP_CNTRL) & + (WPI_GP_CNTRL_MAC_ACCESS_ENA | WPI_GP_CNTRL_SLEEP)) == + WPI_GP_CNTRL_MAC_ACCESS_ENA) + return 0; + DELAY(10); + } + + device_printf(sc->sc_dev, "could not lock memory\n"); + + return ETIMEDOUT; +} + +/* + * Release lock on NIC memory. + */ +static __inline void +wpi_nic_unlock(struct wpi_softc *sc) +{ + WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); +} + +static __inline uint32_t +wpi_prph_read(struct wpi_softc *sc, uint32_t addr) +{ + WPI_WRITE(sc, WPI_PRPH_RADDR, WPI_PRPH_DWORD | addr); + WPI_BARRIER_READ_WRITE(sc); + return WPI_READ(sc, WPI_PRPH_RDATA); +} + +static __inline void +wpi_prph_write(struct wpi_softc *sc, uint32_t addr, uint32_t data) +{ + WPI_WRITE(sc, WPI_PRPH_WADDR, WPI_PRPH_DWORD | addr); + WPI_BARRIER_WRITE(sc); + WPI_WRITE(sc, WPI_PRPH_WDATA, data); +} + +static __inline void +wpi_prph_setbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) +{ + wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) | mask); +} + +static __inline void +wpi_prph_clrbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) +{ + wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) & ~mask); +} + +static __inline void +wpi_prph_write_region_4(struct wpi_softc *sc, uint32_t addr, + const uint32_t *data, int count) +{ + for (; count > 0; count--, data++, addr += 4) + wpi_prph_write(sc, addr, *data); +} + +static __inline uint32_t +wpi_mem_read(struct wpi_softc *sc, uint32_t addr) +{ + WPI_WRITE(sc, WPI_MEM_RADDR, addr); + WPI_BARRIER_READ_WRITE(sc); + return WPI_READ(sc, WPI_MEM_RDATA); +} + +static __inline void +wpi_mem_read_region_4(struct wpi_softc *sc, uint32_t addr, uint32_t *data, + int count) +{ + for (; count > 0; count--, addr += 4) + *data++ = wpi_mem_read(sc, addr); +} + +static int +wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int count) +{ + uint8_t *out = data; + uint32_t val; + int error, ntries; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + if ((error = wpi_nic_lock(sc)) != 0) + return error; + + for (; count > 0; count -= 2, addr++) { + WPI_WRITE(sc, WPI_EEPROM, addr << 2); + for (ntries = 0; ntries < 10; ntries++) { + val = WPI_READ(sc, WPI_EEPROM); + if (val & WPI_EEPROM_READ_VALID) + break; + DELAY(5); + } + if (ntries == 10) { + device_printf(sc->sc_dev, + "timeout reading ROM at 0x%x\n", addr); + return ETIMEDOUT; + } + *out++= val >> 16; + if (count > 1) + *out ++= val >> 24; + } + + wpi_nic_unlock(sc); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + return 0; } static void @@ -799,116 +918,63 @@ wpi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nsegs, int error) { if (error != 0) return; - KASSERT(nsegs == 1, ("too many DMA segments, %d should be 1", nsegs)); - *(bus_addr_t *)arg = segs[0].ds_addr; } /* * Allocates a contiguous block of dma memory of the requested size and - * alignment. Due to limitations of the FreeBSD dma subsystem as of 20071217, - * allocations greater than 4096 may fail. Hence if the requested alignment is - * greater we allocate 'alignment' size extra memory and shift the vaddr and - * paddr after the dma load. This bypasses the problem at the cost of a little - * more memory. + * alignment. */ static int wpi_dma_contig_alloc(struct wpi_softc *sc, struct wpi_dma_info *dma, - void **kvap, bus_size_t size, bus_size_t alignment, int flags) + void **kvap, bus_size_t size, bus_size_t alignment) { int error; - bus_size_t align; - bus_size_t reqsize; - DPRINTFN(WPI_DEBUG_DMA, - ("Size: %zd - alignment %zd\n", size, alignment)); - - dma->size = size; dma->tag = NULL; + dma->size = size; - if (alignment > 4096) { - align = PAGE_SIZE; - reqsize = size + alignment; - } else { - align = alignment; - reqsize = size; - } - error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), align, - 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, - NULL, NULL, reqsize, - 1, reqsize, flags, - NULL, NULL, &dma->tag); - if (error != 0) { - device_printf(sc->sc_dev, - "could not create shared page DMA tag\n"); - goto fail; - } - error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr_start, - flags | BUS_DMA_ZERO, &dma->map); - if (error != 0) { - device_printf(sc->sc_dev, - "could not allocate shared page DMA memory\n"); + error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), alignment, + 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, size, + 1, size, BUS_DMA_NOWAIT, NULL, NULL, &dma->tag); + if (error != 0) goto fail; - } - - error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr_start, - reqsize, wpi_dma_map_addr, &dma->paddr_start, flags); - - /* Save the original pointers so we can free all the memory */ - dma->paddr = dma->paddr_start; - dma->vaddr = dma->vaddr_start; - - /* - * Check the alignment and increment by 4096 until we get the - * requested alignment. Fail if can't obtain the alignment - * we requested. - */ - if ((dma->paddr & (alignment -1 )) != 0) { - int i; - for (i = 0; i < alignment / 4096; i++) { - if ((dma->paddr & (alignment - 1 )) == 0) - break; - dma->paddr += 4096; - dma->vaddr += 4096; - } - if (i == alignment / 4096) { - device_printf(sc->sc_dev, - "alignment requirement was not satisfied\n"); - goto fail; - } - } + error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr, + BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, &dma->map); + if (error != 0) + goto fail; - if (error != 0) { - device_printf(sc->sc_dev, - "could not load shared page DMA map\n"); + error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, size, + wpi_dma_map_addr, &dma->paddr, BUS_DMA_NOWAIT); + if (error != 0) goto fail; - } + + bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); if (kvap != NULL) *kvap = dma->vaddr; return 0; -fail: - wpi_dma_contig_free(dma); +fail: wpi_dma_contig_free(dma); return error; } static void wpi_dma_contig_free(struct wpi_dma_info *dma) { - if (dma->tag) { - if (dma->map != NULL) { - if (dma->paddr_start != 0) { - bus_dmamap_sync(dma->tag, dma->map, - BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(dma->tag, dma->map); - } - bus_dmamem_free(dma->tag, &dma->vaddr_start, dma->map); - } + if (dma->vaddr != NULL) { + bus_dmamap_sync(dma->tag, dma->map, + BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); + bus_dmamap_unload(dma->tag, dma->map); + bus_dmamem_free(dma->tag, dma->vaddr, dma->map); + dma->vaddr = NULL; + } + if (dma->tag != NULL) { bus_dma_tag_destroy(dma->tag); + dma->tag = NULL; } } @@ -918,19 +984,9 @@ wpi_dma_contig_free(struct wpi_dma_info *dma) static int wpi_alloc_shared(struct wpi_softc *sc) { - int error; - - error = wpi_dma_contig_alloc(sc, &sc->shared_dma, - (void **)&sc->shared, sizeof (struct wpi_shared), - PAGE_SIZE, - BUS_DMA_NOWAIT); - - if (error != 0) { - device_printf(sc->sc_dev, - "could not allocate shared area DMA memory\n"); - } - - return error; + /* Shared buffer must be aligned on a 4KB boundary. */ + return wpi_dma_contig_alloc(sc, &sc->shared_dma, + (void **)&sc->shared, sizeof (struct wpi_shared), 4096); } static void @@ -939,114 +995,167 @@ wpi_free_shared(struct wpi_softc *sc) wpi_dma_contig_free(&sc->shared_dma); } +/* + * Allocate DMA-safe memory for firmware transfer. + */ static int -wpi_alloc_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring) +wpi_alloc_fwmem(struct wpi_softc *sc) +{ + /* Must be aligned on a 16-byte boundary. */ + return wpi_dma_contig_alloc(sc, &sc->fw_dma, NULL, + WPI_FW_TEXT_MAXSZ + WPI_FW_DATA_MAXSZ, 16); +} + +static void +wpi_free_fwmem(struct wpi_softc *sc) { + wpi_dma_contig_free(&sc->fw_dma); +} +static int +wpi_alloc_rx_ring(struct wpi_softc *sc) +{ + struct wpi_rx_ring *ring = &sc->rxq; + bus_size_t size; int i, error; ring->cur = 0; + ring->update = 0; - error = wpi_dma_contig_alloc(sc, &ring->desc_dma, - (void **)&ring->desc, WPI_RX_RING_COUNT * sizeof (uint32_t), - WPI_RING_DMA_ALIGN, BUS_DMA_NOWAIT); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + /* Allocate RX descriptors (16KB aligned.) */ + size = WPI_RX_RING_COUNT * sizeof (uint32_t); + error = wpi_dma_contig_alloc(sc, &ring->desc_dma, + (void **)&ring->desc, size, WPI_RING_DMA_ALIGN); if (error != 0) { device_printf(sc->sc_dev, - "%s: could not allocate rx ring DMA memory, error %d\n", + "%s: could not allocate RX ring DMA memory, error %d\n", __func__, error); goto fail; } - error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, - BUS_SPACE_MAXADDR_32BIT, - BUS_SPACE_MAXADDR, NULL, NULL, MJUMPAGESIZE, 1, - MJUMPAGESIZE, BUS_DMA_NOWAIT, NULL, NULL, &ring->data_dmat); - if (error != 0) { - device_printf(sc->sc_dev, - "%s: bus_dma_tag_create_failed, error %d\n", + /* Create RX buffer DMA tag. */ + error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, + BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, + MJUMPAGESIZE, 1, MJUMPAGESIZE, BUS_DMA_NOWAIT, NULL, NULL, + &ring->data_dmat); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: could not create RX buf DMA tag, error %d\n", __func__, error); - goto fail; - } + goto fail; + } /* - * Setup Rx buffers. + * Allocate and map RX buffers. */ for (i = 0; i < WPI_RX_RING_COUNT; i++) { struct wpi_rx_data *data = &ring->data[i]; - struct mbuf *m; bus_addr_t paddr; error = bus_dmamap_create(ring->data_dmat, 0, &data->map); if (error != 0) { device_printf(sc->sc_dev, - "%s: bus_dmamap_create failed, error %d\n", + "%s: could not create RX buf DMA map, error %d\n", __func__, error); goto fail; } - m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); - if (m == NULL) { + + data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); + if (data->m == NULL) { device_printf(sc->sc_dev, - "%s: could not allocate rx mbuf\n", __func__); - error = ENOMEM; + "%s: could not allocate RX mbuf\n", __func__); + error = ENOBUFS; goto fail; } - /* map page */ + error = bus_dmamap_load(ring->data_dmat, data->map, - mtod(m, caddr_t), MJUMPAGESIZE, - wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); + mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, + &paddr, BUS_DMA_NOWAIT); if (error != 0 && error != EFBIG) { device_printf(sc->sc_dev, - "%s: bus_dmamap_load failed, error %d\n", - __func__, error); - m_freem(m); - error = ENOMEM; /* XXX unique code */ + "%s: can't map mbuf (error %d)\n", __func__, + error); goto fail; } - bus_dmamap_sync(ring->data_dmat, data->map, - BUS_DMASYNC_PREWRITE); - data->m = m; + /* Set physical address of RX buffer. */ ring->desc[i] = htole32(paddr); } + bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, BUS_DMASYNC_PREWRITE); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + return 0; -fail: - wpi_free_rx_ring(sc, ring); + +fail: wpi_free_rx_ring(sc); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + return error; } static void -wpi_reset_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring) +wpi_update_rx_ring(struct wpi_softc *sc) { - int ntries; + WPI_WRITE(sc, WPI_FH_RX_WPTR, sc->rxq.cur & ~7); +} - wpi_mem_lock(sc); +static void +wpi_update_rx_ring_ps(struct wpi_softc *sc) +{ + struct wpi_rx_ring *ring = &sc->rxq; - WPI_WRITE(sc, WPI_RX_CONFIG, 0); + if (ring->update != 0) { + /* Wait for INT_WAKEUP event. */ + return; + } - for (ntries = 0; ntries < 100; ntries++) { - if (WPI_READ(sc, WPI_RX_STATUS) & WPI_RX_IDLE) - break; - DELAY(10); + WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); + if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_SLEEP) { + DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s: wakeup request\n", + __func__); + ring->update = 1; + } else { + wpi_update_rx_ring(sc); + WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); } +} + +static void +wpi_reset_rx_ring(struct wpi_softc *sc) +{ + struct wpi_rx_ring *ring = &sc->rxq; + int ntries; - wpi_mem_unlock(sc); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); -#ifdef WPI_DEBUG - if (ntries == 100 && wpi_debug > 0) - device_printf(sc->sc_dev, "timeout resetting Rx ring\n"); -#endif + if (wpi_nic_lock(sc) == 0) { + WPI_WRITE(sc, WPI_FH_RX_CONFIG, 0); + for (ntries = 0; ntries < 1000; ntries++) { + if (WPI_READ(sc, WPI_FH_RX_STATUS) & + WPI_FH_RX_STATUS_IDLE) + break; + DELAY(10); + } + wpi_nic_unlock(sc); + } ring->cur = 0; + ring->update = 0; } static void -wpi_free_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring) +wpi_free_rx_ring(struct wpi_softc *sc) { + struct wpi_rx_ring *ring = &sc->rxq; int i; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + wpi_dma_contig_free(&ring->desc_dma); for (i = 0; i < WPI_RX_RING_COUNT; i++) { @@ -1057,52 +1166,64 @@ wpi_free_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring) BUS_DMASYNC_POSTREAD); bus_dmamap_unload(ring->data_dmat, data->map); m_freem(data->m); + data->m = NULL; } if (data->map != NULL) bus_dmamap_destroy(ring->data_dmat, data->map); } + if (ring->data_dmat != NULL) { + bus_dma_tag_destroy(ring->data_dmat); + ring->data_dmat = NULL; + } } static int -wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int count, - int qid) +wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int qid) { - struct wpi_tx_data *data; + bus_addr_t paddr; + bus_size_t size; int i, error; ring->qid = qid; - ring->count = count; ring->queued = 0; ring->cur = 0; - ring->data = NULL; + ring->update = 0; - error = wpi_dma_contig_alloc(sc, &ring->desc_dma, - (void **)&ring->desc, count * sizeof (struct wpi_tx_desc), - WPI_RING_DMA_ALIGN, BUS_DMA_NOWAIT); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + /* Allocate TX descriptors (16KB aligned.) */ + size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_desc); + error = wpi_dma_contig_alloc(sc, &ring->desc_dma, (void **)&ring->desc, + size, WPI_RING_DMA_ALIGN); if (error != 0) { - device_printf(sc->sc_dev, "could not allocate tx dma memory\n"); - goto fail; + device_printf(sc->sc_dev, + "%s: could not allocate TX ring DMA memory, error %d\n", + __func__, error); + goto fail; } - /* update shared page with ring's base address */ + /* Update shared area with ring physical address. */ sc->shared->txbase[qid] = htole32(ring->desc_dma.paddr); + bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, + BUS_DMASYNC_PREWRITE); - error = wpi_dma_contig_alloc(sc, &ring->cmd_dma, (void **)&ring->cmd, - count * sizeof (struct wpi_tx_cmd), WPI_RING_DMA_ALIGN, - BUS_DMA_NOWAIT); - - if (error != 0) { - device_printf(sc->sc_dev, - "could not allocate tx command DMA memory\n"); - goto fail; + /* + * We only use rings 0 through 4 (4 EDCA + cmd) so there is no need + * to allocate commands space for other rings. + * XXX Do we really need to allocate descriptors for other rings? + */ + if (qid > WPI_CMD_QUEUE_NUM) { + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + return 0; } - ring->data = malloc(count * sizeof (struct wpi_tx_data), M_DEVBUF, - M_NOWAIT | M_ZERO); - if (ring->data == NULL) { + size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_cmd); + error = wpi_dma_contig_alloc(sc, &ring->cmd_dma, (void **)&ring->cmd, + size, 4); + if (error != 0) { device_printf(sc->sc_dev, - "could not allocate tx data slots\n"); + "%s: could not allocate TX cmd DMA memory, error %d\n", + __func__, error); goto fail; } @@ -1111,339 +1232,706 @@ wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int count, WPI_MAX_SCATTER - 1, MCLBYTES, BUS_DMA_NOWAIT, NULL, NULL, &ring->data_dmat); if (error != 0) { - device_printf(sc->sc_dev, "could not create data DMA tag\n"); + device_printf(sc->sc_dev, + "%s: could not create TX buf DMA tag, error %d\n", + __func__, error); goto fail; } - for (i = 0; i < count; i++) { - data = &ring->data[i]; + paddr = ring->cmd_dma.paddr; + for (i = 0; i < WPI_TX_RING_COUNT; i++) { + struct wpi_tx_data *data = &ring->data[i]; + + data->cmd_paddr = paddr; + paddr += sizeof (struct wpi_tx_cmd); error = bus_dmamap_create(ring->data_dmat, 0, &data->map); if (error != 0) { device_printf(sc->sc_dev, - "could not create tx buf DMA map\n"); + "%s: could not create TX buf DMA map, error %d\n", + __func__, error); goto fail; } - bus_dmamap_sync(ring->data_dmat, data->map, - BUS_DMASYNC_PREWRITE); } + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + return 0; -fail: - wpi_free_tx_ring(sc, ring); +fail: wpi_free_tx_ring(sc, ring); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); return error; } static void -wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) +wpi_update_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) { - struct wpi_tx_data *data; - int i, ntries; + WPI_WRITE(sc, WPI_HBUS_TARG_WRPTR, ring->qid << 8 | ring->cur); +} - wpi_mem_lock(sc); +static void +wpi_update_tx_ring_ps(struct wpi_softc *sc, struct wpi_tx_ring *ring) +{ - WPI_WRITE(sc, WPI_TX_CONFIG(ring->qid), 0); - for (ntries = 0; ntries < 100; ntries++) { - if (WPI_READ(sc, WPI_TX_STATUS) & WPI_TX_IDLE(ring->qid)) - break; - DELAY(10); + if (ring->update != 0) { + /* Wait for INT_WAKEUP event. */ + return; } -#ifdef WPI_DEBUG - if (ntries == 100 && wpi_debug > 0) - device_printf(sc->sc_dev, "timeout resetting Tx ring %d\n", - ring->qid); -#endif - wpi_mem_unlock(sc); - for (i = 0; i < ring->count; i++) { - data = &ring->data[i]; + WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); + if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_SLEEP) { + DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s (%d): requesting wakeup\n", + __func__, ring->qid); + ring->update = 1; + } else { + wpi_update_tx_ring(sc, ring); + WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); + } +} + +static void +wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) +{ + int i; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + for (i = 0; i < WPI_TX_RING_COUNT; i++) { + struct wpi_tx_data *data = &ring->data[i]; if (data->m != NULL) { + bus_dmamap_sync(ring->data_dmat, data->map, + BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(ring->data_dmat, data->map); m_freem(data->m); data->m = NULL; } + if (data->ni != NULL) { + ieee80211_free_node(data->ni); + data->ni = NULL; + } } - + /* Clear TX descriptors. */ + memset(ring->desc, 0, ring->desc_dma.size); + bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, + BUS_DMASYNC_PREWRITE); + sc->qfullmsk &= ~(1 << ring->qid); ring->queued = 0; ring->cur = 0; + ring->update = 0; } static void wpi_free_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) { - struct wpi_tx_data *data; int i; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + wpi_dma_contig_free(&ring->desc_dma); wpi_dma_contig_free(&ring->cmd_dma); - if (ring->data != NULL) { - for (i = 0; i < ring->count; i++) { - data = &ring->data[i]; + for (i = 0; i < WPI_TX_RING_COUNT; i++) { + struct wpi_tx_data *data = &ring->data[i]; - if (data->m != NULL) { - bus_dmamap_sync(ring->data_dmat, data->map, - BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(ring->data_dmat, data->map); - m_freem(data->m); - data->m = NULL; - } + if (data->m != NULL) { + bus_dmamap_sync(ring->data_dmat, data->map, + BUS_DMASYNC_POSTWRITE); + bus_dmamap_unload(ring->data_dmat, data->map); + m_freem(data->m); } - free(ring->data, M_DEVBUF); + if (data->map != NULL) + bus_dmamap_destroy(ring->data_dmat, data->map); } - - if (ring->data_dmat != NULL) + if (ring->data_dmat != NULL) { bus_dma_tag_destroy(ring->data_dmat); + ring->data_dmat = NULL; + } } +/* + * Extract various information from EEPROM. + */ static int -wpi_shutdown(device_t dev) +wpi_read_eeprom(struct wpi_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN]) { - struct wpi_softc *sc = device_get_softc(dev); +#define WPI_CHK(res) do { \ + if ((error = res) != 0) \ + goto fail; \ +} while (0) + int error, i; - WPI_LOCK(sc); - wpi_stop_locked(sc); - wpi_unload_firmware(sc); - WPI_UNLOCK(sc); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - return 0; + /* Adapter has to be powered on for EEPROM access to work. */ + if ((error = wpi_apm_init(sc)) != 0) { + device_printf(sc->sc_dev, + "%s: could not power ON adapter, error %d\n", __func__, + error); + return error; + } + + if ((WPI_READ(sc, WPI_EEPROM_GP) & 0x6) == 0) { + device_printf(sc->sc_dev, "bad EEPROM signature\n"); + error = EIO; + goto fail; + } + /* Clear HW ownership of EEPROM. */ + WPI_CLRBITS(sc, WPI_EEPROM_GP, WPI_EEPROM_GP_IF_OWNER); + + /* Read the hardware capabilities, revision and SKU type. */ + WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_SKU_CAP, &sc->cap, + sizeof(sc->cap))); + WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev, + sizeof(sc->rev))); + WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type, + sizeof(sc->type))); + + sc->rev = le16toh(sc->rev); + DPRINTF(sc, WPI_DEBUG_EEPROM, "cap=%x rev=%x type=%x\n", sc->cap, + sc->rev, sc->type); + + /* Read the regulatory domain (4 ASCII characters.) */ + WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, sc->domain, + sizeof(sc->domain))); + + /* Read MAC address. */ + WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_MAC, macaddr, + IEEE80211_ADDR_LEN)); + + /* Read the list of authorized channels. */ + for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++) + WPI_CHK(wpi_read_eeprom_channels(sc, i)); + + /* Read the list of TX power groups. */ + for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++) + WPI_CHK(wpi_read_eeprom_group(sc, i)); + +fail: wpi_apm_stop(sc); /* Power OFF adapter. */ + + DPRINTF(sc, WPI_DEBUG_TRACE, error ? TRACE_STR_END_ERR : TRACE_STR_END, + __func__); + + return error; +#undef WPI_CHK } -static int -wpi_suspend(device_t dev) +/* + * Translate EEPROM flags to net80211. + */ +static uint32_t +wpi_eeprom_channel_flags(struct wpi_eeprom_chan *channel) { - struct wpi_softc *sc = device_get_softc(dev); - struct ieee80211com *ic = sc->sc_ifp->if_l2com; + uint32_t nflags; - ieee80211_suspend_all(ic); - return 0; + nflags = 0; + if ((channel->flags & WPI_EEPROM_CHAN_ACTIVE) == 0) + nflags |= IEEE80211_CHAN_PASSIVE; + if ((channel->flags & WPI_EEPROM_CHAN_IBSS) == 0) + nflags |= IEEE80211_CHAN_NOADHOC; + if (channel->flags & WPI_EEPROM_CHAN_RADAR) { + nflags |= IEEE80211_CHAN_DFS; + /* XXX apparently IBSS may still be marked */ + nflags |= IEEE80211_CHAN_NOADHOC; + } + + /* XXX HOSTAP uses WPI_MODE_IBSS */ + if (nflags & IEEE80211_CHAN_NOADHOC) + nflags |= IEEE80211_CHAN_NOHOSTAP; + + return nflags; } +static void +wpi_read_eeprom_band(struct wpi_softc *sc, int n) +{ + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct wpi_eeprom_chan *channels = sc->eeprom_channels[n]; + const struct wpi_chan_band *band = &wpi_bands[n]; + struct ieee80211_channel *c; + uint8_t chan; + int i, nflags; + + for (i = 0; i < band->nchan; i++) { + if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID)) { + DPRINTF(sc, WPI_DEBUG_EEPROM, + "Channel Not Valid: %d, band %d\n", + band->chan[i],n); + continue; + } + + chan = band->chan[i]; + nflags = wpi_eeprom_channel_flags(&channels[i]); + + c = &ic->ic_channels[ic->ic_nchans++]; + c->ic_ieee = chan; + c->ic_maxregpower = channels[i].maxpwr; + c->ic_maxpower = 2*c->ic_maxregpower; + + if (n == 0) { /* 2GHz band */ + c->ic_freq = ieee80211_ieee2mhz(chan, + IEEE80211_CHAN_G); + + /* G =>'s B is supported */ + c->ic_flags = IEEE80211_CHAN_B | nflags; + c = &ic->ic_channels[ic->ic_nchans++]; + c[0] = c[-1]; + c->ic_flags = IEEE80211_CHAN_G | nflags; + } else { /* 5GHz band */ + c->ic_freq = ieee80211_ieee2mhz(chan, + IEEE80211_CHAN_A); + + c->ic_flags = IEEE80211_CHAN_A | nflags; + } + + /* Save maximum allowed TX power for this channel. */ + sc->maxpwr[chan] = channels[i].maxpwr; + + DPRINTF(sc, WPI_DEBUG_EEPROM, + "adding chan %d (%dMHz) flags=0x%x maxpwr=%d passive=%d," + " offset %d\n", chan, c->ic_freq, + channels[i].flags, sc->maxpwr[chan], + IEEE80211_IS_CHAN_PASSIVE(c), ic->ic_nchans); + } +} + +/** + * Read the eeprom to find out what channels are valid for the given + * band and update net80211 with what we find. + */ static int -wpi_resume(device_t dev) +wpi_read_eeprom_channels(struct wpi_softc *sc, int n) { - struct wpi_softc *sc = device_get_softc(dev); - struct ieee80211com *ic = sc->sc_ifp->if_l2com; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + const struct wpi_chan_band *band = &wpi_bands[n]; + int error; - pci_write_config(dev, 0x41, 0, 1); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + error = wpi_read_prom_data(sc, band->addr, &sc->eeprom_channels[n], + band->nchan * sizeof (struct wpi_eeprom_chan)); + if (error != 0) { + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + return error; + } + + wpi_read_eeprom_band(sc, n); + + ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); - ieee80211_resume_all(ic); return 0; } -/** - * Called by net80211 when ever there is a change to 80211 state machine +static struct wpi_eeprom_chan * +wpi_find_eeprom_channel(struct wpi_softc *sc, struct ieee80211_channel *c) +{ + int i, j; + + for (j = 0; j < WPI_CHAN_BANDS_COUNT; j++) + for (i = 0; i < wpi_bands[j].nchan; i++) + if (wpi_bands[j].chan[i] == c->ic_ieee) + return &sc->eeprom_channels[j][i]; + + return NULL; +} + +/* + * Enforce flags read from EEPROM. */ static int -wpi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) +wpi_setregdomain(struct ieee80211com *ic, struct ieee80211_regdomain *rd, + int nchan, struct ieee80211_channel chans[]) { - struct wpi_vap *wvp = WPI_VAP(vap); - struct ieee80211com *ic = vap->iv_ic; struct ifnet *ifp = ic->ic_ifp; struct wpi_softc *sc = ifp->if_softc; - int error; + int i; - DPRINTF(("%s: %s -> %s flags 0x%x\n", __func__, - ieee80211_state_name[vap->iv_state], - ieee80211_state_name[nstate], sc->flags)); + for (i = 0; i < nchan; i++) { + struct ieee80211_channel *c = &chans[i]; + struct wpi_eeprom_chan *channel; - IEEE80211_UNLOCK(ic); - WPI_LOCK(sc); - if (nstate == IEEE80211_S_SCAN && vap->iv_state != IEEE80211_S_INIT) { - /* - * On !INIT -> SCAN transitions, we need to clear any possible - * knowledge about associations. - */ - error = wpi_config(sc); - if (error != 0) { - device_printf(sc->sc_dev, - "%s: device config failed, error %d\n", - __func__, error); - } - } - if (nstate == IEEE80211_S_AUTH || - (nstate == IEEE80211_S_ASSOC && vap->iv_state == IEEE80211_S_RUN)) { - /* - * The node must be registered in the firmware before auth. - * Also the associd must be cleared on RUN -> ASSOC - * transitions. - */ - error = wpi_auth(sc, vap); - if (error != 0) { - device_printf(sc->sc_dev, - "%s: could not move to auth state, error %d\n", - __func__, error); + channel = wpi_find_eeprom_channel(sc, c); + if (channel == NULL) { + if_printf(ic->ic_ifp, + "%s: invalid channel %u freq %u/0x%x\n", + __func__, c->ic_ieee, c->ic_freq, c->ic_flags); + return EINVAL; } + c->ic_flags |= wpi_eeprom_channel_flags(channel); } - if (nstate == IEEE80211_S_RUN && vap->iv_state != IEEE80211_S_RUN) { - error = wpi_run(sc, vap); - if (error != 0) { - device_printf(sc->sc_dev, - "%s: could not move to run state, error %d\n", - __func__, error); - } + + return 0; +} + +static int +wpi_read_eeprom_group(struct wpi_softc *sc, int n) +{ + struct wpi_power_group *group = &sc->groups[n]; + struct wpi_eeprom_group rgroup; + int i, error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + if ((error = wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32, + &rgroup, sizeof rgroup)) != 0) { + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + return error; } - if (nstate == IEEE80211_S_RUN) { - /* RUN -> RUN transition; just restart the timers */ - wpi_calib_timeout(sc); - /* XXX split out rate control timer */ + + /* Save TX power group information. */ + group->chan = rgroup.chan; + group->maxpwr = rgroup.maxpwr; + /* Retrieve temperature at which the samples were taken. */ + group->temp = (int16_t)le16toh(rgroup.temp); + + DPRINTF(sc, WPI_DEBUG_EEPROM, + "power group %d: chan=%d maxpwr=%d temp=%d\n", n, group->chan, + group->maxpwr, group->temp); + + for (i = 0; i < WPI_SAMPLES_COUNT; i++) { + group->samples[i].index = rgroup.samples[i].index; + group->samples[i].power = rgroup.samples[i].power; + + DPRINTF(sc, WPI_DEBUG_EEPROM, + "\tsample %d: index=%d power=%d\n", i, + group->samples[i].index, group->samples[i].power); } - WPI_UNLOCK(sc); - IEEE80211_LOCK(ic); - return wvp->newstate(vap, nstate, arg); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + return 0; } -/* - * Grab exclusive access to NIC memory. - */ -static void -wpi_mem_lock(struct wpi_softc *sc) +static int +wpi_add_node_entry_adhoc(struct wpi_softc *sc) { - int ntries; - uint32_t tmp; - - tmp = WPI_READ(sc, WPI_GPIO_CTL); - WPI_WRITE(sc, WPI_GPIO_CTL, tmp | WPI_GPIO_MAC); + int newid = WPI_ID_IBSS_MIN; - /* spin until we actually get the lock */ - for (ntries = 0; ntries < 100; ntries++) { - if ((WPI_READ(sc, WPI_GPIO_CTL) & - (WPI_GPIO_CLOCK | WPI_GPIO_SLEEP)) == WPI_GPIO_CLOCK) - break; - DELAY(10); + for (; newid <= WPI_ID_IBSS_MAX; newid++) { + if ((sc->nodesmsk & (1 << newid)) == 0) { + sc->nodesmsk |= 1 << newid; + return newid; + } } - if (ntries == 100) - device_printf(sc->sc_dev, "could not lock memory\n"); + + return WPI_ID_UNDEFINED; } -/* - * Release lock on NIC memory. - */ -static void -wpi_mem_unlock(struct wpi_softc *sc) +static __inline int +wpi_add_node_entry_sta(struct wpi_softc *sc) { - uint32_t tmp = WPI_READ(sc, WPI_GPIO_CTL); - WPI_WRITE(sc, WPI_GPIO_CTL, tmp & ~WPI_GPIO_MAC); + sc->nodesmsk |= 1 << WPI_ID_BSS; + + return WPI_ID_BSS; } -static uint32_t -wpi_mem_read(struct wpi_softc *sc, uint16_t addr) +static __inline int +wpi_check_node_entry(struct wpi_softc *sc, uint8_t id) { - WPI_WRITE(sc, WPI_READ_MEM_ADDR, WPI_MEM_4 | addr); - return WPI_READ(sc, WPI_READ_MEM_DATA); + if (id == WPI_ID_UNDEFINED) + return 0; + + return (sc->nodesmsk >> id) & 1; } -static void -wpi_mem_write(struct wpi_softc *sc, uint16_t addr, uint32_t data) +static __inline void +wpi_clear_node_table(struct wpi_softc *sc) { - WPI_WRITE(sc, WPI_WRITE_MEM_ADDR, WPI_MEM_4 | addr); - WPI_WRITE(sc, WPI_WRITE_MEM_DATA, data); + sc->nodesmsk = 0; } -static void -wpi_mem_write_region_4(struct wpi_softc *sc, uint16_t addr, - const uint32_t *data, int wlen) +static __inline void +wpi_del_node_entry(struct wpi_softc *sc, uint8_t id) { - for (; wlen > 0; wlen--, data++, addr+=4) - wpi_mem_write(sc, addr, *data); + sc->nodesmsk &= ~(1 << id); } -/* - * Read data from the EEPROM. We access EEPROM through the MAC instead of - * using the traditional bit-bang method. Data is read up until len bytes have - * been obtained. - */ -static uint16_t -wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int len) +static struct ieee80211_node * +wpi_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) { - int ntries; - uint32_t val; - uint8_t *out = data; + struct wpi_node *wn; + + wn = malloc(sizeof (struct wpi_node), M_80211_NODE, + M_NOWAIT | M_ZERO); - wpi_mem_lock(sc); + if (wn == NULL) + return NULL; - for (; len > 0; len -= 2, addr++) { - WPI_WRITE(sc, WPI_EEPROM_CTL, addr << 2); + wn->id = WPI_ID_UNDEFINED; - for (ntries = 0; ntries < 10; ntries++) { - if ((val = WPI_READ(sc, WPI_EEPROM_CTL)) & WPI_EEPROM_READY) - break; - DELAY(5); + return &wn->ni; +} + +static void +wpi_node_free(struct ieee80211_node *ni) +{ + struct ieee80211com *ic = ni->ni_ic; + struct wpi_softc *sc = ic->ic_ifp->if_softc; + struct wpi_node *wn = WPI_NODE(ni); + + if (wn->id != WPI_ID_UNDEFINED) { + WPI_NT_LOCK(sc); + if (wpi_check_node_entry(sc, wn->id)) { + wpi_del_node_entry(sc, wn->id); + wpi_del_node(sc, ni); } + WPI_NT_UNLOCK(sc); + } - if (ntries == 10) { - device_printf(sc->sc_dev, "could not read EEPROM\n"); - return ETIMEDOUT; + sc->sc_node_free(ni); +} + +static __inline int +wpi_check_bss_filter(struct wpi_softc *sc) +{ + return (sc->rxon.filter & htole32(WPI_FILTER_BSS)) != 0; +} + +static void +wpi_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, int subtype, int rssi, + int nf) +{ + struct ieee80211vap *vap = ni->ni_vap; + struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc; + struct wpi_vap *wvp = WPI_VAP(vap); + uint64_t ni_tstamp, rx_tstamp; + + wvp->wv_recv_mgmt(ni, m, subtype, rssi, nf); + + if (vap->iv_opmode == IEEE80211_M_IBSS && + vap->iv_state == IEEE80211_S_RUN && + (subtype == IEEE80211_FC0_SUBTYPE_BEACON || + subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)) { + ni_tstamp = le64toh(ni->ni_tstamp.tsf); + rx_tstamp = le64toh(sc->rx_tstamp); + + if (ni_tstamp >= rx_tstamp) { + DPRINTF(sc, WPI_DEBUG_STATE, + "ibss merge, tsf %ju tstamp %ju\n", + (uintmax_t)rx_tstamp, (uintmax_t)ni_tstamp); + (void) ieee80211_ibss_merge(ni); } + } +} - *out++= val >> 16; - if (len > 1) - *out ++= val >> 24; +static void +wpi_restore_node(void *arg, struct ieee80211_node *ni) +{ + struct wpi_softc *sc = arg; + struct wpi_node *wn = WPI_NODE(ni); + int error; + + WPI_NT_LOCK(sc); + if (wn->id != WPI_ID_UNDEFINED) { + wn->id = WPI_ID_UNDEFINED; + if ((error = wpi_add_ibss_node(sc, ni)) != 0) { + device_printf(sc->sc_dev, + "%s: could not add IBSS node, error %d\n", + __func__, error); + } } + WPI_NT_UNLOCK(sc); +} - wpi_mem_unlock(sc); +static void +wpi_restore_node_table(struct wpi_softc *sc, struct wpi_vap *wvp) +{ + struct ieee80211com *ic = sc->sc_ifp->if_l2com; - return 0; + /* Set group keys once. */ + WPI_NT_LOCK(sc); + wvp->wv_gtk = 0; + WPI_NT_UNLOCK(sc); + + ieee80211_iterate_nodes(&ic->ic_sta, wpi_restore_node, sc); + ieee80211_crypto_reload_keys(ic); } -/* - * The firmware text and data segments are transferred to the NIC using DMA. - * The driver just copies the firmware into DMA-safe memory and tells the NIC - * where to find it. Once the NIC has copied the firmware into its internal - * memory, we can free our local copy in the driver. +/** + * Called by net80211 when ever there is a change to 80211 state machine */ static int -wpi_load_microcode(struct wpi_softc *sc, const uint8_t *fw, int size) +wpi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) { - int error, ntries; - - DPRINTFN(WPI_DEBUG_HW,("Loading microcode size 0x%x\n", size)); + struct wpi_vap *wvp = WPI_VAP(vap); + struct ieee80211com *ic = vap->iv_ic; + struct ifnet *ifp = ic->ic_ifp; + struct wpi_softc *sc = ifp->if_softc; + int error = 0; - size /= sizeof(uint32_t); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - wpi_mem_lock(sc); + DPRINTF(sc, WPI_DEBUG_STATE, "%s: %s -> %s\n", __func__, + ieee80211_state_name[vap->iv_state], + ieee80211_state_name[nstate]); - wpi_mem_write_region_4(sc, WPI_MEM_UCODE_BASE, - (const uint32_t *)fw, size); + if (vap->iv_state == IEEE80211_S_RUN && nstate < IEEE80211_S_RUN) { + if ((error = wpi_set_pslevel(sc, 0, 0, 1)) != 0) { + device_printf(sc->sc_dev, + "%s: could not set power saving level\n", + __func__); + return error; + } - wpi_mem_write(sc, WPI_MEM_UCODE_SRC, 0); - wpi_mem_write(sc, WPI_MEM_UCODE_DST, WPI_FW_TEXT); - wpi_mem_write(sc, WPI_MEM_UCODE_SIZE, size); + wpi_set_led(sc, WPI_LED_LINK, 1, 0); + } - /* run microcode */ - wpi_mem_write(sc, WPI_MEM_UCODE_CTL, WPI_UC_RUN); + switch (nstate) { + case IEEE80211_S_SCAN: + WPI_RXON_LOCK(sc); + if (wpi_check_bss_filter(sc) != 0) { + sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); + if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { + device_printf(sc->sc_dev, + "%s: could not send RXON\n", __func__); + } + } + WPI_RXON_UNLOCK(sc); + break; - /* wait while the adapter is busy copying the firmware */ - for (error = 0, ntries = 0; ntries < 1000; ntries++) { - uint32_t status = WPI_READ(sc, WPI_TX_STATUS); - DPRINTFN(WPI_DEBUG_HW, - ("firmware status=0x%x, val=0x%x, result=0x%x\n", status, - WPI_TX_IDLE(6), status & WPI_TX_IDLE(6))); - if (status & WPI_TX_IDLE(6)) { - DPRINTFN(WPI_DEBUG_HW, - ("Status Match! - ntries = %d\n", ntries)); + case IEEE80211_S_ASSOC: + if (vap->iv_state != IEEE80211_S_RUN) break; + /* FALLTHROUGH */ + case IEEE80211_S_AUTH: + /* + * NB: do not optimize AUTH -> AUTH state transmission - + * this will break powersave with non-QoS AP! + */ + + /* + * The node must be registered in the firmware before auth. + * Also the associd must be cleared on RUN -> ASSOC + * transitions. + */ + if ((error = wpi_auth(sc, vap)) != 0) { + device_printf(sc->sc_dev, + "%s: could not move to AUTH state, error %d\n", + __func__, error); } - DELAY(10); + break; + + case IEEE80211_S_RUN: + /* + * RUN -> RUN transition: + * STA mode: Just restart the timers. + * IBSS mode: Process IBSS merge. + */ + if (vap->iv_state == IEEE80211_S_RUN) { + if (vap->iv_opmode != IEEE80211_M_IBSS) { + WPI_RXON_LOCK(sc); + wpi_calib_timeout(sc); + WPI_RXON_UNLOCK(sc); + break; + } else { + /* + * Drop the BSS_FILTER bit + * (there is no another way to change bssid). + */ + WPI_RXON_LOCK(sc); + sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); + if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { + device_printf(sc->sc_dev, + "%s: could not send RXON\n", + __func__); + } + WPI_RXON_UNLOCK(sc); + + /* Restore all what was lost. */ + wpi_restore_node_table(sc, wvp); + + /* XXX set conditionally? */ + wpi_updateedca(ic); + } + } + + /* + * !RUN -> RUN requires setting the association id + * which is done with a firmware cmd. We also defer + * starting the timers until that work is done. + */ + if ((error = wpi_run(sc, vap)) != 0) { + device_printf(sc->sc_dev, + "%s: could not move to RUN state\n", __func__); + } + break; + + default: + break; } - if (ntries == 1000) { - device_printf(sc->sc_dev, "timeout transferring firmware\n"); - error = ETIMEDOUT; + if (error != 0) { + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + return error; } - /* start the microcode executing */ - wpi_mem_write(sc, WPI_MEM_UCODE_CTL, WPI_UC_ENABLE); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + return wvp->wv_newstate(vap, nstate, arg); +} + +static void +wpi_calib_timeout(void *arg) +{ + struct wpi_softc *sc = arg; + + if (wpi_check_bss_filter(sc) == 0) + return; - wpi_mem_unlock(sc); + wpi_power_calibration(sc); - return (error); + callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); } +static __inline uint8_t +rate2plcp(const uint8_t rate) +{ + switch (rate) { + case 12: return 0xd; + case 18: return 0xf; + case 24: return 0x5; + case 36: return 0x7; + case 48: return 0x9; + case 72: return 0xb; + case 96: return 0x1; + case 108: return 0x3; + case 2: return 10; + case 4: return 20; + case 11: return 55; + case 22: return 110; + default: return 0; + } +} + +static __inline uint8_t +plcp2rate(const uint8_t plcp) +{ + switch (plcp) { + case 0xd: return 12; + case 0xf: return 18; + case 0x5: return 24; + case 0x7: return 36; + case 0x9: return 48; + case 0xb: return 72; + case 0x1: return 96; + case 0x3: return 108; + case 10: return 2; + case 20: return 4; + case 55: return 11; + case 110: return 22; + default: return 0; + } +} + +/* Quickly determine if a given rate is CCK or OFDM. */ +#define WPI_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22) + static void -wpi_rx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc, - struct wpi_rx_data *data) +wpi_rx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc, + struct wpi_rx_data *data) { struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; @@ -1451,195 +1939,261 @@ wpi_rx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc, struct wpi_rx_stat *stat; struct wpi_rx_head *head; struct wpi_rx_tail *tail; + struct ieee80211_frame *wh; struct ieee80211_node *ni; - struct mbuf *m, *mnew; + struct mbuf *m, *m1; bus_addr_t paddr; + uint32_t flags; + uint16_t len; int error; stat = (struct wpi_rx_stat *)(desc + 1); if (stat->len > WPI_STAT_MAXLEN) { - device_printf(sc->sc_dev, "invalid rx statistic header\n"); - ifp->if_ierrors++; - return; + device_printf(sc->sc_dev, "invalid RX statistic header\n"); + goto fail1; } bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD); head = (struct wpi_rx_head *)((caddr_t)(stat + 1) + stat->len); - tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + le16toh(head->len)); - - DPRINTFN(WPI_DEBUG_RX, ("rx intr: idx=%d len=%d stat len=%d rssi=%d " - "rate=%x chan=%d tstamp=%ju\n", ring->cur, le32toh(desc->len), - le16toh(head->len), (int8_t)stat->rssi, head->rate, head->chan, - (uintmax_t)le64toh(tail->tstamp))); - - /* discard Rx frames with bad CRC early */ - if ((le32toh(tail->flags) & WPI_RX_NOERROR) != WPI_RX_NOERROR) { - DPRINTFN(WPI_DEBUG_RX, ("%s: rx flags error %x\n", __func__, - le32toh(tail->flags))); - ifp->if_ierrors++; - return; - } - if (le16toh(head->len) < sizeof (struct ieee80211_frame)) { - DPRINTFN(WPI_DEBUG_RX, ("%s: frame too short: %d\n", __func__, - le16toh(head->len))); - ifp->if_ierrors++; - return; - } - - /* XXX don't need mbuf, just dma buffer */ - mnew = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); - if (mnew == NULL) { - DPRINTFN(WPI_DEBUG_RX, ("%s: no mbuf to restock ring\n", - __func__)); - ifp->if_ierrors++; - return; + len = le16toh(head->len); + tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + len); + flags = le32toh(tail->flags); + + DPRINTF(sc, WPI_DEBUG_RECV, "%s: idx %d len %d stat len %u rssi %d" + " rate %x chan %d tstamp %ju\n", __func__, ring->cur, + le32toh(desc->len), len, (int8_t)stat->rssi, + head->plcp, head->chan, (uintmax_t)le64toh(tail->tstamp)); + + /* Discard frames with a bad FCS early. */ + if ((flags & WPI_RX_NOERROR) != WPI_RX_NOERROR) { + DPRINTF(sc, WPI_DEBUG_RECV, "%s: RX flags error %x\n", + __func__, flags); + goto fail1; + } + /* Discard frames that are too short. */ + if (len < sizeof (struct ieee80211_frame_ack)) { + DPRINTF(sc, WPI_DEBUG_RECV, "%s: frame too short: %d\n", + __func__, len); + goto fail1; + } + + m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); + if (m1 == NULL) { + DPRINTF(sc, WPI_DEBUG_ANY, "%s: no mbuf to restock ring\n", + __func__); + goto fail1; } bus_dmamap_unload(ring->data_dmat, data->map); - error = bus_dmamap_load(ring->data_dmat, data->map, - mtod(mnew, caddr_t), MJUMPAGESIZE, - wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); + error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *), + MJUMPAGESIZE, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); if (error != 0 && error != EFBIG) { device_printf(sc->sc_dev, "%s: bus_dmamap_load failed, error %d\n", __func__, error); - m_freem(mnew); - ifp->if_ierrors++; - return; + m_freem(m1); + + /* Try to reload the old mbuf. */ + error = bus_dmamap_load(ring->data_dmat, data->map, + mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, + &paddr, BUS_DMA_NOWAIT); + if (error != 0 && error != EFBIG) { + panic("%s: could not load old RX mbuf", __func__); + } + /* Physical address may have changed. */ + ring->desc[ring->cur] = htole32(paddr); + bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map, + BUS_DMASYNC_PREWRITE); + goto fail1; } - bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); - /* finalize mbuf and swap in new one */ m = data->m; + data->m = m1; + /* Update RX descriptor. */ + ring->desc[ring->cur] = htole32(paddr); + bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, + BUS_DMASYNC_PREWRITE); + + /* Finalize mbuf. */ m->m_pkthdr.rcvif = ifp; m->m_data = (caddr_t)(head + 1); - m->m_pkthdr.len = m->m_len = le16toh(head->len); + m->m_pkthdr.len = m->m_len = len; + + /* Grab a reference to the source node. */ + wh = mtod(m, struct ieee80211_frame *); + + if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) && + (flags & WPI_RX_CIPHER_MASK) == WPI_RX_CIPHER_CCMP) { + /* Check whether decryption was successful or not. */ + if ((flags & WPI_RX_DECRYPT_MASK) != WPI_RX_DECRYPT_OK) { + DPRINTF(sc, WPI_DEBUG_RECV, + "CCMP decryption failed 0x%x\n", flags); + goto fail2; + } + m->m_flags |= M_WEP; + } - data->m = mnew; - /* update Rx descriptor */ - ring->desc[ring->cur] = htole32(paddr); + if (len >= sizeof(struct ieee80211_frame_min)) + ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); + else + ni = NULL; + + sc->rx_tstamp = tail->tstamp; if (ieee80211_radiotap_active(ic)) { struct wpi_rx_radiotap_header *tap = &sc->sc_rxtap; tap->wr_flags = 0; - tap->wr_chan_freq = - htole16(ic->ic_channels[head->chan].ic_freq); - tap->wr_chan_flags = - htole16(ic->ic_channels[head->chan].ic_flags); - tap->wr_dbm_antsignal = (int8_t)(stat->rssi - WPI_RSSI_OFFSET); - tap->wr_dbm_antnoise = (int8_t)le16toh(stat->noise); + if (head->flags & htole16(WPI_STAT_FLAG_SHPREAMBLE)) + tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; + tap->wr_dbm_antsignal = (int8_t)(stat->rssi + WPI_RSSI_OFFSET); + tap->wr_dbm_antnoise = WPI_RSSI_OFFSET; tap->wr_tsft = tail->tstamp; tap->wr_antenna = (le16toh(head->flags) >> 4) & 0xf; - switch (head->rate) { - /* CCK rates */ - case 10: tap->wr_rate = 2; break; - case 20: tap->wr_rate = 4; break; - case 55: tap->wr_rate = 11; break; - case 110: tap->wr_rate = 22; break; - /* OFDM rates */ - case 0xd: tap->wr_rate = 12; break; - case 0xf: tap->wr_rate = 18; break; - case 0x5: tap->wr_rate = 24; break; - case 0x7: tap->wr_rate = 36; break; - case 0x9: tap->wr_rate = 48; break; - case 0xb: tap->wr_rate = 72; break; - case 0x1: tap->wr_rate = 96; break; - case 0x3: tap->wr_rate = 108; break; - /* unknown rate: should not happen */ - default: tap->wr_rate = 0; - } - if (le16toh(head->flags) & 0x4) - tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; + tap->wr_rate = plcp2rate(head->plcp); } WPI_UNLOCK(sc); - ni = ieee80211_find_rxnode(ic, mtod(m, struct ieee80211_frame_min *)); + /* Send the frame to the 802.11 layer. */ if (ni != NULL) { - (void) ieee80211_input(ni, m, stat->rssi, 0); + (void)ieee80211_input(ni, m, stat->rssi, WPI_RSSI_OFFSET); + /* Node is no longer needed. */ ieee80211_free_node(ni); } else - (void) ieee80211_input_all(ic, m, stat->rssi, 0); + (void)ieee80211_input_all(ic, m, stat->rssi, WPI_RSSI_OFFSET); WPI_LOCK(sc); + + return; + +fail2: m_freem(m); + +fail1: if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); +} + +static void +wpi_rx_statistics(struct wpi_softc *sc, struct wpi_rx_desc *desc, + struct wpi_rx_data *data) +{ + /* Ignore */ } static void -wpi_tx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc) +wpi_tx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) { struct ifnet *ifp = sc->sc_ifp; struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3]; - struct wpi_tx_data *txdata = &ring->data[desc->idx]; + struct wpi_tx_data *data = &ring->data[desc->idx]; struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1); - struct ieee80211_node *ni = txdata->ni; - struct ieee80211vap *vap = ni->ni_vap; - int retrycnt = 0; + struct mbuf *m; + struct ieee80211_node *ni; + struct ieee80211vap *vap; + struct ieee80211com *ic; + uint32_t status = le32toh(stat->status); + int ackfailcnt = stat->ackfailcnt / WPI_NTRIES_DEFAULT; - DPRINTFN(WPI_DEBUG_TX, ("tx done: qid=%d idx=%d retries=%d nkill=%d " - "rate=%x duration=%d status=%x\n", desc->qid, desc->idx, - stat->ntries, stat->nkill, stat->rate, le32toh(stat->duration), - le32toh(stat->status))); + KASSERT(data->ni != NULL, ("no node")); + KASSERT(data->m != NULL, ("no mbuf")); - /* - * Update rate control statistics for the node. - * XXX we should not count mgmt frames since they're always sent at - * the lowest available bit-rate. - * XXX frames w/o ACK shouldn't be used either - */ - if (stat->ntries > 0) { - DPRINTFN(WPI_DEBUG_TX, ("%d retries\n", stat->ntries)); - retrycnt = 1; - } - ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_SUCCESS, - &retrycnt, NULL); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - /* XXX oerrors should only count errors !maxtries */ - if ((le32toh(stat->status) & 0xff) != 1) - ifp->if_oerrors++; - else - ifp->if_opackets++; + DPRINTF(sc, WPI_DEBUG_XMIT, "%s: " + "qid %d idx %d retries %d btkillcnt %d rate %x duration %d " + "status %x\n", __func__, desc->qid, desc->idx, stat->ackfailcnt, + stat->btkillcnt, stat->rate, le32toh(stat->duration), status); - bus_dmamap_sync(ring->data_dmat, txdata->map, BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(ring->data_dmat, txdata->map); - /* XXX handle M_TXCB? */ - m_freem(txdata->m); - txdata->m = NULL; - ieee80211_free_node(txdata->ni); - txdata->ni = NULL; + /* Unmap and free mbuf. */ + bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTWRITE); + bus_dmamap_unload(ring->data_dmat, data->map); + m = data->m, data->m = NULL; + ni = data->ni, data->ni = NULL; + vap = ni->ni_vap; + ic = vap->iv_ic; - ring->queued--; + /* + * Update rate control statistics for the node. + */ + if (status & WPI_TX_STATUS_FAIL) { + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + ieee80211_ratectl_tx_complete(vap, ni, + IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL); + } else { + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); + ieee80211_ratectl_tx_complete(vap, ni, + IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL); + } + + ieee80211_tx_complete(ni, m, (status & WPI_TX_STATUS_FAIL) != 0); + + WPI_TXQ_STATE_LOCK(sc); + ring->queued -= 1; + if (ring->queued > 0) { + callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc); + + if (sc->qfullmsk != 0 && + ring->queued < WPI_TX_RING_LOMARK) { + sc->qfullmsk &= ~(1 << ring->qid); + IF_LOCK(&ifp->if_snd); + if (sc->qfullmsk == 0 && + (ifp->if_drv_flags & IFF_DRV_OACTIVE)) { + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; + IF_UNLOCK(&ifp->if_snd); + ieee80211_runtask(ic, &sc->sc_start_task); + } else + IF_UNLOCK(&ifp->if_snd); + } + } else + callout_stop(&sc->tx_timeout); + WPI_TXQ_STATE_UNLOCK(sc); - sc->sc_tx_timer = 0; - ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; - wpi_start_locked(ifp); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); } +/* + * Process a "command done" firmware notification. This is where we wakeup + * processes waiting for a synchronous command completion. + */ static void -wpi_cmd_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc) +wpi_cmd_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) { - struct wpi_tx_ring *ring = &sc->cmdq; + struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; struct wpi_tx_data *data; - DPRINTFN(WPI_DEBUG_CMD, ("cmd notification qid=%x idx=%d flags=%x " - "type=%s len=%d\n", desc->qid, desc->idx, - desc->flags, wpi_cmd_str(desc->type), - le32toh(desc->len))); + DPRINTF(sc, WPI_DEBUG_CMD, "cmd notification qid %x idx %d flags %x " + "type %s len %d\n", desc->qid, desc->idx, + desc->flags, wpi_cmd_str(desc->type), + le32toh(desc->len)); + + if ((desc->qid & WPI_RX_DESC_QID_MSK) != WPI_CMD_QUEUE_NUM) + return; /* Not a command ack. */ - if ((desc->qid & 7) != 4) - return; /* not a command ack */ + KASSERT(ring->queued == 0, ("ring->queued must be 0")); data = &ring->data[desc->idx]; - /* if the command was mapped in a mbuf, free it */ + /* If the command was mapped in an mbuf, free it. */ if (data->m != NULL) { + bus_dmamap_sync(ring->data_dmat, data->map, + BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(ring->data_dmat, data->map); m_freem(data->m); data->m = NULL; } - sc->flags &= ~WPI_FLAG_BUSY; wakeup(&ring->cmd[desc->idx]); + + if (desc->type == WPI_CMD_SET_POWER_MODE) { + WPI_TXQ_LOCK(sc); + if (sc->sc_flags & WPI_PS_PATH) { + sc->sc_update_rx_ring = wpi_update_rx_ring_ps; + sc->sc_update_tx_ring = wpi_update_tx_ring_ps; + } else { + sc->sc_update_rx_ring = wpi_update_rx_ring; + sc->sc_update_tx_ring = wpi_update_tx_ring; + } + WPI_TXQ_UNLOCK(sc); + } } static void @@ -1647,374 +2201,876 @@ wpi_notif_intr(struct wpi_softc *sc) { struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; - struct wpi_rx_desc *desc; - struct wpi_rx_data *data; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); uint32_t hw; bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, BUS_DMASYNC_POSTREAD); - hw = le32toh(sc->shared->next); + hw = le32toh(sc->shared->next) & 0xfff; + hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1; + while (sc->rxq.cur != hw) { - data = &sc->rxq.data[sc->rxq.cur]; + sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT; + + struct wpi_rx_data *data = &sc->rxq.data[sc->rxq.cur]; + struct wpi_rx_desc *desc; bus_dmamap_sync(sc->rxq.data_dmat, data->map, BUS_DMASYNC_POSTREAD); - desc = (void *)data->m->m_ext.ext_buf; + desc = mtod(data->m, struct wpi_rx_desc *); - DPRINTFN(WPI_DEBUG_NOTIFY, - ("notify qid=%x idx=%d flags=%x type=%d len=%d\n", - desc->qid, - desc->idx, - desc->flags, - desc->type, - le32toh(desc->len))); + DPRINTF(sc, WPI_DEBUG_NOTIFY, + "%s: cur=%d; qid %x idx %d flags %x type %d(%s) len %d\n", + __func__, sc->rxq.cur, desc->qid, desc->idx, desc->flags, + desc->type, wpi_cmd_str(desc->type), le32toh(desc->len)); - if (!(desc->qid & 0x80)) /* reply to a command */ - wpi_cmd_intr(sc, desc); + if (!(desc->qid & WPI_UNSOLICITED_RX_NOTIF)) { + /* Reply to a command. */ + wpi_cmd_done(sc, desc); + } switch (desc->type) { case WPI_RX_DONE: - /* a 802.11 frame was received */ - wpi_rx_intr(sc, desc, data); + /* An 802.11 frame has been received. */ + wpi_rx_done(sc, desc, data); + + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { + /* wpi_stop() was called. */ + return; + } + break; case WPI_TX_DONE: - /* a 802.11 frame has been transmitted */ - wpi_tx_intr(sc, desc); + /* An 802.11 frame has been transmitted. */ + wpi_tx_done(sc, desc); break; + case WPI_RX_STATISTICS: + case WPI_BEACON_STATISTICS: + wpi_rx_statistics(sc, desc, data); + break; + + case WPI_BEACON_MISSED: + { + struct wpi_beacon_missed *miss = + (struct wpi_beacon_missed *)(desc + 1); + uint32_t expected, misses, received, threshold; + + bus_dmamap_sync(sc->rxq.data_dmat, data->map, + BUS_DMASYNC_POSTREAD); + + misses = le32toh(miss->consecutive); + expected = le32toh(miss->expected); + received = le32toh(miss->received); + threshold = MAX(2, vap->iv_bmissthreshold); + + DPRINTF(sc, WPI_DEBUG_BMISS, + "%s: beacons missed %u(%u) (received %u/%u)\n", + __func__, misses, le32toh(miss->total), received, + expected); + + if (misses >= threshold || + (received == 0 && expected >= threshold)) { + WPI_RXON_LOCK(sc); + if (callout_pending(&sc->scan_timeout)) { + wpi_cmd(sc, WPI_CMD_SCAN_ABORT, NULL, + 0, 1); + } + WPI_RXON_UNLOCK(sc); + if (vap->iv_state == IEEE80211_S_RUN && + (ic->ic_flags & IEEE80211_F_SCAN) == 0) + ieee80211_beacon_miss(ic); + } + + break; + } +#ifdef WPI_DEBUG + case WPI_BEACON_SENT: + { + struct wpi_tx_stat *stat = + (struct wpi_tx_stat *)(desc + 1); + uint64_t *tsf = (uint64_t *)(stat + 1); + uint32_t *mode = (uint32_t *)(tsf + 1); + + bus_dmamap_sync(sc->rxq.data_dmat, data->map, + BUS_DMASYNC_POSTREAD); + + DPRINTF(sc, WPI_DEBUG_BEACON, + "beacon sent: rts %u, ack %u, btkill %u, rate %u, " + "duration %u, status %x, tsf %ju, mode %x\n", + stat->rtsfailcnt, stat->ackfailcnt, + stat->btkillcnt, stat->rate, le32toh(stat->duration), + le32toh(stat->status), *tsf, *mode); + + break; + } +#endif case WPI_UC_READY: { struct wpi_ucode_info *uc = - (struct wpi_ucode_info *)(desc + 1); + (struct wpi_ucode_info *)(desc + 1); - /* the microcontroller is ready */ - DPRINTF(("microcode alive notification version %x " - "alive %x\n", le32toh(uc->version), - le32toh(uc->valid))); + /* The microcontroller is ready. */ + bus_dmamap_sync(sc->rxq.data_dmat, data->map, + BUS_DMASYNC_POSTREAD); + DPRINTF(sc, WPI_DEBUG_RESET, + "microcode alive notification version=%d.%d " + "subtype=%x alive=%x\n", uc->major, uc->minor, + uc->subtype, le32toh(uc->valid)); if (le32toh(uc->valid) != 1) { device_printf(sc->sc_dev, "microcontroller initialization failed\n"); wpi_stop_locked(sc); } + /* Save the address of the error log in SRAM. */ + sc->errptr = le32toh(uc->errptr); break; } case WPI_STATE_CHANGED: { + bus_dmamap_sync(sc->rxq.data_dmat, data->map, + BUS_DMASYNC_POSTREAD); + uint32_t *status = (uint32_t *)(desc + 1); - /* enabled/disabled notification */ - DPRINTF(("state changed to %x\n", le32toh(*status))); + DPRINTF(sc, WPI_DEBUG_STATE, "state changed to %x\n", + le32toh(*status)); if (le32toh(*status) & 1) { - device_printf(sc->sc_dev, - "Radio transmitter is switched off\n"); - sc->flags |= WPI_FLAG_HW_RADIO_OFF; - ifp->if_drv_flags &= ~IFF_DRV_RUNNING; - /* Disable firmware commands */ - WPI_WRITE(sc, WPI_UCODE_SET, WPI_DISABLE_CMD); + WPI_NT_LOCK(sc); + wpi_clear_node_table(sc); + WPI_NT_UNLOCK(sc); + taskqueue_enqueue(sc->sc_tq, + &sc->sc_radiooff_task); + return; } break; } +#ifdef WPI_DEBUG case WPI_START_SCAN: { -#ifdef WPI_DEBUG + bus_dmamap_sync(sc->rxq.data_dmat, data->map, + BUS_DMASYNC_POSTREAD); + struct wpi_start_scan *scan = - (struct wpi_start_scan *)(desc + 1); -#endif + (struct wpi_start_scan *)(desc + 1); + DPRINTF(sc, WPI_DEBUG_SCAN, + "%s: scanning channel %d status %x\n", + __func__, scan->chan, le32toh(scan->status)); - DPRINTFN(WPI_DEBUG_SCANNING, - ("scanning channel %d status %x\n", - scan->chan, le32toh(scan->status))); break; } +#endif case WPI_STOP_SCAN: { -#ifdef WPI_DEBUG - struct wpi_stop_scan *scan = - (struct wpi_stop_scan *)(desc + 1); -#endif - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - - DPRINTFN(WPI_DEBUG_SCANNING, - ("scan finished nchan=%d status=%d chan=%d\n", - scan->nchan, scan->status, scan->chan)); + bus_dmamap_sync(sc->rxq.data_dmat, data->map, + BUS_DMASYNC_POSTREAD); - sc->sc_scan_timer = 0; - ieee80211_scan_next(vap); + struct wpi_stop_scan *scan = + (struct wpi_stop_scan *)(desc + 1); + + DPRINTF(sc, WPI_DEBUG_SCAN, + "scan finished nchan=%d status=%d chan=%d\n", + scan->nchan, scan->status, scan->chan); + + WPI_RXON_LOCK(sc); + callout_stop(&sc->scan_timeout); + WPI_RXON_UNLOCK(sc); + if (scan->status == WPI_SCAN_ABORTED) + ieee80211_cancel_scan(vap); + else + ieee80211_scan_next(vap); break; } - case WPI_MISSED_BEACON: - { - struct wpi_missed_beacon *beacon = - (struct wpi_missed_beacon *)(desc + 1); - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - - if (le32toh(beacon->consecutive) >= - vap->iv_bmissthreshold) { - DPRINTF(("Beacon miss: %u >= %u\n", - le32toh(beacon->consecutive), - vap->iv_bmissthreshold)); - ieee80211_beacon_miss(ic); - } - break; } + + if (sc->rxq.cur % 8 == 0) { + /* Tell the firmware what we have processed. */ + sc->sc_update_rx_ring(sc); } + } +} - sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT; +/* + * Process an INT_WAKEUP interrupt raised when the microcontroller wakes up + * from power-down sleep mode. + */ +static void +wpi_wakeup_intr(struct wpi_softc *sc) +{ + int qid; + + DPRINTF(sc, WPI_DEBUG_PWRSAVE, + "%s: ucode wakeup from power-down sleep\n", __func__); + + /* Wakeup RX and TX rings. */ + if (sc->rxq.update) { + sc->rxq.update = 0; + wpi_update_rx_ring(sc); } + WPI_TXQ_LOCK(sc); + for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) { + struct wpi_tx_ring *ring = &sc->txq[qid]; - /* tell the firmware what we have processed */ - hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1; - WPI_WRITE(sc, WPI_RX_WIDX, hw & ~7); + if (ring->update) { + ring->update = 0; + wpi_update_tx_ring(sc, ring); + } + } + WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); + WPI_TXQ_UNLOCK(sc); +} + +/* + * This function prints firmware registers + */ +#ifdef WPI_DEBUG +static void +wpi_debug_registers(struct wpi_softc *sc) +{ + size_t i; + static const uint32_t csr_tbl[] = { + WPI_HW_IF_CONFIG, + WPI_INT, + WPI_INT_MASK, + WPI_FH_INT, + WPI_GPIO_IN, + WPI_RESET, + WPI_GP_CNTRL, + WPI_EEPROM, + WPI_EEPROM_GP, + WPI_GIO, + WPI_UCODE_GP1, + WPI_UCODE_GP2, + WPI_GIO_CHICKEN, + WPI_ANA_PLL, + WPI_DBG_HPET_MEM, + }; + static const uint32_t prph_tbl[] = { + WPI_APMG_CLK_CTRL, + WPI_APMG_PS, + WPI_APMG_PCI_STT, + WPI_APMG_RFKILL, + }; + + DPRINTF(sc, WPI_DEBUG_REGISTER,"%s","\n"); + + for (i = 0; i < nitems(csr_tbl); i++) { + DPRINTF(sc, WPI_DEBUG_REGISTER, " %-18s: 0x%08x ", + wpi_get_csr_string(csr_tbl[i]), WPI_READ(sc, csr_tbl[i])); + + if ((i + 1) % 2 == 0) + DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); + } + DPRINTF(sc, WPI_DEBUG_REGISTER, "\n\n"); + + if (wpi_nic_lock(sc) == 0) { + for (i = 0; i < nitems(prph_tbl); i++) { + DPRINTF(sc, WPI_DEBUG_REGISTER, " %-18s: 0x%08x ", + wpi_get_prph_string(prph_tbl[i]), + wpi_prph_read(sc, prph_tbl[i])); + + if ((i + 1) % 2 == 0) + DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); + } + DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); + wpi_nic_unlock(sc); + } else { + DPRINTF(sc, WPI_DEBUG_REGISTER, + "Cannot access internal registers.\n"); + } +} +#endif + +/* + * Dump the error log of the firmware when a firmware panic occurs. Although + * we can't debug the firmware because it is neither open source nor free, it + * can help us to identify certain classes of problems. + */ +static void +wpi_fatal_intr(struct wpi_softc *sc) +{ + struct wpi_fw_dump dump; + uint32_t i, offset, count; + + /* Check that the error log address is valid. */ + if (sc->errptr < WPI_FW_DATA_BASE || + sc->errptr + sizeof (dump) > + WPI_FW_DATA_BASE + WPI_FW_DATA_MAXSZ) { + printf("%s: bad firmware error log address 0x%08x\n", __func__, + sc->errptr); + return; + } + if (wpi_nic_lock(sc) != 0) { + printf("%s: could not read firmware error log\n", __func__); + return; + } + /* Read number of entries in the log. */ + count = wpi_mem_read(sc, sc->errptr); + if (count == 0 || count * sizeof (dump) > WPI_FW_DATA_MAXSZ) { + printf("%s: invalid count field (count = %u)\n", __func__, + count); + wpi_nic_unlock(sc); + return; + } + /* Skip "count" field. */ + offset = sc->errptr + sizeof (uint32_t); + printf("firmware error log (count = %u):\n", count); + for (i = 0; i < count; i++) { + wpi_mem_read_region_4(sc, offset, (uint32_t *)&dump, + sizeof (dump) / sizeof (uint32_t)); + + printf(" error type = \"%s\" (0x%08X)\n", + (dump.desc < nitems(wpi_fw_errmsg)) ? + wpi_fw_errmsg[dump.desc] : "UNKNOWN", + dump.desc); + printf(" error data = 0x%08X\n", + dump.data); + printf(" branch link = 0x%08X%08X\n", + dump.blink[0], dump.blink[1]); + printf(" interrupt link = 0x%08X%08X\n", + dump.ilink[0], dump.ilink[1]); + printf(" time = %u\n", dump.time); + + offset += sizeof (dump); + } + wpi_nic_unlock(sc); + /* Dump driver status (TX and RX rings) while we're here. */ + printf("driver status:\n"); + WPI_TXQ_LOCK(sc); + for (i = 0; i < WPI_DRV_NTXQUEUES; i++) { + struct wpi_tx_ring *ring = &sc->txq[i]; + printf(" tx ring %2d: qid=%-2d cur=%-3d queued=%-3d\n", + i, ring->qid, ring->cur, ring->queued); + } + WPI_TXQ_UNLOCK(sc); + printf(" rx ring: cur=%d\n", sc->rxq.cur); } static void wpi_intr(void *arg) { struct wpi_softc *sc = arg; - uint32_t r; + struct ifnet *ifp = sc->sc_ifp; + uint32_t r1, r2; WPI_LOCK(sc); - r = WPI_READ(sc, WPI_INTR); - if (r == 0 || r == 0xffffffff) { - WPI_UNLOCK(sc); - return; - } + /* Disable interrupts. */ + WPI_WRITE(sc, WPI_INT_MASK, 0); + + r1 = WPI_READ(sc, WPI_INT); + + if (r1 == 0xffffffff || (r1 & 0xfffffff0) == 0xa5a5a5a0) + goto end; /* Hardware gone! */ - /* disable interrupts */ - WPI_WRITE(sc, WPI_MASK, 0); - /* ack interrupts */ - WPI_WRITE(sc, WPI_INTR, r); + r2 = WPI_READ(sc, WPI_FH_INT); - if (r & (WPI_SW_ERROR | WPI_HW_ERROR)) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + DPRINTF(sc, WPI_DEBUG_INTR, "%s: reg1=0x%08x reg2=0x%08x\n", __func__, + r1, r2); + if (r1 == 0 && r2 == 0) + goto done; /* Interrupt not for us. */ + + /* Acknowledge interrupts. */ + WPI_WRITE(sc, WPI_INT, r1); + WPI_WRITE(sc, WPI_FH_INT, r2); + + if (r1 & (WPI_INT_SW_ERR | WPI_INT_HW_ERR)) { device_printf(sc->sc_dev, "fatal firmware error\n"); - DPRINTFN(6,("(%s)\n", (r & WPI_SW_ERROR) ? "(Software Error)" : - "(Hardware Error)")); - if (vap != NULL) - ieee80211_cancel_scan(vap); - ieee80211_runtask(ic, &sc->sc_restarttask); - sc->flags &= ~WPI_FLAG_BUSY; - WPI_UNLOCK(sc); - return; +#ifdef WPI_DEBUG + wpi_debug_registers(sc); +#endif + wpi_fatal_intr(sc); + DPRINTF(sc, WPI_DEBUG_HW, + "(%s)\n", (r1 & WPI_INT_SW_ERR) ? "(Software Error)" : + "(Hardware Error)"); + taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask); + goto end; } - if (r & WPI_RX_INTR) + if ((r1 & (WPI_INT_FH_RX | WPI_INT_SW_RX)) || + (r2 & WPI_FH_INT_RX)) wpi_notif_intr(sc); - if (r & WPI_ALIVE_INTR) /* firmware initialized */ - wakeup(sc); + if (r1 & WPI_INT_ALIVE) + wakeup(sc); /* Firmware is alive. */ - /* re-enable interrupts */ - if (sc->sc_ifp->if_flags & IFF_UP) - WPI_WRITE(sc, WPI_MASK, WPI_INTR_MASK); + if (r1 & WPI_INT_WAKEUP) + wpi_wakeup_intr(sc); - WPI_UNLOCK(sc); +done: + /* Re-enable interrupts. */ + if (ifp->if_flags & IFF_UP) + WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); + +end: WPI_UNLOCK(sc); } -static uint8_t -wpi_plcp_signal(int rate) +static int +wpi_cmd2(struct wpi_softc *sc, struct wpi_buf *buf) { - switch (rate) { - /* CCK rates (returned values are device-dependent) */ - case 2: return 10; - case 4: return 20; - case 11: return 55; - case 22: return 110; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211_frame *wh; + struct wpi_tx_cmd *cmd; + struct wpi_tx_data *data; + struct wpi_tx_desc *desc; + struct wpi_tx_ring *ring; + struct mbuf *m1; + bus_dma_segment_t *seg, segs[WPI_MAX_SCATTER]; + int error, i, hdrlen, nsegs, totlen, pad; - /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */ - /* R1-R4 (ral/ural is R4-R1) */ - case 12: return 0xd; - case 18: return 0xf; - case 24: return 0x5; - case 36: return 0x7; - case 48: return 0x9; - case 72: return 0xb; - case 96: return 0x1; - case 108: return 0x3; + WPI_TXQ_LOCK(sc); - /* unsupported rates (should not get there) */ - default: return 0; + KASSERT(buf->size <= sizeof(buf->data), ("buffer overflow")); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + if (sc->txq_active == 0) { + /* wpi_stop() was called */ + error = ENETDOWN; + goto fail; } -} -/* quickly determine if a given rate is CCK or OFDM */ -#define WPI_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22) + wh = mtod(buf->m, struct ieee80211_frame *); + hdrlen = ieee80211_anyhdrsize(wh); + totlen = buf->m->m_pkthdr.len; + + if (hdrlen & 3) { + /* First segment length must be a multiple of 4. */ + pad = 4 - (hdrlen & 3); + } else + pad = 0; + + ring = &sc->txq[buf->ac]; + desc = &ring->desc[ring->cur]; + data = &ring->data[ring->cur]; + + /* Prepare TX firmware command. */ + cmd = &ring->cmd[ring->cur]; + cmd->code = buf->code; + cmd->flags = 0; + cmd->qid = ring->qid; + cmd->idx = ring->cur; + + memcpy(cmd->data, buf->data, buf->size); + + /* Save and trim IEEE802.11 header. */ + memcpy((uint8_t *)(cmd->data + buf->size), wh, hdrlen); + m_adj(buf->m, hdrlen); + + error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, buf->m, + segs, &nsegs, BUS_DMA_NOWAIT); + if (error != 0 && error != EFBIG) { + device_printf(sc->sc_dev, + "%s: can't map mbuf (error %d)\n", __func__, error); + goto fail; + } + if (error != 0) { + /* Too many DMA segments, linearize mbuf. */ + m1 = m_collapse(buf->m, M_NOWAIT, WPI_MAX_SCATTER - 1); + if (m1 == NULL) { + device_printf(sc->sc_dev, + "%s: could not defrag mbuf\n", __func__); + error = ENOBUFS; + goto fail; + } + buf->m = m1; + + error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, + buf->m, segs, &nsegs, BUS_DMA_NOWAIT); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: can't map mbuf (error %d)\n", __func__, + error); + goto fail; + } + } + + KASSERT(nsegs < WPI_MAX_SCATTER, + ("too many DMA segments, nsegs (%d) should be less than %d", + nsegs, WPI_MAX_SCATTER)); + + data->m = buf->m; + data->ni = buf->ni; + + DPRINTF(sc, WPI_DEBUG_XMIT, "%s: qid %d idx %d len %d nsegs %d\n", + __func__, ring->qid, ring->cur, totlen, nsegs); + + /* Fill TX descriptor. */ + desc->nsegs = WPI_PAD32(totlen + pad) << 4 | (1 + nsegs); + /* First DMA segment is used by the TX command. */ + desc->segs[0].addr = htole32(data->cmd_paddr); + desc->segs[0].len = htole32(4 + buf->size + hdrlen + pad); + /* Other DMA segments are for data payload. */ + seg = &segs[0]; + for (i = 1; i <= nsegs; i++) { + desc->segs[i].addr = htole32(seg->ds_addr); + desc->segs[i].len = htole32(seg->ds_len); + seg++; + } + + bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); + bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, + BUS_DMASYNC_PREWRITE); + bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, + BUS_DMASYNC_PREWRITE); + + /* Kick TX ring. */ + ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; + sc->sc_update_tx_ring(sc, ring); + + if (ring->qid < WPI_CMD_QUEUE_NUM) { + /* Mark TX ring as full if we reach a certain threshold. */ + WPI_TXQ_STATE_LOCK(sc); + if (++ring->queued > WPI_TX_RING_HIMARK) { + sc->qfullmsk |= 1 << ring->qid; + + IF_LOCK(&ifp->if_snd); + ifp->if_drv_flags |= IFF_DRV_OACTIVE; + IF_UNLOCK(&ifp->if_snd); + } + + callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc); + WPI_TXQ_STATE_UNLOCK(sc); + } + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + WPI_TXQ_UNLOCK(sc); + + return 0; + +fail: m_freem(buf->m); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + + WPI_TXQ_UNLOCK(sc); + + return error; +} /* - * Construct the data packet for a transmit buffer and acutally put - * the buffer onto the transmit ring, kicking the card to process the - * the buffer. + * Construct the data packet for a transmit buffer. */ static int -wpi_tx_data(struct wpi_softc *sc, struct mbuf *m0, struct ieee80211_node *ni, - int ac) +wpi_tx_data(struct wpi_softc *sc, struct mbuf *m, struct ieee80211_node *ni) { + const struct ieee80211_txparam *tp; struct ieee80211vap *vap = ni->ni_vap; - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - const struct chanAccParams *cap = &ic->ic_wme.wme_chanParams; - struct wpi_tx_ring *ring = &sc->txq[ac]; - struct wpi_tx_desc *desc; - struct wpi_tx_data *data; - struct wpi_tx_cmd *cmd; - struct wpi_cmd_data *tx; + struct ieee80211com *ic = ni->ni_ic; + struct wpi_node *wn = WPI_NODE(ni); + struct ieee80211_channel *chan; struct ieee80211_frame *wh; - const struct ieee80211_txparam *tp; - struct ieee80211_key *k; - struct mbuf *mnew; - int i, error, nsegs, rate, hdrlen, ismcast; - bus_dma_segment_t segs[WPI_MAX_SCATTER]; + struct ieee80211_key *k = NULL; + struct wpi_buf tx_data; + struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; + uint32_t flags; + uint16_t qos; + uint8_t tid, type; + int ac, error, swcrypt, rate, ismcast, totlen; + + wh = mtod(m, struct ieee80211_frame *); + type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; + ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); - desc = &ring->desc[ring->cur]; - data = &ring->data[ring->cur]; + /* Select EDCA Access Category and TX ring for this frame. */ + if (IEEE80211_QOS_HAS_SEQ(wh)) { + qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0]; + tid = qos & IEEE80211_QOS_TID; + } else { + qos = 0; + tid = 0; + } + ac = M_WME_GETAC(m); - wh = mtod(m0, struct ieee80211_frame *); + chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ? + ni->ni_chan : ic->ic_curchan; + tp = &vap->iv_txparms[ieee80211_chan2mode(chan)]; - hdrlen = ieee80211_hdrsize(wh); - ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); + /* Choose a TX rate index. */ + if (type == IEEE80211_FC0_TYPE_MGT) + rate = tp->mgmtrate; + else if (ismcast) + rate = tp->mcastrate; + else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) + rate = tp->ucastrate; + else if (m->m_flags & M_EAPOL) + rate = tp->mgmtrate; + else { + /* XXX pass pktlen */ + (void) ieee80211_ratectl_rate(ni, NULL, 0); + rate = ni->ni_txrate; + } + /* Encrypt the frame if need be. */ if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { - k = ieee80211_crypto_encap(ni, m0); + /* Retrieve key for TX. */ + k = ieee80211_crypto_encap(ni, m); if (k == NULL) { - m_freem(m0); - return ENOBUFS; + error = ENOBUFS; + goto fail; } - /* packet header may have moved, reset our local pointer */ - wh = mtod(m0, struct ieee80211_frame *); + swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; + + /* 802.11 header may have moved. */ + wh = mtod(m, struct ieee80211_frame *); } + totlen = m->m_pkthdr.len; - cmd = &ring->cmd[ring->cur]; - cmd->code = WPI_CMD_TX_DATA; - cmd->flags = 0; - cmd->qid = ring->qid; - cmd->idx = ring->cur; + if (ieee80211_radiotap_active_vap(vap)) { + struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; - tx = (struct wpi_cmd_data *)cmd->data; - tx->flags = htole32(WPI_TX_AUTO_SEQ); - tx->timeout = htole16(0); - tx->ofdm_mask = 0xff; - tx->cck_mask = 0x0f; - tx->lifetime = htole32(WPI_LIFETIME_INFINITE); - tx->id = ismcast ? WPI_ID_BROADCAST : WPI_ID_BSS; - tx->len = htole16(m0->m_pkthdr.len); + tap->wt_flags = 0; + tap->wt_rate = rate; + if (k != NULL) + tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; + + ieee80211_radiotap_tx(vap, m); + } + + flags = 0; + if (!ismcast) { + /* Unicast frame, check if an ACK is expected. */ + if (!qos || (qos & IEEE80211_QOS_ACKPOLICY) != + IEEE80211_QOS_ACKPOLICY_NOACK) + flags |= WPI_TX_NEED_ACK; + } + + if (!IEEE80211_QOS_HAS_SEQ(wh)) + flags |= WPI_TX_AUTO_SEQ; + if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) + flags |= WPI_TX_MORE_FRAG; /* Cannot happen yet. */ + /* Check if frame must be protected using RTS/CTS or CTS-to-self. */ if (!ismcast) { - if ((ni->ni_flags & IEEE80211_NODE_QOS) == 0 || - !cap->cap_wmeParams[ac].wmep_noackPolicy) - tx->flags |= htole32(WPI_TX_NEED_ACK); - if (m0->m_pkthdr.len + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) { - tx->flags |= htole32(WPI_TX_NEED_RTS|WPI_TX_FULL_TXOP); - tx->rts_ntries = 7; + /* NB: Group frames are sent using CCK in 802.11b/g. */ + if (totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) { + flags |= WPI_TX_NEED_RTS; + } else if ((ic->ic_flags & IEEE80211_F_USEPROT) && + WPI_RATE_IS_OFDM(rate)) { + if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) + flags |= WPI_TX_NEED_CTS; + else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) + flags |= WPI_TX_NEED_RTS; } + + if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) + flags |= WPI_TX_FULL_TXOP; } - /* pick a rate */ - tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)]; - if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_MGT) { + + memset(tx, 0, sizeof (struct wpi_cmd_data)); + if (type == IEEE80211_FC0_TYPE_MGT) { uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; - /* tell h/w to set timestamp in probe responses */ + + /* Tell HW to set timestamp in probe responses. */ if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) - tx->flags |= htole32(WPI_TX_INSERT_TSTAMP); + flags |= WPI_TX_INSERT_TSTAMP; if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) tx->timeout = htole16(3); else tx->timeout = htole16(2); - rate = tp->mgmtrate; - } else if (ismcast) { - rate = tp->mcastrate; - } else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) { - rate = tp->ucastrate; - } else { - (void) ieee80211_ratectl_rate(ni, NULL, 0); - rate = ni->ni_txrate; } - tx->rate = wpi_plcp_signal(rate); - /* be very persistant at sending frames out */ -#if 0 + if (ismcast || type != IEEE80211_FC0_TYPE_DATA) + tx->id = WPI_ID_BROADCAST; + else { + if (wn->id == WPI_ID_UNDEFINED) { + device_printf(sc->sc_dev, + "%s: undefined node id\n", __func__); + error = EINVAL; + goto fail; + } + + tx->id = wn->id; + } + + if (k != NULL && !swcrypt) { + switch (k->wk_cipher->ic_cipher) { + case IEEE80211_CIPHER_AES_CCM: + tx->security = WPI_CIPHER_CCMP; + break; + + default: + break; + } + + memcpy(tx->key, k->wk_key, k->wk_keylen); + } + + tx->len = htole16(totlen); + tx->flags = htole32(flags); + tx->plcp = rate2plcp(rate); + tx->tid = tid; + tx->lifetime = htole32(WPI_LIFETIME_INFINITE); + tx->ofdm_mask = 0xff; + tx->cck_mask = 0x0f; + tx->rts_ntries = 7; tx->data_ntries = tp->maxretry; -#else - tx->data_ntries = 15; /* XXX way too high */ -#endif + + tx_data.ni = ni; + tx_data.m = m; + tx_data.size = sizeof(struct wpi_cmd_data); + tx_data.code = WPI_CMD_TX_DATA; + tx_data.ac = ac; + + return wpi_cmd2(sc, &tx_data); + +fail: m_freem(m); + return error; +} + +static int +wpi_tx_data_raw(struct wpi_softc *sc, struct mbuf *m, + struct ieee80211_node *ni, const struct ieee80211_bpf_params *params) +{ + struct ieee80211vap *vap = ni->ni_vap; + struct ieee80211_key *k = NULL; + struct ieee80211_frame *wh; + struct wpi_buf tx_data; + struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; + uint32_t flags; + uint8_t type; + int ac, rate, swcrypt, totlen; + + wh = mtod(m, struct ieee80211_frame *); + type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; + + ac = params->ibp_pri & 3; + + /* Choose a TX rate index. */ + rate = params->ibp_rate0; + + flags = 0; + if (!IEEE80211_QOS_HAS_SEQ(wh)) + flags |= WPI_TX_AUTO_SEQ; + if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0) + flags |= WPI_TX_NEED_ACK; + if (params->ibp_flags & IEEE80211_BPF_RTS) + flags |= WPI_TX_NEED_RTS; + if (params->ibp_flags & IEEE80211_BPF_CTS) + flags |= WPI_TX_NEED_CTS; + if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) + flags |= WPI_TX_FULL_TXOP; + + /* Encrypt the frame if need be. */ + if (params->ibp_flags & IEEE80211_BPF_CRYPTO) { + /* Retrieve key for TX. */ + k = ieee80211_crypto_encap(ni, m); + if (k == NULL) { + m_freem(m); + return ENOBUFS; + } + swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; + + /* 802.11 header may have moved. */ + wh = mtod(m, struct ieee80211_frame *); + } + totlen = m->m_pkthdr.len; if (ieee80211_radiotap_active_vap(vap)) { struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; + tap->wt_flags = 0; tap->wt_rate = rate; - tap->wt_hwqueue = ac; - if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) + if (params->ibp_flags & IEEE80211_BPF_CRYPTO) tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; - ieee80211_radiotap_tx(vap, m0); + ieee80211_radiotap_tx(vap, m); } - /* save and trim IEEE802.11 header */ - m_copydata(m0, 0, hdrlen, (caddr_t)&tx->wh); - m_adj(m0, hdrlen); + memset(tx, 0, sizeof (struct wpi_cmd_data)); + if (type == IEEE80211_FC0_TYPE_MGT) { + uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; - error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, m0, segs, - &nsegs, BUS_DMA_NOWAIT); - if (error != 0 && error != EFBIG) { - device_printf(sc->sc_dev, "could not map mbuf (error %d)\n", - error); - m_freem(m0); - return error; + /* Tell HW to set timestamp in probe responses. */ + if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) + flags |= WPI_TX_INSERT_TSTAMP; + if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || + subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) + tx->timeout = htole16(3); + else + tx->timeout = htole16(2); } - if (error != 0) { - /* XXX use m_collapse */ - mnew = m_defrag(m0, M_NOWAIT); - if (mnew == NULL) { - device_printf(sc->sc_dev, - "could not defragment mbuf\n"); - m_freem(m0); - return ENOBUFS; - } - m0 = mnew; - error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, - m0, segs, &nsegs, BUS_DMA_NOWAIT); - if (error != 0) { - device_printf(sc->sc_dev, - "could not map mbuf (error %d)\n", error); - m_freem(m0); - return error; + if (k != NULL && !swcrypt) { + switch (k->wk_cipher->ic_cipher) { + case IEEE80211_CIPHER_AES_CCM: + tx->security = WPI_CIPHER_CCMP; + break; + + default: + break; } + + memcpy(tx->key, k->wk_key, k->wk_keylen); } - data->m = m0; - data->ni = ni; + tx->len = htole16(totlen); + tx->flags = htole32(flags); + tx->plcp = rate2plcp(rate); + tx->id = WPI_ID_BROADCAST; + tx->lifetime = htole32(WPI_LIFETIME_INFINITE); + tx->rts_ntries = params->ibp_try1; + tx->data_ntries = params->ibp_try0; - DPRINTFN(WPI_DEBUG_TX, ("sending data: qid=%d idx=%d len=%d nsegs=%d\n", - ring->qid, ring->cur, m0->m_pkthdr.len, nsegs)); + tx_data.ni = ni; + tx_data.m = m; + tx_data.size = sizeof(struct wpi_cmd_data); + tx_data.code = WPI_CMD_TX_DATA; + tx_data.ac = ac; - /* first scatter/gather segment is used by the tx data command */ - desc->flags = htole32(WPI_PAD32(m0->m_pkthdr.len) << 28 | - (1 + nsegs) << 24); - desc->segs[0].addr = htole32(ring->cmd_dma.paddr + - ring->cur * sizeof (struct wpi_tx_cmd)); - desc->segs[0].len = htole32(4 + sizeof (struct wpi_cmd_data)); - for (i = 1; i <= nsegs; i++) { - desc->segs[i].addr = htole32(segs[i - 1].ds_addr); - desc->segs[i].len = htole32(segs[i - 1].ds_len); + return wpi_cmd2(sc, &tx_data); +} + +static int +wpi_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, + const struct ieee80211_bpf_params *params) +{ + struct ieee80211com *ic = ni->ni_ic; + struct ifnet *ifp = ic->ic_ifp; + struct wpi_softc *sc = ifp->if_softc; + int error = 0; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { + ieee80211_free_node(ni); + m_freem(m); + return ENETDOWN; } - bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); - bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, - BUS_DMASYNC_PREWRITE); + WPI_TX_LOCK(sc); + if (params == NULL) { + /* + * Legacy path; interpret frame contents to decide + * precisely how to send the frame. + */ + error = wpi_tx_data(sc, m, ni); + } else { + /* + * Caller supplied explicit parameters to use in + * sending the frame. + */ + error = wpi_tx_data_raw(sc, m, ni, params); + } + WPI_TX_UNLOCK(sc); - ring->queued++; + if (error != 0) { + /* NB: m is reclaimed on tx failure */ + ieee80211_free_node(ni); + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); - /* kick ring */ - ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; - WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + + return error; + } + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); return 0; } @@ -2026,84 +3082,81 @@ static void wpi_start(struct ifnet *ifp) { struct wpi_softc *sc = ifp->if_softc; - - WPI_LOCK(sc); - wpi_start_locked(ifp); - WPI_UNLOCK(sc); -} - -static void -wpi_start_locked(struct ifnet *ifp) -{ - struct wpi_softc *sc = ifp->if_softc; struct ieee80211_node *ni; struct mbuf *m; - int ac; - WPI_LOCK_ASSERT(sc); - - if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) - return; + WPI_TX_LOCK(sc); + DPRINTF(sc, WPI_DEBUG_XMIT, "%s: called\n", __func__); for (;;) { + IF_LOCK(&ifp->if_snd); + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || + (ifp->if_drv_flags & IFF_DRV_OACTIVE)) { + IF_UNLOCK(&ifp->if_snd); + break; + } + IF_UNLOCK(&ifp->if_snd); + IFQ_DRV_DEQUEUE(&ifp->if_snd, m); if (m == NULL) break; - ac = M_WME_GETAC(m); - if (sc->txq[ac].queued > sc->txq[ac].count - 8) { - /* there is no place left in this ring */ - IFQ_DRV_PREPEND(&ifp->if_snd, m); - ifp->if_drv_flags |= IFF_DRV_OACTIVE; - break; - } - ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; - if (wpi_tx_data(sc, m, ni, ac) != 0) { + ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; + if (wpi_tx_data(sc, m, ni) != 0) { ieee80211_free_node(ni); - ifp->if_oerrors++; - break; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } - sc->sc_tx_timer = 5; } + + DPRINTF(sc, WPI_DEBUG_XMIT, "%s: done\n", __func__); + WPI_TX_UNLOCK(sc); } -static int -wpi_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, - const struct ieee80211_bpf_params *params) +static void +wpi_start_task(void *arg0, int pending) { - struct ieee80211com *ic = ni->ni_ic; - struct ifnet *ifp = ic->ic_ifp; - struct wpi_softc *sc = ifp->if_softc; + struct wpi_softc *sc = arg0; + struct ifnet *ifp = sc->sc_ifp; - /* prevent management frames from being sent if we're not ready */ - if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { - m_freem(m); - ieee80211_free_node(ni); - return ENETDOWN; - } - WPI_LOCK(sc); + wpi_start(ifp); +} - /* management frames go into ring 0 */ - if (sc->txq[0].queued > sc->txq[0].count - 8) { - ifp->if_drv_flags |= IFF_DRV_OACTIVE; - m_freem(m); - WPI_UNLOCK(sc); - ieee80211_free_node(ni); - return ENOBUFS; /* XXX */ - } +static void +wpi_watchdog_rfkill(void *arg) +{ + struct wpi_softc *sc = arg; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; - ifp->if_opackets++; - if (wpi_tx_data(sc, m, ni, 0) != 0) - goto bad; - sc->sc_tx_timer = 5; - callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); + DPRINTF(sc, WPI_DEBUG_WATCHDOG, "RFkill Watchdog: tick\n"); - WPI_UNLOCK(sc); - return 0; -bad: - ifp->if_oerrors++; - WPI_UNLOCK(sc); - ieee80211_free_node(ni); - return EIO; /* XXX */ + /* No need to lock firmware memory. */ + if ((wpi_prph_read(sc, WPI_APMG_RFKILL) & 0x1) == 0) { + /* Radio kill switch is still off. */ + callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, + sc); + } else + ieee80211_runtask(ic, &sc->sc_radioon_task); +} + +static void +wpi_scan_timeout(void *arg) +{ + struct wpi_softc *sc = arg; + struct ifnet *ifp = sc->sc_ifp; + + if_printf(ifp, "scan timeout\n"); + taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask); +} + +static void +wpi_tx_timeout(void *arg) +{ + struct wpi_softc *sc = arg; + struct ifnet *ifp = sc->sc_ifp; + + if_printf(ifp, "device timeout\n"); + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask); } static int @@ -2111,30 +3164,27 @@ wpi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) { struct wpi_softc *sc = ifp->if_softc; struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); struct ifreq *ifr = (struct ifreq *) data; - int error = 0, startall = 0; + int error = 0; switch (cmd) { + case SIOCGIFADDR: + error = ether_ioctl(ifp, cmd, data); + break; case SIOCSIFFLAGS: - WPI_LOCK(sc); - if ((ifp->if_flags & IFF_UP)) { - if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { - wpi_init_locked(sc, 0); - startall = 1; - } - } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) || - (sc->flags & WPI_FLAG_HW_RADIO_OFF)) - wpi_stop_locked(sc); - WPI_UNLOCK(sc); - if (startall) - ieee80211_start_all(ic); + if (ifp->if_flags & IFF_UP) { + wpi_init(sc); + + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 && + vap != NULL) + ieee80211_stop(vap); + } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) + wpi_stop(sc); break; case SIOCGIFMEDIA: error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); break; - case SIOCGIFADDR: - error = ether_ioctl(ifp, cmd, data); - break; default: error = EINVAL; break; @@ -2143,64 +3193,63 @@ wpi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) } /* - * Extract various information from EEPROM. - */ -static void -wpi_read_eeprom(struct wpi_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN]) -{ - int i; - - /* read the hardware capabilities, revision and SKU type */ - wpi_read_prom_data(sc, WPI_EEPROM_CAPABILITIES, &sc->cap,1); - wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev,2); - wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type, 1); - - /* read the regulatory domain */ - wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, sc->domain, 4); - - /* read in the hw MAC address */ - wpi_read_prom_data(sc, WPI_EEPROM_MAC, macaddr, 6); - - /* read the list of authorized channels */ - for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++) - wpi_read_eeprom_channels(sc,i); - - /* read the power level calibration info for each group */ - for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++) - wpi_read_eeprom_group(sc,i); -} - -/* * Send a command to the firmware. */ static int -wpi_cmd(struct wpi_softc *sc, int code, const void *buf, int size, int async) +wpi_cmd(struct wpi_softc *sc, int code, const void *buf, size_t size, + int async) { - struct wpi_tx_ring *ring = &sc->cmdq; + struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; struct wpi_tx_desc *desc; + struct wpi_tx_data *data; struct wpi_tx_cmd *cmd; + struct mbuf *m; + bus_addr_t paddr; + int totlen, error; -#ifdef WPI_DEBUG - if (!async) { - WPI_LOCK_ASSERT(sc); - } -#endif + WPI_TXQ_LOCK(sc); - DPRINTFN(WPI_DEBUG_CMD,("wpi_cmd %d size %d async %d\n", code, size, - async)); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - if (sc->flags & WPI_FLAG_BUSY) { - device_printf(sc->sc_dev, "%s: cmd %d not sent, busy\n", - __func__, code); - return EAGAIN; + if (sc->txq_active == 0) { + /* wpi_stop() was called */ + error = 0; + goto fail; } - sc->flags|= WPI_FLAG_BUSY; - KASSERT(size <= sizeof cmd->data, ("command %d too large: %d bytes", - code, size)); + if (async == 0) + WPI_LOCK_ASSERT(sc); + + DPRINTF(sc, WPI_DEBUG_CMD, "%s: cmd %s size %zu async %d\n", + __func__, wpi_cmd_str(code), size, async); desc = &ring->desc[ring->cur]; - cmd = &ring->cmd[ring->cur]; + data = &ring->data[ring->cur]; + totlen = 4 + size; + + if (size > sizeof cmd->data) { + /* Command is too large to fit in a descriptor. */ + if (totlen > MCLBYTES) { + error = EINVAL; + goto fail; + } + m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); + if (m == NULL) { + error = ENOMEM; + goto fail; + } + cmd = mtod(m, struct wpi_tx_cmd *); + error = bus_dmamap_load(ring->data_dmat, data->map, cmd, + totlen, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); + if (error != 0) { + m_freem(m); + goto fail; + } + data->m = m; + } else { + cmd = &ring->cmd[ring->cur]; + paddr = data->cmd_paddr; + } cmd->code = code; cmd->flags = 0; @@ -2208,56 +3257,42 @@ wpi_cmd(struct wpi_softc *sc, int code, const void *buf, int size, int async) cmd->idx = ring->cur; memcpy(cmd->data, buf, size); - desc->flags = htole32(WPI_PAD32(size) << 28 | 1 << 24); - desc->segs[0].addr = htole32(ring->cmd_dma.paddr + - ring->cur * sizeof (struct wpi_tx_cmd)); - desc->segs[0].len = htole32(4 + size); - - /* kick cmd ring */ - ring->cur = (ring->cur + 1) % WPI_CMD_RING_COUNT; - WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur); + desc->nsegs = 1 + (WPI_PAD32(size) << 4); + desc->segs[0].addr = htole32(paddr); + desc->segs[0].len = htole32(totlen); - if (async) { - sc->flags &= ~ WPI_FLAG_BUSY; - return 0; + if (size > sizeof cmd->data) { + bus_dmamap_sync(ring->data_dmat, data->map, + BUS_DMASYNC_PREWRITE); + } else { + bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, + BUS_DMASYNC_PREWRITE); } + bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, + BUS_DMASYNC_PREWRITE); - return msleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz); -} + /* Kick command ring. */ + ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; + sc->sc_update_tx_ring(sc, ring); -static int -wpi_wme_update(struct ieee80211com *ic) -{ -#define WPI_EXP2(v) htole16((1 << (v)) - 1) -#define WPI_USEC(v) htole16(IEEE80211_TXOP_TO_US(v)) - struct wpi_softc *sc = ic->ic_ifp->if_softc; - const struct wmeParams *wmep; - struct wpi_wme_setup wme; - int ac; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + WPI_TXQ_UNLOCK(sc); - /* don't override default WME values if WME is not actually enabled */ - if (!(ic->ic_flags & IEEE80211_F_WME)) + if (async) return 0; - wme.flags = 0; - for (ac = 0; ac < WME_NUM_AC; ac++) { - wmep = &ic->ic_wme.wme_chanParams.cap_wmeParams[ac]; - wme.ac[ac].aifsn = wmep->wmep_aifsn; - wme.ac[ac].cwmin = WPI_EXP2(wmep->wmep_logcwmin); - wme.ac[ac].cwmax = WPI_EXP2(wmep->wmep_logcwmax); - wme.ac[ac].txop = WPI_USEC(wmep->wmep_txopLimit); + return mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz); - DPRINTF(("setting WME for queue %d aifsn=%d cwmin=%d cwmax=%d " - "txop=%d\n", ac, wme.ac[ac].aifsn, wme.ac[ac].cwmin, - wme.ac[ac].cwmax, wme.ac[ac].txop)); - } - return wpi_cmd(sc, WPI_CMD_SET_WME, &wme, sizeof wme, 1); -#undef WPI_USEC -#undef WPI_EXP2 +fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + + WPI_TXQ_UNLOCK(sc); + + return error; } /* - * Configure h/w multi-rate retries. + * Configure HW multi-rate retries. */ static int wpi_mrr_setup(struct wpi_softc *sc) @@ -2267,360 +3302,858 @@ wpi_mrr_setup(struct wpi_softc *sc) struct wpi_mrr_setup mrr; int i, error; - memset(&mrr, 0, sizeof (struct wpi_mrr_setup)); - - /* CCK rates (not used with 802.11a) */ - for (i = WPI_CCK1; i <= WPI_CCK11; i++) { + /* CCK rates (not used with 802.11a). */ + for (i = WPI_RIDX_CCK1; i <= WPI_RIDX_CCK11; i++) { mrr.rates[i].flags = 0; - mrr.rates[i].signal = wpi_ridx_to_plcp[i]; - /* fallback to the immediate lower CCK rate (if any) */ - mrr.rates[i].next = (i == WPI_CCK1) ? WPI_CCK1 : i - 1; - /* try one time at this rate before falling back to "next" */ - mrr.rates[i].ntries = 1; - } - - /* OFDM rates (not used with 802.11b) */ - for (i = WPI_OFDM6; i <= WPI_OFDM54; i++) { + mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; + /* Fallback to the immediate lower CCK rate (if any.) */ + mrr.rates[i].next = + (i == WPI_RIDX_CCK1) ? WPI_RIDX_CCK1 : i - 1; + /* Try twice at this rate before falling back to "next". */ + mrr.rates[i].ntries = WPI_NTRIES_DEFAULT; + } + /* OFDM rates (not used with 802.11b). */ + for (i = WPI_RIDX_OFDM6; i <= WPI_RIDX_OFDM54; i++) { mrr.rates[i].flags = 0; - mrr.rates[i].signal = wpi_ridx_to_plcp[i]; - /* fallback to the immediate lower OFDM rate (if any) */ - /* we allow fallback from OFDM/6 to CCK/2 in 11b/g mode */ - mrr.rates[i].next = (i == WPI_OFDM6) ? + mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; + /* Fallback to the immediate lower rate (if any.) */ + /* We allow fallback from OFDM/6 to CCK/2 in 11b/g mode. */ + mrr.rates[i].next = (i == WPI_RIDX_OFDM6) ? ((ic->ic_curmode == IEEE80211_MODE_11A) ? - WPI_OFDM6 : WPI_CCK2) : + WPI_RIDX_OFDM6 : WPI_RIDX_CCK2) : i - 1; - /* try one time at this rate before falling back to "next" */ - mrr.rates[i].ntries = 1; + /* Try twice at this rate before falling back to "next". */ + mrr.rates[i].ntries = WPI_NTRIES_DEFAULT; } - - /* setup MRR for control frames */ - mrr.which = WPI_MRR_CTL; + /* Setup MRR for control frames. */ + mrr.which = htole32(WPI_MRR_CTL); error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); if (error != 0) { device_printf(sc->sc_dev, "could not setup MRR for control frames\n"); return error; } - - /* setup MRR for data frames */ - mrr.which = WPI_MRR_DATA; + /* Setup MRR for data frames. */ + mrr.which = htole32(WPI_MRR_DATA); error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); if (error != 0) { device_printf(sc->sc_dev, "could not setup MRR for data frames\n"); return error; } + return 0; +} + +static int +wpi_add_node(struct wpi_softc *sc, struct ieee80211_node *ni) +{ + struct ieee80211com *ic = ni->ni_ic; + struct wpi_vap *wvp = WPI_VAP(ni->ni_vap); + struct wpi_node *wn = WPI_NODE(ni); + struct wpi_node_info node; + int error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if (wn->id == WPI_ID_UNDEFINED) + return EINVAL; + + memset(&node, 0, sizeof node); + IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); + node.id = wn->id; + node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? + wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; + node.action = htole32(WPI_ACTION_SET_RATE); + node.antenna = WPI_ANTENNA_BOTH; + + DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding node %d (%s)\n", __func__, + wn->id, ether_sprintf(ni->ni_macaddr)); + + error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: wpi_cmd() call failed with error code %d\n", __func__, + error); + return error; + } + + if (wvp->wv_gtk != 0) { + error = wpi_set_global_keys(ni); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: error while setting global keys\n", __func__); + return ENXIO; + } + } return 0; } +/* + * Broadcast node is used to send group-addressed and management frames. + */ +static int +wpi_add_broadcast_node(struct wpi_softc *sc, int async) +{ + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct wpi_node_info node; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + memset(&node, 0, sizeof node); + IEEE80211_ADDR_COPY(node.macaddr, ifp->if_broadcastaddr); + node.id = WPI_ID_BROADCAST; + node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? + wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; + node.action = htole32(WPI_ACTION_SET_RATE); + node.antenna = WPI_ANTENNA_BOTH; + + DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding broadcast node\n", __func__); + + return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, async); +} + +static int +wpi_add_sta_node(struct wpi_softc *sc, struct ieee80211_node *ni) +{ + struct wpi_node *wn = WPI_NODE(ni); + int error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + wn->id = wpi_add_node_entry_sta(sc); + + if ((error = wpi_add_node(sc, ni)) != 0) { + wpi_del_node_entry(sc, wn->id); + wn->id = WPI_ID_UNDEFINED; + return error; + } + + return 0; +} + +static int +wpi_add_ibss_node(struct wpi_softc *sc, struct ieee80211_node *ni) +{ + struct wpi_node *wn = WPI_NODE(ni); + int error; + + KASSERT(wn->id == WPI_ID_UNDEFINED, + ("the node %d was added before", wn->id)); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if ((wn->id = wpi_add_node_entry_adhoc(sc)) == WPI_ID_UNDEFINED) { + device_printf(sc->sc_dev, "%s: h/w table is full\n", __func__); + return ENOMEM; + } + + if ((error = wpi_add_node(sc, ni)) != 0) { + wpi_del_node_entry(sc, wn->id); + wn->id = WPI_ID_UNDEFINED; + return error; + } + + return 0; +} + +static void +wpi_del_node(struct wpi_softc *sc, struct ieee80211_node *ni) +{ + struct wpi_node *wn = WPI_NODE(ni); + struct wpi_cmd_del_node node; + int error; + + KASSERT(wn->id != WPI_ID_UNDEFINED, ("undefined node id passed")); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + memset(&node, 0, sizeof node); + IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); + node.count = 1; + + DPRINTF(sc, WPI_DEBUG_NODE, "%s: deleting node %d (%s)\n", __func__, + wn->id, ether_sprintf(ni->ni_macaddr)); + + error = wpi_cmd(sc, WPI_CMD_DEL_NODE, &node, sizeof node, 1); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: could not delete node %u, error %d\n", __func__, + wn->id, error); + } +} + +static int +wpi_updateedca(struct ieee80211com *ic) +{ +#define WPI_EXP2(x) ((1 << (x)) - 1) /* CWmin = 2^ECWmin - 1 */ + struct wpi_softc *sc = ic->ic_ifp->if_softc; + struct wpi_edca_params cmd; + int aci, error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + memset(&cmd, 0, sizeof cmd); + cmd.flags = htole32(WPI_EDCA_UPDATE); + for (aci = 0; aci < WME_NUM_AC; aci++) { + const struct wmeParams *ac = + &ic->ic_wme.wme_chanParams.cap_wmeParams[aci]; + cmd.ac[aci].aifsn = ac->wmep_aifsn; + cmd.ac[aci].cwmin = htole16(WPI_EXP2(ac->wmep_logcwmin)); + cmd.ac[aci].cwmax = htole16(WPI_EXP2(ac->wmep_logcwmax)); + cmd.ac[aci].txoplimit = + htole16(IEEE80211_TXOP_TO_US(ac->wmep_txopLimit)); + + DPRINTF(sc, WPI_DEBUG_EDCA, + "setting WME for queue %d aifsn=%d cwmin=%d cwmax=%d " + "txoplimit=%d\n", aci, cmd.ac[aci].aifsn, + cmd.ac[aci].cwmin, cmd.ac[aci].cwmax, + cmd.ac[aci].txoplimit); + } + error = wpi_cmd(sc, WPI_CMD_EDCA_PARAMS, &cmd, sizeof cmd, 1); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + return error; +#undef WPI_EXP2 +} + +static void +wpi_set_promisc(struct wpi_softc *sc) +{ + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + uint32_t promisc_filter; + + promisc_filter = WPI_FILTER_CTL; + if (vap != NULL && vap->iv_opmode != IEEE80211_M_HOSTAP) + promisc_filter |= WPI_FILTER_PROMISC; + + if (ifp->if_flags & IFF_PROMISC) + sc->rxon.filter |= htole32(promisc_filter); + else + sc->rxon.filter &= ~htole32(promisc_filter); +} + +static void +wpi_update_promisc(struct ifnet *ifp) +{ + struct wpi_softc *sc = ifp->if_softc; + + WPI_RXON_LOCK(sc); + wpi_set_promisc(sc); + + if (wpi_send_rxon(sc, 1, 1) != 0) { + device_printf(sc->sc_dev, "%s: could not send RXON\n", + __func__); + } + WPI_RXON_UNLOCK(sc); +} + +static void +wpi_update_mcast(struct ifnet *ifp) +{ + /* Ignore */ +} + static void wpi_set_led(struct wpi_softc *sc, uint8_t which, uint8_t off, uint8_t on) { struct wpi_cmd_led led; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + led.which = which; led.unit = htole32(100000); /* on/off in unit of 100ms */ led.off = off; led.on = on; - (void)wpi_cmd(sc, WPI_CMD_SET_LED, &led, sizeof led, 1); } -static void -wpi_enable_tsf(struct wpi_softc *sc, struct ieee80211_node *ni) +static int +wpi_set_timing(struct wpi_softc *sc, struct ieee80211_node *ni) { - struct wpi_cmd_tsf tsf; + struct wpi_cmd_timing cmd; uint64_t val, mod; - memset(&tsf, 0, sizeof tsf); - memcpy(&tsf.tstamp, ni->ni_tstamp.data, 8); - tsf.bintval = htole16(ni->ni_intval); - tsf.lintval = htole16(10); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + memset(&cmd, 0, sizeof cmd); + memcpy(&cmd.tstamp, ni->ni_tstamp.data, sizeof (uint64_t)); + cmd.bintval = htole16(ni->ni_intval); + cmd.lintval = htole16(10); + + /* Compute remaining time until next beacon. */ + val = (uint64_t)ni->ni_intval * IEEE80211_DUR_TU; + mod = le64toh(cmd.tstamp) % val; + cmd.binitval = htole32((uint32_t)(val - mod)); - /* compute remaining time until next beacon */ - val = (uint64_t)ni->ni_intval * 1024; /* msec -> usec */ - mod = le64toh(tsf.tstamp) % val; - tsf.binitval = htole32((uint32_t)(val - mod)); + DPRINTF(sc, WPI_DEBUG_RESET, "timing bintval=%u tstamp=%ju, init=%u\n", + ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod)); - if (wpi_cmd(sc, WPI_CMD_TSF, &tsf, sizeof tsf, 1) != 0) - device_printf(sc->sc_dev, "could not enable TSF\n"); + return wpi_cmd(sc, WPI_CMD_TIMING, &cmd, sizeof cmd, 1); } -#if 0 /* - * Build a beacon frame that the firmware will broadcast periodically in - * IBSS or HostAP modes. + * This function is called periodically (every 60 seconds) to adjust output + * power to temperature changes. + */ +static void +wpi_power_calibration(struct wpi_softc *sc) +{ + int temp; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + /* Update sensor data. */ + temp = (int)WPI_READ(sc, WPI_UCODE_GP2); + DPRINTF(sc, WPI_DEBUG_TEMP, "Temp in calibration is: %d\n", temp); + + /* Sanity-check read value. */ + if (temp < -260 || temp > 25) { + /* This can't be correct, ignore. */ + DPRINTF(sc, WPI_DEBUG_TEMP, + "out-of-range temperature reported: %d\n", temp); + return; + } + + DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d->%d\n", sc->temp, temp); + + /* Adjust Tx power if need be. */ + if (abs(temp - sc->temp) <= 6) + return; + + sc->temp = temp; + + if (wpi_set_txpower(sc, 1) != 0) { + /* just warn, too bad for the automatic calibration... */ + device_printf(sc->sc_dev,"could not adjust Tx power\n"); + } +} + +/* + * Set TX power for current channel. */ static int -wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni) +wpi_set_txpower(struct wpi_softc *sc, int async) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct wpi_tx_ring *ring = &sc->cmdq; - struct wpi_tx_desc *desc; - struct wpi_tx_data *data; - struct wpi_tx_cmd *cmd; - struct wpi_cmd_beacon *bcn; - struct ieee80211_beacon_offsets bo; - struct mbuf *m0; - bus_addr_t physaddr; - int error; + struct wpi_power_group *group; + struct wpi_cmd_txpower cmd; + uint8_t chan; + int idx, is_chan_5ghz, i; - desc = &ring->desc[ring->cur]; - data = &ring->data[ring->cur]; + /* Retrieve current channel from last RXON. */ + chan = sc->rxon.chan; + is_chan_5ghz = (sc->rxon.flags & htole32(WPI_RXON_24GHZ)) == 0; - m0 = ieee80211_beacon_alloc(ic, ni, &bo); - if (m0 == NULL) { - device_printf(sc->sc_dev, "could not allocate beacon frame\n"); - return ENOMEM; + /* Find the TX power group to which this channel belongs. */ + if (is_chan_5ghz) { + for (group = &sc->groups[1]; group < &sc->groups[4]; group++) + if (chan <= group->chan) + break; + } else + group = &sc->groups[0]; + + memset(&cmd, 0, sizeof cmd); + cmd.band = is_chan_5ghz ? WPI_BAND_5GHZ : WPI_BAND_2GHZ; + cmd.chan = htole16(chan); + + /* Set TX power for all OFDM and CCK rates. */ + for (i = 0; i <= WPI_RIDX_MAX ; i++) { + /* Retrieve TX power for this channel/rate. */ + idx = wpi_get_power_index(sc, group, chan, is_chan_5ghz, i); + + cmd.rates[i].plcp = wpi_ridx_to_plcp[i]; + + if (is_chan_5ghz) { + cmd.rates[i].rf_gain = wpi_rf_gain_5ghz[idx]; + cmd.rates[i].dsp_gain = wpi_dsp_gain_5ghz[idx]; + } else { + cmd.rates[i].rf_gain = wpi_rf_gain_2ghz[idx]; + cmd.rates[i].dsp_gain = wpi_dsp_gain_2ghz[idx]; + } + DPRINTF(sc, WPI_DEBUG_TEMP, + "chan %d/ridx %d: power index %d\n", chan, i, idx); } - cmd = &ring->cmd[ring->cur]; - cmd->code = WPI_CMD_SET_BEACON; - cmd->flags = 0; - cmd->qid = ring->qid; - cmd->idx = ring->cur; + return wpi_cmd(sc, WPI_CMD_TXPOWER, &cmd, sizeof cmd, async); +} - bcn = (struct wpi_cmd_beacon *)cmd->data; - memset(bcn, 0, sizeof (struct wpi_cmd_beacon)); - bcn->id = WPI_ID_BROADCAST; - bcn->ofdm_mask = 0xff; - bcn->cck_mask = 0x0f; - bcn->lifetime = htole32(WPI_LIFETIME_INFINITE); - bcn->len = htole16(m0->m_pkthdr.len); - bcn->rate = (ic->ic_curmode == IEEE80211_MODE_11A) ? - wpi_plcp_signal(12) : wpi_plcp_signal(2); - bcn->flags = htole32(WPI_TX_AUTO_SEQ | WPI_TX_INSERT_TSTAMP); - - /* save and trim IEEE802.11 header */ - m_copydata(m0, 0, sizeof (struct ieee80211_frame), (caddr_t)&bcn->wh); - m_adj(m0, sizeof (struct ieee80211_frame)); - - /* assume beacon frame is contiguous */ - error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m0, void *), - m0->m_pkthdr.len, wpi_dma_map_addr, &physaddr, 0); - if (error != 0) { - device_printf(sc->sc_dev, "could not map beacon\n"); - m_freem(m0); - return error; +/* + * Determine Tx power index for a given channel/rate combination. + * This takes into account the regulatory information from EEPROM and the + * current temperature. + */ +static int +wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group, + uint8_t chan, int is_chan_5ghz, int ridx) +{ +/* Fixed-point arithmetic division using a n-bit fractional part. */ +#define fdivround(a, b, n) \ + ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n)) + +/* Linear interpolation. */ +#define interpolate(x, x1, y1, x2, y2, n) \ + ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n)) + + struct wpi_power_sample *sample; + int pwr, idx; + + /* Default TX power is group maximum TX power minus 3dB. */ + pwr = group->maxpwr / 2; + + /* Decrease TX power for highest OFDM rates to reduce distortion. */ + switch (ridx) { + case WPI_RIDX_OFDM36: + pwr -= is_chan_5ghz ? 5 : 0; + break; + case WPI_RIDX_OFDM48: + pwr -= is_chan_5ghz ? 10 : 7; + break; + case WPI_RIDX_OFDM54: + pwr -= is_chan_5ghz ? 12 : 9; + break; } - data->m = m0; + /* Never exceed the channel maximum allowed TX power. */ + pwr = min(pwr, sc->maxpwr[chan]); - /* first scatter/gather segment is used by the beacon command */ - desc->flags = htole32(WPI_PAD32(m0->m_pkthdr.len) << 28 | 2 << 24); - desc->segs[0].addr = htole32(ring->cmd_dma.paddr + - ring->cur * sizeof (struct wpi_tx_cmd)); - desc->segs[0].len = htole32(4 + sizeof (struct wpi_cmd_beacon)); - desc->segs[1].addr = htole32(physaddr); - desc->segs[1].len = htole32(m0->m_pkthdr.len); + /* Retrieve TX power index into gain tables from samples. */ + for (sample = group->samples; sample < &group->samples[3]; sample++) + if (pwr > sample[1].power) + break; + /* Fixed-point linear interpolation using a 19-bit fractional part. */ + idx = interpolate(pwr, sample[0].power, sample[0].index, + sample[1].power, sample[1].index, 19); - /* kick cmd ring */ - ring->cur = (ring->cur + 1) % WPI_CMD_RING_COUNT; - WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur); + /*- + * Adjust power index based on current temperature: + * - if cooler than factory-calibrated: decrease output power + * - if warmer than factory-calibrated: increase output power + */ + idx -= (sc->temp - group->temp) * 11 / 100; - return 0; + /* Decrease TX power for CCK rates (-5dB). */ + if (ridx >= WPI_RIDX_CCK1) + idx += 10; + + /* Make sure idx stays in a valid range. */ + if (idx < 0) + return 0; + if (idx > WPI_MAX_PWR_INDEX) + return WPI_MAX_PWR_INDEX; + return idx; + +#undef interpolate +#undef fdivround } -#endif +/* + * Set STA mode power saving level (between 0 and 5). + * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving. + */ static int -wpi_auth(struct wpi_softc *sc, struct ieee80211vap *vap) +wpi_set_pslevel(struct wpi_softc *sc, uint8_t dtim, int level, int async) +{ + struct wpi_pmgt_cmd cmd; + const struct wpi_pmgt *pmgt; + uint32_t max, skip_dtim; + uint32_t reg; + int i; + + DPRINTF(sc, WPI_DEBUG_PWRSAVE, + "%s: dtim=%d, level=%d, async=%d\n", + __func__, dtim, level, async); + + /* Select which PS parameters to use. */ + if (dtim <= 10) + pmgt = &wpi_pmgt[0][level]; + else + pmgt = &wpi_pmgt[1][level]; + + memset(&cmd, 0, sizeof cmd); + WPI_TXQ_LOCK(sc); + if (level != 0) { /* not CAM */ + cmd.flags |= htole16(WPI_PS_ALLOW_SLEEP); + sc->sc_flags |= WPI_PS_PATH; + } else + sc->sc_flags &= ~WPI_PS_PATH; + WPI_TXQ_UNLOCK(sc); + /* Retrieve PCIe Active State Power Management (ASPM). */ + reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1); + if (!(reg & 0x1)) /* L0s Entry disabled. */ + cmd.flags |= htole16(WPI_PS_PCI_PMGT); + + cmd.rxtimeout = htole32(pmgt->rxtimeout * IEEE80211_DUR_TU); + cmd.txtimeout = htole32(pmgt->txtimeout * IEEE80211_DUR_TU); + + if (dtim == 0) { + dtim = 1; + skip_dtim = 0; + } else + skip_dtim = pmgt->skip_dtim; + + if (skip_dtim != 0) { + cmd.flags |= htole16(WPI_PS_SLEEP_OVER_DTIM); + max = pmgt->intval[4]; + if (max == (uint32_t)-1) + max = dtim * (skip_dtim + 1); + else if (max > dtim) + max = (max / dtim) * dtim; + } else + max = dtim; + + for (i = 0; i < 5; i++) + cmd.intval[i] = htole32(MIN(max, pmgt->intval[i])); + + return wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async); +} + +static int +wpi_send_btcoex(struct wpi_softc *sc) +{ + struct wpi_bluetooth cmd; + + memset(&cmd, 0, sizeof cmd); + cmd.flags = WPI_BT_COEX_MODE_4WIRE; + cmd.lead_time = WPI_BT_LEAD_TIME_DEF; + cmd.max_kill = WPI_BT_MAX_KILL_DEF; + DPRINTF(sc, WPI_DEBUG_RESET, "%s: configuring bluetooth coexistence\n", + __func__); + return wpi_cmd(sc, WPI_CMD_BT_COEX, &cmd, sizeof(cmd), 0); +} + +static int +wpi_send_rxon(struct wpi_softc *sc, int assoc, int async) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_node *ni = vap->iv_bss; - struct wpi_node_info node; int error; + if (async) + WPI_RXON_LOCK_ASSERT(sc); - /* update adapter's configuration */ - sc->config.associd = 0; - sc->config.filter &= ~htole32(WPI_FILTER_BSS); - IEEE80211_ADDR_COPY(sc->config.bssid, ni->ni_bssid); - sc->config.chan = ieee80211_chan2ieee(ic, ni->ni_chan); - if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) { - sc->config.flags |= htole32(WPI_CONFIG_AUTO | - WPI_CONFIG_24GHZ); - } else { - sc->config.flags &= ~htole32(WPI_CONFIG_AUTO | - WPI_CONFIG_24GHZ); - } - if (IEEE80211_IS_CHAN_A(ni->ni_chan)) { - sc->config.cck_mask = 0; - sc->config.ofdm_mask = 0x15; - } else if (IEEE80211_IS_CHAN_B(ni->ni_chan)) { - sc->config.cck_mask = 0x03; - sc->config.ofdm_mask = 0; + if (assoc && wpi_check_bss_filter(sc) != 0) { + struct wpi_assoc rxon_assoc; + + rxon_assoc.flags = sc->rxon.flags; + rxon_assoc.filter = sc->rxon.filter; + rxon_assoc.ofdm_mask = sc->rxon.ofdm_mask; + rxon_assoc.cck_mask = sc->rxon.cck_mask; + rxon_assoc.reserved = 0; + + error = wpi_cmd(sc, WPI_CMD_RXON_ASSOC, &rxon_assoc, + sizeof (struct wpi_assoc), async); + if (error != 0) { + device_printf(sc->sc_dev, + "RXON_ASSOC command failed, error %d\n", error); + return error; + } } else { - /* XXX assume 802.11b/g */ - sc->config.cck_mask = 0x0f; - sc->config.ofdm_mask = 0x15; - } + if (async) { + WPI_NT_LOCK(sc); + error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, + sizeof (struct wpi_rxon), async); + if (error == 0) + wpi_clear_node_table(sc); + WPI_NT_UNLOCK(sc); + } else { + error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, + sizeof (struct wpi_rxon), async); + if (error == 0) + wpi_clear_node_table(sc); + } - DPRINTF(("config chan %d flags %x cck %x ofdm %x\n", sc->config.chan, - sc->config.flags, sc->config.cck_mask, sc->config.ofdm_mask)); - error = wpi_cmd(sc, WPI_CMD_CONFIGURE, &sc->config, - sizeof (struct wpi_config), 1); - if (error != 0) { - device_printf(sc->sc_dev, "could not configure\n"); - return error; + if (error != 0) { + device_printf(sc->sc_dev, + "RXON command failed, error %d\n", error); + return error; + } + + /* Add broadcast node. */ + error = wpi_add_broadcast_node(sc, async); + if (error != 0) { + device_printf(sc->sc_dev, + "could not add broadcast node, error %d\n", error); + return error; + } } - /* configuration has changed, set Tx power accordingly */ - if ((error = wpi_set_txpower(sc, ni->ni_chan, 1)) != 0) { - device_printf(sc->sc_dev, "could not set Tx power\n"); + /* Configuration has changed, set Tx power accordingly. */ + if ((error = wpi_set_txpower(sc, async)) != 0) { + device_printf(sc->sc_dev, + "%s: could not set TX power, error %d\n", __func__, error); return error; } - /* add default node */ - memset(&node, 0, sizeof node); - IEEE80211_ADDR_COPY(node.bssid, ni->ni_bssid); - node.id = WPI_ID_BSS; - node.rate = (ic->ic_curmode == IEEE80211_MODE_11A) ? - wpi_plcp_signal(12) : wpi_plcp_signal(2); - node.action = htole32(WPI_ACTION_SET_RATE); - node.antenna = WPI_ANTENNA_BOTH; - error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); - if (error != 0) - device_printf(sc->sc_dev, "could not add BSS node\n"); - - return (error); + return 0; } +/** + * Configure the card to listen to a particular channel, this transisions the + * card in to being able to receive frames from remote devices. + */ static int -wpi_run(struct wpi_softc *sc, struct ieee80211vap *vap) +wpi_config(struct wpi_softc *sc) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_node *ni = vap->iv_bss; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + struct ieee80211_channel *c = ic->ic_curchan; int error; - if (vap->iv_opmode == IEEE80211_M_MONITOR) { - /* link LED blinks while monitoring */ - wpi_set_led(sc, WPI_LED_LINK, 5, 5); - return 0; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + /* Set power saving level to CAM during initialization. */ + if ((error = wpi_set_pslevel(sc, 0, 0, 0)) != 0) { + device_printf(sc->sc_dev, + "%s: could not set power saving level\n", __func__); + return error; } - wpi_enable_tsf(sc, ni); + /* Configure bluetooth coexistence. */ + if ((error = wpi_send_btcoex(sc)) != 0) { + device_printf(sc->sc_dev, + "could not configure bluetooth coexistence\n"); + return error; + } - /* update adapter's configuration */ - sc->config.associd = htole16(ni->ni_associd & ~0xc000); - /* short preamble/slot time are negotiated when associating */ - sc->config.flags &= ~htole32(WPI_CONFIG_SHPREAMBLE | - WPI_CONFIG_SHSLOT); - if (ic->ic_flags & IEEE80211_F_SHSLOT) - sc->config.flags |= htole32(WPI_CONFIG_SHSLOT); - if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) - sc->config.flags |= htole32(WPI_CONFIG_SHPREAMBLE); - sc->config.filter |= htole32(WPI_FILTER_BSS); + /* Configure adapter. */ + memset(&sc->rxon, 0, sizeof (struct wpi_rxon)); + IEEE80211_ADDR_COPY(sc->rxon.myaddr, vap->iv_myaddr); - /* XXX put somewhere HC_QOS_SUPPORT_ASSOC + HC_IBSS_START */ + /* Set default channel. */ + sc->rxon.chan = ieee80211_chan2ieee(ic, c); + sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); + if (IEEE80211_IS_CHAN_2GHZ(c)) + sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); - DPRINTF(("config chan %d flags %x\n", sc->config.chan, - sc->config.flags)); - error = wpi_cmd(sc, WPI_CMD_CONFIGURE, &sc->config, sizeof (struct - wpi_config), 1); - if (error != 0) { - device_printf(sc->sc_dev, "could not update configuration\n"); + sc->rxon.filter = WPI_FILTER_MULTICAST; + switch (ic->ic_opmode) { + case IEEE80211_M_STA: + sc->rxon.mode = WPI_MODE_STA; + break; + case IEEE80211_M_IBSS: + sc->rxon.mode = WPI_MODE_IBSS; + sc->rxon.filter |= WPI_FILTER_BEACON; + break; + case IEEE80211_M_HOSTAP: + /* XXX workaround for beaconing */ + sc->rxon.mode = WPI_MODE_IBSS; + sc->rxon.filter |= WPI_FILTER_ASSOC | WPI_FILTER_PROMISC; + break; + case IEEE80211_M_AHDEMO: + sc->rxon.mode = WPI_MODE_HOSTAP; + break; + case IEEE80211_M_MONITOR: + sc->rxon.mode = WPI_MODE_MONITOR; + break; + default: + device_printf(sc->sc_dev, "unknown opmode %d\n", + ic->ic_opmode); + return EINVAL; + } + sc->rxon.filter = htole32(sc->rxon.filter); + wpi_set_promisc(sc); + sc->rxon.cck_mask = 0x0f; /* not yet negotiated */ + sc->rxon.ofdm_mask = 0xff; /* not yet negotiated */ + + /* XXX Current configuration may be unusable. */ + if (IEEE80211_IS_CHAN_NOADHOC(c) && sc->rxon.mode == WPI_MODE_IBSS) { + device_printf(sc->sc_dev, + "%s: invalid channel (%d) selected for IBSS mode\n", + __func__, ieee80211_chan2ieee(ic, c)); + return EINVAL; + } + + if ((error = wpi_send_rxon(sc, 0, 0)) != 0) { + device_printf(sc->sc_dev, "%s: could not send RXON\n", + __func__); return error; } - error = wpi_set_txpower(sc, ni->ni_chan, 1); - if (error != 0) { - device_printf(sc->sc_dev, "could set txpower\n"); + /* Setup rate scalling. */ + if ((error = wpi_mrr_setup(sc)) != 0) { + device_printf(sc->sc_dev, "could not setup MRR, error %d\n", + error); return error; } - /* link LED always on while associated */ - wpi_set_led(sc, WPI_LED_LINK, 0, 1); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); - /* start automatic rate control timer */ - callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); + return 0; +} + +static uint16_t +wpi_get_active_dwell_time(struct wpi_softc *sc, + struct ieee80211_channel *c, uint8_t n_probes) +{ + /* No channel? Default to 2GHz settings. */ + if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) { + return (WPI_ACTIVE_DWELL_TIME_2GHZ + + WPI_ACTIVE_DWELL_FACTOR_2GHZ * (n_probes + 1)); + } - return (error); + /* 5GHz dwell time. */ + return (WPI_ACTIVE_DWELL_TIME_5GHZ + + WPI_ACTIVE_DWELL_FACTOR_5GHZ * (n_probes + 1)); } /* - * Send a scan request to the firmware. Since this command is huge, we map it - * into a mbufcluster instead of using the pre-allocated set of commands. Note, - * much of this code is similar to that in wpi_cmd but because we must manually - * construct the probe & channels, we duplicate what's needed here. XXX In the - * future, this function should be modified to use wpi_cmd to help cleanup the - * code base. + * Limit the total dwell time. + * + * Returns the dwell time in milliseconds. + */ +static uint16_t +wpi_limit_dwell(struct wpi_softc *sc, uint16_t dwell_time) +{ + struct ieee80211com *ic = sc->sc_ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + int bintval = 0; + + /* bintval is in TU (1.024mS) */ + if (vap != NULL) + bintval = vap->iv_bss->ni_intval; + + /* + * If it's non-zero, we should calculate the minimum of + * it and the DWELL_BASE. + * + * XXX Yes, the math should take into account that bintval + * is 1.024mS, not 1mS.. + */ + if (bintval > 0) { + DPRINTF(sc, WPI_DEBUG_SCAN, "%s: bintval=%d\n", __func__, + bintval); + return (MIN(dwell_time, bintval - WPI_CHANNEL_TUNE_TIME * 2)); + } + + /* No association context? Default. */ + return dwell_time; +} + +static uint16_t +wpi_get_passive_dwell_time(struct wpi_softc *sc, struct ieee80211_channel *c) +{ + uint16_t passive; + + if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) + passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_2GHZ; + else + passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_5GHZ; + + /* Clamp to the beacon interval if we're associated. */ + return (wpi_limit_dwell(sc, passive)); +} + +static uint32_t +wpi_get_scan_pause_time(uint32_t time, uint16_t bintval) +{ + uint32_t mod = (time % bintval) * IEEE80211_DUR_TU; + uint32_t nbeacons = time / bintval; + + if (mod > WPI_PAUSE_MAX_TIME) + mod = WPI_PAUSE_MAX_TIME; + + return WPI_PAUSE_SCAN(nbeacons, mod); +} + +/* + * Send a scan request to the firmware. */ static int -wpi_scan(struct wpi_softc *sc) +wpi_scan(struct wpi_softc *sc, struct ieee80211_channel *c) { struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; struct ieee80211_scan_state *ss = ic->ic_scan; - struct wpi_tx_ring *ring = &sc->cmdq; - struct wpi_tx_desc *desc; - struct wpi_tx_data *data; - struct wpi_tx_cmd *cmd; + struct ieee80211vap *vap = ss->ss_vap; struct wpi_scan_hdr *hdr; + struct wpi_cmd_data *tx; + struct wpi_scan_essid *essids; struct wpi_scan_chan *chan; struct ieee80211_frame *wh; struct ieee80211_rateset *rs; - struct ieee80211_channel *c; - enum ieee80211_phymode mode; - uint8_t *frm; - int nrates, pktlen, error, i, nssid; - bus_addr_t physaddr; + uint16_t dwell_active, dwell_passive; + uint8_t *buf, *frm; + int bgscan, bintval, buflen, error, i, nssid; - desc = &ring->desc[ring->cur]; - data = &ring->data[ring->cur]; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - data->m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); - if (data->m == NULL) { - device_printf(sc->sc_dev, - "could not allocate mbuf for scan command\n"); - return ENOMEM; + /* + * We are absolutely not allowed to send a scan command when another + * scan command is pending. + */ + if (callout_pending(&sc->scan_timeout)) { + device_printf(sc->sc_dev, "%s: called whilst scanning!\n", + __func__); + error = EAGAIN; + goto fail; } - cmd = mtod(data->m, struct wpi_tx_cmd *); - cmd->code = WPI_CMD_SCAN; - cmd->flags = 0; - cmd->qid = ring->qid; - cmd->idx = ring->cur; + bgscan = wpi_check_bss_filter(sc); + bintval = vap->iv_bss->ni_intval; + if (bgscan != 0 && + bintval < WPI_QUIET_TIME_DEFAULT + WPI_CHANNEL_TUNE_TIME * 2) { + error = EOPNOTSUPP; + goto fail; + } - hdr = (struct wpi_scan_hdr *)cmd->data; - memset(hdr, 0, sizeof(struct wpi_scan_hdr)); + buf = malloc(WPI_SCAN_MAXSZ, M_DEVBUF, M_NOWAIT | M_ZERO); + if (buf == NULL) { + device_printf(sc->sc_dev, + "%s: could not allocate buffer for scan command\n", + __func__); + error = ENOMEM; + goto fail; + } + hdr = (struct wpi_scan_hdr *)buf; /* - * Move to the next channel if no packets are received within 5 msecs - * after sending the probe request (this helps to reduce the duration - * of active scans). + * Move to the next channel if no packets are received within 10 msecs + * after sending the probe request. */ - hdr->quiet = htole16(5); - hdr->threshold = htole16(1); + hdr->quiet_time = htole16(WPI_QUIET_TIME_DEFAULT); + hdr->quiet_threshold = htole16(1); - if (IEEE80211_IS_CHAN_A(ic->ic_curchan)) { - /* send probe requests at 6Mbps */ - hdr->tx.rate = wpi_ridx_to_plcp[WPI_OFDM6]; + if (bgscan != 0) { + /* + * Max needs to be greater than active and passive and quiet! + * It's also in microseconds! + */ + hdr->max_svc = htole32(250 * IEEE80211_DUR_TU); + hdr->pause_svc = htole32(wpi_get_scan_pause_time(100, + bintval)); + } + + hdr->filter = htole32(WPI_FILTER_MULTICAST | WPI_FILTER_BEACON); + + tx = (struct wpi_cmd_data *)(hdr + 1); + tx->flags = htole32(WPI_TX_AUTO_SEQ); + tx->id = WPI_ID_BROADCAST; + tx->lifetime = htole32(WPI_LIFETIME_INFINITE); - /* Enable crc checking */ - hdr->promotion = htole16(1); + if (IEEE80211_IS_CHAN_5GHZ(c)) { + /* Send probe requests at 6Mbps. */ + tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_OFDM6]; + rs = &ic->ic_sup_rates[IEEE80211_MODE_11A]; } else { - hdr->flags = htole32(WPI_CONFIG_24GHZ | WPI_CONFIG_AUTO); - /* send probe requests at 1Mbps */ - hdr->tx.rate = wpi_ridx_to_plcp[WPI_CCK1]; + hdr->flags = htole32(WPI_RXON_24GHZ | WPI_RXON_AUTO); + /* Send probe requests at 1Mbps. */ + tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_CCK1]; + rs = &ic->ic_sup_rates[IEEE80211_MODE_11G]; } - hdr->tx.id = WPI_ID_BROADCAST; - hdr->tx.lifetime = htole32(WPI_LIFETIME_INFINITE); - hdr->tx.flags = htole32(WPI_TX_AUTO_SEQ); - memset(hdr->scan_essids, 0, sizeof(hdr->scan_essids)); + essids = (struct wpi_scan_essid *)(tx + 1); nssid = MIN(ss->ss_nssid, WPI_SCAN_MAX_ESSIDS); for (i = 0; i < nssid; i++) { - hdr->scan_essids[i].id = IEEE80211_ELEMID_SSID; - hdr->scan_essids[i].esslen = MIN(ss->ss_ssid[i].len, 32); - memcpy(hdr->scan_essids[i].essid, ss->ss_ssid[i].ssid, - hdr->scan_essids[i].esslen); + essids[i].id = IEEE80211_ELEMID_SSID; + essids[i].len = MIN(ss->ss_ssid[i].len, IEEE80211_NWID_LEN); + memcpy(essids[i].data, ss->ss_ssid[i].ssid, essids[i].len); #ifdef WPI_DEBUG - if (wpi_debug & WPI_DEBUG_SCANNING) { + if (sc->sc_debug & WPI_DEBUG_SCAN) { printf("Scanning Essid: "); - ieee80211_print_essid(hdr->scan_essids[i].essid, - hdr->scan_essids[i].esslen); + ieee80211_print_essid(essids[i].data, essids[i].len); printf("\n"); } #endif @@ -2630,916 +4163,1400 @@ wpi_scan(struct wpi_softc *sc) * Build a probe request frame. Most of the following code is a * copy & paste of what is done in net80211. */ - wh = (struct ieee80211_frame *)&hdr->scan_essids[4]; + wh = (struct ieee80211_frame *)(essids + WPI_SCAN_MAX_ESSIDS); wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_REQ; wh->i_fc[1] = IEEE80211_FC1_DIR_NODS; IEEE80211_ADDR_COPY(wh->i_addr1, ifp->if_broadcastaddr); - IEEE80211_ADDR_COPY(wh->i_addr2, IF_LLADDR(ifp)); + IEEE80211_ADDR_COPY(wh->i_addr2, vap->iv_myaddr); IEEE80211_ADDR_COPY(wh->i_addr3, ifp->if_broadcastaddr); - *(u_int16_t *)&wh->i_dur[0] = 0; /* filled by h/w */ - *(u_int16_t *)&wh->i_seq[0] = 0; /* filled by h/w */ + *(uint16_t *)&wh->i_dur[0] = 0; /* filled by h/w */ + *(uint16_t *)&wh->i_seq[0] = 0; /* filled by h/w */ frm = (uint8_t *)(wh + 1); + frm = ieee80211_add_ssid(frm, NULL, 0); + frm = ieee80211_add_rates(frm, rs); + if (rs->rs_nrates > IEEE80211_RATE_SIZE) + frm = ieee80211_add_xrates(frm, rs); - /* add essid IE, the hardware will fill this in for us */ - *frm++ = IEEE80211_ELEMID_SSID; - *frm++ = 0; - - mode = ieee80211_chan2mode(ic->ic_curchan); - rs = &ic->ic_sup_rates[mode]; - - /* add supported rates IE */ - *frm++ = IEEE80211_ELEMID_RATES; - nrates = rs->rs_nrates; - if (nrates > IEEE80211_RATE_SIZE) - nrates = IEEE80211_RATE_SIZE; - *frm++ = nrates; - memcpy(frm, rs->rs_rates, nrates); - frm += nrates; - - /* add supported xrates IE */ - if (rs->rs_nrates > IEEE80211_RATE_SIZE) { - nrates = rs->rs_nrates - IEEE80211_RATE_SIZE; - *frm++ = IEEE80211_ELEMID_XRATES; - *frm++ = nrates; - memcpy(frm, rs->rs_rates + IEEE80211_RATE_SIZE, nrates); - frm += nrates; - } - - /* setup length of probe request */ - hdr->tx.len = htole16(frm - (uint8_t *)wh); + /* Set length of probe request. */ + tx->len = htole16(frm - (uint8_t *)wh); /* * Construct information about the channel that we * want to scan. The firmware expects this to be directly * after the scan probe request */ - c = ic->ic_curchan; chan = (struct wpi_scan_chan *)frm; - chan->chan = ieee80211_chan2ieee(ic, c); + chan->chan = htole16(ieee80211_chan2ieee(ic, c)); chan->flags = 0; - if (!(c->ic_flags & IEEE80211_CHAN_PASSIVE)) { + if (nssid) { + hdr->crc_threshold = WPI_SCAN_CRC_TH_DEFAULT; + chan->flags |= WPI_CHAN_NPBREQS(nssid); + } else + hdr->crc_threshold = WPI_SCAN_CRC_TH_NEVER; + + if (!IEEE80211_IS_CHAN_PASSIVE(c)) chan->flags |= WPI_CHAN_ACTIVE; - if (nssid != 0) - chan->flags |= WPI_CHAN_DIRECT; + + /* + * Calculate the active/passive dwell times. + */ + + dwell_active = wpi_get_active_dwell_time(sc, c, nssid); + dwell_passive = wpi_get_passive_dwell_time(sc, c); + + /* Make sure they're valid. */ + if (dwell_active > dwell_passive) + dwell_active = dwell_passive; + + chan->active = htole16(dwell_active); + chan->passive = htole16(dwell_passive); + + chan->dsp_gain = 0x6e; /* Default level */ + + if (IEEE80211_IS_CHAN_5GHZ(c)) + chan->rf_gain = 0x3b; + else + chan->rf_gain = 0x28; + + DPRINTF(sc, WPI_DEBUG_SCAN, "Scanning %u Passive: %d\n", + chan->chan, IEEE80211_IS_CHAN_PASSIVE(c)); + + hdr->nchan++; + + if (hdr->nchan == 1 && sc->rxon.chan == chan->chan) { + /* XXX Force probe request transmission. */ + memcpy(chan + 1, chan, sizeof (struct wpi_scan_chan)); + + chan++; + + /* Reduce unnecessary delay. */ + chan->flags = 0; + chan->passive = chan->active = hdr->quiet_time; + + hdr->nchan++; } - chan->gain_dsp = 0x6e; /* Default level */ - if (IEEE80211_IS_CHAN_5GHZ(c)) { - chan->active = htole16(10); - chan->passive = htole16(ss->ss_maxdwell); - chan->gain_radio = 0x3b; + + chan++; + + buflen = (uint8_t *)chan - buf; + hdr->len = htole16(buflen); + + DPRINTF(sc, WPI_DEBUG_CMD, "sending scan command nchan=%d\n", + hdr->nchan); + error = wpi_cmd(sc, WPI_CMD_SCAN, buf, buflen, 1); + free(buf, M_DEVBUF); + + if (error != 0) + goto fail; + + callout_reset(&sc->scan_timeout, 5*hz, wpi_scan_timeout, sc); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + return 0; + +fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + + return error; +} + +static int +wpi_auth(struct wpi_softc *sc, struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_node *ni = vap->iv_bss; + struct ieee80211_channel *c = ni->ni_chan; + int error; + + WPI_RXON_LOCK(sc); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + /* Update adapter configuration. */ + sc->rxon.associd = 0; + sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); + IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); + sc->rxon.chan = ieee80211_chan2ieee(ic, c); + sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); + if (IEEE80211_IS_CHAN_2GHZ(c)) + sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); + if (ic->ic_flags & IEEE80211_F_SHSLOT) + sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); + if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) + sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); + if (IEEE80211_IS_CHAN_A(c)) { + sc->rxon.cck_mask = 0; + sc->rxon.ofdm_mask = 0x15; + } else if (IEEE80211_IS_CHAN_B(c)) { + sc->rxon.cck_mask = 0x03; + sc->rxon.ofdm_mask = 0; } else { - chan->active = htole16(20); - chan->passive = htole16(ss->ss_maxdwell); - chan->gain_radio = 0x28; + /* Assume 802.11b/g. */ + sc->rxon.cck_mask = 0x0f; + sc->rxon.ofdm_mask = 0x15; } - DPRINTFN(WPI_DEBUG_SCANNING, - ("Scanning %u Passive: %d\n", - chan->chan, - c->ic_flags & IEEE80211_CHAN_PASSIVE)); + DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x cck %x ofdm %x\n", + sc->rxon.chan, sc->rxon.flags, sc->rxon.cck_mask, + sc->rxon.ofdm_mask); - hdr->nchan++; - chan++; + if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { + device_printf(sc->sc_dev, "%s: could not send RXON\n", + __func__); + } - frm += sizeof (struct wpi_scan_chan); -#if 0 - // XXX All Channels.... - for (c = &ic->ic_channels[1]; - c <= &ic->ic_channels[IEEE80211_CHAN_MAX]; c++) { - if ((c->ic_flags & ic->ic_curchan->ic_flags) != ic->ic_curchan->ic_flags) - continue; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); - chan->chan = ieee80211_chan2ieee(ic, c); - chan->flags = 0; - if (!(c->ic_flags & IEEE80211_CHAN_PASSIVE)) { - chan->flags |= WPI_CHAN_ACTIVE; - if (ic->ic_des_ssid[0].len != 0) - chan->flags |= WPI_CHAN_DIRECT; - } - chan->gain_dsp = 0x6e; /* Default level */ - if (IEEE80211_IS_CHAN_5GHZ(c)) { - chan->active = htole16(10); - chan->passive = htole16(110); - chan->gain_radio = 0x3b; - } else { - chan->active = htole16(20); - chan->passive = htole16(120); - chan->gain_radio = 0x28; - } + WPI_RXON_UNLOCK(sc); + + return error; +} + +static int +wpi_config_beacon(struct wpi_vap *wvp) +{ + struct ieee80211com *ic = wvp->wv_vap.iv_ic; + struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; + struct wpi_buf *bcn = &wvp->wv_bcbuf; + struct wpi_softc *sc = ic->ic_ifp->if_softc; + struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; + struct ieee80211_tim_ie *tie; + struct mbuf *m; + uint8_t *ptr; + int error; - DPRINTFN(WPI_DEBUG_SCANNING, - ("Scanning %u Passive: %d\n", - chan->chan, - c->ic_flags & IEEE80211_CHAN_PASSIVE)); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); - hdr->nchan++; - chan++; + WPI_VAP_LOCK_ASSERT(wvp); - frm += sizeof (struct wpi_scan_chan); + cmd->len = htole16(bcn->m->m_pkthdr.len); + cmd->plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? + wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; + + /* XXX seems to be unused */ + if (*(bo->bo_tim) == IEEE80211_ELEMID_TIM) { + tie = (struct ieee80211_tim_ie *) bo->bo_tim; + ptr = mtod(bcn->m, uint8_t *); + + cmd->tim = htole16(bo->bo_tim - ptr); + cmd->timsz = tie->tim_len; } -#endif - hdr->len = htole16(frm - (uint8_t *)hdr); - pktlen = frm - (uint8_t *)cmd; + /* Necessary for recursion in ieee80211_beacon_update(). */ + m = bcn->m; + bcn->m = m_dup(m, M_NOWAIT); + if (bcn->m == NULL) { + device_printf(sc->sc_dev, + "%s: could not copy beacon frame\n", __func__); + error = ENOMEM; + goto end; + } - error = bus_dmamap_load(ring->data_dmat, data->map, cmd, pktlen, - wpi_dma_map_addr, &physaddr, BUS_DMA_NOWAIT); - if (error != 0) { - device_printf(sc->sc_dev, "could not map scan command\n"); - m_freem(data->m); - data->m = NULL; - return error; + if ((error = wpi_cmd2(sc, bcn)) != 0) { + device_printf(sc->sc_dev, + "%s: could not update beacon frame, error %d", __func__, + error); } - desc->flags = htole32(WPI_PAD32(pktlen) << 28 | 1 << 24); - desc->segs[0].addr = htole32(physaddr); - desc->segs[0].len = htole32(pktlen); + /* Restore mbuf. */ +end: bcn->m = m; - bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, - BUS_DMASYNC_PREWRITE); - bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); + return error; +} + +static int +wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni) +{ + struct wpi_vap *wvp = WPI_VAP(ni->ni_vap); + struct wpi_buf *bcn = &wvp->wv_bcbuf; + struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; + struct mbuf *m; + int error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if (ni->ni_chan == IEEE80211_CHAN_ANYC) + return EINVAL; + + m = ieee80211_beacon_alloc(ni, bo); + if (m == NULL) { + device_printf(sc->sc_dev, + "%s: could not allocate beacon frame\n", __func__); + return ENOMEM; + } - /* kick cmd ring */ - ring->cur = (ring->cur + 1) % WPI_CMD_RING_COUNT; - WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur); + WPI_VAP_LOCK(wvp); + if (bcn->m != NULL) + m_freem(bcn->m); - sc->sc_scan_timer = 5; - return 0; /* will be notified async. of failure/success */ + bcn->m = m; + + error = wpi_config_beacon(wvp); + WPI_VAP_UNLOCK(wvp); + + return error; +} + +static void +wpi_update_beacon(struct ieee80211vap *vap, int item) +{ + struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc; + struct wpi_vap *wvp = WPI_VAP(vap); + struct wpi_buf *bcn = &wvp->wv_bcbuf; + struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; + struct ieee80211_node *ni = vap->iv_bss; + int mcast = 0; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + WPI_VAP_LOCK(wvp); + if (bcn->m == NULL) { + bcn->m = ieee80211_beacon_alloc(ni, bo); + if (bcn->m == NULL) { + device_printf(sc->sc_dev, + "%s: could not allocate beacon frame\n", __func__); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, + __func__); + + WPI_VAP_UNLOCK(wvp); + return; + } + } + WPI_VAP_UNLOCK(wvp); + + if (item == IEEE80211_BEACON_TIM) + mcast = 1; /* TODO */ + + setbit(bo->bo_flags, item); + ieee80211_beacon_update(ni, bo, bcn->m, mcast); + + WPI_VAP_LOCK(wvp); + wpi_config_beacon(wvp); + WPI_VAP_UNLOCK(wvp); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); +} + +static void +wpi_newassoc(struct ieee80211_node *ni, int isnew) +{ + struct ieee80211vap *vap = ni->ni_vap; + struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; + struct wpi_node *wn = WPI_NODE(ni); + int error; + + WPI_NT_LOCK(sc); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if (vap->iv_opmode != IEEE80211_M_STA && wn->id == WPI_ID_UNDEFINED) { + if ((error = wpi_add_ibss_node(sc, ni)) != 0) { + device_printf(sc->sc_dev, + "%s: could not add IBSS node, error %d\n", + __func__, error); + } + } + WPI_NT_UNLOCK(sc); } -/** - * Configure the card to listen to a particular channel, this transisions the - * card in to being able to receive frames from remote devices. - */ static int -wpi_config(struct wpi_softc *sc) +wpi_run(struct wpi_softc *sc, struct ieee80211vap *vap) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct wpi_power power; - struct wpi_bluetooth bluetooth; - struct wpi_node_info node; + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_node *ni = vap->iv_bss; + struct ieee80211_channel *c = ni->ni_chan; int error; - /* set power mode */ - memset(&power, 0, sizeof power); - power.flags = htole32(WPI_POWER_CAM|0x8); - error = wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &power, sizeof power, 0); - if (error != 0) { - device_printf(sc->sc_dev, "could not set power mode\n"); - return error; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); + + if (vap->iv_opmode == IEEE80211_M_MONITOR) { + /* Link LED blinks while monitoring. */ + wpi_set_led(sc, WPI_LED_LINK, 5, 5); + return 0; } - /* configure bluetooth coexistence */ - memset(&bluetooth, 0, sizeof bluetooth); - bluetooth.flags = 3; - bluetooth.lead = 0xaa; - bluetooth.kill = 1; - error = wpi_cmd(sc, WPI_CMD_BLUETOOTH, &bluetooth, sizeof bluetooth, - 0); - if (error != 0) { + /* XXX kernel panic workaround */ + if (c == IEEE80211_CHAN_ANYC) { + device_printf(sc->sc_dev, "%s: incomplete configuration\n", + __func__); + return EINVAL; + } + + if ((error = wpi_set_timing(sc, ni)) != 0) { device_printf(sc->sc_dev, - "could not configure bluetooth coexistence\n"); + "%s: could not set timing, error %d\n", __func__, error); return error; } - /* configure adapter */ - memset(&sc->config, 0, sizeof (struct wpi_config)); - IEEE80211_ADDR_COPY(sc->config.myaddr, IF_LLADDR(ifp)); - /*set default channel*/ - sc->config.chan = htole16(ieee80211_chan2ieee(ic, ic->ic_curchan)); - sc->config.flags = htole32(WPI_CONFIG_TSF); - if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) { - sc->config.flags |= htole32(WPI_CONFIG_AUTO | - WPI_CONFIG_24GHZ); + /* Update adapter configuration. */ + WPI_RXON_LOCK(sc); + IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); + sc->rxon.associd = htole16(IEEE80211_NODE_AID(ni)); + sc->rxon.chan = ieee80211_chan2ieee(ic, c); + sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); + if (IEEE80211_IS_CHAN_2GHZ(c)) + sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); + if (ic->ic_flags & IEEE80211_F_SHSLOT) + sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); + if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) + sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); + if (IEEE80211_IS_CHAN_A(c)) { + sc->rxon.cck_mask = 0; + sc->rxon.ofdm_mask = 0x15; + } else if (IEEE80211_IS_CHAN_B(c)) { + sc->rxon.cck_mask = 0x03; + sc->rxon.ofdm_mask = 0; + } else { + /* Assume 802.11b/g. */ + sc->rxon.cck_mask = 0x0f; + sc->rxon.ofdm_mask = 0x15; } - sc->config.filter = 0; - switch (ic->ic_opmode) { - case IEEE80211_M_STA: - case IEEE80211_M_WDS: /* No know setup, use STA for now */ - sc->config.mode = WPI_MODE_STA; - sc->config.filter |= htole32(WPI_FILTER_MULTICAST); - break; - case IEEE80211_M_IBSS: - case IEEE80211_M_AHDEMO: - sc->config.mode = WPI_MODE_IBSS; - sc->config.filter |= htole32(WPI_FILTER_BEACON | - WPI_FILTER_MULTICAST); - break; - case IEEE80211_M_HOSTAP: - sc->config.mode = WPI_MODE_HOSTAP; - break; - case IEEE80211_M_MONITOR: - sc->config.mode = WPI_MODE_MONITOR; - sc->config.filter |= htole32(WPI_FILTER_MULTICAST | - WPI_FILTER_CTL | WPI_FILTER_PROMISC); + sc->rxon.filter |= htole32(WPI_FILTER_BSS); + + DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x\n", + sc->rxon.chan, sc->rxon.flags); + + if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { + device_printf(sc->sc_dev, "%s: could not send RXON\n", + __func__); + return error; + } + + /* Start periodic calibration timer. */ + callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); + + WPI_RXON_UNLOCK(sc); + + if (vap->iv_opmode == IEEE80211_M_IBSS || + vap->iv_opmode == IEEE80211_M_HOSTAP) { + if ((error = wpi_setup_beacon(sc, ni)) != 0) { + device_printf(sc->sc_dev, + "%s: could not setup beacon, error %d\n", __func__, + error); + return error; + } + } + + if (vap->iv_opmode == IEEE80211_M_STA) { + /* Add BSS node. */ + WPI_NT_LOCK(sc); + error = wpi_add_sta_node(sc, ni); + WPI_NT_UNLOCK(sc); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: could not add BSS node, error %d\n", __func__, + error); + return error; + } + } + + /* Link LED always on while associated. */ + wpi_set_led(sc, WPI_LED_LINK, 0, 1); + + /* Enable power-saving mode if requested by user. */ + if ((vap->iv_flags & IEEE80211_F_PMGTON) && + vap->iv_opmode != IEEE80211_M_IBSS) + (void)wpi_set_pslevel(sc, 0, 3, 1); + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + return 0; +} + +static int +wpi_load_key(struct ieee80211_node *ni, const struct ieee80211_key *k) +{ + const struct ieee80211_cipher *cip = k->wk_cipher; + struct ieee80211vap *vap = ni->ni_vap; + struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; + struct wpi_node *wn = WPI_NODE(ni); + struct wpi_node_info node; + uint16_t kflags; + int error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if (wpi_check_node_entry(sc, wn->id) == 0) { + device_printf(sc->sc_dev, "%s: node does not exist\n", + __func__); + return 0; + } + + switch (cip->ic_cipher) { + case IEEE80211_CIPHER_AES_CCM: + kflags = WPI_KFLAG_CCMP; break; + default: - device_printf(sc->sc_dev, "unknown opmode %d\n", ic->ic_opmode); - return EINVAL; + device_printf(sc->sc_dev, "%s: unknown cipher %d\n", __func__, + cip->ic_cipher); + return 0; } - sc->config.cck_mask = 0x0f; /* not yet negotiated */ - sc->config.ofdm_mask = 0xff; /* not yet negotiated */ - error = wpi_cmd(sc, WPI_CMD_CONFIGURE, &sc->config, - sizeof (struct wpi_config), 0); + + kflags |= WPI_KFLAG_KID(k->wk_keyix); + if (k->wk_flags & IEEE80211_KEY_GROUP) + kflags |= WPI_KFLAG_MULTICAST; + + memset(&node, 0, sizeof node); + node.id = wn->id; + node.control = WPI_NODE_UPDATE; + node.flags = WPI_FLAG_KEY_SET; + node.kflags = htole16(kflags); + memcpy(node.key, k->wk_key, k->wk_keylen); +again: + DPRINTF(sc, WPI_DEBUG_KEY, + "%s: setting %s key id %d for node %d (%s)\n", __func__, + (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", k->wk_keyix, + node.id, ether_sprintf(ni->ni_macaddr)); + + error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); if (error != 0) { - device_printf(sc->sc_dev, "configure command failed\n"); - return error; + device_printf(sc->sc_dev, "can't update node info, error %d\n", + error); + return !error; } - /* configuration has changed, set Tx power accordingly */ - if ((error = wpi_set_txpower(sc, ic->ic_curchan, 0)) != 0) { - device_printf(sc->sc_dev, "could not set Tx power\n"); - return error; + if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k && + k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { + kflags |= WPI_KFLAG_MULTICAST; + node.kflags = htole16(kflags); + + goto again; } - /* add broadcast node */ + return 1; +} + +static void +wpi_load_key_cb(void *arg, struct ieee80211_node *ni) +{ + const struct ieee80211_key *k = arg; + struct ieee80211vap *vap = ni->ni_vap; + struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; + struct wpi_node *wn = WPI_NODE(ni); + int error; + + if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED) + return; + + WPI_NT_LOCK(sc); + error = wpi_load_key(ni, k); + WPI_NT_UNLOCK(sc); + + if (error == 0) { + device_printf(sc->sc_dev, "%s: error while setting key\n", + __func__); + } +} + +static int +wpi_set_global_keys(struct ieee80211_node *ni) +{ + struct ieee80211vap *vap = ni->ni_vap; + struct ieee80211_key *wk = &vap->iv_nw_keys[0]; + int error = 1; + + for (; wk < &vap->iv_nw_keys[IEEE80211_WEP_NKID] && error; wk++) + if (wk->wk_keyix != IEEE80211_KEYIX_NONE) + error = wpi_load_key(ni, wk); + + return !error; +} + +static int +wpi_del_key(struct ieee80211_node *ni, const struct ieee80211_key *k) +{ + struct ieee80211vap *vap = ni->ni_vap; + struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; + struct wpi_node *wn = WPI_NODE(ni); + struct wpi_node_info node; + uint16_t kflags; + int error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if (wpi_check_node_entry(sc, wn->id) == 0) { + DPRINTF(sc, WPI_DEBUG_KEY, "%s: node was removed\n", __func__); + return 1; /* Nothing to do. */ + } + + kflags = WPI_KFLAG_KID(k->wk_keyix); + if (k->wk_flags & IEEE80211_KEY_GROUP) + kflags |= WPI_KFLAG_MULTICAST; + memset(&node, 0, sizeof node); - IEEE80211_ADDR_COPY(node.bssid, ifp->if_broadcastaddr); - node.id = WPI_ID_BROADCAST; - node.rate = wpi_plcp_signal(2); - error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 0); + node.id = wn->id; + node.control = WPI_NODE_UPDATE; + node.flags = WPI_FLAG_KEY_SET; + node.kflags = htole16(kflags); +again: + DPRINTF(sc, WPI_DEBUG_KEY, "%s: deleting %s key %d for node %d (%s)\n", + __func__, (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", + k->wk_keyix, node.id, ether_sprintf(ni->ni_macaddr)); + + error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); if (error != 0) { - device_printf(sc->sc_dev, "could not add broadcast node\n"); - return error; + device_printf(sc->sc_dev, "can't update node info, error %d\n", + error); + return !error; } - /* Setup rate scalling */ - error = wpi_mrr_setup(sc); - if (error != 0) { - device_printf(sc->sc_dev, "could not setup MRR\n"); - return error; + if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k && + k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { + kflags |= WPI_KFLAG_MULTICAST; + node.kflags = htole16(kflags); + + goto again; } - return 0; + return 1; } static void -wpi_stop_master(struct wpi_softc *sc) +wpi_del_key_cb(void *arg, struct ieee80211_node *ni) { - uint32_t tmp; - int ntries; + const struct ieee80211_key *k = arg; + struct ieee80211vap *vap = ni->ni_vap; + struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; + struct wpi_node *wn = WPI_NODE(ni); + int error; - DPRINTFN(WPI_DEBUG_HW,("Disabling Firmware execution\n")); + if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED) + return; - tmp = WPI_READ(sc, WPI_RESET); - WPI_WRITE(sc, WPI_RESET, tmp | WPI_STOP_MASTER | WPI_NEVO_RESET); + WPI_NT_LOCK(sc); + error = wpi_del_key(ni, k); + WPI_NT_UNLOCK(sc); - tmp = WPI_READ(sc, WPI_GPIO_CTL); - if ((tmp & WPI_GPIO_PWR_STATUS) == WPI_GPIO_PWR_SLEEP) - return; /* already asleep */ + if (error == 0) { + device_printf(sc->sc_dev, "%s: error while deleting key\n", + __func__); + } +} - for (ntries = 0; ntries < 100; ntries++) { - if (WPI_READ(sc, WPI_RESET) & WPI_MASTER_DISABLED) - break; - DELAY(10); +static int +wpi_process_key(struct ieee80211vap *vap, const struct ieee80211_key *k, + int set) +{ + struct ieee80211com *ic = vap->iv_ic; + struct wpi_softc *sc = ic->ic_ifp->if_softc; + struct wpi_vap *wvp = WPI_VAP(vap); + struct ieee80211_node *ni; + int error, ni_ref = 0; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + if (k->wk_flags & IEEE80211_KEY_SWCRYPT) { + /* Not for us. */ + return 1; + } + + if (!(k->wk_flags & IEEE80211_KEY_RECV)) { + /* XMIT keys are handled in wpi_tx_data(). */ + return 1; + } + + /* Handle group keys. */ + if (&vap->iv_nw_keys[0] <= k && + k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { + WPI_NT_LOCK(sc); + if (set) + wvp->wv_gtk |= WPI_VAP_KEY(k->wk_keyix); + else + wvp->wv_gtk &= ~WPI_VAP_KEY(k->wk_keyix); + WPI_NT_UNLOCK(sc); + + if (vap->iv_state == IEEE80211_S_RUN) { + ieee80211_iterate_nodes(&ic->ic_sta, + set ? wpi_load_key_cb : wpi_del_key_cb, + __DECONST(void *, k)); + } + + return 1; } - if (ntries == 100) { - device_printf(sc->sc_dev, "timeout waiting for master\n"); + + switch (vap->iv_opmode) { + case IEEE80211_M_STA: + ni = vap->iv_bss; + break; + + case IEEE80211_M_IBSS: + case IEEE80211_M_AHDEMO: + case IEEE80211_M_HOSTAP: + ni = ieee80211_find_vap_node(&ic->ic_sta, vap, k->wk_macaddr); + if (ni == NULL) + return 0; /* should not happen */ + + ni_ref = 1; + break; + + default: + device_printf(sc->sc_dev, "%s: unknown opmode %d\n", __func__, + vap->iv_opmode); + return 0; } + + WPI_NT_LOCK(sc); + if (set) + error = wpi_load_key(ni, k); + else + error = wpi_del_key(ni, k); + WPI_NT_UNLOCK(sc); + + if (ni_ref) + ieee80211_node_decref(ni); + + return error; } static int -wpi_power_up(struct wpi_softc *sc) +wpi_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k, + const uint8_t mac[IEEE80211_ADDR_LEN]) { - uint32_t tmp; - int ntries; + return wpi_process_key(vap, k, 1); +} - wpi_mem_lock(sc); - tmp = wpi_mem_read(sc, WPI_MEM_POWER); - wpi_mem_write(sc, WPI_MEM_POWER, tmp & ~0x03000000); - wpi_mem_unlock(sc); +static int +wpi_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) +{ + return wpi_process_key(vap, k, 0); +} - for (ntries = 0; ntries < 5000; ntries++) { - if (WPI_READ(sc, WPI_GPIO_STATUS) & WPI_POWERED) +/* + * This function is called after the runtime firmware notifies us of its + * readiness (called in a process context). + */ +static int +wpi_post_alive(struct wpi_softc *sc) +{ + int ntries, error; + + /* Check (again) that the radio is not disabled. */ + if ((error = wpi_nic_lock(sc)) != 0) + return error; + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + /* NB: Runtime firmware must be up and running. */ + if (!(wpi_prph_read(sc, WPI_APMG_RFKILL) & 1)) { + device_printf(sc->sc_dev, + "RF switch: radio disabled (%s)\n", __func__); + wpi_nic_unlock(sc); + return EPERM; /* :-) */ + } + wpi_nic_unlock(sc); + + /* Wait for thermal sensor to calibrate. */ + for (ntries = 0; ntries < 1000; ntries++) { + if ((sc->temp = (int)WPI_READ(sc, WPI_UCODE_GP2)) != 0) break; DELAY(10); } - if (ntries == 5000) { + + if (ntries == 1000) { device_printf(sc->sc_dev, - "timeout waiting for NIC to power up\n"); + "timeout waiting for thermal sensor calibration\n"); return ETIMEDOUT; } + + DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d\n", sc->temp); return 0; } +/* + * The firmware boot code is small and is intended to be copied directly into + * the NIC internal memory (no DMA transfer). + */ static int -wpi_reset(struct wpi_softc *sc) +wpi_load_bootcode(struct wpi_softc *sc, const uint8_t *ucode, int size) { - uint32_t tmp; - int ntries; + int error, ntries; - DPRINTFN(WPI_DEBUG_HW, - ("Resetting the card - clearing any uploaded firmware\n")); + DPRINTF(sc, WPI_DEBUG_HW, "Loading microcode size 0x%x\n", size); - /* clear any pending interrupts */ - WPI_WRITE(sc, WPI_INTR, 0xffffffff); + size /= sizeof (uint32_t); - tmp = WPI_READ(sc, WPI_PLL_CTL); - WPI_WRITE(sc, WPI_PLL_CTL, tmp | WPI_PLL_INIT); + if ((error = wpi_nic_lock(sc)) != 0) + return error; + + /* Copy microcode image into NIC memory. */ + wpi_prph_write_region_4(sc, WPI_BSM_SRAM_BASE, + (const uint32_t *)ucode, size); - tmp = WPI_READ(sc, WPI_CHICKEN); - WPI_WRITE(sc, WPI_CHICKEN, tmp | WPI_CHICKEN_RXNOLOS); + wpi_prph_write(sc, WPI_BSM_WR_MEM_SRC, 0); + wpi_prph_write(sc, WPI_BSM_WR_MEM_DST, WPI_FW_TEXT_BASE); + wpi_prph_write(sc, WPI_BSM_WR_DWCOUNT, size); - tmp = WPI_READ(sc, WPI_GPIO_CTL); - WPI_WRITE(sc, WPI_GPIO_CTL, tmp | WPI_GPIO_INIT); + /* Start boot load now. */ + wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START); - /* wait for clock stabilization */ - for (ntries = 0; ntries < 25000; ntries++) { - if (WPI_READ(sc, WPI_GPIO_CTL) & WPI_GPIO_CLOCK) + /* Wait for transfer to complete. */ + for (ntries = 0; ntries < 1000; ntries++) { + uint32_t status = WPI_READ(sc, WPI_FH_TX_STATUS); + DPRINTF(sc, WPI_DEBUG_HW, + "firmware status=0x%x, val=0x%x, result=0x%x\n", status, + WPI_FH_TX_STATUS_IDLE(6), + status & WPI_FH_TX_STATUS_IDLE(6)); + if (status & WPI_FH_TX_STATUS_IDLE(6)) { + DPRINTF(sc, WPI_DEBUG_HW, + "Status Match! - ntries = %d\n", ntries); break; + } DELAY(10); } - if (ntries == 25000) { - device_printf(sc->sc_dev, - "timeout waiting for clock stabilization\n"); + if (ntries == 1000) { + device_printf(sc->sc_dev, "%s: could not load boot firmware\n", + __func__); + wpi_nic_unlock(sc); return ETIMEDOUT; } - /* initialize EEPROM */ - tmp = WPI_READ(sc, WPI_EEPROM_STATUS); - - if ((tmp & WPI_EEPROM_VERSION) == 0) { - device_printf(sc->sc_dev, "EEPROM not found\n"); - return EIO; - } - WPI_WRITE(sc, WPI_EEPROM_STATUS, tmp & ~WPI_EEPROM_LOCKED); + /* Enable boot after power up. */ + wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START_EN); + wpi_nic_unlock(sc); return 0; } -static void -wpi_hw_config(struct wpi_softc *sc) +static int +wpi_load_firmware(struct wpi_softc *sc) { - uint32_t rev, hw; + struct wpi_fw_info *fw = &sc->fw; + struct wpi_dma_info *dma = &sc->fw_dma; + int error; - /* voodoo from the Linux "driver".. */ - hw = WPI_READ(sc, WPI_HWCONFIG); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); - rev = pci_read_config(sc->sc_dev, PCIR_REVID, 1); - if ((rev & 0xc0) == 0x40) - hw |= WPI_HW_ALM_MB; - else if (!(rev & 0x80)) - hw |= WPI_HW_ALM_MM; + /* Copy initialization sections into pre-allocated DMA-safe memory. */ + memcpy(dma->vaddr, fw->init.data, fw->init.datasz); + bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); + memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->init.text, fw->init.textsz); + bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); - if (sc->cap == 0x80) - hw |= WPI_HW_SKU_MRC; + /* Tell adapter where to find initialization sections. */ + if ((error = wpi_nic_lock(sc)) != 0) + return error; + wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); + wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->init.datasz); + wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, + dma->paddr + WPI_FW_DATA_MAXSZ); + wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, fw->init.textsz); + wpi_nic_unlock(sc); + + /* Load firmware boot code. */ + error = wpi_load_bootcode(sc, fw->boot.text, fw->boot.textsz); + if (error != 0) { + device_printf(sc->sc_dev, "%s: could not load boot firmware\n", + __func__); + return error; + } - hw &= ~WPI_HW_REV_D; - if ((le16toh(sc->rev) & 0xf0) == 0xd0) - hw |= WPI_HW_REV_D; + /* Now press "execute". */ + WPI_WRITE(sc, WPI_RESET, 0); - if (sc->type > 1) - hw |= WPI_HW_TYPE_B; + /* Wait at most one second for first alive notification. */ + if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { + device_printf(sc->sc_dev, + "%s: timeout waiting for adapter to initialize, error %d\n", + __func__, error); + return error; + } - WPI_WRITE(sc, WPI_HWCONFIG, hw); + /* Copy runtime sections into pre-allocated DMA-safe memory. */ + memcpy(dma->vaddr, fw->main.data, fw->main.datasz); + bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); + memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->main.text, fw->main.textsz); + bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); + + /* Tell adapter where to find runtime sections. */ + if ((error = wpi_nic_lock(sc)) != 0) + return error; + wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); + wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->main.datasz); + wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, + dma->paddr + WPI_FW_DATA_MAXSZ); + wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, + WPI_FW_UPDATED | fw->main.textsz); + wpi_nic_unlock(sc); + + return 0; } -static void -wpi_rfkill_resume(struct wpi_softc *sc) +static int +wpi_read_firmware(struct wpi_softc *sc) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - int ntries; + const struct firmware *fp; + struct wpi_fw_info *fw = &sc->fw; + const struct wpi_firmware_hdr *hdr; + int error; - /* enable firmware again */ - WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF); - WPI_WRITE(sc, WPI_UCODE_CLR, WPI_DISABLE_CMD); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); - /* wait for thermal sensors to calibrate */ - for (ntries = 0; ntries < 1000; ntries++) { - if ((sc->temp = (int)WPI_READ(sc, WPI_TEMPERATURE)) != 0) - break; - DELAY(10); - } + DPRINTF(sc, WPI_DEBUG_FIRMWARE, + "Attempting Loading Firmware from %s module\n", WPI_FW_NAME); - if (ntries == 1000) { + WPI_UNLOCK(sc); + fp = firmware_get(WPI_FW_NAME); + WPI_LOCK(sc); + + if (fp == NULL) { device_printf(sc->sc_dev, - "timeout waiting for thermal calibration\n"); - return; + "could not load firmware image '%s'\n", WPI_FW_NAME); + return EINVAL; } - DPRINTFN(WPI_DEBUG_TEMP,("temperature %d\n", sc->temp)); - if (wpi_config(sc) != 0) { - device_printf(sc->sc_dev, "device config failed\n"); - return; + sc->fw_fp = fp; + + if (fp->datasize < sizeof (struct wpi_firmware_hdr)) { + device_printf(sc->sc_dev, + "firmware file too short: %zu bytes\n", fp->datasize); + error = EINVAL; + goto fail; } - ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; - ifp->if_drv_flags |= IFF_DRV_RUNNING; - sc->flags &= ~WPI_FLAG_HW_RADIO_OFF; + fw->size = fp->datasize; + fw->data = (const uint8_t *)fp->data; - if (vap != NULL) { - if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) { - if (vap->iv_opmode != IEEE80211_M_MONITOR) { - ieee80211_beacon_miss(ic); - wpi_set_led(sc, WPI_LED_LINK, 0, 1); - } else - wpi_set_led(sc, WPI_LED_LINK, 5, 5); - } else { - ieee80211_scan_next(vap); - wpi_set_led(sc, WPI_LED_LINK, 20, 2); - } + /* Extract firmware header information. */ + hdr = (const struct wpi_firmware_hdr *)fw->data; + + /* | RUNTIME FIRMWARE | INIT FIRMWARE | BOOT FW | + |HDR|<--TEXT-->|<--DATA-->|<--TEXT-->|<--DATA-->|<--TEXT-->| */ + + fw->main.textsz = le32toh(hdr->rtextsz); + fw->main.datasz = le32toh(hdr->rdatasz); + fw->init.textsz = le32toh(hdr->itextsz); + fw->init.datasz = le32toh(hdr->idatasz); + fw->boot.textsz = le32toh(hdr->btextsz); + fw->boot.datasz = 0; + + /* Sanity-check firmware header. */ + if (fw->main.textsz > WPI_FW_TEXT_MAXSZ || + fw->main.datasz > WPI_FW_DATA_MAXSZ || + fw->init.textsz > WPI_FW_TEXT_MAXSZ || + fw->init.datasz > WPI_FW_DATA_MAXSZ || + fw->boot.textsz > WPI_FW_BOOT_TEXT_MAXSZ || + (fw->boot.textsz & 3) != 0) { + device_printf(sc->sc_dev, "invalid firmware header\n"); + error = EINVAL; + goto fail; } - callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); -} + /* Check that all firmware sections fit. */ + if (fw->size < sizeof (*hdr) + fw->main.textsz + fw->main.datasz + + fw->init.textsz + fw->init.datasz + fw->boot.textsz) { + device_printf(sc->sc_dev, + "firmware file too short: %zu bytes\n", fw->size); + error = EINVAL; + goto fail; + } -static void -wpi_init_locked(struct wpi_softc *sc, int force) -{ - struct ifnet *ifp = sc->sc_ifp; - uint32_t tmp; - int ntries, qid; + /* Get pointers to firmware sections. */ + fw->main.text = (const uint8_t *)(hdr + 1); + fw->main.data = fw->main.text + fw->main.textsz; + fw->init.text = fw->main.data + fw->main.datasz; + fw->init.data = fw->init.text + fw->init.textsz; + fw->boot.text = fw->init.data + fw->init.datasz; - wpi_stop_locked(sc); - (void)wpi_reset(sc); + DPRINTF(sc, WPI_DEBUG_FIRMWARE, + "Firmware Version: Major %d, Minor %d, Driver %d, \n" + "runtime (text: %u, data: %u) init (text: %u, data %u) " + "boot (text %u)\n", hdr->major, hdr->minor, le32toh(hdr->driver), + fw->main.textsz, fw->main.datasz, + fw->init.textsz, fw->init.datasz, fw->boot.textsz); - wpi_mem_lock(sc); - wpi_mem_write(sc, WPI_MEM_CLOCK1, 0xa00); - DELAY(20); - tmp = wpi_mem_read(sc, WPI_MEM_PCIDEV); - wpi_mem_write(sc, WPI_MEM_PCIDEV, tmp | 0x800); - wpi_mem_unlock(sc); + DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.text %p\n", fw->main.text); + DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.data %p\n", fw->main.data); + DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.text %p\n", fw->init.text); + DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.data %p\n", fw->init.data); + DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->boot.text %p\n", fw->boot.text); - (void)wpi_power_up(sc); - wpi_hw_config(sc); + return 0; - /* init Rx ring */ - wpi_mem_lock(sc); - WPI_WRITE(sc, WPI_RX_BASE, sc->rxq.desc_dma.paddr); - WPI_WRITE(sc, WPI_RX_RIDX_PTR, sc->shared_dma.paddr + - offsetof(struct wpi_shared, next)); - WPI_WRITE(sc, WPI_RX_WIDX, (WPI_RX_RING_COUNT - 1) & ~7); - WPI_WRITE(sc, WPI_RX_CONFIG, 0xa9601010); - wpi_mem_unlock(sc); - - /* init Tx rings */ - wpi_mem_lock(sc); - wpi_mem_write(sc, WPI_MEM_MODE, 2); /* bypass mode */ - wpi_mem_write(sc, WPI_MEM_RA, 1); /* enable RA0 */ - wpi_mem_write(sc, WPI_MEM_TXCFG, 0x3f); /* enable all 6 Tx rings */ - wpi_mem_write(sc, WPI_MEM_BYPASS1, 0x10000); - wpi_mem_write(sc, WPI_MEM_BYPASS2, 0x30002); - wpi_mem_write(sc, WPI_MEM_MAGIC4, 4); - wpi_mem_write(sc, WPI_MEM_MAGIC5, 5); - - WPI_WRITE(sc, WPI_TX_BASE_PTR, sc->shared_dma.paddr); - WPI_WRITE(sc, WPI_MSG_CONFIG, 0xffff05a5); - - for (qid = 0; qid < 6; qid++) { - WPI_WRITE(sc, WPI_TX_CTL(qid), 0); - WPI_WRITE(sc, WPI_TX_BASE(qid), 0); - WPI_WRITE(sc, WPI_TX_CONFIG(qid), 0x80200008); - } - wpi_mem_unlock(sc); - - /* clear "radio off" and "disable command" bits (reversed logic) */ - WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF); - WPI_WRITE(sc, WPI_UCODE_CLR, WPI_DISABLE_CMD); - sc->flags &= ~WPI_FLAG_HW_RADIO_OFF; - - /* clear any pending interrupts */ - WPI_WRITE(sc, WPI_INTR, 0xffffffff); - - /* enable interrupts */ - WPI_WRITE(sc, WPI_MASK, WPI_INTR_MASK); - - WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF); - WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF); - - if ((wpi_load_firmware(sc)) != 0) { - device_printf(sc->sc_dev, - "A problem occurred loading the firmware to the driver\n"); - return; - } - - /* At this point the firmware is up and running. If the hardware - * RF switch is turned off thermal calibration will fail, though - * the card is still happy to continue to accept commands, catch - * this case and schedule a task to watch for it to be turned on. - */ - wpi_mem_lock(sc); - tmp = wpi_mem_read(sc, WPI_MEM_HW_RADIO_OFF); - wpi_mem_unlock(sc); +fail: wpi_unload_firmware(sc); + return error; +} - if (!(tmp & 0x1)) { - sc->flags |= WPI_FLAG_HW_RADIO_OFF; - device_printf(sc->sc_dev,"Radio Transmitter is switched off\n"); - goto out; +/** + * Free the referenced firmware image + */ +static void +wpi_unload_firmware(struct wpi_softc *sc) +{ + if (sc->fw_fp != NULL) { + firmware_put(sc->fw_fp, FIRMWARE_UNLOAD); + sc->fw_fp = NULL; } +} - /* wait for thermal sensors to calibrate */ - for (ntries = 0; ntries < 1000; ntries++) { - if ((sc->temp = (int)WPI_READ(sc, WPI_TEMPERATURE)) != 0) - break; - DELAY(10); - } +static int +wpi_clock_wait(struct wpi_softc *sc) +{ + int ntries; - if (ntries == 1000) { - device_printf(sc->sc_dev, - "timeout waiting for thermal sensors calibration\n"); - return; - } - DPRINTFN(WPI_DEBUG_TEMP,("temperature %d\n", sc->temp)); + /* Set "initialization complete" bit. */ + WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); - if (wpi_config(sc) != 0) { - device_printf(sc->sc_dev, "device config failed\n"); - return; + /* Wait for clock stabilization. */ + for (ntries = 0; ntries < 2500; ntries++) { + if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_MAC_CLOCK_READY) + return 0; + DELAY(100); } + device_printf(sc->sc_dev, + "%s: timeout waiting for clock stabilization\n", __func__); - ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; - ifp->if_drv_flags |= IFF_DRV_RUNNING; -out: - callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); + return ETIMEDOUT; } -static void -wpi_init(void *arg) +static int +wpi_apm_init(struct wpi_softc *sc) { - struct wpi_softc *sc = arg; - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; + uint32_t reg; + int error; - WPI_LOCK(sc); - wpi_init_locked(sc, 0); - WPI_UNLOCK(sc); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); - if (ifp->if_drv_flags & IFF_DRV_RUNNING) - ieee80211_start_all(ic); /* start all vaps */ -} + /* Disable L0s exit timer (NMI bug workaround). */ + WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_DIS_L0S_TIMER); + /* Don't wait for ICH L0s (ICH bug workaround). */ + WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_L1A_NO_L0S_RX); -static void -wpi_stop_locked(struct wpi_softc *sc) -{ - struct ifnet *ifp = sc->sc_ifp; - uint32_t tmp; - int ac; + /* Set FH wait threshold to max (HW bug under stress workaround). */ + WPI_SETBITS(sc, WPI_DBG_HPET_MEM, 0xffff0000); - sc->sc_tx_timer = 0; - sc->sc_scan_timer = 0; - ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); - sc->flags &= ~WPI_FLAG_HW_RADIO_OFF; - callout_stop(&sc->watchdog_to); - callout_stop(&sc->calib_to); + /* Retrieve PCIe Active State Power Management (ASPM). */ + reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1); + /* Workaround for HW instability in PCIe L0->L0s->L1 transition. */ + if (reg & 0x02) /* L1 Entry enabled. */ + WPI_SETBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); + else + WPI_CLRBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); - /* disable interrupts */ - WPI_WRITE(sc, WPI_MASK, 0); - WPI_WRITE(sc, WPI_INTR, WPI_INTR_MASK); - WPI_WRITE(sc, WPI_INTR_STATUS, 0xff); - WPI_WRITE(sc, WPI_INTR_STATUS, 0x00070000); + WPI_SETBITS(sc, WPI_ANA_PLL, WPI_ANA_PLL_INIT); - wpi_mem_lock(sc); - wpi_mem_write(sc, WPI_MEM_MODE, 0); - wpi_mem_unlock(sc); + /* Wait for clock stabilization before accessing prph. */ + if ((error = wpi_clock_wait(sc)) != 0) + return error; - /* reset all Tx rings */ - for (ac = 0; ac < 4; ac++) - wpi_reset_tx_ring(sc, &sc->txq[ac]); - wpi_reset_tx_ring(sc, &sc->cmdq); + if ((error = wpi_nic_lock(sc)) != 0) + return error; + /* Cleanup. */ + wpi_prph_write(sc, WPI_APMG_CLK_DIS, 0x00000400); + wpi_prph_clrbits(sc, WPI_APMG_PS, 0x00000200); - /* reset Rx ring */ - wpi_reset_rx_ring(sc, &sc->rxq); + /* Enable DMA and BSM (Bootstrap State Machine). */ + wpi_prph_write(sc, WPI_APMG_CLK_EN, + WPI_APMG_CLK_CTRL_DMA_CLK_RQT | WPI_APMG_CLK_CTRL_BSM_CLK_RQT); + DELAY(20); + /* Disable L1-Active. */ + wpi_prph_setbits(sc, WPI_APMG_PCI_STT, WPI_APMG_PCI_STT_L1A_DIS); + wpi_nic_unlock(sc); - wpi_mem_lock(sc); - wpi_mem_write(sc, WPI_MEM_CLOCK2, 0x200); - wpi_mem_unlock(sc); + return 0; +} - DELAY(5); +static void +wpi_apm_stop_master(struct wpi_softc *sc) +{ + int ntries; + + /* Stop busmaster DMA activity. */ + WPI_SETBITS(sc, WPI_RESET, WPI_RESET_STOP_MASTER); - wpi_stop_master(sc); + if ((WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_PS_MASK) == + WPI_GP_CNTRL_MAC_PS) + return; /* Already asleep. */ - tmp = WPI_READ(sc, WPI_RESET); - WPI_WRITE(sc, WPI_RESET, tmp | WPI_SW_RESET); - sc->flags &= ~WPI_FLAG_BUSY; + for (ntries = 0; ntries < 100; ntries++) { + if (WPI_READ(sc, WPI_RESET) & WPI_RESET_MASTER_DISABLED) + return; + DELAY(10); + } + device_printf(sc->sc_dev, "%s: timeout waiting for master\n", + __func__); } static void -wpi_stop(struct wpi_softc *sc) +wpi_apm_stop(struct wpi_softc *sc) { - WPI_LOCK(sc); - wpi_stop_locked(sc); - WPI_UNLOCK(sc); + wpi_apm_stop_master(sc); + + /* Reset the entire device. */ + WPI_SETBITS(sc, WPI_RESET, WPI_RESET_SW); + DELAY(10); + /* Clear "initialization complete" bit. */ + WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); } static void -wpi_calib_timeout(void *arg) +wpi_nic_config(struct wpi_softc *sc) { - struct wpi_softc *sc = arg; - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - int temp; + uint32_t rev; - if (vap->iv_state != IEEE80211_S_RUN) - return; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); - /* update sensor data */ - temp = (int)WPI_READ(sc, WPI_TEMPERATURE); - DPRINTFN(WPI_DEBUG_TEMP,("Temp in calibration is: %d\n", temp)); + /* voodoo from the Linux "driver".. */ + rev = pci_read_config(sc->sc_dev, PCIR_REVID, 1); + if ((rev & 0xc0) == 0x40) + WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MB); + else if (!(rev & 0x80)) + WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MM); - wpi_power_calibration(sc, temp); + if (sc->cap == 0x80) + WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_SKU_MRC); - callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); + if ((sc->rev & 0xf0) == 0xd0) + WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); + else + WPI_CLRBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); + + if (sc->type > 1) + WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_TYPE_B); } -/* - * This function is called periodically (every 60 seconds) to adjust output - * power to temperature changes. - */ -static void -wpi_power_calibration(struct wpi_softc *sc, int temp) +static int +wpi_hw_init(struct wpi_softc *sc) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + int chnl, ntries, error; - /* sanity-check read value */ - if (temp < -260 || temp > 25) { - /* this can't be correct, ignore */ - DPRINTFN(WPI_DEBUG_TEMP, - ("out-of-range temperature reported: %d\n", temp)); - return; - } + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - DPRINTFN(WPI_DEBUG_TEMP,("temperature %d->%d\n", sc->temp, temp)); + /* Clear pending interrupts. */ + WPI_WRITE(sc, WPI_INT, 0xffffffff); - /* adjust Tx power if need be */ - if (abs(temp - sc->temp) <= 6) - return; + if ((error = wpi_apm_init(sc)) != 0) { + device_printf(sc->sc_dev, + "%s: could not power ON adapter, error %d\n", __func__, + error); + return error; + } - sc->temp = temp; + /* Select VMAIN power source. */ + if ((error = wpi_nic_lock(sc)) != 0) + return error; + wpi_prph_clrbits(sc, WPI_APMG_PS, WPI_APMG_PS_PWR_SRC_MASK); + wpi_nic_unlock(sc); + /* Spin until VMAIN gets selected. */ + for (ntries = 0; ntries < 5000; ntries++) { + if (WPI_READ(sc, WPI_GPIO_IN) & WPI_GPIO_IN_VMAIN) + break; + DELAY(10); + } + if (ntries == 5000) { + device_printf(sc->sc_dev, "timeout selecting power source\n"); + return ETIMEDOUT; + } - if (wpi_set_txpower(sc, vap->iv_bss->ni_chan, 1) != 0) { - /* just warn, too bad for the automatic calibration... */ - device_printf(sc->sc_dev,"could not adjust Tx power\n"); + /* Perform adapter initialization. */ + wpi_nic_config(sc); + + /* Initialize RX ring. */ + if ((error = wpi_nic_lock(sc)) != 0) + return error; + /* Set physical address of RX ring. */ + WPI_WRITE(sc, WPI_FH_RX_BASE, sc->rxq.desc_dma.paddr); + /* Set physical address of RX read pointer. */ + WPI_WRITE(sc, WPI_FH_RX_RPTR_ADDR, sc->shared_dma.paddr + + offsetof(struct wpi_shared, next)); + WPI_WRITE(sc, WPI_FH_RX_WPTR, 0); + /* Enable RX. */ + WPI_WRITE(sc, WPI_FH_RX_CONFIG, + WPI_FH_RX_CONFIG_DMA_ENA | + WPI_FH_RX_CONFIG_RDRBD_ENA | + WPI_FH_RX_CONFIG_WRSTATUS_ENA | + WPI_FH_RX_CONFIG_MAXFRAG | + WPI_FH_RX_CONFIG_NRBD(WPI_RX_RING_COUNT_LOG) | + WPI_FH_RX_CONFIG_IRQ_DST_HOST | + WPI_FH_RX_CONFIG_IRQ_TIMEOUT(1)); + (void)WPI_READ(sc, WPI_FH_RSSR_TBL); /* barrier */ + wpi_nic_unlock(sc); + WPI_WRITE(sc, WPI_FH_RX_WPTR, (WPI_RX_RING_COUNT - 1) & ~7); + + /* Initialize TX rings. */ + if ((error = wpi_nic_lock(sc)) != 0) + return error; + wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 2); /* bypass mode */ + wpi_prph_write(sc, WPI_ALM_SCHED_ARASTAT, 1); /* enable RA0 */ + /* Enable all 6 TX rings. */ + wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0x3f); + wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE1, 0x10000); + wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE2, 0x30002); + wpi_prph_write(sc, WPI_ALM_SCHED_TXF4MF, 4); + wpi_prph_write(sc, WPI_ALM_SCHED_TXF5MF, 5); + /* Set physical address of TX rings. */ + WPI_WRITE(sc, WPI_FH_TX_BASE, sc->shared_dma.paddr); + WPI_WRITE(sc, WPI_FH_MSG_CONFIG, 0xffff05a5); + + /* Enable all DMA channels. */ + for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { + WPI_WRITE(sc, WPI_FH_CBBC_CTRL(chnl), 0); + WPI_WRITE(sc, WPI_FH_CBBC_BASE(chnl), 0); + WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0x80200008); + } + wpi_nic_unlock(sc); + (void)WPI_READ(sc, WPI_FH_TX_BASE); /* barrier */ + + /* Clear "radio off" and "commands blocked" bits. */ + WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); + WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_CMD_BLOCKED); + + /* Clear pending interrupts. */ + WPI_WRITE(sc, WPI_INT, 0xffffffff); + /* Enable interrupts. */ + WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); + + /* _Really_ make sure "radio off" bit is cleared! */ + WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); + WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); + + if ((error = wpi_load_firmware(sc)) != 0) { + device_printf(sc->sc_dev, + "%s: could not load firmware, error %d\n", __func__, + error); + return error; + } + /* Wait at most one second for firmware alive notification. */ + if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { + device_printf(sc->sc_dev, + "%s: timeout waiting for adapter to initialize, error %d\n", + __func__, error); + return error; } + + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); + + /* Do post-firmware initialization. */ + return wpi_post_alive(sc); } -/** - * Read the eeprom to find out what channels are valid for the given - * band and update net80211 with what we find. - */ static void -wpi_read_eeprom_channels(struct wpi_softc *sc, int n) +wpi_hw_stop(struct wpi_softc *sc) { - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - const struct wpi_chan_band *band = &wpi_bands[n]; - struct wpi_eeprom_chan channels[WPI_MAX_CHAN_PER_BAND]; - struct ieee80211_channel *c; - int chan, i, passive; + int chnl, qid, ntries; - wpi_read_prom_data(sc, band->addr, channels, - band->nchan * sizeof (struct wpi_eeprom_chan)); + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); - for (i = 0; i < band->nchan; i++) { - if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID)) { - DPRINTFN(WPI_DEBUG_HW, - ("Channel Not Valid: %d, band %d\n", - band->chan[i],n)); - continue; - } + if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) + wpi_nic_lock(sc); - passive = 0; - chan = band->chan[i]; - c = &ic->ic_channels[ic->ic_nchans++]; + WPI_WRITE(sc, WPI_RESET, WPI_RESET_NEVO); - /* is active scan allowed on this channel? */ - if (!(channels[i].flags & WPI_EEPROM_CHAN_ACTIVE)) { - passive = IEEE80211_CHAN_PASSIVE; - } + /* Disable interrupts. */ + WPI_WRITE(sc, WPI_INT_MASK, 0); + WPI_WRITE(sc, WPI_INT, 0xffffffff); + WPI_WRITE(sc, WPI_FH_INT, 0xffffffff); - if (n == 0) { /* 2GHz band */ - c->ic_ieee = chan; - c->ic_freq = ieee80211_ieee2mhz(chan, - IEEE80211_CHAN_2GHZ); - c->ic_flags = IEEE80211_CHAN_B | passive; + /* Make sure we no longer hold the NIC lock. */ + wpi_nic_unlock(sc); - c = &ic->ic_channels[ic->ic_nchans++]; - c->ic_ieee = chan; - c->ic_freq = ieee80211_ieee2mhz(chan, - IEEE80211_CHAN_2GHZ); - c->ic_flags = IEEE80211_CHAN_G | passive; + if (wpi_nic_lock(sc) == 0) { + /* Stop TX scheduler. */ + wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 0); + wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0); - } else { /* 5GHz band */ - /* - * Some 3945ABG adapters support channels 7, 8, 11 - * and 12 in the 2GHz *and* 5GHz bands. - * Because of limitations in our net80211(9) stack, - * we can't support these channels in 5GHz band. - * XXX not true; just need to map to proper frequency - */ - if (chan <= 14) - continue; - - c->ic_ieee = chan; - c->ic_freq = ieee80211_ieee2mhz(chan, - IEEE80211_CHAN_5GHZ); - c->ic_flags = IEEE80211_CHAN_A | passive; + /* Stop all DMA channels. */ + for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { + WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0); + for (ntries = 0; ntries < 200; ntries++) { + if (WPI_READ(sc, WPI_FH_TX_STATUS) & + WPI_FH_TX_STATUS_IDLE(chnl)) + break; + DELAY(10); + } } + wpi_nic_unlock(sc); + } - /* save maximum allowed power for this channel */ - sc->maxpwr[chan] = channels[i].maxpwr; + /* Stop RX ring. */ + wpi_reset_rx_ring(sc); -#if 0 - // XXX We can probably use this an get rid of maxpwr - ben 20070617 - ic->ic_channels[chan].ic_maxpower = channels[i].maxpwr; - //ic->ic_channels[chan].ic_minpower... - //ic->ic_channels[chan].ic_maxregtxpower... -#endif + /* Reset all TX rings. */ + for (qid = 0; qid < WPI_NTXQUEUES; qid++) + wpi_reset_tx_ring(sc, &sc->txq[qid]); - DPRINTF(("adding chan %d (%dMHz) flags=0x%x maxpwr=%d" - " passive=%d, offset %d\n", chan, c->ic_freq, - channels[i].flags, sc->maxpwr[chan], - (c->ic_flags & IEEE80211_CHAN_PASSIVE) != 0, - ic->ic_nchans)); + if (wpi_nic_lock(sc) == 0) { + wpi_prph_write(sc, WPI_APMG_CLK_DIS, + WPI_APMG_CLK_CTRL_DMA_CLK_RQT); + wpi_nic_unlock(sc); } + DELAY(5); + /* Power OFF adapter. */ + wpi_apm_stop(sc); } static void -wpi_read_eeprom_group(struct wpi_softc *sc, int n) +wpi_radio_on(void *arg0, int pending) { - struct wpi_power_group *group = &sc->groups[n]; - struct wpi_eeprom_group rgroup; - int i; + struct wpi_softc *sc = arg0; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32, &rgroup, - sizeof rgroup); + device_printf(sc->sc_dev, "RF switch: radio enabled\n"); - /* save power group information */ - group->chan = rgroup.chan; - group->maxpwr = rgroup.maxpwr; - /* temperature at which the samples were taken */ - group->temp = (int16_t)le16toh(rgroup.temp); + if (vap != NULL) { + wpi_init(sc); + ieee80211_init(vap); + } - DPRINTF(("power group %d: chan=%d maxpwr=%d temp=%d\n", n, - group->chan, group->maxpwr, group->temp)); + if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL) { + WPI_LOCK(sc); + callout_stop(&sc->watchdog_rfkill); + WPI_UNLOCK(sc); + } +} - for (i = 0; i < WPI_SAMPLES_COUNT; i++) { - group->samples[i].index = rgroup.samples[i].index; - group->samples[i].power = rgroup.samples[i].power; +static void +wpi_radio_off(void *arg0, int pending) +{ + struct wpi_softc *sc = arg0; + struct ifnet *ifp = sc->sc_ifp; + struct ieee80211com *ic = ifp->if_l2com; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - DPRINTF(("\tsample %d: index=%d power=%d\n", i, - group->samples[i].index, group->samples[i].power)); - } + device_printf(sc->sc_dev, "RF switch: radio disabled\n"); + + wpi_stop(sc); + if (vap != NULL) + ieee80211_stop(vap); + + WPI_LOCK(sc); + callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, sc); + WPI_UNLOCK(sc); } -/* - * Update Tx power to match what is defined for channel `c'. - */ -static int -wpi_set_txpower(struct wpi_softc *sc, struct ieee80211_channel *c, int async) +static void +wpi_init(void *arg) { + struct wpi_softc *sc = arg; struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; - struct wpi_power_group *group; - struct wpi_cmd_txpower txpower; - u_int chan; - int i; + int error; - /* get channel number */ - chan = ieee80211_chan2ieee(ic, c); + WPI_LOCK(sc); - /* find the power group to which this channel belongs */ - if (IEEE80211_IS_CHAN_5GHZ(c)) { - for (group = &sc->groups[1]; group < &sc->groups[4]; group++) - if (chan <= group->chan) - break; - } else - group = &sc->groups[0]; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); - memset(&txpower, 0, sizeof txpower); - txpower.band = IEEE80211_IS_CHAN_5GHZ(c) ? 0 : 1; - txpower.channel = htole16(chan); + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) + goto end; - /* set Tx power for all OFDM and CCK rates */ - for (i = 0; i <= 11 ; i++) { - /* retrieve Tx power for this channel/rate combination */ - int idx = wpi_get_power_index(sc, group, c, - wpi_ridx_to_rate[i]); + /* Check that the radio is not disabled by hardware switch. */ + if (!(WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL)) { + device_printf(sc->sc_dev, + "RF switch: radio disabled (%s)\n", __func__); + callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, + sc); + goto end; + } - txpower.rates[i].rate = wpi_ridx_to_plcp[i]; + /* Read firmware images from the filesystem. */ + if ((error = wpi_read_firmware(sc)) != 0) { + device_printf(sc->sc_dev, + "%s: could not read firmware, error %d\n", __func__, + error); + goto fail; + } - if (IEEE80211_IS_CHAN_5GHZ(c)) { - txpower.rates[i].gain_radio = wpi_rf_gain_5ghz[idx]; - txpower.rates[i].gain_dsp = wpi_dsp_gain_5ghz[idx]; - } else { - txpower.rates[i].gain_radio = wpi_rf_gain_2ghz[idx]; - txpower.rates[i].gain_dsp = wpi_dsp_gain_2ghz[idx]; - } - DPRINTFN(WPI_DEBUG_TEMP,("chan %d/rate %d: power index %d\n", - chan, wpi_ridx_to_rate[i], idx)); + /* Initialize hardware and upload firmware. */ + error = wpi_hw_init(sc); + wpi_unload_firmware(sc); + if (error != 0) { + device_printf(sc->sc_dev, + "%s: could not initialize hardware, error %d\n", __func__, + error); + goto fail; } - return wpi_cmd(sc, WPI_CMD_TXPOWER, &txpower, sizeof txpower, async); -} + /* Configure adapter now that it is ready. */ + sc->txq_active = 1; + if ((error = wpi_config(sc)) != 0) { + device_printf(sc->sc_dev, + "%s: could not configure device, error %d\n", __func__, + error); + goto fail; + } -/* - * Determine Tx power index for a given channel/rate combination. - * This takes into account the regulatory information from EEPROM and the - * current temperature. - */ -static int -wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group, - struct ieee80211_channel *c, int rate) -{ -/* fixed-point arithmetic division using a n-bit fractional part */ -#define fdivround(a, b, n) \ - ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n)) + IF_LOCK(&ifp->if_snd); + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; + ifp->if_drv_flags |= IFF_DRV_RUNNING; + IF_UNLOCK(&ifp->if_snd); -/* linear interpolation */ -#define interpolate(x, x1, y1, x2, y2, n) \ - ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n)) + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); - struct ifnet *ifp = sc->sc_ifp; - struct ieee80211com *ic = ifp->if_l2com; - struct wpi_power_sample *sample; - int pwr, idx; - u_int chan; + WPI_UNLOCK(sc); - /* get channel number */ - chan = ieee80211_chan2ieee(ic, c); + ieee80211_start_all(ic); - /* default power is group's maximum power - 3dB */ - pwr = group->maxpwr / 2; + return; - /* decrease power for highest OFDM rates to reduce distortion */ - switch (rate) { - case 72: /* 36Mb/s */ - pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 0 : 5; - break; - case 96: /* 48Mb/s */ - pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 7 : 10; - break; - case 108: /* 54Mb/s */ - pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 9 : 12; - break; - } +fail: wpi_stop_locked(sc); +end: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); + WPI_UNLOCK(sc); +} - /* never exceed channel's maximum allowed Tx power */ - pwr = min(pwr, sc->maxpwr[chan]); +static void +wpi_stop_locked(struct wpi_softc *sc) +{ + struct ifnet *ifp = sc->sc_ifp; - /* retrieve power index into gain tables from samples */ - for (sample = group->samples; sample < &group->samples[3]; sample++) - if (pwr > sample[1].power) - break; - /* fixed-point linear interpolation using a 19-bit fractional part */ - idx = interpolate(pwr, sample[0].power, sample[0].index, - sample[1].power, sample[1].index, 19); + WPI_LOCK_ASSERT(sc); - /* - * Adjust power index based on current temperature - * - if colder than factory-calibrated: decreate output power - * - if warmer than factory-calibrated: increase output power - */ - idx -= (sc->temp - group->temp) * 11 / 100; + WPI_TXQ_LOCK(sc); + sc->txq_active = 0; + WPI_TXQ_UNLOCK(sc); - /* decrease power for CCK rates (-5dB) */ - if (!WPI_RATE_IS_OFDM(rate)) - idx += 10; + WPI_TXQ_STATE_LOCK(sc); + callout_stop(&sc->tx_timeout); + WPI_TXQ_STATE_UNLOCK(sc); - /* keep power index in a valid range */ - if (idx < 0) - return 0; - if (idx > WPI_MAX_PWR_INDEX) - return WPI_MAX_PWR_INDEX; - return idx; + WPI_RXON_LOCK(sc); + callout_stop(&sc->scan_timeout); + callout_stop(&sc->calib_to); + WPI_RXON_UNLOCK(sc); -#undef interpolate -#undef fdivround + IF_LOCK(&ifp->if_snd); + ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); + IF_UNLOCK(&ifp->if_snd); + + /* Power OFF hardware. */ + wpi_hw_stop(sc); } -/** - * Called by net80211 framework to indicate that a scan - * is starting. This function doesn't actually do the scan, - * wpi_scan_curchan starts things off. This function is more - * of an early warning from the framework we should get ready - * for the scan. +static void +wpi_stop(struct wpi_softc *sc) +{ + WPI_LOCK(sc); + wpi_stop_locked(sc); + WPI_UNLOCK(sc); +} + +/* + * Callback from net80211 to start a scan. */ static void wpi_scan_start(struct ieee80211com *ic) { - struct ifnet *ifp = ic->ic_ifp; - struct wpi_softc *sc = ifp->if_softc; + struct wpi_softc *sc = ic->ic_ifp->if_softc; - WPI_LOCK(sc); wpi_set_led(sc, WPI_LED_LINK, 20, 2); - WPI_UNLOCK(sc); } -/** - * Called by the net80211 framework, indicates that the - * scan has ended. If there is a scan in progress on the card - * then it should be aborted. +/* + * Callback from net80211 to terminate a scan. */ static void wpi_scan_end(struct ieee80211com *ic) { - /* XXX ignore */ + struct ifnet *ifp = ic->ic_ifp; + struct wpi_softc *sc = ifp->if_softc; + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); + + if (vap->iv_state == IEEE80211_S_RUN) + wpi_set_led(sc, WPI_LED_LINK, 0, 1); } /** @@ -3549,21 +5566,41 @@ wpi_scan_end(struct ieee80211com *ic) static void wpi_set_channel(struct ieee80211com *ic) { + const struct ieee80211_channel *c = ic->ic_curchan; struct ifnet *ifp = ic->ic_ifp; struct wpi_softc *sc = ifp->if_softc; int error; + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); + + WPI_LOCK(sc); + sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq); + sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags); + WPI_UNLOCK(sc); + WPI_TX_LOCK(sc); + sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq); + sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags); + WPI_TX_UNLOCK(sc); + /* * Only need to set the channel in Monitor mode. AP scanning and auth * are already taken care of by their respective firmware commands. */ if (ic->ic_opmode == IEEE80211_M_MONITOR) { - WPI_LOCK(sc); - error = wpi_config(sc); - WPI_UNLOCK(sc); - if (error != 0) + WPI_RXON_LOCK(sc); + sc->rxon.chan = ieee80211_chan2ieee(ic, c); + if (IEEE80211_IS_CHAN_2GHZ(c)) { + sc->rxon.flags |= htole32(WPI_RXON_AUTO | + WPI_RXON_24GHZ); + } else { + sc->rxon.flags &= ~htole32(WPI_RXON_AUTO | + WPI_RXON_24GHZ); + } + if ((error = wpi_send_rxon(sc, 0, 1)) != 0) device_printf(sc->sc_dev, - "error %d settting channel\n", error); + "%s: error %d setting channel\n", __func__, + error); + WPI_RXON_UNLOCK(sc); } } @@ -3576,13 +5613,15 @@ static void wpi_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) { struct ieee80211vap *vap = ss->ss_vap; - struct ifnet *ifp = vap->iv_ic->ic_ifp; - struct wpi_softc *sc = ifp->if_softc; + struct ieee80211com *ic = vap->iv_ic; + struct wpi_softc *sc = ic->ic_ifp->if_softc; + int error; - WPI_LOCK(sc); - if (wpi_scan(sc)) + WPI_RXON_LOCK(sc); + error = wpi_scan(sc, ic->ic_curchan); + WPI_RXON_UNLOCK(sc); + if (error != 0) ieee80211_cancel_scan(vap); - WPI_UNLOCK(sc); } /** @@ -3598,118 +5637,22 @@ wpi_scan_mindwell(struct ieee80211_scan_state *ss) } static void -wpi_hwreset(void *arg, int pending) -{ - struct wpi_softc *sc = arg; - - WPI_LOCK(sc); - wpi_init_locked(sc, 0); - WPI_UNLOCK(sc); -} - -static void -wpi_rfreset(void *arg, int pending) -{ - struct wpi_softc *sc = arg; - - WPI_LOCK(sc); - wpi_rfkill_resume(sc); - WPI_UNLOCK(sc); -} - -/* - * Allocate DMA-safe memory for firmware transfer. - */ -static int -wpi_alloc_fwmem(struct wpi_softc *sc) -{ - /* allocate enough contiguous space to store text and data */ - return wpi_dma_contig_alloc(sc, &sc->fw_dma, NULL, - WPI_FW_MAIN_TEXT_MAXSZ + WPI_FW_MAIN_DATA_MAXSZ, 1, - BUS_DMA_NOWAIT); -} - -static void -wpi_free_fwmem(struct wpi_softc *sc) -{ - wpi_dma_contig_free(&sc->fw_dma); -} - -/** - * Called every second, wpi_watchdog used by the watch dog timer - * to check that the card is still alive - */ -static void -wpi_watchdog(void *arg) +wpi_hw_reset(void *arg, int pending) { struct wpi_softc *sc = arg; struct ifnet *ifp = sc->sc_ifp; struct ieee80211com *ic = ifp->if_l2com; - uint32_t tmp; - - DPRINTFN(WPI_DEBUG_WATCHDOG,("Watchdog: tick\n")); - - if (sc->flags & WPI_FLAG_HW_RADIO_OFF) { - /* No need to lock firmware memory */ - tmp = wpi_mem_read(sc, WPI_MEM_HW_RADIO_OFF); - - if ((tmp & 0x1) == 0) { - /* Radio kill switch is still off */ - callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); - return; - } - - device_printf(sc->sc_dev, "Hardware Switch Enabled\n"); - ieee80211_runtask(ic, &sc->sc_radiotask); - return; - } - - if (sc->sc_tx_timer > 0) { - if (--sc->sc_tx_timer == 0) { - device_printf(sc->sc_dev,"device timeout\n"); - ifp->if_oerrors++; - ieee80211_runtask(ic, &sc->sc_restarttask); - } - } - if (sc->sc_scan_timer > 0) { - struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - if (--sc->sc_scan_timer == 0 && vap != NULL) { - device_printf(sc->sc_dev,"scan timeout\n"); - ieee80211_cancel_scan(vap); - ieee80211_runtask(ic, &sc->sc_restarttask); - } - } + struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); - if (ifp->if_drv_flags & IFF_DRV_RUNNING) - callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); -} + DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); -#ifdef WPI_DEBUG -static const char *wpi_cmd_str(int cmd) -{ - switch (cmd) { - case WPI_DISABLE_CMD: return "WPI_DISABLE_CMD"; - case WPI_CMD_CONFIGURE: return "WPI_CMD_CONFIGURE"; - case WPI_CMD_ASSOCIATE: return "WPI_CMD_ASSOCIATE"; - case WPI_CMD_SET_WME: return "WPI_CMD_SET_WME"; - case WPI_CMD_TSF: return "WPI_CMD_TSF"; - case WPI_CMD_ADD_NODE: return "WPI_CMD_ADD_NODE"; - case WPI_CMD_TX_DATA: return "WPI_CMD_TX_DATA"; - case WPI_CMD_MRR_SETUP: return "WPI_CMD_MRR_SETUP"; - case WPI_CMD_SET_LED: return "WPI_CMD_SET_LED"; - case WPI_CMD_SET_POWER_MODE: return "WPI_CMD_SET_POWER_MODE"; - case WPI_CMD_SCAN: return "WPI_CMD_SCAN"; - case WPI_CMD_SET_BEACON:return "WPI_CMD_SET_BEACON"; - case WPI_CMD_TXPOWER: return "WPI_CMD_TXPOWER"; - case WPI_CMD_BLUETOOTH: return "WPI_CMD_BLUETOOTH"; + if (vap != NULL && (ic->ic_flags & IEEE80211_F_SCAN)) + ieee80211_cancel_scan(vap); - default: - KASSERT(1, ("Unknown Command: %d\n", cmd)); - return "UNKNOWN CMD"; /* Make the compiler happy */ - } + wpi_stop(sc); + if (vap != NULL) + ieee80211_stop(vap); + wpi_init(sc); + if (vap != NULL) + ieee80211_init(vap); } -#endif - -MODULE_DEPEND(wpi, pci, 1, 1, 1); -MODULE_DEPEND(wpi, wlan, 1, 1, 1); -MODULE_DEPEND(wpi, firmware, 1, 1, 1); diff --git a/sys/dev/wpi/if_wpi_debug.h b/sys/dev/wpi/if_wpi_debug.h new file mode 100644 index 0000000..6b78ace --- /dev/null +++ b/sys/dev/wpi/if_wpi_debug.h @@ -0,0 +1,143 @@ +/*- + * Copyright (c) 2006,2007 + * Damien Bergamini <damien.bergamini@free.fr> + * Benjamin Close <Benjamin.Close@clearchain.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $FreeBSD$ + */ + +#ifndef __IF_WPI_DEBUG_H__ +#define __IF_WPI_DEBUG_H__ + +#ifdef WPI_DEBUG +enum { + WPI_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ + WPI_DEBUG_RECV = 0x00000002, /* basic recv operation */ + WPI_DEBUG_STATE = 0x00000004, /* 802.11 state transitions */ + WPI_DEBUG_HW = 0x00000008, /* Stage 1 (eeprom) debugging */ + WPI_DEBUG_RESET = 0x00000010, /* reset processing */ + WPI_DEBUG_FIRMWARE = 0x00000020, /* firmware(9) loading debug */ + WPI_DEBUG_BEACON = 0x00000040, /* beacon handling */ + WPI_DEBUG_WATCHDOG = 0x00000080, /* watchdog timeout */ + WPI_DEBUG_INTR = 0x00000100, /* ISR */ + WPI_DEBUG_SCAN = 0x00000200, /* Scan related operations */ + WPI_DEBUG_NOTIFY = 0x00000400, /* State 2 Notif intr debug */ + WPI_DEBUG_TEMP = 0x00000800, /* TXPower/Temp Calibration */ + WPI_DEBUG_CMD = 0x00001000, /* cmd submission */ + WPI_DEBUG_TRACE = 0x00002000, /* Print begin and start driver function */ + WPI_DEBUG_PWRSAVE = 0x00004000, /* Power save operations */ + WPI_DEBUG_EEPROM = 0x00008000, /* EEPROM info */ + WPI_DEBUG_NODE = 0x00010000, /* node addition/removal */ + WPI_DEBUG_KEY = 0x00020000, /* node key management */ + WPI_DEBUG_EDCA = 0x00040000, /* WME info */ + WPI_DEBUG_REGISTER = 0x00080000, /* print chipset register */ + WPI_DEBUG_BMISS = 0x00100000, /* print number of missed beacons */ + WPI_DEBUG_ANY = 0xffffffff +}; + +#define DPRINTF(sc, m, ...) do { \ + if (sc->sc_debug & (m)) \ + printf(__VA_ARGS__); \ +} while (0) + +#define TRACE_STR_BEGIN "->%s: begin\n" +#define TRACE_STR_DOING "->Doing %s\n" +#define TRACE_STR_END "->%s: end\n" +#define TRACE_STR_END_ERR "->%s: end in error\n" + +#define WPI_DESC(x) case x: return #x + +static const char *wpi_cmd_str(int cmd) +{ + switch (cmd) { + /* Notifications. */ + WPI_DESC(WPI_UC_READY); + WPI_DESC(WPI_RX_DONE); + WPI_DESC(WPI_START_SCAN); + WPI_DESC(WPI_SCAN_RESULTS); + WPI_DESC(WPI_STOP_SCAN); + WPI_DESC(WPI_BEACON_SENT); + WPI_DESC(WPI_RX_STATISTICS); + WPI_DESC(WPI_BEACON_STATISTICS); + WPI_DESC(WPI_STATE_CHANGED); + WPI_DESC(WPI_BEACON_MISSED); + + /* Command notifications. */ + WPI_DESC(WPI_CMD_RXON); + WPI_DESC(WPI_CMD_RXON_ASSOC); + WPI_DESC(WPI_CMD_EDCA_PARAMS); + WPI_DESC(WPI_CMD_TIMING); + WPI_DESC(WPI_CMD_ADD_NODE); + WPI_DESC(WPI_CMD_DEL_NODE); + WPI_DESC(WPI_CMD_TX_DATA); + WPI_DESC(WPI_CMD_MRR_SETUP); + WPI_DESC(WPI_CMD_SET_LED); + WPI_DESC(WPI_CMD_SET_POWER_MODE); + WPI_DESC(WPI_CMD_SCAN); + WPI_DESC(WPI_CMD_SCAN_ABORT); + WPI_DESC(WPI_CMD_SET_BEACON); + WPI_DESC(WPI_CMD_TXPOWER); + WPI_DESC(WPI_CMD_BT_COEX); + + default: + return "UNKNOWN CMD"; + } +} + +/* + * Translate CSR code to string + */ +static const char *wpi_get_csr_string(size_t csr) +{ + switch (csr) { + WPI_DESC(WPI_HW_IF_CONFIG); + WPI_DESC(WPI_INT); + WPI_DESC(WPI_INT_MASK); + WPI_DESC(WPI_FH_INT); + WPI_DESC(WPI_GPIO_IN); + WPI_DESC(WPI_RESET); + WPI_DESC(WPI_GP_CNTRL); + WPI_DESC(WPI_EEPROM); + WPI_DESC(WPI_EEPROM_GP); + WPI_DESC(WPI_GIO); + WPI_DESC(WPI_UCODE_GP1); + WPI_DESC(WPI_UCODE_GP2); + WPI_DESC(WPI_GIO_CHICKEN); + WPI_DESC(WPI_ANA_PLL); + WPI_DESC(WPI_DBG_HPET_MEM); + default: + KASSERT(0, ("Unknown CSR: %d\n", csr)); + return "UNKNOWN CSR"; + } +} + +static const char *wpi_get_prph_string(size_t prph) +{ + switch (prph) { + WPI_DESC(WPI_APMG_CLK_CTRL); + WPI_DESC(WPI_APMG_PS); + WPI_DESC(WPI_APMG_PCI_STT); + WPI_DESC(WPI_APMG_RFKILL); + default: + KASSERT(0, ("Unknown register: %d\n", prph)); + return "UNKNOWN PRPH"; + } +} + +#else +#define DPRINTF(sc, m, ...) do { (void) sc; } while (0) +#endif + +#endif /* __IF_WPI_DEBUG_H__ */ diff --git a/sys/dev/wpi/if_wpireg.h b/sys/dev/wpi/if_wpireg.h index df71b3d..b0aa35c 100644 --- a/sys/dev/wpi/if_wpireg.h +++ b/sys/dev/wpi/if_wpireg.h @@ -18,181 +18,264 @@ */ #define WPI_TX_RING_COUNT 256 -#define WPI_CMD_RING_COUNT 256 -#define WPI_RX_RING_COUNT 64 +#define WPI_TX_RING_LOMARK 192 +#define WPI_TX_RING_HIMARK 224 + +#ifdef DIAGNOSTIC +#define WPI_RX_RING_COUNT_LOG 8 +#else +#define WPI_RX_RING_COUNT_LOG 6 +#endif + +#define WPI_RX_RING_COUNT (1 << WPI_RX_RING_COUNT_LOG) + +#define WPI_NTXQUEUES 8 +#define WPI_DRV_NTXQUEUES 5 +#define WPI_CMD_QUEUE_NUM 4 + +#define WPI_NDMACHNLS 6 + +/* Maximum scatter/gather. */ +#define WPI_MAX_SCATTER 4 /* * Rings must be aligned on a 16K boundary. */ #define WPI_RING_DMA_ALIGN 0x4000 -/* maximum scatter/gather */ -#define WPI_MAX_SCATTER 4 - -/* maximum Rx buffer size */ +/* Maximum Rx buffer size. */ #define WPI_RBUF_SIZE ( 3 * 1024 ) /* XXX 3000 but must be aligned */ /* * Control and status registers. */ -#define WPI_HWCONFIG 0x000 -#define WPI_INTR 0x008 -#define WPI_MASK 0x00c -#define WPI_INTR_STATUS 0x010 -#define WPI_GPIO_STATUS 0x018 +#define WPI_HW_IF_CONFIG 0x000 +#define WPI_INT 0x008 +#define WPI_INT_MASK 0x00c +#define WPI_FH_INT 0x010 +#define WPI_GPIO_IN 0x018 #define WPI_RESET 0x020 -#define WPI_GPIO_CTL 0x024 -#define WPI_EEPROM_CTL 0x02c -#define WPI_EEPROM_STATUS 0x030 -#define WPI_UCODE_SET 0x058 -#define WPI_UCODE_CLR 0x05c -#define WPI_TEMPERATURE 0x060 -#define WPI_CHICKEN 0x100 -#define WPI_PLL_CTL 0x20c -#define WPI_WRITE_MEM_ADDR 0x444 -#define WPI_READ_MEM_ADDR 0x448 -#define WPI_WRITE_MEM_DATA 0x44c -#define WPI_READ_MEM_DATA 0x450 -#define WPI_TX_WIDX 0x460 -#define WPI_TX_CTL(qid) (0x940 + (qid) * 8) -#define WPI_TX_BASE(qid) (0x944 + (qid) * 8) -#define WPI_TX_DESC(qid) (0x980 + (qid) * 80) -#define WPI_RX_CONFIG 0xc00 -#define WPI_RX_BASE 0xc04 -#define WPI_RX_WIDX 0xc20 -#define WPI_RX_RIDX_PTR 0xc24 -#define WPI_RX_CTL 0xcc0 -#define WPI_RX_STATUS 0xcc4 -#define WPI_TX_CONFIG(qid) (0xd00 + (qid) * 32) -#define WPI_TX_CREDIT(qid) (0xd04 + (qid) * 32) -#define WPI_TX_STATE(qid) (0xd08 + (qid) * 32) -#define WPI_TX_BASE_PTR 0xe80 -#define WPI_MSG_CONFIG 0xe88 -#define WPI_TX_STATUS 0xe90 +#define WPI_GP_CNTRL 0x024 +#define WPI_EEPROM 0x02c +#define WPI_EEPROM_GP 0x030 +#define WPI_GIO 0x03c +#define WPI_UCODE_GP1 0x054 +#define WPI_UCODE_GP1_SET 0x058 +#define WPI_UCODE_GP1_CLR 0x05c +#define WPI_UCODE_GP2 0x060 +#define WPI_GIO_CHICKEN 0x100 +#define WPI_ANA_PLL 0x20c +#define WPI_DBG_HPET_MEM 0x240 +#define WPI_MEM_RADDR 0x40c +#define WPI_MEM_WADDR 0x410 +#define WPI_MEM_WDATA 0x418 +#define WPI_MEM_RDATA 0x41c +#define WPI_PRPH_WADDR 0x444 +#define WPI_PRPH_RADDR 0x448 +#define WPI_PRPH_WDATA 0x44c +#define WPI_PRPH_RDATA 0x450 +#define WPI_HBUS_TARG_WRPTR 0x460 + +/* + * Flow-Handler registers. + */ +#define WPI_FH_CBBC_CTRL(qid) (0x940 + (qid) * 8) +#define WPI_FH_CBBC_BASE(qid) (0x944 + (qid) * 8) +#define WPI_FH_RX_CONFIG 0xc00 +#define WPI_FH_RX_BASE 0xc04 +#define WPI_FH_RX_WPTR 0xc20 +#define WPI_FH_RX_RPTR_ADDR 0xc24 +#define WPI_FH_RSSR_TBL 0xcc0 +#define WPI_FH_RX_STATUS 0xcc4 +#define WPI_FH_TX_CONFIG(qid) (0xd00 + (qid) * 32) +#define WPI_FH_TX_BASE 0xe80 +#define WPI_FH_MSG_CONFIG 0xe88 +#define WPI_FH_TX_STATUS 0xe90 /* * NIC internal memory offsets. */ -#define WPI_MEM_MODE 0x2e00 -#define WPI_MEM_RA 0x2e04 -#define WPI_MEM_TXCFG 0x2e10 -#define WPI_MEM_MAGIC4 0x2e14 -#define WPI_MEM_MAGIC5 0x2e20 -#define WPI_MEM_BYPASS1 0x2e2c -#define WPI_MEM_BYPASS2 0x2e30 -#define WPI_MEM_CLOCK1 0x3004 -#define WPI_MEM_CLOCK2 0x3008 -#define WPI_MEM_POWER 0x300c -#define WPI_MEM_PCIDEV 0x3010 -#define WPI_MEM_HW_RADIO_OFF 0x3014 -#define WPI_MEM_UCODE_CTL 0x3400 -#define WPI_MEM_UCODE_SRC 0x3404 -#define WPI_MEM_UCODE_DST 0x3408 -#define WPI_MEM_UCODE_SIZE 0x340c -#define WPI_MEM_UCODE_BASE 0x3800 - -#define WPI_MEM_TEXT_BASE 0x3490 -#define WPI_MEM_TEXT_SIZE 0x3494 -#define WPI_MEM_DATA_BASE 0x3498 -#define WPI_MEM_DATA_SIZE 0x349c - - -/* possible flags for register WPI_HWCONFIG */ -#define WPI_HW_ALM_MB (1 << 8) -#define WPI_HW_ALM_MM (1 << 9) -#define WPI_HW_SKU_MRC (1 << 10) -#define WPI_HW_REV_D (1 << 11) -#define WPI_HW_TYPE_B (1 << 12) - -/* possible flags for registers WPI_READ_MEM_ADDR/WPI_WRITE_MEM_ADDR */ -#define WPI_MEM_4 ((sizeof (uint32_t) - 1) << 24) - -/* possible values for WPI_MEM_UCODE_DST */ -#define WPI_FW_TEXT 0x00000000 - -/* possible flags for WPI_GPIO_STATUS */ -#define WPI_POWERED (1 << 9) - -/* possible flags for register WPI_RESET */ -#define WPI_NEVO_RESET (1 << 0) -#define WPI_SW_RESET (1 << 7) -#define WPI_MASTER_DISABLED (1 << 8) -#define WPI_STOP_MASTER (1 << 9) - -/* possible flags for register WPI_GPIO_CTL */ -#define WPI_GPIO_CLOCK (1 << 0) -#define WPI_GPIO_INIT (1 << 2) -#define WPI_GPIO_MAC (1 << 3) -#define WPI_GPIO_SLEEP (1 << 4) -#define WPI_GPIO_PWR_STATUS 0x07000000 -#define WPI_GPIO_PWR_SLEEP (4 << 24) - -/* possible flags for register WPI_CHICKEN */ -#define WPI_CHICKEN_RXNOLOS (1 << 23) - -/* possible flags for register WPI_PLL_CTL */ -#define WPI_PLL_INIT (1 << 24) - -/* possible flags for register WPI_UCODE_CLR */ -#define WPI_RADIO_OFF (1 << 1) -#define WPI_DISABLE_CMD (1 << 2) - -/* possible flags for WPI_RX_STATUS */ -#define WPI_RX_IDLE (1 << 24) - -/* possible flags for register WPI_UC_CTL */ -#define WPI_UC_ENABLE (1 << 30) -#define WPI_UC_RUN (1U << 31) - -/* possible flags for register WPI_INTR_CSR */ -#define WPI_ALIVE_INTR (1 << 0) -#define WPI_WAKEUP_INTR (1 << 1) -#define WPI_SW_ERROR (1 << 25) -#define WPI_TX_INTR (1 << 27) -#define WPI_HW_ERROR (1 << 29) -#define WPI_RX_INTR (1U << 31) - -#define WPI_INTR_MASK \ - (WPI_SW_ERROR | WPI_HW_ERROR | WPI_TX_INTR | WPI_RX_INTR | \ - WPI_ALIVE_INTR | WPI_WAKEUP_INTR) - -/* possible flags for register WPI_TX_STATUS */ -#define WPI_TX_IDLE(qid) (1 << ((qid) + 24) | 1 << ((qid) + 16)) - -/* possible flags for register WPI_EEPROM_CTL */ -#define WPI_EEPROM_READY (1 << 0) - -/* possible flags for register WPI_EEPROM_STATUS */ +#define WPI_ALM_SCHED_MODE 0x2e00 +#define WPI_ALM_SCHED_ARASTAT 0x2e04 +#define WPI_ALM_SCHED_TXFACT 0x2e10 +#define WPI_ALM_SCHED_TXF4MF 0x2e14 +#define WPI_ALM_SCHED_TXF5MF 0x2e20 +#define WPI_ALM_SCHED_SBYPASS_MODE1 0x2e2c +#define WPI_ALM_SCHED_SBYPASS_MODE2 0x2e30 +#define WPI_APMG_CLK_CTRL 0x3000 +#define WPI_APMG_CLK_EN 0x3004 +#define WPI_APMG_CLK_DIS 0x3008 +#define WPI_APMG_PS 0x300c +#define WPI_APMG_PCI_STT 0x3010 +#define WPI_APMG_RFKILL 0x3014 +#define WPI_BSM_WR_CTRL 0x3400 +#define WPI_BSM_WR_MEM_SRC 0x3404 +#define WPI_BSM_WR_MEM_DST 0x3408 +#define WPI_BSM_WR_DWCOUNT 0x340c +#define WPI_BSM_DRAM_TEXT_ADDR 0x3490 +#define WPI_BSM_DRAM_TEXT_SIZE 0x3494 +#define WPI_BSM_DRAM_DATA_ADDR 0x3498 +#define WPI_BSM_DRAM_DATA_SIZE 0x349c +#define WPI_BSM_SRAM_BASE 0x3800 + + +/* Possible flags for register WPI_HW_IF_CONFIG. */ +#define WPI_HW_IF_CONFIG_ALM_MB (1 << 8) +#define WPI_HW_IF_CONFIG_ALM_MM (1 << 9) +#define WPI_HW_IF_CONFIG_SKU_MRC (1 << 10) +#define WPI_HW_IF_CONFIG_REV_D (1 << 11) +#define WPI_HW_IF_CONFIG_TYPE_B (1 << 12) + +/* Possible flags for registers WPI_PRPH_RADDR/WPI_PRPH_WADDR. */ +#define WPI_PRPH_DWORD ((sizeof (uint32_t) - 1) << 24) + +/* Possible values for WPI_BSM_WR_MEM_DST. */ +#define WPI_FW_TEXT_BASE 0x00000000 +#define WPI_FW_DATA_BASE 0x00800000 + +/* Possible flags for WPI_GPIO_IN. */ +#define WPI_GPIO_IN_VMAIN (1 << 9) + +/* Possible flags for register WPI_RESET. */ +#define WPI_RESET_NEVO (1 << 0) +#define WPI_RESET_SW (1 << 7) +#define WPI_RESET_MASTER_DISABLED (1 << 8) +#define WPI_RESET_STOP_MASTER (1 << 9) + +/* Possible flags for register WPI_GP_CNTRL. */ +#define WPI_GP_CNTRL_MAC_ACCESS_ENA (1 << 0) +#define WPI_GP_CNTRL_MAC_CLOCK_READY (1 << 0) +#define WPI_GP_CNTRL_INIT_DONE (1 << 2) +#define WPI_GP_CNTRL_MAC_ACCESS_REQ (1 << 3) +#define WPI_GP_CNTRL_SLEEP (1 << 4) +#define WPI_GP_CNTRL_PS_MASK (7 << 24) +#define WPI_GP_CNTRL_MAC_PS (4 << 24) +#define WPI_GP_CNTRL_RFKILL (1 << 27) + +/* Possible flags for register WPI_GIO_CHICKEN. */ +#define WPI_GIO_CHICKEN_L1A_NO_L0S_RX (1 << 23) +#define WPI_GIO_CHICKEN_DIS_L0S_TIMER (1 << 29) + +/* Possible flags for register WPI_GIO. */ +#define WPI_GIO_L0S_ENA (1 << 1) + +/* Possible flags for register WPI_FH_RX_CONFIG. */ +#define WPI_FH_RX_CONFIG_DMA_ENA (1U << 31) +#define WPI_FH_RX_CONFIG_RDRBD_ENA (1 << 29) +#define WPI_FH_RX_CONFIG_WRSTATUS_ENA (1 << 27) +#define WPI_FH_RX_CONFIG_MAXFRAG (1 << 24) +#define WPI_FH_RX_CONFIG_NRBD(x) ((x) << 20) +#define WPI_FH_RX_CONFIG_IRQ_DST_HOST (1 << 12) +#define WPI_FH_RX_CONFIG_IRQ_TIMEOUT(x) ((x) << 4) + +/* Possible flags for register WPI_ANA_PLL. */ +#define WPI_ANA_PLL_INIT (1 << 24) + +/* Possible flags for register WPI_UCODE_GP1*. */ +#define WPI_UCODE_GP1_MAC_SLEEP (1 << 0) +#define WPI_UCODE_GP1_RFKILL (1 << 1) +#define WPI_UCODE_GP1_CMD_BLOCKED (1 << 2) + +/* Possible flags for register WPI_FH_RX_STATUS. */ +#define WPI_FH_RX_STATUS_IDLE (1 << 24) + +/* Possible flags for register WPI_BSM_WR_CTRL. */ +#define WPI_BSM_WR_CTRL_START_EN (1 << 30) +#define WPI_BSM_WR_CTRL_START (1U << 31) + +/* Possible flags for register WPI_INT. */ +#define WPI_INT_ALIVE (1 << 0) +#define WPI_INT_WAKEUP (1 << 1) +#define WPI_INT_SW_RX (1 << 3) +#define WPI_INT_SW_ERR (1 << 25) +#define WPI_INT_FH_TX (1 << 27) +#define WPI_INT_HW_ERR (1 << 29) +#define WPI_INT_FH_RX (1U << 31) + +/* Shortcut. */ +#define WPI_INT_MASK_DEF \ + (WPI_INT_SW_ERR | WPI_INT_HW_ERR | WPI_INT_FH_TX | \ + WPI_INT_FH_RX | WPI_INT_ALIVE | WPI_INT_WAKEUP | \ + WPI_INT_SW_RX) + +/* Possible flags for register WPI_FH_INT. */ +#define WPI_FH_INT_RX_CHNL(x) (1 << ((x) + 16)) +#define WPI_FH_INT_HI_PRIOR (1 << 30) +/* Shortcuts for the above. */ +#define WPI_FH_INT_RX \ + (WPI_FH_INT_RX_CHNL(0) | \ + WPI_FH_INT_RX_CHNL(1) | \ + WPI_FH_INT_RX_CHNL(2) | \ + WPI_FH_INT_HI_PRIOR) + +/* Possible flags for register WPI_FH_TX_STATUS. */ +#define WPI_FH_TX_STATUS_IDLE(qid) \ + (1 << ((qid) + 24) | 1 << ((qid) + 16)) + +/* Possible flags for register WPI_EEPROM. */ +#define WPI_EEPROM_READ_VALID (1 << 0) + +/* Possible flags for register WPI_EEPROM_GP. */ #define WPI_EEPROM_VERSION 0x00000007 -#define WPI_EEPROM_LOCKED 0x00000180 +#define WPI_EEPROM_GP_IF_OWNER 0x00000180 + +/* Possible flags for register WPI_APMG_PS. */ +#define WPI_APMG_PS_PWR_SRC_MASK (3 << 24) +/* Possible flags for registers WPI_APMG_CLK_*. */ +#define WPI_APMG_CLK_CTRL_DMA_CLK_RQT (1 << 9) +#define WPI_APMG_CLK_CTRL_BSM_CLK_RQT (1 << 11) + +/* Possible flags for register WPI_APMG_PCI_STT. */ +#define WPI_APMG_PCI_STT_L1A_DIS (1 << 11) struct wpi_shared { - uint32_t txbase[8]; + uint32_t txbase[WPI_NTXQUEUES]; uint32_t next; uint32_t reserved[2]; } __packed; #define WPI_MAX_SEG_LEN 65520 struct wpi_tx_desc { - uint32_t flags; + uint8_t reserved1[3]; + uint8_t nsegs; #define WPI_PAD32(x) (roundup2(x, 4) - (x)) struct { uint32_t addr; uint32_t len; - } __attribute__((__packed__)) segs[WPI_MAX_SCATTER]; - uint8_t reserved[28]; + } __packed segs[WPI_MAX_SCATTER]; + uint8_t reserved2[28]; } __packed; struct wpi_tx_stat { - uint8_t nrts; - uint8_t ntries; - uint8_t nkill; + uint8_t rtsfailcnt; + uint8_t ackfailcnt; + uint8_t btkillcnt; uint8_t rate; uint32_t duration; uint32_t status; +#define WPI_TX_STATUS_SUCCESS 0x01 +#define WPI_TX_STATUS_DIRECT_DONE 0x02 +#define WPI_TX_STATUS_FAIL 0x80 +#define WPI_TX_STATUS_FAIL_SHORT_LIMIT 0x82 +#define WPI_TX_STATUS_FAIL_LONG_LIMIT 0x83 +#define WPI_TX_STATUS_FAIL_FIFO_UNDERRUN 0x84 +#define WPI_TX_STATUS_FAIL_MGMNT_ABORT 0x85 +#define WPI_TX_STATUS_FAIL_NEXT_FRAG 0x86 +#define WPI_TX_STATUS_FAIL_LIFE_EXPIRE 0x87 +#define WPI_TX_STATUS_FAIL_NODE_PS 0x88 +#define WPI_TX_STATUS_FAIL_ABORTED 0x89 +#define WPI_TX_STATUS_FAIL_BT_RETRY 0x8a +#define WPI_TX_STATUS_FAIL_NODE_INVALID 0x8b +#define WPI_TX_STATUS_FAIL_FRAG_DROPPED 0x8c +#define WPI_TX_STATUS_FAIL_TID_DISABLE 0x8d +#define WPI_TX_STATUS_FAIL_FRAME_FLUSHED 0x8e +#define WPI_TX_STATUS_FAIL_INSUFFICIENT_CF_POLL 0x8f +#define WPI_TX_STATUS_FAIL_TX_LOCKED 0x90 +#define WPI_TX_STATUS_FAIL_NO_BEACON_ON_RADAR 0x91 + } __packed; struct wpi_rx_desc { @@ -204,21 +287,27 @@ struct wpi_rx_desc { #define WPI_START_SCAN 130 #define WPI_SCAN_RESULTS 131 #define WPI_STOP_SCAN 132 +#define WPI_BEACON_SENT 144 +#define WPI_RX_STATISTICS 156 +#define WPI_BEACON_STATISTICS 157 #define WPI_STATE_CHANGED 161 -#define WPI_MISSED_BEACON 162 +#define WPI_BEACON_MISSED 162 uint8_t flags; uint8_t idx; uint8_t qid; } __packed; +#define WPI_RX_DESC_QID_MSK 0x07 +#define WPI_UNSOLICITED_RX_NOTIF 0x80 + struct wpi_rx_stat { uint8_t len; #define WPI_STAT_MAXLEN 20 uint8_t id; uint8_t rssi; /* received signal strength */ -#define WPI_RSSI_OFFSET 95 +#define WPI_RSSI_OFFSET -95 uint8_t agc; /* access gain control */ uint16_t signal; @@ -228,8 +317,10 @@ struct wpi_rx_stat { struct wpi_rx_head { uint16_t chan; uint16_t flags; +#define WPI_STAT_FLAG_SHPREAMBLE (1 << 2) + uint8_t reserved; - uint8_t rate; + uint8_t plcp; uint16_t len; } __packed; @@ -239,39 +330,47 @@ struct wpi_rx_tail { #define WPI_RX_NO_OVFL_ERR (1 << 1) /* shortcut for the above */ #define WPI_RX_NOERROR (WPI_RX_NO_CRC_ERR | WPI_RX_NO_OVFL_ERR) +#define WPI_RX_CIPHER_MASK (7 << 8) +#define WPI_RX_CIPHER_CCMP (2 << 8) +#define WPI_RX_DECRYPT_MASK (3 << 11) +#define WPI_RX_DECRYPT_OK (3 << 11) + uint64_t tstamp; uint32_t tbeacon; } __packed; struct wpi_tx_cmd { uint8_t code; -#define WPI_CMD_CONFIGURE 16 -#define WPI_CMD_ASSOCIATE 17 -#define WPI_CMD_SET_WME 19 -#define WPI_CMD_TSF 20 +#define WPI_CMD_RXON 16 +#define WPI_CMD_RXON_ASSOC 17 +#define WPI_CMD_EDCA_PARAMS 19 +#define WPI_CMD_TIMING 20 #define WPI_CMD_ADD_NODE 24 +#define WPI_CMD_DEL_NODE 25 #define WPI_CMD_TX_DATA 28 #define WPI_CMD_MRR_SETUP 71 #define WPI_CMD_SET_LED 72 #define WPI_CMD_SET_POWER_MODE 119 #define WPI_CMD_SCAN 128 +#define WPI_CMD_SCAN_ABORT 129 #define WPI_CMD_SET_BEACON 145 #define WPI_CMD_TXPOWER 151 -#define WPI_CMD_BLUETOOTH 155 +#define WPI_CMD_BT_COEX 155 +#define WPI_CMD_GET_STATISTICS 156 uint8_t flags; uint8_t idx; uint8_t qid; - uint8_t data[360]; + uint8_t data[124]; } __packed; -/* structure for WPI_CMD_CONFIGURE */ -struct wpi_config { +/* Structure for command WPI_CMD_RXON. */ +struct wpi_rxon { uint8_t myaddr[IEEE80211_ADDR_LEN]; uint16_t reserved1; uint8_t bssid[IEEE80211_ADDR_LEN]; uint16_t reserved2; - uint8_t wlap_bssid_addr[6]; + uint8_t wlap[IEEE80211_ADDR_LEN]; uint16_t reserved3; uint8_t mode; #define WPI_MODE_HOSTAP 1 @@ -279,21 +378,22 @@ struct wpi_config { #define WPI_MODE_IBSS 4 #define WPI_MODE_MONITOR 6 - uint8_t air_propogation; + uint8_t air; uint16_t reserved4; uint8_t ofdm_mask; uint8_t cck_mask; uint16_t associd; uint32_t flags; -#define WPI_CONFIG_24GHZ (1 << 0) -#define WPI_CONFIG_CCK (1 << 1) -#define WPI_CONFIG_AUTO (1 << 2) -#define WPI_CONFIG_SHSLOT (1 << 4) -#define WPI_CONFIG_SHPREAMBLE (1 << 5) -#define WPI_CONFIG_NODIVERSITY (1 << 7) -#define WPI_CONFIG_ANTENNA_A (1 << 8) -#define WPI_CONFIG_ANTENNA_B (1 << 9) -#define WPI_CONFIG_TSF (1 << 15) +#define WPI_RXON_24GHZ (1 << 0) +#define WPI_RXON_CCK (1 << 1) +#define WPI_RXON_AUTO (1 << 2) +#define WPI_RXON_SHSLOT (1 << 4) +#define WPI_RXON_SHPREAMBLE (1 << 5) +#define WPI_RXON_NODIVERSITY (1 << 7) +#define WPI_RXON_ANTENNA_A (1 << 8) +#define WPI_RXON_ANTENNA_B (1 << 9) +#define WPI_RXON_TSF (1 << 15) +#define WPI_RXON_CTS_TO_SELF (1 << 30) uint32_t filter; #define WPI_FILTER_PROMISC (1 << 0) @@ -302,12 +402,13 @@ struct wpi_config { #define WPI_FILTER_NODECRYPT (1 << 3) #define WPI_FILTER_BSS (1 << 5) #define WPI_FILTER_BEACON (1 << 6) +#define WPI_FILTER_ASSOC (1 << 7) /* Accept associaton requests. */ uint8_t chan; - uint16_t reserved6; + uint16_t reserved5; } __packed; -/* structure for command WPI_CMD_ASSOCIATE */ +/* Structure for command WPI_CMD_RXON_ASSOC. */ struct wpi_assoc { uint32_t flags; uint32_t filter; @@ -316,20 +417,22 @@ struct wpi_assoc { uint16_t reserved; } __packed; -/* structure for command WPI_CMD_SET_WME */ -struct wpi_wme_setup { +/* Structure for command WPI_CMD_EDCA_PARAMS. */ +struct wpi_edca_params { uint32_t flags; +#define WPI_EDCA_UPDATE (1 << 0) + struct { uint16_t cwmin; uint16_t cwmax; uint8_t aifsn; uint8_t reserved; - uint16_t txop; + uint16_t txoplimit; } __packed ac[WME_NUM_AC]; } __packed; -/* structure for command WPI_CMD_TSF */ -struct wpi_cmd_tsf { +/* Structure for command WPI_CMD_TIMING. */ +struct wpi_cmd_timing { uint64_t tstamp; uint16_t bintval; uint16_t atim; @@ -338,77 +441,102 @@ struct wpi_cmd_tsf { uint16_t reserved; } __packed; -/* structure for WPI_CMD_ADD_NODE */ +/* Structure for command WPI_CMD_ADD_NODE. */ struct wpi_node_info { uint8_t control; -#define WPI_NODE_UPDATE (1 << 0) +#define WPI_NODE_UPDATE (1 << 0) uint8_t reserved1[3]; - uint8_t bssid[IEEE80211_ADDR_LEN]; + uint8_t macaddr[IEEE80211_ADDR_LEN]; uint16_t reserved2; uint8_t id; #define WPI_ID_BSS 0 +#define WPI_ID_IBSS_MIN 2 +#define WPI_ID_IBSS_MAX 23 #define WPI_ID_BROADCAST 24 +#define WPI_ID_UNDEFINED (uint8_t)-1 uint8_t flags; +#define WPI_FLAG_KEY_SET (1 << 0) + uint16_t reserved3; - uint16_t key_flags; - uint8_t tkip; + uint16_t kflags; +#define WPI_KFLAG_CCMP (1 << 1) +#define WPI_KFLAG_KID(kid) ((kid) << 8) +#define WPI_KFLAG_MULTICAST (1 << 14) + + uint8_t tsc2; uint8_t reserved4; uint16_t ttak[5]; uint16_t reserved5; uint8_t key[IEEE80211_KEYBUF_SIZE]; uint32_t action; -#define WPI_ACTION_SET_RATE 4 +#define WPI_ACTION_SET_RATE (1 << 2) + uint32_t mask; uint16_t tid; - uint8_t rate; + uint8_t plcp; uint8_t antenna; -#define WPI_ANTENNA_A (1<<6) -#define WPI_ANTENNA_B (1<<7) -#define WPI_ANTENNA_BOTH (WPI_ANTENNA_A|WPI_ANTENNA_B) +#define WPI_ANTENNA_A (1 << 6) +#define WPI_ANTENNA_B (1 << 7) +#define WPI_ANTENNA_BOTH (WPI_ANTENNA_A | WPI_ANTENNA_B) + uint8_t add_imm; uint8_t del_imm; uint16_t add_imm_start; } __packed; -/* structure for command WPI_CMD_TX_DATA */ +/* Structure for command WPI_CMD_DEL_NODE. */ +struct wpi_cmd_del_node { + uint8_t count; + uint8_t reserved1[3]; + uint8_t macaddr[IEEE80211_ADDR_LEN]; + uint16_t reserved2; +} __packed; + +/* Structure for command WPI_CMD_TX_DATA. */ struct wpi_cmd_data { uint16_t len; uint16_t lnext; uint32_t flags; #define WPI_TX_NEED_RTS (1 << 1) -#define WPI_TX_NEED_CTS (1 << 2) +#define WPI_TX_NEED_CTS (1 << 2) #define WPI_TX_NEED_ACK (1 << 3) #define WPI_TX_FULL_TXOP (1 << 7) -#define WPI_TX_BT_DISABLE (1 << 12) /* bluetooth coexistence */ +#define WPI_TX_BT_DISABLE (1 << 12) /* bluetooth coexistence */ #define WPI_TX_AUTO_SEQ (1 << 13) +#define WPI_TX_MORE_FRAG (1 << 14) #define WPI_TX_INSERT_TSTAMP (1 << 16) - uint8_t rate; + uint8_t plcp; uint8_t id; uint8_t tid; uint8_t security; +#define WPI_CIPHER_WEP 1 +#define WPI_CIPHER_CCMP 2 +#define WPI_CIPHER_TKIP 3 +#define WPI_CIPHER_WEP104 9 + uint8_t key[IEEE80211_KEYBUF_SIZE]; uint8_t tkip[IEEE80211_WEP_MICLEN]; uint32_t fnext; uint32_t lifetime; #define WPI_LIFETIME_INFINITE 0xffffffff + uint8_t ofdm_mask; uint8_t cck_mask; uint8_t rts_ntries; uint8_t data_ntries; uint16_t timeout; uint16_t txop; - struct ieee80211_frame wh; } __packed; -/* structure for command WPI_CMD_SET_BEACON */ +/* Structure for command WPI_CMD_SET_BEACON. */ struct wpi_cmd_beacon { uint16_t len; uint16_t reserved1; uint32_t flags; /* same as wpi_cmd_data */ - uint8_t rate; + uint8_t plcp; uint8_t id; uint8_t reserved2[30]; uint32_t lifetime; @@ -418,41 +546,35 @@ struct wpi_cmd_beacon { uint16_t tim; uint8_t timsz; uint8_t reserved4; - struct ieee80211_frame wh; } __packed; -/* structure for notification WPI_MISSED_BEACON */ -struct wpi_missed_beacon { - uint32_t consecutive; - uint32_t total; - uint32_t expected; - uint32_t received; +/* Structure for notification WPI_BEACON_MISSED. */ +struct wpi_beacon_missed { + uint32_t consecutive; + uint32_t total; + uint32_t expected; + uint32_t received; } __packed; -/* structure for WPI_CMD_MRR_SETUP */ +/* Structure for command WPI_CMD_MRR_SETUP. */ +#define WPI_RIDX_MAX 11 struct wpi_mrr_setup { - uint8_t which; + uint32_t which; #define WPI_MRR_CTL 0 #define WPI_MRR_DATA 1 - uint8_t reserved[3]; - struct { - uint8_t signal; + uint8_t plcp; uint8_t flags; uint8_t ntries; - uint8_t next; -#define WPI_OFDM6 0 -#define WPI_OFDM54 7 -#define WPI_CCK1 8 -#define WPI_CCK2 9 -#define WPI_CCK11 11 +#define WPI_NTRIES_DEFAULT 2 - } __attribute__((__packed__)) rates[WPI_CCK11 + 1]; + uint8_t next; + } __packed rates[WPI_RIDX_MAX + 1]; } __packed; -/* structure for WPI_CMD_SET_LED */ +/* Structure for command WPI_CMD_SET_LED. */ struct wpi_cmd_led { uint32_t unit; /* multiplier (in usecs) */ uint8_t which; @@ -464,136 +586,133 @@ struct wpi_cmd_led { uint8_t reserved; } __packed; -/* structure for WPI_CMD_SET_POWER_MODE */ -struct wpi_power { - uint32_t flags; -#define WPI_POWER_CAM 0 /* constantly awake mode */ - uint32_t rx_timeout; - uint32_t tx_timeout; - uint32_t sleep[5]; +/* Structure for command WPI_CMD_SET_POWER_MODE. */ +struct wpi_pmgt_cmd { + uint16_t flags; +#define WPI_PS_ALLOW_SLEEP (1 << 0) +#define WPI_PS_NOTIFY (1 << 1) +#define WPI_PS_SLEEP_OVER_DTIM (1 << 2) +#define WPI_PS_PCI_PMGT (1 << 3) + + uint8_t reserved[2]; + uint32_t rxtimeout; + uint32_t txtimeout; + uint32_t intval[5]; +} __packed; + +/* Structures for command WPI_CMD_SCAN. */ +#define WPI_SCAN_MAX_ESSIDS 4 +struct wpi_scan_essid { + uint8_t id; + uint8_t len; + uint8_t data[IEEE80211_NWID_LEN]; } __packed; -/* structure for command WPI_CMD_SCAN */ struct wpi_scan_hdr { uint16_t len; uint8_t reserved1; uint8_t nchan; - uint16_t quiet; - uint16_t threshold; - uint16_t promotion; + uint16_t quiet_time; /* timeout in milliseconds */ +#define WPI_QUIET_TIME_DEFAULT 10 + + uint16_t quiet_threshold; /* min # of packets */ + uint16_t crc_threshold; uint16_t reserved2; - uint32_t maxtimeout; - uint32_t suspend; - uint32_t flags; - uint32_t filter; + uint32_t max_svc; /* background scans */ + uint32_t pause_svc; /* background scans */ +#define WPI_PAUSE_MAX_TIME ((1 << 20) - 1) +#define WPI_PAUSE_SCAN(nbeacons, time) ((nbeacons << 24) | time) -struct { - uint16_t len; - uint16_t lnext; uint32_t flags; - uint8_t rate; - uint8_t id; - uint8_t tid; - uint8_t security; - uint8_t key[IEEE80211_KEYBUF_SIZE]; - uint8_t tkip[IEEE80211_WEP_MICLEN]; - uint32_t fnext; - uint32_t lifetime; - uint8_t ofdm_mask; - uint8_t cck_mask; - uint8_t rts_ntries; - uint8_t data_ntries; - uint16_t timeout; - uint16_t txop; -} tx __attribute__((__packed__)); + uint32_t filter; -#define WPI_SCAN_MAX_ESSIDS 4 - struct { - uint8_t id; - uint8_t esslen; - uint8_t essid[32]; - }scan_essids[WPI_SCAN_MAX_ESSIDS]; - /* followed by probe request body */ - /* followed by nchan x wpi_scan_chan */ + /* Followed by a struct wpi_cmd_data. */ + /* Followed by an array of 4 structs wpi_scan_essid. */ + /* Followed by probe request body. */ + /* Followed by an array of ``nchan'' structs wpi_scan_chan. */ } __packed; struct wpi_scan_chan { uint8_t flags; +#define WPI_CHAN_ACTIVE (1 << 0) +#define WPI_CHAN_NPBREQS(x) (((1 << (x)) - 1) << 1) + uint8_t chan; -#define WPI_CHAN_ACTIVE (1 << 0) -#define WPI_CHAN_DIRECT (1 << 1) - uint8_t gain_radio; - uint8_t gain_dsp; + uint8_t rf_gain; + uint8_t dsp_gain; uint16_t active; /* msecs */ uint16_t passive; /* msecs */ } __packed; -/* structure for WPI_CMD_BLUETOOTH */ -struct wpi_bluetooth { - uint8_t flags; - uint8_t lead; - uint8_t kill; - uint8_t reserved; - uint32_t ack; - uint32_t cts; -} __packed; +#define WPI_SCAN_CRC_TH_DEFAULT htole16(1) +#define WPI_SCAN_CRC_TH_NEVER htole16(0xffff) -/* structure for command WPI_CMD_TXPOWER */ -struct wpi_cmd_txpower { +/* Maximum size of a scan command. */ +#define WPI_SCAN_MAXSZ (MCLBYTES - 4) + +#define WPI_ACTIVE_DWELL_TIME_2GHZ (30) /* all times in msec */ +#define WPI_ACTIVE_DWELL_TIME_5GHZ (20) +#define WPI_ACTIVE_DWELL_FACTOR_2GHZ ( 3) +#define WPI_ACTIVE_DWELL_FACTOR_5GHZ ( 2) +#define WPI_PASSIVE_DWELL_TIME_2GHZ ( 20) +#define WPI_PASSIVE_DWELL_TIME_5GHZ ( 10) +#define WPI_PASSIVE_DWELL_BASE (100) +#define WPI_CHANNEL_TUNE_TIME ( 6) + +/* Structure for command WPI_CMD_TXPOWER. */ +struct wpi_cmd_txpower { uint8_t band; -#define WPI_RATE_5GHZ 0 -#define WPI_RATE_2GHZ 1 +#define WPI_BAND_5GHZ 0 +#define WPI_BAND_2GHZ 1 + uint8_t reserved; - uint16_t channel; + uint16_t chan; -#define WPI_RATE_MAPPING_COUNT 12 struct { - uint8_t rate; - uint8_t gain_radio; - uint8_t gain_dsp; - uint8_t reserved; - } __packed rates [WPI_RATE_MAPPING_COUNT]; + uint8_t plcp; + uint8_t rf_gain; + uint8_t dsp_gain; + uint8_t reserved; + } __packed rates[WPI_RIDX_MAX + 1]; } __packed; +/* Structure for command WPI_CMD_BT_COEX. */ +struct wpi_bluetooth { + uint8_t flags; +#define WPI_BT_COEX_DISABLE 0 +#define WPI_BT_COEX_MODE_2WIRE 1 +#define WPI_BT_COEX_MODE_3WIRE 2 +#define WPI_BT_COEX_MODE_4WIRE 3 + uint8_t lead_time; +#define WPI_BT_LEAD_TIME_DEF 30 -#define WPI_FW_MAIN_TEXT_MAXSZ (80 * 1024 ) -#define WPI_FW_MAIN_DATA_MAXSZ (32 * 1024 ) -#define WPI_FW_INIT_TEXT_MAXSZ (80 * 1024 ) -#define WPI_FW_INIT_DATA_MAXSZ (32 * 1024 ) -#define WPI_FW_BOOT_TEXT_MAXSZ 1024 - -#define WPI_FW_UPDATED (1 << 31 ) - -/* firmware image header */ -struct wpi_firmware_hdr { - -#define WPI_FW_MINVERSION 2144 + uint8_t max_kill; +#define WPI_BT_MAX_KILL_DEF 5 - uint32_t version; - uint32_t rtextsz; - uint32_t rdatasz; - uint32_t itextsz; - uint32_t idatasz; - uint32_t btextsz; + uint8_t reserved; + uint32_t kill_ack; + uint32_t kill_cts; } __packed; -/* structure for WPI_UC_READY notification */ +/* Structure for WPI_UC_READY notification. */ struct wpi_ucode_info { - uint32_t version; + uint8_t minor; + uint8_t major; + uint16_t reserved1; uint8_t revision[8]; uint8_t type; uint8_t subtype; - uint16_t reserved; + uint16_t reserved2; uint32_t logptr; - uint32_t errorptr; - uint32_t timestamp; + uint32_t errptr; + uint32_t tstamp; uint32_t valid; } __packed; -/* structure for WPI_START_SCAN notification */ +/* Structure for WPI_START_SCAN notification. */ struct wpi_start_scan { uint64_t tstamp; uint32_t tbeacon; @@ -603,18 +722,126 @@ struct wpi_start_scan { uint32_t status; } __packed; -/* structure for WPI_STOP_SCAN notification */ +/* Structure for WPI_STOP_SCAN notification. */ struct wpi_stop_scan { uint8_t nchan; uint8_t status; +#define WPI_SCAN_COMPLETED 1 +#define WPI_SCAN_ABORTED 2 + uint8_t reserved; uint8_t chan; uint64_t tsf; } __packed; +/* Structures for WPI_{RX,BEACON}_STATISTICS notification. */ +struct wpi_rx_phy_stats { + uint32_t ina; + uint32_t fina; + uint32_t bad_plcp; + uint32_t bad_crc32; + uint32_t overrun; + uint32_t eoverrun; + uint32_t good_crc32; + uint32_t fa; + uint32_t bad_fina_sync; + uint32_t sfd_timeout; + uint32_t fina_timeout; + uint32_t no_rts_ack; + uint32_t rxe_limit; + uint32_t ack; + uint32_t cts; +} __packed; + +struct wpi_rx_general_stats { + uint32_t bad_cts; + uint32_t bad_ack; + uint32_t not_bss; + uint32_t filtered; + uint32_t bad_chan; +} __packed; + +struct wpi_rx_stats { + struct wpi_rx_phy_stats ofdm; + struct wpi_rx_phy_stats cck; + struct wpi_rx_general_stats general; +} __packed; + +struct wpi_tx_stats { + uint32_t preamble; + uint32_t rx_detected; + uint32_t bt_defer; + uint32_t bt_kill; + uint32_t short_len; + uint32_t cts_timeout; + uint32_t ack_timeout; + uint32_t exp_ack; + uint32_t ack; +} __packed; + +struct wpi_general_stats { + uint32_t temp; + uint32_t burst_check; + uint32_t burst; + uint32_t reserved[4]; + uint32_t sleep; + uint32_t slot_out; + uint32_t slot_idle; + uint32_t ttl_tstamp; + uint32_t tx_ant_a; + uint32_t tx_ant_b; + uint32_t exec; + uint32_t probe; +} __packed; + +struct wpi_stats { + uint32_t flags; + struct wpi_rx_stats rx; + struct wpi_tx_stats tx; + struct wpi_general_stats general; +} __packed; + +/* Possible flags for command WPI_CMD_GET_STATISTICS. */ +#define WPI_STATISTICS_BEACON_DISABLE (1 << 1) + + +/* Firmware error dump entry. */ +struct wpi_fw_dump { + uint32_t desc; + uint32_t time; + uint32_t blink[2]; + uint32_t ilink[2]; + uint32_t data; +} __packed; + +/* Firmware image file header. */ +struct wpi_firmware_hdr { + +#define WPI_FW_MINVERSION 2144 +#define WPI_FW_NAME "wpifw" + + uint16_t driver; + uint8_t minor; + uint8_t major; + uint32_t rtextsz; + uint32_t rdatasz; + uint32_t itextsz; + uint32_t idatasz; + uint32_t btextsz; +} __packed; + +#define WPI_FW_TEXT_MAXSZ ( 80 * 1024 ) +#define WPI_FW_DATA_MAXSZ ( 32 * 1024 ) +#define WPI_FW_BOOT_TEXT_MAXSZ 1024 + +#define WPI_FW_UPDATED (1U << 31 ) + +/* + * Offsets into EEPROM. + */ #define WPI_EEPROM_MAC 0x015 #define WPI_EEPROM_REVISION 0x035 -#define WPI_EEPROM_CAPABILITIES 0x045 +#define WPI_EEPROM_SKU_CAP 0x045 #define WPI_EEPROM_TYPE 0x04a #define WPI_EEPROM_DOMAIN 0x060 #define WPI_EEPROM_BAND1 0x063 @@ -626,49 +853,66 @@ struct wpi_stop_scan { struct wpi_eeprom_chan { uint8_t flags; -#define WPI_EEPROM_CHAN_VALID (1<<0) -#define WPI_EEPROM_CHAN_IBSS (1<<1) -#define WPI_EEPROM_CHAN_ACTIVE (1<<3) -#define WPI_EEPROM_CHAN_RADAR (1<<4) +#define WPI_EEPROM_CHAN_VALID (1 << 0) +#define WPI_EEPROM_CHAN_IBSS (1 << 1) +#define WPI_EEPROM_CHAN_ACTIVE (1 << 3) +#define WPI_EEPROM_CHAN_RADAR (1 << 4) int8_t maxpwr; } __packed; struct wpi_eeprom_sample { - uint8_t index; - int8_t power; - uint16_t volt; -}; + uint8_t index; + int8_t power; + uint16_t volt; +} __packed; #define WPI_POWER_GROUPS_COUNT 5 - struct wpi_eeprom_group { - struct wpi_eeprom_sample samples[5]; - int32_t coef[5]; - int32_t corr[5]; - int8_t maxpwr; - uint8_t chan; - int16_t temp; + struct wpi_eeprom_sample samples[5]; + int32_t coef[5]; + int32_t corr[5]; + int8_t maxpwr; + uint8_t chan; + int16_t temp; } __packed; -#define WPI_CHAN_BANDS_COUNT 5 +#define WPI_CHAN_BANDS_COUNT 5 #define WPI_MAX_CHAN_PER_BAND 14 - static const struct wpi_chan_band { - uint32_t addr; /* offset in EEPROM */ - uint8_t nchan; - uint8_t chan[WPI_MAX_CHAN_PER_BAND]; -} wpi_bands[5] = { - { WPI_EEPROM_BAND1, 14, - { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }}, - { WPI_EEPROM_BAND2, 13, - { 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16 }}, - { WPI_EEPROM_BAND3, 12, - { 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64 }}, - { WPI_EEPROM_BAND4, 11, - { 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140 }}, - { WPI_EEPROM_BAND5, 6, - { 145, 149, 153, 157, 161, 165 }} + uint32_t addr; /* offset in EEPROM */ + uint8_t nchan; + uint8_t chan[WPI_MAX_CHAN_PER_BAND]; +} wpi_bands[] = { + /* 20MHz channels, 2GHz band. */ + { WPI_EEPROM_BAND1, 14, + { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 } }, + /* 20MHz channels, 5GHz band. */ + { WPI_EEPROM_BAND2, 13, + { 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16 } }, + { WPI_EEPROM_BAND3, 12, + { 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64 } }, + { WPI_EEPROM_BAND4, 11, + { 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140 } }, + { WPI_EEPROM_BAND5, 6, + { 145, 149, 153, 157, 161, 165 } } +}; + +/* HW rate indices. */ +#define WPI_RIDX_OFDM6 0 +#define WPI_RIDX_OFDM36 5 +#define WPI_RIDX_OFDM48 6 +#define WPI_RIDX_OFDM54 7 +#define WPI_RIDX_CCK1 8 +#define WPI_RIDX_CCK2 9 +#define WPI_RIDX_CCK11 11 + +static const uint8_t wpi_ridx_to_plcp[] = { + /* OFDM: IEEE Std 802.11a-1999, pp. 14 Table 80 */ + /* R1-R4 (ral/ural is R4-R1) */ + 0xd, 0xf, 0x5, 0x7, 0x9, 0xb, 0x1, 0x3, + /* CCK: device-dependent */ + 10, 20, 55, 110 }; #define WPI_MAX_PWR_INDEX 77 @@ -678,25 +922,25 @@ static const struct wpi_chan_band { * the reference driver.) */ static const uint8_t wpi_rf_gain_2ghz[WPI_MAX_PWR_INDEX + 1] = { - 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xbb, 0xbb, 0xbb, - 0xbb, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xd3, 0xd3, 0xb3, 0xb3, 0xb3, - 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x73, 0xeb, 0xeb, 0xeb, - 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xab, 0xab, 0xab, 0x8b, - 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xc3, 0xc3, 0xc3, 0xc3, 0xa3, - 0xa3, 0xa3, 0xa3, 0x83, 0x83, 0x83, 0x83, 0x63, 0x63, 0x63, 0x63, - 0x43, 0x43, 0x43, 0x43, 0x23, 0x23, 0x23, 0x23, 0x03, 0x03, 0x03, - 0x03 + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xbb, 0xbb, 0xbb, + 0xbb, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xd3, 0xd3, 0xb3, 0xb3, 0xb3, + 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x73, 0xeb, 0xeb, 0xeb, + 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xab, 0xab, 0xab, 0x8b, + 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xc3, 0xc3, 0xc3, 0xc3, 0xa3, + 0xa3, 0xa3, 0xa3, 0x83, 0x83, 0x83, 0x83, 0x63, 0x63, 0x63, 0x63, + 0x43, 0x43, 0x43, 0x43, 0x23, 0x23, 0x23, 0x23, 0x03, 0x03, 0x03, + 0x03 }; static const uint8_t wpi_rf_gain_5ghz[WPI_MAX_PWR_INDEX + 1] = { - 0xfb, 0xfb, 0xfb, 0xdb, 0xdb, 0xbb, 0xbb, 0x9b, 0x9b, 0x7b, 0x7b, - 0x7b, 0x7b, 0x5b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x1b, 0x1b, - 0x1b, 0x73, 0x73, 0x73, 0x53, 0x53, 0x53, 0x53, 0x53, 0x33, 0x33, - 0x33, 0x33, 0x13, 0x13, 0x13, 0x13, 0x13, 0xab, 0xab, 0xab, 0x8b, - 0x8b, 0x8b, 0x8b, 0x6b, 0x6b, 0x6b, 0x6b, 0x4b, 0x4b, 0x4b, 0x4b, - 0x2b, 0x2b, 0x2b, 0x2b, 0x0b, 0x0b, 0x0b, 0x0b, 0x83, 0x83, 0x63, - 0x63, 0x63, 0x63, 0x43, 0x43, 0x43, 0x43, 0x23, 0x23, 0x23, 0x23, - 0x03 + 0xfb, 0xfb, 0xfb, 0xdb, 0xdb, 0xbb, 0xbb, 0x9b, 0x9b, 0x7b, 0x7b, + 0x7b, 0x7b, 0x5b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x1b, 0x1b, + 0x1b, 0x73, 0x73, 0x73, 0x53, 0x53, 0x53, 0x53, 0x53, 0x33, 0x33, + 0x33, 0x33, 0x13, 0x13, 0x13, 0x13, 0x13, 0xab, 0xab, 0xab, 0x8b, + 0x8b, 0x8b, 0x8b, 0x6b, 0x6b, 0x6b, 0x6b, 0x4b, 0x4b, 0x4b, 0x4b, + 0x2b, 0x2b, 0x2b, 0x2b, 0x0b, 0x0b, 0x0b, 0x0b, 0x83, 0x83, 0x63, + 0x63, 0x63, 0x63, 0x43, 0x43, 0x43, 0x43, 0x23, 0x23, 0x23, 0x23, + 0x03 }; /* @@ -704,34 +948,89 @@ static const uint8_t wpi_rf_gain_5ghz[WPI_MAX_PWR_INDEX + 1] = { * from the reference driver.) */ static const uint8_t wpi_dsp_gain_2ghz[WPI_MAX_PWR_INDEX + 1] = { - 0x7f, 0x7f, 0x7f, 0x7f, 0x7d, 0x6e, 0x69, 0x62, 0x7d, 0x73, 0x6c, - 0x63, 0x77, 0x6f, 0x69, 0x61, 0x5c, 0x6a, 0x64, 0x78, 0x71, 0x6b, - 0x7d, 0x77, 0x70, 0x6a, 0x65, 0x61, 0x5b, 0x6b, 0x79, 0x73, 0x6d, - 0x7f, 0x79, 0x73, 0x6c, 0x66, 0x60, 0x5c, 0x6e, 0x68, 0x62, 0x74, - 0x7d, 0x77, 0x71, 0x6b, 0x65, 0x60, 0x71, 0x6a, 0x66, 0x5f, 0x71, - 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, - 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, - 0x5f + 0x7f, 0x7f, 0x7f, 0x7f, 0x7d, 0x6e, 0x69, 0x62, 0x7d, 0x73, 0x6c, + 0x63, 0x77, 0x6f, 0x69, 0x61, 0x5c, 0x6a, 0x64, 0x78, 0x71, 0x6b, + 0x7d, 0x77, 0x70, 0x6a, 0x65, 0x61, 0x5b, 0x6b, 0x79, 0x73, 0x6d, + 0x7f, 0x79, 0x73, 0x6c, 0x66, 0x60, 0x5c, 0x6e, 0x68, 0x62, 0x74, + 0x7d, 0x77, 0x71, 0x6b, 0x65, 0x60, 0x71, 0x6a, 0x66, 0x5f, 0x71, + 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, + 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, + 0x5f }; static const uint8_t wpi_dsp_gain_5ghz[WPI_MAX_PWR_INDEX + 1] = { - 0x7f, 0x78, 0x72, 0x77, 0x65, 0x71, 0x66, 0x72, 0x67, 0x75, 0x6b, - 0x63, 0x5c, 0x6c, 0x7d, 0x76, 0x6d, 0x66, 0x60, 0x5a, 0x68, 0x62, - 0x5c, 0x76, 0x6f, 0x68, 0x7e, 0x79, 0x71, 0x69, 0x63, 0x76, 0x6f, - 0x68, 0x62, 0x74, 0x6d, 0x66, 0x62, 0x5d, 0x71, 0x6b, 0x63, 0x78, - 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, - 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x6b, 0x63, 0x78, - 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, - 0x78 + 0x7f, 0x78, 0x72, 0x77, 0x65, 0x71, 0x66, 0x72, 0x67, 0x75, 0x6b, + 0x63, 0x5c, 0x6c, 0x7d, 0x76, 0x6d, 0x66, 0x60, 0x5a, 0x68, 0x62, + 0x5c, 0x76, 0x6f, 0x68, 0x7e, 0x79, 0x71, 0x69, 0x63, 0x76, 0x6f, + 0x68, 0x62, 0x74, 0x6d, 0x66, 0x62, 0x5d, 0x71, 0x6b, 0x63, 0x78, + 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, + 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x6b, 0x63, 0x78, + 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, + 0x78 }; +/* + * Power saving settings (values obtained from the reference driver.) + */ +#define WPI_NDTIMRANGES 2 +#define WPI_NPOWERLEVELS 6 +static const struct wpi_pmgt { + uint32_t rxtimeout; + uint32_t txtimeout; + uint32_t intval[5]; + int skip_dtim; +} wpi_pmgt[WPI_NDTIMRANGES][WPI_NPOWERLEVELS] = { + /* DTIM <= 10 */ + { + { 0, 0, { 0, 0, 0, 0, 0 }, 0 }, /* CAM */ + { 200, 500, { 1, 2, 3, 4, 4 }, 0 }, /* PS level 1 */ + { 200, 300, { 2, 4, 6, 7, 7 }, 0 }, /* PS level 2 */ + { 50, 100, { 2, 6, 9, 9, 10 }, 0 }, /* PS level 3 */ + { 50, 25, { 2, 7, 9, 9, 10 }, 1 }, /* PS level 4 */ + { 25, 25, { 4, 7, 10, 10, 10 }, 1 } /* PS level 5 */ + }, + /* DTIM >= 11 */ + { + { 0, 0, { 0, 0, 0, 0, 0 }, 0 }, /* CAM */ + { 200, 500, { 1, 2, 3, 4, -1 }, 0 }, /* PS level 1 */ + { 200, 300, { 2, 4, 6, 7, -1 }, 0 }, /* PS level 2 */ + { 50, 100, { 2, 6, 9, 9, -1 }, 0 }, /* PS level 3 */ + { 50, 25, { 2, 7, 9, 9, -1 }, 0 }, /* PS level 4 */ + { 25, 25, { 4, 7, 10, 10, -1 }, 0 } /* PS level 5 */ + } +}; + +/* Firmware errors. */ +static const char * const wpi_fw_errmsg[] = { + "OK", + "FAIL", + "BAD_PARAM", + "BAD_CHECKSUM", + "NMI_INTERRUPT", + "SYSASSERT", + "FATAL_ERROR" +}; #define WPI_READ(sc, reg) \ - bus_space_read_4((sc)->sc_st, (sc)->sc_sh, (reg)) + bus_space_read_4((sc)->sc_st, (sc)->sc_sh, (reg)) #define WPI_WRITE(sc, reg, val) \ - bus_space_write_4((sc)->sc_st, (sc)->sc_sh, (reg), (val)) + bus_space_write_4((sc)->sc_st, (sc)->sc_sh, (reg), (val)) #define WPI_WRITE_REGION_4(sc, offset, datap, count) \ - bus_space_write_region_4((sc)->sc_st, (sc)->sc_sh, (offset), \ - (datap), (count)) + bus_space_write_region_4((sc)->sc_st, (sc)->sc_sh, (offset), \ + (datap), (count)) + +#define WPI_SETBITS(sc, reg, mask) \ + WPI_WRITE(sc, reg, WPI_READ(sc, reg) | (mask)) + +#define WPI_CLRBITS(sc, reg, mask) \ + WPI_WRITE(sc, reg, WPI_READ(sc, reg) & ~(mask)) + +#define WPI_BARRIER_WRITE(sc) \ + bus_space_barrier((sc)->sc_st, (sc)->sc_sh, 0, (sc)->sc_sz, \ + BUS_SPACE_BARRIER_WRITE) + +#define WPI_BARRIER_READ_WRITE(sc) \ + bus_space_barrier((sc)->sc_st, (sc)->sc_sh, 0, (sc)->sc_sz, \ + BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE) diff --git a/sys/dev/wpi/if_wpivar.h b/sys/dev/wpi/if_wpivar.h index e579264..7a65b72 100644 --- a/sys/dev/wpi/if_wpivar.h +++ b/sys/dev/wpi/if_wpivar.h @@ -16,8 +16,6 @@ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include <net80211/ieee80211_amrr.h> - struct wpi_rx_radiotap_header { struct ieee80211_radiotap_header wr_ihdr; uint64_t wr_tsft; @@ -28,7 +26,7 @@ struct wpi_rx_radiotap_header { int8_t wr_dbm_antsignal; int8_t wr_dbm_antnoise; uint8_t wr_antenna; -}; +} __packed; #define WPI_RX_RADIOTAP_PRESENT \ ((1 << IEEE80211_RADIOTAP_TSFT) | \ @@ -45,8 +43,7 @@ struct wpi_tx_radiotap_header { uint8_t wt_rate; uint16_t wt_chan_freq; uint16_t wt_chan_flags; - uint8_t wt_hwqueue; -}; +} __packed; #define WPI_TX_RADIOTAP_PRESENT \ ((1 << IEEE80211_RADIOTAP_FLAGS) | \ @@ -55,16 +52,15 @@ struct wpi_tx_radiotap_header { struct wpi_dma_info { bus_dma_tag_t tag; - bus_dmamap_t map; - bus_addr_t paddr; /* aligned p address */ - bus_addr_t paddr_start; /* possibly unaligned p start*/ - caddr_t vaddr; /* aligned v address */ - caddr_t vaddr_start; /* possibly unaligned v start */ + bus_dmamap_t map; + bus_addr_t paddr; + caddr_t vaddr; bus_size_t size; }; struct wpi_tx_data { bus_dmamap_t map; + bus_addr_t cmd_paddr; struct mbuf *m; struct ieee80211_node *ni; }; @@ -74,19 +70,17 @@ struct wpi_tx_ring { struct wpi_dma_info cmd_dma; struct wpi_tx_desc *desc; struct wpi_tx_cmd *cmd; - struct wpi_tx_data *data; + struct wpi_tx_data data[WPI_TX_RING_COUNT]; bus_dma_tag_t data_dmat; int qid; - int count; int queued; int cur; + int update; }; -#define WPI_RBUF_COUNT ( WPI_RX_RING_COUNT + 16 ) - struct wpi_rx_data { - bus_dmamap_t map; - struct mbuf *m; + struct mbuf *m; + bus_dmamap_t map; }; struct wpi_rx_ring { @@ -95,16 +89,14 @@ struct wpi_rx_ring { struct wpi_rx_data data[WPI_RX_RING_COUNT]; bus_dma_tag_t data_dmat; int cur; + int update; }; -struct wpi_amrr { - struct ieee80211_node ni; /* must be the first */ - int txcnt; - int retrycnt; - int success; - int success_threshold; - int recovery; +struct wpi_node { + struct ieee80211_node ni; /* must be the first */ + uint8_t id; }; +#define WPI_NODE(ni) ((struct wpi_node *)(ni)) struct wpi_power_sample { uint8_t index; @@ -119,84 +111,189 @@ struct wpi_power_group { int16_t temp; }; +struct wpi_buf { + uint8_t data[56]; /* sizeof(struct wpi_cmd_beacon) */ + struct ieee80211_node *ni; + struct mbuf *m; + size_t size; + int code; + int ac; +}; + struct wpi_vap { - struct ieee80211vap vap; + struct ieee80211vap wv_vap; + + struct wpi_buf wv_bcbuf; + struct ieee80211_beacon_offsets wv_boff; + struct mtx wv_mtx; - int (*newstate)(struct ieee80211vap *, + uint32_t wv_gtk; +#define WPI_VAP_KEY(kid) (1 << kid) + + int (*wv_newstate)(struct ieee80211vap *, enum ieee80211_state, int); + void (*wv_recv_mgmt)(struct ieee80211_node *, + struct mbuf *, int, int, int); }; #define WPI_VAP(vap) ((struct wpi_vap *)(vap)) +#define WPI_VAP_LOCK_INIT(_wvp) \ + mtx_init(&(_wvp)->wv_mtx, "lock for wv_bcbuf/wv_boff structures", \ + NULL, MTX_DEF) +#define WPI_VAP_LOCK(_wvp) mtx_lock(&(_wvp)->wv_mtx) +#define WPI_VAP_UNLOCK(_wvp) mtx_unlock(&(_wvp)->wv_mtx) +#define WPI_VAP_LOCK_ASSERT(_wvp) mtx_assert(&(_wvp)->wv_mtx, MA_OWNED) +#define WPI_VAP_LOCK_DESTROY(_wvp) mtx_destroy(&(_wvp)->wv_mtx) + +struct wpi_fw_part { + const uint8_t *text; + uint32_t textsz; + const uint8_t *data; + uint32_t datasz; +}; + +struct wpi_fw_info { + const uint8_t *data; + size_t size; + struct wpi_fw_part init; + struct wpi_fw_part main; + struct wpi_fw_part boot; +}; + struct wpi_softc { device_t sc_dev; + struct ifnet *sc_ifp; - struct mtx sc_mtx; + int sc_debug; + + int sc_flags; +#define WPI_PS_PATH (1 << 0) - /* Flags indicating the current state the driver - * expects the hardware to be in - */ - uint32_t flags; -#define WPI_FLAG_HW_RADIO_OFF (1 << 0) -#define WPI_FLAG_BUSY (1 << 1) -#define WPI_FLAG_AUTH (1 << 2) + struct mtx sc_mtx; + struct mtx tx_mtx; - /* shared area */ + /* Shared area. */ struct wpi_dma_info shared_dma; struct wpi_shared *shared; - struct wpi_tx_ring txq[WME_NUM_AC]; - struct wpi_tx_ring cmdq; + struct wpi_tx_ring txq[WPI_NTXQUEUES]; + struct mtx txq_mtx; + struct mtx txq_state_mtx; + uint32_t txq_active; + struct wpi_rx_ring rxq; + uint64_t rx_tstamp; - /* TX Thermal Callibration */ + /* TX Thermal Callibration. */ struct callout calib_to; int calib_cnt; - /* Watch dog timer */ - struct callout watchdog_to; - /* Hardware switch polling timer */ - struct callout hwswitch_to; + struct callout scan_timeout; + struct callout tx_timeout; + + /* Watch dog timer. */ + struct callout watchdog_rfkill; + + /* Firmware image. */ + struct wpi_fw_info fw; + uint32_t errptr; struct resource *irq; struct resource *mem; bus_space_tag_t sc_st; bus_space_handle_t sc_sh; void *sc_ih; + bus_size_t sc_sz; + int sc_cap_off; /* PCIe Capabilities. */ - struct wpi_config config; - int temp; + struct wpi_rxon rxon; + struct mtx rxon_mtx; + int temp; + uint32_t qfullmsk; - int sc_tx_timer; - int sc_scan_timer; + uint32_t nodesmsk; + struct mtx nt_mtx; - struct bpf_if *sc_drvbpf; + void (*sc_node_free)(struct ieee80211_node *); + void (*sc_update_rx_ring)(struct wpi_softc *); + void (*sc_update_tx_ring)(struct wpi_softc *, + struct wpi_tx_ring *); - struct wpi_rx_radiotap_header sc_rxtap; - struct wpi_tx_radiotap_header sc_txtap; + struct wpi_rx_radiotap_header sc_rxtap; + struct wpi_tx_radiotap_header sc_txtap; - /* firmware image */ + /* Firmware image. */ const struct firmware *fw_fp; - /* firmware DMA transfer */ + /* Firmware DMA transfer. */ struct wpi_dma_info fw_dma; - /* Tasks used by the driver */ - struct task sc_restarttask; /* reset firmware task */ - struct task sc_radiotask; /* reset rf task */ + /* Tasks used by the driver. */ + struct task sc_reinittask; + struct task sc_radiooff_task; + struct task sc_radioon_task; + struct task sc_start_task; - /* Eeprom info */ + /* Taskqueue */ + struct taskqueue *sc_tq; + + /* Eeprom info. */ uint8_t cap; uint16_t rev; uint8_t type; + struct wpi_eeprom_chan + eeprom_channels[WPI_CHAN_BANDS_COUNT][WPI_MAX_CHAN_PER_BAND]; struct wpi_power_group groups[WPI_POWER_GROUPS_COUNT]; int8_t maxpwr[IEEE80211_CHAN_MAX]; - char domain[4]; /*reglatory domain XXX */ + char domain[4]; /* Regulatory domain. */ }; + +/* + * Locking order: + * 1. WPI_LOCK; + * 2. WPI_RXON_LOCK; + * 3. WPI_TX_LOCK; + * 4. WPI_NT_LOCK / WPI_VAP_LOCK; + * 5. WPI_TXQ_LOCK; + * 6. WPI_TXQ_STATE_LOCK; + */ + #define WPI_LOCK_INIT(_sc) \ mtx_init(&(_sc)->sc_mtx, device_get_nameunit((_sc)->sc_dev), \ - MTX_NETWORK_LOCK, MTX_DEF) + MTX_NETWORK_LOCK, MTX_DEF) #define WPI_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) #define WPI_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) -#define WPI_LOCK_ASSERT(sc) mtx_assert(&(sc)->sc_mtx, MA_OWNED) +#define WPI_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->sc_mtx, MA_OWNED) #define WPI_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->sc_mtx) + +#define WPI_RXON_LOCK_INIT(_sc) \ + mtx_init(&(_sc)->rxon_mtx, "lock for wpi_rxon structure", NULL, MTX_DEF) +#define WPI_RXON_LOCK(_sc) mtx_lock(&(_sc)->rxon_mtx) +#define WPI_RXON_UNLOCK(_sc) mtx_unlock(&(_sc)->rxon_mtx) +#define WPI_RXON_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->rxon_mtx, MA_OWNED) +#define WPI_RXON_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->rxon_mtx) + +#define WPI_TX_LOCK_INIT(_sc) \ + mtx_init(&(_sc)->tx_mtx, "tx path lock", NULL, MTX_DEF) +#define WPI_TX_LOCK(_sc) mtx_lock(&(_sc)->tx_mtx) +#define WPI_TX_UNLOCK(_sc) mtx_unlock(&(_sc)->tx_mtx) +#define WPI_TX_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->tx_mtx) + +#define WPI_NT_LOCK_INIT(_sc) \ + mtx_init(&(_sc)->nt_mtx, "node table lock", NULL, MTX_DEF) +#define WPI_NT_LOCK(_sc) mtx_lock(&(_sc)->nt_mtx) +#define WPI_NT_UNLOCK(_sc) mtx_unlock(&(_sc)->nt_mtx) +#define WPI_NT_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->nt_mtx) + +#define WPI_TXQ_LOCK_INIT(_sc) \ + mtx_init(&(_sc)->txq_mtx, "txq/cmdq lock", NULL, MTX_DEF) +#define WPI_TXQ_LOCK(_sc) mtx_lock(&(_sc)->txq_mtx) +#define WPI_TXQ_UNLOCK(_sc) mtx_unlock(&(_sc)->txq_mtx) +#define WPI_TXQ_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->txq_mtx) + +#define WPI_TXQ_STATE_LOCK_INIT(_sc) \ + mtx_init(&(_sc)->txq_state_mtx, "txq state lock", NULL, MTX_DEF) +#define WPI_TXQ_STATE_LOCK(_sc) mtx_lock(&(_sc)->txq_state_mtx) +#define WPI_TXQ_STATE_UNLOCK(_sc) mtx_unlock(&(_sc)->txq_state_mtx) +#define WPI_TXQ_STATE_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->txq_state_mtx) diff --git a/sys/geom/bde/g_bde.h b/sys/geom/bde/g_bde.h index 9332c6b..2f29fe3 100644 --- a/sys/geom/bde/g_bde.h +++ b/sys/geom/bde/g_bde.h @@ -182,7 +182,7 @@ AES_init(cipherInstance *ci) } static __inline void -AES_makekey(keyInstance *ki, int dir, u_int len, void *key) +AES_makekey(keyInstance *ki, int dir, u_int len, const void *key) { int error; @@ -191,7 +191,7 @@ AES_makekey(keyInstance *ki, int dir, u_int len, void *key) } static __inline void -AES_encrypt(cipherInstance *ci, keyInstance *ki, void *in, void *out, u_int len) +AES_encrypt(cipherInstance *ci, keyInstance *ki, const void *in, void *out, u_int len) { int error; @@ -200,7 +200,7 @@ AES_encrypt(cipherInstance *ci, keyInstance *ki, void *in, void *out, u_int len) } static __inline void -AES_decrypt(cipherInstance *ci, keyInstance *ki, void *in, void *out, u_int len) +AES_decrypt(cipherInstance *ci, keyInstance *ki, const void *in, void *out, u_int len) { int error; diff --git a/sys/geom/eli/g_eli_crypto.c b/sys/geom/eli/g_eli_crypto.c index 9b42097..43eabf4 100644 --- a/sys/geom/eli/g_eli_crypto.c +++ b/sys/geom/eli/g_eli_crypto.c @@ -32,7 +32,6 @@ __FBSDID("$FreeBSD$"); #include <sys/systm.h> #include <sys/kernel.h> #include <sys/malloc.h> -#include <sys/uio.h> #else #include <stdint.h> #include <string.h> @@ -63,8 +62,6 @@ g_eli_crypto_cipher(u_int algo, int enc, u_char *data, size_t datasize, struct cryptoini cri; struct cryptop *crp; struct cryptodesc *crd; - struct uio *uio; - struct iovec *iov; uint64_t sid; u_char *p; int error; @@ -79,24 +76,13 @@ g_eli_crypto_cipher(u_int algo, int enc, u_char *data, size_t datasize, error = crypto_newsession(&sid, &cri, CRYPTOCAP_F_SOFTWARE); if (error != 0) return (error); - p = malloc(sizeof(*crp) + sizeof(*crd) + sizeof(*uio) + sizeof(*iov), - M_ELI, M_NOWAIT | M_ZERO); + p = malloc(sizeof(*crp) + sizeof(*crd), M_ELI, M_NOWAIT | M_ZERO); if (p == NULL) { crypto_freesession(sid); return (ENOMEM); } crp = (struct cryptop *)p; p += sizeof(*crp); crd = (struct cryptodesc *)p; p += sizeof(*crd); - uio = (struct uio *)p; p += sizeof(*uio); - iov = (struct iovec *)p; p += sizeof(*iov); - - iov->iov_len = datasize; - iov->iov_base = data; - - uio->uio_iov = iov; - uio->uio_iovcnt = 1; - uio->uio_segflg = UIO_SYSSPACE; - uio->uio_resid = datasize; crd->crd_skip = 0; crd->crd_len = datasize; @@ -114,8 +100,8 @@ g_eli_crypto_cipher(u_int algo, int enc, u_char *data, size_t datasize, crp->crp_olen = datasize; crp->crp_opaque = NULL; crp->crp_callback = g_eli_crypto_done; - crp->crp_buf = (void *)uio; - crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIFSYNC | CRYPTO_F_REL; + crp->crp_buf = (void *)data; + crp->crp_flags = CRYPTO_F_CBIFSYNC; crp->crp_desc = crd; error = crypto_dispatch(crp); diff --git a/sys/geom/eli/g_eli_integrity.c b/sys/geom/eli/g_eli_integrity.c index aeb5c2a..f7bf1fd 100644 --- a/sys/geom/eli/g_eli_integrity.c +++ b/sys/geom/eli/g_eli_integrity.c @@ -41,7 +41,6 @@ __FBSDID("$FreeBSD$"); #include <sys/proc.h> #include <sys/sched.h> #include <sys/smp.h> -#include <sys/uio.h> #include <sys/vnode.h> #include <vm/uma.h> @@ -363,8 +362,6 @@ g_eli_auth_read(struct g_eli_softc *sc, struct bio *bp) size += sizeof(struct cryptop) * nsec; size += sizeof(struct cryptodesc) * nsec * 2; size += G_ELI_AUTH_SECKEYLEN * nsec; - size += sizeof(struct uio) * nsec; - size += sizeof(struct iovec) * nsec; cbp->bio_offset = (bp->bio_offset / bp->bio_to->sectorsize) * sc->sc_bytes_per_sector; bp->bio_driver2 = malloc(size, M_ELI, M_WAITOK); cbp->bio_data = bp->bio_driver2; @@ -409,8 +406,6 @@ g_eli_auth_run(struct g_eli_worker *wr, struct bio *bp) struct g_eli_softc *sc; struct cryptop *crp; struct cryptodesc *crde, *crda; - struct uio *uio; - struct iovec *iov; u_int i, lsec, nsec, data_secsize, decr_secsize, encr_secsize; off_t dstoff; int err, error; @@ -449,8 +444,6 @@ g_eli_auth_run(struct g_eli_worker *wr, struct bio *bp) size += sizeof(*crde) * nsec; size += sizeof(*crda) * nsec; size += G_ELI_AUTH_SECKEYLEN * nsec; - size += sizeof(*uio) * nsec; - size += sizeof(*iov) * nsec; data = malloc(size, M_ELI, M_WAITOK); bp->bio_driver2 = data; p = data + encr_secsize * nsec; @@ -464,8 +457,6 @@ g_eli_auth_run(struct g_eli_worker *wr, struct bio *bp) crde = (struct cryptodesc *)p; p += sizeof(*crde); crda = (struct cryptodesc *)p; p += sizeof(*crda); authkey = (u_char *)p; p += G_ELI_AUTH_SECKEYLEN; - uio = (struct uio *)p; p += sizeof(*uio); - iov = (struct iovec *)p; p += sizeof(*iov); data_secsize = sc->sc_data_per_sector; if ((i % lsec) == 0) @@ -482,21 +473,13 @@ g_eli_auth_run(struct g_eli_worker *wr, struct bio *bp) plaindata += data_secsize; } - iov->iov_len = sc->sc_alen + data_secsize; - iov->iov_base = data; - data += encr_secsize; - - uio->uio_iov = iov; - uio->uio_iovcnt = 1; - uio->uio_segflg = UIO_SYSSPACE; - uio->uio_resid = iov->iov_len; - crp->crp_sid = wr->w_sid; - crp->crp_ilen = uio->uio_resid; + crp->crp_ilen = sc->sc_alen + data_secsize; crp->crp_olen = data_secsize; crp->crp_opaque = (void *)bp; - crp->crp_buf = (void *)uio; - crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIFSYNC | CRYPTO_F_REL; + crp->crp_buf = (void *)data; + data += encr_secsize; + crp->crp_flags = CRYPTO_F_CBIFSYNC; if (g_eli_batch) crp->crp_flags |= CRYPTO_F_BATCH; if (bp->bio_cmd == BIO_WRITE) { diff --git a/sys/geom/eli/g_eli_privacy.c b/sys/geom/eli/g_eli_privacy.c index cad3881..a60efe8 100644 --- a/sys/geom/eli/g_eli_privacy.c +++ b/sys/geom/eli/g_eli_privacy.c @@ -41,7 +41,6 @@ __FBSDID("$FreeBSD$"); #include <sys/proc.h> #include <sys/sched.h> #include <sys/smp.h> -#include <sys/uio.h> #include <sys/vnode.h> #include <vm/uma.h> @@ -230,8 +229,6 @@ g_eli_crypto_run(struct g_eli_worker *wr, struct bio *bp) struct g_eli_softc *sc; struct cryptop *crp; struct cryptodesc *crd; - struct uio *uio; - struct iovec *iov; u_int i, nsec, secsize; int err, error; off_t dstoff; @@ -254,8 +251,6 @@ g_eli_crypto_run(struct g_eli_worker *wr, struct bio *bp) */ size = sizeof(*crp) * nsec; size += sizeof(*crd) * nsec; - size += sizeof(*uio) * nsec; - size += sizeof(*iov) * nsec; /* * If we write the data we cannot destroy current bio_data content, * so we need to allocate more memory for encrypted data. @@ -280,28 +275,18 @@ g_eli_crypto_run(struct g_eli_worker *wr, struct bio *bp) for (i = 0, dstoff = bp->bio_offset; i < nsec; i++, dstoff += secsize) { crp = (struct cryptop *)p; p += sizeof(*crp); crd = (struct cryptodesc *)p; p += sizeof(*crd); - uio = (struct uio *)p; p += sizeof(*uio); - iov = (struct iovec *)p; p += sizeof(*iov); - - iov->iov_len = secsize; - iov->iov_base = data; - data += secsize; - - uio->uio_iov = iov; - uio->uio_iovcnt = 1; - uio->uio_segflg = UIO_SYSSPACE; - uio->uio_resid = secsize; crp->crp_sid = wr->w_sid; crp->crp_ilen = secsize; crp->crp_olen = secsize; crp->crp_opaque = (void *)bp; - crp->crp_buf = (void *)uio; + crp->crp_buf = (void *)data; + data += secsize; if (bp->bio_cmd == BIO_WRITE) crp->crp_callback = g_eli_crypto_write_done; else /* if (bp->bio_cmd == BIO_READ) */ crp->crp_callback = g_eli_crypto_read_done; - crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIFSYNC | CRYPTO_F_REL; + crp->crp_flags = CRYPTO_F_CBIFSYNC; if (g_eli_batch) crp->crp_flags |= CRYPTO_F_BATCH; crp->crp_desc = crd; diff --git a/sys/i386/conf/pfSense b/sys/i386/conf/pfSense new file mode 120000 index 0000000..70fe47c --- /dev/null +++ b/sys/i386/conf/pfSense @@ -0,0 +1 @@ +../../amd64/conf/pfSense
\ No newline at end of file diff --git a/sys/i386/conf/pfSense_wrap b/sys/i386/conf/pfSense_wrap new file mode 100644 index 0000000..a3d0a9d --- /dev/null +++ b/sys/i386/conf/pfSense_wrap @@ -0,0 +1,209 @@ +include GENERIC + +nooptions KDB_TRACE +options DDB # Support DDB. + +ident pfSense_wrap + +nooptions MAC # TrustedBSD MAC Framework +nooptions COMPAT_FREEBSD4 # Compatible with FreeBSD4 +nooptions COMPAT_FREEBSD5 # Compatible with FreeBSD5 +nooptions COMPAT_FREEBSD6 # Compatible with FreeBSD6 +nooptions COMPAT_FREEBSD7 # Compatible with FreeBSD7 + +options GEOM_MIRROR +options GEOM_UZIP +options GEOM_PART_MBR +options GEOM_PART_BSD +options GEOM_ELI +options GEOM_BDE + +options CPU_GEODE +options CPU_SOEKRIS +options CPU_ELAN + +options TMPFS +options UNIONFS +options NULLFS +options PPS_SYNC + +# Bus support. Do not remove isa, even if you have no isa slots +device isa + +# VGA +nodevice vga # VGA video card driver +nooptions VESA # Add support for VESA BIOS Extensions (VBE) + +nodevice splash # Splash screen and screen saver support + +# syscons is the default console driver, resembling an SCO console +nodevice sc +nooptions SC_PIXEL_MODE # add support for the raster text mode + +# vt is the new video console driver +nodevice vt +nodevice vt_vga + +# Wireless +nooptions IEEE80211_DEBUG # enable debug msgs +device wlan_rssadapt +device wlan_xauth +device wlan_acl +device iwifw +device ipwfw # Firmware for Intel PRO/Wireless 2100 IEEE 802.11 driver +device wpifw # Firmware for Intel 3945ABG Wireless LAN IEEE 802.11 driver +device iwnfw # Firmware for Intel Wireless WiFi Link 4965AGN IEEE 802.11n driver +device uath # Atheros USB IEEE 802.11a/b/g wireless network device +device ralfw # Firmware for Ralink Technology RT2500 wireless NICs. +device ural # Ralink Technology RT2500USB IEEE 802.11 driver +device urtw # Realtek RTL8187B/L USB IEEE 802.11b/g wireless network device +device rum # Ralink Technology USB IEEE 802.11a/b/g wireless network device +device mwlfw # Firmware for Marvell 88W8363 IEEE 802.11n wireless network driver +device zyd # ZyDAS ZD1211/ZD1211B USB IEEE 802.11b/g wireless network device +device upgt # Conexant/Intersil PrismGT SoftMAC USB IEEE 802.11b/g wireless +device udav # Davicom DM9601 USB Ethernet driver +device axe +device axge +device aue +device cue +device kue +device mos +device rsu +device rsufw +device run # Ralink RT2700U/RT2800U/RT3000U USB 802.11agn +device runfw +device rue +device urtwn +device urtwnfw + +# Only for 8.1+ +device siba_bwn # Broadcom BCM43xx IEEE 802.11b/g wireless network driver +device bwn # Broadcom BCM43xx IEEE 802.11b/g wireless network driver +device bwi # Broadcom BCM43xx IEEE 802.11b/g wireless network driver + +# Pseudo devices. +device pty # Pseudo-ttys (telnet etc) + +# USB support +nooptions USB_DEBUG # enable debug msgs + +# 3G devices +device ufoma +device ucom +device uslcom +device uplcom +device umct +device uvisor +device uark +device uftdi +device uvscom +device umodem +device u3g +device cdce + +device uhid # "Human Interface Devices" + +# FireWire support +device firewire # FireWire bus code +device sbp # SCSI over FireWire (Requires scbus and da) + +# pfsense addons + +device tap +device gre +device if_bridge +device lagg +device vte + +options IPFIREWALL_DEFAULT_TO_ACCEPT +options IPFIREWALL_VERBOSE + +options IPSTEALTH + +options NETGRAPH #netgraph(4) system +options NETGRAPH_VLAN +options NETGRAPH_L2TP +options NETGRAPH_BPF +options NETGRAPH_ETHER +options NETGRAPH_IFACE +options NETGRAPH_EIFACE +options NETGRAPH_PPP +options NETGRAPH_PPPOE +options NETGRAPH_PPTPGRE +options NETGRAPH_RFC1490 +options NETGRAPH_SOCKET +options NETGRAPH_TTY +options NETGRAPH_MPPC_ENCRYPTION +options NETGRAPH_UI +options NETGRAPH_VJC +options NETGRAPH_KSOCKET +options NETGRAPH_LMI +options NETGRAPH_ONE2MANY +options NETGRAPH_BRIDGE +options NETGRAPH_CISCO +options NETGRAPH_ECHO +options NETGRAPH_ASYNC +options NETGRAPH_FRAME_RELAY +options NETGRAPH_HOLE +options NETGRAPH_TEE +options NETGRAPH_TCPMSS +options NETGRAPH_PIPE +options NETGRAPH_CAR +options NETGRAPH_DEFLATE +options NETGRAPH_PRED1 + +options IPSEC +options IPSEC_NAT_T +options TCP_SIGNATURE + +# IPSEC filtering interface +device enc + +options ALTQ +options ALTQ_CBQ +options ALTQ_RED +options ALTQ_RIO +options ALTQ_HFSC +options ALTQ_PRIQ +options ALTQ_FAIRQ +options ALTQ_NOPCC +options ALTQ_CODEL + +# Squid related settings +options MSGMNB=8192 # max # of bytes in a queue +options MSGMNI=40 # number of message queue identifiers +options MSGSEG=512 # number of message segments per queue +options MSGSSZ=32 # size of a message segment +options MSGTQL=2048 # max messages in system + +device pf +device pflog +device carp +device pfsync + +device crypto # core crypto support +device cryptodev # /dev/crypto for access to h/w +device rndtest # FIPS 140-2 entropy tester +device hifn # Hifn 7951, 7781, etc. +options HIFN_DEBUG # enable debugging support: hw.hifn.debug +options HIFN_RNDTEST # enable rndtest support +device ubsec # Broadcom 5501, 5601, 58xx +device safe # safe -- SafeNet crypto accelerator +device padlock + +device speaker + +options DEVICE_POLLING + +options MROUTING + +# Additional cards +device mxge # mxge - Myricom Myri10GE 10 Gigabit Ethernet adapter driver +device cxgb # cxgb -- Chelsio T3 10 Gigabit Ethernet adapter driver +device cxgbe # cxgbe -- Chelsio T5 10 Gigabit Ethernet adapter driver +device ixgbe # http://www.nabble.com/kern-130476:-Error-in-compiling-kernel-with-device-ixgbe-td21424560.html +device nve # nVidia nForce MCP on-board Ethernet Networking +device oce + +# Default serial speed +options CONSPEED=115200 diff --git a/sys/i386/conf/pfSense_wrap_vga b/sys/i386/conf/pfSense_wrap_vga new file mode 100644 index 0000000..55adfd1 --- /dev/null +++ b/sys/i386/conf/pfSense_wrap_vga @@ -0,0 +1,195 @@ +include GENERIC + +nooptions KDB_TRACE +options DDB # Support DDB. + +ident pfSense_wrap_vga + +nooptions MAC # TrustedBSD MAC Framework +nooptions COMPAT_FREEBSD4 # Compatible with FreeBSD4 +nooptions COMPAT_FREEBSD5 # Compatible with FreeBSD5 +nooptions COMPAT_FREEBSD6 # Compatible with FreeBSD6 +nooptions COMPAT_FREEBSD7 # Compatible with FreeBSD7 + +options GEOM_MIRROR +options GEOM_UZIP +options GEOM_PART_MBR +options GEOM_PART_BSD +options GEOM_ELI +options GEOM_BDE + +options CPU_GEODE +options CPU_SOEKRIS +options CPU_ELAN + +options TMPFS +options UNIONFS +options NULLFS +options PPS_SYNC + +# Bus support. Do not remove isa, even if you have no isa slots +device isa + +# Wireless +nooptions IEEE80211_DEBUG # enable debug msgs +device wlan_rssadapt +device wlan_xauth +device wlan_acl +device iwifw +device ipwfw # Firmware for Intel PRO/Wireless 2100 IEEE 802.11 driver +device wpifw # Firmware for Intel 3945ABG Wireless LAN IEEE 802.11 driver +device iwnfw # Firmware for Intel Wireless WiFi Link 4965AGN IEEE 802.11n driver +device uath # Atheros USB IEEE 802.11a/b/g wireless network device +device ralfw # Firmware for Ralink Technology RT2500 wireless NICs. +device ural # Ralink Technology RT2500USB IEEE 802.11 driver +device urtw # Realtek RTL8187B/L USB IEEE 802.11b/g wireless network device +device rum # Ralink Technology USB IEEE 802.11a/b/g wireless network device +device mwlfw # Firmware for Marvell 88W8363 IEEE 802.11n wireless network driver +device zyd # ZyDAS ZD1211/ZD1211B USB IEEE 802.11b/g wireless network device +device upgt # Conexant/Intersil PrismGT SoftMAC USB IEEE 802.11b/g wireless +device udav # Davicom DM9601 USB Ethernet driver +device axe +device axge +device aue +device cue +device kue +device mos +device rsu +device rsufw +device run # Ralink RT2700U/RT2800U/RT3000U USB 802.11agn +device runfw +device rue +device urtwn +device urtwnfw + +# Only for 8.1+ +device siba_bwn # Broadcom BCM43xx IEEE 802.11b/g wireless network driver +device bwn # Broadcom BCM43xx IEEE 802.11b/g wireless network driver +device bwi # Broadcom BCM43xx IEEE 802.11b/g wireless network driver + +# Pseudo devices. +device pty # Pseudo-ttys (telnet etc) + +# USB support +nooptions USB_DEBUG # enable debug msgs + +# 3G devices +device ufoma +device ucom +device uslcom +device uplcom +device umct +device uvisor +device uark +device uftdi +device uvscom +device umodem +device u3g +device cdce + +device uhid # "Human Interface Devices" + +# FireWire support +device firewire # FireWire bus code +device sbp # SCSI over FireWire (Requires scbus and da) + +# pfsense addons + +device tap +device gre +device if_bridge +device lagg +device vte + +options IPFIREWALL_DEFAULT_TO_ACCEPT +options IPFIREWALL_VERBOSE + +options IPSTEALTH + +options NETGRAPH #netgraph(4) system +options NETGRAPH_VLAN +options NETGRAPH_L2TP +options NETGRAPH_BPF +options NETGRAPH_ETHER +options NETGRAPH_IFACE +options NETGRAPH_EIFACE +options NETGRAPH_PPP +options NETGRAPH_PPPOE +options NETGRAPH_PPTPGRE +options NETGRAPH_RFC1490 +options NETGRAPH_SOCKET +options NETGRAPH_TTY +options NETGRAPH_MPPC_ENCRYPTION +options NETGRAPH_UI +options NETGRAPH_VJC +options NETGRAPH_KSOCKET +options NETGRAPH_LMI +options NETGRAPH_ONE2MANY +options NETGRAPH_BRIDGE +options NETGRAPH_CISCO +options NETGRAPH_ECHO +options NETGRAPH_ASYNC +options NETGRAPH_FRAME_RELAY +options NETGRAPH_HOLE +options NETGRAPH_TEE +options NETGRAPH_TCPMSS +options NETGRAPH_PIPE +options NETGRAPH_CAR +options NETGRAPH_DEFLATE +options NETGRAPH_PRED1 + +options IPSEC +options IPSEC_NAT_T +options TCP_SIGNATURE + +# IPSEC filtering interface +device enc + +options ALTQ +options ALTQ_CBQ +options ALTQ_RED +options ALTQ_RIO +options ALTQ_HFSC +options ALTQ_PRIQ +options ALTQ_FAIRQ +options ALTQ_NOPCC +options ALTQ_CODEL + +# Squid related settings +options MSGMNB=8192 # max # of bytes in a queue +options MSGMNI=40 # number of message queue identifiers +options MSGSEG=512 # number of message segments per queue +options MSGSSZ=32 # size of a message segment +options MSGTQL=2048 # max messages in system + +device pf +device pflog +device carp +device pfsync + +device crypto # core crypto support +device cryptodev # /dev/crypto for access to h/w +device rndtest # FIPS 140-2 entropy tester +device hifn # Hifn 7951, 7781, etc. +options HIFN_DEBUG # enable debugging support: hw.hifn.debug +options HIFN_RNDTEST # enable rndtest support +device ubsec # Broadcom 5501, 5601, 58xx +device safe # safe -- SafeNet crypto accelerator +device padlock + +device speaker + +options DEVICE_POLLING + +options MROUTING + +# Additional cards +device mxge # mxge - Myricom Myri10GE 10 Gigabit Ethernet adapter driver +device cxgb # cxgb -- Chelsio T3 10 Gigabit Ethernet adapter driver +device cxgbe # cxgbe -- Chelsio T5 10 Gigabit Ethernet adapter driver +device ixgbe # http://www.nabble.com/kern-130476:-Error-in-compiling-kernel-with-device-ixgbe-td21424560.html +device nve # nVidia nForce MCP on-board Ethernet Networking +device oce + +# Default serial speed +options CONSPEED=115200 diff --git a/sys/libkern/explicit_bzero.c b/sys/libkern/explicit_bzero.c new file mode 100644 index 0000000..2468c55 --- /dev/null +++ b/sys/libkern/explicit_bzero.c @@ -0,0 +1,24 @@ +/* $OpenBSD: explicit_bzero.c,v 1.3 2014/06/21 02:34:26 matthew Exp $ */ +/* + * Public domain. + * Written by Matthew Dempsky. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/libkern.h> + +__attribute__((weak)) void __explicit_bzero_hook(void *, size_t); + +__attribute__((weak)) void +__explicit_bzero_hook(void *buf, size_t len) +{ +} + +void +explicit_bzero(void *buf, size_t len) +{ + memset(buf, 0, len); + __explicit_bzero_hook(buf, len); +} diff --git a/sys/libkern/timingsafe_bcmp.c b/sys/libkern/timingsafe_bcmp.c new file mode 100644 index 0000000..ebada62 --- /dev/null +++ b/sys/libkern/timingsafe_bcmp.c @@ -0,0 +1,32 @@ +/* $OpenBSD: timingsafe_bcmp.c,v 1.2 2014/06/10 04:16:57 deraadt Exp $ */ +/* + * Copyright (c) 2010 Damien Miller. All rights reserved. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $FreeBSD$ + * + */ + +#include <sys/libkern.h> + +int +timingsafe_bcmp(const void *b1, const void *b2, size_t n) +{ + const unsigned char *p1 = b1, *p2 = b2; + int ret = 0; + + for (; n > 0; n--) + ret |= *p1++ ^ *p2++; + return (ret != 0); +} diff --git a/sys/mips/rmi/dev/sec/rmisec.c b/sys/mips/rmi/dev/sec/rmisec.c index 6501f75..31098bc 100644 --- a/sys/mips/rmi/dev/sec/rmisec.c +++ b/sys/mips/rmi/dev/sec/rmisec.c @@ -423,13 +423,8 @@ xlr_sec_process(device_t dev, struct cryptop *crp, int hint) cmd->op.source_buf = (uint64_t) (unsigned long)crp->crp_buf; cmd->op.source_buf_size = crp->crp_ilen; - if (crp->crp_flags & CRYPTO_F_REL) { - cmd->op.dest_buf = (uint64_t) (unsigned long)crp->crp_buf; - cmd->op.dest_buf_size = crp->crp_ilen; - } else { - cmd->op.dest_buf = (uint64_t) (unsigned long)crp->crp_buf; - cmd->op.dest_buf_size = crp->crp_ilen; - } + cmd->op.dest_buf = (uint64_t) (unsigned long)crp->crp_buf; + cmd->op.dest_buf_size = crp->crp_ilen; cmd->op.num_packets = 1; cmd->op.num_fragments = 1; diff --git a/sys/modules/aesni/Makefile b/sys/modules/aesni/Makefile index 26dbedc..6fdfc7e 100644 --- a/sys/modules/aesni/Makefile +++ b/sys/modules/aesni/Makefile @@ -7,13 +7,18 @@ SRCS= aesni.c SRCS+= aeskeys_${MACHINE_CPUARCH}.S SRCS+= device_if.h bus_if.h opt_bus.h cryptodev_if.h -OBJS+= aesni_wrap.o +OBJS+= aesni_ghash.o aesni_wrap.o # Remove -nostdinc so we can get the intrinsics. +aesni_ghash.o: aesni_ghash.c + # XXX - gcc won't understand -mpclmul + ${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} \ + -mmmx -msse -msse4 -maes -mpclmul ${.IMPSRC} + ${CTFCONVERT_CMD} + aesni_wrap.o: aesni_wrap.c ${CC} -c ${CFLAGS:C/^-O2$/-O3/:N-nostdinc} ${WERROR} ${PROF} \ - -mmmx -msse -maes ${.IMPSRC} + -mmmx -msse -msse4 -maes ${.IMPSRC} ${CTFCONVERT_CMD} .include <bsd.kmod.mk> - diff --git a/sys/modules/crypto/Makefile b/sys/modules/crypto/Makefile index 6a37c10..9153445 100644 --- a/sys/modules/crypto/Makefile +++ b/sys/modules/crypto/Makefile @@ -3,19 +3,23 @@ .PATH: ${.CURDIR}/../../opencrypto .PATH: ${.CURDIR}/../../crypto .PATH: ${.CURDIR}/../../crypto/blowfish +.PATH: ${.CURDIR}/../../crypto/camellia .PATH: ${.CURDIR}/../../crypto/des .PATH: ${.CURDIR}/../../crypto/rijndael .PATH: ${.CURDIR}/../../crypto/sha2 -.PATH: ${.CURDIR}/../../crypto/camellia +.PATH: ${.CURDIR}/../../crypto/siphash KMOD = crypto SRCS = crypto.c cryptodev_if.c SRCS += criov.c cryptosoft.c xform.c SRCS += cast.c cryptodeflate.c rmd160.c rijndael-alg-fst.c rijndael-api.c SRCS += skipjack.c bf_enc.c bf_ecb.c bf_skey.c +SRCS += camellia.c camellia-api.c SRCS += des_ecb.c des_enc.c des_setkey.c -SRCS += sha1.c sha2.c +SRCS += sha1.c sha2.c sha256c.c +SRCS += siphash.c +SRCS += gmac.c gfmult.c SRCS += opt_param.h cryptodev_if.h bus_if.h device_if.h -SRCS += opt_ddb.h opt_kdtrace.h -SRCS += camellia.c camellia-api.c +SRCS += opt_ddb.h + .include <bsd.kmod.mk> diff --git a/sys/modules/geom/geom_bde/Makefile b/sys/modules/geom/geom_bde/Makefile index 089126e..5c5a590 100644 --- a/sys/modules/geom/geom_bde/Makefile +++ b/sys/modules/geom/geom_bde/Makefile @@ -6,6 +6,6 @@ KMOD= geom_bde SRCS= g_bde.c g_bde_crypt.c g_bde_lock.c g_bde_work.c -SRCS+= rijndael-alg-fst.c rijndael-api-fst.c sha2.c +SRCS+= rijndael-alg-fst.c rijndael-api-fst.c sha2.c sha256c.c .include <bsd.kmod.mk> diff --git a/sys/modules/gpioapu/Makefile b/sys/modules/gpioapu/Makefile new file mode 100644 index 0000000..80fdd2c --- /dev/null +++ b/sys/modules/gpioapu/Makefile @@ -0,0 +1,7 @@ + +.PATH: ${.CURDIR}/../../dev/gpioapu +KMOD = gpioapu +SRCS = gpioapu.c +SRCS += device_if.h bus_if.h pci_if.h isa_if.h + +.include <bsd.kmod.mk> diff --git a/sys/modules/iwnfw/Makefile b/sys/modules/iwnfw/Makefile index 9075edb..9f8009c 100644 --- a/sys/modules/iwnfw/Makefile +++ b/sys/modules/iwnfw/Makefile @@ -1,5 +1,17 @@ # $FreeBSD$ -SUBDIR= iwn1000 iwn4965 iwn5000 iwn5150 iwn6000 iwn6000g2a iwn6000g2b iwn6050 iwn2030 +SUBDIR= iwn100 \ + iwn105 \ + iwn135 \ + iwn1000 \ + iwn2000 \ + iwn2030 \ + iwn4965 \ + iwn5000 \ + iwn5150 \ + iwn6000 \ + iwn6000g2a \ + iwn6000g2b \ + iwn6050 .include <bsd.subdir.mk> diff --git a/sys/modules/iwnfw/iwn100/Makefile b/sys/modules/iwnfw/iwn100/Makefile new file mode 100644 index 0000000..c72533f --- /dev/null +++ b/sys/modules/iwnfw/iwn100/Makefile @@ -0,0 +1,6 @@ +# $FreeBSD$ + +KMOD= iwn100fw +IMG= iwlwifi-100-39.31.5.1 + +.include <bsd.kmod.mk> diff --git a/sys/modules/iwnfw/iwn105/Makefile b/sys/modules/iwnfw/iwn105/Makefile new file mode 100644 index 0000000..f1f3d8d --- /dev/null +++ b/sys/modules/iwnfw/iwn105/Makefile @@ -0,0 +1,6 @@ +# $FreeBSD$ + +KMOD= iwn105fw +IMG= iwlwifi-105-6-18.168.6.1 + +.include <bsd.kmod.mk> diff --git a/sys/modules/iwnfw/iwn135/Makefile b/sys/modules/iwnfw/iwn135/Makefile new file mode 100644 index 0000000..fd21ac4 --- /dev/null +++ b/sys/modules/iwnfw/iwn135/Makefile @@ -0,0 +1,6 @@ +# $FreeBSD$ + +KMOD= iwn135fw +IMG= iwlwifi-135-6-18.168.6.1 + +.include <bsd.kmod.mk> diff --git a/sys/modules/iwnfw/iwn6000g2b/Makefile b/sys/modules/iwnfw/iwn6000g2b/Makefile index 71a2607..ce76755 100644 --- a/sys/modules/iwnfw/iwn6000g2b/Makefile +++ b/sys/modules/iwnfw/iwn6000g2b/Makefile @@ -1,6 +1,6 @@ # $FreeBSD$ KMOD= iwn6000g2bfw -IMG= iwlwifi-6000g2b-17.168.5.2 +IMG= iwlwifi-6000g2b-18.168.6.1 .include <bsd.kmod.mk> diff --git a/sys/modules/random/Makefile b/sys/modules/random/Makefile index 332515d..6bf47f2 100644 --- a/sys/modules/random/Makefile +++ b/sys/modules/random/Makefile @@ -12,7 +12,7 @@ SRCS+= ivy.c .endif SRCS+= randomdev_soft.c yarrow.c hash.c SRCS+= random_harvestq.c live_entropy_sources.c rwfile.c -SRCS+= rijndael-alg-fst.c rijndael-api-fst.c sha2.c +SRCS+= rijndael-alg-fst.c rijndael-api-fst.c sha2.c sha256c.c SRCS+= bus_if.h device_if.h vnode_if.h opt_cpu.h opt_random.h CFLAGS+= -I${.CURDIR}/../.. diff --git a/sys/modules/wpi/Makefile b/sys/modules/wpi/Makefile index 1e2383f..2e0da73 100644 --- a/sys/modules/wpi/Makefile +++ b/sys/modules/wpi/Makefile @@ -3,6 +3,6 @@ .PATH: ${.CURDIR}/../../dev/wpi KMOD = if_wpi -SRCS = if_wpi.c device_if.h bus_if.h pci_if.h opt_wlan.h +SRCS = if_wpi.c device_if.h bus_if.h pci_if.h opt_wpi.h opt_wlan.h .include <bsd.kmod.mk> diff --git a/sys/modules/zfs/Makefile b/sys/modules/zfs/Makefile index d2da46b..53e8d34 100644 --- a/sys/modules/zfs/Makefile +++ b/sys/modules/zfs/Makefile @@ -72,7 +72,7 @@ SRCS+= zmod_subr.c SRCS+= zutil.c .PATH: ${.CURDIR}/../../crypto/sha2 -SRCS+= sha2.c +SRCS+= sha2.c sha256c.c .PATH: ${SUNW}/common/zfs .include "${SUNW}/uts/common/Makefile.files" diff --git a/sys/net/if.h b/sys/net/if.h index 04bd1f1..ec6287d 100644 --- a/sys/net/if.h +++ b/sys/net/if.h @@ -245,7 +245,7 @@ struct if_data { #define IFCAP_CANTCHANGE (IFCAP_NETMAP) -#define IFQ_MAXLEN 50 +#define IFQ_MAXLEN 128 #define IFNET_SLOWHZ 1 /* granularity is 1 second */ /* @@ -392,6 +392,7 @@ struct ifreq { caddr_t ifru_data; int ifru_cap[2]; u_int ifru_fib; + u_char ifru_vlan_pcp; } ifr_ifru; #define ifr_addr ifr_ifru.ifru_addr /* address */ #define ifr_dstaddr ifr_ifru.ifru_dstaddr /* other end of p-to-p link */ @@ -409,6 +410,7 @@ struct ifreq { #define ifr_curcap ifr_ifru.ifru_cap[1] /* current capabilities */ #define ifr_index ifr_ifru.ifru_index /* interface index */ #define ifr_fib ifr_ifru.ifru_fib /* interface fib */ +#define ifr_vlan_pcp ifr_ifru.ifru_vlan_pcp /* VLAN priority */ }; #define _SIZEOF_ADDR_IFREQ(ifr) \ diff --git a/sys/net/if_bridge.c b/sys/net/if_bridge.c index f7c6365..14d9967 100644 --- a/sys/net/if_bridge.c +++ b/sys/net/if_bridge.c @@ -243,6 +243,7 @@ static void bridge_ifdetach(void *arg __unused, struct ifnet *); static void bridge_init(void *); static void bridge_dummynet(struct mbuf *, struct ifnet *); static void bridge_stop(struct ifnet *, int); +static void bridge_start(struct ifnet *); static int bridge_transmit(struct ifnet *, struct mbuf *); static void bridge_qflush(struct ifnet *); static struct mbuf *bridge_input(struct ifnet *, struct mbuf *); @@ -607,10 +608,13 @@ bridge_clone_create(struct if_clone *ifc, int unit, caddr_t params) if_initname(ifp, bridge_name, unit); ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; ifp->if_ioctl = bridge_ioctl; + ifp->if_start = bridge_start; ifp->if_transmit = bridge_transmit; ifp->if_qflush = bridge_qflush; ifp->if_init = bridge_init; ifp->if_type = IFT_BRIDGE; + IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); + IFQ_SET_READY(&ifp->if_snd); /* * Generate an ethernet address with a locally administered address. @@ -815,6 +819,8 @@ bridge_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) } BRIDGE_LOCK(sc); LIST_FOREACH(bif, &sc->sc_iflist, bif_next) { + if (bif->bif_ifp->if_type == IFT_GIF) + continue; if (bif->bif_ifp->if_mtu != ifr->ifr_mtu) { log(LOG_NOTICE, "%s: invalid MTU: %lu(%s)" " != %d\n", sc->sc_ifp->if_xname, @@ -1106,6 +1112,7 @@ bridge_ioctl_add(struct bridge_softc *sc, void *arg) } #endif /* Allow the first Ethernet member to define the MTU */ + if (ifs->if_type != IFT_GIF) { if (LIST_EMPTY(&sc->sc_iflist)) sc->sc_ifp->if_mtu = ifs->if_mtu; else if (sc->sc_ifp->if_mtu != ifs->if_mtu) { @@ -1113,6 +1120,7 @@ bridge_ioctl_add(struct bridge_softc *sc, void *arg) ifs->if_mtu, ifs->if_xname, sc->sc_ifp->if_mtu); return (EINVAL); } + } bif = malloc(sizeof(*bif), M_DEVBUF, M_NOWAIT|M_ZERO); if (bif == NULL) @@ -2071,6 +2079,47 @@ bridge_qflush(struct ifnet *ifp __unused) } /* + * bridge_start: + * + * Start output on a bridge. + * + */ +static void +bridge_start(struct ifnet *ifp) +{ + struct bridge_softc *sc; + struct mbuf *m; + struct ether_header *eh; + struct ifnet *dst_if; + + sc = ifp->if_softc; + + ifp->if_drv_flags |= IFF_DRV_OACTIVE; + for (;;) { + IFQ_DEQUEUE(&ifp->if_snd, m); + if (m == 0) + break; + ETHER_BPF_MTAP(ifp, m); + + eh = mtod(m, struct ether_header *); + dst_if = NULL; + + BRIDGE_LOCK(sc); + if ((m->m_flags & (M_BCAST|M_MCAST)) == 0) { + dst_if = bridge_rtlookup(sc, eh->ether_dhost, 1); + } + + if (dst_if == NULL) + bridge_broadcast(sc, ifp, m, 0); + else { + BRIDGE_UNLOCK(sc); + bridge_enqueue(sc, dst_if, m); + } + } + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; +} + +/* * bridge_forward: * * The forwarding function of the bridge. diff --git a/sys/net/if_ethersubr.c b/sys/net/if_ethersubr.c index 90ebb56..773918f 100644 --- a/sys/net/if_ethersubr.c +++ b/sys/net/if_ethersubr.c @@ -108,6 +108,8 @@ CTASSERT(sizeof (struct ether_addr) == ETHER_ADDR_LEN); VNET_DEFINE(struct pfil_head, link_pfil_hook); /* Packet filter hooks */ +SYSCTL_DECL(_net_link); + /* netgraph node hooks for ng_ether(4) */ void (*ng_ether_input_p)(struct ifnet *ifp, struct mbuf **mp); void (*ng_ether_input_orphan_p)(struct ifnet *ifp, struct mbuf *m); @@ -610,7 +612,7 @@ ether_input_internal(struct ifnet *ifp, struct mbuf *m) return; } eh = mtod(m, struct ether_header *); - } + } else { #if defined(INET) || defined(INET6) /* @@ -639,6 +641,7 @@ ether_input_internal(struct ifnet *ifp, struct mbuf *m) bcmp(IF_LLADDR(ifp), eh->ether_dhost, ETHER_ADDR_LEN) != 0) m->m_flags |= M_PROMISC; } + } if (harvest.ethernet) random_harvest(&(m->m_data), 12, 2, RANDOM_NET_ETHER); @@ -685,6 +688,9 @@ vnet_ether_init(__unused void *arg) if ((i = pfil_head_register(&V_link_pfil_hook)) != 0) printf("%s: WARNING: unable to register pfil link hook, " "error %d\n", __func__, i); + else + pfil_head_export_sysctl(&V_link_pfil_hook, + SYSCTL_STATIC_CHILDREN(_net_link)); } VNET_SYSINIT(vnet_ether_init, SI_SUB_PROTO_IF, SI_ORDER_ANY, vnet_ether_init, NULL); @@ -737,7 +743,11 @@ ether_demux(struct ifnet *ifp, struct mbuf *m) if (i != 0 || m == NULL) return; - } + + /* M_PROTO2 is for M_IP[6]_NEXTHOP */ + i = m->m_flags & (M_FASTFWD_OURS|M_PROTO2); + } else + i = 0; eh = mtod(m, struct ether_header *); ether_type = ntohs(eh->ether_type); @@ -776,6 +786,8 @@ ether_demux(struct ifnet *ifp, struct mbuf *m) */ m->m_flags &= ~M_VLANTAG; m_clrprotoflags(m); + if (i) + m->m_flags |= M_FASTFWD_OURS|M_PROTO2; m_adj(m, ETHER_HDR_LEN); /* @@ -970,7 +982,6 @@ ether_reassign(struct ifnet *ifp, struct vnet *new_vnet, char *unused __unused) } #endif -SYSCTL_DECL(_net_link); SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW, 0, "Ethernet"); #if 0 diff --git a/sys/net/if_lagg.c b/sys/net/if_lagg.c index ddb9d64..9449df0 100644 --- a/sys/net/if_lagg.c +++ b/sys/net/if_lagg.c @@ -125,6 +125,7 @@ static int lagg_setflag(struct lagg_port *, int, int, int (*func)(struct ifnet *, int)); static int lagg_setflags(struct lagg_port *, int status); static int lagg_transmit(struct ifnet *, struct mbuf *); +static void lagg_start(struct ifnet *); static void lagg_qflush(struct ifnet *); static int lagg_media_change(struct ifnet *); static void lagg_media_status(struct ifnet *, struct ifmediareq *); @@ -358,11 +359,14 @@ lagg_clone_create(struct if_clone *ifc, int unit, caddr_t params) if_initname(ifp, laggname, unit); ifp->if_softc = sc; ifp->if_transmit = lagg_transmit; + ifp->if_start = lagg_start; ifp->if_qflush = lagg_qflush; ifp->if_init = lagg_init; ifp->if_ioctl = lagg_ioctl; ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST; ifp->if_capenable = ifp->if_capabilities = IFCAP_HWSTATS; + IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); + IFQ_SET_READY(&ifp->if_snd); /* * Attach as an ordinary ethernet device, children will be attached @@ -1493,6 +1497,40 @@ lagg_transmit(struct ifnet *ifp, struct mbuf *m) return (error); } +static void +lagg_start(struct ifnet *ifp) +{ + struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc; + struct rm_priotracker tracker; + struct mbuf *m; + int error = 0, len; + + LAGG_RLOCK(sc, &tracker); + /* We need a Tx algorithm and at least one port */ + if (sc->sc_proto == LAGG_PROTO_NONE || sc->sc_count == 0) { + IF_DRAIN(&ifp->if_snd); + LAGG_RUNLOCK(sc, &tracker); + return; + } + + for (;; error = 0) { + IFQ_DEQUEUE(&ifp->if_snd, m); + if (m == NULL) + break; + + ETHER_BPF_MTAP(ifp, m); + + len = m->m_pkthdr.len; + error = (*sc->sc_start)(sc, m); + if (error == 0) { + counter_u64_add(sc->sc_opackets, 1); + counter_u64_add(sc->sc_obytes, len); + } else + ifp->if_oerrors++; + } + LAGG_RUNLOCK(sc, &tracker); +} + /* * The ifp->if_qflush entry point for lagg(4) is no-op. */ diff --git a/sys/net/if_pflog.h b/sys/net/if_pflog.h index 0faeb7d..326b551 100644 --- a/sys/net/if_pflog.h +++ b/sys/net/if_pflog.h @@ -40,10 +40,14 @@ struct pfloghdr { char ruleset[PFLOG_RULESET_NAME_SIZE]; u_int32_t rulenr; u_int32_t subrulenr; +#ifdef PF_USER_INFO uid_t uid; pid_t pid; uid_t rule_uid; pid_t rule_pid; +#else + u_int32_t ridentifier; +#endif u_int8_t dir; u_int8_t pad[3]; }; diff --git a/sys/net/if_pfsync.h b/sys/net/if_pfsync.h index 7a72bbb..ef8ba1f 100644 --- a/sys/net/if_pfsync.h +++ b/sys/net/if_pfsync.h @@ -241,6 +241,9 @@ struct pfsyncreq { char pfsyncr_syncdev[IFNAMSIZ]; struct in_addr pfsyncr_syncpeer; int pfsyncr_maxupdates; +#define PFSYNCF_OK 0x00000001 +#define PFSYNCF_DEFER 0x00000002 +#define PFSYNCF_PUSH 0x00000004 int pfsyncr_defer; }; diff --git a/sys/net/if_stf.c b/sys/net/if_stf.c index 15d7d64..9d923ad 100644 --- a/sys/net/if_stf.c +++ b/sys/net/if_stf.c @@ -3,6 +3,8 @@ /*- * Copyright (C) 2000 WIDE Project. + * Copyright (c) 2010 Hiroki Sato <hrs@FreeBSD.org> + * Copyright (c) 2013 Ermal Luçi <eri@FreeBSD.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -31,7 +33,7 @@ */ /* - * 6to4 interface, based on RFC3056. + * 6to4 interface, based on RFC3056 + 6rd (RFC5569) support. * * 6to4 interface is NOT capable of link-layer (I mean, IPv4) multicasting. * There is no address mapping defined from IPv6 multicast address to IPv4 @@ -60,7 +62,7 @@ * ICMPv6: * - Redirects cannot be used due to the lack of link-local address. * - * stf interface does not have, and will not need, a link-local address. + * stf interface does not have, and will not need, a link-local address. * It seems to have no real benefit and does not help the above symptoms much. * Even if we assign link-locals to interface, we cannot really * use link-local unicast/multicast on top of 6to4 cloud (since there's no @@ -72,6 +74,12 @@ * http://playground.iijlab.net/i-d/draft-itojun-ipv6-transition-abuse-00.txt * for details. The code tries to filter out some of malicious packets. * Note that there is no way to be 100% secure. + * + * 6rd (RFC5569 & RFC5969) extension is enabled when an IPv6 GUA other than + * 2002::/16 is assigned. The stf(4) recognizes a 32-bit just after + * prefixlen as the IPv4 address of the 6rd customer site. The + * prefixlen must be shorter than 32. + * */ #include "opt_inet.h" @@ -92,13 +100,14 @@ #include <machine/cpu.h> #include <sys/malloc.h> +#include <sys/priv.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_clone.h> #include <net/route.h> #include <net/netisr.h> #include <net/if_types.h> -#include <net/if_stf.h> #include <net/vnet.h> #include <netinet/in.h> @@ -106,6 +115,7 @@ #include <netinet/ip.h> #include <netinet/ip_var.h> #include <netinet/in_var.h> +#include <net/if_stf.h> #include <netinet/ip6.h> #include <netinet6/ip6_var.h> @@ -120,20 +130,48 @@ #include <security/mac/mac_framework.h> +#define STF_DEBUG 1 +#if STF_DEBUG > 3 +#define ip_sprintf(buf, a) \ + sprintf(buf, "%u.%u.%u.%u", \ + (ntohl((a)->s_addr)>>24)&0xFF, \ + (ntohl((a)->s_addr)>>16)&0xFF, \ + (ntohl((a)->s_addr)>>8)&0xFF, \ + (ntohl((a)->s_addr))&0xFF); +#endif + +#if STF_DEBUG +#define DEBUG_PRINTF(a, ...) \ + do { \ + if (V_stf_debug >= a) \ + printf(__VA_ARGS__); \ + } while (0) +#else +#define DEBUG_PRINTF(a, ...) +#endif + SYSCTL_DECL(_net_link); static SYSCTL_NODE(_net_link, IFT_STF, stf, CTLFLAG_RW, 0, "6to4 Interface"); -static int stf_route_cache = 1; -SYSCTL_INT(_net_link_stf, OID_AUTO, route_cache, CTLFLAG_RW, - &stf_route_cache, 0, "Caching of IPv4 routes for 6to4 Output"); +static VNET_DEFINE(int, stf_route_cache) = 0; +#define V_stf_route_cache VNET(stf_route_cache) +SYSCTL_VNET_INT(_net_link_stf, OID_AUTO, route_cache, CTLFLAG_RW, + &VNET_NAME(stf_route_cache), 0, + "Enable caching of IPv4 routes for 6to4 output."); + +#if STF_DEBUG +static VNET_DEFINE(int, stf_debug) = 0; +#define V_stf_debug VNET(stf_debug) +SYSCTL_VNET_INT(_net_link_stf, OID_AUTO, stf_debug, CTLFLAG_RW, + &VNET_NAME(stf_debug), 0, + "Enable displaying verbose debug message of stf interfaces"); +#endif -static int stf_permit_rfc1918 = 0; +static int stf_permit_rfc1918 = 1; TUNABLE_INT("net.link.stf.permit_rfc1918", &stf_permit_rfc1918); SYSCTL_INT(_net_link_stf, OID_AUTO, permit_rfc1918, CTLFLAG_RW | CTLFLAG_TUN, &stf_permit_rfc1918, 0, "Permit the use of private IPv4 addresses"); -#define STFUNIT 0 - #define IN6_IS_ADDR_6TO4(x) (ntohs((x)->s6_addr16[0]) == 0x2002) /* @@ -144,24 +182,37 @@ SYSCTL_INT(_net_link_stf, OID_AUTO, permit_rfc1918, CTLFLAG_RW | CTLFLAG_TUN, struct stf_softc { struct ifnet *sc_ifp; + in_addr_t dstv4_addr; + in_addr_t srcv4_addr; + in_addr_t inaddr; + u_int v4prefixlen; union { struct route __sc_ro4; struct route_in6 __sc_ro6; /* just for safety */ } __sc_ro46; #define sc_ro __sc_ro46.__sc_ro4 - struct mtx sc_ro_mtx; + struct mtx sc_mtx; u_int sc_fibnum; const struct encaptab *encap_cookie; + u_int sc_flags; + LIST_ENTRY(stf_softc) stf_list; }; #define STF2IFP(sc) ((sc)->sc_ifp) static const char stfname[] = "stf"; -/* - * Note that mutable fields in the softc are not currently locked. - * We do lock sc_ro in stf_output though. - */ +static struct mtx stf_mtx; static MALLOC_DEFINE(M_STF, stfname, "6to4 Tunnel Interface"); +static VNET_DEFINE(LIST_HEAD(, stf_softc), stf_softc_list); +#define V_stf_softc_list VNET(stf_softc_list) + +#define STF_LOCK_INIT(sc) mtx_init(&(sc)->sc_mtx, "stf softc", \ + NULL, MTX_DEF); +#define STF_LOCK_DESTROY(sc) mtx_destroy(&(sc)->sc_mtx) +#define STF_LOCK(sc) mtx_lock(&(sc)->sc_mtx) +#define STF_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) +#define STF_LOCK_ASSERT(sc) mtx_assert(&(sc)->sc_mtx, MA_OWNED) + static const int ip_stf_ttl = 40; extern struct domain inetdomain; @@ -176,8 +227,6 @@ struct protosw in_stf_protosw = { .pr_usrreqs = &rip_usrreqs }; -static char *stfnames[] = {"stf0", "stf", "6to4", NULL}; - static int stfmodevent(module_t, int, void *); static int stf_encapcheck(const struct mbuf *, int, int, void *); static struct in6_ifaddr *stf_getsrcifa6(struct ifnet *); @@ -191,66 +240,42 @@ static int stf_checkaddr6(struct stf_softc *, struct in6_addr *, static void stf_rtrequest(int, struct rtentry *, struct rt_addrinfo *); static int stf_ioctl(struct ifnet *, u_long, caddr_t); -static int stf_clone_match(struct if_clone *, const char *); -static int stf_clone_create(struct if_clone *, char *, size_t, caddr_t); -static int stf_clone_destroy(struct if_clone *, struct ifnet *); -static struct if_clone *stf_cloner; +#define STF_GETIN4_USE_CACHE 1 +static struct sockaddr_in *stf_getin4addr(struct stf_softc *, struct sockaddr_in *, + struct ifaddr *, int); +static struct sockaddr_in *stf_getin4addr_in6(struct stf_softc *, struct sockaddr_in *, + struct ifaddr *, const struct in6_addr *); +static struct sockaddr_in *stf_getin4addr_sin6(struct stf_softc *, struct sockaddr_in *, + struct ifaddr *, struct sockaddr_in6 *); +static int stf_clone_create(struct if_clone *, int, caddr_t); +static void stf_clone_destroy(struct ifnet *); -static int -stf_clone_match(struct if_clone *ifc, const char *name) -{ - int i; - - for(i = 0; stfnames[i] != NULL; i++) { - if (strcmp(stfnames[i], name) == 0) - return (1); - } - - return (0); -} +static struct if_clone *stf_cloner; static int -stf_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params) +stf_clone_create(struct if_clone *ifc, int unit, caddr_t params) { - int err, unit; struct stf_softc *sc; struct ifnet *ifp; - /* - * We can only have one unit, but since unit allocation is - * already locked, we use it to keep from allocating extra - * interfaces. - */ - unit = STFUNIT; - err = ifc_alloc_unit(ifc, &unit); - if (err != 0) - return (err); - sc = malloc(sizeof(struct stf_softc), M_STF, M_WAITOK | M_ZERO); + sc->sc_fibnum = curthread->td_proc->p_fibnum; ifp = STF2IFP(sc) = if_alloc(IFT_STF); - if (ifp == NULL) { + if (sc->sc_ifp == NULL) { free(sc, M_STF); - ifc_free_unit(ifc, unit); - return (ENOSPC); + return (ENOMEM); } + STF_LOCK_INIT(sc); ifp->if_softc = sc; - sc->sc_fibnum = curthread->td_proc->p_fibnum; - /* - * Set the name manually rather then using if_initname because - * we don't conform to the default naming convention for interfaces. - */ - strlcpy(ifp->if_xname, name, IFNAMSIZ); - ifp->if_dname = stfname; - ifp->if_dunit = IF_DUNIT_NONE; + if_initname(ifp, stfname, unit); - mtx_init(&(sc)->sc_ro_mtx, "stf ro", NULL, MTX_DEF); sc->encap_cookie = encap_attach_func(AF_INET, IPPROTO_IPV6, stf_encapcheck, &in_stf_protosw, sc); if (sc->encap_cookie == NULL) { if_printf(ifp, "attach failed\n"); + if_free(ifp); free(sc, M_STF); - ifc_free_unit(ifc, unit); return (ENOMEM); } @@ -260,42 +285,56 @@ stf_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params) ifp->if_snd.ifq_maxlen = ifqmaxlen; if_attach(ifp); bpfattach(ifp, DLT_NULL, sizeof(u_int32_t)); + + mtx_lock(&stf_mtx); + LIST_INSERT_HEAD(&V_stf_softc_list, sc, stf_list); + mtx_unlock(&stf_mtx); + return (0); } -static int -stf_clone_destroy(struct if_clone *ifc, struct ifnet *ifp) +static void +stf_clone_destroy(struct ifnet *ifp) { struct stf_softc *sc = ifp->if_softc; int err; + mtx_lock(&stf_mtx); + LIST_REMOVE(sc, stf_list); + mtx_unlock(&stf_mtx); + err = encap_detach(sc->encap_cookie); KASSERT(err == 0, ("Unexpected error detaching encap_cookie")); - mtx_destroy(&(sc)->sc_ro_mtx); bpfdetach(ifp); if_detach(ifp); if_free(ifp); + STF_LOCK_DESTROY(sc); free(sc, M_STF); - ifc_free_unit(ifc, STFUNIT); +} - return (0); +static void +vnet_stf_init(const void *unused __unused) +{ + + LIST_INIT(&V_stf_softc_list); } +VNET_SYSINIT(vnet_stf_init, SI_SUB_PSEUDO, SI_ORDER_MIDDLE, vnet_stf_init, + NULL); static int -stfmodevent(mod, type, data) - module_t mod; - int type; - void *data; +stfmodevent(module_t mod, int type, void *data) { switch (type) { case MOD_LOAD: - stf_cloner = if_clone_advanced(stfname, 0, stf_clone_match, - stf_clone_create, stf_clone_destroy); + mtx_init(&stf_mtx, "stf_mtx", NULL, MTX_DEF); + stf_cloner = if_clone_simple(stfname, + stf_clone_create, stf_clone_destroy, 0); break; case MOD_UNLOAD: if_clone_detach(stf_cloner); + mtx_destroy(&stf_mtx); break; default: return (EOPNOTSUPP); @@ -311,28 +350,31 @@ static moduledata_t stf_mod = { }; DECLARE_MODULE(if_stf, stf_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); +MODULE_VERSION(if_stf, 1); static int -stf_encapcheck(m, off, proto, arg) - const struct mbuf *m; - int off; - int proto; - void *arg; +stf_encapcheck(const struct mbuf *m, int off, int proto, void *arg) { struct ip ip; struct in6_ifaddr *ia6; + struct sockaddr_in ia6_in4addr; + struct sockaddr_in ia6_in4mask; + struct sockaddr_in *sin; struct stf_softc *sc; - struct in_addr a, b, mask; + struct ifnet *ifp; + int ret = 0; + DEBUG_PRINTF(1, "%s: enter\n", __func__); sc = (struct stf_softc *)arg; if (sc == NULL) return 0; + ifp = STF2IFP(sc); - if ((STF2IFP(sc)->if_flags & IFF_UP) == 0) + if ((ifp->if_flags & IFF_UP) == 0) return 0; /* IFF_LINK0 means "no decapsulation" */ - if ((STF2IFP(sc)->if_flags & IFF_LINK0) != 0) + if ((ifp->if_flags & IFF_LINK0) != 0) return 0; if (proto != IPPROTO_IPV6) @@ -344,72 +386,169 @@ stf_encapcheck(m, off, proto, arg) if (ip.ip_v != 4) return 0; - ia6 = stf_getsrcifa6(STF2IFP(sc)); + /* Lookup an ia6 whose IPv4 addr encoded in the IPv6 addr is valid. */ + ia6 = stf_getsrcifa6(ifp); if (ia6 == NULL) return 0; + if (sc->srcv4_addr != INADDR_ANY) { + sin = &ia6_in4addr; + sin->sin_addr.s_addr = sc->srcv4_addr; + sin->sin_family = AF_INET; + } else { + sin = stf_getin4addr(sc, &ia6_in4addr, &ia6->ia_ifa, STF_GETIN4_USE_CACHE); + if (sin == NULL) + return (0); + } + +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip6_sprintf(buf, &satosin6(ia6->ia_ifa.ifa_addr)->sin6_addr); + DEBUG_PRINTF(1, "%s: ia6->ia_ifa.ifa_addr = %s\n", __func__, buf); + ip6_sprintf(buf, &ia6->ia_addr.sin6_addr); + DEBUG_PRINTF(1, "%s: ia6->ia_addr = %s\n", __func__, buf); + ip6_sprintf(buf, &satosin6(ia6->ia_ifa.ifa_netmask)->sin6_addr); + DEBUG_PRINTF(1, "%s: ia6->ia_ifa.ifa_netmask = %s\n", __func__, buf); + ip6_sprintf(buf, &ia6->ia_prefixmask.sin6_addr); + DEBUG_PRINTF(1, "%s: ia6->ia_prefixmask = %s\n", __func__, buf); + + ip_sprintf(buf, &ia6_in4addr.sin_addr); + DEBUG_PRINTF(1, "%s: ia6_in4addr.sin_addr = %s\n", __func__, buf); + ip_sprintf(buf, &ip.ip_src); + DEBUG_PRINTF(1, "%s: ip.ip_src = %s\n", __func__, buf); + ip_sprintf(buf, &ip.ip_dst); + DEBUG_PRINTF(1, "%s: ip.ip_dst = %s\n", __func__, buf); + } +#endif /* * check if IPv4 dst matches the IPv4 address derived from the * local 6to4 address. * success on: dst = 10.1.1.1, ia6->ia_addr = 2002:0a01:0101:... */ - if (bcmp(GET_V4(&ia6->ia_addr.sin6_addr), &ip.ip_dst, - sizeof(ip.ip_dst)) != 0) { - ifa_free(&ia6->ia_ifa); - return 0; + DEBUG_PRINTF(1, "%s: check1: ia6_in4addr.sin_addr == ip.ip_dst?\n", __func__); + if (ia6_in4addr.sin_addr.s_addr != ip.ip_dst.s_addr) { + DEBUG_PRINTF(1, "%s: check1: false. Ignore this packet.\n", __func__); + goto freeit; } - /* - * check if IPv4 src matches the IPv4 address derived from the - * local 6to4 address masked by prefixmask. - * success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24 - * fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24 - */ - bzero(&a, sizeof(a)); - bcopy(GET_V4(&ia6->ia_addr.sin6_addr), &a, sizeof(a)); - bcopy(GET_V4(&ia6->ia_prefixmask.sin6_addr), &mask, sizeof(mask)); - ifa_free(&ia6->ia_ifa); - a.s_addr &= mask.s_addr; - b = ip.ip_src; - b.s_addr &= mask.s_addr; - if (a.s_addr != b.s_addr) - return 0; + DEBUG_PRINTF(1, "%s: check2: ia6->ia_addr is 2002::/16?\n", __func__); + + if (IN6_IS_ADDR_6TO4(&ia6->ia_addr.sin6_addr)) { + /* 6to4 (RFC 3056) */ + /* + * check if IPv4 src matches the IPv4 address derived + * from the local 6to4 address masked by prefixmask. + * success on: src = 10.1.1.1, ia6->ia_addr = 2002:0a00:.../24 + * fail on: src = 10.1.1.1, ia6->ia_addr = 2002:0b00:.../24 + */ + DEBUG_PRINTF(1, "%s: check2: true.\n", __func__); + + memcpy(&ia6_in4mask.sin_addr, + GET_V4(&ia6->ia_prefixmask.sin6_addr), + sizeof(ia6_in4mask)); +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip_sprintf(buf, &ia6_in4addr.sin_addr); + DEBUG_PRINTF(1, "%s: ia6->ia_addr = %s\n", + __func__, buf); + ip_sprintf(buf, &ip.ip_src); + DEBUG_PRINTF(1, "%s: ip.ip_src = %s\n", + __func__, buf); + ip_sprintf(buf, &ia6_in4mask.sin_addr); + DEBUG_PRINTF(1, "%s: ia6->ia_prefixmask = %s\n", + __func__, buf); + + DEBUG_PRINTF(1, "%s: check3: ia6_in4addr.sin_addr & mask == ip.ip_src & mask\n", + __func__); + } +#endif + + if ((ia6_in4addr.sin_addr.s_addr & ia6_in4mask.sin_addr.s_addr) != + (ip.ip_src.s_addr & ia6_in4mask.sin_addr.s_addr)) { + DEBUG_PRINTF(1, "%s: check3: false. Ignore this packet.\n", + __func__); + goto freeit; + } + } else { + /* 6rd (RFC 5569) */ + DEBUG_PRINTF(1, "%s: check2: false. 6rd.\n", __func__); + /* + * No restriction on the src address in the case of + * 6rd because the stf(4) interface always has a + * prefix which covers whole of IPv4 src address + * range. So, stf_output() will catch all of + * 6rd-capsuled IPv4 traffic with suspicious inner dst + * IPv4 address (i.e. the IPv6 destination address is + * one the admin does not like to route to outside), + * and then it discard them silently. + */ + } + DEBUG_PRINTF(1, "%s: all clear!\n", __func__); /* stf interface makes single side match only */ - return 32; + ret = 32; +freeit: + ifa_free(&ia6->ia_ifa); + + return (ret); } static struct in6_ifaddr * -stf_getsrcifa6(ifp) - struct ifnet *ifp; +stf_getsrcifa6(struct ifnet *ifp) { - struct ifaddr *ia; + struct ifaddr *ifa; struct in_ifaddr *ia4; - struct sockaddr_in6 *sin6; - struct in_addr in; + struct sockaddr_in *sin; + struct sockaddr_in in4; + struct stf_softc *sc; + + sc = ifp->if_softc; if_addr_rlock(ifp); - TAILQ_FOREACH(ia, &ifp->if_addrhead, ifa_link) { - if (ia->ifa_addr->sa_family != AF_INET6) + TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { + if (ifa->ifa_addr->sa_family != AF_INET6) continue; - sin6 = (struct sockaddr_in6 *)ia->ifa_addr; - if (!IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) + + if (sc->srcv4_addr != INADDR_ANY) { + in4.sin_addr.s_addr = sc->srcv4_addr; + sin = &in4; + } else if ((sin = stf_getin4addr(ifp->if_softc, &in4, ifa, + STF_GETIN4_USE_CACHE)) == NULL) continue; - bcopy(GET_V4(&sin6->sin6_addr), &in, sizeof(in)); - LIST_FOREACH(ia4, INADDR_HASH(in.s_addr), ia_hash) - if (ia4->ia_addr.sin_addr.s_addr == in.s_addr) + LIST_FOREACH(ia4, INADDR_HASH(sin->sin_addr.s_addr), ia_hash) + if (ia4->ia_addr.sin_addr.s_addr == sin->sin_addr.s_addr) break; if (ia4 == NULL) continue; - ifa_ref(ia); +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip6_sprintf(buf, &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr); + DEBUG_PRINTF(1, "%s: ifa->ifa_addr->sin6_addr = %s\n", + __func__, buf); + ip_sprintf(buf, &ia4->ia_addr.sin_addr); + DEBUG_PRINTF(1, "%s: ia4->ia_addr.sin_addr = %s\n", + __func__, buf); + } +#endif + + ifa_ref(ifa); if_addr_runlock(ifp); - return (struct in6_ifaddr *)ia; + return (ifatoia6(ifa)); } if_addr_runlock(ifp); - return NULL; + return (NULL); } static int @@ -419,8 +558,8 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, struct stf_softc *sc; const struct sockaddr_in6 *dst6; struct route *cached_route; - struct in_addr in4; - const void *ptr; + struct sockaddr_in *sin; + struct sockaddr_in in4; struct sockaddr_in *dst4; u_int8_t tos; struct ip *ip; @@ -472,20 +611,33 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, /* * Pickup the right outer dst addr from the list of candidates. * ip6_dst has priority as it may be able to give us shorter IPv4 hops. + * ip6_dst: destination addr in the packet header. + * dst6: destination addr specified in function argument. */ - ptr = NULL; - if (IN6_IS_ADDR_6TO4(&ip6->ip6_dst)) - ptr = GET_V4(&ip6->ip6_dst); - else if (IN6_IS_ADDR_6TO4(&dst6->sin6_addr)) - ptr = GET_V4(&dst6->sin6_addr); - else { - ifa_free(&ia6->ia_ifa); - m_freem(m); - ifp->if_oerrors++; - return ENETUNREACH; + DEBUG_PRINTF(1, "%s: dst addr selection\n", __func__); + sin = stf_getin4addr_in6(sc, &in4, &ia6->ia_ifa, &ip6->ip6_dst); + if (sin == NULL) { + if (sc->dstv4_addr != INADDR_ANY) + in4.sin_addr.s_addr = sc->dstv4_addr; + else { + sin = stf_getin4addr_in6(sc, &in4, &ia6->ia_ifa, &dst6->sin6_addr); + if (sin == NULL) { + ifa_free(&ia6->ia_ifa); + m_freem(m); + ifp->if_oerrors++; + return ENETUNREACH; + } + } } - bcopy(ptr, &in4, sizeof(in4)); +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + ip_sprintf(buf, &in4.sin_addr); + DEBUG_PRINTF(1, "%s: ip_dst = %s\n", __func__, buf); + } +#endif if (bpf_peers_present(ifp->if_bpf)) { /* * We need to prepend the address family as @@ -507,11 +659,30 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, ip = mtod(m, struct ip *); bzero(ip, sizeof(*ip)); + bcopy(&in4.sin_addr, &ip->ip_dst, sizeof(ip->ip_dst)); - bcopy(GET_V4(&((struct sockaddr_in6 *)&ia6->ia_addr)->sin6_addr), - &ip->ip_src, sizeof(ip->ip_src)); + if (sc->srcv4_addr != INADDR_ANY) + in4.sin_addr.s_addr = sc->srcv4_addr; + else { + sin = stf_getin4addr_sin6(sc, &in4, &ia6->ia_ifa, &ia6->ia_addr); + if (sin == NULL) { + ifa_free(&ia6->ia_ifa); + m_freem(m); + ifp->if_oerrors++; + return ENETUNREACH; + } + } + bcopy(&in4.sin_addr, &ip->ip_src, sizeof(ip->ip_src)); +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip_sprintf(buf, &ip->ip_src); + DEBUG_PRINTF(1, "%s: ip_src = %s\n", __func__, buf); + } +#endif ifa_free(&ia6->ia_ifa); - bcopy(&in4, &ip->ip_dst, sizeof(ip->ip_dst)); ip->ip_p = IPPROTO_IPV6; ip->ip_ttl = ip_stf_ttl; ip->ip_len = htons(m->m_pkthdr.len); @@ -520,7 +691,7 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, else ip_ecn_ingress(ECN_NOCARE, &ip->ip_tos, &tos); - if (!stf_route_cache) { + if (!V_stf_route_cache) { cached_route = NULL; goto sendit; } @@ -528,7 +699,7 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, /* * Do we have a cached route? */ - mtx_lock(&(sc)->sc_ro_mtx); + STF_LOCK(sc); dst4 = (struct sockaddr_in *)&sc->sc_ro.ro_dst; if (dst4->sin_family != AF_INET || bcmp(&dst4->sin_addr, &ip->ip_dst, sizeof(ip->ip_dst)) != 0) { @@ -546,8 +717,15 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, rtalloc_fib(&sc->sc_ro, sc->sc_fibnum); if (sc->sc_ro.ro_rt == NULL) { m_freem(m); - mtx_unlock(&(sc)->sc_ro_mtx); ifp->if_oerrors++; + STF_UNLOCK(sc); + return ENETUNREACH; + } + if (sc->sc_ro.ro_rt->rt_ifp == ifp) { + /* infinite loop detection */ + m_free(m); + ifp->if_oerrors++; + STF_UNLOCK(sc); return ENETUNREACH; } } @@ -556,35 +734,33 @@ stf_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, sendit: M_SETFIB(m, sc->sc_fibnum); ifp->if_opackets++; + DEBUG_PRINTF(1, "%s: ip_output dispatch.\n", __func__); error = ip_output(m, NULL, cached_route, 0, NULL, NULL); if (cached_route != NULL) - mtx_unlock(&(sc)->sc_ro_mtx); - return error; + STF_UNLOCK(sc); + + return (error); } static int -isrfc1918addr(in) - struct in_addr *in; +isrfc1918addr(struct in_addr *in) { /* * returns 1 if private address range: * 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 */ if (stf_permit_rfc1918 == 0 && ( - (ntohl(in->s_addr) & 0xff000000) >> 24 == 10 || - (ntohl(in->s_addr) & 0xfff00000) >> 16 == 172 * 256 + 16 || - (ntohl(in->s_addr) & 0xffff0000) >> 16 == 192 * 256 + 168)) + (ntohl(in->s_addr) & 0xff000000) == 10 << 24 || + (ntohl(in->s_addr) & 0xfff00000) == (172 * 256 + 16) << 16 || + (ntohl(in->s_addr) & 0xffff0000) == (192 * 256 + 168) << 16 )) return 1; return 0; } static int -stf_checkaddr4(sc, in, inifp) - struct stf_softc *sc; - struct in_addr *in; - struct ifnet *inifp; /* incoming interface */ +stf_checkaddr4(struct stf_softc *sc, struct in_addr *in, struct ifnet *inifp) { struct in_ifaddr *ia4; @@ -600,13 +776,6 @@ stf_checkaddr4(sc, in, inifp) } /* - * reject packets with private address range. - * (requirement from RFC3056 section 2 1st paragraph) - */ - if (isrfc1918addr(in)) - return -1; - - /* * reject packets with broadcast */ IN_IFADDR_RLOCK(); @@ -629,7 +798,7 @@ stf_checkaddr4(sc, in, inifp) bzero(&sin, sizeof(sin)); sin.sin_family = AF_INET; - sin.sin_len = sizeof(struct sockaddr_in); + sin.sin_len = sizeof(sin); sin.sin_addr = *in; rt = rtalloc1_fib((struct sockaddr *)&sin, 0, 0UL, sc->sc_fibnum); @@ -650,10 +819,7 @@ stf_checkaddr4(sc, in, inifp) } static int -stf_checkaddr6(sc, in6, inifp) - struct stf_softc *sc; - struct in6_addr *in6; - struct ifnet *inifp; /* incoming interface */ +stf_checkaddr6(struct stf_softc *sc, struct in6_addr *in6, struct ifnet *inifp) { /* * check 6to4 addresses @@ -677,9 +843,7 @@ stf_checkaddr6(sc, in6, inifp) } void -in_stf_input(m, off) - struct mbuf *m; - int off; +in_stf_input(struct mbuf *m, int off) { int proto; struct stf_softc *sc; @@ -687,6 +851,7 @@ in_stf_input(m, off) struct ip6_hdr *ip6; u_int8_t otos, itos; struct ifnet *ifp; + struct route_in6 rin6; proto = mtod(m, struct ip *)->ip_p; @@ -710,6 +875,17 @@ in_stf_input(m, off) mac_ifnet_create_mbuf(ifp, m); #endif +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip_sprintf(buf, &ip->ip_dst); + DEBUG_PRINTF(1, "%s: ip->ip_dst = %s\n", __func__, buf); + ip_sprintf(buf, &ip->ip_src); + DEBUG_PRINTF(1, "%s: ip->ip_src = %s\n", __func__, buf); + } +#endif /* * perform sanity check against outer src/dst. * for source, perform ingress filter as well. @@ -730,6 +906,17 @@ in_stf_input(m, off) } ip6 = mtod(m, struct ip6_hdr *); +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip6_sprintf(buf, &ip6->ip6_dst); + DEBUG_PRINTF(1, "%s: ip6->ip6_dst = %s\n", __func__, buf); + ip6_sprintf(buf, &ip6->ip6_src); + DEBUG_PRINTF(1, "%s: ip6->ip6_src = %s\n", __func__, buf); + } +#endif /* * perform sanity check against inner src/dst. * for source, perform ingress filter as well. @@ -740,6 +927,41 @@ in_stf_input(m, off) return; } + /* + * reject packets with private address range. + * (requirement from RFC3056 section 2 1st paragraph) + */ + if ((IN6_IS_ADDR_6TO4(&ip6->ip6_src) && isrfc1918addr(&ip->ip_src)) || + (IN6_IS_ADDR_6TO4(&ip6->ip6_dst) && isrfc1918addr(&ip->ip_dst))) { + m_freem(m); + return; + } + + /* + * Ignore if the destination is the same stf interface because + * all of valid IPv6 outgoing traffic should go interfaces + * except for it. + */ + memset(&rin6, 0, sizeof(rin6)); + rin6.ro_dst.sin6_len = sizeof(rin6.ro_dst); + rin6.ro_dst.sin6_family = AF_INET6; + memcpy(&rin6.ro_dst.sin6_addr, &ip6->ip6_dst, + sizeof(rin6.ro_dst.sin6_addr)); + rtalloc((struct route *)&rin6); + if (rin6.ro_rt == NULL) { + DEBUG_PRINTF(1, "%s: no IPv6 dst. Ignored.\n", __func__); + m_free(m); + return; + } + if ((rin6.ro_rt->rt_ifp == ifp) && + (!IN6_ARE_ADDR_EQUAL(&ip6->ip6_src, &rin6.ro_dst.sin6_addr))) { + DEBUG_PRINTF(1, "%s: IPv6 dst is the same stf. Ignored.\n", __func__); + RTFREE(rin6.ro_rt); + m_free(m); + return; + } + RTFREE(rin6.ro_rt); + itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff; if ((ifp->if_flags & IFF_LINK1) != 0) ip_ecn_egress(ECN_ALLOWED, &otos, &itos); @@ -749,7 +971,7 @@ in_stf_input(m, off) ip6->ip6_flow |= htonl((u_int32_t)itos << 20); m->m_pkthdr.rcvif = ifp; - + if (bpf_peers_present(ifp->if_bpf)) { /* * We need to prepend the address family as @@ -762,6 +984,7 @@ in_stf_input(m, off) bpf_mtap2(ifp->if_bpf, &af, sizeof(af), m); } + DEBUG_PRINTF(1, "%s: netisr_dispatch(NETISR_IPV6)\n", __func__); /* * Put the packet to the network layer input queue according to the * specified address family. @@ -776,48 +999,363 @@ in_stf_input(m, off) /* ARGSUSED */ static void -stf_rtrequest(cmd, rt, info) - int cmd; - struct rtentry *rt; - struct rt_addrinfo *info; +stf_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info) { + RT_LOCK_ASSERT(rt); rt->rt_mtu = rt->rt_ifp->if_mtu; } +static struct sockaddr_in * +stf_getin4addr_in6(struct stf_softc *sc, struct sockaddr_in *sin, + struct ifaddr *ifa, + const struct in6_addr *in6) +{ + struct sockaddr_in6 sin6; + + DEBUG_PRINTF(1, "%s: enter.\n", __func__); + if (ifa == NULL || in6 == NULL) + return NULL; + + memset(&sin6, 0, sizeof(sin6)); + memcpy(&sin6.sin6_addr, in6, sizeof(sin6.sin6_addr)); + sin6.sin6_len = sizeof(sin6); + sin6.sin6_family = AF_INET6; + + return(stf_getin4addr_sin6(sc, sin, ifa, &sin6)); +} + +static struct sockaddr_in * +stf_getin4addr_sin6(struct stf_softc *sc, struct sockaddr_in *sin, + struct ifaddr *ifa, + struct sockaddr_in6 *sin6) +{ + struct in6_ifaddr ia6; + int i; + + DEBUG_PRINTF(1, "%s: enter.\n", __func__); + if (ifa == NULL || sin6 == NULL) + return NULL; + + memset(&ia6, 0, sizeof(ia6)); + memcpy(&ia6, ifatoia6(ifa), sizeof(ia6)); + + /* + * Use prefixmask information from ifa, and + * address information from sin6. + */ + ia6.ia_addr.sin6_family = AF_INET6; + ia6.ia_ifa.ifa_addr = (struct sockaddr *)&ia6.ia_addr; + ia6.ia_ifa.ifa_dstaddr = NULL; + ia6.ia_ifa.ifa_netmask = (struct sockaddr *)&ia6.ia_prefixmask; + +#if STF_DEBUG > 3 + { + char buf[INET6_ADDRSTRLEN + 1]; + memset(&buf, 0, sizeof(buf)); + + ip6_sprintf(buf, &sin6->sin6_addr); + DEBUG_PRINTF(1, "%s: sin6->sin6_addr = %s\n", __func__, buf); + ip6_sprintf(buf, &ia6.ia_addr.sin6_addr); + DEBUG_PRINTF(1, "%s: ia6.ia_addr.sin6_addr = %s\n", __func__, buf); + ip6_sprintf(buf, &ia6.ia_prefixmask.sin6_addr); + DEBUG_PRINTF(1, "%s: ia6.ia_prefixmask.sin6_addr = %s\n", __func__, buf); + } +#endif + + /* + * When (src addr & src mask) != (dst (sin6) addr & src mask), + * the dst is not in the 6rd domain. The IPv4 address must + * not be used. + */ + for (i = 0; i < sizeof(ia6.ia_addr.sin6_addr); i++) { + if ((((u_char *)&ia6.ia_addr.sin6_addr)[i] & + ((u_char *)&ia6.ia_prefixmask.sin6_addr)[i]) + != + (((u_char *)&sin6->sin6_addr)[i] & + ((u_char *)&ia6.ia_prefixmask.sin6_addr)[i])) + return NULL; + } + + /* After the mask check, overwrite ia6.ia_addr with sin6. */ + memcpy(&ia6.ia_addr, sin6, sizeof(ia6.ia_addr)); + return(stf_getin4addr(sc, sin, (struct ifaddr *)&ia6, 0)); +} + +static struct sockaddr_in * +stf_getin4addr(struct stf_softc *sc, struct sockaddr_in *sin, + struct ifaddr *ifa, + int flags) +{ + struct in_addr *in; + struct sockaddr_in6 *sin6; + struct in6_ifaddr *ia6; + + DEBUG_PRINTF(1, "%s: enter.\n", __func__); + if (ifa == NULL || + ifa->ifa_addr == NULL || + ifa->ifa_addr->sa_family != AF_INET6) + return NULL; + + sin6 = satosin6(ifa->ifa_addr); + ia6 = ifatoia6(ifa); + + if ((flags & STF_GETIN4_USE_CACHE) && + (ifa->ifa_dstaddr != NULL) && + (ifa->ifa_dstaddr->sa_family == AF_INET)) { + /* + * XXX: ifa_dstaddr is used as a cache of the + * extracted IPv4 address. + */ + memcpy(sin, satosin(ifa->ifa_dstaddr), sizeof(*sin)); + +#if STF_DEBUG > 3 + { + char tmpbuf[INET6_ADDRSTRLEN + 1]; + memset(&tmpbuf, 0, INET6_ADDRSTRLEN); + + ip_sprintf(tmpbuf, &sin->sin_addr); + DEBUG_PRINTF(1, "%s: cached address was used = %s\n", __func__, tmpbuf); + } +#endif + return (sin); + } + + memset(sin, 0, sizeof(*sin)); + in = &sin->sin_addr; + +#if STF_DEBUG > 3 + { + char tmpbuf[INET6_ADDRSTRLEN + 1]; + memset(&tmpbuf, 0, INET6_ADDRSTRLEN); + + ip6_sprintf(tmpbuf, &sin6->sin6_addr); + DEBUG_PRINTF(1, "%s: sin6->sin6_addr = %s\n", __func__, tmpbuf); + } +#endif + + if (IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) { + /* 6to4 (RFC 3056) */ + bcopy(GET_V4(&sin6->sin6_addr), in, sizeof(*in)); + if (isrfc1918addr(in)) + return NULL; + } else { + /* 6rd (RFC 5569) */ + struct in6_addr buf; + u_char *p = (u_char *)&buf; + u_char *q = (u_char *)&in->s_addr; + u_int residue = 0, v4residue = 0; + u_char mask, v4mask = 0; + int i, j; + u_int plen, loop; + + /* + * 6rd-relays IPv6 prefix is located at a 32-bit just + * after the prefix edge. + */ + plen = in6_mask2len(&satosin6(ifa->ifa_netmask)->sin6_addr, NULL); + if (64 < plen) { + DEBUG_PRINTF(1, "prefixlen is %d\n", plen); + return NULL; + } + + loop = 4; /* Normal 6rd operation */ + memcpy(&buf, &sin6->sin6_addr, sizeof(buf)); + if (sc->v4prefixlen != 0 && sc->v4prefixlen != 32) { + v4residue = sc->v4prefixlen % 8; + } + p += plen / 8; + //plen -= 32; + + residue = plen % 8; + mask = ((u_char)(-1) >> (8 - residue)); + if (v4residue) { + loop++; + v4mask = ((u_char)(-1) << v4residue); + } + /* + * The p points head of the IPv4 address part in + * bytes. The residue is a bit-shift factor when + * prefixlen is not a multiple of 8. + */ + DEBUG_PRINTF(2, "residue = %d 0x%x\n", residue, mask); + for (j = 0, i = (loop - (sc->v4prefixlen / 8)); i < loop; j++, i++) { + if (residue) { + q[i] = ((p[j] & mask) << (8 - residue)); + q[i] |= ((p[j + 1] >> residue) & mask); + DEBUG_PRINTF(2, "FINAL i = %d q[%d] - p[%d/%d] %x\n", + i, q[i], p[j], p[j + 1] >> residue, q[i]); + } else { + q[i] = p[j]; + DEBUG_PRINTF(2, "FINAL q[%d] - p[%d] %x\n", + q[i], p[j], q[i]); + } + } + if (v4residue) { + q[loop - (sc->v4prefixlen / 8)] &= v4mask; + + if (sc->v4prefixlen > 0 && sc->v4prefixlen < 32) + in->s_addr |= sc->inaddr; + } + + //if (in->s_addr != sc->srcv4_addr) + // printf("Wrong decoded address %x/%x!!!!\n", in->s_addr, sc->srcv4_addr); + } + +#if STF_DEBUG > 3 + { + char tmpbuf[INET6_ADDRSTRLEN + 1]; + memset(&tmpbuf, 0, INET_ADDRSTRLEN); + + ip_sprintf(tmpbuf, in); + DEBUG_PRINTF(1, "%s: in->in_addr = %s\n", __func__, tmpbuf); + DEBUG_PRINTF(1, "%s: leave\n", __func__); + } +#endif + + if (flags & STF_GETIN4_USE_CACHE) { + DEBUG_PRINTF(1, "%s: try to access ifa->ifa_dstaddr.\n", __func__); + ifa->ifa_dstaddr = (struct sockaddr *)&ia6->ia_dstaddr; + DEBUG_PRINTF(1, "%s: try to memset 0 to ia_dstaddr.\n", __func__); + memset(&ia6->ia_dstaddr, 0, sizeof(ia6->ia_dstaddr)); + DEBUG_PRINTF(1, "%s: try to memcpy ifa->ifa_dstaddr.\n", __func__); + memcpy((struct sockaddr_in *)ifa->ifa_dstaddr, + sin, sizeof(struct sockaddr_in)); + DEBUG_PRINTF(1, "%s: try to set sa_family.\n", __func__); + ifa->ifa_dstaddr->sa_family = AF_INET; + DEBUG_PRINTF(1, "%s: in->in_addr is stored in ifa_dstaddr.\n", + __func__); + } + + return (sin); +} + + static int -stf_ioctl(ifp, cmd, data) - struct ifnet *ifp; - u_long cmd; - caddr_t data; +stf_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) { + struct stf_softc *sc, *sc_cur; struct ifaddr *ifa; struct ifreq *ifr; - struct sockaddr_in6 *sin6; - struct in_addr addr; + struct sockaddr_in in4; + struct stfv4args args; + struct in6_ifaddr *ia6; + struct ifdrv *ifd; int error, mtu; error = 0; + sc_cur = ifp->if_softc; + switch (cmd) { + case SIOCSDRVSPEC: + ifd = (struct ifdrv *) data; + error = priv_check(curthread, PRIV_NET_ADDIFADDR); + if (error) + break; + if (ifd->ifd_cmd == STF_SV4NET) { + if (ifd->ifd_len != sizeof(args)) { + error = EINVAL; + break; + } + mtx_lock(&stf_mtx); + LIST_FOREACH(sc, &V_stf_softc_list, stf_list) { + if (sc == sc_cur) + continue; + if (sc->inaddr == 0 || sc->v4prefixlen == 0) + continue; + + if ((ntohl(sc->inaddr) & ((uint32_t)(-1) << sc_cur->v4prefixlen)) == ntohl(sc_cur->inaddr)) { + error = EEXIST; + mtx_unlock(&stf_mtx); + return (error); + } + if ((ntohl(sc_cur->inaddr) & ((uint32_t)(-1) << sc->v4prefixlen)) == ntohl(sc->inaddr)) { + error = EEXIST; + mtx_unlock(&stf_mtx); + return (error); + } + } + mtx_unlock(&stf_mtx); + bzero(&args, sizeof args); + error = copyin(ifd->ifd_data, &args, ifd->ifd_len); + if (error) + break; + + sc_cur->srcv4_addr = args.inaddr.s_addr; + sc_cur->inaddr = ntohl(args.inaddr.s_addr); + sc_cur->inaddr &= ((uint32_t)(-1) << args.prefix); + sc_cur->inaddr = htonl(sc_cur->inaddr); + sc_cur->v4prefixlen = args.prefix; + if (sc_cur->v4prefixlen == 0) + sc_cur->v4prefixlen = 32; + } else if (ifd->ifd_cmd == STF_SDSTV4) { + if (ifd->ifd_len != sizeof(args)) { + error = EINVAL; + break; + } + bzero(&args, sizeof args); + error = copyin(ifd->ifd_data, &args, ifd->ifd_len); + if (error) + break; + sc_cur->dstv4_addr = args.dstv4_addr.s_addr; + } else + error = EINVAL; + break; + case SIOCGDRVSPEC: + ifd = (struct ifdrv *) data; + if (ifd->ifd_len != sizeof(args)) { + error = EINVAL; + break; + } + if (ifd->ifd_cmd != STF_GV4NET) { + error = EINVAL; + break; + } + bzero(&args, sizeof args); + args.inaddr.s_addr = sc_cur->srcv4_addr; + args.dstv4_addr.s_addr = sc_cur->dstv4_addr; + args.prefix = sc_cur->v4prefixlen; + error = copyout(&args, ifd->ifd_data, ifd->ifd_len); + + break; case SIOCSIFADDR: ifa = (struct ifaddr *)data; if (ifa == NULL || ifa->ifa_addr->sa_family != AF_INET6) { error = EAFNOSUPPORT; break; } - sin6 = (struct sockaddr_in6 *)ifa->ifa_addr; - if (!IN6_IS_ADDR_6TO4(&sin6->sin6_addr)) { + if (stf_getin4addr(sc_cur, &in4, ifa, 0) == NULL) { error = EINVAL; break; } - bcopy(GET_V4(&sin6->sin6_addr), &addr, sizeof(addr)); - if (isrfc1918addr(&addr)) { - error = EINVAL; - break; + /* + * Sanity check: if more than two interfaces have IFF_UP, do + * if_down() for all of them except for the specified one. + */ + mtx_lock(&stf_mtx); + LIST_FOREACH(sc, &V_stf_softc_list, stf_list) { + if (sc == sc_cur) + continue; + if ((ia6 = stf_getsrcifa6(sc->sc_ifp)) == NULL) + continue; + if (IN6_ARE_ADDR_EQUAL(&ia6->ia_addr.sin6_addr, &ifatoia6(ifa)->ia_addr.sin6_addr)) { + error = EEXIST; + ifa_free(&ia6->ia_ifa); + break; + } + ifa_free(&ia6->ia_ifa); } + mtx_unlock(&stf_mtx); + /* + * XXX: ifa_dstaddr is used as a cache of the + * extracted IPv4 address. + */ + if (ifa->ifa_dstaddr != NULL) + ifa->ifa_dstaddr->sa_family = AF_UNSPEC; ifa->ifa_rtrequest = stf_rtrequest; ifp->if_flags |= IFF_UP; + ifp->if_drv_flags |= IFF_DRV_RUNNING; break; case SIOCADDMULTI: @@ -847,4 +1385,5 @@ stf_ioctl(ifp, cmd, data) } return error; + } diff --git a/sys/net/if_stf.h b/sys/net/if_stf.h index cbaf670..e6ff29e 100644 --- a/sys/net/if_stf.h +++ b/sys/net/if_stf.h @@ -33,6 +33,15 @@ #ifndef _NET_IF_STF_H_ #define _NET_IF_STF_H_ +struct stfv4args { + struct in_addr inaddr; + struct in_addr dstv4_addr; + int prefix; +}; + +#define STF_SV4NET 1 +#define STF_GV4NET 2 +#define STF_SDSTV4 3 void in_stf_input(struct mbuf *, int); #endif /* _NET_IF_STF_H_ */ diff --git a/sys/net/if_tun.c b/sys/net/if_tun.c index 262d6d2..9864278 100644 --- a/sys/net/if_tun.c +++ b/sys/net/if_tun.c @@ -52,6 +52,7 @@ #include <net/vnet.h> #ifdef INET #include <netinet/in.h> +#include <netinet/ip.h> #endif #include <net/bpf.h> #include <net/if_tun.h> @@ -110,6 +111,7 @@ static const char tunname[] = "tun"; static MALLOC_DEFINE(M_TUN, tunname, "Tunnel Interface"); static int tundebug = 0; static int tundclone = 1; +static int tundispatch = 1; static struct clonedevs *tunclones; static TAILQ_HEAD(,tun_softc) tunhead = TAILQ_HEAD_INITIALIZER(tunhead); SYSCTL_INT(_debug, OID_AUTO, if_tun_debug, CTLFLAG_RW, &tundebug, 0, ""); @@ -119,6 +121,8 @@ static SYSCTL_NODE(_net_link, OID_AUTO, tun, CTLFLAG_RW, 0, "IP tunnel software network interface."); SYSCTL_INT(_net_link_tun, OID_AUTO, devfs_cloning, CTLFLAG_RW, &tundclone, 0, "Enable legacy devfs interface creation."); +SYSCTL_INT(_net_link_tun, OID_AUTO, tun_dispatching, CTLFLAG_RW, &tundispatch, 0, + "Queue rather than direct dispatch on write."); TUNABLE_INT("net.link.tun.devfs_cloning", &tundclone); @@ -328,31 +332,28 @@ static void tunstart(struct ifnet *ifp) { struct tun_softc *tp = ifp->if_softc; - struct mbuf *m; TUNDEBUG(ifp,"%s starting\n", ifp->if_xname); - if (ALTQ_IS_ENABLED(&ifp->if_snd)) { - IFQ_LOCK(&ifp->if_snd); - IFQ_POLL_NOLOCK(&ifp->if_snd, m); - if (m == NULL) { - IFQ_UNLOCK(&ifp->if_snd); - return; - } - IFQ_UNLOCK(&ifp->if_snd); - } + if (IFQ_IS_EMPTY(&ifp->if_snd)) + return; + + ifp->if_drv_flags |= IFF_DRV_OACTIVE; - mtx_lock(&tp->tun_mtx); if (tp->tun_flags & TUN_RWAIT) { tp->tun_flags &= ~TUN_RWAIT; wakeup(tp); } - selwakeuppri(&tp->tun_rsel, PZERO + 1); - KNOTE_LOCKED(&tp->tun_rsel.si_note, 0); - if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio) { + if (!TAILQ_EMPTY(&tp->tun_rsel.si_tdlist)) + selwakeuppri(&tp->tun_rsel, PZERO + 1); + if (!KNLIST_EMPTY(&tp->tun_rsel.si_note)) { + mtx_lock(&tp->tun_mtx); + KNOTE_LOCKED(&tp->tun_rsel.si_note, 0); mtx_unlock(&tp->tun_mtx); + } + if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio) pgsigio(&tp->tun_sigio, SIGIO, 0); - } else - mtx_unlock(&tp->tun_mtx); + + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; } /* XXX: should return an error code so it can fail. */ @@ -590,9 +591,7 @@ tunoutput(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst, #endif /* Could be unlocked read? */ - mtx_lock(&tp->tun_mtx); cached_tun_flags = tp->tun_flags; - mtx_unlock(&tp->tun_mtx); if ((cached_tun_flags & TUN_READY) != TUN_READY) { TUNDEBUG (ifp, "not ready 0%o\n", tp->tun_flags); m_freem (m0); @@ -799,9 +798,7 @@ tunread(struct cdev *dev, struct uio *uio, int flag) int error=0, len; TUNDEBUG (ifp, "read\n"); - mtx_lock(&tp->tun_mtx); if ((tp->tun_flags & TUN_READY) != TUN_READY) { - mtx_unlock(&tp->tun_mtx); TUNDEBUG (ifp, "not ready 0%o\n", tp->tun_flags); return (EHOSTDOWN); } @@ -812,19 +809,19 @@ tunread(struct cdev *dev, struct uio *uio, int flag) IFQ_DEQUEUE(&ifp->if_snd, m); if (m == NULL) { if (flag & O_NONBLOCK) { - mtx_unlock(&tp->tun_mtx); return (EWOULDBLOCK); } + mtx_lock(&tp->tun_mtx); tp->tun_flags |= TUN_RWAIT; error = mtx_sleep(tp, &tp->tun_mtx, PCATCH | (PZERO + 1), "tunread", 0); + tp->tun_flags &= ~TUN_RWAIT; + mtx_unlock(&tp->tun_mtx); if (error != 0) { - mtx_unlock(&tp->tun_mtx); return (error); } } } while (m == NULL); - mtx_unlock(&tp->tun_mtx); while (m && uio->uio_resid > 0 && error == 0) { len = min(uio->uio_resid, m->m_len); @@ -849,6 +846,7 @@ tunwrite(struct cdev *dev, struct uio *uio, int flag) struct tun_softc *tp = dev->si_drv1; struct ifnet *ifp = TUN2IFP(tp); struct mbuf *m; + struct ip *ip; uint32_t family; int isr; @@ -876,18 +874,26 @@ tunwrite(struct cdev *dev, struct uio *uio, int flag) mac_ifnet_create_mbuf(ifp, m); #endif - /* Could be unlocked read? */ - mtx_lock(&tp->tun_mtx); + /* XXX: unlocked read? */ if (tp->tun_flags & TUN_IFHEAD) { - mtx_unlock(&tp->tun_mtx); if (m->m_len < sizeof(family) && (m = m_pullup(m, sizeof(family))) == NULL) return (ENOBUFS); family = ntohl(*mtod(m, u_int32_t *)); m_adj(m, sizeof(family)); } else { - mtx_unlock(&tp->tun_mtx); - family = AF_INET; + if (m->m_len < sizeof(struct ip) && + (m = m_pullup(m, sizeof(struct ip))) == NULL) + return (ENOBUFS); + ip = mtod(m, struct ip *); + if (ip->ip_v == IPVERSION) + family = AF_INET; + else if (ip->ip_v == AF_INET6) + family = AF_INET6; + else { + m_freem(m); + return (EINVAL); + } } BPF_MTAP2(ifp, &family, sizeof(family), m); @@ -923,7 +929,10 @@ tunwrite(struct cdev *dev, struct uio *uio, int flag) ifp->if_ipackets++; CURVNET_SET(ifp->if_vnet); M_SETFIB(m, ifp->if_fib); - netisr_dispatch(isr, m); + if (tundispatch) + netisr_queue(isr, m); + else + netisr_dispatch(isr, m); CURVNET_RESTORE(); return (0); } @@ -939,21 +948,17 @@ tunpoll(struct cdev *dev, int events, struct thread *td) struct tun_softc *tp = dev->si_drv1; struct ifnet *ifp = TUN2IFP(tp); int revents = 0; - struct mbuf *m; TUNDEBUG(ifp, "tunpoll\n"); if (events & (POLLIN | POLLRDNORM)) { - IFQ_LOCK(&ifp->if_snd); - IFQ_POLL_NOLOCK(&ifp->if_snd, m); - if (m != NULL) { - TUNDEBUG(ifp, "tunpoll q=%d\n", ifp->if_snd.ifq_len); - revents |= events & (POLLIN | POLLRDNORM); - } else { + if (IFQ_IS_EMPTY(&ifp->if_snd)) { TUNDEBUG(ifp, "tunpoll waiting\n"); selrecord(td, &tp->tun_rsel); + } else { + TUNDEBUG(ifp, "tunpoll q=%d\n", ifp->if_snd.ifq_len); + revents |= events & (POLLIN | POLLRDNORM); } - IFQ_UNLOCK(&ifp->if_snd); } if (events & (POLLOUT | POLLWRNORM)) revents |= events & (POLLOUT | POLLWRNORM); diff --git a/sys/net/if_vlan.c b/sys/net/if_vlan.c index 6a43e37..2de6829 100644 --- a/sys/net/if_vlan.c +++ b/sys/net/if_vlan.c @@ -1,5 +1,9 @@ /*- * Copyright 1998 Massachusetts Institute of Technology + * Copyright 2012 ADARA Networks, Inc. + * + * Portions of this software were developed by Robert N. M. Watson under + * contract to ADARA Networks, Inc. * * Permission to use, copy, modify, and distribute this software and * its documentation for any purpose and without fee is hereby @@ -51,6 +55,7 @@ __FBSDID("$FreeBSD$"); #include <sys/mbuf.h> #include <sys/module.h> #include <sys/rwlock.h> +#include <sys/priv.h> #include <sys/queue.h> #include <sys/socket.h> #include <sys/sockio.h> @@ -112,6 +117,8 @@ struct ifvlan { int ifvm_mintu; /* min transmission unit */ uint16_t ifvm_proto; /* encapsulation ethertype */ uint16_t ifvm_tag; /* tag to apply on packets leaving if */ + uint16_t ifvm_vid; /* VLAN ID */ + uint8_t ifvm_pcp; /* Priority Code Point (PCP). */ } ifv_mib; SLIST_HEAD(, vlan_mc_entry) vlan_mc_listhead; #ifndef VLAN_ARRAY @@ -119,7 +126,9 @@ struct ifvlan { #endif }; #define ifv_proto ifv_mib.ifvm_proto -#define ifv_vid ifv_mib.ifvm_tag +#define ifv_tag ifv_mib.ifvm_tag +#define ifv_vid ifv_mib.ifvm_vid +#define ifv_pcp ifv_mib.ifvm_pcp #define ifv_encaplen ifv_mib.ifvm_encaplen #define ifv_mtufudge ifv_mib.ifvm_mtufudge #define ifv_mintu ifv_mib.ifvm_mintu @@ -144,6 +153,15 @@ static int soft_pad = 0; SYSCTL_INT(_net_link_vlan, OID_AUTO, soft_pad, CTLFLAG_RW, &soft_pad, 0, "pad short frames before tagging"); +/* + * For now, make preserving PCP via an mbuf tag optional, as it increases + * per-packet memory allocations and frees. In the future, it would be + * preferable to reuse ether_vtag for this, or similar. + */ +static int vlan_mtag_pcp = 0; +SYSCTL_INT(_net_link_vlan, OID_AUTO, mtag_pcp, CTLFLAG_RW, &vlan_mtag_pcp, 0, + "Retain VLAN PCP information as packets are passed up the stack"); + static const char vlanname[] = "vlan"; static MALLOC_DEFINE(M_VLAN, vlanname, "802.1Q Virtual LAN Interface"); @@ -188,15 +206,14 @@ static __inline struct ifvlan * vlan_gethash(struct ifvlantrunk *trunk, #endif static void trunk_destroy(struct ifvlantrunk *trunk); +static void vlan_start(struct ifnet *ifp); static void vlan_init(void *foo); static void vlan_input(struct ifnet *ifp, struct mbuf *m); static int vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr); -static void vlan_qflush(struct ifnet *ifp); static int vlan_setflag(struct ifnet *ifp, int flag, int status, int (*func)(struct ifnet *, int)); static int vlan_setflags(struct ifnet *ifp, int status); static int vlan_setmulti(struct ifnet *ifp); -static int vlan_transmit(struct ifnet *ifp, struct mbuf *m); static void vlan_unconfig(struct ifnet *ifp); static void vlan_unconfig_locked(struct ifnet *ifp, int departing); static int vlan_config(struct ifvlan *ifv, struct ifnet *p, uint16_t tag); @@ -693,6 +710,16 @@ vlan_devat(struct ifnet *ifp, uint16_t vid) } /* + * Recalculate the cached VLAN tag exposed via the MIB. + */ +static void +vlan_tag_recalculate(struct ifvlan *ifv) +{ + + ifv->ifv_tag = EVL_MAKETAG(ifv->ifv_vid, ifv->ifv_pcp, 0); +} + +/* * VLAN support can be loaded as a module. The only place in the * system that's intimately aware of this is ether_input. We hook * into this code through vlan_input_p which is defined there and @@ -958,9 +985,12 @@ vlan_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params) /* NB: mtu is not set here */ ifp->if_init = vlan_init; - ifp->if_transmit = vlan_transmit; - ifp->if_qflush = vlan_qflush; + ifp->if_start = vlan_start; ifp->if_ioctl = vlan_ioctl; + + IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); + ifp->if_snd.ifq_drv_maxlen = 0; + IFQ_SET_READY(&ifp->if_snd); ifp->if_flags = VLAN_IFFLAGS; ether_ifattach(ifp, eaddr); /* Now undo some of the damage... */ @@ -1001,6 +1031,8 @@ vlan_clone_destroy(struct if_clone *ifc, struct ifnet *ifp) struct ifvlan *ifv = ifp->if_softc; int unit = ifp->if_dunit; + IFQ_PURGE(&ifp->if_snd); + ether_ifdetach(ifp); /* first, remove it from system-wide lists */ vlan_unconfig(ifp); /* now it can be unconfigured and freed */ if_free(ifp); @@ -1021,97 +1053,114 @@ vlan_init(void *foo __unused) /* * The if_transmit method for vlan(4) interface. */ -static int -vlan_transmit(struct ifnet *ifp, struct mbuf *m) +static void +vlan_start(struct ifnet *ifp) { struct ifvlan *ifv; struct ifnet *p; + struct m_tag *mtag; + struct mbuf *m; + uint16_t tag; int error, len, mcast; + if (ALTQ_IS_ENABLED(&ifp->if_snd)) { + IFQ_LOCK(&ifp->if_snd); + IFQ_POLL_NOLOCK(&ifp->if_snd, m); + if (m == NULL) { + IFQ_UNLOCK(&ifp->if_snd); + return; + } + IFQ_UNLOCK(&ifp->if_snd); + } + ifv = ifp->if_softc; p = PARENT(ifv); - len = m->m_pkthdr.len; - mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0; - - BPF_MTAP(ifp, m); - /* - * Do not run parent's if_transmit() if the parent is not up, - * or parent's driver will cause a system crash. - */ - if (!UP_AND_RUNNING(p)) { - m_freem(m); - ifp->if_oerrors++; - return (ENETDOWN); - } + for (;;) { + IFQ_DEQUEUE(&ifp->if_snd, m); + if (m == NULL) + break; - /* - * Pad the frame to the minimum size allowed if told to. - * This option is in accord with IEEE Std 802.1Q, 2003 Ed., - * paragraph C.4.4.3.b. It can help to work around buggy - * bridges that violate paragraph C.4.4.3.a from the same - * document, i.e., fail to pad short frames after untagging. - * E.g., a tagged frame 66 bytes long (incl. FCS) is OK, but - * untagging it will produce a 62-byte frame, which is a runt - * and requires padding. There are VLAN-enabled network - * devices that just discard such runts instead or mishandle - * them somehow. - */ - if (soft_pad && p->if_type == IFT_ETHER) { - static char pad[8]; /* just zeros */ - int n; + len = m->m_pkthdr.len; + mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0; - for (n = ETHERMIN + ETHER_HDR_LEN - m->m_pkthdr.len; - n > 0; n -= sizeof(pad)) - if (!m_append(m, min(n, sizeof(pad)), pad)) - break; + BPF_MTAP(ifp, m); - if (n > 0) { - if_printf(ifp, "cannot pad short frame\n"); + /* + * Do not run parent's if_transmit() if the parent is not up, + * or parent's driver will cause a system crash. + */ + if (!UP_AND_RUNNING(p)) { ifp->if_oerrors++; - m_freem(m); - return (0); + return; } - } - /* - * If underlying interface can do VLAN tag insertion itself, - * just pass the packet along. However, we need some way to - * tell the interface where the packet came from so that it - * knows how to find the VLAN tag to use, so we attach a - * packet tag that holds it. - */ - if (p->if_capenable & IFCAP_VLAN_HWTAGGING) { - m->m_pkthdr.ether_vtag = ifv->ifv_vid; - m->m_flags |= M_VLANTAG; - } else { - m = ether_vlanencap(m, ifv->ifv_vid); - if (m == NULL) { - if_printf(ifp, "unable to prepend VLAN header\n"); - ifp->if_oerrors++; - return (0); + /* + * Pad the frame to the minimum size allowed if told to. + * This option is in accord with IEEE Std 802.1Q, 2003 Ed., + * paragraph C.4.4.3.b. It can help to work around buggy + * bridges that violate paragraph C.4.4.3.a from the same + * document, i.e., fail to pad short frames after untagging. + * E.g., a tagged frame 66 bytes long (incl. FCS) is OK, but + * untagging it will produce a 62-byte frame, which is a runt + * and requires padding. There are VLAN-enabled network + * devices that just discard such runts instead or mishandle + * them somehow. + */ + if (soft_pad && p->if_type == IFT_ETHER) { + static char pad[8]; /* just zeros */ + int n; + + for (n = ETHERMIN + ETHER_HDR_LEN - m->m_pkthdr.len; + n > 0; n -= sizeof(pad)) + if (!m_append(m, min(n, sizeof(pad)), pad)) + break; + + if (n > 0) { + if_printf(ifp, "cannot pad short frame\n"); + ifp->if_oerrors++; + m_freem(m); + return; + } } - } - /* - * Send it, precisely as ether_output() would have. - */ - error = (p->if_transmit)(p, m); - if (!error) { - ifp->if_opackets++; - ifp->if_omcasts += mcast; - ifp->if_obytes += len; - } else - ifp->if_oerrors++; - return (error); -} + /* + * If underlying interface can do VLAN tag insertion itself, + * just pass the packet along. However, we need some way to + * tell the interface where the packet came from so that it + * knows how to find the VLAN tag to use, so we attach a + * packet tag that holds it. + */ + if (vlan_mtag_pcp && (mtag = m_tag_locate(m, MTAG_8021Q, + MTAG_8021Q_PCP_OUT, NULL)) != NULL) + tag = EVL_MAKETAG(ifv->ifv_vid, *(uint8_t *)(mtag + 1), 0); + else + tag = ifv->ifv_tag; + if (p->if_capenable & IFCAP_VLAN_HWTAGGING) { + m->m_pkthdr.ether_vtag = tag; + m->m_flags |= M_VLANTAG; + } else { + m = ether_vlanencap(m, tag); + if (m == NULL) { + if_printf(ifp, "unable to prepend VLAN header\n"); + ifp->if_oerrors++; + return; + } + } -/* - * The ifp->if_qflush entry point for vlan(4) is a no-op. - */ -static void -vlan_qflush(struct ifnet *ifp __unused) -{ + /* + * Send it, precisely as ether_output() would have. + */ + error = (p->if_transmit)(p, m); + if (!error) { + ifp->if_opackets++; + //ifp->if_omcasts += mcast; + //ifp->if_obytes += len; + } else + ifp->if_oerrors++; + } + + return; } static void @@ -1119,7 +1168,8 @@ vlan_input(struct ifnet *ifp, struct mbuf *m) { struct ifvlantrunk *trunk = ifp->if_vlantrunk; struct ifvlan *ifv; - uint16_t vid; + struct m_tag *mtag; + uint16_t vid, tag; KASSERT(trunk != NULL, ("%s: no trunk", __func__)); @@ -1128,7 +1178,7 @@ vlan_input(struct ifnet *ifp, struct mbuf *m) * Packet is tagged, but m contains a normal * Ethernet frame; the tag is stored out-of-band. */ - vid = EVL_VLANOFTAG(m->m_pkthdr.ether_vtag); + tag = m->m_pkthdr.ether_vtag; m->m_flags &= ~M_VLANTAG; } else { struct ether_vlan_header *evl; @@ -1144,7 +1194,7 @@ vlan_input(struct ifnet *ifp, struct mbuf *m) return; } evl = mtod(m, struct ether_vlan_header *); - vid = EVL_VLANOFTAG(ntohs(evl->evl_tag)); + tag = ntohs(evl->evl_tag); /* * Remove the 802.1q header by copying the Ethernet @@ -1168,6 +1218,8 @@ vlan_input(struct ifnet *ifp, struct mbuf *m) } } + vid = EVL_VLANOFTAG(tag); + TRUNK_RLOCK(trunk); ifv = vlan_gethash(trunk, vid); if (ifv == NULL || !UP_AND_RUNNING(ifv->ifv_ifp)) { @@ -1178,6 +1230,28 @@ vlan_input(struct ifnet *ifp, struct mbuf *m) } TRUNK_RUNLOCK(trunk); + if (vlan_mtag_pcp) { + /* + * While uncommon, it is possible that we will find a 802.1q + * packet encapsulated inside another packet that also had an + * 802.1q header. For example, ethernet tunneled over IPSEC + * arriving over ethernet. In that case, we replace the + * existing 802.1q PCP m_tag value. + */ + mtag = m_tag_locate(m, MTAG_8021Q, MTAG_8021Q_PCP_IN, NULL); + if (mtag == NULL) { + mtag = m_tag_alloc(MTAG_8021Q, MTAG_8021Q_PCP_IN, + sizeof(uint8_t), M_NOWAIT); + if (mtag == NULL) { + m_freem(m); + ifp->if_ierrors++; + return; + } + m_tag_prepend(m, mtag); + } + *(uint8_t *)(mtag + 1) = EVL_PRIOFTAG(tag); + } + m->m_pkthdr.rcvif = ifv->ifv_ifp; ifv->ifv_ifp->if_ipackets++; @@ -1195,7 +1269,7 @@ vlan_config(struct ifvlan *ifv, struct ifnet *p, uint16_t vid) /* VID numbers 0x0 and 0xFFF are reserved */ if (vid == 0 || vid == 0xFFF) return (EINVAL); - if (p->if_type != IFT_ETHER && + if (p->if_type != IFT_ETHER && p->if_type != IFT_BRIDGE && (p->if_capenable & IFCAP_VLAN_HWTAGGING) == 0) return (EPROTONOSUPPORT); if ((p->if_flags & VLAN_IFFLAGS) != VLAN_IFFLAGS) @@ -1226,6 +1300,8 @@ exists: } ifv->ifv_vid = vid; /* must set this before vlan_inshash() */ + ifv->ifv_pcp = 0; /* Default: best effort delivery. */ + vlan_tag_recalculate(ifv); error = vlan_inshash(trunk, ifv); if (error) goto done; @@ -1721,6 +1797,34 @@ vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) } break; + case SIOCGVLANPCP: +#ifdef VIMAGE + if (ifp->if_vnet != ifp->if_home_vnet) { + error = EPERM; + break; + } +#endif + ifr->ifr_vlan_pcp = ifv->ifv_pcp; + break; + + case SIOCSVLANPCP: +#ifdef VIMAGE + if (ifp->if_vnet != ifp->if_home_vnet) { + error = EPERM; + break; + } +#endif + error = priv_check(curthread, PRIV_NET_SETVLANPCP); + if (error) + break; + if (ifr->ifr_vlan_pcp > 7) { + error = EINVAL; + break; + } + ifv->ifv_pcp = ifr->ifr_vlan_pcp; + vlan_tag_recalculate(ifv); + break; + default: error = EINVAL; break; diff --git a/sys/net/if_vlan_var.h b/sys/net/if_vlan_var.h index 4eb3b09..b1950e1 100644 --- a/sys/net/if_vlan_var.h +++ b/sys/net/if_vlan_var.h @@ -89,6 +89,23 @@ struct vlanreq { #define SIOCSETVLAN SIOCSIFGENERIC #define SIOCGETVLAN SIOCGIFGENERIC +#define SIOCGVLANPCP _IOWR('i', 152, struct ifreq) /* Get VLAN PCP */ +#define SIOCSVLANPCP _IOW('i', 153, struct ifreq) /* Set VLAN PCP */ + +/* + * Names for 802.1q priorities ("802.1p"). Notice that in this scheme, + * (0 < 1), allowing default 0-tagged traffic to take priority over background + * tagged traffic. + */ +#define IEEE8021Q_PCP_BK 1 /* Background (lowest) */ +#define IEEE8021Q_PCP_BE 0 /* Best effort (default) */ +#define IEEE8021Q_PCP_EE 2 /* Excellent effort */ +#define IEEE8021Q_PCP_CA 3 /* Critical applications */ +#define IEEE8021Q_PCP_VI 4 /* Video, < 100ms latency */ +#define IEEE8021Q_PCP_VO 5 /* Video, < 10ms latency */ +#define IEEE8021Q_PCP_IC 6 /* Internetwork control */ +#define IEEE8021Q_PCP_NC 7 /* Network control (highest) */ + #ifdef _KERNEL /* * Drivers that are capable of adding and removing the VLAN header @@ -126,6 +143,16 @@ struct vlanreq { * if_capabilities. */ +/* + * The 802.1q code may also tag mbufs with the PCP (priority) field for use in + * other layers of the stack, in which case an m_tag will be used. This is + * semantically quite different from use of the ether_vtag field, which is + * defined only between the device driver and VLAN layer. + */ +#define MTAG_8021Q 1326104895 +#define MTAG_8021Q_PCP_IN 0 /* Input priority. */ +#define MTAG_8021Q_PCP_OUT 1 /* Output priority. */ + #define VLAN_CAPABILITIES(_ifp) do { \ if ((_ifp)->if_vlantrunk != NULL) \ (*vlan_trunk_cap_p)(_ifp); \ diff --git a/sys/net/netisr.c b/sys/net/netisr.c index 0cc6bb8..ef34600 100644 --- a/sys/net/netisr.c +++ b/sys/net/netisr.c @@ -126,6 +126,13 @@ static struct rmlock netisr_rmlock; static SYSCTL_NODE(_net, OID_AUTO, isr, CTLFLAG_RW, 0, "netisr"); +#ifdef DEVICE_POLLING +static int netisr_polling = 0; /* Enable Polling. */ +TUNABLE_INT("net.isr.polling_enable", &netisr_polling); +SYSCTL_INT(_net_isr, OID_AUTO, polling_enable, CTLFLAG_RW, + &netisr_polling, 0, "Enable polling"); +#endif + /*- * Three global direct dispatch policies are supported: * @@ -168,7 +175,7 @@ SYSCTL_INT(_net_isr, OID_AUTO, maxthreads, CTLFLAG_RDTUN, &netisr_maxthreads, 0, "Use at most this many CPUs for netisr processing"); -static int netisr_bindthreads = 0; /* Bind threads to CPUs. */ +static int netisr_bindthreads = 1; /* Bind threads to CPUs. */ TUNABLE_INT("net.isr.bindthreads", &netisr_bindthreads); SYSCTL_INT(_net_isr, OID_AUTO, bindthreads, CTLFLAG_RDTUN, &netisr_bindthreads, 0, "Bind netisr threads to CPUs."); @@ -796,9 +803,11 @@ swi_net(void *arg) nwsp = arg; #ifdef DEVICE_POLLING - KASSERT(nws_count == 1, - ("%s: device_polling but nws_count != 1", __func__)); - netisr_poll(); + if (netisr_polling) { + KASSERT(nws_count == 1, + ("%s: device_polling but nws_count != 1", __func__)); + netisr_poll(); + } #endif #ifdef NETISR_LOCKING NETISR_RLOCK(&tracker); @@ -823,7 +832,8 @@ out: NETISR_RUNLOCK(&tracker); #endif #ifdef DEVICE_POLLING - netisr_pollmore(); + if (netisr_polling) + netisr_pollmore(); #endif } @@ -1078,6 +1088,9 @@ netisr_sched_poll(void) { struct netisr_workstream *nwsp; + if (!netisr_polling) + return; + nwsp = DPCPU_ID_PTR(nws_array[0], nws); NWS_SIGNAL(nwsp); } @@ -1151,7 +1164,7 @@ netisr_init(void *arg) * multiple netisr threads, so for the time being compiling in device * polling disables parallel netisr workers. */ - if (netisr_maxthreads != 1 || netisr_bindthreads != 0) { + if (netisr_polling && (netisr_maxthreads != 1 || netisr_bindthreads != 0)) { printf("netisr_init: forcing maxthreads to 1 and " "bindthreads to 0 for device polling\n"); netisr_maxthreads = 1; diff --git a/sys/net/pfil.c b/sys/net/pfil.c index 44373ee..5d5d346 100644 --- a/sys/net/pfil.c +++ b/sys/net/pfil.c @@ -34,6 +34,7 @@ #include <sys/errno.h> #include <sys/lock.h> #include <sys/malloc.h> +#include <sys/sbuf.h> #include <sys/rmlock.h> #include <sys/socket.h> #include <sys/socketvar.h> @@ -78,7 +79,7 @@ pfil_run_hooks(struct pfil_head *ph, struct mbuf **mp, struct ifnet *ifp, KASSERT(ph->ph_nhooks >= 0, ("Pfil hook count dropped < 0")); for (pfh = pfil_chain_get(dir, ph); pfh != NULL; pfh = TAILQ_NEXT(pfh, pfil_chain)) { - if (pfh->pfil_func != NULL) { + if (!(pfh->pfil_flags & PFIL_DISABLED) && pfh->pfil_func != NULL) { rv = (*pfh->pfil_func)(pfh->pfil_arg, &m, ifp, dir, inp); if (rv != 0 || m == NULL) @@ -211,6 +212,140 @@ pfil_head_unregister(struct pfil_head *ph) return (0); } +static int +pfil_sysctl_handler(SYSCTL_HANDLER_ARGS) +{ + struct rm_priotracker rmpt; + struct pfil_head *ph; + struct packet_filter_hook *pfh, *pfhtmp; + struct sbuf *sb; + pfil_chain_t npfl, *pfl; + char *new_order, *elm, *parse; + int i = 0, err = 0, hintlen, reqlen; + + hintlen = 0; + + ph = (struct pfil_head *)arg1; + if (ph == NULL || !PFIL_HOOKED(ph)) { + err = SYSCTL_OUT(req, "", 2); + return (err); + } + + if (arg2 == PFIL_IN) + pfl = &ph->ph_in; + else + pfl = &ph->ph_out; + + if (TAILQ_EMPTY(pfl)) { + err = SYSCTL_OUT(req, "", 2); + return (err); + } + + /* + * NOTE: This is needed to avoid witness(4) warnings. + */ + PFIL_RLOCK(ph, &rmpt); + TAILQ_FOREACH(pfh, pfl, pfil_chain) { + if (pfh->pfil_name != NULL) + hintlen = strlen(pfh->pfil_name); + else + hintlen += 2; + } + PFIL_RUNLOCK(ph, &rmpt); + + sb = sbuf_new(NULL, NULL, hintlen + 1, SBUF_AUTOEXTEND); + if (sb == NULL) + return (EINVAL); + + PFIL_RLOCK(ph, &rmpt); + TAILQ_FOREACH(pfh, pfl, pfil_chain) { + if (i > 0) + sbuf_printf(sb, ", "); + if (pfh->pfil_name != NULL) + sbuf_printf(sb, "%s%s", pfh->pfil_name, + pfh->pfil_flags & PFIL_DISABLED ? "*" : ""); + else + sbuf_printf(sb, "%s%s", "NA", + pfh->pfil_flags & PFIL_DISABLED ? "*" : ""); + i++; + } + PFIL_RUNLOCK(ph, &rmpt); + + sbuf_finish(sb); + + /* hint for sensible write buffer sizes */ + hintlen = sbuf_len(sb) + i * 2; + err = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1); + sbuf_delete(sb); + + if (err || !req->newptr) + return (err); + + if ((reqlen = req->newlen - req->newidx) > hintlen) + return (E2BIG); + new_order = malloc(reqlen + 1, M_TEMP, M_WAITOK|M_ZERO); + + err = SYSCTL_IN(req, new_order, reqlen); + if (err) + goto error; + new_order[reqlen] = '\0'; /* Just in case */ + parse = new_order; + + TAILQ_INIT(&npfl); + PFIL_WLOCK(ph); + while ((elm = strsep(&parse, " \t,")) != NULL) { + if (*elm == '\0') + continue; + TAILQ_FOREACH_SAFE(pfh, pfl, pfil_chain, pfhtmp) { + if (pfh->pfil_name != NULL) { + if (!strcmp(pfh->pfil_name, elm)) { + TAILQ_REMOVE(pfl, pfh, pfil_chain); + TAILQ_INSERT_TAIL(&npfl, pfh, pfil_chain); + pfh->pfil_flags &= ~PFIL_DISABLED; + break; + } + } else { + if (!strcmp(elm, "NA")) { + TAILQ_REMOVE(pfl, pfh, pfil_chain); + TAILQ_INSERT_TAIL(&npfl, pfh, pfil_chain); + pfh->pfil_flags &= ~PFIL_DISABLED; + break; + } + } + } + } + + TAILQ_FOREACH_SAFE(pfh, pfl, pfil_chain, pfhtmp) { + pfh->pfil_flags |= PFIL_DISABLED; + TAILQ_REMOVE(pfl, pfh, pfil_chain); + TAILQ_INSERT_TAIL(&npfl, pfh, pfil_chain); + } + + TAILQ_CONCAT(pfl, &npfl, pfil_chain); + +error: + PFIL_WUNLOCK(ph); + free(new_order, M_TEMP); + return (err); +} + +void +pfil_head_export_sysctl(struct pfil_head *ph, struct sysctl_oid_list *parent) +{ + struct sysctl_oid *root; + + root = SYSCTL_ADD_NODE(&ph->ph_clist, parent, OID_AUTO, "pfil", + CTLFLAG_RW, 0, "pfil(9) management"); + SYSCTL_ADD_PROC((void *)&ph->ph_clist, SYSCTL_CHILDREN(root), OID_AUTO, + "inbound", CTLTYPE_STRING|CTLFLAG_RW|CTLFLAG_SECURE3, + (void *)ph, PFIL_IN, pfil_sysctl_handler, "A", + "Inbound filter hooks"); + SYSCTL_ADD_PROC((void *)&ph->ph_clist, SYSCTL_CHILDREN(root), OID_AUTO, + "outbound", CTLTYPE_STRING|CTLFLAG_RW|CTLFLAG_SECURE3, + (void *)ph, PFIL_OUT, pfil_sysctl_handler, "A", + "Outbound filter hooks"); +} + /* * pfil_head_get() returns the pfil_head for a given key/dlt. */ @@ -238,6 +373,12 @@ pfil_head_get(int type, u_long val) int pfil_add_hook(pfil_func_t func, void *arg, int flags, struct pfil_head *ph) { + return (pfil_add_named_hook(func, arg, NULL, flags, ph)); +} + +int +pfil_add_named_hook(pfil_func_t func, void *arg, char *name, int flags, struct pfil_head *ph) +{ struct packet_filter_hook *pfh1 = NULL; struct packet_filter_hook *pfh2 = NULL; int err; @@ -262,6 +403,8 @@ pfil_add_hook(pfil_func_t func, void *arg, int flags, struct pfil_head *ph) if (flags & PFIL_IN) { pfh1->pfil_func = func; pfh1->pfil_arg = arg; + pfh1->pfil_name = name; + pfh1->pfil_flags &= ~PFIL_DISABLED; err = pfil_chain_add(&ph->ph_in, pfh1, flags & ~PFIL_OUT); if (err) goto locked_error; @@ -270,6 +413,8 @@ pfil_add_hook(pfil_func_t func, void *arg, int flags, struct pfil_head *ph) if (flags & PFIL_OUT) { pfh2->pfil_func = func; pfh2->pfil_arg = arg; + pfh2->pfil_name = name; + pfh2->pfil_flags &= ~PFIL_DISABLED; err = pfil_chain_add(&ph->ph_out, pfh2, flags & ~PFIL_IN); if (err) { if (flags & PFIL_IN) diff --git a/sys/net/pfil.h b/sys/net/pfil.h index c9a1b65..ff260ce 100644 --- a/sys/net/pfil.h +++ b/sys/net/pfil.h @@ -38,6 +38,7 @@ #include <sys/_mutex.h> #include <sys/lock.h> #include <sys/rmlock.h> +#include <sys/sysctl.h> struct mbuf; struct ifnet; @@ -55,11 +56,14 @@ struct packet_filter_hook { TAILQ_ENTRY(packet_filter_hook) pfil_chain; pfil_func_t pfil_func; void *pfil_arg; + int pfil_flags; + char *pfil_name; }; #define PFIL_IN 0x00000001 #define PFIL_OUT 0x00000002 #define PFIL_WAITOK 0x00000004 +#define PFIL_DISABLED 0x00000008 #define PFIL_ALL (PFIL_IN|PFIL_OUT) typedef TAILQ_HEAD(pfil_chain, packet_filter_hook) pfil_chain_t; @@ -85,6 +89,7 @@ struct pfil_head { struct rmlock ph_lock; /* Private lock storage */ int flags; #endif + struct sysctl_ctx_list ph_clist; union { u_long phu_val; void *phu_ptr; @@ -96,7 +101,9 @@ struct pfil_head { /* Public functions for pfil hook management by packet filters. */ struct pfil_head *pfil_head_get(int, u_long); +void pfil_head_export_sysctl(struct pfil_head *, struct sysctl_oid_list *); int pfil_add_hook(pfil_func_t, void *, int, struct pfil_head *); +int pfil_add_named_hook(pfil_func_t, void *, char *, int, struct pfil_head *); int pfil_remove_hook(pfil_func_t, void *, int, struct pfil_head *); #define PFIL_HOOKED(p) ((p)->ph_nhooks > 0) diff --git a/sys/net/pfkeyv2.h b/sys/net/pfkeyv2.h index c45f8b0..bab26fe 100644 --- a/sys/net/pfkeyv2.h +++ b/sys/net/pfkeyv2.h @@ -218,7 +218,6 @@ struct sadb_x_sa2 { }; /* XXX Policy Extension */ -/* sizeof(struct sadb_x_policy) == 16 */ struct sadb_x_policy { u_int16_t sadb_x_policy_len; u_int16_t sadb_x_policy_exttype; @@ -228,6 +227,8 @@ struct sadb_x_policy { u_int32_t sadb_x_policy_id; u_int32_t sadb_x_policy_reserved2; }; +_Static_assert(sizeof(struct sadb_x_policy) == 16, "struct size mismatch"); + /* * When policy_type == IPSEC, it is followed by some of * the ipsec policy request. @@ -256,31 +257,31 @@ struct sadb_x_ipsecrequest { }; /* NAT-Traversal type, see RFC 3948 (and drafts). */ -/* sizeof(struct sadb_x_nat_t_type) == 8 */ struct sadb_x_nat_t_type { u_int16_t sadb_x_nat_t_type_len; u_int16_t sadb_x_nat_t_type_exttype; u_int8_t sadb_x_nat_t_type_type; u_int8_t sadb_x_nat_t_type_reserved[3]; }; +_Static_assert(sizeof(struct sadb_x_nat_t_type) == 8, "struct size mismatch"); /* NAT-Traversal source or destination port. */ -/* sizeof(struct sadb_x_nat_t_port) == 8 */ struct sadb_x_nat_t_port { u_int16_t sadb_x_nat_t_port_len; u_int16_t sadb_x_nat_t_port_exttype; u_int16_t sadb_x_nat_t_port_port; u_int16_t sadb_x_nat_t_port_reserved; }; +_Static_assert(sizeof(struct sadb_x_nat_t_port) == 8, "struct size mismatch"); /* ESP fragmentation size. */ -/* sizeof(struct sadb_x_nat_t_frag) == 8 */ struct sadb_x_nat_t_frag { u_int16_t sadb_x_nat_t_frag_len; u_int16_t sadb_x_nat_t_frag_exttype; u_int16_t sadb_x_nat_t_frag_fraglen; u_int16_t sadb_x_nat_t_frag_reserved; }; +_Static_assert(sizeof(struct sadb_x_nat_t_frag) == 8, "struct size mismatch"); #define SADB_EXT_RESERVED 0 @@ -332,39 +333,47 @@ struct sadb_x_nat_t_frag { #define SADB_SAFLAGS_PFS 1 -/* RFC2367 numbers - meets RFC2407 */ +/* + * Though some of these numbers (both _AALG and _EALG) appear to be + * IKEv2 numbers and others original IKE numbers, they have no meaning. + * These are constants that the various IKE daemons use to tell the kernel + * what cipher to use. + * + * Do not use these constants directly to decide which Transformation ID + * to send. You are responsible for mapping them yourself. + */ #define SADB_AALG_NONE 0 #define SADB_AALG_MD5HMAC 2 #define SADB_AALG_SHA1HMAC 3 #define SADB_AALG_MAX 252 -/* private allocations - based on RFC2407/IANA assignment */ #define SADB_X_AALG_SHA2_256 5 #define SADB_X_AALG_SHA2_384 6 #define SADB_X_AALG_SHA2_512 7 #define SADB_X_AALG_RIPEMD160HMAC 8 -#define SADB_X_AALG_AES_XCBC_MAC 9 /* draft-ietf-ipsec-ciph-aes-xcbc-mac-04 */ -/* private allocations should use 249-255 (RFC2407) */ +#define SADB_X_AALG_AES_XCBC_MAC 9 /* RFC3566 */ +#define SADB_X_AALG_AES128GMAC 11 /* RFC4543 + Errata1821 */ +#define SADB_X_AALG_AES192GMAC 12 +#define SADB_X_AALG_AES256GMAC 13 #define SADB_X_AALG_MD5 249 /* Keyed MD5 */ #define SADB_X_AALG_SHA 250 /* Keyed SHA */ #define SADB_X_AALG_NULL 251 /* null authentication */ #define SADB_X_AALG_TCP_MD5 252 /* Keyed TCP-MD5 (RFC2385) */ -/* RFC2367 numbers - meets RFC2407 */ #define SADB_EALG_NONE 0 #define SADB_EALG_DESCBC 2 #define SADB_EALG_3DESCBC 3 -#define SADB_EALG_NULL 11 -#define SADB_EALG_MAX 250 -/* private allocations - based on RFC2407/IANA assignment */ #define SADB_X_EALG_CAST128CBC 6 #define SADB_X_EALG_BLOWFISHCBC 7 +#define SADB_EALG_NULL 11 #define SADB_X_EALG_RIJNDAELCBC 12 #define SADB_X_EALG_AES 12 -/* private allocations - based on RFC4312/IANA assignment */ -#define SADB_X_EALG_CAMELLIACBC 22 -/* private allocations should use 249-255 (RFC2407) */ -#define SADB_X_EALG_SKIPJACK 249 /*250*/ /* for IPSEC */ -#define SADB_X_EALG_AESCTR 250 /*249*/ /* draft-ietf-ipsec-ciph-aes-ctr-03 */ +#define SADB_X_EALG_AESCTR 13 +#define SADB_X_EALG_AESGCM8 18 /* RFC4106 */ +#define SADB_X_EALG_AESGCM12 19 +#define SADB_X_EALG_AESGCM16 20 +#define SADB_X_EALG_CAMELLIACBC 22 +#define SADB_X_EALG_AESGMAC 23 /* RFC4543 + Errata1821 */ +#define SADB_EALG_MAX 23 /* !!! keep updated !!! */ /* private allocations - based on RFC2407/IANA assignment */ #define SADB_X_CALG_NONE 0 diff --git a/sys/net/pfvar.h b/sys/net/pfvar.h index ae5ecb9..e46bb69 100644 --- a/sys/net/pfvar.h +++ b/sys/net/pfvar.h @@ -198,10 +198,11 @@ extern struct rwlock pf_rules_lock; (a)->addr32[0] == (b)->addr32[0])) \ #define PF_ANEQ(a, b, c) \ - ((a)->addr32[0] != (b)->addr32[0] || \ + ((c == AF_INET && (a)->addr32[0] != (b)->addr32[0]) || \ + (c == AF_INET6 && ((a)->addr32[0] != (b)->addr32[0] || \ (a)->addr32[1] != (b)->addr32[1] || \ (a)->addr32[2] != (b)->addr32[2] || \ - (a)->addr32[3] != (b)->addr32[3]) \ + (a)->addr32[3] != (b)->addr32[3]))) \ #define PF_AZERO(a, c) \ ((c == AF_INET && !(a)->addr32[0]) || \ @@ -326,6 +327,14 @@ struct pf_rule_gid { u_int8_t op; }; +struct pf_rule_ieee8021q_pcp { + u_int8_t pcp[2]; + u_int8_t op; +#define SETPCP_VALID 0x80 /* Set if PCP value in field is valid. */ +#define SETPCP_PCP_MASK 0x07 /* Mask to retrieve pcp if SETPCP_VALID. */ + u_int8_t setpcp; +}; + struct pf_rule_addr { struct pf_addr_wrap addr; u_int16_t port[2]; @@ -465,6 +474,13 @@ struct pf_osfp_ioctl { int fp_getnum; /* DIOCOSFPGET number */ }; +struct pf_rule_actions { + u_int16_t qid; + u_int16_t pqid; + u_int32_t pdnpipe; + u_int32_t dnpipe; + u_int8_t flags; +}; union pf_rule_ptr { struct pf_rule *ptr; @@ -488,6 +504,7 @@ struct pf_rule { union pf_rule_ptr skip[PF_SKIP_COUNT]; #define PF_RULE_LABEL_SIZE 64 char label[PF_RULE_LABEL_SIZE]; + char schedule[PF_RULE_LABEL_SIZE]; char ifname[IFNAMSIZ]; char qname[PF_QNAME_SIZE]; char pqname[PF_QNAME_SIZE]; @@ -520,12 +537,21 @@ struct pf_rule { u_int32_t limit; u_int32_t seconds; } max_src_conn_rate; - u_int32_t qid; - u_int32_t pqid; + u_int16_t qid; + u_int16_t pqid; + u_int32_t dnpipe; + u_int32_t pdnpipe; +#define PFRULE_DN_IS_PIPE 0x00000010 +#define PFRULE_DN_IS_QUEUE 0x00000020 + u_int32_t free_flags; u_int32_t rt_listid; u_int32_t nr; u_int32_t prob; +#ifdef PF_USER_INFO uid_t cuid; +#else + u_int32_t cuid; +#endif pid_t cpid; counter_u64_t states_cur; @@ -566,6 +592,29 @@ struct pf_rule { u_int8_t allow_opts; u_int8_t rt; u_int8_t return_ttl; + +#ifndef DSCP_EF +/* Copied from altq_cdnr.h */ +/* diffserve code points */ +#define DSCP_MASK 0xfc +#define DSCP_CUMASK 0x03 +#define DSCP_VA 0xb0 +#define DSCP_EF 0xb8 +#define DSCP_AF11 0x28 +#define DSCP_AF12 0x30 +#define DSCP_AF13 0x38 +#define DSCP_AF21 0x48 +#define DSCP_AF22 0x50 +#define DSCP_AF23 0x58 +#define DSCP_AF31 0x68 +#define DSCP_AF32 0x70 +#define DSCP_AF33 0x78 +#define DSCP_AF41 0x88 +#define DSCP_AF42 0x90 +#define DSCP_AF43 0x98 +#define AF_CLASSMASK 0xe0 +#define AF_DROPPRECMASK 0x18 +#endif u_int8_t tos; u_int8_t set_tos; u_int8_t anchor_relative; @@ -580,6 +629,8 @@ struct pf_rule { u_int16_t port; } divert; + struct pf_rule_ieee8021q_pcp ieee8021q_pcp; + uint64_t u_states_cur; uint64_t u_states_tot; uint64_t u_src_nodes; @@ -604,6 +655,13 @@ struct pf_rule { #define PFRULE_REASSEMBLE_TCP 0x1000 #define PFRULE_SET_TOS 0x2000 +/* rule flags for TOS or DSCP differentiation */ +#define PFRULE_TOS 0x2000 +#define PFRULE_DSCP 0x4000 + +/* rule flags for handling ALTQ hashing required by certain disciplines */ +#define PFRULE_ALTQ_HASH 0x8000 + /* rule flags again */ #define PFRULE_IFBOUND 0x00010000 /* if-bound */ #define PFRULE_STATESLOPPY 0x00020000 /* sloppy state tracking */ @@ -708,7 +766,13 @@ struct pf_state { u_int64_t id; u_int32_t creatorid; u_int8_t direction; - u_int8_t pad[3]; + u_int8_t pad[2]; + u_int8_t local_flags; +#define PFSTATE_DIVERT_ALTQ 0x10 +#define PFSTATE_DIVERT_DNCOOKIE 0x20 +#define PFSTATE_DIVERT_ACTION 0x40 +#define PFSTATE_DIVERT_TAG 0x80 +#define PFSTATE_DIVERT_MASK 0xFF00 u_int refs; TAILQ_ENTRY(pf_state) sync_list; @@ -730,7 +794,12 @@ struct pf_state { u_int32_t creation; u_int32_t expire; u_int32_t pfsync_time; + u_int16_t qid; + u_int16_t pqid; + u_int32_t pdnpipe; + u_int32_t dnpipe; u_int16_t tag; + u_int16_t divert_cookie; u_int8_t log; u_int8_t state_flags; #define PFSTATE_ALLOWOPTS 0x01 @@ -743,7 +812,7 @@ struct pf_state { /* XXX */ u_int8_t sync_updates; - u_int8_t _tail[3]; + u_int8_t _tail; }; /* @@ -1079,11 +1148,13 @@ struct pfi_kif { #define PFI_IFLAG_SKIP 0x0100 /* skip filtering on interface */ struct pf_pdesc { +#ifdef PF_USER_INFO struct { int done; uid_t uid; gid_t gid; } lookup; +#endif u_int64_t tot_len; /* Make Mickey money */ union { struct tcphdr *tcp; @@ -1101,6 +1172,7 @@ struct pf_pdesc { u_int16_t *sport; u_int16_t *dport; struct pf_mtag *pf_mtag; + struct pf_rule_actions act; u_int32_t p_len; /* total length of payload */ @@ -1252,6 +1324,11 @@ struct pfioc_state_kill { u_int psk_killed; }; +struct pfioc_schedule_kill { + int numberkilled; + char schedule[PF_RULE_LABEL_SIZE]; +}; + struct pfioc_states { int ps_len; union { @@ -1330,6 +1407,9 @@ struct pfioc_trans { #ifdef _KERNEL #define PFR_FLAG_USERIOCTL 0x10000000 #endif +#define DIOCGETNAMEDALTQ _IOWR('D', 94, struct pfioc_ruleset) +#define DIOCGETNAMEDTAG _IOR('D', 95, u_int32_t) +#define DIOCKILLSCHEDULE _IOWR('D', 96, struct pfioc_schedule_kill) struct pfioc_table { struct pfr_table pfrio_table; @@ -1594,6 +1674,8 @@ int pf_match_addr(u_int8_t, struct pf_addr *, struct pf_addr *, int pf_match_addr_range(struct pf_addr *, struct pf_addr *, struct pf_addr *, sa_family_t); int pf_match_port(u_int8_t, u_int16_t, u_int16_t, u_int16_t); +int pf_match_ieee8021q_pcp(u_int8_t, u_int8_t, u_int8_t, struct mbuf *); +int pf_ieee8021q_setpcp(struct mbuf *m, struct pf_rule *r); void pf_normalize_init(void); void pf_normalize_cleanup(void); diff --git a/sys/net80211/ieee80211.c b/sys/net80211/ieee80211.c index db505ab..2fa7e9a 100644 --- a/sys/net80211/ieee80211.c +++ b/sys/net80211/ieee80211.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> @@ -237,7 +238,7 @@ static int null_transmit(struct ifnet *ifp, struct mbuf *m) { m_freem(m); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return EACCES; /* XXX EIO/EPERM? */ } @@ -569,15 +570,9 @@ ieee80211_vap_attach(struct ieee80211vap *vap, ifp->if_baudrate = IF_Mbps(maxrate); ether_ifattach(ifp, vap->iv_myaddr); - if (vap->iv_opmode == IEEE80211_M_MONITOR) { - /* NB: disallow transmit */ - ifp->if_transmit = null_transmit; - ifp->if_output = null_output; - } else { - /* hook output method setup by ether_ifattach */ - vap->iv_output = ifp->if_output; - ifp->if_output = ieee80211_output; - } + /* hook output method setup by ether_ifattach */ + vap->iv_output = ifp->if_output; + ifp->if_output = ieee80211_output; /* NB: if_mtu set by ether_ifattach to ETHERMTU */ IEEE80211_LOCK(ic); @@ -1407,7 +1402,8 @@ ieee80211_media_status(struct ifnet *ifp, struct ifmediareq *imr) * rate only when running; otherwise we may have a mismatch * in which case the rate will not be convertible. */ - if (vap->iv_state == IEEE80211_S_RUN) { + if (vap->iv_state == IEEE80211_S_RUN || + vap->iv_state == IEEE80211_S_SLEEP) { imr->ifm_status |= IFM_ACTIVE; mode = ieee80211_chan2mode(ic->ic_curchan); } else @@ -1751,3 +1747,23 @@ ieee80211_mac_hash(const struct ieee80211com *ic, return c; } #undef mix + +char +ieee80211_channel_type_char(const struct ieee80211_channel *c) +{ + if (IEEE80211_IS_CHAN_ST(c)) + return 'S'; + if (IEEE80211_IS_CHAN_108A(c)) + return 'T'; + if (IEEE80211_IS_CHAN_108G(c)) + return 'G'; + if (IEEE80211_IS_CHAN_HT(c)) + return 'n'; + if (IEEE80211_IS_CHAN_A(c)) + return 'a'; + if (IEEE80211_IS_CHAN_ANYG(c)) + return 'g'; + if (IEEE80211_IS_CHAN_B(c)) + return 'b'; + return 'f'; +} diff --git a/sys/net80211/ieee80211.h b/sys/net80211/ieee80211.h index 9b005f3..8e586bd 100644 --- a/sys/net80211/ieee80211.h +++ b/sys/net80211/ieee80211.h @@ -169,6 +169,11 @@ struct ieee80211_qosframe_addr4 { #define IEEE80211_FC1_PROTECTED 0x40 #define IEEE80211_FC1_ORDER 0x80 +#define IEEE80211_HAS_SEQ(type, subtype) \ + ((type) != IEEE80211_FC0_TYPE_CTL && \ + !((type) == IEEE80211_FC0_TYPE_DATA && \ + ((subtype) & IEEE80211_FC0_SUBTYPE_QOS_NULL) == \ + IEEE80211_FC0_SUBTYPE_QOS_NULL)) #define IEEE80211_SEQ_FRAG_MASK 0x000f #define IEEE80211_SEQ_FRAG_SHIFT 0 #define IEEE80211_SEQ_SEQ_MASK 0xfff0 diff --git a/sys/net80211/ieee80211_action.c b/sys/net80211/ieee80211_action.c index a36df7c..e37863e 100644 --- a/sys/net80211/ieee80211_action.c +++ b/sys/net80211/ieee80211_action.c @@ -42,6 +42,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> diff --git a/sys/net80211/ieee80211_adhoc.c b/sys/net80211/ieee80211_adhoc.c index e9e0d30..0d761c4 100644 --- a/sys/net80211/ieee80211_adhoc.c +++ b/sys/net80211/ieee80211_adhoc.c @@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_llc.h> #include <net/ethernet.h> @@ -228,6 +229,8 @@ adhoc_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) } #endif break; + case IEEE80211_S_RUN: /* IBSS merge */ + break; default: goto invalid; } @@ -288,7 +291,6 @@ doprint(struct ieee80211vap *vap, int subtype) static int adhoc_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) { -#define HAS_SEQ(type) ((type & 0x4) == 0) struct ieee80211vap *vap = ni->ni_vap; struct ieee80211com *ic = ni->ni_ic; struct ifnet *ifp = vap->iv_ifp; @@ -368,7 +370,10 @@ adhoc_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) /* * Validate the bssid. */ - if (!IEEE80211_ADDR_EQ(bssid, vap->iv_bss->ni_bssid) && + if (!(type == IEEE80211_FC0_TYPE_MGT && + (subtype == IEEE80211_FC0_SUBTYPE_BEACON || + subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)) && + !IEEE80211_ADDR_EQ(bssid, vap->iv_bss->ni_bssid) && !IEEE80211_ADDR_EQ(bssid, ifp->if_broadcastaddr)) { /* not interested in */ IEEE80211_DISCARD_MAC(vap, IEEE80211_MSG_INPUT, @@ -408,7 +413,8 @@ adhoc_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) } IEEE80211_RSSI_LPF(ni->ni_avgrssi, rssi); ni->ni_noise = nf; - if (HAS_SEQ(type)) { + if (IEEE80211_HAS_SEQ(type, subtype) && + IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) { uint8_t tid = ieee80211_gettid(wh); if (IEEE80211_QOS_HAS_SEQ(wh) && TID_TO_WME_AC(tid) >= WME_AC_VI) @@ -652,7 +658,7 @@ adhoc_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) break; } err: - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); out: if (m != NULL) { if (need_tap && ieee80211_radiotap_active_vap(vap)) @@ -729,7 +735,8 @@ adhoc_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, ieee80211_probe_curchan(vap, 1); ic->ic_flags_ext &= ~IEEE80211_FEXT_PROBECHAN; } - ieee80211_add_scan(vap, &scan, wh, subtype, rssi, nf); + ieee80211_add_scan(vap, ic->ic_curchan, &scan, wh, + subtype, rssi, nf); return; } if (scan.capinfo & IEEE80211_CAPINFO_IBSS) { diff --git a/sys/net80211/ieee80211_ageq.c b/sys/net80211/ieee80211_ageq.c index 018ddc2..b650136 100644 --- a/sys/net80211/ieee80211_ageq.c +++ b/sys/net80211/ieee80211_ageq.c @@ -38,6 +38,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> diff --git a/sys/net80211/ieee80211_alq.c b/sys/net80211/ieee80211_alq.c index e651574..a52103a 100644 --- a/sys/net80211/ieee80211_alq.c +++ b/sys/net80211/ieee80211_alq.c @@ -53,10 +53,8 @@ __FBSDID("$FreeBSD$"); #include <net/if.h> #include <net/if_var.h> -#include <net/if_dl.h> -#include <net/if_clone.h> #include <net/if_media.h> -#include <net/if_types.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_freebsd.h> diff --git a/sys/net80211/ieee80211_amrr.c b/sys/net80211/ieee80211_amrr.c index 003b4bc..b1d92c8 100644 --- a/sys/net80211/ieee80211_amrr.c +++ b/sys/net80211/ieee80211_amrr.c @@ -38,7 +38,9 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> +#include <net/ethernet.h> #ifdef INET #include <netinet/in.h> @@ -129,6 +131,12 @@ amrr_deinit(struct ieee80211vap *vap) free(vap->iv_rs, M_80211_RATECTL); } +/* + * Return whether 11n rates are possible. + * + * Some 11n devices may return HT information but no HT rates. + * Thus, we shouldn't treat them as an 11n node. + */ static int amrr_node_is_11n(struct ieee80211_node *ni) { @@ -137,6 +145,8 @@ amrr_node_is_11n(struct ieee80211_node *ni) return (0); if (ni->ni_chan == IEEE80211_CHAN_ANYC) return (0); + if (IEEE80211_IS_CHAN_HT(ni->ni_chan) && ni->ni_htrates.rs_nrates == 0) + return (0); return (IEEE80211_IS_CHAN_HT(ni->ni_chan)); } @@ -185,17 +195,18 @@ amrr_node_init(struct ieee80211_node *ni) rate &= IEEE80211_RATE_VAL; /* pick initial rate from the rateset - HT or otherwise */ + /* Pick something low that's likely to succeed */ 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) + /* 11n - stop at MCS4 */ + if (amrr_node_is_11n(ni)) { + if ((rs->rs_rates[amn->amn_rix] & 0x1f) < 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; } + 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)) diff --git a/sys/net80211/ieee80211_ddb.c b/sys/net80211/ieee80211_ddb.c index 6f7dabf..74e82e5 100644 --- a/sys/net80211/ieee80211_ddb.c +++ b/sys/net80211/ieee80211_ddb.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/if_types.h> diff --git a/sys/net80211/ieee80211_dfs.c b/sys/net80211/ieee80211_dfs.c index 82e525d..5fa9ba4 100644 --- a/sys/net80211/ieee80211_dfs.c +++ b/sys/net80211/ieee80211_dfs.c @@ -48,7 +48,9 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> diff --git a/sys/net80211/ieee80211_freebsd.c b/sys/net80211/ieee80211_freebsd.c index 8c97f1e..0822058 100644 --- a/sys/net80211/ieee80211_freebsd.c +++ b/sys/net80211/ieee80211_freebsd.c @@ -44,6 +44,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_clone.h> #include <net/if_media.h> @@ -419,7 +420,7 @@ ieee80211_getmgtframe(uint8_t **frm, int headroom, int pktlen) * frames which all fit in MHLEN. */ if (m != NULL) - MH_ALIGN(m, len); + M_ALIGN(m, len); } else { m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); if (m != NULL) @@ -872,14 +873,8 @@ wlan_modevent(module_t mod, int type, void *unused) printf("wlan: <802.11 Link Layer>\n"); wlan_bpfevent = EVENTHANDLER_REGISTER(bpf_track, bpf_track, 0, EVENTHANDLER_PRI_ANY); - if (wlan_bpfevent == NULL) - return ENOMEM; wlan_ifllevent = EVENTHANDLER_REGISTER(iflladdr_event, wlan_iflladdr, NULL, EVENTHANDLER_PRI_ANY); - if (wlan_ifllevent == NULL) { - EVENTHANDLER_DEREGISTER(bpf_track, wlan_bpfevent); - return ENOMEM; - } #if __FreeBSD_version >= 1000020 wlan_cloner = if_clone_simple(wlanname, wlan_clone_create, wlan_clone_destroy, 0); diff --git a/sys/net80211/ieee80211_freebsd.h b/sys/net80211/ieee80211_freebsd.h index 711bac3..aa21f3b 100644 --- a/sys/net80211/ieee80211_freebsd.h +++ b/sys/net80211/ieee80211_freebsd.h @@ -355,8 +355,8 @@ wlan_##name##_modevent(module_t mod, int type, void *unused) \ case MOD_UNLOAD: \ case MOD_QUIESCE: \ if (nrefs) { \ - printf("wlan_##name: still in use (%u dynamic refs)\n",\ - nrefs); \ + printf("wlan_" #name ": still in use " \ + "(%u dynamic refs)\n", nrefs); \ return EBUSY; \ } \ if (type == MOD_UNLOAD) { \ diff --git a/sys/net80211/ieee80211_hostap.c b/sys/net80211/ieee80211_hostap.c index 832a8b0..a625b4e 100644 --- a/sys/net80211/ieee80211_hostap.c +++ b/sys/net80211/ieee80211_hostap.c @@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_llc.h> #include <net/ethernet.h> @@ -367,7 +368,7 @@ hostap_deliver_data(struct ieee80211vap *vap, /* * Do accounting. */ - ifp->if_ipackets++; + if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); IEEE80211_NODE_STAT(ni, rx_data); IEEE80211_NODE_STAT_ADD(ni, rx_bytes, m->m_pkthdr.len); if (ETHER_IS_MULTICAST(eh->ether_dhost)) { @@ -383,7 +384,7 @@ hostap_deliver_data(struct ieee80211vap *vap, if (m->m_flags & M_MCAST) { mcopy = m_dup(m, M_NOWAIT); if (mcopy == NULL) - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); else mcopy->m_flags |= M_MCAST; } else { @@ -421,7 +422,7 @@ hostap_deliver_data(struct ieee80211vap *vap, if (err) { /* NB: IFQ_HANDOFF reclaims mcopy */ } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); } } } @@ -477,7 +478,6 @@ doprint(struct ieee80211vap *vap, int subtype) static int hostap_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) { -#define HAS_SEQ(type) ((type & 0x4) == 0) struct ieee80211vap *vap = ni->ni_vap; struct ieee80211com *ic = ni->ni_ic; struct ifnet *ifp = vap->iv_ifp; @@ -570,7 +570,7 @@ hostap_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) IEEE80211_RSSI_LPF(ni->ni_avgrssi, rssi); ni->ni_noise = nf; - if (HAS_SEQ(type)) { + if (IEEE80211_HAS_SEQ(type, subtype)) { uint8_t tid = ieee80211_gettid(wh); if (IEEE80211_QOS_HAS_SEQ(wh) && TID_TO_WME_AC(tid) >= WME_AC_VI) @@ -908,7 +908,7 @@ hostap_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) break; } err: - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); out: if (m != NULL) { if (need_tap && ieee80211_radiotap_active_vap(vap)) @@ -1736,7 +1736,8 @@ hostap_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, ieee80211_probe_curchan(vap, 1); ic->ic_flags_ext &= ~IEEE80211_FEXT_PROBECHAN; } - ieee80211_add_scan(vap, &scan, wh, subtype, rssi, nf); + ieee80211_add_scan(vap, ic->ic_curchan, &scan, wh, + subtype, rssi, nf); return; } /* diff --git a/sys/net80211/ieee80211_ht.c b/sys/net80211/ieee80211_ht.c index 16135e1..618252f 100644 --- a/sys/net80211/ieee80211_ht.c +++ b/sys/net80211/ieee80211_ht.c @@ -43,6 +43,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> @@ -1046,6 +1047,7 @@ ieee80211_ht_node_init(struct ieee80211_node *ni) tap = &ni->ni_tx_ampdu[tid]; tap->txa_tid = tid; tap->txa_ni = ni; + tap->txa_lastsample = ticks; /* NB: further initialization deferred */ } ni->ni_flags |= IEEE80211_NODE_HT | IEEE80211_NODE_AMPDU; @@ -1215,6 +1217,7 @@ ieee80211_ht_wds_init(struct ieee80211_node *ni) for (tid = 0; tid < WME_NUM_TID; tid++) { tap = &ni->ni_tx_ampdu[tid]; tap->txa_tid = tid; + tap->txa_lastsample = ticks; } /* NB: AMPDU tx/rx governed by IEEE80211_FHT_AMPDU_{TX,RX} */ ni->ni_flags |= IEEE80211_NODE_HT | IEEE80211_NODE_AMPDU; @@ -1690,6 +1693,7 @@ ampdu_tx_setup(struct ieee80211_tx_ampdu *tap) { callout_init(&tap->txa_timer, CALLOUT_MPSAFE); tap->txa_flags |= IEEE80211_AGGR_SETUP; + tap->txa_lastsample = ticks; } static void @@ -1717,8 +1721,12 @@ ampdu_tx_stop(struct ieee80211_tx_ampdu *tap) */ bar_stop_timer(tap); - tap->txa_lastsample = 0; + /* + * Reset packet estimate. + */ + tap->txa_lastsample = ticks; tap->txa_avgpps = 0; + /* NB: clearing NAK means we may re-send ADDBA */ tap->txa_flags &= ~(IEEE80211_AGGR_SETUP | IEEE80211_AGGR_NAK); } @@ -2654,10 +2662,24 @@ ieee80211_add_htcap_body(uint8_t *frm, struct ieee80211_node *ni) caps |= IEEE80211_HTCAP_CHWIDTH40; else caps &= ~IEEE80211_HTCAP_CHWIDTH40; - /* use advertised setting (XXX locally constraint) */ + + /* Start by using the advertised settings */ rxmax = MS(ni->ni_htparam, IEEE80211_HTCAP_MAXRXAMPDU); density = MS(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY); + /* Cap at VAP rxmax */ + if (rxmax > vap->iv_ampdu_rxmax) + rxmax = vap->iv_ampdu_rxmax; + + /* + * If the VAP ampdu density value greater, use that. + * + * (Larger density value == larger minimum gap between A-MPDU + * subframes.) + */ + if (vap->iv_ampdu_density > density) + density = vap->iv_ampdu_density; + /* * NB: Hardware might support HT40 on some but not all * channels. We can't determine this earlier because only @@ -2674,9 +2696,12 @@ ieee80211_add_htcap_body(uint8_t *frm, struct ieee80211_node *ni) caps |= IEEE80211_HTCAP_CHWIDTH40; else caps &= ~IEEE80211_HTCAP_CHWIDTH40; + + /* XXX TODO should it start by using advertised settings? */ rxmax = vap->iv_ampdu_rxmax; density = vap->iv_ampdu_density; } + /* adjust short GI based on channel and config */ if ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20) == 0) caps &= ~IEEE80211_HTCAP_SHORTGI20; diff --git a/sys/net80211/ieee80211_input.c b/sys/net80211/ieee80211_input.c index 5e95646..a0f737d 100644 --- a/sys/net80211/ieee80211_input.c +++ b/sys/net80211/ieee80211_input.c @@ -40,6 +40,7 @@ __FBSDID("$FreeBSD$"); #include <net/ethernet.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_llc.h> #include <net/if_media.h> #include <net/if_vlan_var.h> @@ -260,7 +261,7 @@ ieee80211_deliver_data(struct ieee80211vap *vap, /* * Do accounting. */ - ifp->if_ipackets++; + if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); IEEE80211_NODE_STAT(ni, rx_data); IEEE80211_NODE_STAT_ADD(ni, rx_bytes, m->m_pkthdr.len); if (ETHER_IS_MULTICAST(eh->ether_dhost)) { diff --git a/sys/net80211/ieee80211_input.h b/sys/net80211/ieee80211_input.h index b90f46a..f3d569e 100644 --- a/sys/net80211/ieee80211_input.h +++ b/sys/net80211/ieee80211_input.h @@ -168,19 +168,22 @@ ieee80211_check_rxseq(struct ieee80211_node *ni, struct ieee80211_frame *wh) { #define SEQ_LEQ(a,b) ((int)((a)-(b)) <= 0) #define SEQ_EQ(a,b) ((int)((a)-(b)) == 0) -#define HAS_SEQ(type) ((type & 0x4) == 0) #define SEQNO(a) ((a) >> IEEE80211_SEQ_SEQ_SHIFT) #define FRAGNO(a) ((a) & IEEE80211_SEQ_FRAG_MASK) uint16_t rxseq; - uint8_t type; + uint8_t type, subtype; uint8_t tid; struct ieee80211_rx_ampdu *rap; rxseq = le16toh(*(uint16_t *)wh->i_seq); type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; + subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; - /* Types with no sequence number are always treated valid */ - if (! HAS_SEQ(type)) + /* + * Types with no sequence number (or QoS (+)Null frames) + * are always treated valid. + */ + if (! IEEE80211_HAS_SEQ(type, subtype)) return 1; tid = ieee80211_gettid(wh); @@ -235,7 +238,6 @@ ieee80211_check_rxseq(struct ieee80211_node *ni, struct ieee80211_frame *wh) return 1; #undef SEQ_LEQ #undef SEQ_EQ -#undef HAS_SEQ #undef SEQNO #undef FRAGNO } diff --git a/sys/net80211/ieee80211_ioctl.c b/sys/net80211/ieee80211_ioctl.c index 6b668cb..2798d80 100644 --- a/sys/net80211/ieee80211_ioctl.c +++ b/sys/net80211/ieee80211_ioctl.c @@ -32,7 +32,6 @@ __FBSDID("$FreeBSD$"); */ #include "opt_inet.h" -#include "opt_ipx.h" #include "opt_wlan.h" #include <sys/endian.h> @@ -44,6 +43,7 @@ __FBSDID("$FreeBSD$"); #include <sys/systm.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_dl.h> #include <net/if_media.h> #include <net/ethernet.h> @@ -53,11 +53,6 @@ __FBSDID("$FreeBSD$"); #include <netinet/if_ether.h> #endif -#ifdef IPX -#include <netipx/ipx.h> -#include <netipx/ipx_if.h> -#endif - #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_ioctl.h> #include <net80211/ieee80211_regdomain.h> @@ -607,7 +602,7 @@ ieee80211_ioctl_getcurchan(struct ieee80211vap *vap, struct ieee80211req *ireq) * in use. When in RUN state report the vap-specific channel. * Otherwise return curchan. */ - if (vap->iv_state == IEEE80211_S_RUN) + if (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) c = vap->iv_bss->ni_chan; else c = ic->ic_curchan; @@ -925,7 +920,7 @@ ieee80211_ioctl_get80211(struct ieee80211vap *vap, u_long cmd, case IEEE80211_IOC_BSSID: if (ireq->i_len != IEEE80211_ADDR_LEN) return EINVAL; - if (vap->iv_state == IEEE80211_S_RUN) { + if (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) { error = copyout(vap->iv_opmode == IEEE80211_M_WDS ? vap->iv_bss->ni_macaddr : vap->iv_bss->ni_bssid, ireq->i_data, ireq->i_len); @@ -1031,7 +1026,7 @@ ieee80211_ioctl_get80211(struct ieee80211vap *vap, u_long cmd, case IEEE80211_IOC_AMPDU_LIMIT: if (vap->iv_opmode == IEEE80211_M_HOSTAP) ireq->i_val = vap->iv_ampdu_rxmax; - else if (vap->iv_state == IEEE80211_S_RUN) + else if (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) ireq->i_val = MS(vap->iv_bss->ni_htparam, IEEE80211_HTCAP_MAXRXAMPDU); else @@ -1039,7 +1034,7 @@ ieee80211_ioctl_get80211(struct ieee80211vap *vap, u_long cmd, break; case IEEE80211_IOC_AMPDU_DENSITY: if (vap->iv_opmode == IEEE80211_M_STA && - vap->iv_state == IEEE80211_S_RUN) + (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) ireq->i_val = MS(vap->iv_bss->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY); else @@ -1113,7 +1108,7 @@ ieee80211_ioctl_get80211(struct ieee80211vap *vap, u_long cmd, break; case IEEE80211_IOC_SMPS: if (vap->iv_opmode == IEEE80211_M_STA && - vap->iv_state == IEEE80211_S_RUN) { + (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) { if (vap->iv_bss->ni_flags & IEEE80211_NODE_MIMO_RTS) ireq->i_val = IEEE80211_HTCAP_SMPS_DYNAMIC; else if (vap->iv_bss->ni_flags & IEEE80211_NODE_MIMO_PS) @@ -1125,7 +1120,7 @@ ieee80211_ioctl_get80211(struct ieee80211vap *vap, u_long cmd, break; case IEEE80211_IOC_RIFS: if (vap->iv_opmode == IEEE80211_M_STA && - vap->iv_state == IEEE80211_S_RUN) + (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) ireq->i_val = (vap->iv_bss->ni_flags & IEEE80211_NODE_RIFS) != 0; else @@ -1954,7 +1949,7 @@ setcurchan(struct ieee80211vap *vap, struct ieee80211_channel *c) if (IEEE80211_IS_CHAN_NOADHOC(c)) return EINVAL; } - if (vap->iv_state == IEEE80211_S_RUN && + if ((vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) && vap->iv_bss->ni_chan == c) return 0; /* NB: nothing to do */ } @@ -3419,24 +3414,6 @@ ieee80211_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) arp_ifinit(ifp, ifa); break; #endif -#ifdef IPX - /* - * XXX - This code is probably wrong, - * but has been copied many times. - */ - case AF_IPX: { - struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr); - - if (ipx_nullhost(*ina)) - ina->x_host = *(union ipx_host *) - IF_LLADDR(ifp); - else - bcopy((caddr_t) ina->x_host.c_host, - (caddr_t) IF_LLADDR(ifp), - ETHER_ADDR_LEN); - /* fall thru... */ - } -#endif default: if ((ifp->if_flags & IFF_UP) == 0) { ifp->if_flags |= IFF_UP; diff --git a/sys/net80211/ieee80211_mesh.c b/sys/net80211/ieee80211_mesh.c index a06b241..24969a2 100644 --- a/sys/net80211/ieee80211_mesh.c +++ b/sys/net80211/ieee80211_mesh.c @@ -54,6 +54,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_llc.h> #include <net/ethernet.h> @@ -1046,7 +1047,7 @@ mesh_transmit_to_gate(struct ieee80211vap *vap, struct mbuf *m, ni = ieee80211_mesh_find_txnode(vap, rt_gate->rt_dest); if (ni == NULL) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(m); return; } @@ -1182,7 +1183,7 @@ mesh_forward(struct ieee80211vap *vap, struct mbuf *m, IEEE80211_NOTE_FRAME(vap, IEEE80211_MSG_MESH, wh, "%s", "frame not fwd'd, cannot dup"); vap->iv_stats.is_mesh_fwd_nobuf++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return; } mcopy = m_pullup(mcopy, ieee80211_hdrspace(ic, wh) + @@ -1191,7 +1192,7 @@ mesh_forward(struct ieee80211vap *vap, struct mbuf *m, IEEE80211_NOTE_FRAME(vap, IEEE80211_MSG_MESH, wh, "%s", "frame not fwd'd, too short"); vap->iv_stats.is_mesh_fwd_tooshort++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(mcopy); return; } @@ -1249,7 +1250,7 @@ mesh_forward(struct ieee80211vap *vap, struct mbuf *m, /* NB: IFQ_HANDOFF reclaims mbuf */ ieee80211_free_node(ni); } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); } } @@ -1843,7 +1844,7 @@ mesh_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) break; } err: - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); out: if (m != NULL) { if (need_tap && ieee80211_radiotap_active_vap(vap)) @@ -1905,7 +1906,7 @@ mesh_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, int subtype, ieee80211_probe_curchan(vap, 1); ic->ic_flags_ext &= ~IEEE80211_FEXT_PROBECHAN; } - ieee80211_add_scan(vap, &scan, wh, + ieee80211_add_scan(vap, ic->ic_curchan, &scan, wh, subtype, rssi, nf); return; } @@ -2692,7 +2693,7 @@ mesh_send_action(struct ieee80211_node *ni, return EIO; /* XXX */ } - M_PREPEND(m, sizeof(struct ieee80211_frame), M_DONTWAIT); + M_PREPEND(m, sizeof(struct ieee80211_frame), M_NOWAIT); if (m == NULL) { ieee80211_free_node(ni); return ENOMEM; @@ -3333,7 +3334,7 @@ mesh_airtime_calc(struct ieee80211_node *ni) /* Error rate in percentage */ /* XXX assuming small failures are ok */ errrate = (((ifp->if_oerrors + - ifp->if_ierrors) / 100) << M_BITS) / 100; + ifp->if_ierrors) / 100) << M_BITS) / 100; res = (overhead + (nbits / rate)) * ((1 << S_FACTOR) / ((1 << M_BITS) - errrate)); diff --git a/sys/net80211/ieee80211_monitor.c b/sys/net80211/ieee80211_monitor.c index e324081..8909339 100644 --- a/sys/net80211/ieee80211_monitor.c +++ b/sys/net80211/ieee80211_monitor.c @@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_llc.h> #include <net/ethernet.h> @@ -129,7 +130,7 @@ monitor_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) struct ieee80211vap *vap = ni->ni_vap; struct ifnet *ifp = vap->iv_ifp; - ifp->if_ipackets++; + if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); if (ieee80211_radiotap_active_vap(vap)) ieee80211_radiotap_rx(vap, m); diff --git a/sys/net80211/ieee80211_node.c b/sys/net80211/ieee80211_node.c index 4169255..c84f9a8 100644 --- a/sys/net80211/ieee80211_node.c +++ b/sys/net80211/ieee80211_node.c @@ -38,6 +38,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> @@ -92,6 +93,8 @@ static void node_getmimoinfo(const struct ieee80211_node *, static void _ieee80211_free_node(struct ieee80211_node *); +static void node_reclaim(struct ieee80211_node_table *nt, + struct ieee80211_node *ni); static void ieee80211_node_table_init(struct ieee80211com *ic, struct ieee80211_node_table *nt, const char *name, int inact, int keymaxix); @@ -718,9 +721,15 @@ ieee80211_sta_join1(struct ieee80211_node *selbs) IEEE80211_ADDR_EQ(obss->ni_macaddr, selbs->ni_macaddr)); vap->iv_bss = selbs; /* NB: caller assumed to bump refcnt */ if (obss != NULL) { + struct ieee80211_node_table *nt = obss->ni_table; + copy_bss(selbs, obss); ieee80211_node_decref(obss); /* iv_bss reference */ - ieee80211_free_node(obss); /* station table reference */ + + IEEE80211_NODE_LOCK(nt); + node_reclaim(nt, obss); /* station table reference */ + IEEE80211_NODE_UNLOCK(nt); + obss = NULL; /* NB: guard against later use */ } @@ -870,7 +879,7 @@ ieee80211_sta_leave(struct ieee80211_node *ni) void ieee80211_node_deauth(struct ieee80211_node *ni, int reason) { - /* NB: bump the refcnt to be sure temporay nodes are not reclaimed */ + /* NB: bump the refcnt to be sure temporary nodes are not reclaimed */ ieee80211_ref_node(ni); if (ni->ni_associd != 0) IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_DEAUTH, reason); @@ -1748,6 +1757,28 @@ _ieee80211_free_node(struct ieee80211_node *ni) ni->ni_ic->ic_node_free(ni); } +/* + * Clear any entry in the unicast key mapping table. + */ +static int +node_clear_keyixmap(struct ieee80211_node_table *nt, struct ieee80211_node *ni) +{ + ieee80211_keyix keyix; + + keyix = ni->ni_ucastkey.wk_rxkeyix; + if (nt->nt_keyixmap != NULL && keyix < nt->nt_keyixmax && + nt->nt_keyixmap[keyix] == ni) { + IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE, + "%s: %p<%s> clear key map entry %u\n", + __func__, ni, ether_sprintf(ni->ni_macaddr), keyix); + nt->nt_keyixmap[keyix] = NULL; + ieee80211_node_decref(ni); + return 1; + } + + return 0; +} + void #ifdef IEEE80211_DEBUG_REFCNT ieee80211_free_node_debug(struct ieee80211_node *ni, const char *func, int line) @@ -1769,24 +1800,9 @@ ieee80211_free_node(struct ieee80211_node *ni) * Last reference, reclaim state. */ _ieee80211_free_node(ni); - } else if (ieee80211_node_refcnt(ni) == 1 && - nt->nt_keyixmap != NULL) { - ieee80211_keyix keyix; - /* - * Check for a last reference in the key mapping table. - */ - keyix = ni->ni_ucastkey.wk_rxkeyix; - if (keyix < nt->nt_keyixmax && - nt->nt_keyixmap[keyix] == ni) { - IEEE80211_DPRINTF(ni->ni_vap, - IEEE80211_MSG_NODE, - "%s: %p<%s> clear key map entry", __func__, - ni, ether_sprintf(ni->ni_macaddr)); - nt->nt_keyixmap[keyix] = NULL; - ieee80211_node_decref(ni); /* XXX needed? */ + } else if (ieee80211_node_refcnt(ni) == 1) + if (node_clear_keyixmap(nt, ni)) _ieee80211_free_node(ni); - } - } IEEE80211_NODE_UNLOCK(nt); } else { if (ieee80211_node_dectestref(ni)) @@ -1854,7 +1870,6 @@ ieee80211_node_delucastkey(struct ieee80211_node *ni) static void node_reclaim(struct ieee80211_node_table *nt, struct ieee80211_node *ni) { - ieee80211_keyix keyix; IEEE80211_NODE_LOCK_ASSERT(nt); @@ -1869,15 +1884,7 @@ node_reclaim(struct ieee80211_node_table *nt, struct ieee80211_node *ni) * table. We cannot depend on the mapping table entry * being cleared because the node may not be free'd. */ - keyix = ni->ni_ucastkey.wk_rxkeyix; - if (nt->nt_keyixmap != NULL && keyix < nt->nt_keyixmax && - nt->nt_keyixmap[keyix] == ni) { - IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE, - "%s: %p<%s> clear key map entry %u\n", - __func__, ni, ether_sprintf(ni->ni_macaddr), keyix); - nt->nt_keyixmap[keyix] = NULL; - ieee80211_node_decref(ni); /* NB: don't need free */ - } + (void)node_clear_keyixmap(nt, ni); if (!ieee80211_node_dectestref(ni)) { /* * Other references are present, just remove the diff --git a/sys/net80211/ieee80211_output.c b/sys/net80211/ieee80211_output.c index 9247e0e..2158bee 100644 --- a/sys/net80211/ieee80211_output.c +++ b/sys/net80211/ieee80211_output.c @@ -42,6 +42,7 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/ethernet.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_llc.h> #include <net/if_media.h> #include <net/if_vlan_var.h> @@ -157,7 +158,7 @@ ieee80211_vap_pkt_send_dest(struct ieee80211vap *vap, struct mbuf *m, ni->ni_macaddr, NULL, "%s", "classification failure"); vap->iv_stats.is_tx_classify++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(m); ieee80211_free_node(ni); @@ -254,7 +255,7 @@ ieee80211_vap_pkt_send_dest(struct ieee80211vap *vap, struct mbuf *m, ieee80211_free_node(ni); if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if_inc_counter(ifp, IFCOUNTER_OMCASTS, mcast); if_inc_counter(ifp, IFCOUNTER_OBYTES, len); } @@ -304,7 +305,7 @@ ieee80211_start_pkt(struct ieee80211vap *vap, struct mbuf *m) IEEE80211_DPRINTF(vap, IEEE80211_MSG_OUTPUT, "discard frame, %s\n", "m_pullup failed"); vap->iv_stats.is_tx_nobuf++; /* XXX */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return (ENOBUFS); } eh = mtod(m, struct ether_header *); @@ -338,7 +339,7 @@ ieee80211_start_pkt(struct ieee80211vap *vap, struct mbuf *m) ni = ieee80211_find_txnode(vap, eh->ether_dhost); if (ni == NULL) { /* NB: ieee80211_find_txnode does stat+msg */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(m); /* XXX better status? */ return (ENOBUFS); @@ -350,7 +351,7 @@ ieee80211_start_pkt(struct ieee80211vap *vap, struct mbuf *m) "sta not associated (type 0x%04x)", htons(eh->ether_type)); vap->iv_stats.is_tx_notassoc++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(m); ieee80211_free_node(ni); /* XXX better status? */ @@ -369,7 +370,7 @@ ieee80211_start_pkt(struct ieee80211vap *vap, struct mbuf *m) eh->ether_dhost, NULL, "%s", "proxy not enabled"); vap->iv_stats.is_mesh_notproxy++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(m); /* XXX better status? */ return (ENOBUFS); @@ -386,7 +387,7 @@ ieee80211_start_pkt(struct ieee80211vap *vap, struct mbuf *m) * NB: ieee80211_mesh_discover holds/disposes * frame (e.g. queueing on path discovery). */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); /* XXX better status? */ return (ENOBUFS); } @@ -396,6 +397,20 @@ ieee80211_start_pkt(struct ieee80211vap *vap, struct mbuf *m) /* * We've resolved the sender, so attempt to transmit it. */ + + if (vap->iv_state == IEEE80211_S_SLEEP) { + /* + * In power save; queue frame and then wakeup device + * for transmit. + */ + ic->ic_lastdata = ticks; + if (ieee80211_pwrsave(ni, m) != 0) + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); + ieee80211_free_node(ni); + ieee80211_new_state(vap, IEEE80211_S_RUN, 0); + return (0); + } + if (ieee80211_vap_pkt_send_dest(vap, m, ni) != 0) return (ENOBUFS); return (0); @@ -426,24 +441,19 @@ ieee80211_vap_transmit(struct ifnet *ifp, struct mbuf *m) if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return (ENETDOWN); } - if (vap->iv_state == IEEE80211_S_SLEEP) { - /* - * In power save, wakeup device for transmit. - */ - ieee80211_new_state(vap, IEEE80211_S_RUN, 0); - m_freem(m); - return (0); - } + /* * No data frames go out unless we're running. * Note in particular this covers CAC and CSA * states (though maybe we should check muting * for CSA). */ - if (vap->iv_state != IEEE80211_S_RUN) { + if (vap->iv_state != IEEE80211_S_RUN && + vap->iv_state != IEEE80211_S_SLEEP) { IEEE80211_LOCK(ic); /* re-check under the com lock to avoid races */ - if (vap->iv_state != IEEE80211_S_RUN) { + if (vap->iv_state != IEEE80211_S_RUN && + vap->iv_state != IEEE80211_S_SLEEP) { IEEE80211_DPRINTF(vap, IEEE80211_MSG_OUTPUT, "%s: ignore queue, in %s state\n", __func__, ieee80211_state_name[vap->iv_state]); @@ -484,6 +494,13 @@ ieee80211_vap_qflush(struct ifnet *ifp) /* * 802.11 raw output routine. + * + * XXX TODO: this (and other send routines) should correctly + * XXX keep the pwr mgmt bit set if it decides to call into the + * XXX driver to send a frame whilst the state is SLEEP. + * + * Otherwise the peer may decide that we're awake and flood us + * with traffic we are still too asleep to receive! */ int ieee80211_raw_output(struct ieee80211vap *vap, struct ieee80211_node *ni, @@ -600,7 +617,7 @@ ieee80211_output(struct ifnet *ifp, struct mbuf *m, if (ieee80211_classify(ni, m)) senderr(EIO); /* XXX */ - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); IEEE80211_NODE_STAT(ni, tx_data); if (IEEE80211_IS_MULTICAST(wh->i_addr1)) { IEEE80211_NODE_STAT(ni, tx_mcast); @@ -628,7 +645,7 @@ bad: m_freem(m); if (ni != NULL) ieee80211_free_node(ni); - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); return error; #undef senderr } @@ -722,7 +739,12 @@ ieee80211_send_setup( if (tid != IEEE80211_NONQOS_TID && IEEE80211_AMPDU_RUNNING(tap)) m->m_flags |= M_AMPDU_MPDU; else { - seqno = ni->ni_txseqs[tid]++; + if (IEEE80211_HAS_SEQ(type & IEEE80211_FC0_TYPE_MASK, + type & IEEE80211_FC0_SUBTYPE_MASK)) + seqno = ni->ni_txseqs[tid]++; + else + seqno = 0; + *(uint16_t *)&wh->i_seq[0] = htole16(seqno << IEEE80211_SEQ_SEQ_SHIFT); M_SEQNO_SET(m, seqno); @@ -1694,7 +1716,7 @@ ieee80211_add_xrates(uint8_t *frm, const struct ieee80211_rateset *rs) /* * Add an ssid element to a frame. */ -static uint8_t * +uint8_t * ieee80211_add_ssid(uint8_t *frm, const uint8_t *ssid, u_int len) { *frm++ = IEEE80211_ELEMID_SSID; @@ -2314,18 +2336,33 @@ ieee80211_send_mgmt(struct ieee80211_node *ni, int type, int arg) ic->ic_curchan); frm = ieee80211_add_supportedchannels(frm, ic); } + + /* + * Check the channel - we may be using an 11n NIC with an + * 11n capable station, but we're configured to be an 11b + * channel. + */ if ((vap->iv_flags_ht & IEEE80211_FHT_HT) && + IEEE80211_IS_CHAN_HT(ni->ni_chan) && ni->ni_ies.htcap_ie != NULL && - ni->ni_ies.htcap_ie[0] == IEEE80211_ELEMID_HTCAP) + ni->ni_ies.htcap_ie[0] == IEEE80211_ELEMID_HTCAP) { frm = ieee80211_add_htcap(frm, ni); + } frm = ieee80211_add_wpa(frm, vap); if ((ic->ic_flags & IEEE80211_F_WME) && ni->ni_ies.wme_ie != NULL) frm = ieee80211_add_wme_info(frm, &ic->ic_wme); + + /* + * Same deal - only send HT info if we're on an 11n + * capable channel. + */ if ((vap->iv_flags_ht & IEEE80211_FHT_HT) && + IEEE80211_IS_CHAN_HT(ni->ni_chan) && ni->ni_ies.htcap_ie != NULL && - ni->ni_ies.htcap_ie[0] == IEEE80211_ELEMID_VENDOR) + ni->ni_ies.htcap_ie[0] == IEEE80211_ELEMID_VENDOR) { frm = ieee80211_add_htcap_vendor(frm, ni); + } #ifdef IEEE80211_SUPPORT_SUPERG if (IEEE80211_ATH_CAP(vap, ni, IEEE80211_F_ATHEROS)) { frm = ieee80211_add_ath(frm, diff --git a/sys/net80211/ieee80211_phy.c b/sys/net80211/ieee80211_phy.c index 923266c..4242ac0 100644 --- a/sys/net80211/ieee80211_phy.c +++ b/sys/net80211/ieee80211_phy.c @@ -35,12 +35,16 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/kernel.h> #include <sys/systm.h> +#include <sys/malloc.h> #include <sys/socket.h> #include <net/if.h> #include <net/if_media.h> +#include <net/ethernet.h> +#include <net/route.h> + #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_phy.h> diff --git a/sys/net80211/ieee80211_power.c b/sys/net80211/ieee80211_power.c index 4542ec5..812cd70 100644 --- a/sys/net80211/ieee80211_power.c +++ b/sys/net80211/ieee80211_power.c @@ -38,6 +38,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> @@ -554,3 +555,108 @@ ieee80211_sta_pwrsave(struct ieee80211vap *vap, int enable) ieee80211_send_nulldata(ieee80211_ref_node(ni)); } } + +/* + * Handle being notified that we have data available for us in a TIM/ATIM. + * + * This may schedule a transition from _SLEEP -> _RUN if it's appropriate. + * + * In STA mode, we may have put to sleep during scan and need to be dragged + * back out of powersave mode. + */ +void +ieee80211_sta_tim_notify(struct ieee80211vap *vap, int set) +{ + struct ieee80211com *ic = vap->iv_ic; + + /* + * Schedule the driver state change. It'll happen at some point soon. + * Since the hardware shouldn't know that we're running just yet + * (and thus tell the peer that we're awake before we actually wake + * up said hardware), we leave the actual node state transition + * up to the transition to RUN. + * + * XXX TODO: verify that the transition to RUN will wake up the + * BSS node! + */ + IEEE80211_LOCK(vap->iv_ic); + if (set == 1 && vap->iv_state == IEEE80211_S_SLEEP) { + ieee80211_new_state_locked(vap, IEEE80211_S_RUN, 0); + IEEE80211_DPRINTF(vap, IEEE80211_MSG_POWER, + "%s: TIM=%d; wakeup\n", __func__, set); + } else if ((set == 1) && (ic->ic_flags_ext & IEEE80211_FEXT_BGSCAN)) { + /* + * XXX only do this if we're in RUN state? + */ + IEEE80211_DPRINTF(vap, IEEE80211_MSG_POWER, + "%s: wake up from bgscan vap sleep\n", + __func__); + /* + * We may be in BGSCAN mode - this means the VAP is is in STA + * mode powersave. If it is, we need to wake it up so we + * can process outbound traffic. + */ + vap->iv_sta_ps(vap, 0); + } + IEEE80211_UNLOCK(vap->iv_ic); +} + +/* + * Timer check on whether the VAP has had any transmit activity. + * + * This may schedule a transition from _RUN -> _SLEEP if it's appropriate. + */ +void +ieee80211_sta_ps_timer_check(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + + /* XXX lock assert */ + + /* For no, only do this in STA mode */ + if (! (vap->iv_caps & IEEE80211_C_SWSLEEP)) + goto out; + + if (vap->iv_opmode != IEEE80211_M_STA) + goto out; + + /* If we're not at run state, bail */ + if (vap->iv_state != IEEE80211_S_RUN) + goto out; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_POWER, + "%s: lastdata=%llu, ticks=%llu\n", + __func__, (unsigned long long) ic->ic_lastdata, + (unsigned long long) ticks); + + /* If powersave is disabled on the VAP, don't bother */ + if (! (vap->iv_flags & IEEE80211_F_PMGTON)) + goto out; + + /* If we've done any data within our idle interval, bail */ + /* XXX hard-coded to one second for now, ew! */ + if (time_after(ic->ic_lastdata + 500, ticks)) + goto out; + + /* + * Signify we're going into power save and transition the + * node to powersave. + */ + if ((vap->iv_bss->ni_flags & IEEE80211_NODE_PWR_MGT) == 0) + vap->iv_sta_ps(vap, 1); + + /* + * XXX The driver has to handle the fact that we're going + * to sleep but frames may still be transmitted; + * hopefully it and/or us will do the right thing and mark any + * transmitted frames with PWRMGT set to 1. + */ + ieee80211_new_state_locked(vap, IEEE80211_S_SLEEP, 0); + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_POWER, + "%s: time delta=%d msec\n", __func__, + (int) ticks_to_msecs(ticks - ic->ic_lastdata)); + +out: + return; +} diff --git a/sys/net80211/ieee80211_power.h b/sys/net80211/ieee80211_power.h index 55270d2..d9bbaa5 100644 --- a/sys/net80211/ieee80211_power.h +++ b/sys/net80211/ieee80211_power.h @@ -79,6 +79,9 @@ int ieee80211_node_psq_age(struct ieee80211_node *); int ieee80211_pwrsave(struct ieee80211_node *, struct mbuf *); void ieee80211_node_pwrsave(struct ieee80211_node *, int enable); void ieee80211_sta_pwrsave(struct ieee80211vap *, int enable); +void ieee80211_sta_tim_notify(struct ieee80211vap *vap, int set); +void ieee80211_sta_ps_timer_check(struct ieee80211vap *vap); +/* XXX what's this? */ void ieee80211_power_poll(struct ieee80211com *); #endif /* _NET80211_IEEE80211_POWER_H_ */ diff --git a/sys/net80211/ieee80211_proto.c b/sys/net80211/ieee80211_proto.c index 6f75130..2f84769 100644 --- a/sys/net80211/ieee80211_proto.c +++ b/sys/net80211/ieee80211_proto.c @@ -42,6 +42,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sockio.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> /* XXX for ether_sprintf */ diff --git a/sys/net80211/ieee80211_proto.h b/sys/net80211/ieee80211_proto.h index 8df5116..3b46ac4 100644 --- a/sys/net80211/ieee80211_proto.h +++ b/sys/net80211/ieee80211_proto.h @@ -149,6 +149,7 @@ struct mbuf *ieee80211_alloc_cts(struct ieee80211com *, uint8_t *ieee80211_add_rates(uint8_t *, const struct ieee80211_rateset *); uint8_t *ieee80211_add_xrates(uint8_t *, const struct ieee80211_rateset *); +uint8_t *ieee80211_add_ssid(uint8_t *, const uint8_t *, u_int); uint8_t *ieee80211_add_wpa(uint8_t *, const struct ieee80211vap *); uint8_t *ieee80211_add_rsn(uint8_t *, const struct ieee80211vap *); uint8_t *ieee80211_add_qos(uint8_t *, const struct ieee80211_node *); diff --git a/sys/net80211/ieee80211_radiotap.c b/sys/net80211/ieee80211_radiotap.c index f06f7e0..5638f52 100644 --- a/sys/net80211/ieee80211_radiotap.c +++ b/sys/net80211/ieee80211_radiotap.c @@ -42,8 +42,10 @@ __FBSDID("$FreeBSD$"); #include <net/bpf.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_llc.h> #include <net/if_media.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> diff --git a/sys/net80211/ieee80211_ratectl.c b/sys/net80211/ieee80211_ratectl.c index 0ad46bd3..3eff898 100644 --- a/sys/net80211/ieee80211_ratectl.c +++ b/sys/net80211/ieee80211_ratectl.c @@ -30,9 +30,12 @@ __FBSDID("$FreeBSD$"); #include <sys/kernel.h> #include <sys/systm.h> #include <sys/socket.h> +#include <sys/malloc.h> #include <net/if.h> #include <net/if_media.h> +#include <net/ethernet.h> +#include <net/route.h> #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_ratectl.h> diff --git a/sys/net80211/ieee80211_ratectl.h b/sys/net80211/ieee80211_ratectl.h index be81781..5603509 100644 --- a/sys/net80211/ieee80211_ratectl.h +++ b/sys/net80211/ieee80211_ratectl.h @@ -62,13 +62,13 @@ void ieee80211_ratectl_set(struct ieee80211vap *, int); MALLOC_DECLARE(M_80211_RATECTL); -static void __inline +static __inline void ieee80211_ratectl_deinit(struct ieee80211vap *vap) { vap->iv_rate->ir_deinit(vap); } -static void __inline +static __inline void ieee80211_ratectl_node_init(struct ieee80211_node *ni) { const struct ieee80211vap *vap = ni->ni_vap; @@ -76,7 +76,7 @@ ieee80211_ratectl_node_init(struct ieee80211_node *ni) vap->iv_rate->ir_node_init(ni); } -static void __inline +static __inline void ieee80211_ratectl_node_deinit(struct ieee80211_node *ni) { const struct ieee80211vap *vap = ni->ni_vap; @@ -92,14 +92,14 @@ ieee80211_ratectl_rate(struct ieee80211_node *ni, void *arg, uint32_t iarg) return vap->iv_rate->ir_rate(ni, arg, iarg); } -static void __inline +static __inline void ieee80211_ratectl_tx_complete(const struct ieee80211vap *vap, const struct ieee80211_node *ni, int status, void *arg1, void *arg2) { vap->iv_rate->ir_tx_complete(vap, ni, status, arg1, arg2); } -static void __inline +static __inline void ieee80211_ratectl_tx_update(const struct ieee80211vap *vap, const struct ieee80211_node *ni, void *arg1, void *arg2, void *arg3) { @@ -108,7 +108,7 @@ ieee80211_ratectl_tx_update(const struct ieee80211vap *vap, vap->iv_rate->ir_tx_update(vap, ni, arg1, arg2, arg3); } -static void __inline +static __inline void ieee80211_ratectl_setinterval(const struct ieee80211vap *vap, int msecs) { if (vap->iv_rate->ir_setinterval == NULL) diff --git a/sys/net80211/ieee80211_ratectl_none.c b/sys/net80211/ieee80211_ratectl_none.c index 0edec44..a0056f3 100644 --- a/sys/net80211/ieee80211_ratectl_none.c +++ b/sys/net80211/ieee80211_ratectl_none.c @@ -29,13 +29,16 @@ __FBSDID("$FreeBSD$"); #include "opt_wlan.h" #include <sys/param.h> +#include <sys/systm.h> #include <sys/kernel.h> +#include <sys/malloc.h> #include <sys/module.h> #include <sys/socket.h> #include <sys/sysctl.h> #include <net/if.h> #include <net/if_media.h> +#include <net/ethernet.h> #ifdef INET #include <netinet/in.h> diff --git a/sys/net80211/ieee80211_regdomain.c b/sys/net80211/ieee80211_regdomain.c index 6bc5e0d..ed7f422 100644 --- a/sys/net80211/ieee80211_regdomain.c +++ b/sys/net80211/ieee80211_regdomain.c @@ -34,11 +34,14 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <sys/systm.h> #include <sys/kernel.h> +#include <sys/malloc.h> #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_regdomain.h> diff --git a/sys/net80211/ieee80211_rssadapt.c b/sys/net80211/ieee80211_rssadapt.c index aaf4057..f230f60 100644 --- a/sys/net80211/ieee80211_rssadapt.c +++ b/sys/net80211/ieee80211_rssadapt.c @@ -33,13 +33,17 @@ #include "opt_wlan.h" #include <sys/param.h> +#include <sys/systm.h> #include <sys/kernel.h> +#include <sys/malloc.h> #include <sys/module.h> #include <sys/socket.h> #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_rssadapt.h> diff --git a/sys/net80211/ieee80211_scan.c b/sys/net80211/ieee80211_scan.c index 3a8c24d..6c950d6 100644 --- a/sys/net80211/ieee80211_scan.c +++ b/sys/net80211/ieee80211_scan.c @@ -40,40 +40,16 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> #include <net80211/ieee80211_var.h> -#include <net/bpf.h> - -struct scan_state { - struct ieee80211_scan_state base; /* public state */ - - u_int ss_iflags; /* flags used internally */ -#define ISCAN_MINDWELL 0x0001 /* min dwell time reached */ -#define ISCAN_DISCARD 0x0002 /* discard rx'd frames */ -#define ISCAN_CANCEL 0x0004 /* cancel current scan */ -#define ISCAN_ABORT 0x0008 /* end the scan immediately */ - unsigned long ss_chanmindwell; /* min dwell on curchan */ - unsigned long ss_scanend; /* time scan must stop */ - u_int ss_duration; /* duration for next scan */ - struct task ss_scan_task; /* scan execution */ - struct cv ss_scan_cv; /* scan signal */ - struct callout ss_scan_timer; /* scan timer */ -}; -#define SCAN_PRIVATE(ss) ((struct scan_state *) ss) +/* XXX until it's implemented as attach ops */ +#include <net80211/ieee80211_scan_sw.h> -/* - * Amount of time to go off-channel during a background - * scan. This value should be large enough to catch most - * ap's but short enough that we can return on-channel - * before our listen interval expires. - * - * XXX tunable - * XXX check against configured listen interval - */ -#define IEEE80211_SCAN_OFFCHANNEL msecs_to_ticks(150) +#include <net/bpf.h> /* * Roaming-related defaults. RSSI thresholds are as returned by the @@ -92,55 +68,32 @@ struct scan_state { #define ROAM_RATE_QUARTER_DEFAULT 2*3 /* quarter-width 11a/g bss */ #define ROAM_MCS_11N_DEFAULT (1 | IEEE80211_RATE_MCS) /* 11n bss */ -static void scan_curchan(struct ieee80211_scan_state *, unsigned long); -static void scan_mindwell(struct ieee80211_scan_state *); -static void scan_signal(void *); -static void scan_task(void *, int); - -MALLOC_DEFINE(M_80211_SCAN, "80211scan", "802.11 scan state"); - void ieee80211_scan_attach(struct ieee80211com *ic) { - struct scan_state *ss; - ss = (struct scan_state *) malloc(sizeof(struct scan_state), - M_80211_SCAN, M_NOWAIT | M_ZERO); - if (ss == NULL) { - ic->ic_scan = NULL; - return; - } - callout_init_mtx(&ss->ss_scan_timer, IEEE80211_LOCK_OBJ(ic), 0); - cv_init(&ss->ss_scan_cv, "scan"); - TASK_INIT(&ss->ss_scan_task, 0, scan_task, ss); - ic->ic_scan = &ss->base; - ss->base.ss_ic = ic; - - ic->ic_scan_curchan = scan_curchan; - ic->ic_scan_mindwell = scan_mindwell; + /* + * For now, the swscan module does both the + * allocation (so it can pad it) and sets up the net80211 + * bits. + * + * I'll split this stuff later. + */ + ieee80211_swscan_attach(ic); } void ieee80211_scan_detach(struct ieee80211com *ic) { - struct ieee80211_scan_state *ss = ic->ic_scan; - if (ss != NULL) { - IEEE80211_LOCK(ic); - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT; - scan_signal(ss); - IEEE80211_UNLOCK(ic); - ieee80211_draintask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); - callout_drain(&SCAN_PRIVATE(ss)->ss_scan_timer); - KASSERT((ic->ic_flags & IEEE80211_F_SCAN) == 0, - ("scan still running")); - if (ss->ss_ops != NULL) { - ss->ss_ops->scan_detach(ss); - ss->ss_ops = NULL; - } - ic->ic_scan = NULL; - free(SCAN_PRIVATE(ss), M_80211_SCAN); - } + /* + * Ideally we'd do the ss_ops detach call here; + * but then ieee80211_swscan_detach would need + * to be split in two. + * + * I'll do that later. + */ + ieee80211_swscan_detach(ic); } static const struct ieee80211_roamparam defroam[IEEE80211_MODE_MAX] = { @@ -175,6 +128,8 @@ ieee80211_scan_vattach(struct ieee80211vap *vap) vap->iv_roaming = IEEE80211_ROAMING_AUTO; memcpy(vap->iv_roamparms, defroam, sizeof(defroam)); + + ieee80211_swscan_vattach(vap); } void @@ -185,11 +140,10 @@ ieee80211_scan_vdetach(struct ieee80211vap *vap) IEEE80211_LOCK(ic); ss = ic->ic_scan; + + ieee80211_swscan_vdetach(vap); + if (ss != NULL && ss->ss_vap == vap) { - if (ic->ic_flags & IEEE80211_F_SCAN) { - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT; - scan_signal(ss); - } if (ss->ss_ops != NULL) { ss->ss_ops->scan_detach(ss); ss->ss_ops = NULL; @@ -260,8 +214,8 @@ ieee80211_scanner_unregister_all(const struct ieee80211_scanner *scan) * ensure later callbacks find ss_ops set to properly * reflect current operating mode. */ -static void -scan_update_locked(struct ieee80211vap *vap, +void +ieee80211_scan_update_locked(struct ieee80211vap *vap, const struct ieee80211_scanner *scan) { struct ieee80211com *ic = vap->iv_ic; @@ -306,26 +260,6 @@ scan_update_locked(struct ieee80211vap *vap, } } -static char -channel_type(const struct ieee80211_channel *c) -{ - if (IEEE80211_IS_CHAN_ST(c)) - return 'S'; - if (IEEE80211_IS_CHAN_108A(c)) - return 'T'; - if (IEEE80211_IS_CHAN_108G(c)) - return 'G'; - if (IEEE80211_IS_CHAN_HT(c)) - return 'n'; - if (IEEE80211_IS_CHAN_A(c)) - return 'a'; - if (IEEE80211_IS_CHAN_ANYG(c)) - return 'g'; - if (IEEE80211_IS_CHAN_B(c)) - return 'b'; - return 'f'; -} - void ieee80211_scan_dump_channels(const struct ieee80211_scan_state *ss) { @@ -338,14 +272,14 @@ ieee80211_scan_dump_channels(const struct ieee80211_scan_state *ss) const struct ieee80211_channel *c = ss->ss_chans[i]; printf("%s%u%c", sep, ieee80211_chan2ieee(ic, c), - channel_type(c)); + ieee80211_channel_type_char(c)); sep = ", "; } } #ifdef IEEE80211_DEBUG -static void -scan_dump(struct ieee80211_scan_state *ss) +void +ieee80211_scan_dump(struct ieee80211_scan_state *ss) { struct ieee80211vap *vap = ss->ss_vap; @@ -356,8 +290,8 @@ scan_dump(struct ieee80211_scan_state *ss) } #endif /* IEEE80211_DEBUG */ -static void -copy_ssid(struct ieee80211vap *vap, struct ieee80211_scan_state *ss, +void +ieee80211_scan_copy_ssid(struct ieee80211vap *vap, struct ieee80211_scan_state *ss, int nssid, const struct ieee80211_scan_ssid ssids[]) { if (nssid > IEEE80211_SCAN_MAX_SSID) { @@ -374,86 +308,12 @@ copy_ssid(struct ieee80211vap *vap, struct ieee80211_scan_state *ss, /* * Start a scan unless one is already going. */ -static int -start_scan_locked(const struct ieee80211_scanner *scan, - struct ieee80211vap *vap, int flags, u_int duration, - u_int mindwell, u_int maxdwell, - u_int nssid, const struct ieee80211_scan_ssid ssids[]) -{ - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; - - IEEE80211_LOCK_ASSERT(ic); - - if (ic->ic_flags & IEEE80211_F_CSAPENDING) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: scan inhibited by pending channel change\n", __func__); - } else if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: %s scan, duration %u mindwell %u maxdwell %u, desired mode %s, %s%s%s%s%s%s\n" - , __func__ - , flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive" - , duration, mindwell, maxdwell - , ieee80211_phymode_name[vap->iv_des_mode] - , flags & IEEE80211_SCAN_FLUSH ? "flush" : "append" - , flags & IEEE80211_SCAN_NOPICK ? ", nopick" : "" - , flags & IEEE80211_SCAN_NOJOIN ? ", nojoin" : "" - , flags & IEEE80211_SCAN_NOBCAST ? ", nobcast" : "" - , flags & IEEE80211_SCAN_PICK1ST ? ", pick1st" : "" - , flags & IEEE80211_SCAN_ONCE ? ", once" : "" - ); - - scan_update_locked(vap, scan); - if (ss->ss_ops != NULL) { - if ((flags & IEEE80211_SCAN_NOSSID) == 0) - copy_ssid(vap, ss, nssid, ssids); - - /* NB: top 4 bits for internal use */ - ss->ss_flags = flags & 0xfff; - if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) - vap->iv_stats.is_scan_active++; - else - vap->iv_stats.is_scan_passive++; - if (flags & IEEE80211_SCAN_FLUSH) - ss->ss_ops->scan_flush(ss); - if (flags & IEEE80211_SCAN_BGSCAN) - ic->ic_flags_ext |= IEEE80211_FEXT_BGSCAN; - - /* NB: flush frames rx'd before 1st channel change */ - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_DISCARD; - SCAN_PRIVATE(ss)->ss_duration = duration; - ss->ss_next = 0; - ss->ss_mindwell = mindwell; - ss->ss_maxdwell = maxdwell; - /* NB: scan_start must be before the scan runtask */ - ss->ss_ops->scan_start(ss, vap); -#ifdef IEEE80211_DEBUG - if (ieee80211_msg_scan(vap)) - scan_dump(ss); -#endif /* IEEE80211_DEBUG */ - ic->ic_flags |= IEEE80211_F_SCAN; - ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); - } - return 1; - } else { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: %s scan already in progress\n", __func__, - ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive"); - } - return 0; -} - -/* - * Start a scan unless one is already going. - */ int ieee80211_start_scan(struct ieee80211vap *vap, int flags, u_int duration, u_int mindwell, u_int maxdwell, u_int nssid, const struct ieee80211_scan_ssid ssids[]) { - struct ieee80211com *ic = vap->iv_ic; const struct ieee80211_scanner *scan; - int result; scan = ieee80211_scanner_get(vap->iv_opmode); if (scan == NULL) { @@ -464,12 +324,9 @@ ieee80211_start_scan(struct ieee80211vap *vap, int flags, return 0; } - IEEE80211_LOCK(ic); - result = start_scan_locked(scan, vap, flags, duration, + /* XXX ops */ + return ieee80211_swscan_start_scan(scan, vap, flags, duration, mindwell, maxdwell, nssid, ssids); - IEEE80211_UNLOCK(ic); - - return result; } /* @@ -516,49 +373,19 @@ ieee80211_check_scan(struct ieee80211vap *vap, int flags, /* XXX re-use cache contents? e.g. adhoc<->sta */ flags |= IEEE80211_SCAN_FLUSH; } - scan_update_locked(vap, scan); - if (ss->ss_ops != NULL) { - /* XXX verify ss_ops matches vap->iv_opmode */ - if ((flags & IEEE80211_SCAN_NOSSID) == 0) { - /* - * Update the ssid list and mark flags so if - * we call start_scan it doesn't duplicate work. - */ - copy_ssid(vap, ss, nssid, ssids); - flags |= IEEE80211_SCAN_NOSSID; - } - if ((ic->ic_flags & IEEE80211_F_SCAN) == 0 && - (flags & IEEE80211_SCAN_FLUSH) == 0 && - time_before(ticks, ic->ic_lastscan + vap->iv_scanvalid)) { - /* - * We're not currently scanning and the cache is - * deemed hot enough to consult. Lock out others - * by marking IEEE80211_F_SCAN while we decide if - * something is already in the scan cache we can - * use. Also discard any frames that might come - * in while temporarily marked as scanning. - */ - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_DISCARD; - ic->ic_flags |= IEEE80211_F_SCAN; - - /* NB: need to use supplied flags in check */ - ss->ss_flags = flags & 0xff; - result = ss->ss_ops->scan_end(ss, vap); - - ic->ic_flags &= ~IEEE80211_F_SCAN; - SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_DISCARD; - if (result) { - ieee80211_notify_scan_done(vap); - IEEE80211_UNLOCK(ic); - return 1; - } - } - } - result = start_scan_locked(scan, vap, flags, duration, + + /* + * XXX TODO: separate things out a bit better. + * XXX TODO: ops + */ + ieee80211_scan_update_locked(vap, scan); + + result = ieee80211_swscan_check_scan(scan, vap, flags, duration, mindwell, maxdwell, nssid, ssids); + IEEE80211_UNLOCK(ic); - return result; + return (result); } /* @@ -581,10 +408,10 @@ ieee80211_check_scan_current(struct ieee80211vap *vap) int ieee80211_bg_scan(struct ieee80211vap *vap, int flags) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; const struct ieee80211_scanner *scan; + // IEEE80211_UNLOCK_ASSERT(sc); + scan = ieee80211_scanner_get(vap->iv_opmode); if (scan == NULL) { IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, @@ -594,84 +421,14 @@ ieee80211_bg_scan(struct ieee80211vap *vap, int flags) return 0; } - IEEE80211_LOCK(ic); - if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) { - u_int duration; - /* - * Go off-channel for a fixed interval that is large - * enough to catch most ap's but short enough that - * we can return on-channel before our listen interval - * expires. - */ - duration = IEEE80211_SCAN_OFFCHANNEL; - - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: %s scan, ticks %u duration %lu\n", __func__, - ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive", - ticks, duration); - - scan_update_locked(vap, scan); - if (ss->ss_ops != NULL) { - ss->ss_vap = vap; - /* - * A background scan does not select a new sta; it - * just refreshes the scan cache. Also, indicate - * the scan logic should follow the beacon schedule: - * we go off-channel and scan for a while, then - * return to the bss channel to receive a beacon, - * then go off-channel again. All during this time - * we notify the ap we're in power save mode. When - * the scan is complete we leave power save mode. - * If any beacon indicates there are frames pending - * for us then we drop out of power save mode - * (and background scan) automatically by way of the - * usual sta power save logic. - */ - ss->ss_flags |= IEEE80211_SCAN_NOPICK - | IEEE80211_SCAN_BGSCAN - | flags - ; - /* if previous scan completed, restart */ - if (ss->ss_next >= ss->ss_last) { - if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) - vap->iv_stats.is_scan_active++; - else - vap->iv_stats.is_scan_passive++; - /* - * NB: beware of the scan cache being flushed; - * if the channel list is empty use the - * scan_start method to populate it. - */ - ss->ss_next = 0; - if (ss->ss_last != 0) - ss->ss_ops->scan_restart(ss, vap); - else { - ss->ss_ops->scan_start(ss, vap); -#ifdef IEEE80211_DEBUG - if (ieee80211_msg_scan(vap)) - scan_dump(ss); -#endif /* IEEE80211_DEBUG */ - } - } - /* NB: flush frames rx'd before 1st channel change */ - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_DISCARD; - SCAN_PRIVATE(ss)->ss_duration = duration; - ss->ss_maxdwell = duration; - ic->ic_flags |= IEEE80211_F_SCAN; - ic->ic_flags_ext |= IEEE80211_FEXT_BGSCAN; - ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); - } else { - /* XXX msg+stat */ - } - } else { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: %s scan already in progress\n", __func__, - ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive"); - } - IEEE80211_UNLOCK(ic); - - /* NB: racey, does it matter? */ - return (ic->ic_flags & IEEE80211_F_SCAN); + /* + * XXX TODO: pull apart the bgscan logic into whatever + * belongs here and whatever belongs in the software + * scanner. + * + * XXX TODO: ops + */ + return (ieee80211_swscan_bg_scan(scan, vap, flags)); } /* @@ -680,25 +437,9 @@ ieee80211_bg_scan(struct ieee80211vap *vap, int flags) void ieee80211_cancel_scan(struct ieee80211vap *vap) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; - IEEE80211_LOCK(ic); - if ((ic->ic_flags & IEEE80211_F_SCAN) && - ss->ss_vap == vap && - (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: cancel %s scan\n", __func__, - ss->ss_flags & IEEE80211_SCAN_ACTIVE ? - "active" : "passive"); - - /* clear bg scan NOPICK and mark cancel request */ - ss->ss_flags &= ~IEEE80211_SCAN_NOPICK; - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_CANCEL; - /* wake up the scan task */ - scan_signal(ss); - } - IEEE80211_UNLOCK(ic); + /* XXX TODO: ops */ + ieee80211_swscan_cancel_scan(vap); } /* @@ -707,24 +448,9 @@ ieee80211_cancel_scan(struct ieee80211vap *vap) void ieee80211_cancel_anyscan(struct ieee80211vap *vap) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; - IEEE80211_LOCK(ic); - if ((ic->ic_flags & IEEE80211_F_SCAN) && - (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: cancel %s scan\n", __func__, - ss->ss_flags & IEEE80211_SCAN_ACTIVE ? - "active" : "passive"); - - /* clear bg scan NOPICK and mark cancel request */ - ss->ss_flags &= ~IEEE80211_SCAN_NOPICK; - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_CANCEL; - /* wake up the scan task */ - scan_signal(ss); - } - IEEE80211_UNLOCK(ic); + /* XXX TODO: ops */ + ieee80211_swscan_cancel_anyscan(vap); } /* @@ -734,13 +460,9 @@ ieee80211_cancel_anyscan(struct ieee80211vap *vap) void ieee80211_scan_next(struct ieee80211vap *vap) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; - /* wake up the scan task */ - IEEE80211_LOCK(ic); - scan_signal(ss); - IEEE80211_UNLOCK(ic); + /* XXX TODO: ops */ + ieee80211_swscan_scan_next(vap); } /* @@ -753,10 +475,15 @@ ieee80211_scan_done(struct ieee80211vap *vap) struct ieee80211com *ic = vap->iv_ic; struct ieee80211_scan_state *ss; + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s: called\n", __func__); + IEEE80211_LOCK(ic); ss = ic->ic_scan; ss->ss_next = ss->ss_last; /* all channels are complete */ - scan_signal(ss); + + /* XXX TODO: ops */ + ieee80211_swscan_scan_done(vap); + IEEE80211_UNLOCK(ic); } @@ -771,293 +498,14 @@ void ieee80211_probe_curchan(struct ieee80211vap *vap, int force) { struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; - struct ifnet *ifp = vap->iv_ifp; - int i; if ((ic->ic_curchan->ic_flags & IEEE80211_CHAN_PASSIVE) && !force) { ic->ic_flags_ext |= IEEE80211_FEXT_PROBECHAN; return; } - /* - * Send directed probe requests followed by any - * broadcast probe request. - * XXX remove dependence on ic/vap->iv_bss - */ - for (i = 0; i < ss->ss_nssid; i++) - ieee80211_send_probereq(vap->iv_bss, - vap->iv_myaddr, ifp->if_broadcastaddr, - ifp->if_broadcastaddr, - ss->ss_ssid[i].ssid, ss->ss_ssid[i].len); - if ((ss->ss_flags & IEEE80211_SCAN_NOBCAST) == 0) - ieee80211_send_probereq(vap->iv_bss, - vap->iv_myaddr, ifp->if_broadcastaddr, - ifp->if_broadcastaddr, - "", 0); -} - -/* - * Scan curchan. If this is an active scan and the channel - * is not marked passive then send probe request frame(s). - * Arrange for the channel change after maxdwell ticks. - */ -static void -scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) -{ - struct ieee80211vap *vap = ss->ss_vap; - - IEEE80211_LOCK(vap->iv_ic); - if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) - ieee80211_probe_curchan(vap, 0); - callout_reset(&SCAN_PRIVATE(ss)->ss_scan_timer, - maxdwell, scan_signal, ss); - IEEE80211_UNLOCK(vap->iv_ic); -} - -static void -scan_signal(void *arg) -{ - struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg; - - IEEE80211_LOCK_ASSERT(ss->ss_ic); - - cv_signal(&SCAN_PRIVATE(ss)->ss_scan_cv); -} - -/* - * Handle mindwell requirements completed; initiate a channel - * change to the next channel asap. - */ -static void -scan_mindwell(struct ieee80211_scan_state *ss) -{ - struct ieee80211com *ic = ss->ss_ic; - - IEEE80211_LOCK(ic); - scan_signal(ss); - IEEE80211_UNLOCK(ic); -} - -static void -scan_task(void *arg, int pending) -{ -#define ISCAN_REP (ISCAN_MINDWELL | ISCAN_DISCARD) - struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg; - struct ieee80211vap *vap = ss->ss_vap; - struct ieee80211com *ic = ss->ss_ic; - struct ieee80211_channel *chan; - unsigned long maxdwell, scanend; - int scandone = 0; - - IEEE80211_LOCK(ic); - if (vap == NULL || (ic->ic_flags & IEEE80211_F_SCAN) == 0 || - (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)) { - /* Cancelled before we started */ - goto done; - } - - if (ss->ss_next == ss->ss_last) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: no channels to scan\n", __func__); - scandone = 1; - goto done; - } - - if (vap->iv_opmode == IEEE80211_M_STA && - vap->iv_state == IEEE80211_S_RUN) { - if ((vap->iv_bss->ni_flags & IEEE80211_NODE_PWR_MGT) == 0) { - /* Enable station power save mode */ - vap->iv_sta_ps(vap, 1); - /* - * Use an 1ms delay so the null data frame has a chance - * to go out. - * XXX Should use M_TXCB mechanism to eliminate this. - */ - cv_timedwait(&SCAN_PRIVATE(ss)->ss_scan_cv, - IEEE80211_LOCK_OBJ(ic), hz / 1000); - if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) - goto done; - } - } - - scanend = ticks + SCAN_PRIVATE(ss)->ss_duration; - IEEE80211_UNLOCK(ic); - ic->ic_scan_start(ic); /* notify driver */ - IEEE80211_LOCK(ic); - - for (;;) { - scandone = (ss->ss_next >= ss->ss_last) || - (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0; - if (scandone || (ss->ss_flags & IEEE80211_SCAN_GOTPICK) || - (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) || - time_after(ticks + ss->ss_mindwell, scanend)) - break; - - chan = ss->ss_chans[ss->ss_next++]; - - /* - * Watch for truncation due to the scan end time. - */ - if (time_after(ticks + ss->ss_maxdwell, scanend)) - maxdwell = scanend - ticks; - else - maxdwell = ss->ss_maxdwell; - - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: chan %3d%c -> %3d%c [%s, dwell min %lums max %lums]\n", - __func__, - ieee80211_chan2ieee(ic, ic->ic_curchan), - channel_type(ic->ic_curchan), - ieee80211_chan2ieee(ic, chan), channel_type(chan), - (ss->ss_flags & IEEE80211_SCAN_ACTIVE) && - (chan->ic_flags & IEEE80211_CHAN_PASSIVE) == 0 ? - "active" : "passive", - ticks_to_msecs(ss->ss_mindwell), ticks_to_msecs(maxdwell)); - - /* - * Potentially change channel and phy mode. - */ - ic->ic_curchan = chan; - ic->ic_rt = ieee80211_get_ratetable(chan); - IEEE80211_UNLOCK(ic); - /* - * Perform the channel change and scan unlocked so the driver - * may sleep. Once set_channel returns the hardware has - * completed the channel change. - */ - ic->ic_set_channel(ic); - ieee80211_radiotap_chan_change(ic); - - /* - * Scan curchan. Drivers for "intelligent hardware" - * override ic_scan_curchan to tell the device to do - * the work. Otherwise we manage the work outselves; - * sending a probe request (as needed), and arming the - * timeout to switch channels after maxdwell ticks. - * - * scan_curchan should only pause for the time required to - * prepare/initiate the hardware for the scan (if at all), the - * below condvar is used to sleep for the channels dwell time - * and allows it to be signalled for abort. - */ - ic->ic_scan_curchan(ss, maxdwell); - IEEE80211_LOCK(ic); - - SCAN_PRIVATE(ss)->ss_chanmindwell = ticks + ss->ss_mindwell; - /* clear mindwell lock and initial channel change flush */ - SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_REP; - - if ((SCAN_PRIVATE(ss)->ss_iflags & (ISCAN_CANCEL|ISCAN_ABORT))) - continue; - - /* Wait to be signalled to scan the next channel */ - cv_wait(&SCAN_PRIVATE(ss)->ss_scan_cv, IEEE80211_LOCK_OBJ(ic)); - } - if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) - goto done; - - IEEE80211_UNLOCK(ic); - ic->ic_scan_end(ic); /* notify driver */ - IEEE80211_LOCK(ic); - - /* - * Since a cancellation may have occured during one of the - * driver calls (whilst unlocked), update scandone. - */ - if (scandone == 0 && - ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0)) { - /* XXX printf? */ - if_printf(vap->iv_ifp, - "%s: OOPS! scan cancelled during driver call!\n", - __func__); - } - scandone |= ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0); - - /* - * Record scan complete time. Note that we also do - * this when canceled so any background scan will - * not be restarted for a while. - */ - if (scandone) - ic->ic_lastscan = ticks; - /* return to the bss channel */ - if (ic->ic_bsschan != IEEE80211_CHAN_ANYC && - ic->ic_curchan != ic->ic_bsschan) { - ieee80211_setupcurchan(ic, ic->ic_bsschan); - IEEE80211_UNLOCK(ic); - ic->ic_set_channel(ic); - ieee80211_radiotap_chan_change(ic); - IEEE80211_LOCK(ic); - } - /* clear internal flags and any indication of a pick */ - SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_REP; - ss->ss_flags &= ~IEEE80211_SCAN_GOTPICK; - - /* - * If not canceled and scan completed, do post-processing. - * If the callback function returns 0, then it wants to - * continue/restart scanning. Unfortunately we needed to - * notify the driver to end the scan above to avoid having - * rx frames alter the scan candidate list. - */ - if ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0 && - !ss->ss_ops->scan_end(ss, vap) && - (ss->ss_flags & IEEE80211_SCAN_ONCE) == 0 && - time_before(ticks + ss->ss_mindwell, scanend)) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: done, restart " - "[ticks %u, dwell min %lu scanend %lu]\n", - __func__, - ticks, ss->ss_mindwell, scanend); - ss->ss_next = 0; /* reset to begining */ - if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) - vap->iv_stats.is_scan_active++; - else - vap->iv_stats.is_scan_passive++; - - ss->ss_ops->scan_restart(ss, vap); /* XXX? */ - ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); - IEEE80211_UNLOCK(ic); - return; - } - - /* past here, scandone is ``true'' if not in bg mode */ - if ((ss->ss_flags & IEEE80211_SCAN_BGSCAN) == 0) - scandone = 1; - - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: %s, [ticks %u, dwell min %lu scanend %lu]\n", - __func__, scandone ? "done" : "stopped", - ticks, ss->ss_mindwell, scanend); - /* - * Clear the SCAN bit first in case frames are - * pending on the station power save queue. If - * we defer this then the dispatch of the frames - * may generate a request to cancel scanning. - */ -done: - ic->ic_flags &= ~IEEE80211_F_SCAN; - /* - * Drop out of power save mode when a scan has - * completed. If this scan was prematurely terminated - * because it is a background scan then don't notify - * the ap; we'll either return to scanning after we - * receive the beacon frame or we'll drop out of power - * save mode because the beacon indicates we have frames - * waiting for us. - */ - if (scandone) { - vap->iv_sta_ps(vap, 0); - if (ss->ss_next >= ss->ss_last) { - ieee80211_notify_scan_done(vap); - ic->ic_flags_ext &= ~IEEE80211_FEXT_BGSCAN; - } - } - SCAN_PRIVATE(ss)->ss_iflags &= ~(ISCAN_CANCEL|ISCAN_ABORT); - ss->ss_flags &= ~(IEEE80211_SCAN_ONCE | IEEE80211_SCAN_PICK1ST); - IEEE80211_UNLOCK(ic); -#undef ISCAN_REP + /* XXX TODO: ops */ + ieee80211_swscan_probe_curchan(vap, force); } #ifdef IEEE80211_DEBUG @@ -1086,8 +534,8 @@ dump_country(const uint8_t *ie) printf("]"); } -static void -dump_probe_beacon(uint8_t subtype, int isnew, +void +ieee80211_scan_dump_probe_beacon(uint8_t subtype, int isnew, const uint8_t mac[IEEE80211_ADDR_LEN], const struct ieee80211_scanparams *sp, int rssi) { @@ -1114,49 +562,14 @@ dump_probe_beacon(uint8_t subtype, int isnew, */ void ieee80211_add_scan(struct ieee80211vap *vap, + struct ieee80211_channel *curchan, const struct ieee80211_scanparams *sp, const struct ieee80211_frame *wh, int subtype, int rssi, int noise) { - struct ieee80211com *ic = vap->iv_ic; - struct ieee80211_scan_state *ss = ic->ic_scan; - /* XXX locking */ - /* - * Frames received during startup are discarded to avoid - * using scan state setup on the initial entry to the timer - * callback. This can occur because the device may enable - * rx prior to our doing the initial channel change in the - * timer routine. - */ - if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_DISCARD) - return; -#ifdef IEEE80211_DEBUG - if (ieee80211_msg_scan(vap) && (ic->ic_flags & IEEE80211_F_SCAN)) - dump_probe_beacon(subtype, 1, wh->i_addr2, sp, rssi); -#endif - if (ss->ss_ops != NULL && - ss->ss_ops->scan_add(ss, sp, wh, subtype, rssi, noise)) { - /* - * If we've reached the min dwell time terminate - * the timer so we'll switch to the next channel. - */ - if ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_MINDWELL) == 0 && - time_after_eq(ticks, SCAN_PRIVATE(ss)->ss_chanmindwell)) { - IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, - "%s: chan %3d%c min dwell met (%u > %lu)\n", - __func__, - ieee80211_chan2ieee(ic, ic->ic_curchan), - channel_type(ic->ic_curchan), - ticks, SCAN_PRIVATE(ss)->ss_chanmindwell); - SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_MINDWELL; - /* - * NB: trigger at next clock tick or wait for the - * hardware. - */ - ic->ic_scan_mindwell(ss); - } - } + return (ieee80211_swscan_add_scan(vap, curchan, sp, wh, subtype, + rssi, noise)); } /* diff --git a/sys/net80211/ieee80211_scan.h b/sys/net80211/ieee80211_scan.h index 3f13e17..8b54186 100644 --- a/sys/net80211/ieee80211_scan.h +++ b/sys/net80211/ieee80211_scan.h @@ -148,6 +148,7 @@ struct ieee80211_channel *ieee80211_scan_pickchannel(struct ieee80211com *, int) struct ieee80211_scanparams; void ieee80211_add_scan(struct ieee80211vap *, + struct ieee80211_channel *, const struct ieee80211_scanparams *, const struct ieee80211_frame *, int subtype, int rssi, int noise); @@ -273,6 +274,7 @@ struct ieee80211_scanner { struct ieee80211_scan_state *, int); /* add an entry to the cache */ int (*scan_add)(struct ieee80211_scan_state *, + struct ieee80211_channel *, const struct ieee80211_scanparams *, const struct ieee80211_frame *, int subtype, int rssi, int noise); @@ -299,4 +301,14 @@ void ieee80211_scanner_unregister(enum ieee80211_opmode, const struct ieee80211_scanner *); void ieee80211_scanner_unregister_all(const struct ieee80211_scanner *); const struct ieee80211_scanner *ieee80211_scanner_get(enum ieee80211_opmode); +void ieee80211_scan_update_locked(struct ieee80211vap *vap, + const struct ieee80211_scanner *scan); +void ieee80211_scan_copy_ssid(struct ieee80211vap *vap, + struct ieee80211_scan_state *ss, + int nssid, const struct ieee80211_scan_ssid ssids[]); +void ieee80211_scan_dump_probe_beacon(uint8_t subtype, int isnew, + const uint8_t mac[IEEE80211_ADDR_LEN], + const struct ieee80211_scanparams *sp, int rssi); +void ieee80211_scan_dump(struct ieee80211_scan_state *ss); + #endif /* _NET80211_IEEE80211_SCAN_H_ */ diff --git a/sys/net80211/ieee80211_scan_sta.c b/sys/net80211/ieee80211_scan_sta.c index c791ea1..1fb45b0 100644 --- a/sys/net80211/ieee80211_scan_sta.c +++ b/sys/net80211/ieee80211_scan_sta.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/ethernet.h> @@ -227,6 +228,7 @@ sta_flush_table(struct sta_table *st) */ static int sta_add(struct ieee80211_scan_state *ss, + struct ieee80211_channel *curchan, const struct ieee80211_scanparams *sp, const struct ieee80211_frame *wh, int subtype, int rssi, int noise) @@ -309,15 +311,15 @@ found: * IEEE80211_BPARSE_OFFCHAN. */ c = ieee80211_find_channel_byieee(ic, sp->chan, - ic->ic_curchan->ic_flags); + curchan->ic_flags); if (c != NULL) { ise->se_chan = c; } else if (ise->se_chan == NULL) { /* should not happen, pick something */ - ise->se_chan = ic->ic_curchan; + ise->se_chan = curchan; } } else - ise->se_chan = ic->ic_curchan; + ise->se_chan = curchan; if (IEEE80211_IS_CHAN_HT(ise->se_chan) && sp->htcap == NULL) { /* Demote legacy networks to a non-HT channel. */ c = ieee80211_find_channel(ic, ise->se_chan->ic_freq, @@ -599,10 +601,12 @@ makescanlist(struct ieee80211_scan_state *ss, struct ieee80211vap *vap, * so if the desired mode is 11g, then use * the 11b channel list but upgrade the mode. */ - if (vap->iv_des_mode != IEEE80211_MODE_11G || - mode != IEEE80211_MODE_11B) - continue; - mode = IEEE80211_MODE_11G; /* upgrade */ + if (vap->iv_des_mode == IEEE80211_MODE_11G) { + if (mode == IEEE80211_MODE_11G) /* Skip the G check */ + continue; + else if (mode == IEEE80211_MODE_11B) + mode = IEEE80211_MODE_11G; /* upgrade */ + } } } else { /* @@ -732,7 +736,7 @@ sta_cancel(struct ieee80211_scan_state *ss, struct ieee80211vap *vap) return 0; } -/* unalligned little endian access */ +/* unaligned little endian access */ #define LE_READ_2(p) \ ((uint16_t) \ ((((const uint8_t *)(p))[0] ) | \ diff --git a/sys/net80211/ieee80211_scan_sw.c b/sys/net80211/ieee80211_scan_sw.c new file mode 100644 index 0000000..70b4673 --- /dev/null +++ b/sys/net80211/ieee80211_scan_sw.c @@ -0,0 +1,948 @@ +/*- + * Copyright (c) 2002-2008 Sam Leffler, Errno Consulting + * 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$"); + +/* + * IEEE 802.11 scanning support. + */ +#include "opt_wlan.h" + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/kernel.h> +#include <sys/condvar.h> + +#include <sys/socket.h> + +#include <net/if.h> +#include <net/if_var.h> +#include <net/if_media.h> +#include <net/ethernet.h> + +#include <net80211/ieee80211_var.h> + +#include <net80211/ieee80211_scan_sw.h> + +#include <net/bpf.h> + +struct scan_state { + struct ieee80211_scan_state base; /* public state */ + + u_int ss_iflags; /* flags used internally */ +#define ISCAN_MINDWELL 0x0001 /* min dwell time reached */ +#define ISCAN_DISCARD 0x0002 /* discard rx'd frames */ +#define ISCAN_CANCEL 0x0004 /* cancel current scan */ +#define ISCAN_ABORT 0x0008 /* end the scan immediately */ + unsigned long ss_chanmindwell; /* min dwell on curchan */ + unsigned long ss_scanend; /* time scan must stop */ + u_int ss_duration; /* duration for next scan */ + struct task ss_scan_task; /* scan execution */ + struct cv ss_scan_cv; /* scan signal */ + struct callout ss_scan_timer; /* scan timer */ +}; +#define SCAN_PRIVATE(ss) ((struct scan_state *) ss) + +/* + * Amount of time to go off-channel during a background + * scan. This value should be large enough to catch most + * ap's but short enough that we can return on-channel + * before our listen interval expires. + * + * XXX tunable + * XXX check against configured listen interval + */ +#define IEEE80211_SCAN_OFFCHANNEL msecs_to_ticks(150) + +/* + * Roaming-related defaults. RSSI thresholds are as returned by the + * driver (.5dBm). Transmit rate thresholds are IEEE rate codes (i.e + * .5M units) or MCS. + */ +/* rssi thresholds */ +#define ROAM_RSSI_11A_DEFAULT 14 /* 11a bss */ +#define ROAM_RSSI_11B_DEFAULT 14 /* 11b bss */ +#define ROAM_RSSI_11BONLY_DEFAULT 14 /* 11b-only bss */ +/* transmit rate thresholds */ +#define ROAM_RATE_11A_DEFAULT 2*12 /* 11a bss */ +#define ROAM_RATE_11B_DEFAULT 2*5 /* 11b bss */ +#define ROAM_RATE_11BONLY_DEFAULT 2*1 /* 11b-only bss */ +#define ROAM_RATE_HALF_DEFAULT 2*6 /* half-width 11a/g bss */ +#define ROAM_RATE_QUARTER_DEFAULT 2*3 /* quarter-width 11a/g bss */ +#define ROAM_MCS_11N_DEFAULT (1 | IEEE80211_RATE_MCS) /* 11n bss */ + +static void scan_curchan(struct ieee80211_scan_state *, unsigned long); +static void scan_mindwell(struct ieee80211_scan_state *); +static void scan_signal(void *); +static void scan_task(void *, int); + +MALLOC_DEFINE(M_80211_SCAN, "80211scan", "802.11 scan state"); + +void +ieee80211_swscan_attach(struct ieee80211com *ic) +{ + struct scan_state *ss; + + ss = (struct scan_state *) malloc(sizeof(struct scan_state), + M_80211_SCAN, M_NOWAIT | M_ZERO); + if (ss == NULL) { + ic->ic_scan = NULL; + return; + } + callout_init_mtx(&ss->ss_scan_timer, IEEE80211_LOCK_OBJ(ic), 0); + cv_init(&ss->ss_scan_cv, "scan"); + TASK_INIT(&ss->ss_scan_task, 0, scan_task, ss); + + ic->ic_scan = &ss->base; + ss->base.ss_ic = ic; + + ic->ic_scan_curchan = scan_curchan; + ic->ic_scan_mindwell = scan_mindwell; + + /* + * TODO: all of the non-vap scan calls should be methods! + */ +} + +void +ieee80211_swscan_detach(struct ieee80211com *ic) +{ + struct ieee80211_scan_state *ss = ic->ic_scan; + + if (ss != NULL) { + IEEE80211_LOCK(ic); + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT; + scan_signal(ss); + IEEE80211_UNLOCK(ic); + ieee80211_draintask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); + callout_drain(&SCAN_PRIVATE(ss)->ss_scan_timer); + KASSERT((ic->ic_flags & IEEE80211_F_SCAN) == 0, + ("scan still running")); + + /* + * For now, do the ss_ops detach here rather + * than ieee80211_scan_detach(). + * + * I'll figure out how to cleanly split things up + * at a later date. + */ + if (ss->ss_ops != NULL) { + ss->ss_ops->scan_detach(ss); + ss->ss_ops = NULL; + } + ic->ic_scan = NULL; + free(SCAN_PRIVATE(ss), M_80211_SCAN); + } +} + +void +ieee80211_swscan_vattach(struct ieee80211vap *vap) +{ + /* nothing to do for now */ + /* + * TODO: all of the vap scan calls should be methods! + */ + +} + +void +ieee80211_swscan_vdetach(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss; + + IEEE80211_LOCK_ASSERT(ic); + ss = ic->ic_scan; + if (ss != NULL && ss->ss_vap == vap) { + if (ic->ic_flags & IEEE80211_F_SCAN) { + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT; + scan_signal(ss); + } + } +} + +void +ieee80211_swscan_set_scan_duration(struct ieee80211vap *vap, u_int duration) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + IEEE80211_LOCK_ASSERT(ic); + + /* NB: flush frames rx'd before 1st channel change */ + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_DISCARD; + SCAN_PRIVATE(ss)->ss_duration = duration; +} + +void +ieee80211_swscan_run_scan_task(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + IEEE80211_LOCK_ASSERT(ic); + + ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); +} + +/* + * Start a scan unless one is already going. + */ +static int +ieee80211_swscan_start_scan_locked(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags, u_int duration, + u_int mindwell, u_int maxdwell, + u_int nssid, const struct ieee80211_scan_ssid ssids[]) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + IEEE80211_LOCK_ASSERT(ic); + + if (ic->ic_flags & IEEE80211_F_CSAPENDING) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: scan inhibited by pending channel change\n", __func__); + } else if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: %s scan, duration %u mindwell %u maxdwell %u, desired mode %s, %s%s%s%s%s%s\n" + , __func__ + , flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive" + , duration, mindwell, maxdwell + , ieee80211_phymode_name[vap->iv_des_mode] + , flags & IEEE80211_SCAN_FLUSH ? "flush" : "append" + , flags & IEEE80211_SCAN_NOPICK ? ", nopick" : "" + , flags & IEEE80211_SCAN_NOJOIN ? ", nojoin" : "" + , flags & IEEE80211_SCAN_NOBCAST ? ", nobcast" : "" + , flags & IEEE80211_SCAN_PICK1ST ? ", pick1st" : "" + , flags & IEEE80211_SCAN_ONCE ? ", once" : "" + ); + + ieee80211_scan_update_locked(vap, scan); + if (ss->ss_ops != NULL) { + if ((flags & IEEE80211_SCAN_NOSSID) == 0) + ieee80211_scan_copy_ssid(vap, ss, nssid, ssids); + + /* NB: top 4 bits for internal use */ + ss->ss_flags = flags & 0xfff; + if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) + vap->iv_stats.is_scan_active++; + else + vap->iv_stats.is_scan_passive++; + if (flags & IEEE80211_SCAN_FLUSH) + ss->ss_ops->scan_flush(ss); + if (flags & IEEE80211_SCAN_BGSCAN) + ic->ic_flags_ext |= IEEE80211_FEXT_BGSCAN; + + /* Set duration for this particular scan */ + ieee80211_swscan_set_scan_duration(vap, duration); + + ss->ss_next = 0; + ss->ss_mindwell = mindwell; + ss->ss_maxdwell = maxdwell; + /* NB: scan_start must be before the scan runtask */ + ss->ss_ops->scan_start(ss, vap); +#ifdef IEEE80211_DEBUG + if (ieee80211_msg_scan(vap)) + ieee80211_scan_dump(ss); +#endif /* IEEE80211_DEBUG */ + ic->ic_flags |= IEEE80211_F_SCAN; + + /* Start scan task */ + ieee80211_swscan_run_scan_task(vap); + } + return 1; + } else { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: %s scan already in progress\n", __func__, + ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive"); + } + return 0; +} + + +/* + * Start a scan unless one is already going. + * + * Called without the comlock held; grab the comlock as appropriate. + */ +int +ieee80211_swscan_start_scan(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags, + u_int duration, u_int mindwell, u_int maxdwell, + u_int nssid, const struct ieee80211_scan_ssid ssids[]) +{ + struct ieee80211com *ic = vap->iv_ic; + int result; + + IEEE80211_UNLOCK_ASSERT(ic); + + IEEE80211_LOCK(ic); + result = ieee80211_swscan_start_scan_locked(scan, vap, flags, duration, + mindwell, maxdwell, nssid, ssids); + IEEE80211_UNLOCK(ic); + + return result; +} + +/* + * Check the scan cache for an ap/channel to use; if that + * fails then kick off a new scan. + * + * Called with the comlock held. + * + * XXX TODO: split out! + */ +int +ieee80211_swscan_check_scan(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags, + u_int duration, u_int mindwell, u_int maxdwell, + u_int nssid, const struct ieee80211_scan_ssid ssids[]) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + int result; + + IEEE80211_LOCK_ASSERT(ic); + + if (ss->ss_ops != NULL) { + /* XXX verify ss_ops matches vap->iv_opmode */ + if ((flags & IEEE80211_SCAN_NOSSID) == 0) { + /* + * Update the ssid list and mark flags so if + * we call start_scan it doesn't duplicate work. + */ + ieee80211_scan_copy_ssid(vap, ss, nssid, ssids); + flags |= IEEE80211_SCAN_NOSSID; + } + if ((ic->ic_flags & IEEE80211_F_SCAN) == 0 && + (flags & IEEE80211_SCAN_FLUSH) == 0 && + time_before(ticks, ic->ic_lastscan + vap->iv_scanvalid)) { + /* + * We're not currently scanning and the cache is + * deemed hot enough to consult. Lock out others + * by marking IEEE80211_F_SCAN while we decide if + * something is already in the scan cache we can + * use. Also discard any frames that might come + * in while temporarily marked as scanning. + */ + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_DISCARD; + ic->ic_flags |= IEEE80211_F_SCAN; + + /* NB: need to use supplied flags in check */ + ss->ss_flags = flags & 0xff; + result = ss->ss_ops->scan_end(ss, vap); + + ic->ic_flags &= ~IEEE80211_F_SCAN; + SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_DISCARD; + if (result) { + ieee80211_notify_scan_done(vap); + return 1; + } + } + } + result = ieee80211_swscan_start_scan_locked(scan, vap, flags, duration, + mindwell, maxdwell, nssid, ssids); + + return result; +} + +/* + * Restart a previous scan. If the previous scan completed + * then we start again using the existing channel list. + */ +int +ieee80211_swscan_bg_scan(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + /* XXX assert unlocked? */ + // IEEE80211_UNLOCK_ASSERT(ic); + + IEEE80211_LOCK(ic); + if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) { + u_int duration; + /* + * Go off-channel for a fixed interval that is large + * enough to catch most ap's but short enough that + * we can return on-channel before our listen interval + * expires. + */ + duration = IEEE80211_SCAN_OFFCHANNEL; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: %s scan, ticks %u duration %lu\n", __func__, + ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive", + ticks, duration); + + ieee80211_scan_update_locked(vap, scan); + if (ss->ss_ops != NULL) { + ss->ss_vap = vap; + /* + * A background scan does not select a new sta; it + * just refreshes the scan cache. Also, indicate + * the scan logic should follow the beacon schedule: + * we go off-channel and scan for a while, then + * return to the bss channel to receive a beacon, + * then go off-channel again. All during this time + * we notify the ap we're in power save mode. When + * the scan is complete we leave power save mode. + * If any beacon indicates there are frames pending + * for us then we drop out of power save mode + * (and background scan) automatically by way of the + * usual sta power save logic. + */ + ss->ss_flags |= IEEE80211_SCAN_NOPICK + | IEEE80211_SCAN_BGSCAN + | flags + ; + /* if previous scan completed, restart */ + if (ss->ss_next >= ss->ss_last) { + if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) + vap->iv_stats.is_scan_active++; + else + vap->iv_stats.is_scan_passive++; + /* + * NB: beware of the scan cache being flushed; + * if the channel list is empty use the + * scan_start method to populate it. + */ + ss->ss_next = 0; + if (ss->ss_last != 0) + ss->ss_ops->scan_restart(ss, vap); + else { + ss->ss_ops->scan_start(ss, vap); +#ifdef IEEE80211_DEBUG + if (ieee80211_msg_scan(vap)) + ieee80211_scan_dump(ss); +#endif /* IEEE80211_DEBUG */ + } + } + ieee80211_swscan_set_scan_duration(vap, duration); + ss->ss_maxdwell = duration; + ic->ic_flags |= IEEE80211_F_SCAN; + ic->ic_flags_ext |= IEEE80211_FEXT_BGSCAN; + ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); + } else { + /* XXX msg+stat */ + } + } else { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: %s scan already in progress\n", __func__, + ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive"); + } + IEEE80211_UNLOCK(ic); + + /* NB: racey, does it matter? */ + return (ic->ic_flags & IEEE80211_F_SCAN); +} + +/* + * Cancel any scan currently going on for the specified vap. + */ +void +ieee80211_swscan_cancel_scan(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + IEEE80211_LOCK(ic); + if ((ic->ic_flags & IEEE80211_F_SCAN) && + ss->ss_vap == vap && + (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: cancel %s scan\n", __func__, + ss->ss_flags & IEEE80211_SCAN_ACTIVE ? + "active" : "passive"); + + /* clear bg scan NOPICK and mark cancel request */ + ss->ss_flags &= ~IEEE80211_SCAN_NOPICK; + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_CANCEL; + /* wake up the scan task */ + scan_signal(ss); + } else { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: called; F_SCAN=%d, vap=%s, CANCEL=%d\n", + __func__, + !! (ic->ic_flags & IEEE80211_F_SCAN), + (ss->ss_vap == vap ? "match" : "nomatch"), + !! (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL)); + } + IEEE80211_UNLOCK(ic); +} + +/* + * Cancel any scan currently going on. + */ +void +ieee80211_swscan_cancel_anyscan(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + IEEE80211_LOCK(ic); + if ((ic->ic_flags & IEEE80211_F_SCAN) && + (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: cancel %s scan\n", __func__, + ss->ss_flags & IEEE80211_SCAN_ACTIVE ? + "active" : "passive"); + + /* clear bg scan NOPICK and mark cancel request */ + ss->ss_flags &= ~IEEE80211_SCAN_NOPICK; + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_CANCEL; + /* wake up the scan task */ + scan_signal(ss); + } else { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: called; F_SCAN=%d, vap=%s, CANCEL=%d\n", + __func__, + !! (ic->ic_flags & IEEE80211_F_SCAN), + (ss->ss_vap == vap ? "match" : "nomatch"), + !! (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL)); + } + IEEE80211_UNLOCK(ic); +} + +/* + * Public access to scan_next for drivers that manage + * scanning themselves (e.g. for firmware-based devices). + */ +void +ieee80211_swscan_scan_next(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s: called\n", __func__); + + /* wake up the scan task */ + IEEE80211_LOCK(ic); + scan_signal(ss); + IEEE80211_UNLOCK(ic); +} + +/* + * Public access to scan_next for drivers that are not able to scan single + * channels (e.g. for firmware-based devices). + */ +void +ieee80211_swscan_scan_done(struct ieee80211vap *vap) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss; + + IEEE80211_LOCK_ASSERT(ic); + + ss = ic->ic_scan; + scan_signal(ss); +} + +/* + * Probe the curent channel, if allowed, while scanning. + * If the channel is not marked passive-only then send + * a probe request immediately. Otherwise mark state and + * listen for beacons on the channel; if we receive something + * then we'll transmit a probe request. + */ +void +ieee80211_swscan_probe_curchan(struct ieee80211vap *vap, int force) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + struct ifnet *ifp = vap->iv_ifp; + int i; + + /* + * Send directed probe requests followed by any + * broadcast probe request. + * XXX remove dependence on ic/vap->iv_bss + */ + for (i = 0; i < ss->ss_nssid; i++) + ieee80211_send_probereq(vap->iv_bss, + vap->iv_myaddr, ifp->if_broadcastaddr, + ifp->if_broadcastaddr, + ss->ss_ssid[i].ssid, ss->ss_ssid[i].len); + if ((ss->ss_flags & IEEE80211_SCAN_NOBCAST) == 0) + ieee80211_send_probereq(vap->iv_bss, + vap->iv_myaddr, ifp->if_broadcastaddr, + ifp->if_broadcastaddr, + "", 0); +} + +/* + * Scan curchan. If this is an active scan and the channel + * is not marked passive then send probe request frame(s). + * Arrange for the channel change after maxdwell ticks. + */ +static void +scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) +{ + struct ieee80211vap *vap = ss->ss_vap; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: calling; maxdwell=%lu\n", + __func__, + maxdwell); + IEEE80211_LOCK(vap->iv_ic); + if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) + ieee80211_probe_curchan(vap, 0); + callout_reset(&SCAN_PRIVATE(ss)->ss_scan_timer, + maxdwell, scan_signal, ss); + IEEE80211_UNLOCK(vap->iv_ic); +} + +static void +scan_signal(void *arg) +{ + struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg; + + IEEE80211_LOCK_ASSERT(ss->ss_ic); + cv_signal(&SCAN_PRIVATE(ss)->ss_scan_cv); +} + +/* + * Handle mindwell requirements completed; initiate a channel + * change to the next channel asap. + */ +static void +scan_mindwell(struct ieee80211_scan_state *ss) +{ + struct ieee80211com *ic = ss->ss_ic; + + IEEE80211_DPRINTF(ss->ss_vap, IEEE80211_MSG_SCAN, "%s: called\n", __func__); + + IEEE80211_LOCK(ic); + scan_signal(ss); + IEEE80211_UNLOCK(ic); +} + +static void +scan_task(void *arg, int pending) +{ +#define ISCAN_REP (ISCAN_MINDWELL | ISCAN_DISCARD) + struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg; + struct ieee80211vap *vap = ss->ss_vap; + struct ieee80211com *ic = ss->ss_ic; + struct ieee80211_channel *chan; + unsigned long maxdwell, scanend; + int scandone = 0; + + IEEE80211_LOCK(ic); + if (vap == NULL || (ic->ic_flags & IEEE80211_F_SCAN) == 0 || + (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)) { + /* Cancelled before we started */ + goto done; + } + + if (ss->ss_next == ss->ss_last) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: no channels to scan\n", __func__); + scandone = 1; + goto done; + } + + if (vap->iv_opmode == IEEE80211_M_STA && + vap->iv_state == IEEE80211_S_RUN) { + if ((vap->iv_bss->ni_flags & IEEE80211_NODE_PWR_MGT) == 0) { + /* Enable station power save mode */ + vap->iv_sta_ps(vap, 1); + /* + * Use an 1ms delay so the null data frame has a chance + * to go out. + * XXX Should use M_TXCB mechanism to eliminate this. + */ + cv_timedwait(&SCAN_PRIVATE(ss)->ss_scan_cv, + IEEE80211_LOCK_OBJ(ic), hz / 1000); + if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) + goto done; + } + } + + scanend = ticks + SCAN_PRIVATE(ss)->ss_duration; + + /* XXX scan state can change! Re-validate scan state! */ + + IEEE80211_UNLOCK(ic); + ic->ic_scan_start(ic); /* notify driver */ + IEEE80211_LOCK(ic); + + for (;;) { + + scandone = (ss->ss_next >= ss->ss_last) || + (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: loop start; scandone=%d\n", + __func__, + scandone); + + if (scandone || (ss->ss_flags & IEEE80211_SCAN_GOTPICK) || + (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) || + time_after(ticks + ss->ss_mindwell, scanend)) + break; + + chan = ss->ss_chans[ss->ss_next++]; + + /* + * Watch for truncation due to the scan end time. + */ + if (time_after(ticks + ss->ss_maxdwell, scanend)) + maxdwell = scanend - ticks; + else + maxdwell = ss->ss_maxdwell; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: chan %3d%c -> %3d%c [%s, dwell min %lums max %lums]\n", + __func__, + ieee80211_chan2ieee(ic, ic->ic_curchan), + ieee80211_channel_type_char(ic->ic_curchan), + ieee80211_chan2ieee(ic, chan), + ieee80211_channel_type_char(chan), + (ss->ss_flags & IEEE80211_SCAN_ACTIVE) && + (chan->ic_flags & IEEE80211_CHAN_PASSIVE) == 0 ? + "active" : "passive", + ticks_to_msecs(ss->ss_mindwell), ticks_to_msecs(maxdwell)); + + /* + * Potentially change channel and phy mode. + */ + ic->ic_curchan = chan; + ic->ic_rt = ieee80211_get_ratetable(chan); + IEEE80211_UNLOCK(ic); + /* + * Perform the channel change and scan unlocked so the driver + * may sleep. Once set_channel returns the hardware has + * completed the channel change. + */ + ic->ic_set_channel(ic); + ieee80211_radiotap_chan_change(ic); + + /* + * Scan curchan. Drivers for "intelligent hardware" + * override ic_scan_curchan to tell the device to do + * the work. Otherwise we manage the work outselves; + * sending a probe request (as needed), and arming the + * timeout to switch channels after maxdwell ticks. + * + * scan_curchan should only pause for the time required to + * prepare/initiate the hardware for the scan (if at all), the + * below condvar is used to sleep for the channels dwell time + * and allows it to be signalled for abort. + */ + ic->ic_scan_curchan(ss, maxdwell); + IEEE80211_LOCK(ic); + + /* XXX scan state can change! Re-validate scan state! */ + + SCAN_PRIVATE(ss)->ss_chanmindwell = ticks + ss->ss_mindwell; + /* clear mindwell lock and initial channel change flush */ + SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_REP; + + if ((SCAN_PRIVATE(ss)->ss_iflags & (ISCAN_CANCEL|ISCAN_ABORT))) + continue; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s: waiting\n", __func__); + /* Wait to be signalled to scan the next channel */ + cv_wait(&SCAN_PRIVATE(ss)->ss_scan_cv, IEEE80211_LOCK_OBJ(ic)); + } + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s: out\n", __func__); + + if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) + goto done; + + IEEE80211_UNLOCK(ic); + ic->ic_scan_end(ic); /* notify driver */ + IEEE80211_LOCK(ic); + /* XXX scan state can change! Re-validate scan state! */ + + /* + * Since a cancellation may have occured during one of the + * driver calls (whilst unlocked), update scandone. + */ + if (scandone == 0 && + ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0)) { + /* XXX printf? */ + if_printf(vap->iv_ifp, + "%s: OOPS! scan cancelled during driver call (1)!\n", + __func__); + scandone = 1; + } + + /* + * Record scan complete time. Note that we also do + * this when canceled so any background scan will + * not be restarted for a while. + */ + if (scandone) + ic->ic_lastscan = ticks; + /* return to the bss channel */ + if (ic->ic_bsschan != IEEE80211_CHAN_ANYC && + ic->ic_curchan != ic->ic_bsschan) { + ieee80211_setupcurchan(ic, ic->ic_bsschan); + IEEE80211_UNLOCK(ic); + ic->ic_set_channel(ic); + ieee80211_radiotap_chan_change(ic); + IEEE80211_LOCK(ic); + } + /* clear internal flags and any indication of a pick */ + SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_REP; + ss->ss_flags &= ~IEEE80211_SCAN_GOTPICK; + + /* + * If not canceled and scan completed, do post-processing. + * If the callback function returns 0, then it wants to + * continue/restart scanning. Unfortunately we needed to + * notify the driver to end the scan above to avoid having + * rx frames alter the scan candidate list. + */ + if ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0 && + !ss->ss_ops->scan_end(ss, vap) && + (ss->ss_flags & IEEE80211_SCAN_ONCE) == 0 && + time_before(ticks + ss->ss_mindwell, scanend)) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: done, restart " + "[ticks %u, dwell min %lu scanend %lu]\n", + __func__, + ticks, ss->ss_mindwell, scanend); + ss->ss_next = 0; /* reset to begining */ + if (ss->ss_flags & IEEE80211_SCAN_ACTIVE) + vap->iv_stats.is_scan_active++; + else + vap->iv_stats.is_scan_passive++; + + ss->ss_ops->scan_restart(ss, vap); /* XXX? */ + ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task); + IEEE80211_UNLOCK(ic); + return; + } + + /* past here, scandone is ``true'' if not in bg mode */ + if ((ss->ss_flags & IEEE80211_SCAN_BGSCAN) == 0) + scandone = 1; + + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: %s, [ticks %u, dwell min %lu scanend %lu]\n", + __func__, scandone ? "done" : "stopped", + ticks, ss->ss_mindwell, scanend); + + /* + * Since a cancellation may have occured during one of the + * driver calls (whilst unlocked), update scandone. + */ + if (scandone == 0 && + ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0)) { + /* XXX printf? */ + if_printf(vap->iv_ifp, + "%s: OOPS! scan cancelled during driver call (2)!\n", + __func__); + scandone = 1; + } + + /* + * Clear the SCAN bit first in case frames are + * pending on the station power save queue. If + * we defer this then the dispatch of the frames + * may generate a request to cancel scanning. + */ +done: + ic->ic_flags &= ~IEEE80211_F_SCAN; + /* + * Drop out of power save mode when a scan has + * completed. If this scan was prematurely terminated + * because it is a background scan then don't notify + * the ap; we'll either return to scanning after we + * receive the beacon frame or we'll drop out of power + * save mode because the beacon indicates we have frames + * waiting for us. + */ + if (scandone) { + vap->iv_sta_ps(vap, 0); + if (ss->ss_next >= ss->ss_last) { + ieee80211_notify_scan_done(vap); + ic->ic_flags_ext &= ~IEEE80211_FEXT_BGSCAN; + } + } + SCAN_PRIVATE(ss)->ss_iflags &= ~(ISCAN_CANCEL|ISCAN_ABORT); + ss->ss_flags &= ~(IEEE80211_SCAN_ONCE | IEEE80211_SCAN_PICK1ST); + IEEE80211_UNLOCK(ic); +#undef ISCAN_REP +} + +/* + * Process a beacon or probe response frame. + */ +void +ieee80211_swscan_add_scan(struct ieee80211vap *vap, + struct ieee80211_channel *curchan, + const struct ieee80211_scanparams *sp, + const struct ieee80211_frame *wh, + int subtype, int rssi, int noise) +{ + struct ieee80211com *ic = vap->iv_ic; + struct ieee80211_scan_state *ss = ic->ic_scan; + + /* XXX locking */ + /* + * Frames received during startup are discarded to avoid + * using scan state setup on the initial entry to the timer + * callback. This can occur because the device may enable + * rx prior to our doing the initial channel change in the + * timer routine. + */ + if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_DISCARD) + return; +#ifdef IEEE80211_DEBUG + if (ieee80211_msg_scan(vap) && (ic->ic_flags & IEEE80211_F_SCAN)) + ieee80211_scan_dump_probe_beacon(subtype, 1, wh->i_addr2, sp, rssi); +#endif + if (ss->ss_ops != NULL && + ss->ss_ops->scan_add(ss, curchan, sp, wh, subtype, rssi, noise)) { + /* + * If we've reached the min dwell time terminate + * the timer so we'll switch to the next channel. + */ + if ((SCAN_PRIVATE(ss)->ss_iflags & ISCAN_MINDWELL) == 0 && + time_after_eq(ticks, SCAN_PRIVATE(ss)->ss_chanmindwell)) { + IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, + "%s: chan %3d%c min dwell met (%u > %lu)\n", + __func__, + ieee80211_chan2ieee(ic, ic->ic_curchan), + ieee80211_channel_type_char(ic->ic_curchan), + ticks, SCAN_PRIVATE(ss)->ss_chanmindwell); + SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_MINDWELL; + /* + * NB: trigger at next clock tick or wait for the + * hardware. + */ + ic->ic_scan_mindwell(ss); + } + } +} + diff --git a/sys/net80211/ieee80211_scan_sw.h b/sys/net80211/ieee80211_scan_sw.h new file mode 100644 index 0000000..7bb0cc3 --- /dev/null +++ b/sys/net80211/ieee80211_scan_sw.h @@ -0,0 +1,61 @@ +/*- + * Copyright (c) 2015 Adrian Chadd <adrian@FreeBSD.org> + * 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. + * + * $FreeBSD$ + */ +#ifndef __NET80211_IEEE80211_SCAN_SW_H__ +#define __NET80211_IEEE80211_SCAN_SW_H__ + +extern void ieee80211_swscan_attach(struct ieee80211com *ic); +extern void ieee80211_swscan_detach(struct ieee80211com *ic); + +extern void ieee80211_swscan_vattach(struct ieee80211vap *vap); +extern void ieee80211_swscan_vdetach(struct ieee80211vap *vap); + +extern int ieee80211_swscan_start_scan(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags, + u_int duration, u_int mindwell, u_int maxdwell, + u_int nssid, const struct ieee80211_scan_ssid ssids[]); +extern void ieee80211_swscan_set_scan_duration(struct ieee80211vap *vap, + u_int duration); +extern void ieee80211_swscan_run_scan_task(struct ieee80211vap *vap); +extern int ieee80211_swscan_check_scan(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags, + u_int duration, u_int mindwell, u_int maxdwell, + u_int nssid, const struct ieee80211_scan_ssid ssids[]); +extern int ieee80211_swscan_bg_scan(const struct ieee80211_scanner *scan, + struct ieee80211vap *vap, int flags); +extern void ieee80211_swscan_cancel_scan(struct ieee80211vap *vap); +extern void ieee80211_swscan_cancel_anyscan(struct ieee80211vap *vap); +extern void ieee80211_swscan_scan_next(struct ieee80211vap *vap); +extern void ieee80211_swscan_scan_done(struct ieee80211vap *vap); +extern void ieee80211_swscan_probe_curchan(struct ieee80211vap *vap, + int force); +extern void ieee80211_swscan_add_scan(struct ieee80211vap *vap, + struct ieee80211_channel *curchan, + const struct ieee80211_scanparams *sp, + const struct ieee80211_frame *wh, + int subtype, int rssi, int noise); + +#endif /* __NET80211_IEEE80211_SCAN_SW_H__ */ diff --git a/sys/net80211/ieee80211_sta.c b/sys/net80211/ieee80211_sta.c index 8685e4b..267ad11 100644 --- a/sys/net80211/ieee80211_sta.c +++ b/sys/net80211/ieee80211_sta.c @@ -234,6 +234,7 @@ sta_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) switch (ostate) { case IEEE80211_S_SLEEP: /* XXX wakeup */ + /* XXX driver hook to wakeup the hardware? */ case IEEE80211_S_RUN: IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_DISASSOC, @@ -299,12 +300,18 @@ sta_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) if (vap->iv_roaming == IEEE80211_ROAMING_AUTO) ieee80211_check_scan_current(vap); break; + case IEEE80211_S_SLEEP: /* beacon miss */ + /* + * XXX if in sleep we need to wakeup the hardware. + */ + /* FALLTHROUGH */ case IEEE80211_S_RUN: /* beacon miss */ /* * Beacon miss. Notify user space and if not * under control of a user application (roaming * manual) kick off a scan to re-connect. */ + ieee80211_sta_leave(ni); if (vap->iv_roaming == IEEE80211_ROAMING_AUTO) ieee80211_check_scan_current(vap); @@ -403,6 +410,7 @@ sta_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) arg == IEEE80211_FC0_SUBTYPE_ASSOC_RESP); break; case IEEE80211_S_SLEEP: + /* Wake up from sleep */ vap->iv_sta_ps(vap, 0); break; default: @@ -430,9 +438,11 @@ sta_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) ieee80211_node_authorize(ni); /* * Fake association when joining an existing bss. + * + * Don't do this if we're doing SLEEP->RUN. */ - if (ic->ic_newassoc != NULL) - ic->ic_newassoc(vap->iv_bss, ostate != IEEE80211_S_RUN); + if (ic->ic_newassoc != NULL && ostate != IEEE80211_S_SLEEP) + ic->ic_newassoc(vap->iv_bss, (ostate != IEEE80211_S_RUN)); break; case IEEE80211_S_CSA: if (ostate != IEEE80211_S_RUN) @@ -517,7 +527,6 @@ doprint(struct ieee80211vap *vap, int subtype) static int sta_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) { -#define HAS_SEQ(type) ((type & 0x4) == 0) struct ieee80211vap *vap = ni->ni_vap; struct ieee80211com *ic = ni->ni_ic; struct ifnet *ifp = vap->iv_ifp; @@ -613,7 +622,8 @@ sta_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) IEEE80211_RSSI_LPF(ni->ni_avgrssi, rssi); ni->ni_noise = nf; - if (HAS_SEQ(type) && !IEEE80211_IS_MULTICAST(wh->i_addr1)) { + if ( IEEE80211_HAS_SEQ(type, subtype) && + !IEEE80211_IS_MULTICAST(wh->i_addr1)) { uint8_t tid = ieee80211_gettid(wh); if (IEEE80211_QOS_HAS_SEQ(wh) && TID_TO_WME_AC(tid) >= WME_AC_VI) @@ -928,7 +938,7 @@ sta_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) break; } err: - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); out: if (m != NULL) { if (need_tap && ieee80211_radiotap_active_vap(vap)) @@ -1312,6 +1322,7 @@ sta_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, vap->iv_stats.is_beacon_bad++; return; } + /* * Count frame now that we know it's to be processed. */ @@ -1381,25 +1392,66 @@ sta_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, } if (scan.quiet) ic->ic_set_quiet(ni, scan.quiet); + if (scan.tim != NULL) { struct ieee80211_tim_ie *tim = (struct ieee80211_tim_ie *) scan.tim; -#if 0 + /* + * XXX Check/debug this code; see if it's about + * the right time to force the VAP awake if we + * receive a frame destined for us? + */ int aid = IEEE80211_AID(ni->ni_associd); int ix = aid / NBBY; int min = tim->tim_bitctl &~ 1; int max = tim->tim_len + min - 4; - if ((tim->tim_bitctl&1) || - (min <= ix && ix <= max && - isset(tim->tim_bitmap - min, aid))) { - /* - * XXX Do not let bg scan kick off - * we are expecting data. + int tim_ucast = 0, tim_mcast = 0; + + /* + * Only do this for unicast traffic in the TIM + * The multicast traffic notification for + * the scan notification stuff should occur + * differently. + */ + if (min <= ix && ix <= max && + isset(tim->tim_bitmap - min, aid)) { + tim_ucast = 1; + } + + /* + * Do a separate notification + * for the multicast bit being set. + */ + if (tim->tim_bitctl & 1) { + tim_mcast = 1; + } + + /* + * If the TIM indicates there's traffic for + * us then get us out of STA mode powersave. + */ + if (tim_ucast == 1) { + + /* + * Wake us out of SLEEP state if we're + * in it; and if we're doing bgscan + * then wake us out of STA powersave. + */ + ieee80211_sta_tim_notify(vap, 1); + + /* + * This is preventing us from + * continuing a bgscan; because it + * tricks the contbgscan() + * routine to think there's always + * traffic for us. + * + * I think we need both an RX and + * TX ic_lastdata field. */ ic->ic_lastdata = ticks; - vap->iv_sta_ps(vap, 0); } -#endif + ni->ni_dtim_count = tim->tim_count; ni->ni_dtim_period = tim->tim_period; } @@ -1432,8 +1484,8 @@ sta_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, * our ap. */ if (ic->ic_flags & IEEE80211_F_SCAN) { - ieee80211_add_scan(vap, &scan, wh, - subtype, rssi, nf); + ieee80211_add_scan(vap, ic->ic_curchan, + &scan, wh, subtype, rssi, nf); } else if (contbgscan(vap)) { ieee80211_bg_scan(vap, 0); } else if (startbgscan(vap)) { @@ -1446,6 +1498,14 @@ sta_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, } /* + * Put the station to sleep if we haven't seen + * traffic in a while. + */ + IEEE80211_LOCK(ic); + ieee80211_sta_ps_timer_check(vap); + IEEE80211_UNLOCK(ic); + + /* * If we've had a channel width change (eg HT20<->HT40) * then schedule a delayed driver notification. */ @@ -1469,7 +1529,8 @@ sta_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, ieee80211_probe_curchan(vap, 1); ic->ic_flags_ext &= ~IEEE80211_FEXT_PROBECHAN; } - ieee80211_add_scan(vap, &scan, wh, subtype, rssi, nf); + ieee80211_add_scan(vap, ic->ic_curchan, &scan, wh, + subtype, rssi, nf); return; } break; diff --git a/sys/net80211/ieee80211_superg.c b/sys/net80211/ieee80211_superg.c index 461b5a1..81a4b43 100644 --- a/sys/net80211/ieee80211_superg.c +++ b/sys/net80211/ieee80211_superg.c @@ -38,11 +38,12 @@ __FBSDID("$FreeBSD$"); #include <sys/socket.h> -#include <net/bpf.h> -#include <net/ethernet.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_llc.h> #include <net/if_media.h> +#include <net/bpf.h> +#include <net/ethernet.h> #include <net80211/ieee80211_var.h> #include <net80211/ieee80211_input.h> @@ -479,7 +480,7 @@ ff_transmit(struct ieee80211_node *ni, struct mbuf *m) /* NB: IFQ_HANDOFF reclaims mbuf */ ieee80211_free_node(ni); } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); } } else ieee80211_free_node(ni); diff --git a/sys/net80211/ieee80211_var.h b/sys/net80211/ieee80211_var.h index 174fabc..4710697 100644 --- a/sys/net80211/ieee80211_var.h +++ b/sys/net80211/ieee80211_var.h @@ -629,6 +629,7 @@ MALLOC_DECLARE(M_80211_VAP); #define IEEE80211_C_MONITOR 0x00010000 /* CAPABILITY: monitor mode */ #define IEEE80211_C_DFS 0x00020000 /* CAPABILITY: DFS/radar avail*/ #define IEEE80211_C_MBSS 0x00040000 /* CAPABILITY: MBSS available */ +#define IEEE80211_C_SWSLEEP 0x00080000 /* CAPABILITY: do sleep here */ /* 0x7c0000 available */ #define IEEE80211_C_WPA1 0x00800000 /* CAPABILITY: WPA1 avail */ #define IEEE80211_C_WPA2 0x01000000 /* CAPABILITY: WPA2 avail */ @@ -710,6 +711,7 @@ int ieee80211_setmode(struct ieee80211com *, enum ieee80211_phymode); enum ieee80211_phymode ieee80211_chan2mode(const struct ieee80211_channel *); uint32_t ieee80211_mac_hash(const struct ieee80211com *, const uint8_t addr[IEEE80211_ADDR_LEN]); +char ieee80211_channel_type_char(const struct ieee80211_channel *c); void ieee80211_radiotap_attach(struct ieee80211com *, struct ieee80211_radiotap_header *th, int tlen, diff --git a/sys/net80211/ieee80211_wds.c b/sys/net80211/ieee80211_wds.c index d95b45f..fc77259 100644 --- a/sys/net80211/ieee80211_wds.c +++ b/sys/net80211/ieee80211_wds.c @@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$"); #include <sys/sysctl.h> #include <net/if.h> +#include <net/if_var.h> #include <net/if_media.h> #include <net/if_llc.h> #include <net/ethernet.h> @@ -257,14 +258,14 @@ ieee80211_dwds_mcast(struct ieee80211vap *vap0, struct mbuf *m) */ mcopy = m_copypacket(m, M_NOWAIT); if (mcopy == NULL) { - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); /* XXX stat + msg */ continue; } ni = ieee80211_find_txnode(vap, eh->ether_dhost); if (ni == NULL) { /* NB: ieee80211_find_txnode does stat+msg */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(mcopy); continue; } @@ -275,7 +276,7 @@ ieee80211_dwds_mcast(struct ieee80211vap *vap0, struct mbuf *m) eh->ether_dhost, NULL, "%s", "classification failure"); vap->iv_stats.is_tx_classify++; - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); m_freem(mcopy); ieee80211_free_node(ni); continue; @@ -298,10 +299,10 @@ ieee80211_dwds_mcast(struct ieee80211vap *vap0, struct mbuf *m) err = ieee80211_parent_xmitpkt(ic, mcopy); if (err) { /* NB: IFQ_HANDOFF reclaims mbuf */ - ifp->if_oerrors++; + if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); ieee80211_free_node(ni); } else { - ifp->if_opackets++; + if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1); if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len); @@ -409,7 +410,6 @@ wds_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) static int wds_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) { -#define HAS_SEQ(type) ((type & 0x4) == 0) struct ieee80211vap *vap = ni->ni_vap; struct ieee80211com *ic = ni->ni_ic; struct ifnet *ifp = vap->iv_ifp; @@ -491,7 +491,7 @@ wds_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) } IEEE80211_RSSI_LPF(ni->ni_avgrssi, rssi); ni->ni_noise = nf; - if (HAS_SEQ(type)) { + if (IEEE80211_HAS_SEQ(type, subtype)) { uint8_t tid = ieee80211_gettid(wh); if (IEEE80211_QOS_HAS_SEQ(wh) && TID_TO_WME_AC(tid) >= WME_AC_VI) @@ -733,7 +733,7 @@ wds_input(struct ieee80211_node *ni, struct mbuf *m, int rssi, int nf) break; } err: - ifp->if_ierrors++; + if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); out: if (m != NULL) { if (need_tap && ieee80211_radiotap_active_vap(vap)) diff --git a/sys/netgraph/ng_base.c b/sys/netgraph/ng_base.c index cc2d2d6..693b3ac 100644 --- a/sys/netgraph/ng_base.c +++ b/sys/netgraph/ng_base.c @@ -64,6 +64,10 @@ #include <sys/unistd.h> #include <machine/cpu.h> +#include <sys/socket.h> +#include <net/if.h> +#include <net/if_var.h> + #include <net/netisr.h> #include <net/vnet.h> @@ -240,6 +244,8 @@ int ng_path_parse(char *addr, char **node, char **path, char **hook); void ng_rmnode(node_p node, hook_p dummy1, void *dummy2, int dummy3); void ng_unname(node_p node); +extern void (*ng_ether_attach_p)(struct ifnet *ifp); + /* Our own netgraph malloc type */ MALLOC_DEFINE(M_NETGRAPH, "netgraph", "netgraph structures and ctrl messages"); MALLOC_DEFINE(M_NETGRAPH_MSG, "netgraph_msg", "netgraph name storage"); @@ -574,6 +580,13 @@ static const struct ng_cmdlist ng_generic_cmds[] = { &ng_parse_ng_mesg_type, &ng_parse_ng_mesg_type }, + { + NGM_GENERIC_COOKIE, + NGM_ETHER_ATTACH, + "attach", + &ng_parse_string_type, + NULL + }, { 0 } }; @@ -2908,6 +2921,17 @@ ng_generic_msg(node_p here, item_p item, hook_p lasthook) break; } + case NGM_ETHER_ATTACH: + { + struct ifnet *ifp; + ifp = ifunit((char *)msg->data); + if (ifp && ng_ether_attach_p != NULL) { + ng_ether_attach_p(ifp); + } + + break; + } + case NGM_TEXT_CONFIG: case NGM_TEXT_STATUS: /* diff --git a/sys/netgraph/ng_eiface.c b/sys/netgraph/ng_eiface.c index 0f471bb..24a8daa 100644 --- a/sys/netgraph/ng_eiface.c +++ b/sys/netgraph/ng_eiface.c @@ -43,6 +43,7 @@ #include <net/if.h> #include <net/if_media.h> #include <net/if_types.h> +#include <net/if_dl.h> #include <net/netisr.h> #include <net/route.h> #include <net/vnet.h> @@ -66,6 +67,13 @@ static const struct ng_cmdlist ng_eiface_cmdlist[] = { }, { NGM_EIFACE_COOKIE, + NGM_EIFACE_SET_IFNAME, + "setifname", + &ng_parse_string_type, + NULL + }, + { + NGM_EIFACE_COOKIE, NGM_EIFACE_SET, "set", &ng_parse_enaddr_type, @@ -470,6 +478,11 @@ ng_eiface_rcvmsg(node_p node, item_p item, hook_p lasthook) struct ng_mesg *resp = NULL; int error = 0; struct ng_mesg *msg; + char *new_name; + size_t namelen, onamelen; + struct sockaddr_dl *sdl = NULL; + struct ifaddr *ifa = NULL; + node_p ethernode; NGI_GET_MSG(item, msg); switch (msg->header.typecookie) { @@ -496,6 +509,46 @@ ng_eiface_rcvmsg(node_p node, item_p item, hook_p lasthook) } strlcpy(resp->data, ifp->if_xname, IFNAMSIZ); break; + case NGM_EIFACE_SET_IFNAME: + new_name = (char *)msg->data; + + /* Deny request if interface is UP */ + if ((ifp->if_flags & IFF_UP) != 0) { + error = EBUSY; + break; + } + + EVENTHANDLER_INVOKE(ifnet_departure_event, ifp); + + ethernode = ng_name2noderef(node, ifp->if_xname); + if (ethernode != NULL) + ng_name_node(ethernode, new_name); + + strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname)); + ifa = ifp->if_addr; + IFA_LOCK(ifa); + sdl = (struct sockaddr_dl *)ifa->ifa_addr; + namelen = strlen(new_name) + 1; + onamelen = sdl->sdl_nlen; + /* + * Move the address if needed. This is safe because we + * allocate space for a name of length IFNAMSIZ when we + * create this in if_attach(). + */ + if (namelen != onamelen) { + bcopy(sdl->sdl_data + onamelen, + sdl->sdl_data + namelen, sdl->sdl_alen); + } + bcopy(new_name, sdl->sdl_data, namelen); + sdl->sdl_nlen = namelen; + sdl = (struct sockaddr_dl *)ifa->ifa_netmask; + bzero(sdl->sdl_data, onamelen); + while (namelen != 0) + sdl->sdl_data[--namelen] = 0xff; + IFA_UNLOCK(ifa); + + EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp); + break; case NGM_EIFACE_GET_IFADDRS: { diff --git a/sys/netgraph/ng_eiface.h b/sys/netgraph/ng_eiface.h index 6fc1c5b..9f1509b 100644 --- a/sys/netgraph/ng_eiface.h +++ b/sys/netgraph/ng_eiface.h @@ -54,6 +54,7 @@ enum { NGM_EIFACE_GET_IFNAME = 1, /* get the interface name */ NGM_EIFACE_GET_IFADDRS, /* returns list of addresses */ NGM_EIFACE_SET, /* set ethernet address */ + NGM_EIFACE_SET_IFNAME, }; #endif /* _NETGRAPH_NG_EIFACE_H_ */ diff --git a/sys/netgraph/ng_iface.c b/sys/netgraph/ng_iface.c index 6c18d2a..94c8c05c 100644 --- a/sys/netgraph/ng_iface.c +++ b/sys/netgraph/ng_iface.c @@ -70,9 +70,11 @@ #include <sys/socket.h> #include <sys/syslog.h> #include <sys/libkern.h> +#include <sys/ctype.h> #include <net/if.h> #include <net/if_types.h> +#include <net/if_dl.h> #include <net/bpf.h> #include <net/netisr.h> #include <net/route.h> @@ -166,6 +168,13 @@ static const struct ng_cmdlist ng_iface_cmds[] = { }, { NGM_IFACE_COOKIE, + NGM_IFACE_SET_IFNAME, + "setifname", + &ng_parse_string_type, + NULL + }, + { + NGM_IFACE_COOKIE, NGM_IFACE_POINT2POINT, "point2point", NULL, @@ -608,6 +617,10 @@ ng_iface_rcvmsg(node_p node, item_p item, hook_p lasthook) struct ng_mesg *resp = NULL; int error = 0; struct ng_mesg *msg; + char *new_name; + size_t namelen, onamelen; + struct sockaddr_dl *sdl = NULL; + struct ifaddr *ifa = NULL; NGI_GET_MSG(item, msg); switch (msg->header.typecookie) { @@ -622,6 +635,49 @@ ng_iface_rcvmsg(node_p node, item_p item, hook_p lasthook) strlcpy(resp->data, ifp->if_xname, IFNAMSIZ); break; + case NGM_IFACE_SET_IFNAME: + + new_name = (char *)msg->data; + /* Announce the departure of the interface. */ + //new_name[strlen(new_name)] = '\0'; + + /* Deny request if interface is UP */ + if ((ifp->if_flags & IFF_UP) != 0) { + error = EBUSY; + break; + } + + //rt_ifannouncemsg(ifp, IFAN_DEPARTURE); + EVENTHANDLER_INVOKE(ifnet_departure_event, ifp); + + strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname)); + ifa = ifp->if_addr; + IFA_LOCK(ifa); + sdl = (struct sockaddr_dl *)ifa->ifa_addr; + namelen = strlen(new_name) + 1; + onamelen = sdl->sdl_nlen; + /* + * Move the address if needed. This is safe because we + * allocate space for a name of length IFNAMSIZ when we + * create this in if_attach(). + */ + if (namelen != onamelen) { + bcopy(sdl->sdl_data + onamelen, + sdl->sdl_data + namelen, sdl->sdl_alen); + } + bcopy(new_name, sdl->sdl_data, namelen); + sdl->sdl_nlen = namelen; + sdl = (struct sockaddr_dl *)ifa->ifa_netmask; + bzero(sdl->sdl_data, onamelen); + while (namelen != 0) + sdl->sdl_data[--namelen] = 0xff; + IFA_UNLOCK(ifa); + + EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp); + /* Announce the return of the interface. */ + //rt_ifannouncemsg(ifp, IFAN_ARRIVAL); + break; + case NGM_IFACE_POINT2POINT: case NGM_IFACE_BROADCAST: { @@ -699,9 +755,11 @@ ng_iface_rcvmsg(node_p node, item_p item, hook_p lasthook) switch (msg->header.cmd) { case NGM_LINK_IS_UP: ifp->if_drv_flags |= IFF_DRV_RUNNING; + //if_link_state_change(ifp, LINK_STATE_UP); break; case NGM_LINK_IS_DOWN: ifp->if_drv_flags &= ~IFF_DRV_RUNNING; + //if_link_state_change(ifp, LINK_STATE_DOWN); break; default: break; diff --git a/sys/netgraph/ng_iface.h b/sys/netgraph/ng_iface.h index 58fb442..3c843c4 100644 --- a/sys/netgraph/ng_iface.h +++ b/sys/netgraph/ng_iface.h @@ -70,6 +70,7 @@ enum { NGM_IFACE_POINT2POINT, NGM_IFACE_BROADCAST, NGM_IFACE_GET_IFINDEX, + NGM_IFACE_SET_IFNAME, }; #define MTAG_NGIF NGM_IFACE_COOKIE diff --git a/sys/netgraph/ng_message.h b/sys/netgraph/ng_message.h index da531f0..d17ce46 100644 --- a/sys/netgraph/ng_message.h +++ b/sys/netgraph/ng_message.h @@ -138,6 +138,7 @@ enum { NGM_ASCII2BINARY= (13|NGM_READONLY|NGM_HASREPLY), /* (optional) Get/set text config. */ NGM_TEXT_CONFIG = 14, + NGM_ETHER_ATTACH = 15, }; /* diff --git a/sys/netinet/if_ether.c b/sys/netinet/if_ether.c index 78d2f43..3a9d262 100644 --- a/sys/netinet/if_ether.c +++ b/sys/netinet/if_ether.c @@ -80,6 +80,8 @@ SYSCTL_DECL(_net_link_ether); static SYSCTL_NODE(_net_link_ether, PF_INET, inet, CTLFLAG_RW, 0, ""); static SYSCTL_NODE(_net_link_ether, PF_ARP, arp, CTLFLAG_RW, 0, ""); +static VNET_DEFINE(int, arp_carp_mac) = 0; /* default to disabled */ + /* timer values */ static VNET_DEFINE(int, arpt_keep) = (20*60); /* once resolved, good for 20 * minutes */ @@ -98,12 +100,16 @@ VNET_PCPUSTAT_SYSUNINIT(arpstat); static VNET_DEFINE(int, arp_maxhold) = 1; +#define V_arp_carp_mac VNET(arp_carp_mac) #define V_arpt_keep VNET(arpt_keep) #define V_arpt_down VNET(arpt_down) #define V_arp_maxtries VNET(arp_maxtries) #define V_arp_proxyall VNET(arp_proxyall) #define V_arp_maxhold VNET(arp_maxhold) +SYSCTL_VNET_INT(_net_link_ether_inet, OID_AUTO, carp_mac, CTLFLAG_RW, + &VNET_NAME(arp_carp_mac), 0, + "Send CARP mac with replies to CARP ips"); SYSCTL_VNET_INT(_net_link_ether_inet, OID_AUTO, max_age, CTLFLAG_RW, &VNET_NAME(arpt_keep), 0, "ARP entry lifetime in seconds"); @@ -909,6 +915,29 @@ reply: /* default behaviour; never reply by broadcast. */ m->m_flags &= ~(M_BCAST|M_MCAST); } +#ifdef DEV_CARP + if (V_arp_carp_mac && carp_match) { + struct ether_header *eh = (struct ether_header *) sa.sa_data; + short type = htons(ETHERTYPE_ARP); + + ah->ar_hrd = htons(ARPHRD_ETHER); + + (void)memcpy(&eh->ether_type, &type, + sizeof(eh->ether_type)); + (void)memcpy(eh->ether_dhost, ar_tha(ah), + sizeof (eh->ether_dhost)); + (void)memcpy(eh->ether_shost, enaddr, + sizeof(eh->ether_shost)); + + sa.sa_family = pseudo_AF_HDRCMPLT; + sa.sa_len = sizeof(sa); + } else { +#endif + sa.sa_family = AF_ARP; + sa.sa_len = 2; +#ifdef DEV_CARP + } +#endif (void)memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln); (void)memcpy(ar_spa(ah), &itaddr, ah->ar_pln); ah->ar_op = htons(ARPOP_REPLY); @@ -916,8 +945,6 @@ reply: m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + (2 * ah->ar_hln); m->m_pkthdr.len = m->m_len; m->m_pkthdr.rcvif = NULL; - sa.sa_family = AF_ARP; - sa.sa_len = 2; m_clrprotoflags(m); /* Avoid confusing lower layers. */ (*ifp->if_output)(ifp, m, &sa, NULL); ARPSTAT_INC(txreplies); diff --git a/sys/netinet/in.c b/sys/netinet/in.c index b61b4b6..fde54be 100644 --- a/sys/netinet/in.c +++ b/sys/netinet/in.c @@ -315,6 +315,7 @@ in_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp, * Security checks before we get involved in any work. */ switch (cmd) { + case SIOCORDERIFADDR: case SIOCAIFADDR: if (td != NULL) { error = priv_check(td, PRIV_NET_ADDIFADDR); @@ -374,6 +375,7 @@ in_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp, error = 0; switch (cmd) { + case SIOCORDERIFADDR: case SIOCAIFADDR: case SIOCDIFADDR: if (ifra->ifra_addr.sin_family == AF_INET) { @@ -399,10 +401,17 @@ in_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp, goto out; } } - if (cmd == SIOCDIFADDR && ia == NULL) { + if ((cmd == SIOCDIFADDR || cmd == SIOCORDERIFADDR) && ia == NULL) { error = EADDRNOTAVAIL; goto out; } + if (cmd == SIOCORDERIFADDR && ia != NULL) { + IF_ADDR_WLOCK(ifp); + TAILQ_REMOVE(&ifp->if_addrhead, &ia->ia_ifa, ifa_link); + TAILQ_INSERT_AFTER(&ifp->if_addrhead, TAILQ_FIRST(&ifp->if_addrhead), &ia->ia_ifa, ifa_link); + IF_ADDR_WUNLOCK(ifp); + goto out; + } if (ia == NULL) { ia = (struct in_ifaddr *) malloc(sizeof *ia, M_IFADDR, M_NOWAIT | diff --git a/sys/netinet/ip_carp.c b/sys/netinet/ip_carp.c index c5fea16..f85a322 100644 --- a/sys/netinet/ip_carp.c +++ b/sys/netinet/ip_carp.c @@ -115,7 +115,6 @@ struct carp_softc { int sc_sendad_success; #define CARP_SENDAD_MIN_SUCCESS 3 - int sc_init_counter; uint64_t sc_counter; /* authentication */ @@ -143,7 +142,7 @@ struct carp_if { struct ip6_moptions cif_im6o; #endif struct ifnet *cif_ifp; - struct mtx cif_mtx; + struct rwlock cif_mtx; }; #define CARP_INET 0 @@ -247,18 +246,19 @@ SYSCTL_VNET_PCPUSTAT(_net_inet_carp, OID_AUTO, stats, struct carpstats, #define CARP_LOCK_ASSERT(sc) mtx_assert(&(sc)->sc_mtx, MA_OWNED) #define CARP_LOCK(sc) mtx_lock(&(sc)->sc_mtx) #define CARP_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) -#define CIF_LOCK_INIT(cif) mtx_init(&(cif)->cif_mtx, "carp_if", \ - NULL, MTX_DEF) -#define CIF_LOCK_DESTROY(cif) mtx_destroy(&(cif)->cif_mtx) -#define CIF_LOCK_ASSERT(cif) mtx_assert(&(cif)->cif_mtx, MA_OWNED) -#define CIF_LOCK(cif) mtx_lock(&(cif)->cif_mtx) -#define CIF_UNLOCK(cif) mtx_unlock(&(cif)->cif_mtx) +#define CIF_LOCK_INIT(cif) rw_init(&(cif)->cif_mtx, "carp_if") +#define CIF_LOCK_DESTROY(cif) rw_destroy(&(cif)->cif_mtx) +#define CIF_LOCK_ASSERT(cif) rw_assert(&(cif)->cif_mtx, MA_OWNED) +#define CIF_RLOCK(cif) rw_rlock(&(cif)->cif_mtx) +#define CIF_RUNLOCK(cif) rw_runlock(&(cif)->cif_mtx) +#define CIF_WLOCK(cif) rw_wlock(&(cif)->cif_mtx) +#define CIF_WUNLOCK(cif) rw_wunlock(&(cif)->cif_mtx) #define CIF_FREE(cif) do { \ CIF_LOCK_ASSERT(cif); \ if (TAILQ_EMPTY(&(cif)->cif_vrs)) \ carp_free_if(cif); \ else \ - CIF_UNLOCK(cif); \ + CIF_WUNLOCK(cif); \ } while (0) #define CARP_LOG(...) do { \ @@ -579,7 +579,6 @@ carp_input_c(struct mbuf *m, struct carp_header *ch, sa_family_t af) struct ifnet *ifp = m->m_pkthdr.rcvif; struct ifaddr *ifa; struct carp_softc *sc; - uint64_t tmp_counter; struct timeval sc_tv, ch_tv; /* verify that the VHID is valid on the receiving interface */ @@ -619,14 +618,20 @@ carp_input_c(struct mbuf *m, struct carp_header *ch, sa_family_t af) goto out; } - tmp_counter = ntohl(ch->carp_counter[0]); - tmp_counter = tmp_counter<<32; - tmp_counter += ntohl(ch->carp_counter[1]); - - /* XXX Replay protection goes here */ - - sc->sc_init_counter = 0; - sc->sc_counter = tmp_counter; + if (!bcmp(&sc->sc_counter, ch->carp_counter, + sizeof(ch->carp_counter))) { + /* Do not log duplicates from non simplex interfaces */ + if (sc->sc_carpdev->if_flags & IFF_SIMPLEX) { + CARPSTATS_INC(carps_badauth); + ifp->if_ierrors++; + CARP_UNLOCK(sc); + CARP_LOG("%s, replay or network loop detected.\n", + ifp->if_xname); + } else + CARP_UNLOCK(sc); + m_freem(m); + return; + } sc_tv.tv_sec = sc->sc_advbase; sc_tv.tv_usec = DEMOTE_ADVSKEW(sc) * 1000000 / 256; @@ -700,13 +705,12 @@ carp_prepare_ad(struct mbuf *m, struct carp_softc *sc, struct carp_header *ch) { struct m_tag *mtag; - if (sc->sc_init_counter) { + if (!sc->sc_counter) { /* this could also be seconds since unix epoch */ sc->sc_counter = arc4random(); sc->sc_counter = sc->sc_counter << 32; sc->sc_counter += arc4random(); - } else - sc->sc_counter++; + } ch->carp_counter[0] = htonl((sc->sc_counter>>32)&0xffffffff); ch->carp_counter[1] = htonl(sc->sc_counter&0xffffffff); @@ -772,7 +776,8 @@ carp_send_ad_error(struct carp_softc *sc, int error) char msg[sizeof(fmt) + IFNAMSIZ]; sprintf(msg, fmt, error, sc->sc_carpdev->if_xname); - carp_demote_adj(V_carp_senderr_adj, msg); + if (V_carp_senderr_adj > 0) + carp_demote_adj(V_carp_senderr_adj, msg); } sc->sc_sendad_success = 0; } else { @@ -782,7 +787,8 @@ carp_send_ad_error(struct carp_softc *sc, int error) char msg[sizeof(fmt) + IFNAMSIZ]; sprintf(msg, fmt, sc->sc_carpdev->if_xname); - carp_demote_adj(-V_carp_senderr_adj, msg); + if (V_carp_senderr_adj > 0) + carp_demote_adj(-V_carp_senderr_adj, msg); sc->sc_sendad_errors = 0; } else sc->sc_sendad_errors = 0; @@ -1117,18 +1123,17 @@ carp_forus(struct ifnet *ifp, u_char *dhost) if (ena[0] || ena[1] || ena[2] != 0x5e || ena[3] || ena[4] != 1) return (0); - CIF_LOCK(ifp->if_carp); + CIF_RLOCK(ifp->if_carp); IFNET_FOREACH_CARP(ifp, sc) { - CARP_LOCK(sc); - if (sc->sc_state == MASTER && !bcmp(dhost, LLADDR(&sc->sc_addr), - ETHER_ADDR_LEN)) { - CARP_UNLOCK(sc); - CIF_UNLOCK(ifp->if_carp); + //CARP_LOCK(sc); + if (sc->sc_state == MASTER && ena[5] == sc->sc_vhid) { + //CARP_UNLOCK(sc); + CIF_RUNLOCK(ifp->if_carp); return (1); } - CARP_UNLOCK(sc); + //CARP_UNLOCK(sc); } - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); return (0); } @@ -1485,9 +1490,9 @@ carp_alloc(struct ifnet *ifp) sc = malloc(sizeof(*sc), M_CARP, M_WAITOK|M_ZERO); + sc->sc_counter = 0; sc->sc_advbase = CARP_DFLTINTV; sc->sc_vhid = -1; /* required setting */ - sc->sc_init_counter = 1; sc->sc_state = INIT; sc->sc_ifasiz = sizeof(struct ifaddr *); @@ -1503,9 +1508,9 @@ carp_alloc(struct ifnet *ifp) #endif callout_init_mtx(&sc->sc_ad_tmo, &sc->sc_mtx, CALLOUT_RETURNUNLOCKED); - CIF_LOCK(cif); + CIF_WLOCK(cif); TAILQ_INSERT_TAIL(&cif->cif_vrs, sc, sc_list); - CIF_UNLOCK(cif); + CIF_WUNLOCK(cif); mtx_lock(&carp_mtx); LIST_INSERT_HEAD(&carp_list, sc, sc_next); @@ -1669,11 +1674,11 @@ carp_ioctl(struct ifreq *ifr, u_long cmd, struct thread *td) } if (ifp->if_carp) { - CIF_LOCK(ifp->if_carp); + CIF_RLOCK(ifp->if_carp); IFNET_FOREACH_CARP(ifp, sc) if (sc->sc_vhid == carpr.carpr_vhid) break; - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); } if (sc == NULL) { sc = carp_alloc(ifp); @@ -1747,11 +1752,11 @@ carp_ioctl(struct ifreq *ifr, u_long cmd, struct thread *td) priveleged = (priv_check(td, PRIV_NETINET_CARP) == 0); if (carpr.carpr_vhid != 0) { - CIF_LOCK(ifp->if_carp); + CIF_RLOCK(ifp->if_carp); IFNET_FOREACH_CARP(ifp, sc) if (sc->sc_vhid == carpr.carpr_vhid) break; - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); if (sc == NULL) { error = ENOENT; break; @@ -1762,12 +1767,12 @@ carp_ioctl(struct ifreq *ifr, u_long cmd, struct thread *td) int i, count; count = 0; - CIF_LOCK(ifp->if_carp); + CIF_RLOCK(ifp->if_carp); IFNET_FOREACH_CARP(ifp, sc) count++; if (count > carpr.carpr_count) { - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); error = EMSGSIZE; break; } @@ -1779,12 +1784,12 @@ carp_ioctl(struct ifreq *ifr, u_long cmd, struct thread *td) error = copyout(&carpr, ifr->ifr_data + (i * sizeof(carpr)), sizeof(carpr)); if (error) { - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); break; } i++; } - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); } break; } @@ -1833,12 +1838,12 @@ carp_attach(struct ifaddr *ifa, int vhid) return (EPROTOTYPE); } - CIF_LOCK(cif); + CIF_WLOCK(cif); IFNET_FOREACH_CARP(ifp, sc) if (sc->sc_vhid == vhid) break; if (sc == NULL) { - CIF_UNLOCK(cif); + CIF_WUNLOCK(cif); return (ENOENT); } @@ -1846,7 +1851,7 @@ carp_attach(struct ifaddr *ifa, int vhid) if (ifa->ifa_carp->sc_vhid != vhid) carp_detach_locked(ifa); else { - CIF_UNLOCK(cif); + CIF_WUNLOCK(cif); return (0); } } @@ -1891,7 +1896,7 @@ carp_attach(struct ifaddr *ifa, int vhid) carp_sc_state(sc); CARP_UNLOCK(sc); - CIF_UNLOCK(cif); + CIF_WUNLOCK(cif); return (0); } @@ -1902,7 +1907,7 @@ carp_detach(struct ifaddr *ifa) struct ifnet *ifp = ifa->ifa_ifp; struct carp_if *cif = ifp->if_carp; - CIF_LOCK(cif); + CIF_WLOCK(cif); carp_detach_locked(ifa); CIF_FREE(cif); } @@ -1984,13 +1989,13 @@ carp_linkstate(struct ifnet *ifp) { struct carp_softc *sc; - CIF_LOCK(ifp->if_carp); + CIF_RLOCK(ifp->if_carp); IFNET_FOREACH_CARP(ifp, sc) { CARP_LOCK(sc); carp_sc_state(sc); CARP_UNLOCK(sc); } - CIF_UNLOCK(ifp->if_carp); + CIF_RUNLOCK(ifp->if_carp); } static void @@ -2025,9 +2030,11 @@ carp_sc_state(struct carp_softc *sc) static void carp_demote_adj(int adj, char *reason) { + if (adj == 0) + return; atomic_add_int(&V_carp_demotion, adj); CARP_LOG("demoted by %d to %d (%s)\n", adj, V_carp_demotion, reason); - taskqueue_enqueue(taskqueue_swi, &carp_sendall_task); + taskqueue_enqueue(taskqueue_thread, &carp_sendall_task); } static int diff --git a/sys/netinet/ip_divert.c b/sys/netinet/ip_divert.c index e698035..b74d60d 100644 --- a/sys/netinet/ip_divert.c +++ b/sys/netinet/ip_divert.c @@ -267,8 +267,7 @@ divert_packet(struct mbuf *m, int incoming) * this iface name will come along for the ride. * (see div_output for the other half of this.) */ - strlcpy(divsrc.sin_zero, m->m_pkthdr.rcvif->if_xname, - sizeof(divsrc.sin_zero)); + *((u_short *)divsrc.sin_zero) = m->m_pkthdr.rcvif->if_index; } /* Put packet on socket queue, if any */ @@ -342,7 +341,7 @@ div_output(struct socket *so, struct mbuf *m, struct sockaddr_in *sin, /* Loopback avoidance and state recovery */ if (sin) { - int i; + u_short idx; /* set the starting point. We provide a non-zero slot, * but a non_matching chain_id to skip that info and use @@ -350,7 +349,7 @@ div_output(struct socket *so, struct mbuf *m, struct sockaddr_in *sin, */ dt->slot = 1; /* dummy, chain_id is invalid */ dt->chain_id = 0; - dt->rulenum = sin->sin_port+1; /* host format ? */ + dt->rulenum = sin->sin_port; /* host format ? */ dt->rule_id = 0; /* * Find receive interface with the given name, stuffed @@ -358,10 +357,9 @@ div_output(struct socket *so, struct mbuf *m, struct sockaddr_in *sin, * The name is user supplied data so don't trust its size * or that it is zero terminated. */ - for (i = 0; i < sizeof(sin->sin_zero) && sin->sin_zero[i]; i++) - ; - if ( i > 0 && i < sizeof(sin->sin_zero)) - m->m_pkthdr.rcvif = ifunit(sin->sin_zero); + idx = *((u_short *)sin->sin_zero); + if ( idx > 0 ) + m->m_pkthdr.rcvif = ifnet_byindex(idx); } /* Reinject packet into the system as incoming or outgoing */ @@ -832,5 +830,4 @@ static moduledata_t ipdivertmod = { }; DECLARE_MODULE(ipdivert, ipdivertmod, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY); -MODULE_DEPEND(ipdivert, ipfw, 2, 2, 2); MODULE_VERSION(ipdivert, 1); diff --git a/sys/netinet/ip_fastfwd.c b/sys/netinet/ip_fastfwd.c index 13c5785..9c3ea66 100644 --- a/sys/netinet/ip_fastfwd.c +++ b/sys/netinet/ip_fastfwd.c @@ -389,18 +389,6 @@ passout: goto consumed; } -#ifndef ALTQ - /* - * Check if there is enough space in the interface queue - */ - if ((ifp->if_snd.ifq_len + ip_len / ifp->if_mtu + 1) >= - ifp->if_snd.ifq_maxlen) { - IPSTAT_INC(ips_odropped); - /* would send source quench here but that is depreciated */ - goto drop; - } -#endif - /* * Check if media link state of interface is not down */ diff --git a/sys/netinet/ip_fw.h b/sys/netinet/ip_fw.h index dae8cc0..188057d 100644 --- a/sys/netinet/ip_fw.h +++ b/sys/netinet/ip_fw.h @@ -65,7 +65,8 @@ /* IP_FW3 header/opcodes */ typedef struct _ip_fw3_opheader { uint16_t opcode; /* Operation opcode */ - uint16_t reserved[3]; /* Align to 64-bit boundary */ + uint16_t ctxid; + uint16_t reserved[2]; /* Align to 64-bit boundary */ } ip_fw3_opheader; @@ -74,6 +75,14 @@ typedef struct _ip_fw3_opheader { #define IP_FW_TABLE_XDEL 87 /* delete entry */ #define IP_FW_TABLE_XGETSIZE 88 /* get table size */ #define IP_FW_TABLE_XLIST 89 /* list table contents */ +#define IP_FW_TABLE_XLISTENTRY 90 /* list one table entry contents */ +#define IP_FW_TABLE_XZEROENTRY 91 /* zero one table entry stats */ +#define IP_FW_CTX_GET 92 +#define IP_FW_CTX_ADD 93 +#define IP_FW_CTX_DEL 94 +#define IP_FW_CTX_SET 95 +#define IP_FW_CTX_ADDMEMBER 96 +#define IP_FW_CTX_DELMEMBER 97 /* * The kernel representation of ipfw rules is made of a list of @@ -600,11 +609,16 @@ struct _ipfw_dyn_rule { #define IPFW_TABLE_CIDR 1 /* Table for holding IPv4/IPv6 prefixes */ #define IPFW_TABLE_INTERFACE 2 /* Table for holding interface names */ -#define IPFW_TABLE_MAXTYPE 2 /* Maximum valid number */ +#define IPFW_TABLE_MIX 3 /* Table for holding IPv4/mac entries */ +#define IPFW_TABLE_MAC 4 /* Table for holding mac entries */ +#define IPFW_TABLE_MAXTYPE 5 /* Maximum valid number */ typedef struct _ipfw_table_entry { in_addr_t addr; /* network address */ u_int32_t value; /* value */ + uint64_t mac_addr; + uint64_t bytes; + uint64_t packets; u_int16_t tbl; /* table number */ u_int8_t masklen; /* mask length */ } ipfw_table_entry; @@ -616,6 +630,10 @@ typedef struct _ipfw_table_xentry { uint16_t tbl; /* table number */ uint16_t flags; /* record flags */ uint32_t value; /* value */ + uint32_t timestamp; + uint64_t mac_addr; + uint64_t bytes; + uint64_t packets; union { /* Longest field needs to be aligned by 4-byte boundary */ struct in6_addr addr6; /* IPv6 address */ diff --git a/sys/netinet/ip_input.c b/sys/netinet/ip_input.c index 0b29d49..1eefadc 100644 --- a/sys/netinet/ip_input.c +++ b/sys/netinet/ip_input.c @@ -299,6 +299,9 @@ ip_init(void) if ((i = pfil_head_register(&V_inet_pfil_hook)) != 0) printf("%s: WARNING: unable to register pfil hook, " "error %d\n", __func__, i); + else + pfil_head_export_sysctl(&V_inet_pfil_hook, + SYSCTL_STATIC_CHILDREN(_net_inet_ip)); /* Skip initialization of globals for non-default instances. */ if (!IS_DEFAULT_VNET(curvnet)) @@ -511,8 +514,7 @@ tooshort: goto ours; } if (m->m_flags & M_IP_NEXTHOP) { - dchg = (m_tag_find(m, PACKET_TAG_IPFORWARD, NULL) != NULL); - if (dchg != 0) { + if (m_tag_find(m, PACKET_TAG_IPFORWARD, NULL) != NULL) { /* * Directly ship the packet on. This allows * forwarding packets originally destined to us @@ -686,10 +688,6 @@ passin: IPSTAT_INC(ips_cantforward); m_freem(m); } else { -#ifdef IPSEC - if (ip_ipsec_fwd(m)) - goto bad; -#endif /* IPSEC */ ip_forward(m, dchg); } return; @@ -734,7 +732,7 @@ ours: * note that we do not visit this with protocols with pcb layer * code - like udp/tcp/raw ip. */ - if (ip_ipsec_input(m)) + if (ip_ipsec_input(m, ip->ip_p) != 0) goto bad; #endif /* IPSEC */ @@ -1367,6 +1365,13 @@ ip_forward(struct mbuf *m, int srcrt) m_freem(m); return; } +#ifdef IPSEC + if (ip_ipsec_fwd(m) != 0) { + IPSTAT_INC(ips_cantforward); + m_freem(m); + return; + } +#endif /* IPSEC */ #ifdef IPSTEALTH if (!V_ipstealth) { #endif diff --git a/sys/netinet/ip_ipsec.c b/sys/netinet/ip_ipsec.c index 133fa7c..2e43e43 100644 --- a/sys/netinet/ip_ipsec.c +++ b/sys/netinet/ip_ipsec.c @@ -61,15 +61,12 @@ __FBSDID("$FreeBSD$"); #include <machine/in_cksum.h> -#ifdef IPSEC #include <netipsec/ipsec.h> #include <netipsec/xform.h> #include <netipsec/key.h> -#endif /*IPSEC*/ extern struct protosw inetsw[]; -#ifdef IPSEC #ifdef IPSEC_FILTERTUNNEL static VNET_DEFINE(int, ip4_ipsec_filtertunnel) = 1; #else @@ -81,7 +78,6 @@ SYSCTL_DECL(_net_inet_ipsec); SYSCTL_VNET_INT(_net_inet_ipsec, OID_AUTO, filtertunnel, CTLFLAG_RW, &VNET_NAME(ip4_ipsec_filtertunnel), 0, "If set filter packets from an IPsec tunnel."); -#endif /* IPSEC */ /* * Check if we have to jump over firewall processing for this packet. @@ -91,7 +87,6 @@ SYSCTL_VNET_INT(_net_inet_ipsec, OID_AUTO, filtertunnel, int ip_ipsec_filtertunnel(struct mbuf *m) { -#ifdef IPSEC /* * Bypass packet filtering for packets previously handled by IPsec. @@ -99,50 +94,20 @@ ip_ipsec_filtertunnel(struct mbuf *m) if (!V_ip4_ipsec_filtertunnel && m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL) return 1; -#endif return 0; } /* * Check if this packet has an active SA and needs to be dropped instead * of forwarded. - * Called from ip_input(). + * Called from ip_forward(). * 1 = drop packet, 0 = forward packet. */ int ip_ipsec_fwd(struct mbuf *m) { -#ifdef IPSEC - struct m_tag *mtag; - struct tdb_ident *tdbi; - struct secpolicy *sp; - int error; - - mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL); - if (mtag != NULL) { - tdbi = (struct tdb_ident *)(mtag + 1); - sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND); - } else { - sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND, - IP_FORWARDING, &error); - } - if (sp == NULL) { /* NB: can happen if error */ - /*XXX error stat???*/ - DPRINTF(("ip_input: no SP for forwarding\n")); /*XXX*/ - return 1; - } - /* - * Check security policy against packet attributes. - */ - error = ipsec_in_reject(sp, m); - KEY_FREESP(&sp); - if (error) { - IPSTAT_INC(ips_cantforward); - return 1; - } -#endif /* IPSEC */ - return 0; + return (ipsec4_in_reject(m, NULL)); } /* @@ -153,51 +118,16 @@ ip_ipsec_fwd(struct mbuf *m) * 1 = drop packet, 0 = continue processing packet. */ int -ip_ipsec_input(struct mbuf *m) +ip_ipsec_input(struct mbuf *m, int nxt) { -#ifdef IPSEC - struct ip *ip = mtod(m, struct ip *); - struct m_tag *mtag; - struct tdb_ident *tdbi; - struct secpolicy *sp; - int error; /* * enforce IPsec policy checking if we are seeing last header. * note that we do not visit this with protocols with pcb layer * code - like udp/tcp/raw ip. */ - if ((inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0) { - /* - * Check if the packet has already had IPsec processing - * done. If so, then just pass it along. This tag gets - * set during AH, ESP, etc. input handling, before the - * packet is returned to the ip input queue for delivery. - */ - mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL); - if (mtag != NULL) { - tdbi = (struct tdb_ident *)(mtag + 1); - sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND); - } else { - sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND, - IP_FORWARDING, &error); - } - if (sp != NULL) { - /* - * Check security policy against packet attributes. - */ - error = ipsec_in_reject(sp, m); - KEY_FREESP(&sp); - } else { - /* XXX error stat??? */ - error = EINVAL; - DPRINTF(("ip_input: no SP, packet discarded\n"));/*XXX*/ - return 1; - } - if (error) - return 1; - } -#endif /* IPSEC */ - return 0; + if ((inetsw[ip_protox[nxt]].pr_flags & PR_LASTHDR) != 0) + return (ipsec4_in_reject(m, NULL)); + return (0); } /* @@ -224,12 +154,9 @@ ip_ipsec_mtu(struct mbuf *m, int mtu) * -1 = packet was reinjected and stop processing packet */ int -ip_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error) +ip_ipsec_output(struct mbuf **m, struct inpcb *inp, int *error) { -#ifdef IPSEC - struct secpolicy *sp = NULL; - struct tdb_ident *tdbi; - struct m_tag *mtag; + struct secpolicy *sp; if (!key_havesp(IPSEC_DIR_OUTBOUND)) return 0; @@ -243,17 +170,11 @@ ip_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error) * AH, ESP, etc. processing), there will be a tag to bypass * the lookup and related policy checking. */ - mtag = m_tag_find(*m, PACKET_TAG_IPSEC_PENDING_TDB, NULL); - if (mtag != NULL) { - tdbi = (struct tdb_ident *)(mtag + 1); - sp = ipsec_getpolicy(tdbi, IPSEC_DIR_OUTBOUND); - if (sp == NULL) - *error = -EINVAL; /* force silent drop */ - m_tag_delete(*m, mtag); - } else { - sp = ipsec4_checkpolicy(*m, IPSEC_DIR_OUTBOUND, *flags, - error, inp); + if (m_tag_find(*m, PACKET_TAG_IPSEC_OUT_DONE, NULL) != NULL) { + *error = 0; + return (0); } + sp = ipsec4_checkpolicy(*m, IPSEC_DIR_OUTBOUND, error, inp); /* * There are four return cases: * sp != NULL apply IPsec policy @@ -262,40 +183,6 @@ ip_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error) * sp == NULL, error != 0 discard packet, report error */ if (sp != NULL) { - /* Loop detection, check if ipsec processing already done */ - KASSERT(sp->req != NULL, ("ip_output: no ipsec request")); - for (mtag = m_tag_first(*m); mtag != NULL; - mtag = m_tag_next(*m, mtag)) { - if (mtag->m_tag_cookie != MTAG_ABI_COMPAT) - continue; - if (mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_DONE && - mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED) - continue; - /* - * Check if policy has an SA associated with it. - * This can happen when an SP has yet to acquire - * an SA; e.g. on first reference. If it occurs, - * then we let ipsec4_process_packet do its thing. - */ - if (sp->req->sav == NULL) - break; - tdbi = (struct tdb_ident *)(mtag + 1); - if (tdbi->spi == sp->req->sav->spi && - tdbi->proto == sp->req->sav->sah->saidx.proto && - bcmp(&tdbi->dst, &sp->req->sav->sah->saidx.dst, - sizeof (union sockaddr_union)) == 0) { - /* - * No IPsec processing is needed, free - * reference to SP. - * - * NB: null pointer to avoid free at - * done: below. - */ - KEY_FREESP(&sp), sp = NULL; - goto done; - } - } - /* * Do delayed checksums now because we send before * this is done in the normal processing path. @@ -314,7 +201,10 @@ ip_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error) #endif /* NB: callee frees mbuf */ - *error = ipsec4_process_packet(*m, sp->req, *flags, 0); + *error = ipsec4_process_packet(*m, sp->req); + /* Release SP if an error occured */ + if (*error != 0) + KEY_FREESP(&sp); if (*error == EJUSTRETURN) { /* * We had a SP with a level of 'use' and no SA. We @@ -346,22 +236,17 @@ ip_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error) if (*error == -EINVAL) *error = 0; goto bad; - } else { - /* No IPsec processing for this packet. */ } + /* No IPsec processing for this packet. */ } done: if (sp != NULL) KEY_FREESP(&sp); return 0; reinjected: - if (sp != NULL) - KEY_FREESP(&sp); - return -1; + return (-1); bad: if (sp != NULL) KEY_FREESP(&sp); return 1; -#endif /* IPSEC */ - return 0; } diff --git a/sys/netinet/ip_ipsec.h b/sys/netinet/ip_ipsec.h index 2870c11..f499b74 100644 --- a/sys/netinet/ip_ipsec.h +++ b/sys/netinet/ip_ipsec.h @@ -34,7 +34,7 @@ int ip_ipsec_filtertunnel(struct mbuf *); int ip_ipsec_fwd(struct mbuf *); -int ip_ipsec_input(struct mbuf *); +int ip_ipsec_input(struct mbuf *, int); int ip_ipsec_mtu(struct mbuf *, int); -int ip_ipsec_output(struct mbuf **, struct inpcb *, int *, int *); +int ip_ipsec_output(struct mbuf **, struct inpcb *, int *); #endif diff --git a/sys/netinet/ip_output.c b/sys/netinet/ip_output.c index 954785d..0aee48d 100644 --- a/sys/netinet/ip_output.c +++ b/sys/netinet/ip_output.c @@ -123,7 +123,7 @@ ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags, struct ifnet *ifp = NULL; /* keep compiler happy */ struct mbuf *m0; int hlen = sizeof (struct ip); - int mtu; + int mtu = 0; int n; /* scratchpad */ int error = 0; struct sockaddr_in *dst; @@ -136,9 +136,8 @@ ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags, struct in_addr odst; struct m_tag *fwd_tag = NULL; int have_ia_ref; -#ifdef IPSEC - int no_route_but_check_spd = 0; -#endif + int no_route_but_check = 0; + M_ASSERTPKTHDR(m); if (inp != NULL) { @@ -292,10 +291,11 @@ again: * There is no route for this packet, but it is * possible that a matching SPD entry exists. */ - no_route_but_check_spd = 1; mtu = 0; /* Silence GCC warning. */ - goto sendit; #endif + no_route_but_check = 1; + goto sendit; + IPSTAT_INC(ips_noroute); error = EHOSTUNREACH; goto bad; @@ -482,7 +482,7 @@ again: sendit: #ifdef IPSEC - switch(ip_ipsec_output(&m, inp, &flags, &error)) { + switch(ip_ipsec_output(&m, inp, &error)) { case 1: goto bad; case -1: @@ -491,28 +491,34 @@ sendit: default: break; /* Continue with packet processing. */ } - /* - * Check if there was a route for this packet; return error if not. - */ - if (no_route_but_check_spd) { - IPSTAT_INC(ips_noroute); - error = EHOSTUNREACH; - goto bad; - } /* Update variables that are affected by ipsec4_output(). */ ip = mtod(m, struct ip *); hlen = ip->ip_hl << 2; #endif /* IPSEC */ /* Jump over all PFIL processing if hooks are not active. */ - if (!PFIL_HOOKED(&V_inet_pfil_hook)) + if (!PFIL_HOOKED(&V_inet_pfil_hook)) { + if (no_route_but_check) { + IPSTAT_INC(ips_noroute); + error = EHOSTUNREACH; + goto bad; + } goto passout; + } + + if (ifp == NULL) + ifp = V_loif; /* Run through list of hooks for output packets. */ odst.s_addr = ip->ip_dst.s_addr; error = pfil_run_hooks(&V_inet_pfil_hook, &m, ifp, PFIL_OUT, inp); if (error != 0 || m == NULL) goto done; + if (no_route_but_check) { + IPSTAT_INC(ips_noroute); + error = EHOSTUNREACH; + goto bad; + } ip = mtod(m, struct ip *); diff --git a/sys/netinet/sctp_input.c b/sys/netinet/sctp_input.c index 01d2636..4c1a98c 100644 --- a/sys/netinet/sctp_input.c +++ b/sys/netinet/sctp_input.c @@ -5784,7 +5784,6 @@ sctp_common_input_processing(struct mbuf **mm, int iphlen, int offset, int lengt #ifdef INET case AF_INET: if (ipsec4_in_reject(m, &inp->ip_inp.inp)) { - IPSECSTAT_INC(ips_in_polvio); SCTP_STAT_INCR(sctps_hdrops); goto out; } @@ -5793,7 +5792,6 @@ sctp_common_input_processing(struct mbuf **mm, int iphlen, int offset, int lengt #ifdef INET6 case AF_INET6: if (ipsec6_in_reject(m, &inp->ip_inp.inp)) { - IPSEC6STAT_INC(ips_in_polvio); SCTP_STAT_INCR(sctps_hdrops); goto out; } diff --git a/sys/netinet/tcp_input.c b/sys/netinet/tcp_input.c index 32133ae..114802e 100644 --- a/sys/netinet/tcp_input.c +++ b/sys/netinet/tcp_input.c @@ -889,12 +889,10 @@ findpcb: #ifdef IPSEC #ifdef INET6 if (isipv6 && ipsec6_in_reject(m, inp)) { - IPSEC6STAT_INC(ips_in_polvio); goto dropunlock; } else #endif /* INET6 */ if (ipsec4_in_reject(m, inp) != 0) { - IPSECSTAT_INC(ips_in_polvio); goto dropunlock; } #endif /* IPSEC */ diff --git a/sys/netinet/udp_usrreq.c b/sys/netinet/udp_usrreq.c index 79a2166..46bebf6 100644 --- a/sys/netinet/udp_usrreq.c +++ b/sys/netinet/udp_usrreq.c @@ -314,7 +314,6 @@ udp_append(struct inpcb *inp, struct ip *ip, struct mbuf *n, int off, /* Check AH/ESP integrity. */ if (ipsec4_in_reject(n, inp)) { m_freem(n); - IPSECSTAT_INC(ips_in_polvio); return; } #ifdef IPSEC_NAT_T @@ -1561,7 +1560,8 @@ udp4_espdecap(struct inpcb *inp, struct mbuf *m, int off) if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID) m->m_pkthdr.csum_flags &= ~(CSUM_DATA_VALID|CSUM_PSEUDO_HDR); - (void) ipsec4_common_input(m, iphlen, ip->ip_p); + (void) ipsec_common_input(m, iphlen, offsetof(struct ip, ip_p), + AF_INET, ip->ip_p); return (NULL); /* NB: consumed, bypass processing. */ } #endif /* defined(IPSEC) && defined(IPSEC_NAT_T) */ diff --git a/sys/netinet6/in6.c b/sys/netinet6/in6.c index e2073f5..e3c3229 100644 --- a/sys/netinet6/in6.c +++ b/sys/netinet6/in6.c @@ -2375,6 +2375,7 @@ in6if_do_dad(struct ifnet *ifp) case IFT_DUMMY: #endif case IFT_FAITH: + case IFT_STF: /* * These interfaces do not have the IFF_LOOPBACK flag, * but loop packets back. We do not have to do DAD on such diff --git a/sys/netinet6/ip6_forward.c b/sys/netinet6/ip6_forward.c index caa58e6..053864a 100644 --- a/sys/netinet6/ip6_forward.c +++ b/sys/netinet6/ip6_forward.c @@ -70,6 +70,7 @@ __FBSDID("$FreeBSD$"); #include <netinet/in_pcb.h> #ifdef IPSEC +#include <netinet6/ip6_ipsec.h> #include <netipsec/ipsec.h> #include <netipsec/ipsec6.h> #include <netipsec/key.h> @@ -111,21 +112,6 @@ ip6_forward(struct mbuf *m, int srcrt) struct m_tag *fwd_tag; char ip6bufs[INET6_ADDRSTRLEN], ip6bufd[INET6_ADDRSTRLEN]; -#ifdef IPSEC - /* - * Check AH/ESP integrity. - */ - /* - * Don't increment ip6s_cantforward because this is the check - * before forwarding packet actually. - */ - if (ipsec6_in_reject(m, NULL)) { - IPSEC6STAT_INC(ips_in_polvio); - m_freem(m); - return; - } -#endif /* IPSEC */ - /* * Do not forward packets to multicast destination (should be handled * by ip6_mforward(). @@ -150,6 +136,17 @@ ip6_forward(struct mbuf *m, int srcrt) m_freem(m); return; } +#ifdef IPSEC + /* + * Check if this packet has an active SA and needs to be dropped + * instead of forwarded. + */ + if (ip6_ipsec_fwd(m) != 0) { + IP6STAT_INC(ip6s_cantforward); + m_freem(m); + return; + } +#endif /* IPSEC */ #ifdef IPSTEALTH if (!V_ip6stealth) { @@ -179,8 +176,7 @@ ip6_forward(struct mbuf *m, int srcrt) #ifdef IPSEC /* get a security policy for this packet */ - sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, - IP_FORWARDING, &error); + sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, &error); if (sp == NULL) { IPSEC6STAT_INC(ips_out_inval); IP6STAT_INC(ip6s_cantforward); @@ -254,8 +250,7 @@ ip6_forward(struct mbuf *m, int srcrt) /* * when the kernel forwards a packet, it is not proper to apply - * IPsec transport mode to the packet is not proper. this check - * avoid from this. + * IPsec transport mode to the packet. This check avoid from this. * at present, if there is even a transport mode SA request in the * security policy, the kernel does not apply IPsec to the packet. * this check is not enough because the following case is valid. @@ -289,9 +284,9 @@ ip6_forward(struct mbuf *m, int srcrt) * ipsec6_proces_packet will send the packet using ip6_output */ error = ipsec6_process_packet(m, sp->req); - - KEY_FREESP(&sp); - + /* Release SP if an error occured */ + if (error != 0) + KEY_FREESP(&sp); if (error == EJUSTRETURN) { /* * We had a SP with a level of 'use' and no SA. We @@ -557,8 +552,6 @@ pass: if (mcopy) { u_long mtu; #ifdef IPSEC - struct secpolicy *sp; - int ipsecerror; size_t ipsechdrsiz; #endif /* IPSEC */ @@ -571,15 +564,10 @@ pass: * case, as we have the outgoing interface for * encapsulated packet as "rt->rt_ifp". */ - sp = ipsec_getpolicybyaddr(mcopy, IPSEC_DIR_OUTBOUND, - IP_FORWARDING, &ipsecerror); - if (sp) { - ipsechdrsiz = ipsec_hdrsiz(mcopy, - IPSEC_DIR_OUTBOUND, NULL); - if (ipsechdrsiz < mtu) - mtu -= ipsechdrsiz; - } - + ipsechdrsiz = ipsec_hdrsiz(mcopy, IPSEC_DIR_OUTBOUND, + NULL); + if (ipsechdrsiz < mtu) + mtu -= ipsechdrsiz; /* * if mtu becomes less than minimum MTU, * tell minimum MTU (and I'll need to fragment it). diff --git a/sys/netinet6/ip6_input.c b/sys/netinet6/ip6_input.c index b8a75c6..b6602d3 100644 --- a/sys/netinet6/ip6_input.c +++ b/sys/netinet6/ip6_input.c @@ -136,6 +136,7 @@ static struct netisr_handler ip6_nh = { VNET_DECLARE(struct callout, in6_tmpaddrtimer_ch); #define V_in6_tmpaddrtimer_ch VNET(in6_tmpaddrtimer_ch) +SYSCTL_DECL(_net_inet6_ip6); VNET_DEFINE(struct pfil_head, inet6_pfil_hook); VNET_PCPUSTAT_DEFINE(struct ip6stat, ip6stat); @@ -182,6 +183,9 @@ ip6_init(void) if ((i = pfil_head_register(&V_inet6_pfil_hook)) != 0) printf("%s: WARNING: unable to register pfil hook, " "error %d\n", __func__, i); + else + pfil_head_export_sysctl(&V_inet6_pfil_hook, + SYSCTL_STATIC_CHILDREN(_net_inet6_ip6)); scope6_init(); addrsel_policy_init(); diff --git a/sys/netinet6/ip6_ipsec.c b/sys/netinet6/ip6_ipsec.c index ea47566..ac49275 100644 --- a/sys/netinet6/ip6_ipsec.c +++ b/sys/netinet6/ip6_ipsec.c @@ -117,42 +117,18 @@ ip6_ipsec_filtertunnel(struct mbuf *m) /* * Check if this packet has an active SA and needs to be dropped instead * of forwarded. - * Called from ip6_input(). + * Called from ip6_forward(). * 1 = drop packet, 0 = forward packet. */ int ip6_ipsec_fwd(struct mbuf *m) { -#ifdef IPSEC - struct m_tag *mtag; - struct tdb_ident *tdbi; - struct secpolicy *sp; - int error; - mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL); - if (mtag != NULL) { - tdbi = (struct tdb_ident *)(mtag + 1); - sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND); - } else { - sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND, - IP_FORWARDING, &error); - } - if (sp == NULL) { /* NB: can happen if error */ - /*XXX error stat???*/ - DPRINTF(("%s: no SP for forwarding\n", __func__)); /*XXX*/ - return 1; - } - /* - * Check security policy against packet attributes. - */ - error = ipsec_in_reject(sp, m); - KEY_FREESP(&sp); - if (error) { - IP6STAT_INC(ip6s_cantforward); - return 1; - } -#endif /* IPSEC */ - return 0; +#ifdef IPSEC + return (ipsec6_in_reject(m, NULL)); +#else + return (0); +#endif /* !IPSEC */ } /* @@ -165,50 +141,17 @@ ip6_ipsec_fwd(struct mbuf *m) int ip6_ipsec_input(struct mbuf *m, int nxt) { + #ifdef IPSEC - struct m_tag *mtag; - struct tdb_ident *tdbi; - struct secpolicy *sp; - int error; /* * enforce IPsec policy checking if we are seeing last header. * note that we do not visit this with protocols with pcb layer * code - like udp/tcp/raw ip. */ - if ((inet6sw[ip6_protox[nxt]].pr_flags & PR_LASTHDR) != 0 && - ipsec6_in_reject(m, NULL)) { - - /* - * Check if the packet has already had IPsec processing - * done. If so, then just pass it along. This tag gets - * set during AH, ESP, etc. input handling, before the - * packet is returned to the ip input queue for delivery. - */ - mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL); - if (mtag != NULL) { - tdbi = (struct tdb_ident *)(mtag + 1); - sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND); - } else { - sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND, - IP_FORWARDING, &error); - } - if (sp != NULL) { - /* - * Check security policy against packet attributes. - */ - error = ipsec_in_reject(sp, m); - KEY_FREESP(&sp); - } else { - /* XXX error stat??? */ - error = EINVAL; - DPRINTF(("%s: no SP, packet discarded\n", __func__));/*XXX*/ - return 1; - } - if (error) - return 1; - } + if ((inet6sw[ip6_protox[nxt]].pr_flags & PR_LASTHDR) != 0) + return (ipsec6_in_reject(m, NULL)); #endif /* IPSEC */ - return 0; + return (0); } /* @@ -218,27 +161,26 @@ ip6_ipsec_input(struct mbuf *m, int nxt) */ int -ip6_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error, - struct ifnet **ifp) +ip6_ipsec_output(struct mbuf **m, struct inpcb *inp, int *error) { #ifdef IPSEC - struct secpolicy *sp = NULL; - struct tdb_ident *tdbi; - struct m_tag *mtag; - /* XXX int s; */ - mtag = m_tag_find(*m, PACKET_TAG_IPSEC_PENDING_TDB, NULL); - if (mtag != NULL) { - tdbi = (struct tdb_ident *)(mtag + 1); - sp = ipsec_getpolicy(tdbi, IPSEC_DIR_OUTBOUND); - if (sp == NULL) - *error = -EINVAL; /* force silent drop */ - m_tag_delete(*m, mtag); - } else { - sp = ipsec4_checkpolicy(*m, IPSEC_DIR_OUTBOUND, *flags, - error, inp); - } + struct secpolicy *sp; /* + * Check the security policy (SP) for the packet and, if + * required, do IPsec-related processing. There are two + * cases here; the first time a packet is sent through + * it will be untagged and handled by ipsec4_checkpolicy. + * If the packet is resubmitted to ip6_output (e.g. after + * AH, ESP, etc. processing), there will be a tag to bypass + * the lookup and related policy checking. + */ + if (m_tag_find(*m, PACKET_TAG_IPSEC_OUT_DONE, NULL) != NULL) { + *error = 0; + return (0); + } + sp = ipsec4_checkpolicy(*m, IPSEC_DIR_OUTBOUND, error, inp); + /* * There are four return cases: * sp != NULL apply IPsec policy * sp == NULL, error == 0 no IPsec handling needed @@ -246,36 +188,6 @@ ip6_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error, * sp == NULL, error != 0 discard packet, report error */ if (sp != NULL) { - /* Loop detection, check if ipsec processing already done */ - KASSERT(sp->req != NULL, ("ip_output: no ipsec request")); - for (mtag = m_tag_first(*m); mtag != NULL; - mtag = m_tag_next(*m, mtag)) { - if (mtag->m_tag_cookie != MTAG_ABI_COMPAT) - continue; - if (mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_DONE && - mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED) - continue; - /* - * Check if policy has no SA associated with it. - * This can happen when an SP has yet to acquire - * an SA; e.g. on first reference. If it occurs, - * then we let ipsec4_process_packet do its thing. - */ - if (sp->req->sav == NULL) - break; - tdbi = (struct tdb_ident *)(mtag + 1); - if (tdbi->spi == sp->req->sav->spi && - tdbi->proto == sp->req->sav->sah->saidx.proto && - bcmp(&tdbi->dst, &sp->req->sav->sah->saidx.dst, - sizeof (union sockaddr_union)) == 0) { - /* - * No IPsec processing is needed, free - * reference to SP. - */ - goto done; - } - } - /* * Do delayed checksums now because we send before * this is done in the normal processing path. @@ -300,7 +212,9 @@ ip6_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error, /* NB: callee frees mbuf */ *error = ipsec6_process_packet(*m, sp->req); - + /* Release SP if an error occured */ + if (*error != 0) + KEY_FREESP(&sp); if (*error == EJUSTRETURN) { /* * We had a SP with a level of 'use' and no SA. We @@ -332,18 +246,15 @@ ip6_ipsec_output(struct mbuf **m, struct inpcb *inp, int *flags, int *error, if (*error == -EINVAL) *error = 0; goto bad; - } else { - /* No IPsec processing for this packet. */ } + /* No IPsec processing for this packet. */ } done: if (sp != NULL) KEY_FREESP(&sp); return 0; reinjected: - if (sp != NULL) - KEY_FREESP(&sp); - return -1; + return (-1); bad: if (sp != NULL) KEY_FREESP(&sp); diff --git a/sys/netinet6/ip6_ipsec.h b/sys/netinet6/ip6_ipsec.h index a65b19a..e335d85 100644 --- a/sys/netinet6/ip6_ipsec.h +++ b/sys/netinet6/ip6_ipsec.h @@ -35,8 +35,7 @@ int ip6_ipsec_filtertunnel(struct mbuf *); int ip6_ipsec_fwd(struct mbuf *); int ip6_ipsec_input(struct mbuf *, int); -int ip6_ipsec_output(struct mbuf **, struct inpcb *, int *, int *, - struct ifnet **); +int ip6_ipsec_output(struct mbuf **, struct inpcb *, int *); #if 0 int ip6_ipsec_mtu(struct mbuf *); #endif diff --git a/sys/netinet6/ip6_output.c b/sys/netinet6/ip6_output.c index 4fbac61..09eab20 100644 --- a/sys/netinet6/ip6_output.c +++ b/sys/netinet6/ip6_output.c @@ -348,8 +348,9 @@ ip6_output(struct mbuf *m0, struct ip6_pktopts *opt, /* * IPSec checking which handles several cases. * FAST IPSEC: We re-injected the packet. + * XXX: need scope argument. */ - switch(ip6_ipsec_output(&m, inp, &flags, &error, &ifp)) + switch(ip6_ipsec_output(&m, inp, &error)) { case 1: /* Bad packet */ goto freehdrs; diff --git a/sys/netinet6/raw_ip6.c b/sys/netinet6/raw_ip6.c index a37dfc5..54841d1 100644 --- a/sys/netinet6/raw_ip6.c +++ b/sys/netinet6/raw_ip6.c @@ -269,7 +269,6 @@ rip6_input(struct mbuf **mp, int *offp, int proto) */ if (n && ipsec6_in_reject(n, last)) { m_freem(n); - IPSEC6STAT_INC(ips_in_polvio); /* Do not inject data into pcb. */ } else #endif /* IPSEC */ @@ -301,7 +300,6 @@ rip6_input(struct mbuf **mp, int *offp, int proto) */ if ((last != NULL) && ipsec6_in_reject(m, last)) { m_freem(m); - IPSEC6STAT_INC(ips_in_polvio); IP6STAT_DEC(ip6s_delivered); /* Do not inject data into pcb. */ INP_RUNLOCK(last); diff --git a/sys/netinet6/udp6_usrreq.c b/sys/netinet6/udp6_usrreq.c index 17de377..92e6780 100644 --- a/sys/netinet6/udp6_usrreq.c +++ b/sys/netinet6/udp6_usrreq.c @@ -156,7 +156,6 @@ udp6_append(struct inpcb *inp, struct mbuf *n, int off, /* Check AH/ESP integrity. */ if (ipsec6_in_reject(n, inp)) { m_freem(n); - IPSEC6STAT_INC(ips_in_polvio); return; } #endif /* IPSEC */ diff --git a/sys/netipsec/esp.h b/sys/netipsec/esp.h index eb37397..8eb0963 100644 --- a/sys/netipsec/esp.h +++ b/sys/netipsec/esp.h @@ -42,8 +42,7 @@ struct esp { /*variable size, 32bit bound*/ /* Initialization Vector */ /*variable size*/ /* Payload data */ /*variable size*/ /* padding */ - /*8bit*/ /* pad size */ - /*8bit*/ /* next header */ + /*8bit*/ /* pad length */ /*8bit*/ /* next header */ /*variable size, 32bit bound*/ /* Authentication data (new IPsec) */ }; @@ -53,8 +52,7 @@ struct newesp { u_int32_t esp_seq; /* Sequence number */ /*variable size*/ /* (IV and) Payload data */ /*variable size*/ /* padding */ - /*8bit*/ /* pad size */ - /*8bit*/ /* next header */ + /*8bit*/ /* pad length */ /*8bit*/ /* next header */ /*variable size, 32bit bound*/ /* Authentication data */ }; diff --git a/sys/netipsec/ipip_var.h b/sys/netipsec/ipip_var.h deleted file mode 100644 index 02420c1..0000000 --- a/sys/netipsec/ipip_var.h +++ /dev/null @@ -1,71 +0,0 @@ -/* $FreeBSD$ */ -/* $OpenBSD: ip_ipip.h,v 1.5 2002/06/09 16:26:10 itojun Exp $ */ -/*- - * The authors of this code are John Ioannidis (ji@tla.org), - * Angelos D. Keromytis (kermit@csd.uch.gr) and - * Niels Provos (provos@physnet.uni-hamburg.de). - * - * The original version of this code was written by John Ioannidis - * for BSD/OS in Athens, Greece, in November 1995. - * - * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, - * by Angelos D. Keromytis. - * - * Additional transforms and features in 1997 and 1998 by Angelos D. Keromytis - * and Niels Provos. - * - * Additional features in 1999 by Angelos D. Keromytis. - * - * Copyright (C) 1995, 1996, 1997, 1998, 1999 by John Ioannidis, - * Angelos D. Keromytis and Niels Provos. - * Copyright (c) 2001, Angelos D. Keromytis. - * - * Permission to use, copy, and modify this software with or without fee - * is hereby granted, provided that this entire notice is included in - * all copies of any software which is or includes a copy or - * modification of this software. - * You may use this code under the GNU public license if you so wish. Please - * contribute changes back to the authors under this freer than GPL license - * so that we may further the use of strong encryption without limitations to - * all. - * - * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY - * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE - * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR - * PURPOSE. - */ - -#ifndef _NETINET_IPIP_H_ -#define _NETINET_IPIP_H_ - -/* - * IP-inside-IP processing. - * Not quite all the functionality of RFC-1853, but the main idea is there. - */ - -struct ipipstat { - uint64_t ipips_ipackets; /* total input packets */ - uint64_t ipips_opackets; /* total output packets */ - uint64_t ipips_hdrops; /* packet shorter than header shows */ - uint64_t ipips_qfull; - uint64_t ipips_ibytes; - uint64_t ipips_obytes; - uint64_t ipips_pdrops; /* packet dropped due to policy */ - uint64_t ipips_spoof; /* IP spoofing attempts */ - uint64_t ipips_family; /* Protocol family mismatch */ - uint64_t ipips_unspec; /* Missing tunnel endpoint address */ -}; - -#ifdef _KERNEL -#include <sys/counter.h> - -VNET_DECLARE(int, ipip_allow); -VNET_PCPUSTAT_DECLARE(struct ipipstat, ipipstat); - -#define IPIPSTAT_ADD(name, val) \ - VNET_PCPUSTAT_ADD(struct ipipstat, ipipstat, name, (val)) -#define IPIPSTAT_INC(name) IPIPSTAT_ADD(name, 1) -#define V_ipip_allow VNET(ipip_allow) -#endif /* _KERNEL */ -#endif /* _NETINET_IPIP_H_ */ diff --git a/sys/netipsec/ipsec.c b/sys/netipsec/ipsec.c index 93e37e8..bf02f93 100644 --- a/sys/netipsec/ipsec.c +++ b/sys/netipsec/ipsec.c @@ -117,11 +117,12 @@ VNET_DEFINE(int, ip4_esp_trans_deflev) = IPSEC_LEVEL_USE; VNET_DEFINE(int, ip4_esp_net_deflev) = IPSEC_LEVEL_USE; VNET_DEFINE(int, ip4_ah_trans_deflev) = IPSEC_LEVEL_USE; VNET_DEFINE(int, ip4_ah_net_deflev) = IPSEC_LEVEL_USE; -VNET_DEFINE(struct secpolicy, ip4_def_policy); /* ECN ignore(-1)/forbidden(0)/allowed(1) */ VNET_DEFINE(int, ip4_ipsec_ecn) = 0; VNET_DEFINE(int, ip4_esp_randpad) = -1; +static VNET_DEFINE(struct secpolicy, def_policy); +#define V_def_policy VNET(def_policy) /* * Crypto support requirements: * @@ -140,7 +141,7 @@ SYSCTL_DECL(_net_inet_ipsec); /* net.inet.ipsec */ SYSCTL_VNET_INT(_net_inet_ipsec, IPSECCTL_DEF_POLICY, def_policy, - CTLFLAG_RW, &VNET_NAME(ip4_def_policy).policy, 0, + CTLFLAG_RW, &VNET_NAME(def_policy).policy, 0, "IPsec default policy."); SYSCTL_VNET_INT(_net_inet_ipsec, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev, CTLFLAG_RW, &VNET_NAME(ip4_esp_trans_deflev), 0, @@ -212,7 +213,7 @@ SYSCTL_DECL(_net_inet6_ipsec6); /* net.inet6.ipsec6 */ SYSCTL_VNET_INT(_net_inet6_ipsec6, IPSECCTL_DEF_POLICY, def_policy, CTLFLAG_RW, - &VNET_NAME(ip4_def_policy).policy, 0, + &VNET_NAME(def_policy).policy, 0, "IPsec default policy."); SYSCTL_VNET_INT(_net_inet6_ipsec6, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev, CTLFLAG_RW, &VNET_NAME(ip6_esp_trans_deflev), 0, @@ -236,6 +237,7 @@ SYSCTL_VNET_PCPUSTAT(_net_inet6_ipsec6, IPSECCTL_STATS, ipsecstats, struct ipsecstat, ipsec6stat, "IPsec IPv6 statistics."); #endif /* INET6 */ +static int ipsec_in_reject(struct secpolicy *, struct mbuf *); static int ipsec_setspidx_inpcb(struct mbuf *, struct inpcb *); static int ipsec_setspidx(struct mbuf *, struct secpolicyindex *, int); static void ipsec4_get_ulp(struct mbuf *m, struct secpolicyindex *, int); @@ -261,7 +263,7 @@ key_allocsp_default(const char* where, int tag) KEYDEBUG(KEYDEBUG_IPSEC_STAMP, printf("DP key_allocsp_default from %s:%u\n", where, tag)); - sp = &V_ip4_def_policy; + sp = &V_def_policy; if (sp->policy != IPSEC_POLICY_DISCARD && sp->policy != IPSEC_POLICY_NONE) { ipseclog((LOG_INFO, "fixed system default policy: %d->%d\n", @@ -331,6 +333,12 @@ ipsec_getpolicybysock(struct mbuf *m, u_int dir, struct inpcb *inp, int *error) IPSEC_ASSERT(dir == IPSEC_DIR_INBOUND || dir == IPSEC_DIR_OUTBOUND, ("invalid direction %u", dir)); + if (!key_havesp(dir)) { + /* No SP found, use system default. */ + sp = KEY_ALLOCSP_DEFAULT(); + return (sp); + } + /* Set spidx in pcb. */ *error = ipsec_setspidx_inpcb(m, inp); if (*error) @@ -416,7 +424,7 @@ ipsec_getpolicybysock(struct mbuf *m, u_int dir, struct inpcb *inp, int *error) * others : error occured. */ struct secpolicy * -ipsec_getpolicybyaddr(struct mbuf *m, u_int dir, int flag, int *error) +ipsec_getpolicybyaddr(struct mbuf *m, u_int dir, int *error) { struct secpolicyindex spidx; struct secpolicy *sp; @@ -427,17 +435,16 @@ ipsec_getpolicybyaddr(struct mbuf *m, u_int dir, int flag, int *error) ("invalid direction %u", dir)); sp = NULL; + *error = 0; if (key_havesp(dir)) { /* Make an index to look for a policy. */ - *error = ipsec_setspidx(m, &spidx, - (flag & IP_FORWARDING) ? 0 : 1); + *error = ipsec_setspidx(m, &spidx, 0); if (*error != 0) { - DPRINTF(("%s: setpidx failed, dir %u flag %u\n", - __func__, dir, flag)); + DPRINTF(("%s: setpidx failed, dir %u\n", + __func__, dir)); return (NULL); } spidx.dir = dir; - sp = KEY_ALLOCSP(&spidx, dir); } if (sp == NULL) /* No SP found, use system default. */ @@ -447,14 +454,13 @@ ipsec_getpolicybyaddr(struct mbuf *m, u_int dir, int flag, int *error) } struct secpolicy * -ipsec4_checkpolicy(struct mbuf *m, u_int dir, u_int flag, int *error, - struct inpcb *inp) +ipsec4_checkpolicy(struct mbuf *m, u_int dir, int *error, struct inpcb *inp) { struct secpolicy *sp; *error = 0; if (inp == NULL) - sp = ipsec_getpolicybyaddr(m, dir, flag, error); + sp = ipsec_getpolicybyaddr(m, dir, error); else sp = ipsec_getpolicybysock(m, dir, inp, error); if (sp == NULL) { @@ -829,17 +835,13 @@ ipsec_init_policy(struct socket *so, struct inpcbpolicy **pcb_sp) ipsec_delpcbpolicy(new); return (ENOBUFS); } - new->sp_in->state = IPSEC_SPSTATE_ALIVE; new->sp_in->policy = IPSEC_POLICY_ENTRUST; - if ((new->sp_out = KEY_NEWSP()) == NULL) { KEY_FREESP(&new->sp_in); ipsec_delpcbpolicy(new); return (ENOBUFS); } - new->sp_out->state = IPSEC_SPSTATE_ALIVE; new->sp_out->policy = IPSEC_POLICY_ENTRUST; - *pcb_sp = new; return (0); @@ -928,7 +930,6 @@ ipsec_deepcopy_policy(struct secpolicy *src) } dst->req = newchain; - dst->state = src->state; dst->policy = src->policy; /* Do not touch the refcnt fields. */ @@ -980,8 +981,6 @@ ipsec_set_policy_internal(struct secpolicy **pcb_sp, int optname, if ((newsp = key_msg2sp(xpl, len, &error)) == NULL) return (error); - newsp->state = IPSEC_SPSTATE_ALIVE; - /* Clear old SP and set new SP. */ KEY_FREESP(pcb_sp); *pcb_sp = newsp; @@ -1198,7 +1197,7 @@ ipsec_get_reqlevel(struct ipsecrequest *isr) * 0: valid * 1: invalid */ -int +static int ipsec_in_reject(struct secpolicy *sp, struct mbuf *m) { struct ipsecrequest *isr; @@ -1266,6 +1265,9 @@ ipsec_in_reject(struct secpolicy *sp, struct mbuf *m) return (0); /* Valid. */ } +/* + * Non zero return value means security policy DISCARD or policy violation. + */ static int ipsec46_in_reject(struct mbuf *m, struct inpcb *inp) { @@ -1278,13 +1280,9 @@ ipsec46_in_reject(struct mbuf *m, struct inpcb *inp) IPSEC_ASSERT(m != NULL, ("null mbuf")); - /* - * Get SP for this packet. - * When we are called from ip_forward(), we call - * ipsec_getpolicybyaddr() with IP_FORWARDING flag. - */ + /* Get SP for this packet. */ if (inp == NULL) - sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND, IP_FORWARDING, &error); + sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND, &error); else sp = ipsec_getpolicybysock(m, IPSEC_DIR_INBOUND, inp, &error); @@ -1292,8 +1290,7 @@ ipsec46_in_reject(struct mbuf *m, struct inpcb *inp) result = ipsec_in_reject(sp, m); KEY_FREESP(&sp); } else { - result = 0; /* XXX Should be panic? - * -> No, there may be error. */ + result = 1; /* treat errors as policy violation */ } return (result); } @@ -1413,12 +1410,9 @@ ipsec_hdrsiz(struct mbuf *m, u_int dir, struct inpcb *inp) IPSEC_ASSERT(m != NULL, ("null mbuf")); - /* Get SP for this packet. - * When we are called from ip_forward(), we call - * ipsec_getpolicybyaddr() with IP_FORWARDING flag. - */ + /* Get SP for this packet. */ if (inp == NULL) - sp = ipsec_getpolicybyaddr(m, dir, IP_FORWARDING, &error); + sp = ipsec_getpolicybyaddr(m, dir, &error); else sp = ipsec_getpolicybysock(m, dir, inp, &error); @@ -1506,6 +1500,7 @@ ipsec_chkreplay(u_int32_t seq, struct secasvar *sav) int ipsec_updatereplay(u_int32_t seq, struct secasvar *sav) { + char buf[128]; struct secreplay *replay; u_int32_t diff; int fr; @@ -1585,7 +1580,8 @@ ok: return (1); ipseclog((LOG_WARNING, "%s: replay counter made %d cycle. %s\n", - __func__, replay->overflow, ipsec_logsastr(sav))); + __func__, replay->overflow, + ipsec_logsastr(sav, buf, sizeof(buf)))); } replay->count++; @@ -1616,67 +1612,37 @@ vshiftl(unsigned char *bitmap, int nbit, int wsize) } } -#ifdef INET -/* Return a printable string for the IPv4 address. */ -static char * -inet_ntoa4(struct in_addr ina) -{ - static char buf[4][4 * sizeof "123" + 4]; - unsigned char *ucp = (unsigned char *) &ina; - static int i = 3; - - /* XXX-BZ Returns static buffer. */ - i = (i + 1) % 4; - sprintf(buf[i], "%d.%d.%d.%d", ucp[0] & 0xff, ucp[1] & 0xff, - ucp[2] & 0xff, ucp[3] & 0xff); - return (buf[i]); -} -#endif - /* Return a printable string for the address. */ -char * -ipsec_address(union sockaddr_union* sa) +char* +ipsec_address(union sockaddr_union* sa, char *buf, socklen_t size) { -#ifdef INET6 - char ip6buf[INET6_ADDRSTRLEN]; -#endif switch (sa->sa.sa_family) { #ifdef INET case AF_INET: - return (inet_ntoa4(sa->sin.sin_addr)); + return (inet_ntop(AF_INET, &sa->sin.sin_addr, buf, size)); #endif /* INET */ #ifdef INET6 case AF_INET6: - return (ip6_sprintf(ip6buf, &sa->sin6.sin6_addr)); + return (inet_ntop(AF_INET6, &sa->sin6.sin6_addr, buf, size)); #endif /* INET6 */ default: return ("(unknown address family)"); } } -const char * -ipsec_logsastr(struct secasvar *sav) +char * +ipsec_logsastr(struct secasvar *sav, char *buf, size_t size) { - static char buf[256]; - char *p; - struct secasindex *saidx = &sav->sah->saidx; - - IPSEC_ASSERT(saidx->src.sa.sa_family == saidx->dst.sa.sa_family, - ("address family mismatch")); - - p = buf; - snprintf(buf, sizeof(buf), "SA(SPI=%u ", (u_int32_t)ntohl(sav->spi)); - while (p && *p) - p++; - /* NB: only use ipsec_address on one address at a time. */ - snprintf(p, sizeof (buf) - (p - buf), "src=%s ", - ipsec_address(&saidx->src)); - while (p && *p) - p++; - snprintf(p, sizeof (buf) - (p - buf), "dst=%s)", - ipsec_address(&saidx->dst)); + char sbuf[INET6_ADDRSTRLEN], dbuf[INET6_ADDRSTRLEN]; + + IPSEC_ASSERT(sav->sah->saidx.src.sa.sa_family == + sav->sah->saidx.dst.sa.sa_family, ("address family mismatch")); + snprintf(buf, size, "SA(SPI=%08lx src=%s dst=%s)", + (u_long)ntohl(sav->spi), + ipsec_address(&sav->sah->saidx.src, sbuf, sizeof(sbuf)), + ipsec_address(&sav->sah->saidx.dst, dbuf, sizeof(dbuf))); return (buf); } @@ -1705,14 +1671,15 @@ ipsec_dumpmbuf(struct mbuf *m) } static void -ipsec_init(const void *unused __unused) +def_policy_init(const void *unused __unused) { - SECPOLICY_LOCK_INIT(&V_ip4_def_policy); - V_ip4_def_policy.refcnt = 1; /* NB: disallow free. */ + bzero(&V_def_policy, sizeof(struct secpolicy)); + V_def_policy.policy = IPSEC_POLICY_NONE; + V_def_policy.refcnt = 1; } -VNET_SYSINIT(ipsec_init, SI_SUB_PROTO_DOMAININIT, SI_ORDER_ANY, ipsec_init, - NULL); +VNET_SYSINIT(def_policy_init, SI_SUB_PROTO_DOMAININIT, SI_ORDER_ANY, + def_policy_init, NULL); /* XXX This stuff doesn't belong here... */ diff --git a/sys/netipsec/ipsec.h b/sys/netipsec/ipsec.h index 6da3fc7..c05be36 100644 --- a/sys/netipsec/ipsec.h +++ b/sys/netipsec/ipsec.h @@ -81,21 +81,18 @@ struct secpolicyindex { /* Security Policy Data Base */ struct secpolicy { - LIST_ENTRY(secpolicy) chain; - struct mtx lock; + TAILQ_ENTRY(secpolicy) chain; - u_int refcnt; /* reference count */ struct secpolicyindex spidx; /* selector */ - u_int32_t id; /* It's unique number on the system. */ - u_int state; /* 0: dead, others: alive */ -#define IPSEC_SPSTATE_DEAD 0 -#define IPSEC_SPSTATE_ALIVE 1 - u_int policy; /* policy_type per pfkeyv2.h */ - u_int16_t scangen; /* scan generation # */ struct ipsecrequest *req; /* pointer to the ipsec request tree, */ /* if policy == IPSEC else this value == NULL.*/ - + u_int refcnt; /* reference count */ + u_int policy; /* policy_type per pfkeyv2.h */ + u_int state; +#define IPSEC_SPSTATE_DEAD 0 +#define IPSEC_SPSTATE_ALIVE 1 + u_int32_t id; /* It's unique number on the system. */ /* * lifetime handler. * the policy can be used without limitiation if both lifetime and @@ -109,13 +106,6 @@ struct secpolicy { long validtime; /* duration this policy is valid without use */ }; -#define SECPOLICY_LOCK_INIT(_sp) \ - mtx_init(&(_sp)->lock, "ipsec policy", NULL, MTX_DEF) -#define SECPOLICY_LOCK(_sp) mtx_lock(&(_sp)->lock) -#define SECPOLICY_UNLOCK(_sp) mtx_unlock(&(_sp)->lock) -#define SECPOLICY_LOCK_DESTROY(_sp) mtx_destroy(&(_sp)->lock) -#define SECPOLICY_LOCK_ASSERT(_sp) mtx_assert(&(_sp)->lock, MA_OWNED) - /* Request for IPsec */ struct ipsecrequest { struct ipsecrequest *next; @@ -271,17 +261,6 @@ struct ipsecstat { #ifdef _KERNEL #include <sys/counter.h> -struct ipsec_output_state { - struct mbuf *m; - struct route *ro; - struct sockaddr *dst; -}; - -struct ipsec_history { - int ih_proto; - u_int32_t ih_spi; -}; - VNET_DECLARE(int, ipsec_debug); #define V_ipsec_debug VNET(ipsec_debug) @@ -294,7 +273,6 @@ VNET_DECLARE(int, ipsec_integrity); #endif VNET_PCPUSTAT_DECLARE(struct ipsecstat, ipsec4stat); -VNET_DECLARE(struct secpolicy, ip4_def_policy); VNET_DECLARE(int, ip4_esp_trans_deflev); VNET_DECLARE(int, ip4_esp_net_deflev); VNET_DECLARE(int, ip4_ah_trans_deflev); @@ -307,7 +285,6 @@ VNET_DECLARE(int, crypto_support); #define IPSECSTAT_INC(name) \ VNET_PCPUSTAT_ADD(struct ipsecstat, ipsec4stat, name, 1) -#define V_ip4_def_policy VNET(ip4_def_policy) #define V_ip4_esp_trans_deflev VNET(ip4_esp_trans_deflev) #define V_ip4_esp_net_deflev VNET(ip4_esp_net_deflev) #define V_ip4_ah_trans_deflev VNET(ip4_ah_trans_deflev) @@ -328,16 +305,14 @@ extern void ipsec_delisr(struct ipsecrequest *); struct tdb_ident; extern struct secpolicy *ipsec_getpolicy(struct tdb_ident*, u_int); struct inpcb; -extern struct secpolicy *ipsec4_checkpolicy(struct mbuf *, u_int, u_int, +extern struct secpolicy *ipsec4_checkpolicy(struct mbuf *, u_int, int *, struct inpcb *); -extern struct secpolicy * ipsec_getpolicybyaddr(struct mbuf *, u_int, - int, int *); +extern struct secpolicy * ipsec_getpolicybyaddr(struct mbuf *, u_int, int *); struct inpcb; extern int ipsec_init_policy(struct socket *so, struct inpcbpolicy **); extern int ipsec_copy_policy(struct inpcbpolicy *, struct inpcbpolicy *); extern u_int ipsec_get_reqlevel(struct ipsecrequest *); -extern int ipsec_in_reject(struct secpolicy *, struct mbuf *); extern int ipsec_set_policy(struct inpcb *inp, int optname, caddr_t request, size_t len, struct ucred *cred); @@ -355,8 +330,8 @@ extern size_t ipsec_hdrsiz(struct mbuf *, u_int, struct inpcb *); extern size_t ipsec_hdrsiz_tcp(struct tcpcb *); union sockaddr_union; -extern char * ipsec_address(union sockaddr_union* sa); -extern const char *ipsec_logsastr(struct secasvar *); +extern char *ipsec_address(union sockaddr_union *, char *, socklen_t); +extern char *ipsec_logsastr(struct secasvar *, char *, size_t); extern void ipsec_dumpmbuf(struct mbuf *); @@ -366,11 +341,10 @@ extern void ah4_ctlinput(int cmd, struct sockaddr *sa, void *); extern void esp4_input(struct mbuf *m, int off); extern void esp4_ctlinput(int cmd, struct sockaddr *sa, void *); extern void ipcomp4_input(struct mbuf *m, int off); -extern int ipsec4_common_input(struct mbuf *m, ...); +extern int ipsec_common_input(struct mbuf *m, int, int, int, int); extern int ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, - int skip, int protoff, struct m_tag *mt); -extern int ipsec4_process_packet(struct mbuf *, struct ipsecrequest *, - int, int); + int skip, int protoff); +extern int ipsec4_process_packet(struct mbuf *, struct ipsecrequest *); extern int ipsec_process_done(struct mbuf *, struct ipsecrequest *); extern struct mbuf *ipsec_copypkt(struct mbuf *); diff --git a/sys/netipsec/ipsec6.h b/sys/netipsec/ipsec6.h index 5179939..38ac114 100644 --- a/sys/netipsec/ipsec6.h +++ b/sys/netipsec/ipsec6.h @@ -64,7 +64,7 @@ extern int ipsec6_in_reject(struct mbuf *, struct inpcb *); struct m_tag; extern int ipsec6_common_input(struct mbuf **mp, int *offp, int proto); extern int ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, - int skip, int protoff, struct m_tag *mt); + int skip, int protoff); extern void esp6_ctlinput(int, struct sockaddr *, void *); extern int ipsec6_process_packet(struct mbuf *, struct ipsecrequest *); #endif /*_KERNEL*/ diff --git a/sys/netipsec/ipsec_input.c b/sys/netipsec/ipsec_input.c index 66de530..8fb74ff 100644 --- a/sys/netipsec/ipsec_input.c +++ b/sys/netipsec/ipsec_input.c @@ -117,9 +117,10 @@ static void ipsec4_common_ctlinput(int, struct sockaddr *, void *, int); * and call the appropriate transform. The transform callback * takes care of further processing (like ingress filtering). */ -static int +int ipsec_common_input(struct mbuf *m, int skip, int protoff, int af, int sproto) { + char buf[INET6_ADDRSTRLEN]; union sockaddr_union dst_address; struct secasvar *sav; u_int32_t spi; @@ -194,6 +195,13 @@ ipsec_common_input(struct mbuf *m, int skip, int protoff, int af, int sproto) m_copydata(m, offsetof(struct ip6_hdr, ip6_dst), sizeof(struct in6_addr), (caddr_t) &dst_address.sin6.sin6_addr); + /* We keep addresses in SADB without embedded scope id */ + if (IN6_IS_SCOPE_LINKLOCAL(&dst_address.sin6.sin6_addr)) { + /* XXX: sa6_recoverscope() */ + dst_address.sin6.sin6_scope_id = + ntohs(dst_address.sin6.sin6_addr.s6_addr16[1]); + dst_address.sin6.sin6_addr.s6_addr16[1] = 0; + } break; #endif /* INET6 */ default: @@ -207,8 +215,8 @@ ipsec_common_input(struct mbuf *m, int skip, int protoff, int af, int sproto) sav = KEY_ALLOCSA(&dst_address, sproto, spi); if (sav == NULL) { DPRINTF(("%s: no key association found for SA %s/%08lx/%u\n", - __func__, ipsec_address(&dst_address), - (u_long) ntohl(spi), sproto)); + __func__, ipsec_address(&dst_address, buf, sizeof(buf)), + (u_long) ntohl(spi), sproto)); IPSEC_ISTAT(sproto, notdb); m_freem(m); return ENOENT; @@ -216,8 +224,8 @@ ipsec_common_input(struct mbuf *m, int skip, int protoff, int af, int sproto) if (sav->tdb_xform == NULL) { DPRINTF(("%s: attempted to use uninitialized SA %s/%08lx/%u\n", - __func__, ipsec_address(&dst_address), - (u_long) ntohl(spi), sproto)); + __func__, ipsec_address(&dst_address, buf, sizeof(buf)), + (u_long) ntohl(spi), sproto)); IPSEC_ISTAT(sproto, noxform); KEY_FREESAV(&sav); m_freem(m); @@ -234,28 +242,11 @@ ipsec_common_input(struct mbuf *m, int skip, int protoff, int af, int sproto) } #ifdef INET -/* - * Common input handler for IPv4 AH, ESP, and IPCOMP. - */ -int -ipsec4_common_input(struct mbuf *m, ...) -{ - va_list ap; - int off, nxt; - - va_start(ap, m); - off = va_arg(ap, int); - nxt = va_arg(ap, int); - va_end(ap); - - return ipsec_common_input(m, off, offsetof(struct ip, ip_p), - AF_INET, nxt); -} - void ah4_input(struct mbuf *m, int off) { - ipsec4_common_input(m, off, IPPROTO_AH); + ipsec_common_input(m, off, offsetof(struct ip, ip_p), + AF_INET, IPPROTO_AH); } void ah4_ctlinput(int cmd, struct sockaddr *sa, void *v) @@ -268,7 +259,8 @@ ah4_ctlinput(int cmd, struct sockaddr *sa, void *v) void esp4_input(struct mbuf *m, int off) { - ipsec4_common_input(m, off, IPPROTO_ESP); + ipsec_common_input(m, off, offsetof(struct ip, ip_p), + AF_INET, IPPROTO_ESP); } void esp4_ctlinput(int cmd, struct sockaddr *sa, void *v) @@ -281,7 +273,8 @@ esp4_ctlinput(int cmd, struct sockaddr *sa, void *v) void ipcomp4_input(struct mbuf *m, int off) { - ipsec4_common_input(m, off, IPPROTO_IPCOMP); + ipsec_common_input(m, off, offsetof(struct ip, ip_p), + AF_INET, IPPROTO_IPCOMP); } /* @@ -291,9 +284,10 @@ ipcomp4_input(struct mbuf *m, int off) * the processed packet. */ int -ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, - int skip, int protoff, struct m_tag *mt) +ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, + int protoff) { + char buf[INET6_ADDRSTRLEN]; int prot, af, sproto, isr_prot; struct ip *ip; struct m_tag *mtag; @@ -332,8 +326,8 @@ ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, */ if (m->m_len < skip && (m = m_pullup(m, skip)) == NULL) { DPRINTF(("%s: processing failed for SA %s/%08lx\n", - __func__, ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + __func__, ipsec_address(&sav->sah->saidx.dst, + buf, sizeof(buf)), (u_long) ntohl(sav->spi))); IPSEC_ISTAT(sproto, hdrops); error = ENOBUFS; goto bad; @@ -356,6 +350,7 @@ ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, ipsec_bpf(m, sav, AF_INET, ENC_IN|ENC_BEFORE); if ((error = ipsec_filter(&m, PFIL_IN, ENC_IN|ENC_BEFORE)) != 0) return (error); + ip = mtod(m, struct ip *); #endif /* DEV_ENC */ /* IP-in-IP encapsulation */ @@ -449,13 +444,9 @@ ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, /* * Record what we've done to the packet (under what SA it was - * processed). If we've been passed an mtag, it means the packet - * was already processed by an ethernet/crypto combo card and - * thus has a tag attached with all the right information, but - * with a PACKET_TAG_IPSEC_IN_CRYPTO_DONE as opposed to - * PACKET_TAG_IPSEC_IN_DONE type; in that case, just change the type. + * processed). */ - if (mt == NULL && sproto != IPPROTO_IPCOMP) { + if (sproto != IPPROTO_IPCOMP) { mtag = m_tag_get(PACKET_TAG_IPSEC_IN_DONE, sizeof(struct tdb_ident), M_NOWAIT); if (mtag == NULL) { @@ -474,9 +465,6 @@ ipsec4_common_input_cb(struct mbuf *m, struct secasvar *sav, tdbi->alg_enc = sav->alg_enc; m_tag_prepend(m, mtag); - } else if (mt != NULL) { - mt->m_tag_id = PACKET_TAG_IPSEC_IN_DONE; - /* XXX do we need to mark m_flags??? */ } key_sa_recordxfer(sav, m); /* record data transfer */ @@ -593,15 +581,16 @@ ipsec6_common_input(struct mbuf **mp, int *offp, int proto) * filtering and other sanity checks on the processed packet. */ int -ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, int protoff, - struct m_tag *mt) +ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, + int protoff) { + char buf[INET6_ADDRSTRLEN]; int prot, af, sproto; struct ip6_hdr *ip6; struct m_tag *mtag; struct tdb_ident *tdbi; struct secasindex *saidx; - int nxt; + int nxt, isr_prot; u_int8_t nxt8; int error, nest; #ifdef notyet @@ -632,8 +621,8 @@ ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, int proto (m = m_pullup(m, sizeof(struct ip6_hdr))) == NULL) { DPRINTF(("%s: processing failed for SA %s/%08lx\n", - __func__, ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + __func__, ipsec_address(&sav->sah->saidx.dst, buf, + sizeof(buf)), (u_long) ntohl(sav->spi))); IPSEC_ISTAT(sproto, hdrops); error = EACCES; @@ -738,13 +727,9 @@ ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, int proto /* * Record what we've done to the packet (under what SA it was - * processed). If we've been passed an mtag, it means the packet - * was already processed by an ethernet/crypto combo card and - * thus has a tag attached with all the right information, but - * with a PACKET_TAG_IPSEC_IN_CRYPTO_DONE as opposed to - * PACKET_TAG_IPSEC_IN_DONE type; in that case, just change the type. + * processed). */ - if (mt == NULL && sproto != IPPROTO_IPCOMP) { + if (sproto != IPPROTO_IPCOMP) { mtag = m_tag_get(PACKET_TAG_IPSEC_IN_DONE, sizeof(struct tdb_ident), M_NOWAIT); if (mtag == NULL) { @@ -763,10 +748,6 @@ ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, int proto tdbi->alg_enc = sav->alg_enc; m_tag_prepend(m, mtag); - } else { - if (mt != NULL) - mt->m_tag_id = PACKET_TAG_IPSEC_IN_DONE; - /* XXX do we need to mark m_flags??? */ } key_sa_recordxfer(sav, m); @@ -785,6 +766,35 @@ ipsec6_common_input_cb(struct mbuf *m, struct secasvar *sav, int skip, int proto if ((error = ipsec_filter(&m, PFIL_IN, ENC_IN|ENC_AFTER)) != 0) return (error); #endif /* DEV_ENC */ + if (skip == 0) { + /* + * We stripped outer IPv6 header. + * Now we should requeue decrypted packet via netisr. + */ + switch (prot) { +#ifdef INET + case IPPROTO_IPIP: + isr_prot = NETISR_IP; + break; +#endif + case IPPROTO_IPV6: + isr_prot = NETISR_IPV6; + break; + default: + DPRINTF(("%s: cannot handle inner ip proto %d\n", + __func__, prot)); + IPSEC_ISTAT(sproto, nopf); + error = EPFNOSUPPORT; + goto bad; + } + error = netisr_queue_src(isr_prot, (uintptr_t)sav->spi, m); + if (error) { + IPSEC_ISTAT(sproto, qfull); + DPRINTF(("%s: queue full; proto %u packet dropped\n", + __func__, sproto)); + } + return (error); + } /* * See the end of ip6_input for this logic. * IPPROTO_IPV[46] case will be processed just like other ones diff --git a/sys/netipsec/ipsec_output.c b/sys/netipsec/ipsec_output.c index 442fb7a..7fc61ac 100644 --- a/sys/netipsec/ipsec_output.c +++ b/sys/netipsec/ipsec_output.c @@ -60,6 +60,7 @@ #include <netinet/ip6.h> #ifdef INET6 #include <netinet6/ip6_var.h> +#include <netinet6/scope6_var.h> #endif #include <netinet/in_pcb.h> #ifdef INET6 @@ -102,6 +103,7 @@ ipsec_process_done(struct mbuf *m, struct ipsecrequest *isr) IPSEC_ASSERT(m != NULL, ("null mbuf")); IPSEC_ASSERT(isr != NULL, ("null ISR")); + IPSEC_ASSERT(isr->sp != NULL, ("NULL isr->sp")); sav = isr->sav; IPSEC_ASSERT(sav != NULL, ("null SA")); IPSEC_ASSERT(sav->sah != NULL, ("null SAH")); @@ -155,12 +157,18 @@ ipsec_process_done(struct mbuf *m, struct ipsecrequest *isr) tdbi->spi = sav->spi; m_tag_prepend(m, mtag); + key_sa_recordxfer(sav, m); /* record data transfer */ + /* * If there's another (bundled) SA to apply, do so. * Note that this puts a burden on the kernel stack size. * If this is a problem we'll need to introduce a queue * to set the packet on so we can unwind the stack before * doing further processing. + * + * If ipsec[46]_process_packet() will successfully queue + * the request, we need to take additional reference to SP, + * because xform callback will release reference. */ if (isr->next) { /* XXX-BZ currently only support same AF bundles. */ @@ -168,7 +176,11 @@ ipsec_process_done(struct mbuf *m, struct ipsecrequest *isr) #ifdef INET case AF_INET: IPSECSTAT_INC(ips_out_bundlesa); - return ipsec4_process_packet(m, isr->next, 0, 0); + key_addref(isr->sp); + error = ipsec4_process_packet(m, isr->next); + if (error != 0) + KEY_FREESP(&isr->sp); + return (error); /* NOTREACHED */ #endif #ifdef notyet @@ -176,7 +188,11 @@ ipsec_process_done(struct mbuf *m, struct ipsecrequest *isr) case AF_INET6: /* XXX */ IPSEC6STAT_INC(ips_out_bundlesa); - return ipsec6_process_packet(m, isr->next); + key_addref(isr->sp); + error = ipsec6_process_packet(m, isr->next); + if (error != 0) + KEY_FREESP(&isr->sp); + return (error); /* NOTREACHED */ #endif /* INET6 */ #endif @@ -187,12 +203,10 @@ ipsec_process_done(struct mbuf *m, struct ipsecrequest *isr) goto bad; } } - key_sa_recordxfer(sav, m); /* record data transfer */ /* * We're done with IPsec processing, transmit the packet using the - * appropriate network protocol (IP or IPv6). SPD lookup will be - * performed again there. + * appropriate network protocol (IP or IPv6). */ switch (saidx->dst.sa.sa_family) { #ifdef INET @@ -418,17 +432,117 @@ bad: #undef IPSEC_OSTAT } +static int +ipsec_encap(struct mbuf **mp, struct secasindex *saidx) +{ +#ifdef INET6 + struct ip6_hdr *ip6; +#endif + struct ip *ip; + int setdf; + uint8_t itos, proto; + + ip = mtod(*mp, struct ip *); + switch (ip->ip_v) { +#ifdef INET + case IPVERSION: + proto = IPPROTO_IPIP; + /* + * Collect IP_DF state from the inner header + * and honor system-wide control of how to handle it. + */ + switch (V_ip4_ipsec_dfbit) { + case 0: /* clear in outer header */ + case 1: /* set in outer header */ + setdf = V_ip4_ipsec_dfbit; + break; + default:/* propagate to outer header */ + setdf = (ip->ip_off & ntohs(IP_DF)) != 0; + } + itos = ip->ip_tos; + break; +#endif +#ifdef INET6 + case (IPV6_VERSION >> 4): + proto = IPPROTO_IPV6; + ip6 = mtod(*mp, struct ip6_hdr *); + itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff; + setdf = V_ip4_ipsec_dfbit ? 1: 0; + /* scoped address handling */ + in6_clearscope(&ip6->ip6_src); + in6_clearscope(&ip6->ip6_dst); + break; +#endif + default: + return (EAFNOSUPPORT); + } + switch (saidx->dst.sa.sa_family) { +#ifdef INET + case AF_INET: + if (saidx->src.sa.sa_family != AF_INET || + saidx->src.sin.sin_addr.s_addr == INADDR_ANY || + saidx->dst.sin.sin_addr.s_addr == INADDR_ANY) + return (EINVAL); + M_PREPEND(*mp, sizeof(struct ip), M_NOWAIT); + if (*mp == NULL) + return (ENOBUFS); + ip = mtod(*mp, struct ip *); + ip->ip_v = IPVERSION; + ip->ip_hl = sizeof(struct ip) >> 2; + ip->ip_p = proto; + ip->ip_len = htons((*mp)->m_pkthdr.len); + ip->ip_ttl = V_ip_defttl; + ip->ip_sum = 0; + ip->ip_off = setdf ? htons(IP_DF): 0; + ip->ip_src = saidx->src.sin.sin_addr; + ip->ip_dst = saidx->dst.sin.sin_addr; + ip_ecn_ingress(V_ip4_ipsec_ecn, &ip->ip_tos, &itos); + ip->ip_id = ip_newid(); + break; +#endif /* INET */ +#ifdef INET6 + case AF_INET6: + if (saidx->src.sa.sa_family != AF_INET6 || + IN6_IS_ADDR_UNSPECIFIED(&saidx->src.sin6.sin6_addr) || + IN6_IS_ADDR_UNSPECIFIED(&saidx->dst.sin6.sin6_addr)) + return (EINVAL); + M_PREPEND(*mp, sizeof(struct ip6_hdr), M_NOWAIT); + if (*mp == NULL) + return (ENOBUFS); + ip6 = mtod(*mp, struct ip6_hdr *); + ip6->ip6_flow = 0; + ip6->ip6_vfc = IPV6_VERSION; + ip6->ip6_hlim = V_ip6_defhlim; + ip6->ip6_nxt = proto; + ip6->ip6_dst = saidx->dst.sin6.sin6_addr; + /* For link-local address embed scope zone id */ + if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst)) + ip6->ip6_dst.s6_addr16[1] = + htons(saidx->dst.sin6.sin6_scope_id & 0xffff); + ip6->ip6_src = saidx->src.sin6.sin6_addr; + if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) + ip6->ip6_src.s6_addr16[1] = + htons(saidx->src.sin6.sin6_scope_id & 0xffff); + ip6->ip6_plen = htons((*mp)->m_pkthdr.len - sizeof(*ip6)); + ip_ecn_ingress(V_ip6_ipsec_ecn, &proto, &itos); + ip6->ip6_flow |= htonl((uint32_t)proto << 20); + break; +#endif /* INET6 */ + default: + return (EAFNOSUPPORT); + } + return (0); +} + #ifdef INET /* * IPsec output logic for IPv4. */ int -ipsec4_process_packet( - struct mbuf *m, - struct ipsecrequest *isr, - int flags, - int tunalready) +ipsec4_process_packet(struct mbuf *m, struct ipsecrequest *isr) { + char sbuf[INET6_ADDRSTRLEN], dbuf[INET6_ADDRSTRLEN]; + union sockaddr_union *dst; struct secasindex saidx; struct secasvar *sav; struct ip *ip; @@ -447,7 +561,13 @@ ipsec4_process_packet( } sav = isr->sav; - + if (m->m_len < sizeof(struct ip) && + (m = m_pullup(m, sizeof (struct ip))) == NULL) { + error = ENOBUFS; + goto bad; + } + ip = mtod(m, struct ip *); + dst = &sav->sah->saidx.dst; #ifdef DEV_ENC encif->if_opackets++; encif->if_obytes += m->m_pkthdr.len; @@ -457,99 +577,29 @@ ipsec4_process_packet( /* pass the mbuf to enc0 for packet filtering */ if ((error = ipsec_filter(&m, PFIL_OUT, ENC_OUT|ENC_BEFORE)) != 0) goto bad; + ip = mtod(m, struct ip *); #endif - - if (!tunalready) { - union sockaddr_union *dst = &sav->sah->saidx.dst; - int setdf; - - /* - * Collect IP_DF state from the outer header. - */ - if (dst->sa.sa_family == AF_INET) { - if (m->m_len < sizeof (struct ip) && - (m = m_pullup(m, sizeof (struct ip))) == NULL) { - error = ENOBUFS; - goto bad; - } - ip = mtod(m, struct ip *); - /* Honor system-wide control of how to handle IP_DF */ - switch (V_ip4_ipsec_dfbit) { - case 0: /* clear in outer header */ - case 1: /* set in outer header */ - setdf = V_ip4_ipsec_dfbit; - break; - default: /* propagate to outer header */ - setdf = ntohs(ip->ip_off & IP_DF); - break; - } - } else { - ip = NULL; /* keep compiler happy */ - setdf = 0; - } - /* Do the appropriate encapsulation, if necessary */ - if (isr->saidx.mode == IPSEC_MODE_TUNNEL || /* Tunnel requ'd */ - dst->sa.sa_family != AF_INET || /* PF mismatch */ -#if 0 - (sav->flags & SADB_X_SAFLAGS_TUNNEL) || /* Tunnel requ'd */ - sav->tdb_xform->xf_type == XF_IP4 || /* ditto */ -#endif - (dst->sa.sa_family == AF_INET && /* Proxy */ - dst->sin.sin_addr.s_addr != INADDR_ANY && - dst->sin.sin_addr.s_addr != ip->ip_dst.s_addr)) { - struct mbuf *mp; - - /* Fix IPv4 header checksum and length */ - if (m->m_len < sizeof (struct ip) && - (m = m_pullup(m, sizeof (struct ip))) == NULL) { - error = ENOBUFS; - goto bad; - } - ip = mtod(m, struct ip *); - if (ip->ip_v == IPVERSION) { - ip->ip_len = htons(m->m_pkthdr.len); - ip->ip_sum = 0; - ip->ip_sum = in_cksum(m, ip->ip_hl << 2); - } - - /* Encapsulate the packet */ - error = ipip_output(m, isr, &mp, 0, 0); - if (mp == NULL && !error) { - /* Should never happen. */ - DPRINTF(("%s: ipip_output returns no mbuf and " - "no error!", __func__)); - error = EFAULT; - } - if (error) { - if (mp) { - /* XXX: Should never happen! */ - m_freem(mp); - } - m = NULL; /* ipip_output() already freed it */ - goto bad; - } - m = mp, mp = NULL; - /* - * ipip_output clears IP_DF in the new header. If - * we need to propagate IP_DF from the outer header, - * then we have to do it here. - * - * XXX shouldn't assume what ipip_output does. - */ - if (dst->sa.sa_family == AF_INET && setdf) { - if (m->m_len < sizeof (struct ip) && - (m = m_pullup(m, sizeof (struct ip))) == NULL) { - error = ENOBUFS; - goto bad; - } - ip = mtod(m, struct ip *); - ip->ip_off = ntohs(ip->ip_off); - ip->ip_off |= IP_DF; - ip->ip_off = htons(ip->ip_off); - } + /* Do the appropriate encapsulation, if necessary */ + if (isr->saidx.mode == IPSEC_MODE_TUNNEL || /* Tunnel requ'd */ + dst->sa.sa_family != AF_INET || /* PF mismatch */ + (dst->sa.sa_family == AF_INET && /* Proxy */ + dst->sin.sin_addr.s_addr != INADDR_ANY && + dst->sin.sin_addr.s_addr != ip->ip_dst.s_addr)) { + /* Fix IPv4 header checksum and length */ + ip->ip_len = htons(m->m_pkthdr.len); + ip->ip_sum = 0; + ip->ip_sum = in_cksum(m, ip->ip_hl << 2); + error = ipsec_encap(&m, &sav->sah->saidx); + if (error != 0) { + DPRINTF(("%s: encapsulation for SA %s->%s " + "SPI 0x%08x failed with error %d\n", __func__, + ipsec_address(&sav->sah->saidx.src, sbuf, + sizeof(sbuf)), + ipsec_address(&sav->sah->saidx.dst, dbuf, + sizeof(dbuf)), ntohl(sav->spi), error)); + goto bad; } } - #ifdef DEV_ENC /* pass the mbuf to enc0 for bpf processing */ ipsec_bpf(m, sav, sav->sah->saidx.dst.sa.sa_family, ENC_OUT|ENC_AFTER); @@ -561,40 +611,33 @@ ipsec4_process_packet( /* * Dispatch to the appropriate IPsec transform logic. The * packet will be returned for transmission after crypto - * processing, etc. are completed. For encapsulation we - * bypass this call because of the explicit call done above - * (necessary to deal with IP_DF handling for IPv4). + * processing, etc. are completed. * * NB: m & sav are ``passed to caller'' who's reponsible for * for reclaiming their resources. */ - if (sav->tdb_xform->xf_type != XF_IP4) { - union sockaddr_union *dst = &sav->sah->saidx.dst; - switch(dst->sa.sa_family) { - case AF_INET: - ip = mtod(m, struct ip *); - i = ip->ip_hl << 2; - off = offsetof(struct ip, ip_p); - break; + switch(dst->sa.sa_family) { + case AF_INET: + ip = mtod(m, struct ip *); + i = ip->ip_hl << 2; + off = offsetof(struct ip, ip_p); + break; #ifdef INET6 - case AF_INET6: - i = sizeof(struct ip6_hdr); - off = offsetof(struct ip6_hdr, ip6_nxt); - break; + case AF_INET6: + i = sizeof(struct ip6_hdr); + off = offsetof(struct ip6_hdr, ip6_nxt); + break; #endif /* INET6 */ - default: + default: DPRINTF(("%s: unsupported protocol family %u\n", - __func__, dst->sa.sa_family)); - error = EPFNOSUPPORT; - IPSECSTAT_INC(ips_out_inval); - goto bad; - } - error = (*sav->tdb_xform->xf_output)(m, isr, NULL, i, off); - } else { - error = ipsec_process_done(m, isr); + __func__, dst->sa.sa_family)); + error = EPFNOSUPPORT; + IPSECSTAT_INC(ips_out_inval); + goto bad; } + error = (*sav->tdb_xform->xf_output)(m, isr, NULL, i, off); IPSECREQUEST_UNLOCK(isr); - return error; + return (error); bad: if (isr) IPSECREQUEST_UNLOCK(isr); @@ -622,11 +665,9 @@ in6_sa_equal_addrwithscope(const struct sockaddr_in6 *sa, const struct in6_addr * IPsec output logic for IPv6. */ int -ipsec6_process_packet( - struct mbuf *m, - struct ipsecrequest *isr - ) +ipsec6_process_packet(struct mbuf *m, struct ipsecrequest *isr) { + char sbuf[INET6_ADDRSTRLEN], dbuf[INET6_ADDRSTRLEN]; struct secasindex saidx; struct secasvar *sav; struct ip6_hdr *ip6; @@ -644,7 +685,6 @@ ipsec6_process_packet( goto bad; return EJUSTRETURN; } - sav = isr->sav; dst = &sav->sah->saidx.dst; @@ -659,6 +699,7 @@ ipsec6_process_packet( /* pass the mbuf to enc0 for packet filtering */ if ((error = ipsec_filter(&m, PFIL_OUT, ENC_OUT|ENC_BEFORE)) != 0) goto bad; + ip6 = mtod(m, struct ip6_hdr *); #endif /* DEV_ENC */ /* Do the appropriate encapsulation, if necessary */ @@ -668,42 +709,21 @@ ipsec6_process_packet( (!IN6_IS_ADDR_UNSPECIFIED(&dst->sin6.sin6_addr)) && (!in6_sa_equal_addrwithscope(&dst->sin6, &ip6->ip6_dst)))) { - struct mbuf *mp; - - /* Fix IPv6 header payload length. */ - if (m->m_len < sizeof(struct ip6_hdr)) - if ((m = m_pullup(m,sizeof(struct ip6_hdr))) == NULL) { - error = ENOBUFS; - goto bad; - } - if (m->m_pkthdr.len - sizeof(*ip6) > IPV6_MAXPACKET) { /* No jumbogram support. */ error = ENXIO; /*XXX*/ goto bad; } - - /* Encapsulate the packet */ - error = ipip_output(m, isr, &mp, 0, 0); - if (mp == NULL && !error) { - /* Should never happen. */ - DPRINTF(("ipsec6_process_packet: ipip_output " - "returns no mbuf and no error!")); - error = EFAULT; - goto bad; - } - - if (error) { - if (mp) { - /* XXX: Should never happen! */ - m_freem(mp); - } - m = NULL; /* ipip_output() already freed it */ + error = ipsec_encap(&m, &sav->sah->saidx); + if (error != 0) { + DPRINTF(("%s: encapsulation for SA %s->%s " + "SPI 0x%08x failed with error %d\n", __func__, + ipsec_address(&sav->sah->saidx.src, sbuf, + sizeof(sbuf)), + ipsec_address(&sav->sah->saidx.dst, dbuf, + sizeof(dbuf)), ntohl(sav->spi), error)); goto bad; } - - m = mp; - mp = NULL; } #ifdef DEV_ENC diff --git a/sys/netipsec/key.c b/sys/netipsec/key.c index a3e3d76..7705a63 100644 --- a/sys/netipsec/key.c +++ b/sys/netipsec/key.c @@ -48,6 +48,7 @@ #include <sys/domain.h> #include <sys/protosw.h> #include <sys/malloc.h> +#include <sys/rmlock.h> #include <sys/socket.h> #include <sys/socketvar.h> #include <sys/sysctl.h> @@ -140,16 +141,19 @@ static VNET_DEFINE(u_int32_t, acq_seq) = 0; #define V_acq_seq VNET(acq_seq) /* SPD */ -static VNET_DEFINE(LIST_HEAD(_sptree, secpolicy), sptree[IPSEC_DIR_MAX]); +static VNET_DEFINE(TAILQ_HEAD(_sptree, secpolicy), sptree[IPSEC_DIR_MAX]); +static struct rmlock sptree_lock; #define V_sptree VNET(sptree) -static struct mtx sptree_lock; -#define SPTREE_LOCK_INIT() \ - mtx_init(&sptree_lock, "sptree", \ - "fast ipsec security policy database", MTX_DEF) -#define SPTREE_LOCK_DESTROY() mtx_destroy(&sptree_lock) -#define SPTREE_LOCK() mtx_lock(&sptree_lock) -#define SPTREE_UNLOCK() mtx_unlock(&sptree_lock) -#define SPTREE_LOCK_ASSERT() mtx_assert(&sptree_lock, MA_OWNED) +#define SPTREE_LOCK_INIT() rm_init(&sptree_lock, "sptree") +#define SPTREE_LOCK_DESTROY() rm_destroy(&sptree_lock) +#define SPTREE_RLOCK_TRACKER struct rm_priotracker sptree_tracker +#define SPTREE_RLOCK() rm_rlock(&sptree_lock, &sptree_tracker) +#define SPTREE_RUNLOCK() rm_runlock(&sptree_lock, &sptree_tracker) +#define SPTREE_RLOCK_ASSERT() rm_assert(&sptree_lock, RA_RLOCKED) +#define SPTREE_WLOCK() rm_wlock(&sptree_lock) +#define SPTREE_WUNLOCK() rm_wunlock(&sptree_lock) +#define SPTREE_WLOCK_ASSERT() rm_assert(&sptree_lock, RA_WLOCKED) +#define SPTREE_UNLOCK_ASSERT() rm_assert(&sptree_lock, RA_UNLOCKED) static VNET_DEFINE(LIST_HEAD(_sahtree, secashead), sahtree); /* SAD */ #define V_sahtree VNET(sahtree) @@ -411,9 +415,8 @@ struct sadb_msghdr { static struct secasvar *key_allocsa_policy(const struct secasindex *); static void key_freesp_so(struct secpolicy **); static struct secasvar *key_do_allocsa_policy(struct secashead *, u_int); -static void key_delsp(struct secpolicy *); +static void key_unlink(struct secpolicy *); static struct secpolicy *key_getsp(struct secpolicyindex *); -static void _key_delsp(struct secpolicy *sp); static struct secpolicy *key_getspbyid(u_int32_t); static u_int32_t key_newreqid(void); static struct mbuf *key_gather_mbuf(struct mbuf *, @@ -570,15 +573,8 @@ sa_delref(struct secasvar *sav) return (refcount_release(&sav->refcnt)); } -#define SP_ADDREF(p) do { \ - (p)->refcnt++; \ - IPSEC_ASSERT((p)->refcnt != 0, ("SP refcnt overflow")); \ -} while (0) -#define SP_DELREF(p) do { \ - IPSEC_ASSERT((p)->refcnt > 0, ("SP refcnt underflow")); \ - (p)->refcnt--; \ -} while (0) - +#define SP_ADDREF(p) refcount_acquire(&(p)->refcnt) +#define SP_DELREF(p) refcount_release(&(p)->refcnt) /* * Update the refcnt while holding the SPTREE lock. @@ -586,9 +582,8 @@ sa_delref(struct secasvar *sav) void key_addref(struct secpolicy *sp) { - SPTREE_LOCK(); + SP_ADDREF(sp); - SPTREE_UNLOCK(); } /* @@ -601,7 +596,7 @@ key_havesp(u_int dir) { return (dir == IPSEC_DIR_INBOUND || dir == IPSEC_DIR_OUTBOUND ? - LIST_FIRST(&V_sptree[dir]) != NULL : 1); + TAILQ_FIRST(&V_sptree[dir]) != NULL : 1); } /* %%% IPsec policy management */ @@ -615,6 +610,7 @@ struct secpolicy * key_allocsp(struct secpolicyindex *spidx, u_int dir, const char* where, int tag) { + SPTREE_RLOCK_TRACKER; struct secpolicy *sp; IPSEC_ASSERT(spidx != NULL, ("null spidx")); @@ -629,14 +625,11 @@ key_allocsp(struct secpolicyindex *spidx, u_int dir, const char* where, printf("*** objects\n"); kdebug_secpolicyindex(spidx)); - SPTREE_LOCK(); - LIST_FOREACH(sp, &V_sptree[dir], chain) { + SPTREE_RLOCK(); + TAILQ_FOREACH(sp, &V_sptree[dir], chain) { KEYDEBUG(KEYDEBUG_IPSEC_DATA, printf("*** in SPD\n"); kdebug_secpolicyindex(&sp->spidx)); - - if (sp->state == IPSEC_SPSTATE_DEAD) - continue; if (key_cmpspidx_withmask(&sp->spidx, spidx)) goto found; } @@ -650,7 +643,7 @@ found: sp->lastused = time_second; SP_ADDREF(sp); } - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); KEYDEBUG(KEYDEBUG_IPSEC_STAMP, printf("DP %s return SP:%p (ID=%u) refcnt %u\n", __func__, @@ -668,6 +661,7 @@ struct secpolicy * key_allocsp2(u_int32_t spi, union sockaddr_union *dst, u_int8_t proto, u_int dir, const char* where, int tag) { + SPTREE_RLOCK_TRACKER; struct secpolicy *sp; IPSEC_ASSERT(dst != NULL, ("null dst")); @@ -683,14 +677,11 @@ key_allocsp2(u_int32_t spi, union sockaddr_union *dst, u_int8_t proto, printf("spi %u proto %u dir %u\n", spi, proto, dir); kdebug_sockaddr(&dst->sa)); - SPTREE_LOCK(); - LIST_FOREACH(sp, &V_sptree[dir], chain) { + SPTREE_RLOCK(); + TAILQ_FOREACH(sp, &V_sptree[dir], chain) { KEYDEBUG(KEYDEBUG_IPSEC_DATA, printf("*** in SPD\n"); kdebug_secpolicyindex(&sp->spidx)); - - if (sp->state == IPSEC_SPSTATE_DEAD) - continue; /* compare simple values, then dst address */ if (sp->spidx.ul_proto != proto) continue; @@ -710,7 +701,7 @@ found: sp->lastused = time_second; SP_ADDREF(sp); } - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); KEYDEBUG(KEYDEBUG_IPSEC_STAMP, printf("DP %s return SP:%p (ID=%u) refcnt %u\n", __func__, @@ -1169,22 +1160,47 @@ done: void _key_freesp(struct secpolicy **spp, const char* where, int tag) { + struct ipsecrequest *isr, *nextisr; struct secpolicy *sp = *spp; IPSEC_ASSERT(sp != NULL, ("null sp")); - - SPTREE_LOCK(); - SP_DELREF(sp); - KEYDEBUG(KEYDEBUG_IPSEC_STAMP, printf("DP %s SP:%p (ID=%u) from %s:%u; refcnt now %u\n", __func__, sp, sp->id, where, tag, sp->refcnt)); - if (sp->refcnt == 0) { - *spp = NULL; - key_delsp(sp); + if (SP_DELREF(sp) == 0) + return; + *spp = NULL; + for (isr = sp->req; isr != NULL; isr = nextisr) { + if (isr->sav != NULL) { + KEY_FREESAV(&isr->sav); + isr->sav = NULL; + } + nextisr = isr->next; + ipsec_delisr(isr); } - SPTREE_UNLOCK(); + free(sp, M_IPSEC_SP); +} + +static void +key_unlink(struct secpolicy *sp) +{ + + IPSEC_ASSERT(sp != NULL, ("null sp")); + IPSEC_ASSERT(sp->spidx.dir == IPSEC_DIR_INBOUND || + sp->spidx.dir == IPSEC_DIR_OUTBOUND, + ("invalid direction %u", sp->spidx.dir)); + SPTREE_UNLOCK_ASSERT(); + + SPTREE_WLOCK(); + if (sp->state == IPSEC_SPSTATE_DEAD) { + SPTREE_WUNLOCK(); + return; + } + sp->state = IPSEC_SPSTATE_DEAD; + TAILQ_REMOVE(&V_sptree[sp->spidx.dir], sp, chain); + SPTREE_WUNLOCK(); + KEY_FREESP(&sp); } /* @@ -1273,38 +1289,6 @@ key_freesav(struct secasvar **psav, const char* where, int tag) /* %%% SPD management */ /* - * free security policy entry. - */ -static void -key_delsp(struct secpolicy *sp) -{ - struct ipsecrequest *isr, *nextisr; - - IPSEC_ASSERT(sp != NULL, ("null sp")); - SPTREE_LOCK_ASSERT(); - - sp->state = IPSEC_SPSTATE_DEAD; - - IPSEC_ASSERT(sp->refcnt == 0, - ("SP with references deleted (refcnt %u)", sp->refcnt)); - - /* remove from SP index */ - if (__LIST_CHAINED(sp)) - LIST_REMOVE(sp, chain); - - for (isr = sp->req; isr != NULL; isr = nextisr) { - if (isr->sav != NULL) { - KEY_FREESAV(&isr->sav); - isr->sav = NULL; - } - - nextisr = isr->next; - ipsec_delisr(isr); - } - _key_delsp(sp); -} - -/* * search SPD * OUT: NULL : not found * others : found, pointer to a SP. @@ -1312,20 +1296,19 @@ key_delsp(struct secpolicy *sp) static struct secpolicy * key_getsp(struct secpolicyindex *spidx) { + SPTREE_RLOCK_TRACKER; struct secpolicy *sp; IPSEC_ASSERT(spidx != NULL, ("null spidx")); - SPTREE_LOCK(); - LIST_FOREACH(sp, &V_sptree[spidx->dir], chain) { - if (sp->state == IPSEC_SPSTATE_DEAD) - continue; + SPTREE_RLOCK(); + TAILQ_FOREACH(sp, &V_sptree[spidx->dir], chain) { if (key_cmpspidx_exactly(spidx, &sp->spidx)) { SP_ADDREF(sp); break; } } - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); return sp; } @@ -1338,28 +1321,25 @@ key_getsp(struct secpolicyindex *spidx) static struct secpolicy * key_getspbyid(u_int32_t id) { + SPTREE_RLOCK_TRACKER; struct secpolicy *sp; - SPTREE_LOCK(); - LIST_FOREACH(sp, &V_sptree[IPSEC_DIR_INBOUND], chain) { - if (sp->state == IPSEC_SPSTATE_DEAD) - continue; + SPTREE_RLOCK(); + TAILQ_FOREACH(sp, &V_sptree[IPSEC_DIR_INBOUND], chain) { if (sp->id == id) { SP_ADDREF(sp); goto done; } } - LIST_FOREACH(sp, &V_sptree[IPSEC_DIR_OUTBOUND], chain) { - if (sp->state == IPSEC_SPSTATE_DEAD) - continue; + TAILQ_FOREACH(sp, &V_sptree[IPSEC_DIR_OUTBOUND], chain) { if (sp->id == id) { SP_ADDREF(sp); goto done; } } done: - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); return sp; } @@ -1371,11 +1351,8 @@ key_newsp(const char* where, int tag) newsp = (struct secpolicy *) malloc(sizeof(struct secpolicy), M_IPSEC_SP, M_NOWAIT|M_ZERO); - if (newsp) { - SECPOLICY_LOCK_INIT(newsp); - newsp->refcnt = 1; - newsp->req = NULL; - } + if (newsp) + refcount_init(&newsp->refcnt, 1); KEYDEBUG(KEYDEBUG_IPSEC_STAMP, printf("DP %s from %s:%u return SP:%p\n", __func__, @@ -1383,13 +1360,6 @@ key_newsp(const char* where, int tag) return newsp; } -static void -_key_delsp(struct secpolicy *sp) -{ - SECPOLICY_LOCK_DESTROY(sp); - free(sp, M_IPSEC_SP); -} - /* * create secpolicy structure from sadb_x_policy structure. * NOTE: `state', `secpolicyindex' in secpolicy structure are not set, @@ -1869,9 +1839,7 @@ key_spdadd(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) newsp = key_getsp(&spidx); if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) { if (newsp) { - SPTREE_LOCK(); - newsp->state = IPSEC_SPSTATE_DEAD; - SPTREE_UNLOCK(); + key_unlink(newsp); KEY_FREESP(&newsp); } } else { @@ -1883,13 +1851,15 @@ key_spdadd(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) } } + /* XXX: there is race between key_getsp and key_msg2sp. */ + /* allocation new SP entry */ if ((newsp = key_msg2sp(xpl0, PFKEY_EXTLEN(xpl0), &error)) == NULL) { return key_senderror(so, m, error); } if ((newsp->id = key_getnewspid()) == 0) { - _key_delsp(newsp); + KEY_FREESP(&newsp); return key_senderror(so, m, ENOBUFS); } @@ -1905,18 +1875,20 @@ key_spdadd(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) /* sanity check on addr pair */ if (((struct sockaddr *)(src0 + 1))->sa_family != ((struct sockaddr *)(dst0+ 1))->sa_family) { - _key_delsp(newsp); + KEY_FREESP(&newsp); return key_senderror(so, m, EINVAL); } if (((struct sockaddr *)(src0 + 1))->sa_len != ((struct sockaddr *)(dst0+ 1))->sa_len) { - _key_delsp(newsp); + KEY_FREESP(&newsp); return key_senderror(so, m, EINVAL); } #if 1 - if (newsp->req && newsp->req->saidx.src.sa.sa_family && newsp->req->saidx.dst.sa.sa_family) { - if (newsp->req->saidx.src.sa.sa_family != newsp->req->saidx.dst.sa.sa_family) { - _key_delsp(newsp); + if (newsp->req && newsp->req->saidx.src.sa.sa_family && + newsp->req->saidx.dst.sa.sa_family) { + if (newsp->req->saidx.src.sa.sa_family != + newsp->req->saidx.dst.sa.sa_family) { + KEY_FREESP(&newsp); return key_senderror(so, m, EINVAL); } } @@ -1927,9 +1899,10 @@ key_spdadd(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) newsp->lifetime = lft ? lft->sadb_lifetime_addtime : 0; newsp->validtime = lft ? lft->sadb_lifetime_usetime : 0; - newsp->refcnt = 1; /* do not reclaim until I say I do */ + SPTREE_WLOCK(); + TAILQ_INSERT_TAIL(&V_sptree[newsp->spidx.dir], newsp, chain); newsp->state = IPSEC_SPSTATE_ALIVE; - LIST_INSERT_TAIL(&V_sptree[newsp->spidx.dir], newsp, secpolicy, chain); + SPTREE_WUNLOCK(); /* delete the entry in spacqtree */ if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) { @@ -2104,9 +2077,7 @@ key_spddelete(struct socket *so, struct mbuf *m, /* save policy id to buffer to be returned. */ xpl0->sadb_x_policy_id = sp->id; - SPTREE_LOCK(); - sp->state = IPSEC_SPSTATE_DEAD; - SPTREE_UNLOCK(); + key_unlink(sp); KEY_FREESP(&sp); { @@ -2171,9 +2142,7 @@ key_spddelete2(struct socket *so, struct mbuf *m, return key_senderror(so, m, EINVAL); } - SPTREE_LOCK(); - sp->state = IPSEC_SPSTATE_DEAD; - SPTREE_UNLOCK(); + key_unlink(sp); KEY_FREESP(&sp); { @@ -2352,8 +2321,9 @@ key_spdacquire(struct secpolicy *sp) static int key_spdflush(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) { + TAILQ_HEAD(, secpolicy) drainq; struct sadb_msg *newmsg; - struct secpolicy *sp; + struct secpolicy *sp, *nextsp; u_int dir; IPSEC_ASSERT(so != NULL, ("null socket")); @@ -2364,11 +2334,23 @@ key_spdflush(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) if (m->m_len != PFKEY_ALIGN8(sizeof(struct sadb_msg))) return key_senderror(so, m, EINVAL); + TAILQ_INIT(&drainq); + SPTREE_WLOCK(); for (dir = 0; dir < IPSEC_DIR_MAX; dir++) { - SPTREE_LOCK(); - LIST_FOREACH(sp, &V_sptree[dir], chain) - sp->state = IPSEC_SPSTATE_DEAD; - SPTREE_UNLOCK(); + TAILQ_CONCAT(&drainq, &V_sptree[dir], chain); + } + /* + * We need to set state to DEAD for each policy to be sure, + * that another thread won't try to unlink it. + */ + TAILQ_FOREACH(sp, &drainq, chain) + sp->state = IPSEC_SPSTATE_DEAD; + SPTREE_WUNLOCK(); + sp = TAILQ_FIRST(&drainq); + while (sp != NULL) { + nextsp = TAILQ_NEXT(sp, chain); + KEY_FREESP(&sp); + sp = nextsp; } if (sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) { @@ -2401,6 +2383,7 @@ key_spdflush(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) static int key_spddump(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) { + SPTREE_RLOCK_TRACKER; struct secpolicy *sp; int cnt; u_int dir; @@ -2413,20 +2396,20 @@ key_spddump(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) /* search SPD entry and get buffer size. */ cnt = 0; - SPTREE_LOCK(); + SPTREE_RLOCK(); for (dir = 0; dir < IPSEC_DIR_MAX; dir++) { - LIST_FOREACH(sp, &V_sptree[dir], chain) { + TAILQ_FOREACH(sp, &V_sptree[dir], chain) { cnt++; } } if (cnt == 0) { - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); return key_senderror(so, m, ENOENT); } for (dir = 0; dir < IPSEC_DIR_MAX; dir++) { - LIST_FOREACH(sp, &V_sptree[dir], chain) { + TAILQ_FOREACH(sp, &V_sptree[dir], chain) { --cnt; n = key_setdumpsp(sp, SADB_X_SPDDUMP, cnt, mhp->msg->sadb_msg_pid); @@ -2436,7 +2419,7 @@ key_spddump(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp) } } - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); m_freem(m); return 0; } @@ -2848,7 +2831,6 @@ key_cleansav(struct secasvar *sav) sav->tdb_xform->xf_zeroize(sav); sav->tdb_xform = NULL; } else { - KASSERT(sav->iv == NULL, ("iv but no xform")); if (sav->key_auth != NULL) bzero(sav->key_auth->key_data, _KEYLEN(sav->key_auth)); if (sav->key_enc != NULL) @@ -3026,7 +3008,6 @@ key_setsaval(struct secasvar *sav, struct mbuf *m, sav->key_enc = NULL; sav->sched = NULL; sav->schedlen = 0; - sav->iv = NULL; sav->lft_c = NULL; sav->lft_h = NULL; sav->lft_s = NULL; @@ -3871,48 +3852,19 @@ key_ismyaddr(struct sockaddr *sa) * compare my own address for IPv6. * 1: ours * 0: other - * NOTE: derived ip6_input() in KAME. This is necessary to modify more. */ -#include <netinet6/in6_var.h> - static int key_ismyaddr6(struct sockaddr_in6 *sin6) { - struct in6_ifaddr *ia; -#if 0 - struct in6_multi *in6m; -#endif + struct in6_addr in6; - IN6_IFADDR_RLOCK(); - TAILQ_FOREACH(ia, &V_in6_ifaddrhead, ia_link) { - if (key_sockaddrcmp((struct sockaddr *)sin6, - (struct sockaddr *)&ia->ia_addr, 0) == 0) { - IN6_IFADDR_RUNLOCK(); - return 1; - } + if (!IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr)) + return (in6_localip(&sin6->sin6_addr)); -#if 0 - /* - * XXX Multicast - * XXX why do we care about multlicast here while we don't care - * about IPv4 multicast?? - * XXX scope - */ - in6m = NULL; - IN6_LOOKUP_MULTI(sin6->sin6_addr, ia->ia_ifp, in6m); - if (in6m) { - IN6_IFADDR_RUNLOCK(); - return 1; - } -#endif - } - IN6_IFADDR_RUNLOCK(); - - /* loopback, just for safety */ - if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr)) - return 1; - - return 0; + /* Convert address into kernel-internal form */ + in6 = sin6->sin6_addr; + in6.s6_addr16[1] = htons(sin6->sin6_scope_id & 0xffff); + return (in6_localip(&in6)); } #endif /*INET6*/ @@ -4222,47 +4174,30 @@ key_bbcmp(const void *a1, const void *a2, u_int bits) static void key_flush_spd(time_t now) { - static u_int16_t sptree_scangen = 0; - u_int16_t gen = sptree_scangen++; + SPTREE_RLOCK_TRACKER; struct secpolicy *sp; u_int dir; /* SPD */ for (dir = 0; dir < IPSEC_DIR_MAX; dir++) { restart: - SPTREE_LOCK(); - LIST_FOREACH(sp, &V_sptree[dir], chain) { - if (sp->scangen == gen) /* previously handled */ - continue; - sp->scangen = gen; - if (sp->state == IPSEC_SPSTATE_DEAD && - sp->refcnt == 1) { - /* - * Ensure that we only decrease refcnt once, - * when we're the last consumer. - * Directly call SP_DELREF/key_delsp instead - * of KEY_FREESP to avoid unlocking/relocking - * SPTREE_LOCK before key_delsp: may refcnt - * be increased again during that time ? - * NB: also clean entries created by - * key_spdflush - */ - SP_DELREF(sp); - key_delsp(sp); - SPTREE_UNLOCK(); - goto restart; - } + SPTREE_RLOCK(); + TAILQ_FOREACH(sp, &V_sptree[dir], chain) { if (sp->lifetime == 0 && sp->validtime == 0) continue; - if ((sp->lifetime && now - sp->created > sp->lifetime) - || (sp->validtime && now - sp->lastused > sp->validtime)) { - sp->state = IPSEC_SPSTATE_DEAD; - SPTREE_UNLOCK(); + if ((sp->lifetime && + now - sp->created > sp->lifetime) || + (sp->validtime && + now - sp->lastused > sp->validtime)) { + SP_ADDREF(sp); + SPTREE_RUNLOCK(); key_spdexpire(sp); + key_unlink(sp); + KEY_FREESP(&sp); goto restart; } } - SPTREE_UNLOCK(); + SPTREE_RUNLOCK(); } } @@ -7655,7 +7590,7 @@ key_init(void) int i; for (i = 0; i < IPSEC_DIR_MAX; i++) - LIST_INIT(&V_sptree[i]); + TAILQ_INIT(&V_sptree[i]); LIST_INIT(&V_sahtree); @@ -7665,10 +7600,6 @@ key_init(void) LIST_INIT(&V_acqtree); LIST_INIT(&V_spacqtree); - /* system default */ - V_ip4_def_policy.policy = IPSEC_POLICY_NONE; - V_ip4_def_policy.refcnt++; /*never reclaim this*/ - if (!IS_DEFAULT_VNET(curvnet)) return; @@ -7692,6 +7623,7 @@ key_init(void) void key_destroy(void) { + TAILQ_HEAD(, secpolicy) drainq; struct secpolicy *sp, *nextsp; struct secacq *acq, *nextacq; struct secspacq *spacq, *nextspacq; @@ -7699,18 +7631,18 @@ key_destroy(void) struct secreg *reg; int i; - SPTREE_LOCK(); + TAILQ_INIT(&drainq); + SPTREE_WLOCK(); for (i = 0; i < IPSEC_DIR_MAX; i++) { - for (sp = LIST_FIRST(&V_sptree[i]); - sp != NULL; sp = nextsp) { - nextsp = LIST_NEXT(sp, chain); - if (__LIST_CHAINED(sp)) { - LIST_REMOVE(sp, chain); - free(sp, M_IPSEC_SP); - } - } + TAILQ_CONCAT(&drainq, &V_sptree[i], chain); + } + SPTREE_WUNLOCK(); + sp = TAILQ_FIRST(&drainq); + while (sp != NULL) { + nextsp = TAILQ_NEXT(sp, chain); + KEY_FREESP(&sp); + sp = nextsp; } - SPTREE_UNLOCK(); SAHTREE_LOCK(); for (sah = LIST_FIRST(&V_sahtree); sah != NULL; sah = nextsah) { @@ -7831,14 +7763,6 @@ key_sa_chgstate(struct secasvar *sav, u_int8_t state) } } -void -key_sa_stir_iv(struct secasvar *sav) -{ - - IPSEC_ASSERT(sav->iv != NULL, ("null IV")); - key_randomfill(sav->iv, sav->ivlen); -} - /* * Take one of the kernel's security keys and convert it into a PF_KEY * structure within an mbuf, suitable for sending up to a waiting diff --git a/sys/netipsec/key.h b/sys/netipsec/key.h index f197977..39fd1b2 100644 --- a/sys/netipsec/key.h +++ b/sys/netipsec/key.h @@ -106,7 +106,6 @@ extern void key_init(void); extern void key_destroy(void); #endif extern void key_sa_recordxfer(struct secasvar *, struct mbuf *); -extern void key_sa_stir_iv(struct secasvar *); #ifdef IPSEC_NAT_T u_int16_t key_portfromsaddr(struct sockaddr *); #define KEY_PORTFROMSADDR(saddr) \ diff --git a/sys/netipsec/key_debug.c b/sys/netipsec/key_debug.c index 2031af6..c9365e2 100644 --- a/sys/netipsec/key_debug.c +++ b/sys/netipsec/key_debug.c @@ -463,8 +463,8 @@ kdebug_secpolicy(struct secpolicy *sp) if (sp == NULL) panic("%s: NULL pointer was passed.\n", __func__); - printf("secpolicy{ refcnt=%u state=%u policy=%u\n", - sp->refcnt, sp->state, sp->policy); + printf("secpolicy{ refcnt=%u policy=%u\n", + sp->refcnt, sp->policy); kdebug_secpolicyindex(&sp->spidx); @@ -577,11 +577,6 @@ kdebug_secasv(struct secasvar *sav) kdebug_sadb_key((struct sadb_ext *)sav->key_auth); if (sav->key_enc != NULL) kdebug_sadb_key((struct sadb_ext *)sav->key_enc); - if (sav->iv != NULL) { - printf(" iv="); - ipsec_hexdump(sav->iv, sav->ivlen ? sav->ivlen : 8); - printf("\n"); - } if (sav->replay != NULL) kdebug_secreplay(sav->replay); diff --git a/sys/netipsec/keydb.h b/sys/netipsec/keydb.h index 15dbc9c..3fe28eb 100644 --- a/sys/netipsec/keydb.h +++ b/sys/netipsec/keydb.h @@ -122,10 +122,10 @@ struct secasvar { struct seckey *key_auth; /* Key for Authentication */ struct seckey *key_enc; /* Key for Encryption */ - caddr_t iv; /* Initilization Vector */ u_int ivlen; /* length of IV */ void *sched; /* intermediate encryption key */ size_t schedlen; + uint64_t cntr; /* counter for GCM and CTR */ struct secreplay *replay; /* replay prevention */ time_t created; /* for lifetime */ @@ -163,6 +163,12 @@ struct secasvar { #define SECASVAR_UNLOCK(_sav) mtx_unlock(&(_sav)->lock) #define SECASVAR_LOCK_DESTROY(_sav) mtx_destroy(&(_sav)->lock) #define SECASVAR_LOCK_ASSERT(_sav) mtx_assert(&(_sav)->lock, MA_OWNED) +#define SAV_ISGCM(_sav) \ + ((_sav)->alg_enc == SADB_X_EALG_AESGCM8 || \ + (_sav)->alg_enc == SADB_X_EALG_AESGCM12 || \ + (_sav)->alg_enc == SADB_X_EALG_AESGCM16) +#define SAV_ISCTR(_sav) ((_sav)->alg_enc == SADB_X_EALG_AESCTR) +#define SAV_ISCTRORGCM(_sav) (SAV_ISCTR((_sav)) || SAV_ISGCM((_sav))) /* replay prevention */ struct secreplay { diff --git a/sys/netipsec/xform.h b/sys/netipsec/xform.h index e389cab..fee457b 100644 --- a/sys/netipsec/xform.h +++ b/sys/netipsec/xform.h @@ -83,7 +83,7 @@ struct ipescrequest; struct xformsw { u_short xf_type; /* xform ID */ -#define XF_IP4 1 /* IP inside IP */ +#define XF_IP4 1 /* unused */ #define XF_AH 2 /* AH */ #define XF_ESP 3 /* ESP */ #define XF_TCPSIGNATURE 5 /* TCP MD5 Signature option, RFC 2358 */ @@ -105,15 +105,10 @@ struct xformsw { #ifdef _KERNEL extern void xform_register(struct xformsw*); extern int xform_init(struct secasvar *sav, int xftype); +extern int xform_ah_authsize(struct auth_hash *esph); struct cryptoini; -/* XF_IP4 */ -extern int ip4_input6(struct mbuf **m, int *offp, int proto); -extern void ip4_input(struct mbuf *m, int); -extern int ipip_output(struct mbuf *, struct ipsecrequest *, - struct mbuf **, int, int); - /* XF_AH */ extern int ah_init0(struct secasvar *, struct xformsw *, struct cryptoini *); extern int ah_zeroize(struct secasvar *sav); diff --git a/sys/netipsec/xform_ah.c b/sys/netipsec/xform_ah.c index afa452c..6829d59 100644 --- a/sys/netipsec/xform_ah.c +++ b/sys/netipsec/xform_ah.c @@ -80,11 +80,11 @@ (((sav)->flags & SADB_X_EXT_OLD) ? \ sizeof (struct ah) : sizeof (struct ah) + sizeof (u_int32_t)) /* - * Return authenticator size in bytes. The old protocol is known - * to use a fixed 16-byte authenticator. The new algorithm use 12-byte - * authenticator. + * Return authenticator size in bytes, based on a field in the + * algorithm descriptor. */ -#define AUTHSIZE(sav) ah_authsize(sav) +#define AUTHSIZE(sav) ((sav->flags & SADB_X_EXT_OLD) ? 16 : \ + xform_ah_authsize((sav)->tdb_authalgxform)) VNET_DEFINE(int, ah_enable) = 1; /* control flow of packets with AH */ VNET_DEFINE(int, ah_cleartos) = 1; /* clear ip_tos when doing AH calc */ @@ -110,27 +110,35 @@ static unsigned char ipseczeroes[256]; /* larger than an ip6 extension hdr */ static int ah_input_cb(struct cryptop*); static int ah_output_cb(struct cryptop*); -static int -ah_authsize(struct secasvar *sav) +int +xform_ah_authsize(struct auth_hash *esph) { + int alen; - IPSEC_ASSERT(sav != NULL, ("%s: sav == NULL", __func__)); + if (esph == NULL) + return 0; - if (sav->flags & SADB_X_EXT_OLD) - return 16; + switch (esph->type) { + case CRYPTO_SHA2_256_HMAC: + case CRYPTO_SHA2_384_HMAC: + case CRYPTO_SHA2_512_HMAC: + alen = esph->hashsize / 2; /* RFC4868 2.3 */ + break; + + case CRYPTO_AES_128_NIST_GMAC: + case CRYPTO_AES_192_NIST_GMAC: + case CRYPTO_AES_256_NIST_GMAC: + alen = esph->hashsize; + break; - switch (sav->alg_auth) { - case SADB_X_AALG_SHA2_256: - return 16; - case SADB_X_AALG_SHA2_384: - return 24; - case SADB_X_AALG_SHA2_512: - return 32; default: - return AH_HMAC_HASHLEN; + alen = AH_HMAC_HASHLEN; + break; } - /* NOTREACHED */ + + return alen; } + /* * NB: this is public for use by the PF_KEY support. */ @@ -158,6 +166,12 @@ ah_algorithm_lookup(int alg) return &auth_hash_hmac_sha2_384; case SADB_X_AALG_SHA2_512: return &auth_hash_hmac_sha2_512; + case SADB_X_AALG_AES128GMAC: + return &auth_hash_nist_gmac_aes_128; + case SADB_X_AALG_AES192GMAC: + return &auth_hash_nist_gmac_aes_192; + case SADB_X_AALG_AES256GMAC: + return &auth_hash_nist_gmac_aes_256; } return NULL; } @@ -565,12 +579,11 @@ ah_massage_headers(struct mbuf **m0, int proto, int skip, int alg, int out) static int ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) { + char buf[128]; struct auth_hash *ahx; - struct tdb_ident *tdbi; struct tdb_crypto *tc; - struct m_tag *mtag; struct newah *ah; - int hl, rplen, authsize; + int hl, rplen, authsize, error; struct cryptodesc *crda; struct cryptop *crp; @@ -596,7 +609,7 @@ ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) if (sav->replay && !ipsec_chkreplay(ntohl(ah->ah_seq), sav)) { AHSTAT_INC(ahs_replay); DPRINTF(("%s: packet replay failure: %s\n", __func__, - ipsec_logsastr(sav))); + ipsec_logsastr(sav, buf, sizeof(buf)))); m_freem(m); return ENOBUFS; } @@ -607,10 +620,10 @@ ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) authsize = AUTHSIZE(sav); if (hl != authsize + rplen - sizeof (struct ah)) { DPRINTF(("%s: bad authenticator length %u (expecting %lu)" - " for packet in SA %s/%08lx\n", __func__, - hl, (u_long) (authsize + rplen - sizeof (struct ah)), - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + " for packet in SA %s/%08lx\n", __func__, hl, + (u_long) (authsize + rplen - sizeof (struct ah)), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); AHSTAT_INC(ahs_badauthl); m_freem(m); return EACCES; @@ -638,27 +651,9 @@ ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) crda->crd_klen = _KEYBITS(sav->key_auth); crda->crd_key = sav->key_auth->key_data; - /* Find out if we've already done crypto. */ - for (mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_CRYPTO_DONE, NULL); - mtag != NULL; - mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_CRYPTO_DONE, mtag)) { - tdbi = (struct tdb_ident *) (mtag + 1); - if (tdbi->proto == sav->sah->saidx.proto && - tdbi->spi == sav->spi && - !bcmp(&tdbi->dst, &sav->sah->saidx.dst, - sizeof (union sockaddr_union))) - break; - } - /* Allocate IPsec-specific opaque crypto info. */ - if (mtag == NULL) { - tc = (struct tdb_crypto *) malloc(sizeof (struct tdb_crypto) + - skip + rplen + authsize, M_XDATA, M_NOWAIT|M_ZERO); - } else { - /* Hash verification has already been done successfully. */ - tc = (struct tdb_crypto *) malloc(sizeof (struct tdb_crypto), - M_XDATA, M_NOWAIT|M_ZERO); - } + tc = (struct tdb_crypto *) malloc(sizeof (struct tdb_crypto) + + skip + rplen + authsize, M_XDATA, M_NOWAIT | M_ZERO); if (tc == NULL) { DPRINTF(("%s: failed to allocate tdb_crypto\n", __func__)); AHSTAT_INC(ahs_crypto); @@ -667,29 +662,24 @@ ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) return ENOBUFS; } - /* Only save information if crypto processing is needed. */ - if (mtag == NULL) { - int error; + /* + * Save the authenticator, the skipped portion of the packet, + * and the AH header. + */ + m_copydata(m, 0, skip + rplen + authsize, (caddr_t)(tc+1)); + + /* Zeroize the authenticator on the packet. */ + m_copyback(m, skip + rplen, authsize, ipseczeroes); - /* - * Save the authenticator, the skipped portion of the packet, - * and the AH header. - */ - m_copydata(m, 0, skip + rplen + authsize, (caddr_t)(tc+1)); - - /* Zeroize the authenticator on the packet. */ - m_copyback(m, skip + rplen, authsize, ipseczeroes); - - /* "Massage" the packet headers for crypto processing. */ - error = ah_massage_headers(&m, sav->sah->saidx.dst.sa.sa_family, - skip, ahx->type, 0); - if (error != 0) { - /* NB: mbuf is free'd by ah_massage_headers */ - AHSTAT_INC(ahs_hdrops); - free(tc, M_XDATA); - crypto_freereq(crp); - return error; - } + /* "Massage" the packet headers for crypto processing. */ + error = ah_massage_headers(&m, sav->sah->saidx.dst.sa.sa_family, + skip, ahx->type, 0); + if (error != 0) { + /* NB: mbuf is free'd by ah_massage_headers */ + AHSTAT_INC(ahs_hdrops); + free(tc, M_XDATA); + crypto_freereq(crp); + return (error); } /* Crypto operation descriptor. */ @@ -707,14 +697,9 @@ ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) tc->tc_nxt = ah->ah_nxt; tc->tc_protoff = protoff; tc->tc_skip = skip; - tc->tc_ptr = (caddr_t) mtag; /* Save the mtag we've identified. */ KEY_ADDREFSA(sav); tc->tc_sav = sav; - - if (mtag == NULL) - return crypto_dispatch(crp); - else - return ah_input_cb(crp); + return (crypto_dispatch(crp)); } /* @@ -723,13 +708,13 @@ ah_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) static int ah_input_cb(struct cryptop *crp) { + char buf[INET6_ADDRSTRLEN]; int rplen, error, skip, protoff; unsigned char calc[AH_ALEN_MAX]; struct mbuf *m; struct cryptodesc *crd; struct auth_hash *ahx; struct tdb_crypto *tc; - struct m_tag *mtag; struct secasvar *sav; struct secasindex *saidx; u_int8_t nxt; @@ -743,7 +728,6 @@ ah_input_cb(struct cryptop *crp) skip = tc->tc_skip; nxt = tc->tc_nxt; protoff = tc->tc_protoff; - mtag = (struct m_tag *) tc->tc_ptr; m = (struct mbuf *) crp->crp_buf; sav = tc->tc_sav; @@ -789,34 +773,22 @@ ah_input_cb(struct cryptop *crp) /* Copy authenticator off the packet. */ m_copydata(m, skip + rplen, authsize, calc); - /* - * If we have an mtag, we don't need to verify the authenticator -- - * it has been verified by an IPsec-aware NIC. - */ - if (mtag == NULL) { - ptr = (caddr_t) (tc + 1); - - /* Verify authenticator. */ - if (bcmp(ptr + skip + rplen, calc, authsize)) { - DPRINTF(("%s: authentication hash mismatch for packet " - "in SA %s/%08lx\n", __func__, - ipsec_address(&saidx->dst), - (u_long) ntohl(sav->spi))); - AHSTAT_INC(ahs_badauth); - error = EACCES; - goto bad; - } - - /* Fix the Next Protocol field. */ - ((u_int8_t *) ptr)[protoff] = nxt; - - /* Copyback the saved (uncooked) network headers. */ - m_copyback(m, 0, skip, ptr); - } else { - /* Fix the Next Protocol field. */ - m_copyback(m, protoff, sizeof(u_int8_t), &nxt); + /* Verify authenticator. */ + ptr = (caddr_t) (tc + 1); + if (timingsafe_bcmp(ptr + skip + rplen, calc, authsize)) { + DPRINTF(("%s: authentication hash mismatch for packet " + "in SA %s/%08lx\n", __func__, + ipsec_address(&saidx->dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); + AHSTAT_INC(ahs_badauth); + error = EACCES; + goto bad; } + /* Fix the Next Protocol field. */ + ((u_int8_t *) ptr)[protoff] = nxt; + /* Copyback the saved (uncooked) network headers. */ + m_copyback(m, 0, skip, ptr); free(tc, M_XDATA), tc = NULL; /* No longer needed */ /* @@ -845,8 +817,8 @@ ah_input_cb(struct cryptop *crp) error = m_striphdr(m, skip, rplen + authsize); if (error) { DPRINTF(("%s: mangled mbuf chain for SA %s/%08lx\n", __func__, - ipsec_address(&saidx->dst), (u_long) ntohl(sav->spi))); - + ipsec_address(&saidx->dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); AHSTAT_INC(ahs_hdrops); goto bad; } @@ -854,12 +826,12 @@ ah_input_cb(struct cryptop *crp) switch (saidx->dst.sa.sa_family) { #ifdef INET6 case AF_INET6: - error = ipsec6_common_input_cb(m, sav, skip, protoff, mtag); + error = ipsec6_common_input_cb(m, sav, skip, protoff); break; #endif #ifdef INET case AF_INET: - error = ipsec4_common_input_cb(m, sav, skip, protoff, mtag); + error = ipsec4_common_input_cb(m, sav, skip, protoff); break; #endif default: @@ -885,13 +857,10 @@ bad: * AH output routine, called by ipsec[46]_process_packet(). */ static int -ah_output( - struct mbuf *m, - struct ipsecrequest *isr, - struct mbuf **mp, - int skip, - int protoff) +ah_output(struct mbuf *m, struct ipsecrequest *isr, struct mbuf **mp, + int skip, int protoff) { + char buf[INET6_ADDRSTRLEN]; struct secasvar *sav; struct auth_hash *ahx; struct cryptodesc *crda; @@ -929,7 +898,7 @@ ah_output( DPRINTF(("%s: unknown/unsupported protocol family %u, " "SA %s/%08lx\n", __func__, sav->sah->saidx.dst.sa.sa_family, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi))); AHSTAT_INC(ahs_nopf); error = EPFNOSUPPORT; @@ -939,7 +908,7 @@ ah_output( if (rplen + authsize + m->m_pkthdr.len > maxpacketsize) { DPRINTF(("%s: packet in SA %s/%08lx got too big " "(len %u, max len %u)\n", __func__, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi), rplen + authsize + m->m_pkthdr.len, maxpacketsize)); AHSTAT_INC(ahs_toobig); @@ -953,7 +922,7 @@ ah_output( m = m_unshare(m, M_NOWAIT); if (m == NULL) { DPRINTF(("%s: cannot clone mbuf chain, SA %s/%08lx\n", __func__, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi))); AHSTAT_INC(ahs_hdrops); error = ENOBUFS; @@ -966,7 +935,7 @@ ah_output( DPRINTF(("%s: failed to inject %u byte AH header for SA " "%s/%08lx\n", __func__, rplen + authsize, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi))); AHSTAT_INC(ahs_hdrops); /*XXX differs from openbsd */ error = ENOBUFS; @@ -993,9 +962,8 @@ ah_output( if (sav->replay->count == ~0 && (sav->flags & SADB_X_EXT_CYCSEQ) == 0) { DPRINTF(("%s: replay counter wrapped for SA %s/%08lx\n", - __func__, - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + __func__, ipsec_address(&sav->sah->saidx.dst, buf, + sizeof(buf)), (u_long) ntohl(sav->spi))); AHSTAT_INC(ahs_wrap); error = EINVAL; goto bad; @@ -1135,6 +1103,7 @@ ah_output_cb(struct cryptop *crp) m = (struct mbuf *) crp->crp_buf; isr = tc->tc_isr; + IPSEC_ASSERT(isr->sp != NULL, ("NULL isr->sp")); IPSECREQUEST_LOCK(isr); sav = tc->tc_sav; /* With the isr lock released SA pointer can be updated. */ @@ -1198,16 +1167,18 @@ ah_output_cb(struct cryptop *crp) error = ipsec_process_done(m, isr); KEY_FREESAV(&sav); IPSECREQUEST_UNLOCK(isr); - return error; + KEY_FREESP(&isr->sp); + return (error); bad: if (sav) KEY_FREESAV(&sav); IPSECREQUEST_UNLOCK(isr); + KEY_FREESP(&isr->sp); if (m) m_freem(m); free(tc, M_XDATA); crypto_freereq(crp); - return error; + return (error); } static struct xformsw ah_xformsw = { diff --git a/sys/netipsec/xform_esp.c b/sys/netipsec/xform_esp.c index 90f6d56..f1c1eaf 100644 --- a/sys/netipsec/xform_esp.c +++ b/sys/netipsec/xform_esp.c @@ -46,6 +46,9 @@ #include <sys/kernel.h> #include <sys/random.h> #include <sys/sysctl.h> +#include <sys/lock.h> +#include <sys/mutex.h> +#include <machine/atomic.h> #include <net/if.h> #include <net/vnet.h> @@ -113,12 +116,16 @@ esp_algorithm_lookup(int alg) return &enc_xform_blf; case SADB_X_EALG_CAST128CBC: return &enc_xform_cast5; - case SADB_X_EALG_SKIPJACK: - return &enc_xform_skipjack; case SADB_EALG_NULL: return &enc_xform_null; case SADB_X_EALG_CAMELLIACBC: return &enc_xform_camellia; + case SADB_X_EALG_AESCTR: + return &enc_xform_aes_icm; + case SADB_X_EALG_AESGCM16: + return &enc_xform_aes_nist_gcm; + case SADB_X_EALG_AESGMAC: + return &enc_xform_aes_nist_gmac; } return NULL; } @@ -176,12 +183,14 @@ esp_init(struct secasvar *sav, struct xformsw *xsp) __func__, txform->name)); return EINVAL; } - if ((sav->flags&(SADB_X_EXT_OLD|SADB_X_EXT_IV4B)) == SADB_X_EXT_IV4B) { + if ((sav->flags & (SADB_X_EXT_OLD | SADB_X_EXT_IV4B)) == + SADB_X_EXT_IV4B) { DPRINTF(("%s: 4-byte IV not supported with protocol\n", __func__)); return EINVAL; } - keylen = _KEYLEN(sav->key_enc); + /* subtract off the salt, RFC4106, 8.1 and RFC3686, 5.1 */ + keylen = _KEYLEN(sav->key_enc) - SAV_ISCTRORGCM(sav) * 4; if (txform->minkey > keylen || keylen > txform->maxkey) { DPRINTF(("%s: invalid key length %u, must be in the range " "[%u..%u] for algorithm %s\n", __func__, @@ -196,9 +205,10 @@ esp_init(struct secasvar *sav, struct xformsw *xsp) * the ESP header will be processed incorrectly. The * compromise is to force it to zero here. */ - sav->ivlen = (txform == &enc_xform_null ? 0 : txform->blocksize); - sav->iv = (caddr_t) malloc(sav->ivlen, M_XDATA, M_WAITOK); - key_randomfill(sav->iv, sav->ivlen); /*XXX*/ + if (SAV_ISCTRORGCM(sav)) + sav->ivlen = 8; /* RFC4106 3.1 and RFC3686 3.1 */ + else + sav->ivlen = (txform == &enc_xform_null ? 0 : txform->ivsize); /* * Setup AH-related state. @@ -213,12 +223,42 @@ esp_init(struct secasvar *sav, struct xformsw *xsp) sav->tdb_xform = xsp; sav->tdb_encalgxform = txform; + /* + * Whenever AES-GCM is used for encryption, one + * of the AES authentication algorithms is chosen + * as well, based on the key size. + */ + if (sav->alg_enc == SADB_X_EALG_AESGCM16) { + switch (keylen) { + case AES_128_GMAC_KEY_LEN: + sav->alg_auth = SADB_X_AALG_AES128GMAC; + sav->tdb_authalgxform = &auth_hash_nist_gmac_aes_128; + break; + case AES_192_GMAC_KEY_LEN: + sav->alg_auth = SADB_X_AALG_AES192GMAC; + sav->tdb_authalgxform = &auth_hash_nist_gmac_aes_192; + break; + case AES_256_GMAC_KEY_LEN: + sav->alg_auth = SADB_X_AALG_AES256GMAC; + sav->tdb_authalgxform = &auth_hash_nist_gmac_aes_256; + break; + default: + DPRINTF(("%s: invalid key length %u" + "for algorithm %s\n", __func__, + keylen, txform->name)); + return EINVAL; + } + bzero(&cria, sizeof(cria)); + cria.cri_alg = sav->tdb_authalgxform->type; + cria.cri_key = sav->key_enc->key_data; + cria.cri_klen = _KEYBITS(sav->key_enc) - SAV_ISGCM(sav) * 32; + } + /* Initialize crypto session. */ - bzero(&crie, sizeof (crie)); + bzero(&crie, sizeof(crie)); crie.cri_alg = sav->tdb_encalgxform->type; - crie.cri_klen = _KEYBITS(sav->key_enc); crie.cri_key = sav->key_enc->key_data; - /* XXX Rounds ? */ + crie.cri_klen = _KEYBITS(sav->key_enc) - SAV_ISCTRORGCM(sav) * 32; if (sav->tdb_authalgxform && sav->tdb_encalgxform) { /* init both auth & enc */ @@ -251,10 +291,6 @@ esp_zeroize(struct secasvar *sav) if (sav->key_enc) bzero(sav->key_enc->key_data, _KEYLEN(sav->key_enc)); - if (sav->iv) { - free(sav->iv, M_XDATA); - sav->iv = NULL; - } sav->tdb_encalgxform = NULL; sav->tdb_xform = NULL; return error; @@ -266,14 +302,13 @@ esp_zeroize(struct secasvar *sav) static int esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) { + char buf[128]; struct auth_hash *esph; struct enc_xform *espx; - struct tdb_ident *tdbi; struct tdb_crypto *tc; + uint8_t *ivp; int plen, alen, hlen; - struct m_tag *mtag; struct newesp *esp; - struct cryptodesc *crde; struct cryptop *crp; @@ -288,32 +323,19 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) m_freem(m); return EINVAL; } - /* XXX don't pullup, just copy header */ IP6_EXTHDR_GET(esp, struct newesp *, m, skip, sizeof (struct newesp)); esph = sav->tdb_authalgxform; espx = sav->tdb_encalgxform; - /* Determine the ESP header length */ + /* Determine the ESP header and auth length */ if (sav->flags & SADB_X_EXT_OLD) hlen = sizeof (struct esp) + sav->ivlen; else hlen = sizeof (struct newesp) + sav->ivlen; - /* Authenticator hash size */ - if (esph != NULL) { - switch (esph->type) { - case CRYPTO_SHA2_256_HMAC: - case CRYPTO_SHA2_384_HMAC: - case CRYPTO_SHA2_512_HMAC: - alen = esph->hashsize/2; - break; - default: - alen = AH_HMAC_HASHLEN; - break; - } - }else - alen = 0; + + alen = xform_ah_authsize(esph); /* * Verify payload length is multiple of encryption algorithm @@ -326,10 +348,9 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) plen = m->m_pkthdr.len - (skip + hlen + alen); if ((plen & (espx->blocksize - 1)) || (plen <= 0)) { DPRINTF(("%s: payload of %d octets not a multiple of %d octets," - " SA %s/%08lx\n", __func__, - plen, espx->blocksize, - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + " SA %s/%08lx\n", __func__, plen, espx->blocksize, + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), + (u_long)ntohl(sav->spi))); ESPSTAT_INC(esps_badilen); m_freem(m); return EINVAL; @@ -338,9 +359,10 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) /* * Check sequence number. */ - if (esph && sav->replay && !ipsec_chkreplay(ntohl(esp->esp_seq), sav)) { + if (esph != NULL && sav->replay != NULL && + !ipsec_chkreplay(ntohl(esp->esp_seq), sav)) { DPRINTF(("%s: packet replay check for %s\n", __func__, - ipsec_logsastr(sav))); /*XXX*/ + ipsec_logsastr(sav, buf, sizeof(buf)))); /*XXX*/ ESPSTAT_INC(esps_replay); m_freem(m); return ENOBUFS; /*XXX*/ @@ -349,18 +371,6 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) /* Update the counters */ ESPSTAT_ADD(esps_ibytes, m->m_pkthdr.len - (skip + hlen + alen)); - /* Find out if we've already done crypto */ - for (mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_CRYPTO_DONE, NULL); - mtag != NULL; - mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_CRYPTO_DONE, mtag)) { - tdbi = (struct tdb_ident *) (mtag + 1); - if (tdbi->proto == sav->sah->saidx.proto && - tdbi->spi == sav->spi && - !bcmp(&tdbi->dst, &sav->sah->saidx.dst, - sizeof(union sockaddr_union))) - break; - } - /* Get crypto descriptors */ crp = crypto_getreq(esph && espx ? 2 : 1); if (crp == NULL) { @@ -372,12 +382,8 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) } /* Get IPsec-specific opaque pointer */ - if (esph == NULL || mtag != NULL) - tc = (struct tdb_crypto *) malloc(sizeof(struct tdb_crypto), - M_XDATA, M_NOWAIT|M_ZERO); - else - tc = (struct tdb_crypto *) malloc(sizeof(struct tdb_crypto) + alen, - M_XDATA, M_NOWAIT|M_ZERO); + tc = (struct tdb_crypto *) malloc(sizeof(struct tdb_crypto) + alen, + M_XDATA, M_NOWAIT | M_ZERO); if (tc == NULL) { crypto_freereq(crp); DPRINTF(("%s: failed to allocate tdb_crypto\n", __func__)); @@ -386,26 +392,24 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) return ENOBUFS; } - tc->tc_ptr = (caddr_t) mtag; - - if (esph) { + if (esph != NULL) { struct cryptodesc *crda = crp->crp_desc; IPSEC_ASSERT(crda != NULL, ("null ah crypto descriptor")); /* Authentication descriptor */ crda->crd_skip = skip; - crda->crd_len = m->m_pkthdr.len - (skip + alen); + if (SAV_ISGCM(sav)) + crda->crd_len = 8; /* RFC4106 5, SPI + SN */ + else + crda->crd_len = m->m_pkthdr.len - (skip + alen); crda->crd_inject = m->m_pkthdr.len - alen; crda->crd_alg = esph->type; - crda->crd_key = sav->key_auth->key_data; - crda->crd_klen = _KEYBITS(sav->key_auth); /* Copy the authenticator */ - if (mtag == NULL) - m_copydata(m, m->m_pkthdr.len - alen, alen, - (caddr_t) (tc + 1)); + m_copydata(m, m->m_pkthdr.len - alen, alen, + (caddr_t) (tc + 1)); /* Chain authentication request */ crde = crda->crd_next; @@ -431,22 +435,33 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) tc->tc_sav = sav; /* Decryption descriptor */ - if (espx) { - IPSEC_ASSERT(crde != NULL, ("null esp crypto descriptor")); - crde->crd_skip = skip + hlen; - crde->crd_len = m->m_pkthdr.len - (skip + hlen + alen); - crde->crd_inject = skip + hlen - sav->ivlen; - - crde->crd_alg = espx->type; - crde->crd_key = sav->key_enc->key_data; - crde->crd_klen = _KEYBITS(sav->key_enc); - /* XXX Rounds ? */ + IPSEC_ASSERT(crde != NULL, ("null esp crypto descriptor")); + crde->crd_skip = skip + hlen; + crde->crd_len = m->m_pkthdr.len - (skip + hlen + alen); + crde->crd_inject = skip + hlen - sav->ivlen; + + if (SAV_ISCTRORGCM(sav)) { + ivp = &crde->crd_iv[0]; + + /* GCM IV Format: RFC4106 4 */ + /* CTR IV Format: RFC3686 4 */ + /* Salt is last four bytes of key, RFC4106 8.1 */ + /* Nonce is last four bytes of key, RFC3686 5.1 */ + memcpy(ivp, sav->key_enc->key_data + + _KEYLEN(sav->key_enc) - 4, 4); + + if (SAV_ISCTR(sav)) { + /* Initial block counter is 1, RFC3686 4 */ + be32enc(&ivp[sav->ivlen + 4], 1); + } + + m_copydata(m, skip + hlen - sav->ivlen, sav->ivlen, &ivp[4]); + crde->crd_flags |= CRD_F_IV_EXPLICIT; } - if (mtag == NULL) - return crypto_dispatch(crp); - else - return esp_input_cb(crp); + crde->crd_alg = espx->type; + + return (crypto_dispatch(crp)); } /* @@ -455,6 +470,7 @@ esp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) static int esp_input_cb(struct cryptop *crp) { + char buf[128]; u_int8_t lastthree[3], aalg[AH_HMAC_MAXHASHLEN]; int hlen, skip, protoff, error, alen; struct mbuf *m; @@ -462,7 +478,6 @@ esp_input_cb(struct cryptop *crp) struct auth_hash *esph; struct enc_xform *espx; struct tdb_crypto *tc; - struct m_tag *mtag; struct secasvar *sav; struct secasindex *saidx; caddr_t ptr; @@ -474,7 +489,6 @@ esp_input_cb(struct cryptop *crp) IPSEC_ASSERT(tc != NULL, ("null opaque crypto data area!")); skip = tc->tc_skip; protoff = tc->tc_protoff; - mtag = (struct m_tag *) tc->tc_ptr; m = (struct mbuf *) crp->crp_buf; sav = tc->tc_sav; @@ -514,40 +528,21 @@ esp_input_cb(struct cryptop *crp) /* If authentication was performed, check now. */ if (esph != NULL) { - switch (esph->type) { - case CRYPTO_SHA2_256_HMAC: - case CRYPTO_SHA2_384_HMAC: - case CRYPTO_SHA2_512_HMAC: - alen = esph->hashsize/2; - break; - default: - alen = AH_HMAC_HASHLEN; - break; - } - /* - * If we have a tag, it means an IPsec-aware NIC did - * the verification for us. Otherwise we need to - * check the authentication calculation. - */ + alen = xform_ah_authsize(esph); AHSTAT_INC(ahs_hist[sav->alg_auth]); - if (mtag == NULL) { - /* Copy the authenticator from the packet */ - m_copydata(m, m->m_pkthdr.len - alen, - alen, aalg); - - ptr = (caddr_t) (tc + 1); - - /* Verify authenticator */ - if (bcmp(ptr, aalg, alen) != 0) { - DPRINTF(("%s: " - "authentication hash mismatch for packet in SA %s/%08lx\n", - __func__, - ipsec_address(&saidx->dst), - (u_long) ntohl(sav->spi))); - ESPSTAT_INC(esps_badauth); - error = EACCES; - goto bad; - } + /* Copy the authenticator from the packet */ + m_copydata(m, m->m_pkthdr.len - alen, alen, aalg); + ptr = (caddr_t) (tc + 1); + + /* Verify authenticator */ + if (timingsafe_bcmp(ptr, aalg, alen) != 0) { + DPRINTF(("%s: authentication hash mismatch for " + "packet in SA %s/%08lx\n", __func__, + ipsec_address(&saidx->dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); + ESPSTAT_INC(esps_badauth); + error = EACCES; + goto bad; } /* Remove trailing authenticator */ @@ -573,7 +568,7 @@ esp_input_cb(struct cryptop *crp) sizeof (seq), (caddr_t) &seq); if (ipsec_updatereplay(ntohl(seq), sav)) { DPRINTF(("%s: packet replay check for %s\n", __func__, - ipsec_logsastr(sav))); + ipsec_logsastr(sav, buf, sizeof(buf)))); ESPSTAT_INC(esps_replay); error = ENOBUFS; goto bad; @@ -591,7 +586,7 @@ esp_input_cb(struct cryptop *crp) if (error) { ESPSTAT_INC(esps_hdrops); DPRINTF(("%s: bad mbuf chain, SA %s/%08lx\n", __func__, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi))); goto bad; } @@ -603,10 +598,10 @@ esp_input_cb(struct cryptop *crp) if (lastthree[1] + 2 > m->m_pkthdr.len - skip) { ESPSTAT_INC(esps_badilen); DPRINTF(("%s: invalid padding length %d for %u byte packet " - "in SA %s/%08lx\n", __func__, - lastthree[1], m->m_pkthdr.len - skip, - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + "in SA %s/%08lx\n", __func__, lastthree[1], + m->m_pkthdr.len - skip, + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); error = EINVAL; goto bad; } @@ -616,9 +611,9 @@ esp_input_cb(struct cryptop *crp) if (lastthree[1] != lastthree[0] && lastthree[1] != 0) { ESPSTAT_INC(esps_badenc); DPRINTF(("%s: decryption failed for packet in " - "SA %s/%08lx\n", __func__, - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + "SA %s/%08lx\n", __func__, ipsec_address( + &sav->sah->saidx.dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); error = EINVAL; goto bad; } @@ -633,12 +628,12 @@ esp_input_cb(struct cryptop *crp) switch (saidx->dst.sa.sa_family) { #ifdef INET6 case AF_INET6: - error = ipsec6_common_input_cb(m, sav, skip, protoff, mtag); + error = ipsec6_common_input_cb(m, sav, skip, protoff); break; #endif #ifdef INET case AF_INET: - error = ipsec4_common_input_cb(m, sav, skip, protoff, mtag); + error = ipsec4_common_input_cb(m, sav, skip, protoff); break; #endif default: @@ -664,16 +659,14 @@ bad: * ESP output routine, called by ipsec[46]_process_packet(). */ static int -esp_output( - struct mbuf *m, - struct ipsecrequest *isr, - struct mbuf **mp, - int skip, - int protoff -) +esp_output(struct mbuf *m, struct ipsecrequest *isr, struct mbuf **mp, + int skip, int protoff) { + char buf[INET6_ADDRSTRLEN]; struct enc_xform *espx; struct auth_hash *esph; + uint8_t *ivp; + uint64_t cntr; int hlen, rlen, padding, blks, alen, i, roff; struct mbuf *mo = (struct mbuf *) NULL; struct tdb_crypto *tc; @@ -699,27 +692,14 @@ esp_output( rlen = m->m_pkthdr.len - skip; /* Raw payload length. */ /* - * NB: The null encoding transform has a blocksize of 4 - * so that headers are properly aligned. + * RFC4303 2.4 Requires 4 byte alignment. */ - blks = espx->blocksize; /* IV blocksize */ + blks = MAX(4, espx->blocksize); /* Cipher blocksize */ /* XXX clamp padding length a la KAME??? */ padding = ((blks - ((rlen + 2) % blks)) % blks) + 2; - if (esph) - switch (esph->type) { - case CRYPTO_SHA2_256_HMAC: - case CRYPTO_SHA2_384_HMAC: - case CRYPTO_SHA2_512_HMAC: - alen = esph->hashsize/2; - break; - default: - alen = AH_HMAC_HASHLEN; - break; - } - else - alen = 0; + alen = xform_ah_authsize(esph); ESPSTAT_INC(esps_output); @@ -739,16 +719,19 @@ esp_output( default: DPRINTF(("%s: unknown/unsupported protocol " "family %d, SA %s/%08lx\n", __func__, - saidx->dst.sa.sa_family, ipsec_address(&saidx->dst), - (u_long) ntohl(sav->spi))); + saidx->dst.sa.sa_family, ipsec_address(&saidx->dst, + buf, sizeof(buf)), (u_long) ntohl(sav->spi))); ESPSTAT_INC(esps_nopf); error = EPFNOSUPPORT; goto bad; } + DPRINTF(("%s: skip %d hlen %d rlen %d padding %d alen %d blksd %d\n", + __func__, skip, hlen, rlen, padding, alen, blks)); if (skip + hlen + rlen + padding + alen > maxpacketsize) { DPRINTF(("%s: packet in SA %s/%08lx got too big " "(len %u, max len %u)\n", __func__, - ipsec_address(&saidx->dst), (u_long) ntohl(sav->spi), + ipsec_address(&saidx->dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi), skip + hlen + rlen + padding + alen, maxpacketsize)); ESPSTAT_INC(esps_toobig); error = EMSGSIZE; @@ -761,7 +744,8 @@ esp_output( m = m_unshare(m, M_NOWAIT); if (m == NULL) { DPRINTF(("%s: cannot clone mbuf chain, SA %s/%08lx\n", __func__, - ipsec_address(&saidx->dst), (u_long) ntohl(sav->spi))); + ipsec_address(&saidx->dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); ESPSTAT_INC(esps_hdrops); error = ENOBUFS; goto bad; @@ -771,8 +755,8 @@ esp_output( mo = m_makespace(m, skip, hlen, &roff); if (mo == NULL) { DPRINTF(("%s: %u byte ESP hdr inject failed for SA %s/%08lx\n", - __func__, hlen, ipsec_address(&saidx->dst), - (u_long) ntohl(sav->spi))); + __func__, hlen, ipsec_address(&saidx->dst, buf, + sizeof(buf)), (u_long) ntohl(sav->spi))); ESPSTAT_INC(esps_hdrops); /* XXX diffs from openbsd */ error = ENOBUFS; goto bad; @@ -801,7 +785,8 @@ esp_output( pad = (u_char *) m_pad(m, padding + alen); if (pad == NULL) { DPRINTF(("%s: m_pad failed for SA %s/%08lx\n", __func__, - ipsec_address(&saidx->dst), (u_long) ntohl(sav->spi))); + ipsec_address(&saidx->dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); m = NULL; /* NB: free'd by m_pad */ error = ENOBUFS; goto bad; @@ -833,7 +818,7 @@ esp_output( m_copyback(m, protoff, sizeof(u_int8_t), (u_char *) &prot); /* Get crypto descriptors. */ - crp = crypto_getreq(esph && espx ? 2 : 1); + crp = crypto_getreq(esph != NULL ? 2 : 1); if (crp == NULL) { DPRINTF(("%s: failed to acquire crypto descriptors\n", __func__)); @@ -842,27 +827,9 @@ esp_output( goto bad; } - if (espx) { - crde = crp->crp_desc; - crda = crde->crd_next; - - /* Encryption descriptor. */ - crde->crd_skip = skip + hlen; - crde->crd_len = m->m_pkthdr.len - (skip + hlen + alen); - crde->crd_flags = CRD_F_ENCRYPT; - crde->crd_inject = skip + hlen - sav->ivlen; - - /* Encryption operation. */ - crde->crd_alg = espx->type; - crde->crd_key = sav->key_enc->key_data; - crde->crd_klen = _KEYBITS(sav->key_enc); - /* XXX Rounds ? */ - } else - crda = crp->crp_desc; - /* IPsec-specific opaque crypto info. */ tc = (struct tdb_crypto *) malloc(sizeof(struct tdb_crypto), - M_XDATA, M_NOWAIT|M_ZERO); + M_XDATA, M_NOWAIT|M_ZERO); if (tc == NULL) { crypto_freereq(crp); DPRINTF(("%s: failed to allocate tdb_crypto\n", __func__)); @@ -871,6 +838,40 @@ esp_output( goto bad; } + crde = crp->crp_desc; + crda = crde->crd_next; + + /* Encryption descriptor. */ + crde->crd_skip = skip + hlen; + crde->crd_len = m->m_pkthdr.len - (skip + hlen + alen); + crde->crd_flags = CRD_F_ENCRYPT; + crde->crd_inject = skip + hlen - sav->ivlen; + + /* Encryption operation. */ + crde->crd_alg = espx->type; + if (SAV_ISCTRORGCM(sav)) { + ivp = &crde->crd_iv[0]; + + /* GCM IV Format: RFC4106 4 */ + /* CTR IV Format: RFC3686 4 */ + /* Salt is last four bytes of key, RFC4106 8.1 */ + /* Nonce is last four bytes of key, RFC3686 5.1 */ + memcpy(ivp, sav->key_enc->key_data + + _KEYLEN(sav->key_enc) - 4, 4); + SECASVAR_LOCK(sav); + cntr = sav->cntr++; + SECASVAR_UNLOCK(sav); + be64enc(&ivp[4], cntr); + + if (SAV_ISCTR(sav)) { + /* Initial block counter is 1, RFC3686 4 */ + be32enc(&ivp[sav->ivlen + 4], 1); + } + + m_copyback(m, skip + hlen - sav->ivlen, sav->ivlen, &ivp[4]); + crde->crd_flags |= CRD_F_IV_EXPLICIT|CRD_F_IV_PRESENT; + } + /* Callback parameters */ tc->tc_isr = isr; KEY_ADDREFSA(sav); @@ -889,14 +890,13 @@ esp_output( if (esph) { /* Authentication descriptor. */ + crda->crd_alg = esph->type; crda->crd_skip = skip; - crda->crd_len = m->m_pkthdr.len - (skip + alen); + if (SAV_ISGCM(sav)) + crda->crd_len = 8; /* RFC4106 5, SPI + SN */ + else + crda->crd_len = m->m_pkthdr.len - (skip + alen); crda->crd_inject = m->m_pkthdr.len - alen; - - /* Authentication operation. */ - crda->crd_alg = esph->type; - crda->crd_key = sav->key_auth->key_data; - crda->crd_klen = _KEYBITS(sav->key_auth); } return crypto_dispatch(crp); @@ -912,6 +912,7 @@ bad: static int esp_output_cb(struct cryptop *crp) { + char buf[INET6_ADDRSTRLEN]; struct tdb_crypto *tc; struct ipsecrequest *isr; struct secasvar *sav; @@ -923,13 +924,15 @@ esp_output_cb(struct cryptop *crp) m = (struct mbuf *) crp->crp_buf; isr = tc->tc_isr; + IPSEC_ASSERT(isr->sp != NULL, ("NULL isr->sp")); IPSECREQUEST_LOCK(isr); sav = tc->tc_sav; - /* With the isr lock released SA pointer can be updated. */ + + /* With the isr lock released, SA pointer may have changed. */ if (sav != isr->sav) { ESPSTAT_INC(esps_notdb); DPRINTF(("%s: SA gone during crypto (SA %s/%08lx proto %u)\n", - __func__, ipsec_address(&tc->tc_dst), + __func__, ipsec_address(&tc->tc_dst, buf, sizeof(buf)), (u_long) ntohl(tc->tc_spi), tc->tc_proto)); error = ENOBUFS; /*XXX*/ goto bad; @@ -981,16 +984,7 @@ esp_output_cb(struct cryptop *crp) if (esph != NULL) { int alen; - switch (esph->type) { - case CRYPTO_SHA2_256_HMAC: - case CRYPTO_SHA2_384_HMAC: - case CRYPTO_SHA2_512_HMAC: - alen = esph->hashsize/2; - break; - default: - alen = AH_HMAC_HASHLEN; - break; - } + alen = xform_ah_authsize(esph); m_copyback(m, m->m_pkthdr.len - alen, alen, ipseczeroes); } @@ -1001,16 +995,18 @@ esp_output_cb(struct cryptop *crp) error = ipsec_process_done(m, isr); KEY_FREESAV(&sav); IPSECREQUEST_UNLOCK(isr); - return error; + KEY_FREESP(&isr->sp); + return (error); bad: if (sav) KEY_FREESAV(&sav); IPSECREQUEST_UNLOCK(isr); + KEY_FREESP(&isr->sp); if (m) m_freem(m); free(tc, M_XDATA); crypto_freereq(crp); - return error; + return (error); } static struct xformsw esp_xformsw = { diff --git a/sys/netipsec/xform_ipcomp.c b/sys/netipsec/xform_ipcomp.c index 6d95250..a5d1e57 100644 --- a/sys/netipsec/xform_ipcomp.c +++ b/sys/netipsec/xform_ipcomp.c @@ -224,10 +224,10 @@ ipcomp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) static int ipcomp_input_cb(struct cryptop *crp) { + char buf[INET6_ADDRSTRLEN]; struct cryptodesc *crd; struct tdb_crypto *tc; int skip, protoff; - struct mtag *mtag; struct mbuf *m; struct secasvar *sav; struct secasindex *saidx; @@ -241,7 +241,6 @@ ipcomp_input_cb(struct cryptop *crp) IPSEC_ASSERT(tc != NULL, ("null opaque crypto data area!")); skip = tc->tc_skip; protoff = tc->tc_protoff; - mtag = (struct mtag *) tc->tc_ptr; m = (struct mbuf *) crp->crp_buf; sav = tc->tc_sav; @@ -300,8 +299,8 @@ ipcomp_input_cb(struct cryptop *crp) if (error) { IPCOMPSTAT_INC(ipcomps_hdrops); DPRINTF(("%s: bad mbuf chain, IPCA %s/%08lx\n", __func__, - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), + (u_long) ntohl(sav->spi))); goto bad; } @@ -311,12 +310,12 @@ ipcomp_input_cb(struct cryptop *crp) switch (saidx->dst.sa.sa_family) { #ifdef INET6 case AF_INET6: - error = ipsec6_common_input_cb(m, sav, skip, protoff, NULL); + error = ipsec6_common_input_cb(m, sav, skip, protoff); break; #endif #ifdef INET case AF_INET: - error = ipsec4_common_input_cb(m, sav, skip, protoff, NULL); + error = ipsec4_common_input_cb(m, sav, skip, protoff); break; #endif default: @@ -342,14 +341,10 @@ bad: * IPComp output routine, called by ipsec[46]_process_packet() */ static int -ipcomp_output( - struct mbuf *m, - struct ipsecrequest *isr, - struct mbuf **mp, - int skip, - int protoff -) +ipcomp_output(struct mbuf *m, struct ipsecrequest *isr, struct mbuf **mp, + int skip, int protoff) { + char buf[INET6_ADDRSTRLEN]; struct secasvar *sav; struct comp_algo *ipcompx; int error, ralen, maxpacketsize; @@ -393,7 +388,7 @@ ipcomp_output( DPRINTF(("%s: unknown/unsupported protocol family %d, " "IPCA %s/%08lx\n", __func__, sav->sah->saidx.dst.sa.sa_family, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi))); error = EPFNOSUPPORT; goto bad; @@ -402,7 +397,7 @@ ipcomp_output( IPCOMPSTAT_INC(ipcomps_toobig); DPRINTF(("%s: packet in IPCA %s/%08lx got too big " "(len %u, max len %u)\n", __func__, - ipsec_address(&sav->sah->saidx.dst), + ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)), (u_long) ntohl(sav->spi), ralen + skip + IPCOMP_HLENGTH, maxpacketsize)); error = EMSGSIZE; @@ -416,8 +411,8 @@ ipcomp_output( if (m == NULL) { IPCOMPSTAT_INC(ipcomps_hdrops); DPRINTF(("%s: cannot clone mbuf chain, IPCA %s/%08lx\n", - __func__, ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + __func__, ipsec_address(&sav->sah->saidx.dst, buf, + sizeof(buf)), (u_long) ntohl(sav->spi))); error = ENOBUFS; goto bad; } @@ -484,6 +479,7 @@ bad: static int ipcomp_output_cb(struct cryptop *crp) { + char buf[INET6_ADDRSTRLEN]; struct tdb_crypto *tc; struct ipsecrequest *isr; struct secasvar *sav; @@ -496,6 +492,7 @@ ipcomp_output_cb(struct cryptop *crp) skip = tc->tc_skip; isr = tc->tc_isr; + IPSEC_ASSERT(isr->sp != NULL, ("NULL isr->sp")); IPSECREQUEST_LOCK(isr); sav = tc->tc_sav; /* With the isr lock released SA pointer can be updated. */ @@ -541,8 +538,8 @@ ipcomp_output_cb(struct cryptop *crp) if (mo == NULL) { IPCOMPSTAT_INC(ipcomps_wrap); DPRINTF(("%s: IPCOMP header inject failed for IPCA %s/%08lx\n", - __func__, ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + __func__, ipsec_address(&sav->sah->saidx.dst, buf, + sizeof(buf)), (u_long) ntohl(sav->spi))); error = ENOBUFS; goto bad; } @@ -588,8 +585,8 @@ ipcomp_output_cb(struct cryptop *crp) DPRINTF(("%s: unknown/unsupported protocol " "family %d, IPCA %s/%08lx\n", __func__, sav->sah->saidx.dst.sa.sa_family, - ipsec_address(&sav->sah->saidx.dst), - (u_long) ntohl(sav->spi))); + ipsec_address(&sav->sah->saidx.dst, buf, + sizeof(buf)), (u_long) ntohl(sav->spi))); error = EPFNOSUPPORT; goto bad; } @@ -610,16 +607,18 @@ ipcomp_output_cb(struct cryptop *crp) error = ipsec_process_done(m, isr); KEY_FREESAV(&sav); IPSECREQUEST_UNLOCK(isr); - return error; + KEY_FREESP(&isr->sp); + return (error); bad: if (sav) KEY_FREESAV(&sav); IPSECREQUEST_UNLOCK(isr); + KEY_FREESP(&isr->sp); if (m) m_freem(m); free(tc, M_XDATA); crypto_freereq(crp); - return error; + return (error); } static struct xformsw ipcomp_xformsw = { diff --git a/sys/netipsec/xform_ipip.c b/sys/netipsec/xform_ipip.c deleted file mode 100644 index 9585eef..0000000 --- a/sys/netipsec/xform_ipip.c +++ /dev/null @@ -1,662 +0,0 @@ -/* $FreeBSD$ */ -/* $OpenBSD: ip_ipip.c,v 1.25 2002/06/10 18:04:55 itojun Exp $ */ -/*- - * The authors of this code are John Ioannidis (ji@tla.org), - * Angelos D. Keromytis (kermit@csd.uch.gr) and - * Niels Provos (provos@physnet.uni-hamburg.de). - * - * The original version of this code was written by John Ioannidis - * for BSD/OS in Athens, Greece, in November 1995. - * - * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, - * by Angelos D. Keromytis. - * - * Additional transforms and features in 1997 and 1998 by Angelos D. Keromytis - * and Niels Provos. - * - * Additional features in 1999 by Angelos D. Keromytis. - * - * Copyright (C) 1995, 1996, 1997, 1998, 1999 by John Ioannidis, - * Angelos D. Keromytis and Niels Provos. - * Copyright (c) 2001, Angelos D. Keromytis. - * - * Permission to use, copy, and modify this software with or without fee - * is hereby granted, provided that this entire notice is included in - * all copies of any software which is or includes a copy or - * modification of this software. - * You may use this code under the GNU public license if you so wish. Please - * contribute changes back to the authors under this freer than GPL license - * so that we may further the use of strong encryption without limitations to - * all. - * - * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY - * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE - * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR - * PURPOSE. - */ - -/* - * IP-inside-IP processing - */ -#include "opt_inet.h" -#include "opt_inet6.h" -#include "opt_enc.h" - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/mbuf.h> -#include <sys/socket.h> -#include <sys/kernel.h> -#include <sys/protosw.h> -#include <sys/sysctl.h> - -#include <net/if.h> -#include <net/pfil.h> -#include <net/netisr.h> -#include <net/vnet.h> - -#include <netinet/in.h> -#include <netinet/in_systm.h> -#include <netinet/in_var.h> -#include <netinet/ip.h> -#include <netinet/ip_ecn.h> -#include <netinet/ip_var.h> -#include <netinet/ip_encap.h> - -#include <netipsec/ipsec.h> -#include <netipsec/xform.h> - -#include <netipsec/ipip_var.h> - -#ifdef INET6 -#include <netinet/ip6.h> -#include <netipsec/ipsec6.h> -#include <netinet6/ip6_ecn.h> -#include <netinet6/in6_var.h> -#include <netinet6/ip6protosw.h> -#endif - -#include <netipsec/key.h> -#include <netipsec/key_debug.h> - -#include <machine/stdarg.h> - -/* - * We can control the acceptance of IP4 packets by altering the sysctl - * net.inet.ipip.allow value. Zero means drop them, all else is acceptance. - */ -VNET_DEFINE(int, ipip_allow) = 0; -VNET_PCPUSTAT_DEFINE(struct ipipstat, ipipstat); -VNET_PCPUSTAT_SYSINIT(ipipstat); - -#ifdef VIMAGE -VNET_PCPUSTAT_SYSUNINIT(ipipstat); -#endif /* VIMAGE */ - -SYSCTL_DECL(_net_inet_ipip); -SYSCTL_VNET_INT(_net_inet_ipip, OID_AUTO, - ipip_allow, CTLFLAG_RW, &VNET_NAME(ipip_allow), 0, ""); -SYSCTL_VNET_PCPUSTAT(_net_inet_ipip, IPSECCTL_STATS, stats, - struct ipipstat, ipipstat, - "IPIP statistics (struct ipipstat, netipsec/ipip_var.h)"); - -/* XXX IPCOMP */ -#define M_IPSEC (M_AUTHIPHDR|M_AUTHIPDGM|M_DECRYPTED) - -static void _ipip_input(struct mbuf *m, int iphlen, struct ifnet *gifp); - -#ifdef INET6 -/* - * Really only a wrapper for ipip_input(), for use with IPv6. - */ -int -ip4_input6(struct mbuf **m, int *offp, int proto) -{ -#if 0 - /* If we do not accept IP-in-IP explicitly, drop. */ - if (!V_ipip_allow && ((*m)->m_flags & M_IPSEC) == 0) { - DPRINTF(("%s: dropped due to policy\n", __func__)); - IPIPSTAT_INC(ipips_pdrops); - m_freem(*m); - return IPPROTO_DONE; - } -#endif - _ipip_input(*m, *offp, NULL); - return IPPROTO_DONE; -} -#endif /* INET6 */ - -#ifdef INET -/* - * Really only a wrapper for ipip_input(), for use with IPv4. - */ -void -ip4_input(struct mbuf *m, int off) -{ -#if 0 - /* If we do not accept IP-in-IP explicitly, drop. */ - if (!V_ipip_allow && (m->m_flags & M_IPSEC) == 0) { - DPRINTF(("%s: dropped due to policy\n", __func__)); - IPIPSTAT_INC(ipips_pdrops); - m_freem(m); - return; - } -#endif - _ipip_input(m, off, NULL); -} -#endif /* INET */ - -/* - * ipip_input gets called when we receive an IP{46} encapsulated packet, - * either because we got it at a real interface, or because AH or ESP - * were being used in tunnel mode (in which case the rcvif element will - * contain the address of the encX interface associated with the tunnel. - */ - -static void -_ipip_input(struct mbuf *m, int iphlen, struct ifnet *gifp) -{ - struct ip *ipo; -#ifdef INET6 - struct ip6_hdr *ip6 = NULL; - u_int8_t itos; -#endif - int isr; - u_int8_t otos; - u_int8_t v; - int hlen; - - IPIPSTAT_INC(ipips_ipackets); - - m_copydata(m, 0, 1, &v); - - switch (v >> 4) { -#ifdef INET - case 4: - hlen = sizeof(struct ip); - break; -#endif /* INET */ -#ifdef INET6 - case 6: - hlen = sizeof(struct ip6_hdr); - break; -#endif - default: - IPIPSTAT_INC(ipips_family); - m_freem(m); - return /* EAFNOSUPPORT */; - } - - /* Bring the IP header in the first mbuf, if not there already */ - if (m->m_len < hlen) { - if ((m = m_pullup(m, hlen)) == NULL) { - DPRINTF(("%s: m_pullup (1) failed\n", __func__)); - IPIPSTAT_INC(ipips_hdrops); - return; - } - } - ipo = mtod(m, struct ip *); - - /* Keep outer ecn field. */ - switch (v >> 4) { -#ifdef INET - case 4: - otos = ipo->ip_tos; - break; -#endif /* INET */ -#ifdef INET6 - case 6: - otos = (ntohl(mtod(m, struct ip6_hdr *)->ip6_flow) >> 20) & 0xff; - break; -#endif - default: - panic("ipip_input: unknown ip version %u (outer)", v>>4); - } - - /* Remove outer IP header */ - m_adj(m, iphlen); - - /* Sanity check */ - if (m->m_pkthdr.len < sizeof(struct ip)) { - IPIPSTAT_INC(ipips_hdrops); - m_freem(m); - return; - } - - m_copydata(m, 0, 1, &v); - - switch (v >> 4) { -#ifdef INET - case 4: - hlen = sizeof(struct ip); - break; -#endif /* INET */ - -#ifdef INET6 - case 6: - hlen = sizeof(struct ip6_hdr); - break; -#endif - default: - IPIPSTAT_INC(ipips_family); - m_freem(m); - return; /* EAFNOSUPPORT */ - } - - /* - * Bring the inner IP header in the first mbuf, if not there already. - */ - if (m->m_len < hlen) { - if ((m = m_pullup(m, hlen)) == NULL) { - DPRINTF(("%s: m_pullup (2) failed\n", __func__)); - IPIPSTAT_INC(ipips_hdrops); - return; - } - } - - /* - * RFC 1853 specifies that the inner TTL should not be touched on - * decapsulation. There's no reason this comment should be here, but - * this is as good as any a position. - */ - - /* Some sanity checks in the inner IP header */ - switch (v >> 4) { -#ifdef INET - case 4: - ipo = mtod(m, struct ip *); - ip_ecn_egress(V_ip4_ipsec_ecn, &otos, &ipo->ip_tos); - break; -#endif /* INET */ -#ifdef INET6 - case 6: - ip6 = (struct ip6_hdr *) ipo; - itos = (ntohl(ip6->ip6_flow) >> 20) & 0xff; - ip_ecn_egress(V_ip6_ipsec_ecn, &otos, &itos); - ip6->ip6_flow &= ~htonl(0xff << 20); - ip6->ip6_flow |= htonl((u_int32_t) itos << 20); - break; -#endif - default: - panic("ipip_input: unknown ip version %u (inner)", v>>4); - } - - /* Check for local address spoofing. */ - if ((m->m_pkthdr.rcvif == NULL || - !(m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK)) && - V_ipip_allow != 2) { -#ifdef INET - if ((v >> 4) == IPVERSION && - in_localip(ipo->ip_src) != 0) { - IPIPSTAT_INC(ipips_spoof); - m_freem(m); - return; - } -#endif -#ifdef INET6 - if ((v & IPV6_VERSION_MASK) == IPV6_VERSION && - in6_localip(&ip6->ip6_src) != 0) { - IPIPSTAT_INC(ipips_spoof); - m_freem(m); - return; - } -#endif - } - - /* Statistics */ - IPIPSTAT_ADD(ipips_ibytes, m->m_pkthdr.len - iphlen); - - /* - * Interface pointer stays the same; if no IPsec processing has - * been done (or will be done), this will point to a normal - * interface. Otherwise, it'll point to an enc interface, which - * will allow a packet filter to distinguish between secure and - * untrusted packets. - */ - - switch (v >> 4) { -#ifdef INET - case 4: - isr = NETISR_IP; - break; -#endif -#ifdef INET6 - case 6: - isr = NETISR_IPV6; - break; -#endif - default: - panic("%s: bogus ip version %u", __func__, v>>4); - } - - if (netisr_queue(isr, m)) { /* (0) on success. */ - IPIPSTAT_INC(ipips_qfull); - DPRINTF(("%s: packet dropped because of full queue\n", - __func__)); - } -} - -int -ipip_output( - struct mbuf *m, - struct ipsecrequest *isr, - struct mbuf **mp, - int skip, - int protoff -) -{ - struct secasvar *sav; - u_int8_t tp, otos; - struct secasindex *saidx; - int error; -#if defined(INET) || defined(INET6) - u_int8_t itos; -#endif -#ifdef INET - struct ip *ipo; -#endif /* INET */ -#ifdef INET6 - struct ip6_hdr *ip6, *ip6o; -#endif /* INET6 */ - - sav = isr->sav; - IPSEC_ASSERT(sav != NULL, ("null SA")); - IPSEC_ASSERT(sav->sah != NULL, ("null SAH")); - - /* XXX Deal with empty TDB source/destination addresses. */ - - m_copydata(m, 0, 1, &tp); - tp = (tp >> 4) & 0xff; /* Get the IP version number. */ - - saidx = &sav->sah->saidx; - switch (saidx->dst.sa.sa_family) { -#ifdef INET - case AF_INET: - if (saidx->src.sa.sa_family != AF_INET || - saidx->src.sin.sin_addr.s_addr == INADDR_ANY || - saidx->dst.sin.sin_addr.s_addr == INADDR_ANY) { - DPRINTF(("%s: unspecified tunnel endpoint " - "address in SA %s/%08lx\n", __func__, - ipsec_address(&saidx->dst), - (u_long) ntohl(sav->spi))); - IPIPSTAT_INC(ipips_unspec); - error = EINVAL; - goto bad; - } - - M_PREPEND(m, sizeof(struct ip), M_NOWAIT); - if (m == 0) { - DPRINTF(("%s: M_PREPEND failed\n", __func__)); - IPIPSTAT_INC(ipips_hdrops); - error = ENOBUFS; - goto bad; - } - - ipo = mtod(m, struct ip *); - - ipo->ip_v = IPVERSION; - ipo->ip_hl = 5; - ipo->ip_len = htons(m->m_pkthdr.len); - ipo->ip_ttl = V_ip_defttl; - ipo->ip_sum = 0; - ipo->ip_src = saidx->src.sin.sin_addr; - ipo->ip_dst = saidx->dst.sin.sin_addr; - - ipo->ip_id = ip_newid(); - - /* If the inner protocol is IP... */ - switch (tp) { - case IPVERSION: - /* Save ECN notification */ - m_copydata(m, sizeof(struct ip) + - offsetof(struct ip, ip_tos), - sizeof(u_int8_t), (caddr_t) &itos); - - ipo->ip_p = IPPROTO_IPIP; - - /* - * We should be keeping tunnel soft-state and - * send back ICMPs if needed. - */ - m_copydata(m, sizeof(struct ip) + - offsetof(struct ip, ip_off), - sizeof(u_int16_t), (caddr_t) &ipo->ip_off); - ipo->ip_off = ntohs(ipo->ip_off); - ipo->ip_off &= ~(IP_DF | IP_MF | IP_OFFMASK); - ipo->ip_off = htons(ipo->ip_off); - break; -#ifdef INET6 - case (IPV6_VERSION >> 4): - { - u_int32_t itos32; - - /* Save ECN notification. */ - m_copydata(m, sizeof(struct ip) + - offsetof(struct ip6_hdr, ip6_flow), - sizeof(u_int32_t), (caddr_t) &itos32); - itos = ntohl(itos32) >> 20; - ipo->ip_p = IPPROTO_IPV6; - ipo->ip_off = 0; - break; - } -#endif /* INET6 */ - default: - goto nofamily; - } - - otos = 0; - ip_ecn_ingress(ECN_ALLOWED, &otos, &itos); - ipo->ip_tos = otos; - break; -#endif /* INET */ - -#ifdef INET6 - case AF_INET6: - if (IN6_IS_ADDR_UNSPECIFIED(&saidx->dst.sin6.sin6_addr) || - saidx->src.sa.sa_family != AF_INET6 || - IN6_IS_ADDR_UNSPECIFIED(&saidx->src.sin6.sin6_addr)) { - DPRINTF(("%s: unspecified tunnel endpoint " - "address in SA %s/%08lx\n", __func__, - ipsec_address(&saidx->dst), - (u_long) ntohl(sav->spi))); - IPIPSTAT_INC(ipips_unspec); - error = ENOBUFS; - goto bad; - } - - /* scoped address handling */ - ip6 = mtod(m, struct ip6_hdr *); - if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) - ip6->ip6_src.s6_addr16[1] = 0; - if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst)) - ip6->ip6_dst.s6_addr16[1] = 0; - - M_PREPEND(m, sizeof(struct ip6_hdr), M_NOWAIT); - if (m == 0) { - DPRINTF(("%s: M_PREPEND failed\n", __func__)); - IPIPSTAT_INC(ipips_hdrops); - error = ENOBUFS; - goto bad; - } - - /* Initialize IPv6 header */ - ip6o = mtod(m, struct ip6_hdr *); - ip6o->ip6_flow = 0; - ip6o->ip6_vfc &= ~IPV6_VERSION_MASK; - ip6o->ip6_vfc |= IPV6_VERSION; - ip6o->ip6_hlim = IPV6_DEFHLIM; - ip6o->ip6_dst = saidx->dst.sin6.sin6_addr; - ip6o->ip6_src = saidx->src.sin6.sin6_addr; - ip6o->ip6_plen = htons(m->m_pkthdr.len - sizeof(*ip6)); - - switch (tp) { -#ifdef INET - case IPVERSION: - /* Save ECN notification */ - m_copydata(m, sizeof(struct ip6_hdr) + - offsetof(struct ip, ip_tos), sizeof(u_int8_t), - (caddr_t) &itos); - - /* This is really IPVERSION. */ - ip6o->ip6_nxt = IPPROTO_IPIP; - break; -#endif /* INET */ - case (IPV6_VERSION >> 4): - { - u_int32_t itos32; - - /* Save ECN notification. */ - m_copydata(m, sizeof(struct ip6_hdr) + - offsetof(struct ip6_hdr, ip6_flow), - sizeof(u_int32_t), (caddr_t) &itos32); - itos = ntohl(itos32) >> 20; - - ip6o->ip6_nxt = IPPROTO_IPV6; - break; - } - default: - goto nofamily; - } - - otos = 0; - ip_ecn_ingress(V_ip6_ipsec_ecn, &otos, &itos); - ip6o->ip6_flow |= htonl((u_int32_t) otos << 20); - break; -#endif /* INET6 */ - - default: -nofamily: - DPRINTF(("%s: unsupported protocol family %u\n", __func__, - saidx->dst.sa.sa_family)); - IPIPSTAT_INC(ipips_family); - error = EAFNOSUPPORT; /* XXX diffs from openbsd */ - goto bad; - } - - IPIPSTAT_INC(ipips_opackets); - *mp = m; - -#ifdef INET - if (saidx->dst.sa.sa_family == AF_INET) { -#if 0 - if (sav->tdb_xform->xf_type == XF_IP4) - tdb->tdb_cur_bytes += - m->m_pkthdr.len - sizeof(struct ip); -#endif - IPIPSTAT_ADD(ipips_obytes, - m->m_pkthdr.len - sizeof(struct ip)); - } -#endif /* INET */ - -#ifdef INET6 - if (saidx->dst.sa.sa_family == AF_INET6) { -#if 0 - if (sav->tdb_xform->xf_type == XF_IP4) - tdb->tdb_cur_bytes += - m->m_pkthdr.len - sizeof(struct ip6_hdr); -#endif - IPIPSTAT_ADD(ipips_obytes, - m->m_pkthdr.len - sizeof(struct ip6_hdr)); - } -#endif /* INET6 */ - - return 0; -bad: - if (m) - m_freem(m); - *mp = NULL; - return (error); -} - -#ifdef IPSEC -#if defined(INET) || defined(INET6) -static int -ipe4_init(struct secasvar *sav, struct xformsw *xsp) -{ - sav->tdb_xform = xsp; - return 0; -} - -static int -ipe4_zeroize(struct secasvar *sav) -{ - sav->tdb_xform = NULL; - return 0; -} - -static int -ipe4_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff) -{ - /* This is a rather serious mistake, so no conditional printing. */ - printf("%s: should never be called\n", __func__); - if (m) - m_freem(m); - return EOPNOTSUPP; -} - -static struct xformsw ipe4_xformsw = { - XF_IP4, 0, "IPv4 Simple Encapsulation", - ipe4_init, ipe4_zeroize, ipe4_input, ipip_output, -}; - -extern struct domain inetdomain; -#endif /* INET || INET6 */ -#ifdef INET -static struct protosw ipe4_protosw = { - .pr_type = SOCK_RAW, - .pr_domain = &inetdomain, - .pr_protocol = IPPROTO_IPV4, - .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR, - .pr_input = ip4_input, - .pr_ctloutput = rip_ctloutput, - .pr_usrreqs = &rip_usrreqs -}; -#endif /* INET */ -#if defined(INET6) && defined(INET) -static struct ip6protosw ipe6_protosw = { - .pr_type = SOCK_RAW, - .pr_domain = &inetdomain, - .pr_protocol = IPPROTO_IPV6, - .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR, - .pr_input = ip4_input6, - .pr_ctloutput = rip_ctloutput, - .pr_usrreqs = &rip_usrreqs -}; -#endif /* INET6 && INET */ - -#ifdef INET -/* - * Check the encapsulated packet to see if we want it - */ -static int -ipe4_encapcheck(const struct mbuf *m, int off, int proto, void *arg) -{ - /* - * Only take packets coming from IPSEC tunnels; the rest - * must be handled by the gif tunnel code. Note that we - * also return a minimum priority when we want the packet - * so any explicit gif tunnels take precedence. - */ - return ((m->m_flags & M_IPSEC) != 0 ? 1 : 0); -} -#endif /* INET */ - -static void -ipe4_attach(void) -{ - - xform_register(&ipe4_xformsw); - /* attach to encapsulation framework */ - /* XXX save return cookie for detach on module remove */ -#ifdef INET - (void) encap_attach_func(AF_INET, -1, - ipe4_encapcheck, &ipe4_protosw, NULL); -#endif -#if defined(INET6) && defined(INET) - (void) encap_attach_func(AF_INET6, -1, - ipe4_encapcheck, (struct protosw *)&ipe6_protosw, NULL); -#endif -} -SYSINIT(ipe4_xform_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_MIDDLE, ipe4_attach, NULL); -#endif /* IPSEC */ diff --git a/sys/netpfil/ipfw/ip_dn_io.c b/sys/netpfil/ipfw/ip_dn_io.c index 9a4b486..c842ce0 100644 --- a/sys/netpfil/ipfw/ip_dn_io.c +++ b/sys/netpfil/ipfw/ip_dn_io.c @@ -651,6 +651,7 @@ dummynet_send(struct mbuf *m) * to carry reinject info. */ dst = pkt->dn_dir; + pkt->rule.info |= IPFW_IS_DUMMYNET; ifp = pkt->ifp; tag->m_tag_cookie = MTAG_IPFW_RULE; tag->m_tag_id = 0; diff --git a/sys/netpfil/ipfw/ip_dummynet.c b/sys/netpfil/ipfw/ip_dummynet.c index 4de2156..b4b87c7 100644 --- a/sys/netpfil/ipfw/ip_dummynet.c +++ b/sys/netpfil/ipfw/ip_dummynet.c @@ -2290,7 +2290,6 @@ static moduledata_t dummynet_mod = { #define DN_SI_SUB SI_SUB_PROTO_IFATTACHDOMAIN #define DN_MODEV_ORD (SI_ORDER_ANY - 128) /* after ipfw */ DECLARE_MODULE(dummynet, dummynet_mod, DN_SI_SUB, DN_MODEV_ORD); -MODULE_DEPEND(dummynet, ipfw, 2, 2, 2); MODULE_VERSION(dummynet, 3); /* diff --git a/sys/netpfil/ipfw/ip_fw2.c b/sys/netpfil/ipfw/ip_fw2.c index 764696c..68d83f8 100644 --- a/sys/netpfil/ipfw/ip_fw2.c +++ b/sys/netpfil/ipfw/ip_fw2.c @@ -140,8 +140,7 @@ VNET_DEFINE(int, fw_verbose); VNET_DEFINE(u_int64_t, norule_counter); VNET_DEFINE(int, verbose_limit); -/* layer3_chain contains the list of rules for layer 3 */ -VNET_DEFINE(struct ip_fw_chain, layer3_chain); +VNET_DEFINE(struct ip_fw_contextes, ip_fw_contexts); VNET_DEFINE(int, ipfw_nat_ready) = 0; @@ -182,9 +181,6 @@ SYSCTL_INT(_net_inet_ip_fw, OID_AUTO, default_to_accept, CTLFLAG_RDTUN, "Make the default rule accept all packets."); TUNABLE_INT("net.inet.ip.fw.default_to_accept", &default_to_accept); TUNABLE_INT("net.inet.ip.fw.tables_max", (int *)&default_fw_tables); -SYSCTL_VNET_INT(_net_inet_ip_fw, OID_AUTO, static_count, - CTLFLAG_RD, &VNET_NAME(layer3_chain.n_rules), 0, - "Number of static rules"); #ifdef INET6 SYSCTL_DECL(_net_inet6_ip6); @@ -358,8 +354,8 @@ iface_match(struct ifnet *ifp, ipfw_insn_if *cmd, struct ip_fw_chain *chain, uin /* Check by name or by IP address */ if (cmd->name[0] != '\0') { /* match by name */ if (cmd->name[0] == '\1') /* use tablearg to match */ - return ipfw_lookup_table_extended(chain, cmd->p.glob, - ifp->if_xname, tablearg, IPFW_TABLE_INTERFACE); + return (ipfw_lookup_table_extended(chain, cmd->p.glob, + ifp->if_xname, tablearg, IPFW_TABLE_INTERFACE, NULL) != NULL); /* Check name */ if (cmd->p.glob) { if (fnmatch(cmd->name, ifp->if_xname, 0) == 0) @@ -904,6 +900,9 @@ ipfw_chk(struct ip_fw_args *args) */ struct ifnet *oif = args->oif; + if (V_ip_fw_contexts.chain[oif->if_ispare[0]] == NULL) + return (IP_FW_PASS); + int f_pos = 0; /* index of current rule in the array */ int retval = 0; @@ -954,7 +953,14 @@ ipfw_chk(struct ip_fw_args *args) */ int dyn_dir = MATCH_UNKNOWN; ipfw_dyn_rule *q = NULL; - struct ip_fw_chain *chain = &V_layer3_chain; + void *tblent = NULL, *tblent2 = NULL; + + /* XXX: WARNING - The chain is accessed unlocked here. + * There is a potential race here with context handling. + * The chain pointer will get destroyed and a NULL + * pointer dereference can happen! + */ + struct ip_fw_chain *chain = V_ip_fw_contexts.chain[oif->if_ispare[0]]; /* * We store in ulp a pointer to the upper layer protocol header. @@ -1288,6 +1294,8 @@ do { \ continue; skip_or = 0; + tblent = NULL; + tblent2 = NULL; for (l = f->cmd_len, cmd = f->cmd ; l > 0 ; l -= cmdlen, cmd += cmdlen) { int match; @@ -1402,7 +1410,7 @@ do { \ break; case O_IN: /* "out" is "not in" */ - match = (oif == NULL); + match = (args->dir == DIR_IN); break; case O_LAYER2: @@ -1438,11 +1446,18 @@ do { \ case O_IP_SRC_LOOKUP: case O_IP_DST_LOOKUP: if (is_ipv4) { + struct ether_addr *ea = NULL; + uint32_t key = (cmd->opcode == O_IP_DST_LOOKUP) ? dst_ip.s_addr : src_ip.s_addr; uint32_t v = 0; + if (args->eh) { + ea = (struct ether_addr*)((cmd->opcode == O_IP_DST_LOOKUP) ? + args->eh->ether_dhost : + args->eh->ether_shost); + } if (cmdlen > F_INSN_SIZE(ipfw_insn_u32)) { /* generic lookup. The key must be * in 32bit big-endian format. @@ -1484,22 +1499,37 @@ do { \ } else break; } - match = ipfw_lookup_table(chain, - cmd->arg1, key, &v); - if (!match) + tblent2 = ipfw_lookup_table(chain, + cmd->arg1, key, &v, ea); + if (tblent2 == NULL) { + match = 0; break; + } else + match = 1; if (cmdlen == F_INSN_SIZE(ipfw_insn_u32)) match = ((ipfw_insn_u32 *)cmd)->d[0] == v; - else + if (match) tablearg = v; } else if (is_ipv6) { + struct ether_addr *ea = NULL; uint32_t v = 0; + + if (args->eh) { + ea = (struct ether_addr*)((cmd->opcode == O_IP_DST_LOOKUP) ? + args->eh->ether_dhost : + args->eh->ether_shost); + } void *pkey = (cmd->opcode == O_IP_DST_LOOKUP) ? &args->f_id.dst_ip6: &args->f_id.src_ip6; - match = ipfw_lookup_table_extended(chain, + tblent = ipfw_lookup_table_extended(chain, cmd->arg1, pkey, &v, - IPFW_TABLE_CIDR); + IPFW_TABLE_CIDR, ea); + if (tblent == NULL) { + match = 0; + break; + } else + match = 1; if (cmdlen == F_INSN_SIZE(ipfw_insn_u32)) match = ((ipfw_insn_u32 *)cmd)->d[0] == v; if (match) @@ -2314,8 +2344,7 @@ do { \ break; case O_FORWARD_IP: - if (args->eh) /* not valid on layer2 pkts */ - break; + if (!args->eh) {/* not valid on layer2 pkts */ if (q == NULL || q->rule != f || dyn_dir == MATCH_FORWARD) { struct sockaddr_in *sa; @@ -2330,6 +2359,48 @@ do { \ args->next_hop = sa; } } + } else if (args->eh) { + struct m_tag *fwd_tag; + struct sockaddr_in *sa; + u_short sum; + + /* + * Checksum correct? (from ip_fastfwd.c) + */ + if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) + sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID); + else { + if (hlen == sizeof(struct ip)) + sum = in_cksum_hdr(ip); + else + sum = in_cksum(m, hlen); + } + if (sum) { + IPSTAT_INC(ips_badsum); + retval = IP_FW_DENY; + break; + } + + /* + * Remember that we have checked the IP header and found it valid. + */ + m->m_pkthdr.csum_flags |= (CSUM_IP_CHECKED | CSUM_IP_VALID); + + sa = &(((ipfw_insn_sa *)cmd)->sa); + fwd_tag = m_tag_get(PACKET_TAG_IPFORWARD, + sizeof(struct sockaddr_in), M_NOWAIT); + if (fwd_tag == NULL) + retval = IP_FW_DENY; + else { + bcopy(sa, (fwd_tag+1), sizeof(struct sockaddr_in)); + m_tag_prepend(m, fwd_tag); + + if (in_localip(sa->sin_addr)) + m->m_flags |= M_FASTFWD_OURS; + m->m_flags |= M_IP_NEXTHOP; + } + } + retval = IP_FW_PASS; l = 0; /* exit inner loop */ done = 1; /* exit outer loop */ @@ -2337,8 +2408,7 @@ do { \ #ifdef INET6 case O_FORWARD_IP6: - if (args->eh) /* not valid on layer2 pkts */ - break; + if (!args->eh) {/* not valid on layer2 pkts */ if (q == NULL || q->rule != f || dyn_dir == MATCH_FORWARD) { struct sockaddr_in6 *sin6; @@ -2346,6 +2416,24 @@ do { \ sin6 = &(((ipfw_insn_sa6 *)cmd)->sa); args->next_hop6 = sin6; } + } else if (args->eh) { + struct m_tag *fwd_tag; + struct sockaddr_in6 *sin6; + + sin6 = &(((ipfw_insn_sa6 *)cmd)->sa); + fwd_tag = m_tag_get(PACKET_TAG_IPFORWARD, + sizeof(struct sockaddr_in6), M_NOWAIT); + if (fwd_tag == NULL) + retval = IP_FW_DENY; + else { + bcopy(sin6, (fwd_tag+1), sizeof(struct sockaddr_in6)); + m_tag_prepend(m, fwd_tag); + + if (in6_localip(&sin6->sin6_addr)) + m->m_flags |= M_FASTFWD_OURS; + m->m_flags |= M_IP6_NEXTHOP; + } + } retval = IP_FW_PASS; l = 0; /* exit inner loop */ done = 1; /* exit outer loop */ @@ -2417,7 +2505,7 @@ do { \ set_match(args, f_pos, chain); /* Check if this is 'global' nat rule */ if (cmd->arg1 == 0) { - retval = ipfw_nat_ptr(args, NULL, m); + retval = ipfw_nat_ptr(args, NULL, m, chain); break; } t = ((ipfw_insn_nat *)cmd)->nat; @@ -2432,7 +2520,7 @@ do { \ if (cmd->arg1 != IP_FW_TABLEARG) ((ipfw_insn_nat *)cmd)->nat = t; } - retval = ipfw_nat_ptr(args, t, m); + retval = ipfw_nat_ptr(args, t, m, chain); break; case O_REASS: { @@ -2502,6 +2590,10 @@ do { \ struct ip_fw *rule = chain->map[f_pos]; /* Update statistics */ IPFW_INC_RULE_COUNTER(rule, pktlen); + if (tblent != NULL) + ipfw_count_table_xentry_stats(tblent, pktlen); + if (tblent2 != NULL) + ipfw_count_table_entry_stats(tblent2, pktlen); } else { retval = IP_FW_DENY; printf("ipfw: ouch!, skip past end of rules, denying packet\n"); @@ -2536,7 +2628,9 @@ sysctl_ipfw_table_num(SYSCTL_HANDLER_ARGS) if ((error != 0) || (req->newptr == NULL)) return (error); - return (ipfw_resize_tables(&V_layer3_chain, ntables)); + for (int i = 1; i < IP_FW_MAXCTX; i++) + error += ipfw_resize_tables(V_ip_fw_contexts.chain[i], ntables); + return (error); } #endif /* @@ -2614,11 +2708,6 @@ ipfw_destroy(void) static int vnet_ipfw_init(const void *unused) { - int error; - struct ip_fw *rule = NULL; - struct ip_fw_chain *chain; - - chain = &V_layer3_chain; /* First set up some values that are compile time options */ V_autoinc_step = 100; /* bounded to 1..1000 in add_rule() */ @@ -2629,10 +2718,55 @@ vnet_ipfw_init(const void *unused) #ifdef IPFIREWALL_VERBOSE_LIMIT V_verbose_limit = IPFIREWALL_VERBOSE_LIMIT; #endif + + for (int i = 0; i < IP_FW_MAXCTX; i++) + V_ip_fw_contexts.chain[i] = NULL; + + IPFW_CTX_LOCK_INIT(); + + V_ip_fw_contexts.ifnet_arrival = EVENTHANDLER_REGISTER(ifnet_arrival_event, + ipfw_attach_ifnet_event, NULL, EVENTHANDLER_PRI_ANY); + + ipfw_dyn_init(); + + /* First set up some values that are compile time options */ + V_ipfw_vnet_ready = 1; /* Open for business */ + + /* + * Hook the sockopt handler and pfil hooks for ipv4 and ipv6. + * Even if the latter two fail we still keep the module alive + * because the sockopt and layer2 paths are still useful. + * ipfw[6]_hook return 0 on success, ENOENT on failure, + * so we can ignore the exact return value and just set a flag. + * + * Note that V_fw[6]_enable are manipulated by a SYSCTL_PROC so + * changes in the underlying (per-vnet) variables trigger + * immediate hook()/unhook() calls. + * In layer2 we have the same behaviour, except that V_ether_ipfw + * is checked on each packet because there are no pfil hooks. + */ + V_ip_fw_ctl_ptr = ipfw_ctl; + return ipfw_attach_hooks(1); +} + +int +ipfw_context_init(int index) +{ + struct ip_fw_chain *chain; + struct ip_fw *rule = NULL; + + if (index >= IP_FW_MAXCTX) + return (-1); + + TAILQ_INIT(&V_ip_fw_contexts.iflist[index]); + + chain = V_ip_fw_contexts.chain[index]; + + IPFW_LOCK_INIT(chain); + #ifdef IPFIREWALL_NAT LIST_INIT(&chain->nat); #endif - /* insert the default rule and create the initial map */ chain->n_rules = 1; chain->static_len = sizeof(struct ip_fw); @@ -2642,13 +2776,7 @@ vnet_ipfw_init(const void *unused) /* Set initial number of tables */ V_fw_tables_max = default_fw_tables; - error = ipfw_init_tables(chain); - if (error) { - printf("ipfw2: setting up tables failed\n"); - free(chain->map, M_IPFW); - free(rule, M_IPFW); - return (ENOSPC); - } + ipfw_init_tables(chain); /* fill and insert the default rule */ rule->act_ofs = 0; @@ -2660,28 +2788,13 @@ vnet_ipfw_init(const void *unused) chain->default_rule = chain->map[0] = rule; chain->id = rule->id = 1; - IPFW_LOCK_INIT(chain); - ipfw_dyn_init(chain); - - /* First set up some values that are compile time options */ - V_ipfw_vnet_ready = 1; /* Open for business */ + /* + * This can potentially be done on first dynamic rule + * being added to chain. + */ + resize_dynamic_table(chain, V_curr_dyn_buckets); - /* - * Hook the sockopt handler and pfil hooks for ipv4 and ipv6. - * Even if the latter two fail we still keep the module alive - * because the sockopt and layer2 paths are still useful. - * ipfw[6]_hook return 0 on success, ENOENT on failure, - * so we can ignore the exact return value and just set a flag. - * - * Note that V_fw[6]_enable are manipulated by a SYSCTL_PROC so - * changes in the underlying (per-vnet) variables trigger - * immediate hook()/unhook() calls. - * In layer2 we have the same behaviour, except that V_ether_ipfw - * is checked on each packet because there are no pfil hooks. - */ - V_ip_fw_ctl_ptr = ipfw_ctl; - error = ipfw_attach_hooks(1); - return (error); + return (0); } /* @@ -2690,11 +2803,9 @@ vnet_ipfw_init(const void *unused) static int vnet_ipfw_uninit(const void *unused) { - struct ip_fw *reap, *rule; - struct ip_fw_chain *chain = &V_layer3_chain; - int i; V_ipfw_vnet_ready = 0; /* tell new callers to go away */ + /* * disconnect from ipv4, ipv6, layer2 and sockopt. * Then grab, release and grab again the WLOCK so we make @@ -2702,14 +2813,51 @@ vnet_ipfw_uninit(const void *unused) */ (void)ipfw_attach_hooks(0 /* detach */); V_ip_fw_ctl_ptr = NULL; + + ipfw_dyn_uninit(0); /* run the callout_drain */ + + IPFW_CTX_WLOCK(); + EVENTHANDLER_DEREGISTER(ifnet_arrival_event, V_ip_fw_contexts.ifnet_arrival); + for (int i = 0; i < IP_FW_MAXCTX; i++) { + ipfw_context_uninit(i); + } + IPFW_CTX_WUNLOCK(); + IPFW_CTX_LOCK_DESTROY(); + + ipfw_dyn_uninit(1); /* free the remaining parts */ + + return (0); +} + +int +ipfw_context_uninit(int index) +{ + struct ip_fw_chain *chain; + struct ip_fw_ctx_iflist *ifl; + struct ip_fw *reap, *rule; + struct ifnet *ifp; + int i; + + if (index >= IP_FW_MAXCTX) + return (-1); + + chain = V_ip_fw_contexts.chain[index]; + if (chain == NULL) + return (0); + + while (!TAILQ_EMPTY(&V_ip_fw_contexts.iflist[index])) { + ifl = TAILQ_FIRST(&V_ip_fw_contexts.iflist[index]); + TAILQ_REMOVE(&V_ip_fw_contexts.iflist[index], ifl, entry); + ifp = ifunit(ifl->ifname); + if (ifp != NULL) + ifp->if_ispare[0] = 0; + free(ifl, M_IPFW); + } + IPFW_UH_WLOCK(chain); IPFW_UH_WUNLOCK(chain); IPFW_UH_WLOCK(chain); - IPFW_WLOCK(chain); - ipfw_dyn_uninit(0); /* run the callout_drain */ - IPFW_WUNLOCK(chain); - ipfw_destroy_tables(chain); reap = NULL; IPFW_WLOCK(chain); @@ -2725,8 +2873,10 @@ vnet_ipfw_uninit(const void *unused) if (reap != NULL) ipfw_reap_rules(reap); IPFW_LOCK_DESTROY(chain); - ipfw_dyn_uninit(1); /* free the remaining parts */ - return 0; + + free(chain, M_IPFW); + + return (0); } /* diff --git a/sys/netpfil/ipfw/ip_fw_dynamic.c b/sys/netpfil/ipfw/ip_fw_dynamic.c index 81c1b2c..b6cfa62 100644 --- a/sys/netpfil/ipfw/ip_fw_dynamic.c +++ b/sys/netpfil/ipfw/ip_fw_dynamic.c @@ -121,11 +121,9 @@ struct ipfw_dyn_bucket { */ static VNET_DEFINE(struct ipfw_dyn_bucket *, ipfw_dyn_v); static VNET_DEFINE(u_int32_t, dyn_buckets_max); -static VNET_DEFINE(u_int32_t, curr_dyn_buckets); static VNET_DEFINE(struct callout, ipfw_timeout); #define V_ipfw_dyn_v VNET(ipfw_dyn_v) #define V_dyn_buckets_max VNET(dyn_buckets_max) -#define V_curr_dyn_buckets VNET(curr_dyn_buckets) #define V_ipfw_timeout VNET(ipfw_timeout) static VNET_DEFINE(uma_zone_t, ipfw_dyn_rule_zone); @@ -181,6 +179,8 @@ static VNET_DEFINE(u_int32_t, dyn_max); /* max # of dynamic rules */ static int last_log; /* Log ratelimiting */ +VNET_DEFINE(u_int32_t, curr_dyn_buckets); + static void ipfw_dyn_tick(void *vnetx); static void check_dyn_rules(struct ip_fw_chain *, struct ip_fw *, int, int, int); @@ -472,7 +472,7 @@ ipfw_dyn_unlock(ipfw_dyn_rule *q) IPFW_BUCK_UNLOCK(q->bucket); } -static int +int resize_dynamic_table(struct ip_fw_chain *chain, int nbuckets) { int i, k, nbuckets_old; @@ -975,7 +975,6 @@ ipfw_dyn_send_ka(struct mbuf **mtailp, ipfw_dyn_rule *q) static void ipfw_dyn_tick(void * vnetx) { - struct ip_fw_chain *chain; int check_ka = 0; #ifdef VIMAGE struct vnet *vp = vnetx; @@ -983,7 +982,6 @@ ipfw_dyn_tick(void * vnetx) CURVNET_SET(vp); - chain = &V_layer3_chain; /* Run keepalive checks every keepalive_period iff ka is enabled */ if ((V_dyn_keepalive_last + V_dyn_keepalive_period <= time_uptime) && @@ -992,7 +990,12 @@ ipfw_dyn_tick(void * vnetx) check_ka = 1; } - check_dyn_rules(chain, NULL, RESVD_SET, check_ka, 1); + IPFW_CTX_RLOCK(); + for (int i = 1; i < IP_FW_MAXCTX; i++) { + if (V_ip_fw_contexts.chain[i] != NULL) + check_dyn_rules(V_ip_fw_contexts.chain[i], NULL, RESVD_SET, check_ka, 1); + } + IPFW_CTX_RUNLOCK(); callout_reset_on(&V_ipfw_timeout, hz, ipfw_dyn_tick, vnetx, 0); @@ -1308,7 +1311,7 @@ ipfw_expire_dyn_rules(struct ip_fw_chain *chain, struct ip_fw *rule, int set) } void -ipfw_dyn_init(struct ip_fw_chain *chain) +ipfw_dyn_init() { V_ipfw_dyn_v = NULL; @@ -1337,12 +1340,6 @@ ipfw_dyn_init(struct ip_fw_chain *chain) uma_zone_set_max(V_ipfw_dyn_rule_zone, V_dyn_max); callout_init(&V_ipfw_timeout, CALLOUT_MPSAFE); - - /* - * This can potentially be done on first dynamic rule - * being added to chain. - */ - resize_dynamic_table(chain, V_curr_dyn_buckets); } void diff --git a/sys/netpfil/ipfw/ip_fw_nat.c b/sys/netpfil/ipfw/ip_fw_nat.c index 0fb4534..627603d 100644 --- a/sys/netpfil/ipfw/ip_fw_nat.c +++ b/sys/netpfil/ipfw/ip_fw_nat.c @@ -64,26 +64,33 @@ ifaddr_change(void *arg __unused, struct ifnet *ifp) KASSERT(curvnet == ifp->if_vnet, ("curvnet(%p) differs from iface vnet(%p)", curvnet, ifp->if_vnet)); - chain = &V_layer3_chain; - IPFW_WLOCK(chain); - /* Check every nat entry... */ - LIST_FOREACH(ptr, &chain->nat, _next) { - /* ...using nic 'ifp->if_xname' as dynamic alias address. */ - if (strncmp(ptr->if_name, ifp->if_xname, IF_NAMESIZE) != 0) + + IPFW_CTX_RLOCK(); + for (int i = 1; i < IP_FW_MAXCTX; i++) { + chain = V_ip_fw_contexts.chain[i]; + if (chain == NULL) continue; - if_addr_rlock(ifp); - TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { - if (ifa->ifa_addr == NULL) - continue; - if (ifa->ifa_addr->sa_family != AF_INET) + IPFW_WLOCK(chain); + /* Check every nat entry... */ + LIST_FOREACH(ptr, &chain->nat, _next) { + /* ...using nic 'ifp->if_xname' as dynamic alias address. */ + if (strncmp(ptr->if_name, ifp->if_xname, IF_NAMESIZE) != 0) continue; - ptr->ip = ((struct sockaddr_in *) - (ifa->ifa_addr))->sin_addr; - LibAliasSetAddress(ptr->lib, ptr->ip); + if_addr_rlock(ifp); + TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { + if (ifa->ifa_addr == NULL) + continue; + if (ifa->ifa_addr->sa_family != AF_INET) + continue; + ptr->ip = ((struct sockaddr_in *) + (ifa->ifa_addr))->sin_addr; + LibAliasSetAddress(ptr->lib, ptr->ip); + } + if_addr_runlock(ifp); } - if_addr_runlock(ifp); + IPFW_WUNLOCK(chain); } - IPFW_WUNLOCK(chain); + IPFW_CTX_RUNLOCK(); } /* @@ -206,18 +213,18 @@ add_redir_spool_cfg(char *buf, struct cfg_nat *ptr) /* * ipfw_nat - perform mbuf header translation. * - * Note V_layer3_chain has to be locked while calling ipfw_nat() in + * Note *chain has to be locked while calling ipfw_nat() in * 'global' operation mode (t == NULL). * */ static int -ipfw_nat(struct ip_fw_args *args, struct cfg_nat *t, struct mbuf *m) +ipfw_nat(struct ip_fw_args *args, struct cfg_nat *t, struct mbuf *m, + struct ip_fw_chain *chain) { struct mbuf *mcl; struct ip *ip; /* XXX - libalias duct tape */ int ldt, retval, found; - struct ip_fw_chain *chain; char *c; ldt = 0; @@ -276,7 +283,6 @@ ipfw_nat(struct ip_fw_args *args, struct cfg_nat *t, struct mbuf *m) } found = 0; - chain = &V_layer3_chain; IPFW_RLOCK_ASSERT(chain); /* Check every nat entry... */ LIST_FOREACH(t, &chain->nat, _next) { @@ -391,11 +397,10 @@ lookup_nat(struct nat_list *l, int nat_id) } static int -ipfw_nat_cfg(struct sockopt *sopt) +ipfw_nat_cfg(struct sockopt *sopt, struct ip_fw_chain *chain) { struct cfg_nat *cfg, *ptr; char *buf; - struct ip_fw_chain *chain = &V_layer3_chain; size_t len; int gencnt, error = 0; @@ -468,10 +473,9 @@ out: } static int -ipfw_nat_del(struct sockopt *sopt) +ipfw_nat_del(struct sockopt *sopt, struct ip_fw_chain *chain) { struct cfg_nat *ptr; - struct ip_fw_chain *chain = &V_layer3_chain; int i; sooptcopyin(sopt, &i, sizeof i, sizeof i); @@ -492,9 +496,8 @@ ipfw_nat_del(struct sockopt *sopt) } static int -ipfw_nat_get_cfg(struct sockopt *sopt) +ipfw_nat_get_cfg(struct sockopt *sopt, struct ip_fw_chain *chain) { - struct ip_fw_chain *chain = &V_layer3_chain; struct cfg_nat *n; struct cfg_redir *r; struct cfg_spool *s; @@ -552,14 +555,11 @@ retry: } static int -ipfw_nat_get_log(struct sockopt *sopt) +ipfw_nat_get_log(struct sockopt *sopt, struct ip_fw_chain *chain) { uint8_t *data; struct cfg_nat *ptr; int i, size; - struct ip_fw_chain *chain; - - chain = &V_layer3_chain; IPFW_RLOCK(chain); /* one pass to count, one to copy the data */ @@ -604,17 +604,22 @@ vnet_ipfw_nat_uninit(const void *arg __unused) struct cfg_nat *ptr, *ptr_temp; struct ip_fw_chain *chain; - chain = &V_layer3_chain; - IPFW_WLOCK(chain); - LIST_FOREACH_SAFE(ptr, &chain->nat, _next, ptr_temp) { - LIST_REMOVE(ptr, _next); - del_redir_spool_cfg(ptr, &ptr->redir_chain); - LibAliasUninit(ptr->lib); - free(ptr, M_IPFW); + IPFW_CTX_RLOCK(); + for (int i = 1; i < IP_FW_MAXCTX; i++) { + chain = V_ip_fw_contexts.chain[i]; + IPFW_WLOCK(chain); + LIST_FOREACH_SAFE(ptr, &chain->nat, _next, ptr_temp) { + LIST_REMOVE(ptr, _next); + del_redir_spool_cfg(ptr, &ptr->redir_chain); + LibAliasUninit(ptr->lib); + free(ptr, M_IPFW); + } + flush_nat_ptrs(chain, -1 /* flush all */); + V_ipfw_nat_ready = 0; + IPFW_WUNLOCK(chain); } - flush_nat_ptrs(chain, -1 /* flush all */); - V_ipfw_nat_ready = 0; - IPFW_WUNLOCK(chain); + IPFW_CTX_RUNLOCK(); + return (0); } diff --git a/sys/netpfil/ipfw/ip_fw_pfil.c b/sys/netpfil/ipfw/ip_fw_pfil.c index 2bcd1dd..bf225b8 100644 --- a/sys/netpfil/ipfw/ip_fw_pfil.c +++ b/sys/netpfil/ipfw/ip_fw_pfil.c @@ -143,8 +143,9 @@ again: } args.m = *m0; - args.oif = dir == DIR_OUT ? ifp : NULL; + args.oif = ifp; args.inp = inp; + args.dir = dir; ipfw = ipfw_chk(&args); *m0 = args.m; @@ -314,9 +315,8 @@ ipfw_check_frame(void *arg, struct mbuf **m0, struct ifnet *dst, int dir, /* XXX can we free it after use ? */ mtag->m_tag_id = PACKET_TAG_NONE; r = (struct ipfw_rule_ref *)(mtag + 1); - if (r->info & IPFW_ONEPASS) - return (0); - args.rule = *r; + m_tag_delete(*m0, mtag); + return (0); } /* I need some amt of data to be contiguous */ @@ -333,12 +333,15 @@ ipfw_check_frame(void *arg, struct mbuf **m0, struct ifnet *dst, int dir, save_eh = *eh; /* save copy for restore below */ m_adj(m, ETHER_HDR_LEN); /* strip ethernet header */ + dir = dir == PFIL_IN ? DIR_IN : DIR_OUT; + args.m = m; /* the packet we are looking at */ - args.oif = dir == PFIL_OUT ? dst: NULL; /* destination, if any */ + args.oif = dst; /* destination, if any */ args.next_hop = NULL; /* we do not support forward yet */ args.next_hop6 = NULL; /* we do not support forward yet */ args.eh = &save_eh; /* MAC header for bridged/MAC packets */ args.inp = NULL; /* used by ipfw uid/gid/jail rules */ + args.dir = dir; /* pfSense addition */ i = ipfw_chk(&args); m = args.m; if (m != NULL) { @@ -369,13 +372,12 @@ ipfw_check_frame(void *arg, struct mbuf **m0, struct ifnet *dst, int dir, case IP_FW_DUMMYNET: ret = EACCES; - int dir; if (ip_dn_io_ptr == NULL) break; /* i.e. drop */ *m0 = NULL; - dir = PROTO_LAYER2 | (dst ? DIR_OUT : DIR_IN); + dir = PROTO_LAYER2 | dir; ip_dn_io_ptr(&m, dir, &args); return 0; @@ -499,7 +501,11 @@ ipfw_hook(int onoff, int pf) hook_func = (pf == AF_LINK) ? ipfw_check_frame : ipfw_check_packet; - (void) (onoff ? pfil_add_hook : pfil_remove_hook) + if (onoff) + (void) pfil_add_named_hook + (hook_func, NULL, "ipfw", PFIL_IN | PFIL_OUT | PFIL_WAITOK, pfh); + else + (void) pfil_remove_hook (hook_func, NULL, PFIL_IN | PFIL_OUT | PFIL_WAITOK, pfh); return 0; diff --git a/sys/netpfil/ipfw/ip_fw_private.h b/sys/netpfil/ipfw/ip_fw_private.h index e4a2f31..4f4cf93 100644 --- a/sys/netpfil/ipfw/ip_fw_private.h +++ b/sys/netpfil/ipfw/ip_fw_private.h @@ -101,6 +101,7 @@ struct ip_fw_args { struct ipfw_flow_id f_id; /* grabbed from IP header */ //uint32_t cookie; /* a cookie depending on rule action */ + uint32_t dir; /* direction */ struct inpcb *inp; struct _ip6dn_args dummypar; /* dummynet->ip6_output */ @@ -170,6 +171,9 @@ enum { /* result for matching dynamic rules */ MATCH_UNKNOWN, }; +VNET_DECLARE(u_int32_t, curr_dyn_buckets); +#define V_curr_dyn_buckets VNET(curr_dyn_buckets) + /* * The lock for dynamic rules is only used once outside the file, * and only to release the result of lookup_dyn_rule(). @@ -178,6 +182,7 @@ enum { /* result for matching dynamic rules */ struct ip_fw_chain; void ipfw_expire_dyn_rules(struct ip_fw_chain *, struct ip_fw *, int); void ipfw_dyn_unlock(ipfw_dyn_rule *q); +int resize_dynamic_table(struct ip_fw_chain *, int); struct tcphdr; struct mbuf *ipfw_send_pkt(struct mbuf *, struct ipfw_flow_id *, @@ -189,7 +194,7 @@ ipfw_dyn_rule *ipfw_lookup_dyn_rule(struct ipfw_flow_id *pkt, void ipfw_remove_dyn_children(struct ip_fw *rule); void ipfw_get_dynamic(struct ip_fw_chain *chain, char **bp, const char *ep); -void ipfw_dyn_init(struct ip_fw_chain *); /* per-vnet initialization */ +void ipfw_dyn_init(void); /* per-vnet initialization */ void ipfw_dyn_uninit(int); /* per-vnet deinitialization */ int ipfw_dyn_len(void); @@ -200,9 +205,6 @@ VNET_DECLARE(int, fw_one_pass); VNET_DECLARE(int, fw_verbose); #define V_fw_verbose VNET(fw_verbose) -VNET_DECLARE(struct ip_fw_chain, layer3_chain); -#define V_layer3_chain VNET(layer3_chain) - VNET_DECLARE(u_int32_t, set_disable); #define V_set_disable VNET(set_disable) @@ -236,6 +238,33 @@ struct ip_fw_chain { #endif }; +struct ip_fw_ctx_iflist { + TAILQ_ENTRY(ip_fw_ctx_iflist) entry; + char ifname[IFNAMSIZ]; +}; + +#define IP_FW_MAXCTX 4096 +struct ip_fw_contextes { + struct ip_fw_chain *chain[IP_FW_MAXCTX]; /* Arrays of contextes */ + TAILQ_HEAD(, ip_fw_ctx_iflist) iflist[IP_FW_MAXCTX]; + struct rwlock rwctx; + eventhandler_tag ifnet_arrival; +}; + +VNET_DECLARE(struct ip_fw_contextes, ip_fw_contexts); +#define V_ip_fw_contexts VNET(ip_fw_contexts) + +#define IPFW_CTX_LOCK_INIT() rw_init(&V_ip_fw_contexts.rwctx, "IPFW context") +#define IPFW_CTX_LOCK_DESTROY() rw_destroy(&V_ip_fw_contexts.rwctx) +#define IPFW_CTX_WLOCK() rw_wlock(&V_ip_fw_contexts.rwctx) +#define IPFW_CTX_WUNLOCK() rw_wunlock(&V_ip_fw_contexts.rwctx) +#define IPFW_CTX_RLOCK() rw_rlock(&V_ip_fw_contexts.rwctx) +#define IPFW_CTX_RUNLOCK() rw_runlock(&V_ip_fw_contexts.rwctx) + +void ipfw_attach_ifnet_event(void *, struct ifnet *); +int ipfw_context_init(int); +int ipfw_context_uninit(int); + struct sockopt; /* used by tcp_var.h */ /* Macro for working with various counters */ @@ -303,16 +332,21 @@ int ipfw_chk(struct ip_fw_args *args); void ipfw_reap_rules(struct ip_fw *head); /* In ip_fw_table.c */ +struct ether_addr; struct radix_node; -int ipfw_lookup_table(struct ip_fw_chain *ch, uint16_t tbl, in_addr_t addr, - uint32_t *val); -int ipfw_lookup_table_extended(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, - uint32_t *val, int type); +void *ipfw_lookup_table(struct ip_fw_chain *ch, uint16_t tbl, in_addr_t addr, + uint32_t *val, struct ether_addr *); +void *ipfw_lookup_table_extended(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, + uint32_t *val, int type, struct ether_addr *); +void ipfw_count_table_entry_stats(void *, int); +void ipfw_count_table_xentry_stats(void *, int); +int ipfw_zero_table_xentry_stats(struct ip_fw_chain *, ipfw_table_xentry *); +int ipfw_lookup_table_xentry(struct ip_fw_chain *, ipfw_table_xentry *); int ipfw_init_tables(struct ip_fw_chain *ch); void ipfw_destroy_tables(struct ip_fw_chain *ch); int ipfw_flush_table(struct ip_fw_chain *ch, uint16_t tbl); int ipfw_add_table_entry(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, - uint8_t plen, uint8_t mlen, uint8_t type, uint32_t value); + uint8_t plen, uint8_t mlen, uint8_t type, u_int64_t mac_addr, uint32_t value); int ipfw_del_table_entry(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, uint8_t plen, uint8_t mlen, uint8_t type); int ipfw_count_table(struct ip_fw_chain *ch, uint32_t tbl, uint32_t *cnt); @@ -326,8 +360,9 @@ int ipfw_resize_tables(struct ip_fw_chain *ch, unsigned int ntables); extern struct cfg_nat *(*lookup_nat_ptr)(struct nat_list *, int); -typedef int ipfw_nat_t(struct ip_fw_args *, struct cfg_nat *, struct mbuf *); -typedef int ipfw_nat_cfg_t(struct sockopt *); +typedef int ipfw_nat_t(struct ip_fw_args *, struct cfg_nat *, struct mbuf *, + struct ip_fw_chain *); +typedef int ipfw_nat_cfg_t(struct sockopt *, struct ip_fw_chain *); VNET_DECLARE(int, ipfw_nat_ready); #define V_ipfw_nat_ready VNET(ipfw_nat_ready) diff --git a/sys/netpfil/ipfw/ip_fw_sockopt.c b/sys/netpfil/ipfw/ip_fw_sockopt.c index 3c342f7..2776e4c 100644 --- a/sys/netpfil/ipfw/ip_fw_sockopt.c +++ b/sys/netpfil/ipfw/ip_fw_sockopt.c @@ -736,8 +736,8 @@ check_ipfw_struct(struct ip_fw *rule, int size) if (!IPFW_NAT_LOADED) return EINVAL; if (cmdlen != F_INSN_SIZE(ipfw_insn_nat)) - goto bad_size; - goto check_action; + goto bad_size; + goto check_action; case O_FORWARD_MAC: /* XXX not implemented yet */ case O_CHECK_STATE: case O_COUNT: @@ -943,12 +943,15 @@ ipfw_ctl(struct sockopt *sopt) #define RULE_MAXSIZE (256*sizeof(u_int32_t)) int error; size_t size, len, valsize; + struct ifnet *ifp; struct ip_fw *buf, *rule; - struct ip_fw_chain *chain; + static struct ip_fw_chain *chain; + struct ip_fw_ctx_iflist *tmpifl, *tmpifl2 = NULL; + ip_fw3_opheader *op3 = NULL; u_int32_t rulenum[2]; uint32_t opt; char xbuf[128]; - ip_fw3_opheader *op3 = NULL; + char *ifname; error = priv_check(sopt->sopt_td, PRIV_NETINET_IPFW); if (error) @@ -965,7 +968,6 @@ ipfw_ctl(struct sockopt *sopt) return (error); } - chain = &V_layer3_chain; error = 0; /* Save original valsize before it is altered via sooptcopyin() */ @@ -980,9 +982,238 @@ ipfw_ctl(struct sockopt *sopt) return (error); op3 = (ip_fw3_opheader *)xbuf; opt = op3->opcode; + + if (op3->ctxid >= IP_FW_MAXCTX) + return (EINVAL); + + if (opt != IP_FW_CTX_GET && opt != IP_FW_CTX_ADD) { + if (op3->ctxid == 0) + return (ENOENT); + + IPFW_CTX_RLOCK(); + chain = V_ip_fw_contexts.chain[op3->ctxid]; + IPFW_CTX_RUNLOCK(); + if (chain == NULL) + return (ENOENT); + } } + /* Verification needed to avoid problems */ switch (opt) { + case IP_FW_CTX_GET: + case IP_FW_CTX_ADD: + case IP_FW_CTX_DEL: + break; + default: + if (chain == NULL) + return (EINVAL); + /* NOTREACHED */ + } + + switch (opt) { + case IP_FW_CTX_ADD: + IPFW_CTX_WLOCK(); + if (V_ip_fw_contexts.chain[op3->ctxid] != NULL) { + IPFW_CTX_WUNLOCK(); + return (EEXIST); + } + + chain = malloc(sizeof(struct ip_fw_chain), M_IPFW, M_WAITOK | M_ZERO); + TAILQ_INIT(&V_ip_fw_contexts.iflist[op3->ctxid]); + V_ip_fw_contexts.chain[op3->ctxid] = chain; + ipfw_context_init(op3->ctxid); /* XXX: error checking */ + IPFW_CTX_WUNLOCK(); + break; + + case IP_FW_CTX_DEL: + IPFW_CTX_WLOCK(); + if (V_ip_fw_contexts.chain[op3->ctxid] == NULL) { + IPFW_CTX_WUNLOCK(); + return (ENOENT); + } + + ipfw_context_uninit(op3->ctxid); + V_ip_fw_contexts.chain[op3->ctxid] = NULL; + IPFW_CTX_WUNLOCK(); + break; + + case IP_FW_CTX_GET: + { + int i, n, len = 0, want; + char *bufout, *tmpbuf; + + sopt->sopt_valsize = valsize; + + IPFW_CTX_RLOCK(); + for (i = 1; i < IP_FW_MAXCTX; i++) { + if (op3->ctxid > 0 && op3->ctxid != i) + continue; + if (op3->ctxid > 0 && op3->ctxid < i) + break; + + if (V_ip_fw_contexts.chain[i] == NULL) + continue; + + /* Calculate number of bytes for the integer */ + n = i; + while (n > 0) { + n /= 10; + len++; + } + TAILQ_FOREACH(tmpifl, &V_ip_fw_contexts.iflist[i], entry) { + len += strlen(tmpifl->ifname) + 1; + } + len += 3; // newline, :, space + } + IPFW_CTX_RUNLOCK(); + + if (len > sopt->sopt_valsize) { + sopt->sopt_valsize = len; + break; + } + + bufout = malloc(len, M_TEMP, M_WAITOK | M_ZERO); + if (bufout == NULL) + break; + + /* Record our size for later checks */ + want = len; + len = 0; + IPFW_CTX_RLOCK(); + /* Recalculate length to detect if smth changed */ + for (i = 1; i < IP_FW_MAXCTX; i++) { + if (op3->ctxid > 0 && op3->ctxid != i) + continue; + if (op3->ctxid > 0 && op3->ctxid < i) + break; + + if (V_ip_fw_contexts.chain[i] == NULL) + continue; + + /* Calculate number of bytes for the integer */ + n = i; + while (n > 0) { + n /= 10; + len++; + } + TAILQ_FOREACH(tmpifl, &V_ip_fw_contexts.iflist[i], entry) { + len += strlen(tmpifl->ifname) + 1; + } + len += 3; // newline, :, space + } + + if (want >= len) { + tmpbuf = bufout; + for (i = 1; i < IP_FW_MAXCTX; i++) { + if (op3->ctxid > 0 && op3->ctxid != i) + continue; + if (op3->ctxid > 0 && op3->ctxid < i) + break; + + if (V_ip_fw_contexts.chain[i] == NULL) + continue; + + sprintf(tmpbuf, "%d: ", i); + tmpbuf += strlen(tmpbuf); + TAILQ_FOREACH(tmpifl, &V_ip_fw_contexts.iflist[i], entry) { + sprintf(tmpbuf, "%s,", tmpifl->ifname); + tmpbuf += strlen(tmpifl->ifname) + 1; + } + sprintf(tmpbuf, "\n"); + tmpbuf++; + } + } + IPFW_CTX_RUNLOCK(); + + if (want >= len) + error = sooptcopyout(sopt, bufout, len); + else + len = 0; + free(bufout, M_TEMP); + } + break; + + case IP_FW_CTX_SET: + /* XXX: Maybe not use this option at all? */ + IPFW_CTX_RLOCK(); + if (V_ip_fw_contexts.chain[op3->ctxid] == NULL) + error = ENOENT; + else + chain = V_ip_fw_contexts.chain[op3->ctxid]; + IPFW_CTX_RUNLOCK(); + break; + + case IP_FW_CTX_ADDMEMBER: + { + int i; + + ifname = (char *)(op3 + 1); + ifp = ifunit(ifname); + if (ifp == NULL) + return (ENOENT); + + tmpifl = malloc(sizeof(*tmpifl), M_IPFW, M_WAITOK | M_ZERO); + + IPFW_CTX_WLOCK(); + if (V_ip_fw_contexts.chain[op3->ctxid] == NULL) { + IPFW_CTX_WUNLOCK(); + free(tmpifl, M_IPFW); + return (ENOENT); + } + + for (i = 1; i < IP_FW_MAXCTX; i++) { + if (V_ip_fw_contexts.chain[i] == NULL) + continue; + + TAILQ_FOREACH(tmpifl2, &V_ip_fw_contexts.iflist[i], entry) { + if (strlen(tmpifl2->ifname) != strlen(ifname)) + continue; + if (!strcmp(tmpifl2->ifname, ifname)) + goto ctxifacefound; + } + } +ctxifacefound: + if (tmpifl2 != NULL) { + IPFW_CTX_WUNLOCK(); + free(tmpifl, M_IPFW); + return (EEXIST); + } + + strlcpy(tmpifl->ifname, ifname, IFNAMSIZ); + TAILQ_INSERT_HEAD(&V_ip_fw_contexts.iflist[op3->ctxid], tmpifl, entry); + ifp->if_ispare[0] = op3->ctxid; + IPFW_CTX_WUNLOCK(); + } + break; + + case IP_FW_CTX_DELMEMBER: + IPFW_CTX_WLOCK(); + if (V_ip_fw_contexts.chain[op3->ctxid] == NULL) { + IPFW_CTX_WUNLOCK(); + return (ENOENT); + } + + ifname = (char *)(op3 + 1); + TAILQ_FOREACH(tmpifl2, &V_ip_fw_contexts.iflist[op3->ctxid], entry) { + if (strlen(tmpifl2->ifname) != strlen(ifname)) + continue; + if (!strcmp(tmpifl2->ifname, ifname)) + break; + } + if (tmpifl2 == NULL) { + IPFW_CTX_WUNLOCK(); + return (ENOENT); + } + + TAILQ_REMOVE(&V_ip_fw_contexts.iflist[op3->ctxid], tmpifl2, entry); + IPFW_CTX_WUNLOCK(); + free(tmpifl2, M_IPFW); + + ifp = ifunit(ifname); + if (ifp != NULL) + ifp->if_ispare[0] = 0; + break; + case IP_FW_GET: /* * pass up a copy of the current rules. Static rules @@ -1124,7 +1355,7 @@ ipfw_ctl(struct sockopt *sopt) break; error = ipfw_add_table_entry(chain, ent.tbl, &ent.addr, sizeof(ent.addr), ent.masklen, - IPFW_TABLE_CIDR, ent.value); + IPFW_TABLE_CIDR, ent.mac_addr, ent.value); } break; @@ -1157,12 +1388,12 @@ ipfw_ctl(struct sockopt *sopt) error = EINVAL; break; } - + len = xent->len - offsetof(ipfw_table_xentry, k); error = (opt == IP_FW_TABLE_XADD) ? ipfw_add_table_entry(chain, xent->tbl, &xent->k, - len, xent->masklen, xent->type, xent->value) : + len, xent->masklen, xent->type, xent->mac_addr, xent->value) : ipfw_del_table_entry(chain, xent->tbl, &xent->k, len, xent->masklen, xent->type); } @@ -1245,6 +1476,54 @@ ipfw_ctl(struct sockopt *sopt) } break; + case IP_FW_TABLE_XZEROENTRY: /* IP_FW3 */ + { + ipfw_table_xentry *xent = (ipfw_table_xentry *)(op3 + 1); + + /* Check minimum header size */ + if (IP_FW3_OPLENGTH(sopt) < offsetof(ipfw_table_xentry, k)) { + error = EINVAL; + break; + } + + /* Check if len field is valid */ + if (xent->len > sizeof(ipfw_table_xentry)) { + error = EINVAL; + break; + } + + error = ipfw_zero_table_xentry_stats(chain, xent); + if (!error) { + xent->timestamp += boottime.tv_sec; + error = sooptcopyout(sopt, xent, sizeof(*xent)); + } + } + break; + + case IP_FW_TABLE_XLISTENTRY: /* IP_FW3 */ + { + ipfw_table_xentry *xent = (ipfw_table_xentry *)(op3 + 1); + + /* Check minimum header size */ + if (IP_FW3_OPLENGTH(sopt) < offsetof(ipfw_table_xentry, k)) { + error = EINVAL; + break; + } + + /* Check if len field is valid */ + if (xent->len > sizeof(ipfw_table_xentry)) { + error = EINVAL; + break; + } + + error = ipfw_lookup_table_xentry(chain, xent); + if (!error) { + xent->timestamp += boottime.tv_sec; + error = sooptcopyout(sopt, xent, sizeof(*xent)); + } + } + break; + case IP_FW_TABLE_XLIST: /* IP_FW3 */ { ipfw_xtable *tbl; @@ -1284,7 +1563,7 @@ ipfw_ctl(struct sockopt *sopt) /*--- NAT operations are protected by the IPFW_LOCK ---*/ case IP_FW_NAT_CFG: if (IPFW_NAT_LOADED) - error = ipfw_nat_cfg_ptr(sopt); + error = ipfw_nat_cfg_ptr(sopt, chain); else { printf("IP_FW_NAT_CFG: %s\n", "ipfw_nat not present, please load it"); @@ -1294,7 +1573,7 @@ ipfw_ctl(struct sockopt *sopt) case IP_FW_NAT_DEL: if (IPFW_NAT_LOADED) - error = ipfw_nat_del_ptr(sopt); + error = ipfw_nat_del_ptr(sopt, chain); else { printf("IP_FW_NAT_DEL: %s\n", "ipfw_nat not present, please load it"); @@ -1304,7 +1583,7 @@ ipfw_ctl(struct sockopt *sopt) case IP_FW_NAT_GET_CONFIG: if (IPFW_NAT_LOADED) - error = ipfw_nat_get_cfg_ptr(sopt); + error = ipfw_nat_get_cfg_ptr(sopt, chain); else { printf("IP_FW_NAT_GET_CFG: %s\n", "ipfw_nat not present, please load it"); @@ -1314,7 +1593,7 @@ ipfw_ctl(struct sockopt *sopt) case IP_FW_NAT_GET_LOG: if (IPFW_NAT_LOADED) - error = ipfw_nat_get_log_ptr(sopt); + error = ipfw_nat_get_log_ptr(sopt, chain); else { printf("IP_FW_NAT_GET_LOG: %s\n", "ipfw_nat not present, please load it"); @@ -1331,6 +1610,33 @@ ipfw_ctl(struct sockopt *sopt) #undef RULE_MAXSIZE } +void +ipfw_attach_ifnet_event(void *arg __unused, struct ifnet *ifp) +{ + struct ip_fw_ctx_iflist *tmpifl; + + CURVNET_SET(ifp->if_vnet); + + IPFW_CTX_RLOCK(); + for (int i = 1; i < IP_FW_MAXCTX; i++) { + if (V_ip_fw_contexts.chain[i] == NULL) + continue; + TAILQ_FOREACH(tmpifl, &V_ip_fw_contexts.iflist[i], entry) { + if (strlen(tmpifl->ifname) != strlen(ifp->if_xname)) + continue; + if (!strcmp(tmpifl->ifname, ifp->if_xname)) { + printf("Restoring context for interface %s to %d\n", ifp->if_xname, i); + ifp->if_ispare[0] = i; + goto ifctxdone; + break; + } + } + } +ifctxdone: + IPFW_CTX_RUNLOCK(); + + CURVNET_RESTORE(); +} #define RULE_MAXSIZE (256*sizeof(u_int32_t)) diff --git a/sys/netpfil/ipfw/ip_fw_table.c b/sys/netpfil/ipfw/ip_fw_table.c index 760a10c..689596f 100644 --- a/sys/netpfil/ipfw/ip_fw_table.c +++ b/sys/netpfil/ipfw/ip_fw_table.c @@ -59,6 +59,7 @@ __FBSDID("$FreeBSD$"); #include <net/route.h> #include <net/vnet.h> +#include <net/ethernet.h> #include <netinet/in.h> #include <netinet/ip_var.h> /* struct ipfw_rule_ref */ #include <netinet/ip_fw.h> @@ -74,7 +75,11 @@ static MALLOC_DEFINE(M_IPFW_TBL, "ipfw_tbl", "IpFw tables"); struct table_entry { struct radix_node rn[2]; struct sockaddr_in addr, mask; + u_int64_t mac_addr; u_int32_t value; + u_int32_t timestamp; + u_int64_t bytes; + u_int64_t packets; }; struct xaddr_iface { @@ -97,7 +102,11 @@ struct table_xentry { #endif struct xaddr_iface ifmask; } m; + u_int64_t mac_addr; u_int32_t value; + u_int32_t timestamp; + u_int64_t bytes; + u_int64_t packets; }; /* @@ -137,7 +146,7 @@ ipv6_writemask(struct in6_addr *addr6, uint8_t mask) int ipfw_add_table_entry(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, - uint8_t plen, uint8_t mlen, uint8_t type, uint32_t value) + uint8_t plen, uint8_t mlen, uint8_t type, u_int64_t mac_addr, uint32_t value) { struct radix_node_head *rnh, **rnh_ptr; struct table_entry *ent; @@ -161,6 +170,7 @@ ipfw_add_table_entry(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, return (EINVAL); ent = malloc(sizeof(*ent), M_IPFW_TBL, M_WAITOK | M_ZERO); ent->value = value; + ent->mac_addr = mac_addr; /* Set 'total' structure length */ KEY_LEN(ent->addr) = KEY_LEN_INET; KEY_LEN(ent->mask) = KEY_LEN_INET; @@ -182,6 +192,7 @@ ipfw_add_table_entry(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, return (EINVAL); xent = malloc(sizeof(*xent), M_IPFW_TBL, M_WAITOK | M_ZERO); xent->value = value; + xent->mac_addr = mac_addr; /* Set 'total' structure length */ KEY_LEN(xent->a.addr6) = KEY_LEN_INET6; KEY_LEN(xent->m.mask6) = KEY_LEN_INET6; @@ -281,6 +292,28 @@ ipfw_add_table_entry(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, IPFW_WUNLOCK(ch); if (rn == NULL) { + if (type == IPFW_TABLE_CIDR) { + /* Just update if any new value needed */ + if (plen == sizeof(in_addr_t)) { + ent = (struct table_entry *)(rnh->rnh_matchaddr(addr_ptr, rnh)); + if (ent != NULL) { + if (ent->mac_addr) { + if (!bcmp(&mac_addr, &ent->mac_addr, ETHER_ADDR_LEN)) + ent->value = value; + } else + ent->value = value; + } + } else { + xent = (struct table_xentry *)(rnh->rnh_matchaddr(addr_ptr, rnh)); + if (xent != NULL) { + if (xent->mac_addr) { + if (!bcmp(&mac_addr, &xent->mac_addr, ETHER_ADDR_LEN)) + xent->value = value; + } else + xent->value = value; + } + } + } free(ent_ptr, M_IPFW_TBL); return (EEXIST); } @@ -530,31 +563,194 @@ ipfw_resize_tables(struct ip_fw_chain *ch, unsigned int ntables) return (0); } -int +void * ipfw_lookup_table(struct ip_fw_chain *ch, uint16_t tbl, in_addr_t addr, - uint32_t *val) + uint32_t *val, struct ether_addr *ea) { struct radix_node_head *rnh; struct table_entry *ent; struct sockaddr_in sa; if (tbl >= V_fw_tables_max) - return (0); + return (NULL); if ((rnh = ch->tables[tbl]) == NULL) - return (0); + return (NULL); KEY_LEN(sa) = KEY_LEN_INET; sa.sin_addr.s_addr = addr; ent = (struct table_entry *)(rnh->rnh_matchaddr(&sa, rnh)); if (ent != NULL) { - *val = ent->value; - return (1); + if (ea && ent->mac_addr) { + if (bcmp((u_char *)&ent->mac_addr, ea->octet, ETHER_ADDR_LEN) != 0) + ent = NULL; + } + if (ent != NULL) { + *val = ent->value; + return (ent); + } } - return (0); + return (NULL); +} + +void +ipfw_count_table_entry_stats(void *arg, int pktlen) +{ + struct table_entry *xent = arg; + + xent->packets++; + xent->bytes += pktlen; + xent->timestamp = time_uptime; +} + +void +ipfw_count_table_xentry_stats(void *arg, int pktlen) +{ + ipfw_table_xentry *xent= arg; + + xent->packets++; + xent->bytes += pktlen; + xent->timestamp = time_uptime; } int +ipfw_zero_table_xentry_stats(struct ip_fw_chain *ch, ipfw_table_xentry *arg) +{ + struct radix_node_head *rnh; + struct table_xentry *xent; + struct sockaddr_in6 sa6; + struct xaddr_iface iface; + + if (arg->tbl >= V_fw_tables_max) + return (EINVAL); + if (ch->tables[arg->tbl] != NULL) + rnh = ch->tables[arg->tbl]; + else if (ch->xtables[arg->tbl] != NULL) + rnh = ch->xtables[arg->tbl]; + else + return (EINVAL); + + switch (arg->type) { + case IPFW_TABLE_CIDR: + if (ch->tables[arg->tbl] != NULL) { + /* XXX: Maybe better by FreeBSD 11!! */ + struct sockaddr_in sa; + struct table_entry *ent; + + KEY_LEN(sa) = KEY_LEN_INET; + sa.sin_addr.s_addr = *((in_addr_t *)&arg->k.addr6); + ent = (struct table_entry *)(rnh->rnh_matchaddr(&sa, rnh)); + if (ent == NULL) + return (EINVAL); + + arg->bytes = 0; + arg->packets = 0; + arg->value = ent->value; + arg->timestamp = time_uptime; + + return (0); + } else { + KEY_LEN(sa6) = KEY_LEN_INET6; + memcpy(&sa6.sin6_addr, &arg->k.addr6, sizeof(struct in6_addr)); + xent = (struct table_xentry *)(rnh->rnh_matchaddr(&sa6, rnh)); + } + break; + + case IPFW_TABLE_INTERFACE: + KEY_LEN(iface) = KEY_LEN_IFACE + + strlcpy(iface.ifname, arg->k.iface, IF_NAMESIZE) + 1; + /* Assume direct match */ + /* FIXME: Add interface pattern matching */ + xent = (struct table_xentry *)(rnh->rnh_lookup(&iface, NULL, rnh)); + break; + + default: + return (EINVAL); + } + + if (xent != NULL) { + xent->bytes = 0; + xent->packets = 0; + xent->timestamp = time_uptime; + + return (0); + } + return (EINVAL); +} + +int +ipfw_lookup_table_xentry(struct ip_fw_chain *ch, ipfw_table_xentry *arg) +{ + struct radix_node_head *rnh; + struct table_xentry *xent; + + if (arg->tbl >= V_fw_tables_max) + return (EINVAL); + if (ch->tables[arg->tbl] != NULL) + rnh = ch->tables[arg->tbl]; + else if (ch->xtables[arg->tbl] != NULL) + rnh = ch->xtables[arg->tbl]; + else + return (EINVAL); + + switch (arg->type) { + case IPFW_TABLE_CIDR: + { + if (ch->tables[arg->tbl] != NULL) { + /* XXX: Maybe better by FreeBSD 11!! */ + struct sockaddr_in sa; + struct table_entry *ent; + + KEY_LEN(sa) = KEY_LEN_INET; + sa.sin_addr.s_addr = *((in_addr_t *)&arg->k.addr6); + ent = (struct table_entry *)(rnh->rnh_matchaddr(&sa, rnh)); + if (ent == NULL) + return (EINVAL); + + arg->bytes = ent->bytes; + arg->packets = ent->packets; + arg->value = ent->value; + arg->timestamp = ent->timestamp; + arg->mac_addr = ent->mac_addr; + return (0); + } else { + struct sockaddr_in6 sa6; + KEY_LEN(sa6) = KEY_LEN_INET6; + memcpy(&sa6.sin6_addr, &arg->k.addr6, sizeof(struct in6_addr)); + xent = (struct table_xentry *)(rnh->rnh_matchaddr(&sa6, rnh)); + } + } + break; + + case IPFW_TABLE_INTERFACE: + { + struct xaddr_iface iface; + + KEY_LEN(iface) = KEY_LEN_IFACE + + strlcpy(iface.ifname, arg->k.iface, IF_NAMESIZE) + 1; + /* Assume direct match */ + /* FIXME: Add interface pattern matching */ + xent = (struct table_xentry *)(rnh->rnh_lookup(&iface, NULL, rnh)); + } + break; + + default: + return (0); + } + + if (xent != NULL) { + arg->bytes = xent->bytes; + arg->packets = xent->packets; + arg->value = xent->value; + arg->timestamp = xent->timestamp; + arg->mac_addr = xent->mac_addr; + + return (0); + } + return (EINVAL); +} + +void * ipfw_lookup_table_extended(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, - uint32_t *val, int type) + uint32_t *val, int type, struct ether_addr *ea) { struct radix_node_head *rnh; struct table_xentry *xent; @@ -562,15 +758,21 @@ ipfw_lookup_table_extended(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, struct xaddr_iface iface; if (tbl >= V_fw_tables_max) - return (0); + return (NULL); if ((rnh = ch->xtables[tbl]) == NULL) - return (0); + return (NULL); switch (type) { case IPFW_TABLE_CIDR: KEY_LEN(sa6) = KEY_LEN_INET6; memcpy(&sa6.sin6_addr, paddr, sizeof(struct in6_addr)); xent = (struct table_xentry *)(rnh->rnh_matchaddr(&sa6, rnh)); + if (xent != NULL) { + if (ea && xent->mac_addr) { + if (bcmp((u_char *)&xent->mac_addr, ea->octet, ETHER_ADDR_LEN) != 0) + xent = NULL; + } + } break; case IPFW_TABLE_INTERFACE: @@ -582,14 +784,14 @@ ipfw_lookup_table_extended(struct ip_fw_chain *ch, uint16_t tbl, void *paddr, break; default: - return (0); + return (NULL); } if (xent != NULL) { *val = xent->value; - return (1); + return (xent); } - return (0); + return (NULL); } static int @@ -696,9 +898,13 @@ dump_table_xentry_base(struct radix_node *rn, void *arg) else xent->masklen = 33 - ffs(ntohl(n->mask.sin_addr.s_addr)); /* Save IPv4 address as deprecated IPv6 compatible */ - xent->k.addr6.s6_addr32[3] = n->addr.sin_addr.s_addr; + xent->k.addr6.s6_addr32[0] = n->addr.sin_addr.s_addr; xent->flags = IPFW_TCF_INET; xent->value = n->value; + xent->bytes = n->bytes; + xent->packets = n->packets; + xent->timestamp = n->timestamp; + xent->mac_addr = n->mac_addr; tbl->cnt++; return (0); } @@ -742,6 +948,10 @@ dump_table_xentry_extended(struct radix_node *rn, void *arg) } xent->value = n->value; + xent->bytes = n->bytes; + xent->packets = n->packets; + xent->timestamp = n->timestamp; + xent->mac_addr = n->mac_addr; tbl->cnt++; return (0); } diff --git a/sys/netpfil/pf/if_pflog.c b/sys/netpfil/pf/if_pflog.c index 1efd5e2..5c22806 100644 --- a/sys/netpfil/pf/if_pflog.c +++ b/sys/netpfil/pf/if_pflog.c @@ -209,7 +209,7 @@ pflog_packet(struct pfi_kif *kif, struct mbuf *m, sa_family_t af, u_int8_t dir, return (0); bzero(&hdr, sizeof(hdr)); - hdr.length = PFLOG_REAL_HDRLEN; + hdr.length = PFLOG_HDRLEN; hdr.af = af; hdr.action = rm->action; hdr.reason = reason; @@ -218,13 +218,16 @@ pflog_packet(struct pfi_kif *kif, struct mbuf *m, sa_family_t af, u_int8_t dir, if (am == NULL) { hdr.rulenr = htonl(rm->nr); hdr.subrulenr = 1; + hdr.ridentifier = rm->cuid; } else { hdr.rulenr = htonl(am->nr); hdr.subrulenr = htonl(rm->nr); + hdr.ridentifier = rm->cuid; if (ruleset != NULL && ruleset->anchor != NULL) strlcpy(hdr.ruleset, ruleset->anchor->name, sizeof(hdr.ruleset)); } +#ifdef PF_USER_INFO /* * XXXGL: we avoid pf_socket_lookup() when we are holding * state lock, since this leads to unsafe LOR. @@ -239,6 +242,7 @@ pflog_packet(struct pfi_kif *kif, struct mbuf *m, sa_family_t af, u_int8_t dir, hdr.pid = NO_PID; hdr.rule_uid = rm->cuid; hdr.rule_pid = rm->cpid; +#endif hdr.dir = dir; #ifdef INET diff --git a/sys/netpfil/pf/if_pfsync.c b/sys/netpfil/pf/if_pfsync.c index 90e6f8f..7936c07 100644 --- a/sys/netpfil/pf/if_pfsync.c +++ b/sys/netpfil/pf/if_pfsync.c @@ -185,9 +185,6 @@ struct pfsync_softc { struct ip_moptions sc_imo; struct in_addr sc_sync_peer; uint32_t sc_flags; -#define PFSYNCF_OK 0x00000001 -#define PFSYNCF_DEFER 0x00000002 -#define PFSYNCF_PUSH 0x00000004 uint8_t sc_maxupdates; struct ip sc_template; struct callout sc_tmo; @@ -365,7 +362,7 @@ pfsync_clone_destroy(struct ifnet *ifp) callout_drain(&sc->sc_bulkfail_tmo); callout_drain(&sc->sc_bulk_tmo); - if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p) + if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p && V_pfsync_carp_adj > 0) (*carp_demote_adj_p)(-V_pfsync_carp_adj, "pfsync destroy"); bpfdetach(ifp); if_detach(ifp); @@ -1150,7 +1147,7 @@ pfsync_in_bus(struct pfsync_pkt *pkt, struct mbuf *m, int offset, int count) sc->sc_ureq_sent = 0; sc->sc_bulk_tries = 0; callout_stop(&sc->sc_bulkfail_tmo); - if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p) + if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p && V_pfsync_carp_adj > 0) (*carp_demote_adj_p)(-V_pfsync_carp_adj, "pfsync bulk done"); sc->sc_flags |= PFSYNCF_OK; @@ -1308,8 +1305,7 @@ pfsyncioctl(struct ifnet *ifp, u_long cmd, caddr_t data) } pfsyncr.pfsyncr_syncpeer = sc->sc_sync_peer; pfsyncr.pfsyncr_maxupdates = sc->sc_maxupdates; - pfsyncr.pfsyncr_defer = (PFSYNCF_DEFER == - (sc->sc_flags & PFSYNCF_DEFER)); + pfsyncr.pfsyncr_defer = sc->sc_flags; PFSYNC_UNLOCK(sc); return (copyout(&pfsyncr, ifr->ifr_data, sizeof(pfsyncr))); @@ -1401,7 +1397,7 @@ pfsyncioctl(struct ifnet *ifp, u_long cmd, caddr_t data) ip->ip_dst.s_addr = sc->sc_sync_peer.s_addr; /* Request a full state table update. */ - if ((sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p) + if ((sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p && V_pfsync_carp_adj > 0) (*carp_demote_adj_p)(V_pfsync_carp_adj, "pfsync bulk start"); sc->sc_flags &= ~PFSYNCF_OK; @@ -1631,6 +1627,7 @@ pfsync_sendout(int schedswi) sc->sc_ifp->if_obytes += m->m_pkthdr.len; sc->sc_len = PFSYNC_MINPKT; + /* XXX: SHould not drop voluntarily update packets! */ if (!_IF_QFULL(&sc->sc_ifp->if_snd)) _IF_ENQUEUE(&sc->sc_ifp->if_snd, m); else { @@ -1776,7 +1773,7 @@ pfsync_undefer_state(struct pf_state *st, int drop) } } - panic("%s: unable to find deferred state", __func__); + printf("%s: unable to find deferred state", __func__); } static void @@ -2144,7 +2141,7 @@ pfsync_bulk_fail(void *arg) sc->sc_ureq_sent = 0; sc->sc_bulk_tries = 0; PFSYNC_LOCK(sc); - if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p) + if (!(sc->sc_flags & PFSYNCF_OK) && carp_demote_adj_p && V_pfsync_carp_adj > 0) (*carp_demote_adj_p)(-V_pfsync_carp_adj, "pfsync bulk fail"); sc->sc_flags |= PFSYNCF_OK; diff --git a/sys/netpfil/pf/pf.c b/sys/netpfil/pf/pf.c index 48da880..eed1ac8 100644 --- a/sys/netpfil/pf/pf.c +++ b/sys/netpfil/pf/pf.c @@ -62,6 +62,8 @@ __FBSDID("$FreeBSD$"); #include <net/if.h> #include <net/if_types.h> +#include <net/ethernet.h> +#include <net/if_vlan_var.h> #include <net/route.h> #include <net/radix_mpath.h> #include <net/vnet.h> @@ -86,6 +88,9 @@ __FBSDID("$FreeBSD$"); #include <netinet/udp_var.h> #include <netpfil/ipfw/ip_fw_private.h> /* XXX: only for DIR_IN/DIR_OUT */ +#include <netinet/ip_fw.h> +#include <netinet/ip_dummynet.h> +#include <netinet/ip_divert.h> #ifdef INET6 #include <netinet/ip6.h> @@ -226,6 +231,8 @@ static int pf_state_key_attach(struct pf_state_key *, static void pf_state_key_detach(struct pf_state *, int); static int pf_state_key_ctor(void *, int, void *, int); static u_int32_t pf_tcp_iss(struct pf_pdesc *); +void pf_rule_to_actions(struct pf_rule *, + struct pf_rule_actions *); static int pf_test_rule(struct pf_rule **, struct pf_state **, int, struct pfi_kif *, struct mbuf *, int, struct pf_pdesc *, struct pf_rule **, @@ -258,7 +265,8 @@ static int pf_test_state_icmp(struct pf_state **, int, struct pfi_kif *, struct mbuf *, int, void *, struct pf_pdesc *, u_short *); static int pf_test_state_other(struct pf_state **, int, - struct pfi_kif *, struct mbuf *, struct pf_pdesc *); + struct pfi_kif *, struct mbuf *, int, + struct pf_pdesc *); static u_int8_t pf_get_wscale(struct mbuf *, int, u_int16_t, sa_family_t); static u_int16_t pf_get_mss(struct mbuf *, int, u_int16_t, @@ -281,6 +289,10 @@ static u_int pf_purge_expired_states(u_int, int); static void pf_purge_unlinked_rules(void); static int pf_mtag_uminit(void *, int, int); static void pf_mtag_free(struct m_tag *); +static void pf_packet_redo_nat(struct mbuf *, struct pf_pdesc *, + int, struct pf_state *, int); +static void pf_packet_undo_nat(struct mbuf *, struct pf_pdesc *, + int, struct pf_state *, int); #ifdef INET static void pf_route(struct mbuf **, struct pf_rule *, int, struct ifnet *, struct pf_state *, @@ -300,28 +312,36 @@ VNET_DECLARE(int, pf_end_threads); VNET_DEFINE(struct pf_limit, pf_limits[PF_LIMIT_MAX]); -#define PACKET_LOOPED(pd) ((pd)->pf_mtag && \ - (pd)->pf_mtag->flags & PF_PACKET_LOOPED) +#define PACKET_LOOPED(mtag) ((mtag)->flags & PF_PACKET_LOOPED) + +#define PF_DIVERT_MAXPACKETS_REACHED() \ +do { \ + if (r->spare2 && \ + s->packets[dir == PF_OUT] > r->spare2) \ + /* fake that divert already happened */ \ + pd.pf_mtag->flags |= PF_PACKET_LOOPED; \ +} while(0) #define STATE_LOOKUP(i, k, d, s, pd) \ do { \ (s) = pf_find_state((i), (k), (d)); \ if ((s) == NULL) \ return (PF_DROP); \ - if (PACKET_LOOPED(pd)) \ + if (PACKET_LOOPED(pd->pf_mtag)) { \ + if ((s)->key[PF_SK_WIRE] != (s)->key[PF_SK_STACK]) { \ + pf_packet_redo_nat(m, pd, off, s, direction); \ + } \ return (PF_PASS); \ + } \ if ((d) == PF_OUT && \ (((s)->rule.ptr->rt == PF_ROUTETO && \ - (s)->rule.ptr->direction == PF_OUT) || \ - ((s)->rule.ptr->rt == PF_REPLYTO && \ - (s)->rule.ptr->direction == PF_IN)) && \ + (s)->rule.ptr->direction == PF_OUT)) && \ (s)->rt_kif != NULL && \ (s)->rt_kif != (i)) \ return (PF_PASS); \ } while (0) -#define BOUND_IFACE(r, k) \ - ((r)->rule_flag & PFRULE_IFBOUND) ? (k) : V_pfi_all +#define BOUND_IFACE(r, k) k #define STATE_INC_COUNTERS(s) \ do { \ @@ -407,6 +427,160 @@ pf_addr_cmp(struct pf_addr *a, struct pf_addr *b, sa_family_t af) return (0); } +static void +pf_packet_undo_nat(struct mbuf *m, struct pf_pdesc *pd, int off, + struct pf_state *state, int direction) +{ + struct pf_state_key *nk; + + if (state == NULL || state->nat_rule.ptr == NULL) + return; + + if (state->nat_rule.ptr->action == PF_RDR || + state->nat_rule.ptr->action == PF_BINAT) + nk = (state)->key[PF_SK_WIRE]; + else + nk = (state)->key[PF_SK_STACK]; + + switch (pd->proto) { + case IPPROTO_TCP: { + struct tcphdr *th = pd->hdr.tcp; + + if (direction == PF_OUT) { + pf_change_ap(m, pd->src, &th->th_sport, pd->ip_sum, + &th->th_sum, &nk->addr[pd->sidx], + nk->port[pd->sidx], 0, pd->af); + } else { + pf_change_ap(m, pd->dst, &th->th_dport, pd->ip_sum, + &th->th_sum, &nk->addr[pd->didx], + nk->port[pd->didx], 0, pd->af); + } + m_copyback(m, off, sizeof(*th), (caddr_t)th); + } + break; + case IPPROTO_UDP: { + struct udphdr *uh = pd->hdr.udp; + + if (direction == PF_OUT) { + pf_change_ap(m, pd->src, &uh->uh_sport, pd->ip_sum, + &uh->uh_sum, &nk->addr[pd->sidx], + nk->port[pd->sidx], 1, pd->af); + } else { + pf_change_ap(m, pd->dst, &uh->uh_dport, pd->ip_sum, + &uh->uh_sum, &nk->addr[pd->didx], + nk->port[pd->didx], 1, pd->af); + } + m_copyback(m, off, sizeof(*uh), (caddr_t)uh); + } + break; + /* case IPPROTO_ICMP: */ + /* XXX: If we want to do this for icmp is probably wrong!?! */ + /* break; */ + default: + if (direction == PF_OUT) { + switch (pd->af) { + case AF_INET: + pf_change_a(&pd->src->v4.s_addr, + pd->ip_sum, nk->addr[pd->sidx].v4.s_addr, + 0); + break; + case AF_INET6: + PF_ACPY(pd->src, &nk->addr[pd->sidx], pd->af); + break; + } + } else { + switch (pd->af) { + case AF_INET: + pf_change_a(&pd->dst->v4.s_addr, + pd->ip_sum, nk->addr[pd->didx].v4.s_addr, + 0); + break; + case AF_INET6: + PF_ACPY(pd->dst, &nk->addr[pd->didx], pd->af); + break; + } + } + break; + } +} + +static void +pf_packet_redo_nat(struct mbuf *m, struct pf_pdesc *pd, int off, + struct pf_state *state, int direction) +{ + struct pf_state_key *nk; + + if (state == NULL || state->nat_rule.ptr == NULL) + return; + + if (state->nat_rule.ptr->action == PF_RDR || + state->nat_rule.ptr->action == PF_BINAT) + nk = (state)->key[PF_SK_STACK]; + else + nk = (state)->key[PF_SK_WIRE]; + + switch (pd->proto) { + case IPPROTO_TCP: { + struct tcphdr *th = pd->hdr.tcp; + + if (direction == PF_OUT) { + pf_change_ap(m, pd->src, &th->th_sport, pd->ip_sum, + &th->th_sum, &nk->addr[pd->sidx], + nk->port[pd->sidx], 0, pd->af); + } else { + pf_change_ap(m, pd->dst, &th->th_dport, pd->ip_sum, + &th->th_sum, &nk->addr[pd->didx], + nk->port[pd->didx], 0, pd->af); + } + m_copyback(m, off, sizeof(*th), (caddr_t)th); + } + break; + case IPPROTO_UDP: { + struct udphdr *uh = pd->hdr.udp; + + if (direction == PF_OUT) { + pf_change_ap(m, pd->src, &uh->uh_sport, pd->ip_sum, + &uh->uh_sum, &nk->addr[pd->sidx], + nk->port[pd->sidx], 1, pd->af); + } else { + pf_change_ap(m, pd->dst, &uh->uh_dport, pd->ip_sum, + &uh->uh_sum, &nk->addr[pd->didx], + nk->port[pd->didx], 1, pd->af); + } + m_copyback(m, off, sizeof(*uh), (caddr_t)uh); + } + break; + /* case IPPROTO_ICMP: */ + /* XXX: If we want to do this for icmp is probably wrong!?! */ + /* break; */ + default: + if (direction == PF_OUT) { + switch (pd->af) { + case AF_INET: + pf_change_a(&pd->src->v4.s_addr, + pd->ip_sum, nk->addr[pd->sidx].v4.s_addr, + 0); + break; + case AF_INET6: + PF_ACPY(pd->src, &nk->addr[pd->sidx], pd->af); + break; + } + } else { + switch (pd->af) { + case AF_INET: + pf_change_a(&pd->dst->v4.s_addr, + pd->ip_sum, nk->addr[pd->didx].v4.s_addr, + 0); + break; + case AF_INET6: + PF_ACPY(pd->dst, &nk->addr[pd->didx], pd->af); + break; + } + } + break; + } +} + static __inline uint32_t pf_hashkey(struct pf_state_key *sk) { @@ -440,6 +614,20 @@ pf_hashsrc(struct pf_addr *addr, sa_family_t af) return (h & pf_srchashmask); } +#ifdef ALTQ +static int +pf_state_hash(struct pf_state *s) +{ + u_int32_t hv = (intptr_t)s / sizeof(*s); + + hv ^= crc32(&s->src, sizeof(s->src)); + hv ^= crc32(&s->dst, sizeof(s->dst)); + if (hv == 0) + hv = 1; + return (hv); +} +#endif + #ifdef INET6 void pf_addrcpy(struct pf_addr *dst, struct pf_addr *src, sa_family_t af) @@ -1285,7 +1473,7 @@ pf_find_state(struct pfi_kif *kif, struct pf_state_key_cmp *key, u_int dir) /* List is sorted, if-bound states before floating ones. */ TAILQ_FOREACH(s, &sk->states[idx], key_list[idx]) - if (s->kif == V_pfi_all || s->kif == kif) { + { PF_STATE_LOCK(s); PF_HASHROW_UNLOCK(kh); if (s->timeout >= PFTM_MAX) { @@ -1971,9 +2159,9 @@ pf_addr_wrap_neq(struct pf_addr_wrap *aw1, struct pf_addr_wrap *aw2) switch (aw1->type) { case PF_ADDR_ADDRMASK: case PF_ADDR_RANGE: - if (PF_ANEQ(&aw1->v.a.addr, &aw2->v.a.addr, 0)) + if (PF_ANEQ(&aw1->v.a.addr, &aw2->v.a.addr, AF_INET6)) return (1); - if (PF_ANEQ(&aw1->v.a.mask, &aw2->v.a.mask, 0)) + if (PF_ANEQ(&aw1->v.a.mask, &aw2->v.a.mask, AF_INET6)) return (1); return (0); case PF_ADDR_DYNIFTL: @@ -2440,6 +2628,26 @@ pf_send_tcp(struct mbuf *replyto, const struct pf_rule *r, sa_family_t af, pf_send(pfse); } +int +pf_ieee8021q_setpcp(struct mbuf *m, struct pf_rule *r) +{ + struct m_tag *mtag; + + KASSERT(r->ieee8021q_pcp.setpcp & SETPCP_VALID, + ("%s with invalid setpcp", __func__)); + + mtag = m_tag_locate(m, MTAG_8021Q, MTAG_8021Q_PCP_OUT, NULL); + if (mtag == NULL) { + mtag = m_tag_alloc(MTAG_8021Q, MTAG_8021Q_PCP_OUT, + sizeof(uint8_t), M_NOWAIT); + if (mtag == NULL) + return (ENOMEM); + m_tag_prepend(m, mtag); + } + *(uint8_t *)(mtag + 1) = (r->ieee8021q_pcp.setpcp & SETPCP_PCP_MASK); + return (0); +} + static void pf_send_icmp(struct mbuf *m, u_int8_t type, u_int8_t code, sa_family_t af, struct pf_rule *r) @@ -2613,6 +2821,37 @@ pf_match_port(u_int8_t op, u_int16_t a1, u_int16_t a2, u_int16_t p) return (pf_match(op, a1, a2, p)); } +int +pf_match_ieee8021q_pcp(u_int8_t op, u_int8_t pcp1, u_int8_t pcp2, + struct mbuf *m) +{ + struct m_tag *mtag; + uint8_t mpcp; + + /* + * Packets without 802.1q headers are treated as having a PCP of 0 + * (best effort). + */ + mtag = m_tag_locate(m, MTAG_8021Q, MTAG_8021Q_PCP_IN, NULL); + if (mtag != NULL) + mpcp = *(uint8_t *)(mtag + 1); + else + mpcp = IEEE8021Q_PCP_BE; + + /* + * 802.1q uses a non-traditional ordering, in which 1 < 0, allowing + * default 0-tagged ("best effort") traffic to take precedence over + * 1-tagged ("background") traffic. Renumber both PCP arguments + * before making a comparison so that we can use boring arithmetic + * operators. + */ + pcp1 = ((pcp1 == 0) ? 1 : ((pcp1 == 1) ? 0 : pcp1)); + pcp2 = ((pcp2 == 0) ? 1 : ((pcp2 == 1) ? 0 : pcp2)); + mpcp = ((mpcp == 0) ? 1 : ((mpcp == 1) ? 0 : mpcp)); + return (pf_match(op, pcp1, pcp2, mpcp)); +} + +#ifdef PF_USER_INFO static int pf_match_uid(u_int8_t op, uid_t a1, uid_t a2, uid_t u) { @@ -2628,6 +2867,7 @@ pf_match_gid(u_int8_t op, gid_t a1, gid_t a2, gid_t g) return (0); return (pf_match(op, a1, a2, g)); } +#endif int pf_match_tag(struct mbuf *m, struct pf_rule *r, int *tag, int mtag) @@ -2821,6 +3061,22 @@ pf_addr_inc(struct pf_addr *addr, sa_family_t af) } #endif /* INET6 */ +void +pf_rule_to_actions(struct pf_rule *r, struct pf_rule_actions *a) +{ + if (r->qid) + a->qid = r->qid; + if (r->pqid) + a->pqid = r->pqid; + if (r->pdnpipe) + a->pdnpipe = r->pdnpipe; + if (r->dnpipe) + a->dnpipe = r->dnpipe; + if (r->free_flags & PFRULE_DN_IS_PIPE) + a->flags |= PFRULE_DN_IS_PIPE; +} + +#ifdef PF_USER_INFO int pf_socket_lookup(int direction, struct pf_pdesc *pd, struct mbuf *m) { @@ -2900,6 +3156,7 @@ pf_socket_lookup(int direction, struct pf_pdesc *pd, struct mbuf *m) return (1); } +#endif static u_int8_t pf_get_wscale(struct mbuf *m, int off, u_int16_t th_off, sa_family_t af) @@ -3091,12 +3348,14 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, PF_RULES_RASSERT(); +#ifdef PF_USER_INFO if (inp != NULL) { INP_LOCK_ASSERT(inp); pd->lookup.uid = inp->inp_cred->cr_uid; pd->lookup.gid = inp->inp_cred->cr_groups[0]; pd->lookup.done = 1; } +#endif switch (pd->proto) { case IPPROTO_TCP: @@ -3307,7 +3566,11 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, /* icmp only. type always 0 in other cases */ else if (r->code && r->code != icmpcode + 1) r = TAILQ_NEXT(r, entries); - else if (r->tos && !(r->tos == pd->tos)) + else if ((r->rule_flag & PFRULE_TOS) && r->tos && + !(r->tos == pd->tos)) + r = TAILQ_NEXT(r, entries); + else if ((r->rule_flag & PFRULE_DSCP) && r->tos && + !(r->tos == (pd->tos & DSCP_MASK))) r = TAILQ_NEXT(r, entries); else if (r->rule_flag & PFRULE_FRAGMENT) r = TAILQ_NEXT(r, entries); @@ -3315,6 +3578,7 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, (r->flagset & th->th_flags) != r->flags) r = TAILQ_NEXT(r, entries); /* tcp/udp only. uid.op always 0 in other cases */ +#ifdef PF_USER_INFO else if (r->uid.op && (pd->lookup.done || (pd->lookup.done = pf_socket_lookup(direction, pd, m), 1)) && !pf_match_uid(r->uid.op, r->uid.uid[0], r->uid.uid[1], @@ -3326,6 +3590,11 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, !pf_match_gid(r->gid.op, r->gid.gid[0], r->gid.gid[1], pd->lookup.gid)) r = TAILQ_NEXT(r, entries); +#endif + else if (r->ieee8021q_pcp.op && + !pf_match_ieee8021q_pcp(r->ieee8021q_pcp.op, + r->ieee8021q_pcp.pcp[0], r->ieee8021q_pcp.pcp[1], m)) + r = TAILQ_NEXT(r, entries); else if (r->prob && r->prob <= arc4random()) r = TAILQ_NEXT(r, entries); @@ -3343,10 +3612,20 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, if (r->rtableid >= 0) rtableid = r->rtableid; if (r->anchor == NULL) { - match = 1; - *rm = r; - *am = a; - *rsm = ruleset; + if (r->action == PF_MATCH) { + r->packets[direction == PF_OUT]++; + r->bytes[direction == PF_OUT] += pd->tot_len; + pf_rule_to_actions(r, &pd->act); + if (r->log) + PFLOG_PACKET(kif, m, af, + direction, PFRES_MATCH, r, + a, ruleset, pd, 1); + } else { + match = 1; + *rm = r; + *am = a; + *rsm = ruleset; + } if ((*rm)->quick) break; r = TAILQ_NEXT(r, entries); @@ -3365,6 +3644,9 @@ pf_test_rule(struct pf_rule **rm, struct pf_state **sm, int direction, REASON_SET(&reason, PFRES_MATCH); + /* apply actions for last matching pass/block rule */ + pf_rule_to_actions(r, &pd->act); + if (r->log || (nr != NULL && nr->log)) { if (rewrite) m_copyback(m, off, hdrlen, pd->hdr.any); @@ -3538,6 +3820,11 @@ pf_create_state(struct pf_rule *r, struct pf_rule *nr, struct pf_rule *a, s->state_flags |= PFSTATE_SLOPPY; s->log = r->log & PF_LOG_ALL; s->sync_state = PFSYNC_S_NONE; + s->qid = pd->act.qid; + s->pqid = pd->act.pqid; + s->pdnpipe = pd->act.pdnpipe; + s->dnpipe = pd->act.dnpipe; + s->state_flags |= pd->act.flags; if (nr != NULL) s->log |= nr->log & PF_LOG_ALL; switch (pd->proto) { @@ -3776,6 +4063,9 @@ pf_test_fragment(struct pf_rule **rm, int direction, struct pfi_kif *kif, r = r->skip[PF_SKIP_DST_ADDR].ptr; else if (r->tos && !(r->tos == pd->tos)) r = TAILQ_NEXT(r, entries); + else if ((r->rule_flag & PFRULE_DSCP) && r->tos && + !(r->tos == (pd->tos & DSCP_MASK))) + r = TAILQ_NEXT(r, entries); else if (r->os_fingerprint != PF_OSFP_ANY) r = TAILQ_NEXT(r, entries); else if (pd->proto == IPPROTO_UDP && @@ -3788,6 +4078,10 @@ pf_test_fragment(struct pf_rule **rm, int direction, struct pfi_kif *kif, pd->proto == IPPROTO_ICMPV6) && (r->type || r->code)) r = TAILQ_NEXT(r, entries); + else if (r->ieee8021q_pcp.op && + !pf_match_ieee8021q_pcp(r->ieee8021q_pcp.op, + r->ieee8021q_pcp.pcp[0], r->ieee8021q_pcp.pcp[1], m)) + r = TAILQ_NEXT(r, entries); else if (r->prob && r->prob <= (arc4random() % (UINT_MAX - 1) + 1)) r = TAILQ_NEXT(r, entries); @@ -3796,10 +4090,20 @@ pf_test_fragment(struct pf_rule **rm, int direction, struct pfi_kif *kif, r = TAILQ_NEXT(r, entries); else { if (r->anchor == NULL) { - match = 1; - *rm = r; - *am = a; - *rsm = ruleset; + if (r->action == PF_MATCH) { + r->packets[direction == PF_OUT]++; + r->bytes[direction == PF_OUT] += pd->tot_len; + pf_rule_to_actions(r, &pd->act); + if (r->log) + PFLOG_PACKET(kif, m, af, + direction, PFRES_MATCH, r, + a, ruleset, pd, 1); + } else { + match = 1; + *rm = r; + *am = a; + *rsm = ruleset; + } if ((*rm)->quick) break; r = TAILQ_NEXT(r, entries); @@ -3818,6 +4122,9 @@ pf_test_fragment(struct pf_rule **rm, int direction, struct pfi_kif *kif, REASON_SET(&reason, PFRES_MATCH); + /* apply actions for last matching pass/block rule */ + pf_rule_to_actions(r, &pd->act); + if (r->log) PFLOG_PACKET(kif, m, af, direction, reason, r, a, ruleset, pd, 1); @@ -5061,7 +5368,7 @@ pf_test_state_icmp(struct pf_state **state, int direction, struct pfi_kif *kif, static int pf_test_state_other(struct pf_state **state, int direction, struct pfi_kif *kif, - struct mbuf *m, struct pf_pdesc *pd) + struct mbuf *m, int off, struct pf_pdesc *pd) { struct pf_state_peer *src, *dst; struct pf_state_key_cmp key; @@ -5339,6 +5646,12 @@ pf_route(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp, ip = mtod(m0, struct ip *); + if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) { + if (s) + PF_STATE_UNLOCK(s); + return; + } + bzero(&dst, sizeof(dst)); dst.sin_family = AF_INET; dst.sin_len = sizeof(dst); @@ -5386,7 +5699,71 @@ pf_route(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp, if (ifp == NULL) goto bad; - if (oifp != ifp) { + else if (r->rt == PF_REPLYTO || (r->rt == PF_ROUTETO && ifp->if_type == IFT_ENC)) { + /* XXX: Copied from ifaof_ifpforaddr() since it mostly will not return NULL! */ + struct sockaddr_in inaddr; + struct sockaddr *addr; + struct ifaddr *ifa; + char *cp, *cp2, *cp3; + char *cplim; + + inaddr.sin_addr = ip->ip_dst; + inaddr.sin_family = AF_INET; + inaddr.sin_len = sizeof(inaddr); + inaddr.sin_port = 0; + addr = (struct sockaddr *)&inaddr; + + IF_ADDR_RLOCK(ifp); + TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { + if (ifa->ifa_addr->sa_family != AF_INET) + continue; + if (ifa->ifa_netmask == 0) { + if ((bcmp(addr, ifa->ifa_addr, addr->sa_len) == 0) || + (ifa->ifa_dstaddr && + (bcmp(addr, ifa->ifa_dstaddr, addr->sa_len) == 0))) { + IF_ADDR_RUNLOCK(ifp); + return; + } + continue; + } + if (ifp->if_flags & IFF_POINTOPOINT) { + if (bcmp(addr, ifa->ifa_dstaddr, addr->sa_len) == 0) { + IF_ADDR_RUNLOCK(ifp); + return; + } + } else { + cp = addr->sa_data; + cp2 = ifa->ifa_addr->sa_data; + cp3 = ifa->ifa_netmask->sa_data; + cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask; + for (; cp3 < cplim; cp3++) + if ((*cp++ ^ *cp2++) & *cp3) + break; + if (cp3 == cplim) { + IF_ADDR_RUNLOCK(ifp); + return; + } + } + } + IF_ADDR_RUNLOCK(ifp); + } + else if (r->rt == PF_ROUTETO && r->direction == dir && in_localip(ip->ip_dst)) + return; + + if (s != NULL && r->rt == PF_REPLYTO) { + /* + * Send it out since it came from state recorded ifp(rt_addr). + * Routing table lookup might have chosen not correct interface! + */ + } else if (oifp != ifp) { + if (in_broadcast(ip->ip_dst, oifp)) /* XXX: LOCKING of address list?! */ + return; + + if (s && r->rt == PF_ROUTETO && pd->nat_rule != NULL && + r->direction == PF_OUT && r->direction == dir && pd->pf_mtag->routed < 2) { + pf_packet_undo_nat(m0, pd, ntohs(ip->ip_off), s, dir); + } + if (pf_test(PF_OUT, ifp, &m0, NULL) != PF_PASS) goto bad; else if (m0 == NULL) @@ -5440,6 +5817,9 @@ pf_route(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp, error = EMSGSIZE; KMOD_IPSTAT_INC(ips_cantfrag); if (r->rt != PF_DUPTO) { + if (s && pd->nat_rule != NULL) + pf_packet_undo_nat(m0, pd, ntohs(ip->ip_off), s, dir); + icmp_error(m0, ICMP_UNREACH, ICMP_UNREACH_NEEDFRAG, 0, ifp->if_mtu); goto done; @@ -5519,6 +5899,12 @@ pf_route6(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp, ip6 = mtod(m0, struct ip6_hdr *); + if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) { + if (s) + PF_STATE_UNLOCK(s); + return; + } + bzero(&dst, sizeof(dst)); dst.sin6_family = AF_INET6; dst.sin6_len = sizeof(dst); @@ -5558,9 +5944,71 @@ pf_route6(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp, if (ifp == NULL) goto bad; + else if (r->rt == PF_REPLYTO) { + /* XXX: Copied from ifaof_ifpforaddr() since it mostly will not return NULL! */ + struct sockaddr_in6 inaddr6; + struct sockaddr *addr; + struct ifaddr *ifa; + char *cp, *cp2, *cp3; + char *cplim; + + inaddr6.sin6_addr = ip6->ip6_dst; + inaddr6.sin6_family = AF_INET6; + inaddr6.sin6_len = sizeof(inaddr6); + inaddr6.sin6_port = 0; + inaddr6.sin6_flowinfo = 0; + addr = (struct sockaddr *)&inaddr6; + + IF_ADDR_RLOCK(ifp); + TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { + if (ifa->ifa_addr->sa_family != AF_INET6) + continue; + if (ifa->ifa_netmask == 0) { + if ((bcmp(addr, ifa->ifa_addr, addr->sa_len) == 0) || + (ifa->ifa_dstaddr && + (bcmp(addr, ifa->ifa_dstaddr, addr->sa_len) == 0))) { + IF_ADDR_RUNLOCK(ifp); + return; + } + continue; + } + if (ifp->if_flags & IFF_POINTOPOINT) { + if (bcmp(addr, ifa->ifa_dstaddr, addr->sa_len) == 0) { + IF_ADDR_RUNLOCK(ifp); + return; + } + } else { + cp = addr->sa_data; + cp2 = ifa->ifa_addr->sa_data; + cp3 = ifa->ifa_netmask->sa_data; + cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask; + for (; cp3 < cplim; cp3++) + if ((*cp++ ^ *cp2++) & *cp3) + break; + if (cp3 == cplim) { + IF_ADDR_RUNLOCK(ifp); + return; + } + } + } + IF_ADDR_RUNLOCK(ifp); + } else if (r->rt == PF_ROUTETO && r->direction == dir && in6_localaddr(&ip6->ip6_dst)) + return; + + if (s != NULL && r->rt == PF_REPLYTO) { + /* + * Send it out since it came from state recorded ifp(rt_addr). + * Routing table lookup might have chosen not correct interface! + */ + } else if (oifp != ifp) { + + if (s && r->rt == PF_ROUTETO && pd->nat_rule != NULL && + r->direction == PF_OUT && r->direction == dir && pd->pf_mtag->routed < 2) { + int ip_off = ((caddr_t)ip6 - m0->m_data) + sizeof(struct ip6_hdr); + pf_packet_undo_nat(m0, pd, ip_off, s, dir); + } - if (oifp != ifp) { - if (pf_test6(PF_FWD, ifp, &m0, NULL) != PF_PASS) + if (pf_test6(PF_OUT, ifp, &m0, NULL) != PF_PASS) goto bad; else if (m0 == NULL) goto done; @@ -5593,9 +6041,12 @@ pf_route6(struct mbuf **m, struct pf_rule *r, int dir, struct ifnet *oifp, nd6_output(ifp, ifp, m0, &dst, NULL); else { in6_ifstat_inc(ifp, ifs6_in_toobig); - if (r->rt != PF_DUPTO) + if (r->rt != PF_DUPTO) { + if (s && pd->nat_rule != NULL) + pf_packet_undo_nat(m0, pd, ((caddr_t)ip6 - m0->m_data) + sizeof(struct ip6_hdr), s, dir); + icmp6_error(m0, ICMP6_PACKET_TOO_BIG, 0, ifp->if_mtu); - else + } else goto bad; } @@ -5761,7 +6212,11 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) struct pf_state *s = NULL; struct pf_ruleset *ruleset = NULL; struct pf_pdesc pd; - int off, dirndx, pqid = 0; + int off = 0, dirndx, pqid = 0; + int loopedfrom = 0; + u_int16_t divertcookie = 0; + u_int8_t divflags = 0; + struct ip_fw_args dnflow; M_ASSERTPKTHDR(m); @@ -5783,26 +6238,33 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) if (m->m_flags & M_SKIP_FIREWALL) return (PF_PASS); - pd.pf_mtag = pf_find_mtag(m); + pd.pf_mtag = pf_get_mtag(m); + if (pd.pf_mtag == NULL) { + REASON_SET(&reason, PFRES_MEMORY); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: dropping packet due to failed memory allocation for tags\n")); + return PF_DROP; + } PF_RULES_RLOCK(); - if (ip_divert_ptr != NULL && + if ((ip_divert_ptr != NULL || ip_dn_io_ptr != NULL) && ((ipfwtag = m_tag_locate(m, MTAG_IPFW_RULE, 0, NULL)) != NULL)) { struct ipfw_rule_ref *rr = (struct ipfw_rule_ref *)(ipfwtag+1); - if (rr->info & IPFW_IS_DIVERT && rr->rulenum == 0) { - if (pd.pf_mtag == NULL && - ((pd.pf_mtag = pf_get_mtag(m)) == NULL)) { - action = PF_DROP; - goto done; - } - pd.pf_mtag->flags |= PF_PACKET_LOOPED; - m_tag_delete(m, ipfwtag); + pd.pf_mtag->flags |= PF_PACKET_LOOPED; + if (rr->info & IPFW_IS_DUMMYNET) + loopedfrom = 1; + if (rr->info & IPFW_IS_DIVERT) { + divertcookie = rr->rulenum; + divflags = (u_int8_t)(divertcookie >> 8); + divertcookie &= ~PFSTATE_DIVERT_MASK; } if (pd.pf_mtag && pd.pf_mtag->flags & PF_FASTFWD_OURS_PRESENT) { m->m_flags |= M_FASTFWD_OURS; pd.pf_mtag->flags &= ~PF_FASTFWD_OURS_PRESENT; } + m_tag_delete(m, ipfwtag); } else if (pf_normalize_ip(m0, dir, kif, &reason, &pd) != PF_PASS) { /* We do IP header normalization and packet reassembly here */ action = PF_DROP; @@ -5845,6 +6307,10 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) struct tcphdr th; pd.hdr.tcp = &th; + dnflow.f_id._flags = th.th_flags; + dnflow.f_id.dst_port = ntohs(th.th_dport); + dnflow.f_id.src_port = ntohs(th.th_sport); + if (!pf_pull_hdr(m, off, &th, sizeof(th), &action, &reason, AF_INET)) { log = action != PF_PASS; @@ -5859,8 +6325,6 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) action = pf_test_state_tcp(&s, dir, kif, m, off, h, &pd, &reason); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -5874,6 +6338,9 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) struct udphdr uh; pd.hdr.udp = &uh; + dnflow.f_id.dst_port = ntohs(uh.uh_dport); + dnflow.f_id.src_port = ntohs(uh.uh_sport); + if (!pf_pull_hdr(m, off, &uh, sizeof(uh), &action, &reason, AF_INET)) { log = action != PF_PASS; @@ -5888,8 +6355,6 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) } action = pf_test_state_udp(&s, dir, kif, m, off, h, &pd); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -5911,8 +6376,6 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) action = pf_test_state_icmp(&s, dir, kif, m, off, h, &pd, &reason); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -5932,10 +6395,8 @@ pf_test(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) #endif default: - action = pf_test_state_other(&s, dir, kif, m, &pd); + action = pf_test_state_other(&s, dir, kif, m, off, &pd); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -5956,6 +6417,17 @@ done: ("pf: dropping packet with ip options\n")); } + if (s) { + PF_DIVERT_MAXPACKETS_REACHED(); + + if (divflags) { + s->divert_cookie = divertcookie; + s->local_flags |= divflags; + } else { + divertcookie = s->divert_cookie; + divflags = s->local_flags; + } + } if (s && s->tag > 0 && pf_tag_packet(m, &pd, s->tag)) { action = PF_DROP; REASON_SET(&reason, PFRES_MEMORY); @@ -5964,22 +6436,150 @@ done: M_SETFIB(m, r->rtableid); #ifdef ALTQ - if (action == PF_PASS && r->qid) { - if (pd.pf_mtag == NULL && - ((pd.pf_mtag = pf_get_mtag(m)) == NULL)) { - action = PF_DROP; - REASON_SET(&reason, PFRES_MEMORY); + if (s && s->qid) { + pd.act.pqid = s->pqid; + pd.act.qid = s->qid; + } else if (r->qid) { + pd.act.pqid = r->pqid; + pd.act.qid = r->qid; + } + if (action == PF_PASS && pd.act.qid) { + if (s != NULL) + pd.pf_mtag->qid_hash = pf_state_hash(s); + if (pqid || (pd.tos & IPTOS_LOWDELAY)) + pd.pf_mtag->qid = pd.act.pqid; + else + pd.pf_mtag->qid = pd.act.qid; + /* Add hints for ecn. */ + pd.pf_mtag->hdr = h; + } +#endif /* ALTQ */ + + if (divflags & PFSTATE_DIVERT_TAG) + pd.pf_mtag->tag = divertcookie; + else if (divflags & PFSTATE_DIVERT_ALTQ) + pd.pf_mtag->qid = divertcookie; + else if (divflags & PFSTATE_DIVERT_ACTION) { + struct pf_rule *dlr; + action = PF_DROP; + if (s) + pf_unlink_state(s, PF_ENTER_LOCKED); + REASON_SET(&reason, PFRES_DIVERT); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: changing action to with overload from divert.\n")); + dlr = r; + PFLOG_PACKET(kif, m, AF_INET, dir, reason, dlr, a, + ruleset, &pd, (s == NULL)); + m_freem(*m0); + *m0 = NULL; + /* NOTE: Fake this to avoid divert giving errors to the application. */ + return (PF_PASS); + } + + if (divflags & PFSTATE_DIVERT_DNCOOKIE) { + pd.act.dnpipe = divertcookie; + pd.act.pdnpipe = divertcookie; + pd.act.flags |= PFRULE_DN_IS_PIPE; + } else if (s && (s->dnpipe || s->pdnpipe)) { + pd.act.dnpipe = s->dnpipe; + pd.act.pdnpipe = s->pdnpipe; + pd.act.flags = s->state_flags; + } else if (r->dnpipe || r->pdnpipe) { + pd.act.dnpipe = r->dnpipe; + pd.act.dnpipe = r->pdnpipe; + pd.act.flags = r->free_flags; + } + + if (pd.act.dnpipe && ip_dn_io_ptr != NULL && loopedfrom != 1) { + if (dir != r->direction && pd.act.pdnpipe) { + dnflow.rule.info = pd.act.pdnpipe; + } else if (dir == r->direction) { + dnflow.rule.info = pd.act.dnpipe; + } else + goto continueprocessing; + + if (pd.act.flags & PFRULE_DN_IS_PIPE) + dnflow.rule.info |= IPFW_IS_PIPE; + dnflow.f_id.addr_type = 4; /* IPv4 type */ + dnflow.f_id.proto = pd.proto; + if (dir == PF_OUT && s != NULL && s->nat_rule.ptr != NULL && + s->nat_rule.ptr->action == PF_NAT) + dnflow.f_id.src_ip = + ntohl(s->key[(s->direction == PF_IN)]-> + addr[(s->direction == PF_OUT)].v4.s_addr); + else + dnflow.f_id.src_ip = ntohl(h->ip_src.s_addr); + dnflow.f_id.dst_ip = ntohl(h->ip_dst.s_addr); + dnflow.f_id.extra = dnflow.rule.info; + + if (m->m_flags & M_FASTFWD_OURS) { + pd.pf_mtag->flags |= PF_FASTFWD_OURS_PRESENT; + m->m_flags &= ~M_FASTFWD_OURS; + } + + if (s != NULL && s->nat_rule.ptr) + pf_packet_undo_nat(m, &pd, off, s, dir); + + ip_dn_io_ptr(m0, + (dir == PF_IN) ? DIR_IN : DIR_OUT, + &dnflow); + /* This is dummynet fast io processing */ + if (*m0 != NULL) { + m_tag_delete(*m0, m_tag_first(*m0)); + pd.pf_mtag->flags &= ~PF_PACKET_LOOPED; + if (s != NULL && s->nat_rule.ptr) + pf_packet_redo_nat(m, &pd, off, s, dir); } else { - if (pqid || (pd.tos & IPTOS_LOWDELAY)) - pd.pf_mtag->qid = r->pqid; - else - pd.pf_mtag->qid = r->qid; - /* Add hints for ecn. */ - pd.pf_mtag->hdr = h; + *m0 = NULL; + if (s) + PF_STATE_UNLOCK(s); + return (action); } + } +continueprocessing: + if (action == PF_PASS && r->divert.port && ip_divert_ptr != NULL && + !PACKET_LOOPED(&pd)) { + if (!r->spare2 || + (s && s->packets[dir == PF_OUT] <= r->spare2)) { + ipfwtag = m_tag_alloc(MTAG_IPFW_RULE, 0, + sizeof(struct ipfw_rule_ref), M_NOWAIT | M_ZERO); + if (ipfwtag != NULL) { + ((struct ipfw_rule_ref *)(ipfwtag+1))->info = + ntohs(r->divert.port); + ((struct ipfw_rule_ref *)(ipfwtag+1))->rulenum = dir; + + if (s) + PF_STATE_UNLOCK(s); + + m_tag_prepend(m, ipfwtag); + if (m->m_flags & M_FASTFWD_OURS) { + if (pd.pf_mtag == NULL && + ((pd.pf_mtag = pf_get_mtag(m)) == NULL)) { + action = PF_DROP; + REASON_SET(&reason, PFRES_MEMORY); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: failed to allocate tag\n")); + } + pd.pf_mtag->flags |= PF_FASTFWD_OURS_PRESENT; + m->m_flags &= ~M_FASTFWD_OURS; + } + ip_divert_ptr(*m0, dir == PF_IN ? DIR_IN : DIR_OUT); + *m0 = NULL; + + return (action); + } else { + /* XXX: ipfw has the same behaviour! */ + action = PF_DROP; + REASON_SET(&reason, PFRES_MEMORY); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: failed to allocate divert tag\n")); + } + } } -#endif /* ALTQ */ /* * connections redirected to loopback should not match sockets @@ -5990,50 +6590,17 @@ done: pd.proto == IPPROTO_UDP) && s != NULL && s->nat_rule.ptr != NULL && (s->nat_rule.ptr->action == PF_RDR || s->nat_rule.ptr->action == PF_BINAT) && - (ntohl(pd.dst->v4.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) + (ntohl(pd.dst->v4.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) { m->m_flags |= M_SKIP_FIREWALL; - if (action == PF_PASS && r->divert.port && ip_divert_ptr != NULL && - !PACKET_LOOPED(&pd)) { + if (PACKET_LOOPED(pd.pf_mtag) && !loopedfrom) + m->m_flags |= M_FASTFWD_OURS; + } - ipfwtag = m_tag_alloc(MTAG_IPFW_RULE, 0, - sizeof(struct ipfw_rule_ref), M_NOWAIT | M_ZERO); - if (ipfwtag != NULL) { - ((struct ipfw_rule_ref *)(ipfwtag+1))->info = - ntohs(r->divert.port); - ((struct ipfw_rule_ref *)(ipfwtag+1))->rulenum = dir; + pd.pf_mtag->flags &= ~PF_PACKET_LOOPED; - if (s) - PF_STATE_UNLOCK(s); - - m_tag_prepend(m, ipfwtag); - if (m->m_flags & M_FASTFWD_OURS) { - if (pd.pf_mtag == NULL && - ((pd.pf_mtag = pf_get_mtag(m)) == NULL)) { - action = PF_DROP; - REASON_SET(&reason, PFRES_MEMORY); - log = 1; - DPFPRINTF(PF_DEBUG_MISC, - ("pf: failed to allocate tag\n")); - } else { - pd.pf_mtag->flags |= - PF_FASTFWD_OURS_PRESENT; - m->m_flags &= ~M_FASTFWD_OURS; - } - } - ip_divert_ptr(*m0, dir == PF_IN ? DIR_IN : DIR_OUT); - *m0 = NULL; - - return (action); - } else { - /* XXX: ipfw has the same behaviour! */ - action = PF_DROP; - REASON_SET(&reason, PFRES_MEMORY); - log = 1; - DPFPRINTF(PF_DEBUG_MISC, - ("pf: failed to allocate divert tag\n")); - } - } + if (action == PF_PASS && s != NULL && pfsync_update_state_ptr != NULL) + pfsync_update_state_ptr(s); if (log) { struct pf_rule *lr; @@ -6134,7 +6701,10 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) struct pf_state *s = NULL; struct pf_ruleset *ruleset = NULL; struct pf_pdesc pd; - int off, terminal = 0, dirndx, rh_cnt = 0; + int off = 0, terminal = 0, dirndx, rh_cnt = 0; + int loopedfrom = 0; + struct m_tag *dn_tag; + struct ip_fw_args dnflow; int fwdir = dir; M_ASSERTPKTHDR(m); @@ -6145,18 +6715,27 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) * We do need to be careful about bridges. If the * net.link.bridge.pfil_bridge sysctl is set we can be filtering on a * bridge, so if the input interface is a bridge member and the output - * interface is its bridge we're not actually forwarding but bridging. + * interface is its bridge or a member of the same bridge we're not + * actually forwarding but bridging. */ - if (dir == PF_OUT && m->m_pkthdr.rcvif && ifp != m->m_pkthdr.rcvif - && (m->m_pkthdr.rcvif->if_bridge == NULL - || m->m_pkthdr.rcvif->if_bridge != ifp->if_softc)) + if (dir == PF_OUT && m->m_pkthdr.rcvif && ifp != m->m_pkthdr.rcvif && + (m->m_pkthdr.rcvif->if_bridge == NULL || + (m->m_pkthdr.rcvif->if_bridge != ifp->if_softc && + m->m_pkthdr.rcvif->if_bridge != ifp->if_bridge))) fwdir = PF_FWD; if (!V_pf_status.running) return (PF_PASS); memset(&pd, 0, sizeof(pd)); - pd.pf_mtag = pf_find_mtag(m); + pd.pf_mtag = pf_get_mtag(m); + if (pd.pf_mtag == NULL) { + REASON_SET(&reason, PFRES_MEMORY); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: dropping packet due to failed memory allocation for tags\n")); + return PF_DROP; + } if (pd.pf_mtag && pd.pf_mtag->flags & PF_TAG_GENERATED) return (PF_PASS); @@ -6175,8 +6754,20 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) PF_RULES_RLOCK(); + if (((ip_dn_io_ptr != NULL) || (ip_divert_ptr != NULL)) && + ((dn_tag = m_tag_locate(m, MTAG_IPFW_RULE, 0, NULL)) != NULL)) { + struct ipfw_rule_ref *rr = (struct ipfw_rule_ref *)(dn_tag+1); + pd.pf_mtag->flags |= PF_PACKET_LOOPED; + if (rr->info & IPFW_IS_DUMMYNET) + loopedfrom = 1; + if (pd.pf_mtag->flags & PF_FASTFWD_OURS_PRESENT) { + m->m_flags |= M_FASTFWD_OURS; + pd.pf_mtag->flags &= ~PF_FASTFWD_OURS_PRESENT; + } + m_tag_delete(m, dn_tag); + } /* We do IP header normalization and packet reassembly here */ - if (pf_normalize_ip6(m0, dir, kif, &reason, &pd) != PF_PASS) { + else if (pf_normalize_ip6(m0, dir, kif, &reason, &pd) != PF_PASS) { action = PF_DROP; goto done; } @@ -6285,6 +6876,10 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) struct tcphdr th; pd.hdr.tcp = &th; + dnflow.f_id._flags = th.th_flags; + dnflow.f_id.dst_port = th.th_dport; + dnflow.f_id.src_port = th.th_sport; + if (!pf_pull_hdr(m, off, &th, sizeof(th), &action, &reason, AF_INET6)) { log = action != PF_PASS; @@ -6297,8 +6892,6 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) action = pf_test_state_tcp(&s, dir, kif, m, off, h, &pd, &reason); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -6312,6 +6905,9 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) struct udphdr uh; pd.hdr.udp = &uh; + dnflow.f_id.dst_port = uh.uh_dport; + dnflow.f_id.src_port = uh.uh_sport; + if (!pf_pull_hdr(m, off, &uh, sizeof(uh), &action, &reason, AF_INET6)) { log = action != PF_PASS; @@ -6326,8 +6922,6 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) } action = pf_test_state_udp(&s, dir, kif, m, off, h, &pd); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -6356,8 +6950,6 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) action = pf_test_state_icmp(&s, dir, kif, m, off, h, &pd, &reason); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -6368,10 +6960,8 @@ pf_test6(int dir, struct ifnet *ifp, struct mbuf **m0, struct inpcb *inp) } default: - action = pf_test_state_other(&s, dir, kif, m, &pd); + action = pf_test_state_other(&s, dir, kif, m, off, &pd); if (action == PF_PASS) { - if (pfsync_update_state_ptr != NULL) - pfsync_update_state_ptr(s); r = s->rule.ptr; a = s->anchor.ptr; log = s->log; @@ -6405,23 +6995,99 @@ done: if (r->rtableid >= 0) M_SETFIB(m, r->rtableid); + if ((r->ieee8021q_pcp.setpcp & SETPCP_VALID) && + pf_ieee8021q_setpcp(m, r)) { + action = PF_DROP; + REASON_SET(&reason, PFRES_MEMORY); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: failed to allocate 802.1q mtag\n")); + } + + if ((r->ieee8021q_pcp.setpcp & SETPCP_VALID) && + pf_ieee8021q_setpcp(m, r)) { + action = PF_DROP; + REASON_SET(&reason, PFRES_MEMORY); + log = 1; + DPFPRINTF(PF_DEBUG_MISC, + ("pf: failed to allocate 802.1q mtag\n")); + } + #ifdef ALTQ - if (action == PF_PASS && r->qid) { - if (pd.pf_mtag == NULL && - ((pd.pf_mtag = pf_get_mtag(m)) == NULL)) { - action = PF_DROP; - REASON_SET(&reason, PFRES_MEMORY); - } else { - if (pd.tos & IPTOS_LOWDELAY) - pd.pf_mtag->qid = r->pqid; - else - pd.pf_mtag->qid = r->qid; - /* Add hints for ecn. */ - pd.pf_mtag->hdr = h; - } + if (s && s->qid) { + pd.act.pqid = s->pqid; + pd.act.qid = s->qid; + } else if (r->qid) { + pd.act.pqid = r->pqid; + pd.act.qid = r->qid; + } + if (action == PF_PASS && pd.act.qid) { + if (s != NULL) + pd.pf_mtag->qid_hash = pf_state_hash(s); + if (pd.tos & IPTOS_LOWDELAY) + pd.pf_mtag->qid = pd.act.pqid; + else + pd.pf_mtag->qid = pd.act.qid; + /* Add hints for ecn. */ + pd.pf_mtag->hdr = h; } #endif /* ALTQ */ + if (s && (s->dnpipe || s->pdnpipe)) { + pd.act.dnpipe = s->dnpipe; + pd.act.pdnpipe = s->pdnpipe; + pd.act.flags = s->state_flags; + } else if (r->dnpipe || r->pdnpipe) { + pd.act.dnpipe = r->dnpipe; + pd.act.dnpipe = r->pdnpipe; + pd.act.flags = r->free_flags; + } + if ((pd.act.dnpipe || pd.act.pdnpipe) && ip_dn_io_ptr != NULL && loopedfrom != 1) { + if (dir != r->direction && pd.act.pdnpipe) { + dnflow.rule.info = pd.act.pdnpipe; + } else if (dir == r->direction && pd.act.dnpipe) { + dnflow.rule.info = pd.act.dnpipe; + } else + goto continueprocessing6; + + if (pd.act.flags & PFRULE_DN_IS_PIPE) + dnflow.rule.info |= IPFW_IS_PIPE; + dnflow.f_id.addr_type = 6; /* IPv4 type */ + dnflow.f_id.proto = pd.proto; + dnflow.f_id.src_ip = 0; + dnflow.f_id.dst_ip = 0; + if (dir == PF_OUT && s != NULL && s->nat_rule.ptr != NULL && + s->nat_rule.ptr->action == PF_NAT) + dnflow.f_id.src_ip6 = s->key[(s->direction == PF_IN)]->addr[0].v6; + else + dnflow.f_id.src_ip6 = h->ip6_src; + dnflow.f_id.dst_ip6 = h->ip6_dst; + + if (s != NULL && s->nat_rule.ptr) + pf_packet_undo_nat(m, &pd, off, s, dir); + + ip_dn_io_ptr(m0, + ((dir == PF_IN) ? DIR_IN : DIR_OUT) | PROTO_IPV6, + &dnflow); + /* This is dummynet fast io processing */ + if (*m0 != NULL) { + m_tag_delete(*m0, m_tag_first(*m0)); + pd.pf_mtag->flags &= ~PF_PACKET_LOOPED; + if (s != NULL && s->nat_rule.ptr) + pf_packet_redo_nat(m, &pd, off, s, dir); + } else { + *m0 = NULL; + if (s) + PF_STATE_UNLOCK(s); + return (action); + } + } else + pd.pf_mtag->flags &= ~PF_PACKET_LOOPED; +continueprocessing6: + + if (action == PF_PASS && s != NULL && pfsync_update_state_ptr != NULL) + pfsync_update_state_ptr(s); + if (dir == PF_IN && action == PF_PASS && (pd.proto == IPPROTO_TCP || pd.proto == IPPROTO_UDP) && s != NULL && s->nat_rule.ptr != NULL && (s->nat_rule.ptr->action == PF_RDR || diff --git a/sys/netpfil/pf/pf.h b/sys/netpfil/pf/pf.h index 3a5d2aa..5351786 100644 --- a/sys/netpfil/pf/pf.h +++ b/sys/netpfil/pf/pf.h @@ -45,7 +45,8 @@ enum { PF_INOUT, PF_IN, PF_OUT, PF_FWD }; enum { PF_PASS, PF_DROP, PF_SCRUB, PF_NOSCRUB, PF_NAT, PF_NONAT, - PF_BINAT, PF_NOBINAT, PF_RDR, PF_NORDR, PF_SYNPROXY_DROP, PF_DEFER }; + PF_BINAT, PF_NOBINAT, PF_RDR, PF_NORDR, PF_SYNPROXY_DROP, PF_DEFER, + PF_MATCH }; enum { PF_RULESET_SCRUB, PF_RULESET_FILTER, PF_RULESET_NAT, PF_RULESET_BINAT, PF_RULESET_RDR, PF_RULESET_MAX }; enum { PF_OP_NONE, PF_OP_IRG, PF_OP_EQ, PF_OP_NE, PF_OP_LT, @@ -125,7 +126,8 @@ enum { PF_ADDR_ADDRMASK, PF_ADDR_NOROUTE, PF_ADDR_DYNIFTL, #define PFRES_MAXSTATES 12 /* State limit */ #define PFRES_SRCLIMIT 13 /* Source node/conn limit */ #define PFRES_SYNPROXY 14 /* SYN proxy */ -#define PFRES_MAX 15 /* total+1 */ +#define PFRES_DIVERT 15 /* Divert override */ +#define PFRES_MAX 16 /* total+1 */ #define PFRES_NAMES { \ "match", \ @@ -143,6 +145,7 @@ enum { PF_ADDR_ADDRMASK, PF_ADDR_NOROUTE, PF_ADDR_DYNIFTL, "state-limit", \ "src-limit", \ "synproxy", \ + "divert", \ NULL \ } diff --git a/sys/netpfil/pf/pf_altq.h b/sys/netpfil/pf/pf_altq.h index eda0965..3efd4ff 100644 --- a/sys/netpfil/pf/pf_altq.h +++ b/sys/netpfil/pf/pf_altq.h @@ -45,6 +45,12 @@ struct cbq_opts { int flags; }; +struct codel_opts { + u_int target; + u_int interval; + int ecn; +}; + struct priq_opts { int flags; }; @@ -65,6 +71,20 @@ struct hfsc_opts { int flags; }; +/* + * XXX this needs some work + */ +struct fairq_opts { + u_int nbuckets; + u_int hogs_m1; + int flags; + + /* link sharing service curve */ + u_int lssc_m1; + u_int lssc_d; + u_int lssc_m2; +}; + struct pf_altq { char ifname[IFNAMSIZ]; @@ -89,8 +109,10 @@ struct pf_altq { uint16_t flags; /* misc flags */ union { struct cbq_opts cbq_opts; + struct codel_opts codel_opts; struct priq_opts priq_opts; struct hfsc_opts hfsc_opts; + struct fairq_opts fairq_opts; } pq_u; uint32_t qid; /* return value */ diff --git a/sys/netpfil/pf/pf_ioctl.c b/sys/netpfil/pf/pf_ioctl.c index d91c851..146a56f 100644 --- a/sys/netpfil/pf/pf_ioctl.c +++ b/sys/netpfil/pf/pf_ioctl.c @@ -350,7 +350,9 @@ pf_empty_pool(struct pf_palist *poola) pfi_dynaddr_remove(pa->addr.p.dyn); break; case PF_ADDR_TABLE: - pfr_detach_table(pa->addr.p.tbl); + /* XXX: this could be unfinished pooladdr on pabuf */ + if (pa->addr.p.tbl != NULL) + pfr_detach_table(pa->addr.p.tbl); break; } if (pa->kif) @@ -1002,6 +1004,8 @@ pfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, struct thread *td case DIOCCLRRULECTRS: case DIOCGETLIMIT: case DIOCGETALTQS: + case DIOCGETNAMEDALTQ: + case DIOCGETNAMEDTAG: case DIOCGETALTQ: case DIOCGETQSTATS: case DIOCGETRULESETS: @@ -1048,6 +1052,8 @@ pfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, struct thread *td case DIOCGETTIMEOUT: case DIOCGETLIMIT: case DIOCGETALTQS: + case DIOCGETNAMEDALTQ: + case DIOCGETNAMEDTAG: case DIOCGETALTQ: case DIOCGETQSTATS: case DIOCGETRULESETS: @@ -1162,7 +1168,9 @@ pfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, struct thread *td rule->states_cur = counter_u64_alloc(M_WAITOK); rule->states_tot = counter_u64_alloc(M_WAITOK); rule->src_nodes = counter_u64_alloc(M_WAITOK); +#ifdef PF_USER_INFO rule->cuid = td->td_ucred->cr_ruid; +#endif rule->cpid = td->td_proc ? td->td_proc->p_pid : 0; TAILQ_INIT(&rule->rpool.list); @@ -1188,7 +1196,6 @@ pfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, struct thread *td V_ticket_pabuf)); ERROUT(EBUSY); } - tail = TAILQ_LAST(ruleset->rules[rs_num].inactive.ptr, pf_rulequeue); if (tail) @@ -1267,8 +1274,29 @@ pfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, struct thread *td } rule->rpool.cur = TAILQ_FIRST(&rule->rpool.list); +#ifndef PF_USER_INFO + if (rule->cuid) { + tail = TAILQ_FIRST(ruleset->rules[rs_num].active.ptr); + while ((tail != NULL) && (tail->cuid != rule->cuid)) + tail = TAILQ_NEXT(tail, entries); + if (tail != NULL) { + rule->evaluations = tail->evaluations; + rule->packets[0] = tail->packets[0]; + rule->packets[1] = tail->packets[1]; + rule->bytes[0] = tail->bytes[0]; + rule->bytes[1] = tail->bytes[1]; + } else { + rule->evaluations = rule->packets[0] = rule->packets[1] = + rule->bytes[0] = rule->bytes[1] = 0; + } + } else { + rule->evaluations = rule->packets[0] = rule->packets[1] = + rule->bytes[0] = rule->bytes[1] = 0; + } +#else rule->evaluations = rule->packets[0] = rule->packets[1] = rule->bytes[0] = rule->bytes[1] = 0; +#endif TAILQ_INSERT_TAIL(ruleset->rules[rs_num].inactive.ptr, rule, entries); ruleset->rules[rs_num].inactive.rcount++; @@ -1418,7 +1446,9 @@ DIOCADDRULE_error: newrule->states_cur = counter_u64_alloc(M_WAITOK); newrule->states_tot = counter_u64_alloc(M_WAITOK); newrule->src_nodes = counter_u64_alloc(M_WAITOK); +#ifdef PF_USER_INFO newrule->cuid = td->td_ucred->cr_ruid; +#endif newrule->cpid = td->td_proc ? td->td_proc->p_pid : 0; TAILQ_INIT(&newrule->rpool.list); } @@ -1705,6 +1735,30 @@ relock_DIOCKILLSTATES: break; } + case DIOCKILLSCHEDULE: { + struct pf_state *state; + struct pfioc_schedule_kill *psk = (struct pfioc_schedule_kill *)addr; + int killed = 0; + u_int i; + + for (i = 0; i <= pf_hashmask; i++) { + struct pf_idhash *ih = &V_pf_idhash[i]; + +relock_DIOCKILLSCHEDULE: + PF_HASHROW_LOCK(ih); + LIST_FOREACH(state, &ih->states, entry) { + if (!strcmp(psk->schedule, state->rule.ptr->schedule)) { + pf_unlink_state(state, PF_ENTER_LOCKED); + killed++; + goto relock_DIOCKILLSCHEDULE; + } + } + PF_HASHROW_UNLOCK(ih); + } + psk->numberkilled = killed; + break; + } + case DIOCADDSTATE: { struct pfioc_state *ps = (struct pfioc_state *)addr; struct pfsync_state *sp = &ps->state; @@ -2095,6 +2149,16 @@ DIOCGETSTATES_full: break; } + case DIOCGETNAMEDALTQ: { + struct pfioc_ruleset *pa = (struct pfioc_ruleset *)addr; + + if (pa->name[0]) { + pa->nr = pf_qname2qid(pa->name); + pf_qid_unref(pa->nr); + } + break; + } + case DIOCGETALTQS: { struct pfioc_altq *pa = (struct pfioc_altq *)addr; struct pf_altq *altq; @@ -2180,6 +2244,16 @@ DIOCGETSTATES_full: } #endif /* ALTQ */ + case DIOCGETNAMEDTAG: { + /* Little abuse. */ + struct pfioc_ruleset *pa = (struct pfioc_ruleset *)addr; + + if (pa->name[0]) + pa->nr = pf_tagname2tag(pa->name); + + break; + } + case DIOCBEGINADDRS: { struct pfioc_pooladdr *pp = (struct pfioc_pooladdr *)addr; @@ -3626,8 +3700,8 @@ hook_pf(void) pfh_inet = pfil_head_get(PFIL_TYPE_AF, AF_INET); if (pfh_inet == NULL) return (ESRCH); /* XXX */ - pfil_add_hook(pf_check_in, NULL, PFIL_IN | PFIL_WAITOK, pfh_inet); - pfil_add_hook(pf_check_out, NULL, PFIL_OUT | PFIL_WAITOK, pfh_inet); + pfil_add_named_hook(pf_check_in, NULL, "pf", PFIL_IN | PFIL_WAITOK, pfh_inet); + pfil_add_named_hook(pf_check_out, NULL, "pf", PFIL_OUT | PFIL_WAITOK, pfh_inet); #endif #ifdef INET6 pfh_inet6 = pfil_head_get(PFIL_TYPE_AF, AF_INET6); @@ -3640,8 +3714,10 @@ hook_pf(void) #endif return (ESRCH); /* XXX */ } - pfil_add_hook(pf_check6_in, NULL, PFIL_IN | PFIL_WAITOK, pfh_inet6); - pfil_add_hook(pf_check6_out, NULL, PFIL_OUT | PFIL_WAITOK, pfh_inet6); + pfil_add_named_hook(pf_check6_in, NULL, "pf", PFIL_IN | PFIL_WAITOK, + pfh_inet6); + pfil_add_named_hook(pf_check6_out, NULL, "pf", PFIL_OUT | PFIL_WAITOK, + pfh_inet6); #endif V_pf_pfil_hooked = 1; diff --git a/sys/netpfil/pf/pf_mtag.h b/sys/netpfil/pf/pf_mtag.h index 3aacb2e..fd8554a 100644 --- a/sys/netpfil/pf/pf_mtag.h +++ b/sys/netpfil/pf/pf_mtag.h @@ -44,6 +44,7 @@ struct pf_mtag { void *hdr; /* saved hdr pos in mbuf, for ECN */ u_int32_t qid; /* queue id */ + u_int32_t qid_hash; /* queue hashid used by WFQ like algos */ u_int16_t tag; /* tag id */ u_int8_t flags; u_int8_t routed; diff --git a/sys/netpfil/pf/pf_norm.c b/sys/netpfil/pf/pf_norm.c index 4f9a499..b925960 100644 --- a/sys/netpfil/pf/pf_norm.c +++ b/sys/netpfil/pf/pf_norm.c @@ -1151,6 +1151,7 @@ pf_refragment6(struct ifnet *ifp, struct mbuf **m0, struct m_tag *mtag) for (t = m; m; m = t) { t = m->m_nextpkt; m->m_nextpkt = NULL; + m->m_pkthdr.rcvif = ifp; m->m_flags |= M_SKIP_FIREWALL; memset(&pd, 0, sizeof(pd)); pd.pf_mtag = pf_find_mtag(m); diff --git a/sys/netpfil/pf/pf_ruleset.c b/sys/netpfil/pf/pf_ruleset.c index 384e42b..2274359 100644 --- a/sys/netpfil/pf/pf_ruleset.c +++ b/sys/netpfil/pf/pf_ruleset.c @@ -120,6 +120,7 @@ pf_get_ruleset_number(u_int8_t action) return (PF_RULESET_SCRUB); break; case PF_PASS: + case PF_MATCH: case PF_DROP: return (PF_RULESET_FILTER); break; diff --git a/sys/opencrypto/criov.c b/sys/opencrypto/criov.c index 96f0dfc..499bfe3 100644 --- a/sys/opencrypto/criov.c +++ b/sys/opencrypto/criov.c @@ -99,35 +99,31 @@ cuio_copyback(struct uio* uio, int off, int len, caddr_t cp) } /* - * Return a pointer to iov/offset of location in iovec list. + * Return the index and offset of location in iovec list. */ -struct iovec * +int cuio_getptr(struct uio *uio, int loc, int *off) { - struct iovec *iov = uio->uio_iov; - int iol = uio->uio_iovcnt; + int ind, len; - while (loc >= 0) { - /* Normal end of search */ - if (loc < iov->iov_len) { + ind = 0; + while (loc >= 0 && ind < uio->uio_iovcnt) { + len = uio->uio_iov[ind].iov_len; + if (len > loc) { *off = loc; - return (iov); + return (ind); } + loc -= len; + ind++; + } - loc -= iov->iov_len; - if (iol == 0) { - if (loc == 0) { - /* Point at the end of valid data */ - *off = iov->iov_len; - return (iov); - } else - return (NULL); - } else { - iov++, iol--; - } - } + if (ind > 0 && loc == 0) { + ind--; + *off = uio->uio_iov[ind].iov_len; + return (ind); + } - return (NULL); + return (-1); } /* @@ -196,3 +192,50 @@ crypto_apply(int flags, caddr_t buf, int off, int len, error = (*f)(arg, buf + off, len); return (error); } + +int +crypto_mbuftoiov(struct mbuf *mbuf, struct iovec **iovptr, int *cnt, + int *allocated) +{ + struct iovec *iov; + struct mbuf *m, *mtmp; + int i, j; + + *allocated = 0; + iov = *iovptr; + if (iov == NULL) + *cnt = 0; + + m = mbuf; + i = 0; + while (m != NULL) { + if (i == *cnt) { + /* we need to allocate a larger array */ + j = 1; + mtmp = m; + while ((mtmp = mtmp->m_next) != NULL) + j++; + iov = malloc(sizeof *iov * (i + j), M_CRYPTO_DATA, + M_NOWAIT); + if (iov == NULL) + return ENOMEM; + *allocated = 1; + *cnt = i + j; + memcpy(iov, *iovptr, sizeof *iov * i); + } + + iov[i].iov_base = m->m_data; + iov[i].iov_len = m->m_len; + + i++; + m = m->m_next; + } + + if (*allocated) + KASSERT(*cnt == i, ("did not allocate correct amount: %d != %d", + *cnt, i)); + + *iovptr = iov; + *cnt = i; + return 0; +} diff --git a/sys/opencrypto/crypto.c b/sys/opencrypto/crypto.c index 53c11e6..d084b77 100644 --- a/sys/opencrypto/crypto.c +++ b/sys/opencrypto/crypto.c @@ -57,7 +57,6 @@ __FBSDID("$FreeBSD$"); #define CRYPTO_TIMING /* enable timing support */ #include "opt_ddb.h" -#include "opt_kdtrace.h" #include <sys/param.h> #include <sys/systm.h> @@ -162,10 +161,10 @@ int crypto_userasymcrypto = 1; /* userland may do asym crypto reqs */ SYSCTL_INT(_kern, OID_AUTO, userasymcrypto, CTLFLAG_RW, &crypto_userasymcrypto, 0, "Enable/disable user-mode access to asymmetric crypto support"); -int crypto_devallowsoft = 0; /* only use hardware crypto for asym */ +int crypto_devallowsoft = 0; /* only use hardware crypto */ SYSCTL_INT(_kern, OID_AUTO, cryptodevallowsoft, CTLFLAG_RW, &crypto_devallowsoft, 0, - "Enable/disable use of software asym crypto support"); + "Enable/disable use of software crypto by /dev/crypto"); MALLOC_DEFINE(M_CRYPTO_DATA, "crypto", "crypto session records"); @@ -369,9 +368,8 @@ again: best = cap; } } - if (best != NULL) - return best; - if (match == CRYPTOCAP_F_HARDWARE && (flags & CRYPTOCAP_F_SOFTWARE)) { + if (best == NULL && match == CRYPTOCAP_F_HARDWARE && + (flags & CRYPTOCAP_F_SOFTWARE)) { /* sort of an Algol 68-style for loop */ match = CRYPTOCAP_F_SOFTWARE; goto again; @@ -422,9 +420,12 @@ crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int crid) (*sid) <<= 32; (*sid) |= (lid & 0xffffffff); cap->cc_sessions++; - } - } else + } else + CRYPTDEB("dev newsession failed"); + } else { + CRYPTDEB("no driver"); err = EINVAL; + } CRYPTO_DRIVER_UNLOCK(); return err; } @@ -1180,8 +1181,8 @@ crypto_kdone(struct cryptkop *krp) /* XXX: What if driver is loaded in the meantime? */ if (krp->krp_hid < crypto_drivers_num) { cap = &crypto_drivers[krp->krp_hid]; + KASSERT(cap->cc_koperations > 0, ("cc_koperations == 0")); cap->cc_koperations--; - KASSERT(cap->cc_koperations >= 0, ("cc_koperations < 0")); if (cap->cc_flags & CRYPTOCAP_F_CLEANUP) crypto_remove(cap); } diff --git a/sys/opencrypto/cryptodeflate.c b/sys/opencrypto/cryptodeflate.c index 2113611..f342a91 100644 --- a/sys/opencrypto/cryptodeflate.c +++ b/sys/opencrypto/cryptodeflate.c @@ -35,8 +35,6 @@ #include <sys/cdefs.h> __FBSDID("$FreeBSD$"); -#include "opt_kdtrace.h" - #include <sys/types.h> #include <sys/param.h> #include <sys/malloc.h> @@ -107,8 +105,8 @@ deflate_global(data, size, decomp, out) bufh = bufp = malloc(sizeof(*bufp) + (size_t)(size * i), M_CRYPTO_DATA, M_NOWAIT); if (bufp == NULL) { - SDT_PROBE3(opencrypto, deflate, deflate_global, bad, - decomp, 0, __LINE__); + SDT_PROBE5(opencrypto, deflate, deflate_global, bad, + decomp, 0, __LINE__, 0, 0); goto bad2; } bufp->next = NULL; @@ -127,8 +125,8 @@ deflate_global(data, size, decomp, out) deflateInit2(&zbuf, Z_DEFAULT_COMPRESSION, Z_METHOD, window_deflate, Z_MEMLEVEL, Z_DEFAULT_STRATEGY); if (error != Z_OK) { - SDT_PROBE3(opencrypto, deflate, deflate_global, bad, - decomp, error, __LINE__); + SDT_PROBE5(opencrypto, deflate, deflate_global, bad, + decomp, error, __LINE__, 0, 0); goto bad; } @@ -167,8 +165,8 @@ deflate_global(data, size, decomp, out) p = malloc(sizeof(*p) + (size_t)(size * i), M_CRYPTO_DATA, M_NOWAIT); if (p == NULL) { - SDT_PROBE3(opencrypto, deflate, deflate_global, - bad, decomp, 0, __LINE__); + SDT_PROBE5(opencrypto, deflate, deflate_global, + bad, decomp, 0, __LINE__, 0, 0); goto bad; } p->next = NULL; @@ -197,8 +195,8 @@ deflate_global(data, size, decomp, out) *out = malloc(result, M_CRYPTO_DATA, M_NOWAIT); if (*out == NULL) { - SDT_PROBE3(opencrypto, deflate, deflate_global, bad, - decomp, 0, __LINE__); + SDT_PROBE5(opencrypto, deflate, deflate_global, bad, + decomp, 0, __LINE__, 0, 0); goto bad; } if (decomp) diff --git a/sys/opencrypto/cryptodev.c b/sys/opencrypto/cryptodev.c index 44bfa5c..f5e80a0 100644 --- a/sys/opencrypto/cryptodev.c +++ b/sys/opencrypto/cryptodev.c @@ -3,6 +3,12 @@ /*- * Copyright (c) 2001 Theo de Raadt * Copyright (c) 2002-2006 Sam Leffler, Errno Consulting + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -54,10 +60,16 @@ __FBSDID("$FreeBSD$"); #include <sys/module.h> #include <sys/fcntl.h> #include <sys/bus.h> +#include <sys/user.h> +#include <sys/sdt.h> #include <opencrypto/cryptodev.h> #include <opencrypto/xform.h> +SDT_PROVIDER_DECLARE(opencrypto); + +SDT_PROBE_DEFINE1(opencrypto, dev, ioctl, error, "int"/*line number*/); + #ifdef COMPAT_FREEBSD32 #include <sys/mount.h> #include <compat/freebsd32/freebsd32.h> @@ -317,6 +329,8 @@ static int csefree(struct csession *); static int cryptodev_op(struct csession *, struct crypt_op *, struct ucred *, struct thread *td); +static int cryptodev_aead(struct csession *, struct crypt_aead *, + struct ucred *, struct thread *); static int cryptodev_key(struct crypt_kop *); static int cryptodev_find(struct crypt_find_op *); @@ -349,13 +363,24 @@ cryptof_truncate( * by device name/class or through search constraints. */ static int -checkforsoftware(int crid) +checkforsoftware(int *cridp) { - if (crid & CRYPTOCAP_F_SOFTWARE) - return EINVAL; /* XXX */ - if ((crid & CRYPTOCAP_F_HARDWARE) == 0 && - (crypto_getcaps(crid) & CRYPTOCAP_F_HARDWARE) == 0) - return EINVAL; /* XXX */ + int crid; + + crid = *cridp; + + if (!crypto_devallowsoft) { + if (crid & CRYPTOCAP_F_SOFTWARE) { + if (crid & CRYPTOCAP_F_HARDWARE) { + *cridp = CRYPTOCAP_F_HARDWARE; + return 0; + } + return EINVAL; + } + if ((crid & CRYPTOCAP_F_HARDWARE) == 0 && + (crypto_getcaps(crid) & CRYPTOCAP_F_HARDWARE) == 0) + return EINVAL; + } return 0; } @@ -374,6 +399,7 @@ cryptof_ioctl( struct csession *cse; struct session_op *sop; struct crypt_op *cop; + struct crypt_aead *caead; struct enc_xform *txform = NULL; struct auth_hash *thash = NULL; struct crypt_kop *kop; @@ -434,7 +460,15 @@ cryptof_ioctl( case CRYPTO_CAMELLIA_CBC: txform = &enc_xform_camellia; break; + case CRYPTO_AES_ICM: + txform = &enc_xform_aes_icm; + break; + case CRYPTO_AES_NIST_GCM_16: + txform = &enc_xform_aes_nist_gcm; + break; + default: + CRYPTDEB("invalid cipher"); return (EINVAL); } @@ -459,6 +493,16 @@ cryptof_ioctl( case CRYPTO_RIPEMD160_HMAC: thash = &auth_hash_hmac_ripemd_160; break; + case CRYPTO_AES_128_NIST_GMAC: + thash = &auth_hash_nist_gmac_aes_128; + break; + case CRYPTO_AES_192_NIST_GMAC: + thash = &auth_hash_nist_gmac_aes_192; + break; + case CRYPTO_AES_256_NIST_GMAC: + thash = &auth_hash_nist_gmac_aes_256; + break; + #ifdef notdef case CRYPTO_MD5: thash = &auth_hash_md5; @@ -471,6 +515,7 @@ cryptof_ioctl( thash = &auth_hash_null; break; default: + CRYPTDEB("invalid mac"); return (EINVAL); } @@ -482,6 +527,7 @@ cryptof_ioctl( crie.cri_klen = sop->keylen * 8; if (sop->keylen > txform->maxkey || sop->keylen < txform->minkey) { + CRYPTDEB("invalid cipher parameters"); error = EINVAL; goto bail; } @@ -489,8 +535,10 @@ cryptof_ioctl( crie.cri_key = malloc(crie.cri_klen / 8, M_XDATA, M_WAITOK); if ((error = copyin(sop->key, crie.cri_key, - crie.cri_klen / 8))) + crie.cri_klen / 8))) { + CRYPTDEB("invalid key"); goto bail; + } if (thash) crie.cri_next = &cria; } @@ -499,6 +547,7 @@ cryptof_ioctl( cria.cri_alg = thash->type; cria.cri_klen = sop->mackeylen * 8; if (sop->mackeylen != thash->keysize) { + CRYPTDEB("invalid mac key length"); error = EINVAL; goto bail; } @@ -507,8 +556,10 @@ cryptof_ioctl( cria.cri_key = malloc(cria.cri_klen / 8, M_XDATA, M_WAITOK); if ((error = copyin(sop->mackey, cria.cri_key, - cria.cri_klen / 8))) + cria.cri_klen / 8))) { + CRYPTDEB("invalid mac key"); goto bail; + } } } @@ -519,14 +570,18 @@ cryptof_ioctl( #endif ) { crid = SES2(sop)->crid; - error = checkforsoftware(crid); - if (error) + error = checkforsoftware(&crid); + if (error) { + CRYPTDEB("checkforsoftware"); goto bail; + } } else crid = CRYPTOCAP_F_HARDWARE; error = crypto_newsession(&sid, (txform ? &crie : &cria), crid); - if (error) + if (error) { + CRYPTDEB("crypto_newsession"); goto bail; + } cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen, cria.cri_key, cria.cri_klen, sop->cipher, sop->mac, txform, @@ -535,6 +590,7 @@ cryptof_ioctl( if (cse == NULL) { crypto_freesession(sid); error = EINVAL; + CRYPTDEB("csecreate"); goto bail; } sop->ses = cse->ses; @@ -581,8 +637,10 @@ bail: #endif cop = (struct crypt_op *)data; cse = csefind(fcr, cop->ses); - if (cse == NULL) + if (cse == NULL) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); return (EINVAL); + } error = cryptodev_op(cse, cop, active_cred, td); #ifdef COMPAT_FREEBSD32 if (error == 0 && cmd == CIOCCRYPT32) @@ -636,6 +694,13 @@ bail: case CIOCFINDDEV: error = cryptodev_find((struct crypt_find_op *)data); break; + case CIOCCRYPTAEAD: + caead = (struct crypt_aead *)data; + cse = csefind(fcr, caead->ses); + if (cse == NULL) + return (EINVAL); + error = cryptodev_aead(cse, caead, active_cred, td); + break; default: error = EINVAL; break; @@ -658,12 +723,16 @@ cryptodev_op( struct cryptodesc *crde = NULL, *crda = NULL; int error; - if (cop->len > 256*1024-4) + if (cop->len > 256*1024-4) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); return (E2BIG); + } if (cse->txform) { - if (cop->len == 0 || (cop->len % cse->txform->blocksize) != 0) + if (cop->len == 0 || (cop->len % cse->txform->blocksize) != 0) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); return (EINVAL); + } } cse->uio.uio_iov = &cse->iovec; @@ -683,6 +752,7 @@ cryptodev_op( crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL)); if (crp == NULL) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = ENOMEM; goto bail; } @@ -695,13 +765,17 @@ cryptodev_op( if (cse->txform) crde = crp->crp_desc; else { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = EINVAL; goto bail; } } - if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len))) + if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, + cop->len))) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); goto bail; + } if (crda) { crda->crd_skip = 0; @@ -736,15 +810,20 @@ cryptodev_op( if (cop->iv) { if (crde == NULL) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = EINVAL; goto bail; } if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */ + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = EINVAL; goto bail; } - if ((error = copyin(cop->iv, cse->tmp_iv, cse->txform->blocksize))) + if ((error = copyin(cop->iv, cse->tmp_iv, + cse->txform->blocksize))) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); goto bail; + } bcopy(cse->tmp_iv, crde->crd_iv, cse->txform->blocksize); crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT; crde->crd_skip = 0; @@ -757,6 +836,7 @@ cryptodev_op( } if (cop->mac && crda == NULL) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = EINVAL; goto bail; } @@ -775,8 +855,10 @@ again: error = msleep(crp, &cse->lock, PWAIT, "crydev", 0); mtx_unlock(&cse->lock); - if (error != 0) + if (error != 0) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); goto bail; + } if (crp->crp_etype == EAGAIN) { crp->crp_etype = 0; @@ -785,23 +867,30 @@ again: } if (crp->crp_etype != 0) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = crp->crp_etype; goto bail; } if (cse->error) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); error = cse->error; goto bail; } if (cop->dst && - (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, cop->len))) + (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, + cop->len))) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); goto bail; + } if (cop->mac && (error = copyout((caddr_t)cse->uio.uio_iov[0].iov_base + cop->len, - cop->mac, cse->thash->hashsize))) + cop->mac, cse->thash->hashsize))) { + SDT_PROBE1(opencrypto, dev, ioctl, error, __LINE__); goto bail; + } bail: if (crp) @@ -813,6 +902,151 @@ bail: } static int +cryptodev_aead( + struct csession *cse, + struct crypt_aead *caead, + struct ucred *active_cred, + struct thread *td) +{ + struct uio *uio; + struct cryptop *crp = NULL; + struct cryptodesc *crde = NULL, *crda = NULL; + int error; + + if (caead->len > 256*1024-4 || caead->aadlen > 256*1024-4) + return (E2BIG); + + if (cse->txform == NULL || cse->thash == NULL || caead->tag == NULL || + (caead->len % cse->txform->blocksize) != 0) + return (EINVAL); + + uio = &cse->uio; + uio->uio_iov = &cse->iovec; + uio->uio_iovcnt = 1; + uio->uio_offset = 0; + uio->uio_resid = caead->len + caead->aadlen + cse->thash->hashsize; + uio->uio_segflg = UIO_SYSSPACE; + uio->uio_rw = UIO_WRITE; + uio->uio_td = td; + uio->uio_iov[0].iov_len = uio->uio_resid; + + uio->uio_iov[0].iov_base = malloc(uio->uio_iov[0].iov_len, + M_XDATA, M_WAITOK); + + crp = crypto_getreq(2); + if (crp == NULL) { + error = ENOMEM; + goto bail; + } + + crda = crp->crp_desc; + crde = crda->crd_next; + + if ((error = copyin(caead->src, cse->uio.uio_iov[0].iov_base, + caead->len))) + goto bail; + + if ((error = copyin(caead->aad, (char *)cse->uio.uio_iov[0].iov_base + + caead->len, caead->aadlen))) + goto bail; + + crda->crd_skip = caead->len; + crda->crd_len = caead->aadlen; + crda->crd_inject = caead->len + caead->aadlen; + + crda->crd_alg = cse->mac; + crda->crd_key = cse->mackey; + crda->crd_klen = cse->mackeylen * 8; + + if (caead->op == COP_ENCRYPT) + crde->crd_flags |= CRD_F_ENCRYPT; + else + crde->crd_flags &= ~CRD_F_ENCRYPT; + /* crde->crd_skip set below */ + crde->crd_len = caead->len; + crde->crd_inject = 0; + + crde->crd_alg = cse->cipher; + crde->crd_key = cse->key; + crde->crd_klen = cse->keylen * 8; + + crp->crp_ilen = caead->len + caead->aadlen; + crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM + | (caead->flags & COP_F_BATCH); + crp->crp_buf = (caddr_t)&cse->uio.uio_iov; + crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb; + crp->crp_sid = cse->sid; + crp->crp_opaque = (void *)cse; + + if (caead->iv) { + if (caead->ivlen > sizeof cse->tmp_iv) { + error = EINVAL; + goto bail; + } + + if ((error = copyin(caead->iv, cse->tmp_iv, caead->ivlen))) + goto bail; + bcopy(cse->tmp_iv, crde->crd_iv, caead->ivlen); + crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT; + crde->crd_skip = 0; + } else { + crde->crd_flags |= CRD_F_IV_PRESENT; + crde->crd_skip = cse->txform->blocksize; + crde->crd_len -= cse->txform->blocksize; + } + + if ((error = copyin(caead->tag, (caddr_t)cse->uio.uio_iov[0].iov_base + + caead->len + caead->aadlen, cse->thash->hashsize))) + goto bail; +again: + /* + * Let the dispatch run unlocked, then, interlock against the + * callback before checking if the operation completed and going + * to sleep. This insures drivers don't inherit our lock which + * results in a lock order reversal between crypto_dispatch forced + * entry and the crypto_done callback into us. + */ + error = crypto_dispatch(crp); + mtx_lock(&cse->lock); + if (error == 0 && (crp->crp_flags & CRYPTO_F_DONE) == 0) + error = msleep(crp, &cse->lock, PWAIT, "crydev", 0); + mtx_unlock(&cse->lock); + + if (error != 0) + goto bail; + + if (crp->crp_etype == EAGAIN) { + crp->crp_etype = 0; + crp->crp_flags &= ~CRYPTO_F_DONE; + goto again; + } + + if (crp->crp_etype != 0) { + error = crp->crp_etype; + goto bail; + } + + if (cse->error) { + error = cse->error; + goto bail; + } + + if (caead->dst && (error = copyout(cse->uio.uio_iov[0].iov_base, + caead->dst, caead->len))) + goto bail; + + if ((error = copyout((caddr_t)cse->uio.uio_iov[0].iov_base + + caead->len + caead->aadlen, caead->tag, cse->thash->hashsize))) + goto bail; + +bail: + crypto_freereq(crp); + free(cse->uio.uio_iov[0].iov_base, M_XDATA); + + return (error); +} + +static int cryptodev_cb(void *op) { struct cryptop *crp = (struct cryptop *) op; @@ -941,14 +1175,16 @@ static int cryptodev_find(struct crypt_find_op *find) { device_t dev; + size_t fnlen = sizeof find->name; if (find->crid != -1) { dev = crypto_find_device_byhid(find->crid); if (dev == NULL) return (ENOENT); - strlcpy(find->name, device_get_nameunit(dev), - sizeof(find->name)); + strncpy(find->name, device_get_nameunit(dev), fnlen); + find->name[fnlen - 1] = '\x0'; } else { + find->name[fnlen - 1] = '\x0'; find->crid = crypto_find_driver(find->name); if (find->crid == -1) return (ENOENT); @@ -1044,12 +1280,7 @@ csecreate(struct fcrypt *fcr, u_int64_t sid, caddr_t key, u_int64_t keylen, { struct csession *cse; -#ifdef INVARIANTS - /* NB: required when mtx_init is built with INVARIANTS */ cse = malloc(sizeof(struct csession), M_XDATA, M_NOWAIT | M_ZERO); -#else - cse = malloc(sizeof(struct csession), M_XDATA, M_NOWAIT); -#endif if (cse == NULL) return NULL; mtx_init(&cse->lock, "cryptodev", "crypto session lock", MTX_DEF); diff --git a/sys/opencrypto/cryptodev.h b/sys/opencrypto/cryptodev.h index e299522..d14fb3a 100644 --- a/sys/opencrypto/cryptodev.h +++ b/sys/opencrypto/cryptodev.h @@ -23,6 +23,12 @@ * PURPOSE. * * Copyright (c) 2001 Theo de Raadt + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -72,6 +78,7 @@ #define SHA2_512_HASH_LEN 64 #define MD5_KPDK_HASH_LEN 16 #define SHA1_KPDK_HASH_LEN 20 +#define AES_GMAC_HASH_LEN 16 /* Maximum hash algorithm result length */ #define HASH_MAX_LEN SHA2_512_HASH_LEN /* Keep this updated */ @@ -80,40 +87,87 @@ #define MD5_HMAC_BLOCK_LEN 64 #define SHA1_HMAC_BLOCK_LEN 64 #define RIPEMD160_HMAC_BLOCK_LEN 64 -#define SHA2_256_HMAC_BLOCK_LEN 64 -#define SHA2_384_HMAC_BLOCK_LEN 128 -#define SHA2_512_HMAC_BLOCK_LEN 128 +#define SHA2_256_HMAC_BLOCK_LEN 64 +#define SHA2_384_HMAC_BLOCK_LEN 128 +#define SHA2_512_HMAC_BLOCK_LEN 128 /* Maximum HMAC block length */ -#define HMAC_MAX_BLOCK_LEN SHA2_512_HMAC_BLOCK_LEN /* Keep this updated */ +#define HMAC_MAX_BLOCK_LEN SHA2_512_HMAC_BLOCK_LEN /* Keep this updated */ #define HMAC_IPAD_VAL 0x36 #define HMAC_OPAD_VAL 0x5C +/* HMAC Key Length */ +#define NULL_HMAC_KEY_LEN 0 +#define MD5_HMAC_KEY_LEN 16 +#define SHA1_HMAC_KEY_LEN 20 +#define RIPEMD160_HMAC_KEY_LEN 20 +#define SHA2_256_HMAC_KEY_LEN 32 +#define SHA2_384_HMAC_KEY_LEN 48 +#define SHA2_512_HMAC_KEY_LEN 64 +#define AES_128_GMAC_KEY_LEN 16 +#define AES_192_GMAC_KEY_LEN 24 +#define AES_256_GMAC_KEY_LEN 32 /* Encryption algorithm block sizes */ -#define NULL_BLOCK_LEN 4 -#define DES_BLOCK_LEN 8 -#define DES3_BLOCK_LEN 8 -#define BLOWFISH_BLOCK_LEN 8 -#define SKIPJACK_BLOCK_LEN 8 -#define CAST128_BLOCK_LEN 8 -#define RIJNDAEL128_BLOCK_LEN 16 -#define AES_BLOCK_LEN RIJNDAEL128_BLOCK_LEN -#define CAMELLIA_BLOCK_LEN 16 -#define EALG_MAX_BLOCK_LEN AES_BLOCK_LEN /* Keep this updated */ +#define NULL_BLOCK_LEN 4 /* IPsec to maintain alignment */ +#define DES_BLOCK_LEN 8 +#define DES3_BLOCK_LEN 8 +#define BLOWFISH_BLOCK_LEN 8 +#define SKIPJACK_BLOCK_LEN 8 +#define CAST128_BLOCK_LEN 8 +#define RIJNDAEL128_BLOCK_LEN 16 +#define AES_BLOCK_LEN 16 +#define AES_ICM_BLOCK_LEN 1 +#define ARC4_BLOCK_LEN 1 +#define CAMELLIA_BLOCK_LEN 16 +#define EALG_MAX_BLOCK_LEN AES_BLOCK_LEN /* Keep this updated */ + +/* IV Lengths */ + +#define ARC4_IV_LEN 1 +#define AES_GCM_IV_LEN 12 +#define AES_XTS_IV_LEN 8 +#define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ + +/* Min and Max Encryption Key Sizes */ +#define NULL_MIN_KEY 0 +#define NULL_MAX_KEY 256 /* 2048 bits, max key */ +#define DES_MIN_KEY 8 +#define DES_MAX_KEY DES_MIN_KEY +#define TRIPLE_DES_MIN_KEY 24 +#define TRIPLE_DES_MAX_KEY TRIPLE_DES_MIN_KEY +#define BLOWFISH_MIN_KEY 5 +#define BLOWFISH_MAX_KEY 56 /* 448 bits, max key */ +#define CAST_MIN_KEY 5 +#define CAST_MAX_KEY 16 +#define SKIPJACK_MIN_KEY 10 +#define SKIPJACK_MAX_KEY SKIPJACK_MIN_KEY +#define RIJNDAEL_MIN_KEY 16 +#define RIJNDAEL_MAX_KEY 32 +#define AES_MIN_KEY RIJNDAEL_MIN_KEY +#define AES_MAX_KEY RIJNDAEL_MAX_KEY +#define AES_XTS_MIN_KEY (2 * AES_MIN_KEY) +#define AES_XTS_MAX_KEY (2 * AES_MAX_KEY) +#define ARC4_MIN_KEY 1 +#define ARC4_MAX_KEY 32 +#define CAMELLIA_MIN_KEY 8 +#define CAMELLIA_MAX_KEY 32 + +/* Maximum hash algorithm result length */ +#define AALG_MAX_RESULT_LEN 64 /* Keep this updated */ #define CRYPTO_ALGORITHM_MIN 1 -#define CRYPTO_DES_CBC 1 -#define CRYPTO_3DES_CBC 2 -#define CRYPTO_BLF_CBC 3 -#define CRYPTO_CAST_CBC 4 -#define CRYPTO_SKIPJACK_CBC 5 -#define CRYPTO_MD5_HMAC 6 -#define CRYPTO_SHA1_HMAC 7 -#define CRYPTO_RIPEMD160_HMAC 8 -#define CRYPTO_MD5_KPDK 9 -#define CRYPTO_SHA1_KPDK 10 -#define CRYPTO_RIJNDAEL128_CBC 11 /* 128 bit blocksize */ -#define CRYPTO_AES_CBC 11 /* 128 bit blocksize -- the same as above */ -#define CRYPTO_ARC4 12 +#define CRYPTO_DES_CBC 1 +#define CRYPTO_3DES_CBC 2 +#define CRYPTO_BLF_CBC 3 +#define CRYPTO_CAST_CBC 4 +#define CRYPTO_SKIPJACK_CBC 5 +#define CRYPTO_MD5_HMAC 6 +#define CRYPTO_SHA1_HMAC 7 +#define CRYPTO_RIPEMD160_HMAC 8 +#define CRYPTO_MD5_KPDK 9 +#define CRYPTO_SHA1_KPDK 10 +#define CRYPTO_RIJNDAEL128_CBC 11 /* 128 bit blocksize */ +#define CRYPTO_AES_CBC 11 /* 128 bit blocksize -- the same as above */ +#define CRYPTO_ARC4 12 #define CRYPTO_MD5 13 #define CRYPTO_SHA1 14 #define CRYPTO_NULL_HMAC 15 @@ -122,9 +176,18 @@ #define CRYPTO_SHA2_256_HMAC 18 #define CRYPTO_SHA2_384_HMAC 19 #define CRYPTO_SHA2_512_HMAC 20 -#define CRYPTO_CAMELLIA_CBC 21 +#define CRYPTO_CAMELLIA_CBC 21 #define CRYPTO_AES_XTS 22 -#define CRYPTO_ALGORITHM_MAX 22 /* Keep updated - see below */ +#define CRYPTO_AES_ICM 23 /* commonly known as CTR mode */ +#define CRYPTO_AES_NIST_GMAC 24 /* cipher side */ +#define CRYPTO_AES_NIST_GCM_16 25 /* 16 byte ICV */ +#define CRYPTO_AES_128_NIST_GMAC 26 /* auth side */ +#define CRYPTO_AES_192_NIST_GMAC 27 /* auth side */ +#define CRYPTO_AES_256_NIST_GMAC 28 /* auth side */ +#define CRYPTO_ALGORITHM_MAX 28 /* Keep updated - see below */ + +#define CRYPTO_ALGO_VALID(x) ((x) >= CRYPTO_ALGORITHM_MIN && \ + (x) <= CRYPTO_ALGORITHM_MAX) /* Algorithm flags */ #define CRYPTO_ALG_FLAG_SUPPORTED 0x01 /* Algorithm is supported */ @@ -182,6 +245,20 @@ struct crypt_op { caddr_t iv; }; +/* op and flags the same as crypt_op */ +struct crypt_aead { + u_int32_t ses; + u_int16_t op; /* i.e. COP_ENCRYPT */ + u_int16_t flags; + u_int len; + u_int aadlen; + u_int ivlen; + caddr_t src, dst; /* become iov[] inside kernel */ + caddr_t aad; /* additional authenticated data */ + caddr_t tag; /* must fit for chosen TAG length */ + caddr_t iv; +}; + /* * Parameters for looking up a crypto driver/device by * device name or by id. The latter are returned for @@ -239,6 +316,7 @@ struct crypt_kop { #define CIOCGSESSION2 _IOWR('c', 106, struct session2_op) #define CIOCKEY2 _IOWR('c', 107, struct crypt_kop) #define CIOCFINDDEV _IOWR('c', 108, struct crypt_find_op) +#define CIOCCRYPTAEAD _IOWR('c', 109, struct crypt_aead) struct cryptotstat { struct timespec acc; /* total accumulated time */ @@ -269,6 +347,14 @@ struct cryptostats { }; #ifdef _KERNEL + +#if 0 +#define CRYPTDEB(s) do { printf("%s:%d: %s\n", __FILE__, __LINE__, s); \ + } while (0) +#else +#define CRYPTDEB(s) do { } while (0) +#endif + /* Standard initialization structure beginning */ struct cryptoini { int cri_alg; /* Algorithm to use */ @@ -292,14 +378,15 @@ struct cryptodesc { place, so don't copy. */ #define CRD_F_IV_EXPLICIT 0x04 /* IV explicitly provided */ #define CRD_F_DSA_SHA_NEEDED 0x08 /* Compute SHA-1 of buffer for DSA */ +#define CRD_F_COMP 0x0f /* Set when doing compression */ #define CRD_F_KEY_EXPLICIT 0x10 /* Key explicitly provided */ -#define CRD_F_COMP 0x0f /* Set when doing compression */ struct cryptoini CRD_INI; /* Initialization/context data */ -#define crd_iv CRD_INI.cri_iv -#define crd_key CRD_INI.cri_key -#define crd_alg CRD_INI.cri_alg -#define crd_klen CRD_INI.cri_klen +#define crd_esn CRD_INI.cri_esn +#define crd_iv CRD_INI.cri_iv +#define crd_key CRD_INI.cri_key +#define crd_alg CRD_INI.cri_alg +#define crd_klen CRD_INI.cri_klen struct cryptodesc *crd_next; }; @@ -324,9 +411,8 @@ struct cryptop { */ int crp_flags; -#define CRYPTO_F_IMBUF 0x0001 /* Input/output are mbuf chains */ -#define CRYPTO_F_IOV 0x0002 /* Input/output are uio */ -#define CRYPTO_F_REL 0x0004 /* Must return data in same place */ +#define CRYPTO_F_IMBUF 0x0001 /* Input/output are mbuf chains */ +#define CRYPTO_F_IOV 0x0002 /* Input/output are uio */ #define CRYPTO_F_BATCH 0x0008 /* Batch op if possible */ #define CRYPTO_F_CBIMM 0x0010 /* Do callback immediately */ #define CRYPTO_F_DONE 0x0020 /* Operation completed */ @@ -341,12 +427,12 @@ struct cryptop { struct bintime crp_tstamp; /* performance time stamp */ }; -#define CRYPTO_BUF_CONTIG 0x0 -#define CRYPTO_BUF_IOV 0x1 -#define CRYPTO_BUF_MBUF 0x2 +#define CRYPTO_BUF_CONTIG 0x0 +#define CRYPTO_BUF_IOV 0x1 +#define CRYPTO_BUF_MBUF 0x2 -#define CRYPTO_OP_DECRYPT 0x0 -#define CRYPTO_OP_ENCRYPT 0x1 +#define CRYPTO_OP_DECRYPT 0x0 +#define CRYPTO_OP_ENCRYPT 0x1 /* * Hints passed to process methods. @@ -381,9 +467,9 @@ MALLOC_DECLARE(M_CRYPTO_DATA); extern int crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int hard); extern int crypto_freesession(u_int64_t sid); -#define CRYPTOCAP_F_HARDWARE CRYPTO_FLAG_HARDWARE -#define CRYPTOCAP_F_SOFTWARE CRYPTO_FLAG_SOFTWARE -#define CRYPTOCAP_F_SYNC 0x04000000 /* operates synchronously */ +#define CRYPTOCAP_F_HARDWARE CRYPTO_FLAG_HARDWARE +#define CRYPTOCAP_F_SOFTWARE CRYPTO_FLAG_SOFTWARE +#define CRYPTOCAP_F_SYNC 0x04000000 /* operates synchronously */ extern int32_t crypto_get_driverid(device_t dev, int flags); extern int crypto_find_driver(const char *); extern device_t crypto_find_device_byhid(int hid); @@ -418,10 +504,15 @@ extern int crypto_devallowsoft; /* only use hardware crypto */ struct uio; extern void cuio_copydata(struct uio* uio, int off, int len, caddr_t cp); extern void cuio_copyback(struct uio* uio, int off, int len, caddr_t cp); -extern struct iovec *cuio_getptr(struct uio *uio, int loc, int *off); +extern int cuio_getptr(struct uio *uio, int loc, int *off); extern int cuio_apply(struct uio *uio, int off, int len, int (*f)(void *, void *, u_int), void *arg); +struct mbuf; +struct iovec; +extern int crypto_mbuftoiov(struct mbuf *mbuf, struct iovec **iovptr, + int *cnt, int *allocated); + extern void crypto_copyback(int flags, caddr_t buf, int off, int size, caddr_t in); extern void crypto_copydata(int flags, caddr_t buf, int off, int size, diff --git a/sys/opencrypto/cryptosoft.c b/sys/opencrypto/cryptosoft.c index d73f462..052916b 100644 --- a/sys/opencrypto/cryptosoft.c +++ b/sys/opencrypto/cryptosoft.c @@ -9,6 +9,12 @@ * supported the development of this code. * * Copyright (c) 2000, 2001 Angelos D. Keromytis + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). * * Permission to use, copy, and modify this software with or without fee * is hereby granted, provided that this entire notice is included in @@ -35,6 +41,10 @@ __FBSDID("$FreeBSD$"); #include <sys/random.h> #include <sys/kernel.h> #include <sys/uio.h> +#include <sys/lock.h> +#include <sys/rwlock.h> +#include <sys/endian.h> +#include <sys/limits.h> #include <crypto/blowfish/blowfish.h> #include <crypto/sha1.h> @@ -54,14 +64,18 @@ __FBSDID("$FreeBSD$"); static int32_t swcr_id; static struct swcr_data **swcr_sessions = NULL; static u_int32_t swcr_sesnum; +/* Protects swcr_sessions pointer, not data. */ +static struct rwlock swcr_sessions_lock; u_int8_t hmac_ipad_buffer[HMAC_MAX_BLOCK_LEN]; u_int8_t hmac_opad_buffer[HMAC_MAX_BLOCK_LEN]; static int swcr_encdec(struct cryptodesc *, struct swcr_data *, caddr_t, int); static int swcr_authcompute(struct cryptodesc *, struct swcr_data *, caddr_t, int); +static int swcr_authenc(struct cryptop *crp); static int swcr_compdec(struct cryptodesc *, struct swcr_data *, caddr_t, int); static int swcr_freesession(device_t dev, u_int64_t tid); +static int swcr_freesession_locked(device_t dev, u_int64_t tid); /* * Apply a symmetric encryption/decryption algorithm. @@ -71,36 +85,48 @@ swcr_encdec(struct cryptodesc *crd, struct swcr_data *sw, caddr_t buf, int flags) { unsigned char iv[EALG_MAX_BLOCK_LEN], blk[EALG_MAX_BLOCK_LEN], *idat; - unsigned char *ivp, piv[EALG_MAX_BLOCK_LEN]; + unsigned char *ivp, *nivp, iv2[EALG_MAX_BLOCK_LEN]; struct enc_xform *exf; - int i, k, j, blks; + int i, j, k, blks, ind, count, ivlen; + struct uio *uio, uiolcl; + struct iovec iovlcl[4]; + struct iovec *iov; + int iovcnt, iovalloc; + int error; + + error = 0; exf = sw->sw_exf; blks = exf->blocksize; + ivlen = exf->ivsize; /* Check for non-padded data */ if (crd->crd_len % blks) return EINVAL; + if (crd->crd_alg == CRYPTO_AES_ICM && + (crd->crd_flags & CRD_F_IV_EXPLICIT) == 0) + return (EINVAL); + /* Initialize the IV */ if (crd->crd_flags & CRD_F_ENCRYPT) { /* IV explicitly provided ? */ if (crd->crd_flags & CRD_F_IV_EXPLICIT) - bcopy(crd->crd_iv, iv, blks); + bcopy(crd->crd_iv, iv, ivlen); else - arc4rand(iv, blks, 0); + arc4rand(iv, ivlen, 0); /* Do we need to write the IV */ if (!(crd->crd_flags & CRD_F_IV_PRESENT)) - crypto_copyback(flags, buf, crd->crd_inject, blks, iv); + crypto_copyback(flags, buf, crd->crd_inject, ivlen, iv); } else { /* Decryption */ - /* IV explicitly provided ? */ + /* IV explicitly provided ? */ if (crd->crd_flags & CRD_F_IV_EXPLICIT) - bcopy(crd->crd_iv, iv, blks); + bcopy(crd->crd_iv, iv, ivlen); else { /* Get IV off buf */ - crypto_copydata(flags, buf, crd->crd_inject, blks, iv); + crypto_copydata(flags, buf, crd->crd_inject, ivlen, iv); } } @@ -109,341 +135,186 @@ swcr_encdec(struct cryptodesc *crd, struct swcr_data *sw, caddr_t buf, if (sw->sw_kschedule) exf->zerokey(&(sw->sw_kschedule)); + error = exf->setkey(&sw->sw_kschedule, crd->crd_key, crd->crd_klen / 8); if (error) return (error); } + iov = iovlcl; + iovcnt = nitems(iovlcl); + iovalloc = 0; + uio = &uiolcl; + if ((flags & CRYPTO_F_IMBUF) != 0) { + error = crypto_mbuftoiov((struct mbuf *)buf, &iov, &iovcnt, + &iovalloc); + if (error) + return (error); + uio->uio_iov = iov; + uio->uio_iovcnt = iovcnt; + } else if ((flags & CRYPTO_F_IOV) != 0) + uio = (struct uio *)buf; + else { + iov[0].iov_base = buf; + iov[0].iov_len = crd->crd_skip + crd->crd_len; + uio->uio_iov = iov; + uio->uio_iovcnt = 1; + } + ivp = iv; - /* - * xforms that provide a reinit method perform all IV - * handling themselves. - */ - if (exf->reinit) + if (exf->reinit) { + /* + * xforms that provide a reinit method perform all IV + * handling themselves. + */ exf->reinit(sw->sw_kschedule, iv); + } - if (flags & CRYPTO_F_IMBUF) { - struct mbuf *m = (struct mbuf *) buf; + count = crd->crd_skip; + ind = cuio_getptr(uio, count, &k); + if (ind == -1) { + error = EINVAL; + goto out; + } - /* Find beginning of data */ - m = m_getptr(m, crd->crd_skip, &k); - if (m == NULL) - return EINVAL; + i = crd->crd_len; - i = crd->crd_len; - - while (i > 0) { - /* - * If there's insufficient data at the end of - * an mbuf, we have to do some copying. - */ - if (m->m_len < k + blks && m->m_len != k) { - m_copydata(m, k, blks, blk); - - /* Actual encryption/decryption */ - if (exf->reinit) { - if (crd->crd_flags & CRD_F_ENCRYPT) { - exf->encrypt(sw->sw_kschedule, - blk); - } else { - exf->decrypt(sw->sw_kschedule, - blk); - } - } else if (crd->crd_flags & CRD_F_ENCRYPT) { - /* XOR with previous block */ - for (j = 0; j < blks; j++) - blk[j] ^= ivp[j]; - - exf->encrypt(sw->sw_kschedule, blk); - - /* - * Keep encrypted block for XOR'ing - * with next block - */ - bcopy(blk, iv, blks); - ivp = iv; - } else { /* decrypt */ - /* - * Keep encrypted block for XOR'ing - * with next block - */ - if (ivp == iv) - bcopy(blk, piv, blks); - else - bcopy(blk, iv, blks); - - exf->decrypt(sw->sw_kschedule, blk); - - /* XOR with previous block */ - for (j = 0; j < blks; j++) - blk[j] ^= ivp[j]; - - if (ivp == iv) - bcopy(piv, iv, blks); - else - ivp = iv; + while (i > 0) { + /* + * If there's insufficient data at the end of + * an iovec, we have to do some copying. + */ + if (uio->uio_iov[ind].iov_len < k + blks && + uio->uio_iov[ind].iov_len != k) { + cuio_copydata(uio, count, blks, blk); + + /* Actual encryption/decryption */ + if (exf->reinit) { + if (crd->crd_flags & CRD_F_ENCRYPT) { + exf->encrypt(sw->sw_kschedule, + blk); + } else { + exf->decrypt(sw->sw_kschedule, + blk); } - - /* Copy back decrypted block */ - m_copyback(m, k, blks, blk); - - /* Advance pointer */ - m = m_getptr(m, k + blks, &k); - if (m == NULL) - return EINVAL; - - i -= blks; - - /* Could be done... */ - if (i == 0) - break; + } else if (crd->crd_flags & CRD_F_ENCRYPT) { + /* XOR with previous block */ + for (j = 0; j < blks; j++) + blk[j] ^= ivp[j]; + + exf->encrypt(sw->sw_kschedule, blk); + + /* + * Keep encrypted block for XOR'ing + * with next block + */ + bcopy(blk, iv, blks); + ivp = iv; + } else { /* decrypt */ + /* + * Keep encrypted block for XOR'ing + * with next block + */ + nivp = (ivp == iv) ? iv2 : iv; + bcopy(blk, nivp, blks); + + exf->decrypt(sw->sw_kschedule, blk); + + /* XOR with previous block */ + for (j = 0; j < blks; j++) + blk[j] ^= ivp[j]; + + ivp = nivp; } - /* Skip possibly empty mbufs */ - if (k == m->m_len) { - for (m = m->m_next; m && m->m_len == 0; - m = m->m_next) - ; - k = 0; - } - - /* Sanity check */ - if (m == NULL) - return EINVAL; + /* Copy back decrypted block */ + cuio_copyback(uio, count, blks, blk); - /* - * Warning: idat may point to garbage here, but - * we only use it in the while() loop, only if - * there are indeed enough data. - */ - idat = mtod(m, unsigned char *) + k; - - while (m->m_len >= k + blks && i > 0) { - if (exf->reinit) { - if (crd->crd_flags & CRD_F_ENCRYPT) { - exf->encrypt(sw->sw_kschedule, - idat); - } else { - exf->decrypt(sw->sw_kschedule, - idat); - } - } else if (crd->crd_flags & CRD_F_ENCRYPT) { - /* XOR with previous block/IV */ - for (j = 0; j < blks; j++) - idat[j] ^= ivp[j]; - - exf->encrypt(sw->sw_kschedule, idat); - ivp = idat; - } else { /* decrypt */ - /* - * Keep encrypted block to be used - * in next block's processing. - */ - if (ivp == iv) - bcopy(idat, piv, blks); - else - bcopy(idat, iv, blks); - - exf->decrypt(sw->sw_kschedule, idat); - - /* XOR with previous block/IV */ - for (j = 0; j < blks; j++) - idat[j] ^= ivp[j]; - - if (ivp == iv) - bcopy(piv, iv, blks); - else - ivp = iv; - } + count += blks; - idat += blks; - k += blks; - i -= blks; + /* Advance pointer */ + ind = cuio_getptr(uio, count, &k); + if (ind == -1) { + error = EINVAL; + goto out; } - } - return 0; /* Done with mbuf encryption/decryption */ - } else if (flags & CRYPTO_F_IOV) { - struct uio *uio = (struct uio *) buf; - struct iovec *iov; + i -= blks; - /* Find beginning of data */ - iov = cuio_getptr(uio, crd->crd_skip, &k); - if (iov == NULL) - return EINVAL; + /* Could be done... */ + if (i == 0) + break; + } - i = crd->crd_len; - - while (i > 0) { - /* - * If there's insufficient data at the end of - * an iovec, we have to do some copying. - */ - if (iov->iov_len < k + blks && iov->iov_len != k) { - cuio_copydata(uio, k, blks, blk); - - /* Actual encryption/decryption */ - if (exf->reinit) { - if (crd->crd_flags & CRD_F_ENCRYPT) { - exf->encrypt(sw->sw_kschedule, - blk); - } else { - exf->decrypt(sw->sw_kschedule, - blk); - } - } else if (crd->crd_flags & CRD_F_ENCRYPT) { - /* XOR with previous block */ - for (j = 0; j < blks; j++) - blk[j] ^= ivp[j]; - - exf->encrypt(sw->sw_kschedule, blk); - - /* - * Keep encrypted block for XOR'ing - * with next block - */ - bcopy(blk, iv, blks); - ivp = iv; - } else { /* decrypt */ - /* - * Keep encrypted block for XOR'ing - * with next block - */ - if (ivp == iv) - bcopy(blk, piv, blks); - else - bcopy(blk, iv, blks); - - exf->decrypt(sw->sw_kschedule, blk); - - /* XOR with previous block */ - for (j = 0; j < blks; j++) - blk[j] ^= ivp[j]; - - if (ivp == iv) - bcopy(piv, iv, blks); - else - ivp = iv; + /* + * Warning: idat may point to garbage here, but + * we only use it in the while() loop, only if + * there are indeed enough data. + */ + idat = (char *)uio->uio_iov[ind].iov_base + k; + + while (uio->uio_iov[ind].iov_len >= k + blks && i > 0) { + if (exf->reinit) { + if (crd->crd_flags & CRD_F_ENCRYPT) { + exf->encrypt(sw->sw_kschedule, + idat); + } else { + exf->decrypt(sw->sw_kschedule, + idat); } - - /* Copy back decrypted block */ - cuio_copyback(uio, k, blks, blk); - - /* Advance pointer */ - iov = cuio_getptr(uio, k + blks, &k); - if (iov == NULL) - return EINVAL; - - i -= blks; - - /* Could be done... */ - if (i == 0) - break; + } else if (crd->crd_flags & CRD_F_ENCRYPT) { + /* XOR with previous block/IV */ + for (j = 0; j < blks; j++) + idat[j] ^= ivp[j]; + + exf->encrypt(sw->sw_kschedule, idat); + ivp = idat; + } else { /* decrypt */ + /* + * Keep encrypted block to be used + * in next block's processing. + */ + nivp = (ivp == iv) ? iv2 : iv; + bcopy(idat, nivp, blks); + + exf->decrypt(sw->sw_kschedule, idat); + + /* XOR with previous block/IV */ + for (j = 0; j < blks; j++) + idat[j] ^= ivp[j]; + + ivp = nivp; } - /* - * Warning: idat may point to garbage here, but - * we only use it in the while() loop, only if - * there are indeed enough data. - */ - idat = (char *)iov->iov_base + k; - - while (iov->iov_len >= k + blks && i > 0) { - if (exf->reinit) { - if (crd->crd_flags & CRD_F_ENCRYPT) { - exf->encrypt(sw->sw_kschedule, - idat); - } else { - exf->decrypt(sw->sw_kschedule, - idat); - } - } else if (crd->crd_flags & CRD_F_ENCRYPT) { - /* XOR with previous block/IV */ - for (j = 0; j < blks; j++) - idat[j] ^= ivp[j]; - - exf->encrypt(sw->sw_kschedule, idat); - ivp = idat; - } else { /* decrypt */ - /* - * Keep encrypted block to be used - * in next block's processing. - */ - if (ivp == iv) - bcopy(idat, piv, blks); - else - bcopy(idat, iv, blks); - - exf->decrypt(sw->sw_kschedule, idat); - - /* XOR with previous block/IV */ - for (j = 0; j < blks; j++) - idat[j] ^= ivp[j]; - - if (ivp == iv) - bcopy(piv, iv, blks); - else - ivp = iv; - } - - idat += blks; - k += blks; - i -= blks; - } - if (k == iov->iov_len) { - iov++; - k = 0; - } + idat += blks; + count += blks; + k += blks; + i -= blks; } - return 0; /* Done with iovec encryption/decryption */ - } else { /* contiguous buffer */ - if (exf->reinit) { - for (i = crd->crd_skip; - i < crd->crd_skip + crd->crd_len; i += blks) { - if (crd->crd_flags & CRD_F_ENCRYPT) - exf->encrypt(sw->sw_kschedule, buf + i); - else - exf->decrypt(sw->sw_kschedule, buf + i); - } - } else if (crd->crd_flags & CRD_F_ENCRYPT) { - for (i = crd->crd_skip; - i < crd->crd_skip + crd->crd_len; i += blks) { - /* XOR with the IV/previous block, as appropriate. */ - if (i == crd->crd_skip) - for (k = 0; k < blks; k++) - buf[i + k] ^= ivp[k]; - else - for (k = 0; k < blks; k++) - buf[i + k] ^= buf[i + k - blks]; - exf->encrypt(sw->sw_kschedule, buf + i); - } - } else { /* Decrypt */ - /* - * Start at the end, so we don't need to keep the encrypted - * block as the IV for the next block. - */ - for (i = crd->crd_skip + crd->crd_len - blks; - i >= crd->crd_skip; i -= blks) { - exf->decrypt(sw->sw_kschedule, buf + i); - - /* XOR with the IV/previous block, as appropriate */ - if (i == crd->crd_skip) - for (k = 0; k < blks; k++) - buf[i + k] ^= ivp[k]; - else - for (k = 0; k < blks; k++) - buf[i + k] ^= buf[i + k - blks]; + /* + * Advance to the next iov if the end of the current iov + * is aligned with the end of a cipher block. + * Note that the code is equivalent to calling: + * ind = cuio_getptr(uio, count, &k); + */ + if (i > 0 && k == uio->uio_iov[ind].iov_len) { + k = 0; + ind++; + if (ind >= uio->uio_iovcnt) { + error = EINVAL; + goto out; } } - - return 0; /* Done with contiguous buffer encryption/decryption */ } - /* Unreachable */ - return EINVAL; +out: + if (iovalloc) + free(iov, M_CRYPTO_DATA); + + return (error); } static void @@ -578,6 +449,181 @@ swcr_authcompute(struct cryptodesc *crd, struct swcr_data *sw, caddr_t buf, return 0; } +CTASSERT(INT_MAX <= (1ll<<39) - 256); /* GCM: plain text < 2^39-256 */ +CTASSERT(INT_MAX <= (uint64_t)-1); /* GCM: associated data <= 2^64-1 */ + +/* + * Apply a combined encryption-authentication transformation + */ +static int +swcr_authenc(struct cryptop *crp) +{ + uint32_t blkbuf[howmany(EALG_MAX_BLOCK_LEN, sizeof(uint32_t))]; + u_char *blk = (u_char *)blkbuf; + u_char aalg[AALG_MAX_RESULT_LEN]; + u_char uaalg[AALG_MAX_RESULT_LEN]; + u_char iv[EALG_MAX_BLOCK_LEN]; + union authctx ctx; + struct cryptodesc *crd, *crda = NULL, *crde = NULL; + struct swcr_data *sw, *swa, *swe = NULL; + struct auth_hash *axf = NULL; + struct enc_xform *exf = NULL; + caddr_t buf = (caddr_t)crp->crp_buf; + uint32_t *blkp; + int aadlen, blksz, i, ivlen, len, iskip, oskip, r; + + ivlen = blksz = iskip = oskip = 0; + + for (crd = crp->crp_desc; crd; crd = crd->crd_next) { + for (sw = swcr_sessions[crp->crp_sid & 0xffffffff]; + sw && sw->sw_alg != crd->crd_alg; + sw = sw->sw_next) + ; + if (sw == NULL) + return (EINVAL); + + switch (sw->sw_alg) { + case CRYPTO_AES_NIST_GCM_16: + case CRYPTO_AES_NIST_GMAC: + swe = sw; + crde = crd; + exf = swe->sw_exf; + ivlen = 12; + break; + case CRYPTO_AES_128_NIST_GMAC: + case CRYPTO_AES_192_NIST_GMAC: + case CRYPTO_AES_256_NIST_GMAC: + swa = sw; + crda = crd; + axf = swa->sw_axf; + if (swa->sw_ictx == 0) + return (EINVAL); + bcopy(swa->sw_ictx, &ctx, axf->ctxsize); + blksz = axf->blocksize; + break; + default: + return (EINVAL); + } + } + if (crde == NULL || crda == NULL) + return (EINVAL); + + if (crde->crd_alg == CRYPTO_AES_NIST_GCM_16 && + (crde->crd_flags & CRD_F_IV_EXPLICIT) == 0) + return (EINVAL); + + if (crde->crd_klen != crda->crd_klen) + return (EINVAL); + + /* Initialize the IV */ + if (crde->crd_flags & CRD_F_ENCRYPT) { + /* IV explicitly provided ? */ + if (crde->crd_flags & CRD_F_IV_EXPLICIT) + bcopy(crde->crd_iv, iv, ivlen); + else + arc4rand(iv, ivlen, 0); + + /* Do we need to write the IV */ + if (!(crde->crd_flags & CRD_F_IV_PRESENT)) + crypto_copyback(crp->crp_flags, buf, crde->crd_inject, + ivlen, iv); + + } else { /* Decryption */ + /* IV explicitly provided ? */ + if (crde->crd_flags & CRD_F_IV_EXPLICIT) + bcopy(crde->crd_iv, iv, ivlen); + else { + /* Get IV off buf */ + crypto_copydata(crp->crp_flags, buf, crde->crd_inject, + ivlen, iv); + } + } + + /* Supply MAC with IV */ + if (axf->Reinit) + axf->Reinit(&ctx, iv, ivlen); + + /* Supply MAC with AAD */ + aadlen = crda->crd_len; + + for (i = iskip; i < crda->crd_len; i += blksz) { + len = MIN(crda->crd_len - i, blksz - oskip); + crypto_copydata(crp->crp_flags, buf, crda->crd_skip + i, len, + blk + oskip); + bzero(blk + len + oskip, blksz - len - oskip); + axf->Update(&ctx, blk, blksz); + oskip = 0; /* reset initial output offset */ + } + + if (exf->reinit) + exf->reinit(swe->sw_kschedule, iv); + + /* Do encryption/decryption with MAC */ + for (i = 0; i < crde->crd_len; i += blksz) { + len = MIN(crde->crd_len - i, blksz); + if (len < blksz) + bzero(blk, blksz); + crypto_copydata(crp->crp_flags, buf, crde->crd_skip + i, len, + blk); + if (crde->crd_flags & CRD_F_ENCRYPT) { + exf->encrypt(swe->sw_kschedule, blk); + axf->Update(&ctx, blk, len); + crypto_copyback(crp->crp_flags, buf, + crde->crd_skip + i, len, blk); + } else { + axf->Update(&ctx, blk, len); + } + } + + /* Do any required special finalization */ + switch (crda->crd_alg) { + case CRYPTO_AES_128_NIST_GMAC: + case CRYPTO_AES_192_NIST_GMAC: + case CRYPTO_AES_256_NIST_GMAC: + /* length block */ + bzero(blk, blksz); + blkp = (uint32_t *)blk + 1; + *blkp = htobe32(aadlen * 8); + blkp = (uint32_t *)blk + 3; + *blkp = htobe32(crde->crd_len * 8); + axf->Update(&ctx, blk, blksz); + break; + } + + /* Finalize MAC */ + axf->Final(aalg, &ctx); + + /* Validate tag */ + if (!(crde->crd_flags & CRD_F_ENCRYPT)) { + crypto_copydata(crp->crp_flags, buf, crda->crd_inject, + axf->hashsize, uaalg); + + r = timingsafe_bcmp(aalg, uaalg, axf->hashsize); + if (r == 0) { + /* tag matches, decrypt data */ + for (i = 0; i < crde->crd_len; i += blksz) { + len = MIN(crde->crd_len - i, blksz); + if (len < blksz) + bzero(blk, blksz); + crypto_copydata(crp->crp_flags, buf, + crde->crd_skip + i, len, blk); + if (!(crde->crd_flags & CRD_F_ENCRYPT)) { + exf->decrypt(swe->sw_kschedule, blk); + } + crypto_copyback(crp->crp_flags, buf, + crde->crd_skip + i, len, blk); + } + } else + return (EBADMSG); + } else { + /* Inject the authentication data */ + crypto_copyback(crp->crp_flags, buf, crda->crd_inject, + axf->hashsize, aalg); + } + + return (0); +} + /* * Apply a compression/decompression algorithm */ @@ -665,11 +711,13 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) struct enc_xform *txf; struct comp_algo *cxf; u_int32_t i; + int len; int error; if (sid == NULL || cri == NULL) return EINVAL; + rw_wlock(&swcr_sessions_lock); if (swcr_sessions) { for (i = 1; i < swcr_sesnum; i++) if (swcr_sessions[i] == NULL) @@ -692,6 +740,7 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) swcr_sesnum = 0; else swcr_sesnum /= 2; + rw_wunlock(&swcr_sessions_lock); return ENOBUFS; } @@ -705,6 +754,7 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) swcr_sessions = swd; } + rw_downgrade(&swcr_sessions_lock); swd = &swcr_sessions[i]; *sid = i; @@ -712,7 +762,8 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) *swd = malloc(sizeof(struct swcr_data), M_CRYPTO_DATA, M_NOWAIT|M_ZERO); if (*swd == NULL) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return ENOBUFS; } @@ -738,6 +789,16 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) case CRYPTO_AES_XTS: txf = &enc_xform_aes_xts; goto enccommon; + case CRYPTO_AES_ICM: + txf = &enc_xform_aes_icm; + goto enccommon; + case CRYPTO_AES_NIST_GCM_16: + txf = &enc_xform_aes_nist_gcm; + goto enccommon; + case CRYPTO_AES_NIST_GMAC: + txf = &enc_xform_aes_nist_gmac; + (*swd)->sw_exf = txf; + break; case CRYPTO_CAMELLIA_CBC: txf = &enc_xform_camellia; goto enccommon; @@ -749,7 +810,8 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) error = txf->setkey(&((*swd)->sw_kschedule), cri->cri_key, cri->cri_klen / 8); if (error) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return error; } } @@ -780,14 +842,16 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT); if ((*swd)->sw_ictx == NULL) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return ENOBUFS; } (*swd)->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT); if ((*swd)->sw_octx == NULL) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return ENOBUFS; } @@ -810,14 +874,16 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT); if ((*swd)->sw_ictx == NULL) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return ENOBUFS; } (*swd)->sw_octx = malloc(cri->cri_klen / 8, M_CRYPTO_DATA, M_NOWAIT); if ((*swd)->sw_octx == NULL) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return ENOBUFS; } @@ -841,7 +907,8 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, M_NOWAIT); if ((*swd)->sw_ictx == NULL) { - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return ENOBUFS; } @@ -850,12 +917,41 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) (*swd)->sw_axf = axf; break; #endif + + case CRYPTO_AES_128_NIST_GMAC: + axf = &auth_hash_nist_gmac_aes_128; + goto auth4common; + + case CRYPTO_AES_192_NIST_GMAC: + axf = &auth_hash_nist_gmac_aes_192; + goto auth4common; + + case CRYPTO_AES_256_NIST_GMAC: + axf = &auth_hash_nist_gmac_aes_256; + auth4common: + len = cri->cri_klen / 8; + if (len != 16 && len != 24 && len != 32) + return EINVAL; + + (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, + M_NOWAIT); + if ((*swd)->sw_ictx == NULL) { + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); + return ENOBUFS; + } + axf->Init((*swd)->sw_ictx); + axf->Setkey((*swd)->sw_ictx, cri->cri_key, len); + (*swd)->sw_axf = axf; + break; + case CRYPTO_DEFLATE_COMP: cxf = &comp_algo_deflate; (*swd)->sw_cxf = cxf; break; default: - swcr_freesession(dev, i); + swcr_freesession_locked(dev, i); + rw_runlock(&swcr_sessions_lock); return EINVAL; } @@ -863,14 +959,26 @@ swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) cri = cri->cri_next; swd = &((*swd)->sw_next); } + rw_runlock(&swcr_sessions_lock); return 0; } +static int +swcr_freesession(device_t dev, u_int64_t tid) +{ + int error; + + rw_rlock(&swcr_sessions_lock); + error = swcr_freesession_locked(dev, tid); + rw_runlock(&swcr_sessions_lock); + return error; +} + /* * Free a session. */ static int -swcr_freesession(device_t dev, u_int64_t tid) +swcr_freesession_locked(device_t dev, u_int64_t tid) { struct swcr_data *swd; struct enc_xform *txf; @@ -897,6 +1005,9 @@ swcr_freesession(device_t dev, u_int64_t tid) case CRYPTO_SKIPJACK_CBC: case CRYPTO_RIJNDAEL128_CBC: case CRYPTO_AES_XTS: + case CRYPTO_AES_ICM: + case CRYPTO_AES_NIST_GCM_16: + case CRYPTO_AES_NIST_GMAC: case CRYPTO_CAMELLIA_CBC: case CRYPTO_NULL_CBC: txf = swd->sw_exf; @@ -975,11 +1086,15 @@ swcr_process(device_t dev, struct cryptop *crp, int hint) goto done; } - lid = crp->crp_sid & 0xffffffff; - if (lid >= swcr_sesnum || lid == 0 || swcr_sessions[lid] == NULL) { + lid = CRYPTO_SESID2LID(crp->crp_sid); + rw_rlock(&swcr_sessions_lock); + if (swcr_sessions == NULL || lid >= swcr_sesnum || lid == 0 || + swcr_sessions[lid] == NULL) { + rw_runlock(&swcr_sessions_lock); crp->crp_etype = ENOENT; goto done; } + rw_runlock(&swcr_sessions_lock); /* Go through crypto descriptors, processing as we go */ for (crd = crp->crp_desc; crd; crd = crd->crd_next) { @@ -993,10 +1108,17 @@ swcr_process(device_t dev, struct cryptop *crp, int hint) * XXX between the various instances of an algorithm (so we can * XXX locate the correct crypto context). */ + rw_rlock(&swcr_sessions_lock); + if (swcr_sessions == NULL) { + rw_runlock(&swcr_sessions_lock); + crp->crp_etype = ENOENT; + goto done; + } for (sw = swcr_sessions[lid]; sw && sw->sw_alg != crd->crd_alg; sw = sw->sw_next) ; + rw_runlock(&swcr_sessions_lock); /* No such context ? */ if (sw == NULL) { @@ -1011,6 +1133,7 @@ swcr_process(device_t dev, struct cryptop *crp, int hint) case CRYPTO_SKIPJACK_CBC: case CRYPTO_RIJNDAEL128_CBC: case CRYPTO_AES_XTS: + case CRYPTO_AES_ICM: case CRYPTO_CAMELLIA_CBC: if ((crp->crp_etype = swcr_encdec(crd, sw, crp->crp_buf, crp->crp_flags)) != 0) @@ -1035,6 +1158,14 @@ swcr_process(device_t dev, struct cryptop *crp, int hint) goto done; break; + case CRYPTO_AES_NIST_GCM_16: + case CRYPTO_AES_NIST_GMAC: + case CRYPTO_AES_128_NIST_GMAC: + case CRYPTO_AES_192_NIST_GMAC: + case CRYPTO_AES_256_NIST_GMAC: + crp->crp_etype = swcr_authenc(crp); + goto done; + case CRYPTO_DEFLATE_COMP: if ((crp->crp_etype = swcr_compdec(crd, sw, crp->crp_buf, crp->crp_flags)) != 0) @@ -1074,6 +1205,7 @@ swcr_probe(device_t dev) static int swcr_attach(device_t dev) { + rw_init(&swcr_sessions_lock, "swcr_sessions_lock"); memset(hmac_ipad_buffer, HMAC_IPAD_VAL, HMAC_MAX_BLOCK_LEN); memset(hmac_opad_buffer, HMAC_OPAD_VAL, HMAC_MAX_BLOCK_LEN); @@ -1104,6 +1236,12 @@ swcr_attach(device_t dev) REGISTER(CRYPTO_SHA1); REGISTER(CRYPTO_RIJNDAEL128_CBC); REGISTER(CRYPTO_AES_XTS); + REGISTER(CRYPTO_AES_ICM); + REGISTER(CRYPTO_AES_NIST_GCM_16); + REGISTER(CRYPTO_AES_NIST_GMAC); + REGISTER(CRYPTO_AES_128_NIST_GMAC); + REGISTER(CRYPTO_AES_192_NIST_GMAC); + REGISTER(CRYPTO_AES_256_NIST_GMAC); REGISTER(CRYPTO_CAMELLIA_CBC); REGISTER(CRYPTO_DEFLATE_COMP); #undef REGISTER @@ -1115,8 +1253,11 @@ static int swcr_detach(device_t dev) { crypto_unregister_all(swcr_id); - if (swcr_sessions != NULL) - free(swcr_sessions, M_CRYPTO_DATA); + rw_wlock(&swcr_sessions_lock); + free(swcr_sessions, M_CRYPTO_DATA); + swcr_sessions = NULL; + rw_wunlock(&swcr_sessions_lock); + rw_destroy(&swcr_sessions_lock); return 0; } diff --git a/sys/opencrypto/gfmult.c b/sys/opencrypto/gfmult.c new file mode 100644 index 0000000..990a7ff --- /dev/null +++ b/sys/opencrypto/gfmult.c @@ -0,0 +1,275 @@ +/*- + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * This software was developed by John-Mark Gurney under + * the sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * 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$ + * + */ + +#include "gfmult.h" + +#define REV_POLY_REDUCT 0xe1 /* 0x87 bit reversed */ + +/* reverse the bits of a nibble */ +static const uint8_t nib_rev[] = { + 0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe, + 0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf, +}; + +/* calulate v * 2 */ +static inline struct gf128 +gf128_mulalpha(struct gf128 v) +{ + uint64_t mask; + + mask = !!(v.v[1] & 1); + mask = ~(mask - 1); + v.v[1] = (v.v[1] >> 1) | ((v.v[0] & 1) << 63); + v.v[0] = (v.v[0] >> 1) ^ ((mask & REV_POLY_REDUCT) << 56); + + return v; +} + +/* + * Generate a table for 0-16 * h. Store the results in the table w/ indexes + * bit reversed, and the words striped across the values. + */ +void +gf128_genmultable(struct gf128 h, struct gf128table *t) +{ + struct gf128 tbl[16]; + int i; + + tbl[0] = MAKE_GF128(0, 0); + tbl[1] = h; + + for (i = 2; i < 16; i += 2) { + tbl[i] = gf128_mulalpha(tbl[i / 2]); + tbl[i + 1] = gf128_add(tbl[i], h); + } + + for (i = 0; i < 16; i++) { + t->a[nib_rev[i]] = tbl[i].v[0] >> 32; + t->b[nib_rev[i]] = tbl[i].v[0]; + t->c[nib_rev[i]] = tbl[i].v[1] >> 32; + t->d[nib_rev[i]] = tbl[i].v[1]; + } +} + +/* + * Generate tables containing h, h^2, h^3 and h^4, starting at 0. + */ +void +gf128_genmultable4(struct gf128 h, struct gf128table4 *t) +{ + struct gf128 h2, h3, h4; + + gf128_genmultable(h, &t->tbls[0]); + + h2 = gf128_mul(h, &t->tbls[0]); + + gf128_genmultable(h2, &t->tbls[1]); + + h3 = gf128_mul(h, &t->tbls[1]); + gf128_genmultable(h3, &t->tbls[2]); + + h4 = gf128_mul(h2, &t->tbls[1]); + gf128_genmultable(h4, &t->tbls[3]); +} + +/* + * Read a row from the table. + */ +static inline struct gf128 +readrow(struct gf128table *tbl, unsigned bits) +{ + struct gf128 r; + + bits = bits % 16; + + r.v[0] = ((uint64_t)tbl->a[bits] << 32) | tbl->b[bits]; + r.v[1] = ((uint64_t)tbl->c[bits] << 32) | tbl->d[bits]; + + return r; +} + +/* + * These are the reduction values. Since we are dealing with bit reversed + * version, the values need to be bit reversed, AND the indexes are also + * bit reversed to make lookups quicker. + */ +static uint16_t reduction[] = { + 0x0000, 0x1c20, 0x3840, 0x2460, 0x7080, 0x6ca0, 0x48c0, 0x54e0, + 0xe100, 0xfd20, 0xd940, 0xc560, 0x9180, 0x8da0, 0xa9c0, 0xb5e0, +}; + +/* + * Calculate: + * (x*2^4 + word[3,0]*h) * + * 2^4 + word[7,4]*h) * + * ... + * 2^4 + word[63,60]*h + */ +static struct gf128 +gfmultword(uint64_t word, struct gf128 x, struct gf128table *tbl) +{ + struct gf128 row; + unsigned bits; + unsigned redbits; + int i; + + for (i = 0; i < 64; i += 4) { + bits = word % 16; + + /* fetch row */ + row = readrow(tbl, bits); + + /* x * 2^4 */ + redbits = x.v[1] % 16; + x.v[1] = (x.v[1] >> 4) | (x.v[0] % 16) << 60; + x.v[0] >>= 4; + x.v[0] ^= (uint64_t)reduction[redbits] << (64 - 16); + + word >>= 4; + + x = gf128_add(x, row); + } + + return x; +} + +/* + * Calculate + * (x*2^4 + worda[3,0]*h^4+wordb[3,0]*h^3+...+wordd[3,0]*h) * + * ... + * 2^4 + worda[63,60]*h^4+ ... + wordd[63,60]*h + * + * Passing/returning struct is .5% faster than passing in via pointer on + * amd64. + */ +static struct gf128 +gfmultword4(uint64_t worda, uint64_t wordb, uint64_t wordc, uint64_t wordd, + struct gf128 x, struct gf128table4 *tbl) +{ + struct gf128 rowa, rowb, rowc, rowd; + unsigned bitsa, bitsb, bitsc, bitsd; + unsigned redbits; + int i; + + /* + * XXX - nibble reverse words to save a shift? probably not as + * nibble reverse would take 20 ops (5 * 4) verse 16 + */ + + for (i = 0; i < 64; i += 4) { + bitsa = worda % 16; + bitsb = wordb % 16; + bitsc = wordc % 16; + bitsd = wordd % 16; + + /* fetch row */ + rowa = readrow(&tbl->tbls[3], bitsa); + rowb = readrow(&tbl->tbls[2], bitsb); + rowc = readrow(&tbl->tbls[1], bitsc); + rowd = readrow(&tbl->tbls[0], bitsd); + + /* x * 2^4 */ + redbits = x.v[1] % 16; + x.v[1] = (x.v[1] >> 4) | (x.v[0] % 16) << 60; + x.v[0] >>= 4; + x.v[0] ^= (uint64_t)reduction[redbits] << (64 - 16); + + worda >>= 4; + wordb >>= 4; + wordc >>= 4; + wordd >>= 4; + + x = gf128_add(x, gf128_add(rowa, gf128_add(rowb, + gf128_add(rowc, rowd)))); + } + + return x; +} + +struct gf128 +gf128_mul(struct gf128 v, struct gf128table *tbl) +{ + struct gf128 ret; + + ret = MAKE_GF128(0, 0); + + ret = gfmultword(v.v[1], ret, tbl); + ret = gfmultword(v.v[0], ret, tbl); + + return ret; +} + +/* + * Calculate a*h^4 + b*h^3 + c*h^2 + d*h, or: + * (((a*h+b)*h+c)*h+d)*h + */ +struct gf128 +gf128_mul4(struct gf128 a, struct gf128 b, struct gf128 c, struct gf128 d, + struct gf128table4 *tbl) +{ + struct gf128 tmp; + + tmp = MAKE_GF128(0, 0); + + tmp = gfmultword4(a.v[1], b.v[1], c.v[1], d.v[1], tmp, tbl); + tmp = gfmultword4(a.v[0], b.v[0], c.v[0], d.v[0], tmp, tbl); + + return tmp; +} + +/* + * a = data[0..15] + r + * b = data[16..31] + * c = data[32..47] + * d = data[48..63] + * + * Calculate a*h^4 + b*h^3 + c*h^2 + d*h, or: + * (((a*h+b)*h+c)*h+d)*h + */ +struct gf128 +gf128_mul4b(struct gf128 r, const uint8_t *v, struct gf128table4 *tbl) +{ + struct gf128 a, b, c, d; + struct gf128 tmp; + + tmp = MAKE_GF128(0, 0); + + a = gf128_add(r, gf128_read(&v[0*16])); + b = gf128_read(&v[1*16]); + c = gf128_read(&v[2*16]); + d = gf128_read(&v[3*16]); + + tmp = gfmultword4(a.v[1], b.v[1], c.v[1], d.v[1], tmp, tbl); + tmp = gfmultword4(a.v[0], b.v[0], c.v[0], d.v[0], tmp, tbl); + + return tmp; +} diff --git a/sys/opencrypto/gfmult.h b/sys/opencrypto/gfmult.h new file mode 100644 index 0000000..c385618 --- /dev/null +++ b/sys/opencrypto/gfmult.h @@ -0,0 +1,128 @@ +/*- + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * This software was developed by John-Mark Gurney under + * the sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * 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$ + * + */ + +#ifndef _GFMULT_H_ +#define _GFMULT_H_ + +#ifdef __APPLE__ +#define __aligned(x) __attribute__((__aligned__(x))) +#define be64dec(buf) __builtin_bswap64(*(uint64_t *)buf) +#define be64enc(buf, x) (*(uint64_t *)buf = __builtin_bswap64(x)) +#else +#include <sys/endian.h> +#endif + +#ifdef _KERNEL +#include <sys/types.h> +#else +#include <stdint.h> +#include <strings.h> +#endif + +#define REQ_ALIGN (16 * 4) +/* + * The rows are striped across cache lines. Note that the indexes + * are bit reversed to make accesses quicker. + */ +struct gf128table { + uint32_t a[16] __aligned(REQ_ALIGN); /* bits 0 - 31 */ + uint32_t b[16] __aligned(REQ_ALIGN); /* bits 63 - 32 */ + uint32_t c[16] __aligned(REQ_ALIGN); /* bits 95 - 64 */ + uint32_t d[16] __aligned(REQ_ALIGN); /* bits 127 - 96 */ +} __aligned(REQ_ALIGN); + +/* + * A set of tables that contain h, h^2, h^3, h^4. To be used w/ gf128_mul4. + */ +struct gf128table4 { + struct gf128table tbls[4]; +}; + +/* + * GCM per spec is bit reversed in memory. So byte 0 is really bit reversed + * and contains bits 0-7. We can deal w/ this by using right shifts and + * related math instead of having to bit reverse everything. This means that + * the low bits are in v[0] (bits 0-63) and reverse order, while the high + * bits are in v[1] (bits 64-127) and reverse order. The high bit of v[0] is + * bit 0, and the low bit of v[1] is bit 127. + */ +struct gf128 { + uint64_t v[2]; +}; + +/* Note that we don't bit reverse in MAKE_GF128. */ +#define MAKE_GF128(a, b) ((struct gf128){.v = { (a), (b) } }) +#define GF128_EQ(a, b) ((((a).v[0] ^ (b).v[0]) | \ + ((a).v[1] ^ (b).v[1])) == 0) + +static inline struct gf128 +gf128_read(const uint8_t *buf) +{ + struct gf128 r; + + r.v[0] = be64dec(buf); + buf += sizeof(uint64_t); + + r.v[1] = be64dec(buf); + + return r; +} + +static inline void +gf128_write(struct gf128 v, uint8_t *buf) +{ + uint64_t tmp; + + be64enc(buf, v.v[0]); + buf += sizeof tmp; + + be64enc(buf, v.v[1]); +} + +static inline struct gf128 __pure /* XXX - __pure2 instead */ +gf128_add(struct gf128 a, struct gf128 b) +{ + a.v[0] ^= b.v[0]; + a.v[1] ^= b.v[1]; + + return a; +} + +void gf128_genmultable(struct gf128 h, struct gf128table *t); +void gf128_genmultable4(struct gf128 h, struct gf128table4 *t); +struct gf128 gf128_mul(struct gf128 v, struct gf128table *tbl); +struct gf128 gf128_mul4(struct gf128 a, struct gf128 b, struct gf128 c, + struct gf128 d, struct gf128table4 *tbl); +struct gf128 gf128_mul4b(struct gf128 r, const uint8_t *v, + struct gf128table4 *tbl); + +#endif /* _GFMULT_H_ */ diff --git a/sys/opencrypto/gmac.c b/sys/opencrypto/gmac.c new file mode 100644 index 0000000..402092c --- /dev/null +++ b/sys/opencrypto/gmac.c @@ -0,0 +1,119 @@ +/*- + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * This software was developed by John-Mark Gurney under + * the sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * 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$ + * + */ + +#include <sys/types.h> +#include <sys/systm.h> +#include <opencrypto/gfmult.h> +#include <opencrypto/gmac.h> + +void +AES_GMAC_Init(struct aes_gmac_ctx *agc) +{ + + bzero(agc, sizeof *agc); +} + +void +AES_GMAC_Setkey(struct aes_gmac_ctx *agc, const uint8_t *key, uint16_t klen) +{ + const uint8_t zeros[GMAC_BLOCK_LEN] = {}; + struct gf128 h; + uint8_t hbuf[GMAC_BLOCK_LEN]; + + agc->rounds = rijndaelKeySetupEnc(agc->keysched, key, klen * 8); + + rijndaelEncrypt(agc->keysched, agc->rounds, zeros, hbuf); + + h = gf128_read(hbuf); + gf128_genmultable4(h, &agc->ghashtbl); + + explicit_bzero(&h, sizeof h); + explicit_bzero(hbuf, sizeof hbuf); +} + +void +AES_GMAC_Reinit(struct aes_gmac_ctx *agc, const uint8_t *iv, uint16_t ivlen) +{ + + KASSERT(ivlen <= sizeof agc->counter, ("passed ivlen too large!")); + bcopy(iv, agc->counter, ivlen); +} + +int +AES_GMAC_Update(struct aes_gmac_ctx *agc, const uint8_t *data, uint16_t len) +{ + struct gf128 v; + uint8_t buf[GMAC_BLOCK_LEN] = {}; + int i; + + v = agc->hash; + + while (len > 0) { + if (len >= 4*GMAC_BLOCK_LEN) { + i = 4*GMAC_BLOCK_LEN; + v = gf128_mul4b(v, data, &agc->ghashtbl); + } else if (len >= GMAC_BLOCK_LEN) { + i = GMAC_BLOCK_LEN; + v = gf128_add(v, gf128_read(data)); + v = gf128_mul(v, &agc->ghashtbl.tbls[0]); + } else { + i = len; + bcopy(data, buf, i); + v = gf128_add(v, gf128_read(&buf[0])); + v = gf128_mul(v, &agc->ghashtbl.tbls[0]); + explicit_bzero(buf, sizeof buf); + } + len -= i; + data += i; + } + + agc->hash = v; + explicit_bzero(&v, sizeof v); + + return (0); +} + +void +AES_GMAC_Final(uint8_t digest[GMAC_DIGEST_LEN], struct aes_gmac_ctx *agc) +{ + uint8_t enccntr[GMAC_BLOCK_LEN]; + struct gf128 a; + + /* XXX - zero additional bytes? */ + agc->counter[GMAC_BLOCK_LEN - 1] = 1; + + rijndaelEncrypt(agc->keysched, agc->rounds, agc->counter, enccntr); + a = gf128_add(agc->hash, gf128_read(enccntr)); + gf128_write(a, digest); + + explicit_bzero(enccntr, sizeof enccntr); +} diff --git a/sys/opencrypto/gmac.h b/sys/opencrypto/gmac.h new file mode 100644 index 0000000..909b78c --- /dev/null +++ b/sys/opencrypto/gmac.h @@ -0,0 +1,56 @@ +/*- + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * This software was developed by John-Mark Gurney under + * the sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). + * 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$ + * + */ + +#ifndef _GMAC_H_ +#define _GMAC_H_ + +#include "gfmult.h" +#include <crypto/rijndael/rijndael.h> + +#define GMAC_BLOCK_LEN 16 +#define GMAC_DIGEST_LEN 16 + +struct aes_gmac_ctx { + struct gf128table4 ghashtbl; + struct gf128 hash; + uint32_t keysched[4*(RIJNDAEL_MAXNR + 1)]; + uint8_t counter[GMAC_BLOCK_LEN]; + int rounds; +}; + +void AES_GMAC_Init(struct aes_gmac_ctx *); +void AES_GMAC_Setkey(struct aes_gmac_ctx *, const uint8_t *, uint16_t); +void AES_GMAC_Reinit(struct aes_gmac_ctx *, const uint8_t *, uint16_t); +int AES_GMAC_Update(struct aes_gmac_ctx *, const uint8_t *, uint16_t); +void AES_GMAC_Final(uint8_t [GMAC_DIGEST_LEN], struct aes_gmac_ctx *); + +#endif /* _GMAC_H_ */ diff --git a/sys/opencrypto/xform.c b/sys/opencrypto/xform.c index bfb061b..cb44bfa 100644 --- a/sys/opencrypto/xform.c +++ b/sys/opencrypto/xform.c @@ -24,6 +24,12 @@ * Copyright (C) 2001, Angelos D. Keromytis. * * Copyright (C) 2008, Damien Miller + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). * * Permission to use, copy, and modify this software with or without fee * is hereby granted, provided that this entire notice is included in @@ -76,6 +82,7 @@ static int blf_setkey(u_int8_t **, u_int8_t *, int); static int cast5_setkey(u_int8_t **, u_int8_t *, int); static int skipjack_setkey(u_int8_t **, u_int8_t *, int); static int rijndael128_setkey(u_int8_t **, u_int8_t *, int); +static int aes_icm_setkey(u_int8_t **, u_int8_t *, int); static int aes_xts_setkey(u_int8_t **, u_int8_t *, int); static int cml_setkey(u_int8_t **, u_int8_t *, int); @@ -99,6 +106,8 @@ static void rijndael128_decrypt(caddr_t, u_int8_t *); static void aes_xts_decrypt(caddr_t, u_int8_t *); static void cml_decrypt(caddr_t, u_int8_t *); +static void aes_icm_crypt(caddr_t, u_int8_t *); + static void null_zerokey(u_int8_t **); static void des1_zerokey(u_int8_t **); static void des3_zerokey(u_int8_t **); @@ -106,103 +115,149 @@ static void blf_zerokey(u_int8_t **); static void cast5_zerokey(u_int8_t **); static void skipjack_zerokey(u_int8_t **); static void rijndael128_zerokey(u_int8_t **); +static void aes_icm_zerokey(u_int8_t **); static void aes_xts_zerokey(u_int8_t **); static void cml_zerokey(u_int8_t **); +static void aes_icm_reinit(caddr_t, u_int8_t *); static void aes_xts_reinit(caddr_t, u_int8_t *); +static void aes_gcm_reinit(caddr_t, u_int8_t *); static void null_init(void *); -static int null_update(void *, u_int8_t *, u_int16_t); +static void null_reinit(void *ctx, const u_int8_t *buf, u_int16_t len); +static int null_update(void *, const u_int8_t *, u_int16_t); static void null_final(u_int8_t *, void *); -static int MD5Update_int(void *, u_int8_t *, u_int16_t); +static int MD5Update_int(void *, const u_int8_t *, u_int16_t); static void SHA1Init_int(void *); -static int SHA1Update_int(void *, u_int8_t *, u_int16_t); +static int SHA1Update_int(void *, const u_int8_t *, u_int16_t); static void SHA1Final_int(u_int8_t *, void *); -static int RMD160Update_int(void *, u_int8_t *, u_int16_t); -static int SHA256Update_int(void *, u_int8_t *, u_int16_t); -static int SHA384Update_int(void *, u_int8_t *, u_int16_t); -static int SHA512Update_int(void *, u_int8_t *, u_int16_t); +static int RMD160Update_int(void *, const u_int8_t *, u_int16_t); +static int SHA256Update_int(void *, const u_int8_t *, u_int16_t); +static int SHA384Update_int(void *, const u_int8_t *, u_int16_t); +static int SHA512Update_int(void *, const u_int8_t *, u_int16_t); static u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **); static u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **); +#define AESICM_BLOCKSIZE AES_BLOCK_LEN + +struct aes_icm_ctx { + u_int32_t ac_ek[4*(RIJNDAEL_MAXNR + 1)]; + /* ac_block is initalized to IV */ + u_int8_t ac_block[AESICM_BLOCKSIZE]; + int ac_nr; +}; + MALLOC_DEFINE(M_XDATA, "xform", "xform data buffers"); /* Encryption instances */ struct enc_xform enc_xform_null = { CRYPTO_NULL_CBC, "NULL", /* NB: blocksize of 4 is to generate a properly aligned ESP header */ - NULL_BLOCK_LEN, 0, 256, /* 2048 bits, max key */ + NULL_BLOCK_LEN, NULL_BLOCK_LEN, NULL_MIN_KEY, NULL_MAX_KEY, null_encrypt, null_decrypt, null_setkey, null_zerokey, - NULL + NULL, }; struct enc_xform enc_xform_des = { CRYPTO_DES_CBC, "DES", - DES_BLOCK_LEN, 8, 8, + DES_BLOCK_LEN, DES_BLOCK_LEN, DES_MIN_KEY, DES_MAX_KEY, des1_encrypt, des1_decrypt, des1_setkey, des1_zerokey, - NULL + NULL, }; struct enc_xform enc_xform_3des = { CRYPTO_3DES_CBC, "3DES", - DES3_BLOCK_LEN, 24, 24, + DES3_BLOCK_LEN, DES3_BLOCK_LEN, TRIPLE_DES_MIN_KEY, + TRIPLE_DES_MAX_KEY, des3_encrypt, des3_decrypt, des3_setkey, des3_zerokey, - NULL + NULL, }; struct enc_xform enc_xform_blf = { CRYPTO_BLF_CBC, "Blowfish", - BLOWFISH_BLOCK_LEN, 5, 56 /* 448 bits, max key */, + BLOWFISH_BLOCK_LEN, BLOWFISH_BLOCK_LEN, BLOWFISH_MIN_KEY, + BLOWFISH_MAX_KEY, blf_encrypt, blf_decrypt, blf_setkey, blf_zerokey, - NULL + NULL, }; struct enc_xform enc_xform_cast5 = { CRYPTO_CAST_CBC, "CAST-128", - CAST128_BLOCK_LEN, 5, 16, + CAST128_BLOCK_LEN, CAST128_BLOCK_LEN, CAST_MIN_KEY, CAST_MAX_KEY, cast5_encrypt, cast5_decrypt, cast5_setkey, cast5_zerokey, - NULL + NULL, }; struct enc_xform enc_xform_skipjack = { CRYPTO_SKIPJACK_CBC, "Skipjack", - SKIPJACK_BLOCK_LEN, 10, 10, + SKIPJACK_BLOCK_LEN, SKIPJACK_BLOCK_LEN, SKIPJACK_MIN_KEY, + SKIPJACK_MAX_KEY, skipjack_encrypt, - skipjack_decrypt, - skipjack_setkey, + skipjack_decrypt, skipjack_setkey, skipjack_zerokey, - NULL + NULL, }; struct enc_xform enc_xform_rijndael128 = { CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES", - RIJNDAEL128_BLOCK_LEN, 8, 32, + RIJNDAEL128_BLOCK_LEN, RIJNDAEL128_BLOCK_LEN, RIJNDAEL_MIN_KEY, + RIJNDAEL_MAX_KEY, rijndael128_encrypt, rijndael128_decrypt, rijndael128_setkey, rijndael128_zerokey, - NULL + NULL, +}; + +struct enc_xform enc_xform_aes_icm = { + CRYPTO_AES_ICM, "AES-ICM", + AES_BLOCK_LEN, AES_BLOCK_LEN, AES_MIN_KEY, AES_MAX_KEY, + aes_icm_crypt, + aes_icm_crypt, + aes_icm_setkey, + rijndael128_zerokey, + aes_icm_reinit, +}; + +struct enc_xform enc_xform_aes_nist_gcm = { + CRYPTO_AES_NIST_GCM_16, "AES-GCM", + AES_ICM_BLOCK_LEN, AES_GCM_IV_LEN, AES_MIN_KEY, AES_MAX_KEY, + aes_icm_crypt, + aes_icm_crypt, + aes_icm_setkey, + aes_icm_zerokey, + aes_gcm_reinit, +}; + +struct enc_xform enc_xform_aes_nist_gmac = { + CRYPTO_AES_NIST_GMAC, "AES-GMAC", + AES_ICM_BLOCK_LEN, AES_GCM_IV_LEN, AES_MIN_KEY, AES_MAX_KEY, + NULL, + NULL, + NULL, + NULL, + NULL, }; struct enc_xform enc_xform_aes_xts = { CRYPTO_AES_XTS, "AES-XTS", - RIJNDAEL128_BLOCK_LEN, 32, 64, + AES_BLOCK_LEN, AES_XTS_IV_LEN, AES_XTS_MIN_KEY, AES_XTS_MAX_KEY, aes_xts_encrypt, aes_xts_decrypt, aes_xts_setkey, @@ -212,85 +267,123 @@ struct enc_xform enc_xform_aes_xts = { struct enc_xform enc_xform_arc4 = { CRYPTO_ARC4, "ARC4", - 1, 1, 32, + ARC4_BLOCK_LEN, ARC4_IV_LEN, ARC4_MIN_KEY, ARC4_MAX_KEY, + NULL, NULL, NULL, NULL, NULL, - NULL }; struct enc_xform enc_xform_camellia = { CRYPTO_CAMELLIA_CBC, "Camellia", - CAMELLIA_BLOCK_LEN, 8, 32, + CAMELLIA_BLOCK_LEN, CAMELLIA_BLOCK_LEN, CAMELLIA_MIN_KEY, + CAMELLIA_MAX_KEY, cml_encrypt, cml_decrypt, cml_setkey, cml_zerokey, - NULL + NULL, }; /* Authentication instances */ -struct auth_hash auth_hash_null = { +struct auth_hash auth_hash_null = { /* NB: context isn't used */ CRYPTO_NULL_HMAC, "NULL-HMAC", - 0, NULL_HASH_LEN, NULL_HMAC_BLOCK_LEN, sizeof(int), /* NB: context isn't used */ - null_init, null_update, null_final + NULL_HMAC_KEY_LEN, NULL_HASH_LEN, sizeof(int), NULL_HMAC_BLOCK_LEN, + null_init, null_reinit, null_reinit, null_update, null_final }; struct auth_hash auth_hash_hmac_md5 = { CRYPTO_MD5_HMAC, "HMAC-MD5", - 16, MD5_HASH_LEN, MD5_HMAC_BLOCK_LEN, sizeof(MD5_CTX), - (void (*) (void *)) MD5Init, MD5Update_int, + MD5_HMAC_KEY_LEN, MD5_HASH_LEN, sizeof(MD5_CTX), MD5_HMAC_BLOCK_LEN, + (void (*) (void *)) MD5Init, NULL, NULL, MD5Update_int, (void (*) (u_int8_t *, void *)) MD5Final }; struct auth_hash auth_hash_hmac_sha1 = { CRYPTO_SHA1_HMAC, "HMAC-SHA1", - 20, SHA1_HASH_LEN, SHA1_HMAC_BLOCK_LEN, sizeof(SHA1_CTX), - SHA1Init_int, SHA1Update_int, SHA1Final_int + SHA1_HMAC_KEY_LEN, SHA1_HASH_LEN, sizeof(SHA1_CTX), SHA1_HMAC_BLOCK_LEN, + SHA1Init_int, NULL, NULL, SHA1Update_int, SHA1Final_int }; struct auth_hash auth_hash_hmac_ripemd_160 = { CRYPTO_RIPEMD160_HMAC, "HMAC-RIPEMD-160", - 20, RIPEMD160_HASH_LEN, RIPEMD160_HMAC_BLOCK_LEN, sizeof(RMD160_CTX), - (void (*)(void *)) RMD160Init, RMD160Update_int, + RIPEMD160_HMAC_KEY_LEN, RIPEMD160_HASH_LEN, sizeof(RMD160_CTX), + RIPEMD160_HMAC_BLOCK_LEN, + (void (*)(void *)) RMD160Init, NULL, NULL, RMD160Update_int, (void (*)(u_int8_t *, void *)) RMD160Final }; struct auth_hash auth_hash_key_md5 = { CRYPTO_MD5_KPDK, "Keyed MD5", - 0, MD5_KPDK_HASH_LEN, 0, sizeof(MD5_CTX), - (void (*)(void *)) MD5Init, MD5Update_int, + NULL_HMAC_KEY_LEN, MD5_KPDK_HASH_LEN, sizeof(MD5_CTX), 0, + (void (*)(void *)) MD5Init, NULL, NULL, MD5Update_int, (void (*)(u_int8_t *, void *)) MD5Final }; struct auth_hash auth_hash_key_sha1 = { CRYPTO_SHA1_KPDK, "Keyed SHA1", - 0, SHA1_KPDK_HASH_LEN, 0, sizeof(SHA1_CTX), - SHA1Init_int, SHA1Update_int, SHA1Final_int + NULL_HMAC_KEY_LEN, SHA1_KPDK_HASH_LEN, sizeof(SHA1_CTX), 0, + SHA1Init_int, NULL, NULL, SHA1Update_int, SHA1Final_int }; struct auth_hash auth_hash_hmac_sha2_256 = { CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256", - 32, SHA2_256_HASH_LEN, SHA2_256_HMAC_BLOCK_LEN, sizeof(SHA256_CTX), - (void (*)(void *)) SHA256_Init, SHA256Update_int, + SHA2_256_HMAC_KEY_LEN, SHA2_256_HASH_LEN, sizeof(SHA256_CTX), + SHA2_256_HMAC_BLOCK_LEN, + (void (*)(void *)) SHA256_Init, NULL, NULL, SHA256Update_int, (void (*)(u_int8_t *, void *)) SHA256_Final }; struct auth_hash auth_hash_hmac_sha2_384 = { CRYPTO_SHA2_384_HMAC, "HMAC-SHA2-384", - 48, SHA2_384_HASH_LEN, SHA2_384_HMAC_BLOCK_LEN, sizeof(SHA384_CTX), - (void (*)(void *)) SHA384_Init, SHA384Update_int, + SHA2_384_HMAC_KEY_LEN, SHA2_384_HASH_LEN, sizeof(SHA384_CTX), + SHA2_384_HMAC_BLOCK_LEN, + (void (*)(void *)) SHA384_Init, NULL, NULL, SHA384Update_int, (void (*)(u_int8_t *, void *)) SHA384_Final }; struct auth_hash auth_hash_hmac_sha2_512 = { CRYPTO_SHA2_512_HMAC, "HMAC-SHA2-512", - 64, SHA2_512_HASH_LEN, SHA2_512_HMAC_BLOCK_LEN, sizeof(SHA512_CTX), - (void (*)(void *)) SHA512_Init, SHA512Update_int, + SHA2_512_HMAC_KEY_LEN, SHA2_512_HASH_LEN, sizeof(SHA512_CTX), + SHA2_512_HMAC_BLOCK_LEN, + (void (*)(void *)) SHA512_Init, NULL, NULL, SHA512Update_int, (void (*)(u_int8_t *, void *)) SHA512_Final }; +struct auth_hash auth_hash_nist_gmac_aes_128 = { + CRYPTO_AES_128_NIST_GMAC, "GMAC-AES-128", + AES_128_GMAC_KEY_LEN, AES_GMAC_HASH_LEN, sizeof(struct aes_gmac_ctx), + GMAC_BLOCK_LEN, + (void (*)(void *)) AES_GMAC_Init, + (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, + (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, + (int (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Update, + (void (*)(u_int8_t *, void *)) AES_GMAC_Final +}; + +struct auth_hash auth_hash_nist_gmac_aes_192 = { + CRYPTO_AES_192_NIST_GMAC, "GMAC-AES-192", + AES_192_GMAC_KEY_LEN, AES_GMAC_HASH_LEN, sizeof(struct aes_gmac_ctx), + GMAC_BLOCK_LEN, + (void (*)(void *)) AES_GMAC_Init, + (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, + (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, + (int (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Update, + (void (*)(u_int8_t *, void *)) AES_GMAC_Final +}; + +struct auth_hash auth_hash_nist_gmac_aes_256 = { + CRYPTO_AES_256_NIST_GMAC, "GMAC-AES-256", + AES_256_GMAC_KEY_LEN, AES_GMAC_HASH_LEN, sizeof(struct aes_gmac_ctx), + GMAC_BLOCK_LEN, + (void (*)(void *)) AES_GMAC_Init, + (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, + (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, + (int (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Update, + (void (*)(u_int8_t *, void *)) AES_GMAC_Final +}; + /* Compression instance */ struct comp_algo comp_algo_deflate = { CRYPTO_DEFLATE_COMP, "Deflate", @@ -579,6 +672,75 @@ rijndael128_zerokey(u_int8_t **sched) *sched = NULL; } +void +aes_icm_reinit(caddr_t key, u_int8_t *iv) +{ + struct aes_icm_ctx *ctx; + + ctx = (struct aes_icm_ctx *)key; + bcopy(iv, ctx->ac_block, AESICM_BLOCKSIZE); +} + +void +aes_gcm_reinit(caddr_t key, u_int8_t *iv) +{ + struct aes_icm_ctx *ctx; + + aes_icm_reinit(key, iv); + + ctx = (struct aes_icm_ctx *)key; + /* GCM starts with 2 as counter 1 is used for final xor of tag. */ + bzero(&ctx->ac_block[AESICM_BLOCKSIZE - 4], 4); + ctx->ac_block[AESICM_BLOCKSIZE - 1] = 2; +} + +void +aes_icm_crypt(caddr_t key, u_int8_t *data) +{ + struct aes_icm_ctx *ctx; + u_int8_t keystream[AESICM_BLOCKSIZE]; + int i; + + ctx = (struct aes_icm_ctx *)key; + rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, ctx->ac_block, keystream); + for (i = 0; i < AESICM_BLOCKSIZE; i++) + data[i] ^= keystream[i]; + explicit_bzero(keystream, sizeof(keystream)); + + /* increment counter */ + for (i = AESICM_BLOCKSIZE - 1; + i >= 0; i--) + if (++ctx->ac_block[i]) /* continue on overflow */ + break; +} + +int +aes_icm_setkey(u_int8_t **sched, u_int8_t *key, int len) +{ + struct aes_icm_ctx *ctx; + + if (len != 16 && len != 24 && len != 32) + return EINVAL; + + *sched = malloc(sizeof(struct aes_icm_ctx), M_CRYPTO_DATA, + M_NOWAIT | M_ZERO); + if (*sched == NULL) + return ENOMEM; + + ctx = (struct aes_icm_ctx *)*sched; + ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key, len * 8); + return 0; +} + +void +aes_icm_zerokey(u_int8_t **sched) +{ + + bzero(*sched, sizeof(struct aes_icm_ctx)); + free(*sched, M_CRYPTO_DATA); + *sched = NULL; +} + #define AES_XTS_BLOCKSIZE 16 #define AES_XTS_IVSIZE 8 #define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ @@ -728,8 +890,13 @@ null_init(void *ctx) { } +static void +null_reinit(void *ctx, const u_int8_t *buf, u_int16_t len) +{ +} + static int -null_update(void *ctx, u_int8_t *buf, u_int16_t len) +null_update(void *ctx, const u_int8_t *buf, u_int16_t len) { return 0; } @@ -742,14 +909,14 @@ null_final(u_int8_t *buf, void *ctx) } static int -RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len) +RMD160Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) { RMD160Update(ctx, buf, len); return 0; } static int -MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len) +MD5Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) { MD5Update(ctx, buf, len); return 0; @@ -762,7 +929,7 @@ SHA1Init_int(void *ctx) } static int -SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len) +SHA1Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) { SHA1Update(ctx, buf, len); return 0; @@ -775,21 +942,21 @@ SHA1Final_int(u_int8_t *blk, void *ctx) } static int -SHA256Update_int(void *ctx, u_int8_t *buf, u_int16_t len) +SHA256Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) { SHA256_Update(ctx, buf, len); return 0; } static int -SHA384Update_int(void *ctx, u_int8_t *buf, u_int16_t len) +SHA384Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) { SHA384_Update(ctx, buf, len); return 0; } static int -SHA512Update_int(void *ctx, u_int8_t *buf, u_int16_t len) +SHA512Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) { SHA512_Update(ctx, buf, len); return 0; diff --git a/sys/opencrypto/xform.h b/sys/opencrypto/xform.h index 8df7b07..e0b6397 100644 --- a/sys/opencrypto/xform.h +++ b/sys/opencrypto/xform.h @@ -9,6 +9,12 @@ * supported the development of this code. * * Copyright (c) 2000 Angelos D. Keromytis + * Copyright (c) 2014 The FreeBSD Foundation + * All rights reserved. + * + * Portions of this software were developed by John-Mark Gurney + * under sponsorship of the FreeBSD Foundation and + * Rubicon Communications, LLC (Netgate). * * Permission to use, copy, and modify this software without fee * is hereby granted, provided that this entire notice is included in @@ -29,6 +35,7 @@ #include <crypto/sha1.h> #include <crypto/sha2/sha2.h> #include <opencrypto/rmd160.h> +#include <opencrypto/gmac.h> /* Declarations */ struct auth_hash { @@ -36,10 +43,12 @@ struct auth_hash { char *name; u_int16_t keysize; u_int16_t hashsize; - u_int16_t blocksize; u_int16_t ctxsize; + u_int16_t blocksize; void (*Init) (void *); - int (*Update) (void *, u_int8_t *, u_int16_t); + void (*Setkey) (void *, const u_int8_t *, u_int16_t); + void (*Reinit) (void *, const u_int8_t *, u_int16_t); + int (*Update) (void *, const u_int8_t *, u_int16_t); void (*Final) (u_int8_t *, void *); }; @@ -50,6 +59,7 @@ struct enc_xform { int type; char *name; u_int16_t blocksize; + u_int16_t ivsize; u_int16_t minkey, maxkey; void (*encrypt) (caddr_t, u_int8_t *); void (*decrypt) (caddr_t, u_int8_t *); @@ -73,6 +83,7 @@ union authctx { SHA256_CTX sha256ctx; SHA384_CTX sha384ctx; SHA512_CTX sha512ctx; + struct aes_gmac_ctx aes_gmac_ctx; }; extern struct enc_xform enc_xform_null; @@ -82,6 +93,9 @@ extern struct enc_xform enc_xform_blf; extern struct enc_xform enc_xform_cast5; extern struct enc_xform enc_xform_skipjack; extern struct enc_xform enc_xform_rijndael128; +extern struct enc_xform enc_xform_aes_icm; +extern struct enc_xform enc_xform_aes_nist_gcm; +extern struct enc_xform enc_xform_aes_nist_gmac; extern struct enc_xform enc_xform_aes_xts; extern struct enc_xform enc_xform_arc4; extern struct enc_xform enc_xform_camellia; @@ -95,6 +109,9 @@ extern struct auth_hash auth_hash_hmac_ripemd_160; extern struct auth_hash auth_hash_hmac_sha2_256; extern struct auth_hash auth_hash_hmac_sha2_384; extern struct auth_hash auth_hash_hmac_sha2_512; +extern struct auth_hash auth_hash_nist_gmac_aes_128; +extern struct auth_hash auth_hash_nist_gmac_aes_192; +extern struct auth_hash auth_hash_nist_gmac_aes_256; extern struct comp_algo comp_algo_deflate; diff --git a/sys/sys/libkern.h b/sys/sys/libkern.h index 0294537..5faebb1 100644 --- a/sys/sys/libkern.h +++ b/sys/sys/libkern.h @@ -80,6 +80,7 @@ struct malloc_type; uint32_t arc4random(void); void arc4rand(void *ptr, u_int len, int reseed); int bcmp(const void *, const void *, size_t); +int timingsafe_bcmp(const void *, const void *, size_t); void *bsearch(const void *, const void *, size_t, size_t, int (*)(const void *, const void *)); #ifndef HAVE_INLINE_FFS diff --git a/sys/sys/priv.h b/sys/sys/priv.h index 78a8e3e..7347149 100644 --- a/sys/sys/priv.h +++ b/sys/sys/priv.h @@ -341,6 +341,7 @@ #define PRIV_NET_SETIFDESCR 418 /* Set interface description. */ #define PRIV_NET_SETIFFIB 419 /* Set interface fib. */ #define PRIV_NET_VXLAN 420 /* Administer vxlan. */ +#define PRIV_NET_SETVLANPCP 421 /* Set VLAN priority. */ /* * 802.11-related privileges. diff --git a/sys/sys/sockio.h b/sys/sys/sockio.h index e76720f..0ad221b 100644 --- a/sys/sys/sockio.h +++ b/sys/sys/sockio.h @@ -132,5 +132,6 @@ #define SIOCDIFGROUP _IOW('i', 137, struct ifgroupreq) /* delete ifgroup */ #define SIOCGIFGMEMB _IOWR('i', 138, struct ifgroupreq) /* get members */ #define SIOCGIFXMEDIA _IOWR('i', 139, struct ifmediareq) /* get net xmedia */ +#define SIOCORDERIFADDR _IOWR('i', 160, struct ifaliasreq) /* reorder interface */ #endif /* !_SYS_SOCKIO_H_ */ diff --git a/sys/sys/systm.h b/sys/sys/systm.h index cb83ba4..83e4f12 100644 --- a/sys/sys/systm.h +++ b/sys/sys/systm.h @@ -238,6 +238,7 @@ void hexdump(const void *ptr, int length, const char *hdr, int flags); #define ovbcopy(f, t, l) bcopy((f), (t), (l)) void bcopy(const void *from, void *to, size_t len) __nonnull(1) __nonnull(2); void bzero(void *buf, size_t len) __nonnull(1); +void explicit_bzero(void *, size_t) __nonnull(1);; void *memcpy(void *to, const void *from, size_t len) __nonnull(1) __nonnull(2); void *memmove(void *dest, const void *src, size_t n) __nonnull(1) __nonnull(2); |
